diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..3fc4c73e2
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,6 @@
+# Shell scripts are executed and inspected verbatim on every CI host.
+*.sh text eol=lf
+# Original Go test drivers and embedded ASM/C retain byte-exact hash guards.
+*.go text eol=lf
+# Tracked ASM conformance sources retain their original whole-program hashes.
+*.s text eol=lf
diff --git a/.github/actions/publish-windows-llvm22/action.yml b/.github/actions/publish-windows-llvm22/action.yml
new file mode 100644
index 000000000..61a524d00
--- /dev/null
+++ b/.github/actions/publish-windows-llvm22/action.yml
@@ -0,0 +1,9 @@
+name: Publish Windows LLVM 22
+description: Validate and publish one installed LLVM prefix without retry-dependent paths.
+inputs:
+  attempt:
+    description: The successful setup-msys2 attempt (1, 2, or 3).
+    required: true
+runs:
+  using: node24
+  main: index.cjs
diff --git a/.github/actions/publish-windows-llvm22/index.cjs b/.github/actions/publish-windows-llvm22/index.cjs
new file mode 100644
index 000000000..b24b99f94
--- /dev/null
+++ b/.github/actions/publish-windows-llvm22/index.cjs
@@ -0,0 +1,157 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {execFileSync} = require('node:child_process');
+
+function requireThat(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function absent(file) {
+  try { fs.lstatSync(file); } catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  throw new Error('publication target already exists: ' + file);
+}
+
+function directory(file) {
+  const stat = fs.lstatSync(file);
+  requireThat(stat.isDirectory() && !stat.isSymbolicLink(), 'not an owned directory: ' + file);
+  return stat;
+}
+
+function noLinks(file) {
+  const stat = fs.lstatSync(file);
+  requireThat(!stat.isSymbolicLink() && (stat.isFile() || stat.isDirectory()),
+    'redirected or unsupported prefix entry: ' + file);
+  if (stat.isDirectory()) {
+    for (const name of fs.readdirSync(file)) noLinks(path.join(file, name));
+  }
+}
+
+function publishPrefix({runnerTemp, attempt, systemRoot, run}) {
+  requireThat(typeof attempt === 'string' && /^[123]$/.test(attempt), 'unknown successful bootstrap attempt');
+  for (const value of [runnerTemp, systemRoot]) {
+    requireThat(typeof value === 'string' && path.isAbsolute(value) &&
+      path.normalize(value) === value && !/[\x00-\x1f]/.test(value), 'invalid absolute system path');
+  }
+  for (let ancestor = runnerTemp; ; ancestor = path.dirname(ancestor)) {
+    directory(ancestor);
+    if (ancestor === path.dirname(ancestor)) break;
+  }
+  const source = path.join(runnerTemp, 'plan9asm-msys2-attempt-' + attempt, 'msys64', 'clang64');
+  const target = path.join(runnerTemp, 'plan9asm-llvm22');
+  const proof = path.join(runnerTemp, 'plan9asm-llvm22-proof');
+  directory(path.dirname(path.dirname(source)));
+  directory(path.dirname(source));
+  const original = directory(source);
+  absent(target);
+  absent(proof);
+  noLinks(source);
+  for (const relative of ['bin/llvm-config.exe', 'bin/clang.exe', 'bin/clang++.exe',
+    'include/_mingw.h', 'lib/libkernel32.a']) {
+    requireThat(fs.lstatSync(path.join(source, relative)).isFile(), 'missing prefix input: ' + relative);
+  }
+
+  // lstat covers symlinks/junctions; Windows attributes also reject other
+  // reparse tags. Inspect before descending and never follow a redirected node.
+  const checkReparse = `
+$ErrorActionPreference = 'Stop'
+$root = Get-Item -Force -LiteralPath $env:PLAN9ASM_LLVM22_CHECK
+for ($item = $root; $null -ne $item; $item = $item.Parent) {
+  if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'reparse ancestor' }
+}
+$pending = [Collections.Generic.Stack[IO.FileSystemInfo]]::new()
+$pending.Push($root)
+while ($pending.Count) {
+  $item = $pending.Pop()
+  if ($item.Attributes -band [IO.FileAttributes]::ReparsePoint) { throw 'reparse prefix entry' }
+  if ($item -is [IO.DirectoryInfo]) {
+    foreach ($child in $item.GetFileSystemInfos()) { $pending.Push($child) }
+  }
+}`;
+  run(path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', checkReparse],
+    {env: {...process.env, PLAN9ASM_LLVM22_CHECK: source}});
+  const checked = directory(source);
+  requireThat(original.dev === checked.dev && original.ino === checked.ino, 'prefix replaced during validation');
+  for (let ancestor = path.dirname(source); ; ancestor = path.dirname(ancestor)) {
+    directory(ancestor);
+    if (ancestor === path.dirname(ancestor)) break;
+  }
+  noLinks(source);
+  absent(target);
+  // Windows directory rename is same-volume and cannot replace an existing
+  // file/directory. Do not copy, merge, remove failed attempts, or retry a move.
+  fs.renameSync(source, target);
+  const moved = directory(target);
+  requireThat(original.dev === moved.dev && original.ino === moved.ino, 'published prefix identity changed');
+
+  const bin = path.join(target, 'bin');
+  // No bootstrap PATH: the relocation probe must resolve its DLLs, linker,
+  // headers and runtime from the moved prefix, not a retained old installation.
+  const env = {...process.env, PATH: [bin, path.join(systemRoot, 'System32'), systemRoot].join(path.delimiter)};
+  if (process.platform === 'win32') {
+    for (const name of Object.keys(env)) if (name.toUpperCase() === 'PATH' && name !== 'PATH') delete env[name];
+  }
+  const query = (file, args) => {
+    const result = run(file, args, {env});
+    requireThat(typeof result === 'string' && !result.includes('\0'), 'invalid tool output');
+    return result;
+  };
+  const config = path.join(bin, 'llvm-config.exe');
+  const clang = path.join(bin, 'clang.exe');
+  const line = value => {
+    requireThat(/^[^\r\n]+\r?\n?$/.test(value), 'expected one tool output line');
+    return value.replace(/\r?\n$/, '');
+  };
+  const samePath = (value, expected) => path.normalize(line(value).replace(/[\\/]/g, path.sep)) === expected;
+  requireThat(line(query(config, ['--version'])) === '22.1.8', 'expected LLVM 22.1.8');
+  for (const [flag, relative] of [['--prefix', ''], ['--bindir', 'bin'], ['--includedir', 'include'], ['--libdir', 'lib']]) {
+    requireThat(samePath(query(config, [flag]), path.join(target, relative)), 'LLVM prefix did not relocate: ' + flag);
+  }
+  requireThat(/^clang version 22\.1\.8(?:\s|$)/.test(query(clang, ['--version'])), 'expected Clang 22.1.8');
+  const resources = path.join(target, 'lib', 'clang', '22');
+  requireThat(samePath(query(clang, ['--print-resource-dir']), resources), 'Clang resources did not relocate');
+  directory(resources);
+  const flags = args => {
+    const value = query(config, args).replace(/\r/g, '').replace(/\n/g, ' ').trim();
+    requireThat(value.length > 0 && !/[\x00-\x1f]/.test(value) &&
+      !/plan9asm-msys2-attempt-/i.test(value), 'invalid or attempt-dependent LLVM flags');
+    return value;
+  };
+  const environment = {
+    CGO_CFLAGS: flags(['--cflags']),
+    CGO_CXXFLAGS: flags(['--cxxflags']),
+    CGO_LDFLAGS: flags(['--ldflags', '--libs', 'all', '--system-libs']),
+    LLVM_CONFIG: config, CC: clang, CXX: path.join(bin, 'clang++.exe'),
+    CGO_ENABLED: '1', GOFLAGS: '-tags=byollvm',
+  };
+  fs.mkdirSync(proof); // Exclusive, retained on failure; never overwrite a probe.
+  const input = path.join(proof, 'publication.c');
+  const output = path.join(proof, 'publication.exe');
+  fs.writeFileSync(input, '#include <stdint.h>\nint main(void) { return sizeof(uintptr_t) == 8 ? 0 : 1; }\n', {flag: 'wx'});
+  query(clang, [input, '-o', output]);
+  requireThat(fs.lstatSync(output).isFile(), 'compiler did not produce the native probe');
+  query(output, []);
+  return {environment, path: bin};
+}
+
+module.exports = {publishPrefix};
+if (require.main === module) {
+  try {
+    requireThat(process.platform === 'win32', 'Windows LLVM publication requires Windows');
+    const result = publishPrefix({runnerTemp: process.env.RUNNER_TEMP, attempt: process.env.INPUT_ATTEMPT,
+      systemRoot: process.env.SystemRoot || process.env.SYSTEMROOT,
+      run: (file, args, options) => execFileSync(file, args,
+        {...options, encoding: 'utf8', timeout: 120000, maxBuffer: 1024 * 1024, windowsHide: true})});
+    fs.appendFileSync(process.env.GITHUB_ENV, Object.entries(result.environment).map(([key, value]) => `${key}=${value}\n`).join(''));
+    fs.appendFileSync(process.env.GITHUB_PATH, result.path + '\n');
+    console.log('Published and executed LLVM 22.1.8 from ' + result.path);
+  } catch (error) {
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  }
+}
diff --git a/.github/actions/setup-go/action.yml b/.github/actions/setup-go/action.yml
index e46e57771..dfde4216a 100644
--- a/.github/actions/setup-go/action.yml
+++ b/.github/actions/setup-go/action.yml
@@ -3,12 +3,8 @@ description: Set up Go with writable caches on hosted and self-hosted runners
 
 inputs:
   go-version:
-    description: Go version accepted by actions/setup-go
+    description: Exact stable Go version or a registered compatibility label
     required: true
-  cache:
-    description: Whether actions/setup-go should cache dependencies
-    required: false
-    default: "true"
 
 runs:
   using: composite
@@ -21,8 +17,84 @@ runs:
         echo "GOMODCACHE=${RUNNER_TEMP}/go/pkg/mod" >> "$GITHUB_ENV"
         echo "GOCACHE=${RUNNER_TEMP}/go-build-cache" >> "$GITHUB_ENV"
 
+    # Compatibility labels are stable job identities. Freeze their actual SDKs
+    # in source so different runner caches or a mid-run release cannot split
+    # one group across compiler/source versions. Update these pins explicitly
+    # from https://go.dev/dl/?mode=json&include=all.
+    - name: Resolve exact Go version
+      id: resolve_go
+      shell: bash
+      env:
+        REQUESTED_GO_VERSION: ${{ inputs.go-version }}
+      run: |
+        set -euo pipefail
+
+        case "$REQUESTED_GO_VERSION" in
+          1.20.x) resolved_go=1.20.14 ;;
+          1.21.x) resolved_go=1.21.13 ;;
+          1.22.x) resolved_go=1.22.12 ;;
+          1.23.x) resolved_go=1.23.12 ;;
+          1.24.x) resolved_go=1.24.13 ;;
+          1.25.x) resolved_go=1.25.14 ;;
+          1.26.x) resolved_go=1.26.10 ;;
+          1.27.x) resolved_go=1.27.3 ;;
+          *)
+            if [[ ! "$REQUESTED_GO_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+              echo "Go selector has no frozen exact SDK: $REQUESTED_GO_VERSION" >&2
+              exit 1
+            fi
+            resolved_go="$REQUESTED_GO_VERSION"
+            ;;
+        esac
+        printf 'go-version=%s\n' "$resolved_go" >> "$GITHUB_OUTPUT"
+
     - name: Set up Go
+      id: install_go
       uses: actions/setup-go@v7
       with:
-        go-version: ${{ inputs.go-version }}
-        cache: ${{ inputs.cache }}
+        go-version: ${{ steps.resolve_go.outputs.go-version }}
+        # Account cache egress exhaustion must not block compiler installation.
+        # The writable job-local Go caches above remain available.
+        cache: false
+
+    # Some self-hosted runner interruptions report a successful action before
+    # its download completes. Neither that outcome nor an ambient Go is proof
+    # that the requested compiler was installed.
+    - name: Verify Go installation
+      shell: bash
+      env:
+        REQUESTED_GO_VERSION: ${{ inputs.go-version }}
+        RESOLVED_GO_VERSION: ${{ steps.resolve_go.outputs.go-version }}
+        INSTALLED_GO_VERSION: ${{ steps.install_go.outputs.go-version }}
+      run: |
+        set -euo pipefail
+
+        if [[ ! "$INSTALLED_GO_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+          echo "Go installer did not report a complete stable version" >&2
+          exit 1
+        fi
+
+        if [[ ! "$RESOLVED_GO_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ||
+              "$INSTALLED_GO_VERSION" != "$RESOLVED_GO_VERSION" ]]; then
+          echo "Resolved Go $RESOLVED_GO_VERSION, installed $INSTALLED_GO_VERSION" >&2
+          exit 1
+        fi
+
+        if [[ "$REQUESTED_GO_VERSION" =~ ^[0-9]+\.[0-9]+\.x$ ]]; then
+          minor="${REQUESTED_GO_VERSION%.x}"
+          if [[ "$INSTALLED_GO_VERSION" != "$minor."* ]]; then
+            echo "Requested Go $REQUESTED_GO_VERSION, installed $INSTALLED_GO_VERSION" >&2
+            exit 1
+          fi
+        elif [[ "$REQUESTED_GO_VERSION" != "$INSTALLED_GO_VERSION" ]]; then
+          echo "Requested Go $REQUESTED_GO_VERSION, installed $INSTALLED_GO_VERSION" >&2
+          exit 1
+        fi
+
+        actual="$(GOTOOLCHAIN=local go env GOVERSION)"
+        if [[ "$actual" != "go$INSTALLED_GO_VERSION" ]]; then
+          echo "Installed Go $INSTALLED_GO_VERSION, but PATH selects $actual" >&2
+          exit 1
+        fi
+        printf 'Verified Go %s: %s\n' "$INSTALLED_GO_VERSION" "$(command -v go)"
+        GOTOOLCHAIN=local go version
diff --git a/.github/actions/setup-node22/action.yml b/.github/actions/setup-node22/action.yml
new file mode 100644
index 000000000..c32dc0b0a
--- /dev/null
+++ b/.github/actions/setup-node22/action.yml
@@ -0,0 +1,34 @@
+name: Setup Node.js 22
+description: Install the exact Node.js runtime shared by CI producers and verifiers
+
+runs:
+  using: composite
+  steps:
+    - name: Install Node.js 22
+      id: install_node22
+      uses: actions/setup-node@v6
+      with:
+        node-version: '22.23.4'
+
+    # An installer step marked successful without its output must not borrow
+    # the runner image's ambient Node or produce an incompatible WASM scope.
+    - name: Verify Node.js installation
+      shell: bash
+      env:
+        EXPECTED_NODE_VERSION: 'v22.23.4'
+        INSTALLED_NODE_VERSION: ${{ steps.install_node22.outputs.node-version }}
+      run: |
+        set -euo pipefail
+
+        if [[ "$INSTALLED_NODE_VERSION" != "$EXPECTED_NODE_VERSION" ]]; then
+          echo "Expected Node $EXPECTED_NODE_VERSION, installer reported '$INSTALLED_NODE_VERSION'" >&2
+          exit 1
+        fi
+
+        actual="$(node --version)"
+        actual="${actual%$'\r'}"
+        if [[ "$actual" != "$EXPECTED_NODE_VERSION" ]]; then
+          echo "Installed Node $INSTALLED_NODE_VERSION, but PATH selects '$actual'" >&2
+          exit 1
+        fi
+        printf 'Verified Node %s: %s\n' "$actual" "$(command -v node)"
diff --git a/.github/actions/setup-windows-llvm22/action.yml b/.github/actions/setup-windows-llvm22/action.yml
index 6134a7f85..01ea699a9 100644
--- a/.github/actions/setup-windows-llvm22/action.yml
+++ b/.github/actions/setup-windows-llvm22/action.yml
@@ -5,10 +5,42 @@ runs:
   using: composite
   steps:
     - name: Set up MSYS2 for LLVM 22
+      id: msys2_attempt_1
+      continue-on-error: true
       uses: msys2/setup-msys2@v2
       with:
         msystem: CLANG64
         path-type: inherit
+        release: true
+        location: ${{ runner.temp }}/plan9asm-msys2-attempt-1
+        update: true
+
+    # These are bounded installer retries, not test retries or LLVM fallbacks.
+    # Only the first two bootstrap failures may proceed to another attempt.
+    # setup-msys2 refuses an existing installation, including a failed update's
+    # directory. Keep each fresh attempt separate; the action rewrites its
+    # msys2 shell wrapper to the successful installation without deleting any.
+    - name: Retry MSYS2 bootstrap (2 of 3)
+      id: msys2_attempt_2
+      if: ${{ steps.msys2_attempt_1.outcome == 'failure' }}
+      continue-on-error: true
+      uses: msys2/setup-msys2@v2
+      with:
+        msystem: CLANG64
+        path-type: inherit
+        release: true
+        location: ${{ runner.temp }}/plan9asm-msys2-attempt-2
+        update: true
+
+    - name: Retry MSYS2 bootstrap (3 of 3, failure is fatal)
+      id: msys2_attempt_3
+      if: ${{ steps.msys2_attempt_1.outcome == 'failure' && steps.msys2_attempt_2.outcome == 'failure' }}
+      uses: msys2/setup-msys2@v2
+      with:
+        msystem: CLANG64
+        path-type: inherit
+        release: true
+        location: ${{ runner.temp }}/plan9asm-msys2-attempt-3
         update: true
 
     - name: Install LLVM 22
@@ -39,27 +71,31 @@ runs:
 
         # libc++ supplies the compiler runtime. Keep the exact LLVM component
         # set mutually consistent while acknowledging the cc-libs virtual.
-        pacman --noconfirm -U \
-          --assume-installed "$prefix-cc-libs=$LLVM_VERSION" \
-          "${urls[@]}"
+        install_status=1
+        for attempt in 1 2 3; do
+          if pacman --noconfirm -U \
+            --assume-installed "$prefix-cc-libs=$LLVM_VERSION" \
+            "${urls[@]}"; then
+            install_status=0
+            break
+          else
+            install_status=$?
+          fi
+          if (( attempt < 3 )); then
+            echo "Pinned LLVM install attempt $attempt failed ($install_status); retrying in 5 seconds" >&2
+            sleep 5
+          fi
+        done
+        if (( install_status != 0 )); then
+          exit "$install_status"
+        fi
 
         if [[ "$(llvm-config --version)" != "$LLVM_VERSION" ]]; then
           echo "expected LLVM $LLVM_VERSION, got $(llvm-config --version)" >&2
           exit 1
         fi
 
-        flatten() {
-          local value=$1
-          value="${value//$'\r'/}"
-          value="${value//$'\n'/ }"
-          printf '%s' "$value"
-        }
-        echo "CGO_CFLAGS=$(flatten "$(llvm-config --cflags)")" >> "$GITHUB_ENV"
-        echo "CGO_CXXFLAGS=$(flatten "$(llvm-config --cxxflags)")" >> "$GITHUB_ENV"
-        echo "CGO_LDFLAGS=$(flatten "$(llvm-config --ldflags --libs all --system-libs)")" >> "$GITHUB_ENV"
-        clang_bin="$(cygpath -w /clang64/bin)"
-        echo "CC=$clang_bin\\clang.exe" >> "$GITHUB_ENV"
-        echo "CXX=$clang_bin\\clang++.exe" >> "$GITHUB_ENV"
-        echo 'CGO_ENABLED=1' >> "$GITHUB_ENV"
-        echo 'GOFLAGS=-tags=byollvm' >> "$GITHUB_ENV"
-        echo "$clang_bin" >> "$GITHUB_PATH"
+    - name: Publish stable LLVM 22 prefix
+      uses: ./.github/actions/publish-windows-llvm22
+      with:
+        attempt: ${{ steps.msys2_attempt_1.outcome == 'success' && '1' || steps.msys2_attempt_2.outcome == 'success' && '2' || steps.msys2_attempt_3.outcome == 'success' && '3' || '' }}
diff --git a/.github/scripts/audit-arm64-fallback.cjs b/.github/scripts/audit-arm64-fallback.cjs
new file mode 100644
index 000000000..95a0d9dea
--- /dev/null
+++ b/.github/scripts/audit-arm64-fallback.cjs
@@ -0,0 +1,46 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+
+// The exhaustive runner separately verifies the complete source, tools, plan,
+// commands and raw event protocol. This additional contract prevents removal
+// of an execution child from silently shrinking this required runtime matrix.
+function auditARM64Fallback(raw) {
+  const root = 'TestFallbackARM64WideFrameCompilesWithLLVM22';
+  const expected = [root, ...['darwin', 'linux', 'windows', 'native_complete-argument_oracle']
+    .map(child => `${root}/${child}`)].sort();
+  const started = new Set();
+  const passed = new Set();
+  let packagePassed = false;
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event.Action === 'build-output' && typeof event.ImportPath === 'string' && event.ImportPath && !event.Test) {
+      continue;
+    }
+    assert.equal(event.Package, 'github.com/xgo-dev/plan9asm/cmd/plan9asmll');
+    assert.ok(!packagePassed, 'event after package terminal');
+    assert.ok(!['fail', 'skip', 'build-fail'].includes(event.Action), 'required execution did not pass');
+    if (event.Action === 'run') {
+      assert.ok(expected.includes(event.Test) && !started.has(event.Test), 'foreign or duplicate test');
+      started.add(event.Test);
+    }
+    if (event.Action === 'pass') {
+      if (event.Test) {
+        assert.ok(started.has(event.Test) && !passed.has(event.Test), 'unstarted or duplicate terminal');
+        passed.add(event.Test);
+      } else {
+        packagePassed = true;
+      }
+    }
+  }
+  assert.ok(packagePassed, 'package did not finish');
+  assert.deepEqual([...started].sort(), expected, 'missing required execution axis');
+  assert.deepEqual([...passed].sort(), expected, 'incomplete required execution axis');
+  return { roots: 1, children: 4, passed: 5, skipped: 0, incomplete: 0 };
+}
+
+module.exports = { auditARM64Fallback };
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one original runner trace required');
+  process.stdout.write(JSON.stringify(auditARM64Fallback(fs.readFileSync(process.argv[2], 'utf8')), null, 2) + '\n');
+}
diff --git a/.github/scripts/audit-blend-minpos-native.cjs b/.github/scripts/audit-blend-minpos-native.cjs
new file mode 100644
index 000000000..bdb73ee02
--- /dev/null
+++ b/.github/scripts/audit-blend-minpos-native.cjs
@@ -0,0 +1,148 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaultsAMD64',
+  'TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaults386'];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+const forms = [['BLENDVPS', 'X'], ['VBLENDVPS', 'X'], ['VBLENDVPS', 'Y'],
+  ['BLENDVPD', 'X'], ['VBLENDVPD', 'X'], ['VBLENDVPD', 'Y'],
+  ['PBLENDVB', 'X'], ['VPBLENDVB', 'X'], ['VPBLENDVB', 'Y'],
+  ['PHMINPOSUW', 'X'], ['VPHMINPOSUW', 'X']];
+const parents = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+const leaves = parents.flatMap(parent => forms.flatMap(([op, bank]) => ['live', 'dead'].flatMap(role =>
+  [0, 1].map(zero => `${parent}/${op}/${bank}/${role}/maskzero=${zero}`))));
+const children = [...parents, ...leaves];
+const leafSet = new Set(leaves), parentSet = new Set(parents);
+const marker = 'blend/minimum original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0\n';
+const preflight = 'blend/minimum actual native SSE4.1=1 AVX2=1\n';
+const hostPrefix = 'IA32 direct host:', sdkPrefix = 'actual LEA source/object receipt:';
+const imagePrefix = 'native oracle static IA32 ELF';
+const host = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+const image = /native oracle static IA32 ELF bytes=[1-9][0-9]* sha256=[a-f0-9]{64}\b/g;
+
+// These 22 minimum-ISA functions and 44 live/dead/mask cases are actual
+// original-byte fault execution, not the 78-program private mathematical
+// companion or its virtual Z/Y/X alias observations.
+function auditBlendMinposNative(inventory, raw) {
+  const events = raw.split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+  // The shared owner checker closes the root/axis topology. Keep the 264
+  // fixed leaves in the stricter linear protocol below: feeding every leaf
+  // into its all-ancestors loop would make exhaustive negative audits O(n²).
+  const ancestry = events.filter(event => !leafSet.has(event.Test));
+  auditNativeOwners(inventory, ancestry.map(event => JSON.stringify(event)).join('\n'), roots, parents);
+  const outputs = new Map([...roots, ...children].map(name => [name, '']));
+  const states = new Map(), passed = new Map();
+  const spans = new Map(roots.map(root => [root, []]));
+  let started = false, complete = false, driver = '', kernelExecutions = 0;
+
+  function rootObservations(root, final) {
+    const output = outputs.get(root), arch = root.endsWith('386') ? '386' : 'amd64';
+    const capture = new RegExp('actual LEA source/object receipt: SDK=go1\\.27\\.2 target=linux/' + arch +
+      ' source=[a-f0-9]{64} driver=([a-f0-9]{64}) object=[a-f0-9]{64}\\b', 'g');
+    const captures = [...output.matchAll(capture)], hosts = [...output.matchAll(host)];
+    assert.equal(hosts.length, final ? 2 : 1, 'missing or duplicated direct native host bracket');
+    assert.equal(output.split(hostPrefix).length - 1, hosts.length, 'malformed extra native host');
+    assert.equal(captures.length, 1, 'missing unique actual Go1.27.2 source/object receipt');
+    assert.equal(output.split(sdkPrefix).length - 1, 1, 'malformed extra SDK source/object receipt');
+    if (!driver) driver = captures[0][1];
+    assert.equal(captures[0][1], driver, 'native owners used different actual Go drivers');
+    assert.equal(output.split(preflight).length - 1, 1, 'missing complete actual SSE4.1/AVX2 preflight');
+    assert.equal(output.split('blend/minimum actual native').length - 1, 1, 'malformed extra native ISA preflight');
+    assert.ok(hosts[0].index < output.indexOf(preflight) && output.indexOf(preflight) < captures[0].index,
+      'ISA/source capture escaped the actual native host bracket');
+    assert.ok(!output.includes(marker) && !output.includes(imagePrefix),
+      'root summary cannot replace actual leaf execution or axis-owned images');
+    if (final) {
+      assert.ok(captures[0].index < hosts[1].index, 'final host preceded original source capture');
+      const span = spans.get(root).filter(value => value.offset <= hosts[1].index).pop();
+      for (const axis of axes) {
+        assert.ok(passed.has(root + '/' + axis), 'native root lacks a complete optimization axis');
+        assert.ok(span && span.sequence > passed.get(root + '/' + axis), 'final host preceded an execution axis');
+      }
+    }
+  }
+
+  for (const [sequence, event] of events.entries()) {
+    assert.ok(!complete, 'event after complete blend/minimum package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    assert.equal(event.Package, 'github.com/xgo-dev/plan9asm', 'foreign native package');
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown native package lifecycle');
+      if (event.Action === 'start') {
+        assert.ok(!started, 'duplicate native package start');
+        started = true;
+      } else {
+        assert.ok(started, 'observation before native package start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string', 'nontext package output');
+        if (event.Action === 'pass') complete = true;
+      }
+      continue;
+    }
+    assert.ok(started, 'native test before package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown native test lifecycle');
+    const root = event.Test.split('/')[0];
+    if (leafSet.has(event.Test)) {
+      const parent = event.Test.split('/').slice(0, 2).join('/');
+      assert.equal(states.get(root), 'running', 'leaf outside its live root');
+      assert.equal(states.get(parent), 'running', 'leaf outside its live optimization axis');
+    }
+    if (event.Action === 'run') {
+      assert.ok(!states.has(event.Test), 'native test lifecycle restarted');
+      states.set(event.Test, 'running');
+      if (event.Test !== root) rootObservations(root, false);
+      if (leafSet.has(event.Test) && root.endsWith('386')) {
+        const parent = event.Test.split('/').slice(0, 2).join('/');
+        assert.equal([...outputs.get(parent).matchAll(image)].length, 1,
+          'IA32 leaf started before its complete static image inspection');
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'observation outside its live native owner');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string', 'nontext native output');
+      if (event.Test === root) spans.get(root).push({offset: outputs.get(root).length, sequence});
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    passed.set(event.Test, sequence);
+    if (event.Test === root) {
+      rootObservations(root, true);
+      continue;
+    }
+    const output = outputs.get(event.Test);
+    for (const foreign of [hostPrefix, sdkPrefix, 'blend/minimum actual native']) {
+      assert.ok(!output.includes(foreign), 'child cannot replace actual root host/SDK/ISA ownership');
+    }
+    if (parentSet.has(event.Test)) {
+      assert.ok(!output.includes(marker), 'axis summary cannot replace actual completed kernels');
+      const count = root.endsWith('386') ? 1 : 0;
+      assert.equal([...output.matchAll(image)].length, count, 'axis lacks its exact native static image');
+      assert.equal(output.split(imagePrefix).length - 1, count, 'malformed extra IA32 static image');
+      for (const leaf of leaves.filter(name => name.startsWith(event.Test + '/'))) {
+        assert.ok(passed.has(leaf), 'axis ended before its complete opcode/width/live/dead/mask family');
+      }
+    } else {
+      assert.ok(!output.includes(imagePrefix), 'leaf cannot replace its axis-owned IA32 image');
+      assert.equal(output.split(marker).length - 1, 1, 'leaf lacks exactly one complete original/translated 20-probe observation');
+      assert.equal(output.split('blend/minimum original Go bytes').length - 1, 1, 'malformed extra leaf completion');
+      kernelExecutions++;
+    }
+  }
+  assert.equal(passed.size, roots.length + children.length, 'incomplete actual root/axis/leaf inventory');
+  return {roots: roots.length, children: children.length, passed: passed.size, skipped: 0, incomplete: 0,
+    nativeHosts: 4, sdkCaptures: 2, isaPreflights: 2, staticIA32Images: 3,
+    kernelExecutions, pairedProbes: kernelExecutions * 20, directProbeProcesses: kernelExecutions * 40};
+}
+
+module.exports = {auditBlendMinposNative};
+if (require.main === module) {
+  const directory = process.argv[2];
+  process.stdout.write(JSON.stringify(auditBlendMinposNative(
+    fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'))) + '\n');
+}
diff --git a/.github/scripts/audit-duplicate-native-families.cjs b/.github/scripts/audit-duplicate-native-families.cjs
new file mode 100644
index 000000000..1832b2c91
--- /dev/null
+++ b/.github/scripts/audit-duplicate-native-families.cjs
@@ -0,0 +1,169 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+const {requireIA32Images, requireSDKCommands} = require('./audit-integer-native-families.cjs');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNative386',
+];
+const nativeAxes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const axes = [...nativeAxes, 'OriginalGo'];
+const children = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+const nativeHost = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+const avxPreflight = /actual guest CPUID\/XCR0 preflight: AVX=1 AVX2=[01] AVX512F=[01]\r?\n/g;
+const originalArgs = '["-test.run=^TestOriginal$" "-test.count=1" "-test.v"]';
+const originalEvidence = 'actual original Go legacy/VEX: 18 rows × 16 IEEE/bit patterns × 6 masks = 1728 whole32/FLAGS/DF/MXCSR/canary outcomes; no EVEX execution claim\n';
+
+function pipelineEvidence(arch) {
+  return `duplicate native arch=${arch} live=60 dead=30 whole64-outcomes=5760 fault-processes=712; legacy original opcode/all mod16, E4NF/E5NF independent full-span references\n`;
+}
+
+function requireExecutableRoles(output, arch, original, commands, observed) {
+  const receipts = [...output.matchAll(/actual executable=(\/[^\r\n]+?) sha256=([a-f0-9]{64}) argv=(\[[^\r\n]*\])\r?\n/g)];
+  assert.equal(receipts.length, output.split('actual executable=').length - 1,
+    'malformed actual executable receipt');
+  assert.equal(receipts.length, (original ? 2 : 0) + (arch === '386' ? 1 : 0),
+    'actual executable receipts escaped their original Go or native pipeline role');
+  if (original) {
+    assert.deepEqual(receipts.slice(0, 2).map(receipt => receipt.slice(1)),
+      commands.map(command => command.slice(1)), 'SDK commands lost their explicit OriginalGo ownership');
+  }
+  if (arch !== '386') return;
+
+  const executable = receipts[original ? 2 : 0];
+  if (original) {
+    const binary = / "-o" "([^"\r\n]+)" /.exec(commands[1][3]);
+    assert.ok(binary, 'original Go build lost its exact output executable');
+    assert.equal(executable[1], binary[1], 'original execution differs from the actual Go build output');
+  } else {
+    assert.equal(path.posix.basename(executable[1]), 'comparison',
+      'native pipeline cannot substitute original Go compilation or a foreign executable');
+  }
+  assert.equal(executable[2], observed.images[0][2], 'actual executable differs from inspected IA32 image');
+  assert.equal(executable[3], original ? originalArgs : '[]', 'actual executable arguments changed');
+  assert.ok(observed.images[0].index < executable.index && executable.index < observed.direct[0].index,
+    'actual executable escaped its inspected image/direct execution bracket');
+}
+
+// Each first-party wrapper supplies its own fixed inventory and exact program
+// completion witnesses. Reports can never choose the denominator or family.
+function auditSSEAVXNativeFamilies(inventory, raw, roots, pipelineEvidence, originalEvidence) {
+  const children = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+  const result = auditNativeOwners(inventory, raw, roots, children);
+  const outputs = new Map([...roots, ...children].map(name => [name, '']));
+  const outputSpans = new Map(roots.map(root => [root, []]));
+  const states = new Map();
+  const childPasses = new Map();
+  let packageStarted = false, packageComplete = false;
+  let nativeHosts = 0, avxPreflights = 0, sdkBuilds = 0;
+  let staticIA32Images = 0, directIA32Executions = 0;
+
+  const events = raw.split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+  for (const [sequence, event] of events.entries()) {
+    assert.ok(!packageComplete, 'event after the complete duplicate package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown duplicate package action');
+      if (event.Action === 'start') {
+        assert.ok(!packageStarted, 'duplicate native package start');
+        packageStarted = true;
+      } else {
+        assert.ok(packageStarted, 'duplicate observation before package start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string', 'package output must be text');
+        if (event.Action === 'pass') packageComplete = true;
+      }
+      continue;
+    }
+    assert.ok(packageStarted, 'duplicate test before package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown duplicate test action');
+    const root = event.Test.split('/')[0];
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    const original = event.Test === root + '/OriginalGo';
+    if (event.Action === 'run') {
+      states.set(event.Test, 'running');
+      if (event.Test !== root) {
+        const output = outputs.get(root);
+        const hosts = [...output.matchAll(nativeHost)], preflights = [...output.matchAll(avxPreflight)];
+        assert.equal(hosts.length, 1, 'duplicate axis lacks its preceding actual native host observation');
+        assert.equal(preflights.length, 1, 'duplicate axis lacks actual AVX CPUID/XCR0 permission');
+        assert.ok(hosts[0].index < preflights[0].index, 'duplicate AVX preflight preceded native host identity');
+        assert.ok(!output.includes('actual executable='), 'original Go receipts must belong to its explicit child');
+        if (original) {
+          for (const axis of nativeAxes) {
+            assert.equal(states.get(root + '/' + axis), 'passed', 'original Go preceded a complete native axis');
+          }
+        }
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'duplicate observation after its terminal');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string', 'duplicate output must be text');
+      if (event.Test === root) outputSpans.get(root).push({offset: outputs.get(root).length, sequence});
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    const output = outputs.get(event.Test);
+    if (event.Test !== root) {
+      childPasses.set(event.Test, sequence);
+      assert.equal([...output.matchAll(nativeHost)].length, 0, 'child host cannot replace root native ownership');
+      assert.equal([...output.matchAll(avxPreflight)].length, 0, 'child preflight cannot replace root AVX permission');
+      const evidence = original ? originalEvidence : pipelineEvidence(arch);
+      assert.equal(output.split(evidence).length - 1, 1, 'missing exact complete duplicate execution evidence');
+      if (original) {
+        const commands = requireSDKCommands(output);
+        assert.ok(commands[1].index < output.indexOf(evidence), 'original Go terminal preceded actual SDK build');
+        sdkBuilds++;
+        let observed;
+        if (arch === '386') {
+          observed = requireIA32Images(output, 1, originalArgs);
+          assert.ok(commands[1].index < observed.images[0].index &&
+            observed.direct[0].index < output.indexOf(evidence), 'original Go IA32 execution escaped SDK/terminal bracket');
+          staticIA32Images++;
+          directIA32Executions++;
+        }
+        requireExecutableRoles(output, arch, true, commands, observed);
+      } else {
+        let observed;
+        if (arch === '386') {
+          observed = requireIA32Images(output, 2, '[]');
+          assert.ok(observed.images[1].index < output.indexOf(evidence), 'fault image observation followed complete execution');
+          staticIA32Images += 2;
+          directIA32Executions++;
+        }
+        requireExecutableRoles(output, arch, false, undefined, observed);
+      }
+      continue;
+    }
+
+    const hosts = [...output.matchAll(nativeHost)], preflights = [...output.matchAll(avxPreflight)];
+    assert.equal(hosts.length, 2, 'duplicate root must retain pre/post actual native host observations');
+    assert.equal(preflights.length, 1, 'duplicate root must retain its single actual AVX preflight');
+    assert.ok(!output.includes('actual executable='), 'SDK receipts escaped their OriginalGo child');
+    for (const axis of axes) assert.equal(states.get(root + '/' + axis), 'passed', 'root preceded required child completion');
+    const spans = outputSpans.get(root).filter(span => span.offset <= hosts[1].index);
+    assert.ok(spans[spans.length - 1].sequence > childPasses.get(root + '/OriginalGo'),
+      'final native host observation preceded complete original Go execution');
+    // These are live host receipts, not immutable CPU MHz or map snapshots.
+    nativeHosts += 2;
+    avxPreflights++;
+  }
+  return {...result, nativeHosts, avxPreflights, sdkBuilds, staticIA32Images, directIA32Executions};
+}
+
+function auditDuplicateNativeFamilies(inventory, raw) {
+  return auditSSEAVXNativeFamilies(inventory, raw, roots, pipelineEvidence, originalEvidence);
+}
+
+module.exports = {auditDuplicateNativeFamilies, auditSSEAVXNativeFamilies, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditDuplicateNativeFamilies(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-floating-compare.cjs b/.github/scripts/audit-floating-compare.cjs
new file mode 100644
index 000000000..dde879a45
--- /dev/null
+++ b/.github/scripts/audit-floating-compare.cjs
@@ -0,0 +1,25 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSR',
+  'TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffects',
+  'TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpans',
+  'TestCrossLinuxRuntimeMatrixX86FloatingCompareLegacyUpperAliases',
+];
+const children = [
+  ...['CMPPS', 'CMPPD', 'CMPSS', 'CMPSD'].map(opcode => roots[0] + '/' + opcode),
+  ...['-O0', '-O2'].map(level => roots[1] + '/' + level),
+];
+const auditFloatingCompare = (inventory, raw) => auditNativeOwners(inventory, raw, roots, children);
+
+module.exports = {auditFloatingCompare, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditFloatingCompare(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-floating-helpers.cjs b/.github/scripts/audit-floating-helpers.cjs
new file mode 100644
index 000000000..e03aaef2e
--- /dev/null
+++ b/.github/scripts/audit-floating-helpers.cjs
@@ -0,0 +1,50 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = [
+  'TestAMD64GetExpRuntimeSemantics',
+  'TestAMD64GetMantRuntimeSemantics',
+  'TestAMD64ScaleFRuntimeSemantics',
+  'TestAMD64FloatingRangeRuntimeSemantics',
+  'TestAMD64FloatingRangeDoubleAndScalarRuntimeSemantics',
+  'TestAMD64FixupImmediateRuntimeSemantics',
+  'TestAMD64ScaledRoundRuntimeSemantics',
+  'TestAMD64FPClassRuntimeSemantics',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const children = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+
+function auditFloatingHelpers(inventory, raw) {
+  const result = auditNativeOwners(inventory, raw, roots, children);
+  const output = new Map(roots.map(root => [root, '']));
+  const preflights = new Set();
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event.Action === 'output' && output.has(event.Test)) {
+      output.set(event.Test, output.get(event.Test) + event.Output);
+    }
+    if (event.Action !== 'run' || !children.includes(event.Test)) continue;
+    const root = event.Test.split('/')[0];
+    const observation = output.get(root);
+    const flags = observation.match(/AVX512F=1 AVX512DQ=1 AVX512VL=1 OSXSAVE=1 XCR0=([0-9a-f]+)\b/);
+    assert.ok(flags, 'missing current native F/DQ/VL and OS-enabled state: ' + root);
+    assert.equal(BigInt('0x' + flags[1]) & 0xe6n, 0xe6n, 'incomplete native XCR0: ' + root);
+    assert.ok(observation.includes('FLOATING_HELPER_NATIVE_DQ_OK'),
+      'original native DQ opcode did not complete before its runtime: ' + root);
+    preflights.add(root);
+  }
+  assert.equal(preflights.size, 8, 'missing actual native floating-helper preflight');
+  return {...result, preflights: preflights.size};
+}
+
+module.exports = {auditFloatingHelpers, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditFloatingHelpers(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-integer-native-families.cjs b/.github/scripts/audit-integer-native-families.cjs
new file mode 100644
index 000000000..e218c53d0
--- /dev/null
+++ b/.github/scripts/audit-integer-native-families.cjs
@@ -0,0 +1,191 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86MOVNTIOriginalFlagsAndFaults',
+  'TestCrossLinuxRuntimeMatrixX86PackedAlignLegacyNativeFaults',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNative386',
+  'TestCrossLinuxRuntimeMatrixX86SegmentQueryOriginalFlagsAliasesAndFaults',
+  'TestCrossLinuxRuntimeMatrixX86MoveHalfOriginalGoFlagsDFAliases',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNative386',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const children = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+const nativeHost = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+const originalArgs = '["-test.run=^TestOriginal$" "-test.count=1" "-test.v"]';
+const segmentEvidence = '48 original-Go opcode rows × 16 inputs; full GP aliases, six status flags, canaries; 160 live/dead m16 fault processes\n';
+const halfPreflight = 'half native CPUID/XCR0 AVX512F=1; original EVEX transport opcode executed\n';
+const halfEvidence = 'half native full64/FLAGS/DF=1/canary outcomes=512; complete original STD/CLD source and all eight named half moves\n';
+const halfOriginal = 'half actual original Go full64/FLAGS/DF=1/canary outcomes=512\n';
+
+function logicalFPCompletion(ia32, original) {
+  const arch = ia32 ? '386' : 'amd64';
+  const rows = ia32 ? 6 : 8;
+  const values = ia32 ? 96 : 128;
+  const faults = ia32 ? 18 : 24;
+  return original
+    ? `logical FP actual original Go arch=${arch} rows=${rows} values=${values}; complete original FP divisor source and whole AX/DX/DF/canary observations\n`
+    : `logical FP native arch=${arch} rows=${rows} values=${values} dead-division-faults=${faults}; whole AX/DX, DF and canaries; zero/overflow and signed-min/-1 SIGFPE\n`;
+}
+
+function requireIA32Images(output, staticCount, args) {
+  const images = [...output.matchAll(/native oracle static IA32 ELF bytes=([1-9][0-9]*) sha256=([a-f0-9]{64})\b/g)];
+  const direct = [...output.matchAll(/IA32 direct ELF bytes=([1-9][0-9]*) sha256=([a-f0-9]{64}) argv=(\[[^\r\n]*\])/g)];
+  assert.equal(images.length, staticCount, 'missing complete static IA32 observations');
+  assert.equal(direct.length, 1, 'missing direct IA32 execution');
+  assert.equal(direct[0][3], args, 'wrong direct IA32 execution arguments');
+  assert.equal(direct[0][1], images[0][1], 'direct IA32 image size changed');
+  assert.equal(direct[0][2], images[0][2], 'direct IA32 image hash changed');
+  assert.ok(images[0].index < direct[0].index, 'direct IA32 execution preceded image inspection');
+  if (staticCount === 2) {
+    assert.ok(direct[0].index < images[1].index, 'fault image inspection preceded value execution');
+  }
+  return {images, direct};
+}
+
+function requireSDKCommands(output) {
+  const commands = [...output.matchAll(/actual executable=([^\r\n]+\/bin\/go) sha256=([a-f0-9]{64}) argv=(\[[^\r\n]*\])/g)];
+  assert.equal(commands.length, 2, 'must observe the actual SDK version and original Go build');
+  assert.equal(commands[0][1], commands[1][1], 'SDK executable changed');
+  assert.equal(commands[0][2], commands[1][2], 'SDK hash changed');
+  assert.equal(commands[0][3], '["version"]', 'actual SDK version was not observed');
+  assert.match(commands[1][3], /^\["test" "-p=1" "-vet=off" "-c" "-o" "\/[^"\r\n]+\/original\.test" "\."\]$/,
+    'original Go compile did not retain its complete actual SDK command');
+  assert.ok(commands[0].index < commands[1].index, 'original Go build preceded actual SDK version');
+  return commands;
+}
+
+function auditIntegerNativeFamilies(inventory, raw) {
+  const result = auditNativeOwners(inventory, raw, roots, children);
+  const states = new Map();
+  const outputs = new Map([...roots, ...children].map(name => [name, '']));
+  const spans = new Map(roots.map(root => [root, []]));
+  const lastChildPass = new Map();
+  let packageStarted = false, packageComplete = false;
+  let nativeHosts = 0, sdkBuilds = 0, staticIA32Images = 0, directIA32Executions = 0;
+
+  const events = raw.split(/\r?\n/).filter(Boolean).map(line => JSON.parse(line));
+  for (const [sequence, event] of events.entries()) {
+    assert.ok(!packageComplete, 'event after the complete native package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown native package action');
+      if (event.Action === 'start') {
+        assert.ok(!packageStarted, 'duplicate native package start');
+        packageStarted = true;
+      } else {
+        assert.ok(packageStarted, 'native event before package start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string', 'package output must be text');
+        if (event.Action === 'pass') packageComplete = true;
+      }
+      continue;
+    }
+    assert.ok(packageStarted, 'native test before package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown native test action');
+    const root = event.Test.split('/')[0];
+    const half = root.includes('MoveHalf');
+    const logicalFP = root.includes('ImplicitDivideLogicalFP');
+    const observed = root.includes('ImplicitDivide') || root.includes('SegmentQuery') || half;
+    const ia32 = root.endsWith('386');
+    if (event.Action === 'run') {
+      states.set(event.Test, 'running');
+      if (observed && event.Test !== root) {
+        assert.equal([...outputs.get(root).matchAll(nativeHost)].length, 1,
+          'integer axis lacks its preceding actual native host observation');
+        assert.ok(!outputs.get(root).includes('actual executable='),
+          'original Go compilation must follow all three native axes');
+        if (half) {
+          assert.equal(outputs.get(root).split(halfPreflight).length - 1, 1,
+            'half axis lacks actual CPUID/XCR0 and native EVEX transport preflight');
+        }
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'native observation after its terminal');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string', 'native output must be text');
+      if (event.Test === root) {
+        spans.get(root).push({offset: outputs.get(root).length, sequence});
+      }
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    if (event.Test !== root) {
+      lastChildPass.set(root, sequence);
+      if (root.includes('SegmentQuery')) {
+        assert.equal(outputs.get(event.Test).split(segmentEvidence).length - 1, 1,
+          'segment query axis lacks its complete opcode flags alias and fault evidence');
+      }
+      if (half) {
+        assert.equal(outputs.get(event.Test).split(halfEvidence).length - 1, 1,
+          'half axis lacks all 512 full64/FLAGS/DF/canary observations');
+      }
+      if (logicalFP) {
+        assert.equal(outputs.get(event.Test).split(logicalFPCompletion(ia32, false)).length - 1, 1,
+          'logical FP axis lacks complete native whole-register values and dead #DE execution');
+      }
+      if (ia32) {
+        requireIA32Images(outputs.get(event.Test), 2, '[]');
+        staticIA32Images += 2;
+        directIA32Executions++;
+      }
+      continue;
+    }
+    if (!observed) continue;
+
+    const output = outputs.get(root);
+    const hosts = [...output.matchAll(nativeHost)];
+    const commands = requireSDKCommands(output);
+    assert.equal(hosts.length, 2, 'integer root must retain pre/post actual native host observations');
+    assert.ok(hosts[0].index < commands[0].index && commands[0].index < commands[1].index &&
+      commands[1].index < hosts[1].index, 'integer native/SDK observation order changed');
+    if (half) {
+      assert.equal(output.split(halfPreflight).length - 1, 1, 'duplicate or absent half native CPU preflight');
+      assert.equal(output.split(halfOriginal).length - 1, 1, 'missing complete actual original Go DF observations');
+      assert.ok(commands[1].index < output.indexOf(halfOriginal) && output.indexOf(halfOriginal) < hosts[1].index,
+        'original Go DF terminal escaped its SDK/native host bracket');
+    }
+    if (logicalFP) {
+      const completion = logicalFPCompletion(ia32, true);
+      assert.equal(output.split(completion).length - 1, 1,
+        'logical FP root lacks complete actual original Go value execution');
+      assert.ok(commands[1].index < output.indexOf(completion) && output.indexOf(completion) < hosts[1].index,
+        'original Go logical FP completion escaped its SDK/native host bracket');
+    }
+
+    // The SDK and final host observations occur after every execution child.
+    // A printed root PASS before original Go execution cannot certify it.
+    for (const observation of [commands[0], commands[1], hosts[1]]) {
+      const preceding = spans.get(root).filter(span => span.offset <= observation.index);
+      assert.ok(preceding[preceding.length - 1].sequence > lastChildPass.get(root),
+        'original Go or final native host observation preceded the complete native axes');
+    }
+    if (ia32) {
+      const observed = requireIA32Images(output, 1, originalArgs);
+      assert.ok(commands[1].index < observed.images[0].index &&
+        observed.direct[0].index < hosts[1].index, 'original Go IA32 execution escaped its native/SDK bracket');
+      staticIA32Images++;
+      directIA32Executions++;
+    }
+    // /proc/cpuinfo and maps are live observations, not stable identities.
+    // CPU MHz and mappings may change; require both valid hashes, not equality.
+    nativeHosts += hosts.length;
+    sdkBuilds++;
+  }
+  return {...result, nativeHosts, sdkBuilds, staticIA32Images, directIA32Executions};
+}
+
+module.exports = {auditIntegerNativeFamilies, requireIA32Images, requireSDKCommands, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditIntegerNativeFamilies(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-legacy-abs-sign-native.cjs b/.github/scripts/audit-legacy-abs-sign-native.cjs
new file mode 100644
index 000000000..b38989bff
--- /dev/null
+++ b/.github/scripts/audit-legacy-abs-sign-native.cjs
@@ -0,0 +1,127 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaultsAMD64',
+  'TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaults386'];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+const operations = ['PABSB', 'PABSW', 'PABSD', 'PSIGNB', 'PSIGNW', 'PSIGND',
+  'VPABSB', 'VPABSW', 'VPABSD', 'VPSIGNB', 'VPSIGNW', 'VPSIGND'];
+const roles = ['live', 'dead'];
+const parents = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+const leaves = parents.flatMap(parent => operations.flatMap(op => roles.map(role => parent + '/' + op + '/' + role)));
+const children = [...parents, ...leaves];
+const marker = 'ABS/sign original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0\n';
+const preflight = 'ABS/sign actual native SSSE3=1 AVX=1\n';
+const hostPrefix = 'IA32 direct host:';
+const sdkPrefix = 'actual LEA source/object receipt:';
+const imagePrefix = 'native oracle static IA32 ELF';
+const host = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+const image = /native oracle static IA32 ELF bytes=[1-9][0-9]* sha256=[a-f0-9]{64}\b/g;
+
+function auditLegacyAbsSignNative(inventory, raw) {
+  const result = auditNativeOwners(inventory, raw, roots, children);
+  const outputs = new Map([...roots, ...children].map(name => [name, '']));
+  const states = new Map(), passed = new Map();
+  const spans = new Map(roots.map(root => [root, []]));
+  let started = false, complete = false, kernelExecutions = 0;
+
+  function rootObservations(root, final) {
+    const output = outputs.get(root), arch = root.endsWith('386') ? '386' : 'amd64';
+    const captures = [...output.matchAll(new RegExp('actual LEA source/object receipt: SDK=go[1-9][0-9]*\\.[0-9]+(?:\\.[0-9]+)?(?:beta[0-9]+|rc[0-9]+)? target=linux/' + arch +
+      ' source=[a-f0-9]{64} driver=[a-f0-9]{64} object=[a-f0-9]{64}\\b', 'g'))];
+    const hosts = [...output.matchAll(host)];
+    assert.equal(hosts.length, final ? 2 : 1, 'missing or duplicated actual native host bracket');
+    assert.equal(output.split(hostPrefix).length - 1, hosts.length, 'malformed extra native host');
+    assert.equal(captures.length, 1, 'missing unique actual original Go SDK/source/object capture');
+    assert.equal(output.split(sdkPrefix).length - 1, 1, 'malformed extra SDK/source/object capture');
+    assert.equal(output.split(preflight).length - 1, 1, 'missing or duplicated actual SSSE3/AVX preflight');
+    assert.equal(output.split('ABS/sign actual native').length - 1, 1, 'malformed extra CPU preflight');
+    assert.ok(hosts[0].index < output.indexOf(preflight) && output.indexOf(preflight) < captures[0].index,
+      'CPU or original source capture escaped the actual native host bracket');
+    assert.ok(!output.includes(marker) && !output.includes(imagePrefix), 'root summaries cannot replace executed kernels or axis-owned images');
+    if (final) {
+      assert.ok(captures[0].index < hosts[1].index, 'final native host preceded original source capture');
+      const span = spans.get(root).filter(value => value.offset <= hosts[1].index).pop();
+      for (const axis of axes) {
+        assert.ok(passed.has(root + '/' + axis), 'root lacks its complete native optimization axis');
+        assert.ok(span && span.sequence > passed.get(root + '/' + axis), 'final native host preceded an execution axis');
+      }
+    }
+  }
+
+  for (const [sequence, line] of raw.split(/\r?\n/).filter(Boolean).entries()) {
+    const event = JSON.parse(line);
+    assert.ok(!complete, 'event after complete native ABS/sign package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown ABS/sign package lifecycle');
+      if (event.Action === 'start') {
+        assert.ok(!started, 'duplicate ABS/sign package start');
+        started = true;
+      } else {
+        assert.ok(started, 'package observation before actual start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string', 'nontext package output');
+        if (event.Action === 'pass') complete = true;
+      }
+      continue;
+    }
+    assert.ok(started, 'native ABS/sign test before package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown ABS/sign test lifecycle');
+    const root = event.Test.split('/')[0];
+    if (event.Action === 'run') {
+      assert.ok(!states.has(event.Test), 'native ABS/sign lifecycle restarted');
+      states.set(event.Test, 'running');
+      if (event.Test !== root) rootObservations(root, false);
+      if (leaves.includes(event.Test) && root.endsWith('386')) {
+        const parent = event.Test.split('/').slice(0, 2).join('/');
+        assert.equal([...outputs.get(parent).matchAll(image)].length, 1,
+          'IA32 kernel started before its complete static image inspection');
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'ABS/sign observation outside its live owner');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string', 'nontext ABS/sign test output');
+      if (event.Test === root) spans.get(root).push({offset: outputs.get(root).length, sequence});
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    passed.set(event.Test, sequence);
+    if (event.Test === root) {
+      rootObservations(root, true);
+      continue;
+    }
+    const output = outputs.get(event.Test);
+    for (const foreign of [hostPrefix, sdkPrefix, 'ABS/sign actual native']) {
+      assert.ok(!output.includes(foreign), 'child cannot replace actual root host/SDK/ISA ownership');
+    }
+    if (parents.includes(event.Test)) {
+      assert.ok(!output.includes(marker), 'axis summary cannot replace actual kernel execution');
+      const count = root.endsWith('386') ? 1 : 0;
+      assert.equal([...output.matchAll(image)].length, count, 'axis lacks its exact complete native static image');
+      assert.equal(output.split(imagePrefix).length - 1, count, 'malformed extra IA32 static image');
+      for (const op of operations) for (const role of roles) {
+        assert.ok(passed.has(event.Test + '/' + op + '/' + role), 'axis ended before its entire live/dead opcode family');
+      }
+    } else {
+      assert.ok(!output.includes(imagePrefix), 'kernel cannot replace axis-owned image authentication');
+      assert.equal(output.split(marker).length - 1, 1, 'kernel lacks exactly one actual complete 20-probe observation');
+      kernelExecutions++;
+    }
+  }
+  return {...result, nativeHosts: 4, sdkCaptures: 2, isaPreflights: 2, staticIA32Images: 3,
+    kernelExecutions, directProbeProcesses: kernelExecutions * 20 * 2};
+}
+
+module.exports = {auditLegacyAbsSignNative};
+if (require.main === module) {
+  const directory = process.argv[2];
+  process.stdout.write(JSON.stringify(auditLegacyAbsSignNative(
+    fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'))) + '\n');
+}
diff --git a/.github/scripts/audit-lock-native.cjs b/.github/scripts/audit-lock-native.cjs
new file mode 100644
index 000000000..97f9b274b
--- /dev/null
+++ b/.github/scripts/audit-lock-native.cjs
@@ -0,0 +1,20 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86LockScalarRMWNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86LockScalarRMWNative386'];
+const children = roots.flatMap(root => ['-O0', '-O2'].map(level => root + '/' + level));
+function auditNativeLock(inventory, raw) {
+  return auditNativeOwners(inventory, raw, roots, children);
+}
+module.exports = {auditNativeLock, roots, children};
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one actual native LOCK report directory required');
+  const directory = process.argv[2];
+  const result = auditNativeLock(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
diff --git a/.github/scripts/audit-mmx-streaming.cjs b/.github/scripts/audit-mmx-streaming.cjs
new file mode 100644
index 000000000..e1f24a48a
--- /dev/null
+++ b/.github/scripts/audit-mmx-streaming.cjs
@@ -0,0 +1,18 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86MMXStreamingOriginalAndLLVM'];
+const children = ['original-go', 'llvm-default-O0', 'llvm-default-O2', 'llvm-O2-O0', 'llvm-O2-O2']
+  .map(name => roots[0] + '/' + name);
+const auditMMXStreaming = (inventory, raw) => auditNativeOwners(inventory, raw, roots, children);
+
+module.exports = {auditMMXStreaming, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditMMXStreaming(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-native-leaw.cjs b/.github/scripts/audit-native-leaw.cjs
new file mode 100644
index 000000000..c5c054ba7
--- /dev/null
+++ b/.github/scripts/audit-native-leaw.cjs
@@ -0,0 +1,103 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const root = 'TestCrossLinuxRuntimeMatrixX86LEAWRetainedPointerOriginalBytesAndNativeDF';
+const apis = ['text', 'module', 'Go'];
+const pipelines = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const groups = apis.map(api => root + '/' + api);
+const leaves = groups.flatMap(group => pipelines.map(pipeline => group + '/' + pipeline));
+const original = root + '/OriginalGoBytes';
+const children = [...groups, ...leaves, original];
+const llvmMarker = 'native retained LEAW LLVM execution: LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS\n';
+const originalMarker = 'native retained LEAW actual Go bytes execution: LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS\n';
+const hostPrefix = 'IA32 direct host:';
+const sdkPrefix = 'actual LEA source/object receipt:';
+const host = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+const sdk = /actual LEA source\/object receipt: SDK=go[1-9][0-9]*\.[0-9]+(?:\.[0-9]+)?(?:beta[0-9]+|rc[0-9]+)? target=linux\/amd64 source=[a-f0-9]{64} driver=[a-f0-9]{64} object=[a-f0-9]{64}\b/g;
+
+function auditNativeLEAW(inventory, raw) {
+  const result = auditNativeOwners(inventory, raw, [root], children);
+  const outputs = new Map([root, ...children].map(name => [name, '']));
+  const passed = new Map(), states = new Map(), spans = [];
+  let started = false, complete = false;
+  for (const [sequence, line] of raw.split(/\r?\n/).filter(Boolean).entries()) {
+    const event = JSON.parse(line);
+    assert.ok(!complete, 'event after the complete LEAW package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown LEAW package lifecycle action');
+      if (event.Action === 'start') {
+        assert.ok(!started, 'duplicate LEAW package start');
+        started = true;
+      } else {
+        assert.ok(started, 'LEAW package observation before its start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string', 'package output must be text');
+        if (event.Action === 'pass') complete = true;
+      }
+      continue;
+    }
+    assert.ok(started, 'LEAW test before its package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown LEAW test lifecycle action');
+    if (event.Action === 'run') {
+      assert.ok(!states.has(event.Test), 'LEAW test restarted after its original lifecycle');
+      states.set(event.Test, 'running');
+      if (event.Test !== root) {
+        const output = outputs.get(root);
+        const hosts = [...output.matchAll(host)], captures = [...output.matchAll(sdk)];
+        assert.equal(hosts.length, 1, 'LEAW child lacks its preceding actual native host');
+        assert.equal(captures.length, 1, 'LEAW child lacks its preceding actual SDK/source/object capture');
+        assert.ok(hosts[0].index < captures[0].index, 'SDK capture preceded actual native host identity');
+        if (event.Test === original) {
+          for (const group of groups) assert.ok(passed.has(group), 'original bytes preceded a complete API group');
+        }
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'LEAW observation outside its live execution owner');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string', 'LEAW output must be text');
+      if (event.Test === root) spans.push({offset: outputs.get(root).length, sequence});
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    passed.set(event.Test, sequence);
+    const output = outputs.get(event.Test);
+    if (event.Test !== root) {
+      assert.ok(!output.includes(hostPrefix) && !output.includes(sdkPrefix), 'child cannot replace root host/SDK ownership');
+      if (groups.includes(event.Test)) {
+        for (const pipeline of pipelines) assert.ok(passed.has(event.Test + '/' + pipeline), 'API parent preceded an executed LLVM leaf');
+        assert.ok(!output.includes(llvmMarker) && !output.includes(originalMarker), 'API parent cannot replace a leaf execution');
+      } else {
+        const marker = event.Test === original ? originalMarker : llvmMarker;
+        const foreign = event.Test === original ? llvmMarker : originalMarker;
+        assert.equal(output.split(marker).length - 1, 1, 'missing or duplicated complete actual LEAW execution marker');
+        assert.ok(!output.includes(foreign), 'LLVM and actual Go bytes are separate execution obligations');
+      }
+      continue;
+    }
+    const hosts = [...output.matchAll(host)], captures = [...output.matchAll(sdk)];
+    assert.equal(hosts.length, 2, 'LEAW requires actual native pre/post host observations');
+    assert.equal(output.split(hostPrefix).length - 1, 2, 'malformed extra native host receipt');
+    assert.equal(captures.length, 1, 'LEAW requires its unique actual SDK/source/object capture');
+    assert.equal(output.split(sdkPrefix).length - 1, 1, 'malformed extra SDK capture');
+    assert.ok(hosts[0].index < captures[0].index && captures[0].index < hosts[1].index, 'SDK capture escaped native host brackets');
+    for (const child of children) assert.ok(passed.has(child), 'root preceded a required execution child');
+    const finalSpan = spans.filter(span => span.offset <= hosts[1].index).pop();
+    assert.ok(finalSpan && finalSpan.sequence > passed.get(original), 'final host preceded actual original-byte execution');
+    assert.ok(!output.includes(llvmMarker) && !output.includes(originalMarker), 'root summary cannot replace leaf execution');
+  }
+  return {...result, nativeHosts: 2, sdkCaptures: 1, llvmExecutions: 9, originalByteExecutions: 1};
+}
+
+module.exports = {auditNativeLEAW};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditNativeLEAW(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-native-owners.cjs b/.github/scripts/audit-native-owners.cjs
new file mode 100644
index 000000000..36d6ceb56
--- /dev/null
+++ b/.github/scripts/audit-native-owners.cjs
@@ -0,0 +1,52 @@
+const assert = require('node:assert/strict');
+
+// The caller supplies a fixed first-party inventory, never report metadata.
+// Printed payloads and incomplete, duplicated or skipped test axes are not runs.
+function auditNativeOwners(inventory, raw, roots, children) {
+  assert.ok(roots.length > 0, 'required native owners cannot be empty');
+  assert.equal(new Set(roots).size, roots.length, 'duplicate required native owner');
+  assert.ok(roots.every(root => /^Test[^/\s]+$/.test(root)), 'invalid required native owner');
+  assert.ok(children.every(child => roots.some(root => child.startsWith(root + '/'))),
+    'required native child has no owner');
+  const discovered = inventory.split(/\r?\n/).filter(line => line.startsWith('Test'));
+  assert.deepEqual(discovered.slice().sort(), roots.slice().sort(), 'complete fresh native inventory changed');
+  const expected = new Set([...roots, ...children]);
+  assert.equal(expected.size, roots.length + children.length, 'duplicate required native axis');
+  const started = new Set(), passed = new Set();
+  let complete = false;
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event.Action === 'build-output' && typeof event.ImportPath === 'string' && event.ImportPath && !event.Test) continue;
+    assert.equal(event.Package, 'github.com/xgo-dev/plan9asm', 'foreign native package');
+    assert.ok(!complete, 'event after native package terminal');
+    assert.ok(!['fail', 'skip', 'build-fail'].includes(event.Action), 'required native execution failed or skipped');
+    if (event.Test) {
+      const owner = event.Test.split('/')[0];
+      assert.ok(expected.has(event.Test), 'foreign native root or hardware/ABI/backend child');
+      if (event.Test !== owner) assert.ok(started.has(owner) && !passed.has(owner), 'child outside its live owner');
+      for (const parent of expected) {
+        if (event.Test.startsWith(parent + '/')) {
+          assert.ok(started.has(parent) && !passed.has(parent), 'child outside a required live architecture parent');
+        }
+      }
+      if (event.Action === 'run') {
+        assert.ok(!started.has(event.Test), 'duplicate native start');
+        started.add(event.Test);
+      } else {
+        assert.ok(started.has(event.Test), 'event for an unstarted native owner');
+        if (event.Action === 'pass') {
+          assert.ok(!passed.has(event.Test), 'duplicate native terminal');
+          passed.add(event.Test);
+        }
+      }
+    } else if (event.Action === 'pass') {
+      assert.deepEqual([...started].sort(), [...expected].sort(), 'missing native execution axis');
+      assert.deepEqual([...passed].sort(), [...expected].sort(), 'unfinished native execution axis');
+      complete = true;
+    }
+  }
+  assert.ok(complete, 'native package did not finish successfully');
+  return {roots: roots.length, children: children.length, passed: passed.size, skipped: 0, incomplete: 0};
+}
+
+module.exports = {auditNativeOwners};
diff --git a/.github/scripts/audit-native-priority.cjs b/.github/scripts/audit-native-priority.cjs
new file mode 100644
index 000000000..6264b629c
--- /dev/null
+++ b/.github/scripts/audit-native-priority.cjs
@@ -0,0 +1,172 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function auditNativePriority(directory, io = fs) {
+  const inventories = {
+    'static-read': ['TestX86RawReturnStaticReadNumericOracle'],
+    alias: [
+      'TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesOriginalAndLLVM',
+      'TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesCountedProvenance',
+    ],
+    bool: [
+      'TestCrossLinuxRuntimeMatrixAMD64RegisterCanonicalBoolInstructionBytes',
+      'TestCrossLinuxRuntimeMatrixGoAMD64CanonicalBoolByteRepresentation',
+    ],
+    caller: [
+      'TestCrossLinuxRuntimeMatrixX86CallerAddressInstructionBytesAndLLVM',
+      'TestCrossLinuxRuntimeMatrixGoX86CallerAddressABI0Representation',
+    ],
+    'caller-cmp': [
+      'TestCrossLinuxRuntimeMatrixX86CallerAddressCMPInstructionBytesAndLLVM',
+      'TestCrossLinuxRuntimeMatrixGoX86CallerAddressCMPABI0Representation',
+    ],
+    numerical: [
+      'TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableAMD64',
+      'TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableLocalAMD64',
+    ],
+    'numerical-lea': ['TestCrossLinuxRuntimeMatrixX86NumericalLEAOriginalBytesAndLLVM'],
+    'direct-tail': [
+      'TestCrossLinuxRuntimeMatrixAMD64DirectTailWholeSourceOriginalGoAndLLVM',
+      'TestCrossLinuxRuntimeMatrixX86DirectTail386OriginalGoAndLLVM',
+      'TestCrossLinuxRuntimeMatrixX86DirectTailPCResultAliasesAndExternal',
+    ],
+    'gp-simd-sparse': [
+      'TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNativeAMD64OriginalGoAndLLVM',
+      'TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNative386OriginalGoAndLLVM',
+    ],
+    'bit-scan': [
+      'TestCrossLinuxRuntimeMatrixX86BitScanNativeAMD64OriginalGoAndLLVM',
+      'TestCrossLinuxRuntimeMatrixX86BitScanNative386OriginalGoAndLLVM',
+    ],
+    'bool-386': ['TestCrossLinuxRuntimeMatrixX86ABI0Mode32CanonicalBoolOriginalGoAndLLVM'],
+    'packed-string': ['TestCrossLinuxRuntimeMatrixX86PackedStringImplicitVectorNativeAVX'],
+    'independent-fp': [
+      'TestCrossLinuxRuntimeMatrixX86InsertExtractIndependentFPFields',
+      'TestCrossLinuxRuntimeMatrixX86LegacyPSIndependentFPFields',
+    ],
+    'source-stack': ['TestCrossLinuxRuntimeMatrixX86RawSourceStackNumerical'],
+    continuation: ['TestCrossLinuxRuntimeMatrixX86ContinuationWholeCFGOriginalGoAndLLVM'],
+    'packed-string-fault': ['TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults'],
+    'byte-swap': ['TestCrossLinuxRuntimeMatrixX86ByteSwapOriginalGoAndLLVM'],
+    crc32: ['TestAMD64CRC32RuntimeSemanticsAndFlags'],
+    'bit-test': ['TestCrossLinuxRuntimeMatrixX86BitTestNumericalAndAliases'],
+  };
+  const actualFiles = io.readdirSync(directory).filter(name => name.endsWith('-inventory.log')).sort();
+  assert.deepEqual(actualFiles, Object.keys(inventories).map(name => name + '-inventory.log').sort(),
+    'missing or foreign independent native-axis inventories');
+  const mandatory = new Set();
+  for (const [inventory, expected] of Object.entries(inventories)) {
+    const names = io.readFileSync(path.join(directory, inventory + '-inventory.log'), 'utf8')
+      .split(/\r?\n/).filter(line => /^Test\S+$/.test(line));
+    assert.deepEqual(names.slice().sort(), expected.slice().sort(), 'changed mandatory inventory: ' + inventory);
+    for (const name of names) {
+      assert.ok(!mandatory.has(name), 'duplicate mandatory owner: ' + name);
+      mandatory.add(name);
+    }
+  }
+  assert.equal(mandatory.size, 29);
+  const discovered = io.readFileSync(path.join(directory, 'all-roots.stdout'), 'utf8')
+    .split(/\r?\n/).filter(line => /^Test\S+$/.test(line)).sort();
+  assert.equal(discovered.length, 66, 'fresh discovery denominator changed');
+  assert.equal(new Set(discovered).size, 66, 'duplicate fresh discovery');
+  const roots = new Set(), rootTerminals = new Set();
+  const children = new Set(), childTerminals = new Set();
+  let packageTerminal;
+  io.readFileSync(path.join(directory, 'native.stderr'), 'utf8');
+  const raw = io.readFileSync(path.join(directory, 'native.jsonl'), 'utf8');
+  for (const line of raw.split(/\r?\n/)) {
+    if (!line) continue;
+    const event = JSON.parse(line);
+    if (event.Package) assert.equal(event.Package, 'github.com/xgo-dev/plan9asm', 'foreign package event');
+    if (!event.Test) {
+      assert.notEqual(event.Action, 'build-fail', 'native package build failed');
+      if (['pass', 'fail', 'skip'].includes(event.Action)) {
+        assert.equal(event.Package, 'github.com/xgo-dev/plan9asm', 'package terminal lacks exact package identity');
+        assert.equal(packageTerminal, undefined, 'duplicate package terminal');
+        assert.equal(event.Action, 'pass', 'native package did not execute successfully');
+        packageTerminal = { package: event.Package, elapsed: event.Elapsed };
+      }
+      continue;
+    }
+    assert.equal(packageTerminal, undefined, 'test event after package terminal');
+    assert.equal(event.Package, 'github.com/xgo-dev/plan9asm', 'test lacks exact package identity');
+    const child = event.Test.includes('/');
+    const root = event.Test.split('/')[0];
+    const starts = child ? children : roots;
+    const terminals = child ? childTerminals : rootTerminals;
+    if (child) assert.ok(roots.has(root), 'foreign/unstarted child root: ' + event.Test);
+    if (event.Action === 'run') {
+      assert.ok(!starts.has(event.Test), 'duplicate test start: ' + event.Test);
+      if (child) {
+        // t.Run may put slashes in one literal name without intermediate
+        // parent events. The actual root must still have started.
+        assert.ok(!rootTerminals.has(root), 'child starts after root terminal');
+      }
+      starts.add(event.Test);
+    }
+    if (['pass', 'fail', 'skip'].includes(event.Action)) {
+      assert.ok(starts.has(event.Test), 'test terminal lacks start: ' + event.Test);
+      assert.ok(!terminals.has(event.Test), 'duplicate test terminal: ' + event.Test);
+      if (child) assert.ok(!rootTerminals.has(root), 'child finishes after root terminal: ' + event.Test);
+      assert.equal(event.Action, 'pass', event.Test + ' did not execute successfully');
+      terminals.add(event.Test);
+    }
+  }
+  assert.equal(roots.size, 66, 'exact native root denominator changed');
+  assert.deepEqual([...roots].sort(), discovered, 'execution roots differ from fresh discovery');
+  assert.deepEqual([...roots].sort(), [...rootTerminals].sort(), 'incomplete root terminals');
+  assert.deepEqual([...children].sort(), [...childTerminals].sort(), 'incomplete child terminals');
+  assert.ok(packageTerminal, 'missing native package terminal');
+  for (const name of mandatory) {
+    assert.ok(roots.has(name) && rootTerminals.has(name), 'missing mandatory root: ' + name);
+  }
+  const sourceStack = 'TestCrossLinuxRuntimeMatrixX86RawSourceStackNumerical';
+  const continuation = 'TestCrossLinuxRuntimeMatrixX86ContinuationWholeCFGOriginalGoAndLLVM';
+  const requiredChildren = [sourceStack + '/amd64', sourceStack + '/386'];
+  for (const arch of ['amd64', '386']) {
+    for (const dispatch of ['memory', 'register']) {
+      requiredChildren.push(continuation + '/' + arch + '/' + dispatch);
+    }
+  }
+  const packedStringFault = 'TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults';
+  for (const optimization of ['-O0', '-O2']) {
+    requiredChildren.push(packedStringFault + '/' + optimization);
+  }
+  const byteSwap = 'TestCrossLinuxRuntimeMatrixX86ByteSwapOriginalGoAndLLVM';
+  for (const arch of ['amd64', '386']) {
+    requiredChildren.push(byteSwap + '/' + arch);
+  }
+  const directTail386 = 'TestCrossLinuxRuntimeMatrixX86DirectTail386OriginalGoAndLLVM';
+  for (const carrier of ['SI', 'BP', 'SI-stack', 'BP-stack']) {
+    requiredChildren.push(directTail386 + '/' + carrier);
+  }
+  for (const dispatch of ['BP-memory', 'BP-register', 'BP-target']) {
+    requiredChildren.push(continuation + '/386/' + dispatch);
+  }
+  const bitTest = 'TestCrossLinuxRuntimeMatrixX86BitTestNumericalAndAliases';
+  for (const api of ['text', 'module', 'Go']) {
+    for (const axis of ['backend_O0', 'IR_O2/backend_O2']) {
+      requiredChildren.push(`${bitTest}/${api}/${axis}`);
+    }
+  }
+  for (const child of requiredChildren) {
+    assert.ok(children.has(child) && childTerminals.has(child), 'missing required child: ' + child);
+  }
+  return {
+    protocol: 'go_test_json_native66',
+    roots: roots.size, passed: rootTerminals.size,
+    children: children.size, childPassed: childTerminals.size,
+    failed: 0, skipped: 0, incomplete: 0, duplicate: 0,
+    inventories: actualFiles.length, mandatory: [...mandatory].sort(), requiredChildren,
+    packageResult: packageTerminal,
+  };
+}
+
+
+module.exports = { auditNativePriority };
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one native artifact directory required');
+  process.stdout.write(JSON.stringify(auditNativePriority(process.argv[2]), null, 2) + '\n');
+}
diff --git a/.github/scripts/audit-packed-conversion-native.cjs b/.github/scripts/audit-packed-conversion-native.cjs
new file mode 100644
index 000000000..4a2dbc5ef
--- /dev/null
+++ b/.github/scripts/audit-packed-conversion-native.cjs
@@ -0,0 +1,146 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {execFileSync} = require('node:child_process');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const owners = 8;
+const pipelines = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+const statusRoot = 'TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512Status';
+const faultRoot = 'TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaults';
+const independentRoot = 'TestCrossLinuxRuntimeMatrixX86PackedConversionNativeIndependentC';
+
+function partition(root, owner) {
+  assert.ok(Number.isInteger(owner) && owner >= 0 && owner < owners, 'invalid native conversion owner');
+  return root + (owner ? 'Part' + owner : '');
+}
+
+function batches(count, limit, owner) {
+  const selected = [];
+  for (let start = 0, batch = 0; start < count; start += limit, batch++) {
+    if (batch % owners === owner) selected.push([start, Math.min(start + limit, count)]);
+  }
+  assert.ok(selected.length > 0, 'empty native conversion partition');
+  return selected;
+}
+
+function required(owner) {
+  const roots = [partition(statusRoot, owner), partition(faultRoot, owner)];
+  if (!owner) roots.push(independentRoot);
+  const children = [];
+  const values = batches(692, 64, owner);
+  const faults = batches(222, 16, owner);
+  for (const [root, selected, originals] of [
+    [roots[0], values, ['original_go_named', 'original_go_raw']],
+    [roots[1], faults, ['original_go_opcode_reference']],
+  ]) {
+    for (const [start] of selected) {
+      const batch = root + '/batch-' + String(start).padStart(4, '0');
+      children.push(batch, ...originals.map(original => batch + '/' + original));
+      for (const spelling of ['named', 'raw']) {
+        const source = batch + '/' + spelling;
+        children.push(source);
+        for (const api of ['text', 'module', 'Go']) {
+          const publicPath = source + '/' + api;
+          children.push(publicPath, ...pipelines.map(pipeline => publicPath + '/' + pipeline));
+        }
+      }
+    }
+  }
+  if (!owner) children.push(...pipelines.map(pipeline => independentRoot + '/' + pipeline));
+  return {roots, children, values, faults};
+}
+
+function auditOwner(inventory, raw, owner) {
+  const expected = required(owner);
+  const result = auditNativeOwners(inventory, raw, expected.roots, expected.children);
+  const output = new Map(expected.roots.map(root => [root, '']));
+  const preflights = new Set();
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event.Action === 'output' && output.has(event.Test)) {
+      assert.equal(typeof event.Output, 'string', 'invalid native CPU observation');
+      output.set(event.Test, output.get(event.Test) + event.Output);
+    }
+    if (event.Action !== 'run' || !expected.children.includes(event.Test)) continue;
+    const root = event.Test.split('/')[0];
+    const observation = output.get(root);
+    const flags = observation.match(/AVX512F=1 AVX512DQ=1 AVX512BW=1 AVX512VL=1 OSXSAVE=1 XCR0=([0-9a-f]+)\b/);
+    assert.ok(flags, 'missing current native F/DQ/BW/VL or OS state: ' + root);
+    assert.equal(BigInt('0x' + flags[1]) & 0xe6n, 0xe6n, 'incomplete native XCR0: ' + root);
+    assert.ok(observation.includes('PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK'),
+      'original native conversion opcodes did not complete before runtime: ' + root);
+    preflights.add(root);
+  }
+  assert.equal(preflights.size, expected.roots.length, 'missing actual native conversion preflight');
+  return {...result, owner, values: expected.values, faults: expected.faults, preflights: preflights.size};
+}
+
+function readOwner(directory, owner, head) {
+  const context = JSON.parse(fs.readFileSync(path.join(directory, 'context.json'), 'utf8'));
+  assert.deepEqual(Object.keys(context).sort(), ['head', 'owner', 'schema'], 'unknown native owner context fields');
+  assert.equal(context.schema, 1, 'invalid native owner context schema');
+  assert.equal(context.owner, owner, 'native receipt borrowed another partition');
+  assert.match(head, /^[0-9a-f]{40}$/, 'invalid current source identity');
+  assert.equal(context.head, head, 'native receipt is not the current checked-out source');
+  return {...auditOwner(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'), owner), head};
+}
+
+function auditComplete(directories, head) {
+  assert.equal(directories.length, owners, 'missing complete native owner artifacts');
+  const seen = new Set(), receipts = [];
+  for (const directory of directories) {
+    const context = JSON.parse(fs.readFileSync(path.join(directory, 'context.json'), 'utf8'));
+    assert.ok(Number.isInteger(context.owner) && context.owner >= 0 && context.owner < owners,
+      'invalid complete native partition');
+    assert.ok(!seen.has(context.owner), 'duplicated native partition artifact');
+    seen.add(context.owner);
+    // Reaudit the complete raw stream and fresh inventory, not a printed
+    // success string, cached aggregate or self-declared receipt counts.
+    receipts.push(readOwner(directory, context.owner, head));
+  }
+  assert.deepEqual([...seen].sort(), [0, 1, 2, 3, 4, 5, 6, 7], 'incomplete native owner union');
+  for (const [field, count] of [['values', 692], ['faults', 222]]) {
+    const consumed = new Array(count).fill(0);
+    for (const receipt of receipts) {
+      for (const [start, end] of receipt[field]) {
+        for (let index = start; index < end; index++) consumed[index]++;
+      }
+    }
+    assert.ok(consumed.every(count => count === 1), 'native partitions overlap or omit ' + field);
+  }
+  return {head, owners, roots: receipts.reduce((sum, receipt) => sum + receipt.roots, 0),
+    children: receipts.reduce((sum, receipt) => sum + receipt.children, 0),
+    passed: receipts.reduce((sum, receipt) => sum + receipt.passed, 0),
+    valueKernels: 692, faultKernels: 222, skipped: 0, incomplete: 0};
+}
+
+function artifactDirectories(root) {
+  const found = [];
+  for (const entry of fs.readdirSync(root, {withFileTypes: true})) {
+    assert.ok(!entry.isSymbolicLink(), 'native artifacts cannot redirect source receipts');
+    if (!entry.isDirectory()) continue;
+    const directory = path.join(root, entry.name);
+    assert.ok(fs.existsSync(path.join(directory, 'context.json')), 'unrecognized native owner artifact');
+    found.push(directory);
+  }
+  return found;
+}
+
+module.exports = {required, auditOwner, readOwner, auditComplete};
+
+if (require.main === module) {
+  const [command, argument, directory] = process.argv.slice(2);
+  if (command === 'roots') {
+    process.stdout.write(required(Number(argument)).roots.join('|') + '\n');
+  } else {
+    const head = execFileSync('git', ['rev-parse', 'HEAD'], {encoding: 'utf8'}).trim();
+    const result = command === 'owner' ? readOwner(directory, Number(argument), head) :
+      command === 'complete' ? auditComplete(artifactDirectories(argument), head) : null;
+    assert.ok(result, 'unknown native conversion audit command');
+    process.stdout.write(JSON.stringify(result) + '\n');
+  }
+}
diff --git a/.github/scripts/audit-packed-reduction-native.cjs b/.github/scripts/audit-packed-reduction-native.cjs
new file mode 100644
index 000000000..9ee127520
--- /dev/null
+++ b/.github/scripts/audit-packed-reduction-native.cjs
@@ -0,0 +1,134 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {execFileSync} = require('node:child_process');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const owners = 4;
+const pipelines = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+
+function batches(count, limit, owner) {
+  assert.ok(Number.isInteger(owner) && owner >= 0 && owner < owners, 'invalid native reduction owner');
+  const selected = [];
+  for (let start = 0, batch = 0; start < count; start += limit, batch++) {
+    if (batch % owners === owner) selected.push([start, Math.min(start + limit, count)]);
+  }
+  assert.ok(selected.length > 0, 'empty native reduction partition');
+  return selected;
+}
+
+function required(owner) {
+  const values = batches(258, 64, owner), faults = batches(37, 8, owner);
+  const roots = ['Values', 'DeadFaults'].map(family =>
+    'TestCrossLinuxRuntimeMatrixX86PackedReductionNative' + family + 'Part' + owner);
+  const children = [];
+  for (const [root, selected, originals] of [
+    [roots[0], values, ['original_go_named', 'original_go_raw']],
+    [roots[1], faults, ['original_go_opcode_reference']],
+  ]) {
+    for (const [start] of selected) {
+      const batch = root + '/batch-' + String(start).padStart(4, '0');
+      children.push(batch, ...originals.map(original => batch + '/' + original));
+      for (const spelling of ['named', 'raw']) {
+        const source = batch + '/' + spelling;
+        children.push(source);
+        for (const api of ['text', 'module', 'Go']) {
+          const publicPath = source + '/' + api;
+          children.push(publicPath, ...pipelines.map(pipeline => publicPath + '/' + pipeline));
+        }
+      }
+    }
+  }
+  return {roots, children, values, faults};
+}
+
+function auditOwner(inventory, raw, owner) {
+  const expected = required(owner);
+  const result = auditNativeOwners(inventory, raw, expected.roots, expected.children);
+  const output = new Map(expected.roots.map(root => [root, '']));
+  const preflights = new Set();
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    if (event.Action === 'output' && output.has(event.Test)) {
+      assert.equal(typeof event.Output, 'string', 'invalid native reduction CPU observation');
+      output.set(event.Test, output.get(event.Test) + event.Output);
+    }
+    if (event.Action !== 'run' || !expected.children.includes(event.Test)) continue;
+    const root = event.Test.split('/')[0], observation = output.get(root);
+    const flags = observation.match(/SSE3=1 SSE41=1 AVX=1 OSXSAVE=1 XCR0=([0-9a-f]+)\b/);
+    assert.ok(flags, 'missing current native SSE3/SSE4.1/AVX or OS state: ' + root);
+    assert.equal(BigInt('0x' + flags[1]) & 6n, 6n, 'incomplete native XCR0: ' + root);
+    assert.ok(observation.includes('PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK members=fff'),
+      'all12 original native reduction opcodes did not complete before runtime: ' + root);
+    preflights.add(root);
+  }
+  assert.equal(preflights.size, expected.roots.length, 'missing actual native reduction preflight');
+  return {...result, owner, values: expected.values, faults: expected.faults, preflights: preflights.size};
+}
+
+function readOwner(directory, owner, head) {
+  const context = JSON.parse(fs.readFileSync(path.join(directory, 'context.json'), 'utf8'));
+  assert.deepEqual(Object.keys(context).sort(), ['head', 'owner', 'schema'], 'unknown native context fields');
+  assert.equal(context.schema, 1, 'invalid native context schema');
+  assert.equal(context.owner, owner, 'native reduction receipt borrowed another partition');
+  assert.match(head, /^[0-9a-f]{40}$/, 'invalid current source identity');
+  assert.equal(context.head, head, 'native reduction receipt is not the current checked-out source');
+  return {...auditOwner(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'), owner), head};
+}
+
+function auditComplete(directories, head) {
+  assert.equal(directories.length, owners, 'missing complete native reduction artifacts');
+  const seen = new Set(), receipts = [];
+  for (const directory of directories) {
+    const context = JSON.parse(fs.readFileSync(path.join(directory, 'context.json'), 'utf8'));
+    assert.ok(Number.isInteger(context.owner) && context.owner >= 0 && context.owner < owners,
+      'invalid complete native reduction partition');
+    assert.ok(!seen.has(context.owner), 'duplicate native reduction artifact');
+    seen.add(context.owner);
+    receipts.push(readOwner(directory, context.owner, head));
+  }
+  assert.deepEqual([...seen].sort(), [0, 1, 2, 3], 'incomplete native reduction union');
+  for (const [field, count] of [['values', 258], ['faults', 37]]) {
+    const consumed = new Array(count).fill(0);
+    for (const receipt of receipts) {
+      for (const [start, end] of receipt[field]) {
+        for (let index = start; index < end; index++) consumed[index]++;
+      }
+    }
+    assert.ok(consumed.every(count => count === 1), 'native reduction partitions overlap or omit ' + field);
+  }
+  return {head, owners, roots: receipts.reduce((sum, receipt) => sum + receipt.roots, 0),
+    children: receipts.reduce((sum, receipt) => sum + receipt.children, 0),
+    passed: receipts.reduce((sum, receipt) => sum + receipt.passed, 0),
+    valueKernels: 258, faultKernels: 37, skipped: 0, incomplete: 0};
+}
+
+function artifactDirectories(root) {
+  const found = [];
+  for (const entry of fs.readdirSync(root, {withFileTypes: true})) {
+    assert.ok(!entry.isSymbolicLink(), 'native artifacts cannot redirect source receipts');
+    if (!entry.isDirectory()) continue;
+    const directory = path.join(root, entry.name);
+    assert.ok(fs.existsSync(path.join(directory, 'context.json')), 'unrecognized native owner artifact');
+    found.push(directory);
+  }
+  return found;
+}
+
+module.exports = {required, auditOwner, readOwner, auditComplete};
+
+if (require.main === module) {
+  const [command, argument, directory] = process.argv.slice(2);
+  if (command === 'roots') {
+    process.stdout.write(required(Number(argument)).roots.join('|') + '\n');
+  } else {
+    const head = execFileSync('git', ['rev-parse', 'HEAD'], {encoding: 'utf8'}).trim();
+    const result = command === 'owner' ? readOwner(directory, Number(argument), head) :
+      command === 'complete' ? auditComplete(artifactDirectories(argument), head) : null;
+    assert.ok(result, 'unknown native reduction audit command');
+    process.stdout.write(JSON.stringify(result) + '\n');
+  }
+}
diff --git a/.github/scripts/audit-private-leave-native.cjs b/.github/scripts/audit-private-leave-native.cjs
new file mode 100644
index 000000000..7586d84db
--- /dev/null
+++ b/.github/scripts/audit-private-leave-native.cjs
@@ -0,0 +1,112 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+const {requireIA32Images} = require('./audit-integer-native-families.cjs');
+
+const root = 'TestCrossLinuxRuntimeMatrixX86LeavePrivateEmitterWidthsAndFlags';
+const architectures = ['amd64', '386'];
+const pipelines = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const groups = architectures.map(arch => root + '/' + arch);
+const leaves = groups.flatMap(group => pipelines.map(pipeline => group + '/' + pipeline));
+const children = [...groups, ...leaves];
+const hostPrefix = 'IA32 direct host:';
+const sdkPrefix = 'actual LEA source/object receipt:';
+const markerPrefix = 'private LEAVE numerical completion arch=';
+const host = /IA32 direct host: linux\/amd64 kernel=x86_64 CPUsha=[a-f0-9]{64} mapsha=[a-f0-9]{64}\b/g;
+
+function requireSDK(output, arch) {
+  const sdk = new RegExp('actual LEA source/object receipt: SDK=go[1-9][0-9]*\\.[0-9]+(?:\\.[0-9]+)?' +
+    '(?:beta[0-9]+|rc[0-9]+)? target=linux/' + arch +
+    ' source=[a-f0-9]{64} driver=[a-f0-9]{64} object=[a-f0-9]{64}\\b', 'g');
+  assert.equal([...output.matchAll(sdk)].length, 1, 'private width lacks its actual SDK/source/object receipt');
+  assert.equal(output.split(sdkPrefix).length - 1, 1, 'duplicate or malformed SDK capture');
+}
+
+// The fixed numerical contract is deliberately not an original Go/native
+// stack ABI. Reuse the shared exact inventory, then bind every live owner to
+// its real host, selected SDK, IA32 image and complete numerical execution.
+function auditPrivateLEAVE(inventory, raw) {
+  const result = auditNativeOwners(inventory, raw, [root], children);
+  const outputs = new Map([root, ...children].map(name => [name, '']));
+  const states = new Map();
+  let started = false, complete = false;
+  for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+    const event = JSON.parse(line);
+    assert.ok(!complete, 'private LEAVE event after complete package');
+    if (event.Action === 'build-output' && event.ImportPath && !event.Test) continue;
+    if (!event.Test) {
+      assert.ok(['start', 'output', 'pass'].includes(event.Action), 'unknown private-width package action');
+      if (event.Action === 'start') {
+        assert.ok(!started, 'duplicate private-width package start');
+        started = true;
+      } else {
+        assert.ok(started, 'private-width output/terminal before package start');
+        if (event.Action === 'output') assert.equal(typeof event.Output, 'string');
+        if (event.Action === 'pass') complete = true;
+      }
+      continue;
+    }
+    assert.ok(started, 'private-width test before actual package start');
+    assert.ok(['run', 'output', 'pass'].includes(event.Action), 'unknown private-width test action');
+    const arch = event.Test.split('/')[1], group = root + '/' + arch;
+    if (event.Action === 'run') {
+      assert.ok(!states.has(event.Test), 'private-width test restarted after its first lifecycle');
+      states.set(event.Test, 'running');
+      if (event.Test !== root) {
+        assert.equal([...outputs.get(root).matchAll(host)].length, 1, 'actual native host must precede every width');
+        if (leaves.includes(event.Test)) requireSDK(outputs.get(group), arch);
+      }
+      continue;
+    }
+    assert.equal(states.get(event.Test), 'running', 'private-width observation outside live owner');
+    if (event.Action === 'output') {
+      assert.equal(typeof event.Output, 'string');
+      outputs.set(event.Test, outputs.get(event.Test) + event.Output);
+      if (event.Test === root && [...outputs.get(root).matchAll(host)].length > 1) {
+        assert.ok(groups.every(group => states.get(group) === 'passed'), 'final host preceded a complete actual width');
+      }
+      continue;
+    }
+    states.set(event.Test, 'passed');
+    const output = outputs.get(event.Test);
+    if (event.Test === root) {
+      assert.equal([...output.matchAll(host)].length, 2, 'private LEAVE requires actual native host brackets');
+      assert.equal(output.split(hostPrefix).length - 1, 2, 'duplicate or malformed actual host');
+      assert.ok(children.every(child => states.get(child) === 'passed'), 'root preceded a required numerical child');
+      assert.ok(!output.includes(sdkPrefix) && !output.includes(markerPrefix), 'root summary cannot replace SDK/leaf observations');
+    } else if (groups.includes(event.Test)) {
+      requireSDK(output, arch);
+      assert.ok(pipelines.every(pipeline => states.get(group + '/' + pipeline) === 'passed'), 'width parent preceded a real LLVM execution');
+      assert.ok(!output.includes(hostPrefix) && !output.includes(markerPrefix) && !output.includes('IA32 ELF'),
+        'width parent cannot replace actual host or leaf execution');
+    } else {
+      const marker = markerPrefix + arch + ': PRIVATE_LEAVE_128_WIDTH_VALUES_FLAGS_CANARIES_PASS\n';
+      assert.equal(output.split(marker).length - 1, 1, 'missing or duplicate complete private-width execution');
+      assert.equal(output.split(markerPrefix).length - 1, 1, 'foreign width or replacement marker');
+      assert.ok(!output.includes(hostPrefix) && !output.includes(sdkPrefix), 'leaf cannot replace host or SDK owner');
+      if (arch === '386') {
+        const {direct} = requireIA32Images(output, 1, '[]');
+        const commands = [...output.matchAll(/actual executable=([^\r\n]+) sha256=([a-f0-9]{64}) argv=\[\]/g)];
+        assert.equal(commands.length, 1, 'missing actual static IA32 executable observation');
+        assert.equal(commands[0][2], direct[0][2], 'actual IA32 executable hash changed');
+        assert.ok(commands[0].index < direct[0].index && direct[0].index < output.indexOf(marker),
+          'private IA32 completion preceded actual image execution');
+      } else {
+        assert.ok(!output.includes('IA32 ELF'), 'AMD64 execution cannot borrow an IA32 image');
+      }
+    }
+  }
+  return {...result, nativeHosts: 2, sdkCaptures: 2, llvmExecutions: 6,
+    staticIA32Executions: 3, privateNumericalOnly: true};
+}
+
+module.exports = {auditPrivateLEAVE};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditPrivateLEAVE(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-product-cmov.cjs b/.github/scripts/audit-product-cmov.cjs
new file mode 100644
index 000000000..44bce672f
--- /dev/null
+++ b/.github/scripts/audit-product-cmov.cjs
@@ -0,0 +1,36 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+// Product and wide AES execution are portable LLVM, not native AVX512.
+// CMOV additionally executes original Go opcode bytes. Keep all old programs.
+// Vector tests retain their original independent C values and named/raw source.
+// IFMA executes portable integer LLVM against its original independent C oracle,
+// not the original AVX512 instructions.
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86DwordProductIndependentWholeBytes',
+  'TestCrossLinuxRuntimeMatrixX86CMOVIndependentWholeBytes',
+  'TestCrossLinuxRuntimeMatrixX86AESFamilyWholeByteAliases',
+  'TestAMD64VectorTestRuntimeSemantics',
+  'TestAMD64IFMARuntimeSemantics',
+  'TestAMD64QwordBitLookupRuntimeSemantics',
+  'TestCrossLinuxRuntimeMatrixX86CMOVFPPartialCrossSlotWholeBytes',
+];
+const children = ['-O0', '-O2', 'IR_O2/backend_O2'].map(axis => roots[0] + '/' + axis)
+  .concat(['backend_O0', 'backend_O2', 'IR_O2/backend_O2'].map(axis => roots[1] + '/' + axis))
+  .concat(['-O0', '-O2', 'IR_O2/backend_O2'].map(axis => roots[2] + '/' + axis))
+  .concat(['named', 'raw'].flatMap(encoding =>
+    ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'].map(axis => roots[3] + '/' + encoding + '/' + axis)))
+  .concat([4, 5, 6].flatMap(index =>
+    ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'].map(axis => roots[index] + '/' + axis)));
+const auditProductCMOV = (inventory, raw) => auditNativeOwners(inventory, raw, roots, children);
+
+module.exports = {auditProductCMOV, roots, children};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditProductCMOV(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-scalar-bmi.cjs b/.github/scripts/audit-scalar-bmi.cjs
new file mode 100644
index 000000000..5c357e9ae
--- /dev/null
+++ b/.github/scripts/audit-scalar-bmi.cjs
@@ -0,0 +1,20 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = [
+  'TestAMD64BLSRuntimeSemantics',
+  'TestAMD64BEXTRRuntimeSemanticsAndFlags',
+  'TestAMD64BZHIRuntimeSemanticsAndFlags',
+];
+const auditScalarBMI = (inventory, raw) => auditNativeOwners(inventory, raw, roots, []);
+
+module.exports = {auditScalarBMI, roots};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditScalarBMI(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-scalar-reciprocal-native.cjs b/.github/scripts/audit-scalar-reciprocal-native.cjs
new file mode 100644
index 000000000..41cacaa8c
--- /dev/null
+++ b/.github/scripts/audit-scalar-reciprocal-native.cjs
@@ -0,0 +1,27 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditSSEAVXNativeFamilies} = require('./audit-duplicate-native-families.cjs');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNative386',
+];
+const originalEvidence = 'actual original Go scalar estimates: 20 aliases × 24 bit patterns × 64 MXCSR profiles = 30720 whole32/FLAGS/DF/MXCSR/canary outcomes; independent scalar references, no AVX512/Z execution claim\n';
+
+function pipelineEvidence(arch) {
+  return `scalar estimates native arch=${arch} live=20 dead=4 whole32-outcomes=30720 fault-processes=40; SSE/AVX actual scalar opcodes, no AVX512/Z transport\n`;
+}
+
+function auditScalarReciprocalNative(inventory, raw) {
+  return auditSSEAVXNativeFamilies(inventory, raw, roots, pipelineEvidence, originalEvidence);
+}
+
+module.exports = {auditScalarReciprocalNative};
+if (require.main === module) {
+  const directory = process.argv[2];
+  const result = auditScalarReciprocalNative(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/audit-unlocked-native.cjs b/.github/scripts/audit-unlocked-native.cjs
new file mode 100644
index 000000000..a647114d9
--- /dev/null
+++ b/.github/scripts/audit-unlocked-native.cjs
@@ -0,0 +1,21 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86UnlockedScalarRMWNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86UnlockedScalarRMWNative386'];
+const children = roots.flatMap(root => ['text', 'module', 'Go'].map(api => root + '/' + api));
+
+function auditNativeUnlocked(inventory, raw) {
+  return auditNativeOwners(inventory, raw, roots, children);
+}
+module.exports = {auditNativeUnlocked, roots, children};
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one actual unlocked native report directory required');
+  const directory = process.argv[2];
+  const result = auditNativeUnlocked(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
diff --git a/.github/scripts/audit-value-fault-priority.cjs b/.github/scripts/audit-value-fault-priority.cjs
new file mode 100644
index 000000000..08c6acc16
--- /dev/null
+++ b/.github/scripts/audit-value-fault-priority.cjs
@@ -0,0 +1,27 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+// These execute portable LLVM memory semantics on a real Linux host. They do
+// not claim original-Go or physical AVX512 instruction execution.
+const roots = ['TestX86VectorValueNativePortableFaults', 'TestGoX86NumericalSBReadRuntimeFaultCorePolicy'];
+const children = ['text', 'module', 'Go'].map(api => roots[0]+'/'+api)
+  .concat(['386/mutable', '386/width', 'amd64/mutable', 'amd64/width', 'amd64/local']
+    .map(role => roots[1]+'/'+role));
+
+function auditValueFaultPriority(inventory, raw) {
+  return auditNativeOwners(inventory, raw, roots, children);
+}
+
+module.exports = {auditValueFaultPriority, roots, children};
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one actual portable fault report directory required');
+  const directory = process.argv[2];
+  const result = auditValueFaultPriority(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result, null, 2)+'\n');
+}
diff --git a/.github/scripts/audit-x87-native.cjs b/.github/scripts/audit-x87-native.cjs
new file mode 100644
index 000000000..47934e347
--- /dev/null
+++ b/.github/scripts/audit-x87-native.cjs
@@ -0,0 +1,43 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const {auditNativeOwners} = require('./audit-native-owners.cjs');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86X87SignedI64IdentityOriginalGoAndLLVM',
+  'TestAMD64X87ConditionalMoveRuntimeConditions',
+  'TestX86RawX87ClearExceptionRuntimeSemantics',
+  'TestX86RawX87SoftwareClearPreservesAllStatusFields',
+  'TestCrossLinuxRuntimeMatrixX86X87ScopedRoundingOriginalGoAndLLVM',
+];
+const children = [];
+for (const arch of ['amd64', '386']) {
+  const parent = `${roots[0]}/${arch}`;
+  children.push(parent);
+  for (const api of ['text', 'module', 'Go']) {
+    for (const optimized of [false, true]) {
+      for (const backend of [0, 2]) children.push(`${parent}/${api}/IR_O2=${optimized}/backend-O${backend}`);
+    }
+  }
+}
+for (const api of ['text', 'module', 'Go']) {
+  const parent = `${roots[4]}/${api}`;
+  children.push(parent);
+  for (const optimized of [false, true]) {
+    for (const backend of [0, 2]) children.push(`${parent}/IR_O2=${optimized}/backend-O${backend}`);
+  }
+}
+
+function auditNativeX87(inventory, raw) {
+  return auditNativeOwners(inventory, raw, roots, children);
+}
+
+module.exports = {auditNativeX87, roots, children};
+
+if (require.main === module) {
+  assert.equal(process.argv.length, 3, 'one actual native x87 report directory required');
+  const directory = process.argv[2];
+  const result = auditNativeX87(fs.readFileSync(path.join(directory, 'inventory.log'), 'utf8'),
+    fs.readFileSync(path.join(directory, 'raw.jsonl'), 'utf8'));
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+}
diff --git a/.github/scripts/diagnostic-qualification.cjs b/.github/scripts/diagnostic-qualification.cjs
new file mode 100644
index 000000000..317c4c74d
--- /dev/null
+++ b/.github/scripts/diagnostic-qualification.cjs
@@ -0,0 +1,35 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+// Retained to audit receipts from the retired fork diagnostic workflow.
+const finalRequiredNeeds = [
+  'ownership', 'native-x86-oracles', 'sdk-priority', 'arm64-fallback-cross-priority',
+  'lock-native-priority', 'unlocked-rmw-native-priority', 'vector-value-fault-priority',
+  'packed-conversion-native-complete', 'packed-reduction-native-complete', 'complete-windows',
+];
+
+// Scheduling Windows after a failed predecessor discovers its real failures;
+// it cannot supply success for that predecessor. GitHub's current-run needs
+// observations remain the only input, never a job's self-reported outputs.
+function qualifyDiagnosticNeeds(needs) {
+  assert.ok(needs && typeof needs === 'object' && !Array.isArray(needs),
+    'missing actual diagnostic dependency observations');
+  assert.deepEqual(Object.keys(needs).sort(), finalRequiredNeeds.slice().sort(),
+    'diagnostic qualification requires every original gate and complete Windows');
+  for (const name of finalRequiredNeeds) {
+    const observation = needs[name];
+    assert.ok(observation && typeof observation === 'object' && !Array.isArray(observation),
+      'malformed actual dependency result: ' + name);
+    assert.ok(Object.hasOwn(observation, 'result'), 'absent actual dependency result: ' + name);
+    assert.equal(observation.result, 'success', 'required diagnostic gate did not succeed: ' + name);
+  }
+  return {schema: 1, successfulJobs: finalRequiredNeeds.slice()};
+}
+
+module.exports = {qualifyDiagnosticNeeds};
+if (require.main === module) {
+  const input = process.env.DIAGNOSTIC_NEEDS_JSON;
+  assert.equal(typeof input, 'string', 'actual GitHub needs context is required');
+  const result = qualifyDiagnosticNeeds(JSON.parse(input));
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
diff --git a/.github/scripts/node22-setup.cjs b/.github/scripts/node22-setup.cjs
new file mode 100644
index 000000000..7871609c2
--- /dev/null
+++ b/.github/scripts/node22-setup.cjs
@@ -0,0 +1,16 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+
+function requireNode22Setup(step) {
+  assert.equal((step.match(/^(?:        |      - )uses: \.\/\.github\/actions\/setup-node22$/gm) || []).length, 1,
+    'one exact verified Node 22 installer is required');
+  assert.equal((step.match(/^(?:        |      - )uses:/gm) || []).length, 1,
+    'another installer cannot share or replace the required Node step');
+  assert.equal((step.match(/^        timeout-minutes: 10$/gm) || []).length, 1,
+    'Node installation has its own bounded deadline');
+  assert.doesNotMatch(step, /^(?:        |      - )(?:if|continue-on-error|with):|\|\|\s*true|node-version:/m,
+    'the required exact runtime cannot be skipped, weakened or overridden');
+}
+
+module.exports = {requireNode22Setup};
diff --git a/.github/scripts/priority-aes-family-fresh-leases.test.cjs b/.github/scripts/priority-aes-family-fresh-leases.test.cjs
new file mode 100644
index 000000000..e7afc8cb5
--- /dev/null
+++ b/.github/scripts/priority-aes-family-fresh-leases.test.cjs
@@ -0,0 +1,55 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const {test} = require('node:test');
+
+const source = fs.readFileSync('amd64_aes_family_fixed_local_test.go', 'utf8');
+
+test('the complete AES bound-consumer root prepares the process-owned compiler cache', () => {
+  assert.match(source, /func TestX86AESFamilyActualBoundFixedLocalConsumers\(t \*testing\.T\) \{\s*goAMD64FramePrepareOwnedToolCache\(t\)/);
+});
+
+test('the cache helper selects owned artifacts and prepares tools before source leases', () => {
+  const tools = fs.readFileSync('amd64_fixed_local_conversion_tool_cache_test.go', 'utf8');
+  const helper = tools.match(/^func goAMD64FramePrepareOwnedToolCache\(t \*testing\.T\) \{\n([\s\S]*?)^\}/m);
+  assert.ok(helper, 'the real cache owner must exist');
+  // Check the preparation boundary. Actual ownership, cleanup, source
+  // independence and concurrent close are exercised by the Go lifecycle tests.
+  let previous = -1;
+  for (const call of [
+    'fixedLocalProcessToolCache.directory()',
+    't.Setenv("GOCACHE", cache)',
+    'goAMD64FrameSourceFixture(t)',
+    'fixedLocalConversionPrepareToolCache(t, request)',
+  ]) {
+    const offset = helper[1].indexOf(call);
+    assert.ok(offset > previous, `missing or reordered preparation: ${call}`);
+    previous = offset;
+  }
+  assert.match(helper[1], /cache, err := fixedLocalProcessToolCache\.directory\(\)\s*if err != nil \{\s*t\.Fatal\(err\)\s*\}/);
+});
+
+test('all AES targets consume independent original source leases for all three APIs', () => {
+  assert.match(source, /fixedLocalFreshAPIs\(t, pkg, request, options, \[\]string\{"Translate", "Module", "GoModule"\}/);
+  assert.doesNotMatch(source, /requireGoAMD64FrameCapture\(|runtimeOracleStageContext\(|\.BindFixedLocal\(|fixedLocalAPIs\(/);
+});
+
+test('AES retains exactly twelve original names, two source addresses, two targets and one object path', () => {
+  const oracle = fs.readFileSync('amd64_aes_family_effects_test.go', 'utf8');
+  const names = oracle.match(/var x86AESOracleNames = \[\]string\{([^}]+)\}/);
+  assert.ok(names);
+  assert.deepEqual([...names[1].matchAll(/"([^"]+)"/g)].map(match => match[1]),
+    ['AESENC', 'AESENCLAST', 'AESDEC', 'AESDECLAST', 'AESIMC', 'AESKEYGENASSIST',
+      'VAESENC', 'VAESENCLAST', 'VAESDEC', 'VAESDECLAST', 'VAESIMC', 'VAESKEYGENASSIST']);
+  const builder = source.slice(source.indexOf('\tvar assembly, declarations'), source.indexOf('\tfor _, target :='));
+  assert.equal(crypto.createHash('sha256').update(builder).digest('hex'),
+    'ccc5fe309b626943f3f92ef9ecc847e3f009aa66521eb395a4adcc6b6a63ace9');
+  assert.match(builder, /\[\]string\{"16\(SP\)", "tmp-144\(SP\)"\}/);
+  assert.deepEqual([...source.matchAll(/\{"([^"\n]+\/amd64)", "([^"\n]+)"\}/g)]
+    .map(match => match.slice(1)), [['linux/amd64', 'x86_64-unknown-linux-gnu'], ['darwin/amd64', 'x86_64-apple-darwin']]);
+  assert.equal((source.match(/compileLLVMToObject\(/g) || []).length, 1);
+  assert.match(source, /compileLLVMToObject\(t, llc, target\.triple, "aes-native-local\.ll", "aes-native-local\.o", ir\)/);
+  assert.doesNotMatch(source, /x86MulDivRoundOptimize|"-O[0123]"|t\.Skip|t\.Parallel/);
+});
diff --git a/.github/scripts/priority-arm64-fallback.test.cjs b/.github/scripts/priority-arm64-fallback.test.cjs
new file mode 100644
index 000000000..e430dff59
--- /dev/null
+++ b/.github/scripts/priority-arm64-fallback.test.cjs
@@ -0,0 +1,85 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+const { auditARM64Fallback } = require('./audit-arm64-fallback.cjs');
+
+const root = 'TestFallbackARM64WideFrameCompilesWithLLVM22';
+const pkg = 'github.com/xgo-dev/plan9asm/cmd/plan9asmll';
+const names = [root, ...['darwin', 'linux', 'windows', 'native_complete-argument_oracle']
+  .map(child => `${root}/${child}`)];
+const events = [
+  ...names.map(Test => ({ Action: 'run', Test, Package: pkg })),
+  ...names.slice().reverse().map(Test => ({ Action: 'pass', Test, Package: pkg })),
+  { Action: 'pass', Package: pkg },
+];
+const raw = value => value.map(event => JSON.stringify(event)).join('\n') + '\n';
+
+test('mandatory ARM64 runtime axes supplement the exhaustive runner audit', () => {
+  assert.deepEqual(auditARM64Fallback(raw(events)), {
+    roots: 1, children: 4, passed: 5, skipped: 0, incomplete: 0,
+  });
+});
+
+test('successful Go dependency build output is not a failed runtime axis', () => {
+  const dependency = { Action: 'build-output', ImportPath: 'example.invalid/dependency', Output: 'compiler diagnostic\n' };
+  assert.equal(auditARM64Fallback(raw([dependency, ...events])).children, 4);
+});
+
+test('the selected cross scope binds the actual Node auditor through the shared observer', () => {
+  const source = fs.readFileSync('cmd/plan9asmtest/ci_scope.go', 'utf8');
+  assert.match(source, /if os\.Getenv\("PLAN9ASM_CROSS_EXEC"\) == "1" && !cfg\.Module \{\s*if err := captureCINodeDependency\(ctx, cfg, stem, origins\); err != nil/);
+});
+
+test('missing, skipped, duplicated or incomplete execution cannot count as covered', () => {
+  const native = names[4];
+  const mutations = [
+    events.filter(event => event.Test !== native),
+    events.filter(event => !(event.Test === native && event.Action === 'pass')),
+    events.filter(event => event.Test),
+    events.map(event => event.Test === native && event.Action === 'pass' ? { ...event, Action: 'skip' } : event),
+    events.map(event => !event.Test ? { ...event, Action: 'fail' } : event),
+    events.map(event => ({ ...event, Package: pkg + '/foreign' })),
+    [events[0], ...events],
+    [...events.slice(0, -1), events[8], events.at(-1)],
+    [...events, events[0]],
+    [{ Action: 'build-output', ImportPath: '', Output: 'unidentified' }, ...events],
+    [{ Action: 'build-output', ImportPath: 'dep', Test: root }, ...events],
+    [{ Action: 'build-fail', ImportPath: 'dep' }, ...events],
+  ];
+  for (const mutation of mutations) {
+    assert.throws(() => auditARM64Fallback(raw(mutation)));
+  }
+  assert.throws(() => auditARM64Fallback('{not JSON}\n'));
+  assert.throws(() => auditARM64Fallback(''));
+});
+
+function requireDriver(source) {
+  assert.match(source, /PLAN9ASM_CROSS_EXEC:-\} != 1/);
+  assert.match(source, /root=TestFallbackARM64WideFrameCompilesWithLLVM22\n/);
+  assert.match(source, /go run \.\/cmd\/plan9asmtest -dir cmd\/plan9asmll -out/);
+  assert.match(source, /-ci-selector "\^\$\{root\}\$" -ci-isolate-root "\$root"/);
+  assert.match(source, /-shards 2 -timeout 5m/);
+  assert.match(source, /for owner in 0 1; do/);
+  assert.match(source, /-verify-ci-partitions "\$base\/owners"/);
+  assert.match(source, /node \.github\/scripts\/audit-arm64-fallback\.cjs/);
+  assert.match(source, /cross-runtime-owner-0\/root-0000\.stdout/);
+  assert.doesNotMatch(source, /continue-on-error|\|\| true|-run[= ]|timeout (?:10|20|30)m/);
+}
+
+test('ARM64 driver keeps actual nested-module discovery and strict fresh verification', () => {
+  const source = fs.readFileSync('scripts/test-arm64-fallback-ci.sh', 'utf8');
+  requireDriver(source);
+  for (const [before, after] of [
+    ['-dir cmd/plan9asmll', '-dir .'],
+    ['^${root}$', '${root}'],
+    ['for owner in 0 1;', 'for owner in 0;'],
+    ['-verify-ci-partitions', '-verify-removed'],
+    ['audit-arm64-fallback.cjs', 'audit-removed.cjs'],
+    ['PLAN9ASM_CROSS_EXEC:-} != 1', 'PLAN9ASM_CROSS_EXEC:-} != 0'],
+    ['-timeout 5m', '-timeout 20m'],
+  ]) {
+    const changed = source.replace(before, after);
+    assert.notEqual(changed, source);
+    assert.throws(() => requireDriver(changed));
+  }
+});
diff --git a/.github/scripts/priority-blend-minpos-native.test.cjs b/.github/scripts/priority-blend-minpos-native.test.cjs
new file mode 100644
index 000000000..d9d6c6f83
--- /dev/null
+++ b/.github/scripts/priority-blend-minpos-native.test.cjs
@@ -0,0 +1,187 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+// Independent of the auditor and production instruction maps.
+const roots = ['TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaultsAMD64',
+  'TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaults386'];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+const forms = [['BLENDVPS', 'X'], ['VBLENDVPS', 'X'], ['VBLENDVPS', 'Y'],
+  ['BLENDVPD', 'X'], ['VBLENDVPD', 'X'], ['VBLENDVPD', 'Y'],
+  ['PBLENDVB', 'X'], ['VPBLENDVB', 'X'], ['VPBLENDVB', 'Y'],
+  ['PHMINPOSUW', 'X'], ['VPHMINPOSUW', 'X']];
+const parents = roots.flatMap(root => axes.map(axis => root + '/' + axis));
+const leaves = parents.flatMap(parent => forms.flatMap(([op, bank]) => ['live', 'dead'].flatMap(role =>
+  [0, 1].map(zero => `${parent}/${op}/${bank}/${role}/maskzero=${zero}`))));
+const names = [...roots, ...parents, ...leaves];
+const inventory = roots.join('\n') + '\nok\tgithub.com/xgo-dev/plan9asm\n';
+const digest = 'a'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${digest} mapsha=${digest}\n`;
+const preflight = 'blend/minimum actual native SSE4.1=1 AVX2=1\n';
+const marker = 'blend/minimum original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0\n';
+const image = `native oracle static IA32 ELF bytes=4096 sha256=${digest}\n`;
+const sdk = arch => `actual LEA source/object receipt: SDK=go1.27.2 target=linux/${arch} source=${digest} driver=${digest} object=${digest}\n`;
+const event = (Action, Test, Output) => ({Action, Package: 'github.com/xgo-dev/plan9asm',
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    events.push(event('run', root), event('output', root, host + preflight + sdk(arch)));
+    for (const axis of axes) {
+      const parent = root + '/' + axis;
+      events.push(event('run', parent));
+      if (arch === '386') events.push(event('output', parent, image));
+      for (const leaf of leaves.filter(name => name.startsWith(parent + '/'))) {
+        events.push(event('run', leaf), event('output', leaf, marker), event('pass', leaf));
+      }
+      events.push(event('pass', parent));
+    }
+    events.push(event('output', root, host), event('pass', root));
+  }
+  events.push(event('pass'));
+  return events;
+}
+
+function audit(events = completeEvents(), discovered = inventory) {
+  assert.ok(fs.existsSync('.github/scripts/audit-blend-minpos-native.cjs'),
+    'original blend/minimum native scope lacks an explicit strict auditor');
+  return require('./audit-blend-minpos-native.cjs').auditBlendMinposNative(discovered, serialize(events));
+}
+
+test('blend/minimum requires two roots, 264 complete native kernels and 5280 paired probes', () => {
+  assert.deepEqual(audit(), {roots: 2, children: 270, passed: 272, skipped: 0, incomplete: 0,
+    nativeHosts: 4, sdkCaptures: 2, isaPreflights: 2, staticIA32Images: 3,
+    kernelExecutions: 264, pairedProbes: 5280, directProbeProcesses: 10560});
+});
+
+test('blend/minimum rejects every missing duplicate failed skipped or incomplete lifecycle', () => {
+  audit();
+  for (const name of names) {
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === name && value.Action === 'pass'
+        ? {...value, Action} : value)), name + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const original = completeEvents();
+      const at = original.findIndex(value => value.Test === name && value.Action === Action);
+      assert.throws(() => audit(original.filter((_, index) => index !== at)), name + ' missing ' + Action);
+      original.splice(at, 0, original[at]);
+      assert.throws(() => audit(original), name + ' duplicate ' + Action);
+    }
+  }
+});
+
+test('blend/minimum binds all residues and zero-mask dead reads to their own actual completion', () => {
+  audit();
+  for (const leaf of leaves) {
+    for (const replacement of ['', marker + marker, marker.replace('probes 20', 'probes 19')]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === leaf && value.Output
+        ? {...value, Output: replacement} : value)), leaf);
+    }
+  }
+  for (const replacement of [marker.replace('failures 0', 'failures 1'), marker.replace('0x1f80', 'inherited'),
+    marker.replace('0x1f80', '0x21f80'), host + marker, preflight + marker, sdk('amd64') + marker, image + marker]) {
+    assert.throws(() => audit(completeEvents().map(value => value.Test === leaves[0] && value.Output
+      ? {...value, Output: replacement} : value)));
+  }
+  for (const target of [roots[0], parents[0]]) {
+    assert.throws(() => audit(completeEvents().map(value => value.Test === leaves[0] && value.Output
+      ? {...value, Test: target} : value)), 'summary is not actual leaf execution');
+  }
+});
+
+test('blend/minimum requires native host ISA and exact original Go source before every axis', () => {
+  audit();
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    for (const needle of [host, preflight, sdk(arch)]) {
+      for (const replacement of ['', needle + needle, needle.replace(digest, 'invalid'),
+        needle.replace('kernel=x86_64', 'kernel=aarch64'), needle.replace('SSE4.1=1', 'SSE4.1=0'),
+        needle.replace('AVX2=1', 'AVX2=0'), needle.replace('go1.27.2', 'go1.20.14'),
+        needle.replace('linux/' + arch, 'linux/arm64')]) {
+        if (replacement === needle) continue;
+        assert.throws(() => audit(completeEvents().map(value => value.Test === root && value.Output
+          ? {...value, Output: value.Output.replace(needle, replacement)} : value)), root + needle);
+      }
+    }
+    const lateSDK = completeEvents();
+    const at = lateSDK.findIndex(value => value.Test === root && value.Output?.includes(preflight));
+    lateSDK[at] = event('output', root, host + preflight);
+    lateSDK.splice(at + 2, 0, event('output', root, sdk(arch)));
+    assert.throws(() => audit(lateSDK), 'source capture after axis start');
+    const earlyPost = completeEvents();
+    const post = earlyPost.findLastIndex(value => value.Test === root && value.Output === host);
+    const [observation] = earlyPost.splice(post, 1);
+    const terminal = earlyPost.findIndex(value => value.Test === root + '/' + axes[2] && value.Action === 'pass');
+    earlyPost.splice(terminal, 0, observation);
+    assert.throws(() => audit(earlyPost), 'host bracket before final axis');
+  }
+  const otherSDK = completeEvents().map(value => value.Test === roots[1] && value.Output?.includes(' driver=')
+    ? {...value, Output: value.Output.replace(' driver=' + digest, ' driver=' + 'b'.repeat(64))} : value);
+  assert.throws(() => audit(otherSDK), 'the two owners must use the same actual Go driver');
+});
+
+test('blend/minimum IA32 images precede every actual leaf and cannot be emulated summaries', () => {
+  audit();
+  for (const parent of parents.filter(name => name.startsWith(roots[1] + '/'))) {
+    for (const replacement of ['', image + image, image.replace('4096', '0'), image.replace(digest, 'invalid'),
+      image.replace('static IA32', 'QEMU translated')]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === parent && value.Output
+        ? {...value, Output: replacement} : value)), parent);
+    }
+    const late = completeEvents();
+    const at = late.findIndex(value => value.Test === parent && value.Output === image);
+    const [observation] = late.splice(at, 1);
+    late.splice(at + 2, 0, observation);
+    assert.throws(() => audit(late), 'image inspected after first execution');
+  }
+});
+
+test('blend/minimum rejects foreign inventories events packages and out-of-lifecycle output', () => {
+  audit();
+  for (const discovered of ['', inventory + roots[0] + '\n', inventory.replace(roots[0], 'TestObjectsOnly')]) {
+    assert.throws(() => audit(completeEvents(), discovered));
+  }
+  for (const events of [completeEvents().slice(1), completeEvents().slice(0, -1),
+    [event('start'), ...completeEvents()], [...completeEvents(), event('pass')],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'})),
+    [event('output', undefined, '264 kernels passed')]]) assert.throws(() => audit(events));
+  for (const name of [roots[0], parents[0], leaves[0]]) {
+    const late = completeEvents();
+    const at = late.findIndex(value => value.Test === name && value.Action === 'pass');
+    late.splice(at + 1, 0, event('output', name, marker));
+    assert.throws(() => audit(late));
+  }
+});
+
+test('blend/minimum fixed leaves retain their own package and live root/axis lifecycle', () => {
+  audit();
+  for (const leaf of [leaves[0], leaves.at(-1)]) {
+    for (const Action of ['run', 'output', 'pass']) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === leaf && value.Action === Action
+        ? {...value, Package: 'foreign/package'} : value)), 'foreign leaf ' + Action);
+      assert.throws(() => audit(completeEvents().map(value => value.Test === leaf && value.Action === Action
+        ? {...value, Action: 'unrecognized'} : value)), 'unknown leaf ' + Action);
+    }
+    const parent = leaf.split('/').slice(0, 2).join('/');
+    for (const before of [leaf.split('/')[0], parent]) {
+      const events = completeEvents();
+      const own = events.filter(value => value.Test === leaf);
+      const others = events.filter(value => value.Test !== leaf);
+      const at = others.findIndex(value => value.Test === before && value.Action === 'run');
+      others.splice(at, 0, ...own);
+      assert.throws(() => audit(others), 'leaf before actual parent ' + before);
+    }
+    const events = completeEvents();
+    events.push(event('output', leaf, marker));
+    assert.throws(() => audit(events), 'leaf after completed package');
+  }
+  const foreign = completeEvents();
+  foreign.splice(4, 0, event('run', parents[0] + '/unknown/opcode'));
+  assert.throws(() => audit(foreign), 'unknown leaf cannot evade fixed ancestry');
+});
diff --git a/.github/scripts/priority-checkout-source-eol.test.cjs b/.github/scripts/priority-checkout-source-eol.test.cjs
new file mode 100644
index 000000000..14629cbc4
--- /dev/null
+++ b/.github/scripts/priority-checkout-source-eol.test.cjs
@@ -0,0 +1,106 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const test = require('node:test');
+
+const attributes = fs.readFileSync('.gitattributes', 'utf8');
+const source = 'package fixture\n\nconst assembly = `TEXT original(SB),4,$0-0\nRET\n`\n' +
+  'const oracle = `int main(void) { return 0; }\n`\nconst escaped = "\\r\\n"\n';
+const fixtures = {
+  'original.go': source,
+  'nested/original_test.go': source,
+  'original.s': 'TEXT original(SB),4,$0-0\nRET\n',
+  'nested/conformance.s': fs.readFileSync('testdata/conformance/amd64/conformance_amd64.s', 'utf8'),
+  'script.sh': '#!/bin/sh\nprintf "original\\n"\n',
+  'ordinary.txt': 'ordinary text\nsecond line\n',
+  'ordinary.asm': 'TEXT ordinary(SB),4,$0-0\nRET\n',
+  'downloaded/original.s': 'TEXT downloaded(SB),4,$0-0\r\nRET\r\n',
+};
+const digest = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+
+function checkoutFixture(rules) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-checkout-eol-'));
+  const environment = {...process.env};
+  for (const key of Object.keys(environment)) {
+    if (key.startsWith('GIT_')) delete environment[key];
+  }
+  Object.assign(environment, {
+    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: os.devNull, GIT_ATTR_NOSYSTEM: '1',
+  });
+  try {
+    const git = args => {
+      const result = spawnSync('git', ['-c', 'core.attributesFile=' + os.devNull,
+        '-c', 'core.hooksPath=' + os.devNull, '-c', 'commit.gpgsign=false',
+        '-c', 'user.name=Checkout fixture', '-c', 'user.email=fixture@example.invalid',
+        '-C', directory, ...args], {
+        env: environment, encoding: 'utf8', timeout: 5000,
+      });
+      assert.ifError(result.error);
+      assert.equal(result.status, 0, result.stderr);
+      return result.stdout;
+    };
+    git(['init', '--quiet']);
+    git(['config', '--local', 'core.autocrlf', 'true']);
+    git(['config', '--local', 'core.safecrlf', 'false']);
+    fs.writeFileSync(path.join(directory, '.gitattributes'), rules);
+    fs.writeFileSync(path.join(directory, '.gitignore'), 'downloaded/\n');
+    for (const [name, text] of Object.entries(fixtures)) {
+      const target = path.join(directory, name);
+      fs.mkdirSync(path.dirname(target), {recursive: true});
+      fs.writeFileSync(target, text);
+    }
+    git(['add', '.']);
+    git(['commit', '--quiet', '-m', 'original fixture']);
+    for (const name of Object.keys(fixtures)) {
+      if (!name.startsWith('downloaded/')) fs.unlinkSync(path.join(directory, name));
+    }
+    // This actually restores bytes through Git's worktree conversion, not a
+    // handcrafted CRLF replacement or a global user configuration change.
+    git(['checkout-index', '--all', '--force']);
+    return Object.fromEntries(Object.keys(fixtures).map(name =>
+      [name, fs.readFileSync(path.join(directory, name))]));
+  } finally {
+    fs.rmSync(directory, {recursive: true, force: true});
+  }
+}
+
+function requireOriginalSourceBytes(observed) {
+  for (const name of ['original.go', 'nested/original_test.go', 'original.s', 'nested/conformance.s']) {
+    assert.equal(digest(observed[name]), digest(Buffer.from(fixtures[name])),
+      'checkout must preserve complete original repository Go/ASM/C bytes: ' + name);
+    assert.equal(observed[name].includes(Buffer.from('\r\n')), false, name);
+  }
+  assert.equal(observed['script.sh'].toString(), fixtures['script.sh']);
+  for (const name of ['ordinary.txt', 'ordinary.asm']) {
+    assert.equal(observed[name].toString(), fixtures[name].replaceAll('\n', '\r\n'),
+      'control must prove actual autocrlf conversion outside the source policy: ' + name);
+  }
+  assert.equal(digest(observed['downloaded/original.s']), digest(Buffer.from(fixtures['downloaded/original.s'])),
+    'Git source policy must not normalize ignored external authority bytes');
+}
+
+test('actual autocrlf checkout preserves complete Go and ASM hashes without altering downloads', () => {
+  requireOriginalSourceBytes(checkoutFixture(attributes));
+});
+
+test('checkout policy rejects missing substituted or CRLF Go and ASM rules using real Git controls', () => {
+  const complete = '*.sh text eol=lf\n*.go text eol=lf\n*.s text eol=lf\n';
+  requireOriginalSourceBytes(checkoutFixture(complete));
+  for (const changed of [
+    complete.replace('*.go text eol=lf\n', ''),
+    complete.replace('*.go text', '*.notgo text'),
+    complete.replace('*.go text eol=lf', '*.go text eol=crlf'),
+    complete.replace('*.s text eol=lf\n', ''),
+    complete.replace('*.s text', '*.notasm text'),
+    complete.replace('*.s text eol=lf', '*.s text eol=crlf'),
+  ]) {
+    const observed = checkoutFixture(changed);
+    assert.equal(observed['ordinary.txt'].toString(), fixtures['ordinary.txt'].replaceAll('\n', '\r\n'));
+    assert.throws(() => requireOriginalSourceBytes(observed));
+  }
+});
diff --git a/.github/scripts/priority-completion.test.cjs b/.github/scripts/priority-completion.test.cjs
new file mode 100644
index 000000000..939885df3
--- /dev/null
+++ b/.github/scripts/priority-completion.test.cjs
@@ -0,0 +1,200 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const { test } = require('node:test');
+const {jobBody} = require('./workflow-needs.cjs');
+
+const workflow = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+
+function jobSection(name, source = workflow) {
+  return jobBody(source, name);
+}
+
+function policySelector(source) {
+  const steps = jobSection('ci_policy', source).split(/(?=^      - )/m);
+  const selected = steps.filter(step => step.startsWith('      - name: CI policy tests\n'));
+  assert.equal(selected.length, 1, 'one actual Go policy execution step required');
+  assert.doesNotMatch(selected[0], /^        (?:if|continue-on-error):/m);
+  const commands = [...selected[0].matchAll(/^        run: go test \. -run '([^']+)' -count=1$/gm)];
+  assert.equal(commands.length, 1, 'one uncached, unmasked root-package policy command required');
+  return commands[0][1];
+}
+
+function corpusBaselineStep(source) {
+  const steps = jobSection('ci_policy', source).split(/(?=^      - )/m);
+  const selected = steps.filter(step => step.startsWith('      - name: Official corpus form baselines\n'));
+  assert.equal(selected.length, 1, 'one actual corpus baseline execution step required');
+  const step = selected[0];
+  assert.match(step, /^        timeout-minutes: 10$/m);
+  assert.match(step, /^        shell: bash$/m);
+  assert.doesNotMatch(step, /^        (?:if|continue-on-error):/m);
+  const marker = '        run: |\n';
+  assert.equal(step.split(marker).length, 2, 'one literal baseline run body required');
+  const lines = step.slice(step.indexOf(marker) + marker.length).trimEnd().split('\n');
+  assert.ok(lines.every(line => line.startsWith('          ')), 'complete literal shell body required');
+  const script = lines.map(line => line.slice(10)).join('\n') + '\n';
+  assert.deepEqual(script.trimEnd().split('\n'), [
+    'set -euo pipefail',
+    'scripts/check-go-asm-coverage.sh',
+    'scripts/check-arm64-plan9-corpus.sh',
+  ]);
+  return {step, script};
+}
+
+function requireCompletePolicy(source) {
+  assert.equal(policySelector(source),
+    '^(TestCI|TestFixedLocal|TestGoAMD64FixedLocal(Packed|Conversion)RuntimeOwnership$|TestX86PackedConversion(RequiredNativeOwners|CompleteNativeRuntimeOwnership)$|TestX86FloatingCompareRequiredLinuxBuildSelection$|TestRuntimeOracleCommand(ConsumersRetainOwnedExecution|AuditDistinguishesTestingRun)$)',
+    'preflight must select complete static-contract prefixes, not a manually enumerated subset');
+  const policy = jobSection('ci_policy', source);
+  assert.match(policy, /^    timeout-minutes: 20$/m);
+  assert.match(policy, /^          go-version: '1\.27\.1'$/m);
+  assert.match(policy, /^        run: bash scripts\/install-ci-llvm22-ubuntu\.sh$/m);
+  assert.match(policy, /^        uses: \.\/\.github\/actions\/setup-node22$/m);
+  assert.doesNotMatch(policy, /^    (?:needs|if|continue-on-error):/m);
+  corpusBaselineStep(source);
+}
+
+test('translator jobs require policy preflight, not external compatibility', () => {
+  for (const name of [
+    'fmt', 'build',
+    'stdlib-corpus', 'cross-runtime', 'test', 'nested-cli', 'arm-scan', 'race', 'coverage', 'nested-cli-coverage',
+  ]) {
+    const section = jobSection(name);
+    assert.match(section, /^    needs: ci_policy$/m, name);
+    // Native needs success gating must not be bypassed by always()/!cancelled().
+    assert.doesNotMatch(section, /^    if:/m, name);
+  }
+  assert.doesNotMatch(workflow, /discovered_library|reported_library|testdata\/discovery/);
+});
+
+test('all translator matrix failures remain failures', () => {
+  for (const name of ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage', 'cross-runtime']) {
+    const job = jobSection(name);
+    assert.match(job, /^      fail-fast: false$/m);
+    assert.doesNotMatch(job, /continue-on-error:/);
+  }
+});
+
+test('cheap CI policy checks pass before instruction and official corpus jobs', () => {
+  const policy = jobSection('ci_policy');
+  assert.match(policy, /bash scripts\/install-ci-llvm22-ubuntu\.sh/);
+  assert.match(policy, /node --test \.github\/scripts\/priority-\*\.test\.cjs/);
+  requireCompletePolicy(workflow);
+  assert.doesNotMatch(policy, /^    (needs|if):/m);
+  assert.ok(workflow.indexOf('\n  ci_policy:\n') <
+    workflow.indexOf('\n  test:\n'));
+
+  // Exercise the actual workflow body with owned protocol scripts, never Go/LLVM.
+  const {script} = corpusBaselineStep(workflow);
+  for (const [first, second, status, expected] of [
+    [0, 0, 0, ['go-asm', 'arm64-plan9']],
+    [17, 0, 17, ['go-asm']],
+    [0, 19, 19, ['go-asm', 'arm64-plan9']],
+  ]) {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-baseline-preflight-'));
+    try {
+      fs.mkdirSync(path.join(directory, 'scripts'));
+      for (const [file, name, exit] of [
+        ['check-go-asm-coverage.sh', 'go-asm', first],
+        ['check-arm64-plan9-corpus.sh', 'arm64-plan9', second],
+      ]) {
+        fs.writeFileSync(path.join(directory, 'scripts', file),
+          `#!/usr/bin/env bash\nprintf '%s\\n' '${name}' >> calls\nexit ${exit}\n`, {mode: 0o755});
+      }
+      const result = spawnSync('bash', ['--noprofile', '--norc', '-c', script], {
+        cwd: directory, encoding: 'utf8', timeout: 5000,
+      });
+      assert.ifError(result.error);
+      assert.equal(result.signal, null);
+      assert.equal(result.status, status, result.stderr);
+      assert.deepEqual(fs.readFileSync(path.join(directory, 'calls'), 'utf8').trimEnd().split('\n'), expected);
+    } finally {
+      fs.rmSync(directory, {recursive: true, force: true});
+    }
+  }
+});
+
+test('PR preflight selects every existing CI and FixedLocal static contract', () => {
+  requireCompletePolicy(workflow);
+  const selected = new RegExp(policySelector(workflow));
+  const root = path.join(__dirname, '../..');
+  const names = fs.readdirSync(root).filter(file => file.endsWith('_test.go')).flatMap(file =>
+    [...fs.readFileSync(path.join(root, file), 'utf8').matchAll(
+      /^func (Test(?:CI|FixedLocal)[A-Za-z0-9_]+|TestGoAMD64FixedLocal(?:Packed|Conversion)RuntimeOwnership|TestX86PackedConversion(?:RequiredNativeOwners|CompleteNativeRuntimeOwnership)|TestX86FloatingCompareRequiredLinuxBuildSelection|TestRuntimeOracleCommand(?:ConsumersRetainOwnedExecution|AuditDistinguishesTestingRun))\(t \*testing\.T\)/gm,
+    )].map(match => match[1]));
+  for (const guard of [
+    'TestFixedLocalWideCompileOnlyOwnersDoNotRequireRuntimeTransport',
+    'TestFixedLocalCompileOnlyToolsRetainExactLLVMAndSDKWithoutExecution',
+    'TestFixedLocalSharedHelpersBuildOnAllHosts',
+    'TestGoAMD64FixedLocalPackedRuntimeOwnership',
+    'TestGoAMD64FixedLocalConversionRuntimeOwnership',
+    'TestX86PackedConversionRequiredNativeOwners',
+    'TestX86PackedConversionCompleteNativeRuntimeOwnership',
+    'TestX86FloatingCompareRequiredLinuxBuildSelection',
+    'TestRuntimeOracleCommandConsumersRetainOwnedExecution',
+    'TestRuntimeOracleCommandAuditDistinguishesTestingRun',
+  ]) assert.ok(names.includes(guard), 'independently required source guard missing: ' + guard);
+  for (const name of names) assert.ok(selected.test(name), 'preflight omitted existing static contract: ' + name);
+});
+
+test('preflight includes future static contracts without selecting expensive execution owners', () => {
+  const selected = new RegExp(policySelector(workflow));
+  for (const name of ['TestCIFutureSchedulingContract', 'TestFixedLocalFutureSourceOwnershipContract',
+    'TestGoAMD64FixedLocalPackedRuntimeOwnership']) {
+    assert.ok(selected.test(name), 'new static contracts must not need another suffix allowlist: ' + name);
+  }
+  for (const name of [
+    'TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch00',
+    'TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch05',
+    'TestGoAMD64FixedLocalPackedWideRuntimeOracleCompileOnly',
+    'TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch00',
+    'TestGoAMD64FixedLocalReadonlyDataWindowsRegisteredConsumers',
+    'TestX86AESFamilyActualBoundFixedLocalConsumers',
+    'TestRuntimeOracleCommandRequiresBoundContextAndOutput',
+    'TestRuntimeOracleCommandConsumersRetainOwnedExecutionNative',
+    'TestRuntimeOracleCommandAuditDistinguishesTestingRunNative',
+    'TestGoAMD64FixedLocalConversionRuntimeOwnershipNative',
+    'TestX86PackedConversionCompleteNativeRuntimeOwnershipNative',
+    'TestX86FloatingCompareRequiredLinuxBuildSelectionNative',
+  ]) assert.ok(!selected.test(name), 'cheap preflight acquired an actual native/object owner: ' + name);
+});
+
+test('preflight rejects stale suffix allowlists, missing contract families and failure masking', () => {
+  requireCompletePolicy(workflow);
+  const command = "run: go test . -run '" + policySelector(workflow) + "' -count=1";
+  for (const selector of [
+    '^TestCI',
+    '^(TestCI|TestFixedLocal(APIsHaveIndependentBoundedCaptureLeases|WideCompileOnlyHasThreeCompleteAPIOwners)|TestGoAMD64FixedLocalPackedRuntimeOwnership)',
+    '^(TestFixedLocal|TestGoAMD64FixedLocalPackedRuntimeOwnership)',
+    '^(TestCI|TestFixedLocal)',
+    '^(TestCI|TestFixedLocal|TestGoAMD64FixedLocalPackedRuntimeOwnership)',
+    '^(TestCI|TestFixedLocal|TestGoAMD64FixedLocalPackedRuntimeOwnership|TestRuntimeOracleCommand(ConsumersRetainOwnedExecution|AuditDistinguishesTestingRun)$)',
+    '^Test',
+  ]) assert.throws(() => requireCompletePolicy(workflow.replace(command,
+    () => "run: go test . -run '" + selector + "' -count=1")));
+  for (const changed of ['run: echo policy', command + ' || true',
+    "if: false\n        " + command]) {
+    assert.throws(() => requireCompletePolicy(workflow.replace(command, () => changed)));
+  }
+
+  const {step} = corpusBaselineStep(workflow);
+  for (const changed of [
+    '', step + step,
+    step.replace('timeout-minutes: 10', 'timeout-minutes: 0'),
+    step.replace('shell: bash', 'shell: python'),
+    step.replace('        shell: bash', '        if: false\n        shell: bash'),
+    step.replace('        shell: bash', '        continue-on-error: true\n        shell: bash'),
+    step.replace('          scripts/check-go-asm-coverage.sh\n', ''),
+    step.replace('          scripts/check-arm64-plan9-corpus.sh\n', ''),
+    step.replace('scripts/check-go-asm-coverage.sh', 'echo scripts/check-go-asm-coverage.sh'),
+    step.replace('scripts/check-arm64-plan9-corpus.sh', '# scripts/check-arm64-plan9-corpus.sh'),
+    step.replace('set -euo pipefail', 'set +e'),
+    step.replace('scripts/check-go-asm-coverage.sh', 'scripts/check-go-asm-coverage.sh || true'),
+    step.replace('scripts/check-arm64-plan9-corpus.sh', 'scripts/check-arm64-plan9-corpus.sh &'),
+  ]) {
+    assert.notEqual(changed, step, 'negative control must alter the actual baseline step');
+    assert.throws(() => requireCompletePolicy(workflow.replace(step, () => changed)));
+  }
+});
diff --git a/.github/scripts/priority-cross-runtime.test.cjs b/.github/scripts/priority-cross-runtime.test.cjs
new file mode 100644
index 000000000..53bc7b1be
--- /dev/null
+++ b/.github/scripts/priority-cross-runtime.test.cjs
@@ -0,0 +1,141 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+const workflow = fs.readFileSync('.github/workflows/go-ci.yml', 'utf8');
+const nested = fs.readFileSync('.github/workflows/linux-cli-module.yml', 'utf8');
+function job(name, source = workflow) {
+  const marker = `\n  ${name}:\n`;
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, `missing ${name}`);
+  const body = source.slice(start + marker.length);
+  const end = body.search(/^  [a-zA-Z][a-zA-Z0-9_-]*:\s*$/m);
+  return end < 0 ? body : body.slice(0, end);
+}
+
+test('required cross-runtime inventory has sixteen exhaustive owners, not a concurrency cap', () => {
+  const body = job('cross-runtime');
+  assert.match(body, /fail-fast: false/);
+  assert.doesNotMatch(body, /max-parallel:|continue-on-error:/);
+  assert.match(body, /owner: \[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15\]/);
+  assert.match(body, /-ci-isolate-root TestCrossLinuxRuntimeMatrix/);
+  assert.match(body, /-ci-owner \$\{\{ matrix.owner \}\}/);
+  assert.match(body, /-shards 16 -timeout 20m/);
+  assert.match(body, /\^\(TestCrossLinuxRuntimeMatrix\|TestARM64Conformance\|TestARM64RawSQSHLURuntimeSemantics\|TestARMIntegerMemoryRuntimeCross\|TestARMRawSaturationRuntimeCross\)/);
+  assert.match(body, /PLAN9ASM_CROSS_EXEC: '1'/);
+  assert.match(body, /bash scripts\/install-ci-qemu.sh/);
+  assert.match(body, /actions\/upload-artifact@v6/);
+  assert.match(body, /if: \$\{\{ !cancelled\(\) \}\}/);
+});
+
+test('strict completion runs even after a failed owner and keeps original tool requirements', () => {
+  const body = job('cross-runtime-verify');
+  assert.match(body, /needs: cross-runtime/);
+  assert.match(body, /if: \$\{\{ !cancelled\(\) \}\}/);
+  assert.match(body, /-verify-ci-partitions _out\/cross-runtime-partitions/);
+  assert.match(body, /-shards 16 -timeout 20m/);
+  assert.match(body, /-ci-isolate-root TestCrossLinuxRuntimeMatrix/);
+  assert.match(body, /actions\/download-artifact@v8/);
+  assert.match(body, /gcc-i686-linux-gnu gcc-arm-linux-gnueabihf/);
+  assert.match(body, /gcc-aarch64-linux-gnu/);
+  assert.match(body, /bash scripts\/install-ci-qemu.sh/);
+  assert.doesNotMatch(body, /continue-on-error:|PLAN9ASM_CROSS_EXEC: '0'/);
+});
+
+function requireARM64FallbackOwner(source) {
+  const owner = job('cross-runtime', source);
+  assert.match(owner, /- name: Execute rich CLI ARM64 fallback oracle\n        if: \$\{\{ !cancelled\(\) && matrix\.owner == 15 \}\}\n        run: bash scripts\/test-arm64-fallback-ci\.sh execute/);
+  assert.equal((source.match(/- name: Execute rich CLI ARM64 fallback oracle/g) || []).length, 1);
+  const reader = job('cross-runtime-verify', source);
+  assert.match(reader, /- name: Verify rich CLI ARM64 fallback execution\n        if: \$\{\{ !cancelled\(\) \}\}\n        run: bash scripts\/test-arm64-fallback-ci\.sh complete/);
+}
+
+test('rich CLI ARM64 execution has a unique cross owner and a fresh completion reader', () => {
+  requireARM64FallbackOwner(workflow);
+});
+
+test('ARM64 execution cannot lose its unique owner, success guard or reader', () => {
+  for (const [before, after] of [
+    ['Execute rich CLI ARM64 fallback oracle', 'Removed runtime oracle'],
+    ['matrix.owner == 15', 'matrix.owner == 14'],
+    ['!cancelled() && matrix.owner == 15', 'success()'],
+    ['test-arm64-fallback-ci.sh execute', 'test-arm64-fallback-ci.sh complete'],
+    ['Verify rich CLI ARM64 fallback execution', 'Removed execution reader'],
+  ]) {
+    const changed = workflow.replace(before, after);
+    assert.notEqual(changed, workflow);
+    assert.throws(() => requireARM64FallbackOwner(changed));
+  }
+  assert.throws(() => requireARM64FallbackOwner(workflow + '\n      - name: Execute rich CLI ARM64 fallback oracle\n'));
+});
+
+const moduleExecutionJobs = [
+  ...['test', 'race', 'coverage', 'module-completion'].map(name => [workflow, name]),
+  ...['root-parts', 'complete'].map(name => [nested, name]),
+];
+const moduleCompilerInstall = 'bash scripts/install-ci-llvm22-ubuntu.sh ' +
+  'gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu';
+
+// The unchanged portable FMA access oracle executes AArch64 on Linux/amd64
+// in ordinary module owners too. Its linker cannot be supplied solely by the
+// separate cross-runtime job, nor can missing infrastructure become a skip.
+function requireModuleCrossTools(source, name) {
+  const body = job(name, source);
+  const installs = body.split(/(?=^      - )/m).filter(step =>
+    step.includes('run: bash scripts/install-ci-llvm22-ubuntu.sh'));
+  assert.equal(installs.length, 1, `${name}: one LLVM/cross-compiler install`);
+  assert.match(installs[0], /^        timeout-minutes: 14$/m);
+  assert.ok(installs[0].includes(`        run: ${moduleCompilerInstall}\n`),
+    `${name}: both 386 and AArch64 module execution dependencies required`);
+  assert.doesNotMatch(installs[0], /continue-on-error:|\|\|\s*true/);
+  assert.match(body, /^        run: bash scripts\/install-ci-qemu\.sh$/m);
+}
+
+// The intended complete installation is an independent positive control; the
+// real workflow below must satisfy exactly the same requirement on its own.
+for (const [source, name] of moduleExecutionJobs) {
+  const moduleToolsFixture = source.replaceAll(
+    'bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross\n',
+    moduleCompilerInstall + '\n');
+  test(`${name}: real module execution owns its required cross tools`, () => {
+    requireModuleCrossTools(source, name);
+  });
+
+  test(`${name}: complete cross tools reject missing dependencies or swallowed errors`, () => {
+    requireModuleCrossTools(moduleToolsFixture, name);
+    const original = job(name, moduleToolsFixture);
+    for (const [before, after] of [
+      [' gcc-aarch64-linux-gnu', ''],
+      [' gcc-i686-linux-gnu', ''],
+      [' libc6-dev-i386-cross', ''],
+      ['install-ci-llvm22-ubuntu.sh', 'install-unpinned-llvm.sh'],
+      [moduleCompilerInstall, moduleCompilerInstall + ' || true'],
+      ['install-ci-qemu.sh', 'install-unpinned-qemu.sh'],
+    ]) {
+      const mutated = original.replace(before, after);
+      assert.notEqual(mutated, original, `${name}: mutation changed its own job`);
+      // Shell regexes can contain $'; a function keeps replacement bytes literal.
+      const changed = moduleToolsFixture.replace(original, () => mutated);
+      assert.equal(job(name, changed), mutated, 'mutation must retain its exact job boundary');
+      assert.throws(() => requireModuleCrossTools(changed, name), undefined,
+        `${name}: reject ${before}`);
+    }
+  });
+}
+
+test('ARM64 main driver retains the complete strict oracle and its four mandatory children', () => {
+  const driver = fs.readFileSync('scripts/test-arm64-fallback-ci.sh', 'utf8');
+  assert.match(driver, /root=TestFallbackARM64WideFrameCompilesWithLLVM22\n/);
+  assert.match(driver, /-dir cmd\/plan9asmll/);
+  assert.match(driver, /-ci-selector "\^\$\{root\}\$" -ci-isolate-root "\$root"/);
+  assert.match(driver, /-shards 2 -timeout 5m/);
+  assert.match(driver, /for owner in 0 1; do/);
+  assert.match(driver, /-verify-ci-partitions "\$base\/owners"/);
+  assert.match(driver, /node \.github\/scripts\/audit-arm64-fallback\.cjs/);
+  const auditor = fs.readFileSync('.github/scripts/audit-arm64-fallback.cjs', 'utf8');
+  assert.match(auditor, /\['darwin', 'linux', 'windows', 'native_complete-argument_oracle'\]/);
+  assert.match(auditor, /roots: 1, children: 4, passed: 5, skipped: 0, incomplete: 0/);
+  const qemu = fs.readFileSync('scripts/install-ci-qemu.sh', 'utf8');
+  assert.match(qemu, /^version=10\.2\.3$/m);
+  assert.match(qemu, /sha256sum --check --status/);
+});
diff --git a/.github/scripts/priority-current-sdk-scope.test.cjs b/.github/scripts/priority-current-sdk-scope.test.cjs
new file mode 100644
index 000000000..a5432a143
--- /dev/null
+++ b/.github/scripts/priority-current-sdk-scope.test.cjs
@@ -0,0 +1,152 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody} = require('./workflow-needs.cjs');
+
+const source = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+const nested = fs.readFileSync(path.join(__dirname, '../workflows/linux-cli-module.yml'), 'utf8');
+const exactSDK = '1.27.2';
+const minors = ['1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x',
+  '1.25.x', '1.26.x', exactSDK];
+const testCreationOrder = [exactSDK, minors[0], ...minors.slice(1, -1).reverse()];
+const matrixJobs = new Set(['stdlib-corpus', 'test', 'nested-cli', 'module-completion']);
+// The independent SDK/runtime integration workflow has its own exact-SDK
+// policy. These remain the required PR instruction and module owners.
+const jobs = ['fmt', 'build', 'stdlib-corpus', 'cross-runtime',
+  'cross-runtime-verify', 'test', 'nested-cli', 'nested-cli-coverage',
+  'arm-scan', 'race', 'coverage', 'module-completion'];
+
+function requireSetups(workflow) {
+  for (const name of jobs) {
+    const body = jobBody(workflow, name);
+    if (name === 'nested-cli' || name === 'nested-cli-coverage') {
+      assert.match(body, /^    uses: \.\/\.github\/workflows\/linux-cli-module\.yml$/m);
+      const expected = name === 'nested-cli' ? '${{ matrix.go-version }}' : `'${exactSDK}'`;
+      assert.ok(body.includes('      go-version: ' + expected + '\n'));
+      continue;
+    }
+    const setups = body.split(/(?=^      - )/m).filter(step =>
+      /^        uses: \.\/\.github\/actions\/setup-go$/m.test(step));
+    assert.equal(setups.length, name === 'stdlib-corpus' ? 2 : 1,
+      name + ': every actual Go installation must be covered');
+    const expected = matrixJobs.has(name) ? '${{ matrix.go-version }}' : `'${exactSDK}'`;
+    const versions = setups.map(step => {
+      assert.match(step, /^        with:$/m);
+      assert.doesNotMatch(step, /go-version-file:|check-latest:/);
+      const fields = [...step.matchAll(/^          go-version: (.+)$/gm)];
+      assert.equal(fields.length, 1, name + ': one explicit SDK selection required');
+      return fields[0][1];
+    });
+    assert.deepEqual(versions, name === 'stdlib-corpus' ? [`'${exactSDK}'`, expected] : [expected],
+      name + ': current SDK must use the registered exact producer');
+    assert.doesNotMatch(body, /uses: actions\/setup-go@/);
+  }
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(nested, name);
+    const setups = body.split(/(?=^      - )/m).filter(step =>
+      /^        uses: \.\/\.github\/actions\/setup-go$/m.test(step));
+    assert.equal(setups.length, 1, 'one actual reusable SDK setup: ' + name);
+    assert.match(setups[0], /^          go-version: \$\{\{ inputs\.go-version \}\}$/m);
+    assert.doesNotMatch(body, /uses: actions\/setup-go@|go-version-file:|check-latest:/);
+  }
+}
+
+function requireMatrices(workflow) {
+  const regular = jobBody(workflow, 'test');
+  const versions = regular.match(/^        go-version: \[(.+)\]$/m);
+  assert.ok(versions, 'complete test SDK matrix required');
+  assert.deepEqual([...versions[1].matchAll(/'([^']+)'/g)].map(match => match[1]), testCreationOrder);
+  const nested = jobBody(workflow, 'nested-cli').match(/^        go-version: \[(.+)\]$/m);
+  assert.ok(nested, 'complete independent CLI SDK matrix required');
+  assert.deepEqual([...nested[1].matchAll(/'([^']+)'/g)].map(match => match[1]), minors.slice(4));
+
+  const corpus = [...jobBody(workflow, 'stdlib-corpus').matchAll(
+    /^          - \{os: ([^,]+), .*go-version: '([^']+)', .*targets: '([^']+)'\}$/gm)];
+  assert.equal(corpus.length, 10, 'eight Linux SDK lanes and both native hosts remain required');
+  assert.deepEqual(corpus.slice(0, 8).map(match => [match[1], match[2]]),
+    minors.map(version => ['ubuntu-latest', version]));
+  assert.deepEqual(corpus.slice(8).map(match => [match[1], match[2]]),
+    [['macos-latest', exactSDK], ['windows-latest', exactSDK]]);
+
+  const complete = [...jobBody(workflow, 'module-completion').matchAll(
+    /^          - \{flavor: ([^,]+), go-version: '([^']+)'\}$/gm)];
+  assert.deepEqual(complete.map(match => [match[1], match[2]]),
+    [...minors.map(version => ['test', version]), ['race', exactSDK], ['coverage', exactSDK]]);
+}
+
+function requireCurrentFixture(workflow) {
+  const body = jobBody(workflow, 'test');
+  const step = body.split(/(?=^      - )/m).find(step =>
+    step.startsWith('      - name: Required exact downloaded AMD64 numerical fixture\n'));
+  assert.ok(step, 'current-only numerical owner must remain present');
+  assert.ok(step.includes("if: runner.os == 'Linux' && matrix.go-version == '" +
+    exactSDK + "' && matrix.module-owner == 2\n"),
+  'the exact current matrix must still activate its numerical owner');
+  assert.match(step, /go test \.\/gotoolprofile -run="\$scope" -count=1 -timeout=10m/);
+}
+
+function requireArtifactScope(workflow) {
+  for (const flavor of ['race', 'coverage']) {
+    assert.ok(jobBody(workflow, flavor).includes(
+      'name: module-' + flavor + '-' + exactSDK + '-${{ matrix.module-role }}\n'),
+    flavor + ': artifact identity must match the exact completion matrix');
+  }
+  assert.ok(jobBody(workflow, 'windows-module').includes(
+    'name: test (windows-latest, ' + exactSDK + ', ${{ matrix.module }})\n'));
+  assert.doesNotMatch(workflow, /1\.27\.x/, 'no current floating SDK selector or stale scope remains');
+}
+
+function requireCurrentScope(workflow) {
+  requireSetups(workflow);
+  requireMatrices(workflow);
+  requireCurrentFixture(workflow);
+  requireArtifactScope(workflow);
+}
+
+// Negative controls start from a complete positive fixture while the actual
+// workflow is RED. This does not relax compiler-observation admission.
+const fixture = source.replaceAll('1.27.x', exactSDK);
+
+test('formal current Go owners use the audited exact SDK', () => {
+  requireSetups(source);
+});
+
+test('all eight minor lanes and exact current completion scopes remain present', () => {
+  requireMatrices(source);
+});
+
+test('the exact current matrix still executes its required numerical fixture', () => {
+  requireCurrentFixture(source);
+});
+
+test('current artifacts and Windows labels identify the selected exact SDK', () => {
+  requireArtifactScope(source);
+});
+
+test('every current owner rejects a foreign patch or floating selector', () => {
+  requireCurrentScope(fixture);
+  for (const name of jobs) {
+    const before = jobBody(fixture, name);
+    for (const version of ['1.27.3', '1.27.x', '1.27', 'stable']) {
+      const after = before.replaceAll(exactSDK, version);
+      assert.notEqual(after, before, name + ': mutation must change the actual owner');
+      assert.throws(() => requireCurrentScope(fixture.replace(before, () => after)), name + ': ' + version);
+    }
+  }
+});
+
+test('neither stale current-only conditions nor artifact names can borrow another pin', () => {
+  requireCurrentScope(fixture);
+  for (const [before, after] of [
+    ["matrix.go-version == '1.27.2'", "matrix.go-version == '1.27.x'"],
+    ['module-race-1.27.2-', 'module-race-1.27.x-'],
+    ['module-coverage-1.27.2-', 'module-coverage-1.27.3-'],
+    ["{flavor: coverage, go-version: '1.27.2'}", "{flavor: coverage, go-version: '1.27.3'}"],
+  ]) {
+    assert.ok(fixture.includes(before), 'mutation must affect the actual workflow');
+    assert.throws(() => requireCurrentScope(fixture.replace(before, after)));
+  }
+});
diff --git a/.github/scripts/priority-diagnostic-qualification.test.cjs b/.github/scripts/priority-diagnostic-qualification.test.cjs
new file mode 100644
index 000000000..54ab1d81d
--- /dev/null
+++ b/.github/scripts/priority-diagnostic-qualification.test.cjs
@@ -0,0 +1,99 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+
+// Independent inventory for auditing historical diagnostic receipts.
+const {qualifyDiagnosticNeeds} = require('./diagnostic-qualification.cjs');
+const allNeeds = [
+  'ownership', 'native-x86-oracles', 'sdk-priority', 'arm64-fallback-cross-priority',
+  'lock-native-priority', 'unlocked-rmw-native-priority', 'vector-value-fault-priority',
+  'packed-conversion-native-complete', 'packed-reduction-native-complete', 'complete-windows',
+];
+
+function successfulNeeds() {
+  return Object.fromEntries(allNeeds.map(name => [name, {result: 'success', outputs: {}}]));
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+test('only all ten genuine success results qualify; Windows cannot replace an original gate', () => {
+  const {qualifyDiagnosticNeeds} = require('./diagnostic-qualification.cjs');
+  assert.deepEqual(qualifyDiagnosticNeeds(successfulNeeds()), {schema: 1, successfulJobs: allNeeds});
+  for (const name of allNeeds) {
+    for (const result of ['failure', 'skipped', 'cancelled', 'queued', 'in_progress', '', true, null]) {
+      const needs = successfulNeeds();
+      needs[name].result = result;
+      assert.throws(() => qualifyDiagnosticNeeds(needs), undefined, name + ': ' + result);
+    }
+    const missing = successfulNeeds();
+    delete missing[name];
+    assert.throws(() => qualifyDiagnosticNeeds(missing), undefined, 'missing ' + name);
+    for (const malformed of [null, [], 'success', {outputs: {result: 'success'}}]) {
+      const needs = successfulNeeds();
+      needs[name] = malformed;
+      assert.throws(() => qualifyDiagnosticNeeds(needs), undefined, 'malformed ' + name);
+    }
+  }
+  for (const needs of [null, [], true, 'success', {},
+    {...successfulNeeds(), extra: {result: 'success', outputs: {}}}]) {
+    assert.throws(() => qualifyDiagnosticNeeds(needs));
+  }
+  const forged = clone(successfulNeeds());
+  forged['native-x86-oracles'] = {result: 'failure', outputs: {result: 'success'}};
+  forged['complete-windows'].outputs = {qualification: 'success'};
+  assert.throws(() => qualifyDiagnosticNeeds(forged));
+});
+
+test('the actual qualification command exits nonzero for failed, skipped, absent or malformed needs', () => {
+  const script = path.join(__dirname, 'diagnostic-qualification.cjs');
+  const execute = input => {
+    const env = {...process.env};
+    if (input === undefined) delete env.DIAGNOSTIC_NEEDS_JSON;
+    else env.DIAGNOSTIC_NEEDS_JSON = input;
+    return spawnSync(process.execPath, [script], {encoding: 'utf8', timeout: 5000, env});
+  };
+  const rejects = (input, label) => {
+    const failed = execute(input);
+    assert.equal(failed.error, undefined, label);
+    assert.equal(failed.signal, null, label);
+    assert.ok(Number.isInteger(failed.status) && failed.status > 0, label);
+    assert.equal(failed.stdout, '', label);
+  };
+  const success = execute(JSON.stringify(successfulNeeds()));
+  assert.equal(success.error, undefined);
+  assert.equal(success.status, 0, success.stderr);
+  assert.deepEqual(JSON.parse(success.stdout), {schema: 1, successfulJobs: allNeeds});
+  for (const name of allNeeds) {
+    for (const result of ['failure', 'skipped', 'cancelled']) {
+      const needs = successfulNeeds();
+      needs[name].result = result;
+      rejects(JSON.stringify(needs), name + ': ' + result);
+    }
+    const missing = successfulNeeds();
+    delete missing[name];
+    rejects(JSON.stringify(missing), 'missing ' + name);
+  }
+  for (const input of [undefined, '', '{', 'null', '[]', '{}']) {
+    rejects(input, 'malformed actual context: ' + input);
+  }
+});
+
+test('early Windows completion cannot qualify a pending failed or absent original owner', () => {
+  const successful = () => Object.fromEntries(allNeeds.map(name => [name, {result: 'success', outputs: {}}]));
+  assert.deepEqual(qualifyDiagnosticNeeds(successful()), {schema: 1, successfulJobs: allNeeds});
+  for (const name of allNeeds) {
+    for (const result of ['failure', 'cancelled', 'skipped', 'queued', 'in_progress']) {
+      const changed = successful();
+      changed[name] = {result, outputs: {result: 'success', qualification: 'success'}};
+      assert.throws(() => qualifyDiagnosticNeeds(changed), undefined, name + '/' + result);
+    }
+    const changed = successful();
+    delete changed[name];
+    assert.throws(() => qualifyDiagnosticNeeds(changed), undefined, 'absent ' + name);
+  }
+});
diff --git a/.github/scripts/priority-duplicate-native-families.test.cjs b/.github/scripts/priority-duplicate-native-families.test.cjs
new file mode 100644
index 000000000..c12ae729c
--- /dev/null
+++ b/.github/scripts/priority-duplicate-native-families.test.cjs
@@ -0,0 +1,187 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditDuplicateNativeFamilies} = require('./audit-duplicate-native-families.cjs');
+
+// This denominator is independent of the production auditor's inventory.
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNative386',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2', 'OriginalGo'];
+const packageName = 'github.com/xgo-dev/plan9asm';
+const inventory = roots.join('\n') + '\nok\t' + packageName + '\n';
+const hash = 'a'.repeat(64), imageHash = 'b'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${hash} mapsha=${hash}\n`;
+const avx = 'actual guest CPUID/XCR0 preflight: AVX=1 AVX2=0 AVX512F=0\n';
+const staticImage = `native oracle static IA32 ELF bytes=4096 sha256=${imageHash}\n`;
+const directImage = args => `IA32 direct ELF bytes=4096 sha256=${imageHash} argv=${args}\n`;
+const sdk = args => `actual executable=/sdk/bin/go sha256=${hash} argv=${args}\n`;
+const executable = (filename, args) => `actual executable=/tmp/owned/${filename} sha256=${imageHash} argv=${args}\n`;
+const originalArgs = '["-test.run=^TestOriginal$" "-test.count=1" "-test.v"]';
+const compileArgs = '["test" "-p=1" "-vet=off" "-c" "-o" "/tmp/owned/original.test" "."]';
+const pipelineEvidence = arch => `duplicate native arch=${arch} live=60 dead=30 whole64-outcomes=5760 fault-processes=712; legacy original opcode/all mod16, E4NF/E5NF independent full-span references\n`;
+const originalEvidence = 'actual original Go legacy/VEX: 18 rows × 16 IEEE/bit patterns × 6 masks = 1728 whole32/FLAGS/DF/MXCSR/canary outcomes; no EVEX execution claim\n';
+const event = (Action, Test, Output) => ({Action, Package: packageName,
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    events.push(event('run', root), event('output', root, host + avx));
+    for (const axis of axes) {
+      const child = root + '/' + axis;
+      events.push(event('run', child));
+      if (axis === 'OriginalGo') {
+        events.push(event('output', child, sdk('["version"]') + sdk(compileArgs)));
+        if (arch === '386') events.push(event('output', child,
+          staticImage + executable('original.test', originalArgs) + directImage(originalArgs)));
+        events.push(event('output', child, originalEvidence));
+      } else {
+        if (arch === '386') events.push(event('output', child,
+          staticImage + executable('comparison', '[]') + directImage('[]') + staticImage));
+        events.push(event('output', child, pipelineEvidence(arch)));
+      }
+      events.push(event('pass', child));
+    }
+    events.push(event('output', root, host), event('pass', root));
+  }
+  events.push(event('pass'));
+  return events;
+}
+
+test('duplicate moves independently require two native roots and all four execution children', () => {
+  assert.deepEqual(auditDuplicateNativeFamilies(inventory, serialize(completeEvents())),
+    {roots: 2, children: 8, passed: 10, skipped: 0, incomplete: 0,
+      nativeHosts: 4, avxPreflights: 2, sdkBuilds: 2, staticIA32Images: 7, directIA32Executions: 4});
+});
+
+test('duplicate moves reject every absent duplicated failed or skipped required terminal', () => {
+  for (const name of roots.flatMap(root => [root, ...axes.map(axis => root + '/' + axis)])) {
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => auditDuplicateNativeFamilies(inventory,
+        serialize(completeEvents().map(value => value.Action === 'pass' && value.Test === name
+          ? {...value, Action} : value))), name + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const events = completeEvents();
+      const at = events.findIndex(value => value.Test === name && value.Action === Action);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory,
+        serialize(events.filter((_, index) => index !== at))), name + '/missing ' + Action);
+      events.splice(at, 0, events[at]);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), name + '/duplicate ' + Action);
+    }
+  }
+});
+
+test('duplicate moves reject stale inventory malformed lifecycle foreign children and printed PASS', () => {
+  for (const changed of ['', inventory + roots[0] + '\n', inventory.replace(roots[0] + '\n', '')]) {
+    assert.throws(() => auditDuplicateNativeFamilies(changed, serialize(completeEvents())));
+  }
+  for (const changed of [
+    [event('output', undefined, '10 passed')], completeEvents().slice(1), completeEvents().slice(0, -1),
+    [event('start'), ...completeEvents()], [...completeEvents(), event('pass')],
+    [...completeEvents(), {Action: 'build-output', ImportPath: 'runtime', Output: 'late'}],
+    [event('run', roots[0] + '/objects-only'), ...completeEvents()],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'})),
+  ]) assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(changed)));
+  for (const changed of [event('unknown'), event('output', roots[0], 'late')]) {
+    const events = completeEvents();
+    events.splice(-1, 0, changed);
+    assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)));
+  }
+  assert.throws(() => auditDuplicateNativeFamilies(inventory, '{not JSON}'));
+});
+
+test('duplicate moves require native host brackets AVX and complete per-axis evidence', () => {
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    for (const needle of [host, avx]) {
+      for (const replacement of ['', needle.replace('linux/amd64', 'linux/arm64'),
+        needle.replace('AVX=1', 'AVX=0'), needle.replace(hash, 'invalid')]) {
+        if (replacement === needle) continue;
+        const events = completeEvents().map(value => value.Test === root && value.Output
+          ? {...value, Output: value.Output.replace(needle, replacement)} : value);
+        assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), needle);
+      }
+    }
+    for (const axis of axes) {
+      const evidence = axis === 'OriginalGo' ? originalEvidence : pipelineEvidence(arch);
+      for (const replacement of ['', evidence.replace('1728', '1727').replace('712', '711'), evidence + evidence]) {
+        const events = completeEvents().map(value => value.Test === root + '/' + axis && value.Output
+          ? {...value, Output: value.Output.replace(evidence, replacement)} : value);
+        assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), axis);
+      }
+    }
+    const events = completeEvents();
+    const original = events.filter(value => value.Test === root + '/OriginalGo');
+    const earlier = events.filter(value => value.Test !== root + '/OriginalGo');
+    const at = earlier.findIndex(value => value.Test === root + '/' + axes[2] && value.Action === 'pass');
+    earlier.splice(at, 0, ...original);
+    assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(earlier)), 'Go before final native axis');
+  }
+});
+
+test('duplicate original Go requires actual SDK and 386 direct image identity in the OriginalGo child', () => {
+  for (const root of roots) {
+    const child = root + '/OriginalGo';
+    for (const needle of [sdk('["version"]'), sdk(compileArgs)]) {
+      const events = completeEvents().map(value => value.Test === child && value.Output
+        ? {...value, Output: value.Output.replace(needle, '')} : value);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), needle);
+    }
+    const events = completeEvents().map(value => value.Test === child && value.Output
+      ? {...value, Output: value.Output.replace(sdk(compileArgs), sdk(compileArgs).replace(hash, imageHash))} : value);
+    assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), 'changed SDK identity');
+  }
+  for (const axis of axes) {
+    const child = roots[1] + '/' + axis;
+    const args = axis === 'OriginalGo' ? originalArgs : '[]';
+    for (const needle of [staticImage, directImage(args)]) {
+      const events = completeEvents().map(value => value.Test === child && value.Output
+        ? {...value, Output: value.Output.replace(needle, '')} : value);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), child + needle);
+    }
+    for (const replacement of ['bytes=0', 'bytes=-1', 'bytes=guest']) {
+      const events = completeEvents().map(value => value.Test === child && value.Output
+        ? {...value, Output: value.Output.replaceAll('bytes=4096', replacement)} : value);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), replacement);
+    }
+    const changedImage = completeEvents().map(value => value.Test === child && value.Output
+      ? {...value, Output: value.Output.replace(directImage(args), directImage(args).replace(imageHash, hash))} : value);
+    assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(changedImage)), 'changed actual image');
+  }
+});
+
+test('duplicate actual executable receipts retain precise pipeline and original Go roles', () => {
+  auditDuplicateNativeFamilies(inventory, serialize(completeEvents()));
+  for (const axis of axes) {
+    const child = roots[1] + '/' + axis;
+    const original = axis === 'OriginalGo';
+    const receipt = executable(original ? 'original.test' : 'comparison', original ? originalArgs : '[]');
+    for (const replacement of ['', receipt + receipt,
+      receipt.replace(imageHash, hash), receipt.replace('sha256=' + imageHash, 'sha256=invalid'),
+      receipt.replace(original ? 'original.test' : 'comparison', 'unrelated'),
+      receipt.replace(original ? originalArgs : '[]', '["unobserved"]'), sdk(compileArgs)]) {
+      const events = completeEvents().map(value => value.Test === child && value.Output
+        ? {...value, Output: value.Output.replace(receipt, replacement)} : value);
+      assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), axis + '/foreign or absent executable');
+    }
+    const events = completeEvents();
+    const at = events.findIndex(value => value.Test === child && value.Output?.includes(receipt));
+    events[at].Output = events[at].Output.replace(receipt, '');
+    const first = events.findIndex(value => value.Test === child && value.Action === 'output');
+    events.splice(first, 0, event('output', child, receipt));
+    assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), axis + '/execution before inspected image');
+  }
+  const events = completeEvents();
+  const child = roots[1] + '/OriginalGo';
+  const at = events.findIndex(value => value.Test === child && value.Output?.includes(sdk(compileArgs)));
+  events[at].Output = events[at].Output.replace(sdk(compileArgs), '');
+  const pipeline = events.findIndex(value => value.Test === roots[1] + '/backend_O0' && value.Action === 'output');
+  events.splice(pipeline, 0, event('output', roots[1] + '/backend_O0', sdk(compileArgs)));
+  assert.throws(() => auditDuplicateNativeFamilies(inventory, serialize(events)), 'pipeline cannot own original Go compilation');
+});
diff --git a/.github/scripts/priority-floating-compare.test.cjs b/.github/scripts/priority-floating-compare.test.cjs
new file mode 100644
index 000000000..e4cd86207
--- /dev/null
+++ b/.github/scripts/priority-floating-compare.test.cjs
@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditFloatingCompare, roots, children} = require('./audit-floating-compare.cjs');
+
+test('floating execution auditing retains all result, dead, FP-field, alias and backend owners', () => {
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const child of children.filter(child => child.startsWith(root + '/'))) {
+      events.push(event('run', child), event('pass', child));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const raw = values => values.map(JSON.stringify).join('\n') + '\n';
+  const inventory = roots.join('\n') + '\n';
+  assert.deepEqual(auditFloatingCompare(inventory, raw(events)),
+    {roots:4, children:6, passed:10, skipped:0, incomplete:0});
+  for (const name of [...roots, ...children]) {
+    assert.throws(() => auditFloatingCompare(inventory, raw(events.filter(event => event.Test !== name))));
+    assert.throws(() => auditFloatingCompare(inventory, raw(events.map(event =>
+      event.Test === name && event.Action === 'pass' ? {...event, Action:'skip'} : event))));
+    assert.throws(() => auditFloatingCompare(inventory, raw(events.map(event =>
+      event.Test === name ? {...event, Test:name+'-compile-only'} : event))));
+  }
+  assert.throws(() => auditFloatingCompare(roots.slice(1).join('\n')+'\n', raw(events)));
+  assert.throws(() => auditFloatingCompare(inventory, raw([
+    event('start'), {...event('output'), Output:'PASS '+roots.join('\nPASS ')}, event('pass'),
+  ])));
+});
diff --git a/.github/scripts/priority-floating-helpers.test.cjs b/.github/scripts/priority-floating-helpers.test.cjs
new file mode 100644
index 000000000..d8be239b0
--- /dev/null
+++ b/.github/scripts/priority-floating-helpers.test.cjs
@@ -0,0 +1,90 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditFloatingHelpers} = require('./audit-floating-helpers.cjs');
+
+// Keep this denominator independent of the implementation/auditor exports.
+const owners = [
+  'TestAMD64GetExpRuntimeSemantics',
+  'TestAMD64GetMantRuntimeSemantics',
+  'TestAMD64ScaleFRuntimeSemantics',
+  'TestAMD64FloatingRangeRuntimeSemantics',
+  'TestAMD64FloatingRangeDoubleAndScalarRuntimeSemantics',
+  'TestAMD64FixupImmediateRuntimeSemantics',
+  'TestAMD64ScaledRoundRuntimeSemantics',
+  'TestAMD64FPClassRuntimeSemantics',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const packageName = 'github.com/xgo-dev/plan9asm';
+const event = (Action, Test, Output) => ({Action, Package: packageName,
+  ...(Test ? {Test} : {}), ...(Output ? {Output} : {})});
+const inventory = owners.join('\n') + '\nok\t' + packageName + '\n';
+const native = 'AVX512F=1 AVX512DQ=1 AVX512VL=1 OSXSAVE=1 XCR0=e7\nFLOATING_HELPER_NATIVE_DQ_OK\n';
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const owner of owners) {
+    events.push(event('run', owner), event('output', owner, native));
+    for (const axis of axes) {
+      events.push(event('run', owner + '/' + axis), event('pass', owner + '/' + axis));
+    }
+    events.push(event('pass', owner));
+  }
+  events.push(event('pass'));
+  return events;
+}
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+test('native helper audit requires all eight originals and 24 execution children', () => {
+  assert.deepEqual(auditFloatingHelpers(inventory, serialize(completeEvents())),
+    {roots: 8, children: 24, passed: 32, skipped: 0, incomplete: 0, preflights: 8});
+});
+
+test('native helper audit rejects every absent, failed, skipped or incomplete owner/axis', () => {
+  const expected = owners.flatMap(owner => [owner, ...axes.map(axis => owner + '/' + axis)]);
+  for (const name of expected) {
+    const original = completeEvents();
+    for (const action of ['fail', 'skip']) {
+      const changed = original.map(value => value.Action === 'pass' && value.Test === name
+        ? {...value, Action: action} : value);
+      assert.throws(() => auditFloatingHelpers(inventory, serialize(changed)), name + '/' + action);
+    }
+    assert.throws(() => auditFloatingHelpers(inventory,
+      serialize(original.filter(value => value.Test !== name))), 'missing ' + name);
+    assert.throws(() => auditFloatingHelpers(inventory,
+      serialize(original.filter(value => value.Action !== 'pass' || value.Test !== name))), 'unfinished ' + name);
+    const started = original.find(value => value.Action === 'run' && value.Test === name);
+    assert.throws(() => auditFloatingHelpers(inventory,
+      serialize([started, ...original])), 'duplicate ' + name);
+  }
+});
+
+test('native helper audit rejects missing, late or incomplete actual CPU/opcode preflight', () => {
+  for (const owner of owners) {
+    for (const text of ['', native.replace('DQ=1', 'DQ=0'), native.replace('F=1', 'F=0'),
+      native.replace('VL=1', 'VL=0'), native.replace('OSXSAVE=1', 'OSXSAVE=0'),
+      native.replace('XCR0=e7', 'XCR0=7'), native.replace('FLOATING_HELPER_NATIVE_DQ_OK', 'object-only')]) {
+      const changed = completeEvents().map(value => value.Action === 'output' && value.Test === owner
+        ? {...value, Output: text} : value);
+      assert.throws(() => auditFloatingHelpers(inventory, serialize(changed)), owner);
+    }
+    const changed = completeEvents();
+    const at = changed.findIndex(value => value.Action === 'output' && value.Test === owner);
+    const [late] = changed.splice(at, 1);
+    changed.splice(at + 2, 0, late);
+    assert.throws(() => auditFloatingHelpers(inventory, serialize(changed)), 'late ' + owner);
+  }
+});
+
+test('native helper audit rejects changed inventories, foreign paths and printed success', () => {
+  for (const changed of ['', inventory + owners[0] + '\n', inventory.replace(owners[0] + '\n', '')]) {
+    assert.throws(() => auditFloatingHelpers(changed, serialize(completeEvents())));
+  }
+  for (const changed of [
+    [event('output', undefined, '32 passed')],
+    completeEvents().slice(0, -1),
+    [event('run', owners[0] + '/sample'), ...completeEvents()],
+    [...completeEvents(), event('pass')],
+  ]) assert.throws(() => auditFloatingHelpers(inventory, serialize(changed)));
+});
diff --git a/.github/scripts/priority-go-installation.test.cjs b/.github/scripts/priority-go-installation.test.cjs
new file mode 100644
index 000000000..a7b7cb299
--- /dev/null
+++ b/.github/scripts/priority-go-installation.test.cjs
@@ -0,0 +1,218 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const {test} = require('node:test');
+
+const action = fs.readFileSync('.github/actions/setup-go/action.yml', 'utf8');
+
+test('Go setup keeps writable local caches without accessing the account cache quota', () => {
+  assert.match(action, /^        cache: false$/m);
+  assert.doesNotMatch(action, /^  cache:/m);
+  for (const name of ['go-ci.yml', 'windows-module.yml', 'runtime-integration.yml', 'linux-cli-module.yml']) {
+    const source = fs.readFileSync(path.join('.github/workflows', name), 'utf8');
+    const steps = source.split(/(?=^      - )/m).filter(step =>
+      /uses: \.\/\.github\/actions\/setup-go\n/.test(step));
+    assert.ok(steps.length > 0, name);
+    for (const step of steps) {
+      assert.doesNotMatch(step, /^          cache:/m, name);
+    }
+  }
+  for (const variable of ['GOPATH', 'GOBIN', 'GOMODCACHE', 'GOCACHE']) {
+    assert.match(action, new RegExp('echo "' + variable + '=\\$\\{RUNNER_TEMP\\}/'));
+  }
+});
+
+test('formal Go setup has its own bounded installation deadline', () => {
+  for (const name of ['go-ci.yml', 'windows-module.yml', 'runtime-integration.yml', 'linux-cli-module.yml']) {
+    const source = fs.readFileSync(path.join('.github/workflows', name), 'utf8');
+    const steps = source.split(/(?=^      - )/m).filter(step =>
+      /uses: \.\/\.github\/actions\/setup-go\n/.test(step));
+    assert.ok(steps.length > 0, name);
+    for (const step of steps) {
+      assert.match(step, /^        timeout-minutes: 10$/m,
+        name + ': downloads cannot consume the complete test job budget');
+    }
+  }
+});
+
+function verificationScript() {
+  const step = action.split(/(?=^    - name:)/m).find(part =>
+    part.startsWith('    - name: Verify Go installation\n'));
+  assert.ok(step, 'setup must verify the actual Go command after the installer');
+  assert.match(step, /REQUESTED_GO_VERSION: \$\{\{ inputs\.go-version \}\}/);
+  assert.match(step, /INSTALLED_GO_VERSION: \$\{\{ steps\.install_go\.outputs\.go-version \}\}/);
+  assert.doesNotMatch(step, /continue-on-error:|if:|\|\| true/);
+  const start = step.indexOf('      run: |\n');
+  assert.ok(start >= 0, 'the actual verification script is required');
+  return step.slice(start + '      run: |\n'.length)
+    .split('\n').map(line => line.startsWith('        ') ? line.slice(8) : line)
+    .join('\n');
+}
+
+function verify(options = {}) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-go-install-'));
+  try {
+    if (!options.missingGo) {
+      fs.writeFileSync(path.join(directory, 'go'), `#!/bin/sh
+[ "$GOTOOLCHAIN" = local ] || exit 93
+case "$*" in
+  'env GOVERSION') printf 'go%s\\n' "$MOCK_GO_VERSION" ;;
+  'version') printf 'go version go%s linux/amd64\\n' "$MOCK_GO_VERSION" ;;
+  *) exit 92 ;;
+esac
+`, {mode: 0o755});
+    }
+    return spawnSync('/bin/bash', ['--noprofile', '--norc', '-c', verificationScript()], {
+      encoding: 'utf8',
+      timeout: 5000,
+      env: {
+        PATH: directory,
+        REQUESTED_GO_VERSION: options.requested ?? '1.27.2',
+        RESOLVED_GO_VERSION: options.resolved ?? options.installed ?? '1.27.2',
+        INSTALLED_GO_VERSION: options.installed ?? '1.27.2',
+        MOCK_GO_VERSION: options.actual ?? '1.27.2',
+        GOTOOLCHAIN: 'auto',
+      },
+    });
+  } finally {
+    fs.rmSync(directory, {recursive: true, force: true});
+  }
+}
+
+function resolve(requested, toolCache = 'unused-runner-cache') {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-go-resolve-'));
+  try {
+    const step = action.split(/(?=^    - name:)/m).find(part =>
+      part.startsWith('    - name: Resolve exact Go version\n'));
+    assert.ok(step, 'the installer needs a deterministic SDK resolver');
+    const start = step.indexOf('      run: |\n');
+    assert.ok(start >= 0);
+    const script = step.slice(start + '      run: |\n'.length)
+      .split('\n').map(line => line.startsWith('        ') ? line.slice(8) : line)
+      .join('\n');
+    const output = path.join(directory, 'output');
+    fs.writeFileSync(output, '');
+    const result = spawnSync('/bin/bash', ['--noprofile', '--norc', '-c', script], {
+      encoding: 'utf8',
+      timeout: 5000,
+      env: {
+        PATH: directory,
+        REQUESTED_GO_VERSION: requested,
+        RUNNER_TOOL_CACHE: toolCache,
+        GITHUB_OUTPUT: output,
+      },
+    });
+    return {...result, output: fs.readFileSync(output, 'utf8')};
+  } finally {
+    fs.rmSync(directory, {recursive: true, force: true});
+  }
+}
+
+test('setup verifies a real selected command without downloading another toolchain', () => {
+  assert.match(action, /- name: Set up Go\n      id: install_go\n      uses: actions\/setup-go@v7/);
+  assert.match(verificationScript(), /GOTOOLCHAIN=local go env GOVERSION/);
+  const result = verify();
+  assert.ifError(result.error);
+  assert.equal(result.status, 0, result.stderr);
+  assert.match(result.stdout, /Verified Go 1\.27\.2/);
+});
+
+test('a runner cache cannot substitute another patch for the frozen SDK', () => {
+  const result = verify({
+    requested: '1.26.x', resolved: '1.26.10',
+    installed: '1.26.9', actual: '1.26.9',
+  });
+  assert.ifError(result.error);
+  assert.notEqual(result.status, 0, 'the actual mixed-SDK CI group must fail closed');
+  assert.doesNotMatch(result.stdout, /Verified Go/);
+});
+
+test('the installer receives the same repository-frozen exact SDK in every job', () => {
+  const resolver = action.split(/(?=^    - name:)/m).find(part =>
+    part.startsWith('    - name: Resolve exact Go version\n'));
+  assert.ok(resolver, 'wildcard SDK labels need one deterministic tracked mapping');
+  assert.ok(action.indexOf(resolver) < action.indexOf('    - name: Set up Go\n'));
+  const installer = action.split(/(?=^    - name:)/m).find(part =>
+    part.startsWith('    - name: Set up Go\n'));
+  assert.match(installer, /go-version: \$\{\{ steps\.resolve_go\.outputs\.go-version \}\}/);
+  assert.match(action, /RESOLVED_GO_VERSION: \$\{\{ steps\.resolve_go\.outputs\.go-version \}\}/);
+});
+
+test('every compatibility selector is independent of runner cache and release timing', () => {
+  const pins = {
+    '1.20.x': '1.20.14', '1.21.x': '1.21.13',
+    '1.22.x': '1.22.12', '1.23.x': '1.23.12',
+    '1.24.x': '1.24.13', '1.25.x': '1.25.14',
+    '1.26.x': '1.26.10', '1.27.x': '1.27.3',
+  };
+  for (const file of fs.readdirSync('.github/workflows').filter(name => name.endsWith('.yml'))) {
+    const workflow = fs.readFileSync(path.join('.github/workflows', file), 'utf8');
+    for (const match of workflow.matchAll(/\b1\.[0-9]+\.x\b/g)) {
+      assert.ok(Object.hasOwn(pins, match[0]), file + ': missing frozen SDK selector');
+    }
+  }
+  for (const [requested, version] of Object.entries(pins)) {
+    for (const cache of ['image-with-old-sdk', 'image-with-new-sdk']) {
+      const result = resolve(requested, cache);
+      assert.ifError(result.error);
+      assert.equal(result.status, 0, result.stderr);
+      assert.equal(result.output, `go-version=${version}\n`);
+    }
+  }
+});
+
+test('an explicit stable SDK is preserved without a floating lookup', () => {
+  for (const version of ['1.20.14', '1.24.11', '1.27.1', '1.27.2', '1.27.3']) {
+    const result = resolve(version);
+    assert.ifError(result.error);
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.output, `go-version=${version}\n`);
+  }
+});
+
+test('unregistered or malformed SDK selectors fail before installation', () => {
+  for (const version of ['', 'stable', '1.28.x', '1.26', '1.26.*', '1.26.10rc1',
+    '1.26.x\n1.27.2', '1.26.x; echo unexpected']) {
+    const result = resolve(version);
+    assert.ifError(result.error);
+    assert.notEqual(result.status, 0, version);
+    assert.equal(result.output, '');
+  }
+});
+
+test('historical minor selectors verify their own resolved stable patch', () => {
+  for (const [requested, installed] of [['1.20.x', '1.20.14'], ['1.26.x', '1.26.10']]) {
+    const result = verify({requested, installed, actual: installed});
+    assert.ifError(result.error);
+    assert.equal(result.status, 0, result.stderr);
+  }
+});
+
+test('an interrupted installer cannot borrow a preinstalled Go or an empty output', () => {
+  for (const options of [
+    {missingGo: true},
+    {installed: ''},
+    {installed: '1.27.1'},
+    {actual: '1.27.1'},
+    {actual: '1.28.0'},
+    {installed: '1.27.2rc1', actual: '1.27.2rc1'},
+    {installed: '1.27.2\n1.27.2'},
+    {resolved: ''},
+    {resolved: '1.27.2rc1'},
+    {resolved: '1.27.2\n1.27.2'},
+    {resolved: '1.27.1'},
+    {actual: '1.27.2\n1.27.2'},
+    {requested: '1.26.x'},
+    {requested: ''},
+    {requested: 'stable'},
+  ]) {
+    const result = verify(options);
+    assert.ifError(result.error);
+    assert.notEqual(result.status, 0, JSON.stringify(options));
+    assert.doesNotMatch(result.stdout, /Verified Go/);
+  }
+});
diff --git a/.github/scripts/priority-integer-native-families.test.cjs b/.github/scripts/priority-integer-native-families.test.cjs
new file mode 100644
index 000000000..882b245b0
--- /dev/null
+++ b/.github/scripts/priority-integer-native-families.test.cjs
@@ -0,0 +1,243 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditIntegerNativeFamilies} = require('./audit-integer-native-families.cjs');
+
+// Independent owner/axis inventory: do not import the auditor's denominator.
+const owners = [
+  'TestCrossLinuxRuntimeMatrixX86MOVNTIOriginalFlagsAndFaults',
+  'TestCrossLinuxRuntimeMatrixX86PackedAlignLegacyNativeFaults',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNative386',
+  'TestCrossLinuxRuntimeMatrixX86SegmentQueryOriginalFlagsAliasesAndFaults',
+  'TestCrossLinuxRuntimeMatrixX86MoveHalfOriginalGoFlagsDFAliases',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNative386',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const packageName = 'github.com/xgo-dev/plan9asm';
+const hash = 'a'.repeat(64);
+const imageHash = 'b'.repeat(64);
+const inventory = owners.join('\n') + '\nok\t' + packageName + '\n';
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${hash} mapsha=${hash}\n`;
+const staticImage = `native oracle static IA32 ELF bytes=4096 sha256=${imageHash}\n`;
+const directImage = args => `IA32 direct ELF bytes=4096 sha256=${imageHash} argv=${args}\n`;
+const sdk = args => `actual executable=/sdk/bin/go sha256=${hash} argv=${args}\n`;
+const originalArgs = '["-test.run=^TestOriginal$" "-test.count=1" "-test.v"]';
+const compileArgs = '["test" "-p=1" "-vet=off" "-c" "-o" "/tmp/owned/original.test" "."]';
+const segmentEvidence = '48 original-Go opcode rows × 16 inputs; full GP aliases, six status flags, canaries; 160 live/dead m16 fault processes\n';
+const halfPreflight = 'half native CPUID/XCR0 AVX512F=1; original EVEX transport opcode executed\n';
+const halfEvidence = 'half native full64/FLAGS/DF=1/canary outcomes=512; complete original STD/CLD source and all eight named half moves\n';
+const halfOriginal = 'half actual original Go full64/FLAGS/DF=1/canary outcomes=512\n';
+function logicalFPEvidence(owner, original = false) {
+  const arch = owner.endsWith('386') ? '386' : 'amd64';
+  const rows = arch === '386' ? 6 : 8;
+  const values = arch === '386' ? 96 : 128;
+  const faults = arch === '386' ? 18 : 24;
+  return original
+    ? `logical FP actual original Go arch=${arch} rows=${rows} values=${values}; complete original FP divisor source and whole AX/DX/DF/canary observations\n`
+    : `logical FP native arch=${arch} rows=${rows} values=${values} dead-division-faults=${faults}; whole AX/DX, DF and canaries; zero/overflow and signed-min/-1 SIGFPE\n`;
+}
+const event = (Action, Test, Output) => ({Action, Package: packageName,
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const owner of owners) {
+    const observed = owner.includes('ImplicitDivide') || owner.includes('SegmentQuery') || owner.includes('MoveHalf');
+    const ia32 = owner.endsWith('386');
+    events.push(event('run', owner));
+    if (observed) events.push(event('output', owner, host));
+    if (owner.includes('MoveHalf')) events.push(event('output', owner, halfPreflight));
+    for (const axis of axes) {
+      const child = owner + '/' + axis;
+      events.push(event('run', child));
+      if (ia32) {
+        events.push(event('output', child, staticImage + directImage('[]') + staticImage));
+      }
+      if (owner.includes('SegmentQuery')) events.push(event('output', child, segmentEvidence));
+      if (owner.includes('MoveHalf')) events.push(event('output', child, halfEvidence));
+      if (owner.includes('LogicalFP')) events.push(event('output', child, logicalFPEvidence(owner)));
+      events.push(event('pass', child));
+    }
+    if (observed) {
+      events.push(event('output', owner, sdk('["version"]') + sdk(compileArgs)));
+      if (ia32) events.push(event('output', owner, staticImage + directImage(originalArgs)));
+      if (owner.includes('MoveHalf')) events.push(event('output', owner, halfOriginal));
+      if (owner.includes('LogicalFP')) events.push(event('output', owner, logicalFPEvidence(owner, true)));
+      events.push(event('output', owner, host));
+    }
+    events.push(event('pass', owner));
+  }
+  events.push(event('pass'));
+  return events;
+}
+
+test('native integer families require all eight roots and twenty-four complete execution axes', () => {
+  assert.deepEqual(auditIntegerNativeFamilies(inventory, serialize(completeEvents())),
+    {roots: 8, children: 24, passed: 32, skipped: 0, incomplete: 0,
+      nativeHosts: 12, sdkBuilds: 6, staticIA32Images: 14, directIA32Executions: 8});
+});
+
+test('logical FP division requires every actual native and original Go completion', () => {
+  for (const owner of owners.filter(name => name.includes('LogicalFP'))) {
+    for (const name of [owner, ...axes.map(axis => owner + '/' + axis)]) {
+      const marker = logicalFPEvidence(owner, name === owner);
+      for (const replacement of ['', marker + marker, marker.replace('rows=', 'partial-rows='),
+        marker.replace('arch=', 'emulated-arch='), marker.replace('values=', 'ignored-values=')]) {
+        const changed = completeEvents().map(value => value.Test === name && value.Output
+          ? {...value, Output: value.Output.replace(marker, replacement)} : value);
+        assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), name);
+      }
+      const early = completeEvents();
+      const at = early.findIndex(value => value.Test === name && value.Output?.includes(marker));
+      const [completion] = early.splice(at, 1);
+      const beforeRun = early.findIndex(value => value.Test === name && value.Action === 'run');
+      early.splice(beforeRun, 0, completion);
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(early)), 'completion before run');
+      const late = completeEvents();
+      const terminal = late.findIndex(value => value.Test === name && value.Action === 'pass');
+      late.splice(terminal + 1, 0, event('output', name, marker));
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(late)), 'completion after terminal');
+    }
+  }
+});
+
+test('native integer families reject each missing, failed, skipped or duplicate terminal', () => {
+  const names = owners.flatMap(owner => [owner, ...axes.map(axis => owner + '/' + axis)]);
+  for (const name of names) {
+    const original = completeEvents();
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => auditIntegerNativeFamilies(inventory,
+        serialize(original.map(value => value.Action === 'pass' && value.Test === name
+          ? {...value, Action} : value))), name + '/' + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const at = original.findIndex(value => value.Action === Action && value.Test === name);
+      assert.throws(() => auditIntegerNativeFamilies(inventory,
+        serialize(original.filter((_, index) => index !== at))), name + '/missing ' + Action);
+      const duplicate = original.slice();
+      duplicate.splice(at, 0, original[at]);
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(duplicate)),
+        name + '/duplicate ' + Action);
+    }
+  }
+});
+
+test('native integer families reject malformed packages, inventory changes and printed success', () => {
+  for (const changed of ['', inventory + owners[0] + '\n', inventory.replace(owners[0] + '\n', '')]) {
+    assert.throws(() => auditIntegerNativeFamilies(changed, serialize(completeEvents())));
+  }
+  for (const changed of [
+    [event('output', undefined, '16 passed')],
+    completeEvents().slice(1),
+    completeEvents().slice(0, -1),
+    [event('start'), ...completeEvents()],
+    [...completeEvents(), event('pass')],
+    [...completeEvents(), {Action: 'build-output', ImportPath: 'runtime', Output: 'late'}],
+    [event('run', owners[0] + '/objects-only'), ...completeEvents()],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'})),
+  ]) assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)));
+  for (const value of [event('unknown'), event('output', owners[0], 'late output')]) {
+    const changed = completeEvents();
+    changed.splice(-1, 0, value);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)));
+  }
+  assert.throws(() => auditIntegerNativeFamilies(inventory, '{not JSON}'));
+});
+
+test('division and segment native hosts and actual Go SDK builds bracket all three axes', () => {
+  for (const owner of owners.slice(2)) {
+    for (const replacement of ['', host.replace('linux/amd64', 'linux/arm64'),
+      host.replace('kernel=x86_64', 'kernel=aarch64'), host.replace(hash, 'not-a-digest')]) {
+      const changed = completeEvents().map(value => value.Test === owner && value.Output === host
+        ? {...value, Output: replacement} : value);
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), owner);
+    }
+    for (const needle of ['["version"]', compileArgs]) {
+      const changed = completeEvents().map(value => value.Test === owner && value.Output
+        ? {...value, Output: value.Output.replace(sdk(needle), '')} : value);
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), needle);
+    }
+    const changed = completeEvents();
+    const before = changed.findIndex(value => value.Test === owner && value.Output === host);
+    const [late] = changed.splice(before, 1);
+    changed.splice(before + 2, 0, late);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), 'late preflight');
+    const wrongTool = completeEvents().map(value => value.Test === owner && value.Output
+      ? {...value, Output: value.Output.replaceAll('/sdk/bin/go', '/other/bin/go')} : value);
+    // A different actual SDK path is valid if both commands bind the same tool.
+    assert.doesNotThrow(() => auditIntegerNativeFamilies(inventory, serialize(wrongTool)));
+    const splitTool = completeEvents().map(value => value.Test === owner && value.Output
+      ? {...value, Output: value.Output.replace(sdk(compileArgs), sdk(compileArgs).replace(hash, imageHash))}
+      : value);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(splitTool)), 'changed SDK');
+    const liveHostHashes = completeEvents();
+    const lastHost = liveHostHashes.findLastIndex(value => value.Test === owner && value.Output === host);
+    liveHostHashes[lastHost] = {...liveHostHashes[lastHost], Output: host.replaceAll(hash, imageHash)};
+    assert.doesNotThrow(() => auditIntegerNativeFamilies(inventory, serialize(liveHostHashes)));
+    const unboundArgs = completeEvents().map(value => value.Test === owner && value.Output
+      ? {...value, Output: value.Output.replace('"-p=1" "-vet=off"', '"-p=8"')} : value);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(unboundArgs)), 'changed build');
+    const missingPost = completeEvents();
+    const post = missingPost.findLastIndex(value => value.Test === owner && value.Output === host);
+    missingPost.splice(post, 1);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(missingPost)), 'missing final host');
+    const earlyGo = completeEvents();
+    const goAt = earlyGo.findIndex(value => value.Test === owner && value.Output?.includes('actual executable='));
+    const [originalGo] = earlyGo.splice(goAt, 1);
+    const finalChild = earlyGo.findIndex(value => value.Test === owner + '/' + axes[2] && value.Action === 'pass');
+    earlyGo.splice(finalChild, 0, originalGo);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(earlyGo)), 'Go before final axis');
+  }
+});
+
+test('segment query axes require their complete actual opcode flags alias and fault evidence', () => {
+  const owner = owners[4];
+  for (const axis of axes) {
+    for (const replacement of ['', segmentEvidence.replace('160', '159'),
+      segmentEvidence.replace('six status flags', 'ZF only')]) {
+      const changed = completeEvents().map(value => value.Test === owner + '/' + axis && value.Output
+        ? {...value, Output: value.Output.replace(segmentEvidence, replacement)} : value);
+      assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), axis);
+    }
+  }
+});
+
+test('native half moves require actual CPU original Go and each complete DF=1 axis', () => {
+  const owner = owners[5];
+  for (const name of [owner, ...axes.map(axis => owner + '/' + axis)]) {
+    const needles = name === owner ? [halfPreflight, halfOriginal] : [halfEvidence];
+    for (const needle of needles) {
+      for (const replacement of ['', needle + needle, needle.replace('=512', '=511').replace('AVX512F=1', 'AVX512F=0')]) {
+        if (replacement === needle) continue;
+        const changed = completeEvents().map(value => value.Test === name && value.Output
+          ? {...value, Output: value.Output.replace(needle, replacement)} : value);
+        assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), name);
+      }
+    }
+  }
+});
+
+test('division IA32 requires actual static and direct images in every axis and original Go', () => {
+  for (const owner of [owners[3], owners[7]]) {
+    const required = [owner, ...axes.map(axis => owner + '/' + axis)];
+    for (const name of required) {
+      for (const needle of [staticImage, directImage(name === owner ? originalArgs : '[]')]) {
+        const changed = completeEvents().map(value => value.Test === name && value.Output
+          ? {...value, Output: value.Output.replace(needle, '')} : value);
+        assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), name + needle);
+      }
+    }
+  }
+  for (const replacement of ['bytes=0', 'bytes=-1', 'bytes=guest']) {
+    const changed = completeEvents().map(value => value.Output
+      ? {...value, Output: value.Output.replaceAll('bytes=4096', replacement)} : value);
+    assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(changed)), replacement);
+  }
+  const forged = completeEvents().map(value => value.Output
+    ? {...value, Output: value.Output.replaceAll('IA32 direct ELF', 'QEMU translated ELF')} : value);
+  assert.throws(() => auditIntegerNativeFamilies(inventory, serialize(forged)));
+});
diff --git a/.github/scripts/priority-legacy-abs-sign-native.test.cjs b/.github/scripts/priority-legacy-abs-sign-native.test.cjs
new file mode 100644
index 000000000..e469aa3cb
--- /dev/null
+++ b/.github/scripts/priority-legacy-abs-sign-native.test.cjs
@@ -0,0 +1,152 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+// Independent execution denominator, not imported from the auditor.
+const roots = ['TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaultsAMD64',
+  'TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaults386'];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2_backend_O2'];
+const operations = ['PABSB', 'PABSW', 'PABSD', 'PSIGNB', 'PSIGNW', 'PSIGND',
+  'VPABSB', 'VPABSW', 'VPABSD', 'VPSIGNB', 'VPSIGNW', 'VPSIGND'];
+const roles = ['live', 'dead'];
+const children = roots.flatMap(root => axes.flatMap(axis => [root + '/' + axis,
+  ...operations.flatMap(op => roles.map(role => root + '/' + axis + '/' + op + '/' + role))]));
+const inventory = roots.join('\n') + '\nok\tgithub.com/xgo-dev/plan9asm\n';
+const digest = 'a'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${digest} mapsha=${digest}\n`;
+const preflight = 'ABS/sign actual native SSSE3=1 AVX=1\n';
+const marker = 'ABS/sign original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0\n';
+const image = `native oracle static IA32 ELF bytes=4096 sha256=${digest}\n`;
+const sdk = arch => `actual LEA source/object receipt: SDK=go1.27.2 target=linux/${arch} source=${digest} driver=${digest} object=${digest}\n`;
+const event = (Action, Test, Output) => ({Action, Package: 'github.com/xgo-dev/plan9asm',
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    events.push(event('run', root), event('output', root, host + preflight + sdk(arch)));
+    for (const axis of axes) {
+      const parent = root + '/' + axis;
+      events.push(event('run', parent));
+      if (arch === '386') events.push(event('output', parent, image));
+      for (const op of operations) for (const role of roles) {
+        const leaf = parent + '/' + op + '/' + role;
+        events.push(event('run', leaf), event('output', leaf, marker), event('pass', leaf));
+      }
+      events.push(event('pass', parent));
+    }
+    events.push(event('output', root, host), event('pass', root));
+  }
+  events.push(event('pass'));
+  return events;
+}
+
+function audit(events = completeEvents(), discovered = inventory) {
+  const filename = '.github/scripts/audit-legacy-abs-sign-native.cjs';
+  assert.ok(fs.existsSync(filename), 'original legacy alignment faults lack their required exact native auditor');
+  return require('./audit-legacy-abs-sign-native.cjs').auditLegacyAbsSignNative(discovered, serialize(events));
+}
+
+test('legacy ABS/sign native owner requires 144 complete live/dead kernel executions and 5760 direct probes', () => {
+  assert.deepEqual(audit(), {roots: 2, children: 150, passed: 152, skipped: 0, incomplete: 0,
+    nativeHosts: 4, sdkCaptures: 2, isaPreflights: 2, staticIA32Images: 3,
+    kernelExecutions: 144, directProbeProcesses: 5760});
+});
+
+test('legacy ABS/sign rejects every missing duplicated failed skipped or unfinished lifecycle', () => {
+  audit();
+  for (const name of [...roots, ...children]) {
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === name && value.Action === 'pass'
+        ? {...value, Action} : value)), name + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const original = completeEvents();
+      const at = original.findIndex(value => value.Action === Action && value.Test === name);
+      assert.throws(() => audit(original.filter((_, index) => index !== at)), name + ' missing ' + Action);
+      original.splice(at, 0, original[at]);
+      assert.throws(() => audit(original), name + ' duplicate ' + Action);
+    }
+    const late = completeEvents();
+    const at = late.findIndex(value => value.Action === 'pass' && value.Test === name);
+    late.splice(at + 1, 0, event('output', name, 'late output\n'));
+    assert.throws(() => audit(late), name + ' output after terminal');
+  }
+});
+
+test('legacy ABS/sign rejects changed native inventory package lifecycle and printed summaries', () => {
+  audit();
+  for (const discovered of ['', inventory + roots[0] + '\n', inventory.replace(roots[1], 'TestObjectOnly')]) {
+    assert.throws(() => audit(completeEvents(), discovered));
+  }
+  for (const events of [completeEvents().slice(1), completeEvents().slice(0, -1),
+    [...completeEvents(), event('pass')], [event('start'), ...completeEvents()],
+    [event('output', undefined, '144 kernels passed')],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'}))]) assert.throws(() => audit(events));
+});
+
+test('legacy ABS/sign binds each actual 20-probe completion marker to its own live kernel', () => {
+  audit();
+  for (const name of children.filter(name => name.endsWith('/live') || name.endsWith('/dead'))) {
+    for (const replacement of ['', marker + marker, marker.replace('20', '19'), marker.replace('failures 0', 'failures 1'),
+      marker.replace('MXCSR=0x1f80', 'MXCSR=inherited'), marker.replace('MXCSR=0x1f80', 'MXCSR=0x21f80'),
+      host + marker, preflight + marker, sdk('amd64') + marker, image + marker]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === name && value.Output
+        ? {...value, Output: value.Output.replace(marker, replacement)} : value)), name);
+    }
+  }
+  const misplaced = completeEvents().map(value => value.Test === roots[0] + '/backend_O0/PABSB/live' && value.Output
+    ? {...value, Test: roots[0] + '/backend_O0'} : value);
+  assert.throws(() => audit(misplaced), 'axis summary cannot replace an executed kernel');
+});
+
+test('legacy ABS/sign requires actual host ISA and original SDK object before every axis', () => {
+  audit();
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    for (const needle of [host, preflight, sdk(arch)]) {
+      for (const replacement of ['', needle + needle, needle.replace('kernel=x86_64', 'kernel=aarch64'),
+        needle.replace('SSSE3=1', 'SSSE3=0'), needle.replace('AVX=1', 'AVX=0'),
+        needle.replace(digest, 'invalid'), needle.replace('linux/' + arch, 'linux/arm64')]) {
+        if (needle === replacement) continue;
+        assert.throws(() => audit(completeEvents().map(value => value.Test === root && value.Output
+          ? {...value, Output: value.Output.replace(needle, replacement)} : value)), needle);
+      }
+    }
+    const earlyPost = completeEvents();
+    const post = earlyPost.findLastIndex(value => value.Test === root && value.Output === host);
+    const [observation] = earlyPost.splice(post, 1);
+    const beforeLast = earlyPost.findIndex(value => value.Test === root + '/' + axes[2] && value.Action === 'pass');
+    earlyPost.splice(beforeLast, 0, observation);
+    assert.throws(() => audit(earlyPost), 'final native host must follow all complete axes');
+    const earlyAxis = completeEvents();
+    const first = earlyAxis.findIndex(value => value.Test === root && value.Output?.includes(preflight));
+    const output = earlyAxis[first].Output;
+    earlyAxis[first] = event('output', root, host + preflight);
+    earlyAxis.splice(first + 2, 0, event('output', root, sdk(arch)));
+    assert.throws(() => audit(earlyAxis), 'SDK capture cannot follow an axis start');
+    assert.ok(output.includes(sdk(arch)));
+  }
+});
+
+test('legacy ABS/sign every mode32 axis binds a complete static native image before its first kernel', () => {
+  audit();
+  const root = roots[1];
+  for (const axis of axes) {
+    const parent = root + '/' + axis;
+    for (const replacement of ['', image + image, image.replace('4096', '0'),
+      image.replace(digest, 'invalid'), image.replace('static IA32', 'QEMU translated')]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === parent && value.Output
+        ? {...value, Output: value.Output.replace(image, replacement)} : value)), parent);
+    }
+    const late = completeEvents();
+    const at = late.findIndex(value => value.Test === parent && value.Output === image);
+    const [observation] = late.splice(at, 1);
+    late.splice(at + 2, 0, observation);
+    assert.throws(() => audit(late), 'IA32 image cannot be first inspected after execution');
+  }
+});
diff --git a/.github/scripts/priority-linux-cli-partitions.test.cjs b/.github/scripts/priority-linux-cli-partitions.test.cjs
new file mode 100644
index 000000000..2884a2bd0
--- /dev/null
+++ b/.github/scripts/priority-linux-cli-partitions.test.cjs
@@ -0,0 +1,261 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const {spawnSync} = require('node:child_process');
+const test = require('node:test');
+const {jobBody, jobNeeds} = require('./workflow-needs.cjs');
+
+const root = path.join(__dirname, '../..');
+const workflow = fs.readFileSync(path.join(root, '.github/workflows/go-ci.yml'), 'utf8');
+function optional(name) {
+  return fs.existsSync(path.join(root, name)) ? fs.readFileSync(path.join(root, name), 'utf8') : '';
+}
+const nested = optional('.github/workflows/linux-cli-module.yml');
+const driver = optional('scripts/test-linux-cli-module-ci.sh');
+const route = "${{ github.repository_owner == 'xgo-dev' && " +
+  "fromJSON('[\"qiniu\", \"ubuntu-24.04-large\"]') || 'ubuntu-latest' }}";
+const identity = 'linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}';
+const directory = '_out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}';
+
+function step(body, title) {
+  const selected = body.split(/(?=^      - )/m).filter(item =>
+    item.startsWith('      - name: ' + title + '\n'));
+  assert.equal(selected.length, 1, 'one actual step: ' + title);
+  return selected[0];
+}
+
+function requireCalls(source) {
+  for (const [name, flavor, version] of [
+    ['nested-cli', 'test', '${{ matrix.go-version }}'],
+    ['nested-cli-coverage', 'coverage', "'1.27.2'"],
+  ]) {
+    const body = jobBody(source, name);
+    assert.deepEqual(jobNeeds(source, name), ['ci_policy']);
+    assert.match(body, /^    uses: \.\/\.github\/workflows\/linux-cli-module\.yml$/m,
+      name + ': one serial full-package command still exhausts its shared binary deadline');
+    assert.ok(body.includes('      module: ${{ matrix.module }}\n'));
+    assert.ok(body.includes('      go-version: ' + version + '\n'));
+    assert.ok(body.includes('      flavor: ' + flavor + '\n'));
+    assert.match(body, /^        module: \[plan9asm, plan9asmll\]$/m);
+    assert.match(body, /^      fail-fast: false$/m);
+    assert.doesNotMatch(body, /^    if:|continue-on-error:|max-parallel:|\bgo test\b|^    steps:/m);
+  }
+  assert.match(jobBody(source, 'nested-cli'),
+    /^        go-version: \['1\.24\.x', '1\.25\.x', '1\.26\.x', '1\.27\.2'\]$/m);
+}
+
+function requireRoles(source) {
+  for (const input of ['module', 'go-version', 'flavor']) {
+    assert.ok(source.includes('      ' + input + ':\n        required: true\n        type: string\n'));
+  }
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(source, name);
+    assert.ok(body.includes('    runs-on: ' + route + '\n'), name + ': same explicit runner route');
+    assert.doesNotMatch(body, /continue-on-error:|max-parallel:|\|\|\s*true/);
+    assert.match(body, new RegExp('^    timeout-minutes: ' + (name === 'complete' ? 30 : 60) + '$', 'm'));
+    const setup = step(body, 'Setup Go');
+    assert.match(setup, /^        timeout-minutes: 10$/m);
+    assert.match(setup, /^        uses: \.\/\.github\/actions\/setup-go$/m);
+    assert.match(setup, /^          go-version: \$\{\{ inputs\.go-version \}\}$/m);
+    assert.doesNotMatch(setup, /^          cache:/m);
+    const compiler = step(body, 'Install LLVM 22 and cross compilers');
+    assert.match(compiler, /^        timeout-minutes: 14$/m);
+    assert.match(compiler, /^        run: bash scripts\/install-ci-llvm22-ubuntu\.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu$/m);
+    const qemu = step(body, 'Install required execution runtimes');
+    assert.match(qemu, /^        timeout-minutes: 5$/m);
+    assert.match(qemu, /^        run: bash scripts\/install-ci-qemu\.sh$/m);
+    const node = step(body, 'Setup required wasm execution runtime');
+    assert.match(node, /^        timeout-minutes: 10$/m);
+    assert.match(node, /^        uses: \.\/\.github\/actions\/setup-node22$/m);
+    assert.doesNotMatch(node, /node-version:|uses: actions\/setup-node@/);
+    for (const item of [setup, compiler, qemu, node]) {
+      assert.doesNotMatch(item, /^        if:|continue-on-error:/m);
+    }
+    assert.ok(body.indexOf(compiler) < body.indexOf(qemu));
+    assert.ok(body.indexOf(qemu) < body.indexOf(node));
+  }
+  const roots = jobBody(source, 'root-parts');
+  assert.doesNotMatch(roots, /^    if:/m);
+  assert.match(roots, /^        part: \[0, 1, 2, 3\]$/m);
+  assert.match(roots, /^      fail-fast: false$/m);
+  assert.match(roots, /test-linux-cli-module-ci\.sh \$\{\{ inputs\.module \}\} \$\{\{ inputs\.flavor \}\} execute 0 \$\{\{ matrix\.part \}\}/);
+  assert.doesNotMatch(step(roots, 'Execute disjoint root assignment'), /^        if:/m);
+  const retain = step(roots, 'Retain actual root evidence');
+  assert.match(retain, /^        if: \$\{\{ always\(\) \}\}$/m);
+  assert.match(retain, /^        uses: actions\/upload-artifact@v6$/m);
+  assert.match(retain, /^          if-no-files-found: error$/m);
+  assert.ok(retain.includes('          name: ' + identity + '-root-${{ matrix.part }}\n'));
+  assert.ok(retain.includes('          path: ' + directory + '-root-${{ matrix.part }}/\n'));
+  for (const [title, owner] of [['profile', 1], ['remaining-package', 2]]) {
+    const execution = step(roots, 'Execute complete ' + title + ' owner');
+    assert.match(execution, /^        if: \$\{\{ !cancelled\(\) && matrix\.part == 0 \}\}$/m);
+    assert.ok(execution.includes('        run: bash scripts/test-linux-cli-module-ci.sh ' +
+      '${{ inputs.module }} ${{ inputs.flavor }} execute ' + owner + ' -1\n'));
+    const artifact = step(roots, 'Retain actual ' + title + ' evidence');
+    assert.match(artifact, /^        if: \$\{\{ always\(\) && matrix\.part == 0 \}\}$/m);
+    assert.match(artifact, /^        uses: actions\/upload-artifact@v6$/m);
+    assert.match(artifact, /^          if-no-files-found: error$/m);
+    assert.ok(artifact.includes('          name: ' + identity + '-owner-' + owner + '\n'));
+    assert.ok(artifact.includes('          path: ' + directory + '-owner-' + owner + '/\n'));
+  }
+  const complete = jobBody(source, 'complete');
+  assert.deepEqual(jobNeeds(source, 'complete'), ['root-parts']);
+  assert.match(complete, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+  for (let part = 0; part < 4; part++) {
+    const download = step(complete, 'Download root part ' + part);
+    assert.match(download, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+    assert.match(download, /^        uses: actions\/download-artifact@v8$/m);
+    assert.ok(download.includes('          name: ' + identity + '-root-' + part + '\n'));
+    assert.ok(download.includes('          path: ' + directory + '-owners/owner-0000/part-000' + part + '\n'));
+  }
+  for (const [title, owner] of [['Download profile owner', 1], ['Download remaining-package owner', 2]]) {
+    const download = step(complete, title);
+    assert.match(download, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+    assert.match(download, /^        uses: actions\/download-artifact@v8$/m);
+    assert.ok(download.includes('          name: ' + identity + '-owner-' + owner + '\n'));
+    assert.ok(download.includes('          path: ' + directory + '-owners/owner-000' + owner + '\n'));
+  }
+  const verify = step(complete, 'Verify complete CLI module');
+  assert.match(verify, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+  assert.match(verify, /test-linux-cli-module-ci\.sh \$\{\{ inputs\.module \}\} \$\{\{ inputs\.flavor \}\} complete/);
+  assert.doesNotMatch(complete, /merge-multiple:|pattern:|codecov\/codecov-action/);
+  const success = step(complete, 'Require successful CLI owners');
+  assert.match(success, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+  assert.match(success, /^        run: test '\$\{\{ needs\.root-parts\.result \}\}' = success$/m);
+  const summary = step(complete, 'Show complete CLI coverage');
+  assert.match(summary, /^        if: inputs\.flavor == 'coverage'$/m);
+  assert.match(summary, /^        run: go tool cover -func=coverage-\$\{\{ inputs\.module \}\}\.out \| tail -n 1$/m);
+  assert.match(summary, /^        working-directory: cmd\/\$\{\{ inputs\.module \}\}$/m);
+  assert.ok(complete.indexOf(verify) < complete.indexOf(summary));
+  assert.ok(complete.indexOf(summary) < complete.indexOf(success));
+}
+
+function requireDriver(source) {
+  for (const text of ['plan9asm|plan9asmll)', 'test) flags=()',
+    'coverage) flags=("-coverprofile=coverage-$module.out")',
+    '-module', '-dir=cmd/$module', '-shards=8', '-workers=2', '-timeout=30m',
+    '-module-root-partitions=4', '-verify-module=_out/linux-cli-$module-$flavor-owners',
+    'GOFLAGS= GOENV=off GOWORK=off GOTOOLCHAIN=local GOMAXPROCS=2',
+    'go run ./cmd/plan9asmtest']) {
+    assert.ok(source.includes(text), 'complete original module protocol: ' + text);
+  }
+  assert.doesNotMatch(source, /(?:^|\s)-(?:run|skip|short|list)(?:=|\s)|timeout=(?:45m|60m)|\|\|\s*true/);
+}
+
+test('all CLI SDK/module invocations require strict complete partition workflows', () => requireCalls(workflow));
+test('each Linux CLI fragment and fresh aggregate owns exact tools, budgets and evidence', () => requireRoles(nested));
+test('Linux CLI driver retains full inventory, original flags and exact module protocol', () => requireDriver(driver));
+
+test('closed ownership rejects missing pieces, skipped collection and borrowed coverage', () => {
+  requireCalls(workflow);
+  requireRoles(nested);
+  requireDriver(driver);
+  for (const [before, after] of [
+    ['part: [0, 1, 2, 3]', 'part: [0, 1, 2]'],
+    ['execute 2 -1', 'execute 1 -1'],
+    ['needs: root-parts', 'needs: unrelated'],
+    ['    if: ${{ !cancelled() }}', '    if: success()'],
+    ['timeout-minutes: 60', 'timeout-minutes: 90'],
+    ['-root-3\n', '-root-2\n'],
+    ['part-0003\n', 'part-0002\n'],
+    ['uses: ./.github/actions/setup-node22', 'uses: actions/setup-node@v6'],
+    ['timeout-minutes: 10', 'timeout-minutes: 30'],
+    [' gcc-aarch64-linux-gnu', ''],
+    [' gcc-i686-linux-gnu', ''],
+    [' libc6-dev-i386-cross', ''],
+    ['install-ci-qemu.sh', 'install-unpinned-qemu.sh'],
+    ['install-ci-llvm22-ubuntu.sh', 'install-llvm23.sh'],
+    [route, "'ubuntu-latest'"],
+    [identity, 'linux-cli-wrong-module'],
+    [directory + '-root-${{ matrix.part }}/', directory + '-all-roots/'],
+    ["test '${{ needs.root-parts.result }}' = success", 'true'],
+    ['!cancelled() && matrix.part == 0', 'success() && matrix.part == 0'],
+    ['inputs.flavor == \'coverage\'', 'false'],
+  ]) {
+    const changed = nested.replace(before, () => after);
+    assert.notEqual(changed, nested, 'negative control must affect the actual source: ' + before);
+    assert.throws(() => requireRoles(changed), undefined, before);
+  }
+  for (const [before, after] of [
+    ['-timeout=30m', '-timeout=45m'], ['-shards=8', '-shards=4'],
+    ['-module-root-partitions=4', '-module-root-partitions=2'],
+    ['-verify-module=', '-replay-unverified='],
+    ['-dir=cmd/$module', '-dir=cmd/plan9asm'],
+    ['go run ./cmd/plan9asmtest', 'go run ./cmd/plan9asmtest -run=TestOnly'],
+    ['go run ./cmd/plan9asmtest', 'go run ./cmd/plan9asmtest -skip=TestSlow'],
+    ['coverage-$module.out', 'coverage-root.out'],
+  ]) {
+    const changed = driver.replace(before, () => after);
+    assert.notEqual(changed, driver);
+    assert.throws(() => requireDriver(changed), undefined, before);
+  }
+});
+
+test('actual Linux CLI shell transports every module/flavor/owner and rejects partial grammar', t => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'linux-cli-transport-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  // This is explicitly a shell transport fixture, not Go or instruction execution.
+  fs.writeFileSync(path.join(directory, 'go'), '#!/bin/bash\n' +
+    'printf "SYNTHETIC_ENV=%s/%s/%s/%s/%s\\n" "$GOFLAGS" "$GOENV" "$GOWORK" "$GOTOOLCHAIN" "$GOMAXPROCS"\n' +
+    'printf "%s\\n" SYNTHETIC_GO "$@"\n', {mode: 0o700});
+  const run = (...args) => spawnSync('bash', [path.join(root, 'scripts/test-linux-cli-module-ci.sh'), ...args], {
+    cwd: directory,
+    env: {...process.env, PATH: directory + path.delimiter + process.env.PATH, GOFLAGS: ''},
+    encoding: 'utf8', timeout: 5000,
+  });
+  for (const module of ['plan9asm', 'plan9asmll']) {
+    for (const flavor of ['test', 'coverage']) {
+      const outputs = new Set();
+      for (const [owner, part] of [['0', '0'], ['0', '1'], ['0', '2'], ['0', '3'], ['1', '-1'], ['2', '-1']]) {
+        const actual = run(module, flavor, 'execute', owner, part);
+        assert.equal(actual.status, 0, actual.stderr || String(actual.error));
+        const fields = actual.stdout.trim().split('\n');
+        assert.ok(fields.includes('SYNTHETIC_ENV=/off/off/local/2'));
+        for (const field of ['run', './cmd/plan9asmtest', '-module', '-dir=cmd/' + module,
+          '-module-owner=' + owner, '-module-root-partition=' + part, '-shards=8',
+          '-workers=2', '-timeout=30m', '-module-root-partitions=4']) {
+          assert.ok(fields.includes(field), 'actual driver lost ' + field);
+        }
+        assert.equal(fields.includes('-coverprofile=coverage-' + module + '.out'), flavor === 'coverage');
+        const output = fields.filter(field => field.startsWith('-out='));
+        assert.equal(output.length, 1);
+        assert.ok(!outputs.has(output[0]), 'owners cannot share an output directory');
+        outputs.add(output[0]);
+      }
+      if (flavor === 'coverage') {
+        assert.equal(run(module, flavor, 'complete').status, 1, 'missing complete profile must fail');
+        const profile = path.join(directory, 'cmd', module, 'coverage-' + module + '.out');
+        fs.mkdirSync(path.dirname(profile), {recursive: true});
+        fs.writeFileSync(profile, 'synthetic profile, not coverage evidence\n');
+      }
+      const complete = run(module, flavor, 'complete');
+      assert.equal(complete.status, 0, complete.stderr);
+      assert.ok(complete.stdout.includes('-verify-module=_out/linux-cli-' + module + '-' + flavor + '-owners\n'));
+      for (const role of [
+        ['execute', '0', '4'], ['execute', '0', '-1'], ['execute', '0', '01'],
+        ['execute', '0', '+1'], ['execute', '0', '1+1'], ['execute', '3', '-1'],
+        ['execute', '1', '0'], ['execute', '2', '0'], ['execute', '0'],
+        ['execute', '0', '0', 'extra'], ['complete', '0'], ['unknown'],
+      ]) {
+        const invalid = run(module, flavor, ...role);
+        assert.equal(invalid.status, 1, [module, flavor, ...role].join('/'));
+        assert.doesNotMatch(invalid.stdout, /SYNTHETIC_GO/);
+      }
+    }
+  }
+  for (const args of [['root', 'test', 'complete'], ['plan9asm', 'race', 'complete']]) {
+    const invalid = run(...args);
+    assert.equal(invalid.status, 1);
+    assert.doesNotMatch(invalid.stdout, /SYNTHETIC_GO/);
+  }
+  const flags = spawnSync('bash', [path.join(root, 'scripts/test-linux-cli-module-ci.sh'),
+    'plan9asmll', 'test', 'execute', '0', '0'], {
+    cwd: directory, env: {...process.env, PATH: directory + path.delimiter + process.env.PATH, GOFLAGS: '-run=Only'},
+    encoding: 'utf8', timeout: 5000,
+  });
+  assert.equal(flags.status, 1);
+  assert.doesNotMatch(flags.stdout, /SYNTHETIC_GO/);
+});
diff --git a/.github/scripts/priority-lock-native.test.cjs b/.github/scripts/priority-lock-native.test.cjs
new file mode 100644
index 000000000..a4622ddb3
--- /dev/null
+++ b/.github/scripts/priority-lock-native.test.cjs
@@ -0,0 +1,39 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+const roots = ['TestCrossLinuxRuntimeMatrixX86LockScalarRMWNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86LockScalarRMWNative386'];
+
+test('LOCK execution auditing requires original owners and all four completed backend children', () => {
+  const {auditNativeLock, roots: actual, children} = require('./audit-lock-native.cjs');
+  assert.deepEqual(actual, roots);
+  assert.deepEqual(children, roots.flatMap(root => ['-O0', '-O2'].map(level => root + '/' + level)));
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const child of children.filter(name => name.startsWith(root + '/'))) {
+      events.push(event('run', child), event('pass', child));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const inventory = roots.join('\n') + '\n';
+  const encode = values => values.map(JSON.stringify).join('\n') + '\n';
+  assert.deepEqual(auditNativeLock(inventory, encode(events)),
+    {roots: 2, children: 4, passed: 6, skipped: 0, incomplete: 0});
+  for (const child of children) {
+    for (const changed of [
+      events.filter(value => value.Test !== child),
+      events.filter(value => value.Test !== child || value.Action !== 'pass'),
+      events.map(value => value.Test === child && value.Action === 'pass' ? {...value, Action: 'skip'} : value),
+      events.map(value => value.Test === child ? {...value, Test: child + '-object-only'} : value),
+    ]) assert.throws(() => auditNativeLock(inventory, encode(changed)));
+  }
+  for (const changed of [events.slice(0, -1), [...events, event('pass')],
+    [event('start'), {...event('output'), Output: encode(events)}, event('pass')]]) {
+    assert.throws(() => auditNativeLock(inventory, encode(changed)));
+  }
+});
diff --git a/.github/scripts/priority-mask-vector-inputs.test.cjs b/.github/scripts/priority-mask-vector-inputs.test.cjs
new file mode 100644
index 000000000..4821bb2dd
--- /dev/null
+++ b/.github/scripts/priority-mask-vector-inputs.test.cjs
@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+
+test('portable fault audit requires both actual owners and every completed child', () => {
+  const {auditValueFaultPriority, roots, children} = require('./audit-value-fault-priority.cjs');
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const child of children.filter(child => child.startsWith(root+'/'))) {
+      events.push(event('run', child), event('pass', child));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const inventory = roots.join('\n')+'\nok\tgithub.com/xgo-dev/plan9asm\n';
+  const encode = values => values.map(value => JSON.stringify(value)).join('\n')+'\n';
+  assert.deepEqual(auditValueFaultPriority(inventory, encode(events)),
+    {roots:2, children:8, passed:10, skipped:0, incomplete:0});
+  for (const changed of [
+    events.filter(value => value.Test !== children[0]),
+    events.filter(value => value.Test !== children[0] || value.Action !== 'pass'),
+    events.map(value => value.Test === children[0] && value.Action === 'pass' ? {...value, Action:'skip'} : value),
+    events.map(value => value.Test === children[0] && value.Action === 'pass' ? {...value, Action:'fail'} : value),
+    events.map(value => value.Test === children[0] ? {...value, Test:children[0]+'/sample'} : value),
+    events.slice(0,-1),
+    [...events, event('pass')],
+    [event('start'), {...event('output'), Output:'PASS '+children.join('\nPASS ')}, event('pass')],
+  ]) assert.throws(() => auditValueFaultPriority(inventory, encode(changed)));
+  assert.throws(() => auditValueFaultPriority(inventory.replace(roots[0], 'TestUnrelatedOwner'), encode(events)));
+});
diff --git a/.github/scripts/priority-mmx-streaming.test.cjs b/.github/scripts/priority-mmx-streaming.test.cjs
new file mode 100644
index 000000000..8a2393d71
--- /dev/null
+++ b/.github/scripts/priority-mmx-streaming.test.cjs
@@ -0,0 +1,26 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditMMXStreaming, roots, children} = require('./audit-mmx-streaming.cjs');
+
+test('MMX streaming audit rejects omitted, skipped or substituted original/backend execution', () => {
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start'), event('run', roots[0])];
+  for (const child of children) events.push(event('run', child), event('pass', child));
+  events.push(event('pass', roots[0]), event('pass'));
+  const encode = values => values.map(JSON.stringify).join('\n') + '\n';
+  assert.deepEqual(auditMMXStreaming(roots[0] + '\n', encode(events)),
+    {roots:1, children:5, passed:6, skipped:0, incomplete:0});
+  for (const child of children) {
+    for (const changed of [
+      events.filter(value => value.Test !== child),
+      events.map(value => value.Test === child && value.Action === 'pass' ? {...value, Action:'skip'} : value),
+      events.map(value => value.Test === child ? {...value, Test:child+'-object-only'} : value),
+    ]) assert.throws(() => auditMMXStreaming(roots[0]+'\n', encode(changed)));
+  }
+  assert.throws(() => auditMMXStreaming('TestOtherOwner\n', encode(events)));
+  assert.throws(() => auditMMXStreaming(roots[0]+'\n', encode([
+    event('start'), {...event('output'), Output:'PASS '+children.join('\nPASS ')}, event('pass'),
+  ])));
+});
diff --git a/.github/scripts/priority-module-root-parts.test.cjs b/.github/scripts/priority-module-root-parts.test.cjs
new file mode 100644
index 000000000..6e5714337
--- /dev/null
+++ b/.github/scripts/priority-module-root-parts.test.cjs
@@ -0,0 +1,350 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+const {requireJobNeeds} = require('./workflow-needs.cjs');
+
+const workflow = fs.readFileSync(
+  path.join(__dirname, '../workflows/go-ci.yml'), 'utf8',
+);
+const script = fs.readFileSync(
+  path.join(__dirname, '../../scripts/test-module-ci.sh'), 'utf8',
+);
+
+function job(name, source = workflow) {
+  const marker = `\n  ${name}:\n`;
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, `missing job ${name}`);
+  const body = source.slice(start + marker.length);
+  const end = body.search(/^  [a-zA-Z][a-zA-Z0-9_-]*:\s*$/m);
+  return end < 0 ? body : body.slice(0, end);
+}
+
+function step(body, name) {
+  const marker = `      - name: ${name}\n`;
+  const start = body.indexOf(marker);
+  assert.notEqual(start, -1, `missing step ${name}`);
+  const end = body.indexOf('\n      - name:', start + marker.length);
+  return body.slice(start, end < 0 ? body.length : end);
+}
+
+test('every Unix root owner uses one two-shard wave with complete flavor-specific roles', () => {
+  for (const name of ['test', 'race', 'coverage']) {
+    const count = name === 'race' ? 32 : 16;
+    const roles = [
+      ...Array.from({ length: count }, (_, index) => `root-${index}`),
+      'profile', 'other',
+    ];
+    const body = job(name);
+    const match = body.match(/^        module-role: \[([^\]]+)\]$/m);
+    assert.ok(match, `${name}: missing explicit module scheduling roles`);
+    assert.deepEqual(match[1].split(',').map(value => value.trim()), roles);
+
+    const mappings = Array.from(body.matchAll(
+      /^          - \{module-role: (root-\d+|profile|other), module-owner: ([012]), root-partition: (-?\d+)\}$/gm,
+    ), ([, role, owner, part]) => [role, Number(owner), Number(part)]);
+    assert.deepEqual(mappings, [
+      ...Array.from({ length: count }, (_, index) => [`root-${index}`, 0, index]),
+      ['profile', 1, -1],
+      ['other', 2, -1],
+    ], `${name}: role mapping repeats or loses package/shard ownership`);
+    assert.doesNotMatch(body, /^        module-owner: \[/m,
+      `${name}: Cartesian ownership repeats profile/rest`);
+    assert.match(body, /^      fail-fast: false$/m);
+    assert.doesNotMatch(body, /max-parallel:|continue-on-error:/);
+  }
+});
+
+test('root job fanout retains original workers, per-command and job budgets', () => {
+  assert.match(script, /test\) timeout=45m ;;/);
+  assert.match(script, /race\) timeout=60m; flags=\(-race\); root_partitions=32; shards=64 ;;/);
+  assert.match(script, /coverage\) timeout=45m; flags=\(-coverprofile=coverage-root\.out\) ;;/);
+  assert.match(script, /-shards=\$shards -workers=2/);
+  assert.match(script, /GOMAXPROCS=2/);
+  for (const [name, minutes] of [['test', 60], ['race', 75], ['coverage', 60]]) {
+    assert.match(job(name), new RegExp(`^    timeout-minutes: ${minutes}$`, 'm'));
+  }
+  assert.match(job('module-completion'), /^    timeout-minutes: 30$/m);
+});
+
+test('executor and completion both request the same explicit root partition count', () => {
+  assert.match(script, /^root_partitions=16$/m);
+  assert.match(script, /-module-root-partitions=\$root_partitions/);
+  assert.match(script, /-module-root-partition=\$4/);
+  assert.match(script, /\[\[ \$# != 4/);
+  for (const [name, flavor, title] of [
+    ['test', 'test', 'Go test (Ubuntu)'],
+    ['race', 'race', 'Go test (race)'],
+    ['coverage', 'coverage', 'Go test with coverage'],
+  ]) {
+    assert.match(step(job(name), title), new RegExp(
+      `bash scripts/test-module-ci\\.sh ${flavor} execute \\$\\{\\{ matrix\\.module-owner \\}\\} \\$\\{\\{ matrix\\.root-partition \\}\\}`,
+    ));
+  }
+  assert.match(step(job('module-completion'), 'Check complete actual module inventory and coverage'),
+    /bash scripts\/test-module-ci\.sh \$\{\{ matrix\.flavor \}\} complete/);
+});
+
+test('actual shell dispatch validates flavor-specific part bounds before launching Go', t => {
+  // This is only an argument-transport fixture, never compiler/test evidence.
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'module-ci-args-'));
+  t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+  fs.writeFileSync(path.join(directory, 'go'),
+    '#!/usr/bin/env bash\nprintf "%s\\n" SYNTHETIC_GO "$@"\n', { mode: 0o700 });
+  const run = (...args) => spawnSync('bash', [
+    path.join(__dirname, '../../scripts/test-module-ci.sh'), ...args,
+  ], {
+    cwd: directory,
+    env: { ...process.env, PATH: directory + path.delimiter + process.env.PATH, GOFLAGS: '' },
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  for (const [flavor, count, shards] of [['test', 16, 32], ['coverage', 16, 32], ['race', 32, 64]]) {
+    for (const args of [['execute', '0', String(count - 1)], ['execute', '2', '-1'], ['complete']]) {
+      const actual = run(flavor, ...args);
+      assert.equal(actual.status, 0, actual.stderr || String(actual.error));
+      const fields = actual.stdout.trim().split('\n');
+      assert.equal(fields[0], 'SYNTHETIC_GO');
+      assert.ok(fields.includes(`-module-root-partitions=${count}`));
+      assert.ok(fields.includes(`-shards=${shards}`));
+      assert.ok(fields.includes('-workers=2'));
+    }
+    for (const part of [String(count), '-1', '01', '1+1', '999999999999999999999']) {
+      const actual = run(flavor, 'execute', '0', part);
+      assert.equal(actual.status, 1, `${flavor}/${part}: ${actual.stderr}`);
+      assert.doesNotMatch(actual.stdout, /SYNTHETIC_GO/);
+    }
+  }
+});
+
+test('each root part has an exact separate artifact and strict download destination', () => {
+  for (const name of ['test', 'race', 'coverage']) {
+    const body = job(name);
+    assert.match(body, /name: module-(?:test|race|coverage)-.*\$\{\{ matrix\.module-role \}\}/);
+    assert.match(body, /if-no-files-found: error/);
+  }
+  const aggregate = job('module-completion');
+  for (let part = 0; part < 32; part++) {
+    const download = step(aggregate, `Download root part ${part}`);
+    assert.match(download, new RegExp(
+      `^          name: module-\\$\\{\\{ matrix\\.flavor \\}\\}-\\$\\{\\{ matrix\\.go-version \\}\\}-root-${part}$`, 'm',
+    ));
+    assert.match(download, new RegExp(
+      `^          path: _out/module-\\$\\{\\{ matrix\\.flavor \\}\\}-owners/owner-0000/part-${String(part).padStart(4, '0')}$`, 'm',
+    ));
+    if (part >= 16) {
+      assert.match(download, /if: \$\{\{ !cancelled\(\) && matrix\.flavor == 'race' \}\}/);
+    } else {
+      assert.doesNotMatch(download, /matrix\.flavor ==/);
+    }
+  }
+  assert.match(step(aggregate, 'Download profile owner'), /-profile$/m);
+  assert.match(step(aggregate, 'Download remaining-package owner'), /-other$/m);
+  assert.doesNotMatch(aggregate, /merge-multiple:|pattern:/);
+  requireJobNeeds(workflow, 'module-completion', ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']);
+  assert.match(aggregate, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+});
+
+test('owner-two numerical fixture runs once and CLIs have independent complete modules', () => {
+  const body = job('test');
+  assert.match(step(body, 'Required exact downloaded AMD64 numerical fixture'), /matrix\.module-owner == 2/);
+  assert.doesNotMatch(body, /nested_modules|working-directory: cmd\/plan9asm/);
+  requireJobNeeds(workflow, 'nested-cli', ['ci_policy']);
+  assert.match(job('nested-cli'), /^        module: \[plan9asm, plan9asmll\]$/m);
+  assert.doesNotMatch(body, /os: windows-latest/);
+  assert.match(job('windows-module'), /uses: \.\/\.github\/workflows\/windows-module\.yml/);
+  assert.match(body,
+    /go-version: \['1\.27\.2', '1\.20\.x', '1\.26\.x', '1\.25\.x', '1\.24\.x', '1\.23\.x', '1\.22\.x', '1\.21\.x'\]/);
+});
+
+test('selected native CI remains a separate sixteen-owner serial protocol', () => {
+  const body = job('cross-runtime');
+  assert.match(body, /owner: \[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15\]/);
+  assert.match(body, /-ci-owner \$\{\{ matrix.owner \}\} -shards 16 -timeout 20m/);
+  assert.doesNotMatch(body, /module-root-partition|module-owner|(?:^|\s)-workers(?:=|\s)/);
+});
+
+test('Windows modules retain disjoint scheduling and complete coverage readback', () => {
+  const body = job('windows-module');
+  assert.match(body, /^    needs: ci_policy$/m);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.match(body, /^        module: \[root, plan9asm, plan9asmll\]$/m);
+  assert.doesNotMatch(body, /max-parallel:|continue-on-error:/);
+
+  const native = fs.readFileSync(path.join(__dirname, '../workflows/windows-module.yml'), 'utf8');
+  const roots = job('root-parts', native);
+  assert.match(roots, /inputs.module == 'root' && '\[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15\]' \|\| '\[0,1,2,3\]'/);
+  assert.match(roots, /execute 0 \$\{\{ matrix.part \}\}/);
+  const others = job('other-owners', native);
+  assert.match(others, /owner: \[1, 2\]/);
+  assert.match(others, /execute \$\{\{ matrix.owner \}\} -1/);
+  for (const owner of [roots, others]) {
+    assert.match(owner, /fail-fast: false/);
+    assert.match(owner, /timeout-minutes: 60/);
+    assert.match(owner, /if-no-files-found: error/);
+    assert.doesNotMatch(owner, /max-parallel:|continue-on-error:|codecov-action/);
+  }
+  const complete = job('complete', native);
+  requireJobNeeds(native, 'complete', ['root-parts', 'other-owners']);
+  assert.match(complete, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+  assert.doesNotMatch(complete, /merge-multiple:|pattern:/);
+  assert.deepEqual(Array.from(complete.matchAll(
+    /^      - name: Download root part (\d+)$/gm,
+  ), ([, part]) => Number(part)), Array.from({ length: 16 }, (_, part) => part));
+  for (let part = 0; part < 16; part++) {
+    const download = step(complete, `Download root part ${part}`);
+    assert.match(download, new RegExp(`-root-${part}$`, 'm'));
+    assert.match(download, new RegExp(`owner-0000/part-${String(part).padStart(4, '0')}$`, 'm'));
+    if (part >= 4) assert.match(download, /if: \$\{\{ inputs.module == 'root' \}\}/);
+    else assert.doesNotMatch(download, /if:/);
+  }
+  assert.match(step(complete, 'Download profile owner'), /owner-0001$/m);
+  assert.match(step(complete, 'Download remaining-package owner'), /owner-0002$/m);
+  assert.match(step(complete, 'Verify complete module and publish coverage'),
+    /test-windows-module-ci.sh \$\{\{ inputs.module \}\} complete/);
+  assert.match(step(complete, 'Upload verified complete Windows module coverage'),
+    /files: \.\/coverage-windows-\$\{\{ inputs.module \}\}\.out/);
+});
+
+function windowsModuleShellFixture(t) {
+  // Argument transport only; native Go execution is covered by the Windows
+  // module fixture, not by this synthetic command.
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'windows-module-ci-args-'));
+  t.after(() => fs.rmSync(directory, { recursive: true, force: true }));
+  const tools = Object.fromEntries(['go', 'llvm', 'node', 'python', 'jq'].map(name => {
+    const bin = path.join(directory, name, 'bin');
+    fs.mkdirSync(bin, { recursive: true });
+    return [name, bin];
+  }));
+  fs.writeFileSync(path.join(tools.go, 'go'), `#!/bin/bash
+if [[ "$*" == 'env GOHOSTOS' ]]; then
+  echo windows
+elif [[ "$*" == 'env GOROOT' ]]; then
+  printf '%s\\n' '${path.dirname(tools.go)}'
+else
+  printf 'SYNTHETIC_PATH=%s\\n' "$PATH"
+  printf '%s\\n' SYNTHETIC_GO "$@"
+fi
+`, { mode: 0o700 });
+  const commands = {
+    [path.join(directory, 'cygpath')]: 'if [[ "$1" == -m ]]; then echo C:/fixture; else printf "%s\\n" "$2"; fi',
+    [path.join(tools.llvm, 'llvm-config')]: `if [[ "$1" == --version ]]; then echo 22.1.8; else echo '${tools.llvm}'; fi`,
+    [path.join(tools.node, 'node')]: `echo '${tools.node}'`,
+    [path.join(tools.python, 'python')]: `echo '${tools.python}'`,
+    [path.join(tools.jq, 'jq')]: 'exit 0',
+  };
+  for (const [file, body] of Object.entries(commands)) {
+    fs.writeFileSync(file, `#!/usr/bin/env bash\n${body}\n`, { mode: 0o700 });
+  }
+  const environment = {};
+  const runAmbient = (ambient, flags, ...args) => spawnSync('bash', [
+    path.join(__dirname, '../../scripts/test-windows-module-ci.sh'), ...args,
+  ], {
+    cwd: directory,
+    env: {
+      ...process.env,
+      PATH: [directory, ...Object.values(tools), ambient, process.env.PATH].join(path.delimiter),
+      GOFLAGS: flags,
+      LLVM_CONFIG: '',
+      SYSTEMROOT: path.join(directory, 'Windows'),
+      ...environment,
+    },
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  return { directory, tools, environment, runAmbient, run: (flags, ...args) => runAmbient('', flags, ...args) };
+}
+
+test('Windows shell transports complete module roles and rejects hidden build flags', t => {
+  const { directory, run } = windowsModuleShellFixture(t);
+  for (const [module, parts, shards] of [['root', 16, 64], ['plan9asm', 4, 8], ['plan9asmll', 4, 8]]) {
+    const rootRoles = Array.from({ length: parts }, (_, part) => ['execute', '0', String(part)]);
+    for (const args of [...rootRoles, ['execute', '1', '-1'], ['execute', '2', '-1']]) {
+      const actual = run('-tags=byollvm', module, ...args);
+      assert.equal(actual.status, 0, actual.stderr || String(actual.error));
+      const fields = actual.stdout.trim().split('\n');
+      assert.ok(fields.includes(`-module-owner=${args[1]}`));
+      assert.ok(fields.includes(`-module-root-partition=${args[2]}`));
+      for (const field of ['-module', '-timeout=30m', '-workers=2', '-tags=byollvm',
+        `-shards=${shards}`, `-module-root-partitions=${parts}`, `-coverprofile=C:/fixture/coverage-windows-${module}.out`]) {
+        assert.ok(fields.includes(field), `missing ${field}: ${actual.stdout}`);
+      }
+      assert.doesNotMatch(actual.stdout, /-run[=\s]|-skip[=\s]/);
+    }
+    const invalidParts = [String(parts), '-1', '-0', '+1', '01', '08', '1+1', '999999999999999999999'];
+    for (const args of [
+      ...invalidParts.map(part => ['execute', '0', part]),
+      ['execute', '1', '0'], ['complete', '0'],
+    ]) {
+      const actual = run('-tags=byollvm', module, ...args);
+      assert.equal(actual.status, 1, `${module}/${args}: ${actual.stderr}`);
+      assert.doesNotMatch(actual.stdout, /SYNTHETIC_GO/);
+    }
+    const missing = run('-tags=byollvm', module, 'complete');
+    assert.equal(missing.status, 1, 'completion without an actual profile must fail');
+    fs.writeFileSync(path.join(directory, `coverage-windows-${module}.out`), 'fixture\n');
+    const complete = run('-tags=byollvm', module, 'complete');
+    assert.equal(complete.status, 0, complete.stderr);
+    assert.match(complete.stdout, new RegExp(`-verify-module=_out/windows-module-${module}-owners`));
+  }
+  for (const flags of ['', '-tags=foreign', '-tags=byollvm -run=TestOnly']) {
+    const actual = run(flags, 'root', 'execute', '0', '0');
+    assert.equal(actual.status, 1, actual.stderr);
+    assert.doesNotMatch(actual.stdout, /SYNTHETIC_GO/);
+  }
+});
+
+test('Windows module execution and aggregation exclude ambient Git and WSL paths', t => {
+  const { directory, tools, runAmbient } = windowsModuleShellFixture(t);
+  const paths = [];
+  for (const [git, wsl] of [['ucrt64', true], ['mingw64', false]]) {
+    const ambient = [path.join(directory, 'Git', git, 'bin')];
+    if (wsl) ambient.push(path.join(directory, 'WSL'));
+    for (const role of [['execute', '0', '0'], ['complete']]) {
+      fs.writeFileSync(path.join(directory, 'coverage-windows-root.out'), 'fixture\n');
+      const actual = runAmbient(ambient.join(path.delimiter), '-tags=byollvm', 'root', ...role);
+      assert.equal(actual.status, 0, actual.stderr);
+      const observed = actual.stdout.split('\n').find(line => line.startsWith('SYNTHETIC_PATH='));
+      assert.ok(observed, 'the actual driver did not reach the synthetic command');
+      paths.push(observed.slice('SYNTHETIC_PATH='.length));
+    }
+  }
+  assert.equal(new Set(paths).size, 1, 'cross-owner tool search still depends on the hosted image');
+  const selected = paths[0].split(path.delimiter);
+  for (const bin of Object.values(tools)) assert.ok(selected.includes(bin), `lost selected ${bin}`);
+  assert.doesNotMatch(paths[0], /ucrt64|mingw64|WSL/);
+  assert.deepEqual(selected, [
+    tools.go, tools.llvm, tools.node, tools.python, tools.jq,
+    '/cmd', '/usr/bin', path.join(directory, 'Windows', 'System32'), path.join(directory, 'Windows'),
+  ]);
+});
+
+test('Windows module tool selection fails without falling back from explicit LLVM', t => {
+  const { directory, tools, environment, run } = windowsModuleShellFixture(t);
+  const configured = path.join(directory, 'explicit-llvm-config');
+  environment.LLVM_CONFIG = configured;
+  for (const version of ['23.1.0', '21.1.8', '', '22.1.8\nforeign']) {
+    fs.writeFileSync(configured, `#!/usr/bin/env bash\nprintf '%s\\n' '${version}'\n`, { mode: 0o700 });
+    const actual = run('-tags=byollvm', 'root', 'execute', '0', '0');
+    assert.equal(actual.status, 1, actual.stderr);
+    assert.match(actual.stderr, /selected LLVM 22/);
+    assert.doesNotMatch(actual.stdout, /SYNTHETIC_GO/);
+  }
+  environment.LLVM_CONFIG = path.join(directory, 'missing-llvm-config');
+  const missing = run('-tags=byollvm', 'root', 'execute', '0', '0');
+  assert.notEqual(missing.status, 0);
+  assert.doesNotMatch(missing.stdout, /SYNTHETIC_GO/);
+  environment.LLVM_CONFIG = '';
+  for (const name of ['node', 'python']) {
+    const file = path.join(tools[name], name);
+    const original = fs.readFileSync(file);
+    fs.writeFileSync(file, '#!/usr/bin/env bash\nexit 17\n', { mode: 0o700 });
+    const actual = run('-tags=byollvm', 'root', 'execute', '0', '0');
+    assert.equal(actual.status, 1, actual.stderr);
+    assert.match(actual.stderr, /one nonempty path/);
+    assert.doesNotMatch(actual.stdout, /SYNTHETIC_GO/);
+    fs.writeFileSync(file, original, { mode: 0o700 });
+  }
+});
diff --git a/.github/scripts/priority-native-auditor.test.cjs b/.github/scripts/priority-native-auditor.test.cjs
new file mode 100644
index 000000000..e10afd64d
--- /dev/null
+++ b/.github/scripts/priority-native-auditor.test.cjs
@@ -0,0 +1,300 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const test = require('node:test');
+const { auditNativePriority } = require('./audit-native-priority.cjs');
+
+// Synthetic machine-event controls are not native execution receipts.
+const inventories = {
+  'static-read': ['TestX86RawReturnStaticReadNumericOracle'],
+  alias: ['TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesOriginalAndLLVM',
+    'TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesCountedProvenance'],
+  bool: ['TestCrossLinuxRuntimeMatrixAMD64RegisterCanonicalBoolInstructionBytes',
+    'TestCrossLinuxRuntimeMatrixGoAMD64CanonicalBoolByteRepresentation'],
+  caller: ['TestCrossLinuxRuntimeMatrixX86CallerAddressInstructionBytesAndLLVM',
+    'TestCrossLinuxRuntimeMatrixGoX86CallerAddressABI0Representation'],
+  'caller-cmp': ['TestCrossLinuxRuntimeMatrixX86CallerAddressCMPInstructionBytesAndLLVM',
+    'TestCrossLinuxRuntimeMatrixGoX86CallerAddressCMPABI0Representation'],
+  numerical: ['TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableAMD64',
+    'TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableLocalAMD64'],
+  'numerical-lea': ['TestCrossLinuxRuntimeMatrixX86NumericalLEAOriginalBytesAndLLVM'],
+  'direct-tail': ['TestCrossLinuxRuntimeMatrixAMD64DirectTailWholeSourceOriginalGoAndLLVM',
+    'TestCrossLinuxRuntimeMatrixX86DirectTail386OriginalGoAndLLVM',
+    'TestCrossLinuxRuntimeMatrixX86DirectTailPCResultAliasesAndExternal'],
+  'gp-simd-sparse': ['TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNativeAMD64OriginalGoAndLLVM',
+    'TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNative386OriginalGoAndLLVM'],
+  'bit-scan': ['TestCrossLinuxRuntimeMatrixX86BitScanNativeAMD64OriginalGoAndLLVM',
+    'TestCrossLinuxRuntimeMatrixX86BitScanNative386OriginalGoAndLLVM'],
+  'bool-386': ['TestCrossLinuxRuntimeMatrixX86ABI0Mode32CanonicalBoolOriginalGoAndLLVM'],
+  'packed-string': ['TestCrossLinuxRuntimeMatrixX86PackedStringImplicitVectorNativeAVX'],
+  'independent-fp': ['TestCrossLinuxRuntimeMatrixX86InsertExtractIndependentFPFields',
+    'TestCrossLinuxRuntimeMatrixX86LegacyPSIndependentFPFields'],
+  'source-stack': ['TestCrossLinuxRuntimeMatrixX86RawSourceStackNumerical'],
+  continuation: ['TestCrossLinuxRuntimeMatrixX86ContinuationWholeCFGOriginalGoAndLLVM'],
+  'packed-string-fault': ['TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults'],
+  'byte-swap': ['TestCrossLinuxRuntimeMatrixX86ByteSwapOriginalGoAndLLVM'],
+  crc32: ['TestAMD64CRC32RuntimeSemanticsAndFlags'],
+  'bit-test': ['TestCrossLinuxRuntimeMatrixX86BitTestNumericalAndAliases'],
+};
+const sourceStack = inventories['source-stack'][0];
+const continuation = inventories.continuation[0];
+const packedStringFault = inventories['packed-string-fault'][0];
+const byteSwap = inventories['byte-swap'][0];
+const crc32 = inventories.crc32[0];
+const bitTest = inventories['bit-test'][0];
+const directTail386 = inventories['direct-tail'][1];
+const mode32Children = [
+  ...['SI', 'BP', 'SI-stack', 'BP-stack'].map(carrier => directTail386 + '/' + carrier),
+  ...['BP-memory', 'BP-register', 'BP-target'].map(dispatch => continuation + '/386/' + dispatch),
+];
+const requiredChildren = [sourceStack + '/amd64', sourceStack + '/386',
+  ...['amd64', '386'].flatMap(arch => ['memory', 'register'].map(dispatch =>
+    continuation + '/' + arch + '/' + dispatch)),
+  packedStringFault + '/-O0', packedStringFault + '/-O2',
+  byteSwap + '/amd64', byteSwap + '/386', ...mode32Children,
+  ...['text', 'module', 'Go'].flatMap(api => ['backend_O0', 'IR_O2/backend_O2']
+    .map(axis => `${bitTest}/${api}/${axis}`))];
+
+function fixture() {
+  const files = new Map();
+  for (const [name, roots] of Object.entries(inventories)) {
+    files.set(name + '-inventory.log', roots.join('\n') + '\n');
+  }
+  const roots = Object.values(inventories).flat();
+  for (let index = 0; index < 37; index++) roots.push('TestSyntheticExtraOwner' + index);
+  const events = [];
+  const emit = (Action, Test) => events.push({
+    Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? { Test } : {}), Elapsed: 1,
+  });
+  for (const root of roots) {
+    emit('run', root);
+    for (const child of requiredChildren.filter(name => name.startsWith(root + '/'))) {
+      emit('run', child);
+      emit('pass', child);
+    }
+    if (root === 'TestSyntheticExtraOwner0') {
+      // A literal slash in one t.Run name does not create intermediate parents.
+      emit('run', root + '/one/literal/name');
+      emit('pass', root + '/one/literal/name');
+    }
+    emit('pass', root);
+  }
+  events.push({ Action: 'output', Package: 'github.com/xgo-dev/plan9asm',
+    Output: '--- PASS: TestOriginal (1.00s)\n{"Action":"pass","Test":"TestForgedPayload"}\n' });
+  emit('pass');
+  files.set('all-roots.stdout', roots.join('\n') + '\n');
+  files.set('native.jsonl', events.map(JSON.stringify).join('\n') + '\n');
+  files.set('native.stderr', '');
+  return files;
+}
+
+function events(files) {
+  return files.get('native.jsonl').trim().split('\n').map(JSON.parse);
+}
+
+function replaceEvents(files, rows) {
+  files.set('native.jsonl', rows.map(JSON.stringify).join('\n') + '\n');
+}
+
+function audit(files) {
+  return auditNativePriority('synthetic-fixture', {
+    readdirSync() { return [...files.keys()]; },
+    readFileSync(filename) {
+      const name = path.basename(filename);
+      assert.ok(files.has(name), 'missing synthetic file: ' + name);
+      return files.get(name);
+    },
+  });
+}
+
+test('synthetic66 requires nineteen inventories,29 owners and23 source/ISA/fault children', () => {
+  const result = audit(fixture());
+  assert.equal(result.protocol, 'go_test_json_native66');
+  assert.equal(result.roots, 66);
+  assert.equal(result.inventories, 19);
+  assert.equal(result.mandatory.length, 29);
+  assert.ok(result.mandatory.includes(inventories['static-read'][0]));
+  assert.ok(result.mandatory.includes(crc32));
+  assert.ok(result.mandatory.includes(bitTest));
+  assert.equal(result.requiredChildren.length, 23);
+  // Only this synthetic fixture has24 children; real execution is counted.
+  assert.equal(result.children, 24);
+});
+
+test('static-read native root cannot be replaced by a same-count nonmandatory owner', () => {
+  const files = fixture();
+  const root = inventories['static-read'][0];
+  files.set('all-roots.stdout', files.get('all-roots.stdout').replace(root, 'TestUnrelatedStaticRead'));
+  files.set('native.jsonl', files.get('native.jsonl').replaceAll(root, 'TestUnrelatedStaticRead'));
+  assert.throws(() => audit(files), /mandatory root/);
+});
+
+test('CRC32 native root cannot be replaced by a same-count nonmandatory owner', () => {
+  const files = fixture();
+  files.set('all-roots.stdout', files.get('all-roots.stdout').replace(crc32, 'TestUnrelatedCRC32Owner'));
+  files.set('native.jsonl', files.get('native.jsonl').replaceAll(crc32, 'TestUnrelatedCRC32Owner'));
+  assert.throws(() => audit(files), /mandatory root/);
+});
+
+test('CRC32 native root cannot be supplied by printed run and PASS payloads', () => {
+  const files = fixture();
+  const rows = events(files).filter(event => event.Test !== crc32);
+  rows.splice(rows.length - 1, 0, { Action: 'output', Package: 'github.com/xgo-dev/plan9asm',
+    Output: JSON.stringify({ Action: 'run', Test: crc32 }) + '\n' +
+      JSON.stringify({ Action: 'pass', Test: crc32 }) + '\n' });
+  replaceEvents(files, rows);
+  assert.throws(() => audit(files), /denominator|mandatory root/);
+});
+
+test('fresh full discovery rejects same-count nonmandatory root substitution', () => {
+  const files = fixture();
+  files.set('native.jsonl', files.get('native.jsonl').replaceAll(
+    'TestSyntheticExtraOwner0', 'TestUnrelatedSameCountOwner'));
+  assert.throws(() => audit(files), /discovery/);
+});
+
+test('missing, duplicate or renamed independent inventory cannot certify execution', () => {
+  for (const inventory of Object.keys(inventories)) {
+    const absent = fixture();
+    absent.delete(inventory + '-inventory.log');
+    assert.throws(() => audit(absent), /inventories/);
+    const renamed = fixture();
+    renamed.set(inventory + '-inventory.log', 'TestUnrelatedNativeOwner\n');
+    assert.throws(() => audit(renamed), /inventory/);
+    const duplicate = fixture();
+    duplicate.set(inventory + '-inventory.log', duplicate.get(inventory + '-inventory.log').repeat(2));
+    assert.throws(() => audit(duplicate), /inventory/);
+  }
+});
+
+test('each required source-stack ISA, continuation dispatch, fault and byte-swap axis must finish', () => {
+  for (const child of requiredChildren) {
+    const files = fixture();
+    replaceEvents(files, events(files).filter(event => event.Test !== child));
+    assert.throws(() => audit(files), /required child/);
+  }
+});
+
+test('both byte-swap ISAs reject same-count child substitution', () => {
+  for (const arch of ['amd64', '386']) {
+    const files = fixture();
+    files.set('native.jsonl', files.get('native.jsonl').replaceAll(
+      byteSwap + '/' + arch, byteSwap + '/unrelated-' + arch));
+    assert.throws(() => audit(files), /required child/);
+  }
+});
+
+test('all seven ordinary386 carrier, private-stack and code-target children reject substitution', () => {
+  assert.equal(mode32Children.length, 7);
+  for (const child of mode32Children) {
+    const files = fixture();
+    replaceEvents(files, events(files).map(event => event.Test === child ?
+      { ...event, Test: child + '-unrelated' } : event));
+    assert.throws(() => audit(files), /required child/);
+  }
+});
+
+test('root or child SKIP and FAIL are never PASS', () => {
+  for (const name of [...Object.values(inventories).flat(), ...requiredChildren]) {
+    for (const action of ['skip', 'fail']) {
+      const files = fixture();
+      const rows = events(files);
+      rows.find(event => event.Action === 'pass' && event.Test === name).Action = action;
+      replaceEvents(files, rows);
+      assert.throws(() => audit(files), /execute successfully/);
+    }
+  }
+});
+
+test('required children cannot finish after their successful root terminal', () => {
+  for (const child of requiredChildren.filter(name =>
+    name.startsWith(packedStringFault + '/') || name.startsWith(byteSwap + '/') || mode32Children.includes(name))) {
+    const files = fixture();
+    const rows = events(files);
+    const index = rows.findIndex(event => event.Action === 'pass' && event.Test === child);
+    const [terminal] = rows.splice(index, 1);
+    const parent = rows.findIndex(event => event.Action === 'pass' && event.Test === child.split('/')[0]);
+    rows.splice(parent + 1, 0, terminal);
+    replaceEvents(files, rows);
+    assert.throws(() => audit(files), /child.*root terminal/);
+  }
+});
+
+test('duplicate or missing root and child events cannot close the protocol', () => {
+  for (const name of [sourceStack, requiredChildren[0], byteSwap, byteSwap + '/amd64', byteSwap + '/386', crc32,
+    bitTest, ...requiredChildren.filter(child => child.startsWith(bitTest + '/')), ...mode32Children]) {
+    for (const action of ['run', 'pass']) {
+      const duplicate = fixture();
+      const rows = events(duplicate);
+      const index = rows.findIndex(event => event.Action === action && event.Test === name);
+      rows.splice(index + 1, 0, { ...rows[index] });
+      replaceEvents(duplicate, rows);
+      assert.throws(() => audit(duplicate), /duplicate/);
+      const missing = fixture();
+      replaceEvents(missing, events(missing).filter(event => event.Action !== action || event.Test !== name));
+      assert.throws(() => audit(missing));
+    }
+  }
+});
+
+test('tool-output text cannot replace missing machine events', () => {
+  const files = fixture();
+  const rows = events(files).filter(event => event.Action !== 'pass' || event.Test !== requiredChildren[1]);
+  rows.splice(rows.length - 1, 0, { Action: 'output', Package: 'github.com/xgo-dev/plan9asm',
+    Output: JSON.stringify({ Action: 'pass', Test: requiredChildren[1] }) + '\n' });
+  replaceEvents(files, rows);
+  assert.throws(() => audit(files), /child terminals/);
+});
+
+test('ordinary386 carrier execution cannot be supplied by printed PASS payloads', () => {
+  for (const child of mode32Children) {
+    const files = fixture();
+    const rows = events(files).filter(event => event.Test !== child);
+    rows.splice(rows.length - 1, 0, { Action: 'output', Package: 'github.com/xgo-dev/plan9asm',
+      Output: JSON.stringify({ Action: 'run', Test: child }) + '\n' +
+        JSON.stringify({ Action: 'pass', Test: child }) + '\n' });
+    replaceEvents(files, rows);
+    assert.throws(() => audit(files), /required child/);
+  }
+});
+
+test('missing package pass, failed package and malformed JSON remain failures', () => {
+  const incomplete = fixture();
+  replaceEvents(incomplete, events(incomplete).slice(0, -1));
+  assert.throws(() => audit(incomplete), /package terminal/);
+  const failed = fixture();
+  const rows = events(failed);
+  rows[rows.length - 1].Action = 'fail';
+  replaceEvents(failed, rows);
+  assert.throws(() => audit(failed), /execute successfully/);
+  const malformed = fixture();
+  malformed.set('native.jsonl', malformed.get('native.jsonl') + '{truncated\n');
+  assert.throws(() => audit(malformed));
+});
+
+test('foreign package, unstarted child or duplicate package terminals are rejected', () => {
+  const foreign = fixture();
+  foreign.set('native.jsonl', foreign.get('native.jsonl').replaceAll(
+    'github.com/xgo-dev/plan9asm', 'example.invalid/foreign'));
+  assert.throws(() => audit(foreign), /package/);
+  const child = fixture();
+  const rows = events(child);
+  rows.splice(rows.length - 1, 0, { Action: 'pass', Package: 'github.com/xgo-dev/plan9asm',
+    Test: 'TestUnstarted/child' });
+  replaceEvents(child, rows);
+  assert.throws(() => audit(child), /unstarted child/);
+  const duplicate = fixture();
+  const repeated = events(duplicate);
+  repeated.push({ ...repeated[repeated.length - 1] });
+  replaceEvents(duplicate, repeated);
+  assert.throws(() => audit(duplicate), /duplicate package/);
+});
+
+test('package completion requires its own exact package identity', () => {
+  for (const identity of [undefined, null, '']) {
+    const files = fixture();
+    const rows = events(files);
+    rows[rows.length - 1].Package = identity;
+    replaceEvents(files, rows);
+    assert.throws(() => audit(files), /package terminal.*identity/);
+  }
+});
diff --git a/.github/scripts/priority-native-leaw.test.cjs b/.github/scripts/priority-native-leaw.test.cjs
new file mode 100644
index 000000000..461597e2b
--- /dev/null
+++ b/.github/scripts/priority-native-leaw.test.cjs
@@ -0,0 +1,107 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+const root = 'TestCrossLinuxRuntimeMatrixX86LEAWRetainedPointerOriginalBytesAndNativeDF';
+const apis = ['text', 'module', 'Go'];
+const paths = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const children = [...apis.flatMap(api => [root + '/' + api,
+  ...paths.map(path => root + '/' + api + '/' + path)]), root + '/OriginalGoBytes'];
+const inventory = root + '\nok\tgithub.com/xgo-dev/plan9asm\n';
+const hash = 'a'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${hash} mapsha=${hash}\n`;
+const sdk = `actual LEA source/object receipt: SDK=go1.27.2 target=linux/amd64 source=${hash} driver=${hash} object=${hash}\n`;
+const completion = 'LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS\n';
+const llvm = 'native retained LEAW LLVM execution: ' + completion;
+const original = 'native retained LEAW actual Go bytes execution: ' + completion;
+const event = (Action, Test, Output) => ({Action, Package: 'github.com/xgo-dev/plan9asm',
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start'), event('run', root), event('output', root, host + sdk)];
+  for (const api of apis) {
+    const group = root + '/' + api;
+    events.push(event('run', group));
+    for (const path of paths) {
+      const leaf = group + '/' + path;
+      events.push(event('run', leaf), event('output', leaf, llvm), event('pass', leaf));
+    }
+    events.push(event('pass', group));
+  }
+  events.push(event('run', root + '/OriginalGoBytes'), event('output', root + '/OriginalGoBytes', original),
+    event('pass', root + '/OriginalGoBytes'), event('output', root, host), event('pass', root), event('pass'));
+  return events;
+}
+
+function audit(events = completeEvents(), discovered = inventory) {
+  assert.ok(fs.existsSync('.github/scripts/audit-native-leaw.cjs'), 'LEAW lacks a required exact native completion auditor');
+  return require('./audit-native-leaw.cjs').auditNativeLEAW(discovered, serialize(events));
+}
+
+test('native LEAW requires its unique root, three API parents, nine LLVM leaves and actual Go bytes', () => {
+  assert.deepEqual(audit(), {roots: 1, children: 13, passed: 14, skipped: 0, incomplete: 0,
+    nativeHosts: 2, sdkCaptures: 1, llvmExecutions: 9, originalByteExecutions: 1});
+});
+
+test('native LEAW rejects missing duplicated failed skipped and incomplete lifecycle terminals', () => {
+  audit();
+  for (const name of [root, ...children]) {
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === name && value.Action === 'pass'
+        ? {...value, Action} : value)), name + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const events = completeEvents();
+      const at = events.findIndex(value => value.Test === name && value.Action === Action);
+      assert.throws(() => audit(events.filter((_, index) => index !== at)), name + ' missing ' + Action);
+      events.splice(at, 0, events[at]);
+      assert.throws(() => audit(events), name + ' duplicate ' + Action);
+    }
+    const late = completeEvents();
+    const at = late.findIndex(value => value.Test === name && value.Action === 'pass');
+    late.splice(at + 1, 0, event('output', name, 'late output after the terminal\n'));
+    assert.throws(() => audit(late), name + ' output after pass');
+  }
+  for (const discovered of ['', inventory + root + '\n', inventory.replace(root, 'TestUnrelated')]) {
+    assert.throws(() => audit(completeEvents(), discovered));
+  }
+  for (const events of [completeEvents().slice(1), completeEvents().slice(0, -1),
+    [...completeEvents(), event('pass')], [event('start'), ...completeEvents()],
+    [event('output', undefined, '14 passed')],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'}))]) assert.throws(() => audit(events));
+});
+
+test('native LEAW binds real host brackets SDK capture and each actual execution marker to its own live owner', () => {
+  audit();
+  for (const needle of [host, sdk]) {
+    for (const replacement of ['', needle + needle, needle.replace('linux/amd64', 'linux/arm64'),
+      needle.replace(hash, 'invalid')]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === root && value.Output
+        ? {...value, Output: value.Output.replace(needle, replacement)} : value)), needle);
+    }
+  }
+  for (const name of children.filter(name => !apis.some(api => name === root + '/' + api))) {
+    const marker = name.endsWith('/OriginalGoBytes') ? original : llvm;
+    for (const replacement of ['', marker + marker, marker.replace('300', '299'),
+      marker === original ? llvm : original, sdk + marker, host + marker]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === name && value.Output
+        ? {...value, Output: value.Output.replace(marker, replacement)} : value)), name);
+    }
+  }
+  const early = completeEvents();
+  const originalEvents = early.filter(value => value.Test === root + '/OriginalGoBytes');
+  const others = early.filter(value => value.Test !== root + '/OriginalGoBytes');
+  others.splice(3, 0, ...originalEvents);
+  assert.throws(() => audit(others), 'original bytes cannot precede complete API groups');
+  const misplaced = completeEvents().map(value => value.Test === root + '/text/backend_O0' && value.Output
+    ? {...value, Test: root + '/text'} : value);
+  assert.throws(() => audit(misplaced), 'an API parent cannot replace an executed leaf');
+  const late = completeEvents();
+  const at = late.findIndex(value => value.Action === 'output' && value.Test === root);
+  late[at] = event('output', root, host);
+  late.splice(5, 0, event('output', root, sdk));
+  assert.throws(() => audit(late), 'SDK capture must precede the API run');
+});
diff --git a/.github/scripts/priority-nested-cli-coverage-isolation.test.cjs b/.github/scripts/priority-nested-cli-coverage-isolation.test.cjs
new file mode 100644
index 000000000..38c07095c
--- /dev/null
+++ b/.github/scripts/priority-nested-cli-coverage-isolation.test.cjs
@@ -0,0 +1,220 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody, jobNeeds, requireJobNeeds} = require('./workflow-needs.cjs');
+const {requireNode22Setup} = require('./node22-setup.cjs');
+
+const workflow = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+const nested = fs.readFileSync(path.join(__dirname, '../workflows/linux-cli-module.yml'), 'utf8');
+const driver = fs.readFileSync(path.join(__dirname, '../../scripts/test-linux-cli-module-ci.sh'), 'utf8');
+const producer = 'nested-cli-coverage';
+const required = ['test', 'nested-cli', 'race', 'coverage', producer];
+const compilerInstall = 'bash scripts/install-ci-llvm22-ubuntu.sh ' +
+  'gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu';
+const completeCondition = "        if: ${{ !cancelled() && matrix.flavor == 'coverage' }}";
+const completeCommand = "        run: test '${{ needs['nested-cli-coverage'].result }}' = success";
+
+function steps(body) {
+  return body.split(/(?=^      - )/m).slice(1);
+}
+
+function step(body, title) {
+  const selected = steps(body).filter(item => item.startsWith(`      - name: ${title}\n`));
+  assert.equal(selected.length, 1, 'one actual step required: ' + title);
+  return selected[0];
+}
+
+function requireIndependentOwners(source) {
+  const body = jobBody(source, producer);
+  assert.deepEqual(jobNeeds(source, producer), ['ci_policy']);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.doesNotMatch(body, /^    if:|continue-on-error:|max-parallel:|^    steps:/m);
+  const axes = [...body.matchAll(/^        ([a-z-]+): \[([^\]]+)\]$/gm)];
+  assert.deepEqual(axes.map(([, key, values]) => [key, values.split(',').map(value => value.trim())]),
+    [['module', ['plan9asm', 'plan9asmll']]],
+    'one independent current-SDK job for each complete CLI, not a serial module loop');
+  assert.doesNotMatch(body, /^        (?:include|exclude):|\bgo test\b/m);
+  assert.match(body, /^    uses: \.\/\.github\/workflows\/linux-cli-module\.yml$/m);
+  assert.match(body, /^      module: \$\{\{ matrix\.module \}\}$/m);
+  assert.match(body, /^      go-version: '1\.27\.2'$/m);
+  assert.match(body, /^      flavor: coverage$/m);
+  return body;
+}
+
+function requireCompleteCommands(source) {
+  requireIndependentOwners(source);
+  assert.ok(driver.includes('coverage) flags=("-coverprofile=coverage-$module.out")'));
+  assert.ok(driver.includes('-module-root-partitions=4'));
+  assert.ok(driver.includes('-verify-module=_out/linux-cli-$module-$flavor-owners'));
+  assert.ok(driver.includes('-timeout=30m'));
+  assert.doesNotMatch(driver, /(?:^|\s)-(?:run|skip|short|list)(?:=|\s)/m);
+  const complete = jobBody(nested, 'complete');
+  const summary = step(complete, 'Show complete CLI coverage');
+  assert.match(summary, /^        if: inputs\.flavor == 'coverage'$/m);
+  assert.match(summary, /^        run: go tool cover -func=coverage-\$\{\{ inputs\.module \}\}\.out \| tail -n 1$/m);
+  assert.match(summary, /^        working-directory: cmd\/\$\{\{ inputs\.module \}\}$/m);
+  assert.ok(complete.indexOf('Verify complete CLI module') < complete.indexOf(summary));
+}
+
+function requireTools(source) {
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(source, name);
+    const checkout = step(body, 'Checkout');
+    assert.match(checkout, /^        uses: actions\/checkout@v7$/m);
+    const setup = step(body, 'Setup Go');
+    assert.match(setup, /^        timeout-minutes: 10$/m);
+    assert.match(setup, /^        uses: \.\/\.github\/actions\/setup-go$/m);
+    assert.match(setup, /^          go-version: \$\{\{ inputs\.go-version \}\}$/m);
+    assert.doesNotMatch(setup, /^          cache:/m);
+    assert.doesNotMatch(body, /uses: actions\/setup-go@|go-version-file:|check-latest:/);
+    const compiler = step(body, 'Install LLVM 22 and cross compilers');
+    assert.ok(compiler.includes('        run: ' + compilerInstall + '\n'));
+    assert.match(compiler, /^        timeout-minutes: 14$/m);
+    const qemu = step(body, 'Install required execution runtimes');
+    assert.match(qemu, /^        run: bash scripts\/install-ci-qemu\.sh$/m);
+    assert.match(qemu, /^        timeout-minutes: 5$/m);
+    const info = step(body, 'LLVM tools info');
+    for (const command of ['command -v llc', 'llc --version', 'command -v clang', 'clang --version']) {
+      assert.ok(info.includes('          ' + command + '\n'));
+    }
+    const node = step(body, 'Setup required wasm execution runtime');
+    requireNode22Setup(node);
+    for (const item of [checkout, setup, compiler, qemu, info, node]) {
+      assert.doesNotMatch(item, /^        if:|continue-on-error:|\|\|\s*true/m);
+      assert.ok(body.indexOf(item) < body.indexOf('        run: bash scripts/test-linux-cli-module-ci.sh '));
+    }
+    assert.ok(body.indexOf(qemu) < body.indexOf(node));
+  }
+}
+
+function requireOriginalOwners(source) {
+  for (const flavor of ['test', 'race', 'coverage']) {
+    const body = jobBody(source, flavor);
+    assert.doesNotMatch(body, /working-directory: cmd\/|coverage-plan9asm|nested_modules/,
+      flavor + ': root/profile/rest owners must not serialize complete nested CLI suites');
+  }
+  const body = jobBody(source, 'coverage');
+  assert.match(body, /^    timeout-minutes: 60$/m);
+  assert.match(step(body, 'Go test with coverage'),
+    /^        run: bash scripts\/test-module-ci\.sh coverage execute \$\{\{ matrix\.module-owner \}\} \$\{\{ matrix\.root-partition \}\}$/m);
+  const evidence = step(body, 'Retain complete module coverage owner evidence');
+  assert.match(evidence, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+  assert.match(evidence, /^          name: module-coverage-1\.27\.2-\$\{\{ matrix\.module-role \}\}$/m);
+  assert.match(evidence, /^          path: _out\/module-coverage\/$/m);
+  assert.match(evidence, /^          if-no-files-found: error$/m);
+}
+
+function requireCompletion(source) {
+  requireJobNeeds(source, 'module-completion', required);
+  const body = jobBody(source, 'module-completion');
+  assert.match(body, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+  for (const title of ['Check complete actual module inventory and coverage',
+    'Retain independent aggregate evidence']) {
+    assert.match(step(body, title), /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+  }
+  const summary = step(body, 'Show complete module coverage');
+  assert.match(summary, /^        if: matrix\.flavor == 'coverage'$/m);
+  assert.match(summary, /^        run: go tool cover -func=coverage-root\.out \| tail -n 1$/m);
+  const upload = step(body, 'Upload coverage to Codecov');
+  assert.match(upload, /^        if: matrix\.flavor == 'coverage'$/m);
+  assert.match(upload, /^        uses: codecov\/codecov-action@v7$/m);
+  for (const field of ['use_oidc: true', 'files: ./coverage-root.out', 'disable_search: true',
+    'flags: unittests', 'name: ubuntu-go1.27', 'fail_ci_if_error: false', 'verbose: true']) {
+    assert.ok(upload.includes('          ' + field + '\n'));
+  }
+  assert.doesNotMatch(upload, /coverage-\$\{\{|coverage-plan9asm/,
+    'nested modules are not main-module coverage inputs');
+  const success = step(body, 'Require complete CLI coverage');
+  assert.ok(success.includes(completeCondition + '\n'));
+  assert.ok(success.includes(completeCommand + '\n'));
+  assert.doesNotMatch(success, /continue-on-error:|\|\|\s*true/);
+  assert.ok(body.indexOf(success) > body.indexOf(upload),
+    'a failed CLI producer must not suppress the original root aggregate and upload');
+}
+
+test('both complete CLI coverage modules own independent current-SDK job budgets', () => {
+  requireIndependentOwners(workflow);
+  requireCompleteCommands(workflow);
+});
+
+test('independent CLI coverage retains exact Go, LLVM and required execution dependencies', () => {
+  requireIndependentOwners(workflow);
+  requireTools(nested);
+});
+
+test('root coverage no longer serializes CLI coverage and race has no invented CLI matrix', () => {
+  requireOriginalOwners(workflow);
+});
+
+test('CLI coverage failure remains a completion failure after original root evidence collection', () => {
+  requireCompletion(workflow);
+});
+
+test('CLI coverage policy rejects reduced, duplicated, serial, filtered or over-budget owners', () => {
+  requireCompleteCommands(workflow);
+  const body = jobBody(workflow, producer);
+  for (const [before, after] of [
+    ['module: [plan9asm, plan9asmll]', 'module: [plan9asm]'],
+    ['module: [plan9asm, plan9asmll]', 'module: [plan9asmll]'],
+    ['module: [plan9asm, plan9asmll]', 'module: [plan9asm, plan9asm]'],
+    ['needs: ci_policy', 'needs: coverage'],
+    ['fail-fast: false', 'fail-fast: true'],
+    ['fail-fast: false', 'fail-fast: false\n      max-parallel: 1'],
+    ['needs: ci_policy', 'needs: ci_policy\n    continue-on-error: true'],
+    ['linux-cli-module.yml', 'windows-module.yml'],
+    ['module: ${{ matrix.module }}', 'module: plan9asm'],
+    ["go-version: '1.27.2'", "go-version: '1.27.x'"],
+    ['flavor: coverage', 'flavor: test'],
+  ]) {
+    const changed = body.replace(before, () => after);
+    assert.notEqual(changed, body, before);
+    assert.throws(() => requireCompleteCommands(workflow.replace(body, () => changed)), undefined, before);
+  }
+});
+
+test('CLI coverage dependencies cannot borrow skipped, missing or foreign tool installations', () => {
+  requireTools(nested);
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(nested, name);
+    for (const [before, after] of [
+      ['go-version: ${{ inputs.go-version }}', "go-version: '1.27.2'"],
+      [' gcc-i686-linux-gnu', ''],
+      [' libc6-dev-i386-cross', ''],
+      [' gcc-aarch64-linux-gnu', ''],
+      ['install-ci-llvm22-ubuntu.sh', 'install-llvm23.sh'],
+      ['install-ci-qemu.sh', 'install-unpinned-qemu.sh'],
+      ['uses: ./.github/actions/setup-node22', 'uses: actions/setup-node@v6'],
+      ['        run: ' + compilerInstall, '        if: false\n        run: ' + compilerInstall],
+    ]) {
+      const changed = body.replace(before, () => after);
+      assert.notEqual(changed, body, before);
+      assert.throws(() => requireTools(nested.replace(body, () => changed)), undefined, before);
+    }
+  }
+});
+
+test('CLI coverage completion rejects missing needs, skipped collection and borrowed success', () => {
+  requireCompletion(workflow);
+  const body = jobBody(workflow, 'module-completion');
+  for (const gate of required) {
+    const changed = body.replace(/^    needs:.*$/m,
+      () => '    needs: [' + required.filter(name => name !== gate).join(', ') + ']');
+    assert.notEqual(changed, body, gate);
+    assert.throws(() => requireCompletion(workflow.replace(body, () => changed)), undefined, gate);
+  }
+  for (const [before, after] of [
+    ['    if: ${{ !cancelled() }}', '    if: success()'],
+    [completeCondition, "        if: matrix.flavor == 'coverage'"],
+    [completeCondition, "        if: ${{ !cancelled() && matrix.flavor == 'test' }}"],
+    [completeCommand, "        run: test '${{ needs['nested-cli'].result }}' = success"],
+    [completeCommand, completeCommand + ' || true'],
+    [completeCommand, '        run: true'],
+  ]) {
+    const changed = body.replace(before, () => after);
+    assert.notEqual(changed, body, before);
+    assert.throws(() => requireCompletion(workflow.replace(body, () => changed)), undefined, before);
+  }
+});
diff --git a/.github/scripts/priority-nested-cli-isolation.test.cjs b/.github/scripts/priority-nested-cli-isolation.test.cjs
new file mode 100644
index 000000000..62ddd78cf
--- /dev/null
+++ b/.github/scripts/priority-nested-cli-isolation.test.cjs
@@ -0,0 +1,163 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody, jobNeeds, requireJobNeeds} = require('./workflow-needs.cjs');
+const {requireNode22Setup} = require('./node22-setup.cjs');
+
+const workflow = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+const nested = fs.readFileSync(path.join(__dirname, '../workflows/linux-cli-module.yml'), 'utf8');
+const versions = ['1.24.x', '1.25.x', '1.26.x', '1.27.2'];
+const modules = ['plan9asm', 'plan9asmll'];
+const compilerInstall = 'bash scripts/install-ci-llvm22-ubuntu.sh ' +
+  'gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu';
+
+function steps(body) {
+  return body.split(/(?=^      - )/m).slice(1);
+}
+
+function step(body, title) {
+  const selected = steps(body).filter(item => item.startsWith(`      - name: ${title}\n`));
+  assert.equal(selected.length, 1, 'one actual step required: ' + title);
+  return selected[0];
+}
+
+function matrixValues(body, key) {
+  const values = [...body.matchAll(new RegExp(`^        ${key}: \\[([^\\]]+)\\]$`, 'gm'))];
+  assert.equal(values.length, 1, 'one complete matrix axis required: ' + key);
+  return values[0][1].split(',').map(value => value.trim().replace(/^'(.*)'$/, '$1'));
+}
+
+function requireIndependentCLI(source) {
+  const body = jobBody(source, 'nested-cli');
+  assert.deepEqual(jobNeeds(source, 'nested-cli'), ['ci_policy']);
+  assert.doesNotMatch(body, /^    if:|continue-on-error:|max-parallel:/m);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.deepEqual(matrixValues(body, 'go-version'), versions);
+  assert.deepEqual(matrixValues(body, 'module'), modules);
+  assert.doesNotMatch(body, /^        (?:include|exclude):|^    steps:|\bgo test\b/m);
+  assert.match(body, /^    uses: \.\/\.github\/workflows\/linux-cli-module\.yml$/m);
+  assert.match(body, /^      module: \$\{\{ matrix\.module \}\}$/m);
+  assert.match(body, /^      go-version: \$\{\{ matrix\.go-version \}\}$/m);
+  assert.match(body, /^      flavor: test$/m);
+  assert.doesNotMatch(body, /scripts\/test-module-ci\.sh|Required exact downloaded/);
+  requireJobNeeds(source, 'module-completion', ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']);
+  assert.match(jobBody(source, 'module-completion'), /^    if: \$\{\{ !cancelled\(\) \}\}$/m,
+    'completion must still collect original owners after a failed CLI job');
+}
+
+function requireCLITools(source) {
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(source, name);
+    const checkout = step(body, 'Checkout');
+    assert.match(checkout, /^        uses: actions\/checkout@v7$/m);
+    const setup = step(body, 'Setup Go');
+    assert.match(setup, /^        timeout-minutes: 10$/m);
+    assert.match(setup, /^        uses: \.\/\.github\/actions\/setup-go$/m);
+    assert.match(setup, /^          go-version: \$\{\{ inputs\.go-version \}\}$/m);
+    assert.doesNotMatch(setup, /^          cache:/m);
+    assert.doesNotMatch(body, /uses: actions\/setup-go@|go-version-file:|check-latest:/);
+    const compiler = step(body, 'Install LLVM 22 and cross compilers');
+    assert.ok(compiler.includes(`        run: ${compilerInstall}\n`));
+    assert.match(compiler, /^        timeout-minutes: 14$/m);
+    const qemu = step(body, 'Install required execution runtimes');
+    assert.match(qemu, /^        run: bash scripts\/install-ci-qemu\.sh$/m);
+    assert.match(qemu, /^        timeout-minutes: 5$/m);
+    const node = step(body, 'Setup required wasm execution runtime');
+    requireNode22Setup(node);
+    for (const item of [checkout, setup, compiler, qemu, node]) {
+      assert.doesNotMatch(item, /^        if:|continue-on-error:|\|\|\s*true/m);
+      assert.ok(body.indexOf(item) < body.indexOf('        run: bash scripts/test-linux-cli-module-ci.sh '),
+        'every CLI dependency must be installed before execution');
+    }
+    assert.ok(body.indexOf(qemu) < body.indexOf(node), 'retain QEMU/Node PATH provisioning order');
+  }
+}
+
+function requireOriginalOtherOwner(source) {
+  const body = jobBody(source, 'test');
+  assert.match(body, /^    timeout-minutes: 60$/m);
+  assert.match(step(body, 'Go test (Ubuntu)'),
+    /^        run: bash scripts\/test-module-ci\.sh test execute \$\{\{ matrix\.module-owner \}\} \$\{\{ matrix\.root-partition \}\}$/m);
+  assert.doesNotMatch(body, /nested_modules|working-directory: cmd\/plan9asm|Go test \(cmd\/plan9asm/,
+    'remaining-package owners cannot serialize complete CLI suites');
+  const numerical = step(body, 'Required exact downloaded AMD64 numerical fixture');
+  assert.match(numerical,
+    /^        if: runner\.os == 'Linux' && matrix\.go-version == '1\.27\.2' && matrix\.module-owner == 2$/m);
+  assert.match(numerical, /^        shell: bash$/m);
+  assert.match(numerical, /^          set -euo pipefail$/m);
+  assert.match(numerical, /^          test "\$\(go env GOHOSTOS\)\/\$\(go env GOHOSTARCH\)" = linux\/amd64$/m);
+  assert.match(numerical, /^          scope='\^TestAMD64DownloadedFixedLocalLLVM22Numerical\$'$/m);
+  assert.match(numerical,
+    /^          go test \.\/gotoolprofile -list="\$scope" \| grep -Fx 'TestAMD64DownloadedFixedLocalLLVM22Numerical'$/m);
+  assert.match(numerical, /^          go test \.\/gotoolprofile -run="\$scope" -count=1 -timeout=10m$/m);
+}
+
+test('both complete CLIs own independent jobs for every supported nested SDK', () => {
+  requireIndependentCLI(workflow);
+});
+
+test('every independent CLI owner retains its complete tool and execution runtimes', () => {
+  requireCLITools(nested);
+});
+
+test('root other owner retains the exact numerical fixture without serial CLI suites', () => {
+  requireOriginalOtherOwner(workflow);
+});
+
+test('CLI ownership rejects reduced matrices, serial scheduling and weakened success gates', () => {
+  requireIndependentCLI(workflow);
+  const body = jobBody(workflow, 'nested-cli');
+  for (const [before, after] of [
+    ["'1.24.x', ", ''],
+    ["'1.25.x', ", ''],
+    ["'1.26.x', ", ''],
+    ["'1.27.2'", "'1.27.x'"],
+    ['module: [plan9asm, plan9asmll]', 'module: [plan9asm]'],
+    ['module: [plan9asm, plan9asmll]', 'module: [plan9asmll]'],
+    ['fail-fast: false', 'fail-fast: true'],
+    ['fail-fast: false', 'fail-fast: false\n      max-parallel: 1'],
+    ['needs: ci_policy', 'needs: test'],
+    ['linux-cli-module.yml', 'windows-module.yml'],
+    ['module: ${{ matrix.module }}', 'module: plan9asm'],
+    ['go-version: ${{ matrix.go-version }}', "go-version: '1.27.2'"],
+    ['flavor: test', 'flavor: coverage'],
+  ]) {
+    const changed = body.replace(before, () => after);
+    assert.notEqual(changed, body, 'ownership mutation must change its actual job: ' + before);
+    assert.throws(() => requireIndependentCLI(workflow.replace(body, () => changed)), undefined, before);
+  }
+  const complete = jobBody(workflow, 'module-completion');
+  const required = ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage'];
+  for (const gate of required) {
+    const reduced = required.filter(name => name !== gate);
+    const changed = complete.replace(/^    needs:.*$/m, '    needs: [' + reduced.join(', ') + ']');
+    assert.throws(() => requireIndependentCLI(workflow.replace(complete, changed)), undefined, gate);
+  }
+  const skipped = complete.replace('if: ${{ !cancelled() }}', 'if: success()');
+  assert.notEqual(skipped, complete);
+  assert.throws(() => requireIndependentCLI(workflow.replace(complete, skipped)));
+});
+
+test('CLI tool policies reject missing infrastructure and skipped setup', () => {
+  requireCLITools(nested);
+  for (const name of ['root-parts', 'complete']) {
+    const body = jobBody(nested, name);
+    for (const [before, after] of [
+      [' gcc-i686-linux-gnu', ''],
+      [' libc6-dev-i386-cross', ''],
+      [' gcc-aarch64-linux-gnu', ''],
+      ['install-ci-llvm22-ubuntu.sh', 'install-llvm23.sh'],
+      ['install-ci-qemu.sh', 'install-unpinned-qemu.sh'],
+      ['uses: ./.github/actions/setup-node22', 'uses: actions/setup-node@v6'],
+      ['go-version: ${{ inputs.go-version }}', "go-version: '1.27.2'"],
+      ['        run: ' + compilerInstall, '        if: false\n        run: ' + compilerInstall],
+    ]) {
+      const changed = body.replace(before, () => after);
+      assert.notEqual(changed, body, 'tool mutation must change its actual job: ' + before);
+      assert.throws(() => requireCLITools(nested.replace(body, () => changed)), undefined, before);
+    }
+  }
+});
diff --git a/.github/scripts/priority-node22-installation.test.cjs b/.github/scripts/priority-node22-installation.test.cjs
new file mode 100644
index 000000000..d83215d7c
--- /dev/null
+++ b/.github/scripts/priority-node22-installation.test.cjs
@@ -0,0 +1,92 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const {test} = require('node:test');
+
+const action = fs.readFileSync('.github/actions/setup-node22/action.yml', 'utf8');
+
+function verificationScript() {
+  const step = action.split(/(?=^    - name:)/m).find(part =>
+    part.startsWith('    - name: Verify Node.js installation\n'));
+  if (!step) return '';
+  const marker = '      run: |\n';
+  assert.ok(step.includes(marker), 'verification requires the actual script');
+  return step.slice(step.indexOf(marker) + marker.length)
+    .split('\n').map(line => line.startsWith('        ') ? line.slice(8) : line).join('\n');
+}
+
+function verify(options = {}) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-node22-install-'));
+  try {
+    if (!options.missingNode) {
+      fs.writeFileSync(path.join(directory, 'node'), `#!/bin/sh
+[ "$*" = '--version' ] || exit 92
+printf '%s\\n' "$MOCK_NODE_VERSION"
+exit "$MOCK_NODE_EXIT"
+`, {mode: 0o755});
+    }
+    return spawnSync('/bin/bash', ['--noprofile', '--norc', '-c', verificationScript()], {
+      encoding: 'utf8', timeout: 5000,
+      env: {
+        PATH: directory,
+        EXPECTED_NODE_VERSION: 'v22.23.4',
+        INSTALLED_NODE_VERSION: options.installed ?? 'v22.23.4',
+        MOCK_NODE_VERSION: options.actual ?? 'v22.23.4',
+        MOCK_NODE_EXIT: String(options.exit ?? 0),
+      },
+    });
+  } finally {
+    fs.rmSync(directory, {recursive: true, force: true});
+  }
+}
+
+test('Node setup pins one exact runtime and verifies its official installer output', () => {
+  assert.match(action, /id: install_node22\n      uses: actions\/setup-node@v6\n      with:\n        node-version: '22\.23\.4'/);
+  assert.match(action, /INSTALLED_NODE_VERSION: \$\{\{ steps\.install_node22\.outputs\.node-version \}\}/);
+  assert.match(action, /EXPECTED_NODE_VERSION: 'v22\.23\.4'/);
+  assert.doesNotMatch(action, /continue-on-error:|\n      if:|\|\|\s*true|node-version-file:|mirror:/);
+  assert.ok(verificationScript().includes('set -euo pipefail'));
+});
+
+test('a complete exact Node installation selects its actual PATH runtime', () => {
+  for (const actual of ['v22.23.4', 'v22.23.4\r']) {
+    const result = verify({actual});
+    assert.ifError(result.error);
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /Verified Node v22\.23\.4: .*\/node/);
+  }
+});
+
+test('an interrupted Node download cannot borrow an ambient runtime or empty output', () => {
+  for (const options of [
+    {installed: ''},
+    {installed: '', actual: 'v22.23.3'},
+    {installed: '', actual: 'v22.23.4'},
+    {missingNode: true},
+    {actual: 'v22.23.3'},
+    {actual: 'v24.0.0'},
+    {actual: '', exit: 1},
+    {actual: 'v22.23.4', exit: 1},
+  ]) {
+    const result = verify(options);
+    assert.ifError(result.error);
+    assert.notEqual(result.status, 0, JSON.stringify(options));
+    assert.doesNotMatch(result.stdout, /Verified Node/);
+  }
+});
+
+test('Node verification rejects wrong patches, nonstable versions and malformed output', () => {
+  for (const value of ['v22.23.3', '22.23.4', 'v22.23.4-rc.1', 'v24.0.0',
+    'v22.23.4\nv22.23.4', ' v22.23.4', 'v22.23.4 ']) {
+    for (const options of [{installed: value}, {actual: value}]) {
+      const result = verify(options);
+      assert.ifError(result.error);
+      assert.notEqual(result.status, 0, JSON.stringify(options));
+      assert.doesNotMatch(result.stdout, /Verified Node/);
+    }
+  }
+});
diff --git a/.github/scripts/priority-node22-workflows.test.cjs b/.github/scripts/priority-node22-workflows.test.cjs
new file mode 100644
index 000000000..75a5e61d2
--- /dev/null
+++ b/.github/scripts/priority-node22-workflows.test.cjs
@@ -0,0 +1,175 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const {test} = require('node:test');
+const {jobBody} = require('./workflow-needs.cjs');
+const {requireNode22Setup} = require('./node22-setup.cjs');
+
+const roles = {
+  'go-ci.yml': ['ci_policy', 'cross-runtime', 'cross-runtime-verify', 'test', 'nested-cli',
+    'nested-cli-coverage', 'race', 'coverage', 'module-completion'],
+  'windows-module.yml': ['root-parts', 'other-owners', 'complete'],
+  'runtime-integration.yml': ['ci_policy'],
+};
+
+// Both complete layouts retain the same two CLI installation obligations.
+// Once the reusable producer exists, verify its real roles and exact callers;
+// a missing callee cannot make the old inline obligations disappear.
+const cliWorkflow = '.github/workflows/linux-cli-module.yml';
+const usesReusableCLI = fs.existsSync(cliWorkflow);
+if (usesReusableCLI) {
+  roles['go-ci.yml'] = ['ci_policy', 'cross-runtime', 'cross-runtime-verify', 'test',
+    'race', 'coverage', 'module-completion'];
+  roles['linux-cli-module.yml'] = ['root-parts', 'complete'];
+}
+
+function requireCLICaller(body, coverage) {
+  assert.equal((body.match(/^    uses: \.\/\.github\/workflows\/linux-cli-module\.yml$/gm) || []).length, 1);
+  assert.match(body, /^    needs: ci_policy$/m);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.match(body, /^        module: \[plan9asm, plan9asmll\]$/m);
+  assert.match(body, /^      module: \$\{\{ matrix\.module \}\}$/m);
+  if (coverage) {
+    assert.match(body, /^      go-version: '1\.27\.2'$/m);
+    assert.doesNotMatch(body, /^        go-version:/m,
+      'coverage has one exact current SDK, not an additional matrix');
+  } else {
+    assert.ok(body.includes("        go-version: ['1.24.x', '1.25.x', '1.26.x', '1.27.2']\n"));
+    assert.match(body, /^      go-version: \$\{\{ matrix\.go-version \}\}$/m);
+  }
+  assert.ok(body.includes('      flavor: ' + (coverage ? 'coverage' : 'test') + '\n'));
+  assert.doesNotMatch(body, /^    (?:if|runs-on|steps|continue-on-error):|max-parallel:/m);
+}
+
+if (usesReusableCLI) {
+  test('both complete CLI callers preserve their exact reusable runtime obligations', () => {
+    const workflow = fs.readFileSync('.github/workflows/go-ci.yml', 'utf8');
+    for (const [name, coverage] of [['nested-cli', false], ['nested-cli-coverage', true]]) {
+      const body = jobBody(workflow, name);
+      requireCLICaller(body, coverage);
+      for (const [before, after] of [
+        ['uses: ./.github/workflows/linux-cli-module.yml', 'uses: ./.github/workflows/foreign.yml'],
+        ['module: [plan9asm, plan9asmll]', 'module: [plan9asm]'],
+        ["'1.27.2'", "'1.27.x'"],
+        ['flavor: ' + (coverage ? 'coverage' : 'test'), 'flavor: race'],
+        ['fail-fast: false', 'fail-fast: true'],
+      ]) {
+        const changed = body.replace(before, after);
+        assert.notEqual(changed, body);
+        assert.throws(() => requireCLICaller(changed, coverage));
+      }
+    }
+  });
+}
+
+function nodeStep(body) {
+  const steps = body.split(/(?=^      - )/m).slice(1).filter(step =>
+    step.includes('uses: ./.github/actions/setup-node22'));
+  assert.equal(steps.length, 1, 'each required role has exactly one verified Node setup');
+  requireNode22Setup(steps[0]);
+  assert.doesNotMatch(body, /uses: actions\/setup-node@|node-version:/,
+    'another runtime cannot replace or follow the verified exact installer');
+  return steps[0];
+}
+
+// Derive runtime users separately from the closed role census. A new cross or
+// complete-module consumer must not borrow ambient Node just because its name
+// was omitted from the list above.
+function requireRuntimeNodeDependencies(source) {
+  const start = source.indexOf('\njobs:\n');
+  assert.ok(start >= 0, 'a formal reusable workflow must retain its job graph');
+  const jobs = source.slice(start);
+  const observed = [];
+  for (const [, name] of jobs.matchAll(/^  ([a-zA-Z0-9_-]+):$/gm)) {
+    const body = jobBody(source, name);
+    const runtime = /PLAN9ASM_CROSS_EXEC\s*[:=]\s*['"]?1(?:['"]|\s|$)/.test(body) ||
+      /scripts\/test-(?:arm64-fallback|(?:linux-cli-|windows-)?module)-ci\.sh/.test(body) ||
+      /^ +(?:run: )?node\s/m.test(body) ||
+      /^ +run: go test\s/m.test(body);
+    if (runtime) {
+      nodeStep(body);
+      observed.push(name);
+    }
+  }
+  return observed.sort();
+}
+
+function requireFormalRuntimeDependencies(readWorkflow) {
+  const pending = ['go-ci.yml'];
+  const observed = new Map();
+  while (pending.length) {
+    const name = pending.pop();
+    if (observed.has(name)) continue;
+    const source = readWorkflow(name);
+    observed.set(name, requireRuntimeNodeDependencies(source));
+    for (const [, callee] of source.matchAll(
+      /^    uses: \.\/\.github\/workflows\/([a-zA-Z0-9_.-]+\.yml)$/gm)) {
+      pending.push(callee);
+    }
+  }
+  return observed;
+}
+
+test('actual cross-runtime and module consumers independently require verified Node', () => {
+  const workflow = fs.readFileSync('.github/workflows/go-ci.yml', 'utf8');
+  const readWorkflow = name => fs.readFileSync('.github/workflows/' + name, 'utf8');
+  const observed = requireFormalRuntimeDependencies(readWorkflow);
+  assert.deepEqual(observed.get('go-ci.yml'),
+    ['ci_policy', 'coverage', 'cross-runtime', 'cross-runtime-verify',
+      'module-completion', 'race', 'test']);
+  const added = workflow + '\n  new-cross-consumer:\n    env:\n' +
+    "      PLAN9ASM_CROSS_EXEC: '1'\n    steps:\n      - run: go run ./cmd/plan9asmtest\n";
+  assert.throws(() => requireRuntimeNodeDependencies(added),
+    'a newly added consumer cannot disappear from Node coverage');
+  assert.deepEqual(observed.get('windows-module.yml'), ['complete', 'other-owners', 'root-parts']);
+  assert.deepEqual(observed.get('linux-cli-module.yml'), ['complete', 'root-parts']);
+
+  const consumer = "name: New consumer\njobs:\n  new-cross-consumer:\n    env:\n" +
+    "      PLAN9ASM_CROSS_EXEC: '1'\n    steps:\n      - run: go run ./cmd/plan9asmtest\n";
+  const caller = workflow + '\n  new-reusable-consumer:\n' +
+    '    uses: ./.github/workflows/new-consumer.yml\n';
+  const fixture = source => name => name === 'go-ci.yml' ? caller
+    : name === 'new-consumer.yml' ? source : readWorkflow(name);
+  assert.throws(() => requireFormalRuntimeDependencies(fixture(consumer)),
+    /exactly one verified Node setup/);
+  const guarded = consumer.replace('    steps:\n', '    steps:\n' +
+    nodeStep(jobBody(workflow, 'cross-runtime')));
+  assert.deepEqual(requireFormalRuntimeDependencies(fixture(guarded)).get('new-consumer.yml'),
+    ['new-cross-consumer']);
+});
+
+for (const [file, jobs] of Object.entries(roles)) {
+  const workflow = fs.readFileSync('.github/workflows/' + file, 'utf8');
+  test(file + ' preserves every required verified Node role and its setup deadline', () => {
+    assert.equal((workflow.match(/uses: \.\/\.github\/actions\/setup-node22$/gm) || []).length, jobs.length);
+    for (const name of jobs) nodeStep(jobBody(workflow, name));
+  });
+  test(file + ' rejects missing, skipped, duplicate, ambient or unbounded runtime setup', () => {
+    for (const name of jobs) {
+      const body = jobBody(workflow, name), step = nodeStep(body);
+      for (const replacement of [
+        '', step + step,
+        step.replace('uses: ./.github/actions/setup-node22', 'uses: actions/setup-node@v6'),
+        step.replace('timeout-minutes: 10', 'timeout-minutes: 60'),
+        step.replace('timeout-minutes: 10', 'if: false\n        timeout-minutes: 10'),
+        step.replace('timeout-minutes: 10', 'continue-on-error: true\n        timeout-minutes: 10'),
+        ...(step.includes('      - uses:')
+          ? [step.replace('      - uses:', '      - if: false\n        uses:')] : []),
+        step + '        uses: actions/setup-node@v6\n',
+        step + "        with:\n          node-version: '22'\n",
+      ]) {
+        assert.notEqual(replacement, step, 'negative control must change its actual setup');
+        assert.throws(() => nodeStep(body.replace(step, replacement)), undefined, name);
+      }
+    }
+  });
+}
+
+test('policy checks execute only after their own verified Node installation', () => {
+  for (const file of ['go-ci.yml', 'runtime-integration.yml']) {
+    const body = jobBody(fs.readFileSync('.github/workflows/' + file, 'utf8'), 'ci_policy');
+    const setup = nodeStep(body);
+    assert.ok(body.indexOf(setup) < body.indexOf('run: node --test '));
+  }
+});
diff --git a/.github/scripts/priority-optional-avx512.test.cjs b/.github/scripts/priority-optional-avx512.test.cjs
new file mode 100644
index 000000000..cb6ba0b23
--- /dev/null
+++ b/.github/scripts/priority-optional-avx512.test.cjs
@@ -0,0 +1,12 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+test('Windows execution and completion share the explicit optional AVX512 policy', () => {
+  const workflow = fs.readFileSync('.github/workflows/windows-module.yml', 'utf8');
+  assert.match(workflow, /^env:\n  PLAN9ASM_AVX512_RUNTIME: auto\n/m);
+  assert.equal((workflow.match(/PLAN9ASM_AVX512_RUNTIME/g) || []).length, 1,
+    'individual owners cannot override the common execution environment');
+});
diff --git a/.github/scripts/priority-packed-conversions-native.test.cjs b/.github/scripts/priority-packed-conversions-native.test.cjs
new file mode 100644
index 000000000..0c0769956
--- /dev/null
+++ b/.github/scripts/priority-packed-conversions-native.test.cjs
@@ -0,0 +1,148 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const auditor = require('./audit-packed-conversion-native.cjs');
+
+test('native conversion receipts require a strict current-head owner and complete-union auditor', () => {
+  const path = '.github/scripts/audit-packed-conversion-native.cjs';
+  assert.ok(fs.existsSync(path), 'missing complete native conversion receipt auditor');
+  const source = fs.readFileSync(path, 'utf8');
+  for (const guard of ['auditNativeOwners', 'AVX512F=1 AVX512DQ=1 AVX512BW=1 AVX512VL=1 OSXSAVE=1',
+    'PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK', '0xe6n', 'original_go_named', 'original_go_raw']) {
+    assert.ok(source.includes(guard), 'missing strict native conversion guard: ' + guard);
+  }
+});
+
+// This independently constructs the expected semantic partitions and all
+// actual run/pass events. Neither auditor metadata nor a success payload can
+// supply the original Go, public API, backend or native hardware axes.
+function fixture(owner) {
+  const suffix = owner ? 'Part' + owner : '';
+  const roots = [
+    'TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512Status' + suffix,
+    'TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaults' + suffix,
+  ];
+  if (!owner) roots.push('TestCrossLinuxRuntimeMatrixX86PackedConversionNativeIndependentC');
+  const children = [];
+  for (let family = 0; family < 2; family++) {
+    const size = family ? 222 : 692, limit = family ? 16 : 64;
+    for (let start = owner * limit; start < size; start += 8 * limit) {
+      const batch = roots[family] + '/batch-' + String(start).padStart(4, '0');
+      children.push(batch);
+      const originals = family ? ['original_go_opcode_reference'] : ['original_go_named', 'original_go_raw'];
+      children.push(...originals.map(original => batch + '/' + original));
+      for (const spelling of ['named', 'raw']) {
+        const source = batch + '/' + spelling;
+        children.push(source);
+        for (const api of ['text', 'module', 'Go']) {
+          const route = source + '/' + api;
+          children.push(route, ...['backend_O0', 'backend_O2', 'IR_O2_backend_O2'].map(axis => route + '/' + axis));
+        }
+      }
+    }
+  }
+  if (!owner) children.push(...['backend_O0', 'backend_O2', 'IR_O2_backend_O2'].map(axis => roots[2] + '/' + axis));
+  const events = [];
+  const packageName = 'github.com/xgo-dev/plan9asm';
+  const emit = (action, name, output) => {
+    const event = {Action: action, Package: packageName};
+    if (name) event.Test = name;
+    if (output !== undefined) event.Output = output;
+    events.push(event);
+  };
+  function execute(name) {
+    emit('run', name);
+    if (roots.includes(name)) {
+      emit('output', name, 'AVX512F=1 AVX512DQ=1 AVX512BW=1 AVX512VL=1 OSXSAVE=1 XCR0=e7\n');
+      emit('output', name, 'PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK\n');
+    }
+    for (const child of children.filter(child => child.slice(0, child.lastIndexOf('/')) === name)) execute(child);
+    emit('pass', name);
+  }
+  for (const root of roots) execute(root);
+  emit('pass');
+  return {roots, children, inventory: roots.join('\n') + '\n', events};
+}
+
+function raw(events) {
+  return events.map(event => JSON.stringify(event)).join('\n') + '\n';
+}
+
+test('all eight owners consume every complete original/public/native execution axis', () => {
+  let roots = 0, children = 0;
+  for (let owner = 0; owner < 8; owner++) {
+    const independent = fixture(owner), expected = auditor.required(owner);
+    assert.deepEqual(expected.roots, independent.roots);
+    assert.deepEqual(expected.children, independent.children);
+    const result = auditor.auditOwner(independent.inventory, raw(independent.events), owner);
+    assert.equal(result.preflights, independent.roots.length);
+    assert.equal(result.passed, independent.roots.length + independent.children.length);
+    roots += result.roots;
+    children += result.children;
+  }
+  assert.equal(roots, 17);
+  assert.equal(children, 714);
+});
+
+test('failed skipped missing duplicate foreign incomplete and printed native receipts fail', () => {
+  const base = fixture(0);
+  const leaf = base.children.find(child => child.endsWith('/original_go_raw'));
+  for (const action of ['fail', 'skip']) {
+    const events = base.events.map(event => event.Test === leaf && event.Action === 'pass' ? {...event, Action: action} : event);
+    assert.throws(() => auditor.auditOwner(base.inventory, raw(events), 0));
+  }
+  for (const alter of [
+    events => events.filter(event => event.Test !== leaf),
+    events => events.filter(event => !(event.Test === leaf && event.Action === 'pass')),
+    events => [...events.slice(0, -1), {Action: 'pass', Package: 'github.com/xgo-dev/plan9asm', Test: leaf}, events.at(-1)],
+    events => events.map(event => event.Test === leaf ? {...event, Test: event.Test + '/foreign'} : event),
+    events => events.slice(0, -1),
+    events => [{Action: 'output', Package: 'github.com/xgo-dev/plan9asm', Output: 'all native conversions passed\n'}, events.at(-1)],
+  ]) assert.throws(() => auditor.auditOwner(base.inventory, raw(alter(base.events)), 0));
+  assert.throws(() => auditor.auditOwner(base.inventory + 'TestForeign\n', raw(base.events), 0));
+  assert.throws(() => auditor.auditOwner(base.inventory, raw(base.events), 1));
+});
+
+test('each current owner must observe all native features and enabled state before execution', () => {
+  const base = fixture(1);
+  for (const [before, after] of [
+    ['AVX512F=1', 'AVX512F=0'], ['AVX512DQ=1', 'AVX512DQ=0'],
+    ['AVX512BW=1', 'AVX512BW=0'], ['AVX512VL=1', 'AVX512VL=0'],
+    ['OSXSAVE=1', 'OSXSAVE=0'], ['XCR0=e7', 'XCR0=c7'],
+    ['PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK', 'opcode_not_run'],
+  ]) {
+    const events = base.events.map(event => event.Output ? {...event, Output: event.Output.replace(before, after)} : event);
+    assert.throws(() => auditor.auditOwner(base.inventory, raw(events), 1), before);
+  }
+  const late = base.events.filter(event => !event.Output);
+  late.splice(late.length - 2, 0, ...base.events.filter(event => event.Output));
+  assert.throws(() => auditor.auditOwner(base.inventory, raw(late), 1));
+});
+
+test('complete audit reopens all eight current-source raw streams instead of trusting summaries', t => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'packed-native-audit-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  const head = 'a'.repeat(40), directories = [];
+  for (let owner = 0; owner < 8; owner++) {
+    const data = fixture(owner), child = path.join(directory, String(owner));
+    fs.mkdirSync(child);
+    fs.writeFileSync(path.join(child, 'context.json'), JSON.stringify({schema: 1, head, owner}));
+    fs.writeFileSync(path.join(child, 'inventory.log'), data.inventory);
+    fs.writeFileSync(path.join(child, 'raw.jsonl'), raw(data.events));
+    directories.push(child);
+  }
+  assert.deepEqual(auditor.auditComplete(directories, head), {
+    head, owners: 8, roots: 17, children: 714, passed: 731,
+    valueKernels: 692, faultKernels: 222, skipped: 0, incomplete: 0,
+  });
+  assert.throws(() => auditor.auditComplete(directories.slice(0, -1), head));
+  assert.throws(() => auditor.auditComplete([...directories.slice(0, -1), directories[0]], head));
+  assert.throws(() => auditor.auditComplete(directories, 'b'.repeat(40)));
+  const bad = path.join(directories[7], 'raw.jsonl');
+  fs.writeFileSync(bad, '{"allPassed":true}\n');
+  assert.throws(() => auditor.auditComplete(directories, head));
+});
diff --git a/.github/scripts/priority-packed-reductions-native.test.cjs b/.github/scripts/priority-packed-reductions-native.test.cjs
new file mode 100644
index 000000000..6e40295d1
--- /dev/null
+++ b/.github/scripts/priority-packed-reductions-native.test.cjs
@@ -0,0 +1,141 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+const auditor = require('./audit-packed-reduction-native.cjs');
+
+test('native reduction receipts require all current source execution and CPU evidence', () => {
+  const path = '.github/scripts/audit-packed-reduction-native.cjs';
+  assert.ok(fs.existsSync(path), 'missing complete native reduction receipt auditor');
+  const source = fs.readFileSync(path, 'utf8');
+  for (const required of [
+    'auditNativeOwners', 'SSE3=1 SSE41=1 AVX=1 OSXSAVE=1',
+    'PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK', '6n',
+    'original_go_named', 'original_go_raw', 'original_go_opcode_reference',
+    'backend_O0', 'backend_O2', 'IR_O2_backend_O2',
+  ]) {
+    assert.ok(source.includes(required), 'missing strict native reduction guard: ' + required);
+  }
+});
+
+// Synthetic raw streams test only the auditor. Actual CPU/Go/LLVM execution
+// remains required in the separate native jobs; this is not such a receipt.
+function fixture(owner) {
+  const roots = ['Values', 'DeadFaults'].map(family =>
+    'TestCrossLinuxRuntimeMatrixX86PackedReductionNative' + family + 'Part' + owner);
+  const children = [];
+  for (let family = 0; family < 2; family++) {
+    const count = family ? 37 : 258, limit = family ? 8 : 64;
+    for (let start = owner * limit; start < count; start += 4 * limit) {
+      const batch = roots[family] + '/batch-' + String(start).padStart(4, '0');
+      const originals = family ? ['original_go_opcode_reference'] : ['original_go_named', 'original_go_raw'];
+      children.push(batch, ...originals.map(original => batch + '/' + original));
+      for (const spelling of ['named', 'raw']) {
+        const source = batch + '/' + spelling;
+        children.push(source);
+        for (const api of ['text', 'module', 'Go']) {
+          const route = source + '/' + api;
+          children.push(route, ...['backend_O0', 'backend_O2', 'IR_O2_backend_O2'].map(axis => route + '/' + axis));
+        }
+      }
+    }
+  }
+  const events = [];
+  const emit = (Action, Test, Output) => {
+    const event = {Action, Package: 'github.com/xgo-dev/plan9asm'};
+    if (Test) event.Test = Test;
+    if (Output !== undefined) event.Output = Output;
+    events.push(event);
+  };
+  function execute(name) {
+    emit('run', name);
+    if (roots.includes(name)) {
+      emit('output', name, 'SSE3=1 SSE41=1 AVX=1 OSXSAVE=1 XCR0=7\n');
+      emit('output', name, 'PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK members=fff\n');
+    }
+    for (const child of children.filter(child => child.slice(0, child.lastIndexOf('/')) === name)) execute(child);
+    emit('pass', name);
+  }
+  for (const root of roots) execute(root);
+  emit('pass');
+  return {roots, children, inventory: roots.join('\n') + '\n', events};
+}
+
+function raw(events) {
+  return events.map(event => JSON.stringify(event)).join('\n') + '\n';
+}
+
+test('all four owner pairs retain the complete Go source, public API and pipeline axes', () => {
+  let roots = 0, children = 0;
+  for (let owner = 0; owner < 4; owner++) {
+    const independent = fixture(owner), expected = auditor.required(owner);
+    assert.deepEqual(expected.roots, independent.roots);
+    assert.deepEqual(expected.children, independent.children);
+    const result = auditor.auditOwner(independent.inventory, raw(independent.events), owner);
+    assert.equal(result.preflights, 2);
+    assert.equal(result.passed, independent.roots.length + independent.children.length);
+    roots += result.roots;
+    children += result.children;
+  }
+  assert.equal(roots, 8);
+  assert.equal(children, 285);
+});
+
+test('failed skipped missing duplicated foreign incomplete and printed receipts fail', () => {
+  const base = fixture(0), leaf = base.children.find(child => child.endsWith('/original_go_raw'));
+  for (const action of ['fail', 'skip']) {
+    const events = base.events.map(event => event.Test === leaf && event.Action === 'pass' ? {...event, Action: action} : event);
+    assert.throws(() => auditor.auditOwner(base.inventory, raw(events), 0));
+  }
+  for (const change of [
+    events => events.filter(event => event.Test !== leaf),
+    events => events.filter(event => !(event.Test === leaf && event.Action === 'pass')),
+    events => [...events.slice(0, -1), {Action: 'pass', Package: 'github.com/xgo-dev/plan9asm', Test: leaf}, events.at(-1)],
+    events => events.map(event => event.Test === leaf ? {...event, Test: leaf + '/foreign'} : event),
+    events => events.slice(0, -1),
+    events => [{Action: 'output', Package: 'github.com/xgo-dev/plan9asm', Output: 'all reductions passed\n'}, events.at(-1)],
+  ]) assert.throws(() => auditor.auditOwner(base.inventory, raw(change(base.events)), 0));
+  assert.throws(() => auditor.auditOwner(base.inventory, raw(base.events), 1));
+  assert.throws(() => auditor.auditOwner(base.inventory + 'TestForeign\n', raw(base.events), 0));
+});
+
+test('all12 actual opcodes and enabled native state must precede every runtime child', () => {
+  const base = fixture(1);
+  for (const [before, after] of [
+    ['SSE3=1', 'SSE3=0'], ['SSE41=1', 'SSE41=0'], ['AVX=1', 'AVX=0'],
+    ['OSXSAVE=1', 'OSXSAVE=0'], ['XCR0=7', 'XCR0=3'],
+    ['members=fff', 'members=7ff'], ['PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK', 'not_executed'],
+  ]) {
+    const events = base.events.map(event => event.Output ? {...event, Output: event.Output.replace(before, after)} : event);
+    assert.throws(() => auditor.auditOwner(base.inventory, raw(events), 1), before);
+  }
+  const late = base.events.filter(event => !event.Output);
+  late.splice(late.length - 2, 0, ...base.events.filter(event => event.Output));
+  assert.throws(() => auditor.auditOwner(base.inventory, raw(late), 1));
+});
+
+test('complete reduction audit reopens all four current-head raw streams', t => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'reduction-native-audit-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  const head = 'a'.repeat(40), directories = [];
+  for (let owner = 0; owner < 4; owner++) {
+    const data = fixture(owner), child = path.join(directory, String(owner));
+    fs.mkdirSync(child);
+    fs.writeFileSync(path.join(child, 'context.json'), JSON.stringify({schema: 1, head, owner}));
+    fs.writeFileSync(path.join(child, 'inventory.log'), data.inventory);
+    fs.writeFileSync(path.join(child, 'raw.jsonl'), raw(data.events));
+    directories.push(child);
+  }
+  assert.deepEqual(auditor.auditComplete(directories, head), {
+    head, owners: 4, roots: 8, children: 285, passed: 293,
+    valueKernels: 258, faultKernels: 37, skipped: 0, incomplete: 0,
+  });
+  assert.throws(() => auditor.auditComplete(directories.slice(0, -1), head));
+  assert.throws(() => auditor.auditComplete([...directories.slice(0, -1), directories[0]], head));
+  assert.throws(() => auditor.auditComplete(directories, 'b'.repeat(40)));
+  fs.writeFileSync(path.join(directories[3], 'raw.jsonl'), '{"allPassed":true}\n');
+  assert.throws(() => auditor.auditComplete(directories, head));
+});
diff --git a/.github/scripts/priority-packed-string-partitions.test.cjs b/.github/scripts/priority-packed-string-partitions.test.cjs
new file mode 100644
index 000000000..c4962f6a8
--- /dev/null
+++ b/.github/scripts/priority-packed-string-partitions.test.cjs
@@ -0,0 +1,39 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+
+const source = fs.readFileSync(path.join(__dirname, '../../amd64_packed_string_vector_test.go'), 'utf8');
+
+for (const [name, arch, triple] of [
+  ['Linux386', '386', 'i386-unknown-linux-gnu'],
+  ['Windows386', '386', 'i686-pc-windows-msvc'],
+  ['DarwinAMD64', 'amd64', 'x86_64-apple-darwin'],
+  ['LinuxAMD64', 'amd64', 'x86_64-unknown-linux-gnu'],
+  ['WindowsAMD64', 'amd64', 'x86_64-pc-windows-msvc'],
+]) {
+  test('packed-string objects retain independent complete owner ' + name, () => {
+    const declaration = `func TestX86PackedStringObjects${name}(t *testing.T) {\n` +
+      `\tx86PackedStringTargetObjects(t, "${arch}", "${triple}")\n}`;
+    assert.ok(source.includes(declaration), 'missing independent target owner');
+  });
+}
+
+test('packed-string partitioning retains every original row and object axis', () => {
+  assert.ok(source.includes('func TestX86PackedStringObjectBatchInventory(t *testing.T)'));
+  assert.ok(!source.includes('func TestX86PackedStringThreeAPIsFiveTargetsO0O2Objects('));
+  assert.ok(source.includes('const maxFunctions = 64'));
+  assert.ok(source.includes('reflect.DeepEqual(joined, original)'));
+  const helper = source.slice(source.indexOf('func x86PackedStringTargetObjects('),
+    source.indexOf('\nfunc TestX86PackedStringObjectsLinux386('));
+  assert.ok(helper.startsWith('func x86PackedStringTargetObjects('));
+  assert.ok(helper.includes('x86PackedStringObjectBatches(x86PackedStringVectorCases())'));
+  assert.ok(helper.includes('[]string{"text", "module", "Go"}'));
+  assert.ok(helper.includes('[]string{"-O0", "-O2"}'));
+  assert.ok(helper.includes('x86LEAActualTargetGoObject(t, arch, triple, source)'));
+  assert.ok(helper.includes('input = x86UndefinedTrapOptimizedIR(t, input)'));
+  assert.ok(helper.includes('x86PackedStringCompileObject(t, llc, triple, input, level)'));
+  assert.ok(!helper.includes('t.Skip'));
+});
diff --git a/.github/scripts/priority-private-leave-native.test.cjs b/.github/scripts/priority-private-leave-native.test.cjs
new file mode 100644
index 000000000..7e45613e1
--- /dev/null
+++ b/.github/scripts/priority-private-leave-native.test.cjs
@@ -0,0 +1,100 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+const root = 'TestCrossLinuxRuntimeMatrixX86LeavePrivateEmitterWidthsAndFlags';
+const architectures = ['amd64', '386'];
+const paths = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2'];
+const groups = architectures.map(arch => root + '/' + arch);
+const leaves = groups.flatMap(group => paths.map(path => group + '/' + path));
+const names = [root, ...groups, ...leaves];
+const hash = 'a'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${hash} mapsha=${hash}\n`;
+const sdk = arch => `actual LEA source/object receipt: SDK=go1.27.2 target=linux/${arch} source=${hash} driver=${hash} object=${hash}\n`;
+const marker = arch => `private LEAVE numerical completion arch=${arch}: PRIVATE_LEAVE_128_WIDTH_VALUES_FLAGS_CANARIES_PASS\n`;
+const image = `native oracle static IA32 ELF bytes=512 sha256=${hash}\n`;
+const command = `actual executable=/tmp/private-leave sha256=${hash} argv=[]\n`;
+const direct = `IA32 direct ELF bytes=512 sha256=${hash} argv=[]\n`;
+const event = (Action, Test, Output) => ({Action, Package: 'github.com/xgo-dev/plan9asm',
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+
+function completeEvents() {
+  const events = [event('start'), event('run', root), event('output', root, host)];
+  for (const arch of architectures) {
+    const group = root + '/' + arch;
+    events.push(event('run', group), event('output', group, sdk(arch)));
+    for (const path of paths) {
+      const leaf = group + '/' + path;
+      events.push(event('run', leaf), event('output', leaf,
+        (arch === '386' ? image + command + direct : '') + marker(arch)), event('pass', leaf));
+    }
+    events.push(event('pass', group));
+  }
+  events.push(event('output', root, host), event('pass', root), event('pass'));
+  return events;
+}
+
+function audit(events = completeEvents(), inventory = root + '\n') {
+  assert.ok(fs.existsSync('.github/scripts/audit-private-leave-native.cjs'), 'private LEAVE lacks its exact native-width auditor');
+  return require('./audit-private-leave-native.cjs').auditPrivateLEAVE(inventory,
+    events.map(value => JSON.stringify(value)).join('\n'));
+}
+
+test('private LEAVE requires all four width values with six actual pipelines, not a native Go ABI claim', () => {
+  assert.deepEqual(audit(), {roots: 1, children: 8, passed: 9, skipped: 0, incomplete: 0,
+    nativeHosts: 2, sdkCaptures: 2, llvmExecutions: 6, staticIA32Executions: 3, privateNumericalOnly: true});
+});
+
+test('private LEAVE rejects missing duplicate failed skipped incomplete and late lifecycle evidence', () => {
+  audit();
+  for (const name of names) {
+    for (const Action of ['fail', 'skip']) assert.throws(() => audit(completeEvents().map(value =>
+      value.Test === name && value.Action === 'pass' ? {...value, Action} : value)), name + Action);
+    for (const Action of ['run', 'pass']) {
+      const events = completeEvents();
+      const at = events.findIndex(value => value.Test === name && value.Action === Action);
+      assert.throws(() => audit(events.filter((_, index) => index !== at)), name + ' missing ' + Action);
+      events.splice(at, 0, events[at]);
+      assert.throws(() => audit(events), name + ' duplicate ' + Action);
+    }
+    const events = completeEvents();
+    const at = events.findIndex(value => value.Test === name && value.Action === 'pass');
+    events.splice(at + 1, 0, event('output', name, 'late completion\n'));
+    assert.throws(() => audit(events), name + ' output outside running owner');
+  }
+  for (const inventory of ['', root + '\n' + root + '\n', 'TestUnrelated\n']) assert.throws(() => audit(completeEvents(), inventory));
+  for (const events of [completeEvents().slice(1), completeEvents().slice(0, -1),
+    [event('output', undefined, 'all widths passed')], [event('start'), ...completeEvents()],
+    [...completeEvents(), event('pass')], completeEvents().map(value => ({...value, Package: 'foreign'}))]) {
+    assert.throws(() => audit(events));
+  }
+});
+
+test('private LEAVE binds actual host SDK static ELF hash and every complete execution to its own live owner', () => {
+  audit();
+  for (const needle of [host, ...architectures.map(sdk), image, command, direct, ...architectures.map(marker)]) {
+    for (const replacement of ['', needle + needle, needle.replace(hash, 'invalid'),
+      needle.replace('128', '127').replace('linux/amd64', 'linux/arm64').replace('arch=386', 'arch=amd64')]) {
+      if (replacement === needle) continue;
+      assert.throws(() => audit(completeEvents().map(value => value.Output
+        ? {...value, Output: value.Output.replace(needle, replacement)} : value)), needle);
+    }
+  }
+  for (const needle of [image, command, direct]) {
+    assert.throws(() => audit(completeEvents().map(value => value.Output
+      ? {...value, Output: value.Output.replace(needle, needle.replace(hash, 'b'.repeat(64)))} : value)));
+  }
+  const lateSDK = completeEvents();
+  const capture = lateSDK.splice(lateSDK.findIndex(value => value.Output === sdk('amd64')), 1)[0];
+  lateSDK.splice(lateSDK.findIndex(value => value.Test === root + '/amd64/backend_O0' && value.Action === 'pass'), 0, capture);
+  assert.throws(() => audit(lateSDK), 'SDK must precede actual compilation/execution');
+  const earlyHost = completeEvents();
+  const post = earlyHost.splice(earlyHost.length - 3, 1)[0];
+  earlyHost.splice(4, 0, post);
+  assert.throws(() => audit(earlyHost), 'final host must follow both complete architectures');
+  const borrowed = completeEvents().map(value => value.Test === root + '/386/backend_O0' && value.Output
+    ? {...value, Test: root + '/386'} : value);
+  assert.throws(() => audit(borrowed), 'a parent cannot replace a leaf execution');
+});
diff --git a/.github/scripts/priority-product-cmov.test.cjs b/.github/scripts/priority-product-cmov.test.cjs
new file mode 100644
index 000000000..c662c39e1
--- /dev/null
+++ b/.github/scripts/priority-product-cmov.test.cjs
@@ -0,0 +1,40 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditProductCMOV, roots, children} = require('./audit-product-cmov.cjs');
+
+test('product and CMOV execution retains every root and optimization child without skips', () => {
+  assert.deepEqual(roots, [
+    'TestCrossLinuxRuntimeMatrixX86DwordProductIndependentWholeBytes',
+    'TestCrossLinuxRuntimeMatrixX86CMOVIndependentWholeBytes',
+    'TestCrossLinuxRuntimeMatrixX86AESFamilyWholeByteAliases',
+    'TestAMD64VectorTestRuntimeSemantics',
+    'TestAMD64IFMARuntimeSemantics',
+    'TestAMD64QwordBitLookupRuntimeSemantics',
+    'TestCrossLinuxRuntimeMatrixX86CMOVFPPartialCrossSlotWholeBytes',
+  ]);
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const child of children.filter(name => name.startsWith(root + '/'))) {
+      events.push(event('run', child), event('pass', child));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const raw = values => values.map(JSON.stringify).join('\n') + '\n';
+  const inventory = roots.join('\n') + '\n';
+  assert.deepEqual(auditProductCMOV(inventory, raw(events)),
+    {roots: 7, children: 24, passed: 31, skipped: 0, incomplete: 0});
+  for (const name of [...roots, ...children]) {
+    assert.throws(() => auditProductCMOV(inventory, raw(events.filter(event => event.Test !== name))));
+    for (const Action of ['skip', 'fail']) {
+      assert.throws(() => auditProductCMOV(inventory, raw(events.map(event =>
+        event.Test === name && event.Action === 'pass' ? {...event, Action} : event))));
+    }
+  }
+  assert.throws(() => auditProductCMOV(inventory, raw(events.slice(0, -1))));
+  assert.throws(() => auditProductCMOV(inventory, raw([event('start'), event('pass')])));
+});
diff --git a/.github/scripts/priority-race-shard-layout.test.cjs b/.github/scripts/priority-race-shard-layout.test.cjs
new file mode 100644
index 000000000..358e3b301
--- /dev/null
+++ b/.github/scripts/priority-race-shard-layout.test.cjs
@@ -0,0 +1,94 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody, requireJobNeeds} = require('./workflow-needs.cjs');
+
+const workflow = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+const script = fs.readFileSync(path.join(__dirname, '../../scripts/test-module-ci.sh'), 'utf8');
+
+function step(body, title) {
+  const selected = body.split(/(?=^      - )/m).filter(item => item.startsWith(`      - name: ${title}\n`));
+  assert.equal(selected.length, 1, 'one exact complete-owner step required: ' + title);
+  return selected[0];
+}
+
+function requireRaceOwners(source) {
+  const body = jobBody(source, 'race');
+  const roles = Array.from({length: 32}, (_, index) => 'root-' + index).concat('profile', 'other');
+  const axis = body.match(/^        module-role: \[([^\]]+)\]$/m);
+  assert.ok(axis, 'explicit complete race scheduling owners');
+  assert.deepEqual(axis[1].split(',').map(value => value.trim()), roles);
+  const mappings = [...body.matchAll(
+    /^          - \{module-role: (root-\d+|profile|other), module-owner: ([012]), root-partition: (-?\d+)\}$/gm,
+  )].map(([, role, owner, part]) => [role, Number(owner), Number(part)]);
+  assert.deepEqual(mappings, [
+    ...Array.from({length: 32}, (_, index) => ['root-' + index, 0, index]),
+    ['profile', 1, -1], ['other', 2, -1],
+  ]);
+  assert.match(body, /^    needs: ci_policy$/m);
+  assert.match(body, /^    timeout-minutes: 75$/m);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.doesNotMatch(body, /^    if:|max-parallel:|continue-on-error:/m);
+  assert.match(step(body, 'Go test (race)'),
+    /^        run: bash scripts\/test-module-ci\.sh race execute \$\{\{ matrix\.module-owner \}\} \$\{\{ matrix\.root-partition \}\}$/m);
+}
+
+function requireCompleteRaceDownloads(source) {
+  const body = jobBody(source, 'module-completion');
+  requireJobNeeds(source, 'module-completion', ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']);
+  assert.match(body, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+  assert.deepEqual([...body.matchAll(/^      - name: Download root part (\d+)$/gm)].map(match => Number(match[1])),
+    Array.from({length: 32}, (_, index) => index));
+  for (let index = 0; index < 32; index++) {
+    const download = step(body, 'Download root part ' + index);
+    assert.ok(download.includes('name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-' + index + '\n'));
+    assert.ok(download.includes('path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-' +
+      String(index).padStart(4, '0') + '\n'));
+    if (index >= 16) assert.match(download, /^        if: \$\{\{ !cancelled\(\) && matrix\.flavor == 'race' \}\}$/m);
+    else assert.doesNotMatch(download, /^        if:.*matrix\.flavor/m);
+  }
+  assert.doesNotMatch(body, /merge-multiple:|pattern:/);
+}
+
+test('race owns 64 complete shards through 32 independent two-shard jobs', () => {
+  requireRaceOwners(workflow);
+});
+
+test('complete aggregation retains every new race owner without raising budgets', () => {
+  requireCompleteRaceDownloads(workflow);
+});
+
+test('race script selects its complete layout for execution and independent completion', () => {
+  assert.match(script, /^root_partitions=16$/m);
+  assert.match(script, /^shards=32$/m);
+  assert.ok(script.includes('race) timeout=60m; flags=(-race); root_partitions=32; shards=64 ;;'));
+  assert.equal([...script.matchAll(/-shards=\$shards -workers=2/g)].length, 2);
+  assert.match(script, /GOMAXPROCS=2/);
+  assert.match(script, /test\) timeout=45m ;;/);
+  assert.match(script, /coverage\) timeout=45m; flags=\(-coverprofile=coverage-root\.out\) ;;/);
+});
+
+test('race layout rejects an omitted owner, four-shard owner, masked failure or incomplete readback', () => {
+  requireRaceOwners(workflow);
+  requireCompleteRaceDownloads(workflow);
+  const race = jobBody(workflow, 'race');
+  for (const [before, after] of [
+    ['root-31,', ''],
+    ['root-partition: 31', 'root-partition: 30'],
+    ['timeout-minutes: 75', 'timeout-minutes: 90'],
+    ['fail-fast: false', 'fail-fast: true'],
+    ['timeout-minutes: 75', 'timeout-minutes: 75\n    continue-on-error: true'],
+  ]) {
+    const changed = race.replace(before, after);
+    assert.notEqual(changed, race);
+    assert.throws(() => requireRaceOwners(workflow.replace(race, () => changed)));
+  }
+  const complete = jobBody(workflow, 'module-completion');
+  for (const index of [8, 16, 24, 31]) {
+    const download = step(complete, 'Download root part ' + index);
+    assert.throws(() => requireCompleteRaceDownloads(workflow.replace(download, '')));
+  }
+});
diff --git a/.github/scripts/priority-readonly-data-fresh-leases.test.cjs b/.github/scripts/priority-readonly-data-fresh-leases.test.cjs
new file mode 100644
index 000000000..84727c55f
--- /dev/null
+++ b/.github/scripts/priority-readonly-data-fresh-leases.test.cjs
@@ -0,0 +1,82 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const {test} = require('node:test');
+
+const read = file => fs.readFileSync(file, 'utf8');
+const sha = value => crypto.createHash('sha256').update(value).digest('hex');
+const matrix = read('amd64_fixed_local_data_matrix_go127_test.go');
+const objects = read('amd64_fixed_local_data_go127_test.go');
+const runtime = read('amd64_fixed_local_data_runtime_go127_test.go');
+const frame = read('amd64_fixed_local_frame_test.go');
+const fresh = frame.slice(frame.indexOf('func fixedLocalFreshAPIs('), frame.indexOf('\nfunc fixedLocalAPI('));
+const single = frame.slice(frame.indexOf('func fixedLocalAPI('), frame.indexOf('\nfunc fixedLocalRequireContext('));
+
+function requireFreshOwner(source) {
+  assert.match(source, /fixedLocalFreshAPIs\(t, pkg, request, options, \[\]string\{"Translate", "Module", "GoModule"\}/);
+  assert.doesNotMatch(source, /requireGoAMD64FrameCapture\(|runtimeOracleStageContext\(|source\.BindFixedLocal\(|fixedLocalDataAPIs\(/);
+}
+
+function originalCacheSetup(source, owners) {
+  // Cache policy checks owner selection and preparation order; Go lifecycle
+  // tests exercise the process-owned cache and independent source workspaces.
+  // Normalize only this setup call, keeping the original numerical and
+  // mutation/Close fingerprints unchanged.
+  const prepared = '\tgoAMD64FramePrepareOwnedToolCache(t)\n';
+  assert.equal(source.split(prepared).length - 1, owners);
+  return source.replaceAll(prepared, '\tt.Setenv("GOCACHE", t.TempDir())\n');
+}
+
+test('every complete readonly DATA consumer owns a fresh lease per API', () => {
+  requireFreshOwner(matrix.slice(matrix.indexOf('func fixedLocalDataTargetConsumers('), matrix.indexOf('\nfunc TestGoAMD64FixedLocalReadonlyDataRejectsUnownedAccesses(')));
+  requireFreshOwner(objects.slice(objects.indexOf('func TestGoAMD64FixedLocalReadonlyDataThreeTargetObjects('), objects.indexOf('\nfunc fixedLocalDataAPIs(')));
+  requireFreshOwner(runtime);
+});
+
+test('the shared fresh owner passes complete preprocessed DATA to the single API implementation', () => {
+  assert.match(fresh, /fixedLocalAPI\(t, pkg, file, bound, api, check, expanded\)/);
+  assert.match(single, /assembly \.\.\.string/);
+  assert.match(single, /len\(assembly\) > 1/);
+  assert.match(single, /len\(assembly\) == 1 && assembly\[0\] == ""/);
+  assert.match(single, /if len\(assembly\) == 1 \{\s*source\.WriteString\(assembly\[0\]\)/);
+  assert.match(single, /TranslateGoModule\(pkg, \[\]byte\(source\.String\(\)\)/);
+  assert.match(fresh, /defer cancel\(\)/);
+  assert.match(fresh, /defer func\(\) \{\s*if err := source\.Close\(\)/);
+  assert.match(single, /defer ctx\.Dispose\(\)/);
+  assert.match(single, /defer module\.Dispose\(\)/);
+  assert.match(single, /defer translation\.Module\.Dispose\(\)/);
+});
+
+test('the complete literal matrix retains all original 119 operations and four source batches on every target', () => {
+  const builder = matrix.slice(matrix.indexOf('func fixedLocalDataOperations('), matrix.indexOf('\nfunc TestGoAMD64FixedLocalReadonlyDataLinuxRegisteredConsumers('));
+  assert.equal(sha(builder), 'e34a575231dceb014395766eba83308b6a8e078a57082b90ccc6ed92b5b3d3d9');
+  for (const [target, triple] of [['linux/amd64', 'x86_64-unknown-linux-gnu'], ['darwin/amd64', 'x86_64-apple-darwin'], ['windows/amd64', 'x86_64-pc-windows-msvc']]) {
+    assert.ok(matrix.includes(`fixedLocalDataTargetConsumers(t, "${target}", "${triple}")`));
+  }
+  assert.match(matrix, /len\(operations\) != 119/);
+  assert.match(matrix, /for start := 0; start < len\(operations\); start \+= 32/);
+  assert.match(matrix, /for index := start; index < end; index\+\+/);
+  assert.match(matrix, /assembly\.WriteString\(strings\.Replace\(fixedLocalLiteralData, "\$32", "\$64", 1\)\)/);
+  assert.match(matrix, /compileLLVMToObject\(t, llc, triple, "literal-consumers\.ll"/);
+  assert.match(matrix, /compileLLVMToObject\(t, llc, triple, "literal-consumers-opt\.ll"/);
+});
+
+test('original runtime values are unchanged outside independent tool preparation', () => {
+  const original = originalCacheSetup(runtime.slice(0, runtime.indexOf('\tpkg, request,')), 1);
+  assert.equal(sha(original), '85e040739a6a7623e4ef1797241e4ee9ab93bca60203975369762e6e68b16eda');
+  assert.match(runtime, /fixedLocalPackedRunOriginal\(t, execution, assembly\.String\(\), declarations\.String\(\), goOracle, true\)/);
+  assert.match(runtime, /\[\]string\{"-O0", "-O2"\}/);
+});
+
+test('negative shared-binding mutation/Close controls are not renewed', () => {
+  const guards = read('amd64_fixed_local_data_guards_go127_test.go');
+  const additional = guards.indexOf('\nfunc TestGoAMD64FixedLocalReadonlyDataCLIEmissionIdentity(');
+  assert.ok(additional > 0, 'the independent emission-identity regression must remain present');
+  // Appending another independent owner must not change the original controls'
+  // fingerprint or require pretending it shares their cache/observation.
+  const original = originalCacheSetup(guards.slice(0, additional), 2);
+  assert.equal(sha(original), '3730f8eaf2f8485989658c94056002b6508f8cae74a14ba56c7c6c956f472d1a');
+  originalCacheSetup(guards.slice(additional), 1);
+});
diff --git a/.github/scripts/priority-runtime-integration.test.cjs b/.github/scripts/priority-runtime-integration.test.cjs
new file mode 100644
index 000000000..47bacbc35
--- /dev/null
+++ b/.github/scripts/priority-runtime-integration.test.cjs
@@ -0,0 +1,293 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody, jobNeeds} = require('./workflow-needs.cjs');
+
+const directory = path.join(__dirname, '../workflows');
+const goCI = fs.readFileSync(path.join(directory, 'go-ci.yml'), 'utf8');
+const runtimeFile = path.join(directory, 'runtime-integration.yml');
+const runtime = fs.existsSync(runtimeFile) ? fs.readFileSync(runtimeFile, 'utf8') : '';
+const benchmarkScript = fs.readFileSync(path.join(__dirname, '../../scripts/benchmark-compile.sh'), 'utf8');
+const instructionJobs = ['ci_policy', 'fmt', 'build', 'stdlib-corpus', 'cross-runtime',
+  'cross-runtime-verify', 'test', 'nested-cli', 'windows-module', 'arm-scan',
+  'race', 'coverage', 'nested-cli-coverage', 'module-completion'];
+const linuxTargets = ['linux/386', 'linux/amd64', 'linux/arm', 'linux/arm64',
+  'darwin/amd64', 'darwin/arm64', 'windows/386', 'windows/amd64', 'windows/arm64', 'js/wasm'];
+const corpusTargets = [linuxTargets,
+  ...Array.from({length: 7}, () => [...linuxTargets, 'wasip1/wasm']),
+  ['darwin/amd64', 'darwin/arm64'], ['windows/386', 'windows/amd64', 'windows/arm64']];
+
+function jobNames(source) {
+  const sections = source.split('\njobs:\n');
+  assert.equal(sections.length, 2, 'one explicit jobs section');
+  return [...sections[1].matchAll(/^  ([a-zA-Z_][a-zA-Z0-9_-]*):\s*$/gm)].map(match => match[1]);
+}
+
+function requireJobSet(source, expected) {
+  assert.deepEqual(jobNames(source).sort(), expected.slice().sort(), 'complete, unique job ownership');
+}
+
+function requireExactSDK(body) {
+  const setup = body.split(/(?=^      - )/m).filter(step =>
+    /^        uses: \.\/\.github\/actions\/setup-go$/m.test(step));
+  assert.equal(setup.length, 1, 'one observed SDK setup');
+  assert.match(setup[0], /^          go-version: '1\.27\.2'$/m);
+  assert.doesNotMatch(body, /go-version-file:|check-latest:|uses: actions\/setup-go@/);
+}
+
+function requireRuntimeIntegration(source) {
+  assert.match(source, /^name: SDK\/runtime integration$/m);
+  const triggers = source.match(/^on:\n([\s\S]*?)(?=^\S)/m);
+  assert.ok(triggers, 'explicit standalone workflow triggers');
+  assert.deepEqual([...triggers[1].matchAll(/^  ([a-z_]+):[^\n]*$/gm)].map(match => match[1]),
+    ['workflow_dispatch', 'schedule']);
+  assert.match(triggers[1], /^    - cron: '17 3 \* \* 1'$/m, 'one weekly schedule');
+  assert.equal([...triggers[1].matchAll(/cron:/g)].length, 1);
+  assert.match(source, /^  cancel-in-progress: false$/m);
+  assert.match(source, /^permissions:\n  contents: read$/m);
+  requireJobSet(source, ['ci_policy', 'benchmark', 'stdlib-corpus']);
+  assert.doesNotMatch(source, /continue-on-error:|\|\|\s*true|\bexit 0\b/);
+  assert.doesNotMatch(source, /PLAN9ASM_BENCHMARK_(?:TARGETS|REPORT_DIR):/);
+
+  const policy = jobBody(source, 'ci_policy');
+  assert.doesNotMatch(policy, /^    (?:needs|if):/m);
+  assert.match(policy, /^    timeout-minutes: 20$/m);
+  assert.match(policy, /^        run: bash scripts\/install-ci-llvm22-ubuntu\.sh$/m);
+  assert.match(policy, /^        run: node --test \.github\/scripts\/priority-\*\.test\.cjs$/m);
+  assert.match(policy, /^        run: go test \. -run '\^TestCI' -count=1$/m);
+  requireExactSDK(policy);
+
+  const job = jobBody(source, 'benchmark');
+  assert.deepEqual(jobNeeds(source, 'benchmark'), ['ci_policy']);
+  assert.match(job, /^    name: complete standard-library SDK\/runtime compile \(Go 1\.27, LLVM 22\)$/m);
+  assert.match(job, /^    timeout-minutes: 35$/m);
+  assert.doesNotMatch(job, /^    if:/m);
+  requireExactSDK(job);
+  const steps = job.split(/(?=^      - )/m).slice(1);
+  assert.equal(steps.length, 5, 'retain every original execution and report step');
+  assert.match(steps[0], /^        uses: actions\/checkout@v7$/m);
+  assert.match(steps[1], /^        run: bash scripts\/install-ci-llvm22-ubuntu\.sh$/m);
+  assert.match(steps[1], /^        timeout-minutes: 14$/m);
+  for (const step of steps.slice(0, 4)) assert.doesNotMatch(step, /^        if:/m);
+  assert.match(steps[3], /^        run: scripts\/benchmark-compile\.sh$/m);
+  const environment = [...steps[3].matchAll(/^          ([A-Z0-9_]+): (.+)$/gm)];
+  assert.deepEqual(environment.map(match => [match[1], match[2]]), [
+    ['PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS', "'300'"],
+    ['PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS', "'900'"],
+  ]);
+  assert.match(steps[4], /^        if: always\(\)$/m);
+  assert.match(steps[4], /^        uses: actions\/upload-artifact@v6$/m);
+  assert.match(steps[4], /^          name: compile-benchmark$/m);
+  assert.match(steps[4], /^          path: _out\/compile-benchmark$/m);
+  assert.match(steps[4], /^          if-no-files-found: error$/m);
+
+  const corpus = jobBody(source, 'stdlib-corpus');
+  assert.deepEqual(jobNeeds(source, 'stdlib-corpus'), ['ci_policy']);
+  assert.match(corpus, /^    name: complete stdlib source\/object corpus \(/m);
+  assert.doesNotMatch(corpus, /^    if:|--instructions-only/m);
+  assert.match(corpus, /^          scripts\/check-stdlib-corpus\.sh$/m);
+  requireCorpusTargets(corpus);
+  // The complete matrix, tools and prebuild transport are still the original
+  // corpus job. Only its instruction-only call and redundant official-table
+  // step differ from the required PR instruction owner.
+  assert.equal(corpusBody(corpus), corpusBody(jobBody(goCI, 'stdlib-corpus')),
+    'full SDK/OS/architecture-profile matrix and tool requirements must match');
+}
+
+function corpusBody(body) {
+  return body.replace(/^    name: [^\n]+\n/m, '')
+    .replace('scripts/check-stdlib-corpus.sh --instructions-only', 'scripts/check-stdlib-corpus.sh')
+    .split('\n      - name: Official Go assembler coverage regression\n')[0].trimEnd();
+}
+
+function requireCorpusTargets(body) {
+  const actual = [...body.matchAll(/targets: '([^']+)'/g)].map(match => match[1].split(','));
+  assert.deepEqual(actual, corpusTargets,
+    'every SDK/host lane must retain its complete, independently known OS/architecture inventory');
+}
+
+function requireInstructionOwners(source) {
+  requireJobSet(source, instructionJobs);
+  assert.doesNotMatch(source, /runtime-integration\.yml|scripts\/benchmark-compile\.sh/);
+  for (const name of ['fmt', 'build', 'stdlib-corpus', 'cross-runtime', 'test', 'nested-cli',
+    'windows-module', 'arm-scan', 'race', 'coverage', 'nested-cli-coverage']) {
+    assert.deepEqual(jobNeeds(source, name), ['ci_policy'], name);
+    assert.doesNotMatch(jobBody(source, name), /^    if:|continue-on-error:/m, name);
+  }
+  assert.deepEqual(jobNeeds(source, 'cross-runtime-verify'), ['cross-runtime']);
+  assert.deepEqual(jobNeeds(source, 'module-completion'),
+    ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']);
+  assert.match(jobBody(source, 'build'), /run: scripts\/check-arm64-plan9-corpus\.sh/);
+  const corpus = jobBody(source, 'stdlib-corpus');
+  assert.match(corpus, /^    name: stdlib instruction corpus \(/m);
+  assert.match(corpus, /^          scripts\/check-stdlib-corpus\.sh --instructions-only$/m);
+  assert.match(corpus, /scripts\/check-go-asm-coverage\.sh/);
+  requireCorpusTargets(corpus);
+  assert.match(jobBody(source, 'cross-runtime'), /scripts\/install-ci-qemu\.sh/);
+  assert.match(jobBody(source, 'windows-module'), /uses: \.\/\.github\/workflows\/windows-module\.yml/);
+  assert.match(jobBody(source, 'coverage'), /bash scripts\/test-module-ci\.sh coverage execute/);
+  assert.match(jobBody(source, 'module-completion'), /files: \.\/coverage-root\.out/);
+}
+
+function withoutJob(source, name) {
+  return source.replace('\n  ' + name + ':\n' + jobBody(source, name), '\n');
+}
+
+// The positive mutation fixture is the intended move of the real existing
+// job, not a claimed execution result. Actual workflow tests below never use
+// this fallback to hide a missing integration workflow.
+let instructionFixture = /\n  benchmark:\n/.test(goCI) ? withoutJob(goCI, 'benchmark') : goCI;
+instructionFixture = instructionFixture.replace('name: stdlib-corpus (', 'name: stdlib instruction corpus (')
+  .replace('          scripts/check-stdlib-corpus.sh\n', '          scripts/check-stdlib-corpus.sh --instructions-only\n');
+let runtimeFixture = runtime;
+if (!runtimeFixture) {
+  const policy = jobBody(goCI, 'ci_policy').replace("go-version: '1.27.1'", "go-version: '1.27.2'");
+  const benchmark = jobBody(goCI, 'benchmark').replace('name: compile benchmark (Go 1.27, LLVM 22)',
+    'name: complete standard-library SDK/runtime compile (Go 1.27, LLVM 22)');
+  const corpus = jobBody(goCI, 'stdlib-corpus')
+    .replace('name: stdlib-corpus (', 'name: complete stdlib source/object corpus (')
+    .split('\n      - name: Official Go assembler coverage regression\n')[0];
+  runtimeFixture = "name: SDK/runtime integration\n\non:\n  workflow_dispatch:\n  schedule:\n" +
+    "    - cron: '17 3 * * 1'\n\nconcurrency:\n" +
+    "  group: ${{ github.workflow }}-${{ github.ref }}\n  cancel-in-progress: false\n\n" +
+    'permissions:\n  contents: read\n\njobs:\n  ci_policy:\n' + policy + '\n  benchmark:\n' + benchmark +
+    '\n  stdlib-corpus:\n' + corpus;
+}
+
+test('complete SDK/runtime integration has independent manual and weekly strict ownership', () => {
+  requireRuntimeIntegration(runtime);
+});
+
+test('PR Go CI retains every instruction owner without a successful runtime placeholder', () => {
+  requireInstructionOwners(goCI);
+});
+
+test('the unchanged strict benchmark still requires full five-target whole-source compilation', () => {
+  assert.ok(benchmarkScript.includes('targets_csv=${PLAN9ASM_BENCHMARK_TARGETS:-linux/386,linux/amd64,linux/arm,linux/arm64,js/wasm}'));
+  for (const flag of ['-patterns=std', '-compile', '-strict-load', '-keep-going=true']) {
+    assert.ok(benchmarkScript.includes('    ' + flag + ' \\'), flag);
+  }
+  assert.match(benchmarkScript, /\.failed == 0 and \.not_applicable == 0 and \.success == \.total_asm/);
+  assert.match(benchmarkScript, /if \(\( budget_failed != 0 \|\| compile_failed != 0 \)\); then\n  exit 1/);
+  assert.match(benchmarkScript, /benchmark reports already exist; select a fresh PLAN9ASM_BENCHMARK_REPORT_DIR/);
+});
+
+test('runtime policy rejects trigger, compiler, budget, source, report and failure masking drift', async t => {
+  requireRuntimeIntegration(runtimeFixture);
+  const changes = [
+    ['PR trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  pull_request:\n'],
+    ['inline PR trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  pull_request: {}\n'],
+    ['push trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  push:\n'],
+    ['inline push trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  push: {}\n'],
+    ['call trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  workflow_call:\n'],
+    ['duplicate manual trigger', '  workflow_dispatch:\n', '  workflow_dispatch:\n  workflow_dispatch: {}\n'],
+    ['duplicate schedule trigger', '  schedule:\n', '  schedule:\n  schedule:\n'],
+    ['missing manual', '  workflow_dispatch:\n', ''],
+    ['daily schedule', "cron: '17 3 * * 1'", "cron: '17 3 * * *'"],
+    ['cancel prior evidence', 'cancel-in-progress: false', 'cancel-in-progress: true'],
+    ['missing policy command', "run: go test . -run '^TestCI' -count=1", 'run: echo policy'],
+    ['foreign SDK', "go-version: '1.27.2'", "go-version: '1.27.3'"],
+    ['floating SDK', "go-version: '1.27.2'", "go-version: '1.27.x'"],
+    ['wrong LLVM', 'run: bash scripts/install-ci-llvm22-ubuntu.sh', 'run: echo LLVM23'],
+    ['job budget', 'timeout-minutes: 35', 'timeout-minutes: 45'],
+    ['target budget', "PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS: '300'", "PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS: '600'"],
+    ['total budget', "PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS: '900'", "PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS: '1800'"],
+    ['partial target override', "PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS: '900'", "PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS: '900'\n          PLAN9ASM_BENCHMARK_TARGETS: linux/amd64"],
+    ['successful placeholder', 'run: scripts/benchmark-compile.sh', 'run: echo success'],
+    ['arguments substitute sources', 'run: scripts/benchmark-compile.sh', 'run: scripts/benchmark-compile.sh -patterns=math'],
+    ['hidden command failure', 'run: scripts/benchmark-compile.sh', 'run: scripts/benchmark-compile.sh || true'],
+    ['hidden job failure', '    timeout-minutes: 35', '    timeout-minutes: 35\n    continue-on-error: true'],
+    ['skipped job', '    timeout-minutes: 35', '    timeout-minutes: 35\n    if: false'],
+    ['skipped compile', '      - name: Translate and compile standard-library assembly', '      - name: Translate and compile standard-library assembly\n        if: false'],
+    ['lost failure report', 'if: always()', 'if: success()'],
+    ['missing report', 'if-no-files-found: error', 'if-no-files-found: ignore'],
+    ['wrong report', 'path: _out/compile-benchmark', 'path: _out/partial-benchmark'],
+    ['runtime corpus reduced to scanning', '          scripts/check-stdlib-corpus.sh\n', '          scripts/check-stdlib-corpus.sh --instructions-only\n'],
+    ['missing corpus target', 'linux/arm64,', ''],
+    ['missing corpus prebuild', 'go build -C cmd/plan9asm -o "$tool" .', 'echo no-tool'],
+  ];
+  for (const [name, before, after] of changes) {
+    await t.test(name, () => {
+      assert.ok(runtimeFixture.includes(before), 'mutation must apply');
+      assert.throws(() => requireRuntimeIntegration(runtimeFixture.replaceAll(before, after)));
+    });
+  }
+  await t.test('missing benchmark policy needs', () => {
+    assert.throws(() => requireRuntimeIntegration(runtimeFixture.replace('    needs: ci_policy\n', '')));
+  });
+  await t.test('duplicate benchmark owner', () => {
+    assert.throws(() => requireRuntimeIntegration(runtimeFixture + '\n  benchmark:\n    run: true\n'));
+  });
+  await t.test('missing full source/object corpus owner', () => {
+    assert.throws(() => requireRuntimeIntegration(withoutJob(runtimeFixture, 'stdlib-corpus')));
+  });
+  for (const line of jobBody(runtimeFixture, 'stdlib-corpus').split('\n').filter(line =>
+    /^          - \{os: /.test(line))) {
+    await t.test('missing full corpus lane ' + line.trim(), () => {
+      assert.throws(() => requireRuntimeIntegration(runtimeFixture.replace(line + '\n', '')));
+    });
+  }
+});
+
+test('responsibility split cannot delete or replace a required instruction owner', async t => {
+  requireInstructionOwners(instructionFixture);
+  for (const name of instructionJobs) {
+    await t.test('missing ' + name, () => {
+      assert.throws(() => requireInstructionOwners(withoutJob(instructionFixture, name)));
+    });
+  }
+  for (const [before, after] of [
+    ['scripts/check-go-asm-coverage.sh', 'echo official-coverage'],
+    ['scripts/check-stdlib-corpus.sh', 'echo corpus'],
+    ['scripts/check-stdlib-corpus.sh --instructions-only', 'scripts/check-stdlib-corpus.sh'],
+    ['scripts/check-arm64-plan9-corpus.sh', 'echo arm64-corpus'],
+    ['linux/arm64,', ''],
+    ['scripts/install-ci-qemu.sh', 'echo native'],
+    ['files: ./coverage-root.out', 'files: ./partial-coverage.out'],
+    ['    needs: [test, nested-cli, race, coverage, nested-cli-coverage]',
+      '    needs: [test, nested-cli, race, nested-cli-coverage]'],
+    ['    needs: [test, nested-cli, race, coverage, nested-cli-coverage]',
+      '    needs: [test, nested-cli, race, coverage]'],
+    ['uses: ./.github/workflows/windows-module.yml', 'uses: ./.github/workflows/runtime-integration.yml'],
+  ]) {
+    await t.test('replace ' + before, () => {
+      assert.ok(instructionFixture.includes(before), 'mutation must apply');
+      assert.throws(() => requireInstructionOwners(instructionFixture.replaceAll(before, after)));
+    });
+  }
+  await t.test('successful old benchmark identity', () => {
+    assert.throws(() => requireInstructionOwners(instructionFixture + '\n  benchmark:\n    run: echo success\n'));
+  });
+});
+
+test('both corpus copies independently reject every missing or duplicate OS/architecture target', async t => {
+  requireCorpusTargets(jobBody(goCI, 'stdlib-corpus'));
+  requireRuntimeIntegration(runtimeFixture);
+  requireInstructionOwners(instructionFixture);
+  function replaceTargets(source, lane, targets) {
+    const body = jobBody(source, 'stdlib-corpus');
+    const field = [...body.matchAll(/targets: '([^']+)'/g)][lane];
+    const changed = body.slice(0, field.index) + "targets: '" + targets.join(',') + "'" +
+      body.slice(field.index + field[0].length);
+    assert.notEqual(changed, body, 'target mutation must apply');
+    return source.replace(body, changed);
+  }
+  for (const [lane, targets] of corpusTargets.entries()) {
+    for (const [index, target] of targets.entries()) {
+      for (const operation of ['missing', 'duplicate']) {
+        await t.test('lane ' + lane + '/' + target + '/' + operation, () => {
+          const changed = targets.slice();
+          if (operation === 'missing') changed.splice(index, 1);
+          else changed.splice(index, 0, target);
+          // Change both copies together: cross-workflow equality alone must
+          // never make a jointly reduced or duplicated matrix acceptable.
+          assert.throws(() => requireInstructionOwners(replaceTargets(instructionFixture, lane, changed)));
+          assert.throws(() => requireRuntimeIntegration(replaceTargets(runtimeFixture, lane, changed)));
+        });
+      }
+    }
+  }
+});
diff --git a/.github/scripts/priority-scalar-bmi.test.cjs b/.github/scripts/priority-scalar-bmi.test.cjs
new file mode 100644
index 000000000..29173d301
--- /dev/null
+++ b/.github/scripts/priority-scalar-bmi.test.cjs
@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const {auditScalarBMI, roots} = require('./audit-scalar-bmi.cjs');
+
+test('native scalar BMI execution cannot be replaced by skips, output text or an incomplete owner', () => {
+  const event = (Action, Test) => ({Action, Package:'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start'), ...roots.flatMap(root => [event('run', root), event('pass', root)]), event('pass')];
+  const raw = values => values.map(JSON.stringify).join('\n') + '\n';
+  const inventory = roots.join('\n') + '\n';
+  assert.deepEqual(auditScalarBMI(inventory, raw(events)),
+    {roots:3, children:0, passed:3, skipped:0, incomplete:0});
+  for (const root of roots) {
+    assert.throws(() => auditScalarBMI(inventory, raw(events.filter(event => event.Test !== root))));
+    assert.throws(() => auditScalarBMI(inventory, raw(events.map(event =>
+      event.Test === root && event.Action === 'pass' ? {...event, Action:'skip'} : event))));
+  }
+  assert.throws(() => auditScalarBMI(inventory, raw(events.slice(0, -1))));
+  assert.throws(() => auditScalarBMI(inventory,
+    raw([event('start'), {...event('output'), Output:roots.join('\nPASS ')}, event('pass')])));
+});
diff --git a/.github/scripts/priority-scalar-reciprocal-native.test.cjs b/.github/scripts/priority-scalar-reciprocal-native.test.cjs
new file mode 100644
index 000000000..96e83993c
--- /dev/null
+++ b/.github/scripts/priority-scalar-reciprocal-native.test.cjs
@@ -0,0 +1,157 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+// Deliberately independent of the implementation's denominator and receipts.
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNativeAMD64',
+  'TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNative386',
+];
+const axes = ['backend_O0', 'backend_O2', 'IR_O2/backend_O2', 'OriginalGo'];
+const hash = 'a'.repeat(64), imageHash = 'b'.repeat(64);
+const host = `IA32 direct host: linux/amd64 kernel=x86_64 CPUsha=${hash} mapsha=${hash}\n`;
+const avx = 'actual guest CPUID/XCR0 preflight: AVX=1 AVX2=0 AVX512F=0\n';
+const image = `native oracle static IA32 ELF bytes=4096 sha256=${imageHash}\n`;
+const direct = args => `IA32 direct ELF bytes=4096 sha256=${imageHash} argv=${args}\n`;
+const sdk = args => `actual executable=/sdk/bin/go sha256=${hash} argv=${args}\n`;
+const executable = (filename, args) => `actual executable=/tmp/owned/${filename} sha256=${imageHash} argv=${args}\n`;
+const originalArgs = '["-test.run=^TestOriginal$" "-test.count=1" "-test.v"]';
+const compileArgs = '["test" "-p=1" "-vet=off" "-c" "-o" "/tmp/owned/original.test" "."]';
+const evidence = arch => `scalar estimates native arch=${arch} live=20 dead=4 whole32-outcomes=30720 fault-processes=40; SSE/AVX actual scalar opcodes, no AVX512/Z transport\n`;
+const originalEvidence = 'actual original Go scalar estimates: 20 aliases × 24 bit patterns × 64 MXCSR profiles = 30720 whole32/FLAGS/DF/MXCSR/canary outcomes; independent scalar references, no AVX512/Z execution claim\n';
+const inventory = roots.join('\n') + '\nok\tgithub.com/xgo-dev/plan9asm\n';
+const event = (Action, Test, Output) => ({Action, Package: 'github.com/xgo-dev/plan9asm',
+  ...(Test ? {Test} : {}), ...(Output !== undefined ? {Output} : {})});
+const serialize = events => events.map(value => JSON.stringify(value)).join('\n');
+
+function completeEvents() {
+  const events = [event('start')];
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    events.push(event('run', root), event('output', root, host + avx));
+    for (const axis of axes) {
+      const child = root + '/' + axis;
+      events.push(event('run', child));
+      if (axis === 'OriginalGo') {
+        events.push(event('output', child, sdk('["version"]') + sdk(compileArgs)));
+        if (arch === '386') events.push(event('output', child,
+          image + executable('original.test', originalArgs) + direct(originalArgs)));
+        events.push(event('output', child, originalEvidence));
+      } else {
+        if (arch === '386') events.push(event('output', child,
+          image + executable('comparison', '[]') + direct('[]') + image));
+        events.push(event('output', child, evidence(arch)));
+      }
+      events.push(event('pass', child));
+    }
+    events.push(event('output', root, host), event('pass', root));
+  }
+  events.push(event('pass'));
+  return events;
+}
+
+function audit(events = completeEvents(), discovered = inventory) {
+  const auditor = '.github/scripts/audit-scalar-reciprocal-native.cjs';
+  assert.ok(fs.existsSync(auditor), 'scalar estimates lack an independent strict native completion auditor');
+  return require('./audit-scalar-reciprocal-native.cjs').auditScalarReciprocalNative(discovered, serialize(events));
+}
+
+test('scalar estimate native ownership requires two roots, three optimized native axes and actual Go', () => {
+  assert.deepEqual(audit(), {roots: 2, children: 8, passed: 10, skipped: 0, incomplete: 0,
+    nativeHosts: 4, avxPreflights: 2, sdkBuilds: 2, staticIA32Images: 7, directIA32Executions: 4});
+});
+
+test('scalar estimates reject every missing duplicate skipped failed or incomplete execution terminal', () => {
+  audit(); // A failing/missing auditor must not make the negative controls pass.
+  for (const name of roots.flatMap(root => [root, ...axes.map(axis => root + '/' + axis)])) {
+    for (const Action of ['fail', 'skip']) {
+      assert.throws(() => audit(completeEvents().map(value => value.Action === 'pass' && value.Test === name
+        ? {...value, Action} : value)), name + Action);
+    }
+    for (const Action of ['run', 'pass']) {
+      const events = completeEvents();
+      const at = events.findIndex(value => value.Test === name && value.Action === Action);
+      assert.throws(() => audit(events.filter((_, index) => index !== at)), name + ' missing ' + Action);
+      events.splice(at, 0, events[at]);
+      assert.throws(() => audit(events), name + ' duplicate ' + Action);
+    }
+  }
+  for (const changed of ['', inventory + roots[0] + '\n', inventory.replace(roots[0] + '\n', '')]) {
+    assert.throws(() => audit(completeEvents(), changed));
+  }
+  for (const events of [completeEvents().slice(1), completeEvents().slice(0, -1),
+    [...completeEvents(), event('pass')], [event('start'), ...completeEvents()],
+    completeEvents().map(value => ({...value, Package: 'foreign/package'}))]) assert.throws(() => audit(events));
+});
+
+test('scalar estimates require real host brackets AVX OS permission SDK identities and direct static IA32', () => {
+  audit();
+  for (const root of roots) {
+    const arch = root.endsWith('386') ? '386' : 'amd64';
+    for (const needle of [host, avx]) {
+      for (const replacement of ['', needle + needle, needle.replace('linux/amd64', 'linux/arm64'),
+        needle.replace('AVX=1', 'AVX=0'), needle.replace(hash, 'invalid')]) {
+        if (replacement === needle) continue;
+        assert.throws(() => audit(completeEvents().map(value => value.Test === root && value.Output
+          ? {...value, Output: value.Output.replace(needle, replacement)} : value)));
+      }
+    }
+    for (const axis of axes) {
+      const child = root + '/' + axis;
+      const receipt = axis === 'OriginalGo' ? originalEvidence : evidence(arch);
+      for (const replacement of ['', receipt + receipt, receipt.replaceAll('30720', '30719')]) {
+        assert.throws(() => audit(completeEvents().map(value => value.Test === child && value.Output
+          ? {...value, Output: value.Output.replace(receipt, replacement)} : value)));
+      }
+      const required = [];
+      if (axis === 'OriginalGo') required.push(sdk('["version"]'), sdk(compileArgs));
+      if (arch === '386') required.push(image, direct(axis === 'OriginalGo' ? originalArgs : '[]'));
+      for (const needle of required) {
+        assert.throws(() => audit(completeEvents().map(value => value.Test === child && value.Output
+          ? {...value, Output: value.Output.replace(needle, '')} : value)));
+      }
+    }
+  }
+  const child = roots[1] + '/OriginalGo';
+  for (const needle of [sdk(compileArgs), direct(originalArgs)]) {
+    assert.throws(() => audit(completeEvents().map(value => value.Test === child && value.Output
+      ? {...value, Output: value.Output.replace(needle, needle.replace(needle.includes('actual executable') ? hash : imageHash, 'c'.repeat(64)))} : value)));
+  }
+  const events = completeEvents();
+  const original = events.filter(value => value.Test === roots[0] + '/OriginalGo');
+  const earlier = events.filter(value => value.Test !== roots[0] + '/OriginalGo');
+  const at = earlier.findIndex(value => value.Test === roots[0] + '/' + axes[2] && value.Action === 'pass');
+  earlier.splice(at, 0, ...original);
+  assert.throws(() => audit(earlier), 'actual Go cannot precede a finished native axis');
+});
+
+test('scalar estimate executable receipts cannot replace or escape original Go ownership', () => {
+  audit();
+  for (const axis of axes) {
+    const child = roots[1] + '/' + axis;
+    const original = axis === 'OriginalGo';
+    const receipt = executable(original ? 'original.test' : 'comparison', original ? originalArgs : '[]');
+    for (const replacement of ['', receipt + receipt,
+      receipt.replace(imageHash, hash), receipt.replace('sha256=' + imageHash, 'sha256=invalid'),
+      receipt.replace(original ? 'original.test' : 'comparison', 'unrelated'),
+      receipt.replace(original ? originalArgs : '[]', '["unobserved"]'), sdk(compileArgs)]) {
+      assert.throws(() => audit(completeEvents().map(value => value.Test === child && value.Output
+        ? {...value, Output: value.Output.replace(receipt, replacement)} : value)), axis + '/foreign or absent executable');
+    }
+    const events = completeEvents();
+    const at = events.findIndex(value => value.Test === child && value.Output?.includes(receipt));
+    events[at].Output = events[at].Output.replace(receipt, '');
+    const first = events.findIndex(value => value.Test === child && value.Action === 'output');
+    events.splice(first, 0, event('output', child, receipt));
+    assert.throws(() => audit(events), axis + '/execution before inspected image');
+  }
+  const events = completeEvents();
+  const child = roots[1] + '/OriginalGo';
+  const at = events.findIndex(value => value.Test === child && value.Output?.includes(sdk(compileArgs)));
+  events[at].Output = events[at].Output.replace(sdk(compileArgs), '');
+  const pipeline = events.findIndex(value => value.Test === roots[1] + '/backend_O0' && value.Action === 'output');
+  events.splice(pipeline, 0, event('output', roots[1] + '/backend_O0', sdk(compileArgs)));
+  assert.throws(() => audit(events), 'pipeline cannot own original Go compilation');
+});
diff --git a/.github/scripts/priority-stdlib-corpus-mode.test.cjs b/.github/scripts/priority-stdlib-corpus-mode.test.cjs
new file mode 100644
index 000000000..2461d7120
--- /dev/null
+++ b/.github/scripts/priority-stdlib-corpus-mode.test.cjs
@@ -0,0 +1,354 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const test = require('node:test');
+
+// These executable protocol fixtures never invoke Go or LLVM. The real Python
+// validator and actual checked-out shell script still decide scan failures.
+const goFixture = [
+  '#!/usr/bin/env bash', 'set -euo pipefail',
+  'if [[ "$1" == env ]]; then printenv "$2"; exit; fi',
+  'if [[ "$1" == version ]]; then printf "protocol Go version only\\n"; exit; fi',
+  '[[ "$1" == build ]] || exit 91',
+  'while (( $# > 0 )); do',
+  '  if [[ "$1" == -o ]]; then',
+  '    case "$2" in',
+  '      *plan9asmscan|*plan9asmscan.exe) role=scanner; source=$CORPUS_PROTOCOL_SCANNER ;;',
+  '      *) role=cli; source=$CORPUS_PROTOCOL_TRANSLATOR ;;',
+  '    esac',
+  '    printf "build|%s\\n" "$role" >> "$CORPUS_PROTOCOL_TRACE"',
+  '    [[ "$CORPUS_PROTOCOL_MODE" != "build-$role" ]] || exit 42',
+  '    cp "$source" "$2"', '    exit', '  fi', '  shift', 'done', 'exit 92',
+].join('\n') + '\n';
+
+const scannerFixture = [
+  '#!/usr/bin/env bash', 'set -euo pipefail', 'goos= goarch= output=',
+  'while (( $# > 0 )); do', '  IFS== read -r key value <<< "$1"',
+  '  case "$key" in',
+  '    -goos) goos=$value ;; -goarch) goarch=$value ;;',
+  '    -out) shift; output=$1 ;;', '  esac', '  shift', 'done',
+  'printf "scan|%s/%s|%s|%s|%s|%s|%s\\n" "$goos" "$goarch" "$GO386" "$GOAMD64" "$GOARM" "$GOARM64" "$GOWASM" >> "$CORPUS_PROTOCOL_TRACE"',
+  '[[ "$CORPUS_PROTOCOL_MODE" != scanner-exit ]] || { echo protocol-scanner-failure >&2; exit 43; }',
+  'if [[ "$CORPUS_PROTOCOL_MODE" == malformed ]]; then printf "{broken\\n" > "$output"; exit; fi',
+  "unsupported='[]'; forms='[]'; errors='[]'",
+  'case "$CORPUS_PROTOCOL_MODE" in',
+  "  op) unsupported='[{\"op\":\"PROTOCOL_BAD\",\"count\":1}]' ;;",
+  "  form) forms='[{\"form\":\"PROTOCOL_BAD register\",\"errors\":[\"protocol form rejection\"]}]' ;;",
+  "  parse) errors='[{\"File\":\"protocol.s\",\"Err\":\"protocol parse rejection\"}]' ;;",
+  'esac',
+  'printf \'{"std_pkgs_with_sfile":1,"asm_files":1,"unsupported":%s,"unsupported_by_form":%s,"parse_errs":%s}\\n\' "$unsupported" "$forms" "$errors" > "$output"',
+].join('\n') + '\n';
+
+const translatorFixture = [
+  '#!/usr/bin/env bash', 'set -euo pipefail',
+  '[[ "$1" == transpile && "$GOTOOLCHAIN" == local ]] || exit 93', 'shift',
+  'goos= goarch= output= meta=',
+  'while (( $# > 0 )); do',
+  '  IFS== read -r key value <<< "$1"',
+  '  case "$key" in',
+  '    -goos) goos=$value ;; -goarch) goarch=$value ;;',
+  '    -dir) shift; output=$1 ;; -meta) shift; meta=$1 ;;',
+  '    std) ;; *) exit 94 ;;', '  esac', '  shift', 'done',
+  'printf "transpile|%s/%s|%s|%s|%s|%s|%s\\n" "$goos" "$goarch" "$GO386" "$GOAMD64" "$GOARM" "$GOARM64" "$GOWASM" >> "$CORPUS_PROTOCOL_TRACE"',
+  '[[ "$CORPUS_PROTOCOL_MODE" != transpile ]] || { echo protocol-transpile-failure >&2; exit 44; }',
+  'mkdir -p "$output"',
+  '[[ "$CORPUS_PROTOCOL_MODE" != empty ]] || exit 0',
+  'printf "; protocol fixture, not LLVM compilation evidence\\n" > "$output/protocol.ll"',
+  'if [[ "$goarch" == wasm ]]; then printf "; second protocol input, not LLVM evidence\\n" > "$output/second.ll"; fi',
+  'printf "{}\\n" > "$meta"',
+].join('\n') + '\n';
+
+const llvmFixture = [
+  '#!/usr/bin/env bash', 'set -euo pipefail',
+  'if [[ "$1" == --version ]]; then printf "LLVM version 22.1.8\\n"; exit; fi',
+  'triple= output= input= object=false',
+  'while (( $# > 0 )); do', '  IFS== read -r key value <<< "$1"',
+  '  case "$key" in',
+  '    -mtriple) triple=$value ;; -filetype) [[ "$value" == obj ]] || exit 95; object=true ;;',
+  '    -o) shift; output=$1 ;; *.ll) input=$1 ;;', '  esac', '  shift', 'done',
+  '[[ "$object" == true && -n "$triple" && -n "$output" && -f "$input" ]] || exit 96',
+  'name=$(basename "$input")',
+  'printf "object|%s|%s\\n" "$triple" "$name" >> "$CORPUS_PROTOCOL_TRACE"',
+  '[[ "$CORPUS_PROTOCOL_MODE" != object ]] || { echo protocol-object-failure >&2; exit 45; }',
+  'if [[ "$CORPUS_PROTOCOL_MODE" == second-object && "$name" == second.ll ]]; then echo protocol-second-object-failure >&2; exit 47; fi',
+  'printf "protocol fixture only, not a real object\\n" > "$output"',
+].join('\n') + '\n';
+
+const llvmConfigFixture = [
+  '#!/usr/bin/env bash', 'set -euo pipefail',
+  'case "$1" in',
+  '  --version) if [[ "$CORPUS_PROTOCOL_MODE" == wrong-llvm ]]; then echo 23.0.0; else echo 22.1.8; fi ;;',
+  '  --bindir) if [[ "$CORPUS_PROTOCOL_MODE" == missing-llvm ]]; then echo "$CORPUS_PROTOCOL_BIN/missing"; else echo "$CORPUS_PROTOCOL_BIN"; fi ;;',
+  '  *) exit 97 ;;', 'esac',
+].join('\n') + '\n';
+
+function observeNativeBashExecutable() {
+  const command = process.platform === 'win32'
+    ? 'if [[ "$BASH" == *.exe ]]; then cygpath -w -- "$BASH"; else cygpath -w -- "$BASH.exe"; fi'
+    : 'printf "%s\\n" "$BASH"';
+  // Resolve only in the original native environment. Windows Node cannot
+  // resolve a command name through a child's colon-delimited MSYS PATH.
+  const result = spawnSync('bash', ['-c', command], {env: process.env,
+    encoding: 'utf8', timeout: 5000});
+  assert.ifError(result.error);
+  assert.equal(result.status, 0, result.stderr);
+  assert.equal(result.stderr, '');
+  const line = result.stdout.match(/^([^\r\n\0]+)\r?\n$/);
+  assert.ok(line, 'one complete native Bash executable path');
+  const executable = line[1];
+  assert.equal(executable, executable.trim(), 'an unpadded executable path');
+  assert.ok(path.isAbsolute(executable), 'native absolute Bash executable');
+  assert.ok(fs.statSync(executable).isFile(), 'Bash executable must be a regular file');
+  fs.accessSync(executable, fs.constants.X_OK);
+  return executable;
+}
+
+const bashExecutable = observeNativeBashExecutable();
+
+function runCorpusShell(args, options) {
+  return spawnSync(bashExecutable, args, options);
+}
+
+function shellPaths(names) {
+  if (process.platform !== 'win32') return names;
+  const result = runCorpusShell(['-c',
+    'for name in "$@"; do cygpath -u -- "$name" || exit; done', 'corpus-paths', ...names],
+  {encoding: 'utf8', timeout: 5000});
+  assert.ifError(result.error);
+  assert.equal(result.status, 0, result.stderr);
+  const converted = result.stdout.trimEnd().split(/\r?\n/);
+  assert.equal(converted.length, names.length);
+  return converted;
+}
+
+function fixture(t, mode = 'success', targets = '') {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'stdlib-corpus-protocol-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  const bin = path.join(directory, 'bin');
+  const scripts = path.join(directory, 'scripts');
+  fs.mkdirSync(bin);
+  fs.mkdirSync(scripts);
+  for (const name of ['check-stdlib-corpus.sh', 'llvm22.sh']) {
+    fs.copyFileSync(path.join(__dirname, '../../scripts', name), path.join(scripts, name));
+  }
+  for (const [name, source] of Object.entries({go: goFixture, scanner: scannerFixture,
+    translator: translatorFixture, llc: llvmFixture, 'llvm-config': llvmConfigFixture})) {
+    fs.writeFileSync(path.join(bin, name), source, {mode: 0o700});
+  }
+  if (mode === 'broken-python') {
+    for (const name of ['python', 'python3']) {
+      fs.writeFileSync(path.join(bin, name), '#!/usr/bin/env bash\necho protocol-python-failure >&2\nexit 46\n', {mode: 0o700});
+    }
+  }
+  const trace = path.join(directory, 'trace');
+  const [shellBin, shellScript, scanner, translator, shellTrace, config] = shellPaths([
+    bin, path.join(scripts, 'check-stdlib-corpus.sh'), path.join(bin, 'scanner'),
+    path.join(bin, 'translator'), trace, path.join(bin, 'llvm-config'),
+  ]);
+  const shellPath = runCorpusShell(['-c', 'printf "%s" "$PATH"'],
+    {encoding: 'utf8', timeout: 5000});
+  assert.ifError(shellPath.error);
+  assert.equal(shellPath.status, 0, shellPath.stderr);
+  const environment = {...process.env,
+    PATH: shellBin + ':' + shellPath.stdout, LLVM_CONFIG: config,
+    PLAN9ASM_CMD: mode === 'missing-cli' ? shellBin + '/absent' : '',
+    PLAN9ASM_CORPUS_TARGETS: targets, PLAN9ASM_CORPUS_INCLUDE_WINDOWS: '1',
+    CORPUS_PROTOCOL_BIN: shellBin, CORPUS_PROTOCOL_SCANNER: scanner,
+    CORPUS_PROTOCOL_TRANSLATOR: translator, CORPUS_PROTOCOL_TRACE: shellTrace,
+    CORPUS_PROTOCOL_MODE: mode,
+  };
+  return {
+    run(args = []) {
+      const result = runCorpusShell([shellScript, ...args], {cwd: directory,
+        env: environment, encoding: 'utf8', timeout: 15000, maxBuffer: 1024 * 1024});
+      assert.ifError(result.error);
+      assert.equal(result.signal, null, result.stderr);
+      assert.equal(typeof result.status, 'number');
+      const rows = fs.existsSync(trace) ? fs.readFileSync(trace, 'utf8').trimEnd().split('\n') : [];
+      return {...result, rows, output: result.stdout + result.stderr};
+    },
+  };
+}
+
+test('corpus Bash transport uses the observed executable even when child PATH has no Bash', t => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'corpus-shell-transport-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  const command = process.platform === 'win32'
+    ? 'if [[ "$BASH" == *.exe ]]; then cygpath -w -- "$BASH"; else cygpath -w -- "$BASH.exe"; fi'
+    : 'printf "%s\\n" "$BASH"';
+  // Independent prior uses the original native PATH, never the child's POSIX
+  // search list. This is process transport, not a compiler/native-ISA oracle.
+  const observed = spawnSync('bash', ['-c', command], {env: process.env,
+    encoding: 'utf8', timeout: 5000});
+  assert.ifError(observed.error);
+  assert.equal(observed.status, 0, observed.stderr);
+  const executable = observed.stdout.replace(/\r?\n$/, '');
+  assert.ok(path.isAbsolute(executable));
+  assert.doesNotMatch(executable, /[\r\n\0]/);
+  assert.ok(fs.statSync(executable).isFile());
+  fs.accessSync(executable, fs.constants.X_OK);
+
+  const options = {env: {...process.env, PATH: directory}, encoding: 'utf8', timeout: 5000};
+  const args = ['-c', 'printf "CORPUS_SHELL_TRANSPORT_PASS\\n"'];
+  const named = spawnSync('bash', args, options);
+  assert.equal(named.error && named.error.code, 'ENOENT', 'negative must fail actual command lookup');
+  const absolute = spawnSync(executable, args, options);
+  assert.ifError(absolute.error);
+  assert.equal(absolute.status, 0, absolute.stderr);
+  assert.equal(absolute.stdout, 'CORPUS_SHELL_TRANSPORT_PASS\n');
+
+  const actual = runCorpusShell(args, options);
+  assert.ifError(actual.error);
+  assert.equal(actual.status, 0, actual.stderr);
+  assert.equal(actual.stdout, absolute.stdout);
+});
+
+test('corpus rewritten-PATH consumers never resolve Bash by name', () => {
+  for (const consumer of [runCorpusShell, shellPaths, fixture]) {
+    assert.doesNotMatch(consumer.toString(), /spawnSync\(['"]bash['"]/,
+      consumer.name + ': only the original native-environment bootstrap may use a name');
+  }
+});
+
+function expectedScans() {
+  const rows = [];
+  const add = (target, role = '', value = '') => {
+    const settings = ['GO386', 'GOAMD64', 'GOARM', 'GOARM64', 'GOWASM'].map(name =>
+      name === role ? value : '');
+    rows.push(['scan', target, ...settings].join('|'));
+  };
+  for (const value of ['sse2', 'softfloat']) add('linux/386', 'GO386', value);
+  for (const value of ['v1', 'v2', 'v3', 'v4']) add('linux/amd64', 'GOAMD64', value);
+  for (const value of ['5', '5,hardfloat', '6', '6,softfloat', '7', '7,softfloat']) add('linux/arm', 'GOARM', value);
+  for (let index = 0; index < 10; index++) add('linux/arm64', 'GOARM64', 'v8.' + index);
+  for (let index = 0; index < 6; index++) add('linux/arm64', 'GOARM64', 'v9.' + index);
+  for (const value of ['v8.0,lse', 'v8.0,crypto', 'v8.0,lse,crypto']) add('linux/arm64', 'GOARM64', value);
+  add('darwin/amd64');
+  add('darwin/arm64');
+  for (const target of ['js/wasm', 'wasip1/wasm']) {
+    add(target);
+    for (const value of ['satconv', 'signext', 'satconv,signext']) add(target, 'GOWASM', value);
+  }
+  for (const target of ['windows/386', 'windows/amd64', 'windows/arm64']) add(target);
+  assert.equal(rows.length, 44, 'all original default profiles');
+  assert.equal(new Set(rows).size, 44, 'each original profile exactly once');
+  return rows;
+}
+
+function wasmScanRows() {
+  const rows = expectedScans().filter(row => /^scan\|(?:js|wasip1)\/wasm\|/.test(row));
+  assert.equal(rows.length, 8, 'complete JS/WASI plus all GOWASM profiles');
+  return rows;
+}
+
+function wasmObjectRows(scan) {
+  const triple = scan.split('|')[1] === 'js/wasm' ? 'wasm32-unknown-unknown' : 'wasm32-unknown-wasi';
+  return ['protocol.ll', 'second.ll'].map(name => 'object|' + triple + '|' + name);
+}
+
+test('instruction-only corpus scans all 44 profiles and compiles every full contextual WASM source', t => {
+  const result = fixture(t).run(['--instructions-only']);
+  assert.equal(result.status, 0, result.output);
+  assert.deepEqual(result.rows.filter(row => row.startsWith('scan|')), expectedScans());
+  const wasm = new Set(wasmScanRows());
+  const expected = ['build|scanner', 'build|cli'];
+  for (const scan of expectedScans()) {
+    expected.push(scan);
+    if (wasm.has(scan)) expected.push(scan.replace('scan|', 'transpile|'), ...wasmObjectRows(scan));
+  }
+  assert.deepEqual(result.rows, expected,
+    'WASM needs whole typed-stack source and every LLVM object; other architectures remain scan-only');
+});
+
+test('default corpus retains all 44 whole-source and object compilation protocols', t => {
+  const result = fixture(t).run();
+  assert.equal(result.status, 0, result.output);
+  assert.deepEqual(result.rows.filter(row => row.startsWith('scan|')), expectedScans());
+  const translations = result.rows.filter(row => row.startsWith('transpile|'));
+  assert.deepEqual(translations, expectedScans().map(row => row.replace('scan|', 'transpile|')));
+  assert.equal(result.rows.filter(row => row.startsWith('object|')).length, 52,
+    'all 44 targets plus the second generated file in each of eight WASM profiles');
+});
+
+test('both corpus modes keep scan and required-tool failures fatal', async t => {
+  const failures = {
+    op: /unsupported ops remain: PROTOCOL_BAD/,
+    form: /unsupported operand forms remain: PROTOCOL_BAD/,
+    parse: /parse errors remain: protocol.s: protocol parse rejection/,
+    malformed: /JSONDecodeError/,
+    'scanner-exit': /protocol-scanner-failure/,
+    'build-scanner': /build/,
+    'build-cli': /build/,
+    'wrong-llvm': /LLVM_CONFIG must select LLVM 22/,
+    'missing-llvm': /LLVM 22 llc not found/,
+    'missing-cli': /PLAN9ASM_CMD is not executable/,
+    'broken-python': /protocol-python-failure/,
+  };
+  for (const args of [[], ['--instructions-only']]) {
+    for (const [mode, diagnostic] of Object.entries(failures)) {
+      await t.test((args.length ? 'instructions/' : 'default/') + mode, t => {
+        const result = fixture(t, mode, 'windows/arm64').run(args);
+        assert.notEqual(result.status, 0, result.output);
+        if (mode.startsWith('build-')) {
+          assert.ok(result.rows.includes('build|' + mode.slice('build-'.length)), 'actual failed tool build');
+        } else {
+          assert.match(result.output, diagnostic);
+        }
+      });
+    }
+  }
+});
+
+test('instruction-only mode never starts a failing whole-runtime transpiler', t => {
+  const result = fixture(t, 'transpile', 'windows/arm64').run(['--instructions-only']);
+  assert.equal(result.status, 0, result.output);
+  assert.deepEqual(result.rows.filter(row => row.startsWith('scan|')), ['scan|windows/arm64|||||']);
+  assert.deepEqual(result.rows.filter(row => /^(transpile|object)\|/.test(row)), []);
+});
+
+test('instruction-only mode cannot hide any contextual WASM source or object failure', async t => {
+  for (const scan of wasmScanRows()) {
+    const fields = scan.split('|');
+    const target = fields[1] + (fields[6] ? '/' + fields[6].replaceAll(',', '+') : '');
+    for (const mode of ['transpile', 'empty', 'object', 'second-object']) {
+      await t.test(target + '/' + mode, t => {
+        const result = fixture(t, mode, target).run(['--instructions-only']);
+        assert.notEqual(result.status, 0, 'WASM Context was accepted without its complete source/object companion');
+        assert.match(result.output, mode === 'empty' ? /no \.ll files generated/ :
+          new RegExp('protocol-' + mode + '-failure'));
+        assert.deepEqual(result.rows.filter(row => row.startsWith('scan|')), [scan]);
+        assert.deepEqual(result.rows.filter(row => row.startsWith('transpile|')),
+          [scan.replace('scan|', 'transpile|')]);
+        if (mode === 'second-object') {
+          assert.deepEqual(result.rows.filter(row => row.startsWith('object|')), wasmObjectRows(scan));
+        }
+      });
+    }
+  }
+});
+
+test('default corpus retains transpile, empty-output and object failures', async t => {
+  for (const mode of ['transpile', 'empty', 'object']) {
+    await t.test(mode, t => {
+      const result = fixture(t, mode, 'windows/arm64').run();
+      assert.notEqual(result.status, 0, result.output);
+      assert.match(result.output, mode === 'empty' ? /no \.ll files generated/ :
+        new RegExp('protocol-' + mode + '-failure'));
+    });
+  }
+});
+
+test('corpus mode arguments reject unknown, duplicate and extra operands', async t => {
+  for (const args of [['--unknown'], ['--instructions-only', '--instructions-only'],
+    ['--instructions-only', 'std'], ['--instructions-only=true'], ['std']]) {
+    await t.test(args.join(' '), t => {
+      const result = fixture(t, 'success', 'windows/arm64').run(args);
+      assert.notEqual(result.status, 0, 'unrecognized mode silently ran the default protocol');
+      assert.deepEqual(result.rows, [], 'invalid arguments must fail before any tool invocation');
+    });
+  }
+});
diff --git a/.github/scripts/priority-ubuntu-llvm-install.test.cjs b/.github/scripts/priority-ubuntu-llvm-install.test.cjs
new file mode 100644
index 000000000..8568ef2e8
--- /dev/null
+++ b/.github/scripts/priority-ubuntu-llvm-install.test.cjs
@@ -0,0 +1,304 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {spawnSync} = require('node:child_process');
+const {test} = require('node:test');
+
+const root = path.join(__dirname, '../..');
+const installer = path.join(root, 'scripts/install-ci-llvm22-ubuntu.sh');
+const configure = path.join(root, 'scripts/configure-ci-ubuntu-mirrors.py');
+const badMirrors = 'https:/us.archive.ubuntu.com/ubuntu\n' +
+  'https://mirrors.edge.kernel.org/ubuntu\n';
+const sources = 'Types: deb\nURIs: mirror+file:/etc/apt/apt-mirrors.txt\n' +
+  'Suites: noble noble-updates noble-backports\n' +
+  'Components: main universe restricted multiverse\n' +
+  'Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg\n';
+
+function fixture(t, mirrors = true) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-ubuntu-apt-'));
+  t.after(() => fs.rmSync(directory, {recursive: true, force: true}));
+  if (mirrors) {
+    for (const file of ['apt-mirrors.txt', 'apt-mirrors-security.txt']) {
+      fs.writeFileSync(path.join(directory, file), badMirrors);
+    }
+  }
+  fs.writeFileSync(path.join(directory, 'ubuntu.sources'), sources);
+  fs.writeFileSync(path.join(directory, 'custom-mirrors.txt'), 'https://apt.llvm.org/noble/\n');
+  return directory;
+}
+
+function runConfigure(directory, architecture) {
+  const result = spawnSync('python3', [configure, directory, architecture], {
+    encoding: 'utf8', timeout: 5000,
+    env: {...process.env, PYTHONDONTWRITEBYTECODE: '1'},
+  });
+  assert.ifError(result.error);
+  assert.equal(result.status, 0, result.stderr);
+  return result.stdout;
+}
+
+function assertUnchangedSources(directory) {
+  assert.equal(fs.readFileSync(path.join(directory, 'ubuntu.sources'), 'utf8'), sources);
+  assert.equal(fs.readFileSync(path.join(directory, 'custom-mirrors.txt'), 'utf8'),
+    'https://apt.llvm.org/noble/\n');
+}
+
+test('Ubuntu mirror configuration repairs the actual malformed runner lists only', t => {
+  for (const [architecture, archive, security] of [
+    ['amd64', 'https://archive.ubuntu.com/ubuntu/', 'https://security.ubuntu.com/ubuntu/'],
+    ['i386', 'https://archive.ubuntu.com/ubuntu/', 'https://security.ubuntu.com/ubuntu/'],
+    ['arm64', 'https://ports.ubuntu.com/ubuntu-ports/', 'https://ports.ubuntu.com/ubuntu-ports/'],
+    ['armhf', 'https://ports.ubuntu.com/ubuntu-ports/', 'https://ports.ubuntu.com/ubuntu-ports/'],
+  ]) {
+    const directory = fixture(t);
+    assert.equal(runConfigure(directory, architecture), archive + '\n');
+    assert.equal(runConfigure(directory, architecture), archive + '\n');
+    assert.equal(fs.readFileSync(path.join(directory, 'apt-mirrors.txt'), 'utf8'), archive + '\n');
+    assert.equal(fs.readFileSync(path.join(directory, 'apt-mirrors-security.txt'), 'utf8'), security + '\n');
+    assertUnchangedSources(directory);
+  }
+});
+
+test('Ubuntu direct sources do not acquire new mirror lists or unrelated configuration', t => {
+  const directory = fixture(t, false);
+  runConfigure(directory, 'amd64');
+  assert.deepEqual(fs.readdirSync(directory).sort(), ['custom-mirrors.txt', 'ubuntu.sources']);
+  assertUnchangedSources(directory);
+});
+
+// Execute the actual Bash installer. Every privileged/network/package command
+// is intercepted; only the real narrow helper runs against this test's directory.
+function runInstaller(t, options = {}) {
+  const directory = fixture(t);
+  const environment = path.join(directory, 'environment');
+  const script = `
+updates=0
+installs=0
+IFS=, read -r -a update_statuses <<< "$MOCK_UPDATES"
+IFS=, read -r -a install_statuses <<< "$MOCK_INSTALLS"
+dpkg() {
+  case "$1" in
+    -s) return "$MOCK_INSTALLED" ;;
+    --print-architecture)
+      printf 'DPKG_ARCH\\n' >&2
+      if [[ "$MOCK_ARCH_EXIT" != 0 ]]; then return "$MOCK_ARCH_EXIT"; fi
+      printf '%s\\n' "$MOCK_ARCH" ;;
+    *) return 99 ;;
+  esac
+}
+lsb_release() { test "$1" = -cs && printf 'noble\\n'; }
+curl() {
+  printf 'CURL'; printf ' <%s>' "$@"; printf '\\n' >&2
+  printf 'test signing key\\n'
+}
+tee() {
+  case "$1" in
+    /etc/apt/trusted.gpg.d/llvm-snapshot.asc|/etc/apt/sources.list.d/llvm.list|/etc/apt/sources.list.d/plan9asm-ci-fallback.list)
+      command tee "$MOCK_APT/$(basename "$1")" ;;
+    *) return 99 ;;
+  esac
+}
+env() {
+  test "$1" = DEBIAN_FRONTEND=noninteractive || return 99
+  shift
+  "$@"
+}
+timeout() {
+  test "$1" = -k && test "$2" = 10s || return 99
+  case "$3" in 2m|4m) ;; *) return 99 ;; esac
+  printf 'TIMEOUT %s\\n' "$3"
+  shift 3
+  "$@"
+}
+apt-get() {
+  printf 'APT_BEGIN\\n' >&2
+  printf 'APT'; printf ' <%s>' "$@"; printf '\\n'
+  for arg in "$@"; do
+    case "$arg" in
+      update)
+        updates=$((updates + 1))
+        return "\${update_statuses[updates - 1]:-99}" ;;
+      install)
+        installs=$((installs + 1))
+        return "\${install_statuses[installs - 1]:-99}" ;;
+    esac
+  done
+  return 99
+}
+sudo() {
+  case "$1" in
+    tee|timeout) "$@" ;;
+    python3)
+      test "$#" = 4 && test "$3" = /etc/apt || return 99
+      printf 'CONFIGURE %s\\n' "$4" >&2
+      if [[ "$MOCK_CONFIG_EXIT" != 0 ]]; then return "$MOCK_CONFIG_EXIT"; fi
+      if [[ "$MOCK_CONFIG_OUTPUT" != __actual_helper__ ]]; then
+        printf '%s' "$MOCK_CONFIG_OUTPUT"
+      else
+        command python3 "$2" "$MOCK_APT" "$4"
+      fi ;;
+    *) return 99 ;;
+  esac
+}
+llvm-config-22() { printf '%s\\n' "$MOCK_LLVM_VERSION"; }
+clang-22() { return 0; }
+llc-22() { return 0; }
+source "$1" gcc-i686-linux-gnu libc6-dev-i386-cross
+`;
+  const result = spawnSync('bash', ['--noprofile', '--norc', '-c', script, 'installer-test', installer], {
+    encoding: 'utf8', timeout: 5000,
+    env: {
+      ...process.env, PYTHONDONTWRITEBYTECODE: '1',
+      MOCK_APT: directory, MOCK_ARCH: options.architecture || 'amd64',
+      MOCK_ARCH_EXIT: String(options.architectureExit || 0),
+      MOCK_INSTALLED: options.installed ? '0' : '1',
+      MOCK_UPDATES: (options.updates || [0]).join(','),
+      MOCK_INSTALLS: (options.installs || [0]).join(','),
+      MOCK_CONFIG_EXIT: String(options.configurationExit || 0),
+      MOCK_CONFIG_OUTPUT: options.configurationOutput === undefined
+        ? '__actual_helper__' : options.configurationOutput,
+      MOCK_LLVM_VERSION: options.version || '22.1.8', GITHUB_ENV: environment,
+    },
+  });
+  assert.ifError(result.error);
+  return {...result, directory, environment: fs.existsSync(environment)
+    ? fs.readFileSync(environment, 'utf8') : ''};
+}
+
+test('actual Ubuntu installer configures mirrors before strict IPv4 update and install', t => {
+  const result = runInstaller(t);
+  assert.equal(result.status, 0, result.stderr);
+  assert.ok(result.stderr.indexOf('CONFIGURE amd64\n') >= 0, result.stderr);
+  assert.ok(result.stderr.indexOf('CONFIGURE amd64\n') < result.stderr.indexOf('APT_BEGIN\n'), result.stderr);
+  for (const command of result.stdout.split('\n').filter(line => line.startsWith('APT '))) {
+    for (const option of ['Acquire::ForceIPv4=true', 'APT::Update::Error-Mode=any',
+      'Acquire::Retries=2', 'Acquire::http::Timeout=30', 'Acquire::https::Timeout=30']) {
+      assert.ok(command.includes('<' + option + '>'), command);
+    }
+  }
+  assert.match(result.stdout, /TIMEOUT 2m\n/);
+  assert.match(result.stdout, /TIMEOUT 4m\n/);
+  assert.match(result.stdout, /<install> <-y> <llvm-22-dev> <clang-22> <libclang-22-dev> <lld-22> <libunwind-22-dev> <libc\+\+-22-dev> <gcc-i686-linux-gnu> <libc6-dev-i386-cross>/);
+  assert.equal(fs.readFileSync(path.join(result.directory, 'apt-mirrors.txt'), 'utf8'),
+    'https://archive.ubuntu.com/ubuntu/\n');
+  assertUnchangedSources(result.directory);
+  assert.match(result.environment, /^PATH=\/usr\/lib\/llvm-22\/bin:/);
+});
+
+test('already installed LLVM packages need no mirror change, update or download', t => {
+  const result = runInstaller(t, {installed: true});
+  assert.equal(result.status, 0, result.stderr);
+  assert.doesNotMatch(result.stdout + result.stderr, /DPKG_ARCH|CONFIGURE|APT |CURL|TIMEOUT/);
+  assert.equal(fs.readFileSync(path.join(result.directory, 'apt-mirrors.txt'), 'utf8'), badMirrors);
+  assertUnchangedSources(result.directory);
+  assert.match(result.environment, /^PATH=\/usr\/lib\/llvm-22\/bin:/);
+});
+
+test('two exhausted updates retain exit 124 without installation or PATH publication', t => {
+  const result = runInstaller(t, {updates: [124, 124]});
+  assert.equal(result.status, 124, result.stderr);
+  const commands = result.stdout.split('\n').filter(line => line.startsWith('APT '));
+  assert.equal(commands.length, 2);
+  assert.ok(commands.every(line => line.endsWith('<update>')));
+  assert.match(commands[1], /<Dir::Etc::sourcelist=\/etc\/apt\/sources.list.d\/plan9asm-ci-fallback.list>/);
+  assert.match(commands[1], /<Dir::Etc::sourceparts=->/);
+  assert.equal(result.environment, '');
+});
+
+test('fallback keeps strict network options, the identical package transaction and original budgets', t => {
+  const result = runInstaller(t, {updates: [0, 0], installs: [100, 0]});
+  assert.equal(result.status, 0, result.stderr);
+  const commands = result.stdout.split('\n').filter(line => line.startsWith('APT '));
+  assert.equal(commands.length, 4);
+  for (const command of commands) {
+    assert.match(command, /<Acquire::ForceIPv4=true>/);
+    assert.match(command, /<APT::Update::Error-Mode=any>/);
+  }
+  assert.equal(commands[1].slice(commands[1].indexOf('<install>')),
+    commands[3].slice(commands[3].indexOf('<install>')));
+  assert.equal((result.stdout.match(/^TIMEOUT 2m$/gm) || []).length, 2);
+  assert.equal((result.stdout.match(/^TIMEOUT 4m$/gm) || []).length, 2);
+});
+
+test('isolated fallback uses the same official Ubuntu architecture route as the repaired mirror lists', async t => {
+  for (const [architecture, archive] of [
+    ['amd64', 'https://archive.ubuntu.com/ubuntu/'],
+    ['i386', 'https://archive.ubuntu.com/ubuntu/'],
+    ['arm64', 'https://ports.ubuntu.com/ubuntu-ports/'],
+    ['armhf', 'https://ports.ubuntu.com/ubuntu-ports/'],
+  ]) {
+    await t.test(architecture, child => {
+      const result = runInstaller(child, {architecture, updates: [124, 0]});
+      assert.equal(result.status, 0, result.stderr);
+      const key = '[signed-by=/usr/share/keyrings/ubuntu-archive-keyring.gpg]';
+      const components = 'main universe restricted multiverse';
+      assert.equal(fs.readFileSync(path.join(result.directory, 'plan9asm-ci-fallback.list'), 'utf8'),
+        `deb ${key} ${archive} noble ${components}\n` +
+        `deb ${key} ${archive} noble-updates ${components}\n` +
+        'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-22 main\n');
+      assert.equal(fs.readFileSync(path.join(result.directory, 'apt-mirrors.txt'), 'utf8'), archive + '\n');
+      const commands = result.stdout.split('\n').filter(line => line.startsWith('APT '));
+      assert.equal(commands.length, 3);
+      assert.equal((result.stderr.match(/^DPKG_ARCH$/gm) || []).length, 1);
+      assert.ok(commands[0].endsWith('<update>'));
+      assert.ok(commands[1].endsWith('<update>'));
+      assert.ok(commands[2].includes('<install>'));
+      assertUnchangedSources(result.directory);
+    });
+  }
+});
+
+test('failed fallback update cannot fall through to missing-package installation or publish PATH', t => {
+  const result = runInstaller(t, {updates: [124, 100]});
+  assert.equal(result.status, 100, result.stderr);
+  const commands = result.stdout.split('\n').filter(line => line.startsWith('APT '));
+  assert.equal(commands.length, 2);
+  for (const command of commands) {
+    assert.ok(command.endsWith('<update>'));
+    assert.match(command, /<APT::Update::Error-Mode=any>/);
+  }
+  assert.equal(result.environment, '');
+});
+
+test('invalid mirror helper output or helper failure cannot reach APT or publish PATH', async t => {
+  for (const [name, configurationOutput] of [
+    ['empty', ''],
+    ['foreign URL', 'https://example.invalid/ubuntu/\n'],
+    ['diagnostic prefix', 'CONFIGURE amd64\nhttps://archive.ubuntu.com/ubuntu/\n'],
+    ['extra source', 'https://archive.ubuntu.com/ubuntu/\nextra-source\n'],
+  ]) {
+    await t.test(name, child => {
+      const result = runInstaller(child, {configurationOutput});
+      assert.equal(result.status, 1, result.stderr);
+      assert.match(result.stderr, /invalid Ubuntu archive mirror/);
+      assert.doesNotMatch(result.stdout, /APT |TIMEOUT/);
+      assert.equal(result.environment, '');
+    });
+  }
+  await t.test('failure exit', child => {
+    const result = runInstaller(child, {configurationExit: 68});
+    assert.equal(result.status, 68, result.stderr);
+    assert.doesNotMatch(result.stdout, /APT |TIMEOUT/);
+    assert.equal(result.environment, '');
+  });
+});
+
+test('failed architecture query cannot silently select the ports route', t => {
+  const result = runInstaller(t, {architectureExit: 67});
+  assert.equal(result.status, 67, result.stderr);
+  assert.doesNotMatch(result.stdout + result.stderr, /CONFIGURE|APT |TIMEOUT/);
+  assert.equal(result.environment, '');
+});
+
+test('failed package installation and wrong LLVM version cannot publish success', t => {
+  const failed = runInstaller(t, {updates: [0, 0], installs: [100, 101]});
+  assert.equal(failed.status, 101, failed.stderr);
+  assert.equal(failed.environment, '');
+  for (const installed of [false, true]) {
+    const wrong = runInstaller(t, {installed, version: '23.0.0'});
+    assert.equal(wrong.status, 1, wrong.stderr);
+    assert.match(wrong.stderr, /does not select LLVM 22/);
+    assert.equal(wrong.environment, '');
+  }
+});
diff --git a/.github/scripts/priority-unix-root-owner-budget.test.cjs b/.github/scripts/priority-unix-root-owner-budget.test.cjs
new file mode 100644
index 000000000..fad315a83
--- /dev/null
+++ b/.github/scripts/priority-unix-root-owner-budget.test.cjs
@@ -0,0 +1,103 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody, requireJobNeeds} = require('./workflow-needs.cjs');
+
+const workflow = fs.readFileSync(path.join(__dirname, '../workflows/go-ci.yml'), 'utf8');
+const script = fs.readFileSync(path.join(__dirname, '../../scripts/test-module-ci.sh'), 'utf8');
+
+function step(body, title) {
+  const matches = body.split(/(?=^      - )/m).filter(value => value.startsWith(`      - name: ${title}\n`));
+  assert.equal(matches.length, 1, 'one exact step required: ' + title);
+  return matches[0];
+}
+
+function requireOwners(source, name) {
+  const body = jobBody(source, name);
+  const roles = Array.from({length: 16}, (_, index) => 'root-' + index).concat('profile', 'other');
+  const axis = body.match(/^        module-role: \[([^\]]+)\]$/m);
+  assert.ok(axis, name + ': explicit complete scheduling roles');
+  assert.deepEqual(axis[1].split(',').map(value => value.trim()), roles);
+  assert.deepEqual([...body.matchAll(
+    /^          - \{module-role: (root-\d+|profile|other), module-owner: ([012]), root-partition: (-?\d+)\}$/gm,
+  )].map(([, role, owner, part]) => [role, Number(owner), Number(part)]), [
+    ...Array.from({length: 16}, (_, index) => ['root-' + index, 0, index]),
+    ['profile', 1, -1], ['other', 2, -1],
+  ]);
+  assert.match(body, /^    needs: ci_policy$/m);
+  assert.match(body, /^    timeout-minutes: 60$/m);
+  assert.match(body, /^      fail-fast: false$/m);
+  assert.doesNotMatch(body, /^    if:|max-parallel:|continue-on-error:|module-owner: \[/m);
+  const title = name === 'test' ? 'Go test (Ubuntu)' : 'Go test with coverage';
+  assert.ok(step(body, title).includes('run: bash scripts/test-module-ci.sh ' + name +
+    ' execute ${{ matrix.module-owner }} ${{ matrix.root-partition }}\n'));
+}
+
+function requireDownloads(source) {
+  const body = jobBody(source, 'module-completion');
+  requireJobNeeds(source, 'module-completion', ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']);
+  assert.match(body, /^    if: \$\{\{ !cancelled\(\) \}\}$/m);
+  for (let index = 0; index < 32; index++) {
+    const download = step(body, 'Download root part ' + index);
+    assert.ok(download.includes('name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-' + index + '\n'));
+    assert.ok(download.includes('path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-' +
+      String(index).padStart(4, '0') + '\n'));
+    if (index > 0 && index < 16) assert.match(download, /^        if: \$\{\{ !cancelled\(\) \}\}$/m);
+    if (index < 16) assert.doesNotMatch(download, /^        if:.*matrix\.flavor/m);
+    if (index >= 16) assert.match(download, /^        if: \$\{\{ !cancelled\(\) && matrix\.flavor == 'race' \}\}$/m);
+  }
+  assert.doesNotMatch(body, /merge-multiple:|pattern:/);
+}
+
+test('test and coverage retain all roots in sixteen independently budgeted owners', () => {
+  requireOwners(workflow, 'test');
+  requireOwners(workflow, 'coverage');
+});
+
+test('Unix root owners use one two-worker wave without raising any original budget', () => {
+  assert.match(script, /^root_partitions=16$/m);
+  assert.match(script, /^shards=32$/m);
+  assert.match(script, /test\) timeout=45m ;;/);
+  assert.match(script, /coverage\) timeout=45m; flags=\(-coverprofile=coverage-root\.out\) ;;/);
+  assert.match(script, /race\) timeout=60m; flags=\(-race\); root_partitions=32; shards=64 ;;/);
+  assert.equal([...script.matchAll(/-shards=\$shards -workers=2/g)].length, 2);
+  assert.equal([...script.matchAll(/-module-root-partitions=\$root_partitions/g)].length, 2);
+  assert.match(script, /GOMAXPROCS=2/);
+  assert.match(jobBody(workflow, 'race'), /^    timeout-minutes: 75$/m);
+  assert.match(jobBody(workflow, 'module-completion'), /^    timeout-minutes: 30$/m);
+});
+
+test('all flavors require exact root fragments zero through fifteen before complete readback', () => {
+  requireDownloads(workflow);
+});
+
+test('lost or duplicated owners, stale eight-part readback and relaxed budgets are rejected', () => {
+  for (const name of ['test', 'coverage']) {
+    requireOwners(workflow, name);
+    const body = jobBody(workflow, name);
+    for (const [before, after] of [
+      ['root-15,', ''],
+      ['root-partition: 15', 'root-partition: 14'],
+      ['timeout-minutes: 60', 'timeout-minutes: 75'],
+      ['fail-fast: false', 'fail-fast: true'],
+      ['timeout-minutes: 60', 'timeout-minutes: 60\n    continue-on-error: true'],
+    ]) {
+      const changed = body.replace(before, after);
+      assert.notEqual(changed, body);
+      assert.throws(() => requireOwners(workflow.replace(body, () => changed), name));
+    }
+  }
+  requireDownloads(workflow);
+  const complete = jobBody(workflow, 'module-completion');
+  for (const index of [8, 15]) {
+    const original = step(complete, 'Download root part ' + index);
+    assert.throws(() => requireDownloads(workflow.replace(original, '')));
+    const stale = original.replace('if: ${{ !cancelled() }}',
+      "if: ${{ !cancelled() && matrix.flavor == 'race' }}");
+    assert.notEqual(stale, original);
+    assert.throws(() => requireDownloads(workflow.replace(original, () => stale)));
+  }
+});
diff --git a/.github/scripts/priority-unlocked-native.test.cjs b/.github/scripts/priority-unlocked-native.test.cjs
new file mode 100644
index 000000000..41f57e104
--- /dev/null
+++ b/.github/scripts/priority-unlocked-native.test.cjs
@@ -0,0 +1,41 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const {auditNativeUnlocked, roots, children} = require('./audit-unlocked-native.cjs');
+
+test('unlocked audit requires both executed ISAs and all three public API children', () => {
+  assert.equal(roots.length, 2);
+  assert.equal(children.length, 6);
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const child of children.filter(name => name.startsWith(root + '/'))) {
+      events.push(event('run', child), event('pass', child));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const inventory = roots.join('\n') + '\n';
+  const encode = rows => rows.map(JSON.stringify).join('\n') + '\n';
+  assert.deepEqual(auditNativeUnlocked(inventory, encode(events)),
+    {roots: 2, children: 6, passed: 8, skipped: 0, incomplete: 0});
+  for (const child of children) {
+    for (const altered of [
+      events.filter(row => row.Test !== child),
+      events.map(row => row.Test === child && row.Action === 'pass' ? {...row, Action: 'skip'} : row),
+      events.map(row => row.Test === child ? {...row, Test: child + '-object-only'} : row),
+    ]) assert.throws(() => auditNativeUnlocked(inventory, encode(altered)));
+  }
+  assert.throws(() => auditNativeUnlocked(inventory,
+    encode([event('start'), {...event('output'), Output: encode(events)}, event('pass')])));
+});
+
+test('unlocked native sources retain real host and backend requirements', () => {
+  const native = fs.readFileSync('amd64_scalar_memory_rmw_linux_amd64_test.go', 'utf8');
+  assert.equal((native.match(/x87IA32RequireNativeHost\(t\)/g) || []).length, 4);
+  assert.equal((native.match(/\[\]string\{"-O0", "-O2"\}/g) || []).length, 2);
+  assert.doesNotMatch(native, /\.Skip|qemu|rosetta|PLAN9ASM_CROSS_EXEC/);
+});
diff --git a/.github/scripts/priority-windows-cancelled-evidence.test.cjs b/.github/scripts/priority-windows-cancelled-evidence.test.cjs
new file mode 100644
index 000000000..e2a9b65c5
--- /dev/null
+++ b/.github/scripts/priority-windows-cancelled-evidence.test.cjs
@@ -0,0 +1,55 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+
+const source = fs.readFileSync(path.join(__dirname, '../workflows/windows-module.yml'), 'utf8');
+const labels = ['Retain actual root evidence', 'Retain actual package evidence'];
+
+function retention(source, label) {
+  const start = source.indexOf('      - name: ' + label + '\n');
+  assert.notEqual(start, -1, label);
+  const tail = source.slice(start);
+  const next = tail.search(/\n(?:      - |  [a-z-]+:)/);
+  return tail.slice(0, next < 0 ? undefined : next);
+}
+
+function verify(source) {
+  for (const label of labels) {
+    const step = retention(source, label);
+    assert.match(step, /^        if: \$\{\{ always\(\) \}\}$/m, label);
+    assert.match(step, /uses: actions\/upload-artifact@v6/);
+    assert.match(step, /if-no-files-found: error/);
+  }
+}
+
+function condition(source, label, replacement) {
+  const step = retention(source, label);
+  const changed = step.replace(/^        if: .+\n/m, replacement);
+  assert.notEqual(changed, step, label);
+  return source.replace(step, changed);
+}
+
+// Mutations start from a complete positive fixture even while the real
+// workflow is RED; missing or cancellation-dependent retention must fail.
+let fixture = source;
+for (const label of labels) {
+  const step = retention(fixture, label);
+  fixture = fixture.replace(step, step.replace(/^        if: .+$/m, '        if: ${{ always() }}'));
+}
+
+test('cancelled Windows owners retain diagnostic evidence, not successful coverage', () => {
+  verify(source);
+});
+
+for (const label of labels) {
+  test(label + ' cannot lose its cancellation-independent condition', () => {
+    verify(fixture);
+    assert.throws(() => verify(condition(fixture, label, '')));
+  });
+  test(label + ' cannot suppress reports after cancellation', () => {
+    assert.throws(() => verify(condition(fixture, label, '        if: ${{ !cancelled() }}\n')));
+  });
+}
diff --git a/.github/scripts/priority-windows-codecov-python.test.cjs b/.github/scripts/priority-windows-codecov-python.test.cjs
new file mode 100644
index 000000000..c26746784
--- /dev/null
+++ b/.github/scripts/priority-windows-codecov-python.test.cjs
@@ -0,0 +1,148 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody} = require('./workflow-needs.cjs');
+
+const source = fs.readFileSync(path.join(__dirname, '../workflows/windows-module.yml'), 'utf8');
+const setup = `      - name: Set up compatible Python for coverage upload
+        id: codecov_python
+        uses: actions/setup-python@v7
+        with:
+          python-version: '3.13'
+`;
+const beforeUpload = `      - name: Check Codecov Python and pip ownership
+        shell: bash
+        env:
+          CODECOV_PYTHON: \${{ steps.codecov_python.outputs.python-path }}
+        run: |
+          python - <<'PY'
+          import os
+          import shutil
+          import subprocess
+          import sys
+          if sys.version_info[:2] != (3, 13):
+              raise SystemExit("Codecov upload requires Python 3.13")
+          if not os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"]):
+              raise SystemExit("Codecov Python differs from setup-python output")
+          pip = shutil.which("pip")
+          expected = os.path.join(os.path.dirname(sys.executable), "Scripts", "pip.exe")
+          if not pip or not os.path.samefile(pip, expected):
+              raise SystemExit("Codecov pip is not owned by the selected Python")
+          print("Codecov upload Python:", sys.version, sys.executable, flush=True)
+          print("Codecov upload pip:", pip, flush=True)
+          subprocess.run([pip, "--version"], check=True)
+          PY
+`;
+const afterUpload = `      - name: Check installed Codecov CLI ownership
+        shell: bash
+        env:
+          CODECOV_PYTHON: \${{ steps.codecov_python.outputs.python-path }}
+        run: |
+          python - <<'PY'
+          import os
+          import shutil
+          import subprocess
+          import sys
+          if not os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"]):
+              raise SystemExit("Codecov Python changed during upload")
+          cli = shutil.which("codecovcli")
+          expected = os.path.join(os.path.dirname(sys.executable), "Scripts", "codecovcli.exe")
+          if not cli or not os.path.samefile(cli, expected):
+              raise SystemExit("Codecov CLI is not owned by the selected Python")
+          print("Codecov upload CLI:", cli, flush=True)
+          subprocess.run([cli, "--help"], check=True)
+          PY
+`;
+
+function oneStep(body, marker) {
+  const found = body.split(/(?=^      - )/m).filter(step => step.includes(marker));
+  assert.equal(found.length, 1, 'one actual step required: ' + marker);
+  return found[0];
+}
+
+function requirePhaseBoundary(workflow) {
+  for (const name of ['root-parts', 'other-owners']) {
+    assert.doesNotMatch(jobBody(workflow, name), /setup-python|codecov-action|CODECOV_PYTHON/);
+  }
+  const body = jobBody(workflow, 'complete');
+  const verify = body.indexOf('- name: Verify complete module and publish coverage\n');
+  const retain = body.indexOf('- name: Retain independent completion evidence\n');
+  const python = body.indexOf('uses: actions/setup-python@v7\n');
+  const upload = body.indexOf('- name: Upload verified complete Windows module coverage\n');
+  assert.ok(verify >= 0 && retain > verify && python > retain && upload > python,
+    'the uploader must not alter Python/PATH before module qualification and evidence retention');
+  assert.equal((body.match(/uses: actions\/setup-python@/g) || []).length, 1);
+  const action = oneStep(body, '- name: Upload verified complete Windows module coverage\n');
+  for (const input of ['use_pypi: true', 'use_oidc: true', 'disable_search: true',
+    'fail_ci_if_error: true', 'files: ./coverage-windows-${{ inputs.module }}.out']) {
+    assert.ok(action.includes(input), 'retain actual verified coverage upload input: ' + input);
+  }
+  assert.doesNotMatch(action, /continue-on-error:|if:|skip_validation:|PYO3_USE_ABI3_FORWARD_COMPATIBILITY/);
+}
+
+function requireCompatiblePython(workflow) {
+  requirePhaseBoundary(workflow);
+  const body = jobBody(workflow, 'complete');
+  const python = oneStep(body, 'uses: actions/setup-python@v7\n');
+  assert.match(python, /^        id: codecov_python$/m);
+  assert.match(python, /^          python-version: '3\.13'$/m);
+  assert.doesNotMatch(python, /python-version-file:|update-environment: false|allow-prereleases: true/);
+}
+
+function requireBindings(workflow) {
+  const body = jobBody(workflow, 'complete');
+  const before = oneStep(body, '- name: Check Codecov Python and pip ownership\n');
+  const after = oneStep(body, '- name: Check installed Codecov CLI ownership\n');
+  for (const step of [before, after]) {
+    assert.match(step, /^        shell: bash$/m);
+    assert.ok(step.includes('CODECOV_PYTHON: ${{ steps.codecov_python.outputs.python-path }}\n'));
+    assert.ok(step.includes('os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"])'));
+    assert.doesNotMatch(step, /continue-on-error:|if:|GITHUB_PATH|GITHUB_ENV|PYO3_USE_ABI3_FORWARD_COMPATIBILITY/);
+  }
+  for (const text of ['sys.version_info[:2] != (3, 13)', 'shutil.which("pip")',
+    '"Scripts", "pip.exe"', 'not os.path.samefile(pip, expected)',
+    'subprocess.run([pip, "--version"], check=True)']) {
+    assert.ok(before.includes(text), 'the action executes PATH pip, not a python action input: ' + text);
+  }
+  for (const text of ['shutil.which("codecovcli")', '"Scripts", "codecovcli.exe"',
+    'not os.path.samefile(cli, expected)', 'subprocess.run([cli, "--help"], check=True)']) {
+    assert.ok(after.includes(text), 'the actual installed CLI must be observed: ' + text);
+  }
+  const upload = body.indexOf('- name: Upload verified complete Windows module coverage\n');
+  assert.ok(body.indexOf(before) < upload && body.indexOf(after) > upload);
+}
+
+const fixture = source.replace(/      - uses: actions\/setup-python@v7\n        with:\n          python-version: '3\.x'\n/,
+  setup + beforeUpload);
+const completeFixture = fixture.endsWith(afterUpload) ? fixture : fixture + afterUpload;
+
+test('Windows coverage uploader uses a compatible Python after qualification', () => requireCompatiblePython(source));
+test('PATH pip and installed Codecov CLI are actually bound to the selected Python', () => requireBindings(source));
+test('upload setup cannot change a live module toolbank or suppress an upload error', () => requirePhaseBoundary(source));
+
+test('another Python minor or disabled PATH update cannot borrow the compatible pin', () => {
+  requireCompatiblePython(completeFixture);
+  requireBindings(completeFixture);
+  for (const value of ['3.x', '3.15', '3.14', '${{ matrix.python }}']) {
+    assert.throws(() => requireCompatiblePython(completeFixture.replace("python-version: '3.13'", `python-version: '${value}'`)));
+  }
+  assert.throws(() => requireCompatiblePython(completeFixture.replace("python-version: '3.13'", "python-version: '3.13'\n          update-environment: false")));
+});
+
+test('Python, pip and installed CLI binding checks cannot be omitted or softened', () => {
+  for (const text of ['os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"])',
+    'not os.path.samefile(pip, expected)', 'not os.path.samefile(cli, expected)',
+    'subprocess.run([pip, "--version"], check=True)', 'subprocess.run([cli, "--help"], check=True)']) {
+    assert.ok(completeFixture.includes(text));
+    assert.throws(() => requireBindings(completeFixture.replace(text, 'REMOVED_CHECK')));
+  }
+});
+
+test('compatible upload Python cannot move before module evidence is sealed', () => {
+  const moved = completeFixture.replace(setup, '').replace('      - name: Verify complete module and publish coverage\n',
+    setup + '      - name: Verify complete module and publish coverage\n');
+  assert.throws(() => requirePhaseBoundary(moved));
+});
diff --git a/.github/scripts/priority-windows-llvm-prefix.test.cjs b/.github/scripts/priority-windows-llvm-prefix.test.cjs
new file mode 100644
index 000000000..61293d673
--- /dev/null
+++ b/.github/scripts/priority-windows-llvm-prefix.test.cjs
@@ -0,0 +1,158 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {test} = require('node:test');
+
+const action = fs.readFileSync('.github/actions/setup-windows-llvm22/action.yml', 'utf8');
+const publisherFile = path.resolve('.github/actions/publish-windows-llvm22/index.cjs');
+function publisher() {
+  assert.ok(fs.existsSync(publisherFile), 'successful attempts need one stable, guarded native publication');
+  return require(publisherFile).publishPrefix;
+}
+
+function fixture(t, attempt = '1') {
+  const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'llvm22 prefix '));
+  t.after(() => fs.rmSync(root, {recursive: true, force: true}));
+  const source = path.join(root, 'plan9asm-msys2-attempt-' + attempt, 'msys64', 'clang64');
+  for (const relative of ['bin/llvm-config.exe', 'bin/clang.exe', 'bin/clang++.exe',
+    'include/stdint.h', 'include/_mingw.h', 'lib/libkernel32.a', 'lib/clang/22/include/stddef.h']) {
+    const file = path.join(source, relative);
+    fs.mkdirSync(path.dirname(file), {recursive: true});
+    fs.writeFileSync(file, 'synthetic transport input, not executable LLVM\n', {flag: 'wx'});
+  }
+  const target = path.join(root, 'plan9asm-llvm22');
+  const commands = [];
+  const run = (file, args, options) => {
+    commands.push({file, args});
+    const name = path.basename(file);
+    if (name === 'powershell.exe') {
+      assert.ok(args.join(' ').includes('ReparsePoint'));
+      assert.ok(options.env.PLAN9ASM_LLVM22_CHECK);
+      return '';
+    }
+    assert.ok(file.startsWith(target + path.sep) || file.startsWith(path.join(root, 'plan9asm-llvm22-proof') + path.sep));
+    if (name === 'llvm-config.exe') {
+      switch (args.join(' ')) {
+        case '--version': return '22.1.8\r\n';
+        case '--prefix': return target + '\r\n';
+        case '--bindir': return path.join(target, 'bin') + '\n';
+        case '--includedir': return path.join(target, 'include') + '\n';
+        case '--libdir': return path.join(target, 'lib') + '\n';
+        case '--cflags': return '-I' + path.join(target, 'include') + '\n';
+        case '--cxxflags': return '-I' + path.join(target, 'include') + ' -std=c++17\n';
+        case '--ldflags --libs all --system-libs': return '-L' + path.join(target, 'lib') + ' -lLLVM\n';
+        default: assert.fail('unexpected real publisher query: ' + args.join(' '));
+      }
+    }
+    if (name === 'clang.exe') {
+      if (args.join(' ') === '--version') return 'clang version 22.1.8\nTarget: x86_64-w64-windows-gnu\n';
+      if (args.join(' ') === '--print-resource-dir') return path.join(target, 'lib', 'clang', '22') + '\n';
+      const output = args[args.indexOf('-o') + 1];
+      assert.ok(output.startsWith(path.join(root, 'plan9asm-llvm22-proof') + path.sep));
+      fs.writeFileSync(output, 'synthetic link result, never native execution\n', {flag: 'wx'});
+      return '';
+    }
+    assert.equal(name, 'publication.exe');
+    assert.equal(fs.existsSync(file), true);
+    return '';
+  };
+  return {root, source, target, commands, run, options: {runnerTemp: root, attempt,
+    systemRoot: path.join(root, 'Windows'), run}};
+}
+
+test('different successful bootstrap attempts publish identical strict tool bindings', t => {
+  const publish = publisher();
+  const f = fixture(t);
+  const first = publish(f.options);
+  assert.equal(fs.existsSync(f.source), false);
+  assert.equal(first.path, path.join(f.target, 'bin'));
+  assert.equal(first.environment.LLVM_CONFIG, path.join(f.target, 'bin', 'llvm-config.exe'));
+  assert.equal(first.environment.CC, path.join(f.target, 'bin', 'clang.exe'));
+  assert.equal(first.environment.CXX, path.join(f.target, 'bin', 'clang++.exe'));
+  assert.equal(first.environment.CGO_ENABLED, '1');
+  assert.equal(first.environment.GOFLAGS, '-tags=byollvm');
+  assert.doesNotMatch(JSON.stringify(first), /plan9asm-msys2-attempt-/);
+  fs.renameSync(f.target, path.join(f.root, 'retained-success-1'));
+  fs.renameSync(path.join(f.root, 'plan9asm-llvm22-proof'), path.join(f.root, 'retained-proof-1'));
+  const secondSource = path.join(f.root, 'plan9asm-msys2-attempt-2', 'msys64', 'clang64');
+  fs.mkdirSync(path.dirname(secondSource), {recursive: true});
+  fs.cpSync(path.join(f.root, 'retained-success-1'), secondSource, {recursive: true, errorOnExist: true});
+  const failed = path.join(f.root, 'plan9asm-msys2-attempt-1', 'failed-update.txt');
+  fs.writeFileSync(failed, 'preserved original bootstrap failure\n');
+  const second = publish({...f.options, attempt: '2'});
+  assert.deepEqual(second, first, 'strict compiler environments must not depend on which attempt succeeded');
+  assert.equal(fs.readFileSync(failed, 'utf8'), 'preserved original bootstrap failure\n');
+});
+
+test('publication never covers an existing target or a redirected source', t => {
+  const publish = publisher();
+  for (const kind of ['file', 'directory', 'symlink', 'source-link', 'nested-link']) {
+    const f = fixture(t);
+    if (kind === 'file') fs.writeFileSync(f.target, 'keep target');
+    if (kind === 'directory') fs.mkdirSync(f.target);
+    if (kind === 'symlink') fs.symlinkSync(f.source, f.target, 'dir');
+    if (kind === 'source-link') {
+      const retained = path.join(f.root, 'original-source');
+      fs.renameSync(f.source, retained);
+      fs.symlinkSync(retained, f.source, 'dir');
+    }
+    if (kind === 'nested-link') fs.symlinkSync(path.join(f.source, 'include'), path.join(f.source, 'redirect'), 'dir');
+    assert.throws(() => publish(f.options), undefined, kind);
+    assert.equal(f.commands.filter(c => path.basename(c.file) === 'clang.exe').length, 0);
+    assert.equal(fs.existsSync(f.source), true, 'refused publication cannot remove its source');
+  }
+});
+
+test('unknown attempts, missing inputs and replacement during checks fail closed', t => {
+  const publish = publisher();
+  for (const attempt of ['', '0', '4', '01', '../1']) {
+    const f = fixture(t);
+    assert.throws(() => publish({...f.options, attempt}));
+    assert.equal(fs.existsSync(f.target), false);
+  }
+  const missing = fixture(t);
+  fs.unlinkSync(path.join(missing.source, 'bin', 'clang.exe'));
+  assert.throws(() => publish(missing.options));
+  const replaced = fixture(t);
+  let changed = false;
+  assert.throws(() => publish({...replaced.options, run(file, args, options) {
+    if (!changed && path.basename(file) === 'powershell.exe') {
+      changed = true;
+      fs.renameSync(replaced.source, path.join(replaced.root, 'retained-replaced-source'));
+      fs.mkdirSync(replaced.source);
+    }
+    return replaced.run(file, args, options);
+  }}));
+  assert.equal(fs.existsSync(replaced.target), false);
+});
+
+test('relocation, version, resource, compile and execution failures cannot publish bindings', t => {
+  const publish = publisher();
+  for (const kind of ['version', 'prefix', 'resources', 'flags', 'compile', 'execute', 'reparse']) {
+    const f = fixture(t);
+    assert.throws(() => publish({...f.options, run(file, args, options) {
+      const name = path.basename(file), command = args.join(' ');
+      if (kind === 'reparse' && name === 'powershell.exe') throw Error('native reparse point');
+      if (kind === 'version' && name === 'llvm-config.exe' && command === '--version') return '23.0.0\n';
+      if (kind === 'prefix' && command === '--prefix') return f.source + '\n';
+      if (kind === 'resources' && command === '--print-resource-dir') return path.join(f.source, 'lib/clang/22') + '\n';
+      if (kind === 'flags' && command === '--cflags') return '-I' + path.join(f.source, 'include') + '\n';
+      if (kind === 'compile' && name === 'clang.exe' && args.includes('-o')) throw Error('compile/link failed');
+      if (kind === 'execute' && name === 'publication.exe') throw Error('native execution failed');
+      return f.run(file, args, options);
+    }}), undefined, kind);
+  }
+});
+
+test('the actual action installs first and publishes only through the stable native action', () => {
+  const install = action.slice(action.indexOf('    - name: Install LLVM 22'));
+  assert.match(install, /uses: \.\/\.github\/actions\/publish-windows-llvm22/);
+  assert.doesNotMatch(install, />> "\$GITHUB_ENV"|>> "\$GITHUB_PATH"/);
+  assert.match(install, /steps\.msys2_attempt_1\.outcome == 'success'.*'1'/);
+  const metadata = fs.readFileSync('.github/actions/publish-windows-llvm22/action.yml', 'utf8');
+  assert.match(metadata, /using: node24/);
+  assert.doesNotMatch(metadata, /continue-on-error:|\n\s+if:/);
+});
diff --git a/.github/scripts/priority-windows-llvm.test.cjs b/.github/scripts/priority-windows-llvm.test.cjs
new file mode 100644
index 000000000..0a523847c
--- /dev/null
+++ b/.github/scripts/priority-windows-llvm.test.cjs
@@ -0,0 +1,175 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+
+const action = fs.readFileSync('.github/actions/setup-windows-llvm22/action.yml', 'utf8');
+
+function bootstrapSteps() {
+  const bootstrap = action.slice(action.indexOf('  steps:'), action.indexOf('    - name: Install LLVM 22'));
+  return bootstrap.split(/(?=    - name:)/).filter(step => step.includes('uses: msys2/setup-msys2@v2'));
+}
+
+// Model the observed setup-msys2 implementation at ec48f7c5447b3140e2b088413ae3a55687bccb6e:
+// release installs into join(location || RUNNER_TEMP, 'msys64'), refuses an
+// existing directory, and writes the msys2 shell before updating packages.
+// A failed download/extraction/update can therefore leave the directory behind.
+function bootstrap(updateOutcomes) {
+  const runnerTemp = 'D:\\runner temp';
+  const directories = new Set();
+  const attempts = [];
+  let shellInstallation;
+  for (const [index, step] of bootstrapSteps().entries()) {
+    if (index > 0) {
+      const condition = step.match(/if: \$\{\{ (.+) \}\}/)?.[1];
+      const expected = Array.from({ length: index }, (_, prior) =>
+        `steps.msys2_attempt_${prior + 1}.outcome == 'failure'`).join(' && ');
+      assert.equal(condition, expected, 'retry only after every prior failure');
+      if (!attempts.every(attempt => attempt.outcome === 'failure')) break;
+    }
+    const location = step.match(/\n        location: (.+)/)?.[1]
+      .replace('${{ runner.temp }}', runnerTemp) || runnerTemp;
+    const installation = path.win32.join(location, 'msys64');
+    const collision = directories.has(installation);
+    let outcome = 'failure';
+    if (!collision) {
+      directories.add(installation);
+      shellInstallation = installation;
+      outcome = updateOutcomes[index] === 0 ? 'success' : 'failure';
+    }
+    attempts.push({ installation, collision, outcome });
+    if (outcome === 'success') break;
+    if (!/continue-on-error: true/.test(step)) {
+      return { attempts, directories, shellInstallation, installerMayRun: false };
+    }
+  }
+  return {
+    attempts, directories, shellInstallation,
+    installerMayRun: attempts.at(-1)?.outcome === 'success',
+  };
+}
+
+test('MSYS2 bootstrap retries are bounded and the final failure remains fatal', () => {
+  const attempts = bootstrapSteps();
+  assert.equal(attempts.length, 3);
+  for (const [index, step] of attempts.entries()) {
+    assert.match(step, new RegExp(`id: msys2_attempt_${index + 1}`));
+    assert.match(step, /msystem: CLANG64/);
+    assert.match(step, /path-type: inherit/);
+    assert.match(step, /update: true/);
+    if (index < 2) {
+      assert.match(step, /continue-on-error: true/);
+    } else {
+      assert.doesNotMatch(step, /continue-on-error:/);
+    }
+    if (index > 0) {
+      for (let prior = 1; prior <= index; prior++) {
+        assert.match(step, new RegExp(`steps\\.msys2_attempt_${prior}\\.outcome == 'failure'`));
+      }
+    }
+  }
+});
+
+test('a partially installed MSYS2 directory cannot poison subsequent bootstrap attempts', () => {
+  for (const outcomes of [[1, 0], [1, 1, 0]]) {
+    const result = bootstrap(outcomes);
+    assert.equal(result.installerMayRun, true, 'a later successful update must reach LLVM installation');
+    assert.equal(result.attempts.length, outcomes.length);
+    assert.ok(result.attempts.every(attempt => !attempt.collision), 'each retry must start a fresh installation');
+    assert.equal(result.directories.size, outcomes.length, 'failed bootstrap directories are retained, not deleted');
+    assert.equal(result.shellInstallation, result.attempts.at(-1).installation,
+      'the official msys2 wrapper must select the successful attempt, not the first failed installation');
+  }
+});
+
+test('all three bootstrap attempts explicitly own distinct fresh runner-temp locations', () => {
+  const locations = bootstrapSteps().map((step, index) => {
+    assert.match(step, /\n        release: true\n/);
+    const location = step.match(/\n        location: (.+)/)?.[1];
+    assert.equal(location, `\${{ runner.temp }}/plan9asm-msys2-attempt-${index + 1}`);
+    return location;
+  });
+  assert.equal(new Set(locations).size, 3);
+  assert.doesNotMatch(action, /release: false|Remove-Item|rm\s+-[rf]|SigLevel\s*=|--nosignature|--skippgpcheck/);
+});
+
+test('bootstrap success short-circuits retries and exhausted bootstrap remains fatal', () => {
+  const first = bootstrap([0]);
+  assert.equal(first.attempts.length, 1);
+  assert.equal(first.installerMayRun, true);
+  assert.equal(first.shellInstallation, first.attempts[0].installation);
+  const exhausted = bootstrap([1, 1, 1]);
+  assert.equal(exhausted.attempts.length, 3);
+  assert.ok(exhausted.attempts.every(attempt => !attempt.collision));
+  assert.equal(exhausted.installerMayRun, false, 'no LLVM transaction or build environment after final failure');
+});
+
+function install(outcomes, version = '22.1.8') {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'plan9asm-llvm-install-'));
+  try {
+    const installStep = action.slice(action.indexOf('    - name: Install LLVM 22')).split(/\n    - name:/)[0];
+    const run = installStep.slice(installStep.indexOf('      run: |\n') + '      run: |\n'.length)
+      .split('\n').map(line => line.startsWith('        ') ? line.slice(8) : line).join('\n');
+    const script = `
+mock_pacman_calls=0
+outcomes=(${outcomes.join(' ')})
+pacman() {
+  mock_pacman_calls=$((mock_pacman_calls + 1))
+  printf 'PACMAN:'
+  printf ' %s' "$@"
+  printf '\\n'
+  return "\${outcomes[mock_pacman_calls - 1]}"
+}
+sleep() { test "$1" = 5; printf 'RETRY_WAIT\\n'; }
+llvm-config() {
+  if [[ "$1" == --version ]]; then printf '%s\\n' "$MOCK_LLVM_VERSION";
+  else printf 'checked-flags\\n'; fi
+}
+cygpath() { printf 'checked-clang64-bin\\n'; }
+${run}`;
+    const result = spawnSync('bash', ['-c', script], {
+      encoding: 'utf8', timeout: 5000,
+      env: {
+        ...process.env,
+        LLVM_VERSION: '22.1.8', LLVM_PACKAGE_VERSION: '22.1.8-2',
+        LLVM_RUNTIME_PACKAGE_VERSION: '22.1.8-1', MOCK_LLVM_VERSION: version,
+        GITHUB_ENV: path.join(directory, 'environment'), GITHUB_PATH: path.join(directory, 'path'),
+      },
+    });
+    assert.ifError(result.error);
+    return {
+      ...result,
+      environment: fs.existsSync(path.join(directory, 'environment'))
+        ? fs.readFileSync(path.join(directory, 'environment'), 'utf8') : '',
+    };
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+test('actual installer script retries the identical pinned transaction only', () => {
+  for (const outcomes of [[0], [67, 0], [67, 68, 0]]) {
+    const result = install(outcomes);
+    assert.equal(result.status, 0, result.stderr);
+    const transactions = result.stdout.split('\n').filter(line => line.startsWith('PACMAN:'));
+    assert.equal(transactions.length, outcomes.length);
+    assert.equal(new Set(transactions).size, 1);
+    assert.match(transactions[0], /llvm-22\.1\.8-2-any\.pkg\.tar\.zst/);
+    assert.doesNotMatch(transactions[0], /llvm-23/);
+    assert.equal((result.stdout.match(/RETRY_WAIT/g) || []).length, outcomes.length - 1);
+    assert.equal(result.environment, '', 'installation alone cannot publish attempt-dependent bindings');
+  }
+});
+
+test('exhausted installation and wrong LLVM version publish no build environment', () => {
+  const exhausted = install([67, 68, 69]);
+  assert.equal(exhausted.status, 69, exhausted.stderr);
+  assert.equal((exhausted.stdout.match(/PACMAN:/g) || []).length, 3);
+  assert.equal(exhausted.environment, '');
+  const wrongVersion = install([0], '23.0.0');
+  assert.equal(wrongVersion.status, 1);
+  assert.match(wrongVersion.stderr, /expected LLVM 22\.1\.8, got 23\.0\.0/);
+  assert.equal(wrongVersion.environment, '');
+});
diff --git a/.github/scripts/priority-windows-sdk-scope.test.cjs b/.github/scripts/priority-windows-sdk-scope.test.cjs
new file mode 100644
index 000000000..b52483d73
--- /dev/null
+++ b/.github/scripts/priority-windows-sdk-scope.test.cjs
@@ -0,0 +1,95 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const test = require('node:test');
+const {jobBody} = require('./workflow-needs.cjs');
+
+const source = fs.readFileSync(path.join(__dirname, '../workflows/windows-module.yml'), 'utf8');
+const jobs = ['root-parts', 'other-owners', 'complete'];
+const exactSDK = '1.27.2';
+
+// These independent jobs exchange one source/tool/environment-bound plan.
+// A floating minor selector can resolve to a different SDK between execution
+// and fresh completion. Pin the shared scope, never normalize its real hashes.
+function requireExactSDK(workflow) {
+  for (const name of jobs) {
+    const body = jobBody(workflow, name);
+    const steps = body.split(/(?=^      - )/m).slice(1);
+    const setup = steps.filter(step =>
+      /^      - uses: \.\/\.github\/actions\/setup-go$/m.test(step));
+    assert.equal(setup.length, 1, name + ': one actual owned Go setup required');
+    assert.doesNotMatch(body, /uses: actions\/setup-go@/,
+      name + ': another Go installer cannot replace the owned setup');
+    const versions = [...setup[0].matchAll(/^          go-version: (.+)$/gm)];
+    assert.equal(versions.length, 1, name + ': one explicit Go pin required');
+    assert.match(setup[0], /^        with:$/m, name + ': setup input scope missing');
+    assert.ok(versions[0][1] === `'${exactSDK}'` || versions[0][1] === `"${exactSDK}"`,
+      name + ': execution and completion require the same exact ' + exactSDK + ' SDK');
+    assert.doesNotMatch(setup[0], /go-version-file:|check-latest:/,
+      name + ': no alternative source may override the exact SDK');
+  }
+  assert.equal((workflow.match(/uses: \.\/\.github\/actions\/setup-go$/gm) || []).length, 3,
+    'all shared Windows Go setup roles must be covered');
+}
+
+function replaceJob(workflow, name, change) {
+  const before = jobBody(workflow, name);
+  const after = change(before);
+  assert.notEqual(after, before, 'negative control must mutate its actual job');
+  return workflow.replace(before, after);
+}
+
+// Controls begin from a complete positive fixture even while the real source
+// is RED. A matching pin in another job or run string is never a substitute.
+const fixture = source.replace(/^          go-version: .+$/gm, `          go-version: '${exactSDK}'`);
+
+test('shared Windows execution and fresh completion pin one exact SDK', () => {
+  requireExactSDK(source);
+});
+
+test('main Windows caller retains the shared executor and aggregate scope', () => {
+  for (const [file, name] of [
+    ['go-ci.yml', 'windows-module'],
+  ]) {
+    const workflow = fs.readFileSync(path.join(__dirname, '../workflows', file), 'utf8');
+    const body = jobBody(workflow, name);
+    assert.match(body, /^    uses: \.\/\.github\/workflows\/windows-module\.yml$/m);
+    assert.match(body, /^      module: \$\{\{ matrix\.module \}\}$/m);
+    assert.doesNotMatch(body, /go-version:/,
+      name + ': the shared scope must not inherit a floating caller selector');
+  }
+  requireExactSDK(fixture);
+});
+
+for (const name of jobs) {
+  test(name + ' cannot use another patch, floating minor or dynamic SDK selector', () => {
+    requireExactSDK(fixture);
+    for (const version of ['1.27.3', '1.27.x', '1.27', 'stable', '${{ matrix.go }}']) {
+      assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+        body.replace(`go-version: '${exactSDK}'`, `go-version: '${version}'`))));
+    }
+  });
+
+  test(name + ' cannot omit, duplicate or borrow its SDK pin', () => {
+    const pin = `          go-version: '${exactSDK}'\n`;
+    for (const replacement of ['', pin + pin, '          go-version-file: go.mod\n']) {
+      assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+        body.replace(pin, replacement))));
+    }
+    assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+      body.replace(pin, '') + `      - run: echo "go-version: '${exactSDK}'"\n`)));
+  });
+
+  test(name + ' cannot lose or repeat the actual Go installer', () => {
+    const setup = '      - uses: ./.github/actions/setup-go\n';
+    assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+      body.replace(setup, '      - uses: actions/setup-go@v7\n'))));
+    assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+      body.replace(setup, setup + `        with:\n          go-version: '${exactSDK}'\n` + setup))));
+    assert.throws(() => requireExactSDK(replaceJob(fixture, name, body =>
+      body.replace(`          go-version: '${exactSDK}'\n`,
+        `          go-version: '${exactSDK}'\n          check-latest: true\n`))));
+  });
+}
diff --git a/.github/scripts/priority-workflow-needs.test.cjs b/.github/scripts/priority-workflow-needs.test.cjs
new file mode 100644
index 000000000..6d1cc18b5
--- /dev/null
+++ b/.github/scripts/priority-workflow-needs.test.cjs
@@ -0,0 +1,57 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const {jobBody, jobNeeds, requireJobNeeds} = require('./workflow-needs.cjs');
+
+function replaceNeeds(source, name, declaration) {
+  const body = jobBody(source, name);
+  const changed = body.replace(/^    needs:.*$/m, '    needs: ' + declaration);
+  assert.notEqual(body, changed, 'negative/format control must change its actual job');
+  return source.replace(body, changed);
+}
+
+test('concrete dependencies reject duplicates, expressions, self references and absent jobs', () => {
+  const source = 'jobs:\n  first:\n    runs-on: ubuntu-latest\n' +
+    '  second:\n    runs-on: ubuntu-latest\n' +
+    '  complete:\n    needs: [first, second]\n';
+  const requireComplete = value => requireJobNeeds(value, 'complete', ['first', 'second']);
+  assert.deepEqual(requireComplete(source), ['first', 'second']);
+  assert.deepEqual(requireComplete(replaceNeeds(source, 'complete', '["second", "first"]')), ['second', 'first']);
+  for (const declaration of [
+    '[first, first]', '[first, absent]', '[first, complete]',
+    '${{ needs.from_another_job }}', '[]', '[first,]', '[first]', '[second]',
+  ]) assert.throws(() => requireComplete(replaceNeeds(source, 'complete', declaration)));
+  const body = jobBody(source, 'complete');
+  assert.throws(() => requireComplete(source.replace(body,
+    body.replace(/^    needs:.*$/m, '    needs: first\n    needs: second'))));
+  assert.throws(() => requireComplete(source.replace(body, body.replace(/^    needs:.*\n/m, ''))));
+  assert.throws(() => requireComplete(source + '\n  complete:\n'));
+  assert.throws(() => requireComplete(source.replace('\n  first:\n', '\n  absent:\n')));
+});
+
+test('main and reusable CLI completion retain every actual owner gate', () => {
+  for (const [file, name, required] of [
+    ['go-ci.yml', 'module-completion', ['test', 'nested-cli', 'race', 'coverage', 'nested-cli-coverage']],
+    ['windows-module.yml', 'complete', ['root-parts', 'other-owners']],
+    ['linux-cli-module.yml', 'complete', ['root-parts']],
+  ]) {
+    const source = fs.readFileSync('.github/workflows/' + file, 'utf8');
+    requireJobNeeds(source, name, required);
+    requireJobNeeds(replaceNeeds(source, name, '[' + required.slice().reverse().join(', ') + ']'), name, required);
+    for (const missing of required) {
+      const reduced = '[' + required.filter(gate => gate !== missing).join(', ') + ']';
+      assert.throws(() => requireJobNeeds(replaceNeeds(source, name, reduced), name, required));
+    }
+  }
+});
+
+test('concrete block and scalar needs retain the same owned success requirements', () => {
+  const source = 'jobs:\n  first:\n    runs-on: ubuntu-latest\n' +
+    '  second:\n    needs: first\n' +
+    '  complete:\n    needs:\n      - first\n      - second\n';
+  assert.deepEqual(jobNeeds(source, 'second'), ['first']);
+  assert.deepEqual(requireJobNeeds(source, 'complete', ['second', 'first']), ['first', 'second']);
+  assert.throws(() => requireJobNeeds(source.replace('      - second\n', ''), 'complete', ['first', 'second']));
+});
diff --git a/.github/scripts/priority-x87-native.test.cjs b/.github/scripts/priority-x87-native.test.cjs
new file mode 100644
index 000000000..aa18de3a3
--- /dev/null
+++ b/.github/scripts/priority-x87-native.test.cjs
@@ -0,0 +1,86 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const test = require('node:test');
+
+const roots = [
+  'TestCrossLinuxRuntimeMatrixX86X87SignedI64IdentityOriginalGoAndLLVM',
+  'TestAMD64X87ConditionalMoveRuntimeConditions',
+  'TestX86RawX87ClearExceptionRuntimeSemantics',
+  'TestX86RawX87SoftwareClearPreservesAllStatusFields',
+  'TestCrossLinuxRuntimeMatrixX86X87ScopedRoundingOriginalGoAndLLVM',
+];
+
+test('native x87 auditor requires actual complete ordered terminals, not printed PASS text', () => {
+  const {auditNativeX87, roots: actualRoots, children} = require('./audit-x87-native.cjs');
+  assert.deepEqual(actualRoots, roots);
+  const originalChildren = [];
+  for (const arch of ['amd64', '386']) {
+    const parent = `${roots[0]}/${arch}`;
+    originalChildren.push(parent);
+    for (const api of ['text', 'module', 'Go']) {
+      for (const optimized of [false, true]) {
+        for (const backend of [0, 2]) originalChildren.push(`${parent}/${api}/IR_O2=${optimized}/backend-O${backend}`);
+      }
+    }
+  }
+  const roundingChildren = [];
+  for (const api of ['text', 'module', 'Go']) {
+    const parent = `${roots[4]}/${api}`;
+    roundingChildren.push(parent);
+    for (const optimized of [false, true]) {
+      for (const backend of [0, 2]) roundingChildren.push(`${parent}/IR_O2=${optimized}/backend-O${backend}`);
+    }
+  }
+  assert.equal(originalChildren.length, 26, 'retain all original native axes');
+  assert.equal(roundingChildren.length, 15, 'three rounding API parents and twelve complete pipelines');
+  assert.deepEqual(children, [...originalChildren, ...roundingChildren]);
+  const event = (Action, Test) => ({Action, Package: 'github.com/xgo-dev/plan9asm', ...(Test ? {Test} : {})});
+  const events = [event('start')];
+  for (const root of roots) {
+    events.push(event('run', root));
+    for (const parent of children.filter(name => name.startsWith(root + '/') && name.split('/').length === 2)) {
+      events.push(event('run', parent));
+      for (const child of children.filter(name => name.startsWith(parent + '/'))) {
+        events.push(event('run', child), event('pass', child));
+      }
+      events.push(event('pass', parent));
+    }
+    events.push(event('pass', root));
+  }
+  events.push(event('pass'));
+  const inventory = roots.join('\n') + '\nok\tgithub.com/xgo-dev/plan9asm\n';
+  const encode = values => values.map(value => JSON.stringify(value)).join('\n') + '\n';
+  assert.deepEqual(auditNativeX87(inventory, encode(events)), {roots: 5, children: 41, passed: 46, skipped: 0, incomplete: 0});
+  const child = children[1];
+  const earlyParent = events.filter(value => value.Test !== children[0] || value.Action !== 'pass');
+  earlyParent.splice(earlyParent.findIndex(value => value.Test === child), 0, event('pass', children[0]));
+  for (const changed of [
+    earlyParent,
+    events.filter(value => value.Test !== child),
+    events.filter(value => value.Test !== child || value.Action !== 'pass'),
+    events.map(value => value.Test === child && value.Action === 'pass' ? {...value, Action: 'skip'} : value),
+    events.map(value => value.Test === child && value.Action === 'pass' ? {...value, Action: 'fail'} : value),
+    events.map(value => value.Test === child ? {...value, Test: child + '-object-only'} : value),
+    events.slice(0, -1),
+    [...events, event('pass')],
+    [event('start'), {...event('output'), Output: events.map(value => 'PASS ' + (value.Test || 'package')).join('\n')}, event('pass')],
+  ]) assert.throws(() => auditNativeX87(inventory, encode(changed)));
+  for (const child of roundingChildren) {
+    for (const action of ['skip', 'fail']) {
+      assert.throws(() => auditNativeX87(inventory, encode(events.map(value =>
+        value.Test === child && value.Action === 'pass' ? {...value, Action: action} : value))));
+    }
+    assert.throws(() => auditNativeX87(inventory, encode(events.filter(value => value.Test !== child))));
+    assert.throws(() => auditNativeX87(inventory, encode(events.filter(value =>
+      value.Test !== child || value.Action !== 'pass'))));
+  }
+  assert.throws(() => auditNativeX87(inventory.replace(roots[0], 'TestObjectOnly'), encode(events)));
+});
+
+test('scoped rounding emits explicit live API parents for all twelve native pipelines', () => {
+  const source = fs.readFileSync('x86_x87_scoped_rounding_linux_amd64_test.go', 'utf8');
+  assert.match(source, /func TestCrossLinuxRuntimeMatrixX86X87ScopedRoundingOriginalGoAndLLVM\(t \*testing\.T\)/);
+  assert.match(source, /for _, api := range \[\]string\{"text", "module", "Go"\} \{\n\s+t\.Run\(api, func\(t \*testing\.T\) \{/);
+  assert.match(source, /t\.Run\(fmt\.Sprintf\("IR_O2=%t\/backend%s", optimized, level\)/);
+  assert.doesNotMatch(source, /t\.Skip|exec\.Command|qemu|rosetta/);
+});
diff --git a/.github/scripts/workflow-needs.cjs b/.github/scripts/workflow-needs.cjs
new file mode 100644
index 000000000..0b9fc9890
--- /dev/null
+++ b/.github/scripts/workflow-needs.cjs
@@ -0,0 +1,61 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+
+function jobBody(source, name) {
+  assert.match(name, /^[a-zA-Z_][a-zA-Z0-9_-]*$/, 'invalid workflow job identity');
+  const marker = '\n  ' + name + ':\n';
+  assert.equal(source.split(marker).length - 1, 1, 'one exact workflow job required: ' + name);
+  const rest = source.slice(source.indexOf(marker) + marker.length);
+  const end = rest.search(/^  [a-zA-Z_][a-zA-Z0-9_-]*:\s*$/m);
+  return end < 0 ? rest : rest.slice(0, end);
+}
+
+// This intentionally accepts only concrete job identities, not an expression,
+// comment or a matching line in a different job. Whitespace/order and adding
+// another real dependency do not change whether each required gate is present.
+function jobNeeds(source, name) {
+  const lines = jobBody(source, name).split('\n');
+  const positions = lines.flatMap((line, index) => /^    needs:/.test(line) ? [index] : []);
+  assert.equal(positions.length, 1, 'one actual needs declaration required: ' + name);
+  const index = positions[0], value = lines[index].slice('    needs:'.length).trim();
+  let needs;
+  if (value.startsWith('[')) {
+    assert.ok(value.endsWith(']'), 'incomplete concrete needs array: ' + name);
+    needs = value.slice(1, -1).split(',').map(value => value.trim());
+  } else if (value) {
+    needs = [value];
+  } else {
+    needs = [];
+    for (const line of lines.slice(index + 1)) {
+      if (!/^      - /.test(line)) break;
+      needs.push(line.slice('      - '.length).trim());
+    }
+  }
+  assert.ok(needs.length > 0, 'empty workflow needs: ' + name);
+  needs = needs.map(dependency => {
+    if ((dependency.startsWith('"') && dependency.endsWith('"')) ||
+        (dependency.startsWith("'") && dependency.endsWith("'"))) {
+      return dependency.slice(1, -1);
+    }
+    return dependency;
+  });
+  assert.equal(new Set(needs).size, needs.length, 'duplicate workflow dependency: ' + name);
+  for (const dependency of needs) {
+    assert.match(dependency, /^[a-zA-Z_][a-zA-Z0-9_-]*$/, 'non-concrete workflow dependency: ' + name);
+    assert.notEqual(dependency, name, 'workflow job cannot depend on itself');
+    jobBody(source, dependency);
+  }
+  return needs;
+}
+
+function requireJobNeeds(source, name, required) {
+  const actual = jobNeeds(source, name);
+  assert.equal(new Set(required).size, required.length, 'duplicate required dependency policy');
+  for (const dependency of required) {
+    assert.ok(actual.includes(dependency), name + ' omitted required success gate: ' + dependency);
+  }
+  return actual;
+}
+
+module.exports = {jobBody, jobNeeds, requireJobNeeds};
diff --git a/.github/workflows/go-ci.yml b/.github/workflows/go-ci.yml
index 39dd98fc6..fd13182ef 100644
--- a/.github/workflows/go-ci.yml
+++ b/.github/workflows/go-ci.yml
@@ -18,18 +18,60 @@ permissions:
   contents: read
 
 jobs:
+  ci_policy:
+    name: CI policy preflight
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install LLVM 22
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
+
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.1'
+
+      - name: Setup verified policy runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+
+      - name: Workflow scheduling regression tests
+        run: node --test .github/scripts/priority-*.test.cjs
+
+      - name: CI policy tests
+        run: go test . -run '^(TestCI|TestFixedLocal|TestGoAMD64FixedLocal(Packed|Conversion)RuntimeOwnership$|TestX86PackedConversion(RequiredNativeOwners|CompleteNativeRuntimeOwnership)$|TestX86FloatingCompareRequiredLinuxBuildSelection$|TestRuntimeOracleCommand(ConsumersRetainOwnedExecution|AuditDistinguishesTestingRun)$)' -count=1
+
+      - name: Compile explicit native AVX512 owners and verify their inventory
+        run: go test . -tags=plan9asm_native_avx512 -run '^TestCIAVX512NativeQualificationInventory$' -count=1
+
+      - name: Official corpus form baselines
+        timeout-minutes: 10
+        shell: bash
+        run: |
+          set -euo pipefail
+          scripts/check-go-asm-coverage.sh
+          scripts/check-arm64-plan9-corpus.sh
+
+
   fmt:
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    needs: ci_policy
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v7
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
 
       - name: Go fmt check
         run: |
@@ -41,25 +83,22 @@ jobs:
           fi
 
   build:
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    needs: ci_policy
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v7
 
       - name: Install LLVM 22
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
 
       - name: Go build
         run: go build ./...
@@ -75,61 +114,10 @@ jobs:
       - name: ARM64 Plan 9 reference corpus
         run: scripts/check-arm64-plan9-corpus.sh
 
-  reported_library_list:
-    name: Third-party corpus matrix
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
-    outputs:
-      libraries: ${{ steps.matrix.outputs.libraries }}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-
-      - name: Read third-party library manifest
-        id: matrix
-        run: |
-          manifest=testdata/corpus/reported-libraries.json
-          if ! jq -e '.libraries | length > 0 and all(.[]; (.id | test("^[a-z0-9]+(-[a-z0-9]+)*$")))' "$manifest" >/dev/null; then
-            echo "third-party library ids must match ^[a-z0-9]+(-[a-z0-9]+)*$" >&2
-            exit 1
-          fi
-          libraries=$(jq -c '[.libraries[].id]' "$manifest")
-          printf '%s\n' "libraries=$libraries" >> "$GITHUB_OUTPUT"
-
-  reported_library_corpus:
-    name: third-party-corpus (${{ matrix.library }})
-    needs: reported_library_list
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
-    strategy:
-      fail-fast: false
-      matrix:
-        library: ${{ fromJSON(needs.reported_library_list.outputs.libraries) }}
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-
-      - name: Install LLVM 22
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
-
-      - name: Setup Go
-        uses: ./.github/actions/setup-go
-        with:
-          go-version: '1.27.x'
-          cache: true
-
-      - name: Scan latest module and compile complete asm corpus
-        env:
-          REPORTED_LIBRARY: ${{ matrix.library }}
-        run: scripts/check-reported-library-corpus.sh "$REPORTED_LIBRARY"
 
   stdlib-corpus:
-    name: stdlib-corpus (${{ matrix.os }}, Go ${{ matrix.go-version }})
+    needs: ci_policy
+    name: stdlib instruction corpus (${{ matrix.os }}, Go ${{ matrix.go-version }})
     runs-on: ${{ github.repository_owner == 'xgo-dev' && matrix.runner || matrix.os }}
     strategy:
       fail-fast: false
@@ -145,10 +133,10 @@ jobs:
           - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.24.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
           - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.25.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
           - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.26.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.27.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.27.2', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
           # Native hosts are auxiliary integration checks on the latest Go.
-          - {os: macos-latest, go-version: '1.27.x', targets: 'darwin/amd64,darwin/arm64'}
-          - {os: windows-latest, go-version: '1.27.x', targets: 'windows/386,windows/amd64,windows/arm64'}
+          - {os: macos-latest, go-version: '1.27.2', targets: 'darwin/amd64,darwin/arm64'}
+          - {os: windows-latest, go-version: '1.27.2', targets: 'windows/386,windows/amd64,windows/arm64'}
 
     steps:
       - name: Checkout
@@ -156,12 +144,8 @@ jobs:
 
       - name: Install LLVM 22 (Ubuntu)
         if: runner.os == 'Linux'
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
 
       - name: Install LLVM 22 (macOS)
         if: runner.os == 'macOS'
@@ -181,10 +165,10 @@ jobs:
 
       - name: Setup Go for corpus tool build
         if: matrix.prebuild_tool
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: false
+          go-version: '1.27.2'
 
       - name: Build corpus tool for older Go lane
         if: matrix.prebuild_tool
@@ -195,10 +179,10 @@ jobs:
           echo "PLAN9ASM_CMD=$tool" >> "$GITHUB_ENV"
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
           go-version: ${{ matrix.go-version }}
-          cache: true
 
       - name: Stdlib asm corpus gate
         shell: bash
@@ -206,7 +190,7 @@ jobs:
           PLAN9ASM_CORPUS_TARGETS: ${{ matrix.targets }}
         run: |
           chmod +x scripts/check-stdlib-corpus.sh
-          scripts/check-stdlib-corpus.sh
+          scripts/check-stdlib-corpus.sh --instructions-only
 
       - name: Official Go assembler coverage regression
         shell: bash
@@ -215,37 +199,133 @@ jobs:
           scripts/check-go-asm-coverage.sh
 
   cross-runtime:
+    needs: ci_policy
     name: cross compile, link, and run (Linux)
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    strategy:
+      # Every selected root is owned exactly once; owner zero isolates the
+      # giant matrix root. A failure must not cancel other owners.
+      fail-fast: false
+      matrix:
+        owner: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+    env:
+      GOFLAGS: ''
+      GOENV: 'off'
+      GOWORK: 'off'
+      GOTOOLCHAIN: local
+      PLAN9ASM_CROSS_EXEC: '1'
 
     steps:
       - name: Checkout
         uses: actions/checkout@v7
 
-      - name: Install LLVM, cross compilers, and QEMU
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y \
-            llvm-22-dev clang-22 lld-22 \
-            gcc-i686-linux-gnu gcc-arm-linux-gnueabihf gcc-aarch64-linux-gnu \
-            qemu-user
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+      - name: Install LLVM and cross compilers
+        timeout-minutes: 14
+        run: >-
+          bash scripts/install-ci-llvm22-ubuntu.sh
+          gcc-i686-linux-gnu gcc-arm-linux-gnueabihf
+          gcc-aarch64-linux-gnu
+
+      - name: Install pinned QEMU user-mode emulators
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
+
+      - name: Setup required wasm execution runtime
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-node22
 
       - name: Cross transpile, compile, link, and run
-        env:
-          PLAN9ASM_CROSS_EXEC: '1'
-        run: go test . -run '^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance)' -count=1 -v
+        run: |
+          mkdir -p _out
+          go run ./cmd/plan9asmtest -out _out/cross-runtime-owner \
+            -ci-selector '^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance|TestARM64RawSQSHLURuntimeSemantics|TestARMIntegerMemoryRuntimeCross|TestARMRawSaturationRuntimeCross)' \
+            -ci-isolate-root TestCrossLinuxRuntimeMatrix \
+            -ci-owner ${{ matrix.owner }} -shards 16 -timeout 20m
+
+      - name: Execute rich CLI ARM64 fallback oracle
+        if: ${{ !cancelled() && matrix.owner == 15 }}
+        run: bash scripts/test-arm64-fallback-ci.sh execute
+
+      - name: Retain every owner receipt, including failures
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: cross-runtime-owner-${{ matrix.owner }}
+          path: _out/cross-runtime-owner
+          if-no-files-found: error
+
+  cross-runtime-verify:
+    name: cross-runtime exhaustive completion
+    needs: cross-runtime
+    if: ${{ !cancelled() }}
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    env:
+      GOFLAGS: ''
+      GOENV: 'off'
+      GOWORK: 'off'
+      GOTOOLCHAIN: local
+      PLAN9ASM_CROSS_EXEC: '1'
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install LLVM and cross compilers
+        timeout-minutes: 14
+        run: >-
+          bash scripts/install-ci-llvm22-ubuntu.sh
+          gcc-i686-linux-gnu gcc-arm-linux-gnueabihf
+          gcc-aarch64-linux-gnu
+
+      - name: Install pinned QEMU user-mode emulators
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+
+      - name: Setup required wasm execution runtime
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-node22
+
+      - name: Download all owner evidence
+        uses: actions/download-artifact@v8
+        with:
+          pattern: cross-runtime-owner-*
+          path: _out/cross-runtime-partitions
+
+      - name: Verify the fresh complete five-prefix inventory
+        run: |
+          go run ./cmd/plan9asmtest -out _out/cross-runtime-aggregate \
+            -verify-ci-partitions _out/cross-runtime-partitions \
+            -ci-selector '^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance|TestARM64RawSQSHLURuntimeSemantics|TestARMIntegerMemoryRuntimeCross|TestARMRawSaturationRuntimeCross)' \
+            -ci-isolate-root TestCrossLinuxRuntimeMatrix -shards 16 -timeout 20m
+
+      - name: Verify rich CLI ARM64 fallback execution
+        if: ${{ !cancelled() }}
+        run: bash scripts/test-arm64-fallback-ci.sh complete
+
+      - name: Retain completion evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: cross-runtime-completion
+          path: _out/cross-runtime-aggregate
+          if-no-files-found: error
 
   test:
-    name: test (${{ matrix.os }}, ${{ matrix.go-version }}, ${{ matrix.nested_modules }})
+    needs: ci_policy
+    name: test (${{ matrix.os }}, ${{ matrix.go-version }}, ${{ matrix.module-role }})
+    timeout-minutes: 60
     permissions:
       contents: read
       id-token: write
@@ -254,26 +334,42 @@ jobs:
       # Keep both matrix variants visible even if one fails.
       fail-fast: false
       matrix:
+        os: [ubuntu-latest]
+        # Create current-SDK and minimum-SDK jobs before historical lanes.
+        # Runner scheduling is external; retain every version and owner.
+        go-version: ['1.27.2', '1.20.x', '1.26.x', '1.25.x', '1.24.x', '1.23.x', '1.22.x', '1.21.x']
+        module-role: [root-0, root-1, root-2, root-3, root-4, root-5, root-6, root-7,
+          root-8, root-9, root-10, root-11, root-12, root-13, root-14, root-15, profile, other]
         include:
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.20.x', nested_modules: false}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.21.x', nested_modules: false}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.22.x', nested_modules: false}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.23.x', nested_modules: false}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.24.x', nested_modules: true}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.25.x', nested_modules: true}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.26.x', nested_modules: true}
-          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.27.x', nested_modules: true}
-          - {os: windows-latest, go-version: '1.27.x', nested_modules: true}
+          - {module-role: root-0, module-owner: 0, root-partition: 0}
+          - {module-role: root-1, module-owner: 0, root-partition: 1}
+          - {module-role: root-2, module-owner: 0, root-partition: 2}
+          - {module-role: root-3, module-owner: 0, root-partition: 3}
+          - {module-role: root-4, module-owner: 0, root-partition: 4}
+          - {module-role: root-5, module-owner: 0, root-partition: 5}
+          - {module-role: root-6, module-owner: 0, root-partition: 6}
+          - {module-role: root-7, module-owner: 0, root-partition: 7}
+          - {module-role: root-8, module-owner: 0, root-partition: 8}
+          - {module-role: root-9, module-owner: 0, root-partition: 9}
+          - {module-role: root-10, module-owner: 0, root-partition: 10}
+          - {module-role: root-11, module-owner: 0, root-partition: 11}
+          - {module-role: root-12, module-owner: 0, root-partition: 12}
+          - {module-role: root-13, module-owner: 0, root-partition: 13}
+          - {module-role: root-14, module-owner: 0, root-partition: 14}
+          - {module-role: root-15, module-owner: 0, root-partition: 15}
+          - {module-role: profile, module-owner: 1, root-partition: -1}
+          - {module-role: other, module-owner: 2, root-partition: -1}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large]}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v7
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
           go-version: ${{ matrix.go-version }}
-          cache: true
 
       - name: Setup Python (Windows)
         if: runner.os == 'Windows'
@@ -283,17 +379,18 @@ jobs:
 
       - name: Install LLVM 22 (Ubuntu)
         if: runner.os == 'Linux'
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
 
       - name: Install LLVM 22 (Windows)
         if: runner.os == 'Windows'
         uses: ./.github/actions/setup-windows-llvm22
 
+      - name: Install required 386 execution runtime
+        if: runner.os == 'Linux'
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+
       - name: LLVM tools info
         shell: bash
         run: |
@@ -302,52 +399,69 @@ jobs:
           command -v clang
           clang --version
 
+      - name: Setup required wasm execution runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+
       - name: Go test (Ubuntu)
         if: runner.os != 'Windows'
-        run: go test ./...
+        run: bash scripts/test-module-ci.sh test execute ${{ matrix.module-owner }} ${{ matrix.root-partition }}
 
-      - name: Go test (cmd/plan9asm, Ubuntu)
-        if: runner.os != 'Windows' && matrix.nested_modules
-        run: go test ./...
-        working-directory: cmd/plan9asm
-
-      - name: Go test (cmd/plan9asmll, Ubuntu)
-        if: runner.os != 'Windows' && matrix.nested_modules
-        run: go test ./...
-        working-directory: cmd/plan9asmll
-
-      - name: Go test with coverage (Windows)
-        if: runner.os == 'Windows' && matrix.go-version == '1.27.x'
+      - name: Required exact downloaded AMD64 numerical fixture
+        if: runner.os == 'Linux' && matrix.go-version == '1.27.2' && matrix.module-owner == 2
         shell: bash
         run: |
           set -euo pipefail
-          go test ./... -coverprofile=coverage-windows-root.out
-          (cd cmd/plan9asm && go test ./... -coverprofile=../../coverage-windows-plan9asm.out)
-          (cd cmd/plan9asmll && go test ./... -coverprofile=../../coverage-windows-plan9asmll.out)
+          test "$(go env GOHOSTOS)/$(go env GOHOSTARCH)" = linux/amd64
+          scope='^TestAMD64DownloadedFixedLocalLLVM22Numerical$'
+          go test ./gotoolprofile -list="$scope" | grep -Fx 'TestAMD64DownloadedFixedLocalLLVM22Numerical'
+          go test ./gotoolprofile -run="$scope" -count=1 -timeout=10m
+
+      - name: Retain complete module owner evidence (Ubuntu)
+        if: ${{ !cancelled() && runner.os != 'Windows' }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: module-test-${{ matrix.go-version }}-${{ matrix.module-role }}
+          path: _out/module-test/
+          if-no-files-found: error
+
+  # Complete CLI suites need independent job budgets instead of sharing the
+  # remaining-package owner's root suite and current numerical fixture.
+  nested-cli:
+    needs: ci_policy
+    name: test (ubuntu-latest, ${{ matrix.go-version }}, ${{ matrix.module }})
+    strategy:
+      fail-fast: false
+      matrix:
+        go-version: ['1.24.x', '1.25.x', '1.26.x', '1.27.2']
+        module: [plan9asm, plan9asmll]
 
-      - name: Go test (Windows)
-        if: runner.os == 'Windows' && matrix.go-version != '1.27.x'
-        shell: bash
-        run: |
-          set -euo pipefail
-          go test ./...
-          (cd cmd/plan9asm && go test ./...)
-          (cd cmd/plan9asmll && go test ./...)
+    uses: ./.github/workflows/linux-cli-module.yml
+    with:
+      module: ${{ matrix.module }}
+      go-version: ${{ matrix.go-version }}
+      flavor: test
 
-      - name: Upload Windows coverage to Codecov
-        if: runner.os == 'Windows' && matrix.go-version == '1.27.x'
-        uses: codecov/codecov-action@v7
-        with:
-          use_oidc: true
-          files: ./coverage-windows-root.out,./coverage-windows-plan9asm.out,./coverage-windows-plan9asmll.out
-          disable_search: true
-          flags: windows
-          name: windows-go1.27
-          fail_ci_if_error: true
-          verbose: true
+
+  # Each module independently executes its complete inventory; only its strict
+  # root/profile/remaining-package aggregate may publish coverage.
+  windows-module:
+    needs: ci_policy
+    name: test (windows-latest, 1.27.2, ${{ matrix.module }})
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        module: [root, plan9asm, plan9asmll]
+    uses: ./.github/workflows/windows-module.yml
+    with:
+      module: ${{ matrix.module }}
 
   arm-scan:
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    needs: ci_policy
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
     strategy:
       fail-fast: false
       matrix:
@@ -364,23 +478,14 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Install LLVM 22
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          for attempt in 1 2 3; do
-            sudo apt-get update && sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev && break
-            if [ "$attempt" -eq 3 ]; then
-              exit 1
-            fi
-            sleep 5
-          done
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
 
       - name: ARM scan gate
         env:
@@ -407,31 +512,116 @@ jobs:
           PY
 
   race:
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    needs: ci_policy
+    name: race (${{ matrix.module-role }})
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 75
+    strategy:
+      fail-fast: false
+      matrix:
+        module-role: [root-0, root-1, root-2, root-3, root-4, root-5, root-6, root-7,
+          root-8, root-9, root-10, root-11, root-12, root-13, root-14, root-15,
+          root-16, root-17, root-18, root-19, root-20, root-21, root-22, root-23,
+          root-24, root-25, root-26, root-27, root-28, root-29, root-30, root-31,
+          profile, other]
+        include:
+          - {module-role: root-0, module-owner: 0, root-partition: 0}
+          - {module-role: root-1, module-owner: 0, root-partition: 1}
+          - {module-role: root-2, module-owner: 0, root-partition: 2}
+          - {module-role: root-3, module-owner: 0, root-partition: 3}
+          - {module-role: root-4, module-owner: 0, root-partition: 4}
+          - {module-role: root-5, module-owner: 0, root-partition: 5}
+          - {module-role: root-6, module-owner: 0, root-partition: 6}
+          - {module-role: root-7, module-owner: 0, root-partition: 7}
+          - {module-role: root-8, module-owner: 0, root-partition: 8}
+          - {module-role: root-9, module-owner: 0, root-partition: 9}
+          - {module-role: root-10, module-owner: 0, root-partition: 10}
+          - {module-role: root-11, module-owner: 0, root-partition: 11}
+          - {module-role: root-12, module-owner: 0, root-partition: 12}
+          - {module-role: root-13, module-owner: 0, root-partition: 13}
+          - {module-role: root-14, module-owner: 0, root-partition: 14}
+          - {module-role: root-15, module-owner: 0, root-partition: 15}
+          - {module-role: root-16, module-owner: 0, root-partition: 16}
+          - {module-role: root-17, module-owner: 0, root-partition: 17}
+          - {module-role: root-18, module-owner: 0, root-partition: 18}
+          - {module-role: root-19, module-owner: 0, root-partition: 19}
+          - {module-role: root-20, module-owner: 0, root-partition: 20}
+          - {module-role: root-21, module-owner: 0, root-partition: 21}
+          - {module-role: root-22, module-owner: 0, root-partition: 22}
+          - {module-role: root-23, module-owner: 0, root-partition: 23}
+          - {module-role: root-24, module-owner: 0, root-partition: 24}
+          - {module-role: root-25, module-owner: 0, root-partition: 25}
+          - {module-role: root-26, module-owner: 0, root-partition: 26}
+          - {module-role: root-27, module-owner: 0, root-partition: 27}
+          - {module-role: root-28, module-owner: 0, root-partition: 28}
+          - {module-role: root-29, module-owner: 0, root-partition: 29}
+          - {module-role: root-30, module-owner: 0, root-partition: 30}
+          - {module-role: root-31, module-owner: 0, root-partition: 31}
+          - {module-role: profile, module-owner: 1, root-partition: -1}
+          - {module-role: other, module-owner: 2, root-partition: -1}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v7
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
 
       - name: Install LLVM 22
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
+
+      - name: Install required 386 execution runtime
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+
+      - name: Setup required wasm execution runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
 
       - name: Go test (race)
-        run: go test -race ./...
+        run: bash scripts/test-module-ci.sh race execute ${{ matrix.module-owner }} ${{ matrix.root-partition }}
+
+      - name: Retain complete module race owner evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: module-race-1.27.2-${{ matrix.module-role }}
+          path: _out/module-race/
+          if-no-files-found: error
 
   coverage:
-    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-24.04' }}
+    needs: ci_policy
+    name: coverage (${{ matrix.module-role }})
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        module-role: [root-0, root-1, root-2, root-3, root-4, root-5, root-6, root-7,
+          root-8, root-9, root-10, root-11, root-12, root-13, root-14, root-15, profile, other]
+        include:
+          - {module-role: root-0, module-owner: 0, root-partition: 0}
+          - {module-role: root-1, module-owner: 0, root-partition: 1}
+          - {module-role: root-2, module-owner: 0, root-partition: 2}
+          - {module-role: root-3, module-owner: 0, root-partition: 3}
+          - {module-role: root-4, module-owner: 0, root-partition: 4}
+          - {module-role: root-5, module-owner: 0, root-partition: 5}
+          - {module-role: root-6, module-owner: 0, root-partition: 6}
+          - {module-role: root-7, module-owner: 0, root-partition: 7}
+          - {module-role: root-8, module-owner: 0, root-partition: 8}
+          - {module-role: root-9, module-owner: 0, root-partition: 9}
+          - {module-role: root-10, module-owner: 0, root-partition: 10}
+          - {module-role: root-11, module-owner: 0, root-partition: 11}
+          - {module-role: root-12, module-owner: 0, root-partition: 12}
+          - {module-role: root-13, module-owner: 0, root-partition: 13}
+          - {module-role: root-14, module-owner: 0, root-partition: 14}
+          - {module-role: root-15, module-owner: 0, root-partition: 15}
+          - {module-role: profile, module-owner: 1, root-partition: -1}
+          - {module-role: other, module-owner: 2, root-partition: -1}
     permissions:
       contents: read
       id-token: write
@@ -441,37 +631,307 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Setup Go
+        timeout-minutes: 10
         uses: ./.github/actions/setup-go
         with:
-          go-version: '1.27.x'
-          cache: true
+          go-version: '1.27.2'
 
       - name: Install LLVM 22
-        run: |
-          echo "deb http://apt.llvm.org/$(lsb_release -cs)/ llvm-toolchain-$(lsb_release -cs)-22 main" | sudo tee /etc/apt/sources.list.d/llvm.list
-          wget -qO- https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/llvm-snapshot.asc >/dev/null
-          sudo apt-get update
-          sudo apt-get install -y llvm-22-dev clang-22 libclang-22-dev lld-22 libunwind-22-dev libc++-22-dev
-          echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
 
-      - name: Go test with coverage
-        run: |
-          go test ./... -coverprofile=coverage-root.out
-          go tool cover -func=coverage-root.out | tail -n 1
+      - name: Install required 386 execution runtime
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
 
-      - name: Go test with coverage (cmd/plan9asm)
-        run: |
-          go test ./... -coverprofile=coverage-plan9asm.out
-          go tool cover -func=coverage-plan9asm.out | tail -n 1
-        working-directory: cmd/plan9asm
+      - name: Setup required wasm execution runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
 
-      - name: Go test with coverage (cmd/plan9asmll)
-        run: |
-          go test ./... -coverprofile=coverage-plan9asmll.out
-          go tool cover -func=coverage-plan9asmll.out | tail -n 1
-        working-directory: cmd/plan9asmll
+      - name: Go test with coverage
+        run: bash scripts/test-module-ci.sh coverage execute ${{ matrix.module-owner }} ${{ matrix.root-partition }}
 
+      - name: Retain complete module coverage owner evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: module-coverage-1.27.2-${{ matrix.module-role }}
+          path: _out/module-coverage/
+          if-no-files-found: error
+
+  # Coverage-instrumented CLI suites retain their own complete command budget,
+  # independent of the main module and of the ordinary nested CLI matrix.
+  nested-cli-coverage:
+    needs: ci_policy
+    name: coverage (ubuntu-latest, 1.27.2, ${{ matrix.module }})
+    strategy:
+      fail-fast: false
+      matrix:
+        module: [plan9asm, plan9asmll]
+
+    uses: ./.github/workflows/linux-cli-module.yml
+    with:
+      module: ${{ matrix.module }}
+      go-version: '1.27.2'
+      flavor: coverage
+
+  module-completion:
+    needs: [test, nested-cli, race, coverage, nested-cli-coverage]
+    if: ${{ !cancelled() }}
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - {flavor: test, go-version: '1.20.x'}
+          - {flavor: test, go-version: '1.21.x'}
+          - {flavor: test, go-version: '1.22.x'}
+          - {flavor: test, go-version: '1.23.x'}
+          - {flavor: test, go-version: '1.24.x'}
+          - {flavor: test, go-version: '1.25.x'}
+          - {flavor: test, go-version: '1.26.x'}
+          - {flavor: test, go-version: '1.27.2'}
+          - {flavor: race, go-version: '1.27.2'}
+          - {flavor: coverage, go-version: '1.27.2'}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: ${{ matrix.go-version }}
+      - name: Install LLVM 22
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
+      - name: Install required 386 execution runtime
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+      - name: Setup required wasm execution runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+      - name: Download root part 0
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-0
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0000
+      - name: Download root part 1
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-1
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0001
+      - name: Download root part 2
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-2
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0002
+      - name: Download root part 3
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-3
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0003
+      - name: Download root part 4
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-4
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0004
+      - name: Download root part 5
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-5
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0005
+      - name: Download root part 6
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-6
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0006
+      - name: Download root part 7
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-7
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0007
+      - name: Download root part 8
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-8
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0008
+      - name: Download root part 9
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-9
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0009
+      - name: Download root part 10
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-10
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0010
+      - name: Download root part 11
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-11
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0011
+      - name: Download root part 12
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-12
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0012
+      - name: Download root part 13
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-13
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0013
+      - name: Download root part 14
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-14
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0014
+      - name: Download root part 15
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-15
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0015
+      - name: Download root part 16
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-16
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0016
+      - name: Download root part 17
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-17
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0017
+      - name: Download root part 18
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-18
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0018
+      - name: Download root part 19
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-19
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0019
+      - name: Download root part 20
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-20
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0020
+      - name: Download root part 21
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-21
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0021
+      - name: Download root part 22
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-22
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0022
+      - name: Download root part 23
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-23
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0023
+      - name: Download root part 24
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-24
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0024
+      - name: Download root part 25
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-25
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0025
+      - name: Download root part 26
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-26
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0026
+      - name: Download root part 27
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-27
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0027
+      - name: Download root part 28
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-28
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0028
+      - name: Download root part 29
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-29
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0029
+      - name: Download root part 30
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-30
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0030
+      - name: Download root part 31
+        if: ${{ !cancelled() && matrix.flavor == 'race' }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-root-31
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0000/part-0031
+      - name: Download profile owner
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-profile
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0001
+      - name: Download remaining-package owner
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: module-${{ matrix.flavor }}-${{ matrix.go-version }}-other
+          path: _out/module-${{ matrix.flavor }}-owners/owner-0002
+      - name: Check complete actual module inventory and coverage
+        if: ${{ !cancelled() }}
+        run: bash scripts/test-module-ci.sh ${{ matrix.flavor }} complete
+      - name: Retain independent aggregate evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: module-verified-${{ matrix.flavor }}-${{ matrix.go-version }}
+          path: _out/module-${{ matrix.flavor }}-verified/
+          if-no-files-found: error
+      - name: Show complete module coverage
+        if: matrix.flavor == 'coverage'
+        run: go tool cover -func=coverage-root.out | tail -n 1
       - name: Upload coverage to Codecov
+        if: matrix.flavor == 'coverage'
         uses: codecov/codecov-action@v7
         with:
           use_oidc: true
@@ -481,3 +941,6 @@ jobs:
           name: ubuntu-go1.27
           fail_ci_if_error: false
           verbose: true
+      - name: Require complete CLI coverage
+        if: ${{ !cancelled() && matrix.flavor == 'coverage' }}
+        run: test '${{ needs['nested-cli-coverage'].result }}' = success
diff --git a/.github/workflows/linux-cli-module.yml b/.github/workflows/linux-cli-module.yml
new file mode 100644
index 000000000..aad38ca85
--- /dev/null
+++ b/.github/workflows/linux-cli-module.yml
@@ -0,0 +1,166 @@
+name: Complete Linux CLI module
+
+on:
+  workflow_call:
+    inputs:
+      module:
+        required: true
+        type: string
+      go-version:
+        required: true
+        type: string
+      flavor:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  root-parts:
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        part: [0, 1, 2, 3]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: ${{ inputs.go-version }}
+      - name: Install LLVM 22 and cross compilers
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
+      - name: Install required execution runtimes
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+      - name: LLVM tools info
+        shell: bash
+        run: |
+          command -v llc
+          llc --version
+          command -v clang
+          clang --version
+      - name: Setup required wasm execution runtime
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-node22
+      - name: Execute disjoint root assignment
+        run: bash scripts/test-linux-cli-module-ci.sh ${{ inputs.module }} ${{ inputs.flavor }} execute 0 ${{ matrix.part }}
+      - name: Retain actual root evidence
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-root-${{ matrix.part }}
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-root-${{ matrix.part }}/
+          if-no-files-found: error
+
+      # Both CLIs currently have only their root package. Keep the two real
+      # empty-role receipts without allocating separate empty runner jobs.
+      # Any future profile/rest packages still execute, never invent a pass.
+      - name: Execute complete profile owner
+        if: ${{ !cancelled() && matrix.part == 0 }}
+        run: bash scripts/test-linux-cli-module-ci.sh ${{ inputs.module }} ${{ inputs.flavor }} execute 1 -1
+      - name: Retain actual profile evidence
+        if: ${{ always() && matrix.part == 0 }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-owner-1
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owner-1/
+          if-no-files-found: error
+      - name: Execute complete remaining-package owner
+        if: ${{ !cancelled() && matrix.part == 0 }}
+        run: bash scripts/test-linux-cli-module-ci.sh ${{ inputs.module }} ${{ inputs.flavor }} execute 2 -1
+      - name: Retain actual remaining-package evidence
+        if: ${{ always() && matrix.part == 0 }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-owner-2
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owner-2/
+          if-no-files-found: error
+
+  complete:
+    needs: root-parts
+    if: ${{ !cancelled() }}
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 30
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: ${{ inputs.go-version }}
+      - name: Install LLVM 22 and cross compilers
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross gcc-aarch64-linux-gnu
+      - name: Install required execution runtimes
+        timeout-minutes: 5
+        run: bash scripts/install-ci-qemu.sh
+      - name: LLVM tools info
+        shell: bash
+        run: |
+          command -v llc
+          llc --version
+          command -v clang
+          clang --version
+      - name: Setup required wasm execution runtime
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-node22
+      - name: Download root part 0
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-root-0
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0000/part-0000
+      - name: Download root part 1
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-root-1
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0000/part-0001
+      - name: Download root part 2
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-root-2
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0000/part-0002
+      - name: Download root part 3
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-root-3
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0000/part-0003
+      - name: Download profile owner
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-owner-1
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0001
+      - name: Download remaining-package owner
+        if: ${{ !cancelled() }}
+        uses: actions/download-artifact@v8
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-owner-2
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-owners/owner-0002
+      - name: Verify complete CLI module
+        if: ${{ !cancelled() }}
+        run: bash scripts/test-linux-cli-module-ci.sh ${{ inputs.module }} ${{ inputs.flavor }} complete
+      - name: Retain independent completion evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: linux-cli-${{ inputs.module }}-${{ inputs.go-version }}-${{ inputs.flavor }}-completion
+          path: _out/linux-cli-${{ inputs.module }}-${{ inputs.flavor }}-verified/
+          if-no-files-found: error
+      - name: Show complete CLI coverage
+        if: inputs.flavor == 'coverage'
+        run: go tool cover -func=coverage-${{ inputs.module }}.out | tail -n 1
+        working-directory: cmd/${{ inputs.module }}
+      - name: Require successful CLI owners
+        if: ${{ !cancelled() }}
+        run: test '${{ needs.root-parts.result }}' = success
diff --git a/.github/workflows/runtime-integration.yml b/.github/workflows/runtime-integration.yml
new file mode 100644
index 000000000..8a5725fba
--- /dev/null
+++ b/.github/workflows/runtime-integration.yml
@@ -0,0 +1,154 @@
+name: SDK/runtime integration
+
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '17 3 * * 1'
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  ci_policy:
+    name: CI policy preflight
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 20
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install LLVM 22
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
+
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+
+      - name: Setup verified policy runtime
+        uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+
+      - name: Workflow scheduling regression tests
+        run: node --test .github/scripts/priority-*.test.cjs
+
+      - name: CI policy tests
+        run: go test . -run '^TestCI' -count=1
+
+  benchmark:
+    needs: ci_policy
+    name: complete standard-library SDK/runtime compile (Go 1.27, LLVM 22)
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && fromJSON('["qiniu", "ubuntu-24.04-large"]') || 'ubuntu-latest' }}
+    timeout-minutes: 35
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install LLVM 22
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
+
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+
+      - name: Translate and compile standard-library assembly
+        env:
+          PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS: '300'
+          PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS: '900'
+        run: scripts/benchmark-compile.sh
+
+      - name: Upload benchmark report
+        if: always()
+        uses: actions/upload-artifact@v6
+        with:
+          name: compile-benchmark
+          path: _out/compile-benchmark
+          if-no-files-found: error
+
+  stdlib-corpus:
+    needs: ci_policy
+    name: complete stdlib source/object corpus (${{ matrix.os }}, Go ${{ matrix.go-version }})
+    runs-on: ${{ github.repository_owner == 'xgo-dev' && matrix.runner || matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Linux is the authoritative cross-target corpus gate. Each
+          # unversioned Linux architecture and wasm target expands to every
+          # setting supported by that Go toolchain in check-stdlib-corpus.sh.
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.20.x', prebuild_tool: true, targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.21.x', prebuild_tool: true, targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.22.x', prebuild_tool: true, targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.23.x', prebuild_tool: true, targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.24.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.25.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.26.x', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          - {os: ubuntu-latest, runner: [qiniu, ubuntu-24.04-large], go-version: '1.27.2', targets: 'linux/386,linux/amd64,linux/arm,linux/arm64,darwin/amd64,darwin/arm64,windows/386,windows/amd64,windows/arm64,js/wasm,wasip1/wasm'}
+          # Native hosts are auxiliary integration checks on the latest Go.
+          - {os: macos-latest, go-version: '1.27.2', targets: 'darwin/amd64,darwin/arm64'}
+          - {os: windows-latest, go-version: '1.27.2', targets: 'windows/386,windows/amd64,windows/arm64'}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+
+      - name: Install LLVM 22 (Ubuntu)
+        if: runner.os == 'Linux'
+        timeout-minutes: 14
+        run: bash scripts/install-ci-llvm22-ubuntu.sh
+
+      - name: Install LLVM 22 (macOS)
+        if: runner.os == 'macOS'
+        run: |
+          brew install llvm@22
+          echo "PATH=$(brew --prefix llvm@22)/bin:$PATH" >> "$GITHUB_ENV"
+
+      - name: Setup Python (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/setup-python@v7
+        with:
+          python-version: '3.x'
+
+      - name: Install LLVM 22 (Windows)
+        if: runner.os == 'Windows'
+        uses: ./.github/actions/setup-windows-llvm22
+
+      - name: Setup Go for corpus tool build
+        if: matrix.prebuild_tool
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+
+      - name: Build corpus tool for older Go lane
+        if: matrix.prebuild_tool
+        shell: bash
+        run: |
+          tool="$RUNNER_TEMP/plan9asm"
+          go build -C cmd/plan9asm -o "$tool" .
+          echo "PLAN9ASM_CMD=$tool" >> "$GITHUB_ENV"
+
+      - name: Setup Go
+        timeout-minutes: 10
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: ${{ matrix.go-version }}
+
+      - name: Stdlib asm corpus gate
+        shell: bash
+        env:
+          PLAN9ASM_CORPUS_TARGETS: ${{ matrix.targets }}
+        run: |
+          chmod +x scripts/check-stdlib-corpus.sh
+          scripts/check-stdlib-corpus.sh
diff --git a/.github/workflows/windows-module.yml b/.github/workflows/windows-module.yml
new file mode 100644
index 000000000..a1109694a
--- /dev/null
+++ b/.github/workflows/windows-module.yml
@@ -0,0 +1,256 @@
+name: Complete Windows module
+
+on:
+  workflow_call:
+    inputs:
+      module:
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  PLAN9ASM_AVX512_RUNTIME: auto
+
+jobs:
+  root-parts:
+    runs-on: windows-latest
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        part: ${{ fromJSON(inputs.module == 'root' && '[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]' || '[0,1,2,3]') }}
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+        timeout-minutes: 10
+      - uses: ./.github/actions/setup-windows-llvm22
+      - uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+      - name: Execute disjoint root assignment
+        shell: bash
+        run: bash scripts/test-windows-module-ci.sh ${{ inputs.module }} execute 0 ${{ matrix.part }}
+      - name: Retain actual root evidence
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-${{ matrix.part }}
+          path: _out/windows-module-${{ inputs.module }}/
+          if-no-files-found: error
+
+  other-owners:
+    runs-on: windows-latest
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        owner: [1, 2]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+        timeout-minutes: 10
+      - uses: ./.github/actions/setup-windows-llvm22
+      - uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+      - name: Execute complete profile or remaining packages
+        shell: bash
+        run: bash scripts/test-windows-module-ci.sh ${{ inputs.module }} execute ${{ matrix.owner }} -1
+      - name: Retain actual package evidence
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-owner-${{ matrix.owner }}
+          path: _out/windows-module-${{ inputs.module }}/
+          if-no-files-found: error
+
+  complete:
+    needs: [root-parts, other-owners]
+    if: ${{ !cancelled() }}
+    runs-on: windows-latest
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v7
+      - uses: ./.github/actions/setup-go
+        with:
+          go-version: '1.27.2'
+        timeout-minutes: 10
+      - uses: ./.github/actions/setup-windows-llvm22
+      - uses: ./.github/actions/setup-node22
+        timeout-minutes: 10
+      - name: Download root part 0
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-0
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0000
+      - name: Download root part 1
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-1
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0001
+      - name: Download root part 2
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-2
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0002
+      - name: Download root part 3
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-3
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0003
+      - name: Download root part 4
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-4
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0004
+      - name: Download root part 5
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-5
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0005
+      - name: Download root part 6
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-6
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0006
+      - name: Download root part 7
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-7
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0007
+      - name: Download root part 8
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-8
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0008
+      - name: Download root part 9
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-9
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0009
+      - name: Download root part 10
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-10
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0010
+      - name: Download root part 11
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-11
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0011
+      - name: Download root part 12
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-12
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0012
+      - name: Download root part 13
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-13
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0013
+      - name: Download root part 14
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-14
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0014
+      - name: Download root part 15
+        if: ${{ inputs.module == 'root' }}
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-root-15
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0000/part-0015
+      - name: Download profile owner
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-owner-1
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0001
+      - name: Download remaining-package owner
+        uses: actions/download-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-owner-2
+          path: _out/windows-module-${{ inputs.module }}-owners/owner-0002
+      - name: Verify complete module and publish coverage
+        shell: bash
+        run: bash scripts/test-windows-module-ci.sh ${{ inputs.module }} complete
+      - name: Retain independent completion evidence
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v6
+        with:
+          name: windows-module-${{ inputs.module }}-completion
+          path: _out/windows-module-${{ inputs.module }}-verified/
+          if-no-files-found: error
+      - name: Set up compatible Python for coverage upload
+        id: codecov_python
+        uses: actions/setup-python@v7
+        with:
+          python-version: '3.13'
+      - name: Check Codecov Python and pip ownership
+        shell: bash
+        env:
+          CODECOV_PYTHON: ${{ steps.codecov_python.outputs.python-path }}
+        run: |
+          python - <<'PY'
+          import os
+          import shutil
+          import subprocess
+          import sys
+          if sys.version_info[:2] != (3, 13):
+              raise SystemExit("Codecov upload requires Python 3.13")
+          if not os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"]):
+              raise SystemExit("Codecov Python differs from setup-python output")
+          pip = shutil.which("pip")
+          expected = os.path.join(os.path.dirname(sys.executable), "Scripts", "pip.exe")
+          if not pip or not os.path.samefile(pip, expected):
+              raise SystemExit("Codecov pip is not owned by the selected Python")
+          print("Codecov upload Python:", sys.version, sys.executable, flush=True)
+          print("Codecov upload pip:", pip, flush=True)
+          subprocess.run([pip, "--version"], check=True)
+          PY
+      - name: Upload verified complete Windows module coverage
+        uses: codecov/codecov-action@v7
+        with:
+          use_pypi: true
+          use_oidc: true
+          files: ./coverage-windows-${{ inputs.module }}.out
+          disable_search: true
+          flags: windows
+          name: windows-go1.27-${{ inputs.module }}
+          fail_ci_if_error: true
+          verbose: true
+      - name: Check installed Codecov CLI ownership
+        shell: bash
+        env:
+          CODECOV_PYTHON: ${{ steps.codecov_python.outputs.python-path }}
+        run: |
+          python - <<'PY'
+          import os
+          import shutil
+          import subprocess
+          import sys
+          if not os.path.samefile(sys.executable, os.environ["CODECOV_PYTHON"]):
+              raise SystemExit("Codecov Python changed during upload")
+          cli = shutil.which("codecovcli")
+          expected = os.path.join(os.path.dirname(sys.executable), "Scripts", "codecovcli.exe")
+          if not cli or not os.path.samefile(cli, expected):
+              raise SystemExit("Codecov CLI is not owned by the selected Python")
+          print("Codecov upload CLI:", cli, flush=True)
+          subprocess.run([cli, "--help"], check=True)
+          PY
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..bbe7e64e2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/_out/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 000000000..dfffd6c89
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,61 @@
+# plan9asm development
+
+plan9asm translates Go Plan 9 assembly to LLVM IR. This repository owns the
+translator, shared Go source/tool observations, official instruction coverage
+and independent regression tests. External scanning, ledgers and compatibility
+batches live in [llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm).
+
+## Start here
+
+1. Inspect `git status --short`, `git worktree list` and `git remote -v`.
+   Preserve existing work and reuse a persistent idle worktree.
+2. Read [architecture](docs/development/architecture.md), [current work](docs/development/current-work.md),
+   [instruction families](docs/development/instructions.md) and
+   [validation](docs/development/validation.md) for the task.
+
+## Rules
+
+- Push only to an allowed `cpunion` or `dastai` fork. Create/update the
+  contribution PR; do not directly push, merge, approve or close upstream PRs.
+- Use current Go 1.27 and LLVM 22. Never fall back to another LLVM version;
+  missing required tools/backends fail, never skip.
+- Support all five architectures: 386, amd64, arm, arm64 and wasm.
+  Host-inapplicable runtime tests require an explicit cross-runtime counterpart.
+  Never generate LLVM `blockaddress` for wasm.
+- Use TDD. Consult complete official Go tables and implement typed instruction
+  families and operand formats. Each ecosystem-discovered defect must have an
+  independent regression and a rule-class fix, not a library-specific patch.
+- Run tests with Go while llgo support is incomplete; do not add `!llgo` tags.
+- Keep rejection, source context, translation, LLVM compilation and executed
+  semantics distinct. Infrastructure failures never establish source rejection.
+- Use `apply_patch`, readable multi-line code and moderate blank lines, then
+  `gofmt`. Release LLVM objects and owned subprocess resources promptly.
+- Do not commit private paths/hosts, package caches, binaries or reports.
+  Keep evidence under ignored `_out/`; preserve failed reports as failed.
+- Freeze source and tools during validation, even documentation. Never edit a
+  running snapshot or reuse its report to certify a changed revision.
+- Commit verified batches promptly. Stage repairs in the allowed fork; retain
+  draft status until current-head tests, CI, review and coverage pass.
+- Before publishing test-helper or workflow changes, run the complete Node
+  policy suite and the Go `ci_policy` selector described in validation.
+
+## Commands
+
+After selecting the tools documented in validation:
+
+```sh
+go test . -run '<focused-family-regex>' -count=1
+go test ./... -count=1 -timeout=45m
+(cd cmd/plan9asm && go test ./... -count=1)
+(cd cmd/plan9asmll && go test ./... -count=1)
+scripts/check-go-asm-coverage.sh
+scripts/check-arm64-plan9-corpus.sh
+scripts/check-stdlib-corpus.sh --instructions-only
+```
+
+Instruction checks retain complete WASM source/object compilation. Default
+full-source corpus and strict benchmark belong to the independent
+[SDK/runtime integration workflow](docs/development/validation.md#official-forms-and-benchmark).
+
+Do not reintroduce external discovery jobs or ledger gates into translator CI.
+Keep this entry point short; durable procedures belong in linked documents.
diff --git a/README.md b/README.md
index 4eb8494f1..bcdd983c6 100644
--- a/README.md
+++ b/README.md
@@ -40,8 +40,9 @@ Plan 9 assembly parser and LLVM IR translator, extracted as an independent modul
   releases are intentionally rejected instead of used as fallbacks.
 - `TranslateModule` builds an in-memory `llvm.Module` (`github.com/xgo-dev/llvm`).
 - `Translate` keeps compatibility and returns textual IR from that module.
-- Root module dependency stays small (`goplus/llvm`).
-- `golang.org/x/tools/go/packages` is used only in `cmd/plan9asmll` submodule.
+- The root module uses `github.com/xgo-dev/llvm` for LLVM bindings.
+- Both `cmd/plan9asm` and `cmd/plan9asmll` use `golang.org/x/tools/go/packages`
+  in their separate modules.
 - `cmd/plan9asm` does not depend on `llgo/internal/build` or `llgo/internal/packages`.
 
 ## Quick test
@@ -120,6 +121,18 @@ go run -C cmd/plan9asmll . \
   -report /tmp/plan9asmll-x86.json
 ```
 
+For an ordinary external module, `-feature-profile` explicitly consumes a
+private `actual_go_cpu_profile_consumer_v1` invocation artifact. It re-observes
+the actual Go marker/environment/tool identity, loads that same environment,
+checks selected source hashes and package-role macros, and records CPP/LLVM
+output hashes. Source directories and module replacements must match the
+artifact's exact source root. Special and test-only package roles remain
+outside this mode. Without the flag, existing CLI behavior is unchanged.
+The external runner in [llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm)
+owns module discovery, ledger records and third-party compatibility CI. It pins
+this translator and the shared `gotoolprofile` package; translation/object
+checks remain distinct from operand-form and runtime coverage.
+
 ## Output behavior
 
 - Every asm file is printed with explicit status (`OK` or `FAIL`).
diff --git a/amd64_abi.go b/amd64_abi.go
new file mode 100644
index 000000000..c227c591d
--- /dev/null
+++ b/amd64_abi.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) abi0CallStackPtr(off int64) (string, error) {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return "", fmt.Errorf("ABI0 call stack: %w", err)
+	}
+	addr := sp
+	if off != 0 {
+		next := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", next, sp, off)
+		addr = "%" + next
+	}
+	ptr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", ptr, addr)
+	return "%" + ptr, nil
+}
+
+func (c *amd64Ctx) abi0CallArgs(callee string, sig FuncSig) ([]string, error) {
+	slotsByArg := make([][]FrameSlot, len(sig.Args))
+	for _, slot := range sig.Frame.Params {
+		if slot.Index < 0 || slot.Index >= len(sig.Args) {
+			return nil, fmt.Errorf("amd64 call %q: ABI0 parameter at +%d has invalid argument index %d", callee, slot.Offset, slot.Index)
+		}
+		slotsByArg[slot.Index] = append(slotsByArg[slot.Index], slot)
+	}
+	args := make([]string, 0, len(sig.Args))
+	for argIndex, argType := range sig.Args {
+		slots := slotsByArg[argIndex]
+		if len(slots) == 0 {
+			return nil, fmt.Errorf("amd64 call %q: ABI0 argument %d has no frame slot", callee, argIndex)
+		}
+		if len(slots) == 1 && len(frameSlotFields(slots[0])) == 0 {
+			if slots[0].Type != argType {
+				return nil, fmt.Errorf("amd64 call %q: ABI0 argument %d frame type %s does not match %s", callee, argIndex, slots[0].Type, argType)
+			}
+			ptr, err := c.abi0CallStackPtr(slots[0].Offset)
+			if err != nil {
+				return nil, err
+			}
+			value := c.loadFPStorage(argType, ptr, ", align 1")
+			args = append(args, fmt.Sprintf("%s %s", argType, value))
+			continue
+		}
+		aggregate := "undef"
+		for _, slot := range slots {
+			if len(frameSlotFields(slot)) == 0 {
+				return nil, fmt.Errorf("amd64 call %q: ABI0 aggregate argument %d has a scalar frame slot", callee, argIndex)
+			}
+			ptr, err := c.abi0CallStackPtr(slot.Offset)
+			if err != nil {
+				return nil, err
+			}
+			value := c.loadFPStorage(slot.Type, ptr, ", align 1")
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %s%s\n", inserted, argType, aggregate, slot.Type, value, frameSlotExtractSuffix(slot))
+			aggregate = "%" + inserted
+		}
+		args = append(args, fmt.Sprintf("%s %s", argType, aggregate))
+	}
+	return args, nil
+}
+
+func (c *amd64Ctx) storeABI0CallResult(callee string, sig FuncSig, result string) error {
+	if len(sig.Frame.Results) == 0 {
+		return fmt.Errorf("amd64 call %q: ABI0 result %s has no frame slot", callee, sig.Ret)
+	}
+	fields, aggregate := parseLiteralStructFields(sig.Ret)
+	for _, slot := range sig.Frame.Results {
+		value := result
+		if aggregate {
+			if slot.Index < 0 || slot.Index >= len(fields) || fields[slot.Index] != slot.Type {
+				return fmt.Errorf("amd64 call %q: ABI0 result slot %d does not match %s", callee, slot.Index, sig.Ret)
+			}
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, sig.Ret, result, slot.Index)
+			value = "%" + extracted
+		} else if slot.Index != 0 || slot.Type != sig.Ret {
+			return fmt.Errorf("amd64 call %q: ABI0 scalar result frame does not match %s", callee, sig.Ret)
+		}
+		ptr, err := c.abi0CallStackPtr(slot.Offset)
+		if err != nil {
+			return err
+		}
+		c.storeFPStorage(slot.Type, value, ptr, ", align 1", "")
+	}
+	return nil
+}
diff --git a/amd64_abi0_anchor_test.go b/amd64_abi0_anchor_test.go
new file mode 100644
index 000000000..87668c8cd
--- /dev/null
+++ b/amd64_abi0_anchor_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestAMD64ABI0AnchorPreservesTailJumpRelocation(t *testing.T) {
+	args := make([]LLVMType, 15)
+	for i := range args {
+		args[i] = I32
+	}
+	for _, anchorName := range []string{"gcasmABI0Keep", "relocationKeep"} {
+		source := fmt.Sprintf("TEXT ·%s(SB),NOSPLIT,$0-0\n", anchorName) +
+			"JMP ·Fn(SB)\nJMP ·FnTwo(SB)\nJMP ·FnThree(SB)\n"
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs := map[string]FuncSig{
+			"example." + anchorName: {Name: "example." + anchorName, Ret: Void},
+			"example.Fn":            {Name: "example.Fn", Args: args, Ret: I32},
+			"example.FnTwo":         {Name: "example.FnTwo", Args: args, Ret: I32},
+			"example.FnThree":       {Name: "example.FnThree", Args: args, Ret: I32},
+		}
+		for _, target := range []struct {
+			goarch string
+			triple string
+		}{
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i386-apple-darwin"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			triple := target.triple
+			t.Run(anchorName+"/"+triple, func(t *testing.T) {
+				ir, err := Translate(file, Options{
+					Goarch: target.goarch, TargetTriple: triple,
+					ResolveSym: testResolveSym("example"), Sigs: sigs,
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, symbol := range []string{"example.Fn", "example.FnTwo", "example.FnThree"} {
+					if !strings.Contains(ir, "ptr @"+symbol) {
+						t.Fatalf("ABI0 anchor omitted direct symbol relocation for %s", symbol)
+					}
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc not found")
+				}
+				objdump := findLLVM22Tool("llvm-objdump")
+				if objdump == "" {
+					t.Fatal("LLVM 22 llvm-objdump not found")
+				}
+				dir := t.TempDir()
+				llPath := filepath.Join(dir, "anchor.ll")
+				object := filepath.Join(dir, "anchor.o")
+				if err := os.WriteFile(llPath, []byte(ir), 0644); err != nil {
+					t.Fatal(err)
+				}
+				if output, err := exec.Command(llc, "-mtriple="+triple, "-filetype=obj", llPath, "-o", object).CombinedOutput(); err != nil {
+					t.Fatalf("LLVM 22 object compile: %v\n%s", err, output)
+				}
+				output, err := exec.Command(objdump, "-dr", object).CombinedOutput()
+				if err != nil {
+					t.Fatalf("LLVM 22 object dump: %v\n%s", err, output)
+				}
+				if !regexp.MustCompile(`(?m)^\s*0: e9 `).Match(output) {
+					t.Fatalf("anchor is not an entry-point tail jump with target relocation:\n%s", output)
+				}
+				for _, symbol := range []string{"example.Fn", "example.FnTwo", "example.FnThree"} {
+					if !strings.Contains(string(output), symbol) {
+						t.Fatalf("object omitted relocation for %s:\n%s", symbol, output)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64NonAnchorStillRejectsUnmappedTailArguments(t *testing.T) {
+	const source = "TEXT ·forward(SB),NOSPLIT,$0-0\nJMP ·Fn(SB)\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	args := make([]LLVMType, 7)
+	for i := range args {
+		args[i] = I32
+	}
+	_, err = Translate(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: testResolveSym("example"),
+		Sigs: map[string]FuncSig{
+			"example.forward": {Name: "example.forward", Ret: Void},
+			"example.Fn":      {Name: "example.Fn", Args: args, Ret: I32},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "missing arg reg") {
+		t.Fatalf("unmapped non-anchor tail arguments unexpectedly accepted: %v", err)
+	}
+}
diff --git a/amd64_abi0_forward.go b/amd64_abi0_forward.go
new file mode 100644
index 000000000..2410abcfe
--- /dev/null
+++ b/amd64_abi0_forward.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+// inferX86ABI0Forwarder proves the complete straight-line adapter shape before
+// assigning a typed ABI0 signature to an indirect CALL. The final incoming
+// word is the code pointer, not an argument of the callback. This is structural
+// inference: no library, function or parameter names participate.
+func inferX86ABI0Forwarder(fn Func, sig FuncSig, goarch string) *FuncSig {
+	if goarch != "amd64" || len(sig.ArgRegs) != 0 || len(sig.Args) == 0 {
+		return nil
+	}
+	codeIndex := len(sig.Args) - 1
+	if sig.Args[codeIndex] != I64 && sig.Args[codeIndex] != Ptr {
+		return nil
+	}
+	var code FrameSlot
+	var params []FrameSlot
+	codeSlots := 0
+	for _, slot := range sig.Frame.Params {
+		if slot.Index == codeIndex {
+			code = slot
+			codeSlots++
+		} else {
+			params = append(params, slot)
+		}
+	}
+	if codeSlots != 1 || len(frameSlotFields(code)) != 0 {
+		return nil
+	}
+
+	instructions := x86ABI0ForwardInstructions(fn)
+	// Two instructions per copied slot, code-pointer load, CALL, then RET.
+	if len(instructions) != 2*len(params)+2*len(sig.Frame.Results)+3 {
+		return nil
+	}
+	for i, slot := range params {
+		load, store := instructions[2*i], instructions[2*i+1]
+		if !x86ABI0ForwardCopy(load, store, slot, true) ||
+			store.Args[1].Mem.Off != slot.Offset || slot.Offset >= code.Offset {
+			return nil
+		}
+	}
+	callIndex := 2*len(params) + 1
+	load, call := instructions[callIndex-1], instructions[callIndex]
+	if load.Op != "MOVQ" || len(load.Args) != 2 || load.Args[0].Kind != OpFP ||
+		load.Args[0].FPOffset != code.Offset || load.Args[1].Kind != OpReg ||
+		call.Op != "CALL" || len(call.Args) != 1 || call.Args[0].Kind != OpReg ||
+		call.Args[0].Reg != load.Args[1].Reg {
+		return nil
+	}
+	results := append([]FrameSlot(nil), sig.Frame.Results...)
+	for i, slot := range results {
+		load, store := instructions[callIndex+1+2*i], instructions[callIndex+2+2*i]
+		if !x86ABI0ForwardCopy(load, store, slot, false) {
+			return nil
+		}
+		// Removing the trailing pointer shifts the callback's results one
+		// pointer word earlier. Do not infer a signature from arbitrary loads.
+		if load.Args[0].Mem.Off != slot.Offset-8 || slot.Offset-8 < code.Offset {
+			return nil
+		}
+		results[i].Offset -= 8
+	}
+	last := instructions[len(instructions)-1]
+	if last.Op != "RET" || len(last.Args) != 0 {
+		return nil
+	}
+	return &FuncSig{
+		Args: append([]LLVMType(nil), sig.Args[:codeIndex]...), Ret: sig.Ret,
+		Frame: FrameLayout{Params: params, Results: results},
+	}
+}
+
+func x86ABI0ForwardCopy(load, store Instr, slot FrameSlot, incoming bool) bool {
+	if len(load.Args) != 2 || len(store.Args) != 2 ||
+		load.Args[1].Kind != OpReg || store.Args[0].Kind != OpReg ||
+		load.Args[1].Reg != store.Args[0].Reg || load.Args[1].Reg == SP || load.Args[1].Reg == BP {
+		return false
+	}
+	width := x86ABI0ForwardMoveBytes(load, 0)
+	if width == 0 || width != x86ABI0ForwardMoveBytes(store, 1) || width != frameTypeSize(slot.Type, 8) {
+		return false
+	}
+	fp, sp := load.Args[0], store.Args[1]
+	if !incoming {
+		fp, sp = store.Args[1], load.Args[0]
+	}
+	return fp.Kind == OpFP && fp.FPOffset == slot.Offset &&
+		sp.Kind == OpMem && sp.Mem.Base == SP && sp.Mem.Index == "" && sp.Mem.Sym == "" &&
+		sp.Mem.OffRaw == "" && sp.Mem.IndexExt == "" && sp.Mem.Segment == "" && sp.Mem.Scale == 0
+}
+
+func x86ABI0ForwardInstructions(fn Func) []Instr {
+	var instructions []Instr
+	for _, ins := range fn.Instrs {
+		switch ins.Op {
+		case "TEXT", "PCDATA", "FUNCDATA", "GO_ARGS", "NO_LOCAL_POINTERS":
+			continue
+		}
+		instructions = append(instructions, ins)
+	}
+	return instructions
+}
+
+// Widening MOVs retain their low source bytes. Only copying those exact bytes
+// back is forwarding; arithmetic, masks and partial-width stores do not qualify.
+func x86ABI0ForwardMoveBytes(ins Instr, index int) int64 {
+	if len(ins.Args) != 2 || !x86ResultNamedPredicateInstruction(ins) {
+		return 0
+	}
+	if x86RawReturnScalarMoveBytes(x86SourceMoveInstruction(ins, "amd64").Op) == 0 {
+		if form, known, err := amd64ScalarVectorMoveProperties(ins, "amd64"); known {
+			if err != nil || form.mask >= 0 || form.memory != index || form.spec.rawOnly {
+				return 0
+			}
+		} else if _, known, err := x86ScalarExtensionProperties(ins.Op, ins, "amd64"); index != 0 || !known || err != nil {
+			return 0
+		}
+	}
+	// This temporary projection queries the shared width grammar only. It is
+	// never emitted and cannot create a logical FP or native storage role.
+	projected := ins
+	projected.Args = append([]Operand(nil), ins.Args...)
+	projected.Args[index] = Operand{Kind: OpFP}
+	width, write, known := X86FPAccessBytes(projected, index, "amd64")
+	if !known || write != (index == 1) {
+		return 0
+	}
+	return width
+}
diff --git a/amd64_abi0_forward_test.go b/amd64_abi0_forward_test.go
new file mode 100644
index 000000000..a1c4b1781
--- /dev/null
+++ b/amd64_abi0_forward_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestX86ABI0ForwardCopyScalarWidths(t *testing.T) {
+	for _, test := range []struct {
+		op, register string
+		typ          LLVMType
+	}{
+		{"MOVB", "AX", I8},
+		{"MOVW", "AX", I16},
+		{"MOVL", "AX", I32},
+		{"MOVQ", "AX", I64},
+		{"MOVSS", "X0", "float"},
+		{"MOVSD", "X0", "double"},
+	} {
+		t.Run(test.op, func(t *testing.T) {
+			source := fmt.Sprintf(`TEXT copy(SB),$16-16
+	%s arg+8(FP), %s
+	%s %s, 8(SP)
+	%s 8(SP), %s
+	%s %s, ret+8(FP)
+	RET
+`, test.op, test.register, test.op, test.register,
+				test.op, test.register, test.op, test.register)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var instructions []Instr
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Op != "TEXT" {
+					instructions = append(instructions, ins)
+				}
+			}
+			slot := FrameSlot{Offset: 8, Type: test.typ}
+			if !x86ABI0ForwardCopy(instructions[0], instructions[1], slot, true) ||
+				!x86ABI0ForwardCopy(instructions[2], instructions[3], slot, false) {
+				t.Fatal("rejected equal-width scalar frame copies")
+			}
+			slot.Type = I64
+			if test.typ == I64 || test.typ == "double" {
+				slot.Type = I32
+			}
+			if x86ABI0ForwardCopy(instructions[0], instructions[1], slot, true) {
+				t.Fatal("accepted a copy with the wrong frame-slot width")
+			}
+		})
+	}
+}
+
+func TestX86ABI0ForwarderRequiresCompleteTypedShape(t *testing.T) {
+	tc := issue44Cases[3]
+	pkg := mustGoPackage(t, "test/forward", "package forward\n"+tc.declarations)
+	fn := pkg.Types.Scope().Lookup("Y").(*types.Func)
+	sig, err := goFuncSigForDeclaredFunc("Y", fn, "amd64", nil, nil, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, old, replacement string
+		valid                  bool
+	}{
+		{name: "exact", valid: true},
+		{name: "renamed_code_parameter", old: "code+", replacement: "function_pointer+", valid: true},
+		{name: "wrong_argument_offset", old: "AX, 8(SP)", replacement: "AX, 0(SP)"},
+		{name: "wrong_argument_width", old: "MOVQ b+8(FP)", replacement: "MOVL b+8(FP)"},
+		{name: "missing_argument", old: "MOVQ AX, 8(SP)\n", replacement: ""},
+		{name: "wrong_code_slot", old: "code+16(FP)", replacement: "code+8(FP)"},
+		{name: "wrong_code_register", old: "CALL *AX", replacement: "CALL *BX"},
+		{name: "wrong_result_offset", old: "16(SP), AX", replacement: "8(SP), AX"},
+		{name: "wrong_result_destination", old: "ret+24(FP)", replacement: "ret+16(FP)"},
+		{name: "mutation", old: "CALL *AX", replacement: "INCQ 0(SP)\nCALL *AX"},
+		{name: "second_call", old: "CALL *AX", replacement: "CALL *AX\nCALL *AX"},
+		{name: "branch", old: "CALL *AX", replacement: "JMP end\nCALL *AX\nend:"},
+		{name: "tail_jump", old: "RET", replacement: "JMP *AX"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := tc.assembly
+			if test.old != "" {
+				source = strings.Replace(source, test.old, test.replacement, 1)
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := inferX86ABI0Forwarder(file.Funcs[0], sig, "amd64")
+			if (got != nil) != test.valid {
+				t.Fatalf("inferred %+v, want valid=%v", got, test.valid)
+			}
+			if got != nil && (len(got.Args) != 2 || got.Ret != I64 || got.Frame.Results[0].Offset != 16) {
+				t.Fatalf("wrong callback signature: %+v", got)
+			}
+		})
+	}
+}
+
+func TestGoABI0NestedAggregateFrameLayout(t *testing.T) {
+	pkg := mustGoPackage(t, "test/layout", `package layout
+type Mixed struct { Byte uint8; Pair [2]uint64; Z complex128 }
+func Y(a Mixed, b complex64) (r Mixed)
+`)
+	fn := pkg.Types.Scope().Lookup("Y").(*types.Func)
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			sig, err := goFuncSigForDeclaredFunc("Y", fn, arch, nil, nil, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if sig.Args[0] != "{ i8, [2 x i64], { double, double } }" || len(sig.Frame.Params) != 7 || len(sig.Frame.Results) != 5 {
+				t.Fatalf("incorrect aggregate layout: %+v", sig)
+			}
+			word := int64(goWordSize(arch))
+			wantOffsets := []int64{0, word, word + 8, word + 16, word + 24, word + 32, word + 36}
+			wantPaths := []string{", 0", ", 1, 0", ", 1, 1", ", 2, 0", ", 2, 1", ", 0", ", 1"}
+			for i, slot := range sig.Frame.Params {
+				if slot.Offset != wantOffsets[i] || frameSlotExtractSuffix(slot) != wantPaths[i] {
+					t.Fatalf("slot %d = %+v, want offset=%d path=%s", i, slot, wantOffsets[i], wantPaths[i])
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_abi0_outgoing_candidate.go b/amd64_abi0_outgoing_candidate.go
new file mode 100644
index 000000000..7f59bdf74
--- /dev/null
+++ b/amd64_abi0_outgoing_candidate.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import "strings"
+
+// A complete typed forwarding adapter uses the existing ABI0 call allocation.
+// This only chooses that existing route. It grants no initialized bytes, FLAGS,
+// native backing, caller extent or source authority to its later translation.
+func x86ABI0OutgoingForwarder(fn Func, options Options) bool {
+	if options.Goarch != "amd64" || options.ResolveSym == nil ||
+		fn.FrameSize <= 0 || fn.FrameSize > 4096 || fn.ArgSize < 0 || fn.ArgSize > 4096 ||
+		len(fn.Instrs) > 8192 || len(fn.X86RawText) != 0 || strings.Contains(fn.Sym, "<") {
+		return false
+	}
+	resolvedCaller := options.ResolveSym(fn.Sym)
+	caller, found := options.Sigs[resolvedCaller]
+	if !found || caller.Name != "" && caller.Name != resolvedCaller || !x86ABI0ForwardLayout(caller, fn.ArgSize) {
+		return false
+	}
+	sourceFrames := [2]map[int64]FrameSlot{make(map[int64]FrameSlot), make(map[int64]FrameSlot)}
+	for group, slots := range [][]FrameSlot{caller.Frame.Params, caller.Frame.Results} {
+		for _, slot := range slots {
+			sourceFrames[group][slot.Offset] = slot
+		}
+	}
+	instructions := x86ABI0ForwardInstructions(fn)
+	if len(instructions) == 0 || instructions[len(instructions)-1].Op != OpRET ||
+		len(instructions[len(instructions)-1].Args) != 0 {
+		return false
+	}
+	start, calls := 0, 0
+	for start < len(instructions)-1 {
+		at := start
+		for at < len(instructions) && instructions[at].Op != OpCALL {
+			at++
+		}
+		if at == len(instructions) || len(instructions[at].Args) != 1 || instructions[at].Args[0].Kind != OpSym {
+			return false
+		}
+		call := instructions[at]
+		name, offset, valid := parseSBRef(call.Args[0].Sym)
+		if !valid || offset != 0 || strings.Contains(name, "<") || !x86ResultNamedPredicateInstruction(call) {
+			return false
+		}
+		resolved := options.ResolveSym(name)
+		callee, declared := options.Sigs[resolved]
+		if !declared || callee.Name != "" && callee.Name != resolved || !x86ABI0ForwardLayout(callee, fn.FrameSize) ||
+			at-start != 2*len(callee.Frame.Params) || at+1+2*len(callee.Frame.Results) >= len(instructions) ||
+			len(caller.Frame.Results) != len(callee.Frame.Results) {
+			return false
+		}
+		writtenResults := make(map[int64]bool, len(caller.Frame.Results))
+		for group, slots := range [][]FrameSlot{callee.Frame.Params, callee.Frame.Results} {
+			incoming, begin := group == 0, start
+			if !incoming {
+				begin = at + 1
+			}
+			for index, slot := range slots {
+				load, store := instructions[begin+2*index], instructions[begin+2*index+1]
+				if len(load.Args) != 2 || len(store.Args) != 2 {
+					return false
+				}
+				fp, sp, memoryIndex := load.Args[0], store, 1
+				if !incoming {
+					fp, sp, memoryIndex = store.Args[1], load, 0
+				}
+				memory, err := fixedLocalMemoryAddress(sp, memoryIndex, fn.FrameSize)
+				if err != nil || memory != sp.Args[memoryIndex].Mem || memory.Off != slot.Offset {
+					return false
+				}
+				source, matched := sourceFrames[group][fp.FPOffset]
+				if !matched || fp.Kind != OpFP || slot.Type != source.Type || !x86ABI0ForwardCopy(load, store, source, incoming) {
+					return false
+				}
+				if !incoming {
+					if writtenResults[source.Offset] {
+						return false
+					}
+					writtenResults[source.Offset] = true
+				}
+			}
+		}
+		start = at + 1 + 2*len(callee.Frame.Results)
+		calls++
+	}
+	return calls != 0 && start == len(instructions)-1
+}
+
+func x86ABI0ForwardLayout(sig FuncSig, limit int64) bool {
+	return x86ABI0FrameLayout(sig, limit, "amd64")
+}
+
+func x86ABI0FrameLayout(sig FuncSig, limit int64, arch string) bool {
+	if len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.WASMContext != "" ||
+		sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		len(sig.Frame.Params)+len(sig.Frame.Results) > 4096 {
+		return false
+	}
+	results := []LLVMType{sig.Ret}
+	if sig.Ret == Void {
+		results = nil
+	} else if fields, aggregate := parseLiteralStructFields(sig.Ret); aggregate {
+		results = fields
+	}
+	if len(results) != len(sig.Frame.Results) {
+		return false
+	}
+	end := int64(0)
+	roles := make(map[string]bool)
+	for group, slots := range [][]FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for index, slot := range slots {
+			width := x86FrameScalarBytes(slot.Type, arch)
+			if width == 0 || slot.Offset < end || slot.Offset > limit-width {
+				return false
+			}
+			if group == 0 {
+				role, valid := x86ResultParameterRole(sig.Args, slot)
+				if !valid || roles[role] {
+					return false
+				}
+				roles[role] = true
+			} else if slot.Index != index || !x86RawReturnSlotMatchesSignature(slot, 1, sig) {
+				return false
+			}
+			end = slot.Offset + width
+		}
+	}
+	remaining := len(sig.Frame.Params)
+	for _, argument := range sig.Args {
+		// The existing role check proves every supplied leaf is unique. Count
+		// all actual leaves as well, so missing aggregate fields cannot pass.
+		err := goLLVMScalarLeaves(argument, nil, uint64(len(sig.Frame.Params)), func(LLVMType, []int) error {
+			if remaining == 0 {
+				return ErrProbeNeedsContext
+			}
+			remaining--
+			return nil
+		})
+		if err != nil {
+			return false
+		}
+	}
+	return remaining == 0
+}
diff --git a/amd64_abi0_outgoing_candidate_test.go b/amd64_abi0_outgoing_candidate_test.go
new file mode 100644
index 000000000..6e5089c91
--- /dev/null
+++ b/amd64_abi0_outgoing_candidate_test.go
@@ -0,0 +1,300 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func requireX86OutgoingCandidateGoSource(t *testing.T, source string) {
+	t.Helper()
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	t.Logf("original Go assembler accepted source sha256=%x", sha256.Sum256([]byte(source)))
+}
+
+func x86OutgoingCandidateFixture(t *testing.T, parameters, load string, calls []string) (*File, Options, string) {
+	t.Helper()
+	declarations := "package outgoing\nfunc Caller(" + parameters + ") float64\n" +
+		"func First(a uint8) float64\nfunc Callee(" + parameters + ") float64\n"
+	pkg := mustGoPackage(t, "outgoing", declarations)
+	options := Options{Goarch: "amd64", Sigs: make(map[string]FuncSig),
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "outgoing.", 1) }}
+	for _, name := range []string{"Caller", "First", "Callee"} {
+		declaration := pkg.Types.Scope().Lookup(name).(*types.Func)
+		sig, err := DeriveGoFuncABI0Signature("outgoing."+name, declaration, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	caller := options.Sigs["outgoing.Caller"]
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Caller(SB),4,$64-%d\n", caller.Frame.Results[0].Offset+8)
+	for _, name := range calls {
+		callee := options.Sigs["outgoing."+name]
+		for index, slot := range callee.Frame.Params {
+			input := caller.Frame.Params[index]
+			move, register := "MOVQ", "AX"
+			switch slot.Type {
+			case I8:
+				move = "MOVB"
+			case I16:
+				move = "MOVW"
+			case I32:
+				move = "MOVL"
+			case "float":
+				move, register = "MOVSS", "X0"
+			case "double":
+				move, register = "MOVSD", "X0"
+			}
+			read := move
+			if index == 0 && load != "" {
+				read = load
+			}
+			inputName := input.Name
+			if inputName == "" {
+				inputName = fmt.Sprintf("arg%d", index)
+			}
+			fmt.Fprintf(&source, "%s %s+%d(FP),%s\n%s %s,%d(SP)\n",
+				read, inputName, input.Offset, register, move, register, slot.Offset)
+		}
+		fmt.Fprintf(&source, "CALL ·%s(SB)\nMOVSD %d(SP),X1\nMOVSD X1,ret+%d(FP)\n",
+			name, callee.Frame.Results[0].Offset, caller.Frame.Results[0].Offset)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, options, source.String()
+}
+
+func TestGoAMD64FixedLocalOutgoingABI0ForwardCandidates(t *testing.T) {
+	for _, parameters := range []string{
+		"a uint8", "a uint16", "a uint32", "a uint64", "a float32", "a float64",
+		"a uint8,b uint64", "a struct { X uint8; Y uint64 }",
+		"a []byte", "a [3]uint64", "a struct { X [2]uint16; Y struct { Z uint64 } }",
+	} {
+		for _, rounds := range []int{1, 2} {
+			t.Run(fmt.Sprintf("%s/%d", parameters, rounds), func(t *testing.T) {
+				calls := []string{"Callee"}
+				if rounds == 2 {
+					calls = append(calls, "Callee")
+				}
+				file, options, source := x86OutgoingCandidateFixture(t, parameters, "", calls)
+				requireX86OutgoingCandidateGoSource(t, source)
+				t.Logf("original untyped source candidate=%t", GoAMD64FixedLocalFrameBindingNeeded(file, "amd64"))
+				if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+					t.Fatal("complete typed outgoing frame was routed to the unrelated native-frame factory")
+				}
+			})
+		}
+	}
+	t.Run("different callee layouts", func(t *testing.T) {
+		file, options, source := x86OutgoingCandidateFixture(t, "a uint8,b uint64", "MOVBLZX", []string{"First", "Callee"})
+		requireX86OutgoingCandidateGoSource(t, source)
+		if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+			t.Fatal("independent typed call rounds lost their actual parameter/result offsets")
+		}
+	})
+	t.Run("multiple callers", func(t *testing.T) {
+		_, options, source := x86OutgoingCandidateFixture(t, "a uint64", "", []string{"Callee"})
+		sig := options.Sigs["outgoing.Caller"]
+		sig.Name = "outgoing.Other"
+		options.Sigs[sig.Name] = sig
+		second := strings.Replace(source, "·Caller", "·Other", 1)
+		complete := source + second
+		requireX86OutgoingCandidateGoSource(t, complete)
+		file, err := Parse(ArchAMD64, complete)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+			t.Fatal("a second complete typed caller changed the source role")
+		}
+		file, err = Parse(ArchAMD64, source+strings.Replace(second, "RET\n", "MOVQ AX,48(SP)\nRET\n", 1))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+			t.Fatal("one valid caller hid another function's private access")
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalOutgoingABI0ForwardGuards(t *testing.T) {
+	for _, test := range []struct {
+		name, old, replacement string
+	}{
+		{"padding store", "CALL ·Callee(SB)", "MOVB AX,1(SP)\nCALL ·Callee(SB)"},
+		{"private store", "CALL ·Callee(SB)", "MOVQ AX,48(SP)\nCALL ·Callee(SB)"},
+		{"extra vector access", "CALL ·Callee(SB)", "PADDL 32(SP),X0\nCALL ·Callee(SB)"},
+		{"overlapping source slots", "MOVQ AX,8(SP)", "MOVQ AX,0(SP)"},
+		{"wrong width", "MOVQ AX,8(SP)", "MOVL AX,8(SP)"},
+		{"wrong register", "MOVQ AX,8(SP)", "MOVQ BX,8(SP)"},
+		{"missing input", "MOVQ AX,8(SP)\n", ""},
+		{"old result", "MOVSD 16(SP),X1", "MOVSD 8(SP),X1"},
+		{"SP escape", "CALL ·Callee(SB)", "MOVQ SP,R11\nCALL ·Callee(SB)"},
+		{"SP write", "CALL ·Callee(SB)", "ADDQ $16,SP\nCALL ·Callee(SB)"},
+		{"BP alias", "MOVQ AX,8(SP)", "MOVQ AX,-56(BP)"},
+		{"indexed access", "MOVQ AX,8(SP)", "MOVQ AX,8(SP)(CX*1)"},
+		{"flags across call", "CALL ·Callee(SB)", "CMPQ AX,AX\nCALL ·Callee(SB)\nSETCS CL"},
+		{"branch", "CALL ·Callee(SB)", "JMP next\nnext:\nCALL ·Callee(SB)"},
+		{"indirect", "CALL ·Callee(SB)", "CALL AX"},
+		{"internal ABI", "CALL ·Callee(SB)", "CALL ·Callee<ABIInternal>(SB)"},
+		{"missing callee", "CALL ·Callee(SB)", "CALL ·Missing(SB)"},
+		{"frame overflow", "$64-24", "$16-24"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, options, source := x86OutgoingCandidateFixture(t, "a uint8,b uint64", "MOVBLZX", []string{"First", "Callee"})
+			if !strings.Contains(source, test.old) {
+				t.Fatalf("negative control did not mutate its source: %q", test.old)
+			}
+			source = strings.Replace(source, test.old, test.replacement, 1)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") || !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+				t.Fatal("unclosed frame or call silently bypassed its original candidate")
+			}
+		})
+	}
+	for _, change := range []string{"zero options", "duplicate options", "custom caller", "custom callee", "overlapping callee", "missing slot"} {
+		t.Run(change, func(t *testing.T) {
+			file, options, _ := x86OutgoingCandidateFixture(t, "a uint8,b uint64", "MOVBLZX", []string{"Callee"})
+			provided := []Options{options}
+			switch change {
+			case "zero options":
+				provided = []Options{{}}
+			case "duplicate options":
+				provided = append(provided, options)
+			case "custom caller", "custom callee":
+				name := "outgoing.Callee"
+				if change == "custom caller" {
+					name = "outgoing.Caller"
+				}
+				sig := options.Sigs[name]
+				sig.ArgRegs = []Reg{AX, BX}
+				options.Sigs[name] = sig
+			case "overlapping callee":
+				sig := options.Sigs["outgoing.Callee"]
+				sig.Frame.Params[1].Offset = 0
+				options.Sigs[sig.Name] = sig
+			case "missing slot":
+				sig := options.Sigs["outgoing.Callee"]
+				sig.Frame.Params = sig.Frame.Params[:1]
+				options.Sigs[sig.Name] = sig
+			}
+			if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", provided...) {
+				t.Fatal("ambiguous or nonordinary declarations disabled the native-frame candidate")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalOutgoingExtensionFamily(t *testing.T) {
+	for _, opcode := range []Op{
+		"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVBQSX", "MOVBQZX",
+		"MOVWLSX", "MOVWLZX", "MOVWQSX", "MOVWQZX", "MOVLQSX", "MOVLQZX", "MOVSWW", "MOVZWW",
+	} {
+		t.Run(string(opcode), func(t *testing.T) {
+			spec := amd64ScalarExtensionMoveSpecs[opcode]
+			parameters := fmt.Sprintf("a uint%d", spec.sourceBits)
+			file, options, source := x86OutgoingCandidateFixture(t, parameters, string(opcode), []string{"Callee"})
+			requireX86OutgoingCandidateGoSource(t, source)
+			if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+				t.Fatal("shared widening move did not preserve its exact outgoing low bytes")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalOutgoingCompleteSlotGuards(t *testing.T) {
+	t.Run("missing aggregate field", func(t *testing.T) {
+		_, options, source := x86OutgoingCandidateFixture(t, "a struct { X uint8; Y uint64 }", "", []string{"Callee"})
+		for _, name := range []string{"Caller", "Callee"} {
+			sig := options.Sigs["outgoing."+name]
+			sig.Frame.Params = sig.Frame.Params[:1]
+			options.Sigs[sig.Name] = sig
+		}
+		const missing = "MOVQ arg1+8(FP),AX\nMOVQ AX,8(SP)\n"
+		if !strings.Contains(source, missing) {
+			t.Fatal("aggregate negative did not remove its second field")
+		}
+		source = strings.Replace(source, missing, "", 1)
+		requireX86OutgoingCandidateGoSource(t, source)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+			t.Fatal("one aggregate leaf was mistaken for its complete argument")
+		}
+	})
+	t.Run("duplicate result destination", func(t *testing.T) {
+		options, source := x86OutgoingMultipleResultsFixture(t, 8, 8)
+		requireX86OutgoingCandidateGoSource(t, source)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+			t.Fatal("two stores to one result were mistaken for complete result forwarding")
+		}
+	})
+}
+
+func x86OutgoingMultipleResultsFixture(t *testing.T, firstOffset, secondOffset int) (Options, string) {
+	t.Helper()
+	_, options, source := x86OutgoingCandidateFixture(t, "a uint64", "", []string{"Callee"})
+	for _, name := range []string{"Caller", "Callee"} {
+		sig := options.Sigs["outgoing."+name]
+		sig.Ret = "{ double, double }"
+		second := sig.Frame.Results[0]
+		second.Index, second.Offset = 1, 16
+		sig.Frame.Results = append(sig.Frame.Results, second)
+		options.Sigs[sig.Name] = sig
+	}
+	source = strings.Replace(source, "$64-16", "$64-24", 1)
+	source = strings.Replace(source, "ret+8(FP)", fmt.Sprintf("ret+%d(FP)", firstOffset), 1)
+	source = strings.Replace(source, "RET\n", fmt.Sprintf("MOVSD 16(SP),X1\nMOVSD X1,ret+%d(FP)\nRET\n", secondOffset), 1)
+	return options, source
+}
+
+func TestGoAMD64FixedLocalOutgoingMultipleResults(t *testing.T) {
+	for _, offsets := range [][2]int{{8, 16}, {16, 8}} {
+		t.Run(fmt.Sprint(offsets), func(t *testing.T) {
+			options, source := x86OutgoingMultipleResultsFixture(t, offsets[0], offsets[1])
+			requireX86OutgoingCandidateGoSource(t, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64", options) {
+				t.Fatal("complete distinct result destinations lost their ordinary call route")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalOutgoingLayoutBoundaries(t *testing.T) {
+	for _, typ := range []LLVMType{"{}", "[0 x i64]", "%unknown"} {
+		t.Run(string(typ), func(t *testing.T) {
+			if x86ABI0ForwardLayout(FuncSig{Args: []LLVMType{typ}, Ret: Void}, 8) {
+				t.Fatal("unsupported empty or named type acquired a complete frame role")
+			}
+		})
+	}
+	for _, typ := range []LLVMType{"[2 x i64]", "[18446744073709551615 x i64]"} {
+		t.Run(string(typ), func(t *testing.T) {
+			sig := FuncSig{Args: []LLVMType{typ}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Type: I64, Index: 0, Field: 0}}}}
+			if x86ABI0ForwardLayout(sig, 8) {
+				t.Fatal("one array element was mistaken for the complete bounded inventory")
+			}
+		})
+	}
+}
diff --git a/amd64_accumulator_sign_extend_forms.go b/amd64_accumulator_sign_extend_forms.go
new file mode 100644
index 000000000..9efd606fc
--- /dev/null
+++ b/amd64_accumulator_sign_extend_forms.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86AccumulatorSignExtendSpec struct {
+	sourceBytes, destinationBytes int64
+	destination                   Reg
+}
+
+// Complete x86 ynone / 98,99 family. The prefix selects the operand width; the
+// destination distinguishes sign extension from the sign-only high half.
+var x86AccumulatorSignExtendSpecs = map[Op]x86AccumulatorSignExtendSpec{
+	"CBW":  {1, 2, AX},
+	"CWDE": {2, 4, AX},
+	"CDQE": {4, 8, AX},
+	"CWD":  {2, 2, DX},
+	"CDQ":  {4, 4, DX},
+	"CQO":  {8, 8, DX},
+}
+
+func x86AccumulatorSignExtendProperties(op Op, ins Instr, arch string) (x86AccumulatorSignExtendSpec, bool, error) {
+	name := strings.ToUpper(string(op))
+	base, _, dotted := strings.Cut(name, ".")
+	spec, known := x86AccumulatorSignExtendSpecs[Op(base)]
+	if !known {
+		return spec, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.destinationBytes == 8 ||
+		dotted || len(ins.Args) != 0 || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s requires its original zero-operand ynone row: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func x86TypedAccumulatorSignExtendByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	spec, known, err := x86AccumulatorSignExtendProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: -1, operand: Operand{Kind: OpReg, Reg: AX}, width: spec.sourceBytes, read: true},
+		{index: -1, operand: Operand{Kind: OpReg, Reg: spec.destination}, width: spec.destinationBytes, write: true},
+	}}, true, nil
+}
diff --git a/amd64_address_memory_class_test.go b/amd64_address_memory_class_test.go
new file mode 100644
index 000000000..8d020485b
--- /dev/null
+++ b/amd64_address_memory_class_test.go
@@ -0,0 +1,373 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86MemoryClassKeepsAddressImmediatesDistinct(t *testing.T) {
+	for _, source := range []string{
+		"$·cell(SB)", "$·cell+8(SB)", "$16(AX)", "$16(AX)(CX*4)",
+	} {
+		t.Run(source, func(t *testing.T) {
+			operand, err := parseOperandForArch(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if operand.Kind != OpSym || !strings.HasPrefix(operand.Sym, "$") {
+				t.Fatalf("source address identity lost: %#v", operand)
+			}
+			if isAMD64MemoryOperand(operand) {
+				t.Fatalf("Go TYPE_ADDR became a memory operand: %#v", operand)
+			}
+			// A caller-built operand must obey the same lexical boundary.
+			operand.Sym = " \t" + operand.Sym
+			if isAMD64MemoryOperand(operand) {
+				t.Fatal("whitespace granted address-immediate memory permission")
+			}
+		})
+	}
+
+	for _, source := range []string{
+		"·cell(SB)", "·cell+8(SB)", "(AX)", "16(AX)(CX*4)",
+		"arg+0(FP)", "local-8(SP)", "(FS)", "(GS)",
+	} {
+		t.Run("memory/"+source, func(t *testing.T) {
+			operand, err := parseOperandForArch(ArchAMD64, source)
+			if err != nil || !isAMD64MemoryOperand(operand) {
+				t.Fatalf("ordinary memory class changed: %#v: %v", operand, err)
+			}
+		})
+	}
+}
+
+func TestX86AddressImmediateMemoryOnlyFormsRejectAcrossAPIs(t *testing.T) {
+	// Independent witnesses from Go's Ym/Ymb/Yml, yxchg, SSE memory,
+	// scalar-memory and non-temporal rows. The source contains a TYPE_ADDR
+	// where a real memory operand is required; relocation is not a load/store.
+	rows := []string{
+		"XADDB AL,%s", "XADDW CX,%s", "XADDL CX,%s",
+		"XCHGB AL,%s", "XCHGW CX,%s", "XCHGL CX,%s",
+		"INCB %s", "INCW %s", "INCL %s",
+		"DECB %s", "DECW %s", "DECL %s",
+		"NEGB %s", "NEGW %s", "NEGL %s",
+		"NOTB %s", "NOTW %s", "NOTL %s",
+		"BTCL $1,%s", "BTRL $1,%s", "BTSL $1,%s",
+		"STMXCSR %s", "LDMXCSR %s", "CLFLUSH %s",
+		"MOVNTIL CX,%s", "MOVNTO X0,%s", "MOVNTPS X0,%s",
+		"ADDSUBPS %s,X0", "ADDSUBPD %s,X0",
+		"AESENC %s,X0", "PSHUFB %s,X0", "LDDQU %s,X0",
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range rows {
+			for _, address := range []string{"$·cell(SB)", "$16(AX)"} {
+				instruction := fmt.Sprintf(row, address)
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					memorySource := "TEXT ·Value(SB),4,$0-0\n" +
+						fmt.Sprintf(row, strings.TrimPrefix(address, "$")) + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, memorySource, "", true)
+					source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					for _, target := range x86AddressMemoryTargets(arch) {
+						for _, api := range []string{"text", "module", "go"} {
+							t.Run(target+"/"+api, func(t *testing.T) {
+								_, err := x86AddressMemoryAPI(t, api, source, arch, target)
+								if err == nil {
+									t.Fatal("Go-rejected address immediate acquired memory semantics")
+								}
+							})
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86AddressClassActualGoRulesExcludeMemory(t *testing.T) {
+	// Read the actual selected assembler's complete classification/coverage
+	// relation. This oracle does not use the translator's operand predicate.
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(),
+		"src/cmd/internal/obj/x86/asm6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := make(map[string]bool)
+	foundAddress, foundConstant := false, false
+	edges := make(map[string][]string)
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch node := node.(type) {
+		case *ast.FuncDecl:
+			if node.Name.Name != "oclass" {
+				return true
+			}
+			ast.Inspect(node.Body, func(child ast.Node) bool {
+				clause, ok := child.(*ast.CaseClause)
+				if !ok {
+					return true
+				}
+				for _, value := range clause.List {
+					name, ok := value.(*ast.SelectorExpr)
+					if !ok || name.Sel.Name != "TYPE_ADDR" && name.Sel.Name != "TYPE_CONST" {
+						continue
+					}
+					foundAddress = foundAddress || name.Sel.Name == "TYPE_ADDR"
+					foundConstant = foundConstant || name.Sel.Name == "TYPE_CONST"
+					for _, statement := range clause.Body {
+						ast.Inspect(statement, func(inside ast.Node) bool {
+							if result, ok := inside.(*ast.ReturnStmt); ok {
+								if len(result.Results) != 1 {
+									t.Fatal("unexpected Go operand classification return")
+								}
+								ident, ok := result.Results[0].(*ast.Ident)
+								if !ok || !strings.HasPrefix(ident.Name, "Y") {
+									t.Fatal("unregistered Go address/constant classifier")
+								}
+								classes[ident.Name] = true
+							}
+							return true
+						})
+					}
+				}
+				return true
+			})
+			return false
+		case *ast.AssignStmt:
+			for _, left := range node.Lhs {
+				index, ok := left.(*ast.IndexExpr)
+				if !ok {
+					continue
+				}
+				name, ok := index.X.(*ast.Ident)
+				if !ok || name.Name != "ycover" {
+					continue
+				}
+				sum, ok := index.Index.(*ast.BinaryExpr)
+				if !ok || sum.Op != token.ADD {
+					t.Fatal("unregistered Go class coverage index")
+				}
+				product, ok := sum.X.(*ast.BinaryExpr)
+				if !ok || product.Op != token.MUL {
+					t.Fatal("unregistered Go class coverage product")
+				}
+				from, fromOK := product.X.(*ast.Ident)
+				size, sizeOK := product.Y.(*ast.Ident)
+				to, toOK := sum.Y.(*ast.Ident)
+				if !fromOK || !sizeOK || !toOK || size.Name != "Ymax" {
+					t.Fatal("unregistered Go class coverage operands")
+				}
+				if from.Name == "i" && to.Name == "i" {
+					continue // The actual diagonal only relates a class to itself.
+				}
+				if !strings.HasPrefix(from.Name, "Y") || !strings.HasPrefix(to.Name, "Y") {
+					t.Fatal("unregistered computed Go class relation")
+				}
+				edges[from.Name] = append(edges[from.Name], to.Name)
+			}
+		}
+		return true
+	})
+	if !foundAddress || !foundConstant || !classes["Yiauto"] || !classes["Yi32"] || len(edges) == 0 {
+		t.Fatal("incomplete actual Go TYPE_ADDR/constant/coverage inventory")
+	}
+	for changed := true; changed; {
+		changed = false
+		for from := range classes {
+			for _, to := range edges[from] {
+				if !classes[to] {
+					classes[to], changed = true, true
+				}
+			}
+		}
+	}
+	for _, memory := range []string{"Ym", "Ymb", "Yml", "Ymm", "Yxm", "Yxvm", "Yyvm", "Yzvm"} {
+		if classes[memory] {
+			t.Fatalf("actual Go address immediate acquired memory-class reachability: %s", memory)
+		}
+	}
+}
+
+func TestX86AddressClassPreservesActualMemoryAndRelocationObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		move := "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range []struct {
+			body         string
+			needsContext bool
+		}{
+			{move + " $·cell(SB),AX", false},
+			{move + " $16(AX),BX", false},
+			{"XADDL CX,·cell(SB)", true},
+			{"XCHGL CX,16(AX)", true},
+			{"INCL ·cell(SB)", true},
+			{"NEGL 16(AX)", true},
+			{"STMXCSR ·cell(SB)", true},
+			{"LDMXCSR 16(AX)", true},
+			{"PSHUFB ·cell(SB),X0", false},
+			{"MOVNTPS X0,16(AX)", true},
+		} {
+			source := "TEXT ·Value(SB),4,$0-0\n" + row.body + "\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, target := range x86AddressMemoryTargets(arch) {
+				if row.needsContext {
+					// Keep every original memory/relocation object. A Void
+					// format fixture supplies neither initialized AX nor the
+					// external cell's storage role to a public source proof.
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir := x86ScalarFormatObjectUnit(t, file,
+						map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}, arch, target, 0)
+					x86ResultInitializationObject(t, llc, target, ir, "original-address-format")
+				}
+				for _, api := range []string{"text", "module", "go"} {
+					t.Run(arch+"/"+row.body+"/"+target+"/"+api, func(t *testing.T) {
+						ir, err := x86AddressMemoryAPI(t, api, source, arch, target)
+						if row.needsContext {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unbound format acquired public storage/input authority", err)
+							}
+							return
+						}
+						if err != nil {
+							t.Fatal("legitimate memory/address operand lost:", err)
+						}
+						x86ResultInitializationObject(t, llc, target, ir, "address-class")
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86AddressClassInitializedExchangeObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			// Keep the discovering operands. The static counterpart supplies
+			// its actual mutable DATA; the pointer counterpart binds its entry
+			// parameter. Both independently define the numerical CX input.
+			fixtures := []x86OriginalGPInitializedFormat{
+				{
+					source: "DATA ·cell+0(SB)/4,$0\nGLOBL ·cell(SB),16,$4\n" +
+						"TEXT ·AddressStatic(SB),4,$0-0\nMOVL $7,CX\nXADDL CX,·cell(SB)\nRET\n",
+					declaration: "func AddressStatic()",
+				},
+				{
+					source: fmt.Sprintf("TEXT ·AddressPointer(SB),4,$0-%d\n%s p+0(FP),AX\n"+
+						"MOVL $7,CX\nXCHGL CX,16(AX)\nRET\n", word, move),
+					declaration: "func AddressPointer(p *[32]byte)",
+				},
+			}
+			x86OriginalGPInitializedFormatObjects(t, fixtures, target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86AddressClassInitializedNonTemporalStoreObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			// Keep the discovering row byte-for-byte, including displacement.
+			// The new entry explicitly supplies its pointer and vector inputs;
+			// neither the declaration nor LLVM zeroed slots supplies them.
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n"+
+				"PXOR X0,X0\nMOVNTPS X0,16(AX)\nRET\n", word, move)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[32]byte)", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original non-temporal address form rejected", err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						if !strings.Contains(text, "asm sideeffect") || !strings.Contains(text, "movntps") {
+							t.Fatal("actual non-temporal store/alignment effect disappeared")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86AddressMemoryTargets(arch string) []string {
+	if arch == "386" {
+		return []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+	}
+	return []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	}
+}
+
+func x86AddressMemoryAPI(t *testing.T, api, source, arch, target string) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	options := Options{
+		Goarch: arch, TargetTriple: target, ResolveSym: resolve,
+		Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}},
+	}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return module.String(), nil
+	}
+	if api != "go" {
+		t.Fatalf("unregistered API %q", api)
+	}
+	pkg := mustGoPackage(t, "example.invalid/addressclass", "package addressclass\nfunc Value()\n")
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: arch, TargetTriple: target, ResolveSym: resolve,
+	})
+	if translated != nil && !translated.Module.IsNil() {
+		defer translated.Module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return translated.Module.String(), nil
+}
diff --git a/amd64_address_memory_sinks_test.go b/amd64_address_memory_sinks_test.go
new file mode 100644
index 000000000..64e4387cc
--- /dev/null
+++ b/amd64_address_memory_sinks_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86SymbolMemoryPointerRejectsAddressIdentityBeforeEmission(t *testing.T) {
+	for _, source := range []string{
+		"$·cell(SB)", "$·cell+8(SB)", " \t$·cell-8(SB)",
+	} {
+		t.Run(source, func(t *testing.T) {
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			before, temporary := output.String(), ctx.tmp
+			pointer, err := ctx.ptrFromSB(source)
+			if err == nil || pointer != "" || !strings.Contains(err.Error(), "address immediate") {
+				t.Fatalf("address acquired a memory pointer: %q: %v", pointer, err)
+			}
+			if output.String() != before || ctx.tmp != temporary {
+				t.Fatal("rejected address emitted IR or consumed a temporary")
+			}
+		})
+	}
+
+	for _, source := range []string{"·cell(SB)", "·cell+8(SB)", "·cell-8(SB)"} {
+		t.Run("memory/"+source, func(t *testing.T) {
+			ctx, _ := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			if pointer, err := ctx.ptrFromSB(source); err != nil || pointer == "" {
+				t.Fatalf("ordinary symbolic memory lost: %q: %v", pointer, err)
+			}
+		})
+	}
+}
+
+func x86AddressMemorySinkRows(arch string) []string {
+	// These ordinary stores and x87 loads use direct OpSym dispatch, not the
+	// shared memory-class predicate. Their Go encoder rows still require actual
+	// memory, including the complete scalar and x87 storage widths below.
+	rows := []string{
+		"MOVB AL,%s", "MOVW CX,%s", "MOVL CX,%s",
+		"MOVSS X0,%s", "MOVSD X0,%s", "MOVOU X0,%s",
+		"FMOVF F0,%s", "FMOVFP F0,%s", "FMOVD F0,%s", "FMOVDP F0,%s",
+		"FMOVW F0,%s", "FMOVWP F0,%s", "FMOVL F0,%s", "FMOVLP F0,%s",
+		"FMOVVP F0,%s", "FMOVBP F0,%s", "FMOVXP F0,%s",
+		"FMOVF %s,F0", "FMOVD %s,F0", "FMOVW %s,F0", "FMOVL %s,F0",
+		"FMOVV %s,F0", "FMOVB %s,F0", "FMOVX %s,F0",
+	}
+	if arch == "amd64" {
+		rows = append(rows, "MOVQ CX,%s")
+	}
+	return rows
+}
+
+func x86AddressMemorySinkSource(row, operand string) string {
+	// These are compile-only syntax/operand tests. Initialize explicit register
+	// inputs, but do not claim execution of the external cell or x87 state.
+	return "TEXT ·Value(SB),4,$0-0\nMOVL $7,AX\nMOVL $9,CX\n" +
+		"PXOR X0,X0\nFLDZ\n" + fmt.Sprintf(row, operand) + "\nRET\n"
+}
+
+func TestX86AddressImmediateDirectMemorySinksRejectAcrossAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86AddressMemorySinkRows(arch) {
+			for _, operand := range []string{"$·cell(SB)", "$·cell+8(SB)"} {
+				t.Run(arch+"/"+fmt.Sprintf(row, operand), func(t *testing.T) {
+					ordinary := x86AddressMemorySinkSource(row, strings.TrimPrefix(operand, "$"))
+					goAssemblerOracleOutput(t, arch, ordinary, "", true)
+					source := x86AddressMemorySinkSource(row, operand)
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					for _, target := range x86AddressMemoryTargets(arch) {
+						for _, api := range []string{"text", "module", "go"} {
+							t.Run(target+"/"+api, func(t *testing.T) {
+								if _, err := x86AddressMemoryAPI(t, api, source, arch, target); err == nil {
+									t.Fatal("Go-rejected address bypassed memory-role validation")
+								}
+							})
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectSymbolMemorySinkObjectsRemainSupported(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86AddressMemorySinkRows(arch) {
+			source := x86AddressMemorySinkSource(row, "·cell+8(SB)")
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, target := range x86AddressMemoryTargets(arch) {
+				for _, api := range []string{"text", "module", "go"} {
+					t.Run(arch+"/"+row+"/"+target+"/"+api, func(t *testing.T) {
+						ir, err := x86AddressMemoryAPI(t, api, source, arch, target)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("format-only external sink acquired storage or x87 state", err)
+						}
+						if api == "text" {
+							x86LEAActualTargetGoObject(t, arch, target, source)
+							unit := x86ZeroArgumentLowererObjectUnit(t, mustParseX86RawReturn(t, source), arch, target, "ExternalSinkEmitterOnly",
+								func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+									if known, terminated, err := consumer.lowerMov(instruction.Op, instruction); known {
+										return known, terminated, err
+									}
+									if known, terminated, err := consumer.lowerVec(instruction.Op, instruction); known {
+										return known, terminated, err
+									}
+									if known, terminated, err := consumer.lowerFP(instruction.Op, instruction); known {
+										return known, terminated, err
+									}
+									return consumer.lowerX87(instruction.Op, instruction)
+								})
+							x86ResultInitializationObject(t, llc, target, unit, "original-external-sink-emitter-only")
+						}
+						if counterpart, integer := x86AddressIntegerSinkCounterpart(row); integer {
+							declaration := fmt.Sprintf("func Value(input %s)", counterpart.inputType)
+							body := x86X87IntegerInputCases(counterpart)[0].body
+							bounded := x86X87IntegerInputSource(t, arch, declaration, body, false, "")
+							boundedAPI := api
+							if api == "go" {
+								boundedAPI = "Go"
+							}
+							ir, err = x86X87InitializedWordAPI(t, bounded, declaration, arch, target, boundedAPI, X87Software)
+							if err != nil || ir == "" {
+								t.Fatal("independent initialized and balanced integer-sink counterpart failed", err)
+							}
+							x86ResultInitializationObject(t, llc, target, ir, "memory-sink")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+// Match the independent complete eight integer memory directions, never the
+// implementation's permission table. Their original external operands remain
+// unbound; the separate counterpart owns actual typed input/private storage.
+func x86AddressIntegerSinkCounterpart(row string) (x86X87IntegerInputRow, bool) {
+	for _, counterpart := range x86X87IntegerInputRows {
+		if counterpart.name == "round" {
+			continue
+		}
+		instruction := strings.ReplaceAll(counterpart.instruction, "input+0(FP)", "memory")
+		instruction = strings.ReplaceAll(instruction, "converted-8(SP)", "memory")
+		if fmt.Sprintf(row, "memory") == instruction {
+			return counterpart, true
+		}
+	}
+	return x86X87IntegerInputRow{}, false
+}
diff --git a/amd64_addsub_round_closure_test.go b/amd64_addsub_round_closure_test.go
new file mode 100644
index 000000000..c43faf9de
--- /dev/null
+++ b/amd64_addsub_round_closure_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Each complete original VEX row has register and memory counterparts.
+// This is bounded numerical availability/object evidence, not native FP,
+// MXCSR, fault execution or a certificate for the input pointee's extent.
+func TestX86AlternatingRoundInitializedOfficialRowsThreeAPIObjects(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, output := 8, "MOVQ", "VMOVUPS Z2,(DX)"
+			if target.arch == "386" {
+				word, move, output = 4, "MOVL", "VMOVUPS Y2,(DX)"
+			}
+			var source, declarations, refusedSource, refusedDeclarations strings.Builder
+			rows, functions, refusedRows, refusedFunctions := 0, 0, 0, 0
+			for _, row := range rules {
+				if row.Opcode != "VADDSUBPS" && row.Opcode != "VADDSUBPD" && row.Opcode != "VROUNDPS" && row.Opcode != "VROUNDPD" && row.Opcode != "VROUNDSS" && row.Opcode != "VROUNDSD" {
+					continue
+				}
+				rows++
+				goRefused := target.arch == "386" && (row.Opcode == "VROUNDSS" || row.Opcode == "VROUNDSD")
+				if goRefused {
+					refusedRows++
+				}
+				bank := map[string]string{"Yxr": "X", "Yyr": "Y"}[row.Classes[len(row.Classes)-1]]
+				if bank == "" {
+					t.Fatal("original row lost its VEX carrier", row)
+				}
+				immediate := "$7"
+				if row.Classes[0] == "Yi8" {
+					immediate = "$-1"
+				}
+				for _, memory := range []bool{false, true} {
+					name := fmt.Sprint("AlternatingRound", functions)
+					functions++
+					var function strings.Builder
+					declaration := fmt.Sprintf("func %s(out *[64]byte,a,b *[32]byte)\n", name)
+					fmt.Fprintf(&function, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DX\n%s a+%d(FP),AX\n", name, 3*word, move, move, word)
+					first := bank + "0"
+					if memory {
+						first = "(AX)"
+					} else {
+						function.WriteString("VMOVUPS (AX),Y0\n")
+					}
+					if strings.HasPrefix(row.Opcode, "VADDSUB") || strings.HasSuffix(row.Opcode, "SS") || strings.HasSuffix(row.Opcode, "SD") {
+						fmt.Fprintf(&function, "%s b+%d(FP),BX\nVMOVUPS (BX),Y1\n", move, 2*word)
+					}
+					switch {
+					case strings.HasPrefix(row.Opcode, "VADDSUB"):
+						fmt.Fprintf(&function, "%s %s,%s1,%s2\n", row.Opcode, first, bank, bank)
+					case strings.HasSuffix(row.Opcode, "SS") || strings.HasSuffix(row.Opcode, "SD"):
+						fmt.Fprintf(&function, "%s %s,%s,X1,X2\n", row.Opcode, immediate, first)
+					default:
+						fmt.Fprintf(&function, "%s %s,%s,%s2\n", row.Opcode, immediate, first, bank)
+					}
+					function.WriteString(output + "\nRET\n")
+					if goRefused {
+						refusedFunctions++
+						refusedSource.WriteString(function.String())
+						refusedDeclarations.WriteString(declaration)
+					} else {
+						source.WriteString(function.String())
+						declarations.WriteString(declaration)
+					}
+				}
+			}
+			if rows != 14 || functions != 28 {
+				t.Fatal("complete original row/source union changed", rows, functions)
+			}
+			if target.arch == "386" {
+				if refusedRows != 2 || refusedFunctions != 4 || rows-refusedRows != 12 || functions-refusedFunctions != 24 {
+					t.Fatal("mode32 ordinary/refused source union changed", rows, functions, refusedRows, refusedFunctions)
+				}
+				x86RoundRejectedGoSource(t, refusedSource.String(), refusedDeclarations.String(), target.arch, target.triple)
+			} else if refusedRows != 0 || refusedFunctions != 0 {
+				t.Fatal("AMD64 lost an original canonical row")
+			}
+			t.Logf("original rows=%d functions=%d selected rows=%d functions=%d refused rows=%d functions=%d", rows, functions, rows-refusedRows, functions-refusedFunctions, refusedRows, refusedFunctions)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete independently initialized alternating/round rows rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+
+}
diff --git a/amd64_addsub_round_forms.go b/amd64_addsub_round_forms.go
new file mode 100644
index 000000000..ce08cc12a
--- /dev/null
+++ b/amd64_addsub_round_forms.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Alternating add/sub uses the existing floating dependency record, with
+// its own complete legacy/VEX grammar and no EVEX mask or rounding forms.
+func x86AlternatingFloatProperties(ins Instr, arch string) (x86FloatBinaryForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	f := x86FloatBinaryForm{first: 0, second: 1, destination: len(ins.Args) - 1, mask: -1, memory: -1, byteWidth: 16}
+	switch name {
+	case "ADDSUBPS":
+		f.bits, f.legacy = 32, true
+	case "ADDSUBPD":
+		f.bits, f.legacy = 64, true
+	case "VADDSUBPS":
+		f.bits = 32
+	case "VADDSUBPD":
+		f.bits = 64
+	default:
+		return f, false, nil
+	}
+	if dotted {
+		return f, true, fmt.Errorf("%s %s has no suffixed forms in Go 1.27: %q", arch, name, ins.Raw)
+	}
+	legacyRegister := func(operand Operand) bool {
+		index, valid := amd64ParseXReg(operand.Reg)
+		return operand.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+	}
+	if f.legacy {
+		if len(ins.Args) != 2 || !legacyRegister(ins.Args[1]) {
+			return f, true, fmt.Errorf("%s %s expects X/m128, X using Go 1.27's yxm table: %q", arch, name, ins.Raw)
+		}
+		if ins.Args[0].Kind == OpReg {
+			if !legacyRegister(ins.Args[0]) {
+				return f, true, fmt.Errorf("%s %s source is outside the legacy X class: %q", arch, name, ins.Raw)
+			}
+		} else if !isAMD64MemoryOperand(ins.Args[0]) {
+			return f, true, fmt.Errorf("%s %s source must be X or memory: %q", arch, name, ins.Raw)
+		}
+	} else {
+		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
+			return f, true, fmt.Errorf("%s %s expects src1, src2, destination: %q", arch, name, ins.Raw)
+		}
+		f.byteWidth = amd64VectorByteWidth(ins.Args[2].Reg)
+		if f.byteWidth != 16 && f.byteWidth != 32 || !amd64VEXVectorRegister(ins.Args[1], f.byteWidth) || !amd64VEXVectorRegister(ins.Args[2], f.byteWidth) {
+			return f, true, fmt.Errorf("%s %s second source and destination must be same-width VEX X/Y registers: %q", arch, name, ins.Raw)
+		}
+		if ins.Args[0].Kind == OpReg {
+			if !amd64VEXVectorRegister(ins.Args[0], f.byteWidth) {
+				return f, true, fmt.Errorf("%s %s first source must match the destination width: %q", arch, name, ins.Raw)
+			}
+		} else if !isAMD64MemoryOperand(ins.Args[0]) {
+			return f, true, fmt.Errorf("%s %s first source must be a vector register or memory: %q", arch, name, ins.Raw)
+		}
+	}
+	if isAMD64MemoryOperand(ins.Args[0]) {
+		f.memory, f.memoryBytes = 0, f.byteWidth
+	}
+	return f, true, nil
+}
+
+type x86RoundForm struct {
+	spec                       amd64RoundSpec
+	source, upper, destination Operand
+	byteWidth, memoryBytes     int
+	immediate                  uint8
+	memory                     bool
+}
+
+// The original single round spec remains the only operation selector. Scalar
+// source bytes and upper-copy bytes stay separate from the X/Y carrier.
+func x86RoundProperties(ins Instr, arch string) (x86RoundForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64RoundSpecs[Op(name)]
+	f := x86RoundForm{spec: spec}
+	if !known {
+		return f, false, nil
+	}
+	if dotted {
+		return f, true, fmt.Errorf("%s %s does not accept instruction suffixes: %q", arch, name, ins.Raw)
+	}
+	want := 3
+	if spec.vector && spec.scalar {
+		want = 4
+	}
+	if len(ins.Args) != want {
+		return f, true, fmt.Errorf("%s %s expects immediate, source, %sdestination: %q", arch, name, map[bool]string{true: "upper-lane source, "}[spec.vector && spec.scalar], ins.Raw)
+	}
+	// I386's ordinary Go frontend does not accept this four-operand form.
+	// A normalized encoded instruction retains its separate physical grammar.
+	if arch == "386" && spec.vector && spec.scalar && !ins.x86Encoded && ins.x86SourceRaw == nil {
+		return f, true, fmt.Errorf("%s %s four-operand form is not accepted by Go's frontend: %q", arch, name, ins.Raw)
+	}
+	immediate := ins.Args[0]
+	if !amd64UnsignedImmediate(immediate, 8) &&
+		!(spec.vector && !spec.scalar && amd64VectorByteShiftImmediate(immediate)) {
+		return f, true, fmt.Errorf("%s %s expects an integer immediate within Go's 8-bit table: %q", arch, name, ins.Raw)
+	}
+	imm := immediate.Imm
+	f.immediate, f.source, f.destination = uint8(imm), ins.Args[1], ins.Args[len(ins.Args)-1]
+	if f.destination.Kind != OpReg {
+		return f, true, fmt.Errorf("%s %s destination must be a vector register: %q", arch, name, ins.Raw)
+	}
+	f.byteWidth = amd64VectorByteWidth(f.destination.Reg)
+	register := func(operand Operand, width int, memory bool) bool {
+		if memory && isAMD64MemoryOperand(operand) {
+			return true
+		}
+		index, valid := amd64VectorRegisterIndex(operand.Reg, width)
+		return amd64VEXVectorRegister(operand, width) && valid && (arch != "386" || index < 8)
+	}
+	if spec.scalar {
+		if f.byteWidth != 16 || !register(f.destination, 16, false) {
+			return f, true, fmt.Errorf("%s %s destination must be an X register in the Go VEX class: %q", arch, name, ins.Raw)
+		}
+	} else if !spec.vector && f.byteWidth != 16 || spec.vector && f.byteWidth != 16 && f.byteWidth != 32 || !register(f.destination, f.byteWidth, false) {
+		return f, true, fmt.Errorf("%s %s destination has a width outside Go 1.27's table: %q", arch, name, ins.Raw)
+	}
+	if !register(f.source, f.byteWidth, true) {
+		return f, true, fmt.Errorf("%s %s source must be same-width X/Y or memory: %q", arch, name, ins.Raw)
+	}
+	f.upper = f.destination
+	if spec.vector && spec.scalar {
+		f.upper = ins.Args[2]
+		if !register(f.upper, 16, false) {
+			return f, true, fmt.Errorf("%s %s upper-lane source must be an X register: %q", arch, name, ins.Raw)
+		}
+	}
+	f.memory, f.memoryBytes = isAMD64MemoryOperand(f.source), f.byteWidth
+	if spec.scalar {
+		f.memoryBytes = spec.laneBits / 8
+	}
+	return f, true, nil
+}
+
+func x86TypedAlternatingFloatByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	f, known, err := x86AlternatingFloatProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		err = fmt.Errorf("alternating floating dispatch/source opcode mismatch")
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: f.first, operand: ins.Args[f.first], width: int64(f.byteWidth), read: true},
+		{index: f.second, operand: ins.Args[f.second], width: int64(f.byteWidth), read: true},
+		{index: f.destination, operand: ins.Args[f.destination], width: int64(f.byteWidth), write: true},
+	}}
+	effect.vector.upperWrite = x86TypedVectorUpperZero
+	if f.legacy {
+		effect.vector.upperWrite = x86TypedVectorUpperPreserve
+	}
+	return effect, true, nil
+}
+
+func x86TypedRoundByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	f, known, err := x86RoundProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		err = fmt.Errorf("round dispatch/source opcode mismatch")
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: 1, read: true},
+		{index: 1, operand: f.source, width: int64(f.memoryBytes), read: true},
+	}}
+	if f.spec.scalar {
+		upper := len(ins.Args) - 1
+		if f.spec.vector {
+			upper = 2
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: upper, operand: f.upper, width: 16, read: true, requiredBytes: 0xffff &^ x86CallerVectorByteMask(int64(f.memoryBytes))})
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{index: len(ins.Args) - 1, operand: f.destination, width: int64(f.byteWidth), write: true})
+	effect.vector.upperWrite = x86TypedVectorUpperZero
+	if !f.spec.vector {
+		effect.vector.upperWrite = x86TypedVectorUpperPreserve
+	}
+	return effect, true, nil
+}
diff --git a/amd64_addsub_round_memory.go b/amd64_addsub_round_memory.go
new file mode 100644
index 000000000..7a82cea67
--- /dev/null
+++ b/amd64_addsub_round_memory.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import "fmt"
+
+// Only these normalized VEX family forms select an observable read. Legacy,
+// registers and logical FP retain their existing evaluator and alias behavior.
+// This is emission, never a source, address, extent or caller certificate.
+func (c *amd64Ctx) loadAlternatingRoundFloat(operand Operand, width, bits int, observable bool) (string, error) {
+	if observable && (operand.Kind == OpMem || operand.Kind == OpSym) {
+		bytes, err := c.loadX86PackedShiftBytes(operand, width, true)
+		if err != nil {
+			return "", err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", result, width, bytes, amd64FMA3LLVMType(width*8/bits, bits))
+		return "%" + result, nil
+	}
+	if width*8 == bits {
+		return c.evalScalarFloatForInteger(operand, bits)
+	}
+	return c.loadHorizontalFloatingOperand(operand, width, bits)
+}
+
+func (c *amd64Ctx) loadRoundPackedBytes(form x86RoundForm) (string, error) {
+	if form.spec.vector && (form.source.Kind == OpMem || form.source.Kind == OpSym) {
+		return c.loadX86PackedShiftBytes(form.source, form.byteWidth, true)
+	}
+	return c.loadPackedCompareBytes(form.source, form.byteWidth)
+}
diff --git a/amd64_adx_forms.go b/amd64_adx_forms.go
new file mode 100644
index 000000000..aad936e12
--- /dev/null
+++ b/amd64_adx_forms.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type x86ADXForm struct {
+	spec                amd64ADXSpec
+	source, destination Operand
+}
+
+// All four yml_rl rows share one complete grammar. Their independent CF/OF
+// chains are effects, not source-memory, native-entry or numerical authority.
+func x86ADXProperties(op Op, ins Instr, arch string) (x86ADXForm, bool, error) {
+	name, _, suffix := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64ADXSpecs[Op(name)]
+	form := x86ADXForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86ADXForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go ADX yml_rl grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 || suffix || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	form.source, form.destination = ins.Args[0], ins.Args[1]
+	if form.destination.Kind != OpReg || !isX86YrlRegisterForArch(form.destination.Reg, arch) {
+		return fail()
+	}
+	if form.source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.source.Reg, arch) {
+			return fail()
+		}
+	} else if !x86ScalarCompareMemoryValid(form.source, arch) {
+		if ins.x86Encoded && ins.x86RIPLiteral && form.source.Kind == OpImm {
+			return form, true, fmt.Errorf("%w: physical ADX literal needs its original native-read role", ErrProbeNeedsContext)
+		}
+		return fail()
+	}
+	return form, true, nil
+}
+
+func (form x86ADXForm) carryFlag() uint8 {
+	if form.spec.carry == amd64ADXCarryOF {
+		return x86ByteFlagOF
+	}
+	return x86ByteFlagCF
+}
+
+func x86TypedADXByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86ADXProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.spec.bits / 8)
+	flag := form.carryFlag()
+	return x86TypedByteEffect{requiresResultProof: true, flagsRead: flag, flagsDefined: flag, flagsKilled: flag,
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: form.source, width: width, read: true},
+			{index: 1, operand: form.destination, width: width, read: true, write: true},
+		}}, true, nil
+}
+
+func x86RawADXSource(ins Instr, arch string) bool {
+	_, known, err := x86ADXProperties(ins.Op, ins, arch)
+	origin := ins.x86SourceRaw
+	if !known || err != nil || origin == nil || origin.op != ins.Op || !reflect.DeepEqual(origin.args, ins.Args) ||
+		origin.vectorBytes != ins.x86VectorBytes || origin.addressBits != ins.x86AddressBits ||
+		ins.x86AddressBits != goWordSize(arch)*8 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 ||
+		ins.x86RawNearReturn != nil || ins.x86RIPLiteral || ins.x86NumericalRead != nil {
+		return false
+	}
+	source := ins.Args[0]
+	return source.Kind == OpReg || source.Kind == OpMem && x86OrdinaryNativeMemoryOperand(source, arch)
+}
+
+func x86LoweredADXResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ADXProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawADXSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw, local.x86AddressBits = false, nil, 0
+	}
+	if !x86OrdinaryNativeMemoryOperand(form.source, arch) {
+		return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+	}
+	effect, _, err := x86TypedADXByteEffect(local.Op, local, arch)
+	if err != nil || state.flags&effect.flagsRead != effect.flagsRead {
+		return false, true
+	}
+	for _, input := range effect.operands {
+		if input.read && !x86ResultReadWithNativeContinuation(local, input.operand, input.width, state, owned, arch, true) {
+			return false, true
+		}
+	}
+	if !x86ResultStore(form.destination, int64(form.spec.bits/8), state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
diff --git a/amd64_aes_family_effects_test.go b/amd64_aes_family_effects_test.go
new file mode 100644
index 000000000..a3c5e10f8
--- /dev/null
+++ b/amd64_aes_family_effects_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent source inventory: six SSE names and their six AVX names. AES
+// round rows are destructive only in their legacy spelling; no Go AES row
+// has a K operand, broadcast or zeroing suffix.
+var x86AESOracleNames = []string{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST", "VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST", "VAESIMC", "VAESKEYGENASSIST"}
+
+func x86AESOracleRow(name, source, bank string) (string, int) {
+	if strings.Contains(name, "KEYGEN") {
+		return name + " $27," + source + "," + bank + "2", 2
+	}
+	if strings.HasSuffix(name, "IMC") {
+		return name + " " + source + "," + bank + "2", 2
+	}
+	if strings.HasPrefix(name, "V") {
+		return name + " " + source + "," + bank + "1," + bank + "2", 2
+	}
+	return name + " " + source + "," + bank + "1", 1
+}
+
+func TestX86AESFamilyInitialTypedAndPrivateResults(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86AESOracleNames {
+			row, destination := x86AESOracleRow(name, "X0", "X")
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+				ins := x86YMMReadSource(t, row)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatalf("complete AES typed byte/flags effect absent: known=%t err=%v", known, err)
+				}
+				for _, transfer := range []struct {
+					name string
+					fn   func(Instr, *x86ResultState, []bool, int64, string) bool
+				}{{"public", x86ResultTransfer}, {"private", x86ScalarFPResultTransfer}} {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+					if !transfer.fn(ins, &state, nil, 0, arch) || state.xmm[destination] != 0xffff || state.flags != x86ByteFlagsAll {
+						t.Fatal(transfer.name, "lost complete AES input/result or preserved flags", state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86AESFamilyInitialCallerSourceEffects(t *testing.T) {
+	for _, name := range x86AESOracleNames {
+		row, destination := x86AESOracleRow(name, "X0", "X")
+		t.Run(name, func(t *testing.T) {
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\n" + row + fmt.Sprintf("\nVMOVSS X%d,(DX)", destination)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal("actual Go accepted whole-family caller has no registered AES source effect", err)
+			}
+		})
+	}
+}
+
+func TestX86AESFamilyResultEveryNativeMemoryByte(t *testing.T) {
+	for _, name := range x86AESOracleNames {
+		row, destination := x86AESOracleRow(name, "a+0(FP)", "X")
+		ins := x86YMMReadSource(t, row)
+		for missing := -1; missing < 16; missing++ {
+			t.Run(fmt.Sprintf("%s/missing%d", name, missing), func(t *testing.T) {
+				state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll}
+				state.xmm[1] = 0xffff
+				owned := make([]bool, 16)
+				for i := range owned {
+					owned[i], state.fp[i] = true, i != missing
+				}
+				before := state.clone()
+				got := x86ScalarFPResultTransfer(ins, &state, owned, 16, "amd64")
+				if got != (missing == -1) || got && state.xmm[destination] != 0xffff || !got && !reflect.DeepEqual(state, before) {
+					t.Fatal("native m128 envelope/unknown byte must not be shrunk to numerical subwords", got, state)
+				}
+			})
+		}
+	}
+}
+
+func TestX86AESFamilyWholeSourceResultsCannotLaunderUndefinedInputs(t *testing.T) {
+	for _, name := range x86AESOracleNames {
+		row, destination := x86AESOracleRow(name, "X0", "X")
+		for _, target := range x86RawReturnTargets {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(name+"/"+target.triple+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·F(SB),4,$0-4\n%s\nMOVL X%d,AX\nMOVL AX,ret+0(FP)\nRET\n", row, destination)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func F() uint32\n", target.arch, target.triple, api)
+					if target.arch == "amd64" {
+						x86VectorScratchCodegenControl(t, source, "func F() uint32\n", target.arch, target.triple, ir, err)
+						return
+					}
+					if err == nil {
+						t.Fatal("undefined AES byte escaped through GP result-store fallback")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_aes_family_encoder_test.go b/amd64_aes_family_encoder_test.go
new file mode 100644
index 000000000..55504de47
--- /dev/null
+++ b/amd64_aes_family_encoder_test.go
@@ -0,0 +1,531 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86AESFamilyNamedAndRawThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var source, declarations strings.Builder
+				declarations.WriteString("package aesobjects\n")
+				count := 0
+				for _, name := range x86AESOracleNames {
+					widths := []int{16}
+					if strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+						widths = append(widths, 32, 64)
+					}
+					for _, width := range widths {
+						bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+						for _, operand := range []string{bank + "0", fmt.Sprintf("%d(AX)(CX*2)", width)} {
+							row, _ := x86AESOracleRow(name, operand, bank)
+							code := x86OrderingHintGoBytes(t, target.arch, "TEXT actual(SB),4,$0-0\n"+row+"\nRET\n")
+							if raw {
+								row = x86DwordProductDirectives(code[:len(code)-1])
+							}
+							fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", count, row)
+							fmt.Fprintf(&declarations, "func F%d()\n", count)
+							count++
+						}
+					}
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("original AES formats invented native addresses or vector inputs", api, err)
+						}
+					})
+				}
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				signatures := make(map[string]FuncSig)
+				for _, fn := range file.Funcs {
+					name := strings.TrimPrefix(fn.Sym, "·")
+					signatures[name] = FuncSig{Name: name, Ret: Void}
+				}
+				ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+					func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerAES(ins.Op, ins) })
+				for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, input, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86AESFamilyCompressedDisp8EntireTupleAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86AESOracleNames[6:10] {
+			for _, width := range []int{16, 32, 64} {
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				for _, disp := range []int{-128, -1, 1, 127} {
+					for _, address := range []string{fmt.Sprintf("%d(AX)", disp*width), fmt.Sprintf("%d(AX)(CX*2)", disp*width), fmt.Sprintf("%d(BP)", disp*width)} {
+						// X16 forces Go's EVEX X/Y rows. Their original bytes are
+						// never patched into a different register contract. Go accepts
+						// that spelling in mode32, but physical high banks remain Context.
+						row := name + " " + address + "," + bank + "1," + bank + "16"
+						if width == 64 {
+							row = name + " " + address + ",Z1,Z2"
+						}
+						t.Run(arch+"/"+row, func(t *testing.T) {
+							code := x86OrderingHintGoBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+							mode := 64
+							if arch == "386" {
+								if width != 64 {
+									if _, _, known, err := decodedX86AESInstruction(code, 32); !known || !errors.Is(err, ErrProbeNeedsContext) {
+										t.Fatal("actual mode32 high destination acquired a low-bank identity", row, fmt.Sprintf("%x", code), err)
+									}
+									// Inspect exactly the same original bytes in physical
+									// mode64 for their tuple address, not mode32 permission.
+								} else {
+									mode = 32
+								}
+							}
+							ins, length, known, err := decodedX86AESInstruction(code, mode)
+							if !known || err != nil || length != len(code)-1 || ins.Args[0].Mem.Off != int64(disp*width) {
+								t.Fatal("actual Go compressed full tuple did not retain exact native address", row, fmt.Sprintf("%x", code), ins, err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86AESFamilyOriginalGoPhysicalRegisterExtensionAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86AESOracleNames[6:10] {
+			for _, width := range []int{16, 32, 64} {
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				for role := 0; role < 3; role++ {
+					for _, index := range []int{0, 7, 8, 15, 16, 31} {
+						args := []string{bank + "0", bank + "1", bank + "2"}
+						args[role] = fmt.Sprintf("%s%d", bank, index)
+						row := name + " " + strings.Join(args, ",")
+						t.Run(arch+"/"+row, func(t *testing.T) {
+							if arch == "386" && width == 64 && index >= 8 {
+								goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+								if _, known, err := x86AESProperties(Op(name), x86YMMReadSource(t, row), arch); !known || err == nil {
+									t.Fatal("actual Go rejected mode32 Z bank acquired a valid grammar row", row, err)
+								}
+								return
+							}
+							code := x86OrderingHintGoBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+							mode := 64
+							if arch == "386" {
+								mode = 32
+								if index >= 8 {
+									if _, _, known, err := decodedX86AESInstruction(code, mode); !known || !errors.Is(err, ErrProbeNeedsContext) {
+										t.Fatal("actual Go high spelling acquired a different physical mode32 register", row, fmt.Sprintf("%x", code), err)
+									}
+									return
+								}
+							}
+							ins, length, known, err := decodedX86AESInstruction(code, mode)
+							if !known || err != nil || length != len(code)-1 || ins.Args[role].Reg != Reg(args[role]) {
+								t.Fatal("all original VEX/EVEX source/state/destination extension bits", row, fmt.Sprintf("%x", code), ins, err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86AESFamilyMode32NamedHighAndRawReservedBoundaries(t *testing.T) {
+	for _, name := range x86AESOracleNames[6:10] {
+		for _, bank := range []string{"X", "Y"} {
+			row := name + " " + bank + "16," + bank + "1," + bank + "2"
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			if _, known, err := x86AESProperties(Op(name), x86YMMReadSource(t, row), "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Go named high mode32 vector borrowed physical identity", row, err)
+			}
+		}
+	}
+	valid := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\nVAESENC 64(AX),Z1,Z2\nRET\n")
+	for _, mutation := range []func([]byte){func(b []byte) { b[2] &^= 4 }, func(b []byte) { b[3] |= 1 }, func(b []byte) { b[3] |= 0x80 }, func(b []byte) { b[3] |= 0x10 }, func(b []byte) { b[3] |= 0x60 }} {
+		changed := append([]byte(nil), valid...)
+		mutation(changed)
+		if _, _, known, err := decodedX86AESInstruction(changed, 64); !known || err == nil {
+			t.Fatal("reserved AES bytes acquired an unrelated raw effect", fmt.Sprintf("%x", changed), err)
+		}
+	}
+}
+
+func TestX86AESFamilyPhysicalWIGIndependentLLVMDecoder(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, name := range x86AESOracleNames[6:] {
+		forms := []struct {
+			width       int
+			destination int
+		}{{16, 2}}
+		if !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+			forms = append(forms, struct {
+				width       int
+				destination int
+			}{32, 2}, struct {
+				width       int
+				destination int
+			}{16, 16}, struct {
+				width       int
+				destination int
+			}{32, 16}, struct {
+				width       int
+				destination int
+			}{64, 2})
+		}
+		for _, form := range forms {
+			width := form.width
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			row, _ := x86AESOracleRow(name, fmt.Sprintf("%d(AX)", width), bank)
+			row = strings.TrimSuffix(row, bank+"2") + fmt.Sprintf("%s%d", bank, form.destination)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			// Intel's VEX and EVEX AES attributes are WIG. This is an
+			// explicit physical-attribute fixture, not a claimed Go named row.
+			for _, wide := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/W=%t", row, wide), func(t *testing.T) {
+					physical := append([]byte(nil), code[:len(code)-1]...)
+					if wide {
+						physical[2] |= 0x80
+					}
+					var input strings.Builder
+					for _, b := range physical {
+						fmt.Fprintf(&input, "0x%02x ", b)
+					}
+					ctx, cancel := runtimeOracleStageContext(t)
+					defer cancel()
+					command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=x86_64-unknown-linux-gnu")
+					command.Stdin = strings.NewReader(input.String() + "\n")
+					output, err := runtimeOracleCombinedOutput(ctx, command)
+					if err != nil || !strings.Contains(strings.ToLower(string(output)), strings.ToLower(name)) || strings.Contains(string(output), "warning:") {
+						t.Fatal("independent LLVM22 physical WIG decoder", err, string(output))
+					}
+					ins, length, known, err := decodedX86AESInstruction(physical, 64)
+					if !known || err != nil || length != len(physical) || ins.Op != Op(name) {
+						t.Fatal("complete physical AES WIG attribute lost", fmt.Sprintf("%x", physical), ins, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86AESFamilyLogicalFPNumericalSpanContracts(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range x86AESOracleNames {
+			row, _ := x86AESOracleRow(name, "a+0(FP)", "X")
+			for _, contract := range []struct {
+				parameters string
+				accepted   bool
+			}{{"a,b uint64", true}, {"a,b,c,d float32", true}, {"a,b float64", true},
+				{"a uint8,b uint64", false}, {"a uint8,b uint64,c uint32", false}, {"a,b *byte", false}, {"a,b,c,d *byte", false}} {
+				t.Run(target.triple+"/"+name+"/"+contract.parameters, func(t *testing.T) {
+					size := 16
+					switch contract.parameters {
+					case "a uint8,b uint64":
+						if target.arch == "386" {
+							size = 12
+						}
+					case "a uint8,b uint64,c uint32":
+						if target.arch == "amd64" {
+							size = 20
+						}
+					case "a,b *byte":
+						size = int(goWordSize(target.arch)) * 2
+					case "a,b,c,d *byte":
+						size = int(goWordSize(target.arch)) * 4
+					}
+					source := fmt.Sprintf("TEXT ·F(SB),4,$0-%d\n%s\nRET\n", size, row)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					initialized := strings.Replace(source, fmt.Sprintf("$0-%d\n", size),
+						fmt.Sprintf("$0-%d\nMOVL $1,AX\nMOVL AX,X1\n", size), 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							declaration := "func F(" + contract.parameters + ")\n"
+							if contract.accepted && strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+								if ir == "" || err != nil {
+									t.Fatal("unused original FP round result cannot change an unrelated source contract", api, err)
+								}
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, initialized, declaration, target.arch, target.triple, api)
+							accepted := contract.accepted && strings.HasPrefix(name, "V")
+							if (err == nil) != accepted || !accepted && ir != "" {
+								t.Fatal("numeric FP bytes cannot supply native legacy AES alignment, holes or pointer backing", accepted, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86AESFamilyAbsoluteDisp32AndImmediateClasses(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86AESOracleNames {
+			for _, address := range []int64{-2147483649, -2147483648, 2147483647, 4294967295, 4294967296} {
+				accepted := address == int64(int32(address)) || arch == "386" && address == int64(uint32(address))
+				row, _ := x86AESOracleRow(name, fmt.Sprint(address), "X")
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", accepted)
+					_, known, err := x86AESProperties(Op(name), x86YMMReadSource(t, row), arch)
+					if !known || (err == nil) != accepted {
+						t.Fatal("physical Go disp32 extent differs from shared AES grammar", accepted, err)
+					}
+				})
+			}
+		}
+		for _, name := range []string{"AESKEYGENASSIST", "VAESKEYGENASSIST"} {
+			var all strings.Builder
+			for immediate := -129; immediate <= 256; immediate++ {
+				accepted := immediate >= 0 && immediate <= 255 || name == "VAESKEYGENASSIST" && immediate >= -128 && immediate < 0
+				row := fmt.Sprintf("%s $%d,X0,X2", name, immediate)
+				if accepted {
+					all.WriteString(row + "\n")
+				} else {
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+				}
+				if _, known, err := x86AESProperties(Op(name), x86YMMReadSource(t, row), arch); !known || (err == nil) != accepted {
+					t.Fatal("complete Yu8/Yi8 immediate classes", arch, row, accepted, err)
+				}
+			}
+			goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+all.String()+"RET\n", "", true)
+		}
+	}
+}
+
+func TestX86AESFamilyCompleteIndependentEncoderRows(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	data, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []struct{ name, body string }{{"yaes", "{Zlitm_r, 2, argList{Yxm, Yxr}},"}, {"yxshuf", "{Zibm_r, 2, argList{Yu8, Yxm, Yxr}},"}} {
+		start := strings.Index(string(data), "var "+table.name+" = []ytab{")
+		if start < 0 {
+			t.Fatal(table.name)
+		}
+		actual := strings.SplitN(strings.SplitN(string(data)[start:], "\n}", 2)[0], "[]ytab{", 2)[1]
+		a, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+		if err != nil {
+			t.Fatal(err)
+		}
+		w, err := x86SignedPackedFloatGoOpcodeTokens(table.body)
+		if err != nil || !reflect.DeepEqual(a, w) {
+			t.Fatal("complete legacy zcase/zoffset/classes changed", table.name, actual)
+		}
+	}
+	legacyRows := regexp.MustCompile(`\{A(AES[A-Z]+), ([^,]+), ([^,]+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(legacyRows) != 6 || len(x86AESSpecs) != 12 {
+		t.Fatal("whole family inventory changed", len(legacyRows), len(x86AESSpecs))
+	}
+	for i, name := range x86AESOracleNames[:6] {
+		table, escape, opcode := "yaes", "0x38", []string{"0xdc", "0xdd", "0xde", "0xdf", "0xdb", "0xdf"}[i]
+		if i == 5 {
+			table, escape = "yxshuf", "0x3a"
+		}
+		want := fmt.Sprintf("{A%s, %s, Pq, opBytes{%s, %s, 0}}", name, table, escape, opcode)
+		if !strings.Contains(string(data), want) {
+			t.Fatal("legacy complete prefix/opcode attributes changed", want)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if !strings.HasPrefix(rule.Opcode, "VAES") {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		isIMC, isKey := rule.Opcode == "VAESIMC", rule.Opcode == "VAESKEYGENASSIST"
+		opcode := map[string]string{"VAESENC": "0xDC", "VAESENCLAST": "0xDD", "VAESDEC": "0xDE", "VAESDECLAST": "0xDF", "VAESIMC": "0xDB", "VAESKEYGENASSIST": "0xDF"}[rule.Opcode]
+		if opcode == "" {
+			t.Fatal("unaccounted actual Go AES member", rule.Opcode)
+		}
+		table, classes, zcase := "_yvaesdec", []string{"Yxm,Yxr,Yxr", "Yym,Yyr,Yyr", "YxmEvex,YxrEvex,YxrEvex", "YymEvex,YyrEvex,YyrEvex", "Yzm,Yzr,Yzr"}, "Zvex_rm_v_r"
+		zoffset, offset := []int{2, 2, 3, 3, 3}, []int{0, 2, 4, 7, 10}
+		var opbytes []string
+		if isKey {
+			table, classes, zcase = "_yvaeskeygenassist", []string{"Yu8,Yxm,Yxr", "Yi8,Yxm,Yxr"}, "Zvex_i_rm_r"
+			zoffset, offset = []int{0, 2}, []int{0, 0}
+			opbytes = []string{"avxEscape | vex128 | vex66 | vex0F3A | vexW0", opcode}
+		} else if isIMC {
+			table, classes = "_yvaesimc", []string{"Yxm,Yxr"}
+			zoffset, offset = []int{2}, []int{0}
+			opbytes = []string{"avxEscape | vex128 | vex66 | vex0F38 | vexW0", opcode}
+		} else {
+			for _, width := range []int{128, 256} {
+				opbytes = append(opbytes, fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F38 | vexW0", width), opcode)
+			}
+			for _, width := range []int{128, 256, 512} {
+				opbytes = append(opbytes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW0", width), fmt.Sprintf("evexN%d", width/8), opcode)
+			}
+			if index >= 2 {
+				zcase = "Zevex_rm_v_r"
+			}
+		}
+		if index >= len(classes) || rule.RowIndex != index || rule.Ytab != table || rule.Prefix != "Pavx" || rule.ZCase != zcase || rule.ZOffset != zoffset[index] || rule.EncodingOffset != offset[index] || strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, opbytes) {
+			t.Fatal("independent entire encoder row/attributes changed", rule)
+		}
+	}
+	for i, name := range x86AESOracleNames[6:] {
+		want := 5
+		if i == 4 {
+			want = 1
+		}
+		if i == 5 {
+			want = 2
+		}
+		if counts[name] != want {
+			t.Fatal(name, counts, want)
+		}
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil || regexp.MustCompile(`instructions\["V?AES`).Match(aliases) {
+		t.Fatal("actual Go AES alias inventory changed", err)
+	}
+}
+
+func TestX86AESFamilyActualGoRawEncoderForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86AESOracleNames {
+			widths := []int{16}
+			if strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+				widths = append(widths, 32, 64)
+			}
+			for _, width := range widths {
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				for _, source := range []string{bank + "0", fmt.Sprintf("%d(AX)", width), fmt.Sprintf("-%d(AX)(CX*2)", width), "(FS)", "(GS)"} {
+					row, _ := x86AESOracleRow(name, source, bank)
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						code := x86OrderingHintGoBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+						file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+x86DwordProductDirectives(code[:len(code)-1])+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						decoded, err := decodeX86RawDirectives(file.Funcs[0], arch)
+						if err != nil {
+							t.Fatal("actual Go AES physical row missing", row, fmt.Sprintf("%x", code), err)
+						}
+						ins := decoded.Instrs[1]
+						form, known, err := x86AESProperties(ins.Op, ins, arch)
+						if !known || err != nil || form.byteWidth != width {
+							t.Fatal("actual Go raw AES identity", ins, err)
+						}
+						named := x86YMMReadSource(t, row)
+						for i := range named.Args {
+							if named.Args[i].Kind == OpMem && (named.Args[i].Mem.Base == FS || named.Args[i].Mem.Base == GS) {
+								named.Args[i].Mem.Segment, named.Args[i].Mem.Base = named.Args[i].Mem.Base, ""
+							}
+							if named.Args[i].Kind == OpMem && named.Args[i].Mem.Index == "" {
+								named.Args[i].Mem.Scale = ins.Args[i].Mem.Scale // no-index scale is not an encoded input
+							}
+							if named.Args[i].Kind == OpMem && strings.Contains(name, "KEYGEN") {
+								named.Args[i].Mem.Segment = "" // actual From3 prefix omission, independently bound above
+							}
+						}
+						if ins.Op != named.Op || !reflect.DeepEqual(ins.Args, named.Args) {
+							t.Fatalf("physical original operand/tuple width changed %s code=%x actual=%#v named=%#v", row, code, ins.Args, named.Args)
+						}
+					})
+				}
+			}
+		}
+	}
+	// Independent fixed byte witness: prefix, map, opcode and immediate. The
+	// source encoder is checked independently of our decoder/typed grammar.
+	for name, want := range map[string][]byte{"AESENC X0,X1": {0x66, 0x0f, 0x38, 0xdc, 0xc8, 0xc3}, "AESKEYGENASSIST $27,X0,X2": {0x66, 0x0f, 0x3a, 0xdf, 0xd0, 27, 0xc3}, "VAESENC X0,X1,X2": {0xc4, 0xe2, 0x71, 0xdc, 0xd0, 0xc3}, "VAESKEYGENASSIST $-128,X0,X2": {0xc4, 0xe3, 0x79, 0xdf, 0xd0, 128, 0xc3}} {
+		got := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+name+"\nRET\n")
+		if !bytes.Equal(got, want) {
+			t.Fatal("independent fixed AES prefix/opcode bytes", name, got, want)
+		}
+	}
+}
+
+func TestX86AESFamilyThreeAPIsFiveTargetNumericResults(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, name := range x86AESOracleNames {
+				for _, memory := range []bool{false, true} {
+					first, params, offset := "X0", "", 0
+					if memory {
+						first, params, offset = "a+0(FP)", "a,b uint64", 16
+					}
+					row, destination := x86AESOracleRow(name, first, "X")
+					if memory && !strings.HasPrefix(name, "V") {
+						row, destination = x86AESOracleRow(name, "X3", "X")
+						row = "MOVOU a+0(FP),X3\n" + row
+					}
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-%d\nMOVL $1,AX\nMOVL AX,X0\nMOVL AX,X1\n%s\nMOVQ X%d,ret+%d(FP)\nRET\n", count, offset+8, row, destination, offset)
+					fmt.Fprintf(&declarations, "func F%d(%s) uint64\n", count, params)
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "aes-results-"+api+".ll", "aes-results-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86AESFamilyPermissionAndEncodingBoundaries(t *testing.T) {
+	for _, name := range x86AESOracleNames {
+		for _, source := range []string{"(SP)", "(BP)", "tmp(SP)"} {
+			row, _ := x86AESOracleRow(name, source, "X")
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-16\n"+row+"\nRET\n", "", true)
+			ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·F(SB),4,$0-16\n"+row+"\nRET\n", "func F(a,b uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatal("AES grammar granted unbound native stack storage", row, err)
+			}
+		}
+	}
+}
diff --git a/amd64_aes_family_fault_runtime_unix_test.go b/amd64_aes_family_fault_runtime_unix_test.go
new file mode 100644
index 000000000..b218a5210
--- /dev/null
+++ b/amd64_aes_family_fault_runtime_unix_test.go
@@ -0,0 +1,143 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86AESFamilyLiveDeadFaultEnvelopes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	declarations.WriteString("package aesfault\n")
+	count, outcomes := 0, 0
+	for _, name := range x86AESOracleNames {
+		legacy := !strings.HasPrefix(name, "V")
+		widths := []int{16}
+		if !legacy && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+			widths = append(widths, 32, 64)
+		}
+		for _, width := range widths {
+			for _, dead := range []bool{false, true} {
+				fn := fmt.Sprintf("F%d", count)
+				count++
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				row, destination := x86AESOracleRow(name, "(DI)", bank)
+				store := ""
+				if !dead {
+					store = fmt.Sprintf("MOVQ out+8(FP),SI\nVMOVUPS %s%d,(SI)\n", bank, destination)
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DI\nVPXORD Z1,Z1,Z1\n%s\n%sRET\n", fn, row, store)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte,out *[64]byte)\n", fn)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint8_t*);\n", fn)
+				original := "NULL"
+				legacyInt := 0
+				if legacy {
+					legacyInt = 1
+					original = "Original" + fn
+					nativeStore := ""
+					if !dead {
+						nativeStore = fmt.Sprintf("MOVOU X%d,(SI)\n", destination)
+					}
+					actual := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\nPXOR X1,X1\n"+row+"\n"+nativeStore+"RET\n")
+					var encoded []string
+					for _, value := range actual {
+						encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+					}
+					symbol := original
+					if strings.Contains(execution.triple, "apple") {
+						symbol = "_" + symbol
+					}
+					fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(encoded, ",")+"\n")
+					fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint8_t*);\n", original)
+					outcomes += 9
+				}
+				outcomes += 9
+				fmt.Fprintf(&rows, "{%s,%s,%d,%d},\n", fn, original, width, legacyInt)
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir := x86NarrowOracleIR(t, source.String(), declarations.String(), execution.triple)
+	// Rosetta is a differential diagnostic, not the native alignment oracle.
+	// The Linux AMD64 owner must additionally enforce the architectural fault.
+	nativeAlignment := runtime.GOOS == "linux" && runtime.GOARCH == "amd64"
+	reference := fmt.Sprintf("#define NATIVE_ALIGNMENT %d\n", x86FloatAddSubBoolInt(nativeAlignment)) +
+		fmt.Sprintf(x86AESFaultC, prototypes.String(), originals.String(), rows.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)}} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "aes-fault", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("aes live/dead kernels %d exact fault outcomes %d tripwires 4 failures 0\n", count, outcomes)
+			if string(output) != want {
+				t.Fatal("AES original/native-width/dead-read faults", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+const x86AESFaultC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#ifndef ALIGNMENT_OBSERVED
+#define ALIGNMENT_OBSERVED(kernel,address,fault) ((void)0)
+#endif
+%s
+%s
+typedef void(*Program)(const uint8_t*,uint8_t*);
+typedef struct {Program translated,original;unsigned width,legacy;} Kernel;
+static Kernel kernels[]={%s};
+static int observe(Program p,unsigned width,unsigned address){
+ pid_t child=fork();if(child<0)return -1;
+ if(child==0){
+  struct rlimit no_core={0,0};if(setrlimit(RLIMIT_CORE,&no_core))_exit(120);
+  _Alignas(64) uint8_t data[128],out[64];memset(data,0xa7,sizeof(data));const uint8_t *input=data;
+  if(address==1)input++;
+  if(address==2)input=NULL;
+  if(address>=3){long page=sysconf(_SC_PAGESIZE);if(page<=0)_exit(121);
+   uint8_t *memory=mmap(NULL,2*(size_t)page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);if(memory==MAP_FAILED)_exit(122);
+   memset(memory,0xa7,2*(size_t)page);
+   if(address<7){if(mprotect(memory+page,(size_t)page,PROT_NONE))_exit(123);
+    unsigned available[]={0,width-1,width,width+1};input=memory+page-available[address-3];
+   }else{if(mprotect(memory,(size_t)page,PROT_NONE))_exit(123);input=memory+page-(address==7?4:12);}
+  }
+  p(input,out);_exit(0);
+ }
+ int status=0;if(waitpid(child,&status,0)!=child)return -2;
+ if(WIFEXITED(status))return WEXITSTATUS(status)?-3:0;
+ if(WIFSIGNALED(status)&&(WTERMSIG(status)==SIGSEGV||WTERMSIG(status)==SIGBUS))return 1;
+ return -4;
+}
+static void missing(const uint8_t*p,uint8_t*out){(void)p;(void)out;}
+static void short_read(const uint8_t*p,uint8_t*out){out[0]=*(volatile const uint8_t*)p;}
+static void over_read(const uint8_t*p,uint8_t*out){out[0]=*((volatile const uint8_t*)p+63);}
+static void missing_prefix(const uint8_t*p,uint8_t*out){out[0]=*((volatile const uint8_t*)p+4)^*((volatile const uint8_t*)p+12);}
+int main(void){unsigned count=0;
+ if(observe(missing,16,2)!=0||observe(short_read,64,4)!=0||observe(over_read,16,5)!=1||observe(missing_prefix,16,7)!=0)return 4;
+ for(unsigned i=0;i<sizeof(kernels)/sizeof(kernels[0]);i++)for(unsigned a=0;a<9;a++){
+  Kernel k=kernels[i];int want=a==2||a==3||a==4||a>=7;
+  // Intel SDM Table 2-21: legacy SSE memory operands retain #GP for a
+  // non-16-byte-aligned address; VEX/EVEX do not inherit that exception.
+  int unaligned=k.legacy&&(a==1||a==6);
+  if(unaligned&&NATIVE_ALIGNMENT)want=1;
+  for(int original=1;original>=0;original--){if(original&&!k.original)continue;
+   int got=observe(original?k.original:k.translated,k.width,a);count++;
+   // Diagnostic hosts still require exact original/translated agreement.
+   if(original&&unaligned&&!NATIVE_ALIGNMENT&&(got==0||got==1)){
+    want=got;ALIGNMENT_OBSERVED(i,a,got);
+   }
+   if(got!=want){fprintf(stderr,"AES kernel%%u width%%u address%%u original%%d got%%d want%%d\n",i,k.width,a,original,got,want);return 1;}
+  }
+ }
+ printf("aes live/dead kernels %%zu exact fault outcomes %%u tripwires 4 failures 0\n",sizeof(kernels)/sizeof(kernels[0]),count);return 0;
+}
+`
diff --git a/amd64_aes_family_fixed_local_test.go b/amd64_aes_family_fixed_local_test.go
new file mode 100644
index 000000000..3de68a9b9
--- /dev/null
+++ b/amd64_aes_family_fixed_local_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86AESFamilyActualBoundFixedLocalConsumers(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	var assembly, declarations strings.Builder
+	count := 0
+	for _, name := range x86AESOracleNames {
+		for _, source := range []string{"16(SP)", "tmp-144(SP)"} {
+			row, _ := x86AESOracleRow(name, source, "X")
+			if strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+				row = name + " " + source + ",X0,X0"
+			} else if strings.Contains(name, "KEYGEN") {
+				row = name + " $27," + source + ",X0"
+			} else {
+				row = name + " " + source + ",X0"
+			}
+			body, _, _ := x86PrivateAlignedFrameAuditFixture(t, row)
+			fn := fmt.Sprintf("F%d", count)
+			count++
+			assembly.WriteString(strings.Replace(body, "·Value", "·"+fn, 1))
+			fmt.Fprintf(&declarations, "func %s(a,b,c,d uint64) uint64\n", fn)
+		}
+	}
+	for _, target := range []struct{ name, triple string }{{"linux/amd64", "x86_64-unknown-linux-gnu"}, {"darwin/amd64", "x86_64-apple-darwin"}} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "aes-native-local.ll", "aes-native-local.o", ir)
+			})
+		})
+	}
+}
diff --git a/amd64_aes_family_forms.go b/amd64_aes_family_forms.go
new file mode 100644
index 000000000..270d722fa
--- /dev/null
+++ b/amd64_aes_family_forms.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86AESOperation uint8
+
+const (
+	x86AESEncrypt x86AESOperation = iota
+	x86AESEncryptLast
+	x86AESDecrypt
+	x86AESDecryptLast
+	x86AESInverseMix
+	x86AESKeyAssist
+)
+
+type x86AESSpec struct {
+	operation x86AESOperation
+	vector    bool
+}
+
+// All AES optab attributes are explicit. In particular _yvaesdec has EVEX
+// full tuples but no mask, broadcast, zeroing, rounding or SAE capability.
+var x86AESSpecs = map[Op]x86AESSpec{
+	"AESENC": {x86AESEncrypt, false}, "AESENCLAST": {x86AESEncryptLast, false},
+	"AESDEC": {x86AESDecrypt, false}, "AESDECLAST": {x86AESDecryptLast, false},
+	"AESIMC": {x86AESInverseMix, false}, "AESKEYGENASSIST": {x86AESKeyAssist, false},
+	"VAESENC": {x86AESEncrypt, true}, "VAESENCLAST": {x86AESEncryptLast, true},
+	"VAESDEC": {x86AESDecrypt, true}, "VAESDECLAST": {x86AESDecryptLast, true},
+	"VAESIMC": {x86AESInverseMix, true}, "VAESKEYGENASSIST": {x86AESKeyAssist, true},
+}
+
+type x86AESForm struct {
+	spec                                          x86AESSpec
+	byteWidth, source, state, destination, memory int
+	sourceOperand                                 Operand // effective Go source role; original instruction is immutable
+}
+
+// This shared grammar supplies operand roles only. No bank initialization,
+// native memory, source authentication, frame or pointer authority is created.
+func x86AESProperties(op Op, ins Instr, arch string) (x86AESForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86AESSpecs[Op(name)]
+	if !known {
+		return x86AESForm{}, false, nil
+	}
+	f := x86AESForm{spec: spec, byteWidth: 16, source: 0, state: -1, destination: len(ins.Args) - 1, memory: -1}
+	fail := func() (x86AESForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go AES grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || suffix != "" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	count := 2
+	if spec.operation == x86AESKeyAssist {
+		count, f.source = 3, 1
+		if len(ins.Args) != count || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat || !amd64UnsignedImmediate(ins.Args[0], 8) && !(spec.vector && amd64VectorByteShiftImmediate(ins.Args[0])) {
+			return fail()
+		}
+	} else if spec.operation < x86AESInverseMix {
+		f.state = 1
+		if spec.vector {
+			count = 3
+		}
+	}
+	if len(ins.Args) != count {
+		return fail()
+	}
+	if spec.vector && spec.operation < x86AESInverseMix {
+		f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	}
+	register := func(a Operand) bool {
+		if a.Kind != OpReg {
+			return false
+		}
+		if spec.vector && spec.operation < x86AESInverseMix {
+			return amd64GoPackedVectorMoveRegister(a, f.byteWidth, arch)
+		}
+		index, valid := amd64ParseXReg(a.Reg)
+		return valid && index < 16 && (spec.vector || arch != "386" || index < 8)
+	}
+	if !register(ins.Args[f.destination]) || f.state >= 0 && !register(ins.Args[f.state]) {
+		return fail()
+	}
+	source := ins.Args[f.source]
+	if isAMD64MemoryOperand(source) {
+		validation := source
+		if source.Kind == OpMem && arch == "386" && strings.HasSuffix(source.Mem.Sym, "(SB)") {
+			validation.Mem.Base = "" // actual Go ignores Reg, not Index, for named SB memory
+		}
+		if !x86PackedShiftMemoryValid(validation, arch) {
+			return fail()
+		}
+		if source.Kind == OpSym {
+			if address, err := parseInt(strings.TrimSpace(source.Sym)); err == nil &&
+				address != int64(int32(address)) && !(arch == "386" && address == int64(uint32(address))) {
+				return fail()
+			}
+		}
+		if source.Kind == OpMem {
+			if !x86ConditionalMoveOffsetKnown(source.Mem) {
+				return fail()
+			}
+			if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+				return f, true, err
+			}
+		}
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return f, true, fmt.Errorf("%w: AES source has no bound native address-size override", ErrProbeNeedsContext)
+		}
+		f.memory = f.source
+	} else if !register(source) {
+		return fail()
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return f, true, err
+	}
+	f.sourceOperand = source
+	if spec.operation == x86AESKeyAssist && source.Kind == OpMem && !ins.x86Encoded && ins.x86SourceRaw == nil {
+		// cmd/asm puts this memory in From3; obj/x86 emits segment prefixes
+		// only from From and To. Its real memory bytes therefore omit this
+		// annotation. Raw physical instructions retain their actual prefix.
+		f.sourceOperand.Mem.Segment = ""
+		if source.Mem.Base == FS || source.Mem.Base == GS {
+			f.sourceOperand.Mem.Base = ""
+		}
+	}
+	return f, true, nil
+}
+
+func x86TypedAESByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86AESProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	e := x86TypedByteEffect{requiresResultProof: true,
+		operands: []x86TypedByteOperand{{index: f.source, operand: f.sourceOperand, width: int64(f.byteWidth), read: true}}}
+	if f.state >= 0 && f.state != f.destination {
+		e.operands = append(e.operands, x86TypedByteOperand{index: f.state, operand: ins.Args[f.state], width: int64(f.byteWidth), read: true})
+	}
+	e.operands = append(e.operands, x86TypedByteOperand{index: f.destination, operand: ins.Args[f.destination], width: int64(f.byteWidth), read: f.state == f.destination, write: true})
+	return e, true, nil
+}
+
+// Numerical dependencies are independent of the complete physical memory
+// envelope. A SubWord/RotWord observes only source dwords 1 and 3; an AES round
+// never has a zero idiom when the two sources alias. Wider lanes are 128-bit.
+func x86AESDefinedBytes(f x86AESForm, source, state uint64) uint64 {
+	known := uint64(0)
+	for lane := 0; lane < f.byteWidth; lane += 16 {
+		for out := 0; out < 16; out++ {
+			var sourceMask, stateMask uint64
+			switch f.spec.operation {
+			case x86AESKeyAssist:
+				at := out/8*8 + 4 + out%4
+				if out%8 >= 4 {
+					at = out/8*8 + 4 + (out+1)%4
+				}
+				sourceMask = uint64(1) << uint(lane+at)
+			case x86AESInverseMix:
+				sourceMask = uint64(15) << uint(lane+out/4*4)
+			default:
+				sourceMask = uint64(1) << uint(lane+out)
+				column, row := out/4, out%4
+				first, last := 0, 4
+				if f.spec.operation == x86AESEncryptLast || f.spec.operation == x86AESDecryptLast {
+					first, last = row, row+1
+				}
+				for r := first; r < last; r++ {
+					shift := r
+					if f.spec.operation == x86AESDecrypt || f.spec.operation == x86AESDecryptLast {
+						shift = 4 - r
+					}
+					stateMask |= uint64(1) << uint(lane+((column+shift)%4)*4+r)
+				}
+			}
+			if source&sourceMask == sourceMask && state&stateMask == stateMask {
+				known |= uint64(1) << uint(lane+out)
+			}
+		}
+	}
+	return known
+}
+
+func x86ResultAESStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultAESStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultAESStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86AESProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	read := func(index int) (uint64, bool) {
+		a := ins.Args[index]
+		if index == f.source {
+			a = f.sourceOperand
+		}
+		if a.Kind == OpReg {
+			i, valid := amd64VectorRegisterIndex(a.Reg, f.byteWidth)
+			if !valid || i >= len(state.xmm) {
+				return 0, false
+			}
+			return state.vectorBytes(i), true
+		}
+		return x86CallerVectorByteMask(int64(f.byteWidth)),
+			x86ResultReadWithNativeContinuation(ins, a, int64(f.byteWidth), state, owned, arch, native && index == f.source)
+	}
+	source, valid := read(f.source)
+	if !valid {
+		return false, true
+	}
+	input := uint64(0)
+	if f.state >= 0 {
+		input, valid = read(f.state)
+		if !valid {
+			return false, true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	if destination >= len(state.xmm) {
+		return false, true
+	}
+	defined := x86AESDefinedBytes(f, source, input)
+	// Preserve the existing nontrapping register NUM domain: an accepted
+	// transfer may leave result bytes unknown, never initialized to alloca
+	// zeroes. Every later result, store, address or control use still consumes
+	// its actual known bytes. Native memory retains its full read above.
+	state.writeVector(destination, f.byteWidth, defined, !f.spec.vector)
+	return true, true
+}
diff --git a/amd64_aes_family_runtime_test.go b/amd64_aes_family_runtime_test.go
new file mode 100644
index 000000000..b332c274f
--- /dev/null
+++ b/amd64_aes_family_runtime_test.go
@@ -0,0 +1,241 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// FIPS-197 byte arithmetic, independent of LLVM intrinsics, the source grammar
+// and the production defined-byte model. Compute the S-box from GF(2^8), not
+// from a table shared with any emitter.
+const x86AESIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+static uint8_t mul(uint8_t a,uint8_t b){uint8_t v=0;for(int i=0;i<8;i++){if(b&1)v^=a; a=(uint8_t)((a<<1)^((a&128)?0x1b:0));b>>=1;}return v;}
+static uint8_t rol(uint8_t a,int n){return (uint8_t)((a<<n)|(a>>(8-n)));}
+static uint8_t box(uint8_t a){uint8_t p=1,b=a;int n=254;if(!a)p=0;else while(n){if(n&1)p=mul(p,b);b=mul(b,b);n>>=1;}return p^rol(p,1)^rol(p,2)^rol(p,3)^rol(p,4)^0x63;}
+static uint8_t inverse(uint8_t a){for(int i=0;i<256;i++)if(box((uint8_t)i)==a)return (uint8_t)i;return 0;}
+static void mix(uint8_t *out,const uint8_t *in,int inv){for(int c=0;c<4;c++)for(int r=0;r<4;r++){
+ const uint8_t forward[4]={2,3,1,1},backward[4]={14,11,13,9};out[c*4+r]=0;
+ for(int k=0;k<4;k++)out[c*4+r]^=mul(in[c*4+k],inv?backward[(k-r+4)%4]:forward[(k-r+4)%4]);}}
+static void aes(uint8_t *out,const uint8_t *state,const uint8_t *key,int op,int imm){
+ uint8_t shifted[16],temp[16];
+ if(op==4){mix(out,key,1);return;}
+ if(op==5){for(int h=0;h<2;h++)for(int b=0;b<4;b++){out[h*8+b]=box(key[h*8+4+b]);out[h*8+4+b]=box(key[h*8+4+(b+1)%4])^(b==0?imm:0);}return;}
+ for(int c=0;c<4;c++)for(int r=0;r<4;r++){int source=((c+(op>=2?4-r:r))%4)*4+r;shifted[c*4+r]=op>=2?inverse(state[source]):box(state[source]);}
+ if(op==0||op==2)mix(temp,shifted,op==2);else memcpy(temp,shifted,16);
+ for(int i=0;i<16;i++)out[i]=temp[i]^key[i];
+}
+typedef void(*Program)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t);
+struct Aligned {_Alignas(64) uint8_t before[64],value[80],after[64];};
+static int check(Program p,const char *name,int width,int op,int legacy,int memory,int alias,int imm){
+ for(int sample=0;sample<37;sample++)for(int profile=0;profile<2;profile++){
+  struct Aligned a,b,old,out;memset(&a,0xa7,sizeof(a));memset(&b,0xb9,sizeof(b));memset(&old,0x6d,sizeof(old));memset(&out,0xc3,sizeof(out));
+  for(int i=0;i<64;i++){a.value[i]=(uint8_t)(sample*19+i*37);b.value[i]=(uint8_t)(sample*71+i*11);old.value[i]=(uint8_t)(sample*97+i*3);}
+  struct Aligned oa=a,ob=b,oo=old;uint64_t seed=profile?0x8d5:0;uint32_t csr=0x1f80|((sample%4)<<13)|(sample%64),saved=_mm_getcsr();_mm_setcsr(csr);
+  p(out.value,a.value,b.value,old.value,seed,csr);uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+  uint64_t flags;uint32_t reported;memcpy(&flags,out.value+64,8);memcpy(&reported,out.value+72,4);
+  if((flags&0x8d5)!=seed||reported!=csr||after!=csr||memcmp(&a,&oa,sizeof(a))||memcmp(&b,&ob,sizeof(b))||memcmp(&old,&oo,sizeof(old)))return 1;
+  uint8_t expected[64];const uint8_t *retained=alias==0?a.value:alias==1?b.value:old.value;
+  memcpy(expected,legacy?retained:(const uint8_t[64]){0},64);
+  for(int lane=0;lane<width;lane+=16)aes(expected+lane,b.value+lane,a.value+lane,op,imm);
+  for(int i=0;i<64;i++)if(out.value[i]!=expected[i]){fprintf(stderr,"%s sample%d byte%d got%x want%x\n",name,sample,i,out.value[i],expected[i]);return 2;}
+  for(int i=0;i<64;i++)if(out.before[i]!=0xc3||out.after[i]!=0xc3)return 3;
+  for(int i=76;i<80;i++)if(out.value[i]!=0xc3)return 4;
+ }return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86AESFamilyWholeByteAliases(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, reference, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	reference.WriteString(x86AESIndependentC)
+	count := 0
+	for index, name := range x86AESOracleNames {
+		op, legacy := index%6, !strings.HasPrefix(name, "V")
+		widths := []int{16}
+		if !legacy && op < 4 {
+			widths = append(widths, 32, 64)
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, memory := range []bool{false, true} {
+				for alias := 0; alias < 3; alias++ {
+					if legacy && op < 4 && alias != 1 {
+						continue
+					}
+					key := bank + "0"
+					if memory {
+						key = "(CX)"
+					}
+					row, destination := x86AESOracleRow(name, key, bank)
+					if legacy && op < 4 {
+						destination = 1
+					} else {
+						row = strings.TrimSuffix(row, bank+"2") + fmt.Sprintf("%s%d", bank, alias)
+						destination = alias
+					}
+					fn := fmt.Sprintf("A%d", count)
+					count++
+					fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte,flags uint64,csr uint32)\n", fn)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-44\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nVMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nLDMXCSR csr+40(FP)\nPUSHQ flags+32(FP)\nPOPFQ\n%s\nVMOVUPS Z%d,(AX)\nPUSHFQ\nPOPQ R9\nMOVQ R9,64(AX)\nSTMXCSR 72(AX)\nRET\n", fn, row, destination)
+					fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t);\n", fn)
+					legacyInt, memoryInt := 0, 0
+					if legacy {
+						legacyInt = 1
+					}
+					if memory {
+						memoryInt = 1
+					}
+					fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,%d,%d,%d,27))return 1;\n", fn, row, width, op, legacyInt, memoryInt, destination)
+				}
+			}
+		}
+	}
+	reference.WriteString("int main(void){\n" + checks.String() + "return 0;}\n")
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir := x86NarrowOracleIR(t, source.String(), declarations.String(), execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) { execution.compileAndRunLLVM(t, "aes-byte-alias", ir, reference.String(), level) })
+	}
+	t.Run("IR_O2/backend_O2", func(t *testing.T) {
+		execution.compileAndRunLLVM(t, "aes-byte-alias-ir-o2", x86DwordProductIROptimize(t, ir), reference.String(), "-O2")
+	})
+	t.Logf("%d AES-family kernels ×37 samples ×2 flag/MXCSR seeds on three explicit optimization axes; all64 vector bytes, aliases, exact native memory, inputs and output canaries; portable wide VAES is not original AVX512 execution", count)
+}
+
+// Execute genuine Go-assembler bytes, not bytes obtained from our grammar or
+// LLVM. The host's legacy AES X128 axis is distinct from portable wide VAES;
+// no original AVX512 execution or native-Linux claim is made here.
+func TestCrossLinuxRuntimeMatrixX86AESFamilyOriginalGoFullX128Bytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var original, checks strings.Builder
+	count := 0
+	for op, name := range x86AESOracleNames[:6] {
+		for _, memory := range []bool{false, true} {
+			for alias := 0; alias < 3; alias++ {
+				if op < 4 && alias != 1 {
+					continue
+				}
+				input := "X0"
+				if memory {
+					input = "(SI)"
+				}
+				row, destination := x86AESOracleRow(name, input, "X")
+				if op >= 4 {
+					row = strings.TrimSuffix(row, "X2") + fmt.Sprintf("X%d", alias)
+					destination = alias
+				}
+				fn := fmt.Sprintf("NativeAES%d", count)
+				count++
+				// SysV DI/SI/DX/CX/R8/R9 provide out/a/b/old/flags/csr.
+				body := fmt.Sprintf("TEXT actual(SB),4,$0-0\nMOVOU (SI),X0\nMOVOU (DX),X1\nMOVOU (CX),X2\nMOVL R9,76(DI)\nLDMXCSR 76(DI)\nPUSHQ R8\nPOPFQ\n%s\nMOVOU X%d,(DI)\nPUSHFQ\nPOPQ AX\nMOVQ AX,64(DI)\nSTMXCSR 72(DI)\nRET\n", row, destination)
+				code := x86OrderingHintGoBytes(t, "amd64", body)
+				var encoded []string
+				for _, b := range code {
+					encoded = append(encoded, fmt.Sprintf("0x%02x", b))
+				}
+				symbol := fn
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				original.WriteString(x86OriginalSysVDeclaration("void", fn, "uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t"))
+				fmt.Fprintf(&original, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(encoded, ",")+"\n")
+				fmt.Fprintf(&checks, "if(nativecheck(%s,%q,%d))return 1;\n", fn, row, op)
+			}
+		}
+	}
+	reference := x86AESIndependentC + original.String() + x86AESNativeCheckC + "int main(void){\n" + checks.String() + fmt.Sprintf("printf(\"original Go AES X128 kernels %d samples %d full-byte failures 0\\n\");return 0;}\n", count, count*37*2)
+	output := execution.compileAndRunLLVM(t, "aes-native-go-bytes", "target triple = \""+execution.triple+"\"\n", reference, "-O2")
+	want := fmt.Sprintf("original Go AES X128 kernels %d samples %d full-byte failures 0\n", count, count*37*2)
+	if string(output) != want {
+		t.Fatal("actual Go full-X128 source-byte oracle", string(output))
+	}
+	t.Log(strings.TrimSpace(string(output)))
+}
+
+var x86AESNativeCheckC = x86OriginalSysVPointer("void", "OriginalProgram",
+	"uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t") + `
+static int nativecheck(OriginalProgram p,const char *name,int op){
+ for(int sample=0;sample<37;sample++)for(int profile=0;profile<2;profile++){
+  struct Aligned a,b,old,out;memset(&a,0xa7,sizeof(a));memset(&b,0xb9,sizeof(b));memset(&old,0x6d,sizeof(old));memset(&out,0xc3,sizeof(out));
+  for(int i=0;i<64;i++){a.value[i]=(uint8_t)(sample*19+i*37);b.value[i]=(uint8_t)(sample*71+i*11);old.value[i]=(uint8_t)(sample*97+i*3);}
+  struct Aligned oa=a,ob=b,oo=old;uint64_t seed=profile?0x8d5:0;uint32_t csr=0x1f80|((sample%4)<<13)|(sample%64),saved=_mm_getcsr();_mm_setcsr(csr);
+  p(out.value,a.value,b.value,old.value,seed,csr);uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+  uint64_t flags;uint32_t reported,scratch;memcpy(&flags,out.value+64,8);memcpy(&reported,out.value+72,4);memcpy(&scratch,out.value+76,4);
+  uint8_t expected[16];aes(expected,b.value,a.value,op,27);
+  if(memcmp(out.value,expected,16)||(flags&0x8d5)!=seed||reported!=csr||scratch!=csr||after!=csr||memcmp(&a,&oa,sizeof(a))||memcmp(&b,&ob,sizeof(b))||memcmp(&old,&oo,sizeof(old))){fprintf(stderr,"original %s sample%d full bytes/flags/CSR/input mismatch\n",name,sample);return 1;}
+  for(int i=16;i<64;i++)if(out.value[i]!=0xc3)return 2;
+  for(int i=0;i<64;i++)if(out.before[i]!=0xc3||out.after[i]!=0xc3)return 3;
+ }return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86AESFamilyLogicalFloatBitPayloads(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, reference, checks strings.Builder
+	declarations.WriteString("package aesbits\n")
+	reference.WriteString(x86AESIndependentC)
+	count := 0
+	for op, name := range x86AESOracleNames {
+		for _, bits := range []int{32, 64} {
+			fn := fmt.Sprintf("FloatAES%d", count)
+			count++
+			row, destination := x86AESOracleRow(name, "a+0(FP)", "X")
+			if !strings.HasPrefix(name, "V") {
+				// This is a logical bit-payload oracle, not native FP backing.
+				// Use Go's unaligned move before the legacy register operation;
+				// the separate memory oracle checks its alignment exceptions.
+				row, destination = x86AESOracleRow(name, "X3", "X")
+				row = "MOVOU a+0(FP),X3\n" + row
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nMOVQ out+16(FP),AX\nVMOVUPS Z%d,(AX)\nRET\n", fn, row, destination)
+			if bits == 32 {
+				checks.WriteString("for(unsigned j=0;j<4;j++){uint32_t v=payloads32[(sample+j)%8];memcpy(key+j*4,&v,4);}\n")
+				fmt.Fprintf(&declarations, "func %s(a,b,c,d float32,out *[64]byte)\n", fn)
+				fmt.Fprintf(&reference, "extern void %s(float,float,float,float,uint8_t*);\n", fn)
+				fmt.Fprintf(&checks, "{float f[4];memcpy(f,key,16);%s(f[0],f[1],f[2],f[3],out.value);}\n", fn)
+			} else {
+				checks.WriteString("for(unsigned j=0;j<2;j++){uint64_t v=payloads64[(sample+j)%8];memcpy(key+j*8,&v,8);}\n")
+				fmt.Fprintf(&declarations, "func %s(a,b float64,out *[64]byte)\n", fn)
+				fmt.Fprintf(&reference, "extern void %s(double,double,uint8_t*);\n", fn)
+				fmt.Fprintf(&checks, "{double f[2];memcpy(f,key,16);%s(f[0],f[1],out.value);}\n", fn)
+			}
+			fmt.Fprintf(&checks, "aes(expected,(const uint8_t[16]){0},key,%d,27);\n", op%6)
+			fmt.Fprintf(&checks, `if (memcmp(out.value,expected,64) || _mm_getcsr()!=csr) {
+ fprintf(stderr,"%s sample%%u csr%%x want%%x\n",sample,_mm_getcsr(),csr);
+ for(int j=0;j<64;j++) if(out.value[j]!=expected[j])
+  fprintf(stderr,"byte%%d got%%x want%%x\n",j,out.value[j],expected[j]);
+ return 1;
+}
+`, fn)
+			checks.WriteString(`for(int j=0;j<64;j++) if(out.before[j]!=0xc3 || out.after[j]!=0xc3) return 2;
+for(int j=64;j<80;j++) if(out.value[j]!=0xc3) return 3;
+memset(&out,0xc3,sizeof(out));
+`)
+		}
+	}
+	reference.WriteString(`
+int main(void){
+ const uint32_t payloads32[]={0,0x80000000,0x7fc00013,0x7f800001,0xff800001,0x7f800000,0xff800000,1};
+ const uint64_t payloads64[]={0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff8000000000013),UINT64_C(0x7ff0000000000001),UINT64_C(0xfff0000000000001),UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),1};
+ for(unsigned sample=0;sample<8;sample++){
+  uint8_t key[16],expected[64]={0};struct Aligned out;memset(&out,0xc3,sizeof(out));
+  unsigned csr=0x1f80|((sample%4)<<13)|(sample%64),saved=_mm_getcsr();_mm_setcsr(csr);
+` + checks.String() + `_mm_setcsr(saved);
+ }return 0;
+}
+`)
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir := x86NarrowOracleIR(t, source.String(), declarations.String(), execution.triple)
+	for _, axis := range []struct{ name, ir, backend string }{{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2/backend_O2", x86DwordProductIROptimize(t, ir), "-O2"}} {
+		t.Run(axis.name, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "aes-float-bits", axis.ir, reference.String(), axis.backend)
+		})
+	}
+	t.Logf("%d complete F32/F64 logical bit-view kernels ×8 NaN/zero/infinity/denormal payloads on three axes; full64 bytes/MXCSR/canaries, no numeric float conversion or native-FP certificate", count)
+}
diff --git a/amd64_aes_family_sdk_test.go b/amd64_aes_family_sdk_test.go
new file mode 100644
index 000000000..e71928f37
--- /dev/null
+++ b/amd64_aes_family_sdk_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is a tiny actual-SDK object/source fixture, not a local stdlib/corpus
+// replay. Original AES instructions and selected function bodies are retained.
+// Dynamic aeskeysched contents alone are not extent, pointer or initialization
+// authority. A later global producer must authenticate its own source/layout.
+func TestX86AESFamilyOriginalSDKMemhash386GlobalBoundary(t *testing.T) {
+	relative := "src/internal/runtime/maps/memhash_386.s"
+	names := []string{"·memHash32AES", "·memHash64AES"}
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), relative))
+	if errors.Is(err, os.ErrNotExist) {
+		relative = "src/runtime/asm_386.s"
+		names = []string{"runtime·memhash32", "runtime·memhash64"}
+		data, err = os.ReadFile(filepath.Join(runtime.GOROOT(), relative))
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	headerPath := filepath.Join(runtime.GOROOT(), "pkg/include/textflag.h")
+	header, err := os.ReadFile(headerPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			start := strings.Index(string(data), "TEXT "+name+"(SB)")
+			if start < 0 {
+				t.Fatal("actual SDK selected function disappeared", relative, name)
+			}
+			body := string(data[start:])
+			if next := strings.Index(body[1:], "\nTEXT "); next >= 0 {
+				body = body[:next+1]
+			}
+			original := "#include \"textflag.h\"\n" + body
+			dir := t.TempDir()
+			input, object := filepath.Join(dir, "actual-sdk.s"), filepath.Join(dir, "actual-sdk.o")
+			if err := os.WriteFile(input, []byte(original), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "asm", "-I", filepath.Dir(headerPath), "-p", "actual-sdk", "-o", object, input)
+			command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, "386"); failure != nil {
+				t.Fatal("unchanged SDK function original object", failure, string(output))
+			}
+			physical, err := os.ReadFile(object)
+			if err != nil {
+				t.Fatal(err)
+			}
+			processed, err := PreprocessAssemblySource(original, AssemblyPreprocessOptions{FileName: relative, ReadInclude: func(parent, name string) (string, []byte, error) {
+				if name != "textflag.h" {
+					return "", nil, fmt.Errorf("unselected header %s", name)
+				}
+				return "pkg/include/textflag.h", header, nil
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, processed) // shared x86 parser; the typed consumer is explicitly mode386
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatal("actual source/include parser", err)
+			}
+			aes := 0
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Op != "AESENC" {
+					continue
+				}
+				aes++
+				form, known, err := x86AESProperties(ins.Op, ins, "386")
+				if !known || err != nil || form.byteWidth != 16 || form.memory != 0 {
+					t.Fatal("unchanged actual SDK AES source must have registered whole-family grammar", ins, err)
+				}
+				state := x86ResultState{}
+				state.xmm[0] = 0xffff
+				if ok, known := x86ResultAESStep(ins, &state, nil, "386"); !known || ok {
+					t.Fatal("dynamic SB numerical values borrowed unproved initialized/extent authority", ins)
+				}
+			}
+			if aes != 3 {
+				t.Fatal("actual SDK AES inventory changed", aes)
+			}
+			t.Logf("SDK=%s full-sourceSHA256=%x selected-originalSHA256=%x headerSHA256=%x original-objectSHA256=%x bytes=%d exactAES=%d; global producer absent, not a corpus/version pass", relative, sha256.Sum256(data), sha256.Sum256([]byte(original)), sha256.Sum256(header), sha256.Sum256(physical), len(physical), aes)
+		})
+	}
+}
diff --git a/amd64_aes_scalar_integration_runtime_test.go b/amd64_aes_scalar_integration_runtime_test.go
new file mode 100644
index 000000000..746118516
--- /dev/null
+++ b/amd64_aes_scalar_integration_runtime_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Execute the exact original FP source, not a GP-source substitute. The tiny
+// test-only native bridge owns an ABI0 argument/result area for those actual
+// Go object bytes and retains the four bytes immediately after the result.
+// Neither this bridge nor its initialized bytes grant production native-FP,
+// fixed-local, caller or pointer permission.
+func TestCrossLinuxRuntimeMatrixX86AESFamilyScalarInsertResult(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const source = "TEXT ·view(SB),4,$0-12\nMOVL k+0(FP),X0\nPINSRD $1,k+0(FP),X0\nAESENC X0,X0\nMOVL X0,ret+8(FP)\nRET\n"
+	code := x86OrderingHintGoBytes(t, "amd64", source)
+	var encoded []string
+	for _, value := range code {
+		encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+	}
+	original, bridge := "OriginalGoAESScalar", "OriginalGoAESScalarBridge"
+	if strings.Contains(execution.triple, "apple") {
+		original, bridge = "_"+original, "_"+bridge
+	}
+	assembly := ".text\n.globl " + original + "\n" + original + ":\n.byte " + strings.Join(encoded, ",") +
+		"\n.globl " + bridge + "\n" + bridge + ":\nsubq $24,%rsp\nmovl %edi,0(%rsp)\nmovl %esi,4(%rsp)\nmovl $0xc3c3c3c3,8(%rsp)\nmovl $0x6d6d6d6d,12(%rsp)\ncall " + original + "\nmovq 8(%rsp),%rax\naddq $24,%rsp\nret\n"
+	// This reference uses independent FIPS-197 arithmetic. It does not reuse
+	// the production grammar, LLVM AES intrinsic or byte-definedness model.
+	reference := x86AESIndependentC + fmt.Sprintf("\n__asm__(%q);\n", assembly) +
+		x86OriginalSysVDeclaration("uint64_t", "OriginalGoAESScalarBridge", "uint32_t,uint32_t") + `
+extern uint32_t view(uint32_t,uint32_t);
+int main(void){
+ for(unsigned sample=0;sample<64;sample++){
+  const uint32_t special[4]={0,0xffffffff,0x80000000,0x01234567};
+  uint32_t k=sample<4?special[sample]:sample*0x9137a5c3u+0x87654321u,h=k^0x6b5917d3u;
+  uint8_t input[16]={0},expected[16];uint32_t want;
+  memcpy(input,&k,4);memcpy(input+4,&k,4);aes(expected,input,input,0,0);memcpy(&want,expected,4);
+  uint64_t original=OriginalGoAESScalarBridge(k,h);uint32_t translated=view(k,h);
+  if((uint32_t)original!=want||(original>>32)!=0x6d6d6d6du||translated!=want){
+   fprintf(stderr,"mixed AES scalar sample%u original%llx translated%x expected%x\n",sample,(unsigned long long)original,translated,want);return 1;
+  }
+ }
+ puts("mixed AES scalar exact Go bytes/FIPS/translated samples 64 result-canary failures 0");return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k,h uint32) uint32\n", "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, axis := range []struct{ name, level string }{{"backend_O0", "-O0"}, {"backend_O2", "-O2"}, {"IR_O2/backend_O2", "-O2"}} {
+			t.Run(api+"/"+axis.name, func(t *testing.T) {
+				optimized := ir
+				if strings.HasPrefix(axis.name, "IR_O2/") {
+					optimized = x86DwordProductIROptimize(t, ir)
+				}
+				output := execution.compileAndRunLLVM(t, "aes-scalar-result", optimized, reference, axis.level)
+				if string(output) != "mixed AES scalar exact Go bytes/FIPS/translated samples 64 result-canary failures 0\n" {
+					t.Fatal("unbound mixed-source runtime result", string(output))
+				}
+			})
+		}
+	}
+	t.Logf("exact original Go FP source bytes %x; 3 translation APIs x3 explicit optimization axes x64 independent result/canary samples (host transport, not native Linux)", code)
+}
diff --git a/amd64_ah_flags.go b/amd64_ah_flags.go
new file mode 100644
index 000000000..f89640a83
--- /dev/null
+++ b/amd64_ah_flags.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86AHFlagsSpec struct {
+	toAH bool
+}
+
+// The complete ynone/Px family in both Go x86 modes. AH is an implicit byte
+// operand; OF, DF and all other FLAGS are outside this five-bit transfer.
+var x86AHFlagsSpecs = map[Op]x86AHFlagsSpec{
+	"LAHF": {toAH: true}, "SAHF": {},
+}
+
+const x86AHFlagsMask = x86ByteFlagCF | x86ByteFlagPF | x86ByteFlagAF | x86ByteFlagZF | x86ByteFlagSF
+
+func x86AHFlagsProperties(op Op, ins Instr, arch string) (x86AHFlagsSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86AHFlagsSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	if len(ins.Args) != 0 {
+		return spec, true, fmt.Errorf("%s %s takes no operands: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s outside Go AH/FLAGS ynone grammar: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func x86TypedAHFlagsEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86AHFlagsProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: -1, operand: Operand{Kind: OpReg, Reg: AH}, width: 1, read: !spec.toAH, write: spec.toAH},
+	}}
+	if spec.toAH {
+		effect.flagsRead = x86AHFlagsMask
+	} else {
+		effect.flagsDefined, effect.flagsKilled = x86AHFlagsMask, x86AHFlagsMask
+	}
+	return effect, true, nil
+}
diff --git a/amd64_andn_feature_identity_test.go b/amd64_andn_feature_identity_test.go
new file mode 100644
index 000000000..062e7d32c
--- /dev/null
+++ b/amd64_andn_feature_identity_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Go's scalar BMI rows are ANDNL and ANDNQ. The 32 packed logical names
+// are a separate family even when their source mnemonic starts with ANDN.
+func TestX86ANDNFeatureIdentityDoesNotBorrowScalarBMI(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ScalarFPLogicalOpcodes {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				row, _ := x86ScalarFPLogicalRow(op)
+				source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0])
+				for _, feature := range strings.Split(features, ",") {
+					if feature == "+bmi" || feature == "+bmi2" {
+						t.Errorf("packed opcode %s borrowed scalar ISA: %s", op, features)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ANDNNativeMemoryKeepsItsOwnISAAndScalarControls(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, tc := range []struct{ row, want string }{
+			{"ANDNPS (AX),X1", "+sse"},
+			{"ANDNPD (AX),X1", "+sse2"},
+			{"ANDNL AX,BX,CX", "+bmi"},
+		} {
+			t.Run(arch+"/"+tc.row, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + tc.row + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0]); got != tc.want {
+					t.Errorf("native source ISA=%q want=%q", got, tc.want)
+				}
+			})
+		}
+	}
+	// The Q row is independently retained, not accidentally dropped while
+	// removing packed names from the former broad prefix heuristic.
+	source := "TEXT f(SB),4,$0-0\nANDNQ AX,BX,CX\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", file.Funcs[0]); got != "+bmi" {
+		t.Fatalf("scalar Q BMI row lost its ISA: %q", got)
+	}
+}
diff --git a/amd64_arithmetic_shift_go_rules_test.go b/amd64_arithmetic_shift_go_rules_test.go
new file mode 100644
index 000000000..e1c9bb11a
--- /dev/null
+++ b/amd64_arithmetic_shift_go_rules_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent complete ordered rows, including zero-offset aliases. Encoding
+// attributes are opcode-specific even when operand tables are shared.
+func TestX86ArithmeticShiftCompleteGoEncoderRules(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, spec := range []struct {
+		name, table, mapName, w, immediate, opcode, broadcast string
+		uniform, vex                                          bool
+	}{
+		{"VPSRAW", "_yvpslld", "vex0F", "vexW0", "0x71", "0xE1", "", true, true},
+		{"VPSRAD", "_yvpslld", "vex0F", "vexW0", "0x72", "0xE2", "evexBcstN4", true, true},
+		{"VPSRAQ", "_yvpsraq", "vex0F", "vexW1", "0x72", "0xE2", "evexBcstN8", true, false},
+		{"VPSRAVD", "_yvandnpd", "vex0F38", "vexW0", "", "0x46", "evexBcstN4", false, true},
+		{"VPSRAVQ", "_yvblendmpd", "vex0F38", "vexW1", "", "0x46", "evexBcstN8", false, false},
+		{"VPSRAVW", "_yvblendmpd", "vex0F38", "vexW1", "", "0x11", "", false, false},
+	} {
+		var expected []goasmrules.X86AVXRule
+		var bytes []string
+		offset := 0
+		add := func(zcase string, advance int, classes string) {
+			expected = append(expected, goasmrules.X86AVXRule{
+				Opcode: spec.name, Ytab: spec.table, Prefix: "Pavx", RowIndex: len(expected),
+				ZCase: zcase, ZOffset: advance, EncodingOffset: offset, Classes: strings.Split(classes, ","),
+			})
+			offset += advance
+		}
+		if spec.vex {
+			if spec.uniform {
+				for _, bank := range []string{"Yxr", "Yyr"} {
+					add("Zvex_i_rm_vo", 0, "Yu8,"+bank+","+bank)
+					add("Zvex_i_rm_vo", 3, "Yi8,"+bank+","+bank)
+				}
+			}
+			for index, bank := range []string{"Yxr", "Yyr"} {
+				source := []string{"Yxm", "Yym"}[index]
+				if spec.uniform {
+					source = "Yxm"
+				}
+				add("Zvex_rm_v_r", 2, source+","+bank+","+bank)
+			}
+			for pass := 0; pass < 2; pass++ {
+				if pass == 0 && !spec.uniform {
+					continue
+				}
+				for _, width := range []int{128, 256} {
+					bytes = append(bytes, fmt.Sprintf("avxEscape | vex%d | vex66 | %s | %s", width, spec.mapName, spec.w))
+					if pass == 0 {
+						bytes = append(bytes, spec.immediate, "04")
+					} else {
+						bytes = append(bytes, spec.opcode)
+					}
+				}
+			}
+		}
+		for pass := 0; pass < 2; pass++ {
+			if pass == 0 && !spec.uniform {
+				continue
+			}
+			for index, bank := range []string{"YxrEvex", "YyrEvex", "Yzr"} {
+				source := []string{"YxmEvex", "YymEvex", "Yzm"}[index]
+				if spec.uniform && pass == 1 {
+					source = "YxmEvex"
+				}
+				classes, zcase, masked, advance := source+","+bank+","+bank, "Zevex_rm_v_r", "Zevex_rm_v_k_r", 3
+				if pass == 0 {
+					classes, zcase, masked, advance = "Yu8,"+source+","+bank, "Zevex_i_rm_vo", "Zevex_i_rm_k_vo", 4
+				}
+				add(zcase, 0, classes)
+				parts := strings.Split(classes, ",")
+				add(masked, advance, strings.Join(parts[:len(parts)-1], ",")+",Yknot0,"+bank)
+				width := []int{128, 256, 512}[index]
+				prefix := strings.ReplaceAll(fmt.Sprintf("avxEscape | evex%d | evex66 | %s | %s", width, spec.mapName, spec.w), "vex0F", "evex0F")
+				prefix = strings.ReplaceAll(prefix, "vexW", "evexW")
+				tuple := 16
+				if !spec.uniform || pass == 0 {
+					tuple = width / 8
+				}
+				attributes := fmt.Sprintf("evexN%d", tuple)
+				if (!spec.uniform || pass == 0) && spec.broadcast != "" {
+					attributes += " | " + spec.broadcast
+				}
+				bytes = append(bytes, prefix, attributes+" | evexZeroingEnabled")
+				if pass == 0 {
+					bytes = append(bytes, spec.immediate, "04")
+				} else {
+					bytes = append(bytes, spec.opcode)
+				}
+			}
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == spec.name {
+				actual = append(actual, rule)
+			}
+		}
+		for index := range expected {
+			expected[index].OpBytes = bytes
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("complete ordered arithmetic encoder rules changed: %s\ngot %+v\nwant %+v", spec.name, actual, expected)
+		}
+	}
+}
+
+func TestX86PackedShiftEVEXUnsignedImmediateGrammar(t *testing.T) {
+	for _, name := range []string{"VPSLLD", "VPSLLQ", "VPSRLD", "VPSRLQ", "VPSRAD", "VPSRAQ"} {
+		for _, count := range []int{-128, -1} {
+			row := fmt.Sprintf("%s.BCST $%d,(AX),X2", name, count)
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64"); !known || err == nil {
+				t.Errorf("EVEX-only Yu8 broadcast accepted signed count: %s: %v", row, err)
+			}
+		}
+	}
+}
diff --git a/amd64_arithmetic_shift_result_test.go b/amd64_arithmetic_shift_result_test.go
new file mode 100644
index 000000000..e87322775
--- /dev/null
+++ b/amd64_arithmetic_shift_result_test.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// Independent of the production shift directory. Uniform counts select their
+// low qword; variable counts have one complete unsigned integer per data lane.
+func x86ArithmeticShiftTestNames() []string {
+	return []string{"PSRAW", "PSRAL", "VPSRAW", "VPSRAD", "VPSRAQ", "VPSRAVW", "VPSRAVD", "VPSRAVQ"}
+}
+
+func x86ArithmeticShiftTestBits(name string) int {
+	switch name[len(name)-1] {
+	case 'W':
+		return 16
+	case 'Q':
+		return 64
+	default:
+		return 32
+	}
+}
+
+func TestX86ArithmeticShiftSharedTypedResultGrammar(t *testing.T) {
+	for _, name := range x86ArithmeticShiftTestNames() {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			legacy := name[0] != 'V'
+			if legacy && bank != "X" {
+				continue
+			}
+			perLane := len(name) > 5 && name[5] == 'V'
+			count := "X0"
+			if perLane {
+				count = bank + "0"
+			}
+			row := name + " " + count + "," + bank + "1," + bank + "2"
+			if legacy {
+				row = name + " X0,X1"
+			}
+			ins := x86ScalarLaneInstruction(t, row)
+			for _, arch := range []string{"386", "amd64"} {
+				form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+				if !known || err != nil || form.laneBits != x86ArithmeticShiftTestBits(name) {
+					t.Errorf("complete arithmetic family missing from shared result grammar: %s/%s: %v", arch, row, err)
+					continue
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.writeVector(1, 64, ^uint64(0), false)
+				if accepted, known := x86ResultPackedShiftStep(ins, &state, nil, arch); !known || !accepted {
+					t.Errorf("initialized arithmetic result rejected: %s/%s", arch, row)
+				}
+			}
+		}
+	}
+}
+
+// Enumerate individual bits rather than borrowing the interval implementation.
+// Oversized arithmetic counts select the sign bit, never a constant zero.
+func TestX86ArithmeticShiftEverySignBitDependency(t *testing.T) {
+	for _, name := range x86ArithmeticShiftTestNames() {
+		legacy := name[0] != 'V'
+		perLane := len(name) > 5 && name[5] == 'V'
+		for _, width := range []int{16, 32, 64} {
+			if legacy && width != 16 {
+				continue
+			}
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			counts := []int{-1}
+			if !perLane {
+				counts = append(counts, 0, 1, 7, 8, 15, 16, 31, 32, 63, 64, 127, 255)
+			}
+			for _, count := range counts {
+				if legacy && count == 255 {
+					continue
+				}
+				countSource := "X0"
+				if count >= 0 {
+					countSource = fmt.Sprintf("$%d", count)
+				} else if perLane {
+					countSource = bank + "0"
+				}
+				row := name + " " + countSource + "," + bank + "1," + bank + "2"
+				if legacy {
+					row = name + " " + countSource + ",X1"
+				}
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+				if !known || err != nil {
+					t.Errorf("arithmetic dependency grammar missing: %s: %v", row, err)
+					continue
+				}
+				bits := x86ArithmeticShiftTestBits(name)
+				for output := 0; output < width; output++ {
+					var data, counter uint64
+					for bit := output * 8; bit < output*8+8; bit++ {
+						first, end := count, count+1
+						if count < 0 {
+							first, end = 0, bits+1
+						}
+						for shift := first; shift < end; shift++ {
+							from := bit%bits + shift
+							if from >= bits {
+								from = bits - 1
+							}
+							data |= uint64(1) << uint((bit/bits*bits+from)/8)
+						}
+					}
+					if count < 0 {
+						counter = 255
+						if perLane {
+							counter = x86CallerVectorByteMask(int64(bits/8)) << uint(output/(bits/8)*(bits/8))
+						}
+					}
+					gotData, gotCount := x86PackedShiftByteInputs(form, output)
+					if gotData != data || gotCount != counter {
+						t.Fatalf("%s byte%d: dependencies %x/%x want %x/%x", row, output, gotData, gotCount, data, counter)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ArithmeticShiftWholeSourceInputBoundaries(t *testing.T) {
+	for _, name := range x86ArithmeticShiftTestNames() {
+		row, memory, destination := name+" X0,X1", name+" (AX),X1", "X1"
+		if name[0] == 'V' {
+			row, memory, destination = name+" X0,X1,X2", name+" (AX),X1,X2", "X2"
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			// Partial numerical knowledge is intentional: an unobserved
+			// pure register result need not initialize every output byte.
+			// Ordinary ABI0 codegen may select allocated vector scratch.
+			// Native addresses and masks retain independent input checks.
+			source := "TEXT ·view(SB),4,$0-4\n" + row + "\nPEXTRD $0," + destination + ",AX\nMOVL AX,ret+0(FP)\nRET\n"
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", "amd64", "x86_64-unknown-linux-gnu", api)
+			x86VectorScratchCodegenControl(t, source, "func view() uint32", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			ir, err = x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-0\n"+memory+"\nRET\n",
+				"func view()", "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("unbound dead native count accepted: %s/%s: %v", memory, api, err)
+			}
+			if name[0] == 'V' {
+				masked := name + ".Z X0,X1,K1,X2"
+				ir, err = x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-0\n"+masked+"\nRET\n",
+					"func view()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("unknown dead mask accepted: %s/%s: %v", masked, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ArithmeticShiftSignBytesMasksAndUpperAliases(t *testing.T) {
+	for _, row := range []string{
+		"PSRAW $127,X1", "PSRAL $127,X1", "VPSRAW $255,X1,X2",
+		"VPSRAD $255,Y1,Y2", "VPSRAQ $255,Z1,Z2",
+		"VPSRAW $255,X1,K1,X2", "VPSRAW.Z $255,X1,K1,X2",
+		"VPSRAD $255,Y1,K1,Y2", "VPSRAQ.Z $255,Z1,K1,Z2",
+	} {
+		ins := x86ScalarLaneInstruction(t, row)
+		form, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+		if !known || err != nil {
+			t.Fatal(row, err)
+		}
+		var signs uint64
+		for at := form.laneBits/8 - 1; at < form.byteWidth; at += form.laneBits / 8 {
+			signs |= uint64(1) << uint(at)
+		}
+		for hole := -1; hole < form.byteWidth; hole++ {
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+			data := signs | 0xa55a000000000000
+			if hole >= 0 {
+				data &^= uint64(1) << uint(hole)
+			}
+			state.writeVector(1, 64, data, false)
+			state.writeVector(2, 64, 0x55aa55aa55aa55aa, false)
+			state.masks[1] = true
+			before := state.clone()
+			if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+				t.Fatal("partial arithmetic shift transfer rejected", row, hole)
+			}
+			var expected uint64
+			for output := 0; output < form.byteWidth; output++ {
+				sign := output/(form.laneBits/8)*(form.laneBits/8) + form.laneBits/8 - 1
+				if before.vectorBytes(1)&(uint64(1)<<uint(sign)) != 0 {
+					expected |= uint64(1) << uint(output)
+				}
+			}
+			destination := 2
+			if form.legacy {
+				destination = 1
+			}
+			if form.mask >= 0 && !form.zeroing {
+				expected &= before.vectorBytes(destination)
+			}
+			want := before.clone()
+			want.writeVector(destination, form.byteWidth, expected, form.legacy)
+			if !reflect.DeepEqual(state, want) {
+				t.Fatal("sign dependency, mask, upper alias or unrelated state changed", row, hole)
+			}
+		}
+	}
+	for _, row := range []string{"VPSRAQ $-1,X1,X2", "VPSRAD $1.0,X1,X2", "VPSRAW $undefined,X1,X2"} {
+		ins := x86ScalarLaneInstruction(t, row)
+		if _, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64"); !known || err == nil {
+			t.Fatal("invalid integer count acquired arithmetic grammar", row, err)
+		}
+	}
+}
diff --git a/amd64_arithmetic_shift_value_test.go b/amd64_arithmetic_shift_value_test.go
new file mode 100644
index 000000000..e4edf35d7
--- /dev/null
+++ b/amd64_arithmetic_shift_value_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86ArithmeticShiftValueRows(arch string) []struct{ op, bank, mode string } {
+	var rows []struct{ op, bank, mode string }
+	for _, name := range x86ArithmeticShiftTestNames() {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if name[0] != 'V' && bank != "X" {
+				continue
+			}
+			modes := []string{"plain"}
+			if arch == "amd64" && name[0] == 'V' {
+				modes = append(modes, "merge", "zero")
+			}
+			for _, mode := range modes {
+				rows = append(rows, struct{ op, bank, mode string }{name, bank, mode})
+			}
+		}
+	}
+	return rows
+}
+
+func x86ArithmeticShiftValueProgram(arch string) (string, string, string, string) {
+	return x86FixedBinaryValueRuntimeProgram(arch, false, "ArithmeticShift", x86ArithmeticShiftValueRows,
+		func(op string) (int, int) {
+			perLane := 0
+			if strings.Contains(op, "RAV") {
+				perLane = 1
+			}
+			return x86ArithmeticShiftTestBits(op), perLane
+		})
+}
+
+func TestX86ArithmeticShiftPortableBaselineTargetIR(t *testing.T) {
+	source, declarations, _, _ := x86ArithmeticShiftValueProgram("amd64")
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(api, err)
+			}
+			if regexp.MustCompile(`"target-features"="[^"]*\+avx`).MatchString(ir) {
+				t.Errorf("portable numerical oracle retains native ISA requirements: %s/%s", triple, api)
+			}
+		}
+	}
+}
+
+func TestX86ArithmeticShiftInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	if len(x86ArithmeticShiftValueRows("amd64")) != 56 || len(x86ArithmeticShiftValueRows("386")) != 20 {
+		t.Fatal("complete arithmetic opcode/width denominator changed")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _, _ := x86ArithmeticShiftValueProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+// Portable LLVM numerical execution is not original AVX/AVX512 execution.
+// Counts include each boundary and high unsigned bits; the reference builds
+// individual output bits without signed C shifts or the production emitter.
+func TestX86ArithmeticShiftPortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, cWord := "amd64", "uint64_t"
+	if strconv.IntSize == 32 {
+		arch, cWord = "386", "uint32_t"
+	}
+	source, declarations, prototypes, rows := x86ArithmeticShiftValueProgram(arch)
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes +
+		"typedef " + cWord + " shift_word;\n" + `
+struct kernel {void (*fn)(uint8_t*,uint8_t*,uint8_t*,shift_word);unsigned width,bits,mode,legacy,per_lane;};
+static const struct kernel kernels[]={
+` + rows + `};
+int main(void) {
+    const uint64_t counts[]={0,1,7,8,15,16,31,32,63,64,127,255,256,UINT64_C(0x100000000),UINT64_MAX};
+    const shift_word masks[]={0,1,(shift_word)0xa55a9c63f00fc33cULL,(shift_word)-1};
+    for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++) {
+        const struct kernel *p=&kernels[k];
+        for(unsigned sample=0;sample<33;sample++)for(unsigned c=0;c<sizeof(counts)/sizeof(counts[0]);c++)
+                for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+            uint8_t a[67],b[67],a_before[67],b_before[67],out[67],want[64];
+            memset(a,0xa7,sizeof(a));memset(b,0x91,sizeof(b));memset(out,0xc3,sizeof(out));
+            for(unsigned i=0;i<64;i++)b[i+1]=(i*73+sample*29)^(sample>>1);
+            unsigned count_bytes=p->per_lane?p->bits/8:8;
+            for(unsigned lane=0;lane<64/count_bytes;lane++)for(unsigned byte=0;byte<count_bytes;byte++)
+                a[1+lane*count_bytes+byte]=counts[(c+lane)%15]>>(byte*8);
+            memcpy(a_before,a,67);memcpy(b_before,b,67);memcpy(want,b+1,64);
+            if(!p->legacy)memset(want+p->width,0,64-p->width);
+            for(unsigned lane=0;lane<p->width/(p->bits/8);lane++) {
+                if(p->mode && !(masks[m]>>lane&1)) {
+                    if(p->mode==2)memset(want+lane*(p->bits/8),0,p->bits/8);
+                    continue;
+                }
+                unsigned at=p->per_lane?lane*count_bytes:0;
+                uint64_t shift=0;
+                for(unsigned byte=0;byte<count_bytes;byte++)shift|=(uint64_t)a[1+at+byte]<<(byte*8);
+                if(shift>=p->bits)shift=p->bits-1;
+                for(unsigned bit=0;bit<p->bits;bit++) {
+                    unsigned from=bit+(unsigned)shift;
+                    if(from>=p->bits)from=p->bits-1;
+                    unsigned input=lane*p->bits+from,output=lane*p->bits+bit;
+                    unsigned value=(b[1+input/8]>>(input%8))&1;
+                    want[output/8]=(want[output/8]&~(1u<<(output%8)))|(value<<(output%8));
+                }
+            }
+            p->fn(a+1,b+1,out+1,masks[m]);
+            if(memcmp(out+1,want,64)||out[65]!=1||out[0]!=0xc3||out[66]!=0xc3||
+                    memcmp(a,a_before,67)||memcmp(b,b_before,67)) {
+                fprintf(stderr,"arithmetic shift row=%u sample=%u count=%u width=%u bits=%u\n",k,sample,c,p->width,p->bits);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil {
+				t.Fatal(api, err)
+			}
+			if regexp.MustCompile(`"target-features"="[^"]*\+avx`).MatchString(ir) {
+				t.Fatal("portable arithmetic oracle requires native AVX/AVX512 hardware")
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "arithmetic-shift-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+	t.Log("complete opcode/width kernels and Go-valid merge/zero masks; full 64-byte aliases, CF, input/output canaries and unsigned saturating counts; portable LLVM only")
+}
diff --git a/amd64_atomic_memory_test.go b/amd64_atomic_memory_test.go
new file mode 100644
index 000000000..51ca561db
--- /dev/null
+++ b/amd64_atomic_memory_test.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// An object-only success is insufficient: LLVM can legalize an under-aligned
+// atomicrmw into an unresolved libatomic call, absent from the Windows CRT.
+func TestX86AtomicExchangeMemoryNeedsNoRuntimeHelpers(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"386", "i686-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-w64-windows-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"amd64", "x86_64-w64-windows-gnu"},
+		{"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-apple-darwin"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT exchange(SB),$0-0\n")
+			for _, family := range []string{"XADD", "XCHG"} {
+				widths := "BWL"
+				if target.arch == "amd64" {
+					widths += "Q"
+				}
+				for _, width := range widths {
+					reg := "DX"
+					if width == 'B' {
+						reg = "DL"
+					}
+					fmt.Fprintf(&source, "%s%c %s, 1(BX)\n", family, width, reg)
+					fmt.Fprintf(&source, "%s%c %s, 1(FS)\n", family, width, reg)
+					fmt.Fprintf(&source, "%s%c %s, 1(GS)\n", family, width, reg)
+				}
+			}
+			source.WriteString("RET\n")
+			// Preserve every uninitialized original instruction and its Go
+			// object/public Context. This private emitter proves formats and
+			// absence of invented runtime helpers, not initialized execution.
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(), "exchange", target.arch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+				func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+					spec, known := amd64ExchangeSpecs[instruction.Op]
+					if !known {
+						return false, false, fmt.Errorf("original exchange fixture changed family: %s", instruction.Raw)
+					}
+					return c.lowerExchange(instruction.Op, spec, instruction)
+				})
+			dir := t.TempDir()
+			input := filepath.Join(dir, "exchange.ll")
+			if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			asm, err := exec.Command(llc, "-mtriple="+target.triple, "-filetype=asm", input, "-o", "-").CombinedOutput()
+			if err != nil {
+				t.Fatalf("LLVM 22: %v\n%s", err, asm)
+			}
+			if strings.Contains(string(asm), "__atomic") || strings.Contains(string(asm), "__sync") {
+				t.Fatalf("native x86 exchange acquired an external atomic helper:\n%s", asm)
+			}
+			for _, segment := range []string{"%fs:", "%gs:"} {
+				want := 6
+				if target.arch == "amd64" {
+					want = 8
+				}
+				if got := strings.Count(string(asm), segment); got != want {
+					t.Fatalf("atomic memory operand retained %d/%d %s overrides:\n%s", got, want, segment, asm)
+				}
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+			}
+			// The complete original instruction tail is byte-exact. Only
+			// actual typed-pointer and numerical entry producers are added.
+			_, original, found := strings.Cut(source.String(), "\n")
+			if !found {
+				t.Fatal("original exchange fixture lost its TEXT header")
+			}
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			initialized := fmt.Sprintf("TEXT exchange(SB),4,$0-%d\n%s p+0(FP),BX\n%s $5,DX\n%s",
+				word, move, move, original)
+			if !strings.HasSuffix(initialized, original) {
+				t.Fatal("initialized exchange changed an original instruction or direction")
+			}
+			x86OriginalGPInitializedFormatObjects(t, []x86OriginalGPInitializedFormat{{
+				source: initialized, declaration: "func exchange(p *[32]byte)",
+			}}, target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86ExchangeGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A((?:XADD|XCHG)[BWLQ]),\s*(\w+),`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 8 || len(rows) != len(amd64ExchangeSpecs) {
+		t.Fatalf("Go encoder has %d exchange opcodes; grammar has %d", len(rows), len(amd64ExchangeSpecs))
+	}
+	for _, row := range rows {
+		spec, ok := amd64ExchangeSpecs[Op(row[1])]
+		bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[row[1][len(row[1])-1]]
+		kind, table := amd64ExchangeSwap, "yxchg"
+		if strings.HasPrefix(row[1], "XADD") {
+			kind, table = amd64ExchangeAdd, "yrl_ml"
+			if bits == 8 {
+				table = "yrb_mb"
+			}
+		} else if bits == 8 {
+			table = "yml_mb"
+		}
+		if !ok || spec.bits != bits || spec.kind != kind || row[2] != table {
+			t.Errorf("Go %s/%s disagrees with typed grammar: %+v", row[1], row[2], spec)
+		}
+	}
+}
+
+func TestAMD64ExchangeUnalignedRuntimeSemantics(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution requires amd64 or Rosetta; the all-host object matrix remains required")
+	}
+	var source, declarations, cases strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, family := range []string{"XADD", "XCHG", "REVERSE"} {
+		for i, width := range "BWLQ" {
+			bits := []int{8, 16, 32, 64}[i]
+			name := fmt.Sprintf("exchange_%s_%d", family, bits)
+			reg := "AX"
+			if bits == 8 {
+				reg = "AL"
+			}
+			instruction := fmt.Sprintf("%s%c %s, 1(BX)", family, width, reg)
+			if family == "REVERSE" {
+				instruction = fmt.Sprintf("XCHG%c 1(BX), %s", width, reg)
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVQ p+0(FP), BX\nMOVQ v+8(FP), AX\n%s\nMOVQ AX, ret+16(FP)\nRET\n", name, instruction)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64}, Ret: I64, Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+				Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+			}}
+			fmt.Fprintf(&declarations, "extern uint64_t %s(uint8_t *, uint64_t);\n", name)
+			add := 0
+			if family == "XADD" {
+				add = 1
+			}
+			fmt.Fprintf(&cases, "{%s, %d, %d},\n", name, bits, add)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple, runPrefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+` + declarations.String() + `
+int main(void) {
+  struct { uint64_t (*fn)(uint8_t *, uint64_t); int bits, add; } cases[] = {
+` + cases.String() + `
+  };
+  const uint64_t values[] = {0, 1, UINT64_MAX, UINT64_C(0x8877665544332211), UINT64_C(0x8000000080008080)};
+  for (unsigned c = 0; c < sizeof(cases)/sizeof(cases[0]); c++) {
+    int bits = cases[c].bits, bytes = bits/8;
+    uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+    for (unsigned offset = 0; offset < 8; offset++) {
+      for (unsigned a = 0; a < 5; a++) for (unsigned b = 0; b < 5; b++) {
+        _Alignas(64) uint8_t storage[64];
+        memset(storage, 0x5a, sizeof(storage));
+        uint64_t initial = values[a], value = values[b];
+        memcpy(storage + offset + 1, &initial, bytes);
+        uint64_t got = cases[c].fn(storage + offset, value), memory = 0;
+        memcpy(&memory, storage + offset + 1, bytes);
+        uint64_t want = initial & mask;
+        if (bits < 32) want |= value & ~mask;
+        if (got != want || memory != ((cases[c].add ? initial + value : value) & mask)) return 1;
+        for (unsigned i = 0; i < sizeof(storage); i++) {
+          if ((i < offset + 1 || i >= offset + 1 + bytes) && storage[i] != 0x5a) return 2;
+        }
+      }
+    }
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "exchange_unaligned", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_auxiliary_carry_runtime_test.go b/amd64_auxiliary_carry_runtime_test.go
new file mode 100644
index 000000000..3bd59f2fb
--- /dev/null
+++ b/amd64_auxiliary_carry_runtime_test.go
@@ -0,0 +1,310 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The reference computes carry/borrow using widened arithmetic, including the
+// low nibble for AF; it does not repeat the lowerer's XOR-bit implementation.
+const x86AuxiliaryGoReference = `package auxiliary
+
+import (
+ "encoding/binary"
+ "math/bits"
+ "testing"
+)
+
+type kernel struct {
+ fn func(*[64]byte, uint64, uint64, uint64)
+ op string
+ width, form int
+}
+
+func expected(op string, width, form int, a, b, seed uint64) uint64 {
+ if width == 0 || (op == "CMPS" || op == "SCAS") && form != 0 {
+  return seed & 0x8d5
+ }
+ mask := ^uint64(0)
+ if width < 64 {
+  mask = (uint64(1) << width) - 1
+ }
+ a &= mask
+ b &= mask
+ if form == 3 {
+  b = 1
+ }
+ carry := uint64(0)
+ if op == "ADC" || op == "SBB" {
+  carry = seed & 1
+ }
+ add := op == "ADD" || op == "ADC" || op == "INC" || op == "XADD"
+ switch op {
+ case "INC", "DEC":
+  b = 1
+ case "NEG":
+  b, a = a, 0
+ case "CMPXCHG":
+  a, b = b, a
+ }
+
+ result := a - b - carry
+ cf := a < b || a == b && carry != 0
+ af := (a & 15) < (b & 15) + carry
+ if add {
+  var c uint64
+  result, c = bits.Add64(a, b, carry)
+  cf = c != 0 || width < 64 && result > mask
+  af = (a & 15) + (b & 15) + carry > 15
+ }
+ result &= mask
+ sign := uint64(1) << (width - 1)
+ overflow := ((a ^ b) & (a ^ result) & sign) != 0
+ if add {
+  overflow = ((^(a ^ b)) & (a ^ result) & sign) != 0
+ }
+ if op == "INC" || op == "DEC" {
+  cf = seed & 1 != 0
+ }
+
+ f := uint64(0)
+ if cf { f |= 1 }
+ if bits.OnesCount8(uint8(result)) % 2 == 0 { f |= 4 }
+ if af { f |= 16 }
+ if result == 0 { f |= 64 }
+ if result & sign != 0 { f |= 128 }
+ if overflow { f |= 2048 }
+ return f
+}
+
+func check(t *testing.T, k kernel, a, b, seed uint64) {
+ t.Helper()
+ var out [64]byte
+ for i := range out {
+  out[i] = 0xa7
+ }
+ k.fn(&out, a, b, seed)
+ want := expected(k.op, k.width, k.form, a, b, seed)
+ got := binary.LittleEndian.Uint64(out[24:32]) & 0x8d5
+ if got != want || out[32] != byte(want) | 2 {
+  t.Fatalf("%s width=%d form=%d a=%x b=%x seed=%x flags=%x LAHF=%x want=%x", k.op, k.width, k.form, a, b, seed, got, out[32], want)
+ }
+ flags := []uint64{want & 1, (want >> 2) & 1, (want >> 6) & 1, (want >> 7) & 1, (want >> 11) & 1, ((want >> 7) ^ (want >> 11)) & 1}
+ for i, v := range flags {
+  if out[33+i] != byte(v) {
+   t.Fatalf("%s SETcc %d got=%d want=%d", k.op, i, out[33+i], v)
+  }
+ }
+ for i, v := range out {
+  if (i >= 16 && i < 24 || i >= 39) && v != 0xa7 {
+   t.Fatalf("%s byte canary %d", k.op, i)
+  }
+ }
+}
+
+func TestOriginalArithmeticStatus(t *testing.T) {
+ edges := []uint64{0, 1, 15, 16, 17, 127, 128, 255, 256, 32767, 32768, 65535, 0x7fffffff, 0x80000000, 0xffffffff, 0x7fffffffffffffff, 0x8000000000000000, ^uint64(0)}
+ for _, k := range kernels {
+  for _, seed := range []uint64{0, 0x8d5} {
+   for a := uint64(0); a < 16; a++ {
+    for b := uint64(0); b < 16; b++ {
+     check(t, k, a, b, seed)
+    }
+   }
+   for i, a := range edges {
+    for _, b := range []uint64{edges[(i+1)%len(edges)], edges[(i+7)%len(edges)]} {
+     check(t, k, a, b, seed)
+    }
+   }
+  }
+ }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86AuxiliaryCarryOriginalGo(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	var cases []x86AuxiliaryCase
+	for _, row := range x86AuxiliaryCases("amd64") {
+		if row.op != "CMPXCHG" {
+			cases = append(cases, row)
+		}
+	}
+	x86AuxiliaryOriginalGo(t, cases)
+}
+
+func TestCrossLinuxRuntimeMatrixX86AuxiliaryCarryCMPXCHGNativeGo(t *testing.T) {
+	if runtime.GOARCH != "amd64" {
+		t.Skip("original CMPXCHG flags require the native AMD64 cross-runtime job, not Rosetta")
+	}
+	var cases []x86AuxiliaryCase
+	for _, row := range x86AuxiliaryCases("amd64") {
+		if row.op == "CMPXCHG" {
+			cases = append(cases, row)
+		}
+	}
+	x86AuxiliaryOriginalGo(t, cases)
+}
+
+func x86AuxiliaryOriginalGo(t *testing.T, cases []x86AuxiliaryCase) {
+	t.Helper()
+	var declarations, kernels strings.Builder
+	kernels.WriteString("var kernels=[]kernel{\n")
+	for _, row := range cases {
+		fmt.Fprintf(&declarations, "func %s(*[64]byte,uint64,uint64,uint64)\n", row.name)
+		fmt.Fprintf(&kernels, "{%s,%q,%d,%d},\n", row.name, row.op, row.bits, row.form)
+	}
+	kernels.WriteString("}\n")
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":            "module auxiliary\n\ngo 1.20\n",
+		"auxiliary.go":      "package auxiliary\n" + declarations.String(),
+		"auxiliary_amd64.s": x86AuxiliaryAssembly("amd64", cases),
+		"auxiliary_test.go": x86AuxiliaryGoReference + kernels.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go complete arithmetic status: %v\n%s", err, output)
+	}
+	t.Logf("%d original Go kernels, exhaustive low nibbles, both CF/AF seeds and signed/unsigned width boundaries", len(cases))
+}
+
+const x86AuxiliaryCReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef void (*kernel)(uint8_t *, uint64_t, uint64_t, uint64_t);
+
+static int check(kernel fn, const char *op, int width, int form,
+                 uint64_t a, uint64_t b, uint64_t seed) {
+ _Alignas(8) uint8_t out[64];
+ memset(out, 0xa7, sizeof(out));
+ fn(out, a, b, seed);
+
+ uint64_t want = seed & 0x8d5;
+ if (width && !((!strcmp(op, "CMPS") || !strcmp(op, "SCAS")) && form)) {
+  uint64_t mask = width == 64 ? UINT64_MAX : (UINT64_C(1) << width) - 1;
+  a &= mask;
+  b &= mask;
+  if (form == 3) {
+   b = 1;
+  }
+  unsigned carry = !strcmp(op, "ADC") || !strcmp(op, "SBB") ? seed & 1 : 0;
+  int add = !strcmp(op, "ADD") || !strcmp(op, "ADC") ||
+            !strcmp(op, "INC") || !strcmp(op, "XADD");
+  if (!strcmp(op, "INC") || !strcmp(op, "DEC")) {
+   b = 1;
+  }
+  if (!strcmp(op, "NEG")) {
+   b = a;
+   a = 0;
+  }
+  if (!strcmp(op, "CMPXCHG")) {
+   uint64_t swap = a;
+   a = b;
+   b = swap;
+  }
+
+  __uint128_t wide = add ? (__uint128_t)a + b + carry : (__uint128_t)a - b - carry;
+  uint64_t result = (uint64_t)wide & mask;
+  unsigned cf = add ? wide > mask : (__uint128_t)a < (__uint128_t)b + carry;
+  unsigned af = add ? (a & 15) + (b & 15) + carry > 15 : (a & 15) < (b & 15) + carry;
+  uint64_t sign = UINT64_C(1) << (width - 1);
+  unsigned of = (add ? (~(a ^ b) & (a ^ result)) : (a ^ b) & (a ^ result)) & sign ? 1 : 0;
+  if (!strcmp(op, "INC") || !strcmp(op, "DEC")) {
+   cf = seed & 1;
+  }
+  unsigned ones = 0;
+  for (unsigned i = 0; i < 8; i++) {
+   ones += (result >> i) & 1;
+  }
+  want = cf | ((ones % 2 == 0) << 2) | (af << 4) | ((result == 0) << 6) |
+         ((!!(result & sign)) << 7) | (of << 11);
+ }
+
+ uint64_t flags;
+ memcpy(&flags, out + 24, 8);
+ flags &= 0x8d5;
+ if (flags != want || out[32] != ((want & 255) | 2)) {
+  fprintf(stderr, "%s width=%d form=%d flags=%llx lahf=%x want=%llx\n",
+          op, width, form, (unsigned long long)flags, out[32], (unsigned long long)want);
+  return 1;
+ }
+ unsigned bits[] = {0, 2, 6, 7, 11};
+ for (unsigned i = 0; i < 5; i++) {
+  if (out[33+i] != ((want >> bits[i]) & 1)) {
+   return 2;
+  }
+ }
+ if (out[38] != (((want >> 7) ^ (want >> 11)) & 1)) {
+  return 3;
+ }
+ for (unsigned i = 16; i < 24; i++) {
+  if (out[i] != 0xa7) {
+   return 4;
+  }
+ }
+ for (unsigned i = 39; i < 64; i++) {
+  if (out[i] != 0xa7) {
+   return 5;
+  }
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86AuxiliaryCarryLLVM(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	cases := x86AuxiliaryCases("amd64")
+	file, err := Parse(ArchAMD64, x86AuxiliaryAssembly("amd64", cases))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declarations, checks strings.Builder
+	for _, row := range cases {
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,uint64_t,uint64_t,uint64_t);\n", row.name)
+		fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,a,b,seed))return 1;\n", row.name, row.op, row.bits, row.form)
+	}
+	main := x86AuxiliaryCReference + declarations.String() + `
+int main(void) {
+ const uint64_t edges[] = {
+  0, 1, 15, 16, 17, 127, 128, 255, 256, 32767, 32768, 65535,
+  0x7fffffff, 0x80000000, 0xffffffff, 0x7fffffffffffffff,
+  0x8000000000000000, UINT64_MAX
+ };
+ for (unsigned s = 0; s < 2; s++) {
+  for (unsigned i = 0; i < 292; i++) {
+   uint64_t seed = s ? 0x8d5 : 0, a, b;
+   if (i < 256) {
+    a = i / 16;
+    b = i % 16;
+   } else {
+    a = edges[(i-256)/2];
+    b = edges[((i-256)/2 + (i%2 ? 7 : 1))%18];
+   }
+` + checks.String() + "  }\n }\n return 0;\n}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			ir, err := Translate(file, x86AuxiliaryOptions("amd64", triple, cases))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if optimized {
+				ir = x86MulDivRoundOptimize(t, ir)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "auxiliary-status", triple, ir, main, prefix)
+		})
+	}
+}
diff --git a/amd64_auxiliary_carry_test.go b/amd64_auxiliary_carry_test.go
new file mode 100644
index 000000000..8245af1f3
--- /dev/null
+++ b/amd64_auxiliary_carry_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86AuxiliaryCase struct {
+	name string
+	op   string
+	bits int
+	form int
+}
+
+// Operand axes are tested independently of the existing complete encoder-row
+// tests. All arithmetic flag producers, including exchange/string comparisons,
+// must feed the same architectural AF bit consumed by LAHF and PUSHF.
+func x86AuxiliaryCases(arch string) []x86AuxiliaryCase {
+	var cases []x86AuxiliaryCase
+	widths := []int{8, 16, 32}
+	if arch == "amd64" {
+		widths = append(widths, 64)
+	}
+	for _, op := range []string{"ADD", "SUB", "ADC", "SBB", "CMP", "INC", "DEC", "NEG", "XADD", "CMPXCHG", "CMPS", "SCAS"} {
+		forms := 4 // Register, memory source, memory destination, immediate.
+		switch op {
+		case "INC", "DEC", "NEG", "XADD", "CMPXCHG":
+			forms = 2
+		case "CMPS", "SCAS":
+			forms = 3 // Single comparison; zero-count REP and REPN with NULL inputs.
+		}
+		for _, bits := range widths {
+			for form := 0; form < forms; form++ {
+				cases = append(cases, x86AuxiliaryCase{fmt.Sprintf("aux%d", len(cases)), op, bits, form})
+			}
+		}
+	}
+	return append(cases, x86AuxiliaryCase{"auxpopf", "POPF", 0, 0}, x86AuxiliaryCase{"auxsahf", "SAHF", 0, 0})
+}
+
+func x86AuxiliaryAssembly(arch string, cases []x86AuxiliaryCase) string {
+	saved := "R8"
+	if arch == "386" {
+		saved = "BP"
+	}
+	return x86AuxiliaryAssemblyWithSavedRegister(arch, cases, saved)
+}
+
+func x86AuxiliaryAssemblyWithSavedRegister(arch string, cases []x86AuxiliaryCase, saved string) string {
+	move, push, flags, slot := "Q", "Q", "Q", 8
+	if arch == "386" {
+		move, push, flags, slot = "L", "L", "L", 4
+	}
+	var source strings.Builder
+	for _, row := range cases {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", row.name, slot*4)
+		fmt.Fprintf(&source, "MOV%s out+0(FP),DI\nMOV%s a+%d(FP),BX\nMOV%s b+%d(FP),DX\nMOV%s seed+%d(FP),CX\n", move, move, slot, move, slot*2, move, slot*3)
+		fmt.Fprintf(&source, "MOV%s BX,0(DI)\nMOV%s DX,8(DI)\n", move, move)
+		if row.op == "SAHF" {
+			fmt.Fprintf(&source, "MOV%s CX,AX\nSHL%s $8,AX\n", move, move)
+		}
+		if row.op == "CMPXCHG" {
+			fmt.Fprintf(&source, "MOV%s DX,AX\n", move)
+		}
+		if row.op == "CMPS" || row.op == "SCAS" {
+			// Use an ordinary GP, not AMD64's independently owned BP frame.
+			fmt.Fprintf(&source, "PUSH%s %s\n", push, saved)
+			fmt.Fprintf(&source, "MOV%s DI,%s\nMOV%s DI,SI\nADD%s $8,DI\nMOV%s BX,AX\n", move, saved, move, move, move)
+		}
+		fmt.Fprintf(&source, "PUSH%s CX\nPOPF%s\n", push, flags)
+		suffix := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[row.bits]
+		opcode := row.op + suffix
+		switch row.op {
+		case "POPF": // The seed is already installed above.
+		case "SAHF":
+			source.WriteString("SAHF\n")
+		case "CMPS", "SCAS":
+			if row.form != 0 {
+				fmt.Fprintf(&source, "MOV%s $0,CX\nMOV%s $0,SI\nMOV%s $0,DI\n", move, move, move)
+				prefix := "REP"
+				if row.form == 2 {
+					prefix = "REPN"
+				}
+				fmt.Fprintf(&source, "%s\n", prefix)
+			}
+			fmt.Fprintf(&source, "%s\nMOV%s %s,DI\n", opcode, move, saved)
+		case "INC", "DEC", "NEG":
+			destination := "BX"
+			if row.form == 1 {
+				destination = "0(DI)"
+			}
+			fmt.Fprintf(&source, "%s %s\n", opcode, destination)
+		case "XADD", "CMPXCHG":
+			destination := "BX"
+			if row.form == 1 {
+				destination = "0(DI)"
+			}
+			fmt.Fprintf(&source, "%s DX,%s\n", opcode, destination)
+		case "CMP":
+			operands := []string{"BX,DX", "BX,8(DI)", "0(DI),DX", "BX,$1"}
+			fmt.Fprintf(&source, "%s %s\n", opcode, operands[row.form])
+		default:
+			operands := []string{"DX,BX", "8(DI),BX", "DX,0(DI)", "$1,BX"}
+			fmt.Fprintf(&source, "%s %s\n", opcode, operands[row.form])
+		}
+		fmt.Fprintf(&source, "PUSHF%s\nPOP%s CX\nMOV%s CX,24(DI)\nLAHF\nMOVB AH,32(DI)\n", flags, push, move)
+		source.WriteString("SETCS 33(DI)\nSETPS 34(DI)\nSETEQ 35(DI)\nSETMI 36(DI)\nSETOS 37(DI)\nSETLT 38(DI)\n")
+		if row.op == "CMPS" || row.op == "SCAS" {
+			fmt.Fprintf(&source, "POP%s %s\n", push, saved)
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String()
+}
+
+func TestX86AuxiliaryCarryOriginalPhysicalBPRemainsContext(t *testing.T) {
+	cases := []x86AuxiliaryCase{{name: "PhysicalFrame", op: "CMPS", bits: 8}}
+	source := x86AuxiliaryAssemblyWithSavedRegister("amd64", cases, "BP")
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The whole-family owner retains the ordinary mode32 BP form.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source,
+					"func PhysicalFrame(out *byte,a,b,seed uint64)", target.arch, target.triple, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("original BP source borrowed ordinary numerical GP transport", api, err)
+				}
+			}
+		})
+	}
+}
+
+func x86AuxiliaryOptions(arch, triple string, cases []x86AuxiliaryCase) Options {
+	typ, slot := I64, int64(8)
+	if arch == "386" {
+		typ, slot = I32, 4
+	}
+	sigs := make(map[string]FuncSig, len(cases))
+	for _, row := range cases {
+		sigs[row.name] = FuncSig{Name: row.name, Args: []LLVMType{Ptr, typ, typ, typ}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: slot, Type: typ, Index: 1, Field: -1},
+				{Offset: slot * 2, Type: typ, Index: 2, Field: -1},
+				{Offset: slot * 3, Type: typ, Index: 3, Field: -1},
+			}},
+		}
+	}
+	return Options{Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	}
+}
+
+func TestX86AuxiliaryCarryWholeFamilyObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			cases := x86AuxiliaryCases(target.arch)
+			source := x86AuxiliaryAssembly(target.arch, cases)
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, x86AuxiliaryOptions(target.arch, target.triple, cases))
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "auxiliary.ll", "auxiliary.o", ir)
+			if !strings.Contains(ir, "%flags_af = alloca i1") {
+				t.Fatal("arithmetic status consumers silently omit architectural AF")
+			}
+		})
+	}
+}
diff --git a/amd64_bextr_forms.go b/amd64_bextr_forms.go
new file mode 100644
index 000000000..c6317d4d9
--- /dev/null
+++ b/amd64_bextr_forms.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+func x86BEXTRProperties(op Op, ins Instr, arch string) (x86ScalarBitFieldForm, bool, error) {
+	return x86ScalarBitFieldFamilyProperties(op, ins, arch, x86BitFieldExtract)
+}
+
+func x86TypedScalarBitFieldByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ScalarBitFieldProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	return x86TypedByteEffect{
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: form.control, width: form.spec.controlBytes, read: true},
+			{index: 1, operand: form.source, width: width, read: true},
+			{index: 2, operand: form.destination, width: width, write: true},
+		},
+		flagsDefined:        form.spec.flagsDefined,
+		flagsKilled:         x86ByteFlagsAll,
+		requiresResultProof: true,
+	}, true, nil
+}
+
+// A paired native read supplies numerical source bytes only if it continues.
+// It grants no caller, extent, raw-entry or reusable native-memory capability.
+func x86ResultScalarBitFieldStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64,
+	arch string, nativeRead bool) (bool, bool) {
+	effect, known, err := x86TypedScalarBitFieldByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	for _, operand := range effect.operands {
+		if !operand.read {
+			continue
+		}
+		if operand.operand.Kind == OpReg {
+			index, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+			if !valid || state.pointerGP[index] {
+				return false, true
+			}
+		}
+		if !x86ResultReadWithNativeContinuation(ins, operand.operand, operand.width, state, owned, arch, nativeRead) {
+			return false, true
+		}
+	}
+	output := effect.operands[2]
+	if !x86ResultStore(output.operand, output.width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
diff --git a/amd64_bittest_effects_test.go b/amd64_bittest_effects_test.go
new file mode 100644
index 000000000..3331947cf
--- /dev/null
+++ b/amd64_bittest_effects_test.go
@@ -0,0 +1,194 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BitTestTypedByteAndFlagEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BitTestOracleNames(arch) {
+			width := int64(map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]])
+			writes := len(op) != 3
+			for _, index := range []string{"$1", "CX"} {
+				ins := x86PureGPUnknownInstruction(t, op+" "+index+",AX")
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 || effect.dynamicMemory ||
+					effect.flagsDefined != x86ByteFlagCF || effect.flagsRead != 0 ||
+					effect.flagsKilled != x86ByteFlagsAll&^(x86ByteFlagCF|x86ByteFlagZF) ||
+					!effect.operands[1].read || effect.operands[1].write != writes {
+					t.Fatalf("incomplete %s/%s byte/flag effects: %+v %v", arch, ins.Raw, effect, err)
+				}
+				for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+					state := x86ResultState{flags: flags}
+					state.gp[0], state.gp[1] = 0xff, 0xff
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) || state.flags != flags&x86ByteFlagZF|x86ByteFlagCF {
+						t.Fatalf("%s/%s invented incoming flag state %x: %x", arch, ins.Raw, flags, state.flags)
+					}
+				}
+				for missingOperand := 0; missingOperand < 2; missingOperand++ {
+					for missingByte := int64(-1); missingByte < width; missingByte++ {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.gp[1] = uint8(1<<uint(width)-1), uint8(1<<uint(width)-1)
+						missing := missingByte >= 0 && (missingOperand == 1 || index != "$1")
+						if missing {
+							register := 1 - missingOperand
+							state.gp[register] &^= 1 << uint(missingByte)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						if accepted == missing {
+							t.Fatalf("%s/%s missing operand=%d byte=%d admitted=%v", arch, ins.Raw, missingOperand, missingByte, accepted)
+						}
+						if accepted {
+							want := before.gp[0]
+							if writes && width == 4 {
+								want |= 0xf0
+							}
+							if state.gp[0] != want || state.gp[1] != before.gp[1] || state.flags != x86ByteFlagCF|x86ByteFlagZF {
+								t.Fatalf("%s/%s changed unwritten bytes or preserved undefined flags: %+v", arch, ins.Raw, state)
+							}
+						}
+					}
+				}
+				memory := x86PureGPUnknownInstruction(t, op+" "+index+",(DX)")
+				effect, known, err = x86TypedInstructionByteEffect(memory.Op, memory, arch)
+				if !known || err != nil || effect.dynamicMemory != (index == "CX") {
+					t.Fatal("memory bit string was mistaken for a fixed register word", memory, effect, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86BitTestFlagsAndMemoryDoNotAcquireAuthority(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86BitTestOracleNames(target.arch) {
+			for _, condition := range []struct {
+				branch string
+				valid  bool
+			}{{"JCS", true}, {"JE", true}, {"JOS", false}, {"JMI", false}, {"JPS", false}} {
+				source := "TEXT ·value(SB),4,$0-4\nMOVL $1,AX\nCMPL AX,AX\n" + op + " $0,AX\n" +
+					condition.branch + " equal\nMOVL $7,AX\nMOVL AX,X0\nJMP done\nequal:\nPXOR X0,X0\ndone:\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					_, err := x86ScalarFPBitViewAPI(t, source, "func value() uint32", target.arch, target.triple, api)
+					if condition.valid && err != nil || !condition.valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s/%s/%s/%s flag initialization differs: %v", target.triple, op, condition.branch, api, err)
+					}
+				}
+			}
+			for _, memory := range []string{"unbound(SB)", "(DX)", "8(DX)(FS*1)", "8(DX)(GS*1)"} {
+				source := "TEXT ·value(SB),4,$0-4\n" + op + " $0," + memory + "\nPXOR X0,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func value() uint32", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("new native/source read authority: %s/%s/%s/%s: %v", target.triple, op, memory, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BitTestSegmentContinuationObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range x86BitTestOracleNames(target.arch) {
+				for _, segment := range []string{"FS", "GS"} {
+					for _, index := range []string{"$0", "CX"} {
+						memory := "8(" + segment + ")"
+						ins := x86PureGPUnknownInstruction(t, op+" "+index+","+memory)
+						state := x86ResultState{}
+						state.gp[1] = 0xff
+						if x86ResultTransfer(ins, &state, nil, 0, target.arch) {
+							t.Fatal("standalone observer borrowed paired native segment continuation", ins.Raw)
+						}
+
+						// Preserve the original bare-segment program. Only the
+						// register-index counterpart adds its required input.
+						name := fmt.Sprintf("segment%d", count)
+						count++
+						setup := ""
+						if index == "CX" {
+							setup = "MOVL $1,CX\n"
+						}
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n%s%s %s,%s\nPXOR X0,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n",
+							name, setup, op, index, memory)
+						fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if strings.Count(text, "load volatile") != count ||
+						strings.Count(text, "store volatile") != count*3/4 ||
+						!strings.Contains(text, "addrspace(256)") || !strings.Contains(text, "addrspace(257)") {
+						t.Fatal("dead segment bit operations lost their exact paired accesses", api)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86BitTestFPCompleteByteSpans(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		var validSource, declarations strings.Builder
+		count := 0
+		for _, op := range x86BitTestOracleNames(target.arch) {
+			width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+			for _, declaration := range []string{"func value(x uint64)", "func value(x [8]byte)", "func value(x float64)"} {
+				for offset := -1; offset <= 8; offset++ {
+					valid := offset >= 0 && offset+width <= 8
+					source := fmt.Sprintf("TEXT ·value(SB),4,$0-8\n%s $-1,x%+d(FP)\nRET\n", op, offset)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if valid && err != nil || !valid && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("%s/%s/%s/%s/%d byte boundary: %v", target.triple, op, declaration, api, offset, err)
+						}
+						if valid && x86CMOVFPHasNumericConversion(ir) {
+							t.Fatal("raw FP bits were numerically converted")
+						}
+					}
+				}
+			}
+			for _, declaration := range []string{"func value(x *uint64)", "func value(x uint8,y uint64)", "func value() uint64"} {
+				source := fmt.Sprintf("TEXT ·value(SB),4,$0-16\n%s $0,x+0(FP)\nRET\n", op)
+				if _, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("hole/pointer/uninitialized result acquired FP bytes: %s/%s/%s: %v", target.triple, op, declaration, err)
+				}
+			}
+			name := fmt.Sprintf("span%d", count)
+			fmt.Fprintf(&validSource, "TEXT ·%s(SB),4,$0-8\n%s $1,x+0(FP)\nRET\n", name, op)
+			fmt.Fprintf(&declarations, "func %s(x [8]byte)\n", name)
+			count++
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, validSource.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, validSource.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "bit-test-fp.ll", "bit-test-fp.o", ir)
+		}
+	}
+}
diff --git a/amd64_bittest_encoder_test.go b/amd64_bittest_encoder_test.go
new file mode 100644
index 000000000..5c046d13f
--- /dev/null
+++ b/amd64_bittest_encoder_test.go
@@ -0,0 +1,389 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BitTestCompleteGoEncoderRows(t *testing.T) {
+	contents, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(contents)
+	start := strings.Index(text, "var ybtl = []ytab{")
+	if start < 0 {
+		t.Fatal("actual Go omitted the bit-string encoder table")
+	}
+	actual := strings.SplitN(strings.SplitN(text[start:], "\n}", 2)[0], "[]ytab{", 2)[1]
+	got, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+	want, wantErr := x86SignedPackedFloatGoOpcodeTokens(`{Zibo_m,2,argList{Yi8,Yml}}, {Zr_m,1,argList{Yrl,Yml}},`)
+	if err != nil || wantErr != nil || !reflect.DeepEqual(got, want) {
+		t.Fatal("complete ordered ybtl rows/classes/zcase/offset changed")
+	}
+	rows := regexp.MustCompile(`(?m)^\s*\{A(BT(?:C|R|S)?[WLQ]),\s*(\w+),\s*(\w+),\s*opBytes\{([^}]+)\}\},`).FindAllStringSubmatch(text, -1)
+	if len(rows) != 12 {
+		t.Fatalf("complete Go family changed: %d rows", len(rows))
+	}
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		op, suffix := row[1], row[1][len(row[1])-1]
+		stem := op[:len(op)-1]
+		group := map[string]int{"BT": 4, "BTC": 7, "BTR": 6, "BTS": 5}[stem]
+		registerOpcode := map[string]int{"BT": 0xa3, "BTC": 0xbb, "BTR": 0xb3, "BTS": 0xab}[stem]
+		prefix := map[byte]string{'W': "Pq", 'L': "Pm", 'Q': "Pw"}[suffix]
+		encoding := fmt.Sprintf("0xba,0%d,0x%x", group, registerOpcode)
+		if suffix == 'Q' {
+			encoding = fmt.Sprintf("0x0f,0xba,0%d,0x0f,0x%x", group, registerOpcode)
+		}
+		got, err := x86SignedPackedFloatGoOpcodeTokens(row[4])
+		want, wantErr := x86SignedPackedFloatGoOpcodeTokens(encoding)
+		if seen[op] || row[2] != "ybtl" || row[3] != prefix || err != nil || wantErr != nil || !reflect.DeepEqual(got, want) {
+			t.Fatal("complete Go family registration/prefix/opcode changed", row)
+		}
+		seen[op] = true
+	}
+	for _, op := range x86BitTestOracleNames("amd64") {
+		if !seen[op] {
+			t.Fatal("independent witness absent from actual Go optab", op)
+		}
+	}
+}
+
+func TestX86BitTestAllImmediateBytesActualGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		var expected []byte
+		source.WriteString("TEXT f(SB),4,$0-0\n")
+		count := 0
+		for _, op := range x86BitTestOracleNames(arch) {
+			stem, suffix := op[:len(op)-1], op[len(op)-1]
+			group := byte(map[string]int{"BT": 4, "BTC": 7, "BTR": 6, "BTS": 5}[stem])
+			for immediate := -128; immediate < 128; immediate++ {
+				for _, destination := range []string{"AX", "7(DX)"} {
+					fmt.Fprintf(&source, "%s $%d,%s\n", op, immediate, destination)
+					if suffix == 'W' {
+						expected = append(expected, 0x66)
+					} else if suffix == 'Q' {
+						expected = append(expected, 0x48)
+					}
+					expected = append(expected, 0x0f, 0xba)
+					if destination == "AX" {
+						expected = append(expected, 0xc0|group<<3)
+					} else {
+						// Go emits exactly the source displacement, not a new
+						// displacement inferred from high immediate bits.
+						expected = append(expected, 0x42|group<<3, 7)
+					}
+					expected = append(expected, byte(immediate))
+					ins := x86PureGPUnknownInstruction(t, fmt.Sprintf("%s $%d,%s", op, immediate, destination))
+					form, known, err := x86BitTestProperties(ins.Op, ins, arch)
+					if !known || err != nil || form.index.Imm != int64(immediate) {
+						t.Fatal("typed immediate differs from independent original Go byte", ins, err)
+					}
+					count++
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		expected = append(expected, 0xc3)
+		actual := x86PackedShiftActualGoBytes(t, arch, source.String())
+		if !bytes.Equal(actual, expected) {
+			t.Fatalf("%s complete original immediate bytes differ: got %d bytes, want %d", arch, len(actual), len(expected))
+		}
+		t.Logf("%s: %d actual Go bit-string encodings, every imm8, register and memory", arch, count)
+	}
+}
+
+func TestX86BitTestCompleteFormsFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, deadRegisters strings.Builder
+			var initialized, unknownMemory []x86OriginalGPInitializedFormat
+			var deadDeclarations strings.Builder
+			privateOnly := 0
+			count := 0
+			for _, op := range x86BitTestOracleNames(target.arch) {
+				rows := []string{"$-128,AX", "$127,CX", "CX,AX", "AX,AX", "SP,BP", "CX,SP",
+					"$63,7(DX)", "CX,7(DX)", "CX,-3(DX)(SI*4)", "$1,data-3(SB)", "CX,data+3(SB)",
+					"$1,8(FS)", "CX,8(GS)", "$1,4096", "CX,4096"}
+				if target.arch == "amd64" {
+					rows = append(rows, "R8,R15", "R9,-7(R12)(R11*8)")
+				} else {
+					rows = append(rows, "$4294967295,AX", "CX,data(SB)(SP)", "$1,data(SB)(BX*4)")
+				}
+				registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+				if target.arch == "amd64" {
+					registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+				}
+				for _, register := range registers {
+					rows = append(rows, register+",AX", "$1,"+register, "AX,"+register)
+				}
+				for _, row := range rows {
+					body := op + " " + row
+					ins := x86PureGPUnknownInstruction(t, body)
+					form, known, err := x86BitTestProperties(ins.Op, ins, target.arch)
+					if !known || err != nil {
+						t.Fatalf("typed shape %s: %v", body, err)
+					}
+					name := fmt.Sprintf("form%d", count)
+					original := fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, body)
+					source.WriteString(original)
+					hardwareOnly := form.destination.Kind == OpMem && form.destination.Mem.Segment != "" &&
+						form.destination.Mem.Base == "" && form.destination.Mem.Index == "" && form.index.Kind == OpImm
+					if form.destination.Kind != OpReg && !hardwareOnly {
+						unknownMemory = append(unknownMemory, x86OriginalGPInitializedFormat{
+							source: original, declaration: "func " + name + "()",
+						})
+					}
+					ordinaryScratch := form.destination.Kind == OpReg &&
+						!x86OriginalGPPhysicalRegister(form.destination.Reg, target.arch) &&
+						(form.index.Kind != OpReg || !x86OriginalGPPhysicalRegister(form.index.Reg, target.arch))
+					if ordinaryScratch {
+						// A dead ordinary register scratch is still a valid
+						// public source; do not invent NUM to retain that domain.
+						deadRegisters.WriteString(original)
+						fmt.Fprintf(&deadDeclarations, "func %s()\n", name)
+					}
+					fixture, reason := x86BitTestOriginalInitializedFormat(target.arch, name, body, form)
+					if reason == "" {
+						initialized = append(initialized, fixture)
+					} else {
+						privateOnly++
+						t.Logf("original row %d retains format/public-role boundary: %s: %s", count, body, reason)
+					}
+					count++
+				}
+			}
+			want := map[string]int{"amd64": 780, "386": 336}[target.arch]
+			if count != want {
+				t.Fatal("original ordered bit-test inventory changed", count, want)
+			}
+			wantInitialized := map[string]int{"amd64": 636, "386": 248}[target.arch]
+			if len(initialized) != wantInitialized || privateOnly != want-wantInitialized {
+				t.Fatal("original bit-test input partition changed", len(initialized), privateOnly, wantInitialized)
+			}
+			// The complete unchanged source retains actual Go objects and
+			// three public Context observations. Emit every original row
+			// through the same typed family, with no public input claim.
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			formats := *file
+			formats.Funcs = nil
+			physicalWrites := 0
+			for _, function := range file.Funcs {
+				instruction := function.Instrs[1]
+				form, _, _ := x86BitTestProperties(instruction.Op, instruction, target.arch)
+				if target.arch != "386" || form.stem == "BT" || form.destination.Kind != OpReg || form.destination.Reg != SP {
+					formats.Funcs = append(formats.Funcs, function)
+					continue
+				}
+				// Go encodes these original physical ESP writes, but the
+				// ordinary emitter requires a modeled stack/return contract.
+				// Preserve its actual rejection rather than fabricate an object.
+				var partial strings.Builder
+				resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+				consumer := newX86Ctx(&partial, function, signatures[resolve(function.Sym)], resolve,
+					signatures, target.arch, target.triple, false)
+				if err := consumer.emitEntryAllocas(); err != nil {
+					t.Fatal(err)
+				}
+				known, terminal, err := consumer.lowerBitTestFamily(instruction.Op, instruction)
+				if !known || terminal || err == nil || !strings.Contains(err.Error(), "386 direct SP write is unsupported") {
+					t.Fatal("original physical ESP row lost its independent emitter boundary", instruction.Raw, err)
+				}
+				physicalWrites++
+			}
+			if want := map[string]int{"amd64": 0, "386": 18}[target.arch]; physicalWrites != want {
+				t.Fatal("original physical ESP write inventory changed", physicalWrites, want)
+			}
+			ir := x86SingleInstructionFormatObjectUnits(t, &formats, signatures, target.arch, target.triple,
+				func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return c.lowerBitTestFamily(instruction.Op, instruction)
+				})
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+			}
+			for row, fixture := range unknownMemory {
+				t.Run(fmt.Sprintf("unbound-memory/row%d", row), func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("unbound original memory format invented inputs", api, err)
+						}
+					}
+				})
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run("dead-registers/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, deadRegisters.String(), deadDeclarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original pure dead-register domain changed", err)
+					}
+				})
+			}
+			x86OriginalGPInitializedFormatObjects(t, initialized, target.arch, target.triple)
+			t.Logf("%d original Go formats; %d private LLVM formats; %d explicit physical-emitter rejections; %d exact-row initialized counterparts; %d independent physical/static/address roles",
+				count, len(formats.Funcs), physicalWrites, len(initialized), privateOnly)
+		})
+	}
+}
+
+// These test-only inputs name complete Go sources; they carry no product
+// permission and are never substituted into the original format inventory.
+type x86OriginalGPInitializedFormat struct {
+	source, declaration string
+}
+
+// Keep original row identity, exact displacement, segment and operand order.
+// A real NUM producer is separate from an opaque incoming pointer identity.
+func x86BitTestOriginalInitializedFormat(arch, name, body string, form x86BitTestForm) (x86OriginalGPInitializedFormat, string) {
+	var numerical []Reg
+	if form.index.Kind == OpReg {
+		numerical = append(numerical, form.index.Reg)
+	}
+	pointer := Reg("")
+	switch form.destination.Kind {
+	case OpReg:
+		numerical = append(numerical, form.destination.Reg)
+	case OpMem:
+		memory := form.destination.Mem
+		if memory.Sym != "" {
+			return x86OriginalGPInitializedFormat{}, "static bit string needs its independently bound source/storage role"
+		}
+		if memory.Segment != "" {
+			// The hardware base is implicit; an explicit GP is its NUM
+			// offset, never an opaque incoming-pointer identity.
+			if memory.Base != "" {
+				numerical = append(numerical, memory.Base)
+			}
+		} else {
+			if memory.Base == "" {
+				return x86OriginalGPInitializedFormat{}, "absolute numerical address has no ordinary opaque-pointer entry role"
+			}
+			pointer = memory.Base
+		}
+		if memory.Index != "" {
+			numerical = append(numerical, memory.Index)
+		}
+	default:
+		return x86OriginalGPInitializedFormat{}, "absolute/SB operand keeps its independent source-bound address role"
+	}
+	if pointer != "" && x86OriginalGPPhysicalRegister(pointer, arch) {
+		return x86OriginalGPInitializedFormat{}, "physical source frame register needs an independent registered entry"
+	}
+	for _, register := range numerical {
+		if x86OriginalGPPhysicalRegister(register, arch) {
+			return x86OriginalGPInitializedFormat{}, "physical source frame register cannot be fabricated as ordinary NUM"
+		}
+		if register == pointer {
+			return x86OriginalGPInitializedFormat{}, "one opaque address identity cannot also provide numerical source/index bytes"
+		}
+	}
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	var prefix strings.Builder
+	arguments, declaration := 0, "func "+name+"()"
+	if pointer != "" {
+		arguments = word
+		declaration = "func " + name + "(p *[64]byte)"
+		fmt.Fprintf(&prefix, "%s p+0(FP),%s\n", move, pointer)
+	}
+	seen := make(map[Reg]bool)
+	for _, register := range numerical {
+		if !seen[register] {
+			fmt.Fprintf(&prefix, "%s $1,%s\n", move, register)
+			seen[register] = true
+		}
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s%s\nRET\n", name, arguments, prefix.String(), body)
+	return x86OriginalGPInitializedFormat{source, declaration}, ""
+}
+
+// This ordinary source observer has no physical SP/amd64BP entry role.
+// BP remains an ordinary GP in Go's mode32 source contract.
+func x86OriginalGPPhysicalRegister(register Reg, arch string) bool {
+	return register == SP || arch == "amd64" && register == BP
+}
+
+// Batch complete original-format counterparts, never one LLVM process per
+// row. All original bytes and private objects remain independently owned.
+func x86OriginalGPInitializedFormatObjects(t *testing.T, fixtures []x86OriginalGPInitializedFormat, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for start := 0; start < len(fixtures); start += 32 {
+		end := start + 32
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		t.Run(fmt.Sprintf("initialized/batch%02d", start/32), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, fixture := range fixtures[start:end] {
+				source.WriteString(fixture.source)
+				declarations.WriteString(fixture.declaration + "\n")
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("same original instruction with complete ordinary inputs", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BitTestMalformedAndModeForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BitTestOracleNames(arch) {
+			for _, row := range []string{"$128,AX", "$-129,AX", "$1.0,AX", "AL,AX", "X0,AX", "AX,X0", "AX,$1", "AX", "(AX),BX", "$1,(AX)(SP*2)"} {
+				body := op + " " + row
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+				ins := x86PureGPUnknownInstruction(t, body)
+				if _, known, err := x86BitTestProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Errorf("malformed original form admitted: %s %s", arch, body)
+				}
+			}
+			for _, mutate := range []func(*Instr){
+				func(i *Instr) { i.Op += ".Z" },
+				func(i *Instr) { i.Args[0].ImmRaw = "unknown" },
+				func(i *Instr) { i.Args[1].Mem.OffRaw = "unknown" },
+				func(i *Instr) { i.Args[1].Mem.Index = CX; i.Args[1].Mem.Scale = 3 },
+			} {
+				ins := x86PureGPUnknownInstruction(t, op+" $1,(DX)")
+				mutate(&ins)
+				if _, known, err := x86BitTestProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Errorf("typed malformed shape admitted: %s %+v", arch, ins)
+				}
+			}
+		}
+	}
+	for _, body := range []string{"BTQ AX,BX", "BTCQ $1,(AX)", "BTRQ AX,BX", "BTSQ AX,BX", "BTL R8,AX", "BTSL AX,R15"} {
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+		ins := x86PureGPUnknownInstruction(t, body)
+		if _, known, err := x86BitTestProperties(ins.Op, ins, "386"); !known || err == nil {
+			t.Error("386 accepted unavailable native encoding", body)
+		}
+	}
+}
diff --git a/amd64_bittest_fault_runtime_unix_test.go b/amd64_bittest_fault_runtime_unix_test.go
new file mode 100644
index 000000000..313681c37
--- /dev/null
+++ b/amd64_bittest_fault_runtime_unix_test.go
@@ -0,0 +1,127 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This root is required by the Linux cross-runtime matrix. Local Rosetta
+// observations are diagnostic, not a replacement for native AMD64 execution.
+func TestCrossLinuxRuntimeMatrixX86BitTestDeadMemoryFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, native, prototypes, pairs strings.Builder
+	count := 0
+	for _, op := range x86BitTestOracleNames("amd64") {
+		for _, index := range []string{"$0", "CX"} {
+			name, original := fmt.Sprintf("dead%d", count), fmt.Sprintf("original%d", count)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ index+8(FP),CX\n%s %s,(AX)\nRET\n", name, op, index)
+			fmt.Fprintf(&declarations, "func %s(p *byte,index int64)\n", name)
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\nMOVQ SI,CX\n"+op+" "+index+",(DI)\nRET\n")
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,int64_t),%s(uint8_t*,int64_t);\n", name, original)
+			width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+			indexed, writes := 0, 1
+			if index == "CX" {
+				indexed = 1
+			}
+			if len(op) == 3 {
+				writes = 0
+			}
+			fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d},\n", original, name, width, indexed, writes)
+			count++
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + native.String() + `
+typedef void (*program)(uint8_t*,int64_t);
+static const struct { program original,translated; int width,indexed,writes; } pairs[]={
+` + pairs.String() + `};
+static int outcome(program fn,uint8_t *p,int64_t index) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        fn(p,index); _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    uint8_t *data=mmap(0,3*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(data==MAP_FAILED || mprotect(data+2*page,page,PROT_NONE)) return 2;
+    memset(data,0xff,2*page);
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(int shift=-1;shift<=1;++shift) {
+            for(int available=0;available<=2*pairs[i].width;++available) {
+                int displacement=pairs[i].indexed?shift*pairs[i].width:0;
+                int expected=available-displacement<pairs[i].width;
+                int64_t index=shift*8*pairs[i].width;
+                int a=outcome(pairs[i].original,data+2*page-available,index);
+                int b=outcome(pairs[i].translated,data+2*page-available,index);
+                if(a!=expected || b!=expected) {
+                    fprintf(stderr,"dead bit test=%u shift=%d available=%d want=%d Go=%d LLVM=%d\n",i,shift,available,expected,a,b);
+                    return 1;
+                }
+            }
+        }
+    }
+    for(int fill=0;fill<=255;fill+=255) {
+        if(mprotect(data,page,PROT_READ|PROT_WRITE)) return 3;
+        memset(data,fill,page);
+        if(mprotect(data,page,PROT_READ)) return 3;
+        for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+            int a=outcome(pairs[i].original,data+16,0);
+            int b=outcome(pairs[i].translated,data+16,0);
+            if(a!=pairs[i].writes || b!=pairs[i].writes) return 4;
+        }
+    }
+    if(munmap(data,3*page)) return 5;
+    puts("24 original Go/LLVM bit-string programs: dead full-width reads, signed offsets, read-only RMW");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "bit-test-dead", pipeline.ir, main, pipeline.level)
+					if string(output) != "24 original Go/LLVM bit-string programs: dead full-width reads, signed offsets, read-only RMW\n" {
+						t.Fatalf("missing original/LLVM fault receipt: %s", output)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_bittest_forms.go b/amd64_bittest_forms.go
new file mode 100644
index 000000000..1bc878c1e
--- /dev/null
+++ b/amd64_bittest_forms.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// All twelve Go ybtl registrations share these roles. A memory destination
+// with a register index is a signed bit string, not a fixed-width envelope.
+// This grammar supplies no memory, caller, native-frame or initialized bytes.
+type x86BitTestForm struct {
+	stem        string
+	bits        int
+	index       Operand
+	destination Operand
+}
+
+func x86BitTestProperties(op Op, ins Instr, arch string) (x86BitTestForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base := strings.SplitN(name, ".", 2)[0]
+	stem, bits, known := amd64BitTestProperties(base)
+	form := x86BitTestForm{stem: stem, bits: bits}
+	if !known {
+		return form, false, nil
+	}
+	fail := func(reason string) (x86BitTestForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if name != base || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) ||
+		arch != "386" && arch != "amd64" || arch == "386" && bits == 64 || len(ins.Args) != 2 {
+		return fail("has an invalid mode, suffix, identity or operand count")
+	}
+	form.index, form.destination = ins.Args[0], ins.Args[1]
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, form.destination, arch); segment {
+		if err != nil {
+			return form, true, err
+		}
+		form.destination = projected
+	}
+	if form.index.Kind == OpImm {
+		if form.index.ImmIsFloat || form.index.ImmRaw != "" {
+			return fail("requires a resolved integer bit index")
+		}
+		if arch == "386" {
+			form.index.Imm = int64(int32(form.index.Imm)) // Go oclass precedes Yi8.
+		}
+		if form.index.Imm < -128 || form.index.Imm > 127 {
+			return fail("bit index is outside Go's signed Yi8 class")
+		}
+	} else if form.index.Kind != OpReg || !isX86YrlRegisterForArch(form.index.Reg, arch) {
+		return fail("bit index is outside Go's Yi8/Yrl rows")
+	}
+	if form.destination.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.destination.Reg, arch) {
+			return fail("destination is outside Go's Yml register class")
+		}
+	} else if !x86ScalarCompareMemoryValid(form.destination, arch) {
+		if x86SourceTLSMemoryRole(form.destination, arch) {
+			return form, true, fmt.Errorf("%w: bit string needs its actual Go TLS address contract", ErrProbeNeedsContext)
+		}
+		return fail("destination is outside Go's encodable Yml memory class")
+	}
+	return form, true, nil
+}
+
+func x86TypedBitTestByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86BitTestProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	return x86TypedByteEffect{
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: form.index, width: width, read: true},
+			{index: 1, operand: form.destination, width: width, read: true, write: form.stem != "BT"},
+		},
+		flagsDefined:  x86ByteFlagCF,
+		flagsKilled:   x86ByteFlagOF | x86ByteFlagSF | x86ByteFlagAF | x86ByteFlagPF,
+		dynamicMemory: form.index.Kind == OpReg && form.destination.Kind != OpReg,
+	}, true, nil
+}
diff --git a/amd64_bittest_fp_runtime_test.go b/amd64_bittest_fp_runtime_test.go
new file mode 100644
index 000000000..48351829c
--- /dev/null
+++ b/amd64_bittest_fp_runtime_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86BitTestFPPartialWriteback(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, checks, goChecks strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, op := range x86BitTestOracleNames("amd64") {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+		for offset := 0; offset+width <= 8; offset++ {
+			name := fmt.Sprintf("Partial%d", count)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\n%s $-1,x+%d(FP)\nMOVQ x+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n", name, op, offset)
+			fmt.Fprintf(&declarations, "func %s(x uint64) uint64\n", name)
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t);\n", name)
+			mask := uint64(1) << uint(8*(offset+width)-1)
+			cWant, goWant := "x", "x"
+			switch op[:len(op)-1] {
+			case "BTC":
+				cWant, goWant = fmt.Sprintf("(x^UINT64_C(0x%x))", mask), fmt.Sprintf("x^uint64(0x%x)", mask)
+			case "BTR":
+				cWant, goWant = fmt.Sprintf("(x&~UINT64_C(0x%x))", mask), fmt.Sprintf("x&^uint64(0x%x)", mask)
+			case "BTS":
+				cWant, goWant = fmt.Sprintf("(x|UINT64_C(0x%x))", mask), fmt.Sprintf("x|uint64(0x%x)", mask)
+			}
+			fmt.Fprintf(&checks, "if(%s(x)!=%s) {fprintf(stderr,\"FP partial %d mismatch\\n\");return 1;}\n", name, cWant, count)
+			fmt.Fprintf(&goChecks, "if got,want:=%s(x),%s;got!=want {t.Fatalf(\"FP partial %d got=%%x want=%%x\",got,want)}\n", name, goWant, count)
+			count++
+		}
+	}
+	if count != 52 {
+		t.Fatalf("partial FP byte-span denominator changed: %d", count)
+	}
+	const patterns = "0,1,0x8000000000000000,0xffffffffffffffff,0x55aa0123cdef9876,0x7ff8000000000001"
+	original := "package oracle\nimport \"testing\"\nfunc TestOriginal(t *testing.T) { for _,x:=range []uint64{" + patterns + "} {\n" + goChecks.String() + "}}\n"
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), source.String(), original)
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() +
+		"int main(void) {const uint64_t patterns[]={" + patterns + "};\nfor(unsigned i=0;i<6;++i) {uint64_t x=patterns[i];\n" + checks.String() +
+		"}\nputs(\"52 partial FP programs x 6 complete values\");return 0;}\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), strings.TrimPrefix(declarations.String(), "package oracle\n"), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ level, ir string }{{"-O0", ir}, {"-O2", x86MulDivRoundOptimize(t, ir)}} {
+				output := execution.compileAndRunLLVM(t, "bit-test-fp-partial", pipeline.ir, main, pipeline.level)
+				if string(output) != "52 partial FP programs x 6 complete values\n" {
+					t.Fatalf("missing complete original/LLVM FP value oracle: %s", output)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_bittest_runtime_test.go b/amd64_bittest_runtime_test.go
new file mode 100644
index 000000000..e98214360
--- /dev/null
+++ b/amd64_bittest_runtime_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The original Go machine bytes and this independent whole-byte reference
+// agree separately with LLVM. CF and preserved ZF are compared; the ISA's
+// undefined OF/SF/AF/PF are deliberately not assigned invented expectations.
+func TestCrossLinuxRuntimeMatrixX86BitTestNumericalAndAliases(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, native, prototypes, pairs strings.Builder
+	count := 0
+	for _, op := range x86BitTestOracleNames("amd64") {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+		operation := map[string]int{"BT": 0, "BTC": 1, "BTR": 2, "BTS": 3}[op[:len(op)-1]]
+		for _, memory := range []bool{false, true} {
+			for _, index := range []string{"CX", "$-128", "$-1", "$0", "$15", "$16", "$31", "$32", "$63", "$64", "$127", "DX"} {
+				if memory && index == "DX" {
+					continue // DX/DX is the separate register alias axis.
+				}
+				name, original := fmt.Sprintf("numeric%d", count), fmt.Sprintf("original%d", count)
+				destination, originalDestination, after := "DX", "DX", "MOVQ DX,(DI)\n"
+				memoryFlag, mode, immediate := 0, 0, 0
+				if memory {
+					destination, originalDestination, after, memoryFlag = "(DI)", "(DI)", "", 1
+				}
+				if strings.HasPrefix(index, "$") {
+					mode = 1
+					if _, err := fmt.Sscanf(index, "$%d", &immediate); err != nil {
+						t.Fatal(err)
+					}
+				} else if index == "DX" {
+					mode = 2
+				}
+				body := op + " " + index + "," + destination
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ p+0(FP),DI\nMOVQ index+8(FP),CX\nMOVQ value+16(FP),DX\nCMPQ DX,DX\n%s\nPUSHFQ\nPOPQ AX\nANDQ $65,AX\n%sMOVQ AX,ret+24(FP)\nRET\n", name, body, after)
+				fmt.Fprintf(&declarations, "func %s(p *byte,index int64,value uint64) uint64\n", name)
+				code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\nMOVQ SI,CX\nCMPQ DX,DX\n"+op+" "+index+","+originalDestination+"\nPUSHFQ\nPOPQ AX\nANDQ $65,AX\n"+after+"RET\n")
+				var bytes []string
+				for _, b := range code {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+				}
+				symbol := original
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+				fmt.Fprintf(&prototypes, "extern uint64_t %s(uint8_t*,int64_t,uint64_t);\n", name)
+				prototypes.WriteString(x86OriginalSysVDeclaration("uint64_t", original, "uint8_t*,int64_t,uint64_t"))
+				fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d,%d,%d},\n", original, name, width, operation, memoryFlag, mode, immediate)
+				count++
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + native.String() +
+		x86OriginalSysVPointer("uint64_t", "originalProgram", "uint8_t*,int64_t,uint64_t") + `
+typedef uint64_t (*program)(uint8_t*,int64_t,uint64_t);
+static const struct { originalProgram original; program translated; int width,op,memory,mode,immediate; } pairs[]={
+` + pairs.String() + `};
+int main(void) {
+    const int64_t indexes[]={-255,-129,-128,-65,-64,-33,-32,-17,-16,-1,0,1,15,16,31,32,63,64,65,127,255};
+    const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0x55aa0123cdef9876),UINT64_C(0x12345678ffffffff)};
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(unsigned j=0;j<sizeof(indexes)/sizeof(*indexes);++j) {
+            for(unsigned v=0;v<sizeof(values)/sizeof(*values);++v) {
+                uint8_t original[512],translated[512],expected[512];
+                for(unsigned b=0;b<sizeof(expected);++b) expected[b]=(uint8_t)(b*71+v*3);
+                memcpy(original,expected,sizeof(expected));
+                memcpy(translated,expected,sizeof(expected));
+                int bits=8*pairs[i].width;
+                uint64_t index=pairs[i].mode==1?(uint64_t)pairs[i].immediate:
+                    pairs[i].mode==2?values[v]:(uint64_t)indexes[j];
+                int64_t offset=0;
+                if(pairs[i].memory && pairs[i].mode!=1) {
+                    int64_t signedIndex=bits==16?(int16_t)index:bits==32?(int32_t)index:(int64_t)index;
+                    /* Floor division, not C's truncation toward zero. */
+                    offset=(signedIndex>=0?signedIndex/bits:-1-((-1-signedIndex)/bits))*pairs[i].width;
+                }
+                uint64_t old=values[v];
+                if(pairs[i].memory) {
+                    old=0;
+                    memcpy(&old,expected+257+offset,pairs[i].width);
+                }
+                uint64_t selected=UINT64_C(1)<<(index&(bits-1));
+                uint64_t flags=64|!!(old&selected),result=old;
+                if(pairs[i].op==1) result^=selected;
+                if(pairs[i].op==2) result&=~selected;
+                if(pairs[i].op==3) result|=selected;
+                if(pairs[i].memory) {
+                    if(pairs[i].op) memcpy(expected+257+offset,&result,pairs[i].width);
+                } else {
+                    if(pairs[i].op && bits==32) result=(uint32_t)result;
+                    memcpy(expected+257,&result,8);
+                }
+                uint64_t a=pairs[i].original(original+257,indexes[j],values[v]);
+                uint64_t b=pairs[i].translated(translated+257,indexes[j],values[v]);
+                if(a!=flags || b!=flags || memcmp(original,expected,sizeof(expected)) || memcmp(translated,expected,sizeof(expected))) {
+                    fprintf(stderr,"bit test=%u index=%lld value=%llx expected flags=%llx Go=%llx LLVM=%llx\n",
+                        i,(long long)indexes[j],(unsigned long long)values[v],(unsigned long long)flags,(unsigned long long)a,(unsigned long long)b);
+                    return 1;
+                }
+            }
+        }
+    }
+    printf("%zu original Go/LLVM bit tests x 126 independent whole-memory, alias and CF/ZF checks\n",sizeof(pairs)/sizeof(*pairs));
+    return 0;
+}
+
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "bit-test-numerical", pipeline.ir, main, pipeline.level)
+					want := fmt.Sprintf("%d original Go/LLVM bit tests x 126 independent whole-memory, alias and CF/ZF checks\n", count)
+					if string(output) != want {
+						t.Fatalf("missing independent original/LLVM numerical receipt: %s", output)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_bittest_typed_test.go b/amd64_bittest_typed_test.go
new file mode 100644
index 000000000..eda656e7f
--- /dev/null
+++ b/amd64_bittest_typed_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86BitTestOracleNames(arch string) []string {
+	var names []string
+	for _, stem := range []string{"BT", "BTC", "BTR", "BTS"} {
+		for _, suffix := range "WLQ" {
+			if arch != "386" || suffix != 'Q' {
+				names = append(names, stem+string(suffix))
+			}
+		}
+	}
+	return names
+}
+
+func TestX86BitTestDeadReadSurvivesIROptimization(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86BitTestOracleNames(arch) {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·dead(SB),4,$0-%d\n%s p+0(FP),AX\n%s $0,(AX)\nRET\n", word, move, op)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func dead(p *byte)", arch, triple, "text")
+				if err != nil {
+					t.Fatal(err)
+				}
+				optimized := x86MulDivRoundOptimize(t, ir)
+				if !strings.Contains(optimized, "load volatile") {
+					t.Fatalf("Go's required bit-string read/fault was removed by LLVM IR O2:\n%s", optimized)
+				}
+				if strings.HasPrefix(op, "BTC") || strings.HasPrefix(op, "BTR") || strings.HasPrefix(op, "BTS") {
+					if !strings.Contains(optimized, "store volatile") {
+						t.Fatal("native bit-string write is not independently observable")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86BitTest386ImmediateClassification(t *testing.T) {
+	for _, op := range x86BitTestOracleNames("386") {
+		// Go mode32 classifies its int32 value before selecting Yi8. This
+		// witness is legal despite the original source literal exceeding 32 bits.
+		source := "TEXT ·value(SB),4,$0-0\n" + op + " $4294967295,AX\nRET\n"
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		if _, err := x86ScalarFPBitViewAPI(t, source, "func value()", "386", "i386-unknown-linux-gnu", "text"); err != nil {
+			t.Errorf("actual Go signed-Yi8 classification %s: %v", op, err)
+		}
+	}
+}
+
+func TestX86BitTestDynamicFPDoesNotBecomeModulo(t *testing.T) {
+	for _, op := range x86BitTestOracleNames("amd64") {
+		source := "TEXT ·value(SB),4,$0-16\nMOVQ index+8(FP),CX\n" + op + " CX,x+0(FP)\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		_, err := x86ScalarFPBitViewAPI(t, source, "func value(x uint64,index int64)", "amd64", "x86_64-unknown-linux-gnu", "text")
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("dynamic native bit string borrowed fixed FP slot/modulo: %s: %v", op, err)
+		}
+	}
+}
diff --git a/amd64_blend_minpos_forms.go b/amd64_blend_minpos_forms.go
new file mode 100644
index 000000000..2cef580ef
--- /dev/null
+++ b/amd64_blend_minpos_forms.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These two Go tables share a full vector source and a vector output, not
+// their data dependencies. Blends read one sign bit per mask lane and two
+// possible data bytes; minimum-position reads all eight unsigned words.
+// Neither the grammar nor a native address establishes initialized storage.
+type x86BlendMinposForm struct {
+	source, destination, mask, base int
+	byteWidth, laneBits             int
+	legacy, minimum                 bool
+	memory                          bool
+}
+
+func x86BlendMinposProperties(op Op, ins Instr, arch string) (x86BlendMinposForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	blend, isBlend := amd64VariableBlendSpecs[Op(name)]
+	minimum, isMinimum := amd64MinimumPositionSpecs[Op(name)]
+	form := x86BlendMinposForm{source: 0, destination: 1, mask: -1, base: -1,
+		byteWidth: 16, laneBits: 16, minimum: isMinimum}
+	if !isBlend && !isMinimum {
+		return form, false, nil
+	}
+	fail := func() (x86BlendMinposForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go blend/minimum-position operand grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	vector := isBlend && blend.vector || isMinimum && minimum.vector
+	form.legacy = !vector
+	if isBlend {
+		form.source, form.mask, form.base, form.destination = 1, 0, 2, 2
+		form.laneBits = blend.laneBits
+		if vector {
+			form.destination = 3
+		}
+	}
+	if len(ins.Args) != form.destination+1 {
+		return fail()
+	}
+	if arch == "386" && len(ins.Args) > 3 && !ins.x86Encoded {
+		// The ordinary Go frontend cannot express this VEX form in mode32.
+		// Only a validated physical decoder supplies its distinct grammar;
+		// original bytes and all producer inputs still need whole replay.
+		return fail()
+	}
+	form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+	if form.byteWidth != 16 && (form.byteWidth != 32 || form.legacy || form.minimum) {
+		return fail()
+	}
+	register := func(operand Operand) bool {
+		if !vector {
+			index, valid := amd64ParseXReg(operand.Reg)
+			return operand.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+		}
+		return amd64VEXVectorRegister(operand, form.byteWidth)
+	}
+	if !register(ins.Args[form.destination]) ||
+		isBlend && (!register(ins.Args[form.mask]) || !register(ins.Args[form.base]) ||
+			form.legacy && ins.Args[form.mask].Reg != "X0") {
+		return fail()
+	}
+	source := ins.Args[form.source]
+	form.memory = isAMD64MemoryOperand(source)
+	if !register(source) && (!form.memory || !x86PackedShiftMemoryValid(source, arch)) {
+		return fail()
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func x86TypedBlendMinposByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86BlendMinposProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.source, operand: ins.Args[form.source], width: int64(form.byteWidth), read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth), write: true},
+	}}
+	if !form.minimum {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: int64(form.byteWidth), read: true},
+			x86TypedByteOperand{index: form.base, operand: ins.Args[form.base], width: int64(form.byteWidth), read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_blend_minpos_native.go b/amd64_blend_minpos_native.go
new file mode 100644
index 000000000..d3be27dc8
--- /dev/null
+++ b/amd64_blend_minpos_native.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// All four legacy m128 names use Intel Type4, unlike their VEX forms.
+// An unaligned load or align16 metadata cannot retain the original #GP.
+// One sideeffect opcode also retains the read for dead/zero-mask results.
+func (c *amd64Ctx) lowerLegacyBlendMinposMemory(ins Instr, form x86BlendMinposForm) error {
+	source := ins.Args[form.source]
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || source.Kind == OpFP {
+		return fmt.Errorf("%w: legacy blend/minimum m128 needs its original native x86 storage and alignment", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	mnemonic := strings.ToLower(string(ins.Op))
+	result := c.newTmp()
+	if form.minimum {
+		fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s %s)\n",
+			result, mnemonic+" "+segment+"($1), $0", "=x,r,~{memory}", pointerType, pointer)
+	} else {
+		// The original implicit X0 is an independent input even when the
+		// source destination aliases X0. A temporary early-clobber output
+		// prevents LLVM's carrier allocation from overwriting that input.
+		mask, failure := c.loadPackedCompareBytes(ins.Args[form.mask], 16)
+		if failure != nil {
+			return failure
+		}
+		base, failure := c.loadPackedCompareBytes(ins.Args[form.base], 16)
+		if failure != nil {
+			return failure
+		}
+		maskCarrier, baseCarrier := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x float>\n", maskCarrier, mask)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x float>\n", baseCarrier, base)
+		fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(<4 x float> %%%s, %s %s, <4 x float> %%%s)\n",
+			result, mnemonic+" "+segment+"($2), $0", "=&x,0,r,{xmm0},~{memory}", baseCarrier, pointerType, pointer, maskCarrier)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, result)
+	return c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+}
diff --git a/amd64_blend_variable_runtime_test.go b/amd64_blend_variable_runtime_test.go
new file mode 100644
index 000000000..583df9eba
--- /dev/null
+++ b/amd64_blend_variable_runtime_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VariableBlendMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			var source, declarations, checks strings.Builder
+			sigs := map[string]FuncSig{}
+			index := 0
+			for _, family := range x86VariableBlendTestFamilies {
+				for _, width := range []int{0, 16, 32} {
+					for _, memory := range []bool{false, true} {
+						for dst := 0; dst < 4; dst++ {
+							name := fmt.Sprintf("blend%d", index)
+							index++
+							reg, move, op, size := "X", "MOVOU", family.legacy, 16
+							if width > 0 {
+								op, size = family.vector, width
+							}
+							if width == 32 {
+								reg, move = "Y", "VMOVUPS"
+							}
+							fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+							source.WriteString("MOVQ base+0(FP),AX\nMOVQ source+8(FP),BX\nMOVQ mask+16(FP),CX\nMOVQ out+24(FP),DI\n")
+							for r := 0; r < 4; r++ {
+								fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", r)
+							}
+							fmt.Fprintf(&source, "%s (CX),%s0\n%s (BX),%s1\n", move, reg, move, reg)
+							operand := reg + "1"
+							if memory {
+								operand = "(BX)"
+							}
+							line := fmt.Sprintf("%s %s0,%s,%s%d", op, reg, operand, reg, dst)
+							if width > 0 {
+								line = fmt.Sprintf("%s %s0,%s,%s2,%s%d", op, reg, operand, reg, reg, dst)
+							}
+							emitX86GoEncodedTestInstruction(t, &source, line, raw)
+							fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\nRET\n", dst, dst, dst)
+							sigs[name] = FuncSig{
+								Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+								Frame: FrameLayout{Params: []FrameSlot{
+									{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+									{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+									{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+									{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+								}},
+							}
+							fmt.Fprintf(&declarations, "extern void %s(const void*, const void*, const void*, void*);\n", name)
+							fmt.Fprintf(&checks, "    if (check(%s, %d, %d, %d, %d)) {\n", name, size, family.bits/8, width, dst)
+							fmt.Fprintf(&checks, "        fprintf(stderr, \"%s failed\\n\");\n        return 1;\n    }\n", name)
+						}
+					}
+				}
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			// The unchanged C intentionally asks for unaligned numerical
+			// values. Execute its explicit private mathematical companion,
+			// not the original legacy memory opcode's different #GP contract.
+			file = x86BlendMinposPrivateMathCompanion(t, source.String(), 72, 12, 96)
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err = x86BlendMinposMathIR(file, ir)
+			if err != nil {
+				t.Fatal("private mathematical companion lost exact source/IR ownership", err)
+			}
+			body := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+				x86TestGuardPagesC + declarations.String() + x86VariableBlendOracleC +
+				"\nint main(void) {\n    if (setup_guard()) return 2;\n" +
+				checks.String() + "    return free_guard();\n}\n"
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "variable-blend-private-math", triple, ir, body)
+		})
+	}
+}
+
+const x86VariableBlendOracleC = `
+static int check(void (*fn)(const void*, const void*, const void*, void*),
+                 int size, int lane, int vex, int dst) {
+    for (int n = 0; n < 256; n++) {
+        uint8_t old[65], storage[33], masks[33], out[112], want[112] = {0};
+        uint8_t *input = storage + 1, *mask = masks + 1;
+        for (int i = 0; i < 65; i++) old[i] = (uint8_t)(i * 3 + n);
+        for (int i = 0; i < size; i++) {
+            input[i] = (uint8_t)(i * 7 + n + 83);
+            mask[i] = (uint8_t)(n + i * 31);
+        }
+        const uint8_t *base = old + 1;
+        if (!vex && dst == 0) base = mask;
+        if (!vex && dst == 1) base = input;
+        for (int i = 0; i < size; i += lane) {
+            int enabled = mask[i + lane - 1] >> 7;
+            memcpy(want + i, (enabled ? input : base) + i, (size_t)lane);
+        }
+        if (!vex) memcpy(want + 16, old + 1 + 16, 48);
+        memcpy(want + 64, want, 32);
+        memcpy(want + 96, want, 16);
+
+        for (int edge = 0; edge < 2; edge++) {
+            const uint8_t *source = input;
+            if (edge) {
+                source = guard + page - size;
+                memcpy(guard + page - size, input, (size_t)size);
+            }
+            memset(out, 0xa5, sizeof(out));
+            fn(old + 1, source, mask, out);
+            if (memcmp(out, want, sizeof(out))) {
+                fprintf(stderr, "size=%d lane=%d vex=%d dst=%d n=%d edge=%d\n",
+                        size, lane, vex, dst, n, edge);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_blocks.go b/amd64_blocks.go
index 19e9cba47..5d051cb05 100644
--- a/amd64_blocks.go
+++ b/amd64_blocks.go
@@ -6,38 +6,91 @@ import (
 )
 
 type amd64Block struct {
-	name   string
-	instrs []Instr
+	name      string
+	instrs    []Instr
+	synthetic bool
+}
+
+func isAMD64ConditionalBranch(op Op) bool {
+	op = Op(strings.ToUpper(string(op)))
+	if _, known := x86CounterControlPropertiesForOpcode(op); known {
+		return true
+	}
+	return x86BranchCondition(op) != ""
+}
+
+// Branch lowering, byte dependencies and closed-loop predicates share the
+// complete condition-alias family. Counter-zero branches have a different role.
+func x86BranchCondition(op Op) string {
+	switch op {
+	case "JE", "JEQ", "JZ":
+		return "EQ"
+	case "JNE", "JNZ":
+		return "NE"
+	case "JL", "JLT", "JNGE":
+		return "LT"
+	case "JGE", "JNL":
+		return "GE"
+	case "JS", "JMI":
+		return "MI"
+	case "JNS", "JPL":
+		return "PL"
+	case "JLE", "JNG":
+		return "LE"
+	case "JG", "JGT", "JNLE":
+		return "GT"
+	case "JB", "JLO", "JC", "JCS", "JNAE":
+		return "CS"
+	case "JNC", "JCC", "JAE", "JHS", "JNB":
+		return "CC"
+	case "JBE", "JLS", "JNA":
+		return "LS"
+	case "JA", "JHI", "JNBE":
+		return "HI"
+	case "JO", "JOS":
+		return "OS"
+	case "JNO", "JOC":
+		return "OC"
+	case "JP", "JPE", "JPS":
+		return "PS"
+	case "JNP", "JPO", "JPC":
+		return "PC"
+	}
+	return ""
+}
+
+func isAMD64CounterZeroBranch(op Op) bool {
+	spec, known := x86CounterControlPropertiesForOpcode(op)
+	return known && !spec.decrement
 }
 
 func amd64SplitBlocks(fn Func) []amd64Block {
-	blocks := []amd64Block{{name: "entry"}}
+	names := newAssemblyBlockNames(fn)
+	blocks := []amd64Block{{name: names.fresh("entry"), synthetic: true}}
 	cur := 0
 	anon := 0
 
 	isPCRelTarget := func(ins Instr) (off int64, ok bool) {
 		op := strings.ToUpper(string(ins.Op))
-		switch Op(op) {
-		case "JMP",
-			"JE", "JEQ", "JZ", "JNE", "JNZ",
-			"JL", "JLT", "JLE", "JG", "JGT", "JGE", "JS", "JNS",
-			"JB", "JLO", "JBE", "JA", "JHI", "JAE", "JHS", "JLS", "JNA",
-			"JNC", "JC", "JCC":
-		default:
+		if op != "JMP" && op != "LOOP" && op != "XBEGIN" && !isAMD64ConditionalBranch(Op(op)) {
 			return 0, false
 		}
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpMem {
+		args := ins.Args
+		if op != "JMP" && len(args) == 2 && args[0].Kind == OpImm {
+			args = args[1:]
+		}
+		if len(args) != 1 || args[0].Kind != OpMem {
 			return 0, false
 		}
-		if !strings.EqualFold(string(ins.Args[0].Mem.Base), "PC") {
+		if !strings.EqualFold(string(args[0].Mem.Base), "PC") {
 			return 0, false
 		}
-		return ins.Args[0].Mem.Off, true
+		return args[0].Mem.Off, true
 	}
 
 	startAnon := func() {
 		anon++
-		blocks = append(blocks, amd64Block{name: fmt.Sprintf("anon_%d", anon)})
+		blocks = append(blocks, amd64Block{name: names.fresh(fmt.Sprintf("anon_%d", anon)), synthetic: true})
 		cur = len(blocks) - 1
 	}
 
@@ -46,16 +99,16 @@ func amd64SplitBlocks(fn Func) []amd64Block {
 			return true
 		}
 		op := strings.ToUpper(string(ins.Op))
-		switch Op(op) {
-		case "JMP",
-			"JE", "JEQ", "JZ", "JNE", "JNZ",
-			"JL", "JLT", "JLE", "JG", "JGT", "JGE", "JS", "JNS",
-			"JB", "JLO", "JBE", "JA", "JHI", "JAE", "JHS", "JLS", "JNA",
-			"JNC", "JC", "JCC":
+		if _, ok := amd64FarReturnSpecs[Op(op)]; ok {
+			return true
+		}
+		if spec, ok := amd64SystemTransferSpecs[Op(op)]; ok && spec.terminates() {
+			return true
+		}
+		if op == "JMP" || op == "LOOP" || op == "XBEGIN" || isAMD64ConditionalBranch(Op(op)) {
 			return true
-		default:
-			return false
 		}
+		return false
 	}
 
 	linear := make([]Instr, 0, len(fn.Instrs))
@@ -79,8 +132,9 @@ func amd64SplitBlocks(fn Func) []amd64Block {
 	for _, ins := range fn.Instrs {
 		if ins.Op == OpLABEL && len(ins.Args) == 1 && ins.Args[0].Kind == OpLabel {
 			lbl := ins.Args[0].Sym
-			if len(blocks[cur].instrs) == 0 && strings.HasPrefix(blocks[cur].name, "anon_") {
+			if cur != 0 && len(blocks[cur].instrs) == 0 && blocks[cur].synthetic {
 				blocks[cur].name = lbl
+				blocks[cur].synthetic = false
 				continue
 			}
 			blocks = append(blocks, amd64Block{name: lbl})
@@ -97,15 +151,22 @@ func amd64SplitBlocks(fn Func) []amd64Block {
 		}
 	}
 
-	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && strings.HasPrefix(blocks[len(blocks)-1].name, "anon_") {
+	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && blocks[len(blocks)-1].synthetic {
 		blocks = blocks[:len(blocks)-1]
 	}
 	return blocks
 }
 
 func amd64LLVMBlockName(src string) string {
+	return "bb_" + amd64LLVMSafeName(src)
+}
+
+// Keep block names in a namespace distinct from SSA temporaries and register
+// allocas. Go permits local labels such as x1 and t1, which otherwise collide
+// with the translator's %x1 and %t1 values in LLVM IR.
+func amd64LLVMSafeName(src string) string {
 	if src == "" {
-		return "bb"
+		return "empty"
 	}
 	var out []byte
 	for i := 0; i < len(src); i++ {
@@ -115,16 +176,15 @@ func amd64LLVMBlockName(src string) string {
 			continue
 		}
 		out = append(out, '_')
+		out = append(out, "0123456789abcdef"[ch>>4])
+		out = append(out, "0123456789abcdef"[ch&0xf])
 	}
 	s := string(out)
 	if s == "" {
-		return "bb"
+		return "empty"
 	}
 	if s[0] >= '0' && s[0] <= '9' {
-		s = "bb_" + s
-	}
-	if s == "entry" {
-		s = "bb_entry"
+		s = "n_" + s
 	}
 	return s
 }
diff --git a/amd64_bls_forms.go b/amd64_bls_forms.go
new file mode 100644
index 000000000..f29c012ce
--- /dev/null
+++ b/amd64_bls_forms.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86BLSKind uint8
+
+const (
+	x86BLSIsolate x86BLSKind = iota
+	x86BLSMask
+	x86BLSReset
+)
+
+type x86BLSSpec struct {
+	bits  int
+	kind  x86BLSKind
+	digit byte
+}
+
+var x86BLSSpecs = map[Op]x86BLSSpec{
+	"BLSIL":   {32, x86BLSIsolate, 3},
+	"BLSIQ":   {64, x86BLSIsolate, 3},
+	"BLSMSKL": {32, x86BLSMask, 2},
+	"BLSMSKQ": {64, x86BLSMask, 2},
+	"BLSRL":   {32, x86BLSReset, 1},
+	"BLSRQ":   {64, x86BLSReset, 1},
+}
+
+type x86BLSForm struct {
+	spec                x86BLSSpec
+	source, destination Operand
+}
+
+// The complete Go Yml,Yrl family uses VEX.LZ/0F38/F3. W is ignored in
+// mode32; retain the original Q spelling, but consume its physical width.
+func x86BLSProperties(op Op, ins Instr, arch string) (x86BLSForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86BLSSpecs[Op(name)]
+	form := x86BLSForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86BLSForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go BLS grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	if arch == "386" {
+		form.spec.bits = 32
+	}
+	form.source, form.destination = ins.Args[0], ins.Args[1]
+	if form.source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.source.Reg, arch) {
+			return fail()
+		}
+	} else if !isAMD64MemoryOperand(form.source) || !x86PackedShiftMemoryValid(form.source, arch) ||
+		x86NamedMultiplyMemoryError(form.source, arch) != nil {
+		return fail()
+	}
+	if form.destination.Kind != OpReg || !isX86YrlRegisterForArch(form.destination.Reg, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86TypedBLSByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86BLSProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.spec.bits / 8)
+	return x86TypedByteEffect{
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: form.source, width: width, read: true},
+			{index: 1, operand: form.destination, width: width, write: true},
+		},
+		flagsDefined:        x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF,
+		flagsKilled:         x86ByteFlagsAll,
+		requiresResultProof: true,
+	}, true, nil
+}
+
+// Only the paired exact-width volatile emitter consumes this continuation.
+// This creates no pointee, caller, frame or raw-entry capability.
+func x86LoweredBLSNativeRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86BLSProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if form.source.Kind != OpMem || form.source.Mem.Sym != "" {
+		return false, false
+	}
+	width := int64(form.spec.bits / 8)
+	if !x86ResultReadWithNativeContinuation(ins, form.source, width, state, owned, arch, true) ||
+		!x86ResultStore(form.destination, width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	effect, _, _ := x86TypedBLSByteEffect(ins.Op, ins, arch)
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
+
+func (c *amd64Ctx) evalBLSSource(ins Instr, form x86BLSForm, typ LLVMType) (string, error) {
+	if form.source.Kind == OpFP && x86ResultNamedPredicateInstruction(ins) {
+		if value, handled, err := c.loadIntegerFPBytesMode(form.source.FPOffset, typ, true); handled || err != nil {
+			return value, err
+		}
+	}
+	if isAMD64MemoryOperand(form.source) && form.source.Kind != OpFP &&
+		(c.nativeMemoryOperand(ins, 0) ||
+			x86CallerMemoryCertified(ins, 0) || c.fixedLocalMemoryCertified(ins, 0)) {
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return "", fmt.Errorf("%w: BLS needs its original native address size", ErrProbeNeedsContext)
+		}
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+		return "%" + value, nil
+	}
+	return c.evalIntSized(form.source, typ)
+}
diff --git a/amd64_bmi2_shift_386_contract_test.go b/amd64_bmi2_shift_386_contract_test.go
new file mode 100644
index 000000000..b74865610
--- /dev/null
+++ b/amd64_bmi2_shift_386_contract_test.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86BMI2Shift386Program struct {
+	name, source, declaration, destination string
+}
+
+func x86BMI2Shift386Programs(t *testing.T, source, secondDestination string) []x86BMI2Shift386Program {
+	t.Helper()
+	parts := strings.Split(source, "TEXT ")
+	if len(parts) != 25 || parts[0] != "" {
+		t.Fatal("complete historical 24-TEXT inventory changed")
+	}
+	var programs []x86BMI2Shift386Program
+	for index, part := range parts[1:] {
+		name := fmt.Sprintf("shift386_%d", index)
+		if !strings.HasPrefix(part, name+"(SB),4,$0-12\n") {
+			t.Fatal("original TEXT order, frame or result extent changed", index)
+		}
+		destination := "CX"
+		if index%2 != 0 {
+			destination = secondDestination
+		}
+		programs = append(programs, x86BMI2Shift386Program{
+			name: name, source: "TEXT " + part, destination: destination,
+			declaration: fmt.Sprintf("func %s(count uint32,source *uint32) uint32\n", name),
+		})
+	}
+	return programs
+}
+
+// These complete bytes are independent of the translator and raw decoder.
+// In mode32 the Q spellings retain Go's W1 bytes, but hardware ignores W.
+// The final 89 /r SIB 24 0c store is physically relative to the current ESP,
+// even though the original source names the ABI0 result ret+8(FP).
+func x86BMI2Shift386ExpectedCode(t *testing.T, index int, destination string) []byte {
+	t.Helper()
+	third := []byte{0x7a, 0xfa, 0x79, 0xf9, 0x7b, 0xfb}[index/4]
+	register := map[string]byte{"CX": 1, "SP": 4, "DX": 2}[destination]
+	if register == 0 {
+		t.Fatal("unknown independent destination", destination)
+	}
+	code := []byte{0x8b, 0x44, 0x24, 4, 0x8b, 0x5c, 0x24, 8}
+	code = append(code, 0xc4, 0xe2, third, 0xf7, register<<3|3)
+	return append(code, 0x89, 0x44|register<<3, 0x24, 12, 0xc3)
+}
+
+func x86BMI2Shift386OriginalGoPrior(t *testing.T, source, secondDestination string) []x86BMI2Shift386Program {
+	t.Helper()
+	programs := x86BMI2Shift386Programs(t, source, secondDestination)
+	listing := x86InsertExtractGoListing(t, "386", source)
+	codes, instructions := map[string][]byte{}, map[string][]string{}
+	owner := ""
+	for _, line := range strings.Split(string(listing), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[1] == "STEXT" {
+			owner = fields[0]
+			if dot := strings.LastIndex(owner, "."); dot >= 0 {
+				owner = owner[dot+1:]
+			}
+			if _, duplicate := codes[owner]; duplicate {
+				t.Fatal("duplicate original Go TEXT owner", owner)
+			}
+			codes[owner] = nil
+		}
+		if chunk := x86InsertExtractListedBytes(line); len(chunk) != 0 {
+			pc, err := strconv.ParseInt(fields[0], 0, 64)
+			if owner == "" || err != nil || pc != int64(len(codes[owner])) {
+				t.Fatal("unbound or noncontiguous original Go bytes", line, err)
+			}
+			codes[owner] = append(codes[owner], chunk...)
+		}
+		if row := goAMD64FrameRow.FindStringSubmatch(line); row != nil && !strings.HasPrefix(row[3], "TEXT") {
+			instructions[owner] = append(instructions[owner], strings.Join(strings.Fields(row[3]), ""))
+		}
+	}
+	if len(codes) != 24 {
+		t.Fatal("original Go object lost a complete TEXT", len(codes))
+	}
+	for index, program := range programs {
+		if !bytes.Equal(codes[program.name], x86BMI2Shift386ExpectedCode(t, index, program.destination)) {
+			t.Fatalf("complete original Go bytes differ for %s (%s): %x", program.name, program.destination, codes[program.name])
+		}
+		rows := instructions[program.name]
+		if len(rows) < 4 || rows[len(rows)-1] != "RET" {
+			t.Fatal("original Go listing lost its real return", program.name, rows)
+		}
+		if index%4 < 2 && !strings.HasSuffix(rows[len(rows)-3], ","+program.destination) {
+			t.Fatal("original named instruction no longer writes its physical destination", program.name, rows)
+		}
+	}
+	t.Logf("actual complete original Go object: sourceSHA=%x, 24 functions; physical destination write, ESP+12 result store and RET bytes retained; no original program execution", sha256.Sum256([]byte(source)))
+	return programs
+}
+
+func TestX86BMI2Shift386OriginalGoPhysicalSPAndReturnContract(t *testing.T) {
+	source, _, _, _ := x86BMI2Shift386Fixture(t, "SP")
+	programs := x86BMI2Shift386OriginalGoPrior(t, source, "SP")
+	stack, ordinary := 0, 0
+	for _, program := range programs {
+		if program.destination == "SP" {
+			stack++
+		} else {
+			ordinary++
+		}
+	}
+	if stack != 12 || ordinary != 12 {
+		t.Fatal("original SP and CX coverage changed", stack, ordinary)
+	}
+	// The first original C sample is value=0/count=0. Every shift writes ESP=0;
+	// the next actual store targets address 12 and RET cannot recover the old PC.
+	// This is a source/object witness, not a claim that the invalid ABI ran.
+	if x86LogicalSourceFrameRegister(SP, "386") != true {
+		t.Fatal("physical SP became an ordinary numerical source register")
+	}
+}
+
+func TestX86BMI2Shift386OriginalSPStaysContextAndCXWorks(t *testing.T) {
+	source, _, _, _ := x86BMI2Shift386Fixture(t, "SP")
+	programs := x86BMI2Shift386OriginalGoPrior(t, source, "SP")
+	var declarations strings.Builder
+	for _, program := range programs {
+		declarations.WriteString(program.declaration)
+	}
+	for _, target := range x86RawReturnTargets[:2] {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "386", target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("whole original source acquired an unproved physical stack return", err)
+					}
+					for _, program := range programs {
+						t.Run(program.name, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, program.source, program.declaration, "386", target.triple, api)
+							if program.destination == "SP" {
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("SP result replaced the physical ABI0 continuation with a virtual GP", err)
+								}
+							} else if err != nil || ir == "" {
+								t.Fatal("same complete initialized CX program must remain supported", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BMI2Shift386SafeGPCompanionCompleteObjects(t *testing.T) {
+	source, signatures, cDeclarations, checks := x86BMI2Shift386Fixture(t, "DX")
+	programs := x86BMI2Shift386OriginalGoPrior(t, source, "DX")
+	_, originalSignatures, originalCDeclarations, originalChecks := x86BMI2Shift386Fixture(t, "SP")
+	if !reflect.DeepEqual(signatures, originalSignatures) || cDeclarations != originalCDeclarations || checks != originalChecks || strings.Count(checks, "if (check(") != 24 {
+		t.Fatal("safe GP companion changed original signatures, C calls or 24-kernel denominator")
+	}
+	var declarations strings.Builder
+	for _, program := range programs {
+		declarations.WriteString(program.declaration)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets[:2] {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "386", target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("explicit initialized GP companion did not close", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, "-O0")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BMI2Shift386RequiredDriverChoosesSafeGPCompanion(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_bmi2_shift_cross_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixtures, driver, literals := 0, "", []string{}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestCrossLinuxRuntimeMatrixBMI2Shift386" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				if name, ok := call.Fun.(*ast.Ident); ok && name.Name == "x86BMI2Shift386Fixture" && len(call.Args) == 2 {
+					fixtures++
+					if literal, ok := call.Args[1].(*ast.BasicLit); ok && literal.Kind == token.STRING {
+						driver, err = strconv.Unquote(literal.Value)
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+				}
+			}
+			if assignment, ok := node.(*ast.AssignStmt); ok && len(assignment.Lhs) == 1 && len(assignment.Rhs) == 1 {
+				if name, ok := assignment.Lhs[0].(*ast.Ident); ok && name.Name == "mainC" {
+					ast.Inspect(assignment.Rhs[0], func(node ast.Node) bool {
+						if literal, ok := node.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+							value, err := strconv.Unquote(literal.Value)
+							if err != nil {
+								t.Fatal(err)
+							}
+							literals = append(literals, value)
+						}
+						return true
+					})
+				}
+			}
+			return true
+		})
+	}
+	if len(literals) != 3 || fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(literals, "\x00")))) != "40eda8daa32e89f9f9c077d2cf2ef23e41331377a7fc44f5992c46e9e9228718" {
+		t.Fatal("original complete C source, 256 samples or page-end/fault oracle changed")
+	}
+	if fixtures != 1 || driver != "DX" {
+		t.Fatalf("required runtime must explicitly execute the safe CX/DX companion, not the original physical-SP source: fixtures=%d role=%q", fixtures, driver)
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "TestCrossLinuxRuntimeMatrix") {
+		t.Fatal("safe companion lost the required complete cross-runtime owner", err)
+	}
+}
diff --git a/amd64_bmi2_shift_386_fixture_test.go b/amd64_bmi2_shift_386_fixture_test.go
new file mode 100644
index 000000000..da051b4c6
--- /dev/null
+++ b/amd64_bmi2_shift_386_fixture_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// SP preserves the complete historical source. DX is an explicitly separate
+// executable GP companion: it does not certify the original physical-SP rows.
+func x86BMI2Shift386Fixture(t *testing.T, secondDestination string) (string, map[string]FuncSig, string, string) {
+	t.Helper()
+	if secondDestination != "SP" && secondDestination != "DX" {
+		t.Fatal("unknown BMI2 386 fixture role", secondDestination)
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, op := range x86BMI2ShiftTestOps {
+		kind := 0
+		if strings.HasPrefix(op, "SHRX") {
+			kind = 1
+		} else if strings.HasPrefix(op, "SARX") {
+			kind = 2
+		}
+
+		for _, raw := range []bool{false, true} {
+			for _, destination := range []string{"CX", secondDestination} {
+				name := fmt.Sprintf("shift386_%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-12\n", name)
+				source.WriteString("MOVL count+0(FP),AX\nMOVL source+4(FP),BX\n")
+				line := fmt.Sprintf("%s AX,(BX),%s\n", op, destination)
+				if raw {
+					code := assembleX87ControlBytes(t, "386", "TEXT probe(SB),4,$0-0\n"+line+"RET\n")
+					for _, b := range code[:len(code)-1] {
+						fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+					}
+				} else {
+					source.WriteString(line)
+				}
+				fmt.Fprintf(&source, "MOVL %s,ret+8(FP)\nRET\n", destination)
+
+				sigs[name] = FuncSig{
+					Name: name,
+					Args: []LLVMType{I32, Ptr},
+					Ret:  I32,
+					Frame: FrameLayout{
+						Params: []FrameSlot{
+							{Offset: 0, Type: I32, Index: 0, Field: -1},
+							{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+						},
+						Results: []FrameSlot{
+							{Offset: 8, Type: I32, Index: 0, Field: -1},
+						},
+					},
+				}
+				fmt.Fprintf(&declarations, "extern uint32_t %s(uint32_t, const uint32_t*);\n", name)
+				fmt.Fprintf(&checks, "    if (check(%s, value, %d)) return %d;\n", name, kind, index)
+			}
+		}
+	}
+	if index != 24 {
+		t.Fatalf("generated %d functions, want 24", index)
+	}
+	return source.String(), sigs, declarations.String(), checks.String()
+}
diff --git a/amd64_bmi2_shift_cross_test.go b/amd64_bmi2_shift_cross_test.go
new file mode 100644
index 000000000..84b4f6f7a
--- /dev/null
+++ b/amd64_bmi2_shift_cross_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"runtime"
+	"testing"
+)
+
+// Keep this in the required CI cross-runtime regex, not an optional native test.
+func TestCrossLinuxRuntimeMatrixBMI2Shift386(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"i686-linux-gnu-gcc", "qemu-i386"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+
+	// Execute the explicitly separate CX/DX companion. The historical CX/SP
+	// source remains covered by complete Go objects and public Context tests;
+	// its unrecovered physical ESP write is not a valid ABI0 return program.
+	source, sigs, declarations, checks := x86BMI2Shift386Fixture(t, "DX")
+
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+` + declarations + x86BMI2ShiftOracleC + `
+static void memory_fault(int signal_number) {
+    (void)signal_number;
+    _exit(98);
+}
+
+static int check(uint32_t (*fn)(uint32_t, const uint32_t*), uint32_t *value, int kind) {
+    uint32_t values[] = {0, 1, UINT32_MAX, 0x80000000U, 0x7fffffffU, 0xfedcba98U};
+    for (unsigned n = 0; n < 256; n++) {
+        *value = values[n % 6];
+        uint32_t count = n < 128 ? n : UINT32_MAX - n;
+        if (fn(count, value) != shift_reference(*value, count, 32, kind)) {
+            fprintf(stderr, "386 kind=%d case=%u\n", kind, n);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int main(void) {
+    if (signal(SIGSEGV, memory_fault) == SIG_ERR) return 92;
+    long page = sysconf(_SC_PAGESIZE);
+    if (page < 4) return 90;
+
+    uint8_t *memory = mmap(NULL, page * 2, PROT_READ | PROT_WRITE,
+                           MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (memory == MAP_FAILED || mprotect(memory + page, page, PROT_NONE)) return 91;
+    uint32_t *value = (uint32_t *)(memory + page - 4);
+` + checks + "    return munmap(memory, page * 2) != 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc"}, "bmi2_shift_386",
+		"i386-unknown-linux-gnu", ir, mainC, []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+}
diff --git a/amd64_bmi2_shift_runtime_test.go b/amd64_bmi2_shift_runtime_test.go
new file mode 100644
index 000000000..7be9d70c1
--- /dev/null
+++ b/amd64_bmi2_shift_runtime_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BMI2ShiftRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("execution requires amd64 or Rosetta; five-target objects remain required")
+	}
+
+	source, sigs, declarations, checks := x86BMI2ShiftRuntimeFixture(t)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := x86BMI2ShiftRuntimeDriver(declarations, checks)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bmi2_shift", triple, ir, mainC, prefix)
+}
+
+func x86BMI2ShiftRuntimeFixture(t *testing.T) (string, map[string]FuncSig, string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, op := range x86BMI2ShiftTestOps {
+		bits, kind := 32, 0
+		if strings.HasSuffix(op, "Q") {
+			bits = 64
+		}
+		if strings.HasPrefix(op, "SHRX") {
+			kind = 1
+		} else if strings.HasPrefix(op, "SARX") {
+			kind = 2
+		}
+
+		for _, raw := range []bool{false, true} {
+			for _, memory := range []bool{false, true} {
+				for _, destination := range []string{"CX", "AX", "DX"} {
+					name := fmt.Sprintf("bmi2shift%d", index)
+					index++
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", name)
+					source.WriteString("MOVQ count+0(FP),AX\nMOVQ source+8(FP),BX\nMOVQ out+16(FP),DI\n")
+					source.WriteString("MOVQ (BX),DX\nMOVQ $-1,CX\nCMPQ AX,AX\nSTC\n")
+					input := "DX"
+					if memory {
+						input = "(BX)"
+					}
+					line := fmt.Sprintf("%s AX,%s,%s", op, input, destination)
+					emitX86GoEncodedTestInstruction(t, &source, line, raw)
+					fmt.Fprintf(&source, "MOVQ %s,(DI)\n", destination)
+					source.WriteString("SETCS 8(DI)\nSETEQ 9(DI)\nSETPS 10(DI)\nSETMI 11(DI)\nSETOS 12(DI)\nRET\n")
+
+					sigs[name] = FuncSig{
+						Name: name,
+						Args: []LLVMType{I64, Ptr, Ptr},
+						Ret:  Void,
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: I64, Index: 0, Field: -1},
+							{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+						}},
+					}
+					fmt.Fprintf(&declarations, "extern void %s(uint64_t, const void*, void*);\n", name)
+					fmt.Fprintf(&checks, "    if (check(%s, %d, %d)) return %d;\n", name, bits, kind, index)
+				}
+			}
+		}
+	}
+	if index != 72 {
+		t.Fatalf("generated %d functions, want 72", index)
+	}
+
+	return source.String(), sigs, declarations.String(), checks.String()
+}
+
+func x86BMI2ShiftRuntimeDriver(declarations, checks string) string {
+	return "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		declarations + x86BMI2ShiftOracleC + `
+static int check(void (*fn)(uint64_t, const void*, void*), int bits, int kind) {
+    uint64_t values[] = {0, 1, UINT64_MAX, UINT64_C(0x8000000080000000),
+                         UINT64_C(0x7fffffff7fffffff), UINT64_C(0xfedcba9876543210)};
+    for (unsigned n = 0; n < 256; n++) {
+        uint8_t input[9], out[13] = {0};
+        uint64_t value = values[n % 6];
+        uint64_t count = n < 128 ? n : UINT64_MAX - n;
+        memcpy(input + 1, &value, sizeof(value));
+
+        fn(count, input + 1, out);
+        uint64_t got;
+        memcpy(&got, out, sizeof(got));
+        if (got != shift_reference(value, count, bits, kind) ||
+            out[8] != 1 || out[9] != 1 || out[10] != 1 || out[11] || out[12]) {
+            fprintf(stderr, "bits=%d kind=%d case=%u\n", bits, kind, n);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+int main(void) {
+` + checks + "    return 0;\n}\n"
+}
+
+const x86BMI2ShiftOracleC = `
+static uint64_t shift_reference(uint64_t value, uint64_t count, int bits, int kind) {
+    uint64_t mask = bits == 64 ? UINT64_MAX : UINT32_MAX;
+    unsigned shift = (unsigned)count & (bits - 1);
+    value &= mask;
+    if (kind == 0) {
+        return (value << shift) & mask;
+    }
+
+    uint64_t result = value >> shift;
+    if (kind == 2 && shift && (value & (UINT64_C(1) << (bits - 1)))) {
+        result |= mask ^ (mask >> shift);
+    }
+    return result;
+}
+`
diff --git a/amd64_broadcast_go_frame_test.go b/amd64_broadcast_go_frame_test.go
new file mode 100644
index 000000000..2f1035980
--- /dev/null
+++ b/amd64_broadcast_go_frame_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86PackedBroadcastGoFrameScalarWidths(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		pointerBytes, movePointer := 8, "MOVQ"
+		triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			pointerBytes, movePointer = 4, "MOVL"
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, form := range []struct {
+			op    string
+			bytes int
+		}{
+			{"VPBROADCASTB", 1}, {"VPBROADCASTW", 2},
+			{"VPBROADCASTD", 4}, {"VPBROADCASTQ", 8},
+		} {
+			t.Run(arch+"/"+form.op, func(t *testing.T) {
+				outOffset := (form.bytes + pointerBytes - 1) &^ (pointerBytes - 1)
+				var source, declarations strings.Builder
+				declarations.WriteString("package broadcast\n")
+				for _, width := range []string{"X", "Y", "Z"} {
+					for index, masking := range []struct{ suffix, mask string }{
+						{}, {mask: "K1,"}, {suffix: ".Z", mask: "K7,"},
+					} {
+						name := fmt.Sprintf("Broadcast%s%d", width, index)
+						fmt.Fprintf(&declarations, "func %s(x uint%d, out *[64]byte)\n", name, form.bytes*8)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", name, outOffset+pointerBytes)
+						if masking.mask != "" {
+							fmt.Fprintf(&source, "%s $1,AX\nKMOVQ AX,%s\n", movePointer, strings.TrimSuffix(masking.mask, ","))
+							if masking.suffix == "" {
+								clear := map[string]string{"X": "PXOR X0,X0", "Y": "VPXOR Y0,Y0,Y0", "Z": "VPXORD Z0,Z0,Z0"}[width]
+								fmt.Fprintln(&source, clear)
+							}
+						}
+						fmt.Fprintf(&source, "%s%s x+0(FP),%s%s0\n", form.op, masking.suffix, masking.mask, width)
+						fmt.Fprintf(&source, "%s out+%d(FP),AX\n", movePointer, outOffset)
+						store := map[string]string{"X": "MOVOU", "Y": "VMOVDQU", "Z": "VMOVDQU64"}[width]
+						fmt.Fprintf(&source, "%s %s0,(AX)\nRET\n", store, width)
+					}
+				}
+				requireX86GoAssemblerResult(t, arch, source.String(), true)
+				sourceText := source.String()
+				if arch == "386" {
+					// KMOVQ's W bit is ignored for a GP transfer in mode32.
+					// Keep KMOVD as a reference and compile the original below.
+					sourceText = strings.ReplaceAll(sourceText, "KMOVQ AX,", "KMOVD AX,")
+					requireX86GoAssemblerResult(t, arch, sourceText, true)
+				}
+				file, err := Parse(ArchAMD64, sourceText)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := mustGoPackage(t, "example.com/broadcast", declarations.String())
+				resolve := testResolveSym(pkg.Path)
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range triples {
+					t.Run(triple, func(t *testing.T) {
+						if arch == "386" {
+							original, err := Parse(ArchAMD64, source.String())
+							if err != nil {
+								t.Fatal(err)
+							}
+							originalSigs, err := goSigsForAsmFile(pkg, original, resolve, arch, nil, nil, nil)
+							if err != nil {
+								t.Fatal(err)
+							}
+							ir, err := Translate(original, Options{
+								Goarch: arch, TargetTriple: triple, Sigs: originalSigs, ResolveSym: resolve,
+							})
+							if err != nil || ir == "" {
+								t.Fatal("original mode32 KMOVQ must consume GP32 and zero-extend the mask", err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, ir, level)
+							}
+						}
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						module, err := TranslateModuleInContext(ctx, file, Options{
+							Goarch: arch, TargetTriple: triple, Sigs: sigs, ResolveSym: resolve,
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						defer module.Dispose()
+						if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, triple, "broadcast-frame.ll", "broadcast-frame.o", module.String())
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_broadcast_views_test.go b/amd64_broadcast_views_test.go
new file mode 100644
index 000000000..7880db6c1
--- /dev/null
+++ b/amd64_broadcast_views_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent axes from Go 1.27 _yvpbroadcastb: B/W/D/Q, X/Y/Z,
+// memory/X/GP source, unmasked/merge/zero. Observe every overlapping view,
+// including upper bits, and suppress masked-off scalar memory faults.
+func integerBroadcastViews(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, spec := range []struct {
+		op   string
+		bits int
+	}{
+		{"VPBROADCASTB", 8}, {"VPBROADCASTW", 16}, {"VPBROADCASTD", 32}, {"VPBROADCASTQ", 64},
+	} {
+		for width, dst := range []string{"X0", "Y0", "Z0"} {
+			for input := 0; input < 3; input++ {
+				for mask := 0; mask < 3; mask++ {
+					name := fmt.Sprintf("integer_broadcast_%d", index)
+					index++
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ old+0(FP),BX\nMOVQ src+8(FP),AX\nMOVQ out+16(FP),DI\nMOVQ mask+24(FP),CX\nKMOVQ CX,K7\nVMOVUPS (BX),Z0\n", name)
+					operand := "(AX)"
+					if input == 1 {
+						source.WriteString("VMOVUPS (AX),X1\n")
+						operand = "X1"
+					} else if input == 2 {
+						source.WriteString("MOVQ (AX),R8\n")
+						operand = "R8"
+					}
+					op, predicate := spec.op, ""
+					if mask != 0 {
+						predicate = "K7,"
+					}
+					if mask == 2 {
+						op += ".Z"
+					}
+					fmt.Fprintf(&source, "%s %s,%s%s\nVMOVUPS Z0,(DI)\nVMOVUPS Y0,64(DI)\nVMOVUPS X0,96(DI)\nRET\n", op, operand, predicate, dst)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+						}},
+					}
+					fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *,uint64_t);\n", name)
+					fmt.Fprintf(&checks, "if (check(%s,%d,%d,%d,%d)) return 1;\n", name, 16<<width, spec.bits/8, mask, input)
+				}
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+` + declarations.String() + `
+static int check(void (*fn)(const void *,const void *,void *,uint64_t),int width,int lane,int form,int input) {
+  const uint64_t masks[] = {0, 1, 2, UINT64_C(0xaaaaaaaaaaaaaaaa), UINT64_MAX, UINT64_C(1) << 63};
+  for (unsigned m = 0; m < sizeof(masks)/sizeof(masks[0]); m++) {
+    uint8_t old[64], src[16], output[112];
+    for (int i = 0; i < 64; i++) old[i] = (uint8_t)(197-i*3);
+    for (int i = 0; i < 16; i++) src[i] = (uint8_t)(17+i*7);
+    uint64_t relevant = width/lane == 64 ? UINT64_MAX : (UINT64_C(1) << (width/lane)) - 1;
+    int inactiveMemory = input == 0 && form != 0 && (masks[m] & relevant) == 0;
+    fn(old, inactiveMemory ? 0 : src, output, masks[m]);
+    for (int view = 0; view < 3; view++) {
+      int offset = view == 0 ? 0 : view == 1 ? 64 : 96;
+      for (int i = 0; i < (64 >> view); i++) {
+        int enabled = form == 0 || ((masks[m] >> (i/lane)) & 1);
+        uint8_t want = i >= width ? 0 : enabled ? src[i%lane] : form == 2 ? 0 : old[i];
+        if (output[offset+i] != want) {
+          fprintf(stderr,"broadcast width=%d lane=%d form=%d input=%d mask=%u view=%d byte=%d got=%u want=%u\n",width,lane,form,input,m,view,i,output[offset+i],want);
+          return 1;
+        }
+      }
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	return ir, main
+}
+
+func TestIntegerBroadcastRegisterViews(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"x86_64-apple-macosx", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := integerBroadcastViews(t, triple)
+			compileLLVMToObject(t, llc, triple, "integer_broadcast.ll", "integer_broadcast.o", ir)
+			var runner []string
+			execute := runtime.GOARCH == "amd64" && triple == testTargetTriple(runtime.GOOS, runtime.GOARCH)
+			if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && triple == "x86_64-apple-macosx" && rosettaAvailable() {
+				execute = true
+				runner = []string{"/usr/bin/arch", "-x86_64"}
+			}
+			if execute {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "integer_broadcast", triple, ir, main, runner)
+			}
+		})
+	}
+}
diff --git a/amd64_bswap.go b/amd64_bswap.go
new file mode 100644
index 000000000..f8bd54b47
--- /dev/null
+++ b/amd64_bswap.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Go's complete ybswap row is a single Yrl destination encoded by Z_rp.
+// There is no byte/word, memory, immediate, mask or suffix form.
+var x86ByteSwapSpecs = map[Op]int{"BSWAPL": 32, "BSWAPQ": 64}
+
+func x86ByteSwapProperties(op Op, ins Instr, arch string) (int, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86ByteSwapSpecs[Op(name)]
+	if !known {
+		return 0, false, nil
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && bits == 64 || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 1 ||
+		ins.Args[0].Kind != OpReg || !isX86YrlRegisterForArch(ins.Args[0].Reg, arch) {
+		return bits, true, fmt.Errorf("%s %s outside Go BSWAP register grammar: %q", arch, op, ins.Raw)
+	}
+	return bits, true, nil
+}
+
+func x86TypedByteSwapEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	bits, known, err := x86ByteSwapProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(bits / 8), read: true, write: true},
+	}}, true, nil // BSWAP does not read or modify FLAGS, DF or any memory.
+}
+
+// Byte facts are permuted, not widened to a full initialized word. The same
+// dependency transports independently proved canonical bytes, never values,
+// pointer identity, native backing or a new canonicality witness.
+func x86ByteSwapByteMask(before uint8, bits int) uint8 {
+	var after uint8
+	for index := 0; index < bits/8; index++ {
+		if before&(1<<uint(index)) != 0 {
+			after |= 1 << uint(bits/8-1-index)
+		}
+	}
+	return after
+}
+
+func x86ResultByteSwapStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	bits, known, err := x86ByteSwapProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	index, _, valid := x86ResultGP(ins.Args[0].Reg, int64(bits/8), arch)
+	if !valid || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	state.gp[index] = x86ByteSwapByteMask(state.gp[index], bits)
+	if bits == 32 {
+		state.gp[index] |= 0xf0 // The internal i64 carrier zero-extends r32.
+	}
+	state.pointerGP[index] = false
+	return true, true
+}
+
+func (c *amd64Ctx) byteSwapResultInitialized() error {
+	return c.integerEffectResultInitialized("BSWAP")
+}
+
+func (c *amd64Ctx) integerEffectResultInitialized(family string) error {
+	if proof := c.fpScalarSource.x86SourceStack; proof != nil && proof.caller != nil {
+		// The complete caller/stack proof already checked every numerical
+		// input and native access. Consume that exact owner, not a logical FP
+		// proof for the normalized physical stack or a new memory capability.
+		emitted := c.sig
+		if c.fpSourceSig.Attrs == "" && emitted.Attrs == c.fpFeatureAttrs {
+			emitted.Attrs = "" // Only the renderer's exact, separately bound feature handoff.
+		}
+		if c.goarch != "amd64" || c.sourceStack != proof || c.sig.Ret != Void ||
+			len(c.sig.Frame.Results) != 0 || !reflect.DeepEqual(emitted, c.fpSourceSig) ||
+			!x86CallerNormalizedSourceMatches(c.fpScalarSource, c.fpSourceSig) {
+			return fmt.Errorf("%w: %s checked caller continuation changed", ErrProbeNeedsContext, family)
+		}
+		return nil
+	}
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return err
+	}
+	// Generic result-byte initialization is not a canonical bool witness.
+	// The ordinary ABI0 consumer covers one logical I1 return. A mixed tuple
+	// instead needs the existing complete NUM/canonical preflight, whose flag
+	// is set only after the shared cached proof succeeds. Other independently
+	// authenticated consumers retain their own result/canonicality contracts.
+	canonicalABI0 := x86ABI0LogicalBoolFrameRole(c.fpScalarSource, c.sig, c.goarch)
+	physicalBool := c.fpScalarSource.x86SourceStack != nil && c.sig.Ret == I1
+	if canonicalABI0 || physicalBool || c.fpMixedBoolBytes ||
+		c.fpScalarSource.x86FixedLocal != nil || x86RegisterBoolResultNeedsProof(c.fpScalarSource, c.sig, c.goarch) {
+		return nil
+	}
+	for _, slot := range c.fpResults {
+		if slot.Type == I1 {
+			return fmt.Errorf("%w: %s bool result requires an independent canonical result role", ErrProbeNeedsContext, family)
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) lowerByteSwap(op Op, ins Instr) (bool, bool, error) {
+	bits, known, err := x86ByteSwapProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	typ := amd64IntegerTypeForBits(bits)
+	value, err := c.evalIntSized(ins.Args[0], typ)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.bswap.%s(%s %s)\n", result, typ, typ, typ, value)
+	return true, false, c.storeRegSized(ins.Args[0].Reg, typ, "%"+result)
+}
diff --git a/amd64_byte_alias_test.go b/amd64_byte_alias_test.go
new file mode 100644
index 000000000..472b45803
--- /dev/null
+++ b/amd64_byte_alias_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Go 1.27's amd64 Yrb class contains BPB/SIB/DIB and R8B..R15B in
+// addition to the four low and four high legacy byte-register spellings.
+// REG_SPB is deliberately not classified as Yrb by cmd/internal/obj/x86.
+func TestTranslateAMD64ExtendedByteRegisterCompleteGoAssemblerClass(t *testing.T) {
+	aliases := []string{"BPB", "SIB", "DIB", "R8B", "R9B", "R10B", "R11B", "R12B", "R13B", "R14B", "R15B"}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT extendedbyteforms(SB),NOSPLIT,$0-0\n")
+			for _, alias := range aliases {
+				fmt.Fprintf(&source, "\tMOVB %s, (AX)\n", alias)
+				fmt.Fprintf(&source, "\tMOVB (AX), %s\n", alias)
+				fmt.Fprintf(&source, "\tMOVBQZX %s, CX\n", alias)
+				fmt.Fprintf(&source, "\tMOVBQSX %s, DX\n", alias)
+			}
+			source.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "extendedbyteforms", "amd64", target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "extended-byte-"+target.name+".ll", "extended-byte-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ExtendedByteRegisterRejectsFormsOutsideGoAssemblerClass(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			aliases := []string{"SPB"}
+			if target.goarch == "386" {
+				aliases = append(aliases, "BPB", "SIB", "DIB", "R8B", "R9B", "R10B", "R11B", "R12B", "R13B", "R14B", "R15B")
+			}
+			for _, alias := range aliases {
+				instruction := "MOVB " + alias + ", (AX)"
+				file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+				if err == nil {
+					_, err = Translate(file, Options{
+						TargetTriple: target.triple,
+						Goarch:       target.goarch,
+						Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+					})
+				}
+				if err == nil {
+					t.Fatalf("Translate accepted %q outside Go 1.27's byte-register class for %s", instruction, target.goarch)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64ExtendedByteRegisterAliasesShareFullRegisterStorage(t *testing.T) {
+	for _, test := range []struct {
+		alias Reg
+		base  Reg
+	}{
+		{BPB, BP}, {SIB, SI}, {DIB, DI},
+		{R8B, Reg("R8")}, {R9B, Reg("R9")}, {R10B, Reg("R10")}, {R11B, Reg("R11")},
+		{R12B, Reg("R12")}, {R13B, Reg("R13")}, {R14B, Reg("R14")}, {R15B, Reg("R15")},
+	} {
+		base, shift, ok := amd64ByteAlias(test.alias)
+		if !ok || base != test.base || shift != 0 {
+			t.Errorf("amd64ByteAlias(%s) = (%s, %d, %v), want (%s, 0, true)", test.alias, base, shift, ok, test.base)
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_caller_test.go b/amd64_byte_shuffle_caller_test.go
new file mode 100644
index 000000000..b4a0ab303
--- /dev/null
+++ b/amd64_byte_shuffle_caller_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86ByteShuffleActualCallerThreeAPIs(t *testing.T) {
+	var body strings.Builder
+	rows := []string{"PSHUFB X0,X1"}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, control := range []string{bank + "0", "(DI)"} {
+			rows = append(rows,
+				fmt.Sprintf("VPSHUFB %s,%s1,%s1", control, bank, bank),
+				fmt.Sprintf("VPSHUFB %s,%s1,K1,%s1", control, bank, bank),
+				fmt.Sprintf("VPSHUFB.Z %s,%s1,K1,%s1", control, bank, bank))
+		}
+	}
+	for _, row := range rows {
+		fmt.Fprintf(&body, "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\n%s\nVMOVSS X1,(DX)\n", row)
+	}
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body.String(), 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "shuffle-text.ll", "shuffle-text.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "shuffle-module.ll", "shuffle-module.o", module.String())
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleCallerMemoryCertificateAndAlignment(t *testing.T) {
+	for _, row := range []string{"VPSHUFB (DI),X0,X2", "VPSHUFB.Z (DI),Z0,K1,Z2", "PSHUFB (DI),X0"} {
+		result := "X2"
+		if strings.HasPrefix(row, "PSHUFB") {
+			result = "X0"
+		}
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n"+row+"\nVMOVSS "+result+",(DX)", 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if strings.HasPrefix(row, "PSHUFB") {
+			if err == nil {
+				t.Fatal("caller slice acquired legacy m128 alignment")
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86ByteShuffleProperties(ins.Op, ins, "amd64")
+			if !known || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			index := form.memory
+			access, exists := ins.x86CallerMemory[index]
+			if !exists || access.write || access.width != int64(form.byteWidth) || !x86CallerMemoryCertified(ins, index) {
+				t.Fatal("caller lost full E4NF tuple")
+			}
+			for _, change := range []string{"opcode", "width", "address", "destination", "direction", "mask"} {
+				mutated := ins
+				mutated.Args = append([]Operand(nil), ins.Args...)
+				updated := access
+				switch change {
+				case "opcode":
+					mutated.Op = "VPANDD"
+				case "width":
+					updated.width--
+				case "address":
+					mutated.Args[index].Mem.Off++
+				case "destination":
+					mutated.Args[form.destination].Reg = "X3"
+				case "direction":
+					updated.write = true
+				case "mask":
+					if form.mask >= 0 {
+						mutated.Args[form.mask].Reg = "K2"
+					} else {
+						mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K2"})
+					}
+				}
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: updated}
+				if x86CallerMemoryCertified(mutated, index) {
+					t.Fatal("changed shuffle retained caller memory authority", change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("no shuffle consumed the caller proof")
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_effects.go b/amd64_byte_shuffle_effects.go
new file mode 100644
index 000000000..c7dfc1c35
--- /dev/null
+++ b/amd64_byte_shuffle_effects.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+func x86ResultByteShuffleStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultByteShuffleStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultByteShuffleStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86ByteShuffleProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	control := uint64(0)
+	if form.memory >= 0 {
+		// Only the paired emitter may observe continuation past its complete
+		// native read. A mask cannot shrink E4NF, certify alignment or grant
+		// backing; public/caller observers keep their separate storage rules.
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[form.memory], int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+		control = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, form.byteWidth)
+		control = state.vectorBytes(index)
+	}
+	data, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	initialized := x86ByteShuffleDefinedBytes(form.byteWidth, control, state.vectorBytes(data))
+	if form.mask >= 0 && !form.zeroing {
+		initialized &= state.vectorBytes(destination)
+	}
+	state.writeVector(destination, form.byteWidth, initialized, form.legacy)
+	return true, true
+}
+
+func x86CallerByteShuffleStep(ins *Instr, form x86PackedBinaryForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	control := uint64(0)
+	if form.memory >= 0 {
+		// A bounded slice is not a witness for legacy m128 alignment.
+		// E4NF vector reads require the full tuple even with a zero mask.
+		if form.legacy || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		control = width
+	} else {
+		control = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)]
+	}
+	data := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)]
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := x86ByteShuffleDefinedBytes(form.byteWidth, control, data)
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_byte_shuffle_fault_unix_test.go b/amd64_byte_shuffle_fault_unix_test.go
new file mode 100644
index 000000000..c4f7aa213
--- /dev/null
+++ b/amd64_byte_shuffle_fault_unix_test.go
@@ -0,0 +1,177 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ByteShuffleMemoryFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, entries strings.Builder
+	count := 0
+	for _, width := range []int{16, 32, 64} {
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+		for legacy := 0; legacy < 2; legacy++ {
+			if legacy != 0 && width != 16 {
+				continue
+			}
+			for masking := 0; masking < 3; masking++ {
+				if legacy != 0 && masking != 0 {
+					continue
+				}
+				for dead := 0; dead < 2; dead++ {
+					name := fmt.Sprint("Fault", count)
+					count++
+					row := "VPSHUFB"
+					if legacy != 0 {
+						row = "PSHUFB"
+					}
+					if masking == 2 {
+						row += ".Z"
+					}
+					row += " (SI)," + bank + "1"
+					if masking != 0 {
+						row += ",K1"
+					}
+					if legacy == 0 {
+						row += "," + bank + "1"
+					}
+					fmt.Fprintf(&declarations, "func %s(out,control,data *[64]byte)\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ control+8(FP),SI\nMOVQ data+16(FP),DX\nVMOVUPS (DX),Z1\nMOVL $0,AX\nKMOVQ AX,K1\n%s\n", name, row)
+					if dead == 0 {
+						fmt.Fprintf(&source, "VMOVUPS %s1,(DI)\n", bank)
+					}
+					source.WriteString("RET\n")
+					fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*);\n", name)
+					original := "0"
+					if legacy != 0 {
+						// Original Go bytes use the native C argument registers.
+						// This does not claim native VEX/EVEX execution.
+						original = "Original" + name
+						native := "TEXT native(SB),4,$0-0\nMOVOU (DX),X1\nPSHUFB (SI),X1\n"
+						if dead == 0 {
+							native += "MOVOU X1,(DI)\n"
+						}
+						code := x86OrderingHintGoBytes(t, "amd64", native+"RET\n")
+						var bytes []string
+						for _, value := range code {
+							bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+						}
+						symbol := original
+						if strings.Contains(execution.triple, "apple") {
+							symbol = "_" + symbol
+						}
+						fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+						fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*);\n", original)
+					}
+					fmt.Fprintf(&entries, "{%s,%s,%d,%d,%d},\n", name, original, width, masking, dead)
+				}
+			}
+		}
+	}
+	if count != 20 {
+		t.Fatal("incomplete fault family", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := fmt.Sprintf(x86ByteShuffleFaultReference, prototypes.String(), originals.String(), entries.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					text := ir
+					if level == "-O2" {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					output := execution.compileAndRunLLVM(t, "byte-shuffle-faults", text, driver, level)
+					if string(output) != "byte shuffle: 20 kernels, 110 address outcomes, failures 0\n" {
+						t.Fatal("incomplete fault oracle", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+const x86ByteShuffleFaultReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+%s
+%s
+typedef void (*Program)(uint8_t*,const uint8_t*,const uint8_t*);
+typedef struct { Program translated, original; int width, masking, dead; } Kernel;
+static const Kernel kernels[] = {%s};
+
+static int observe(Program run, Kernel k, const uint8_t *control) {
+    pid_t child = fork();
+    if (child < 0) return -1;
+    if (child == 0) {
+        struct rlimit no_core = {0,0};
+        if (setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        _Alignas(64) uint8_t data[64], out[66];
+        for (int i=0;i<64;i++) data[i]=(uint8_t)(i*17+31);
+        memset(out,0xa7,sizeof(out));
+        run(out+1,control,data);
+        for (int i=0;i<66;i++) {
+            unsigned want=0xa7;
+            if (!k.dead && i>=1 && i<=k.width) {
+                int offset=i-1;
+                if (k.masking) want=k.masking==2 ? 0 : data[offset];
+                else want=control[offset]&0x80 ? 0 : data[offset/16*16+(control[offset]&15)];
+            }
+            if (out[i]!=want) _exit(121);
+        }
+        _exit(0);
+    }
+    int status;
+    if (waitpid(child,&status,0)!=child) return -2;
+    if (WIFEXITED(status)) return WEXITSTATUS(status)==0 ? 0 : -3;
+    if (WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -4;
+}
+
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if (page<128) return 1;
+    uint8_t *memory=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if (memory==MAP_FAILED || mprotect(memory+page,page,PROT_NONE)) return 2;
+    for (long i=0;i<page;i++) memory[i]=(uint8_t)(i*53+7);
+    unsigned outcomes=0;
+    for (unsigned i=0;i<sizeof(kernels)/sizeof(kernels[0]);i++) {
+        Kernel k=kernels[i];
+        const uint8_t *addresses[]={NULL,memory+page-k.width+1,memory+page-k.width,memory+1,memory};
+        for (unsigned j=0;j<sizeof(addresses)/sizeof(addresses[0]);j++) {
+            int got=observe(k.translated,k,addresses[j]);
+            int want=j<2;
+            if (k.original) {
+                want=observe(k.original,k,addresses[j]);
+                // Native hardware and Rosetta can differ on unaligned SSE.
+                // Compare actual original behavior, never label it native CI.
+                if (want<0 || (j<2 && want!=1) || (j>1 && j!=3 && want!=0)) return 3;
+                outcomes++;
+            }
+            if (got<0 || got!=want) {
+                fprintf(stderr,"kernel %%u address %%u got %%d want %%d\n",i,j,got,want);
+                return 4;
+            }
+            outcomes++;
+        }
+    }
+    if (munmap(memory,2*page)) return 5;
+    printf("byte shuffle: %%zu kernels, %%u address outcomes, failures 0\n",sizeof(kernels)/sizeof(kernels[0]),outcomes);
+    return 0;
+}
+`
diff --git a/amd64_byte_shuffle_forms.go b/amd64_byte_shuffle_forms.go
new file mode 100644
index 000000000..3a7cd74cc
--- /dev/null
+++ b/amd64_byte_shuffle_forms.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's ymshufb has only X/m128, X, not the ISA's separate MMX form.
+// Both vector encodings share the binary grammar, with no broadcast or SAE.
+var x86ByteShuffleSpecs = map[Op]x86PackedBinarySpec{
+	"PSHUFB":  {encoding: x86PackedLogicalLegacyFP},
+	"VPSHUFB": {encoding: x86PackedLogicalVEXOrEVEX, zeroing: true},
+}
+
+func x86ByteShuffleProperties(op Op, ins Instr, arch string) (x86PackedBinaryForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ByteShuffleSpecs[Op(base)]
+	if !known {
+		return x86PackedBinaryForm{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86PackedBinaryForm{}, true, fmt.Errorf("byte shuffle dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	local := ins
+	local.Op = op
+	grammarArch := arch
+	if arch == "386" && ins.x86Encoded && spec.encoding != x86PackedLogicalLegacyFP {
+		// Physical EVEX masking does not inherit cmd/asm's named operand cap.
+		grammarArch = "amd64"
+	}
+	form, err := x86PackedBinaryProperties(local, grammarArch, spec)
+	if err == nil && grammarArch != arch && form.memory >= 0 && !x86PackedShiftMemoryValid(local.Args[form.memory], arch) {
+		err = fmt.Errorf("386 byte shuffle physical source has an unbound address")
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(local, arch)
+	}
+	if err == nil && form.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		err = fmt.Errorf("%w: byte shuffle has no bound address-size override", ErrProbeNeedsContext)
+	}
+	return form, true, err
+}
+
+// A dynamic control byte may select any byte of its own 128-bit data lane.
+// This is numerical definedness, never a memory, alignment or caller grant.
+func x86ByteShuffleDefinedBytes(width int, control, data uint64) uint64 {
+	var known uint64
+	for start := 0; start < width; start += 16 {
+		lane := uint64(0xffff) << uint(start)
+		if data&lane == lane {
+			known |= control & lane
+		}
+	}
+	return known
+}
+
+func x86TypedByteShuffleEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ByteShuffleProperties(op, ins, arch)
+	if !known || err != nil || !form.legacy {
+		return x86TypedByteEffect{}, known && (err != nil || form.legacy), err
+	}
+	return x86PackedBinaryDependencyEffect(ins, form, ins.Args[form.first]), true, nil
+}
diff --git a/amd64_byte_shuffle_forms_test.go b/amd64_byte_shuffle_forms_test.go
new file mode 100644
index 000000000..310ec0403
--- /dev/null
+++ b/amd64_byte_shuffle_forms_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteShuffleCompleteGoEncoderRows(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{APSHUFB, ymshufb, Pq, opBytes{0x38, 0x00}}",
+		"var ymshufb = []ytab{\n\t{Zm2_r, 2, argList{Yxm, Yxr}},\n}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("actual legacy Go row changed", row)
+		}
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(x86ByteShuffleSpecs) != 2 {
+		t.Fatal("byte shuffle family changed")
+	}
+	for _, row := range []struct{ begin, end, want string }{
+		{"{as: AVPSHUFB,", "\n\t}},", `{as: AVPSHUFB, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F38 | vexW0, 0x00,
+		avxEscape | vex256 | vex66 | vex0F38 | vexW0, 0x00,
+		avxEscape | evex128 | evex66 | evex0F38 | evexW0, evexN16 | evexZeroingEnabled, 0x00,
+		avxEscape | evex256 | evex66 | evex0F38 | evexW0, evexN32 | evexZeroingEnabled, 0x00,
+		avxEscape | evex512 | evex66 | evex0F38 | evexW0, evexN64 | evexZeroingEnabled, 0x00,`},
+		{"var _yvandnpd =", "\n}", `var _yvandnpd = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},`},
+	} {
+		start := strings.Index(string(avx), row.begin)
+		if start < 0 || strings.SplitN(string(avx)[start:], row.end, 2)[0] != row.want {
+			t.Fatal("actual Go encoder classes, offsets or attributes changed", row.begin)
+		}
+	}
+}
+
+func x86ByteShuffleFormatRows(arch string) []string {
+	var rows []string
+	for _, source := range []string{"X0", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-16(SP)", "·data(SB)", "(FS)", "(GS)"} {
+		rows = append(rows, "PSHUFB "+source+",X1")
+	}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, source := range []string{bank + "0", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+			for mode := 0; mode < 3; mode++ {
+				if arch == "386" && mode != 0 {
+					continue
+				}
+				name, args := "VPSHUFB", source+","+bank+"1"
+				if mode != 0 {
+					args += ",K7"
+				}
+				if mode == 2 {
+					name += ".Z"
+				}
+				rows = append(rows, name+" "+args+","+bank+"2")
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86ByteShuffleGoFormsAndMemoryShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ByteShuffleFormatRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$64-64\n"+row+"\nRET\n", "", true)
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86ByteShuffleProperties(ins.Op, ins, arch)
+				if !known || err != nil || !x86CallerVectorMoveKnown(ins) {
+					t.Fatal("Go shape missing in a consumer", known, err)
+				}
+				if form.memory >= 0 {
+					width, write, known := x86InstructionMemoryShape(ins, form.memory, arch)
+					if !known || write || width != int64(form.byteWidth) {
+						t.Fatal("lost full E4NF control tuple", width, write, known)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ByteShuffleMode32HighBanksRemainContext(t *testing.T) {
+	for _, bank := range []string{"X", "Y"} {
+		for _, index := range []int{8, 15, 16, 31} {
+			row := fmt.Sprintf("VPSHUFB %s%d,%s1,%s2", bank, index, bank, bank)
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86ByteShuffleProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("source acceptance invented physical high-bank identity", row, err)
+			}
+		}
+	}
+}
+
+func TestX86ByteShuffleInvalidFormsAndSourceIdentity(t *testing.T) {
+	for _, row := range []string{
+		"PSHUFB M0,M1", "PSHUFB X16,X1", "PSHUFB.Z X0,X1",
+		"VPSHUFB X0,Y1,Y2", "VPSHUFB X0,(AX),X2", "VPSHUFB $1,X1,X2",
+		"VPSHUFB X0,X1,K0,X2", "VPSHUFB.BCST (AX),X1,X2",
+		"VPSHUFB.SAE X0,X1,X2", "VPSHUFB.RN_SAE X0,X1,X2",
+		"VPSHUFB (AX)(CX*3),X1,X2", "VPSHUFB 2147483648(AX),X1,X2",
+	} {
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		file, parseErr := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if parseErr != nil {
+			// The original Go rejection above still owns this source axis.
+			continue
+		}
+		ins := file.Funcs[0].Instrs[1]
+		if _, known, err := x86ByteShuffleProperties(ins.Op, ins, "amd64"); !known || err == nil || x86CallerVectorMoveKnown(ins) {
+			t.Fatal("invalid Go form acquired an effect", row, known, err)
+		}
+	}
+	for _, row := range []string{"PSHUFB (AX),X1", "VPSHUFB (AX),X1,X2"} {
+		for _, mutation := range []string{"dispatch", "address-size", "unbound-override"} {
+			ins := x86ScalarLaneInstruction(t, row)
+			op := ins.Op
+			switch mutation {
+			case "dispatch":
+				ins.Op = "MOVOU"
+			case "address-size":
+				ins.x86AddressBits = 32
+			case "unbound-override":
+				ins.x86UnboundAddressOverride = true
+			}
+			var out strings.Builder
+			ctx := amd64Ctx{goarch: "amd64", b: &out}
+			if known, _, err := ctx.lowerPackedByteShuffle(op, ins); !known || err == nil || out.Len() != 0 {
+				t.Fatal("changed source identity emitted IR", row, mutation, err, out.String())
+			}
+		}
+	}
+}
+
+func TestX86ByteShuffleVectorDispatcherUsesCompleteGrammar(t *testing.T) {
+	for _, row := range []string{
+		"PSHUFB Y0,X0", "PSHUFB X0", "PSHUFB.Z X0,X1",
+		"VPSHUFB Y0,Y1,AX", "VPSHUFB X0,Y1,Y2",
+		"VPSHUFB X0,X1,K0,X2", "VPSHUFB.BCST (AX),X1,X2",
+	} {
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		for _, keepOpcode := range []bool{false, true} {
+			ins := x86ScalarLaneInstruction(t, row)
+			op := ins.Op
+			if !keepOpcode {
+				ins.Op = ""
+			}
+			var output strings.Builder
+			ctx := amd64Ctx{goarch: "amd64", b: &output}
+			known, terminated, err := ctx.lowerVec(op, ins)
+			if !known || terminated || err == nil || output.Len() != 0 {
+				t.Fatalf("vector dispatcher bypassed byte-shuffle grammar for %q: (%v, %v, %v), IR %q", row, known, terminated, err, output.String())
+			}
+		}
+	}
+	for _, row := range []string{
+		"PSHUFB X0,X1", "VPSHUFB X0,X1,X2", "VPSHUFB Y0,Y1,Y2",
+		"VPSHUFB Z0,Z1,Z2", "VPSHUFB X0,X1,K7,X2", "VPSHUFB.Z Z0,Z1,K7,Z2",
+	} {
+		ins := x86ScalarLaneInstruction(t, row)
+		function := Func{Instrs: []Instr{ins}}
+		family, familyOutput := newAMD64CtxWithFuncForTest(t, function, FuncSig{Name: "shuffle", Ret: Void}, nil)
+		dispatch, dispatchOutput := newAMD64CtxWithFuncForTest(t, function, FuncSig{Name: "shuffle", Ret: Void}, nil)
+		if known, terminated, err := family.lowerPackedByteShuffle(ins.Op, ins); !known || terminated || err != nil {
+			t.Fatal("independent family entry", row, known, terminated, err)
+		}
+		if known, terminated, err := dispatch.lowerVec(ins.Op, ins); !known || terminated || err != nil {
+			t.Fatal("vector family entry", row, known, terminated, err)
+		}
+		if familyOutput.String() != dispatchOutput.String() {
+			t.Fatal("vector dispatcher changed the family's emitted effects", row)
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_native_result_test.go b/amd64_byte_shuffle_native_result_test.go
new file mode 100644
index 000000000..14208d048
--- /dev/null
+++ b/amd64_byte_shuffle_native_result_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ByteShuffleNativeResultRows(arch string) []string {
+	rows := []string{"PSHUFB (DX),X0"}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		rows = append(rows, "VPSHUFB (DX),"+bank+"0,"+bank+"1")
+		if arch == "amd64" {
+			rows = append(rows, "VPSHUFB (DX),"+bank+"0,K1,"+bank+"1",
+				"VPSHUFB.Z (DX),"+bank+"0,K1,"+bank+"1")
+		}
+	}
+	return rows
+}
+
+func TestX86ByteShuffleNativeResultsCompleteFamilyFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			var source, declarations strings.Builder
+			for index, row := range x86ByteShuffleNativeResultRows(target.arch) {
+				name, output := fmt.Sprint("ShuffleNative", index), "X1"
+				if strings.HasPrefix(row, "PSHUFB ") {
+					output = "X0"
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DX\n"+
+					"VPXORQ Z0,Z0,Z0\nVPXORQ Z1,Z1,Z1\nMOVL $1,AX\nKMOVW AX,K1\n%s\n"+
+					"PEXTRD $0,%s,AX\nMOVL AX,ret+%d(FP)\nRET\n", name, word+4, move, row, output, word)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte) uint32\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete initialized family lost its paired native read", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleNativeContinuationCannotCreateAddressOrMaskFacts(t *testing.T) {
+	for _, row := range x86ByteShuffleNativeResultRows("amd64") {
+		for _, mutation := range []string{"unknown-base", "pointer-index", "missing-mask", "numerical-address"} {
+			if mutation == "missing-mask" && !strings.Contains(row, "K1") {
+				continue
+			}
+			t.Run(row+"/"+mutation, func(t *testing.T) {
+				setup := "MOVQ p+0(FP),DX\nVPXORQ Z0,Z0,Z0\nVPXORQ Z1,Z1,Z1\nMOVL $1,AX\nKMOVW AX,K1\n"
+				instruction := row
+				switch mutation {
+				case "unknown-base":
+					setup = strings.Replace(setup, "MOVQ p+0(FP),DX\n", "", 1)
+				case "pointer-index":
+					instruction = strings.Replace(row, "(DX)", "(DX)(DX*1)", 1)
+				case "missing-mask":
+					setup = strings.Replace(setup, "KMOVW AX,K1\n", "", 1)
+				case "numerical-address":
+					setup += "MOVL $1,DX\n"
+				}
+				output := "X1"
+				if strings.HasPrefix(row, "PSHUFB ") {
+					output = "X0"
+				}
+				source := "TEXT ·Shuffle(SB),4,$0-12\n" + setup + instruction + "\nPEXTRD $0," + output + ",AX\nMOVL AX,ret+8(FP)\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Shuffle(p *[64]byte) uint32", "amd64", "x86_64-unknown-linux-gnu", api)
+					if mutation == "numerical-address" {
+						x86RequireNumericNativeSourceContext(t, source, "func Shuffle(p *[64]byte) uint32", "amd64")
+						goAssemblerOracleOutput(t, "amd64", source, "", true)
+						width := 16
+						if strings.Contains(row, "Y0") {
+							width = 32
+						} else if strings.Contains(row, "Z0") {
+							width = 64
+						}
+						read := strings.Contains(ir, fmt.Sprintf("load volatile <%d x i8>", width))
+						if strings.HasPrefix(row, "PSHUFB ") {
+							read = strings.Contains(ir, "call <4 x float> asm sideeffect \"pshufb ") && strings.Contains(ir, "~{memory}")
+						}
+						if err != nil || !read {
+							t.Fatal("numerical address lost the original exact-width byte-shuffle read", err)
+						}
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("conditional native read manufactured independent facts", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_objects_test.go b/amd64_byte_shuffle_objects_test.go
new file mode 100644
index 000000000..6d4a3e831
--- /dev/null
+++ b/amd64_byte_shuffle_objects_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteShuffleThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86ByteShuffleFormatRows(target.arch)
+			for begin := 0; begin < len(rows); begin += 64 {
+				end := begin + 64
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprint(begin), func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows[begin:end] {
+						if strings.HasPrefix(row, "PSHUFB ") && (strings.Contains(row, "(FP)") || strings.Contains(row, "(SP)")) {
+							// Explicit native-storage rejection controls below.
+							continue
+						}
+						fmt.Fprintf(&declarations, "func Shuffle%d(value [64]byte)\n", index)
+						fmt.Fprintf(&source, "TEXT ·Shuffle%d(SB),4,$64-64\n%s\nRET\n", index, row)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(api, err)
+						}
+						x86ResultInitializationObject(t, llc, target.triple, ir, "byte-shuffle-"+api)
+						x86ResultInitializationObject(t, llc, target.triple, x86MulDivRoundOptimize(t, ir), "byte-shuffle-"+api+"-optimized")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleVirtualLegacyStorageRemainsContext(t *testing.T) {
+	for _, row := range []string{"PSHUFB value+0(FP),X1", "PSHUFB local-16(SP),X1", "PSHUFB (SP),X1", "PSHUFB (BP),X1"} {
+		for _, target := range x86RawReturnTargets {
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				source := "TEXT ·Shuffle(SB),4,$64-64\nPXOR X1,X1\n" + row + "\nRET\n"
+				declaration := "func Shuffle(value [64]byte)"
+				if strings.Contains(row, "(BP)") {
+					source = x86OrdinaryBPNativeSource(target.arch, "Shuffle", row, "(BP)", 64)
+					declaration = "func Shuffle(p *byte)"
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, row, ir, err)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_raw_test.go b/amd64_byte_shuffle_raw_test.go
new file mode 100644
index 000000000..e5da92d4e
--- /dev/null
+++ b/amd64_byte_shuffle_raw_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteShuffleRawWIGAndPhysicalMasks(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, width := range []byte{0, 4} {
+			for _, w := range []byte{0, 0x80} {
+				code := []byte{0xc4, 0xe2, 0x71 | width | w, 0x00, 0xd0}
+				ins, size, known, err := decodedX86VPSHUFBInstruction(code, mode)
+				if !known || err != nil || size != len(code) || ins.Op != "VPSHUFB" {
+					t.Errorf("VEX.WIG mode=%d code=%x: size=%d known=%t err=%v", mode, code, size, known, err)
+				}
+			}
+		}
+		for width := byte(0); width < 3; width++ {
+			for mask := byte(0); mask < 8; mask++ {
+				for _, zero := range []byte{0, 0x80} {
+					if mask == 0 && zero != 0 {
+						continue
+					}
+					for _, w := range []byte{0, 0x80} {
+						code := []byte{0x62, 0xf2, 0x75 | w, 8 | width<<5 | mask | zero, 0x00, 0xd0}
+						t.Run(fmt.Sprintf("%d/%x", mode, code), func(t *testing.T) {
+							ins, size, known, err := decodedX86VPSHUFBInstruction(code, mode)
+							if !known || err != nil || size != len(code) {
+								t.Fatalf("physical EVEX inherited named operand limit or W0: size=%d known=%t err=%v", size, known, err)
+							}
+							arch := "amd64"
+							if mode == 32 {
+								arch = "386"
+							}
+							if !ins.x86Encoded {
+								t.Fatal("decoder lost physical encoding identity")
+							}
+							if _, known, err := x86ByteShuffleProperties(ins.Op, ins, arch); !known || err != nil {
+								t.Fatal("typed physical consumer", known, err)
+							}
+							ins.x86Encoded = false
+							if _, _, err := x86ByteShuffleProperties(ins.Op, ins, arch); mode == 32 && mask != 0 && err == nil {
+								t.Fatal("named mode32 form acquired physical decoder authority")
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ByteShuffleRawThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var codes [][]byte
+	for _, width := range []byte{0, 4} {
+		for _, w := range []byte{0, 0x80} {
+			codes = append(codes, []byte{0xc4, 0xe2, 0x71 | width | w, 0x00, 0xd0})
+		}
+	}
+	for width := byte(0); width < 3; width++ {
+		for _, mask := range []byte{1, 7} {
+			for _, zero := range []byte{0, 0x80} {
+				for _, w := range []byte{0, 0x80} {
+					codes = append(codes, []byte{0x62, 0xf2, 0x75 | w, 8 | width<<5 | mask | zero, 0x00, 0xd0})
+				}
+			}
+		}
+	}
+	var source, declarations strings.Builder
+	for index, code := range codes {
+		fmt.Fprintf(&declarations, "func RawShuffle%d()\n", index)
+		fmt.Fprintf(&source, "TEXT ·RawShuffle%d(SB),4,$0-0\n", index)
+		for _, b := range code {
+			fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+		}
+		source.WriteString("RET\n")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "raw-byte-shuffle-"+api)
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleReservedRawForms(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc4, 0xe2, 0x70, 0, 0xd0},             // Wrong mandatory prefix.
+		{0xc4, 0xe2, 0x71, 0},                   // Truncated ModRM.
+		{0x62, 0xf2, 0x75, 0x68, 0, 0xd0},       // Reserved LL.
+		{0x62, 0xf2, 0x75, 0x18, 0, 0xd0},       // No broadcast/rounding.
+		{0x62, 0xf2, 0x75, 0x88, 0, 0xd0},       // Zeroing without mask.
+		{0x67, 0x62, 0xf2, 0x75, 0x08, 0, 0x10}, // Unbound address size.
+	} {
+		for _, mode := range []int{32, 64} {
+			if _, _, known, err := decodedX86VPSHUFBInstruction(code, mode); !known || err == nil {
+				t.Fatalf("reserved byte shuffle accepted: mode=%d code=%x known=%t err=%v", mode, code, known, err)
+			}
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_result_test.go b/amd64_byte_shuffle_result_test.go
new file mode 100644
index 000000000..997975159
--- /dev/null
+++ b/amd64_byte_shuffle_result_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteShuffleIndependentResultConsumers(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const data = "DATA control<>+0(SB)/8,$0x0001020304050607\nDATA control<>+8(SB)/8,$0x08090a0b0c0d0e0f\nGLOBL control<>(SB),8,$16\n"
+	for _, row := range []string{
+		"PSHUFB X0,X1", "VPSHUFB X0,X1,X1",
+		"PSHUFB control<>(SB),X1", "VPSHUFB control<>(SB),X1,X1",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := data + "TEXT ·view(SB),4,$0-20\nMOVQ a+0(FP),X0\nMOVQ b+8(FP),X1\n" + row + "\nPEXTRD $0,X1,AX\nMOVL AX,ret+16(FP)\nRET\n"
+			for _, target := range x86RawReturnTargets {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a,b uint64) uint32\n", target.arch, target.triple, api)
+					if err != nil {
+						t.Fatalf("%s/%s complete numerical shuffle has no result consumer: %v", target.triple, api, err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "byte-shuffle-result-"+api)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleDeadMemoryRetainsOriginalAccess(t *testing.T) {
+	for _, row := range []struct {
+		body  string
+		width int
+	}{
+		{"PSHUFB (DX),X0", 16},
+		{"VPSHUFB (DX),X0,X1", 16},
+		{"VPSHUFB (DX),Y0,Y1", 32},
+		{"VPSHUFB (DX),Z0,Z1", 64},
+		{"VPSHUFB.Z (DX),Z0,K1,Z1", 64},
+	} {
+		t.Run(row.body, func(t *testing.T) {
+			source := "TEXT ·view(SB),4,$0-8\nMOVQ p+0(FP),DX\nVPXORQ Z0,Z0,Z0\nMOVL $0,AX\nKMOVW AX,K1\n" + row.body + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte)\n", "amd64", "x86_64-unknown-linux-gnu", "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				want := fmt.Sprintf("load volatile <%d x i8>", row.width)
+				if !strings.HasPrefix(row.body, "V") {
+					want = "asm sideeffect \"pshufb "
+				}
+				if !strings.Contains(text, want) {
+					t.Errorf("dead shuffle lost its full native read/alignment effect: want %s", want)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ByteShuffleSparseResultAndCallerBytes(t *testing.T) {
+	for _, width := range []int{16, 32, 64} {
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+		for _, legacy := range []bool{false, true} {
+			if legacy && width != 16 {
+				continue
+			}
+			for masking := 0; masking < 3; masking++ {
+				if legacy && masking != 0 {
+					continue
+				}
+				row, dst := "VPSHUFB", 2
+				if legacy {
+					row, dst = "PSHUFB", 1
+				}
+				if masking == 2 {
+					row += ".Z"
+				}
+				row += " " + bank + "0," + bank + "1"
+				if masking != 0 {
+					row += ",K1"
+				}
+				if !legacy {
+					row += "," + bank + "2"
+				}
+				ins := x86ScalarLaneInstruction(t, row)
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						initial := [3]uint64{^uint64(0), ^uint64(0), ^uint64(0)}
+						if missing >= 0 {
+							initial[input] &^= uint64(1) << uint(missing)
+						}
+						result := x86ResultState{flags: 0x3f}
+						caller := x86SourceStackState{vectors: map[Reg]uint64{}, masks: map[Reg]bool{"K1": true}}
+						for i, value := range initial {
+							result.writeVector(i, 64, value, false)
+							caller.vectors[Reg(fmt.Sprintf("Z%d", i))] = value
+						}
+						result.masks[1] = true
+						if !x86ResultTransfer(ins, &result, nil, 0, "amd64") || !x86CallerVectorMoveStep(&ins, &caller, nil) {
+							t.Fatal("missing byte consumer", row)
+						}
+						var want uint64
+						for output := 0; output < 64; output++ {
+							known := !legacy || initial[dst]>>uint(output)&1 != 0
+							if output < width {
+								known = initial[0]>>uint(output)&1 != 0
+								for selected := 0; selected < 16; selected++ {
+									known = known && initial[1]>>uint(output/16*16+selected)&1 != 0
+								}
+								if masking == 1 {
+									known = known && initial[dst]>>uint(output)&1 != 0
+								}
+							}
+							if known {
+								want |= uint64(1) << uint(output)
+							}
+						}
+						if result.vectorBytes(dst) != want || caller.vectors[Reg(fmt.Sprintf("Z%d", dst))] != want || result.flags != 0x3f {
+							t.Fatalf("%s input=%d missing=%d: result=%x caller=%x want=%x", row, input, missing, result.vectorBytes(dst), caller.vectors[Reg(fmt.Sprintf("Z%d", dst))], want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ByteShuffleResultMemoryAndMaskBoundaries(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+		row := "VPSHUFB.Z value+0(FP)," + bank + "1,K1," + bank + "2"
+		ins := x86ScalarLaneInstruction(t, row)
+		for missing := -1; missing < 64; missing++ {
+			for _, maskKnown := range []bool{false, true} {
+				state := x86ResultState{fp: make([]bool, 64)}
+				owned := make([]bool, 64)
+				for i := range owned {
+					owned[i], state.fp[i] = true, i != missing
+				}
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.masks[1] = maskKnown
+				accepted := x86ResultTransfer(ins, &state, owned, 64, "amd64")
+				want := maskKnown && (missing < 0 || missing >= width)
+				if accepted != want || accepted && state.vectorBytes(2) != ^uint64(0) || len(ins.x86CallerMemory) != 0 {
+					t.Fatal("mask/tuple observation invented bytes or caller permission", row, missing, maskKnown, accepted)
+				}
+			}
+		}
+	}
+	for _, source := range []string{"(AX)", "·unknown(SB)", "value-1(FP)"} {
+		ins := x86ScalarLaneInstruction(t, "VPSHUFB.Z "+source+",X1,K1,X2")
+		state := x86ResultState{}
+		state.xmm[1], state.masks[1], state.pointerGP[0] = 0xffff, true, true
+		if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+			t.Fatal("unproved memory acquired numerical authority", source)
+		}
+	}
+}
diff --git a/amd64_byte_shuffle_runtime_test.go b/amd64_byte_shuffle_runtime_test.go
new file mode 100644
index 000000000..e2bb101d0
--- /dev/null
+++ b/amd64_byte_shuffle_runtime_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This observes portable LLVM semantics, not execution of original AVX512.
+// Every output byte, including wider aliases and surrounding canaries, is
+// compared with an independent scalar reference over all 256 control values.
+func TestCrossLinuxRuntimeMatrixX86ByteShuffleSoftware(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, reference, checks strings.Builder
+	reference.WriteString(x86ByteShuffleReference)
+	count := 0
+	for _, width := range []int{16, 32, 64} {
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+		for legacy := 0; legacy < 2; legacy++ {
+			for memory := 0; memory < 2; memory++ {
+				for mask := 0; mask < 3; mask++ {
+					for dst := 0; dst < 3; dst++ {
+						if legacy != 0 && (width != 16 || mask != 0 || dst != 1) {
+							continue
+						}
+						name := fmt.Sprint("Shuffle", count)
+						count++
+						row, control := "VPSHUFB", bank+"0"
+						if legacy != 0 {
+							row = "PSHUFB"
+						}
+						if memory != 0 {
+							control = "(DI)"
+						}
+						if mask == 2 {
+							row += ".Z"
+						}
+						row += " " + control + "," + bank + "1"
+						if mask != 0 {
+							row += ",K1"
+						}
+						if legacy == 0 {
+							row += fmt.Sprintf(",%s%d", bank, dst)
+						}
+						fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed,mask uint64)\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-56\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\nMOVQ flags+24(FP),CX\nMOVQ csr+32(FP),BX\n", name)
+						source.WriteString("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nMOVQ mask+48(FP),AX\nKMOVQ AX,K1\nPUSHQ seed+40(FP)\nPOPFQ\n")
+						fmt.Fprintf(&source, "%s\nVMOVUPS Z%d,(DX)\nPUSHFQ\nPOPQ AX\nMOVQ AX,(CX)\nSTMXCSR (BX)\nRET\n", row, dst)
+						fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t*,uint32_t*,uint64_t,uint64_t);\n", name)
+						fmt.Fprintf(&checks, "    if (check(%s,%q,%d,%d,%d,%d)) return 1;\n", name, row, width, legacy, mask, dst)
+					}
+				}
+			}
+		}
+	}
+	if count != 56 || count > 64 {
+		t.Fatal("incomplete or oversized runtime batch", count)
+	}
+	reference.WriteString("int main(void) {\n" + checks.String() + "    return 0;\n}\n")
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "byte-shuffle", ir, reference.String(), level)
+				})
+			}
+		})
+	}
+}
+
+const x86ByteShuffleReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+
+typedef void (*kernel)(uint8_t *, const uint8_t *, const uint8_t *,
+                       uint64_t *, uint32_t *, uint64_t, uint64_t);
+
+static int check(kernel fn, const char *name, int width, int legacy,
+                 int masking, int dst) {
+    _Alignas(64) uint8_t a[64], b[64], out[192], oldA[64], oldB[64];
+    const uint64_t masks[] = {0, UINT64_MAX, UINT64_C(0x5555555555555555), UINT64_C(1) << 63};
+    for (int sample = 0; sample < 256; ++sample) {
+        for (int i = 0; i < 64; ++i) {
+            a[i] = (uint8_t)(sample + i * 53);
+            b[i] = (uint8_t)(sample * 17 - i * 91);
+        }
+        memcpy(oldA, a, 64);
+        memcpy(oldB, b, 64);
+        for (int seedIndex = 0; seedIndex < 2; ++seedIndex) {
+            uint64_t seed = seedIndex ? 0x8d5 : 0;
+            for (unsigned mi = 0; mi < sizeof(masks)/sizeof(masks[0]); ++mi) {
+                uint64_t mask = masks[mi];
+                struct { uint64_t before, value, after; } flags = {11, 0, 13};
+                struct { uint32_t before, value, after; } csr = {17, 0, 19};
+                uint32_t initialCSR = _mm_getcsr();
+                memset(out, 0xa7, sizeof(out));
+                fn(out + 64, a, b, &flags.value, &csr.value, seed, mask);
+                if ((flags.value & 0x8d5) != seed || flags.before != 11 || flags.after != 13 ||
+                    csr.value != initialCSR || csr.before != 17 || csr.after != 19 ||
+                    memcmp(a, oldA, 64) || memcmp(b, oldB, 64)) {
+                    fprintf(stderr, "%s state/input/canary mismatch\n", name);
+                    return 1;
+                }
+                for (int i = 0; i < 192; ++i) {
+                    unsigned want = 0xa7;
+                    int offset = i - 64;
+                    if (offset >= 0 && offset < 64) {
+                        const uint8_t *old = dst == 0 ? a : b;
+                        want = legacy ? old[offset] : 0;
+                        if (offset < width) {
+                            if (!masking || ((mask >> offset) & 1)) {
+                                want = a[offset] & 0x80 ? 0 : b[(offset / 16) * 16 + (a[offset] & 15)];
+                            } else {
+                                want = masking == 2 ? 0 : old[offset];
+                            }
+                        }
+                    }
+                    if (out[i] != want) {
+                        fprintf(stderr, "%s sample=%d mask=%llx byte=%d got=%x want=%x\n",
+                                name, sample, (unsigned long long)mask, i, out[i], want);
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_carry_control.go b/amd64_carry_control.go
new file mode 100644
index 000000000..e75e5d16b
--- /dev/null
+++ b/amd64_carry_control.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86CarryControlSpec struct {
+	set, complement bool
+}
+
+// asm6.go's complete CLC/STC/CMC family is ynone/Px in both x86 modes.
+// Only CF changes; none of the other arithmetic flags or DF is defined here.
+var x86CarryControlSpecs = map[Op]x86CarryControlSpec{
+	"CLC": {}, "STC": {set: true}, "CMC": {complement: true},
+}
+
+func x86CarryControlProperties(op Op, ins Instr, arch string) (x86CarryControlSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86CarryControlSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 0 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s outside Go carry-control ynone grammar: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func x86TypedCarryControlByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86CarryControlProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{flagsKilled: x86ByteFlagCF, flagsDefined: x86ByteFlagCF}
+	if spec.complement {
+		effect.flagsRead = x86ByteFlagCF
+	}
+	return effect, true, nil
+}
diff --git a/amd64_clmul_definedness_test.go b/amd64_clmul_definedness_test.go
new file mode 100644
index 000000000..7eeaa7c00
--- /dev/null
+++ b/amd64_clmul_definedness_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86CLMULSelectedQwordResultBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, vector := range []bool{false, true} {
+			if arch == "386" && vector {
+				continue // Stock Go rejects the four-operand source form.
+			}
+			for _, immediate := range []int{0, 1, 16, 17, 238, 239, 254, 255} {
+				name, tail := "PCLMULQDQ", "X0,X1"
+				if vector {
+					name, tail = "VPCLMULQDQ", "X0,X1,X2"
+				}
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, name, immediate), func(t *testing.T) {
+					row := fmt.Sprintf("%s $%d,%s", name, immediate, tail)
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+					ins := x86ScalarLaneInstruction(t, row)
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagZF}
+					state.xmm[0] = uint16(255) << uint((immediate>>4&1)*8)
+					state.xmm[1] = uint16(255) << uint((immediate&1)*8)
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+						t.Fatal("complete selected qwords lack their registered result effect")
+					}
+					destination := 1
+					if vector {
+						destination = 2
+					}
+					if state.xmm[destination] != 0xffff || state.flags != x86ByteFlagCF|x86ByteFlagZF {
+						t.Fatal("carryless product did not define exactly the full X result while preserving flags")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CLMULMissingByteAndAliasEffects(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, legacy := range []bool{true, false} {
+			if legacy && bank != "X" {
+				continue
+			}
+			for immediate := 0; immediate < 256; immediate++ {
+				row := fmt.Sprintf("PCLMULQDQ $%d,X0,X1", immediate)
+				if !legacy {
+					row = fmt.Sprintf("VPCLMULQDQ $%d,%s0,%s1,%s2", immediate, bank, bank, bank)
+				}
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86CLMULProperties(ins.Op, ins, "amd64")
+				if !known || err != nil {
+					t.Fatal(err)
+				}
+				for missing := -1; missing < form.byteWidth; missing++ {
+					for source := 0; source < 2; source++ {
+						inputs := [2]uint64{^uint64(0), ^uint64(0)}
+						if missing >= 0 {
+							inputs[source] &^= uint64(1) << uint(missing)
+						}
+						state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": inputs[0], "Z1": inputs[1], "Z2": 1 << 60}}
+						if !x86CallerVectorMoveKnown(ins) || !x86CallerVectorMoveStep(&ins, &state, nil) {
+							t.Fatal("complete register effect is unregistered", row)
+						}
+						want := ^uint64(0)
+						if missing >= 0 {
+							selector := immediate & 1
+							if source == 0 {
+								selector = immediate >> 4 & 1
+							}
+							if missing%16/8 == selector {
+								want &^= uint64(65535) << uint(missing/16*16)
+							}
+						}
+						destination := Reg("Z2")
+						if legacy {
+							destination = "Z1"
+						}
+						if state.vectors[destination] != want {
+							t.Fatalf("%s missing %d operand %d got %016x want %016x", row, missing, source, state.vectors[destination], want)
+						}
+						result := x86ResultState{}
+						result.writeVector(0, 64, inputs[0], false)
+						result.writeVector(1, 64, inputs[1], false)
+						result.writeVector(2, 64, 1<<60, false)
+						if !x86ResultTransfer(ins, &result, nil, 0, "amd64") {
+							t.Fatal("partial known bytes lost the effect registration")
+						}
+						index := 2
+						if legacy {
+							index = 1
+						}
+						if result.vectorBytes(index) != want {
+							t.Fatal("caller/result complete numerical byte selectors differ", row)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86CLMULNoMemoryOrUnknownResultPermission(t *testing.T) {
+	for _, row := range []string{
+		"PCLMULQDQ $0,(AX),X1", "PCLMULQDQ $0,·data(SB),X1",
+		"VPCLMULQDQ $0,(AX),X1,X2", "VPCLMULQDQ $0,(AX),Y1,Y2", "VPCLMULQDQ $0,(AX),Z1,Z2",
+	} {
+		ins := x86ScalarLaneInstruction(t, row)
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z1": ^uint64(0)}}
+		if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &state, nil) || len(ins.x86CallerMemory) != 0 {
+			t.Fatal("shape or selected qword invented caller memory authority", row)
+		}
+		result := x86ResultState{pointerGP: [16]bool{true}}
+		result.xmm[1] = 0xffff
+		if x86ResultTransfer(ins, &result, nil, 0, "amd64") {
+			t.Fatal("pointer identity or SB spelling invented readable bytes", row)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, missing := range []int{0, 1, 2, 3} {
+			body := "MOVL $7,AX\n"
+			for lane := 0; lane < 4; lane++ {
+				if lane != missing {
+					body += fmt.Sprintf("PINSRD $%d,AX,X%d\n", lane%2, lane/2)
+				}
+			}
+			body += "PCLMULQDQ $0,X0,X1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a partially missing selected qword acquired numerical result bytes", arch, missing, err)
+			}
+		}
+	}
+}
+
+func TestX86CLMULScalarResultWholeSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, immediate := range []int{0, 1, 16, 17} {
+			t.Run(fmt.Sprintf("%s/%d", arch, immediate), func(t *testing.T) {
+				// Separate 32-bit insertions initialize only each selected qword;
+				// the opposite halves deliberately retain unknown input bytes.
+				body := "MOVL $7,AX\n"
+				for operand, selector := range []int{immediate >> 4 & 1, immediate & 1} {
+					for half := 0; half < 2; half++ {
+						body += fmt.Sprintf("PINSRD $%d,AX,X%d\n", selector*2+half, operand)
+					}
+				}
+				body += fmt.Sprintf("PCLMULQDQ $%d,X0,X1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET", immediate)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); err != nil {
+						t.Errorf("selected qword result failed: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_clmul_fault_runtime_test.go b/amd64_clmul_fault_runtime_test.go
new file mode 100644
index 000000000..9c528265b
--- /dev/null
+++ b/amd64_clmul_fault_runtime_test.go
@@ -0,0 +1,95 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86CLMULOriginalDeadReadFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, references, pairs strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, immediate := range []int{0, 1, 16, 17} {
+		name := fmt.Sprint("clmulfault", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ p+0(FP),AX\nPXOR X1,X1\nPCLMULQDQ $%d,(AX),X1\nRET\n", name, immediate)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+		code := x86OrderingHintGoBytes(t, "amd64", fmt.Sprintf("TEXT f(SB),4,$0-0\nPCLMULQDQ $%d,(DI),X1\nRET\n", immediate))
+		if len(code) != 7 || code[len(code)-1] != 0xc3 {
+			t.Fatal("original memory opcode or its RET changed", code)
+		}
+		var bytes []string
+		for _, value := range code[:len(code)-1] {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+		}
+		fmt.Fprintf(&references, "extern void %s(const void*);\nstatic void original%d(const void *p) {\n", name, index)
+		fmt.Fprintf(&references, "    __asm__ volatile(\"pxor %%%%xmm1, %%%%xmm1; .byte %s\"::\"D\"(p):\"xmm1\",\"memory\");\n}\n", strings.Join(bytes, ","))
+		if index > 0 {
+			pairs.WriteString(",")
+		}
+		fmt.Fprintf(&pairs, "{original%d,%s}", index, name)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + references.String() + `
+typedef void (*operation)(const void*);
+struct pair {operation original,translated;};
+static const struct pair pairs[]={ ` + pairs.String() + ` };
+static int outcome(operation fn,const void *p) {
+    pid_t pid=fork(); if(pid<0) return -1;
+    if(!pid) {
+        struct rlimit limit={0,0}; if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+        fn(p); _exit(0);
+    }
+    int status; if(waitpid(pid,&status,0)!=pid) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status)) return WTERMSIG(status);
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE); if(page<128) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    for(unsigned op=0;op<4;op++) for(unsigned extent=0;extent<=32;extent++) {
+        const void *p=region+page-extent;
+        int original=outcome(pairs[op].original,p),translated=outcome(pairs[op].translated,p);
+        if(original<0 || original!=translated || (extent==32 && original!=0) ||
+           (extent==0 && original!=SIGSEGV && original!=SIGBUS)) {
+            fprintf(stderr,"CLMUL selector=%u extent=%u original=%d translated=%d\n",op,extent,original,translated);
+            return 3;
+        }
+    }
+    for(unsigned op=0;op<4;op++) {
+        int original=outcome(pairs[op].original,0),translated=outcome(pairs[op].translated,0);
+        if(original!=translated || (original!=SIGSEGV && original!=SIGBUS)) return 4;
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "clmul-original-dead-faults", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_clmul_forms.go b/amd64_clmul_forms.go
new file mode 100644
index 000000000..89f116953
--- /dev/null
+++ b/amd64_clmul_forms.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's yxshuf and _yvpclmulqdq rows select one qword from each 128-bit
+// lane. The complete memory tuple is distinct from those numerical inputs.
+type x86CLMULForm struct {
+	legacy                    bool
+	byteWidth, source, second int
+	destination, memory       int
+	immediate                 uint8
+}
+
+func x86CLMULProperties(op Op, ins Instr, arch string) (x86CLMULForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	if name != "PCLMULQDQ" && name != "VPCLMULQDQ" {
+		return x86CLMULForm{}, false, nil
+	}
+	f := x86CLMULForm{legacy: name == "PCLMULQDQ", source: 1, second: 2, destination: 3, memory: -1}
+	if f.legacy {
+		f.destination = 2
+	}
+	fail := func() (x86CLMULForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go carryless-multiply grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) != f.destination+1 || arch == "386" && !f.legacy && !ins.x86Encoded {
+		return fail()
+	}
+	constant, valid := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !valid || !amd64UnsignedImmediate(constant, 8) {
+		return fail()
+	}
+	f.immediate = uint8(constant.Imm)
+	f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	if f.legacy && f.byteWidth != 16 || f.byteWidth != 16 && f.byteWidth != 32 && f.byteWidth != 64 {
+		return fail()
+	}
+	register := func(operand Operand) bool {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+		limit := 32
+		if f.legacy {
+			limit = 16
+		}
+		if arch == "386" {
+			limit = 8 // A physical raw binding is not a high-bank or named-frontend permission.
+		}
+		return operand.Kind == OpReg && valid && index < limit
+	}
+	if !register(ins.Args[f.second]) || !register(ins.Args[f.destination]) {
+		return fail()
+	}
+	source := ins.Args[f.source]
+	if register(source) {
+		return f, true, nil
+	}
+	if !isAMD64MemoryOperand(source) || !x86PackedShiftMemoryValid(source, arch) {
+		return fail()
+	}
+	if source.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+			return f, true, err
+		}
+		if source.Mem.OffRaw != "" || source.Mem.IndexExt != "" {
+			return fail()
+		}
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return f, true, fmt.Errorf("%w: carryless multiply has no bound native address-size override", ErrProbeNeedsContext)
+	}
+	f.memory = f.source
+	return f, true, nil
+}
+
+func x86TypedLegacyCLMULByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86CLMULProperties(op, ins, arch)
+	if !known || err != nil || !form.legacy {
+		return x86TypedByteEffect{}, known && (err != nil || form.legacy), err
+	}
+	return x86CLMULDependencyEffect(ins, form), true, nil
+}
+
+func x86CLMULDependencyEffect(ins Instr, form x86CLMULForm) x86TypedByteEffect {
+	binary := x86PackedBinaryForm{
+		byteWidth: form.byteWidth, first: form.source, second: form.second, destination: form.destination,
+		legacy: form.legacy, mask: -1, memory: form.memory, memoryBytes: form.byteWidth,
+	}
+	effect := x86PackedBinaryDependencyEffect(ins, binary, ins.Args[form.source])
+	source, second := x86CLMULSelectedBytes(form)
+	if ins.Args[form.source].Kind == OpReg {
+		effect.operands[0].requiredBytes = source
+	}
+	effect.operands[1].requiredBytes = second
+	return effect
+}
+
+// Selection controls numerical register inputs, never the physical memory
+// tuple. Each lane consumes one qword from each of the two source operands.
+func x86CLMULSelectedBytes(f x86CLMULForm) (source, second uint64) {
+	for lane := 0; lane < f.byteWidth; lane += 16 {
+		source |= uint64(255) << uint(lane+int(f.immediate>>4&1)*8)
+		second |= uint64(255) << uint(lane+int(f.immediate&1)*8)
+	}
+	return
+}
+
+// Each product requires all bytes of exactly two selected qwords. No mask,
+// unselected qword, destination alias or numerical zero supplies a missing input.
+func x86CLMULDefinedBytes(f x86CLMULForm, source, second uint64) uint64 {
+	var known uint64
+	sourceBytes, secondBytes := x86CLMULSelectedBytes(f)
+	for lane := 0; lane < f.byteWidth; lane += 16 {
+		laneMask := uint64(65535) << uint(lane)
+		sourceMask, secondMask := sourceBytes&laneMask, secondBytes&laneMask
+		if source&sourceMask == sourceMask && second&secondMask == secondMask {
+			known |= laneMask
+		}
+	}
+	return known
+}
+
+func x86ResultCLMULStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	f, known, err := x86CLMULProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	return x86ResultCLMULTransfer(ins, f, state, owned, arch, false)
+}
+
+// Keep the complete captured form across a source-local provenance projection.
+// Memory always consumes the original full tuple; numerical availability still
+// depends only on the two selected qwords of each independent 128-bit lane.
+func x86ResultCLMULTransfer(ins Instr, f x86CLMULForm, state *x86ResultState,
+	owned []bool, arch string, nativeRead bool) (bool, bool) {
+	source := x86CallerVectorByteMask(int64(f.byteWidth))
+	if f.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[f.memory], int64(f.byteWidth), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[f.source].Reg, f.byteWidth)
+		source = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[f.second].Reg, f.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	state.writeVector(destination, f.byteWidth, x86CLMULDefinedBytes(f, source, state.vectorBytes(second)), f.legacy)
+	return true, true
+}
+
+func x86CallerCLMULStep(ins Instr, f x86CLMULForm, state *x86SourceStackState) bool {
+	if f.memory >= 0 {
+		return false // A registered byte effect grants no new native read proof.
+	}
+	source := state.vectors[x86CallerVectorRoot(ins.Args[f.source].Reg)]
+	second := state.vectors[x86CallerVectorRoot(ins.Args[f.second].Reg)]
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	width := x86CallerVectorByteMask(int64(f.byteWidth))
+	known := x86CLMULDefinedBytes(f, source, second)
+	if f.legacy {
+		state.vectors[destination] = state.vectors[destination]&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_clmul_forms_test.go b/amd64_clmul_forms_test.go
new file mode 100644
index 000000000..17e874bc4
--- /dev/null
+++ b/amd64_clmul_forms_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86CLMULIndependentCompleteGoRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "{APCLMULQDQ, yxshuf, Pq, opBytes{0x3a, 0x44, 0}}") {
+		t.Fatal("complete Go legacy prefix/map/opcode/offset changed")
+	}
+	start := strings.Index(string(legacy), "var yxshuf = []ytab{")
+	if start < 0 {
+		t.Fatal("Go omitted yxshuf")
+	}
+	actual := strings.SplitN(string(legacy)[start:], "\n}", 2)[0]
+	actual = strings.SplitN(actual, "[]ytab{", 2)[1]
+	if strings.Join(strings.Fields(actual), " ") != "{Zibm_r, 2, argList{Yu8, Yxm, Yxr}}," {
+		t.Fatal("complete Go legacy classes/zcase/zoffset changed", actual)
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := []string{
+		"Yu8,Yxm,Yxr,Yxr", "Yu8,Yym,Yyr,Yyr",
+		"Yu8,YxmEvex,YxrEvex,YxrEvex", "Yu8,YymEvex,YyrEvex,YyrEvex", "Yu8,Yzm,Yzr,Yzr",
+	}
+	opbytes := []string{
+		"avxEscape | vex128 | vex66 | vex0F3A | vexW0", "0x44",
+		"avxEscape | vex256 | vex66 | vex0F3A | vexW0", "0x44",
+		"avxEscape | evex128 | evex66 | evex0F3A | evexW0", "evexN16", "0x44",
+		"avxEscape | evex256 | evex66 | evex0F3A | evexW0", "evexN32", "0x44",
+		"avxEscape | evex512 | evex66 | evex0F3A | evexW0", "evexN64", "0x44",
+	}
+	count := 0
+	for _, rule := range rules {
+		if rule.Opcode != "VPCLMULQDQ" {
+			continue
+		}
+		zcase := "Zevex_i_rm_v_r"
+		if count < 2 {
+			zcase = "Zvex_i_rm_v_r"
+		}
+		if count >= 5 || rule.RowIndex != count || rule.Ytab != "_yvpclmulqdq" || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != []int{2, 2, 3, 3, 3}[count] ||
+			rule.EncodingOffset != []int{0, 2, 4, 7, 10}[count] ||
+			strings.Join(rule.Classes, ",") != classes[count] || !reflect.DeepEqual(rule.OpBytes, opbytes) {
+			t.Fatal("complete independent Go vector row changed", rule)
+		}
+		count++
+	}
+	if count != 5 {
+		t.Fatal("incomplete vector family", count)
+	}
+}
+
+func x86CLMULIndependentRows(arch string) []string {
+	var rows []string
+	limit := 16
+	if arch == "386" {
+		limit = 8
+	}
+	for immediate := 0; immediate < 256; immediate++ {
+		rows = append(rows, fmt.Sprintf("PCLMULQDQ $%d,X0,X1", immediate))
+	}
+	for index := 0; index < limit; index++ {
+		rows = append(rows, fmt.Sprintf("PCLMULQDQ $17,X%d,X1", index), fmt.Sprintf("PCLMULQDQ $17,X0,X%d", index))
+	}
+	for _, memory := range []string{"(AX)", "16(BX)(CX*2)", "value+0(FP)", "local-16(SP)", "·data(SB)", "(FS)", "(GS)"} {
+		rows = append(rows, "PCLMULQDQ $255,"+memory+",X1")
+	}
+	if arch == "386" {
+		// cmd/asm classifies TYPE_CONST after mode32 signed truncation.
+		rows = append(rows, "PCLMULQDQ $4294967296,X0,X1", "PCLMULQDQ $4294967551,X0,X1")
+		return rows
+	}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for immediate := 0; immediate < 256; immediate++ {
+			rows = append(rows, fmt.Sprintf("VPCLMULQDQ $%d,%s0,%s1,%s2", immediate, bank, bank, bank))
+		}
+		for index := 0; index < 32; index++ {
+			for operand := 0; operand < 3; operand++ {
+				registers := []string{bank + "0", bank + "1", bank + "2"}
+				registers[operand] = fmt.Sprintf("%s%d", bank, index)
+				rows = append(rows, "VPCLMULQDQ $255,"+strings.Join(registers, ","))
+			}
+		}
+		for _, memory := range []string{"(AX)", "16(BX)(CX*2)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, "VPCLMULQDQ $17,"+memory+","+bank+"1,"+bank+"2")
+		}
+	}
+	return rows
+}
+
+func TestX86CLMULCompleteGoOperandAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86CLMULIndependentRows(arch)
+			var source strings.Builder
+			for index, row := range rows {
+				fmt.Fprintf(&source, "TEXT f%d(SB),4,$64-64\n%s\nRET\n", index, row)
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, fn := range file.Funcs {
+				ins := fn.Instrs[1]
+				before := fmt.Sprintf("%#v", ins)
+				form, known, err := x86CLMULProperties(ins.Op, ins, arch)
+				if !known || err != nil {
+					t.Fatal(rows[index], err)
+				}
+				for operand := range ins.Args {
+					width, write, memory := x86InstructionMemoryShape(ins, operand, arch)
+					if memory != (operand == form.memory) || memory && (write || width != int64(form.byteWidth)) {
+						t.Fatal("native tuple differs from complete operand form", rows[index], operand, width, write, memory)
+					}
+					if ins.Args[operand].Kind == OpFP {
+						width, write, known := X86FPAccessBytes(ins, operand, arch)
+						if !known || write || width != int64(form.byteWidth) {
+							t.Fatal("FP diagnostic lost full native tuple", rows[index], width, write, known)
+						}
+					}
+				}
+				if fmt.Sprintf("%#v", ins) != before {
+					t.Fatal("grammar changed its original source")
+				}
+			}
+			t.Logf("%d complete independent Go forms accepted", len(rows))
+		})
+	}
+}
+
+func TestX86CLMULInvalidGrammarAndPrivateBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := []string{
+			"PCLMULQDQ $-1,X0,X1", "PCLMULQDQ $256,X0,X1", "PCLMULQDQ $1.5,X0,X1",
+			"PCLMULQDQ $1,X16,X0", "PCLMULQDQ $1,Y0,Y1", "PCLMULQDQ $1,M0,M1",
+			"PCLMULQDQ.Z $1,X0,X1", "PCLMULQDQ $1,X0,(AX)", "PCLMULQDQ $1,X0",
+			"VPCLMULQDQ $-1,X0,X1,X2", "VPCLMULQDQ $256,X0,X1,X2",
+			"VPCLMULQDQ.Z $1,X0,X1,X2", "VPCLMULQDQ.BCST $1,(AX),X1,X2",
+			"VPCLMULQDQ $1,X0,Y1,Y2", "VPCLMULQDQ $1,X0,X1,K1,X2",
+			"VPCLMULQDQ $1,X0,(AX),X2", "VPCLMULQDQ $1,X0,X1,(AX)",
+		}
+		if arch == "386" {
+			rows = append(rows, "PCLMULQDQ $1,X8,X0", "VPCLMULQDQ $1,X0,X1,X2", "VPCLMULQDQ $1,Z0,Z1,Z2")
+		}
+		for _, row := range rows {
+			goAssemblerOracleOutput(t, arch, "TEXT ·invalid(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86CLMULProperties(ins.Op, ins, arch); !known || err == nil {
+				t.Error("unbound grammar accepted", arch, row)
+			}
+		}
+	}
+	for _, mutation := range []string{"float", "unresolved", "dispatch", "address-size", "unknown-displacement", "unknown-index"} {
+		ins := x86ScalarLaneInstruction(t, "PCLMULQDQ $1,(AX),X1")
+		op := ins.Op
+		switch mutation {
+		case "float":
+			ins.Args[0].ImmIsFloat = true
+		case "unresolved":
+			ins.Args[0].ImmRaw = "missing"
+		case "dispatch":
+			ins.Op = "AESENC"
+		case "address-size":
+			ins.x86AddressBits = 32
+		case "unknown-displacement":
+			ins.Args[1].Mem.OffRaw = "missing"
+		case "unknown-index":
+			ins.Args[1].Mem.IndexExt = "unknown"
+		}
+		if _, known, err := x86CLMULProperties(op, ins, "amd64"); !known || err == nil {
+			t.Error("constructed source bypassed complete grammar", mutation)
+		}
+	}
+}
diff --git a/amd64_clmul_objects_test.go b/amd64_clmul_objects_test.go
new file mode 100644
index 000000000..03cd91c16
--- /dev/null
+++ b/amd64_clmul_objects_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86CLMULThreeAPIFiveTargetResultObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, vector := range []bool{false, true} {
+				if target.arch == "386" && vector {
+					continue // Source mode, independently checked against Go.
+				}
+				for _, selector := range []int{0, 1, 16, 17} {
+					var body strings.Builder
+					body.WriteString("MOVL a+0(FP),AX\nMOVL b+4(FP),BX\n")
+					for half := 0; half < 2; half++ {
+						fmt.Fprintf(&body, "PINSRD $%d,AX,X0\nPINSRD $%d,BX,X1\n", (selector>>4&1)*2+half, (selector&1)*2+half)
+					}
+					if vector {
+						fmt.Fprintf(&body, "VPCLMULQDQ $%d,X0,X1,X2\nPEXTRD $0,X2,AX\n", selector)
+					} else {
+						fmt.Fprintf(&body, "PCLMULQDQ $%d,X0,X1\nPEXTRD $0,X1,AX\n", selector)
+					}
+					source := "TEXT ·view(SB),4,$0-12\n" + body.String() + "MOVL AX,ret+8(FP)\nRET\n"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a,b uint32) uint32\n", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal(api, vector, selector, err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "clmul-result.ll", "clmul-result.o", ir)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_clmul_runtime_test.go b/amd64_clmul_runtime_test.go
new file mode 100644
index 000000000..2d6357b83
--- /dev/null
+++ b/amd64_clmul_runtime_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Polynomial long multiplication is independent of the production selectors,
+// descriptors and LLVM intrinsic. Both input qwords and both output qwords are
+// observed, including the otherwise ignored immediate bits.
+const x86CLMULIndependentC = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+static void product(uint64_t a,uint64_t b,uint64_t *out) {
+    uint64_t lo=0,hi=0;
+    for(unsigned bit=0;bit<64;bit++) {
+        if((b>>bit)&1) {
+            lo^=a<<bit;
+            if(bit) hi^=a>>(64-bit);
+        }
+    }
+    out[0]=lo; out[1]=hi;
+}
+static const uint64_t edges[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+    UINT64_C(0x123456789abcdef0),UINT64_C(0xfedcba9876543210),
+    UINT64_C(0x1111111111111111),UINT64_C(0xaaaaaaaaaaaaaaaa)};
+struct Buffer {_Alignas(64) uint8_t before[64],value[80],after[64];};
+typedef void (*Program)(uint8_t*,const uint8_t*,const uint8_t*);
+static int check(Program program,const char *name,unsigned width,int legacy,int selector,int alias) {
+    for(unsigned sample=0;sample<73;sample++) {
+        struct Buffer a,b,out;
+        memset(&a,0xa7,sizeof(a)); memset(&b,0xb9,sizeof(b)); memset(&out,0xc3,sizeof(out));
+        for(unsigned word=0;word<8;word++) {
+            uint64_t av=edges[(sample+word)%8],bv=edges[(sample/8+word*3)%8];
+            if(sample>=64) {av^=(uint64_t)sample*713781;bv^=(uint64_t)sample*391531;}
+            memcpy(a.value+word*8,&av,8); memcpy(b.value+word*8,&bv,8);
+        }
+        struct Buffer originalA=a,originalB=b,want=out;
+        for(unsigned lane=0;lane<width;lane+=16) {
+            uint64_t av,bv,pair[2];
+            memcpy(&av,(alias==3?b.value:a.value)+lane+((selector>>4)&1)*8,8);
+            memcpy(&bv,b.value+lane+(selector&1)*8,8);
+            product(bv,av,pair); memcpy(want.value+lane,pair,16);
+        }
+        memcpy(want.value+width,legacy?b.value+width:(uint8_t[64]){0},64-width);
+        want.value[64]=1; want.value[65]=0;
+        unsigned saved=_mm_getcsr(),profile=0x1f80|((sample%4)<<13)|(sample%64);
+        memcpy(want.value+68,&profile,4); _mm_setcsr(profile);
+        program(out.value,a.value,b.value); unsigned after=_mm_getcsr(); _mm_setcsr(saved);
+        if(after!=profile||memcmp(&a,&originalA,sizeof(a))||memcmp(&b,&originalB,sizeof(b))||memcmp(&out,&want,sizeof(out))) {
+            for(unsigned i=0;i<sizeof(out);i++) if(((uint8_t*)&out)[i]!=((uint8_t*)&want)[i])
+                fprintf(stderr,"%s sample=%u byte=%u got=%x want=%x\n",name,sample,i,((uint8_t*)&out)[i],((uint8_t*)&want)[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86CLMULCompleteBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, kind := range []string{"legacy", "X", "Y", "Z"} {
+		legacy := kind == "legacy"
+		bank, width := kind, 16
+		if legacy {
+			bank = "X"
+		} else if bank == "Y" {
+			width = 32
+		} else if bank == "Z" {
+			width = 64
+		}
+		for _, selector := range []int{0, 1, 16, 17, 238, 255} {
+			for _, alias := range []int{0, 1, 2, 3, 4} {
+				if legacy && (alias == 1 || alias == 2) {
+					continue
+				}
+				name := fmt.Sprint("clmulbytes", count)
+				count++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\n", name)
+				source.WriteString("VMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nCMPQ AX,AX\nSTC\n")
+				first, second, destination := bank+"0", bank+"1", bank+"2"
+				if alias == 1 {
+					destination = first
+				} else if alias == 2 {
+					destination = second
+				} else if alias == 3 {
+					first = second
+				} else if alias == 4 {
+					first = "(BX)"
+				}
+				if legacy {
+					destination = "X1"
+					fmt.Fprintf(&source, "PCLMULQDQ $%d,%s,%s\n", selector, first, destination)
+				} else {
+					fmt.Fprintf(&source, "VPCLMULQDQ $%d,%s,%s,%s\n", selector, first, second, destination)
+				}
+				fmt.Fprintf(&source, "VMOVUPS Z%s,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nSTMXCSR 68(AX)\nRET\n", destination[1:])
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					}}}
+				fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*);\n", name)
+				fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,%d,%d)) return 1;\n", name, kind+fmt.Sprint(selector, "/", alias), width, x86FloatAddSubBoolInt(legacy), selector, alias)
+			}
+		}
+	}
+	if count != 108 {
+		t.Fatal("complete independent runtime denominator changed", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := x86CLMULIndependentC + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "clmul-complete-bytes", triple, text, oracle, prefix)
+		})
+	}
+	t.Log("108 kernels x 73 inputs, full aliases/flags/MXCSR/canaries; portable LLVM wide semantics, not native AVX512 execution")
+}
+
+func TestCrossLinuxRuntimeMatrixX86CLMULOriginalGo(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var functions, checks strings.Builder
+	count := 0
+	for _, immediate := range []int{0, 1, 16, 17, 238, 255} {
+		for _, alias := range []int{0, 3, 4} {
+			source := "X0"
+			if alias == 3 {
+				source = "X1"
+			} else if alias == 4 {
+				source = "(AX)"
+			}
+			row := fmt.Sprintf("PCLMULQDQ $%d,%s,X1", immediate, source)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if len(code) != 7 || code[len(code)-1] != 0xc3 {
+				t.Fatal("actual Go object differs from one legacy instruction plus RET", row, code)
+			}
+			var bytes []string
+			for _, value := range code[:len(code)-1] {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+			}
+			name := fmt.Sprint("original", count)
+			count++
+			assembly := "movdqu (%%rax), %%xmm0\n\tmovdqu (%%rsi), %%xmm1\n\tcmpq %%rax, %%rax\n\tstc\n\t.byte " + strings.Join(bytes, ",") +
+				"\n\tmovdqu %%xmm1, (%%rdi)\n\tsetc 64(%%rdi)\n\tsetne 65(%%rdi)\n\tstmxcsr 68(%%rdi)"
+			fmt.Fprintf(&functions, `static void %s(uint8_t *out,const uint8_t *a,const uint8_t *b) {
+    memcpy(out+16,b+16,48);
+    __asm__ volatile(%q::"a"(a),"S"(b),"D"(out):"xmm0","xmm1","cc","memory");
+}
+`, name, assembly)
+			fmt.Fprintf(&checks, "if(check(%s,%q,16,1,%d,%d)) return 1;\n", name, row, immediate, alias)
+		}
+	}
+	oracle := x86CLMULIndependentC + functions.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	execution.compileAndRunLLVM(t, "clmul-original-go", "define void @unused() { ret void }\n", oracle, "-O2")
+	t.Log("18 actual original Go legacy encodings x 73 numerical/FLAGS/MXCSR samples; native X results, not original wide-register execution")
+}
diff --git a/amd64_cmov_effects_test.go b/amd64_cmov_effects_test.go
new file mode 100644
index 000000000..245389f59
--- /dev/null
+++ b/amd64_cmov_effects_test.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86CMOVFamilyIndependentCallerSourceEffect(t *testing.T) {
+	for _, row := range []string{"CMOVWCC BX,AX", "CMOVLLE BX,AX", "CMOVQPS BX,AX", "CMOVLLE (DI),AX"} {
+		t.Run(row, func(t *testing.T) {
+			body := "MOVQ $9,BX\nCMPQ AX,BX\n" + row + "\nMOVL AX,(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal("actual-Go conditional move has no complete caller source effect", err)
+			}
+		})
+	}
+}
+
+func TestX86CMOVFamilyCompleteCallerAndPotentialInputGuards(t *testing.T) {
+	for _, name := range x86CMOVOracleNames("amd64") {
+		for _, test := range []struct {
+			label, body string
+			valid       bool
+		}{
+			{"register", "MOVQ $9,BX\nCMPQ AX,BX\n" + name + " BX,AX", true},
+			{"self", "CMPQ AX,AX\n" + name + " AX,AX", true},
+			{"readonly-memory", "CMPQ AX,AX\n" + name + " (DI),AX", true},
+			{"undefined-source", "CMPQ AX,AX\n" + name + " BX,AX", false},
+			{"undefined-old-target", "CMPQ AX,AX\n" + name + " AX,BX", false},
+			{"incoming-pointer-source", "CMPQ AX,AX\n" + name + " DI,AX", false},
+			{"incoming-pointer-target", "CMPQ AX,AX\n" + name + " AX,DI", false},
+			{"pointer-flags", "CMPQ DI,DI\n" + name + " AX,AX", false},
+			{"unknown-flags", name + " AX,AX", false},
+			{"unknown-memory-pointer", "CMPQ AX,AX\n" + name + " (R8),AX", false},
+			{"stack-register-source", "CMPQ AX,AX\n" + name + " SP,AX", false},
+			{"frame-register-target", "CMPQ AX,AX\n" + name + " AX,BP", false},
+			{"incoming-g", "CMPQ AX,AX\n" + name + " R14,AX", false},
+		} {
+			t.Run(name+"/"+test.label, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", test.body+"\nMOVL AX,(DX)", 1)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+				if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("potential source/old-target/flags or permission boundary", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CMOVFamilyCompleteResultPotentialBytes(t *testing.T) {
+	for _, name := range x86CMOVOracleNames("amd64") {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[name[4]]
+		for _, source := range []string{"AX", "x+0(FP)"} {
+			body := "MOVQ x+0(FP),AX\nMOVQ $9,BX\nCMPQ AX,BX\n" + name + " " + source + ",BX\nMOVQ BX,ret0+8(FP)\nRET"
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint64", body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatal("complete result family", name, source, err)
+			}
+		}
+		for _, input := range []Reg{AX, BX} {
+			for missing := 0; missing < 8; missing++ {
+				t.Run(fmt.Sprintf("%s/%s/missing%d", name, input, missing), func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+name+" AX,BX\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					effect, known, err := x86TypedInstructionByteEffect(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], "amd64")
+					if !known || err != nil {
+						t.Fatal(err)
+					}
+					state := x86SourceStackState{numericFlags: true, known: map[Reg]uint8{AX: 0xff, BX: 0xff}, callers: map[Reg]x86CallerPointerValue{}}
+					state.known[input] &^= 1 << uint(missing)
+					before := state.known[input]
+					_, valid := x86CallerConditionalMoveStep(&file.Funcs[0].Instrs[1], &state, nil)
+					if valid != (missing >= width) {
+						t.Fatal("each potential byte must exist, regardless of predicate", valid, width, effect)
+					}
+					if !valid && state.known[input] != before {
+						t.Fatal("failed proof washed unknown bytes")
+					}
+					result := x86ResultState{flags: x86ByteFlagsAll}
+					result.gp[0], result.gp[3] = 0xff, 0xff
+					index := 0
+					if input == BX {
+						index = 3
+					}
+					result.gp[index] &^= 1 << uint(missing)
+					beforeResult := result
+					validResult := x86ResultTransfer(file.Funcs[0].Instrs[1], &result, nil, 0, "amd64")
+					if validResult != (missing >= width) || !validResult && !reflect.DeepEqual(result, beforeResult) {
+						t.Fatal("result observer borrowed potential undefined bytes or mutated a failed proof", validResult)
+					}
+					if validResult && width == 4 && result.gp[3] != 0xff {
+						t.Fatal("L false-or-true writes did not define upper zero bytes")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyExactRequiredFlagsAndUnconditionalFrameBytes(t *testing.T) {
+	for _, name := range x86CMOVOracleNames("amd64") {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[name[4]]
+		for _, source := range []string{"AX", "x+0(FP)", "local-8(SP)"} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$8-8\n"+name+" "+source+",BX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			flags := uint8(0)
+			for _, condition := range x86CMOVOracleConditions {
+				if strings.HasSuffix(name, condition.name) {
+					flags = condition.flags
+				}
+			}
+			for bit := uint8(1); bit <= x86ByteFlagOF; bit <<= 1 {
+				state := x86ResultState{flags: x86ByteFlagsAll &^ bit, fp: make([]bool, 8), auto: make([]bool, 8)}
+				state.gp[0], state.gp[3] = 0xff, 0xff
+				owned := make([]bool, 8)
+				for index := 0; index < 8; index++ {
+					state.fp[index], state.auto[index], owned[index] = true, true, true
+				}
+				valid := x86ResultTransfer(ins, &state, owned, 8, "amd64")
+				if valid != (flags&bit == 0) || valid && state.flags != x86ByteFlagsAll&^bit {
+					t.Fatal("CMOV exact flag dependency/preservation", name, source, bit, valid)
+				}
+			}
+			if source == "AX" {
+				continue
+			}
+			for missing := 0; missing < 8; missing++ {
+				state := x86ResultState{flags: x86ByteFlagsAll, fp: make([]bool, 8), auto: make([]bool, 8)}
+				state.gp[0], state.gp[3] = 0xff, 0xff
+				owned := make([]bool, 8)
+				for index := 0; index < 8; index++ {
+					state.fp[index], state.auto[index], owned[index] = true, true, true
+				}
+				state.fp[missing], state.auto[missing] = false, false
+				if valid := x86ResultTransfer(ins, &state, owned, 8, "amd64"); valid != (missing >= width) {
+					t.Fatal("CMOV condition cannot suppress a missing FP/AUTO source byte", name, source, missing, valid)
+				}
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyCountedComparisonVersionGuards(t *testing.T) {
+	base := x86CallerCountedLoopScalarAssembly(false)
+	for _, destination := range []string{"BX", "CX", "AX"} {
+		t.Run(destination, func(t *testing.T) {
+			assembly := strings.Replace(base, "CMPL CX,AX\nJNE again", "CMPL CX,AX\nCMOVLLE R11,"+destination+"\nJNE again", 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("CMOV relaxed the exact adjacent comparison/latch or retained a stale counter/bound version", destination, err)
+			}
+		})
+	}
+}
+
+func TestX86CMOVFamilyCountedNumberObserver(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\nCMOVLLE BX,AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	flags := x86CallerCountedFlags{pc: 7, op: "CMPL", known: true, equal: true}
+	facts := x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{
+		AX: {version: 2, value: 17, known: true}, BX: {version: 3, value: 23, known: true},
+	}, flags: flags, source: -1}
+	facts.step(8, 0, file.Funcs[0].Instrs[1], x86SourceStackState{}, nil)
+	if facts.flags != flags {
+		t.Fatal("CMOV changed existing numerical flag facts", facts.flags)
+	}
+	if _, retained := facts.regs[AX]; retained {
+		t.Fatal("CMOV invented an unconditional selected numerical value or retained a stale target version")
+	}
+	if !facts.regs[BX].known || facts.regs[BX].version != 3 {
+		t.Fatal("CMOV erased its unchanged source version")
+	}
+}
+
+func TestX86CMOVFamilyIndependentResultByteEffect(t *testing.T) {
+	for _, row := range []string{"CMOVWCC AX,BX", "CMOVLLE AX,BX", "CMOVQPS AX,BX", "CMOVLLE AX,AX"} {
+		t.Run(row, func(t *testing.T) {
+			result := "BX"
+			if row == "CMOVLLE AX,AX" {
+				result = "AX"
+			}
+			body := "MOVQ x+0(FP),AX\nMOVQ $9,BX\nCMPQ AX,BX\n" + row + "\nMOVQ " + result + ",ret0+8(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint64", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatal("actual-Go conditional move has no complete result byte effect", err)
+			}
+		})
+	}
+}
+
+func TestX86CMOVFamilyIndependentDeadNativeRead(t *testing.T) {
+	for _, row := range []string{"CMOVWCC (DI),BX", "CMOVLLE (DI),BX", "CMOVQPS (DI),BX"} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT ·Dead(SB),4,$0-0\nMOVQ $7,AX\nMOVQ $9,BX\nCMPQ AX,BX\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Dead()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original uninitialized DI acquired native memory permission", api, err)
+				}
+			}
+			initialized := strings.Replace(source, "$0-0\n", "$0-8\nMOVQ p+0(FP),DI\n", 1)
+			goAssemblerOracleOutput(t, "amd64", initialized, "", true)
+			ir := x86NarrowOracleIR(t, initialized, "package cmov\nfunc Dead(p *byte)\n", "x86_64-unknown-linux-gnu")
+			optimized := x86DwordProductIROptimize(t, ir)
+			t.Logf("original loads=%t; actual IR default<O2> retains any read=%t", strings.Contains(ir, " = load "), strings.Contains(optimized, " = load "))
+			if !strings.Contains(ir, "load volatile") || !strings.Contains(optimized, "load volatile") {
+				t.Fatal("unconditional source read can disappear with a dead CMOV result under real IR default<O2>")
+			}
+		})
+	}
+}
+
+func TestX86CMOVFamilyExactSourceMemoryCertificates(t *testing.T) {
+	for _, name := range x86CMOVOracleNames("amd64") {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "CMPQ AX,AX\n"+name+" (DI),AX\nMOVL AX,(DX)", 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			if ins.Op != Op(name) {
+				continue
+			}
+			found = true
+			access, exists := ins.x86CallerMemory[0]
+			width := map[byte]int64{'W': 2, 'L': 4, 'Q': 8}[name[4]]
+			if !exists || access.width != width || access.write || !x86CallerMemoryCertified(ins, 0) {
+				t.Fatal("false condition shrank or omitted native source read", name, access)
+			}
+			for _, mutation := range []string{"opcode", "width", "direction", "offset", "destination", "source", "address-size", "segment"} {
+				changed, certificate := ins, access
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.x86CallerMemory = map[int]x86CallerMemoryAccess{0: access}
+				switch mutation {
+				case "opcode":
+					changed.Op = "CMOV" + Op(string(name[4])) + "CS"
+					if changed.Op == ins.Op {
+						changed.Op = "CMOV" + Op(string(name[4])) + "CC"
+					}
+				case "width":
+					certificate.width--
+					changed.x86CallerMemory[0] = certificate
+				case "direction":
+					certificate.write = true
+					changed.x86CallerMemory[0] = certificate
+				case "offset":
+					changed.Args[0].Mem.Off++
+				case "destination":
+					changed.Args[1].Reg = BX
+				case "source":
+					changed.Args[0].Mem.Base = SI
+				case "address-size":
+					changed.x86AddressBits = 32
+				case "segment":
+					changed.Args[0].Mem.Segment = FS
+				}
+				if x86CallerMemoryCertified(changed, 0) {
+					t.Fatal("stale source or native extent survived", name, mutation)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("source normalization omitted family instruction", name)
+		}
+	}
+}
diff --git a/amd64_cmov_fault_runtime_unix_test.go b/amd64_cmov_fault_runtime_unix_test.go
new file mode 100644
index 000000000..127eb792b
--- /dev/null
+++ b/amd64_cmov_fault_runtime_unix_test.go
@@ -0,0 +1,117 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86CMOVUnconditionalFaultEnvelopes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, prototypes, originals, rows strings.Builder
+	declarations.WriteString("package faultoracle\n")
+	count := 0
+	for _, width := range []string{"W", "L", "Q"} {
+		for condition, row := range x86CMOVOracleConditions {
+			for _, dead := range []bool{false, true} {
+				fn := fmt.Sprintf("F%d", count)
+				count++
+				name := "CMOV" + width + row.name
+				store, nativeStore := "MOVQ out+16(FP),DX\nMOVQ BX,(DX)\n", "MOVQ AX,(DX)\n"
+				if dead {
+					store, nativeStore = "", ""
+				}
+				fmt.Fprintf(&declarations, "func %s(p *[8]byte,seed uint64,out *uint64)\n", fn)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-24\nMOVQ p+0(FP),DI\nMOVQ seed+8(FP),AX\nMOVQ $0x87654321fedcba98,BX\nPUSHQ AX\nPOPFQ\n%s (DI),BX\n%sRET\n", fn, name, store)
+				original := "Original" + fn
+				actual := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\nMOVQ $0x87654321fedcba98,AX\nPUSHQ SI\nPOPFQ\n"+name+" (DI),AX\n"+nativeStore+"RET\n")
+				var bytes []string
+				for _, value := range actual {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+				}
+				symbol := original
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint64_t,uint64_t*);\nextern void %s(const uint8_t*,uint64_t,uint64_t*);\n", fn, original)
+				fmt.Fprintf(&rows, "{%s,%s,%d,%d},\n", fn, original, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition)
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	reference := fmt.Sprintf(x86CMOVFaultC, prototypes.String(), originals.String(), rows.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmov-fault", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("cmov live/dead kernels %d translated/original fault outcomes %d false/live/dead tripwires 4 failures 0\n", count, count*2*7*2)
+			if string(output) != want {
+				t.Fatal("unconditional exact-width source fault disagreement", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+const x86CMOVFaultC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+` + x86CMOVConditionC + `
+%s
+%s
+typedef void(*Program)(const uint8_t*,uint64_t,uint64_t*);
+typedef struct {Program translated,original;unsigned width,condition;} Kernel;
+static Kernel kernels[]={%s};
+static int observe(Program p,unsigned width,unsigned address,uint64_t flags) {
+ pid_t child=fork();if(child<0) return -1;
+ if(child==0) {
+  struct rlimit no_core={0,0};if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+  uint8_t data[16];memset(data,0xa7,sizeof(data));const uint8_t *input=data;
+  if(address==1) input++;
+  if(address==2) input=NULL;
+  if(address>=3) {
+   long page=sysconf(_SC_PAGESIZE);if(page<=0) _exit(121);
+   uint8_t *memory=mmap(NULL,2*(size_t)page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+   if(memory==MAP_FAILED) _exit(122);
+   memset(memory,0xa7,(size_t)page);
+   if(mprotect(memory+page,(size_t)page,PROT_NONE)) _exit(123);
+   unsigned available[]={0,width-1,width,width+1};input=memory+page-available[address-3];
+  }
+  uint64_t out=0;p(input,flags,&out);_exit(0);
+ }
+ int status=0;if(waitpid(child,&status,0)!=child) return -2;
+ if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+ if(WIFSIGNALED(status)&&(WTERMSIG(status)==SIGSEGV||WTERMSIG(status)==SIGBUS)) return 1;
+ return -4;
+}
+static void missing_read(const uint8_t*p,uint64_t f,uint64_t*out) {(void)p;(void)f;(void)out;}
+static void too_wide(const uint8_t*p,uint64_t f,uint64_t*out) {(void)f;*out=*(volatile const uint64_t*)p;}
+int main(void) {
+ unsigned count=0;
+ // Negative observers prove faults are real, not a forged list of outcomes.
+ if(observe(missing_read,8,2,0)!=0||observe(missing_read,8,4,0)!=0||observe(too_wide,2,5,0)!=1||observe(too_wide,4,5,0)!=1) return 4;
+ for(unsigned i=0;i<sizeof(kernels)/sizeof(kernels[0]);i++) for(unsigned taken=0;taken<2;taken++) {
+  Kernel k=kernels[i];uint64_t flags=0;unsigned found=0;
+  for(unsigned f=0;f<64;f++) if(predicate(k.condition,seed(f))==(int)taken) {flags=seed(f);found=1;break;}
+  if(!found) return 5;
+  for(unsigned address=0;address<7;address++) for(int native=1;native>=0;native--) {
+   int want=address==2||address==3||address==4;
+   int got=observe(native?k.original:k.translated,k.width,address,flags);count++;
+   if(got!=want) {fprintf(stderr,"kernel%%u width%%u taken%%u address%%u native%%u got%%d want%%d\n",i,k.width,taken,address,native,got,want);return 1;}
+  }
+ }
+ printf("cmov live/dead kernels %%zu translated/original fault outcomes %%u false/live/dead tripwires 4 failures 0\n",sizeof(kernels)/sizeof(kernels[0]),count);
+ return 0;
+}
+`
diff --git a/amd64_cmov_fixed_local_runtime_test.go b/amd64_cmov_fixed_local_runtime_test.go
new file mode 100644
index 000000000..1991188e2
--- /dev/null
+++ b/amd64_cmov_fixed_local_runtime_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch00(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch01(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch02(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch03(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch04(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 4)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch05(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 5)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytesBatch06(t *testing.T) {
+	x86CMOVFixedLocalRuntimeBatch(t, 6)
+}
+
+func x86CMOVFixedLocalRuntimeBatch(t *testing.T, batch int) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	target, ok := x86CMOVFixedLocalExecutionTarget(execution.triple)
+	if !ok {
+		t.Fatal("CMOV frame capture requires the actual execution target", execution.triple)
+	}
+	goAMD64FramePrepareOwnedToolCache(t)
+	triple := execution.triple
+	kernels := x86CMOVFixedLocalKernels(true)
+	start, end, ok := fixedLocalObjectBatchRange(len(kernels), batch)
+	if !ok {
+		t.Fatal("invalid complete CMOV runtime batch", batch, len(kernels))
+	}
+	var assembly, declarations, prototypes, rows strings.Builder
+	prefix := ""
+	if target == "darwin/amd64" {
+		prefix = "_"
+	}
+	for _, kernel := range kernels[start:end] {
+		assembly.WriteString(kernel.assembly)
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) uint64\n", kernel.name)
+		symbol := prefix + "example.invalid/framefixture." + kernel.name
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t,uint64_t) __asm__(%s);\n", kernel.name, runtimeCAsmLabel(symbol))
+		fmt.Fprintf(&rows, "{%s,%d,%d,%d},\n", kernel.name, kernel.width, kernel.condition, kernel.mode)
+	}
+	pkg, request, file, options := x86CMOVFixedLocalFixture(t, assembly.String(), declarations.String(), target, triple)
+	observer := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := observer.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := end - start
+	reference := runtimeCAsmLabelPreamble + fmt.Sprintf(x86CMOVFixedLocalWholeBytesC, prototypes.String(), rows.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmov-fixed-local-auto", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("cmov/private GP/SIMD AUTO kernels %d whole-byte outcomes %d failures 0\n", count, count*64)
+			if string(output) != want {
+				t.Fatal("actual native AUTO displacement/predicate/writeback mismatch", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+	x86WordMultiplyRunOriginalGo(t, execution, "package oracle\n"+declarations.String(), assembly.String(), fmt.Sprintf(x86CMOVFixedLocalOriginalGo, rows.String()))
+	t.Logf("batch%d: %d/%d independently executed actual Go ABI0 local CMOV/GP/SIMD kernels ×64 full-width input pairs; host native/Rosetta is not strict Linux evidence", batch, count, len(kernels))
+}
+
+func x86CMOVFixedLocalExecutionTarget(triple string) (string, bool) {
+	switch triple {
+	case "x86_64-unknown-linux-gnu":
+		return "linux/amd64", true
+	case "x86_64-apple-darwin", "x86_64-apple-macosx":
+		return "darwin/amd64", true
+	case "x86_64-pc-windows-msvc", "x86_64-w64-windows-gnu":
+		return "windows/amd64", true
+	default:
+		return "", false
+	}
+}
+
+func TestX86CMOVFixedLocalExecutionTargets(t *testing.T) {
+	for _, row := range []struct{ triple, target string }{
+		{"x86_64-unknown-linux-gnu", "linux/amd64"},
+		{"x86_64-apple-darwin", "darwin/amd64"},
+		{"x86_64-apple-macosx", "darwin/amd64"},
+		{"x86_64-pc-windows-msvc", "windows/amd64"},
+		{"x86_64-w64-windows-gnu", "windows/amd64"},
+		{"aarch64-unknown-linux-gnu", ""},
+		{"i686-pc-windows-msvc", ""},
+		{"", ""},
+	} {
+		actual, ok := x86CMOVFixedLocalExecutionTarget(row.triple)
+		if actual != row.target || ok != (row.target != "") {
+			t.Fatal("capture must retain the actual native execution platform", row, actual, ok)
+		}
+	}
+	for _, platform := range []string{"linux", "darwin", "windows"} {
+		triple := testTargetTriple(platform, "amd64")
+		if actual, ok := x86CMOVFixedLocalExecutionTarget(triple); !ok || actual != platform+"/amd64" {
+			t.Fatal("actual shared runtime triple lost its capture platform", triple, actual, ok)
+		}
+	}
+}
+
+const x86CMOVFixedLocalWholeBytesC = `
+#include <stdint.h>
+#include <stdio.h>
+` + x86CMOVConditionC + `
+%s
+typedef struct {uint64_t(*fn)(uint64_t,uint64_t);unsigned width,condition,mode;} Kernel;
+static Kernel kernels[]={%s};
+int main(void) {
+ const uint64_t edges[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),UINT64_C(0x7fffffffffffffff),UINT64_C(0x87654321fedcba98),UINT64_C(0x80000000),UINT64_C(0x7fc123457f800001)};
+ unsigned count=0;
+ for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++) for(unsigned x=0;x<8;x++) for(unsigned y=0;y<8;y++) {
+  Kernel kernel=kernels[k];uint64_t a=edges[x],b=edges[y],difference=a-b;
+  unsigned ones=0;for(unsigned bit=0;bit<8;bit++) ones+=(difference>>bit)&1;
+  uint64_t flags=(a<b)|((uint64_t)(!(ones&1))<<2)|((uint64_t)(difference==0)<<6)|((difference>>63)<<7)|((((a^b)&(a^difference))>>63)<<11);
+  uint64_t selected=predicate(kernel.condition,flags)?a:b;
+  uint64_t mask=kernel.width==8?UINT64_MAX:((UINT64_C(1)<<(kernel.width*8))-1);
+  uint64_t want=kernel.width==2?((b&~mask)|(selected&mask)):(selected&mask);
+  if(kernel.mode) want=kernel.mode==1?b:a;
+  uint64_t got=kernel.fn(a,b);
+  if(got!=want) {fprintf(stderr,"kernel%%u a%%llx b%%llx got%%llx want%%llx\n",k,(unsigned long long)a,(unsigned long long)b,(unsigned long long)got,(unsigned long long)want);return 1;}
+  count++;
+ }
+ printf("cmov/private GP/SIMD AUTO kernels %%zu whole-byte outcomes %%u failures 0\n",sizeof(kernels)/sizeof(kernels[0]),count);
+ return 0;
+}
+`
+
+const x86CMOVFixedLocalOriginalGo = `package oracle
+import "testing"
+func TestOriginal(t *testing.T) {
+ kernels:=[]struct{fn func(uint64,uint64)uint64;width,condition,mode int}{%s}
+ edges:=[]uint64{0,1,0xffffffffffffffff,0x8000000000000000,0x7fffffffffffffff,0x87654321fedcba98,0x80000000,0x7fc123457f800001}
+ count:=0
+ for k,kernel:=range kernels {for _,a:=range edges {for _,b:=range edges {
+  d:=a-b;ones:=0;for bit:=uint(0);bit<8;bit++ {ones+=int(d>>bit&1)}
+  cf,pf,zf,sf,of:=a<b,ones&1==0,d==0,d>>63!=0,((a^b)&(a^d))>>63!=0
+  predicates:=[]bool{!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf}
+  selected:=b;if predicates[kernel.condition] {selected=a}
+  mask:=uint64(0xffffffffffffffff);if kernel.width<8 {mask=(uint64(1)<<uint(kernel.width*8))-1}
+  want:=selected&mask;if kernel.width==2 {want|=b&^mask};if kernel.mode!=0 {want=a;if kernel.mode==1 {want=b}}
+  if got:=kernel.fn(a,b);got!=want {t.Fatalf("kernel%%d a%%x b%%x got%%x want%%x",k,a,b,got,want)};count++
+ }}}
+ t.Logf("actual Go local AUTO whole-byte outcomes %%d failures 0",count)
+}
+`
diff --git a/amd64_cmov_fixed_local_source_units_test.go b/amd64_cmov_fixed_local_source_units_test.go
new file mode 100644
index 000000000..ad8d2cb60
--- /dev/null
+++ b/amd64_cmov_fixed_local_source_units_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86CMOVFixedLocalSourceUnit struct {
+	start, end             int
+	assembly, declarations string
+	names                  []string
+}
+
+func x86CMOVFixedLocalObjectSources(kernels []x86CMOVFixedLocalKernel, batch int) ([]x86CMOVFixedLocalSourceUnit, bool) {
+	start, end, ok := fixedLocalObjectBatchRange(len(kernels), batch)
+	if !ok {
+		return nil, false
+	}
+	var units []x86CMOVFixedLocalSourceUnit
+	for chunk := start; chunk < end; chunk += 32 {
+		limit := chunk + 32
+		if limit > end {
+			limit = end
+		}
+		units = append(units, x86CMOVFixedLocalSourceForRange(kernels, chunk, limit))
+	}
+	return units, true
+}
+
+func x86CMOVFixedLocalSourceForRange(kernels []x86CMOVFixedLocalKernel, start, end int) x86CMOVFixedLocalSourceUnit {
+	unit := x86CMOVFixedLocalSourceUnit{start: start, end: end}
+	var assembly, declarations strings.Builder
+	for _, kernel := range kernels[start:end] {
+		assembly.WriteString(kernel.assembly)
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) uint64\n", kernel.name)
+		unit.names = append(unit.names, "example.invalid/framefixture."+kernel.name)
+	}
+	unit.assembly, unit.declarations = assembly.String(), declarations.String()
+	return unit
+}
+
+func TestFixedLocalCMOVObjectSourcesPreserveCompleteOriginalUnion(t *testing.T) {
+	kernels := x86CMOVFixedLocalKernels(false)
+	runtimeKernels := x86CMOVFixedLocalKernels(true)
+	if len(kernels) != 384 || len(runtimeKernels) != 387 ||
+		!reflect.DeepEqual(runtimeKernels[:len(kernels)], kernels) {
+		t.Fatal("complete CMOV grammar or original runtime GP/SIMD suffix changed")
+	}
+	// Independent axes prevent a cropped or duplicated producer table from
+	// validating its own source union merely by retaining the same count.
+	conditions := []string{
+		"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS",
+		"LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS",
+	}
+	sources := []string{
+		"AX", "8(SP)", "tmp(SP)", "UNKNOWN(SP)",
+		"tmp+0(SP)", "tmp+(0*4)(SP)", "tmp-8(SP)", "tmp-(2*4)(SP)",
+	}
+	if !reflect.DeepEqual(x86CMOVAUTOSources, sources[2:]) || len(x86CMOVOracleConditions) != len(conditions) {
+		t.Fatal("complete independent CMOV condition/source spelling inventory changed")
+	}
+	for index, condition := range x86CMOVOracleConditions {
+		if condition.name != conditions[index] {
+			t.Fatal("original CMOV condition ordering changed", index, condition)
+		}
+	}
+	var originalAssembly, originalDeclarations strings.Builder
+	for index, kernel := range kernels {
+		operation := "CMOV" + []string{"W", "L", "Q"}[index/128] + conditions[index/8%16]
+		if kernel.name != fmt.Sprintf("F%d", index) || kernel.width != []int{2, 4, 8}[index/128] ||
+			kernel.condition != index/8%16 || kernel.mode != 0 ||
+			kernel.assembly != x86CMOVFixedLocalAssembly(kernel.name, operation, sources[index%8]) ||
+			!strings.HasPrefix(kernel.assembly, "TEXT ·"+kernel.name+"(SB),4,$16-24\n") {
+			t.Fatal("original condition/width/source ordinal, symbol or ABI changed", index, kernel)
+		}
+		originalAssembly.WriteString(kernel.assembly)
+		fmt.Fprintf(&originalDeclarations, "func F%d(a,b uint64) uint64\n", index)
+	}
+	for index, kernel := range runtimeKernels[384:] {
+		if kernel.name != fmt.Sprintf("F%d", 384+index) || kernel.width != 8 || kernel.mode != index+1 {
+			t.Fatal("original runtime private GP/SIMD kernel changed", index, kernel)
+		}
+	}
+	seen, sourceCount := make([]int, len(kernels)), 0
+	var actualAssembly, actualDeclarations strings.Builder
+	for batch := 0; batch < 6; batch++ {
+		start, end, ok := fixedLocalObjectBatchRange(len(kernels), batch)
+		if !ok || end-start != 64 {
+			t.Fatal("the six complete scheduling owners changed", batch, start, end, ok)
+		}
+		units, ok := x86CMOVFixedLocalObjectSources(kernels, batch)
+		if !ok || len(units) == 0 {
+			t.Fatal("missing independently complete original source units", batch)
+		}
+		next := start
+		for _, unit := range units {
+			if unit.start != next || unit.end <= unit.start || unit.end > end {
+				t.Fatal("source units cropped, overlap or escape the original owner", batch, unit.start, unit.end, next)
+			}
+			if unit.end-unit.start > 32 {
+				t.Error("one five-minute API lease still carries more than 32 complete functions", batch, unit.end-unit.start)
+			}
+			file, err := Parse(ArchAMD64, unit.assembly)
+			if err != nil || file == nil || len(file.Funcs) != unit.end-unit.start || len(unit.names) != len(file.Funcs) {
+				t.Fatal("source unit is not an independently complete parsed program", batch, err)
+			}
+			for index := unit.start; index < unit.end; index++ {
+				local := index - unit.start
+				if file.Funcs[local].Sym != fmt.Sprintf("·F%d", index) ||
+					unit.names[local] != fmt.Sprintf("example.invalid/framefixture.F%d", index) {
+					t.Fatal("source unit renamed, reordered or substituted an original function", index)
+				}
+				seen[index]++
+			}
+			actualAssembly.WriteString(unit.assembly)
+			actualDeclarations.WriteString(unit.declarations)
+			next, sourceCount = unit.end, sourceCount+1
+		}
+		if next != end {
+			t.Fatal("source units omitted the end of a complete scheduling owner", batch, next, end)
+		}
+	}
+	if sourceCount != 12 || actualAssembly.String() != originalAssembly.String() ||
+		actualDeclarations.String() != originalDeclarations.String() {
+		t.Error("independent source units must reproduce all original ASM/declarations in twelve bounded programs", sourceCount)
+	}
+	for index, owners := range seen {
+		if owners != 1 {
+			t.Fatal("missing or duplicated original CMOV function", index, owners)
+		}
+	}
+	for _, batch := range []int{-1, 6} {
+		if units, ok := x86CMOVFixedLocalObjectSources(kernels, batch); ok || len(units) != 0 {
+			t.Fatal("invalid source owner accepted", batch)
+		}
+	}
+	if units, ok := x86CMOVFixedLocalObjectSources(nil, 0); ok || len(units) != 0 {
+		t.Fatal("empty original source inventory accepted")
+	}
+
+	function := fixedLocalLeaseFunctions(t, "amd64_cmov_fixed_local_test.go")["x86CMOVFixedLocalActualObjects"]
+	if function == nil || fixedLocalLeaseCalls(function.Body)["x86CMOVFixedLocalObjectSources"] != 1 {
+		t.Error("actual object consumer still captures one unpartitioned scheduling source")
+		return
+	}
+	unitLoops := 0
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		loop, ok := node.(*ast.RangeStmt)
+		if !ok || !fixedLocalLeaseIdent(loop.X, "units") {
+			return true
+		}
+		unitLoops++
+		calls := fixedLocalLeaseCalls(loop.Body)
+		if calls["x86CMOVFixedLocalFixture"] != 1 || calls["fixedLocalFreshAPIs"] != 1 {
+			t.Error("each source unit requires its own typed namespace and fresh three-API lifecycle")
+		}
+		ast.Inspect(loop.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			switch fixedLocalLeaseCallName(call) {
+			case "x86CMOVFixedLocalFixture":
+				if len(call.Args) != 5 {
+					t.Fatal("source unit changed its complete typed fixture arguments")
+				}
+				fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[:1]}, "t")
+				fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[3:]}, "target", "triple")
+				for index, field := range []string{"assembly", "declarations"} {
+					selected, ok := call.Args[index+1].(*ast.SelectorExpr)
+					if !ok || !fixedLocalLeaseIdent(selected.X, "unit") || selected.Sel.Name != field {
+						t.Error("source unit substituted the complete original payload", field)
+					}
+				}
+			case "fixedLocalFreshAPIs":
+				if len(call.Args) != 6 {
+					t.Fatal("source unit lost its complete API consumer")
+				}
+				fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[:4]}, "t", "pkg", "request", "options")
+				apis, ok := call.Args[4].(*ast.CompositeLit)
+				if !ok || len(apis.Elts) != 3 {
+					t.Fatal("source unit lost an independent public API")
+				}
+				for index, want := range []string{"Translate", "Module", "GoModule"} {
+					literal, ok := apis.Elts[index].(*ast.BasicLit)
+					if !ok || literal.Value != fmt.Sprintf("%q", want) {
+						t.Error("source unit changed its complete three-API plan", want)
+					}
+				}
+			}
+			return true
+		})
+		return true
+	})
+	if unitLoops != 1 {
+		t.Error("source units must drive exactly one independent consumer loop", unitLoops)
+	}
+}
diff --git a/amd64_cmov_fixed_local_test.go b/amd64_cmov_fixed_local_test.go
new file mode 100644
index 000000000..ab9ef065b
--- /dev/null
+++ b/amd64_cmov_fixed_local_test.go
@@ -0,0 +1,389 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+var x86CMOVAUTOSources = []string{"tmp(SP)", "UNKNOWN(SP)", "tmp+0(SP)", "tmp+(0*4)(SP)", "tmp-8(SP)", "tmp-(2*4)(SP)"}
+
+func TestX86CMOVFamilyAUTOActualGoPhysicalRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			if arch == "386" && width == "Q" {
+				continue
+			}
+			for _, source := range x86CMOVAUTOSources {
+				t.Run(arch+"/"+width+"/"+source, func(t *testing.T) {
+					code := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$16-0\nCMOV"+width+"LE "+source+",AX\nRET\n")
+					mode := 64
+					if arch == "386" {
+						mode = 32
+					}
+					found := 0
+					for len(code) > 0 {
+						ins, err := x86asm.Decode(code, mode)
+						if err != nil || ins.Len == 0 {
+							t.Fatal("independent actual Go object decode", err)
+						}
+						if ins.Op == x86asm.CMOVLE {
+							memory, ok := ins.Args[1].(x86asm.Mem)
+							want := int64(16)
+							if strings.Contains(source, "-") {
+								want = 8
+							}
+							if !ok || memory.Disp != want || memory.Index != 0 || ins.MemBytes != map[string]int{"W": 2, "L": 4, "Q": 8}[width] {
+								t.Fatal("NAME_AUTO is frame+offset, not virtual/native zero", source, ins)
+							}
+							found++
+						}
+						code = code[ins.Len:]
+					}
+					if found != 1 {
+						t.Fatal("actual Go did not emit one CMOV", found)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyAUTOGrammarThreeAPIFiveTargets(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, source := range x86CMOVAUTOSources {
+			var assembly strings.Builder
+			for _, name := range x86CMOVOracleNames(target.arch) {
+				fmt.Fprintf(&assembly, "%s %s,AX\n", name, source)
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$16-0\n"+name+" "+source+",AX\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				t.Run(target.triple+"/"+name+"/"+source, func(t *testing.T) {
+					if _, known, err := x86ConditionalMoveProperties(ins.Op, ins, target.arch); !known || err != nil {
+						t.Fatal("accepted NAME_AUTO descriptive offset is not an undefined macro", err)
+					}
+				})
+			}
+			original := "TEXT ·Value(SB),4,$16-0\n" + assembly.String() + "RET\n"
+			goAssemblerOracleOutput(t, target.arch, original, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+source+"/"+api, func(t *testing.T) {
+					_, err := x86OrderingHintTranslateAPI(t, api, original, "package ordering\nfunc Value()\n", target.arch, target.triple)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("legal grammar is not original native storage authority", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86CMOVFixedLocalAssembly(name, op, source string) string {
+	shift, restore := "", ""
+	if source != "AX" && source != "8(SP)" && source != "tmp-8(SP)" && source != "tmp-(2*4)(SP)" {
+		shift, restore = "MOVQ SP,R11\nADDQ $-16,SP\n", "MOVQ R11,SP\n"
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$16-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ AX,0(SP)\nMOVQ AX,8(SP)\n%sCMPQ AX,BX\n%s %s,BX\n%sMOVQ BX,ret+16(FP)\nRET\n", name, shift, op, source, restore)
+}
+
+func TestX86CMOVFamilyFixedLocalSourceRoleQueryNotPermission(t *testing.T) {
+	for _, op := range x86CMOVOracleNames("amd64") {
+		for _, source := range []string{"tmp(SP)", "UNKNOWN(SP)", "tmp-8(SP)", "tmp-(2*4)(SP)", "8(SP)", "(BP)", "AX", "a+0(FP)", "slot+UNKNOWN(SP)"} {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$16-24\n"+op+" "+source+",BX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := source != "AX" && source != "a+0(FP)" && source != "slot+UNKNOWN(SP)"
+			if got := GoAMD64FixedLocalFrameBindingNeeded(file, "amd64"); got != want {
+				t.Errorf("typed source binding query %s %s got=%t want=%t", op, source, got, want)
+			}
+		}
+	}
+}
+
+func x86CMOVFixedLocalFixture(t *testing.T, assembly, declarations, target, triple string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	pkg, request := goAMD64FrameTypedFixture(t, declarations, assembly)
+	request.Target = target
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{}
+	for _, name := range pkg.Types.Scope().Names() {
+		sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[sig.Name] = sig
+	}
+	return pkg, request, file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) }}
+}
+
+type x86CMOVFixedLocalKernel struct {
+	name, assembly         string
+	width, condition, mode int
+}
+
+func x86CMOVFixedLocalKernels(includeMoves bool) []x86CMOVFixedLocalKernel {
+	var kernels []x86CMOVFixedLocalKernel
+	for _, width := range []string{"W", "L", "Q"} {
+		for condition, row := range x86CMOVOracleConditions {
+			for _, source := range append([]string{"AX", "8(SP)"}, x86CMOVAUTOSources...) {
+				name := fmt.Sprintf("F%d", len(kernels))
+				kernels = append(kernels, x86CMOVFixedLocalKernel{
+					name:      name,
+					assembly:  x86CMOVFixedLocalAssembly(name, "CMOV"+width+row.name, source),
+					width:     map[string]int{"W": 2, "L": 4, "Q": 8}[width],
+					condition: condition,
+				})
+			}
+		}
+	}
+	if includeMoves {
+		for mode, operation := range []string{
+			"MOVQ tmp-8(SP),BX",
+			"MOVQ AX,tmp-8(SP)\nMOVQ tmp-8(SP),BX",
+			"MOVOU tmp-16(SP),X0\nMOVQ X0,BX",
+		} {
+			name := fmt.Sprintf("F%d", len(kernels))
+			kernels = append(kernels, x86CMOVFixedLocalKernel{
+				name: name, width: 8, mode: mode + 1,
+				assembly: fmt.Sprintf("TEXT ·%s(SB),4,$16-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ AX,0(SP)\nMOVQ BX,8(SP)\n%s\nMOVQ BX,ret+16(FP)\nRET\n", name, operation),
+			})
+		}
+	}
+	return kernels
+}
+
+func TestX86CMOVFixedLocalCompleteBatchPlan(t *testing.T) {
+	for _, includeMoves := range []bool{false, true} {
+		kernels := x86CMOVFixedLocalKernels(includeMoves)
+		count, batches := 384, 6
+		if includeMoves {
+			count, batches = 387, 7
+		}
+		if len(kernels) != count {
+			t.Fatal("complete original CMOV/GP/SIMD kernel inventory changed", includeMoves, len(kernels))
+		}
+		seen := make([]int, count)
+		for batch := 0; batch < batches; batch++ {
+			start, end, ok := fixedLocalObjectBatchRange(count, batch)
+			if !ok || end-start > 64 || end <= start {
+				t.Fatal("invalid bounded CMOV batch", batch, start, end, ok)
+			}
+			for index := start; index < end; index++ {
+				seen[index]++
+				kernel := kernels[index]
+				if kernel.name != fmt.Sprintf("F%d", index) ||
+					!strings.HasPrefix(kernel.assembly, "TEXT ·"+kernel.name+"(SB),4,$16-24\n") {
+					t.Fatal("batch changed original source symbol or ABI0 frame", index, kernel)
+				}
+				if index < 384 {
+					width := []int{2, 4, 8}[index/128]
+					if kernel.width != width || kernel.condition != index/8%16 || kernel.mode != 0 {
+						t.Fatal("batch changed independent width/condition/source ordering", index, kernel)
+					}
+				} else if kernel.width != 8 || kernel.condition != 0 || kernel.mode != index-383 {
+					t.Fatal("batch lost original private GP/SIMD AUTO kernel", index, kernel)
+				}
+			}
+		}
+		for index, owners := range seen {
+			if owners != 1 {
+				t.Fatal("missing or duplicated original kernel", index, owners)
+			}
+		}
+		for _, batch := range []int{-1, batches} {
+			if _, _, ok := fixedLocalObjectBatchRange(count, batch); ok {
+				t.Fatal("out-of-range CMOV batch accepted", count, batch)
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch00(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 0)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch01(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 1)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch02(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 2)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch03(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 3)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch04(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 4)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsLinuxBatch05(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 5)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch00(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 0)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch01(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 1)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch02(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 2)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch03(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 3)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch04(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 4)
+}
+
+func TestX86CMOVFamilyFixedLocalAUTOActualObjectsDarwinBatch05(t *testing.T) {
+	x86CMOVFixedLocalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 5)
+}
+
+func x86CMOVFixedLocalActualObjects(t *testing.T, target, triple string, batch int) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	kernels := x86CMOVFixedLocalKernels(false)
+	units, ok := x86CMOVFixedLocalObjectSources(kernels, batch)
+	if !ok {
+		t.Fatal("invalid complete CMOV object batch", batch, len(kernels))
+	}
+	count := 0
+	for index, unit := range units {
+		count += unit.end - unit.start
+		t.Run(fmt.Sprintf("source%d", index), func(t *testing.T) {
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, unit.assembly, unit.declarations, target, triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "fixed_local_native") {
+					t.Fatal("exact sealed original local storage", err)
+				}
+				for _, optimize := range []bool{false, true} {
+					input := ir
+					if optimize {
+						input = x86DwordProductIROptimize(t, ir)
+					}
+					x86CompactExpandRequireAllDefinitions(t, input, unit.names)
+					compileLLVMToObject(t, llc, triple, "cmov-fixed-local.ll", "cmov-fixed-local.o", input)
+				}
+			})
+		})
+	}
+	t.Logf("%s batch%d: %d/%d original condition/width/register/physical/AUTO kernels; %d independent sources, three APIs, original/optimized IR, llc-O0",
+		target, batch, count, len(kernels), len(units))
+}
+
+func TestX86CMOVFamilyFixedLocalEveryReadAndAuthorityNegatives(t *testing.T) {
+	for _, op := range x86CMOVOracleNames("amd64") {
+		base := x86CMOVFixedLocalAssembly("Value", op, "tmp(SP)")
+		pkg := mustGoPackage(t, "cmovlocal", "package cmovlocal\nfunc Value(a,b uint64) uint64\n")
+		sig := x86WordMultiplySignature(t, pkg, "Value")
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[4]]
+		mutations := map[string]string{
+			"unknown flags":          strings.Replace(base, "CMPQ AX,BX", "MOVQ AX,DX", 1),
+			"old target pointer":     strings.Replace(base, "CMPQ AX,BX", "CMPQ AX,BX\nMOVQ SP,BX", 1),
+			"g target":               strings.Replace(base, "tmp(SP),BX", "tmp(SP),R14", 1),
+			"BP target":              strings.Replace(base, "tmp(SP),BX", "tmp(SP),BP", 1),
+			"AUTO saved BP":          strings.Replace(base, "ADDQ $-16,SP", "ADDQ $0,SP", 1),
+			"AUTO return":            strings.Replace(base, "tmp(SP)", "tmp+24(SP)", 1),
+			"undefined expression":   strings.Replace(base, "tmp(SP)", "slot+UNKNOWN(SP)", 1),
+			"AUTO address input":     strings.Replace(base, op+" tmp(SP),BX", "MOVQ $tmp(SP),AX\n"+op+" AX,BX", 1),
+			"FP pointer permission":  strings.Replace(base, "tmp(SP)", "p+0(FP)", 1),
+			"source private pointer": strings.Replace(base, "MOVQ AX,0(SP)", "MOVQ SP,0(SP)", 1),
+		}
+		for missing := 0; missing < width; missing++ {
+			var stores, old strings.Builder
+			for byteIndex := 0; byteIndex < width; byteIndex++ {
+				if byteIndex != missing {
+					fmt.Fprintf(&stores, "MOVB $1,%d(SP)\n", byteIndex)
+				}
+			}
+			// Old destination reads are potential even when every flag seed
+			// makes the predicate true. Byte-state is checked independently.
+			old.WriteString("MOVQ b+8(FP),DX\n")
+			mutations[fmt.Sprintf("source byte %d", missing)] = strings.Replace(base, "MOVQ AX,0(SP)\n", stores.String(), 1)
+			changed, err := Parse(ArchAMD64, strings.Replace(base, "MOVQ b+8(FP),BX\n", old.String(), 1))
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Run(op+fmt.Sprintf("/old byte %d", missing), func(t *testing.T) {
+				state := x86FixedLocalState{
+					pointers: map[Reg]int64{SP: -16},
+					known:    map[Reg]uint8{AX: 255, BX: 255 &^ (1 << uint(missing))},
+					bytes:    newFixedLocalByteSet(16), flags: x86ByteFlagsAll,
+				}
+				for index := int64(0); index < 16; index++ {
+					state.bytes.set(index, true)
+				}
+				for _, ins := range changed.Funcs[0].Instrs {
+					if ins.Op == Op(op) {
+						if err := fixedLocalStep(&ins, &state, sig, &x86FixedLocalProof{frame: 16}, 0); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("missing old byte became a defined potential input", err)
+						}
+					}
+				}
+			})
+		}
+		for name, source := range mutations {
+			t.Run(op+"/"+name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("fixed local memory/flags/pointer/frame authority grew", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CMOVFamilyFixedLocalSharedAUTOExistingFalseCertificate(t *testing.T) {
+	// This is never executed: Go's named AUTO displacement is 160+16,
+	// while the old private proof mistakenly certified virtual offset 16.
+	pkg, _, file, options := fixedLocalFrameFixture(t, "PADDQ tmp+16(SP),X0")
+	goAssemblerOracleOutput(t, "amd64", fixedLocalVoidAssembly(file), "", true)
+	if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("named AUTO native out-of-frame bytes acquired an offset-zero virtual certificate", err)
+	}
+}
+
+func TestX86CMOVFamilyFixedLocalSharedAUTOGPAndSIMD(t *testing.T) {
+	for _, operation := range []string{"MOVQ tmp-8(SP),BX", "MOVQ AX,tmp-8(SP)\nMOVQ tmp-8(SP),BX", "MOVOU tmp-16(SP),X0\nMOVQ X0,BX"} {
+		t.Run(operation, func(t *testing.T) {
+			assembly := "TEXT ·Value(SB),4,$16-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ AX,0(SP)\nMOVQ BX,8(SP)\n" + operation + "\nMOVQ BX,ret+16(FP)\nRET\n"
+			pkg, request, file, options := x86CMOVFixedLocalFixture(t, assembly, "func Value(a,b uint64) uint64", "linux/amd64", "x86_64-unknown-linux-gnu")
+			observer := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := observer.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("the shared original AUTO role needs its actual native displacement", err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "fixed_local_native") {
+					t.Fatal("shared scalar/SIMD native offset consumer", err)
+				}
+			})
+		})
+	}
+}
diff --git a/amd64_cmov_forms.go b/amd64_cmov_forms.go
new file mode 100644
index 000000000..91bad1976
--- /dev/null
+++ b/amd64_cmov_forms.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ConditionalMoveSpec struct {
+	bits      int
+	condition string
+}
+
+// Each entry is a Go yml_rl row, not a conditional memory-access permission.
+// W preserves the other GP bytes. L clears the upper half even on a false
+// predicate. Both the source and the old destination are potential inputs.
+var x86ConditionalMoveSpecs = map[Op]x86ConditionalMoveSpec{
+	"CMOVWCC": {16, "CC"}, "CMOVWCS": {16, "CS"}, "CMOVWEQ": {16, "EQ"}, "CMOVWGE": {16, "GE"},
+	"CMOVWGT": {16, "GT"}, "CMOVWHI": {16, "HI"}, "CMOVWLE": {16, "LE"}, "CMOVWLS": {16, "LS"},
+	"CMOVWLT": {16, "LT"}, "CMOVWMI": {16, "MI"}, "CMOVWNE": {16, "NE"}, "CMOVWOC": {16, "OC"},
+	"CMOVWOS": {16, "OS"}, "CMOVWPC": {16, "PC"}, "CMOVWPL": {16, "PL"}, "CMOVWPS": {16, "PS"},
+	"CMOVLCC": {32, "CC"}, "CMOVLCS": {32, "CS"}, "CMOVLEQ": {32, "EQ"}, "CMOVLGE": {32, "GE"},
+	"CMOVLGT": {32, "GT"}, "CMOVLHI": {32, "HI"}, "CMOVLLE": {32, "LE"}, "CMOVLLS": {32, "LS"},
+	"CMOVLLT": {32, "LT"}, "CMOVLMI": {32, "MI"}, "CMOVLNE": {32, "NE"}, "CMOVLOC": {32, "OC"},
+	"CMOVLOS": {32, "OS"}, "CMOVLPC": {32, "PC"}, "CMOVLPL": {32, "PL"}, "CMOVLPS": {32, "PS"},
+	"CMOVQCC": {64, "CC"}, "CMOVQCS": {64, "CS"}, "CMOVQEQ": {64, "EQ"}, "CMOVQGE": {64, "GE"},
+	"CMOVQGT": {64, "GT"}, "CMOVQHI": {64, "HI"}, "CMOVQLE": {64, "LE"}, "CMOVQLS": {64, "LS"},
+	"CMOVQLT": {64, "LT"}, "CMOVQMI": {64, "MI"}, "CMOVQNE": {64, "NE"}, "CMOVQOC": {64, "OC"},
+	"CMOVQOS": {64, "OS"}, "CMOVQPC": {64, "PC"}, "CMOVQPL": {64, "PL"}, "CMOVQPS": {64, "PS"},
+}
+
+type x86ConditionalMoveForm struct {
+	x86ConditionalMoveSpec
+	source, destination Operand
+}
+
+func x86ConditionalMoveProperties(op Op, ins Instr, arch string) (x86ConditionalMoveForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base, _, suffixed := strings.Cut(name, ".")
+	spec, known := x86ConditionalMoveSpecs[Op(base)]
+	if !known {
+		return x86ConditionalMoveForm{}, false, nil
+	}
+	fail := func(reason string) (x86ConditionalMoveForm, bool, error) {
+		return x86ConditionalMoveForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 || suffixed ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 2 {
+		return fail("has an unbound mode, suffix, dispatch identity or operand count")
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, arch) {
+		return fail("expects a Yrl destination")
+	}
+	if source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(source.Reg, arch) {
+			return fail("register source is outside the Go Yml class")
+		}
+	} else if source.Kind == OpMem {
+		if !x86ConditionalMoveOffsetKnown(source.Mem) || source.Mem.IndexExt != "" ||
+			source.Mem.Segment != "" && source.Mem.Segment != FS && source.Mem.Segment != GS {
+			return fail("has an unresolved or unencodable memory source")
+		}
+		if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+			return x86ConditionalMoveForm{}, true, err
+		}
+		validation := source
+		if arch == "386" && strings.HasSuffix(source.Mem.Sym, "(SB)") {
+			validation.Mem.Base = "" // Go ignores Reg, not Index, for named memory.
+		}
+		if !x86PackedShiftMemoryValid(validation, arch) {
+			return fail("has an unencodable source address")
+		}
+	} else if !x86PackedShiftMemoryValid(source, arch) {
+		return fail("expects a Yml register or memory source")
+	}
+	if source.Kind == OpSym {
+		if address, err := parseInt(strings.TrimSpace(source.Sym)); err == nil &&
+			address != int64(int32(address)) && !(arch == "386" && address == int64(uint32(address))) {
+			return fail("absolute source address is outside Go's physical disp32 extent")
+		}
+	}
+	return x86ConditionalMoveForm{spec, source, destination}, true, nil
+}
+
+func x86TypedConditionalMoveByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ConditionalMoveProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: width, read: true},
+		{index: 1, operand: form.destination, width: width, read: true, write: true},
+	}, flagsRead: x86ByteConditionFlags(form.condition), requiresResultProof: true}, true, nil
+}
+
+func x86CallerConditionalMoveStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) (bool, bool) {
+	form, known, err := x86ConditionalMoveProperties(ins.Op, *ins, "amd64")
+	if !known || err != nil || !x86SourceStackNumericFlagsRead(state, x86ByteConditionFlags(form.condition)) {
+		return known, false
+	}
+	width := int64(form.bits / 8)
+	if !x86CallerNumericRead(form.destination, width, state) {
+		return true, false // Neither possible old pointer bits nor missing bytes are washed away.
+	}
+	if form.source.Kind == OpMem {
+		if !x86CallerOrdinaryMemoryStep(ins, 0, state, proof, width, false) {
+			return true, false
+		}
+	} else if !x86CallerNumericRead(form.source, width, state) {
+		return true, false // FP pointer slots are imports only, never CMOV inputs.
+	}
+	return true, x86CallerNumericWrite(form.destination.Reg, width, state)
+}
diff --git a/amd64_cmov_forms_test.go b/amd64_cmov_forms_test.go
new file mode 100644
index 000000000..1f8b0ace1
--- /dev/null
+++ b/amd64_cmov_forms_test.go
@@ -0,0 +1,447 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Intel condition/opcode/flag inventory, not the production map.
+var x86CMOVOracleConditions = []struct {
+	name   string
+	opcode byte
+	flags  uint8
+}{
+	{"CC", 0x43, x86ByteFlagCF}, {"CS", 0x42, x86ByteFlagCF},
+	{"EQ", 0x44, x86ByteFlagZF}, {"GE", 0x4d, x86ByteFlagSF | x86ByteFlagOF},
+	{"GT", 0x4f, x86ByteFlagZF | x86ByteFlagSF | x86ByteFlagOF}, {"HI", 0x47, x86ByteFlagCF | x86ByteFlagZF},
+	{"LE", 0x4e, x86ByteFlagZF | x86ByteFlagSF | x86ByteFlagOF}, {"LS", 0x46, x86ByteFlagCF | x86ByteFlagZF},
+	{"LT", 0x4c, x86ByteFlagSF | x86ByteFlagOF}, {"MI", 0x48, x86ByteFlagSF},
+	{"NE", 0x45, x86ByteFlagZF}, {"OC", 0x41, x86ByteFlagOF},
+	{"OS", 0x40, x86ByteFlagOF}, {"PC", 0x4b, x86ByteFlagPF},
+	{"PL", 0x49, x86ByteFlagSF}, {"PS", 0x4a, x86ByteFlagPF},
+}
+
+func TestX86CMOVFamilyActualGoCompletePhysicalBytesAndCaller(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			if arch == "386" && width == "Q" {
+				continue
+			}
+			for _, condition := range x86CMOVOracleConditions {
+				name := "CMOV" + width + condition.name
+				for _, row := range []struct {
+					source, destination string
+					modrm, rex          byte
+				}{
+					{"BX", "AX", 0xc3, 0}, {"AX", "AX", 0xc0, 0}, {"(DI)", "AX", 0x07, 0}, {"R8", "R9", 0xc8, 0x45},
+				} {
+					if arch == "386" && row.rex != 0 {
+						continue
+					}
+					t.Run(arch+"/"+name+"/"+row.source, func(t *testing.T) {
+						instruction := name + " " + row.source + "," + row.destination
+						actual := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+						var want []byte
+						if width == "W" {
+							want = append(want, 0x66)
+						}
+						rex := row.rex
+						if width == "Q" {
+							if rex == 0 {
+								rex = 0x48
+							} else {
+								rex |= 8
+							}
+						}
+						if rex != 0 {
+							want = append(want, rex)
+						}
+						want = append(want, 0x0f, condition.opcode, row.modrm, 0xc3)
+						if !bytes.Equal(actual, want) {
+							t.Fatalf("independent exact Go prefix/opcode/ModRM bytes %s got %x want %x", instruction, actual, want)
+						}
+						file, err := Parse(ArchAMD64, "TEXT original(SB),4,$0-0\n"+x86DwordProductDirectives(actual[:len(actual)-1])+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						decoded, err := decodeX86RawDirectives(file.Funcs[0], arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						if decoded.Instrs[1].Op != Op(name) {
+							t.Fatal("physical condition alias/width normalization", decoded.Instrs[1].Op, name)
+						}
+						if arch != "amd64" || row.rex != 0 {
+							return
+						}
+						prefix := "MOVQ $9,BX\nCMPQ AX,BX\n"
+						body := x86DwordProductDirectives(actual[:len(actual)-1])
+						assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", prefix+body+"\nMOVL AX,(DX)", 1)
+						pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+						if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+							t.Fatal("actual Go physical source/caller effect", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86CMOVOracleNames(arch string) []string {
+	var names []string
+	for _, width := range []string{"W", "L", "Q"} {
+		if arch == "386" && width == "Q" {
+			continue
+		}
+		for _, condition := range x86CMOVOracleConditions {
+			names = append(names, "CMOV"+width+condition.name)
+		}
+	}
+	return names
+}
+
+func TestX86CMOVFamilyCompleteIndependentEncoderRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	if !regexp.MustCompile(`(?s)var yml_rl = \[\]ytab\{\s*\{Zm_r, 1, argList\{Yml, Yrl\}\},\s*\}`).MatchString(table) {
+		t.Fatal("complete Go conditional-move zcase/zoffset/classes changed")
+	}
+	rows := regexp.MustCompile(`\{A(CMOV[A-Z]+), ([^,]+), ([^,]+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(table, -1)
+	if len(rows) != 48 || len(x86ConditionalMoveSpecs) != 48 {
+		t.Fatal("complete family inventory changed", len(rows), len(x86ConditionalMoveSpecs))
+	}
+	seen := map[string]bool{}
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, condition := range x86CMOVOracleConditions {
+			name, prefix := "CMOV"+width+condition.name, map[string]string{"W": "Pq", "L": "Pm", "Q": "Pw"}[width]
+			bytes := fmt.Sprintf("0x%02x", condition.opcode)
+			if width == "Q" {
+				bytes = "0x0f, " + bytes
+			}
+			want := fmt.Sprintf("{A%s, yml_rl, %s, opBytes{%s}}", name, prefix, bytes)
+			if !strings.Contains(table, want) {
+				t.Fatal("independent complete encoder attributes changed", want)
+			}
+			if _, found := x86ConditionalMoveSpecs[Op(name)]; !found {
+				t.Fatal("missing actual Go member", name)
+			}
+			seen[name] = true
+		}
+	}
+	for _, row := range rows {
+		if !seen[row[1]] {
+			t.Fatal("unaccounted actual Go family row", row)
+		}
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(aliases), `instructions["CMOV`) {
+		t.Fatal("actual Go source alias inventory changed")
+	}
+}
+
+func TestX86CMOVFamilyIndependentAbsoluteAddressExtent(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86CMOVOracleNames(arch) {
+			for _, test := range []struct {
+				address string
+				valid   bool
+			}{
+				{"0", true}, {"-1", true}, {"2147483647", true}, {"-2147483648", true},
+				{"2147483648", arch == "386"}, {"4294967295", arch == "386"}, {"4294967296", false}, {"-2147483649", false},
+			} {
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+name+" "+test.address+",AX\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				_, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch)
+				if !known || (err == nil) != test.valid {
+					t.Errorf("%s %s absolute address %s valid=%t err=%v", arch, name, test.address, test.valid, err)
+				}
+			}
+		}
+		for _, address := range []string{"0", "-1", "2147483647", "-2147483648", "2147483648", "4294967295", "4294967296", "-2147483649"} {
+			valid := address != "4294967296" && address != "-2147483649" && (arch == "386" || address != "2147483648" && address != "4294967295")
+			goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\nCMOVLLE "+address+",AX\nRET\n", "", valid)
+		}
+	}
+}
+
+func TestX86CMOVFamilyWholeFormatsEffectsAndShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		registers := strings.Fields("AX BX CX DX SP BP SI DI")
+		if arch == "amd64" {
+			registers = append(registers, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15")...)
+		}
+		sources := append(append([]string(nil), registers...), "(AX)", "-1(AX)(CX*2)", "127(AX)(DX*8)", "value+0(FP)", "local-8(SP)", "·data(SB)", "(FS)", "(GS)")
+		var assembly strings.Builder
+		count := 0
+		for _, name := range x86CMOVOracleNames(arch) {
+			for _, source := range sources {
+				row := name + " " + source + ",AX"
+				fmt.Fprintf(&assembly, "TEXT f%d(SB),4,$16-8\n%s\nRET\n", count, row)
+				count++
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$16-8\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				before := fmt.Sprintf("%#v", ins)
+				form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch)
+				if !known || err != nil {
+					t.Fatal(arch, row, err)
+				}
+				width := int64(form.bits / 8)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				flags := uint8(0)
+				for _, condition := range x86CMOVOracleConditions {
+					if strings.HasSuffix(name, condition.name) {
+						flags = condition.flags
+					}
+				}
+				if !known || err != nil || effect.flagsRead != flags || effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.dynamicMemory ||
+					len(effect.operands) != 2 || effect.operands[0].index != 0 || effect.operands[1].index != 1 ||
+					!effect.operands[0].read || effect.operands[0].write || !effect.operands[1].read || !effect.operands[1].write ||
+					effect.operands[0].width != width || effect.operands[1].width != width {
+					t.Fatal(row, effect, err)
+				}
+				if !x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+					t.Fatal("source-stack omitted typed member", row)
+				}
+				for index, arg := range ins.Args {
+					bytes, write, valid := x86InstructionMemoryShape(ins, index, arch)
+					memory := index == 0 && isAMD64MemoryOperand(arg)
+					if valid != memory || valid && (bytes != width || write || x86ScalarMoveMemoryBytes(ins, index, arch) != width) {
+						t.Fatal("source extent/direction", row, bytes, write, valid)
+					}
+					if arg.Kind == OpFP {
+						if bytes, write, valid := X86FPAccessBytes(ins, index, arch); !valid || write || bytes != width {
+							t.Fatal("FP extent disagreement", row)
+						}
+					}
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("source identity mutated", row)
+				}
+			}
+			// Destination Yrl is independent of the source class, including self aliases.
+			for _, destination := range registers {
+				fmt.Fprintf(&assembly, "TEXT f%d(SB),4,$0-0\n%s %s,%s\nRET\n", count, name, destination, destination)
+				count++
+			}
+		}
+		goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+		t.Logf("%s independent actual-Go forms %d", arch, count)
+	}
+}
+
+func TestX86CMOVFamilyDispatchAndGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86CMOVOracleNames("amd64") {
+			if arch == "386" && name[4] == 'Q' {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+name+" AX,BX\nRET\n", "", false)
+				continue
+			}
+			operands := []string{"$1,AX", "AX,(BX)", "AL,AX", "AH,AX", "AX,AL", "X1,AX", "K1,AX", "M0,AX", "(AX)(SP*2),BX"}
+			if arch == "386" {
+				operands = append(operands, "R8,AX", "AX,R8")
+			}
+			for _, operands := range operands {
+				source := "TEXT f(SB),4,$0-0\n" + name + " " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					continue
+				}
+				if _, known, err := x86ConditionalMoveProperties(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], arch); !known || err == nil {
+					t.Fatal("Go rejection obtained an effect", arch, source, err)
+				}
+			}
+		}
+	}
+	for _, identity := range []Op{"", "CMOVLLE", "cmovlle", "CMOVLGE", "CMOVLLE.Z"} {
+		ins := Instr{Op: identity, Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}}
+		before := append([]Operand(nil), ins.Args...)
+		_, known, err := x86ConditionalMoveProperties("CMOVLLE", ins, "amd64")
+		valid := identity == "" || strings.EqualFold(string(identity), "CMOVLLE")
+		if !known || (err == nil) != valid || !reflect.DeepEqual(ins.Args, before) {
+			t.Fatal("dispatch identity", identity, err)
+		}
+		if !valid {
+			var out strings.Builder
+			ctx := amd64Ctx{b: &out, goarch: "amd64"}
+			if _, _, err := ctx.lowerConditionalMove("CMOVLLE", ins); err == nil || out.Len() != 0 {
+				t.Fatal("contradictory identity emitted IR")
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var body strings.Builder
+				for _, name := range x86CMOVOracleNames(target.arch) {
+					for _, source := range []string{"AX", "BX", "(DI)", "-1(DI)(SI*2)"} {
+						fmt.Fprintf(&body, "%s %s,BX\n", name, source)
+					}
+				}
+				if raw {
+					bytes := x86OrderingHintGoBytes(t, target.arch, "TEXT original(SB),4,$0-0\n"+body.String()+"RET\n")
+					body.Reset()
+					if bytes[len(bytes)-1] != 0xc3 {
+						t.Fatal("actual Go body lacks its exact trailing RET")
+					}
+					for _, value := range bytes[:len(bytes)-1] {
+						fmt.Fprintf(&body, "BYTE $%d\n", value)
+					}
+				} else {
+					for _, name := range x86CMOVOracleNames(target.arch) {
+						fmt.Fprintf(&body, "%s value+0(FP),BX\n%s ·data(SB),BX\n%s (FS),BX\n%s (GS),BX\n", name, name, name, name)
+					}
+				}
+				source := "TEXT ·Forms(SB),4,$0-8\n" + body.String() + "RET\nGLOBL ·data(SB),8,$8\nDATA ·data+0(SB)/8,$0x1020304050607080\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Forms(value uint64)\n", target.arch, target.triple)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original formats invented predicate, data or native input bytes", api, err)
+					}
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				signatures := map[string]FuncSig{"Forms": {Name: "Forms", Args: []LLVMType{I64}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}}
+				ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+					func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerConditionalMove(ins.Op, ins) })
+				for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, input, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CMOVFamilyBoundFrameNumericalExtent(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, width := range []string{"W", "L", "Q"} {
+			if target.arch == "386" && width == "Q" {
+				continue
+			}
+			for _, test := range []struct {
+				declaration, field string
+				valid              bool
+			}{
+				{"func Value(x uint64)", "x+0(FP)", true},
+				{"func Value(x uint64)", "x+1(FP)", width != "Q"},
+				{"func Value(x uint8,y uint8)", "x+0(FP)", width == "W"},
+				{"func Value(x uint8,y uint32)", "x+0(FP)", false},
+				{"func Value(x float64)", "x+0(FP)", true},
+				{"func Value(x *uint64)", "x+0(FP)", false},
+				{"func Value()", "ret+0(FP)", false},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					size := 8
+					if test.declaration == "func Value(x uint8,y uint8)" {
+						size = 2
+					}
+					if test.declaration == "func Value(x *uint64)" && target.arch == "386" {
+						size = 4
+					}
+					if test.declaration == "func Value()" {
+						size = 0
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nCMOV%sLE %s,AX\nRET\n", size, width, test.field)
+					if test.valid {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+test.declaration+"\n", target.arch, target.triple)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("original FP format invented old destination or predicate bytes", api, err)
+						}
+					}
+					// Only the source storage varies: give every row independent
+					// old-destination data and FLAGS before testing its exact span.
+					source = strings.Replace(source, fmt.Sprintf("$0-%d\n", size),
+						fmt.Sprintf("$0-%d\nMOVL $7,AX\nCMPL AX,$0\n", size), 1)
+					_, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+test.declaration+"\n", target.arch, target.triple)
+					if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("numerical FP bit extent/hole/type permission", target.triple, width, test.declaration, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyNativeStackAndFPAuthorityUnchanged(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, operand := range []string{"(SP)", "(BP)", "(SI)(BP*1)", "value+7(FP)", "missing+8(FP)", "p+0(FP)"} {
+			t.Run(target.triple+"/"+operand, func(t *testing.T) {
+				declaration := "package ordering\nfunc Value(value uint64)\n"
+				size, width, setup := 8, "Q", ""
+				if target.arch == "386" {
+					width = "L"
+				}
+				if operand == "p+0(FP)" {
+					declaration = "package ordering\nfunc Value(p *uint64)\n"
+					if target.arch == "386" {
+						size = 4
+					}
+				}
+				ordinary := target.arch == "386" && strings.Contains(operand, "BP")
+				if ordinary {
+					size, declaration = 4, "package ordering\nfunc Value(p *byte)\n"
+					setup = "MOVL p+0(FP),BP\n"
+					if strings.Contains(operand, "BP*") {
+						setup = "MOVL p+0(FP),SI\nMOVL $0,BP\n"
+					}
+				}
+				// Every row has an independent defined numerical old destination
+				// and FLAGS, so a Context result must still be about source storage.
+				setup += fmt.Sprintf("MOV%s $7,AX\nCMP%s AX,$0\n", width, width)
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sCMOV%sLE %s,AX\nRET\n", size, setup, width, operand)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, declaration, target.arch, target.triple)
+					if ordinary {
+						if err != nil {
+							t.Fatal("ordinary386 BP native CMOV", api, err)
+						}
+						for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							x86RequireCMOVVolatileWidth(t, input, 4, 1)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("new native-stack, pointer or missing-FP input authority", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_cmov_fp_bitview_runtime_test.go b/amd64_cmov_fp_bitview_runtime_test.go
new file mode 100644
index 000000000..3c1b5db64
--- /dev/null
+++ b/amd64_cmov_fp_bitview_runtime_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The native oracle contains actual Go bytes and receives raw IEEE bits by
+// MOVSS/MOVSD only. Its predicates and byte reference are independent of the
+// typed grammar; signaling NaNs never undergo arithmetic or conversion.
+func TestCrossLinuxRuntimeMatrixX86CMOVFPBitViewsWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, prototypes, originals, rows, goRows strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, typ := range []string{"float32", "float64"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			if typ == "float32" && width == "Q" {
+				continue
+			}
+			for condition, row := range x86CMOVOracleConditions {
+				fn := fmt.Sprintf("F%d", count)
+				count++
+				name := "CMOV" + width + row.name
+				fmt.Fprintf(&declarations, "func %s(out *[16]byte,f %s,old,seed uint64)\n", fn, typ)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ old+16(FP),BX\nPUSHQ seed+24(FP)\nPOPFQ\n%s f+8(FP),BX\nMOVQ BX,(DI)\nPUSHFQ\nPOPQ AX\nMOVQ AX,8(DI)\nRET\n", fn, name)
+				move, ctype, size := "MOVSS", "float", 32
+				if typ == "float64" {
+					move, ctype, size = "MOVSD", "double", 64
+				}
+				actual := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\nPUSHQ BX\nSUBQ $8,SP\n"+move+" X0,(SP)\nMOVQ SI,BX\nPUSHQ DX\nPOPFQ\n"+name+" (SP),BX\nMOVQ BX,(DI)\nPUSHFQ\nPOPQ AX\nMOVQ AX,8(DI)\nADDQ $8,SP\nPOPQ BX\nRET\n")
+				var bytes []string
+				for _, value := range actual {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+				}
+				original, symbol := "Original"+fn, "Original"+fn
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,%s,uint64_t,uint64_t);\n", fn, ctype)
+				prototypes.WriteString(x86OriginalSysVDeclaration("void", original, "uint8_t*,"+ctype+",uint64_t,uint64_t"))
+				if size == 32 {
+					fmt.Fprintf(&rows, "{%s,%s,0,0,%d,%d,32},\n", fn, original, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition)
+					fmt.Fprintf(&goRows, "{%s,nil,%d,%d,32},\n", fn, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition)
+				} else {
+					fmt.Fprintf(&rows, "{0,0,%s,%s,%d,%d,64},\n", fn, original, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition)
+					fmt.Fprintf(&goRows, "{nil,%s,%d,%d,64},\n", fn, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition)
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	if x86CMOVFPHasNumericConversion(ir) {
+		t.Fatal("CMOV floating bit views numerically converted")
+	}
+	reference := fmt.Sprintf(x86CMOVFPWholeBytesC, prototypes.String(), originals.String(), rows.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmov-fp-whole-bytes", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("cmov FP kernels %d translated/original whole-byte outcomes %d NaN/zero/flags/mxcsr/canary failures 0\n", count, count*64*8*2)
+			if string(output) != want {
+				t.Fatal("independent FP payload/predicate mismatch", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), fmt.Sprintf(x86CMOVFPOriginalGo, goRows.String()))
+	t.Logf("%d actual original Go ABI0 floating-source kernels ×64 flag seeds ×8 IEEE edge payloads; native host execution is not strict native Linux evidence", count)
+}
+
+var x86CMOVFPWholeBytesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+` + x86CMOVConditionC +
+	x86OriginalSysVPointer("void", "OriginalProgram32", "uint8_t*,float,uint64_t,uint64_t") +
+	x86OriginalSysVPointer("void", "OriginalProgram64", "uint8_t*,double,uint64_t,uint64_t") + `
+%s
+%s
+typedef void(*Program32)(uint8_t*,float,uint64_t,uint64_t);
+typedef void(*Program64)(uint8_t*,double,uint64_t,uint64_t);
+typedef struct {Program32 f32;OriginalProgram32 o32;Program64 f64;OriginalProgram64 o64;unsigned width,condition,bits;} Kernel;
+static Kernel kernels[]={%s};
+int main(void) {
+ const uint32_t bits32[]={0,0x80000000,0x7fc00001,0x7f800001,0xffc12345,0x7f800000,0xffffffff,0x00000001};
+ const uint64_t bits64[]={0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff8000000000001),UINT64_C(0x7ff0000000000001),UINT64_C(0xfff8123456789abc),UINT64_C(0x7ff0000000000000),UINT64_MAX,1};
+ unsigned count=0;
+ for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++) for(unsigned f=0;f<64;f++) for(unsigned v=0;v<8;v++) for(unsigned native=0;native<2;native++) {
+  Kernel kernel=kernels[k];uint8_t out[80];memset(out,0xa7,sizeof(out));
+  uint64_t source=kernel.bits==32?bits32[v]:bits64[v],old=UINT64_C(0x87654321fedcba98)^((uint64_t)v<<40),flags=seed(f),got,afterFlags;
+  uint32_t csr=0x1f80|((f%%4)<<13)|(f&63),saved=_mm_getcsr();_mm_setcsr(csr);
+  if(kernel.bits==32) {
+   float value;
+   memcpy(&value,bits32+v,4);
+   if(native) {
+    kernel.o32(out+32,value,old,flags);
+   } else {
+    kernel.f32(out+32,value,old,flags);
+   }
+  } else {
+   double value;
+   memcpy(&value,bits64+v,8);
+   if(native) {
+    kernel.o64(out+32,value,old,flags);
+   } else {
+    kernel.f64(out+32,value,old,flags);
+   }
+  }
+  uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+  memcpy(&got,out+32,8);memcpy(&afterFlags,out+40,8);
+  uint64_t mask=kernel.width==8?UINT64_MAX:((UINT64_C(1)<<(kernel.width*8))-1);
+  uint64_t selected=predicate(kernel.condition,flags)?source:old;
+  uint64_t want=kernel.width==2?((old&~mask)|(selected&mask)):(selected&mask);
+  if(got!=want||(afterFlags&0x8d5)!=flags||after!=csr) {fprintf(stderr,"kernel%%u native%%u payload%%llx got%%llx want%%llx\n",k,native,(unsigned long long)source,(unsigned long long)got,(unsigned long long)want);return 1;}
+  for(unsigned b=0;b<32;b++) if(out[b]!=0xa7||out[48+b]!=0xa7) return 2;
+  count++;
+ }
+ printf("cmov FP kernels %%zu translated/original whole-byte outcomes %%u NaN/zero/flags/mxcsr/canary failures 0\n",sizeof(kernels)/sizeof(kernels[0]),count);
+ return 0;
+}
+`
+
+const x86CMOVFPOriginalGo = `package oracle
+import("encoding/binary";"math";"testing")
+func TestOriginal(t *testing.T) {
+ kernels:=[]struct{f32 func(*[16]byte,float32,uint64,uint64);f64 func(*[16]byte,float64,uint64,uint64);width,condition,bits int}{%s}
+ bits32:=[]uint32{0,0x80000000,0x7fc00001,0x7f800001,0xffc12345,0x7f800000,0xffffffff,1}
+ bits64:=[]uint64{0,0x8000000000000000,0x7ff8000000000001,0x7ff0000000000001,0xfff8123456789abc,0x7ff0000000000000,0xffffffffffffffff,1}
+ count:=0
+ for k,kernel:=range kernels {for f:=uint64(0);f<64;f++ {for v:=0;v<8;v++ {
+  flags:=(f&1)|((f>>1&1)<<2)|((f>>2&1)<<4)|((f>>3&1)<<6)|((f>>4&1)<<7)|((f>>5&1)<<11)
+  cf,pf,zf,sf,of:=flags&1!=0,flags&4!=0,flags&64!=0,flags&128!=0,flags&2048!=0
+  predicates:=[]bool{!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf}
+  source:=bits64[v];if kernel.bits==32 {source=uint64(bits32[v])}
+  old:=uint64(0x87654321fedcba98)^(uint64(v)<<40);selected:=old;if predicates[kernel.condition] {selected=source}
+  mask:=uint64(0xffffffffffffffff);if kernel.width<8 {mask=(uint64(1)<<uint(kernel.width*8))-1}
+  want:=selected&mask;if kernel.width==2 {want|=old&^mask}
+  var out [16]byte;if kernel.bits==32 {kernel.f32(&out,math.Float32frombits(bits32[v]),old,flags)} else {kernel.f64(&out,math.Float64frombits(bits64[v]),old,flags)}
+  got,afterFlags:=binary.LittleEndian.Uint64(out[:8]),binary.LittleEndian.Uint64(out[8:])
+  if got!=want||afterFlags&0x8d5!=flags {t.Fatalf("kernel%%d bits%%x got%%x want%%x flags%%x",k,source,got,want,afterFlags)};count++
+ }}}
+ t.Logf("actual Go FP whole-byte outcomes %%d payload/zero/flags failures 0",count)
+}
+`
diff --git a/amd64_cmov_fp_bitview_test.go b/amd64_cmov_fp_bitview_test.go
new file mode 100644
index 000000000..d608ad119
--- /dev/null
+++ b/amd64_cmov_fp_bitview_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// CMOV reads bits, including NaN payloads and the sign bit of zero. A complete
+// declared floating field is numerical storage, not pointer/frame authority.
+func TestX86CMOVFamilyFPBitViewsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, typ := range []string{"float32", "float64"} {
+			for _, width := range []string{"W", "L", "Q"} {
+				if target.arch == "386" && width == "Q" || typ == "float32" && width == "Q" {
+					continue
+				}
+				var assembly strings.Builder
+				for _, condition := range x86CMOVOracleConditions {
+					fmt.Fprintf(&assembly, "CMOV%s%s f+0(FP),AX\n", width, condition.name)
+				}
+				size := map[string]int{"float32": 4, "float64": 8}[typ]
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", size, assembly.String())
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				initialized := strings.Replace(source, "\nCMOV", "\nXORL AX,AX\nCMOV", 1)
+				goAssemblerOracleOutput(t, target.arch, initialized, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+typ+"/"+width+"/"+api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value(f "+typ+")\n", target.arch, target.triple)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("original FP formats invented old AX or predicate FLAGS", api, err)
+						}
+						ir, err = x86OrderingHintTranslateAPI(t, api, initialized, "package ordering\nfunc Value(f "+typ+")\n", target.arch, target.triple)
+						if err != nil {
+							t.Fatal("existing complete floating logical bit-view was lost", err)
+						}
+						if x86CMOVFPHasNumericConversion(ir) {
+							t.Fatal("raw FP bytes were numerically converted")
+						}
+						compileLLVMToObject(t, llc, target.triple, "cmov-fp-"+api+".ll", "cmov-fp-"+api+".o", ir)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CMOVFamilyFPBitViewsExactPartialAndCrossSlotExtent(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, test := range []struct {
+			declaration, width, source string
+			size                       int
+			valid                      bool
+		}{
+			{"func Value(f float32)", "W", "f+2(FP)", 4, true},
+			{"func Value(f float64)", "L", "f+4(FP)", 8, true},
+			{"func Value(f float32)", "L", "f+1(FP)", 4, false},
+			{"func Value(f float64)", "Q", "f+1(FP)", 8, false},
+			{"func Value(f float32,g float32)", "Q", "f+0(FP)", 8, true},
+			{"func Value(f float32,g float32)", "L", "f+2(FP)", 8, true},
+			{"func Value(f float32,g uint32)", "Q", "f+0(FP)", 8, true},
+			{"func Value(f float32,g uint64)", "Q", "f+0(FP)", 16, false},
+			{"func Value(f float32,g *uint32)", "Q", "f+0(FP)", 16, false},
+			{"func Value(f *float64)", "Q", "f+0(FP)", 8, false},
+		} {
+			if target.arch == "386" && test.width == "Q" {
+				continue
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nCMOV%sLE %s,AX\nRET\n", test.size, test.width, test.source)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			initialized := strings.Replace(source, "\nCMOV", "\nXORL AX,AX\nCMOV", 1)
+			goAssemblerOracleOutput(t, target.arch, initialized, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+test.declaration+"/"+test.width+"/"+test.source+"/"+api, func(t *testing.T) {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+test.declaration+"\n", target.arch, target.triple)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original partial FP format invented old AX or predicate FLAGS", api, err)
+					}
+					ir, err = x86OrderingHintTranslateAPI(t, api, initialized, "package ordering\n"+test.declaration+"\n", target.arch, target.triple)
+					if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("complete bit span/holes/Ptr contract", err)
+					}
+					if test.valid && x86CMOVFPHasNumericConversion(ir) {
+						t.Fatal("FP byte reconstruction became a numerical conversion")
+					}
+					if test.valid {
+						compileLLVMToObject(t, llc, target.triple, "cmov-fp-span-"+api+".ll", "cmov-fp-span-"+api+".o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+// Common intrinsic declarations are not executed conversion instructions.
+func x86CMOVFPHasNumericConversion(ir string) bool {
+	return regexp.MustCompile(`(?m)^\s+%[^\n]+ = (fptosi|fptoui|call [^\n]*@llvm\.fpto(si|ui))`).MatchString(ir)
+}
diff --git a/amd64_cmov_fp_span_runtime_test.go b/amd64_cmov_fp_span_runtime_test.go
new file mode 100644
index 000000000..4f80b7525
--- /dev/null
+++ b/amd64_cmov_fp_span_runtime_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86CMOVFPPartialCrossSlotWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, prototypes, checks, goChecks strings.Builder
+	declarations.WriteString("package oracle\n")
+	for index, row := range []struct{ declaration, width, source, ctype, call, goCall, raw string }{
+		{"f float32,old uint64", "W", "f+2(FP)", "float,uint64_t", "f,old", "math.Float32frombits(a),old", "uint64_t(a)>>16"},
+		{"f float64,old uint64", "W", "f+6(FP)", "double,uint64_t", "d,old", "math.Float64frombits(q),old", "q>>48"},
+		{"f float64,old uint64", "L", "f+4(FP)", "double,uint64_t", "d,old", "math.Float64frombits(q),old", "q>>32"},
+		{"f,g float32,old uint64", "Q", "f+0(FP)", "float,float,uint64_t", "f,g,old", "math.Float32frombits(a),math.Float32frombits(b),old", "uint64_t(a)|(uint64_t(b)<<32)"},
+		{"f,g float32,old uint64", "L", "f+2(FP)", "float,float,uint64_t", "f,g,old", "math.Float32frombits(a),math.Float32frombits(b),old", "(uint64_t(a)|(uint64_t(b)<<32))>>16"},
+		{"f float32,g uint32,old uint64", "Q", "f+0(FP)", "float,uint32_t,uint64_t", "f,b,old", "math.Float32frombits(a),b,old", "uint64_t(a)|(uint64_t(b)<<32)"},
+	} {
+		fn := fmt.Sprintf("S%d", index)
+		fmt.Fprintf(&declarations, "func %s(%s) uint64\n", fn, row.declaration)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-24\nMOVQ old+8(FP),AX\nCLC\nCMOV%sCC %s,AX\nMOVQ AX,ret+16(FP)\nRET\n", fn, row.width, row.source)
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(%s);\n", fn, row.ctype)
+		raw := strings.ReplaceAll(row.raw, "uint64_t(", "uint64(")
+		craw := strings.ReplaceAll(row.raw, "uint64_t(", "(uint64_t)(")
+		want, goWant := "("+craw+")", "("+raw+")"
+		if row.width == "W" {
+			want, goWant = "((old&~UINT64_C(0xffff))|(("+craw+")&0xffff))", "((old&^uint64(0xffff))|(("+raw+")&0xffff))"
+		} else if row.width == "L" {
+			want, goWant = "(("+craw+")&UINT64_C(0xffffffff))", "(("+raw+")&uint64(0xffffffff))"
+		}
+		fmt.Fprintf(&checks, "if(%s(%s)!=%s) {fprintf(stderr,\"span%d mismatch\\n\");return 1;} count++;\n", fn, row.call, want, index)
+		fmt.Fprintf(&goChecks, "if got,want:=%s(%s),%s;got!=want {t.Fatalf(\"span%d got=%%x want=%%x\",got,want)};count++\n", fn, row.goCall, goWant, index)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	if x86CMOVFPHasNumericConversion(ir) {
+		t.Fatal("partial/cross-slot bits numerically converted")
+	}
+	reference := fmt.Sprintf(x86CMOVFPSpanC, prototypes.String(), checks.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmov-fp-spans", pipeline.ir, reference, pipeline.backend)
+			if string(output) != "cmov FP partial/cross-slot whole-byte outcomes 384 failures 0\n" {
+				t.Fatal("independent exact FP bytes", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), fmt.Sprintf(x86CMOVFPSpanGo, goChecks.String()))
+}
+
+const x86CMOVFPSpanC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+%s
+int main(void) {
+ const uint32_t bits[]={0,0x80000000,0x7fc00001,0x7f800001,0xffc12345,0x7f800000,0xffffffff,1};
+ const uint64_t wide[]={0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff8000000000001),UINT64_C(0x7ff0000000000001),UINT64_C(0xfff8123456789abc),UINT64_C(0x7ff0000000000000),UINT64_MAX,1};
+ unsigned count=0;
+ for(unsigned x=0;x<8;x++) for(unsigned y=0;y<8;y++) {
+  uint32_t a=bits[x],b=bits[y];uint64_t q=wide[x],old=UINT64_C(0x87654321fedcba98)^((uint64_t)y<<40);
+  float f,g;double d;memcpy(&f,&a,4);memcpy(&g,&b,4);memcpy(&d,&q,8);
+  %s
+ }
+ printf("cmov FP partial/cross-slot whole-byte outcomes %%u failures 0\n",count);return 0;
+}
+`
+
+const x86CMOVFPSpanGo = `package oracle
+import("math";"testing")
+func TestOriginal(t *testing.T) {
+ bits:=[]uint32{0,0x80000000,0x7fc00001,0x7f800001,0xffc12345,0x7f800000,0xffffffff,1}
+ wide:=[]uint64{0,0x8000000000000000,0x7ff8000000000001,0x7ff0000000000001,0xfff8123456789abc,0x7ff0000000000000,0xffffffffffffffff,1}
+ count:=0
+ for x,a:=range bits {for y,b:=range bits {q:=wide[x];old:=uint64(0x87654321fedcba98)^(uint64(y)<<40)
+ %s
+ }}
+ if count!=384 {t.Fatal(count)};t.Logf("actual Go partial/cross-slot outcomes %%d failures 0",count)
+}
+`
diff --git a/amd64_cmov_runtime_test.go b/amd64_cmov_runtime_test.go
new file mode 100644
index 000000000..423467102
--- /dev/null
+++ b/amd64_cmov_runtime_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Actual Go-emitted bytes are embedded in independent native wrappers; none
+// of the C arithmetic or condition reference is derived from the typed forms.
+func TestCrossLinuxRuntimeMatrixX86CMOVIndependentWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, originals, prototypes, rows strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	count := 0
+	for _, width := range []string{"W", "L", "Q"} {
+		for condition, row := range x86CMOVOracleConditions {
+			name := "CMOV" + width + row.name
+			for mode, source := range []string{"BX", "(SI)", "AX"} {
+				fn := fmt.Sprintf("C%d", count)
+				count++
+				fmt.Fprintf(&declarations, "func %s(out *[16]byte,src *[8]byte,old,seed uint64)\n", fn)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ src+8(FP),SI\nMOVQ old+16(FP),AX\nMOVQ (SI),BX\nPUSHQ seed+24(FP)\nPOPFQ\n%s %s,AX\nMOVQ AX,(DI)\nPUSHFQ\nPOPQ AX\nMOVQ AX,8(DI)\nRET\n", fn, name, source)
+				original := "Original" + fn
+				actual := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\nPUSHQ BX\nMOVQ DX,AX\nMOVQ (SI),BX\nPUSHQ CX\nPOPFQ\n"+name+" "+source+",AX\nMOVQ AX,(DI)\nPUSHFQ\nPOPQ AX\nMOVQ AX,8(DI)\nPOPQ BX\nRET\n")
+				var bytes []string
+				for _, value := range actual {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+				}
+				symbol := original
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,uint64_t,uint64_t);\n", fn)
+				prototypes.WriteString(x86OriginalSysVDeclaration("void", original, "uint8_t*,const uint8_t*,uint64_t,uint64_t"))
+				fmt.Fprintf(&rows, "{%s,%s,%d,%d,%d},\n", fn, original, map[string]int{"W": 2, "L": 4, "Q": 8}[width], condition, mode)
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	reference := fmt.Sprintf(x86CMOVWholeBytesC, prototypes.String(), originals.String(), rows.String())
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmov-whole-bytes", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("cmov kernels %d translated/original whole-byte outcomes %d flags/mxcsr/input/canary failures 0\n", count, count*64*3*2)
+			if string(output) != want {
+				t.Fatal("independent full bytes, flags and native predicate mismatch", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+const x86CMOVConditionC = `
+static int predicate(unsigned c,uint64_t f) {
+ int cf=(f>>0)&1,pf=(f>>2)&1,zf=(f>>6)&1,sf=(f>>7)&1,of=(f>>11)&1;
+ switch(c) {
+ case 0:return !cf;case 1:return cf;case 2:return zf;case 3:return sf==of;
+ case 4:return !zf&&sf==of;case 5:return !cf&&!zf;case 6:return zf||sf!=of;
+ case 7:return cf||zf;case 8:return sf!=of;case 9:return sf;case 10:return !zf;
+ case 11:return !of;case 12:return of;case 13:return !pf;case 14:return !sf;case 15:return pf;
+ }return -1;
+}
+static uint64_t seed(unsigned n) {
+ return ((uint64_t)(n&1))|((uint64_t)((n>>1)&1)<<2)|((uint64_t)((n>>2)&1)<<4)|
+ ((uint64_t)((n>>3)&1)<<6)|((uint64_t)((n>>4)&1)<<7)|((uint64_t)((n>>5)&1)<<11);
+}
+`
+
+var x86CMOVWholeBytesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+` + x86CMOVConditionC +
+	x86OriginalSysVPointer("void", "OriginalProgram", "uint8_t*,const uint8_t*,uint64_t,uint64_t") + `
+%s
+%s
+typedef void(*Program)(uint8_t*,const uint8_t*,uint64_t,uint64_t);
+typedef struct {Program translated;OriginalProgram original;unsigned width,condition,mode;} Kernel;
+static Kernel kernels[]={%s};
+struct Guard {uint8_t before[32],value[16],after[32];};
+int main(void) {
+ unsigned count=0;
+ const uint64_t edges[]={UINT64_C(0x87654321fedcba98),UINT64_C(0xffff000080000001),UINT64_C(0x0123456789abcdef)};
+ for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++) for(unsigned f=0;f<64;f++) for(unsigned v=0;v<3;v++) for(unsigned native=0;native<2;native++) {
+  Kernel kernel=kernels[k];struct Guard out;memset(&out,0xa7,sizeof(out));
+  uint8_t input[10],copy[10];memset(input,0x59,sizeof(input));
+  uint64_t source=edges[(v+1)%%3],old=edges[v],flags=seed(f),got=0,afterFlags=0;
+  memcpy(input+1,&source,8);memcpy(copy,input,sizeof(input));
+  uint32_t csr=0x1f80|((f%%4)<<13)|(f&63),saved=_mm_getcsr();_mm_setcsr(csr);
+  if(native) {
+   kernel.original(out.value,input+1,old,flags);
+  } else {
+   kernel.translated(out.value,input+1,old,flags);
+  }
+  uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+  memcpy(&got,out.value,8);memcpy(&afterFlags,out.value+8,8);
+  uint64_t mask=kernel.width==8?UINT64_MAX:((UINT64_C(1)<<(kernel.width*8))-1);
+  uint64_t selected=predicate(kernel.condition,flags)?(kernel.mode==2?old:source):old;
+  uint64_t want=kernel.width==2?((old&~mask)|(selected&mask)):(selected&mask);
+  if(got!=want||(afterFlags&0x8d5)!=flags||after!=csr||memcmp(input,copy,sizeof(input))) {
+   fprintf(stderr,"kernel%%u native%%u width%%u flags%%llx got%%llx want%%llx observedflags%%llx\n",k,native,kernel.width,(unsigned long long)flags,(unsigned long long)got,(unsigned long long)want,(unsigned long long)afterFlags);return 1;
+  }
+  for(unsigned b=0;b<32;b++) if(out.before[b]!=0xa7||out.after[b]!=0xa7) return 2;
+  count++;
+ }
+ printf("cmov kernels %%zu translated/original whole-byte outcomes %%u flags/mxcsr/input/canary failures 0\n",sizeof(kernels)/sizeof(kernels[0]),count);
+ return 0;
+}
+`
diff --git a/amd64_cmpxchg_actual_observation_test.go b/amd64_cmpxchg_actual_observation_test.go
new file mode 100644
index 000000000..5bc22d05b
--- /dev/null
+++ b/amd64_cmpxchg_actual_observation_test.go
@@ -0,0 +1,353 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86CMPXCHGActualObservation struct {
+	output [16]uint64
+	csr    uint32
+	bytes  [96]byte
+}
+
+type x86CMPXCHGActualPacket struct {
+	rows       [576]x86CMPXCHGActualObservation
+	deviations int
+}
+
+// This is transport/opcode equivalence, not a pass of the mathematical ISA
+// model. The separate original-Go/C strict roots still reject every deviation.
+func TestX86CMPXCHGOriginalGoAndCCompleteObservationEquivalence(t *testing.T) {
+	x86CMPXCHGActualEquivalence(t, x86FloatCompareExecutionTools(t))
+}
+
+func x86CMPXCHGActualEquivalence(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	declarations, assembly, names := x86CMPXCHGNumericalFixture()
+	x86CMPXCHGCSRControlObject(t)
+	declarations += "func resetCSR()\nfunc restoreCSR(value uint32)\n"
+	assembly += x86CMPXCHGCSRControlAssembly
+	goDriver := strings.Replace(x86CMPXCHGGoNumerical, "KERNEL_NAMES", names, 1)
+	goDriver = x86CMPXCHGObserveGoDriver(t, goDriver)
+	t.Logf("actual diagnostic declaration/assembly/Go-driver SHA256 %x/%x/%x", sha256.Sum256([]byte(declarations)), sha256.Sum256([]byte(assembly)), sha256.Sum256([]byte(goDriver)))
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), runtime.GOOS, "amd64", declarations, assembly, goDriver)
+	goOutput := execution.run(t, original)
+	t.Logf("actual original Go complete observer stdout:\n%s", goOutput)
+	goPacket, err := x86CMPXCHGParseActualPacket(goOutput)
+	if err != nil {
+		t.Fatalf("actual original Go complete observation: %v", err)
+	}
+	cDriver := x86CMPXCHGObserveCDriver(t, x86CMPXCHGOriginalCSource())
+	t.Logf("actual diagnostic independent C-driver SHA256 %x", sha256.Sum256([]byte(cDriver)))
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			cOutput := x86CMPXCHGCompileOriginalC(t, execution, cDriver, level)
+			t.Logf("actual independent C complete observer stdout:\n%s", cOutput)
+			cPacket, err := x86CMPXCHGParseActualPacket(cOutput)
+			if err != nil {
+				t.Fatalf("actual independent C opcode complete observation: %v", err)
+			}
+			if goPacket.deviations != cPacket.deviations {
+				t.Errorf("independent mathematical deviation counts differ: Go=%d C=%d", goPacket.deviations, cPacket.deviations)
+			}
+			mismatches := 0
+			for ordinal, goRow := range goPacket.rows {
+				if goRow != cPacket.rows[ordinal] {
+					if mismatches < 2 {
+						t.Logf("actual observation %d differs: Go=%+v C=%+v", ordinal, goRow, cPacket.rows[ordinal])
+					}
+					mismatches++
+				}
+			}
+			if mismatches != 0 {
+				t.Errorf("complete actual Go/C observations differ: %d/576", mismatches)
+			}
+			t.Logf("actual Go/C complete observations=576 equal; mathematical/ISA deviations=%d; equivalence only, not native ISA numerical P", goPacket.deviations)
+		})
+	}
+}
+
+const x86CMPXCHGCSRControlAssembly = `
+DATA cmpxchgCSRseed<>+0(SB)/4,$0x1f80
+GLOBL cmpxchgCSRseed<>(SB),8,$4
+TEXT ·resetCSR(SB),4,$0-0
+LDMXCSR cmpxchgCSRseed<>(SB)
+RET
+TEXT ·restoreCSR(SB),4,$0-4
+LDMXCSR value+0(FP)
+RET
+`
+
+func x86CMPXCHGCSRControlObject(t *testing.T) {
+	t.Helper()
+	directory := t.TempDir()
+	source, object := filepath.Join(directory, "control.s"), filepath.Join(directory, "control.o")
+	if err := os.WriteFile(source, []byte(x86CMPXCHGCSRControlAssembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "asm", "-S",
+		"-p", "ordering", "-o", object, source)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64", "GOFLAGS=", "GOENV=off", "GOWORK=off")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(source, object, output, err, ctx.Err(), true, "amd64"); failure != nil {
+		t.Fatalf("actual CSR control object: %v\n%s", failure, output)
+	}
+	if !strings.Contains(string(output), "0f ae 15 00 00 00 00 c3") ||
+		!strings.Contains(string(output), "0f ae 54 24 08 c3") ||
+		!strings.Contains(string(output), "80 1f 00 00") || strings.Count(string(output), "LDMXCSR") != 2 {
+		t.Fatalf("actual DATA source/load/restore bytes changed:\n%s", output)
+	}
+	bytes, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual source/Go CSR object SHA256 %x/%x; complete listing:\n%s", sha256.Sum256([]byte(x86CMPXCHGCSRControlAssembly)), sha256.Sum256(bytes), output)
+}
+
+func x86CMPXCHGObserverReplace(t *testing.T, source, from, to string) string {
+	t.Helper()
+	if strings.Count(source, from) != 1 {
+		t.Fatalf("independent observer seam disappeared or became ambiguous: %q", from)
+	}
+	return strings.Replace(source, from, to, 1)
+}
+
+// The exact assembly and strict mathematical drivers are not changed. These
+// diagnostic drivers only emit every actual observation and separate canary/
+// CSR transport failure from the already-preserved mathematical deviation.
+func x86CMPXCHGObserveGoDriver(t *testing.T, source string) string {
+	t.Helper()
+	source = x86CMPXCHGObserverReplace(t, source, "observations, failures := 0, 0", "observations, failures, transportFailures := 0, 0, 0")
+	source = x86CMPXCHGObserverReplace(t, source, "if failures < 24 {", "if false && failures < 24 {")
+	source = x86CMPXCHGObserverReplace(t, source, "if kernelFailures != 0 {", "if false && kernelFailures != 0 {")
+	source = x86CMPXCHGObserverReplace(t, source, "                    before := csr()", "                    originalCSR := csr()\n                    resetCSR()\n                    before := csr()")
+	source = x86CMPXCHGObserverReplace(t, source, "                    after := csr()", "                    after := csr()\n                    restoreCSR(originalCSR)\n                    restoredCSR := csr()")
+	source = x86CMPXCHGObserverReplace(t, source, "                    observations++", `                    transportBad := out[6]>>32 != canary>>32 || csr != before || after != before || restoredCSR != originalCSR || raw != expectedRaw
+                    for i := 7; i < len(out); i++ { transportBad = transportBad || out[i] != canary }
+                    if transportBad { transportFailures++ }
+                    fmt.Printf("OBS %d %d %d %d", index, observations%48/4, map[bool]int{false:0, true:1}[equal], observations%2)
+                    for i, value := range out {
+                        if i == 4 { value &= 0x8d5 }
+                        fmt.Printf(" %x", value)
+                    }
+                    fmt.Printf(" %x %x %x %x %x\n", before, after, originalCSR, restoredCSR, raw)
+                    observations++`)
+	source = x86CMPXCHGObserverReplace(t, source,
+		`    fmt.Printf("original CMPXCHG numerical observations %d failures %d\n", observations, failures)
+    if failures != 0 { os.Exit(1) }`,
+		`    fmt.Printf("END %d %d %d\n", observations, failures, transportFailures)
+    if transportFailures != 0 { os.Exit(1) }`)
+	return source
+}
+
+func x86CMPXCHGObserveCDriver(t *testing.T, source string) string {
+	t.Helper()
+	source = x86CMPXCHGObserverReplace(t, source, "unsigned observations = 0, failures = 0;", "unsigned observations = 0, failures = 0, transport_failures = 0;")
+	source = x86CMPXCHGObserverReplace(t, source, "if (kernel_failures <= 2) {", "if (0 && kernel_failures <= 2) {")
+	source = x86CMPXCHGObserverReplace(t, source, "if (kernel_failures) {", "if (0 && kernel_failures) {")
+	source = x86CMPXCHGObserverReplace(t, source, `                    __asm__ volatile("stmxcsr %0" : "=m"(before));`,
+		`                    unsigned original_csr, controlled_csr = 0x1f80;
+                    __asm__ volatile("stmxcsr %0" : "=m"(original_csr));
+                    __asm__ volatile("ldmxcsr %0" : : "m"(controlled_csr));
+                    __asm__ volatile("stmxcsr %0" : "=m"(before));`)
+	source = x86CMPXCHGObserverReplace(t, source, `                    __asm__ volatile("stmxcsr %0" : "=m"(after));`,
+		`                    __asm__ volatile("stmxcsr %0" : "=m"(after));
+                    __asm__ volatile("ldmxcsr %0" : : "m"(original_csr));
+                    unsigned restored_csr;
+                    __asm__ volatile("stmxcsr %0" : "=m"(restored_csr));`)
+	source = x86CMPXCHGObserverReplace(t, source, "                    observations++;", `                    int transport_bad = (out[6]>>32) != (canary>>32) ||
+                        (uint32_t)out[6] != before || after != before || restored_csr != original_csr || memcmp(raw, expected, sizeof(raw));
+                    for (unsigned i = 7; i < 16; i++) transport_bad |= out[i] != canary;
+                    transport_failures += transport_bad != 0;
+                    printf("OBS %u %u %u %u", index, edge, equal, seed);
+                    for (unsigned i = 0; i < 16; i++) {
+                        uint64_t value = i == 4 ? out[i]&0x8d5 : out[i];
+                        printf(" %llx", (unsigned long long)value);
+                    }
+                    printf(" %x %x %x %x ", before, after, original_csr, restored_csr);
+                    for (unsigned i = 0; i < sizeof(raw); i++) printf("%02x", raw[i]);
+                    printf("\n");
+                    observations++;`)
+	source = x86CMPXCHGObserverReplace(t, source,
+		`    printf("actual C opcode CMPXCHG numerical observations %u failures %u\n", observations, failures);
+    return failures ? 1 : 0;`,
+		`    printf("END %u %u %u\n", observations, failures, transport_failures);
+    return transport_failures ? 1 : 0;`)
+	return source
+}
+
+func x86CMPXCHGParseActualPacket(output []byte) (x86CMPXCHGActualPacket, error) {
+	var packet x86CMPXCHGActualPacket
+	lines := strings.Split(string(output), "\n")
+	if len(output) > 1<<20 || len(lines) != 578 || lines[577] != "" {
+		return packet, fmt.Errorf("incomplete, extra or over-bound actual observation output")
+	}
+	// Windows C stdio emits CRLF. Accept that text transport without
+	// trimming field whitespace or discarding malformed embedded CR bytes.
+	for index := range lines {
+		lines[index] = strings.TrimSuffix(lines[index], "\r")
+	}
+	parse := func(text string, base, bits int) (uint64, error) {
+		value, err := strconv.ParseUint(text, base, bits)
+		if err != nil || strconv.FormatUint(value, base) != text {
+			return 0, fmt.Errorf("noncanonical actual value %q", text)
+		}
+		return value, nil
+	}
+	for ordinal, line := range lines[:576] {
+		fields := strings.Split(line, " ")
+		if len(fields) != 26 || fields[0] != "OBS" {
+			return packet, fmt.Errorf("actual observation %d has incomplete/unknown fields", ordinal)
+		}
+		want := []int{ordinal / 48, ordinal % 48 / 4, ordinal % 4 / 2, ordinal % 2}
+		for index, value := range want {
+			if fields[index+1] != strconv.Itoa(value) {
+				return packet, fmt.Errorf("duplicate, missing or reordered actual observation %d", ordinal)
+			}
+		}
+		row := &packet.rows[ordinal]
+		for index := range row.output {
+			value, err := parse(fields[index+5], 16, 64)
+			if err != nil {
+				return packet, err
+			}
+			row.output[index] = value
+		}
+		before, err := parse(fields[21], 16, 32)
+		if err != nil {
+			return packet, err
+		}
+		after, err := parse(fields[22], 16, 32)
+		if err != nil || before != 0x1f80 || before != after || uint32(row.output[6]) != uint32(before) {
+			return packet, fmt.Errorf("actual MXCSR transport changed at observation %d", ordinal)
+		}
+		row.csr = uint32(before)
+		// Ambient input differs between independent Go/C processes. Preserve
+		// both complete values in the raw trace and require exact restoration;
+		// opcode equality concerns the identical controlled MXCSR input.
+		originalCSR, err := parse(fields[23], 16, 32)
+		if err != nil {
+			return packet, err
+		}
+		restoredCSR, err := parse(fields[24], 16, 32)
+		if err != nil || originalCSR != restoredCSR {
+			return packet, fmt.Errorf("actual ambient MXCSR restoration failed at observation %d", ordinal)
+		}
+		if row.output[4]&^uint64(0x8d5) != 0 || row.output[5] != row.output[4]&0xd5|2 || row.output[6]>>32 != 0xa7a7a7a7 {
+			return packet, fmt.Errorf("actual status/LAHF or output canary was incomplete at observation %d", ordinal)
+		}
+		for index := 7; index < 16; index++ {
+			if row.output[index] != 0xa7a7a7a7a7a7a7a7 {
+				return packet, fmt.Errorf("actual output canary changed at observation %d", ordinal)
+			}
+		}
+		if len(fields[25]) != 192 || strings.ToLower(fields[25]) != fields[25] {
+			return packet, fmt.Errorf("actual complete byte observation missing at %d", ordinal)
+		}
+		bytes, err := hex.DecodeString(fields[25])
+		if err != nil {
+			return packet, err
+		}
+		copy(row.bytes[:], bytes)
+		family := ordinal / 96
+		start := 17
+		if family == 5 {
+			start = 16
+		}
+		width := []int{1, 2, 4, 8, 8, 16}[family]
+		for index, value := range row.bytes {
+			if (index < start || index >= start+width) && value != 0xa7 {
+				return packet, fmt.Errorf("actual input canary changed at observation %d", ordinal)
+			}
+		}
+	}
+	footer := strings.Split(lines[576], " ")
+	if len(footer) != 4 || footer[0] != "END" || footer[1] != "576" || footer[3] != "0" {
+		return packet, fmt.Errorf("actual observer has missing/unknown/nonzero transport terminal")
+	}
+	deviations, err := parse(footer[2], 10, 16)
+	if err != nil || deviations > 576 {
+		return packet, fmt.Errorf("actual observer has invalid mathematical deviation count")
+	}
+	packet.deviations = int(deviations)
+	return packet, nil
+}
+
+func TestX86CMPXCHGActualObservationPacketRejectsIncompleteTransport(t *testing.T) {
+	// Synthetic output-protocol tripwires, not actual opcode execution evidence.
+	var source strings.Builder
+	for ordinal := 0; ordinal < 576; ordinal++ {
+		fmt.Fprintf(&source, "OBS %d %d %d %d", ordinal/48, ordinal%48/4, ordinal%4/2, ordinal%2)
+		for index := 0; index < 16; index++ {
+			value := uint64(0xa7a7a7a7a7a7a7a7)
+			switch index {
+			case 4:
+				value = 64
+			case 5:
+				value = 66
+			case 6:
+				value = 0xa7a7a7a700001f80
+			}
+			fmt.Fprintf(&source, " %x", value)
+		}
+		fmt.Fprintf(&source, " 1f80 1f80 1f80 1f80 %s\n", strings.Repeat("a7", 96))
+	}
+	source.WriteString("END 576 0 0\n")
+	valid := source.String()
+	packet, err := x86CMPXCHGParseActualPacket([]byte(valid))
+	if err != nil || packet.deviations != 0 {
+		t.Fatalf("complete synthetic protocol control: %v", err)
+	}
+	for name, output := range map[string]string{
+		"CRLF":  strings.ReplaceAll(valid, "\n", "\r\n"),
+		"mixed": strings.Replace(valid, "\n", "\r\n", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			actual, err := x86CMPXCHGParseActualPacket([]byte(output))
+			if err != nil || actual != packet {
+				t.Fatalf("text-mode line endings changed the complete observation: %v", err)
+			}
+		})
+	}
+	for name, mutation := range map[string]string{
+		"bare-CR":         strings.Replace(valid, "\n", "\r", 1),
+		"double-CR":       strings.Replace(valid, "\n", "\r\r\n", 1),
+		"embedded-CR":     strings.Replace(valid, "OBS 0", "OBS\r 0", 1),
+		"missing":         strings.TrimSuffix(valid, "END 576 0 0\n"),
+		"unknown":         valid + "unknown\n",
+		"duplicate":       strings.Replace(valid, "OBS 0 0 0 1", "OBS 0 0 0 0", 1),
+		"truncated":       strings.Replace(valid, strings.Repeat("a7", 96), "a7", 1),
+		"canary":          strings.Replace(valid, strings.Repeat("a7", 96), "a6"+strings.Repeat("a7", 95), 1),
+		"changed-CSR":     strings.Replace(valid, "1f80 1f80", "1f80 1f81", 1),
+		"uncontrolled":    strings.Replace(valid, "1f80 1f80", "1fa0 1fa0", 1),
+		"unrestored":      strings.Replace(valid, "1f80 1f80 1f80 1f80", "1f80 1f80 1fa0 1f80", 1),
+		"unknown-LAHF":    strings.Replace(valid, " 40 42 ", " 40 43 ", 1),
+		"transport-exit":  strings.Replace(valid, "END 576 0 0", "END 576 0 1", 1),
+		"wrong-count":     strings.Replace(valid, "END 576", "END 575", 1),
+		"overflow":        strings.Replace(valid, "END 576 0 0", "END 576 65536 0", 1),
+		"diagnostic-only": "END 576 240 0\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := x86CMPXCHGParseActualPacket([]byte(mutation)); err == nil {
+				t.Fatal("incomplete/unknown actual transport got equivalence credit")
+			}
+		})
+	}
+	mutated := packet
+	mutated.rows[575].output[0] ^= 1
+	if reflect.DeepEqual(packet, mutated) {
+		t.Fatal("full observation comparison did not retain a late register byte")
+	}
+}
diff --git a/amd64_cmpxchg_boundaries_test.go b/amd64_cmpxchg_boundaries_test.go
new file mode 100644
index 000000000..2b6f86c64
--- /dev/null
+++ b/amd64_cmpxchg_boundaries_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86CMPXCHGDirectHelpersCannotBypassOrderedGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			op       Op
+			identity Op
+			bits     int
+			pair     bool
+			args     []Operand
+			context  bool
+		}{
+			{"CMPXCHG8B", "CMPXCHG8B", 64, true, []Operand{{Kind: OpReg, Reg: BX}}, true},
+			{"CMPXCHGL", "MOVL", 32, false, []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: BX}}, false},
+			{"CMPXCHGL", "CMPXCHGL", 16, false, []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: BX}}, false},
+			{"UNKNOWN", "UNKNOWN", 32, false, []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: BX}}, false},
+		} {
+			t.Run(fmt.Sprintf("%s/%s/%s/width=%d", arch, row.op, row.identity, row.bits), func(t *testing.T) {
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before, temporary := output.String(), ctx.tmp
+				ins := Instr{Op: row.identity, Args: row.args}
+				var known, terminated bool
+				var err error
+				if row.pair {
+					known, terminated, err = ctx.lowerPairCompareExchange(string(row.op), row.bits, ins)
+				} else {
+					known, terminated, err = ctx.lowerScalarCompareExchange(string(row.op), row.bits, ins)
+				}
+				if !known || terminated || err == nil || errors.Is(err, ErrProbeNeedsContext) != row.context ||
+					before != output.String() || temporary != ctx.tmp {
+					t.Fatalf("direct helper bypassed complete grammar or emitted partial IR: %t/%t/%v", known, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CMPXCHGFPRequiresCompleteNativeExtentAndIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := testTargetTriple("linux", arch)
+		for _, row := range []struct {
+			body, declaration string
+			valid             bool
+		}{
+			{"CMPXCHGB CL,value+0(FP)", "func locked(value uint8)", true},
+			{"CMPXCHGW CX,value+0(FP)", "func locked(value uint8)", false},
+			{"CMPXCHGL CX,value+0(FP)", "func locked(value uint16)", false},
+			{"CMPXCHG8B value+0(FP)", "func locked(value uint32)", false},
+			{"CMPXCHGL CX,value+2(FP)", "func locked(value uint32)", false},
+			{"CMPXCHGL CX,value+8(FP)", "func locked(value uint32)", false},
+		} {
+			t.Run(arch+"/"+row.body+"/"+row.declaration, func(t *testing.T) {
+				source := "TEXT ·locked(SB),4,$0-16\nMOVL $1,AX\nMOVL $2,BX\nMOVL $3,CX\nMOVL $4,DX\n" + row.body + "\nRET\n"
+				actual := x86OrderingHintGoBytes(t, arch, source)
+				t.Logf("actual Go accepts the source spelling: %x; this does not prove its typed FP extent", actual)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\n"+row.declaration+"\n", arch, triple)
+					if row.valid {
+						if err != nil || !strings.Contains(ir, "cmpxchgb") {
+							t.Fatalf("complete pre-existing one-byte FP extent was rejected in %s: %v", api, err)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), triple, "fp-control.ll", "fp-control.o", ir)
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("incomplete FP native extent acquired an atomic write in %s: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("amd64/16B/shadow/"+api, func(t *testing.T) {
+			source := "TEXT ·locked(SB),4,$0-16\nMOVL $1,AX\nMOVL $2,BX\nMOVL $3,CX\nMOVL $4,DX\nCMPXCHG16B value+0(FP)\nRET\n"
+			actual := x86OrderingHintGoBytes(t, "amd64", source)
+			t.Logf("actual original FP16 opcode: %x; no native alignment identity supplied by a logical shadow", actual)
+			ir, err := x86OrderingHintTranslateAPI(t, api, source,
+				"package ordering\nfunc locked(value [2]uint64)\n", "amd64", "x86_64-unknown-linux-gnu")
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("virtual FP shadow fabricated CMPXCHG16B native address/alignment: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86CMPXCHGFPBackendRequiresExplicitNativeTarget(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		otherMode := "i386-unknown-linux-gnu"
+		if arch == "386" {
+			otherMode = "x86_64-unknown-linux-gnu"
+		}
+		// Use the complete byte extent from the positive owner. A missing
+		// implicit register or FP byte must not substitute for backend rejection.
+		source := "TEXT ·locked(SB),4,$0-16\nMOVL $1,AX\nMOVL $2,BX\nMOVL $3,CX\nMOVL $4,DX\nCMPXCHGB CL,value+0(FP)\nRET\n"
+		x86OrderingHintGoBytes(t, arch, source)
+		for _, triple := range []string{"", otherMode, "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\nfunc locked(value uint8)\n", arch, triple)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "inline assembly") {
+						t.Fatal("complete native FP CAS escaped an absent or foreign backend", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_cmpxchg_fault_observer_test.go b/amd64_cmpxchg_fault_observer_test.go
new file mode 100644
index 000000000..d4eddf50b
--- /dev/null
+++ b/amd64_cmpxchg_fault_observer_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func x86CMPXCHGObserveFault(t *testing.T, execution x86FloatCompareExecution, executable string, index, address, original int) (string, error) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	return x86CMPXCHGObserveFaultContext(ctx, execution, executable, index, address, original)
+}
+
+func x86CMPXCHGObserveFaultContext(ctx context.Context, execution x86FloatCompareExecution, executable string, index, address, original int) (string, error) {
+	// Each leaf executable is the owned child: no fork, descendant, exception
+	// handler or native unwinder can hide the actual instruction's termination.
+	child, cancel := context.WithTimeout(ctx, 30*time.Second)
+	defer cancel()
+	args := execution.command(executable, strconv.Itoa(index), strconv.Itoa(address), strconv.Itoa(original))
+	stdout, stderr, err := runtimeOracleMachineOutput(child, exec.CommandContext(child, args[0], args[1:]...))
+	if child.Err() != nil {
+		return "", child.Err()
+	}
+	witness := fmt.Sprintf("CMPXCHG enter %d %d %d\n", index, address, original)
+	result, cause := x86CMPXCHGFaultResult(runtime.GOOS, string(stdout), witness, err)
+	if cause != nil {
+		return "", fmt.Errorf("kernel %d address %d original %d: %w\nstdout: %q\nstderr: %q", index, address, original, cause, stdout, stderr)
+	}
+	return result, nil
+}
+
+func x86CMPXCHGFaultResult(goos, stdout, witness string, err error) (string, error) {
+	result, cause := x86NativeFaultResult(goos, stdout, witness, "CMPXCHG complete\n", err)
+	if cause == nil && result == "fpe" {
+		return "", fmt.Errorf("floating-point fault is not a CMPXCHG outcome")
+	}
+	return result, cause
+}
+
+func x86NativeFaultResult(goos, stdout, witness, completed string, err error) (string, error) {
+	if err == nil {
+		if stdout == witness+completed {
+			return "return", nil
+		}
+		return "", fmt.Errorf("missing exact completed state/canary receipt")
+	}
+	// Do not unwrap joined errors: cancellation, pipes and ownership cleanup
+	// failures must not become accepted native exceptions.
+	exit, ok := err.(*exec.ExitError)
+	if !ok || exit.ProcessState == nil || stdout != witness {
+		return "", fmt.Errorf("not an isolated native fault after the exact entry receipt: %w", err)
+	}
+	status, ok := exit.ProcessState.Sys().(syscall.WaitStatus)
+	if !ok {
+		return "", fmt.Errorf("missing actual process termination status")
+	}
+	if goos == "windows" {
+		return x86NativeWindowsFault(uint32(exit.ExitCode()))
+	}
+	if status.Signaled() {
+		switch status.Signal() {
+		case syscall.SIGSEGV:
+			return "segv", nil
+		case syscall.SIGBUS:
+			return "bus", nil
+		case syscall.SIGILL:
+			return "ill", nil
+		case syscall.SIGFPE:
+			return "fpe", nil
+		}
+	}
+	return "", fmt.Errorf("setup, state or unexpected process failure: %w", err)
+}
+
+func x86NativeWindowsFault(code uint32) (string, error) {
+	if code == 0xc000008f { // EXCEPTION_FLT_INEXACT_RESULT, not other FP exceptions.
+		return "fpe", nil
+	}
+	return x86CMPXCHGWindowsFault(code)
+}
+
+func TestX86NativeWindowsPrecisionFaultCode(t *testing.T) {
+	if got, err := x86NativeWindowsFault(0xc000008f); err != nil || got != "fpe" {
+		t.Fatalf("native precision exception: %s, %v", got, err)
+	}
+	for _, code := range []uint32{136, 0xc000008e, 0xc0000090, 0xc0000091, 0xc0000094} {
+		if _, err := x86NativeWindowsFault(code); err == nil {
+			t.Fatalf("different exception/ordinary exit became precision evidence: %#x", code)
+		}
+	}
+	if _, err := x86CMPXCHGWindowsFault(0xc000008f); err == nil {
+		t.Fatal("precision exception became a registered CMPXCHG fault")
+	}
+}
+
+func x86CMPXCHGWindowsFault(code uint32) (string, error) {
+	// GetExitCodeProcess returns the unhandled exception value, not 128+signal.
+	// Keep only these three native exception classes; ordinary exits never
+	// count as faults, even when original and translated setup fail identically.
+	switch code {
+	case 0xc0000005: // EXCEPTION_ACCESS_VIOLATION
+		return "segv", nil
+	case 0x80000002: // EXCEPTION_DATATYPE_MISALIGNMENT
+		return "bus", nil
+	case 0xc000001d: // EXCEPTION_ILLEGAL_INSTRUCTION
+		return "ill", nil
+	}
+	return "", fmt.Errorf("not a registered native Windows exception: %#x", code)
+}
+
+func TestX86CMPXCHGWindowsFaultCodes(t *testing.T) {
+	for code, want := range map[uint32]string{0xc0000005: "segv", 0x80000002: "bus", 0xc000001d: "ill"} {
+		if got, err := x86CMPXCHGWindowsFault(code); err != nil || got != want {
+			t.Fatalf("exception %#x: %s, %v", code, got, err)
+		}
+	}
+	for _, code := range []uint32{0, 1, 80, 82, 83, 84, 85, 86, 87, 88, 120, 125, 132, 135, 137, 139, 259, 0xc00000fd, 0xffffffff} {
+		if _, err := x86CMPXCHGWindowsFault(code); err == nil {
+			t.Fatalf("ordinary/setup/stack-overflow exit %#x became native opcode evidence", code)
+		}
+	}
+}
+
+func TestX86CMPXCHGFaultObserverRejectsFalseEvidence(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const driver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/resource.h>
+#endif
+int main(int argc, char **argv) {
+#ifdef _WIN32
+ SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+#else
+ struct rlimit no_core = {0, 0};
+ if (setrlimit(RLIMIT_CORE, &no_core)) return 120;
+#endif
+ if (argc != 4) return 80;
+ int mode = atoi(argv[1]);
+ if (mode == 2) return 82;
+ printf("CMPXCHG enter %d 0 0\n", mode == 7 ? 99 : mode);
+ if (fflush(stdout)) return 87;
+ if (mode == 1 || mode == 7) __asm__ volatile("movl $0,(%0)" :: "r"((uintptr_t)0) : "memory");
+ if (mode == 3) return 139;
+ if (mode == 4) return 0;
+ if (mode == 5) __asm__ volatile("ud2");
+ if (mode == 6) return 85;
+ if (mode == 8) for (;;) __asm__ volatile("" ::: "memory");
+ puts("CMPXCHG complete");
+ return 0;
+}
+`
+	executable := execution.compileLLVM(t, "fault-controls", "", driver, "-O0")
+	for _, test := range []struct {
+		mode int
+		want string
+	}{{0, "return"}, {1, "segv"}, {2, ""}, {3, ""}, {4, ""}, {5, "ill"}, {6, ""}, {7, ""}} {
+		t.Run(strconv.Itoa(test.mode), func(t *testing.T) {
+			got, err := x86CMPXCHGObserveFault(t, execution, executable, test.mode, 0, 0)
+			if got != test.want || (err == nil) != (test.want != "") {
+				t.Fatalf("got %s, %v; want %s", got, err, test.want)
+			}
+		})
+	}
+	t.Run("cancellation", func(t *testing.T) {
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+		if _, err := x86CMPXCHGObserveFaultContext(ctx, execution, executable, 8, 0, 0); !errors.Is(err, context.DeadlineExceeded) {
+			t.Fatalf("cancellation became a native opcode outcome: %v", err)
+		}
+	})
+	t.Run("joined-cleanup", func(t *testing.T) {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		args := execution.command(executable, "5", "0", "0")
+		stdout, _, err := runtimeOracleMachineOutput(ctx, exec.CommandContext(ctx, args[0], args[1:]...))
+		const witness = "CMPXCHG enter 5 0 0\n"
+		if got, cause := x86CMPXCHGFaultResult(runtime.GOOS, string(stdout), witness, err); cause != nil || got != "ill" {
+			t.Fatal("missing actual illegal-instruction control", got, cause)
+		}
+		if _, cause := x86CMPXCHGFaultResult(runtime.GOOS, string(stdout), witness, errors.Join(err, fmt.Errorf("owned cleanup failure"))); cause == nil {
+			t.Fatal("cleanup error was erased by the native exception")
+		}
+	})
+}
diff --git a/amd64_cmpxchg_fault_portability_test.go b/amd64_cmpxchg_fault_portability_test.go
new file mode 100644
index 000000000..fc8d729b9
--- /dev/null
+++ b/amd64_cmpxchg_fault_portability_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86CMPXCHGFaultWindowsHeaderBoundary(t *testing.T) {
+	x86FaultWindowsHeaderBoundary(t, x86CMPXCHGFaultReference,
+		[]string{"VirtualAlloc", "VirtualProtect", "VirtualFree", "kernel.original(p)", "kernel.translated(p)"})
+}
+
+func TestX86MemoryFaultWindowsHeaderBoundary(t *testing.T) {
+	driver := x86MemoryFaultDriver("static int sample(const uint8_t *p) { return *p; }\n", "{sample, 4, 3},")
+	x86FaultWindowsHeaderBoundary(t, driver,
+		[]string{"VirtualAlloc", "VirtualProtect", "VirtualFree", "kernel.run(input)", "source[i]"})
+}
+
+func TestX86SignedConversionFaultWindowsHeaderBoundary(t *testing.T) {
+	driver := x86MemoryFaultSupportC + `
+static void sample(const void *p) { (void)p; }
+static const struct { void (*run)(const void *); unsigned width, bits; }
+    cases[] = {{sample, 4, 32}};
+` + x86SignedIntegerFloatFaultMainC
+	x86FaultWindowsHeaderBoundary(t, driver,
+		[]string{"VirtualAlloc", "VirtualProtect", "VirtualFree", "cases[row].run(input)", "cvtsi2ssl", "cvtsi2sdq"})
+}
+
+func x86FaultWindowsHeaderBoundary(t *testing.T, driver string, required []string) {
+	t.Helper()
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	directory := t.TempDir()
+	if err := os.Mkdir(filepath.Join(directory, "sys"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	// This observes actual preprocessing of the complete driver, not a
+	// Windows SDK, object, link or runtime claim. Missing POSIX dependencies
+	// are poisoned so the host cannot accidentally supply them.
+	for _, name := range []string{"stdint.h", "stdio.h", "string.h", "stdlib.h", "signal.h", "windows.h"} {
+		if err := os.WriteFile(filepath.Join(directory, name), nil, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, name := range []string{"unistd.h", "sys/mman.h", "sys/resource.h", "sys/wait.h"} {
+		if err := os.WriteFile(filepath.Join(directory, filepath.FromSlash(name)), []byte("#error unexpected_POSIX_fault_dependency\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	input := filepath.Join(directory, "fault.c")
+	if err := os.WriteFile(input, []byte(driver), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, clang, "-target", "x86_64-w64-windows-gnu", "-nostdinc",
+		"-I", directory, "-E", "-P", input)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("Windows fault driver still consumes POSIX headers: %v\n%s", err, output)
+	}
+	for _, operation := range required {
+		if !strings.Contains(string(output), operation) {
+			t.Fatal("Windows fault driver lost its real guard or operation", operation)
+		}
+	}
+}
diff --git a/amd64_cmpxchg_fault_runtime_test.go b/amd64_cmpxchg_fault_runtime_test.go
new file mode 100644
index 000000000..b69af4f86
--- /dev/null
+++ b/amd64_cmpxchg_fault_runtime_test.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Native opcode outcomes, not CPUID advertisements, establish availability and
+// fault behavior. This is an instruction-level C observer tied to original Go
+// opcode bytes, not execution of the stock Go ABI0 caller or a native CI claim.
+func TestX86CMPXCHGOriginalOpcodeOutcomeEquivalence(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	x86CMPXCHGRunFaultCollector(t, execution, false)
+}
+
+func x86CMPXCHGRunFaultCollector(t *testing.T, execution x86FloatCompareExecution, native bool) {
+	t.Helper()
+	var assembly, declarations, prototypes, originals, cases strings.Builder
+	declarations.WriteString("package ordering\n")
+	for index, row := range x86CMPXCHGOriginalRows {
+		for _, locked := range []bool{false, true} {
+			name := fmt.Sprintf("cas%d_%t", index, locked)
+			body := x86CMPXCHGOriginalBody(index, "(SI)")
+			if locked {
+				body = "LOCK\n\t" + body
+			}
+			// Use the source register initialized by the reference: desired low
+			// is in CX for scalar forms, and BX/CX for pair forms.
+			source := strings.Replace(x86NamedLockOracleSource("amd64", body), "·locked", "·"+name, 1)
+			actual := x86OrderingHintGoBytes(t, "amd64", source)
+			opcode := []byte{0x0f, 0xb1, 0x0e}
+			switch row.bits {
+			case 8:
+				if !row.pair {
+					opcode = []byte{0x0f, 0xb0, 0x0e}
+				}
+			case 16:
+				opcode = append([]byte{0x66}, opcode...)
+			case 64:
+				if row.pair {
+					opcode = []byte{0x0f, 0xc7, 0x0e}
+				} else {
+					opcode = append([]byte{0x48}, opcode...)
+				}
+			case 128:
+				opcode = []byte{0x48, 0x0f, 0xc7, 0x0e}
+			}
+			if locked {
+				opcode = append([]byte{0xf0}, opcode...)
+			}
+			if !bytes.HasSuffix(actual, append(append([]byte(nil), opcode...), 0xc3)) {
+				t.Fatalf("complete original opcode/prefix binding changed: %s %x", name, actual)
+			}
+			t.Logf("actual Go %s terminal machine bytes=%x; object identity only", name, opcode)
+			assembly.WriteString(source)
+			fmt.Fprintf(&declarations, "func %s(p *[32]byte)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(unsigned char *);\n", name)
+			fmt.Fprintf(&cases, "    {%s, original_%s, %d, %d},\n", name, name, row.bits/8, index)
+			prefix := ""
+			if locked {
+				prefix = "lock; "
+			}
+			if row.pair {
+				part, mnemonic := "uint32_t", "cmpxchg8b"
+				if row.bits == 128 {
+					part, mnemonic = "uint64_t", "cmpxchg16b"
+				}
+				fmt.Fprintf(&originals, `static void original_%s(unsigned char *p) {
+    %s low = 2, high = 5;
+    __asm__ volatile("%s%s (%%4)"
+        : "+a"(low), "+d"(high)
+        : "b"((%s)3), "c"((%s)4), "r"(p)
+        : "cc", "memory");
+}
+`, name, part, prefix, mnemonic, part, part)
+			} else {
+				typ := fmt.Sprintf("uint%d_t", row.bits)
+				width := map[int]string{8: "b", 16: "w", 32: "l", 64: "q"}[row.bits]
+				fmt.Fprintf(&originals, `static void original_%s(unsigned char *p) {
+    %s accumulator = 2;
+    __asm__ volatile("%scmpxchg%s %%1, (%%2)"
+        : "+a"(accumulator)
+        : "c"((%s)4), "r"(p)
+        : "cc", "memory");
+}
+`, name, typ, prefix, width, typ)
+			}
+		}
+	}
+	ir, err := x86OrderingHintTranslateAPI(t, "text", assembly.String(), declarations.String(), "amd64", execution.triple)
+	if err != nil {
+		t.Fatal(err)
+	}
+	reference := fmt.Sprintf(x86CMPXCHGFaultReference, prototypes.String(), originals.String(), cases.String())
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "cmpxchg-fault", ir, reference, level)
+			observations, deviations := 0, 0
+			for index := 0; index < len(x86CMPXCHGOriginalRows)*2; index++ {
+				for address := 0; address < 4; address++ {
+					original, err := x86CMPXCHGObserveFault(t, execution, executable, index, address, 1)
+					if err != nil {
+						t.Fatal(err)
+					}
+					translated, err := x86CMPXCHGObserveFault(t, execution, executable, index, address, 0)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if original != translated {
+						t.Fatalf("kernel %d address %d: original %s, translated %s", index, address, original, translated)
+					}
+					misalignedPair := x86CMPXCHGOriginalRows[index/2].bits == 128 && address == 1
+					fault := address >= 2 || misalignedPair
+					if fault && original != "segv" && original != "bus" || !fault && original != "return" {
+						deviations++
+					}
+					if native && misalignedPair && original != "segv" {
+						t.Fatal("native Linux misaligned CMPXCHG16B did not report #GP as SIGSEGV")
+					}
+					observations += 2
+				}
+			}
+			if observations != 96 || native && deviations != 0 {
+				t.Fatalf("CMPXCHG opcode outcomes %d, ISA deviations %d", observations, deviations)
+			}
+			t.Logf("CMPXCHG opcode outcomes %d; ISA deviations %d; outcome failures 0", observations, deviations)
+		})
+	}
+}
+
+const x86CMPXCHGFaultReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#ifndef _WIN32
+#include <sys/resource.h>
+#endif
+` + x86TestGuardPagesC + `
+
+%s
+%s
+typedef struct {
+    void (*translated)(unsigned char *);
+    void (*original)(unsigned char *);
+    unsigned width, family;
+} Kernel;
+
+static int exercise(Kernel kernel, unsigned index, unsigned address, unsigned original) {
+    _Alignas(16) unsigned char raw[64];
+    memset(raw, 0xa7, sizeof(raw));
+    unsigned char *p = raw + 16;
+    if (address == 1) p++;
+    if (address == 2) p = NULL;
+    if (address == 3) {
+        if (setup_guard()) return 82;
+        memset(guard, 0xa7, page);
+        p = guard + page - (kernel.width - 1);
+    }
+    unsigned char expected[16] = {0};
+    uint64_t low = 2, high = 5, desired_low = 3, desired_high = 4;
+    if (kernel.family == 4) {
+        uint32_t pair[2] = {2, 5}, desired[2] = {3, 4};
+        memcpy(expected, desired, 8);
+        if (address < 2) memcpy(p, pair, 8);
+    } else if (kernel.family == 5) {
+        memcpy(expected, &desired_low, 8);
+        memcpy(expected + 8, &desired_high, 8);
+        if (address < 2) {
+            memcpy(p, &low, 8);
+            memcpy(p + 8, &high, 8);
+        }
+    } else {
+        memcpy(expected, &desired_high, kernel.width);
+        if (address < 2) memcpy(p, &low, kernel.width);
+    }
+    if (printf("CMPXCHG enter %%u %%u %%u\n", index, address, original) < 0 || fflush(stdout)) return 87;
+    if (original) kernel.original(p);
+    else kernel.translated(p);
+    if (address == 3 && free_guard()) return 83;
+    if (address >= 2) return 84;
+    if (memcmp(p, expected, kernel.width)) return 85;
+    size_t begin = (size_t)(p - raw);
+    for (size_t i = 0; i < sizeof(raw); i++) {
+        if ((i < begin || i >= begin + kernel.width) && raw[i] != 0xa7) return 86;
+    }
+    if (puts("CMPXCHG complete") < 0 || fflush(stdout)) return 88;
+    return 0;
+}
+
+int main(int argc, char **argv) {
+#ifdef _WIN32
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+#else
+    struct rlimit no_core = {0, 0};
+    if (setrlimit(RLIMIT_CORE, &no_core)) return 120;
+#endif
+    Kernel kernels[] = {
+%s
+    };
+    if (argc != 4 || strlen(argv[1]) > 2 || strlen(argv[2]) != 1 || strlen(argv[3]) != 1) return 80;
+    unsigned long values[3];
+    for (unsigned i = 0; i < 3; i++) {
+        char *end;
+        if (argv[i+1][0] < '0' || argv[i+1][0] > '9') return 80;
+        values[i] = strtoul(argv[i+1], &end, 10);
+        if (*end) return 80;
+    }
+    if (values[0] >= sizeof(kernels)/sizeof(kernels[0]) || values[1] >= 4 || values[2] >= 2) return 80;
+    return exercise(kernels[values[0]], (unsigned)values[0], (unsigned)values[1], (unsigned)values[2]);
+}
+`
diff --git a/amd64_cmpxchg_forms.go b/amd64_cmpxchg_forms.go
new file mode 100644
index 000000000..eb1469135
--- /dev/null
+++ b/amd64_cmpxchg_forms.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86CompareExchangeSpec struct {
+	bits int
+	pair bool
+}
+
+// Complete original yrb_mb, yrl_ml and yscond rows. Syntax acceptance is
+// distinct from a physical encoder-view or native-memory permission.
+var x86CompareExchangeSpecs = map[Op]x86CompareExchangeSpec{
+	"CMPXCHGB":   {bits: 8},
+	"CMPXCHGW":   {bits: 16},
+	"CMPXCHGL":   {bits: 32},
+	"CMPXCHGQ":   {bits: 64},
+	"CMPXCHG8B":  {bits: 64, pair: true},
+	"CMPXCHG16B": {bits: 128, pair: true},
+}
+
+type x86CompareExchangeForm struct {
+	spec        x86CompareExchangeSpec
+	source      Operand
+	destination Operand
+}
+
+func x86CompareExchangeProperties(op Op, ins Instr, arch string) (x86CompareExchangeForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base := strings.SplitN(name, ".", 2)[0]
+	spec, recognized := x86CompareExchangeSpecs[Op(base)]
+	if !recognized {
+		return x86CompareExchangeForm{}, false, nil
+	}
+	invalid := func(reason string) (x86CompareExchangeForm, bool, error) {
+		return x86CompareExchangeForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	context := func(reason string) (x86CompareExchangeForm, bool, error) {
+		return x86CompareExchangeForm{}, true, fmt.Errorf("%w: %s %s %s: %q", ErrProbeNeedsContext, arch, op, reason, ins.Raw)
+	}
+	if name != base || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return invalid("does not accept suffixes or a contradictory source identity")
+	}
+	if arch != "amd64" && arch != "386" {
+		return invalid("requires a registered x86 mode")
+	}
+	if arch == "386" && (spec.bits == 128 || spec.bits == 64 && !spec.pair) {
+		return invalid("is illegal in 32-bit mode")
+	}
+	count := 2
+	if spec.pair {
+		count = 1
+	}
+	if len(ins.Args) != count {
+		return invalid("does not have its complete ordered operand count")
+	}
+	form := x86CompareExchangeForm{spec: spec, destination: ins.Args[count-1]}
+	if !spec.pair {
+		if projected, segment, err := x86NamedSegmentMemorySource(ins, form.destination, arch); segment {
+			if err != nil {
+				return form, true, err
+			}
+			form.destination = projected
+		}
+	}
+	registerAllowed := func(reg Reg) bool {
+		if spec.pair || spec.bits == 8 {
+			return isGoYmbRegisterForArch(reg, arch)
+		}
+		return isX86YrlRegisterForArch(reg, arch)
+	}
+	if !spec.pair {
+		form.source = ins.Args[0]
+		if form.source.Kind != OpReg || !registerAllowed(form.source.Reg) {
+			return invalid("source is outside its original Yrb/Yrl class")
+		}
+	}
+	destination := form.destination
+	if destination.Kind == OpReg {
+		if !registerAllowed(destination.Reg) {
+			return invalid("destination is outside its original Ymb/Yml class")
+		}
+	} else if !isAMD64MemoryOperand(destination) ||
+		destination.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(destination.Sym), "$") {
+		return invalid("destination is not its original register/memory operand")
+	} else if destination.Kind == OpMem && !x86MemoryRegistersValidForArch(destination.Mem, arch) {
+		return invalid("memory uses an out-of-range address register")
+	}
+	if spec.pair && destination.Kind == OpReg {
+		return context("Go emits a non-memory pair operand with native #UD, not a numerical CAS")
+	}
+	if spec.bits == 8 {
+		if arch == "386" {
+			for _, operand := range []Operand{form.source, destination} {
+				if operand.Kind == OpReg && (operand.Reg == BP || operand.Reg == SI || operand.Reg == DI) {
+					return context("Go's byte-register expansion changes the implicit accumulator before CMPXCHG")
+				}
+			}
+		} else if x86CompareExchangeHasREXByteView(form) {
+			for _, operand := range []Operand{form.source, destination} {
+				if operand.Kind == OpReg && (operand.Reg == AH || operand.Reg == BH || operand.Reg == CH || operand.Reg == DH) {
+					return context("Go's REX encoding changes a high-byte spelling to an unbound low-byte physical view")
+				}
+			}
+		}
+	}
+	return form, true, nil
+}
+
+func x86CompareExchangeHasREXByteView(form x86CompareExchangeForm) bool {
+	requiresREX := func(reg Reg) bool {
+		switch reg {
+		case SP, BP, SI, DI, BPB, SIB, DIB:
+			return true
+		}
+		base, _, alias := amd64ByteAlias(reg)
+		if alias {
+			reg = base
+		}
+		return strings.HasPrefix(string(reg), "R")
+	}
+	for _, operand := range []Operand{form.source, form.destination} {
+		if operand.Kind == OpReg && requiresREX(operand.Reg) {
+			return true
+		}
+		if operand.Kind == OpMem {
+			for _, reg := range []Reg{operand.Mem.Base, operand.Mem.Index} {
+				if strings.HasPrefix(string(reg), "R") {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
diff --git a/amd64_cmpxchg_linux_amd64_test.go b/amd64_cmpxchg_linux_amd64_test.go
new file mode 100644
index 000000000..373ce1e75
--- /dev/null
+++ b/amd64_cmpxchg_linux_amd64_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "testing"
+
+// These strict mathematical oracles require real Linux/AMD64 execution.
+// The unchanged shared fixtures preserve all six flags, complete aliases,
+// MXCSR and canaries. Local Go/C equivalence never satisfies this ISA axis.
+func TestCrossLinuxRuntimeMatrixX86CMPXCHGOriginalGoCompleteNumerical(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86CMPXCHGOriginalNumerical(t, x86FloatCompareExecutionTools(t))
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMPXCHGIndependentCOriginalOpcodeNumerical(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86CMPXCHGOriginalCNumerical(t, x86FloatCompareExecutionTools(t))
+	x87IA32RequireNativeHost(t)
+}
+
+// This required native axis is selected by the existing CrossLinuxRuntimeMatrix
+// CI prefix. Rosetta/QEMU equivalence does not satisfy its actual #GP assertion.
+func TestCrossLinuxRuntimeMatrixX86CMPXCHGNativeFaultAndAccessWidth(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86CMPXCHGRunFaultCollector(t, x86FloatCompareExecutionTools(t), true)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86CMPXCHGNativeNumerical(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	t.Run("original-Go", func(t *testing.T) {
+		x86CMPXCHGOriginalNumerical(t, execution)
+	})
+	t.Run("original-C-opcode", func(t *testing.T) {
+		x86CMPXCHGOriginalCNumerical(t, execution)
+	})
+	t.Run("LLVM", func(t *testing.T) {
+		x86CMPXCHGLLVMNumerical(t, execution)
+	})
+	t.Run("Go-C-actual-equivalence", func(t *testing.T) {
+		x86CMPXCHGActualEquivalence(t, execution)
+	})
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_cmpxchg_native.go b/amd64_cmpxchg_native.go
new file mode 100644
index 000000000..0e3fd88ff
--- /dev/null
+++ b/amd64_cmpxchg_native.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) compareExchangeNativePrefix(memory Operand) (lock, segment string) {
+	if c.namedAtomicLock {
+		lock = "lock; "
+	}
+	if memory.Kind == OpMem && memory.Mem.Segment != "" {
+		segment = "%" + strings.ToLower(string(memory.Mem.Segment)) + ":"
+	}
+	return lock, segment
+}
+
+func (c *amd64Ctx) emitScalarCompareExchangeNative(bits int, memory Operand, pointer, pointerType, expected, desired string) (old, success string) {
+	lock, segment := c.compareExchangeNativePrefix(memory)
+	typ := amd64IntegerTypeForBits(bits)
+	width := map[int]string{8: "b", 16: "w", 32: "l", 64: "q"}[bits]
+	register := "r"
+	if bits == 8 {
+		register = "q"
+	}
+	result, oldName, successByte, successName := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	// The complete native opcode supplies the read/write cycle on both paths,
+	// including failure. A plain original opcode does not acquire LOCK. No LLVM
+	// alignment precondition is asserted, and explicit FS/GS remains attached.
+	fmt.Fprintf(c.b, "  %%%s = call { %s, i8 } asm sideeffect \"%scmpxchg%s $3, %s$2; sete $1\", \"={ax},=q,=*m,%s,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s elementtype(%s) %s, %s %s, %s %s, %s elementtype(%s) %s)\n",
+		result, typ, lock, width, segment, register, pointerType, typ, pointer, typ, desired, typ, expected, pointerType, typ, pointer)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i8 } %%%s, 0\n", oldName, typ, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i8 } %%%s, 1\n", successByte, typ, result)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %%%s, 0\n", successName, successByte)
+	return "%" + oldName, "%" + successName
+}
+
+func (c *amd64Ctx) emitPairCompareExchangeNative(bits int, memory Operand, pointer, pointerType, ax, dx, bx, cx string) (old, success string) {
+	lock, segment := c.compareExchangeNativePrefix(memory)
+	part, pair, mnemonic := I32, LLVMType("i64"), "cmpxchg8b"
+	if bits == 128 {
+		part, pair, mnemonic = I64, LLVMType("i128"), "cmpxchg16b"
+	} else {
+		ax, dx = c.truncI64(ax, I32), c.truncI64(dx, I32)
+		bx, cx = c.truncI64(bx, I32), c.truncI64(cx, I32)
+	}
+	result := c.newTmp()
+	// 8B supports unaligned memory without an invented natural alignment.
+	// 16B retains the actual opcode's native #GP when its address is unaligned;
+	// LLVM align=16 would instead give undefined behavior, not that exception.
+	fmt.Fprintf(c.b, "  %%%s = call { %s, %s, i8 } asm sideeffect \"%s%s %s$3; sete $2\", \"={ax},={dx},=q,=*m,{bx},{cx},0,1,*m,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s elementtype(%s) %s, %s %s, %s %s, %s %s, %s %s, %s elementtype(%s) %s)\n",
+		result, part, part, lock, mnemonic, segment, pointerType, pair, pointer, part, bx, part, cx, part, ax, part, dx, pointerType, pair, pointer)
+	low, high, byteName, successName := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, %s, i8 } %%%s, 0\n", low, part, part, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, %s, i8 } %%%s, 1\n", high, part, part, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, %s, i8 } %%%s, 2\n", byteName, part, part, result)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %%%s, 0\n", successName, byteName)
+	low64, high64 := "%"+low, "%"+high
+	if part == I32 {
+		lowWide, highWide := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", lowWide, low64)
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", highWide, high64)
+		low64, high64 = "%"+lowWide, "%"+highWide
+	}
+	return c.compareExchangeJoinPair(low64, high64, bits), "%" + successName
+}
diff --git a/amd64_cmpxchg_native_family_test.go b/amd64_cmpxchg_native_family_test.go
new file mode 100644
index 000000000..f93002c89
--- /dev/null
+++ b/amd64_cmpxchg_native_family_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Independent complete original Go registrations, including ordered encoder
+// class, prefix and bytes. Go's yscond admits a register spelling even though
+// Intel's pair instructions require memory and raise #UD for ModRM.mod=3.
+var x86CMPXCHGOriginalRows = []struct {
+	op, registration string
+	bits             int
+	pair             bool
+}{
+	{"CMPXCHGB", "{ACMPXCHGB, yrb_mb, Pb, opBytes{0x0f, 0xb0}}", 8, false},
+	{"CMPXCHGW", "{ACMPXCHGW, yrl_ml, Pe, opBytes{0x0f, 0xb1}}", 16, false},
+	{"CMPXCHGL", "{ACMPXCHGL, yrl_ml, Px, opBytes{0x0f, 0xb1}}", 32, false},
+	{"CMPXCHGQ", "{ACMPXCHGQ, yrl_ml, Pw, opBytes{0x0f, 0xb1}}", 64, false},
+	{"CMPXCHG8B", "{ACMPXCHG8B, yscond, Pm, opBytes{0xc7, 01}}", 64, true},
+	{"CMPXCHG16B", "{ACMPXCHG16B, yscond, Pw, opBytes{0x0f, 0xc7, 01}}", 128, true},
+}
+
+func TestX86CMPXCHGByteEncoderViewsCannotInventSourceAliases(t *testing.T) {
+	for _, row := range []struct {
+		arch, body string
+		encoded    []byte
+	}{
+		{"amd64", "CMPXCHGB AH,R11", []byte{0x41, 0x0f, 0xb0, 0xe3}},
+		{"amd64", "CMPXCHGB AH,(R12)", []byte{0x41, 0x0f, 0xb0, 0x24, 0x24}},
+		{"amd64", "CMPXCHGB R11,AH", []byte{0x44, 0x0f, 0xb0, 0xdc}},
+		{"386", "CMPXCHGB BP,(BX)", []byte{0x95, 0x0f, 0xb0, 0x03, 0x95}},
+		{"386", "CMPXCHGB SI,DI", []byte{0x96, 0x87, 0xdf, 0x0f, 0xb0, 0xc3, 0x87, 0xdf, 0x96}},
+	} {
+		t.Run(row.arch+"/"+row.body, func(t *testing.T) {
+			source := x86NamedLockOracleSource(row.arch, row.body)
+			if row.arch == "amd64" {
+				source = strings.Replace(source, "\t"+row.body, "\tMOVQ $9,R11\n\tMOVQ p+0(FP),R12\n\t"+row.body, 1)
+			}
+			actual := x86OrderingHintGoBytes(t, row.arch, source)
+			if !bytes.HasSuffix(actual, append(append([]byte(nil), row.encoded...), 0xc3)) {
+				t.Fatalf("original whole encoder effect changed: %x", actual)
+			}
+			mode := 64
+			if row.arch == "386" {
+				mode = 32
+			}
+			physical, err := x86asm.Decode(row.encoded, mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("original first physical opcode=%s; full sequence=%x", x86asm.GoSyntax(physical, 0, nil), row.encoded)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source,
+					"package ordering\nfunc locked(p *[32]byte)\n", row.arch, testTargetTriple("linux", row.arch))
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("Go encoder view/implicit accumulator rewrite acquired a false source effect: %s/%v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86CMPXCHGCompleteOriginalOrderedRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	for _, row := range x86CMPXCHGOriginalRows {
+		if !strings.Contains(table, row.registration) {
+			t.Fatal("original opcode-specific encoding changed", row.registration)
+		}
+	}
+	for _, grammar := range []string{
+		"var yrb_mb = []ytab{\n\t{Zr_m, 1, argList{Yrb, Ymb}},\n}",
+		"var yrl_ml = []ytab{\n\t{Zr_m, 1, argList{Yrl, Yml}},\n}",
+		"var yscond = []ytab{\n\t{Zo_m, 2, argList{Ymb}},\n}",
+	} {
+		if !strings.Contains(table, grammar) {
+			t.Fatal("complete ordered operand class changed", grammar)
+		}
+	}
+}
+
+func x86CMPXCHGOriginalBody(row int, destination string) string {
+	op := x86CMPXCHGOriginalRows[row]
+	if op.pair {
+		return op.op + " " + destination
+	}
+	source := "CX"
+	if op.bits == 8 {
+		source = "CL"
+	}
+	return op.op + " " + source + "," + destination
+}
+
+func TestX86CMPXCHGNativeMemoryHasNoInventedLLVMAlignment(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for index, row := range x86CMPXCHGOriginalRows {
+			if target.arch == "386" && (row.op == "CMPXCHGQ" || row.bits == 128) {
+				continue
+			}
+			for _, destination := range []string{"1(SI)", "0(FS)", "0(GS)"} {
+				for _, locked := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/locked=%t", target.triple, row.op, destination, locked), func(t *testing.T) {
+						body := x86CMPXCHGOriginalBody(index, destination)
+						if locked {
+							body = "LOCK\n\t" + body
+						}
+						source := x86NamedLockOracleSource(target.arch, body)
+						actual := x86OrderingHintGoBytes(t, target.arch, source)
+						t.Logf("actual original %s bytes=%x (object only, no unsafe execution)", row.op, actual)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86OrderingHintTranslateAPI(t, api, source,
+									"package ordering\nfunc locked(p *[32]byte)\n", target.arch, target.triple)
+								if err != nil {
+									t.Fatal("Go-accepted complete native memory operation", err)
+								}
+								if regexp.MustCompile(`(?m)^\s*%[^\n]+ = cmpxchg `).MatchString(ir) {
+									t.Fatal("native memory operand acquired an unproved LLVM atomic alignment")
+								}
+								want := strings.ToLower(row.op)
+								if locked {
+									want = "lock; " + want
+								} else if strings.Contains(ir, "lock; cmpxchg") {
+									t.Fatal("unprefixed original instruction acquired a LOCK effect")
+								}
+								if !strings.Contains(ir, "asm sideeffect \""+want) || !strings.Contains(ir, "=*m") || !strings.Contains(ir, "*m") {
+									t.Fatal("full native read/write opcode was not retained", want)
+								}
+								if destination == "0(FS)" && !strings.Contains(ir, "%fs:") || destination == "0(GS)" && !strings.Contains(ir, "%gs:") {
+									t.Fatal("actual original segment override disappeared")
+								}
+								compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "cmpxchg-native.ll", "cmpxchg-native.o", ir)
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CMPXCHGPairRegisterDoesNotInventSoftwareCAS(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86CMPXCHGOriginalRows[4:] {
+			if arch == "386" && row.bits == 128 {
+				continue
+			}
+			for _, register := range []string{"AX", "BX", "SI"} {
+				t.Run(arch+"/"+row.op+"/"+register, func(t *testing.T) {
+					source := x86NamedLockOracleSource(arch, row.op+" "+register)
+					actual := x86OrderingHintGoBytes(t, arch, source)
+					t.Logf("Go-accepted pair-register #UD object bytes=%x; not a numerical oracle", actual)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source,
+							"package ordering\nfunc locked(p *[32]byte)\n", arch, testTargetTriple("linux", arch))
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("pair-register #UD became a normal software CAS in %s: %v", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CMPXCHGDispatchIdentityFailsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := Parse(ArchAMD64, "TEXT locked(SB),4,$0-0\nCMPXCHGL CX,BX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, identity := range []Op{"CMPXCHGQ", "MOVL", "CMPXCHGL.BAD"} {
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ctx.goarch = arch
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = identity
+			before, temporary := out.String(), ctx.tmp
+			known, terminated, err := ctx.lowerCompareExchange("CMPXCHGL", ins)
+			if !known || terminated || err == nil || before != out.String() || temporary != ctx.tmp {
+				t.Fatalf("contradictory dispatched/source opcode changed IR: %s %v", identity, err)
+			}
+		}
+	}
+}
diff --git a/amd64_cmpxchg_numerical_runtime_test.go b/amd64_cmpxchg_numerical_runtime_test.go
new file mode 100644
index 000000000..c3d718cde
--- /dev/null
+++ b/amd64_cmpxchg_numerical_runtime_test.go
@@ -0,0 +1,347 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86CMPXCHGOriginalNumerical(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	declarations, source, names := x86CMPXCHGNumericalFixture()
+	driver := strings.Replace(x86CMPXCHGGoNumerical, "KERNEL_NAMES", names, 1)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), runtime.GOOS, "amd64", declarations, source, driver)
+	output := execution.run(t, original)
+	if string(output) != "original CMPXCHG numerical observations 576 failures 0\n" {
+		t.Fatalf("actual unchanged Go ABI0 numerical/status/canary oracle: %s", output)
+	}
+	t.Log(string(output))
+}
+
+func TestX86CMPXCHGLLVMCompleteNumerical(t *testing.T) {
+	x86CMPXCHGLLVMNumerical(t, x86FloatCompareExecutionTools(t))
+}
+
+func x86CMPXCHGLLVMNumerical(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	declarations, source, names := x86CMPXCHGNumericalFixture()
+	ir, err := x86OrderingHintTranslateAPI(t, "Go", source, declarations, "amd64", execution.triple)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var prototypes strings.Builder
+	for _, name := range strings.Split(strings.TrimSpace(names), ",") {
+		name = strings.TrimSpace(name)
+		if name != "" {
+			fmt.Fprintf(&prototypes, "extern void %s(uint64_t *, unsigned char *, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);\n", name)
+		}
+	}
+	reference := strings.Replace(x86CMPXCHGCNumerical, "KERNEL_PROTOTYPES", prototypes.String(), 1)
+	reference = strings.Replace(reference, "KERNEL_NAMES", names, 1)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "cmpxchg-numerical", ir, reference, level)
+			if string(output) != "LLVM CMPXCHG numerical observations 576 failures 0\n" {
+				t.Fatalf("independent full byte/status/canary oracle: %s", output)
+			}
+			t.Log(string(output))
+		})
+	}
+}
+
+func x86CMPXCHGNumericalFixture() (declarations, source, names string) {
+	var decl, assembly, functions strings.Builder
+	decl.WriteString("package main\n")
+	// The independent family order binds the oracle's widths and pair policy.
+	for index, op := range []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHGQ", "CMPXCHG8B", "CMPXCHG16B"} {
+		for _, locked := range []bool{false, true} {
+			name := fmt.Sprintf("numeric_%d_%t", index, locked)
+			fmt.Fprintf(&decl, "func %s(out *[16]uint64, p *[32]byte, expectedLo, expectedHi, desiredLo, desiredHi, seed uint64)\n", name)
+			fmt.Fprintf(&functions, "%s,\n", name)
+			fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-56
+MOVQ out+0(FP),R10
+MOVQ p+8(FP),SI
+MOVQ expectedLo+16(FP),AX
+MOVQ expectedHi+24(FP),DX
+MOVQ desiredLo+32(FP),BX
+MOVQ desiredHi+40(FP),CX
+MOVQ seed+48(FP),R8
+PUSHQ R8
+POPFQ
+`, name)
+			if locked {
+				assembly.WriteString("LOCK\n")
+			}
+			switch index {
+			case 0:
+				assembly.WriteString(op + " BL,(SI)\n")
+			case 4, 5:
+				assembly.WriteString(op + " (SI)\n")
+			default:
+				assembly.WriteString(op + " BX,(SI)\n")
+			}
+			assembly.WriteString(`MOVQ AX,0(R10)
+MOVQ DX,8(R10)
+MOVQ BX,16(R10)
+MOVQ CX,24(R10)
+PUSHFQ
+POPQ R9
+MOVQ R9,32(R10)
+LAHF
+MOVBLZX AH,BX
+MOVQ BX,40(R10)
+STMXCSR 48(R10)
+RET
+`)
+		}
+	}
+	decl.WriteString("func csr() uint32\n")
+	assembly.WriteString("TEXT ·csr(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\n")
+	return decl.String(), assembly.String(), functions.String()
+}
+
+const x86CMPXCHGGoNumerical = `package main
+
+import (
+    "encoding/binary"
+    "fmt"
+    "os"
+    "runtime"
+    "unsafe"
+)
+
+func widthMask(bits uint) uint64 {
+    if bits == 64 { return ^uint64(0) }
+    return uint64(1)<<bits - 1
+}
+
+func subtractFlags(a, b uint64, bits uint) uint64 {
+    mask := widthMask(bits)
+    a, b = a&mask, b&mask
+    result := (a-b)&mask
+    var flags uint64
+    if a < b { flags |= 1 }
+    parity := byte(result)
+    parity ^= parity>>4
+    parity ^= parity>>2
+    parity ^= parity>>1
+    if parity&1 == 0 { flags |= 4 }
+    if a&15 < b&15 { flags |= 16 }
+    if result == 0 { flags |= 64 }
+    if result>>(bits-1) != 0 { flags |= 128 }
+    if ((a^b)&(a^result))>>(bits-1) != 0 { flags |= 2048 }
+    return flags
+}
+
+func main() {
+    runtime.LockOSThread()
+    kernels := []func(*[16]uint64, *[32]byte, uint64, uint64, uint64, uint64, uint64){
+        KERNEL_NAMES
+    }
+    edges := []uint64{0, 1, 15, 16, 127, 128, 255, 256,
+        0x7fffffff, 0x80000000, 0x8000000000000000, ^uint64(0)}
+    widths := []uint{8, 16, 32, 64, 32, 64}
+    const canary uint64 = 0xa7a7a7a7a7a7a7a7
+    observations, failures := 0, 0
+    for index, kernel := range kernels {
+        kernelFailures, registerFailures, statusFailures := 0, 0, 0
+        family := index/2
+        bits := widths[family]
+        mask := widthMask(bits)
+        size := int(bits/8)
+        if family >= 4 { size *= 2 }
+        for _, edge := range edges {
+            for _, equal := range []bool{false, true} {
+                for _, seed := range []uint64{0x8c7, 0x12} {
+                    raw := [96]byte{}
+                    for i := range raw { raw[i] = 0xa7 }
+                    aligned := 16 + int((-uintptr(unsafe.Pointer(&raw[0])))&15)
+                    if family != 5 { aligned++ }
+                    p := (*[32]byte)(unsafe.Pointer(&raw[aligned]))
+                    low, high := edge&mask, (^edge)&mask
+                    for byteIndex := 0; byteIndex < size; byteIndex++ {
+                        value := low
+                        if byteIndex >= int(bits/8) { value = high }
+                        p[byteIndex] = byte(value >> (8*uint(byteIndex%int(bits/8))))
+                    }
+                    expectedLow, expectedHigh := low, high
+                    if !equal { expectedLow = (low+1)&mask }
+                    expectedLow |= 0x13579bdf2468ace0 & ^mask
+                    expectedHigh |= 0x2468ace013579bdf & ^mask
+                    desiredLow := edge ^ 0xd3c2b1a097867564
+                    desiredHigh := ^edge ^ 0x789abcdef0123456
+                    expectedRaw := raw
+                    if equal {
+                        for byteIndex := 0; byteIndex < size; byteIndex++ {
+                            value := desiredLow
+                            if byteIndex >= int(bits/8) { value = desiredHigh }
+                            expectedRaw[aligned+byteIndex] = byte(value >> (8*uint(byteIndex%int(bits/8))))
+                        }
+                    }
+                    out := [16]uint64{}
+                    for i := range out { out[i] = canary }
+                    before := csr()
+                    kernel(&out, p, expectedLow, expectedHigh, desiredLow, desiredHigh, seed)
+                    after := csr()
+                    wantLow, wantHigh := expectedLow, expectedHigh
+                    if !equal {
+                        if bits == 32 { wantLow = low } else { wantLow = expectedLow&^mask | low }
+                        if family >= 4 {
+                            if bits == 32 { wantHigh = high } else { wantHigh = high }
+                        }
+                    }
+                    flags := subtractFlags(expectedLow, low, bits)
+                    if family >= 4 {
+                        flags = seed & 0x8d5 &^ 64
+                        if equal { flags |= 64 }
+                    }
+                    csr := binary.LittleEndian.Uint32((*[4]byte)(unsafe.Pointer(&out[6]))[:])
+                    bad := out[0] != wantLow || out[1] != wantHigh ||
+                        out[2] != desiredLow || out[3] != desiredHigh ||
+                        out[4]&0x8d5 != flags || out[5] != (flags&0xd5 | 2) ||
+                        out[6]>>32 != canary>>32 || csr != before || after != before || raw != expectedRaw
+                    for i := 7; i < len(out); i++ { bad = bad || out[i] != canary }
+                    if bad {
+                        kernelFailures++
+                        if out[0] != wantLow || out[1] != wantHigh || out[2] != desiredLow || out[3] != desiredHigh {
+                            registerFailures++
+                        }
+                        if out[4]&0x8d5 != flags || out[5] != (flags&0xd5 | 2) {
+                            statusFailures++
+                        }
+                        if failures < 24 {
+                            fmt.Printf("original failure kernel=%d bits=%d edge=%x equal=%t seed=%x out=%x wantAX=%x wantDX=%x flags=%x\n",
+                                index, bits, edge, equal, seed, out, wantLow, wantHigh, flags)
+                        }
+                        failures++
+                    }
+                    observations++
+                }
+            }
+        }
+        if kernelFailures != 0 {
+            fmt.Printf("original kernel=%d observations=48 failures=%d register=%d status=%d\n",
+                index, kernelFailures, registerFailures, statusFailures)
+        }
+    }
+    fmt.Printf("original CMPXCHG numerical observations %d failures %d\n", observations, failures)
+    if failures != 0 { os.Exit(1) }
+}
+`
+
+const x86CMPXCHGCNumerical = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+KERNEL_PROTOTYPES
+typedef void (*Kernel)(uint64_t *, unsigned char *, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
+
+static uint64_t width_mask(unsigned bits) {
+    return bits == 64 ? UINT64_MAX : ((UINT64_C(1)<<bits)-1);
+}
+
+static uint64_t subtraction(uint64_t a, uint64_t b, unsigned bits) {
+    uint64_t mask = width_mask(bits);
+    a &= mask;
+    b &= mask;
+    uint64_t difference = (a-b)&mask;
+    uint64_t flags = a < b;
+    unsigned ones = 0;
+    for (unsigned bit = 0; bit < 8; bit++) ones += (difference>>bit)&1;
+    if (!(ones&1)) flags |= 4;
+    if ((a&15) < (b&15)) flags |= 16;
+    if (!difference) flags |= 64;
+    if (difference>>(bits-1)) flags |= 128;
+    if (((a^b)&(a^difference))>>(bits-1)) flags |= 2048;
+    return flags;
+}
+
+int main(void) {
+    Kernel kernels[] = { KERNEL_NAMES };
+    const uint64_t edges[] = {0, 1, 15, 16, 127, 128, 255, 256,
+        0x7fffffff, 0x80000000, UINT64_C(0x8000000000000000), UINT64_MAX};
+    const unsigned widths[] = {8, 16, 32, 64, 32, 64};
+    const uint64_t seeds[] = {0x8c7, 0x12};
+    const uint64_t canary = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    unsigned observations = 0, failures = 0;
+    for (unsigned index = 0; index < 12; index++) {
+        unsigned kernel_failures = 0, register_failures = 0, status_failures = 0;
+        unsigned family = index/2, bits = widths[family];
+        uint64_t mask = width_mask(bits);
+        unsigned size = bits/8 * (family >= 4 ? 2 : 1);
+        for (unsigned edge = 0; edge < 12; edge++) {
+            for (unsigned equal = 0; equal < 2; equal++) {
+                for (unsigned seed = 0; seed < 2; seed++) {
+                    _Alignas(16) unsigned char raw[96], expected[96];
+                    memset(raw, 0xa7, sizeof(raw));
+                    unsigned start = family == 5 ? 16 : 17;
+                    unsigned char *p = raw+start;
+                    uint64_t low = edges[edge]&mask, high = ~edges[edge]&mask;
+                    for (unsigned byte = 0; byte < size; byte++) {
+                        uint64_t value = byte >= bits/8 ? high : low;
+                        p[byte] = value>>(8*(byte%(bits/8)));
+                    }
+                    uint64_t expected_low = equal ? low : (low+1)&mask;
+                    expected_low |= UINT64_C(0x13579bdf2468ace0)&~mask;
+                    uint64_t expected_high = high | (UINT64_C(0x2468ace013579bdf)&~mask);
+                    uint64_t desired_low = edges[edge]^UINT64_C(0xd3c2b1a097867564);
+                    uint64_t desired_high = ~edges[edge]^UINT64_C(0x789abcdef0123456);
+                    memcpy(expected, raw, sizeof(raw));
+                    if (equal) {
+                        for (unsigned byte = 0; byte < size; byte++) {
+                            uint64_t value = byte >= bits/8 ? desired_high : desired_low;
+                            expected[start+byte] = value>>(8*(byte%(bits/8)));
+                        }
+                    }
+                    uint64_t out[16];
+                    for (unsigned i = 0; i < 16; i++) out[i] = canary;
+                    unsigned before, after;
+                    __asm__ volatile("stmxcsr %0" : "=m"(before));
+                    kernels[index](out, p, expected_low, expected_high, desired_low, desired_high, seeds[seed]);
+                    __asm__ volatile("stmxcsr %0" : "=m"(after));
+                    uint64_t want_low = expected_low, want_high = expected_high;
+                    if (!equal) {
+                        want_low = bits == 32 ? low : (expected_low&~mask)|low;
+                        if (family >= 4) want_high = high;
+                    }
+                    uint64_t flags = subtraction(expected_low, low, bits);
+                    if (family >= 4) {
+                        flags = (seeds[seed]&0x8d5)&~UINT64_C(64);
+                        if (equal) flags |= 64;
+                    }
+                    int bad = out[0] != want_low || out[1] != want_high ||
+                        out[2] != desired_low || out[3] != desired_high ||
+                        (out[4]&0x8d5) != flags || out[5] != ((flags&0xd5)|2) ||
+                        (out[6]>>32) != (canary>>32) || (uint32_t)out[6] != before ||
+                        after != before || memcmp(raw, expected, sizeof(raw));
+                    for (unsigned i = 7; i < 16; i++) bad |= out[i] != canary;
+                    if (bad) {
+                        kernel_failures++;
+                        register_failures += out[0] != want_low || out[1] != want_high ||
+                            out[2] != desired_low || out[3] != desired_high;
+                        status_failures += (out[4]&0x8d5) != flags || out[5] != ((flags&0xd5)|2);
+                        if (kernel_failures <= 2) {
+                            fprintf(stdout, "LLVM failure kernel=%u bits=%u edge=%llx equal=%u seed=%llx AX=%llx/%llx DX=%llx/%llx flags=%llx/%llx BX=%llx CX=%llx\n",
+                                index, bits, (unsigned long long)edges[edge], equal,
+                                (unsigned long long)seeds[seed], (unsigned long long)out[0],
+                                (unsigned long long)want_low, (unsigned long long)out[1],
+                                (unsigned long long)want_high, (unsigned long long)out[4],
+                                (unsigned long long)flags, (unsigned long long)out[2], (unsigned long long)out[3]);
+                        }
+                        failures++;
+                    }
+                    observations++;
+                }
+            }
+        }
+        if (kernel_failures) {
+            printf("LLVM kernel=%u observations=48 failures=%u register=%u status=%u\n",
+                index, kernel_failures, register_failures, status_failures);
+        }
+    }
+    printf("LLVM CMPXCHG numerical observations %u failures %u\n", observations, failures);
+    return failures ? 1 : 0;
+}
+`
diff --git a/amd64_cmpxchg_object_test.go b/amd64_cmpxchg_object_test.go
new file mode 100644
index 000000000..3015dce06
--- /dev/null
+++ b/amd64_cmpxchg_object_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86CMPXCHGThreeAPIsFiveTargetsExactNativeO0O2Objects(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 compiler and disassembler are required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		var source, declarations strings.Builder
+		declarations.WriteString("package ordering\n")
+		want := make(map[string]struct {
+			op     string
+			bits   int
+			locked bool
+		})
+		for index, row := range x86CMPXCHGOriginalRows {
+			if target.arch == "386" && (row.op == "CMPXCHGQ" || row.bits == 128) {
+				continue
+			}
+			for _, locked := range []bool{false, true} {
+				name := fmt.Sprintf("cas%d_%t", index, locked)
+				body := x86CMPXCHGOriginalBody(index, "1(SI)")
+				if locked {
+					body = "LOCK\n\t" + body
+				}
+				original := strings.Replace(x86NamedLockOracleSource(target.arch, body), "·locked", "·"+name, 1)
+				// Original objects are accepted without executing unsafe forms.
+				x86OrderingHintGoBytes(t, target.arch, original)
+				source.WriteString(original)
+				fmt.Fprintf(&declarations, "func %s(p *[32]byte)\n", name)
+				opcode := "CMPXCHG"
+				if row.pair {
+					opcode = row.op
+				}
+				want[name] = struct {
+					op     string
+					bits   int
+					locked bool
+				}{opcode, row.bits, locked}
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "native.ll"), filepath.Join(dir, "native.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+					listing := x86FloatCompareCaptureCommand(t, exec.Command(disassembler, "--disassemble", object))
+					sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?(cas[0-9]+_(?:false|true))>:\n`).FindAllSubmatchIndex(listing, -1)
+					seen := make(map[string]bool)
+					for index, section := range sections {
+						name := string(listing[section[2]:section[3]])
+						expected, known := want[name]
+						if !known || seen[name] {
+							t.Fatalf("unexpected or duplicate original function identity %s", name)
+						}
+						end := len(listing)
+						if index+1 < len(sections) {
+							end = sections[index+1][0]
+						}
+						var code []byte
+						for _, line := range strings.Split(string(listing[section[1]:end]), "\n") {
+							fields := strings.Fields(line)
+							if len(fields) < 2 || !strings.HasSuffix(fields[0], ":") {
+								continue
+							}
+							var machine []byte
+							for _, field := range fields[1:] {
+								if len(field) != 2 {
+									break
+								}
+								value, err := hex.DecodeString(field)
+								if err != nil {
+									break
+								}
+								machine = append(machine, value[0])
+							}
+							code = append(code, machine...)
+						}
+						// LLVM's disassembler displays a standalone F0 byte as a
+						// separate "lock" line. Decode complete contiguous bytes,
+						// not that presentation boundary, as the CPU does.
+						mode := 64
+						if target.arch == "386" {
+							mode = 32
+						}
+						count := 0
+						for len(code) != 0 {
+							physical, err := x86asm.Decode(code, mode)
+							if err != nil || physical.Len <= 0 || physical.Len > len(code) {
+								t.Fatalf("incomplete physical function decode %s: %x %v", name, code, err)
+							}
+							machine := code[:physical.Len]
+							code = code[physical.Len:]
+							if !strings.HasPrefix(physical.Op.String(), "CMPXCHG") {
+								continue
+							}
+							count++
+							locked := false
+							for _, prefix := range physical.Prefix {
+								if byte(prefix) == 0xf0 {
+									locked = true
+								}
+							}
+							width := physical.DataSize
+							if bytes.Contains(machine, []byte{0x0f, 0xb0}) {
+								// x/arch DataSize retains the operand-size state for
+								// B0, whose opcode independently specifies byte width.
+								width = 8
+							}
+							if physical.Op.String() != expected.op || locked != expected.locked ||
+								expected.op == "CMPXCHG" && width != expected.bits {
+								t.Fatalf("%s/%s lost native width/prefix/opcode: %x %s\n%s", level, name, machine,
+									x86asm.GoSyntax(physical, 0, nil), listing)
+							}
+						}
+						if count != 1 {
+							t.Fatalf("%s/%s has %d complete native operations\n%s", level, name, count, listing)
+						}
+						seen[name] = true
+					}
+					if len(seen) != len(want) {
+						t.Fatalf("%s emitted %d/%d complete functions\n%s", level, len(seen), len(want), listing)
+					}
+					t.Logf("%s independently decoded %d native opcodes with exact width and LOCK identity", level, len(seen))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_cmpxchg_original_c_runtime_test.go b/amd64_cmpxchg_original_c_runtime_test.go
new file mode 100644
index 000000000..422e51533
--- /dev/null
+++ b/amd64_cmpxchg_original_c_runtime_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func x86CMPXCHGOriginalCNumerical(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	reference := x86CMPXCHGOriginalCSource()
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := x86CMPXCHGCompileOriginalC(t, execution, reference, level)
+			if string(output) != "actual C opcode CMPXCHG numerical observations 576 failures 0\n" {
+				t.Fatalf("actual original C opcode vs independent math: %s", output)
+			}
+			t.Log(string(output))
+		})
+	}
+}
+
+func x86CMPXCHGOriginalCSource() string {
+	_, _, names := x86CMPXCHGNumericalFixture()
+	var definitions strings.Builder
+	for index, op := range []string{"cmpxchgb %bl,", "cmpxchgw %bx,", "cmpxchgl %ebx,", "cmpxchgq %rbx,", "cmpxchg8b ", "cmpxchg16b "} {
+		for _, locked := range []bool{false, true} {
+			name := fmt.Sprintf("numeric_%d_%t", index, locked)
+			prefix := ""
+			if locked {
+				prefix = "lock; "
+			}
+			fmt.Fprintf(&definitions, `static void %s(uint64_t *out, unsigned char *p,
+        uint64_t expected_low, uint64_t expected_high, uint64_t desired_low,
+        uint64_t desired_high, uint64_t seed) {
+    __asm__ volatile(
+        "pushq %%[seed]; popfq; %s%s(%%%%rsi);"
+`, name, prefix, strings.ReplaceAll(op, "%", "%%"))
+			definitions.WriteString(`        "movq %%rax,0(%%rdi); movq %%rdx,8(%%rdi);"
+        "movq %%rbx,16(%%rdi); movq %%rcx,24(%%rdi);"
+        "pushfq; popq %%r9; movq %%r9,32(%%rdi);"
+        "lahf; movzbl %%ah,%%ebx; movq %%rbx,40(%%rdi);"
+        "stmxcsr 48(%%rdi);"
+        : "+a"(expected_low), "+d"(expected_high), "+b"(desired_low), "+c"(desired_high)
+        : "D"(out), "S"(p), [seed] "r"(seed)
+        : "r9", "cc", "memory");
+}
+`)
+		}
+	}
+	reference := strings.Replace(x86CMPXCHGCNumerical, "KERNEL_PROTOTYPES", definitions.String(), 1)
+	reference = strings.Replace(reference, "KERNEL_NAMES", names, 1)
+	reference = strings.ReplaceAll(reference, "LLVM failure", "actual C opcode failure")
+	reference = strings.ReplaceAll(reference, "LLVM kernel", "actual C opcode kernel")
+	reference = strings.ReplaceAll(reference, "LLVM CMPXCHG numerical", "actual C opcode CMPXCHG numerical")
+	return reference
+}
+
+func x86CMPXCHGCompileOriginalC(t *testing.T, execution x86FloatCompareExecution, sourceText, level string) []byte {
+	t.Helper()
+	directory := t.TempDir()
+	source := filepath.Join(directory, "original.c")
+	executable := filepath.Join(directory, gotoolchain.HostExecutable("original"))
+	if err := os.WriteFile(source, []byte(sourceText), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := append([]string(nil), execution.compiler...)
+	command = append(command, level, source, "-o", executable)
+	x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+	return execution.run(t, executable)
+}
diff --git a/amd64_cmpxchg_original_catalogue_test.go b/amd64_cmpxchg_original_catalogue_test.go
new file mode 100644
index 000000000..480b20152
--- /dev/null
+++ b/amd64_cmpxchg_original_catalogue_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Keep the complete historical source bodies and all 33/24 accepted operands.
+// The official include changes no instruction: it supplies their original
+// NOSPLIT/NOPTR spellings from the selected actual SDK, not a invented ABI.
+func x86CMPXCHGMixedOriginalCatalogue(t *testing.T, arch, source string) {
+	t.Helper()
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "complete.s"), filepath.Join(directory, "complete.o")
+	if err := os.WriteFile(input, []byte("#include \"textflag.h\"\n"+source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), "tool", "asm", "-S",
+		"-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-p", "ordering", "-o", object, input)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch,
+		"GOFLAGS=", "GOENV=off", "GOWORK=off", "GOEXPERIMENT=")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, arch); failure != nil {
+		t.Fatalf("actual complete original syntax object: %v\n%s", failure, output)
+	}
+	t.Logf("actual original complete accepted catalogue, not unsafe execution:\n%s", output)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatalf("complete original source parse: %v", err)
+	}
+	count, physicalContext := 0, 0
+	for _, instruction := range file.Funcs[0].Instrs {
+		if !strings.HasPrefix(string(instruction.Op), "CMPXCHG") {
+			continue
+		}
+		_, recognized, err := x86CompareExchangeProperties(instruction.Op, instruction, arch)
+		if !recognized || err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("actual original accepted row disappeared from grammar: %+v/%v", instruction, err)
+		}
+		count++
+		if err != nil {
+			physicalContext++
+			t.Logf("source/physical bank or native #UD Context: %s: %v", instruction.Raw, err)
+		}
+	}
+	want := 33
+	if arch == "386" {
+		want = 24
+	}
+	if count != want || physicalContext != 5 {
+		t.Fatalf("complete original syntax/physical-context denominator changed: %d/%d, want %d/5", count, physicalContext, want)
+	}
+}
diff --git a/amd64_comi_boundaries_test.go b/amd64_comi_boundaries_test.go
new file mode 100644
index 000000000..7fbbe628d
--- /dev/null
+++ b/amd64_comi_boundaries_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86COMIWholeFileNativeTargetAndDefinedFlags(t *testing.T) {
+	for _, name := range x86COMIOracleNames() {
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, dead := range []bool{false, true} {
+				before := ""
+				if dead {
+					before = "RET\n"
+				}
+				for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", "i386-unknown-linux-gnu", "x86_64madeup-unknown-linux-gnu"} {
+					source := "TEXT ·view(SB),4,$0-0\n" + before + name + " X0,X1\nRET\n"
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", "amd64", triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("missing native target accepted", name, api, dead, triple, err)
+					}
+					malformed := strings.Replace(source, "X0,X1", "X0,Y1", 1)
+					if _, err := x86ScalarFPBitViewAPI(t, malformed, "func view()\n", "amd64", triple, api); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native-target context hid malformed/dead source", name, api, dead, triple, err)
+					}
+				}
+			}
+			for _, missing := range []int{-1, 0, 1} {
+				var setup strings.Builder
+				for input := 0; input < 2; input++ {
+					if input != missing {
+						fmt.Fprintf(&setup, "XORPS X%d,X%d\n", input, input)
+					}
+				}
+				source := "TEXT ·view(SB),4,$0-4\n" + setup.String() + "XORL AX,AX\n" + name + " X0,X1\nSETEQ AL\nMOVL AX,X2\nPEXTRD $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if missing != -1 {
+					x86VectorScratchCodegenControl(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					continue
+				}
+				if err != nil {
+					t.Fatal("undefined input acquired public result permission", name, api, missing, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86COMIRuntimePartitionCompleteAndOriginalInventory(t *testing.T) {
+	remaining := make(map[string]bool)
+	for _, row := range x86ScalarCompareAFCases("amd64", true) {
+		remaining[row.name] = true
+	}
+	var counts [3]int
+	for _, axis := range []x86FloatCompareRuntimeISA{x86FloatCompareSSE, x86FloatCompareVEX, x86FloatCompareEVEX} {
+		cases := x86ScalarCompareAFRuntimeCases(axis)
+		for _, row := range cases {
+			if !remaining[row.name] {
+				t.Fatal("duplicate runtime kernel", row)
+			}
+			delete(remaining, row.name)
+			counts[axis-1]++
+		}
+		goAssemblerOracleOutput(t, "amd64", x86ScalarCompareAFAssembly("amd64", cases), "", true)
+	}
+	if len(remaining) != 0 || counts != [3]int{48, 48, 48} {
+		t.Fatal("complete runtime partition changed", remaining, counts)
+	}
+}
diff --git a/amd64_comi_fault_runtime_test.go b/amd64_comi_fault_runtime_test.go
new file mode 100644
index 000000000..60cac94c5
--- /dev/null
+++ b/amd64_comi_fault_runtime_test.go
@@ -0,0 +1,169 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86COMIDeadMemoryExtent(t *testing.T) {
+	x86COMIDeadFaults(t, false)
+}
+
+func x86COMIDeadFaults(t *testing.T, native bool) {
+	t.Helper()
+	axis := x86FloatCompareSSE
+	if native {
+		axis = x86FloatCompareEVEX
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	if native && (runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || len(execution.prefix) != 0) {
+		t.Fatal("COMI exception delivery requires actual native Linux AMD64")
+	}
+	assembly, declarations, driver, _, trapChecks := x86COMIDeadFaultFixture(t, native, execution.triple)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "comi-fault", pipeline.ir, driver, pipeline.level)
+					want := fmt.Sprintf("COMI original Go/LLVM dead reads matched; native IE/DE/SAE checks=%d\n", trapChecks)
+					if string(output) != want {
+						t.Fatal("missing complete fault receipt", string(output))
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86COMIDeadFaultFixture(t *testing.T, native bool, triple string) (string, string, string, int, int) {
+	t.Helper()
+	var assembly, declarations, original, prototypes, pairs strings.Builder
+	count := 0
+	for _, name := range x86COMIOracleNames() {
+		if strings.HasPrefix(name, "V") && !native {
+			continue
+		}
+		suffixes := []string{""}
+		if strings.HasPrefix(name, "V") {
+			suffixes = append(suffixes, ".SAE")
+		}
+		for _, suffix := range suffixes {
+			width, load := 4, "MOVSS"
+			if strings.HasSuffix(name, "D") {
+				width, load = 8, "MOVSD"
+			}
+			body := "XORPS X1,X1\nLDMXCSR (SI)\n" + name + " (DI),X1\n"
+			if suffix != "" {
+				body = "XORPS X1,X1\n" + load + " (DI),X0\nLDMXCSR (SI)\n" + name + suffix + " X0,X1\n"
+			}
+			body += "XORL AX,AX\nRET\n" // The comparison FLAGS are deliberately dead.
+			function, nativeFunction := fmt.Sprintf("fault%d", count), fmt.Sprintf("original%d", count)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DI\nMOVQ csr+8(FP),SI\n%s", function, body)
+			fmt.Fprintf(&declarations, "func %s(p *uint64,csr *uint32)\n", function)
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+body)
+			bytes := make([]string, len(code))
+			for index, value := range code {
+				bytes[index] = fmt.Sprintf("0x%02x", value)
+			}
+			symbol := nativeFunction
+			if strings.Contains(triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&original, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern void %s(uint64_t*,uint32_t*),%s(uint64_t*,uint32_t*);\n", function, nativeFunction)
+			quiet, sae := 0, 0
+			if strings.Contains(name, "UCOMI") {
+				quiet = 1
+			}
+			if suffix != "" {
+				sae = 1
+			}
+			fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d},\n", nativeFunction, function, width, quiet, sae)
+			count++
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	trapChecks := 0
+	if native {
+		trapChecks = 1
+	}
+	driver := fmt.Sprintf("#define NATIVE_TRAPS %d\n", trapChecks) + `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + original.String() + prototypes.String() + `
+typedef void (*kernel)(uint64_t*,uint32_t*);
+static const struct {kernel original,translated;int width,quiet,sae;} pairs[]={
+` + pairs.String() + `};
+static int outcome(kernel fn,uint8_t *p,uint32_t csr) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        fn((uint64_t*)p,&csr);
+        _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status)) {
+        int signal=WTERMSIG(status);
+        if(signal==SIGSEGV || signal==SIGBUS) return 1;
+        if(signal==SIGFPE) return 2;
+    }
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    uint8_t *p=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(p==MAP_FAILED || mprotect(p+page,page,PROT_NONE)) return 2;
+    memset(p,0,page);
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);i++) {
+        for(int available=0;available<=pairs[i].width+1;available++) {
+            int want=available<pairs[i].width;
+            int a=outcome(pairs[i].original,p+page-available,0x1f80);
+            int b=outcome(pairs[i].translated,p+page-available,0x1f80);
+            if(a!=want || b!=want) {
+                fprintf(stderr,"COMI dead read %u available=%d want=%d Go=%d LLVM=%d\n",i,available,want,a,b);
+                return 3;
+            }
+        }
+        for(int event=0;NATIVE_TRAPS && event<3;event++) {
+            uint64_t bits;
+            if(pairs[i].width==8)
+                bits=event==0?UINT64_C(0x7ff8123456789abc):event==1?UINT64_C(0x7ff0123456789abc):1;
+            else
+                bits=event==0?UINT64_C(0x7fc12345):event==1?UINT64_C(0x7f812345):1;
+            memcpy(p,&bits,8);
+            uint32_t csr=event==2?0x1e80:0x1f00;
+            int want=pairs[i].sae || (event==0 && pairs[i].quiet)?0:2;
+            int a=outcome(pairs[i].original,p,csr),b=outcome(pairs[i].translated,p,csr);
+            if(a!=want || b!=want) {
+                fprintf(stderr,"COMI exception %u event=%d want=%d Go=%d LLVM=%d\n",i,event,want,a,b);
+                return 4;
+            }
+        }
+    }
+    if(munmap(p,2*page)) return 5;
+    printf("COMI original Go/LLVM dead reads matched; native IE/DE/SAE checks=%d\n",NATIVE_TRAPS);
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), driver, count, trapChecks
+}
diff --git a/amd64_comi_fixture_compile_unix_test.go b/amd64_comi_fixture_compile_unix_test.go
new file mode 100644
index 000000000..732572f7a
--- /dev/null
+++ b/amd64_comi_fixture_compile_unix_test.go
@@ -0,0 +1,131 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Consume the exact builders used by all four native Linux owners without
+// executing an AVX/AVX512 opcode. Linux objects, original Go linked programs
+// and the host-target C attachment have separate, explicit compilation claims.
+func TestX86COMINativeRuntimeFixturesCompileOnly(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	total := 0
+	t.Run("RawNativeCompare", func(t *testing.T) {
+		source, _, driver, count := x86COMIRawNativeFixture(t)
+		var declarations strings.Builder
+		for index := 0; index < count; index++ {
+			fmt.Fprintf(&declarations, "func flagcompare%d(a,b,out *byte)\n", index)
+		}
+		if count != 24 {
+			t.Fatal("raw complete runtime inventory changed", count)
+		}
+		x86COMICompileFixture(t, execution, source, declarations.String(), driver)
+		total += count
+	})
+	t.Run("NativeDeadExceptions", func(t *testing.T) {
+		source, declarations, driver, count, traps := x86COMIDeadFaultFixture(t, true, execution.triple)
+		if count != 12 || traps != 1 {
+			t.Fatal("native exception checks dropped", count, traps)
+		}
+		x86COMICompileFixture(t, execution, source, declarations, driver)
+		total += count
+	})
+	for _, axis := range []x86FloatCompareRuntimeISA{x86FloatCompareVEX, x86FloatCompareEVEX} {
+		t.Run(fmt.Sprintf("NativeVectorFlags/ISA%d", axis), func(t *testing.T) {
+			cases := x86ScalarCompareAFRuntimeCases(axis)
+			if len(cases) != 48 {
+				t.Fatal("native FLAGS inventory changed", len(cases))
+			}
+			files := x86ScalarCompareAFOriginalFiles(axis)
+			x86COMICompileOriginalGo(t, files, true)
+			declarations := strings.TrimPrefix(files["status.go"], "package scalarstatus\n")
+			x86COMICompileFixture(t, execution, files["status_amd64.s"], declarations, x86ScalarCompareAFRuntimeC(cases))
+			total += len(cases)
+		})
+		t.Run(fmt.Sprintf("NativeVectorMXCSR/ISA%d", axis), func(t *testing.T) {
+			source, declarations, original, driver, count := x86COMIConstantOracle(axis)
+			want := 24
+			if axis == x86FloatCompareEVEX {
+				want = 96
+			}
+			if count != want {
+				t.Fatal("native MXCSR inventory changed", count, want)
+			}
+			x86COMICompileOriginalGo(t, map[string]string{
+				"go.mod": "module comistatus\n\ngo 1.20\n", "main.go": original, "original_amd64.s": source,
+			}, false)
+			x86COMICompileFixture(t, execution, source, declarations, driver)
+			total += count
+		})
+	}
+	if total != 252 {
+		t.Fatal("four native owner fixtures are not exhaustively compiled", total)
+	}
+	t.Log("252 exact native runtime kernels compiled in six bounded batches (at most 96 functions); no native AVX/AVX512 or trap execution performed")
+}
+
+func x86COMICompileOriginalGo(t *testing.T, files map[string]string, testPackage bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	arguments := []string{"build", "-p=2", "-o", filepath.Join(dir, "original"), "."}
+	if testPackage {
+		arguments = []string{"test", "-c", "-p=2", "-vet=off", "-o", filepath.Join(dir, "original"), "."}
+	}
+	goBinary, _ := x86LEAActualSDKDriver(t)
+	command := exec.Command(goBinary, arguments...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+}
+
+func x86COMICompileFixture(t *testing.T, execution x86FloatCompareExecution, source, declarations, driver string) {
+	t.Helper()
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR_O2=%v", optimized), func(t *testing.T) {
+					input := ir
+					if optimized {
+						input = x86MulDivRoundOptimize(t, input)
+					}
+					compileLLVMToObject(t, execution.llc, "x86_64-unknown-linux-gnu", "comi.ll", "comi.o", input)
+				})
+			}
+		})
+	}
+	// Link (but never run) the same actual C/native-byte oracle on the available
+	// host ABI. On non-Linux hosts this is not Linux libc/link/runtime evidence.
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "comi.ll"), filepath.Join(dir, "comi.o")
+	csource, executable := filepath.Join(dir, "oracle.c"), filepath.Join(dir, "oracle")
+	for path, contents := range map[string]string{input: x86MulDivRoundOptimize(t, ir), csource: driver} {
+		if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(execution.llc, "-O2", "-mtriple="+execution.triple, "-filetype=obj", input, "-o", object))
+	command := append([]string(nil), execution.compiler...)
+	command = append(command, "-O2", csource, object, "-lm", "-o", executable)
+	x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+}
diff --git a/amd64_comi_forms.go b/amd64_comi_forms.go
new file mode 100644
index 000000000..04b3e792c
--- /dev/null
+++ b/amd64_comi_forms.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type x86COMISpec struct {
+	bits   int
+	vector bool
+}
+
+var x86COMISpecs = map[Op]x86COMISpec{
+	"COMISS": {32, false}, "UCOMISS": {32, false},
+	"COMISD": {64, false}, "UCOMISD": {64, false},
+	"VCOMISS": {32, true}, "VUCOMISS": {32, true},
+	"VCOMISD": {64, true}, "VUCOMISD": {64, true},
+}
+
+// Go's yxm and _yvcomisd rows have two read-only scalar operands, not a
+// vector destination. EVEX adds register-only SAE, never masking/broadcast.
+type x86COMIForm struct {
+	spec      x86COMISpec
+	name      string
+	sae, evex bool
+}
+
+func x86COMIProperties(ins Instr, arch string) (x86COMIForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86COMISpecs[Op(name)]
+	form := x86COMIForm{spec: spec, name: name, sae: suffix == "SAE", evex: ins.x86ScalarFlagCompareEVEX || dotted}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86COMIForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go scalar flag-compare grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || len(ins.Args) != 2 ||
+		dotted && (!spec.vector || suffix != "SAE" || ins.Args[0].Kind != OpReg) {
+		return fail()
+	}
+	var contextErr error
+	for index, operand := range ins.Args {
+		if operand.Kind == OpReg {
+			register, valid := amd64ParseXReg(operand.Reg)
+			if !valid || !spec.vector && (register >= 16 || arch == "386" && register >= 8) {
+				return fail()
+			}
+			if arch == "386" && register >= 8 {
+				contextErr = fmt.Errorf("%w: %s lacks physical mode32 high-X identity", ErrProbeNeedsContext, ins.Op)
+			}
+			form.evex = form.evex || register >= 16
+			continue
+		}
+		if index != 0 || !isAMD64MemoryOperand(operand) {
+			return fail()
+		}
+		if operand.Kind == OpMem {
+			if operand.Mem.OffRaw != "" || operand.Mem.IndexExt != "" {
+				return fail()
+			}
+			if err := x86SymbolIndexedMemoryError(operand.Mem, arch); err != nil {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					return form, true, err
+				}
+				contextErr = err
+				continue
+			}
+			if arch == "386" && strings.HasSuffix(operand.Mem.Sym, "(SB)") {
+				operand.Mem.Base = ""
+			}
+		}
+		if !x86PackedShiftMemoryValid(operand, arch) {
+			return fail()
+		}
+	}
+	return form, true, contextErr
+}
+
+func validateX86COMIFile(file *File, options Options) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	needed := false
+	var contextErr error
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			_, known, err := x86COMIProperties(instruction, options.Goarch)
+			if known && err != nil {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					return fmt.Errorf("%s: %w", function.Sym, err)
+				}
+				if contextErr == nil {
+					contextErr = fmt.Errorf("%s: %w", function.Sym, err)
+				}
+			}
+			needed = needed || known
+		}
+	}
+	if contextErr != nil {
+		return contextErr
+	}
+	if needed && !x86ScalarFloatIntegerNativeTarget(options.Goarch, options.TargetTriple) {
+		return fmt.Errorf("%w: scalar flag comparison requires its native x86 MXCSR target", ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+func x86TypedCOMIByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	name, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86COMISpecs[Op(name)]; !known {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if !strings.EqualFold(string(op), string(ins.Op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("scalar flag comparison effect/source mismatch")
+	}
+	form, known, err := x86COMIProperties(ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.spec.bits / 8)
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: width, read: true},
+		{index: 1, operand: ins.Args[1], width: width, read: true},
+	}, flagsDefined: x86ByteFlagsAll, requiresResultProof: true}, true, nil
+}
+
+func x86ResultCOMIStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultCOMIStepWithRead(ins, state, owned, arch, false)
+}
+
+// Only the paired native comparison supplies conditional numerical inputs.
+// Its complete opcode preserves the scalar read, MXCSR and exception effects;
+// no memory backing or reusable input fact reaches the declaration observer.
+func x86ResultCOMIStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86COMIProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	width := int64(form.spec.bits / 8)
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg {
+			index, _ := amd64ParseXReg(operand.Reg)
+			mask := x86CallerVectorByteMask(width)
+			if state.vectorBytes(index)&mask != mask {
+				return false, true
+			}
+		} else if !x86ResultReadWithNativeContinuation(ins, operand, width, state, owned, arch, nativeRead) {
+			return false, true
+		}
+	}
+	state.flags = x86ByteFlagsAll
+	return true, true
+}
diff --git a/amd64_comi_grammar_test.go b/amd64_comi_grammar_test.go
new file mode 100644
index 000000000..c12a824a7
--- /dev/null
+++ b/amd64_comi_grammar_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86COMIOracleNames() []string {
+	return []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"}
+}
+
+func TestX86COMIIndependentCompleteEncoderRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n}") {
+		t.Fatal("complete legacy yxm operand table changed")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, name := range x86COMIOracleNames() {
+		double, vector := strings.HasSuffix(name, "D"), strings.HasPrefix(name, "V")
+		opcode := "0x2F"
+		if strings.Contains(name, "UCOMI") {
+			opcode = "0x2E"
+		}
+		if !vector {
+			prefix := "Pm"
+			if double {
+				prefix = "Pe"
+			}
+			entry := fmt.Sprintf("{A%s, yxm, %s, opBytes{%s}}", name, prefix, strings.ToLower(opcode))
+			if !strings.Contains(string(legacy), entry) {
+				t.Fatal("legacy scalar compare opcode attributes changed", entry)
+			}
+			count++
+			continue
+		}
+		vex, evex, tuple := "avxEscape | vex128 | vex0F | vexW0", "avxEscape | evex128 | evex0F | evexW0", "evexN4 | evexSaeEnabled"
+		if double {
+			vex, evex, tuple = "avxEscape | vex128 | vex66 | vex0F | vexW0", "avxEscape | evex128 | evex66 | evex0F | evexW1", "evexN8 | evexSaeEnabled"
+		}
+		opbytes := []string{vex, opcode, evex, tuple, opcode}
+		index := 0
+		for _, row := range rules {
+			if row.Opcode != name {
+				continue
+			}
+			class, zcase, advance, offset := "Yxm", "Zvex_rm_v_r", 2, 0
+			if index == 1 {
+				class, zcase, advance, offset = "YxmEvex", "Zevex_rm_v_r", 3, 2
+			}
+			destination := "Yxr"
+			if index == 1 {
+				destination = "YxrEvex"
+			}
+			if row.Ytab != "_yvcomisd" || row.Prefix != "Pavx" || row.RowIndex != index || row.EncodingOffset != offset ||
+				row.ZCase != zcase || row.ZOffset != advance || !reflect.DeepEqual(row.Classes, []string{class, destination}) || !reflect.DeepEqual(row.OpBytes, opbytes) {
+				t.Fatalf("%s independent complete encoder row changed: %+v", name, row)
+			}
+			index++
+			count++
+		}
+		if index != 2 {
+			t.Fatal("missing scalar compare encoder rows", name, index)
+		}
+	}
+	if count != 12 || len(x86COMISpecs) != 8 {
+		t.Fatal("complete eight-name/twelve-row family changed", count, len(x86COMISpecs))
+	}
+}
+
+func TestX86COMITypedEveryByteAndEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86COMIOracleNames() {
+			width := 4
+			if strings.HasSuffix(name, "D") {
+				width = 8
+			}
+			instruction := x86ScalarLaneInstruction(t, name+" X1,X2")
+			effect, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, arch)
+			want := x86TypedByteEffect{operands: []x86TypedByteOperand{
+				{index: 0, operand: instruction.Args[0], width: int64(width), read: true},
+				{index: 1, operand: instruction.Args[1], width: int64(width), read: true},
+			}, flagsDefined: x86ByteFlagsAll, requiresResultProof: true}
+			if !known || err != nil || !reflect.DeepEqual(effect, want) {
+				t.Fatal("comparison gained a write or lost exact input bytes/FLAGS", arch, name, effect, err)
+			}
+			for _, input := range []int{1, 2} {
+				for missing := -1; missing < 64; missing++ {
+					state := &x86ResultState{}
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.writeVector(2, 64, ^uint64(0), false)
+					bytes := ^uint64(0)
+					if missing >= 0 {
+						bytes &^= 1 << uint(missing)
+					}
+					state.writeVector(input, 64, bytes, false)
+					accepted := x86ResultTransfer(instruction, state, nil, 0, arch)
+					want := missing < 0 || missing >= width
+					if accepted != want || state.vectorBytes(input) != bytes || accepted && state.flags != x86ByteFlagsAll || !accepted && state.flags != 0 {
+						t.Fatal("comparison consumed undefined bytes or changed inputs/FLAGS on failure", arch, name, input, missing)
+					}
+				}
+			}
+			for _, kind := range []string{"FP", "AUTO", "SB", "pointer"} {
+				for missing := -1; missing < width; missing++ {
+					owned := make([]bool, 16)
+					state := &x86ResultState{fp: make([]bool, 16), auto: make([]bool, 16)}
+					state.writeVector(2, 64, ^uint64(0), false)
+					for i := range owned {
+						owned[i], state.fp[i], state.auto[i] = i != missing, i != missing, i != missing
+					}
+					operand := "value+0(FP)"
+					switch kind {
+					case "AUTO":
+						operand = "local-16(SP)"
+					case "SB":
+						operand = "external(SB)"
+					case "pointer":
+						operand = "(BX)"
+						state.pointerGP[3] = true
+					}
+					accepted := x86ResultTransfer(x86ScalarLaneInstruction(t, name+" "+operand+",X2"), state, owned, 0, arch)
+					want := (kind == "FP" || kind == "AUTO") && missing == -1
+					if accepted != want {
+						t.Fatal("comparison acquired unowned/undefined memory", arch, name, kind, missing)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86COMIHelperCannotBorrowForeignDispatch(t *testing.T) {
+	for _, operation := range []Op{"ADDQ", "MOVQ", "UNKNOWN.COMISS", "COMISS"} {
+		var ir strings.Builder
+		ctx := amd64Ctx{b: &ir, goarch: "amd64", targetTriple: "x86_64-unknown-linux-gnu"}
+		instruction := x86ScalarLaneInstruction(t, "MOVQ AX,BX")
+		known, terminated, err := ctx.lowerVectorScalarFlagCompare(operation, instruction)
+		_, effectKnown, effectErr := x86TypedCOMIByteEffect(operation, instruction, "amd64")
+		want := operation == "COMISS"
+		if known != want || effectKnown != want || (err != nil) != want || (effectErr != nil) != want || terminated || ir.Len() != 0 {
+			t.Fatal("COMI helper borrowed foreign source/dispatch identity", operation, known, effectKnown, err, effectErr)
+		}
+	}
+}
diff --git a/amd64_comi_native_avx512_linux_amd64_test.go b/amd64_comi_native_avx512_linux_amd64_test.go
new file mode 100644
index 000000000..53318021b
--- /dev/null
+++ b/amd64_comi_native_avx512_linux_amd64_test.go
@@ -0,0 +1,26 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86COMIRawNativeCompare(t *testing.T) {
+	x86COMIRawNativeCompare(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86COMINativeDeadExceptions(t *testing.T) {
+	x86COMIDeadFaults(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlagsEVEX(t *testing.T) {
+	t.Run("EVEX", func(t *testing.T) {
+		x86ScalarCompareAFOriginalGo(t, x86FloatCompareEVEX)
+		x86ScalarCompareAFLLVM(t, x86FloatCompareEVEX)
+	})
+}
+
+func TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSREVEX(t *testing.T) {
+	t.Run("EVEX", func(t *testing.T) {
+		x86COMIOriginalConstantsAndMXCSR(t, x86FloatCompareEVEX)
+	})
+}
diff --git a/amd64_comi_native_input_test.go b/amd64_comi_native_input_test.go
new file mode 100644
index 000000000..fe3156880
--- /dev/null
+++ b/amd64_comi_native_input_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86COMINativeInputSource(arch, name, op, setup, address, tail string) string {
+	word, size := "Q", 8
+	if arch == "386" {
+		word, size = "L", 4
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s p+0(FP),DX\n"+
+		"MOVL $0,AX\nMOVL AX,X1\nMOVL $2,CX\n%s%s %s,X1\n%s"+
+		"PUSHF%s\nPOP%s AX\nMOV%s AX,ret+%d(FP)\nRET\n",
+		name, 2*size, word, setup, op, address, tail, word, word, word, size)
+}
+
+func x86COMINativeInputStatusProjection(arch, name, op, setup, address, tail string) string {
+	source := x86COMINativeInputSource(arch, name, op, setup, address, tail)
+	word := "Q"
+	if arch == "386" {
+		word = "L"
+	}
+	// COMI defines only the six status flags, not incoming DF or ID. Keep
+	// the original full-word observation below as an explicit negative.
+	pop := "POP" + word + " AX\n"
+	return strings.Replace(source, pop, pop+"AND"+word+" $0x8d5,AX\n", 1)
+}
+
+func TestX86COMINativeInputCompleteFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, op := range x86COMIOracleNames() {
+				source.WriteString(x86COMINativeInputStatusProjection(target.arch, op, op, "", "-7(DX)(CX*4)", ""))
+				fmt.Fprintf(&declarations, "func %s(p *byte) uintptr\n", op)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized native compare input rejected", api, err)
+				}
+				if strings.Count(ir, "asm sideeffect") != 8 ||
+					strings.Count(ir, "elementtype([4 x i8])") != 4 ||
+					strings.Count(ir, "elementtype([8 x i8])") != 4 {
+					t.Fatal("native comparison lost its exact scalar access or MXCSR effect", api)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86COMINativeInputCannotSupplyOtherRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, triple := "L", "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			word, triple = "Q", "x86_64-unknown-linux-gnu"
+		}
+		for _, op := range x86COMIOracleNames() {
+			for _, row := range []struct{ name, remove, setup, address, tail string }{
+				{"vector-input", "MOVL AX,X1\n", "", "(DX)", ""},
+				{"index-input", "MOVL $2,CX\n", "", "(DX)(CX*4)", ""},
+				{"pointer-index", "", "MOV" + word + " p+0(FP),CX\n", "(DX)(CX*4)", ""},
+				{"numeric-base", "", "MOVL $4,DX\n", "(DX)", ""},
+				{"unknown-base", "MOV" + word + " p+0(FP),DX\n", "", "(DX)", ""},
+				{"unbound-symbol", "", "", "external(SB)", ""},
+				{"unbound-segment", "", "", "(FS)", ""},
+				{"unknown-store", "", "", "(DX)", "MOVL BX,(DX)\n"},
+				{"no-future-pointer", "", "", "(DX)", "MOVL (DX),DX\n" + op + " (DX),X1\n"},
+			} {
+				t.Run(arch+"/"+op+"/"+row.name, func(t *testing.T) {
+					source := x86COMINativeInputStatusProjection(arch, "view", op, row.setup, row.address, row.tail)
+					if row.remove != "" {
+						source = strings.Replace(source, row.remove, "", 1)
+					}
+					paired := row.name == "numeric-base" || row.name == "no-future-pointer"
+					if paired {
+						x86RequireNumericNativeSourceContext(t, source, "var external [8]byte\nfunc view(p *byte) uintptr\n", arch)
+						x86LEAActualTargetGoObject(t, arch, triple, source)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "var external [8]byte\nfunc view(p *byte) uintptr\n", arch, triple, api)
+						if paired {
+							width, count := 4, 1
+							if strings.HasSuffix(op, "D") {
+								width = 8
+							}
+							if row.name == "no-future-pointer" {
+								count = 2
+							}
+							if err != nil || strings.Count(ir, fmt.Sprintf("elementtype([%d x i8])", width)) != count ||
+								!strings.Contains(ir, strings.ToLower(op)+" ") || !strings.Contains(ir, "~{fpsr}") ||
+								row.name == "no-future-pointer" && !strings.Contains(ir, "load volatile i32,") {
+								t.Fatal("independently paired COMI reads lost width, opcode or FP effects", api, err)
+							}
+							x86NumericNativeAddressObject(t, ir, triple)
+							continue
+						}
+						if arch == "amd64" && row.name == "vector-input" {
+							x86VectorScratchCodegenControl(t, source, "var external [8]byte\nfunc view(p *byte) uintptr\n", arch, triple, ir, err)
+							continue
+						}
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("native comparison supplied missing input or storage authority", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86COMINativeStatusDoesNotInventDFOrID(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86COMIOracleNames() {
+			source := x86COMINativeInputSource(target.arch, "view", op, "", "-7(DX)(CX*4)", "")
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *byte) uintptr\n", target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("native status query invented full FLAGS including unknown DF/ID", target, op, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86COMINativeReadPreservesUnrelatedState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86COMIOracleNames() {
+			for missing := -1; missing < 64; missing++ {
+				ins := x86ScalarLaneInstruction(t, op+" -7(DX)(CX*4),X1")
+				state := x86ResultState{direction: x86ResultDirectionBackward,
+					valueStack: &x86ResultValueStack{bytes: []uint8{1, 2}, id: true}}
+				state.gp[1], state.pointerGP[2], state.masks[7] = 0xff, true, true
+				state.callerAddressGP[2], state.flags = true, x86ByteFlagCF
+				bytes := ^uint64(0)
+				if missing >= 0 {
+					bytes &^= 1 << uint(missing)
+				}
+				state.writeVector(1, 64, bytes, false)
+				before := state.clone()
+				if accepted, known := x86ResultCOMIStep(ins, &state, nil, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone observer borrowed a conditional native read", arch, op, missing)
+				}
+				width := 4
+				if strings.HasSuffix(op, "D") {
+					width = 8
+				}
+				want := missing < 0 || missing >= width
+				accepted, known := x86ResultCOMIStepWithRead(ins, &state, nil, arch, true)
+				if want {
+					before.flags = x86ByteFlagsAll
+				}
+				if !known || accepted != want || !reflect.DeepEqual(state, before) {
+					t.Fatal("native continuation changed unrelated state or ignored a missing scalar byte", arch, op, missing)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_comi_review_test.go b/amd64_comi_review_test.go
new file mode 100644
index 000000000..e53b0ab1f
--- /dev/null
+++ b/amd64_comi_review_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86COMIModeContextCannotHideMalformedSource(t *testing.T) {
+	for _, name := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, body := range []string{
+			name + " X8,Y1\n",
+			name + " slot+0(FP)(AX*1),Y1\n",
+			name + " X8,X1\nRET\n" + name + " X0,Y1\n",
+			name + " X8,X1\nRET\nTEXT ·later(SB),4,$0-0\n" + name + " X0,Y1\n",
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(name+"/"+api+"/"+body, func(t *testing.T) {
+					_, err := x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-0\n"+body+"RET\n",
+						"func view()\nfunc later()\n", "386", "i386-unknown-linux-gnu", api)
+					if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("mode32 context hid malformed original source: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86COMIDirectLowererRequiresNativeTarget(t *testing.T) {
+	for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "i386-unknown-linux-gnu"} {
+		var output strings.Builder
+		ctx := amd64Ctx{b: &output, goarch: "amd64", targetTriple: triple}
+		instruction := x86ScalarLaneInstruction(t, "COMISS X0,X1")
+		known, terminated, err := ctx.lowerVectorScalarFlagCompare(instruction.Op, instruction)
+		if !known || terminated || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+			t.Fatal("direct helper emitted without native target", triple, known, terminated, err, output.String())
+		}
+	}
+}
+
+func TestX86COMIRawVEXLengthIsNotPortableIgnoredBit(t *testing.T) {
+	for _, name := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+name+" X0,X1\nRET\n")
+		if len(code) != 5 || code[0] != 0xc5 || code[1]&4 != 0 {
+			t.Fatalf("actual Go must retain its VEX.L0 encoding: %s %x", name, code)
+		}
+		code[1] |= 4
+		for _, mode := range []int{32, 64} {
+			if _, _, matched, err := decodedX86ScalarFlagCompareInstruction(code[:4], mode); !matched || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("raw VEX.L1 normalized to L0 without physical contract: %s mode%d %x %v", name, mode, code, err)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT ·view(SB),4,$0-0\n")
+			for _, value := range code[:4] {
+				fmt.Fprintf(&source, "BYTE $%#x\n", value)
+			}
+			source.WriteString("RET\n")
+			arch, triple := "amd64", "x86_64-unknown-linux-gnu"
+			if mode == 32 {
+				arch, triple = "386", "i386-unknown-linux-gnu"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source.String(), "func view()\n", arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw L1 lost context through public API", name, arch, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86COMIRawEVEXGenerationSurvivesLowRegisters(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·view(SB),4,$0-0\n")
+	for _, opcode := range []int{0x2e, 0x2f} {
+		for _, double := range []bool{false, true} {
+			code := []byte{0x62, 0xf1, 0x7c, 0x08, byte(opcode), 0xc8}
+			if double {
+				code[2] |= 0x81
+			}
+			for _, value := range code {
+				fmt.Fprintf(&source, "BYTE $%#x\n", value)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range x86RawReturnTargets {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				if ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func view()\n", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original low-bank EVEX format invented its X inputs", err)
+				}
+				ir := x86COMIOriginalFormatObject(t, source.String(), target.arch, target.triple)
+				if strings.Count(ir, "{evex} v") != 4 || !strings.Contains(ir, "+avx512f") {
+					t.Fatal("low-register raw EVEX private format lost generation/feature", ir)
+				}
+				x86COMICompileOriginalFormatObjects(t, llc, target.triple, "raw-evex-comi", ir)
+			})
+		}
+	}
+}
diff --git a/amd64_comi_runtime_linux_amd64_test.go b/amd64_comi_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..952da9004
--- /dev/null
+++ b/amd64_comi_runtime_linux_amd64_test.go
@@ -0,0 +1,16 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlags(t *testing.T) {
+	t.Run("VEX", func(t *testing.T) {
+		x86ScalarCompareAFOriginalGo(t, x86FloatCompareVEX)
+		x86ScalarCompareAFLLVM(t, x86FloatCompareVEX)
+	})
+}
+
+func TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSR(t *testing.T) {
+	t.Run("VEX", func(t *testing.T) {
+		x86COMIOriginalConstantsAndMXCSR(t, x86FloatCompareVEX)
+	})
+}
diff --git a/amd64_comi_runtime_owner_test.go b/amd64_comi_runtime_owner_test.go
new file mode 100644
index 000000000..f44ff7ffa
--- /dev/null
+++ b/amd64_comi_runtime_owner_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func TestX86COMIRequiredNativeRuntimeOwners(t *testing.T) {
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	selector, err := x86FloatCompareLinuxCISelector(string(workflow))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, source := range []struct {
+		path   string
+		tagged bool
+		owners map[string]struct {
+			calls map[string]string
+			axis  string
+		}
+	}{
+		{"amd64_comi_runtime_linux_amd64_test.go", false, map[string]struct {
+			calls map[string]string
+			axis  string
+		}{
+			"TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlags": {map[string]string{
+				"x86ScalarCompareAFOriginalGo": "x86FloatCompareVEX", "x86ScalarCompareAFLLVM": "x86FloatCompareVEX",
+			}, "VEX"},
+			"TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSR": {map[string]string{
+				"x86COMIOriginalConstantsAndMXCSR": "x86FloatCompareVEX",
+			}, "VEX"},
+		}},
+		{"amd64_comi_native_avx512_linux_amd64_test.go", true, map[string]struct {
+			calls map[string]string
+			axis  string
+		}{
+			"TestCrossLinuxRuntimeMatrixX86COMIRawNativeCompare":     {map[string]string{"x86COMIRawNativeCompare": ""}, ""},
+			"TestCrossLinuxRuntimeMatrixX86COMINativeDeadExceptions": {map[string]string{"x86COMIDeadFaults": "true"}, ""},
+			"TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlagsEVEX": {map[string]string{
+				"x86ScalarCompareAFOriginalGo": "x86FloatCompareEVEX", "x86ScalarCompareAFLLVM": "x86FloatCompareEVEX",
+			}, "EVEX"},
+			"TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSREVEX": {map[string]string{
+				"x86COMIOriginalConstantsAndMXCSR": "x86FloatCompareEVEX",
+			}, "EVEX"},
+		}},
+	} {
+		for _, target := range []struct{ os, arch string }{
+			{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm64"},
+			{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+		} {
+			for _, qualified := range []bool{false, true} {
+				ctx := build.Default
+				ctx.GOOS, ctx.GOARCH = target.os, target.arch
+				ctx.BuildTags = nil
+				if qualified {
+					ctx.BuildTags = []string{"plan9asm_native_avx512"}
+				}
+				matched, err := ctx.MatchFile(".", source.path)
+				want := target.os == "linux" && target.arch == "amd64" && (!source.tagged || qualified)
+				if err != nil || matched != want {
+					t.Fatal("COMI ISA ownership changed", source.path, target, qualified, matched, err)
+				}
+			}
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), source.path, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, declaration := range file.Decls {
+			fn, ok := declaration.(*ast.FuncDecl)
+			if !ok {
+				continue
+			}
+			expected, known := source.owners[fn.Name.Name]
+			if !known || !selector.MatchString(fn.Name.Name) {
+				t.Fatal("unexpected or unselected native owner", fn.Name.Name)
+			}
+			delete(source.owners, fn.Name.Name)
+			actual, runs := make(map[string]string), 0
+			ast.Inspect(fn.Body, func(node ast.Node) bool {
+				switch node := node.(type) {
+				case *ast.IfStmt, *ast.ReturnStmt, *ast.ForStmt, *ast.RangeStmt, *ast.BranchStmt:
+					t.Fatal("native owner cannot conditionally skip or truncate its fixture", fn.Name.Name)
+				case *ast.CallExpr:
+					if method, ok := node.Fun.(*ast.SelectorExpr); ok {
+						receiver, owned := method.X.(*ast.Ident)
+						if !owned || receiver.Name != "t" || method.Sel.Name != "Run" || len(node.Args) != 2 {
+							t.Fatal("native owner cannot replace execution with skip/log helpers", fn.Name.Name)
+						}
+						literal, ok := node.Args[0].(*ast.BasicLit)
+						if !ok {
+							t.Fatal("native ISA child must be explicit", fn.Name.Name)
+						}
+						axis, err := strconv.Unquote(literal.Value)
+						if err != nil || axis != expected.axis {
+							t.Fatal("native ISA child changed", fn.Name.Name, axis, err)
+						}
+						runs++
+						return true
+					}
+					callee, ok := node.Fun.(*ast.Ident)
+					if !ok {
+						return true
+					}
+					argument, known := expected.calls[callee.Name]
+					if !known || len(node.Args) != 1 && len(node.Args) != 2 {
+						t.Fatal("unknown native fixture call", callee.Name)
+					}
+					owner, ok := node.Args[0].(*ast.Ident)
+					if !ok || owner.Name != "t" {
+						t.Fatal("native fixture lost its test owner")
+					}
+					got := ""
+					if len(node.Args) == 2 {
+						value, ok := node.Args[1].(*ast.Ident)
+						if !ok {
+							t.Fatal("native fixture lost explicit native/ISA argument")
+						}
+						got = value.Name
+					}
+					if _, duplicate := actual[callee.Name]; duplicate || got != argument {
+						t.Fatal("duplicated or weakened native fixture", callee.Name, got)
+					}
+					actual[callee.Name] = got
+				}
+				return true
+			})
+			if !reflect.DeepEqual(actual, expected.calls) || (runs == 1) != (expected.axis != "") || runs > 1 {
+				t.Fatal("incomplete native fixture dispatch", fn.Name.Name, actual, runs)
+			}
+		}
+		if len(source.owners) != 0 {
+			t.Fatal("native COMI execution owners missing", source.owners)
+		}
+	}
+}
diff --git a/amd64_comi_status_runtime_test.go b/amd64_comi_status_runtime_test.go
new file mode 100644
index 000000000..e94f633bf
--- /dev/null
+++ b/amd64_comi_status_runtime_test.go
@@ -0,0 +1,145 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86COMIConstantOracle(axis x86FloatCompareRuntimeISA) (assembly, declarations, original, driver string, functions int) {
+	var asm, decl, goCalls, cDecl, cCalls strings.Builder
+	index := 0
+	for _, name := range []string{"COMISS", "UCOMISS", "COMISD", "UCOMISD"} {
+		if axis != x86FloatCompareSSE {
+			name = "V" + name
+		}
+		values, one := []uint64{0x7fc12345, 0x7f812345, 1}, uint64(0x3f800000)
+		if strings.HasSuffix(name, "D") {
+			values, one = []uint64{0x7ff8123456789abc, 0x7ff0123456789abc, 1}, 0x3ff0000000000000
+		}
+		forms := []struct{ suffix, source, destination string }{{"", "X0", "X1"}}
+		if axis == x86FloatCompareEVEX {
+			forms = []struct{ suffix, source, destination string }{
+				{"", "X16", "X17"}, {"", "X30", "X31"},
+				{".SAE", "X0", "X1"}, {".SAE", "X16", "X17"},
+			}
+		}
+		for _, form := range forms {
+			for _, bits := range values {
+				for _, dead := range []bool{false, true} {
+					function := fmt.Sprintf("comi%d", index)
+					fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-12\nSTMXCSR saved-4(SP)\nMOVQ out+0(FP),DI\n", function)
+					fmt.Fprintf(&asm, "MOVQ $%#x,AX\nMOVQ AX,X0\nMOVQ $%#x,AX\nMOVQ AX,X1\n", bits, one)
+					if form.source != "X0" {
+						fmt.Fprintf(&asm, "VMOVAPS X0,%s\nVMOVAPS X1,%s\n", form.source, form.destination)
+					}
+					fmt.Fprintf(&asm, "LDMXCSR csr+8(FP)\n%s%s %s,%s\n", name, form.suffix, form.source, form.destination)
+					if dead {
+						asm.WriteString("MOVQ $0x77,BX\n")
+					} else {
+						asm.WriteString("PUSHFQ\nPOPQ BX\nANDQ $0x8d5,BX\n")
+					}
+					asm.WriteString("MOVQ BX,(DI)\nSTMXCSR 8(DI)\nLDMXCSR saved-4(SP)\nRET\n")
+					fmt.Fprintf(&decl, "func %s(out *[4]uint64, csr uint32)\n", function)
+					fmt.Fprintf(&goCalls, "check(%d,%s)\n", index, function)
+					fmt.Fprintf(&cDecl, "extern void %s(uint64_t*,uint32_t);\n", function)
+					fmt.Fprintf(&cCalls, "check(%d,%s);\n", index, function)
+					index++
+				}
+			}
+		}
+	}
+	original = `package main
+import "fmt"
+func check(index int, fn func(*[4]uint64,uint32)) {
+    for mode:=0; mode<8; mode++ {
+        out:=[4]uint64{0x1111111111111111,0x2222222222222222,0x3333333333333333,0x4444444444444444}
+        csr:=uint32(0x1f80)|uint32(mode&1)<<6|uint32(mode>>1&1)<<15|uint32(mode>>2)<<5
+        fn(&out,csr)
+        fmt.Printf("%d %d %016x %016x %016x %016x\n",index,mode,out[0],out[1],out[2],out[3])
+    }
+}
+` + decl.String() + "func main(){\n" + goCalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static void check(int index,void (*fn)(uint64_t*,uint32_t)) {
+    for(unsigned mode=0; mode<8; mode++) {
+        uint64_t out[]={UINT64_C(0x1111111111111111),UINT64_C(0x2222222222222222),UINT64_C(0x3333333333333333),UINT64_C(0x4444444444444444)};
+        uint32_t csr=0x1f80|((mode&1)<<6)|((mode>>1&1)<<15)|((mode>>2)<<5);
+        fn(out,csr);
+        printf("%d %u %016llx %016llx %016llx %016llx\n",index,mode,(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2],(unsigned long long)out[3]);
+    }
+}
+` + cDecl.String() + "int main(void){\n" + cCalls.String() + "return 0;}\n"
+	return asm.String(), decl.String(), original, driver, index
+}
+
+func TestCrossLinuxRuntimeMatrixX86COMIOriginalConstantsAndMXCSR(t *testing.T) {
+	x86COMIOriginalConstantsAndMXCSR(t, x86FloatCompareSSE)
+}
+
+func TestX86COMICompleteStatusOriginalInventory(t *testing.T) {
+	for _, axis := range []x86FloatCompareRuntimeISA{x86FloatCompareSSE, x86FloatCompareVEX, x86FloatCompareEVEX} {
+		assembly, _, _, _, functions := x86COMIConstantOracle(axis)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		want := 24
+		if axis == x86FloatCompareEVEX {
+			want = 96
+		}
+		if functions != want {
+			t.Fatal("changed constant status denominator", axis, functions)
+		}
+	}
+}
+
+func x86COMIOriginalConstantsAndMXCSR(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	assembly, declarations, main, driver, count := x86COMIConstantOracle(axis)
+	original := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, main)
+	want := strings.Split(strings.TrimSpace(string(original)), "\n")
+	expected := 24
+	if axis == x86FloatCompareEVEX {
+		expected = 96
+	}
+	if count != expected || len(want) != expected*8 {
+		t.Fatalf("original Go produced %d functions/%d rows, want %d functions x 8 MXCSR controls", count, len(want), expected)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				for _, backend := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%v/backend%s", optimized, backend), func(t *testing.T) {
+						output := execution.compileAndRunLLVM(t, "comi-status", input, driver, backend)
+						got := strings.Split(strings.TrimSpace(string(output)), "\n")
+						if len(got) != len(want) {
+							t.Fatalf("LLVM rows=%d original=%d", len(got), len(want))
+						}
+						mismatches := 0
+						for index := range want {
+							if got[index] != want[index] {
+								if mismatches == 0 {
+									t.Logf("first mismatch: original %s; LLVM %s", want[index], got[index])
+								}
+								mismatches++
+							}
+						}
+						if mismatches != 0 {
+							t.Errorf("original Go FLAGS/MXCSR/canary mismatches=%d/%d", mismatches, len(want))
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_compact_native_memory.go b/amd64_compact_native_memory.go
new file mode 100644
index 000000000..89c4039ee
--- /dev/null
+++ b/amd64_compact_native_memory.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import "fmt"
+
+// Native compact arrays advance only for enabled lanes. Ordinary masked LLVM
+// intrinsics may discard a dead read; guarded volatile accesses retain the
+// source instruction's enabled access/fault, even when its vector is unused.
+// No inbounds, alignment, extent or allocation assumption follows from a GEP.
+func (c *amd64Ctx) lowerNativeCompactMemory(ins Instr, form x86PackedCompactForm) error {
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return fmt.Errorf("%w: compact memory needs its original native address size", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(ins.Args[form.memory])
+	if err != nil {
+		return err
+	}
+	width, bits := form.byteWidth, form.laneBits
+	if form.mask < 0 {
+		if form.expand {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, %s %s, align 1\n", value, width, pointerType, pointer)
+			return c.storePackedMoveOperand(ins.Args[form.destination], width, "%"+value)
+		}
+		value, err := c.loadPackedCompareBytes(ins.Args[0], width)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile <%d x i8> %s, %s %s, align 1\n", width, value, pointerType, pointer)
+		return nil
+	}
+	mask, err := c.loadK(ins.Args[form.mask].Reg)
+	if err != nil {
+		return err
+	}
+	lanes := width * 8 / bits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, bits)
+	value := "zeroinitializer"
+	if !form.expand || !form.zeroing {
+		operand := ins.Args[0]
+		if form.expand {
+			operand = ins.Args[form.destination]
+		}
+		value, err = c.loadPackedCompareLanes(operand, width, bits, false)
+		if err != nil {
+			return err
+		}
+	}
+	offset := "0"
+	for lane := 0; lane < lanes; lane++ {
+		active := amd64MaskBitI1(c, mask, lane)
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %s\n", address, pointerType, pointer, offset)
+		if form.expand {
+			loaded, err := c.loadX86ScalarIf(bits, active, func() (string, error) {
+				loaded := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %%%s, align 1\n", loaded, bits, pointerType, address)
+				return "%" + loaded, nil
+			})
+			if err != nil {
+				return err
+			}
+			if !form.zeroing {
+				old, selected := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", old, vectorType, value, lane)
+				fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %s, i%d %%%s\n", selected, active, bits, loaded, bits, old)
+				loaded = "%" + selected
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, value, bits, loaded, lane)
+			value = "%" + inserted
+		} else {
+			element := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", element, vectorType, value, lane)
+			storeLabel, joinLabel := c.newTmp()+"_compact_store", c.newTmp()+"_compact_join"
+			fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n%s:\n", active, storeLabel, joinLabel, storeLabel)
+			fmt.Fprintf(c.b, "  store volatile i%d %%%s, %s %%%s, align 1\n", bits, element, pointerType, address)
+			fmt.Fprintf(c.b, "  br label %%%s\n%s:\n", joinLabel, joinLabel)
+		}
+		step, next := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %d, i64 0\n", step, active, bits/8)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", next, offset, step)
+		offset = "%" + next
+	}
+	if form.expand {
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, vectorType, value, width)
+		return c.storePackedMoveOperand(ins.Args[form.destination], width, "%"+bytes)
+	}
+	return nil
+}
diff --git a/amd64_conditional_set_effects_test.go b/amd64_conditional_set_effects_test.go
new file mode 100644
index 000000000..37a55626e
--- /dev/null
+++ b/amd64_conditional_set_effects_test.go
@@ -0,0 +1,271 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86ConditionalSetTestNames = strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS")
+
+func TestX86ConditionalSetActualGoTableAndOrderedForms(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A(SET[A-Z]+), yscond, Pb, opBytes\{0x0f, (0x[0-9a-f]+), 00\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 16 || !strings.Contains(string(data), "var yscond = []ytab{\n\t{Zo_m, 2, argList{Ymb}},\n}") {
+		t.Fatalf("actual SDK SETcc row/class inventory changed: %d", len(rows))
+	}
+	for _, row := range rows {
+		if _, registered := x86ConditionalSetConditions[Op(row[1])]; !registered {
+			t.Fatalf("actual Go row has no shared conditional byte form: %v", row)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		registers := "AX BX CX DX AH AL BH BL CH CL DH DL BP SI DI"
+		if arch == "amd64" {
+			registers += " SP BPB SIB DIB R8 R9 R10 R11 R12 R13 R14 R15 R8B R9B R10B R11B R12B R13B R14B R15B"
+		}
+		var source strings.Builder
+		source.WriteString("TEXT ·Value(SB),4,$0-1\n")
+		for _, op := range x86ConditionalSetTestNames {
+			for _, destination := range append(strings.Fields(registers), "(AX)", "7(AX)(CX*4)", "state(SB)", "ret0+0(FP)") {
+				line := op + " " + destination
+				file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-1\n"+line+"\nRET")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				before := fmt.Sprintf("%#v", ins)
+				if _, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); !recognized || err != nil {
+					t.Fatalf("%s %s shared row: %v", arch, line, err)
+				}
+				if !x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+					t.Fatalf("valid lowerer row is missing source-stack registration: %s", line)
+				}
+				if isAMD64MemoryOperand(ins.Args[0]) {
+					width, write, known := x86InstructionMemoryShape(ins, 0, arch)
+					if width != 1 || !write || !known || x86ScalarMoveMemoryBytes(ins, 0, arch) != 1 {
+						t.Fatalf("conditional byte memory shape: %s %d/%t/%t", line, width, write, known)
+					}
+					if ins.Args[0].Kind == OpFP {
+						if width, write, known := X86FPAccessBytes(ins, 0, arch); width != 1 || !write || !known {
+							t.Fatal("FP observation disagrees with the ordered form")
+						}
+					}
+				}
+				if fmt.Sprintf("%#v", ins) != before {
+					t.Fatal("typed form changed source identity")
+				}
+				source.WriteString(line + "\n")
+			}
+		}
+		source.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+	}
+}
+
+func TestX86ConditionalSetRejectsMalformedAndConflictingIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{"SETNE", "SETNE $1", "SETNE X0", "SETNE M0", "SETNE K1", "SETNE AX,BX", "SETNE.Z AX", "SETNE (AX)(SP*1)"} {
+			source := "TEXT ·Value(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				continue
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); !recognized || err == nil {
+				t.Fatalf("malformed source obtained a conditional byte effect: %s/%s", arch, row)
+			}
+		}
+	}
+	for _, identity := range []Op{"", "SETNE", "setne", "SETEQ", "SETNE.BAD"} {
+		var output strings.Builder
+		ctx := amd64Ctx{b: &output, goarch: "amd64"}
+		ins := Instr{Op: identity, Args: []Operand{{Kind: OpReg, Reg: AX}}}
+		// Success is tested at the grammar seam without relying on default
+		// LLVM flags. Contradictions must fail before even loading flags.
+		_, recognized, err := x86ConditionalSetProperties("SETNE", ins, "amd64")
+		valid := identity == "" || strings.EqualFold(string(identity), "SETNE")
+		if !recognized || (err == nil) != valid {
+			t.Fatalf("dispatch identity %q: %v", identity, err)
+		}
+		if !valid {
+			if _, _, err := ctx.lowerConditionalSet("SETNE", ins); err == nil || output.Len() != 0 {
+				t.Fatal("contradictory dispatch emitted IR")
+			}
+		}
+	}
+}
+
+func TestX86ConditionalSetCallerConsumesOnlyDefinedFlagsAndExactByte(t *testing.T) {
+	for _, op := range x86ConditionalSetTestNames {
+		for _, destination := range []string{"AX", "AH", "(DX)"} {
+			body := "CMPL AX,$0\n" + op + " " + destination
+			if destination != "(DX)" {
+				body += "\nMOVB " + destination + ",(DX)"
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			source := strings.NewReplacer("var res float32", "var res uint8", ") float32 {", ") uint8 {").Replace(x86CallerFixtureSource)
+			pkg, _ := x86CallerCoreFixture(t, source, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatalf("%s byte admission: %v", body, err)
+			}
+		}
+	}
+	for name, body := range map[string]string{
+		"unknown flags":   "SETNE AX\nMOVB AX,(DX)",
+		"pointer flags":   "CMPQ DX,$0\nSETNE AX\nMOVB AX,(DX)",
+		"partial pointer": "CMPL AX,$0\nSETNE DX\nMOVB AX,(DX)",
+		"input write":     "CMPL AX,$0\nSETNE (DI)",
+		"unknown address": "CMPL AX,$0\nSETNE (BX)",
+		"wide result":     "CMPL AX,$0\nSETNE 4(DX)",
+		"undefined upper": "CMPL AX,$0\nSETNE BX\nMOVL BX,(DX)",
+		"join flags":      "CMPL AX,$0\nJE other\nADDQ $0,DX\nother:\nSETNE AX\nMOVB AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved flags/byte/address acquired continuation: %v", err)
+			}
+		})
+	}
+	// A private-region pointer is never washed into a number by an eight-bit
+	// output. The exact AH bit mask preserves unrelated known bytes.
+	state := x86SourceStackState{numericFlags: true, known: map[Reg]uint8{AX: 1}, callers: map[Reg]x86CallerPointerValue{DX: {argument: 0}}}
+	ins := Instr{Op: "SETNE", Args: []Operand{{Kind: OpReg, Reg: AH}}}
+	if _, valid := x86CallerConditionalSetStep(&ins, &state, nil); !valid || state.known[AX] != 3 || !state.numericFlags {
+		t.Fatal("SETcc does not preserve exact byte knowledge and flags")
+	}
+	ins.Args[0].Reg = DX
+	if _, valid := x86CallerConditionalSetStep(&ins, &state, nil); valid || len(state.callers) != 1 {
+		t.Fatal("SETcc washed surviving pointer bytes")
+	}
+}
+
+func TestX86ConditionalSetThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var body strings.Builder
+			fmt.Fprintf(&body, "%s x+0(FP),SI\nMOVL $7,AX\nCMPL AX,$3\n", move)
+			for _, op := range x86ConditionalSetTestNames {
+				fmt.Fprintf(&body, "%s AX\n%s AH\n%s (SI)\n%s ret0+%d(FP)\n", op, op, op, op, word)
+			}
+			body.WriteString("RET")
+			pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x *uint8) uint8", body.String())
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig}, ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") }}
+			text, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, text, "text")
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+		})
+	}
+}
+
+func TestX86ABI0OccupiedPointerAndSetRetainUnavailableInputs(t *testing.T) {
+	for name, body := range map[string]string{
+		"pointer bytes":         "MOVQ x+0(FP),AX\nMOVL AX,ret0+24(FP)\nRET",
+		"partial pointer bytes": "MOVB x+0(FP),AX\nMOVL AX,ret0+24(FP)\nRET",
+		"pointer dereference":   "MOVQ x+0(FP),AX\nMOVL (AX),BX\nMOVL BX,ret0+24(FP)\nRET",
+		"unknown flags":         "SETNE AX\nMOVB AX,ret0+24(FP)\nRET",
+		"unknown upper":         "MOVL $1,BX\nCMPL BX,$0\nSETNE AX\nMOVL AX,ret0+24(FP)\nRET",
+		"missing result bytes":  "MOVL $1,AX\nCMPL AX,$0\nSETNE ret0+24(FP)\nRET",
+		"flags join":            "MOVL $1,AX\nCMPL AX,$0\nJE other\nSETNE ret0+24(FP)\nother:\nRET",
+		"call":                  "MOVL $1,ret0+24(FP)\nCALL ·other(SB)\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x []uint32) uint32", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			before := fmt.Sprintf("%#v %#v", file, sig)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("occupied pointer or byte output manufactured input/result: %v", err)
+			}
+			if !reflect.DeepEqual(before, fmt.Sprintf("%#v %#v", file, sig)) {
+				t.Fatal("observer mutated source/layout")
+			}
+		})
+	}
+	// Result initialization observes reachable execution, not unused source
+	// bytes. A complete result followed by an unconditional jump does not read
+	// the dead pointer input. Transporting an unused opaque pointer is also
+	// legal; consuming its bytes as a numeric result must still fail.
+	const dead = "MOVL $1,ret0+24(FP)\nJMP end\nMOVQ x+0(FP),AX\nend:\nRET"
+	for _, fixture := range []struct {
+		name, body string
+		context    bool
+	}{
+		{"dead pointer bytes", dead, false},
+		{"reachable opaque pointer unused", strings.Replace(dead, "JMP end", "JMP input\ninput:", 1), false},
+		{"reachable pointer result", strings.Replace(strings.Replace(dead, "JMP end", "JMP input\ninput:", 1),
+			"MOVQ x+0(FP),AX", "MOVQ x+0(FP),AX\nMOVL AX,ret0+24(FP)", 1), true},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x []uint32) uint32", fixture.body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			before := fmt.Sprintf("%#v %#v", file, sig)
+			err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+			if fixture.context && !errors.Is(err, ErrProbeNeedsContext) || !fixture.context && err != nil {
+				t.Fatalf("reachable result/input boundary changed: %v", err)
+			}
+			if before != fmt.Sprintf("%#v %#v", file, sig) {
+				t.Fatal("result observer changed source or manufactured pointer layout")
+			}
+		})
+	}
+	// A derived pointer layout still cannot become a pointer result contract.
+	pkg := mustGoPackage(t, "example.invalid/pointer", "package pointer\nfunc Value(x *uint32) *uint32\n")
+	sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-16\nMOVQ x+0(FP),AX\nMOVQ AX,ret0+8(FP)\nRET")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("pointer result gained numeric result authority")
+	}
+}
diff --git a/amd64_conditional_set_forms.go b/amd64_conditional_set_forms.go
new file mode 100644
index 000000000..1cff89b8b
--- /dev/null
+++ b/amd64_conditional_set_forms.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Both reviewed Go encoders use yscond: one Ymb destination, one byte
+// written, no input data operand and no flags output. This grammar establishes
+// neither initialized flags nor any authority for the destination address.
+var x86ConditionalSetConditions = map[Op]string{
+	"SETCC": "CC", "SETCS": "CS", "SETEQ": "EQ", "SETGE": "GE",
+	"SETGT": "GT", "SETHI": "HI", "SETLE": "LE", "SETLS": "LS",
+	"SETLT": "LT", "SETMI": "MI", "SETNE": "NE", "SETOC": "OC",
+	"SETOS": "OS", "SETPC": "PC", "SETPL": "PL", "SETPS": "PS",
+}
+
+type x86ConditionalSetForm struct {
+	condition   string
+	destination Operand
+}
+
+func x86ConditionalSetProperties(op Op, ins Instr, arch string) (x86ConditionalSetForm, bool, error) {
+	var form x86ConditionalSetForm
+	name := strings.ToUpper(string(op))
+	base := strings.SplitN(name, ".", 2)[0]
+	condition, recognized := x86ConditionalSetConditions[Op(base)]
+	if !recognized {
+		return form, false, nil
+	}
+	fail := func(reason string) (x86ConditionalSetForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || name != base ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail("has an unbound mode, suffix or dispatch identity")
+	}
+	if len(ins.Args) != 1 {
+		return fail("expects one Ymb destination")
+	}
+	dst := ins.Args[0]
+	if dst.Kind == OpReg {
+		if !isGoYmbRegisterForArch(dst.Reg, arch) {
+			return fail("register is outside the Go Ymb class")
+		}
+	} else if !isAMD64MemoryOperand(dst) {
+		return fail("expects a Ymb register or memory destination")
+	}
+	if dst.Kind == OpMem {
+		memory := dst.Mem
+		if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+			return form, true, err
+		}
+		if arch == "386" && strings.HasSuffix(memory.Sym, "(SB)") {
+			memory.Base = "" // The named-memory encoder discards this annotation.
+		}
+		if !x86MemoryRegistersValidForArch(memory, arch) || memory.Index == SP ||
+			memory.Index != "" && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 ||
+			memory.Off != int64(int32(memory.Off)) && !(arch == "386" && memory.Off == int64(uint32(memory.Off))) {
+			return fail("has an unencodable memory address")
+		}
+	}
+	form.condition, form.destination = condition, dst
+	return form, true, nil
+}
+
+func x86CallerConditionalSetStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) (bool, bool) {
+	form, recognized, err := x86ConditionalSetProperties(ins.Op, *ins, "amd64")
+	if !recognized || err != nil || !x86SourceStackNumericFlagsRead(state, x86ByteConditionFlags(form.condition)) {
+		return recognized, false
+	}
+	if form.destination.Kind == OpReg {
+		return true, x86CallerNumericWrite(form.destination.Reg, 1, state)
+	}
+	return true, x86CallerOrdinaryMemoryStep(ins, 0, state, proof, 1, true)
+}
+
+// Only the paired lowering may continue an actual volatile native-byte store.
+// FLAGS and incoming address identity must already exist; no logical memory,
+// canonical result, caller envelope or pointer bound is produced here.
+func x86LoweredNativeConditionalSet(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.destination.Kind != OpMem || !x86OrdinaryNativeMemoryOperand(form.destination, arch) {
+		return false, false
+	}
+	required := x86ByteConditionFlags(form.condition)
+	return x86ResultNamedPredicateInstruction(ins) && ins.x86NumericalRead == nil &&
+		required != 0 && state.flags&required == required &&
+		x86ResultIncomingPointerAddressIdentity(form.destination, state, arch), true
+}
diff --git a/amd64_conditional_set_runtime_test.go b/amd64_conditional_set_runtime_test.go
new file mode 100644
index 000000000..3a9c4ce6e
--- /dev/null
+++ b/amd64_conditional_set_runtime_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This independent boolean reference uses architectural flags, not the
+// translator's condition builder or the form map's condition strings.
+const x86ConditionalSetIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static unsigned truth(unsigned condition,uint64_t flags) {
+ unsigned c=flags&1,p=flags>>2&1,z=flags>>6&1,s=flags>>7&1,o=flags>>11&1;
+ switch(condition) {
+ case 0:return !c;case 1:return c;case 2:return z;case 3:return s==o;
+ case 4:return !z&&s==o;case 5:return !c&&!z;case 6:return z||s!=o;
+ case 7:return c||z;case 8:return s!=o;case 9:return s;case 10:return !z;
+ case 11:return !o;case 12:return o;case 13:return !p;case 14:return !s;case 15:return p;
+ } return 2;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86ConditionalSetAllFlagsAliasesAndCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, tests, c strings.Builder
+	declarations.WriteString("package conditional\n")
+	tests.WriteString(`package conditional
+import("testing";"encoding/binary")
+func TestOriginal(t *testing.T) {
+ for sample:=0;sample<64;sample++ {
+  flags:=uint64(2)
+  for bit,index:=range []uint{0,2,4,6,7,11} {if sample&(1<<bit)!=0 {flags|=1<<index}}
+`)
+	c.WriteString(x86ConditionalSetIndependentC)
+	c.WriteString("typedef void (*kernel)(uint8_t *,uint64_t);\n")
+	var names []string
+	for condition, op := range x86ConditionalSetTestNames {
+		for destination, target := range []string{"AX", "AH", "BX", "BH", "(DI)", "1(DI)"} {
+			name := fmt.Sprintf("conditional%d", len(names))
+			names = append(names, name)
+			fmt.Fprintf(&declarations, "func %s(out *[32]byte,flags uint64)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\nMOVQ out+0(FP),DI\nMOVQ $0x1122334455667788,AX\nMOVQ $0x8877665544332211,BX\nMOVQ flags+8(FP),CX\nPUSHQ CX\nPOPFQ\n%s %s\nMOVQ AX,8(DI)\nMOVQ BX,16(DI)\nPUSHFQ\nPOPQ CX\nMOVQ CX,24(DI)\nRET\n", name, op, target)
+			fmt.Fprintf(&c, "extern void %s(uint8_t *,uint64_t);\n", name)
+			fmt.Fprintf(&tests, `{
+ var out,want [32]byte
+ for i:=range out {out[i]=0xc3;want[i]=0xc3}
+ binary.LittleEndian.PutUint64(want[8:],0x1122334455667788)
+ binary.LittleEndian.PutUint64(want[16:],0x8877665544332211)
+ c,p,z,s,o:=flags&1!=0,flags&4!=0,flags&64!=0,flags&128!=0,flags&2048!=0
+ values:=[]bool{!c,c,z,s==o,!z&&s==o,!c&&!z,z||s!=o,c||z,s!=o,s,!z,!o,o,!p,!s,p}
+ value:=byte(0);if values[%d] {value=1}
+ offsets:=[]int{8,9,16,17,0,1};want[offsets[%d]]=value
+ %s(&out,flags)
+ observed:=binary.LittleEndian.Uint64(out[24:]);binary.LittleEndian.PutUint64(want[24:],observed)
+ if out!=want || observed&0x8d5!=flags&0x8d5 {t.Fatalf("%s sample%%d got%%x want%%x flags%%x",sample,out,want,observed)}
+}
+`, condition, destination, name, name)
+		}
+	}
+	tests.WriteString("}\n}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module conditional\n\ngo 1.20\n", "conditional.go": declarations.String(), "conditional_amd64.s": assembly.String(), "conditional_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("actual original Go SETcc runtime missing terminal: %s", output)
+	}
+	c.WriteString("static kernel kernels[]={" + strings.Join(names, ",") + "};\n")
+	c.WriteString(`int main(void) {
+ const unsigned offsets[]={8,9,16,17,0,1};
+ for(unsigned kernel=0;kernel<96;kernel++) for(unsigned sample=0;sample<64;sample++) {
+  uint8_t out[32],want[32];memset(out,0xc3,32);memset(want,0xc3,32);
+  uint64_t a=UINT64_C(0x1122334455667788),b=UINT64_C(0x8877665544332211),flags=2,observed;
+  const unsigned bits[]={0,2,4,6,7,11};for(unsigned bit=0;bit<6;bit++) if(sample&(1<<bit))flags|=UINT64_C(1)<<bits[bit];
+  memcpy(want+8,&a,8);memcpy(want+16,&b,8);want[offsets[kernel%6]]=truth(kernel/6,flags);
+  kernels[kernel](out,flags);memcpy(&observed,out+24,8);memcpy(want+24,&observed,8);
+  if(memcmp(out,want,32)||(observed&0x8d5)!=(flags&0x8d5)) {fprintf(stderr,"kernel%u sample%u flags%llx wanted%llx\n",kernel,sample,(unsigned long long)observed,(unsigned long long)flags);return 1;}
+ }
+ return 0;
+}
+`)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, name := range names {
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1},
+		}}}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs, ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "conditional-set", ir, c.String(), level)
+		})
+	}
+	t.Log("original Go 96 kernels × 64 independent flag seeds and LLVM O0/O2; exact full GP aliases, six flags, 32-byte canaries")
+}
diff --git a/amd64_conflict_funnel_fault_runtime_unix_test.go b/amd64_conflict_funnel_fault_runtime_unix_test.go
new file mode 100644
index 000000000..8e706fc12
--- /dev/null
+++ b/amd64_conflict_funnel_fault_runtime_unix_test.go
@@ -0,0 +1,117 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This checks the translated portable native accesses against independent
+// E4/E4NF fault expectations. It is not an original AVX512 execution oracle.
+func TestX86ConflictFunnelDeadNativeReadFaults(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable guard-page oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, row := range x86ConflictFunnelRows() {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && row.bits == 16 {
+				continue
+			}
+			op := row.op
+			bytes := 64
+			if broadcast {
+				op += ".BCST"
+				bytes = row.bits / 8
+			}
+			op += ".Z"
+			instruction := x86ConflictFunnelInstruction(op, "Z", "(AX)", "K1,", row.unary, row.variable)
+			name := fmt.Sprint("Dead", count)
+			fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\n"+
+				"KMOVQ mask+8(FP),K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nRET\n", name, instruction)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *,uint64_t);\n", name)
+			unary := 0
+			if row.unary {
+				unary = 1
+			}
+			fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, bytes, row.bits/8, unary)
+			count++
+		}
+	}
+	if count != 24 {
+		t.Fatal("incomplete independent dead memory/fault shape inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal("complete original dead native source rejected", err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + `
+typedef void (*Kernel)(const uint8_t *,uint64_t);
+typedef struct { Kernel run; int bytes,lane,nf; } Row;
+static const Row rows[] = {
+` + metadata.String() + `
+};
+static int fault(Kernel run,const uint8_t *p,uint64_t mask) {
+  pid_t child=fork();
+  if(child<0) return -1;
+  if(!child) {
+    struct rlimit no_core={0,0};
+    if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+    run(p,mask);
+    _exit(0);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)==0?0:-3;
+  if(WIFSIGNALED(status)) return WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS?1:-4;
+  return -5;
+}
+int main(void) {
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(p==MAP_FAILED || mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  for(long i=0;i<page;i++) p[i]=(uint8_t)(i*17+3);
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    const Row *row=&rows[r];
+    struct {const uint8_t *p;uint64_t mask;int want;} cases[]={
+      {0,0,row->nf},
+      {0,UINT64_C(1)<<63,row->nf},
+      {p+page-row->bytes,UINT64_MAX,0},
+      {p+page-row->bytes+1,UINT64_MAX,1},
+      {p+page-row->lane,1,row->nf && row->bytes>row->lane},
+      {p+page-row->lane+1,1,1},
+    };
+    for(unsigned c=0;c<sizeof(cases)/sizeof(cases[0]);c++) {
+      int actual=fault(row->run,cases[c].p,cases[c].mask);
+      if(actual!=cases[c].want) {
+        fprintf(stderr,"dead access row=%u case=%u bytes=%d actual=%d want=%d\n",r,c,row->bytes,actual,cases[c].want);
+        return 1;
+      }
+    }
+  }
+  return munmap(p,(size_t)page*2)?1:0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "conflict_funnel_dead_faults", triple, ir, mainC)
+}
diff --git a/amd64_conflict_funnel_forms.go b/amd64_conflict_funnel_forms.go
new file mode 100644
index 000000000..9c418bfe3
--- /dev/null
+++ b/amd64_conflict_funnel_forms.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedConflictForm struct {
+	x86PackedBinaryForm
+	spec amd64PackedConflictSpec
+}
+
+// Unary _yvexpandpd has the same width/mask/address axes as the binary
+// grammar. The local extra operand exists only while validating that shape;
+// consumers retain the original source indexes and instruction identity.
+func x86PackedConflictProperties(op Op, ins Instr, arch string) (x86PackedConflictForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedConflictSpecs[Op(base)]
+	result := x86PackedConflictForm{spec: spec}
+	if !known {
+		return result, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return result, true, fmt.Errorf("%s %s has an unbound dispatch or unary operand count", arch, op)
+	}
+	local := ins
+	local.Op = op
+	destination := ins.Args[len(ins.Args)-1]
+	local.Args = []Operand{ins.Args[0], destination, destination}
+	if len(ins.Args) == 3 {
+		local.Args = []Operand{ins.Args[0], destination, ins.Args[1], destination}
+	}
+	var err error
+	result.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch,
+		x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: spec.laneBits / 8, zeroing: true}, true)
+	result.second, result.destination = -1, len(ins.Args)-1
+	if result.mask >= 0 {
+		result.mask = 1
+	}
+	return result, true, err
+}
+
+type x86FunnelShiftForm struct {
+	x86PackedBinaryForm
+	spec amd64FunnelShiftSpec
+}
+
+func x86FunnelShiftProperties(op Op, ins Instr, arch string) (x86FunnelShiftForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64FunnelShiftSpecs[Op(base)]
+	result := x86FunnelShiftForm{spec: spec}
+	if !known {
+		return result, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return result, true, fmt.Errorf("funnel-shift dispatch/source opcode mismatch")
+	}
+	local := ins
+	local.Op = op
+	offset := 0
+	if !spec.variable {
+		if len(ins.Args) != 4 && len(ins.Args) != 5 || !amd64UnsignedImmediate(ins.Args[0], 8) || arch == "386" {
+			return result, true, fmt.Errorf("%s %s has an invalid imm8 or named frontend arity", arch, op)
+		}
+		offset = 1
+		local.Args = ins.Args[1:]
+	}
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, zeroing: true}
+	if spec.laneBits != 16 {
+		grammar.broadcastBytes = spec.laneBits / 8
+	}
+	var err error
+	result.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, grammar, false)
+	result.first += offset
+	result.second += offset
+	result.destination += offset
+	if result.mask >= 0 {
+		result.mask += offset
+	}
+	if result.memory >= 0 {
+		result.memory += offset
+	}
+	return result, true, err
+}
+
+func x86ConflictFunnelOperandGrammar(ins Instr, arch string, spec x86PackedBinarySpec, unary bool) (x86PackedBinaryForm, error) {
+	local, contextual := x86VectorValueMemoryInput(ins, arch)
+	form, err := x86PackedBinaryOperandGrammar(local, arch, spec, unary)
+	if err != nil {
+		return form, err
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, err
+	}
+	if form.memory >= 0 && !contextual && !x86PackedShiftMemoryValid(ins.Args[form.memory], arch) {
+		return form, fmt.Errorf("%s %s has an unresolved or unbound memory operand", arch, ins.Op)
+	}
+	if form.memory >= 0 {
+		source := ins.Args[form.memory]
+		if source.Kind == OpMem {
+			if !x86ConditionalMoveOffsetKnown(source.Mem) || source.Mem.IndexExt != "" ||
+				source.Mem.Segment != "" && source.Mem.Segment != FS && source.Mem.Segment != GS {
+				return form, fmt.Errorf("%s %s has an unresolved or foreign address", arch, ins.Op)
+			}
+			if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+				return form, err
+			}
+		}
+		if source.Kind == OpSym {
+			if address, parseErr := parseInt(strings.TrimSpace(source.Sym)); parseErr == nil &&
+				address != int64(int32(address)) && !(arch == "386" && address == int64(uint32(address))) {
+				return form, fmt.Errorf("%s %s absolute source exceeds its disp32 extent", arch, ins.Op)
+			}
+		}
+	}
+	if contextual {
+		return form, x86VectorValueMemoryContext(ins)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return form, fmt.Errorf("%w: %s needs its original default address mode", ErrProbeNeedsContext, ins.Op)
+	}
+	return form, nil
+}
+
+func (c *amd64Ctx) validateConflictFunnelMemory(ins Instr, form x86PackedBinaryForm) error {
+	if form.memory < 0 {
+		return nil
+	}
+	source := ins.Args[form.memory]
+	if source.Kind == OpMem && !c.nativeMemoryOperand(ins, form.memory) &&
+		!x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+		return fmt.Errorf("%w: %s needs its original native storage binding", ErrProbeNeedsContext, ins.Op)
+	}
+	if source.Kind == OpFP {
+		return c.validateX86PackedShiftFPSpan(source.FPOffset, form.memoryBytes)
+	}
+	return nil
+}
+
+// The typed operand description is shared by byte consumers, not a caller,
+// native backing or raw-entry permission. Variable funnel destinations are
+// numerical inputs even with EVEX.z; immediate results only merge old bytes.
+func x86TypedConflictFunnelByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	var form x86PackedBinaryForm
+	var old, known bool
+	var err error
+	if parsed, recognized, failure := x86PackedConflictProperties(op, ins, arch); recognized {
+		form, known, err = parsed.x86PackedBinaryForm, true, failure
+	} else if parsed, recognized, failure := x86FunnelShiftProperties(op, ins, arch); recognized {
+		form, old, known, err = parsed.x86PackedBinaryForm, parsed.spec.variable, true, failure
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedFixedVectorInputs(ins, form, old), true, nil
+}
+
+func x86TypedFixedVectorInputs(ins Instr, form x86PackedBinaryForm, old bool) x86TypedByteEffect {
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width,
+			read: old || form.mask >= 0 && !form.zeroing, write: true},
+	}}
+	if form.second >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.second, operand: ins.Args[form.second], width: width, read: true})
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect
+}
diff --git a/amd64_conflict_funnel_forms_test.go b/amd64_conflict_funnel_forms_test.go
new file mode 100644
index 000000000..3f9f8c8b3
--- /dev/null
+++ b/amd64_conflict_funnel_forms_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ConflictFunnelCompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts, total := make(map[string]int), 0
+	for _, row := range x86ConflictFunnelRows() {
+		for _, rule := range rules {
+			if rule.Opcode != row.op {
+				continue
+			}
+			index := counts[row.op]
+			counts[row.op]++
+			total++
+			ytab, zcase := "_yvblendmpd", "Zevex_rm_v_r"
+			classes := []string{"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+				"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex", "Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr"}
+			if index%2 != 0 {
+				zcase = "Zevex_rm_v_k_r"
+			}
+			if row.unary {
+				ytab = "_yvexpandpd"
+				classes = []string{"YxmEvex,YxrEvex", "YxmEvex,Yknot0,YxrEvex",
+					"YymEvex,YyrEvex", "YymEvex,Yknot0,YyrEvex", "Yzm,Yzr", "Yzm,Yknot0,Yzr"}
+				if index%2 != 0 {
+					zcase = "Zevex_rm_k_r"
+				}
+			} else if !row.variable {
+				ytab, zcase = "_yvalignd", "Zevex_i_rm_v_r"
+				if index%2 != 0 {
+					zcase = "Zevex_i_rm_v_k_r"
+				}
+				for i := range classes {
+					classes[i] = "Yu8," + classes[i]
+				}
+			}
+			mapName, opcode, w := "evex0F38", "0xC4", 0
+			if row.bits != 32 {
+				w = 1
+			}
+			if !row.unary {
+				number := 0x70
+				if row.bits != 16 {
+					number++
+				}
+				if strings.HasPrefix(row.op, "VPSHR") {
+					number += 2
+				}
+				opcode = fmt.Sprintf("0x%X", number)
+				if !row.variable {
+					mapName = "evex0F3A"
+				}
+			}
+			var attributes []string
+			for _, width := range []int{128, 256, 512} {
+				memory := fmt.Sprintf("evexN%d", width/8)
+				if row.bits != 16 {
+					memory += fmt.Sprintf(" | evexBcstN%d", row.bits/8)
+				}
+				memory += " | evexZeroingEnabled"
+				attributes = append(attributes,
+					fmt.Sprintf("avxEscape | evex%d | evex66 | %s | evexW%d", width, mapName, w), memory, opcode)
+			}
+			if index >= 6 || rule.RowIndex != index || rule.Ytab != ytab || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != index%2*3 || rule.EncodingOffset != index/2*3 ||
+				strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, attributes) {
+				t.Fatal("complete independent encoder row or opcode attributes changed", row.op, rule)
+			}
+		}
+		if counts[row.op] != 6 {
+			t.Fatal("incomplete independent family row inventory", row.op, counts[row.op])
+		}
+	}
+	if len(counts) != 14 || total != 84 {
+		t.Fatal("complete conflict/funnel family changed", len(counts), total)
+	}
+}
+
+func TestX86ConflictFunnelMaskAndOldDestinationRoles(t *testing.T) {
+	for _, row := range x86ConflictFunnelRows() {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				op, mask := row.op, ""
+				if mode != "plain" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					op += ".Z"
+				}
+				ins := x86ScalarLaneInstruction(t, x86ConflictFunnelInstruction(op, bank, bank+"0", mask, row.unary, row.variable))
+				for _, missing := range []string{"none", "mask", "old"} {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.masks[1] = missing != "mask"
+					if missing != "old" {
+						state.writeVector(2, 64, ^uint64(0), false)
+					}
+					before := state.clone()
+					want := !(missing == "mask" && mode != "plain" || missing == "old" && (row.variable || mode == "merge"))
+					if accepted := x86ResultTransfer(ins, &state, nil, 0, "amd64"); accepted != want {
+						t.Fatal("mask merge and old data inputs were conflated", row.op, bank, mode, missing, accepted, want)
+					}
+					if !want && !reflect.DeepEqual(state, before) {
+						t.Fatal("rejected input mutated reaching numerical state")
+					}
+				}
+				effect, known, err := x86TypedConflictFunnelByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil || !effect.requiresResultProof {
+					t.Fatal("complete typed byte shape omitted an input obligation", row.op, err)
+				}
+				writes := 0
+				for _, operand := range effect.operands {
+					if operand.write {
+						writes++
+						if operand.read != (row.variable || mode == "merge") || operand.width != int64(amd64VectorByteWidth(Reg(bank+"0"))) {
+							t.Fatal("typed numerical destination role changed", row.op, mode, operand)
+						}
+					}
+				}
+				if writes != 1 {
+					t.Fatal("unexpected typed destination inventory", writes)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ConflictFunnelRejectsUnresolvedShapesBeforeIR(t *testing.T) {
+	for _, row := range x86ConflictFunnelRows() {
+		for _, mutation := range []string{"suffix", "offset", "extension", "segment", "index", "absolute", "dispatch", "float", "unresolved"} {
+			if row.unary || row.variable {
+				if mutation == "float" || mutation == "unresolved" {
+					continue
+				}
+			}
+			t.Run(row.op+"/"+mutation, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, x86ConflictFunnelInstruction(row.op, "X", "(AX)", "", row.unary, row.variable))
+				source := 0
+				if !row.unary && !row.variable {
+					source = 1
+				}
+				op := ins.Op
+				switch mutation {
+				case "suffix":
+					op += ".SAE"
+					ins.Op = op
+				case "offset":
+					ins.Args[source].Mem.OffRaw = "UNKNOWN"
+				case "extension":
+					ins.Args[source].Mem.IndexExt = "UXTW"
+				case "segment":
+					ins.Args[source].Mem.Segment = "DS"
+				case "index":
+					ins.Args[source].Mem.Index, ins.Args[source].Mem.Scale = SP, 2
+				case "absolute":
+					ins.Args[source] = Operand{Kind: OpSym, Sym: "4294967296"}
+				case "dispatch":
+					ins.Op = "VPXORD"
+				case "float":
+					ins.Args[0].ImmIsFloat = true
+				case "unresolved":
+					ins.Args[0].ImmRaw = "UNKNOWN"
+				}
+				var ir strings.Builder
+				consumer := &amd64Ctx{b: &ir, goarch: "amd64"}
+				var known bool
+				var err error
+				if row.unary {
+					known, _, err = consumer.lowerPackedConflict(op, ins)
+				} else {
+					known, _, err = consumer.lowerFunnelShift(op, ins)
+				}
+				if !known || err == nil || ir.Len() != 0 {
+					t.Fatal("invalid original shape reached IR or an unknown dispatch", known, err, ir.String())
+				}
+			})
+		}
+	}
+}
+
+func TestX86ConflictFunnelNativeContinuationKeepsAddressAndOriginBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ConflictFunnelRows() {
+			if arch == "386" && !row.unary && !row.variable {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, x86ConflictFunnelInstruction(row.op, "X", "-1(SI)(BX*2)", "", row.unary, row.variable))
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.writeVector(2, 64, ^uint64(0), false)
+				state.pointerGP[6], state.gp[3] = true, 0xff
+				before := state.clone()
+				if accepted := x86ResultTransfer(ins, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone observer acquired a paired native read")
+				}
+				want := before.clone()
+				want.writeVector(2, 16, 0xffff, false)
+				accepted, known := x86LoweredFixedVectorNativeRead(ins, &state, nil, arch)
+				if !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("paired native read lost its exact output or changed independent state", accepted, known)
+				}
+				for _, mutation := range []string{"pointer", "index", "pointer-index", "raw", "encoded", "address", "segment", "raw-return"} {
+					input, changed := before.clone(), ins
+					switch mutation {
+					case "pointer":
+						input.pointerGP[6] = false
+					case "index":
+						input.gp[3] = 1
+					case "pointer-index":
+						input.pointerGP[3], input.gp[3] = true, 0
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "encoded":
+						changed.x86Encoded = true
+					case "address":
+						changed.x86AddressBits = 32
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "raw-return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					}
+					original := input.clone()
+					if accepted, _ := x86LoweredFixedVectorNativeRead(changed, &input, nil, arch); accepted || !reflect.DeepEqual(input, original) {
+						t.Fatal("unproved source or address acquired native result bytes", mutation)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ConflictFunnelZeroMasksRetainDistinctNativeReads(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if word == 4 {
+			move = "MOVL"
+		}
+		for _, row := range x86ConflictFunnelRows() {
+			if target.arch == "386" && !row.unary && !row.variable {
+				continue
+			}
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && row.bits == 16 {
+						continue
+					}
+					op, mask := row.op, "K1,"
+					if broadcast {
+						op += ".BCST"
+					}
+					masked := target.arch != "386" || row.unary
+					if masked {
+						op += ".Z"
+					} else {
+						mask = ""
+					}
+					instruction := x86ConflictFunnelInstruction(op, bank, "(AX)", mask, row.unary, row.variable)
+					width := amd64VectorByteWidth(Reg(bank + "0"))
+					t.Run(target.triple+"/"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n"+
+							"MOVL $0,BX\nKMOVD BX,K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nRET\n", word, move, instruction)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("complete dead native source rejected", api, err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							if !row.unary && masked {
+								if !strings.Contains(ir, fmt.Sprintf("load volatile i%d", row.bits)) || strings.Contains(optimized, "load volatile") {
+									t.Fatal("E4 zero mask failed to suppress only its native lane reads", api)
+								}
+							} else {
+								bytes := width
+								if broadcast {
+									bytes = row.bits / 8
+								}
+								load := fmt.Sprintf("load volatile <%d x i8>", bytes)
+								if strings.Count(ir, load) != 1 || strings.Count(optimized, load) != 1 {
+									t.Fatal("E4NF or unmasked source lost its exact complete tuple", api, load)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_conflict_funnel_runtime_test.go b/amd64_conflict_funnel_runtime_test.go
new file mode 100644
index 000000000..cd1bdfaec
--- /dev/null
+++ b/amd64_conflict_funnel_runtime_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These are the unchanged original C numerical oracles, compiled for the
+// actual host. They do not claim original AVX512 hardware execution.
+func x86ConflictFunnelPortableRuntime(t *testing.T, llc, clang, name, triple, ir, mainC string) {
+	t.Helper()
+	for _, pipeline := range []struct {
+		name      string
+		optimized bool
+		backend   int
+	}{
+		{name: "backend_O0"},
+		{name: "backend_O2", backend: 2},
+		{name: "IR_O2/backend_O2", optimized: true, backend: 2},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			text := ir
+			if pipeline.optimized {
+				text = x86DwordProductIROptimize(t, ir)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, name, triple,
+				text, mainC, nil, pipeline.backend)
+		})
+	}
+}
+
+func x86ConflictFunnelWholeByteRuntime(t *testing.T, bank string) {
+	t.Helper()
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable whole-byte oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, row := range x86ConflictFunnelRows() {
+		for mode, suffix := range []string{"", "", ".Z"} {
+			name := fmt.Sprint("Whole", count)
+			mask := ""
+			if mode != 0 {
+				mask = "K1,"
+			}
+			selector := 255
+			if bank == "X" {
+				selector = 0
+			} else if bank == "Y" {
+				selector = row.bits // The immediate wraps modulo the lane width.
+			}
+			instruction := x86ConflictFunnelInstruction(row.op+suffix, bank, bank+"0", mask, row.unary, row.variable)
+			instruction = strings.Replace(instruction, "$255,", fmt.Sprintf("$%d,", selector), 1)
+			fmt.Fprintf(&declarations, "func %s(out *[257]byte,a,b,old *[64]byte,mask uint64)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\n"+
+				"MOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ old+24(FP),DX\n"+
+				"VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (DX),Z2\nVMOVUPS (DX),Z3\n"+
+				"KMOVQ mask+32(FP),K1\nSTC\n%s\n"+
+				"VMOVUPS Z2,0(DI)\nVMOVUPS Z0,64(DI)\nVMOVUPS Z1,128(DI)\nVMOVUPS Z3,192(DI)\nSETCS 256(DI)\nRET\n", name, instruction)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", name)
+			kind, left := 0, 0
+			if !row.unary {
+				kind = 1
+				if row.variable {
+					kind = 2
+				}
+				if strings.HasPrefix(row.op, "VPSHL") {
+					left = 1
+				}
+			}
+			fmt.Fprintf(&metadata, "{%s,%d,%d,%d,%d,%d,%d},\n", name, kind, row.bits,
+				amd64VectorByteWidth(Reg(bank+"0")), left, mode, selector)
+			count++
+		}
+	}
+	if count != 42 {
+		t.Fatal("incomplete independent whole-byte numerical union", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal("complete original whole-byte source rejected", err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);
+typedef struct { Kernel run; int kind,bits,width,left,mode,selector; } Row;
+static const Row rows[] = {
+` + metadata.String() + `
+};
+static uint64_t read_lane(const uint8_t *p,int bytes) {
+  uint64_t value=0;
+  for(int i=0;i<bytes;i++) value|=(uint64_t)p[i]<<(8*i);
+  return value;
+}
+static void write_lane(uint8_t *p,int bytes,uint64_t value) {
+  for(int i=0;i<bytes;i++) p[i]=(uint8_t)(value>>(8*i));
+}
+int main(void) {
+  static const uint64_t masks[]={0,UINT64_MAX,UINT64_C(0xaaaaaaaa55555555),UINT64_C(0x8000000000000000),1};
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    const Row *row=&rows[r];
+    for(int trial=0;trial<32;trial++) {
+      uint8_t a[64],b[64],old[64],out[259],want[257];
+      for(int i=0;i<64;i++) {
+        a[i]=(uint8_t)(i*37+trial*23+19);
+        b[i]=(uint8_t)(i*13+trial*43+71);
+        old[i]=(uint8_t)(i*29+trial*17+131);
+      }
+      int bytes=row->bits/8,lanes=row->width/bytes;
+      if(row->kind==0) {
+        for(int lane=0;lane<lanes;lane++) write_lane(a+lane*bytes,bytes,(uint64_t)((lane+trial)%4)*UINT64_C(0x1020304));
+      } else if(row->kind==2) {
+        const uint64_t counts[]={0,1,(uint64_t)(row->bits-1),(uint64_t)row->bits,(uint64_t)(row->bits+1),UINT64_MAX};
+        for(int lane=0;lane<lanes;lane++) write_lane(a+lane*bytes,bytes,counts[(lane+trial)%6]);
+      }
+      uint64_t mask=masks[trial%5];
+      memset(out,0xa7,sizeof(out));
+      memset(want,0,sizeof(want));
+      memcpy(want+64,a,64);
+      memcpy(want+128,b,64);
+      memcpy(want+192,old,64);
+      want[256]=1;
+      for(int lane=0;lane<lanes;lane++) {
+        uint64_t first=read_lane(a+lane*bytes,bytes),second=read_lane(b+lane*bytes,bytes);
+        uint64_t previous=read_lane(old+lane*bytes,bytes),result=0;
+        if(row->kind==0) {
+          for(int prior=0;prior<lane;prior++) if(first==read_lane(a+prior*bytes,bytes)) result|=UINT64_C(1)<<prior;
+        } else {
+          unsigned count=(row->kind==2?(unsigned)first:(unsigned)row->selector)&(row->bits-1);
+          uint64_t base=row->kind==2?previous:second,other=row->kind==2?second:first;
+          if(!count) result=base;
+          else if(row->left) result=(base<<count)|(other>>(row->bits-count));
+          else result=(base>>count)|(other<<(row->bits-count));
+        }
+        if(row->mode && !((mask>>lane)&1)) result=row->mode==2?0:previous;
+        write_lane(want+lane*bytes,bytes,result);
+      }
+      rows[r].run(out+1,a,b,old,mask);
+      if(out[0]!=0xa7 || out[258]!=0xa7 || memcmp(out+1,want,sizeof(want))) {
+        fprintf(stderr,"whole-byte row=%u trial=%d bits=%d width=%d mode=%d\n",r,trial,row->bits,row->width,row->mode);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "conflict_funnel_whole_"+bank, triple, ir, mainC)
+}
+
+func TestX86ConflictFunnelWholeXByteSemantics(t *testing.T) {
+	x86ConflictFunnelWholeByteRuntime(t, "X")
+}
+
+func TestX86ConflictFunnelWholeYByteSemantics(t *testing.T) {
+	x86ConflictFunnelWholeByteRuntime(t, "Y")
+}
+
+func TestX86ConflictFunnelWholeZByteSemantics(t *testing.T) {
+	x86ConflictFunnelWholeByteRuntime(t, "Z")
+}
diff --git a/amd64_conformance_axis_test.go b/amd64_conformance_axis_test.go
new file mode 100644
index 000000000..b1c42af28
--- /dev/null
+++ b/amd64_conformance_axis_test.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestAMD64ConformanceNativeMoveAssertionsRetainRequiredAxis(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang is required")
+	}
+	for _, native := range []bool{false, true} {
+		t.Run(fmt.Sprint(native), func(t *testing.T) {
+			command := exec.Command(clang, "-E", "-P", "-x", "c", "-")
+			command.Stdin = strings.NewReader(amd64ConformanceRuntimeC(native))
+			out, err := command.CombinedOutput()
+			if err != nil {
+				t.Fatalf("actual driver preprocessing: %v\n%s", err, out)
+			}
+			for _, call := range []string{
+				"packedFloatMoveMaskSemantics(move_mask_out, move_src, move_old)",
+				"sameWidthPackedConversionSemantics(same_width_out,",
+			} {
+				if strings.Contains(string(out), call) != native {
+					t.Errorf("native=%v has wrong actual call selection for %s", native, call)
+				}
+			}
+			if !strings.Contains(string(out), "packedFloatMoveVEXSemantics(move_vex_out, move_src)") {
+				t.Error("portable register-move assertions were lost")
+			}
+		})
+	}
+}
diff --git a/amd64_conformance_entry_closure_test.go b/amd64_conformance_entry_closure_test.go
new file mode 100644
index 000000000..74ba2455c
--- /dev/null
+++ b/amd64_conformance_entry_closure_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This directory checks each original public entry independently, not complete
+// program execution. KeepFunc receives the complete original ASM and the same
+// complete Go declarations on every request; no producer, DATA or signature is
+// rewritten to bypass the first failure in the combined runtime translation.
+func TestAMD64ConformanceEveryOriginalEntrySourceClosure(t *testing.T) {
+	source, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations, err := os.ReadFile("testdata/conformance/amd64/conformance.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fmt.Sprintf("%x", sha256.Sum256(source)) != "3c105a49b705062c1ced2ecb492e5319e8d6836a8ca35a1cb276b9969f6ebc0e" ||
+		fmt.Sprintf("%x", sha256.Sum256(declarations)) != "00bc95eb6d5cd5d1c976c8e077fa3f48f3c65bfd47815d7614b2866d2b7c41d2" {
+		t.Fatal("original complete conformance ASM or Go declarations changed")
+	}
+	file, err := Parse(ArchAMD64, string(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != 45 {
+		t.Fatal("complete original public entry directory changed", len(file.Funcs))
+	}
+	pkg := mustGoPackage(t, "amd64conformance", string(declarations))
+	resolve := func(symbol string) string {
+		return strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil || len(signatures) != len(file.Funcs) {
+		t.Fatal("complete original Go signature directory differs", len(signatures), err)
+	}
+	// This existing stock-Go compiler prior includes both entire original
+	// files and runs before any translator request, without native execution.
+	if !t.Run("OriginalGoObjects", TestAMD64ConformanceOriginalWideSourceCompiles) {
+		t.Fatal("original complete Go program must compile before source-closure observations")
+	}
+	seen := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		name := resolve(fn.Sym)
+		if seen[name] {
+			t.Fatal("duplicate original public entry", name)
+		}
+		seen[name] = true
+		t.Run(name, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			translated, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+				FileName: "conformance_amd64.s", GOOS: "linux", GOARCH: "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve,
+				KeepFunc: func(_ string, resolved string) bool { return resolved == name },
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil || translated == nil || translated.Module.IsNil() {
+				t.Fatal("original initialized public entry lacks its own complete source closure", err)
+			}
+			if len(translated.Functions) != 1 || translated.Functions[0].TextSymbol != fn.Sym ||
+				translated.Functions[0].ResolvedSymbol != name ||
+				!reflect.DeepEqual(translated.Signatures[name], signatures[name]) {
+				t.Fatal("isolated entry changed its original public identity or Go signature")
+			}
+			if translated.Module.String() == "" {
+				t.Fatal("source closure returned no original public function")
+			}
+		})
+	}
+}
diff --git a/amd64_conformance_native_test.go b/amd64_conformance_native_test.go
new file mode 100644
index 000000000..1c32b5823
--- /dev/null
+++ b/amd64_conformance_native_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// The same complete first-party original Go/ASM bytes are compiled under the
+// actual selected driver. This program is executed only after the mandatory
+// native AVX512 preflight; the historical NativeGo test never called this TEXT.
+func amd64ConformanceOriginalWideGo(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("original wide conformance requires its actual native Linux AMD64 counterpart")
+	}
+	dir := amd64ConformanceOriginalWidePackage(t)
+	command := exec.Command("go", "test", "-p=2", "-count=1", "-run", "^TestOriginal(SameWidthPackedConversion|PackedFloatMoveMasks)$", "-v", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	t.Logf("actual original Go full-source wide conformance: %s", x86FloatCompareCaptureCommand(t, command))
+}
+
+func amd64ConformanceOriginalWidePackage(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	for _, name := range []string{"conformance.go", "conformance_amd64.s"} {
+		contents, err := os.ReadFile(filepath.Join("testdata", "conformance", "amd64", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for name, source := range map[string]string{
+		"go.mod":       "module nativewideconformance\n\ngo 1.20\n",
+		"wide_test.go": amd64ConformanceOriginalWideTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func TestAMD64ConformanceOriginalWideSourceCompiles(t *testing.T) {
+	dir := amd64ConformanceOriginalWidePackage(t)
+	command := exec.Command("go", "test", "-p=2", "-c", "-o", filepath.Join(dir, "wide"), ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	x86FloatCompareCaptureCommand(t, command)
+	t.Log("complete original Go/ASM and new original wide oracle compile for Linux AMD64; object is not executed on this portable axis")
+}
+
+const amd64ConformanceOriginalWideTest = `package amd64conformance
+
+import (
+    "encoding/binary"
+    "math"
+    "testing"
+    "unsafe"
+)
+
+func TestOriginalPackedFloatMoveMasks(t *testing.T) {
+    aligned := func(size, phase int) ([]byte, []byte, int) {
+        storage := make([]byte, size+128)
+        for i := range storage {
+            storage[i] = 0xa7
+        }
+        base := uintptr(unsafe.Pointer(&storage[0]))
+        offset := int((64-base%64)%64) + phase
+        return storage, storage[offset:offset+size], offset
+    }
+    _, src, _ := aligned(64, 0)
+    _, old, _ := aligned(64, 0)
+    storage, out, offset := aligned(688, 16)
+    for i := range src {
+        src[i] = byte(3 + 17*i)
+        old[i] = byte(0xf0 - 3*i)
+    }
+    packedFloatMoveMaskSemantics((*[688]byte)(out), (*[64]byte)(src), (*[64]byte)(old))
+
+    forms := []struct { offset, width, lane int; zero bool }{
+        {0,16,4,false}, {16,16,4,true}, {32,16,4,false}, {48,16,4,false},
+        {64,16,8,false}, {80,16,8,true}, {96,16,8,false},
+        {112,32,4,false}, {144,32,4,true}, {176,32,4,false},
+        {208,32,8,false}, {240,32,8,true}, {272,32,8,false},
+        {304,64,4,false}, {368,64,4,true}, {432,64,4,false},
+        {496,64,8,false}, {560,64,8,true}, {624,64,8,false},
+    }
+    for _, form := range forms {
+        for i := 0; i < form.width; i++ {
+            want := old[i]
+            if (0xa55a >> (i / form.lane)) & 1 != 0 {
+                want = src[i]
+            } else if form.zero {
+                want = 0
+            }
+            if got := out[form.offset+i]; got != want {
+                t.Fatalf("original move offset=%d byte=%d: got=%02x want=%02x", form.offset, i, got, want)
+            }
+        }
+    }
+    for i, value := range storage {
+        if (i < offset || i >= offset+len(out)) && value != 0xa7 {
+            t.Fatalf("original move output canary changed at %d", i)
+        }
+    }
+}
+
+func TestOriginalSameWidthPackedConversion(t *testing.T) {
+    var ints [16]int32
+    floats := [16]float32{
+        1.5,-1.5,2.75,-2.75,0.5,-0.5,3.25,-3.25,
+        4.5,-4.5,5.75,-5.75,6.5,-6.5,7.25,-7.25,
+    }
+    var squares32 [16]float32
+    var squares64 [8]float64
+    for i:=0;i<16;i++ {
+        ints[i]=int32(i-8)
+        squares32[i]=float32((i+1)*(i+1))
+    }
+    for i:=0;i<8;i++ {
+        squares64[i]=float64((i+1)*(i+1))
+    }
+    nearest := [16]int32{2,-2,3,-3,0,0,3,-3,4,-4,6,-6,6,-6,7,-7}
+    truncated := [16]int32{1,-1,2,-2,0,0,3,-3,4,-4,5,-5,6,-6,7,-7}
+    down := [16]int32{1,-2,2,-3,0,-1,3,-4,4,-5,5,-6,6,-7,7,-8}
+    up := [16]int32{2,-1,3,-2,1,0,4,-3,5,-4,6,-5,7,-6,8,-7}
+    var guarded [578]byte
+    guarded[0],guarded[577]=0xa7,0xb9
+    output:=guarded[1:577]
+    sameWidthPackedConversionSemantics((*[576]byte)(output),&ints,&floats,&squares32,&squares64)
+    if guarded[0]!=0xa7 || guarded[577]!=0xb9 {
+        t.Fatal("original wide conversion output canary changed")
+    }
+    single := func(offset int) float32 {
+        return math.Float32frombits(binary.LittleEndian.Uint32(output[offset:]))
+    }
+    integer := func(offset int) int32 {
+        return int32(binary.LittleEndian.Uint32(output[offset:]))
+    }
+    for i:=0;i<16;i++ {
+        if single(4*i)!=float32(ints[i]) || integer(64+4*i)!=nearest[i] ||
+            integer(128+4*i)!=truncated[i] || single(192+4*i)!=float32(i+1) ||
+            integer(320+4*i)!=nearest[i] || integer(384+4*i)!=down[i] ||
+            integer(448+4*i)!=up[i] || integer(512+4*i)!=truncated[i] {
+            t.Fatalf("original wide conversion lane %d output=%x",i,output)
+        }
+    }
+    for i:=0;i<8;i++ {
+        value:=math.Float64frombits(binary.LittleEndian.Uint64(output[256+8*i:]))
+        if value!=float64(i+1) {
+            t.Fatalf("original wide sqrt lane %d value=%v",i,value)
+        }
+    }
+}
+`
diff --git a/amd64_conformance_test.go b/amd64_conformance_test.go
index f481eb5d6..13cad5a4c 100644
--- a/amd64_conformance_test.go
+++ b/amd64_conformance_test.go
@@ -1,8 +1,7 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -15,9 +14,9 @@ func TestAMD64ConformanceNativeGo(t *testing.T) {
 	if runtime.GOARCH != "amd64" && !(runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()) {
 		t.Skip("native Go assembler oracle requires an amd64 host")
 	}
-	cmd := exec.Command("go", "test", "./testdata/conformance/amd64")
+	cmd := exec.Command("go", "test", "-count=1", "./testdata/conformance/amd64")
 	if runtime.GOARCH != "amd64" {
-		cmd.Env = append(os.Environ(), "GOARCH=amd64")
+		cmd.Env = append(os.Environ(), "GOARCH=amd64", "PLAN9ASM_ROSETTA=1")
 	}
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Fatalf("native Go conformance failed: %v\n%s", err, out)
@@ -25,14 +24,11 @@ func TestAMD64ConformanceNativeGo(t *testing.T) {
 }
 
 func TestAMD64ConformanceLLVMRuntime(t *testing.T) {
-	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
-	if runtime.GOARCH != "amd64" && !crossRosetta {
-		t.Skip("runtime execution test only runs on amd64 host")
-	}
-	llc, clang, ok := findLlcAndClang(t)
-	if !ok {
-		t.Skip("llc/clang not found")
-	}
+	amd64ConformanceLLVMRuntime(t, x86FloatCompareRuntimeTools(t, x86FloatCompareSSE), false)
+}
+
+func amd64ConformanceLLVMRuntime(t *testing.T, execution x86FloatCompareExecution, nativeWide bool) {
+	t.Helper()
 
 	src, err := os.ReadFile(filepath.Join("testdata", "conformance", "amd64", "conformance_amd64.s"))
 	if err != nil {
@@ -47,12 +43,7 @@ func TestAMD64ConformanceLLVMRuntime(t *testing.T) {
 		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
 		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
 	}}
-	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
-	var runPrefix []string
-	if crossRosetta {
-		triple = "x86_64-apple-macosx"
-		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
-	}
+	triple := execution.triple
 	ll, err := Translate(file, Options{
 		TargetTriple: triple,
 		ResolveSym:   resolve,
@@ -133,6 +124,238 @@ func TestAMD64ConformanceLLVMRuntime(t *testing.T) {
 					{Offset: 24, Type: I64, Index: 3, Field: -1},
 				}},
 			},
+			"scalarShiftRotateSemantics": {
+				Name: "scalarShiftRotateSemantics",
+				Args: []LLVMType{Ptr, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+			"incDecSemantics": {
+				Name: "incDecSemantics",
+				Args: []LLVMType{Ptr, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+				}},
+			},
+			"scalarAddSubSemantics": {
+				Name: "scalarAddSubSemantics",
+				Args: []LLVMType{Ptr, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+			"compareExchangeScalarSemantics": {
+				Name: "compareExchangeScalarSemantics",
+				Args: []LLVMType{Ptr, Ptr, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+					{Offset: 24, Type: I64, Index: 3, Field: -1},
+				}},
+			},
+			"compareExchangePairSemantics": {
+				Name: "compareExchangePairSemantics",
+				Args: []LLVMType{Ptr, Ptr, I64, I64, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+					{Offset: 24, Type: I64, Index: 3, Field: -1},
+					{Offset: 32, Type: I64, Index: 4, Field: -1},
+					{Offset: 40, Type: I64, Index: 5, Field: -1},
+				}},
+			},
+			"parallelBitSemantics": {
+				Name: "parallelBitSemantics",
+				Args: []LLVMType{Ptr, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+			"bitTestRegisterSemantics": {
+				Name: "bitTestRegisterSemantics",
+				Args: []LLVMType{Ptr, I64, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+			"bitTestMemorySemantics": {
+				Name: "bitTestMemorySemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"packedWordMultiplyAddSemantics": {
+				Name: "packedWordMultiplyAddSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedUnsignedSignedByteMultiplyAddSemantics": {
+				Name: "packedUnsignedSignedByteMultiplyAddSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedDotProductSemantics": {
+				Name: "packedDotProductSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+					{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				}},
+			},
+			"packedIntegerMinMaxSemantics": {
+				Name: "packedIntegerMinMaxSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedWordMultiplySemantics": {
+				Name: "packedWordMultiplySemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedFloatShuffleSemantics": {
+				Name: "packedFloatShuffleSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"inLaneFloatingPermuteSemantics": {
+				Name: "inLaneFloatingPermuteSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"immediatePackedBlendSemantics": {
+				Name: "immediatePackedBlendSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedUnpackSemantics": {
+				Name: "packedUnpackSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"qwordPermuteSemantics": {
+				Name: "qwordPermuteSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"qwordVariablePermuteSemantics": {
+				Name: "qwordVariablePermuteSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedFloatMoveVEXSemantics": {
+				Name: "packedFloatMoveVEXSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"packedFloatMoveMaskSemantics": {
+				Name: "packedFloatMoveMaskSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"packedSignExtendMoveVEXSemantics": {
+				Name: "packedSignExtendMoveVEXSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"packedSignExtendMoveMaskSemantics": {
+				Name: "packedSignExtendMoveMaskSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
 			"goHexVectorOps": {
 				Name: "goHexVectorOps",
 				Args: []LLVMType{Ptr, Ptr, Ptr},
@@ -161,12 +384,141 @@ func TestAMD64ConformanceLLVMRuntime(t *testing.T) {
 				Ret:   Void,
 				Frame: ptrParams,
 			},
+			"packedSubtractSemantics": {
+				Name: "packedSubtractSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"expandedEcosystemVectors": {
+				Name: "expandedEcosystemVectors",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"parityBranches": {
+				Name: "parityBranches",
+				Args: []LLVMType{I8},
+				Ret:  I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I8, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+			"unorderedBranch": {
+				Name: "unorderedBranch",
+				Args: []LLVMType{LLVMType("double")},
+				Ret:  I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+			"packedFloatToDwordModes": {
+				Name: "packedFloatToDwordModes",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"sameWidthPackedConversionSemantics": {
+				Name: "sameWidthPackedConversionSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				}},
+			},
+			"packedSingleToDouble": {
+				Name: "packedSingleToDouble",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"conditionalMoveCodes": {
+				Name: "conditionalMoveCodes",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"fma3Semantics": {
+				Name: "fma3Semantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+					{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+					{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+				}},
+			},
+			"binaryFloatingSemantics": {
+				Name: "binaryFloatingSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				}},
+			},
+			"horizontalFloatingSemantics": {
+				Name: "horizontalFloatingSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				}},
+			},
 		},
 	})
 	if err != nil {
 		t.Fatal(err)
 	}
-	mainC := `
+	// Numeric fixtures must return normally. Go-accepted EVEX zeroing memory
+	// stores raise #UD and belong in the separate exhaustive fault oracle,
+	// not in a fixture whose C driver expects an arithmetic result.
+	if strings.Contains(ll, `asm sideeffect "ud2"`) {
+		t.Fatal("numeric conformance fixture contains an architectural trap; preserve it in the separate expected-fault oracle")
+	}
+	// Every source function reaches the LLVM object on both execution axes.
+	// Only native aligned moves and wide conversions require AVX512 execution;
+	// their complete assertions also run against the original Go object there.
+	execution.compileAndRunLLVM(t, "amd64_conformance", ll, amd64ConformanceRuntimeC(nativeWide), "-O2")
+	t.Logf("complete original assembly object; native-wide runtime=%v, actual transport=%v", nativeWide, execution.prefix)
+}
+
+func amd64ConformanceRuntimeC(nativeWide bool) string {
+	return fmt.Sprintf("#define PLAN9ASM_CONFORMANCE_NATIVE_WIDE %d\n", x86FloatAddSubBoolInt(nativeWide)) + `
 #include <stdint.h>
 extern void byteMemory(uint8_t *p, uint8_t value);
 extern void byteFlags(uint8_t *p, uint8_t *flags);
@@ -176,9 +528,61 @@ extern uint32_t shiftLegacyThreeOperand(uint32_t src, uint32_t dst, uint32_t amo
 extern uint64_t clearTopBit(uint64_t value);
 extern void doubleShift32(uint32_t *out, uint32_t src, uint32_t dst, uint32_t amount);
 extern void doubleShift64(uint64_t *out, uint64_t src, uint64_t dst, uint64_t amount);
+extern void scalarShiftRotateSemantics(uint64_t *out, uint64_t value, uint64_t count);
+extern void incDecSemantics(uint64_t *out, uint64_t value);
+extern void scalarAddSubSemantics(uint64_t *out, uint64_t value, uint64_t source);
+extern void compareExchangeScalarSemantics(uint64_t *out, uint64_t *memory, uint64_t expected, uint64_t desired);
+extern void compareExchangePairSemantics(uint64_t *out, uint64_t *memory, uint64_t expected_low, uint64_t expected_high, uint64_t desired_low, uint64_t desired_high);
+extern void parallelBitSemantics(uint64_t *out, uint64_t mask, uint64_t source);
+extern void bitTestRegisterSemantics(uint64_t *out, uint64_t value, uint64_t index);
+extern void bitTestMemorySemantics(uint8_t *out, uint64_t *data);
+extern void packedWordMultiplyAddSemantics(int32_t *out, int16_t *a, int16_t *b);
+extern void packedUnsignedSignedByteMultiplyAddSemantics(int16_t *out, int8_t *signed_input, uint8_t *unsigned_input);
+extern void packedDotProductSemantics(int32_t *out, int8_t *signed_bytes, uint8_t *unsigned_bytes, int16_t *words_a, int16_t *words_b, int32_t *accumulator);
+extern void packedIntegerMinMaxSemantics(uint8_t *out, uint8_t *a, uint8_t *b);
+extern void packedWordMultiplySemantics(uint16_t *out, int16_t *a, int16_t *b);
+extern void packedFloatShuffleSemantics(uint8_t *out, uint8_t *a, uint8_t *b);
+extern void inLaneFloatingPermuteSemantics(uint8_t *out, uint8_t *data, uint8_t *control);
+extern void immediatePackedBlendSemantics(uint8_t *out, uint8_t *a, uint8_t *b);
+extern void packedUnpackSemantics(uint8_t *out, uint8_t *a, uint8_t *b);
+extern void qwordPermuteSemantics(uint64_t *out, uint64_t *data);
+extern void qwordVariablePermuteSemantics(uint64_t *out, uint64_t *data, uint64_t *control);
+extern void packedFloatMoveVEXSemantics(uint8_t *out, uint8_t *src);
+extern void packedFloatMoveMaskSemantics(uint8_t *out, uint8_t *src, uint8_t *old);
+extern void packedSignExtendMoveVEXSemantics(uint8_t *out, uint8_t *src);
+extern void packedSignExtendMoveMaskSemantics(uint8_t *out, uint8_t *src, uint8_t *old);
 extern void goHexVectorOps(uint8_t *out, uint8_t *a, uint8_t *b);
 extern uint64_t goHexWordOps(uint64_t value, uint64_t count);
 extern void packedArithmeticShift32(int32_t *out, int32_t *src);
+extern void packedSubtractSemantics(uint8_t *out, uint8_t *a, uint8_t *b);
+extern void expandedEcosystemVectors(uint8_t *out, uint8_t *a, uint8_t *b);
+extern uint64_t parityBranches(uint8_t value);
+extern uint64_t unorderedBranch(double value);
+extern void packedFloatToDwordModes(int32_t *out, float *src);
+extern void sameWidthPackedConversionSemantics(uint8_t *out, int32_t *ints, float *floats, float *squares32, double *squares64);
+extern void packedSingleToDouble(double *out, float *src);
+extern void conditionalMoveCodes(uint64_t *out, uint64_t *src);
+extern void fma3Semantics(uint8_t *out, double *a64, double *b64, double *c64, float *a32, float *b32, float *c32);
+extern void binaryFloatingSemantics(uint8_t *out, double *a64, double *b64, float *a32, float *b32);
+extern void horizontalFloatingSemantics(uint8_t *out, float *a32, float *b32, double *a64, double *b64);
+
+static uint16_t load16(const uint8_t *p) {
+	return (uint16_t)p[0] | (uint16_t)p[1] << 8;
+}
+static uint32_t load32(const uint8_t *p) {
+	return (uint32_t)load16(p) | (uint32_t)load16(p + 2) << 16;
+}
+static uint64_t load64(const uint8_t *p) {
+	return (uint64_t)load32(p) | (uint64_t)load32(p + 4) << 32;
+}
+static float loadf32(const uint8_t *p) {
+	union { uint32_t bits; float value; } converted = {load32(p)};
+	return converted.value;
+}
+static double loadf64(const uint8_t *p) {
+	union { uint64_t bits; double value; } converted = {load64(p)};
+	return converted.value;
+}
 
 static uint32_t shld32(uint32_t src, uint32_t dst, uint32_t count) {
 	count &= 31;
@@ -196,6 +600,77 @@ static uint64_t shrd64(uint64_t src, uint64_t dst, uint64_t count) {
 	count &= 63;
 	return count == 0 ? dst : (dst >> count) | (src << (64 - count));
 }
+static uint64_t rol(uint64_t value, unsigned bits, uint64_t count) {
+	uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+	count %= bits;
+	value &= mask;
+	return count == 0 ? value : ((value << count) | (value >> (bits - count))) & mask;
+}
+static uint64_t ror(uint64_t value, unsigned bits, uint64_t count) {
+	return rol(value, bits, bits - count % bits);
+}
+static uint64_t replace_low(uint64_t value, uint64_t low, unsigned bits) {
+	uint64_t mask = (UINT64_C(1) << bits) - 1;
+	return (value & ~mask) | (low & mask);
+}
+
+static uint64_t reference_scalar_add_sub(int add, unsigned bits, uint64_t value, uint64_t source,
+	int register_destination, uint64_t *flags) {
+	uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+	uint64_t destination_low = value & mask, source_low = source & mask;
+	uint64_t result_low = add ? (destination_low + source_low) & mask : (destination_low - source_low) & mask;
+	uint64_t carry = add ? result_low < destination_low : destination_low < source_low;
+	uint64_t sign_bit = UINT64_C(1) << (bits - 1);
+	uint64_t overflow = add
+		? ((~(destination_low ^ source_low) & (destination_low ^ result_low) & sign_bit) != 0)
+		: (((destination_low ^ source_low) & (destination_low ^ result_low) & sign_bit) != 0);
+	uint8_t low_byte = (uint8_t)result_low;
+	uint64_t parity = 1;
+	while (low_byte != 0) {
+		parity ^= 1;
+		low_byte &= low_byte - 1;
+	}
+	*flags = carry | overflow << 8 | (result_low == 0) << 16 |
+		((result_low & sign_bit) != 0) << 24 | parity << 32;
+	if (bits == 64 || (register_destination && bits == 32)) return result_low;
+	return (value & ~mask) | result_low;
+}
+
+static uint64_t reference_pdep(uint64_t mask, uint64_t source) {
+	uint64_t result = 0;
+	while (mask != 0) {
+		uint64_t lowest = mask & (0 - mask);
+		if (source & 1) result |= lowest;
+		source >>= 1;
+		mask &= mask - 1;
+	}
+	return result;
+}
+
+static uint64_t reference_pext(uint64_t mask, uint64_t source) {
+	uint64_t result = 0, output_bit = 1;
+	while (mask != 0) {
+		uint64_t lowest = mask & (0 - mask);
+		if (source & lowest) result |= output_bit;
+		output_bit <<= 1;
+		mask &= mask - 1;
+	}
+	return result;
+}
+
+static uint64_t reference_bit_test_register(int operation, unsigned bits, uint64_t value, uint64_t index, uint64_t *carry) {
+	uint64_t bit = index & (bits - 1);
+	*carry = (value >> bit) & 1;
+	if (operation == 0) return value;
+	uint64_t mask = UINT64_C(1) << bit;
+	uint64_t low = value;
+	if (operation == 1) low ^= mask;
+	if (operation == 2) low &= ~mask;
+	if (operation == 3) low |= mask;
+	if (bits == 16) return (value & ~UINT64_C(0xffff)) | (low & UINT64_C(0xffff));
+	if (bits == 32) return (uint32_t)low;
+	return low;
+}
 
 int main(void) {
 	uint8_t bytes[4] = {0x10, 0xf0, 0x5a, 0xa0};
@@ -265,6 +740,538 @@ int main(void) {
 					return 50 + i;
 		}
 	}
+	const uint64_t scalar_value = UINT64_C(0x8123456789abcdef);
+	const uint64_t word_dst = UINT64_C(0xfedcba9876543210);
+	for (uint64_t count = 0; count < 16; count++) {
+		uint64_t out[14] = {0}, want[14] = {0};
+		scalarShiftRotateSemantics(out, scalar_value, count);
+		uint64_t hardware_count = count & 31;
+		uint64_t byte_logical = hardware_count < 8 ? (uint8_t)scalar_value >> hardware_count : 0;
+		uint64_t byte_arithmetic = hardware_count < 8 ? (uint8_t)((int8_t)scalar_value >> hardware_count) : UINT8_MAX;
+		uint64_t word_count = count & 15;
+		uint16_t shldw = (uint16_t)word_dst, shrdw = (uint16_t)word_dst;
+		if (word_count != 0) {
+			shldw = (uint16_t)(((uint16_t)word_dst << word_count) | ((uint16_t)scalar_value >> (16 - word_count)));
+			shrdw = (uint16_t)(((uint16_t)word_dst >> word_count) | ((uint16_t)scalar_value << (16 - word_count)));
+		}
+		want[0] = replace_low(scalar_value, rol(scalar_value, 8, count), 8);
+		want[1] = replace_low(scalar_value, ror(scalar_value, 8, count), 8);
+		want[2] = replace_low(scalar_value, byte_arithmetic, 8);
+		want[3] = replace_low(scalar_value, byte_logical, 8);
+		want[4] = replace_low(scalar_value, rol(scalar_value, 16, count), 16);
+		want[5] = replace_low(scalar_value, (uint16_t)((int16_t)scalar_value >> hardware_count), 16);
+		want[6] = (uint32_t)scalar_value << hardware_count;
+		want[7] = ror(scalar_value, 64, count);
+		want[8] = replace_low(scalar_value, byte_logical, 8);
+		want[9] = replace_low(scalar_value, rol(scalar_value, 16, count), 16);
+		want[10] = replace_low(word_dst, shldw, 16);
+		want[11] = replace_low(word_dst, shrdw, 16);
+		want[12] = replace_low(scalar_value, (uint8_t)scalar_value << 3, 8);
+		want[13] = (uint32_t)((int32_t)scalar_value >> 3);
+		for (int i = 0; i < 14; i++)
+			if (out[i] != want[i]) return 196 + i;
+	}
+	const uint64_t inc_values[] = {0, 1, 0x7f, 0xff, 0xffff, 0xffffffff, UINT64_C(0x8123456789abcdef)};
+	for (unsigned v = 0; v < sizeof(inc_values) / sizeof(inc_values[0]); v++) {
+		uint64_t value = inc_values[v], out[12] = {0};
+		incDecSemantics(out, value);
+		uint64_t want[12] = {
+			replace_low(value, (uint8_t)value + 1, 8),
+			replace_low(value, (uint8_t)value - 1, 8),
+			replace_low(value, (uint16_t)value + 1, 16),
+			replace_low(value, (uint16_t)value - 1, 16),
+			(uint32_t)value + 1, (uint32_t)value - 1, value + 1, value - 1,
+			replace_low(value, (uint8_t)value + 1, 8),
+			replace_low(value, (uint16_t)value - 1, 16),
+			UINT64_C(0x0000000000010101), UINT64_C(0x0000000101000001),
+		};
+		for (int i = 0; i < 12; i++)
+			if (out[i] != want[i]) return 220 + i;
+	}
+	const uint64_t scalar_add_sub_cases[][2] = {
+		{0, 0}, {UINT64_MAX, 1}, {0x7f, 1}, {0x7fff, 1},
+		{0x7fffffff, 1}, {UINT64_C(0x7fffffffffffffff), 1},
+		{UINT64_C(0x8123456789abcdef), UINT64_C(0xfedcba9876543210)},
+	};
+	const unsigned scalar_add_sub_widths[] = {8, 16, 32, 64};
+	for (unsigned v = 0; v < sizeof(scalar_add_sub_cases) / sizeof(scalar_add_sub_cases[0]); v++) {
+		uint64_t value = scalar_add_sub_cases[v][0], source = scalar_add_sub_cases[v][1];
+		uint64_t out[16] = {0}, want[16] = {0};
+		scalarAddSubSemantics(out, value, source);
+		for (unsigned width_index = 0; width_index < 4; width_index++) {
+			unsigned bits = scalar_add_sub_widths[width_index];
+			want[width_index * 4] = reference_scalar_add_sub(1, bits, value, source, 1, &want[width_index * 4 + 1]);
+			want[width_index * 4 + 2] = reference_scalar_add_sub(0, bits, value, UINT64_MAX, 0, &want[width_index * 4 + 3]);
+		}
+		for (int i = 0; i < 16; i++)
+			if (out[i] != want[i]) return 232 + i;
+	}
+	const uint64_t cmpxchg_expected_values[] = {
+		0, UINT64_MAX, 0x7f, 0x7fff, 0x7fffffff,
+		UINT64_C(0x7fffffffffffffff), UINT64_C(0x8123456789abcdef),
+	};
+	const uint64_t cmpxchg_desired = UINT64_C(0xfedcba9876543210);
+	for (unsigned v = 0; v < sizeof(cmpxchg_expected_values) / sizeof(cmpxchg_expected_values[0]); v++) {
+		uint64_t expected = cmpxchg_expected_values[v], memory[8] = {0}, initial[8] = {0};
+		uint64_t out[24] = {0}, want[24] = {0};
+		for (unsigned width_index = 0; width_index < 4; width_index++) {
+			unsigned bits = scalar_add_sub_widths[width_index];
+			uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+			uint64_t base = UINT64_C(0xa5a5a5a5a5a5a5a5) & ~mask;
+			memory[width_index * 2] = base | (expected & mask);
+			memory[width_index * 2 + 1] = base | ((expected ^ (UINT64_C(1) << (bits - 1))) & mask);
+			initial[width_index * 2] = memory[width_index * 2];
+			initial[width_index * 2 + 1] = memory[width_index * 2 + 1];
+		}
+		compareExchangeScalarSemantics(out, memory, expected, cmpxchg_desired);
+		for (unsigned width_index = 0; width_index < 4; width_index++) {
+			unsigned bits = scalar_add_sub_widths[width_index];
+			uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+			uint64_t success_initial = initial[width_index * 2];
+			uint64_t failure_initial = initial[width_index * 2 + 1];
+			unsigned output_index = width_index * 6;
+			want[output_index] = (success_initial & ~mask) | (cmpxchg_desired & mask);
+			want[output_index + 1] = expected;
+			reference_scalar_add_sub(0, bits, success_initial, expected, 1, &want[output_index + 2]);
+			want[output_index + 3] = failure_initial;
+			if (bits == 8 || bits == 16) want[output_index + 4] = (expected & ~mask) | (failure_initial & mask);
+			if (bits == 32) want[output_index + 4] = (uint32_t)failure_initial;
+			if (bits == 64) want[output_index + 4] = failure_initial;
+			reference_scalar_add_sub(0, bits, expected, failure_initial, 1, &want[output_index + 5]);
+		}
+		for (int i = 0; i < 24; i++)
+			if (out[i] != want[i]) return 248 + i;
+	}
+	const uint64_t cmpxchg_expected_low = UINT64_C(0xaaaaaaaa11223344);
+	const uint64_t cmpxchg_expected_high = UINT64_C(0xbbbbbbbb55667788);
+	const uint64_t cmpxchg_desired_low = UINT64_C(0x0123456789abcdef);
+	const uint64_t cmpxchg_desired_high = UINT64_C(0xfedcba9876543210);
+	for (int success = 0; success <= 1; success++) {
+		_Alignas(16) uint64_t memory[4] = {0}, out[9] = {0}, want[9] = {0};
+		if (success) {
+			memory[0] = cmpxchg_expected_low;
+			memory[1] = cmpxchg_expected_high;
+			memory[2] = (cmpxchg_expected_low & UINT32_MAX) | (cmpxchg_expected_high & UINT32_MAX) << 32;
+		} else {
+			memory[0] = UINT64_C(0x1020304050607080);
+			memory[1] = UINT64_C(0x90a0b0c0d0e0f001);
+			memory[2] = UINT64_C(0x8877665544332211);
+		}
+		uint64_t old16_low = memory[0], old16_high = memory[1], old8 = memory[2];
+		compareExchangePairSemantics(out, memory, cmpxchg_expected_low, cmpxchg_expected_high,
+			cmpxchg_desired_low, cmpxchg_desired_high);
+		if (success) {
+			want[0] = (cmpxchg_desired_low & UINT32_MAX) | (cmpxchg_desired_high & UINT32_MAX) << 32;
+			want[1] = cmpxchg_expected_low;
+			want[2] = cmpxchg_expected_high;
+			want[3] = 1;
+			want[4] = cmpxchg_desired_low;
+			want[5] = cmpxchg_desired_high;
+			want[6] = cmpxchg_expected_low;
+			want[7] = cmpxchg_expected_high;
+			want[8] = 1;
+		} else {
+			want[0] = old8;
+			want[1] = (uint32_t)old8;
+			want[2] = (uint32_t)(old8 >> 32);
+			want[4] = old16_low;
+			want[5] = old16_high;
+			want[6] = old16_low;
+			want[7] = old16_high;
+		}
+		for (int i = 0; i < 9; i++)
+			if (out[i] != want[i]) return 272 + i;
+	}
+	const uint64_t parallel_cases[][2] = {
+		{0, UINT64_C(0x0123456789abcdef)},
+		{UINT64_MAX, UINT64_C(0x0123456789abcdef)},
+		{UINT64_C(0xaaaaaaaaaaaaaaaa), UINT64_C(0x0123456789abcdef)},
+		{UINT64_C(0x8040201008040201), UINT64_C(0xfedcba9876543210)},
+		{UINT64_C(0x8000000100000081), UINT64_MAX},
+	};
+	for (unsigned v = 0; v < sizeof(parallel_cases) / sizeof(parallel_cases[0]); v++) {
+		uint64_t mask = parallel_cases[v][0], source = parallel_cases[v][1], out[8] = {0};
+		parallelBitSemantics(out, mask, source);
+		uint64_t mask32 = (uint32_t)mask, source32 = (uint32_t)source;
+		uint64_t want[8] = {
+			reference_pdep(mask, source), reference_pdep(mask, source),
+			reference_pext(mask, source), reference_pext(mask, source),
+			reference_pdep(mask32, source32), reference_pdep(mask32, source32),
+			reference_pext(mask32, source32), reference_pext(mask32, source32),
+		};
+		for (int i = 0; i < 8; i++)
+			if (out[i] != want[i]) return 124;
+	}
+	const uint64_t bit_test_value = UINT64_C(0xfedcba9876543210);
+	const uint64_t bit_test_index = 21;
+	uint64_t bit_test_out[24] = {0};
+	bitTestRegisterSemantics(bit_test_out, bit_test_value, bit_test_index);
+	const unsigned bit_test_widths[3] = {16, 32, 64};
+	for (int width_index = 0; width_index < 3; width_index++) {
+		unsigned bits = bit_test_widths[width_index];
+		for (int operation = 0; operation < 4; operation++) {
+			uint64_t operand_index = bit_test_index;
+			if (operation == 0) operand_index = bits - 1;
+			if (operation == 2) operand_index = 4;
+			uint64_t carry = 0;
+			uint64_t result = reference_bit_test_register(operation, bits, bit_test_value, operand_index, &carry);
+			int output_index = 2 * (width_index * 4 + operation);
+			if (bit_test_out[output_index] != result || bit_test_out[output_index + 1] != carry) return 125;
+		}
+	}
+	uint64_t bit_test_data[9] = {
+		UINT64_MAX, UINT64_C(1) << 17, 0,
+		UINT64_MAX, UINT64_C(1) << 33, 0,
+		UINT64_MAX, 0, UINT64_C(1) << 1,
+	};
+	uint8_t bit_test_carry[12] = {0};
+	bitTestMemorySemantics(bit_test_carry, bit_test_data);
+	const uint8_t bit_test_want_carry[12] = {1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0};
+	const uint64_t bit_test_want_data[9] = {
+		UINT64_C(0x7fffffffffffffff), 1, 0,
+		UINT64_C(0x7fffffffffffffff), 1, 0,
+		UINT64_C(0x7fffffffffffffff), 1, 0,
+	};
+	for (int i = 0; i < 12; i++)
+		if (bit_test_carry[i] != bit_test_want_carry[i]) return 126;
+	for (int i = 0; i < 9; i++)
+		if (bit_test_data[i] != bit_test_want_data[i]) return 127;
+	int16_t word_madd_a[16] = {
+		INT16_MIN, INT16_MIN, -30000, -1, 0, 1, 12345, INT16_MAX,
+		7, -11, 1000, -2000, 22222, -12345, INT16_MAX, INT16_MAX,
+	};
+	int16_t word_madd_b[16] = {
+		INT16_MIN, INT16_MIN, -23456, INT16_MAX, -1, INT16_MAX, -2345, INT16_MAX,
+		-9, 13, -3000, 4000, -11111, 23456, INT16_MAX, INT16_MAX,
+	};
+	int32_t word_madd_out[18] = {0}, word_madd_reference[8] = {0}, word_madd_want[18] = {0};
+	for (int i = 0; i < 8; i++) {
+		int64_t sum = (int64_t)word_madd_a[2*i] * word_madd_b[2*i] +
+			(int64_t)word_madd_a[2*i+1] * word_madd_b[2*i+1];
+		word_madd_reference[i] = (int32_t)(uint32_t)sum;
+	}
+	for (int i = 0; i < 2; i++) word_madd_want[i] = word_madd_reference[i];
+	for (int i = 0; i < 4; i++) {
+		word_madd_want[2+i] = word_madd_reference[i];
+		word_madd_want[6+i] = word_madd_reference[i];
+	}
+	for (int i = 0; i < 8; i++) word_madd_want[10+i] = word_madd_reference[i];
+	packedWordMultiplyAddSemantics(word_madd_out, word_madd_a, word_madd_b);
+	for (int i = 0; i < 18; i++)
+		if (word_madd_out[i] != word_madd_want[i]) return 128;
+	int8_t byte_madd_signed[32] = {
+		127, 127, -128, -128, 100, -100, 1, -1,
+		64, -64, 11, 12, -13, 14, 15, -16,
+		31, -32, 33, -34, 35, -36, 37, -38,
+		39, -40, 41, -42, 43, -44, 45, -46,
+	};
+	uint8_t byte_madd_unsigned[32] = {
+		255, 255, 255, 255, 200, 3, 255, 128,
+		250, 249, 17, 19, 23, 29, 31, 37,
+		41, 43, 47, 53, 59, 61, 67, 71,
+		73, 79, 83, 89, 97, 101, 103, 107,
+	};
+	int16_t byte_madd_out[32] = {0}, byte_madd_reference[16] = {0}, byte_madd_want[32] = {0};
+	for (int i = 0; i < 16; i++) {
+		int32_t sum = (int32_t)byte_madd_signed[2*i] * byte_madd_unsigned[2*i] +
+			(int32_t)byte_madd_signed[2*i+1] * byte_madd_unsigned[2*i+1];
+		if (sum > INT16_MAX) sum = INT16_MAX;
+		if (sum < INT16_MIN) sum = INT16_MIN;
+		byte_madd_reference[i] = (int16_t)sum;
+	}
+	for (int i = 0; i < 8; i++) {
+		byte_madd_want[i] = byte_madd_reference[i];
+		byte_madd_want[8+i] = byte_madd_reference[i];
+	}
+	for (int i = 0; i < 16; i++) byte_madd_want[16+i] = byte_madd_reference[i];
+	packedUnsignedSignedByteMultiplyAddSemantics(byte_madd_out, byte_madd_signed, byte_madd_unsigned);
+	for (int i = 0; i < 32; i++)
+		if (byte_madd_out[i] != byte_madd_want[i]) return 129;
+	int8_t dot_signed_bytes[64];
+	uint8_t dot_unsigned_bytes[64];
+	int16_t dot_words_a[32], dot_words_b[32];
+	int32_t dot_accumulator[16], dot_out[64] = {0};
+	for (int i = 0; i < 64; i++) {
+		dot_signed_bytes[i] = (i / 4) & 1 ? -128 : 127;
+		dot_unsigned_bytes[i] = (uint8_t)(255 - (i & 3));
+	}
+	for (int i = 0; i < 32; i++) {
+		dot_words_a[i] = (i / 2) & 1 ? INT16_MIN : INT16_MAX;
+		dot_words_b[i] = (i & 1) ? INT16_MAX : INT16_MIN;
+	}
+	for (int i = 0; i < 16; i++) {
+		switch (i & 3) {
+		case 0: dot_accumulator[i] = INT32_MAX - 10; break;
+		case 1: dot_accumulator[i] = INT32_MIN + 10; break;
+		case 2: dot_accumulator[i] = 123456789; break;
+		default: dot_accumulator[i] = -987654321; break;
+		}
+	}
+	packedDotProductSemantics(dot_out, dot_signed_bytes, dot_unsigned_bytes, dot_words_a, dot_words_b, dot_accumulator);
+	for (int lane = 0; lane < 16; lane++) {
+		int64_t byte_sum = dot_accumulator[lane];
+		for (int item = 0; item < 4; item++) byte_sum += (int64_t)dot_signed_bytes[4*lane+item] * dot_unsigned_bytes[4*lane+item];
+		int64_t byte_sat = byte_sum;
+		if (byte_sat > INT32_MAX) byte_sat = INT32_MAX;
+		if (byte_sat < INT32_MIN) byte_sat = INT32_MIN;
+		int64_t word_sum = dot_accumulator[lane];
+		for (int item = 0; item < 2; item++) word_sum += (int64_t)dot_words_a[2*lane+item] * dot_words_b[2*lane+item];
+		int64_t word_sat = word_sum;
+		if (word_sat > INT32_MAX) word_sat = INT32_MAX;
+		if (word_sat < INT32_MIN) word_sat = INT32_MIN;
+		if ((uint32_t)dot_out[lane] != (uint32_t)byte_sum) return 930 + lane;
+		if (dot_out[16+lane] != (int32_t)byte_sat) return 950 + lane;
+		if ((uint32_t)dot_out[32+lane] != (uint32_t)word_sum) return 970 + lane;
+		if (dot_out[48+lane] != (int32_t)word_sat) return 990 + lane;
+	}
+	uint8_t minmax_a[64], minmax_b[64], minmax_out[1024] = {0};
+	for (int i = 0; i < 64; i++) {
+		minmax_a[i] = (uint8_t)(0x80 + 73*i);
+		minmax_b[i] = (uint8_t)(0xff - 29*i);
+	}
+	packedIntegerMinMaxSemantics(minmax_out, minmax_a, minmax_b);
+	for (int lane = 0; lane < 64; lane++) {
+		int8_t a = (int8_t)minmax_a[lane], b = (int8_t)minmax_b[lane];
+		if ((int8_t)minmax_out[lane] != (a < b ? a : b)) return 1010 + lane;
+		if (minmax_out[64+lane] != (minmax_a[lane] < minmax_b[lane] ? minmax_a[lane] : minmax_b[lane])) return 1080 + lane;
+		if ((int8_t)minmax_out[128+lane] != (a > b ? a : b)) return 1150 + lane;
+		if (minmax_out[192+lane] != (minmax_a[lane] > minmax_b[lane] ? minmax_a[lane] : minmax_b[lane])) return 1220 + lane;
+	}
+	for (int lane = 0; lane < 32; lane++) {
+		uint16_t au = load16(minmax_a + 2*lane), bu = load16(minmax_b + 2*lane);
+		int16_t as = (int16_t)au, bs = (int16_t)bu;
+		if ((int16_t)load16(minmax_out + 256 + 2*lane) != (as < bs ? as : bs)) return 1290 + lane;
+		if (load16(minmax_out + 320 + 2*lane) != (au < bu ? au : bu)) return 1330 + lane;
+		if ((int16_t)load16(minmax_out + 384 + 2*lane) != (as > bs ? as : bs)) return 1370 + lane;
+		if (load16(minmax_out + 448 + 2*lane) != (au > bu ? au : bu)) return 1410 + lane;
+	}
+	for (int lane = 0; lane < 16; lane++) {
+		uint32_t au = load32(minmax_a + 4*lane), bu = load32(minmax_b + 4*lane);
+		int32_t as = (int32_t)au, bs = (int32_t)bu;
+		if ((int32_t)load32(minmax_out + 512 + 4*lane) != (as < bs ? as : bs)) return 1450 + lane;
+		if (load32(minmax_out + 576 + 4*lane) != (au < bu ? au : bu)) return 1470 + lane;
+		if ((int32_t)load32(minmax_out + 640 + 4*lane) != (as > bs ? as : bs)) return 1490 + lane;
+		if (load32(minmax_out + 704 + 4*lane) != (au > bu ? au : bu)) return 1510 + lane;
+	}
+	for (int lane = 0; lane < 8; lane++) {
+		uint64_t au = load64(minmax_a + 8*lane), bu = load64(minmax_b + 8*lane);
+		int64_t as = (int64_t)au, bs = (int64_t)bu;
+		if ((int64_t)load64(minmax_out + 768 + 8*lane) != (as < bs ? as : bs)) return 1530 + lane;
+		if (load64(minmax_out + 832 + 8*lane) != (au < bu ? au : bu)) return 1540 + lane;
+		if ((int64_t)load64(minmax_out + 896 + 8*lane) != (as > bs ? as : bs)) return 1550 + lane;
+		if (load64(minmax_out + 960 + 8*lane) != (au > bu ? au : bu)) return 1560 + lane;
+	}
+	int16_t word_a[8] = {INT16_MIN, INT16_MIN, -30000, -1, 0, 1, 12345, INT16_MAX};
+	int16_t word_b[8] = {INT16_MIN, INT16_MAX, -23456, INT16_MAX, -1, INT16_MAX, -2345, INT16_MAX};
+	uint16_t word_mul_out[64] = {0}, word_mul_want[64] = {0};
+	packedWordMultiplySemantics(word_mul_out, word_a, word_b);
+	for (int i = 0; i < 8; i++) {
+		int32_t product = (int32_t)word_a[i] * (int32_t)word_b[i];
+		uint32_t unsigned_product = (uint32_t)(uint16_t)word_a[i] * (uint32_t)(uint16_t)word_b[i];
+		int32_t rounded = (product + 0x4000) >> 15;
+		uint16_t values[4] = {(uint16_t)product, (uint16_t)(product >> 16), (uint16_t)(unsigned_product >> 16), (uint16_t)rounded};
+		for (int mode = 0; mode < 4; mode++) {
+			word_mul_want[mode*8+i] = values[mode];
+			word_mul_want[(mode+4)*8+i] = values[mode];
+		}
+	}
+	for (int i = 0; i < 64; i++)
+		if (word_mul_out[i] != word_mul_want[i]) return 240 + i;
+	uint32_t shuffle_a[8], shuffle_b[8];
+	uint8_t shuffle_out[96] = {0};
+	for (int i = 0; i < 8; i++) {
+		shuffle_a[i] = 0xa0 + i;
+		shuffle_b[i] = 0xb0 + i;
+	}
+	packedFloatShuffleSemantics(shuffle_out, (uint8_t *)shuffle_a, (uint8_t *)shuffle_b);
+	const uint32_t shuffle_ps[12] = {
+		0xb3, 0xb2, 0xa1, 0xa0,
+		0xb3, 0xb2, 0xa1, 0xa0,
+		0xb7, 0xb6, 0xa5, 0xa4,
+	};
+	for (int i = 0; i < 4; i++)
+		if (load32(shuffle_out + 4*i) != shuffle_ps[i]) return 310 + i;
+	if (load64(shuffle_out + 16) != UINT64_C(0x000000b1000000b0) ||
+		load64(shuffle_out + 24) != UINT64_C(0x000000a3000000a2)) return 314;
+	for (int i = 0; i < 8; i++)
+		if (load32(shuffle_out + 32 + 4*i) != shuffle_ps[4+i]) return 315 + i;
+	const uint64_t shuffle_pd[4] = {
+		UINT64_C(0x000000b1000000b0), UINT64_C(0x000000a3000000a2),
+		UINT64_C(0x000000b5000000b4), UINT64_C(0x000000a7000000a6),
+	};
+	for (int i = 0; i < 4; i++)
+		if (load64(shuffle_out + 64 + 8*i) != shuffle_pd[i]) return 323 + i;
+	uint32_t in_lane_data[8] = {0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107};
+	uint32_t in_lane_control[8] = {3, 2, 1, 0, 4, 5, 6, 7};
+	uint8_t in_lane_out[144] = {0};
+	inLaneFloatingPermuteSemantics(in_lane_out, (uint8_t *)in_lane_data, (uint8_t *)in_lane_control);
+	for (int lane = 0; lane < 4; lane++)
+		if (load32(in_lane_out + 4*lane) != in_lane_data[3-lane]) return 324;
+	for (int lane = 0; lane < 8; lane++) {
+		uint32_t immediate_value = in_lane_data[(lane/4)*4 + 3-(lane%4)];
+		uint32_t variable_value = in_lane_data[(lane/4)*4 + (in_lane_control[lane]&3)];
+		if (load32(in_lane_out + 16 + 4*lane) != immediate_value) return 325;
+		if (load32(in_lane_out + 48 + 4*lane) != variable_value) return 326;
+	}
+	for (int lane = 0; lane < 4; lane++) {
+		uint64_t data_q[4], control_q[4];
+		for (int i = 0; i < 4; i++) {
+			data_q[i] = (uint64_t)in_lane_data[2*i] | (uint64_t)in_lane_data[2*i+1] << 32;
+			control_q[i] = (uint64_t)in_lane_control[2*i] | (uint64_t)in_lane_control[2*i+1] << 32;
+		}
+		uint64_t immediate_value = data_q[(lane/2)*2 + ((0x05 >> lane)&1)];
+		uint64_t variable_value = data_q[(lane/2)*2 + ((control_q[lane] >> 1)&1)];
+		if (load64(in_lane_out + 80 + 8*lane) != immediate_value) return 327;
+		if (load64(in_lane_out + 112 + 8*lane) != variable_value) return 328;
+	}
+	uint8_t blend_a[32], blend_b[32], blend_out[240] = {0};
+	for (int i = 0; i < 32; i++) {
+		blend_a[i] = (uint8_t)(0x20 + i);
+		blend_b[i] = (uint8_t)(0xc0 + i);
+	}
+	immediatePackedBlendSemantics(blend_out, blend_a, blend_b);
+	const int blend_offsets[11] = {0, 16, 32, 48, 64, 96, 112, 144, 160, 192, 208};
+	const int blend_widths[11] = {16, 16, 16, 16, 32, 16, 32, 16, 32, 16, 32};
+	const int blend_lane_bytes[11] = {2, 4, 8, 2, 2, 4, 4, 4, 4, 8, 8};
+	for (int block = 0; block < 11; block++) {
+		for (int i = 0; i < blend_widths[block]; i++) {
+			int bit = (i / blend_lane_bytes[block]) % 8;
+			uint8_t want = (0xa5 & (1 << bit)) ? blend_a[i] : blend_b[i];
+			if (blend_out[blend_offsets[block] + i] != want) return 327 + block;
+		}
+	}
+	uint8_t unpack_out[384] = {0};
+	packedUnpackSemantics(unpack_out, blend_a, blend_b);
+	const int unpack_offsets[16] = {0,16,32,48,64,80,96,112,128,160,192,224,256,288,320,352};
+	const int unpack_widths[16] = {16,16,16,16,16,16,16,16,32,32,32,32,32,32,32,32};
+	const int unpack_lane_bytes[16] = {1,1,2,2,4,4,8,8,1,1,2,2,4,4,8,8};
+	for (int block = 0; block < 16; block++) {
+		int output = unpack_offsets[block];
+		int high = block & 1;
+		for (int group = 0; group < unpack_widths[block]; group += 16) {
+			int lanes_per_group = 16 / unpack_lane_bytes[block];
+			int start = high ? lanes_per_group / 2 : 0;
+			for (int lane = start; lane < start + lanes_per_group / 2; lane++) {
+				int input = group + lane * unpack_lane_bytes[block];
+				for (int byte = 0; byte < unpack_lane_bytes[block]; byte++) {
+					if (unpack_out[output++] != blend_b[input + byte]) return 338 + block;
+				}
+				for (int byte = 0; byte < unpack_lane_bytes[block]; byte++) {
+					if (unpack_out[output++] != blend_a[input + byte]) return 354 + block;
+				}
+			}
+		}
+	}
+	uint64_t permute_data[4] = {0x10, 0x21, 0x32, 0x43};
+	uint64_t permute_control[4] = {3, 0, 5, 2};
+	uint64_t permute_out[8] = {0}, variable_permute_out[8] = {0};
+	const uint64_t permute_immediate[4] = {0x10, 0x32, 0x21, 0x43};
+	const uint64_t permute_variable[4] = {0x43, 0x10, 0x21, 0x32};
+	qwordPermuteSemantics(permute_out, permute_data);
+	qwordVariablePermuteSemantics(variable_permute_out, permute_data, permute_control);
+	for (int block = 0; block < 2; block++) {
+		for (int lane = 0; lane < 4; lane++)
+			if (permute_out[4*block+lane] != permute_immediate[lane]) return 370 + block;
+	}
+	for (int block = 0; block < 2; block++) {
+		for (int lane = 0; lane < 4; lane++)
+			if (variable_permute_out[4*block+lane] != permute_variable[lane]) return 372 + block;
+	}
+	_Alignas(64) uint8_t move_src[64], move_old[64];
+	uint8_t move_vex_out[128] = {0};
+	for (int i = 0; i < 64; i++) {
+		move_src[i] = (uint8_t)(3 + 17*i);
+		move_old[i] = (uint8_t)(0xf0 - 3*i);
+	}
+	packedFloatMoveVEXSemantics(move_vex_out, move_src);
+	for (int block = 0; block < 4; block++)
+		for (int i = 0; i < 32; i++)
+			if (move_vex_out[32*block+i] != move_src[i]) return 374 + block;
+#if PLAN9ASM_CONFORMANCE_NATIVE_WIDE
+	// X stores need 16-byte alignment. Z stores at offsets 432 and 624
+	// need a base congruent to 16 modulo 64, not a 64-aligned base itself.
+	_Alignas(64) uint8_t move_mask_storage[768];
+	for (int i = 0; i < 768; i++) move_mask_storage[i] = 0xa7;
+	uint8_t *move_mask_out = move_mask_storage + 16;
+	packedFloatMoveMaskSemantics(move_mask_out, move_src, move_old);
+	for (int i = 0; i < 16; i++)
+		if (move_mask_storage[i] != 0xa7) return 950;
+	for (int i = 704; i < 768; i++)
+		if (move_mask_storage[i] != 0xa7) return 951;
+	const int move_offsets[14] = {0,16,32,48,64,80,96,112,144,176,208,240,272,304};
+	const int move_widths[14] = {16,16,16,16,16,16,16,32,32,32,32,32,32,64};
+	const int move_lane_bytes[14] = {4,4,4,4,8,8,8,4,4,4,8,8,8,4};
+	const int move_zero[14] = {0,1,0,0,0,1,0,0,1,0,0,1,0,0};
+	for (int block = 0; block < 14; block++) {
+		for (int i = 0; i < move_widths[block]; i++) {
+			int active = (0xa55a >> (i / move_lane_bytes[block])) & 1;
+			uint8_t want = active ? move_src[i] : (move_zero[block] ? 0 : move_old[i]);
+			if (move_mask_out[move_offsets[block]+i] != want) return 378 + block;
+		}
+	}
+	const int move_z_offsets[5] = {368,432,496,560,624};
+	const int move_z_lane_bytes[5] = {4,4,8,8,8};
+	const int move_z_zero[5] = {1,0,0,1,0};
+	for (int block = 0; block < 5; block++) {
+		for (int i = 0; i < 64; i++) {
+			int active = (0xa55a >> (i / move_z_lane_bytes[block])) & 1;
+			uint8_t want = active ? move_src[i] : (move_z_zero[block] ? 0 : move_old[i]);
+			if (move_mask_out[move_z_offsets[block]+i] != want) return 392 + block;
+		}
+	}
+#endif
+	uint8_t extend_src[32] = {
+		0x00,0x01,0x7f,0x80,0xff,0x55,0xaa,0x40,
+		0xc0,0x11,0xee,0x33,0xcc,0x66,0x99,0x22,
+		0xdd,0x44,0xbb,0x77,0x88,0x10,0xf0,0x20,
+		0xe0,0x30,0xd0,0x50,0xb0,0x60,0xa0,0x70,
+	};
+	uint8_t extend_vex_out[288] = {0};
+	const int extend_input_bits[6] = {8,8,8,16,16,32};
+	const int extend_output_bits[6] = {16,32,64,32,64,64};
+	packedSignExtendMoveVEXSemantics(extend_vex_out, extend_src);
+	for (int op = 0; op < 6; op++) {
+		for (int form = 0; form < 2; form++) {
+			int width = form ? 32 : 16;
+			int offset = form ? 96 + 32*op : 16*op;
+			int lanes = width * 8 / extend_output_bits[op];
+			for (int lane = 0; lane < lanes; lane++) {
+				const uint8_t *p = extend_src + lane * extend_input_bits[op] / 8;
+				int64_t expected = extend_input_bits[op] == 8 ? (int64_t)(int8_t)p[0] :
+					extend_input_bits[op] == 16 ? (int64_t)(int16_t)load16(p) : (int64_t)(int32_t)load32(p);
+				const uint8_t *actual = extend_vex_out + offset + lane * extend_output_bits[op] / 8;
+				uint64_t actual_bits = extend_output_bits[op] == 16 ? load16(actual) :
+					extend_output_bits[op] == 32 ? load32(actual) : load64(actual);
+				uint64_t mask = extend_output_bits[op] == 16 ? UINT64_C(0xffff) :
+					extend_output_bits[op] == 32 ? UINT64_C(0xffffffff) : UINT64_MAX;
+				if (actual_bits != ((uint64_t)expected & mask)) return 397 + op;
+			}
+		}
+	}
+	uint8_t extend_old[64], extend_mask_out[768] = {0};
+	for (int i = 0; i < 64; i++) extend_old[i] = (uint8_t)(0xe7 - 5*i);
+	packedSignExtendMoveMaskSemantics(extend_mask_out, extend_src, extend_old);
+	for (int op = 0; op < 6; op++) {
+		int lanes = 512 / extend_output_bits[op];
+		for (int zero = 0; zero < 2; zero++) {
+			int offset = 128*op + 64*zero;
+			for (int lane = 0; lane < lanes; lane++) {
+				const uint8_t *input = extend_src + lane * extend_input_bits[op] / 8;
+				int64_t extended = extend_input_bits[op] == 8 ? (int64_t)(int8_t)input[0] :
+					extend_input_bits[op] == 16 ? (int64_t)(int16_t)load16(input) : (int64_t)(int32_t)load32(input);
+				const uint8_t *actual = extend_mask_out + offset + lane * extend_output_bits[op] / 8;
+				uint64_t actual_bits = extend_output_bits[op] == 16 ? load16(actual) :
+					extend_output_bits[op] == 32 ? load32(actual) : load64(actual);
+				const uint8_t *old = extend_old + lane * extend_output_bits[op] / 8;
+				uint64_t old_bits = extend_output_bits[op] == 16 ? load16(old) :
+					extend_output_bits[op] == 32 ? load32(old) : load64(old);
+				uint64_t width_mask = extend_output_bits[op] == 16 ? UINT64_C(0xffff) :
+					extend_output_bits[op] == 32 ? UINT64_C(0xffffffff) : UINT64_MAX;
+				uint64_t expected = (UINT64_C(0xa55aa55a) >> lane) & 1 ? (uint64_t)extended & width_mask : (zero ? 0 : old_bits);
+				if (actual_bits != expected) return 403 + op;
+			}
+		}
+	}
 	uint8_t a[16], b[16], vector_out[160] = {0};
 	const uint8_t or_mask[16] = {
 		0x80, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
@@ -310,10 +1317,321 @@ int main(void) {
 	packedArithmeticShift32(packed_out, packed_src);
 	for (int i = 0; i < 8; i++)
 		if (packed_out[i] != packed_want[i]) return 80 + i;
+
+	uint8_t subtract_a[16] = {0x7f, 0x80, 0x64, 0x9c, 0x32, 0xce, 0x00, 0x01, 0xff, 0x00, 0x34, 0x12, 0x00, 0x80, 0xff, 0x7f};
+	uint8_t subtract_b[16] = {0xff, 0x01, 0x9c, 0x64, 0xce, 0x32, 0x01, 0x00, 0x01, 0xff, 0x78, 0x56, 0xff, 0x7f, 0x01, 0x80};
+	uint8_t subtract_out[80] = {0};
+	packedSubtractSemantics(subtract_out, subtract_a, subtract_b);
+	for (int i = 0; i < 16; i++) {
+		int signed_value = (int)(int8_t)subtract_a[i] - (int)(int8_t)subtract_b[i];
+		if (signed_value < -128) signed_value = -128;
+		if (signed_value > 127) signed_value = 127;
+		if (subtract_out[i] != (uint8_t)(int8_t)signed_value) return 190;
+		int unsigned_value = (int)subtract_a[i] - (int)subtract_b[i];
+		if (unsigned_value < 0) unsigned_value = 0;
+		if (subtract_out[32+i] != (uint8_t)unsigned_value) return 191;
+	}
+	for (int i = 0; i < 8; i++) {
+		int signed_value = (int)(int16_t)load16(subtract_a + 2*i) - (int)(int16_t)load16(subtract_b + 2*i);
+		if (signed_value < -32768) signed_value = -32768;
+		if (signed_value > 32767) signed_value = 32767;
+		if (load16(subtract_out + 16 + 2*i) != (uint16_t)(int16_t)signed_value) return 192;
+		int unsigned_value = (int)load16(subtract_a + 2*i) - (int)load16(subtract_b + 2*i);
+		if (unsigned_value < 0) unsigned_value = 0;
+		if (load16(subtract_out + 48 + 2*i) != (uint16_t)unsigned_value) return 193;
+	}
+	for (int i = 0; i < 2; i++)
+		if (load64(subtract_out + 64 + 8*i) != load64(subtract_a + 8*i) - load64(subtract_b + 8*i)) return 194;
+
+	uint8_t ecosystem_a[16] = {
+		0x00, 0x7f, 0x80, 0xff, 0x34, 0x12, 0xfe, 0xff,
+		0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x00, 0x80,
+	};
+	uint8_t ecosystem_b[16] = {
+		0xff, 0x80, 0x7f, 0x00, 0x78, 0x56, 0x02, 0x00,
+		0xef, 0xcd, 0xab, 0x90, 0xff, 0xff, 0xff, 0x7f,
+	};
+	uint8_t ecosystem_out[816] = {0};
+	expandedEcosystemVectors(ecosystem_out, ecosystem_a, ecosystem_b);
+	for (int i = 0; i < 16; i++) {
+		uint8_t min_u = ecosystem_a[i] < ecosystem_b[i] ? ecosystem_a[i] : ecosystem_b[i];
+		uint8_t max_u = ecosystem_a[i] > ecosystem_b[i] ? ecosystem_a[i] : ecosystem_b[i];
+		int8_t as = (int8_t)ecosystem_a[i], bs = (int8_t)ecosystem_b[i];
+		if (ecosystem_out[i] != min_u || ecosystem_out[16+i] != (uint8_t)(as < bs ? as : bs)) return 100;
+		if (ecosystem_out[96+i] != max_u || ecosystem_out[112+i] != (uint8_t)(as > bs ? as : bs)) return 101;
+	}
+	for (int i = 0; i < 8; i++) {
+		uint16_t au = load16(ecosystem_a + 2*i), bu = load16(ecosystem_b + 2*i);
+		int16_t as = (int16_t)au, bs = (int16_t)bu;
+		if (load16(ecosystem_out + 32 + 2*i) != (au < bu ? au : bu)) return 102;
+		if ((int16_t)load16(ecosystem_out + 48 + 2*i) != (as < bs ? as : bs)) return 103;
+		if (load16(ecosystem_out + 128 + 2*i) != (au > bu ? au : bu)) return 104;
+		if ((int16_t)load16(ecosystem_out + 144 + 2*i) != (as > bs ? as : bs)) return 105;
+	}
+	for (int i = 0; i < 4; i++) {
+		uint32_t au = load32(ecosystem_a + 4*i), bu = load32(ecosystem_b + 4*i);
+		int32_t as = (int32_t)au, bs = (int32_t)bu;
+		if (load32(ecosystem_out + 64 + 4*i) != (au < bu ? au : bu)) return 106;
+		if ((int32_t)load32(ecosystem_out + 80 + 4*i) != (as < bs ? as : bs)) return 107;
+		if (load32(ecosystem_out + 160 + 4*i) != (au > bu ? au : bu)) return 108;
+		if ((int32_t)load32(ecosystem_out + 176 + 4*i) != (as > bs ? as : bs)) return 109;
+	}
+	for (int i = 0; i < 2; i++)
+		if (load64(ecosystem_out + 192 + 8*i) != (load64(ecosystem_a + 8*i) << 13)) return 110;
+	for (int i = 208; i < 224; i++)
+		if (ecosystem_out[i] != 0) return 111;
+	if (load64(ecosystem_out + 224) != 0x0123456789abcdefULL) return 112;
+	if (load64(ecosystem_out + 232) != 0x0000000089abcdefULL) return 113;
+	if (load32(ecosystem_out + 240) != 0x89abcdefU) return 119;
+	for (int i = 244; i < 256; i++) if (ecosystem_out[i] != 0) return 121;
+	if (load64(ecosystem_out + 256) != load64(ecosystem_a)) return 122;
+	if (load64(ecosystem_out + 264) != 0) return 123;
+	for (int i = 0; i < 16; i++)
+		if (ecosystem_out[272+i] != (uint8_t)(((uint16_t)ecosystem_a[i] + ecosystem_b[i] + 1) >> 1)) return 124;
+	for (int i = 0; i < 8; i++)
+		if (load16(ecosystem_out + 288 + 2*i) != (uint16_t)(((uint32_t)load16(ecosystem_a + 2*i) + load16(ecosystem_b + 2*i) + 1) >> 1)) return 125;
+	for (int i = 0; i < 16; i++)
+		if (ecosystem_out[304+i] != ((int8_t)ecosystem_a[i] > (int8_t)ecosystem_b[i] ? 0xff : 0)) return 126;
+	for (int i = 0; i < 8; i++)
+		if (load16(ecosystem_out + 320 + 2*i) != ((int16_t)load16(ecosystem_a + 2*i) > (int16_t)load16(ecosystem_b + 2*i) ? 0xffff : 0)) return 127;
+	for (int i = 0; i < 4; i++)
+		if (load32(ecosystem_out + 336 + 4*i) != ((int32_t)load32(ecosystem_a + 4*i) > (int32_t)load32(ecosystem_b + 4*i) ? 0xffffffffU : 0)) return 128;
+	for (int i = 0; i < 2; i++)
+		if (load64(ecosystem_out + 352 + 8*i) != ((int64_t)load64(ecosystem_a + 8*i) > (int64_t)load64(ecosystem_b + 8*i) ? ~0ULL : 0)) return 129;
+	for (int i = 0; i < 8; i++) {
+		int16_t value = (int16_t)load16(ecosystem_a + 2*i);
+		if ((int16_t)load16(ecosystem_out + 368 + 2*i) != (int16_t)(value >> 3)) return 150;
+		if ((int16_t)load16(ecosystem_out + 384 + 2*i) != (int16_t)(value >> 15)) return 151;
+	}
+	for (int i = 0; i < 2; i++) {
+		if (load32(ecosystem_out + 400 + 8*i) != load32(ecosystem_a + 4*i)) return 152;
+		if (load32(ecosystem_out + 404 + 8*i) != load32(ecosystem_b + 4*i)) return 153;
+		if (load32(ecosystem_out + 416 + 8*i) != load32(ecosystem_a + 8 + 4*i)) return 154;
+		if (load32(ecosystem_out + 420 + 8*i) != load32(ecosystem_b + 8 + 4*i)) return 155;
+	}
+	if (load64(ecosystem_out + 432) != load64(ecosystem_a) || load64(ecosystem_out + 440) != load64(ecosystem_b)) return 156;
+	if (load64(ecosystem_out + 448) != load64(ecosystem_a + 8) || load64(ecosystem_out + 456) != load64(ecosystem_b + 8)) return 157;
+	for (int i = 0; i < 8; i++) if (load16(ecosystem_out + 464 + 2*i) != ecosystem_a[i]) return 158;
+	for (int i = 0; i < 4; i++) if (load32(ecosystem_out + 480 + 4*i) != ecosystem_a[i]) return 159;
+	for (int i = 0; i < 2; i++) if (load64(ecosystem_out + 496 + 8*i) != ecosystem_a[i]) return 160;
+	for (int i = 0; i < 4; i++) if (load32(ecosystem_out + 512 + 4*i) != load16(ecosystem_a + 2*i)) return 161;
+	for (int i = 0; i < 2; i++) if (load64(ecosystem_out + 528 + 8*i) != load16(ecosystem_a + 2*i)) return 162;
+	for (int i = 0; i < 2; i++) if (load64(ecosystem_out + 544 + 8*i) != load32(ecosystem_a + 4*i)) return 163;
+	for (int i = 0; i < 2; i++) {
+		if (load32(ecosystem_out + 560 + 4*i) != load32(ecosystem_a + 8*i) + load32(ecosystem_a + 8*i + 4)) return 164;
+		if (load32(ecosystem_out + 568 + 4*i) != load32(ecosystem_b + 8*i) + load32(ecosystem_b + 8*i + 4)) return 165;
+		if (load32(ecosystem_out + 608 + 4*i) != load32(ecosystem_a + 8*i) - load32(ecosystem_a + 8*i + 4)) return 166;
+		if (load32(ecosystem_out + 616 + 4*i) != load32(ecosystem_b + 8*i) - load32(ecosystem_b + 8*i + 4)) return 167;
+	}
+	for (int i = 0; i < 4; i++) {
+		int32_t aa = (int16_t)load16(ecosystem_a + 4*i) + (int16_t)load16(ecosystem_a + 4*i + 2);
+		int32_t ba = (int16_t)load16(ecosystem_b + 4*i) + (int16_t)load16(ecosystem_b + 4*i + 2);
+		int32_t as = (int16_t)load16(ecosystem_a + 4*i) - (int16_t)load16(ecosystem_a + 4*i + 2);
+		int32_t bs = (int16_t)load16(ecosystem_b + 4*i) - (int16_t)load16(ecosystem_b + 4*i + 2);
+		if (aa < -32768) aa = -32768; if (aa > 32767) aa = 32767;
+		if (ba < -32768) ba = -32768; if (ba > 32767) ba = 32767;
+		if (as < -32768) as = -32768; if (as > 32767) as = 32767;
+		if (bs < -32768) bs = -32768; if (bs > 32767) bs = 32767;
+		if ((int16_t)load16(ecosystem_out + 576 + 2*i) != (int16_t)aa) return 168;
+		if ((int16_t)load16(ecosystem_out + 584 + 2*i) != (int16_t)ba) return 169;
+		if (load16(ecosystem_out + 592 + 2*i) != (uint16_t)(load16(ecosystem_a + 4*i) + load16(ecosystem_a + 4*i + 2))) return 170;
+		if (load16(ecosystem_out + 600 + 2*i) != (uint16_t)(load16(ecosystem_b + 4*i) + load16(ecosystem_b + 4*i + 2))) return 171;
+		if ((int16_t)load16(ecosystem_out + 624 + 2*i) != (int16_t)as) return 172;
+		if ((int16_t)load16(ecosystem_out + 632 + 2*i) != (int16_t)bs) return 173;
+		if (load16(ecosystem_out + 640 + 2*i) != (uint16_t)(load16(ecosystem_a + 4*i) - load16(ecosystem_a + 4*i + 2))) return 174;
+		if (load16(ecosystem_out + 648 + 2*i) != (uint16_t)(load16(ecosystem_b + 4*i) - load16(ecosystem_b + 4*i + 2))) return 175;
+	}
+	uint16_t minimum = 0xffff, minimum_index = 0;
+	for (int i = 0; i < 8; i++) {
+		uint16_t value = load16(ecosystem_a + 2*i);
+		if (value < minimum) { minimum = value; minimum_index = (uint16_t)i; }
+	}
+	if (load16(ecosystem_out + 656) != minimum || load16(ecosystem_out + 658) != minimum_index) return 176;
+	for (int i = 660; i < 672; i++) if (ecosystem_out[i] != 0) return 177;
+	for (int block = 0; block < 2; block++)
+		for (int i = 0; i < 16; i++) {
+			uint8_t want_masked = (int8_t)ecosystem_b[i] < 0 ? ecosystem_a[i] : ecosystem_b[i];
+			if (ecosystem_out[672 + 16*block + i] != want_masked) return 178 + block;
+		}
+	for (int i = 0; i < 8; i++) {
+		if (load16(ecosystem_out + 704 + 2*i) != (uint16_t)(load16(ecosystem_a + 2*i) << 3)) return 180;
+		if (load16(ecosystem_out + 752 + 2*i) != (uint16_t)(load16(ecosystem_a + 2*i) >> 3)) return 181;
+	}
+	for (int i = 0; i < 4; i++) {
+		if (load32(ecosystem_out + 720 + 4*i) != load32(ecosystem_a + 4*i) << 3) return 182;
+		if (load32(ecosystem_out + 768 + 4*i) != load32(ecosystem_a + 4*i) >> 3) return 183;
+	}
+	for (int i = 0; i < 2; i++) {
+		if (load64(ecosystem_out + 736 + 8*i) != load64(ecosystem_a + 8*i) << 3) return 184;
+		if (load64(ecosystem_out + 784 + 8*i) != load64(ecosystem_a + 8*i) >> 3) return 185;
+	}
+	if (load64(ecosystem_out + 800) != 3 || load64(ecosystem_out + 808) != 0) return 186;
+	uint64_t parity0 = parityBranches(0x00);
+	if (parity0 != 1) return 120 + (int)parity0;
+	if (parityBranches(0x03) != 1) return 114;
+	if (parityBranches(0x01) != 2) return 115;
+	if (parityBranches(0x07) != 2) return 116;
+	volatile double zero = 0.0;
+	if (unorderedBranch(1.25) != 0) return 117;
+	if (unorderedBranch(zero / zero) != 1) return 118;
+	float conversion_src[4] = {1.5f, -1.5f, 2.75f, -2.75f};
+	int32_t conversion_out[20] = {0};
+	int32_t conversion_want[20] = {
+		2, -2, 3, -3,
+		1, -2, 2, -3,
+		2, -1, 3, -2,
+		1, -1, 2, -2,
+		1, -1, 2, -2,
+	};
+	packedFloatToDwordModes(conversion_out, conversion_src);
+	for (int i = 0; i < 20; i++)
+		if (conversion_out[i] != conversion_want[i]) return 130 + i;
+#if PLAN9ASM_CONFORMANCE_NATIVE_WIDE
+	int32_t same_width_ints[16];
+	float same_width_floats[16] = {
+		1.5f, -1.5f, 2.75f, -2.75f, 0.5f, -0.5f, 3.25f, -3.25f,
+		4.5f, -4.5f, 5.75f, -5.75f, 6.5f, -6.5f, 7.25f, -7.25f,
+	};
+	float same_width_squares32[16];
+	double same_width_squares64[8];
+	for (int i = 0; i < 16; i++) {
+		same_width_ints[i] = i - 8;
+		same_width_squares32[i] = (float)((i + 1) * (i + 1));
+	}
+	for (int i = 0; i < 8; i++) same_width_squares64[i] = (double)((i + 1) * (i + 1));
+	int32_t same_width_nearest[16] = {2,-2,3,-3,0,0,3,-3,4,-4,6,-6,6,-6,7,-7};
+	int32_t same_width_trunc[16] = {1,-1,2,-2,0,0,3,-3,4,-4,5,-5,6,-6,7,-7};
+	int32_t same_width_down[16] = {1,-2,2,-3,0,-1,3,-4,4,-5,5,-6,6,-7,7,-8};
+	int32_t same_width_up[16] = {2,-1,3,-2,1,0,4,-3,5,-4,6,-5,7,-6,8,-7};
+	uint8_t same_width_out[576] = {0};
+	sameWidthPackedConversionSemantics(same_width_out, same_width_ints, same_width_floats, same_width_squares32, same_width_squares64);
+	for (int i = 0; i < 16; i++) {
+		if (loadf32(same_width_out + 4*i) != (float)same_width_ints[i]) return 760 + i;
+		if ((int32_t)load32(same_width_out + 64 + 4*i) != same_width_nearest[i]) return 780 + i;
+		if ((int32_t)load32(same_width_out + 128 + 4*i) != same_width_trunc[i]) return 800 + i;
+		if (loadf32(same_width_out + 192 + 4*i) != (float)(i + 1)) return 820 + i;
+		if ((int32_t)load32(same_width_out + 320 + 4*i) != same_width_nearest[i]) return 840 + i;
+		if ((int32_t)load32(same_width_out + 384 + 4*i) != same_width_down[i]) return 860 + i;
+		if ((int32_t)load32(same_width_out + 448 + 4*i) != same_width_up[i]) return 880 + i;
+		if ((int32_t)load32(same_width_out + 512 + 4*i) != same_width_trunc[i]) return 900 + i;
+	}
+	for (int i = 0; i < 8; i++)
+		if (loadf64(same_width_out + 256 + 8*i) != (double)(i + 1)) return 920 + i;
+#endif
+	double widening_out[4] = {0};
+	double widening_want[4] = {1.5, -1.5, 2.75, -2.75};
+	packedSingleToDouble(widening_out, conversion_src);
+	for (int i = 0; i < 4; i++)
+		if (widening_out[i] != widening_want[i]) return 180 + i;
+	uint64_t cmov_src[16];
+	uint64_t cmov_out[16] = {0};
+	for (int i = 0; i < 16; i++) cmov_src[i] = 101 + (uint64_t)i;
+	conditionalMoveCodes(cmov_out, cmov_src);
+	int cmov_taken[16] = {1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1};
+	for (int i = 0; i < 16; i++) {
+		uint64_t want = cmov_taken[i] ? cmov_src[i] : UINT64_MAX;
+		if (cmov_out[i] != want) return 160 + i;
+	}
+	double fma_a64[2] = {2, -3}, fma_b64[2] = {5, 7}, fma_c64[2] = {11, -13};
+	float fma_a32[4] = {2, -3, 4, -5};
+	float fma_b32[4] = {5, 7, -11, -13};
+	float fma_c32[4] = {17, -19, 23, -29};
+	uint8_t fma_out[288] = {0};
+	fma3Semantics(fma_out, fma_a64, fma_b64, fma_c64, fma_a32, fma_b32, fma_c32);
+	for (int lane = 0; lane < 2; lane++) {
+		double a = fma_a64[lane], b = fma_b64[lane], c = fma_c64[lane];
+		double want[8] = {
+			c*a+b, b*c+a, b*a+c, c*a-b, -(b*c)+a, -(b*a)-c,
+			lane % 2 == 0 ? c*a-b : c*a+b,
+			lane % 2 == 0 ? b*a+c : b*a-c,
+		};
+		for (int block = 0; block < 8; block++)
+			if (loadf64(fma_out + 16*block + 8*lane) != want[block]) return 500 + 2*block + lane;
+	}
+	for (int lane = 0; lane < 4; lane++) {
+		float a = fma_a32[lane], b = fma_b32[lane], c = fma_c32[lane];
+		float want[6] = {
+			c*a+b, b*c-a, -(b*a)+c, -(c*a)-b,
+			lane % 2 == 0 ? b*c-a : b*c+a,
+			lane % 2 == 0 ? b*a+c : b*a-c,
+		};
+		for (int block = 0; block < 6; block++)
+			if (loadf32(fma_out + 128 + 16*block + 4*lane) != want[block]) return 520 + 4*block + lane;
+	}
+	if (loadf64(fma_out + 224) != fma_c64[0]*fma_a64[0]+fma_b64[0] ||
+		loadf64(fma_out + 232) != fma_c64[1]) return 550;
+	if (loadf64(fma_out + 240) != fma_b64[0]*fma_c64[0]-fma_a64[0] ||
+		loadf64(fma_out + 248) != fma_c64[1]) return 551;
+	if (loadf32(fma_out + 256) != -(fma_b32[0]*fma_a32[0])+fma_c32[0] ||
+		loadf32(fma_out + 260) != fma_c32[1] ||
+		loadf32(fma_out + 264) != fma_c32[2] ||
+		loadf32(fma_out + 268) != fma_c32[3]) return 552;
+	if (loadf32(fma_out + 272) != -(fma_c32[0]*fma_a32[0])-fma_b32[0] ||
+		loadf32(fma_out + 276) != fma_c32[1] ||
+		loadf32(fma_out + 280) != fma_c32[2] ||
+		loadf32(fma_out + 284) != fma_c32[3]) return 553;
+	double binary_a64[2] = {2, -3}, binary_b64[2] = {20, 30};
+	float binary_a32[4] = {2, -3, 4, -5}, binary_b32[4] = {20, 30, -40, -50};
+	double binary_want64[6][2] = {
+		{22, 27}, {18, 33}, {40, -90}, {10, -10}, {20, 30}, {2, -3},
+	};
+	float binary_want32[6][4] = {
+		{22, 27, -36, -55},
+		{18, 33, -44, -45},
+		{40, -90, -160, 250},
+		{10, -10, -10, 10},
+		{20, 30, 4, -5},
+		{2, -3, -40, -50},
+	};
+	uint8_t binary_out[384] = {0};
+	binaryFloatingSemantics(binary_out, binary_a64, binary_b64, binary_a32, binary_b32);
+	for (int operation = 0; operation < 6; operation++) {
+		for (int lane = 0; lane < 2; lane++)
+			if (loadf64(binary_out + 16*operation + 8*lane) != binary_want64[operation][lane]) return 600 + 2*operation + lane;
+		for (int lane = 0; lane < 4; lane++)
+			if (loadf32(binary_out + 96 + 16*operation + 4*lane) != binary_want32[operation][lane]) return 620 + 4*operation + lane;
+		for (int lane = 0; lane < 2; lane++) {
+			double want = lane == 0 ? binary_want64[operation][0] : binary_b64[lane];
+			if (loadf64(binary_out + 192 + 16*operation + 8*lane) != want) return 650 + 2*operation + lane;
+		}
+		for (int lane = 0; lane < 4; lane++) {
+			float want = lane == 0 ? binary_want32[operation][0] : binary_b32[lane];
+			if (loadf32(binary_out + 288 + 16*operation + 4*lane) != want) return 670 + 4*operation + lane;
+		}
+	}
+	float horizontal_a32[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+	float horizontal_b32[8] = {10, 20, 30, 40, 50, 60, 70, 80};
+	double horizontal_a64[4] = {1, 2, 3, 4};
+	double horizontal_b64[4] = {10, 20, 30, 40};
+	float horizontal_want32[4][8] = {
+		{30, 70, 3, 7, 110, 150, 11, 15},
+		{-10, -10, -1, -1, -10, -10, -1, -1},
+		{30, 70, 3, 7, 0, 0, 0, 0},
+		{-10, -10, -1, -1, 0, 0, 0, 0},
+	};
+	double horizontal_want64[4][4] = {
+		{30, 3, 70, 7},
+		{-10, -1, -10, -1},
+		{30, 3, 0, 0},
+		{-10, -1, 0, 0},
+	};
+	uint8_t horizontal_out[192] = {0};
+	horizontalFloatingSemantics(horizontal_out, horizontal_a32, horizontal_b32, horizontal_a64, horizontal_b64);
+	for (int block = 0; block < 2; block++)
+		for (int lane = 0; lane < 8; lane++)
+			if (loadf32(horizontal_out + 32*block + 4*lane) != horizontal_want32[block][lane]) return 700 + 8*block + lane;
+	for (int block = 0; block < 2; block++)
+		for (int lane = 0; lane < 4; lane++)
+			if (loadf64(horizontal_out + 64 + 32*block + 8*lane) != horizontal_want64[block][lane]) return 720 + 4*block + lane;
+	for (int block = 0; block < 2; block++)
+		for (int lane = 0; lane < 4; lane++)
+			if (loadf32(horizontal_out + 128 + 16*block + 4*lane) != horizontal_want32[2+block][lane]) return 740 + 4*block + lane;
+	for (int block = 0; block < 2; block++)
+		for (int lane = 0; lane < 2; lane++)
+			if (loadf64(horizontal_out + 160 + 16*block + 8*lane) != horizontal_want64[2+block][lane]) return 750 + 2*block + lane;
 	return 0;
 }
 `
-	compileAndRunRuntimeTestForTarget(t, llc, clang, "amd64_conformance", triple, ll, mainC, runPrefix)
 }
 
 func rosettaAvailable() bool {
diff --git a/amd64_continuation.go b/amd64_continuation.go
new file mode 100644
index 000000000..7c928220a
--- /dev/null
+++ b/amd64_continuation.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// X86TailGroup names one ordinary entry and its private continuation TEXTs.
+// Names use source spelling, before Options.ResolveSym. See X86TailGroups.
+type X86TailGroup struct {
+	Root    string
+	Helpers []string
+}
+
+type x86Continuation struct {
+	root  string
+	label string
+}
+
+func (f *File) isX86Continuation(name string, resolve func(string) string) bool {
+	for symbol := range f.x86Continuations {
+		if resolve(symbol) == name {
+			return true
+		}
+	}
+	return false
+}
+
+func coalesceX86Continuations(file *File, opt Options) (*File, error) {
+	if file == nil {
+		return nil, fmt.Errorf("nil file")
+	}
+	if file.x86ContinuationGraph != nil {
+		if err := file.x86ContinuationGraph.verify(file, opt); err != nil {
+			return nil, err
+		}
+		return file, nil
+	}
+	if len(file.x86Continuations) != 0 {
+		return nil, x86ContinuationContext("unbound prepared continuation inventory")
+	}
+	if len(opt.X86TailGroups) == 0 {
+		return file, nil
+	}
+	if file.Arch != ArchAMD64 || (opt.Goarch != "amd64" && opt.Goarch != "386") {
+		return nil, fmt.Errorf("x86 continuation groups require an x86 target")
+	}
+	resolve := opt.ResolveSym
+	if resolve == nil {
+		resolve = func(s string) string { return s }
+	}
+	functions := make(map[string]Func, len(file.Funcs))
+	for _, fn := range file.Funcs {
+		if _, duplicate := functions[fn.Sym]; duplicate {
+			return nil, fmt.Errorf("duplicate continuation TEXT %q", fn.Sym)
+		}
+		functions[fn.Sym] = fn
+	}
+	addresses := map[string]x86Continuation{}
+	owners := map[string]string{}
+	for gi, group := range opt.X86TailGroups {
+		if len(group.Helpers) == 0 {
+			return nil, fmt.Errorf("empty continuation group %q", group.Root)
+		}
+		members := append([]string{group.Root}, group.Helpers...)
+		for mi, name := range members {
+			fn, exists := functions[name]
+			if !exists || owners[name] != "" {
+				return nil, fmt.Errorf("missing or repeated continuation TEXT %q", name)
+			}
+			owners[name] = group.Root
+			if fn.X86RawText != nil || fn.FrameSize != 0 {
+				return nil, fmt.Errorf("continuation TEXT %q requires a zero frame and no native layout dependency", name)
+			}
+			if len(fn.Instrs) == 0 {
+				return nil, fmt.Errorf("empty continuation TEXT %q", name)
+			}
+			last := fn.Instrs[len(fn.Instrs)-1]
+			if (last.Op != "RET" || len(last.Args) != 0) && last.Op != "JMP" {
+				return nil, fmt.Errorf("continuation TEXT %q has no explicit terminating transfer", name)
+			}
+			if mi == 0 {
+				continue
+			}
+			sig, ok := opt.Sigs[resolve(name)]
+			if !ok || sig.Ret != Void || len(sig.Args) != 0 || fn.ArgSize != 0 ||
+				len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+				return nil, fmt.Errorf("continuation %q must be a zero-frame void helper", name)
+			}
+			addresses[name] = x86Continuation{
+				root: group.Root, label: fmt.Sprintf("p9_cont_%d_%d", gi, mi),
+			}
+		}
+	}
+
+	// These addresses are local control-flow labels, not callable functions or
+	// byte-addressable code. Refuse a group before emitting any changed ABI.
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			for ai, arg := range ins.Args {
+				if arg.Kind != OpSym {
+					continue
+				}
+				base, off, ok := parseSBRef(arg.Sym)
+				target, continuation := addresses[strings.TrimPrefix(base, "$")]
+				if !ok || !continuation {
+					continue
+				}
+				if off != 0 || ins.Op == "CALL" || (ins.Op == "JMP" && owners[fn.Sym] != target.root) {
+					return nil, fmt.Errorf("invalid continuation reference in %q: %s", fn.Sym, ins.Raw)
+				}
+				if ins.Op == "JMP" && len(ins.Args) == 1 {
+					continue
+				}
+				form := x86SourceMoveInstruction(ins, opt.Goarch)
+				address := form.Op == "LEAQ" || form.Op == "LEAL" ||
+					((form.Op == "MOVQ" || form.Op == "MOVL") && strings.HasPrefix(arg.Sym, "$"))
+				if !address || ai != 0 || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+					return nil, fmt.Errorf("continuation %q is not readable or callable code: %s", base, ins.Raw)
+				}
+			}
+		}
+	}
+	for _, d := range file.Data {
+		if d.Addr != "" {
+			base, _, _ := parseSBRef(d.Addr)
+			if _, ok := addresses[strings.TrimPrefix(base, "$")]; ok {
+				return nil, fmt.Errorf("continuation DATA relocations require an explicit initializer")
+			}
+		}
+	}
+
+	fused := map[string]Func{}
+	for gi, group := range opt.X86TailGroups {
+		root := functions[group.Root]
+		root.Instrs = nil
+		root.x86IndirectLabels = nil
+		for mi, name := range append([]string{group.Root}, group.Helpers...) {
+			fn := functions[name]
+			prefix := fmt.Sprintf("p9_body_%d_%d_", gi, mi)
+			if mi != 0 {
+				label := addresses[name].label
+				root.Instrs = append(root.Instrs, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label}}})
+				root.x86IndirectLabels = append(root.x86IndirectLabels, label)
+			}
+			labels := map[string]string{}
+			for i, ins := range fn.Instrs {
+				if ins.Op == OpLABEL && len(ins.Args) == 1 {
+					labels[ins.Args[0].Sym] = fmt.Sprintf("%s%d", prefix, i)
+				}
+			}
+			for _, ins := range fn.Instrs {
+				ins.Args = append([]Operand(nil), ins.Args...)
+				for ai, arg := range ins.Args {
+					switch arg.Kind {
+					case OpLabel:
+						ins.Args[ai].Sym = labels[arg.Sym]
+					case OpIdent:
+						if label, ok := labels[arg.Ident]; ok {
+							ins.Args[ai].Ident = label
+						}
+					case OpReg:
+						if label, ok := labels[string(arg.Reg)]; ok && (ins.Op == "JMP" || isAMD64ConditionalBranch(ins.Op)) {
+							ins.Args[ai] = Operand{Kind: OpIdent, Ident: label}
+						}
+					case OpSym:
+						base, off, ok := parseSBRef(arg.Sym)
+						if target, exists := addresses[base]; ok && exists && off == 0 && ins.Op == "JMP" {
+							ins.Args[ai] = Operand{Kind: OpIdent, Ident: target.label}
+						}
+					}
+				}
+				root.Instrs = append(root.Instrs, ins)
+			}
+		}
+		fused[group.Root] = root
+	}
+	result := *file
+	result.Funcs = nil
+	result.x86Continuations = addresses
+	for _, fn := range file.Funcs {
+		if _, helper := addresses[fn.Sym]; helper {
+			continue
+		}
+		if root, ok := fused[fn.Sym]; ok {
+			fn = root
+		}
+		fn.x86ContinuationAddresses = addresses
+		result.Funcs = append(result.Funcs, fn)
+	}
+	return sealX86Continuations(file, &result, opt)
+}
diff --git a/amd64_continuation_test.go b/amd64_continuation_test.go
new file mode 100644
index 000000000..25d66051b
--- /dev/null
+++ b/amd64_continuation_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The empty helper declarations describe Go entries, not the register/frame
+// contract of a JMP from another TEXT. This fixture borrows the root frame.
+const x86ContinuationSource = `
+TEXT ·initTable(SB),$0-0
+ LEAQ ·step(SB),AX
+ MOVQ AX,table<>(SB)
+ RET
+GLOBL table<>(SB),16,$8
+TEXT ·run(SB),$0-24
+ MOVQ out+0(FP),DI
+ MOVQ n+8(FP),BX
+ MOVQ $7,R15
+ MOVQ R15,X13
+ LEAQ table<>(SB),R14
+ XORQ R15,R15
+ TESTQ BX,BX
+ JEQ done
+dispatch:
+ MOVQ (R14),AX
+ JMP AX
+done:
+ JMP ·exit(SB)
+TEXT ·step(SB),$0-0
+ MOVQ X13,DX
+ ADDQ DX,R15
+ SUBQ $1,BX
+ JMP ·check(SB)
+TEXT ·check(SB),$0-0
+ JEQ done
+ MOVQ (R14),AX
+ JMP AX
+done:
+ JMP ·exit(SB)
+TEXT ·exit(SB),$0-0
+ MOVQ R15,(DI)
+ MOVQ R15,result+16(FP)
+ RET
+`
+
+func x86ContinuationOptions(triple string) Options {
+	return Options{
+		Goarch: "amd64", TargetTriple: triple,
+		X86TailGroups: []X86TailGroup{{Root: "·run", Helpers: []string{"·step", "·check", "·exit"}}},
+		ResolveSym:    func(s string) string { return strings.TrimPrefix(s, "·") },
+		Sigs: map[string]FuncSig{
+			"initTable": {Ret: Void},
+			"run": {
+				Args: []LLVMType{Ptr, I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: I64, Index: 1, Field: -1},
+					},
+					Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+			"step": {Ret: Void}, "check": {Ret: Void}, "exit": {Ret: Void},
+		},
+	}
+}
+
+func TestX86ContinuationBorrowedFrame(t *testing.T) {
+	requireX86GoAssemblerResult(t, "amd64", x86ContinuationSource, true)
+	ir := x86ContinuationIR(t, "x86_64-unknown-linux-gnu", x86ContinuationSource)
+	if !strings.Contains(ir, "indirectbr") || !strings.Contains(ir, "blockaddress") {
+		t.Fatal("continuations must branch within the root CFG")
+	}
+	if strings.Contains(ir, "define void @step") || strings.Contains(ir, "call i64 %") {
+		t.Fatal("a continuation must not be emitted as a fresh function invocation")
+	}
+}
+
+func x86ContinuationIR(t *testing.T, triple, source string) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, x86ContinuationOptions(triple))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestX86ContinuationLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH == "amd64" || crossRosetta {
+		runX86ContinuationGo(t)
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			for _, memoryJump := range []bool{false, true} {
+				source := x86ContinuationSource
+				if memoryJump {
+					source = strings.ReplaceAll(source, " MOVQ (R14),AX\n JMP AX", " JMP (R14)")
+				}
+				ir := x86ContinuationIR(t, triple, source)
+				compileLLVMToObject(t, llc, triple, "continuation.ll", "continuation.o", ir)
+				if (runtime.GOARCH == "amd64" && runtime.GOOS == "linux" && triple == "x86_64-unknown-linux-gnu") ||
+					((runtime.GOARCH == "amd64" || crossRosetta) && runtime.GOOS == "darwin" && triple == "x86_64-apple-darwin") {
+					clang := findLLVM22Tool("clang")
+					if clang == "" {
+						t.Fatal("LLVM 22 clang not found")
+					}
+					runX86Continuation(t, llc, clang, triple, ir)
+				}
+			}
+		})
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86Continuation386IR(t, triple)
+			compileLLVMToObject(t, llc, triple, "continuation386.ll", "continuation386.o", ir)
+		})
+	}
+}
+
+func x86Continuation386IR(t *testing.T, triple string) string {
+	t.Helper()
+	source := strings.NewReplacer(
+		" MOVQ R15,X13\n", "", " MOVQ X13,DX\n ADDQ DX,R15", " ADDL $7,DX",
+		"R15", "DX", "R14", "SI", "MOVQ", "MOVL", "LEAQ", "LEAL",
+		"XORQ", "XORL", "TESTQ", "TESTL", "SUBQ", "SUBL",
+		"n+8(FP)", "n+4(FP)", "result+16(FP)", "result+8(FP)",
+		"$0-24", "$0-12", "GLOBL table<>(SB),16,$8", "GLOBL table<>(SB),16,$4",
+	).Replace(x86ContinuationSource)
+	requireX86GoAssemblerResult(t, "386", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	opt := x86ContinuationOptions(triple)
+	opt.Goarch = "386"
+	sig := opt.Sigs["run"]
+	sig.Args[1], sig.Ret = I32, I32
+	sig.Frame.Params[1].Offset, sig.Frame.Params[1].Type = 4, I32
+	sig.Frame.Results[0].Offset, sig.Frame.Results[0].Type = 8, I32
+	opt.Sigs["run"] = sig
+	ir, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func runX86Continuation(t *testing.T, llc, clang, triple, ir string) {
+	t.Helper()
+	if dir := os.Getenv("PLAN9ASM_RUNTIME_ARTIFACT_DIR"); dir != "" {
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			t.Fatal(err)
+		}
+		for name, data := range map[string]string{"continuation.ll": ir, "main.c": x86ContinuationMain} {
+			if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0644); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	compiler := []string{clang}
+	var runner []string
+	if runtime.GOARCH != "amd64" && strings.Contains(triple, "darwin") {
+		compiler = append(compiler, "-target", triple)
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	if strings.Contains(triple, "linux") {
+		// The shared harness invokes llc with its default static relocation
+		// model. Match that object when linking a native executable.
+		compiler = append(compiler, "-no-pie")
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "continuation", triple, ir, x86ContinuationMain, runner)
+}
+
+func runX86ContinuationGo(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":               "module example.com/continuation\n\ngo 1.20\n",
+		"continuation_amd64.s": strings.ReplaceAll(x86ContinuationSource, "(SB),$0-", "(SB),4,$0-"),
+		"continuation.go":      "package p\nfunc initTable()\nfunc run(out *uint64, n uint64) (result uint64)\nfunc step()\nfunc check()\nfunc exit()\n",
+		"continuation_test.go": `package p
+import "testing"
+func TestState(t *testing.T) {
+  initTable()
+  for _, n := range []uint64{0, 1, 2, 19, 100000} {
+    out := [3]uint64{0x1234, ^uint64(0), 0x5678}
+    result := run(&out[1], n)
+    if result != n*7 || out[1] != result || out[0] != 0x1234 || out[2] != 0x5678 {
+      t.Fatalf("n=%d result=%d out=%v", n, result, out)
+    }
+  }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// asmdecl describes callable entries, not the helpers' borrowed frame.
+	// This oracle tests Go's actual assembler/linker/runtime semantics.
+	cmd := exec.Command("go", "test", "-vet=off", "-count=1", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go continuation oracle: %v\n%s", err, out)
+	}
+}
+
+func TestX86ContinuationRejectsInvalidGroups(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		change func(*File, *Options)
+	}{
+		{"other_arch", func(f *File, o *Options) { f.Arch = ArchWASM; o.Goarch = "wasm" }},
+		{"missing_root", func(f *File, o *Options) { o.X86TailGroups[0].Root = "absent" }},
+		{"missing_helper", func(f *File, o *Options) { o.X86TailGroups[0].Helpers[0] = "absent" }},
+		{"duplicate", func(f *File, o *Options) { o.X86TailGroups = append(o.X86TailGroups, o.X86TailGroups[0]) }},
+		{"empty", func(f *File, o *Options) { o.X86TailGroups[0].Helpers = nil }},
+		{"local_frame", func(f *File, o *Options) { f.Funcs[2].FrameSize = 8 }},
+		{"root_frame", func(f *File, o *Options) { f.Funcs[1].FrameSize = 8 }},
+		{"fallthrough", func(f *File, o *Options) { f.Funcs[2].Instrs = append(f.Funcs[2].Instrs, Instr{Op: "NOP"}) }},
+		{"code_read", func(f *File, o *Options) { f.Funcs[0].Instrs[1].Op = "MOVQ" }},
+		{"arg_frame", func(f *File, o *Options) { f.Funcs[2].ArgSize = 8 }},
+		{"typed_entry", func(f *File, o *Options) { o.Sigs["step"] = FuncSig{Args: []LLVMType{I64}, Ret: Void} }},
+		{"callable", func(f *File, o *Options) {
+			f.Funcs[0].Instrs[0] = Instr{Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: "·step(SB)"}}}
+		}},
+		{"offset", func(f *File, o *Options) { f.Funcs[0].Instrs[1].Args[0].Sym = "·step+1(SB)" }},
+		{"data", func(f *File, o *Options) { f.Data = []DataStmt{{Sym: "table<>", Width: 8, Addr: "·step(SB)"}} }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, x86ContinuationSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			opt := x86ContinuationOptions("x86_64-unknown-linux-gnu")
+			test.change(file, &opt)
+			if _, err := coalesceX86Continuations(file, opt); err == nil {
+				t.Fatal("invalid continuation proof accepted")
+			}
+		})
+	}
+}
+
+const x86ContinuationMain = `
+#include <stdint.h>
+extern void initTable(void);
+extern uint64_t run(uint64_t *, uint64_t);
+int main(void) {
+  initTable();
+  const uint64_t counts[] = {0, 1, 2, 19, 100000};
+  for (unsigned i = 0; i < sizeof(counts) / sizeof(counts[0]); i++) {
+    uint64_t out[3] = {0x1234, UINT64_MAX, 0x5678};
+    uint64_t result = run(out + 1, counts[i]);
+    if (result != counts[i] * 7 || out[1] != result ||
+        out[0] != 0x1234 || out[2] != 0x5678) return 1;
+  }
+  return 0;
+}
+`
diff --git a/amd64_cpu_query_consumers_test.go b/amd64_cpu_query_consumers_test.go
new file mode 100644
index 000000000..4a7b50679
--- /dev/null
+++ b/amd64_cpu_query_consumers_test.go
@@ -0,0 +1,226 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86CPUQueryTypedGrammarAndDispatchBoundaries(t *testing.T) {
+	if len(x86CPUQuerySpecs) != 2 {
+		t.Fatal("complete official CPU-query family changed")
+	}
+	for _, op := range []Op{OpCPUID, OpXGETBV} {
+		spec := x86CPUQuerySpecs[op]
+		inputs, outputs, encoding := []Reg{AX, CX}, []Reg{AX, BX, CX, DX}, []byte{0xa2}
+		if op == OpXGETBV {
+			inputs, outputs, encoding = []Reg{CX}, []Reg{AX, DX}, []byte{0x01, 0xd0}
+		}
+		if spec.native != strings.ToLower(string(op)) || !reflect.DeepEqual(spec.inputs, inputs) ||
+			!reflect.DeepEqual(spec.outputs, outputs) || !bytes.Equal(spec.opBytes, encoding) {
+			t.Fatal("CPU-query typed syntax or implicit effect changed", op)
+		}
+		for _, arch := range []string{"386", "amd64", "", "arm", "arm64", "wasm"} {
+			for _, suffix := range []string{"", ".Z", ".SAE", ".BCST"} {
+				for _, identity := range []Op{"", op, Op(strings.ToLower(string(op))), "MOVQ", Op(string(op) + ".BAD")} {
+					t.Run(arch+"/"+string(op)+suffix+"/identity="+string(identity), func(t *testing.T) {
+						instruction := Instr{Op: identity, Raw: string(op) + suffix}
+						before := fmt.Sprintf("%#v", instruction)
+						ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+						ctx.goarch = arch
+						ir, temporary := output.String(), ctx.tmp
+						known, terminated, err := ctx.lowerX86CPUQuery(Op(string(op)+suffix), instruction)
+						invalid := arch != "386" && arch != "amd64" || suffix != "" ||
+							identity != "" && !strings.EqualFold(string(identity), string(op))
+						if !known || terminated || (err != nil) != invalid ||
+							invalid && (ir != output.String() || temporary != ctx.tmp) || before != fmt.Sprintf("%#v", instruction) {
+							t.Fatal("CPU-query dispatch mutated input or emitted before rejection", err)
+						}
+					})
+				}
+			}
+		}
+	}
+	if _, known, err := x86CPUQueryProperties("RDTSC", Instr{}, "amd64"); known || err != nil {
+		t.Fatal("timestamps must not acquire the CPU-query grammar")
+	}
+}
+
+func TestX86CPUQueryConstructedFileConsumersRetainParserGrammar(t *testing.T) {
+	pkg := mustGoPackage(t, "cpuquery", "package cpuquery\nfunc query()\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{OpCPUID, OpXGETBV} {
+			for _, operand := range []string{"AX", "(AX)", "$1", "AX,DX"} {
+				t.Run(arch+"/"+string(op)+"/"+operand, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·query(SB),4,$0-0\n"+string(op)+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					file.Funcs[0].Instrs[1].Args, err = parseOperandsCSV(ArchAMD64, op, operand)
+					if err != nil {
+						t.Fatal(err)
+					}
+					before := fmt.Sprintf("%#v", file.Funcs[0])
+					options := Options{Goarch: arch, ResolveSym: resolve, Sigs: signatures}
+					if ir, err := Translate(file, options); err == nil || ir != "" {
+						t.Fatal("constructed text consumer bypassed Go's zero-operand grammar", err)
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+						t.Fatal("constructed module consumer returned an invalid query module", err)
+					}
+					if err == nil || before != fmt.Sprintf("%#v", file.Funcs[0]) {
+						t.Fatal("constructed module grammar changed its source or silently accepted it", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CPUQueryDescriptorCannotSupplyCallerOrStackPermission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, suffix := OpMOVQ, "Q"
+		if arch == "386" {
+			move, suffix = OpMOVL, "L"
+		}
+		for _, op := range []Op{OpCPUID, OpXGETBV} {
+			instruction := Instr{Op: op, Raw: string(op)}
+			if _, known, err := x86CPUQueryProperties(op, instruction, arch); !known || err != nil {
+				t.Fatal("valid CPU-query grammar is not bound", op, err)
+			}
+			if x86SourceStackInstructionKnown(instruction, move, suffix, arch) {
+				t.Fatal("implicit-register descriptor granted a native caller/stack contract", op)
+			}
+		}
+	}
+}
+
+func x86CPUQueryIR(t *testing.T, source, arch, triple, api string) string {
+	t.Helper()
+	return x86CPUQueryIRFromDeclaration(t, source, "func query()\n", arch, triple, api)
+}
+
+func x86CPUQueryIRFromDeclaration(t *testing.T, source, declarations, arch, triple, api string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "cpuquery", "package cpuquery\n"+declarations)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: resolve})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+		}
+		if err != nil || translated == nil || translated.Module.IsNil() {
+			t.Fatalf("Go module CPU-query consumer: %v", err)
+		}
+		return translated.Module.String()
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: signatures}
+	if api == "text" {
+		ir, err := Translate(file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return ir
+	}
+	if api != "module" {
+		t.Fatal("unknown CPU-query consumer", api)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil || module.IsNil() {
+		t.Fatalf("LLVM module CPU-query consumer: %v", err)
+	}
+	return module.String()
+}
+
+func TestX86CPUQueryNamedRawThreeAPIsFiveTargetsProduceActualObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM 22 llc and llvm-objdump required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		for _, op := range []Op{OpCPUID, OpXGETBV} {
+			for _, raw := range []bool{false, true} {
+				body := string(op) + "\n"
+				if raw {
+					body = "BYTE $0x0f\n"
+					encoding := []byte{0xa2}
+					if op == OpXGETBV {
+						encoding = []byte{0x01, 0xd0}
+					}
+					for _, value := range encoding {
+						body += fmt.Sprintf("BYTE $%#x\n", value)
+					}
+				}
+				source := "TEXT ·query(SB),4,$0-0\n" + body + "RET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				initialized := "TEXT ·query(SB),4,$0-0\nMOVL $0,AX\nMOVL $0,CX\n" + body + "RET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, initialized)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+string(op)+fmt.Sprint("/raw=", raw)+"/"+api, func(t *testing.T) {
+						unbound, err := x86ScalarFPBitViewAPI(t, source, "func query()", target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || unbound != "" {
+							t.Fatal("original uninitialized query acquired an entry-register contract", err)
+						}
+						ir := x86CPUQueryIR(t, initialized, target.arch, target.triple, api)
+						for _, optimized := range []bool{false, true} {
+							t.Run(fmt.Sprint("O2=", optimized), func(t *testing.T) {
+								input := ir
+								if optimized {
+									input = x86UndefinedTrapOptimizedIR(t, input)
+								}
+								if strings.Count(input, "asm sideeffect \""+strings.ToLower(string(op))+"\"") != 1 {
+									t.Fatal("whole CPU query was removed or duplicated")
+								}
+								dir := t.TempDir()
+								ll, object := filepath.Join(dir, "query.ll"), filepath.Join(dir, "query.o")
+								if err := os.WriteFile(ll, []byte(input), 0600); err != nil {
+									t.Fatal(err)
+								}
+								x86FloatCompareCaptureCommand(t, exec.Command(llc, "-filetype=obj", "-mtriple="+target.triple, ll, "-o", object))
+								actual := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "--disassemble", object))
+								physical := regexp.MustCompile(`(?m)\b` + strings.ToLower(string(op)) + `\b`)
+								if len(physical.FindAll(actual, -1)) != 1 {
+									t.Fatalf("actual LLVM object lost native CPU-query identity:\n%s", actual)
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_cpu_query_family_test.go b/amd64_cpu_query_family_test.go
new file mode 100644
index 000000000..2f95d89e2
--- /dev/null
+++ b/amd64_cpu_query_family_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86CPUQueryCompleteOfficialRowsAndImplicitRegisters(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete Go zero-operand table changed")
+	}
+	for _, form := range []struct {
+		op        Op
+		row       string
+		encoding  []byte
+		registers []Reg
+	}{
+		{OpCPUID, "{ACPUID, ynone, Pm, opBytes{0xa2}}", []byte{0x0f, 0xa2, 0xc3}, []Reg{AX, BX, CX, DX}},
+		{OpXGETBV, "{AXGETBV, ynone, Pm, opBytes{01, 0xd0}}", []byte{0x0f, 0x01, 0xd0, 0xc3}, []Reg{AX, CX, DX}},
+	} {
+		if !strings.Contains(string(table), form.row) {
+			t.Fatal("complete Go CPU-query encoding changed", form.op)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+string(form.op), func(t *testing.T) {
+				source := "TEXT query(SB),4,$0-0\n" + string(form.op) + "\nRET\n"
+				if actual := assembleX87ControlBytes(t, arch, source); !bytes.Equal(actual, form.encoding) {
+					t.Fatalf("original Go CPU-query identity: %x", actual)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, _ := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				for _, register := range form.registers {
+					if ctx.regSlot[register] == "" {
+						t.Errorf("implicit CPU-query register %s has no allocated slot", register)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CPUQueryBareAcceptedSourceAcrossThreeAPIs(t *testing.T) {
+	pkg := mustGoPackage(t, "cpuquery", "package cpuquery\nfunc query()\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{OpCPUID, OpXGETBV} {
+			source := "TEXT ·query(SB),4,$0-0\n" + string(op) + "\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+string(op)+"/"+api, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: arch, ResolveSym: resolve, Sigs: signatures}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						module, translateErr := TranslateModuleInContext(ctx, file, options)
+						err = translateErr
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "Go":
+						translated, translateErr := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, ResolveSym: resolve})
+						err = translateErr
+						if translated != nil && !translated.Module.IsNil() {
+							defer translated.Module.Dispose()
+							ir = translated.Module.String()
+						}
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("Go-accepted syntax supplied missing implicit inputs to %s: %v\n%s", api, err, ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CPUQueryConstructedInvalidOperandsRejectBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{OpCPUID, OpXGETBV} {
+			for _, operand := range []string{"AX", "(AX)", "$1", "AX,DX"} {
+				t.Run(arch+"/"+string(op)+"/"+operand, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT query(SB),4,$0-0\n"+string(op)+" "+operand+"\nRET\n", "", false)
+					// Parse already rejects these source forms. Constructed File/helper
+					// callers must not bypass that grammar and silently emit a query.
+					args, err := parseOperandsCSV(ArchAMD64, op, operand)
+					if err != nil {
+						t.Fatal(err)
+					}
+					fn := Func{Instrs: []Instr{{Op: OpMOVL, Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}}}, {Op: OpMOVL, Args: []Operand{{Kind: OpReg, Reg: DX}, {Kind: OpReg, Reg: AX}}}}}
+					ctx, output := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerArith(op, Instr{Op: op, Args: args, Raw: string(op) + " " + operand})
+					if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+						t.Fatalf("invalid CPU-query form emitted IR: %t/%t/%v", known, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_cpu_query_forms.go b/amd64_cpu_query_forms.go
new file mode 100644
index 000000000..304d0ff1b
--- /dev/null
+++ b/amd64_cpu_query_forms.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86CPUQuerySpec struct {
+	native  string
+	inputs  []Reg
+	outputs []Reg
+	opBytes []byte // Complete Go ynone/Pm opcode row, after its 0x0f prefix.
+}
+
+var x86CPUQuerySpecs = map[Op]x86CPUQuerySpec{
+	OpCPUID:  {"cpuid", []Reg{AX, CX}, []Reg{AX, BX, CX, DX}, []byte{0xa2}},
+	OpXGETBV: {"xgetbv", []Reg{CX}, []Reg{AX, DX}, []byte{0x01, 0xd0}},
+}
+
+func x86CPUQueryProperties(op Op, ins Instr, arch string) (x86CPUQuerySpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86CPUQuerySpecs[Op(name)]
+	if !known {
+		return x86CPUQuerySpec{}, false, nil
+	}
+	if len(ins.Args) != 0 || dotted || arch != "amd64" && arch != "386" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s requires the exact zero-operand Go CPU-query form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+// The native emitter consumes these same low dword inputs before overwriting
+// its zero-extended outputs. Continued execution supplies numerical bytes,
+// not a pointer, caller region, raw entry or promise that XGETBV cannot fault.
+func x86TypedCPUQueryByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86CPUQueryProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if !x86RegisterQueryPreservesSourceState(ins) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: CPU query original/normalized source identity differs", ErrProbeNeedsContext)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for _, register := range spec.inputs {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: 4, read: true,
+		})
+	}
+	for _, register := range spec.outputs {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: 4, write: true,
+		})
+	}
+	return effect, true, nil
+}
+
+func x86TypedRegisterQueryByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if effect, known, err := x86TypedHardwareRandomByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedCPUQueryByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedTimestampByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	return x86TypedRTMStatusByteEffect(op, ins, arch)
+}
+
+// Register queries keep DF and the private numerical stack. Their separate
+// descriptors retain all GP and FLAGS writes: an RTM status query, unlike a CPU
+// query or timestamp, replaces FLAGS. Random producers also replace their one
+// destination and FLAGS. Other opcodes cannot inherit this exact source boundary.
+func x86RegisterQueryPreservesSourceState(ins Instr) bool {
+	if x86HardwareRandomPreservesSourceState(ins) {
+		return true
+	}
+	name := Op(strings.ToUpper(string(ins.Op)))
+	_, cpu := x86CPUQuerySpecs[name]
+	_, timestamp := x86TimestampSpecs[name]
+	rtm, transaction := amd64RTMSpecs[name]
+	status := transaction && rtm.kind == amd64RTMTest
+	if !cpu && !timestamp && !status || len(ins.Args) != 0 || ins.x86Encoded || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	return origin == nil || len(origin.args) == 0 && strings.EqualFold(string(origin.op), string(ins.Op))
+}
+
+func (spec x86CPUQuerySpec) resultType() LLVMType {
+	return LLVMType("{ " + strings.TrimSuffix(strings.Repeat("i32, ", len(spec.outputs)), ", ") + " }")
+}
+
+func (spec x86CPUQuerySpec) constraints() string {
+	var fields []string
+	for _, register := range spec.outputs {
+		fields = append(fields, "={"+strings.ToLower(string(register))+"}")
+	}
+	for _, register := range spec.inputs {
+		fields = append(fields, "{"+strings.ToLower(string(register))+"}")
+	}
+	// Preserve source ordering at the compiler boundary. These conservative
+	// clobbers do not assert that XGETBV serializes hardware or changes flags.
+	fields = append(fields, "~{dirflag}", "~{fpsr}", "~{flags}", "~{memory}")
+	return strings.Join(fields, ",")
+}
+
+func emitX86CPUQuery(b *strings.Builder, spec x86CPUQuerySpec, inputs []string, newTmp func() string) []string {
+	arguments := make([]string, len(inputs))
+	for index, input := range inputs {
+		arguments[index] = "i32 " + input
+	}
+	call := newTmp()
+	fmt.Fprintf(b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n",
+		call, spec.resultType(), spec.native, spec.constraints(), strings.Join(arguments, ", "))
+	outputs := make([]string, len(spec.outputs))
+	for index := range outputs {
+		part := newTmp()
+		fmt.Fprintf(b, "  %%%s = extractvalue %s %%%s, %d\n", part, spec.resultType(), call, index)
+		outputs[index] = "%" + part
+	}
+	return outputs
+}
+
+func (c *amd64Ctx) lowerX86CPUQuery(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86CPUQueryProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	inputs := make([]string, len(spec.inputs))
+	for index, register := range spec.inputs {
+		value, err := c.loadReg(register)
+		if err != nil {
+			return true, false, err
+		}
+		inputs[index] = c.truncI64(value, I32)
+	}
+	outputs := emitX86CPUQuery(c.b, spec, inputs, c.newTmp)
+	for index, register := range spec.outputs {
+		if err := c.storeRegSized(register, I32, outputs[index]); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
diff --git a/amd64_cpu_query_linux_amd64_test.go b/amd64_cpu_query_linux_amd64_test.go
new file mode 100644
index 000000000..447a75f5e
--- /dev/null
+++ b/amd64_cpu_query_linux_amd64_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CPUQuery386IndependentC() string {
+	return strings.NewReplacer(
+		"uint64_t", "uint32_t", "UINT64_C(0xabcdef0123456789)", "UINT32_C(0x23456789)",
+		"UINT64_C(0x13579bdf2468ace0)", "UINT32_C(0x2468ace0)",
+		"UINT64_C(0x7e6d5c4b3a291807)", "UINT32_C(0x3a291807)",
+		"UINT64_C(0xa1b2c3d400000000)", "UINT32_C(0)",
+	).Replace(x86CPUQueryIndependentC)
+}
+
+// Real Linux IA32 execution is required separately from Rosetta, emulators
+// and portable object compilation. Missing LLVM 22/cross tools fail this root.
+func TestCrossLinuxRuntimeMatrixX86CPUQueryNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required LLVM 22/native IA32 compiler: %v", err)
+	}
+	dir := t.TempDir()
+	referenceSource, referenceExecutable := filepath.Join(dir, "reference.c"), filepath.Join(dir, "reference")
+	if err := os.WriteFile(referenceSource, []byte("#define REFERENCE_ONLY 1\n"+x86CPUQuery386IndependentC()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie", referenceSource, "-O2", "-o", referenceExecutable))
+	referenceProgram, err := x87IA32StaticExecutable(referenceExecutable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	reference := string(x87IA32RunDirect(t, referenceProgram, nil, os.Environ()))
+	lines := strings.Split(strings.TrimSpace(reference), "\n")
+	if len(lines) != 2 || !strings.HasPrefix(lines[0], "cpu query ") || !strings.HasPrefix(lines[1], "xgetbv ") {
+		t.Fatalf("actual native IA32 query reference: %q", reference)
+	}
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			original := x86CPUQueryBuildOriginal386(t, raw)
+			for _, suffix := range []string{"", "_af"} {
+				if err := original.verify(); err != nil {
+					t.Fatal(err)
+				}
+				output, err := x87IA32Capture(t, original.path, []string{suffix}, "", append(os.Environ(), "GOTRACEBACK=system"))
+				if guard := original.verify(); guard != nil {
+					t.Fatal(guard)
+				}
+				if lines[1] == "xgetbv SIGILL" {
+					if !x86UndefinedTrapOriginalSignal(output, err) || !strings.HasPrefix(string(output), lines[0]+"\n") {
+						t.Fatalf("original native IA32 query fault: %v\n%s", err, output)
+					}
+				} else if err != nil || string(output) != reference {
+					t.Fatalf("original native IA32 query state: %v\n%s", err, output)
+				}
+			}
+			declarations, assembly := x86CPUQueryRuntimeFixtures(raw, "386")
+			pkg := mustGoPackage(t, "cpuquery386", "package cpuquery386\n"+declarations)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+				GOARCH: "386", TargetTriple: "i386-unknown-linux-gnu",
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				if err != nil {
+					translated.Module.Dispose()
+				}
+			}
+			if err != nil || translated == nil || translated.Module.IsNil() {
+				t.Fatalf("native IA32 query module: %v", err)
+			}
+			ir := translated.Module.String()
+			verification := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction)
+			translated.Module.Dispose()
+			if verification != nil {
+				t.Fatal(verification)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86UndefinedTrapOptimizedIR(t, input)
+					}
+					dir := t.TempDir()
+					ll, object := filepath.Join(dir, "query.ll"), filepath.Join(dir, "query.o")
+					main, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "query")
+					for name, contents := range map[string]string{ll: input, main: x86CPUQuery386IndependentC()} {
+						if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", ll, "-o", object))
+					x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie", object, main, "-O2", "-o", executable))
+					sealed, err := x87IA32StaticExecutable(executable)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != reference {
+						t.Fatalf("actual native IA32 LLVM query state: %q / %q", output, reference)
+					}
+				})
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_cpu_query_native_reference_test.go b/amd64_cpu_query_native_reference_test.go
new file mode 100644
index 000000000..097f83abf
--- /dev/null
+++ b/amd64_cpu_query_native_reference_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86CPUQueryBuildOriginal386(t *testing.T, raw bool) x87IA32Executable {
+	t.Helper()
+	declarations, assembly := x86CPUQueryRuntimeFixtures(raw, "386")
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module cpuquery386\n\ngo 1.20\n", "main.go": x86CPUQuery386OriginalDriver(),
+		"decl.go": "package main\n" + declarations, "query_386.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=1", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOOS=linux", "GOARCH=386", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	sealed, err := x87IA32StaticExecutable(executable)
+	if err != nil || sealed.verify() != nil {
+		t.Fatalf("unchanged IA32 query reference did not compile as stable ELF32: %v", err)
+	}
+	return sealed
+}
+
+// This portable axis compiles unchanged original Go objects, not a native
+// execution pass. The required Linux counterpart runs these same programs.
+func TestX86CPUQuery386OriginalNativeReferenceCompiles(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			_ = x86CPUQueryBuildOriginal386(t, raw)
+		})
+	}
+}
+
+func TestX86CPUQuery386RuntimeSourceObjects(t *testing.T) {
+	x86CPUQueryRuntimeSourceObjects(t, "386", []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"})
+}
+
+func TestX86CPUQueryAMD64RuntimeSourceObjects(t *testing.T) {
+	x86CPUQueryRuntimeSourceObjects(t, "amd64", []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	})
+}
+
+func x86CPUQueryRuntimeSourceObjects(t *testing.T, arch string, triples []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, raw := range []bool{false, true} {
+		declarations, source := x86CPUQueryRuntimeFixtures(raw, arch)
+		for _, triple := range triples {
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", triple, raw, api), func(t *testing.T) {
+					ir := x86CPUQueryIRFromDeclaration(t, source, declarations, arch, triple, api)
+					for _, op := range []string{"cpuid", "xgetbv"} {
+						if strings.Count(ir, "asm sideeffect \""+op+"\"") != 2 {
+							t.Fatal("original native query reference lost a complete opcode", op)
+						}
+					}
+					compileLLVMToObject(t, llc, triple, "query.ll", "query.o", ir)
+					compileLLVMToObject(t, llc, triple, "query-opt.ll", "query-opt.o", x86UndefinedTrapOptimizedIR(t, ir))
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_cpu_query_runtime_fixtures_test.go b/amd64_cpu_query_runtime_fixtures_test.go
new file mode 100644
index 000000000..70c4508bc
--- /dev/null
+++ b/amd64_cpu_query_runtime_fixtures_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func x86CPUQueryRuntimeFixtures(raw bool, arch string) (declarations, assembly string) {
+	for _, op := range []Op{OpCPUID, OpXGETBV} {
+		name := "query"
+		if op == OpXGETBV {
+			name = "fault"
+		}
+		body := string(op) + "\n"
+		if raw {
+			body = "BYTE $0x0f\nBYTE $0xa2\n"
+			if op == OpXGETBV {
+				body = "BYTE $0x0f\nBYTE $0x01\nBYTE $0xd0\n"
+			}
+		}
+		for index, seed := range []uint64{0x8c7, 0x12} {
+			entry := name
+			if index != 0 {
+				entry += "_af"
+			}
+			declarations += fmt.Sprintf("func %s(out *[8]uint64)\n", entry)
+			assembly += fmt.Sprintf(`TEXT ·%s(SB),4,$0-8
+    MOVQ out+0(FP),DI
+    MOVQ $0xa1b2c3d400000000,AX
+    MOVQ $0xa1b2c3d400000000,CX
+    MOVQ $0x7e6d5c4b3a291807,BX
+    MOVQ $-1,DX
+    PUSHQ $%#x
+    POPFQ
+    %s
+    MOVQ AX,0(DI)
+    MOVQ BX,8(DI)
+    MOVQ CX,16(DI)
+    MOVQ DX,24(DI)
+    PUSHFQ
+    POPQ R8
+    MOVQ R8,32(DI)
+    STMXCSR 40(DI)
+    RET
+`, entry, seed, body)
+		}
+	}
+	if arch == "386" {
+		declarations = strings.ReplaceAll(declarations, "uint64", "uint32")
+		assembly = strings.NewReplacer(
+			"$0-8", "$0-4", "MOVQ", "MOVL", "PUSHQ", "PUSHL", "POPFQ", "POPFL",
+			"PUSHFQ", "PUSHFL", "POPQ R8", "POPL SI", "R8,32(DI)", "SI,16(DI)",
+			"$0xa1b2c3d400000000", "$0", "$0x7e6d5c4b3a291807", "$0x3a291807",
+			"BX,8(DI)", "BX,4(DI)", "CX,16(DI)", "CX,8(DI)", "DX,24(DI)", "DX,12(DI)",
+			"40(DI)", "20(DI)",
+		).Replace(assembly)
+	} else if arch != "amd64" {
+		panic("CPU-query fixture requires an x86 architecture")
+	}
+	return
+}
+
+const x86CPUQueryOriginalDriver = `package main
+
+import (
+    "fmt"
+    "os"
+    "syscall"
+)
+
+func main() {
+    if err := syscall.Setrlimit(syscall.RLIMIT_CORE, &syscall.Rlimit{}); err != nil {
+        panic(err)
+    }
+    cpu, state, flags := query, fault, uint64(0x8c5)
+    if len(os.Args) == 2 && os.Args[1] == "_af" {
+        cpu, state, flags = query_af, fault_af, 0x10
+    }
+    sample := func(call func(*[8]uint64)) [8]uint64 {
+        out := [8]uint64{0,0,0,0,0,0,0xabcdef0123456789,0x13579bdf2468ace0}
+        call(&out)
+        if out[4]&0x8d5 != flags || out[6] != 0xabcdef0123456789 || out[7] != 0x13579bdf2468ace0 {
+            panic(fmt.Sprintf("original query flags/canary: %x", out))
+        }
+        return out
+    }
+    out := sample(cpu)
+    for _, value := range out[:4] {
+        if value>>32 != 0 { panic("query output did not zero-extend") }
+    }
+    fmt.Printf("cpu query %x %x %x %x\n", out[0],out[1],out[2],out[3])
+    out = sample(state)
+    if out[0]>>32 != 0 || out[3]>>32 != 0 || out[1] != 0x7e6d5c4b3a291807 || out[2] != 0xa1b2c3d400000000 {
+        panic(fmt.Sprintf("original XGETBV implicit registers: %x", out))
+    }
+    fmt.Printf("xgetbv %x %x\n", out[0],out[3])
+}
+`
+
+func x86CPUQuery386OriginalDriver() string {
+	return strings.NewReplacer(
+		"uint64", "uint32", "0xabcdef0123456789", "0x23456789", "0x13579bdf2468ace0", "0x2468ace0",
+		"0x7e6d5c4b3a291807", "0x3a291807", "0xa1b2c3d400000000", "0",
+	).Replace(x86CPUQueryOriginalDriver)
+}
diff --git a/amd64_cpu_query_runtime_unix_test.go b/amd64_cpu_query_runtime_unix_test.go
new file mode 100644
index 000000000..3df4dde82
--- /dev/null
+++ b/amd64_cpu_query_runtime_unix_test.go
@@ -0,0 +1,186 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86CPUQueryOriginalAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	referenceSource, referenceExecutable := filepath.Join(dir, "reference.c"), filepath.Join(dir, "reference")
+	if err := os.WriteFile(referenceSource, []byte("#define REFERENCE_ONLY 1\n"+x86CPUQueryIndependentC), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, referenceSource, referenceExecutable)
+	reference := string(execution.run(t, referenceExecutable))
+	lines := strings.Split(strings.TrimSpace(reference), "\n")
+	if len(lines) != 2 || !strings.HasPrefix(lines[0], "cpu query ") || !strings.HasPrefix(lines[1], "xgetbv ") {
+		t.Fatalf("independent native CPU/OS-state reference: %q", reference)
+	}
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			declarations, assembly := x86CPUQueryRuntimeFixtures(raw, "amd64")
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			original := x86CPUQueryBuildOriginal(t, execution, declarations, assembly)
+			for _, suffix := range []string{"", "_af"} {
+				arguments := execution.command(original)
+				arguments = append(arguments, suffix)
+				ctx, cancel := runtimeOracleStageContext(t)
+				command := exec.CommandContext(ctx, arguments[0], arguments[1:]...)
+				command.Env = append(os.Environ(), "GOTRACEBACK=system")
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				cancel()
+				if lines[1] == "xgetbv SIGILL" {
+					if !x86UndefinedTrapOriginalSignal(output, err) || !strings.HasPrefix(string(output), lines[0]+"\n") {
+						t.Fatalf("unchanged Go XGETBV did not retain its actual unavailable-ISA fault: %v\n%s", err, output)
+					}
+				} else if err != nil || string(output) != reference {
+					t.Fatalf("original Go query values/zero extension/flags/canaries differ from native reference: %v\n%s\nreference=%s", err, output, reference)
+				}
+			}
+			ir := x86NarrowOracleIR(t, assembly, "package cpuquery\n"+declarations, execution.triple)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86UndefinedTrapOptimizedIR(t, input)
+					}
+					output := execution.compileAndRunLLVM(t, "cpuquery", input, x86CPUQueryIndependentC, level)
+					if string(output) != reference {
+						t.Fatalf("LLVM query result/fault differs from independent native reference: %q / %q", output, reference)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86CPUQueryBuildOriginal(t *testing.T, execution x86FloatCompareExecution, declarations, assembly string) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module cpuquery\n\ngo 1.20\n", "main.go": x86CPUQueryOriginalDriver,
+		"decl.go": "package main\n" + declarations, "query_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=1", "-o", executable, ".")
+	command.Dir = dir
+	goos := runtime.GOOS
+	if strings.Contains(execution.triple, "linux") {
+		goos = "linux"
+	}
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOOS="+goos, "GOARCH=amd64", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	return executable
+}
+
+const x86CPUQueryIndependentC = `
+#include <cpuid.h>
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+// Observe the actual instruction, not an advertised CPUID capability. An
+// emulator may mask OSXSAVE while still implementing XGETBV successfully.
+static int native_state(unsigned *low, unsigned *high) {
+    int channel[2];
+    if (pipe(channel)) return -1;
+    pid_t child=fork();
+    if (child<0) {
+        close(channel[0]);
+        close(channel[1]);
+        return -1;
+    }
+    if (child==0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        if (close(channel[0])) _exit(121);
+        unsigned values[2];
+        __asm__ volatile("xgetbv" : "=a"(values[0]),"=d"(values[1]) : "c"(0));
+        if (write(channel[1],values,sizeof(values))!=sizeof(values) || close(channel[1])) _exit(122);
+        _exit(0);
+    }
+    if (close(channel[1])) return -1;
+    int status=0;
+    pid_t waited;
+    do { waited=waitpid(child,&status,0); } while (waited<0 && errno==EINTR);
+    unsigned values[2]={0,0};
+    ssize_t count=read(channel[0],values,sizeof(values));
+    if (close(channel[0]) || waited!=child) return -1;
+    if (WIFSIGNALED(status) && WTERMSIG(status)==SIGILL && count==0) return 0;
+    if (!WIFEXITED(status) || WEXITSTATUS(status)!=0 || count!=sizeof(values)) return -1;
+    *low=values[0];
+    *high=values[1];
+    return 1;
+}
+
+#if !REFERENCE_ONLY
+extern void query(uint64_t *);
+extern void query_af(uint64_t *);
+extern void fault(uint64_t *);
+extern void fault_af(uint64_t *);
+
+static int check(uint64_t *out, uint64_t flags, unsigned csr) {
+    return (out[4]&0x8d5)==flags && out[5]==csr &&
+        out[6]==UINT64_C(0xabcdef0123456789) && out[7]==UINT64_C(0x13579bdf2468ace0);
+}
+#endif
+
+int main(void) {
+    unsigned a,b,c,d,low=0,high=0;
+    int available=native_state(&low,&high);
+    if (available<0) return 10;
+    if (!__get_cpuid(0,&a,&b,&c,&d)) return 11;
+#if !REFERENCE_ONLY
+    void (*cpu[])(uint64_t *)={query,query_af};
+    void (*state[])(uint64_t *)={fault,fault_af};
+    const uint64_t flags[]={0x8c5,0x10};
+    for (unsigned index=0;index<2;index++) {
+        uint64_t out[8]={0,0,0,0,0,0,UINT64_C(0xabcdef0123456789),UINT64_C(0x13579bdf2468ace0)};
+        unsigned before,after;
+        __asm__ volatile("stmxcsr %0" : "=m"(before));
+        cpu[index](out);
+        __asm__ volatile("stmxcsr %0" : "=m"(after));
+        if (!check(out,flags[index],before) || after!=before || out[0]!=a || out[1]!=b || out[2]!=c || out[3]!=d) return 12;
+        if (available) {
+            state[index](out);
+            __asm__ volatile("stmxcsr %0" : "=m"(after));
+            if (!check(out,flags[index],before) || after!=before || out[0]!=low || out[3]!=high ||
+                out[1]!=UINT64_C(0x7e6d5c4b3a291807) || out[2]!=UINT64_C(0xa1b2c3d400000000)) return 13;
+        } else {
+            pid_t child=fork();
+            if (child<0) return 14;
+            if (child==0) {
+                struct rlimit no_core = {0, 0};
+                if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+                state[index](out);
+                _exit(91);
+            }
+            int status=0;
+            if (waitpid(child,&status,0)!=child || !WIFSIGNALED(status) || WTERMSIG(status)!=SIGILL) return 15;
+        }
+    }
+#endif
+    printf("cpu query %x %x %x %x\n",a,b,c,d);
+    if (available) printf("xgetbv %x %x\n",low,high);
+    else puts("xgetbv SIGILL");
+    return 0;
+}
+`
diff --git a/amd64_crc32_forms.go b/amd64_crc32_forms.go
new file mode 100644
index 000000000..b394afb73
--- /dev/null
+++ b/amd64_crc32_forms.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86CRC32Form struct {
+	bits                int
+	source, destination Operand
+}
+
+// ycrc32b is Zlitm_r/Ymb,Yrl; W/L/Q use Zlitm_r/Yml,Yrl.
+// Px/Pe/Pw select the source width, not the accumulator width: every row
+// reads only the old low32 and writes a zero-extended CRC32 result.
+var x86CRC32Specs = map[Op]int{"CRC32B": 8, "CRC32W": 16, "CRC32L": 32, "CRC32Q": 64}
+
+func x86CRC32Properties(op Op, ins Instr, arch string) (x86CRC32Form, bool, error) {
+	name, _, suffix := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86CRC32Specs[Op(name)]
+	if !known {
+		return x86CRC32Form{}, false, nil
+	}
+	fail := func(reason string) (x86CRC32Form, bool, error) {
+		return x86CRC32Form{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || arch == "386" && bits == 64 || suffix ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 2 {
+		return fail("requires its complete Go mode and source/destination row")
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, arch) {
+		return fail("requires a Go Yrl accumulator destination")
+	}
+	if source.Kind == OpReg {
+		valid := isX86YrlRegisterForArch(source.Reg, arch)
+		if bits == 8 {
+			valid = isGoYmbRegisterForArch(source.Reg, arch)
+		}
+		if !valid {
+			return fail("source is outside its Go Ymb/Yml register class")
+		}
+	} else {
+		if x86SourceTLSMemoryRole(source, arch) {
+			return x86CRC32Form{}, true, fmt.Errorf("%w: CRC32 TLS source needs its actual native address contract", ErrProbeNeedsContext)
+		}
+		if !x86ScalarCompareMemoryValid(source, arch) {
+			return fail("requires an encodable Go Ymb/Yml memory source")
+		}
+	}
+	if arch == "amd64" && bits == 8 && source.Kind == OpReg && !ins.x86Encoded && ins.x86SourceRaw == nil {
+		source.Reg = x86CRC32GoByteRegister(source.Reg, destination.Reg)
+	}
+	return x86CRC32Form{bits: bits, source: source, destination: destination}, true, nil
+}
+
+// Unlike Pb, Go's Px/Zlitm_r CRC row never calls bytereg. Full SP/BP/SI/DI
+// therefore encode AH/CH/DH/BH without REX. An extended accumulator or an
+// explicit low-byte/extended source selects the REX low-byte view instead.
+// This local operand copy does not rewrite original source/certificate identity.
+func x86CRC32GoByteRegister(source, destination Reg) Reg {
+	rex := strings.HasPrefix(string(destination), "R") || strings.HasPrefix(string(source), "R") ||
+		source == BPB || source == SIB || source == DIB
+	if rex {
+		switch source {
+		case AH, CH, DH, BH:
+			return amd64YmbEffectiveRegister(source, 16)
+		}
+		return source
+	}
+	switch source {
+	case SP:
+		return AH
+	case BP:
+		return CH
+	case SI:
+		return DH
+	case DI:
+		return BH
+	}
+	return source
+}
+
+// NUM-only dependency registration is deliberately not admission in the raw,
+// source-stack or caller grammars. All inputs precede any destination write.
+func x86TypedCRC32ByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86CRC32Properties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: int64(form.bits / 8), read: true},
+		{index: 1, operand: form.destination, width: 4, read: true, write: true},
+	}}, true, nil // CRC32 preserves all six status bits and DF.
+}
+
+func x86LoweredCRC32NativeRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86CRC32Properties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) ||
+		!x86ResultRead(form.destination, 4, state, owned, arch) ||
+		!x86ResultReadWithNativeContinuation(ins, form.source, int64(form.bits/8), state, owned, arch, true) {
+		return false, true
+	}
+	return x86ResultStore(form.destination, 4, state, owned, resultOffset, arch), true
+}
diff --git a/amd64_ctx.go b/amd64_ctx.go
index 3eeef7edb..498b5b2b4 100644
--- a/amd64_ctx.go
+++ b/amd64_ctx.go
@@ -16,13 +16,17 @@ type amd64Ctx struct {
 	goarch       string
 	targetTriple string
 
-	resolve  func(string) string
-	sigs     map[string]FuncSig
-	annotate bool
+	resolve        func(string) string
+	sigs           map[string]FuncSig
+	annotate       bool
+	continuations  map[string]x86Continuation
+	indirectLabels []string
+	indirectABI0   *FuncSig // proven straight-line stack-argument callback adapter
 
 	tmp int
 
-	blocks []amd64Block
+	blocks     []amd64Block
+	directTail *x86DirectTailRoot
 	// Mapping between linear instruction index and block index. Used to
 	// resolve n(PC) branches which are instruction-relative.
 	blockBase  []int
@@ -31,9 +35,8 @@ type amd64Ctx struct {
 	usedRegs map[Reg]bool
 	regSlot  map[Reg]string // gp reg -> alloca name
 
-	zeroUpperVector bool // VEX/EVEX writes clear the upper register bits
-	usedXRegs       map[int]bool
-	xRegSlot        map[int]string // xmm reg index -> alloca name (<16 x i8>)
+	usedXRegs map[int]bool
+	xRegSlot  map[int]string // xmm reg index -> alloca name (<16 x i8>)
 
 	usedYRegs map[int]bool
 	yRegSlot  map[int]string // ymm reg index -> alloca name (<32 x i8>)
@@ -41,38 +44,70 @@ type amd64Ctx struct {
 	usedZRegs map[int]bool
 	zRegSlot  map[int]string // zmm reg index -> alloca name (<64 x i8>)
 
-	usedKRegs      map[int]bool
-	kRegSlot       map[int]string // avx512 mask reg index -> alloca name (i64)
-	usedX87        bool
-	usesX87Convert bool
-	x87Slot        [8]string // x87 stack registers, represented as f64 values
-	x87ControlSlot string
-	x87StatusSlot  string // condition-code status populated by FTST for FSTSW
-	x87IntegerSlot string // hardware FISTP result for explicit 386 x87 lowering
-	x87Mode        X87Mode
-
-	flagsZSlot     string
-	flagsSltSlot   string // signed negative-style bit for J{L,LE,G,GE}-like checks
-	flagsCFSlot    string // carry/borrow style bit for J{B,BE,A,AE,NC,C}-like checks
-	flagsOFSlot    string // overflow-style bit used by ADOX carry chain modeling
-	flagsIDSlot    string // CPUID availability bit preserved by PUSHFL/POPFL
-	flagsWritten   bool
-	allowSPWrite   bool   // current instruction has an explicitly modeled 386 SP destination
-	directionSlot  string // x86 DF, used by MOVS/STOS/SCAS instructions
-	repeatPrefix   string // pending REP/REPN prefix for the following instruction
-	vstackSlot     string // [64 x i64] virtual stack for PUSHQ/POPQ
-	vspSlot        string // i64 virtual stack pointer (next free slot)
-	localStackSlot string // byte-addressable backing storage for x86 SP references
-	classicFrame   string // contiguous classic Go ABI frame used by 386 FP addressing
-	classicSize    int64
-	classicBias    int64
-
-	fpParams       map[int64]FrameSlot // off(FP) -> slot
-	fpResults      []FrameSlot
-	fpResAllocaOff map[int64]string // off(FP) -> alloca
-	fpResAllocaIdx map[int]string   // result index -> alloca
-	fpResWritten   map[int]bool     // result index -> whether written via +off(FP)
-	fpResAddrTaken map[int]bool     // result index -> address of fp_ret_* escaped
+	usedKRegs           map[int]bool
+	kRegSlot            map[int]string // avx512 mask reg index -> alloca name (i64)
+	usedX87             bool
+	usesX87Convert      bool
+	x87Slot             [8]string // x87 stack registers, represented as f64 values
+	x87IntegerValueSlot [8]string // Exact signed-integer payload for each logical value.
+	x87ExactSlot        [8]string // Runtime tag; never source availability or entry authority.
+	x87ControlSlot      string
+	x87StatusSlot       string // condition-code status populated by FTST for FSTSW
+	x87IntegerSlot      string // hardware FISTP result for explicit 386 x87 lowering
+	x87Mode             X87Mode
+
+	flagsZSlot        string
+	flagsSltSlot      string // architectural SF; signed conditions combine it with OF
+	flagsCFSlot       string // carry/borrow style bit for J{B,BE,A,AE,NC,C}-like checks
+	flagsPFSlot       string // parity bit for J{P,PE,PS,NP,PO,PC}-like checks
+	flagsAFSlot       string // auxiliary carry/borrow from bit 3, exposed by LAHF/PUSHF
+	flagsOFSlot       string // overflow-style bit used by ADOX carry chain modeling
+	flagsIDSlot       string // CPUID ID bit preserved by native-width flags stack forms
+	flagsWritten      bool
+	allowSPWrite      bool   // current instruction has an explicitly modeled 386 SP destination
+	directionSlot     string // x86 DF, used by MOVS/STOS/SCAS instructions
+	repeatPrefix      string // pending REP/REPN prefix for the following instruction
+	namedAtomicLock   bool   // actual same-block source-adjacent LOCK for this instruction only
+	lockScalarNS      string // compiler name allocation, not a source capability
+	bitScanNS         string // compiler name allocation, not a source capability
+	vstackSlot        string // [64 x i64] virtual stack for PUSHQ/POPQ
+	vspSlot           string // i64 virtual stack pointer (next free slot)
+	localStackSlot    string // byte-addressable backing storage for x86 SP references
+	logicalAUTOBase   string // immutable entry-SP SSA address, not a source pointer fact
+	logicalAUTOExtent int    // proved ordinary logical frame bytes above entry SP
+	privateFlagsStack bool   // complete paired mode32 proof owns bare nonnegative SP offsets
+	sourceStack       *x86SourceStackProof
+	fixedLocal        *x86FixedLocalProof
+	fixedMemRoles     map[MemRef]MemRef // exact certified current-instruction native role projection
+	frameSize         int64             // local bytes below the Go assembler's implicit amd64 BP
+	classicFrame      string            // contiguous classic Go ABI frame used by 386 FP addressing
+	classicSize       int64
+	classicBias       int64
+
+	fpParams          map[int64]FrameSlot // off(FP) -> slot
+	fpParamAlloca     map[int64]string    // off(FP) -> mutable parameter shadow
+	fpResults         []FrameSlot
+	fpResAllocaOff    map[int64]string             // off(FP) -> alloca
+	fpResAllocaIdx    map[int]string               // result index -> alloca
+	fpResWritten      map[int]bool                 // result index -> whether written via +off(FP)
+	fpResAddrTaken    map[int]bool                 // result index -> address of fp_ret_* escaped
+	fpScalarSource    Func                         // source for all-path checks of new scalar result views
+	fpSourceSig       FuncSig                      // original request-local declaration before feature rendering
+	fpFeatureAttrs    string                       // exact compiler-rendered feature reference, never supplied attributes
+	fixedLocalResult  *x86FixedLocalResultSnapshot // pure per-call source index; live module guards remain separate
+	fpBoolCallSource  *x86ABI0BoolCallSource       // complete custom-helper graph, not a standalone register entry
+	fpScalarData      map[x86StaticSBAddress]int64 // exact effective SB address -> available emitted numerical bytes
+	fpShiftLiterals   map[x86StaticSBAddress]x86ShiftLiteral
+	goReadOnlyStorage *goReadOnlyStorage // declaration-only numerical reads, never emitted/writable DATA
+	goReadOnlyOperand *goReadOnlyRead    // exact current instruction; cleared before the next instruction
+	fpScalarChecked   bool
+	fpScalarCheckErr  error
+	fpScalarTrapOnly  bool // Complete private logical-shadow proof: every path ends in an exact trap.
+	fpMixedBoolBytes  bool // Ordinary tuple inputs/canonical bool passed; result audit is separate.
+	dataBPSource      bool // Complete named leaf's private opaque-pointer holder, never physical BP.
+
+	fpStaticAddressValues *x86StaticAddressValues // No dereference capability.
+	nativeMMXRegion       *x86NativeMMXRegion     // Whole source/NUM proof paired to the actual emitted MMX region.
 }
 
 func newAMD64Ctx(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, annotate bool) *amd64Ctx {
@@ -88,6 +123,10 @@ func newX86Ctx(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) st
 		resolve:        resolve,
 		sigs:           sigs,
 		annotate:       annotate,
+		frameSize:      fn.FrameSize,
+		sourceStack:    fn.x86SourceStack,
+		fixedLocal:     fn.x86FixedLocal,
+		indirectABI0:   inferX86ABI0Forwarder(fn, sig, goarch),
 		blocks:         amd64SplitBlocks(fn),
 		usedRegs:       map[Reg]bool{},
 		regSlot:        map[Reg]string{},
@@ -100,15 +139,29 @@ func newX86Ctx(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) st
 		usedKRegs:      map[int]bool{},
 		kRegSlot:       map[int]string{},
 		fpParams:       map[int64]FrameSlot{},
+		fpParamAlloca:  map[int64]string{},
 		fpResAllocaOff: map[int64]string{},
 		fpResAllocaIdx: map[int]string{},
 		fpResWritten:   map[int]bool{},
 		fpResAddrTaken: map[int]bool{},
+		fpScalarSource: fn,
+		fpSourceSig:    sig,
+		dataBPSource:   x86DataBPSourceScope(fn, sig, goarch),
 		blockByIdx:     map[int]int{},
 	}
+	if fn.x86DirectTailRoot != nil {
+		c.directTail = fn.x86DirectTailRoot
+		c.blocks = c.directTail.blocks()
+	}
 	for _, s := range sig.Frame.Params {
 		c.fpParams[s.Offset] = s
 	}
+	c.continuations = make(map[string]x86Continuation, len(fn.x86ContinuationAddresses))
+	for symbol, target := range fn.x86ContinuationAddresses {
+		target.root = resolve(target.root)
+		c.continuations[resolve(symbol)] = target
+	}
+	c.indirectLabels = fn.x86IndirectLabels
 	c.fpResults = append([]FrameSlot(nil), sig.Frame.Results...)
 	base := 0
 	for i, blk := range c.blocks {
@@ -120,7 +173,7 @@ func newX86Ctx(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) st
 }
 
 func (c *amd64Ctx) useHardwareX87() bool {
-	return c.goarch == "386" && c.x87Mode != X87Software
+	return c.x87Mode != X87Software
 }
 
 func (c *amd64Ctx) emitSourceComment(ins Instr) {
@@ -136,7 +189,7 @@ func (c *amd64Ctx) newTmp() string {
 }
 
 func (c *amd64Ctx) slotName(r Reg) string {
-	return "%" + amd64LLVMBlockName("reg_"+string(r))
+	return "%reg_" + amd64LLVMSafeName(string(r))
 }
 
 func (c *amd64Ctx) xSlotName(i int) string {
@@ -208,6 +261,10 @@ func (c *amd64Ctx) scanUsedRegs() {
 		if r == "" {
 			return
 		}
+		// Byte aliases are read and written through their containing GP slot.
+		if base, _, ok := amd64ByteAlias(r); ok {
+			r = base
+		}
 		if idx, ok := amd64ParseXReg(r); ok {
 			c.usedXRegs[idx] = true
 			return
@@ -224,7 +281,7 @@ func (c *amd64Ctx) scanUsedRegs() {
 			c.usedKRegs[idx] = true
 			return
 		}
-		if _, ok := amd64ParseX87Reg(r); ok && c.goarch == "386" {
+		if _, ok := amd64ParseX87Reg(r); ok {
 			c.usedX87 = true
 			return
 		}
@@ -235,9 +292,13 @@ func (c *amd64Ctx) scanUsedRegs() {
 		case OpReg:
 			markReg(op.Reg)
 		case OpMem:
-			markReg(op.Mem.Base)
-			if op.Mem.Index != "" {
-				markReg(op.Mem.Index)
+			memory := op.Mem
+			if named, valid := x86SBMemoryAddressRole(op, c.goarch); valid {
+				memory = named // An ignored Reg must not allocate a virtual stack.
+			}
+			markReg(memory.Base)
+			if memory.Index != "" {
+				markReg(memory.Index)
 			}
 		case OpRegList:
 			for _, r := range op.RegList {
@@ -248,27 +309,128 @@ func (c *amd64Ctx) scanUsedRegs() {
 
 	for _, blk := range c.blocks {
 		for _, ins := range blk.instrs {
+			if form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, c.goarch); known && err == nil {
+				markReg(form.destination)
+			}
+			if form, known, err := x86CRC32Properties(ins.Op, ins, c.goarch); known && err == nil {
+				markOp(form.source) // Px/Zlitm_r can select a different byte's GP root.
+				markOp(form.destination)
+			}
+			if effect, known, err := x86TypedPackedIntegerCompareByteEffect(ins.Op, ins, c.goarch); known && err == nil {
+				for _, operand := range effect.operands {
+					markOp(operand.operand)
+				}
+			}
 			op := strings.ToUpper(string(ins.Op))
-			if c.goarch == "386" && isX87Op(Op(op)) {
+			if dot := strings.IndexByte(op, '.'); dot >= 0 {
+				op = op[:dot]
+			}
+			if isX87Op(Op(op)) {
 				c.usedX87 = true
 				if op == "FMOVVP" {
 					c.usesX87Convert = true
 				}
 			}
+			if op == "LAHF" || op == "SAHF" {
+				markReg(AX)
+			}
+			if spec, ok := amd64ImplicitSystemSpecs[Op(op)]; ok {
+				registers := spec.inputs | spec.outputs
+				if registers&amd64ImplicitAX != 0 {
+					markReg(AX)
+				}
+				if registers&amd64ImplicitCX != 0 {
+					markReg(CX)
+				}
+				if registers&amd64ImplicitDX != 0 {
+					markReg(DX)
+				}
+			}
+			if spec, known, err := x86TimestampProperties(Op(op), ins, c.goarch); known && err == nil {
+				for _, register := range x86TimestampRegisters(spec) {
+					markReg(register)
+				}
+			}
+			if spec, known, err := x86CPUQueryProperties(Op(op), ins, c.goarch); known && err == nil {
+				for _, register := range spec.inputs {
+					markReg(register)
+				}
+				for _, register := range spec.outputs {
+					markReg(register)
+				}
+			}
+			if spec, known, err := amd64PackedStringCompareProperties(Op(op), ins, c.goarch); known && err == nil {
+				output, _, _ := spec.resultEffect()
+				markReg(output)
+				if spec.explicitLength {
+					markReg(AX)
+					markReg(DX)
+				}
+			}
+			if spec, ok := amd64RTMSpecs[Op(op)]; ok && spec.outputAX {
+				markReg(AX)
+			}
+			if spec, ok := amd64SystemTransferSpecs[Op(op)]; ok {
+				if spec.inputs&amd64SystemTransferCX != 0 {
+					markReg(CX)
+				}
+				if spec.inputs&amd64SystemTransferDX != 0 {
+					markReg(DX)
+				}
+				if c.goarch != "386" && spec.inputs&amd64SystemTransferR11 != 0 {
+					markReg(Reg("R11"))
+				}
+			}
+			if _, ok := amd64LeaveSpecs[Op(op)]; ok {
+				markReg(BP)
+				markReg(SP)
+			}
+			if op == "XLAT" {
+				markReg(AX)
+				markReg(BX)
+			}
 			if c.goarch == "386" {
 				switch op {
-				case "PUSHL", "POPL", "PUSHFL", "POPFL", "PUSHAL", "POPAL", "ADJSP":
+				case "PUSHW", "POPW", "PUSHFW", "POPFW", "PUSHL", "POPL", "PUSHFL", "POPFL", "PUSHAL", "POPAL", "ADJSP":
 					markReg(SP)
 				}
 			}
 			for _, arg := range ins.Args {
 				markOp(arg)
 			}
+			if form, known, err := x86PackedAverageProperties(ins.Op, ins, c.goarch); known && err == nil {
+				markOp(form.source)
+			}
+			if form, recognized, err := x86ScalarExtensionProperties(Op(op), ins, c.goarch); recognized && err == nil && form.source.Kind == OpReg {
+				markReg(form.source.Reg)
+			}
+			if _, fourSource := amd64FourSourceSpecs[Op(op)]; fourSource && len(ins.Args) >= 2 && ins.Args[1].Kind == OpRegList && len(ins.Args[1].RegList) != 0 {
+				first := ins.Args[1].RegList[0]
+				if index, ok := amd64ParseXReg(first); ok {
+					base := index &^ 3
+					for register := base; register < base+4; register++ {
+						markReg(Reg(fmt.Sprintf("X%d", register)))
+					}
+				} else if index, ok := amd64ParseZReg(first); ok {
+					base := index &^ 3
+					for register := base; register < base+4; register++ {
+						markReg(Reg(fmt.Sprintf("Z%d", register)))
+					}
+				}
+			}
+			if len(ins.Args) == 1 && ins.Args[0].Kind == OpReg {
+				if spec, ok := x86UnaryYmbSpecs[Op(op)]; ok {
+					markReg(amd64YmbEffectiveRegister(ins.Args[0].Reg, spec.bits))
+				}
+			}
 		}
 	}
 
 	// Ensure a few common regs exist even if only used implicitly by helpers.
 	markReg(AX)
+	if c.goarch != "386" && c.frameSize > 0 && c.usedRegs[BP] {
+		markReg(SP)
+	}
 
 	// Ensure arg regs exist for ABIInternal-style stdlib asm. This matters for:
 	//   - functions like runtime·cmpstring<ABIInternal> that tail-call helpers
@@ -295,8 +457,45 @@ func (c *amd64Ctx) scanUsedRegs() {
 	}
 }
 
+func (c *amd64Ctx) vectorAllocationWidths() map[int]int {
+	widths := make(map[int]int)
+	for i := range c.usedXRegs {
+		widths[i] = 16
+	}
+	for i := range c.usedYRegs {
+		widths[i] = 32
+	}
+	for i := range c.usedZRegs {
+		widths[i] = 64
+	}
+	return widths
+}
+
 func (c *amd64Ctx) emitEntryAllocas() error {
+	if err := c.prepareLogicalAUTOStorage(); err != nil {
+		return err
+	}
+	resultRegion, regionalResults := x86DirectTailResultRegion(c.fpScalarSource, c.sig, c.goarch)
+	if regionalResults && (!c.fpScalarChecked || c.fpScalarCheckErr != nil) {
+		return fmt.Errorf("%w: contiguous result backing lacks its complete source-byte proof", ErrProbeNeedsContext)
+	}
+	if c.fixedLocal != nil && (c.fixedLocal.binding == nil || c.fixedLocal.binding != c.sig.x86FixedLocal ||
+		c.goarch != "amd64" || c.targetTriple != c.fixedLocal.binding.target || c.frameSize != c.fixedLocal.frame) {
+		return goAMD64FrameContext("fixed local storage consumer lost its sealed source identity")
+	}
 	c.scanUsedRegs()
+	if c.sourceStack != nil || c.fixedLocal != nil {
+		c.usedRegs[SP] = true
+	}
+	var framedCalls []int
+	if c.directTail != nil {
+		for pc, ins := range c.directTail.instructions {
+			if call, framed := c.directTail.privateFramedCall(pc); framed && ins.Op == OpCALL {
+				framedCalls = append(framedCalls, call)
+				c.usedRegs[BP] = true
+			}
+		}
+	}
 
 	regs := make([]string, 0, len(c.usedRegs))
 	for r := range c.usedRegs {
@@ -304,7 +503,7 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 	}
 	sort.Strings(regs)
 
-	c.b.WriteString(amd64LLVMBlockName("entry") + ":\n")
+	c.b.WriteString(amd64LLVMBlockName(c.blocks[0].name) + ":\n")
 	for _, rs := range regs {
 		r := Reg(rs)
 		name := c.slotName(r)
@@ -312,41 +511,80 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 		fmt.Fprintf(c.b, "  %s = alloca i64\n", name)
 		fmt.Fprintf(c.b, "  store i64 0, ptr %s\n", name)
 	}
-	if spSlot, ok := c.regSlot[SP]; ok && c.goarch == "386" {
-		minOff, maxOff := c.stackOffsetRange()
-		movement, err := c.stackMovementBudget()
-		if err != nil {
-			return err
+	for _, call := range framedCalls {
+		fmt.Fprintf(c.b, "  %%private_call_bp_%d = alloca i64\n", call)
+	}
+	if spSlot, ok := c.regSlot[SP]; ok {
+		if c.fixedLocal != nil {
+			// The complete proof excludes saved BP/return/incoming FP bytes,
+			// proves every observed word-aligned SP residue, and prevents local
+			// addresses escaping or being compared numerically. A word-aligned
+			// physical buffer preserves that residue domain, not a stronger
+			// SIMD-aligned shadow capable of repairing an uncertain source.
+			size := c.fixedLocal.frame + 64
+			c.localStackSlot = "%fixed_local_native"
+			fmt.Fprintf(c.b, "  %s = alloca [%d x i8], align 8\n", c.localStackSlot, size)
+			base := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds [%d x i8], ptr %s, i32 0, i64 32\n", base, size, c.localStackSlot)
+			address := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", address, base)
+			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", address, spSlot)
+		} else {
+			minOff, maxOff := c.stackOffsetRange()
+			if c.sourceStack != nil && c.sourceStack.minimum < minOff {
+				minOff = c.sourceStack.minimum
+			}
+			var movement int64
+			if c.goarch == "386" {
+				var err error
+				movement, err = c.stackMovementBudget()
+				if err != nil {
+					return err
+				}
+			}
+			minOff -= movement
+			maxOff += movement
+			const guard = int64(64)
+			bias := guard - minOff
+			if c.sourceStack != nil {
+				// A native Go entry SP is word-aligned. Preserve that same
+				// congruence so proved AND alignment has identical byte offsets.
+				word := c.sourceStack.word
+				bias = (bias + word - 1) & -word
+			}
+			size := bias + maxOff + guard
+			if size < 256 {
+				size = 256
+			}
+			c.localStackSlot = "%local_stack"
+			if c.sourceStack != nil {
+				fmt.Fprintf(c.b, "  %s = alloca [%d x i8], align %d\n", c.localStackSlot, size, c.sourceStack.word)
+			} else {
+				fmt.Fprintf(c.b, "  %s = alloca [%d x i8]\n", c.localStackSlot, size)
+			}
+			base := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds [%d x i8], ptr %s, i32 0, i64 %d\n", base, size, c.localStackSlot, bias)
+			addr := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", addr, base)
+			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", addr, spSlot)
+			if c.logicalAUTOExtent != 0 {
+				c.logicalAUTOBase = "%" + addr
+			}
+			if bpSlot, ok := c.regSlot[BP]; ok && c.goarch != "386" && c.frameSize > 0 {
+				// Go saves BP before reserving TEXT's local frame. Thus a source
+				// -8(BP) aliases FrameSize-8(SP), including across outgoing calls.
+				bp := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %d\n", bp, addr, c.frameSize)
+				fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", bp, bpSlot)
+			}
 		}
-		minOff -= movement
-		maxOff += movement
-		const guard = int64(64)
-		bias := guard - minOff
-		size := bias + maxOff + guard
-		if size < 256 {
-			size = 256
-		}
-		c.localStackSlot = "%local_stack"
-		fmt.Fprintf(c.b, "  %s = alloca [%d x i8]\n", c.localStackSlot, size)
-		base := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds [%d x i8], ptr %s, i32 0, i64 %d\n", base, size, c.localStackSlot, bias)
-		addr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", addr, base)
-		fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", addr, spSlot)
 	}
 
-	// XMM, YMM and ZMM are overlapping views of the same physical register.
-	// Allocate the widest view used by the function and share its low bytes.
-	widths := make(map[int]int)
-	for i := range c.usedXRegs {
-		widths[i] = 16
-	}
-	for i := range c.usedYRegs {
-		widths[i] = 32
-	}
-	for i := range c.usedZRegs {
-		widths[i] = 64
-	}
+	// Keep all live X/Y/Z views on one physical byte bank. Encoding-specific
+	// writers still decide whether to preserve or clear the upper bytes;
+	// source mnemonic prefixes cannot select that effect (Go rewrites some
+	// V-prefixed scalar literals into legacy SSE instructions).
+	widths := c.vectorAllocationWidths()
 	indices := make([]int, 0, len(widths))
 	for i := range widths {
 		indices = append(indices, i)
@@ -357,8 +595,7 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 		name := c.xSlotName(i)
 		if width == 32 {
 			name = fmt.Sprintf("%%y%d", i)
-		}
-		if width == 64 {
+		} else if width == 64 {
 			name = fmt.Sprintf("%%z%d", i)
 		}
 		c.xRegSlot[i] = name
@@ -389,6 +626,12 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 			c.x87Slot[i] = name
 			fmt.Fprintf(c.b, "  %s = alloca double\n", name)
 			fmt.Fprintf(c.b, "  store double 0.000000e+00, ptr %s\n", name)
+			c.x87IntegerValueSlot[i] = fmt.Sprintf("%%x87_integer%d", i)
+			c.x87ExactSlot[i] = fmt.Sprintf("%%x87_exact%d", i)
+			fmt.Fprintf(c.b, "  %s = alloca i64\n", c.x87IntegerValueSlot[i])
+			fmt.Fprintf(c.b, "  store i64 0, ptr %s\n", c.x87IntegerValueSlot[i])
+			fmt.Fprintf(c.b, "  %s = alloca i1\n", c.x87ExactSlot[i])
+			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.x87ExactSlot[i])
 		}
 		c.x87ControlSlot = "%x87_control"
 		c.x87StatusSlot = "%x87_status"
@@ -401,21 +644,24 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 			fmt.Fprintf(c.b, "  %s = alloca i64\n", c.x87IntegerSlot)
 		}
 	}
-
 	c.flagsZSlot = "%flags_z"
 	c.flagsSltSlot = "%flags_slt"
 	c.flagsCFSlot = "%flags_cf"
+	c.flagsPFSlot = "%flags_pf"
+	c.flagsAFSlot = "%flags_af"
 	c.flagsOFSlot = "%flags_of"
-	if c.goarch == "386" {
-		c.directionSlot = "%direction_backward"
-		c.flagsIDSlot = "%flags_id"
-	}
+	c.directionSlot = "%direction_backward"
+	c.flagsIDSlot = "%flags_id"
 	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsZSlot)
 	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsZSlot)
 	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsSltSlot)
 	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsSltSlot)
 	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsCFSlot)
 	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsPFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsPFSlot)
+	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsAFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsAFSlot)
 	fmt.Fprintf(c.b, "  %s = alloca i1\n", c.flagsOFSlot)
 	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
 	if c.flagsIDSlot != "" {
@@ -445,17 +691,51 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 			return err
 		}
 	} else {
-		for _, r := range c.fpResults {
-			name := fmt.Sprintf("%%fp_ret_%d", r.Index)
-			c.fpResAllocaIdx[r.Index] = name
-			c.fpResAllocaOff[r.Offset] = name
-			fmt.Fprintf(c.b, "  %s = alloca %s\n", name, r.Type)
-			fmt.Fprintf(c.b, "  store %s %s, ptr %s\n", r.Type, llvmZeroValue(r.Type), name)
+		// Named FP parameters have mutable frame-slot semantics in Go assembly.
+		// Keep shadow storage even though LLVM function arguments are SSA values;
+		// assembly kernels commonly advance slice pointers by writing base+off(FP)
+		// and reading the updated value in a later loop iteration.
+		for _, slot := range c.sig.Frame.Params {
+			if slot.Index < 0 || slot.Index >= len(c.sig.Args) {
+				return fmt.Errorf("FP frame slot: invalid arg index %d at +%d(FP)", slot.Index, slot.Offset)
+			}
+			name := amd64FPParamSlotName(slot.Offset)
+			c.fpParamAlloca[slot.Offset] = name
+			value := fmt.Sprintf("%%arg%d", slot.Index)
+			if fields := frameSlotFields(slot); len(fields) != 0 {
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", extracted, c.sig.Args[slot.Index], value, frameSlotExtractSuffix(slot))
+				value = "%" + extracted
+			}
+			fmt.Fprintf(c.b, "  %s = alloca %s\n", name, x86FPStorageType(slot.Type))
+			c.storeFPStorage(slot.Type, value, name, "", "")
+		}
+		if regionalResults {
+			c.emitDirectTailResultRegion(resultRegion)
+		} else {
+			for _, r := range c.fpResults {
+				name := fmt.Sprintf("%%fp_ret_%d", r.Index)
+				c.fpResAllocaIdx[r.Index] = name
+				c.fpResAllocaOff[r.Offset] = name
+				fmt.Fprintf(c.b, "  %s = alloca %s\n", name, x86FPStorageType(r.Type))
+				c.storeFPStorage(r.Type, llvmZeroValue(r.Type), name, "", "")
+			}
+		}
+	}
+	if regionalResults {
+		// One region address may reach any of its fields. RET must load each
+		// member's actual storage, never a return-register fallback. This is
+		// addressability, not a numerical initialization fact.
+		for _, slot := range c.fpResults {
+			c.markFPResultAddrTaken(slot.Offset)
 		}
 	}
 
 	// Map LLVM args -> simulated registers for ABIInternal-ish entrypoints and
 	// for helper<> bodies with explicit ArgRegs.
+	if c.sig.amd64GoArguments != nil {
+		return c.emitAMD64GoArguments()
+	}
 	if len(c.sig.ArgRegs) > 0 {
 		for i := 0; i < len(c.sig.Args) && i < len(c.sig.ArgRegs); i++ {
 			r := c.sig.ArgRegs[i]
@@ -525,6 +805,13 @@ func (c *amd64Ctx) emitEntryAllocas() error {
 	return nil
 }
 
+func amd64FPParamSlotName(off int64) string {
+	if off < 0 {
+		return fmt.Sprintf("%%fp_arg_n%d", -off)
+	}
+	return fmt.Sprintf("%%fp_arg_%d", off)
+}
+
 func x86FrameTypeSize(ty LLVMType) int64 {
 	switch ty {
 	case I1, I8:
@@ -591,29 +878,33 @@ func (c *amd64Ctx) emit386ClassicFrame() error {
 			return fmt.Errorf("FP frame slot: invalid arg index %d at +%d(FP)", slot.Index, slot.Offset)
 		}
 		value := fmt.Sprintf("%%arg%d", slot.Index)
-		if slot.Field >= 0 {
+		if fields := frameSlotFields(slot); len(fields) != 0 {
 			extracted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, c.sig.Args[slot.Index], value, slot.Field)
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", extracted, c.sig.Args[slot.Index], value, frameSlotExtractSuffix(slot))
 			value = "%" + extracted
 		}
-		fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1\n", slot.Type, value, c.classicFramePtr(slot.Offset))
+		c.storeFPStorage(slot.Type, value, c.classicFramePtr(slot.Offset), ", align 1", "")
 	}
 	for _, slot := range c.fpResults {
 		ptr := c.classicFramePtr(slot.Offset)
 		c.fpResAllocaIdx[slot.Index] = ptr
 		c.fpResAllocaOff[slot.Offset] = ptr
-		fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1\n", slot.Type, llvmZeroValue(slot.Type), ptr)
+		c.storeFPStorage(slot.Type, llvmZeroValue(slot.Type), ptr, ", align 1", "")
 	}
 	return nil
 }
 
 func (c *amd64Ctx) stackOffsetRange() (minOff, maxOff int64) {
+	maxOff = c.frameSize
 	for _, block := range c.blocks {
 		for _, ins := range block.instrs {
 			for _, arg := range ins.Args {
 				if arg.Kind != OpMem || arg.Mem.Base != SP {
 					continue
 				}
+				if _, static := x86SBMemoryAddressRole(arg, c.goarch); static {
+					continue
+				}
 				if arg.Mem.Off < minOff {
 					minOff = arg.Mem.Off
 				}
@@ -648,6 +939,10 @@ func (c *amd64Ctx) stackMovementBudget() (int64, error) {
 				if err := add(4, ins); err != nil {
 					return 0, err
 				}
+			case "PUSHW", "POPW", "PUSHFW", "POPFW":
+				if err := add(2, ins); err != nil {
+					return 0, err
+				}
 			case "PUSHAL", "POPAL":
 				if err := add(32, ins); err != nil {
 					return 0, err
@@ -664,6 +959,26 @@ func (c *amd64Ctx) stackMovementBudget() (int64, error) {
 						return 0, err
 					}
 				}
+			case "INCL", "DECL":
+				if is386SPDestination(ins) {
+					if err := add(1, ins); err != nil {
+						return 0, err
+					}
+				}
+			case "INCW", "DECW":
+				if is386SPDestination(ins) {
+					// A low-word wrap can move the modeled SP by as much as 65535.
+					if err := add(65535, ins); err != nil {
+						return 0, err
+					}
+				}
+			case "ADDW", "SUBW":
+				if is386SPDestination(ins) {
+					// A low-word update can move the modeled SP by up to 65535.
+					if err := add(65535, ins); err != nil {
+						return 0, err
+					}
+				}
 			case "ANDL":
 				if movement, ok := bounded386SPAndMovement(ins); ok {
 					if err := add(movement, ins); err != nil {
@@ -709,15 +1024,67 @@ func bounded386SPAndMovement(ins Instr) (int64, bool) {
 }
 
 func models386SPWrite(ins Instr) bool {
+	op := strings.ToUpper(string(ins.Op))
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		op = op[:dot]
+	}
+	if op == "MOVQ" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg && ins.Args[1].Reg == SP && ins.Args[0].Kind == OpReg {
+		class, _, special := x86MachineRegister(ins.Args[0].Reg)
+		return special && (class == "cr" || class == "dr")
+	}
+	if len(ins.Args) == 1 && ins.Args[0].Kind == OpReg {
+		if spec, ok := x86UnaryYmbSpecs[Op(op)]; ok && spec.bits != 64 {
+			return amd64YmbEffectiveRegister(ins.Args[0].Reg, spec.bits) == SP
+		}
+	}
 	if !is386SPDestination(ins) {
 		return false
 	}
-	switch strings.ToUpper(string(ins.Op)) {
-	case "MOVL", "ADDL", "SUBL", "LEAL", "POPL":
+	if _, ok := amd64BMI2ShiftSpecs[Op(op)]; ok {
+		return true
+	}
+	if _, known, err := x86ScalarFloatIntegerProperties(ins, "386"); known {
+		return err == nil
+	}
+	switch op {
+	case "MOVL", "ADDW", "SUBW", "ADCW", "SBBW", "ADDL", "SUBL", "ADCL", "SBBL", "ADCXL", "ADOXL", "LEAW", "LEAL", "POPW", "POPL",
+		"CRC32B", "CRC32W", "CRC32L",
+		"CMPXCHGW", "CMPXCHGL",
+		"POPCNTW", "POPCNTL", "TZCNTW", "TZCNTL", "LZCNTW", "LZCNTL", "PMOVMSKB", "VPMOVMSKB",
+		"BEXTRL", "BEXTRQ", "BZHIL", "BZHIQ", "BLSIL", "BLSIQ", "BLSMSKL", "BLSMSKQ", "BLSRL", "BLSRQ",
+		"ANDNL", "ANDNQ",
+		"PDEPL", "PDEPQ", "PEXTL", "PEXTQ":
 		// These are the direct SP forms used by the official 386 corpus. MOVL
 		// and non-SP LEAL rebase to an explicitly supplied stack context;
 		// arithmetic and SP-relative LEAL retain the current stack model.
 		return true
+	case "RDPID":
+		return len(ins.Args) == 1 && ins.Args[0].Kind == OpReg && ins.Args[0].Reg == SP
+	case "RCLW", "RCLL", "RCRW", "RCRL", "ROLW", "ROLL", "RORW", "RORL", "SARW", "SARL",
+		"SALW", "SALL", "SHLW", "SHLL", "SHRW", "SHRL":
+		return true
+	case "INCW", "DECW", "INCL", "DECL":
+		return true
+	case "BTCW", "BTCL", "BTRW", "BTRL", "BTSW", "BTSL":
+		return true
+	case "SLDTW", "SLDTL", "SMSWW", "SMSWL", "STRW", "STRL":
+		// Go's Yml destination class includes SP in 386 mode. These system
+		// instructions write their result directly to that destination.
+		return true
+	case "LARW", "LARL", "LSLW", "LSLL":
+		// LAR/LSL use the same Yrl destination class, including SP.
+		return true
+	case "LFSW", "LFSL", "LGSW", "LGSL", "LSSW", "LSSL":
+		// Far-pointer loads also use Yrl, including SP, for their offset.
+		return true
+	case "RDFSBASEL", "RDGSBASEL":
+		// The 386 FSGSBASE read forms use Yrl destinations, including SP.
+		return true
+	case "MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX",
+		"MOVWLSX", "MOVWLZX", "MOVLQZX", "MOVSWW", "MOVZWW":
+		return true
+	case "KMOVB", "KMOVW", "KMOVD", "KMOVQ":
+		return len(ins.Args) == 2 && amd64IsKOperand(ins.Args[0])
 	case "ANDL":
 		_, ok := bounded386SPAndMovement(ins)
 		return ok
@@ -760,6 +1127,37 @@ func (c *amd64Ctx) popI64() string {
 	return "%" + val
 }
 
+func (c *amd64Ctx) pushI16(v string) error {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return err
+	}
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i64 %s, 2\n", next, sp)
+	if err := c.storeRegUnchecked(SP, "%"+next); err != nil {
+		return err
+	}
+	p := c.ptrFromAddrI64("%" + next)
+	fmt.Fprintf(c.b, "  store i16 %s, ptr %s, align 1\n", v, p)
+	return nil
+}
+
+func (c *amd64Ctx) popI16() (string, error) {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return "", err
+	}
+	p := c.ptrFromAddrI64(sp)
+	v := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s, align 1\n", v, p)
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, 2\n", next, sp)
+	if err := c.storeRegUnchecked(SP, "%"+next); err != nil {
+		return "", err
+	}
+	return "%" + v, nil
+}
+
 func (c *amd64Ctx) pushI32(v string) error {
 	sp, err := c.loadReg(SP)
 	if err != nil {
@@ -838,6 +1236,28 @@ func amd64ByteAlias(rr Reg) (base Reg, shift uint, ok bool) {
 		return DX, 0, true
 	case DH:
 		return DX, 8, true
+	case BPB:
+		return BP, 0, true
+	case SIB:
+		return SI, 0, true
+	case DIB:
+		return DI, 0, true
+	case R8B:
+		return Reg("R8"), 0, true
+	case R9B:
+		return Reg("R9"), 0, true
+	case R10B:
+		return Reg("R10"), 0, true
+	case R11B:
+		return Reg("R11"), 0, true
+	case R12B:
+		return Reg("R12"), 0, true
+	case R13B:
+		return Reg("R13"), 0, true
+	case R14B:
+		return Reg("R14"), 0, true
+	case R15B:
+		return Reg("R15"), 0, true
 	default:
 		return "", 0, false
 	}
@@ -877,6 +1297,9 @@ func amd64ByteRegBase(r Reg) (base Reg, shift uint, ok bool) {
 }
 
 func (c *amd64Ctx) loadReg(r Reg) (string, error) {
+	if r == TLS {
+		return "", fmt.Errorf("%w: TLS pseudo-register needs its native Go TLS source contract", ErrProbeNeedsContext)
+	}
 	// Model byte aliases used by stdlib asm. Reads return the selected byte as a
 	// zero-extended i64.
 	if base, shift, ok := amd64ByteAlias(r); ok {
@@ -1000,21 +1423,6 @@ func (c *amd64Ctx) storeRegSized(r Reg, ty LLVMType, v string) error {
 	}
 }
 
-// clearVectorUpper clears bytes above the written width while leaving the
-// low view unchanged. Legacy SSE writes deliberately preserve those bytes.
-func (c *amd64Ctx) clearVectorUpper(idx, lowBytes int) {
-	slot, width := c.zRegSlot[idx], 64
-	if slot == "" {
-		slot, width = c.yRegSlot[idx], 32
-	}
-	if slot == "" || width <= lowBytes {
-		return
-	}
-	upper := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 %d\n", upper, slot, lowBytes)
-	fmt.Fprintf(c.b, "  store <%d x i8> zeroinitializer, ptr %%%s, align 1\n", width-lowBytes, upper)
-}
-
 func (c *amd64Ctx) loadX(r Reg) (string, error) {
 	idx, ok := amd64ParseXReg(r)
 	if !ok {
@@ -1022,7 +1430,7 @@ func (c *amd64Ctx) loadX(r Reg) (string, error) {
 	}
 	slot, ok := c.xRegSlot[idx]
 	if !ok {
-		return "<16 x i8> zeroinitializer", nil
+		return "zeroinitializer", nil
 	}
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s\n", t, slot)
@@ -1038,9 +1446,6 @@ func (c *amd64Ctx) storeX(r Reg, v string) error {
 	if !ok {
 		return nil
 	}
-	if c.zeroUpperVector {
-		c.clearVectorUpper(idx, 16)
-	}
 	fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s\n", v, slot)
 	return nil
 }
@@ -1052,7 +1457,7 @@ func (c *amd64Ctx) loadY(r Reg) (string, error) {
 	}
 	slot, ok := c.yRegSlot[idx]
 	if !ok {
-		return "<32 x i8> zeroinitializer", nil
+		return "zeroinitializer", nil
 	}
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load <32 x i8>, ptr %s\n", t, slot)
@@ -1060,19 +1465,12 @@ func (c *amd64Ctx) loadY(r Reg) (string, error) {
 }
 
 func (c *amd64Ctx) storeY(r Reg, v string) error {
-	idx, ok := amd64ParseYReg(r)
-	if !ok {
+	if _, ok := amd64ParseYReg(r); !ok {
 		return fmt.Errorf("not a Y reg: %s", r)
 	}
-	slot, ok := c.yRegSlot[idx]
-	if !ok {
-		return nil
-	}
-	if c.zeroUpperVector {
-		c.clearVectorUpper(idx, 32)
-	}
-	fmt.Fprintf(c.b, "  store <32 x i8> %s, ptr %s\n", v, slot)
-	return nil
+	// A 256-bit VEX write also replaces X and clears the upper Z view.
+	// Raw and named instructions must observe the same physical register.
+	return c.storePackedMoveOperand(Operand{Kind: OpReg, Reg: r}, 32, v)
 }
 
 func (c *amd64Ctx) loadZ(r Reg) (string, error) {
@@ -1082,7 +1480,7 @@ func (c *amd64Ctx) loadZ(r Reg) (string, error) {
 	}
 	slot, ok := c.zRegSlot[idx]
 	if !ok {
-		return "<64 x i8> zeroinitializer", nil
+		return "zeroinitializer", nil
 	}
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load <64 x i8>, ptr %s\n", t, slot)
@@ -1142,6 +1540,7 @@ func (c *amd64Ctx) setZSFlagsFromI64(v string) {
 	slt := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %s, 0\n", slt, v)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", slt, c.flagsSltSlot)
+	c.setParityFlagSized(I64, v)
 }
 
 func (c *amd64Ctx) setZSFlagsFromI32(v string) {
@@ -1151,6 +1550,33 @@ func (c *amd64Ctx) setZSFlagsFromI32(v string) {
 	slt := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %s, 0\n", slt, v)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", slt, c.flagsSltSlot)
+	c.setParityFlagSized(I32, v)
+}
+
+func (c *amd64Ctx) setParityFlagSized(ty LLVMType, v string) {
+	low := v
+	if ty != I8 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to i8\n", truncated, ty, v)
+		low = "%" + truncated
+	}
+	shift4 := c.newTmp()
+	fold4 := c.newTmp()
+	shift2 := c.newTmp()
+	fold2 := c.newTmp()
+	shift1 := c.newTmp()
+	fold1 := c.newTmp()
+	bit := c.newTmp()
+	parity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i8 %s, 4\n", shift4, low)
+	fmt.Fprintf(c.b, "  %%%s = xor i8 %s, %%%s\n", fold4, low, shift4)
+	fmt.Fprintf(c.b, "  %%%s = lshr i8 %%%s, 2\n", shift2, fold4)
+	fmt.Fprintf(c.b, "  %%%s = xor i8 %%%s, %%%s\n", fold2, fold4, shift2)
+	fmt.Fprintf(c.b, "  %%%s = lshr i8 %%%s, 1\n", shift1, fold2)
+	fmt.Fprintf(c.b, "  %%%s = xor i8 %%%s, %%%s\n", fold1, fold2, shift1)
+	fmt.Fprintf(c.b, "  %%%s = and i8 %%%s, 1\n", bit, fold1)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i8 %%%s, 0\n", parity, bit)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", parity, c.flagsPFSlot)
 }
 
 func (c *amd64Ctx) setCmpFlags(a, b string) {
@@ -1165,6 +1591,9 @@ func (c *amd64Ctx) setCmpFlags(a, b string) {
 	ult := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %s\n", ult, a, b)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", ult, c.flagsCFSlot)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %s\n", result, a, b)
+	c.setParityFlagSized(I64, "%"+result)
 }
 
 func (c *amd64Ctx) loadFlag(slot string) string {
@@ -1181,6 +1610,25 @@ func (c *amd64Ctx) fpParam(off int64) (slot FrameSlot, ok bool) {
 	return s, true
 }
 
+func (c *amd64Ctx) loadFPParamValue(slot FrameSlot) (string, error) {
+	if slot.Index < 0 || slot.Index >= len(c.sig.Args) {
+		return "", fmt.Errorf("FP read slot: invalid arg index %d at +%d(FP)", slot.Index, slot.Offset)
+	}
+	if c.classicFrame != "" {
+		return c.loadFPStorage(slot.Type, c.classicFramePtr(slot.Offset), ", align 1"), nil
+	}
+	if shadow := c.fpParamAlloca[slot.Offset]; shadow != "" {
+		return c.loadFPStorage(slot.Type, shadow, ""), nil
+	}
+	value := fmt.Sprintf("%%arg%d", slot.Index)
+	if fields := frameSlotFields(slot); len(fields) != 0 {
+		extracted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", extracted, c.sig.Args[slot.Index], value, frameSlotExtractSuffix(slot))
+		value = "%" + extracted
+	}
+	return value, nil
+}
+
 func (c *amd64Ctx) fpResultAlloca(off int64) (string, LLVMType, bool) {
 	s, ok := c.fpParams[off]
 	_ = s
@@ -1233,13 +1681,14 @@ func (c *amd64Ctx) evalFPToI64(off int64) (string, error) {
 			}
 		}
 		if alloca, ty, rok := c.fpResultAlloca(off); rok && ty != "" {
-			ld := c.newTmp()
 			align := ""
 			if c.classicFrame != "" {
 				align = ", align 1"
 			}
-			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s%s\n", ld, ty, alloca, align)
-			v := "%" + ld
+			if ty == I1 && c.abi0BoolResultByteStorage() {
+				ty = I8 // An intermediate numerical read is not a logical bool conversion.
+			}
+			v := c.loadFPStorage(ty, alloca, align)
 			switch ty {
 			case I64:
 				return v, nil
@@ -1283,24 +1732,23 @@ func (c *amd64Ctx) evalFPToI64(off int64) (string, error) {
 		// inference (common in low-level runtime assembly).
 		return "0", nil
 	}
-	idx := slot.Index
-	if idx < 0 || idx >= len(c.sig.Args) {
-		return "", fmt.Errorf("FP read slot: invalid arg index %d at +%d(FP)", idx, off)
-	}
-	arg := fmt.Sprintf("%%arg%d", idx)
-
-	// If this FP slot refers to a field within an aggregate argument (string/slice),
-	// extract that field first.
 	ty := slot.Type
-	if c.classicFrame != "" {
-		loaded := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", loaded, ty, c.classicFramePtr(off))
-		arg = "%" + loaded
-	} else if slot.Field >= 0 {
-		aggTy := c.sig.Args[idx]
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, aggTy, arg, slot.Field)
-		arg = "%" + t
+	if ty == I1 && c.abi0BoolResultByteStorage() {
+		pointer := c.fpParamAlloca[slot.Offset]
+		if c.classicFrame != "" {
+			pointer = c.classicFramePtr(slot.Offset)
+		}
+		if pointer == "" {
+			return "", fmt.Errorf("missing physical bool parameter copy at +%d(FP)", slot.Offset)
+		}
+		byteValue := c.loadFPStorage(I8, pointer, ", align 1")
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %s to i64\n", wide, byteValue)
+		return "%" + wide, nil
+	}
+	arg, err := c.loadFPParamValue(slot)
+	if err != nil {
+		return "", err
 	}
 	switch ty {
 	case Ptr:
@@ -1342,33 +1790,143 @@ func (c *amd64Ctx) evalFPToI64(off int64) (string, error) {
 	}
 }
 
+func amd64IntegerTypeBits(ty LLVMType) (int, bool) {
+	switch ty {
+	case I1:
+		return 1, true
+	case I8:
+		return 8, true
+	case I16:
+		return 16, true
+	case I32:
+		return 32, true
+	case I64:
+		return 64, true
+	default:
+		return 0, false
+	}
+}
+
+func amd64IntegerTypeForBits(bits int) LLVMType {
+	switch bits {
+	case 1:
+		return I1
+	case 8:
+		return I8
+	case 16:
+		return I16
+	case 32:
+		return I32
+	case 64:
+		return I64
+	default:
+		return ""
+	}
+}
+
+func (c *amd64Ctx) coerceFPStoreValue(from, to LLVMType, value string) (string, error) {
+	if from == to {
+		return value, nil
+	}
+	pointerBits := 64
+	if c.goarch == "386" {
+		pointerBits = 32
+	}
+
+	rawType := from
+	rawValue := value
+	switch from {
+	case Ptr:
+		rawType = amd64IntegerTypeForBits(pointerBits)
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to %s\n", cast, value, rawType)
+		rawValue = "%" + cast
+	case LLVMType("float"):
+		rawType = I32
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", cast, value)
+		rawValue = "%" + cast
+	case LLVMType("double"):
+		rawType = I64
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", cast, value)
+		rawValue = "%" + cast
+	default:
+		if _, ok := amd64IntegerTypeBits(from); !ok {
+			return "", fmt.Errorf("unsupported FP store source type %s", from)
+		}
+	}
+
+	targetBits := 0
+	switch to {
+	case Ptr:
+		targetBits = pointerBits
+	case LLVMType("float"):
+		targetBits = 32
+	case LLVMType("double"):
+		targetBits = 64
+	default:
+		var ok bool
+		targetBits, ok = amd64IntegerTypeBits(to)
+		if !ok {
+			return "", fmt.Errorf("unsupported FP store destination type %s", to)
+		}
+	}
+
+	fromBits, _ := amd64IntegerTypeBits(rawType)
+	targetIntType := amd64IntegerTypeForBits(targetBits)
+	if fromBits > targetBits {
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", cast, rawType, rawValue, targetIntType)
+		rawType, rawValue = targetIntType, "%"+cast
+	} else if fromBits < targetBits {
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", cast, rawType, rawValue, targetIntType)
+		rawType, rawValue = targetIntType, "%"+cast
+	}
+
+	switch to {
+	case Ptr:
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr %s %s to ptr\n", cast, rawType, rawValue)
+		return "%" + cast, nil
+	case LLVMType("float"), LLVMType("double"):
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", cast, rawType, rawValue, to)
+		return "%" + cast, nil
+	default:
+		return rawValue, nil
+	}
+}
+
 func (c *amd64Ctx) storeFPResult(off int64, ty LLVMType, v string) error {
+	return c.storeFPResultWithMetadata(off, ty, v, "")
+}
+
+func (c *amd64Ctx) storeFPResultWithMetadata(off int64, ty LLVMType, v, metadata string) error {
 	align := ""
 	if c.classicFrame != "" {
 		// The 386 ABI frame is a byte array, and FP offsets need not provide
 		// the natural alignment required by the value stored in a slot.
 		align = ", align 1"
 	}
-	if slot, ok := c.fpParams[off]; ok && c.classicFrame != "" {
-		// 386 ABIInternal stubs write register arguments back into the
-		// caller-provided FP argument area before tail-calling an ABI0
-		// handler (for example runtime.panicIndex). The classic frame is
-		// deliberately mutable, unlike an LLVM SSA argument.
-		value := v
-		switch {
-		case ty == slot.Type:
-		case ty == I32 && slot.Type == Ptr:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", t, v)
-			value = "%" + t
-		case ty == Ptr && slot.Type == I32:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i32\n", t, v)
-			value = "%" + t
-		default:
-			return fmt.Errorf("FP parameter write type mismatch: have %s want %s at +%d(FP)", ty, slot.Type, off)
+	if slot, ok := c.fpParams[off]; ok {
+		ptr := c.fpParamAlloca[off]
+		if c.classicFrame != "" {
+			ptr = c.classicFramePtr(off)
+		}
+		if ptr == "" {
+			return fmt.Errorf("missing mutable FP parameter slot at +%d(FP)", off)
 		}
-		fmt.Fprintf(c.b, "  store %s %s, ptr %s%s\n", slot.Type, value, c.classicFramePtr(off), align)
+		storageType := slot.Type
+		if storageType == I1 && c.abi0BoolResultByteStorage() {
+			storageType = I8
+		}
+		value, err := c.coerceFPStoreValue(ty, storageType, v)
+		if err != nil {
+			return fmt.Errorf("FP parameter write type mismatch: have %s want %s at +%d(FP): %w", ty, slot.Type, off, err)
+		}
+		c.storeFPStorage(storageType, value, ptr, align, metadata)
 		return nil
 	}
 	if c.goarch == "386" && ty == I32 {
@@ -1403,9 +1961,9 @@ func (c *amd64Ctx) storeFPResult(off int64, ty LLVMType, v string) error {
 			if slot.Type == LLVMType("double") {
 				cast := c.newTmp()
 				fmt.Fprintf(c.b, "  %%%s = bitcast i64 %%%s to double\n", cast, merged)
-				fmt.Fprintf(c.b, "  store double %%%s, ptr %s%s\n", cast, alloca, align)
+				fmt.Fprintf(c.b, "  store double %%%s, ptr %s%s%s\n", cast, alloca, align, metadata)
 			} else {
-				fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s\n", merged, alloca, align)
+				fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s%s\n", merged, alloca, align, metadata)
 			}
 			c.fpResWritten[slot.Index] = true
 			return nil
@@ -1415,11 +1973,43 @@ func (c *amd64Ctx) storeFPResult(off int64, ty LLVMType, v string) error {
 	if !ok {
 		return fmt.Errorf("unsupported FP write slot: +%d(FP)", off)
 	}
+	if slotTy == I1 {
+		if c.abi0BoolResultByteStorage() {
+			value, err := c.coerceFPStoreValue(ty, I8, v)
+			if err != nil {
+				return fmt.Errorf("FP bool result byte write at +%d(FP): %w", off, err)
+			}
+			c.storeFPStorage(I8, value, alloca, align, metadata)
+			c.markFPResultWritten(off)
+			return nil
+		}
+		value, err := c.coerceFPStoreValue(ty, I1, v)
+		if err != nil {
+			return fmt.Errorf("FP bool result write at +%d(FP): %w", off, err)
+		}
+		c.storeFPStorage(I1, value, alloca, align, metadata)
+		c.markFPResultWritten(off)
+		return nil
+	}
 	if slotTy != "" && slotTy != ty {
 		if c.goarch == "386" && ty == I32 && slotTy == Ptr {
 			p := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", p, v)
-			fmt.Fprintf(c.b, "  store ptr %%%s, ptr %s%s\n", p, alloca, align)
+			fmt.Fprintf(c.b, "  store ptr %%%s, ptr %s%s%s\n", p, alloca, align, metadata)
+			c.markFPResultWritten(off)
+			return nil
+		}
+		if ty == I32 && slotTy == LLVMType("float") {
+			cast := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to float\n", cast, v)
+			fmt.Fprintf(c.b, "  store float %%%s, ptr %s%s%s\n", cast, alloca, align, metadata)
+			c.markFPResultWritten(off)
+			return nil
+		}
+		if ty == LLVMType("float") && slotTy == I32 {
+			cast := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", cast, v)
+			fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s%s%s\n", cast, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		}
@@ -1451,41 +2041,68 @@ func (c *amd64Ctx) storeFPResult(off int64, ty LLVMType, v string) error {
 					fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", t, ty, v, slotTy)
 					cast = "%" + t
 				}
-				fmt.Fprintf(c.b, "  store %s %s, ptr %s%s\n", slotTy, cast, alloca, align)
+				fmt.Fprintf(c.b, "  store %s %s, ptr %s%s%s\n", slotTy, cast, alloca, align, metadata)
 				c.markFPResultWritten(off)
 				return nil
 			}
 		}
+		if (ty == I64 || ty == LLVMType("double")) && slotTy == LLVMType("float") {
+			secondAlloca, secondTy, secondOK := c.fpResultAlloca(off + 4)
+			if !secondOK || secondTy != LLVMType("float") {
+				return fmt.Errorf("FP write at +%d(FP) cannot split a 64-bit memory operand", off)
+			}
+			bits := v
+			if ty == LLVMType("double") {
+				cast := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", cast, v)
+				bits = "%" + cast
+			}
+			low := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low, bits)
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", shifted, bits)
+			high := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", high, shifted)
+			lowFloat := c.newTmp()
+			highFloat := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", lowFloat, low)
+			fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", highFloat, high)
+			fmt.Fprintf(c.b, "  store float %%%s, ptr %s%s%s\n", lowFloat, alloca, align, metadata)
+			fmt.Fprintf(c.b, "  store float %%%s, ptr %s%s%s\n", highFloat, secondAlloca, align, metadata)
+			c.markFPResultWritten(off)
+			c.markFPResultWritten(off + 4)
+			return nil
+		}
 		// Cast integer sizes when needed (common: i64 reg -> i32 return slot).
 		switch {
 		case ty == I64 && slotTy == I32:
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t, v)
-			fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s%s\n", t, alloca, align)
+			fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s%s%s\n", t, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		case ty == I64 && slotTy == LLVMType("double"):
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", t, v)
-			fmt.Fprintf(c.b, "  store double %%%s, ptr %s%s\n", t, alloca, align)
+			fmt.Fprintf(c.b, "  store double %%%s, ptr %s%s%s\n", t, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		case ty == LLVMType("double") && slotTy == I64:
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", t, v)
-			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s\n", t, alloca, align)
+			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s%s\n", t, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		case ty == I64 && slotTy == Ptr:
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", t, v)
-			fmt.Fprintf(c.b, "  store ptr %%%s, ptr %s%s\n", t, alloca, align)
+			fmt.Fprintf(c.b, "  store ptr %%%s, ptr %s%s%s\n", t, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		case ty == Ptr && slotTy == I64:
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, v)
-			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s\n", t, alloca, align)
+			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s%s%s\n", t, alloca, align, metadata)
 			c.markFPResultWritten(off)
 			return nil
 		case ty == I64 && slotTy == I64:
@@ -1494,7 +2111,7 @@ func (c *amd64Ctx) storeFPResult(off int64, ty LLVMType, v string) error {
 			return fmt.Errorf("FP write type mismatch: have %s want %s at +%d(FP)", ty, slotTy, off)
 		}
 	}
-	fmt.Fprintf(c.b, "  store %s %s, ptr %s%s\n", ty, v, alloca, align)
+	fmt.Fprintf(c.b, "  store %s %s, ptr %s%s%s\n", ty, v, alloca, align, metadata)
 	c.markFPResultWritten(off)
 	return nil
 }
@@ -1508,13 +2125,11 @@ func (c *amd64Ctx) loadFPResult(slot FrameSlot) (string, error) {
 	if !ok {
 		return "", fmt.Errorf("missing fp result alloca for index %d", slot.Index)
 	}
-	t := c.newTmp()
 	align := ""
 	if c.classicFrame != "" {
 		align = ", align 1"
 	}
-	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s%s\n", t, slot.Type, alloca, align)
-	return "%" + t, nil
+	return c.loadFPStorage(slot.Type, alloca, align), nil
 }
 
 func isAMD64FloatRetTy(ty LLVMType) bool {
@@ -1639,8 +2254,7 @@ func parseSBRef(sym string) (base string, off int64, ok bool) {
 		if s == "" {
 			return "", 0, false
 		}
-		base, off = splitSymPlusOff(s)
-		return base, off, true
+		return parseSymbolOffset(s)
 	}
 	// Also accept bare symbol names used by a few platform asm stubs
 	// (e.g. windows arm64 shared-user-data aliases).
@@ -1650,8 +2264,8 @@ func parseSBRef(sym string) (base string, off int64, ok bool) {
 	if _, ok := parseMem(sym); ok {
 		return "", 0, false
 	}
-	base, off = splitSymPlusOff(sym)
-	if strings.TrimSpace(base) == "" {
+	base, off, ok = parseSymbolOffset(sym)
+	if !ok || strings.TrimSpace(base) == "" {
 		return "", 0, false
 	}
 	return base, off, true
@@ -1665,6 +2279,17 @@ func (c *amd64Ctx) addrFromMem(mem MemRef) (addrI64 string, err error) {
 }
 
 func (c *amd64Ctx) addrFromPlainMem(mem MemRef) (addrI64 string, err error) {
+	if mem.Base == TLS || mem.Index == TLS {
+		return "", fmt.Errorf("%w: TLS memory needs its native Go progedit, relocation and TLS address contract", ErrProbeNeedsContext)
+	}
+	if physical, certified := c.fixedMemRoles[mem]; certified {
+		mem = physical
+	} else if address, logical, err := c.logicalAUTOAddress(mem); logical {
+		return address, err
+	}
+	if err := x86SymbolIndexedMemoryError(mem, c.goarch); err != nil {
+		return "", err
+	}
 	var cur string
 	if mem.Sym != "" {
 		base, err := c.ptrFromSB(mem.Sym)
@@ -1735,18 +2360,24 @@ func (c *amd64Ctx) ptrFromAddrI64(addrI64 string) string {
 }
 
 func (c *amd64Ctx) ptrFromSB(sym string) (ptr string, err error) {
+	// This entry point consumes memory, not Go's TYPE_ADDR immediate. Address
+	// evaluators must first select that role explicitly; silently removing '$'
+	// here lets direct OpSym load/store dispatch bypass the memory grammar.
+	if strings.HasPrefix(strings.TrimSpace(sym), "$") {
+		return "", fmt.Errorf("address immediate is not symbolic memory: %q", sym)
+	}
 	base, off, ok := parseSBRef(sym)
 	if !ok {
 		return "", fmt.Errorf("invalid (SB) sym ref: %q", sym)
 	}
-	base = strings.TrimPrefix(base, "$")
-	res := base
-	if strings.Contains(base, "·") || strings.Contains(base, "/") || strings.Contains(base, ".") {
-		res = c.resolve(base)
-	} else {
-		res = c.resolve("·" + base)
-	}
+	res := resolveAssemblyDataSymbol(base, c.resolve)
 	p := llvmGlobal(res)
+	if continuation, ok := c.continuations[res]; ok {
+		if off != 0 {
+			return "", fmt.Errorf("continuation address cannot have a byte offset: %q", sym)
+		}
+		return fmt.Sprintf("blockaddress(%s, %%%s)", llvmGlobal(continuation.root), amd64LLVMBlockName(continuation.label)), nil
+	}
 	if off == 0 {
 		return p, nil
 	}
diff --git a/amd64_data_bp.go b/amd64_data_bp.go
new file mode 100644
index 000000000..a34e768cf
--- /dev/null
+++ b/amd64_data_bp.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// This is an ordinary source's data-register view, not physical BP entry or
+// frame backing. Go's nonempty NOSPLIT frame preserves its caller BP. The
+// complete named source must independently exclude every observation of that
+// frame, native entry, call and escaping frame address. Reaching input facts
+// are still proved by the ordinary whole-source CFG below.
+func x86DataBPSourceScope(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" || fn.FrameSize <= 0 || fn.FrameSize > 4096 || fn.FrameSize%8 != 0 ||
+		strings.Contains(fn.Sym, "<") || len(sig.ArgRegs) != 0 || len(fn.X86RawText) != 0 ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86BoolCalls != nil || sig.x86CallerRegions != nil ||
+		len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 || fn.x86BoolReadonlyInputs ||
+		len(fn.Instrs) == 0 || len(fn.Instrs) > 4096 || fn.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	_, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) != 3 {
+		return false
+	}
+	frame, args, err := parseTEXTFrame(parts)
+	if err != nil || frame != fn.FrameSize || args != fn.ArgSize {
+		return false
+	}
+	expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+		if value, known := goTextFlagValues[name]; known {
+			return value
+		}
+		return name
+	})
+	flags, known := parseImmExpr(strings.TrimSpace(expression))
+	if !known || flags != 4 { // NOSPLIT, never NOFRAME, NEEDCTXT or another prologue role.
+		return false
+	}
+	found := false
+	var source strings.Builder
+	for _, ins := range fn.Instrs {
+		if ins.Raw == "" || len(ins.Raw) > (1<<20)-source.Len()-1 {
+			return false
+		}
+		source.WriteString(ins.Raw)
+		source.WriteByte('\n')
+		if !x86ResultNamedPredicateInstruction(ins) {
+			return false
+		}
+		switch ins.Op {
+		case OpCALL, "BYTE", "WORD", "LONG", "QUAD":
+			return false
+		}
+		if _, stack, _ := x86StackWidthProperties(ins, arch); stack {
+			return false // Private PUSH/FLAGS storage keeps its own source owner.
+		}
+		if x86LEAWidth(ins.Op, arch) != 0 && len(ins.Args) != 0 && ins.Args[0].Kind == OpFP {
+			return false // LEA's Ym operand takes the FP address without OpFPAddr.
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFPAddr || operand.Kind == OpSym {
+				return false
+			}
+			if operand.Kind == OpReg {
+				root, gp := x86CallerGP(operand.Reg)
+				if gp && root == SP {
+					return false
+				}
+				found = found || operand.Reg == BP
+			}
+			if operand.Kind == OpMem {
+				memory := operand.Mem
+				if memory.Base == SP || memory.Index == SP || memory.Sym != "" || memory.Segment != "" {
+					return false
+				}
+				found = found || memory.Base == BP || memory.Index == BP
+			}
+		}
+	}
+	if !found {
+		return false
+	}
+	// One bounded source replay, not one parse per instruction. Mutable fields
+	// cannot reinterpret a physical-frame use or a different source spelling.
+	parsed, err := Parse(ArchAMD64, source.String())
+	return err == nil && len(parsed.Funcs) == 1 && len(parsed.UnlinkedPrelude) == 0 &&
+		len(parsed.Data) == 0 && len(parsed.Globl) == 0 && parsed.Funcs[0].Sym == fn.Sym &&
+		parsed.Funcs[0].FrameSize == fn.FrameSize && parsed.Funcs[0].ArgSize == fn.ArgSize &&
+		reflect.DeepEqual(parsed.Funcs[0].Instrs, fn.Instrs)
+}
+
+// Project only the grammar query, never the original source or emitted address.
+// AX is an ordinary encoding-equivalent base; the complete displacement/index
+// checks remain with the existing scalar move descriptor. BP as an index is
+// not a numerical input and cannot borrow this opaque-pointer holder role.
+func x86DataBPScalarMove(ins Instr) (x86ScalarNativeLoadForm, x86ScalarNativeStoreForm, bool, bool) {
+	if len(ins.Args) != 2 {
+		return x86ScalarNativeLoadForm{}, x86ScalarNativeStoreForm{}, false, false
+	}
+	projected := ins
+	projected.Args = append([]Operand(nil), ins.Args...)
+	for index, operand := range ins.Args {
+		if operand.Kind != OpMem || operand.Mem.Base != BP || operand.Mem.Index == BP {
+			continue
+		}
+		projected.Args[index].Mem.Base = AX
+		if index == 0 {
+			form, known, err := x86ScalarNativeLoadProperties(ins.Op, projected, "amd64")
+			if known && err == nil && !x86LogicalSourceFrameRegister(form.destination, "amd64") {
+				form.source = operand
+				return form, x86ScalarNativeStoreForm{}, true, false
+			}
+		} else {
+			form, known, err := x86ScalarNativeStoreProperties(ins.Op, projected, "amd64")
+			if known && err == nil && (form.source.Kind != OpReg || !x86LogicalSourceFrameRegister(form.source.Reg, "amd64")) {
+				form.destination = operand
+				return x86ScalarNativeLoadForm{}, form, false, true
+			}
+		}
+	}
+	return x86ScalarNativeLoadForm{}, x86ScalarNativeStoreForm{}, false, false
+}
+
+func x86ResultDataBPStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64) (bool, bool) {
+	if !x86ResultNamedPredicateInstruction(ins) || len(ins.Args) != 2 {
+		return false, false
+	}
+	local := x86SourceMoveInstruction(ins, "amd64")
+	first, last := ins.Args[0], ins.Args[1]
+	if local.Op == "MOVQ" && (first.Kind == OpReg && first.Reg == BP || last.Kind == OpReg && last.Reg == BP) {
+		pointer := false
+		if first.Kind == OpFP {
+			pointer = state.pointerFP[first.FPOffset]
+		} else if first.Kind == OpReg && first.Reg == BP {
+			pointer = state.shapeOnly || state.pointerGP[5]
+		} else if first.Kind == OpReg {
+			if index, _, valid := x86ResultGP(first.Reg, 8, "amd64"); valid {
+				pointer = state.shapeOnly || state.pointerGP[index]
+			}
+		}
+		index, _, valid := x86ResultGP(last.Reg, 8, "amd64")
+		if last.Kind == OpReg && last.Reg == BP {
+			index, valid = 5, true
+		}
+		if last.Kind != OpReg || !valid || !pointer {
+			return false, true
+		}
+		state.pointerGP[index], state.gp[index], state.canonicalGP[index] = true, 0, 0
+		state.callerAddressGP[index], state.callerAddressOrigin[index] = false, 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		return true, true // No pointer bits become NUM or a caller/frame address.
+	}
+	load, store, read, write := x86DataBPScalarMove(ins)
+	if !read && !write {
+		return false, false
+	}
+	memory := load.source
+	if write {
+		memory = store.destination
+	}
+	if !state.shapeOnly && !state.pointerGP[5] {
+		return false, true
+	}
+	if memory.Mem.Index != "" && !x86ResultRead(Operand{Kind: OpReg, Reg: memory.Mem.Index}, 8, state, owned, "amd64") {
+		return false, true
+	}
+	if write {
+		return x86ResultRead(store.source, store.bytes, state, owned, "amd64"), true
+	}
+	return x86ResultStore(Operand{Kind: OpReg, Reg: load.destination}, load.bytes, state, owned, resultOffset, "amd64"), true
+}
+
+func (c *amd64Ctx) lowerDataBPScalarMove(ins Instr) (bool, error) {
+	if !c.dataBPSource {
+		return false, nil
+	}
+	load, store, read, write := x86DataBPScalarMove(ins)
+	if !read && !write {
+		return false, nil
+	}
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return true, err
+	}
+	if read {
+		return true, c.lowerScalarNativeLoad(load, ins)
+	}
+	return true, c.lowerScalarNativeStore(store, ins)
+}
diff --git a/amd64_data_bp_overwrite_test.go b/amd64_data_bp_overwrite_test.go
new file mode 100644
index 000000000..04afc9417
--- /dev/null
+++ b/amd64_data_bp_overwrite_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type amd64DataBPOverwriteCase struct {
+	name, before, overwrite, after string
+	extraParameter                 bool
+}
+
+// Every negative keeps the same initialized pointer producer and numerical
+// shift as its positive control. Removing the later native BP access must not
+// turn an unsupported overwrite into an accepted dead-value transfer.
+func amd64CheckDataBPOverwriteCases(t *testing.T, cases []amd64DataBPOverwriteCase) {
+	t.Helper()
+	type program struct {
+		name, source, declaration string
+		overwrite                 bool
+	}
+	var programs []program
+	var originalObjects strings.Builder
+	for index, test := range cases {
+		for _, useBP := range []bool{false, true} {
+			for _, overwrite := range []bool{false, true} {
+				symbol := fmt.Sprintf("BPOverwrite%d_%t_%t", index, useBP, overwrite)
+				arguments, extra := 8, ""
+				if test.extraParameter {
+					arguments, extra = 16, ", adjacent uint64"
+				}
+				var body strings.Builder
+				body.WriteString("MOVQ p+0(FP),BP\nMOVL $0x12345678,AX\n")
+				body.WriteString(test.before + "\n")
+				if overwrite {
+					body.WriteString(test.overwrite + "\n")
+				}
+				body.WriteString(test.after + "\n")
+				if useBP {
+					body.WriteString("MOVL (BP),AX\n")
+				}
+				body.WriteString("ROLL $7,AX\n")
+				if useBP {
+					body.WriteString("MOVL AX,12(BP)\n")
+				}
+				source := fmt.Sprintf("TEXT ·%s(SB),4,$8-%d\n%sRET\n", symbol, arguments, body.String())
+				originalObjects.WriteString(source)
+				programs = append(programs, program{
+					name:   fmt.Sprintf("%s/use-BP=%t/overwrite=%t", test.name, useBP, overwrite),
+					source: source, declaration: fmt.Sprintf("func %s(p *[16]byte%s)\n", symbol, extra),
+					overwrite: overwrite,
+				})
+			}
+		}
+	}
+	// These are all original, legal stock-Go sources, including overlapping
+	// unaligned FP writes. A parser/encoder/tool failure is not Context evidence.
+	if !t.Run("OriginalGoObjects", func(t *testing.T) {
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", originalObjects.String())
+	}) {
+		t.Fatal("original Go object prerequisite failed; no overwrite rejection is certified")
+	}
+	for _, test := range programs {
+		t.Run(test.name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, test.source, test.declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if test.overwrite {
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("an overwritten register or FP pointer slot retained its old data-BP authority", err)
+						}
+					} else if err != nil || ir == "" {
+						t.Fatal("the identical initialized pointer source without the overwrite must remain accepted", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestAMD64DataBPRejectsPartialAndNumericRegisterOverwrites(t *testing.T) {
+	var cases []amd64DataBPOverwriteCase
+	for _, width := range []struct{ suffix, source, destination string }{
+		{"B", "AL", "BPB"}, {"W", "AX", "BP"}, {"L", "AX", "BP"}, {"Q", "AX", "BP"},
+	} {
+		cases = append(cases,
+			amd64DataBPOverwriteCase{name: "immediate/" + width.suffix,
+				overwrite: fmt.Sprintf("MOV%s $7,%s", width.suffix, width.destination)},
+			amd64DataBPOverwriteCase{name: "numeric-register/" + width.suffix,
+				overwrite: fmt.Sprintf("MOV%s %s,%s", width.suffix, width.source, width.destination)},
+		)
+	}
+	amd64CheckDataBPOverwriteCases(t, cases)
+}
+
+func TestAMD64DataBPRejectsXToBPOverwrites(t *testing.T) {
+	var cases []amd64DataBPOverwriteCase
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+		cases = append(cases, amd64DataBPOverwriteCase{
+			name: op, before: "PXOR X0,X0", overwrite: op + " X0,BP",
+		})
+	}
+	amd64CheckDataBPOverwriteCases(t, cases)
+}
+
+func TestAMD64DataBPRejectsOverwrittenAliasesAndCFGJoins(t *testing.T) {
+	var cases []amd64DataBPOverwriteCase
+	for _, width := range []struct{ suffix, source, destination string }{
+		{"B", "AL", "DL"}, {"W", "AX", "DX"}, {"L", "AX", "DX"}, {"Q", "AX", "DX"},
+	} {
+		overwrite := fmt.Sprintf("MOV%s %s,%s", width.suffix, width.source, width.destination)
+		cases = append(cases,
+			amd64DataBPOverwriteCase{name: "alias/" + width.suffix, before: "MOVQ BP,DX",
+				overwrite: overwrite, after: "MOVQ DX,BP"},
+			amd64DataBPOverwriteCase{name: "reaching-join/" + width.suffix, extraParameter: true,
+				before:    "MOVQ BP,DX\nMOVQ adjacent+8(FP),CX\nTESTQ CX,CX\nJE joined",
+				overwrite: overwrite, after: "joined:\nMOVQ DX,BP"},
+		)
+	}
+	amd64CheckDataBPOverwriteCases(t, cases)
+}
+
+func amd64CheckDataBPFPSlotOverwrites(t *testing.T, suffix string) {
+	t.Helper()
+	var cases []amd64DataBPOverwriteCase
+	for offset := 0; offset < 8; offset++ {
+		cases = append(cases, amd64DataBPOverwriteCase{
+			name: fmt.Sprintf("MOV%s/offset=%d", suffix, offset), extraParameter: true,
+			overwrite: fmt.Sprintf("MOV%s $7,p+%d(FP)", suffix, offset), after: "MOVQ p+0(FP),BP",
+		})
+	}
+	amd64CheckDataBPOverwriteCases(t, cases)
+}
+
+func TestAMD64DataBPRejectsByteFPSlotOverwriteBeforeReimport(t *testing.T) {
+	amd64CheckDataBPFPSlotOverwrites(t, "B")
+}
+
+func TestAMD64DataBPRejectsWordFPSlotOverwriteBeforeReimport(t *testing.T) {
+	amd64CheckDataBPFPSlotOverwrites(t, "W")
+}
+
+func TestAMD64DataBPRejectsDwordFPSlotOverwriteBeforeReimport(t *testing.T) {
+	amd64CheckDataBPFPSlotOverwrites(t, "L")
+}
+
+func TestAMD64DataBPRejectsQwordFPSlotOverwriteBeforeReimport(t *testing.T) {
+	amd64CheckDataBPFPSlotOverwrites(t, "Q")
+}
diff --git a/amd64_data_bp_prologue_test.go b/amd64_data_bp_prologue_test.go
new file mode 100644
index 000000000..d471826de
--- /dev/null
+++ b/amd64_data_bp_prologue_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Observe either complete stock-Go encoding, never choose by the SDK version.
+// This recognizes only the exact first-party fixture, including its original
+// body, adjusted FP input, total frame and both halves of the saved BP cell.
+// It remains a test observation, not a source-frame permission producer.
+func amd64DataBPSavedFrameListing(listing string, frame int) (string, error) {
+	if frame != 8 && frame != 16 {
+		return "", fmt.Errorf("unregistered first-party frame %d", frame)
+	}
+	line := regexp.MustCompile(`(?m)^[ \t]*0x[0-9a-f]+[ \t]+[0-9]+[ \t]+\([^\r\n]*:[0-9]+\)[ \t]+([A-Z][A-Z0-9]*)(?:[ \t]+([^\r\n]*))?\r?$`)
+	var instructions []string
+	texts := 0
+	for _, match := range line.FindAllStringSubmatch(listing, -1) {
+		op, args := match[1], strings.Join(strings.Fields(match[2]), " ")
+		if op == "TEXT" {
+			parts := strings.Split(args, ",")
+			if texts != 0 || len(instructions) != 0 || len(parts) != 3 ||
+				!strings.HasSuffix(strings.TrimSpace(parts[0]), ".Value(SB)") ||
+				strings.TrimSpace(parts[1]) != "NOSPLIT" || strings.TrimSpace(parts[2]) != fmt.Sprintf("$%d-8", frame+8) {
+				return "", fmt.Errorf("original Go TEXT lost its exact saved-word frame: %s", args)
+			}
+			texts++
+			continue
+		}
+		if op == "FUNCDATA" || op == "PCDATA" {
+			continue // Zero-width compiler metadata is not an executed instruction.
+		}
+		instructions = append(instructions, strings.TrimSpace(op+" "+args))
+	}
+	if texts != 1 || len(instructions) != 10 {
+		return "", fmt.Errorf("incomplete or extended fixture: TEXTs=%d instructions=%v", texts, instructions)
+	}
+	body := []string{
+		fmt.Sprintf("MOVQ p+%d(FP), BP", frame+16),
+		"MOVL (BP), AX", "ROLL $7, AX", "MOVL AX, 12(BP)",
+	}
+	var style string
+	var expected []string
+	switch instructions[0] {
+	case "PUSHQ BP":
+		style = "PUSH/MOV/SUB + ADD/POP/RET"
+		expected = []string{"PUSHQ BP", "MOVQ SP, BP", fmt.Sprintf("SUBQ $%d, SP", frame)}
+		expected = append(expected, body...)
+		expected = append(expected, fmt.Sprintf("ADDQ $%d, SP", frame), "POPQ BP", "RET")
+	case fmt.Sprintf("SUBQ $%d, SP", frame+8):
+		style = "SUB/store/LEA + load/ADD/RET"
+		expected = []string{
+			fmt.Sprintf("SUBQ $%d, SP", frame+8), fmt.Sprintf("MOVQ BP, %d(SP)", frame),
+			fmt.Sprintf("LEAQ %d(SP), BP", frame),
+		}
+		expected = append(expected, body...)
+		expected = append(expected, fmt.Sprintf("MOVQ %d(SP), BP", frame), fmt.Sprintf("ADDQ $%d, SP", frame+8), "RET")
+	default:
+		return "", fmt.Errorf("unknown original Go frame entry: %s", instructions[0])
+	}
+	for index := range expected {
+		if instructions[index] != expected[index] {
+			return "", fmt.Errorf("%s instruction %d=%q, want %q", style, index, instructions[index], expected[index])
+		}
+	}
+	return style, nil
+}
+
+func TestAMD64DataBPSavedFrameListingRequiresCompleteOrderedEnvelope(t *testing.T) {
+	for _, frame := range []int{8, 16} {
+		for _, style := range []string{"PUSH", "SP-cell"} {
+			name := fmt.Sprintf("%s/%d", style, frame)
+			var instructions []string
+			if style == "PUSH" {
+				instructions = []string{
+					"PUSHQ BP", "MOVQ SP, BP", fmt.Sprintf("SUBQ $%d, SP", frame),
+					fmt.Sprintf("MOVQ p+%d(FP), BP", frame+16), "MOVL (BP), AX", "ROLL $7, AX", "MOVL AX, 12(BP)",
+					fmt.Sprintf("ADDQ $%d, SP", frame), "POPQ BP", "RET",
+				}
+			} else {
+				instructions = []string{
+					fmt.Sprintf("SUBQ $%d, SP", frame+8), fmt.Sprintf("MOVQ BP, %d(SP)", frame), fmt.Sprintf("LEAQ %d(SP), BP", frame),
+					fmt.Sprintf("MOVQ p+%d(FP), BP", frame+16), "MOVL (BP), AX", "ROLL $7, AX", "MOVL AX, 12(BP)",
+					fmt.Sprintf("MOVQ %d(SP), BP", frame), fmt.Sprintf("ADDQ $%d, SP", frame+8), "RET",
+				}
+			}
+			listing := func(rows []string, extent int) string {
+				var text strings.Builder
+				fmt.Fprintf(&text, "\t0x0000 00000 (fixture.s:1)\tTEXT\tfixture.Value(SB), NOSPLIT, $%d-8\n", extent)
+				for index, row := range rows {
+					op, args, _ := strings.Cut(row, " ")
+					fmt.Fprintf(&text, "\t0x%04x %05d (fixture.s:%d)\t%s\t%s\n", index, index, index+1, op, args)
+				}
+				return text.String()
+			}
+			t.Run(name+"/complete", func(t *testing.T) {
+				if _, err := amd64DataBPSavedFrameListing(listing(instructions, frame+8), frame); err != nil {
+					t.Fatal("independent complete stock-Go fixture was rejected", err)
+				}
+			})
+			for _, mutation := range []string{
+				"delete-save", "delete-restore", "wrong-save", "wrong-restore", "wrong-frame-setup",
+				"wrong-allocation", "wrong-release", "wrong-FP-input", "swap-save-and-setup", "duplicate-save", "delete-return", "wrong-TEXT",
+			} {
+				t.Run(name+"/"+mutation, func(t *testing.T) {
+					rows := append([]string(nil), instructions...)
+					save, setup, allocation, restore, release := 0, 1, 2, 8, 7
+					if style == "SP-cell" {
+						save, setup, allocation, restore, release = 1, 2, 0, 7, 8
+					}
+					extent := frame + 8
+					switch mutation {
+					case "delete-save":
+						rows = append(rows[:save], rows[save+1:]...)
+					case "delete-restore":
+						rows = append(rows[:restore], rows[restore+1:]...)
+					case "wrong-save":
+						rows[save] = fmt.Sprintf("MOVQ BP, %d(SP)", frame+8)
+					case "wrong-restore":
+						rows[restore] = fmt.Sprintf("MOVQ %d(SP), BP", frame+8)
+					case "wrong-frame-setup":
+						rows[setup] = fmt.Sprintf("LEAQ %d(SP), BP", frame+8)
+					case "wrong-allocation":
+						rows[allocation] = fmt.Sprintf("SUBQ $%d, SP", frame+16)
+					case "wrong-release":
+						rows[release] = fmt.Sprintf("ADDQ $%d, SP", frame+16)
+					case "wrong-FP-input":
+						rows[3] = fmt.Sprintf("MOVQ p+%d(FP), BP", frame+8)
+					case "swap-save-and-setup":
+						rows[save], rows[setup] = rows[setup], rows[save]
+					case "duplicate-save":
+						rows = append(rows, rows[save])
+					case "delete-return":
+						rows = rows[:len(rows)-1]
+					case "wrong-TEXT":
+						extent += 8
+					}
+					if _, err := amd64DataBPSavedFrameListing(listing(rows, extent), frame); err == nil {
+						t.Fatal("an incomplete, reordered or wrong-width saved-BP frame passed observation")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_data_bp_source_test.go b/amd64_data_bp_source_test.go
new file mode 100644
index 000000000..a8046ea11
--- /dev/null
+++ b/amd64_data_bp_source_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These fixtures need only a source-defined data register. They do not read
+// physical BP, expose a frame address or use their allocated local storage.
+// The real Go prologue/epilogue is observed separately below; a frame-size
+// number by itself is not a reusable native-frame permission.
+func amd64DataBPSource(frame int, setup, body string) string {
+	return fmt.Sprintf("TEXT ·Value(SB),4,$%d-8\n%s\n%s\nRET\n", frame, setup, body)
+}
+
+func TestAMD64DataBPActualGoSavedFramePrologue(t *testing.T) {
+	for _, frame := range []int{8, 16} {
+		t.Run(fmt.Sprint(frame), func(t *testing.T) {
+			source := amd64DataBPSource(frame, "MOVQ p+0(FP),BP",
+				"MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)")
+			listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			style, err := amd64DataBPSavedFrameListing(listing, frame)
+			if err != nil {
+				t.Fatalf("original Go did not preserve the complete ordered BP/frame envelope: %v\n%s", err, listing)
+			}
+			t.Logf("original Go preserves its physical BP using %s; this observation grants no translator frame capability", style)
+		})
+	}
+}
+
+func TestAMD64SourceDefinedDataBPInitializedProgramsThreeAPIs(t *testing.T) {
+	for _, row := range []struct {
+		name, setup, body string
+		frame             int
+	}{
+		{"direct", "MOVQ p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"copied-pointer", "MOVQ p+0(FP),SI\nMOVQ SI,BP", "MOVL 4(BP),AX\nROLL $7,AX\nMOVL AX,8(BP)", 8},
+		{"copied-back", "MOVQ p+0(FP),BP\nMOVQ BP,BX", "MOVL 8(BX),AX\nROLL $7,AX\nMOVL AX,12(BX)", 16},
+		{"same-origin-join", "MOVL $1,CX\nCMPL CX,$0\nJE other\nMOVQ p+0(FP),BP\nJMP join\nother:\nMOVQ p+0(FP),BP\njoin:",
+			"MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 16},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := amd64DataBPSource(row.frame, row.setup, row.body)
+			for _, triple := range []string{
+				"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "amd64", triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[4]uint32)\n", "amd64", triple, api)
+							if err != nil || ir == "" {
+								t.Fatalf("complete source-defined data BP lost its initialized input: %v", err)
+							}
+							if !strings.Contains(ir, "load volatile i32") || !strings.Contains(ir, "store volatile i32") {
+								t.Fatal("source-defined data BP must retain the original exact native accesses")
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestAMD64SourceDefinedDataBPDoesNotGrantMissingInputsOrFrameRoles(t *testing.T) {
+	for _, row := range []struct {
+		name, setup, body string
+		frame             int
+	}{
+		{"unknown-entry", "NOP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"partial-pointer", "MOVW p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"truncated-pointer", "MOVL p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"numeric-address", "MOVQ $7,BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"unknown-store-data", "MOVQ p+0(FP),BP", "MOVL AX,12(BP)\nROLL $7,AX", 8},
+		{"lost-pointer", "MOVQ p+0(FP),BP\nMOVL $7,BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"missing-path", "MOVL $1,CX\nCMPL CX,$0\nJE join\nMOVQ p+0(FP),BP\njoin:",
+			"MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"entry-physical-BP", "MOVQ BP,SI\nMOVQ p+0(FP),BP", "MOVL (SI),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"physical-SP", "MOVQ SP,BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"FP-address", "LEAQ p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"unbound-AUTO", "MOVQ p+0(FP),BP\nMOVQ $7,slot-8(SP)", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 8},
+		{"frameless-clobber", "MOVQ p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)", 0},
+		{"raw-RET", "MOVQ p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)\nBYTE $0xc3", 8},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := amd64DataBPSource(row.frame, row.setup, row.body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[4]uint32)\n", "amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("a data-register source view manufactured missing input or physical-frame authority: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestAMD64SourceDefinedDataBPRejectsUnusedFPAddressesThreeAPIs(t *testing.T) {
+	for _, address := range []string{
+		"LEAW n+8(FP),AX", "LEAL n+8(FP),AX", "LEAQ n+8(FP),AX",
+		"MOVQ $n+8(FP),AX", "MOVD $n+8(FP),AX", "MOVDQ2Q $n+8(FP),AX",
+	} {
+		t.Run(address, func(t *testing.T) {
+			for _, takeAddress := range []bool{false, true} {
+				t.Run(fmt.Sprintf("take-address=%t", takeAddress), func(t *testing.T) {
+					body := "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)"
+					if takeAddress {
+						// n is a real initialized numerical parameter, not a missing
+						// slot or pointer. AX is overwritten before observation, so
+						// unused-address transfer cannot conceal a missing input.
+						body = address + "\n" + body
+					}
+					source := strings.Replace(amd64DataBPSource(8, "MOVQ p+0(FP),BP", body), "$8-8", "$8-16", 1)
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[4]uint32,n uint64)\n",
+								"amd64", "x86_64-unknown-linux-gnu", api)
+							if takeAddress {
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("an unused but actual FP address borrowed the data BP source scope", err)
+								}
+							} else if err != nil || ir == "" {
+								t.Fatal("the same complete initialized program without FP-address observation must remain supported", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_data_bp_state_test.go b/amd64_data_bp_state_test.go
new file mode 100644
index 000000000..7fa22fe2e
--- /dev/null
+++ b/amd64_data_bp_state_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64SourceDefinedDataBPExactNativeWidthsAndAliases(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	var source, declarations strings.Builder
+	for index, row := range []struct{ move, rotate, register string }{
+		{"MOVB", "ROLB", "AL"}, {"MOVW", "ROLW", "AX"},
+		{"MOVL", "ROLL", "AX"}, {"MOVQ", "ROLQ", "AX"},
+		{"MOVD", "ROLQ", "AX"}, {"MOVDQ2Q", "ROLQ", "AX"},
+	} {
+		name := fmt.Sprintf("Value%d", index)
+		body := fmt.Sprintf("%s (BP),%s\n%s $7,%s\n%s %s,8(BP)",
+			row.move, row.register, row.rotate, row.register, row.move, row.register)
+		source.WriteString(strings.Replace(amd64DataBPSource(8, "MOVQ p+0(FP),BP", body), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *[16]byte)\n", name)
+	}
+	for _, triple := range []string{
+		"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete data BP move widths/source aliases lost their typed input", err)
+					}
+					for _, width := range []int{8, 16, 32, 64} {
+						want := 1
+						if width == 64 {
+							want = 3
+						}
+						if strings.Count(ir, fmt.Sprintf("load volatile i%d,", width)) != want ||
+							strings.Count(ir, fmt.Sprintf("store volatile i%d ", width)) != want {
+							t.Fatal("native BP input/output must retain every exact-width original access", width)
+						}
+					}
+					for _, body := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						compileLLVMToObject(t, llc, triple, "data-bp.ll", "data-bp.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestAMD64SourceDefinedDataBPUsesExistingPointerCloneJoinAndAtomicity(t *testing.T) {
+	var initial x86ResultState
+	initial.pointerFP = map[int64]bool{0: true}
+	initial.gp[1], initial.canonicalGP[1] = 0xff, 1
+	initial.flags, initial.direction = x86ByteFlagCF, x86ResultDirectionBackward
+	state := initial.clone()
+	imported := x86ScalarLaneInstruction(t, "MOVQ p+0(FP),BP")
+	if accepted, known := x86ResultDataBPStep(imported, &state, nil, 0); !accepted || !known {
+		t.Fatal("complete typed import did not define the existing BP opaque-pointer slot")
+	}
+	want := initial.clone()
+	want.pointerGP[5] = true
+	if !reflect.DeepEqual(state, want) || state.gp[5] != 0 || state.callerAddressGP[5] {
+		t.Fatal("a data BP import fabricated NUM, caller-address or unrelated state")
+	}
+
+	clone := state.clone()
+	clone.pointerGP[5] = false
+	if !state.pointerGP[5] || state.intersect(clone).pointerGP[5] {
+		t.Fatal("a clone/join retained an absent incoming BP pointer identity")
+	}
+	if !state.intersect(state.clone()).pointerGP[5] {
+		t.Fatal("equal complete pointer paths lost their existing must-fact")
+	}
+	for _, spelling := range []string{
+		"MOVQ BP,BX", "MOVQ BX,BP", "MOVL (BP),AX", "MOVL AX,8(BP)",
+	} {
+		t.Run("initialized/"+spelling, func(t *testing.T) {
+			before := state.clone()
+			before.pointerGP[3], before.gp[0] = true, 0xff
+			if accepted, known := x86ResultDataBPStep(x86ScalarLaneInstruction(t, spelling), &before, nil, 0); !accepted || !known {
+				t.Fatal("an actual initialized pointer/data input was lost", accepted, known)
+			}
+			if before.flags != state.flags || before.direction != state.direction || before.gp[5] != 0 || before.callerAddressGP[5] {
+				t.Fatal("data BP transfer created pointer bits or changed FLAGS/DF")
+			}
+		})
+	}
+	for _, spelling := range []string{
+		"MOVQ BP,BX", "MOVQ BX,BP", "MOVL (BP),AX", "MOVL AX,8(BP)", "MOVL (BP)(CX*1),AX",
+	} {
+		t.Run("missing/"+spelling, func(t *testing.T) {
+			before := initial.clone()
+			before.gp[1] = 0
+			frozen := before.clone()
+			if accepted, known := x86ResultDataBPStep(x86ScalarLaneInstruction(t, spelling), &before, nil, 0); accepted || !known || !reflect.DeepEqual(before, frozen) {
+				t.Fatal("a rejected transfer manufactured input facts or partially mutated state", accepted, known)
+			}
+		})
+	}
+	for byteIndex := 0; byteIndex < 8; byteIndex++ {
+		t.Run(fmt.Sprintf("index-byte/%d", byteIndex), func(t *testing.T) {
+			before := state.clone()
+			before.gp[1] = 0xff &^ (1 << byteIndex)
+			frozen := before.clone()
+			instruction := x86ScalarLaneInstruction(t, "MOVL (BP)(CX*1),AX")
+			if accepted, known := x86ResultDataBPStep(instruction, &before, nil, 0); accepted || !known || !reflect.DeepEqual(before, frozen) {
+				t.Fatal("an actual incoming BP pointer substituted for a missing numerical index byte")
+			}
+		})
+	}
+}
+
+func TestAMD64SourceDefinedDataBPScopeDoesNotBorrowOtherOwners(t *testing.T) {
+	source := amd64DataBPSource(8, "MOVQ p+0(FP),BP", "MOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)")
+	_, file, signature, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[4]uint32)",
+		"MOVQ p+0(FP),BP\nMOVL (BP),AX\nROLL $7,AX\nMOVL AX,12(BP)\nRET")
+	parsed, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file.Funcs[0] = parsed.Funcs[0]
+	if !x86DataBPSourceScope(file.Funcs[0], signature, "amd64") {
+		t.Fatal("the independent initialized complete named source lost its data-register view")
+	}
+	for _, mutation := range []string{
+		"mode32", "frameless", "changed-frame", "changed-args", "NOFRAME", "NEEDCTXT", "CALL", "raw-origin",
+		"raw-entry", "source-stack", "fixed-local", "continuation", "register-entry", "FP-address", "SP", "private-PUSH",
+		"changed-source-raw", "changed-source-operands",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			fn, sig, arch := file.Funcs[0], signature, "amd64"
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			switch mutation {
+			case "mode32":
+				arch = "386"
+			case "frameless":
+				fn.FrameSize = 0
+			case "changed-frame":
+				fn.FrameSize += 8
+			case "changed-args":
+				fn.ArgSize += 8
+			case "NOFRAME":
+				fn.Instrs[0].Raw = "TEXT ·Value(SB),516,$8-8"
+			case "NEEDCTXT":
+				fn.Instrs[0].Raw = "TEXT ·Value(SB),68,$8-8"
+			case "CALL":
+				fn.Instrs[2] = x86ScalarLaneInstruction(t, "CALL foreign(SB)")
+			case "raw-origin":
+				fn.Instrs[2].x86Encoded = true
+			case "raw-entry":
+				fn.X86RawText = []byte{0xc3}
+			case "source-stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed-local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			case "continuation":
+				fn.x86ContinuationFlow = new(x86ContinuationFlow)
+			case "register-entry":
+				sig.ArgRegs = []Reg{AX}
+			case "FP-address":
+				fn.Instrs[2] = x86ScalarLaneInstruction(t, "LEAQ p+0(FP),AX")
+			case "SP":
+				fn.Instrs[2] = x86ScalarLaneInstruction(t, "MOVQ SP,AX")
+			case "private-PUSH":
+				fn.Instrs[2] = x86ScalarLaneInstruction(t, "PUSHQ AX")
+			case "changed-source-raw":
+				fn.Instrs[1].Raw = "MOVQ unknown+0(FP),AX"
+			case "changed-source-operands":
+				fn.Instrs[1].Args = append([]Operand(nil), fn.Instrs[1].Args...)
+				fn.Instrs[1].Args[1].Reg = BX
+			}
+			if x86DataBPSourceScope(fn, sig, arch) {
+				t.Fatal("the bounded data-register source view borrowed another physical/source owner")
+			}
+		})
+	}
+	for _, address := range []string{
+		"LEAW p+0(FP),AX", "LEAL p+0(FP),AX", "LEAQ p+0(FP),AX",
+		"MOVQ $p+0(FP),AX", "MOVD $p+0(FP),AX", "MOVDQ2Q $p+0(FP),AX",
+	} {
+		t.Run("complete-FP-address-family/"+address, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			fn.Instrs[2] = x86ScalarLaneInstruction(t, address)
+			if x86DataBPSourceScope(fn, signature, "amd64") {
+				t.Fatal("the complete LEA width/address-MOV alias family acquired a data BP source role")
+			}
+		})
+	}
+}
diff --git a/amd64_defined_status_consumers_test.go b/amd64_defined_status_consumers_test.go
new file mode 100644
index 000000000..89716399a
--- /dev/null
+++ b/amd64_defined_status_consumers_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86StatusFlagMaskClearsExactlyItsPhysicalSubset(t *testing.T) {
+	// Independent architectural bit positions, not the production slot list.
+	flags := []struct {
+		bit  uint
+		slot string
+	}{
+		{0, "%flags_cf"}, {2, "%flags_pf"}, {4, "%flags_af"},
+		{6, "%flags_z"}, {7, "%flags_slt"}, {11, "%flags_of"},
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for subset := 0; subset < 64; subset++ {
+			t.Run(fmt.Sprintf("%s/subset=%02x", arch, subset), func(t *testing.T) {
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				output.Reset()
+				temporary := ctx.tmp
+				var mask x86StatusFlagMask
+				var want strings.Builder
+				for index, flag := range flags {
+					if subset&(1<<uint(index)) != 0 {
+						mask |= 1 << flag.bit
+						fmt.Fprintf(&want, "  store i1 false, ptr %s\n", flag.slot)
+					}
+				}
+				ctx.clearX86StatusFlags(mask)
+				if output.String() != want.String() || ctx.tmp != temporary {
+					t.Fatal("status subset changed another bit, allocated a value, or lost a selected bit",
+						output.String(), want.String())
+				}
+			})
+		}
+	}
+}
+
+// Each combined object contains the complete affected family. This avoids one
+// compiler process per spelling while retaining all Go sources and three APIs.
+// These are object proofs, not execution of WAITPKG/random/enqueue instructions.
+func TestX86DefinedStatusThreeAPIsFiveTargetsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("required LLVM 22 llc missing")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, initialized := range []bool{false, true} {
+			var declarations, assembly strings.Builder
+			word, valueType, valueBytes := "Q", "uint64", 8
+			if target.arch == "386" {
+				word, valueType, valueBytes = "L", "uint32", 4
+			}
+			writers := x86DefinedZeroAFWriters()
+			for _, op := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+				writers = append(writers, x86DefinedZeroAFCase{op, op + " X0,X1", false})
+			}
+			count := 0
+			for _, row := range writers {
+				if target.arch == "386" && row.amd64Only {
+					continue // Absent 64-bit Go encoding, not a skipped target.
+				}
+				name := fmt.Sprintf("status%d", count)
+				parameters := "seed " + valueType
+				argumentBytes, returnOffset := 2*valueBytes, valueBytes
+				// Initialize each instruction's actual complete inputs. MOVL to X
+				// clears X128; KMOVW zero-extends K. Both precede the FLAGS seed.
+				setup := ""
+				if initialized && strings.HasPrefix(row.op, "ENQCMD") {
+					parameters += ", command, device *[64]byte"
+					argumentBytes, returnOffset = 4*valueBytes, 3*valueBytes
+					setup += fmt.Sprintf("MOV%s command+%d(FP),AX\nMOV%s device+%d(FP),DI\n",
+						word, valueBytes, word, 2*valueBytes)
+				}
+				fmt.Fprintf(&declarations, "func %s(%s) %s\n", name, parameters, valueType)
+				if strings.Contains(row.instruction, "X0") {
+					setup += "MOVL AX,X0\nMOVL AX,X1\n"
+				}
+				if strings.Contains(row.instruction, "K1") {
+					setup += "KMOVW AX,K1\nKMOVW AX,K2\n"
+				}
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\n"+
+					"%s"+
+					"PUSH%s seed+0(FP)\nPOPF%s\n%s\nPUSHF%s\nPOP%s CX\nMOV%s CX,ret+%d(FP)\nRET\n",
+					name, argumentBytes, setup, word, word, row.instruction, word, word, word, returnOffset)
+				count++
+			}
+			wantCount := 42
+			if target.arch == "386" {
+				wantCount = 39
+			}
+			if count != wantCount {
+				t.Fatal("complete independent defined-status family changed", target.arch, count)
+			}
+			goAssemblerOracleOutput(t, target.arch, assembly.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/initialized=%t/%s", target.triple, initialized, api), func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(),
+						target.arch, target.triple, api)
+					if initialized {
+						if err != nil {
+							t.Fatal("complete initialized status family", err)
+						}
+					} else {
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("original enqueue source invented its two addresses", err)
+						}
+						// Keep the complete original 42/39-function source, including
+						// invalid enqueue inputs, as a direct format-object witness.
+						file, err := Parse(ArchAMD64, assembly.String())
+						if err != nil {
+							t.Fatal(err)
+						}
+						pkg := mustGoPackage(t, "status", "package status\n"+declarations.String())
+						resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+						sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+						if err != nil {
+							t.Fatal(err)
+						}
+						normalized, err := normalizeX86RawFile(file, target.arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir = x86ScalarFormatObjectUnit(t, normalized, sigs, target.arch, target.triple, 0)
+					}
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprint("O2=", optimized), func(t *testing.T) {
+							input := ir
+							if optimized {
+								input = x86UndefinedTrapOptimizedIR(t, input)
+							}
+							compileLLVMToObject(t, llc, target.triple, "status.ll", "status.o", input)
+							t.Logf("actual LLVM object contains %d declared status writers", count)
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_defined_status_ia32_test.go b/amd64_defined_status_ia32_test.go
new file mode 100644
index 000000000..4a0dd3f1e
--- /dev/null
+++ b/amd64_defined_status_ia32_test.go
@@ -0,0 +1,405 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// IA32 has no Q-width POPCNT. This retains all seven physical baseline kernels
+// without granting an IA32 encoding or runtime role to VEX/mask instructions.
+func x86DefinedStatusIA32Kernels() []x86DefinedStatusKernel {
+	var result []x86DefinedStatusKernel
+	for _, kernel := range x86DefinedStatusKernels()[:8] {
+		if kernel.kind == 0 && kernel.bits == 64 {
+			continue
+		}
+		result = append(result, kernel)
+	}
+	return result
+}
+
+func x86DefinedStatusIA32Fixture(arch string) (declarations, source string) {
+	word, pointerBytes := "L", 4
+	if arch == "amd64" {
+		word, pointerBytes = "Q", 8
+	}
+	var decl, assembly strings.Builder
+	for _, kernel := range x86DefinedStatusIA32Kernels() {
+		fmt.Fprintf(&decl, "func %s(out *[8]uint32, left, right, seed uint32)\n", kernel.name)
+		fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-%d
+MOV%s out+0(FP),DI
+MOVL left+%d(FP),AX
+MOVL right+%d(FP),BX
+MOVL seed+%d(FP),SI
+MOVL BX,DX
+MOVL AX,X0
+MOVL BX,X1
+PUSH%s SI
+POPF%s
+%s
+PUSHF%s
+POP%s SI
+MOVL SI,0(DI)
+LAHF
+MOVB AH,4(DI)
+RET
+`, kernel.name, pointerBytes+12, word, pointerBytes, pointerBytes+4,
+			pointerBytes+8, word, word, kernel.instruction, word, word)
+	}
+	return decl.String(), assembly.String()
+}
+
+// Reuse the independent mathematical model and all 8x8x2 input axes. Only the
+// transport width changes. Signed length is widened before abs so MinInt32 is
+// not negated in a 32-bit int; Go's vector-fill shifts otherwise remain defined.
+func x86DefinedStatusIA32GoDriver(t *testing.T) string {
+	t.Helper()
+	var names, kinds, widths strings.Builder
+	for _, kernel := range x86DefinedStatusIA32Kernels() {
+		fmt.Fprintf(&names, "%s,\n", kernel.name)
+		fmt.Fprintf(&kinds, "%d,", kernel.kind)
+		fmt.Fprintf(&widths, "%d,", kernel.bits)
+	}
+	source := strings.NewReplacer(
+		"KERNEL_NAMES", names.String(), "KERNEL_KINDS", kinds.String(),
+		"KERNEL_WIDTHS", widths.String(), "ACTUAL_OBSERVATIONS", "false",
+		"uint64", "uint32", "0xa7a7a7a7a7a7a7a7", "0xa7a7a7a7",
+		"if bits == 64", "if bits == 32",
+		"int(int32(left)), int(int32(right))", "int64(int32(left)), int64(int32(right))",
+		"la, lb := 16, 16", "la, lb := int64(16), int64(16)",
+		"if i >= la && i >= lb || i < la && i < lb", "if int64(i) >= la && int64(i) >= lb || int64(i) < la && int64(i) < lb",
+	).Replace(x86DefinedStatusGoDriver)
+	formatted, err := format.Source([]byte(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(formatted)
+}
+
+func x86DefinedStatusIA32CDriver() string {
+	var prototypes, kernels strings.Builder
+	for _, kernel := range x86DefinedStatusIA32Kernels() {
+		fmt.Fprintf(&prototypes, "extern void %s(uint32_t *, uint32_t, uint32_t, uint32_t);\n", kernel.name)
+		fmt.Fprintf(&kernels, "{%s,%d,%d,\"%s\"},\n", kernel.name, kernel.kind, kernel.bits, kernel.instruction)
+	}
+	source := strings.NewReplacer(
+		"KERNEL_PROTOTYPES", prototypes.String(), "KERNELS", kernels.String(),
+		"uint64_t", "uint32_t", "UINT64_MAX", "UINT32_MAX", "UINT64_C", "UINT32_C",
+		"0xa7a7a7a7a7a7a7a7", "0xa7a7a7a7",
+		"bits == 64 ?", "bits == 32 ?",
+		"a[i] = right>>(8*i);", "a[i] = ((uint64_t)right)>>(8*i);",
+		"b[i] = left>>(8*i);", "b[i] = ((uint64_t)left)>>(8*i);",
+	).Replace(x86DefinedStatusCDriver)
+	return source
+}
+
+func x86DefinedStatusIA32BuildOriginal(t *testing.T) x87IA32Executable {
+	t.Helper()
+	dir := t.TempDir()
+	declarations, assembly := x86DefinedStatusIA32Fixture("386")
+	inputs := map[string]string{
+		"go.mod":       "module definedstatus386\n\ngo 1.20\n",
+		"main.go":      x86DefinedStatusIA32GoDriver(t),
+		"decl.go":      "package main\n" + declarations,
+		"status_386.s": assembly,
+	}
+	for name, contents := range inputs {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("original IA32 input=%s bytes=%d sha256=%x", name, len(contents), sha256.Sum256([]byte(contents)))
+	}
+	goBinary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	env := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOROOT="+runtime.GOROOT(), "GOFLAGS=", "GOEXPERIMENT=", "GOOS=linux",
+		"GOARCH=386", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	version, err := x87IA32Capture(t, goBinary, []string{"version"}, dir, env)
+	if err != nil || !strings.HasPrefix(string(version), "go version "+runtime.Version()+" ") {
+		t.Fatalf("original IA32 SDK identity mismatch: %v\n%s", err, version)
+	}
+	executable := filepath.Join(dir, "original-go")
+	output, err := x87IA32Capture(t, goBinary,
+		[]string{"build", "-p=2", "-o", executable, "."}, dir, env)
+	if err != nil || len(output) != 0 {
+		t.Fatalf("original IA32 Go build failed: %v\n%s", err, output)
+	}
+	sealed, err := x87IA32StaticExecutable(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("original Go %s static IA32 ELF bytes=%d sha256=%x; compile-only receipt",
+		runtime.Version(), sealed.size, sealed.hash)
+	return sealed
+}
+
+func TestX86DefinedStatusIA32OriginalGoStaticELFActualCompile(t *testing.T) {
+	executable := x86DefinedStatusIA32BuildOriginal(t)
+	if err := executable.verify(); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("seven kernels and 896 mathematical observations built; native execution is a separate required root")
+}
+
+func TestX86DefinedStatusIA32RequiredNativeCounterpartSource(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_defined_status_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var counterpart *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == "TestCrossLinuxRuntimeMatrixX86DefinedStatusNative386" {
+			counterpart = function
+		}
+	}
+	if counterpart == nil {
+		t.Fatal("required original-Go/LLVM O0/O2 native IA32 defined-status counterpart is missing")
+	}
+	want := map[string]bool{
+		"x87IA32RequireNativeHost":          false,
+		"x86DefinedStatusIA32BuildOriginal": false,
+		"x87IA32RunDirect":                  false,
+		"x86DefinedStatusIA32CompileAndRun": false,
+	}
+	levels := map[string]bool{"-O0": false, "-O2": false}
+	ast.Inspect(counterpart.Body, func(node ast.Node) bool {
+		if literal, ok := node.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, required := levels[value]; required {
+				levels[value] = true
+			}
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if function, ok := call.Fun.(*ast.Ident); ok {
+			if _, required := want[function.Name]; required {
+				want[function.Name] = true
+			}
+		}
+		if selector, ok := call.Fun.(*ast.SelectorExpr); ok && strings.HasPrefix(selector.Sel.Name, "Skip") {
+			t.Error("required native IA32 counterpart cannot skip failed tools or execution")
+		}
+		return true
+	})
+	for function, found := range want {
+		if !found {
+			t.Errorf("required native IA32 counterpart lacks %s", function)
+		}
+	}
+	for level, found := range levels {
+		if !found {
+			t.Errorf("required native IA32 counterpart lacks %s", level)
+		}
+	}
+	ast.Inspect(file, func(node ast.Node) bool {
+		literal, ok := node.(*ast.BasicLit)
+		if ok && literal.Kind == token.STRING {
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if value == "qemu-i386" || value == "-exec" {
+				t.Error("required native IA32 counterpart cannot substitute a guest executor")
+			}
+		}
+		return true
+	})
+}
+
+func x86DefinedStatusIA32Capabilities(cpuinfo string) error {
+	flags := make(map[string]bool)
+	for _, line := range strings.Split(cpuinfo, "\n") {
+		key, value, ok := strings.Cut(line, ":")
+		if ok && strings.TrimSpace(key) == "flags" {
+			for _, flag := range strings.Fields(value) {
+				flags[flag] = true
+			}
+		}
+	}
+	for _, required := range []string{"sse4_1", "sse4_2", "popcnt"} {
+		if !flags[required] {
+			return fmt.Errorf("required native IA32 capability missing: %s", required)
+		}
+	}
+	return nil
+}
+
+func x86DefinedStatusIA32RequireCapabilities(t *testing.T) {
+	t.Helper()
+	file, err := os.Open("/proc/cpuinfo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	contents, err := io.ReadAll(io.LimitReader(file, (4<<20)+1))
+	if err != nil || len(contents) > 4<<20 {
+		t.Fatal("unbound native IA32 capability observation", err)
+	}
+	if err := x86DefinedStatusIA32Capabilities(string(contents)); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86DefinedStatusIA32CapabilitiesAreRequired(t *testing.T) {
+	if err := x86DefinedStatusIA32Capabilities("flags: fpu cmov popcnt sse4_1 sse4_2\n"); err != nil {
+		t.Fatal(err)
+	}
+	for _, observation := range []string{
+		"flags: fpu cmov sse4_1 sse4_2\n", "flags: fpu cmov popcnt sse4_2\n",
+		"flags: fpu cmov popcnt sse4_1\n", "notflags: popcnt sse4_1 sse4_2\n",
+		"flags: popcnt_extended sse4_1_extended sse4_2_extended\n", "",
+	} {
+		if x86DefinedStatusIA32Capabilities(observation) == nil {
+			t.Errorf("missing/foreign CPU capability was accepted: %q", observation)
+		}
+	}
+}
+
+func TestX86DefinedStatusIA32ReferenceTransportWidth(t *testing.T) {
+	kernels := x86DefinedStatusIA32Kernels()
+	if len(kernels) != 7 || kernels[0].bits != 16 || kernels[1].bits != 32 {
+		t.Fatal("native IA32 kernel denominator changed", kernels)
+	}
+	declarations, source := x86DefinedStatusIA32Fixture("386")
+	if strings.Count(declarations, "*[8]uint32") != 7 ||
+		strings.Count(source, "$0-16") != 7 || strings.Count(source, "MOVB AH,4(DI)") != 7 ||
+		strings.Contains(source, "Q ") || strings.Contains(source, "PUSHFQ") {
+		t.Fatal("IA32 fixture lost actual four-byte transport or physical instruction width")
+	}
+	goSource := x86DefinedStatusIA32GoDriver(t)
+	if !strings.Contains(goSource, "int64(int32(left))") || !strings.Contains(goSource, "int64(int32(right))") {
+		t.Fatal("minimum signed IA32 length must be widened before negation")
+	}
+	cSource := x86DefinedStatusIA32CDriver()
+	if strings.Contains(cSource, "= right>>(8*i)") || strings.Contains(cSource, "= left>>(8*i)") ||
+		!strings.Contains(cSource, "((uint64_t)right)>>(8*i)") || !strings.Contains(cSource, "((uint64_t)left)>>(8*i)") {
+		t.Fatal("independent C vector filling must not shift a uint32 by 32 or more")
+	}
+	if !strings.Contains(cSource, "bits == 32 ? UINT32_MAX") || !strings.Contains(goSource, "if bits == 32") {
+		t.Fatal("full IA32 mask must not shift a uint32 by its width")
+	}
+}
+
+func TestX86DefinedStatusIA32IndependentCActualCompile(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("required LLVM 22 clang missing")
+	}
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "model.c"), filepath.Join(dir, "model.o")
+	// Freestanding syntax/object checking needs no host libc headers or fake
+	// sysroot. The required native counterpart uses the unchanged stdio driver.
+	source := strings.Replace(x86DefinedStatusIA32CDriver(), "#include <stdio.h>",
+		"extern int printf(const char *, ...);", 1)
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output, err := x87IA32Capture(t, clang, []string{"-target", "i386-unknown-linux-gnu",
+				"-ffreestanding", "-Wall", "-Wextra", "-Werror", level, "-c", input, "-o", object}, dir, os.Environ())
+			if err != nil || len(output) != 0 {
+				t.Fatalf("independent IA32 C model object failed: %v\n%s", err, output)
+			}
+			parsed, err := elf.Open(object)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer parsed.Close()
+			if parsed.Class != elf.ELFCLASS32 || parsed.Machine != elf.EM_386 || parsed.Type != elf.ET_REL {
+				t.Fatal("independent C model did not produce an IA32 object")
+			}
+			contents, err := os.ReadFile(object)
+			if err != nil || len(contents) == 0 {
+				t.Fatal("missing IA32 C model object", err)
+			}
+			t.Logf("independent IA32 C model %s bytes=%d sha256=%x; compile-only, not executed",
+				level, len(contents), sha256.Sum256(contents))
+		})
+	}
+}
+
+// These objects cover every affected LLVM target/API independently of the
+// required direct Linux/386 executable. No cross-object is a runtime receipt.
+func TestX86DefinedStatusIA32ThreeAPIsFiveTargetsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("required LLVM 22 llc missing")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		declarations, source := x86DefinedStatusIA32Fixture(target.arch)
+		goAssemblerOracleOutput(t, target.arch, source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir := x86CPUQueryIRFromDeclaration(t, source, declarations, target.arch, target.triple, api)
+				for _, optimized := range []bool{false, true} {
+					t.Run(fmt.Sprint("O2=", optimized), func(t *testing.T) {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						compileLLVMToObject(t, llc, target.triple, "status.ll", "status.o", input)
+					})
+				}
+			})
+		}
+	}
+}
+
+func x86DefinedStatusIA32CompileAndRun(t *testing.T, llc, ir, level string) {
+	t.Helper()
+	dir := t.TempDir()
+	llPath, object := filepath.Join(dir, "status.ll"), filepath.Join(dir, "status.o")
+	mainPath, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "translated")
+	for name, contents := range map[string]string{llPath: ir, mainPath: x86DefinedStatusIA32CDriver()} {
+		if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	output, err := x87IA32Capture(t, llc,
+		[]string{level, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", llPath, "-o", object}, dir, os.Environ())
+	if err != nil || len(output) != 0 {
+		t.Fatalf("LLVM22 IA32 %s object failed: %v\n%s", level, err, output)
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err = x87IA32Capture(t, compiler,
+		[]string{"-static", "-no-pie", level, "-Wall", "-Wextra", "-Werror=shift-count-overflow",
+			object, mainPath, "-o", executable}, dir, os.Environ())
+	if err != nil || len(output) != 0 {
+		t.Fatalf("static IA32 %s independent C link failed: %v\n%s", level, err, output)
+	}
+	sealed, err := x87IA32StaticExecutable(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "LLVM defined-status observations 896 failures 0\n" {
+		t.Fatalf("LLVM IA32 %s six-flag/LAHF/full canary oracle: %q", level, output)
+	}
+}
diff --git a/amd64_defined_status_linux_amd64_test.go b/amd64_defined_status_linux_amd64_test.go
new file mode 100644
index 000000000..4459675f6
--- /dev/null
+++ b/amd64_defined_status_linux_amd64_test.go
@@ -0,0 +1,51 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os"
+	"testing"
+)
+
+// Unlike emulated-host observation agreement, these required native roots
+// retain the full independent ISA expectations, including PTEST's cleared AF.
+// Missing tools, instructions or actual native backing are failures.
+func TestCrossLinuxRuntimeMatrixX86DefinedStatusOriginalGoNumerical(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86DefinedStatusOriginalGoNumerical(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86DefinedStatusIndependentOriginalCNumerical(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86DefinedStatusIndependentOriginalCNumerical(t)
+}
+
+// The native kernel, original ABI0 executable and both translated ELF32
+// executables are required. No Rosetta/QEMU or cross-object substitutes them.
+func TestCrossLinuxRuntimeMatrixX86DefinedStatusNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86DefinedStatusIA32RequireCapabilities(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("required LLVM 22 llc missing")
+	}
+	t.Run("OriginalGo", func(t *testing.T) {
+		original := x86DefinedStatusIA32BuildOriginal(t)
+		output := x87IA32RunDirect(t, original, nil, os.Environ())
+		if string(output) != "original defined-status observations 896 failures 0\n" {
+			t.Fatalf("original Go IA32 ABI0 six-flag/LAHF/full canary oracle: %q", output)
+		}
+	})
+	declarations, source := x86DefinedStatusIA32Fixture("386")
+	ir := x86CPUQueryIRFromDeclaration(t, source, declarations, "386", "i386-unknown-linux-gnu", "Go")
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			x86DefinedStatusIA32CompileAndRun(t, llc, input, level)
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_defined_status_numerical_test.go b/amd64_defined_status_numerical_test.go
new file mode 100644
index 000000000..5f31cd839
--- /dev/null
+++ b/amd64_defined_status_numerical_test.go
@@ -0,0 +1,541 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86DefinedStatusKernel struct {
+	name, instruction string
+	kind, bits        int
+}
+
+func x86DefinedStatusKernels() []x86DefinedStatusKernel {
+	var kernels []x86DefinedStatusKernel
+	add := func(instruction string, kind, bits int) {
+		kernels = append(kernels, x86DefinedStatusKernel{
+			fmt.Sprintf("status%d", len(kernels)), instruction, kind, bits,
+		})
+	}
+	for _, width := range []struct {
+		suffix string
+		bits   int
+	}{{"W", 16}, {"L", 32}, {"Q", 64}} {
+		add("POPCNT"+width.suffix+" AX,BX", 0, width.bits)
+	}
+	add("PTEST X0,X1", 1, 128)
+	for _, op := range []string{"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM"} {
+		kind := 2
+		if strings.HasPrefix(op, "PCMPI") {
+			kind = 3
+		}
+		add(op+" $8,X0,X1", kind, 128)
+	}
+	for _, op := range []string{"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM"} {
+		kind := 2
+		if strings.HasPrefix(op, "VPCMPI") {
+			kind = 3
+		}
+		add(op+" $8,X0,X1", kind, 128)
+	}
+	for _, stem := range []string{"KTEST", "KORTEST"} {
+		for _, width := range []struct {
+			suffix string
+			bits   int
+		}{{"B", 8}, {"W", 16}, {"D", 32}, {"Q", 64}} {
+			kind := 4
+			if stem == "KORTEST" {
+				kind = 5
+			}
+			add(stem+width.suffix+" K1,K2", kind, width.bits)
+		}
+	}
+	return kernels
+}
+
+func x86DefinedStatusNumericalFixture() (declarations, source string) {
+	var decl, assembly strings.Builder
+	for _, kernel := range x86DefinedStatusKernels() {
+		fmt.Fprintf(&decl, "func %s(out *[8]uint64, left, right, seed uint64)\n", kernel.name)
+		fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-32
+MOVQ out+0(FP),DI
+MOVQ left+8(FP),AX
+MOVQ right+16(FP),BX
+MOVQ seed+24(FP),SI
+MOVQ BX,DX
+MOVQ AX,X0
+MOVQ BX,X1
+`, kernel.name)
+		if kernel.kind >= 4 {
+			assembly.WriteString("KMOVQ AX,K1\nKMOVQ BX,K2\n")
+		}
+		fmt.Fprintf(&assembly, `
+PUSHQ SI
+POPFQ
+%s
+PUSHFQ
+POPQ SI
+MOVQ SI,0(DI)
+LAHF
+MOVB AH,8(DI)
+RET
+`, kernel.instruction)
+	}
+	return decl.String(), assembly.String()
+}
+
+// The baseline original-Go root executes SSE4.2/POPCNT, not AVX512 masks.
+// Its exact source includes the mask objects, but no mask body is called here.
+func x86DefinedStatusOriginalGoNumerical(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, source := x86DefinedStatusNumericalFixture()
+	driver := x86DefinedStatusOriginalGoDriver(false)
+	original := x86DefinedStatusBuildOriginal(t, execution, declarations, source, driver)
+	output := execution.run(t, original)
+	if string(output) != "original defined-status observations 1024 failures 0\n" {
+		t.Fatalf("original Go six-bit status/LAHF/canary model: %s", output)
+	}
+}
+
+func x86DefinedStatusOriginalGoDriver(observe bool) string {
+	kernels := x86DefinedStatusKernels()[:8]
+	var names, kinds, widths strings.Builder
+	for _, kernel := range kernels {
+		fmt.Fprintf(&names, "%s,\n", kernel.name)
+		fmt.Fprintf(&kinds, "%d,", kernel.kind)
+		fmt.Fprintf(&widths, "%d,", kernel.bits)
+	}
+	return strings.NewReplacer(
+		"KERNEL_NAMES", names.String(), "KERNEL_KINDS", kinds.String(),
+		"KERNEL_WIDTHS", widths.String(), "ACTUAL_OBSERVATIONS", fmt.Sprint(observe),
+	).Replace(x86DefinedStatusGoDriver)
+}
+
+func x86DefinedStatusBuildOriginal(t *testing.T, execution x86FloatCompareExecution, declarations, assembly, driver string) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":         "module definedstatus\n\ngo 1.20\n",
+		"main.go":        driver,
+		"decl.go":        "package main\n" + declarations,
+		"status_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=1", "-o", executable, ".")
+	command.Dir = dir
+	goos := runtime.GOOS
+	if strings.Contains(execution.triple, "linux") {
+		goos = "linux"
+	}
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOOS="+goos, "GOARCH=amd64", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	return executable
+}
+
+func TestX86DefinedStatusLLVMNumerical(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, source := x86DefinedStatusNumericalFixture()
+	ir := x86CPUQueryIRFromDeclaration(t, source, declarations, "amd64", execution.triple, "Go")
+	var prototypes, kernels strings.Builder
+	for _, kernel := range x86DefinedStatusKernels() {
+		fmt.Fprintf(&prototypes, "extern void %s(uint64_t *, uint64_t, uint64_t, uint64_t);\n", kernel.name)
+		fmt.Fprintf(&kernels, "{%s,%d,%d,\"%s\"},\n", kernel.name, kernel.kind, kernel.bits, kernel.instruction)
+	}
+	driver := strings.NewReplacer("KERNEL_PROTOTYPES", prototypes.String(),
+		"KERNELS", kernels.String()).Replace(x86DefinedStatusCDriver)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			output := execution.compileAndRunLLVM(t, "defined-status", input, driver, level)
+			want := fmt.Sprintf("LLVM defined-status observations %d failures 0\n", len(x86DefinedStatusKernels())*128)
+			if string(output) != want {
+				t.Fatalf("independent six-bit status/LAHF/canary model: %s", output)
+			}
+		})
+	}
+}
+
+// The C producer executes entire physical opcodes and captures flags in the
+// same inline block, independently of Go's ABI0 wrapper and LLVM lowering.
+func x86DefinedStatusOriginalCSource() string {
+	instructions := []string{
+		"popcntw %%ax,%%bx", "popcntl %%eax,%%ebx", "popcntq %%rax,%%rbx",
+		"ptest %%xmm0,%%xmm1",
+		"pcmpestri $8,%%xmm0,%%xmm1", "pcmpestrm $8,%%xmm0,%%xmm1",
+		"pcmpistri $8,%%xmm0,%%xmm1", "pcmpistrm $8,%%xmm0,%%xmm1",
+	}
+	var functions, registrations strings.Builder
+	for index, kernel := range x86DefinedStatusKernels()[:8] {
+		fmt.Fprintf(&functions, `static void %s(uint64_t *out, uint64_t left, uint64_t right, uint64_t seed) {
+    uint64_t length = right;
+    __asm__ volatile(
+        "movq %%%%rax,%%%%xmm0\n\t"
+        "movq %%%%rbx,%%%%xmm1\n\t"
+        "pushq %%%%rsi\n\t"
+        "popfq\n\t"
+        "%s\n\t"
+        "pushfq\n\t"
+        "popq %%%%rsi\n\t"
+        "movq %%%%rsi,0(%%%%rdi)\n\t"
+        "lahf\n\t"
+        "movb %%%%ah,8(%%%%rdi)\n\t"
+        : "+a"(left), "+b"(right), "+d"(length), "+S"(seed)
+        : "D"(out)
+        : "cc", "memory", "xmm0", "xmm1", "rcx");
+}
+
+`, kernel.name, instructions[index])
+		fmt.Fprintf(&registrations, "{%s,%d,%d,%q},\n", kernel.name, kernel.kind, kernel.bits, kernel.instruction)
+	}
+	source := strings.NewReplacer("KERNEL_PROTOTYPES", functions.String(),
+		"KERNELS", registrations.String()).Replace(x86DefinedStatusCDriver)
+	return strings.ReplaceAll(source, "LLVM", "original-C")
+}
+
+func x86DefinedStatusIndependentOriginalCNumerical(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source := filepath.Join(dir, "original.c")
+	if err := os.WriteFile(source, []byte(x86DefinedStatusOriginalCSource()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := filepath.Join(dir, "original-c"+level)
+			arguments := append([]string(nil), execution.compiler...)
+			arguments = append(arguments, level, source, "-o", executable)
+			x86FloatCompareCaptureCommand(t, exec.Command(arguments[0], arguments[1:]...))
+			output := execution.run(t, executable)
+			if string(output) != "original-C defined-status observations 1024 failures 0\n" {
+				t.Fatalf("actual C opcodes versus independent six-bit status model: %s", output)
+			}
+		})
+	}
+}
+
+// Common emulated-host evidence is exact original-Go/C agreement, not ISA
+// conformance. Every original result is retained; native Linux separately
+// runs the unchanged strict mathematical oracle. No deviation is a skip.
+func TestX86DefinedStatusOriginalGoAndCObservationAgreement(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, assembly := x86DefinedStatusNumericalFixture()
+	original := x86DefinedStatusBuildOriginal(t, execution, declarations, assembly, x86DefinedStatusOriginalGoDriver(true))
+	observations := execution.run(t, original)
+	lines := strings.Split(strings.TrimSuffix(string(observations), "\n"), "\n")
+	summary := regexp.MustCompile(`^observed-status observations 1024 model-deviations ([0-9]+) invalid-observations 0$`)
+	if len(lines) != 1025 || !summary.MatchString(lines[len(lines)-1]) {
+		t.Fatalf("incomplete or invalid actual original-Go observation transcript: %s", observations)
+	}
+	dir := t.TempDir()
+	source := filepath.Join(dir, "original.c")
+	if err := os.WriteFile(source, []byte("#define OBSERVE_ACTUAL 1\n"+x86DefinedStatusOriginalCSource()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := filepath.Join(dir, "original-c"+level)
+			arguments := append([]string(nil), execution.compiler...)
+			arguments = append(arguments, level, source, "-o", executable)
+			x86FloatCompareCaptureCommand(t, exec.Command(arguments[0], arguments[1:]...))
+			actual := execution.run(t, executable)
+			if string(actual) != string(observations) {
+				t.Fatalf("original Go/C full status/LAHF/canary transcript differs: Go=%x C=%x\n%s\n%s",
+					sha256.Sum256(observations), sha256.Sum256(actual), observations, actual)
+			}
+			t.Logf("original observation agreement sha=%x; %s; not native ISA conformance",
+				sha256.Sum256(actual), lines[len(lines)-1])
+		})
+	}
+}
+
+const x86DefinedStatusGoDriver = `package main
+
+import (
+    "fmt"
+    "os"
+)
+
+func mask(bits uint) uint64 {
+    if bits == 64 {
+        return ^uint64(0)
+    }
+    return uint64(1)<<bits - 1
+}
+
+func flags(kind int, bits uint, left, right uint64) uint64 {
+    if kind == 0 {
+        if left&mask(bits) == 0 {
+            return 64
+        }
+        return 0
+    }
+    if kind == 1 {
+        var result uint64
+        if left&right == 0 {
+            result |= 64
+        }
+        if ^right&left == 0 {
+            result |= 1
+        }
+        return result
+    }
+    var a, b [16]byte
+    for i := 0; i < 8; i++ {
+        a[i] = byte(right >> (8*uint(i)))
+        b[i] = byte(left >> (8*uint(i)))
+    }
+    la, lb := 16, 16
+    if kind == 2 {
+        la, lb = int(int32(left)), int(int32(right))
+        if la < 0 {
+            la = -la
+        }
+        if lb < 0 {
+            lb = -lb
+        }
+        if la > 16 {
+            la = 16
+        }
+        if lb > 16 {
+            lb = 16
+        }
+    } else {
+        la, lb = 0, 0
+        for la < 16 && a[la] != 0 {
+            la++
+        }
+        for lb < 16 && b[lb] != 0 {
+            lb++
+        }
+    }
+    var matches uint64
+    for i := 0; i < 16; i++ {
+        if i >= la && i >= lb || i < la && i < lb && a[i] == b[i] {
+            matches |= 1 << uint(i)
+        }
+    }
+    var result uint64
+    if matches != 0 {
+        result |= 1
+    }
+    if lb < 16 {
+        result |= 64
+    }
+    if la < 16 {
+        result |= 128
+    }
+    if matches&1 != 0 {
+        result |= 2048
+    }
+    return result
+}
+
+func main() {
+    const observeActual = ACTUAL_OBSERVATIONS
+    kernels := []func(*[8]uint64,uint64,uint64,uint64){KERNEL_NAMES}
+    kinds := []int{KERNEL_KINDS}
+    widths := []uint{KERNEL_WIDTHS}
+    values := []uint64{0,1,0x55,0xaa,0xff,0xffff,0x80000000,^uint64(0)}
+    const canary = uint64(0xa7a7a7a7a7a7a7a7)
+    observations, failures, invalid := 0, 0, 0
+    for index, kernel := range kernels {
+        kernelFailures := 0
+        for _, left := range values {
+            for _, right := range values {
+                for _, seed := range []uint64{0x8d7,0x12} {
+                    var out [8]uint64
+                    for i := range out {
+                        out[i] = canary
+                    }
+                    kernel(&out,left,right,seed)
+                    want := flags(kinds[index],widths[index],left,right)
+                    invalidObservation := byte(out[1]) != byte(out[0]&0xd5|2) ||
+                        out[1]>>8 != canary>>8
+                    for i := 2; i < len(out); i++ {
+                        invalidObservation = invalidObservation || out[i] != canary
+                    }
+                    if invalidObservation {
+                        invalid++
+                    }
+                    if observeActual {
+                        fmt.Printf("observed-status %d %016x", index, out[0]&0x8d5)
+                        for i := 1; i < len(out); i++ {
+                            fmt.Printf(" %016x", out[i])
+                        }
+                        fmt.Println()
+                    }
+                    bad := out[0]&0x8d5 != want || invalidObservation
+                    if bad {
+                        if !observeActual && failures < 12 {
+                            fmt.Printf("original status kernel=%d left=%x right=%x flags=%x want=%x\n",index,left,right,out[0]&0x8d5,want)
+                        }
+                        failures++
+                        kernelFailures++
+                    }
+                    observations++
+                }
+            }
+        }
+        if !observeActual && kernelFailures != 0 {
+            fmt.Printf("original status kernel=%d failures=%d\n",index,kernelFailures)
+        }
+    }
+    if observeActual {
+        fmt.Printf("observed-status observations %d model-deviations %d invalid-observations %d\n",observations,failures,invalid)
+        if invalid != 0 {
+            os.Exit(1)
+        }
+        return
+    }
+    fmt.Printf("original defined-status observations %d failures %d\n",observations,failures)
+    if failures != 0 {
+        os.Exit(1)
+    }
+}
+`
+
+const x86DefinedStatusCDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#ifndef OBSERVE_ACTUAL
+#define OBSERVE_ACTUAL 0
+#endif
+KERNEL_PROTOTYPES
+
+typedef struct {
+    void (*run)(uint64_t *, uint64_t, uint64_t, uint64_t);
+    unsigned kind, bits;
+    const char *name;
+} Kernel;
+
+static uint64_t mask(unsigned bits) {
+    return bits == 64 ? UINT64_MAX : (UINT64_C(1)<<bits)-1;
+}
+
+static uint64_t flags(unsigned kind, unsigned bits, uint64_t left, uint64_t right) {
+    if (kind == 0) {
+        return (left&mask(bits)) == 0 ? 64 : 0;
+    }
+    if (kind == 1) {
+        return (left&right ? 0 : 64) | (~right&left ? 0 : 1);
+    }
+    if (kind >= 4) {
+        uint64_t m = mask(bits);
+        left &= m;
+        right &= m;
+        if (kind == 4) {
+            return (left&right ? 0 : 64) | (left&~right ? 0 : 1);
+        }
+        uint64_t combined = left|right;
+        return (combined ? 0 : 64) | (combined == m ? 1 : 0);
+    }
+    unsigned char a[16] = {0}, b[16] = {0};
+    for (unsigned i = 0; i < 8; i++) {
+        a[i] = right>>(8*i);
+        b[i] = left>>(8*i);
+    }
+    unsigned la = 16, lb = 16;
+    if (kind == 2) {
+        int64_t na = (int32_t)left, nb = (int32_t)right;
+        if (na < 0) {
+            na = -na;
+        }
+        if (nb < 0) {
+            nb = -nb;
+        }
+        la = na > 16 ? 16 : (unsigned)na;
+        lb = nb > 16 ? 16 : (unsigned)nb;
+    } else {
+        la = lb = 0;
+        while (la < 16 && a[la]) {
+            la++;
+        }
+        while (lb < 16 && b[lb]) {
+            lb++;
+        }
+    }
+    unsigned matches = 0;
+    for (unsigned i = 0; i < 16; i++) {
+        if ((i >= la && i >= lb) || (i < la && i < lb && a[i] == b[i])) {
+            matches |= 1u<<i;
+        }
+    }
+    return (matches ? 1 : 0) | (lb < 16 ? 64 : 0) | (la < 16 ? 128 : 0) |
+        (matches&1 ? 2048 : 0);
+}
+
+int main(void) {
+    Kernel kernels[] = {KERNELS};
+    const uint64_t values[] = {0,1,0x55,0xaa,0xff,0xffff,0x80000000,UINT64_MAX};
+    const uint64_t seeds[] = {0x8d7,0x12};
+    const uint64_t canary = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    unsigned observations = 0, failures = 0, invalid = 0;
+    for (unsigned index = 0; index < sizeof(kernels)/sizeof(kernels[0]); index++) {
+        unsigned kernel_failures = 0;
+        for (unsigned l = 0; l < 8; l++) {
+            for (unsigned r = 0; r < 8; r++) {
+                for (unsigned seed = 0; seed < 2; seed++) {
+                    uint64_t out[8];
+                    for (unsigned i = 0; i < 8; i++) {
+                        out[i] = canary;
+                    }
+                    kernels[index].run(out,values[l],values[r],seeds[seed]);
+                    uint64_t want = flags(kernels[index].kind,kernels[index].bits,values[l],values[r]);
+                    int invalid_observation = (unsigned char)out[1] != ((out[0]&0xd5)|2) ||
+                        (out[1]>>8) != (canary>>8);
+                    for (unsigned i = 2; i < 8; i++) {
+                        invalid_observation |= out[i] != canary;
+                    }
+                    invalid += !!invalid_observation;
+                    if (OBSERVE_ACTUAL) {
+                        printf("observed-status %u %016llx",index,(unsigned long long)(out[0]&0x8d5));
+                        for (unsigned i = 1; i < 8; i++) {
+                            printf(" %016llx",(unsigned long long)out[i]);
+                        }
+                        printf("\n");
+                    }
+                    int bad = (out[0]&0x8d5) != want || invalid_observation;
+                    if (bad) {
+                        if (!OBSERVE_ACTUAL && failures < 12) {
+                            printf("LLVM status kernel=%u left=%llx right=%llx flags=%llx want=%llx\n",
+                                index,(unsigned long long)values[l],(unsigned long long)values[r],
+                                (unsigned long long)(out[0]&0x8d5),(unsigned long long)want);
+                        }
+                        failures++;
+                        kernel_failures++;
+                    }
+                    observations++;
+                }
+            }
+        }
+        if (!OBSERVE_ACTUAL && kernel_failures) {
+            printf("LLVM status family=%s failures=%u\n",kernels[index].name,kernel_failures);
+        }
+    }
+    if (OBSERVE_ACTUAL) {
+        printf("observed-status observations %u model-deviations %u invalid-observations %u\n",observations,failures,invalid);
+        return invalid ? 1 : 0;
+    }
+    printf("LLVM defined-status observations %u failures %u\n",observations,failures);
+    return failures ? 1 : 0;
+}
+`
diff --git a/amd64_defined_zero_af_test.go b/amd64_defined_zero_af_test.go
new file mode 100644
index 000000000..1ee9c5404
--- /dev/null
+++ b/amd64_defined_zero_af_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86DefinedZeroAFCase struct {
+	op, instruction string
+	amd64Only       bool
+}
+
+// These independent ISA witnesses cover every current non-arithmetic writer
+// whose AF result is defined to be zero. Go encoding tables establish syntax;
+// they do not describe the status effects. ENQCMD/S currently use raw source.
+func x86DefinedZeroAFWriters() []x86DefinedZeroAFCase {
+	cases := []x86DefinedZeroAFCase{
+		{"UMWAIT", "UMWAIT BX", false},
+		{"TPAUSE", "TPAUSE BX", false},
+		{"PTEST", "PTEST X0,X1", false},
+		{"VPTEST", "VPTEST X0,X1", false},
+		{"VTESTPD", "VTESTPD X0,X1", false},
+		{"VTESTPS", "VTESTPS X0,X1", false},
+		{"XTEST", "XTEST", false},
+		{"ENQCMD", "BYTE $0xf2\nBYTE $0x0f\nBYTE $0x38\nBYTE $0xf8\nBYTE $0x38", false},
+		{"ENQCMDS", "BYTE $0xf3\nBYTE $0x0f\nBYTE $0x38\nBYTE $0xf8\nBYTE $0x38", false},
+	}
+	for _, stem := range []string{"RDRAND", "RDSEED", "POPCNT"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			op := stem + width
+			operand := "BX"
+			if stem == "POPCNT" {
+				operand = "AX,BX"
+			}
+			cases = append(cases, x86DefinedZeroAFCase{op, op + " " + operand, width == "Q"})
+		}
+	}
+	for _, stem := range []string{"KTEST", "KORTEST"} {
+		for _, width := range []string{"B", "W", "D", "Q"} {
+			op := stem + width
+			cases = append(cases, x86DefinedZeroAFCase{op, op + " K1,K2", false})
+		}
+	}
+	for _, stem := range []string{"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM"} {
+		for _, prefix := range []string{"", "V"} {
+			op := prefix + stem
+			cases = append(cases, x86DefinedZeroAFCase{op, op + " $0,X0,X1", false})
+		}
+	}
+	return cases
+}
+
+func x86DefinedZeroAFSource(arch, name, instruction string) string {
+	word := "Q"
+	if arch == "386" {
+		word = "L"
+	}
+	return fmt.Sprintf("TEXT %s(SB),4,$0-0\nMOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\n"+
+		"PUSH%s $0x8d7\nPOPF%s\n%s\nPUSHF%s\nPOP%s CX\nRET\n",
+		name, word, word, instruction, word, word)
+}
+
+func TestX86DefinedZeroAFWritersClearAfterOperation(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86DefinedZeroAFWriters() {
+			if arch == "386" && row.amd64Only {
+				continue // Go's explicit 64-bit operand row is not a 386 form.
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				source := x86DefinedZeroAFSource(arch, "status", row.instruction)
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				var ir string
+				if strings.Contains(row.instruction, "X0") || strings.Contains(row.instruction, "K1") || strings.HasPrefix(row.op, "ENQCMD") {
+					// The unchanged source does not initialize vectors/masks or
+					// either device address. Keep its original format and Context;
+					// the complete combined status test owns initialized programs.
+					ir = x86UnboundVoidRawScalarFormatObject(t, source, arch, triple)
+				} else {
+					requireX86GoAssemblerResult(t, arch, source, true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err = Translate(file, Options{Goarch: arch, TargetTriple: triple,
+						Sigs: map[string]FuncSig{"status": {Name: "status", Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+				// One false store initializes the slot before the explicit AF=1
+				// seed. A defined-zero writer needs its own subsequent store.
+				if strings.Count(ir, "store i1 false, ptr %flags_af") != 2 {
+					t.Fatalf("%s retained seeded AF instead of its defined-zero status result", row.op)
+				}
+				compileLLVMToObject(t, llc, triple, "af.ll", "af.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86DefinedZeroAFExistingCompareWriterControls(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				source := x86DefinedZeroAFSource(arch, "status", op+" X0,X1")
+				// The original source has no X0/X1 inputs. Keep its actual Go
+				// object and explicit public Context before inspecting emission.
+				ir := x86UnboundVoidScalarFormatObject(t, source, "status", arch, triple)
+				if strings.Count(ir, "store i1 false, ptr %flags_af") != 2 {
+					t.Fatal("original compare emitter lost AF clearing")
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc required")
+				}
+				compileLLVMToObject(t, llc, triple, "compare-status.ll", "compare-status.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86DefinedCompareStatusInitializedFiveTargetsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, value, size := "L", "uint32", 4
+		if target.arch == "amd64" {
+			word, value, size = "Q", "uint64", 8
+		}
+		var source, declarations strings.Builder
+		for _, op := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+			fmt.Fprintf(&declarations, "func %s(seed %s) %s\n", op, value, value)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOVL $0,AX\nMOVL AX,X0\nMOVL AX,X1\nPUSH%s seed+0(FP)\nPOPF%s\n%s X0,X1\nPUSHF%s\nPOP%s AX\nMOV%s AX,ret+%d(FP)\nRET\n",
+				op, 2*size, word, word, op, word, word, word, size)
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || strings.Count(ir, "store i1 false, ptr %flags_af") != 16 {
+					t.Fatal("initialized compare family lost its public status effect", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_direction.go b/amd64_direction.go
new file mode 100644
index 000000000..adecda81a
--- /dev/null
+++ b/amd64_direction.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86DirectionControlSpec struct {
+	backward bool
+}
+
+// These are Go's complete two ynone/Px rows, in both x86 source modes.
+// DF is separate from the six arithmetic status flags and from pointer facts.
+var x86DirectionControlSpecs = map[Op]x86DirectionControlSpec{
+	"CLD": {},
+	"STD": {backward: true},
+}
+
+func x86DirectionControlProperties(op Op, ins Instr, arch string) (x86DirectionControlSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86DirectionControlSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	if len(ins.Args) != 0 {
+		return spec, true, fmt.Errorf("%s takes no operands; %s direction-control ynone grammar: %q", name, arch, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 0 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s outside Go direction-control ynone grammar: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func (c *amd64Ctx) lowerDirectionControl(ins Instr) (bool, error) {
+	spec, known, err := x86DirectionControlProperties(ins.Op, ins, c.goarch)
+	if !known || err != nil {
+		return known, err
+	}
+	if c.directionSlot != "" {
+		fmt.Fprintf(c.b, "  store i1 %t, ptr %s\n", spec.backward, c.directionSlot)
+	}
+	// Every target consumes virtual DF in the exact string helpers. Only a
+	// matching x86 backend also owns the physical direction-flag side effect;
+	// embedding CLD/STD in an ARM/WASM module is not portable emulation.
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, \"~{dirflag}\"()\n", strings.ToLower(string(ins.Op)))
+	}
+	return true, nil
+}
diff --git a/amd64_directive_effects.go b/amd64_directive_effects.go
new file mode 100644
index 000000000..214d1f463
--- /dev/null
+++ b/amd64_directive_effects.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type x86DirectiveEffect uint8
+
+const (
+	x86DirectiveLayout x86DirectiveEffect = iota + 1
+	x86DirectiveMetadata
+)
+
+type x86DirectiveForm struct {
+	effect    x86DirectiveEffect
+	alignment int64
+}
+
+// These are the existing metadata directives and the complete PCALIGN family,
+// not a blanket pseudo-op exemption. They preserve numerical availability but
+// still have native layout/GC effects. This grammar grants no caller, raw-PC,
+// stack, metadata ownership or physical function-alignment permission.
+func x86DirectiveProperties(ins Instr) (x86DirectiveForm, bool, error) {
+	var form x86DirectiveForm
+	base, _, _ := strings.Cut(string(ins.Op), ".")
+	count := 2
+	switch base {
+	case "PCALIGN":
+		form.effect, count = x86DirectiveLayout, 1
+	case "PCALIGNMAX":
+		form.effect = x86DirectiveLayout
+	case "PCDATA", "FUNCDATA":
+		form.effect = x86DirectiveMetadata
+	default:
+		return form, false, nil
+	}
+	fail := func() (x86DirectiveForm, bool, error) {
+		return form, true, fmt.Errorf("invalid x86 %s directive operands: %q", base, ins.Raw)
+	}
+	if string(ins.Op) != base || len(ins.Args) != count {
+		return fail()
+	}
+	constant := func(arg Operand) bool {
+		return arg.Kind == OpImm && arg.ImmRaw == "" && !arg.ImmIsFloat
+	}
+	if !constant(ins.Args[0]) {
+		return fail()
+	}
+	if form.effect == x86DirectiveLayout {
+		// obj.AlignmentPaddingLength: both spellings retain the function's
+		// required alignment, even when PCALIGNMAX emits no padding here.
+		form.alignment = ins.Args[0].Imm
+		if form.alignment < 8 || form.alignment > 2048 || form.alignment&(form.alignment-1) != 0 {
+			return fail()
+		}
+		if count == 2 && (!constant(ins.Args[1]) || ins.Args[1].Imm < 0 || ins.Args[1].Imm >= form.alignment) {
+			return fail()
+		}
+		return form, true, nil
+	}
+	if base == "PCDATA" {
+		// The backend's ypcdata row is Yi32,Yi32 and linkpcln retains an
+		// int32 value. Frontend constant syntax alone is insufficient.
+		if ins.Args[0].Imm < 0 || ins.Args[0].Imm > math.MaxInt32 || !constant(ins.Args[1]) ||
+			ins.Args[1].Imm < math.MinInt32 || ins.Args[1].Imm > math.MaxInt32 {
+			return fail()
+		}
+		return form, true, nil
+	}
+	// cmd/asm.validSymbol alone is not the full contract: x86's yfuncdata
+	// row requires memory and linkpcln requires its offset to be zero. An
+	// accepted frontend offset otherwise panics during object production.
+	arg := ins.Args[1]
+	symbol := strings.TrimSpace(arg.Sym)
+	if ins.Args[0].Imm < 0 || ins.Args[0].Imm > math.MaxInt32 ||
+		arg.Kind != OpSym || !strings.HasSuffix(symbol, "(SB)") {
+		return fail()
+	}
+	name, offset := splitSymPlusOff(strings.TrimSpace(strings.TrimSuffix(symbol, "(SB)")))
+	if offset != 0 || !validPPIdentifier(strings.TrimSuffix(name, "<>")) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func validateX86DirectiveFile(file *File) error {
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if _, known, err := x86DirectiveProperties(ins); known && err != nil {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+		}
+	}
+	return nil
+}
diff --git a/amd64_directive_effects_go127_test.go b/amd64_directive_effects_go127_test.go
new file mode 100644
index 000000000..1a7e1e5c1
--- /dev/null
+++ b/amd64_directive_effects_go127_test.go
@@ -0,0 +1,41 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// PCALIGNMAX was added after the oldest supported SDK. Current Go checks its
+// real encoding; untagged tests still check every consumer on historical Go.
+func TestX86DirectiveCurrentGoCompleteFormats(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86DirectiveValidForms() {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT value(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			})
+		}
+		for _, row := range []string{
+			"PCALIGN", "PCALIGN $16,$1", "PCALIGN AX", "PCALIGN $16.0",
+			"PCDATA $0", "PCDATA AX,$1", "PCDATA $0,$1.0",
+			"FUNCDATA $0", "FUNCDATA AX,metadata(SB)", "FUNCDATA $0,$1",
+			"FUNCDATA $0,metadata(SB)(AX)", "FUNCDATA $0,metadata(SB)(AX*1)",
+		} {
+			t.Run(arch+"/invalid/"+row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT value(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			})
+		}
+	}
+}
+
+func TestX86DirectiveCurrentGoFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []string{"PCALIGN $16", "PCALIGNMAX $16,$7", "PCDATA $0,$-1", "FUNCDATA $0,metadata(SB)"} {
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT value(SB),4,$0-4\nMOVL $1,AX\n%s\nMOVL AX,ret+0(FP)\nRET\n", row)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			})
+		}
+	}
+}
diff --git a/amd64_directive_effects_test.go b/amd64_directive_effects_test.go
new file mode 100644
index 000000000..f474fa92b
--- /dev/null
+++ b/amd64_directive_effects_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectiveResultInitialization(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, directive := range []string{
+			"PCALIGN $16",
+			"PCALIGNMAX $16,$7",
+			"PCDATA $0,$-1",
+			"FUNCDATA $0,metadata(SB)",
+		} {
+			t.Run(arch+"/"+directive, func(t *testing.T) {
+				body := fmt.Sprintf("MOVL $1,AX\n%s\nMOVL AX,ret0+0(FP)\nRET", directive)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+				for name, check := range map[string]func(Func, FuncSig, string) error{
+					"public":  CheckX86ABI0ResultInitialization,
+					"private": checkX86ScalarFPResultInitialization,
+				} {
+					if err := check(file.Funcs[0], sig, arch); err != nil {
+						t.Errorf("%s: valid directive changed numerical availability: %v", name, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86DirectiveValidForms() []string {
+	forms := []string{
+		"PCDATA $0,$-1", "PCDATA $1,$2",
+		"FUNCDATA $0,metadata(SB)", "FUNCDATA $1,metadata<>+0(SB)",
+		"FUNCDATA $2,metadata+(4-4)(SB)",
+	}
+	for _, alignment := range []int{8, 16, 32, 64, 128, 256, 512, 1024, 2048} {
+		forms = append(forms, fmt.Sprintf("PCALIGN $%d", alignment))
+		for _, limit := range []int{0, alignment - 1} {
+			forms = append(forms, fmt.Sprintf("PCALIGNMAX $%d,$%d", alignment, limit))
+		}
+	}
+	return forms
+}
+
+func TestX86DirectiveNumericalStateUnchanged(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86DirectiveValidForms() {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, row)
+				for _, transfer := range []func(Instr, *x86ResultState, []bool, int64, string) bool{
+					x86ResultTransfer, x86ScalarFPResultTransfer,
+				} {
+					for _, shape := range []bool{false, true} {
+						state := x86ResultState{fp: []bool{true, false}, auto: []bool{false, true},
+							pointerFP: map[int64]bool{0: true}, shapeOnly: shape, flags: x86ByteFlagCF}
+						for index := range state.gp {
+							state.gp[index] = uint8(index * 7)
+							state.pointerGP[index] = index%2 == 0
+						}
+						for index := range state.xmm {
+							state.xmm[index] = uint16(index * 31)
+							state.vectorUpper[index] = uint64(index) << 40
+						}
+						state.masks[3] = true
+						before := state.clone()
+						if !transfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+							t.Fatal("directive changed definedness or pointer/flag identity")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86DirectiveMalformedAndUnknownEffects(t *testing.T) {
+	rows := []string{
+		"PCALIGN", "PCALIGN $16,$1", "PCALIGN $0", "PCALIGN $4", "PCALIGN $24", "PCALIGN $4096",
+		"PCALIGN $-16", "PCALIGN $16.0", "PCALIGN $(missing)", "PCALIGN AX", "PCALIGN 16(AX)", "PCALIGN.Z $16",
+		"PCALIGNMAX", "PCALIGNMAX $16", "PCALIGNMAX $16,$0,$1", "PCALIGNMAX $16,$16", "PCALIGNMAX $16,$-1",
+		"PCALIGNMAX $24,$1", "PCALIGNMAX $16,$1.0", "PCALIGNMAX $16,AX", "PCALIGNMAX AX,$1", "PCALIGNMAX $16,$missing",
+		"PCDATA $0", "PCDATA $0,$1,$2", "PCDATA AX,$1", "PCDATA $0,$1.0", "PCDATA $0,$missing", "PCDATA.Z $0,$1",
+		"FUNCDATA $0", "FUNCDATA $0,$1", "FUNCDATA AX,metadata(SB)", "FUNCDATA $0.0,metadata(SB)",
+		"FUNCDATA $0,metadata", "FUNCDATA $0,metadata(FP)", "FUNCDATA $0,metadata(SB)(AX)",
+		"FUNCDATA $0,metadata(SB)(AX*1)", "FUNCDATA $0,metadata+missing(SB)", "FUNCDATA.Z $0,metadata(SB)",
+		"FUNCDATA $0,$metadata(SB)", "FUNCDATA $0,metadata+4(SB)", "FUNCDATA $-1,metadata(SB)",
+		"PCDATA $-1,$0", "PCDATA $0,$2147483648", "PCDATA $0,$-2147483649",
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			ins := x86PureGPUnknownInstruction(t, row)
+			if _, known, err := x86DirectiveProperties(ins); !known || err == nil {
+				t.Fatal("invalid directive accepted", known, err)
+			}
+			for _, target := range x86RawReturnTargets {
+				for _, dead := range []bool{false, true} {
+					body := row + "\nMOVL $1,ret+0(FP)\nRET"
+					if dead {
+						body = "MOVL $1,ret+0(FP)\nRET\n" + row
+					}
+					source := "TEXT ·view(SB),4,$0-4\n" + body + "\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api); err == nil {
+							t.Fatal("malformed source bypassed full source grammar", target.triple, dead, api)
+						}
+					}
+				}
+			}
+		})
+	}
+	for _, row := range []string{"BYTE $0x90", "WORD $0x9090", "LONG $0", "QUAD $0", "NO_LOCAL_POINTERS", "UNDEF", "NOT_A_DIRECTIVE"} {
+		if _, known, _ := x86DirectiveProperties(x86PureGPUnknownInstruction(t, row)); known {
+			t.Fatal("unregistered pseudo/native operation acquired numerical noop", row)
+		}
+	}
+}
+
+func TestX86DirectiveDoesNotInitializeOrAuthorizeEffects(t *testing.T) {
+	for _, row := range []string{"PCALIGN $16", "PCALIGNMAX $16,$7", "PCDATA $0,$-1", "FUNCDATA $0,metadata(SB)"} {
+		for name, body := range map[string]string{
+			"missing result": row + "\nRET",
+			"unknown GP":     row + "\nMOVL AX,ret0+0(FP)\nRET",
+			"unknown vector": row + "\nMOVL X0,ret0+0(FP)\nRET",
+			"unknown flags":  row + "\nJE missing\nMOVL $1,ret0+0(FP)\nmissing:\nRET",
+			"native pointer": "MOVL $1,AX\n" + row + "\nMOVL (AX),BX\nMOVL BX,ret0+0(FP)\nRET",
+			"raw bytes":      row + "\nBYTE $0x90\nMOVL $1,ret0+0(FP)\nRET",
+			"unknown dead":   "MOVL $1,ret0+0(FP)\nRET\n" + row + "\nNOT_A_DIRECTIVE\nRET",
+		} {
+			t.Run(row+"/"+name, func(t *testing.T) {
+				for _, arch := range []string{"amd64", "386"} {
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+					for _, check := range []func(Func, FuncSig, string) error{
+						CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+					} {
+						if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("directive supplied missing numerical/native authority", err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86DirectiveThreeAPIsFiveLLVMTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			body := strings.Join(x86DirectiveValidForms(), "\n")
+			source := "TEXT ·view(SB),4,$0-4\nMOVL $305419896,AX\n" + body + "\nMOVL AX,X0\nMOVL X0,ret+0(FP)\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, api)
+			}
+		})
+	}
+}
+
+func TestX86DirectiveCommonGoFormats(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		// Old x86 backends predate alignment directives. The shared grammar
+		// and LLVM tests above still run there, while these original-Go forms
+		// are genuinely common to every supported compiler.
+		for _, row := range []string{"PCDATA $0,$-1", "FUNCDATA $0,metadata<>+0(SB)"} {
+			goAssemblerOracleOutput(t, arch, "TEXT value(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+		}
+	}
+}
+
+func TestX86DirectiveLayoutIsNotNumericalAuthority(t *testing.T) {
+	for _, row := range []string{"PCALIGN $32", "PCALIGNMAX $32,$0", "PCALIGNMAX $32,$31"} {
+		t.Run(row, func(t *testing.T) {
+			for _, arch := range []string{"amd64", "386"} {
+				source := "TEXT refer(SB),4,$0-0\nMOVL data(SB),AX\nRET\nTEXT data(SB),4,$0-0\n" + row + "\nLONG $0xdeadbeef\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for pass := 0; pass < 2; pass++ {
+					file, err = normalizeX86RawFile(file, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if file.Funcs[1].X86RawAlign != 32 || string(file.Funcs[1].X86RawText) != string([]byte{0xef, 0xbe, 0xad, 0xde}) {
+						t.Fatal("layout-only directive lost exact raw TEXT alignment/bytes")
+					}
+				}
+				framed, err := Parse(ArchAMD64, strings.Replace(source, "TEXT data(SB),4,$0-0", "TEXT data(SB),4,$16-0", 1))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := normalizeX86RawFile(framed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("layout-only directive authorized a native source frame", err)
+				}
+				// A native byte jump cannot infer its displacement across an
+				// alignment boundary from ordinary numerical no-op semantics.
+				crossing, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\nBYTE $0xeb\nBYTE $2\n"+row+"\nBYTE $0x90\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := normalizeX86RawFile(crossing, arch); err == nil {
+					t.Fatal("unknown native byte jump crossed layout boundary")
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_duplicate_move_forms.go b/amd64_duplicate_move_forms.go
new file mode 100644
index 000000000..86f9b7d98
--- /dev/null
+++ b/amd64_duplicate_move_forms.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86DuplicateMoveSpec struct {
+	laneBytes int
+	odd       bool
+	vector    bool
+}
+
+// All three legacy yxm and all three shared _yvmovddup rows. The selector
+// describes numerical bytes; it never reduces the native memory access tuple.
+var x86DuplicateMoveSpecs = map[Op]x86DuplicateMoveSpec{
+	"MOVDDUP": {8, false, false}, "MOVSHDUP": {4, true, false}, "MOVSLDUP": {4, false, false},
+	"VMOVDDUP": {8, false, true}, "VMOVSHDUP": {4, true, true}, "VMOVSLDUP": {4, false, true},
+}
+
+type x86DuplicateMoveForm struct {
+	x86PackedBinaryForm
+	spec   x86DuplicateMoveSpec
+	source Operand
+}
+
+func x86DuplicateMoveProperties(op Op, ins Instr, arch string) (x86DuplicateMoveForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86DuplicateMoveSpecs[Op(base)]
+	form := x86DuplicateMoveForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return form, true, fmt.Errorf("%s %s has an unbound dispatch or unary operand count", arch, op)
+	}
+	local, grammar := ins, x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}
+	local.Op = op
+	if spec.vector {
+		grammar.encoding, grammar.zeroing = x86PackedLogicalVEXOrEVEX, true
+		destination := ins.Args[len(ins.Args)-1]
+		local.Args = []Operand{ins.Args[0], destination, destination}
+		if len(ins.Args) == 3 {
+			local.Args = []Operand{ins.Args[0], destination, ins.Args[1], destination}
+		}
+	}
+	var err error
+	form.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, grammar, spec.vector)
+	form.second, form.destination = -1, len(ins.Args)-1
+	if form.mask >= 0 {
+		form.mask = 1
+	}
+	if form.memory >= 0 && spec.laneBytes == 8 && form.byteWidth == 16 {
+		form.memoryBytes = 8 // Only X-width DDUP reads one scalar qword.
+	}
+	form.source = ins.Args[0]
+	return form, true, err
+}
+
+func (form x86DuplicateMoveForm) sourceByte(output int) int {
+	lane := output / form.spec.laneBytes
+	if form.spec.odd {
+		lane |= 1
+	} else {
+		lane &^= 1
+	}
+	return lane*form.spec.laneBytes + output%form.spec.laneBytes
+}
+
+func (form x86DuplicateMoveForm) sourceMask() uint64 {
+	var mask uint64
+	for output := 0; output < form.byteWidth; output++ {
+		mask |= uint64(1) << uint(form.sourceByte(output))
+	}
+	return mask
+}
+
+func x86ResultDuplicateMoveStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86DuplicateMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	widthMask := x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] || !form.zeroing && state.vectorBytes(destination)&widthMask != widthMask {
+			return false, true
+		}
+	}
+	if form.memory >= 0 {
+		if form.legacy && form.spec.laneBytes == 4 {
+			// Virtual FP/AUTO bytes are not the original aligned m128.
+			if _, static := x86StaticSBReadAddress(form.source, arch); !static &&
+				(!nativeRead || !x86OrdinaryNativeMemoryOperand(form.source, arch)) {
+				return false, true
+			}
+		}
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else {
+		source, _ := amd64VectorRegisterIndex(form.source.Reg, form.byteWidth)
+		required := form.sourceMask()
+		if state.vectorBytes(source)&required != required {
+			return false, true
+		}
+	}
+	// Every potentially selected numerical byte is now known. All reads,
+	// including an aliased source and masked merge, precede any output write.
+	state.writeVector(destination, form.byteWidth, widthMask, form.legacy)
+	return true, true
+}
diff --git a/amd64_dword_product_displacement_test.go b/amd64_dword_product_displacement_test.go
new file mode 100644
index 000000000..08301e7f4
--- /dev/null
+++ b/amd64_dword_product_displacement_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86DwordProductDisplacementOracle struct {
+	row   string
+	width int
+	tuple int
+	units int
+	mask  bool
+	high  bool
+	mem   MemRef
+	code  []byte
+}
+
+// These tuples and offsets are independently prescribed from the actual
+// Go encoder's Full/N16,N32,N64 and BcstN8 rows, not production properties.
+func x86DwordProductDisplacementOracles(t *testing.T) []x86DwordProductDisplacementOracle {
+	t.Helper()
+	var result []x86DwordProductDisplacementOracle
+	addresses := []MemRef{
+		{Base: AX}, {Base: BP}, {Base: SP, Index: CX, Scale: 2},
+		{Base: AX, Index: CX, Scale: 4}, {Base: "R13", Index: "R12", Scale: 8},
+	}
+	for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				for masking := 0; masking < 3; masking++ {
+					for _, units := range []int{-129, -128, -1, 1, 127, 128} {
+						for _, memory := range addresses {
+							tuple, op := width, name
+							if broadcast {
+								tuple, op = 8, name+".BCST"
+							}
+							if masking == 2 {
+								op += ".Z"
+							}
+							memory.Off = int64(units * tuple)
+							bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+							second, destination := bank+"1", bank+"2"
+							high := masking == 0 && !broadcast && width != 64
+							if high {
+								second, destination = bank+"17", bank+"18" // Force actual EVEX.
+							}
+							args := (Operand{Kind: OpMem, Mem: memory}).String() + "," + second
+							if masking == 1 {
+								args += ",K1"
+							} else if masking == 2 {
+								args += ",K7"
+							}
+							row := op + " " + args + "," + destination
+							code := x86OrderingHintGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+row+"\nRET\n")
+							if len(code) < 8 || code[0] != 0x62 || code[2]&0x80 == 0 || code[len(code)-1] != 0xc3 {
+								t.Fatalf("independent original EVEX.W1 object changed: %s %x", row, code)
+							}
+							mod, end := code[5]>>6, 6
+							if code[5]&7 == 4 {
+								end++ // Independently observe SIB, not decoded source.
+							}
+							if units >= -128 && units <= 127 {
+								if mod != 1 || int(int8(code[end])) != units || len(code) != end+2 {
+									t.Fatalf("original compressed disp8/%d changed: %s %x", tuple, row, code)
+								}
+							} else if mod != 2 || len(code) != end+5 {
+								t.Fatalf("original unscaled disp32 boundary changed: %s %x", row, code)
+							}
+							result = append(result, x86DwordProductDisplacementOracle{row, width, tuple, units, masking != 0, high, memory, code[:len(code)-1]})
+						}
+					}
+				}
+			}
+		}
+	}
+	return result
+}
+
+func TestX86DwordProductCompressedDisp8IndependentPhysicalSource(t *testing.T) {
+	fixtures := x86DwordProductDisplacementOracles(t)
+	for _, fixture := range fixtures {
+		for _, mode := range []int{32, 64} {
+			for _, prefix := range []struct {
+				byte    byte
+				segment Reg
+			}{{0, ""}, {0x64, FS}, {0x65, GS}} {
+				t.Run(fmt.Sprintf("%s/mode%d/prefix%x", fixture.row, mode, prefix.byte), func(t *testing.T) {
+					code := append([]byte(nil), fixture.code...)
+					if prefix.byte != 0 {
+						code = append([]byte{prefix.byte}, code...)
+					}
+					ins, length, known, err := decodedX86DwordToQwordMultiplyInstruction(code, mode)
+					if mode == 32 && (fixture.high || fixture.mem.Base == "R13") {
+						if !known || err == nil {
+							t.Fatal("extended physical mode32 bank/address acquired permission", ins, err)
+						}
+						return
+					}
+					want := fixture.mem
+					want.Segment = prefix.segment
+					if !known || err != nil || length != len(code) || !ins.x86Encoded || len(ins.Args) == 0 || ins.Args[0].Kind != OpMem || !reflect.DeepEqual(ins.Args[0].Mem, want) {
+						t.Fatalf("native physical tuple source changed: %x got=%+v length%d known%t err%v want=%+v", code, ins, length, known, err, want)
+					}
+				})
+			}
+			for _, bad := range [][]byte{
+				append([]byte{0x67}, fixture.code...),
+				append([]byte{0x64, 0x67}, fixture.code...),
+				append([]byte{0x65, 0x67}, fixture.code...),
+			} {
+				if _, _, known, err := decodedX86DwordToQwordMultiplyInstruction(bad, mode); !known || err == nil {
+					t.Fatal("address override acquired unbound source permission", fixture.row, mode, err)
+				}
+			}
+		}
+		wrongW := append([]byte(nil), fixture.code...)
+		wrongW[2] &^= 0x80
+		if _, _, known, err := decodedX86DwordToQwordMultiplyInstruction(wrongW, 64); !known || err == nil {
+			t.Fatal("full/broadcast EVEX.W0 accepted", fixture.row, err)
+		}
+	}
+	t.Logf("%d independently assembled full/broadcast,unmasked/merge/zero,disp8/disp32,SIB/bank witnesses ×two modes ×three segment prefixes; address/W rejection retained", len(fixtures))
+}
+
+func x86DwordProductDirectives(code []byte) string {
+	var out strings.Builder
+	for _, value := range code {
+		fmt.Fprintf(&out, "BYTE $%d\n", value)
+	}
+	return out.String()
+}
+
+func TestX86DwordProductTupleOffsetsThreeAPIsFiveTargetObjects(t *testing.T) {
+	fixtures := x86DwordProductDisplacementOracles(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw%t", triple, raw), func(t *testing.T) {
+				arch := "amd64"
+				if strings.HasPrefix(triple, "i") {
+					arch = "386"
+				}
+				var source, declarations strings.Builder
+				declarations.WriteString("package tuples\n")
+				count := 0
+				for _, fixture := range fixtures {
+					// SP/BP decoder identity is proved above, without using it
+					// to confer an unbound native frame in this object fixture.
+					if fixture.mem.Base == SP || fixture.mem.Base == BP || arch == "386" && (fixture.high || fixture.mem.Base == "R13" || !raw && fixture.mask) {
+						continue
+					}
+					row := fixture.row
+					if raw {
+						row = x86DwordProductDirectives(fixture.code)
+					}
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", count, row)
+					fmt.Fprintf(&declarations, "func F%d()\n", count)
+					count++
+				}
+				goAssemblerOracleOutput(t, arch, source.String(), "", true)
+				ir := x86DwordProductOriginalFormatObject(t, source.String(), declarations.String(), arch, triple, 0)
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+				t.Logf("%d original tuple/disp32 forms: three public Context checks plus emitter objects", count)
+			})
+		}
+	}
+}
+
+func TestX86DwordProductTupleRawRejectedPrefixesThreeAPIs(t *testing.T) {
+	for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				op, tuple := name, width
+				if broadcast {
+					op, tuple = name+".BCST", 8
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				row := fmt.Sprintf("%s %d(AX),%s1,K1,%s2", op, tuple, bank, bank)
+				code := x86OrderingHintGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+row+"\nRET\n")
+				wrongW := append([]byte(nil), code[:len(code)-1]...)
+				wrongW[2] &^= 0x80
+				for _, bad := range [][]byte{append([]byte{0x67}, code[:len(code)-1]...), append([]byte{0x64, 0x67}, code[:len(code)-1]...), wrongW} {
+					for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+						t.Run(fmt.Sprintf("%s/%x/%s", row, bad, triple), func(t *testing.T) {
+							arch := "amd64"
+							if strings.HasPrefix(triple, "i") {
+								arch = "386"
+							}
+							source := "TEXT ·F(SB),4,$0-0\n" + x86DwordProductDirectives(bad) + "RET\n"
+							file, err := Parse(ArchAMD64, source)
+							if err != nil {
+								t.Fatal(err)
+							}
+							options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"F": {Name: "F", Ret: Void}}, ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+							if ir, err := Translate(file, options); err == nil || ir != "" {
+								t.Fatal("reserved tuple/address text accepted", err)
+							}
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							module, err := TranslateModuleInContext(ctx, file, options)
+							if !module.IsNil() {
+								defer module.Dispose()
+							}
+							if err == nil || !module.IsNil() {
+								t.Fatal("reserved tuple/address module accepted", err)
+							}
+							pkg := mustGoPackage(t, "tuples", "package tuples\nfunc F()\n")
+							result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: options.ResolveSym})
+							if result != nil && !result.Module.IsNil() {
+								defer result.Module.Dispose()
+							}
+							if err == nil || result != nil {
+								t.Fatal("reserved tuple/address Go module accepted", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86DwordProductVEXDisplacementsRemainUnscaled(t *testing.T) {
+	for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+		for _, bank := range []string{"X", "Y"} {
+			for _, units := range []int{-129, -128, -1, 1, 127, 128} {
+				for _, memory := range []MemRef{{Base: AX}, {Base: BP}, {Base: AX, Index: CX, Scale: 4}, {Base: SP, Index: CX, Scale: 2}, {Base: "R13", Index: "R12", Scale: 8}} {
+					memory.Off = int64(units)
+					row := fmt.Sprintf("%s %s,%s1,%s2", name, (Operand{Kind: OpMem, Mem: memory}).String(), bank, bank)
+					original := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+row+"\nRET\n")
+					if original[0] != 0xc4 && original[0] != 0xc5 {
+						t.Fatal("actual Go no longer emitted VEX", row, original)
+					}
+					for _, mode := range []int{32, 64} {
+						for _, segment := range []Reg{"", FS, GS} {
+							t.Run(fmt.Sprintf("%s/mode%d/segment%s", row, mode, segment), func(t *testing.T) {
+								code := append([]byte(nil), original[:len(original)-1]...)
+								if segment != "" {
+									prefix := byte(0x64)
+									if segment == GS {
+										prefix = 0x65
+									}
+									code = append([]byte{prefix}, code...)
+								}
+								ins, length, known, err := decodedX86DwordToQwordMultiplyInstruction(code, mode)
+								if mode == 32 && memory.Base == "R13" {
+									if !known || err == nil {
+										t.Fatal("VEX extended address acquired mode32 binding")
+									}
+									return
+								}
+								want := memory
+								want.Segment = segment
+								if !known || err != nil || length != len(code) || !ins.x86Encoded || ins.Args[0].Kind != OpMem || !reflect.DeepEqual(ins.Args[0].Mem, want) {
+									t.Fatal("VEX source displacement incorrectly scaled", row, ins, err, want)
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_dword_product_fault_runtime_unix_test.go b/amd64_dword_product_fault_runtime_unix_test.go
new file mode 100644
index 000000000..935188954
--- /dev/null
+++ b/amd64_dword_product_fault_runtime_unix_test.go
@@ -0,0 +1,179 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent fault envelopes include all eight bytes of each potentially
+// active qword, even though only its low dword affects the numerical product.
+// Original SSE instructions are the bytes emitted by Go, not mnemonic aliases
+// assembled by the C compiler. No original AVX512 execution is claimed here.
+func TestCrossLinuxRuntimeMatrixX86DwordProductDeadResultFaultEnvelopes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, prototypes, originals, cases strings.Builder
+	declarations.WriteString("package faultoracle\n")
+	count := 0
+	for _, name := range x86DwordProductOracleNames {
+		legacy := !strings.HasPrefix(name, "V")
+		widths := []int{16}
+		if !legacy {
+			widths = append(widths, 32, 64)
+		}
+		for _, width := range widths {
+			for broadcast := 0; broadcast < 2; broadcast++ {
+				if legacy && broadcast != 0 {
+					continue
+				}
+				for masking := 0; masking < 3; masking++ {
+					if legacy && masking != 0 {
+						continue
+					}
+					tuple := width
+					if broadcast != 0 {
+						tuple = 8
+					}
+					for _, displacement := range []int{0, tuple, -tuple} {
+						if legacy && displacement != 0 {
+							continue
+						}
+						fn := fmt.Sprintf("F%d", count)
+						count++
+						bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+						op, args := name, fmt.Sprintf("%d(BX),%s1", displacement, bank)
+						if broadcast != 0 {
+							op += ".BCST"
+						}
+						if masking == 2 {
+							op += ".Z"
+						}
+						if !legacy {
+							if masking != 0 {
+								args += ",K1"
+							}
+							args += "," + bank + "2"
+						}
+						instruction := op + " " + args
+						if displacement != 0 {
+							actual := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+							instruction = x86DwordProductDirectives(actual[:len(actual)-1])
+						}
+						fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", fn)
+						fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),BX\nMOVQ mask+8(FP),AX\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nKMOVQ AX,K1\n%s\nRET\n", fn, instruction)
+						fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint64_t);\n", fn)
+						original := "NULL"
+						if legacy {
+							original = "original_" + fn
+							actual := x86OrderingHintGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\nPXOR X1,X1\n"+name+" (DI),X1\nRET\n")
+							var bytes []string
+							for _, value := range actual {
+								bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+							}
+							symbol := original
+							if strings.Contains(execution.triple, "apple") {
+								symbol = "_" + symbol
+							}
+							fmt.Fprintf(&originals, "extern void %s(const uint8_t*,uint64_t);\n__asm__(%q);\n", original, ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+						}
+						fmt.Fprintf(&cases, "{%s,%s,%d,%d,%d,%t,%d},\n", fn, original, width, broadcast, masking, legacy, displacement)
+					}
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	strict, deviations := 1, 0
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		strict, deviations = 0, 8
+	}
+	reference := fmt.Sprintf(x86DwordProductFaultC, prototypes.String(), originals.String(), cases.String(), strict)
+	for _, pipeline := range []struct{ name, backend, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+		{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "dword-product-fault", pipeline.ir, reference, pipeline.backend)
+			want := fmt.Sprintf("dword-product fault outcomes %d original SSE outcomes 80 alignment deviations %d failures 0\n", count*10*4, deviations)
+			if string(output) != want {
+				t.Fatalf("native width/alignment, dead result or qword masked fault suppression: %s", output)
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+const x86DwordProductFaultC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <stdbool.h>
+%s
+%s
+typedef struct {void(*translated)(const uint8_t*,uint64_t);void(*original)(const uint8_t*,uint64_t);unsigned width,broadcast,masking,legacy;int displacement;} Kernel;
+static Kernel kernels[]={%s};
+static const uint64_t masks[]={0,1,0x80,UINT64_MAX};
+static unsigned need(Kernel k,uint64_t mask) {
+ if(!k.masking) return k.broadcast?8:k.width;
+ unsigned high=0;
+ for(unsigned i=0;i<k.width/8;i++) if((mask>>i)&1) high=k.broadcast?8:(i+1)*8;
+ return high;
+}
+static int observe(Kernel k,unsigned address,uint64_t mask,int original) {
+ pid_t child=fork();
+ if(child<0) return -1;
+ if(child==0) {
+  struct rlimit no_core={0,0};
+  if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+  _Alignas(64) uint8_t data[256];memset(data,0xa7,sizeof(data));
+  const uint8_t *p=data+64;
+  if(address==1) p++;
+  if(address==2) p=NULL;
+  if(address>=3) {
+   long page=sysconf(_SC_PAGESIZE);if(page<=0) _exit(121);
+   uint8_t *mapping=mmap(NULL,2*(size_t)page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+   if(mapping==MAP_FAILED) _exit(122);
+   memset(mapping,0xa7,(size_t)page);
+   if(mprotect(mapping+page,(size_t)page,PROT_NONE)) _exit(123);
+   unsigned available[]={0,4,7,8,k.width-1,k.width,64};
+   p=mapping+page-available[address-3];
+  }
+  if(original) k.original(p,mask);else k.translated(p,mask);
+  _exit(0);
+ }
+ int status=0;if(waitpid(child,&status,0)!=child) return -2;
+ if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+ if(WIFSIGNALED(status)&&(WTERMSIG(status)==SIGSEGV||WTERMSIG(status)==SIGBUS)) return 1;
+ return -4;
+}
+static int expected(Kernel k,unsigned address,uint64_t mask) {
+ unsigned bytes=need(k,mask),available[]={0,4,7,8,k.width-1,k.width,64};
+ if(k.legacy&&(address==1||(address>=3&&(available[address-3]%%16)!=0))) return 1;
+ return (address==2&&bytes)||(address>=3&&bytes&&(int)bytes+k.displacement>(int)available[address-3]);
+}
+int main(void) {
+ unsigned count=0,native=0,deviations=0,failures=0;const int strict=%d;
+ for(unsigned i=0;i<sizeof(kernels)/sizeof(kernels[0]);i++) for(unsigned a=0;a<10;a++) for(unsigned m=0;m<4;m++) {
+  Kernel k=kernels[i];int want=expected(k,a,masks[m]),got=observe(k,a,masks[m],0);count++;
+  if(k.original) {
+   int actual=observe(k,a,masks[m],1);native++;
+   // This exact readable alignment-only Rosetta deviation is reported,
+   // never substituted into the strict native Linux architectural gate.
+   if(!strict&&a==1&&actual==0&&want==1) {deviations++;want=actual;}
+   if(actual!=want) {fprintf(stderr,"original SSE kernel%%u address%%u got%%d want%%d\n",i,a,actual,want);failures++;}
+  }
+  if(got!=want) {fprintf(stderr,"kernel%%u address%%u mask%%llx got%%d want%%d\n",i,a,(unsigned long long)masks[m],got,want);failures++;}
+ }
+ printf("dword-product fault outcomes %%u original SSE outcomes %%u alignment deviations %%u failures %%u\n",count,native,deviations,failures);
+ return failures?1:0;
+}
+`
diff --git a/amd64_dword_product_forms.go b/amd64_dword_product_forms.go
new file mode 100644
index 000000000..ca91dc11b
--- /dev/null
+++ b/amd64_dword_product_forms.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+type x86DwordProductSpec struct {
+	x86PackedBinarySpec
+	signed       bool
+	nativeOpcode string
+}
+
+// Go names the legacy unsigned instruction PMULULQ, not Intel's PMULUDQ.
+// Only the unsigned legacy ymm table has an MMX/m64 row. Both AVX tables
+// permit qword broadcast and qword writemasking, never rounding or SAE.
+var x86DwordProductSpecs = map[Op]x86DwordProductSpec{
+	"PMULDQ":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, true, "pmuldq"},
+	"PMULULQ":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, false, "pmuludq"},
+	"VPMULDQ":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 8, zeroing: true}, true, ""},
+	"VPMULUDQ": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 8, zeroing: true}, false, ""},
+}
+
+type x86DwordProductForm = x86PackedPhysicalForm
+
+// The operand model grants no initialized bank, native extent or caller role.
+// In particular a GP spelling admitted to Ymm still names the physical MMX
+// bank, and a named high mode32 vector still needs its physical binding.
+func x86DwordProductProperties(op Op, ins Instr, arch string) (x86DwordProductForm, bool, error) {
+	return x86PackedPhysicalProperties(op, ins, arch, x86PackedDwordProduct)
+}
diff --git a/amd64_dword_product_forms_test.go b/amd64_dword_product_forms_test.go
new file mode 100644
index 000000000..efc46c032
--- /dev/null
+++ b/amd64_dword_product_forms_test.go
@@ -0,0 +1,416 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var x86DwordProductOracleNames = []string{"PMULDQ", "PMULULQ", "VPMULDQ", "VPMULUDQ"}
+
+func x86DwordProductOracleRows(t *testing.T, arch string) []string {
+	t.Helper()
+	var rows []string
+	for _, name := range x86DwordProductOracleNames[:2] {
+		for _, source := range []string{"X0", "X7", "(AX)", "16(AX)(CX*2)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, name+" "+source+",X1")
+		}
+		if arch == "amd64" {
+			rows = append(rows, name+" X15,X1")
+		}
+	}
+	if arch == "amd64" {
+		for _, source := range []string{"M0", "M7", "(AX)", "value+0(FP)", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			rows = append(rows, "PMULULQ "+source+",M1")
+		}
+	}
+	official := x86OfficialPackedBinaryWitnesses(t)
+	for _, name := range x86DwordProductOracleNames[2:] {
+		if len(official[name]) == 0 {
+			t.Fatal("independent complete Go rules omitted", name)
+		}
+		for _, row := range official[name] {
+			if arch != "386" || strings.Count(row, ",") != 3 {
+				rows = append(rows, row)
+			}
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{"value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+				rows = append(rows, name+" "+source+","+bank+"1,"+bank+"2",
+					name+".BCST "+source+","+bank+"1,"+bank+"2")
+			}
+			if arch != "386" || bank != "Z" {
+				rows = append(rows, name+" "+bank+"20,"+bank+"21,"+bank+"22")
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86DwordProductCompleteIndependentEncoderRows(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []struct{ name, body string }{
+		{"ymm", "{Zm_r_xm, 1, argList{Ymm, Ymr}},\n{Zm_r_xm, 2, argList{Yxm, Yxr}},"},
+		{"yxm_q4", "{Zm_r, 1, argList{Yxm, Yxr}},"},
+	} {
+		start := strings.Index(string(legacy), "var "+table.name+" = []ytab{")
+		if start < 0 {
+			t.Fatal("actual Go omitted table", table.name)
+		}
+		actual := strings.SplitN(string(legacy)[start:], "\n}", 2)[0]
+		actual = strings.SplitN(actual, "[]ytab{", 2)[1]
+		actualTokens, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+		if err != nil {
+			t.Fatal(err)
+		}
+		wantTokens, err := x86SignedPackedFloatGoOpcodeTokens(table.body)
+		if err != nil || !reflect.DeepEqual(actualTokens, wantTokens) {
+			t.Fatal("actual Go complete legacy zcase/zoffset/classes changed", table.name, actual)
+		}
+	}
+	for _, row := range []string{"{APMULDQ, yxm_q4, Pq4, opBytes{0x28}}", "{APMULULQ, ymm, Py1, opBytes{0xf4, Pe, 0xf4}}"} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("actual Go legacy prefix/opbytes changed", row)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := []string{"Yxm,Yxr,Yxr", "Yym,Yyr,Yyr", "YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex", "YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex", "Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr"}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VPMULDQ" && rule.Opcode != "VPMULUDQ" {
+			continue
+		}
+		mapName, opcode := "0F", "0xF4"
+		if rule.Opcode == "VPMULDQ" {
+			mapName, opcode = "0F38", "0x28"
+		}
+		var opbytes []string
+		for _, width := range []int{128, 256} {
+			opbytes = append(opbytes, fmt.Sprintf("avxEscape | vex%d | vex66 | vex%s | vexW0", width, mapName), opcode)
+		}
+		for _, width := range []int{128, 256, 512} {
+			opbytes = append(opbytes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex%s | evexW1", width, mapName), fmt.Sprintf("evexN%d | evexBcstN8 | evexZeroingEnabled", width/8), opcode)
+		}
+		index := counts[rule.Opcode]
+		zcase := "Zevex_rm_v_r"
+		if index < 2 {
+			zcase = "Zvex_rm_v_r"
+		} else if index%2 == 1 {
+			zcase = "Zevex_rm_v_k_r"
+		}
+		if index >= 8 || rule.RowIndex != index || rule.Ytab != "_yvandnpd" || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != []int{2, 2, 0, 3, 0, 3, 0, 3}[index] ||
+			rule.EncodingOffset != []int{0, 2, 4, 4, 7, 7, 10, 10}[index] ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, opbytes) {
+			t.Fatal("independent whole Go encoder row changed", rule)
+		}
+		counts[rule.Opcode]++
+	}
+	if len(x86DwordProductSpecs) != 4 || counts["VPMULDQ"] != 8 || counts["VPMULUDQ"] != 8 {
+		t.Fatal("entire signed/unsigned family is not closed", counts)
+	}
+	for _, name := range x86DwordProductOracleNames {
+		if _, exists := x86DwordProductSpecs[Op(name)]; !exists {
+			t.Fatal("production omitted independent family member", name)
+		}
+	}
+	// PMULUDQ is a decoder alias, never another accepted Go source mnemonic.
+	arch, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil || strings.Contains(string(arch), "instructions[\"PMULUDQ\"]") {
+		t.Fatal("actual Go alias inventory changed", err)
+	}
+}
+
+func TestX86DwordProductWholeFormatsEffectsAndMemoryShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86DwordProductOracleRows(t, arch)
+		var source strings.Builder
+		for i, row := range rows {
+			fmt.Fprintf(&source, "TEXT f%d(SB),4,$64-64\n%s\nRET\n", i, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, fn := range file.Funcs {
+			ins := fn.Instrs[1]
+			before := fmt.Sprintf("%#v", ins)
+			form, known, err := x86DwordProductProperties(ins.Op, ins, arch)
+			high := arch == "386" && strings.Contains(rows[index], "20")
+			if !known || high && !errors.Is(err, ErrProbeNeedsContext) || !high && err != nil {
+				t.Fatal("Go-accepted source lost syntax/context classification", arch, rows[index], err)
+			}
+			if high {
+				continue
+			}
+			for i, operand := range ins.Args {
+				width, write, valid := x86InstructionMemoryShape(ins, i, arch)
+				if valid != (i == form.memory && !form.mmx) || valid && (write || width != int64(form.memoryBytes)) {
+					t.Fatal("native tuple shape changed", rows[index], width, write, valid)
+				}
+				if operand.Kind == OpFP {
+					width, write, valid = X86FPAccessBytes(ins, i, arch)
+					if !valid || write || width != int64(form.memoryBytes) {
+						t.Fatal("FP observation lost native memory span", rows[index], width, write, valid)
+					}
+				}
+			}
+			if form.legacy {
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.flagsRead != 0 ||
+					!effect.operands[0].read || effect.operands[0].write || !effect.operands[1].read || !effect.operands[1].write ||
+					effect.operands[0].width != int64(form.byteWidth) || effect.operands[1].width != int64(form.byteWidth) || !reflect.DeepEqual(effect.operands[0].operand, form.source) {
+					t.Fatal("legacy typed read/modify/write/flags/bank mismatch", effect, err)
+				}
+			}
+			if before != fmt.Sprintf("%#v", ins) || x86CallerVectorMoveKnown(ins) != !form.mmx {
+				t.Fatal("form modified source or borrowed MMX input permission", ins)
+			}
+		}
+		t.Logf("%s: %d independently Go-accepted complete-family forms; syntax/context/effects distinct", arch, len(rows))
+	}
+}
+
+func TestX86DwordProductThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", triple, raw), func(t *testing.T) {
+				rows := x86DwordProductOracleRows(t, arch)
+				if raw {
+					rows = nil
+					for _, name := range x86DwordProductOracleNames[2:] {
+						for _, row := range x86OfficialPackedBinaryWitnesses(t)[name] {
+							code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+							var directives strings.Builder
+							for _, value := range code[:len(code)-1] {
+								fmt.Fprintf(&directives, "BYTE $%d\n", value)
+							}
+							rows = append(rows, directives.String())
+						}
+					}
+				}
+				var source, declarations strings.Builder
+				declarations.WriteString("package product\n")
+				count := 0
+				for _, row := range rows {
+					if !raw {
+						parsed, err := Parse(ArchAMD64, "TEXT f(SB),4,$64-64\n"+row+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := parsed.Funcs[0].Instrs[1]
+						form, _, err := x86DwordProductProperties(ins.Op, ins, arch)
+						if errors.Is(err, ErrProbeNeedsContext) || form.mmx || form.legacy && form.memory >= 0 && (form.source.Kind == OpFP || form.source.Kind == OpMem && form.source.Mem.Base == SP) {
+							continue
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$64-64\n%s\nRET\n", count, row)
+					fmt.Fprintf(&declarations, "func F%d(value [64]byte)\n", count)
+					count++
+				}
+				goAssemblerOracleOutput(t, arch, source.String(), "", true)
+				ir := x86DwordProductOriginalFormatObject(t, source.String(), declarations.String(), arch, triple, 64)
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+				t.Logf("%d original formats: three public Context checks and emitter objects, not initialized public entries", count)
+			})
+		}
+	}
+}
+
+func x86DwordProductReservedZeroObservation(t *testing.T, name string) {
+	t.Helper()
+	source := "TEXT f(SB),4,$0-0\n" + name + ".Z (AX),X1,X2\nRET\n"
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "reserved.s"), filepath.Join(dir, "reserved.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), err == nil, "amd64"); failure != nil {
+		t.Fatal(failure)
+	}
+	if err != nil {
+		if !bytes.Contains(output, []byte("mask register must be specified for .Z instructions")) {
+			t.Fatal("unknown Go rejection", string(output))
+		}
+		return
+	}
+	// Historical Go1.20 emits reserved EVEX.z=1,aaa=0. It is not a legal
+	// format and remains rejected by every translation API and raw decoder.
+	mapByte, opcode := byte(0xf1), byte(0xf4)
+	if name == "VPMULDQ" {
+		mapByte, opcode = 0xf2, 0x28
+	}
+	code := []byte{0x62, mapByte, 0xf5, 0x88, opcode, 0x10, 0xc3}
+	var listing []string
+	for _, value := range code {
+		listing = append(listing, fmt.Sprintf("%02x", value))
+	}
+	if !bytes.Contains(output, []byte(strings.Join(listing, " "))) {
+		t.Fatal("historical reserved encoding changed", string(output))
+	}
+	if _, _, known, err := decodedX86DwordToQwordMultiplyInstruction(code[:len(code)-1], 64); !known || err == nil {
+		t.Fatal("historical maskless zero encoding gained physical permission", known, err)
+	}
+}
+
+func TestX86DwordProductDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, name := range x86DwordProductOracleNames {
+		opcode := Op(name)
+		row := name + " X0,X1"
+		if strings.HasPrefix(name, "V") {
+			row += ",X2"
+		}
+		for _, sourceOp := range []Op{"", opcode, Op(strings.ToLower(name)), "UNKNOWN", "MOVQ"} {
+			file, err := Parse(ArchAMD64, "TEXT one(SB),$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = sourceOp
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			known, term, err := ctx.lowerDwordToQwordMultiply(opcode, ins)
+			if sourceOp == "UNKNOWN" || sourceOp == "MOVQ" {
+				if !known || term || err == nil || before != out.String() {
+					t.Fatal("conflicting dispatch/source identity emitted IR", opcode, sourceOp, err)
+				}
+			} else if !known || term || err != nil {
+				t.Fatal("compatible helper identity rejected", opcode, sourceOp, err)
+			}
+			if ins.Op != sourceOp {
+				t.Fatal("helper mutated input identity")
+			}
+		}
+	}
+}
+
+func TestX86DwordProductMalformedAndContextThreeAPIsBeforeIR(t *testing.T) {
+	for _, name := range x86DwordProductOracleNames {
+		vector := strings.HasPrefix(name, "V")
+		rows := []string{name + " $1,X1", name + " Y0,Y1", name + " X16,X0", name + " X0,(AX)", name + " (AX)(SP*2),X1"}
+		if vector {
+			rows = []string{name + " $1,X1,X2", name + " X0,Y1,X2", name + " X0,X1,K0,X2", name + " X0,X1,(AX)", name + ".BCST X0,X1,X2", name + ".SAE X0,X1,X2", name + ".RN_SAE X0,X1,X2", name + ".Z.BCST (AX),X1,K1,X2", name + " (AX)(SP*2),X1,X2"}
+			x86DwordProductReservedZeroObservation(t, name)
+			rows = append(rows, name+".Z (AX),X1,X2")
+		}
+		for _, row := range rows {
+			if !strings.Contains(row, ".Z (") {
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				t.Run(row+"/"+triple, func(t *testing.T) {
+					arch := "amd64"
+					if strings.HasPrefix(triple, "i") {
+						arch = "386"
+					}
+					file, err := Parse(ArchAMD64, "TEXT ·F(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						return
+					}
+					options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"F": {Name: "F", Ret: Void}}, ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+					if ir, err := Translate(file, options); err == nil || ir != "" {
+						t.Fatal("malformed text emitted IR", err)
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err == nil || !module.IsNil() {
+						t.Fatal("malformed direct module accepted", err)
+					}
+					pkg := mustGoPackage(t, "product", "package product\nfunc F()\n")
+					result, err := translateGoModuleInContext(ctx, pkg, []byte("TEXT ·F(SB),4,$0-0\n"+row+"\nRET\n"), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: options.ResolveSym})
+					if result != nil && !result.Module.IsNil() {
+						defer result.Module.Dispose()
+					}
+					if err == nil || result != nil {
+						t.Fatal("malformed Go module accepted", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DwordProductMode32PhysicalMarkerAndMMXBank(t *testing.T) {
+	for _, name := range x86DwordProductOracleNames[2:] {
+		for _, row := range x86OfficialPackedBinaryWitnesses(t)[name] {
+			if strings.Count(row, ",") != 3 {
+				continue
+			}
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			ins, length, known, err := decodedX86DwordToQwordMultiplyInstruction(code[:len(code)-1], 32)
+			if !known || err != nil || length != len(code)-1 || !ins.x86Encoded {
+				t.Fatal("actual physical low-bank mode32 decode missing", row, ins, err)
+			}
+			if _, _, err := x86DwordProductProperties(ins.Op, ins, "386"); err != nil {
+				t.Fatal("physical mask inherited named frontend limit", row, err)
+			}
+			data, err := json.Marshal(ins)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var restored Instr
+			if err := json.Unmarshal(data, &restored); err != nil {
+				t.Fatal(err)
+			}
+			restored.Raw = "BYTE genuine-looking decoder text"
+			if _, _, err := x86DwordProductProperties(restored.Op, restored, "386"); err == nil {
+				t.Fatal("JSON/raw text fabricated private physical marker")
+			}
+		}
+	}
+	for _, source := range []string{"AX", "SP", "BP", "R14", "R15"} {
+		row := "PMULULQ " + source + ",M1"
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := out.String()
+		if known, _, err := ctx.lowerDwordToQwordMultiply(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1]); !known || !errors.Is(err, ErrProbeNeedsContext) || out.String() != before {
+			t.Fatal("GP spelling became initialized MMX transport", row, err)
+		}
+	}
+}
diff --git a/amd64_dword_product_runtime_test.go b/amd64_dword_product_runtime_test.go
new file mode 100644
index 000000000..55bda4703
--- /dev/null
+++ b/amd64_dword_product_runtime_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86DwordProductIROptimize(t *testing.T, ir string) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatalf("LLVM22 dword-product IR default<O2>: %v", err)
+	}
+	return module.String()
+}
+
+// This scalar reference is independent of the production lane model, typed
+// specifications and LLVM operations. All products fit widened 64-bit math.
+const x86DwordProductCReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include <xmmintrin.h>
+static uint32_t dword(const uint8_t *p) {
+ return (uint32_t)p[0]|(uint32_t)p[1]<<8|(uint32_t)p[2]<<16|(uint32_t)p[3]<<24;
+}
+static uint64_t product(uint32_t x,uint32_t y,int sign) {
+ if(!sign) return (uint64_t)x*y;
+ int64_t a=x<UINT32_C(0x80000000)?x:(int64_t)x-INT64_C(0x100000000);
+ int64_t b=y<UINT32_C(0x80000000)?y:(int64_t)y-INT64_C(0x100000000);
+ return (uint64_t)(a*b);
+}
+static const uint32_t edges[]={0,1,2,0x7ffffffe,0x7fffffff,0x80000000,0x80000001,0xfffffffe,0xffffffff};
+static const uint64_t masks[]={0,1,0x5555555555555555,UINT64_MAX};
+struct Aligned {_Alignas(64) uint8_t before[64],value[80],after[64];};
+typedef void(*Program)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint64_t,uint32_t);
+static int check(Program program,const char*name,int width,int sign,int source,int alias,int masking,int legacy) {
+ for(int sample=0;sample<97;sample++) for(int state=0;state<2;state++) for(int m=0;m<4;m++) {
+  struct Aligned a,b,old,out;
+  memset(&a,0xa7,sizeof(a));memset(&b,0xb9,sizeof(b));memset(&old,0x6d,sizeof(old));memset(&out,0xc3,sizeof(out));
+  for(int i=0;i<64;i+=4) {
+   uint32_t x=edges[(sample+i/4)%9],y=edges[(sample/9+i*3)%9];
+   if(sample>81) {x=(uint32_t)(sample*7919+i*104729);y=(uint32_t)(sample*65537+i*37);}
+   for(int j=0;j<4;j++) {a.value[i+j]=(uint8_t)(x>>(j*8));b.value[i+j]=(uint8_t)(y>>(j*8));}
+  }
+  struct Aligned beforeA=a,beforeB=b,beforeOld=old;
+  uint64_t seed=state?UINT64_C(0x8d5):0;
+  uint32_t profile=(uint32_t)(0x1f80|((sample%4)<<13)|(sample%64)),saved=_mm_getcsr();
+  _mm_setcsr(profile);
+  program(out.value,a.value,b.value,old.value,masks[m],seed,profile);
+  uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+  uint64_t flags=0;uint32_t csr=0;memcpy(&flags,out.value+64,8);memcpy(&csr,out.value+72,4);
+  if((flags&0x8d5)!=seed||csr!=profile||after!=profile||memcmp(&a,&beforeA,sizeof(a))||memcmp(&b,&beforeB,sizeof(b))||memcmp(&old,&beforeOld,sizeof(old))) return 1;
+  const uint8_t *retained=alias==0?a.value:alias==1?b.value:old.value;
+  for(int i=0;i<64;i++) {
+   int active=!masking||((masks[m]>>(i/8))&1);
+   int broadcast=source==2||source>=5;
+   int displacement=source==3?width:source==4?-width:source==5?8:source==6?-8:0;
+   const uint8_t *sourceBytes=(const uint8_t *)&a+offsetof(struct Aligned,value);
+   uint64_t value=product(dword(sourceBytes+displacement+(broadcast?0:i/8*8)),dword(b.value+i/8*8),sign);
+   uint8_t want=i<width?(active?(uint8_t)(value>>((i%8)*8)):(masking==2?0:retained[i])):(legacy?retained[i]:0);
+   if(out.value[i]!=want) {fprintf(stderr,"%s sample%d mask%llx byte%d got%x want%x\n",name,sample,(unsigned long long)masks[m],i,out.value[i],want);return 2;}
+  }
+  for(int i=0;i<64;i++) if(out.before[i]!=0xc3||out.after[i]!=0xc3) return 3;
+  for(int i=76;i<80;i++) if(out.value[i]!=0xc3) return 4;
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86DwordProductIndependentWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, reference, checks strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	reference.WriteString(x86DwordProductCReference)
+	count := 0
+	for _, name := range x86DwordProductOracleNames {
+		legacy, sign := 0, 0
+		if !strings.HasPrefix(name, "V") {
+			legacy = 1
+		}
+		if strings.Contains(name, "MULDQ") {
+			sign = 1
+		}
+		widths := []int{16}
+		if legacy == 0 {
+			widths = append(widths, 32, 64)
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for source := 0; source < 7; source++ {
+				if legacy != 0 && source >= 2 {
+					continue
+				}
+				for alias := 0; alias < 3; alias++ {
+					if legacy != 0 && alias != 1 {
+						continue
+					}
+					for masking := 0; masking < 3; masking++ {
+						if legacy != 0 && masking != 0 {
+							continue
+						}
+						fn := fmt.Sprintf("P%d", count)
+						count++
+						first := bank + "0"
+						op := name
+						if source != 0 {
+							first = "(CX)"
+						}
+						if source == 2 || source >= 5 {
+							op += ".BCST"
+						}
+						if source == 3 || source == 4 {
+							displacement := width
+							if source == 4 {
+								displacement = -width
+							}
+							first = fmt.Sprintf("%d(CX)", displacement)
+						} else if source >= 5 {
+							displacement := 8
+							if source == 6 {
+								displacement = -8
+							}
+							first = fmt.Sprintf("%d(CX)", displacement)
+						}
+						if masking == 2 {
+							op += ".Z"
+						}
+						args := first + "," + bank + "1"
+						if legacy == 0 {
+							if masking != 0 {
+								args += ",K1"
+							}
+							args += fmt.Sprintf(",%s%d", bank, alias)
+						}
+						instruction := op + " " + args
+						if source >= 3 {
+							actual := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+							instruction = x86DwordProductDirectives(actual[:len(actual)-1])
+						}
+						fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte,mask,flags uint64,csr uint32)\n", fn)
+						fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-52\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nMOVQ mask+32(FP),R9\nVMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nKMOVQ R9,K1\nLDMXCSR csr+48(FP)\nPUSHQ flags+40(FP)\nPOPFQ\n%s\nVMOVUPS Z%d,(AX)\nPUSHFQ\nPOPQ R9\nMOVQ R9,64(AX)\nSTMXCSR 72(AX)\nRET\n", fn, instruction, alias)
+						fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint64_t,uint32_t);\n", fn)
+						fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,%d,%d,%d,%d))return 1;\n", fn, op+" "+args, width, sign, source, alias, masking, legacy)
+					}
+				}
+			}
+		}
+	}
+	reference.WriteString("int main(void){\n" + checks.String() + "return 0;}\n")
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "dword-product-full", ir, reference.String(), level)
+		})
+	}
+	t.Run("IR_O2/backend_O2", func(t *testing.T) {
+		execution.compileAndRunLLVM(t, "dword-product-ir-o2", x86DwordProductIROptimize(t, ir), reference.String(), "-O2")
+	})
+	t.Logf("%d LLVM kernels ×97 initialized samples ×2 six-flag seeds ×4 masks; all64 output bytes, both operand/destination aliases, actual-original-Go raw ±Full/±m64bcst offsets, odd dwords, full MXCSR/input/canaries; explicit IR default<O2> distinct from llc backend O0/O2. Portable LLVM execution does not execute original AVX512.", count)
+}
+
+func TestCrossLinuxRuntimeMatrixX86DwordProductOriginalGoSSE(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\nfunc ReadCSR() uint32\nfunc SetCSR(value uint32)\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\nTEXT ·SetCSR(SB),4,$0-4\nLDMXCSR value+0(FP)\nRET\n")
+	tests.WriteString(`package oracle
+import("testing";"unsafe";"runtime")
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread();defer runtime.UnlockOSThread()
+ // Exercise the runtime's floating-point heap-sampling path between kernels.
+ // LockOSThread alone does not preserve MXCSR across ordinary Go allocations.
+ oldRate:=runtime.MemProfileRate;runtime.MemProfileRate=2
+ defer func(){runtime.MemProfileRate=oldRate}()
+ saved:=ReadCSR();defer SetCSR(saved)
+ edges:=[...]uint32{0,1,2,0x7fffffff,0x80000000,0x80000001,0xfffffffe,0xffffffff}
+ for sample:=0;sample<97;sample++ {for _,seed:=range []uint64{0,0x8d5} {
+ var a,b,out [160]byte
+ align:=func(value *[160]byte)(*[64]byte,int){at:=16+int((-uintptr(unsafe.Pointer(&value[16])))&15);return (*[64]byte)(unsafe.Pointer(&value[at])),at}
+ ap,_:=align(&a);bp,_:=align(&b);op,offset:=align(&out)
+ for i:=range a {a[i]=0xa7;b[i]=0xb9;out[i]=0xc3}
+ for i:=0;i<64;i+=4 {x,y:=edges[(sample+i/4)%8],edges[(sample/8+i*3)%8];for j:=0;j<4;j++ {ap[i+j]=byte(x>>uint(j*8));bp[i+j]=byte(y>>uint(j*8))}}
+ originalA,originalB:=a,b
+ profile:=uint32(0x1f80|((sample%4)<<13)|(sample%64))
+`)
+	count := 0
+	for _, name := range x86DwordProductOracleNames[:2] {
+		for _, source := range []string{"X0", "X1", "(DI)"} {
+			fn := fmt.Sprintf("S%d", count)
+			count++
+			fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed uint64,profile uint32)\n", fn)
+			// Own the complete state window in assembly. A Go allocation (even
+			// on a locked thread) can set MXCSR.PE in runtime heap sampling.
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-52\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\nMOVQ flags+24(FP),CX\nMOVQ csr+32(FP),BX\nMOVOU (DI),X0\nMOVOU (SI),X1\nLDMXCSR profile+48(FP)\nPUSHQ seed+40(FP)\nPOPFQ\n%s %s,X1\nMOVOU X1,(DX)\nPUSHFQ\nPOPQ AX\nMOVQ AX,(CX)\nSTMXCSR (BX)\nRET\n", fn, name, source)
+			alias, signed := 0, 0
+			if source == "X1" {
+				alias = 1
+			}
+			if name == "PMULDQ" {
+				signed = 1
+			}
+			fmt.Fprintf(&tests, `{
+ flags:=struct{before,value,after uint64}{0x11223344,0,0x44332211};csr:=struct{before,value,after uint32}{0x55667788,0,0x88776655}
+ // This deliberate prior-state difference makes loss of per-kernel setup
+ // deterministic, without relying on when the runtime happens to sample.
+ SetCSR(profile^0x20)
+ %s(op,ap,bp,&flags.value,&csr.value,seed,profile)
+ after:=ReadCSR()
+ if flags.value&0x8d5!=seed||csr.value!=profile||after!=profile||flags.before!=0x11223344||flags.after!=0x44332211||csr.before!=0x55667788||csr.after!=0x88776655||a!=originalA||b!=originalB {
+  t.Fatalf("%s sample%%d flags=%%x want=%%x csr=%%x after=%%x want=%%x flagCanaries=%%x/%%x csrCanaries=%%x/%%x inputChanges=%%t/%%t",
+   sample,flags.value,seed,csr.value,after,profile,flags.before,flags.after,csr.before,csr.after,a!=originalA,b!=originalB)
+ }
+ for i,value:=range out {want:=byte(0xc3);if i>=offset&&i<offset+16 {
+  index:=i-offset;at:=index/8*8
+  read:=func(p *[64]byte)uint32{return uint32(p[at])|uint32(p[at+1])<<8|uint32(p[at+2])<<16|uint32(p[at+3])<<24}
+  x,y:=read(ap),read(bp);if %d!=0 {x=y}
+  product:=uint64(x)*uint64(y);if %d!=0 {product=uint64(int64(int32(x))*int64(int32(y)))}
+  want=byte(product>>uint((index%%8)*8))
+ };if value!=want {t.Fatalf("%s sample%%d byte%%d got%%x want%%x",sample,i,value,want)}}
+}
+`, fn, fn, alias, signed, fn)
+		}
+	}
+	tests.WriteString("}}\n}\n")
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), tests.String())
+	t.Logf("%d actual original Go SSE kernels ×97 samples ×2 seeds, complete bytes, signed/unsigned extreme products, ignored odd dwords, flags/MXCSR/canaries. Rosetta is diagnostic; native Linux axis remains required.", count)
+}
diff --git a/amd64_ecosystem_test.go b/amd64_ecosystem_test.go
new file mode 100644
index 000000000..db6b9390b
--- /dev/null
+++ b/amd64_ecosystem_test.go
@@ -0,0 +1,7804 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestTranslateAMD64LegacyDoubleShiftRegisterPair(t *testing.T) {
+	src := `
+TEXT shiftpair(SB),NOSPLIT,$0-0
+	MOVQ $1, SI
+	MOVQ $2, CX
+	SHLQ $13, CX:SI
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "shiftpair")
+}
+
+func TestTranslateX86UD2CompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns UD2 to ynone on both 386 and amd64: its complete
+	// accepted surface is exactly the no-operand form.
+	file, err := Parse(ArchAMD64, "TEXT ud2forms(SB),NOSPLIT,$0-0\n\tUD2\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"ud2forms": {Name: "ud2forms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "unreachable") {
+				t.Fatalf("%s UD2 translation is not terminating:\n%s", target.goarch, ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "ud2-"+target.goarch+".ll", "ud2-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86UD2RejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\tUD2 AX\n")
+	if err != nil {
+		return
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		if _, err := Translate(file, Options{
+			TargetTriple: target.triple,
+			Goarch:       target.goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("%s UD2 with an operand unexpectedly translated", target.goarch)
+		}
+	}
+}
+
+func TestTranslateAMD64ScalarShiftRotateCompleteGoAssemblerForms(t *testing.T) {
+	// ROL/ROR/SAR/SAL/SHL/SHR share yshb/yshl. Each width accepts $1,
+	// unsigned imm8, CL, and CX counts with a same-width GP-or-memory target.
+	var src strings.Builder
+	src.WriteString("TEXT scalarshiftrotateforms(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"ROL", "ROR", "SAR", "SAL", "SHL", "SHR"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			op := stem + width
+			if width == "B" {
+				fmt.Fprintf(&src, "\t%s $1, AH\n", op)
+				fmt.Fprintf(&src, "\t%s $255, R11\n", op)
+				fmt.Fprintf(&src, "\t%s CL, (BX)\n", op)
+				fmt.Fprintf(&src, "\t%s CX, AL\n", op)
+			} else {
+				fmt.Fprintf(&src, "\t%s $1, AX\n", op)
+				fmt.Fprintf(&src, "\t%s $255, R11\n", op)
+				fmt.Fprintf(&src, "\t%s CL, (BX)\n", op)
+				fmt.Fprintf(&src, "\t%s CX, AX\n", op)
+			}
+		}
+	}
+	// Go's special double-shift table adds signed imm8/CL/CX, GP source,
+	// GP-or-memory destination rows to SHL/SHR W/L/Q only.
+	for _, op := range []string{"SHLW", "SHLL", "SHLQ", "SHRW", "SHRL", "SHRQ"} {
+		fmt.Fprintf(&src, "\t%s $-128, AX, BX\n", op)
+		fmt.Fprintf(&src, "\t%s $127, R11, (DI)\n", op)
+		fmt.Fprintf(&src, "\t%s CL, AX, BX\n", op)
+		fmt.Fprintf(&src, "\t%s CX, R11, (DI)\n", op)
+	}
+	src.WriteString("\tRET\n")
+	// The complete original encoder inventory has no input declaration and
+	// includes undefined word double-shift counts. It is a format object,
+	// not an initialized numerical program; keep its public Context result.
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "scalarshiftrotateforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "scalar-shift-rotate-forms.ll", "scalar-shift-rotate-forms.o", ll)
+}
+
+func TestTranslate386ScalarShiftRotateCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT scalarshiftrotateforms386(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"ROL", "ROR", "SAR", "SAL", "SHL", "SHR"} {
+		for _, width := range []string{"B", "W", "L"} {
+			op := stem + width
+			if width == "B" {
+				fmt.Fprintf(&src, "\t%s $1, AH\n", op)
+				fmt.Fprintf(&src, "\t%s $255, DX\n", op)
+				fmt.Fprintf(&src, "\t%s CL, (BX)\n", op)
+				fmt.Fprintf(&src, "\t%s CX, AL\n", op)
+				fmt.Fprintf(&src, "\t%s $1, BP\n", op)
+				fmt.Fprintf(&src, "\t%s $255, SI\n", op)
+				fmt.Fprintf(&src, "\t%s CL, DI\n", op)
+			} else {
+				fmt.Fprintf(&src, "\t%s $1, AX\n", op)
+				fmt.Fprintf(&src, "\t%s $255, SI\n", op)
+				fmt.Fprintf(&src, "\t%s CL, (BX)\n", op)
+				fmt.Fprintf(&src, "\t%s CX, DI\n", op)
+			}
+		}
+	}
+	for _, op := range []string{"SHLW", "SHLL", "SHRW", "SHRL"} {
+		fmt.Fprintf(&src, "\t%s $-128, AX, BX\n", op)
+		fmt.Fprintf(&src, "\t%s $127, SI, (DI)\n", op)
+		fmt.Fprintf(&src, "\t%s CL, AX, BX\n", op)
+		fmt.Fprintf(&src, "\t%s CX, SI, (DI)\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "scalarshiftrotateforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "scalar-shift-rotate-386-forms.ll", "scalar-shift-rotate-386-forms.o", ll)
+}
+
+func TestTranslateX86PortIOCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT portioforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"INB", "INW", "INL", "OUTB", "OUTW", "OUTL"} {
+		fmt.Fprintf(&src, "\t%s\n", op)
+		fmt.Fprintf(&src, "\t%s $7\n", op)
+	}
+	for _, op := range []string{"INSB", "INSW", "INSL", "OUTSB", "OUTSW", "OUTSL"} {
+		fmt.Fprintf(&src, "\t%s\n", op)
+		fmt.Fprintf(&src, "\tCLD; REP; %s\n", op)
+		fmt.Fprintf(&src, "\tSTD; REPN; %s\n", op)
+		fmt.Fprintln(&src, "\tCLD")
+	}
+	src.WriteString("\tRET\n")
+
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"portioforms": {Name: "portioforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "inb`, `asm sideeffect "inw`, `asm sideeffect "inl`,
+				`asm sideeffect "outb`, `asm sideeffect "outw`, `asm sideeffect "outl`,
+				`asm sideeffect "insb`, `asm sideeffect "insw`, `asm sideeffect "insl`,
+				`asm sideeffect "outsb`, `asm sideeffect "outsw`, `asm sideeffect "outsl`,
+				`asm sideeffect "rep; insb`, `asm sideeffect "rep; outsb`,
+				`asm sideeffect "repne; insb`, `asm sideeffect "repne; outsb`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s port-I/O translation missing %q:\n%s", target.goarch, want, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "port-io-"+target.goarch+".ll", "port-io-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PortIORejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		for _, instruction := range []string{
+			"INB AX",
+			"INW $1, AX",
+			"OUTL AX",
+			"OUTB $1, AX",
+			"INSB AX",
+			"OUTSL (SI)",
+			"REP; INL",
+		} {
+			name := target.goarch + "/" + strings.NewReplacer(" ", "_", ";", "_").Replace(instruction)
+			t.Run(name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("%s %q unexpectedly translated", target.goarch, instruction)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86StringInstructionsCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+		widths []string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu", widths: []string{"B", "W", "L"}},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", widths: []string{"B", "W", "L", "Q"}},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT stringforms(SB),NOSPLIT,$0-0\n")
+			for _, stem := range []string{"MOVS", "STOS", "SCAS"} {
+				for _, width := range target.widths {
+					op := stem + width
+					fmt.Fprintf(&src, "\t%s\n", op)
+					fmt.Fprintf(&src, "\tCLD; REP; %s\n", op)
+					fmt.Fprintf(&src, "\tSTD; REPN; %s\n", op)
+					fmt.Fprintln(&src, "\tCLD")
+				}
+			}
+			src.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "stringforms", target.goarch, target.triple)
+			for _, stem := range []string{"movs", "rep_stos", "rep_scas"} {
+				for _, width := range target.widths {
+					want := "@__plan9asm_" + stem + strings.ToLower(width)
+					if !strings.Contains(ll, want) {
+						t.Fatalf("%s string translation missing %q:\n%s", target.goarch, want, ll)
+					}
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "string-forms-"+target.goarch+".ll", "string-forms-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslate386RejectsQwordStringInstructions(t *testing.T) {
+	for _, op := range []string{"MOVSQ", "STOSQ", "SCASQ"} {
+		t.Run(op, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+op+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("386 %s unexpectedly translated", op)
+			}
+		})
+	}
+}
+
+func TestTranslate386RejectsStaleNamedFPResultOffsets(t *testing.T) {
+	src := `TEXT legacyresults(SB),NOSPLIT,$0-56
+	MOVL AX, retax+28(FP)
+	MOVL BX, retbx+32(FP)
+	MOVL CX, retcx+40(FP)
+	MOVL DX, retdx+44(FP)
+	MOVL SI, retsi+48(FP)
+	MOVL DI, retdi+52(FP)
+	MOVL BP, retbp+56(FP)
+	RET
+`
+	requireStaleNamedFPGoDiagnostic(t, src)
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	results := make([]FrameSlot, 0, 7)
+	names := []string{"retax", "retbx", "retcx", "retdx", "retsi", "retdi", "retbp"}
+	for i, name := range names {
+		results = append(results, FrameSlot{Offset: int64(28 + 4*i), Type: I32, Index: i, Field: -1, Name: name})
+	}
+	_, err = Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"legacyresults": {
+				Name:  "legacyresults",
+				Args:  []LLVMType{I32, I32, I32, I32, I32, I32, I32},
+				Ret:   LLVMType("{ i32, i32, i32, i32, i32, i32, i32 }"),
+				Frame: FrameLayout{Results: results},
+			},
+		},
+	})
+	if err == nil {
+		t.Fatal("stale explicit result offsets were silently rewritten by name")
+	}
+}
+
+func TestTranslateX86MOVLScalarResultMemoryForms(t *testing.T) {
+	const source = `TEXT movlresults(SB),NOSPLIT,$0-8
+	MOVL $-1, first+0(FP)
+	MOVL AX, second+4(FP)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			options := Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{"movlresults": {
+					Name: "movlresults",
+					Ret:  LLVMType("{ i32, i32 }"),
+					Frame: FrameLayout{Results: []FrameSlot{
+						{Offset: 0, Type: I32, Index: 0, Field: -1, Name: "first"},
+						{Offset: 4, Type: I32, Index: 1, Field: -1, Name: "second"},
+					}},
+				}},
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], options.Sigs["movlresults"], target.goarch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("the original undeclared AX input became a complete source proof", err)
+			}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("the original fragment acquired an incoming AX argument", err)
+			}
+			// Preserve both original MOVL result forms. A separate complete
+			// producer initializes the GP input instead of borrowing entry zeroes.
+			initialized := strings.Replace(source, "\tMOVL AX, second+4(FP)", "\tMOVL $7,AX\n\tMOVL AX, second+4(FP)", 1)
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+source+strings.Replace(initialized, "movlresults", "initialized", 1))
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run("initialized-"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, "func movlresults() (first,second uint32)", target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized MOVL result forms rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateX86MOVLRejectsMemoryToResultMemory(t *testing.T) {
+	for _, source := range []string{"arg+0(FP)", "(AX)", "global(SB)"} {
+		t.Run(strings.NewReplacer("(", "_", ")", "_", "+", "_").Replace(source), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-4\n\tMOVL "+source+", result+0(FP)\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{"bad": {
+					Name:  "bad",
+					Ret:   I32,
+					Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1, Name: "result"}}},
+				}},
+			}); err == nil {
+				t.Fatalf("MOVL %s, result(FP) unexpectedly translated", source)
+			}
+		})
+	}
+}
+
+func TestTranslateX86ImplicitMultiplyDivideCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's ydivb/ydivl tables give MUL, IMUL, DIV, and IDIV one
+	// GP-or-memory operand. IMUL W/L/Q additionally uses yimul/yimul3 for
+	// the two- and three-operand signed multiply forms.
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+		widths []string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu", widths: []string{"B", "W", "L"}},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", widths: []string{"B", "W", "L", "Q"}},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT muldivforms(SB),NOSPLIT,$0-0\n")
+			for _, width := range target.widths {
+				reg := "BX"
+				for _, stem := range []string{"MUL", "IMUL", "DIV", "IDIV"} {
+					fmt.Fprintf(&src, "\t%s%s %s\n", stem, width, reg)
+					fmt.Fprintf(&src, "\t%s%s (SI)\n", stem, width)
+				}
+				if width != "B" {
+					fmt.Fprintf(&src, "\tIMUL%s $-128, CX\n", width)
+					fmt.Fprintf(&src, "\tIMUL%s $4294967295, DI\n", width)
+					fmt.Fprintf(&src, "\tIMUL%s BX, CX\n", width)
+					fmt.Fprintf(&src, "\tIMUL%s (SI), DI\n", width)
+					fmt.Fprintf(&src, "\tIMUL3%s $-128, BX, CX\n", width)
+					fmt.Fprintf(&src, "\tIMUL3%s $4294967295, (SI), DI\n", width)
+				}
+			}
+			src.WriteString("\tRET\n")
+			// Retain every original Go row and its missing-input Context.
+			// Emitter-only objects are not a Void-entry exemption; initialized
+			// product objects have their independent five-target owner.
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "muldivforms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "mul-div-forms-"+target.goarch+".ll", "mul-div-forms-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ImplicitMultiplyDivideRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	common := []string{
+		"MULB $1",
+		"DIVW AX, BX",
+		"IDIVL AX, BX",
+		"IMULB AX, BX",
+		"IMUL3B $1, AX, BX",
+		"IMULW (AX), (BX)",
+		"IMUL3W AX, BX, CX",
+		"IMUL3L $1, AX, (BX)",
+		"IMULL X0",
+	}
+	for _, target := range []struct {
+		goarch       string
+		triple       string
+		instructions []string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instructions: append(append([]string{}, common...), "MULQ AX", "IMULQ AX", "DIVQ AX", "IDIVQ AX", "IMUL3Q $1, AX, BX")},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instructions: append(append([]string{}, common...), "IMULQ $4294967296, AX", "IMUL3Q $-2147483649, AX, BX")},
+	} {
+		for _, instruction := range target.instructions {
+			name := target.goarch + "/" + strings.NewReplacer(" ", "_", ",", "_", "(", "_", ")", "_").Replace(instruction)
+			t.Run(name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("%s accepted %q outside Go 1.27's multiply/divide tables", target.goarch, instruction)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateAMD64ScalarShiftRotateRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"SHRB $-1, AL",
+		"SHLB $256, AL",
+		"SARW AX, BX",
+		"SALL (AX), BX",
+		"ROLL $1, X1",
+		"RORB $1, X1",
+		"RORQ.Z $1, AX, AX",
+		"SHLB $1, AL, BL",
+		"SARL $1, AX, BX",
+		"SALW $1, AX, BX",
+		"ROLQ $1, AX, BX",
+		"SHLL $128, AX, BX",
+		"SHRL DX, AX, BX",
+		"SHLW $1, (AX), BX",
+		"SHRQ $1, AX, $2",
+		"SHLB $1, AX, BX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidscalarshiftrotate(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidscalarshiftrotate": {Name: "invalidscalarshiftrotate", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's shift/rotate tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386ScalarShiftRotateRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"SHRQ $1, AX",
+		"ROLQ CL, (BX)",
+		"SHRB $1, SP",
+		"SARL $1, R8",
+		"SHLL $1, R8, AX",
+		"SHLQ $1, AX, BX",
+		"SHRQ CL, AX, (BX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidscalarshiftrotate386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidscalarshiftrotate386": {Name: "invalidscalarshiftrotate386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64IncDecCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT incdecforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"INCB", "DECB"} {
+		fmt.Fprintf(&src, "\t%s AL\n", op)
+		fmt.Fprintf(&src, "\t%s AH\n", op)
+		fmt.Fprintf(&src, "\t%s BPB\n", op)
+		fmt.Fprintf(&src, "\t%s R15B\n", op)
+		fmt.Fprintf(&src, "\t%s R11\n", op)
+		fmt.Fprintf(&src, "\t%s (BX)\n", op)
+	}
+	for _, op := range []string{"INCW", "DECW", "INCL", "DECL", "INCQ", "DECQ"} {
+		fmt.Fprintf(&src, "\t%s AX\n", op)
+		fmt.Fprintf(&src, "\t%s R11\n", op)
+		fmt.Fprintf(&src, "\t%s (BX)\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "incdecforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "inc-dec-forms.ll", "inc-dec-forms.o", ll)
+}
+
+func TestTranslate386IncDecCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT incdecforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"INCB", "DECB"} {
+		fmt.Fprintf(&src, "\t%s AL\n", op)
+		fmt.Fprintf(&src, "\t%s AH\n", op)
+		fmt.Fprintf(&src, "\t%s DX\n", op)
+		fmt.Fprintf(&src, "\t%s BP\n", op)
+		fmt.Fprintf(&src, "\t%s SI\n", op)
+		fmt.Fprintf(&src, "\t%s DI\n", op)
+		fmt.Fprintf(&src, "\t%s (BX)\n", op)
+	}
+	for _, op := range []string{"INCW", "DECW", "INCL", "DECL"} {
+		fmt.Fprintf(&src, "\t%s AX\n", op)
+		fmt.Fprintf(&src, "\t%s SI\n", op)
+		fmt.Fprintf(&src, "\t%s (BX)\n", op)
+		fmt.Fprintf(&src, "\t%s SP\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "incdecforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "inc-dec-386-forms.ll", "inc-dec-386-forms.o", ll)
+}
+
+func TestTranslateAMD64IncDecRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"INCB",
+		"INCW AX, BX",
+		"DECL $1",
+		"DECQ X0",
+		"INCQ.Z AX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidincdec(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidincdec": {Name: "invalidincdec", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's INC/DEC tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386IncDecRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"INCB SP",
+		"INCW R8",
+		"DECL R11",
+		"INCQ AX",
+		"DECQ (BX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidincdec386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidincdec386": {Name: "invalidincdec386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedWordMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedwordmulforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PMULLW", "PMULHW", "PMULHUW"} {
+		fmt.Fprintf(&src, "\t%s M0, M1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), M1\n", op)
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1\n", op)
+	}
+	src.WriteString("\tPMULHRSW X0, X1\n\tPMULHRSW (AX), X1\n")
+	for _, op := range []string{"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW"} {
+		fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X21, X22\n", op)
+		fmt.Fprintf(&src, "\t%s X0, X1, K1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s.Z Y0, Y1, K2, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s.Z Z0, Z1, K3, Z2\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedwordmulforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-word-multiply-forms.ll", "packed-word-multiply-forms.o", ll)
+}
+
+func TestTranslate386PackedWordMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedwordmulforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW"} {
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1\n", op)
+	}
+	for _, op := range []string{"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW"} {
+		fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z1, Z2\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedwordmulforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-word-multiply-386-forms.ll", "packed-word-multiply-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedWordMultiplyRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PMULLW Y0, Y1",
+		"PMULHRSW M0, M1",
+		"PMULHW.Z X0, X1",
+		"VPMULLW.BCST (AX), X1, X2",
+		"VPMULHW.SAE X0, X1, X2",
+		"VPMULHUW.Z X0, X1, X2",
+		"VPMULLW X0, Y1, Y2",
+		"VPMULHW X0, X1, K0, X2",
+		"VPMULHUW X0, X1, AX, X2",
+		"VPMULHRSW X0, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedwordmul(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedwordmul": {Name: "invalidpackedwordmul", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed-word multiply tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedWordMultiplyRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PMULLW M0, M1",
+		"PMULHW (AX), M1",
+		"PMULHUW X8, X0",
+		"PMULHRSW X0, X8",
+		"VPMULLW Z8, Z1, Z2",
+		"VPMULHW X0, X1, K1, X2",
+		"VPMULHUW.Z X0, X1, K1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedwordmul386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedwordmul386": {Name: "invalidpackedwordmul386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedWordMultiplyAddCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses ymm for PMADDWL and _yvandnpd for VPMADDWD.
+	src := `TEXT packedwordmaddforms(SB),NOSPLIT,$0-0
+	PMADDWL M0, M1
+	PMADDWL (AX), M2
+	PMADDWL X0, X1
+	PMADDWL (AX), X15
+	VPMADDWD X0, X1, X2
+	VPMADDWD (AX), X1, X2
+	VPMADDWD Y0, Y1, Y2
+	VPMADDWD (AX), Y1, Y2
+	VPMADDWD Z0, Z1, Z2
+	VPMADDWD (AX), Z1, Z2
+	VPMADDWD X20, X21, X22
+	VPMADDWD Y20, Y21, Y22
+	VPMADDWD Z20, Z21, Z22
+	VPMADDWD X20, X21, K1, X22
+	VPMADDWD.Z (AX), X21, K2, X22
+	VPMADDWD Y20, Y21, K3, Y22
+	VPMADDWD.Z (AX), Y21, K4, Y22
+	VPMADDWD Z20, Z21, K5, Z22
+	VPMADDWD.Z (AX), Z21, K6, Z22
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedwordmaddforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-word-multiply-add-forms.ll", "packed-word-multiply-add-forms.o", ll)
+}
+
+func TestTranslate386PackedWordMultiplyAddCompleteGoAssemblerForms(t *testing.T) {
+	src := `TEXT packedwordmaddforms386(SB),NOSPLIT,$0-0
+	PMADDWL X0, X1
+	PMADDWL (AX), X7
+	VPMADDWD X0, X1, X2
+	VPMADDWD (AX), X1, X2
+	VPMADDWD Y0, Y1, Y2
+	VPMADDWD (AX), Y1, Y2
+	VPMADDWD Z0, Z1, Z7
+	VPMADDWD (AX), Z6, Z7
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedwordmaddforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-word-multiply-add-386-forms.ll", "packed-word-multiply-add-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedWordMultiplyAddRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PMADDWL.Z X0, X1",
+		"PMADDWL X0",
+		"PMADDWL Y0, Y1",
+		"PMADDWL X0, M1",
+		"PMADDWL X16, X1",
+		"PMADDWL X0, (AX)",
+		"VPMADDWD X0, X1",
+		"VPMADDWD M0, M1, M2",
+		"VPMADDWD X0, Y1, Y2",
+		"VPMADDWD X0, X1, (AX)",
+		"VPMADDWD.BCST (AX), X1, X2",
+		"VPMADDWD.Z X0, X1, X2",
+		"VPMADDWD X0, X1, K0, X2",
+		"VPMADDWD X0, X1, AX, X2",
+		"VPMADDWD X0, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidpackedwordmadd(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedwordmadd": {Name: "invalidpackedwordmadd", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PMADDWL/VPMADDWD tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedWordMultiplyAddRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PMADDWL M0, M1",
+		"PMADDWL (AX), M1",
+		"PMADDWL X8, X0",
+		"PMADDWL X0, X8",
+		"VPMADDWD Z8, Z1, Z2",
+		"VPMADDWD Z0, Z1, Z8",
+		"VPMADDWD X0, X1, K1, X2",
+		"VPMADDWD.Z X0, X1, K1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidpackedwordmadd386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedwordmadd386": {Name: "invalidpackedwordmadd386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedFloatShuffleCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedfloatshuffleforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"SHUFPS", "SHUFPD"} {
+		fmt.Fprintf(&src, "\t%s $0, X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s $255, (AX), X15\n", op)
+	}
+	for _, op := range []string{"VSHUFPS", "VSHUFPD"} {
+		fmt.Fprintf(&src, "\t%s $0, X0, X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s $255, (AX), X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s $1, Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s $2, (AX), Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s $3, Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s $4, (AX), Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s $5, X20, X21, X22\n", op)
+		fmt.Fprintf(&src, "\t%s $6, X0, X1, K1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s.Z $7, Y0, Y1, K2, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST $8, (AX), Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST.Z $9, (AX), Z1, K3, Z2\n", op)
+	}
+	src.WriteString("\tRET\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86PackedFloatShuffleUnboundFormatObject(t, src.String(), "amd64", triple, 26)
+			for _, pipeline := range []struct{ text, level string }{
+				{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				x86PackedStringCompileObject(t, llc, triple, pipeline.text, pipeline.level)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedFloatShuffleCompleteGoAssemblerForms(t *testing.T) {
+	src := `
+TEXT packedfloatshuffleforms386(SB),NOSPLIT,$0-0
+	SHUFPS $0, X0, X1
+	SHUFPS $255, (AX), X7
+	SHUFPD $0, X0, X1
+	SHUFPD $255, (AX), X7
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86PackedFloatShuffleUnboundFormatObject(t, src, "386", triple, 4)
+			for _, pipeline := range []struct{ text, level string }{
+				{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				x86PackedStringCompileObject(t, llc, triple, pipeline.text, pipeline.level)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedFloatShuffleRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"SHUFPS $-1, X0, X1",
+		"SHUFPD $256, X0, X1",
+		"SHUFPS.Z $0, X0, X1",
+		"VSHUFPS $0, X0, X1",
+		"VSHUFPD.SAE $0, X0, X1, X2",
+		"VSHUFPS.Z $0, X0, X1, X2",
+		"VSHUFPD $0, X0, Y1, Y2",
+		"VSHUFPS $0, X0, X1, K0, X2",
+		"VSHUFPD $0, X0, X1, AX, X2",
+		"VSHUFPS.BCST $0, X0, X1, X2",
+		"VSHUFPD.BCST $0, (AX), X1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedfloatshuffle(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedfloatshuffle": {Name: "invalidpackedfloatshuffle", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed-float shuffle tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedFloatShuffleRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"SHUFPS $0, X8, X0",
+		"SHUFPD $0, X0, X8",
+		"VSHUFPS $0, X0, X1, X2",
+		"VSHUFPD $0, Y0, Y1, Y2",
+		"VSHUFPS.BCST $0, (AX), X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedfloatshuffle386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedfloatshuffle386": {Name: "invalidpackedfloatshuffle386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ImmediatePackedBlendCompleteGoAssemblerForms(t *testing.T) {
+	x86ImmediateBlendOriginalBareFormatObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestTranslate386ImmediatePackedBlendCompleteGoAssemblerForms(t *testing.T) {
+	x86ImmediateBlendOriginalBareFormatObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestTranslateAMD64ImmediatePackedBlendRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PBLENDW $-1, X0, X1",
+		"BLENDPS $256, X0, X1",
+		"BLENDPD.Z $0, X0, X1",
+		"PBLENDW $0, X20, X1",
+		"BLENDPS $0, X0, X20",
+		"VPBLENDW $-1, X0, X1, X2",
+		"VPBLENDD $256, X0, X1, X2",
+		"VBLENDPS $0, X0, X1",
+		"VBLENDPD $0, X0, Y1, Y2",
+		"VPBLENDW $0, X20, X1, X2",
+		"VPBLENDD $0, Y0, Y20, Y2",
+		"VBLENDPS $0, Z0, Z1, Z2",
+		"VBLENDPD.Z $0, X0, X1, X2",
+		"VPBLENDW.BCST $0, (AX), X1, X2",
+		"VPBLENDD $0, X0, X1, K1, X2",
+		"VBLENDPS $0, X0, (AX), X2",
+		"VBLENDPD $0, X0, X1, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidimmediatepackedblend(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidimmediatepackedblend": {Name: "invalidimmediatepackedblend", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's immediate packed-blend tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386ImmediatePackedBlendRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PBLENDW $0, X8, X0",
+		"BLENDPS $0, X0, X8",
+		"BLENDPD.Z $0, X0, X1",
+		"VPBLENDW $0, X0, X1, X2",
+		"VPBLENDD $0, Y0, Y1, Y2",
+		"VBLENDPS $0, X0, X1, X2",
+		"VBLENDPD $0, Y0, Y1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidimmediatepackedblend386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidimmediatepackedblend386": {Name: "invalidimmediatepackedblend386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedUnpackCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedunpackforms(SB),NOSPLIT,$0-0\n")
+	legacyMMX := []string{"PUNPCKLBW", "PUNPCKHBW", "PUNPCKLWL", "PUNPCKHWL", "PUNPCKLLQ", "PUNPCKHLQ"}
+	for _, op := range legacyMMX {
+		fmt.Fprintf(&src, "\t%s M0, M1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), M7\n", op)
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X15\n", op)
+	}
+	for _, op := range []string{"PUNPCKLQDQ", "PUNPCKHQDQ"} {
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X15\n", op)
+	}
+	vectorOps := []string{
+		"VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLWD", "VPUNPCKHWD",
+		"VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+	}
+	for _, op := range vectorOps {
+		fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1, X15\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y15\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z1, Z31\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X21, X22\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, Y21, K1, Y22\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), Z21, K2, Z22\n", op)
+		if strings.Contains(op, "DQ") {
+			fmt.Fprintf(&src, "\t%s.BCST (AX), X21, X22\n", op)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), Y21, Y22\n", op)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), Z21, Z22\n", op)
+			fmt.Fprintf(&src, "\t%s.BCST.Z (AX), Z21, K3, Z22\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedunpackforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-unpack-forms.ll", "packed-unpack-forms.o", ll)
+}
+
+func TestTranslate386PackedUnpackCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedunpackforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{
+		"PUNPCKLBW", "PUNPCKHBW", "PUNPCKLWL", "PUNPCKHWL",
+		"PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PUNPCKHQDQ",
+	} {
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X7\n", op)
+	}
+	for _, op := range []string{
+		"VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLWD", "VPUNPCKHWD",
+		"VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+	} {
+		fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y2\n", op)
+		// Named high-register mode32 acceptance is retained by the separate
+		// actual-Go/physical-Context oracle, not fabricated LLVM registers.
+		fmt.Fprintf(&src, "\t%s X5, X6, X7\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		if strings.Contains(op, "DQ") {
+			fmt.Fprintf(&src, "\t%s.BCST (AX), Y1, Y2\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedunpackforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-unpack-386-forms.ll", "packed-unpack-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedUnpackRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PUNPCKLBW.Z X0, X1",
+		"PUNPCKLWL X20, X1",
+		"PUNPCKHWL X0, X20",
+		"PUNPCKLLQ M0, X1",
+		"PUNPCKHLQ X0, M1",
+		"PUNPCKLQDQ M0, M1",
+		"PUNPCKHQDQ Y0, X1",
+		"VPUNPCKLBW X0, X1",
+		"VPUNPCKHWD X0, Y1, Y2",
+		"VPUNPCKLDQ X0, (AX), X2",
+		"VPUNPCKHQDQ X0, X1, (AX)",
+		"VPUNPCKLBW X32, X1, X2",
+		"VPUNPCKHWD Z0, Z1, K0, Z2",
+		"VPUNPCKLWD.Z Z0, Z1, Z2",
+		"VPUNPCKHBW.BCST (AX), X1, X2",
+		"VPUNPCKLWD.BCST (AX), Y1, Y2",
+		"VPUNPCKLDQ.BCST X0, X1, X2",
+		"VPUNPCKHQDQ.BCST (AX), X1, Y2",
+		"VPUNPCKHDQ.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedunpack(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedunpack": {Name: "invalidpackedunpack", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed-unpack tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedUnpackRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PUNPCKLBW M0, M1",
+		"PUNPCKHWL (AX), M1",
+		"PUNPCKLQDQ M0, M1",
+		"PUNPCKHBW X8, X0",
+		"PUNPCKHLQ X0, X8",
+		"VPUNPCKLWD Z8, Z1, Z2",
+		"VPUNPCKHWD Z0, Z8, Z2",
+		"VPUNPCKLDQ Z0, Z1, Z8",
+		"VPUNPCKLBW X0, X1, K1, X2",
+		"VPUNPCKLDQ.Z Z0, Z1, K1, Z2",
+		"VPUNPCKHQDQ.BCST.Z (AX), Y1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedunpack386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedunpack386": {Name: "invalidpackedunpack386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64QwordPermuteCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT qwordpermuteforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VPERMQ", "VPERMPD"} {
+		fmt.Fprintf(&src, "\t%s $-128, Y0, Y1\n", op)
+		fmt.Fprintf(&src, "\t%s $255, (AX), Y15\n", op)
+		fmt.Fprintf(&src, "\t%s $0, Y20, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s $1, Z20, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s $2, Y20, K1, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z $3, Z20, K2, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST $4, (AX), Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST.Z $5, (AX), K3, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, Y21, Y22\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y21, K1, Y22\n", op)
+		fmt.Fprintf(&src, "\t%s.Z Z20, Z21, K2, Z22\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST (AX), Y21, Y22\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST.Z (AX), Z21, K3, Z22\n", op)
+	}
+	src.WriteString("\tRET\n")
+	// All original 32 rows remain Go/public-Context inputs. These private
+	// format objects are distinct from the initialized public family matrix.
+	ll := x86ElementPermuteUnboundFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu", 32, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	x86ElementPermuteCompileFormatObjects(t, llc, "x86_64-unknown-linux-gnu", ll)
+}
+
+func TestTranslate386QwordPermuteCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT qwordpermuteforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VPERMQ", "VPERMPD"} {
+		fmt.Fprintf(&src, "\t%s $-128, Y0, Y1\n", op)
+		fmt.Fprintf(&src, "\t%s $255, (AX), Y7\n", op)
+		fmt.Fprintf(&src, "\t%s $0, Y20, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s $1, Z0, Z1\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST $2, (AX), Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST $3, (AX), Z7\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y1, Y2\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, Z1, Z2\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, Y21, Y22\n", op)
+		fmt.Fprintf(&src, "\t%s.BCST (AX), Z1, Z7\n", op)
+	}
+	src.WriteString("\tRET\n")
+	// Go accepts six extended-Y rows, but they do not authorize physical
+	// mode32 registers. Preserve all 22 original Go/Context rows before
+	// compiling the other 16 physical rows through the private emitter.
+	ll := x86ElementPermuteUnboundFormatObject(t, src.String(), "386", "i386-unknown-linux-gnu", 16, 6)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	x86ElementPermuteCompileFormatObjects(t, llc, "i386-unknown-linux-gnu", ll)
+}
+
+func TestTranslateAMD64QwordPermuteRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMQ $-129, Y0, Y1",
+		"VPERMPD $256, Y0, Y1",
+		"VPERMQ $-1, Y20, Y21",
+		"VPERMPD $-1, Z0, Z1",
+		"VPERMQ.BCST $-1, (AX), Y1",
+		"VPERMQ $0, X0, X1",
+		"VPERMPD X0, X1, X2",
+		"VPERMQ $0, Y0, Z1",
+		"VPERMPD Y0, Z1, Z2",
+		"VPERMQ Y0, (AX), Y2",
+		"VPERMPD Y0, Y1, (AX)",
+		"VPERMQ $0, Y0, K0, Y1",
+		"VPERMPD Z0, Z1, K0, Z2",
+		"VPERMQ.Z $0, Y0, Y1",
+		"VPERMPD.Z Y0, Y1, Y2",
+		"VPERMQ.BCST $0, Y0, Y1",
+		"VPERMPD.BCST Y0, Y1, Y2",
+		"VPERMQ.SAE $0, Y0, Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidqwordpermute(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidqwordpermute": {Name: "invalidqwordpermute", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's _yvpermq table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386QwordPermuteRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMQ $-1, Y20, Y21",
+		"VPERMPD $0, Z8, Z1",
+		"VPERMQ $0, Z0, Z8",
+		"VPERMPD Z8, Z1, Z2",
+		"VPERMQ Z0, Z8, Z2",
+		"VPERMPD Z0, Z1, Z8",
+		"VPERMQ $0, Y0, K1, Y1",
+		"VPERMPD Z0, Z1, K1, Z2",
+		"VPERMQ.BCST.Z (AX), Z1, K1, Z2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidqwordpermute386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidqwordpermute386": {Name: "invalidqwordpermute386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedFloatMoveCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns VMOVAPD/APS/UPD/UPS the same 16-row _yvmovapd
+	// table: bidirectional X/Y/Z register-or-memory moves, EVEX high
+	// registers, and K1-K7 merge/zero masking for every width and direction.
+	var src strings.Builder
+	src.WriteString("TEXT packedfloatmoveforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS"} {
+		for _, width := range []string{"X", "Y"} {
+			fmt.Fprintf(&src, "\t%s %s0, %s1\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s1, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s2\n", op, width)
+			fmt.Fprintf(&src, "\t%s %s20, %s21\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s20, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s21\n", op, width)
+		}
+		fmt.Fprintf(&src, "\t%s Z0, Z1\n", op)
+		fmt.Fprintf(&src, "\t%s Z1, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z2\n", op)
+		fmt.Fprintf(&src, "\t%s Z20, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s Z20, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z21\n", op)
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s %s1, K1, %s2\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s1, K2, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), K3, %s2\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z %s1, K4, %s2\n", op, width, width)
+			// Go accepts .Z memory stores, but their native EVEX.z encoding
+			// raises #UD. Independent-entry and fault oracles cover that effect.
+			fmt.Fprintf(&src, "\t%s.Z %s1, K5, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z (AX), K6, %s2\n", op, width)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidVectorMoveFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-float-move-forms.ll", "packed-float-move-forms.o", ll)
+}
+
+func TestTranslate386PackedFloatMoveCompleteGoAssemblerForms(t *testing.T) {
+	// Go accepts high X/Y spellings and all three-operand mask rows. Observe
+	// their Context separately; actual mode32 objects use the physical low bank.
+	source := x86EVEXPackedFloat386OriginalSource()
+	physical := x86PhysicalMode32ObjectSource(t, source, "386")
+	ll := x86UnboundVoidVectorMoveFormatObject(t, physical, "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-float-move-386-forms.ll", "packed-float-move-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedFloatMoveRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVAPD X1, Y2",
+		"VMOVAPS Y1, Z2",
+		"VMOVUPD Z1, X2",
+		"VMOVUPS (AX), (BX)",
+		"VMOVAPD K1, X2",
+		"VMOVAPS X1, K0, X2",
+		"VMOVUPD (AX), K0, X2",
+		"VMOVUPS.Z X1, X2",
+		"VMOVAPD.BCST (AX), X2",
+		"VMOVAPS.SAE X1, X2",
+		"VMOVUPD.RN_SAE X1, X2",
+		"VMOVUPS X1, K1, Y2",
+		"VMOVAPD X1, X2, K1",
+		"VMOVAPS X1",
+		"VMOVUPD X1, K1, X2, X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedfloatmove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedfloatmove": {Name: "invalidpackedfloatmove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's _yvmovapd table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedFloatMoveRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVAPD Z8, Z1",
+		"VMOVAPS Z0, Z8",
+		"VMOVUPD Z8, (AX)",
+		"VMOVUPS (AX), Z8",
+		"VMOVAPD Z0, K1, Z8",
+		"VMOVAPS.Z Z8, K1, (AX)",
+		"VMOVUPD.Z (AX), K1, Z8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedfloatmove386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedfloatmove386": {Name: "invalidpackedfloatmove386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateX86EVEXPackedIntegerMoveCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns this complete family the same 12-row _yvmovdqa32
+	// table. Each opcode accepts bidirectional X/Y/Z register-or-memory
+	// moves plus K1-K7 merge/zero masking for every width and direction.
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			source := x86EVEXPackedIntegerMoveOriginalSource(target.goarch)
+			physical := x86PhysicalMode32ObjectSource(t, source, target.goarch)
+			ll := x86UnboundVoidVectorMoveFormatObject(t, physical, target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "evex-packed-integer-move-"+target.goarch+".ll", "evex-packed-integer-move-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86EVEXPackedIntegerMoveRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVDQA32 X1, Y2",
+		"VMOVDQA64 Y1, Z2",
+		"VMOVDQU8 (AX), (BX)",
+		"VMOVDQU16 X1, K0, X2",
+		"VMOVDQU32.Z X1, X2",
+		"VMOVDQU64.BCST (AX), Z2",
+		"VMOVDQU8.SAE X1, X2",
+		"VMOVDQU16 X1, K1, Y2",
+		"VMOVDQU32 X1",
+		"VMOVDQA64 X1, K1, X2, X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's _yvmovdqa32 table", instruction)
+			}
+		})
+	}
+	for _, instruction := range []string{
+		"VMOVDQA32 Z8, Z0",
+		"VMOVDQA64 Z0, Z8",
+		"VMOVDQU8 Z8, (AX)",
+		"VMOVDQU16 (AX), Z8",
+		"VMOVDQU32 Z0, K1, Z8",
+		"VMOVDQU64.Z (AX), K1, Z8",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT bad386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			return
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs:         map[string]FuncSig{"bad386": {Name: "bad386", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("386 Translate accepted architecture-restricted %q", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64PackedSignExtendMoveCompleteGoAssemblerForms(t *testing.T) {
+	// The complete signed widening family consists of six legacy yxm_q4
+	// instructions plus six V instructions. BW/WD/DQ use _yvcvtdq2pd
+	// (X source for X/Y destinations and Y source for Z); BD/BQ/WQ use
+	// _yvbroadcastss (X source for every destination width).
+	var src strings.Builder
+	src.WriteString("TEXT packedsignextendmoveforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PMOVSXBW", "PMOVSXBD", "PMOVSXBQ", "PMOVSXWD", "PMOVSXWQ", "PMOVSXDQ"} {
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X2\n", op)
+		fmt.Fprintf(&src, "\t%s X15, X14\n", op)
+	}
+	for _, op := range []string{"VPMOVSXBW", "VPMOVSXWD", "VPMOVSXDQ"} {
+		fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X2\n", op)
+		fmt.Fprintf(&src, "\t%s X0, Y1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y2\n", op)
+		fmt.Fprintf(&src, "\t%s Y0, Z1\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z2\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, K1, X21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K2, X21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, K3, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K4, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, K5, Z21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K6, Z21\n", op)
+	}
+	for _, op := range []string{"VPMOVSXBD", "VPMOVSXBQ", "VPMOVSXWQ"} {
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s X0, %s1\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s2\n", op, width)
+			fmt.Fprintf(&src, "\t%s X20, %s21\n", op, width)
+			fmt.Fprintf(&src, "\t%s X20, K1, %s21\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z (AX), K2, %s21\n", op, width)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86SignExtendOriginalFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu", 108, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-sign-extend-move-forms.ll", "packed-sign-extend-move-forms.o", ll)
+}
+
+func TestTranslate386PackedSignExtendMoveCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedsignextendmoveforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PMOVSXBW", "PMOVSXBD", "PMOVSXBQ", "PMOVSXWD", "PMOVSXWQ", "PMOVSXDQ"} {
+		fmt.Fprintf(&src, "\t%s X0, X7\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X7\n", op)
+	}
+	for _, op := range []string{"VPMOVSXBW", "VPMOVSXWD", "VPMOVSXDQ"} {
+		fmt.Fprintf(&src, "\t%s X20, X21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s Y20, Z7\n", op)
+		fmt.Fprintf(&src, "\t%s X20, K1, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K2, Z7\n", op)
+	}
+	for _, op := range []string{"VPMOVSXBD", "VPMOVSXBQ", "VPMOVSXWQ"} {
+		fmt.Fprintf(&src, "\t%s X20, X21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s X20, Z7\n", op)
+		fmt.Fprintf(&src, "\t%s X20, K1, Y21\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K2, Z7\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86SignExtendOriginalFormatObject(t, src.String(), "386", "i386-unknown-linux-gnu", 18, 24)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-sign-extend-move-386-forms.ll", "packed-sign-extend-move-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedSignExtendMoveRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PMOVSXBW X16, X1",
+		"PMOVSXBD X1, X16",
+		"PMOVSXBQ Y1, X2",
+		"PMOVSXWD X1, Y2",
+		"PMOVSXWQ X1, (AX)",
+		"PMOVSXDQ.Z X1, X2",
+		"PMOVSXBW X1, K1, X2",
+		"VPMOVSXBW Y1, Y2",
+		"VPMOVSXWD X1, Z2",
+		"VPMOVSXDQ Z1, Z2",
+		"VPMOVSXBD Y1, Z2",
+		"VPMOVSXBQ Y1, Y2",
+		"VPMOVSXWQ Z1, X2",
+		"VPMOVSXBW X1, (AX)",
+		"VPMOVSXBD (AX), (BX)",
+		"VPMOVSXBQ X1, K0, Y2",
+		"VPMOVSXWD.Z X1, Y2",
+		"VPMOVSXDQ.BCST (AX), Y2",
+		"VPMOVSXWQ.SAE X1, Z2",
+		"VPMOVSXBW.RN_SAE X1, Y2",
+		"VPMOVSXBD X1",
+		"VPMOVSXBQ X1, K1, Y2, Y3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedsignextendmove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedsignextendmove": {Name: "invalidpackedsignextendmove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's signed-extension move tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedSignExtendMoveRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PMOVSXBW X8, X1",
+		"PMOVSXBD X1, X8",
+		"PMOVSXBQ X15, X7",
+		"VPMOVSXBW Y1, Z8",
+		"VPMOVSXWD (AX), Z8",
+		"VPMOVSXDQ Y20, K1, Z8",
+		"VPMOVSXBD X20, Z8",
+		"VPMOVSXBQ.Z (AX), K1, Z8",
+		"VPMOVSXWQ X20, K1, Z8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedsignextendmove386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedsignextendmove386": {Name: "invalidpackedsignextendmove386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64MOVDFromXRegister(t *testing.T) {
+	src := `
+TEXT movdfromx(SB),NOSPLIT,$0-0
+	PXOR X12, X12
+	MOVD X12, DX
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "movdfromx")
+}
+
+func TestTranslateAMD64MOVDAliasCompleteGo127Forms(t *testing.T) {
+	// cmd/asm aliases MOVD to AMOVQ on x86. These cover every ymovq operand
+	// class that the alias can select in 64-bit mode: GP/immediate/memory,
+	// MMX/memory/GP/XMM, and XMM/memory/GP/XMM.
+	src := `
+TEXT movdaliasforms(SB),NOSPLIT,$0-0
+	MOVD AX, BX
+	MOVD $1, AX
+	MOVD AX, 8(BX)
+	MOVD 8(BX), AX
+	MOVD (BX), M0
+	MOVD M0, 8(BX)
+	MOVD AX, M1
+	MOVD M1, AX
+	MOVD X0, M2
+	MOVD M2, M3
+	MOVD AX, X1
+	MOVD 24(SP), X9
+	MOVD X1, AX
+	MOVD X9, 32(SP)
+	MOVD X1, X2
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "movdaliasforms", "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ll, "load i64") || !strings.Contains(ll, "store i64") {
+		t.Fatalf("MOVD alias did not preserve MOVQ-width memory semantics:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "movd-alias-forms.ll", "movd-alias-forms.o", ll)
+}
+
+func TestTranslateAMD64MOVDAliasRejectsFormsOutsideGo127Ymovq(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVD $1, X0",
+		"MOVD M0, X0",
+		"MOVD X0, X1, X2",
+		"MOVD.Z X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT badmovd(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"badmovd": {Name: "badmovd", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's MOVD/ymovq forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64LegacyPrefetchFamilyCompleteGo127Forms(t *testing.T) {
+	src := `
+TEXT prefetchforms(SB),NOSPLIT,$0-0
+	PREFETCHNTA (AX)
+	PREFETCHT0 8(BX)
+	PREFETCHT1 source(SB)
+	PREFETCHT2 16(SP)
+	RET
+`
+	ll := translateAMD64EcosystemCase(t, src, "prefetchforms")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "prefetch-forms.ll", "prefetch-forms.o", ll)
+}
+
+func TestTranslateAMD64LegacyPrefetchFamilyRejectsNonMemoryForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PREFETCHNTA",
+		"PREFETCHT0 AX",
+		"PREFETCHT1 $1",
+		"PREFETCHT2 (AX), (BX)",
+		"PREFETCHT0.Z (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT badprefetch(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"badprefetch": {Name: "badprefetch", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's yprefetch table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ArithmeticDisplacementExpression(t *testing.T) {
+	const source = `
+TEXT arithmeticdisplacement(SB),NOSPLIT,$32-0
+	ADDQ 0+(1*16)(BP), R10
+	MOVQ (-16+8)(SP), AX
+	RET
+`
+	goAssemblerOracleOutput(t, "amd64", "#define NOSPLIT 4\n"+source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Instrs[1].Args[0]; got.Kind != OpMem || got.Mem.Base != BP || got.Mem.Off != 16 {
+		t.Fatalf("BP arithmetic displacement parsed as %+v, want offset 16", got)
+	}
+	if got := file.Funcs[0].Instrs[2].Args[0]; got.Kind != OpMem || got.Mem.Base != SP || got.Mem.Off != -8 {
+		t.Fatalf("SP arithmetic displacement parsed as %+v, want offset -8", got)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("unbound/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func arithmeticdisplacement()",
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original displacement grammar supplied BP/R10 or physical stack input", err)
+			}
+		})
+	}
+
+	// The exact original memory expressions now address initialized local
+	// bytes: BP is an explicit private-frame pointer and SP is restored before
+	// returning. Neither expression grants a physical entry register value.
+	const initialized = `TEXT ·arithmeticdisplacement(SB),4,$32-24
+	MOVQ SP, BP
+	MOVQ a+0(FP), AX
+	MOVQ b+8(FP), R10
+	MOVQ AX, 16(SP)
+	MOVQ AX, 8(SP)
+	MOVQ SP, R11
+	ADDQ $16, SP
+	ADDQ 0+(1*16)(BP), R10
+	MOVQ (-16+8)(SP), AX
+	MOVQ R11, SP
+	ADDQ R10, AX
+	MOVQ AX, ret+16(FP)
+	RET
+`
+	x86StackExpressionBoundObjects(t, initialized, "func arithmeticdisplacement(a,b uint64) uint64")
+}
+
+func TestTranslateAMD64GoTLSPseudoRegisterForms(t *testing.T) {
+	const source = `
+TEXT ·tlsforms(SB),4,$0-0
+	MOVQ TLS, CX
+	MOVQ 0(CX)(TLS*1), BX
+	MOVQ 8(TLS), DX
+	RET
+	`
+	x86ScalarCompareTLSGoObject(t, source, "amd64", "linux", false)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func tlsforms()", "amd64", "x86_64-unknown-linux-gnu", api)
+		if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatalf("%s: TLS source without native contract returned error=%v, IR=%s", api, err, ir)
+		}
+	}
+}
+
+func TestTranslateAMD64LegacyIntegerToFloatConversionFamilyCompleteGo127Forms(t *testing.T) {
+	ll := x86UnboundVoidScalarFormatObject(t, `
+TEXT integerfloatconversions(SB),NOSPLIT,$0-0
+	CVTSL2SS AX, X0
+	CVTSL2SS 4(BX), X1
+	CVTSL2SD CX, X2
+	CVTSL2SD 8(BX), X3
+	CVTSQ2SS SI, X4
+	CVTSQ2SS 16(BX), X5
+	CVTSQ2SD DI, X6
+	CVTSQ2SD 24(BX), X7
+	CVTPL2PS X0, X1
+	CVTPL2PS 32(BX), X2
+	CVTPL2PD X4, X5
+	CVTPL2PD 48(BX), X6
+	RET
+`, "integerfloatconversions", "amd64", "x86_64-unknown-linux-gnu")
+	for _, want := range []string{"@llvm.experimental.constrained.sitofp.f32.i32", "@llvm.experimental.constrained.sitofp.f64.i64", "cvtdq2ps", "cvtdq2pd"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("missing %q in integer-to-float conversion IR:\n%s", want, ll)
+		}
+	}
+	if strings.Count(ll, "asm sideeffect") != 4 || strings.Contains(ll, " = sitofp <") {
+		t.Fatal("packed native conversions lost whole-opcode side effects")
+	}
+	ll = x86SignedIntegerFloatOptimize(t, ll)
+	if strings.Count(ll, "asm sideeffect") != 4 {
+		t.Fatal("O2 dropped a native packed conversion")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "integer-float-conversions.ll", "integer-float-conversions.o", ll)
+}
+
+func TestTranslateAMD64LegacyIntegerToFloatConversionFamilyRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTSL2SS $1, X0",
+		"CVTSQ2SS X0, X1",
+		"CVTSQ2SD AX, Y0",
+		"CVTPL2PS AX, X0",
+		"CVTPL2PD X0, Y0",
+		"CVTPL2PS.Z X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT badconversion(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"badconversion": {Name: "badconversion", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's legacy integer-to-float tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ScalarFloatBroadcastFamilyCompleteGo127Forms(t *testing.T) {
+	ll := x86UnboundVoidScalarFormatObject(t, `
+TEXT scalarfloatbroadcasts(SB),NOSPLIT,$0-0
+	VBROADCASTSS X0, X1
+	VBROADCASTSS 4(AX), Y1
+	VBROADCASTSS X16, Z17
+	VBROADCASTSS X16, K1, X17
+	VBROADCASTSS.Z 8(AX), K2, Y18
+	VBROADCASTSS 12(AX), K3, Z19
+	VBROADCASTSD X0, Y1
+	VBROADCASTSD 8(AX), Z1
+	VBROADCASTSD X16, K1, Y17
+	VBROADCASTSD.Z 16(AX), K2, Z18
+	RET
+`, "scalarfloatbroadcasts", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "scalar-float-broadcasts.ll", "scalar-float-broadcasts.o", ll)
+}
+
+func TestTranslateAMD64ScalarFloatBroadcastFamilyRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VBROADCASTSS AX, X0",
+		"VBROADCASTSD X0, X1",
+		"VBROADCASTSS.Z X0, Y1",
+		"VBROADCASTSD X0, K0, Y1",
+		"VBROADCASTSS.BCST 4(AX), Y1",
+		"VBROADCASTSD X0, K1, K2, Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT badbroadcast(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"badbroadcast": {Name: "badbroadcast", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar broadcast tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64DwordToQwordMultiplyFamilyCompleteGo127Forms(t *testing.T) {
+	ll := x86UnboundVoidScalarFormatObject(t, `
+TEXT dwordqwordmultiply(SB),NOSPLIT,$0-0
+	PMULDQ X0, X1
+	PMULDQ 16(AX), X2
+	PMULULQ M0, M1
+	PMULULQ 24(AX), M2
+	PMULULQ X0, X1
+	PMULULQ 32(AX), X2
+	VPMULDQ X0, X1, X2
+	VPMULDQ Y0, Y1, Y2
+	VPMULDQ Z0, Z1, Z2
+	VPMULDQ Z0, Z1, K1, Z2
+	VPMULDQ.Z Z0, Z1, K2, Z2
+	VPMULDQ.BCST 40(AX), Z1, Z2
+	VPMULDQ.BCST.Z 48(AX), Z1, K3, Z2
+	VPMULUDQ X0, X1, X2
+	VPMULUDQ Y0, Y1, Y2
+	VPMULUDQ Z0, Z1, Z2
+	VPMULUDQ Z0, Z1, K1, Z2
+	VPMULUDQ.Z Z0, Z1, K2, Z2
+	VPMULUDQ.BCST 56(AX), Z1, Z2
+	VPMULUDQ.BCST.Z 64(AX), Z1, K3, Z2
+	RET
+`, "dwordqwordmultiply", "amd64", "x86_64-unknown-linux-gnu")
+	for _, want := range []string{"sext <", "zext <", "mul <2 x i64>", "mul <4 x i64>", "mul <8 x i64>"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("missing %q in dword-to-qword multiply IR:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "dword-qword-multiply.ll", "dword-qword-multiply.o", ll)
+}
+
+func TestTranslateAMD64DwordToQwordMultiplyFamilyRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PMULDQ M0, M1",
+		"PMULULQ Y0, Y1",
+		"VPMULUDQ X0, Y1, X2",
+		"VPMULDQ Z0, Z1, K0, Z2",
+		"VPMULUDQ.Z Z0, Z1, Z2",
+		"VPMULDQ.BCST Z0, Z1, Z2",
+		"VPMULUDQ.Z.BCST 8(AX), Z1, K1, Z2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT badmultiply(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"badmultiply": {Name: "badmultiply", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's dword-to-qword multiply tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386NewlyDiscoveredX86FamiliesCompleteGo127Forms(t *testing.T) {
+	// Keep the 386 matrix explicit: x86 opcode names are shared with amd64, but
+	// cmd/asm's operand tables and available registers differ in 32-bit mode.
+	src := `
+TEXT discoveredx86forms386(SB),NOSPLIT,$0-0
+	MOVD (AX), X0
+	MOVD X0, 8(AX)
+	MOVD X0, X1
+	MOVD 16(AX), M0
+	MOVD M0, 24(AX)
+	MOVD X0, M1
+	CVTSL2SS AX, X0
+	CVTSL2SS 4(BX), X1
+	CVTSL2SD CX, X2
+	CVTSL2SD 8(BX), X3
+	CVTPL2PS X0, X1
+	CVTPL2PS 16(BX), X2
+	CVTPL2PD X4, X5
+	CVTPL2PD 24(BX), X6
+	VBROADCASTSS X0, X1
+	VBROADCASTSS 4(AX), Y1
+	VBROADCASTSS 8(AX), Z1
+	VBROADCASTSD X0, Y2
+	VBROADCASTSD 16(AX), Z2
+	PMULDQ X0, X1
+	PMULDQ 16(AX), X2
+	PMULULQ X0, X1
+	PMULULQ 24(AX), X2
+	VPMULDQ X0, X1, X2
+	VPMULDQ Y0, Y1, Y2
+	VPMULDQ Z0, Z1, Z2
+	VPMULUDQ X0, X1, X2
+	VPMULUDQ Y0, Y1, Y2
+	VPMULUDQ Z0, Z1, Z2
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "discoveredx86forms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "discovered-x86-386-forms.ll", "discovered-x86-386-forms.o", ll)
+}
+
+func TestTranslate386NewlyDiscoveredX86FamiliesRejectArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVD AX, BX",
+		"MOVD M0, M1",
+		"MOVD M0, X0",
+		"CVTSQ2SS AX, X0",
+		"CVTSQ2SD 8(AX), X0",
+		"PMULULQ M0, M1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad386discovered(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"bad386discovered": {Name: "bad386discovered", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for GOARCH=386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64MOVQFromXRegisterToFrameResult(t *testing.T) {
+	src := `
+TEXT vectorret(SB),NOSPLIT,$0-8
+	PXOR X0, X0
+	MOVQ X0, vectorGlobal<>(SB)
+	MOVQ X0, ret+0(FP)
+	RET
+`
+	opts := Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{"vectorret": {
+			Name: "vectorret",
+			Ret:  I64,
+			Frame: FrameLayout{Results: []FrameSlot{{
+				Offset: 0,
+				Type:   I64,
+				Index:  0,
+				Field:  -1,
+			}}},
+		}},
+	}
+	t.Run("defined-storage", func(t *testing.T) {
+		bound := "GLOBL vectorGlobal<>(SB),16,$8\n" + strings.Replace(src, ",NOSPLIT,", ",4,", 1)
+		x86LEAActualTargetGoObject(t, "amd64", opts.TargetTriple, bound)
+		file, err := Parse(ArchAMD64, bound)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, opts)
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		for _, backend := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, opts.TargetTriple, ir, backend)
+		}
+	})
+	t.Run("unbound-storage", func(t *testing.T) {
+		// The original source has no storage definition. A signature and
+		// initialized X0 cannot establish the external symbol's extent.
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ir, err := Translate(file, opts); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatal("unbound static storage acquired an extent", err)
+		}
+	})
+}
+
+func TestTranslateAMD64X87Arithmetic(t *testing.T) {
+	src := `
+TEXT x87amd64(SB),NOSPLIT,$0-0
+	FLDZ
+	FLD1
+	FADDD F1, F0
+	FSUBD F1, F0
+	FLDCW 0(SP)
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "x87amd64")
+}
+
+func TestTranslateAMD64FuzzerBitTestAndVectorSubtract(t *testing.T) {
+	src := `
+TEXT fuzzops(SB),NOSPLIT,$0-0
+	BTL $16, CX
+	JCS done
+	VPSUBB Y0, Y1, Y2
+done:
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	// Keep the exact original fuzzer source as Go and public Context coverage.
+	// CX and both vector inputs are absent from its Void entry contract.
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86UnboundVoidFormatSource(t, src, "fuzzops", target.arch, target.triple)
+			inputs := "MOVL $0,CX\nVPXOR Y0,Y0,Y0\nVPXOR Y1,Y1,Y1\n"
+			initialized := strings.Replace(src, "BTL $16, CX", inputs+"BTL $16, CX", 1)
+			live := strings.Replace(initialized, "$0-0", "$0-32", 1)
+			live = strings.Replace(live, inputs, "VPXOR Y2,Y2,Y2\n"+inputs, 1)
+			live = strings.Replace(live, "done:", "done:\nVMOVDQU Y2,ret+0(FP)", 1)
+			const liveDeclaration = "func fuzzops() (ret, b, c, d uint64)"
+			for _, program := range []struct{ source, declaration string }{
+				{initialized, "func fuzzops()"},
+				{live, liveDeclaration},
+			} {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+program.source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, program.source, program.declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized bit-test/branch/subtract program rejected", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			}
+			for _, missing := range strings.Split(strings.TrimSpace(inputs), "\n") {
+				t.Run("missing-"+missing, func(t *testing.T) {
+					// Pure dead integer arithmetic may retain unknown bytes.
+					// Returning the full Y register makes every byte observable.
+					incomplete := strings.Replace(live, missing+"\n", "", 1)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+incomplete)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, incomplete, liveDeclaration, target.arch, target.triple, api)
+						if target.arch == "amd64" && strings.HasPrefix(missing, "VPXOR ") {
+							x86VectorScratchCodegenControl(t, incomplete, liveDeclaration, target.arch, target.triple, ir, err)
+							continue
+						}
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("live result acquired missing control or vector inputs", api, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateX86DivisionAndFrameArithmetic(t *testing.T) {
+	amd64Source := `
+TEXT divmod(SB),NOSPLIT,$0-32
+	MOVQ $0, DX
+	MOVQ a+0(FP), AX
+	DIVQ b+8(FP)
+	MOVQ AX, quo+16(FP)
+	MOVQ DX, rem+24(FP)
+	RET
+`
+	translateX86FrameCase(t, amd64Source, "amd64", "x86_64-unknown-linux-gnu", "divmod")
+
+	x86Source := `
+TEXT mulparts(SB),NOSPLIT,$0-32
+	MOVL a+0(FP), AX
+	MULL b+8(FP)
+	MOVL AX, hi+16(FP)
+	ADDL DX, hi+16(FP)
+	RET
+`
+	// Retain the complete historical body and its old manual two-I64 result
+	// layout as a missing-byte audit: it writes only the low four bytes of
+	// the first result and none of the second, not two initialized I64s.
+	file, err := Parse(ArchAMD64, x86Source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	old := FuncSig{Name: "mulparts", Args: []LLVMType{I64, I64}, Ret: LLVMType("{ i64, i64 }"), Frame: FrameLayout{
+		Params:  []FrameSlot{{Type: I64, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+		Results: []FrameSlot{{Offset: 16, Type: I64, Field: -1}, {Offset: 24, Type: I64, Index: 1, Field: -1}},
+	}}
+	ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{"mulparts": old}})
+	x86PartialTupleCodegenControl(t, x86Source, "func mulparts(a,b uint64) (hi,lo uint64)", "386", "i386-unknown-linux-gnu", ir, err)
+	// Only the low written word is observed; neither the high word nor the
+	// completely unwritten second tuple element is a deterministic output.
+	defined := "define i32 @DefinedLow() {\n %r = call { i64, i64 } @mulparts(i64 4294967295,i64 2)\n" +
+		" %first = extractvalue { i64, i64 } %r, 0\n %low = trunc i64 %first to i32\n ret i32 %low\n}\n"
+	x86ScalarFPNamedConstantResult(t, ir+defined, "DefinedLow", []uint64{0xffffffff})
+	// The same complete operations have one genuine I32 result. Bind the
+	// actual declaration and exact argument/result extent, not borrowed slots.
+	complete := strings.Replace(x86Source, "$0-32", "$0-20", 1)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("complete-mulparts/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, complete, "func mulparts(a,b uint64) uint32", "386", "i386-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("complete typed multiply/frame operations rejected", err)
+			}
+			probe := "define i32 @Probe() {\n %r = call i32 @mulparts(i64 4294967295,i64 2)\n ret i32 %r\n}\n"
+			x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{0xffffffff})
+		})
+	}
+}
+
+func TestTranslateAMD64LegacyBranchHintAndSignedDivision(t *testing.T) {
+	src := `
+TEXT signeddivmod(SB),NOSPLIT,$0-32
+	MOVQ a+0(FP), AX
+	MOVQ b+8(FP), CX
+	CMPQ CX, $-1
+	JEQ $1, special
+	CQO
+	IDIVQ CX
+	JMP done
+special:
+	NEGQ AX
+	MOVQ $0, DX
+done:
+	MOVQ AX, quo+16(FP)
+	MOVQ DX, rem+24(FP)
+	RET
+`
+	translateX86FrameCase(t, src, "amd64", "x86_64-unknown-linux-gnu", "signeddivmod")
+}
+
+func TestTranslateAMD64LoopBranch(t *testing.T) {
+	src := `
+TEXT countedloop(SB),NOSPLIT,$0-0
+	MOVQ $2, CX
+loop:
+	LOOP loop
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "countedloop")
+}
+
+func TestTranslateAMD64RawDataDirectives(t *testing.T) {
+	src := `
+TEXT rawencoding(SB),NOSPLIT,$0-0
+	LONG $0xe77da1c4
+	QUAD $0x4109048d47d18941
+	RET
+`
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawencoding": {Name: "rawencoding", Ret: Void}}}); err == nil || !strings.Contains(err.Error(), "decode raw x86 directive group") {
+		t.Fatalf("reachable opaque data directives must fail closed, got %v", err)
+	}
+}
+
+func TestTranslateAMD64HighQuadwordInterleave(t *testing.T) {
+	src := `
+TEXT highquadword(SB),NOSPLIT,$0-0
+	PUNPCKHQDQ X1, X0
+	VPUNPCKHQDQ Y0, Y1, Y2
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "highquadword")
+}
+
+func TestTranslateAMD64AdditionalAVXUnpackAndBroadcastFamilies(t *testing.T) {
+	src := `
+TEXT avxunpackbroadcast(SB),NOSPLIT,$0-0
+	VPUNPCKLQDQ X0, X1, X2
+	VPUNPCKLQDQ Y0, Y1, Y2
+	VPUNPCKLDQ X0, X1, X2
+	VPUNPCKLDQ Y0, Y1, Y2
+	VPUNPCKHDQ X0, X1, X2
+	VPUNPCKHDQ Y0, Y1, Y2
+	VPBROADCASTD (AX), X3
+	VPBROADCASTD (AX), Y3
+	VPSHUFD $0x4e, (AX), X4
+	VPSHUFD $0x4e, X0, X4
+	VPSHUFD $0x4e, (AX), Z4
+	VPSLLD $12, X5, X13
+	VPSRLD $7, (AX), X13
+	VPSLLD $12, Y5, Y13
+	VPSLLD $12, Z5, Z13
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "avxunpackbroadcast", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "avx-unpack-broadcast-formats.ll", "avx-unpack-broadcast-formats.o", ll)
+}
+
+func TestTranslateAMD64DwordShuffleCompleteGoAssemblerForms(t *testing.T) {
+	src := `
+TEXT dwordshuffleforms(SB),NOSPLIT,$0-0
+	PSHUFD $1, X1, X2
+	PSHUFD $1, (AX), X2
+	PSHUFL $1, X1, X2
+	VPSHUFD $1, X1, X2
+	VPSHUFD $1, (AX), X2
+	VPSHUFD $1, Y1, Y2
+	VPSHUFD $1, (AX), Y2
+	VPSHUFD $1, Z1, Z2
+	VPSHUFD $1, (AX), Z2
+	VPSHUFD $1, X1, K1, X2
+	VPSHUFD.Z $1, (AX), K1, X2
+	VPSHUFD $1, Y1, K1, Y2
+	VPSHUFD.Z $1, (AX), K1, Y2
+	VPSHUFD $1, Z1, K1, Z2
+	VPSHUFD.Z $1, (AX), K1, Z2
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "dwordshuffleforms")
+}
+
+func TestTranslateAMD64CanonicalPackedByteShiftAliases(t *testing.T) {
+	src := `
+TEXT packedbyteshifts(SB),NOSPLIT,$0-0
+	PSLLO $4, X0
+	PSRLO $4, X0
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "packedbyteshifts")
+}
+
+func TestTranslateAMD64PackedUniformShiftCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's x86 assembler assigns all of these instructions the same
+	// _yvpslld operand-format table. Keep this test in lockstep with that
+	// family instead of adding only the form first observed in a dependency.
+	for _, op := range []string{
+		"VPSLLD", "VPSLLQ", "VPSLLW",
+		"VPSRAD", "VPSRAW",
+		"VPSRLD", "VPSRLQ", "VPSRLW",
+	} {
+		var src strings.Builder
+		fmt.Fprintf(&src, "TEXT uniformshift%s(SB),NOSPLIT,$0-0\n", op)
+		for _, operands := range []string{
+			"$3, X1, X2", "$-1, X1, X2", "$3, (AX), X2",
+			"$3, Y1, Y2", "$-1, Y1, Y2", "$3, (AX), Y2",
+			"$3, Z1, Z2", "$3, (AX), Z2",
+			"X0, X1, X2", "(AX), X1, X2",
+			"X0, Y1, Y2", "(AX), Y1, Y2",
+			"X0, Z1, Z2", "(AX), Z1, Z2",
+			"$3, X1, K1, X2", "$3, (AX), K1, X2",
+			"$3, Y1, K1, Y2", "$3, (AX), K1, Y2",
+			"$3, Z1, K1, Z2", "$3, (AX), K1, Z2",
+			"X0, X1, K1, X2", "(AX), X1, K1, X2",
+			"X0, Y1, K1, Y2", "(AX), Y1, K1, Y2",
+			"X0, Z1, K1, Z2", "(AX), Z1, K1, Z2",
+		} {
+			fmt.Fprintf(&src, "\t%s %s\n", op, operands)
+		}
+		for _, operands := range []string{
+			"$3, X1, K1, X2", "$3, (AX), K1, X2",
+			"$3, Y1, K1, Y2", "$3, (AX), K1, Y2",
+			"$3, Z1, K1, Z2", "$3, (AX), K1, Z2",
+			"X0, X1, K1, X2", "(AX), X1, K1, X2",
+			"X0, Y1, K1, Y2", "(AX), Y1, K1, Y2",
+			"X0, Z1, K1, Z2", "(AX), Z1, K1, Z2",
+		} {
+			fmt.Fprintf(&src, "\t%s.Z %s\n", op, operands)
+		}
+		src.WriteString("\tRET\n")
+		ll := x86UnboundVoidScalarFormatObject(t, src.String(), "uniformshift"+op, "amd64", "x86_64-unknown-linux-gnu")
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "uniform-shift.ll", "uniform-shift.o", ll)
+	}
+}
+
+func TestTranslateAMD64PackedIntegerCompareCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns all eight equality/greater-than variants the shared
+	// _yvpcmpeqb table. VEX writes X/Y vectors; EVEX compares X/Y/Z lanes into
+	// K registers, optionally masked by K1-K7. D/Q also permit memory broadcast.
+	ops := []string{
+		"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ",
+		"VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ",
+	}
+	forms := []string{
+		"X1, X2, X3", "(AX), X2, X3",
+		"Y1, Y2, Y3", "(AX), Y2, Y3",
+		"X1, X2, K3", "(AX), X2, K3",
+		"X1, X2, K1, K3", "(AX), X2, K1, K3",
+		"Y1, Y2, K3", "(AX), Y2, K3",
+		"Y1, Y2, K1, K3", "(AX), Y2, K1, K3",
+		"Z1, Z2, K3", "(AX), Z2, K3",
+		"Z1, Z2, K1, K3", "(AX), Z2, K1, K3",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT packedintegercompareforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range ops {
+		for _, form := range forms {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+			for _, form := range []string{
+				"(AX), X2, K3", "(AX), X2, K1, K3",
+				"(AX), Y2, K3", "(AX), Y2, K1, K3",
+				"(AX), Z2, K3", "(AX), Z2, K1, K3",
+			} {
+				fmt.Fprintf(&src, "\t%s.BCST %s\n", op, form)
+			}
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedintegercompareforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-integer-compare-forms.ll", "packed-integer-compare-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedIntegerCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPCMPEQB Z1, Z2, Z3",
+		"VPCMPEQW X1, Y2, Y3",
+		"VPCMPEQD X1, X2, K0, K3",
+		"VPCMPEQQ.Z X1, X2, K1, K3",
+		"VPCMPGTB.BCST (AX), X2, K3",
+		"VPCMPGTW.SAE X1, X2, K3",
+		"VPCMPGTD.BCST X1, X2, K3",
+		"VPCMPGTQ.BCST (AX), X2, X3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedintegercompare(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedintegercompare": {Name: "invalidpackedintegercompare", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's _yvpcmpeqb table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedAndNotCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 defines the whole AND-NOT family across three operand tables:
+	// PANDN's ymm table (MMX/XMM), VPANDN's _yvaddsubpd table (X/Y VEX),
+	// and VPANDND/Q's _yvblendmpd table (X/Y/Z EVEX with optional K1-K7
+	// masking and zeroing). Only the D/Q EVEX variants permit memory broadcast.
+	src := `
+TEXT packedandnotforms(SB),NOSPLIT,$0-0
+	PANDN M1, M2
+	PANDN (AX), M2
+	PANDN X1, X2
+	PANDN (AX), X2
+	VPANDN X1, X2, X3
+	VPANDN (AX), X2, X3
+	VPANDN Y1, Y2, Y3
+	VPANDN (AX), Y2, Y3
+	VPANDND X1, X2, X3
+	VPANDND (AX), X2, X3
+	VPANDND X1, X2, K1, X3
+	VPANDND.Z (AX), X2, K1, X3
+	VPANDND Y1, Y2, Y3
+	VPANDND (AX), Y2, Y3
+	VPANDND Y1, Y2, K1, Y3
+	VPANDND.Z (AX), Y2, K1, Y3
+	VPANDND Z1, Z2, Z3
+	VPANDND (AX), Z2, Z3
+	VPANDND Z1, Z2, K1, Z3
+	VPANDND.Z (AX), Z2, K1, Z3
+	VPANDND.BCST (AX), X2, X3
+	VPANDND.BCST (AX), X2, K1, X3
+	VPANDND.BCST.Z (AX), X2, K1, X3
+	VPANDND.BCST (AX), Y2, Y3
+	VPANDND.BCST (AX), Y2, K1, Y3
+	VPANDND.BCST.Z (AX), Y2, K1, Y3
+	VPANDND.BCST (AX), Z2, Z3
+	VPANDND.BCST (AX), Z2, K1, Z3
+	VPANDND.BCST.Z (AX), Z2, K1, Z3
+	VPANDNQ X1, X2, X3
+	VPANDNQ (AX), X2, X3
+	VPANDNQ X1, X2, K1, X3
+	VPANDNQ.Z (AX), X2, K1, X3
+	VPANDNQ Y1, Y2, Y3
+	VPANDNQ (AX), Y2, Y3
+	VPANDNQ Y1, Y2, K1, Y3
+	VPANDNQ.Z (AX), Y2, K1, Y3
+	VPANDNQ Z1, Z2, Z3
+	VPANDNQ (AX), Z2, Z3
+	VPANDNQ Z1, Z2, K1, Z3
+	VPANDNQ.Z (AX), Z2, K1, Z3
+	VPANDNQ.BCST (AX), X2, X3
+	VPANDNQ.BCST (AX), X2, K1, X3
+	VPANDNQ.BCST.Z (AX), X2, K1, X3
+	VPANDNQ.BCST (AX), Y2, Y3
+	VPANDNQ.BCST (AX), Y2, K1, Y3
+	VPANDNQ.BCST.Z (AX), Y2, K1, Y3
+	VPANDNQ.BCST (AX), Z2, Z3
+	VPANDNQ.BCST (AX), Z2, K1, Z3
+	VPANDNQ.BCST.Z (AX), Z2, K1, Z3
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedandnotforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-and-not-forms.ll", "packed-and-not-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedAndNotRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PANDN Y1, Y2",
+		"VPANDN Z1, Z2, Z3",
+		"VPANDN.X Z1, Z2, Z3",
+		"VPANDND X1, Y2, Y3",
+		"VPANDND X1, X2, K0, X3",
+		"VPANDND.Z X1, X2, X3",
+		"VPANDND.SAE X1, X2, K1, X3",
+		"VPANDND.BCST X1, X2, X3",
+		"VPANDNQ.BCST (AX), X2, Y3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedandnot(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedandnot": {Name: "invalidpackedandnot", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PANDN/VPANDN operand tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedScalarBroadcastCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns VPBROADCASTB/W/D/Q the same _yvpbroadcastb table.
+	// VEX broadcasts X/m to X/Y; EVEX adds GP and X/m sources, X/Y/Z
+	// destinations, K1-K7 merge masking, and masked .Z zeroing.
+	forms := []string{
+		"X1, X2", "(AX), X2", "table<>(SB), X2", "0, X2",
+		"X1, Y2", "(AX), Y2", "table<>(SB), Y2", "0x1234, Y2",
+		"AX, X2", "AX, Y2", "AX, Z2",
+		"X1, Z2", "(AX), Z2",
+		"AX, K1, X2", "X1, K1, X2", "(AX), K1, X2",
+		"AX, K1, Y2", "X1, K1, Y2", "(AX), K1, Y2",
+		"AX, K1, Z2", "X1, K1, Z2", "(AX), K1, Z2",
+	}
+	zeroForms := []string{
+		"AX, K1, X2", "X1, K1, X2", "(AX), K1, X2",
+		"AX, K1, Y2", "X1, K1, Y2", "(AX), K1, Y2",
+		"AX, K1, Z2", "X1, K1, Z2", "(AX), K1, Z2",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT packedscalarbroadcastforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+		for _, form := range forms {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		for _, form := range zeroForms {
+			fmt.Fprintf(&src, "\t%s.Z %s\n", op, form)
+		}
+	}
+	src.WriteString("\tRET\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedscalarbroadcastforms", "amd64", target.triple)
+			compileLLVMToObject(t, llc, target.triple, "packed-scalar-broadcast-forms-"+target.name+".ll", "packed-scalar-broadcast-forms-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateAMD64PackedScalarBroadcastRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPBROADCASTB $1, X2",
+		"VPBROADCASTW Y1, Y2",
+		"VPBROADCASTD X1, K0, X2",
+		"VPBROADCASTQ X1, AX",
+		"VPBROADCASTB.Z X1, X2",
+		"VPBROADCASTW.BCST (AX), X2",
+		"VPBROADCASTD.SAE X1, K1, X2",
+		"VPBROADCASTQ X1, K1, Y2, Z3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedscalarbroadcast(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedscalarbroadcast": {Name: "invalidpackedscalarbroadcast", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's _yvpbroadcastb table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedIntegerAddCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Go 1.27's legacy ymm table gives these instructions MMX and XMM forms.
+	for _, op := range []string{"PADDB", "PADDL", "PADDSB", "PADDSW", "PADDUSB", "PADDUSW", "PADDW"} {
+		src := fmt.Sprintf(`
+TEXT legacy%sforms(SB),NOSPLIT,$0-0
+	%s M1, M2
+	%s (AX), M2
+	%s X1, X2
+	%s (AX), X2
+	RET
+`, op, op, op, op, op)
+		ir := x86UnboundVoidScalarFormatObject(t, src, "legacy"+op+"forms", "amd64", "x86_64-unknown-linux-gnu")
+		x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O0")
+	}
+	// PADDQ is deliberately narrower in Go's legacy yxm table: XMM only.
+	legacyQ := `
+TEXT legacyPADDQforms(SB),NOSPLIT,$0-0
+	PADDQ X1, X2
+	PADDQ (AX), X2
+	RET
+`
+	legacyIR := x86UnboundVoidScalarFormatObject(t, legacyQ, "legacyPADDQforms", "amd64", "x86_64-unknown-linux-gnu")
+	x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", legacyIR, "-O0")
+
+	// Every AVX variant shares _yvandnpd: X/Y/Z register-or-memory inputs,
+	// optional K1-K7 merge/zero masks. D/Q additionally enable broadcast.
+	commonForms := []string{
+		"X1, X2, X3", "(AX), X2, X3",
+		"X1, X2, K1, X3", "(AX), X2, K1, X3",
+		"Y1, Y2, Y3", "(AX), Y2, Y3",
+		"Y1, Y2, K1, Y3", "(AX), Y2, K1, Y3",
+		"Z1, Z2, Z3", "(AX), Z2, Z3",
+		"Z1, Z2, K1, Z3", "(AX), Z2, K1, Z3",
+	}
+	maskedForms := []string{
+		"X1, X2, K1, X3", "(AX), X2, K1, X3",
+		"Y1, Y2, K1, Y3", "(AX), Y2, K1, Y3",
+		"Z1, Z2, K1, Z3", "(AX), Z2, K1, Z3",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT packedintegeraddforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{
+		"VPADDB", "VPADDW", "VPADDD", "VPADDQ",
+		"VPADDSB", "VPADDSW", "VPADDUSB", "VPADDUSW",
+	} {
+		for _, form := range commonForms {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		for _, form := range maskedForms {
+			fmt.Fprintf(&src, "\t%s.Z %s\n", op, form)
+		}
+		if op == "VPADDD" || op == "VPADDQ" {
+			for _, form := range []string{
+				"(AX), X2, X3", "(AX), X2, K1, X3",
+				"(AX), Y2, Y3", "(AX), Y2, K1, Y3",
+				"(AX), Z2, Z3", "(AX), Z2, K1, Z3",
+			} {
+				fmt.Fprintf(&src, "\t%s.BCST %s\n", op, form)
+			}
+			for _, form := range []string{
+				"(AX), X2, K1, X3", "(AX), Y2, K1, Y3", "(AX), Z2, K1, Z3",
+			} {
+				fmt.Fprintf(&src, "\t%s.BCST.Z %s\n", op, form)
+			}
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedintegeraddforms", "amd64", "x86_64-unknown-linux-gnu")
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-integer-add-forms.ll", "packed-integer-add-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedIntegerAddRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PADDQ M1, M2",
+		"PADDB Y1, Y2",
+		"VPADDB X1, Y2, Y3",
+		"VPADDW X1, X2, K0, X3",
+		"VPADDD.Z X1, X2, X3",
+		"VPADDQ.BCST X1, X2, X3",
+		"VPADDSB.BCST (AX), X2, X3",
+		"VPADDSW.SAE X1, X2, K1, X3",
+		"VPADDUSB X1, X2, K1, X3, X4",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedintegeradd(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedintegeradd": {Name: "invalidpackedintegeradd", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed-add tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedIntegerSubtractCompleteGoAssemblerForms(t *testing.T) {
+	// All eight legacy instructions use yxm: X/m128, X. Unlike the packed-add
+	// family, none of these legacy subtract spellings has an MMX row.
+	var src strings.Builder
+	src.WriteString("TEXT packedintegersubtractforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PSUBB", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW", "PSUBW"} {
+		fmt.Fprintf(&src, "\t%s X1, X15\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X15\n", op)
+	}
+
+	// All eight V spellings share _yvandnpd. Exercise every VEX/EVEX width,
+	// both register and memory members of each rm class, high EVEX registers,
+	// K merge/zero masks, and the D/Q-only broadcast rows.
+	commonForms := []string{
+		"X1, X2, X3", "(AX), X2, X3",
+		"Y1, Y2, Y3", "(AX), Y2, Y3",
+		"Z1, Z2, Z3", "(AX), Z2, Z3",
+		"X20, X21, X22", "Y20, Y21, Y22", "Z20, Z21, Z22",
+	}
+	maskedForms := []string{
+		"X20, X21, K1, X22", "(AX), X21, K1, X22",
+		"Y20, Y21, K1, Y22", "(AX), Y21, K1, Y22",
+		"Z20, Z21, K1, Z22", "(AX), Z21, K1, Z22",
+	}
+	for _, op := range []string{
+		"VPSUBB", "VPSUBD", "VPSUBQ", "VPSUBSB",
+		"VPSUBSW", "VPSUBUSB", "VPSUBUSW", "VPSUBW",
+	} {
+		for _, form := range commonForms {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		for _, form := range maskedForms {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+			fmt.Fprintf(&src, "\t%s.Z %s\n", op, form)
+		}
+		if op == "VPSUBD" || op == "VPSUBQ" {
+			for _, width := range []string{"X", "Y", "Z"} {
+				fmt.Fprintf(&src, "\t%s.BCST (AX), %s21, %s22\n", op, width, width)
+				fmt.Fprintf(&src, "\t%s.BCST (AX), %s21, K1, %s22\n", op, width, width)
+				fmt.Fprintf(&src, "\t%s.BCST.Z (AX), %s21, K1, %s22\n", op, width, width)
+			}
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedintegersubtractforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-integer-subtract-forms.ll", "packed-integer-subtract-forms.o", ll)
+}
+
+func TestTranslate386PackedIntegerSubtractCompleteGoAssemblerForms(t *testing.T) {
+	// In 386 mode only the low eight registers have proved physical bindings.
+	// Go-accepted high-bank EVEX spellings require separate Context tests:
+	// frontend acceptance alone is not a mode32 physical register identity.
+	var src strings.Builder
+	src.WriteString("TEXT packedintegersubtractforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PSUBB", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW", "PSUBW"} {
+		fmt.Fprintf(&src, "\t%s X1, X7\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X7\n", op)
+	}
+	for _, op := range []string{
+		"VPSUBB", "VPSUBD", "VPSUBQ", "VPSUBSB",
+		"VPSUBSW", "VPSUBUSB", "VPSUBUSW", "VPSUBW",
+	} {
+		for _, form := range []string{
+			"X1, X2, X7", "(AX), X2, X7",
+			"Y1, Y2, Y7", "(AX), Y2, Y7",
+			"Z1, Z2, Z7", "(AX), Z2, Z7",
+		} {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		if op == "VPSUBD" || op == "VPSUBQ" {
+			fmt.Fprintf(&src, "\t%s.BCST (AX), X2, X7\n", op)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), Y2, Y7\n", op)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), Z2, Z7\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedintegersubtractforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-integer-subtract-386-forms.ll", "packed-integer-subtract-386-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedIntegerSubtractRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PSUBB M1, M2",
+		"PSUBQ Y1, Y2",
+		"VPSUBB X1, Y2, Y3",
+		"VPSUBW X1, X2, K0, X3",
+		"VPSUBD.Z X1, X2, X3",
+		"VPSUBQ.BCST X1, X2, X3",
+		"VPSUBSB.BCST (AX), X2, X3",
+		"VPSUBSW.SAE X1, X2, K1, X3",
+		"VPSUBUSB X1, X2, K1, X3, X4",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedintegersubtract(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedintegersubtract": {Name: "invalidpackedintegersubtract", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed-subtract tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedIntegerSubtractRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PSUBB X1, X8",
+		"VPSUBQ Z8, Z2, Z3",
+		"VPSUBD X1, X2, K1, X3",
+		"VPSUBQ.Z X1, X2, K1, X3",
+		"VPSUBD.BCST.Z (AX), X2, K1, X3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedintegersubtract386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidpackedintegersubtract386": {Name: "invalidpackedintegersubtract386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedSumAbsoluteDifferencesCompleteGoAssemblerForms(t *testing.T) {
+	src := `
+TEXT packedsadforms(SB),NOSPLIT,$0-0
+	PSADBW X1, X2
+	PSADBW (AX), X2
+	VPSADBW X1, X2, X3
+	VPSADBW (AX), X2, X3
+	VPSADBW Y1, Y2, Y3
+	VPSADBW (AX), Y2, Y3
+	VPSADBW Z1, Z2, Z3
+	VPSADBW (AX), Z2, Z3
+	RET
+`
+	// These original formats have neither vector inputs nor a pointer entry.
+	// Retain their Go objects and public Context checks; initialized public
+	// objects for the complete SAD family live in x86_result_sad_test.go.
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedsadforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-sad-forms.ll", "packed-sad-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedSumAbsoluteDifferencesRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PSADBW Y1, Y2",
+		"VPSADBW X1, Y2, Y3",
+		"VPSADBW X1, X2, K1, X3",
+		"VPSADBW.Z X1, X2, X3",
+		"VPSADBW.BCST (AX), X2, X3",
+		"VPSADBW $1, X2, X3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedsad(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedsad": {Name: "invalidpackedsad", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PSADBW/VPSADBW tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64VectorLaneExtractCompleteGoAssemblerForms(t *testing.T) {
+	// VEXTRACTF128/I128 share Go 1.27's _yvextractf128 table.
+	var src strings.Builder
+	src.WriteString("TEXT vectorlaneextractforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VEXTRACTF128", "VEXTRACTI128"} {
+		fmt.Fprintf(&src, "\t%s $1, Y1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s $-1, Y1, (AX)\n", op)
+	}
+	// These four produce 128 bits from either Y or Z and share
+	// _yvextractf32x4, including masked register/memory destinations.
+	for _, op := range []string{"VEXTRACTF32X4", "VEXTRACTF64X2", "VEXTRACTI32X4", "VEXTRACTI64X2"} {
+		for _, form := range []string{
+			"$1, Y1, X2", "$1, Y1, (AX)",
+			"$1, Y1, K1, X2", "$1, Y1, K1, (AX)",
+			"$3, Z1, X2", "$3, Z1, (AX)",
+			"$3, Z1, K1, X2", "$3, Z1, K1, (AX)",
+		} {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		fmt.Fprintf(&src, "\t%s.Z $1, Y1, K1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s.Z $3, Z1, K1, X2\n", op)
+	}
+	// These four produce 256 bits from Z and share _yvextractf32x8.
+	for _, op := range []string{"VEXTRACTF32X8", "VEXTRACTF64X4", "VEXTRACTI32X8", "VEXTRACTI64X4"} {
+		for _, form := range []string{
+			"$1, Z1, Y2", "$1, Z1, (AX)",
+			"$1, Z1, K1, Y2", "$1, Z1, K1, (AX)",
+		} {
+			fmt.Fprintf(&src, "\t%s %s\n", op, form)
+		}
+		fmt.Fprintf(&src, "\t%s.Z $1, Z1, K1, Y2\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "vectorlaneextractforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "vector-lane-extract-forms.ll", "vector-lane-extract-forms.o", ll)
+}
+
+func TestTranslateAMD64VectorLaneExtractRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VEXTRACTI128 $1, Z1, X2",
+		"VEXTRACTF128 $1, Y1, K1, X2",
+		"VEXTRACTI32X4 $1, X1, X2",
+		"VEXTRACTF64X2 $1, Y1, Y2",
+		"VEXTRACTI32X8 $1, Y1, Y2",
+		"VEXTRACTF64X4 $1, Z1, K0, Y2",
+		"VEXTRACTF32X4.Z $1, Y1, X2",
+		"VEXTRACTI64X2.Z $1, Z1, K1, (AX)",
+		"VEXTRACTI64X4.SAE $1, Z1, Y2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidvectorlaneextract(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			// Go encodes EVEX.z memory extracts, although Intel specifies #UD.
+			// Retain this control alongside the eight translator refusals.
+			terminal := instruction == "VEXTRACTI64X2.Z $1, Z1, K1, (AX)"
+			goSource := strings.Replace(src, "NOSPLIT", "4", 1)
+			if instruction == "VEXTRACTF32X4.Z $1, Y1, X2" {
+				// Old Go could encode z=1/aaa=0; retain that observation
+				// without granting the reserved form translation semantics.
+				x86InsertExtractReservedZeroMaskGoObservation(t, goSource,
+					0x62, 0xf3, 0x7d, 0xa8, 0x19, 0xca, 0x01)
+			} else {
+				x86ScalarLiteralExpectedGoListing(t, "amd64", goSource, terminal)
+			}
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidvectorlaneextract": {Name: "invalidvectorlaneextract", Ret: Void},
+				},
+			})
+			if terminal {
+				if err != nil {
+					t.Fatal("Go-encodable memory zeroing must terminate before reading its inputs", err)
+				}
+				if _, err := x86OfficialMoveFaultBody(ll, "invalidvectorlaneextract"); err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's vector-lane extract tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedScalarExtractCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's legacy yextr/yextrw tables accept an unsigned imm8, an
+	// X0-X15 source, and a GP-or-memory destination. The yextr table used by
+	// B/D/Q also (unusually) classifies M0-M7 as destinations; those names
+	// encode the correspondingly numbered GP registers.
+	var src strings.Builder
+	src.WriteString("TEXT packedscalarextractforms(SB),NOSPLIT,$0-0\n")
+	for _, spec := range []struct {
+		op       string
+		maxIndex int
+		mmxDst   bool
+	}{
+		{op: "PEXTRB", maxIndex: 15, mmxDst: true},
+		{op: "PEXTRW", maxIndex: 7},
+		{op: "PEXTRD", maxIndex: 3, mmxDst: true},
+		{op: "PEXTRQ", maxIndex: 1, mmxDst: true},
+	} {
+		fmt.Fprintf(&src, "\t%s $%d, X15, AX\n", spec.op, spec.maxIndex)
+		fmt.Fprintf(&src, "\t%s $255, X15, (AX)\n", spec.op)
+		if spec.mmxDst {
+			fmt.Fprintf(&src, "\t%s $%d, X15, M2\n", spec.op, spec.maxIndex)
+		}
+	}
+
+	// Go 1.27's _yvextractps/_yvpextrw tables add signed-imm8 VEX forms
+	// for X0-X15 and unsigned-imm8 EVEX forms for X16-X31. They do not add
+	// mask or instruction-suffix forms.
+	for _, spec := range []struct {
+		op       string
+		maxIndex int
+	}{
+		{op: "VPEXTRB", maxIndex: 15},
+		{op: "VPEXTRW", maxIndex: 7},
+		{op: "VPEXTRD", maxIndex: 3},
+		{op: "VPEXTRQ", maxIndex: 1},
+	} {
+		fmt.Fprintf(&src, "\t%s $%d, X1, R8\n", spec.op, spec.maxIndex)
+		fmt.Fprintf(&src, "\t%s $255, X1, (AX)\n", spec.op)
+		fmt.Fprintf(&src, "\t%s $-128, X1, R8\n", spec.op)
+		fmt.Fprintf(&src, "\t%s $%d, X31, R15\n", spec.op, spec.maxIndex)
+		fmt.Fprintf(&src, "\t%s $255, X31, (AX)\n", spec.op)
+	}
+	src.WriteString("\tRET\n")
+
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedscalarextractforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-scalar-extract-forms.ll", "packed-scalar-extract-forms.o", ll)
+}
+
+func TestTranslateAMD64PackedScalarExtractRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PEXTRB $-1, X1, AX",
+		"PEXTRD $256, X1, AX",
+		"PEXTRW $1, X1, M2",
+		"PEXTRQ $1, X16, AX",
+		"PEXTRB $1, Y1, AX",
+		"VPEXTRB $-129, X1, AX",
+		"VPEXTRW $256, X1, AX",
+		"VPEXTRD $-1, X20, AX",
+		"VPEXTRQ $1, X1, M2",
+		"VPEXTRB $1, X1, K1, AX",
+		"VPEXTRW.Z $1, X1, AX",
+		"VPEXTRD.BCST $1, X1, (AX)",
+		"VPEXTRQ.SAE $1, X1, AX",
+		"VPEXTRB $1, X1, X2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedscalarextract(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedscalarextract": {Name: "invalidpackedscalarextract", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PEXTR/VPEXTR tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64MoveHighLowPackedSingleCompleteGoAssemblerForms(t *testing.T) {
+	// MOVHLPS/MOVLHPS use Go 1.27's yxr table (X0-X15, two operands).
+	// VMOVHLPS/VMOVLHPS share _yvmovhlps: three X operands, with both the
+	// X0-X15 VEX entry and the X0-X31 EVEX entry.
+	src := `
+TEXT movehighlowpackedsingleforms(SB),NOSPLIT,$0-0
+	MOVHLPS X1, X2
+	MOVLHPS X15, X0
+	VMOVHLPS X1, X2, X3
+	VMOVLHPS X15, X14, X13
+	VMOVHLPS X20, X2, X3
+	VMOVHLPS X1, X20, X3
+	VMOVLHPS X1, X2, X31
+	RET
+`
+	ll := translateAMD64EcosystemCase(t, src, "movehighlowpackedsingleforms")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "move-high-low-packed-single-forms.ll", "move-high-low-packed-single-forms.o", ll)
+}
+
+func TestTranslateAMD64MoveHighLowPackedSingleRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVHLPS X16, X1",
+		"MOVLHPS X1, X16",
+		"MOVHLPS (AX), X1",
+		"MOVLHPS X1, X2, X3",
+		"VMOVHLPS X1, X2",
+		"VMOVLHPS (AX), X2, X3",
+		"VMOVHLPS Y1, Y2, Y3",
+		"VMOVLHPS X1, X2, K1, X3",
+		"VMOVHLPS.Z X1, X2, X3",
+		"VMOVLHPS.BCST X1, X2, X3",
+		"VMOVHLPS.SAE X1, X2, X3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidmovehighlowpackedsingle(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidmovehighlowpackedsingle": {Name: "invalidmovehighlowpackedsingle", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's MOVHLPS/MOVLHPS tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PopulationCountCompleteGoAssemblerForms(t *testing.T) {
+	// POPCNTW/L/Q all use Go 1.27's yml_rl table: a Yml GP-or-memory
+	// source followed by a Yrl GP destination.
+	src := `
+TEXT populationcountforms(SB),NOSPLIT,$0-0
+	POPCNTW AX, BX
+	POPCNTW (AX), R8
+	POPCNTW R15, R14
+	POPCNTL AX, BX
+	POPCNTL (AX), R8
+	POPCNTL R15, R14
+	POPCNTQ AX, BX
+	POPCNTQ (AX), R8
+	POPCNTQ R15, R14
+	RET
+`
+	ll := x86ScalarCountUnboundFormatObject(t, src, "populationcountforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "population-count-forms.ll", "population-count-forms.o", ll)
+}
+
+func TestTranslate386PopulationCountCompleteGoAssemblerForms(t *testing.T) {
+	src := `
+TEXT populationcount386forms(SB),NOSPLIT,$0-0
+	POPCNTW AX, BX
+	POPCNTW (AX), CX
+	POPCNTL AX, BX
+	POPCNTL (AX), CX
+	RET
+`
+	ll := x86ScalarCountUnboundFormatObject(t, src, "populationcount386forms", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "population-count-386-forms.ll", "population-count-386-forms.o", ll)
+
+	invalid, err := Parse(ArchAMD64, "TEXT invalidpopulationcount386(SB),NOSPLIT,$0-0\n\tPOPCNTQ AX, BX\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(invalid, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"invalidpopulationcount386": {Name: "invalidpopulationcount386", Ret: Void},
+		},
+	}); err == nil {
+		t.Fatal("Translate accepted POPCNTQ for GOARCH=386")
+	}
+}
+
+func TestTranslateAMD64PopulationCountRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"POPCNTW AL, BX",
+		"POPCNTL AX, AH",
+		"POPCNTQ M1, AX",
+		"POPCNTW X1, AX",
+		"POPCNTL AX, (BX)",
+		"POPCNTQ $1, AX",
+		"POPCNTW.Z AX, BX",
+		"POPCNTL AX, BX, CX",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpopulationcount(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpopulationcount": {Name: "invalidpopulationcount", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's POPCNT tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedMoveMaskCompleteGoAssemblerForms(t *testing.T) {
+	// PMOVMSKB's ymskb table has X and M source rows. VPMOVMSKB's
+	// _yvmovmskpd table has X and Y source rows. Every row writes Yrl and
+	// every vector register is limited to 0-15; neither table has EVEX rows.
+	src := `
+TEXT packedmovemaskforms(SB),NOSPLIT,$0-0
+	PMOVMSKB X0, AX
+	PMOVMSKB X15, R8
+	PMOVMSKB M0, BX
+	PMOVMSKB M7, R15
+	VPMOVMSKB X0, AX
+	VPMOVMSKB X15, R8
+	VPMOVMSKB Y0, BX
+	VPMOVMSKB Y15, R15
+	RET
+`
+	// Keep the original uninitialized, unterminated MMX source as a public
+	// context boundary. Legal Go operand forms do not supply physical inputs.
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+src, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("original-context/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, src, "func packedmovemaskforms()", "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original source acquired initialized vectors or MMX tag cleanup", err)
+			}
+		})
+	}
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var initialized, declarations strings.Builder
+	widths := map[string]int{}
+	widthCounts := map[int]int{}
+	for _, instruction := range file.Funcs[0].Instrs {
+		form, known, err := x86MoveMaskProperties(instruction.Op, instruction, "amd64")
+		if !known {
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		name := fmt.Sprintf("PackedMoveMaskForm%d", len(widths))
+		widths[name] = form.byteWidth
+		widthCounts[form.byteWidth]++
+		original := strings.TrimSpace(instruction.Raw)
+		load, cleanup := "MOVOU", ""
+		if form.byteWidth == 8 {
+			load, cleanup = "MOVQ", "EMMS\n"
+		} else if form.byteWidth == 32 {
+			load = "VMOVDQU"
+		}
+		body := fmt.Sprintf("MOVQ p+0(FP),SI\n%s (SI),%s\n%s\n%sMOVQ %s,ret+8(FP)\nRET\n",
+			load, instruction.Args[0].Reg, original, cleanup, instruction.Args[1].Reg)
+		fmt.Fprintf(&initialized, "TEXT ·%s(SB),4,$0-16\n%s", name, body)
+		fmt.Fprintf(&declarations, "func %s(p *[32]byte) uint64\n", name)
+
+		// Observe each original operation's result, rather than allowing an
+		// unused Void destination to hide an undefined source register.
+		undefined := fmt.Sprintf("TEXT ·%s(SB),4,$0-8\n%s\n%sMOVQ %s,ret+0(FP)\nRET\n",
+			name, original, cleanup, instruction.Args[1].Reg)
+		goAssemblerOracleOutput(t, "amd64", undefined, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run("undefined-input/"+name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, undefined, "func "+name+"() uint64", "amd64", "x86_64-unknown-linux-gnu", api)
+				if form.byteWidth != 8 {
+					x86VectorScratchCodegenControl(t, undefined, "func "+name+"() uint64", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					return
+				}
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("mask result acquired an undefined physical source", original, err)
+				}
+			})
+			if form.byteWidth == 8 {
+				t.Run("missing-EMMS/"+name+"/"+api, func(t *testing.T) {
+					unterminated := "TEXT ·" + name + "(SB),4,$0-16\n" + strings.ReplaceAll(body, cleanup, "")
+					ir, err := x86ScalarFPBitViewAPI(t, unterminated, "func "+name+"(p *[32]byte) uint64", "amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("initialized MMX source dispensed with real tag cleanup", original, err)
+					}
+				})
+			}
+		}
+	}
+	if len(widths) != 8 || widthCounts[8] != 2 || widthCounts[16] != 4 || widthCounts[32] != 2 {
+		t.Fatal("original eight move-mask forms changed", widths, widthCounts)
+	}
+	goAssemblerOracleOutput(t, "amd64", initialized.String(), "", true)
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM 22 llc and llvm-objdump required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("initialized/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, initialized.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("complete initialized move-mask forms rejected", err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					listing := x86ExchangeObjectDisassembly(t, llc, objdump, "x86_64-unknown-linux-gnu", ir, level)
+					assertEcosystemPackedMoveMaskObjectResults(t, listing, widths)
+				})
+			}
+		})
+	}
+}
+
+func assertEcosystemPackedMoveMaskObjectResults(t *testing.T, listing string, widths map[string]int) {
+	t.Helper()
+	owner := ""
+	masks, cleanups := map[string]int{}, map[string]int{}
+	for _, line := range strings.Split(listing, "\n") {
+		if _, name, found := strings.Cut(line, " <"); found && strings.HasSuffix(name, ">:") {
+			owner = strings.TrimSuffix(name, ">:")
+			continue
+		}
+		if _, known := widths[owner]; !known {
+			continue
+		}
+		for _, atom := range strings.Fields(line) {
+			if atom == "pmovmskb" || atom == "vpmovmskb" {
+				masks[owner]++
+			} else if atom == "emms" {
+				cleanups[owner]++
+			}
+		}
+	}
+	for name, width := range widths {
+		// A Y source may lower to one AVX2 mask or two SSE2 halves. Every
+		// independently returned mask must survive both optimization levels.
+		if masks[name] != 1 && (width != 32 || masks[name] != 2) {
+			t.Fatal("observable move-mask output missing from its target function", name, masks[name])
+		}
+		if width == 8 && cleanups[name] != 1 {
+			t.Fatal("MMX target region lost its tag cleanup", name, cleanups[name])
+		}
+	}
+}
+
+func TestTranslateAMD64PackedMoveMaskRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PMOVMSKB Y1, AX",
+		"PMOVMSKB X16, AX",
+		"PMOVMSKB (AX), BX",
+		"PMOVMSKB X1, M2",
+		"VPMOVMSKB M1, AX",
+		"VPMOVMSKB X16, AX",
+		"VPMOVMSKB Y16, AX",
+		"VPMOVMSKB X1, AL",
+		"VPMOVMSKB X1, X2",
+		"VPMOVMSKB X1, K1, AX",
+		"PMOVMSKB.Z X1, AX",
+		"VPMOVMSKB.BCST Y1, AX",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedmovemask(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedmovemask": {Name: "invalidpackedmovemask", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PMOVMSKB/VPMOVMSKB tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64BitwiseNotCompleteGoAssemblerForms(t *testing.T) {
+	// NOTB/W/L/Q all use Go 1.27's yscond table, whose sole row is Ymb.
+	// Besides memory and full GP spellings, Ymb admits low/high byte register
+	// spellings; for wider operations Go encodes those spellings by ModRM
+	// number (for example, NOTW AH encodes NOTW SP).
+	var src strings.Builder
+	src.WriteString("TEXT bitwisenotforms(SB),NOSPLIT,$0-0\n")
+	operands := []string{
+		"AX", "BX", "CX", "DX", "SP", "BP", "SI", "DI",
+		"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
+		"AL", "AH", "BL", "BH", "CL", "CH", "DL", "DH",
+		"BPB", "SIB", "DIB", "R8B", "R9B", "R10B", "R11B", "R12B", "R13B", "R14B", "R15B",
+		"(BX)",
+	}
+	for _, op := range []string{"NOTB", "NOTW", "NOTL", "NOTQ"} {
+		for _, operand := range operands {
+			fmt.Fprintf(&src, "\t%s %s\n", op, operand)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "bitwisenotforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "bitwise-not-forms.ll", "bitwise-not-forms.o", ll)
+}
+
+func TestTranslate386BitwiseNotCompleteGoAssemblerForms(t *testing.T) {
+	// In 386 mode Go classifies SP as Yrl32, which does not cover Ymb, but
+	// accepts BP/SI/DI by synthesizing an equivalent instruction sequence.
+	// Exercise every accepted GP spelling, both byte aliases, and memory.
+	var src strings.Builder
+	src.WriteString("TEXT bitwisenot386forms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"NOTB", "NOTW", "NOTL"} {
+		for _, operand := range []string{
+			"AX", "BX", "CX", "DX", "BP", "SI", "DI",
+			"AL", "AH", "BL", "BH", "CL", "CH", "DL", "DH",
+			"(BX)",
+		} {
+			fmt.Fprintf(&src, "\t%s %s\n", op, operand)
+		}
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "bitwisenot386forms", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "bitwise-not-386-forms.ll", "bitwise-not-386-forms.o", ll)
+
+	for _, instruction := range []string{"NOTB SP", "NOTW SP", "NOTL SP", "NOTQ AX", "NOTB R8"} {
+		t.Run("reject_"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			invalid, err := Parse(ArchAMD64, "TEXT invalidbitwisenot386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(invalid, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidbitwisenot386": {Name: "invalidbitwisenot386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for GOARCH=386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64BitwiseNotRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"NOTB M1",
+		"NOTW X1",
+		"NOTL K1",
+		"NOTQ $1",
+		"NOTB AX, BX",
+		"NOTW.Z AX",
+		"NOTL.BCST (AX)",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidbitwisenot(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidbitwisenot": {Name: "invalidbitwisenot", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's NOT tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ParallelBitDepositExtractCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses one _yandnl row for the whole family:
+	// Yml source/mask, Yrl source value, and Yrl destination. This gives each
+	// L/Q instruction both register and memory first-operand forms.
+	var src strings.Builder
+	src.WriteString("TEXT parallelbitforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+		fmt.Fprintf(&src, "\t%s AX, BX, CX\n", op)
+		fmt.Fprintf(&src, "\t%s (SI), R8, R15\n", op)
+		fmt.Fprintf(&src, "\t%s parallelBitMask(SB), R9, R10\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "parallelbitforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "parallel-bit-forms.ll", "parallel-bit-forms.o", ll)
+}
+
+func TestTranslate386ParallelBitDepositExtractCompleteGoAssemblerForms(t *testing.T) {
+	// The Go 1.27 assembler accepts the same four instruction names in 386
+	// mode. Yml/Yrl admit all eight 386 GP registers, including SP in any
+	// register position; only the first operand can instead be memory.
+	var src strings.Builder
+	src.WriteString("TEXT parallelbitforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+		fmt.Fprintf(&src, "\t%s AX, BX, CX\n", op)
+		fmt.Fprintf(&src, "\t%s (SI), BP, DI\n", op)
+		fmt.Fprintf(&src, "\t%s SP, AX, BX\n", op)
+		fmt.Fprintf(&src, "\t%s AX, SP, BX\n", op)
+		fmt.Fprintf(&src, "\t%s AX, BX, SP\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "parallelbitforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "parallel-bit-386-forms.ll", "parallel-bit-386-forms.o", ll)
+}
+
+func TestTranslateAMD64ParallelBitDepositExtractRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PDEPL AX, BX",
+		"PDEPQ AX, (BX), CX",
+		"PEXTL AX, BX, (CX)",
+		"PEXTQ $1, AX, BX",
+		"PDEPL AL, BX, CX",
+		"PDEPQ AX, X0, BX",
+		"PEXTL AX, BX, X0",
+		"PEXTQ.Z AX, BX, CX",
+		"PDEPL.BCST (AX), BX, CX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidparallelbit(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidparallelbit": {Name: "invalidparallelbit", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PDEP/PEXT table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386ParallelBitDepositExtractRejectsHighRegisters(t *testing.T) {
+	for _, instruction := range []string{
+		"PDEPL R8, AX, BX",
+		"PDEPQ AX, R8, BX",
+		"PEXTL AX, BX, R8",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT invalidparallelbit386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidparallelbit386": {Name: "invalidparallelbit386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q, which Go 1.27 rejects for GOARCH=386", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64BitTestFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 gives all BT/BTC/BTR/BTS W/L/Q instructions exactly two ybtl
+	// rows: signed imm8 + Yml and Yrl + Yml.
+	var src strings.Builder
+	src.WriteString("TEXT bittestforms(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"BT", "BTC", "BTR", "BTS"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			op := stem + width
+			fmt.Fprintf(&src, "\t%s $-128, AX\n", op)
+			fmt.Fprintf(&src, "\t%s $127, (BX)\n", op)
+			fmt.Fprintf(&src, "\t%s CX, R15\n", op)
+			fmt.Fprintf(&src, "\t%s R8, 8(SI)\n", op)
+			fmt.Fprintf(&src, "\t%s R9, bitTestGlobal(SB)\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	x86BitTestCompositeFormatObjects(t, src.String(), "bittestforms", "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestTranslate386BitTestFamilyCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT bittestforms386(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"BT", "BTC", "BTR", "BTS"} {
+		for _, width := range []string{"W", "L"} {
+			op := stem + width
+			fmt.Fprintf(&src, "\t%s $-128, AX\n", op)
+			fmt.Fprintf(&src, "\t%s $127, (BX)\n", op)
+			fmt.Fprintf(&src, "\t%s CX, DI\n", op)
+			fmt.Fprintf(&src, "\t%s SP, BP\n", op)
+			fmt.Fprintf(&src, "\t%s AX, SP\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	x86BitTestCompositeFormatObjects(t, src.String(), "bittestforms386", "386", "i386-unknown-linux-gnu")
+}
+
+func TestTranslateAMD64BitTestFamilyRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"BTB $1, AX",
+		"BTRL $128, AX",
+		"BTSQ $-129, AX",
+		"BTCW AX",
+		"BTL (AX), BX",
+		"BTRQ AL, AX",
+		"BTSW AX, $1",
+		"BTQ AX, X0",
+		"BTCL.Z AX, BX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidbittest(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidbittest": {Name: "invalidbittest", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's ybtl table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386BitTestFamilyRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"BTQ $1, AX",
+		"BTCQ AX, BX",
+		"BTRQ $1, (BX)",
+		"BTSQ AX, SP",
+		"BTL R8, AX",
+		"BTRW AX, R8",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT invalidbittest386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidbittest386": {Name: "invalidbittest386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q, which Go 1.27 rejects for GOARCH=386", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64ScalarAddSubCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT scalaraddsubforms(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"ADD", "SUB"} {
+		fmt.Fprintf(&src, "\t%sB $-2147483648, AL\n", stem)
+		fmt.Fprintf(&src, "\t%sB $4294967295, bytearg+0(FP)\n", stem)
+		fmt.Fprintf(&src, "\t%sB BP, (BX)\n", stem)
+		fmt.Fprintf(&src, "\t%sB (BX), R15\n", stem)
+		fmt.Fprintf(&src, "\t%sB bytearg+0(FP), R14\n", stem)
+		fmt.Fprintf(&src, "\t%sB CL, bytearg+0(FP)\n", stem)
+		for _, form := range []struct {
+			width  string
+			fpName string
+			offset int
+		}{
+			{width: "W", fpName: "wordarg", offset: 8},
+			{width: "L", fpName: "longarg", offset: 16},
+			{width: "Q", fpName: "quadarg", offset: 24},
+		} {
+			op := stem + form.width
+			fmt.Fprintf(&src, "\t%s $-2147483648, AX\n", op)
+			fmt.Fprintf(&src, "\t%s $4294967295, %s+%d(FP)\n", op, form.fpName, form.offset)
+			fmt.Fprintf(&src, "\t%s R8, (BX)\n", op)
+			fmt.Fprintf(&src, "\t%s (BX), R15\n", op)
+			fmt.Fprintf(&src, "\t%s %s+%d(FP), R14\n", op, form.fpName, form.offset)
+			fmt.Fprintf(&src, "\t%s CX, %s+%d(FP)\n", op, form.fpName, form.offset)
+		}
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"scalaraddsubforms": {
+				Name: "scalaraddsubforms",
+				Args: []LLVMType{I8, I16, I32, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I8, Index: 0, Field: -1},
+					{Offset: 8, Type: I16, Index: 1, Field: -1},
+					{Offset: 16, Type: I32, Index: 2, Field: -1},
+					{Offset: 24, Type: I64, Index: 3, Field: -1},
+				}},
+			},
+		},
+	}
+	// Keep the original Go-accepted source and all public Context controls.
+	// Its synthetic FP offsets and incoming native registers are format
+	// witnesses, not an ordinary initialized ABI0 entry.
+	x86UnboundVoidFormatSource(t, src.String(), "scalaraddsubforms", "amd64", options.TargetTriple)
+	ll := x86ScalarFormatObjectUnit(t, file, options.Sigs, "amd64", options.TargetTriple, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "scalar-add-sub-forms.ll", "scalar-add-sub-forms.o", ll)
+}
+
+func TestTranslate386ScalarAddSubCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT scalaraddsubforms386(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"ADD", "SUB"} {
+		fmt.Fprintf(&src, "\t%sB $4294967296, BP\n", stem)
+		fmt.Fprintf(&src, "\t%sB $-2147483649, bytearg+0(FP)\n", stem)
+		fmt.Fprintf(&src, "\t%sB SI, (BX)\n", stem)
+		fmt.Fprintf(&src, "\t%sB (BX), DI\n", stem)
+		for _, form := range []struct {
+			width  string
+			fpName string
+			offset int
+		}{
+			{width: "W", fpName: "wordarg", offset: 4},
+			{width: "L", fpName: "longarg", offset: 8},
+		} {
+			op := stem + form.width
+			fmt.Fprintf(&src, "\t%s $4294967296, AX\n", op)
+			fmt.Fprintf(&src, "\t%s $1, SP\n", op)
+			fmt.Fprintf(&src, "\t%s $-2147483649, %s+%d(FP)\n", op, form.fpName, form.offset)
+			fmt.Fprintf(&src, "\t%s SI, (BX)\n", op)
+			fmt.Fprintf(&src, "\t%s (BX), DI\n", op)
+		}
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"scalaraddsubforms386": {
+				Name: "scalaraddsubforms386",
+				Args: []LLVMType{I8, I16, I32},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I8, Index: 0, Field: -1},
+					{Offset: 4, Type: I16, Index: 1, Field: -1},
+					{Offset: 8, Type: I32, Index: 2, Field: -1},
+				}},
+			},
+		},
+	}
+	x86UnboundVoidFormatSource(t, src.String(), "scalaraddsubforms386", "386", options.TargetTriple)
+	ll := x86ScalarFormatObjectUnit(t, file, options.Sigs, "386", options.TargetTriple, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "scalar-add-sub-386-forms.ll", "scalar-add-sub-386-forms.o", ll)
+}
+
+func TestTranslateAMD64ScalarAddSubRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"ADDB (AX), (BX)",
+		"SUBW (AX), (BX)",
+		"ADDL $-2147483649, AX",
+		"SUBQ $4294967296, AX",
+		"ADDQ.Z AX, BX",
+		"SUBQ X0, AX",
+		"ADDQ AX, X0",
+		"SUBQ AX, $1",
+		"ADDB SP, (AX)",
+		"SUBB (AX), SP",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidscalaraddsub(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidscalaraddsub": {Name: "invalidscalaraddsub", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's ADD/SUB tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386ScalarAddSubRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"ADDQ AX, BX",
+		"SUBQ $1, (BX)",
+		"ADDL R8, AX",
+		"SUBW AX, R8",
+		"ADDB R8, (AX)",
+		"SUBB (AX), R8",
+		"ADDB SP, (AX)",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT invalidscalaraddsub386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidscalaraddsub386": {Name: "invalidscalaraddsub386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64CompareExchangeOriginalSyntaxContextCatalogue(t *testing.T) {
+	src := `
+DATA cmpxchgdata+0(SB)/8, $0
+DATA cmpxchgdata+8(SB)/8, $0
+GLOBL cmpxchgdata(SB), NOPTR, $16
+TEXT cmpxchgforms(SB),NOSPLIT,$0-16
+	CMPXCHGB AH, R11
+	CMPXCHGB R11, SP
+	CMPXCHGB DL, (R12)
+	CMPXCHGB DL, 0(FS)
+	CMPXCHGB DL, cmpxchgdata(SB)
+	CMPXCHGB DL, value+0(FP)
+	CMPXCHGW DX, R11
+	CMPXCHGW R11, (R12)
+	CMPXCHGW DX, 0(GS)
+	CMPXCHGW DX, cmpxchgdata(SB)
+	CMPXCHGW DX, value+0(FP)
+	CMPXCHGL DX, R11
+	CMPXCHGL R11, (R12)
+	CMPXCHGL DX, 0(FS)
+	CMPXCHGL DX, cmpxchgdata(SB)
+	CMPXCHGL DX, value+0(FP)
+	CMPXCHGQ DX, R11
+	CMPXCHGQ R11, (R12)
+	CMPXCHGQ DX, 0(GS)
+	CMPXCHGQ DX, cmpxchgdata(SB)
+	CMPXCHGQ DX, value+0(FP)
+	CMPXCHG8B R11
+	CMPXCHG8B SP
+	CMPXCHG8B (R12)
+	CMPXCHG8B 0(FS)
+	CMPXCHG8B cmpxchgdata(SB)
+	CMPXCHG8B value+0(FP)
+	CMPXCHG16B R11
+	CMPXCHG16B SP
+	CMPXCHG16B (R12)
+	CMPXCHG16B 0(GS)
+	CMPXCHG16B cmpxchgdata(SB)
+	CMPXCHG16B value+0(FP)
+	RET
+`
+	x86CMPXCHGMixedOriginalCatalogue(t, "amd64", src)
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"cmpxchgforms": {
+				Name: "cmpxchgforms",
+				Args: []LLVMType{LLVMType("i128")},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: LLVMType("i128"), Index: 0, Field: -1},
+				}},
+			},
+		},
+	})
+	// This unchanged syntax catalogue contains Go-accepted physical high-byte
+	// rewrites, non-memory pair #UD and an unbound 16B FP shadow. It is not a
+	// numerical native-positive. Closed memory forms have independent objects.
+	if !errors.Is(err, ErrProbeNeedsContext) || ll != "" {
+		t.Fatalf("mixed original native-identity gaps acquired a numerical object: %v", err)
+	}
+}
+
+func TestTranslate386CompareExchangeOriginalSyntaxContextCatalogue(t *testing.T) {
+	src := `
+DATA cmpxchgdata386+0(SB)/8, $0
+GLOBL cmpxchgdata386(SB), NOPTR, $8
+TEXT cmpxchgforms386(SB),NOSPLIT,$0-8
+	CMPXCHGB BP, (BX)
+	CMPXCHGB SI, DI
+	CMPXCHGB DL, 0(FS)
+	CMPXCHGB DL, cmpxchgdata386(SB)
+	CMPXCHGB DL, value+0(FP)
+	CMPXCHGW SI, DI
+	CMPXCHGW DX, SP
+	CMPXCHGW DX, (BX)
+	CMPXCHGW DX, 0(FS)
+	CMPXCHGW DX, cmpxchgdata386(SB)
+	CMPXCHGW DX, value+0(FP)
+	CMPXCHGL SI, DI
+	CMPXCHGL DX, SP
+	CMPXCHGL DX, (BX)
+	CMPXCHGL DX, 0(FS)
+	CMPXCHGL DX, cmpxchgdata386(SB)
+	CMPXCHGL DX, value+0(FP)
+	CMPXCHG8B AX
+	CMPXCHG8B BP
+	CMPXCHG8B SI
+	CMPXCHG8B (BX)
+	CMPXCHG8B 0(FS)
+	CMPXCHG8B cmpxchgdata386(SB)
+	CMPXCHG8B value+0(FP)
+	RET
+`
+	x86CMPXCHGMixedOriginalCatalogue(t, "386", src)
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"cmpxchgforms386": {
+				Name: "cmpxchgforms386",
+				Args: []LLVMType{I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+				}},
+			},
+		},
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ll != "" {
+		t.Fatalf("mixed original byte expansion/pair #UD acquired a numerical object: %v", err)
+	}
+}
+
+func TestTranslateAMD64CompareExchangeRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"CMPXCHGB (BX), DL",
+		"CMPXCHGW (BX), DX",
+		"CMPXCHGL $1, DX",
+		"CMPXCHGQ DX, $1",
+		"CMPXCHGB X0, DL",
+		"CMPXCHGL DX, X0",
+		"CMPXCHG8B",
+		"CMPXCHG8B (BX), AX",
+		"CMPXCHG8B $1",
+		"CMPXCHG16B",
+		"CMPXCHG16B (BX), AX",
+		"CMPXCHG16B.Z (BX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidcmpxchg(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidcmpxchg": {Name: "invalidcmpxchg", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's CMPXCHG tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386CompareExchangeRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"CMPXCHGQ DX, (BX)",
+		"CMPXCHG16B (BX)",
+		"CMPXCHGB R8, (BX)",
+		"CMPXCHGW R8, (BX)",
+		"CMPXCHGL R8, (BX)",
+		"CMPXCHGB SP, (BX)",
+		"CMPXCHGB DL, SP",
+		"CMPXCHG8B SP",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT invalidcmpxchg386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalidcmpxchg386": {Name: "invalidcmpxchg386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which Go 1.27 rejects for 386", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64TrailingZeroCountCompleteGoAssemblerForms(t *testing.T) {
+	// TZCNTW/L/Q all use Go 1.27's ycrc32l table: Yml source, Yrl
+	// destination. The width is selected only by the opcode prefix.
+	src := `
+TEXT trailingzerocountforms(SB),NOSPLIT,$0-0
+	TZCNTW AX, BX
+	TZCNTW (AX), R8
+	TZCNTW R15, R14
+	TZCNTL AX, BX
+	TZCNTL (AX), R8
+	TZCNTL R15, R14
+	TZCNTQ AX, BX
+	TZCNTQ (AX), R8
+	TZCNTQ R15, R14
+	RET
+`
+	ll := x86ScalarCountUnboundFormatObject(t, src, "trailingzerocountforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "trailing-zero-count-forms.ll", "trailing-zero-count-forms.o", ll)
+}
+
+func TestTranslate386TrailingZeroCountCompleteGoAssemblerForms(t *testing.T) {
+	src := `
+TEXT trailingzerocount386forms(SB),NOSPLIT,$0-0
+	TZCNTW AX, BX
+	TZCNTW (AX), CX
+	TZCNTL AX, BX
+	TZCNTL (AX), CX
+	RET
+`
+	ll := x86ScalarCountUnboundFormatObject(t, src, "trailingzerocount386forms", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "trailing-zero-count-386-forms.ll", "trailing-zero-count-386-forms.o", ll)
+
+	invalid, err := Parse(ArchAMD64, "TEXT invalidtrailingzerocount386(SB),NOSPLIT,$0-0\n\tTZCNTQ AX, BX\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(invalid, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"invalidtrailingzerocount386": {Name: "invalidtrailingzerocount386", Ret: Void},
+		},
+	}); err == nil {
+		t.Fatal("Translate accepted TZCNTQ for GOARCH=386")
+	}
+}
+
+func TestTranslateAMD64TrailingZeroCountRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"TZCNTW AL, BX",
+		"TZCNTL AX, AH",
+		"TZCNTQ M1, AX",
+		"TZCNTW X1, AX",
+		"TZCNTL AX, (BX)",
+		"TZCNTQ $1, AX",
+		"TZCNTW.Z AX, BX",
+		"TZCNTL AX, BX, CX",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidtrailingzerocount(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidtrailingzerocount": {Name: "invalidtrailingzerocount", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's TZCNT tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64FloatingCompareCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's legacy yxcmpi table accepts X/m, X0-X15, signed imm8.
+	// The packed AVX _yvcmppd table adds X/Y vector-result VEX forms and
+	// X/Y/Z K-result EVEX forms. EVEX memory sources may use .BCST; only
+	// the Z-register source form may use .SAE. The scalar _yvcmpsd table
+	// has X vector-result VEX forms and X K-result EVEX forms; only the
+	// EVEX register-source form may use .SAE.
+	var src strings.Builder
+	src.WriteString("TEXT floatingcompareforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"CMPPD", "CMPPS", "CMPSD", "CMPSS"} {
+		fmt.Fprintf(&src, "\t%s X1, X15, $-128\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X15, $127\n", op)
+	}
+	for _, op := range []string{"VCMPPD", "VCMPPS"} {
+		fmt.Fprintf(&src, "\t%s $255, X1, X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s $0, (AX), X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s $255, Y1, Y2, Y3\n", op)
+		fmt.Fprintf(&src, "\t%s $0, (AX), Y2, Y3\n", op)
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s $255, %s20, %s21, K0\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s $0, (AX), %s21, K1, K7\n", op, width)
+			fmt.Fprintf(&src, "\t%s.BCST $255, (AX), %s21, K7\n", op, width)
+		}
+		fmt.Fprintf(&src, "\t%s.SAE $255, Z20, Z21, K1, K7\n", op)
+	}
+	for _, op := range []string{"VCMPSD", "VCMPSS"} {
+		fmt.Fprintf(&src, "\t%s $255, X1, X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s $0, (AX), X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s $255, X20, X21, K0\n", op)
+		fmt.Fprintf(&src, "\t%s $0, (AX), X21, K1, K7\n", op)
+		fmt.Fprintf(&src, "\t%s.SAE $255, X20, X21, K1, K7\n", op)
+	}
+	src.WriteString("\tRET\n")
+
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "floatingcompareforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "floating-compare-forms.ll", "floating-compare-forms.o", ll)
+}
+
+func TestTranslate386FloatingCompareCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT floatingcompareforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"CMPPD", "CMPPS", "CMPSD", "CMPSS"} {
+		fmt.Fprintf(&src, "\t%s X1, X7, $-128\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X7, $127\n", op)
+	}
+	src.WriteString("\tRET\n")
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "floatingcompareforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "floating-compare-forms-386.ll", "floating-compare-forms-386.o", ll)
+}
+
+func TestTranslateAMD64FloatingCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"CMPPD X1, X2, $-129",
+		"CMPPS X1, X2, $128",
+		"CMPSD X16, X2, $0",
+		"CMPSS X1, X16, $0",
+		"CMPPD Y1, X2, $0",
+		"CMPPS.BCST (AX), X2, $0",
+		"VCMPPD $-1, X1, X2, X3",
+		"VCMPPS $256, X1, X2, X3",
+		"VCMPSD $0, Y1, X2, X3",
+		"VCMPSS $0, X1, Y2, X3",
+		"VCMPPD $0, X1, X2, Y3",
+		"VCMPPS $0, Y1, Y2, X3",
+		"VCMPPD $0, X20, X21, X22",
+		"VCMPSD $0, X20, X21, X22",
+		"VCMPSS $0, X1, X2, K0, K1",
+		"VCMPPD $0, X1, X2, K0, K1",
+		"VCMPPS.Z $0, Z1, Z2, K1, K2",
+		"VCMPPD.BCST $0, Z1, Z2, K1",
+		"VCMPPS.BCST $0, (AX), X2, X3",
+		"VCMPSD.BCST $0, (AX), X2, K1",
+		"VCMPSS.BCST $0, (AX), X2, K1",
+		"VCMPPD.SAE $0, X1, X2, K1",
+		"VCMPPS.SAE $0, Y1, Y2, K1",
+		"VCMPPD.SAE $0, (AX), Z2, K1",
+		"VCMPSD.SAE $0, (AX), X2, K1",
+		"VCMPSS.SAE $0, X1, X2, X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidfloatingcompare(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidfloatingcompare": {Name: "invalidfloatingcompare", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's CMP/VCMP floating-point tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386FloatingCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"CMPPD X8, X1, $0",
+		"CMPSD X1, X8, $0",
+		"VCMPPD $0, X1, X2, X3",
+		"VCMPSD $0, X1, X2, X3",
+	} {
+		src := "TEXT invalidfloatingcompare386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidfloatingcompare386": {Name: "invalidfloatingcompare386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q for GOARCH=386", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64PackedSaturatingNarrowCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 names the legacy signed dword-to-word instruction PACKSSLW.
+	// PACKSSLW/PACKSSWB/PACKUSWB use ymm (MMX/m64 and X/m128 forms), while
+	// PACKUSDW uses yxm_q4 (X/m128 only). All four V instructions share
+	// _yvandnpd: X/Y VEX plus X/Y/Z EVEX, optional K1-K7 and .Z. Only the
+	// dword-to-word forms enable EVEX 32-bit memory broadcast.
+	var src strings.Builder
+	src.WriteString("TEXT packedsaturatingnarrowforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PACKSSLW", "PACKSSWB", "PACKUSWB"} {
+		fmt.Fprintf(&src, "\t%s M1, M7\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), M7\n", op)
+		fmt.Fprintf(&src, "\t%s X1, X15\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X15\n", op)
+	}
+	src.WriteString("\tPACKUSDW X1, X15\n\tPACKUSDW (AX), X15\n")
+	for _, op := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		fmt.Fprintf(&src, "\t%s X1, X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s Y1, Y2, Y3\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y2, Y3\n", op)
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s %s20, %s21, %s22\n", op, width, width, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s21, K1, %s22\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.Z %s20, %s21, K7, %s22\n", op, width, width, width)
+		}
+	}
+	for _, op := range []string{"VPACKSSDW", "VPACKUSDW"} {
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s.BCST (AX), %s21, %s22\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), %s21, K1, %s22\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST.Z (AX), %s21, K7, %s22\n", op, width, width)
+		}
+	}
+	src.WriteString("\tRET\n")
+
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedsaturatingnarrowforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-saturating-narrow-forms.ll", "packed-saturating-narrow-forms.o", ll)
+}
+
+func TestTranslate386PackedSaturatingNarrowCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT packedsaturatingnarrowforms386(SB),4,$0-0\n")
+	for _, op := range []string{"PACKSSLW", "PACKSSWB", "PACKUSWB"} {
+		fmt.Fprintf(&src, "\t%s X1, X7\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X7\n", op)
+	}
+	src.WriteString("\tPACKUSDW X1, X7\n\tPACKUSDW (AX), X7\n")
+	for _, op := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s %s1,%s2,%s3\n", op, bank, bank, bank)
+			fmt.Fprintf(&src, "\t%s (AX),%s2,%s3\n", op, bank, bank)
+			if op == "VPACKSSDW" || op == "VPACKUSDW" {
+				fmt.Fprintf(&src, "\t%s.BCST (AX),%s2,%s3\n", op, bank, bank)
+			}
+		}
+	}
+	src.WriteString("\tRET\n")
+	goAssemblerOracleOutput(t, "386", src.String(), "", true)
+	ll := x86UnboundVoidScalarFormatObject(t, src.String(), "packedsaturatingnarrowforms386", "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-saturating-narrow-forms-386.ll", "packed-saturating-narrow-forms-386.o", ll)
+}
+
+func TestTranslateAMD64PackedSaturatingNarrowRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PACKSSLW M1, X2",
+		"PACKSSWB X1, M2",
+		"PACKUSDW M1, M2",
+		"PACKUSWB X16, X1",
+		"PACKSSLW X1, X16",
+		"PACKSSWB.Z X1, X2",
+		"PACKUSWB X1, X2, X3",
+		"VPACKSSDW X1, X2",
+		"VPACKSSWB X1, Y2, Y3",
+		"VPACKUSDW Y1, Y2, X3",
+		"VPACKUSWB Z1, Z2, Y3",
+		"VPACKSSDW X1, X2, K0, X3",
+		"VPACKSSWB.Z X1, X2, X3",
+		"VPACKUSDW.BCST X1, X2, X3",
+		"VPACKUSWB.BCST (AX), X2, X3",
+		"VPACKSSWB.BCST.Z (AX), X2, K1, X3",
+		"VPACKSSDW.SAE X1, X2, X3",
+		"VPACKUSWB X1, X2, K1",
+		"VPACKUSDW X1, (AX), X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidpackedsaturatingnarrow(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedsaturatingnarrow": {Name: "invalidpackedsaturatingnarrow", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PACK/VPACK tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedSaturatingNarrowRejectsVectorForms(t *testing.T) {
+	for _, op := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		for _, row := range []string{op + " X1,X2,K1,X3", op + ".Z Z1,Z2,K1,Z3", op + " Z1,Z2,Z8"} {
+			t.Run(row, func(t *testing.T) {
+				source := "TEXT invalidpackedsaturatingnarrow386(SB),4,$0-0\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{TargetTriple: "i386-unknown-linux-gnu", Goarch: "386",
+					Sigs: map[string]FuncSig{"invalidpackedsaturatingnarrow386": {Name: "invalidpackedsaturatingnarrow386", Ret: Void}},
+				}); err == nil {
+					t.Fatal("Go-rejected mode32 pack syntax acquired successful lowering")
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateAMD64VariableDwordPermuteCompleteGoAssemblerForms(t *testing.T) {
+	// VPERMD and VPERMPS share Go 1.27's _yvpermd table: Y-only VEX,
+	// Y/Z EVEX, optional K1-K7 and .Z, plus 32-bit memory broadcast.
+	var src strings.Builder
+	src.WriteString("TEXT variabledwordpermuteforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VPERMD", "VPERMPS"} {
+		fmt.Fprintf(&src, "\t%s Y1, Y2, Y3\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Y2, Y3\n", op)
+		for _, width := range []string{"Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s %s20, %s21, %s22\n", op, width, width, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s21, K1, %s22\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.Z %s20, %s21, K7, %s22\n", op, width, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST (AX), %s21, %s22\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST.Z (AX), %s21, K7, %s22\n", op, width, width)
+		}
+	}
+	src.WriteString("\tRET\n")
+
+	ll := x86ElementPermuteUnboundFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu", 24, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "variable-dword-permute-forms.ll", "variable-dword-permute-forms.o", ll)
+}
+
+func TestTranslateAMD64VariableDwordPermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMD X1, X2, X3",
+		"VPERMPS Y1, Z2, Z3",
+		"VPERMD Z1, Z2, Y3",
+		"VPERMPS Y1, (AX), Y3",
+		"VPERMD Y1, Y2, K0, Y3",
+		"VPERMPS.Z Y1, Y2, Y3",
+		"VPERMD.BCST Y1, Y2, Y3",
+		"VPERMPS.BCST.Z (AX), Z2, Z3",
+		"VPERMD.SAE Y1, Y2, Y3",
+		"VPERMPS Y1, Y2, K1",
+		"VPERMD Y1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidvariabledwordpermute(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidvariabledwordpermute": {Name: "invalidvariabledwordpermute", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's VPERMD/VPERMPS table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386VariableDwordPermuteCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT variabledwordpermuteforms386(SB),$0-0\n")
+	for _, op := range []string{"VPERMD", "VPERMPS"} {
+		fmt.Fprintf(&source, "\t%s Y1, Y2, Y3\n", op)
+		fmt.Fprintf(&source, "\t%s (AX), Y2, Y3\n", op)
+		fmt.Fprintf(&source, "\t%s Y31, Y30, Y29\n", op)
+		fmt.Fprintf(&source, "\t%s Z7, Z6, Z5\n", op)
+		fmt.Fprintf(&source, "\t%s.BCST (AX), Y30, Y29\n", op)
+		fmt.Fprintf(&source, "\t%s.BCST (AX), Z6, Z5\n", op)
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "linux", triple: "i386-unknown-linux-gnu"},
+		{name: "windows", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			ll := x86ElementPermuteUnboundFormatObject(t, source.String(), "386", target.triple, 8, 4)
+			compileLLVMToObject(t, llc, target.triple, "variable-dword-permute-forms-386-"+target.name+".ll", "variable-dword-permute-forms-386-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslate386VariableDwordPermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMD Z8, Z0, Z1",
+		"VPERMPS Z0, Z8, Z1",
+		"VPERMD Z0, Z1, Z8",
+		"VPERMD Y1, Y2, K1, Y3",
+		"VPERMPS.Z Y1, Y2, K1, Y3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's 386 VPERMD/VPERMPS table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ConditionalSetCompleteGoAssemblerForms(t *testing.T) {
+	conditions := []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"}
+	var src strings.Builder
+	src.WriteString("TEXT conditionalsetforms(SB),NOSPLIT,$0-1\n")
+	for _, condition := range conditions {
+		op := "SET" + condition
+		fmt.Fprintf(&src, "\t%s R15\n", op)
+		fmt.Fprintf(&src, "\t%s AH\n", op)
+		fmt.Fprintf(&src, "\t%s BPB\n", op)
+		fmt.Fprintf(&src, "\t%s R15B\n", op)
+		fmt.Fprintf(&src, "\t%s (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s conditionalSetGlobal(SB)\n", op)
+		fmt.Fprintf(&src, "\t%s ret+0(FP)\n", op)
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"conditionalsetforms": {
+				Name: "conditionalsetforms",
+				Ret:  I8,
+				Frame: FrameLayout{Results: []FrameSlot{{
+					Offset: 0,
+					Type:   I8,
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+		},
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ll != "" {
+		t.Fatal("original format-only SETcc source invented FLAGS or a native address", err)
+	}
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+src.String(), "", true)
+	ll = x86ConditionalSetOriginalEmitterUnit(t, file, "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "conditional-set-forms.ll", "conditional-set-forms.o", ll)
+}
+
+func TestTranslate386ConditionalSetCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT conditionalsetforms386(SB),NOSPLIT,$0-1\n")
+	for _, condition := range []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"} {
+		op := "SET" + condition
+		fmt.Fprintf(&src, "\t%s DX\n", op)
+		fmt.Fprintf(&src, "\t%s AH\n", op)
+		fmt.Fprintf(&src, "\t%s BP\n", op)
+		fmt.Fprintf(&src, "\t%s SI\n", op)
+		fmt.Fprintf(&src, "\t%s DI\n", op)
+		fmt.Fprintf(&src, "\t%s (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s ret+0(FP)\n", op)
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"conditionalsetforms386": {
+				Name: "conditionalsetforms386",
+				Ret:  I8,
+				Frame: FrameLayout{Results: []FrameSlot{{
+					Offset: 0,
+					Type:   I8,
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+		},
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ll != "" {
+		t.Fatal("original format-only SETcc source invented FLAGS or a native address", err)
+	}
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+src.String(), "", true)
+	ll = x86ConditionalSetOriginalEmitterUnit(t, file, "386", "i386-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "conditional-set-forms-386.ll", "conditional-set-forms-386.o", ll)
+}
+
+func TestTranslateAMD64ConditionalSetRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"SETNE X1",
+		"SETLE M1",
+		"SETEQ K1",
+		"SETCC $1",
+		"SETGT",
+		"SETGE AX, BX",
+		"SETHI.Z AX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidconditionalset(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidconditionalset": {Name: "invalidconditionalset", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's SETcc tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386ConditionalSetRejectsArchitectureRestrictedRegisters(t *testing.T) {
+	for _, register := range []string{"SP", "R8"} {
+		file, err := Parse(ArchAMD64, "TEXT invalidconditionalset386(SB),NOSPLIT,$0-0\n\tSETNE "+register+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidconditionalset386": {Name: "invalidconditionalset386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted SETNE %s for GOARCH=386", register)
+		}
+	}
+}
+
+func TestTranslateAMD64VectorScalarMoveCompleteGoAssemblerForms(t *testing.T) {
+	// VMOVSD and VMOVSS share Go 1.27's _yvmovsd table. It contains VEX
+	// scalar register-to-memory, memory-to-register, and three-register merge
+	// forms plus their EVEX high-register and optional K-mask counterparts.
+	// Zeroing is valid only for masked register destinations.
+	var src strings.Builder
+	src.WriteString("TEXT vectorscalarmoveforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VMOVSD", "VMOVSS"} {
+		fmt.Fprintf(&src, "\t%s X1, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X1\n", op)
+		fmt.Fprintf(&src, "\t%s X1, X2, X3\n", op)
+		fmt.Fprintf(&src, "\t%s X20, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s X20, K1, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X20\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), K1, X20\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K7, X20\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X21, X22\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X21, K1, X22\n", op)
+		fmt.Fprintf(&src, "\t%s.Z X20, X21, K7, X22\n", op)
+	}
+	src.WriteString("\tRET\n")
+
+	ll := x86UnboundVoidVectorMoveFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "vector-scalar-move-forms.ll", "vector-scalar-move-forms.o", ll)
+}
+
+func TestTranslateAMD64VectorScalarMoveFrameSources(t *testing.T) {
+	src := `
+TEXT vmovsdframe(SB),NOSPLIT,$0-8
+	VMOVSD value+0(FP), X0
+	RET
+TEXT vmovssframe(SB),NOSPLIT,$0-4
+	VMOVSS value+0(FP), X0
+	RET
+TEXT vmovsdframeresult(SB),NOSPLIT,$0-8
+	VMOVSD X0, value+0(FP)
+	RET
+TEXT vmovssframeresult(SB),NOSPLIT,$0-4
+	VMOVSS X0, value+0(FP)
+	RET
+`
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"vmovsdframe": {
+				Name: "vmovsdframe",
+				Args: []LLVMType{LLVMType("double")},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{{
+					Offset: 0,
+					Type:   LLVMType("double"),
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+			"vmovssframe": {
+				Name: "vmovssframe",
+				Args: []LLVMType{LLVMType("float")},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{{
+					Offset: 0,
+					Type:   LLVMType("float"),
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+			"vmovsdframeresult": {
+				Name: "vmovsdframeresult",
+				Ret:  LLVMType("double"),
+				Frame: FrameLayout{Results: []FrameSlot{{
+					Offset: 0,
+					Type:   LLVMType("double"),
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+			"vmovssframeresult": {
+				Name: "vmovssframeresult",
+				Ret:  LLVMType("float"),
+				Frame: FrameLayout{Results: []FrameSlot{{
+					Offset: 0,
+					Type:   LLVMType("float"),
+					Index:  0,
+					Field:  -1,
+				}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "vector-scalar-move-frame.ll", "vector-scalar-move-frame.o", ll)
+}
+
+func TestTranslateAMD64VectorScalarMoveRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVSD X1, X2",
+		"VMOVSS (AX), (BX)",
+		"VMOVSD Y1, X2, X3",
+		"VMOVSS X1, Y2, X3",
+		"VMOVSD X1, X2, Y3",
+		"VMOVSS X1, X2, (AX)",
+		"VMOVSD (AX), K0, X1",
+		"VMOVSS X1, K0, (AX)",
+		"VMOVSD X1, X2, K0, X3",
+		"VMOVSS.Z (AX), X1",
+		"VMOVSD.Z X1, K1, (AX)",
+		"VMOVSS.Z X1, X2, X3",
+		"VMOVSD.BCST (AX), X1",
+		"VMOVSS.SAE X1, X2, X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalidvectorscalarmove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", strings.ReplaceAll(src, "NOSPLIT", "4"), false)
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidvectorscalarmove": {Name: "invalidvectorscalarmove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's VMOVSD/VMOVSS table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386VectorScalarMoveRejectsForms(t *testing.T) {
+	for _, op := range []string{"VMOVSD", "VMOVSS"} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),4,$0-0\n"+op+" X0, X1, K1, X2\nRET\n", false)
+		file, err := Parse(ArchAMD64, "TEXT invalidvectorscalarmove386(SB),NOSPLIT,$0-0\n\t"+op+" X0, X1, K1, X2\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalidvectorscalarmove386": {Name: "invalidvectorscalarmove386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %s for GOARCH=386", op)
+		}
+	}
+}
+
+func TestTranslateX86VectorScalarFlagCompareCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 gives VCOMISD/VCOMISS/VUCOMISD/VUCOMISS the shared
+	// _yvcomisd table. It has exactly two rows: VEX X/m,X and EVEX X/m,X.
+	// EVEX permits X0-X31 and .SAE for register sources; it does not permit
+	// masks, zeroing, broadcast, or vector widths other than X. Go's 386
+	// assembler exposes the same two rows, including the EVEX register class.
+	var src strings.Builder
+	src.WriteString("TEXT vectorscalarflagcompareforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VCOMISD", "VCOMISS", "VUCOMISD", "VUCOMISS"} {
+		fmt.Fprintf(&src, "\t%s X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X2\n", op)
+		fmt.Fprintf(&src, "\t%s X20, X2\n", op)
+		fmt.Fprintf(&src, "\t%s X1, X21\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), X21\n", op)
+		fmt.Fprintf(&src, "\t%s.SAE X1, X2\n", op)
+		fmt.Fprintf(&src, "\t%s.SAE X20, X21\n", op)
+	}
+	src.WriteString("\tRET\n")
+	// Named Go frontend compatibility includes high X registers even on
+	// 386; raw architectural 32-bit decoding has stricter register limits.
+	for _, arch := range []string{"386", "amd64"} {
+		assembleX87ControlBytes(t, arch, strings.ReplaceAll(src.String(), "NOSPLIT", "4"))
+	}
+
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-macosx"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, src.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"vectorscalarflagcompareforms": {Name: "vectorscalarflagcompareforms", Ret: Void},
+				},
+			})
+			if target.goarch == "386" {
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 high-X") {
+					t.Fatalf("source-accepted high banks lack a physical 386 register binding: %v", err)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original named COMI formats invented their missing inputs", err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			ir := x86COMIOriginalFormatObject(t, src.String(), target.goarch, target.triple)
+			x86COMICompileOriginalFormatObjects(t, llc, target.triple, "vector-scalar-flag-compare-"+target.goarch, ir)
+		})
+	}
+}
+
+func TestTranslateX86VectorScalarFlagCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			for _, instruction := range []string{
+				"VCOMISD",
+				"VCOMISS X1",
+				"VUCOMISD X1, X2, X3",
+				"VUCOMISS Y1, X2",
+				"VCOMISD X1, Y2",
+				"VCOMISS Z1, X2",
+				"VUCOMISD K1, X2",
+				"VUCOMISS X1, (AX)",
+				"VCOMISD $1, X2",
+				"VCOMISS.SAE (AX), X2",
+				"VUCOMISD.BCST (AX), X2",
+				"VUCOMISS.Z X1, X2",
+				"VCOMISD X1, K1, X2",
+			} {
+				t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+					src := "TEXT invalidvectorscalarflagcompare(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+					file, err := Parse(ArchAMD64, src)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := Translate(file, Options{
+						TargetTriple: target.triple,
+						Goarch:       target.goarch,
+						Sigs: map[string]FuncSig{
+							"invalidvectorscalarflagcompare": {Name: "invalidvectorscalarflagcompare", Ret: Void},
+						},
+					}); err == nil {
+						t.Fatalf("Translate accepted %q for %s, which is absent from Go 1.27's _yvcomisd table", instruction, target.goarch)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64AdditionalPackedIntegerFamilies(t *testing.T) {
+	src := `
+TEXT packedintegerfamilies(SB),NOSPLIT,$0-0
+	PADDB X0, X1
+	PCMPEQW X0, X1
+	PMULLW X0, X1
+	PABSD X0, X1
+	PSUBUSB X0, X1
+	PTEST X0, X1
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedintegerfamilies", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-integer-formats.ll", "packed-integer-formats.o", ll)
+}
+
+func TestTranslateAMD64AdditionalConditionalMoveWidths(t *testing.T) {
+	src := `
+TEXT conditionalmoves(SB),NOSPLIT,$0-0
+	CMPQ AX, BX
+	CMOVQLE CX, DX
+	CMOVLGT CX, DX
+	CMOVWCC CX, DX
+	RET
+`
+	ir := x86UnboundVoidScalarFormatObject(t, src, "conditionalmoves", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "conditional-move-formats.ll", "conditional-move-formats.o", ir)
+}
+
+func TestTranslateAMD64LegacyScalarAndPackedFloatingPointFamilies(t *testing.T) {
+	src := `
+TEXT floatfamilies(SB),NOSPLIT,$0-0
+	MOVSS (AX), X0
+	SQRTSS X0, X1
+	ADDSS X0, X1
+	SUBSS X0, X1
+	MULSS X0, X1
+	DIVSS X0, X1
+	MINSS X0, X1
+	MAXSS X0, X1
+	MOVSS X1, (BX)
+	MOVUPD (AX), X2
+	MOVAPD X2, (BX)
+	MOVUPD X2, 16(BX)
+	XORPD X2, X3
+	ANDPS X2, X3
+	ADDPS X2, X3
+	SUBPS X2, X3
+	MULPS X2, X3
+	DIVPS X2, X3
+	MINPS X2, X3
+	MAXPS X2, X3
+	SQRTPS X2, X3
+	ADDPD X2, X3
+	SUBPD X2, X3
+	MULPD X2, X3
+	DIVPD X2, X3
+	MINPD X2, X3
+	MAXPD X2, X3
+	SQRTPD X2, X3
+	MOVLHPS X2, X3
+	MOVHLPS X2, X3
+	MOVLPD (AX), X3
+	MOVLPD X3, (BX)
+	MOVHPD (AX), X3
+	MOVHPD X3, (BX)
+	SHUFPD $1, X2, X3
+	UNPCKLPS X2, X3
+	UNPCKHPD X2, X3
+	MOVDDUP X2, X3
+	HADDPD X2, X3
+	HADDPD (AX), X3
+	HADDPS X2, X3
+	HADDPS (AX), X3
+	CVTSS2SD X2, X3
+	CVTSS2SD (AX), X3
+	CVTSD2SS X2, X3
+	CVTSD2SS (AX), X3
+	UCOMISS X2, X3
+	UCOMISD X2, X3
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "floatfamilies", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "legacy-floating-formats.ll", "legacy-floating-formats.o", ll)
+}
+
+func TestTranslateAMD64DuplicateMoveFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's legacy yxm table accepts X/m -> X for MOVDDUP,
+	// MOVSHDUP, and MOVSLDUP. Its shared _yvmovddup table accepts
+	// X/m -> X, Y/m -> Y, and Z/m -> Z for all three V-prefixed forms,
+	// with optional K masking (and .Z zero masking) on EVEX forms.
+	src := `
+TEXT duplicatemoveforms(SB),NOSPLIT,$0-8
+	MOVDDUP X1, X2
+	MOVDDUP (AX), X2
+	MOVDDUP source(SB), X2
+	MOVDDUP alpha+0(FP), X2
+	MOVSHDUP X1, X2
+	MOVSHDUP (AX), X2
+	MOVSHDUP source(SB), X2
+	MOVSLDUP X1, X2
+	MOVSLDUP (AX), X2
+	MOVSLDUP source(SB), X2
+	VMOVDDUP X1, X2
+	VMOVDDUP (AX), X2
+	VMOVDDUP Y1, Y2
+	VMOVDDUP (AX), Y2
+	VMOVDDUP X16, X17
+	VMOVDDUP X16, K1, X17
+	VMOVDDUP.Z (AX), K1, X17
+	VMOVDDUP Y16, Y17
+	VMOVDDUP Y16, K1, Y17
+	VMOVDDUP.Z (AX), K1, Y17
+	VMOVDDUP Z1, Z2
+	VMOVDDUP Z1, K1, Z2
+	VMOVDDUP.Z source(SB), K1, Z2
+	VMOVSHDUP X1, X2
+	VMOVSHDUP (AX), X2
+	VMOVSHDUP Y1, Y2
+	VMOVSHDUP (AX), Y2
+	VMOVSHDUP X16, X17
+	VMOVSHDUP X16, K1, X17
+	VMOVSHDUP.Z (AX), K1, X17
+	VMOVSHDUP Y16, Y17
+	VMOVSHDUP Y16, K1, Y17
+	VMOVSHDUP.Z (AX), K1, Y17
+	VMOVSHDUP Z1, Z2
+	VMOVSHDUP Z1, K1, Z2
+	VMOVSHDUP.Z source(SB), K1, Z2
+	VMOVSLDUP X1, X2
+	VMOVSLDUP (AX), X2
+	VMOVSLDUP Y1, Y2
+	VMOVSLDUP (AX), Y2
+	VMOVSLDUP X16, X17
+	VMOVSLDUP X16, K1, X17
+	VMOVSLDUP.Z (AX), K1, X17
+	VMOVSLDUP Y16, Y17
+	VMOVSLDUP Y16, K1, Y17
+	VMOVSLDUP.Z (AX), K1, Y17
+	VMOVSLDUP Z1, Z2
+	VMOVSLDUP Z1, K1, Z2
+	VMOVSLDUP.Z source(SB), K1, Z2
+	RET
+`
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures := map[string]FuncSig{"duplicatemoveforms": {
+		Name: "duplicatemoveforms",
+		Args: []LLVMType{LLVMType("double")},
+		Ret:  Void,
+		Frame: FrameLayout{Params: []FrameSlot{{
+			Offset: 0,
+			Type:   LLVMType("double"),
+			Index:  0,
+			Field:  -1,
+		}}},
+	}}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", "#include \"textflag.h\"\n"+src)
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, src, "func duplicatemoveforms(alpha float64)", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("original format table invented its missing register/address/mask inputs", api, err)
+		}
+	}
+	ir := x86DuplicateMoveFormatObjectUnit(t, file, signatures, "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "duplicate-formats.ll", "duplicate-formats.o", ir)
+}
+
+func TestTranslateAMD64DuplicateMoveFamilyRejectsFormsOutsideGoOptabs(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVSHDUP Y1, Y2",
+		"MOVSLDUP.Z X1, X2",
+		"VMOVSHDUP X1, Y2",
+		"VMOVSLDUP.Z X1, X2",
+		"VMOVDDUP.Z.Z X1, K1, X2",
+		"VMOVDDUP X1, K0, X2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidduplicatemove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidduplicatemove": {Name: "invalidduplicatemove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's yxm/_yvmovddup tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedDwordMultiplyFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses yxm_q4 for PMULLD (X/m, X) and _yvandnpd for
+	// VPMULLD. The latter has VEX X/Y forms plus EVEX X/Y/Z forms with
+	// optional K1-K7 masking, .Z zero masking, and memory-only .BCST.
+	src := `
+TEXT packeddwordmultiplyforms(SB),NOSPLIT,$0-0
+	PMULLD X1, X2
+	PMULLD (AX), X2
+	PMULLD source(SB), X2
+	VPMULLD X1, X2, X3
+	VPMULLD (AX), X2, X3
+	VPMULLD Y1, Y2, Y3
+	VPMULLD (AX), Y2, Y3
+	VPMULLD X16, X17, X18
+	VPMULLD X16, X17, K1, X18
+	VPMULLD.Z (AX), X17, K1, X18
+	VPMULLD Y16, Y17, Y18
+	VPMULLD Y16, Y17, K1, Y18
+	VPMULLD.Z (AX), Y17, K1, Y18
+	VPMULLD Z1, Z2, Z3
+	VPMULLD Z1, Z2, K1, Z3
+	VPMULLD.Z source(SB), Z2, K1, Z3
+	VPMULLD.BCST (AX), X17, X18
+	VPMULLD.BCST (AX), Y17, K1, Y18
+	VPMULLD.BCST.Z source(SB), Z2, K1, Z3
+	RET
+`
+	translateAMD64EcosystemCase(t, src, "packeddwordmultiplyforms")
+}
+
+func TestTranslateAMD64PackedDwordMultiplyFamilyRejectsFormsOutsideGoOptabs(t *testing.T) {
+	for _, instruction := range []string{
+		"PMULLD Y1, Y2",
+		"VPMULLD X1, Y2, Y3",
+		"VPMULLD X1, X2, K0, X3",
+		"VPMULLD.Z X1, X2, X3",
+		"VPMULLD.BCST X1, X2, K1, X3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackeddwordmultiply(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackeddwordmultiply": {Name: "invalidpackeddwordmultiply", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PMULLD/VPMULLD tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64MXCSRStateFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's ysvrs_mo/ysvrs_om and _yvldmxcsr tables give all four
+	// instructions exactly one m32 operand. Syntax is not storage authority:
+	// exercise bounded initialized AUTO, actual typed FP and emitted DATA.
+	// Native pointers and static stores retain separate negative controls.
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86MXCSRBoundMemoryForms(t, target.arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("complete initialized MXCSR storage: %v", err)
+					}
+					if row.local && !strings.Contains(ir, "%local_stack = alloca") {
+						t.Fatal("bounded AUTO operand lost byte-addressable local storage")
+					}
+					if !strings.Contains(ir, row.intrinsic) {
+						t.Fatalf("MXCSR lowering omitted %s", row.intrinsic)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateAMD64MXCSRStateFamilyRejectsNonMemoryForms(t *testing.T) {
+	for _, instruction := range []string{
+		"LDMXCSR AX",
+		"VLDMXCSR $1",
+		"STMXCSR X1",
+		"VSTMXCSR.Z (AX)",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidmxcsrstate(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidmxcsrstate": {Name: "invalidmxcsrstate", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, but Go's MXCSR tables require one memory operand", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedFloatToDwordFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's yxcvm1 table gives both instructions X/m -> X and X/m -> M.
+	// An X destination consumes four float32 lanes; an MMX destination consumes
+	// two lanes (and therefore only 64 bits for a memory source).
+	src := `
+TEXT packedfloattodwordforms(SB),NOSPLIT,$0-0
+	CVTPS2PL X1, X2
+	CVTPS2PL (AX), X2
+	CVTPS2PL source(SB), X2
+	CVTTPS2PL X1, X2
+	CVTTPS2PL (AX), X2
+	CVTTPS2PL source(SB), X2
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, src, "packedfloattodwordforms", "amd64", "x86_64-unknown-linux-gnu")
+	for _, intrinsic := range []string{"asm sideeffect \"cvtps2dq", "asm sideeffect \"cvttps2dq"} {
+		if !strings.Contains(ll, intrinsic) {
+			t.Fatalf("packed float-to-dword lowering omitted %s", intrinsic)
+		}
+	}
+}
+
+func TestTranslateAMD64PackedFloatToDwordFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTPS2PL Y1, X2",
+		"CVTPS2PL X1, Y2",
+		"CVTPS2PL $1, X2",
+		"CVTTPS2PL.Z X1, X2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedfloattodword(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedfloattodword": {Name: "invalidpackedfloattodword", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's yxcvm1 table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ConditionalMoveFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 has 48 entries sharing yml_rl: W/L/Q width crossed with all
+	// 16 x86 condition codes. Yml accepts a same-width GP register or memory;
+	// Yrl requires a GP register destination. Exercise both source categories
+	// and both ordinary and extended registers for every instruction.
+	conditions := []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"}
+	var src strings.Builder
+	src.WriteString("TEXT conditionalmoveforms(SB),NOSPLIT,$0-8\n")
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, condition := range conditions {
+			op := "CMOV" + width + condition
+			fmt.Fprintf(&src, "\t%s CX, DX\n", op)
+			fmt.Fprintf(&src, "\t%s (R10), R11\n", op)
+		}
+	}
+	src.WriteString("\tCMOVQPS source(SB), R10\n")
+	src.WriteString("\tCMOVQPS input+0(FP), R9\n")
+	src.WriteString("\tRET\n")
+
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{"conditionalmoveforms": {
+			Name: "conditionalmoveforms",
+			Args: []LLVMType{I64},
+			Ret:  Void,
+			Frame: FrameLayout{Params: []FrameSlot{{
+				Offset: 0, Type: I64, Index: 0, Field: -1,
+			}}},
+		}},
+	}
+	// All original register and native memory rows remain format witnesses,
+	// not initialized public programs. Keep the actual FP input declaration.
+	original := strings.Replace(src.String(), "TEXT conditionalmoveforms", "TEXT ·conditionalmoveforms", 1)
+	x86LEAActualTargetGoObject(t, "amd64", options.TargetTriple, "#include \"textflag.h\"\n"+original)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, original,
+			"func conditionalmoveforms(input uint64)\n", "amd64", options.TargetTriple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("uninitialized CMOV data/address/predicate became public input", api, err)
+		}
+	}
+	ir := x86ScalarFormatObjectUnit(t, file, options.Sigs, "amd64", options.TargetTriple, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	compileLLVMToObject(t, llc, options.TargetTriple, "cmov-original-formats.ll", "cmov-original-formats.o", ir)
+}
+
+func TestTranslateAMD64ConditionalMoveFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"CMOVQPS $1, AX",
+		"CMOVQPS AX, (BX)",
+		"CMOVQPS X1, AX",
+		"CMOVQPS.Z AX, BX",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidconditionalmove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidconditionalmove": {Name: "invalidconditionalmove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, but Go 1.27's yml_rl requires register/memory source and register destination", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64PackedSingleToDoubleFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's legacy yxm entry is X/m64 -> X. The VCVTPS2PD
+	// _yvcvtph2ps table adds X/m64 -> X, X/m128 -> Y, and Y/m256 -> Z,
+	// with EVEX masks/zeroing, memory broadcast, and SAE on the Z form.
+	src := `
+TEXT packedsingletodoubleforms(SB),NOSPLIT,$0-0
+	CVTPS2PD X1, X2
+	CVTPS2PD (AX), X2
+	CVTPS2PD source(SB), X2
+	VCVTPS2PD X1, X2
+	VCVTPS2PD (AX), X2
+	VCVTPS2PD X16, X17
+	VCVTPS2PD X16, K1, X17
+	VCVTPS2PD.Z (AX), K7, X17
+	VCVTPS2PD.BCST (AX), X17
+	VCVTPS2PD.BCST.Z source(SB), K1, X17
+	VCVTPS2PD X1, Y2
+	VCVTPS2PD (AX), Y2
+	VCVTPS2PD X16, Y17
+	VCVTPS2PD X16, K1, Y17
+	VCVTPS2PD.Z (AX), K7, Y17
+	VCVTPS2PD.BCST (AX), Y17
+	VCVTPS2PD.BCST.Z source(SB), K1, Y17
+	VCVTPS2PD Y1, Z2
+	VCVTPS2PD (AX), Z2
+	VCVTPS2PD Y16, Z17
+	VCVTPS2PD Y16, K1, Z17
+	VCVTPS2PD.Z (AX), K7, Z17
+	VCVTPS2PD.BCST (AX), Z17
+	VCVTPS2PD.BCST.Z source(SB), K1, Z17
+	VCVTPS2PD.SAE Y16, Z17
+	VCVTPS2PD.SAE.Z Y16, K1, Z17
+	RET
+`
+	// This original complete format inventory has no vector/address/mask
+	// producers. Keep its actual Go object and all three public Context results;
+	// private format objects do not replace the initialized 53-row public matrix.
+	ll := x86PackedPrecisionOriginalFormatObject(t, src, "packedsingletodoubleforms",
+		"amd64", "x86_64-unknown-linux-gnu", false, 26, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-single-to-double.ll", "packed-single-to-double.o", ll)
+}
+
+func TestTranslateAMD64PackedSingleToDoubleFamilyRejectsFormsOutsideGoOptabs(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTPS2PD Y1, X2",
+		"CVTPS2PD.Z X1, X2",
+		"VCVTPS2PD Y1, Y2",
+		"VCVTPS2PD X1, Z2",
+		"VCVTPS2PD Z1, Z2",
+		"VCVTPS2PD X1, K0, X2",
+		"VCVTPS2PD.Z X1, X2",
+		"VCVTPS2PD.BCST X1, X2",
+		"VCVTPS2PD.SAE (AX), Z2",
+		"VCVTPS2PD.SAE X1, X2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidpackedsingletodouble(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalidpackedsingletodouble": {Name: "invalidpackedsingletodouble", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's CVTPS2PD/VCVTPS2PD tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64ComplexFrameBitwiseMoveForms(t *testing.T) {
+	// MOVSD and MOVUPS retain their ordinary yxmov X/m<->X formats when the
+	// memory operand names a complex64 or complex128 value in the Go FP frame.
+	src := `
+TEXT complexframemoves(SB),NOSPLIT,$0-48
+	MOVSD input64+0(FP), X0
+	MOVSD X0, result64+24(FP)
+	MOVUPS input128+8(FP), X1
+	MOVUPS X1, result128+32(FP)
+	RET
+`
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"complexframemoves": {
+				Name: "complexframemoves",
+				Args: []LLVMType{"{ float, float }", "{ double, double }"},
+				Ret:  LLVMType("{ float, float, double, double }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: LLVMType("float"), Index: 0, Field: 0},
+						{Offset: 4, Type: LLVMType("float"), Index: 0, Field: 1},
+						{Offset: 8, Type: LLVMType("double"), Index: 1, Field: 0},
+						{Offset: 16, Type: LLVMType("double"), Index: 1, Field: 1},
+					},
+					Results: []FrameSlot{
+						{Offset: 24, Type: LLVMType("float"), Index: 0, Field: -1},
+						{Offset: 28, Type: LLVMType("float"), Index: 1, Field: -1},
+						{Offset: 32, Type: LLVMType("double"), Index: 2, Field: -1},
+						{Offset: 40, Type: LLVMType("double"), Index: 3, Field: -1},
+					},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "complex-frame-moves.ll", "complex-frame-moves.o", ll)
+}
+
+func TestTranslateAMD64WritableFPParameterSlots(t *testing.T) {
+	// Go's assembler gives named FP parameter slots mutable frame semantics.
+	// Real assembly such as Gonum's GEMV kernels advances a slice base pointer
+	// by writing it back to base+off(FP), then reads the updated value later.
+	src := `
+TEXT writablefpparam(SB),NOSPLIT,$0-16
+body:
+	MOVQ input+0(FP), AX
+	ADDQ $8, AX
+	MOVQ AX, input+0(FP)
+	MOVQ input+0(FP), BX
+	MOVQ BX, result+8(FP)
+	RET
+`
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"writablefpparam": {
+				Name: "writablefpparam",
+				Args: []LLVMType{Ptr},
+				Ret:  Ptr,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: Ptr, Index: 0, Field: -1}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, "%fp_arg_0 = alloca ptr") {
+		t.Fatalf("writable FP parameter did not receive mutable shadow storage:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "writable-fp-param.ll", "writable-fp-param.o", ll)
+}
+
+func TestTranslateAMD64ConditionalBranchAliasFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Keep this list aligned with the x86 aliases installed by
+	// cmd/asm/internal/arch.archX86 in Go 1.27. Every conditional branch uses
+	// yjcond: target, $0+target, and $1+target.
+	aliases := []string{
+		"JA", "JAE", "JB", "JBE", "JC", "JCC", "JCS",
+		"JE", "JEQ", "JG", "JGE", "JGT", "JHI", "JHS",
+		"JL", "JLE", "JLO", "JLS", "JLT", "JMI", "JNA",
+		"JNAE", "JNB", "JNBE", "JNC", "JNE", "JNG", "JNGE",
+		"JNL", "JNLE", "JNO", "JNP", "JNS", "JNZ", "JO",
+		"JOC", "JOS", "JP", "JPC", "JPE", "JPL", "JPO",
+		"JPS", "JS", "JZ",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT conditionalbranchaliases(SB),NOSPLIT,$0-0\n")
+	src.WriteString("\tUCOMISD X0, X1\n")
+	for i, alias := range aliases {
+		for hint := -1; hint <= 1; hint++ {
+			label := fmt.Sprintf("branch_alias_%d_%d", i, hint+1)
+			if hint < 0 {
+				fmt.Fprintf(&src, "\t%s %s\n", alias, label)
+			} else {
+				fmt.Fprintf(&src, "\t%s $%d, %s\n", alias, hint, label)
+			}
+			fmt.Fprintf(&src, "%s:\n", label)
+		}
+	}
+	src.WriteString("\tRET\n")
+
+	// Preserve the complete original Go object and missing-input Context.
+	// The independent initialized counterpart supplies both COMI inputs.
+	ll := x86ConditionalBranchAliasOriginalFormatObject(t, src.String(), "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "conditional-branch-alias-formats.ll", "conditional-branch-alias-formats.o", ll)
+}
+
+func TestTranslateX86MSRAccessFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 assigns both RDMSR and WRMSR the operand-free ynone table on
+	// amd64 and 386. Their inputs/outputs are the architectural CX and DX:AX
+	// register tuple.
+	src := `
+TEXT msraccessforms(SB),NOSPLIT,$0-0
+	MOVL $0x10, CX
+	RDMSR
+	WRMSR
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"msraccessforms": {Name: "msraccessforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`asm sideeffect "rdmsr"`, `asm sideeffect "wrmsr"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("MSR access lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "msr-access.ll", "msr-access.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86MSRAccessFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		for _, instruction := range []string{"RDMSR AX", "WRMSR CX", "RDMSR.P", "WRMSR.Z"} {
+			name := target.goarch + "_" + strings.NewReplacer(" ", "_", ".", "_").Replace(instruction)
+			t.Run(name, func(t *testing.T) {
+				src := "TEXT invalidmsraccess(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+				file, err := Parse(ArchAMD64, src)
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs: map[string]FuncSig{
+						"invalidmsraccess": {Name: "invalidmsraccess", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q for %s, but Go 1.27 uses ynone", instruction, target.goarch)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86DescriptorTableFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 groups the system descriptor instructions into these complete
+	// operand tables: LGDT/LIDT and SGDT/SIDT take memory; LLDT/LTR/LMSW take
+	// GP-register or memory inputs; SLDT*/SMSW*/STR* write GP registers or
+	// memory. Q forms exist only on amd64.
+	common := `
+TEXT descriptorforms(SB),NOSPLIT,$32-0
+	LGDT (BX)
+	LIDT 8(SP)
+	SGDT (CX)
+	SIDT 16(SP)
+	LLDT AX
+	LLDT (BX)
+	LTR DI
+	LTR 8(SP)
+	LMSW CX
+	LMSW (DX)
+	SLDTW AX
+	SLDTW (BX)
+	SLDTL DI
+	SLDTL 8(SP)
+	SMSWW CX
+	SMSWW (DX)
+	SMSWL BP
+	SMSWL 16(SP)
+	STRW SI
+	STRW (DI)
+	STRL BX
+	STRL 24(SP)
+	STRL SP
+`
+	amd64Only := `
+	SLDTQ R11
+	SLDTQ (R12)
+	SMSWQ R13
+	SMSWQ (R14)
+	STRQ R15
+	STRQ (R10)
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-macosx"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			src := common
+			if target.goarch == "amd64" {
+				src += amd64Only
+			}
+			src += "\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"descriptorforms": {Name: "descriptorforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "lgdt`, `asm sideeffect "lidt`,
+				`asm sideeffect "sgdt`, `asm sideeffect "sidt`,
+				`asm sideeffect "lldt`, `asm sideeffect "ltr`, `asm sideeffect "lmsw`,
+				`asm sideeffect "sldt`, `asm sideeffect "smsw`, `asm sideeffect "str`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("descriptor-table lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "descriptor-table.ll", "descriptor-table.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86DescriptorTableFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	tests := []struct {
+		name        string
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{name: "lgdt-register", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LGDT AX"},
+		{name: "sgdt-register", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SGDT R11"},
+		{name: "lidt-immediate", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LIDT $1"},
+		{name: "sidt-two-operands", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SIDT (AX), (BX)"},
+		{name: "lldt-immediate", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LLDT $1"},
+		{name: "ltr-vector", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LTR X0"},
+		{name: "lmsw-two-operands", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LMSW AX, BX"},
+		{name: "sldtw-immediate", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SLDTW $1"},
+		{name: "smswl-vector", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SMSWL X0"},
+		{name: "strq-two-operands", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "STRQ AX, BX"},
+		{name: "lgdt-suffix", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "LGDT.P (AX)"},
+		{name: "sldtw-suffix", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SLDTW.Z AX"},
+		{name: "386-sldtq", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "SLDTQ AX"},
+		{name: "386-smswq", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "SMSWQ AX"},
+		{name: "386-strq", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "STRQ AX"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			src := "TEXT invaliddescriptor(SB),NOSPLIT,$0-0\n\t" + test.instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: test.triple,
+				Goarch:       test.goarch,
+				Sigs: map[string]FuncSig{
+					"invaliddescriptor": {Name: "invaliddescriptor", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q for %s outside the Go 1.27 optab", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestTranslateX86MachineRegisterMoveFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// This is the complete special-register portion of Go 1.27's ymovtab,
+	// excluding the independently handled segment and TLS moves. MOVQ special
+	// forms are accepted in 386 mode too; CR8 is the sole 64-bit-only register.
+	common := `
+TEXT machineregistermoves(SB),NOSPLIT,$32-0
+	MOVL CR0, AX
+	MOVL BX, CR0
+	MOVL CR2, CX
+	MOVL DX, CR2
+	MOVL CR3, BP
+	MOVL SI, CR3
+	MOVL CR4, DI
+	MOVL AX, CR4
+	MOVQ CR0, BX
+	MOVQ CX, CR0
+	MOVQ CR2, DX
+	MOVQ BP, CR2
+	MOVQ CR3, SI
+	MOVQ DI, CR3
+	MOVQ CR4, AX
+	MOVQ BX, CR4
+	MOVL DR0, CX
+	MOVL DX, DR0
+	MOVL DR6, BP
+	MOVL SI, DR6
+	MOVL DR7, DI
+	MOVL AX, DR7
+	MOVQ DR0, BX
+	MOVQ CX, DR0
+	MOVQ DR2, DX
+	MOVQ BP, DR2
+	MOVQ DR3, SI
+	MOVQ DI, DR3
+	MOVQ DR6, AX
+	MOVQ BX, DR6
+	MOVQ DR7, CX
+	MOVQ DX, DR7
+	MOVL TR6, AX
+	MOVL TR6, 0(SP)
+	MOVL BX, TR6
+	MOVL 4(SP), TR6
+	MOVL TR7, CX
+	MOVL TR7, 8(SP)
+	MOVL DX, TR7
+	MOVL 12(SP), TR7
+	MOVL 0(SP), GDTR
+	MOVL GDTR, 16(SP)
+	MOVL 0(SP), IDTR
+	MOVL IDTR, 16(SP)
+	MOVQ 0(SP), GDTR
+	MOVQ GDTR, 16(SP)
+	MOVQ 0(SP), IDTR
+	MOVQ IDTR, 16(SP)
+	MOVW AX, LDTR
+	MOVW 0(SP), LDTR
+	MOVW LDTR, BX
+	MOVW LDTR, 0(SP)
+	MOVW CX, MSW
+	MOVW 4(SP), MSW
+	MOVW MSW, DX
+	MOVW MSW, 4(SP)
+	MOVW BP, TASK
+	MOVW 8(SP), TASK
+	MOVW TASK, SI
+	MOVW TASK, 8(SP)
+	MOVL CR0, SP
+	MOVQ CR0, SP
+`
+	amd64Only := `
+	MOVL CR8, R11
+	MOVL R12, CR8
+	MOVQ CR8, R13
+	MOVQ R14, CR8
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-macosx"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			src := common
+			if target.goarch == "amd64" {
+				src += amd64Only
+			}
+			src += "\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"machineregistermoves": {Name: "machineregistermoves", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"%cr0", "%dr0", ".byte 0x0f, 0x24", ".byte 0x0f, 0x26"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("machine-register lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "machine-register.ll", "machine-register.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86MachineRegisterMoveFamilyRejectsFormsOutsideGoMovtab(t *testing.T) {
+	tests := []struct {
+		name        string
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{name: "cr1", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ CR1, AX"},
+		{name: "cr5", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVL AX, CR5"},
+		{name: "cr-memory", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ CR0, (AX)"},
+		{name: "386-cr8-l", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVL CR8, AX"},
+		{name: "386-cr8-q", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVQ AX, CR8"},
+		{name: "movl-dr2", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVL DR2, AX"},
+		{name: "movq-dr1", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ AX, DR1"},
+		{name: "dr-memory", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ (AX), DR0"},
+		{name: "tr5", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVL TR5, AX"},
+		{name: "tr-q", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ TR6, AX"},
+		{name: "gdtr-register", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ AX, GDTR"},
+		{name: "gdtr-width", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVW (AX), GDTR"},
+		{name: "ldtr-width", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVL AX, LDTR"},
+		{name: "machine-suffix", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVQ.P CR0, AX"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			src := "TEXT invalidmachineregistermove(SB),NOSPLIT,$0-0\n\t" + test.instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: test.triple,
+				Goarch:       test.goarch,
+				Sigs: map[string]FuncSig{
+					"invalidmachineregistermove": {Name: "invalidmachineregistermove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q for %s outside Go 1.27's ymovtab", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestTranslateX86ScalarExtensionMoveCompleteGo127Forms(t *testing.T) {
+	amd64Ops := []string{
+		"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVBQSX", "MOVBQZX",
+		"MOVWLSX", "MOVWLZX", "MOVWQSX", "MOVWQZX", "MOVLQSX", "MOVLQZX",
+		"MOVSWW", "MOVZWW",
+	}
+	ops386 := []string{
+		"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX",
+		"MOVWLSX", "MOVWLZX", "MOVLQZX", "MOVSWW", "MOVZWW",
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+		ops    []string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", ops: amd64Ops},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", ops: amd64Ops},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", ops: amd64Ops},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu", ops: ops386},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc", ops: ops386},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT scalar_extension_forms(SB),NOSPLIT,$0-1\n")
+			for _, op := range target.ops {
+				source := "AX"
+				if strings.HasPrefix(op, "MOVB") {
+					source = "AL"
+					if target.goarch == "386" {
+						source = "BP" // Go rewrites this Yrl32 byte source through BX.
+					}
+				}
+				fmt.Fprintf(&src, "\t%s %s, CX\n", op, source)
+				fmt.Fprintf(&src, "\t%s 8(BX), DX\n", op)
+			}
+			src.WriteString("\tMOVBWZX x+0(FP), SP\n\tRET\n")
+			file, err := Parse(ArchAMD64, src.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Keep the original arbitrary BX reads and physical SP write as
+			// Go/emitter formats. Neither syntax grants a source/frame role.
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+src.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, src.String(), "func scalar_extension_forms(x uint8)", target.goarch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original extension formats acquired unbound source/physical SP inputs", api, err)
+				}
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{
+				"scalar_extension_forms": {
+					Name: "scalar_extension_forms", Args: []LLVMType{I8}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I8, Index: 0, Field: -1}}},
+				},
+			}, target.goarch, target.triple, 0)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ll, level)
+			}
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.goarch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var initialized, declarations, scratch, scratchDeclarations strings.Builder
+			for index, op := range target.ops {
+				register := "AX"
+				if strings.HasPrefix(op, "MOVB") {
+					register = "AL"
+					if target.goarch == "386" {
+						register = "BP"
+					}
+				}
+				for _, source := range []string{register, "8(BX)"} {
+					name := fmt.Sprintf("Extension%d", initialized.Len())
+					fmt.Fprintf(&declarations, "func %s(x %s,p *[16]byte) %s\n", name, typ, typ)
+					fmt.Fprintf(&initialized, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s p+%d(FP),BX\n%s $0,CX\n", name, 3*word, move, move, word, move)
+					if register == "BP" {
+						initialized.WriteString("MOVL AX,BP\n")
+					}
+					fmt.Fprintf(&initialized, "%s %s,CX\n%s CX,ret+%d(FP)\nRET\n", op, source, move, 2*word)
+				}
+				fmt.Fprintf(&scratchDeclarations, "func Scratch%d()\n", index)
+				fmt.Fprintf(&scratch, "TEXT ·Scratch%d(SB),4,$0-0\n%s %s,CX\nRET\n", index, op, register)
+			}
+			for _, fixture := range []struct{ name, source, declarations string }{
+				{"initialized", initialized.String(), declarations.String()},
+				{"dead-register", scratch.String(), scratchDeclarations.String()},
+			} {
+				x86LEAActualTargetGoObject(t, target.goarch, target.triple, fixture.source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declarations, target.goarch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete extension counterpart", fixture.name, api, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86ScalarExtensionMoveRejectsFormsOutsideGo127Tables(t *testing.T) {
+	tests := []struct {
+		name        string
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{name: "missing-source", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVBWZX AX"},
+		{name: "too-many", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVBLZX AL, AX, BX"},
+		{name: "immediate-source", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVBQZX $1, AX"},
+		{name: "vector-source", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVBWZX X1, AX"},
+		{name: "byte-source-for-word-class", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVWLZX AL, AX"},
+		{name: "memory-destination", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVBLSX AL, (AX)"},
+		{name: "byte-destination", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVWQZX AX, AL"},
+		{name: "suffix", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "MOVLQZX.Z AX, BX"},
+		{name: "386-byte-to-qword-sign", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVBQSX AL, AX"},
+		{name: "386-byte-to-qword-zero", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVBQZX AL, AX"},
+		{name: "386-word-to-qword-sign", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVWQSX AX, BX"},
+		{name: "386-word-to-qword-zero", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVWQZX AX, BX"},
+		{name: "386-long-to-qword-sign", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVLQSX AX, BX"},
+		{name: "386-r8-source", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVWLZX R8, AX"},
+		{name: "386-r8-destination", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVBLZX AL, R8"},
+		{name: "386-sp-byte-source", goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "MOVBWZX SP, AX"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			src := "TEXT invalid_scalar_extension(SB),NOSPLIT,$0-0\n\t" + test.instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: test.triple,
+				Goarch:       test.goarch,
+				Sigs: map[string]FuncSig{
+					"invalid_scalar_extension": {Name: "invalid_scalar_extension", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q for %s outside Go 1.27's ymb_rl/yml_rl tables", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestTranslateX86MaskLogicalCompleteGo127Forms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT mask_logical_forms(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"KAND", "KANDN", "KOR", "KXNOR", "KXOR"} {
+		for _, width := range []string{"B", "W", "D", "Q"} {
+			fmt.Fprintf(&src, "\t%s%s K1, K2, K3\n", stem, width)
+		}
+	}
+	for _, stem := range []string{"KNOT", "KTEST", "KORTEST"} {
+		for _, width := range []string{"B", "W", "D", "Q"} {
+			fmt.Fprintf(&src, "\t%s%s K1, K2\n", stem, width)
+		}
+	}
+	src.WriteString("\tRET\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			// Preserve the original uninitialized format inventory. Complete
+			// initialized programs have independent public API/runtime owners.
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "mask_logical_forms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "mask-logical-"+target.name+".ll", "mask-logical-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86MaskLogicalRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, instruction := range []string{
+		"KXNORW K1, K2",
+		"KXNORW K1, K2, K3, K4",
+		"KANDW K1, K2, AX",
+		"KANDNW K1, (AX), K3",
+		"KORQ $1, K2, K3",
+		"KXORB K1, K2, K8",
+		"KNOTD K1",
+		"KNOTQ K1, K2, K3",
+		"KNOTW AX, K2",
+		"KTESTB K1, (AX)",
+		"KTESTW K1, K2, K3",
+		"KORTESTD K1",
+		"KORTESTQ.Z K1, K2",
+		"KXORQ.Z K1, K2, K3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_mask_logical(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			for _, target := range []struct {
+				goarch string
+				triple string
+			}{
+				{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+				{goarch: "386", triple: "i386-unknown-linux-gnu"},
+			} {
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs: map[string]FuncSig{
+						"invalid_mask_logical": {Name: "invalid_mask_logical", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q for %s outside Go 1.27's _ykaddb/_yknotb tables", instruction, target.goarch)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86MaskMoveCompleteGo127Forms(t *testing.T) {
+	// Go 1.27 assigns KMOVB/W/D/Q the same _ykmovb table. Its four rows are:
+	// K -> memory, K -> GP, K-or-memory -> K, and GP -> K. Ykm therefore also
+	// includes the K -> K form. Exercise every row plus each Plan 9 memory
+	// spelling accepted as Ym, on both x86 architectures and all CI object
+	// formats.
+	var src strings.Builder
+	src.WriteString("TEXT mask_move_forms(SB),NOSPLIT,$0-16\n")
+	for _, op := range []string{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+		fmt.Fprintf(&src, "\t%s K1, 16(BX)\n", op)
+		fmt.Fprintf(&src, "\t%s K1, AX\n", op)
+		fmt.Fprintf(&src, "\t%s K1, K2\n", op)
+		fmt.Fprintf(&src, "\t%s K0, K7\n", op)
+		fmt.Fprintf(&src, "\t%s 16(BX), K2\n", op)
+		fmt.Fprintf(&src, "\t%s AX, K2\n", op)
+		fmt.Fprintf(&src, "\t%s K5, SP\n", op)
+		fmt.Fprintf(&src, "\t%s SP, K5\n", op)
+		fmt.Fprintf(&src, "\t%s x+0(FP), K3\n", op)
+		fmt.Fprintf(&src, "\t%s K3, ret+8(FP)\n", op)
+		fmt.Fprintf(&src, "\t%s mask_move_source(SB), K4\n", op)
+		fmt.Fprintf(&src, "\t%s K4, mask_move_destination(SB)\n", op)
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			targetSource := src.String()
+			if target.goarch == "amd64" {
+				var highRegisters strings.Builder
+				for _, op := range []string{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+					fmt.Fprintf(&highRegisters, "\t%s K6, R15\n", op)
+					fmt.Fprintf(&highRegisters, "\t%s R15, K6\n", op)
+				}
+				targetSource += highRegisters.String()
+			}
+			targetSource += "\tRET\n"
+			file, err := Parse(ArchAMD64, targetSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"mask_move_forms": {
+						Name: "mask_move_forms", Args: []LLVMType{I64}, Ret: I64,
+						Frame: FrameLayout{
+							Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+							Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+						},
+					},
+				},
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("format-only KMOV source invented initialized masks or native storage", err)
+			}
+			goAssemblerOracleOutput(t, target.goarch, "#include \"textflag.h\"\n"+targetSource, "", true)
+			for _, instruction := range file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1] {
+				if !amd64MaskMoveOperandsValid(instruction, target.goarch) {
+					t.Fatal("complete original Go row lost its typed grammar", instruction.Raw)
+				}
+			}
+			t.Log("original complete Go forms retain Context; initialized GP, FP, native and caller counterparts own LLVM objects")
+		})
+	}
+}
+
+func TestTranslate386MaskMoveRejectsAMD64OnlyYrlRegisters(t *testing.T) {
+	for _, instruction := range []string{"KMOVB K1, R8", "KMOVW R8, K1", "KMOVD K1, R15", "KMOVQ R15, K1"} {
+		src := "TEXT invalid_mask_move_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalid_mask_move_386": {Name: "invalid_mask_move_386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q for 386 outside Go 1.27's Yrl class", instruction)
+		}
+	}
+}
+
+func TestTranslateX86MaskMoveRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"KMOVB K1",
+		"KMOVW K1, K2, K3",
+		"KMOVD $1, K1",
+		"KMOVQ K1, $1",
+		"KMOVB 8(AX), BX",
+		"KMOVW AX, 8(BX)",
+		"KMOVD AX, BX",
+		"KMOVQ 8(AX), 16(BX)",
+		"KMOVB X1, K2",
+		"KMOVW K1, X2",
+		"KMOVD K8, AX",
+		"KMOVQ AX, K8",
+		"KMOVQ.Z K1, K2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_mask_move(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			for _, target := range []struct {
+				goarch string
+				triple string
+			}{
+				{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+				{goarch: "386", triple: "i386-unknown-linux-gnu"},
+			} {
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs: map[string]FuncSig{
+						"invalid_mask_move": {Name: "invalid_mask_move", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q for %s outside Go 1.27's _ykmovb table", instruction, target.goarch)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86GatherCompleteGo127Forms(t *testing.T) {
+	// Go 1.27 has eight data-gather instructions over three operand tables,
+	// plus eight EVEX gather-prefetch instructions over two tables. Generate
+	// every row of all five tables for each opcode. The 386 assembler accepts
+	// EVEX gather with X/Y/Z0..7 VSIB indices; amd64 additionally accepts the
+	// high EVEX register classes.
+	dataGroups := []struct {
+		ops   []string
+		table string
+	}{
+		{ops: []string{"VGATHERDPS", "VGATHERQPD", "VPGATHERDD", "VPGATHERQQ"}, table: "dps"},
+		{ops: []string{"VGATHERDPD", "VPGATHERDQ"}, table: "dpd"},
+		{ops: []string{"VGATHERQPS", "VPGATHERQD"}, table: "qps"},
+	}
+	prefetchGroups := []struct {
+		ops        []string
+		indexWidth string
+	}{
+		{ops: []string{"VGATHERPF0DPD", "VGATHERPF1DPD"}, indexWidth: "Y"},
+		{ops: []string{
+			"VGATHERPF0DPS", "VGATHERPF0QPD", "VGATHERPF0QPS",
+			"VGATHERPF1DPS", "VGATHERPF1QPD", "VGATHERPF1QPS",
+		}, indexWidth: "Z"},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT gather_forms(SB),NOSPLIT,$0-0\n")
+			for _, group := range dataGroups {
+				for _, op := range group.ops {
+					switch group.table {
+					case "dps":
+						fmt.Fprintf(&src, "\t%s X1, (BX)(X2*1), X3\n", op)
+						fmt.Fprintf(&src, "\t%s Y1, 4(BX)(Y2*2), Y3\n", op)
+						fmt.Fprintf(&src, "\t%s 8(X2*4), K1, X3\n", op)
+						fmt.Fprintf(&src, "\t%s 12(BX)(Y2*8), K1, Y3\n", op)
+						fmt.Fprintf(&src, "\t%s 16(BX)(Z2*4), K1, Z3\n", op)
+					case "dpd":
+						fmt.Fprintf(&src, "\t%s X1, (BX)(X2*1), X3\n", op)
+						fmt.Fprintf(&src, "\t%s Y1, 8(BX)(X2*2), Y3\n", op)
+						fmt.Fprintf(&src, "\t%s 16(X2*4), K1, X3\n", op)
+						fmt.Fprintf(&src, "\t%s 24(BX)(X2*8), K1, Y3\n", op)
+						fmt.Fprintf(&src, "\t%s 32(BX)(Y2*4), K1, Z3\n", op)
+					case "qps":
+						fmt.Fprintf(&src, "\t%s X1, (BX)(X2*1), X3\n", op)
+						fmt.Fprintf(&src, "\t%s X1, 4(BX)(Y2*2), X3\n", op)
+						fmt.Fprintf(&src, "\t%s 8(X2*4), K1, X3\n", op)
+						fmt.Fprintf(&src, "\t%s 12(BX)(Y2*8), K1, X3\n", op)
+						fmt.Fprintf(&src, "\t%s 16(BX)(Z2*4), K1, Y3\n", op)
+					}
+					// Unlike VSIB indices, Go 1.27 permits high EVEX X/Y
+					// destination registers even in 386 mode.
+					switch group.table {
+					case "dps":
+						fmt.Fprintf(&src, "\t%s (BX)(X2*4), K2, X20\n", op)
+						fmt.Fprintf(&src, "\t%s (BX)(Y2*4), K2, Y20\n", op)
+					case "dpd":
+						fmt.Fprintf(&src, "\t%s (BX)(X2*4), K2, X20\n", op)
+						fmt.Fprintf(&src, "\t%s (BX)(X2*4), K2, Y20\n", op)
+					case "qps":
+						fmt.Fprintf(&src, "\t%s (BX)(X2*8), K2, X20\n", op)
+						fmt.Fprintf(&src, "\t%s (BX)(Z2*8), K2, Y20\n", op)
+					}
+					if target.goarch == "amd64" {
+						switch group.table {
+						case "dps":
+							fmt.Fprintf(&src, "\t%s (BX)(X20*4), K2, X21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(Y20*4), K2, Y21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(Z20*4), K2, Z21\n", op)
+						case "dpd":
+							fmt.Fprintf(&src, "\t%s (BX)(X20*4), K2, X21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(X20*4), K2, Y21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(Y20*4), K2, Z21\n", op)
+						case "qps":
+							fmt.Fprintf(&src, "\t%s (BX)(X20*8), K2, X21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(Y20*8), K2, X21\n", op)
+							fmt.Fprintf(&src, "\t%s (BX)(Z20*8), K2, Y21\n", op)
+						}
+					}
+				}
+			}
+			for _, group := range prefetchGroups {
+				for _, op := range group.ops {
+					fmt.Fprintf(&src, "\t%s K1, 40(BX)(%s2*4)\n", op, group.indexWidth)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s K7, 48(%s20*8)\n", op, group.indexWidth)
+					}
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			// Original operand formats have neither incoming values nor a
+			// pointer base. Preserve Go bytes and objects with public Context;
+			// the separate official-row owner supplies real initialized inputs.
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "gather_forms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "gather-"+target.name+".ll", "gather-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86GatherRejectsFormsOutsideGo127Tables(t *testing.T) {
+	tests := []struct {
+		name        string
+		instruction string
+	}{
+		{name: "missing-mask", instruction: "VPGATHERDD (AX)(X2*4), X3"},
+		{name: "too-many", instruction: "VGATHERDPS (AX)(X2*4), K1, K2, X3"},
+		{name: "plain-memory", instruction: "VPGATHERDD (AX), K1, X3"},
+		{name: "gp-index", instruction: "VPGATHERDD (AX)(CX*4), K1, X3"},
+		{name: "bad-scale", instruction: "VPGATHERDD (AX)(X2*3), K1, X3"},
+		{name: "k0-mask", instruction: "VPGATHERDD (AX)(X2*4), K0, X3"},
+		{name: "vector-mask-in-evex", instruction: "VPGATHERDD (AX)(X2*4), X1, X3"},
+		{name: "k-mask-in-vex", instruction: "VPGATHERDD K1, (AX)(X2*4), X3"},
+		{name: "dps-wrong-index", instruction: "VPGATHERDD (AX)(Y2*4), K1, X3"},
+		{name: "dps-wrong-destination", instruction: "VPGATHERDD (AX)(X2*4), K1, Y3"},
+		{name: "dpd-wrong-index", instruction: "VPGATHERDQ (AX)(Y2*4), K1, Y3"},
+		{name: "dpd-wrong-destination", instruction: "VPGATHERDQ (AX)(Y2*4), K1, X3"},
+		{name: "qps-wrong-index", instruction: "VPGATHERQD (AX)(Y2*8), K1, Y3"},
+		{name: "qps-wrong-destination", instruction: "VPGATHERQD (AX)(Z2*8), K1, Z3"},
+		{name: "vex-mask-index-alias", instruction: "VPGATHERDD X2, (AX)(X2*4), X3"},
+		{name: "vex-mask-dest-alias", instruction: "VPGATHERDD X3, (AX)(X2*4), X3"},
+		{name: "vex-index-dest-alias", instruction: "VPGATHERDD X1, (AX)(X3*4), X3"},
+		{name: "evex-index-dest-alias", instruction: "VPGATHERDD (AX)(X3*4), K1, X3"},
+		{name: "zero-suffix", instruction: "VPGATHERDD.Z (AX)(X2*4), K1, X3"},
+		{name: "broadcast-suffix", instruction: "VPGATHERQQ.BCST (AX)(X2*8), K1, X3"},
+		{name: "prefetch-k0", instruction: "VGATHERPF0DPD K0, (AX)(Y2*8)"},
+		{name: "prefetch-wrong-index", instruction: "VGATHERPF0DPD K1, (AX)(Z2*8)"},
+		{name: "prefetch-extra-dest", instruction: "VGATHERPF1DPS K1, (AX)(Z2*4), Z3"},
+		{name: "prefetch-suffix", instruction: "VGATHERPF1QPS.Z K1, (AX)(Z2*8)"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			src := "TEXT invalid_gather(SB),NOSPLIT,$0-0\n\t" + test.instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			for _, target := range []struct {
+				goarch string
+				triple string
+			}{
+				{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+				{goarch: "386", triple: "i386-unknown-linux-gnu"},
+			} {
+				if _, err := Translate(file, Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs: map[string]FuncSig{
+						"invalid_gather": {Name: "invalid_gather", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q for %s outside Go 1.27's gather tables", test.instruction, target.goarch)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslate386GatherRejectsHighVSIBAndZRegisters(t *testing.T) {
+	for _, instruction := range []string{
+		"VPGATHERDD (AX)(X8*4), K1, X3",
+		"VPGATHERDQ (AX)(Y8*4), K1, Z3",
+		"VPGATHERQD (AX)(Z8*8), K1, Y3",
+		"VPGATHERDD (AX)(Z2*4), K1, Z8",
+		"VGATHERPF0DPD K1, (AX)(Y8*8)",
+		"VGATHERPF1DPS K1, (AX)(Z8*4)",
+	} {
+		src := "TEXT invalid_gather_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalid_gather_386": {Name: "invalid_gather_386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's 386 VSIB/register classes", instruction)
+		}
+	}
+}
+
+func TestTranslateAMD64TernaryLogicCompleteGo127Forms(t *testing.T) {
+	// VPTERNLOGD/Q share Go 1.27's six-row _yvalignd table: X/Y/Z,
+	// each with an unmasked and K1-K7 masked row. Their EVEX encodings add
+	// scalar D/Q broadcast and zeroing. Exercise every row/suffix combination,
+	// high EVEX registers, and every value in the unsigned-imm8 truth table.
+	var src strings.Builder
+	src.WriteString("TEXT ternary_logic_forms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&src, "\t%s $0, %s0, %s1, %s2\n", op, width, width, width)
+			fmt.Fprintf(&src, "\t%s $255, 8(BX), %s3, %s4\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s $0xd8, %s5, %s6, K1, %s7\n", op, width, width, width)
+			fmt.Fprintf(&src, "\t%s.Z $0xaa, 16(BX), %s8, K2, %s9\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST $0xcc, 24(BX), %s10, %s11\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.BCST.Z $0xf0, 32(BX), %s12, K3, %s13\n", op, width, width)
+		}
+		fmt.Fprintf(&src, "\t%s $0x96, X29, X30, X31\n", op)
+		fmt.Fprintf(&src, "\t%s $0x96, Y29, Y30, Y31\n", op)
+		fmt.Fprintf(&src, "\t%s $0x96, Z29, Z30, Z31\n", op)
+	}
+	for immediate := 0; immediate <= 255; immediate++ {
+		fmt.Fprintf(&src, "\tVPTERNLOGD $%d, X0, X1, X2\n", immediate)
+		fmt.Fprintf(&src, "\tVPTERNLOGQ $%d, X3, X4, X5\n", immediate)
+	}
+	src.WriteString("\tRET\n")
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			// Keep all554 original rows, including high banks and every
+			// selector. Missing BX/K1-K3 inputs make this an original Go
+			// and emitter format object, not a public initialized program.
+			file, signatures := x86UnboundVoidFormatSources(t, src.String(), "amd64", target.triple)
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, "amd64", target.triple, 0)
+			compileLLVMToObject(t, llc, target.triple, "ternary-logic-"+target.name+".ll", "ternary-logic-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestAMD64TernaryLogicTruthTableOrderingExhaustive(t *testing.T) {
+	for immediate := 0; immediate <= 255; immediate++ {
+		for truthIndex := 0; truthIndex < 8; truthIndex++ {
+			a := truthIndex&4 != 0
+			b := truthIndex&2 != 0
+			third := truthIndex&1 != 0
+			want := immediate&(1<<truthIndex) != 0
+			if got := amd64TernaryLogicBit(uint8(immediate), a, b, third); got != want {
+				t.Fatalf("imm=%#02x A=%v B=%v C=%v: got %v, want %v", immediate, a, b, third, got, want)
+			}
+		}
+	}
+
+	c, _ := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.ternaryLogic", Ret: Void}, nil)
+	for _, test := range []struct {
+		name      string
+		immediate uint8
+		want      string
+	}{
+		{name: "A", immediate: 0xf0, want: "%old_destination"},
+		{name: "B", immediate: 0xcc, want: "%vvvv_source"},
+		{name: "C", immediate: 0xaa, want: "%rm_source"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := c.emitTernaryLogicBytes(16, test.immediate, "%old_destination", "%vvvv_source", "%rm_source")
+			if got != test.want {
+				t.Fatalf("truth-table selector %#02x = %q, want %q", test.immediate, got, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64TernaryLogicRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VPTERNLOGD X0, X1, X2",
+		"VPTERNLOGD $0, X0, X1",
+		"VPTERNLOGQ $0, X0, X1, X2, X3, X4",
+		"VPTERNLOGD $-1, X0, X1, X2",
+		"VPTERNLOGQ $256, X0, X1, X2",
+		"VPTERNLOGD AX, X0, X1, X2",
+		"VPTERNLOGD $0, Y0, X1, X2",
+		"VPTERNLOGQ $0, X0, Y1, X2",
+		"VPTERNLOGD $0, X0, X1, Y2",
+		"VPTERNLOGQ $0, X0, 8(BX), X2",
+		"VPTERNLOGD $0, X0, X1, 8(BX)",
+		"VPTERNLOGD $0, X0, X1, K0, X2",
+		"VPTERNLOGQ $0, X0, X1, K8, X2",
+		"VPTERNLOGD.Z $0, X0, X1, X2",
+		"VPTERNLOGQ.BCST $0, X0, X1, X2",
+		"VPTERNLOGD.BCST.Z $0, 8(BX), X1, X2",
+		"VPTERNLOGQ.Z.BCST $0, 8(BX), X1, K1, X2",
+		"VPTERNLOGD.SAE $0, X0, X1, X2",
+		"VPTERNLOGQ.BCST.BCST $0, 8(BX), X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_ternary_logic(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalid_ternary_logic": {Name: "invalid_ternary_logic", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvalignd table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386TernaryLogicMatchesGoAssemblerOperandLimit(t *testing.T) {
+	// Go 1.27's 386 assembler frontend rejects the four/five-operand source
+	// syntax before optab matching, so this is an asserted compatibility rule,
+	// not an unsupported-form skip. Check both 386 CI object formats.
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			for _, instruction := range []string{
+				"VPTERNLOGD $0, X0, X1, X2",
+				"VPTERNLOGQ $255, 8(BX), Y1, Y2",
+				"VPTERNLOGD.Z $0xd8, Z0, Z1, K1, Z2",
+				"VPTERNLOGQ.BCST.Z $0x96, 16(BX), X1, K7, X2",
+			} {
+				src := "TEXT invalid_ternary_logic_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+				file, err := Parse(ArchAMD64, src)
+				if err != nil {
+					continue
+				}
+				if _, err := Translate(file, Options{
+					TargetTriple: triple,
+					Goarch:       "386",
+					Sigs: map[string]FuncSig{
+						"invalid_ternary_logic_386": {Name: "invalid_ternary_logic_386", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q although Go 1.27's 386 assembler rejects its operand count", instruction)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86PackedRotateCompleteGo127Forms(t *testing.T) {
+	immediateOps := []string{"VPROLD", "VPROLQ", "VPRORD", "VPRORQ"}
+	variableOps := []string{"VPROLVD", "VPROLVQ", "VPRORVD", "VPRORVQ"}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT packed_rotate_forms(SB),NOSPLIT,$0-0\n")
+			for _, op := range immediateOps {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s $0, %s0, %s1\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s $255, 8(BX), %s2\n", op, width)
+					fmt.Fprintf(&src, "\t%s.BCST $31, 16(BX), %s3\n", op, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s $7, %s4, K1, %s5\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.Z $11, 24(BX), K2, %s6\n", op, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z $13, 32(BX), K3, %s7\n", op, width)
+					}
+				}
+				fmt.Fprintf(&src, "\t%s $17, X30, X31\n", op)
+				fmt.Fprintf(&src, "\t%s $19, Y30, Y31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s $23, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s $23, Z6, Z7\n", op)
+				}
+			}
+			for _, op := range variableOps {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s %s7, %s8, K1, %s9\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.Z 24(BX), %s10, K2, %s11\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z 32(BX), %s12, K3, %s13\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				fmt.Fprintf(&src, "\t%s Y29, Y30, Y31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s Z29, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s Z5, Z6, Z7\n", op)
+				}
+			}
+			for immediate := 0; immediate <= 255; immediate++ {
+				fmt.Fprintf(&src, "\tVPROLD $%d, X0, X1\n", immediate)
+				fmt.Fprintf(&src, "\tVPRORQ $%d, X2, X3\n", immediate)
+			}
+			src.WriteString("\tRET\n")
+
+			physical, contextual := 680, 0
+			if target.goarch == "386" {
+				physical, contextual = 592, 16
+			}
+			ll := x86PackedRotateUnboundFormatObject(t, src.String(), target.goarch, target.triple, physical, contextual)
+			compileLLVMToObject(t, llc, target.triple, "packed-rotate-"+target.name+".ll", "packed-rotate-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedRotateRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPROLD X0, X1",
+		"VPROLQ $0, X0",
+		"VPRORD $0, X0, X1, X2, X3",
+		"VPRORQ $-1, X0, X1",
+		"VPROLD $256, X0, X1",
+		"VPROLVD X0, X1",
+		"VPRORVQ X0, X1, X2, X3, X4",
+		"VPROLD $7, Y0, X1",
+		"VPRORQ $7, X0, Y1",
+		"VPROLVD X0, Y1, Y2",
+		"VPRORVQ Y0, Y1, X2",
+		"VPROLD $7, X0, K0, X1",
+		"VPROLVD X0, X1, K0, X2",
+		"VPRORD.Z $7, X0, X1",
+		"VPRORVD.Z X0, X1, X2",
+		"VPROLQ.BCST $7, X0, X1",
+		"VPROLVQ.BCST X0, X1, X2",
+		"VPRORD.BCST.Z $7, 8(BX), X1",
+		"VPRORVD.BCST.Z 8(BX), X1, X2",
+		"VPROLD.Z.BCST $7, 8(BX), K1, X1",
+		"VPROLVD.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_packed_rotate(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalid_packed_rotate": {Name: "invalid_packed_rotate", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvprold/_yvblendmpd tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedRotateRejectsMaskedAndHighZForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VPROLD $7, X0, K1, X1",
+		"VPRORQ.Z $7, Y0, K7, Y1",
+		"VPROLVD X0, X1, K1, X2",
+		"VPRORVQ.BCST.Z 8(BX), Y1, K1, Y2",
+		"VPROLD $7, Z7, Z8",
+		"VPRORD $7, Z8, Z7",
+		"VPROLVD Z6, Z7, Z8",
+		"VPRORVQ Z8, Z7, Z6",
+	} {
+		for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+			src := "TEXT invalid_packed_rotate_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				continue
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalid_packed_rotate_386": {Name: "invalid_packed_rotate_386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q for %s outside Go 1.27's 386 source forms", instruction, triple)
+			}
+		}
+	}
+}
+
+func TestTranslateX86EVEXPackedLogicalCompleteGo127Forms(t *testing.T) {
+	ops := []string{"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT evex_packed_logical_forms(SB),NOSPLIT,$0-0\n")
+			for _, op := range ops {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s %s7, %s8, K1, %s9\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.Z 24(BX), %s10, K2, %s11\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z 32(BX), %s12, K3, %s13\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				fmt.Fprintf(&src, "\t%s Y29, Y30, Y31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s Z29, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s Z5, Z6, Z7\n", op)
+				}
+			}
+			src.WriteString("\tRET\n")
+			_, signatures := x86UnboundVoidFormatSource(t, src.String(), "evex_packed_logical_forms", target.goarch, target.triple)
+			file, err := Parse(ArchAMD64, x86PhysicalMode32ObjectSource(t, src.String(), target.goarch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			compileLLVMToObject(t, llc, target.triple, "evex-packed-logical-"+target.name+".ll", "evex-packed-logical-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86EVEXPackedLogicalRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VPXORD X0, X1",
+		"VPORQ X0, X1, X2, X3, X4",
+		"VPANDD $1, X1, X2",
+		"VPANDNQ X0, Y1, Y2",
+		"VPORD Y0, Y1, X2",
+		"VPXORQ X0, 8(BX), X2",
+		"VPANDD X0, X1, 8(BX)",
+		"VPANDNQ X0, X1, K0, X2",
+		"VPORD.Z X0, X1, X2",
+		"VPXORD.BCST X0, X1, X2",
+		"VPANDQ.BCST.Z 8(BX), X1, X2",
+		"VPORQ.Z.BCST 8(BX), X1, K1, X2",
+		"VPXORD.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_evex_packed_logical(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalid_evex_packed_logical": {Name: "invalid_evex_packed_logical", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvblendmpd table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386EVEXPackedLogicalRejectsMaskedAndHighZForms(t *testing.T) {
+	for _, op := range []string{"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"} {
+		for _, operands := range []string{
+			"X0, X1, K1, X2",
+			"Z6, Z7, Z8",
+			"Z8, Z7, Z6",
+		} {
+			instruction := op + " " + operands
+			src := "TEXT invalid_evex_packed_logical_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", strings.Replace(src, ",NOSPLIT", "", 1), false)
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				continue
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"invalid_evex_packed_logical_386": {Name: "invalid_evex_packed_logical_386", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's 386 operand/register limits", instruction)
+			}
+		}
+	}
+}
+
+func TestTranslateX86PackedFloatingLogicalCompleteGo127Forms(t *testing.T) {
+	legacyOps := []string{"ANDPS", "ANDPD", "ANDNPS", "ANDNPD", "ORPS", "ORPD", "XORPS", "XORPD"}
+	vectorOps := []string{"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD"}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT packed_floating_logical_forms(SB),NOSPLIT,$0-0\n")
+			for _, op := range legacyOps {
+				fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+				fmt.Fprintf(&src, "\t%s 8(BX), X2\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s X14, X15\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s X6, X7\n", op)
+				}
+			}
+			for _, op := range vectorOps {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s %s7, %s8, K1, %s9\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.Z 24(BX), %s10, K2, %s11\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z 32(BX), %s12, K3, %s13\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				fmt.Fprintf(&src, "\t%s Y29, Y30, Y31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s Z29, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s Z5, Z6, Z7\n", op)
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			_, signatures := x86UnboundVoidFormatSource(t, src.String(), "packed_floating_logical_forms", target.goarch, target.triple)
+			file, err := Parse(ArchAMD64, x86PhysicalMode32ObjectSource(t, src.String(), target.goarch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			compileLLVMToObject(t, llc, target.triple, "packed-floating-logical-"+target.name+".ll", "packed-floating-logical-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedFloatingLogicalRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, instruction := range []string{
+		"ANDPS X0",
+		"ORPD X0, X1, X2",
+		"ANDNPS Y0, X1",
+		"XORPD X0, Y1",
+		"ORPS.Z X0, X1",
+		"VXORPS X0, X1",
+		"VANDPD X0, X1, X2, X3, X4",
+		"VANDNPS X0, Y1, Y2",
+		"VORPD Y0, Y1, X2",
+		"VXORPS X0, 8(BX), X2",
+		"VANDPD X0, X1, K0, X2",
+		"VANDNPS.Z X0, X1, X2",
+		"VORPD.BCST X0, X1, X2",
+		"VXORPS.BCST.Z 8(BX), X1, X2",
+		"VANDPD.Z.BCST 8(BX), X1, K1, X2",
+		"VORPS.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT invalid_packed_floating_logical(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"invalid_packed_floating_logical": {Name: "invalid_packed_floating_logical", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's yxm/_yvandnpd tables", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386PackedFloatingLogicalRejectsArchitectureRestrictedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"ANDPS X8, X7",
+		"XORPD X7, X8",
+		"VANDPS X0, X1, K1, X2",
+		"VXORPD.BCST.Z 8(BX), Y1, K1, Y2",
+		"VORPS Z6, Z7, Z8",
+		"VANDNPD Z8, Z7, Z6",
+	} {
+		src := "TEXT invalid_packed_floating_logical_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalid_packed_floating_logical_386": {Name: "invalid_packed_floating_logical_386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's 386 register/operand limits", instruction)
+		}
+	}
+}
+
+func go127FMA3PackedOps() []string {
+	var ops []string
+	for _, family := range []string{"VFMADD", "VFMSUB", "VFNMADD", "VFNMSUB", "VFMADDSUB", "VFMSUBADD"} {
+		for _, order := range []string{"132", "213", "231"} {
+			for _, element := range []string{"PS", "PD"} {
+				ops = append(ops, family+order+element)
+			}
+		}
+	}
+	return ops
+}
+
+func go127FMA3ScalarOps() []string {
+	var ops []string
+	for _, family := range []string{"VFMADD", "VFMSUB", "VFNMADD", "VFNMSUB"} {
+		for _, order := range []string{"132", "213", "231"} {
+			for _, element := range []string{"SS", "SD"} {
+				ops = append(ops, family+order+element)
+			}
+		}
+	}
+	return ops
+}
+
+func TestTranslateX86FMA3CompleteGo127Forms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT fma3_complete_forms(SB),NOSPLIT,$0-0\n")
+			for _, op := range go127FMA3PackedOps() {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s %s7, %s8, K1, %s9\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.Z 24(BX), %s10, K2, %s11\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z 32(BX), %s12, K3, %s13\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				fmt.Fprintf(&src, "\t%s Y29, Y30, Y31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s Z29, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s Z5, Z6, Z7\n", op)
+				}
+				for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					fmt.Fprintf(&src, "\t%s.%s Z0, Z1, Z2\n", op, rounding)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s.%s Z3, Z4, K4, Z5\n", op, rounding)
+						fmt.Fprintf(&src, "\t%s.%s.Z Z6, Z7, K5, Z8\n", op, rounding)
+					}
+				}
+			}
+			for _, op := range go127FMA3ScalarOps() {
+				fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+				fmt.Fprintf(&src, "\t%s 8(BX), X3, X4\n", op)
+				fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s X5, X6, K1, X7\n", op)
+					fmt.Fprintf(&src, "\t%s.Z 16(BX), X8, K2, X9\n", op)
+				}
+				for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					fmt.Fprintf(&src, "\t%s.%s X10, X11, X12\n", op, rounding)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s.%s X13, X14, K3, X15\n", op, rounding)
+						fmt.Fprintf(&src, "\t%s.%s.Z X16, X17, K4, X18\n", op, rounding)
+					}
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			wanted := map[string]int{"amd64": 1596, "386": 744}[target.goarch]
+			if rows := strings.Count(src.String(), "\n\tV"); rows != wanted {
+				t.Fatal("complete original FMA3 source denominator changed", target.goarch, rows, wanted)
+			}
+			if target.goarch == "386" {
+				// Preserve the full original Go object before the existing
+				// separate low-bank physical projection. It is not equivalent
+				// to the unbound high-bank source or a native runtime witness.
+				x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+src.String())
+			}
+			physical := x86PhysicalMode32ObjectSource(t, src.String(), target.goarch)
+			file, signatures := x86UnboundVoidFormatSource(t, physical, "fma3_complete_forms", target.goarch, target.triple)
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			compileLLVMToObject(t, llc, target.triple, "fma3-complete-"+target.name+".ll", "fma3-complete-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86FMA3RejectsFormsOutsideGo127Tables(t *testing.T) {
+	reject := func(t *testing.T, instruction string) {
+		t.Helper()
+		src := "TEXT invalid_fma3(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			return
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "x86_64-unknown-linux-gnu",
+			Goarch:       "amd64",
+			Sigs: map[string]FuncSig{
+				"invalid_fma3": {Name: "invalid_fma3", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's _yvaddpd/_yvaddsd tables", instruction)
+		}
+	}
+	for _, op := range go127FMA3PackedOps() {
+		for _, operands := range []string{
+			"X0, X1",
+			"X0, X1, X2, X3, X4",
+			"X0, Y1, Y2",
+			"X0, 8(BX), X2",
+			"X0, X1, K0, X2",
+			"X0, X1, AX",
+			".Z X0, X1, X2",
+			".BCST X0, X1, X2",
+			".BCST.Z 8(BX), X1, X2",
+			".RN_SAE X0, X1, X2",
+			".RN_SAE 8(BX), Z1, Z2",
+			".SAE Z0, Z1, Z2",
+			".Z.BCST 8(BX), X1, K1, X2",
+			".BCST.RN_SAE 8(BX), Z1, Z2",
+		} {
+			instruction := op + " " + operands
+			if strings.HasPrefix(operands, ".") {
+				parts := strings.SplitN(operands, " ", 2)
+				instruction = op + parts[0] + " " + parts[1]
+			}
+			t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+				reject(t, instruction)
+			})
+		}
+	}
+	for _, op := range go127FMA3ScalarOps() {
+		for _, operands := range []string{
+			"X0, X1",
+			"X0, X1, X2, X3, X4",
+			"Y0, X1, X2",
+			"X0, 8(BX), X2",
+			"X0, X1, K0, X2",
+			".Z X0, X1, X2",
+			".BCST 8(BX), X1, X2",
+			".RN_SAE 8(BX), X1, X2",
+			".SAE X0, X1, X2",
+			".RN_SAE.BCST 8(BX), X1, X2",
+		} {
+			instruction := op + " " + operands
+			if strings.HasPrefix(operands, ".") {
+				parts := strings.SplitN(operands, " ", 2)
+				instruction = op + parts[0] + " " + parts[1]
+			}
+			t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+				reject(t, instruction)
+			})
+		}
+	}
+}
+
+func TestTranslate386FMA3RejectsArchitectureRestrictedForms(t *testing.T) {
+	var instructions []string
+	for _, op := range go127FMA3PackedOps() {
+		instructions = append(instructions,
+			op+" X0, X1, K1, X2",
+			op+" Z6, Z7, Z8",
+			op+" Z8, Z7, Z6",
+		)
+	}
+	for _, op := range go127FMA3ScalarOps() {
+		instructions = append(instructions, op+" X0, X1, K1, X2")
+	}
+	for _, instruction := range instructions {
+		src := "TEXT invalid_fma3_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalid_fma3_386": {Name: "invalid_fma3_386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's 386 register/operand limits", instruction)
+		}
+	}
+}
+
+func go127BinaryFloatingOps(scalar bool) []string {
+	var ops []string
+	for _, family := range []string{"VADD", "VSUB", "VMUL", "VDIV", "VMAX", "VMIN"} {
+		elements := []string{"PS", "PD"}
+		if scalar {
+			elements = []string{"SS", "SD"}
+		}
+		for _, element := range elements {
+			ops = append(ops, family+element)
+		}
+	}
+	return ops
+}
+
+func go127BinaryFloatingUsesSAE(op string) bool {
+	return strings.HasPrefix(op, "VMAX") || strings.HasPrefix(op, "VMIN")
+}
+
+func TestTranslateX86BinaryFloatingCompleteGo127Forms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT binary_floating_complete_forms(SB),NOSPLIT,$0-0\n")
+			for _, op := range go127BinaryFloatingOps(false) {
+				mode32MulDiv := target.goarch == "386" && (strings.HasPrefix(op, "VMUL") || strings.HasPrefix(op, "VDIV"))
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s %s7, %s8, K1, %s9\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.Z 24(BX), %s10, K2, %s11\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z 32(BX), %s12, K3, %s13\n", op, width, width)
+					}
+				}
+				if mode32MulDiv {
+					// Named high banks have no physical IA32 register identity.
+					// Their Go acceptance/Context is tested separately below.
+					fmt.Fprintf(&src, "\t%s X5, X6, X7\n", op)
+					fmt.Fprintf(&src, "\t%s Y5, Y6, Y7\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+					fmt.Fprintf(&src, "\t%s Y29, Y30, Y31\n", op)
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s Z29, Z30, Z31\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s Z5, Z6, Z7\n", op)
+				}
+				if go127BinaryFloatingUsesSAE(op) {
+					fmt.Fprintf(&src, "\t%s.SAE Z0, Z1, Z2\n", op)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s.SAE.Z Z3, Z4, K4, Z5\n", op)
+					}
+				} else {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						fmt.Fprintf(&src, "\t%s.%s Z0, Z1, Z2\n", op, rounding)
+						if target.goarch == "amd64" {
+							fmt.Fprintf(&src, "\t%s.%s.Z Z3, Z4, K4, Z5\n", op, rounding)
+						}
+					}
+				}
+			}
+			for _, op := range go127BinaryFloatingOps(true) {
+				mode32MulDiv := target.goarch == "386" && (strings.HasPrefix(op, "VMUL") || strings.HasPrefix(op, "VDIV"))
+				fmt.Fprintf(&src, "\t%s X0, X1, X2\n", op)
+				fmt.Fprintf(&src, "\t%s 8(BX), X3, X4\n", op)
+				if mode32MulDiv {
+					fmt.Fprintf(&src, "\t%s X5, X6, X7\n", op)
+				} else {
+					fmt.Fprintf(&src, "\t%s X29, X30, X31\n", op)
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&src, "\t%s X5, X6, K1, X7\n", op)
+					fmt.Fprintf(&src, "\t%s.Z 16(BX), X8, K2, X9\n", op)
+				}
+				if go127BinaryFloatingUsesSAE(op) {
+					fmt.Fprintf(&src, "\t%s.SAE X10, X11, X12\n", op)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&src, "\t%s.SAE.Z X13, X14, K3, X15\n", op)
+					}
+				} else {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						if mode32MulDiv {
+							fmt.Fprintf(&src, "\t%s.%s X2, X3, X4\n", op, rounding)
+						} else {
+							fmt.Fprintf(&src, "\t%s.%s X10, X11, X12\n", op, rounding)
+						}
+						if target.goarch == "amd64" {
+							fmt.Fprintf(&src, "\t%s.%s.Z X13, X14, K3, X15\n", op, rounding)
+						}
+					}
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			// Keep every original Go format and its public Context boundary.
+			// This source has no numerical/native/merge producers; initialized
+			// Arithmetic public objects have their own complete independent matrix.
+			file, signatures := x86UnboundVoidFormatSource(t, src.String(),
+				"binary_floating_complete_forms", target.goarch, target.triple)
+			local := *file
+			local.Funcs = append([]Func(nil), file.Funcs...)
+			local.Funcs[0].Instrs = nil
+			contextRows := 0
+			for _, instruction := range file.Funcs[0].Instrs {
+				if _, known, err := x86FloatArithmeticProperties(instruction, target.goarch, ""); known && err != nil {
+					highRegister := false
+					for _, operand := range instruction.Args {
+						name := string(operand.Reg)
+						if operand.Kind != OpReg || len(name) < 2 || !strings.ContainsRune("XYZ", rune(name[0])) {
+							continue
+						}
+						index, parseErr := strconv.Atoi(name[1:])
+						highRegister = highRegister || parseErr == nil && index >= 8
+					}
+					if target.goarch != "386" || !highRegister || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original arithmetic format became malformed", instruction.Raw, err)
+					}
+					contextRows++
+					continue // Only the unbound physical bank lacks an emitter object.
+				}
+				local.Funcs[0].Instrs = append(local.Funcs[0].Instrs, instruction)
+			}
+			if target.goarch == "386" && contextRows != 44 || target.goarch == "amd64" && contextRows != 0 {
+				t.Fatal("original arithmetic physical-bank partition changed", target.goarch, contextRows)
+			}
+			ll := x86ScalarFormatObjectUnit(t, &local, signatures, target.goarch, target.triple, 0)
+			compileLLVMToObject(t, llc, target.triple, "binary-floating-complete-"+target.name+".ll", "binary-floating-complete-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86BinaryFloatingRejectsFormsOutsideGo127Tables(t *testing.T) {
+	reject := func(t *testing.T, instruction string) {
+		t.Helper()
+		src := "TEXT invalid_binary_floating(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			return
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "x86_64-unknown-linux-gnu",
+			Goarch:       "amd64",
+			Sigs: map[string]FuncSig{
+				"invalid_binary_floating": {Name: "invalid_binary_floating", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's _yvaddpd/_yvaddsd tables", instruction)
+		}
+	}
+	for _, op := range go127BinaryFloatingOps(false) {
+		forms := []string{
+			"X0, X1",
+			"X0, X1, X2, X3, X4",
+			"X0, Y1, Y2",
+			"X0, 8(BX), X2",
+			"X0, X1, K0, X2",
+			"X0, X1, AX",
+			".Z X0, X1, X2",
+			".BCST X0, X1, X2",
+			".BCST.Z 8(BX), X1, X2",
+			".Z.BCST 8(BX), X1, K1, X2",
+		}
+		if go127BinaryFloatingUsesSAE(op) {
+			forms = append(forms,
+				".RN_SAE Z0, Z1, Z2",
+				".SAE X0, X1, X2",
+				".SAE 8(BX), Z1, Z2",
+				".BCST.SAE 8(BX), Z1, Z2",
+			)
+		} else {
+			forms = append(forms,
+				".SAE Z0, Z1, Z2",
+				".RN_SAE X0, X1, X2",
+				".RN_SAE 8(BX), Z1, Z2",
+				".BCST.RN_SAE 8(BX), Z1, Z2",
+			)
+		}
+		for _, operands := range forms {
+			instruction := op + " " + operands
+			if strings.HasPrefix(operands, ".") {
+				parts := strings.SplitN(operands, " ", 2)
+				instruction = op + parts[0] + " " + parts[1]
+			}
+			t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+				reject(t, instruction)
+			})
+		}
+	}
+	for _, op := range go127BinaryFloatingOps(true) {
+		forms := []string{
+			"X0, X1",
+			"X0, X1, X2, X3, X4",
+			"Y0, X1, X2",
+			"X0, 8(BX), X2",
+			"X0, X1, K0, X2",
+			".Z X0, X1, X2",
+			".BCST 8(BX), X1, X2",
+		}
+		if go127BinaryFloatingUsesSAE(op) {
+			forms = append(forms, ".RN_SAE X0, X1, X2", ".SAE 8(BX), X1, X2")
+		} else {
+			forms = append(forms, ".SAE X0, X1, X2", ".RN_SAE 8(BX), X1, X2")
+		}
+		for _, operands := range forms {
+			instruction := op + " " + operands
+			if strings.HasPrefix(operands, ".") {
+				parts := strings.SplitN(operands, " ", 2)
+				instruction = op + parts[0] + " " + parts[1]
+			}
+			t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+				reject(t, instruction)
+			})
+		}
+	}
+}
+
+func TestTranslate386BinaryFloatingRejectsArchitectureRestrictedForms(t *testing.T) {
+	var instructions []string
+	for _, op := range append(go127BinaryFloatingOps(false), go127BinaryFloatingOps(true)...) {
+		if strings.HasSuffix(op, "PS") || strings.HasSuffix(op, "PD") {
+			instructions = append(instructions, op+" X0, X1, K1, X2", op+" Z6, Z7, Z8", op+" Z8, Z7, Z6")
+		} else {
+			instructions = append(instructions, op+" X0, X1, K1, X2")
+		}
+	}
+	for _, instruction := range instructions {
+		src := "TEXT invalid_binary_floating_386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs: map[string]FuncSig{
+				"invalid_binary_floating_386": {Name: "invalid_binary_floating_386", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's 386 register/operand limits", instruction)
+		}
+	}
+}
+
+func TestTranslateX86HorizontalFloatingCompleteGo127Forms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			second, destination := 14, 15
+			if target.goarch == "386" {
+				second, destination = 6, 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT horizontal_floating_complete_forms(SB),4,$0-0\n")
+			for _, operation := range []string{"HADD", "HSUB"} {
+				for _, element := range []string{"PS", "PD"} {
+					op := operation + element
+					fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+					fmt.Fprintf(&src, "\t%s 8(BX), X%d\n", op, destination)
+					vop := "V" + op
+					fmt.Fprintf(&src, "\t%s X0, X1, X2\n", vop)
+					fmt.Fprintf(&src, "\t%s 16(BX), X%d, X%d\n", vop, second, destination)
+					fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", vop)
+					fmt.Fprintf(&src, "\t%s 32(BX), Y%d, Y%d\n", vop, second, destination)
+				}
+			}
+			src.WriteString("\tRET\n")
+			goAssemblerOracleOutput(t, target.goarch, src.String(), "", true)
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "horizontal_floating_complete_forms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "horizontal-floating-complete-"+target.name+".ll", "horizontal-floating-complete-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86HorizontalFloatingRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, op := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD", "VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD"} {
+		forms := []string{"X0", "X0, X1, X2, X3", "Y0, X1", "X16, X1"}
+		validOperands := "X0, X1"
+		if strings.HasPrefix(op, "V") {
+			forms = []string{
+				"X0, X1", "X0, X1, X2, X3", "X0, Y1, Y2", "X16, X1, X2",
+				"X0, X1, X16", "Z0, Z1, Z2", "X0, X1, K1, X2",
+			}
+			validOperands = "X0, X1, X2"
+		}
+		var instructions []string
+		for _, operands := range forms {
+			instructions = append(instructions, op+" "+operands)
+		}
+		for _, suffix := range []string{".Z", ".BCST", ".SAE", ".RN_SAE"} {
+			instructions = append(instructions, op+suffix+" "+validOperands)
+		}
+		for _, instruction := range instructions {
+			t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+				src := "TEXT invalid_horizontal_floating(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+				file, err := Parse(ArchAMD64, src)
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, Options{
+					TargetTriple: "x86_64-unknown-linux-gnu",
+					Goarch:       "amd64",
+					Sigs: map[string]FuncSig{
+						"invalid_horizontal_floating": {Name: "invalid_horizontal_floating", Ret: Void},
+					},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q outside Go 1.27's yxm/_yvaddsubpd tables", instruction)
+				}
+			})
+		}
+	}
+}
+
+func translateAMD64EcosystemCase(t *testing.T, src, symbol string) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs:         map[string]FuncSig{symbol: {Name: symbol, Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ll
+}
+
+func translateX86FrameCase(t *testing.T, src, goarch, triple, symbol string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{
+		Params: []FrameSlot{
+			{Offset: 0, Type: I64, Index: 0, Field: -1},
+			{Offset: 8, Type: I64, Index: 1, Field: -1},
+		},
+		Results: []FrameSlot{
+			{Offset: 16, Type: I64, Index: 0, Field: -1},
+			{Offset: 24, Type: I64, Index: 1, Field: -1},
+		},
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs: map[string]FuncSig{symbol: {
+			Name:  symbol,
+			Args:  []LLVMType{I64, I64},
+			Ret:   LLVMType("{ i64, i64 }"),
+			Frame: frame,
+		}},
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_encoding_writeback_arm64_test.go b/amd64_encoding_writeback_arm64_test.go
new file mode 100644
index 000000000..ae7eecdf0
--- /dev/null
+++ b/amd64_encoding_writeback_arm64_test.go
@@ -0,0 +1,10 @@
+package plan9asm
+
+import "testing"
+
+// These source instructions use their actual portable ARM64 backend paths.
+// Native x86-only reciprocal/ER and MXCSR-reading paths remain in the object
+// inventory; no intrinsic or status computation is stripped for this host.
+func TestX86EncodingWritebackPortableARM64(t *testing.T) {
+	x86EncodingWritebackRuntime(t, x86ScalarCountHostExecution(t), "portable")
+}
diff --git a/amd64_encoding_writeback_linux_amd64_test.go b/amd64_encoding_writeback_linux_amd64_test.go
new file mode 100644
index 000000000..dba1ba02b
--- /dev/null
+++ b/amd64_encoding_writeback_linux_amd64_test.go
@@ -0,0 +1,9 @@
+package plan9asm
+
+import "testing"
+
+// This counterpart observes the actual Y bank and requires native AVX2.
+// It does not substitute a Y observation for AVX512's complete Z bank.
+func TestCrossLinuxRuntimeMatrixX86EncodingWritebackAVX2(t *testing.T) {
+	x86EncodingWritebackRuntime(t, fixedLocalVEXNativeTools(t), "avx2")
+}
diff --git a/amd64_encoding_writeback_test.go b/amd64_encoding_writeback_test.go
new file mode 100644
index 000000000..84a2c2473
--- /dev/null
+++ b/amd64_encoding_writeback_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86EncodingWritebackCase struct {
+	instruction        string
+	width, scalarBytes int
+	legacy             bool
+	portable, avx2     bool
+	gather             int // 1: VEX vector mask; 2: EVEX predicate mask.
+}
+
+// One observation per writer path, plus independent legacy and wider controls.
+// Arithmetic and fault oracles stay with each family; this matrix observes
+// physical upper bytes, scalar passthrough, aliases and unrelated state only.
+var x86EncodingWritebackCases = []x86EncodingWritebackCase{
+	{"VRANGEPS $0,X1,X2,X@", 16, 0, false, true, false, 0},
+	{"VRANGESS $0,X1,X2,X@", 16, 4, false, true, false, 0},
+	{"VGETMANTPS $0,X1,X@", 16, 0, false, false, false, 0},
+	{"VGETMANTSD $0,X1,X2,X@", 16, 8, false, false, false, 0},
+	{"VADDSUBPS X1,X2,X@", 16, 0, false, true, true, 0},
+	{"ADDSUBPS X1,X@", 16, 0, true, true, true, 0},
+	{"VADDPS X1,X2,X@", 16, 0, false, true, true, 0},
+	{"VADDSD X1,X2,X@", 16, 8, false, true, true, 0},
+	{"VADDPS X1,X2,K1,X@", 16, 0, false, true, false, 0},
+	{"VADDPS.Z X1,X2,K1,X@", 16, 0, false, true, false, 0},
+	{"VADDSD X1,X2,K1,X@", 16, 8, false, true, false, 0},
+	{"VADDSD.Z X1,X2,K1,X@", 16, 8, false, true, false, 0},
+	{"VGATHERDPS X2,(AX)(X1*4),X@", 16, 0, false, true, true, 1},
+	{"VGATHERDPS (AX)(X1*4),K1,X@", 16, 0, false, true, false, 2},
+	{"VPMOVDB Z1,X@", 16, 0, false, true, false, 0},
+	{"VPMOVDW Z1,Y@", 32, 0, false, true, false, 0},
+	{"VGETEXPPS X1,X@", 16, 0, false, false, false, 0},
+	{"VGETEXPSS X1,X2,X@", 16, 4, false, false, false, 0},
+	{"VRCP14PS X1,X@", 16, 0, false, false, false, 0},
+	{"VRCP14SS X1,X2,X@", 16, 4, false, false, false, 0},
+	{"VRCPPS X1,X@", 16, 0, false, false, true, 0},
+	{"RCPPS X1,X@", 16, 0, true, false, true, 0},
+	{"VRCP28SS X1,X2,X@", 16, 4, false, false, false, 0},
+	{"VEXP2PS Z1,Z@", 64, 0, false, false, false, 0},
+	{"VRNDSCALEPS $0,X1,X@", 16, 0, false, false, false, 0},
+	{"VREDUCESD $0,X1,X2,X@", 16, 8, false, false, false, 0},
+	{"VROUNDPS $0,X1,X@", 16, 0, false, true, true, 0},
+	{"ROUNDPS $0,X1,X@", 16, 0, true, true, true, 0},
+	{"VROUNDSS $0,X1,X2,X@", 16, 4, false, true, true, 0},
+	{"ROUNDSS $0,X1,X@", 16, 4, true, true, true, 0},
+	{"VSCALEFPS X1,X2,X@", 16, 0, false, false, false, 0},
+	{"VSCALEFSS X1,X2,X@", 16, 4, false, false, false, 0},
+	{"VFIXUPIMMPS $0,X1,X2,X@", 16, 0, false, false, false, 0},
+	{"VFIXUPIMMSD $0,X1,X2,X@", 16, 8, false, false, false, 0},
+	{"VSHUFI32X4 $0,Y1,Y2,Y@", 32, 0, false, true, false, 0},
+	{"VPERMD Y1,Y2,Y@", 32, 0, false, true, true, 0},
+	{"VRANGEPS $0,X1,X2,K1,X@", 16, 0, false, true, false, 0},
+	{"VRANGEPS.Z $0,X1,X2,K1,X@", 16, 0, false, true, false, 0},
+	{"VFIXUPIMMSD $0,X1,X2,K1,X@", 16, 8, false, false, false, 0},
+	{"VFIXUPIMMSD.Z $0,X1,X2,K1,X@", 16, 8, false, false, false, 0},
+}
+
+func x86EncodingWritebackProgram(t *testing.T, mode string) (string, string, string) {
+	t.Helper()
+	physical, bank := 64, "Z"
+	if mode == "avx2" {
+		physical, bank = 32, "Y"
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, row := range x86EncodingWritebackCases {
+		if mode == "portable" && !row.portable || mode == "avx2" && !row.avx2 {
+			continue
+		}
+		aliases := []int{0, 1}
+		if row.gather != 0 {
+			aliases = []int{0, 3} // A gather destination must not alias its VSIB index or mask.
+		}
+		for _, destination := range aliases {
+			instruction := strings.ReplaceAll(row.instruction, "@", fmt.Sprint(destination))
+			name := fmt.Sprint("Writer", count)
+			fmt.Fprintf(&declarations, "func %s(out *[260]byte,state *[256]byte,p *[64]byte,mask uint64)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ state+8(FP),SI\nMOVQ p+16(FP),AX\n", name)
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&source, "VMOVUPS %d(SI),%s%d\n", register*64, bank, register)
+			}
+			if strings.Contains(instruction, "K1") {
+				source.WriteString("KMOVQ mask+24(FP),K1\n")
+			}
+			source.WriteString("MOVL $5,R8\nCMPL R8,$3\n")
+			source.WriteString(instruction + "\n")
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&source, "VMOVUPS %s%d,%d(DI)\n", bank, register, register*64)
+			}
+			source.WriteString("SETCS 256(DI)\nSETOS 257(DI)\nRET\n")
+			fmt.Fprintf(&prototypes, "extern void InstructionFormat%d(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", count)
+			fmt.Fprintf(&rows, "{InstructionFormat%d,%q,%d,%d,%d,%d,%t,%d},\n",
+				count, instruction, physical, row.width, row.scalarBytes, destination, row.legacy, row.gather)
+			count++
+		}
+	}
+	if len(x86EncodingWritebackCases) != 40 || count == 0 {
+		t.Fatal("encoding writer path inventory changed", len(x86EncodingWritebackCases), mode, count)
+	}
+	want := map[string]int{"all": 80, "portable": 44, "avx2": 24}[mode]
+	if count != want {
+		t.Fatal("execution counterpart lost its exact original row partition", mode, count, want)
+	}
+	t.Logf("%s: %d original functions; native-only/MXCSR/ER rows remain in the full 80-function object inventory", mode, count)
+	driver := strings.NewReplacer("PROTOTYPES", prototypes.String(), "ROWS", rows.String()).Replace(x86EncodingWritebackDriver)
+	return source.String(), declarations.String(), driver
+}
+
+func x86EncodingWritebackIR(t *testing.T, mode, triple string) (string, string) {
+	t.Helper()
+	source, declarations, driver := x86EncodingWritebackProgram(t, mode)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "writer", "package writer\n"+declarations)
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The complete initialized instruction emitter is isolated from public
+	// source-effect registration. Do not count this as public API acceptance.
+	return x86ScalarFormatObjectUnit(t, file, sigs, "amd64", triple, 0), driver
+}
+
+func TestX86EncodingWritebackCompleteEmitterObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := x86EncodingWritebackIR(t, "all", triple)
+			for _, level := range []string{"-O0", "-O2"} {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				x86PackedStringCompileObject(t, llc, triple, input, level)
+			}
+		})
+	}
+}
+
+func x86EncodingWritebackRuntime(t *testing.T, execution x86FloatCompareExecution, mode string) {
+	t.Helper()
+	ir, driver := x86EncodingWritebackIR(t, mode, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86MulDivRoundOptimize(t, ir)
+			}
+			execution.compileAndRunLLVM(t, "encoding-writeback", input, driver, level)
+		})
+	}
+}
+
+const x86EncodingWritebackDriver = `
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+struct row {
+    void (*run)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+    const char *name;
+    unsigned physical,width,scalar,destination;
+    bool legacy;
+    unsigned gather;
+};
+static const struct row rows[]={ROWS};
+int main(void) {
+    const uint64_t masks[]={0,1,5,UINT64_MAX};
+    unsigned failures=0;
+    for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+        const struct row *row=&rows[r];
+        for(unsigned sample=0;sample<4;sample++) {
+            uint8_t state[256],before[256],output[262],memory[64];
+            for(unsigned bank=0;bank<4;bank++) for(unsigned lane=0;lane<16;lane++) {
+                uint32_t bits=UINT32_C(0x3fc00000)+bank*UINT32_C(0x100000)+lane*256+sample*65536;
+                memcpy(state+bank*64+lane*4,&bits,4);
+            }
+            if(row->gather) memset(state+64,0,64);
+            if(row->gather==1) memset(state+128,255,64);
+            memcpy(before,state,256);
+            memset(memory,0x37,64);
+            memset(output,0xa7,sizeof(output));
+            row->run(output+1,state,memory,masks[sample]);
+            if(memcmp(state,before,256)||output[0]!=0xa7||output[259]!=0xa7||
+               output[260]!=0xa7||output[261]!=0xa7||output[257]||output[258])return 1;
+            for(unsigned byte=0;byte<64;byte++)if(memory[byte]!=0x37)return 1;
+            for(unsigned byte=0;byte<256;byte++) {
+                unsigned bank=byte/64,lane=byte%64;
+                unsigned expected=before[byte];
+                if(lane>=row->physical)expected=0xa7;
+                else if(bank==row->destination) {
+                    if(lane>=row->width)expected=row->legacy?before[byte]:0;
+                    else if(row->scalar && lane>=row->scalar && lane<16)
+                        expected=before[(row->legacy?row->destination:2)*64+lane];
+                    else continue; /* Per-family oracles own the arithmetic result. */
+                } else if(row->gather==1 && bank==2)expected=0;
+                if(output[byte+1]!=expected) {
+                    fprintf(stderr,"%s sample=%u bank=%u byte=%u got=%x want=%x\n",
+                            row->name,sample,bank,lane,output[byte+1],expected);
+                    failures++;
+                    break;
+                }
+            }
+        }
+    }
+    fprintf(stderr,"encoding writeback rows=%zu failed samples=%u\n",sizeof(rows)/sizeof(rows[0]),failures);
+    return failures?1:0;
+}
+`
diff --git a/amd64_enqueue_forms.go b/amd64_enqueue_forms.go
new file mode 100644
index 000000000..772721ca8
--- /dev/null
+++ b/amd64_enqueue_forms.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type x86EnqueueForm struct {
+	native      string
+	source      Operand
+	destination Operand
+	addressBits int
+	wordBits    int
+}
+
+// Both instructions use m512 and a read-only GP address. REX.W and 66 do
+// not select that register's width; the address-size attribute does.
+func x86EnqueueProperties(op Op, ins Instr, arch string) (x86EnqueueForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base := strings.SplitN(name, ".", 2)[0]
+	if _, known := x86EnqueueOps[base]; !known {
+		return x86EnqueueForm{}, false, nil
+	}
+	fail := func() (x86EnqueueForm, bool, error) {
+		return x86EnqueueForm{}, true, fmt.Errorf("%s %s requires an exact memory/GP enqueue address form: %q", arch, op, ins.Raw)
+	}
+	if name != base || arch != "amd64" && arch != "386" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 2 {
+		return fail()
+	}
+	form := x86EnqueueForm{native: strings.ToLower(base), source: ins.Args[0], destination: ins.Args[1], wordBits: 64}
+	if arch == "386" {
+		form.wordBits = 32
+	}
+	form.addressBits = ins.x86AddressBits
+	if form.addressBits == 0 {
+		form.addressBits = form.wordBits
+	}
+	if form.addressBits != form.wordBits && form.addressBits != form.wordBits/2 ||
+		!reflect.DeepEqual(form.destination, Operand{Kind: OpReg, Reg: form.destination.Reg}) ||
+		!isX86YrlRegisterForArch(form.destination.Reg, arch) {
+		return fail()
+	}
+	source := form.source
+	switch source.Kind {
+	case OpMem:
+		memory := source.Mem
+		if !reflect.DeepEqual(source, Operand{Kind: OpMem, Mem: memory}) ||
+			memory.OffRaw != "" || memory.IndexExt != "" || !x86MemoryRegistersValidForArch(memory, arch) ||
+			!x86EnqueueAddressEncoding(memory, form.addressBits) ||
+			memory.Segment != "" && memory.Segment != FS && memory.Segment != GS ||
+			memory.Index == SP || memory.Index == "" && memory.Scale != 0 ||
+			memory.Index != "" && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+			return fail()
+		}
+	case OpSym:
+		if source.Sym == "" || !reflect.DeepEqual(source, Operand{Kind: OpSym, Sym: source.Sym}) {
+			return fail()
+		}
+	case OpFP:
+		if !reflect.DeepEqual(source, Operand{Kind: OpFP, FPName: source.FPName, FPOffset: source.FPOffset}) {
+			return fail()
+		}
+	default:
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86EnqueueAddressEncoding(memory MemRef, bits int) bool {
+	if bits == 16 {
+		if memory.Off < -1<<15 || memory.Off > 1<<16-1 {
+			return false
+		}
+		if memory.Index != "" {
+			return (memory.Base == BX || memory.Base == BP) &&
+				(memory.Index == SI || memory.Index == DI) && memory.Scale == 1
+		}
+		return memory.Base == "" || memory.Base == BX || memory.Base == BP || memory.Base == SI || memory.Base == DI
+	}
+	maximum := int64(1<<31 - 1)
+	if bits == 32 {
+		maximum = 1<<32 - 1
+	}
+	return memory.Off >= -1<<31 && memory.Off <= maximum
+}
+
+// This exact ordinary-address source boundary is shared by the paired native
+// continuation and its storage post-consumers, never by declaration queries.
+func x86EnqueueSourceForm(ins Instr, arch string) (x86EnqueueForm, bool) {
+	form, known, err := x86EnqueueProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.addressBits != form.wordBits || form.source.Kind != OpMem ||
+		form.source.Mem.Segment != "" || ins.x86Encoded || ins.x86RawNearReturn != nil ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 || ins.x86NumericalRead != nil {
+		return form, false
+	}
+	origin := ins.x86SourceRaw
+	if origin == nil {
+		return form, ins.x86AddressBits == 0
+	}
+	return form, ins.x86AddressBits == form.wordBits &&
+		strings.EqualFold(string(origin.op), string(ins.Op)) && reflect.DeepEqual(origin.args, ins.Args)
+}
+
+// Only the accepted transfer establishes inputs. This predicate preserves
+// existing DF/ID/private storage; it creates no memory or entry permission.
+func x86EnqueuePreservesStorage(ins Instr) bool {
+	arch := "amd64"
+	if ins.x86AddressBits == 32 {
+		arch = "386"
+	}
+	_, valid := x86EnqueueSourceForm(ins, arch)
+	return valid
+}
+
+func x86LoweredEnqueueResultStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	_, known, err := x86EnqueueProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	form, valid := x86EnqueueSourceForm(ins, arch)
+	if !valid || !x86ResultIncomingPointerAddressIdentity(form.source, state, arch) {
+		return false, true
+	}
+	device := Operand{Kind: OpMem, Mem: MemRef{Base: form.destination.Reg}}
+	if !x86ResultIncomingPointerAddressIdentity(device, state, arch) {
+		return false, true
+	}
+	// The original hardware opcode either faults or returns retry status. No
+	// successful submission, PASID, privilege, pointee or future read follows.
+	state.flags = x86ByteFlagsAll
+	return true, true
+}
diff --git a/amd64_eval.go b/amd64_eval.go
index 16a0454d8..c155d3569 100644
--- a/amd64_eval.go
+++ b/amd64_eval.go
@@ -6,6 +6,12 @@ import (
 )
 
 func (c *amd64Ctx) evalI64(op Operand) (string, error) {
+	if c.goReadOnlyOperand.allows(op, 8) {
+		return c.evalIntSized(op, I64)
+	}
+	if err := unresolvedSymbolicImmediateErrorForArch(op, ArchAMD64); err != nil {
+		return "", err
+	}
 	switch op.Kind {
 	case OpImm:
 		return fmt.Sprintf("%d", op.Imm), nil
@@ -26,18 +32,18 @@ func (c *amd64Ctx) evalI64(op Operand) (string, error) {
 		addrOnly := strings.HasPrefix(s, "$")
 		if addrOnly {
 			s = strings.TrimSpace(strings.TrimPrefix(s, "$"))
+			if mem, matched, err := parseX86SymbolIndexedMemory(s); matched {
+				if err != nil {
+					return "", err
+				}
+				return c.addrFromSymbolIndexedAddress(mem)
+			}
 			if mem, ok := parseMem(s); ok {
 				return c.addrFromMem(mem)
 			}
 		}
 		p, err := c.ptrFromSB(s)
 		if err != nil {
-			// Some runtime asm constants (e.g. $const_stackGuard) come from
-			// includes/macros that we don't fully materialize. Treat unresolved
-			// bare symbols as immediate zero to keep translation progressing.
-			if !strings.Contains(s, "(SB)") {
-				return "0", nil
-			}
 			return "", err
 		}
 		if addrOnly {
diff --git a/amd64_explicit_mask_move_forms.go b/amd64_explicit_mask_move_forms.go
new file mode 100644
index 000000000..9a4ecc0ca
--- /dev/null
+++ b/amd64_explicit_mask_move_forms.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ExplicitMaskMoveSpec struct {
+	laneBits int
+}
+
+// Go's complete _yvmaskmovpd table: X/Y load/store with vector sign-bit
+// masks, not K writemasks. VMASKMOVPS/PD are W0, not WIG (W1 raises #UD).
+var amd64ExplicitMaskMoveSpecs = map[Op]amd64ExplicitMaskMoveSpec{
+	"VMASKMOVPS": {laneBits: 32},
+	"VMASKMOVPD": {laneBits: 64},
+	"VPMASKMOVD": {laneBits: 32},
+	"VPMASKMOVQ": {laneBits: 64},
+}
+
+type x86ExplicitMaskMoveForm struct {
+	spec      amd64ExplicitMaskMoveSpec
+	byteWidth int
+	memory    int
+	load      bool
+}
+
+// Shape supplies no numerical mask bits, native address or frame backing.
+func x86ExplicitMaskMoveProperties(op Op, ins Instr, arch string) (x86ExplicitMaskMoveForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64ExplicitMaskMoveSpecs[Op(name)]
+	form := x86ExplicitMaskMoveForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86ExplicitMaskMoveForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go explicit vector-mask move grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 3 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	form.load = isAMD64MemoryOperand(ins.Args[0])
+	if form.load == isAMD64MemoryOperand(ins.Args[2]) {
+		return fail()
+	}
+	form.memory = 2
+	data := ins.Args[0]
+	if form.load {
+		form.memory, data = 0, ins.Args[2]
+	}
+	form.byteWidth = amd64VectorByteWidth(ins.Args[1].Reg)
+	if form.byteWidth != 16 && form.byteWidth != 32 ||
+		!amd64VEXVectorRegister(ins.Args[1], form.byteWidth) || !amd64VEXVectorRegister(data, form.byteWidth) {
+		return fail()
+	}
+	memory := ins.Args[form.memory]
+	if memory.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(memory.Mem, arch); err != nil {
+			return form, true, err
+		}
+		if memory.Mem.OffRaw != "" || memory.Mem.IndexExt != "" {
+			return fail()
+		}
+		if arch == "386" && strings.HasSuffix(memory.Mem.Sym, "(SB)") {
+			memory.Mem.Base = "" // Go ignores this annotation, not the index input.
+		}
+	}
+	if !x86PackedShiftMemoryValid(memory, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+// Only the byte containing each lane's most significant bit is an input.
+func (f x86ExplicitMaskMoveForm) signByteInputs() uint64 {
+	lane := f.spec.laneBits / 8
+	var required uint64
+	for offset := lane - 1; offset < f.byteWidth; offset += lane {
+		required |= uint64(1) << uint(offset)
+	}
+	return required
+}
+
+func x86TypedExplicitMaskMoveByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86ExplicitMaskMoveProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	width := int64(f.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: width, read: true},
+		{index: 1, operand: ins.Args[1], width: width, read: true},
+		{index: 2, operand: ins.Args[2], width: width, write: true},
+	}}, true, nil
+}
diff --git a/amd64_extension_native_result_test.go b/amd64_extension_native_result_test.go
new file mode 100644
index 000000000..56d1ae1f1
--- /dev/null
+++ b/amd64_extension_native_result_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Go encoder rows, not the lowerer's extension specification.
+var x86ExtensionNativeOracle = []struct {
+	op, table, prefix, bytes string
+	source, destination      int
+	signed, amd64Only        bool
+}{
+	{"MOVBWSX", "ymb_rl", "Pq", "0xbe", 1, 2, true, false},
+	{"MOVBWZX", "ymb_rl", "Pq", "0xb6", 1, 2, false, false},
+	{"MOVBLSX", "ymb_rl", "Pm", "0xbe", 1, 4, true, false},
+	{"MOVBLZX", "ymb_rl", "Pm", "0xb6", 1, 4, false, false},
+	{"MOVBQSX", "ymb_rl", "Pw", "0x0f, 0xbe", 1, 8, true, true},
+	{"MOVBQZX", "ymb_rl", "Pw", "0x0f, 0xb6", 1, 8, false, true},
+	{"MOVWLSX", "yml_rl", "Pm", "0xbf", 2, 4, true, false},
+	{"MOVWLZX", "yml_rl", "Pm", "0xb7", 2, 4, false, false},
+	{"MOVWQSX", "yml_rl", "Pw", "0x0f, 0xbf", 2, 8, true, true},
+	{"MOVWQZX", "yml_rl", "Pw", "0x0f, 0xb7", 2, 8, false, true},
+	{"MOVLQSX", "yml_rl", "Pw", "0x63", 4, 8, true, true},
+	{"MOVLQZX", "yml_rl", "Px", "0x8b", 4, 8, false, false},
+	{"MOVSWW", "ymb_rl", "Pe", "0x0f, 0xbf", 2, 2, true, false},
+	{"MOVZWW", "ymb_rl", "Pe", "0x0f, 0xb7", 2, 2, false, false},
+}
+
+func TestX86ExtensionCompleteEncoderAttributes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range x86ExtensionNativeOracle {
+		want := fmt.Sprintf("{A%s, %s, %s, opBytes{%s}}", row.op, row.table, row.prefix, row.bytes)
+		if !strings.Contains(string(data), want) {
+			t.Fatal("original Go encoder attributes changed:", want)
+		}
+	}
+}
+
+func x86ExtensionNativeFixture(name, arch, body string, dead bool) (string, string) {
+	word, move, lane, typ, seed := 8, "MOVQ", "Q", "uint64", "0x87654321fedcba98"
+	if arch == "386" {
+		word, move, lane, typ, seed = 4, "MOVL", "D", "uint32", "0xfedcba98"
+	}
+	tail := fmt.Sprintf("PINSR%s $0,CX,X1\nPEXTR%s $0,X1,AX\n%s AX,ret+%d(FP)\n", lane, lane, move, word)
+	decl := fmt.Sprintf("func %s(p *[4]byte) %s\n", name, typ)
+	args := word * 2
+	if dead {
+		tail = ""
+		decl = fmt.Sprintf("func %s(p *[4]byte)\n", name)
+		args = word
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DX\nMOVL $1,BX\n%s $%s,CX\n%s\n%sRET\n",
+		name, args, move, move, seed, body, tail)
+	return source, decl
+}
+
+func TestX86ExtensionNativeResultsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86ExtensionNativeOracle {
+				if target.arch == "386" && row.amd64Only {
+					continue // Independently Go-rejected mode; covered by the existing rejection oracle.
+				}
+				for _, address := range []string{"(DX)", "-1(DX)(BX*1)"} {
+					asm, decl := x86ExtensionNativeFixture(fmt.Sprintf("F%d", count), target.arch, row.op+" "+address+",CX", false)
+					source.WriteString(asm)
+					declarations.WriteString(decl)
+					count++
+				}
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("native extension must supply only its continued numerical result:", err)
+					}
+					if strings.Count(ir, "load volatile i") != count {
+						t.Fatal("conditional results lack paired exact native reads")
+					}
+					compileLLVMToObject(t, llc, target.triple, "extension-native.ll", "extension-native.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ExtensionDeadNativeReadSurvivesOptimization(t *testing.T) {
+	for _, row := range x86ExtensionNativeOracle {
+		t.Run(row.op, func(t *testing.T) {
+			source, declaration := x86ExtensionNativeFixture("F", "amd64", row.op+" (DX),CX", true)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := fmt.Sprintf("load volatile i%d,", row.source*8)
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				if strings.Count(text, want) != 1 {
+					t.Fatalf("dead native %s lost its exact %d-byte read", row.op, row.source)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ExtensionNativeResultsDoNotGrantStandaloneMemory(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86ExtensionNativeOracle {
+			if arch == "386" && row.amd64Only {
+				continue
+			}
+			body := fmt.Sprintf("%s p+0(FP),DX\nMOVL $0,CX\n%s (DX),CX\nMOVL CX,ret0+%d(FP)\nRET", move, row.op, word)
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *[4]byte) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s/%s acquired standalone memory: %v", arch, row.op, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExtensionNativeResultBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for name, body := range map[string]string{
+			"unknown base":                        "MOVBLZX (DI),CX",
+			"numeric base":                        "MOVL $42,DX\nMOVBLZX (DX),CX",
+			"unknown index":                       "MOVBLZX (DX)(DI*1),CX",
+			"pointer index":                       "MOVBLZX (DX)(DX*1),CX",
+			"unbound data":                        "MOVBLZX ·external(SB),CX",
+			"word high bytes":                     move + " DX,CX\nMOVBWSX (DX),CX",
+			"pointer clobbered by partial result": "MOVBWSX (DX),DX\nMOVBLZX (DX),CX",
+			"mixed pointer join": "CMPL BX,$0\nJE other\n" + move + " DX,DI\nJMP end\n" +
+				"other:\nMOVL $42,DI\nend:\nMOVBLZX (DI),CX",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				source, decl := x86ExtensionNativeFixture("F", arch, body, false)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if name == "numeric base" {
+					x86RequireNumericNativeSourceContext(t, source, decl, arch)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, decl, arch, triple, api)
+					if name == "numeric base" {
+						if err != nil || !strings.Contains(ir, "load volatile i8,") {
+							t.Fatal("complete NUM address lost its byte extension read", api, err)
+						}
+						x86NumericNativeAddressObject(t, ir, triple)
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s manufactured numerical or pointer bytes: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExtensionNativeResultEffectsAndOriginBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ExtensionNativeOracle {
+			if arch == "386" && row.amd64Only {
+				continue
+			}
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row.op+" -1(DX)(BX*1),CX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			base, _, _ := x86ResultGP(DX, 4, arch)
+			index, _, _ := x86ResultGP(BX, 4, arch)
+			destination, _, _ := x86ResultGP(CX, 4, arch)
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.pointerGP[base] = true
+			state.gp[index] = 0xff
+			before := state.clone()
+			accepted, known := x86LoweredScalarExtensionRead(ins, &state, nil, 0, arch)
+			want := uint8(0xff)
+			if row.destination == 2 {
+				want = 3 // W leaves every other byte unknown.
+			}
+			if !accepted || !known || state.gp[destination] != want || state.flags != before.flags ||
+				!state.pointerGP[base] || state.gp[base] != 0 || state.pointerGP[destination] {
+				t.Fatalf("%s/%s widened its effect: %+v", arch, row.op, state)
+			}
+			for _, mutation := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment"} {
+				changed, rejected := ins, before.clone()
+				switch mutation {
+				case "decoded":
+					changed.x86Encoded = true
+				case "raw":
+					changed.x86SourceRaw = new(x86SourceRawInstruction)
+				case "raw return":
+					changed.x86RawNearReturn = new(x86RawNearReturnForm)
+				case "address":
+					changed.x86AddressBits = 32
+				case "unbound address":
+					changed.x86UnboundAddressOverride = true
+				case "segment":
+					changed.x86SegmentPrefix = 0x64
+				}
+				if accepted, _ := x86LoweredScalarExtensionRead(changed, &rejected, nil, 0, arch); accepted || rejected.gp != before.gp || rejected.pointerGP != before.pointerGP {
+					t.Fatalf("%s/%s granted an unbound %s effect", arch, row.op, mutation)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_extension_native_runtime_unix_test.go b/amd64_extension_native_runtime_unix_test.go
new file mode 100644
index 000000000..675312185
--- /dev/null
+++ b/amd64_extension_native_runtime_unix_test.go
@@ -0,0 +1,164 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ExtensionNativeResultsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	for _, row := range x86ExtensionNativeOracle {
+		for _, dead := range []bool{false, true} {
+			name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+			body := row.op + " -1(DX)(BX*1),CX"
+			native := "MOVQ $0x87654321fedcba98,AX\n" + row.op + " (DI),AX\n"
+			if dead {
+				body += "\nMOVQ $0x87654321fedcba98,CX"
+				native += "MOVQ $0x87654321fedcba98,AX\n"
+			}
+			asm, decl := x86ExtensionNativeFixture(name, "amd64", body, false)
+			source.WriteString(asm)
+			declarations.WriteString(decl)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+native+"RET\n")
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+			signed, discarded := 0, 0
+			if row.signed {
+				signed = 1
+			}
+			if dead {
+				discarded = 1
+			}
+			fmt.Fprintf(&rows, "{%s,%s,%d,%d,%d,%d},\n", name, original, row.source, row.destination, signed, discarded)
+			count++
+		}
+	}
+	if count != 28 {
+		t.Fatal("incomplete live/dead extension family", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := fmt.Sprintf(x86ExtensionNativeRuntimeC, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "extension-native", text, driver, level)
+					if string(output) != "28 extension kernels: numerical 3584, fault 336, tripwires 2; failures 0\n" {
+						t.Fatal("original/LLVM extension semantics or read envelope differs:", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+const x86ExtensionNativeRuntimeC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+%s
+%s
+typedef uint64_t (*Program)(const uint8_t*);
+typedef struct {
+    Program translated, original;
+    unsigned width, destination, sign, dead;
+} Kernel;
+static const Kernel kernels[]={%s};
+static const uint64_t seed=UINT64_C(0x87654321fedcba98);
+
+static uint64_t reference(Kernel k, const uint8_t *p) {
+    if(k.dead) return seed;
+    uint64_t value=0;
+    for(unsigned b=0;b<k.width;b++) value|=(uint64_t)p[b]<<(8*b);
+    if(k.sign && (p[k.width-1]&0x80)) value|=UINT64_MAX<<(8*k.width);
+    if(k.destination==2) return (seed&~UINT64_C(0xffff))|(value&0xffff);
+    if(k.destination==4) return value&UINT64_C(0xffffffff);
+    return value;
+}
+
+static int fault(Program run, const uint8_t *p) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        volatile uint64_t result=run(p);
+        (void)result;
+        _exit(0);
+    }
+    int status=0;
+    if(waitpid(child,&status,0)!=child) return -2;
+    if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -4;
+}
+
+static uint64_t missing_read(const uint8_t *p) { (void)p; return seed; }
+static uint64_t too_wide(const uint8_t *p) { return *(volatile const uint64_t*)p; }
+
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 1;
+    uint8_t *memory=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(memory==MAP_FAILED || mprotect(memory+page,page,PROT_NONE)) return 2;
+    memset(memory,0xa7,page);
+    if(fault(missing_read,NULL)!=0 || fault(too_wide,memory+page-4)!=1) return 3;
+    unsigned numerical=0, faults=0;
+    for(unsigned i=0;i<sizeof(kernels)/sizeof(kernels[0]);i++) {
+        Kernel k=kernels[i];
+        for(unsigned pattern=0;pattern<64;pattern++) {
+            uint8_t bytes[8];
+            for(unsigned b=0;b<sizeof(bytes);b++) bytes[b]=(uint8_t)(pattern*37+b*11);
+            // Both aligned and unaligned inputs; sign and high preserved bytes vary.
+            const uint8_t *p=bytes+(pattern&1);
+            uint64_t want=reference(k,p);
+            if(k.original(p)!=want || k.translated(p)!=want) {
+                fprintf(stderr,"kernel %%u pattern %%u expected %%llx\n",i,pattern,(unsigned long long)want);
+                return 4;
+            }
+            numerical+=2;
+        }
+        for(unsigned address=0;address<6;address++) {
+            // NULL, zero/short/full/extra extents, and ordinary unaligned storage.
+            unsigned available[]={0,0,k.width-1,k.width,k.width+1,0};
+            const uint8_t *p=address==0?NULL:address==5?memory+1:memory+page-available[address];
+            int want=address<3;
+            if(fault(k.original,p)!=want || fault(k.translated,p)!=want) {
+                fprintf(stderr,"kernel %%u address %%u expected fault %%d\n",i,address,want);
+                return 5;
+            }
+            faults+=2;
+        }
+    }
+    if(munmap(memory,2*page)) return 6;
+    printf("28 extension kernels: numerical %%u, fault %%u, tripwires 2; failures 0\n",numerical,faults);
+    return 0;
+}
+`
diff --git a/amd64_extension_symbol_operand_test.go b/amd64_extension_symbol_operand_test.go
new file mode 100644
index 000000000..9c4f377db
--- /dev/null
+++ b/amd64_extension_symbol_operand_test.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86ExtensionBareSymbolsDoNotBecomeNativeStorage(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ExtensionNativeOracle {
+			if arch == "386" && row.amd64Only {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row.op+" broken,AX\nRET\n", "", false)
+				ins := Instr{Op: Op(row.op), Raw: row.op + " broken,AX",
+					Args: []Operand{{Kind: OpSym, Sym: "broken"}, {Kind: OpReg, Reg: AX}}}
+				if _, known, err := x86ScalarExtensionProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Error("shared extension grammar admitted a bare symbol", known, err)
+				}
+				c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.Value", Ret: Void}, nil)
+				c.goarch = arch
+				before := output.String()
+				if handled, _, err := c.lowerMov(ins.Op, ins); !handled || err == nil || before != output.String() {
+					t.Error("direct extension emitter created storage for a bare name", handled, err)
+				}
+				for _, address := range []string{"table<>(SB)", "1234"} {
+					source := fmt.Sprintf("TEXT f(SB),4,$0-0\n%s %s,AX\nRET\n", row.op, address)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					control := ins
+					control.Args = []Operand{{Kind: OpSym, Sym: address}, {Kind: OpReg, Reg: AX}}
+					control.Raw = row.op + " " + address + ",AX"
+					if _, known, err := x86ScalarExtensionProperties(control.Op, control, arch); !known || err != nil {
+						t.Fatal("valid SB/absolute source lost its existing grammar", address, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_address_flags_runtime_go127_test.go b/amd64_fixed_local_address_flags_runtime_go127_test.go
new file mode 100644
index 000000000..2e3d26a0a
--- /dev/null
+++ b/amd64_fixed_local_address_flags_runtime_go127_test.go
@@ -0,0 +1,187 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Each backend checks FLAGS against its own actual global addresses. Different
+// linkers need not place the two objects in the same relative order. Address
+// excursions are integer operations and are never dereferenced here.
+func fixedLocalAddressFlagsProgram(triple string) (assembly, declarations, original, driver string) {
+	operations := []string{
+		"ADDQ CX,SI\nSETCS DL",
+		"SUBQ CX,SI\nSETCS DL",
+		"ADDQ CX,SI\nINCQ SI\nSETEQ DL",
+		"ADDQ CX,SI\nDECQ SI\nSETEQ DL",
+		"ADDQ CX,SI\nMOVQ $·Other(SB),DI\nCMPQ SI,DI\nSETCS DL",
+	}
+	declarations = "var Table, Other [4]uint64\n"
+	var goFunctions, cFunctions, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, operation := range operations {
+		name := fmt.Sprintf("Flags%d", index)
+		assembly += fixedLocalDataAddressFunction(name, "MOVQ $·Table(SB),SI\n"+operation)
+		declarations += "func " + name + "(a uint64) uint64\n"
+		fmt.Fprintf(&goFunctions, "%s,", name)
+		fmt.Fprintf(&cFunctions, "flags%d,", index)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t flags%d(uint64_t) __asm__(%s);\n", index,
+			runtimeCAsmLabel(prefix+"example.invalid/framefixture."+name))
+	}
+	original = `package main
+import ("fmt"; "unsafe")
+` + declarations + `
+func expected(index int, base, other, delta uint64) uint64 {
+    var flag bool
+    switch index {
+    case 0: flag = base+delta < base
+    case 1: flag = base < delta
+    case 2: flag = base+delta+1 == 0
+    case 3: flag = base+delta-1 == 0
+    case 4: flag = base+delta < other
+    default: panic("unknown reference operation")
+    }
+    if flag {
+        return 1
+    }
+    return 0
+}
+func main() {
+    base := uint64(uintptr(unsafe.Pointer(&Table[0])))
+    other := uint64(uintptr(unsafe.Pointer(&Other[0])))
+    inputs := []uint64{0,1,8,^uint64(0),-base,-base-1,1-base,other-base-1,other-base,other-base+1}
+    for i := range Table {
+        Table[i] = uint64(i+1)*0x0102030405060708
+        Other[i] = ^Table[i]
+    }
+    before, beforeOther := Table, Other
+    functions := []func(uint64)uint64{` + goFunctions.String() + `}
+    for index, function := range functions {
+        for sample, delta := range inputs {
+            want, got := expected(index,base,other,delta), function(delta)
+            if got != want || Table != before || Other != beforeOther {
+                panic(fmt.Sprintf("case=%d sample=%d got=%d want=%d",index,sample,got,want))
+            }
+            fmt.Printf("%d %d PASS\n",index,sample)
+        }
+    }
+}
+`
+	driver = "#include <stdint.h>\n#include <stdio.h>\n" + runtimeCAsmLabelPreamble + cDeclarations.String() +
+		fmt.Sprintf("uint64_t table[4] __asm__(%s);\nuint64_t other_table[4] __asm__(%s);\n",
+			runtimeCAsmLabel(prefix+"example.invalid/framefixture.Table"),
+			runtimeCAsmLabel(prefix+"example.invalid/framefixture.Other")) + `
+static uint64_t expected(unsigned index, uint64_t base, uint64_t other, uint64_t delta) {
+    switch (index) {
+    case 0: return base+delta < base;
+    case 1: return base < delta;
+    case 2: return base+delta+1 == 0;
+    case 3: return base+delta-1 == 0;
+    case 4: return base+delta < other;
+    default: return UINT64_MAX;
+    }
+}
+int main(void) {
+    uint64_t base=(uintptr_t)table, other=(uintptr_t)other_table;
+    uint64_t inputs[]={0,1,8,UINT64_MAX,-base,-base-1,1-base,other-base-1,other-base,other-base+1};
+    uint64_t (*functions[])(uint64_t)={` + cFunctions.String() + `};
+    for (unsigned i=0;i<4;i++) {
+        table[i]=(uint64_t)(i+1)*UINT64_C(0x0102030405060708);
+        other_table[i]=~table[i];
+    }
+    for (unsigned index=0;index<5;index++) {
+        for (unsigned sample=0;sample<10;sample++) {
+            uint64_t want=expected(index,base,other,inputs[sample]);
+            uint64_t got=functions[index](inputs[sample]);
+            if (got!=want) {
+                fprintf(stderr,"case=%u sample=%u got=%llu want=%llu\n",
+                    index,sample,(unsigned long long)got,(unsigned long long)want);
+                return 1;
+            }
+            for (unsigned i=0;i<4;i++) {
+                uint64_t value=(uint64_t)(i+1)*UINT64_C(0x0102030405060708);
+                if (table[i]!=value || other_table[i]!=~value) {
+                    return 2;
+                }
+            }
+            printf("%u %u PASS\n",index,sample);
+        }
+    }
+    return 0;
+}
+`
+	return
+}
+
+func fixedLocalAddressFlagsRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly, declarations, original, driver := fixedLocalAddressFlagsProgram(execution.triple)
+	var want []string
+	for index := 0; index < 5; index++ {
+		for sample := 0; sample < 10; sample++ {
+			want = append(want, fmt.Sprintf("%d %d PASS", index, sample))
+		}
+	}
+	check := func(output []byte) {
+		t.Helper()
+		if strings.TrimSpace(string(output)) != strings.Join(want, "\n") {
+			t.Fatalf("native address FLAGS reference did not complete every case:\n%s", output)
+		}
+	}
+	if execute {
+		check(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))
+	} else {
+		x86COMICompileOriginalGo(t, map[string]string{
+			"go.mod": "module addressflags\ngo 1.20\n", "main.go": original, "original_amd64.s": assembly,
+		}, false)
+	}
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations,
+		runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly,
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					if execute {
+						check(execution.compileAndRunLLVM(t, "address-flags", input, driver, level))
+					} else {
+						execution.compileLLVM(t, "address-flags", input, driver, level)
+					}
+				})
+			}
+		})
+	t.Logf("5 complete functions, 10 deltas from each backend's own addresses, independent arithmetic references and 64-byte global canaries; execute=%v", execute)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalAddressFlags(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	t.Run("address-flags", func(t *testing.T) {
+		fixedLocalAddressFlagsRuntime(t, execution, true)
+	})
+	t.Run("machine-bits", func(t *testing.T) {
+		fixedLocalMachineBitsRuntime(t, execution, true)
+	})
+	for _, scope := range []string{"auxiliary", "vector spill", "multiply"} {
+		t.Run(scope, func(t *testing.T) {
+			fixedLocalMachineRuntime(t, execution, true, scope)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalAddressFlagsRuntimeObjects(t *testing.T) {
+	fixedLocalAddressFlagsRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
diff --git a/amd64_fixed_local_aes.go b/amd64_fixed_local_aes.go
new file mode 100644
index 000000000..b80f02012
--- /dev/null
+++ b/amd64_fixed_local_aes.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+func fixedLocalAESByteStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	f, known, err := x86AESProperties(ins.Op, *ins, "amd64")
+	if !known {
+		return false, nil
+	}
+	if err != nil || f.byteWidth != 16 {
+		return true, goAMD64FrameContext("fixed local AES shape is not closed")
+	}
+	width := uint64(65535)
+	source := state.vectors[x86CallerVectorRoot(f.sourceOperand.Reg)] & width
+	if f.memory >= 0 {
+		if _, _, err := fixedLocalReadMemory(ins, f.memory, state, proof, residue, 16, 1); err != nil {
+			return true, err
+		}
+		source = width
+	}
+	input := uint64(0)
+	if f.state >= 0 {
+		input = state.vectors[x86CallerVectorRoot(ins.Args[f.state].Reg)] & width
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	defined := x86AESDefinedBytes(f, source, input)
+	if !f.spec.vector {
+		state.vectors[destination] = state.vectors[destination]&^width | defined
+	} else {
+		state.vectors[destination] = ^width | defined
+	}
+	return true, nil
+}
diff --git a/amd64_fixed_local_affine.go b/amd64_fixed_local_affine.go
new file mode 100644
index 000000000..07bf446db
--- /dev/null
+++ b/amd64_fixed_local_affine.go
@@ -0,0 +1,271 @@
+package plan9asm
+
+import "math"
+
+// A full-word LEA keeps the same private-frame identity with a checked offset.
+// It does not read memory or initialize numerical bytes; the later access must
+// still establish its width, bounds, alignment and reaching initialized bytes.
+func fixedLocalPrivateAddressStep(ins Instr, state *x86FixedLocalState, proof *x86FixedLocalProof) (bool, error) {
+	view := ins
+	if derived, known, err := x86NamedFrameMoveAddressInstruction(ins, "amd64"); known {
+		if err != nil {
+			return true, goAMD64FrameContext("fixed local original MOV address grammar is not closed")
+		}
+		view = derived
+	}
+	if x86LEAWidth(view.Op, "amd64") == 0 || len(view.Args) != 2 || view.Args[0].Kind != OpMem {
+		return false, nil
+	}
+	if _, private := state.pointers[view.Args[0].Mem.Base]; !private {
+		return false, nil
+	}
+	if proof == nil || ins.x86AddressBits != 0 {
+		return true, goAMD64FrameContext("fixed local LEA requires the original native address width and frame")
+	}
+	width, err := x86LEAOperandWidth(view, "amd64")
+	address, addressErr := fixedLocalMemoryAddress(ins, 0, proof.frame)
+	offset, known := fixedLocalPrivateOffset(address, state)
+	destination := ins.Args[1].Reg
+	if err != nil || addressErr != nil || !known || destination == SP {
+		return true, goAMD64FrameContext("fixed local LEA requires an original private address and checked numerical displacement")
+	}
+	delete(state.opaque, destination)
+	delete(state.constants, destination)
+	delete(state.booleans, destination)
+	state.revokeRange(destination)
+	if width == 8 {
+		state.known[destination] = 0
+		state.pointers[destination] = offset
+	} else {
+		// Truncated address bytes remain unknown. They cannot be reused as
+		// NUM or as a pointer; W preserves old upper bytes and L zeroes them.
+		delete(state.pointers, destination)
+		state.known[destination] &^= x86CallerByteMask(destination, width)
+		if width == 4 {
+			state.known[destination] = 0xf0
+		}
+	}
+	return true, nil
+}
+
+// Full-word affine operations preserve an actual typed input's identity, not
+// numerical pointer bytes, pointee bounds or private-frame ownership. Grammar,
+// widths and FLAGS come from the same typed forms as ordinary GP lowering.
+func fixedLocalInputAddressStep(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int) (bool, error) {
+	// A typed FP source can introduce the first native address. Otherwise no
+	// address operation is possible before a register or spill carries one.
+	if len(state.opaque) == 0 && len(state.opaqueCells) == 0 &&
+		(len(ins.Args) == 0 || ins.Args[0].Kind != OpFP) {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local affine input lacks a unique pointer and numerical offset: %s", ins.Op)
+	}
+	write := func(destination Operand, origin x86FixedLocalOrigins, killed, defined uint8) (bool, error) {
+		root, valid := x86CallerGP(destination.Reg)
+		if destination.Kind != OpReg || !valid || root != destination.Reg || root == SP {
+			return fail()
+		}
+		writeFixedLocalOrigin(state, root, origin)
+		state.flags = state.flags&^killed | defined
+		if killed|defined != 0 {
+			state.comparison = x86FixedLocalComparison{}
+		}
+		return true, nil
+	}
+	shift := func(origins x86FixedLocalOrigins, operand Operand, subtract bool) (x86FixedLocalOrigins, bool) {
+		if !fixedLocalOriginOwners(origins, proof) {
+			return origins, false
+		}
+		if origins.address.symbol == "" {
+			return origins, true // Actual native arithmetic supplies no pointee bound.
+		}
+		delta, known := operand.Imm, operand.Kind == OpImm && operand.ImmRaw == "" && !operand.ImmIsFloat
+		if operand.Kind == OpReg {
+			delta, known = state.constants[operand.Reg]
+		}
+		if !known || subtract && delta == math.MinInt64 {
+			origins.address = x86StaticSBAddress{}
+			return origins, true
+		}
+		if subtract {
+			delta = -delta
+		}
+		origins.address.offset += delta // Match the emitted wrapping i64 address arithmetic.
+		return origins, true
+	}
+	if !x86ResultNamedPredicateInstruction(*ins) {
+		return false, nil
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, *ins, "amd64"); known && err == nil && form.spec.bits == 64 {
+		origin, pointer := fixedLocalOpaqueRegister(form.destination, state)
+		switch form.spec.stem {
+		case "ADD", "SUB", "ADC", "SBB":
+			if form.destination.Kind != OpReg {
+				return false, nil
+			}
+			carry := form.spec.carryInput
+			if carry && state.flags&x86ByteFlagCF == 0 {
+				return fail()
+			}
+			subtract := form.spec.stem == "SUB" || form.spec.stem == "SBB"
+			value, err := fixedLocalReadValue(ins, 0, state, sig, proof, residue, 8, false)
+			if err != nil || value.pointer {
+				return false, nil // The shared machine reader reports invalid inputs.
+			}
+			if pointer && !value.opaque {
+				var valid bool
+				origin, valid = shift(origin, form.source, subtract)
+				if !valid {
+					return fail()
+				}
+				if carry {
+					origin.address = x86StaticSBAddress{} // Defined CF need not be constant.
+				}
+				return write(form.destination, origin, form.spec.flagsKilled, form.spec.flagsDefined)
+			}
+			if !subtract && value.opaque && !pointer && fixedLocalNumericRead(form.destination, 8, state) {
+				sourceOrigin, valid := shift(value.identity, form.destination, false)
+				if !valid {
+					return fail()
+				}
+				if carry {
+					sourceOrigin.address = x86StaticSBAddress{}
+				}
+				return write(form.destination, sourceOrigin, form.spec.flagsKilled, form.spec.flagsDefined)
+			}
+			return false, nil // Other arithmetic results are bits, not addresses.
+		case "INC", "DEC":
+			if pointer {
+				var valid bool
+				origin, valid = shift(origin, Operand{Kind: OpImm, Imm: 1}, form.spec.stem == "DEC")
+				if !valid {
+					return fail()
+				}
+				return write(form.destination, origin, form.spec.flagsKilled, form.spec.flagsDefined)
+			}
+		}
+	}
+	if effect, known, err := x86NamedLEAByteEffect(ins.Op, *ins, "amd64"); known && err == nil && x86LEAWidth(ins.Op, "amd64") == 8 {
+		memory := ins.Args[0].Mem
+		origin, pointer := state.opaque[memory.Base]
+		if pointer && origin.valid() {
+			for _, input := range effect.operands {
+				if input.read && input.operand.Reg != memory.Base && !fixedLocalNumericRead(input.operand, input.width, state) {
+					return fail()
+				}
+			}
+			// An aliased pointer index is still a second pointer, even if it
+			// happens to share the base's spelling or original entry slot.
+			if _, secondPointer := state.opaque[memory.Index]; secondPointer {
+				return fail()
+			}
+			displacement, known, valid := fixedLocalNativeDisplacement(memory, state)
+			if !valid || !fixedLocalOriginOwners(origin, proof) {
+				return fail()
+			}
+			if origin.address.symbol != "" {
+				if known {
+					origin.address.offset += displacement
+				} else {
+					origin.address = x86StaticSBAddress{}
+				}
+			}
+			return write(ins.Args[1], origin, effect.flagsKilled, effect.flagsDefined)
+		}
+	}
+	form, known, err := x86ScalarCompareProperties(ins.Op, *ins, "amd64")
+	if !known || err != nil || form.test || form.bits != 64 {
+		return false, nil
+	}
+	values := [2]x86FixedLocalOrigins{}
+	opaque := func(index int) bool {
+		operand := form.args[index]
+		if origin, found := fixedLocalOpaqueRegister(operand, state); found {
+			values[index] = origin
+			return true
+		}
+		if operand.Kind != OpMem || proof == nil {
+			return false
+		}
+		address, err := fixedLocalMemoryAddress(*ins, index, proof.frame)
+		if err != nil {
+			return false
+		}
+		offset, found := fixedLocalPrivateOffset(address, state)
+		if !found {
+			return false
+		}
+		origin, found := state.opaqueCells[offset]
+		values[index] = origin
+		return found && origin.valid()
+	}
+	pointers := [2]bool{opaque(0), opaque(1)}
+	if !pointers[0] || !pointers[1] {
+		return false, nil
+	}
+	for index, operand := range form.args {
+		if !fixedLocalOriginOwners(values[index], proof) {
+			return fail()
+		}
+		if operand.Kind == OpMem {
+			if _, err := fixedLocalMemory(ins, index, state, proof, residue, 8, 1, false, true); err != nil {
+				return true, err
+			}
+		}
+	}
+	flags := uint8(x86ByteFlagsAll)
+	comparison := x86FixedLocalComparison{}
+	if values[0].hasLiteral() || values[1].hasLiteral() {
+		if !pointers[0] || !pointers[1] || !fixedLocalOriginOwners(values[0], proof) || !fixedLocalOriginOwners(values[1], proof) {
+			return fail()
+		}
+		// The actual CMP preserves every architectural flag. Its optional
+		// literal equality fact is narrower than that emitted operation.
+		for index, value := range values {
+			if literal, single := value.literal(); single && form.args[1-index].Kind == OpReg {
+				comparison = x86FixedLocalComparison{register: form.args[1-index].Reg, literal: literal}
+				break
+			}
+		}
+	}
+	state.flags, state.comparison = flags, comparison
+	return true, nil
+}
+
+func fixedLocalOpaqueRegister(operand Operand, state *x86FixedLocalState) (x86FixedLocalOrigins, bool) {
+	root, valid := x86CallerGP(operand.Reg)
+	if operand.Kind != OpReg || !valid || root != operand.Reg {
+		return x86FixedLocalOrigins{}, false
+	}
+	origin, found := state.opaque[root]
+	return origin, found && origin.valid()
+}
+
+// Native effective addresses use wrapping machine arithmetic, unlike relocated
+// private-frame offsets. A complete NUM index needs no caller bounds proof.
+func fixedLocalNativeDisplacement(memory MemRef, state *x86FixedLocalState) (offset int64, known, valid bool) {
+	if memory.OffRaw != "" || memory.Sym != "" || memory.Segment != "" || memory.IndexExt != "" {
+		return 0, false, false
+	}
+	if memory.Index == "" {
+		return memory.Off, true, memory.Scale == 0
+	}
+	if !fixedLocalNumericRead(Operand{Kind: OpReg, Reg: memory.Index}, 8, state) ||
+		memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+		return 0, false, false
+	}
+	index, known := state.constants[memory.Index]
+	return memory.Off + index*memory.Scale, known, true
+}
+
+func intersectFixedLocalOrigins[K, V comparable](previous, current map[K]V) bool {
+	changed := false
+	for key, value := range previous {
+		if incoming, found := current[key]; !found || incoming != value {
+			delete(previous, key)
+			changed = true
+		}
+	}
+	return changed
+}
diff --git a/amd64_fixed_local_affine_runtime_test.go b/amd64_fixed_local_affine_runtime_test.go
new file mode 100644
index 000000000..8c650b0ca
--- /dev/null
+++ b/amd64_fixed_local_affine_runtime_test.go
@@ -0,0 +1,141 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func fixedLocalAffineRuntimeProgram(t *testing.T, triple string) (string, string, string, string) {
+	t.Helper()
+	bodies := []string{
+		"ADDQ AX,SI\nMOVQ (SI),AX",
+		"ADDQ SI,AX\nMOVQ (AX),AX",
+		"SUBQ AX,SI\nMOVQ (SI),AX",
+		"LEAQ -8(SI)(AX*2),CX\nMOVQ (CX),AX",
+		"INCQ SI\nDECQ SI\nMOVQ (SI),AX",
+		"MOVQ $0,AX\nCMPQ SI,DI\nSETCS AL",
+		"MOVQ $0,AX\nMOVQ SI,8(SP)\nCMPQ DI,8(SP)\nSETCS AL",
+		"MOVQ $0,AX\nMOVQ SI,8(SP)\nCMPQ 8(SP),DI\nSETCS AL",
+		"CMPQ AX,$0\nJEQ left\nLEAQ 8(SI),CX\nJMP join\nleft:\nLEAQ 16(SI),CX\njoin:\nMOVQ (CX),AX",
+		"CMPQ AX,$0\nJEQ join\nMOVQ SI,8(SP)\njoin:",
+	}
+	for _, register := range []string{"BP", "R14"} {
+		bodies = append(bodies,
+			fmt.Sprintf("MOVQ SI,%s\nADDQ AX,%s\nMOVQ (%s),AX", register, register, register),
+			fmt.Sprintf("LEAQ 8(SI),%s\nADDQ AX,%s\nMOVQ (%s),AX", register, register, register))
+	}
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, body := range bodies {
+		_, _, source := fixedLocalInputFixture(t, body)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p, q *uint64, a uint64) uint64\n", name)
+		fmt.Fprintf(&goRows, "%s,\n", name)
+		fmt.Fprintf(&cRows, "value%d,\n", index)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t *, uint64_t *, uint64_t) __asm__(%s);\n",
+			index, runtimeCAsmLabel(prefix+"example.invalid/framefixture."+name))
+	}
+	original := `package main
+import "fmt"
+` + declarations.String() + `
+func main() {
+    rows := []func(*uint64, *uint64, uint64) uint64{
+` + goRows.String() + `
+    }
+    var data [16]uint64
+    for i := range data { data[i] = uint64(i)*0x0102030405060708 ^ 0xfedcba9876543210 }
+    for n, call := range rows {
+        for v := 0; v < 4; v++ {
+            got := call(&data[8], &data[7+v%3], uint64(v*8))
+            fmt.Printf("%d %d %016x\n", n, v, got)
+        }
+    }
+    for i, got := range data {
+        if got != uint64(i)*0x0102030405060708 ^ 0xfedcba9876543210 { panic("input modified") }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+int main(void) {
+    uint64_t (*const rows[])(uint64_t *, uint64_t *, uint64_t) = {
+` + cRows.String() + `
+    };
+    uint64_t data[16];
+    for (unsigned i = 0; i < 16; i++) data[i] = i*UINT64_C(0x0102030405060708) ^ UINT64_C(0xfedcba9876543210);
+    for (unsigned n = 0; n < sizeof(rows)/sizeof(rows[0]); n++) {
+        for (unsigned v = 0; v < 4; v++) {
+            printf("%u %u %016llx\n", n, v, (unsigned long long)rows[n](&data[8], &data[7+v%3], v*8));
+        }
+    }
+    for (unsigned i = 0; i < 16; i++) {
+        if (data[i] != (i*UINT64_C(0x0102030405060708) ^ UINT64_C(0xfedcba9876543210))) return 2;
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalAffine(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	t.Setenv("GOCACHE", t.TempDir())
+	assembly, declarations, original, driver := fixedLocalAffineRuntimeProgram(t, execution.triple)
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))), "\n")
+	if len(want) != 14*4 {
+		t.Fatalf("original Go produced %d rows, want 14 affine kernels x 4 offsets", len(want))
+	}
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(level, func(t *testing.T) {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				got := strings.Split(strings.TrimSpace(string(execution.compileAndRunLLVM(t, "private-affine", input, driver, level))), "\n")
+				if len(got) != len(want) {
+					t.Fatalf("LLVM rows = %d, original = %d", len(got), len(want))
+				}
+				for index := range want {
+					if got[index] != want[index] {
+						t.Fatalf("affine value/compare row %d: original %s; LLVM %s", index, want[index], got[index])
+					}
+				}
+			})
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalInputAffineMemoryFaults(t *testing.T) {
+	cases := []fixedLocalInputFaultCase{
+		{"ADDQ $8,SI\nMOVQ -8(SI),CX", 8},
+		{"SUBQ $8,SI\nMOVQ 8(SI),CX", 8},
+		{"ADDQ SI,AX\nMOVQ (AX),CX", 8},
+		{"LEAQ 8(SI)(AX*8),CX\nMOVQ -8(CX),AX", 8},
+		{"MOVQ SI,BP\nADDQ AX,BP\nMOVQ (BP),CX", 8},
+		{"LEAQ 8(SI),BP\nADDQ AX,BP\nMOVQ -8(BP),CX", 8},
+	}
+	for _, register := range []string{"BP", "R14"} {
+		for index, suffix := range []string{"B", "W", "L", "Q"} {
+			for _, operands := range []string{"(%s),CX", "AX,(%s)"} {
+				operation := "MOVQ SI," + register + "\nMOV" + suffix + " " + fmt.Sprintf(operands, register)
+				cases = append(cases, fixedLocalInputFaultCase{operation, 1 << uint(index)})
+			}
+		}
+	}
+	fixedLocalInputMemoryFaults(t, cases)
+}
diff --git a/amd64_fixed_local_affine_test.go b/amd64_fixed_local_affine_test.go
new file mode 100644
index 000000000..552cb1b4c
--- /dev/null
+++ b/amd64_fixed_local_affine_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalInputAffineAddresses(t *testing.T) {
+	var original strings.Builder
+	for index, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"pointer plus number", "ADDQ AX,SI\nMOVQ (SI),AX", true},
+		{"number plus pointer", "ADDQ SI,AX\nMOVQ (AX),AX", true},
+		{"pointer minus number", "SUBQ AX,SI\nMOVQ (SI),AX", true},
+		{"pointer immediate", "ADDQ $8,SI\nSUBQ $16,SI\nMOVQ (SI),AX", true},
+		{"indexed LEA scale1", "LEAQ -64(SI)(AX*1),CX\nMOVQ (CX),AX", true},
+		{"indexed LEA scale2", "LEAQ -64(SI)(AX*2),CX\nMOVQ (CX),AX", true},
+		{"indexed LEA scale4", "LEAQ -64(SI)(AX*4),CX\nMOVQ (CX),AX", true},
+		{"indexed LEA scale8", "LEAQ -64(SI)(AX*8),CX\nMOVQ (CX),AX", true},
+		{"pointer increment", "INCQ SI\nDECQ SI\nMOVQ (SI),AX", true},
+		{"pointer compare", "CMPQ SI,DI\nSETCS AL", true},
+		{"pointer immediate compare", "CMPQ SI,$0\nSETCS AL", true},
+		{"pointer spill compare", "MOVQ SI,8(SP)\nCMPQ DI,8(SP)\nSETCS AL", true},
+		{"reverse spill compare", "MOVQ SI,8(SP)\nCMPQ 8(SP),DI\nSETCS AL", true},
+		{"dead differing origin", "CMPQ AX,$0\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ DI,CX\njoin:", true},
+		{"dead conditional spill", "CMPQ AX,$0\nJEQ join\nMOVQ SI,8(SP)\njoin:", true},
+		{"same origin derived join", "CMPQ AX,$0\nJEQ left\nLEAQ 8(SI),CX\nJMP join\nleft:\nLEAQ 16(SI),CX\njoin:\nMOVQ (CX),AX", true},
+		{"pointer plus pointer", "ADDQ DI,SI\nMOVQ (SI),AX", true},
+		{"number minus pointer", "SUBQ SI,AX\nMOVQ (AX),AX", true},
+		{"pointer bits escape", "ADDQ SI,AX", false},
+		{"partial pointer arithmetic", "ADDL $8,SI\nMOVQ (SI),AX", true},
+		{"pointer index", "LEAQ (SI)(DI*2),CX\nMOVQ (CX),AX", false},
+		{"aliased pointer index", "LEAQ (SI)(SI*1),CX\nMOVQ (CX),AX", false},
+		{"unknown index", "LEAQ (SI)(R8*2),CX\nMOVQ (CX),AX", false},
+		{"native and numerical comparison", "CMPQ SI,AX\nSETCS AL", true},
+		{"uninitialized spill compare", "CMPQ SI,8(SP)\nSETCS AL", false},
+		{"different origin consumed", "CMPQ AX,$0\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ DI,CX\njoin:\nMOVQ (CX),AX", true},
+		{"pointer and number join", "CMPQ AX,$0\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ AX,CX\njoin:\nMOVQ (CX),AX", false},
+		{"conditional spill consumed", "CMPQ AX,$0\nJEQ join\nMOVQ SI,8(SP)\njoin:\nMOVQ 8(SP),CX\nMOVQ (CX),AX", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, source := fixedLocalInputFixture(t, row.body)
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+			proved, err := proveX86FixedLocal(fn, sig)
+			if row.valid && err != nil {
+				t.Fatal("typed input address lost its original identity", err)
+			}
+			if !row.valid && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved pointer acquired numerical or native access", err)
+			}
+			if row.name == "pointer plus pointer" || row.name == "partial pointer arithmetic" {
+				fixedLocalRequireNumericNativeRole(t, proved, SI)
+			}
+			if row.name == "number minus pointer" {
+				fixedLocalRequireNumericNativeRole(t, proved, AX)
+			}
+		})
+	}
+	// Positive and negative proof rows alike remain valid original Go syntax.
+	// A refusal here must not masquerade as a translator provenance check.
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_alias_candidate_go127_test.go b/amd64_fixed_local_alias_candidate_go127_test.go
new file mode 100644
index 000000000..897144879
--- /dev/null
+++ b/amd64_fixed_local_alias_candidate_go127_test.go
@@ -0,0 +1,62 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalAliasedFrameProgram() (string, string, []string) {
+	var assembly, declarations strings.Builder
+	var expected []string
+	for _, register := range []Reg{AX, BX, CX, DX, SI, DI, BP, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		for _, address := range []string{"MOVQ SP,%s", "LEAQ 16(SP),%s"} {
+			name := fmt.Sprintf("Value%d", len(expected))
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$160-16\n", name)
+			fmt.Fprintf(&assembly, address+"\n", register)
+			fmt.Fprintf(&assembly, "MOVQ $7,8(%s)\nMOVQ 8(%s),AX\nMOVQ AX,ret0+8(FP)\nRET\n", register, register)
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			expected = append(expected, "0000000000000007")
+		}
+	}
+	return assembly.String(), declarations.String(), expected
+}
+
+func TestGoAMD64FixedLocalAliasedFrameObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, expected := fixedLocalAliasedFrameProgram()
+	if len(expected) != 30 {
+		t.Fatal("complete GP/address family inventory changed", len(expected))
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Fatal("complete aliased scratch source bypassed actual frame capture")
+			}
+			var names []string
+			for index := range expected {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("complete aliased scratch source rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "alias-frame.ll", "alias-frame.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "alias-frame-opt.ll", "alias-frame-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
diff --git a/amd64_fixed_local_alias_candidate_runtime_go127_test.go b/amd64_fixed_local_alias_candidate_runtime_go127_test.go
new file mode 100644
index 000000000..010d13a68
--- /dev/null
+++ b/amd64_fixed_local_alias_candidate_runtime_go127_test.go
@@ -0,0 +1,13 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalAliasedFrame(t *testing.T) {
+	assembly, declarations, expected := fixedLocalAliasedFrameProgram()
+	if len(expected) != 30 {
+		t.Fatal("complete aliased frame runtime inventory changed", len(expected))
+	}
+	fixedLocalConstantResultsRuntime(t, assembly, declarations, expected)
+}
diff --git a/amd64_fixed_local_alias_candidate_test.go b/amd64_fixed_local_alias_candidate_test.go
new file mode 100644
index 000000000..f89157b87
--- /dev/null
+++ b/amd64_fixed_local_alias_candidate_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalPrivateAddressRoles(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"private base", "LEAQ 8(SP),SI\nMOVQ AX,(SI)\nMOVQ (SI),AX", true},
+		{"private alias", "MOVQ SP,SI\nLEAQ 8(SI),SI\nMOVQ AX,(SI)\nMOVQ (SI),AX", true},
+		{"constant index", "MOVQ $2,CX\nLEAQ (SP)(CX*8),SI\nMOVQ AX,(SI)\nMOVQ (SI),AX", true},
+		{"logical displacement", "LEAQ tmp-8(SP),SI\nMOVQ AX,(SI)\nMOVQ (SI),AX", true},
+		{"uninitialized memory", "LEAQ 8(SP),SI\nMOVQ (SI),AX", false},
+		{"narrow pointer", "LEAL 8(SP),SI\nMOVQ AX,(SI)", false},
+		{"stack mutation", "LEAQ 8(SP),SP", false},
+		{"unknown index", "LEAQ (SP)(CX*8),SI\nMOVQ AX,(SI)", false},
+		{"pointer index", "MOVQ SP,CX\nLEAQ (SP)(CX*1),SI\nMOVQ AX,(SI)", false},
+		{"index overflow", "MOVQ $0x7fffffffffffffff,CX\nLEAQ (SP)(CX*8),SI", false},
+		{"outside frame", "LEAQ 4096(SP),SI\nMOVQ AX,(SI)", false},
+		{"before frame", "LEAQ -8(SP),SI\nMOVQ AX,(SI)", false},
+		{"pointer is not NUM", "LEAQ 8(SP),AX\nADDQ AX,0(SP)", false},
+		{"unknown base", "LEAQ 8(SI),SI\nMOVQ AX,(SI)", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalGPFixture(t, row.body)
+			_, err := proveX86FixedLocal(fn, sig)
+			if row.want && err != nil || !row.want && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("private address role = %v: %v", row.want, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPrivateAddressWidthAndFrame(t *testing.T) {
+	fn, _, _ := fixedLocalGPFixture(t, "LEAQ 8(SP),SI")
+	var address Instr
+	for _, ins := range fn.Instrs {
+		if ins.Op == "LEAQ" {
+			address = ins
+		}
+	}
+	for _, bits := range []int{0, 16, 32} {
+		for _, proof := range []*x86FixedLocalProof{nil, {frame: 64}} {
+			state := x86FixedLocalState{pointers: map[Reg]int64{SP: 0}, known: make(map[Reg]uint8)}
+			ins := address
+			ins.x86AddressBits = bits
+			known, err := fixedLocalPrivateAddressStep(ins, &state, proof)
+			want := bits == 0 && proof != nil
+			if !known || want && err != nil || !want && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("address bits %d, frame %v: known=%v error=%v", bits, proof != nil, known, err)
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalAliasedFrameCandidates(t *testing.T) {
+	var originals strings.Builder
+	type example struct{ name, source string }
+	var examples []example
+	for _, register := range []Reg{AX, BX, CX, DX, SI, DI, BP, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		for _, address := range []string{"MOVQ SP,%s", "LEAQ 16(SP),%s"} {
+			for _, access := range []string{"MOVQ 8(%s),AX", "MOVOU X0,8(%s)"} {
+				name := fmt.Sprintf("Value%d", len(examples))
+				source := fmt.Sprintf("TEXT ·%s(SB),4,$160-0\n", name) +
+					fmt.Sprintf(address, register) + "\n" + fmt.Sprintf(access, register) + "\nRET\n"
+				originals.WriteString(source)
+				examples = append(examples, example{name, source})
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", originals.String(), true)
+	for _, row := range examples {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, row.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Fatal("physical frame address through a GP register bypassed source observation")
+			}
+			if GoAMD64FixedLocalFrameBindingNeeded(file, "386") {
+				t.Fatal("amd64 query selected another source mode")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalAliasedCandidateSourceRoles(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"copy chain", "MOVQ SP,R14\nMOVQ R14,R15\nMOVQ 8(R15),AX", true},
+		{"inverse register chain", "MOVQ SP,R15\nMOVQ R15,R14\nMOVQ R14,AX\nMOVQ 8(AX),BX", true},
+		{"MOVD source alias", "MOVD SP,R14\nMOVQ 8(R14),AX", true},
+		{"MOVDQ2Q source alias", "MOVDQ2Q SP,R14\nMOVQ 8(R14),AX", true},
+		{"overwritten possible alias", "MOVQ SP,R14\nMOVQ SI,R14\nMOVQ 8(R14),AX", true},
+		{"address chain", "MOVQ SP,R14\nLEAQ 16(R14),R15\nMOVQ 8(R15),AX", true},
+		{"CFG order", "JMP define\nuse:\nMOVQ 8(R15),AX\nRET\ndefine:\nMOVQ SP,R14\nMOVQ R14,R15\nJMP use", true},
+		{"index", "MOVQ SP,R14\nMOVQ (AX)(R14*1),BX", true},
+		{"unrelated base", "LEAQ 16(SP),R14\nMOVQ 8(R15),AX", false},
+		{"no memory", "LEAQ 16(SP),R14", false},
+		{"address only", "MOVQ SP,R14\nLEAQ 16(R14),AX", false},
+		{"sized NOP", "MOVQ SP,R14\nNOPL 16(R14)", false},
+		{"logical AUTO", "LEAQ tmp-16(SP),R14\nMOVQ (R14),AX", false},
+		{"partial copy", "MOVL SP,R14\nMOVQ (R14),AX", false},
+		{"partial address", "LEAL 16(SP),R14\nMOVQ (R14),AX", false},
+		{"different source", "MOVQ SI,R14\nMOVQ (R14),AX", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$160-0\n"+row.body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := GoAMD64FixedLocalFrameBindingNeeded(file, "amd64"); got != row.want {
+				t.Fatalf("source observation candidate = %v, want %v", got, row.want)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_api_lease_inventory_unix_test.go b/amd64_fixed_local_api_lease_inventory_unix_test.go
new file mode 100644
index 000000000..194972caf
--- /dev/null
+++ b/amd64_fixed_local_api_lease_inventory_unix_test.go
@@ -0,0 +1,149 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Inventory is independent of the future scheduling change. These are the
+// original full payloads, not new reduced numerical examples or source proofs.
+func TestFixedLocalWideAPILeasePreservesCompletePayloadInventory(t *testing.T) {
+	for _, row := range []struct {
+		all   bool
+		count int
+	}{{false, 28}, {true, 340}} {
+		assembly, declarations, cases := fixedLocalPackedRuntimeProgram(row.all)
+		file, err := Parse(ArchAMD64, assembly)
+		if err != nil {
+			t.Fatal("original complete numerical source no longer parses", err)
+		}
+		if len(cases) != row.count || len(file.Funcs) != row.count {
+			t.Fatal("original complete numerical source changed", row.all, len(cases), err)
+		}
+		var assembled, declared strings.Builder
+		for batch := 0; batch < (row.count+63)/64; batch++ {
+			start, end, ok := fixedLocalObjectBatchRange(row.count, batch)
+			if !ok || end-start > 64 || end <= start {
+				t.Fatal("lost bounded complete-source batch", row.all, batch, start, end)
+			}
+			// Split at original TEXT boundaries without changing a single raw
+			// byte or renaming ValueN; the future real producer must agree.
+			for index := start; index < end; index++ {
+				begin := strings.Index(assembly, fmt.Sprintf("TEXT ·Value%d(SB)", index))
+				finish := len(assembly)
+				if index+1 < row.count {
+					finish = strings.Index(assembly, fmt.Sprintf("TEXT ·Value%d(SB)", index+1))
+				}
+				if begin < 0 || finish <= begin || file.Funcs[index].Sym != fmt.Sprintf("·Value%d", index) {
+					t.Fatal("missing or substituted original source member", index)
+				}
+				assembled.WriteString(assembly[begin:finish])
+				fmt.Fprintf(&declared, "func Value%d(a, mask uint64) uint64\n", index)
+			}
+		}
+		if assembled.String() != assembly || declared.String() != declarations {
+			t.Fatal("source batches changed, cropped or duplicated original full ASM/declarations")
+		}
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			goOracle, cOracle := fixedLocalPackedRuntimeOracles(cases, triple)
+			if strings.Count(goOracle, "{Value") != row.count || strings.Count(cOracle, "{value") != row.count ||
+				strings.Count(cOracle, "extern uint64_t value") != row.count {
+				t.Fatal("original Go/C oracle lost a complete source member", triple, row.count)
+			}
+			for index, entry := range cases {
+				goRow := fmt.Sprintf("{Value%d,%d,%d,%d,%d},\n", index, entry.width, entry.bits, entry.word, entry.mode)
+				cRow := fmt.Sprintf("{value%d,%d,%d,%d,%d},\n", index, entry.width, entry.bits, entry.word, entry.mode)
+				if strings.Count(goOracle, goRow) != 1 || strings.Count(cOracle, cRow) != 1 {
+					t.Fatal("original oracle source width/lane/merge/canary axis changed", triple, index)
+				}
+			}
+			for _, required := range []string{
+				"const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),UINT64_C(0x123456789abcdef0),UINT64_C(0x7ff81234567890ab)};",
+				"const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x5555555555555555),UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_C(0x8000000000000000)};",
+				"for(unsigned v=0;v<6;v++) for(unsigned m=0;m<6;m++)",
+				"for(unsigned bit=0;bit<64;bit++)",
+			} {
+				if !strings.Contains(cOracle, required) {
+					t.Fatal("lease repair cannot reduce original C inputs/masks/whole-byte observations", required)
+				}
+			}
+			batches := fixedLocalPackedLeaseBatches(t, row.all, triple)
+			if len(batches) != (row.count+63)/64 {
+				t.Fatal("source batches omitted a member", triple, len(batches))
+			}
+			var batchAssembly, batchDeclarations, batchRows, batchPrototypes strings.Builder
+			for index, batch := range batches {
+				start, end, ok := fixedLocalObjectBatchRange(row.count, index)
+				if !ok || batch.start != start || batch.end != end {
+					t.Fatal("source batch changed its exact original range", index, batch.start, batch.end)
+				}
+				observed, err := Parse(ArchAMD64, batch.assembly)
+				if err != nil || observed == nil || len(observed.Funcs) != end-start {
+					t.Fatal("source batch is not an independently complete source", index, err)
+				}
+				batchAssembly.WriteString(batch.assembly)
+				batchDeclarations.WriteString(batch.declarations)
+				batchRows.WriteString(batch.rows)
+				batchPrototypes.WriteString(batch.prototypes)
+				if strings.Count(batch.oracle, "{value") != end-start {
+					t.Fatal("C batch contains an omitted or foreign active oracle row", index)
+				}
+			}
+			if batchAssembly.String() != assembly || batchDeclarations.String() != declarations ||
+				!strings.Contains(cOracle, batchRows.String()) || !strings.Contains(cOracle, batchPrototypes.String()) {
+				t.Fatal("the bounded source/C union differs from the complete original payload", triple)
+			}
+		}
+	}
+}
+
+type fixedLocalPackedLeaseBatch struct {
+	start, end                                       int
+	assembly, declarations, oracle, rows, prototypes string
+}
+
+// This fixture partitions only original input text, before any source owner
+// exists. Each future consumer must create a separate real package/capture for
+// a batch; it cannot crop a File and borrow the full 340-function capability.
+func fixedLocalPackedLeaseBatches(t *testing.T, all bool, triple string) []fixedLocalPackedLeaseBatch {
+	t.Helper()
+	assembly, declarations, cases := fixedLocalPackedRuntimeProgram(all)
+	_, oracle := fixedLocalPackedRuntimeOracles(cases, triple)
+	const table = "static const struct entry cases[]={\n"
+	prototypeStart := strings.Index(oracle, "extern uint64_t value0(")
+	prototypeEnd := strings.Index(oracle, "\nstruct entry {")
+	rowStart := strings.Index(oracle, table) + len(table)
+	rowEnd := strings.Index(oracle, "\n};\nint main(void)")
+	if prototypeStart < 0 || prototypeEnd <= prototypeStart || rowStart < len(table) || rowEnd <= rowStart {
+		t.Fatal("original C oracle lost its independent declaration/case boundaries")
+	}
+	text := strings.SplitAfter(assembly, "RET\n")
+	decls := strings.SplitAfter(declarations, "\n")
+	prototypes := strings.SplitAfter(oracle[prototypeStart:prototypeEnd], "\n")
+	rows := strings.SplitAfter(oracle[rowStart:rowEnd], "\n")
+	for name, entries := range map[string][]string{"assembly": text, "declarations": decls, "C prototypes": prototypes, "C rows": rows} {
+		if len(entries) != len(cases)+1 || entries[len(cases)] != "" {
+			t.Fatal("original fixture has ambiguous source boundaries", name, len(entries), len(cases))
+		}
+	}
+	var batches []fixedLocalPackedLeaseBatch
+	for index := 0; index < (len(cases)+63)/64; index++ {
+		start, end, ok := fixedLocalObjectBatchRange(len(cases), index)
+		if !ok {
+			t.Fatal("missing bounded original source range", index)
+		}
+		batch := fixedLocalPackedLeaseBatch{
+			start: start, end: end,
+			assembly:     strings.Join(text[start:end], ""),
+			declarations: strings.Join(decls[start:end], ""),
+			rows:         strings.Join(rows[start:end], ""),
+			prototypes:   strings.Join(prototypes[start:end], ""),
+		}
+		batch.oracle = oracle[:prototypeStart] + batch.prototypes + oracle[prototypeEnd:rowStart] + batch.rows + oracle[rowEnd:]
+		batches = append(batches, batch)
+	}
+	return batches
+}
diff --git a/amd64_fixed_local_api_lease_lifecycle_test.go b/amd64_fixed_local_api_lease_lifecycle_test.go
new file mode 100644
index 000000000..1c5a01e87
--- /dev/null
+++ b/amd64_fixed_local_api_lease_lifecycle_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestFixedLocalFreshCaptureNeverRevivesPreviousAPILease(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	var previous Options
+	var previousSource *GoAMD64FrameSource
+	for _, capture := range []string{"first", "second", "third"} {
+		t.Run(capture, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("fresh independent original-Go capture", err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if source == previousSource {
+				t.Fatal("a new API reused the closed previous observation")
+			}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("fresh observation lost the original complete source binding", err)
+			}
+			if ir, err := Translate(file, bound); err != nil || ir == "" {
+				t.Fatal("fresh source cannot independently consume the same original payload", err)
+			}
+			if previousSource != nil {
+				if ir, err := Translate(file, previous); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("new capture revived a previous API's closed/cancelled binding", err)
+				}
+			}
+			previous, previousSource = bound, source
+		})
+	}
+}
+
+func TestFixedLocalFreshAPILeaseRetainsOriginalStageBudget(t *testing.T) {
+	now := time.Date(2026, 10, 21, 0, 0, 0, 0, time.UTC)
+	for _, delay := range []time.Duration{0, 4 * time.Minute, 8 * time.Minute} {
+		start := now.Add(delay)
+		if got := runtimeOracleStageDeadline(start, time.Time{}, false); got != start.Add(5*time.Minute) {
+			t.Fatal("API lease changed the original five-minute bound", delay, got)
+		}
+	}
+	deadline := now.Add(4 * time.Minute)
+	if got := runtimeOracleStageDeadline(now, deadline, true); got != deadline.Add(-3*time.Second) {
+		t.Fatal("fresh API lease escaped the real test deadline/cleanup reserve", got)
+	}
+	if got := runtimeOracleStageDeadline(deadline, deadline, true); !got.Before(deadline) {
+		t.Fatal("new API revived an exhausted test lifetime", got)
+	}
+}
diff --git a/amd64_fixed_local_api_lease_test.go b/amd64_fixed_local_api_lease_test.go
new file mode 100644
index 000000000..0dc47c4ef
--- /dev/null
+++ b/amd64_fixed_local_api_lease_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// These are scheduling checks, not fabricated source observations. Every API
+// still has to capture and consume its complete actual Go package independently.
+func TestFixedLocalAPIsHaveIndependentBoundedCaptureLeases(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_fixed_local_frame_test.go")
+	helper := functions["fixedLocalFreshAPIs"]
+	if helper == nil {
+		t.Fatal("three sequential APIs still share one source/binding lease; missing per-API capture owner")
+	}
+	var scopes []*ast.FuncLit
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || fixedLocalLeaseCallName(call) != "t.Run" || len(call.Args) != 2 {
+			return true
+		}
+		if scope, ok := call.Args[1].(*ast.FuncLit); ok {
+			scopes = append(scopes, scope)
+		}
+		return true
+	})
+	if len(scopes) != 1 {
+		t.Fatalf("each selected API needs one independent synchronous owner, got %d", len(scopes))
+	}
+	scope := scopes[0]
+	counts := fixedLocalLeaseCalls(scope.Body)
+	for _, name := range []string{"runtimeOracleStageContext", "CaptureGoAMD64FrameSource", "source.preprocess", "Parse", "source.BindFixedLocal", "fixedLocalAPI"} {
+		if counts[name] != 1 {
+			t.Errorf("per-API owner must retain exactly one %s, got %d", name, counts[name])
+		}
+	}
+	for _, name := range []string{"runtimeOracleProofContext", "requireGoAMD64FrameCapture", "fixedLocalAPIs", "t.Parallel"} {
+		if counts[name] != 0 {
+			t.Errorf("per-API owner cannot extend, prematurely cancel, share or overlap its lease: %s", name)
+		}
+	}
+	all := fixedLocalLeaseCalls(helper.Body)
+	for _, name := range []string{"runtimeOracleStageContext", "CaptureGoAMD64FrameSource", "source.BindFixedLocal"} {
+		if all[name] != counts[name] {
+			t.Errorf("%s escaped the API lifetime", name)
+		}
+	}
+	if all["runtimeOracleProofContext"] != 0 {
+		t.Error("an outer proof context cannot extend the independent five-minute API stage")
+	}
+
+	var stage, capture, bind, consume token.Pos
+	var cancel, close bool
+	ast.Inspect(scope.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		switch fixedLocalLeaseCallName(call) {
+		case "runtimeOracleStageContext":
+			stage = call.Pos()
+			fixedLocalLeaseRequireArguments(t, call, "t")
+		case "CaptureGoAMD64FrameSource":
+			capture = call.Pos()
+			fixedLocalLeaseRequireArguments(t, call, "ctx", "pkg", "request")
+		case "source.BindFixedLocal":
+			bind = call.Pos()
+			fixedLocalLeaseRequireArguments(t, call, "ctx", "pkg", "file", "options")
+		case "fixedLocalAPI":
+			consume = call.Pos()
+			fixedLocalLeaseRequireArguments(t, call, "t", "pkg", "file", "bound", "api", "check", "expanded")
+		}
+		return true
+	})
+	for _, statement := range scope.Body.List {
+		deferred, ok := statement.(*ast.DeferStmt)
+		if !ok {
+			continue
+		}
+		if fixedLocalLeaseCallName(deferred.Call) == "cancel" {
+			cancel = true
+		}
+		if closure, ok := deferred.Call.Fun.(*ast.FuncLit); ok {
+			close = close || fixedLocalLeaseCalls(closure.Body)["source.Close"] == 1
+		}
+	}
+	if !cancel || !close {
+		t.Error("each API must cancel and close its own source before the next API starts, including fatal paths")
+	}
+	if !(stage < capture && capture < bind && bind < consume) {
+		t.Error("each complete source capture and binding must precede only that API's consumption")
+	}
+}
+
+func TestFixedLocalCompleteConsumersDoNotShareAPILease(t *testing.T) {
+	for _, owner := range []struct{ filename, helper string }{
+		{"amd64_fixed_local_conversion_test.go", "fixedLocalConversionActualObjects"},
+		{"amd64_fixed_local_packed_matrix_test.go", "fixedLocalPackedActualObjects"},
+		{"amd64_cmov_fixed_local_test.go", "x86CMOVFixedLocalActualObjects"},
+		{"amd64_fixed_local_conversion_runtime_unix_test.go", "fixedLocalConversionRuntimeBatch"},
+		{"amd64_fixed_local_packed_runtime_test.go", "fixedLocalPackedRuntimeAPIs"},
+		{"amd64_fixed_local_data_matrix_go127_test.go", "fixedLocalDataTargetConsumers"},
+		{"amd64_fixed_local_data_go127_test.go", "TestGoAMD64FixedLocalReadonlyDataThreeTargetObjects"},
+		{"amd64_fixed_local_data_runtime_go127_test.go", "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalReadonlyData"},
+		{"amd64_fixed_local_transport_runtime_test.go", "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTransportByteValues"},
+		{"amd64_fixed_local_transport_test.go", "TestGoAMD64FixedLocalTransportActualObjects"},
+		{"amd64_fixed_local_nontemporal_test.go", "fixedLocalNonTemporalActualObjects"},
+		{"amd64_aes_family_fixed_local_test.go", "TestX86AESFamilyActualBoundFixedLocalConsumers"},
+	} {
+		t.Run(owner.helper, func(t *testing.T) {
+			function := fixedLocalLeaseFunctions(t, owner.filename)[owner.helper]
+			if function == nil {
+				t.Fatal("missing complete independently scheduled source owner", owner.helper)
+			}
+			calls := fixedLocalLeaseCalls(function.Body)
+			if calls["fixedLocalFreshAPIs"] != 1 {
+				t.Error("complete source must use the shared fresh-capture API owner exactly once")
+			}
+			for _, name := range []string{"fixedLocalAPIs", "requireGoAMD64FrameCapture", "runtimeOracleStageContext", "runtimeOracleProofContext"} {
+				if calls[name] != 0 {
+					t.Errorf("outer %s would start or share a lease before the current API", name)
+				}
+			}
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if ok {
+					if name := fixedLocalLeaseCallName(call); name == "source.BindFixedLocal" || name == "observer.BindFixedLocal" {
+						t.Error("complete source must not transport an outer API's bound options")
+					}
+				}
+				return true
+			})
+		})
+	}
+
+	// CMOV runtime currently owns one public API. Do not silently multiply its
+	// expensive execution matrix while repairing the three-API object owners.
+	function := fixedLocalLeaseFunctions(t, "amd64_cmov_fixed_local_runtime_test.go")["x86CMOVFixedLocalRuntimeBatch"]
+	if function == nil || fixedLocalLeaseCalls(function.Body)["Translate"] != 1 || fixedLocalLeaseCalls(function.Body)["fixedLocalFreshAPIs"] != 0 {
+		t.Fatal("single-API CMOV runtime ownership changed")
+	}
+}
+
+func TestFixedLocalWideCompileOnlyHasThreeCompleteAPIOwners(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_fixed_local_packed_runtime_test.go")
+	owners := []struct{ root, api string }{
+		{"TestGoAMD64FixedLocalPackedWideRuntimeOracleCompileOnly", "Translate"},
+		{"TestGoAMD64FixedLocalPackedWideRuntimeOracleModuleCompileOnly", "Module"},
+		{"TestGoAMD64FixedLocalPackedWideRuntimeOracleGoModuleCompileOnly", "GoModule"},
+	}
+	want := make(map[string]bool)
+	for _, owner := range owners {
+		want[owner.root] = true
+	}
+	for name := range functions {
+		if strings.HasPrefix(name, "TestGoAMD64FixedLocalPackedWideRuntimeOracle") && !want[name] {
+			t.Error("unknown or duplicated complete-wide API owner", name)
+		}
+	}
+	for _, owner := range owners {
+		t.Run(owner.api, func(t *testing.T) {
+			function := functions[owner.root]
+			if function == nil {
+				t.Fatal("missing independent complete 340-kernel API owner", owner.root)
+			}
+			var calls []*ast.CallExpr
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				if call, ok := node.(*ast.CallExpr); ok && fixedLocalLeaseCallName(call) == "fixedLocalPackedRuntimeAPIs" {
+					calls = append(calls, call)
+				}
+				return true
+			})
+			if len(calls) != 1 || len(calls[0].Args) != 5 {
+				t.Fatal("API owner must call the unchanged full wide program once, without three-API accumulation")
+			}
+			call := calls[0]
+			for index, name := range []string{"t", "execution", "true", "false"} {
+				identifier, ok := call.Args[index].(*ast.Ident)
+				if !ok || identifier.Name != name {
+					t.Fatal("wide compile-only owner lost its original complete-source/execute=false role")
+				}
+			}
+			apis, ok := call.Args[4].(*ast.CompositeLit)
+			if !ok || len(apis.Elts) != 1 {
+				t.Fatal("one top-level owner must execute exactly one API, not crop the source")
+			}
+			literal, ok := apis.Elts[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("API owner must retain an explicit API identity")
+			}
+			api, err := strconv.Unquote(literal.Value)
+			if err != nil || api != owner.api {
+				t.Fatal("substituted or duplicated complete-source API", api, err)
+			}
+		})
+	}
+	runtime := functions["fixedLocalPackedRuntime"]
+	if runtime == nil || fixedLocalLeaseCalls(runtime.Body)["fixedLocalPackedRuntimeAPIs"] != 1 {
+		t.Error("original native runtime must still execute its complete three-API plan")
+	} else {
+		apis := make(map[string]int)
+		ast.Inspect(runtime.Body, func(node ast.Node) bool {
+			literal, ok := node.(*ast.BasicLit)
+			if ok && literal.Kind == token.STRING {
+				value, err := strconv.Unquote(literal.Value)
+				if err == nil {
+					apis[value]++
+				}
+			}
+			return true
+		})
+		for _, api := range []string{"Translate", "Module", "GoModule"} {
+			if apis[api] != 1 {
+				t.Error("original runtime lost one complete public API", api)
+			}
+		}
+	}
+	helper := functions["fixedLocalPackedRuntimeAPIs"]
+	if helper != nil {
+		calls := fixedLocalLeaseCalls(helper.Body)
+		for _, name := range []string{"fixedLocalPackedLeaseBatches", "fixedLocalFreshAPIs"} {
+			if calls[name] != 1 {
+				t.Errorf("each API must own complete <=64-function source batches: %s count %d", name, calls[name])
+			}
+		}
+		if calls["fixedLocalPackedRunOriginal"] != 1 {
+			t.Error("the complete original Go oracle must remain independently compiled/executed once")
+		}
+		pipelines := make(map[string]int)
+		ast.Inspect(helper.Body, func(node ast.Node) bool {
+			literal, ok := node.(*ast.BasicLit)
+			if ok && literal.Kind == token.STRING {
+				value, err := strconv.Unquote(literal.Value)
+				if err == nil {
+					pipelines[value]++
+				}
+			}
+			return true
+		})
+		for _, name := range []string{"backend_O0", "backend_O2", "IR_O2/backend_O2"} {
+			if pipelines[name] != 1 {
+				t.Error("every complete source batch must retain the three independent LLVM pipelines", name)
+			}
+		}
+	}
+
+	fixedLocalPackedRequireNativeBatchOwners(t)
+}
+
+func fixedLocalLeaseFunctions(t *testing.T, filename string) map[string]*ast.FuncDecl {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range syntax.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			functions[function.Name.Name] = function
+		}
+	}
+	return functions
+}
+
+func fixedLocalLeaseCalls(node ast.Node) map[string]int {
+	counts := make(map[string]int)
+	ast.Inspect(node, func(node ast.Node) bool {
+		if call, ok := node.(*ast.CallExpr); ok {
+			counts[fixedLocalLeaseCallName(call)]++
+		}
+		return true
+	})
+	return counts
+}
+
+func fixedLocalLeaseCallName(call *ast.CallExpr) string {
+	if name, ok := call.Fun.(*ast.Ident); ok {
+		return name.Name
+	}
+	if selector, ok := call.Fun.(*ast.SelectorExpr); ok {
+		if receiver, ok := selector.X.(*ast.Ident); ok {
+			return receiver.Name + "." + selector.Sel.Name
+		}
+	}
+	return ""
+}
+
+func fixedLocalLeaseRequireArguments(t *testing.T, call *ast.CallExpr, names ...string) {
+	t.Helper()
+	if len(call.Args) != len(names) {
+		t.Errorf("%s changed complete source/binding arguments", fixedLocalLeaseCallName(call))
+		return
+	}
+	for index, name := range names {
+		identifier, ok := call.Args[index].(*ast.Ident)
+		if !ok || identifier.Name != name {
+			t.Errorf("%s substituted argument %d: want %s", fixedLocalLeaseCallName(call), index, name)
+		}
+	}
+}
diff --git a/amd64_fixed_local_auto.go b/amd64_fixed_local_auto.go
new file mode 100644
index 000000000..19ab49bc4
--- /dev/null
+++ b/amd64_fixed_local_auto.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"math"
+	"reflect"
+	"strings"
+)
+
+// NAME_AUTO is a source address role, not an input/storage permission. Go
+// obj6 adds deltasp-bpsize to its explicit offset. This bounded observer has
+// no CALL/PUSH/POP/ADJSP producer, so the lexical bias is exactly TEXT's local
+// size; separately proved SP relocation still contributes its native offset.
+// Replay the original operand because parsing constant expressions alone
+// loses the difference between tmp-8(SP) and physical -8(SP).
+func fixedLocalMemoryAddress(ins Instr, index int, frame int64) (MemRef, error) {
+	fail := func() (MemRef, error) {
+		return MemRef{}, goAMD64FrameContext("fixed local original memory address role is not closed")
+	}
+	if index < 0 || index >= len(ins.Args) {
+		return fail()
+	}
+	operand := ins.Args[index]
+	addressMove := false
+	if index == 0 {
+		if view, known, err := x86NamedFrameMoveAddressInstruction(ins, "amd64"); known {
+			if err != nil {
+				return fail()
+			}
+			operand, addressMove = view.Args[0], true
+		}
+	}
+	if operand.Kind != OpMem {
+		return fail()
+	}
+	memory := operand.Mem
+	if memory.Base != SP {
+		if memory.OffRaw != "" {
+			return fail()
+		}
+		return memory, nil
+	}
+	op, rest := splitOpcode(ins.Raw)
+	literals := splitTopLevelCSV(rest)
+	if !strings.EqualFold(op, string(ins.Op)) || len(literals) != len(ins.Args) {
+		return fail()
+	}
+	parsed, err := parseOperandForArch(ArchAMD64, literals[index])
+	if err != nil || !reflect.DeepEqual(parsed, ins.Args[index]) {
+		return fail()
+	}
+	spelling := strings.TrimSpace(literals[index])
+	if addressMove {
+		spelling = strings.TrimSpace(strings.TrimPrefix(spelling, "$"))
+	}
+	literal := x86ResultAUTOLiteral.FindStringSubmatch(spelling)
+	if literal == nil {
+		// Indexing/segment/symbol roles are independently validated by the
+		// native observer; none may be relabeled as a named local offset.
+		if memory.OffRaw != "" {
+			return fail()
+		}
+		return memory, nil
+	}
+	prefix := strings.TrimSpace(literal[1])
+	offset, named := parseNamedStackConstantOffset(prefix)
+	if validPPIdentifier(prefix) {
+		offset, named = 0, true
+	}
+	if !named {
+		if memory.OffRaw != "" {
+			return fail()
+		}
+		return memory, nil // Numeric, unnamed (SP) remains post-prologue SP.
+	}
+	if offset != memory.Off || frame <= 0 || offset > 0 && frame > math.MaxInt64-offset {
+		return fail()
+	}
+	memory.Off += frame
+	memory.OffRaw = ""
+	return memory, nil
+}
+
+// This query resolves only a complete numerical constant index. It neither
+// changes the emitted address nor supplies a memory origin, extent or access.
+// All arithmetic is checked before an original private/literal bound is used.
+func fixedLocalConstantDisplacement(memory MemRef, state *x86FixedLocalState) (int64, bool) {
+	if memory.OffRaw != "" || memory.Sym != "" || memory.Segment != "" || memory.IndexExt != "" {
+		return 0, false
+	}
+	if memory.Index == "" {
+		return memory.Off, memory.Scale == 0
+	}
+	root, valid := x86CallerGP(memory.Index)
+	value, known := state.constants[root]
+	scale := memory.Scale
+	if !valid || root != memory.Index || !known ||
+		!fixedLocalNumericRead(Operand{Kind: OpReg, Reg: root}, 8, state) ||
+		scale != 1 && scale != 2 && scale != 4 && scale != 8 {
+		return 0, false
+	}
+	if value > math.MaxInt64/scale || value < math.MinInt64/scale {
+		return 0, false
+	}
+	delta := value * scale
+	if delta > 0 && memory.Off > math.MaxInt64-delta || delta < 0 && memory.Off < math.MinInt64-delta {
+		return 0, false
+	}
+	return memory.Off + delta, true
+}
+
+// Reads, writes and complete pointer-spill lookups use the same resolved
+// byte address. An indexed read must not borrow the unindexed slot's role.
+func fixedLocalPrivateOffset(memory MemRef, state *x86FixedLocalState) (int64, bool) {
+	base, private := state.pointers[memory.Base]
+	displacement, known := fixedLocalConstantDisplacement(memory, state)
+	if !private || !known || displacement > 0 && base > math.MaxInt64-displacement ||
+		displacement < 0 && base < math.MinInt64-displacement {
+		return 0, false
+	}
+	return base + displacement, true
+}
+
+// Descriptive bare NAME_AUTO is offset zero, not an undefined preprocessor
+// expression. This syntax query does not grant a native memory certificate.
+func x86ConditionalMoveOffsetKnown(memory MemRef) bool {
+	if memory.OffRaw == "" {
+		return true
+	}
+	if memory.Base != SP || memory.Sym != "" {
+		return false
+	}
+	if offset, named := parseNamedStackConstantOffset(memory.OffRaw); named {
+		return offset == memory.Off
+	}
+	return validPPIdentifier(memory.OffRaw) && memory.Off == 0
+}
+
+func fixedLocalConditionalMoveStep(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, known, err := x86ConditionalMoveProperties(ins.Op, *ins, "amd64")
+	if !known {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local CMOV flags or conditional value roles are not defined")
+	}
+	required := x86ByteConditionFlags(form.condition)
+	if err != nil || required == 0 || state.flags&required != required {
+		return fail()
+	}
+	if ins.Args[0].Kind == OpFP {
+		// Declared numerical FP inputs use the shared GP effect. This value
+		// transport path retains its existing pointer and private-spill roles.
+		value, err := fixedLocalReadValue(ins, 0, state, sig, proof, residue, int64(form.bits/8), false)
+		if err != nil || value.pointer || value.opaque {
+			return fail()
+		}
+		old, err := fixedLocalReadValue(ins, 1, state, sig, proof, residue, int64(form.bits/8), false)
+		if err != nil || old.pointer || old.opaque {
+			return fail()
+		}
+		return false, nil
+	}
+	width := int64(form.bits / 8)
+	old, err := fixedLocalReadValue(ins, 1, state, FuncSig{}, proof, residue, width, false)
+	if err != nil {
+		return true, err
+	}
+	// Both potential values remain mandatory. In particular memory is read
+	// unconditionally; selecting it never grants logical FP pointer imports.
+	value, err := fixedLocalReadValue(ins, 0, state, FuncSig{}, proof, residue, width, false)
+	if err != nil {
+		return true, err
+	}
+	if value.opaque && old.opaque && !value.identity.equal(old.identity) &&
+		(!fixedLocalOriginOwners(value.identity, proof) || !fixedLocalOriginOwners(old.identity, proof)) {
+		return fail()
+	}
+	value, valid := mergeFixedLocalScalarValues(value, old)
+	if !valid {
+		return fail()
+	}
+	return true, fixedLocalWriteValue(ins, 1, 0, value, state, FuncSig{}, proof, residue, width)
+}
diff --git a/amd64_fixed_local_binary_effect_test.go b/amd64_fixed_local_binary_effect_test.go
new file mode 100644
index 000000000..7727851dc
--- /dev/null
+++ b/amd64_fixed_local_binary_effect_test.go
@@ -0,0 +1,336 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This independent inventory includes PADDD's source alias separately from
+// the 27 canonical legacy XMM instructions. No production spec defines it.
+func fixedLocalBinaryEffectNames() []string {
+	names := append([]string(nil), x86LegacyIntegerArithmeticTestNames...)
+	return append(names, "PMULLD", "PMULLW", "PMULHW", "PMULHUW", "PMULHRSW",
+		"PMULDQ", "PMULULQ", "PAVGB", "PAVGW", "PMADDWL", "PMADDUBSW")
+}
+
+func TestGoAMD64FixedLocalTypedBinaryEffects(t *testing.T) {
+	names := fixedLocalBinaryEffectNames()
+	if len(names) != 28 {
+		t.Fatalf("independent legacy family inventory: %d, want 27 + one alias", len(names))
+	}
+	var original strings.Builder
+	ordinal := 0
+	for _, name := range names {
+		for _, input := range []string{"16(SP)", "X1", "X0"} {
+			t.Run(name+"/"+input, func(t *testing.T) {
+				operation := name + " " + input + ",X0"
+				source, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "MOVOU 16(SP),X1\n"+operation)
+				original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+				ordinal++
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				proved, err := proveX86FixedLocal(file.Funcs[0], sig)
+				if err != nil {
+					t.Fatal("initialized complete legacy family source rejected", err)
+				}
+				observed := 0
+				for _, ins := range proved.Instrs {
+					if string(ins.Op) != name {
+						continue
+					}
+					observed++
+					access, found := ins.x86FixedLocalMemory[0]
+					if found != (input == "16(SP)") || found &&
+						(access.width != 16 || access.write || access.nativeInput || access.owner != proved.x86FixedLocal) {
+						t.Fatalf("wrong exact private memory role: %+v", access)
+					}
+				}
+				if observed != 1 {
+					t.Fatalf("proved source retained %d target instructions, want one", observed)
+				}
+				candidate, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$160-40\n"+operation+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if GoAMD64FixedLocalFrameBindingNeeded(candidate, "amd64") != (input == "16(SP)") ||
+					GoAMD64FixedLocalFrameBindingNeeded(candidate, "386") {
+					t.Fatal("candidate query differs from the typed memory role")
+				}
+			})
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalTypedBinaryAliasBytes(t *testing.T) {
+	for _, name := range fixedLocalBinaryEffectNames() {
+		for _, old := range []uint64{0xffff, 0x804020100000ffff, ^uint64(0)} {
+			t.Run(fmt.Sprintf("%s/%x", name, old), func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+name+" X1,X0\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				state := x86FixedLocalState{
+					vectors: map[Reg]uint64{x86CallerVectorRoot("X0"): old, x86CallerVectorRoot("X1"): 0xffff},
+					flags:   x86ByteFlagCF,
+				}
+				if err := fixedLocalVectorStep(&file.Funcs[0].Instrs[1], &state, nil, 0); err != nil {
+					t.Fatal(err)
+				}
+				if state.vectors[x86CallerVectorRoot("X0")] != old || state.flags != x86ByteFlagCF {
+					t.Fatal("legacy arithmetic changed upper vector definedness or FLAGS", state)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalTypedBinaryMetadata(t *testing.T) {
+	for _, name := range fixedLocalBinaryEffectNames() {
+		file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+name+" X1,X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+		if !known || err != nil || effect.vector.upperWrite != x86TypedVectorUpperPreserve ||
+			effect.vector.memoryAlignment != 16 || len(effect.operands) != 2 {
+			t.Fatal("shared descriptor lost the complete validated alias/storage role", name, effect, err)
+		}
+		lowercase := ins
+		lowercase.Op = Op(strings.ToLower(name))
+		lowerEffect, lowerKnown, lowerErr := x86TypedInstructionByteEffect(lowercase.Op, lowercase, "amd64")
+		if !lowerKnown || lowerErr != nil || !reflect.DeepEqual(lowerEffect, effect) {
+			t.Fatal("negative prefix filter changed the case-insensitive family contract", name, lowerErr)
+		}
+		effect.vector = x86TypedVectorEffect{}
+		state := x86FixedLocalState{vectors: map[Reg]uint64{
+			x86CallerVectorRoot("X0"): ^uint64(0), x86CallerVectorRoot("X1"): ^uint64(0),
+		}}
+		if err := fixedLocalTypedByteStep(&ins, &state, FuncSig{}, nil, 0, effect); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unregistered default metadata authorized a vector effect", name, err)
+		}
+	}
+	for _, name := range []string{"PADDW", "PMULLW", "PMULULQ", "PAVGB", "PMADDWL"} {
+		file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+name+" AX,M1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+		if !known || err != nil || len(effect.operands) != 2 || effect.operands[0].operand.Reg != "M0" ||
+			effect.operands[0].width != 8 || effect.vector != (x86TypedVectorEffect{}) {
+			t.Fatal("GP spelling changed the physical MMX bank or granted XMM metadata", name, effect, err)
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalTypedBinaryBoundaries(t *testing.T) {
+	for _, name := range []string{"PSUBSW", "PMULLD", "PMULHW", "PMULDQ", "PAVGB", "PMADDUBSW"} {
+		source, sig, _ := x86PrivateAlignedFrameAuditFixture(t, name+" 16(SP),X0")
+		for _, row := range []struct{ name, from, to string }{
+			{"missing memory byte", "MOVQ CX,24(SP)", "MOVB CX,24(SP)"},
+			{"unknown destination", "MOVOU 48(SP),X0", "MOVOU 48(SP),X1"},
+			{"unaligned memory", name + " 16(SP)", name + " 17(SP)"},
+			{"outside frame", name + " 16(SP)", name + " 160(SP)"},
+			{"unknown source", name + " 16(SP)", name + " X2"},
+			{"MMX source bank", name + " 16(SP),X0", name + " 16(SP),M0"},
+			{"unbound FP", name + " 16(SP)", name + " a+0(FP)"},
+			{"raw source", name + " 16(SP),X0", "BYTE $0x90"},
+			{"private pointer spill", "MOVQ AX,16(SP)", "MOVQ SP,16(SP)"},
+		} {
+			t.Run(name+"/"+row.name, func(t *testing.T) {
+				changed := strings.Replace(source, row.from, row.to, 1)
+				if changed == source {
+					t.Fatal("negative fixture did not change the complete source")
+				}
+				file, err := Parse(ArchAMD64, changed)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unproved native bytes gained fixed-local authority", err)
+				}
+			})
+		}
+		t.Run(name+"/opaque pointer spill", func(t *testing.T) {
+			source, sig, _ := x86PrivateAlignedFrameAuditTypedFixture(t, name+" 16(SP),X0",
+				"package frameaudit\nfunc Value(a *uint64, b, c, d uint64) uint64\n")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+				t.Fatal("complete native spill bits were rejected as vector input", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedBinaryObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, _, _ := fixedLocalBinaryRuntimeProgram(t, "x86_64-unknown-linux-gnu")
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			var names []string
+			for index := range fixedLocalBinaryEffectNames() {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "legacy-binary.ll", "legacy-binary.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "legacy-binary-opt.ll", "legacy-binary-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
+
+// One complete original source serves both the object matrix and native
+// differential test. Observe both result halves and a separate input canary.
+func fixedLocalBinaryRuntimeProgram(t *testing.T, triple string) (string, string, string, string) {
+	t.Helper()
+	return fixedLocalBinaryRuntimeProgramForNames(t, triple, fixedLocalBinaryEffectNames())
+}
+
+func fixedLocalBinaryRuntimeProgramForNames(t *testing.T, triple string, names []string) (string, string, string, string) {
+	t.Helper()
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, name := range names {
+		source, _, _ := x86PrivateAlignedFrameAuditFixture(t, name+" 16(SP),X0")
+		source = strings.Replace(source, "$160-40", "$160-48", 1)
+		source = strings.Replace(source, "MOVQ SP,R11", "MOVQ mode+32(FP),R8\nMOVQ SP,R11", 1)
+		source = strings.Replace(source, "MOVQ X0,AX", `MOVOU X0,48(SP)
+CMPQ R8,$1
+JEQ high
+CMPQ R8,$2
+JEQ canary
+MOVQ 48(SP),AX
+JMP done
+high:
+MOVQ 56(SP),AX
+JMP done
+canary:
+MOVQ 16(SP),AX
+done:`, 1)
+		source = strings.Replace(source, "ret+32(FP)", "ret+40(FP)", 1)
+		function := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+function, 1))
+		fmt.Fprintf(&declarations, "func %s(a,b,c,d,mode uint64) uint64\n", function)
+		fmt.Fprintf(&goRows, "%s,\n", function)
+		fmt.Fprintf(&cRows, "value%d,\n", index)
+		label := runtimeCAsmLabel(prefix + "example.invalid/framefixture." + function)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t,uint64_t,uint64_t,uint64_t,uint64_t) __asm__(%s);\n", index, label)
+	}
+	const values = `0,1,0x7f7f7f7f7f7f7f7f,0x8080808080808080,
+0x7fff7fff7fff7fff,0x8000800080008000,0x7fffffff7fffffff,
+0x8000000080000000,0xffffffffffffffff,0x0123456789abcdef`
+	original := `package main
+import "fmt"
+` + declarations.String() + `
+func main() {
+    rows := []func(uint64,uint64,uint64,uint64,uint64) uint64{
+` + goRows.String() + `
+    }
+    values := []uint64{` + values + `}
+    for n, call := range rows {
+        for v, value := range values {
+            for mode := uint64(0); mode < 3; mode++ {
+                got := call(value,values[(v+1)%len(values)],^value,values[(v+len(values)-1)%len(values)],mode)
+                fmt.Printf("%d %d %d %016x\n",n,v,mode,got)
+            }
+        }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+int main(void) {
+    uint64_t (*rows[])(uint64_t,uint64_t,uint64_t,uint64_t,uint64_t) = {
+` + cRows.String() + `
+    };
+    const uint64_t values[] = {` + values + `};
+    const size_t count = sizeof(values)/sizeof(values[0]);
+    for (size_t n = 0; n < sizeof(rows)/sizeof(rows[0]); n++) {
+        for (size_t v = 0; v < count; v++) {
+            for (unsigned mode = 0; mode < 3; mode++) {
+                uint64_t got = rows[n](values[v],values[(v+1)%count],~values[v],values[(v+count-1)%count],mode);
+                printf("%zu %zu %u %016llx\n",n,v,mode,(unsigned long long)got);
+            }
+        }
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func BenchmarkFixedLocalLegacyVectorStep(b *testing.B) {
+	for _, operation := range []string{"PADDQ X1,X0", "PMADDWL X1,X0", "CMPPS X1,X0,$0"} {
+		b.Run(strings.Fields(operation)[0], func(b *testing.B) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+operation+"\nRET\n")
+			if err != nil {
+				b.Fatal(err)
+			}
+			state := x86FixedLocalState{vectors: map[Reg]uint64{
+				x86CallerVectorRoot("X0"): ^uint64(0), x86CallerVectorRoot("X1"): ^uint64(0),
+			}}
+			instruction := &file.Funcs[0].Instrs[1]
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				if err := fixedLocalVectorStep(instruction, &state, nil, 0); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkFixedLocalLegacyVectorProof(b *testing.B) {
+	for _, operation := range []string{"PADDQ X1,X0", "PMADDWL X1,X0", "CMPPS X1,X0,$0"} {
+		b.Run(strings.Fields(operation)[0], func(b *testing.B) {
+			source := "TEXT ·Value(SB),4,$64-16\nMOVQ a+0(FP),AX\n" +
+				"MOVQ AX,0(SP)\nMOVQ AX,8(SP)\nMOVOU 0(SP),X0\nMOVOU X0,X1\n" +
+				strings.Repeat(operation+"\n", 8) + "MOVQ X0,AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				b.Fatal(err)
+			}
+			sig := FuncSig{Name: "Value", Args: []LLVMType{I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				}}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_binary_runtime_test.go b/amd64_fixed_local_binary_runtime_test.go
new file mode 100644
index 000000000..bb04824a7
--- /dev/null
+++ b/amd64_fixed_local_binary_runtime_test.go
@@ -0,0 +1,61 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTypedBinary(t *testing.T) {
+	fixedLocalBinaryRuntime(t, fixedLocalBinaryEffectNames(), 28)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTypedLogical(t *testing.T) {
+	fixedLocalBinaryRuntime(t, x86LegacyLogicalMemoryNames, 12)
+}
+
+func fixedLocalBinaryRuntime(t *testing.T, names []string, count int) {
+	t.Helper()
+	if len(names) != count {
+		t.Fatalf("independent runtime kernel inventory: %d, want %d", len(names), count)
+	}
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	t.Setenv("GOCACHE", t.TempDir())
+	assembly, declarations, original, driver := fixedLocalBinaryRuntimeProgramForNames(t, execution.triple, names)
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))), "\n")
+	if len(want) != count*10*3 {
+		t.Fatalf("original Go produced %d rows, want %d kernels x 10 values x 3 observations", len(want), count)
+	}
+	pkg, request, _, options := fixedLocalTransportFixture(t,
+		assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "private-binary", input, driver, level)
+					got := strings.Split(strings.TrimSpace(string(output)), "\n")
+					if len(got) != len(want) {
+						t.Fatalf("LLVM row count = %d, original = %d", len(got), len(want))
+					}
+					for index := range want {
+						if got[index] != want[index] {
+							t.Fatalf("private packed value/canary row %d: original %s; LLVM %s", index, want[index], got[index])
+						}
+					}
+				})
+			}
+		})
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("original Go and LLVM amd64 execution via Rosetta, not native x86 hardware")
+	}
+}
diff --git a/amd64_fixed_local_binding.go b/amd64_fixed_local_binding.go
new file mode 100644
index 000000000..a96d576b4
--- /dev/null
+++ b/amd64_fixed_local_binding.go
@@ -0,0 +1,548 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+// The public value transports only a private live observer binding. Neither
+// a declaration, a frame size nor a JSON round trip can construct this proof.
+type x86FixedLocalBinding struct {
+	identity       *x86FixedLocalBinding
+	source         *GoAMD64FrameSource
+	context        context.Context
+	file           [32]byte
+	assembly       string
+	target         string
+	inputs         map[string][32]byte
+	signatures     map[string]FuncSig
+	frames         map[string]bool   // Only entries whose complete local proof succeeded.
+	leaves         map[string]string // Original source symbol to observed native TEXT, never a signature.
+	symbols        map[string]string
+	declarations   map[string]goAMD64FrameDeclaration
+	callees        map[string]goAMD64FrameDeclaration // Separate typed Go/SDK callees, not private source TEXTs.
+	numericalReads *GoX86NumericalReadBinding
+	literalData    map[string]x86FixedLocalData
+	globals        map[string]goReadOnlyObject
+}
+
+// BindFixedLocal binds a complete original typed ABI0 file to its actual Go
+// object observation. It does not support dynamic incoming frames, pointees,
+// unauthenticated imported declarations, native entries or arbitrary local-memory
+// effects. Foreign SDK calls require their captured declaration and ABI0 entry.
+// The returned Options are independent copies; their private signatures may
+// also be transported by GoModuleOptions.ManualSig. The capture context must
+// remain live through translation. Close or any failed Verify revokes them.
+func (source *GoAMD64FrameSource) BindFixedLocal(ctx context.Context, pkg GoPackage, file *File, options Options) (Options, error) {
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	if file == nil || options.ResolveSym == nil {
+		return Options{}, goAMD64FrameContext("fixed local binding needs complete source and symbol resolution")
+	}
+	originalOptions := options
+	numerical := options.NumericalReads
+	if numerical != nil {
+		if err := verifyNumericalReadInputs(file, options); err != nil {
+			return Options{}, err
+		}
+		source.mu.Lock()
+		joined := source.numericalBinding == numerical
+		source.mu.Unlock()
+		if !joined || ctx != numerical.context || pkg.Types != numerical.originalTypes ||
+			!numericalSameImports(pkg.Imports, numerical.originalImports) {
+			return Options{}, goAMD64FrameContext("fixed local source has a foreign numerical read owner")
+		}
+	}
+	// Never execute a caller callback while holding the observer lock. Freeze
+	// its answers before the locked full-source/declaration comparison; that
+	// comparison rejects any mutation made while resolving these names.
+	resolved := make(map[string]string, len(file.Funcs))
+	for _, fn := range file.Funcs {
+		resolved[fn.Sym] = options.ResolveSym(fn.Sym)
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpCALL && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym {
+				if name, offset, valid := parseSBRef(ins.Args[0].Sym); valid && offset == 0 {
+					resolved[name] = options.ResolveSym(name)
+				}
+			}
+		}
+	}
+	for _, global := range file.Globl {
+		if name, valid := fixedLocalDataSymbol(global.Sym); valid {
+			resolved[name] = options.ResolveSym(name)
+		}
+	}
+	for symbol := range fixedLocalGlobalSymbols(file) {
+		resolved[symbol] = options.ResolveSym(symbol)
+	}
+	options.ResolveSym = func(symbol string) string { return resolved[symbol] }
+	if numerical != nil {
+		// The caller has been checked; the locked observation consumes only
+		// sealed answers, without re-entering numerical/owner callbacks.
+		options.ResolveSym = numerical.resolve
+	}
+	// ResolveSym may change the caller's lifetime. Sample its context only
+	// outside the observer lock and retain the original, not this temporary
+	// standard command context, in every returned private binding.
+	private, contextErr := captureGoAMD64FramePrivateContext(ctx)
+	if contextErr != nil {
+		source.mu.Lock()
+		source.ready = false
+		source.mu.Unlock()
+		return Options{}, errors.Join(goAMD64FrameContext("fixed local caller context expired"), contextErr)
+	}
+	defer private.stop()
+	source.mu.Lock()
+	bound, err := source.bindFixedLocalLocked(private, ctx, pkg, file, options)
+	source.mu.Unlock()
+	if contextErr := private.verify(); contextErr != nil {
+		source.mu.Lock()
+		source.ready = false
+		source.mu.Unlock()
+		return Options{}, errors.Join(err, goAMD64FrameContext("fixed local caller context expired"), contextErr)
+	}
+	if err != nil {
+		return Options{}, err
+	}
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	if numerical != nil {
+		if err := verifyNumericalReadInputs(file, originalOptions); err != nil {
+			return Options{}, err
+		}
+		// Bind a fresh numerical token to the independently established local
+		// capability. The frame keeps its original token; no token is mutated.
+		bound.NumericalReads = nil
+		return numerical.source.BindNumericalReads(ctx, pkg, file, bound)
+	}
+	return bound, nil
+}
+
+func (source *GoAMD64FrameSource) bindFixedLocalLocked(ctx context.Context, lifetime context.Context, pkg GoPackage, file *File, options Options) (Options, error) {
+	if !source.ready || ctx == nil || ctx.Err() != nil || file == nil || file.Arch != ArchAMD64 ||
+		options.Goarch != "amd64" || pkg.Types == nil || pkg.Path != source.selection.ImportPath || pkg.Types.Path() != pkg.Path {
+		return Options{}, goAMD64FrameContext("fixed local binding has no matching live package/target")
+	}
+	targets := map[string]string{
+		"x86_64-unknown-linux-gnu": "linux/amd64",
+		"x86_64-apple-darwin":      "darwin/amd64",
+		"x86_64-apple-macosx":      "darwin/amd64",
+		"x86_64-pc-windows-msvc":   "windows/amd64",
+		"x86_64-w64-windows-gnu":   "windows/amd64",
+	}
+	if targets[options.TargetTriple] != source.request.Target || options.WASMABI != WASMABIDirect ||
+		len(file.UnlinkedPrelude)+len(options.X86TailGroups) != 0 {
+		return Options{}, goAMD64FrameContext("fixed local binding target or complete source roles disagree")
+	}
+	original, err := goAMD64FrameRead(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil {
+		return Options{}, err
+	}
+	expanded, err := source.preprocess(source.request.AssemblyFile, original)
+	if err != nil {
+		return Options{}, err
+	}
+	actual, err := ParseWithDefines(ArchAMD64, expanded, nil)
+	if err != nil {
+		return Options{}, err
+	}
+	fingerprint, err := x86CallerSourceFingerprint(actual)
+	if err != nil {
+		return Options{}, err
+	}
+	provided, err := x86CallerSourceFingerprint(file)
+	if err != nil || provided != fingerprint {
+		return Options{}, goAMD64FrameContext("fixed local binding requires the exact full original parsed file")
+	}
+	resolve := options.ResolveSym
+	if resolve == nil {
+		return Options{}, goAMD64FrameContext("fixed local binding needs actual package symbol resolution")
+	}
+	globals, err := fixedLocalGlobalRequests(pkg, actual, resolve)
+	if err != nil {
+		return Options{}, err
+	}
+	declarations, err := source.typedDeclarationsForSourceRole(pkg, false, "amd64", false, nil, false, globals)
+	if err != nil {
+		return Options{}, err
+	}
+	callees, err := source.ordinaryCallDeclarations(pkg, actual)
+	if err != nil || !reflect.DeepEqual(callees, source.callees) {
+		return Options{}, errors.Join(goAMD64FrameContext("ordinary Go call declarations changed"), err)
+	}
+	binding := &x86FixedLocalBinding{
+		source:         source,
+		context:        lifetime,
+		file:           fingerprint,
+		assembly:       expanded,
+		target:         options.TargetTriple,
+		inputs:         make(map[string][32]byte, len(source.inputs)),
+		signatures:     make(map[string]FuncSig),
+		frames:         make(map[string]bool),
+		leaves:         make(map[string]string),
+		symbols:        make(map[string]string),
+		declarations:   make(map[string]goAMD64FrameDeclaration),
+		callees:        callees,
+		numericalReads: options.NumericalReads,
+		globals:        globals,
+	}
+	binding.identity = binding
+	literalData, dataSymbols, err := source.fixedLocalData(actual, expanded, resolve)
+	if err != nil {
+		return Options{}, err
+	}
+	binding.literalData = literalData
+	for symbol, name := range dataSymbols {
+		binding.symbols[symbol] = name
+	}
+	for symbol, object := range globals {
+		binding.symbols[symbol] = object.native
+	}
+	if options.NumericalReads != nil {
+		if err := joinNumericalReadCertificates(actual, options); err != nil {
+			return Options{}, err
+		}
+	}
+	for name, sum := range source.inputs {
+		binding.inputs[name] = sum
+	}
+	// Only the authenticated foreign SDK owner can supply a missing callee.
+	// Keep explicit consumer signatures strict and copy before exposing slices.
+	joined := make(map[string]FuncSig, len(options.Sigs)+len(callees))
+	for name, sig := range options.Sigs {
+		joined[name] = sig
+	}
+	for name, declaration := range callees {
+		path, _ := goReadOnlyImportedName(name)
+		if _, supplied := joined[name]; !supplied && path != pkg.Path {
+			selected, captured := source.imports[path]
+			if !captured || !selected.Standard || selected.Module != nil {
+				return Options{}, goAMD64FrameContext("ordinary callee defaults require their actual SDK owner")
+			}
+			joined[name] = declaration.signature
+		}
+	}
+	options.Sigs, err = cloneFixedLocalSigs(joined)
+	if err != nil {
+		return Options{}, err
+	}
+	actualSignatures, err := cloneFixedLocalSigs(options.Sigs)
+	if err != nil {
+		return Options{}, err
+	}
+	for name, declaration := range callees {
+		sig, supplied := options.Sigs[name]
+		if !supplied || !reflect.DeepEqual(sig, declaration.signature) {
+			return Options{}, goAMD64FrameContext("ordinary Go callee signature or resolution changed: %s", name)
+		}
+		binding.signatures[name] = actualSignatures[name]
+		binding.declarations[name] = declaration
+		binding.symbols[name] = name
+	}
+	leafSources := make(map[string]string)
+	for name, observed := range source.functions {
+		if observed.privateLeaf {
+			leafSources[observed.sourceSymbol] = name
+		}
+	}
+	for _, fn := range actual.Funcs {
+		name := resolve(fn.Sym)
+		for _, ins := range fn.Instrs {
+			if ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			symbol, _, _ := parseSBRef(ins.Args[0].Sym)
+			target := goAMD64FrameCallName(pkg.Path, symbol)
+			if _, ordinary := callees[target]; ordinary && resolve(symbol) != target {
+				return Options{}, goAMD64FrameContext("ordinary Go callsite changed its exact target resolution")
+			}
+			if _, ordinary := callees[target]; ordinary {
+				binding.symbols[symbol] = target
+			}
+		}
+		if native, leaf := leafSources[fn.Sym]; leaf {
+			if _, supplied := options.Sigs[name]; supplied || name == "" {
+				return Options{}, goAMD64FrameContext("private leaf cannot acquire a supplied callable signature")
+			}
+			binding.leaves[fn.Sym], binding.symbols[fn.Sym] = native, name
+			continue
+		}
+		observed, found := source.functions[name]
+		declaration, declared := declarations[name]
+		expectedName := pkg.Path + "." + strings.TrimPrefix(fn.Sym, "·")
+		sig, supplied := options.Sigs[name]
+		if !found || !supplied || name != expectedName || len(observed.code) == 0 ||
+			observed.locals != goAMD64FrameNativeLocals(fn.FrameSize) || !goAMD64FrameArgumentsMatch(fn, observed.args) ||
+			!reflect.DeepEqual(sig, observed.signature) || !declared ||
+			!source.matchesFixedLocalDeclaration(name, declaration) {
+			return Options{}, goAMD64FrameContext("fixed local actual declaration/object/symbol mismatch: %s", fn.Sym)
+		}
+		if fn.FrameSize > 0 {
+			binding.frames[name] = true
+			sig.x86FixedLocal = binding
+		}
+		binding.signatures[name] = actualSignatures[name]
+		// Preserve the independently re-typechecked language identity, not
+		// merely the collapsed LLVM signature. Neither observation-only
+		// composite roles nor stale private metadata can replace this witness.
+		declaration.signature = actualSignatures[name]
+		binding.declarations[name] = declaration
+		binding.symbols[fn.Sym] = name
+		options.Sigs[name] = sig
+	}
+	if len(options.Sigs)+len(binding.leaves) != len(actual.Funcs)+len(callees) {
+		return Options{}, goAMD64FrameContext("fixed local complete entry/leaf signature inventory differs")
+	}
+	if len(binding.frames) == 0 {
+		return Options{}, goAMD64FrameContext("complete source has no private fixed frame to bind")
+	}
+	graph, err := newX86FixedLocalLeafGraph(actual, options, binding)
+	if err != nil {
+		return Options{}, err
+	}
+	for _, fn := range actual.Funcs {
+		name := binding.symbols[fn.Sym]
+		if !binding.frames[name] {
+			continue
+		}
+		if err := ctx.Err(); err != nil {
+			return Options{}, err
+		}
+		if _, err := proveX86FixedLocalRoot(fn, options.Sigs[name], graph); err != nil {
+			return Options{}, err
+		}
+	}
+	return options, nil
+}
+
+// After validating mutable public input, consume only independent immutable
+// copies. A stateful resolver or a mutation of the caller's Options map cannot
+// change the declaration or function name between normalization and emission.
+func freezeX86FixedLocalOptions(options Options, bindings []*x86FixedLocalBinding) (Options, error) {
+	if len(bindings) == 0 {
+		return options, nil
+	}
+	symbols := make(map[string]string)
+	options.Sigs = make(map[string]FuncSig)
+	for _, binding := range bindings {
+		for symbol, name := range binding.symbols {
+			symbols[symbol] = name
+		}
+		signatures, err := cloneFixedLocalSigs(binding.signatures)
+		if err != nil {
+			return Options{}, err
+		}
+		for name, sig := range signatures {
+			if binding.frames[name] {
+				sig.x86FixedLocal = binding
+			}
+			options.Sigs[name] = sig
+		}
+	}
+	options.ResolveSym = func(symbol string) string {
+		if name, found := symbols[symbol]; found {
+			return name
+		}
+		if options.NumericalReads != nil {
+			return options.NumericalReads.resolve(symbol)
+		}
+		return symbol // No source contract admits external calls or addresses.
+	}
+	return options, nil
+}
+
+func freezeX86FixedLocalFile(file *File, bindings []*x86FixedLocalBinding) (*File, error) {
+	if len(bindings) == 0 {
+		return file, nil
+	}
+	if len(bindings) != 1 {
+		return nil, goAMD64FrameContext("fixed local complete file has multiple source owners")
+	}
+	binding := bindings[0]
+	fingerprint, err := x86CallerSourceFingerprint(file)
+	if err != nil || fingerprint != binding.file {
+		return nil, goAMD64FrameContext("fixed local resolver changed the original source during validation")
+	}
+	// Parsing the guarded observer's immutable expanded bytes gives the
+	// consumer independent Func/Instr/Operand slices with no caller aliases
+	// or pre-existing private certificates.
+	actual, err := ParseWithDefines(ArchAMD64, binding.assembly, nil)
+	if err != nil {
+		return nil, err
+	}
+	fingerprint, err = x86CallerSourceFingerprint(actual)
+	if err != nil || fingerprint != binding.file {
+		return nil, goAMD64FrameContext("fixed local sealed source snapshot changed")
+	}
+	if graph := file.x86DirectTails; graph != nil && graph.fixedLocal == binding {
+		actual.x86DirectTails = graph // Same verified complete source, fresh instruction slices.
+	}
+	return actual, nil
+}
+
+func cloneFixedLocalSigs(input map[string]FuncSig) (map[string]FuncSig, error) {
+	// The source signatures are JSON-encodable public ABI metadata. Reusing
+	// neither caller slices nor nested FrameSlot fields prevents mutation leaks.
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		return nil, goAMD64FrameContext("fixed local declaration cannot be independently copied: %v", err)
+	}
+	var result map[string]FuncSig
+	if err := json.Unmarshal(encoded, &result); err != nil {
+		return nil, goAMD64FrameContext("fixed local declaration copy cannot be decoded: %v", err)
+	}
+	return result, nil
+}
+
+func verifyX86FixedLocalBindings(file *File, options Options) ([]*x86FixedLocalBinding, error) {
+	var bindings []*x86FixedLocalBinding
+	seen := make(map[*x86FixedLocalBinding]bool)
+	for _, sig := range options.Sigs {
+		binding := sig.x86FixedLocal
+		if binding == nil || seen[binding] {
+			continue
+		}
+		seen[binding] = true
+		if file == nil || file.Arch != ArchAMD64 || options.Goarch != "amd64" || options.TargetTriple != binding.target ||
+			options.ResolveSym == nil || options.WASMABI != WASMABIDirect || len(options.X86TailGroups) != 0 {
+			return nil, goAMD64FrameContext("fixed local consumer target or resolver changed")
+		}
+		if err := binding.verify(); err != nil {
+			return nil, err
+		}
+		if binding.numericalReads != nil && (options.NumericalReads == nil ||
+			options.NumericalReads.source != binding.numericalReads.source ||
+			options.NumericalReads.context != binding.context) {
+			return nil, goAMD64FrameContext("fixed local numerical consumer has a foreign source/context")
+		}
+		fingerprint, err := x86CallerSourceFingerprint(file)
+		if err != nil || fingerprint != binding.file || len(options.Sigs) != len(binding.signatures) {
+			return nil, goAMD64FrameContext("fixed local consumer original/normalized source changed")
+		}
+		for _, fn := range file.Funcs {
+			name := options.ResolveSym(fn.Sym)
+			for _, ins := range fn.Instrs {
+				if _, ordinary := fixedLocalOrdinaryCall(ins, binding); ordinary {
+					symbol, _, _ := parseSBRef(ins.Args[0].Sym)
+					if options.ResolveSym(symbol) != binding.symbols[symbol] {
+						return nil, goAMD64FrameContext("ordinary Go callsite consumer resolution changed")
+					}
+				}
+			}
+			if _, leaf := binding.leaves[fn.Sym]; leaf {
+				if _, supplied := options.Sigs[name]; supplied || name != binding.symbols[fn.Sym] {
+					return nil, goAMD64FrameContext("private leaf consumer changed its non-callable identity")
+				}
+				continue
+			}
+			actual, found := options.Sigs[name]
+			expected, declared := binding.signatures[name]
+			var frame *x86FixedLocalBinding
+			if binding.frames[name] {
+				frame = binding
+			}
+			actual.x86FixedLocal = nil
+			if !found || !declared || name != binding.symbols[fn.Sym] || !reflect.DeepEqual(actual, expected) ||
+				options.Sigs[name].x86FixedLocal != frame {
+				return nil, goAMD64FrameContext("fixed local consumer declaration or unique symbol binding changed")
+			}
+		}
+		for name := range binding.callees {
+			if actual, found := options.Sigs[name]; !found || !reflect.DeepEqual(actual, binding.signatures[name]) {
+				return nil, goAMD64FrameContext("ordinary Go callee consumer signature or identity changed")
+			}
+		}
+		for _, global := range file.Globl {
+			name, private := fixedLocalDataSymbol(global.Sym)
+			if !private || options.ResolveSym(name) != binding.symbols[name] {
+				return nil, goAMD64FrameContext("fixed local consumer literal symbol resolution changed")
+			}
+		}
+		for symbol, object := range binding.globals {
+			if options.ResolveSym(symbol) != object.native {
+				return nil, goAMD64FrameContext("fixed local consumer Go variable resolution changed")
+			}
+		}
+		bindings = append(bindings, binding)
+	}
+	return bindings, nil
+}
+
+func (binding *x86FixedLocalBinding) verify() error {
+	if binding == nil || binding.identity != binding || binding.source == nil {
+		return goAMD64FrameContext("missing or expired fixed local observer binding")
+	}
+	if err := binding.source.Verify(binding.context); err != nil {
+		return err
+	}
+	binding.source.mu.Lock()
+	defer binding.source.mu.Unlock()
+	if !binding.source.ready || !reflect.DeepEqual(binding.inputs, binding.source.inputs) {
+		return goAMD64FrameContext("fixed local observer identity changed or was revoked")
+	}
+	if len(binding.declarations) != len(binding.signatures) || len(binding.frames) == 0 {
+		return goAMD64FrameContext("fixed local typed language witnesses are incomplete")
+	}
+	for name, signature := range binding.signatures {
+		declaration, found := binding.declarations[name]
+		if callee, ordinary := binding.callees[name]; ordinary {
+			if !found || binding.frames[name] || !reflect.DeepEqual(callee, declaration) ||
+				!reflect.DeepEqual(callee, binding.source.callees[name]) || !reflect.DeepEqual(signature, callee.signature) {
+				return goAMD64FrameContext("ordinary Go callee source identity changed")
+			}
+			continue
+		}
+		if !found || !reflect.DeepEqual(signature, declaration.signature) ||
+			!binding.source.matchesFixedLocalDeclaration(name, declaration) ||
+			binding.frames[name] != (binding.source.functions[name].locals > 0) {
+			return goAMD64FrameContext("fixed local typed language/object identity changed: %s", name)
+		}
+	}
+	for symbol, native := range binding.leaves {
+		fn, found := binding.source.functions[native]
+		if !found || !fn.privateLeaf || fn.sourceSymbol != symbol || fn.signature.Name != "" {
+			return goAMD64FrameContext("private leaf original machine identity changed")
+		}
+	}
+	return nil
+}
+
+// Called only while source.mu is held. The expected declaration comes from
+// an independent original-source typecheck at Bind, then a private deep copy
+// retained by that binding. A factory observation alone grants no permission.
+func (source *GoAMD64FrameSource) matchesFixedLocalDeclaration(name string, expected goAMD64FrameDeclaration) bool {
+	observed, found := source.functions[name]
+	original, declared := source.declarations[name]
+	return found && declared && fixedLocalTransportRole(expected.transport) &&
+		observed.transport == expected.transport && original.transport == expected.transport &&
+		expected.languageType != "" && observed.languageType == expected.languageType &&
+		original.languageType == expected.languageType &&
+		reflect.DeepEqual(observed.signature, expected.signature) && reflect.DeepEqual(original.signature, expected.signature)
+}
+
+func finishX86FixedLocalBindings(bindings []*x86FixedLocalBinding) error {
+	for _, binding := range bindings {
+		if err := binding.verify(); err != nil {
+			return fmt.Errorf("fixed local post-consumption verification: %w", err)
+		}
+	}
+	return nil
+}
+
+// Use a digest of the complete public instruction shape; private certificates
+// are not serialized and cannot self-authenticate a modified instruction.
+func fixedLocalInstructionDigest(ins Instr) ([32]byte, error) {
+	encoded, err := json.Marshal(ins)
+	if err != nil {
+		return [32]byte{}, goAMD64FrameContext("fixed local instruction cannot be bound: %v", err)
+	}
+	return sha256.Sum256(encoded), nil
+}
diff --git a/amd64_fixed_local_block_native_linux_amd64_test.go b/amd64_fixed_local_block_native_linux_amd64_test.go
new file mode 100644
index 000000000..240949aea
--- /dev/null
+++ b/amd64_fixed_local_block_native_linux_amd64_test.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalBlockTransfer(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, fixedLocalBlockRuntimeKernels())
+}
diff --git a/amd64_fixed_local_block_runtime_test.go b/amd64_fixed_local_block_runtime_test.go
new file mode 100644
index 000000000..e2a891ae5
--- /dev/null
+++ b/amd64_fixed_local_block_runtime_test.go
@@ -0,0 +1,39 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalBlockRuntimeKernels() []fixedLocalVEXRuntimeKernel {
+	var kernels []fixedLocalVEXRuntimeKernel
+	for _, name := range []string{"VINSERTF128", "VINSERTI128", "VEXTRACTF128", "VEXTRACTI128"} {
+		for _, selector := range []int{0, 1, 254, 255} {
+			prefix := fmt.Sprintf("%s $%d,", name, selector)
+			var operations []string
+			if strings.HasPrefix(name, "VINSERT") {
+				for _, source := range []string{"X0", "64(BP)", "65(BP)", "0(SI)", "1(SI)"} {
+					operations = append(operations, prefix+source+",Y1,Y2")
+				}
+				operations = append(operations, prefix+"X0,Y1,Y0", prefix+"X0,Y1,Y1", prefix+"X0,Y0,Y0")
+			} else {
+				for _, destination := range []string{"X2", "X1", "64(BP)", "65(BP)", "0(SI)", "1(SI)"} {
+					operations = append(operations, prefix+"Y1,"+destination)
+				}
+			}
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: operations[0], operations: operations})
+		}
+	}
+	return kernels
+}
+
+func TestGoAMD64FixedLocalBlockTransferRuntimeObjects(t *testing.T) {
+	kernels := fixedLocalBlockRuntimeKernels()
+	if len(kernels) != 16 {
+		t.Fatal("block-transfer runtime inventory changed", len(kernels))
+	}
+	fixedLocalVectorRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, kernels)
+}
diff --git a/amd64_fixed_local_block_transfer_test.go b/amd64_fixed_local_block_transfer_test.go
new file mode 100644
index 000000000..14f6fed12
--- /dev/null
+++ b/amd64_fixed_local_block_transfer_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalBlockWitnesses(t *testing.T) []fixedLocalVEXWitness {
+	t.Helper()
+	// Original Go has one unsigned insertion row and two overlapping
+	// signed/unsigned extraction rows for each of the F/I spellings.
+	return fixedLocalVEXFamilyWitnesses(t, `^V(INSERT|EXTRACT)[FI]128$`, 6, 18)
+}
+
+func TestGoAMD64FixedLocalBlockTransferCompleteFamilies(t *testing.T) {
+	witnesses := fixedLocalBlockWitnesses(t)
+	fixedLocalCheckVEXEncodings(t, witnesses)
+	fixedLocalCheckVEXPhysicalBoundaries(t, witnesses)
+	fixedLocalCheckVEXFamilies(t, witnesses)
+}
+
+func TestGoAMD64FixedLocalBlockTransferSelectedBytes(t *testing.T) {
+	for _, name := range []string{"VINSERTF128", "VINSERTI128", "VEXTRACTF128", "VEXTRACTI128"} {
+		insert := strings.HasPrefix(name, "VINSERT")
+		for _, alias := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/alias=%t", name, alias), func(t *testing.T) {
+				minimum := -128
+				if insert {
+					minimum = 0
+				}
+				for selector := minimum; selector <= 255; selector++ {
+					selected := uint64(0xffff) << (uint(selector&1) * 16)
+					input, destination := selected, "X2"
+					args := "Y1," + destination
+					if alias {
+						destination, args = "X1", "Y1,X1"
+					}
+					if insert {
+						input, destination = uint64(0xffffffff)&^selected, "Y2"
+						if alias {
+							destination = "Y1"
+						}
+						args = "X0,Y1," + destination
+					}
+					ins := x86YMMReadSource(t, fmt.Sprintf("%s $%d,%s", name, selector, args))
+					state := x86FixedLocalState{vectors: map[Reg]uint64{
+						"Z0": 0xffff, "Z1": input, "Z2": 0, "Z7": 123,
+					}, flags: x86ByteFlagsAll}
+					if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+						t.Fatal("unselected source bytes must not be inputs", selector, err)
+					}
+					if state.vectors[x86CallerVectorRoot(Reg(destination))] != ^uint64(0) ||
+						!alias && state.vectors["Z1"] != input || state.vectors["Z7"] != 123 || state.flags != x86ByteFlagsAll {
+						t.Fatal("block transfer lost an alias, upper zero or unrelated state", selector, state)
+					}
+					for bit := uint(0); bit < 32; bit++ {
+						if input&(1<<bit) == 0 {
+							continue
+						}
+						state.vectors["Z1"] = input &^ (1 << bit)
+						if err := fixedLocalVectorStep(&ins, &state, nil, 0); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("missing selected/retained byte accepted", selector, bit, err)
+						}
+					}
+				}
+			})
+		}
+	}
+	for _, name := range []string{"VINSERTF128", "VINSERTI128"} {
+		t.Run(name+"/all operands alias", func(t *testing.T) {
+			for selector := 0; selector <= 255; selector++ {
+				input := uint64(0xffffffff)
+				if selector&1 != 0 {
+					input = 0xffff // The low chunk supplies both halves.
+				}
+				ins := x86YMMReadSource(t, fmt.Sprintf("%s $%d,X0,Y0,Y0", name, selector))
+				for missing := -1; missing < 32; missing++ {
+					known := input
+					if missing >= 0 {
+						known &^= 1 << uint(missing)
+					}
+					state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": known}}
+					err := fixedLocalVectorStep(&ins, &state, nil, 0)
+					if known == input {
+						if err != nil || state.vectors["Z0"] != ^uint64(0) {
+							t.Fatal("aliased inputs lost their common selected bytes", selector, missing, err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("insertion invented a source/retained byte", selector, missing, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalBlockTransferMemoryBounds(t *testing.T) {
+	for _, name := range []string{"VINSERTF128", "VINSERTI128", "VEXTRACTF128", "VEXTRACTI128"} {
+		for _, offset := range []int{0, 65, 176, 177, 256} {
+			t.Run(fmt.Sprintf("%s/%d", name, offset), func(t *testing.T) {
+				args := fmt.Sprintf("$1,Y1,%d(BP)", offset)
+				if strings.HasPrefix(name, "VINSERT") {
+					args = fmt.Sprintf("$1,%d(BP),Y1,Y2", offset)
+				}
+				fn, sig, _ := fixedLocalVEXFixture(t, name+" "+args)
+				_, err := proveX86FixedLocal(fn, sig)
+				// The fixture initializes the private read extent through 191.
+				// Writes may initialize a new in-frame span, but never escape it.
+				want := offset >= 64 && offset <= 176 || !strings.HasPrefix(name, "VINSERT") && offset == 0
+				if (err == nil) != want {
+					t.Fatal("complete unaligned m128 access has wrong bounds", want, err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalBlockTransferObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	witnesses := fixedLocalBlockWitnesses(t)
+	for index, row := range witnesses {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(row.source), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(witnesses))
+}
diff --git a/amd64_fixed_local_broadcast_test.go b/amd64_fixed_local_broadcast_test.go
new file mode 100644
index 000000000..b759ca44b
--- /dev/null
+++ b/amd64_fixed_local_broadcast_test.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type fixedLocalBroadcastCase struct {
+	name, source, destination string
+	bytes                     int
+}
+
+// The independent complete Go table directory includes EVEX rows too. Only
+// these four original ytabs contain VEX rows; GP, mask and newer block sources
+// remain with their existing separate consumers.
+func fixedLocalBroadcastCases(t *testing.T) []fixedLocalBroadcastCase {
+	t.Helper()
+	var rows []fixedLocalBroadcastCase
+	for _, spec := range x86BroadcastTestDirectory {
+		switch spec.table {
+		case "_yvpbroadcastb", "_yvbroadcastss", "_yvbroadcastsd", "_yvbroadcastf128":
+		default:
+			continue
+		}
+		for _, bank := range spec.destinations {
+			if bank == 'Z' {
+				continue
+			}
+			sources := []string{"65(BP)"}
+			if strings.Contains(spec.source, "X") {
+				sources = append(sources, "X0")
+			}
+			for _, source := range sources {
+				rows = append(rows, fixedLocalBroadcastCase{spec.name, source, string(bank) + "2", spec.bytes})
+			}
+		}
+	}
+	if len(rows) != 24 {
+		t.Fatal("complete VEX broadcast memory/register and width inventory changed", len(rows))
+	}
+	return rows
+}
+
+func (row fixedLocalBroadcastCase) instruction() string {
+	return row.name + " " + row.source + "," + row.destination
+}
+
+func TestX86FixedLocalBroadcastOriginalFormsAndEffects(t *testing.T) {
+	rows := fixedLocalBroadcastCases(t)
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		for _, row := range rows {
+			source.WriteString(row.instruction() + "\n")
+		}
+		code, pcs := x86NumericalBoundaryGoBytes(t, arch, source.String()+"RET")
+		if len(pcs) != len(rows)+1 {
+			t.Fatal("original Go instruction inventory changed", len(pcs))
+		}
+		for index, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				encoded := code[pcs[index]:pcs[index+1]]
+				if len(encoded) < 3 || encoded[0] != 0xc4 && encoded[0] != 0xc5 {
+					t.Fatalf("original row did not select VEX: %x", encoded)
+				}
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86UnmaskedVEXByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 {
+					t.Fatal("complete broadcast family lacks its typed dependency", known, err)
+				}
+				input, output := effect.operands[0], effect.operands[1]
+				width := int64(row.bytes)
+				var required uint64
+				if row.source == "X0" {
+					width, required = 16, uint64(1)<<uint(row.bytes)-1
+				}
+				if input.index != 0 || !input.read || input.write || input.width != width || input.requiredBytes != required ||
+					output.index != 1 || output.read || !output.write || output.width != int64(amd64VectorByteWidth(Reg(row.destination))) ||
+					effect.vector.upperWrite != x86TypedVectorUpperZero || effect.vector.memoryAlignment != 1 ||
+					effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatalf("broadcast source extent/upper alias/FLAGS changed: %+v", effect)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalBroadcastSelectedBytes(t *testing.T) {
+	for _, row := range fixedLocalBroadcastCases(t) {
+		if row.source != "X0" {
+			continue
+		}
+		for _, alias := range []bool{false, true} {
+			destination := row.destination
+			if alias {
+				destination = destination[:1] + "0"
+			}
+			t.Run(row.name+"/"+destination, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.name+" X0,"+destination)
+				required := uint64(1)<<uint(row.bytes) - 1
+				for missing := -1; missing < row.bytes; missing++ {
+					input := required
+					if missing >= 0 {
+						input &^= uint64(1) << uint(missing)
+					}
+					state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": input, "Z2": 0, "Z7": 0xa55a}, flags: x86ByteFlagsAll}
+					before := cloneFixedLocalState(state)
+					err := fixedLocalVectorStep(&ins, &state, nil, 0)
+					if missing >= 0 {
+						if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(state.vectors, before.vectors) || state.flags != before.flags {
+							t.Fatal("missing scalar byte invented or partially published", missing, err, state)
+						}
+						continue
+					}
+					before.vectors[x86CallerVectorRoot(Reg(destination))] = ^uint64(0)
+					if err != nil || !reflect.DeepEqual(state.vectors, before.vectors) || state.flags != before.flags {
+						t.Fatal("broadcast lost a source alias, upper zero or FLAGS", err, state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func fixedLocalBroadcastBody(row fixedLocalBroadcastCase) string {
+	// Consume every byte of the Y alias, including VEX.128's zeroed upper
+	// half, through private memory and the real ABI0 result.
+	return row.instruction() + "\nVMOVDQU Y2,128(BP)\n" +
+		"MOVQ 128(BP),AX\nXORQ 136(BP),AX\nORQ 144(BP),AX\nADDQ 152(BP),AX\nMOVQ AX,128(BP)"
+}
+
+func TestGoAMD64FixedLocalBroadcastCompleteFunctions(t *testing.T) {
+	var original strings.Builder
+	for index, row := range fixedLocalBroadcastCases(t) {
+		original.WriteString(strings.Replace(fixedLocalVEXAssembly(fixedLocalBroadcastBody(row)), "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, row := range fixedLocalBroadcastCases(t) {
+		t.Run(row.instruction(), func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, fixedLocalBroadcastBody(row))
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("complete initialized broadcast frame/result rejected", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalBroadcastMemoryAndEncodingBoundaries(t *testing.T) {
+	for _, row := range fixedLocalBroadcastCases(t) {
+		if row.source == "X0" {
+			continue
+		}
+		for _, offset := range []int{0, 65, 192 - row.bytes, 193 - row.bytes, 256} {
+			t.Run(fmt.Sprintf("%s/%s/%d", row.name, row.destination, offset), func(t *testing.T) {
+				operation := fmt.Sprintf("%s %d(BP),%s", row.name, offset, row.destination)
+				fn, sig, source := fixedLocalVEXFixture(t, operation)
+				requireX86GoAssemblerResult(t, "amd64", source, true)
+				_, err := proveX86FixedLocal(fn, sig)
+				want := offset >= 64 && offset+row.bytes <= 192
+				if want && err != nil || !want && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("broadcast lost its exact initialized source extent", want, err)
+				}
+			})
+		}
+	}
+	for _, source := range []string{
+		"VPBROADCASTQ AX,Y2", "VPBROADCASTD X16,Y2", "VBROADCASTSS X0,Z2",
+		"VPBROADCASTW X0,K1,Y2", "VPBROADCASTB.Z X0,K1,Y2",
+		"VBROADCASTI32X2 X0,Y2", "VBROADCASTF32X4 64(BP),Y2", "VPBROADCASTMB2Q K1,Y2",
+		"VBROADCASTI128 (AX),Y2", "VBROADCASTF128 256(BP),Y2",
+	} {
+		t.Run(source, func(t *testing.T) {
+			fn, sig, original := fixedLocalVEXFixture(t, source)
+			requireX86GoAssemblerResult(t, "amd64", original, true)
+			if source == "VBROADCASTI128 (AX),Y2" {
+				fixedLocalRequireNumericControl(t, fn, sig, original, "func Value(p *uint64,a uint64) uint64",
+					source, 0, 16, false, "load volatile <16 x i8>")
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("broadcast invented an EVEX, mask, pointer or memory role", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalBroadcastObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	rows := fixedLocalBroadcastCases(t)
+	for index, row := range rows {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(fixedLocalBroadcastBody(row)), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(rows))
+}
diff --git a/amd64_fixed_local_byte_state_test.go b/amd64_fixed_local_byte_state_test.go
new file mode 100644
index 000000000..06d60ac87
--- /dev/null
+++ b/amd64_fixed_local_byte_state_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// Keep the oracle byte-addressed. The production representation may change,
+// but a partially overwritten byte and an adjacent byte remain independent.
+func fixedLocalByteStateFixture(size int) (x86FixedLocalState, []bool, []bool) {
+	state := fixedLocalExchangeState()
+	state.bytes = newFixedLocalByteSet(int64(size))
+	state.booleanBytes = newFixedLocalByteSet(int64(size))
+	known, booleans := make([]bool, size), make([]bool, size)
+	for index := range known {
+		known[index] = index%5 != 0
+		booleans[index] = known[index] && index%3 == 0
+		fixedLocalByteStateSet(&state, index, known[index], booleans[index])
+	}
+	return state, known, booleans
+}
+
+func fixedLocalByteStateSet(state *x86FixedLocalState, index int, known, boolean bool) {
+	state.bytes.set(int64(index), known)
+	state.booleanBytes.set(int64(index), boolean)
+}
+
+func checkFixedLocalByteState(t *testing.T, state x86FixedLocalState, known, booleans []bool) {
+	t.Helper()
+	missing := make([]int, len(known)+1)
+	for index := range known {
+		missing[index+1] = missing[index]
+		if !known[index] {
+			missing[index+1]++
+		}
+		if state.bytes.has(int64(index)) != known[index] || state.booleanBytes.has(int64(index)) != booleans[index] {
+			t.Fatalf("byte %d: numerical=%v boolean=%v, want %v/%v", index,
+				state.bytes.has(int64(index)), state.booleanBytes.has(int64(index)), known[index], booleans[index])
+		}
+	}
+	for _, offset := range []int{0, 1, 7, 31, 63, 64, 65, len(known)} {
+		for _, width := range []int{0, 1, 2, 8, 16, 63, 64, 65, len(known) - offset} {
+			if offset > len(known) || width < 0 || width > len(known)-offset {
+				continue
+			}
+			want := missing[offset+width] == missing[offset]
+			if got := state.bytes.all(int64(offset), int64(width)); got != want {
+				t.Fatalf("numerical read [%d,%d): got %v, want %v", offset, offset+width, got, want)
+			}
+		}
+	}
+	for index := len(known); index < len(state.bytes)*64; index++ {
+		if state.bytes.has(int64(index)) || state.booleanBytes.has(int64(index)) {
+			t.Fatalf("padding byte %d acquired facts outside the original frame", index)
+		}
+	}
+	for offset := 0; offset < len(known); offset++ {
+		width := len(known) - offset
+		if width > 8 {
+			width = 8
+		}
+		var expected uint8
+		for index := 0; index < width; index++ {
+			if booleans[offset+index] {
+				expected |= 1 << uint(index)
+			}
+		}
+		if got := fixedLocalMemoryBooleans(&state, int64(offset), int64(width)); got != expected {
+			t.Fatalf("boolean read [%d,%d): got %#x, want %#x", offset, offset+width, got, expected)
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalByteStatePartialWrites(t *testing.T) {
+	for _, size := range []int{1, 7, 8, 63, 64, 65, 127, 128, 129, 1408} {
+		t.Run(fmt.Sprint(size), func(t *testing.T) {
+			state, known, booleans := fixedLocalByteStateFixture(size)
+			for _, offset := range []int{0, 1, 7, 8, 31, 60, 63, 64, 65, 127, size - 1} {
+				for _, width := range []int{1, 2, 4, 8, 16, 32, 64} {
+					if offset < 0 || width > size-offset {
+						continue
+					}
+					for _, complete := range []bool{false, true} {
+						fixedLocalNumericalStore(&state, int64(offset), int64(width), complete)
+						for index := offset; index < offset+width; index++ {
+							known[index] = known[index] || complete
+							booleans[index] = false
+						}
+						checkFixedLocalByteState(t, state, known, booleans)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalByteStateScalarTransport(t *testing.T) {
+	const size = 129
+	state, known, booleans := fixedLocalByteStateFixture(size)
+	proof := &x86FixedLocalProof{frame: size}
+	for _, offset := range []int{0, 7, 60, 63, 64, 65, 120} {
+		for _, form := range []struct {
+			op    string
+			width int64
+		}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}} {
+			width := form.width
+			ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $1,%d(SP)", form.op, offset))
+			value := fixedLocalScalarValue{booleans: 0xa5}
+			if err := fixedLocalWriteValue(&ins, 1, 0, value, &state, FuncSig{}, proof, 0, width); err != nil {
+				t.Fatal(err)
+			}
+			for index := int64(0); index < width; index++ {
+				known[offset+int(index)] = true
+				booleans[offset+int(index)] = 0xa5&(1<<uint(index)) != 0
+			}
+			checkFixedLocalByteState(t, state, known, booleans)
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalByteStateMeetAndClone(t *testing.T) {
+	for _, size := range []int{0, 1, 63, 64, 65, 128, 129, 1408, 65536} {
+		t.Run(fmt.Sprint(size), func(t *testing.T) {
+			state, known, booleans := fixedLocalByteStateFixture(size)
+			other := cloneFixedLocalState(state)
+			expectedKnown := append([]bool(nil), known...)
+			expectedBooleans := append([]bool(nil), booleans...)
+			wantChanged := false
+			for index := range known {
+				lastKnown, lastBoolean := index%7 != 0, index%11 == 0
+				fixedLocalByteStateSet(&other, index, lastKnown, lastBoolean)
+				expectedKnown[index] = known[index] && lastKnown
+				expectedBooleans[index] = booleans[index] && lastBoolean
+				wantChanged = wantChanged || expectedKnown[index] != known[index] || expectedBooleans[index] != booleans[index]
+			}
+			checkFixedLocalByteState(t, state, known, booleans)
+			changed, err := mergeFixedLocalState(&state, other)
+			if err != nil || changed != wantChanged {
+				t.Fatalf("first meet: changed=%v want=%v error=%v", changed, wantChanged, err)
+			}
+			checkFixedLocalByteState(t, state, expectedKnown, expectedBooleans)
+			if changed, err := mergeFixedLocalState(&state, other); err != nil || changed {
+				t.Fatalf("stable meet changed state: %v, %v", changed, err)
+			}
+			for index := range known {
+				fixedLocalByteStateSet(&other, index, true, true)
+			}
+			checkFixedLocalByteState(t, state, expectedKnown, expectedBooleans)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalByteStateFrameTail(t *testing.T) {
+	for _, size := range []int{8, 24, 72} {
+		for _, start := range []int{size - 8, size - 7, size - 1} {
+			for _, write := range []bool{false, true} {
+				for _, offset := range []int{size - 1, size} {
+					name := fmt.Sprintf("frame%d/spill%d/write%v/byte%d", size, start, write, offset)
+					t.Run(name, func(t *testing.T) {
+						state, _, _ := fixedLocalByteStateFixture(size)
+						for index := 0; index < size; index++ {
+							fixedLocalByteStateSet(&state, index, write, false)
+						}
+						state.known[AX] = 255
+						// A malformed observed spill must not borrow the bitmap's
+						// padding as storage, even when the RMW byte is initialized.
+						state.opaqueCells[int64(start)] = fixedLocalOrigin(x86FixedLocalOrigin{})
+						row := fmt.Sprintf("SUBB %d(SP),AX", offset)
+						if write {
+							row = fmt.Sprintf("SUBB $1,%d(SP)", offset)
+						}
+						ins := x86ScalarLaneInstruction(t, row)
+						effect, found, err := fixedLocalGPByteEffect(ins)
+						if err != nil || !found {
+							t.Fatal("scalar grammar fixture is invalid", found, err)
+						}
+						proof := &x86FixedLocalProof{frame: int64(size)}
+						err = fixedLocalTypedByteStep(&ins, &state, FuncSig{}, proof, 0, effect)
+						want := start == size-8 && offset < size
+						if (err == nil) != want || !want && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("private tail acceptance=%v, want %v: %v", err == nil, want, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func BenchmarkFixedLocalFrameState(b *testing.B) {
+	for _, size := range []int{64, 1408, 65536} {
+		state, _, _ := fixedLocalByteStateFixture(size)
+		b.Run(fmt.Sprintf("clone/%d", size), func(b *testing.B) {
+			b.ReportAllocs()
+			for index := 0; index < b.N; index++ {
+				fixedLocalOriginBenchmarkState = cloneFixedLocalState(state)
+			}
+		})
+		b.Run(fmt.Sprintf("meet/%d", size), func(b *testing.B) {
+			other := cloneFixedLocalState(state)
+			b.ReportAllocs()
+			b.ResetTimer()
+			for index := 0; index < b.N; index++ {
+				if changed, err := mergeFixedLocalState(&other, state); err != nil || changed {
+					b.Fatal("identical byte states must be unchanged", changed, err)
+				}
+			}
+			fixedLocalOriginBenchmarkState = other
+		})
+	}
+}
diff --git a/amd64_fixed_local_bytes.go b/amd64_fixed_local_bytes.go
new file mode 100644
index 000000000..b78a7c829
--- /dev/null
+++ b/amd64_fixed_local_bytes.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+// These bits describe source-byte facts, not accessible storage. The existing
+// frame/operand checks still bound every read and write; padding bits stay zero.
+type x86FixedLocalByteSet []uint64
+
+func newFixedLocalByteSet(size int64) x86FixedLocalByteSet {
+	return make(x86FixedLocalByteSet, (size+63)/64)
+}
+
+func (bytes x86FixedLocalByteSet) has(index int64) bool {
+	return bytes[index>>6]&(uint64(1)<<uint(index&63)) != 0
+}
+
+func (bytes x86FixedLocalByteSet) set(index int64, value bool) {
+	mask := uint64(1) << uint(index&63)
+	if value {
+		bytes[index>>6] |= mask
+	} else {
+		bytes[index>>6] &^= mask
+	}
+}
+
+func fixedLocalByteWordMask(offset, width int64) (uint64, int64) {
+	count := int64(64) - (offset & 63)
+	if width < count {
+		count = width
+	}
+	return (^uint64(0) >> uint(64-count)) << uint(offset&63), count
+}
+
+func (bytes x86FixedLocalByteSet) setRange(offset, width int64, value bool) {
+	for width > 0 {
+		mask, count := fixedLocalByteWordMask(offset, width)
+		if value {
+			bytes[offset>>6] |= mask
+		} else {
+			bytes[offset>>6] &^= mask
+		}
+		offset, width = offset+count, width-count
+	}
+}
+
+func (bytes x86FixedLocalByteSet) all(offset, width int64) bool {
+	for width > 0 {
+		mask, count := fixedLocalByteWordMask(offset, width)
+		if bytes[offset>>6]&mask != mask {
+			return false
+		}
+		offset, width = offset+count, width-count
+	}
+	return true
+}
+
+func (bytes x86FixedLocalByteSet) intersect(other x86FixedLocalByteSet) bool {
+	changed := false
+	for index, previous := range bytes {
+		current := previous & other[index]
+		changed = changed || current != previous
+		bytes[index] = current
+	}
+	return changed
+}
diff --git a/amd64_fixed_local_candidate.go b/amd64_fixed_local_candidate.go
new file mode 100644
index 000000000..c400f45e3
--- /dev/null
+++ b/amd64_fixed_local_candidate.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+// GoAMD64FixedLocalFrameBindingNeeded is a source-role query, not a frame or
+// memory certificate. The complete actual-object factory and fixed-local
+// proof must independently succeed before any instruction gains backing.
+// One optional typed declaration set keeps complete ABI0 forwarding adapters
+// on their existing call route. Missing or ambiguous options retain the query's
+// original conservative behavior and grant no source or translation permission.
+func GoAMD64FixedLocalFrameBindingNeeded(file *File, goarch string, options ...Options) bool {
+	if file == nil || file.Arch != ArchAMD64 || goarch != "amd64" {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		if fn.FrameSize <= 0 {
+			continue
+		}
+		if len(options) == 1 && x86ABI0OutgoingForwarder(fn, options[0]) {
+			continue
+		}
+		bases := fixedLocalCandidateBases(fn)
+		for _, ins := range fn.Instrs {
+			// The final candidate role requires possible physical-frame memory. Avoid
+			// parsing allocating effects for register-only or unrelated inputs;
+			// this negative filter grants neither grammar nor storage permission.
+			localMemory := false
+			for _, operand := range ins.Args {
+				if operand.Kind == OpMem && bases.has(operand.Mem) {
+					localMemory = true
+					break
+				}
+			}
+			if !localMemory {
+				continue
+			}
+			memory, eligible := -1, false
+			physicalOnly := false
+			if _, _, known, err := x86SwapProperties(ins, goarch); known {
+				eligible, physicalOnly = err == nil, true
+				for index, operand := range ins.Args {
+					if operand.Kind == OpMem {
+						memory = index
+					}
+				}
+			} else if _, known, err := x86ScalarRegisterLoadProperties(ins.Op, ins, goarch); known {
+				memory, eligible, physicalOnly = 0, err == nil, true
+			} else if _, known, err := x86ScalarRegisterStoreProperties(ins.Op, ins, goarch); known {
+				memory, eligible, physicalOnly = 1, err == nil, true
+			} else if form, known, err := fixedLocalConversionProperties(ins); known {
+				memory, eligible = form.memory, err == nil && !form.mmx
+			} else if form, known, err := fixedLocalScalarLaneProperties(ins); known {
+				memory, eligible = form.memory, err == nil
+			} else if form, known, err := amd64PackedVectorMoveProperties(ins, goarch); known {
+				memory, eligible = form.memory, err == nil && !form.undefinedOpcode()
+				physicalOnly = !form.spec.aligned
+			} else if form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, goarch); known {
+				memory, eligible = form.move.memory, err == nil && !form.trap
+			} else if form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, goarch); known {
+				memory, eligible = form.memory, err == nil
+				physicalOnly = !form.aligned
+			} else if form, known, err := x86SHAProperties(ins.Op, ins, goarch); known {
+				memory, eligible = form.memory, err == nil
+			} else if form, known, err := x86AESProperties(ins.Op, ins, goarch); known {
+				memory, eligible = form.memory, err == nil && form.byteWidth == 16
+			} else if effect, known, err := fixedLocalVectorByteEffect(ins); known {
+				eligible = err == nil
+				for _, operand := range effect.operands {
+					if operand.operand.Kind == OpMem {
+						memory = operand.index
+					}
+				}
+			} else if form, known, err := x86FloatCompareProperties(ins, goarch); known {
+				memory, eligible = form.memory, err == nil && form.legacy && !form.scalar && form.byteWidth == 16
+			} else if form, known, err := x86ConditionalMoveProperties(ins.Op, ins, goarch); known {
+				memory, eligible = 0, err == nil && form.source.Kind == OpMem
+			} else if effect, known, err := fixedLocalGPByteEffect(ins); known {
+				eligible, physicalOnly = err == nil && !effect.dynamicMemory, true
+				for _, operand := range effect.operands {
+					if operand.operand.Kind == OpMem && (operand.read || operand.write) {
+						memory = operand.index
+					}
+				}
+			}
+			if eligible && memory >= 0 && memory < len(ins.Args) {
+				source := ins.Args[memory]
+				// Static SB and incoming native GP addresses keep their existing
+				// contracts. Virtual FP is not original local native storage.
+				if source.Kind == OpMem && bases.has(source.Mem) {
+					if physicalOnly {
+						// Scalar and unaligned transport can use logical AUTO. Only
+						// physical SP/BP needs this additional source observer; the
+						// existing parser retains the distinct named displacement.
+						address, err := fixedLocalMemoryAddress(ins, memory, fn.FrameSize)
+						if err != nil || address != source.Mem {
+							continue
+						}
+					}
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+type fixedLocalCandidateBaseSet uint16
+
+func fixedLocalCandidateRegister(reg Reg) (int, bool) {
+	if reg == SP {
+		return 4, true
+	}
+	if reg == BP {
+		return 5, true
+	}
+	index, _, valid := x86ResultGP(reg, 8, "amd64")
+	return index, valid
+}
+
+func (bases fixedLocalCandidateBaseSet) has(memory MemRef) bool {
+	for _, reg := range []Reg{memory.Base, memory.Index} {
+		if index, valid := fixedLocalCandidateRegister(reg); valid && bases&(1<<uint(index)) != 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// This small syntactic closure only selects the independent frame observer.
+// It is deliberately insensitive to CFG order and overwrites: reaching values,
+// bounds and every actual access must still pass the complete frame proof.
+func fixedLocalCandidateBases(fn Func) fixedLocalCandidateBaseSet {
+	var dependencies [16]fixedLocalCandidateBaseSet
+	for _, ins := range fn.Instrs {
+		if form, width, known, err := x86SwapProperties(ins, "amd64"); known {
+			if err == nil && width == 8 && form.other.Kind == OpReg {
+				first, firstValid := fixedLocalCandidateRegister(form.register.Reg)
+				last, lastValid := fixedLocalCandidateRegister(form.other.Reg)
+				if firstValid && lastValid {
+					dependencies[first] |= 1 << uint(last)
+					dependencies[last] |= 1 << uint(first)
+				}
+			}
+			continue
+		}
+		op := x86SourceMoveInstruction(ins, "amd64").Op
+		if op != "MOVQ" && op != "LEAQ" {
+			continue
+		}
+		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+			continue
+		}
+		destination, valid := fixedLocalCandidateRegister(ins.Args[1].Reg)
+		if !valid {
+			continue
+		}
+		var sources [2]Reg
+		if op == "MOVQ" && ins.Args[0].Kind == OpReg {
+			sources[0] = ins.Args[0].Reg
+		} else if ins.Op == "LEAQ" && ins.Args[0].Kind == OpMem {
+			width, err := x86LEAOperandWidth(ins, "amd64")
+			address, addressErr := fixedLocalMemoryAddress(ins, 0, fn.FrameSize)
+			if err != nil || width != 8 || addressErr != nil || address != ins.Args[0].Mem {
+				continue
+			}
+			sources = [2]Reg{address.Base, address.Index}
+		}
+		for _, reg := range sources {
+			if source, valid := fixedLocalCandidateRegister(reg); valid {
+				dependencies[destination] |= 1 << uint(source)
+			}
+		}
+	}
+	bases := fixedLocalCandidateBaseSet(1<<4 | 1<<5)
+	for {
+		previous := bases
+		for destination, sources := range dependencies {
+			if sources&bases != 0 {
+				bases |= 1 << uint(destination)
+			}
+		}
+		if bases == previous {
+			return bases
+		}
+	}
+}
diff --git a/amd64_fixed_local_candidate_test.go b/amd64_fixed_local_candidate_test.go
new file mode 100644
index 000000000..f5b2fb172
--- /dev/null
+++ b/amd64_fixed_local_candidate_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalScalarFrameCandidates(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, operation := range []string{
+			"MOV%s AX,8(SP)", "MOV%s 8(SP),AX", "MOV%s $1,8(SP)",
+			"ADD%s $1,8(SP)", "XOR%s AX,8(SP)", "NOT%s 8(SP)",
+			"ROL%s $1,8(SP)", "CMP%s 8(SP),AX",
+		} {
+			instruction := fmt.Sprintf(operation, width)
+			source := "TEXT ·Value(SB),4,$64-0\n" + instruction + "\nRET\n"
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+			count++
+			t.Run(instruction, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+					t.Fatal("scalar-only physical scratch never reaches the actual frame observer")
+				}
+				if GoAMD64FixedLocalFrameBindingNeeded(file, "386") {
+					t.Fatal("amd64 source query changed a different source architecture")
+				}
+			})
+		}
+	}
+	if count != 32 {
+		t.Fatal("incomplete scalar family/width fixture", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, instruction := range []string{
+		"MOVQ AX,tmp-8(SP)", "MOVQ tmp-8(SP),AX", "ADDQ $1,tmp-8(SP)",
+		"MOVQ AX,(SI)", "MOVQ (SI),AX", "ADDQ $1,(SI)",
+		"MOVQ AX,BX", "NOPL 8(SP)", "LEAQ 8(SP),AX", "MOVQ.Z AX,8(SP)",
+	} {
+		t.Run("not physical access/"+instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Fatal("candidate supplied a role to unrelated syntax")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameCandidateQueryCannotSupplyPermission(t *testing.T) {
+	for _, operation := range []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDD 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+	} {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			source, sig, pkg := x86PrivateAlignedFrameAuditFixture(t, operation)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") || GoAMD64FixedLocalFrameBindingNeeded(file, "386") {
+				t.Fatal("candidate query lost its exact native family/target role")
+			}
+			x86PrivateAlignedFrameAuditAPIs(t, source, sig, pkg, func(t *testing.T, err error) {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("query supplied a forged native permission: %v", err)
+				}
+			})
+		})
+	}
+	for _, source := range []string{
+		"TEXT ·Value(SB),4,$0-0\nPADDL 16(SP),X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL X1,X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nVPADDD X1,X2,X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL (AX),M0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL X1\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL constant<>(SB),X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL (AX),X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-0\nPADDL (AX)(CX*2),X0\nRET\n",
+		"TEXT ·Value(SB),4,$160-16\nPADDL input+0(FP),X0\nRET\n",
+	} {
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+			t.Fatalf("query widened unrelated source grammar: %s", source)
+		}
+	}
+}
diff --git a/amd64_fixed_local_clmul_native_linux_amd64_test.go b/amd64_fixed_local_clmul_native_linux_amd64_test.go
new file mode 100644
index 000000000..3411c1b61
--- /dev/null
+++ b/amd64_fixed_local_clmul_native_linux_amd64_test.go
@@ -0,0 +1,13 @@
+package plan9asm
+
+import "testing"
+
+// Original Go executes every legacy and VEX kernel before comparison with
+// the three LLVM APIs. Missing ISA or a failed preflight is a failure, not a
+// skipped execution receipt or an object-only substitute.
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalCLMUL(t *testing.T) {
+	execution := fixedLocalVEXNativeTools(t)
+	t.Logf("%s", execution.run(t, fixedLocalCLMULRuntimePreflight(t, execution)))
+	fixedLocalVectorRuntime(t, execution, true, fixedLocalCLMULRuntimeKernels(t))
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_fixed_local_clmul_test.go b/amd64_fixed_local_clmul_test.go
new file mode 100644
index 000000000..6ea694042
--- /dev/null
+++ b/amd64_fixed_local_clmul_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalCLMULCases() []string {
+	var operations []string
+	for _, selector := range []int{0, 1, 16, 17} {
+		for _, source := range []string{"X1", "X2", "64(BP)", "(SI)"} {
+			operations = append(operations, fmt.Sprintf("PCLMULQDQ $%d,%s,X2", selector, source))
+		}
+		for _, bank := range []string{"X", "Y"} {
+			for _, source := range []string{bank + "1", "64(BP)", "(SI)", "65(BP)", "1(SI)"} {
+				operations = append(operations, fmt.Sprintf("VPCLMULQDQ $%d,%s,%s2,%s3", selector, source, bank, bank))
+			}
+			for _, destination := range []string{bank + "1", bank + "2"} {
+				operations = append(operations, fmt.Sprintf("VPCLMULQDQ $%d,%s1,%s2,%s", selector, bank, bank, destination))
+			}
+		}
+	}
+	return operations
+}
+
+func TestGoAMD64FixedLocalCLMULOfficialVEXBytes(t *testing.T) {
+	// The existing complete CLMUL audit owns all six original rows. These
+	// two VEX rows supply source witnesses, not exact encoder-row selection.
+	witnesses := fixedLocalVEXFamilyWitnesses(t, `^VPCLMULQDQ$`, 2, 6)
+	fixedLocalCheckVEXEncodings(t, witnesses)
+	fixedLocalCheckVEXPhysicalBoundaries(t, witnesses)
+}
+
+func TestGoAMD64FixedLocalCLMULCompleteFamilies(t *testing.T) {
+	operations := fixedLocalCLMULCases()
+	if len(operations) != 72 {
+		t.Fatal("CLMUL selector/width/alias/memory inventory changed", len(operations))
+	}
+	var assembly strings.Builder
+	for index, operation := range operations {
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(operation), "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	for _, operation := range operations {
+		t.Run(operation, func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, operation)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("original Go accepts complete carryless-multiply source but private-frame effect is missing", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCLMULSelectedBytesAndAliases(t *testing.T) {
+	for _, shape := range []struct {
+		name, bank string
+		width      int
+	}{
+		{"PCLMULQDQ", "X", 16}, {"VPCLMULQDQ", "X", 16}, {"VPCLMULQDQ", "Y", 32},
+	} {
+		for _, destination := range []int{1, 2, 3} {
+			if shape.name == "PCLMULQDQ" && destination == 3 {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%s/destination%d", shape.name, shape.bank, destination), func(t *testing.T) {
+				for immediate := 0; immediate < 256; immediate++ {
+					second := 2
+					operation := fmt.Sprintf("VPCLMULQDQ $%d,%s1,%s2,%s%d", immediate, shape.bank, shape.bank, shape.bank, destination)
+					if shape.name == "PCLMULQDQ" {
+						second = destination
+						operation = fmt.Sprintf("PCLMULQDQ $%d,X1,X%d", immediate, destination)
+					}
+					ins := x86YMMReadSource(t, operation)
+					secondRoot := Reg(fmt.Sprintf("Z%d", second))
+					output := Reg(fmt.Sprintf("Z%d", destination))
+					// Independent byte positions: bit 4 selects the first source;
+					// bit 0 selects the second (old destination for legacy).
+					needed := map[Reg]uint64{}
+					for lane := 0; lane < shape.width; lane += 16 {
+						for byteIndex := 0; byteIndex < 8; byteIndex++ {
+							needed["Z1"] |= uint64(1) << uint(lane+(immediate>>4&1)*8+byteIndex)
+							needed[secondRoot] |= uint64(1) << uint(lane+(immediate&1)*8+byteIndex)
+						}
+					}
+					for missing := -1; missing < shape.width; missing++ {
+						for _, input := range []Reg{"Z1", secondRoot} {
+							state := x86FixedLocalState{
+								vectors: map[Reg]uint64{"Z1": needed["Z1"], "Z2": needed["Z2"], "Z3": 0, "Z7": 0x1234},
+								flags:   x86ByteFlagsAll,
+							}
+							state.vectors[output] |= uint64(1) << 60
+							if missing >= 0 {
+								state.vectors[input] &^= uint64(1) << uint(missing)
+							}
+							beforeOutput := state.vectors[output]
+							wantFailure := missing >= 0 && needed[input]&(uint64(1)<<uint(missing)) != 0
+							err := fixedLocalVectorStep(&ins, &state, nil, 0)
+							if wantFailure {
+								if !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatalf("%s missing %s byte %d acquired numerical result: %v", operation, input, missing, err)
+								}
+								if state.vectors[output] != beforeOutput || state.flags != x86ByteFlagsAll {
+									t.Fatal("rejected input changed numerical output or FLAGS", operation)
+								}
+								continue
+							}
+							if err != nil {
+								t.Fatal("unselected bytes became required inputs", operation, input, missing, err)
+							}
+							want := ^uint64(0)
+							if shape.name == "PCLMULQDQ" {
+								want = (uint64(1) << 60) | 0xffff
+							}
+							if state.vectors[output] != want || state.vectors["Z7"] != 0x1234 || state.flags != x86ByteFlagsAll {
+								t.Fatal("carryless multiply changed upper aliases, unrelated state or FLAGS", operation, state)
+							}
+							for register, mask := range needed {
+								if register != output && state.vectors[register] != mask {
+									t.Fatal("non-destination input was modified", operation, register)
+								}
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalRequiredVectorBytesBoundaries(t *testing.T) {
+	for _, row := range []struct {
+		name            string
+		kind            OperandKind
+		register        Reg
+		width           int64
+		required, known uint64
+		read, wantPass  bool
+	}{
+		{"default full", OpReg, "X1", 16, 0, 0xffff, true, true},
+		{"default missing", OpReg, "X1", 16, 0, 0xff, true, false},
+		{"selected complete", OpReg, "X1", 16, 0xff, 0xff, true, true},
+		{"selected missing", OpReg, "X1", 16, 0xff, 0xfe, true, false},
+		{"beyond width", OpReg, "X1", 16, 0x10000, ^uint64(0), true, false},
+		{"empty width", OpReg, "X1", 0, 1, ^uint64(0), true, false},
+		{"GP is not vector", OpReg, AX, 8, 1, ^uint64(0), true, false},
+		{"memory is full tuple", OpMem, "", 16, 1, ^uint64(0), true, false},
+		{"write is not read", OpReg, "X1", 16, 1, ^uint64(0), false, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			ins := x86YMMReadSource(t, "PSHUFD $0,X1,X2")
+			effect := x86TypedByteEffect{
+				vector: x86TypedVectorEffect{x86TypedVectorUpperPreserve, 16},
+				operands: []x86TypedByteOperand{{
+					operand: Operand{Kind: row.kind, Reg: row.register}, width: row.width,
+					read: row.read, write: !row.read, requiredBytes: row.required,
+				}},
+			}
+			state := x86FixedLocalState{vectors: map[Reg]uint64{"Z1": row.known}, known: map[Reg]uint8{AX: 255}}
+			err := fixedLocalTypedByteStep(&ins, &state, FuncSig{}, nil, 0, effect)
+			if (err == nil) != row.wantPass {
+				t.Fatal("required vector bytes changed their width/storage domain", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCLMULFullMemoryAndFormGuards(t *testing.T) {
+	for _, operation := range []string{
+		"PCLMULQDQ $0,65(BP),X2", "PCLMULQDQ $0,256(BP),X2",
+		"PCLMULQDQ $0,(AX),X2", "PCLMULQDQ $0,a+8(FP),X2", "PCLMULQDQ $0,X7,X2",
+		"VPCLMULQDQ $0,256(BP),Y2,Y3", "VPCLMULQDQ $0,(AX),Y2,Y3",
+		"VPCLMULQDQ $0,X16,X2,X3", "VPCLMULQDQ $0,Z1,Z2,Z3",
+		"VPCLMULQDQ $0,X1,X2,K1,X3", "VPCLMULQDQ.Z $0,X1,X2,X3",
+		"VPCLMULQDQ.BCST $0,(SI),X2,X3", "VPCLMULQDQ $-1,X1,X2,X3",
+		"VPCLMULQDQ $256,X1,X2,X3", "VPCLMULQDQ $0.5,X1,X2,X3",
+	} {
+		t.Run(operation, func(t *testing.T) {
+			fn, sig, source := fixedLocalVEXFixture(t, operation)
+			if operation == "PCLMULQDQ $0,(AX),X2" || operation == "VPCLMULQDQ $0,(AX),Y2,Y3" {
+				width := int64(16)
+				if operation == "VPCLMULQDQ $0,(AX),Y2,Y3" {
+					width = 32
+				}
+				fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64) uint64",
+					operation, 1, width, false, "pclmulqdq")
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown storage or unadmitted form acquired a private-frame effect", err)
+			}
+		})
+	}
+	for _, operation := range []string{"PCLMULQDQ $0,64(BP),X2", "VPCLMULQDQ $0,64(BP),X2,X3", "VPCLMULQDQ $0,64(BP),Y2,Y3"} {
+		t.Run(operation+"/unselected-memory-byte", func(t *testing.T) {
+			_, sig, source := fixedLocalVEXFixture(t, operation)
+			// CompleteFamilies owns the corresponding unchanged positive.
+			// Register inputs use a disjoint range; the removed qword is
+			// numerically unselected but still in the native memory tuple.
+			changed := strings.ReplaceAll(source, "VMOVDQU 64(BP)", "VMOVDQU 128(BP)")
+			if changed == source {
+				t.Fatal("fixture no longer moved the register inputs to separate storage")
+			}
+			source = strings.Replace(changed, "MOVQ AX,72(BP)\n", "", 1)
+			if source == changed {
+				t.Fatal("fixture no longer removed the unselected memory qword")
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("selected low qword replaced complete native memory tuple", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCLMULObjects(t *testing.T) {
+	operations := fixedLocalCLMULCases()
+	var assembly, declarations strings.Builder
+	for index, operation := range operations {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(operation), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(operations))
+}
diff --git a/amd64_fixed_local_compile_only_tools_test.go b/amd64_fixed_local_compile_only_tools_test.go
new file mode 100644
index 000000000..7d95945ed
--- /dev/null
+++ b/amd64_fixed_local_compile_only_tools_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/token"
+	"strconv"
+	"testing"
+)
+
+func TestFixedLocalWideCompileOnlyOwnersDoNotRequireRuntimeTransport(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_fixed_local_packed_runtime_test.go")
+	for _, name := range []string{
+		"TestGoAMD64FixedLocalPackedWideRuntimeOracleCompileOnly",
+		"TestGoAMD64FixedLocalPackedWideRuntimeOracleModuleCompileOnly",
+		"TestGoAMD64FixedLocalPackedWideRuntimeOracleGoModuleCompileOnly",
+	} {
+		t.Run(name, func(t *testing.T) {
+			function := functions[name]
+			if function == nil {
+				t.Fatal("missing complete 340-kernel object owner", name)
+			}
+			calls := fixedLocalLeaseCalls(function.Body)
+			if calls["fixedLocalPackedCompileOnlyTools"] != 1 || calls["x86FloatCompareExecutionTools"] != 0 {
+				t.Error("object-only source/LLVM/C compilation must not depend on a CPU or emulator execution route")
+			}
+		})
+	}
+	t.Run("whole-vector move", func(t *testing.T) {
+		move := fixedLocalLeaseFunctions(t, "amd64_packed_vector_move_aligned_oracle_unix_test.go")["TestX86PackedMoveAlignedOriginalGoOracleCompileOnly"]
+		if move == nil {
+			t.Fatal("missing original-Go aligned move object owner")
+		}
+		calls := fixedLocalLeaseCalls(move.Body)
+		if calls["fixedLocalPackedCompileOnlyTools"] != 1 || calls["x86FloatCompareExecutionTools"] != 0 {
+			t.Error("move object compilation must select LLVM22/SDK without execution capability")
+		}
+	})
+	// Keep the actual execution roles separate, including their real CPU/OS
+	// checks. Object compilation cannot certify the original native programs.
+	sse := functions["TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedSSE"]
+	if sse == nil || fixedLocalLeaseCalls(sse.Body)["x86FloatCompareRuntimeTools"] != 1 {
+		t.Error("actual SSE execution tools were weakened")
+	}
+	fixedLocalPackedRequireNativeBatchOwners(t)
+}
+
+func TestFixedLocalCompileOnlyToolsRetainExactLLVMAndSDKWithoutExecution(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_fixed_local_packed_runtime_test.go")
+	helper := functions["fixedLocalPackedCompileOnlyTools"]
+	if helper == nil {
+		t.Fatal("missing LLVM22 object-only tool selector independent of execution capability")
+	}
+	calls := fixedLocalLeaseCalls(helper.Body)
+	for _, name := range []string{"findLlcAndClang", "testTargetTriple", "runtimeOracleStageContext", "nativeoracle.DarwinClangFlags"} {
+		if calls[name] != 1 {
+			t.Error("object-only tool selection lost its exact LLVM22/target/bounded real SDK selection", name, calls[name])
+		}
+	}
+	for _, name := range []string{
+		"x86FloatCompareExecutionTools", "x86FloatAddSubRuntimeTools", "x86FloatCompareRuntimeTools",
+		"x86PackedDoubleDwordNativeTools", "rosettaAvailable", "exec.LookPath", "t.Skip", "t.Skipf", "execution.run",
+	} {
+		if calls[name] != 0 {
+			t.Error("compile-only tools gained a CPU, transport or skip dependency", name)
+		}
+	}
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		if call, ok := node.(*ast.CallExpr); ok && fixedLocalLeaseCallName(call) == "testTargetTriple" {
+			if len(call.Args) != 2 {
+				t.Error("object-only target lost its actual host OS and original AMD64 ABI")
+				return true
+			}
+			os, ok := call.Args[0].(*ast.SelectorExpr)
+			if !ok || !fixedLocalLeaseIdent(os.X, "runtime") || os.Sel.Name != "GOOS" {
+				t.Error("object-only target substituted its actual host OS")
+			}
+			arch, ok := call.Args[1].(*ast.BasicLit)
+			if !ok || arch.Kind != token.STRING {
+				t.Error("object-only target lost its explicit original AMD64 ABI")
+			} else if value, err := strconv.Unquote(arch.Value); err != nil || value != "amd64" {
+				t.Error("object-only target changed its original AMD64 ABI", value, err)
+			}
+		}
+		if literal, ok := node.(*ast.CompositeLit); ok && fixedLocalLeaseIdent(literal.Type, "x86FloatCompareExecution") {
+			for _, field := range literal.Elts {
+				if entry, ok := field.(*ast.KeyValueExpr); ok &&
+					(fixedLocalLeaseIdent(entry.Key, "prefix") || fixedLocalLeaseIdent(entry.Key, "preserveArgv0")) {
+					t.Error("object-only tool selection must not configure any executable transport")
+				}
+			}
+		}
+		return true
+	})
+}
+
+func fixedLocalLeaseIdent(expression ast.Expr, name string) bool {
+	identifier, ok := expression.(*ast.Ident)
+	return ok && identifier.Name == name
+}
diff --git a/amd64_fixed_local_conditional_values_test.go b/amd64_fixed_local_conditional_values_test.go
new file mode 100644
index 000000000..31693f820
--- /dev/null
+++ b/amd64_fixed_local_conditional_values_test.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalConditionalTypedValues(t *testing.T) {
+	for _, condition := range x86CMOVOracleConditions {
+		for _, width := range []struct {
+			name  string
+			bytes int64
+		}{{"W", 2}, {"L", 4}, {"Q", 8}} {
+			for _, source := range []string{"AX", "BX", "8(SP)"} {
+				text := "CMOV" + width.name + condition.name + " " + source + ",BX"
+				t.Run(text, func(t *testing.T) {
+					state := fixedLocalExchangeState()
+					state.known[AX], state.known[BX] = 255, 255
+					state.booleans[AX], state.booleans[BX] = 0x55, 0xaa
+					for i := int64(0); i < 8; i++ {
+						state.bytes.set(8+i, true)
+						state.booleanBytes.set(8+i, 0x55&(1<<uint(i)) != 0)
+					}
+					ins := x86ScalarLaneInstruction(t, text)
+					if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+						t.Fatal("complete numerical alternatives rejected", err)
+					}
+					mask := uint8((1 << uint(width.bytes)) - 1)
+					want := uint8(0xaa &^ mask)
+					if source == "BX" {
+						want |= 0xaa & mask
+					}
+					if width.bytes == 4 {
+						want |= 240
+					}
+					if state.booleans[BX] != want || state.known[BX] != 255 || state.flags != x86ByteFlagsAll {
+						t.Fatal("conditional selection lost byte intersection, upper writeback or FLAGS", state)
+					}
+					if _, constant := state.constants[BX]; constant {
+						t.Fatal("a memory/partial numerical value acquired an invented constant")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalConditionalPointerIdentity(t *testing.T) {
+	for _, condition := range x86CMOVOracleConditions {
+		for _, row := range []struct {
+			name   string
+			origin x86FixedLocalOrigin
+		}{
+			{"private", x86FixedLocalOrigin{}},
+			{"input", x86FixedLocalOrigin{parameter: 8}},
+			{"literal", x86FixedLocalOrigin{literal: x86StaticSBAddress{"table<>", 16}}},
+			{"global", x86FixedLocalOrigin{global: "example.global"}},
+		} {
+			for _, source := range []string{"AX", "BX", "8(SP)"} {
+				t.Run(condition.name+"/"+row.name+"/"+source, func(t *testing.T) {
+					state := fixedLocalExchangeState()
+					if row.name == "private" {
+						state.pointers[AX], state.pointers[BX], state.addresses[8] = 24, 24, 24
+					} else {
+						origin := fixedLocalOrigin(row.origin)
+						state.opaque[AX], state.opaque[BX], state.opaqueCells[8] = origin, origin, origin
+					}
+					before := cloneFixedLocalState(state)
+					ins := x86ScalarLaneInstruction(t, "CMOVQ"+condition.name+" "+source+",BX")
+					if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+						t.Fatal("same complete pointer identity was treated as numerical bytes", err)
+					}
+					if state.known[BX] != 0 || state.flags != before.flags ||
+						!reflect.DeepEqual(state.pointers, before.pointers) || !reflect.DeepEqual(state.opaque, before.opaque) {
+						t.Fatal("conditional pointer acquired NUM, lost identity or changed FLAGS", state, before)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalConditionalRangeAndAuthority(t *testing.T) {
+	t.Run("different inputs", func(t *testing.T) {
+		state := fixedLocalExchangeState()
+		state.opaque[SI] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+		state.opaque[DI] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 8})
+		ins := x86ScalarLaneInstruction(t, "CMOVQEQ SI,DI")
+		proof := &x86FixedLocalProof{frame: 64}
+		if err := fixedLocalStep(&ins, &state, FuncSig{}, proof, 0); err != nil {
+			t.Fatal("two bounded native alternatives rejected", err)
+		}
+		if !state.opaque[DI].valid() || state.opaque[DI].readonly() || fixedLocalNumericRead(Operand{Kind: OpReg, Reg: DI}, 8, &state) {
+			t.Fatal("conditional input address was lost or acquired an unrelated role")
+		}
+		read := x86ScalarLaneInstruction(t, "MOVQ (DI),AX")
+		if err := fixedLocalStep(&read, &state, FuncSig{}, proof, 0); err != nil {
+			t.Fatal("native alternatives lost their existing faulting read", err)
+		}
+	})
+	for _, bounds := range []struct {
+		name              string
+		left, right, want x86UnsignedRange
+		both              bool
+	}{
+		{"same constant", x86UnsignedRange{8, 8}, x86UnsignedRange{8, 8}, x86UnsignedRange{8, 8}, true},
+		{"same", x86UnsignedRange{8, 16}, x86UnsignedRange{8, 16}, x86UnsignedRange{8, 16}, true},
+		{"overlap", x86UnsignedRange{8, 16}, x86UnsignedRange{12, 24}, x86UnsignedRange{8, 24}, true},
+		{"reverse overlap", x86UnsignedRange{12, 24}, x86UnsignedRange{8, 16}, x86UnsignedRange{8, 24}, true},
+		{"disjoint", x86UnsignedRange{8, 8}, x86UnsignedRange{24, 24}, x86UnsignedRange{8, 24}, true},
+		{"reverse disjoint", x86UnsignedRange{24, 24}, x86UnsignedRange{8, 8}, x86UnsignedRange{8, 24}, true},
+		{"one unbounded", x86UnsignedRange{8, 16}, x86UnsignedRange{}, x86UnsignedRange{}, false},
+	} {
+		t.Run(bounds.name, func(t *testing.T) {
+			state := fixedLocalExchangeState()
+			state.known[AX], state.known[BX] = 255, 255
+			state.setRange(AX, bounds.left)
+			if bounds.both {
+				state.setRange(BX, bounds.right)
+			}
+			if bounds.left.minimum == bounds.left.maximum {
+				state.constants[AX] = int64(bounds.left.minimum)
+			}
+			if bounds.both && bounds.right.minimum == bounds.right.maximum {
+				state.constants[BX] = int64(bounds.right.minimum)
+			}
+			state.comparison = x86FixedLocalComparison{register: BX, constant: 31}
+			ins := x86ScalarLaneInstruction(t, "CMOVQEQ AX,BX")
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+				t.Fatal(err)
+			}
+			value, bounded := state.ranges[BX]
+			if bounded != bounds.both || bounded && value != bounds.want || state.comparison.register != "" {
+				t.Fatal("selection intersected ranges or retained its old comparison value", value, bounded, state.comparison)
+			}
+			constant, known := state.constants[BX]
+			if known != (bounds.name == "same constant") || known && constant != 8 {
+				t.Fatal("equal constants were lost or unequal alternatives invented a constant", constant, known)
+			}
+		})
+	}
+	for _, row := range []struct{ name, body string }{
+		{"different private offsets", "LEAQ 8(SP),CX\nLEAQ 24(SP),DX\nCMOVQEQ CX,DX"},
+		{"input and NUM", "CMOVQEQ SI,AX"},
+		{"NUM and input", "CMOVQEQ AX,SI"},
+		{"private and input", "LEAQ 8(SP),CX\nCMOVQEQ CX,SI"},
+		{"partial input", "MOVQ SI,CX\nCMOVLEQ SI,CX"},
+		{"logical pointer slot", "MOVQ SI,CX\nCMOVQEQ p+0(FP),CX"},
+		{"uninitialized potential memory", "CMOVQEQ 8(SP),AX"},
+		{"memory extent", "CMOVQEQ 60(SP),AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalInputFixture(t, "CMPQ AX,AX\n"+row.body)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("conditional selection invented a pointer or access authority", err)
+			}
+		})
+	}
+	for _, operands := range []string{"AX,BX", "BX,AX"} {
+		t.Run("literal-input/"+operands, func(t *testing.T) {
+			state := fixedLocalExchangeState()
+			state.opaque[AX] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+			state.opaque[BX] = fixedLocalOrigin(x86FixedLocalOrigin{literal: x86StaticSBAddress{"table<>", 16}})
+			before := cloneFixedLocalState(state)
+			ins := x86ScalarLaneInstruction(t, "CMOVQEQ "+operands)
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); !errors.Is(err, ErrProbeNeedsContext) ||
+				!reflect.DeepEqual(state, before) {
+				t.Fatal("readonly/native selection widened authority or changed rejected state", err)
+			}
+		})
+		t.Run("bound-literal-input/"+operands, func(t *testing.T) {
+			state := fixedLocalExchangeState()
+			state.opaque[AX] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+			state.opaque[BX] = fixedLocalOrigin(x86FixedLocalOrigin{literal: x86StaticSBAddress{"table<>", 16}})
+			proof := &x86FixedLocalProof{frame: 64, binding: &x86FixedLocalBinding{
+				literalData: map[string]x86FixedLocalData{"table<>": {size: 32, alignment: 16}},
+			}}
+			ins := x86ScalarLaneInstruction(t, "CMOVQEQ "+operands)
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, proof, 0); err != nil {
+				t.Fatal("bounded readonly/native alternatives rejected", err)
+			}
+			destination := ins.Args[1].Reg
+			read := x86ScalarLaneInstruction(t, fmt.Sprintf("MOVQ (%s),CX", destination))
+			if err := fixedLocalStep(&read, &state, FuncSig{}, proof, 0); err != nil {
+				t.Fatal("complete readonly/native read rejected", err)
+			}
+			write := x86ScalarLaneInstruction(t, fmt.Sprintf("MOVQ $1,(%s)", destination))
+			if err := fixedLocalStep(&write, &state, FuncSig{}, proof, 0); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("readonly alternative acquired write permission", err)
+			}
+		})
+	}
+}
+
+func fixedLocalConditionalBodies() []string {
+	var bodies []string
+	for _, condition := range x86CMOVOracleConditions {
+		for _, body := range []string{
+			"MOVQ $8,CX\nMOVQ $8,DX\nCMPQ AX,AX\nCMOVQ%s CX,DX\nMOVQ AX,(SP)(DX*1)\nMOVQ 8(SP),AX",
+			"LEAQ 0(SP),CX\nMOVQ CX,DX\nCMPQ AX,AX\nCMOVQ%s CX,DX\nMOVQ (DX),AX",
+			"MOVQ SI,CX\nCMPQ AX,AX\nCMOVQ%s SI,CX\nMOVQ (CX),AX",
+		} {
+			bodies = append(bodies, fmt.Sprintf(body, condition.name))
+		}
+	}
+	return bodies
+}
+
+func TestGoAMD64FixedLocalConditionalCompleteSources(t *testing.T) {
+	var source strings.Builder
+	bodies := fixedLocalConditionalBodies()
+	for index, body := range bodies {
+		fn, sig, assembly := fixedLocalInputFixture(t, body)
+		fmt.Fprint(&source, strings.Replace(assembly, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(fmt.Sprint(index+1), func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("whole conditional value transport source rejected", err)
+			}
+		})
+	}
+	if len(bodies) != 48 {
+		t.Fatal("complete condition/value inventory changed", len(bodies))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+}
+
+func TestGoAMD64FixedLocalConditionalObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	bodies := fixedLocalConditionalBodies()
+	for index, body := range bodies {
+		_, _, source := fixedLocalInputFixture(t, body)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p,q *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(bodies))
+}
diff --git a/amd64_fixed_local_constant_arithmetic_runtime_go127_test.go b/amd64_fixed_local_constant_arithmetic_runtime_go127_test.go
new file mode 100644
index 000000000..60e1edf26
--- /dev/null
+++ b/amd64_fixed_local_constant_arithmetic_runtime_go127_test.go
@@ -0,0 +1,40 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalConstantArithmeticProgram(t *testing.T) (string, string, []string) {
+	t.Helper()
+	cases := fixedLocalConstantArithmeticCases()
+	if len(cases) != 20 {
+		t.Fatal("constant arithmetic runtime inventory changed", len(cases))
+	}
+	var assembly, declarations strings.Builder
+	var expected []string
+	for _, input := range []int{0, -1} {
+		for _, row := range cases {
+			name := fmt.Sprintf("Value%d", len(expected))
+			// Exercise both successors of the same-value join independently.
+			body := fmt.Sprintf("MOVQ $77,24(SP)\nMOVQ $%d,AX\n%s\nMOVQ (SP)(SI*8),AX", input, row.body)
+			assembly.WriteString(fixedLocalConstantIndexFunction(name, body))
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			expected = append(expected, "000000000000004d")
+		}
+	}
+	return assembly.String(), declarations.String(), expected
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConstantArithmetic(t *testing.T) {
+	assembly, declarations, expected := fixedLocalConstantArithmeticProgram(t)
+	fixedLocalConstantResultsRuntime(t, assembly, declarations, expected)
+}
+
+func TestGoAMD64FixedLocalConstantArithmeticObjects(t *testing.T) {
+	assembly, declarations, expected := fixedLocalConstantArithmeticProgram(t)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(expected))
+}
diff --git a/amd64_fixed_local_constant_arithmetic_test.go b/amd64_fixed_local_constant_arithmetic_test.go
new file mode 100644
index 000000000..40933a8f4
--- /dev/null
+++ b/amd64_fixed_local_constant_arithmetic_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalConstantArithmeticCases() []struct{ name, body string } {
+	return []struct{ name, body string }{
+		{"zero xor", "XORQ SI,SI\nADDQ $3,SI"},
+		{"add immediate", "MOVQ $1,SI\nADDQ $2,SI"},
+		{"subtract immediate", "MOVQ $5,SI\nSUBQ $2,SI"},
+		{"and immediate", "MOVQ $7,SI\nANDQ $3,SI"},
+		{"or immediate", "MOVQ $2,SI\nORQ $1,SI"},
+		{"xor immediate", "MOVQ $4,SI\nXORQ $7,SI"},
+		{"add register", "MOVQ $1,SI\nMOVQ $2,DI\nADDQ DI,SI"},
+		{"subtract register", "MOVQ $5,SI\nMOVQ $2,DI\nSUBQ DI,SI"},
+		{"and register", "MOVQ $7,SI\nMOVQ $3,DI\nANDQ DI,SI"},
+		{"or register", "MOVQ $2,SI\nMOVQ $1,DI\nORQ DI,SI"},
+		{"xor register", "MOVQ $4,SI\nMOVQ $7,DI\nXORQ DI,SI"},
+		{"increment", "MOVQ $2,SI\nINCQ SI"},
+		{"decrement", "MOVQ $4,SI\nDECQ SI"},
+		{"negate", "MOVQ $-3,SI\nNEGQ SI"},
+		{"complement", "MOVQ $-4,SI\nNOTQ SI"},
+		{"sign extended immediate", "MOVQ $4,SI\nADDQ $0xffffffff,SI"},
+		{"negative operand", "MOVQ $-1,SI\nADDQ $4,SI"},
+		{"modular arithmetic", "MOVQ $0x7fffffffffffffff,SI\nADDQ $1,SI\nSUBQ $1,SI\nANDQ $3,SI"},
+		{"value copied before overwrite", "MOVQ $3,DI\nMOVQ DI,SI\nMOVQ $5,DI\nADDQ $0,SI"},
+		{"same value at join", "MOVQ $3,SI\nCMPQ AX,$0\nJEQ joined\nADDQ $0,SI\njoined:"},
+	}
+}
+
+func TestGoAMD64FixedLocalConstantArithmeticIndex(t *testing.T) {
+	var original strings.Builder
+	cases := fixedLocalConstantArithmeticCases()
+	if len(cases) != 20 {
+		t.Fatal("constant arithmetic operand and boundary inventory changed", len(cases))
+	}
+	for index, row := range cases {
+		body := "MOVQ $77,24(SP)\n" + row.body + "\nMOVQ (SP)(SI*8),AX"
+		fn, sig, source := fixedLocalGPFixture(t, body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			proved, err := proveX86FixedLocal(fn, sig)
+			if err != nil {
+				t.Fatal("exact numerical index from typed arithmetic was lost", err)
+			}
+			found := false
+			for _, instruction := range proved.Instrs {
+				if instruction.Op != "MOVQ" || instruction.Args[0].Kind != OpMem || instruction.Args[0].Mem.Index != SI {
+					continue
+				}
+				access, present := instruction.x86FixedLocalMemory[0]
+				if !present || access.nativeInput || access.write || access.width != 8 ||
+					access.offset != [8]int64{24, 24, 24, 24, 24, 24, 24, 24} {
+					t.Fatalf("constant arithmetic acquired different bytes: %+v", access)
+				}
+				found = true
+			}
+			if !found {
+				t.Fatal("original indexed instruction disappeared")
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalConstantArithmeticKeepsUnknownRoles(t *testing.T) {
+	var original strings.Builder
+	for index, row := range []struct{ name, body string }{
+		{"unknown initial value", "ADDQ $3,SI"},
+		{"unknown source", "MOVQ $3,SI\nADDQ CX,SI"},
+		{"partial source", "MOVQ $3,SI\nMOVW $0,CX\nADDQ CX,SI"},
+		{"partial overwrite", "MOVQ $3,SI\nADDB $0,SI"},
+		{"pointer source", "MOVQ $3,SI\nMOVQ SP,DI\nADDQ DI,SI"},
+		{"numeric is not private", "MOVQ $0,DI\nADDQ $0,DI\nMOVQ (DI),SI"},
+		{"carry value unavailable", "MOVQ $3,SI\nSTC\nADCQ $0,SI"},
+		{"borrow value unavailable", "MOVQ $3,SI\nSTC\nSBBQ $0,SI"},
+		{"different values at join", "MOVQ $3,SI\nCMPQ AX,$0\nJEQ joined\nADDQ $1,SI\njoined:"},
+		{"zero xor word is partial", "XORW SI,SI\nADDQ $3,SI"},
+		{"overflow cannot grant extent", "MOVQ $0x7fffffffffffffff,SI\nADDQ $1,SI"},
+		{"arithmetic cannot grant extent", "MOVQ $7,SI\nADDQ $1,SI"},
+	} {
+		body := "MOVQ $77,24(SP)\nMOVQ $77,32(SP)\n" + row.body + "\nMOVQ (SP)(SI*8),AX"
+		fn, sig, source := fixedLocalGPFixture(t, body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err == nil {
+				t.Fatal("unknown numerical value or memory origin became an exact index")
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_conversion.go b/amd64_fixed_local_conversion.go
new file mode 100644
index 000000000..8e2293eea
--- /dev/null
+++ b/amd64_fixed_local_conversion.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+// This normalizes the existing complete conversion grammars for the private
+// frame observer. It grants neither caller storage nor a physical MMX role.
+type x86FixedLocalConversion struct {
+	inputBytes, outputBytes, activeBytes int
+	memoryBytes, memory, destination     int
+	mask                                 int
+	legacy, zeroing, mmx                 bool
+}
+
+func fixedLocalConversionProperties(ins Instr) (x86FixedLocalConversion, bool, error) {
+	if form, known, err := x86SignedPackedFloatProperties(ins, "amd64"); known {
+		return x86FixedLocalConversion{
+			inputBytes: form.inputBytes, outputBytes: form.byteWidth,
+			activeBytes: form.byteWidth, memoryBytes: form.memoryBytes,
+			memory: form.memory, destination: form.destination, mask: form.mask,
+			legacy: form.spec.legacy, zeroing: form.zeroing, mmx: form.mmx,
+		}, true, err
+	}
+	form, known, err := x86PackedConversionProperties(ins, "amd64")
+	return x86FixedLocalConversion{
+		inputBytes: form.inputBytes, outputBytes: form.shape.destinationBytes,
+		activeBytes: form.shape.lanes * form.spec.destinationBits / 8,
+		memoryBytes: form.memoryBytes, memory: form.memory,
+		destination: form.destination, mask: form.mask,
+		legacy: form.spec.legacy, zeroing: form.properties.zeroing, mmx: form.mmx,
+	}, known, err
+}
+
+func fixedLocalConversionStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, known, err := fixedLocalConversionProperties(*ins)
+	if !known {
+		return false, nil
+	}
+	if err != nil || form.mmx {
+		return true, goAMD64FrameContext("fixed local conversion lacks an ordinary physical vector shape")
+	}
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return true, goAMD64FrameContext("fixed local conversion has an undefined mask")
+	}
+	if form.memory >= 0 {
+		// Legacy m128 retains its alignment requirement. CVTDQ2PD m64
+		// and VEX/EVEX have no corresponding 16-byte #GP requirement.
+		alignment := int64(1)
+		if form.legacy && form.memoryBytes == 16 {
+			alignment = 16
+		}
+		if _, _, err := fixedLocalReadMemory(ins, form.memory, state, proof, residue,
+			int64(form.memoryBytes), alignment); err != nil {
+			return true, err
+		}
+	} else {
+		input := state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]
+		required := x86CallerVectorByteMask(int64(form.inputBytes))
+		if input&required != required {
+			return true, goAMD64FrameContext("fixed local conversion reads undefined numerical bytes")
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	active := x86CallerVectorByteMask(int64(form.activeBytes))
+	if form.mask >= 0 && !form.zeroing && state.vectors[destination]&active != active {
+		return true, goAMD64FrameContext("fixed local conversion merges undefined destination bytes")
+	}
+	// Narrowing explicitly clears its carrier padding. Legacy preserves
+	// wider aliases; VEX/EVEX clears them. Integer FLAGS remain unchanged.
+	if form.legacy {
+		state.vectors[destination] |= x86CallerVectorByteMask(int64(form.outputBytes))
+	} else {
+		state.vectors[destination] = ^uint64(0)
+	}
+	return true, nil
+}
diff --git a/amd64_fixed_local_conversion_runtime_linux_amd64_test.go b/amd64_fixed_local_conversion_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..7ccf8f07e
--- /dev/null
+++ b/amd64_fixed_local_conversion_runtime_linux_amd64_test.go
@@ -0,0 +1,33 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch00(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch01(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch02(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch03(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch04(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 4)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch05(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 5)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch06(t *testing.T) {
+	fixedLocalConversionRuntimeBatch(t, x86PackedDoubleDwordNativeTools(t), true, 6)
+}
diff --git a/amd64_fixed_local_conversion_runtime_unix_test.go b/amd64_fixed_local_conversion_runtime_unix_test.go
new file mode 100644
index 000000000..a378f2171
--- /dev/null
+++ b/amd64_fixed_local_conversion_runtime_unix_test.go
@@ -0,0 +1,307 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type fixedLocalConversionRuntimeCase struct {
+	name, destination string
+	width, offset     int
+	dead              bool
+}
+
+func fixedLocalConversionRuntimeCases(all bool) []fixedLocalConversionRuntimeCase {
+	rows := x86PackedNativeAddressRows()
+	rows = append(rows,
+		struct{ name, destination string }{"CVTPL2PS", "X1"},
+		struct{ name, destination string }{"CVTPL2PD", "X1"},
+		struct{ name, destination string }{"VCVTDQ2PS", "Y1"},
+		struct{ name, destination string }{"VCVTDQ2PD", "Y1"})
+	var cases []fixedLocalConversionRuntimeCase
+	for _, row := range rows {
+		if !all && strings.HasPrefix(row.name, "V") {
+			continue
+		}
+		width := 16
+		if strings.HasPrefix(row.destination, "Y") {
+			width = 32
+		}
+		for _, dead := range []bool{false, true} {
+			for _, offset := range []int{120, 128, 128 + width - 8, 128 + width} {
+				cases = append(cases, fixedLocalConversionRuntimeCase{
+					name: row.name, destination: row.destination,
+					width: width, offset: offset, dead: dead,
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func fixedLocalConversionRuntimeProgram(cases []fixedLocalConversionRuntimeCase, triple string) (string, string, string, string) {
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, row := range cases {
+		name := fmt.Sprintf("Value%d", index)
+		operation := row.name + " 64(BP)," + row.destination
+		if !row.dead {
+			move := "VMOVDQU"
+			if !strings.HasPrefix(row.name, "V") {
+				move = "MOVOU"
+			}
+			operation += "\n" + move + " " + row.destination + ",128(BP)"
+		}
+		body := fixedLocalPackedAssembly(operation)
+		body = strings.Replace(body, "$256-16", "$512-16", 1)
+		body = strings.Replace(body, "MOVQ 128(BP),AX", fmt.Sprintf("MOVQ %d(BP),AX", row.offset), 1)
+		assembly.WriteString(strings.Replace(body, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		canary := row.dead || row.offset < 128 || row.offset >= 128+row.width
+		fmt.Fprintf(&goRows, "{%s, %v},\n", name, canary)
+		canaryValue := 0
+		if canary {
+			canaryValue = 1
+		}
+		fmt.Fprintf(&cRows, "{value%d, %d},\n", index, canaryValue)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t) __asm__(\"%sexample.invalid/framefixture.%s\");\n", index, prefix, name)
+	}
+	// The caller controls and snapshots MXCSR outside the observed frame.
+	// These helpers belong only to the independently compiled Go executable.
+	original := `package main
+import "fmt"
+func readCSR() uint32
+func writeCSR(csr uint32)
+` + declarations.String() + `
+func main() {
+    rows := []struct { call func(uint64) uint64; canary bool }{
+` + goRows.String() + `
+    }
+    values := []uint64{0,1,^uint64(0),0x8000000080000000,0x3fc000003fc00000,0x3ff8000000000000,0x7fc123457fc12345,0x7ff8123456789abc}
+    for n,row := range rows {
+        for v,value := range values {
+            for mode:=0; mode<32; mode++ {
+                csr := uint32(0x1f80) | uint32(mode&3)<<13 | uint32((mode>>2)&1)<<6 | uint32((mode>>3)&1)<<15
+                if mode&16 != 0 { csr |= 63 }
+                writeCSR(csr)
+                got := row.call(value)
+                status := readCSR()
+                writeCSR(0x1f80)
+                if row.canary && got != value { panic("original private-frame canary changed") }
+                fmt.Printf("%d %d %d %016x %08x\n", n,v,mode,got,status)
+            }
+        }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <xmmintrin.h>
+` + cDeclarations.String() + `
+int main(void) {
+    const struct { uint64_t (*call)(uint64_t); int canary; } rows[] = {
+` + cRows.String() + `
+    };
+    const uint64_t values[] = {0,1,UINT64_MAX,UINT64_C(0x8000000080000000),UINT64_C(0x3fc000003fc00000),UINT64_C(0x3ff8000000000000),UINT64_C(0x7fc123457fc12345),UINT64_C(0x7ff8123456789abc)};
+    for (unsigned n=0; n<sizeof(rows)/sizeof(rows[0]); n++) {
+        for (unsigned v=0; v<8; v++) {
+            for (unsigned mode=0; mode<32; mode++) {
+                unsigned csr = 0x1f80 | ((mode&3)<<13) | (((mode>>2)&1)<<6) | (((mode>>3)&1)<<15);
+                if (mode&16) csr |= 63;
+                _mm_setcsr(csr);
+                uint64_t got = rows[n].call(values[v]);
+                unsigned status = _mm_getcsr();
+                _mm_setcsr(0x1f80);
+                if (rows[n].canary && got != values[v]) return 2;
+                printf("%u %u %u %016llx %08x\n",n,v,mode,(unsigned long long)got,status);
+            }
+        }
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func fixedLocalConversionRuntime(t *testing.T, execution x86FloatCompareExecution, all bool) {
+	t.Helper()
+	cases := fixedLocalConversionRuntimeCases(all)
+	for batch := 0; batch*48 < len(cases); batch++ {
+		fixedLocalConversionRuntimeBatch(t, execution, all, batch)
+	}
+}
+
+func fixedLocalConversionRuntimeBatchRange(total, batch int) (start, end int, ok bool) {
+	if total <= 0 || batch < 0 || batch > (total-1)/48 {
+		return 0, 0, false
+	}
+	start, end = batch*48, total
+	if total-start > 48 {
+		end = start + 48
+	}
+	return start, end, true
+}
+
+func fixedLocalConversionRuntimeBatch(t *testing.T, execution x86FloatCompareExecution, all bool, batch int) {
+	t.Helper()
+	cases := fixedLocalConversionRuntimeCases(all)
+	start, end, ok := fixedLocalConversionRuntimeBatchRange(len(cases), batch)
+	if !ok {
+		t.Fatal("invalid complete conversion runtime batch", batch, len(cases))
+	}
+	// Reuse only this batch's disposable compiler artifacts. Each API still
+	// captures, binds, consumes and closes its own complete source observation.
+	t.Setenv("GOCACHE", t.TempDir())
+	t.Run(fmt.Sprintf("batch%d", batch), func(t *testing.T) {
+		assembly, declarations, original, driver := fixedLocalConversionRuntimeProgram(cases[start:end], execution.triple)
+		helpers := "TEXT ·readCSR(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\nTEXT ·writeCSR(SB),4,$0-4\nLDMXCSR csr+0(FP)\nRET\n"
+		want := string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly+helpers, original))
+		if strings.Count(want, "\n") != (end-start)*8*32 {
+			t.Fatal("original Go numerical/status denominator changed")
+		}
+		pkg, request, _, options := x86CMOVFixedLocalFixture(t,
+			assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+		fixedLocalConversionPrepareToolCache(t, request)
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimize := range []bool{false, true} {
+				input, level := ir, "-O0"
+				if optimize {
+					input, level = x86MulDivRoundOptimize(t, ir), "-O2"
+				}
+				got := string(execution.compileAndRunLLVM(t, "private-conversion", input, driver, level))
+				if got != want {
+					t.Fatal("original Go and LLVM private-frame value/MXCSR/canary results differ")
+				}
+			}
+		})
+	})
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionSSE(t *testing.T) {
+	fixedLocalConversionRuntime(t, x86FloatCompareRuntimeTools(t, x86FloatCompareSSE), false)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("Rosetta SSE diagnostic, not native AVX512 execution")
+	}
+}
+
+func TestGoAMD64FixedLocalConversionRuntimeOwnership(t *testing.T) {
+	for _, input := range [][2]int{{0, 0}, {48, -1}, {48, 1}, {336, 7}} {
+		if _, _, ok := fixedLocalConversionRuntimeBatchRange(input[0], input[1]); ok {
+			t.Fatal("invalid conversion runtime batch accepted", input)
+		}
+	}
+	for _, row := range []struct {
+		all   bool
+		count int
+	}{{false, 48}, {true, 336}} {
+		cases := fixedLocalConversionRuntimeCases(row.all)
+		if len(cases) != row.count {
+			t.Fatalf("runtime cases all=%v: %d, want %d", row.all, len(cases), row.count)
+		}
+		seen := make([]int, len(cases))
+		for batch := 0; batch*48 < len(cases); batch++ {
+			start, end, ok := fixedLocalConversionRuntimeBatchRange(len(cases), batch)
+			if !ok || end-start != 48 {
+				t.Fatal("incomplete conversion runtime batch", batch, start, end)
+			}
+			for index := start; index < end; index++ {
+				seen[index]++
+			}
+		}
+		for index, count := range seen {
+			if count != 1 {
+				t.Fatal("missing or duplicated original runtime case", index, count)
+			}
+		}
+		names := make(map[string]int)
+		for _, entry := range cases {
+			names[entry.name]++
+		}
+		if len(names)*8 != row.count {
+			t.Fatal("runtime inventory lost distinct family members", names)
+		}
+		for name, count := range names {
+			if count != 8 {
+				t.Fatalf("%s lost a live/dead or canary axis: %d", name, count)
+			}
+		}
+		assembly, _, _, _ := fixedLocalConversionRuntimeProgram(cases, "x86_64-unknown-linux-gnu")
+		requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	}
+	const filename = "amd64_fixed_local_conversion_runtime_linux_amd64_test.go"
+	for _, qualified := range []bool{false, true} {
+		for _, target := range []struct{ os, arch string }{
+			{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"}, {"linux", "arm64"},
+			{"js", "wasm"}, {"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+		} {
+			t.Run(fmt.Sprintf("selection/qualified=%t/%s-%s", qualified, target.os, target.arch), func(t *testing.T) {
+				context := ciNativeAVX512BuildContext(target.os, target.arch, qualified)
+				selected, err := context.MatchFile(".", filename)
+				want := qualified && target.os == "linux" && target.arch == "amd64"
+				if err != nil || selected != want {
+					t.Fatal("native conversion batch lost its explicit selection", target, qualified, selected, err)
+				}
+			})
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	owners := 0
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		owners++
+		name := fmt.Sprintf("TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch%02d", owners-1)
+		if function.Name.Name != name || function.Body == nil || len(function.Body.List) != 1 {
+			t.Fatal("native owner missing or conditional")
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("native runtime must execute directly")
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 4 || !fixedLocalConversionIdent(call.Fun, "fixedLocalConversionRuntimeBatch") ||
+			!fixedLocalConversionIdent(call.Args[0], "t") || !fixedLocalConversionIdent(call.Args[2], "true") {
+			t.Fatal("native runtime lost its complete-family axis")
+		}
+		batch, ok := call.Args[3].(*ast.BasicLit)
+		if !ok || batch.Kind != token.INT || batch.Value != fmt.Sprint(owners-1) {
+			t.Fatal("native runtime lost an original batch")
+		}
+		tools, ok := call.Args[1].(*ast.CallExpr)
+		if !ok || len(tools.Args) != 1 || !fixedLocalConversionIdent(tools.Fun, "x86PackedDoubleDwordNativeTools") ||
+			!fixedLocalConversionIdent(tools.Args[0], "t") {
+			t.Fatal("native runtime bypassed actual CPU/OS/opcode checks")
+		}
+	}
+	if owners != 7 {
+		t.Fatal("missing or ambiguous native owner", owners)
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") {
+		t.Fatal("required native runtime root not selected by CI", err)
+	}
+}
+
+func fixedLocalConversionIdent(expression ast.Expr, name string) bool {
+	identifier, ok := expression.(*ast.Ident)
+	return ok && identifier.Name == name
+}
diff --git a/amd64_fixed_local_conversion_test.go b/amd64_fixed_local_conversion_test.go
new file mode 100644
index 000000000..17e0c7c4a
--- /dev/null
+++ b/amd64_fixed_local_conversion_test.go
@@ -0,0 +1,534 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalConversionOperations() []string {
+	var operations []string
+	seen := make(map[string]bool)
+	for _, row := range append(x86PackedConversionOracleRows("amd64"), x86SignedPackedFloatRows("amd64")...) {
+		// Keep the complete independent register/mask/rounding inventory and
+		// one private address representative. Physical MMX stays unbound.
+		if strings.Contains(row, "M0") || strings.Contains(row, "M7") {
+			continue
+		}
+		_, operands, _ := strings.Cut(row, " ")
+		source, _, _ := strings.Cut(operands, ",")
+		if source == "(AX)" || source == "3(AX)" {
+			row = strings.Replace(row, source, "64(BP)", 1)
+		} else if strings.Contains(row, "(") || strings.Contains(row, " 256,") {
+			continue
+		}
+		if !seen[row] {
+			seen[row] = true
+			operations = append(operations, row)
+		}
+	}
+	return operations
+}
+
+func fixedLocalConversionOperation(row string) string {
+	// Every source and merge byte is independently numerical, including
+	// legacy upper aliases. Conversion output is then observed by a store.
+	prefix := "KMOVQ AX,K1\nKMOVQ AX,K3\nKMOVQ AX,K7\n"
+	for _, index := range []int{0, 7, 15, 20, 21, 31} {
+		prefix += fmt.Sprintf("VMOVDQU64 64(BP),Z%d\n", index)
+	}
+	parts := strings.Split(row, ",")
+	destination := strings.TrimSpace(parts[len(parts)-1])
+	return prefix + row + "\nVMOVDQU64 Z" + destination[1:] + ",128(BP)"
+}
+
+func TestGoAMD64FixedLocalConversionCompleteFamilyProof(t *testing.T) {
+	var original strings.Builder
+	names := make(map[string]bool)
+	for index, row := range fixedLocalConversionOperations() {
+		t.Run(row, func(t *testing.T) {
+			op := strings.Fields(row)[0]
+			name, _, _ := strings.Cut(op, ".")
+			names[name] = true
+			operation := fixedLocalConversionOperation(row)
+			pkg, _, file, options := fixedLocalPackedFixture(t, operation)
+			assembly := fixedLocalPackedAssembly(operation)
+			original.WriteString(strings.Replace(assembly, "·Value", fmt.Sprintf("·Value%d", index), 1))
+			if strings.Contains(row, "(BP)") && !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Error("native conversion memory did not request a complete original frame binding")
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+				t.Fatalf("initialized private conversion rejected: %v", err)
+			}
+		})
+	}
+	if len(names) != 42 {
+		t.Fatalf("complete independent conversion namespace = %d, want 42", len(names))
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalConversionWholeSourceNegatives(t *testing.T) {
+	operation := "VCVTDQ2PD 64(BP),Y0\nVMOVDQU Y0,128(BP)"
+	pkg, _, _, options := fixedLocalPackedFixture(t, operation)
+	original := fixedLocalPackedAssembly(operation)
+	for name, source := range map[string]string{
+		"input hole":                strings.Replace(original, "MOVQ AX,64(BP)", "MOVB AX,64(BP)", 1),
+		"outside frame":             strings.Replace(original, "VCVTDQ2PD 64(BP)", "VCVTDQ2PD 256(BP)", 1),
+		"incoming pointer":          strings.Replace(original, "MOVQ SP,BP", "MOVQ AX,BP", 1),
+		"unknown mask":              strings.Replace(original, "64(BP),Y0", "64(BP),K1,Y0", 1),
+		"unknown merge":             strings.Replace(original, operation, "KMOVQ AX,K1\nVCVTDQ2PD 64(BP),K1,Y0\nVMOVDQU Y0,128(BP)", 1),
+		"zero mask missing storage": strings.Replace(original, operation, "MOVQ $0,DX\nKMOVQ DX,K1\nVCVTDQ2PD.Z 256(BP),K1,Y0\nVMOVDQU Y0,128(BP)", 1),
+		"unknown source vector":     strings.Replace(original, "VCVTDQ2PD 64(BP)", "VCVTDQ2PD X0", 1),
+		"legacy m128 alignment":     strings.Replace(original, operation, "CVTPL2PS 65(BP),X0\nMOVOU X0,128(BP)", 1),
+		"MMX input":                 strings.Replace(original, operation, "CVTPL2PD M0,X0\nMOVOU X0,128(BP)", 1),
+		"MMX output":                strings.Replace(original, operation, "CVTPS2PL X0,M0", 1),
+		"private escape":            strings.Replace(original, "MOVQ AX,ret+8(FP)", "MOVQ BP,ret+8(FP)", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if name == "incoming pointer" {
+				fixedLocalRequireNumericControl(t, file.Funcs[0], options.Sigs[pkg.Path+".Value"], source,
+					"func Value(a uint64) uint64", "VCVTDQ2PD 64(BP),Y0", 0, 16, false, "vcvtdq2pd")
+				return
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed native conversion accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalConversionSparseByteEffects(t *testing.T) {
+	// Independent representatives of every width, alias and mask rule. The
+	// complete family test separately binds all encoder forms to these rules.
+	for _, row := range []struct {
+		instruction        string
+		input, active      int
+		legacy, mask, zero bool
+	}{
+		{"CVTPL2PD X0,X1", 8, 16, true, false, false},
+		{"CVTPS2PL X0,X1", 16, 16, true, false, false},
+		{"CVTPD2PL X0,X1", 16, 8, true, false, false},
+		{"VCVTDQ2PD X0,Y1", 16, 32, false, false, false},
+		{"VCVTPD2DQY Y0,X1", 32, 16, false, false, false},
+		{"VCVTPD2DQ Z0,Y1", 64, 32, false, false, false},
+		{"VCVTPS2QQ X0,Y1", 16, 32, false, false, false},
+		{"VCVTQQ2PSY Y0,X1", 32, 16, false, false, false},
+		{"VCVTPS2DQ.Z X0,K1,X1", 16, 16, false, true, true},
+		{"VCVTPS2DQ X0,K1,X1", 16, 16, false, true, false},
+		{"VCVTPD2DQX X0,K1,X1", 16, 8, false, true, false},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			source := x86CallerVectorRoot(ins.Args[0].Reg)
+			destination := x86CallerVectorRoot(ins.Args[len(ins.Args)-1].Reg)
+			fresh := func() x86FixedLocalState {
+				return x86FixedLocalState{
+					vectors: map[Reg]uint64{source: ^uint64(0), destination: ^uint64(0)},
+					masks:   map[Reg]bool{"K1": true},
+					flags:   x86ByteFlagsAll,
+				}
+			}
+			check := func(state *x86FixedLocalState, accepted bool) {
+				t.Helper()
+				known, err := fixedLocalConversionStep(&ins, state, &x86FixedLocalProof{}, 0)
+				if !known || accepted && err != nil || !accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("conversion effect accepted=%t: known=%t, %v", accepted, known, err)
+				}
+			}
+			for missing := 0; missing < 64; missing++ {
+				state := fresh()
+				state.vectors[source] &^= uint64(1) << uint(missing)
+				check(&state, missing >= row.input)
+			}
+			for missing := 0; missing < 64; missing++ {
+				state := fresh()
+				state.vectors[destination] &^= uint64(1) << uint(missing)
+				accepted := !row.mask || row.zero || missing >= row.active
+				check(&state, accepted)
+				if !accepted {
+					continue
+				}
+				want := ^uint64(0)
+				if row.legacy && missing >= 16 {
+					want &^= uint64(1) << uint(missing)
+				}
+				if state.vectors[destination] != want || state.flags != x86ByteFlagsAll {
+					t.Fatalf("byte %d: alias/zero padding/FLAGS changed: %+v", missing, state)
+				}
+			}
+			if row.mask {
+				state := fresh()
+				state.masks["K1"] = false
+				check(&state, false)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalConversionExactMemoryTuples(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		width       int
+		aligned     bool
+	}{
+		{"CVTPL2PD (BP),X1", 8, false},
+		{"CVTPL2PS (BP),X1", 16, true},
+		{"CVTPS2PL (BP),X1", 16, true},
+		{"CVTPD2PL (BP),X1", 16, true},
+		{"VCVTDQ2PD (BP),X1", 8, false},
+		{"VCVTDQ2PD (BP),Y1", 16, false},
+		{"VCVTDQ2PD (BP),Z1", 32, false},
+		{"VCVTDQ2PS (BP),Z1", 64, false},
+		{"VCVTDQ2PD.BCST.Z (BP),K1,Z1", 4, false},
+		{"VCVTPD2DQX (BP),X1", 16, false},
+		{"VCVTPD2DQY (BP),X1", 32, false},
+		{"VCVTPD2DQ (BP),Y1", 64, false},
+		{"VCVTPS2QQ.BCST.Z (BP),K1,Z1", 4, false},
+		{"VCVTUQQ2PS.BCST.Z (BP),K1,Y1", 8, false},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT value(SB),4,$128-0\n"+row.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			original := file.Funcs[0].Instrs[1]
+			destination := x86CallerVectorRoot(original.Args[len(original.Args)-1].Reg)
+			check := func(missing, offset int, accepted bool) {
+				t.Helper()
+				ins := original
+				state := x86FixedLocalState{
+					pointers: map[Reg]int64{BP: int64(offset)},
+					vectors:  map[Reg]uint64{destination: ^uint64(0)},
+					masks:    map[Reg]bool{"K1": true},
+					bytes:    newFixedLocalByteSet(128),
+				}
+				for index := 0; index < 128; index++ {
+					state.bytes.set(int64(index), index != missing)
+				}
+				proof := &x86FixedLocalProof{frame: 128}
+				known, err := fixedLocalConversionStep(&ins, &state, proof, 0)
+				if !known || accepted && err != nil || !accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("byte=%d offset=%d accepted=%t: known=%t, %v", missing, offset, accepted, known, err)
+				}
+				if accepted {
+					access := ins.x86FixedLocalMemory[0]
+					if access.owner != proof || access.width != int64(row.width) || access.write || state.flags != 0 {
+						t.Fatal("wrong native memory tuple, write permission or invented FLAGS", access)
+					}
+				}
+				if missing >= 0 && state.bytes.has(int64(missing)) {
+					t.Fatal("conversion manufactured initialized memory")
+				}
+			}
+			for missing := 0; missing < 128; missing++ {
+				check(missing, 0, missing >= row.width)
+			}
+			check(-1, 1, !row.aligned)
+			check(-1, 129-row.width, false)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch00(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 0)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch01(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 1)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch02(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 2)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch03(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 3)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch04(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 4)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch05(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 5)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch06(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 6)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch07(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 7)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch08(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 8)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch09(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 9)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch10(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 10)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch11(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 11)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch00(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 0)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch01(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 1)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch02(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 2)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch03(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 3)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch04(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 4)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch05(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 5)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch06(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 6)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch07(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 7)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch08(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 8)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch09(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 9)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch10(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 10)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch11(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 11)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch00(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 0)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch01(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 1)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch02(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 2)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch03(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 3)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch04(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 4)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch05(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 5)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch06(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 6)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch07(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 7)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch08(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 8)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch09(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 9)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch10(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 10)
+}
+
+func TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch11(t *testing.T) {
+	fixedLocalConversionActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 11)
+}
+
+func fixedLocalObjectBatchRange(total, batch int) (start, end int, ok bool) {
+	const size = 64
+	if total <= 0 || batch < 0 || batch >= (total+size-1)/size {
+		return 0, 0, false
+	}
+	start, end = batch*size, (batch+1)*size
+	if end > total {
+		end = total
+	}
+	return start, end, true
+}
+
+func TestGoAMD64FixedLocalConversionObjectBatchPlan(t *testing.T) {
+	rows := fixedLocalConversionOperations()
+	if len(rows) != 741 {
+		t.Fatal("complete independent conversion inventory changed", len(rows))
+	}
+	seen := make([]int, len(rows))
+	for batch := 0; batch < 12; batch++ {
+		start, end, ok := fixedLocalObjectBatchRange(len(rows), batch)
+		if !ok || end-start > 64 || end <= start {
+			t.Fatal("invalid independent conversion batch", batch, start, end, ok)
+		}
+		for index := start; index < end; index++ {
+			seen[index]++
+		}
+	}
+	// Scheduling remains twelve complete batches. Independent source captures
+	// cover those same 741 functions exactly once in bounded 32-function units.
+	chunks, sourceSeen := 0, make([]int, len(rows))
+	for batch := 0; batch < 12; batch++ {
+		start, end, _ := fixedLocalObjectBatchRange(len(rows), batch)
+		for chunk := start; chunk < end; chunk += 32 {
+			limit := fixedLocalConversionSourceEnd(chunk, end)
+			if limit <= chunk || limit > end || limit-chunk > 32 {
+				t.Fatal("invalid independently captured conversion source", chunk, limit, end)
+			}
+			for index := chunk; index < limit; index++ {
+				sourceSeen[index]++
+			}
+			chunks++
+		}
+	}
+	if chunks != 24 {
+		t.Fatal("complete conversion source plan changed", chunks)
+	}
+	for index, count := range seen {
+		if count != 1 || sourceSeen[index] != 1 {
+			t.Fatal("missing or duplicated original conversion form", index, rows[index], count)
+		}
+	}
+	for _, input := range [][2]int{{0, 0}, {741, -1}, {741, 12}} {
+		if _, _, ok := fixedLocalObjectBatchRange(input[0], input[1]); ok {
+			t.Fatal("invalid conversion batch accepted", input)
+		}
+	}
+}
+
+func fixedLocalConversionSourceEnd(start, end int) int {
+	if end-start > 32 {
+		return start + 32
+	}
+	return end
+}
+
+func fixedLocalConversionActualObjects(t *testing.T, target, triple string, batch int) {
+	t.Helper()
+	// Go 1.27 builds objdump into GOCACHE. Reuse this batch's test-owned
+	// compiler cache, not its independent source, object or lifetime records.
+	t.Setenv("GOCACHE", t.TempDir())
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	rows := fixedLocalConversionOperations()
+	start, end, ok := fixedLocalObjectBatchRange(len(rows), batch)
+	if !ok {
+		t.Fatal("invalid complete conversion object batch", batch, len(rows))
+	}
+	// Keep the twelve complete scheduling owners, but give each independent
+	// source proof at most 32 functions within its unchanged five-minute lease.
+	for chunk := start; chunk < end; chunk += 32 {
+		limit := fixedLocalConversionSourceEnd(chunk, end)
+		t.Run(fmt.Sprintf("batch%d/source%d", batch, (chunk-start)/32), func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			var names []string
+			for index := chunk; index < limit; index++ {
+				name := fmt.Sprintf("Value%d", index)
+				body := fixedLocalPackedAssembly(fixedLocalConversionOperation(rows[index]))
+				assembly.WriteString(strings.Replace(body, "·Value", "·"+name, 1))
+				fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+				names = append(names, "example.invalid/framefixture."+name)
+			}
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t,
+				assembly.String(), declarations.String(), target, triple)
+			fixedLocalConversionPrepareToolCache(t, request)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, "fixed_local_native") || !strings.Contains(ir, "asm sideeffect") {
+					t.Fatal("conversion did not consume native private backing")
+				}
+				for _, optimize := range []bool{false, true} {
+					input := ir
+					if optimize {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					x86CompactExpandRequireAllDefinitions(t, input, names)
+					compileLLVMToObject(t, llc, triple, "frame-conversion.ll", "frame-conversion.o", input)
+				}
+			})
+		})
+	}
+	t.Logf("%s batch%d: %d/%d forms, three LLVM APIs, O0/O2", target, batch, end-start, len(rows))
+}
+
+func TestGoAMD64FixedLocalConversionSharedCacheKeepsSourcesIndependent(t *testing.T) {
+	cache := t.TempDir()
+	t.Setenv("GOCACHE", cache)
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		t.Setenv(key, "")
+	}
+	const assembly = "TEXT ·Value(SB),4,$0-16\nMOVQ a+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+	first, a, _, _ := x86CMOVFixedLocalFixture(t, assembly, "func Value(a uint64) uint64",
+		"linux/amd64", "x86_64-unknown-linux-gnu")
+	second, b, _, _ := x86CMOVFixedLocalFixture(t, assembly, "func Value(a uint64) uint64",
+		"linux/amd64", "x86_64-unknown-linux-gnu")
+	values := func(request GoAMD64FrameCaptureRequest) map[string]string {
+		environment := make(map[string]string)
+		for _, entry := range request.Environment {
+			key, value, _ := strings.Cut(entry, "=")
+			environment[key] = value
+		}
+		return environment
+	}
+	left, right := values(a), values(b)
+	if left["GOCACHE"] != cache || right["GOCACHE"] != cache {
+		t.Fatal("batch fixtures did not inherit their parent's owned build cache")
+	}
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		if left[key] == "" || left[key] == right[key] || left[key] == cache || right[key] == cache {
+			t.Fatal("independent source observations shared private state", key)
+		}
+	}
+	if a.Directory == b.Directory || first.Types == second.Types {
+		t.Fatal("sharing compiler artifacts reused an original source or typed package")
+	}
+}
diff --git a/amd64_fixed_local_conversion_tool_cache_test.go b/amd64_fixed_local_conversion_tool_cache_test.go
new file mode 100644
index 000000000..23494800d
--- /dev/null
+++ b/amd64_fixed_local_conversion_tool_cache_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Share only this test process's disposable compiler artifacts. Each source
+// lease and command workspace remains independently owned by its fixture.
+func goAMD64FramePrepareOwnedToolCache(t *testing.T) {
+	t.Helper()
+	cache, err := fixedLocalProcessToolCache.directory()
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOCACHE", cache)
+	_, request := goAMD64FrameSourceFixture(t)
+	fixedLocalConversionPrepareToolCache(t, request)
+}
+
+// Tool construction is setup, not a source/object observation. In particular,
+// this output cannot replace Capture's independent bounded tool query or seals.
+func fixedLocalConversionPrepareToolCache(t *testing.T, request GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	cache := ""
+	for _, entry := range request.Environment {
+		key, value, _ := strings.Cut(entry, "=")
+		if key == "GOCACHE" {
+			if cache != "" || value == "" {
+				t.Fatal("conversion setup requires one explicit owned compiler cache")
+			}
+			cache = value
+		}
+	}
+	if cache == "" || request.GoBinary == "" || request.Directory == "" {
+		t.Fatal("conversion setup lost its actual tool, directory or compiler cache")
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, request.GoBinary, "tool", "-n", "objdump")
+	command.Dir, command.Env = request.Directory, request.Environment
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("prepare actual Go objdump before source capture: %v\n%s", err, output)
+	}
+}
diff --git a/amd64_fixed_local_counted_loop.go b/amd64_fixed_local_counted_loop.go
new file mode 100644
index 000000000..99dfe4b49
--- /dev/null
+++ b/amd64_fixed_local_counted_loop.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import "math"
+
+// A syntax-only descriptor for an innermost, single-entry straight-line loop.
+// Counter values, storage and all per-iteration effects are checked by the
+// ordinary replay. Unknown or more general loops retain the existing CFG meet.
+type x86FixedLocalCountedLoop struct {
+	header, update, latch int
+	counter               Reg
+	delta                 int64
+	bound                 uint64
+}
+
+func fixedLocalCountedLoops(fn Func, edges map[int][]int, instructions []int) map[int]x86FixedLocalCountedLoop {
+	linear := fixedLocalLinearEdges(fn, edges, instructions)
+	end := make([]int, len(instructions))
+	for pc := len(instructions) - 1; pc >= 0; pc-- {
+		end[pc] = pc
+		if linear[pc] {
+			end[pc] = end[pc+1]
+		}
+	}
+	var loops map[int]x86FixedLocalCountedLoop
+	for latch := 2; latch+1 < len(instructions); latch++ {
+		targets := edges[latch]
+		if len(targets) != 2 || targets[0] != latch+1 {
+			continue
+		}
+		header := targets[1]
+		if header <= 0 || header > latch-2 || end[header] != latch {
+			continue // Full predecessor counts exclude side entries and nested branches.
+		}
+		condition := x86BranchCondition(fn.Instrs[instructions[latch]].Op)
+		if condition != "CS" && condition != "HI" {
+			continue
+		}
+		compare := fn.Instrs[instructions[latch-1]]
+		cmp, recognized, err := x86ScalarCompareProperties(compare.Op, compare, "amd64")
+		if !recognized || err != nil || cmp.test || cmp.bits != 64 ||
+			cmp.args[0].Kind != OpReg || cmp.args[1].Kind != OpImm {
+			continue
+		}
+		counter, valid := x86CallerGP(cmp.args[0].Reg)
+		if !valid || counter != cmp.args[0].Reg || counter == SP {
+			continue
+		}
+		// These straight-line bodies cannot overlap: another latch would
+		// terminate end[header]. Their combined backwards scan stays O(N).
+		// Replay checks that every other typed transfer preserves the counter.
+		for update := latch - 2; update >= header; update-- {
+			delta := fixedLocalCountedDelta(fn.Instrs[instructions[update]], counter)
+			if delta == 0 || delta > 0 && condition != "CS" || delta < 0 && condition != "HI" {
+				continue
+			}
+			if loops == nil {
+				loops = make(map[int]x86FixedLocalCountedLoop)
+			}
+			loops[header] = x86FixedLocalCountedLoop{header, update, latch, counter, delta, uint64(cmp.args[1].Imm)}
+			break
+		}
+	}
+	return loops
+}
+
+func fixedLocalCountedDelta(ins Instr, counter Reg) int64 {
+	form, recognized, err := x86LockScalarRMWProperties(ins.Op, ins, "amd64")
+	if !recognized || err != nil || form.spec.bits != 64 ||
+		form.destination.Kind != OpReg || form.destination.Reg != counter {
+		return 0
+	}
+	switch form.spec.stem {
+	case "ADD", "SUB":
+		if form.source.Kind == OpImm {
+			delta := form.source.Imm // The shared grammar applies encoded imm32 sign extension.
+			if form.spec.stem == "SUB" {
+				delta = -delta
+			}
+			return delta
+		}
+	case "INC":
+		return 1
+	case "DEC":
+		return -1
+	}
+	return 0
+}
+
+func (loop x86FixedLocalCountedLoop) number(state *x86FixedLocalState) (uint64, bool) {
+	value, known := state.constants[loop.counter]
+	return uint64(value), known && fixedLocalNumericRead(Operand{Kind: OpReg, Reg: loop.counter}, 8, state)
+}
+
+func (loop x86FixedLocalCountedLoop) next(value uint64) (uint64, error) {
+	if loop.delta > 0 {
+		step := uint64(loop.delta)
+		if value > math.MaxUint64-step {
+			return 0, goAMD64FrameContext("fixed local counted-loop counter wraps")
+		}
+		return value + step, nil
+	}
+	step := uint64(-loop.delta)
+	if value < step {
+		return 0, goAMD64FrameContext("fixed local counted-loop counter wraps")
+	}
+	return value - step, nil
+}
+
+func (loop x86FixedLocalCountedLoop) continues(value uint64) bool {
+	if loop.delta > 0 {
+		return value < loop.bound
+	}
+	return value > loop.bound
+}
+
+// Keep every iteration, including early aliases. A fresh visit from an outer
+// fixed point replaces the provisional series; it never appends stale visits.
+func fixedLocalCountedAccesses(previous, current map[int]x86FixedLocalAccess, iteration int) error {
+	if iteration != 0 && len(previous) != len(current) {
+		return goAMD64FrameContext("fixed local counted-loop access inventory changed")
+	}
+	for operand, access := range current {
+		if iteration == 0 {
+			access.iterationOffsets = [][8]int64{access.offset}
+		} else {
+			prior, found := previous[operand]
+			if !found || !fixedLocalAccessShapeEqual(prior, access) ||
+				len(prior.iterationOffsets) != iteration {
+				return goAMD64FrameContext("fixed local counted-loop access role changed")
+			}
+			prior.iterationOffsets = append(prior.iterationOffsets, access.offset)
+			access = prior
+		}
+		current[operand] = access
+	}
+	return nil
+}
diff --git a/amd64_fixed_local_counted_loop_alias_go127_test.go b/amd64_fixed_local_counted_loop_alias_go127_test.go
new file mode 100644
index 000000000..d532bcf78
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_alias_go127_test.go
@@ -0,0 +1,57 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalCountedLoopAliasCase struct {
+	offsets []int
+}
+
+func fixedLocalCountedLoopAliasProgram(t *testing.T) (string, string, []fixedLocalCountedLoopAliasCase) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	var cases []fixedLocalCountedLoopAliasCase
+	for _, step := range []int{1, 4} {
+		for _, descending := range []bool{false, true} {
+			first, limit, update, branch := 0, 4*step, "ADDQ", "JB"
+			if descending {
+				first, limit, update, branch = 4*step, 0, "SUBQ", "JA"
+			}
+			var body strings.Builder
+			body.WriteString("MOVQ $77,248(SP)\nMOVQ a+0(FP),DI\nANDQ $1,DI\nADDQ $1,DI\nMOVQ $0,DX\nouter:\n")
+			fmt.Fprintf(&body, "MOVQ $%d,SI\nloop:\nMOVQ AX,BX\nADDQ SI,BX\n"+
+				"MOVQ BX,16(SP)(SI*1)\nADDQ $2,16(SP)(SI*1)\n"+
+				"%s $%d,SI\nCMPQ SI,$%d\n%s loop\n"+
+				"ADDQ $1,DX\nCMPQ DX,DI\nJB outer\nMOVQ $0,AX\n", first, update, step, limit, branch)
+			var offsets []int
+			for iteration := 0; iteration < 4; iteration++ {
+				offset := iteration * step
+				if descending {
+					offset = (4 - iteration) * step
+				}
+				offsets = append(offsets, offset)
+				fmt.Fprintf(&body, "ADDQ %d(SP),AX\n", 16+offset)
+			}
+			body.WriteString("ADDQ 248(SP),AX")
+			_, _, source := fixedLocalCountedLoopFixture(t, body.String())
+			name := fmt.Sprintf("Value%d", len(cases))
+			assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			cases = append(cases, fixedLocalCountedLoopAliasCase{offsets})
+		}
+	}
+	if len(cases) != 4 {
+		t.Fatal("overlapping-iteration inventory changed", len(cases))
+	}
+	return assembly.String(), declarations.String(), cases
+}
+
+func TestGoAMD64FixedLocalCountedLoopAliasObjects(t *testing.T) {
+	assembly, declarations, cases := fixedLocalCountedLoopAliasProgram(t)
+	fixedLocalCountedLoopObjects(t, assembly, declarations, len(cases))
+}
diff --git a/amd64_fixed_local_counted_loop_contract_test.go b/amd64_fixed_local_counted_loop_contract_test.go
new file mode 100644
index 000000000..c2e2ae0ad
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_contract_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalCountedLoopAliasesAndUpdates(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	aliases := x86ConditionalBranchAliasOracle()
+	var names []string
+	for alias := range aliases {
+		names = append(names, alias)
+	}
+	sort.Strings(names)
+	for _, alias := range names {
+		canonical := aliases[alias]
+		if got := x86BranchCondition(Op(alias)); got != strings.TrimPrefix(canonical, "J") {
+			t.Fatalf("complete branch condition %s = %s, want %s", alias, got, canonical)
+		}
+		if canonical != "JCS" && canonical != "JHI" {
+			continue
+		}
+		for _, register := range strings.Fields("AX BX CX DX DI SI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+			for variant := 0; variant < 3; variant++ {
+				first, bound, delta, operation := 0, 24, 8, "ADDQ"
+				if canonical == "JHI" {
+					first, bound, operation = 24, 0, "SUBQ"
+				}
+				if variant == 1 {
+					delta = -delta
+					if operation == "ADDQ" {
+						operation = "SUBQ"
+					} else {
+						operation = "ADDQ"
+					}
+				}
+				update, scale := fmt.Sprintf("%s $%d,%s", operation, delta, register), 1
+				if variant == 2 {
+					first, bound, operation, scale = 0, 3, "INCQ", 8
+					if canonical == "JHI" {
+						first, bound, operation = 3, 0, "DECQ"
+					}
+					update = operation + " " + register
+				}
+				body := fmt.Sprintf("MOVQ $%d,%s\nloop:\nMOVQ AX,16(SP)(%s*%d)\n%s\nCMPQ %s,$%d\n%s loop\nMOVQ 24(SP),AX",
+					first, register, register, scale, update, register, bound, alias)
+				fn, sig, source := fixedLocalCountedLoopFixture(t, body)
+				original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+				count++
+				t.Run(alias+"/"+register+"/"+operation, func(t *testing.T) {
+					if _, err := proveX86FixedLocal(fn, sig); err != nil {
+						t.Fatal("canonical unsigned condition or signed update spelling was lost", err)
+					}
+				})
+			}
+		}
+	}
+	if count != 360 {
+		t.Fatal("eight unsigned aliases by 15 GP registers and three update spellings changed", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalCountedLoopCertificates(t *testing.T) {
+	const body = "MOVQ $0,SI\nloop:\nMOVQ AX,16(SP)(SI*8)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 32(SP),AX"
+	fn, sig, source := fixedLocalCountedLoopFixture(t, body)
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	for _, mutation := range []string{"none", "early offset", "missing iteration", "inline offset", "snapshot copy"} {
+		t.Run(mutation, func(t *testing.T) {
+			proved, err := proveX86FixedLocal(fn, sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			lower := &amd64Ctx{fixedLocal: proved.x86FixedLocal}
+			found := false
+			for _, instruction := range proved.Instrs {
+				for operand, access := range instruction.x86FixedLocalMemory {
+					if len(access.iterationOffsets) == 0 {
+						continue
+					}
+					found = true
+					if len(access.iterationOffsets) != 3 || access.offset != access.iterationOffsets[0] {
+						t.Fatal("loop did not preserve its complete ordered access inventory", access)
+					}
+					for iteration, offsets := range access.iterationOffsets {
+						for _, offset := range offsets {
+							if offset != int64(16+8*iteration) {
+								t.Fatal("one original SP residue or iteration changed bytes", offsets)
+							}
+						}
+					}
+					switch mutation {
+					case "early offset":
+						// Mutate the original instruction's backing slice directly.
+						// Its separately frozen expected access must not change.
+						access.iterationOffsets[0][0]++
+					case "missing iteration":
+						access.iterationOffsets = access.iterationOffsets[1:]
+					case "inline offset":
+						access.offset[0]++
+					case "snapshot copy":
+						copy := cloneX86ReplayFixedLocalMemory(instruction.x86FixedLocalMemory)
+						copy[operand].iterationOffsets[0][0]++
+						if !lower.fixedLocalMemoryCertified(instruction, operand) {
+							t.Fatal("changing a copied snapshot changed its source")
+						}
+						access = copy[operand]
+					}
+					instruction.x86FixedLocalMemory[operand] = access
+					if lower.fixedLocalMemoryCertified(instruction, operand) != (mutation == "none") {
+						t.Fatal("incomplete or changed iteration series retained its authority")
+					}
+				}
+			}
+			if !found {
+				t.Fatal("no loop access received a complete series")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCountedLoopBudgetIsAtomic(t *testing.T) {
+	const body = "MOVQ $0,SI\nloop:\nMOVQ AX,16(SP)(SI*8)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 32(SP),AX"
+	fn, sig, _ := fixedLocalCountedLoopFixture(t, body)
+	for _, budget := range []x86FixedLocalBudget{{steps: 9, bytes: 64 << 20}, {steps: 1 << 18, bytes: 9 * fn.FrameSize}} {
+		proof := &x86FixedLocalProof{frame: fn.FrameSize}
+		if err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, nil); err == nil {
+			t.Fatal("partial counted-loop execution exhausted its budget but succeeded")
+		}
+		for _, instruction := range fn.Instrs {
+			if len(instruction.x86FixedLocalMemory) != 0 {
+				t.Fatal("unfinished counted loop published provisional access history")
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalCountedLoopPreservesGenericCFG(t *testing.T) {
+	var original strings.Builder
+	for index, row := range []struct{ name, body string }{
+		{"wrapping counter with fixed access", "MOVQ $-1,SI\nloop:\nMOVQ AX,16(SP)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 16(SP),AX"},
+		{"counter replaced with fixed access", "MOVQ $0,SI\nloop:\nMOVQ $3,SI\nMOVQ AX,16(SP)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 16(SP),AX"},
+		{"counter replaced before indexed access", "MOVQ $0,SI\nloop:\nMOVQ $3,SI\nMOVQ AX,16(SP)(SI*8)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 40(SP),AX"},
+	} {
+		fn, sig, source := fixedLocalCountedLoopFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			plain := fn
+			plain.Instrs = append([]Instr(nil), fn.Instrs...)
+			edges, instructions, err := fixedLocalEdges(plain)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof := &x86FixedLocalProof{frame: fn.FrameSize}
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			for residue := 0; residue < 8; residue++ {
+				if err := replayX86FixedLocalCFG(&plain, sig, proof, residue, &budget, nil, edges, instructions, nil, nil, nil); err != nil {
+					t.Fatal("the original generic CFG must independently establish this fixture", err)
+				}
+			}
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("new loop closure must preserve ordinary CFG acceptance", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalReplayLateResidueFailureIsAtomic(t *testing.T) {
+	fn, sig, source := fixedLocalGPFixture(t, "MOVQ AX,16(SP)\nMOVQ AX,24(SP)\nMOVQ 24(SP),AX")
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	proof := &x86FixedLocalProof{frame: fn.FrameSize}
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	if err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, nil); err != nil {
+		t.Fatal(err)
+	}
+	last := -1
+	for index, instruction := range fn.Instrs {
+		if len(instruction.x86FixedLocalMemory) != 0 {
+			last = index
+		}
+	}
+	if last < 0 {
+		t.Fatal("fixture has no late memory annotation")
+	}
+	for operand, access := range fn.Instrs[last].x86FixedLocalMemory {
+		access.width++
+		fn.Instrs[last].x86FixedLocalMemory[operand] = access
+	}
+	before := make([]map[int]x86FixedLocalAccess, len(fn.Instrs))
+	for index, instruction := range fn.Instrs {
+		before[index] = cloneX86ReplayFixedLocalMemory(instruction.x86FixedLocalMemory)
+	}
+	if err := replayX86FixedLocal(&fn, sig, proof, 1, &budget, nil, nil); err == nil {
+		t.Fatal("late cross-residue shape mismatch was accepted")
+	}
+	for index, instruction := range fn.Instrs {
+		if !reflect.DeepEqual(before[index], instruction.x86FixedLocalMemory) {
+			t.Fatal("failed final validation published an earlier partial annotation", index)
+		}
+	}
+}
diff --git a/amd64_fixed_local_counted_loop_go127_test.go b/amd64_fixed_local_counted_loop_go127_test.go
new file mode 100644
index 000000000..91ff2d098
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_go127_test.go
@@ -0,0 +1,105 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalCountedLoopProgram(t *testing.T) (string, string, []string) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	assembly.WriteString(fixedLocalAddressData)
+	var expected []string
+	appendFunction := func(body, want string) {
+		name := fmt.Sprintf("Value%d", len(expected))
+		_, _, source := fixedLocalCountedLoopFixture(t, body)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		expected = append(expected, want)
+	}
+	for _, row := range fixedLocalCountedLoopCases() {
+		// Every stored qword is input + 2, read once after the complete
+		// loop; a separate canary contributes 77. Native callers use -1.
+		appendFunction(row.body, fmt.Sprintf("%016x", row.iterations+77))
+	}
+	for _, descending := range []bool{false, true} {
+		appendFunction(fixedLocalCountedLiteralBody(descending), "64686c7074787c80")
+	}
+	return assembly.String(), declarations.String(), expected
+}
+
+func fixedLocalCountedLiteralBody(descending bool) string {
+	first, offset, limit, update, branch := 0, 0, 4, "ADDQ", "JB"
+	if descending {
+		first, offset, limit, update, branch = 4, -8, 0, "SUBQ", "JA"
+	}
+	return fmt.Sprintf("LEAQ literal<>(SB),BP\nMOVQ $0,8(SP)\nMOVQ $%d,SI\nloop:\n"+
+		"MOVQ %d(BP)(SI*8),AX\nMOVQ AX,16(SP)(SI*8)\nADDQ AX,8(SP)\n"+
+		"%s $1,SI\nCMPQ SI,$%d\n%s loop\nMOVQ 8(SP),AX", first, offset, update, limit, branch)
+}
+
+func TestGoAMD64FixedLocalCountedLoopObjects(t *testing.T) {
+	assembly, declarations, expected := fixedLocalCountedLoopProgram(t)
+	if len(expected) != 38 {
+		t.Fatal("counted-loop object inventory changed", len(expected))
+	}
+	fixedLocalCountedLoopObjects(t, assembly, declarations, len(expected))
+}
+
+func fixedLocalCountedLoopObjects(t *testing.T, assembly, declarations string, count int) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			var names []string
+			for index := 0; index < count; index++ {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("original bounded-loop source rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "counted-loop.ll", "counted-loop.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "counted-loop-opt.ll", "counted-loop-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCountedLiteralLoopGuards(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	valid := fixedLocalCountedLiteralBody(false)
+	for _, row := range []struct{ name, body string }{
+		{"last read exceeds DATA", strings.Replace(valid, "CMPQ SI,$4", "CMPQ SI,$5", 1)},
+		{"negative first read", strings.Replace(valid, "MOVQ 0(BP)", "MOVQ -8(BP)", 1)},
+		{"readonly indexed store", strings.Replace(valid, "MOVQ 0(BP)(SI*8),AX", "MOVQ AX,0(BP)(SI*8)", 1)},
+		{"readonly indexed RMW", strings.Replace(valid, "MOVQ 0(BP)(SI*8),AX", "ADDQ AX,0(BP)(SI*8)", 1)},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			_, _, source := fixedLocalCountedLoopFixture(t, row.body)
+			pkg, request, file, options := fixedLocalTransportFixture(t, fixedLocalAddressData+source,
+				"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			owner := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := owner.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("counted loop acquired an invalid DATA extent or write", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_counted_loop_runtime_go127_test.go b/amd64_fixed_local_counted_loop_runtime_go127_test.go
new file mode 100644
index 000000000..5ff1df87c
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_runtime_go127_test.go
@@ -0,0 +1,57 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"testing"
+)
+
+func fixedLocalCountedLoopRuntimeInputs() []uint64 {
+	// Both low-bit values exercise one and two outer passes. The remaining
+	// values distinguish wrapped arithmetic and overlapping byte stores.
+	return []uint64{0, 1, ^uint64(0), ^uint64(0) - 1, 0x0123456789abcdef}
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalCountedLoop(t *testing.T) {
+	assembly, declarations, inventory := fixedLocalCountedLoopProgram(t)
+	if len(inventory) != 38 {
+		t.Fatal("counted-loop runtime inventory changed", len(inventory))
+	}
+	inputs := fixedLocalCountedLoopRuntimeInputs()
+	var expected [][]string
+	for _, input := range inputs {
+		var values []string
+		for _, row := range fixedLocalCountedLoopCases() {
+			values = append(values, fmt.Sprintf("%016x", uint64(row.iterations)*(input+2)+77))
+		}
+		expected = append(expected, append(values, "64686c7074787c80", "64686c7074787c80"))
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalCountedLoopAliases(t *testing.T) {
+	assembly, declarations, cases := fixedLocalCountedLoopAliasProgram(t)
+	inputs := fixedLocalCountedLoopRuntimeInputs()
+	var expected [][]string
+	for _, input := range inputs {
+		var values []string
+		for _, row := range cases {
+			// This byte-array oracle preserves earlier stores that overlap
+			// later iterations; retaining only the last access gives a
+			// different result for these nonuniform input bytes.
+			var memory [32]byte
+			for _, offset := range row.offsets {
+				binary.LittleEndian.PutUint64(memory[offset:], input+uint64(offset)+2)
+			}
+			sum := uint64(77)
+			for _, offset := range row.offsets {
+				sum += binary.LittleEndian.Uint64(memory[offset:])
+			}
+			values = append(values, fmt.Sprintf("%016x", sum))
+		}
+		expected = append(expected, values)
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
diff --git a/amd64_fixed_local_counted_loop_test.go b/amd64_fixed_local_counted_loop_test.go
new file mode 100644
index 000000000..eb0a9fe24
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalCountedLoopCase struct {
+	name, body string
+	iterations int
+}
+
+func fixedLocalCountedLoopCases() []fixedLocalCountedLoopCase {
+	var cases []fixedLocalCountedLoopCase
+	for _, count := range []int{2, 3, 8} {
+		for _, step := range []int{1, 8, 16} {
+			for _, descending := range []bool{false, true} {
+				for _, outer := range []bool{false, true} {
+					scale := 1
+					if step == 1 {
+						scale = 8
+					}
+					first, limit, update, branch := 0, count*step, "ADDQ", "JB"
+					if descending {
+						first, limit, update, branch = count*step, 0, "SUBQ", "JA"
+					}
+					var body strings.Builder
+					body.WriteString("MOVQ $77,248(SP)\n")
+					if outer {
+						// The input-dependent outer loop remains an ordinary CFG
+						// fixed point. Its one or two passes must each re-establish
+						// the inner loop's complete private initialization.
+						body.WriteString("MOVQ a+0(FP),DI\nANDQ $1,DI\nADDQ $1,DI\nMOVQ $0,DX\nouter:\n")
+					}
+					fmt.Fprintf(&body, "MOVQ $%d,SI\nloop:\nMOVQ AX,16(SP)(SI*%d)\nADDQ $2,16(SP)(SI*%d)\n%s $%d,SI\nCMPQ SI,$%d\n%s loop\n",
+						first, scale, scale, update, step, limit, branch)
+					if outer {
+						body.WriteString("ADDQ $1,DX\nCMPQ DX,DI\nJB outer\n")
+					}
+					// An independent fixed-address read of every iteration's
+					// store detects partial initialization and skipped visits.
+					for iteration := 0; iteration < count; iteration++ {
+						offset := 16 + iteration*step*scale
+						if descending {
+							offset = 16 + (count-iteration)*step*scale
+						}
+						op := "ADDQ"
+						if iteration == 0 {
+							op = "MOVQ"
+						}
+						fmt.Fprintf(&body, "%s %d(SP),AX\n", op, offset)
+					}
+					body.WriteString("ADDQ 248(SP),AX")
+					name := fmt.Sprintf("count%d/step%d/descending%t/outer%t", count, step, descending, outer)
+					cases = append(cases, fixedLocalCountedLoopCase{name, body.String(), count})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func fixedLocalCountedLoopFixture(t *testing.T, body string) (Func, FuncSig, string) {
+	t.Helper()
+	_, sig, source := fixedLocalGPFixture(t, body)
+	source = strings.Replace(source, "$64-16", "$256-16", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestGoAMD64FixedLocalCountedLoopCompleteInitialization(t *testing.T) {
+	var original strings.Builder
+	cases := fixedLocalCountedLoopCases()
+	if len(cases) != 36 {
+		t.Fatal("count/stride/direction/outer-loop inventory changed", len(cases))
+	}
+	for index, row := range cases {
+		fn, sig, source := fixedLocalCountedLoopFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			proved, err := proveX86FixedLocal(fn, sig)
+			if err != nil {
+				t.Fatal("bounded iterations lost initialized private bytes", err)
+			}
+			before, beforeErr := x86CallerSourceFingerprint(fn)
+			after, afterErr := x86CallerSourceFingerprint(proved)
+			if beforeErr != nil || afterErr != nil || before != after || len(fn.Instrs) != len(proved.Instrs) {
+				t.Fatal("proof must retain the complete original source and loop body", beforeErr, afterErr)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalCountedLoopRejectsUnprovedIterations(t *testing.T) {
+	const prefix = "MOVQ $0,SI\nloop:\n"
+	const store = "MOVQ AX,16(SP)(SI*8)\n"
+	const suffix = "ADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 32(SP),AX"
+	var original strings.Builder
+	for index, row := range []struct{ name, body string }{
+		{"read before first write", prefix + "MOVQ 16(SP)(SI*8),BX\n" + store + suffix},
+		{"read next iteration before write", prefix + store + "MOVQ 24(SP)(SI*8),BX\n" + suffix},
+		{"partial initialization", prefix + "MOVB AX,16(SP)(SI*8)\n" + suffix},
+		{"partial counter overwrite", prefix + "ADDB $0,SI\n" + store + suffix},
+		{"counter overwritten in body", prefix + "ADDQ $1,SI\n" + store + suffix},
+		{"unknown initial counter", "MOVQ a+0(FP),SI\nloop:\n" + store + suffix},
+		{"zero update cannot initialize later bytes", prefix + store + "ADDQ $0,SI\nCMPQ SI,$3\nJB loop\nMOVQ 32(SP),AX"},
+		{"unbounded limit", prefix + store + "ADDQ $1,SI\nCMPQ SI,AX\nJB loop\nMOVQ AX,AX"},
+		{"latch flags replaced", prefix + store + "ADDQ $1,SI\nCMPQ SI,$3\nTESTQ AX,AX\nJB loop\nMOVQ 32(SP),AX"},
+		{"latch compares another counter", prefix + store + "ADDQ $1,SI\nCMPQ SI,$3\nCMPQ AX,$3\nJB loop\nMOVQ AX,AX"},
+		{"counter wraps", "MOVQ $-1,SI\nloop:\n" + store + "ADDQ $1,SI\nCMPQ SI,$3\nJB loop"},
+		{"entry bypasses counter", "CMPQ AX,$0\nJEQ inside\nMOVQ $0,SI\nloop:\ninside:\n" + store + suffix},
+		{"conditional write is incomplete", prefix + "CMPQ AX,$0\nJEQ missing\n" + store + "missing:\n" + suffix},
+		{"unwritten gap after loop", prefix + store + "ADDQ $2,SI\nCMPQ SI,$4\nJB loop\nMOVQ 24(SP),AX"},
+		{"last iteration exceeds frame", "MOVQ $29,SI\nloop:\n" + store + "ADDQ $1,SI\nCMPQ SI,$32\nJB loop"},
+		{"early iteration changes residue alias", "MOVQ $77,16(SP)\nMOVQ SP,R8\nADDQ $16,R8\nANDQ $-16,R8\nMOVQ $1,SI\nloop:\nMOVQ AX,(R8)(SI*8)\nADDQ $1,SI\nCMPQ SI,$3\nJB loop\nMOVQ 16(SP),AX"},
+	} {
+		fn, sig, source := fixedLocalCountedLoopFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err == nil {
+				t.Fatal("incomplete iterations or private-byte aliases acquired a proof")
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_counted_loop_update_gap_go127_test.go b/amd64_fixed_local_counted_loop_update_gap_go127_test.go
new file mode 100644
index 000000000..eebb66c4c
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_update_gap_go127_test.go
@@ -0,0 +1,39 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalCountedLoopUpdateGapProgram(t *testing.T) (string, string, int) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	count := 0
+	for _, row := range fixedLocalCountedLoopUpdateGapCases() {
+		if !strings.HasPrefix(row.name, "SI/") ||
+			!strings.HasSuffix(row.name, "/GP and flags") && !strings.HasSuffix(row.name, "/two vector moves") {
+			continue
+		}
+		// The scratch GP in the gap changes AX. Keep the input separately
+		// and make every initialized slot equal input+2 modulo the word size.
+		body := "MOVQ a+0(FP),R8\n" + strings.Replace(row.body,
+			"MOVQ $7,16(SP)(SI*8)", "MOVQ R8,16(SP)(SI*8)\nADDQ $2,16(SP)(SI*8)", 1)
+		_, _, source := fixedLocalCountedLoopFixture(t, body)
+		name := fmt.Sprintf("Value%d", count)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		count++
+	}
+	if count != 8 {
+		t.Fatal("four counter updates by GP/vector gap inventory changed", count)
+	}
+	return assembly.String(), declarations.String(), count
+}
+
+func TestGoAMD64FixedLocalCountedLoopUpdateGapObjects(t *testing.T) {
+	assembly, declarations, count := fixedLocalCountedLoopUpdateGapProgram(t)
+	fixedLocalCountedLoopObjects(t, assembly, declarations, count)
+}
diff --git a/amd64_fixed_local_counted_loop_update_gap_runtime_linux_go127_test.go b/amd64_fixed_local_counted_loop_update_gap_runtime_linux_go127_test.go
new file mode 100644
index 000000000..46c82e05d
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_update_gap_runtime_linux_go127_test.go
@@ -0,0 +1,24 @@
+//go:build linux && (amd64 || arm64) && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalCountedLoopUpdateGap(t *testing.T) {
+	assembly, declarations, count := fixedLocalCountedLoopUpdateGapProgram(t)
+	inputs := fixedLocalCountedLoopRuntimeInputs()
+	var expected [][]string
+	for _, input := range inputs {
+		values := make([]string, count)
+		for index := range values {
+			values[index] = fmt.Sprintf("%016x", input+2)
+		}
+		expected = append(expected, values)
+	}
+	// Original Go executes the Y-register moves. Require actual AVX and
+	// enabled OS register state before either source program runs.
+	fixedLocalResultsRuntimeISA(t, assembly, declarations, inputs, expected, x86FloatCompareVEX)
+}
diff --git a/amd64_fixed_local_counted_loop_update_gap_test.go b/amd64_fixed_local_counted_loop_update_gap_test.go
new file mode 100644
index 000000000..ea36c8364
--- /dev/null
+++ b/amd64_fixed_local_counted_loop_update_gap_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalCountedLoopUpdateGapCases() []fixedLocalCountedLoopCase {
+	var cases []fixedLocalCountedLoopCase
+	for _, register := range strings.Fields("AX BX CX DX SI DI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+		scratch := "AX"
+		if register == scratch {
+			scratch = "BX"
+		}
+		for _, operation := range []string{"ADDQ", "SUBQ", "INCQ", "DECQ"} {
+			first, bound, branch := 0, 3, "JB"
+			if operation == "SUBQ" || operation == "DECQ" {
+				first, bound, branch = 3, 0, "JA"
+			}
+			update := operation + " " + register
+			if operation == "ADDQ" || operation == "SUBQ" {
+				update = operation + " $1," + register
+			}
+			for _, gap := range []struct{ name, initialize, body string }{
+				{"NOP", "", "NOP"},
+				{"GP and flags", "", fmt.Sprintf("MOVQ %s,%s\nADDQ $3,%s", register, scratch, scratch)},
+				{"two vector moves", "MOVQ $0,64(SP)\nMOVQ $0,72(SP)\nMOVQ $0,80(SP)\nMOVQ $0,88(SP)\n" +
+					"VMOVDQU 64(SP),Y6\nVMOVDQU Y6,Y7\n", "VMOVDQU Y6,Y4\nVMOVDQU Y7,Y5"},
+				{"private word", "", "MOVQ $7,64(SP)\nMOVQ 64(SP)," + scratch},
+			} {
+				body := gap.initialize + fmt.Sprintf("MOVQ $%d,%s\nloop:\n"+
+					"MOVQ $7,16(SP)(%s*8)\n%s\n%s\nCMPQ %s,$%d\n%s loop\nMOVQ 24(SP),AX",
+					first, register, register, update, gap.body, register, bound, branch)
+				name := register + "/" + operation + "/" + gap.name
+				cases = append(cases, fixedLocalCountedLoopCase{name, body, 3})
+			}
+		}
+	}
+	return cases
+}
+
+func TestGoAMD64FixedLocalCountedLoopUpdateGap(t *testing.T) {
+	cases := fixedLocalCountedLoopUpdateGapCases()
+	if len(cases) != 240 {
+		t.Fatal("15 counters by four updates and four typed gaps changed", len(cases))
+	}
+	var original strings.Builder
+	for index, row := range cases {
+		_, _, source := fixedLocalCountedLoopFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, row := range cases {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalCountedLoopFixture(t, row.body)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("typed instructions preserving the counter must not hide its unique update", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalCountedLoopUpdateGapRejectsCounterChanges(t *testing.T) {
+	const prefix = "MOVQ $0,SI\nloop:\nMOVQ $7,16(SP)(SI*8)\n"
+	const suffix = "CMPQ SI,$3\nJB loop\nMOVQ 32(SP),AX"
+	type example struct{ name, body string }
+	var cases []example
+	for _, row := range []struct{ name, middle string }{
+		{"changed before update", "MOVQ $7,SI\nADDQ $1,SI\nNOP\n"},
+		{"changed after update", "ADDQ $1,SI\nMOVQ $7,SI\n"},
+		{"partial before update", "ADDB $1,SI\nADDQ $1,SI\nNOP\n"},
+		{"partial after update", "ADDQ $1,SI\nADDB $1,SI\n"},
+		{"zero-extended counter", "ADDQ $1,SI\nMOVL SI,SI\n"},
+		{"two updates", "ADDQ $1,SI\nNOP\nINCQ SI\nNOP\n"},
+		{"canceling updates", "ADDQ $1,SI\nNOP\nSUBQ $1,SI\nNOP\n"},
+		{"partial counter alias", "MOVQ SI,AX\nADDQ $1,SI\nMOVB AL,SI\n"},
+		{"unknown counter replacement", "ADDQ $1,SI\nMOVQ a+0(FP),SI\n"},
+	} {
+		cases = append(cases, example{row.name, prefix + row.middle + suffix})
+	}
+	// LAHF has a typed implicit AH write; FLAGS are initialized by CMP.
+	// An otherwise unsupported string instruction would fail too early to
+	// establish that the counter guard sees implicit register writes.
+	implicit := prefix + "ADDQ $1,SI\nCMPQ SI,SI\nLAHF\n" + suffix
+	cases = append(cases, example{"implicit counter write", strings.ReplaceAll(implicit, "SI", "AX")})
+	var original strings.Builder
+	for index, row := range cases {
+		fn, sig, source := fixedLocalCountedLoopFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			for _, instruction := range fn.Instrs {
+				if !fixedLocalInstructionShape(instruction) {
+					t.Fatal("counter negative needs registered typed instructions", instruction.Raw)
+				}
+			}
+			if _, err := proveX86FixedLocal(fn, sig); err == nil {
+				t.Fatal("a changed counter or latch comparison acquired complete iteration authority")
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_data.go b/amd64_fixed_local_data.go
new file mode 100644
index 000000000..650f571e5
--- /dev/null
+++ b/amd64_fixed_local_data.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"bytes"
+	"strings"
+)
+
+type x86FixedLocalData struct {
+	size, alignment int64
+	literals        map[int64]x86ShiftLiteral
+}
+
+type x86FixedLocalMemoryRole uint8
+
+const (
+	x86FixedLocalPrivateMemory x86FixedLocalMemoryRole = iota
+	x86FixedLocalLiteralMemory
+	x86FixedLocalNativeInput
+)
+
+func fixedLocalDataSymbol(symbol string) (string, bool) {
+	name := strings.TrimPrefix(symbol, "·")
+	if !strings.HasSuffix(name, "<>") || len(name) <= 2 || strings.ContainsAny(name, "·/.") {
+		return "", false
+	}
+	return "·" + name, true
+}
+
+// Library callers preserve the private <> spelling; the ordinary CLIs render
+// it as $local. Both describe the same source-local LLVM namespace, not the
+// original Go object's name/ABI. Never accept an arbitrary caller renaming.
+func fixedLocalDataEmissionMatches(symbol, packagePath, emitted string) bool {
+	canonical := numericalNativeName(symbol, packagePath)
+	return emitted == canonical || emitted == strings.TrimSuffix(canonical, "<>")+"$local"
+}
+
+// Called under the original source lock after its whole parsed file has been
+// matched. Private literal definitions cannot be replaced by a Go variable,
+// linker winner, mutable global, address initializer or caller-supplied extent.
+func (source *GoAMD64FrameSource) fixedLocalData(file *File, expanded string, resolve func(string) string) (map[string]x86FixedLocalData, map[string]string, error) {
+	if len(file.Data)+len(file.Globl) == 0 {
+		return nil, nil, nil
+	}
+	observed, err := source.fixedLocalDataObservation(source.request.AssemblyFile, expanded)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(observed.Layouts) != len(file.Globl) {
+		return nil, nil, goAMD64FrameContext("fixed local DATA lacks its whole original definition inventory")
+	}
+	data := make(map[string]x86FixedLocalData)
+	requests := x86PackedLogicalLiteralRequests(file, "amd64")
+	symbols := make(map[string]string)
+	// BindFixedLocal has already frozen the resolver outside the source lock.
+	// Keep every emitted definition injective, including the complete TEXT set.
+	used := make(map[string]bool, len(file.Funcs)+len(file.Globl))
+	for _, fn := range file.Funcs {
+		name := resolve(fn.Sym)
+		if name == "" || used[name] {
+			return nil, nil, goAMD64FrameContext("fixed local emitted function identities are empty or collapsed")
+		}
+		used[name] = true
+	}
+	var total int64
+	for index, global := range file.Globl {
+		layout := observed.Layouts[index]
+		definition := layout.Definition
+		name, private := fixedLocalDataSymbol(global.Sym)
+		emitted := resolve(name)
+		if _, duplicate := symbols[name]; duplicate {
+			return nil, nil, goAMD64FrameContext("fixed local DATA definitions collapse to the same translated identity")
+		}
+		if !private || !fixedLocalDataEmissionMatches(name, source.selection.ImportPath, emitted) || used[emitted] {
+			return nil, nil, goAMD64FrameContext("fixed local DATA resolver changed or collapsed its private emitted identity")
+		}
+		used[emitted] = true
+		total += int64(definition.Size)
+		if !layout.Static || layout.ABI != 65535 ||
+			layout.Flags != 8 && layout.Flags != 24 || definition.Kind != 3 && definition.Kind != 4 || definition.Flags != 0 ||
+			definition.Flags2 != 0 || len(definition.Relocations) != 0 || global.SizeRaw != "" ||
+			definition.Size == 0 || definition.Size > 64<<10 || total > 1<<20 || len(definition.Data) > int(definition.Size) {
+			return nil, nil, goAMD64FrameContext("fixed local DATA requires bounded private relocation-free readonly storage")
+		}
+		// Compare the translator's complete initializer with independent actual
+		// Go bytes, including sparse zero gaps and trailing allocation. A GLOBL
+		// that shortens preceding DATA must not acquire a larger LLVM extent.
+		image := make([]byte, definition.Size)
+		size := global.Size
+		for _, fragment := range file.Data {
+			if fragment.Sym != global.Sym {
+				continue
+			}
+			payload, err := dataStmtPayload(fragment)
+			if err != nil || fragment.Addr != "" || fragment.Off < 0 || fragment.Off > int64(len(image))-int64(len(payload)) {
+				return nil, nil, goAMD64FrameContext("fixed local DATA initializer has an unbound source byte extent")
+			}
+			copy(image[fragment.Off:], payload)
+			if end := fragment.Off + int64(len(payload)); end > size {
+				size = end
+			}
+		}
+		if size != int64(definition.Size) || !bytes.Equal(image[:len(definition.Data)], definition.Data) ||
+			!bytes.Equal(image[len(definition.Data):], make([]byte, len(image)-len(definition.Data))) {
+			return nil, nil, goAMD64FrameContext("fixed local translated DATA differs from the original Go initialized extent")
+		}
+		literal := x86FixedLocalData{size: size, alignment: goAssemblyDataAlignment(ArchAMD64, size)}
+		for offset, width := range requests[global.Sym] {
+			if offset > size-int64(width) {
+				continue // The ordinary full access check owns this rejection.
+			}
+			if literal.literals == nil {
+				literal.literals = make(map[int64]x86ShiftLiteral)
+			}
+			tuple := x86ShiftLiteral{width: uint8(width)}
+			copy(tuple.bytes[:], image[offset:offset+int64(width)])
+			literal.literals[offset] = tuple
+		}
+		data[global.Sym] = literal
+		symbols[name] = emitted
+	}
+	return data, symbols, nil
+}
+
+// Project only immutable original DATA facts while constructing the local
+// effect plan. The full memory read and its bounds/alignment remain unchanged.
+func fixedLocalLogicalLiteralEffect(ins Instr, effect x86TypedByteEffect, binding *x86FixedLocalBinding) x86TypedByteEffect {
+	if binding == nil || len(ins.Args) == 0 || ins.Args[0].Kind != OpSym {
+		return effect
+	}
+	form, known, err := x86PackedLogicalProperties(ins, "amd64")
+	if !known || err != nil || form.memory != form.first || form.memoryBytes <= 0 {
+		return effect
+	}
+	address, valid := x86StaticSBReadAddress(form.source, "amd64")
+	literal := binding.literalData[address.symbol].literals[address.offset]
+	if !valid || int(literal.width) < form.memoryBytes {
+		return effect
+	}
+	var required uint64
+	for index := 0; index < form.byteWidth; index++ {
+		if x86PackedLogicalSecondBits(form.spec.mode, literal.bytes[index%form.memoryBytes]) != 0 {
+			required |= uint64(1) << uint(index)
+		}
+	}
+	if required == x86CallerVectorByteMask(int64(form.byteWidth)) {
+		return effect
+	}
+	effect.operands = append([]x86TypedByteOperand(nil), effect.operands...)
+	for index := range effect.operands {
+		operand := &effect.operands[index]
+		if operand.index == form.second && operand.operand.Kind == OpReg {
+			// requiredBytes zero otherwise means the ordinary full-width read.
+			operand.read, operand.requiredBytes = required != 0, required
+		}
+	}
+	return effect
+}
+
+// Readonly DATA never receives a frame offset or a native-frame certificate.
+// The only consumer is an already registered numerical memory operand. The
+// complete original file and immutable symbol resolution own its LLVM global.
+func fixedLocalReadMemory(ins *Instr, index int, state *x86FixedLocalState, proof *x86FixedLocalProof,
+	residue int, width, alignment int64) (offset int64, role x86FixedLocalMemoryRole, err error) {
+	if index >= 0 && index < len(ins.Args) && ins.Args[index].Kind == OpSym {
+		if proof.binding == nil || width <= 0 || alignment <= 0 {
+			return 0, x86FixedLocalLiteralMemory, goAMD64FrameContext("fixed local DATA read has no original literal owner")
+		}
+		name, offset, valid := parseSBRef(ins.Args[index].Sym)
+		if !valid || !fixedLocalLiteralRange(proof.binding, x86StaticSBAddress{name, offset}, width, alignment) {
+			return 0, x86FixedLocalLiteralMemory, goAMD64FrameContext("fixed local DATA read exceeds original identity, extent or alignment")
+		}
+		return offset, x86FixedLocalLiteralMemory, nil
+	}
+	return fixedLocalMemoryAccess(ins, index, state, proof, residue, width, alignment, false, false)
+}
+
+func fixedLocalLiteralRange(binding *x86FixedLocalBinding, address x86StaticSBAddress, width, alignment int64) bool {
+	if binding == nil || width <= 0 || alignment <= 0 {
+		return false
+	}
+	data, found := binding.literalData[address.symbol]
+	return found && address.offset >= 0 && width <= data.size && address.offset <= data.size-width &&
+		alignment <= data.alignment && address.offset%alignment == 0
+}
+
+func fixedLocalStaticAddressStep(ins Instr, state *x86FixedLocalState, proof *x86FixedLocalProof) (bool, error) {
+	address, valid := fixedLocalStaticAddress(ins)
+	if !valid {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local address has no matching original storage: %s", ins.Op)
+	}
+	if proof == nil || proof.binding == nil {
+		return fail()
+	}
+	var origin x86FixedLocalOrigin
+	if _, literal := proof.binding.literalData[address.symbol]; literal {
+		// Address computation may leave an object before returning. A later
+		// exact access owns its bounds diagnostic, never adjacent storage.
+		origin.literal = address
+	} else {
+		object, found := proof.binding.globals[fixedLocalGlobalSymbol(address.symbol)]
+		if ins.Op == "LEAQ" || !found || object.variable == nil || object.native == "" {
+			return fail()
+		}
+		origin.global = object.native
+	}
+	writeFixedLocalOrigin(state, ins.Args[1].Reg, fixedLocalOrigin(origin))
+	return true, nil
+}
+
+func writeFixedLocalOrigin(state *x86FixedLocalState, destination Reg, origin x86FixedLocalOrigins) {
+	state.revokeRange(destination)
+	delete(state.pointers, destination)
+	delete(state.constants, destination)
+	state.opaque[destination], state.known[destination], state.booleans[destination] = origin, 0, 0
+}
diff --git a/amd64_fixed_local_data_address_go127_test.go b/amd64_fixed_local_data_address_go127_test.go
new file mode 100644
index 000000000..586cb8fbf
--- /dev/null
+++ b/amd64_fixed_local_data_address_go127_test.go
@@ -0,0 +1,294 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const fixedLocalAddressData = "DATA literal<>+0(SB)/8,$0x0102030405060708\n" +
+	"DATA literal<>+8(SB)/8,$0x1112131415161718\n" +
+	"DATA literal<>+16(SB)/8,$0x2122232425262728\n" +
+	"DATA literal<>+24(SB)/8,$0x3132333435363738\nGLOBL literal<>(SB),8,$32\n"
+
+func fixedLocalDataAddressFunction(name, body string) string {
+	return fmt.Sprintf("TEXT ·%s(SB),4,$32-16\nMOVQ a+0(FP),CX\nMOVQ $0,DX\n%s\nMOVQ DX,ret+8(FP)\nRET\n", name, body)
+}
+
+func fixedLocalDataAddressKernels() (string, string, int) {
+	var assembly, declarations strings.Builder
+	assembly.WriteString(fixedLocalAddressData)
+	count := 0
+	// The register inventory is independent of the translator's bank helper.
+	// SP is the private frame, not an ordinary destination for a DATA address.
+	for _, register := range strings.Fields("AX BX CX DX DI SI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+		for _, address := range []string{"MOVQ $literal<>(SB),", "LEAQ literal<>(SB),"} {
+			name := fmt.Sprintf("Value%d", count)
+			body := fmt.Sprintf(`%s%s
+MOVQ %s,8(SP)
+MOVQ $0,%s
+MOVQ 8(SP),%s
+ADDQ $16,%s
+SUBQ $8,%s
+LEAQ 8(%s),%s
+INCQ %s
+DECQ %s
+MOVOU (%s),X0
+PADDQ X0,X0
+MOVQ X0,DX`, address, register, register, register, register,
+				register, register, register, register, register, register, register)
+			assembly.WriteString(fixedLocalDataAddressFunction(name, body))
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			count++
+		}
+	}
+	return assembly.String(), declarations.String(), count
+}
+
+func TestGoAMD64FixedLocalReadonlyDataAddressObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, count := fixedLocalDataAddressKernels()
+	if count != 30 {
+		t.Fatal("complete GP bank/address grammar denominator changed", count)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("bounded readonly DATA addresses must compose with the complete private frame", err)
+					}
+					if !strings.Contains(ir, "internal constant [32 x i8]") {
+						t.Fatal("original private readonly DATA definition missing")
+					}
+					compileLLVMToObject(t, llc, target.triple, "data-address.ll", "data-address.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "data-address-opt.ll", "data-address-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+	t.Log("30 original-Go kernels: two address forms, full non-SP GP bank, complete spills and constant affine offsets; three APIs at O0/O2")
+}
+
+func TestGoAMD64FixedLocalReadonlyDataAddressGuards(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	const acquire = "LEAQ literal<>(SB),SI\n"
+	// These complete machine addresses need their original storage, but not a
+	// universal bound for every possible invocation. This is translation only.
+	dynamic := map[string]bool{
+		"unknown affine offset":  true,
+		"unknown index":          true,
+		"joined offset past end": true,
+		"numeric pointer":        true,
+	}
+	for _, row := range []struct{ name, body string }{
+		{"past end", acquire + "MOVQ 25(SI),DX"},
+		{"negative", acquire + "MOVQ -1(SI),DX"},
+		{"affine past end", acquire + "ADDQ $25,SI\nMOVQ (SI),DX"},
+		{"affine negative", acquire + "SUBQ $1,SI\nMOVQ (SI),DX"},
+		{"initial displacement", "LEAQ literal<>+25(SB),SI\nMOVQ (SI),DX"},
+		{"unaligned", acquire + "INCQ SI\nMOVO (SI),X0"},
+		{"unknown affine offset", acquire + "ADDQ CX,SI\nMOVQ (SI),DX"},
+		{"unknown index", acquire + "MOVQ (SI)(CX*1),DX"},
+		{"offset overflow", acquire + "MOVQ $9223372036854775807,R8\nADDQ R8,SI\nINCQ SI\nMOVQ (SI),DX"},
+		{"joined offset past end", acquire + "CMPQ CX,$0\nJEQ joined\nADDQ $32,SI\njoined:\nMOVQ (SI),DX"},
+		{"joined readonly write", acquire + "CMPQ CX,$0\nJEQ joined\nADDQ $8,SI\njoined:\nMOVQ DX,(SI)"},
+		{"partial spill", acquire + "MOVL SI,8(SP)\nMOVQ 8(SP),SI\nMOVQ (SI),DX"},
+		{"write", acquire + "MOVQ DX,(SI)"},
+		{"write after spill", acquire + "MOVQ SI,8(SP)\nMOVQ 8(SP),BP\nMOVQ DX,(BP)"},
+		{"numeric result", acquire + "MOVQ SI,DX"},
+		{"numeric pointer", "MOVQ $1234,SI\nMOVQ (SI),DX"},
+		{"unowned symbol", "MOVQ $foreign(SB),SI\nMOVQ (SI),DX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalAddressData + fixedLocalDataAddressFunction("Value", row.body)
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			// Capture must succeed first: a producer/tool failure does not
+			// establish that the translator rejects an unsafe memory role.
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if dynamic[row.name] {
+				if err != nil {
+					t.Fatal("dynamic native address incorrectly required a caller bounds proof", err)
+				}
+				if row.name == "numeric pointer" {
+					proved, err := proveX86FixedLocal(file.Funcs[0], bound.Sigs[pkg.Path+".Value"])
+					if err != nil {
+						t.Fatal(err)
+					}
+					fixedLocalRequireNumericNativeRole(t, proved, SI)
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("readonly address acquired unknown bytes, alignment, mutable or numerical permission", err)
+			}
+		})
+	}
+	t.Run("different bounded offsets at join", func(t *testing.T) {
+		assembly := fixedLocalAddressData + fixedLocalDataAddressFunction("Value",
+			acquire+"CMPQ CX,$0\nJEQ joined\nADDQ $8,SI\njoined:\nMOVQ (SI),DX")
+		pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+			"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc required")
+		}
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal("both readonly alternatives must retain their bounded read", err)
+				}
+				compileLLVMToObject(t, llc, options.TargetTriple, "joined-data.ll", "joined-data.o", ir)
+				compileLLVMToObject(t, llc, options.TargetTriple, "joined-data-opt.ll", "joined-data-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+	})
+	t.Run("pointer result cannot escape its bounds", func(t *testing.T) {
+		assembly := fixedLocalAddressData + "TEXT ·Value(SB),4,$32-8\n" + acquire + "MOVQ SI,ret+0(FP)\nRET\n"
+		pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+			"func Value() *uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+		source := requireGoAMD64FrameCapture(t, pkg, request)
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("private literal escaped as an unbounded externally mutable pointer", err)
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalReadonlyDataAddressBinding(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly := fixedLocalAddressData + fixedLocalDataAddressFunction("Value",
+		"MOVQ SP,R12\nADDQ $16,R12\nANDQ $-16,R12\n"+
+			"MOVQ $literal<>+8(SB),BP\nMOVQ BP,(R12)\nMOVQ (R12),R14\nMOVQ 16(R14),DX")
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+		"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+	fixedLocalDataAPIs(t, pkg, file, assembly, options, fixedLocalRequireContext)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("actual original DATA address failed binding", err)
+	}
+	for _, mutation := range []string{"resolver", "JSON", "byte", "extent"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed, input := bound, assembly
+			switch mutation {
+			case "resolver":
+				changed.ResolveSym = func(symbol string) string {
+					if symbol == "·literal<>" {
+						return "foreign.literal<>"
+					}
+					return options.ResolveSym(symbol)
+				}
+			case "JSON":
+				changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+				if err != nil {
+					t.Fatal(err)
+				}
+			case "byte":
+				input = strings.Replace(input, "0x3132333435363738", "0x3132333435363739", 1)
+			case "extent":
+				input = strings.Replace(input, ",8,$32", ",8,$64", 1)
+			}
+			parsed, err := Parse(ArchAMD64, input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalDataAPIs(t, pkg, parsed, input, changed, fixedLocalRequireContext)
+		})
+	}
+	path := filepath.Join(request.Directory, request.AssemblyFile)
+	changed := strings.Replace(assembly, "0x3132333435363738", "0x3132333435363739", 1)
+	if err := os.WriteFile(path, []byte(changed), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalDataAPIs(t, pkg, file, assembly, bound, fixedLocalRequireContext)
+	if err := os.WriteFile(path, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalDataAPIs(t, pkg, file, assembly, bound, fixedLocalRequireContext)
+}
+
+func TestGoAMD64FixedLocalReadonlyDataAddressLayoutFlags(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const acquire = "LEAQ literal<>(SB),SI\n"
+	const other = "DATA other<>+0(SB)/8,$77\nGLOBL other<>(SB),8,$32\n"
+	for _, row := range []struct {
+		name, body string
+		emit       bool
+	}{
+		{"ADD carry", acquire + "ADDQ $8,SI\nSETCS DL", true},
+		{"SUB carry", acquire + "ADDQ $8,SI\nSUBQ $8,SI\nSETCS DL", true},
+		{"INC zero", acquire + "INCQ SI\nSETEQ DL", true},
+		{"DEC zero", acquire + "ADDQ $8,SI\nDECQ SI\nSETEQ DL", true},
+		{"cross literal comparison", acquire + "LEAQ other<>(SB),DI\nCMPQ SI,DI\nSETCS DL", true},
+		{"literal numerical comparison", acquire + "CMPQ SI,$1234\nSETCS DL", true},
+		{"spilled literal comparison", acquire + "MOVQ SI,8(SP)\nCMPQ 8(SP),$0\nSETEQ DL", true},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalAddressData + other + fixedLocalDataAddressFunction("Value", row.body)
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			if row.emit {
+				// Preserve the actual machine operation. Compiling independent
+				// globals does not promise Go's final linked addresses, relative
+				// ordering or cross-object adjacency; this is object evidence.
+				fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+					func(t *testing.T, ir string, err error) {
+						if err != nil {
+							t.Fatal("complete native address FLAGS source rejected", err)
+						}
+						x86CompactExpandRequireAllDefinitions(t, ir, []string{pkg.Path + ".Value"})
+						compileLLVMToObject(t, llc, options.TargetTriple, "address-flags.ll", "address-flags.o", ir)
+						compileLLVMToObject(t, llc, options.TargetTriple, "address-flags-opt.ll", "address-flags-opt.o", x86MulDivRoundOptimize(t, ir))
+					})
+				return
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unsupported literal/immediate comparator acquired an address role", err)
+			}
+		})
+	}
+	for _, row := range []struct{ name, body string }{
+		{"LEA preserves flags", "CMPQ CX,$1\n" + acquire + "LEAQ 8(SI),SI\nSETEQ DL"},
+		{"INC preserves carry", "CMPQ CX,$1\n" + acquire + "INCQ SI\nSETCS DL"},
+		{"DATA bytes are numeric", acquire + "CMPQ (SI),$0\nSETNE DL"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalAddressData + fixedLocalDataAddressFunction("Value", row.body)
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil || ir == "" {
+						t.Fatal("unaffected numerical FLAGS were lost across a DATA address operation", err)
+					}
+				})
+		})
+	}
+}
diff --git a/amd64_fixed_local_data_address_runtime_go127_test.go b/amd64_fixed_local_data_address_runtime_go127_test.go
new file mode 100644
index 000000000..e9f437992
--- /dev/null
+++ b/amd64_fixed_local_data_address_runtime_go127_test.go
@@ -0,0 +1,162 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalReadonlyDataAddress(t *testing.T) {
+	assembly, declarations, count := fixedLocalDataAddressKernels()
+	if count != 30 {
+		t.Fatal("complete DATA address runtime inventory changed", count)
+	}
+	expected := make([]string, count)
+	for index := range expected {
+		// The source DATA's third qword is loaded and added to itself.
+		expected[index] = "424446484a4c4e50"
+	}
+	fixedLocalConstantResultsRuntime(t, assembly, declarations, expected)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConstantIndex(t *testing.T) {
+	cases := fixedLocalConstantIndexCases()
+	if len(cases) != 30 {
+		t.Fatal("complete constant index runtime inventory changed", len(cases))
+	}
+	var assembly, declarations strings.Builder
+	assembly.WriteString(fixedLocalAddressData)
+	var expected []string
+	for index, row := range cases {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(fixedLocalConstantIndexFunction(name, row.body))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		// Indexed and fixed-address reads each sum to 19+20+22+26, plus
+		// the adjacent private canary 77. The fixed tail is reset each time.
+		value := "00000000000000fb"
+		if row.literal {
+			value = "64686c7074787c80" // Sum of the four independent source DATA qwords.
+		}
+		expected = append(expected, value)
+	}
+	fixedLocalConstantResultsRuntime(t, assembly.String(), declarations.String(), expected)
+}
+
+func fixedLocalConstantResultsRuntime(t *testing.T, assembly, declarations string, expected []string) {
+	t.Helper()
+	fixedLocalResultsRuntime(t, assembly, declarations, []uint64{^uint64(0)}, [][]string{expected})
+}
+
+func fixedLocalResultsRuntime(t *testing.T, assembly, declarations string, inputs []uint64, expected [][]string) {
+	t.Helper()
+	fixedLocalResultsRuntimeISA(t, assembly, declarations, inputs, expected, x86FloatCompareSSE)
+}
+
+func fixedLocalResultsRuntimeISA(t *testing.T, assembly, declarations string, inputs []uint64, expected [][]string, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	if len(inputs) == 0 || len(expected) != len(inputs) || len(expected[0]) == 0 {
+		t.Fatal("invalid fixed-local runtime input/result inventory")
+	}
+	count := len(expected[0])
+	var values []string
+	for index, row := range expected {
+		if len(row) != count {
+			t.Fatal("inconsistent fixed-local runtime result count", index, len(row), count)
+		}
+		values = append(values, row...)
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	goAMD64FramePrepareOwnedToolCache(t)
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	var goCalls, cDeclarations, cCalls strings.Builder
+	for index := 0; index < count; index++ {
+		label := runtimeCAsmLabel(prefix + fmt.Sprintf("example.invalid/framefixture.Value%d", index))
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t) __asm__(%s);\n", index, label)
+	}
+	for _, input := range inputs {
+		for index := 0; index < count; index++ {
+			fmt.Fprintf(&goCalls, "fmt.Printf(\"%%016x\\n\",Value%d(uint64(0x%x)))\n", index, input)
+			fmt.Fprintf(&cCalls, "printf(\"%%016llx\\n\",(unsigned long long)value%d(UINT64_C(0x%x)));\n", index, input)
+		}
+	}
+	original := "package main\nimport \"fmt\"\n" + declarations + "func main() {\n" + goCalls.String() + "}\n"
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))), "\n")
+	if len(want) != len(values) {
+		t.Fatal("original Go fixed-local output inventory changed", len(want), len(values))
+	}
+	for index, value := range want {
+		if value != values[index] {
+			t.Fatalf("original Go kernel %d input %#x returned %s, want %s", index%count, inputs[index/count], value, values[index])
+		}
+	}
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + runtimeCAsmLabelPreamble +
+		cDeclarations.String() + "int main(void) {\n" + cCalls.String() + "return 0;\n}\n"
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	check := func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(level, func(t *testing.T) {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				output := execution.compileAndRunLLVM(t, "fixed-local-results", input, driver, level)
+				got := strings.Split(strings.TrimSpace(string(output)), "\n")
+				if len(got) != len(want) {
+					t.Fatal("LLVM fixed-local output inventory changed", len(got), len(want))
+				}
+				for index := range want {
+					if got[index] != want[index] {
+						t.Fatalf("fixed-local kernel %d input %#x: original %s, LLVM %s", index%count, inputs[index/count], want[index], got[index])
+					}
+				}
+			})
+		}
+	}
+	fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly, check)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("original Go and LLVM amd64 execute through Rosetta, not native x86 hardware")
+	}
+}
+
+func fixedLocalResultsRuntimeAPIs(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest,
+	file *File, options Options, assembly string, check func(*testing.T, string, error)) {
+	t.Helper()
+	apis := []string{"Translate", "Module", "GoModule"}
+	if fixedLocalResultsRuntimeNeedsBinding(file, options) {
+		fixedLocalFreshAPIs(t, pkg, request, options, apis, check)
+	} else {
+		// Ordinary sources require no private-frame observation or permission.
+		// Reuse the independent original Go and C drivers with their own APIs.
+		for _, api := range apis {
+			t.Run(api, func(t *testing.T) {
+				fixedLocalAPI(t, pkg, file, options, api, check, assembly)
+			})
+		}
+	}
+}
+
+func fixedLocalResultsRuntimeNeedsBinding(file *File, options Options) bool {
+	if file == nil || file.Arch != ArchAMD64 || len(file.Funcs) == 0 || options.NumericalReads != nil {
+		return true
+	}
+	for _, fn := range file.Funcs {
+		if fn.FrameSize != 0 || fn.x86FixedLocal != nil || fn.x86SourceStack != nil {
+			return true
+		}
+	}
+	for _, sig := range options.Sigs {
+		if sig.x86FixedLocal != nil {
+			return true
+		}
+	}
+	return false
+}
diff --git a/amd64_fixed_local_data_go127_test.go b/amd64_fixed_local_data_go127_test.go
new file mode 100644
index 000000000..8e0e53e58
--- /dev/null
+++ b/amd64_fixed_local_data_go127_test.go
@@ -0,0 +1,89 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const fixedLocalLiteralData = "DATA literal<>+0(SB)/8,$0x0102030405060708\n" +
+	"DATA literal<>+8(SB)/8,$0x1112131415161718\nGLOBL literal<>(SB),8,$32\n"
+
+func fixedLocalDataFixture(t *testing.T, operation, data string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options, string) {
+	t.Helper()
+	pkg, request, _, options := fixedLocalFrameFixture(t, operation)
+	name := filepath.Join(request.Directory, request.AssemblyFile)
+	original, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly := data + string(original)
+	if err := os.WriteFile(name, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, request, file, options, assembly
+}
+
+func fixedLocalDataCLIOptions(options Options) Options {
+	resolve := options.ResolveSym
+	options.ResolveSym = func(symbol string) string {
+		name := resolve(symbol)
+		if strings.HasSuffix(symbol, "<>") {
+			return strings.TrimSuffix(name, "<>") + "$local"
+		}
+		return name
+	}
+	return options
+}
+
+func TestGoAMD64FixedLocalReadonlyDataThreeTargetObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			for _, spelling := range []string{"source", "CLI"} {
+				t.Run(spelling, func(t *testing.T) {
+					pkg, request, _, options, assembly := fixedLocalDataFixture(t,
+						"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0", fixedLocalLiteralData)
+					request.Target, options.TargetTriple = target.name, target.triple
+					if spelling == "CLI" {
+						options = fixedLocalDataCLIOptions(options)
+					}
+					x86LEAActualTargetGoObject(t, "amd64", target.triple, assembly)
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+						if err != nil || !strings.Contains(ir, "internal constant [32 x i8]") || !strings.Contains(ir, "fixed_local_native") {
+							t.Fatal("missing joined private DATA/frame translation", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "data-frame.ll", "data-frame.o", ir)
+						compileLLVMToObject(t, llc, target.triple, "data-frame-opt.ll", "data-frame-opt.o", x86MulDivRoundOptimize(t, ir))
+					})
+				})
+			}
+		})
+	}
+}
+
+func fixedLocalDataAPIs(t *testing.T, pkg GoPackage, file *File, assembly string, options Options, check func(*testing.T, string, error)) {
+	t.Helper()
+	// Negative/mutation callers deliberately keep their supplied binding. Never
+	// renew an expired or revoked observation while testing its rejection.
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			fixedLocalAPI(t, pkg, file, options, api, check, assembly)
+		})
+	}
+}
diff --git a/amd64_fixed_local_data_guards_go127_test.go b/amd64_fixed_local_data_guards_go127_test.go
new file mode 100644
index 000000000..a201f737c
--- /dev/null
+++ b/amd64_fixed_local_data_guards_go127_test.go
@@ -0,0 +1,168 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalReadonlyDataConsumerIdentity(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request, file, options, assembly := fixedLocalDataFixture(t,
+		"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0", fixedLocalLiteralData)
+	fixedLocalDataAPIs(t, pkg, file, assembly, options, fixedLocalRequireContext)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"resolver", "JSON", "byte", "extent", "flags", "missing DATA", "new DATA"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed, input := bound, assembly
+			switch mutation {
+			case "resolver":
+				changed.ResolveSym = func(symbol string) string {
+					if symbol == "·literal<>" {
+						return "foreign.literal<>"
+					}
+					return options.ResolveSym(symbol)
+				}
+			case "JSON":
+				changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+				if err != nil {
+					t.Fatal(err)
+				}
+			case "byte":
+				input = strings.Replace(input, "0x0102030405060708", "0x0102030405060709", 1)
+			case "extent":
+				input = strings.Replace(input, ",8,$32", ",8,$64", 1)
+			case "flags":
+				input = strings.Replace(input, ",8,$32", ",16,$32", 1)
+			case "missing DATA":
+				input = strings.TrimPrefix(input, fixedLocalLiteralData)
+			case "new DATA":
+				input = "GLOBL extra<>(SB),8,$8\n" + input
+			}
+			parsed, err := Parse(ArchAMD64, input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalDataAPIs(t, pkg, parsed, input, changed, fixedLocalRequireContext)
+		})
+	}
+	// A callback's later answer cannot replace the already verified symbol.
+	t.Run("stateful", func(t *testing.T) {
+		calls := 0
+		changed := bound
+		changed.ResolveSym = func(symbol string) string {
+			if symbol == "·literal<>" {
+				calls++
+				if calls > 1 {
+					return "foreign.literal<>"
+				}
+			}
+			return options.ResolveSym(symbol)
+		}
+		// Each API gets a fresh callback counter.
+		fixedLocalDataAPIs(t, pkg, file, assembly, changed, func(t *testing.T, ir string, err error) {
+			if err != nil || strings.Contains(ir, "foreign.literal") || calls != 1 {
+				t.Fatal("mutable resolver escaped sealed literal identity", calls, err)
+			}
+			calls = 0
+		})
+	})
+	path := filepath.Join(request.Directory, request.AssemblyFile)
+	changed := strings.Replace(assembly, "0x0102030405060708", "0x0102030405060709", 1)
+	if err := os.WriteFile(path, []byte(changed), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalDataAPIs(t, pkg, file, assembly, bound, fixedLocalRequireContext)
+	if err := os.WriteFile(path, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalDataAPIs(t, pkg, file, assembly, bound, fixedLocalRequireContext)
+}
+
+func TestGoAMD64FixedLocalReadonlyDataRejectsCoalescedDefinitions(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	// Go's bare and qualified static names are distinct definitions. The
+	// ordinary LLVM resolver cannot fold them into one global in a binding.
+	data := fixedLocalLiteralData + "DATA ·literal<>+0(SB)/8,$99\nGLOBL ·literal<>(SB),8,$32\n"
+	pkg, request, file, options, assembly := fixedLocalDataFixture(t,
+		"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0", data)
+	x86LEAActualTargetGoObject(t, "amd64", options.TargetTriple, assembly)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("distinct original globals acquired one LLVM identity", err)
+	}
+}
+
+func TestGoAMD64FixedLocalReadonlyDataCLIEmissionIdentity(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request, file, options, assembly := fixedLocalDataFixture(t,
+		"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0", fixedLocalLiteralData)
+	options = fixedLocalDataCLIOptions(options)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("original private DATA cannot retain the CLI's existing local spelling", err)
+	}
+	for _, direction := range []string{"function to DATA", "DATA to function"} {
+		t.Run(direction, func(t *testing.T) {
+			changed := options
+			changed.ResolveSym = func(symbol string) string {
+				if direction == "function to DATA" && symbol == file.Funcs[0].Sym {
+					return options.ResolveSym("·literal<>")
+				}
+				if direction == "DATA to function" && symbol == "·literal<>" {
+					return options.ResolveSym(file.Funcs[0].Sym)
+				}
+				return options.ResolveSym(symbol)
+			}
+			if _, err := source.BindFixedLocal(ctx, pkg, file, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original TEXT and DATA acquired one emitted definition", err)
+			}
+		})
+	}
+	for _, name := range []string{"", "foreign.literal$local", pkg.Path + ".literal", pkg.Path + ".literal<>", options.ResolveSym(file.Funcs[0].Sym)} {
+		t.Run("changed-emission="+name, func(t *testing.T) {
+			changed := bound
+			changed.ResolveSym = func(symbol string) string {
+				if symbol == "·literal<>" {
+					return name
+				}
+				return options.ResolveSym(symbol)
+			}
+			fixedLocalDataAPIs(t, pkg, file, assembly, changed, fixedLocalRequireContext)
+		})
+	}
+	t.Run("stateful", func(t *testing.T) {
+		calls := 0
+		changed := bound
+		changed.ResolveSym = func(symbol string) string {
+			if symbol == "·literal<>" {
+				calls++
+				if calls > 1 {
+					return "foreign.literal$local"
+				}
+			}
+			return options.ResolveSym(symbol)
+		}
+		fixedLocalDataAPIs(t, pkg, file, assembly, changed, func(t *testing.T, ir string, err error) {
+			if err != nil || !strings.Contains(ir, "literal$local") || strings.Contains(ir, "foreign.literal") || calls != 1 {
+				t.Fatal("mutable resolver escaped the original DATA's sealed emission", calls, err)
+			}
+			calls = 0
+		})
+	})
+}
diff --git a/amd64_fixed_local_data_matrix_go127_test.go b/amd64_fixed_local_data_matrix_go127_test.go
new file mode 100644
index 000000000..f6abf9b78
--- /dev/null
+++ b/amd64_fixed_local_data_matrix_go127_test.go
@@ -0,0 +1,144 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalDataOperations() []string {
+	var operations []string
+	for _, name := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+		operations = append(operations, name+" literal<>+1(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0")
+	}
+	for _, name := range []string{"MOVO", "MOVOA", "MOVOU", "MOVAPS", "MOVAPD", "MOVUPS", "MOVUPD"} {
+		operations = append(operations, name+" literal<>(SB),X0")
+	}
+	for _, row := range fixedLocalPackedMoveOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			aligned := row.name == "VMOVDQA" || row.name == "VMOVAPD" || row.name == "VMOVAPS" ||
+				row.name == "VMOVDQA32" || row.name == "VMOVDQA64"
+			// Original Go's default assembly DATA alignment is at most 32.
+			// A 64-byte aligned memory instruction needs a separate witness.
+			if bank == "Z" && (!row.evex || aligned) {
+				continue
+			}
+			operations = append(operations, row.name+" literal<>(SB),"+bank+"0")
+			if row.evex {
+				operations = append(operations,
+					"KMOVQ AX,K1\n"+row.name+" literal<>(SB),K1,"+bank+"0",
+					"KMOVQ AX,K1\n"+row.name+".Z literal<>(SB),K1,"+bank+"0")
+			}
+		}
+	}
+	for _, name := range []string{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+		operations = append(operations, name+" literal<>+1(SB),K1\nKMOVQ K1,DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0")
+	}
+	for _, operation := range []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+	} {
+		operations = append(operations, strings.Replace(operation, "16(SP)", "literal<>(SB)", 1))
+	}
+	for _, name := range []string{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC"} {
+		operations = append(operations, name+" literal<>(SB),X0")
+	}
+	operations = append(operations, "AESKEYGENASSIST $255,literal<>(SB),X0")
+	for _, name := range []string{"VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST"} {
+		operations = append(operations, name+" literal<>(SB),X0,X0")
+	}
+	operations = append(operations, "VAESIMC literal<>(SB),X0", "VAESKEYGENASSIST $255,literal<>(SB),X0")
+	for _, name := range []string{"CMOVWEQ", "CMOVLEQ", "CMOVQEQ"} {
+		operations = append(operations, "CMPQ AX,AX\n"+name+" literal<>+1(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0")
+	}
+	return operations
+}
+
+func TestGoAMD64FixedLocalReadonlyDataLinuxRegisteredConsumers(t *testing.T) {
+	fixedLocalDataTargetConsumers(t, "linux/amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestGoAMD64FixedLocalReadonlyDataDarwinRegisteredConsumers(t *testing.T) {
+	fixedLocalDataTargetConsumers(t, "darwin/amd64", "x86_64-apple-darwin")
+}
+
+func TestGoAMD64FixedLocalReadonlyDataWindowsRegisteredConsumers(t *testing.T) {
+	fixedLocalDataTargetConsumers(t, "windows/amd64", "x86_64-pc-windows-msvc")
+}
+
+func fixedLocalDataTargetConsumers(t *testing.T, target, triple string) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	operations := fixedLocalDataOperations()
+	if len(operations) != 119 {
+		t.Fatal("complete literal consumer denominator changed", len(operations))
+	}
+	for start := 0; start < len(operations); start += 32 {
+		end := start + 32
+		if end > len(operations) {
+			end = len(operations)
+		}
+		t.Run(fmt.Sprintf("%s/batch%d", target, start/32), func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			assembly.WriteString(strings.Replace(fixedLocalLiteralData, "$32", "$64", 1))
+			for index := start; index < end; index++ {
+				name := fmt.Sprintf("Value%d", index)
+				body, _, _ := x86PrivateAlignedFrameAuditFixture(t, operations[index]+"\nPADDQ 16(SP),X0")
+				assembly.WriteString(strings.Replace(body, "·Value", "·"+name, 1))
+				fmt.Fprintf(&declarations, "func %s(a,b,c,d uint64) uint64\n", name)
+			}
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, assembly.String(), declarations.String(), target, triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "literal-consumers.ll", "literal-consumers.o", ir)
+				compileLLVMToObject(t, llc, triple, "literal-consumers-opt.ll", "literal-consumers-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+		})
+	}
+	t.Logf("independent literal consumer operations=%d; actual Go target=%s, three APIs, O0/O2; at most 32 functions/module", len(operations), target)
+}
+
+func TestGoAMD64FixedLocalReadonlyDataRejectsUnownedAccesses(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, row := range []struct{ name, operation, data string }{
+		{"past end", "MOVOU literal<>+24(SB),X0", fixedLocalLiteralData},
+		{"negative", "MOVQ literal<>-1(SB),DX", fixedLocalLiteralData},
+		{"unaligned", "MOVO literal<>+1(SB),X0", fixedLocalLiteralData},
+		{"wide alignment", "VMOVDQA64 literal<>(SB),Z0", strings.Replace(fixedLocalLiteralData, "$32", "$64", 1)},
+		{"zero mask cannot hide extent", "MOVQ $0,AX\nKMOVQ AX,K1\nVMOVDQU64.Z literal<>(SB),K1,Z0", fixedLocalLiteralData},
+		{"write", "MOVOU X0,literal<>(SB)", fixedLocalLiteralData},
+		{"address past end", "LEAQ literal<>(SB),DX\nADDQ $40,DX\nMOVQ (DX),DX", fixedLocalLiteralData},
+		{"mutable", "MOVOU literal<>(SB),X0", strings.Replace(fixedLocalLiteralData, ",8,$32", ",16,$32", 1)},
+		{"nonprivate", "MOVOU literal(SB),X0", strings.ReplaceAll(fixedLocalLiteralData, "literal<>", "literal")},
+		{"address initializer", "MOVOU literal<>(SB),X0", fixedLocalLiteralData + "DATA pointer<>(SB)/8,$literal<>(SB)\nGLOBL pointer<>(SB),8,$8\n"},
+		{"shortened extent", "MOVQ literal<>(SB),DX", strings.Replace(fixedLocalLiteralData, "$32", "$8", 1)},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, request, file, options, assembly := fixedLocalDataFixture(t, row.operation+"\nPADDQ 16(SP),X0", row.data)
+			x86LEAActualTargetGoObject(t, "amd64", options.TargetTriple, assembly)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			expanded, err := source.preprocess(request.AssemblyFile, []byte(assembly))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = Parse(ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unowned literal operation obtained fixed-local permission", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_data_runtime_go127_test.go b/amd64_fixed_local_data_runtime_go127_test.go
new file mode 100644
index 000000000..990f8ba2c
--- /dev/null
+++ b/amd64_fixed_local_data_runtime_go127_test.go
@@ -0,0 +1,135 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalReadonlyData(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	operations := []string{
+		"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0",
+		"PADDQ literal<>(SB),X0",
+		"MOVQ literal<>+8(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0",
+		"MOVOU literal<>+16(SB),X0\nPADDQ 16(SP),X0",
+		"MOVQ literal<>+3(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0",
+		"MOVB literal<>+1(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0",
+		"MOVW literal<>+1(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0",
+		"MOVL literal<>+1(SB),DX\nMOVQ DX,48(SP)\nMOVOU 48(SP),X0",
+	}
+	var assembly, declarations, calls, cDeclarations, cCalls strings.Builder
+	assembly.WriteString(fixedLocalLiteralData)
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	for index, operation := range operations {
+		name := fmt.Sprintf("Value%d", index)
+		body, _, _ := x86PrivateAlignedFrameAuditFixture(t, operation)
+		assembly.WriteString(strings.Replace(body, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a,b,c,d uint64) uint64\n", name)
+		fmt.Fprintf(&calls, `
+		if got := %s(a, b, c, d); got != expected(%d, a, c) {
+			t.Fatalf("case %d seed=%%d got=%%x", seed, got)
+		}
+`, name, index, index)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t,uint64_t,uint64_t,uint64_t) __asm__(\"%sexample.invalid/framefixture.%s\");\n", index, prefix, name)
+		fmt.Fprintf(&cCalls, `
+		if (value%d(a, b, c, d) != expected(%d, a, c)) {
+			fprintf(stderr, "case %d seed=%%u\n", seed);
+			return 1;
+		}
+`, index, index, index)
+	}
+	goOracle := `package framefixture
+import "testing"
+func expected(op int, a, c uint64) uint64 {
+	const lo = uint64(0x0102030405060708)
+	const hi = uint64(0x1112131415161718)
+	switch op {
+	case 0:
+		return lo+a
+	case 1:
+		return lo+c
+	case 2:
+		return hi
+	case 3:
+		return a
+	case 4:
+		return lo>>24 | (hi&0xffffff)<<40
+	case 5:
+		return c&^255 | 7
+	case 6:
+		return c&^65535 | 0x0607
+	case 7:
+		return 0x04050607
+	}
+	panic("unknown case")
+}
+func TestOriginal(t *testing.T) {
+	for seed := uint64(0); seed < 256; seed++ {
+		a := seed*0x102030405060708
+		b, c, d := ^a, a^0xfedcba9876543210, a+0x1234
+` + calls.String() + `
+	}
+}
+`
+	cOracle := `#include <stdint.h>
+#include <stdio.h>
+` + cDeclarations.String() + `
+static uint64_t expected(unsigned op, uint64_t a, uint64_t c) {
+	const uint64_t lo = UINT64_C(0x0102030405060708);
+	const uint64_t hi = UINT64_C(0x1112131415161718);
+	switch (op) {
+	case 0:
+		return lo+a;
+	case 1:
+		return lo+c;
+	case 2:
+		return hi;
+	case 3:
+		return a;
+	case 4:
+		return lo>>24 | (hi&0xffffff)<<40;
+	case 5:
+		return (c&~UINT64_C(255)) | 7;
+	case 6:
+		return (c&~UINT64_C(65535)) | 0x0607;
+	case 7:
+		return 0x04050607;
+	}
+	return 0;
+}
+int main(void) {
+	for (unsigned seed=0; seed<256; seed++) {
+		uint64_t a = seed*UINT64_C(0x102030405060708);
+		uint64_t b = ~a, c = a^UINT64_C(0xfedcba9876543210), d = a+0x1234;
+` + cCalls.String() + `
+	}
+	return 0;
+}
+`
+	pkg, request, _, options := x86CMOVFixedLocalFixture(t, assembly.String(), declarations.String(), runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalPackedRunOriginal(t, execution, assembly.String(), declarations.String(), goOracle, true)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			input := ir
+			if level == "-O2" {
+				input = x86MulDivRoundOptimize(t, ir)
+			}
+			execution.compileAndRunLLVM(t, "readonly-frame", input, cOracle, level)
+		}
+	})
+	t.Log("2048 independent numeric outcomes: original Go and three LLVM APIs at O0/O2; includes sparse zero tails and unaligned/partial scalar reads")
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("Rosetta legacy SSE diagnostic, not native Linux or AVX/AVX512 execution")
+	}
+}
diff --git a/amd64_fixed_local_dead_blocks_test.go b/amd64_fixed_local_dead_blocks_test.go
new file mode 100644
index 000000000..7b40f5920
--- /dev/null
+++ b/amd64_fixed_local_dead_blocks_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These are source/CFG regressions, not execution witnesses for the dead MOVs.
+func fixedLocalDeadBlockSource(operation, prefix, branch string) string {
+	return "TEXT ·Value(SB),4,$24-16\nMOVQ a+0(FP),BX\n" +
+		"MOVQ $7,AX\nMOVQ AX,0(SP)\n" + prefix + branch +
+		"gap:\n" + operation + "\ndone:\n" +
+		"MOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+}
+
+func TestGoAMD64FixedLocalDeadMemoryBlocks(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, direction := range []string{"read", "write"} {
+			t.Run(width+"/"+direction, func(t *testing.T) {
+				operation := "MOV" + width + " (CX),AX"
+				if direction == "write" {
+					operation = "MOV" + width + " AX,(CX)"
+				}
+				assembly := fixedLocalDeadBlockSource(operation, "", "JMP done\n")
+				pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+					"func Value(a uint64) uint64", "linux/amd64", "x86_64-unknown-linux-gnu")
+				// Preserve the complete original instruction, including its
+				// uninitialized address. Assembly acceptance grants no access.
+				frameRelocationOriginal(t, pkg, request)
+				fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+					func(t *testing.T, ir string, err error) {
+						if err != nil {
+							t.Fatal("unconditional source jump did not exclude its dead memory block", err)
+						}
+						compileLLVMToObject(t, llc, options.TargetTriple, "dead.ll", "dead.o", ir)
+						compileLLVMToObject(t, llc, options.TargetTriple, "dead-o2.ll", "dead-o2.o", x86MulDivRoundOptimize(t, ir))
+					})
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalLiveMemoryStillRequiresProof(t *testing.T) {
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, direction := range []string{"read", "write"} {
+			for _, address := range []string{"unknown", "partial"} {
+				t.Run(width+"/"+direction+"/"+address, func(t *testing.T) {
+					operation := "MOV" + width + " (CX),AX"
+					if direction == "write" {
+						operation = "MOV" + width + " AX,(CX)"
+					}
+					prefix := ""
+					if address == "partial" {
+						prefix = "MOVB $1,CX\n"
+					}
+					// Both successors are possible for the declared input;
+					// AX is known even in the write cases, isolating address duty.
+					assembly := fixedLocalDeadBlockSource(operation, prefix, "CMPQ BX,$0\nJEQ gap\nJMP done\n")
+					pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+						"func Value(a uint64) uint64", "linux/amd64", "x86_64-unknown-linux-gnu")
+					frameRelocationOriginal(t, pkg, request)
+					for _, api := range []string{"Translate", "Module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							ctx, cancel := runtimeOracleStageContext(t)
+							defer cancel()
+							source := requireGoAMD64FrameCapture(t, pkg, request)
+							file, err := Parse(ArchAMD64, assembly)
+							if err != nil {
+								t.Fatal(err)
+							}
+							bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+							if err != nil {
+								if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "unknown/escaping address provenance") {
+									t.Fatal("live address failed outside its expected binding obligation", err)
+								}
+								t.Log("live address rejected at Bind before codegen", err)
+								return
+							}
+							fixedLocalAPI(t, pkg, file, bound, api, fixedLocalRequireContext, assembly)
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalDeadBlocksKeepCompleteGrammar(t *testing.T) {
+	const operation = "MOVQ (CX),AX"
+	fn, sig := fixedLocalReplayFixture(t, "JMP done\n"+operation+"\ndone:")
+	proven, err := proveX86FixedLocal(fn, sig)
+	if err != nil {
+		t.Fatal("legal complete dead source failed the independent proof baseline", err)
+	}
+	matched := 0
+	for _, ins := range proven.Instrs {
+		if len(ins.Args) == 2 && ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Base == CX {
+			matched++
+			if len(ins.x86FixedLocalMemory) != 0 {
+				t.Fatal("an unreachable unknown address acquired a memory certificate")
+			}
+		}
+	}
+	if matched != 1 {
+		t.Fatal("independent dead-address control is missing or duplicated", matched)
+	}
+	for _, invalid := range []string{"MOVQ AX", "VADDPS X0,X1,AX", "MOVQ AX,(CX)\nSYSCALL"} {
+		t.Run(fmt.Sprint(invalid), func(t *testing.T) {
+			assembly := strings.Replace(fixedLocalReplaySource("JMP done\n"+operation+"\ndone:"), operation, invalid, 1)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); err == nil {
+				t.Fatal("dead source bypassed complete typed-format validation", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalDeadBlockLabelAliases(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, label := range []string{"gap", "done"} {
+		t.Run(label, func(t *testing.T) {
+			assembly := fixedLocalDeadBlockSource("MOVQ (CX),AX", "", "JMP done\n")
+			assembly = strings.Replace(assembly, label+":\n", label+":\n"+label+"_alias:\n", 1)
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(a uint64) uint64", "linux/amd64", "x86_64-unknown-linux-gnu")
+			frameRelocationOriginal(t, pkg, request)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("adjacent labels lost their common successor", err)
+					}
+					if label == "done" {
+						found := false
+						for _, line := range strings.Split(ir, "\n") {
+							if strings.HasPrefix(strings.TrimSpace(line), amd64LLVMBlockName("done")+":") {
+								found = true
+								continue
+							}
+							if found && strings.TrimSpace(line) != "" && !strings.HasPrefix(strings.TrimSpace(line), ";") {
+								if !strings.HasPrefix(strings.TrimSpace(line), "br label %"+amd64LLVMBlockName("done_alias")) {
+									t.Fatal("reachable empty label did not continue to its live successor", line)
+								}
+								break
+							}
+						}
+						if !found {
+							t.Fatal("reachable source label disappeared")
+						}
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "aliases.ll", "aliases.o", ir)
+				})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalDeadBlockProjectionGuards(t *testing.T) {
+	assembly := fixedLocalDeadBlockSource("MOVQ (CX),AX", "", "JMP done\n")
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+		"func Value(a uint64) uint64", "linux/amd64", "x86_64-unknown-linux-gnu")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64", bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := normalized.Funcs[0]
+	makeConsumer := func() *amd64Ctx {
+		return newX86Ctx(new(strings.Builder), fn, bound.Sigs[pkg.Path+".Value"], bound.ResolveSym,
+			bound.Sigs, "amd64", options.TargetTriple, false)
+	}
+	baseline, err := makeConsumer().fixedLocalBlockReachability()
+	if err != nil || len(baseline) == 0 {
+		t.Fatal("actual source did not establish a valid emission projection", err)
+	}
+	for _, name := range []string{"owner", "source", "emitted instruction", "block mapping"} {
+		t.Run(name, func(t *testing.T) {
+			consumer := makeConsumer()
+			switch name {
+			case "owner":
+				consumer.fixedLocal = &x86FixedLocalProof{}
+			case "source":
+				consumer.fpScalarSource.Instrs = append([]Instr(nil), fn.Instrs...)
+				consumer.fpScalarSource.Instrs[0].Raw += " // changed source"
+			case "emitted instruction":
+				for index, live := range baseline {
+					if !live && len(consumer.blocks[index].instrs) != 0 {
+						consumer.blocks[index].instrs[0].Op = "SYSCALL"
+						break
+					}
+				}
+			case "block mapping":
+				consumer.blockBase[1]++
+			}
+			if projection, err := consumer.fixedLocalBlockReachability(); !errors.Is(err, ErrProbeNeedsContext) || projection != nil {
+				t.Fatal("changed emission acquired an unreachable-source exception", err)
+			}
+		})
+	}
+	for _, name := range []string{"private graph", "indirect", "address-taken"} {
+		t.Run(name, func(t *testing.T) {
+			consumer := makeConsumer()
+			switch name {
+			case "private graph":
+				consumer.directTail = &x86DirectTailRoot{}
+			case "indirect":
+				consumer.indirectABI0 = &FuncSig{}
+			case "address-taken":
+				consumer.indirectLabels = []string{"gap"}
+			}
+			if projection, err := consumer.fixedLocalBlockReachability(); err != nil || projection != nil {
+				t.Fatal("a separate entry graph was pruned", err)
+			}
+		})
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if projection, err := makeConsumer().fixedLocalBlockReachability(); !errors.Is(err, ErrProbeNeedsContext) || projection != nil {
+		t.Fatal("closed actual source retained an emission exception", err)
+	}
+}
diff --git a/amd64_fixed_local_exchange.go b/amd64_fixed_local_exchange.go
new file mode 100644
index 000000000..b7ed96b13
--- /dev/null
+++ b/amd64_fixed_local_exchange.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+func fixedLocalExchangeStep(ins *Instr, state *x86FixedLocalState, sig FuncSig,
+	proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, width, known, err := x86SwapProperties(*ins, "amd64")
+	if !known {
+		return false, nil
+	}
+	if err != nil {
+		return true, err
+	}
+	if form.nop {
+		return true, nil // Go's accumulator 90 encoding preserves even unknown bytes.
+	}
+	for _, operand := range ins.Args {
+		root, _ := x86CallerGP(operand.Reg)
+		if operand.Kind != OpReg && operand.Kind != OpMem || operand.Kind == OpReg && root == SP {
+			return true, goAMD64FrameContext("fixed local exchange requires registers or independently owned memory")
+		}
+	}
+	first, err := fixedLocalReadValue(ins, 0, state, sig, proof, residue, width, true)
+	if err != nil {
+		return true, err
+	}
+	last, err := fixedLocalReadValue(ins, 1, state, sig, proof, residue, width, true)
+	if err != nil {
+		return true, err
+	}
+	comparison := state.comparison
+	order := [2]int{0, 1}
+	if ins.Args[1].Kind == OpMem {
+		order = [2]int{1, 0}
+	}
+	// Snapshot reads precede both writes. Write memory first so a base/index
+	// that is also exchanged still addresses its original location.
+	values := [2]fixedLocalScalarValue{last, first}
+	for _, index := range order {
+		if err := fixedLocalWriteValue(ins, index, 1-index, values[index], state, sig, proof, residue, width); err != nil {
+			return true, err
+		}
+	}
+	if width == 8 && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg {
+		for index, operand := range ins.Args {
+			if comparison.register == operand.Reg {
+				comparison.register = ins.Args[1-index].Reg
+				break
+			}
+		}
+		state.comparison = comparison
+	}
+	return true, nil // XCHG preserves FLAGS; only their value correlation moves.
+}
diff --git a/amd64_fixed_local_exchange_go127_test.go b/amd64_fixed_local_exchange_go127_test.go
new file mode 100644
index 000000000..1fae3f60b
--- /dev/null
+++ b/amd64_fixed_local_exchange_go127_test.go
@@ -0,0 +1,105 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+	"testing"
+)
+
+type fixedLocalExchangeCase struct {
+	body string
+	want func(uint64) uint64
+}
+
+func fixedLocalExchangeCases() []fixedLocalExchangeCase {
+	const other = uint64(0x1122334455667788)
+	var rows []fixedLocalExchangeCase
+	for _, width := range []struct {
+		suffix string
+		bits   uint
+	}{{"B", 8}, {"W", 16}, {"L", 32}, {"Q", 64}} {
+		for _, location := range []string{"register", "memory first", "memory last"} {
+			width, location := width, location
+			memory := "8(SP)"
+			if location == "memory first" && width.bits < 64 {
+				// Exercise unaligned native exchange without crossing a cacheline
+				// on machines that trap split locks. Keep qwords word-aligned.
+				memory = "3(SP)"
+			}
+			body := "MOVQ $0x1122334455667788,CX\nMOVQ CX," + memory + "\n"
+			switch location {
+			case "register":
+				body += "XCHG" + width.suffix + " AX,CX\n"
+			case "memory first":
+				body += "XCHG" + width.suffix + " " + memory + ",AX\nMOVQ " + memory + ",CX\n"
+			case "memory last":
+				body += "XCHG" + width.suffix + " AX,8(SP)\nMOVQ 8(SP),CX\n"
+			}
+			// Observe both outputs asymmetrically: XOR or addition alone would
+			// hide an incorrect implementation that did not exchange anything.
+			body += "RORQ $13,CX\nXORQ CX,AX"
+			rows = append(rows, fixedLocalExchangeCase{body, func(input uint64) uint64 {
+				mask := uint64(1)<<width.bits - 1
+				first, last := input&^mask|other&mask, other&^mask|input&mask
+				if width.bits == 32 {
+					first = uint64(uint32(first))
+					if location == "register" {
+						last = uint64(uint32(last))
+					}
+				}
+				return first ^ bits.RotateLeft64(last, -13)
+			}})
+		}
+	}
+	for _, operands := range []string{"AH,AL", "AL,AH"} {
+		rows = append(rows, fixedLocalExchangeCase{"XCHGB " + operands, func(input uint64) uint64 {
+			return input&^0xffff | (input&255)<<8 | input>>8&255
+		}})
+	}
+	rows = append(rows,
+		fixedLocalExchangeCase{
+			"MOVQ AX,8(SP)\nMOVQ $0x1122334455667788,CX\nMOVQ CX,24(SP)\nLEAQ 8(SP),CX\nLEAQ 24(SP),DX\nXCHGQ CX,DX\nMOVQ (CX),AX",
+			func(uint64) uint64 { return other },
+		},
+		fixedLocalExchangeCase{
+			"LEAQ 8(SP),CX\nMOVQ AX,DX\nXCHGQ CX,DX\nMOVQ CX,(DX)\nMOVQ 8(SP),AX",
+			func(input uint64) uint64 { return input },
+		},
+		fixedLocalExchangeCase{
+			"MOVQ AX,8(SP)\nLEAQ 8(SP),CX\nXCHGQ CX,(CX)\nMOVQ 8(SP),DX\nMOVQ CX,(DX)\nMOVQ 8(SP),AX",
+			func(input uint64) uint64 { return input },
+		},
+		fixedLocalExchangeCase{
+			"MOVQ AX,8(SP)\nMOVQ $0x1122334455667788,CX\nMOVQ CX,24(SP)\nMOVQ $8,CX\nMOVQ $24,DX\nXCHGQ CX,DX\nMOVQ (SP)(CX*1),AX",
+			func(uint64) uint64 { return other },
+		},
+		fixedLocalExchangeCase{"XCHGL AX,AX", func(input uint64) uint64 { return input }},
+		fixedLocalExchangeCase{"MOVQ AX,BX\nXCHGL BX,BX\nMOVQ BX,AX", func(input uint64) uint64 { return uint64(uint32(input)) }},
+		fixedLocalExchangeCase{"MOVQ $0x1122334455667788,CX\nSTC\nXCHGQ AX,CX\nADCQ $0,AX", func(uint64) uint64 { return other + 1 }},
+	)
+	return rows
+}
+
+func fixedLocalExchangeProgram(t *testing.T) (string, string, []fixedLocalExchangeCase) {
+	t.Helper()
+	rows := fixedLocalExchangeCases()
+	if len(rows) != 21 {
+		t.Fatal("exchange width, memory, alias and typed-value inventory changed", len(rows))
+	}
+	var assembly, declarations strings.Builder
+	for index, row := range rows {
+		_, _, source := fixedLocalGPFixture(t, row.body)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+	}
+	return assembly.String(), declarations.String(), rows
+}
+
+func TestGoAMD64FixedLocalExchangeObjects(t *testing.T) {
+	assembly, declarations, rows := fixedLocalExchangeProgram(t)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(rows))
+}
diff --git a/amd64_fixed_local_exchange_runtime_go127_test.go b/amd64_fixed_local_exchange_runtime_go127_test.go
new file mode 100644
index 000000000..720034159
--- /dev/null
+++ b/amd64_fixed_local_exchange_runtime_go127_test.go
@@ -0,0 +1,22 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalExchange(t *testing.T) {
+	assembly, declarations, rows := fixedLocalExchangeProgram(t)
+	inputs := []uint64{0, 1, ^uint64(0), 0x0123456789abcdef}
+	var expected [][]string
+	for _, input := range inputs {
+		var values []string
+		for _, row := range rows {
+			values = append(values, fmt.Sprintf("%016x", row.want(input)))
+		}
+		expected = append(expected, values)
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
diff --git a/amd64_fixed_local_exchange_test.go b/amd64_fixed_local_exchange_test.go
new file mode 100644
index 000000000..0f8e7bf63
--- /dev/null
+++ b/amd64_fixed_local_exchange_test.go
@@ -0,0 +1,360 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func fixedLocalExchangeState() x86FixedLocalState {
+	return x86FixedLocalState{
+		pointers: map[Reg]int64{SP: 0}, opaque: make(map[Reg]x86FixedLocalOrigins),
+		opaqueCells: make(map[int64]x86FixedLocalOrigins), addresses: make(map[int64]int64),
+		known: make(map[Reg]uint8), constants: make(map[Reg]int64),
+		booleans: make(map[Reg]uint8), vectors: make(map[Reg]uint64),
+		masks: make(map[Reg]bool), results: make(map[int]bool),
+		bytes: newFixedLocalByteSet(64), booleanBytes: newFixedLocalByteSet(64),
+		flags: x86ByteFlagsAll,
+	}
+}
+
+func TestGoAMD64FixedLocalExchangeRegisters(t *testing.T) {
+	registers := append(x86CommutedPointerAddRegisters("amd64"), BP)
+	var source strings.Builder
+	source.WriteString("TEXT ·Value(SB),4,$0-0\n")
+	for _, width := range []struct {
+		suffix string
+		bytes  int64
+	}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+		for _, first := range registers {
+			for _, last := range registers {
+				body := fmt.Sprintf("XCHG%s %s,%s", width.suffix, first, last)
+				fmt.Fprintln(&source, body)
+				t.Run(body, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, body)
+					if !fixedLocalInstructionShape(ins) {
+						t.Fatal("existing typed exchange family is absent from fixed-frame shapes")
+					}
+					state := fixedLocalExchangeState()
+					state.known[first], state.known[last] = 255, 255
+					state.booleans[first], state.booleans[last] = 0x55, 0xaa
+					oldFirst, oldLast := state.booleans[first], state.booleans[last]
+					if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+						t.Fatal("initialized exchange rejected", err)
+					}
+					mask := uint8((1 << uint(width.bytes)) - 1)
+					wantFirst, wantLast := oldFirst&^mask|oldLast&mask, oldLast&^mask|oldFirst&mask
+					if width.bytes == 4 && !(first == AX && last == AX) {
+						wantFirst, wantLast = wantFirst|240, wantLast|240
+					}
+					if state.booleans[first] != wantFirst || state.booleans[last] != wantLast ||
+						state.known[first] != 255 || state.known[last] != 255 || state.flags != x86ByteFlagsAll {
+						t.Fatal("swap lost byte identity, dword zero extension or FLAGS", state)
+					}
+				})
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+}
+
+func TestGoAMD64FixedLocalExchangeByteAliasesAndValues(t *testing.T) {
+	for _, width := range []struct {
+		suffix string
+		bytes  int64
+	}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+		for _, reg := range []Reg{AX, BX} {
+			for missing := int64(0); missing < width.bytes; missing++ {
+				t.Run(fmt.Sprintf("missing/%s/%s/%d", width.suffix, reg, missing), func(t *testing.T) {
+					state := fixedLocalExchangeState()
+					state.known[AX], state.known[BX] = 255, 255
+					state.known[reg] &^= 1 << uint(missing)
+					before := cloneFixedLocalState(state)
+					ins := x86ScalarLaneInstruction(t, "XCHG"+width.suffix+" AX,BX")
+					if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(state, before) {
+						t.Fatal("incomplete input mutated state or acquired initialized bytes", err)
+					}
+				})
+			}
+		}
+	}
+	for _, operands := range []string{"AH,AL", "AL,AH", "CH,CL", "CL,CH", "AH,BH", "AL,BL", "R11,R12", "SI,DI"} {
+		t.Run(operands, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, "XCHGB "+operands)
+			state := fixedLocalExchangeState()
+			for _, reg := range []Reg{AX, BX, CX, SI, DI, "R11", "R12"} {
+				state.known[reg], state.booleans[reg] = 255, 0x55
+				state.constants[reg] = 0x1234
+				state.setRange(reg, x86UnsignedRange{1, 2})
+			}
+			before := cloneFixedLocalState(state)
+			first, last := ins.Args[0], ins.Args[1]
+			firstRoot, _ := x86CallerGP(first.Reg)
+			lastRoot, _ := x86CallerGP(last.Reg)
+			firstBits := fixedLocalBooleanRead(first, 1, &before)
+			lastBits := fixedLocalBooleanRead(last, 1, &before)
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalWriteBooleans(&before, first.Reg, 1, lastBits)
+			fixedLocalWriteBooleans(&before, last.Reg, 1, firstBits)
+			delete(before.constants, firstRoot)
+			delete(before.constants, lastRoot)
+			if !reflect.DeepEqual(state, before) {
+				t.Fatal("overlapping aliases did not snapshot both inputs or revoke fullword facts", state, before)
+			}
+		})
+	}
+	for _, width := range []string{"W", "L", "Q"} {
+		t.Run("accumulator NOP/"+width, func(t *testing.T) {
+			state := fixedLocalExchangeState()
+			state.opaque[AX] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 8})
+			state.comparison = x86FixedLocalComparison{register: AX, constant: 7}
+			before := cloneFixedLocalState(state)
+			ins := x86ScalarLaneInstruction(t, "XCHG"+width+" AX,AX")
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil || !reflect.DeepEqual(state, before) {
+				t.Fatal("Go opcode 90 is a NOP even for opaque or undefined bytes", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalExchangeValueDomains(t *testing.T) {
+	roles := []string{"number", "private", "incoming", "readonly"}
+	for _, first := range roles {
+		for _, last := range roles {
+			t.Run(first+"/"+last, func(t *testing.T) {
+				state := fixedLocalExchangeState()
+				seed := func(reg Reg, role string, value int64) {
+					switch role {
+					case "number":
+						state.known[reg], state.constants[reg], state.booleans[reg] = 255, value, 0xfe
+						state.setRange(reg, x86UnsignedRange{uint64(value), uint64(value)})
+					case "private":
+						state.pointers[reg] = value
+					case "incoming":
+						state.opaque[reg] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: value})
+					case "readonly":
+						state.opaque[reg] = fixedLocalOrigin(x86FixedLocalOrigin{literal: x86StaticSBAddress{symbol: "table<>(SB)", offset: value}})
+					}
+				}
+				seed(AX, first, 8)
+				seed(BX, last, 24)
+				state.comparison = x86FixedLocalComparison{register: AX, constant: 31}
+				before := cloneFixedLocalState(state)
+				ins := x86ScalarLaneInstruction(t, "XCHGQ AX,BX")
+				if err := fixedLocalStep(&ins, &state, FuncSig{}, &x86FixedLocalProof{frame: 64}, 0); err != nil {
+					t.Fatal(err)
+				}
+				for _, pair := range [][2]Reg{{AX, BX}, {BX, AX}} {
+					to, from := pair[0], pair[1]
+					if state.known[to] != before.known[from] || state.booleans[to] != before.booleans[from] ||
+						state.pointers[to] != before.pointers[from] || state.opaque[to] != before.opaque[from] ||
+						state.constants[to] != before.constants[from] || state.ranges[to] != before.ranges[from] {
+						t.Fatal("exchange lost a complete typed value or retained an old value", to, state, before)
+					}
+				}
+				if state.comparison != (x86FixedLocalComparison{register: BX, constant: 31}) || state.flags != before.flags {
+					t.Fatal("FLAGS must follow the same compared value after a full-word exchange", state.comparison)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalExchangeCompleteRoles(t *testing.T) {
+	rows := []struct {
+		name, body string
+		input, ok  bool
+	}{
+		{"private pointers", "LEAQ 8(SP),R14\nLEAQ 24(SP),R15\nXCHGQ R15,R14\nMOVQ AX,(R14)\nMOVQ 24(SP),AX", false, true},
+		{"private and NUM", "LEAQ 8(SP),CX\nMOVQ AX,DX\nXCHGQ CX,DX\nMOVQ CX,(DX)\nMOVQ 8(SP),AX", false, true},
+		{"NUM and private", "LEAQ 8(SP),CX\nMOVQ AX,DX\nXCHGQ DX,CX\nMOVQ CX,(DX)\nMOVQ 8(SP),AX", false, true},
+		{"old roles cannot survive swap", "LEAQ 8(SP),CX\nMOVQ AX,DX\nXCHGQ DX,CX\nMOVQ DX,(CX)\nMOVQ 8(SP),AX", false, false},
+		{"private spill and NUM", "LEAQ 24(SP),CX\nMOVQ CX,8(SP)\nXCHGQ AX,8(SP)\nMOVQ 8(SP),DX\nMOVQ DX,(AX)\nMOVQ 24(SP),AX", false, true},
+		{"NUM spill and private", "LEAQ 24(SP),CX\nXCHGQ 0(SP),CX\nMOVQ 0(SP),DX\nMOVQ CX,(DX)\nMOVQ 24(SP),AX", false, true},
+		{"memory address uses old register", "MOVQ AX,8(SP)\nLEAQ 8(SP),CX\nXCHGQ CX,(CX)\nMOVQ 8(SP),DX\nMOVQ CX,(DX)\nMOVQ 8(SP),AX", false, true},
+		{"native pointers", "XCHGQ SI,DI\nMOVQ (DI),AX", true, true},
+		{"native and NUM", "XCHGQ SI,AX\nMOVQ (AX),AX", true, true},
+		{"native spill", "MOVQ SI,8(SP)\nXCHGQ 8(SP),AX\nMOVQ (AX),AX", true, true},
+		{"native private swap", "LEAQ 16(SP),CX\nXCHGQ SI,CX\nMOVQ (CX),AX\nMOVQ AX,(SI)\nMOVQ 16(SP),AX", true, true},
+		{"constant index", "MOVQ $8,CX\nMOVQ $16,DX\nXCHGQ CX,DX\nMOVQ AX,(SP)(CX*1)\nMOVQ 16(SP),AX", false, true},
+		{"flags preserved", "MOVQ AX,CX\nSTC\nXCHGQ AX,CX\nADCQ $0,AX", false, true},
+		{"unknown register", "XCHGQ AX,CX", false, false},
+		{"unknown memory", "XCHGQ AX,8(SP)", false, false},
+		{"crossing frame", "XCHGQ AX,60(SP)", false, false},
+		{"partial pointer", "MOVQ SP,CX\nXCHGW AX,CX", false, false},
+		{"partial opaque", "XCHGL SI,AX", true, false},
+		{"partial spill", "MOVQ SI,8(SP)\nXCHGL AX,8(SP)", true, false},
+		{"pointer cannot escape", "LEAQ 8(SP),CX\nXCHGQ CX,(SI)", true, false},
+		{"NUM not address", "XCHGQ AX,0(SP)\nMOVQ (AX),AX", false, false},
+		{"pointer not NUM", "LEAQ 8(SP),CX\nXCHGQ AX,CX", false, false},
+		{"stack register", "XCHGQ AX,SP", false, false},
+		{"flags not invented", "MOVQ AX,CX\nXCHGQ AX,CX\nADCQ $0,AX", false, false},
+	}
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, memory := range []string{"0(SP)", "3(SI)"} {
+			for _, reverse := range []bool{false, true} {
+				first, last := "AX", memory
+				if reverse {
+					first, last = last, first
+				}
+				rows = append(rows, struct {
+					name, body string
+					input, ok  bool
+				}{"XCHG" + width + " " + first + "," + last, "XCHG" + width + " " + first + "," + last, memory == "3(SI)", true})
+			}
+		}
+	}
+	var source strings.Builder
+	for index, row := range rows {
+		fixture := fixedLocalGPFixture
+		if row.input {
+			fixture = fixedLocalInputFixture
+		}
+		fn, sig, original := fixture(t, row.body)
+		source.WriteString(strings.Replace(original, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if row.name == "NUM not address" {
+				fixedLocalRequireNumericControl(t, fn, sig, original, "func Value(a uint64) uint64",
+					"MOVQ (AX),AX", 0, 8, false, "load volatile i64")
+				return
+			}
+			_, err := proveX86FixedLocal(fn, sig)
+			if row.ok && err != nil || !row.ok && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("complete typed exchange valid=%t: %v", row.ok, err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+}
+
+func TestGoAMD64FixedLocalExchangeCandidates(t *testing.T) {
+	for _, row := range []struct {
+		body string
+		want bool
+	}{
+		{"MOVQ SP,CX\nXCHGQ DX,CX\nMOVQ (DX),AX", true},
+		{"MOVQ SP,CX\nXCHGQ CX,DX\nMOVQ (DX),AX", true},
+		{"MOVQ SP,CX\nXCHGQ CX,DX\nXCHGQ DX,R15\nMOVQ (R15),AX", true},
+		{"XCHGQ CX,0(SP)", true},
+		{"XCHGQ 0(SP),CX", true},
+		{"XCHGB CX,0(SP)", true},
+		{"XCHGW 0(SP),CX", true},
+		{"XCHGL CX,0(SP)", true},
+		{"MOVQ SP,CX\nXCHGL CX,DX\nMOVQ (DX),AX", false},
+		{"MOVQ SI,CX\nXCHGQ CX,DX\nMOVQ (DX),AX", false},
+		{"MOVQ SP,CX\nXCHGQ CX,DX", false},
+		{"XCHGQ CX,scratch-8(SP)", false},
+	} {
+		t.Run(row.body, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-0\n"+row.body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := GoAMD64FixedLocalFrameBindingNeeded(file, "amd64"); got != row.want {
+				t.Fatalf("candidate=%t, want %t", got, row.want)
+			}
+		})
+	}
+}
+
+func TestX86ExchangeCallerOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, suffix := x86ResultPointerWord(arch), "Q"
+		if arch == "386" {
+			suffix = "L"
+		}
+		t.Run(arch+"/complete same-origin difference", func(t *testing.T) {
+			body := fmt.Sprintf("MOV%s p+0(FP),AX\nMOV%s n+%d(FP),BX\nXCHG%s AX,BX\nADD%s AX,BX\nSUB%s p+0(FP),BX\nMOV%s BX,ret+%d(FP)\nRET", suffix, suffix, word, suffix, suffix, suffix, suffix, 2*word)
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p *byte,n uintptr) uintptr", body)
+			requireX86GoAssemblerResult(t, arch, source, true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal("swapped incoming pointer lost its complete original-source origin", err)
+				}
+			}
+		})
+		for _, operands := range []string{"AX,BX", "BX,AX", "AX,AX"} {
+			t.Run(arch+"/"+operands, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "XCHG"+suffix+" "+operands)
+				state := x86ResultState{callerAddressFP: map[int64]bool{0: true, word: true}}
+				first, _, _ := x86ResultGP(AX, word, arch)
+				last, _, _ := x86ResultGP(BX, word, arch)
+				state.pointerGP[first], state.pointerGP[last] = true, true
+				state.callerAddressGP[first], state.callerAddressGP[last] = true, true
+				state.callerAddressOrigin[first], state.callerAddressOrigin[last] = 1, uint16(word+1)
+				before := state.clone()
+				if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("existing typed whole-word swap rejected")
+				}
+				state.callerAddressGP = x86ResultCallerAddressesAfterTransfer(ins, before.callerAddressGP, state.callerAddressGP, state.callerAddressFP, arch)
+				state.callerAddressOrigin = x86ResultCallerOriginsAfter(ins, before.callerAddressOrigin, state.callerAddressGP, state.callerAddressFP, arch)
+				if operands != "AX,AX" {
+					before.callerAddressOrigin[first], before.callerAddressOrigin[last] = before.callerAddressOrigin[last], before.callerAddressOrigin[first]
+				}
+				if state.callerAddressGP != before.callerAddressGP || state.callerAddressOrigin != before.callerAddressOrigin {
+					t.Fatal("whole-word swap lost or invented incoming-pointer identity", state, before)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExchangeCanonicalBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			body   string
+			ax, bx uint8
+		}{
+			{"XCHGB AH,AL", 0x56, 0xaa},
+			{"XCHGB AL,AH", 0x56, 0xaa},
+			{"XCHGB AX,BX", 0x54, 0xab},
+			{"XCHGW AX,BX", 0x56, 0xa9},
+			{"XCHGL AX,BX", 0x5a, 0xa5},
+			{"XCHGL AX,AX", 0x55, 0xaa},
+			{"XCHGL BX,BX", 0x55, 0xaa},
+			{"XCHGB AX,(SI)", 0x54, 0xaa},
+			{"XCHGB (SI),AX", 0x54, 0xaa},
+		} {
+			t.Run(arch+"/"+row.body, func(t *testing.T) {
+				before := [16]uint8{0: 0x55, 3: 0xaa, 6: 0x81}
+				want := before
+				want[0], want[3] = row.ax, row.bx
+				if arch == "amd64" && strings.HasPrefix(row.body, "XCHGL") && row.body != "XCHGL AX,AX" {
+					want[3] |= 240
+					if row.body != "XCHGL BX,BX" {
+						want[0] |= 240
+					}
+				}
+				if got := x86RegisterCanonicalBytesAfter(x86ScalarLaneInstruction(t, row.body), before, arch); got != want {
+					t.Fatal("independent canonical-byte domain did not follow the same typed swap", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalExchangeReadonlyAndRange(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"readonly origin moves", "LEAQ literal<>(SB),CX\nMOVQ AX,DX\nXCHGQ CX,DX\nMOVQ (DX),AX", true},
+		{"readonly remains readonly", "LEAQ literal<>(SB),CX\nMOVQ AX,DX\nXCHGQ CX,DX\nXCHGQ AX,(DX)", false},
+		{"readonly extent unchanged", "LEAQ literal<>+240(SB),CX\nMOVQ AX,DX\nXCHGQ CX,DX\nMOVQ (DX),AX", false},
+		{"range moves", fixedLocalRangePrefix + "MOVQ $0,CX\nXCHGQ R9,CX\n" + strings.ReplaceAll(fixedLocalRangeLoad, "R9", "CX"), true},
+		{"comparison follows value", "MOVQ AX,R9\nMOVQ AX,CX\nCMPQ R9,$16\nXCHGQ R9,CX\nJAE done\nTESTQ CX,CX\nJE done\n" + strings.ReplaceAll(fixedLocalRangeLoad, "R9", "CX"), true},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalRangeFixture(t, row.body)
+			_, err := proveX86FixedLocal(fn, sig)
+			if row.valid && err != nil || !row.valid && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("readonly/range value valid=%t: %v", row.valid, err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_frame_test.go b/amd64_fixed_local_frame_test.go
new file mode 100644
index 000000000..cd1d91410
--- /dev/null
+++ b/amd64_fixed_local_frame_test.go
@@ -0,0 +1,785 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func fixedLocalFrameFixture(t *testing.T, operation string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	_, request := goAMD64FrameSourceFixture(t)
+	source, _, _ := x86PrivateAlignedFrameAuditFixture(t, operation)
+	declaration := []byte("package framefixture\nfunc Value(a, b, c, d uint64) uint64\n")
+	for name, data := range map[string][]byte{
+		"value.go": declaration, "value_amd64.s": []byte(source),
+	} {
+		if err := os.WriteFile(filepath.Join(request.Directory, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "value.go", declaration, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("example.invalid/framefixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := DeriveGoFuncABI0Signature(typed.Path()+".Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", typed.Path()+".", 1) }
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}
+	return pkg, request, file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve,
+		Sigs: map[string]FuncSig{sig.Name: sig},
+	}
+}
+
+func TestGoAMD64FixedLocalFrameSevenOriginalNativeOperations(t *testing.T) {
+	for _, operation := range []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+	} {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, operation)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			observed := source.functions[pkg.Path+".Value"]
+			if observed.locals != 168 || observed.args != 40 || len(observed.code) == 0 {
+				t.Fatalf("missing actual original Go frame/object: %+v", observed)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			options, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, file, options, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatalf("original numeric frame needs sealed native backing: %v", err)
+				}
+				for _, required := range []string{"fixed_local_native", "align 8", "asm sideeffect"} {
+					if !strings.Contains(ir, required) {
+						t.Fatalf("missing actual native storage/opcode %q", required)
+					}
+				}
+			})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameActualTargetObjectsPreserveProducerBoundary(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64", "linux/386", "windows/386"} {
+		t.Run(target, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			request.Target = target
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if strings.HasSuffix(target, "/386") || target == "windows/amd64" && err != nil {
+				if !errors.Is(err, ErrProbeNeedsContext) || source != nil ||
+					target == "windows/amd64" && !strings.Contains(err.Error(), "SSEHUNWINDINFO") {
+					t.Fatalf("unclosed physical target unexpectedly obtained authority: %v", err)
+				}
+				t.Logf("existing actual observer boundary remains Context, not a positive fixed-local object: %v", err)
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if target == "darwin/amd64" {
+				options.TargetTriple = "x86_64-apple-darwin"
+			}
+			if target == "windows/amd64" {
+				options.TargetTriple = "x86_64-pc-windows-msvc"
+			}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, options.TargetTriple, "fixed-local.ll", "fixed-local.o", ir)
+				compileLLVMToObject(t, llc, options.TargetTriple, "fixed-local-opt.ll", "fixed-local-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameScalarMemoryWidthsHaveExactCertificates(t *testing.T) {
+	for _, form := range []struct {
+		opcode string
+		width  int64
+	}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}} {
+		t.Run(form.opcode, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			var source, stores strings.Builder
+			for _, ins := range file.Funcs[0].Instrs {
+				source.WriteString(ins.Raw + "\n")
+			}
+			for offset := int64(16); offset < 32; offset += form.width {
+				fmt.Fprintf(&stores, "%s $1,%d(SP)\n", form.opcode, offset)
+			}
+			fmt.Fprintf(&stores, "%s 16(SP),DX\n", form.opcode)
+			original := strings.Replace(source.String(), "MOVQ AX,16(SP)\nMOVQ CX,24(SP)\n", stores.String(), 1)
+			requireX86GoAssemblerResult(t, "amd64", original, true)
+			if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(original), 0600); err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := observed.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized, err := normalizeX86RawFile(file, "amd64", bound)
+			if err != nil {
+				t.Fatal(err)
+			}
+			read, write := false, false
+			for _, ins := range normalized.Funcs[0].Instrs {
+				if string(ins.Op) != form.opcode {
+					continue
+				}
+				for _, access := range ins.x86FixedLocalMemory {
+					if access.width != form.width {
+						t.Fatalf("scalar byte envelope changed: %+v", access)
+					}
+					read = read || !access.write
+					write = write || access.write
+				}
+			}
+			if !read || !write {
+				t.Fatal("missing independently proved scalar read/write")
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || ir == "" {
+					t.Fatalf("actual scalar memory width failed consumer: %v", err)
+				}
+			})
+		})
+	}
+}
+
+func fixedLocalAPIs(t *testing.T, pkg GoPackage, file *File, options Options, check func(*testing.T, string, error)) {
+	t.Helper()
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			fixedLocalAPI(t, pkg, file, options, api, check)
+		})
+	}
+}
+
+// Each API consumes its own complete actual source observation. Neither the
+// compiler cache nor a previous API's options can extend or revive that lease.
+func fixedLocalFreshAPIs(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest, options Options, apis []string, check func(*testing.T, string, error)) {
+	t.Helper()
+	seen := make(map[string]bool)
+	if len(apis) == 0 {
+		t.Fatal("missing fixed-local API inventory")
+	}
+	for _, api := range apis {
+		if (api != "Translate" && api != "Module" && api != "GoModule") || seen[api] {
+			t.Fatal("unknown or duplicated fixed-local API", api)
+		}
+		seen[api] = true
+	}
+	for _, api := range apis {
+		t.Run(api, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			original, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Bind consumes the exact producer's complete CPP output, including
+			// suffix formatting. The original file remains an immutable input.
+			expanded, err := source.preprocess(request.AssemblyFile, original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(source.functions) != len(file.Funcs) {
+				t.Fatal("incomplete actual original Go object inventory")
+			}
+			fixedLocalAPI(t, pkg, file, bound, api, check, expanded)
+		})
+	}
+}
+
+func fixedLocalAPI(t *testing.T, pkg GoPackage, file *File, options Options, api string, check func(*testing.T, string, error), assembly ...string) {
+	t.Helper()
+	if len(assembly) > 1 || len(assembly) == 1 && assembly[0] == "" {
+		t.Fatal("expected at most one complete nonempty assembly source")
+	}
+	switch api {
+	case "Translate":
+		ir, err := Translate(file, options)
+		check(t, ir, err)
+	case "Module":
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := TranslateModuleInContext(ctx, file, options)
+		ir := ""
+		if !module.IsNil() {
+			defer module.Dispose()
+			ir = module.String()
+		}
+		check(t, ir, err)
+	case "GoModule":
+		var source strings.Builder
+		// The fresh owner supplies its exact preprocessed source, retaining
+		// DATA/GLOBL as well as every TEXT body in this independent API.
+		if len(assembly) == 1 {
+			source.WriteString(assembly[0])
+		} else {
+			for _, fn := range file.Funcs {
+				for _, ins := range fn.Instrs {
+					source.WriteString(ins.Raw + "\n")
+				}
+			}
+		}
+		goos := "linux"
+		if strings.Contains(options.TargetTriple, "apple") {
+			goos = "darwin"
+		}
+		if strings.Contains(options.TargetTriple, "windows") {
+			goos = "windows"
+		}
+		translation, err := TranslateGoModule(pkg, []byte(source.String()), GoModuleOptions{
+			GOOS: goos, GOARCH: options.Goarch,
+			TargetTriple: options.TargetTriple, Sizes: types.SizesFor("gc", options.Goarch), WASMABI: options.WASMABI,
+			ResolveSym: options.ResolveSym,
+			ManualSig:  func(name string) (FuncSig, bool) { sig, found := options.Sigs[name]; return sig, found },
+		})
+		ir := ""
+		if translation != nil && !translation.Module.IsNil() {
+			defer translation.Module.Dispose()
+			ir = translation.Module.String()
+		}
+		check(t, ir, err)
+	default:
+		t.Fatal("unknown fixed-local API", api)
+	}
+}
+
+func fixedLocalRequireContext(t *testing.T, ir string, err error) {
+	t.Helper()
+	if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatalf("unbound frame/effect produced IR: %v %s", err, ir)
+	}
+}
+
+func TestGoAMD64FixedLocalFrameThreeAPIsCannotForgeOrMutateBinding(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	fixedLocalAPIs(t, pkg, file, options, fixedLocalRequireContext)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"JSON", "signature", "slot", "attrs", "target", "arch", "resolver", "source", "missing function", "ABI"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := bound
+			changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for name, sig := range changed.Sigs {
+				sig.x86FixedLocal = bound.Sigs[name].x86FixedLocal
+				changed.Sigs[name] = sig
+			}
+			changedFile := *file
+			changedFile.Funcs = append([]Func(nil), file.Funcs...)
+			sig := changed.Sigs[pkg.Path+".Value"]
+			switch mutation {
+			case "JSON":
+				changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+				if err != nil {
+					t.Fatal(err)
+				}
+			case "signature":
+				sig.Args[0] = I32
+			case "slot":
+				sig.Frame.Params[0].Offset++
+			case "attrs":
+				sig.Attrs = "nounwind"
+			case "target":
+				changed.TargetTriple = "x86_64-apple-darwin"
+			case "arch":
+				changed.Goarch = "386"
+			case "resolver":
+				changed.ResolveSym = func(string) string { return "foreign.Value" }
+			case "ABI":
+				changed.WASMABI = WASMABIGo
+			case "source":
+				changedFile.Funcs[0].FrameSize += 8
+				changedFile.Funcs[0].Instrs = append([]Instr(nil), file.Funcs[0].Instrs...)
+				changedFile.Funcs[0].Instrs[0].Raw = strings.Replace(changedFile.Funcs[0].Instrs[0].Raw, "$160-40", "$168-40", 1)
+			case "missing function":
+				changedFile.Funcs = nil
+			}
+			if mutation != "JSON" {
+				changed.Sigs[pkg.Path+".Value"] = sig
+			}
+			check := fixedLocalRequireContext
+			if mutation == "missing function" {
+				check = func(t *testing.T, ir string, err error) {
+					if err == nil || ir != "" {
+						t.Fatalf("missing entire source produced a module: %v", err)
+					}
+				}
+			}
+			fixedLocalAPIs(t, pkg, &changedFile, changed, check)
+		})
+	}
+	// Mutating the original input does not mutate the returned signature nor
+	// the separately cloned sealed expected declaration.
+	input := options.Sigs[pkg.Path+".Value"]
+	input.Args[0] = I32
+	options.Sigs[pkg.Path+".Value"] = input
+	if _, err := Translate(file, bound); err != nil {
+		t.Fatalf("caller-owned Options changed the immutable binding: %v", err)
+	}
+	// Tail groups exist only in Options, not in GoModuleOptions. Exercise the
+	// actual two consumers that can receive this request, not a fake transport.
+	changed := bound
+	changed.X86TailGroups = []X86TailGroup{{Root: "·Value", Helpers: []string{"·Value"}}}
+	ir, err := Translate(file, changed)
+	fixedLocalRequireContext(t, ir, err)
+	llvmContext := llvm.NewContext()
+	defer llvmContext.Dispose()
+	module, err := TranslateModuleInContext(llvmContext, file, changed)
+	if !module.IsNil() {
+		defer module.Dispose()
+		t.Fatal("unbound continuation request produced a module")
+	}
+	fixedLocalRequireContext(t, "", err)
+}
+
+func TestGoAMD64FixedLocalFrameBindResolverMayRevokeWithoutLockingDeadlock(t *testing.T) {
+	if os.Getenv("PLAN9ASM_FIXED_LOCAL_REENTRANCY_CHILD") != "1" {
+		stage, cancelStage := runtimeOracleStageContext(t)
+		defer cancelStage()
+		ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+		defer cancel()
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestGoAMD64FixedLocalFrameBindResolverMayRevokeWithoutLockingDeadlock$", "-test.timeout=1m")
+		command.Env = append(os.Environ(), "PLAN9ASM_FIXED_LOCAL_REENTRANCY_CHILD=1")
+		if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+			t.Fatalf("bounded actual bind resolver/Close child failed or deadlocked: %v\n%s", err, output)
+		}
+		return
+	}
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	resolve := options.ResolveSym
+	options.ResolveSym = func(symbol string) string {
+		if err := source.Close(); err != nil {
+			t.Fatal(err)
+		}
+		return resolve(symbol)
+	}
+	if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("callback-revoked observation obtained a binding: %v", err)
+	}
+}
+
+func TestGoAMD64FixedLocalFrameTruncatedConstantCannotAuthorizePointerArithmetic(t *testing.T) {
+	for _, move := range []string{"MOVL", "MOVW", "MOVB"} {
+		t.Run(move, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			var original strings.Builder
+			for _, ins := range file.Funcs[0].Instrs {
+				original.WriteString(ins.Raw + "\n")
+			}
+			changed := strings.Replace(original.String(), "MOVQ $31,R9\nNOTQ R9\nANDQ R9,SP", "MOVQ $-16,AX\n"+move+" AX,BX\nANDQ BX,SP", 1)
+			requireX86GoAssemblerResult(t, "amd64", changed, true)
+			if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(changed), 0600); err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("actual Go accepted %s narrow constant acquired full-width pointer authority: %v", move, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameClosedExpiredAndChangedSourceRevokes(t *testing.T) {
+	for _, mutation := range []string{"close", "cancel", "file", "object", "listing", "export", "post-consumer"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			stage, finish := runtimeOracleStageContext(t)
+			defer finish()
+			ctx, cancel := context.WithCancel(stage)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var path string
+			switch mutation {
+			case "close":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "cancel":
+				cancel()
+			case "file":
+				path = filepath.Join(request.Directory, "value.go")
+			case "object":
+				path = filepath.Join(source.owned, request.AssemblyFile+".o")
+			case "listing":
+				path = filepath.Join(source.owned, request.AssemblyFile+".o.listing")
+			case "export":
+				path = source.selection.Export
+			case "post-consumer":
+				calls := 0
+				bound.ResolveSym = func(symbol string) string {
+					calls++
+					if calls == 1 {
+						if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package changed\n"), 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+					return options.ResolveSym(symbol)
+				}
+			}
+			if path != "" {
+				if err := os.WriteFile(path, []byte("mutation"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+			if mutation != "post-consumer" && source.ready {
+				t.Fatal("failed observer verification did not permanently revoke the binding")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameResolverCannotChangeParsedSourceAfterValidation(t *testing.T) {
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := bound.ResolveSym
+			bound.ResolveSym = func(symbol string) string {
+				for index := range file.Funcs[0].Instrs {
+					ins := &file.Funcs[0].Instrs[index]
+					if ins.Op == "PADDQ" {
+						ins.Op = "PADDB"
+						ins.Raw = strings.Replace(ins.Raw, "PADDQ", "PADDB", 1)
+					}
+				}
+				return resolve(symbol)
+			}
+			if api == "Translate" {
+				ir, err := Translate(file, bound)
+				fixedLocalRequireContext(t, ir, err)
+				return
+			}
+			if api == "Module" {
+				llvmContext := llvm.NewContext()
+				defer llvmContext.Dispose()
+				module, err := TranslateModuleInContext(llvmContext, file, bound)
+				if !module.IsNil() {
+					defer module.Dispose()
+					t.Fatal("resolver-mutated original source produced a module")
+				}
+				fixedLocalRequireContext(t, "", err)
+				return
+			}
+			// GoModule reparses the original bytes into its own private file;
+			// this public-file mutation cannot change that source. Its resolver
+			// is frozen before consumer normalization, so the original opcode
+			// must remain independently bound rather than silently substituted.
+			original := strings.Builder{}
+			for _, ins := range file.Funcs[0].Instrs {
+				original.WriteString(ins.Raw + "\n")
+			}
+			translation, err := TranslateGoModule(pkg, []byte(original.String()), GoModuleOptions{
+				GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple,
+				Sizes: types.SizesFor("gc", "amd64"), ResolveSym: bound.ResolveSym,
+				ManualSig: func(name string) (FuncSig, bool) { sig, found := bound.Sigs[name]; return sig, found },
+			})
+			if translation != nil && !translation.Module.IsNil() {
+				defer translation.Module.Dispose()
+			}
+			if err != nil || translation == nil || !strings.Contains(translation.Module.String(), "paddq") {
+				t.Fatalf("GoModule did not preserve its independent original source: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameProofFullByteWidthAddressAndControlNegatives(t *testing.T) {
+	base, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "PADDQ 16(SP),X0")
+	mutations := map[string]string{
+		"alignment":                strings.Replace(base, "ADDQ $32,SP", "ADDQ $33,SP", 1),
+		"read extent":              strings.Replace(base, "PADDQ 16(SP)", "PADDQ 152(SP)", 1),
+		"write extent":             strings.Replace(base, "MOVQ AX,16(SP)", "MOVQ AX,160(SP)", 1),
+		"unknown pointer":          strings.Replace(base, "PADDQ 16(SP)", "PADDQ 16(SI)", 1),
+		"indexed pointer":          strings.Replace(base, "PADDQ 16(SP)", "PADDQ 16(SP)(AX*1)", 1),
+		"segment":                  strings.Replace(base, "PADDQ 16(SP)", "PADDQ 16(FS)", 1),
+		"pointer result":           strings.Replace(base, "MOVQ AX,ret+32(FP)", "MOVQ R11,ret+32(FP)", 1),
+		"pointer flags":            strings.Replace(base, "MOVQ AX,ret+32(FP)", "CMPQ R11,AX\nMOVQ AX,ret+32(FP)", 1),
+		"pointer truncated":        strings.Replace(base, "MOVQ SP,R11", "MOVL SP,R11", 1),
+		"missing restore":          strings.Replace(base, "MOVQ R11,SP", "MOVQ $0,R10", 1),
+		"pointer cell clobber":     strings.Replace(base, "MOVQ 96(SP),R11", "MOVB $1,96(SP)\nMOVQ 96(SP),R11", 1),
+		"pointer bytes as numeric": strings.Replace(base, "PADDQ 16(SP)", "PADDQ 96(SP)", 1),
+		"unknown call":             strings.Replace(base, "PADDQ", "CALL ·Other(SB)\nPADDQ", 1),
+		"unknown dead effect":      base + "SYSCALL\n",
+		"result width":             strings.Replace(base, "MOVQ AX,ret+32(FP)", "MOVL AX,ret+32(FP)", 1),
+		"local spill escape":       strings.Replace(base, "MOVQ AX,ret+32(FP)", "MOVQ R11,·global(SB)\nMOVQ AX,ret+32(FP)", 1),
+		"unknown flags branch":     strings.Replace(base, "MOVQ AX,16(SP)", "JEQ done\nMOVQ AX,16(SP)", 1) + "done:\nRET\n",
+		"FP after SP change":       strings.Replace(base, "MOVQ AX,16(SP)", "MOVQ a+0(FP),AX\nMOVQ AX,16(SP)", 1),
+		"high legacy vector bank":  strings.ReplaceAll(base, "X0", "X16"),
+	}
+	for byteIndex := 0; byteIndex < 16; byteIndex++ {
+		var stores strings.Builder
+		for index := 0; index < 16; index++ {
+			if index != byteIndex {
+				fmt.Fprintf(&stores, "MOVB $1,%d(SP)\n", 16+index)
+			}
+		}
+		mutated := strings.Replace(base, "MOVQ AX,16(SP)\nMOVQ CX,24(SP)\n", stores.String(), 1)
+		mutations[fmt.Sprintf("missing byte %02d", byteIndex)] = mutated
+	}
+	for name, source := range mutations {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved source admitted: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalFrameAllPathInitializationAndResourceBounds(t *testing.T) {
+	base, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "PADDQ 16(SP),X0")
+	branch := strings.Replace(base, "MOVQ CX,24(SP)", "MOVQ CX,24(SP)\nCMPQ AX,CX\nJEQ joined\nMOVQ CX,24(SP)\njoined:", 1)
+	requireX86GoAssemblerResult(t, "amd64", branch, true)
+	file, err := Parse(ArchAMD64, branch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proved, err := proveX86FixedLocal(file.Funcs[0], sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, ins := range proved.Instrs {
+		if ins.Op != "PADDQ" {
+			continue
+		}
+		access := ins.x86FixedLocalMemory[0]
+		if access.offset != [8]int64{48, 40, 32, 24, 48, 40, 32, 24} {
+			t.Fatalf("missing all original SP residue accesses: %v", access.offset)
+		}
+	}
+	for name, source := range map[string]string{
+		"one predecessor uninitialized": strings.Replace(branch, "MOVQ CX,24(SP)\nCMPQ", "CMPQ", 1),
+		"stale pointer flags":           strings.Replace(branch, "CMPQ AX,CX", "ADDQ $0,SP", 1),
+		"loop loses flags":              strings.Replace(branch, "JEQ joined", "before:\nJEQ joined\nIMULQ $3,AX\nJMP before", 1),
+		"different address join":        strings.Replace(branch, "JEQ joined\nMOVQ CX,24(SP)", "JEQ joined\nADDQ $8,SP\nMOVQ CX,24(SP)", 1),
+		"fallthrough":                   strings.TrimSuffix(base, "RET\n"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved CFG gained backing: %v", err)
+			}
+		})
+	}
+	tooLarge := file.Funcs[0]
+	tooLarge.FrameSize = 1 << 20
+	if _, err := proveX86FixedLocal(tooLarge, sig); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("oversized physical frame was admitted")
+	}
+	// A long straight block no longer retains one state per instruction.
+	// Exercise the unchanged storage cap with actual control-flow boundaries.
+	tooLarge, largeSig := fixedLocalRetainedStateBudgetFixture(t)
+	if _, err := proveX86FixedLocal(tooLarge, largeSig); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "state storage budget") {
+		t.Fatal("retained frame-state storage budget was ignored", err)
+	}
+}
+
+func TestGoAMD64FixedLocalFrameResidueDependentAliasesCannotRelocate(t *testing.T) {
+	base, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "PADDQ 16(SP),X0")
+	// Both address origins belong to the same local frame, and every byte is
+	// initialized for every residue. Nevertheless this write overlaps the
+	// source's low word, high word or neither depending on original SP mod 32.
+	// A new physical alloca cannot silently choose one of these observations.
+	source := strings.Replace(base, "MOVQ BX,56(SP)", "MOVQ BX,56(SP)\nMOVQ $1,48(R11)", 1)
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("residue-dependent initialized aliases were relocated: %v", err)
+	}
+	// Independent little-endian byte-memory mathematics, not the production
+	// address/state/certificate implementation, exposes the actual data change.
+	want := [4][2]uint64{{6, 10}, {7, 8}, {7, 10}, {7, 10}}
+	for residue := 0; residue < 4; residue++ {
+		var memory [256]byte
+		sp := 32 + residue*8
+		aligned := sp&^31 + 32
+		for index, value := range []uint64{2, 3} {
+			binary.LittleEndian.PutUint64(memory[aligned+16+index*8:], value)
+		}
+		for index, value := range []uint64{5, 7} {
+			binary.LittleEndian.PutUint64(memory[aligned+48+index*8:], value)
+		}
+		binary.LittleEndian.PutUint64(memory[sp+48:], 1)
+		got := [2]uint64{}
+		for index := range got {
+			got[index] = binary.LittleEndian.Uint64(memory[aligned+16+index*8:]) +
+				binary.LittleEndian.Uint64(memory[aligned+48+index*8:])
+		}
+		if got != want[residue] {
+			t.Fatalf("independent original residue %d data: got %v want %v", residue, got, want[residue])
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalFrameCertificatesArePrivateExactAndRevocable(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64", bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := normalized.Funcs[0]
+	lower := &amd64Ctx{fixedLocal: fn.x86FixedLocal}
+	for _, ins := range fn.Instrs {
+		for index, access := range ins.x86FixedLocalMemory {
+			if !lower.fixedLocalMemoryCertified(ins, index) {
+				t.Fatal("missing independently replayed original access")
+			}
+			for residue, offset := range access.offset {
+				if offset < 0 || offset+access.width > 160 {
+					t.Fatalf("invalid residue %d certified extent", residue)
+				}
+			}
+			for _, mutation := range []string{"op", "args", "width", "owner", "JSON", "address size"} {
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.x86FixedLocalMemory = make(map[int]x86FixedLocalAccess)
+				for key, value := range ins.x86FixedLocalMemory {
+					changed.x86FixedLocalMemory[key] = value
+				}
+				switch mutation {
+				case "op":
+					changed.Op = "UNDEF"
+				case "args":
+					changed.Args[index].Mem.Off++
+				case "width":
+					value := changed.x86FixedLocalMemory[index]
+					value.width++
+					changed.x86FixedLocalMemory[index] = value
+				case "owner":
+					value := changed.x86FixedLocalMemory[index]
+					value.owner = &x86FixedLocalProof{}
+					changed.x86FixedLocalMemory[index] = value
+				case "JSON":
+					data, _ := json.Marshal(ins)
+					changed = Instr{}
+					if err := json.Unmarshal(data, &changed); err != nil {
+						t.Fatal(err)
+					}
+				case "address size":
+					changed.x86AddressBits = 32
+				}
+				if lower.fixedLocalMemoryCertified(changed, index) {
+					t.Fatalf("%s preserved a stale native access certificate", mutation)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_fixed_local_framed_leaf.go b/amd64_fixed_local_framed_leaf.go
new file mode 100644
index 000000000..4b769d72f
--- /dev/null
+++ b/amd64_fixed_local_framed_leaf.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import "fmt"
+
+// The existing expansion gives every helper RET one original callsite resume.
+// Reuse that identity; no independent call graph or stack-coordinate map exists.
+func (view *x86DirectTailRoot) privateFramedCall(pc int) (int, bool) {
+	if !view.privateCallTransition(pc) || view.graph == nil || view.graph.fixedLocal == nil {
+		return 0, false
+	}
+	call := pc
+	if view.instructions[pc].Op == OpRET {
+		call = view.edges[pc][0] - 1
+	}
+	if call < 0 || call >= len(view.instructions) || view.instructions[call].Op != OpCALL || len(view.edges[call]) != 1 {
+		return 0, false
+	}
+	target := view.edges[call][0]
+	if target < 0 || target >= len(view.points) {
+		return 0, false
+	}
+	fn := view.graph.original.Funcs[view.points[target].text]
+	return call, fn.FrameSize > 0 && view.graph.fixedLocal.leaves[fn.Sym] != ""
+}
+
+// A source leaf cannot call another helper. One immutable saved value therefore
+// suffices, including partially known bytes and addresses; it grants no read.
+type x86FixedLocalSavedBP struct {
+	call  int
+	value fixedLocalScalarValue
+	known uint8
+}
+
+func fixedLocalFrameTransition(view *x86DirectTailRoot, pc int, state *x86FixedLocalState) error {
+	call, framed := view.privateFramedCall(pc)
+	if !framed {
+		return nil // An observed zero-frame leaf preserves BP and FLAGS.
+	}
+	var saved *x86FixedLocalSavedBP
+	if view.instructions[pc].Op == OpCALL {
+		if state.savedBP != nil {
+			return goAMD64FrameContext("framed source leaf acquired a nested call")
+		}
+		saved = &x86FixedLocalSavedBP{call: call, known: state.known[BP]}
+		saved.value.address, saved.value.pointer = state.pointers[BP]
+		saved.value.identity, saved.value.opaque = state.opaque[BP]
+		saved.value.constant, saved.value.constantKnown = state.constants[BP]
+		saved.value.bounds, saved.value.bounded = state.ranges[BP]
+		saved.value.booleans = state.booleans[BP]
+		state.savedBP = saved
+	} else {
+		saved = state.savedBP
+		if saved == nil || saved.call != call {
+			return goAMD64FrameContext("framed leaf RET lost its matching saved BP")
+		}
+		state.savedBP = nil
+	}
+	delete(state.pointers, BP)
+	delete(state.opaque, BP)
+	delete(state.constants, BP)
+	delete(state.ranges, BP)
+	delete(state.booleans, BP)
+	state.known[BP] = 0
+	state.flags = 0
+	state.comparison = x86FixedLocalComparison{}
+	if view.instructions[pc].Op == OpRET {
+		value := saved.value
+		state.known[BP], state.booleans[BP] = saved.known, value.booleans
+		if value.pointer {
+			state.pointers[BP] = value.address
+		}
+		if value.opaque {
+			state.opaque[BP] = value.identity
+		}
+		if value.constantKnown {
+			state.constants[BP] = value.constant
+		}
+		if value.bounded {
+			state.setRange(BP, value.bounds)
+		}
+	}
+	return nil
+}
+
+func mergeFixedLocalSavedBP(previous *x86FixedLocalState, current x86FixedLocalState) (bool, error) {
+	first, last := previous.savedBP, current.savedBP
+	if first == last {
+		return false, nil
+	}
+	if first == nil || last == nil || first.call != last.call {
+		return false, goAMD64FrameContext("fixed local CFG crosses distinct automatic BP saves")
+	}
+	left, right := first.value, last.value
+	if left.opaque != right.opaque {
+		// Match the ordinary register join: an address on only one incoming
+		// path becomes unknown, never numerical knowledge or private storage.
+		left.opaque, right.opaque = false, false
+		left.identity, right.identity = x86FixedLocalOrigins{}, x86FixedLocalOrigins{}
+	}
+	value, compatible := mergeFixedLocalScalarValues(left, right)
+	if !compatible {
+		return false, goAMD64FrameContext("saved BP has inconsistent private address identities")
+	}
+	merged := x86FixedLocalSavedBP{call: first.call, value: value, known: first.known & last.known}
+	if merged == *first {
+		return false, nil
+	}
+	previous.savedBP = &merged
+	return true, nil
+}
+
+func (c *amd64Ctx) lowerPrivateFrameTransition(pc int) error {
+	call, framed := c.directTail.privateFramedCall(pc)
+	if !framed {
+		return nil
+	}
+	slot := fmt.Sprintf("%%private_call_bp_%d", call)
+	if c.directTail.instructions[pc].Op == OpCALL {
+		value, err := c.loadReg(BP)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", value, slot)
+		return nil
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", value, slot)
+	return c.storeReg(BP, "%"+value)
+}
diff --git a/amd64_fixed_local_framed_leaf_go127_test.go b/amd64_fixed_local_framed_leaf_go127_test.go
new file mode 100644
index 000000000..2e985ae72
--- /dev/null
+++ b/amd64_fixed_local_framed_leaf_go127_test.go
@@ -0,0 +1,299 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type fixedLocalFramedLeafCase struct {
+	name, caller, helper string
+	frame                int
+}
+
+func fixedLocalFramedLeafCases() []fixedLocalFramedLeafCase {
+	helper := "MOVQ $7,BP\n ADDQ BP,AX"
+	return []fixedLocalFramedLeafCase{
+		{"numeric_bp", "MOVQ $11,BP\n CALL leaf<>(SB)\n ADDQ BP,AX", helper, 8},
+		{"private_address_bp", "LEAQ 16(SP),BP\n CALL leaf<>(SB)\n ADDQ (BP),AX", helper, 16},
+		{"unknown_bp", "CALL leaf<>(SB)", helper, 24},
+		{"untouched_bp", "CALL leaf<>(SB)", "ADDQ $7,AX", 56},
+		{"partial_bp", "MOVB $11,BP\n CALL leaf<>(SB)\n MOVBLZX BP,BX\n ADDQ BX,AX", helper, 32},
+		{"two_call_sites", "MOVQ $3,BP\n CALL leaf<>(SB)\n ADDQ BP,AX\n CALL leaf<>(SB)\n ADDQ BP,AX", helper, 40},
+		{"loop_reentry", "MOVQ $11,BP\n MOVQ $3,SI\nagain:\n CALL leaf<>(SB)\n ADDQ BP,AX\n DECQ SI\n JNZ again", helper, 64},
+		{"two_returns", "LEAQ 16(SP),BP\n CALL leaf<>(SB)\n ADDQ (BP),AX", `MOVQ $7,BP
+ CMPQ AX,BP
+ JCS small
+ ADDQ BP,AX
+ RET
+small:
+ SUBQ BP,AX`, 128},
+	}
+}
+
+func fixedLocalFramedLeafSource(row fixedLocalFramedLeafCase) string {
+	return fmt.Sprintf(`TEXT ·Value(SB),4,$80-16
+ MOVQ a+0(FP),AX
+ MOVQ AX,16(SP)
+ MOVQ $7,BX
+ %s
+ MOVQ AX,ret+8(FP)
+ RET
+TEXT leaf<>(SB),4,$%d
+ %s
+ RET
+`, row.caller, row.frame, row.helper)
+}
+
+func TestGoAMD64FixedLocalFramedLeafCompleteSources(t *testing.T) {
+	for _, row := range fixedLocalFramedLeafCases() {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalFramedLeafSource(row)
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil || strings.Count(ir, "define ") != 1 {
+						t.Fatal("observed framed leaf lost its caller or acquired an independent ABI", err)
+					}
+					fixedLocalPrivateLeafObjects(t, ir)
+				})
+		})
+	}
+}
+
+const fixedLocalFramedLeafIncomingAddress = `TEXT ·Value(SB),4,$80-16
+ MOVQ a+0(FP),BP
+ MOVQ (BP),AX
+ CALL leaf<>(SB)
+ ADDQ (BP),AX
+ MOVQ AX,ret+8(FP)
+ RET
+TEXT leaf<>(SB),4,$48
+ MOVQ $7,BP
+ ADDQ BP,AX
+ RET
+`
+
+func TestGoAMD64FixedLocalFramedLeafIncomingAddress(t *testing.T) {
+	x86InsertExtractGoListing(t, "amd64", fixedLocalFramedLeafIncomingAddress)
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, fixedLocalFramedLeafIncomingAddress,
+		"func Value(a *uint64) uint64")
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal("caller incoming address did not survive the observed helper frame", err)
+			}
+			fixedLocalPrivateLeafObjects(t, ir)
+		})
+}
+
+func TestGoAMD64WindowsFramedLeafCompleteObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, spelling := range []string{"leaf<>", "leaf"} {
+		t.Run(spelling, func(t *testing.T) {
+			assembly := strings.ReplaceAll(fixedLocalFramedLeafSource(fixedLocalFramedLeafCases()[1]), "leaf<>", spelling)
+			dir := t.TempDir()
+			input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+			if err := os.WriteFile(input, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "oracle", "-o", object, input)
+			command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=windows", "GOARCH=amd64")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, "amd64"); failure != nil {
+				t.Fatalf("original Windows framed-helper object: %v\n%s", failure, output)
+			}
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			request.Target = "windows/amd64"
+			options.TargetTriple = "x86_64-pc-windows-msvc"
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("Windows helper lost its complete frame and SEH observation", err)
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "framed-leaf.ll", "framed-leaf.o", ir)
+					compileLLVMToObject(t, llc, options.TargetTriple, "framed-leaf-opt.ll", "framed-leaf-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
+
+func TestGoAMD64WindowsFramedLeafRequiresSEH(t *testing.T) {
+	assembly := fixedLocalFramedLeafSource(fixedLocalFramedLeafCases()[1])
+	pkg, request, _ := fixedLocalPrivateLeafFixture(t, assembly)
+	request.Target = "windows/amd64"
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	object, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	listing, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := source.frameDataObject(assembly, object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	leaves, err := goAMD64WindowsSourceLeafTexts(file, pkg, listing, data.Member.Texts, data.TextOrder)
+	if err != nil || len(leaves) != 1 {
+		t.Fatal("original source lost its single private framed helper", err)
+	}
+	observed, err := source.observeWindowsUnwind(object, leaves)
+	if err != nil {
+		t.Fatal("original framed helper must carry actual Go unwind metadata", err)
+	}
+	for index, text := range observed.Texts {
+		if text.Index != leaves[0].Index {
+			continue
+		}
+		filtered := text.Auxiliary[:0:0]
+		links := 0
+		for _, aux := range text.Auxiliary {
+			if aux.Type == observed.AuxType {
+				links++
+			} else {
+				filtered = append(filtered, aux)
+			}
+		}
+		if links != 1 {
+			t.Fatal("original private frame lacks exactly one SEH owner", links)
+		}
+		observed.Texts[index].Auxiliary = filtered
+		if err := goAMD64FrameWindowsUnwindFunctions(source.functions, source.origins, request.Directory, observed); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("framed helper borrowed the zero-frame SEH exemption", err)
+		}
+		return
+	}
+	t.Fatal("original complete object lost its helper TEXT")
+}
+
+func TestGoAMD64FixedLocalFramedLeafBoundaries(t *testing.T) {
+	for _, row := range []fixedLocalFramedLeafCase{
+		{"incoming_bp", "MOVQ $11,BP\n CALL leaf<>(SB)", "MOVQ BP,AX", 8},
+		{"incoming_bp_memory", "LEAQ 16(SP),BP\n CALL leaf<>(SB)", "MOVQ (BP),AX", 8},
+		{"partial_callee_bp", "CALL leaf<>(SB)", "MOVB $11,BP\n MOVQ BP,AX", 16},
+		{"partial_caller_bp", "MOVB $11,BP\n CALL leaf<>(SB)\n MOVQ BP,AX", "MOVQ $7,BP", 24},
+		{"incoming_flags", "CMPQ AX,BX\n CALL leaf<>(SB)", "SETCS CL\n MOVBLZX CL,AX", 32},
+		{"returned_flags", "CALL leaf<>(SB)\n SETCS CL\n MOVBLZX CL,AX", "CMPQ AX,BX", 128},
+		{"different_saved_private_bp", `LEAQ 16(SP),BP
+ LEAQ 24(SP),R8
+ MOVQ $3,SI
+again:
+ CALL leaf<>(SB)
+ XCHGQ BP,R8
+ DECQ SI
+ JNZ again`, "MOVQ $7,BP\n ADDQ BP,AX", 8},
+		{"no_automatic_bp", "MOVQ $11,BP\n CALL leaf<>(SB)\n ADDQ BP,AX", "MOVQ $7,BP\n ADDQ BP,AX", 8},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalFramedLeafSource(row)
+			if row.name == "no_automatic_bp" {
+				// NOSPLIT|NOFRAME is legal Go source with explicit locals,
+				// but it lacks the automatic BP save that this class requires.
+				assembly = strings.Replace(assembly, "TEXT leaf<>(SB),4,$8", "TEXT leaf<>(SB),516,$8", 1)
+			}
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if owner != nil {
+				defer owner.Close()
+			}
+			if err != nil && row.name != "no_automatic_bp" {
+				t.Fatal("semantic boundary requires successful original source/frame capture", err)
+			}
+			if err == nil {
+				file, parseErr := Parse(ArchAMD64, assembly)
+				if parseErr != nil {
+					t.Fatal(parseErr)
+				}
+				_, err = owner.BindFixedLocal(ctx, pkg, file, options)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("automatic frame supplied caller BP or arithmetic FLAGS to source", err)
+			}
+			t.Logf("original Go accepted; observed frame or typed state refused: %v", err)
+		})
+	}
+}
+
+func TestGoAMD64SDKFramedLeafWholeOriginalSource(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/internal/fips140/nistec")
+	original, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete original SDK source/object precondition", err)
+	}
+	defer original.Close()
+	pkg := sdkAMD64FrameActualPackage(t, original.source)
+	owner, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, Target: request.Target,
+		AssemblyFile: "p256_asm_amd64.s", Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("complete SDK source lost its independently observed helper frames", err)
+	}
+	defer owner.Close()
+	// This supersedes the former whole-source rejection: automatic private
+	// frames now have an observed contract. Keep every original TEXT and the
+	// native-identity negatives below; cropping the helper is not acceptance.
+	expanded := owner.sdkFrame.owner.source.observation.CPP[0].Output
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil || len(file.Funcs) != len(owner.functions) {
+		t.Fatal("complete original SDK TEXT inventory changed", err)
+	}
+	for _, name := range []string{"p256MulInternal", "p256SqrInternal"} {
+		fn, found := owner.functions[name]
+		if !found || !fn.privateLeaf || fn.locals != 16 || fn.signature.Name != "" || len(fn.code) == 0 {
+			t.Fatal("original nonzero helper lost its native frame or acquired a callable ABI", name)
+		}
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("complete SDK frame observation changed during consumption", err)
+	}
+	data := owner.sdkFrame.owner.source
+	data.operation.Lock()
+	defer data.operation.Unlock()
+	controls := 0
+	for frame := range data.observation.Frames {
+		for index := range data.observation.Frames[frame].Records {
+			record := &data.observation.Frames[frame].Records[index]
+			if record.Symbol != "p256MulInternal" && record.Symbol != "p256SqrInternal" {
+				continue
+			}
+			for _, locals := range []uint64{0, 8, 24} {
+				t.Run(fmt.Sprintf("%s/native_locals_%d", record.Symbol, locals), func(t *testing.T) {
+					original := record.Locals
+					record.Locals = locals
+					_, _, err := owner.sdkFrameRecords()
+					record.Locals = original
+					if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "SDK-primary private leaf/native identity differs") {
+						t.Fatal("mismatched native locals acquired the original helper frame", err)
+					}
+				})
+				controls++
+			}
+		}
+	}
+	if controls != 6 {
+		t.Fatal("complete original SDK helper mismatch inventory changed", controls)
+	}
+}
diff --git a/amd64_fixed_local_framed_leaf_runtime_go127_test.go b/amd64_fixed_local_framed_leaf_runtime_go127_test.go
new file mode 100644
index 000000000..32ec428fa
--- /dev/null
+++ b/amd64_fixed_local_framed_leaf_runtime_go127_test.go
@@ -0,0 +1,148 @@
+//go:build linux && amd64 && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalFramedLeaf(t *testing.T) {
+	cases := fixedLocalFramedLeafCases()
+	var assembly, declarations strings.Builder
+	for index, row := range cases {
+		name := fmt.Sprintf("Value%d", index)
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		source := strings.NewReplacer("·Value(", "·"+name+"(", "leaf<>", fmt.Sprintf("leaf%d<>", index)).Replace(
+			fixedLocalFramedLeafSource(row))
+		assembly.WriteString(source)
+	}
+	inputs := []uint64{0, 1, 6, 7, 8, 0xffffffff, 0x100000000, ^uint64(0)}
+	expected := make([][]string, len(inputs))
+	for index, input := range inputs {
+		for _, row := range cases {
+			var result uint64
+			switch row.name {
+			case "numeric_bp", "partial_bp":
+				result = input + 18
+			case "private_address_bp":
+				result = input*2 + 7
+			case "unknown_bp", "untouched_bp":
+				result = input + 7
+			case "two_call_sites":
+				result = input + 20
+			case "loop_reentry":
+				result = input + 54
+			case "two_returns":
+				result = input*2 + 7
+				if input < 7 {
+					result = input*2 - 7
+				}
+			default:
+				t.Fatal("missing independent original-frame oracle", row.name)
+			}
+			expected[index] = append(expected[index], fmt.Sprintf("%016x", result))
+		}
+	}
+	fixedLocalResultsRuntime(t, assembly.String(), declarations.String(), inputs, expected)
+	if !t.Failed() {
+		t.Logf("FRAMED_LEAF_NATIVE_COMPLETE functions=%d inputs_per_function=%d APIs=3 LLVM_levels=O0,O2 original_observations=%d LLVM_comparisons=%d",
+			len(cases), len(inputs), len(cases)*len(inputs), len(cases)*len(inputs)*3*2)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FramedLeafIncomingAddress(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	inputs := []uint64{0, 1, 0xffffffff, 0x100000000, ^uint64(0)}
+	var goCalls, cCalls strings.Builder
+	var expected []string
+	for _, input := range inputs {
+		fmt.Fprintf(&goCalls, "{ a := uint64(0x%x); fmt.Printf(\"%%016x\\n\",Value(&a)) }\n", input)
+		fmt.Fprintf(&cCalls, "{ uint64_t a = UINT64_C(0x%x); printf(\"%%016llx\\n\",(unsigned long long)value(&a)); }\n", input)
+		expected = append(expected, fmt.Sprintf("%016x", input*2+7))
+	}
+	const declaration = "func Value(a *uint64) uint64"
+	original := "package main\nimport \"fmt\"\n" + declaration + "\nfunc main() {\n" + goCalls.String() + "}\n"
+	want := strings.Fields(string(x86ScalarFloatIntegerOriginalOutput(t, execution, fixedLocalFramedLeafIncomingAddress, original)))
+	if strings.Join(want, " ") != strings.Join(expected, " ") {
+		t.Fatal("original helper did not restore its caller's input address", want, expected)
+	}
+	label := runtimeCAsmLabel("example.invalid/framefixture.Value")
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + runtimeCAsmLabelPreamble +
+		"extern uint64_t value(uint64_t *) __asm__(" + label + ");\nint main(void) {\n" + cCalls.String() + "return 0;\n}\n"
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, fixedLocalFramedLeafIncomingAddress, declaration)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					got := strings.Fields(string(execution.compileAndRunLLVM(t, "framed-leaf-input-address", input, driver, level)))
+					if strings.Join(got, " ") != strings.Join(want, " ") {
+						t.Fatal("translated helper changed caller input-address semantics", got, want)
+					}
+				})
+			}
+		})
+	if !t.Failed() {
+		t.Logf("FRAMED_LEAF_NATIVE_ADDRESS functions=1 inputs_per_function=%d APIs=3 LLVM_levels=O0,O2 original_observations=%d LLVM_comparisons=%d",
+			len(inputs), len(inputs), len(inputs)*3*2)
+	}
+}
+
+// These accepted original Go programs observe the automatic physical frame.
+// Their framed variants deliberately remain translation counterexamples:
+// arithmetic FLAGS do not retain their caller/body value across ADD/SUB SP.
+func TestCrossLinuxRuntimeMatrixGoAMD64FramedLeafPhysicalFlags(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var assembly, declarations, calls strings.Builder
+	var frames []int
+	for _, frame := range []int{0, 8, 128} {
+		for _, incoming := range []bool{true, false} {
+			row := fixedLocalFramedLeafCase{
+				caller: "CALL leaf<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+				helper: "CMPQ AX,BX",
+				frame:  frame,
+			}
+			if incoming {
+				row.caller = "CMPQ AX,BX\n CALL leaf<>(SB)"
+				row.helper = "SETCS CL\n MOVBLZX CL,AX"
+			}
+			index := len(frames)
+			name := fmt.Sprintf("Value%d", index)
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			fmt.Fprintf(&calls, "fmt.Println(%s(0))\nfmt.Println(%s(8))\n", name, name)
+			assembly.WriteString(strings.NewReplacer("·Value(", "·"+name+"(",
+				"leaf<>", fmt.Sprintf("leaf%d<>", index)).Replace(fixedLocalFramedLeafSource(row)))
+			frames = append(frames, frame)
+		}
+	}
+	original := "package main\nimport \"fmt\"\n" + declarations.String() + "func main() {\n" + calls.String() + "}\n"
+	got := strings.Fields(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly.String(), original)))
+	if len(got) != 2*len(frames) {
+		t.Fatal("original physical-FLAGS observation inventory changed", len(got))
+	}
+	for index, frame := range frames {
+		first, second := got[2*index], got[2*index+1]
+		if frame == 0 {
+			if first != "1" || second != "0" {
+				t.Fatal("original zero-frame CALL/RET did not preserve both carry values", first, second)
+			}
+			continue
+		}
+		// Go can encode a 128-byte adjustment using the opposite operation
+		// and a negative imm8. Do not assume every physical frame clears CF;
+		// neither encoding preserves the preceding arithmetic input's CF.
+		if first != second || first != "0" && first != "1" {
+			t.Fatal("original automatic frame unexpectedly preserved arithmetic CF", frame, first, second)
+		}
+	}
+	t.Logf("FRAMED_LEAF_PHYSICAL_FLAGS original_only=true functions=%d inputs_per_function=2 original_observations=%d LLVM_comparisons=0",
+		len(frames), len(frames)*2)
+}
diff --git a/amd64_fixed_local_global.go b/amd64_fixed_local_global.go
new file mode 100644
index 000000000..04bc6d833
--- /dev/null
+++ b/amd64_fixed_local_global.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// Keep native addresses opaque through the existing CFG, affine and spill
+// transfers. A Go variable is not an FP slot, numeric bits or private storage.
+type x86FixedLocalOrigin struct {
+	parameter int64
+	global    string
+	literal   x86StaticSBAddress
+}
+
+func fixedLocalGlobalSymbol(symbol string) string {
+	if !strings.ContainsAny(symbol, "·./") {
+		return "·" + symbol
+	}
+	return symbol
+}
+
+func fixedLocalStaticAddress(ins Instr) (x86StaticSBAddress, bool) {
+	ins = x86SourceMoveInstruction(ins, "amd64")
+	if ins.Op != "LEAQ" && x86RawReturnScalarMoveBytes(ins.Op) != 8 ||
+		!x86ResultNamedPredicateInstruction(ins) || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		return x86StaticSBAddress{}, false
+	}
+	root, valid := x86CallerGP(ins.Args[1].Reg)
+	if !valid || root != ins.Args[1].Reg || root == SP {
+		return x86StaticSBAddress{}, false
+	}
+	if ins.Op == "LEAQ" {
+		width, err := x86LEAOperandWidth(ins, "amd64")
+		address, valid := x86StaticSBSourceAddress(ins.Args[0], "amd64")
+		return address, err == nil && width == 8 && valid
+	}
+	address, immediate, valid := x86StaticAddressValueSource(ins.Args[0], "amd64")
+	return address, valid && immediate
+}
+
+func fixedLocalGlobalSymbols(file *File) map[string]bool {
+	var symbols map[string]bool
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			address, valid := fixedLocalStaticAddress(ins)
+			if !valid || ins.Op == "LEAQ" {
+				continue
+			}
+			if symbols == nil {
+				symbols = make(map[string]bool)
+			}
+			symbols[fixedLocalGlobalSymbol(address.symbol)] = true
+		}
+	}
+	return symbols
+}
+
+// Resolve only actual same-package variable candidates. The caller freezes
+// callbacks outside its source lock; the same original typecheck below joins
+// their complete numerical layout. No process, new source owner or initializer
+// evaluation is needed, and no initializer bytes become LLVM constants.
+func fixedLocalGlobalRequests(pkg GoPackage, file *File, resolve func(string) string) (map[string]goReadOnlyObject, error) {
+	var objects map[string]goReadOnlyObject
+	for symbol := range fixedLocalGlobalSymbols(file) {
+		name := goReadOnlyLocalName(pkg, symbol)
+		variable, exists := pkg.Types.Scope().Lookup(name).(*types.Var)
+		if !exists || variable.IsField() || variable.Pkg() != pkg.Types {
+			continue
+		}
+		native := gosym.PackagePrefix(pkg.Path) + "." + name
+		if resolve(symbol) != native {
+			return nil, goAMD64FrameContext("ordinary Go variable has a foreign native identity: %s", symbol)
+		}
+		if objects == nil {
+			objects = make(map[string]goReadOnlyObject)
+		}
+		objects[symbol] = goReadOnlyObject{native: native}
+	}
+	return objects, nil
+}
+
+// Called inside the frame observer's one complete independent typecheck.
+// Reuse the ordinary numerical-variable layout grammar, never just a name,
+// supplied type, guessed extent, symbol address or the variable's initial value.
+func joinFixedLocalGlobalDeclarations(actual, supplied *types.Package, syntax []*ast.File, sizes types.Sizes, objects map[string]goReadOnlyObject) error {
+	if len(objects) == 0 {
+		return nil
+	}
+	declarations := make(map[string]goReadOnlyObject, len(objects))
+	for symbol, object := range objects {
+		name := goReadOnlyName(actual.Path(), symbol)
+		variable, found := actual.Scope().Lookup(name).(*types.Var)
+		previous, provided := supplied.Scope().Lookup(name).(*types.Var)
+		if !found || !provided || variable.IsField() || previous.IsField() || variable.Pkg() != actual {
+			return goAMD64FrameContext("ordinary address lacks its original Go variable: %s", symbol)
+		}
+		size, spans, shape, err := goReadOnlyLayout(variable.Type(), sizes)
+		priorSize, priorSpans, priorShape, priorErr := goReadOnlyLayout(previous.Type(), sizes)
+		if err != nil || priorErr != nil || size != priorSize || shape != priorShape || !reflect.DeepEqual(spans, priorSpans) {
+			return goAMD64FrameContext("ordinary Go variable differs from its complete original numerical type: %s", symbol)
+		}
+		object.variable, object.size, object.spans, object.shape = variable, size, spans, shape
+		objects[symbol], declarations[name] = object, object
+	}
+	return goReadOnlyCheckAliases(syntax, actual, declarations)
+}
diff --git a/amd64_fixed_local_global_runtime_test.go b/amd64_fixed_local_global_runtime_test.go
new file mode 100644
index 000000000..1500c6579
--- /dev/null
+++ b/amd64_fixed_local_global_runtime_test.go
@@ -0,0 +1,80 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalMutableGlobal(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	goAMD64FramePrepareOwnedToolCache(t)
+	const original = `package main
+import "fmt"
+var Table [4]uint64
+func Value(a uint64) uint64
+func main() {
+    for i := uint64(0); i < 17; i++ {
+        for j := range Table { Table[j] = (i + uint64(j)) * 0x1020304050607081 }
+        fmt.Printf("%016x\n", Value(i))
+        Table[0] ^= ^uint64(0)
+        fmt.Printf("%016x\n", Value(i))
+    }
+}
+`
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, fixedLocalGlobalAssembly, original))), "\n")
+	if len(want) != 34 {
+		t.Fatalf("original mutable Go variable produced %d rows, want 34", len(want))
+	}
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	driver := runtimeCAsmLabelPreamble + fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+uint64_t table[4] __asm__(%s);
+extern uint64_t value(uint64_t) __asm__(%s);
+int main(void) {
+    for (uint64_t i = 0; i < 17; i++) {
+        for (unsigned j = 0; j < 4; j++) table[j] = (i + j) * UINT64_C(0x1020304050607081);
+        printf("%%016llx\n", (unsigned long long)value(i));
+        table[0] ^= UINT64_MAX;
+        printf("%%016llx\n", (unsigned long long)value(i));
+    }
+    return 0;
+}
+`, runtimeCAsmLabel(prefix+"example.invalid/framefixture.Table"), runtimeCAsmLabel(prefix+"example.invalid/framefixture.Value"))
+	pkg, request, _, options := fixedLocalTransportFixture(t, fixedLocalGlobalAssembly,
+		fixedLocalGlobalDeclarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalGlobalCheckExternal(t, ir)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "mutable-global", input, driver, level)
+					got := strings.Split(strings.TrimSpace(string(output)), "\n")
+					if len(got) != len(want) {
+						t.Fatalf("LLVM row count = %d, original = %d", len(got), len(want))
+					}
+					for index := range want {
+						if got[index] != want[index] {
+							t.Fatalf("mutable global row %d: original %s; LLVM %s", index, want[index], got[index])
+						}
+					}
+				})
+			}
+		})
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("original Go and LLVM amd64 execution via Rosetta, not native x86 hardware")
+	}
+}
diff --git a/amd64_fixed_local_global_test.go b/amd64_fixed_local_global_test.go
new file mode 100644
index 000000000..0ee1cf068
--- /dev/null
+++ b/amd64_fixed_local_global_test.go
@@ -0,0 +1,191 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// A complete original Go definition supplies the variable's typed identity,
+// not a constant value, an ASM DATA object or a private-frame byte extent.
+func TestGoAMD64FixedLocalGlobalAddressObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			for _, register := range []string{"SI", "BP", "R14"} {
+				t.Run(register, func(t *testing.T) {
+					assembly := strings.NewReplacer("SI", register, "DX", register).Replace(fixedLocalGlobalAssembly)
+					pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+						fixedLocalGlobalDeclarations, target.name, target.triple)
+					// Each API first compiles/captures this complete original Go
+					// source independently; only then does it bind and translate.
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+						func(t *testing.T, ir string, err error) {
+							if err != nil {
+								t.Fatal("ordinary mutable global address and private frame must compose", err)
+							}
+							fixedLocalGlobalCheckExternal(t, ir)
+							compileLLVMToObject(t, llc, target.triple, "global.ll", "global.o", ir)
+							compileLLVMToObject(t, llc, target.triple, "global-opt.ll", "global-opt.o", x86MulDivRoundOptimize(t, ir))
+						})
+				})
+			}
+		})
+	}
+}
+
+func fixedLocalGlobalCheckExternal(t *testing.T, ir string) {
+	t.Helper()
+	for _, line := range strings.Split(ir, "\n") {
+		if strings.HasPrefix(line, "@") && strings.Contains(line, "framefixture.Table") {
+			if !strings.Contains(line, "external global [32 x i8]") {
+				t.Fatal("ordinary mutable Go variable was not retained as external storage", line)
+			}
+			return
+		}
+	}
+	t.Fatal("ordinary mutable Go variable declaration missing")
+}
+
+func TestGoAMD64FixedLocalGlobalAddressGuards(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, row := range []struct{ name, old, replacement string }{
+		{"partial address", "MOVQ SI,8(SP)", "MOVL SI,8(SP)"},
+		{"pointer arithmetic", "ADDQ $16,DX", "ADDQ SI,DX"},
+		{"numeric address", "MOVQ $·Table(SB),SI", "MOVQ $1234,SI"},
+		{"numeric result", "MOVQ AX,ret+8(FP)", "MOVQ SI,ret+8(FP)"},
+		{"write role", "MOVOU (DX),X1", "MOVOU X0,(DX)"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := strings.Replace(fixedLocalGlobalAssembly, row.old, row.replacement, 1)
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+				fixedLocalGlobalDeclarations, "linux/amd64", "x86_64-unknown-linux-gnu")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if row.name == "pointer arithmetic" || row.name == "numeric address" {
+				if err != nil {
+					t.Fatal("defined numerical address lost its ordinary native read", err)
+				}
+				proved, err := proveX86FixedLocal(file.Funcs[0], bound.Sigs[pkg.Path+".Value"])
+				if err != nil {
+					t.Fatal(err)
+				}
+				fixedLocalRequireNumericNativeRole(t, proved, DX)
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("static address acquired unrelated numeric, write or private-frame permission", err)
+			}
+		})
+	}
+	for _, declaration := range []string{"var Table [4]*uint64", "var Table [4]float64", "var Table [8]uint64"} {
+		t.Run("supplied_type/"+declaration, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalTransportFixture(t, fixedLocalGlobalAssembly,
+				fixedLocalGlobalDeclarations, "linux/amd64", "x86_64-unknown-linux-gnu")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, "fixture.go", "package framefixture\n"+declaration+"\nfunc Value(a uint64) uint64\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config := types.Config{Sizes: types.SizesFor("gc", "amd64")}
+			typed, err := config.Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg.Types, pkg.Syntax = typed, []*ast.File{syntax}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("supplied variable type replaced the original complete Go source", err)
+			}
+		})
+	}
+	t.Run("global and FP slot zero remain typed alternatives", func(t *testing.T) {
+		assembly := strings.Replace(fixedLocalGlobalAssembly, "$32-16", "$32-24", 1)
+		assembly = strings.Replace(assembly, "a+0(FP)", "a+8(FP)", 1)
+		assembly = strings.Replace(assembly, "ret+8(FP)", "ret+16(FP)", 1)
+		assembly = strings.Replace(assembly, "MOVQ SI,8(SP)",
+			"MOVQ p+0(FP),DI\nCMPQ AX,$0\nJEQ joined\nMOVQ DI,SI\njoined:\nMOVQ SI,8(SP)", 1)
+		declarations := "var Table [4]uint64\nfunc Value(p *uint64, a uint64) uint64\n"
+		pkg, request, _, options := fixedLocalTransportFixture(t, assembly,
+			declarations, "linux/amd64", "x86_64-unknown-linux-gnu")
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc required")
+		}
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal("distinct global/input alternatives lost their native read", err)
+				}
+				fixedLocalGlobalCheckExternal(t, ir)
+				compileLLVMToObject(t, llc, options.TargetTriple, "joined-global.ll", "joined-global.o", ir)
+				compileLLVMToObject(t, llc, options.TargetTriple, "joined-global-opt.ll", "joined-global-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+
+		changed := strings.Replace(assembly, "joined:\nMOVQ SI,8(SP)", "joined:\nXORQ SI,AX\nMOVQ SI,8(SP)", 1)
+		if changed == assembly {
+			t.Fatal("machine-bit fixture lost its joined address operand")
+		}
+		assembly = changed
+		pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+			"var Table [4]uint64\nfunc Value(p *uint64, a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+		source := requireGoAMD64FrameCapture(t, pkg, request)
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		if _, err := source.BindFixedLocal(ctx, pkg, file, options); err != nil {
+			t.Fatal("original global/input machine-bit arithmetic rejected", err)
+		}
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, options.TargetTriple, "global-bits.ll", "global-bits.o", ir)
+			})
+	})
+	t.Run("bound symbol and lifetime", func(t *testing.T) {
+		pkg, request, file, options := fixedLocalTransportFixture(t, fixedLocalGlobalAssembly,
+			fixedLocalGlobalDeclarations, "linux/amd64", "x86_64-unknown-linux-gnu")
+		source := requireGoAMD64FrameCapture(t, pkg, request)
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		changed := bound
+		changed.ResolveSym = func(symbol string) string {
+			if symbol == "·Table" {
+				return "foreign.Table"
+			}
+			return bound.ResolveSym(symbol)
+		}
+		if ir, err := Translate(file, changed); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatal("different variable inherited the original declaration", err)
+		}
+		if err := source.Close(); err != nil {
+			t.Fatal(err)
+		}
+		if ir, err := Translate(file, bound); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatal("closed original source retained a static address role", err)
+		}
+	})
+}
diff --git a/amd64_fixed_local_gp.go b/amd64_fixed_local_gp.go
new file mode 100644
index 000000000..41216b076
--- /dev/null
+++ b/amd64_fixed_local_gp.go
@@ -0,0 +1,289 @@
+package plan9asm
+
+// Reuse the ordinary typed GP grammar. The descriptor only names byte and
+// FLAGS dependencies; this consumer must still establish every private read,
+// address origin and write. CMP/TEST retain their opposite immediate roles.
+func fixedLocalGPByteEffect(ins Instr) (x86TypedByteEffect, bool, error) {
+	if effect, known, err := x86NamedLEAByteEffect(ins.Op, ins, "amd64"); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedGPByteEffect(ins.Op, ins, "amd64"); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedImplicitMultiplyByteEffect(ins.Op, ins, "amd64"); known {
+		return effect, true, err
+	}
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, "amd64")
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{flagsDefined: x86ByteFlagsAll, flagsKilled: x86ByteFlagsAll}
+	if form.test {
+		effect.flagsDefined &^= x86ByteFlagAF
+	}
+	for index, operand := range form.args {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: index, operand: operand, width: int64(form.bits / 8), read: true,
+		})
+	}
+	return effect, true, nil
+}
+
+// Preserve a full numerical word only after the ordinary typed transfer has
+// succeeded. These are machine-word values with wraparound, not checked pointer
+// offsets or termination facts. The existing family owns grammar and immediates;
+// partial writes and numerical values depending on unknown carry stay unknown.
+func fixedLocalConstantArithmetic(ins Instr, effect x86TypedByteEffect, state *x86FixedLocalState) (Reg, int64, bool) {
+	spec, recognized := x86LockScalarRMWSpecs[ins.Op]
+	if !recognized || spec.bits != 64 || len(effect.operands) == 0 {
+		return "", 0, false
+	}
+	destination := effect.operands[len(effect.operands)-1]
+	root, valid := x86CallerGP(destination.operand.Reg)
+	old, known := state.constants[root]
+	if destination.operand.Kind != OpReg || destination.width != 8 || !destination.write ||
+		!valid || root != destination.operand.Reg || root == SP ||
+		!known && spec.stem != "XOR" {
+		return "", 0, false
+	}
+	// The shared typed family already resolved aliases and encoded immediates.
+	// Its input-free XOR descriptor is the existing self-XOR zero rule.
+	if spec.stem == "XOR" && !effect.operands[0].read && !destination.read {
+		return root, 0, true
+	}
+	if !known || !fixedLocalNumericRead(destination.operand, 8, state) {
+		return "", 0, false
+	}
+	value, input := uint64(old), uint64(0)
+	if !spec.unary {
+		operand := effect.operands[0].operand
+		source, constant := operand.Imm, operand.Kind == OpImm
+		if operand.Kind == OpReg {
+			source, constant = state.constants[operand.Reg]
+		}
+		if !constant || !fixedLocalNumericRead(operand, 8, state) {
+			return "", 0, false
+		}
+		input = uint64(source)
+	}
+	switch spec.stem {
+	case "ADD":
+		value += input
+	case "SUB":
+		value -= input
+	case "AND":
+		value &= input
+	case "OR":
+		value |= input
+	case "XOR":
+		value ^= input
+	case "INC":
+		value++
+	case "DEC":
+		value--
+	case "NEG":
+		value = -value
+	case "NOT":
+		value = ^value
+	default:
+		return "", 0, false
+	}
+	return root, int64(value), true
+}
+
+// A parsed address is not necessarily a memory access. Numerical LEA and
+// sized NOP use the same syntax without loading/storing it. Query the validated
+// effect rather than granting them a fabricated private-storage certificate.
+func fixedLocalGPAddressOnly(ins Instr, index int) bool {
+	if index < 0 || index >= len(ins.Args) || ins.Args[index].Kind != OpMem {
+		return false
+	}
+	effect, known, err := fixedLocalGPByteEffect(ins)
+	if !known || err != nil || effect.dynamicMemory {
+		return false
+	}
+	for _, operand := range effect.operands {
+		if operand.index == index && (operand.operand.Kind == OpMem || operand.operand.Kind == OpSym) &&
+			(operand.read || operand.write) {
+			return false
+		}
+	}
+	return true
+}
+
+func fixedLocalTypedByteStep(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int,
+	effect x86TypedByteEffect) error {
+	fail := func() error {
+		return goAMD64FrameContext("fixed local typed effect lacks numerical bytes, FLAGS or private storage: %s", ins.Op)
+	}
+	if effect.dynamicMemory || state.flags&effect.flagsRead != effect.flagsRead {
+		return fail()
+	}
+	alignment := int64(1)
+	if effect.vector.upperWrite != x86TypedVectorUpperUnknown {
+		if effect.vector.upperWrite != x86TypedVectorUpperPreserve && effect.vector.upperWrite != x86TypedVectorUpperZero ||
+			effect.vector.memoryAlignment <= 0 {
+			return fail()
+		}
+		alignment = effect.vector.memoryAlignment
+	}
+	// Read all inputs before any write, including aliased outputs. RMW receives
+	// one write-capable access certificate only after its old bytes are proved.
+	for _, operand := range effect.operands {
+		if operand.requiredBytes != 0 && (!operand.read || operand.operand.Kind != OpReg ||
+			amd64VectorByteWidth(operand.operand.Reg) == 0 ||
+			operand.requiredBytes&^x86CallerVectorByteMask(operand.width) != 0) {
+			return fail()
+		}
+		if !operand.read {
+			continue
+		}
+		if operand.operand.Kind != OpMem && operand.operand.Kind != OpSym {
+			if operand.operand.Kind == OpReg && amd64VectorByteWidth(operand.operand.Reg) != 0 {
+				mask := x86CallerVectorByteMask(operand.width)
+				if operand.requiredBytes != 0 {
+					mask = operand.requiredBytes
+				}
+				if effect.vector.upperWrite == x86TypedVectorUpperUnknown || mask == 0 ||
+					state.vectors[x86CallerVectorRoot(operand.operand.Reg)]&mask != mask {
+					return fail()
+				}
+				continue
+			}
+			if !fixedLocalMachineRead(ins, operand, state, sig, proof, residue) {
+				return fail()
+			}
+			continue
+		}
+		if err := fixedLocalMachineMemory(ins, operand, state, proof, residue, alignment); err != nil {
+			return err
+		}
+	}
+	for _, operand := range effect.operands {
+		if !operand.write {
+			continue
+		}
+		switch operand.operand.Kind {
+		case OpMem:
+			offset, role, err := fixedLocalMemoryAccess(ins, operand.index, state, proof, residue, operand.width, alignment, true, false)
+			if err != nil {
+				return err
+			}
+			if role == x86FixedLocalPrivateMemory {
+				// An integer RMW drops an overlapping native-address role,
+				// but its untouched actual machine bytes remain initialized.
+				for start := offset - 7; start < offset+operand.width; start++ {
+					origin, found := state.opaqueCells[start]
+					if found && fixedLocalOriginOwners(origin, proof) {
+						if start < 0 || start > proof.frame-8 {
+							return fail()
+						}
+						state.bytes.setRange(start, 8, true)
+					}
+				}
+				fixedLocalNumericalStore(state, offset, operand.width, true)
+			}
+		case OpReg:
+			if amd64VectorByteWidth(operand.operand.Reg) != 0 {
+				mask := x86CallerVectorByteMask(operand.width)
+				if effect.vector.upperWrite == x86TypedVectorUpperUnknown || mask == 0 {
+					return fail()
+				}
+				root := x86CallerVectorRoot(operand.operand.Reg)
+				if effect.vector.upperWrite == x86TypedVectorUpperZero {
+					state.vectors[root] = ^uint64(0)
+				} else {
+					state.vectors[root] |= mask
+				}
+				continue
+			}
+			root, valid := x86CallerGP(operand.operand.Reg)
+			mask := x86CallerByteMask(operand.operand.Reg, operand.width)
+			_, private := state.pointers[root]
+			origin, opaque := state.opaque[root]
+			if !valid || root == SP || mask == 0 ||
+				private && operand.width != 8 {
+				return fail()
+			}
+			if opaque && fixedLocalOriginOwners(origin, proof) {
+				state.known[root] = 255 // Narrow writes preserve defined native upper bits.
+			}
+			if operand.width == 4 {
+				mask = 255 // Architectural dword writes define the upper half.
+			}
+			delete(state.pointers, root)
+			delete(state.opaque, root)
+			delete(state.constants, root)
+			fixedLocalWriteBooleans(state, operand.operand.Reg, operand.width, 0)
+			state.known[root] |= mask
+		default:
+			return fail() // FP transport and external stores have separate owners.
+		}
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	if effect.flagsKilled|effect.flagsDefined != 0 {
+		state.comparison = x86FixedLocalComparison{}
+	}
+	return nil
+}
+
+// Integer effects consume machine bits. Native addresses have all eight bytes;
+// relocated private-frame identities do not. This does not change the stricter
+// address-index, scalar transport or result-ABI predicates.
+func fixedLocalMachineRead(ins *Instr, operand x86TypedByteOperand, state *x86FixedLocalState,
+	sig FuncSig, proof *x86FixedLocalProof, residue int) bool {
+	if amd64IsKOperand(operand.operand) {
+		return operand.width == 8 && state.masks[operand.operand.Reg]
+	}
+	if operand.operand.Kind == OpFP {
+		value, err := fixedLocalReadValue(ins, operand.index, state, sig, proof, residue, operand.width, false)
+		return err == nil && !value.pointer && (!value.opaque || fixedLocalOriginOwners(value.identity, proof))
+	}
+	if fixedLocalNumericRead(operand.operand, operand.width, state) {
+		return true
+	}
+	root, valid := x86CallerGP(operand.operand.Reg)
+	origin, native := state.opaque[root]
+	_, private := state.pointers[root]
+	return operand.operand.Kind == OpReg && valid && root != SP && !private && native &&
+		x86CallerByteMask(operand.operand.Reg, operand.width) != 0 && fixedLocalOriginOwners(origin, proof)
+}
+
+func fixedLocalMachineMemory(ins *Instr, operand x86TypedByteOperand, state *x86FixedLocalState,
+	proof *x86FixedLocalProof, residue int, alignment int64) error {
+	if operand.operand.Kind == OpSym {
+		_, _, err := fixedLocalReadMemory(ins, operand.index, state, proof, residue, operand.width, alignment)
+		return err
+	}
+	address, err := fixedLocalMemoryAddress(*ins, operand.index, proof.frame)
+	if err != nil {
+		return err
+	}
+	offset, private := fixedLocalPrivateOffset(address, state)
+	if !private {
+		_, _, err := fixedLocalMemoryAccess(ins, operand.index, state, proof, residue, operand.width, alignment, operand.write, false)
+		return err
+	}
+	if _, err := fixedLocalMemory(ins, operand.index, state, proof, residue, operand.width, alignment, operand.write, true); err != nil {
+		return err
+	}
+	for index := offset; index < offset+operand.width; index++ {
+		if state.bytes.has(index) {
+			continue
+		}
+		defined := false
+		// Full pointer spills need not be aligned. Exactly eight possible
+		// starting offsets can contain a byte, independent of frame size.
+		for start := index - 7; start <= index; start++ {
+			origin, found := state.opaqueCells[start]
+			if found && start >= 0 && start <= proof.frame-8 && fixedLocalOriginOwners(origin, proof) {
+				defined = true
+				break
+			}
+		}
+		if !defined {
+			return goAMD64FrameContext("fixed local machine read contains undefined or relocated private bytes")
+		}
+	}
+	return nil
+}
diff --git a/amd64_fixed_local_gp_bank_test.go b/amd64_fixed_local_gp_bank_test.go
new file mode 100644
index 000000000..a09c1a275
--- /dev/null
+++ b/amd64_fixed_local_gp_bank_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// ABI0 does not give R14 an initialized g value. Nonzero original Go frames
+// independently save/restore BP outside the body. Both registers can therefore
+// hold explicitly defined virtual values, without exposing their entry state.
+func TestGoAMD64FixedLocalDefinedGPBank(t *testing.T) {
+	var original strings.Builder
+	ordinal := 0
+	for _, register := range []string{"AX", "BX", "CX", "DX", "SI", "DI", "BP", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			body := fmt.Sprintf("MOVQ AX,%s\nADD%s $1,%s\nMOVQ %s,AX", register, width, register, register)
+			fn, sig, source := fixedLocalGPFixture(t, body)
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+			ordinal++
+			t.Run(register+"/"+width, func(t *testing.T) {
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					t.Fatal("explicitly defined ABI0 register rejected", err)
+				}
+			})
+		}
+	}
+	if ordinal != 60 {
+		t.Fatal("incomplete independent GP bank/width matrix", ordinal)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, register := range []string{"BP", "R14"} {
+		for index, body := range []string{
+			"MOVQ " + register + ",AX",
+			"MOVB $0," + register + "\nMOVQ " + register + ",AX",
+			"MOVQ (" + register + "),AX",
+			"MOVQ SP," + register + "\nMOVQ " + register + ",AX",
+			"MOVQ $1," + register + "\nMOVQ (" + register + "),AX",
+		} {
+			t.Run(fmt.Sprintf("unbound/%s/%d", register, index), func(t *testing.T) {
+				fn, sig, _ := fixedLocalGPFixture(t, body)
+				proved, err := proveX86FixedLocal(fn, sig)
+				if index == 4 {
+					if err != nil {
+						t.Fatal("defined numerical bits lost their faulting native access", err)
+					}
+					fixedLocalRequireNumericNativeRole(t, proved, Reg(register))
+					return
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("entry register or numerical bits gained pointer authority", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalDefinedGPBankRoles(t *testing.T) {
+	var original strings.Builder
+	ordinal := 0
+	for _, register := range []string{"BP", "R14"} {
+		for index, operation := range []string{
+			"MOVQ AX,%s\nCMPQ AX,AX\nSETEQ %s\nMOVQ %s,AX",
+			"MOVQ AX,%s\nCMPQ AX,AX\nCMOVQEQ AX,%s\nMOVQ %s,AX",
+			"KMOVQ AX,K1\nKMOVQ K1,%s\nADDQ $1,%s\nMOVQ %s,AX",
+		} {
+			body := fmt.Sprintf(operation, register, register, register)
+			fn, sig, source := fixedLocalGPFixture(t, body)
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+			ordinal++
+			t.Run(fmt.Sprintf("%s/numeric/%d", register, index), func(t *testing.T) {
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					t.Fatal("defined register rejected by an independent effect consumer", err)
+				}
+			})
+		}
+		for index, operation := range []string{
+			"MOVQ SI,%s\nADDQ AX,%s\nMOVQ (%s),AX",
+			"LEAQ 8(SI),%s\nADDQ AX,%s\nMOVQ (%s),AX",
+		} {
+			body := fmt.Sprintf(operation, register, register, register)
+			fn, sig, source := fixedLocalInputFixture(t, body)
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+			ordinal++
+			t.Run(fmt.Sprintf("%s/input/%d", register, index), func(t *testing.T) {
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					t.Fatal("explicit typed input origin rejected", err)
+				}
+			})
+		}
+		pkg, _, file, options := fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+		source := strings.Replace(fixedLocalVoidAssembly(file), "MOVQ AX,16(SP)", "MOVQ AX,"+register+"\nMOVQ AX,16(SP)", 1)
+		parsed, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Run(register+"/void", func(t *testing.T) {
+			if _, err := proveX86FixedLocal(parsed.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+				t.Fatal("void source rejected a defined register", err)
+			}
+		})
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+		ordinal++
+	}
+	if ordinal != 12 {
+		t.Fatal("incomplete independent role matrix", ordinal)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_gp_runtime_test.go b/amd64_fixed_local_gp_runtime_test.go
new file mode 100644
index 000000000..be355c2be
--- /dev/null
+++ b/amd64_fixed_local_gp_runtime_test.go
@@ -0,0 +1,231 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These numerical kernels exercise the same original amd64 program on both
+// sides. In particular, a host-target rewrite cannot stand in for x86 FLAGS,
+// partial memory writes or the original Go-generated frame.
+func fixedLocalGPRuntimeProgram(triple string) (string, string, string, string) {
+	var bodies []string
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, stem := range []string{"ADD", "SUB", "AND", "OR", "XOR", "ADC", "SBB"} {
+			bodies = append(bodies, "STC\n"+stem+width+" $1,0(SP)\n")
+		}
+	}
+	for _, stem := range []string{"ADD", "SUB", "AND", "OR", "XOR", "ADC", "SBB"} {
+		bodies = append(bodies, "STC\n"+stem+"Q a+0(FP),AX\nMOVQ AX,0(SP)\n")
+	}
+	for _, operation := range []string{
+		"CMPQ a+0(FP),AX", "CMPQ AX,a+0(FP)", "CMPQ a+0(FP),$1",
+		"TESTQ a+0(FP),AX", "TESTQ AX,a+0(FP)", "TESTQ $1,a+0(FP)",
+	} {
+		bodies = append(bodies, operation+"\n")
+	}
+	for _, condition := range []string{
+		"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS",
+		"LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS",
+	} {
+		bodies = append(bodies, "MOVQ $42,CX\nCMPQ a+0(FP),$1\nCMOVQ"+condition+
+			" a+0(FP),CX\nMOVQ CX,0(SP)\n")
+	}
+	for _, body := range []string{
+		"MOVQ $3,CX\nagain:\nADDQ CX,AX\nSUBQ $1,CX\nJNE again\n",
+		"MOVQ $3,16(SP)\nagain:\nADDQ $1,AX\nSUBQ $1,16(SP)\nJNE again\n",
+		"CMPQ AX,AX\nMOVQ AX,CX\nLEAQ 7(AX)(CX*2),AX\nNOPL 24(SP)\n",
+		"CMPQ AX,$1\nJEQ left\nMOVQ $2,CX\nJMP join\nleft:\nMOVQ $3,CX\njoin:\nADDQ CX,AX\n",
+	} {
+		bodies = append(bodies, body+"MOVQ AX,0(SP)\n")
+	}
+	for _, register := range []string{"AX", "BX", "CX", "DX", "SI", "DI", "BP", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			bodies = append(bodies, fmt.Sprintf("MOVQ AX,%s\nADD%s $1,%s\nMOVQ %s,AX\nMOVQ AX,0(SP)\n", register, width, register, register))
+		}
+	}
+
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, body := range bodies {
+		name := fmt.Sprintf("Value%d", index)
+		fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$64-24
+MOVQ a+0(FP),AX
+MOVQ AX,0(SP)
+MOVQ AX,8(SP)
+%s`, name, body)
+		// MOV and SETcc preserve FLAGS. Capture every defined arithmetic flag
+		// before the shifts/ORs used to pack them; AF is undefined for logic.
+		assembly.WriteString(`MOVQ $0,CX
+MOVQ $0,DX
+MOVQ $0,BX
+MOVQ $0,R8
+MOVQ $0,R9
+SETCS CL
+SETPS DL
+SETEQ BL
+SETMI R8
+SETOS R9
+SHLQ $1,DX
+SHLQ $2,BX
+SHLQ $3,R8
+SHLQ $4,R9
+ORQ DX,CX
+ORQ BX,CX
+ORQ R8,CX
+ORQ R9,CX
+MOVQ mode+8(FP),DX
+CMPQ DX,$1
+JEQ flags
+CMPQ DX,$2
+JEQ canary
+MOVQ 0(SP),AX
+JMP done
+flags:
+MOVQ CX,AX
+JMP done
+canary:
+MOVQ 8(SP),AX
+done:
+MOVQ AX,ret+16(FP)
+RET
+`)
+		fmt.Fprintf(&declarations, "func %s(a, mode uint64) uint64\n", name)
+		fmt.Fprintf(&goRows, "%s,\n", name)
+		fmt.Fprintf(&cRows, "value%d,\n", index)
+		label := runtimeCAsmLabel(prefix + "example.invalid/framefixture." + name)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t, uint64_t) __asm__(%s);\n", index, label)
+	}
+	original := `package main
+import "fmt"
+` + declarations.String() + `
+func main() {
+    rows := []func(uint64, uint64) uint64{
+` + goRows.String() + `
+    }
+    values := []uint64{
+        0, 1, 0x7f, 0x80, 0xff, 0x7fff, 0x8000, 0xffff,
+        0x7fffffff, 0x80000000, 0xffffffff,
+        0x7fffffffffffffff, 0x8000000000000000, ^uint64(0), 0x8080808080808080,
+    }
+    for n, call := range rows {
+        for v, value := range values {
+            for mode := uint64(0); mode < 3; mode++ {
+                got := call(value, mode)
+                if mode == 2 && got != value {
+                    panic("original private-frame canary changed")
+                }
+                fmt.Printf("%d %d %d %016x\n", n, v, mode, got)
+            }
+        }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+int main(void) {
+    uint64_t (*const rows[])(uint64_t, uint64_t) = {
+` + cRows.String() + `
+    };
+    const uint64_t values[] = {
+        0, 1, 0x7f, 0x80, 0xff, 0x7fff, 0x8000, 0xffff,
+        0x7fffffff, UINT64_C(0x80000000), UINT64_C(0xffffffff),
+        UINT64_C(0x7fffffffffffffff), UINT64_C(0x8000000000000000),
+        UINT64_MAX, UINT64_C(0x8080808080808080),
+    };
+    for (unsigned n = 0; n < sizeof(rows)/sizeof(rows[0]); n++) {
+        for (unsigned v = 0; v < sizeof(values)/sizeof(values[0]); v++) {
+            for (unsigned mode = 0; mode < 3; mode++) {
+                uint64_t got = rows[n](values[v], mode);
+                if (mode == 2 && got != values[v]) {
+                    return 2;
+                }
+                printf("%u %u %u %016llx\n", n, v, mode, (unsigned long long)got);
+            }
+        }
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func TestGoAMD64FixedLocalTypedGPRuntimeObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const triple = "x86_64-unknown-linux-gnu"
+	assembly, declarations, _, _ := fixedLocalGPRuntimeProgram(triple)
+	pkg, request, _, options := fixedLocalTransportFixture(t,
+		assembly, declarations, "linux/amd64", triple)
+	var names []string
+	for index := 0; index < 121; index++ {
+		names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+	}
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				x86CompactExpandRequireAllDefinitions(t, input, names)
+				x86PackedStringCompileObject(t, llc, triple, input, level)
+			}
+		})
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTypedGP(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	// Each API owns a fresh source observation, not a reused proof. Compile
+	// original Go and prepare objdump before opening any observation lease.
+	t.Setenv("GOCACHE", t.TempDir())
+	assembly, declarations, original, driver := fixedLocalGPRuntimeProgram(execution.triple)
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))), "\n")
+	if len(want) != 121*15*3 {
+		t.Fatalf("original Go produced %d rows, want 121 kernels x 15 values x 3 observations", len(want))
+	}
+	pkg, request, _, options := fixedLocalTransportFixture(t,
+		assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "private-gp", input, driver, level)
+					got := strings.Split(strings.TrimSpace(string(output)), "\n")
+					if len(got) != len(want) {
+						t.Fatalf("LLVM row count = %d, original = %d", len(got), len(want))
+					}
+					for index := range want {
+						if got[index] != want[index] {
+							t.Fatalf("private GP value/FLAGS/canary row %d: original %s; LLVM %s", index, want[index], got[index])
+						}
+					}
+				})
+			}
+		})
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("original Go and LLVM amd64 execution via Rosetta, not native x86 hardware")
+	}
+}
diff --git a/amd64_fixed_local_gp_simd.go b/amd64_fixed_local_gp_simd.go
new file mode 100644
index 000000000..cd6acecca
--- /dev/null
+++ b/amd64_fixed_local_gp_simd.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+// The complete GP/X grammar owns widths and aliases. This consumer supplies
+// only the existing numerical register, private/native memory and FP roles;
+// it does not turn relocated or opaque addresses into numerical vector bytes.
+func fixedLocalGPSIMDTransferStep(ins *Instr, state *x86FixedLocalState, sig FuncSig,
+	proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, recognized, err := x86GPSIMDTransferProperties(*ins, "amd64")
+	if !recognized || err != nil {
+		return recognized, err
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local GP/X transfer lacks numerical bytes or a bound storage role")
+	}
+	if form.mmx || form.spec.rawOnly {
+		return fail()
+	}
+	width := int64(form.bits / 8)
+	low := x86CallerVectorByteMask(width)
+	var known uint64
+	if form.sourceX {
+		known = state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)] & low
+	} else if form.memory < 0 {
+		root, valid := x86CallerGP(ins.Args[0].Reg)
+		_, private := state.pointers[root]
+		_, opaque := state.opaque[root]
+		if ins.Args[0].Kind != OpReg || !valid || root == SP || private || opaque {
+			return fail()
+		}
+		known = uint64(state.known[root]) & low
+	} else {
+		value, err := fixedLocalReadValue(ins, 0, state, sig, proof, residue, width, false)
+		if err != nil {
+			return true, err
+		}
+		if value.pointer || value.opaque {
+			return fail()
+		}
+		known = low // Memory and FP inputs require their complete numerical role.
+	}
+	if form.destinationX {
+		root := x86CallerVectorRoot(ins.Args[1].Reg)
+		state.vectors[root] = form.definedVectorBytes(known, state.vectors[root])
+		return true, nil
+	}
+	if ins.Args[1].Kind != OpReg && known != low {
+		return fail() // An unknown stored byte cannot initialize memory or FP.
+	}
+	if err := fixedLocalWriteValue(ins, 1, 0, fixedLocalScalarValue{}, state, sig, proof, residue, width); err != nil {
+		return true, err
+	}
+	if ins.Args[1].Kind == OpReg {
+		root, _ := x86CallerGP(ins.Args[1].Reg)
+		// Replace old facts even for unknown inputs; dword GP writes define
+		// the upper dword as zero. The shared writer revoked address/value facts.
+		state.known[root] = uint8(known) | ^uint8(low)
+	}
+	return true, nil
+}
diff --git a/amd64_fixed_local_gp_simd_native_linux_amd64_test.go b/amd64_fixed_local_gp_simd_native_linux_amd64_test.go
new file mode 100644
index 000000000..d67b606ef
--- /dev/null
+++ b/amd64_fixed_local_gp_simd_native_linux_amd64_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalGPSIMD(t *testing.T) {
+	var kernels []fixedLocalVEXRuntimeKernel
+	for _, family := range fixedLocalGPSIMDNames {
+		operations := []string{
+			family.name + " AX,X1",
+			family.name + " X0,BX\nMOVQ BX,72(BP)",
+			family.name + " 65(BP),X1",
+			family.name + " X0,65(BP)",
+			family.name + " 1(SI),X1",
+			family.name + " X0,1(SI)",
+		}
+		if family.bits == 64 {
+			operations = append(operations, family.name+" X0,X1", family.name+" X1,X1")
+		}
+		for index, operation := range operations {
+			// Observe the whole Y destination, all private canaries, native
+			// input stores and dword GP zero-extension. SETCS observes the
+			// original carry without an instruction which changes FLAGS.
+			operations[index] = "MOVQ (SI),AX\nMOVQ $-1,BX\nSTC\n" + operation +
+				"\nSETCS R8\nMOVBQZX R8,R8\nMOVQ R8,88(BP)"
+		}
+		kernels = append(kernels, fixedLocalVEXRuntimeKernel{family.name, operations})
+	}
+	if len(kernels) != 6 {
+		t.Fatal("complete low-bank native transfer inventory changed", len(kernels))
+	}
+	// AVX2 is required for the independent driver to observe preserved upper
+	// Y aliases. X31/EVEX objects have a separate hardware acceptance boundary.
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, kernels)
+	if !t.Failed() {
+		t.Log("GP_SIMD_NATIVE_COMPLETE families=6 inputs_per_family=16 APIs=3 LLVM_levels=O0,O2 original_observations=96 LLVM_comparisons=576")
+	}
+}
diff --git a/amd64_fixed_local_gp_simd_test.go b/amd64_fixed_local_gp_simd_test.go
new file mode 100644
index 000000000..81276f7be
--- /dev/null
+++ b/amd64_fixed_local_gp_simd_test.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Go spellings: MOVD and MOVDQ2Q are MOVQ aliases. The MMX row
+// and decoder-only VMOVW retain their separate physical-state contracts.
+var fixedLocalGPSIMDNames = []struct {
+	name   string
+	bits   int
+	legacy bool
+}{
+	{"MOVL", 32, true}, {"MOVQ", 64, true},
+	{"MOVD", 64, true}, {"MOVDQ2Q", 64, true},
+	{"VMOVD", 32, false}, {"VMOVQ", 64, false},
+}
+
+type fixedLocalGPSIMDCase struct {
+	name, body string
+	result     string
+}
+
+func fixedLocalGPSIMDCases() []fixedLocalGPSIMDCase {
+	var rows []fixedLocalGPSIMDCase
+	for _, family := range fixedLocalGPSIMDNames {
+		banks := []string{"X1"}
+		if !family.legacy {
+			banks = append(banks, "X31")
+		}
+		for _, bank := range banks {
+			seed, extract := "MOVOU 16(SP),"+bank, "MOVQ "+bank+",AX"
+			if bank == "X31" {
+				seed, extract = "VMOVQ AX,"+bank, "VMOVQ "+bank+",AX"
+			}
+			add := func(label, body, result string) {
+				rows = append(rows, fixedLocalGPSIMDCase{family.name + "/" + bank + "/" + label, body, result})
+			}
+			add("GP to X", family.name+" AX,"+bank+"\n"+extract, "uint64")
+			add("X to GP", seed+"\n"+family.name+" "+bank+",AX", "uint64")
+			for _, address := range []string{"16(SP)", "17(SP)", "1(SI)"} {
+				add("load "+address, family.name+" "+address+","+bank+"\n"+extract, "uint64")
+				add("store "+address, seed+"\n"+family.name+" "+bank+","+address, "uint64")
+			}
+			input := "a+8(FP)"
+			if family.bits == 32 {
+				input = "b+16(FP)"
+			}
+			add("FP input", family.name+" "+input+","+bank+"\n"+extract, "uint64")
+			add("FP result", seed+"\n"+family.name+" "+bank+",ret+24(FP)", fmt.Sprintf("uint%d", family.bits))
+			if family.bits == 64 {
+				add("X copy", family.name+" X0,"+bank+"\n"+extract, "uint64")
+				add("X self", seed+"\n"+family.name+" "+bank+","+bank+"\n"+extract, "uint64")
+			}
+		}
+	}
+	return rows
+}
+
+func fixedLocalGPSIMDFixture(t *testing.T, row fixedLocalGPSIMDCase) (Func, FuncSig, string) {
+	t.Helper()
+	body := "MOVQ p+0(FP),SI\nMOVQ a+8(FP),AX\nMOVL b+16(FP),BX\n" +
+		"MOVQ AX,16(SP)\nMOVQ AX,24(SP)\nMOVOU 16(SP),X0\n" + row.body + "\n"
+	if !strings.HasSuffix(row.name, "/FP result") {
+		body += "MOVQ AX,ret+24(FP)\n"
+	}
+	_, _, sig, source := x86ResultInitializationFixture(t, "amd64",
+		"func Value(p *uint64, a uint64, b uint32) "+row.result, body+"RET")
+	source = strings.Replace(source, "$0-", "$80-", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestGoAMD64FixedLocalGPSIMDCompleteSources(t *testing.T) {
+	rows := fixedLocalGPSIMDCases()
+	if len(rows) != 90 {
+		t.Fatal("complete GP/X source inventory changed", len(rows))
+	}
+	var original strings.Builder
+	for index, row := range rows {
+		_, _, source := fixedLocalGPSIMDFixture(t, row)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	// An original assembler/fixture failure is not a translator rejection.
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, row := range rows {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalGPSIMDFixture(t, row)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("original complete GP/X transfer lacks fixed-local support", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalGPSIMDCompleteObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	rows := fixedLocalGPSIMDCases()
+	for index, row := range rows {
+		_, _, source := fixedLocalGPSIMDFixture(t, row)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64, a uint64, b uint32) %s\n", name, row.result)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(rows))
+}
+
+func TestGoAMD64FixedLocalGPSIMDDefinedBytes(t *testing.T) {
+	for _, family := range fixedLocalGPSIMDNames {
+		for _, direction := range []string{"GP to X", "X to GP", "X self"} {
+			if direction == "X self" && family.bits == 32 {
+				continue
+			}
+			t.Run(family.name+"/"+direction, func(t *testing.T) {
+				width := family.bits / 8
+				low := uint64(1)<<uint(width) - 1
+				for _, input := range []uint64{0, 1, 0x55 & low, low &^ 1, low} {
+					const upper = uint64(0x5500000012340000)
+					state := cloneFixedLocalState(x86FixedLocalState{
+						known:   map[Reg]uint8{AX: uint8(input)},
+						vectors: map[Reg]uint64{"Z1": upper | input}, flags: x86ByteFlagsAll,
+						constants: map[Reg]int64{AX: 42}, booleans: map[Reg]uint8{AX: 255},
+					})
+					operands := "AX,X1"
+					if direction == "X to GP" {
+						operands = "X1,AX"
+					} else if direction == "X self" {
+						operands = "X1,X1"
+					}
+					ins := x86ScalarLaneInstruction(t, family.name+" "+operands)
+					if err := fixedLocalStep(&ins, &state, FuncSig{}, nil, 0); err != nil {
+						t.Fatal("byte-preserving numeric register transfer rejected", input, err)
+					}
+					if state.flags != x86ByteFlagsAll {
+						t.Fatal("numeric transfer changed FLAGS")
+					}
+					if direction == "X to GP" {
+						_, constant := state.constants[AX]
+						if state.known[AX] != uint8(input)|^uint8(low) || constant || state.booleans[AX] != ^uint8(low) {
+							t.Fatal("unknown input retained old GP facts or lost zero-extension", input, state)
+						}
+						if state.vectors["Z1"] != upper|input {
+							t.Fatal("GP destination changed source X aliases")
+						}
+						continue
+					}
+					want := ^low | input
+					if family.legacy {
+						want = upper | (0xffff &^ low) | input
+					}
+					if state.vectors["Z1"] != want || state.known[AX] != uint8(input) {
+						t.Fatal("transfer lost unknown bytes, zeroed X bytes or upper aliases", input, state.vectors["Z1"], want)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalGPSIMDConsumerBoundaries(t *testing.T) {
+	for _, family := range fixedLocalGPSIMDNames {
+		for _, row := range []struct{ name, body string }{
+			{"private address", family.name + " SP,X1"},
+			{"native address", family.name + " SI,X1"},
+			{"undefined stored bytes", family.name + " X15,16(SP)"},
+			{"undefined result bytes", family.name + " X15,AX\nMOVQ AX,16(SP)"},
+			{"missing private byte", "MOVB AX,32(SP)\n" + family.name + " 32(SP),X1"},
+			{"private pointer spill", "MOVQ SP,16(SP)\n" + family.name + " 16(SP),X1"},
+			{"native pointer spill", "MOVQ SI,16(SP)\n" + family.name + " 16(SP),X1"},
+			{"past private frame", family.name + " 80(SP),X1"},
+			{"untyped FP input", family.name + " p+0(FP),X1"},
+			{"FP padding", family.name + " b+20(FP),X1"},
+			{"input FP store", family.name + " X0,a+8(FP)"},
+			{"numeric bits are not address", family.name + " X0,CX\nMOVQ (CX),AX"},
+			{"readonly unowned symbol", family.name + " X0,literal<>(SB)"},
+			{"MMX needs physical owner", "MOVQ X0,M0\nEMMS"},
+		} {
+			t.Run(family.name+"/"+row.name, func(t *testing.T) {
+				fn, sig, source := fixedLocalGPSIMDFixture(t, fixedLocalGPSIMDCase{body: row.body, result: "uint64"})
+				requireX86GoAssemblerResult(t, "amd64", source, true)
+				if row.name == "numeric bits are not address" {
+					fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64,b uint32) uint64",
+						"MOVQ (CX),AX", 0, 8, false, "load volatile i64")
+					return
+				}
+				if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("numeric transfer acquired missing bytes or another binding role", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_gp_test.go b/amd64_fixed_local_gp_test.go
new file mode 100644
index 000000000..b3c1bb393
--- /dev/null
+++ b/amd64_fixed_local_gp_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalGPFixture(t *testing.T, body string) (Func, FuncSig, string) {
+	t.Helper()
+	_, _, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(a uint64) uint64",
+		"MOVQ a+0(FP),AX\nMOVQ AX,0(SP)\n"+body+"\nMOVQ AX,ret+8(FP)\nRET")
+	source = strings.Replace(source, "$0-16", "$64-16", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestGoAMD64FixedLocalTypedGPWidths(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	// Independent family/width axes. Every memory RMW must read initialized
+	// numerical bytes before writing; the syntax oracle is Go's assembler.
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, stem := range []string{"ADD", "SUB", "AND", "OR", "XOR", "ADC", "SBB"} {
+			for _, destination := range []string{"AX", "0(SP)"} {
+				body := "CMPQ AX,AX\n" + stem + width + " $1," + destination
+				fn, sig, source := fixedLocalGPFixture(t, body)
+				original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+				count++
+				t.Run(stem+width+"/"+destination, func(t *testing.T) {
+					if _, err := proveX86FixedLocal(fn, sig); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+		for _, stem := range []string{"NEG", "NOT", "INC", "DEC"} {
+			for _, destination := range []string{"AX", "0(SP)"} {
+				body := stem + width + " " + destination
+				fn, sig, source := fixedLocalGPFixture(t, body)
+				original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+				count++
+				t.Run(stem+width+"/"+destination, func(t *testing.T) {
+					if _, err := proveX86FixedLocal(fn, sig); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+	if count != 88 {
+		t.Fatalf("family/width fixture count changed: %d", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalTypedGPFlagsAndProvenance(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"carry only", "STC\nADCQ $1,AX", true},
+		{"NOP preserves carry", "STC\nNOP\nADCQ $1,AX", true},
+		{"NOP does not define carry", "NOP\nADCQ $1,AX", false},
+		{"NOP does not define registers", "NOP\nADDQ CX,AX", false},
+		{"carry branch", "STC\nJCS done\ndone:", true},
+		{"carry is not zero", "STC\nJEQ done\ndone:", false},
+		{"carry is not set zero", "STC\nSETEQ CL", false},
+		{"carry is not conditional zero", "STC\nMOVQ AX,CX\nCMOVQEQ CX,AX", false},
+		{"undefined carry", "ADCQ $1,AX", false},
+		{"compare defines AH flags", "CMPQ AX,AX\nLAHF", true},
+		{"test does not define AF", "TESTQ AX,AX\nLAHF", false},
+		{"ADX does not define zero", "STC\nADCXQ AX,AX\nJEQ done\ndone:", false},
+		{"multiply defines carry", "IMULQ $3,AX\nJCS done\ndone:", true},
+		{"multiply kills old zero", "CMPQ AX,AX\nIMULQ $3,AX\nJEQ done\ndone:", false},
+		{"test memory", "TESTQ $1,0(SP)\nJEQ done\ndone:", true},
+		{"compare memory", "CMPQ 0(SP),$1\nJEQ done\ndone:", true},
+		{"self xor initializes", "XORQ CX,CX\nADDQ CX,AX", true},
+		{"dword zero extension", "XORL CX,CX\nADDQ CX,AX", true},
+		{"word not zero extension", "XORW CX,CX\nADDQ CX,AX", false},
+		{"uninitialized register", "ADDQ CX,AX", false},
+		{"uninitialized memory", "SUBQ $1,8(SP)", false},
+		{"uninitialized self memory", "XORQ AX,8(SP)", false},
+		{"crossing frame", "ADDQ $1,60(SP)", false},
+		{"numeric not a pointer", "ADDQ $1,(AX)", true},
+		{"dynamic memory bit index", "BTQ AX,0(SP)", false},
+		{"spilled pointer is not numeric", "MOVQ SP,CX\nMOVQ CX,8(SP)\nADDQ $1,8(SP)", false},
+		{"private not numerical", "MOVQ SP,CX\nXORQ CX,AX", false},
+		{"partial private overwrite", "MOVQ SP,CX\nXORW CX,CX", false},
+		{"stack overwrite", "XORQ SP,SP", false},
+		{"unknown suffix", "ADDQ.Z $1,AX", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalGPFixture(t, row.body)
+			proved, err := proveX86FixedLocal(fn, sig)
+			if (err == nil) != row.valid {
+				t.Fatalf("valid=%v: %v", row.valid, err)
+			}
+			if row.name == "numeric not a pointer" {
+				fixedLocalRequireNumericNativeRole(t, proved, AX)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedGPActualObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	for index, body := range []string{
+		"STC\nNOP\nADCQ $1,AX",
+		"ADDQ $1,AX\nSUBW $1,0(SP)\nMOVQ 0(SP),AX",
+		"STC\nADCQ $1,AX\nSBBL $1,0(SP)\nMOVQ 0(SP),AX",
+		"NOTQ AX\nNEGB 0(SP)\nINCW 0(SP)\nDECL 0(SP)\nMOVQ 0(SP),AX",
+		"TESTQ $1,0(SP)\nCMOVQEQ 0(SP),AX\nSETCS CL",
+		"MOVQ AX,CX\nIMULQ $3,CX\nADDQ CX,AX",
+		"CMPQ AX,AX\nLAHF\nSAHF\nSHLQ $1,0(SP)\nMOVQ 0(SP),AX",
+		"MOVQ AX,CX\nLEAQ 7(AX)(CX*2),AX\nNOPL 8(SP)",
+		"MOVQ $3,CX\nagain:\nADDQ CX,AX\nSUBQ $1,CX\nJNE again",
+		"MOVQ $3,8(SP)\nagain:\nADDQ $1,AX\nSUBQ $1,8(SP)\nJNE again",
+		"CMPQ AX,$1\nJEQ left\nMOVQ $2,CX\nJMP join\nleft:\nMOVQ $3,CX\njoin:\nADDQ CX,AX",
+	} {
+		_, _, source := fixedLocalGPFixture(t, body)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		fmt.Fprintf(&declarations, "func Value%d(a uint64) uint64\n", index)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "typed-gp.ll", "typed-gp.o", ir)
+				})
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceLocalBranches(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"forward", "JMP done\ndone:\nRET", true},
+		{"backward", "again:\nSUBQ $1,AX\nJNE done\nJMP again\ndone:\nRET", true},
+		{"missing", "JMP absent\nRET", false},
+		{"past end", "JMP done\nRET\ndone:", false},
+		{"external", "JMP ·Other(SB)\nRET", false},
+		{"indirect", "JMP AX\nRET", false},
+		{"relative", "JMP 2(PC)\nRET", false},
+		{"call", "CALL ·Other(SB)\nRET", false},
+		{"tail return", "RET ·Other(SB)", false},
+		{"raw", "BYTE $0xc3\nRET", false},
+		{"alignment", "PCALIGN $16\nRET", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$16-0\n"+row.body+"\n")
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatalf("parse original source: %v", err)
+			}
+			err = goAMD64FrameSourceInstructions(file.Funcs[0])
+			if (err == nil) != row.valid {
+				t.Fatalf("valid=%v: %v", row.valid, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedGPLoopAndJoin(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"numeric counter", "MOVQ $3,CX\nagain:\nADDQ CX,AX\nSUBQ $1,CX\nJNE again", true},
+		{"private counter", "MOVQ $3,8(SP)\nagain:\nADDQ $1,AX\nSUBQ $1,8(SP)\nJNE again", true},
+		{"numeric constants join", "CMPQ AX,$1\nJEQ left\nMOVQ $2,CX\nJMP join\nleft:\nMOVQ $3,CX\njoin:\nADDQ CX,AX", true},
+		{"missing first iteration", "again:\nADDQ CX,AX\nMOVQ $3,CX\nJNE again", false},
+		{"flags lost on backedge", "CMPQ AX,AX\nagain:\nSETNE CL\nIMULQ $3,AX\nJCS again", false},
+		{"drifting private address", "MOVQ SP,CX\nagain:\nADDQ $8,CX\nCMPQ AX,AX\nJNE again", false},
+		{"numeric becomes pointer", "MOVQ AX,CX\nagain:\nADDQ CX,AX\nMOVQ SP,CX\nCMPQ AX,AX\nJNE again", false},
+		{"missing byte on one path", "CMPQ AX,$1\nJEQ done\nMOVQ AX,8(SP)\ndone:\nMOVQ 8(SP),AX", false},
+		{"no reachable return", "again:\nJMP again", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalGPFixture(t, row.body)
+			_, err := proveX86FixedLocal(fn, sig)
+			if (err == nil) != row.valid {
+				t.Fatalf("valid=%v: %v", row.valid, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedGPAddressIsNotAccess(t *testing.T) {
+	for _, row := range []struct {
+		body string
+		want bool
+	}{
+		{"LEAQ 7(AX)(CX*2),AX", true},
+		{"LEAL 7(AX),CX", true},
+		{"NOPL 8(SP)", true},
+		{"NOPW (AX)", true},
+		{"LEAQ 8(SP),AX", true},     // Address-only grammar does not grant private backing or NUM.
+		{"LEAQ slot(SP),AX", false}, // A source owner must resolve the descriptive AUTO role.
+		{"LEAQ δοκιμή(SP),AX", false},
+		{"LEAQ UNKNOWN(RSP),AX", false},
+		{"LEAQ UNKNOWN(AX),AX", false},
+		{"LEAQ.Z (AX),CX", false},
+		{"MOVQ (AX),CX", false},
+		{"CMPQ (AX),CX", false},
+		{"ADDQ (AX),CX", false},
+		{"INCQ (AX)", false},
+		{"BTQ CX,(AX)", false},
+		{"UNKNOWN (AX)", false},
+	} {
+		t.Run(row.body, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+row.body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Raw != row.body {
+					continue
+				}
+				if got := fixedLocalGPAddressOnly(ins, 0); got != row.want {
+					t.Fatalf("address-only = %v, want %v", got, row.want)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedGPCFGBudgetIsAtomic(t *testing.T) {
+	fn, sig, _ := fixedLocalGPFixture(t, "MOVQ $3,CX\nagain:\nADDQ CX,AX\nSUBQ $1,CX\nJNE again")
+	for _, budget := range []x86FixedLocalBudget{
+		{steps: 4, bytes: 64 << 20}, // Includes the initial private store.
+		{steps: 1 << 18, bytes: fn.FrameSize - 1},
+	} {
+		proof := &x86FixedLocalProof{frame: fn.FrameSize}
+		if err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, nil); err == nil {
+			t.Fatal("exhausted analysis budget was accepted")
+		}
+		for _, ins := range fn.Instrs {
+			if len(ins.x86FixedLocalMemory) != 0 {
+				t.Fatal("incomplete analysis published an access")
+			}
+		}
+	}
+}
diff --git a/amd64_fixed_local_gp_work_test.go b/amd64_fixed_local_gp_work_test.go
new file mode 100644
index 000000000..6ac2643f4
--- /dev/null
+++ b/amd64_fixed_local_gp_work_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const fixedLocalGPWorkBlock = "ADDQ $3,AX\nRORQ $7,AX\nIMULQ $3,AX\nMULQ BX\nADCQ $1,DX\nSBBQ $1,AX\nCMPQ AX,DX\n"
+
+func fixedLocalGPWorkSource(block string, repeats int, frame int64, partitioned bool) string {
+	body := strings.Repeat(block, repeats)
+	if partitioned {
+		body = strings.Replace(fixedLocalLayoutPingPong, "loop:\n", "loop:\n"+body, 1)
+		body = strings.Replace(body, "ret+16(FP)", "ret+8(FP)", 1)
+	} else {
+		body += "MOVQ AX,ret+8(FP)\nRET\n"
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$%d-16\nMOVQ a+0(FP),CX\nMOVQ $1,AX\nMOVQ $3,BX\n", frame) + body
+}
+
+func TestGoAMD64FixedLocalPartitionGPWork(t *testing.T) {
+	source := fixedLocalGPWorkSource(fixedLocalGPWorkBlock, 128, 4096, true)
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	_, sig := fixedLocalReplayFixture(t, "")
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	proven, err := proveX86FixedLocalAttempt(fn, sig, &budget, true)
+	t.Logf("partition GP: steps=%d bytes=%d error=%v", budget.steps, budget.bytes, err)
+	if err != nil || proven.x86FixedLocal == nil {
+		t.Fatal("complete initialized GP register work must retain bounded frame costs", err)
+	}
+	used := (1 << 18) - budget.steps
+	if used < 16*2*128*7 || budget.bytes <= 0 {
+		t.Fatal("both layouts and sixteen phases must retain every real step", used, budget)
+	}
+	budget = x86FixedLocalBudget{steps: used - 1, bytes: 64 << 20}
+	proven, err = proveX86FixedLocalAttempt(fn, sig, &budget, true)
+	if !errors.Is(err, ErrProbeNeedsContext) || budget.steps != 0 || !reflect.DeepEqual(proven, fn) {
+		t.Fatal("one missing GP step must fail atomically", budget, err)
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionGPRouting(t *testing.T) {
+	rows := []struct {
+		name, body string
+		valid      bool
+	}{
+		{"multiply", "MOVQ $2,AX\nMOVQ $3,BX\nMULQ BX\nADDQ DX,AX", true},
+		{"mulx", "MOVQ $2,DX\nMOVQ $3,BX\nMULXQ BX,AX,SI\nADDQ SI,AX", true},
+		{"carry", "MOVQ $2,AX\nCMPQ AX,AX\nADCQ $1,AX\nSBBQ $1,AX", true},
+		{"private add and mask", "MOVQ SP,AX\nADDQ $16,AX\nANDQ $-16,AX\nMOVQ $7,(AX)\nMOVQ (AX),AX", true},
+		{"private constant", "MOVQ $16,BX\nMOVQ SP,AX\nADDQ BX,AX\nMOVQ $7,(AX)\nMOVQ (AX),AX", true},
+		{"missing AX", "MOVQ $3,BX\nMULQ BX", false},
+		{"missing DX", "MOVQ $3,BX\nMULXQ BX,AX,SI", false},
+		{"missing carry", "MOVQ $2,AX\nADCQ $1,AX", false},
+		{"private partial write", "MOVQ SP,AX\nADDL $8,AX", false},
+		{"private escape", "MOVQ SP,AX\nADDQ $8,AX", false},
+		{"private offset", "MOVQ SP,AX\nADDQ $72,AX\nMOVQ (AX),AX", false},
+		{"private flags", "MOVQ $1,BX\nMOVQ SP,AX\nADDQ $16,AX\nADCQ $1,BX\nMOVQ BX,AX", false},
+	}
+	var assembly strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&assembly, "TEXT ·Value%d(SB),4,$64-16\n%s\nMOVQ AX,ret+8(FP)\nRET\n", index, row.body)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil || len(file.Funcs) != len(rows) {
+		t.Fatal("complete routing inventory changed", err)
+	}
+	_, sig := fixedLocalReplayFixture(t, "")
+	for index, row := range rows {
+		t.Run(row.name, func(t *testing.T) {
+			fn := file.Funcs[index]
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			proven, err := proveX86FixedLocalAttempt(fn, sig, &budget, true)
+			if (err == nil) != row.valid {
+				t.Fatal("cost classification changed the original semantic route", err)
+			}
+			if err != nil && (!errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(proven, fn)) {
+				t.Fatal("rejected GP input changed its error class or published a proof", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionGPWorkProjection(t *testing.T) {
+	rows := []struct {
+		source string
+		cheap  bool
+	}{
+		{"ADDB $1,AX", true}, {"ADDW $1,AX", true}, {"ADDL $1,AX", true}, {"ADDQ $1,AX", true},
+		{"ANDQ $-16,AX", true}, {"ADCQ BX,AX", true}, {"SBBQ BX,AX", true}, {"CMPQ AX,$0", true},
+		{"MULB BX", true}, {"MULW BX", true}, {"MULL BX", true}, {"MULQ BX", true},
+		{"IMULQ BX", true}, {"MULXQ BX,AX,SI", true}, {"CMOVQEQ BX,AX", true},
+		{"ADDQ (SP),AX", false}, {"MULQ (SP)", false}, {"ADDQ a+0(FP),AX", false},
+		{"ADDQ value(SB),AX", false}, {"LEAQ (AX)(BX*8),CX", false}, {"BTQ AX,(BX)", false},
+		{"PUSHQ AX", false}, {"POPQ AX", false}, {"CALL helper(SB)", false}, {"RET", false},
+		{"REP", false}, {"JMP done", false}, {"ADDQ AX", false}, {"UNKNOWN AX", false},
+	}
+	for _, row := range rows {
+		t.Run(row.source, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-16\n"+row.source+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[len(file.Funcs[0].Instrs)-1]
+			effect, got := fixedLocalGPRegisterWork(ins)
+			if got != row.cheap {
+				t.Fatal("conservative source/effect work projection changed", got)
+			}
+			if !got && !reflect.DeepEqual(effect, x86TypedByteEffect{}) {
+				t.Fatal("failed cost query retained a partial descriptor")
+			}
+			if !row.cheap {
+				return
+			}
+			for _, metadata := range []string{"encoded", "raw", "address", "segment", "numerical"} {
+				changed := ins
+				switch metadata {
+				case "encoded":
+					changed.x86Encoded = true
+				case "raw":
+					changed.x86SourceRaw = &x86SourceRawInstruction{}
+				case "address":
+					changed.x86AddressBits = 32
+				case "segment":
+					changed.x86SegmentPrefix = 0x64
+				case "numerical":
+					changed.x86NumericalRead = &x86NumericalReadCertificate{}
+				}
+				if effect, cheap := fixedLocalGPRegisterWork(changed); cheap || !reflect.DeepEqual(effect, x86TypedByteEffect{}) {
+					t.Fatal("source/native or numerical-read metadata received a register discount", metadata)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkFixedLocalGPWorkProjection(b *testing.B) {
+	for _, partitioned := range []bool{false, true} {
+		for _, memory := range []bool{false, true} {
+			name := fmt.Sprintf("partition=%t/memory=%t", partitioned, memory)
+			b.Run(name, func(b *testing.B) {
+				block := fixedLocalGPWorkBlock
+				if memory {
+					block += "MOVQ AX,0(SP)\nMOVQ 0(SP),AX\n"
+				}
+				file, err := Parse(ArchAMD64, fixedLocalGPWorkSource(block, 8, 64, partitioned))
+				if err != nil {
+					b.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				_, sig := fixedLocalReplayFixture(b, "")
+				run := func() {
+					budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+					if _, err := proveX86FixedLocalAttempt(fn, sig, &budget, partitioned); err != nil {
+						b.Fatal("benchmark must be a complete accepted proof", err)
+					}
+				}
+				run()
+				b.ReportAllocs()
+				b.ResetTimer()
+				for iteration := 0; iteration < b.N; iteration++ {
+					run()
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_implicit_multiply_legacy_test.go b/amd64_fixed_local_implicit_multiply_legacy_test.go
new file mode 100644
index 000000000..10e09dc4a
--- /dev/null
+++ b/amd64_fixed_local_implicit_multiply_legacy_test.go
@@ -0,0 +1,24 @@
+//go:build !go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalImplicitMultiplyPrivateLeafNeedsAuditedProducer(t *testing.T) {
+	assembly, declarations, _, _ := fixedLocalImplicitMultiplyProgram("x86_64-unknown-linux-gnu", true)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, request, _, _ := fixedLocalTransportFixture(t, assembly, declarations, "linux/amd64", "x86_64-unknown-linux-gnu")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if source != nil {
+		defer source.Close()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "mixed DATA needs its independent actual Go object producer") {
+		t.Fatal("private CALL borrowed an unaudited original object association", err)
+	}
+}
diff --git a/amd64_fixed_local_implicit_multiply_objects_test.go b/amd64_fixed_local_implicit_multiply_objects_test.go
new file mode 100644
index 000000000..e0b8b1c6a
--- /dev/null
+++ b/amd64_fixed_local_implicit_multiply_objects_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalImplicitMultiplyProgram(triple string, privateLeaf bool) (string, string, string, string) {
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	count := 0
+	for _, stem := range []string{"MUL", "IMUL"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			inputs := []string{"CX", "AX", "DX", "8(SP)"}
+			if width == "B" {
+				inputs = append(inputs, "AH")
+			}
+			if width == "Q" {
+				inputs = append(inputs, "(DX)")
+			}
+			for _, input := range inputs {
+				name := fmt.Sprintf("Value%d", count)
+				fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$64-32
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),DX
+MOVQ AX,0(SP)
+MOVQ DX,8(SP)
+MOVQ DX,CX
+`, name)
+				if input == "(DX)" {
+					assembly.WriteString("LEAQ 8(SP),DX\n")
+				}
+				if privateLeaf && input == "(DX)" {
+					// The source pointer addresses this caller's private frame.
+					// The observed leaf never reads its own SP or a fabricated ABI.
+					fmt.Fprintf(&assembly, "CALL multiply%d<>(SB)\n", count)
+				} else {
+					fmt.Fprintf(&assembly, "%s%s %s\n", stem, width, input)
+				}
+				assembly.WriteString(`MOVQ $0,R8
+MOVQ $0,R9
+SETCS R8
+SETOS R9
+MOVQ mode+16(FP),CX
+CMPQ CX,$1
+JEQ high
+CMPQ CX,$2
+JEQ carry
+CMPQ CX,$3
+JEQ overflow
+CMPQ CX,$4
+JEQ canary
+JMP done
+high:
+MOVQ DX,AX
+JMP done
+carry:
+MOVQ R8,AX
+JMP done
+overflow:
+MOVQ R9,AX
+JMP done
+canary:
+MOVQ 0(SP),AX
+done:
+MOVQ AX,ret+24(FP)
+RET
+`)
+				if privateLeaf && input == "(DX)" {
+					fmt.Fprintf(&assembly, "TEXT multiply%d<>(SB),4,$0-0\n%sQ (DX)\nRET\n", count, stem)
+				}
+				fmt.Fprintf(&declarations, "func %s(a,b,mode uint64) uint64\n", name)
+				fmt.Fprintf(&goRows, "%s,\n", name)
+				fmt.Fprintf(&cRows, "value%d,\n", count)
+				label := runtimeCAsmLabel(prefix + "example.invalid/framefixture." + name)
+				fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t,uint64_t,uint64_t) __asm__(%s);\n", count, label)
+				count++
+			}
+		}
+	}
+	const values = `0,1,0x7f,0x80,0xff,0x7fff,0x8000,0xffff,
+0x7fffffff,0x80000000,0xffffffff,0x7fffffffffffffff,
+0x8000000000000000,0xffffffffffffffff,0x8080808080808080,0x0123456789abcdef`
+	original := `package main
+import "fmt"
+` + declarations.String() + `
+func main() {
+    rows := []func(uint64,uint64,uint64) uint64{
+` + goRows.String() + `
+    }
+    values := []uint64{` + values + `}
+    for n, call := range rows {
+        for v, a := range values {
+            b := values[(v+1)%len(values)]
+            for mode := uint64(0); mode < 5; mode++ {
+                got := call(a,b,mode)
+                if mode == 4 && got != a { panic("private input canary changed") }
+                fmt.Printf("%d %d %d %016x\n",n,v,mode,got)
+            }
+        }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+int main(void) {
+    uint64_t (*const rows[])(uint64_t,uint64_t,uint64_t) = {
+` + cRows.String() + `
+    };
+    const uint64_t values[] = {` + values + `};
+    const unsigned count = sizeof(values)/sizeof(values[0]);
+    for (unsigned n = 0; n < sizeof(rows)/sizeof(rows[0]); n++) {
+        for (unsigned v = 0; v < count; v++) {
+            for (unsigned mode = 0; mode < 5; mode++) {
+                uint64_t got = rows[n](values[v],values[(v+1)%count],mode);
+                if (mode == 4 && got != values[v]) { return 2; }
+                printf("%u %u %u %016llx\n",n,v,mode,(unsigned long long)got);
+            }
+        }
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func TestGoAMD64FixedLocalImplicitMultiplyObjects(t *testing.T) {
+	fixedLocalImplicitMultiplyObjects(t, false)
+}
+
+func fixedLocalImplicitMultiplyObjects(t *testing.T, privateLeaf bool) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, _, _ := fixedLocalImplicitMultiplyProgram("x86_64-unknown-linux-gnu", privateLeaf)
+	helpers := 0
+	if privateLeaf {
+		helpers = 2
+	}
+	if strings.Count(assembly, "TEXT ·Value") != 36 || strings.Count(assembly, "TEXT multiply") != helpers {
+		t.Fatal("incomplete independent multiply kernel/private-leaf inventory")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			var names []string
+			for index := 0; index < 36; index++ {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "implicit-multiply.ll", "implicit-multiply.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "implicit-multiply-opt.ll", "implicit-multiply-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
diff --git a/amd64_fixed_local_implicit_multiply_runtime_go127_test.go b/amd64_fixed_local_implicit_multiply_runtime_go127_test.go
new file mode 100644
index 000000000..bf16792cd
--- /dev/null
+++ b/amd64_fixed_local_implicit_multiply_runtime_go127_test.go
@@ -0,0 +1,52 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalImplicitMultiplyPrivateLeafObjects(t *testing.T) {
+	fixedLocalImplicitMultiplyObjects(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalImplicitMultiply(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	t.Setenv("GOCACHE", t.TempDir())
+	assembly, declarations, original, driver := fixedLocalImplicitMultiplyProgram(execution.triple, true)
+	want := strings.Split(strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))), "\n")
+	if len(want) != 36*16*5 {
+		t.Fatalf("original Go produced %d rows, want 36 kernels x 16 inputs x 5 observations", len(want))
+	}
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "private-implicit-multiply", input, driver, level)
+					got := strings.Split(strings.TrimSpace(string(output)), "\n")
+					if len(got) != len(want) {
+						t.Fatalf("LLVM row count = %d, original = %d", len(got), len(want))
+					}
+					for index := range want {
+						if got[index] != want[index] {
+							t.Fatalf("private multiply halves/FLAGS/canary row %d: original %s; LLVM %s", index, want[index], got[index])
+						}
+					}
+				})
+			}
+		})
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("original Go and LLVM amd64 execution via Rosetta, not native x86 hardware")
+	}
+}
diff --git a/amd64_fixed_local_implicit_multiply_test.go b/amd64_fixed_local_implicit_multiply_test.go
new file mode 100644
index 000000000..9167abd7f
--- /dev/null
+++ b/amd64_fixed_local_implicit_multiply_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// The family and physical widths are an independent inventory; the existing
+// official-table owner checks these names against Go's complete multiply rows.
+var fixedLocalImplicitMultiplyWidths = []struct {
+	suffix string
+	width  int64
+	input  uint8
+	output uint8
+}{
+	{"B", 1, 1, 3},
+	{"W", 2, 3, 3},
+	{"L", 4, 15, 255},
+	{"Q", 8, 255, 255},
+}
+
+func TestGoAMD64FixedLocalImplicitMultiplyForms(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, stem := range []string{"MUL", "IMUL"} {
+		for _, width := range fixedLocalImplicitMultiplyWidths {
+			name := stem + width.suffix
+			inputs := []string{"AX", "CX", "DX", "R8", "8(SP)", "(DX)"}
+			if width.width == 1 {
+				inputs = append(inputs, "AL", "AH")
+			}
+			for _, input := range inputs {
+				t.Run(name+"/"+input, func(t *testing.T) {
+					body := "MOVQ AX,CX\nMOVQ AX,R8\nMOVQ AX,DX\nMOVQ AX,8(SP)\n"
+					if input == "(DX)" {
+						body += "LEAQ 8(SP),DX\n"
+					}
+					body += name + " " + input
+					// A narrow output cannot overwrite only part of a private
+					// pointer. Byte multiply leaves DX unchanged; qword replaces it.
+					valid := input != "(DX)" || width.width == 1 || width.width == 8
+					fn, sig, source := fixedLocalGPFixture(t, body)
+					original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+					count++
+					proved, err := proveX86FixedLocal(fn, sig)
+					if !valid {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("partial output overwrote a private pointer", err)
+						}
+						return
+					}
+					if err != nil {
+						t.Fatal("complete initialized implicit multiply rejected", err)
+					}
+					observed := 0
+					for _, ins := range proved.Instrs {
+						if string(ins.Op) != name {
+							continue
+						}
+						observed++
+						access, found := ins.x86FixedLocalMemory[0]
+						memory := strings.Contains(input, "(")
+						if found != memory || found && (access.width != width.width || access.write ||
+							access.nativeInput || access.owner != proved.x86FixedLocal) {
+							t.Fatal("multiply did not preserve its exact private read", access)
+						}
+					}
+					if observed != 1 {
+						t.Fatalf("proved source retained %d multiply instructions, want one", observed)
+					}
+				})
+			}
+		}
+	}
+	if count != 52 {
+		t.Fatalf("independent multiply inventory changed: %d", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalImplicitMultiplyByteEffects(t *testing.T) {
+	for _, stem := range []string{"MUL", "IMUL"} {
+		for _, width := range fixedLocalImplicitMultiplyWidths {
+			sources := []struct {
+				name, root Reg
+				mask       uint8
+			}{{AX, AX, width.input}, {CX, CX, width.input}, {DX, DX, width.input}}
+			if width.width == 1 {
+				sources = append(sources, struct {
+					name, root Reg
+					mask       uint8
+				}{"AH", AX, 2})
+			}
+			for _, source := range sources {
+				name := stem + width.suffix
+				t.Run(name+"/"+string(source.name), func(t *testing.T) {
+					ins := x86YMMReadSource(t, name+" "+string(source.name))
+					effect, known, err := fixedLocalGPByteEffect(ins)
+					if !known || err != nil || !effect.requiresResultProof {
+						t.Fatal("closed implicit family lacks its existing numerical effect", known, err)
+					}
+					state := x86FixedLocalState{
+						known:    map[Reg]uint8{AX: width.input, DX: 0, CX: 0},
+						booleans: make(map[Reg]uint8),
+						flags:    x86ByteFlagsAll,
+					}
+					state.known[source.root] |= source.mask
+					before := cloneFixedLocalState(state)
+					want := cloneFixedLocalState(before)
+					want.known[AX] |= width.output
+					if width.width != 1 {
+						want.known[DX] |= width.output
+					}
+					want.flags = x86ByteFlagCF | x86ByteFlagOF
+					if err := fixedLocalTypedByteStep(&ins, &state, FuncSig{}, nil, 0, effect); err != nil ||
+						!reflect.DeepEqual(state.known, want.known) || state.flags != want.flags {
+						t.Fatal("implicit accumulator/output width or FLAGS changed", state, want, err)
+					}
+					for _, input := range []struct {
+						root Reg
+						mask uint8
+					}{{AX, width.input}, {source.root, source.mask}} {
+						for bit := uint8(1); bit != 0; bit <<= 1 {
+							if input.mask&bit == 0 {
+								continue
+							}
+							missing := cloneFixedLocalState(before)
+							missing.known[input.root] &^= bit
+							if err := fixedLocalTypedByteStep(&ins, &missing, FuncSig{}, nil, 0, effect); !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown input byte acquired a numerical result", input, bit, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalImplicitMultiplyBoundaries(t *testing.T) {
+	for _, stem := range []string{"MUL", "IMUL"} {
+		for _, width := range fixedLocalImplicitMultiplyWidths {
+			name := stem + width.suffix
+			for _, row := range []struct {
+				name, before, source, after string
+				valid                       bool
+			}{
+				{"carry", "", "0(SP)", "ADCQ $0,AX", true},
+				{"overflow", "", "0(SP)", "JOS done\ndone:", true},
+				{"old zero revoked", "CMPQ AX,AX\n", "0(SP)", "JEQ done\ndone:", false},
+				{"old parity revoked", "CMPQ AX,AX\n", "0(SP)", "JPS done\ndone:", false},
+				{"old sign revoked", "CMPQ AX,AX\n", "0(SP)", "JMI done\ndone:", false},
+				{"old auxiliary revoked", "CMPQ AX,AX\n", "0(SP)", "LAHF", false},
+				{"missing source", "", "CX", "", false},
+				{"private accumulator", "MOVQ SP,AX\n", "0(SP)", "", false},
+				{"private source", "MOVQ SP,CX\n", "CX", "", false},
+				{"unwritten memory", "", "8(SP)", "", false},
+				{"one missing memory byte", "MOVQ AX,8(SP)\n", fmt.Sprintf("%d(SP)", 17-width.width), "", false},
+				{"outside frame", "", "64(SP)", "", false},
+				{"one byte outside frame", "MOVQ AX,56(SP)\n", fmt.Sprintf("%d(SP)", 65-width.width), "", false},
+				{"numerical address", "", "(AX)", "", true},
+				{"private spill", "MOVQ SP,8(SP)\n", "8(SP)", "", false},
+			} {
+				t.Run(name+"/"+row.name, func(t *testing.T) {
+					fn, sig, _ := fixedLocalGPFixture(t, row.before+name+" "+row.source+"\n"+row.after)
+					proved, err := proveX86FixedLocal(fn, sig)
+					if (err == nil) != row.valid {
+						t.Fatalf("valid=%v: %v", row.valid, err)
+					}
+					if row.name == "numerical address" {
+						fixedLocalRequireNumericNativeRole(t, proved, AX)
+					}
+				})
+			}
+			for _, role := range []string{"accumulator", "source"} {
+				t.Run(name+"/opaque "+role, func(t *testing.T) {
+					body := "MOVQ SI,CX\n" + name + " CX"
+					if role == "accumulator" {
+						body = "MOVQ SI,AX\n" + name + " 0(SP)"
+					}
+					fn, sig, _ := fixedLocalInputFixture(t, body)
+					if _, err := proveX86FixedLocal(fn, sig); err != nil {
+						t.Fatal("complete native machine bits were rejected as multiply input", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_fixed_local_index_go127_test.go b/amd64_fixed_local_index_go127_test.go
new file mode 100644
index 000000000..ee57851f7
--- /dev/null
+++ b/amd64_fixed_local_index_go127_test.go
@@ -0,0 +1,143 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalConstantIndexFunction(name, body string) string {
+	return fmt.Sprintf("TEXT ·%s(SB),4,$64-16\nMOVQ a+0(FP),AX\nMOVQ AX,0(SP)\n%s\nMOVQ AX,ret+8(FP)\nRET\n", name, body)
+}
+
+func TestGoAMD64FixedLocalConstantIndexObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	assembly.WriteString(fixedLocalAddressData)
+	cases := fixedLocalConstantIndexCases()
+	if len(cases) != 30 {
+		t.Fatal("two origins by complete non-SP GP bank changed", len(cases))
+	}
+	for index, row := range cases {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(fixedLocalConstantIndexFunction(name, row.body))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			var names []string
+			for index := range cases {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("original constant-index private/DATA source rejected", err)
+					}
+					if !strings.Contains(ir, "internal constant [32 x i8]") {
+						t.Fatal("private readonly DATA was not retained")
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "constant-index.ll", "constant-index.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "constant-index-opt.ll", "constant-index-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+	t.Log("30 original-Go functions cover 15 non-SP index registers, four scales, private store/RMW/load and readonly DATA reads; three APIs at O0/O2")
+}
+
+func TestGoAMD64FixedLocalConstantIndexGuards(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, literal := range []bool{false, true} {
+		name, acquire, size := "private", "MOVQ SP,DI\n", 64
+		if literal {
+			name, acquire, size = "literal", "LEAQ literal<>(SB),DI\n", 32
+		}
+		for _, row := range []struct {
+			name, body string
+			valid      bool
+		}{
+			{"first byte via negative index", "MOVQ $-1,SI\nMOVQ 8(DI)(SI*8),AX", true},
+			{"last byte", fmt.Sprintf("MOVQ $%d,SI\nMOVQ $0,AX\nMOVB (DI)(SI*1),AX", size-1), true},
+			{"last word", fmt.Sprintf("MOVQ $%d,SI\nMOVQ $0,AX\nMOVW (DI)(SI*1),AX", size-2), true},
+			{"last dword", fmt.Sprintf("MOVQ $%d,SI\nMOVL (DI)(SI*1),AX", size-4), true},
+			{"last qword", fmt.Sprintf("MOVQ $%d,SI\nMOVQ (DI)(SI*8),AX", size/8-1), true},
+			{"last vector", fmt.Sprintf("MOVQ $%d,SI\nMOVOU (DI)(SI*1),X0\nMOVQ X0,AX", size-16), true},
+			{"indexed full spill round trip", "MOVQ DI,16(SP)\nMOVQ $2,SI\nMOVQ (SP)(SI*8),R8\nMOVQ (R8),AX", true},
+			{"before allocation", "MOVQ $-1,SI\nMOVQ (DI)(SI*1),AX", false},
+			{"past allocation", fmt.Sprintf("MOVQ $%d,SI\nMOVQ 1(DI)(SI*8),AX", size/8-1), false},
+			{"positive multiply wraps to base", "MOVQ $9223372036854775807,SI\nMOVQ 2(DI)(SI*2),AX", literal},
+			{"negative multiply wraps to base", "MOVQ $-9223372036854775808,SI\nMOVQ (DI)(SI*2),AX", literal},
+			{"displacement overflow", "MOVQ $9223372036854775807,SI\nMOVQ 1(DI)(SI*1),AX", false},
+			{"unaligned vector", "MOVQ $1,SI\nMOVO (DI)(SI*1),X0", false},
+			{"dynamic numerical index", "MOVQ a+0(FP),SI\nMOVQ (DI)(SI*1),AX", literal},
+			{"unknown upper index bytes", "MOVW $0,SI\nMOVQ (DI)(SI*1),AX", false},
+			{"defined partial index overwrite", "MOVQ $0,SI\nMOVB $1,SI\nMOVQ (DI)(SI*1),AX", literal},
+			{"pointer used as index", "MOVQ DI,SI\nMOVQ (DI)(SI*1),AX", false},
+			{"numeric base loses origin", "MOVQ $0,DI\nMOVQ $0,SI\nMOVQ (DI)(SI*1),AX", true},
+			{"different constants at join", "MOVQ $77,8(SP)\nMOVQ $0,SI\nCMPQ AX,$0\nJEQ joined\nMOVQ $1,SI\njoined:\nMOVQ (DI)(SI*8),AX", literal},
+			{"loaded numerical index", "MOVQ $0,SI\nMOVQ (DI)(SI*1),SI\nMOVQ (DI)(SI*1),AX", literal},
+		} {
+			t.Run(name+"/"+row.name, func(t *testing.T) {
+				body := "MOVQ $77,48(SP)\nMOVQ $77,56(SP)\n" + acquire + row.body
+				assembly := fixedLocalAddressData + fixedLocalConstantIndexFunction("Value", body)
+				pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+					"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+				// The actual Go capture is a prerequisite, not evidence that an
+				// invalid extent or provenance was rejected by our translator.
+				source := requireGoAMD64FrameCapture(t, pkg, request)
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+				if row.valid && err != nil {
+					t.Fatal("valid constant-index boundary rejected", err)
+				}
+				if !row.valid && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unproved constant-index bytes or origin accepted", err)
+				}
+				if row.name == "numeric base loses origin" {
+					proved, err := proveX86FixedLocal(file.Funcs[0], bound.Sigs[pkg.Path+".Value"])
+					if err != nil {
+						t.Fatal(err)
+					}
+					fixedLocalRequireNumericNativeRole(t, proved, DI)
+				}
+			})
+		}
+	}
+	for _, row := range []struct{ name, body string }{
+		{"readonly store", "LEAQ literal<>(SB),DI\nMOVQ $1,SI\nMOVQ AX,(DI)(SI*8)"},
+		{"readonly RMW", "LEAQ literal<>(SB),DI\nMOVQ $1,SI\nADDQ AX,(DI)(SI*8)"},
+		{"uninitialized private bytes", "MOVQ $1,SI\nMOVQ (SP)(SI*8),AX"},
+		{"partial private initialization", "MOVQ $1,SI\nMOVL AX,(SP)(SI*8)\nMOVQ (SP)(SI*8),AX"},
+		{"indexed write revokes spilled origin", "MOVQ SP,R8\nMOVQ R8,16(SP)\nMOVQ $2,SI\nMOVL $0,(SP)(SI*8)\nMOVQ 16(SP),DI\nMOVQ (DI),AX"},
+		{"index cannot borrow unindexed private spill", "MOVQ SP,R8\nMOVQ R8,0(SP)\nMOVQ $1,SI\nMOVQ (SP)(SI*8),DI\nMOVQ $77,(DI)\nMOVQ $0,AX"},
+		{"index cannot borrow unindexed literal spill", "LEAQ literal<>(SB),DI\nMOVQ DI,0(SP)\nMOVQ $1,SI\nMOVQ (SP)(SI*8),DI\nMOVQ (DI),AX"},
+		{"mixed private and literal index", "LEAQ literal<>(SB),SI\nMOVQ (SP)(SI*1),AX"},
+		{"mixed literal and private index", "LEAQ literal<>(SB),DI\nMOVQ SP,SI\nMOVQ (DI)(SI*1),AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalAddressData + fixedLocalConstantIndexFunction("Value", row.body)
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("indexed access acquired uninitialized/mutable/address permission", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_index_test.go b/amd64_fixed_local_index_test.go
new file mode 100644
index 000000000..885a95b84
--- /dev/null
+++ b/amd64_fixed_local_index_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalConstantIndexCase struct {
+	name, body string
+	literal    bool
+}
+
+func fixedLocalConstantIndexCases() []fixedLocalConstantIndexCase {
+	var cases []fixedLocalConstantIndexCase
+	// Independent physical GP inventory: SP is a base, never an index.
+	for _, register := range strings.Fields("AX BX CX DX DI SI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+		for _, literal := range []bool{false, true} {
+			var body strings.Builder
+			body.WriteString("MOVQ $0,8(SP)\n")
+			base, name := "SP", "private/"+register
+			if literal {
+				base, name = "SI", "literal/"+register
+				if register == base {
+					base = "DI"
+				}
+				fmt.Fprintf(&body, "LEAQ literal<>(SB),%s\n", base)
+			} else {
+				body.WriteString("MOVQ $77,48(SP)\n")
+			}
+			for ordinal, scale := range []int{1, 2, 4, 8} {
+				offset := 56 // The final qword of this private 64-byte frame.
+				if literal {
+					offset = ordinal * 8
+				}
+				address := fmt.Sprintf("%d(%s)(%s*%d)", offset-3*scale, base, register, scale)
+				if !literal {
+					body.WriteString("MOVQ $0,56(SP)\n")
+				}
+				fmt.Fprintf(&body, "MOVQ $3,%s\n", register)
+				if !literal {
+					fmt.Fprintf(&body, "MOVQ $%d,%s\nADDQ $1,%s\n", 17+scale, address, address)
+				}
+				fmt.Fprintf(&body, "MOVQ %s,AX\nADDQ AX,8(SP)\n", address)
+				if !literal {
+					body.WriteString("MOVQ 56(SP),AX\nADDQ AX,8(SP)\n")
+				}
+			}
+			if !literal {
+				body.WriteString("MOVQ 48(SP),AX\nADDQ AX,8(SP)\n")
+			}
+			body.WriteString("MOVQ 8(SP),AX")
+			cases = append(cases, fixedLocalConstantIndexCase{name, body.String(), literal})
+		}
+	}
+	return cases
+}
+
+func TestGoAMD64FixedLocalConstantIndexPrivate(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, row := range fixedLocalConstantIndexCases() {
+		if row.literal {
+			continue
+		}
+		fn, sig, source := fixedLocalGPFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+		count++
+		t.Run(row.name, func(t *testing.T) {
+			proved, err := proveX86FixedLocal(fn, sig)
+			if err != nil {
+				t.Fatal("constant index must retain exact private bytes", err)
+			}
+			accesses := 0
+			for _, instruction := range proved.Instrs {
+				for index, operand := range instruction.Args {
+					if operand.Kind != OpMem || operand.Mem.Index == "" {
+						continue
+					}
+					accesses++
+					access, found := instruction.x86FixedLocalMemory[index]
+					write := instruction.Op == "ADDQ" || index == 1
+					if !found || access.owner != proved.x86FixedLocal || access.width != 8 ||
+						access.nativeInput || access.write != write || access.offset != [8]int64{56, 56, 56, 56, 56, 56, 56, 56} {
+						t.Fatalf("indexed access lost its exact byte/role certificate: %+v", access)
+					}
+				}
+			}
+			if accesses != 12 {
+				t.Fatal("expected one store/RMW/load for each scale", accesses)
+			}
+		})
+	}
+	if count != 15 {
+		t.Fatal("independent non-SP GP inventory changed", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_input_runtime_test.go b/amd64_fixed_local_input_runtime_test.go
new file mode 100644
index 000000000..34f2f7332
--- /dev/null
+++ b/amd64_fixed_local_input_runtime_test.go
@@ -0,0 +1,91 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The independent volatile-byte reference checks an observable access, not
+// original SIMD execution or any claimed pointee extent from its Go type.
+func TestGoAMD64FixedLocalInputMemoryDeadReadFaults(t *testing.T) {
+	t.Run("native-numeric-address", fixedLocalNativeNumericAddressRuntime)
+	fixedLocalInputMemoryFaults(t, []fixedLocalInputFaultCase{{"MOVQ (SI),CX", 8}, {"CMPQ (SI),$0", 8}})
+}
+
+func TestGoAMD64FixedLocalInputMemoryDeadMultiplyFaults(t *testing.T) {
+	var cases []fixedLocalInputFaultCase
+	for index, suffix := range []string{"W", "L", "Q"} {
+		for _, instruction := range []string{"IMUL" + suffix + " (SI),AX", "IMUL3" + suffix + " $0,(SI),AX"} {
+			cases = append(cases, fixedLocalInputFaultCase{instruction, 2 << uint(index)})
+		}
+	}
+	fixedLocalInputMemoryFaults(t, cases)
+}
+
+func TestGoAMD64FixedLocalInputMemoryDeadLogicalFaults(t *testing.T) {
+	var cases []fixedLocalInputFaultCase
+	for index, suffix := range []string{"B", "W", "L", "Q"} {
+		for _, stem := range []string{"AND", "OR", "XOR"} {
+			cases = append(cases, fixedLocalInputFaultCase{stem + suffix + " (SI),AX", 1 << uint(index)})
+		}
+	}
+	fixedLocalInputMemoryFaults(t, cases)
+}
+
+type fixedLocalInputFaultCase struct {
+	instruction string
+	width       int
+}
+
+func fixedLocalInputMemoryFaults(t *testing.T, cases []fixedLocalInputFaultCase) {
+	t.Helper()
+	execution := x86ScalarCountHostExecution(t)
+	originalTriple := testTargetTriple(runtime.GOOS, "amd64")
+	var assembly, declarations, prototypes, rows strings.Builder
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	for index, row := range cases {
+		_, _, source := fixedLocalInputFixture(t, row.instruction+"\nMOVQ $0,AX")
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		fmt.Fprintf(&declarations, "func Value%d(p, q *uint64, a uint64) uint64\n", index)
+		fmt.Fprintf(&prototypes, "extern uint64_t value%d(const uint8_t *,uint64_t *,uint64_t) __asm__(%q);\n",
+			index, prefix+"example.invalid/framefixture.Value"+fmt.Sprint(index))
+		fmt.Fprintf(&prototypes, "static int run%d(const uint8_t *p) {\n    uint64_t output = 0;\n    return value%d(p, &output, 0) != 0;\n}\n", index, index)
+		fmt.Fprintf(&rows, "{run%d,%d,%d},\n", index, row.width, row.width-1)
+	}
+	driver := x86MemoryFaultDriver(prototypes.String(), rows.String())
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(),
+		runtime.GOOS+"/amd64", originalTriple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.HasPrefix(strings.TrimSpace(line), "declare ") {
+					continue // The common prelude includes unused x86 declarations.
+				}
+				if strings.Contains(line, " asm ") || strings.Contains(line, "@llvm.x86.") {
+					t.Fatal("host scalar oracle cannot execute x86-specific operations")
+				}
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2_backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					compileLLVMToObject(t, execution.llc, originalTriple, "input-fault.ll", "input-fault.o", pipeline.ir)
+					executable := execution.compileLLVM(t, "fixed-local-input-fault", pipeline.ir, driver, pipeline.level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, len(cases))
+				})
+			}
+		})
+	t.Log("original amd64 three-API objects; actual-host pure scalar LLVM fault execution, not original x86/Go execution")
+}
diff --git a/amd64_fixed_local_input_test.go b/amd64_fixed_local_input_test.go
new file mode 100644
index 000000000..104d92567
--- /dev/null
+++ b/amd64_fixed_local_input_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalInputFixture(t *testing.T, body string) (Func, FuncSig, string) {
+	t.Helper()
+	_, _, sig, source := x86ResultInitializationFixture(t, "amd64",
+		"func Value(p, q *uint64, a uint64) uint64",
+		"MOVQ p+0(FP),SI\nMOVQ q+8(FP),DI\nMOVQ a+16(FP),AX\nMOVQ AX,0(SP)\n"+
+			body+"\nMOVQ AX,ret+24(FP)\nRET")
+	source = strings.Replace(source, "$0-32", "$64-32", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestGoAMD64FixedLocalInputMemoryWidths(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, operation := range []string{
+			"MOV%s 3(SI),CX\nMOVQ CX,8(SP)\nMOVQ 8(SP),AX",
+			"MOV%s AX,5(DI)",
+			"ADD%s 3(SI),AX",
+			"ADD%s $1,5(DI)",
+			"NEG%s 5(DI)",
+			"CMP%s 3(SI),$1\nSETCS CL",
+		} {
+			body := "MOVQ AX,CX\n" + fmt.Sprintf(operation, width)
+			fn, sig, source := fixedLocalInputFixture(t, body)
+			original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+			count++
+			t.Run(fmt.Sprintf("%s/%d", width, count), func(t *testing.T) {
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+	if count != 24 {
+		t.Fatal("changed independent scalar memory width inventory", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalInputMemoryProvenance(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"copy", "MOVQ SI,CX\nMOVQ 3(CX),AX", true},
+		{"private pointer spill", "MOVQ SI,8(SP)\nMOVQ 8(SP),CX\nMOVQ 3(CX),AX", true},
+		{"private numerical spill", "MOVQ (SI),CX\nMOVQ CX,8(SP)\nMOVQ 8(SP),AX", true},
+		{"unaligned vector", "MOVOU (SI),X0\nMOVOU X0,16(SP)\nMOVQ 16(SP),AX", true},
+		{"aligned native vector", "MOVO (SI),X0\nMOVOU X0,16(SP)\nMOVQ 16(SP),AX", true},
+		{"native vector output", "MOVOU (SI),X0\nMOVOU X0,(DI)", true},
+		{"mask zeroing native input", "KMOVQ AX,K1\nVMOVDQU8.Z (SI),K1,Z0\nVMOVDQU8 Z0,0(SP)\nMOVQ 0(SP),AX", true},
+		{"mask native output", "KMOVQ AX,K1\nVMOVDQU8 (SI),Z0\nVMOVDQU8 Z0,K1,(DI)", true},
+		{"numerical loop", "MOVQ $3,CX\nagain:\nADDQ (SI),AX\nSUBQ $1,CX\nJNE again", true},
+		{"same input join", "CMPQ AX,$1\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ SI,CX\njoin:\nMOVQ (CX),AX", true},
+		{"numerical address", "MOVQ (AX),CX", true},
+		{"loaded integer is not pointer", "MOVQ (SI),CX\nMOVQ (CX),AX", true},
+		{"private pointer escape", "MOVQ SP,CX\nMOVQ CX,(DI)", false},
+		{"opaque pointer store", "MOVQ SI,(DI)", false},
+		{"private pointer arithmetic", "ADDQ SI,AX", false},
+		{"input pointer arithmetic", "ADDQ $8,SI\nMOVQ (SI),AX", true},
+		{"input pointer LEA", "LEAQ 8(SI),CX\nMOVQ (CX),AX", true},
+		{"input pointer partial write", "MOVB $0,SI\nMOVQ (SI),AX", false},
+		{"input pointer partial spill", "MOVQ SI,8(SP)\nMOVB $0,8(SP)\nMOVQ 8(SP),CX\nMOVQ (CX),AX", false},
+		{"numerical index", "MOVQ (SI)(AX*2),CX", true},
+		{"private index", "MOVQ (SI)(SP*1),CX", false},
+		{"segment", "MOVQ (SI)(FS*1),CX", false},
+		{"different input join", "CMPQ AX,$1\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ DI,CX\njoin:\nMOVQ (CX),AX", true},
+		{"pointer and number join", "CMPQ AX,$1\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ AX,CX\njoin:\nMOVQ (CX),AX", false},
+		{"private missing byte", "MOVQ (SI),AX\nADDQ $1,8(SP)", false},
+		{"private crossing frame", "MOVQ (SI),AX\nMOVQ AX,60(SP)", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalInputFixture(t, row.body)
+			proved, err := proveX86FixedLocal(fn, sig)
+			if (err == nil) != row.valid {
+				t.Fatalf("valid=%v: %v", row.valid, err)
+			}
+			if row.name == "numerical address" {
+				fixedLocalRequireNumericNativeRole(t, proved, AX)
+			}
+			if row.name == "loaded integer is not pointer" {
+				fixedLocalRequireNumericNativeRole(t, proved, CX)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalInputMemoryActualObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	for index, body := range []string{
+		"MOVQ (SI),CX\nMOVQ CX,8(SP)\nMOVQ 8(SP),AX\nMOVQ AX,(DI)",
+		"ADDQ (SI),AX\nSUBW $1,(DI)\nNEGB 1(DI)",
+		"CMPQ (SI),$1\nCMOVQCS 8(SI),AX\nSETCS 8(DI)",
+		"MOVO (SI),X0\nMOVOU X0,16(SP)\nMOVOU X0,(DI)\nMOVQ 16(SP),AX",
+		"KMOVQ AX,K1\nVMOVDQU8.Z (SI),K1,Z0\nVMOVDQU8 Z0,0(SP)\nVMOVDQU8 Z0,K1,(DI)\nMOVQ 0(SP),AX",
+		"MOVQ SI,8(SP)\nMOVQ 8(SP),CX\nMOVQ (CX),AX\nMOVQ $0,AX",
+		"ADDQ AX,SI\nMOVQ (SI),AX",
+		"ADDQ SI,AX\nMOVQ (AX),AX",
+		"SUBQ AX,SI\nMOVQ (SI),AX",
+		"LEAQ -64(SI)(AX*8),CX\nMOVQ (CX),AX",
+		"INCQ SI\nDECQ SI\nMOVQ (SI),AX",
+		"MOVQ SI,8(SP)\nCMPQ DI,8(SP)\nSETCS AL",
+		"MOVQ SI,8(SP)\nCMPQ 8(SP),DI\nSETCS AL",
+		"CMPQ AX,$0\nJEQ join\nMOVQ SI,8(SP)\njoin:",
+	} {
+		_, _, source := fixedLocalInputFixture(t, body)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		fmt.Fprintf(&declarations, "func Value%d(p, q *uint64, a uint64) uint64\n", index)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			fixedLocalConversionPrepareToolCache(t, request)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, required := range []string{"load volatile i64", "store volatile i64", "movdqa"} {
+						if !strings.Contains(ir, required) {
+							t.Fatal("native memory instruction lost observable access", required)
+						}
+					}
+					masked := x86StringMemoryFunction(t, ir, pkg.Path+".Value4")
+					if strings.Count(masked, "load volatile i8,") != 64 ||
+						strings.Count(masked, "store volatile i8 ") != 64 || strings.Count(masked, "br i1 ") != 128 {
+						t.Fatal("masked input/output lost its active-lane volatile accesses")
+					}
+					optimized := x86MulDivRoundOptimize(t, ir)
+					for _, version := range []string{ir, optimized} {
+						dead := x86StringMemoryFunction(t, version, pkg.Path+".Value5")
+						if !strings.Contains(dead, "load volatile i64") {
+							t.Fatal("dead native input read disappeared from its own function")
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "input-memory.ll", "input-memory.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "input-memory-opt.ll", "input-memory-opt.o", optimized)
+				})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalInputMemoryRoleCertificate(t *testing.T) {
+	fn, sig, _ := fixedLocalInputFixture(t, "MOVQ (SI),CX\nMOVQ CX,8(SP)\nMOVQ 8(SP),AX\nMOVQ AX,(DI)")
+	proved, err := proveX86FixedLocal(fn, sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := amd64Ctx{fixedLocal: proved.x86FixedLocal}
+	native, private := 0, 0
+	for _, instruction := range proved.Instrs {
+		for index, access := range instruction.x86FixedLocalMemory {
+			if _, valid := ctx.fixedLocalMemoryAccess(instruction, index); !valid {
+				t.Fatal("original access lost its whole-function binding")
+			}
+			if ctx.fixedLocalMemoryCertified(instruction, index) == access.nativeInput {
+				t.Fatal("native input acquired a private extent/alignment certificate")
+			}
+			if access.nativeInput {
+				native++
+			} else {
+				private++
+			}
+			changed := instruction
+			changed.x86FixedLocalMemory = map[int]x86FixedLocalAccess{index: access}
+			access.nativeInput = !access.nativeInput
+			changed.x86FixedLocalMemory[index] = access
+			if _, valid := ctx.fixedLocalMemoryAccess(changed, index); valid {
+				t.Fatal("mutated address role retained authority")
+			}
+		}
+	}
+	if native != 2 || private != 3 {
+		t.Fatal("incomplete independent memory role inventory", native, private)
+	}
+}
diff --git a/amd64_fixed_local_integer_compare_objects_test.go b/amd64_fixed_local_integer_compare_objects_test.go
new file mode 100644
index 000000000..7bef3b91b
--- /dev/null
+++ b/amd64_fixed_local_integer_compare_objects_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoAMD64FixedLocalIntegerCompareCompleteObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	rows := fixedLocalIntegerCompareCases()
+	if len(rows) != 168 {
+		t.Fatal("complete comparison object inventory changed", len(rows))
+	}
+	var assembly, declarations strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalIntegerCompareSource(row), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64, a uint64) uint64\n", name)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t,
+				assembly.String(), declarations.String(), target.name, target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("complete fixed-frame integer comparisons failed translation", err)
+					}
+					optimized := fixedLocalIntegerCompareConstantResults(t, ir, pkg.Path, rows)
+					compileLLVMToObject(t, llc, target.triple, "compare.ll", "compare.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "compare-opt.ll", "compare-opt.o", optimized)
+				})
+		})
+	}
+}
+
+// Parse and optimize each complete module once. Check the actual return value
+// of every self relation, including unknown inputs, rather than IR substrings.
+func fixedLocalIntegerCompareConstantResults(t *testing.T, ir, path string, rows []fixedLocalIntegerCompareCase) string {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for index := range rows {
+		function := module.NamedFunction(fmt.Sprintf("%s.Value%d", path, index))
+		if function.IsNil() || function.FirstBasicBlock().IsNil() {
+			t.Fatal("complete source omitted original function", index)
+		}
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	checked := 0
+	for index, row := range rows {
+		if !row.self {
+			continue
+		}
+		checked++
+		want := ^uint64(0)
+		if strings.Contains(row.operation, "PCMPGT") {
+			want = 0
+		}
+		function := module.NamedFunction(fmt.Sprintf("%s.Value%d", path, index))
+		returns := 0
+		for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+			for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+				if instruction.IsAReturnInst().IsNil() {
+					continue
+				}
+				returns++
+				if instruction.OperandsCount() != 1 || instruction.Operand(0).IsAConstantInt().IsNil() ||
+					instruction.Operand(0).ZExtValue() != want {
+					t.Fatalf("self relation %s did not return %016x: %s", row.name, want, function.String())
+				}
+			}
+		}
+		if returns != 1 {
+			t.Fatal("self relation lost its sole return", row.name, returns)
+		}
+	}
+	if checked != 48 {
+		t.Fatal("self-comparison constant inventory changed", checked)
+	}
+	return module.String()
+}
diff --git a/amd64_fixed_local_integer_compare_runtime_linux_amd64_test.go b/amd64_fixed_local_integer_compare_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..44323a5d9
--- /dev/null
+++ b/amd64_fixed_local_integer_compare_runtime_linux_amd64_test.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalIntegerCompare(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, fixedLocalIntegerCompareRuntimeKernels(t))
+}
diff --git a/amd64_fixed_local_integer_compare_runtime_test.go b/amd64_fixed_local_integer_compare_runtime_test.go
new file mode 100644
index 000000000..8b3d1e84b
--- /dev/null
+++ b/amd64_fixed_local_integer_compare_runtime_test.go
@@ -0,0 +1,46 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func fixedLocalIntegerCompareRuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	var kernels []fixedLocalVEXRuntimeKernel
+	owners := make(map[string]int)
+	rows := fixedLocalIntegerCompareCases()
+	for _, row := range rows {
+		parts := strings.Split(row.name, "/")
+		shape := parts[0] + "/" + parts[1]
+		index, exists := owners[shape]
+		if !exists {
+			index, owners[shape] = len(kernels), len(kernels)
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: shape})
+		}
+		// Observe defined CMP FLAGS after each comparison, including AF via
+		// LAHF, in scratch bytes outside all comparison input ranges.
+		operation := "MOVQ (SI),AX\nCMPQ AX,$1\n" + row.operation +
+			"\nLAHF\nMOVB AH,120(BP)\nSETOS 121(BP)"
+		if strings.Contains(row.name, "unknown self") {
+			// The common oracle observes Y0..Y3. Expose each high-bank result
+			// without reading undefined legacy upper bytes; VEX defines them.
+			if row.legacy {
+				operation += "\nMOVOU " + row.destination + ",X2"
+			} else {
+				operation += "\nVMOVDQU " + strings.Replace(row.destination, "X", "Y", 1) + ",Y2"
+			}
+		}
+		kernels[index].operations = append(kernels[index].operations, operation)
+	}
+	if len(kernels) != 24 || len(rows) != 168 {
+		t.Fatal("comparison runtime family/width/operand inventory changed", len(kernels), len(rows))
+	}
+	return kernels
+}
+
+func TestGoAMD64FixedLocalIntegerCompareRuntimeObjects(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, fixedLocalIntegerCompareRuntimeKernels(t))
+}
diff --git a/amd64_fixed_local_integer_compare_test.go b/amd64_fixed_local_integer_compare_test.go
new file mode 100644
index 000000000..2a4e696d6
--- /dev/null
+++ b/amd64_fixed_local_integer_compare_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalIntegerCompareCase struct {
+	name, operation, destination string
+	width                        int
+	legacy, self                 bool
+}
+
+func fixedLocalIntegerCompareCases() []fixedLocalIntegerCompareCase {
+	var rows []fixedLocalIntegerCompareCase
+	for index, name := range x86PackedIntegerCompareTestNames {
+		legacy := index < 8
+		banks := []string{"X", "Y"}
+		if legacy {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			width := 16
+			if bank == "Y" {
+				width = 32
+			}
+			add := func(label, operands, destination string, self bool) {
+				rows = append(rows, fixedLocalIntegerCompareCase{
+					name + "/" + bank + "/" + label, name + " " + operands,
+					destination, width, legacy, self,
+				})
+			}
+			if legacy {
+				add("register", "X1,X0", "X0", false)
+				add("alias", "X0,X0", "X0", true)
+				add("private", "64(BP),X0", "X0", false)
+				add("native", "(SI),X0", "X0", false)
+				add("unknown self", "X15,X15", "X15", true)
+				continue
+			}
+			for _, destination := range []string{bank + "2", bank + "0", bank + "1"} {
+				add("register "+destination, bank+"0,"+bank+"1,"+destination, destination, false)
+			}
+			for _, memory := range []string{"64(BP)", "65(BP)", "(SI)"} {
+				add("memory "+memory, memory+","+bank+"1,"+bank+"2", bank+"2", false)
+			}
+			for _, destination := range []string{bank + "6", bank + "15"} {
+				add("unknown self "+destination, bank+"15,"+bank+"15,"+destination, destination, true)
+			}
+		}
+	}
+	return rows
+}
+
+func fixedLocalIntegerCompareSource(row fixedLocalIntegerCompareCase) string {
+	// Keep the complete original aligned scratch function. Store the compared
+	// low qword into its actual result slot, so the comparison is observable.
+	low := strings.Replace(row.destination, "Y", "X", 1)
+	return fixedLocalVEXAssembly(row.operation + "\nMOVQ " + low + ",AX\nMOVQ AX,128(BP)")
+}
+
+func TestGoAMD64FixedLocalIntegerCompareCompleteSources(t *testing.T) {
+	rows := fixedLocalIntegerCompareCases()
+	if len(rows) != 168 {
+		t.Fatal("fixed-frame source inventory changed", len(rows))
+	}
+	var original strings.Builder
+	for index, row := range rows {
+		source := fixedLocalIntegerCompareSource(row)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *uint64, a uint64) uint64", "RET")
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+				t.Fatal("complete integer-comparison source rejected", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalIntegerCompareAliasesAndFlags(t *testing.T) {
+	for index, name := range x86PackedIntegerCompareTestNames {
+		legacy := index < 8
+		for _, width := range []int{16, 32} {
+			if legacy && width != 16 {
+				continue
+			}
+			bank := "X"
+			if width == 32 {
+				bank = "Y"
+			}
+			for _, self := range []bool{false, true} {
+				for _, upper := range []uint64{0, 1 << 50, 0xffffffffffff0000} {
+					t.Run(fmt.Sprintf("%s/%s/self=%v/upper=%x", name, bank, self, upper), func(t *testing.T) {
+						operands := bank + "1," + bank + "0"
+						if self {
+							operands = bank + "0," + bank + "0"
+						}
+						if !legacy {
+							operands += "," + bank + "0"
+						}
+						ins := x86ScalarLaneInstruction(t, name+" "+operands)
+						state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": upper, "Z1": 0}, flags: x86ByteFlagsAll}
+						mask := x86CallerVectorByteMask(int64(width))
+						if !self {
+							state.vectors["Z0"] |= mask
+							state.vectors["Z1"] = mask
+						}
+						if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+							t.Fatal("shared compare effect was not consumed", err)
+						}
+						want := ^uint64(0)
+						if legacy {
+							want = upper | mask
+						}
+						if state.vectors["Z0"] != want || state.flags != x86ByteFlagsAll {
+							t.Fatal("comparison changed upper aliases or architectural FLAGS", state)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalIntegerCompareConsumerBoundaries(t *testing.T) {
+	for index, name := range x86PackedIntegerCompareTestNames {
+		legacy := index < 8
+		banks := []string{"X", "Y"}
+		if legacy {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			operands := "64(BP)," + bank + "1"
+			if !legacy {
+				operands += "," + bank + "2"
+			}
+			_, sig, source := fixedLocalVEXFixture(t, name+" "+operands)
+			changes := []struct{ name, from, to string }{
+				{"missing byte", "MOVQ AX,64(BP)", "MOVB AX,64(BP)"},
+				{"private pointer", "MOVQ AX,64(BP)", "MOVQ SP,64(BP)"},
+				{"missing second input", "VMOVDQU 64(BP),Y1", "NOP"},
+				{"outside frame", name + " 64(BP)", name + " 512(BP)"},
+			}
+			if legacy {
+				changes = append(changes, struct{ name, from, to string }{"unaligned legacy", name + " 64(BP)", name + " 65(BP)"})
+			}
+			for _, change := range changes {
+				t.Run(name+"/"+bank+"/"+change.name, func(t *testing.T) {
+					changed := strings.Replace(source, change.from, change.to, 1)
+					if changed == source {
+						t.Fatal("complete-source mutation did not change its intended input")
+					}
+					file, err := Parse(ArchAMD64, changed)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("compare supplied missing private storage or input authority", err)
+					}
+				})
+			}
+		}
+	}
+	// These valid ISA forms have separate MMX or EVEX mask-result consumers.
+	// Descriptor metadata must not silently grant fixed-frame vector storage.
+	var separate []string
+	for index, name := range x86PackedIntegerCompareTestNames {
+		if index < 8 {
+			if index%4 != 3 {
+				separate = append(separate, name+" M0,M1")
+			}
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			separate = append(separate, name+" "+bank+"0,"+bank+"1,K0", name+" "+bank+"0,"+bank+"1,K1,K2")
+		}
+	}
+	for _, name := range x86ImmediateCompareResultMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			separate = append(separate, name+" $255,"+bank+"0,"+bank+"1,K0", name+" $7,"+bank+"0,"+bank+"1,K1,K2")
+		}
+	}
+	for _, operation := range separate {
+		t.Run(operation, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, operation)
+			effect, known, err := x86TypedPackedIntegerCompareByteEffect(ins.Op, ins, "amd64")
+			if !known || err != nil || effect.vector != (x86TypedVectorEffect{}) {
+				t.Fatal("separate valid ISA form changed grammar or gained vector storage", err, effect)
+			}
+			if _, known, err := fixedLocalVectorByteEffect(ins); known && err == nil {
+				t.Fatal("MMX or EVEX mask result acquired this fixed-frame vector consumer")
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_layout.go b/amd64_fixed_local_layout.go
new file mode 100644
index 000000000..0cbd68662
--- /dev/null
+++ b/amd64_fixed_local_layout.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import "reflect"
+
+// Nodes are source CFG boundaries with distinct private layouts. Edge order is
+// the source CFG order; -1 is infeasible and -2 is an ordinary final return.
+type x86FixedLocalLayoutNode struct {
+	pc, end int
+	targets [2]int
+}
+
+type x86FixedLocalLayoutGraph struct {
+	nodes    []x86FixedLocalLayoutNode
+	retained int64 // First-phase graph and new layout series during final replay.
+	series   int64 // Newly allocated layout series in the previous residue.
+}
+
+type x86FixedLocalLayouts struct {
+	reference []x86FixedLocalLayoutNode
+	nodes     []x86FixedLocalLayoutNode
+	at        map[int][]int
+}
+
+func newFixedLocalLayouts(reference []x86FixedLocalLayoutNode) x86FixedLocalLayouts {
+	count := len(reference)
+	if count == 0 {
+		count = 1
+	}
+	result := x86FixedLocalLayouts{reference: reference, nodes: make([]x86FixedLocalLayoutNode, count), at: map[int][]int{0: {0}}}
+	for index := range result.nodes {
+		result.nodes[index].targets = [2]int{-1, -1}
+		if len(reference) != 0 {
+			result.nodes[index].pc = reference[index].pc
+			if index != 0 {
+				pc := reference[index].pc
+				result.at[pc] = append(result.at[pc], index)
+			}
+		}
+	}
+	return result
+}
+
+func (layouts *x86FixedLocalLayouts) target(states map[int]x86FixedLocalState, from, edge, pc int, next x86FixedLocalState,
+	budget *x86FixedLocalBudget) (int, error) {
+	match := -1
+	for _, index := range layouts.at[pc] {
+		prior, found := states[index]
+		if err := budget.consumeOrigins(64 + 2*fixedLocalStateWork(prior) + fixedLocalStateWork(next)); err != nil {
+			return 0, err
+		}
+		if !found {
+			continue
+		}
+		if err := fixedLocalLayoutRoles(prior, next); err != nil {
+			return 0, err
+		}
+		if reflect.DeepEqual(prior.pointers, next.pointers) && reflect.DeepEqual(prior.addresses, next.addresses) {
+			match = index
+		}
+	}
+	if len(layouts.reference) != 0 {
+		match = layouts.reference[from].targets[edge]
+		if match < 0 || match >= len(layouts.nodes) || layouts.nodes[match].pc != pc {
+			return 0, goAMD64FrameContext("fixed local layout edge depends on original SP residue")
+		}
+	} else if match < 0 {
+		match = len(layouts.nodes)
+		layouts.nodes = append(layouts.nodes, x86FixedLocalLayoutNode{pc: pc, targets: [2]int{-1, -1}})
+	}
+	if _, found := states[match]; !found && len(layouts.reference) == 0 {
+		layouts.at[pc] = append(layouts.at[pc], match)
+	}
+	layouts.nodes[from].targets[edge] = match
+	return match, nil
+}
+
+func fixedLocalLayoutRoles(first, last x86FixedLocalState) error {
+	if len(first.pointers) != len(last.pointers) || len(first.addresses) != len(last.addresses) || first.pointers[SP] != last.pointers[SP] {
+		return goAMD64FrameContext("fixed local CFG private roles disagree")
+	}
+	for reg := range first.pointers {
+		if _, found := last.pointers[reg]; !found {
+			return goAMD64FrameContext("fixed local CFG private roles disagree")
+		}
+	}
+	for offset := range first.addresses {
+		if _, found := last.addresses[offset]; !found {
+			return goAMD64FrameContext("fixed local CFG private spill roles disagree")
+		}
+	}
+	_, err := mergeFixedLocalSavedBP(&first, last)
+	return err
+}
+
+func (layouts *x86FixedLocalLayouts) finish() error {
+	seen, work := map[int]bool{0: true}, []int{0}
+	for head := 0; head < len(work); head++ {
+		for _, target := range layouts.nodes[work[head]].targets {
+			if target >= 0 && !seen[target] {
+				seen[target] = true
+				work = append(work, target)
+			}
+		}
+	}
+	if len(seen) != len(layouts.nodes) || len(layouts.reference) != 0 && !reflect.DeepEqual(layouts.reference, layouts.nodes) {
+		return goAMD64FrameContext("fixed local final layout graph has new, missing or provisional edges")
+	}
+	return nil
+}
+
+// These are bounded logical payload charges, not an estimate of Go heap RSS.
+// The node charge includes current/reference arrays with spare capacity, source
+// indexes and the observation index. A completed first phase is reserved apart.
+// Map bucket/allocator overhead remains outside this logical payload bound.
+const fixedLocalLayoutNodeBytes int64 = 192
+
+func fixedLocalLayoutAccessBytes(accesses map[int]x86FixedLocalAccess) int64 {
+	bytes := int64(len(accesses)) * 192
+	for _, access := range accesses {
+		bytes += int64(cap(access.iterationOffsets)) * 64
+	}
+	return bytes
+}
+
+func fixedLocalAccessShapeEqual(first, last x86FixedLocalAccess) bool {
+	return first.owner == last.owner && first.shape == last.shape && first.width == last.width &&
+		first.write == last.write && first.nativeInput == last.nativeInput && first.ordinal == last.ordinal
+}
+
+func collectFixedLocalLayoutAccesses(nodes int, observations map[int]map[int]map[int]x86FixedLocalAccess,
+	available int64) (map[int]map[int]x86FixedLocalAccess, int64, error) {
+	result := make(map[int]map[int]x86FixedLocalAccess)
+	groups := make(map[int][]map[int]x86FixedLocalAccess)
+	for node := 0; node < nodes; node++ {
+		for pc, current := range observations[node] {
+			if first, found := result[pc]; found {
+				if len(groups[pc]) == 0 {
+					groups[pc] = append(groups[pc], first)
+				}
+				groups[pc] = append(groups[pc], current)
+			} else {
+				result[pc] = current
+			}
+		}
+	}
+	available -= int64(len(result)) * 16 // Temporary source-PC index, not old certificates.
+	for _, group := range groups {
+		available -= 40 + int64(cap(group))*8
+	}
+	var allocated int64
+	for pc, group := range groups {
+		for operand, first := range result[pc] {
+			count := 0
+			for _, current := range group {
+				access, found := current[operand]
+				if len(current) != len(result[pc]) || !found || !fixedLocalAccessShapeEqual(first, access) {
+					return nil, 0, goAMD64FrameContext("fixed local layout access role changed")
+				}
+				count += len(access.iterationOffsets)
+				if len(access.iterationOffsets) == 0 {
+					count++
+				}
+			}
+			allocated += int64(count) * 64
+			if allocated > available {
+				return nil, 0, goAMD64FrameContext("fixed local retained state storage budget exceeded")
+			}
+			offsets := make([][8]int64, 0, count)
+			for _, current := range group {
+				access := current[operand]
+				if len(access.iterationOffsets) == 0 {
+					offsets = append(offsets, access.offset)
+				} else {
+					offsets = append(offsets, access.iterationOffsets...)
+				}
+			}
+			first.iterationOffsets = offsets
+			result[pc][operand] = first
+		}
+	}
+	if allocated > available {
+		return nil, 0, goAMD64FrameContext("fixed local retained state storage budget exceeded")
+	}
+	return result, allocated, nil
+}
diff --git a/amd64_fixed_local_layout_boundary_test.go b/amd64_fixed_local_layout_boundary_test.go
new file mode 100644
index 000000000..57ee20822
--- /dev/null
+++ b/amd64_fixed_local_layout_boundary_test.go
@@ -0,0 +1,19 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalOrdinaryRetainedBoundary(t *testing.T) {
+	var body strings.Builder
+	for index := 0; index < 15; index++ {
+		fmt.Fprintf(&body, "JMP next%d\nnext%d:\n", index, index)
+	}
+	fn, sig := fixedLocalReplayFixture(t, body.String())
+	fn.FrameSize = 64 << 10
+	if _, err := proveX86FixedLocal(fn, sig); err != nil {
+		t.Fatal("sixteen ordinary states must retain the original one-MiB allowance", err)
+	}
+}
diff --git a/amd64_fixed_local_layout_join_test.go b/amd64_fixed_local_layout_join_test.go
new file mode 100644
index 000000000..8de42b091
--- /dev/null
+++ b/amd64_fixed_local_layout_join_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const fixedLocalLayoutPingPong = `
+LEAQ 16(SP),R14
+LEAQ 24(SP),R15
+MOVQ $1,(R14)
+loop:
+CMPQ CX,$0
+JEQ done
+MOVQ (R14),AX
+ADDQ $1,AX
+MOVQ AX,(R15)
+XCHGQ R14,R15
+SUBQ $1,CX
+JMP loop
+done:
+MOVQ (R14),AX
+MOVQ AX,ret+16(FP)
+RET
+`
+
+const fixedLocalLayoutDeadReturn = `
+MOVQ $7,ret+16(FP)
+CMPQ CX,$0
+JEQ done
+LEAQ 16(SP),AX
+done:
+RET
+`
+
+func fixedLocalTerminalReturnBodies() []string {
+	return []string{fixedLocalLayoutDeadReturn, strings.Replace(fixedLocalLayoutDeadReturn,
+		"LEAQ 16(SP),AX", "LEAQ 24(SP),AX\nMOVQ AX,16(SP)", 1)}
+}
+
+func TestGoAMD64FixedLocalTerminalJoinPrograms(t *testing.T) {
+	rows := []struct {
+		name, body string
+		accept     bool
+	}{
+		{"dead private register at return", fixedLocalTerminalReturnBodies()[0], true},
+		{"dead private spill at return", fixedLocalTerminalReturnBodies()[1], true},
+		{"undefined joined register is used", strings.Replace(fixedLocalLayoutDeadReturn,
+			"done:\nRET", "done:\nMOVQ (AX),BX\nRET", 1), false},
+		{"result is missing", strings.Replace(fixedLocalLayoutDeadReturn,
+			"MOVQ $7,ret+16(FP)\n", "", 1), false},
+		{"only one predecessor writes the result", `
+CMPQ CX,$0
+JEQ missing
+MOVQ $7,ret+16(FP)
+JMP done
+missing:
+NOP
+done:
+RET
+`, false},
+		{"private SP is not restored", strings.Replace(fixedLocalLayoutDeadReturn,
+			"LEAQ 16(SP),AX", "LEAQ 8(SP),AX\nMOVQ AX,SP", 1), false},
+		{"private and native roles conflict", `
+CMPQ CX,$0
+JEQ native
+LEAQ 16(SP),AX
+MOVQ $1,(AX)
+JMP joined
+native:
+MOVQ p+0(FP),AX
+joined:
+MOVQ (AX),BX
+MOVQ BX,ret+16(FP)
+RET
+`, false},
+		{"initial buffer is undefined", strings.Replace(fixedLocalLayoutPingPong,
+			"MOVQ $1,(R14)\n", "", 1), false},
+		{"next buffer is not written", strings.Replace(fixedLocalLayoutPingPong,
+			"MOVQ AX,(R15)\n", "", 1), false},
+	}
+	functions := make([]Func, len(rows))
+	signatures := make([]FuncSig, len(rows))
+	var original strings.Builder
+	for index, row := range rows {
+		_, _, sig, source := x86ResultInitializationFixture(t, "amd64",
+			"func Value(p *uint64, n uint64) uint64", "MOVQ n+8(FP),CX\n"+row.body)
+		source = strings.Replace(source, "$0-24", "$64-24", 1)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil || len(file.Funcs) != 1 || file.Funcs[0].FrameSize != 64 {
+			t.Fatal("complete source fixture has no expected private frame", err)
+		}
+		functions[index], signatures[index] = file.Funcs[0], sig
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	// All complete source functions must assemble before their distinct
+	// translation outcomes are checked. Source legality is not a memory proof.
+	goAssemblerOracleOutput(t, "amd64", original.String(), "", true)
+	for index, row := range rows {
+		t.Run(row.name, func(t *testing.T) {
+			_, err := proveX86FixedLocal(functions[index], signatures[index])
+			if row.accept && err != nil {
+				t.Fatal("complete initialized source lost a valid private layout", err)
+			}
+			if !row.accept && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved source gained a private frame", err)
+			}
+		})
+	}
+}
+
+func fixedLocalTerminalReturnProgram() (assembly, declarations string) {
+	var asm, decl strings.Builder
+	for index, body := range fixedLocalTerminalReturnBodies() {
+		body = strings.ReplaceAll(body, "ret+16(FP)", "ret+8(FP)")
+		fmt.Fprintf(&asm, "TEXT ·Value%d(SB),4,$64-16\nMOVQ a+0(FP),CX\n%s", index, body)
+		fmt.Fprintf(&decl, "func Value%d(a uint64) uint64\n", index)
+	}
+	return asm.String(), decl.String()
+}
+
+func TestGoAMD64FixedLocalTerminalJoinObjects(t *testing.T) {
+	assembly, declarations := fixedLocalTerminalReturnProgram()
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, 2)
+}
diff --git a/amd64_fixed_local_layout_partition_test.go b/amd64_fixed_local_layout_partition_test.go
new file mode 100644
index 000000000..16dfe98e2
--- /dev/null
+++ b/amd64_fixed_local_layout_partition_test.go
@@ -0,0 +1,251 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func fixedLocalLayoutPartitionBodies() []string {
+	three := strings.Replace(fixedLocalLayoutPingPong,
+		"MOVQ $1,(R14)", "LEAQ 32(SP),R13\nMOVQ R14,R12\nMOVQ $1,(R14)", 1)
+	three = strings.Replace(three, "XCHGQ R14,R15",
+		"MOVQ R14,R12\nMOVQ R15,R14\nMOVQ R13,R15\nMOVQ R12,R13", 1)
+	spill := strings.Replace(fixedLocalLayoutPingPong, "MOVQ $1,(R14)",
+		"MOVQ R14,32(SP)\nMOVQ R15,40(SP)\nMOVQ $1,(R14)", 1)
+	spill = strings.Replace(spill, "loop:\n", "loop:\nMOVQ 32(SP),R14\nMOVQ 40(SP),R15\n", 1)
+	spill = strings.Replace(spill, "XCHGQ R14,R15",
+		"MOVQ R15,32(SP)\nMOVQ R14,40(SP)", 1)
+	return []string{fixedLocalLayoutPingPong, three, spill}
+}
+
+func fixedLocalLayoutPartitionProgram() (assembly, declarations string) {
+	var asm, decl strings.Builder
+	for index, body := range fixedLocalLayoutPartitionBodies() {
+		body = strings.ReplaceAll(body, "ret+16(FP)", "ret+8(FP)")
+		fmt.Fprintf(&asm, "TEXT ·Value%d(SB),4,$64-16\nMOVQ a+0(FP),CX\n%s", index, body)
+		fmt.Fprintf(&decl, "func Value%d(a uint64) uint64\n", index)
+	}
+	return asm.String(), decl.String()
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionPrograms(t *testing.T) {
+	assembly, _ := fixedLocalLayoutPartitionProgram()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil || len(file.Funcs) != 3 {
+		t.Fatal("complete private-layout source inventory changed", err)
+	}
+	_, sig := fixedLocalReplayFixture(t, "")
+	for index, fn := range file.Funcs {
+		t.Run(fmt.Sprint(index), func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("current initialized buffer lost its matching private layout", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionObjects(t *testing.T) {
+	assembly, declarations := fixedLocalLayoutPartitionProgram()
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, 3)
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionResidueAliases(t *testing.T) {
+	body := strings.Replace(fixedLocalLayoutPingPong, "LEAQ 16(SP),R14",
+		"MOVQ $77,16(SP)\nLEAQ 16(SP),R14\nANDQ $-16,R14", 1)
+	body = strings.Replace(body, "MOVQ AX,ret+16(FP)",
+		"ADDQ 16(SP),AX\nMOVQ AX,ret+16(FP)", 1)
+	_, _, sig, source := x86ResultInitializationFixture(t, "amd64",
+		"func Value(p *uint64, n uint64) uint64", "MOVQ n+8(FP),CX\n"+body)
+	source = strings.Replace(source, "$0-24", "$64-24", 1)
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "byte identity depends") {
+		t.Fatal("layout alternatives lost the canary's residue-dependent alias", err)
+	}
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionStorageBound(t *testing.T) {
+	var body strings.Builder
+	for index := 0; index < 8; index++ {
+		fmt.Fprintf(&body, "LEAQ %d(SP),R%d\n", index*8, index+8)
+	}
+	body.WriteString("loop:\nTESTQ $1,AX\nJZ rotate\nXCHGQ R8,R9\nJMP count\nrotate:\n")
+	for index := 8; index < 15; index++ {
+		fmt.Fprintf(&body, "XCHGQ R%d,R%d\n", index, index+1)
+	}
+	body.WriteString("count:\nSUBQ $1,AX\nJNZ loop\n")
+	for _, frame := range []int64{64, 32 << 10} {
+		t.Run(fmt.Sprint(frame), func(t *testing.T) {
+			fn, sig := fixedLocalReplayFixture(t, body.String())
+			fn.FrameSize = frame
+			proof := &x86FixedLocalProof{frame: frame}
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			var layouts x86FixedLocalLayoutGraph
+			err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, &layouts)
+			t.Logf("frame=%d remaining_steps=%d remaining_bytes=%d error=%v", frame, budget.steps, budget.bytes, err)
+			failure := "state storage budget"
+			if frame == 64 {
+				// The original small-frame stress now pays for its candidate
+				// comparisons first. Larger frames isolate the retained cap.
+				failure = "state byte bound"
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), failure) {
+				t.Fatal("independent work/retained layout limit was not enforced", err)
+			}
+			if budget.steps <= 0 || budget.bytes <= 0 {
+				t.Fatal("layout bounds must reject before instruction/work counters underflow")
+			}
+			for _, ins := range fn.Instrs {
+				if len(ins.x86FixedLocalMemory) != 0 {
+					t.Fatal("layout storage failure published provisional accesses")
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionFrozenEdges(t *testing.T) {
+	assembly, _ := fixedLocalLayoutPartitionProgram()
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, sig := fixedLocalReplayFixture(t, "")
+	fn := file.Funcs[0]
+	proof := &x86FixedLocalProof{frame: fn.FrameSize}
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	var layouts x86FixedLocalLayoutGraph
+	if err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, &layouts); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"missing edge", "different block", "extra node", "other layout"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := layouts
+			changed.nodes = append([]x86FixedLocalLayoutNode(nil), layouts.nodes...)
+			switch mutation {
+			case "missing edge":
+				changed.nodes[0].targets = [2]int{-1, -1}
+			case "different block":
+				changed.nodes[0].end++
+			case "extra node":
+				changed.nodes = append(changed.nodes, x86FixedLocalLayoutNode{targets: [2]int{-1, -1}})
+			case "other layout":
+				changedEdge := false
+				for index, node := range changed.nodes {
+					for edge, target := range node.targets {
+						for other, candidate := range changed.nodes {
+							if !changedEdge && target >= 0 && target != other && candidate.pc == changed.nodes[target].pc {
+								changed.nodes[index].targets[edge], changedEdge = other, true
+							}
+						}
+					}
+				}
+				if !changedEdge {
+					t.Fatal("fixture has no separate private layouts at the same source PC")
+				}
+			}
+			before := append([]Instr(nil), fn.Instrs...)
+			for index := range before {
+				before[index].x86FixedLocalMemory = cloneX86ReplayFixedLocalMemory(before[index].x86FixedLocalMemory)
+			}
+			current := fn
+			current.Instrs = append([]Instr(nil), fn.Instrs...)
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			err := replayX86FixedLocal(&current, sig, proof, 1, &budget, nil, &changed)
+			if mutation == "other layout" {
+				if err != nil {
+					t.Fatal("one residue can establish the relabeled cycle locally", err)
+				}
+				// Relabeling a cycle is locally consistent. Its complete byte
+				// correspondence and independent final graph are the consumers
+				// that must reject a different layout relative to the prefix.
+				for residue := 2; residue < 8; residue++ {
+					if err := replayX86FixedLocal(&current, sig, proof, residue, &budget, nil, &changed); err != nil {
+						t.Fatal("complete-residue replay", err)
+					}
+				}
+				accesses := make(map[int]map[int]x86FixedLocalAccess)
+				anchors, mismatches := 0, 0
+				for index, instruction := range current.Instrs {
+					if len(instruction.x86FixedLocalMemory) != 0 {
+						accesses[index] = instruction.x86FixedLocalMemory
+						for _, access := range instruction.x86FixedLocalMemory {
+							if instruction.Raw == "MOVQ $1,(R14)" && access.offset[0] == 16 && access.offset[1] == 16 {
+								anchors++
+							}
+							if instruction.Raw == "MOVQ (R14),AX" && len(access.iterationOffsets) == 2 &&
+								access.iterationOffsets[0][0] == 16 && access.iterationOffsets[0][1] == 24 {
+								mismatches++
+							}
+						}
+					}
+				}
+				if anchors != 1 || mismatches != 2 || current.x86FixedLocal != nil {
+					t.Fatal("fixture lost its 16-to-16 prefix versus 16-to-24 reads, or published an unfinished proof")
+				}
+				if err := fixedLocalRelocationAliases(accesses); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("one original byte acquired two relocated identities", err)
+				}
+				freshFile, parseErr := Parse(ArchAMD64, assembly)
+				if parseErr != nil {
+					t.Fatal(parseErr)
+				}
+				fresh := freshFile.Funcs[0]
+				if _, err := proveX86FixedLocal(fresh, sig); err != nil {
+					t.Fatal("the unchanged complete source must still succeed", err)
+				}
+				freshProof := &x86FixedLocalProof{frame: fresh.FrameSize}
+				freshBudget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+				var freshGraph x86FixedLocalLayoutGraph
+				for residue := 0; residue < 8; residue++ {
+					if err := replayX86FixedLocal(&fresh, sig, freshProof, residue, &freshBudget, nil, &freshGraph); err != nil {
+						t.Fatal("independent final graph rebuild", err)
+					}
+				}
+				if !reflect.DeepEqual(freshGraph.nodes, layouts.nodes) || reflect.DeepEqual(freshGraph.nodes, changed.nodes) {
+					t.Fatal("independent final replay accepted the changed prefix/layout correspondence")
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a different residue acquired changed layout correspondence", err)
+			}
+			if !reflect.DeepEqual(before, current.Instrs) {
+				t.Fatal("failed layout replay published a provisional observation")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalLayoutPartitionLateResidue(t *testing.T) {
+	fn, sig := fixedLocalReplayFixture(t, `LEAQ 16(SP),BX
+CMPQ AX,$0
+JEQ unchanged
+ANDQ $-16,BX
+unchanged:
+MOVQ AX,(BX)`)
+	original := fn
+	original.Instrs = append([]Instr(nil), fn.Instrs...)
+	proof := &x86FixedLocalProof{frame: fn.FrameSize}
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	if err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, nil); err != nil {
+		t.Fatal("residue zero has a single private layout", err)
+	}
+	if err := replayX86FixedLocal(&fn, sig, proof, 1, &budget, nil, nil); !errors.Is(err, errFixedLocalLayoutJoin) {
+		t.Fatal("a later residue must expose the distinct private layouts", err)
+	}
+	// A fresh partition attempt still cannot match this source's differing
+	// residue graphs. It must not mix earlier flat and later partition records.
+	got, err := proveX86FixedLocal(original, sig)
+	if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(got, original) {
+		t.Fatal("late partition failure published an incomplete source proof", err)
+	}
+}
diff --git a/amd64_fixed_local_logical_literal_go127_test.go b/amd64_fixed_local_logical_literal_go127_test.go
new file mode 100644
index 000000000..322eb3609
--- /dev/null
+++ b/amd64_fixed_local_logical_literal_go127_test.go
@@ -0,0 +1,150 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func fixedLocalLogicalLiteralRequireBinding(t *testing.T, assembly string) {
+	t.Helper()
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+		"func Value(input, output *byte)\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+	// A real successful original-Go observation precedes the translator
+	// assertion. Assembler/tool failures cannot stand in for this RED.
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	if _, err := source.BindFixedLocal(ctx, pkg, file, options); err != nil {
+		t.Fatal("complete original source lost constant-mask byte dependencies", err)
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralPartialInsert(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	fixedLocalLogicalLiteralRequireBinding(t,
+		fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PAND", 0, 16, false}, false))
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralCompleteFormats(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	rows := fixedLocalLogicalLiteralCases()
+	if len(rows) != 36 {
+		t.Fatal("independent logical family/legacy-X/VEX-X-Y inventory changed", len(rows))
+	}
+	for _, row := range rows {
+		t.Run(fmt.Sprintf("%s/%d", row.opcode, row.width), func(t *testing.T) {
+			fixedLocalLogicalLiteralRequireBinding(t, fixedLocalLogicalLiteralSource(row, false))
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralNoRegisterRead(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	count := 0
+	for _, row := range fixedLocalLogicalLiteralCases() {
+		// Select the integer spelling once per operation and vector width.
+		name := strings.TrimPrefix(row.opcode, "V")
+		if name != "PAND" && name != "PANDN" && name != "POR" {
+			continue
+		}
+		count++
+		t.Run(fmt.Sprintf("%s/%d", row.opcode, row.width), func(t *testing.T) {
+			fixedLocalLogicalLiteralRequireBinding(t, fixedLocalLogicalLiteralSource(row, true))
+		})
+	}
+	if count != 9 {
+		t.Fatal("complete constant annihilator inventory changed", count)
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralAccessGuards(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	and := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PAND", 0, 16, false}, false)
+	andNot := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PANDN", 1, 16, false}, false)
+	or := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"POR", 2, 16, false}, false)
+	xor := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PXOR", 3, 16, false}, false)
+	zero := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PAND", 0, 16, false}, true)
+	for _, row := range []struct{ name, source string }{
+		{"AND retains one unknown bit", strings.Replace(and, "/8,$0x0\n", "/8,$0x1\n", 1)},
+		{"ANDNOT retains one unknown bit", strings.Replace(andNot, "/8,$0x0\n", "/8,$0x1\n", 1)},
+		{"OR retains one unknown bit", strings.Replace(or, "$0xffffffffffffffff", "$0xfffffffffffffffe", 1)},
+		{"XOR keeps every input", strings.Replace(xor, "MOVOU (DI),X5", "PINSRD $3,(DI),X5", 1)},
+		{"missing selected lane", strings.Replace(and, "PINSRD $3,(DI),X5\n", "", 1)},
+		{"zero still needs extent", strings.Replace(zero, "PAND mask<>(SB)", "PAND mask<>+1(SB)", 1)},
+		{"zero still needs alignment", strings.Replace(strings.Replace(zero,
+			"GLOBL mask<>(SB),8,$16", "GLOBL mask<>(SB),8,$32", 1), "PAND mask<>(SB)", "PAND mask<>+1(SB)", 1)},
+		{"mutable bytes are not constants", strings.Replace(zero, "GLOBL mask<>(SB),8,", "GLOBL mask<>(SB),0,", 1)},
+		{"native memory supplies no constant", strings.Replace(and, "PAND mask<>(SB)", "PAND (DI)", 1)},
+		{"register value is not tracked constant", strings.Replace(and,
+			"PAND mask<>(SB)", "MOVOU mask<>(SB),X7\nPAND X7", 1)},
+		{"readonly write remains forbidden", strings.Replace(zero,
+			"MOVOU X5,0(SP)", "MOVOU X5,mask<>(SB)\nMOVOU X5,0(SP)", 1)},
+		{"numeric result supplies no pointer", strings.Replace(zero,
+			"MOVOU X5,0(SP)", "MOVQ X5,BX\nMOVQ (BX),AX\nMOVOU X5,0(SP)", 1)},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalTransportFixture(t, row.source,
+				"func Value(input, output *byte)\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			if row.name == "numeric result supplies no pointer" {
+				fixedLocalRequireNumericControl(t, file.Funcs[0], options.Sigs[pkg.Path+".Value"], row.source,
+					"func Value(input,output *byte)", "MOVQ (BX),AX", 0, 8, false, "load volatile i64")
+				return
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("constant mask removed an independent input or storage requirement", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralOwnerLifetime(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly := fixedLocalLogicalLiteralSource(fixedLocalLogicalLiteralCase{"PAND", 0, 16, false}, false)
+	for _, mutation := range []string{"unbound", "public DATA", "original DATA", "closed", "cancelled"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+				"func Value(input, output *byte)\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("valid owner control failed before lifetime mutation", err)
+			}
+			input := assembly
+			switch mutation {
+			case "unbound":
+				bound = options
+			case "public DATA":
+				input = strings.Replace(assembly, "/8,$0x0\n", "/8,$0x1\n", 1)
+				file, err = Parse(ArchAMD64, input)
+				if err != nil {
+					t.Fatal(err)
+				}
+			case "original DATA":
+				path := filepath.Join(request.Directory, request.AssemblyFile)
+				changed := strings.Replace(assembly, "/8,$0x0\n", "/8,$0x1\n", 1)
+				if err := os.WriteFile(path, []byte(changed), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "closed":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "cancelled":
+				cancel()
+			}
+			// Retain the original binding, including its revoked lifetime.
+			fixedLocalDataAPIs(t, pkg, file, input, bound, fixedLocalRequireContext)
+		})
+	}
+}
diff --git a/amd64_fixed_local_logical_literal_objects_go127_test.go b/amd64_fixed_local_logical_literal_objects_go127_test.go
new file mode 100644
index 000000000..b944538f0
--- /dev/null
+++ b/amd64_fixed_local_logical_literal_objects_go127_test.go
@@ -0,0 +1,87 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalLogicalLiteralKernel struct {
+	name       string
+	row        fixedLocalLogicalLiteralCase
+	annihilate bool
+}
+
+func fixedLocalLogicalLiteralKernels(t *testing.T) []fixedLocalLogicalLiteralKernel {
+	t.Helper()
+	var kernels []fixedLocalLogicalLiteralKernel
+	for _, row := range fixedLocalLogicalLiteralCases() {
+		kernels = append(kernels, fixedLocalLogicalLiteralKernel{row: row})
+		name := strings.TrimPrefix(row.opcode, "V")
+		if name == "PAND" || name == "PANDN" || name == "POR" {
+			kernels = append(kernels, fixedLocalLogicalLiteralKernel{row: row, annihilate: true})
+		}
+	}
+	if len(kernels) != 45 {
+		t.Fatal("complete logical literal source denominator changed", len(kernels))
+	}
+	for index := range kernels {
+		kernels[index].name = fmt.Sprintf("Value%d", index)
+	}
+	return kernels
+}
+
+func fixedLocalLogicalLiteralProgram(kernels []fixedLocalLogicalLiteralKernel) (string, string) {
+	var assembly, declarations strings.Builder
+	for _, kernel := range kernels {
+		source := fixedLocalLogicalLiteralSource(kernel.row, kernel.annihilate)
+		source = strings.ReplaceAll(source, "mask<>", kernel.name+"Mask<>")
+		source = strings.Replace(source, "·Value", "·"+kernel.name, 1)
+		assembly.WriteString(source)
+		fmt.Fprintf(&declarations, "func %s(input, output *byte)\n", kernel.name)
+	}
+	return assembly.String(), declarations.String()
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralThreeTargetObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	kernels := fixedLocalLogicalLiteralKernels(t)
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			for start := 0; start < len(kernels); start += 24 {
+				end := start + 24
+				if end > len(kernels) {
+					end = len(kernels)
+				}
+				t.Run(fmt.Sprint(start/24), func(t *testing.T) {
+					assembly, declarations := fixedLocalLogicalLiteralProgram(kernels[start:end])
+					pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+						func(t *testing.T, ir string, err error) {
+							if err != nil {
+								t.Fatal("complete constant-mask logical program did not translate", err)
+							}
+							var names []string
+							for _, kernel := range kernels[start:end] {
+								names = append(names, pkg.Path+"."+kernel.name)
+							}
+							x86CompactExpandRequireAllDefinitions(t, ir, names)
+							compileLLVMToObject(t, llc, target.triple, "logical-literal.ll", "logical-literal.o", ir)
+							compileLLVMToObject(t, llc, target.triple, "logical-literal-opt.ll", "logical-literal-opt.o", x86MulDivRoundOptimize(t, ir))
+						})
+				})
+			}
+		})
+	}
+	t.Log("45 complete kernels: 36 formats and 9 annihilators; 3 targets, 3 independent API owners, O0/O2; no execution claim")
+}
diff --git a/amd64_fixed_local_logical_literal_runtime_go127_test.go b/amd64_fixed_local_logical_literal_runtime_go127_test.go
new file mode 100644
index 000000000..0a898929d
--- /dev/null
+++ b/amd64_fixed_local_logical_literal_runtime_go127_test.go
@@ -0,0 +1,200 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func fixedLocalLogicalLiteralOracles(kernels []fixedLocalLogicalLiteralKernel, triple string) (string, string) {
+	var goRows, declarations, cRows strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for _, kernel := range kernels {
+		annihilate := 0
+		if kernel.annihilate {
+			annihilate = 1
+		}
+		fmt.Fprintf(&goRows, "{%s,%d,%d,%t},\n", kernel.name, kernel.row.width, kernel.row.mode, kernel.annihilate)
+		fmt.Fprintf(&declarations, "extern void %s(const uint8_t *,uint8_t *) __asm__(%q);\n",
+			kernel.name, prefix+"example.invalid/framefixture."+kernel.name)
+		fmt.Fprintf(&cRows, "{%s,%d,%d,%d},\n", kernel.name, kernel.row.width, kernel.row.mode, annihilate)
+	}
+	original := `package framefixture
+
+import "testing"
+
+func TestOriginal(t *testing.T) {
+    rows := []struct {
+        call func(*byte, *byte)
+        width, mode int
+        annihilate bool
+    }{
+` + goRows.String() + `
+    }
+    count := 0
+    for row, test := range rows {
+        for sample := 0; sample < 256; sample++ {
+            for alias := 0; alias < 2; alias++ {
+                var input, output [96]byte
+                for at := range input {
+                    input[at] = byte(at*29 + sample)
+                    output[at] = byte(at*7 + sample + 151)
+                }
+                before := input
+                wantInput, wantOutput := input, output
+                destination := &output[17]
+                if alias != 0 {
+                    destination = &input[17]
+                }
+                for at := 0; at < test.width; at++ {
+                    selected := !test.annihilate && at >= 12 && at < 16
+                    var first, second byte
+                    if selected {
+                        second = before[24+at-12]
+                    }
+                    switch test.mode {
+                    case 0, 1:
+                        if selected { first = 255 }
+                    case 2:
+                        if !selected { first = 255 }
+                    case 3:
+                        first, second = byte(at*13+7), before[24+at]
+                    default:
+                        t.Fatal("unknown operation")
+                    }
+                    var want byte
+                    switch test.mode {
+                    case 0: want = first & second
+                    case 1: want = first & ^second
+                    case 2: want = first | second
+                    case 3: want = first ^ second
+                    }
+                    if alias != 0 {
+                        wantInput[17+at] = want
+                    } else {
+                        wantOutput[17+at] = want
+                    }
+                }
+                test.call(&input[24], destination)
+                if input != wantInput || output != wantOutput {
+                    t.Fatalf("row=%d sample=%d alias=%d input=%x/%x output=%x/%x", row, sample, alias,
+                        input, wantInput, output, wantOutput)
+                }
+                count++
+            }
+        }
+    }
+    if count != len(rows)*256*2 { t.Fatal("incomplete source execution", count) }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static const struct {
+    void (*call)(const uint8_t *, uint8_t *);
+    unsigned width, mode, annihilate;
+} cases[] = {
+` + cRows.String() + `
+};
+
+int main(void) {
+    unsigned count = 0;
+    for (unsigned row = 0; row < sizeof(cases)/sizeof(cases[0]); row++) {
+        for (unsigned sample = 0; sample < 256; sample++) {
+            for (unsigned alias = 0; alias < 2; alias++) {
+                uint8_t input[96], output[96], before[96], want_input[96], want_output[96];
+                for (unsigned at = 0; at < sizeof(input); at++) {
+                    input[at] = (uint8_t)(at*29 + sample);
+                    output[at] = (uint8_t)(at*7 + sample + 151);
+                }
+                memcpy(before, input, sizeof(input));
+                memcpy(want_input, input, sizeof(input));
+                memcpy(want_output, output, sizeof(output));
+                for (unsigned at = 0; at < cases[row].width; at++) {
+                    unsigned selected = !cases[row].annihilate && at >= 12 && at < 16;
+                    uint8_t first = 0, second = selected ? before[24+at-12] : 0, want;
+                    switch (cases[row].mode) {
+                    case 0: case 1: first = selected ? 255 : 0; break;
+                    case 2: first = selected ? 0 : 255; break;
+                    case 3: first = (uint8_t)(at*13+7); second = before[24+at]; break;
+                    default: return 2;
+                    }
+                    switch (cases[row].mode) {
+                    case 0: want = first & second; break;
+                    case 1: want = first & (uint8_t)~second; break;
+                    case 2: want = first | second; break;
+                    case 3: want = first ^ second; break;
+                    default: return 3;
+                    }
+                    if (alias) want_input[17+at] = want;
+                    else want_output[17+at] = want;
+                }
+                cases[row].call(input+24, alias ? input+17 : output+17);
+                if (memcmp(input, want_input, sizeof(input)) || memcmp(output, want_output, sizeof(output))) {
+                    fprintf(stderr, "row=%u sample=%u alias=%u full buffer/canary mismatch\n", row, sample, alias);
+                    return 1;
+                }
+                count++;
+            }
+        }
+    }
+    if (count != sizeof(cases)/sizeof(cases[0])*256*2) return 4;
+    puts("logical literal values and complete canaries PASS");
+    return 0;
+}
+`
+	return original, driver
+}
+
+func fixedLocalLogicalLiteralRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	kernels := fixedLocalLogicalLiteralKernels(t)
+	for start := 0; start < len(kernels); start += 24 {
+		end := start + 24
+		if end > len(kernels) {
+			end = len(kernels)
+		}
+		t.Run(fmt.Sprint(start/24), func(t *testing.T) {
+			assembly, declarations := fixedLocalLogicalLiteralProgram(kernels[start:end])
+			original, driver := fixedLocalLogicalLiteralOracles(kernels[start:end], execution.triple)
+			fixedLocalPackedRunOriginal(t, execution, assembly, declarations, original, execute)
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations,
+				runtime.GOOS+"/amd64", execution.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							input := ir
+							if level == "-O2" {
+								input = x86MulDivRoundOptimize(t, ir)
+							}
+							if !execute {
+								execution.compileLLVM(t, "logical-literal-oracle", input, driver, level)
+								return
+							}
+							output := execution.compileAndRunLLVM(t, "logical-literal-oracle", input, driver, level)
+							if strings.TrimSpace(string(output)) != "logical literal values and complete canaries PASS" {
+								t.Fatal("incomplete original byte oracle execution", string(output))
+							}
+						})
+					}
+				})
+		})
+	}
+	t.Logf("45 original kernels, 256 samples, disjoint/overlapping inputs and outputs, both complete 96-byte buffers; execute=%t", execute)
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralRuntimeObjects(t *testing.T) {
+	fixedLocalLogicalLiteralRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
diff --git a/amd64_fixed_local_logical_literal_runtime_linux_amd64_test.go b/amd64_fixed_local_logical_literal_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..1e3ad4eef
--- /dev/null
+++ b/amd64_fixed_local_logical_literal_runtime_linux_amd64_test.go
@@ -0,0 +1,9 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalLogicalLiterals(t *testing.T) {
+	fixedLocalLogicalLiteralRuntime(t, fixedLocalVEXNativeTools(t), true)
+}
diff --git a/amd64_fixed_local_logical_literal_test.go b/amd64_fixed_local_logical_literal_test.go
new file mode 100644
index 000000000..2daab41e6
--- /dev/null
+++ b/amd64_fixed_local_logical_literal_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type fixedLocalLogicalLiteralCase struct {
+	opcode string
+	mode   int // Independent oracle: AND, ANDNOT, OR, XOR.
+	width  int
+	vex    bool
+}
+
+func fixedLocalLogicalLiteralCases() []fixedLocalLogicalLiteralCase {
+	var rows []fixedLocalLogicalLiteralCase
+	for mode, names := range [][3]string{
+		{"PAND", "ANDPS", "ANDPD"},
+		{"PANDN", "ANDNPS", "ANDNPD"},
+		{"POR", "ORPS", "ORPD"},
+		{"PXOR", "XORPS", "XORPD"},
+	} {
+		for _, name := range names {
+			rows = append(rows, fixedLocalLogicalLiteralCase{name, mode, 16, false})
+			for _, width := range []int{16, 32} {
+				rows = append(rows, fixedLocalLogicalLiteralCase{"V" + name, mode, width, true})
+			}
+		}
+	}
+	return rows
+}
+
+func fixedLocalLogicalLiteralSource(row fixedLocalLogicalLiteralCase, annihilate bool) string {
+	mask := make([]byte, row.width)
+	for index := range mask {
+		switch row.mode {
+		case 0, 1:
+			if !annihilate && index >= 12 && index < 16 {
+				mask[index] = 255
+			}
+		case 2:
+			if annihilate || index < 12 || index >= 16 {
+				mask[index] = 255
+			}
+		case 3:
+			mask[index] = byte(index*13 + 7)
+		}
+	}
+	var assembly strings.Builder
+	for offset := 0; offset < row.width; offset += 8 {
+		fmt.Fprintf(&assembly, "DATA mask<>+%d(SB)/8,$%#x\n", offset, binary.LittleEndian.Uint64(mask[offset:]))
+	}
+	fmt.Fprintf(&assembly, "GLOBL mask<>(SB),8,$%d\n", row.width)
+	assembly.WriteString("TEXT ·Value(SB),4,$32-16\nMOVQ input+0(FP),DI\nMOVQ output+8(FP),SI\n")
+	bank, move := "X", "MOVOU"
+	if row.vex {
+		move = "VMOVDQU"
+		if row.width == 32 {
+			bank = "Y"
+		}
+	}
+	if row.mode == 3 {
+		fmt.Fprintf(&assembly, "%s (DI),%s5\n", move, bank)
+	} else if !annihilate {
+		// The other physical vector bytes deliberately remain undefined in
+		// the source proof. No full-register zero idiom precedes this insert.
+		assembly.WriteString("PINSRD $3,(DI),X5\n")
+	}
+	destination := bank + "5"
+	if row.vex {
+		destination = bank + "6"
+		fmt.Fprintf(&assembly, "%s mask<>(SB),%s5,%s\n", row.opcode, bank, destination)
+	} else {
+		fmt.Fprintf(&assembly, "%s mask<>(SB),%s\n", row.opcode, destination)
+	}
+	fmt.Fprintf(&assembly, "%s %s,0(SP)\n%s 0(SP),%s\n%s %s,(SI)\nRET\n",
+		move, destination, move, destination, move, destination)
+	return assembly.String()
+}
+
+// This is an independent byte oracle, not a call to a production operation.
+func fixedLocalLogicalLiteralByte(mode int, first, second byte) byte {
+	switch mode {
+	case 0:
+		return first & second
+	case 1:
+		return first & ^second
+	case 2:
+		return first | second
+	case 3:
+		return first ^ second
+	default:
+		panic("unknown test operation")
+	}
+}
+
+func TestX86PackedLogicalConstantByteDependencies(t *testing.T) {
+	for mode, operation := range []amd64PackedLogicalMode{
+		amd64PackedLogicalAnd, amd64PackedLogicalAndNot, amd64PackedLogicalOr, amd64PackedLogicalXor,
+	} {
+		for first := 0; first < 256; first++ {
+			actual := x86PackedLogicalSecondBits(operation, byte(first))
+			for second := 0; second < 256; second++ {
+				base := fixedLocalLogicalLiteralByte(mode, byte(first), byte(second))
+				for bit := 0; bit < 8; bit++ {
+					changed := fixedLocalLogicalLiteralByte(mode, byte(first), byte(second)^(1<<uint(bit)))
+					if (base != changed) != (actual&(1<<uint(bit)) != 0) {
+						t.Fatalf("mode=%d first=%x second=%x bit=%d dependency=%x", mode, first, second, bit, actual)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalLiteralPlanProjection(t *testing.T) {
+	for _, row := range fixedLocalLogicalLiteralCases() {
+		for _, annihilate := range []bool{false, true} {
+			if annihilate && row.mode == 3 {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%d/constant=%t", row.opcode, row.width, annihilate), func(t *testing.T) {
+				assembly := fixedLocalLogicalLiteralSource(row, annihilate)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Internal dependency projection only. Public owner and source
+				// validity are independently exercised by actual-Go captures.
+				literal := x86ShiftLiteral{width: uint8(row.width)}
+				for _, datum := range file.Data {
+					payload, err := dataStmtPayload(datum)
+					if err != nil {
+						t.Fatal(err)
+					}
+					copy(literal.bytes[datum.Off:], payload)
+				}
+				binding := &x86FixedLocalBinding{literalData: map[string]x86FixedLocalData{
+					"mask<>": {size: int64(row.width), alignment: 16,
+						literals: map[int64]x86ShiftLiteral{0: literal}},
+				}}
+				var logical Instr
+				for _, ins := range file.Funcs[0].Instrs {
+					if string(ins.Op) == row.opcode {
+						logical = ins
+					}
+				}
+				effect, known, err := fixedLocalVectorByteEffect(logical)
+				if !known || err != nil {
+					t.Fatal("existing complete typed form rejected", known, err)
+				}
+				original := effect
+				original.operands = append([]x86TypedByteOperand(nil), effect.operands...)
+				projected := fixedLocalLogicalLiteralEffect(logical, effect, binding)
+				if !reflect.DeepEqual(effect, original) {
+					t.Fatal("projection mutated its caller's shared operand slice")
+				}
+				want := uint64(0xf000)
+				if annihilate {
+					want = 0
+				}
+				if row.mode == 3 {
+					want = x86CallerVectorByteMask(int64(row.width))
+				}
+				if len(projected.operands) != len(effect.operands) ||
+					!reflect.DeepEqual(projected.operands[0], original.operands[0]) || !projected.operands[0].read {
+					t.Fatal("constant dependency removed or changed the complete memory read")
+				}
+				register := projected.operands[1]
+				required := register.requiredBytes
+				if register.read && required == 0 {
+					required = x86CallerVectorByteMask(register.width)
+				}
+				if required != want || register.read != (want != 0) ||
+					register.write != original.operands[1].write || projected.vector != original.vector ||
+					projected.flagsRead != original.flagsRead || projected.flagsDefined != original.flagsDefined ||
+					projected.flagsKilled != original.flagsKilled {
+					t.Fatal("projection changed required bytes, aliases or FLAGS", required, want, projected)
+				}
+				state := x86FixedLocalState{flags: x86ByteFlagsAll, vectors: map[Reg]uint64{
+					"Z5": want | 1<<40, "Z6": 1 << 50,
+				}}
+				proof := &x86FixedLocalProof{binding: binding, frame: 32}
+				if err := fixedLocalTypedByteStep(&logical, &state, FuncSig{}, proof, 0, projected); err != nil {
+					t.Fatal("exact required input bytes failed the unchanged typed evaluator", err)
+				}
+				if state.flags != x86ByteFlagsAll {
+					t.Fatal("logical operation changed FLAGS")
+				}
+				if row.vex {
+					if state.vectors["Z6"] != ^uint64(0) || state.vectors["Z5"] != want|1<<40 {
+						t.Fatal("VEX output failed to zero upper aliases or changed the source")
+					}
+				} else if state.vectors["Z5"] != 0xffff|1<<40 || state.vectors["Z6"] != 1<<50 {
+					t.Fatal("legacy output changed upper aliases or unrelated registers")
+				}
+				for _, invalid := range []*x86FixedLocalBinding{
+					nil, {}, {literalData: map[string]x86FixedLocalData{
+						"mask<>": {size: int64(row.width), alignment: 16},
+					}},
+				} {
+					if got := fixedLocalLogicalLiteralEffect(logical, effect, invalid); !reflect.DeepEqual(got, original) {
+						t.Fatal("missing actual literal tuple acquired a constant dependency")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_logical_test.go b/amd64_fixed_local_logical_test.go
new file mode 100644
index 000000000..5b0ad5a17
--- /dev/null
+++ b/amd64_fixed_local_logical_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestGoAMD64FixedLocalLogicalOfficialRows(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := make(map[string]bool)
+	for _, name := range x86LegacyLogicalMemoryNames {
+		wanted[name] = true
+	}
+	xmm, mmx := 0, 0
+	for _, opcode := range catalog.Optab {
+		if !wanted[opcode.Opcode] {
+			continue
+		}
+		for _, row := range opcode.Rows {
+			if row.ZCase != "Zm_r_xm" {
+				t.Fatalf("unmodeled original logical row: %+v", row)
+			}
+			switch strings.Join(row.Classes, ",") {
+			case "Yxm,Yxr":
+				xmm++
+			case "Ymm,Ymr":
+				mmx++ // Inventoried, not admitted to the private XMM consumer.
+			default:
+				t.Fatalf("unmodeled original logical operands: %+v", row)
+			}
+		}
+	}
+	if len(wanted) != 12 || xmm != 12 || mmx != 4 {
+		t.Fatalf("official logical family changed: names=%d XMM=%d MMX=%d", len(wanted), xmm, mmx)
+	}
+}
+
+func fixedLocalLogicalZeroName(name string) bool {
+	switch name {
+	case "PXOR", "XORPS", "XORPD", "PANDN", "ANDNPS", "ANDNPD":
+		return true
+	}
+	return false
+}
+
+func fixedLocalLogicalFixture(t *testing.T, name, input string, uninitialized bool) (string, FuncSig) {
+	t.Helper()
+	source, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "MOVOU 16(SP),X1\n"+name+" "+input+",X0")
+	if uninitialized {
+		source = strings.Replace(source, "MOVOU 48(SP),X0\n", "", 1)
+	}
+	return source, sig
+}
+
+func fixedLocalLogicalProgram(t *testing.T) (string, string, int) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	count := 0
+	for _, name := range x86LegacyLogicalMemoryNames {
+		for _, input := range []string{"16(SP)", "X1", "X0", "zero"} {
+			zero := input == "zero"
+			if zero && !fixedLocalLogicalZeroName(name) {
+				continue
+			}
+			if zero {
+				input = "X0"
+			}
+			source, _ := fixedLocalLogicalFixture(t, name, input, zero)
+			function := fmt.Sprintf("Value%d", count)
+			assembly.WriteString(strings.Replace(source, "·Value", "·"+function, 1))
+			fmt.Fprintf(&declarations, "func %s(a,b,c,d uint64) uint64\n", function)
+			count++
+		}
+	}
+	return assembly.String(), declarations.String(), count
+}
+
+func TestGoAMD64FixedLocalLogicalCompleteFamilies(t *testing.T) {
+	assembly, _, count := fixedLocalLogicalProgram(t)
+	if count != 42 {
+		t.Fatal("complete 12-name register/memory/alias and six zero identities changed", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	for _, name := range x86LegacyLogicalMemoryNames {
+		for _, input := range []string{"16(SP)", "X1", "X0"} {
+			t.Run(name+"/"+input, func(t *testing.T) {
+				source, sig := fixedLocalLogicalFixture(t, name, input, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+					t.Fatal("initialized complete logical family source rejected", err)
+				}
+			})
+		}
+		if fixedLocalLogicalZeroName(name) {
+			t.Run(name+"/zero identity", func(t *testing.T) {
+				source, sig := fixedLocalLogicalFixture(t, name, "X0", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+					t.Fatal("same-register zero identity incorrectly needs old numerical bytes", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalUpperAliasesAndFlags(t *testing.T) {
+	for _, name := range x86LegacyLogicalMemoryNames {
+		for _, old := range []uint64{0xffff, 0x804020100000ffff, ^uint64(0)} {
+			t.Run(fmt.Sprintf("%s/%x", name, old), func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+name+" X1,X0\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": old, "Z1": 0xffff}, flags: x86ByteFlagsAll}
+				if err := fixedLocalVectorStep(&file.Funcs[0].Instrs[1], &state, nil, 0); err != nil {
+					t.Fatal(err)
+				}
+				if state.vectors["Z0"] != old || state.flags != x86ByteFlagsAll {
+					t.Fatal("legacy logical operation changed upper bytes or FLAGS", state)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalBoundaries(t *testing.T) {
+	for _, name := range x86LegacyLogicalMemoryNames {
+		for _, row := range []struct{ name, input, from, to string }{
+			{"unknown destination", "X1", "MOVOU 48(SP),X0", "MOVOU 48(SP),X2"},
+			{"unknown source", "X2", "", ""},
+			{"missing memory byte", "16(SP)", "MOVQ CX,24(SP)", "MOVB CX,24(SP)"},
+			{"unaligned memory", "17(SP)", "", ""},
+			{"outside frame", "160(SP)", "", ""},
+			{"MMX source", "M0", "", ""},
+			{"high bank", "X16", "", ""},
+		} {
+			t.Run(name+"/"+row.name, func(t *testing.T) {
+				source, sig := fixedLocalLogicalFixture(t, name, row.input, false)
+				if row.from != "" {
+					changed := strings.Replace(source, row.from, row.to, 1)
+					if changed == source {
+						t.Fatal("negative fixture did not change the source")
+					}
+					source = changed
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unproved bytes, alignment or physical bank acquired a logical effect", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalLogicalObjects(t *testing.T) {
+	assembly, declarations, count := fixedLocalLogicalProgram(t)
+	if count != 42 {
+		t.Fatal("complete-source logical denominator changed", count)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, count)
+}
+
+func fixedLocalCompleteVectorObjects(t *testing.T, assembly, declarations string, count int) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("ordinary vector/private-frame source failed complete translation", err)
+					}
+					var names []string
+					for index := 0; index < count; index++ {
+						names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "private-vector.ll", "private-vector.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "private-vector-opt.ll", "private-vector-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
diff --git a/amd64_fixed_local_machine_bits_policy_test.go b/amd64_fixed_local_machine_bits_policy_test.go
new file mode 100644
index 000000000..e5c3d7dc8
--- /dev/null
+++ b/amd64_fixed_local_machine_bits_policy_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Retain the complete formerly rejected sources, including their original
+// private frame setup and ABI. A successful internal effect probe is not an
+// object certificate for these newly accepted machine-bit consumers.
+func TestGoAMD64FixedLocalMachineBitsRetainedPolicyObjects(t *testing.T) {
+	t.Run("native vector spill", func(t *testing.T) {
+		var assembly, declarations strings.Builder
+		for index, name := range []string{"PSUBSW", "PMULLD", "PMULHW", "PMULDQ", "PAVGB", "PMADDUBSW"} {
+			source, _, _ := x86PrivateAlignedFrameAuditTypedFixture(t, name+" 16(SP),X0",
+				"package frameaudit\nfunc Value(a *uint64, b, c, d uint64) uint64\n")
+			function := fmt.Sprintf("Value%d", index)
+			assembly.WriteString(strings.Replace(source, "·Value", "·"+function, 1))
+			fmt.Fprintf(&declarations, "func %s(a *uint64, b, c, d uint64) uint64\n", function)
+		}
+		fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), 6)
+	})
+	t.Run("native multiply", func(t *testing.T) {
+		var assembly, declarations strings.Builder
+		count := 0
+		for _, stem := range []string{"MUL", "IMUL"} {
+			for _, width := range fixedLocalImplicitMultiplyWidths {
+				name := stem + width.suffix
+				for _, role := range []string{"accumulator", "source"} {
+					body := "MOVQ SI,CX\n" + name + " CX"
+					if role == "accumulator" {
+						body = "MOVQ SI,AX\n" + name + " 0(SP)"
+					}
+					_, _, source := fixedLocalInputFixture(t, body)
+					function := fmt.Sprintf("Value%d", count)
+					assembly.WriteString(strings.Replace(source, "·Value", "·"+function, 1))
+					fmt.Fprintf(&declarations, "func %s(p, q *uint64, a uint64) uint64\n", function)
+					count++
+				}
+			}
+		}
+		if count != 16 {
+			t.Fatal("original native multiply source inventory changed", count)
+		}
+		fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), count)
+	})
+	t.Run("unused native arithmetic", func(t *testing.T) {
+		base := fixedLocalTransportAssembly("Value0", 49, fixedLocalTransportBoolBody)
+		body := strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "ADDQ CX,DX", 1)
+		assembly := strings.Replace(base, fixedLocalTransportBoolBody, body, 1)
+		declaration := "func Value0(" + fixedLocalTransportParams + ") bool"
+		fixedLocalCompleteVectorObjects(t, assembly, declaration, 1)
+	})
+}
diff --git a/amd64_fixed_local_machine_bits_runtime_go127_test.go b/amd64_fixed_local_machine_bits_runtime_go127_test.go
new file mode 100644
index 000000000..98636fc5c
--- /dev/null
+++ b/amd64_fixed_local_machine_bits_runtime_go127_test.go
@@ -0,0 +1,513 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type fixedLocalMachineRuntimeCase struct {
+	operation, bits, left, right, carry int
+	destinationShift, sourceShift       int
+	body                                string
+}
+
+// Native pointers contribute their actual initialized bits. The independent
+// Go and C references each use their own buffers' addresses, never assume the
+// same linker/stack layout, and check every canary byte after the assembly call.
+func fixedLocalMachineRuntimeCases() []fixedLocalMachineRuntimeCase {
+	flags := "SETCS 0(R8)\nSETEQ 1(R8)\nSETMI 2(R8)\nSETOS 3(R8)\nSETPS 4(R8)\n"
+	var rows []fixedLocalMachineRuntimeCase
+	for wi, suffix := range []string{"B", "W", "L", "Q"} {
+		for op, stem := range []string{"ADD", "ADC", "SUB", "SBB", "AND", "OR", "XOR"} {
+			for _, left := range []int{0, 1} {
+				for _, right := range []int{0, 2} {
+					for carry := 0; carry < 2; carry++ {
+						register := []string{"AX", "SI", "DI"}
+						body := "MOVQ SI,R8\nMOVQ " + register[left] + ",BX\nMOVQ " + register[right] + ",CX\nCMPQ AX,AX\n"
+						if carry != 0 {
+							body += "STC\n"
+						}
+						body += stem + suffix + " CX,BX\n" + flags + "XORQ $0,BX\nMOVQ BX,AX"
+						rows = append(rows, fixedLocalMachineRuntimeCase{op, []int{8, 16, 32, 64}[wi], left, right, carry, 0, 0, body})
+					}
+				}
+			}
+		}
+	}
+	for _, operand := range []struct {
+		source string
+		role   int
+	}{{"SI", 1}, {"p+0(FP)", 1}} {
+		body := "MOVQ SI,R8\nMULQ " + operand.source + "\nSETCS 0(R8)\nMOVB $0,1(R8)\nMOVB $0,2(R8)\nSETOS 3(R8)\nMOVB $0,4(R8)"
+		rows = append(rows, fixedLocalMachineRuntimeCase{7, 64, 0, operand.role, 0, 0, 0, body})
+	}
+	for _, shifts := range [][2]int{{0, 8}, {8, 0}} {
+		registers := map[int]string{0: "AL", 8: "AH"}
+		body := "MOVQ SI,R8\nMOVQ SI,AX\nSUBB " + registers[shifts[1]] + "," + registers[shifts[0]] + "\n" + flags + "XORQ $0,AX"
+		rows = append(rows, fixedLocalMachineRuntimeCase{2, 8, 1, 1, 0, shifts[0], shifts[1], body})
+	}
+	return rows
+}
+
+func fixedLocalMachineRuntimeScope(scope string) []fixedLocalMachineRuntimeCase {
+	rows := fixedLocalMachineRuntimeCases()
+	if scope == "machine" {
+		return rows
+	}
+	if scope == "auxiliary" {
+		var selected []fixedLocalMachineRuntimeCase
+		for _, row := range rows {
+			if row.operation > 3 || row.bits != 64 || row.left != 1 || row.right != 0 {
+				continue
+			}
+			// Preserve BX and the five SETcc observations. AH cannot be
+			// encoded directly with the REX prefix required by an R8 address.
+			row.body = strings.Replace(row.body, "XORQ $0,BX",
+				"LAHF\nMOVB AH,CL\nANDB $16,CL\nMOVB CL,5(R8)\nXORQ $0,BX", 1)
+			selected = append(selected, row)
+		}
+		return selected
+	}
+	if scope == "vector spill" {
+		return []fixedLocalMachineRuntimeCase{{operation: 8, bits: 64, left: 1,
+			body: "MOVQ SI,R8\nMOVQ SP,R11\nANDQ $-16,SP\nADDQ $16,SP\n" +
+				"MOVQ SI,16(SP)\nMOVQ AX,24(SP)\nCMPQ AX,AX\n" +
+				"PXOR X0,X0\nPADDQ 16(SP),X0\nMOVQ R11,SP\n" +
+				"SETCS 0(R8)\nSETEQ 1(R8)\nSETMI 2(R8)\nSETOS 3(R8)\nSETPS 4(R8)\nMOVQ X0,AX",
+		}}
+	}
+	if scope == "multiply" {
+		var selected []fixedLocalMachineRuntimeCase
+		for _, stem := range []string{"MUL", "IMUL"} {
+			operation := 7
+			if stem == "IMUL" {
+				operation = 9
+			}
+			for _, width := range fixedLocalImplicitMultiplyWidths {
+				for _, accumulator := range []bool{false, true} {
+					left, right := 0, 1
+					body := "MOVQ SI,R8\nMOVQ SI,CX\n" + stem + width.suffix + " CX\n"
+					if accumulator {
+						left, right = 1, 0
+						body = "MOVQ SI,R8\nMOVQ SI,AX\n" + stem + width.suffix + " 0(SP)\n"
+					}
+					body += "SETCS 0(R8)\nMOVB $0,1(R8)\nMOVB $0,2(R8)\nSETOS 3(R8)\nMOVB $0,4(R8)"
+					selected = append(selected, fixedLocalMachineRuntimeCase{
+						operation: operation, bits: int(width.width * 8), left: left, right: right, body: body,
+					})
+				}
+			}
+		}
+		return selected
+	}
+	return nil
+}
+
+func fixedLocalMachineBitsRuntimeProgram(t *testing.T, triple, scope string) (assembly, declarations, original, driver string) {
+	t.Helper()
+	rows := fixedLocalMachineRuntimeScope(scope)
+	want := map[string]int{"machine": 228, "auxiliary": 8, "vector spill": 1, "multiply": 16}[scope]
+	if want == 0 || len(rows) != want {
+		t.Fatal("independent machine-bit runtime inventory changed", len(rows))
+	}
+	checkedFlags := 5
+	if scope == "auxiliary" {
+		checkedFlags = 6
+	}
+	var functions []fixedLocalPointerChoiceCase
+	var goRows, cRows, goFunctions, cFunctions, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, row := range rows {
+		functions = append(functions, fixedLocalPointerChoiceCase{fmt.Sprintf("machine%d", index), row.body})
+		fields := fmt.Sprintf("{%d,%d,%d,%d,%d,%d,%d},", row.operation, row.bits, row.left, row.right, row.carry, row.destinationShift, row.sourceShift)
+		goRows.WriteString(fields)
+		cRows.WriteString(fields)
+		fmt.Fprintf(&goFunctions, "Value%d,", index)
+		fmt.Fprintf(&cFunctions, "value%d,", index)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t*,uint64_t*,uint64_t) __asm__(%s);\n", index,
+			runtimeCAsmLabel(prefix+fmt.Sprintf("example.invalid/framefixture.Value%d", index)))
+	}
+	assembly, declarations = fixedLocalPointerChoiceProgram(t, "", functions)
+	original = `package main
+
+import (
+	"fmt"
+	"math/bits"
+	"unsafe"
+)
+
+` + fmt.Sprintf("const checkedFlags = %d\n", checkedFlags) + declarations + `
+
+type row struct{ op, width, left, right, carry, ds, ss int }
+
+var rows = []row{` + goRows.String() + `}
+
+func reference(c row, base, other, a uint64) (uint64, [6]byte) {
+	values := [3]uint64{a, base, other}
+	old := values[c.left]
+	if c.op == 8 {
+		// The vector adds zero to the spilled native address. Integer FLAGS
+		// still describe the equal comparison preceding the vector operation.
+		return old, [6]byte{0, 1, 0, 0, 1, 0}
+	}
+	mask := ^uint64(0)
+	if c.width < 64 {
+		mask = (uint64(1) << c.width) - 1
+	}
+	x, y := (old>>c.ds)&mask, (values[c.right]>>c.ss)&mask
+	sign := uint64(1) << (c.width - 1)
+	var r, cf, of uint64
+	switch c.op {
+	case 0, 1:
+		carry := uint64(0)
+		if c.op == 1 {
+			carry = uint64(c.carry)
+		}
+		r, cf = bits.Add64(x, y, carry)
+		if c.width < 64 && r > mask {
+			cf = 1
+		}
+		r &= mask
+		if (^(x ^ y) & (x ^ r) & sign) != 0 {
+			of = 1
+		}
+	case 2, 3:
+		carry := uint64(0)
+		if c.op == 3 {
+			carry = uint64(c.carry)
+		}
+		r, cf = bits.Sub64(x, y, carry)
+		r &= mask
+		if ((x ^ y) & (x ^ r) & sign) != 0 {
+			of = 1
+		}
+	case 4:
+		r = x & y
+	case 5:
+		r = x | y
+	case 6:
+		r = x ^ y
+	case 7:
+		hi, lo := bits.Mul64(x, y)
+		r = lo
+		if hi != 0 || c.width < 64 && lo>>c.width != 0 {
+			cf, of = 1, 1
+		}
+	case 9:
+		if x&sign != 0 {
+			x |= ^mask
+		}
+		if y&sign != 0 {
+			y |= ^mask
+		}
+		hi, lo := bits.Mul64(x, y)
+		if int64(x) < 0 {
+			hi -= y
+		}
+		if int64(y) < 0 {
+			hi -= x
+		}
+		r = lo
+		low, high := lo&mask, uint64(0)
+		if low&sign != 0 {
+			low |= ^mask
+			high = ^uint64(0)
+		}
+		if lo != low || hi != high {
+			cf, of = 1, 1
+		}
+	default:
+		panic("unknown reference")
+	}
+	flags := [6]byte{byte(cf), 0, 0, byte(of), 0, 0}
+	if checkedFlags == 6 {
+		carry := uint64(0)
+		if c.op == 1 || c.op == 3 {
+			carry = uint64(c.carry)
+		}
+		if c.op < 2 && (x&15)+(y&15)+carry > 15 ||
+			c.op >= 2 && (x&15) < (y&15)+carry {
+			flags[5] = 16
+		}
+	}
+	if c.op != 7 && c.op != 9 {
+		if r == 0 {
+			flags[1] = 1
+		}
+		if r&sign != 0 {
+			flags[2] = 1
+		}
+		if bits.OnesCount8(uint8(r))%2 == 0 {
+			flags[4] = 1
+		}
+	}
+	if c.op == 7 || c.op == 9 {
+		if c.width == 8 {
+			mask = 65535 // Byte multiply writes AX; word multiply also writes AX.
+		}
+		r &= mask
+	}
+	if c.width < 32 {
+		r = (old &^ (mask << c.ds)) | (r << c.ds)
+	}
+	return r, flags
+}
+func main() {
+	functions := []func(*uint64, *uint64, uint64) uint64{` + goFunctions.String() + `}
+	for index, fn := range functions {
+		for alias := 0; alias < 2; alias++ {
+			var left, right [32]uint64
+			p, q := &left[4], &right[4]
+			if alias != 0 {
+				q = p
+			}
+			base, other := uint64(uintptr(unsafe.Pointer(p))), uint64(uintptr(unsafe.Pointer(q)))
+			inputs := []uint64{
+				0, 1, 7, 8, 127, 128, 255, 256, 32767, 32768, 65535, 65536,
+				1<<31 - 1, 1 << 31, 1<<63 - 1, 1 << 63, ^uint64(0),
+				-base, other - base, base,
+			}
+			for sample, a := range inputs {
+				for i := range left {
+					left[i] = uint64(i+1)*0x0102030405060708 ^ a
+					right[i] = ^left[i]
+				}
+				wantLeft, wantRight := left, right
+				want, flags := reference(rows[index], base, other, a)
+				bytes := (*[256]byte)(unsafe.Pointer(&wantLeft))
+				for i, f := range flags[:checkedFlags] {
+					bytes[32+i] = f
+				}
+				got := fn(p, q, a)
+				if got != want || left != wantLeft || right != wantRight {
+					panic(fmt.Sprintf("case=%d sample=%d alias=%d got=%016x want=%016x", index, sample, alias, got, want))
+				}
+				fmt.Printf("%d %d %d PASS\n", index, alias, sample)
+			}
+		}
+	}
+}
+`
+	driver = "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		fmt.Sprintf("enum { function_count = %d, checked_flags = %d };\n", len(rows), checkedFlags) +
+		runtimeCAsmLabelPreamble + cDeclarations.String() + `
+typedef struct {
+    unsigned op, width, left, right, carry, ds, ss;
+} row;
+static const row rows[] = {
+    ` + cRows.String() + `
+};
+static uint64_t reference(row c, uint64_t base, uint64_t other, uint64_t a,
+                          unsigned char flags[6]) {
+    uint64_t values[] = {a, base, other}, old = values[c.left];
+    if (c.op == 8) {
+        const unsigned char equal_flags[] = {0, 1, 0, 0, 1, 0};
+        memcpy(flags, equal_flags, sizeof equal_flags);
+        return old;
+    }
+    uint64_t mask = c.width == 64 ? UINT64_MAX : (UINT64_C(1) << c.width) - 1;
+    uint64_t x = (old >> c.ds) & mask, y = (values[c.right] >> c.ss) & mask,
+             sign = UINT64_C(1) << (c.width - 1), r = 0;
+    unsigned cf = 0, of = 0;
+    switch (c.op) {
+    case 0:
+    case 1: {
+        __uint128_t wide = (__uint128_t)x + y + (c.op == 1 ? c.carry : 0);
+        r = (uint64_t)wide & mask;
+        cf = wide > mask;
+        of = (~(x ^ y) & (x ^ r) & sign) != 0;
+        break;
+    }
+    case 2:
+    case 3: {
+        __uint128_t rhs = (__uint128_t)y + (c.op == 3 ? c.carry : 0);
+        r = (uint64_t)((__uint128_t)x - rhs) & mask;
+        cf = (__uint128_t)x < rhs;
+        of = ((x ^ y) & (x ^ r) & sign) != 0;
+        break;
+    }
+    case 4:
+        r = x & y;
+        break;
+    case 5:
+        r = x | y;
+        break;
+    case 6:
+        r = x ^ y;
+        break;
+    case 7: {
+        __uint128_t wide = (__uint128_t)x * y;
+        r = (uint64_t)wide;
+        cf = of = wide > mask;
+        break;
+    }
+    case 9: {
+        __int128 sx = x, sy = y;
+        if (x & sign)
+            sx -= (__int128)1 << c.width;
+        if (y & sign)
+            sy -= (__int128)1 << c.width;
+        __int128 wide = sx * sy;
+        r = (uint64_t)wide;
+        __int128 limit = (__int128)1 << (c.width - 1);
+        cf = of = wide < -limit || wide >= limit;
+        break;
+    }
+    default:
+        return 0;
+    }
+    flags[0] = cf;
+    flags[1] = 0;
+    flags[2] = 0;
+    flags[3] = of;
+    flags[4] = 0;
+    flags[5] = 0;
+    if (checked_flags == 6) {
+        unsigned carry = c.op == 1 || c.op == 3 ? c.carry : 0;
+        unsigned low_left = x & 15, low_right = (y & 15) + carry;
+        if (c.op < 2 ? low_left + low_right > 15 : low_left < low_right) {
+            flags[5] = 16;
+        }
+    }
+    if (c.op != 7 && c.op != 9) {
+        unsigned parity = 0;
+        for (unsigned b = 0; b < 8; b++)
+            parity ^= (r >> b) & 1;
+        flags[1] = r == 0;
+        flags[2] = (r & sign) != 0;
+        flags[4] = !parity;
+    }
+    if (c.op == 7 || c.op == 9) {
+        if (c.width == 8)
+            mask = 65535;
+        r &= mask;
+    }
+    if (c.width < 32)
+        r = (old & ~(mask << c.ds)) | (r << c.ds);
+    return r;
+}
+int main(void) {
+    uint64_t (*functions[])(uint64_t *, uint64_t *, uint64_t) = {
+        ` + cFunctions.String() + `
+    };
+    for (unsigned index = 0; index < function_count; index++)
+        for (unsigned alias = 0; alias < 2; alias++) {
+            uint64_t left[32], right[32], wantLeft[32], wantRight[32];
+            uint64_t *p = &left[4], *q = alias ? p : &right[4];
+            uint64_t base = (uintptr_t)p, other = (uintptr_t)q;
+            uint64_t inputs[] = {0,
+                                 1,
+                                 7,
+                                 8,
+                                 127,
+                                 128,
+                                 255,
+                                 256,
+                                 32767,
+                                 32768,
+                                 65535,
+                                 65536,
+                                 (UINT64_C(1) << 31) - 1,
+                                 UINT64_C(1) << 31,
+                                 (UINT64_C(1) << 63) - 1,
+                                 UINT64_C(1) << 63,
+                                 UINT64_MAX,
+                                 -base,
+                                 other - base,
+                                 base};
+            for (unsigned sample = 0; sample < 20; sample++) {
+                uint64_t a = inputs[sample];
+                for (unsigned i = 0; i < 32; i++) {
+                    left[i] = (uint64_t)(i + 1) * UINT64_C(0x0102030405060708) ^ a;
+                    right[i] = ~left[i];
+                }
+                memcpy(wantLeft, left, sizeof left);
+                memcpy(wantRight, right, sizeof right);
+                unsigned char flags[6];
+                uint64_t want = reference(rows[index], base, other, a, flags);
+                memcpy((unsigned char *)wantLeft + 32, flags, checked_flags);
+                uint64_t got = functions[index](p, q, a);
+                if (got != want || memcmp(left, wantLeft, sizeof left) ||
+                    memcmp(right, wantRight, sizeof right)) {
+                    fprintf(stderr, "case=%u sample=%u alias=%u got=%016llx want=%016llx\n", index,
+                            sample, alias, (unsigned long long)got, (unsigned long long)want);
+                    return 1;
+                }
+                printf("%u %u %u PASS\n", index, alias, sample);
+            }
+        }
+    return 0;
+}
+`
+	return
+}
+
+func fixedLocalMachineBitsRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	fixedLocalMachineRuntime(t, execution, execute, "machine")
+}
+
+func fixedLocalMachineRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool, scope string) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly, declarations, original, driver := fixedLocalMachineBitsRuntimeProgram(t, execution.triple, scope)
+	count := len(fixedLocalMachineRuntimeScope(scope))
+	var want []string
+	for index := 0; index < count; index++ {
+		for alias := 0; alias < 2; alias++ {
+			for sample := 0; sample < 20; sample++ {
+				want = append(want, fmt.Sprintf("%d %d %d PASS", index, alias, sample))
+			}
+		}
+	}
+	check := func(output []byte) {
+		t.Helper()
+		if strings.TrimSpace(string(output)) != strings.Join(want, "\n") {
+			t.Fatalf("incomplete machine-bit arithmetic oracle:\n%s", output)
+		}
+	}
+	if execute {
+		check(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original))
+	} else {
+		x86COMICompileOriginalGo(t, map[string]string{"go.mod": "module machinebits\ngo 1.20\n", "main.go": original, "original_amd64.s": assembly}, false)
+	}
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(level, func(t *testing.T) {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				if execute {
+					check(execution.compileAndRunLLVM(t, "machine-bits", input, driver, level))
+				} else {
+					execution.compileLLVM(t, "machine-bits", input, driver, level)
+				}
+			})
+		}
+	})
+	t.Logf("%s: %d complete functions, 20 actual-address samples, two aliases and all 512 canary bytes; execute=%v", scope, count, execute)
+}
+
+func TestGoAMD64FixedLocalMachineBitsRuntimeObjects(t *testing.T) {
+	fixedLocalMachineBitsRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
+
+func TestGoAMD64FixedLocalMachineSupplementalRuntimeObjects(t *testing.T) {
+	for _, scope := range []string{"auxiliary", "vector spill", "multiply"} {
+		t.Run(scope, func(t *testing.T) {
+			fixedLocalMachineRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, scope)
+		})
+	}
+}
diff --git a/amd64_fixed_local_machine_bits_test.go b/amd64_fixed_local_machine_bits_test.go
new file mode 100644
index 000000000..b4fd0eb89
--- /dev/null
+++ b/amd64_fixed_local_machine_bits_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalMachineBitCases() []fixedLocalPointerChoiceCase {
+	var rows []fixedLocalPointerChoiceCase
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, stem := range []string{"ADD", "ADC", "SUB", "SBB", "AND", "OR", "XOR"} {
+			for _, destination := range []string{"AX", "SI"} {
+				for _, source := range []string{"AX", "DI"} {
+					body := "MOVQ " + destination + ",BX\nMOVQ " + source + ",CX\nCMPQ AX,AX\n" +
+						stem + width + " CX,BX\nXORQ $0,BX\nMOVQ BX,AX"
+					rows = append(rows, fixedLocalPointerChoiceCase{
+						fmt.Sprintf("%s%s/%s/%s", stem, width, destination, source), body,
+					})
+				}
+			}
+		}
+		for _, stem := range []string{"NEG", "NOT", "INC", "DEC"} {
+			rows = append(rows, fixedLocalPointerChoiceCase{stem + width,
+				"MOVQ SI,BX\n" + stem + width + " BX\nXORQ $0,BX\nMOVQ BX,AX"})
+		}
+		for _, stem := range []string{"CMP", "TEST"} {
+			rows = append(rows, fixedLocalPointerChoiceCase{stem + width,
+				stem + width + " SI,AX\nSETCS AL"})
+		}
+		rows = append(rows,
+			fixedLocalPointerChoiceCase{"spill source/" + width,
+				"MOVQ SI,8(SP)\nSUB" + width + " 8(SP),AX"},
+			fixedLocalPointerChoiceCase{"spill destination/" + width,
+				"MOVQ SI,8(SP)\nSUB" + width + " AX,8(SP)\nMOVQ 8(SP),AX"},
+		)
+	}
+	for _, row := range []fixedLocalPointerChoiceCase{
+		{"aliased full address", "SUBQ SI,SI\nMOVQ SI,AX"},
+		{"high byte alias", "MOVQ SI,AX\nSUBB AH,AL\nXORQ $0,AX"},
+		{"typed pointer FP", "SUBQ q+8(FP),SI\nMOVQ SI,AX"},
+		{"typed pointer FP mixed", "SUBQ p+0(FP),AX"},
+		{"first address from typed FP", "XORQ SI,SI\nXORQ DI,DI\nMOVQ $0,CX\nADDQ p+0(FP),CX\nMOVQ (CX),AX"},
+		{"typed numeric FP affine", "ADDQ a+16(FP),SI\nSUBQ DI,SI\nMOVQ SI,AX"},
+		{"pointer FP multiply", "MULQ p+0(FP)"},
+		{"address multiply", "MULQ SI"},
+		{"address shift", "MOVQ SI,AX\nSHRQ $3,AX"},
+		{"pointer compare native numeric", "CMPQ SI,AX\nSETCS AL"},
+		{"carry consumed", "STC\nSBBQ SI,AX\nSETCS CL\nMOVBQZX CL,CX\nADDQ CX,AX"},
+		{"address flags branch", "SUBQ DI,SI\nJCS done\nINCQ AX\ndone:"},
+		{"unaligned spill interior", "MOVQ SI,3(SP)\nSUBL 4(SP),AX"},
+		{"unaligned spill partial RMW", "MOVQ SI,3(SP)\nSUBB AX,7(SP)\nMOVQ 3(SP),AX"},
+		{"two spill boundary", "MOVQ SI,8(SP)\nMOVQ DI,16(SP)\nSUBQ 12(SP),AX"},
+		{"vector machine input", "MOVQ SI,8(SP)\nMOVQ AX,16(SP)\nMOVQ AX,24(SP)\nMOVQ AX,32(SP)\nVPXOR Y0,Y0,Y0\nVPADDQ 8(SP),Y0,Y0\nMOVQ X0,AX"},
+	} {
+		rows = append(rows, row)
+	}
+	return append(rows, fixedLocalMachineAddressCases()...)
+}
+
+// Inputs point inside the native oracle's buffers, so both +/- one-byte paths
+// remain valid for every original input and alias choice.
+func fixedLocalMachineAddressCases() []fixedLocalPointerChoiceCase {
+	return []fixedLocalPointerChoiceCase{
+		{"ADC native CF0", "CLC\nADCQ $0,SI\nMOVQ (SI),AX"},
+		{"ADC native CF1", "STC\nADCQ $0,SI\nMOVQ (SI),AX"},
+		{"SBB native CF0", "CLC\nSBBQ $0,SI\nMOVQ (SI),AX"},
+		{"SBB native CF1", "STC\nSBBQ $0,SI\nMOVQ (SI),AX"},
+		{"ADC reversed CF0", "MOVQ $0,CX\nCLC\nADCQ SI,CX\nMOVQ (CX),AX"},
+		{"ADC reversed CF1", "MOVQ $0,CX\nSTC\nADCQ SI,CX\nMOVQ (CX),AX"},
+	}
+}
+
+func TestGoAMD64FixedLocalMachineBitsCompleteSources(t *testing.T) {
+	rows := fixedLocalMachineBitCases()
+	if len(rows) != 166 {
+		t.Fatal("independent machine-bit source inventory changed", len(rows))
+	}
+	var assembly strings.Builder
+	for index, row := range rows {
+		fn, sig, source := fixedLocalInputFixture(t, row.body)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("initialized machine input rejected", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+}
+
+func TestGoAMD64FixedLocalMachineBitsRetainCapabilities(t *testing.T) {
+	for _, row := range []fixedLocalPointerChoiceCase{
+		{"difference is not address", "SUBQ DI,SI\nMOVQ (SI),AX"},
+		{"sum is not address", "ADDQ DI,SI\nMOVQ (SI),AX"},
+		{"number minus address", "SUBQ SI,AX\nMOVQ (AX),AX"},
+		{"truncated result is not address", "SUBL AX,SI\nMOVQ (SI),AX"},
+		{"private source", "MOVQ SP,CX\nSUBQ CX,AX"},
+		{"private destination", "MOVQ SP,CX\nSUBQ SI,CX"},
+		{"private source spill", "MOVQ SP,8(SP)\nSUBQ 8(SP),AX"},
+		{"private destination spill", "MOVQ SP,8(SP)\nSUBQ AX,8(SP)"},
+		{"unknown source", "SUBQ R12,SI"},
+		{"unknown byte", "MOVB $1,R12\nSUBQ R12,SI"},
+		{"partial revoked spill", "MOVQ SI,8(SP)\nMOVB $1,9(SP)\nSUBQ 8(SP),AX"},
+		{"missing carry", "SBBQ SI,AX"},
+		{"multiply does not define zero", "MULQ SI\nJE done\ndone:"},
+		{"private index", "SUBQ (DI)(SP*1),AX"},
+		{"native index", "SUBQ (DI)(SI*1),AX"},
+		{"NUM is not address", "SUBQ DI,SI\nSUBQ (SI),AX"},
+		{"partial FP pointer", "SUBL p+0(FP),AX"},
+		{"changed SP FP", "ADDQ $8,SP\nSUBQ p+0(FP),AX\nADDQ $-8,SP"},
+		{"FP padding", "SUBQ p+1(FP),AX"},
+		{"FP destination", "SUBQ SI,a+16(FP)"},
+		{"undefined spill boundary", "MOVQ SI,8(SP)\nSUBQ 12(SP),AX"},
+		{"vector private source", "MOVQ SP,8(SP)\nMOVQ AX,16(SP)\nMOVQ AX,24(SP)\nMOVQ AX,32(SP)\nVPXOR Y0,Y0,Y0\nVPADDQ 8(SP),Y0,Y0"},
+		{"vector undefined source", "MOVQ SI,8(SP)\nVPXOR Y0,Y0,Y0\nVPADDQ 8(SP),Y0,Y0"},
+		{"carry sum is not address", "STC\nADCQ DI,SI\nMOVQ (SI),AX"},
+		{"carry difference is not address", "CLC\nSBBQ DI,SI\nMOVQ (SI),AX"},
+		{"carry number minus address", "STC\nSBBQ SI,AX\nMOVQ (AX),AX"},
+		{"missing address carry", "ADCQ $0,SI\nMOVQ (SI),AX"},
+		{"conditional FP pointer is not NUM", "CMPQ AX,AX\nCMOVQEQ p+0(FP),AX"},
+		{"conditional FP number is not address", "CMPQ AX,AX\nCMOVQEQ a+16(FP),SI\nXORQ $0,SI\nMOVQ SI,AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, source := fixedLocalInputFixture(t, row.body)
+			operation := ""
+			switch row.name {
+			case "difference is not address", "sum is not address", "truncated result is not address", "carry sum is not address", "carry difference is not address":
+				operation = "MOVQ (SI),AX"
+			case "number minus address", "carry number minus address":
+				operation = "MOVQ (AX),AX"
+			case "NUM is not address":
+				operation = "SUBQ (SI),AX"
+			}
+			if operation != "" {
+				fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p,q *uint64,a uint64) uint64",
+					operation, 0, 8, false, "load volatile i64")
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("machine input acquired unrelated storage, flags or ABI", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalMachineBitsCompleteObjects(t *testing.T) {
+	rows := fixedLocalMachineBitCases()
+	assembly, declarations := fixedLocalPointerChoiceProgram(t, "", rows)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(rows))
+}
diff --git a/amd64_fixed_local_mixed_entries_test.go b/amd64_fixed_local_mixed_entries_test.go
new file mode 100644
index 000000000..f384ce6a3
--- /dev/null
+++ b/amd64_fixed_local_mixed_entries_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// One physical source owns both entries. Ordinary dereferences an incoming Go
+// pointer, which is deliberately not a private-frame address or numeric input.
+func fixedLocalMixedEntriesFixture(t *testing.T, ordinaryFirst bool) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options, string) {
+	t.Helper()
+	_, request, _, _ := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	name := filepath.Join(request.Directory, request.AssemblyFile)
+	frame, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ordinary := "TEXT ·Ordinary(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ (AX),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+	assembly := string(frame) + ordinary
+	if ordinaryFirst {
+		assembly = ordinary + string(frame)
+	}
+	declaration := "package framefixture\nfunc Value(a, b, c, d uint64) uint64\nfunc Ordinary(p *uint64) uint64\n"
+	if err := os.WriteFile(name, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	goFile := filepath.Join(request.Directory, "value.go")
+	if err := os.WriteFile(goFile, []byte(declaration), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, goFile, declaration, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("example.invalid/framefixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: make(map[string]FuncSig),
+		ResolveSym: func(symbol string) string { return typed.Path() + "." + strings.TrimPrefix(symbol, "·") }}
+	for _, name := range []string{"Value", "Ordinary"} {
+		sig, err := DeriveGoFuncABI0Signature(typed.Path()+"."+name, typed.Scope().Lookup(name).(*types.Func), "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}, request, file, options, assembly
+}
+
+func TestGoAMD64FixedLocalMixedOrdinaryEntries(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, ordinaryFirst := range []bool{false, true} {
+		order := "frame-first"
+		if ordinaryFirst {
+			order = "ordinary-first"
+		}
+		t.Run(order, func(t *testing.T) {
+			pkg, request, _, options, _ := fixedLocalMixedEntriesFixture(t, ordinaryFirst)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil || strings.Count(ir, "define ") != 2 || strings.Count(ir, "%fixed_local_native = alloca") != 1 ||
+					!strings.Contains(ir, pkg.Path+".Value") || !strings.Contains(ir, pkg.Path+".Ordinary") {
+					t.Fatal("mixed full source did not retain exactly one private frame and both ordinary ABI0 entries", err)
+				}
+				compileLLVMToObject(t, llc, options.TargetTriple, "mixed.ll", "mixed.o", ir)
+				compileLLVMToObject(t, llc, options.TargetTriple, "mixed-opt.ll", "mixed-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalMixedEntryInventoryAndRevocation(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request, file, options, assembly := fixedLocalMixedEntriesFixture(t, false)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frameName, ordinaryName := pkg.Path+".Value", pkg.Path+".Ordinary"
+	frameBinding := bound.Sigs[frameName].x86FixedLocal
+	if len(source.functions) != 2 || len(bound.Sigs) != 2 || frameBinding == nil || bound.Sigs[ordinaryName].x86FixedLocal != nil {
+		t.Fatal("complete inventory was confused with per-function private-frame permission")
+	}
+	for _, mutation := range []string{"omit ordinary", "ordinary signature", "borrow frame", "detach frame", "crop source"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := bound
+			changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			frame, ordinary := changed.Sigs[frameName], changed.Sigs[ordinaryName]
+			frame.x86FixedLocal = frameBinding
+			changedFile := *file
+			switch mutation {
+			case "ordinary signature":
+				ordinary.Args[0] = I64
+			case "borrow frame":
+				ordinary.x86FixedLocal = frameBinding
+			case "detach frame":
+				frame.x86FixedLocal = nil
+			case "crop source":
+				changedFile.Funcs = file.Funcs[:1]
+			}
+			changed.Sigs[frameName], changed.Sigs[ordinaryName] = frame, ordinary
+			if mutation == "omit ordinary" {
+				delete(changed.Sigs, ordinaryName)
+			}
+			ir, err := Translate(&changedFile, changed)
+			fixedLocalRequireContext(t, ir, err)
+		})
+	}
+	// A body with no frame capability remains part of the revocable complete
+	// source identity. Changing it must revoke the sibling's backing as well.
+	changed := strings.Replace(assembly, "MOVQ (AX),AX", "MOVQ 8(AX),AX", 1)
+	if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(changed), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("ordinary sibling mutation retained the complete source owner", err)
+	}
+	ir, err := Translate(file, bound)
+	fixedLocalRequireContext(t, ir, err)
+}
+
+func TestGoAMD64FixedLocalMixedEntryRejectsUnclosedRoles(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, role := range []string{"source call", "private helper"} {
+		t.Run(role, func(t *testing.T) {
+			pkg, request, _, _, assembly := fixedLocalMixedEntriesFixture(t, false)
+			if role == "source call" {
+				assembly = strings.Replace(assembly, "TEXT ·Value(SB),4,$160-40", "TEXT ·Value(SB),$160-40\nCALL runtime·morestack_noctxt(SB)", 1)
+			} else {
+				assembly += "TEXT helper<>(SB),4,$0-0\nRET\n"
+			}
+			if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil {
+				source.Close()
+			}
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ordinary sibling invented a source-call or private-entry contract", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_native_address_objects_go127_test.go b/amd64_fixed_local_native_address_objects_go127_test.go
new file mode 100644
index 000000000..187f213da
--- /dev/null
+++ b/amd64_fixed_local_native_address_objects_go127_test.go
@@ -0,0 +1,14 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestGoAMD64FixedLocalNativeAddressObjects(t *testing.T) {
+	rows := fixedLocalNativeAddressCases()
+	if len(rows) != 17 {
+		t.Fatal("complete native-address source inventory changed", len(rows))
+	}
+	assembly, declarations := fixedLocalPointerChoiceProgram(t, fixedLocalChoiceData, rows)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(rows))
+}
diff --git a/amd64_fixed_local_native_address_test.go b/amd64_fixed_local_native_address_test.go
new file mode 100644
index 000000000..10197ad55
--- /dev/null
+++ b/amd64_fixed_local_native_address_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Every read below is valid for both runtime choices when the native input
+// points to its actual test buffer. A possible literal in the abstract state
+// is not proof that an out-of-range literal access is executed.
+func fixedLocalNativeAddressCases() []fixedLocalPointerChoiceCase {
+	selected := "LEAQ choice<>(SB),CX\nCMPQ AX,$0\nCMOVQNE SI,CX\n"
+	guarded := "CMPQ AX,$0\nJE literal\nMOVOU 128(CX),X0\nJMP read\nliteral:\nMOVOU (CX),X0\nread:\nMOVQ X0,AX"
+	return []fixedLocalPointerChoiceCase{
+		{"two actual read paths", selected + guarded},
+		{"unexecuted out-of-range candidate", selected + "CMPQ AX,$0\nJE done\nMOVQ 128(CX),AX\ndone:"},
+		{"CFG preserves actual address", "CMPQ AX,$0\nJE choose\nMOVQ SI,CX\nJMP join\nchoose:\nLEAQ choice<>(SB),CX\njoin:\n" + guarded},
+		{"private spill preserves actual address", selected + "MOVQ CX,8(SP)\nMOVQ 8(SP),CX\n" + guarded},
+		{"exact address excursion returns before read", "LEAQ choice<>(SB),CX\nADDQ $128,CX\nSUBQ $128,CX\nMOVQ (CX),AX"},
+		{"source address expression returns before read", "LEAQ choice<>+128(SB),CX\nSUBQ $128,CX\nMOVQ (CX),AX"},
+		{"dynamic affine literal address", "MOVQ AX,DX\nANDQ $7,DX\nSHLQ $3,DX\nLEAQ choice<>(SB),CX\nADDQ DX,CX\nMOVQ (CX),AX"},
+		{"dynamic affine selected address", selected + "MOVQ AX,DX\nANDQ $7,DX\nSHLQ $3,DX\nADDQ DX,CX\nMOVQ (CX),AX"},
+		{"finite address loop converges", selected + "MOVQ $4,R11\nagain:\nADDQ $8,CX\nDECQ R11\nJNE again\nMOVQ (CX),AX"},
+		{"native compare retains carry flags", selected + "CMPQ CX,CX\nCMOVQCC DI,CX\nMOVQ (CX),AX"},
+		{"native address arithmetic retains carry flags", selected + "ADDQ $0,CX\nCMOVQCC DI,CX\nMOVQ (CX),AX"},
+		{"more than four source choices", fixedLocalChoiceCountBody(8)},
+		{"former fifth alternative limit", fixedLocalChoiceCountBody(5)},
+		{"dynamic indexed selected address", selected + "MOVQ AX,DX\nANDQ $7,DX\nMOVQ (CX)(DX*8),AX"},
+		{"indexed joined literals", "LEAQ choice<>(SB),CX\nLEAQ other<>(SB),DX\nCMPQ AX,$0\nCMOVQEQ DX,CX\nMOVQ $1,DX\nMOVQ (CX)(DX*8),AX"},
+		{"dynamic indexed literal address", "MOVQ AX,DX\nANDQ $7,DX\nSHLQ $3,DX\nLEAQ choice<>(SB),CX\nMOVQ (CX)(DX*1),AX"},
+		{"dynamic indexed literal LEA", "MOVQ AX,DX\nANDQ $7,DX\nLEAQ choice<>(SB),CX\nLEAQ (CX)(DX*8),CX\nMOVQ (CX),AX"},
+	}
+}
+
+func TestGoAMD64FixedLocalNativeAddressCompleteSources(t *testing.T) {
+	var assembly strings.Builder
+	assembly.WriteString(fixedLocalChoiceData)
+	for index, row := range fixedLocalNativeAddressCases() {
+		fn, sig, source := fixedLocalPointerChoiceFixture(t, row.body)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("complete original native address operation was rejected", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+}
+
+func TestGoAMD64FixedLocalNativeAddressRetainsBoundaries(t *testing.T) {
+	t.Run("native address has machine bits", func(t *testing.T) {
+		fn, sig, _ := fixedLocalPointerChoiceFixture(t, fixedLocalChoicePrefix+"XORQ CX,AX")
+		if _, err := proveX86FixedLocal(fn, sig); err != nil {
+			t.Fatal("complete native arithmetic source rejected", err)
+		}
+	})
+	for _, row := range []fixedLocalPointerChoiceCase{
+		{"known literal read exceeds object", "LEAQ choice<>(SB),CX\nMOVQ 64(CX),AX"},
+		{"known literal vector crosses object", "LEAQ choice<>(SB),CX\nMOVOU 56(CX),X0\nMOVQ X0,AX"},
+		{"known indexed literal exceeds object", "LEAQ choice<>(SB),CX\nMOVQ $8,DX\nMOVQ (CX)(DX*8),AX"},
+		{"known readonly write", "LEAQ choice<>(SB),CX\nMOVQ AX,(CX)"},
+		{"readonly alternative does not grant write", fixedLocalChoicePrefix + "MOVQ AX,(CX)"},
+		{"other object does not establish adjacency", "LEAQ choice<>+64(SB),CX\nLEAQ other<>(SB),DX\nMOVQ (CX),AX"},
+		{"private address cannot merge with native", "LEAQ 8(SP),CX\nCMPQ AX,$0\nCMOVQEQ SI,CX\nMOVQ (CX),AX"},
+		{"partial register address is undefined", fixedLocalChoicePrefix + "MOVL CX,DX\nMOVQ (DX),AX"},
+		{"partial spilled address is undefined", fixedLocalChoicePrefix + "MOVQ CX,8(SP)\nMOVB $1,9(SP)\nMOVQ 8(SP),DX\nMOVQ (DX),AX"},
+		{"unknown input is not an address", "CMPQ AX,$0\nCMOVQEQ SI,R12\nMOVQ (R12),AX"},
+		{"numeric input is not an address", "MOVQ $1,CX\nMOVQ (CX),AX"},
+		{"unknown index is not numerical", fixedLocalChoicePrefix + "MOVQ (CX)(R12*8),AX"},
+		{"private index is not numerical", fixedLocalChoicePrefix + "MOVQ (CX)(SP*1),AX"},
+		{"address index is not numerical", fixedLocalChoicePrefix + "MOVQ (CX)(DI*8),AX"},
+		{"partial index is undefined", fixedLocalChoicePrefix + "MOVW $1,R12\nMOVQ (CX)(R12*8),AX"},
+		{"equality does not grant readonly write", fixedLocalChoicePrefix + "CMPQ CX,R8\nJNE done\nMOVQ AX,(CX)\ndone:"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, source := fixedLocalPointerChoiceFixture(t, row.body)
+			if row.name == "numeric input is not an address" {
+				fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p,q *uint64,a uint64) uint64",
+					"MOVQ (CX),AX", 0, 8, false, "load volatile i64")
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("native address acquired unrelated storage or numerical permission", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_native_numeric_runtime_test.go b/amd64_fixed_local_native_numeric_runtime_test.go
new file mode 100644
index 000000000..2040899f5
--- /dev/null
+++ b/amd64_fixed_local_native_numeric_runtime_test.go
@@ -0,0 +1,109 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Called from the existing dead-read fault root, retaining its cross-runtime
+// owner. Original Go checks valid unaligned accesses; the shared independent
+// byte reference checks NULL and short-page faults in owned child processes.
+func fixedLocalNativeNumericAddressRuntime(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	assembly, declarations := fixedLocalNativeNumericRuntimeSources(t)
+	var goCalls, prototypes, rows, validCalls strings.Builder
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	for ordinal := 0; ordinal < 8; ordinal++ {
+		width := 1 << uint(ordinal%4)
+		fmt.Fprintf(&goCalls, `
+    for i := range buffer { buffer[i] = 0x91 }
+    if Value%d(&address,&output,0) != 23063 { t.Fatal("original value %d") }
+`, ordinal, ordinal)
+		if ordinal >= 4 {
+			fmt.Fprintf(&goCalls, `
+    for i, value := range buffer {
+        want := byte(0x91)
+        if i >= 1 && i < 1+%d { want = 0 }
+        if i == 1 { want = 17 }
+        if value != want { t.Fatal("original exact store", %d, i, value, want) }
+    }
+`, width, ordinal)
+		}
+		fmt.Fprintf(&prototypes, "extern uint64_t value%d(const uint64_t *,uint64_t *,uint64_t) __asm__(%q);\n",
+			ordinal, prefix+"example.invalid/framefixture.Value"+fmt.Sprint(ordinal))
+		// The first pointer is always a valid local word. Only the loaded
+		// initialized NUM word contains the faulting effective address.
+		fmt.Fprintf(&prototypes, `
+static int run%d(const uint8_t *p) {
+    uint64_t address = (uint64_t)(uintptr_t)p, output = 0;
+    return value%d(&address, &output, 0) != 23063;
+}
+`, ordinal, ordinal)
+		fmt.Fprintf(&rows, "{run%d,%d,%d},\n", ordinal, width, width-1)
+		fmt.Fprintf(&validCalls, "memset(buffer,0x91,sizeof buffer);\nif(value%d(&address,&output,0)!=23063)return %d;\n", ordinal, 10+ordinal)
+		if ordinal >= 4 {
+			fmt.Fprintf(&validCalls, `
+for(unsigned i=0;i<sizeof buffer;i++) {
+    unsigned want=0x91;
+    if(i>=1 && i<1+%d) want=0;
+    if(i==1) want=17;
+    if(buffer[i]!=want) return %d;
+}
+`, width, 30+ordinal)
+		} else {
+			validCalls.WriteString("for(unsigned i=0;i<sizeof buffer;i++)if(buffer[i]!=0x91)return 50;\n")
+		}
+	}
+	original := `package framefixture
+import (
+    "runtime"
+    "testing"
+    "unsafe"
+)
+var originalNumericBuffer *[17]byte
+func TestOriginal(t *testing.T) {
+    buffer := [17]byte{}
+    originalNumericBuffer = &buffer
+    address := uint64(uintptr(unsafe.Pointer(&buffer[1])))
+    output := uint64(0)
+` + goCalls.String() + `
+    runtime.KeepAlive(&buffer)
+}
+`
+	fixedLocalPackedRunOriginal(t, execution, assembly, declarations, original, true)
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	driver := x86MemoryFaultDriver(prototypes.String(), rows.String())
+	// This independent valid-input executable owns all post-call byte checks.
+	// A fault probe never reads its invalid pointer after the translated call.
+	validDriver := "#include <stdint.h>\n#include <string.h>\n" + prototypes.String() + `
+int main(void) {
+    uint8_t buffer[17];
+    uint64_t address=(uint64_t)(uintptr_t)&buffer[1],output=0;
+` + validCalls.String() + "return 0;\n}\n"
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, pipeline := range []struct{ name, level, source string }{
+			{"backend_O0", "-O0", ir},
+			{"IR_O2_backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+		} {
+			t.Run(pipeline.name, func(t *testing.T) {
+				compileLLVMToObject(t, execution.llc, triple, "native-numeric-fault.ll", "native-numeric-fault.o", pipeline.source)
+				execution.compileAndRunLLVM(t, "native-numeric-valid", pipeline.source, validDriver, pipeline.level)
+				executable := execution.compileLLVM(t, "native-numeric-fault", pipeline.source, driver, pipeline.level)
+				x86CheckMemoryFaultMatrix(t, execution, executable, 8)
+			})
+		}
+	})
+}
diff --git a/amd64_fixed_local_native_numeric_test.go b/amd64_fixed_local_native_numeric_test.go
new file mode 100644
index 000000000..6b10dc02c
--- /dev/null
+++ b/amd64_fixed_local_native_numeric_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalRequireNumericNativeRole(t *testing.T, fn Func, base Reg) {
+	t.Helper()
+	ctx := amd64Ctx{fixedLocal: fn.x86FixedLocal}
+	found := false
+	for _, ins := range fn.Instrs {
+		for index, operand := range ins.Args {
+			if operand.Kind != OpMem || operand.Mem.Base != base {
+				continue
+			}
+			access, valid := ctx.fixedLocalMemoryAccess(ins, index)
+			if !valid || !access.nativeInput || ctx.fixedLocalMemoryCertified(ins, index) {
+				t.Fatal("numerical native access acquired private storage", ins.Raw, access)
+			}
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("missing original numerical native access", base)
+	}
+}
+
+// These ordinary source programs establish machine bits independently of
+// pointer types. The access keeps a native address, never a private offset.
+func TestGoAMD64FixedLocalNativeNumericWidths(t *testing.T) {
+	var assembly strings.Builder
+	count := 0
+	for _, register := range []string{"BX", "BP", "R14"} {
+		for _, suffix := range []string{"B", "W", "L", "Q"} {
+			for _, operation := range []string{
+				"MOV%s (%s),CX",
+				"MOV%s $17,(%s)",
+				"ADD%s $1,(%s)",
+			} {
+				accessSource := fmt.Sprintf(operation, suffix, register)
+				body := "MOVQ AX," + register + "\n" + accessSource + "\nMOVQ $0,AX"
+				fn, sig, source := fixedLocalInputFixture(t, body)
+				assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", count), 1))
+				count++
+				t.Run(register+"/"+accessSource, func(t *testing.T) {
+					proved, err := proveX86FixedLocal(fn, sig)
+					if err != nil {
+						t.Fatal("complete numerical machine address rejected", err)
+					}
+					found := false
+					ctx := amd64Ctx{fixedLocal: proved.x86FixedLocal}
+					for _, ins := range proved.Instrs {
+						if ins.Raw != accessSource {
+							continue
+						}
+						for index, access := range ins.x86FixedLocalMemory {
+							found = true
+							if !access.nativeInput || access.owner != proved.x86FixedLocal || ctx.fixedLocalMemoryCertified(ins, index) {
+								t.Fatal("native numerical access acquired private storage", access)
+							}
+						}
+					}
+					if !found {
+						t.Fatal("original numerical access lost its exact source binding")
+					}
+				})
+			}
+		}
+	}
+	if count != 36 {
+		t.Fatal("GP bank/width/effect inventory changed", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+}
+
+func TestGoAMD64FixedLocalNativeNumericProducers(t *testing.T) {
+	for _, body := range []string{
+		"MOVQ (SI),R14\nMOVQ (R14),AX",
+		"MOVQ (SI),CX\nMOVQ 32(SI),DX\nADDQ DX,CX\nMOVQ CX,8(SP)\nMOVQ 8(SP),R14\nSUBQ AX,R14\nMOVQ (R14),AX",
+		"MOVQ AX,R14\nMOVQ $2,CX\nLEAQ -8(R14)(CX*4),R14\nMOVQ (R14),AX",
+		"MOVQ $0,R14\nMOVQ (R14),CX\nMOVQ $0,AX",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", "/"), func(t *testing.T) {
+			fn, sig, _ := fixedLocalInputFixture(t, body)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("native numerical address lost an initialized producer", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalNativeNumericGuards(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown base":             "MOVQ (R14),AX",
+		"partial base":             "MOVW $0,R14\nMOVQ (R14),AX",
+		"unknown index":            "MOVQ AX,R14\nMOVQ (R14)(R15*1),AX",
+		"partial index":            "MOVQ AX,R14\nMOVW $0,R15\nMOVQ (R14)(R15*1),AX",
+		"private address bits":     "MOVQ SP,R14\nXORQ $1,R14\nMOVQ (R14),AX",
+		"private address store":    "MOVQ AX,R14\nMOVQ SP,CX\nMOVQ CX,(R14)",
+		"private missing byte":     "MOVQ AX,R14\nMOVQ 8(SP),CX\nMOVQ CX,(R14)",
+		"private range":            "MOVQ AX,R14\nMOVQ (R14),CX\nMOVQ CX,60(SP)",
+		"opaque partial overwrite": "MOVB $0,SI\nMOVQ (SI),AX",
+		"unknown incoming R14":     "ADDQ $0,R14\nMOVQ (R14),AX",
+		"unknown path":             "CMPQ AX,$0\nJEQ known\nJMP join\nknown:\nMOVQ AX,R14\njoin:\nMOVQ (R14),AX",
+		"segment":                  "MOVQ AX,R14\nMOVQ (R14)(FS*1),AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalInputFixture(t, body)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown bytes or private address acquired a native role", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalNativeNumericObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations := fixedLocalNativeNumericRuntimeSources(t)
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			fixedLocalConversionPrepareToolCache(t, request)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if strings.Count(input, "load volatile i64") < 8 || strings.Count(input, "store volatile") < 4 {
+						t.Fatal("native address producer or dead access lost its observable effect")
+					}
+					compileLLVMToObject(t, llc, target.triple, "native-numeric.ll", "native-numeric.o", input)
+				}
+			})
+		})
+	}
+}
+
+func fixedLocalNativeNumericRuntimeSources(t *testing.T) (string, string) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	for _, store := range []bool{false, true} {
+		for index, suffix := range []string{"B", "W", "L", "Q"} {
+			ordinal := index
+			access := "MOV" + suffix + " (R14),CX"
+			if store {
+				ordinal += 4
+				access = "MOV" + suffix + " $17,(R14)"
+			}
+			body := "MOVQ (SI),R14\nMOVQ R14,8(SP)\nMOVQ 8(SP),R14\nADDQ $3,R14\nSUBQ $3,R14\n" + access + "\nMOVQ $23063,AX"
+			_, _, source := fixedLocalInputFixture(t, body)
+			assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", ordinal), 1))
+			fmt.Fprintf(&declarations, "func Value%d(p, q *uint64, a uint64) uint64\n", ordinal)
+		}
+	}
+	return assembly.String(), declarations.String()
+}
diff --git a/amd64_fixed_local_native_scalar_observable_test.go b/amd64_fixed_local_native_scalar_observable_test.go
new file mode 100644
index 000000000..417c0d039
--- /dev/null
+++ b/amd64_fixed_local_native_scalar_observable_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalNativeScalarDeadAccesses(t *testing.T) {
+	const declaration = "func Value(p,q *uint64,a uint64) uint64"
+	const triple = "x86_64-unknown-linux-gnu"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, row := range []string{
+		"SQRTSS (%s),X1", "SQRTSD (%s),X1",
+		"VSQRTSS (%s),X1,X2", "VSQRTSD (%s),X1,X2",
+		"ADDSS (%s),X1", "ADDSD (%s),X1",
+		"VADDSS (%s),X1,X2", "VADDSD (%s),X1,X2",
+		"VMOVSS (%s),X1", "VMOVSD (%s),X1",
+		"VMOVSS X1,(%s)", "VMOVSD X1,(%s)",
+		"ADDB (%s),CL", "ADDW (%s),CX", "ADDL (%s),CX", "ADDQ (%s),CX",
+	} {
+		for _, base := range []string{"AX", "BP"} {
+			operation := fmt.Sprintf(row, base)
+			t.Run(operation, func(t *testing.T) {
+				body := "MOVQ $1,CX\nMOVQ CX,X1\nMOVQ $0,AX\nMOVQ AX," + base + "\n" +
+					operation + "\nMOVQ $0,AX"
+				_, _, assembly := fixedLocalInputFixture(t, body)
+				pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", triple)
+				captureStage, captureCancel := runtimeOracleStageContext(t)
+				source, err := CaptureGoAMD64FrameSource(captureStage, pkg, request)
+				captureCancel()
+				if strings.HasPrefix(operation, "VMOV") {
+					x86LEAActualTargetGoObject(t, "amd64", triple, assembly)
+					if source != nil {
+						if closeErr := source.Close(); closeErr != nil {
+							t.Error(closeErr)
+						}
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) ||
+						!strings.Contains(err.Error(), "unregistered or truncated whole native VEX/EVEX encoding") {
+						t.Fatal("unclosed scalar-move object producer acquired source facts", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := source.Close(); err != nil {
+						t.Error(err)
+					}
+				})
+				original, err := goAMD64FrameRead(filepath.Join(request.Directory, request.AssemblyFile))
+				if err != nil {
+					t.Fatal(err)
+				}
+				expanded, err := source.preprocess(request.AssemblyFile, original)
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := ParseWithDefines(ArchAMD64, expanded, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				stage, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				bound, err := source.BindFixedLocal(stage, pkg, file, options)
+				if !strings.HasPrefix(operation, "ADD") || strings.HasPrefix(operation, "ADDSS") || strings.HasPrefix(operation, "ADDSD") {
+					x86LEAActualTargetGoObject(t, "amd64", triple, assembly)
+					if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "unregistered instruction shape") {
+						t.Fatal("unregistered scalar floating family acquired a fixed-local owner", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal("original scalar source lacks its fixed-local owner", err)
+				}
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86PackedFloatStorageAPI(api, file, bound)
+						if err != nil || ir == "" {
+							t.Fatal("original scalar source did not translate", err)
+						}
+						for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							observable := regexp.MustCompile(`\b(?:load|store) volatile i(?:8|16|32|64)\b`).MatchString(text)
+							for _, line := range strings.Split(text, "\n") {
+								observable = observable || strings.Contains(line, "asm sideeffect") &&
+									strings.Contains(line, "~{memory}") && strings.Contains(line, "*m")
+							}
+							if !observable {
+								t.Fatal("dead scalar native access lost its observable memory effect", operation, api, text)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, text, level)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_native_vector_input_test.go b/amd64_fixed_local_native_vector_input_test.go
new file mode 100644
index 000000000..eb3ac886f
--- /dev/null
+++ b/amd64_fixed_local_native_vector_input_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalNativeVectorConsumers(t *testing.T) {
+	// Independent semantic/transport witnesses. The complete spelling and
+	// format inventories remain with each family's original Go-table owners.
+	type witness struct {
+		family, instruction string
+		operand             int
+		width               int64
+		write               bool
+	}
+	rows := []witness{
+		{"wrapping-add", "PADDQ (%s),X1", 0, 16, false},
+		{"subtract", "PSUBQ (%s),X1", 0, 16, false},
+		{"logical", "PAND (%s),X1", 0, 16, false},
+		{"word-multiply", "PMULLW (%s),X1", 0, 16, false},
+		{"word-madd", "PMADDWL (%s),X1", 0, 16, false},
+		{"average", "PAVGB (%s),X1", 0, 16, false},
+		{"compare", "PCMPEQB (%s),X1", 0, 16, false},
+		{"shuffle-bytes", "PSHUFB (%s),X1", 0, 16, false},
+		{"shuffle-words", "PSHUFD $0,(%s),X1", 1, 16, false},
+		{"unpack", "PUNPCKLBW (%s),X1", 0, 16, false},
+		{"pack", "PACKSSWB (%s),X1", 0, 16, false},
+		{"integer-minmax", "PMINUB (%s),X1", 0, 16, false},
+		{"horizontal", "PHADDW (%s),X1", 0, 16, false},
+		{"SAD", "PSADBW (%s),X1", 0, 16, false},
+		{"AES", "AESENC (%s),X1", 0, 16, false},
+		{"CLMUL", "PCLMULQDQ $0,(%s),X1", 1, 16, false},
+		{"packed-conversion-X", "VCVTTPS2DQ (%s),X1", 0, 16, false},
+		{"packed-conversion-Y", "VCVTDQ2PD (%s),Y1", 0, 16, false},
+	}
+	for _, bank := range []struct {
+		name  string
+		width int64
+	}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+		rows = append(rows,
+			witness{"aligned-masked-load-" + bank.name, "VMOVDQA64.Z (%s),K1," + bank.name + "1", 0, bank.width, false},
+			witness{"aligned-masked-store-" + bank.name, "VMOVDQA64 " + bank.name + "1,K1,(%s)", 2, bank.width, true})
+	}
+	for _, row := range rows {
+		for _, base := range []string{"AX", "BP"} {
+			t.Run(row.family+"/"+base, func(t *testing.T) {
+				operation := fmt.Sprintf(row.instruction, base)
+				body := "VMOVDQU8 (SI),Z0\nVMOVDQU8 (SI),Z1\nVMOVDQU8 (SI),Z2\n" +
+					"MOVQ $1,CX\nKMOVQ CX,K1\nMOVQ AX," + base + "\n" + operation + "\nMOVQ $0,AX"
+				fn, sig, assembly := fixedLocalInputFixture(t, body)
+				switch row.family {
+				case "SAD", "horizontal", "integer-minmax", "pack", "unpack":
+					// These legal instructions retain a separate fixed-local
+					// owner boundary, before this native-address consumer.
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", assembly)
+					if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) ||
+						!strings.Contains(err.Error(), "unregistered instruction shape") {
+						t.Fatal("unregistered private family acquired a source owner", err)
+					}
+					return
+				}
+				emitted := strings.ToLower(strings.Split(operation, " ")[0])
+				emitted, _, _ = strings.Cut(emitted, ".")
+				if emitted == "pmaddwl" {
+					emitted = "pmaddwd" // Go's Plan 9 word-to-long spelling.
+				}
+				fixedLocalRequireNumericControl(t, fn, sig, assembly,
+					"func Value(p,q *uint64,a uint64) uint64", operation, row.operand, row.width, row.write,
+					emitted)
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalNativeMemoryRoleGuards(t *testing.T) {
+	const operation = "PADDQ (BP),X1"
+	body := "VMOVDQU8 (SI),Z1\nMOVQ AX,BP\n" + operation + "\nMOVQ $0,AX"
+	fn, sig, _ := fixedLocalInputFixture(t, body)
+	proved, err := proveX86FixedLocal(fn, sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := amd64Ctx{fixedLocal: proved.x86FixedLocal, goarch: "amd64"}
+	var original Instr
+	for _, ins := range proved.Instrs {
+		if ins.Raw == operation {
+			original = ins
+		}
+	}
+	if original.Op == "" || x86OrdinaryNativeMemoryOperand(original.Args[0], "amd64") ||
+		!ctx.nativeMemoryOperand(original, 0) || ctx.fixedLocalMemoryCertified(original, 0) {
+		t.Fatal("the exact native BP role became ordinary or private storage")
+	}
+	for _, row := range []struct {
+		name   string
+		change func(*amd64Ctx, *Instr)
+	}{
+		{"missing-owner", func(c *amd64Ctx, _ *Instr) { c.fixedLocal = nil }},
+		{"other-owner", func(c *amd64Ctx, _ *Instr) { c.fixedLocal = new(x86FixedLocalProof) }},
+		{"missing-record", func(_ *amd64Ctx, i *Instr) { i.x86FixedLocalMemory = nil }},
+		{"changed-shape", func(_ *amd64Ctx, i *Instr) { i.Args[0].Mem.Off++ }},
+		{"raw", func(_ *amd64Ctx, i *Instr) { i.x86Encoded = true }},
+		{"address-size", func(_ *amd64Ctx, i *Instr) { i.x86AddressBits = 32 }},
+		{"changed-role", func(_ *amd64Ctx, i *Instr) {
+			access := i.x86FixedLocalMemory[0]
+			access.nativeInput = false
+			i.x86FixedLocalMemory = map[int]x86FixedLocalAccess{0: access}
+		}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			consumer, changed := ctx, original
+			changed.Args = append([]Operand(nil), original.Args...)
+			row.change(&consumer, &changed)
+			if consumer.nativeMemoryOperand(changed, 0) || consumer.fixedLocalMemoryCertified(changed, 0) {
+				t.Fatal("a stale native record acquired an address or private certificate")
+			}
+		})
+	}
+	for _, prefix := range []string{"", "MOVW AX,BP\n"} {
+		changed, layout, _ := fixedLocalInputFixture(t,
+			"VMOVDQU8 (SI),Z1\n"+prefix+operation+"\nMOVQ $0,AX")
+		if _, err := proveX86FixedLocal(changed, layout); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unknown or partial BP bits acquired a native memory role", prefix, err)
+		}
+	}
+	private, layout, _ := fixedLocalVEXFixture(t, "PADDQ 64(BP),X1")
+	private, err = proveX86FixedLocal(private, layout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := amd64Ctx{fixedLocal: private.x86FixedLocal, goarch: "amd64"}
+	for _, ins := range private.Instrs {
+		if ins.Raw == "PADDQ 64(BP),X1" {
+			if consumer.nativeMemoryOperand(ins, 0) || !consumer.fixedLocalMemoryCertified(ins, 0) {
+				t.Fatal("a private BP extent was reclassified as native input")
+			}
+			return
+		}
+	}
+	t.Fatal("missing original private BP control")
+}
diff --git a/amd64_fixed_local_nontemporal_test.go b/amd64_fixed_local_nontemporal_test.go
new file mode 100644
index 000000000..37fd8cfed
--- /dev/null
+++ b/amd64_fixed_local_nontemporal_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalNonTemporalOperation(name, bank string, vector, load bool) string {
+	if load {
+		return name + " 64(BP)," + bank + "0\nMOVOU X0,128(BP)"
+	}
+	initialize := "MOVOU 64(BP),X0\n"
+	if vector {
+		initialize = "VMOVUPS 64(BP)," + bank + "0\n"
+	}
+	return initialize + name + " " + bank + "0,128(BP)\nSFENCE"
+}
+
+func TestGoAMD64FixedLocalNonTemporalCompleteFamilyProof(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, row := range x86NonTemporalNativeOracle {
+		banks := []string{"X"}
+		if row.vector {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			t.Run(row.name+"/"+bank, func(t *testing.T) {
+				operation := fixedLocalNonTemporalOperation(row.name, bank, row.vector, row.load)
+				pkg, _, file, options := fixedLocalPackedFixture(t, operation)
+				original.WriteString(strings.Replace(fixedLocalPackedAssembly(operation), "·Value", fmt.Sprint("·Value", count), 1))
+				count++
+				if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+					t.Error("native non-temporal access omitted its actual fixed-frame binding")
+				}
+				sig := options.Sigs[pkg.Path+".Value"]
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+					t.Fatalf("complete initialized non-temporal frame: %v", err)
+				}
+				memory, misaligned := "128(BP)", "129(BP)"
+				if row.load {
+					memory, misaligned = "64(BP)", "65(BP)"
+				}
+				for _, displacement := range []string{misaligned, "320(BP)"} {
+					changedOperation := strings.Replace(operation, memory, displacement, 1)
+					changed := fixedLocalPackedAssembly(changedOperation)
+					parsed, err := Parse(ArchAMD64, changed)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := proveX86FixedLocal(parsed.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("misaligned or out-of-frame bytes acquired native backing", displacement, err)
+					}
+				}
+			})
+		}
+	}
+	if count != 17 {
+		t.Fatal("independent fixed-frame non-temporal family is incomplete", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func fixedLocalNonTemporalActualObjects(t *testing.T, target, triple string) {
+	t.Helper()
+	t.Setenv("GOCACHE", t.TempDir())
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	var names []string
+	for _, row := range x86NonTemporalNativeOracle {
+		banks := []string{"X"}
+		if row.vector {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			name := fmt.Sprint("Stream", len(names))
+			names = append(names, "example.invalid/framefixture."+name)
+			operation := fixedLocalNonTemporalOperation(row.name, bank, row.vector, row.load)
+			assembly.WriteString(strings.Replace(fixedLocalPackedAssembly(operation), "·Value", "·"+name, 1))
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		}
+	}
+	if len(names) != 17 {
+		t.Fatal("complete independent fixed-frame non-temporal inventory changed", len(names))
+	}
+	pkg, request, _, options := x86CMOVFixedLocalFixture(t, assembly.String(), declarations.String(), target, triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil || strings.Count(ir, "%fixed_local_native = alloca") != len(names) {
+			t.Fatal("original non-temporal frame inventory lost its actual binding", err)
+		}
+		for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+			x86CompactExpandRequireAllDefinitions(t, text, names)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, text, level)
+			}
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalNonTemporalActualObjectsLinux(t *testing.T) {
+	fixedLocalNonTemporalActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestGoAMD64FixedLocalNonTemporalActualObjectsDarwin(t *testing.T) {
+	fixedLocalNonTemporalActualObjects(t, "darwin/amd64", "x86_64-apple-darwin")
+}
+
+func TestGoAMD64FixedLocalNonTemporalActualObjectsWindows(t *testing.T) {
+	fixedLocalNonTemporalActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc")
+}
diff --git a/amd64_fixed_local_numeric_controls_test.go b/amd64_fixed_local_numeric_controls_test.go
new file mode 100644
index 000000000..7652069aa
--- /dev/null
+++ b/amd64_fixed_local_numeric_controls_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// A complete NUM address owns this native access, never a private frame
+// offset, a caller allocation, or the standalone result observer's authority.
+func fixedLocalRequireNumericControl(t *testing.T, fn Func, sig FuncSig, assembly, declaration, operation string, operand int, width int64, write bool, emitted string) {
+	t.Helper()
+	if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("paired native access became a standalone result proof", err)
+	}
+	ordinal := -1
+	for index, ins := range fn.Instrs {
+		if ins.Raw == operation {
+			ordinal = index
+		}
+	}
+	if ordinal < 0 {
+		t.Fatal("original NUM operation is missing", operation)
+	}
+	goAMD64FramePrepareOwnedToolCache(t)
+	const triple = "x86_64-unknown-linux-gnu"
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", triple)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	original, err := goAMD64FrameRead(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := source.preprocess(request.AssemblyFile, original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err = ParseWithDefines(ArchAMD64, expanded, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stage, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(stage, pkg, file, options)
+	if err != nil {
+		t.Fatal("actual original NUM source did not bind", err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != len(fn.Instrs) ||
+		file.Funcs[0].Instrs[ordinal].Op != fn.Instrs[ordinal].Op || !reflect.DeepEqual(file.Funcs[0].Instrs[ordinal].Args, fn.Instrs[ordinal].Args) {
+		t.Fatal("actual preprocessing changed the original NUM operation", operation)
+	}
+	proved, err := proveX86FixedLocal(file.Funcs[0], bound.Sigs[pkg.Path+".Value"])
+	if err != nil {
+		t.Fatal("initialized NUM native source rejected", err)
+	}
+	ctx := amd64Ctx{fixedLocal: proved.x86FixedLocal}
+	found := false
+	for index, ins := range proved.Instrs {
+		if index != ordinal {
+			continue
+		}
+		access, valid := ctx.fixedLocalMemoryAccess(ins, operand)
+		if !valid || !access.nativeInput || ctx.fixedLocalMemoryCertified(ins, operand) ||
+			access.width != width || access.write != write || len(ins.x86CallerMemory) != 0 || ins.x86NumericalRead != nil {
+			t.Fatal("NUM access changed width/effect or acquired a separate storage role", operation, access)
+		}
+		found = true
+	}
+	if !found {
+		t.Fatal("original NUM operation lost its exact access", operation)
+	}
+	ir, err := Translate(file, bound)
+	if err != nil || !strings.Contains(ir, emitted) ||
+		!strings.Contains(ir, "volatile") && !strings.Contains(ir, "asm sideeffect") {
+		t.Fatal("NUM native instruction lost its emitted observable effect", emitted, err, ir)
+	}
+	x86NumericNativeAddressObject(t, ir, triple)
+}
diff --git a/amd64_fixed_local_numerical.go b/amd64_fixed_local_numerical.go
new file mode 100644
index 000000000..43b7a93b1
--- /dev/null
+++ b/amd64_fixed_local_numerical.go
@@ -0,0 +1,20 @@
+package plan9asm
+
+// Only an exact private read certificate supplies the SB bytes. The local
+// proof learns numerical definedness, never a constant, pointer or address.
+func fixedLocalNumericalReadStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	if ins.x86NumericalRead == nil {
+		return false, nil
+	}
+	if _, form, valid := numericalCertifiedRead(*ins, "amd64"); valid && form.spec.vector != x86NumericalSBScalar {
+		if !numericalVectorMapStep(*ins, "amd64", form, state.vectors, state.masks) {
+			return true, goAMD64FrameContext("fixed local numerical vector read needs its complete typed inputs")
+		}
+		return true, nil
+	}
+	effect, valid := x86NumericalReadEffect(*ins, "amd64")
+	if !valid {
+		return true, goAMD64FrameContext("fixed local numerical read certificate changed")
+	}
+	return true, fixedLocalTypedByteStep(ins, state, FuncSig{}, proof, residue, effect)
+}
diff --git a/amd64_fixed_local_original_test.go b/amd64_fixed_local_original_test.go
new file mode 100644
index 000000000..1e29f1006
--- /dev/null
+++ b/amd64_fixed_local_original_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// Shared by portable object tests and the Unix native runtime oracles.
+var fixedLocalNativeOperations = []string{
+	"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+	"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+}
+
+func fixedLocalPackedRunOriginal(t *testing.T, execution x86FloatCompareExecution, assembly, declarations, oracle string, execute bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":        "module example.invalid/framefixture\ngo 1.20\n",
+		"value.go":      "package framefixture\n" + declarations,
+		"value_amd64.s": assembly, "value_test.go": oracle,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, gotoolchain.HostExecutable("original.test"))
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-c", "-p=2", "-vet=off", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go packed-frame oracle: %v\n%s", err, output)
+	}
+	if execute {
+		t.Logf("original Go: %s", execution.run(t, binary, "-test.run=^TestOriginal$"))
+	}
+}
diff --git a/amd64_fixed_local_origins.go b/amd64_fixed_local_origins.go
new file mode 100644
index 000000000..06ae52b59
--- /dev/null
+++ b/amd64_fixed_local_origins.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+// An initialized machine address, separate from NUM and relocated private SP.
+// Roles describe its possible sources, not a proof of its runtime pointee
+// extent. Preserve one exact literal only while all literal alternatives agree.
+// Forgetting that detail never forgets the address or introduces permission.
+type x86FixedLocalOrigins struct {
+	address x86StaticSBAddress
+	roles   uint8
+}
+
+const (
+	fixedLocalNativeAddress uint8 = 1 << iota
+	fixedLocalGlobalAddress
+	fixedLocalLiteralAddress
+	fixedLocalAddressRoles = fixedLocalNativeAddress | fixedLocalGlobalAddress | fixedLocalLiteralAddress
+)
+
+// Retain the conservative per-entry charge used before address compaction.
+// Joins now update a fixed-size value and allocate no alternative-set tails.
+const fixedLocalOriginPayloadBytes int64 = 64
+
+func fixedLocalOriginStorage(state x86FixedLocalState) int64 {
+	bytes := fixedLocalOriginMapStorage(state.opaque) + fixedLocalOriginMapStorage(state.opaqueCells)
+	if state.savedBP != nil {
+		bytes += 2 * fixedLocalOriginPayloadBytes // Includes the immutable saved register facts.
+	}
+	return bytes
+}
+
+func fixedLocalOriginMapStorage[K comparable](values map[K]x86FixedLocalOrigins) int64 {
+	return int64(len(values)) * fixedLocalOriginPayloadBytes
+}
+
+func fixedLocalOrigin(origin x86FixedLocalOrigin) x86FixedLocalOrigins {
+	switch {
+	case origin.literal.symbol != "":
+		return x86FixedLocalOrigins{address: origin.literal, roles: fixedLocalLiteralAddress}
+	case origin.global != "":
+		return x86FixedLocalOrigins{roles: fixedLocalGlobalAddress}
+	default:
+		return x86FixedLocalOrigins{roles: fixedLocalNativeAddress}
+	}
+}
+
+func (origins x86FixedLocalOrigins) valid() bool {
+	return origins.roles != 0 && origins.roles&^fixedLocalAddressRoles == 0 &&
+		(origins.hasLiteral() || origins.address == (x86StaticSBAddress{}))
+}
+
+func (origins x86FixedLocalOrigins) equal(other x86FixedLocalOrigins) bool {
+	return origins == other
+}
+
+func (origins x86FixedLocalOrigins) union(other x86FixedLocalOrigins) (x86FixedLocalOrigins, bool) {
+	if !origins.valid() || !other.valid() {
+		return x86FixedLocalOrigins{}, false
+	}
+	address := origins.address
+	if !origins.hasLiteral() {
+		address = other.address
+	} else if other.hasLiteral() && address != other.address {
+		address = x86StaticSBAddress{}
+	}
+	return x86FixedLocalOrigins{address: address, roles: origins.roles | other.roles}, true
+}
+
+func (origins x86FixedLocalOrigins) hasLiteral() bool {
+	return origins.roles&fixedLocalLiteralAddress != 0
+}
+
+func (origins x86FixedLocalOrigins) readonly() bool {
+	return origins.roles&(fixedLocalGlobalAddress|fixedLocalLiteralAddress) != 0
+}
+
+func (origins x86FixedLocalOrigins) literal() (x86StaticSBAddress, bool) {
+	return origins.address, origins.roles == fixedLocalLiteralAddress && origins.address.symbol != ""
+}
+
+func fixedLocalOriginOwners(origins x86FixedLocalOrigins, proof *x86FixedLocalProof) bool {
+	if !origins.valid() {
+		return false
+	}
+	if !origins.hasLiteral() {
+		return true
+	}
+	if proof == nil || proof.binding == nil || len(proof.binding.literalData) == 0 {
+		return false
+	}
+	if origins.address.symbol == "" {
+		return true // Each original literal was checked before joining identities.
+	}
+	_, found := proof.binding.literalData[origins.address.symbol]
+	return found
+}
+
+func cloneFixedLocalOrigins[K comparable](input map[K]x86FixedLocalOrigins) map[K]x86FixedLocalOrigins {
+	result := make(map[K]x86FixedLocalOrigins, len(input))
+	for key, value := range input {
+		result[key] = value
+	}
+	return result
+}
+
+func mergeFixedLocalOrigins[K comparable](previous, current map[K]x86FixedLocalOrigins) (bool, error) {
+	changed := false
+	for key, old := range previous {
+		incoming, found := current[key]
+		if !found {
+			delete(previous, key) // Unknown on either path is still unknown.
+			changed = true
+			continue
+		}
+		merged, valid := old.union(incoming)
+		if !valid {
+			return false, goAMD64FrameContext("fixed local CFG has an invalid opaque address")
+		}
+		if merged != old {
+			previous[key] = merged
+			changed = true
+		}
+	}
+	return changed, nil
+}
+
+// Only the captured compared register is refined. Native addresses may equal
+// the literal. Excluding one unknown literal never excludes every readonly
+// alternative or turns an address into numerical bytes.
+func fixedLocalLiteralEdge(state x86FixedLocalState, op Op, taken bool) (x86FixedLocalState, bool) {
+	comparison := state.comparison
+	origins, found := state.opaque[comparison.register]
+	condition := x86BranchCondition(op)
+	if !found || !origins.valid() || condition != "EQ" && condition != "NE" {
+		return state, true
+	}
+	next := fixedLocalOrigin(x86FixedLocalOrigin{literal: comparison.literal})
+	if taken != (condition == "EQ") {
+		if origins.address != comparison.literal {
+			return state, true
+		}
+		next = x86FixedLocalOrigins{roles: origins.roles &^ fixedLocalLiteralAddress}
+	}
+	if next.roles == 0 {
+		return state, false
+	}
+	if next != origins {
+		state.opaque = cloneFixedLocalOrigins(state.opaque)
+		state.opaque[comparison.register] = next
+	}
+	return state, true
+}
diff --git a/amd64_fixed_local_origins_test.go b/amd64_fixed_local_origins_test.go
new file mode 100644
index 000000000..20e66e61c
--- /dev/null
+++ b/amd64_fixed_local_origins_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+	"unsafe"
+)
+
+var fixedLocalOriginBenchmarkState x86FixedLocalState
+
+func BenchmarkFixedLocalOriginState(b *testing.B) {
+	for _, entries := range []int{1, 8, 32} {
+		state := x86FixedLocalState{
+			pointers: make(map[Reg]int64), addresses: make(map[int64]int64),
+			opaqueCells: make(map[int64]x86FixedLocalOrigins),
+		}
+		for index := 0; index < entries; index++ {
+			state.opaqueCells[int64(index)*8] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: int64(index) * 8})
+		}
+		b.Run(fmt.Sprintf("clone/%d", entries), func(b *testing.B) {
+			b.ReportAllocs()
+			for index := 0; index < b.N; index++ {
+				fixedLocalOriginBenchmarkState = cloneFixedLocalState(state)
+			}
+		})
+		b.Run(fmt.Sprintf("join/%d", entries), func(b *testing.B) {
+			previous := cloneFixedLocalState(state)
+			b.ReportAllocs()
+			b.ResetTimer()
+			for index := 0; index < b.N; index++ {
+				if changed, err := mergeFixedLocalState(&previous, state); err != nil || changed {
+					b.Fatal("identical singleton states must be unchanged", changed, err)
+				}
+			}
+			fixedLocalOriginBenchmarkState = previous
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalOriginJoinStorageBudget(t *testing.T) {
+	previous := map[Reg]x86FixedLocalOrigins{AX: fixedLocalOrigin(x86FixedLocalOrigin{})}
+	current := map[Reg]x86FixedLocalOrigins{AX: fixedLocalOrigin(x86FixedLocalOrigin{
+		literal: x86StaticSBAddress{symbol: "choice<>"},
+	})}
+	before := fixedLocalOriginMapStorage(previous)
+	if changed, err := mergeFixedLocalOrigins(previous, current); err != nil || !changed {
+		t.Fatal("actual address join failed", changed, err)
+	}
+	if bytes := fixedLocalOriginMapStorage(previous); bytes != before || bytes != 64 {
+		t.Fatal("fixed-size address join changed the conservative per-entry charge", bytes)
+	}
+	for _, capacity := range []int64{63, 64} {
+		budget := x86FixedLocalBudget{bytes: capacity}
+		err := budget.consumeOrigins(before)
+		if errors.Is(err, ErrProbeNeedsContext) != (capacity < before) {
+			t.Fatal("cloning addresses bypassed its unchanged work bound", capacity, err)
+		}
+		if capacity < before && budget.bytes != capacity {
+			t.Fatal("failed work accounting partially consumed its budget")
+		}
+	}
+	allocations := testing.AllocsPerRun(10, func() {
+		previous[AX] = fixedLocalOrigin(x86FixedLocalOrigin{})
+		if _, err := mergeFixedLocalOrigins(previous, current); err != nil {
+			panic(err)
+		}
+	})
+	if allocations != 0 {
+		t.Fatal("address join allocated alternative-set storage", allocations)
+	}
+}
+
+func TestGoAMD64FixedLocalOriginValueStorage(t *testing.T) {
+	if size := unsafe.Sizeof(x86FixedLocalOrigins{}); size > uintptr(fixedLocalOriginPayloadBytes) || size > 128 {
+		t.Fatalf("address value is %d bytes, exceeding its charge or inline map threshold", size)
+	}
+}
+
+func TestGoAMD64FixedLocalOriginSetValueSemantics(t *testing.T) {
+	set := func(offsets ...int64) x86FixedLocalOrigins {
+		value := fixedLocalOrigin(x86FixedLocalOrigin{literal: x86StaticSBAddress{symbol: "choice<>", offset: offsets[0]}})
+		for _, offset := range offsets[1:] {
+			var valid bool
+			value, valid = value.union(fixedLocalOrigin(x86FixedLocalOrigin{literal: x86StaticSBAddress{symbol: "choice<>", offset: offset}}))
+			if !valid {
+				t.Fatal("complete native address join rejected")
+			}
+		}
+		return value
+	}
+	t.Run("invalid equal values remain unknown", func(t *testing.T) {
+		for _, value := range []x86FixedLocalOrigins{{}, {roles: 0x80}, {
+			roles: fixedLocalNativeAddress, address: x86StaticSBAddress{symbol: "foreign<>"},
+		}} {
+			previous := map[Reg]x86FixedLocalOrigins{AX: value}
+			if _, err := mergeFixedLocalOrigins(previous, map[Reg]x86FixedLocalOrigins{AX: value}); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("equal fast path granted an invalid address", err)
+			}
+		}
+	})
+	t.Run("independent order and duplicate joins", func(t *testing.T) {
+		for _, offsets := range [][]int64{{0, 8, 16}, {16, 0, 8}, {8, 16, 8, 0, 16}} {
+			first, second := set(0, 8, 16), set(offsets...)
+			previous := map[Reg]x86FixedLocalOrigins{AX: first}
+			if changed, err := mergeFixedLocalOrigins(previous, map[Reg]x86FixedLocalOrigins{AX: second}); err != nil || changed {
+				t.Fatal("address join did not converge independently of order", changed, err)
+			}
+			if first != second || previous[AX] != first || !first.readonly() {
+				t.Fatal("joining addresses lost readonly storage or changed a canonical value")
+			}
+		}
+	})
+	t.Run("union does not change either input", func(t *testing.T) {
+		first, second := set(0), fixedLocalOrigin(x86FixedLocalOrigin{})
+		merged, valid := first.union(second)
+		if !valid || !merged.hasLiteral() || merged.roles&fixedLocalNativeAddress == 0 ||
+			first != set(0) || second.hasLiteral() {
+			t.Fatal("union mutated an input or lost an address role")
+		}
+	})
+	t.Run("affine write does not change prior state", func(t *testing.T) {
+		fn, sig, _ := fixedLocalPointerChoiceFixture(t, "MOVQ (SI),AX")
+		proof := &x86FixedLocalProof{frame: fn.FrameSize, binding: sig.x86FixedLocal}
+		original := set(8)
+		state := x86FixedLocalState{
+			opaque: map[Reg]x86FixedLocalOrigins{AX: original},
+			known:  make(map[Reg]uint8), booleans: make(map[Reg]uint8),
+		}
+		ins := Instr{Op: "ADDQ", Args: []Operand{{Kind: OpImm, Imm: 8}, {Kind: OpReg, Reg: AX}}}
+		if handled, err := fixedLocalInputAddressStep(&ins, &state, sig, proof, 0); err != nil || !handled {
+			t.Fatal("exact affine write rejected", handled, err)
+		}
+		if !reflect.DeepEqual(original, set(8)) || !reflect.DeepEqual(state.opaque[AX], set(16)) {
+			t.Fatal("affine write changed the prior address value")
+		}
+	})
+}
diff --git a/amd64_fixed_local_packed.go b/amd64_fixed_local_packed.go
new file mode 100644
index 000000000..ecf461c88
--- /dev/null
+++ b/amd64_fixed_local_packed.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+// Reuse the complete source grammars and their byte effects. This adapter adds
+// independently replayed private-frame memory, typed native input addresses
+// and separately bound literal reads; it never supplies caller or raw access.
+func fixedLocalPackedMoveStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, known, err := amd64PackedVectorMoveProperties(*ins, "amd64")
+	legacy := false
+	alignment := int64(1)
+	if !known {
+		if original, recognized, originalErr := x86NonTemporalVectorProperties(ins.Op, *ins, "amd64"); recognized {
+			known, err, legacy = true, originalErr, !original.spec.vector
+			form = original.move
+			if original.trap {
+				return true, goAMD64FrameContext("fixed local non-temporal move has no numerical continuation")
+			}
+		}
+	}
+	if !known {
+		original, recognized, originalErr := x86LegacyPackedMoveProperties(ins.Op, *ins, "amd64")
+		if !recognized {
+			return false, nil
+		}
+		known, err, legacy = true, originalErr, true
+		form = amd64PackedVectorMoveForm{
+			byteWidth: 16, destination: 1, mask: -1,
+			memory: original.memory, memoryWrite: original.memoryWrite,
+		}
+		form.spec.aligned = original.aligned
+	}
+	if err != nil || form.undefinedOpcode() {
+		return known, goAMD64FrameContext("fixed local packed move has no numerical continuation")
+	}
+	if form.spec.aligned {
+		alignment = int64(form.byteWidth)
+	}
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return true, goAMD64FrameContext("fixed local packed move has an undefined mask")
+	}
+	width := int64(form.byteWidth)
+	widthMask := x86CallerVectorByteMask(width)
+	numerical := widthMask
+	if form.memory == 0 {
+		// The private proof does not model runtime mask values: require every
+		// possible read byte. Lowering still executes the original masked
+		// opcode, including its alignment and masked fault behavior.
+		if _, _, err := fixedLocalReadMemory(ins, 0, state, proof, residue, width, alignment); err != nil {
+			return true, err
+		}
+	} else {
+		numerical = state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)] & widthMask
+	}
+	if form.memoryWrite {
+		if numerical != widthMask {
+			return true, goAMD64FrameContext("fixed local packed store has undefined source bytes")
+		}
+		offset, role, err := fixedLocalMemoryAccess(ins, form.memory, state, proof, residue, width, alignment, true, false)
+		if err != nil {
+			return true, err
+		}
+		// A runtime mask is not an all-one mask. A partial store may invalidate
+		// a private pointer spill, but cannot initialize its retained bytes.
+		if role == x86FixedLocalPrivateMemory {
+			fixedLocalNumericalStore(state, offset, width, form.mask < 0)
+		}
+		return true, nil
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	previous := state.vectors[destination]
+	numerical = form.definedActiveBytes(numerical, previous)
+	if legacy {
+		state.vectors[destination] = previous&^widthMask | numerical
+	} else {
+		state.vectors[destination] = ^widthMask | numerical
+	}
+	return true, nil
+}
+
+func fixedLocalNumericalStore(state *x86FixedLocalState, offset, width int64, complete bool) {
+	fixedLocalRevokeSpillRoles(state, offset, width)
+	if complete {
+		state.bytes.setRange(offset, width, true)
+	}
+}
+
+// KMOV supplies numerical predicates through its existing four-width grammar.
+// Full-word private addresses never become mask values. Local reads/writes
+// retain the same byte envelope and owner as every other fixed-frame access.
+func fixedLocalMaskMoveStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	bits, known := amd64MaskMoveSpecs[ins.Op]
+	if !known {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local mask move has unproved shape or numerical bytes")
+	}
+	if !amd64MaskMoveOperandsValid(*ins, "amd64") {
+		return fail()
+	}
+	width := int64(bits / 8)
+	source, destination := ins.Args[0], ins.Args[1]
+	if source.Kind == OpMem || source.Kind == OpSym {
+		if _, _, err := fixedLocalReadMemory(ins, 0, state, proof, residue, width, 1); err != nil {
+			return true, err
+		}
+	} else if amd64IsKOperand(source) {
+		if !state.masks[source.Reg] {
+			return fail()
+		}
+	} else if !fixedLocalNumericRead(source, width, state) {
+		return fail()
+	}
+	if destination.Kind == OpMem {
+		offset, role, err := fixedLocalMemoryAccess(ins, 1, state, proof, residue, width, 1, true, false)
+		if err != nil {
+			return true, err
+		}
+		if role == x86FixedLocalPrivateMemory {
+			fixedLocalNumericalStore(state, offset, width, true)
+		}
+		return true, nil
+	}
+	if amd64IsKOperand(destination) {
+		state.masks[destination.Reg] = true
+		return true, nil
+	}
+	root, valid := x86CallerGP(destination.Reg)
+	if !valid || root == SP {
+		return fail()
+	}
+	// Every KMOV GP destination zero-extends to the full architectural word.
+	delete(state.pointers, root)
+	delete(state.opaque, root)
+	delete(state.constants, root)
+	fixedLocalWriteBooleans(state, destination.Reg, 8, 0)
+	state.known[root] = 255
+	return true, nil
+}
diff --git a/amd64_fixed_local_packed_effects_test.go b/amd64_fixed_local_packed_effects_test.go
new file mode 100644
index 000000000..656261cdb
--- /dev/null
+++ b/amd64_fixed_local_packed_effects_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalPackedMasksAndUpperAliases(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"legacy preserves unknown upper", "MOVOU 64(BP),X0\nVMOVDQU Y0,128(BP)", false},
+		{"VEX zeroes upper", "VMOVDQU 64(BP),X0\nVMOVDQU64 Z0,128(BP)", true},
+		{"EVEX zeroes upper", "VMOVDQU64 64(BP),Y31\nVMOVDQU64 Z31,128(BP)", true},
+		{"legacy retains known upper", "VMOVDQU64 64(BP),Z0\nMOVOU 64(BP),X0\nVMOVDQU64 Z0,128(BP)", true},
+		{"merge needs old bytes", "KMOVQ AX,K1\nVMOVDQA64 64(BP),K1,Z0\nVMOVDQA64 Z0,128(BP)", false},
+		{"zero needs no old bytes", "KMOVQ AX,K1\nVMOVDQA64.Z 64(BP),K1,Z0\nVMOVDQA64 Z0,128(BP)", true},
+		{"zero cannot bless unknown source", "KMOVQ AX,K1\nVMOVDQA64.Z Z1,K1,Z0\nVMOVDQA64 Z0,128(BP)", false},
+		{"mask is undefined", "VMOVDQA64.Z 64(BP),K1,Z0\nVMOVDQA64 Z0,128(BP)", false},
+		{"unknown source store", "VMOVDQA64 Z0,128(BP)", false},
+		{"Go zero store traps", "VMOVDQA64 64(BP),Z0\nKMOVQ AX,K1\nVMOVDQA64.Z Z0,K1,128(BP)", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, _, file, options := fixedLocalPackedFixture(t, row.body)
+			requireX86GoAssemblerResult(t, "amd64", fixedLocalPackedAssembly(row.body), true)
+			_, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"])
+			if row.valid && err != nil || !row.valid && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("private byte transfer valid=%v: %v", row.valid, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMaskedStoreCannotInitializeUnknownBytes(t *testing.T) {
+	const body = "VMOVDQA64 64(BP),Z0\nKMOVQ AX,K1\nVMOVDQA64 Z0,K1,128(BP)"
+	pkg, _, _, options := fixedLocalPackedFixture(t, body)
+	sig := options.Sigs[pkg.Path+".Value"]
+	for missing := 0; missing < 64; missing++ {
+		t.Run(fmt.Sprint(missing), func(t *testing.T) {
+			assembly := fixedLocalPackedAssembly(body)
+			var stores strings.Builder
+			for index := 0; index < 8; index++ {
+				if index != missing%8 {
+					fmt.Fprintf(&stores, "MOVB $1,%d(BP)\n", 128+missing/8*8+index)
+				}
+			}
+			assembly = strings.Replace(assembly, fmt.Sprintf("MOVQ AX,%d(BP)\n", 128+missing/8*8), stores.String(), 1)
+			assembly = strings.Replace(assembly, "MOVQ 128(BP),AX", fmt.Sprintf("MOVQ %d(BP),AX", 128+missing/8*8), 1)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("dynamic mask initialized retained byte %d: %v", missing, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMaskMovesCompleteLocalRoles(t *testing.T) {
+	for _, opcode := range []string{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+		t.Run(opcode, func(t *testing.T) {
+			body := fmt.Sprintf("%s AX,K0\n%s K0,K7\n%s K7,128(BP)\n%s 64(BP),K1\n%s K1,CX\nVMOVDQA64.Z 64(BP),K1,Z0\nVMOVDQA64 Z0,128(BP)", opcode, opcode, opcode, opcode, opcode)
+			pkg, _, file, options := fixedLocalPackedFixture(t, body)
+			requireX86GoAssemblerResult(t, "amd64", fixedLocalPackedAssembly(body), true)
+			sig := options.Sigs[pkg.Path+".Value"]
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+				t.Fatal("complete local mask transfer", err)
+			}
+			for name, changed := range map[string]string{
+				"private pointer": strings.Replace(body, opcode+" AX,K0", opcode+" BP,K0", 1),
+				"unknown GP":      strings.Replace(body, opcode+" AX,K0", opcode+" DX,K0", 1),
+				"unknown K":       strings.Replace(body, opcode+" AX,K0", opcode+" K2,K0", 1),
+				"BP output":       strings.Replace(body, opcode+" K1,CX", opcode+" K1,BP", 1),
+				"SP output":       strings.Replace(body, opcode+" K1,CX", opcode+" K1,SP", 1),
+				"outside frame":   strings.Replace(body, "128(BP)", "256(BP)", 1),
+				"global output":   strings.Replace(body, "128(BP)", "external(SB)", 1),
+			} {
+				t.Run(name, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, fixedLocalPackedAssembly(changed))
+					if err != nil {
+						t.Fatal(err)
+					}
+					if name == "BP output" {
+						fixedLocalRequireNumericControl(t, file.Funcs[0], sig, fixedLocalPackedAssembly(changed),
+							"func Value(a uint64) uint64", "VMOVDQA64.Z 64(BP),K1,Z0", 0, 64, false, "load volatile i64")
+						return
+					}
+					if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("mask move acquired another native role", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPackedCFGMergeMasksAndBytes(t *testing.T) {
+	for name, body := range map[string]string{
+		"mask omitted on one path":   "CMPQ AX,AX\nJEQ joined\nKMOVQ AX,K1\njoined:\nVMOVDQA64.Z 64(BP),K1,Z0\nVMOVDQA64 Z0,128(BP)",
+		"vector omitted on one path": "CMPQ AX,AX\nJEQ joined\nVMOVDQA64 64(BP),Z0\njoined:\nVMOVDQA64 Z0,128(BP)",
+		"BP differs on one path":     "CMPQ AX,AX\nJEQ joined\nADDQ $64,BP\njoined:\nVMOVDQA64 64(BP),Z0\nVMOVDQA64 Z0,128(BP)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, _, file, options := fixedLocalPackedFixture(t, body)
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("predecessor lost its must-defined/source role", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMaskedStoreRevokesPrivatePointerSpills(t *testing.T) {
+	for _, mask := range []string{"AX", "$0", "$1", "$-1"} {
+		for _, use := range []string{"MOVQ 32(BP),R11\nMOVQ 64(R11),AX", "MOVQ 32(BP),AX"} {
+			t.Run(mask+"/"+use, func(t *testing.T) {
+				body := "VMOVDQU64 64(BP),Z0\nMOVQ BP,32(BP)\nMOVQ " + mask + ",DX\nKMOVQ DX,K1\nVMOVDQU64 Z0,K1,32(BP)\n" + use
+				pkg, _, file, options := fixedLocalPackedFixture(t, body)
+				requireX86GoAssemblerResult(t, "amd64", fixedLocalPackedAssembly(body), true)
+				if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("partial store preserved pointer authority or invented numerical bytes", err)
+				}
+			})
+		}
+	}
+	// This domain proves mask definedness, not constant mask values. Even a
+	// zero mask must conservatively revoke the overlapping pointer certificate.
+	state := x86FixedLocalState{bytes: newFixedLocalByteSet(96), booleanBytes: newFixedLocalByteSet(96), addresses: map[int64]int64{32: 8, 80: 16}}
+	fixedLocalNumericalStore(&state, 36, 16, false)
+	if _, found := state.addresses[32]; found || state.addresses[80] != 16 {
+		t.Fatal("partial overlap did not revoke exactly the overlapping pointer spill")
+	}
+	for index := int64(0); index < 96; index++ {
+		if state.bytes.has(index) {
+			t.Fatalf("masked store invented initialized byte %d", index)
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMergeRequiresEveryDestinationByte(t *testing.T) {
+	for _, bank := range []struct {
+		name  string
+		width int64
+	}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+		file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$256-0\nVMOVDQU8 "+bank.name+"1,K1,"+bank.name+"0\nVMOVDQU8 "+bank.name+"0,0(BP)\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for missing := int64(0); missing < bank.width; missing++ {
+			t.Run(fmt.Sprintf("%s/%d", bank.name, missing), func(t *testing.T) {
+				state := x86FixedLocalState{
+					pointers: map[Reg]int64{BP: 0}, masks: map[Reg]bool{"K1": true},
+					vectors: map[Reg]uint64{"Z0": ^(uint64(1) << uint(missing)), "Z1": ^uint64(0)},
+					bytes:   newFixedLocalByteSet(256), addresses: make(map[int64]int64),
+				}
+				proof := &x86FixedLocalProof{frame: 256, accesses: make(map[int]map[int]x86FixedLocalAccess)}
+				copy := file.Funcs[0].Instrs[1]
+				if known, err := fixedLocalPackedMoveStep(&copy, &state, proof, 0); !known || err != nil {
+					t.Fatalf("register merge: known=%v error=%v", known, err)
+				}
+				if got, want := state.vectors["Z0"], ^(uint64(1) << uint(missing)); got != want {
+					t.Fatalf("merge/upper-zero bytes=%016x want=%016x", got, want)
+				}
+				store := file.Funcs[0].Instrs[2]
+				if _, err := fixedLocalPackedMoveStep(&store, &state, proof, 0); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("merge result exposed an undefined destination byte", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_packed_matrix_test.go b/amd64_fixed_local_packed_matrix_test.go
new file mode 100644
index 000000000..507f2ecb2
--- /dev/null
+++ b/amd64_fixed_local_packed_matrix_test.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalPackedCompleteProgram() (string, string, int) {
+	return fixedLocalPackedCompleteProgramRange(0, 195)
+}
+
+func fixedLocalPackedCompleteProgramRange(start, end int) (string, string, int) {
+	var assembly, declarations strings.Builder
+	count := 0
+	emit := func(operation string) {
+		index := count
+		count++
+		if index < start || index >= end {
+			return
+		}
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalPackedAssembly(operation), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+	}
+	for _, row := range fixedLocalPackedMoveOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if bank == "Z" && !row.evex {
+				continue
+			}
+			for _, high := range []bool{false, true} {
+				first, last := bank+"0", bank+"1"
+				if high {
+					first, last = bank+"15", bank+"14"
+					if row.evex {
+						first, last = bank+"31", bank+"30"
+					}
+				}
+				for _, predicate := range []string{"none", "merge", "zero"} {
+					if predicate != "none" && !row.evex {
+						continue
+					}
+					operation := fmt.Sprintf("%s 64(BP),%s\n%s 128(BP),%s\n", row.name, first, row.name, last)
+					mask, opcode := "", row.name
+					if predicate != "none" {
+						operation += "KMOVQ AX,K7\n"
+						mask = "K7,"
+					}
+					if predicate == "zero" {
+						opcode += ".Z"
+					}
+					operation += fmt.Sprintf("%s 64(BP),%s%s\n%s %s,%s%s\n%s %s,%s128(BP)",
+						opcode, mask, first, opcode, first, mask, last, row.name, last, mask)
+					emit(operation)
+				}
+			}
+		}
+	}
+	// Legacy aliases retain upper bytes and share the exact same local envelope.
+	for _, name := range []string{"MOVO", "MOVOA", "MOVOU", "MOVAPS", "MOVAPD", "MOVUPS", "MOVUPD"} {
+		operation := fmt.Sprintf("%s 64(BP),X15\n%s X15,X0\n%s X0,128(BP)", name, name, name)
+		emit(operation)
+	}
+	return assembly.String(), declarations.String(), count
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsLinuxBatch00(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 0)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsLinuxBatch01(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 1)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsLinuxBatch02(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 2)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsLinuxBatch03(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "linux/amd64", "x86_64-unknown-linux-gnu", 3)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsDarwinBatch00(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 0)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsDarwinBatch01(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 1)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsDarwinBatch02(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 2)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsDarwinBatch03(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "darwin/amd64", "x86_64-apple-darwin", 3)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsWindowsBatch00(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 0)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsWindowsBatch01(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 1)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsWindowsBatch02(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 2)
+}
+
+func TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsWindowsBatch03(t *testing.T) {
+	fixedLocalPackedActualObjects(t, "windows/amd64", "x86_64-pc-windows-msvc", 3)
+}
+
+func TestGoAMD64FixedLocalPackedObjectBatchPlan(t *testing.T) {
+	completeAssembly, completeDeclarations, count := fixedLocalPackedCompleteProgram()
+	if count != 195 {
+		t.Fatal("complete independent packed format inventory changed", count)
+	}
+	var assembly, declarations strings.Builder
+	for batch := 0; batch < 4; batch++ {
+		start, end, ok := fixedLocalObjectBatchRange(count, batch)
+		if !ok {
+			t.Fatal("missing packed object batch", batch)
+		}
+		body, decls, total := fixedLocalPackedCompleteProgramRange(start, end)
+		file, err := Parse(ArchAMD64, body)
+		if err != nil || total != count || len(file.Funcs) != end-start {
+			t.Fatal("packed object batch lost its exact function range", batch, err)
+		}
+		assembly.WriteString(body)
+		declarations.WriteString(decls)
+	}
+	if assembly.String() != completeAssembly || declarations.String() != completeDeclarations {
+		t.Fatal("packed object batches changed, omitted or duplicated original source bytes")
+	}
+}
+
+func fixedLocalPackedActualObjects(t *testing.T, target, triple string, batch int) {
+	t.Helper()
+	// Keep lazy Go tools in this root's disposable cache, not a global cache
+	// or a different source/object observation.
+	t.Setenv("GOCACHE", t.TempDir())
+	start, end, ok := fixedLocalObjectBatchRange(195, batch)
+	if !ok {
+		t.Fatal("invalid complete packed object batch", batch)
+	}
+	assembly, declarations, total := fixedLocalPackedCompleteProgramRange(start, end)
+	if total != 195 {
+		t.Fatalf("independent width/register/mask/legacy matrix changed: %d", total)
+	}
+	count := end - start
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	t.Run(fmt.Sprintf("batch%d", batch), func(t *testing.T) {
+		pkg, request, _, options := x86CMOVFixedLocalFixture(t, assembly, declarations, target, triple)
+		fixedLocalConversionPrepareToolCache(t, request)
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+			if err != nil || strings.Count(ir, "%fixed_local_native = alloca") != count {
+				t.Fatalf("complete original frame inventory lost: %v", err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				var names []string
+				for index := start; index < end; index++ {
+					names = append(names, fmt.Sprintf("example.invalid/framefixture.Value%d", index))
+				}
+				x86CompactExpandRequireAllDefinitions(t, text, names)
+				compileLLVMToObject(t, llc, triple, "complete-packed.ll", "complete-packed.o", text)
+			}
+		})
+	})
+}
+
+func TestGoAMD64FixedLocalPackedEveryByteAndUnknownRole(t *testing.T) {
+	for _, bank := range []struct {
+		name  string
+		width int
+	}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+		operation := fmt.Sprintf("VMOVDQA64 64(BP),%s0\nVMOVDQA64 %s0,128(BP)", bank.name, bank.name)
+		pkg, _, _, options := fixedLocalPackedFixture(t, operation)
+		sig := options.Sigs[pkg.Path+".Value"]
+		base := fixedLocalPackedAssembly(operation)
+		for missing := 0; missing < bank.width; missing++ {
+			t.Run(fmt.Sprintf("%s/byte%d", bank.name, missing), func(t *testing.T) {
+				var stores strings.Builder
+				for index := 0; index < 8; index++ {
+					if index != missing%8 {
+						fmt.Fprintf(&stores, "MOVB $1,%d(BP)\n", 64+missing/8*8+index)
+					}
+				}
+				assembly := strings.Replace(base, fmt.Sprintf("MOVQ AX,%d(BP)\n", 64+missing/8*8), stores.String(), 1)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("missing private byte obtained native read authority", err)
+				}
+			})
+		}
+		for name, changed := range map[string]string{
+			"past frame":           strings.Replace(base, operation, strings.Replace(operation, "64(BP)", "256(BP)", 1), 1),
+			"misaligned":           strings.Replace(base, operation, strings.Replace(operation, "64(BP)", "65(BP)", 1), 1),
+			"unknown base":         strings.Replace(base, operation, strings.Replace(operation, "64(BP)", "64(DX)", 1), 1),
+			"external escape":      strings.Replace(base, operation, "MOVQ BP,(AX)\n"+operation, 1),
+			"private mask":         strings.Replace(base, operation, "KMOVQ BP,K1\n"+operation, 1),
+			"unaligned residue":    strings.Replace(base, "ANDQ $-64,BP", "ANDQ $-8,BP", 1),
+			"unknown address size": strings.Replace(base, "ADDQ $64,BP", "ADDQ DX,BP", 1),
+		} {
+			t.Run(bank.name+"/"+name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, changed)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("native frame boundary was weakened", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMod64IndependentAliasReplay(t *testing.T) {
+	operation := "VMOVDQA64 64(BP),Z0\nVMOVDQA64 Z0,128(BP)"
+	pkg, _, file, options := fixedLocalPackedFixture(t, operation)
+	sig := options.Sigs[pkg.Path+".Value"]
+	proved, err := proveX86FixedLocal(file.Funcs[0], sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, ins := range proved.Instrs {
+		if ins.Op != "VMOVDQA64" {
+			continue
+		}
+		for operand, access := range ins.x86FixedLocalMemory {
+			for residue, offset := range access.offset {
+				base := int64(((residue*8 + 64) & -64) - residue*8)
+				if offset != base+ins.Args[operand].Mem.Off || (offset+int64(residue*8))%64 != 0 {
+					t.Fatalf("mod64 residue %d: %+v", residue, access)
+				}
+			}
+		}
+	}
+	// Only residues six and seven overlap this scalar store with source bytes.
+	// Checking the old four residues would miss this real alias difference.
+	changed := strings.Replace(fixedLocalPackedAssembly(operation), operation, "MOVQ $0,80(SP)\n"+operation, 1)
+	requireX86GoAssemblerResult(t, "amd64", changed, true)
+	file, err = Parse(ArchAMD64, changed)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "byte identity") {
+		t.Fatal("residue-dependent byte aliases were relocated", err)
+	}
+}
diff --git a/amd64_fixed_local_packed_native_linux_amd64_test.go b/amd64_fixed_local_packed_native_linux_amd64_test.go
new file mode 100644
index 000000000..010a04e53
--- /dev/null
+++ b/amd64_fixed_local_packed_native_linux_amd64_test.go
@@ -0,0 +1,35 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch00(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch01(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch02(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch03(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch04(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 4)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch05(t *testing.T) {
+	fixedLocalPackedNativeWideBatch(t, 5)
+}
+
+func fixedLocalPackedNativeWideBatch(t *testing.T, batch int) {
+	t.Helper()
+	execution := x86PackedDoubleDwordNativeTools(t)
+	fixedLocalPackedRuntimeAPIs(t, execution, true, true, []string{"Translate", "Module", "GoModule"}, batch)
+}
diff --git a/amd64_fixed_local_packed_native_partition_test.go b/amd64_fixed_local_packed_native_partition_test.go
new file mode 100644
index 000000000..2d3491462
--- /dev/null
+++ b/amd64_fixed_local_packed_native_partition_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func fixedLocalPackedRequireNativeBatchOwners(t *testing.T) {
+	t.Helper()
+	functions := fixedLocalLeaseFunctions(t, "amd64_fixed_local_packed_native_linux_amd64_test.go")
+	const prefix = "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWide"
+	expected := make(map[string]int)
+	for batch := 0; batch < 6; batch++ {
+		expected[fmt.Sprintf("%sBatch%02d", prefix, batch)] = batch
+	}
+	for name := range functions {
+		if strings.HasPrefix(name, prefix) {
+			if _, ok := expected[name]; !ok {
+				t.Error("unknown or monolithic native source owner", name)
+			}
+		}
+	}
+	for name, batch := range expected {
+		function := functions[name]
+		if function == nil {
+			t.Error("missing complete native source owner", name)
+			continue
+		}
+		if len(function.Body.List) != 1 {
+			t.Fatal("native owner must delegate exactly once", name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("native owner lost its complete source call", name)
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || fixedLocalLeaseCallName(call) != "fixedLocalPackedNativeWideBatch" || len(call.Args) != 2 {
+			t.Fatal("native owner must retain the shared source/preflight helper", name)
+		}
+		fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[:1]}, "t")
+		literal, ok := call.Args[1].(*ast.BasicLit)
+		if !ok || literal.Kind != token.INT || literal.Value != strconv.Itoa(batch) {
+			t.Fatal("native owner substituted or repeated a source batch", name)
+		}
+	}
+	helper := functions["fixedLocalPackedNativeWideBatch"]
+	if helper == nil {
+		t.Error("missing independently preflighted native source helper")
+		return
+	}
+	calls := fixedLocalLeaseCalls(helper.Body)
+	if calls["x86PackedDoubleDwordNativeTools"] != 1 || calls["fixedLocalPackedRuntimeAPIs"] != 1 || calls["t.Skip"] != 0 {
+		t.Fatal("every source owner needs the unchanged actual native preflight and API plan")
+	}
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || fixedLocalLeaseCallName(call) != "fixedLocalPackedRuntimeAPIs" {
+			return true
+		}
+		if len(call.Args) != 6 {
+			t.Fatal("native source owner must select one complete batch")
+		}
+		fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[:4]}, "t", "execution", "true", "true")
+		fixedLocalLeaseRequireArguments(t, &ast.CallExpr{Fun: call.Fun, Args: call.Args[5:]}, "batch")
+		apis, ok := call.Args[4].(*ast.CompositeLit)
+		if !ok || len(apis.Elts) != 3 {
+			t.Fatal("native source owner lost a public API")
+		}
+		for index, want := range []string{"Translate", "Module", "GoModule"} {
+			literal, ok := apis.Elts[index].(*ast.BasicLit)
+			if !ok || literal.Value != strconv.Quote(want) {
+				t.Fatal("native source owner changed its complete three-API plan")
+			}
+		}
+		return true
+	})
+}
diff --git a/amd64_fixed_local_packed_native_partition_unix_test.go b/amd64_fixed_local_packed_native_partition_unix_test.go
new file mode 100644
index 000000000..8f6b836bb
--- /dev/null
+++ b/amd64_fixed_local_packed_native_partition_unix_test.go
@@ -0,0 +1,79 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"go/ast"
+	"go/token"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestFixedLocalPackedNativeBatchSelectionPreservesCompleteSourceUnion(t *testing.T) {
+	helper := fixedLocalLeaseFunctions(t, "amd64_fixed_local_packed_runtime_test.go")["fixedLocalPackedRuntimeAPIs"]
+	if helper == nil {
+		t.Fatal("missing complete packed source consumer")
+	}
+	var selection, original token.Pos
+	consumesSelected := false
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		if loop, ok := node.(*ast.RangeStmt); ok {
+			if indices, ok := loop.X.(*ast.Ident); ok && indices.Name == "indices" {
+				consumesSelected = true
+			}
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		switch fixedLocalLeaseCallName(call) {
+		case "fixedLocalPackedBatchSelection":
+			selection = call.Pos()
+		case "fixedLocalPackedRunOriginal":
+			original = call.Pos()
+			fixedLocalLeaseRequireArguments(t, call, "t", "execution", "assembly", "declarations", "goOracle", "execute")
+		}
+		return true
+	})
+	if selection == 0 || original <= selection || !consumesSelected {
+		t.Fatal("invalid ownership must fail before running the unchanged whole original, and only selected complete batches may execute")
+	}
+	for _, all := range []bool{false, true} {
+		batches := fixedLocalPackedLeaseBatches(t, all, "x86_64-unknown-linux-gnu")
+		indices, err := fixedLocalPackedBatchSelection(len(batches))
+		if err != nil || len(indices) != len(batches) {
+			t.Fatal("default compile-only/SSE source selection changed", err)
+		}
+		var assembly, declarations, rows, prototypes strings.Builder
+		for index, batch := range batches {
+			selected, err := fixedLocalPackedBatchSelection(len(batches), index)
+			if err != nil || !reflect.DeepEqual(selected, []int{index}) || indices[index] != index {
+				t.Fatal("one required owner must retain exactly its complete original source batch", index, selected, err)
+			}
+			assembly.WriteString(batch.assembly)
+			declarations.WriteString(batch.declarations)
+			rows.WriteString(batch.rows)
+			prototypes.WriteString(batch.prototypes)
+		}
+		original, decls, cases := fixedLocalPackedRuntimeProgram(all)
+		_, oracle := fixedLocalPackedRuntimeOracles(cases, "x86_64-unknown-linux-gnu")
+		if assembly.String() != original || declarations.String() != decls ||
+			!strings.Contains(oracle, rows.String()) || !strings.Contains(oracle, prototypes.String()) {
+			t.Fatal("independent source owners cropped, renamed or duplicated the original whole program")
+		}
+	}
+}
+
+func TestFixedLocalPackedNativeBatchSelectionRejectsInvalidOwners(t *testing.T) {
+	for _, selected := range [][]int{{-1}, {6}, {0, 0}, {0, 1}, {5, 4}} {
+		if _, err := fixedLocalPackedBatchSelection(6, selected...); err == nil {
+			t.Error("invalid or repeated source selection became an executable owner", selected)
+		}
+	}
+	for _, total := range []int{-1, 0} {
+		if _, err := fixedLocalPackedBatchSelection(total); err == nil {
+			t.Error("empty source inventory became a successful owner", total)
+		}
+	}
+}
diff --git a/amd64_fixed_local_packed_runtime_test.go b/amd64_fixed_local_packed_runtime_test.go
new file mode 100644
index 000000000..04aa3836d
--- /dev/null
+++ b/amd64_fixed_local_packed_runtime_test.go
@@ -0,0 +1,337 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+type fixedLocalPackedRuntimeCase struct {
+	width, bits, word, mode int
+}
+
+func fixedLocalPackedRuntimeProgram(all bool) (string, string, []fixedLocalPackedRuntimeCase) {
+	var assembly, declarations strings.Builder
+	var cases []fixedLocalPackedRuntimeCase
+	add := func(opcode, bank string, width, bits, mode int) {
+		for word := -1; word <= width/8; word++ {
+			index := len(cases)
+			cases = append(cases, fixedLocalPackedRuntimeCase{width, bits, word, mode})
+			fmt.Fprintf(&declarations, "func Value%d(a, mask uint64) uint64\n", index)
+			fmt.Fprintf(&assembly, "TEXT ·Value%d(SB),4,$512-24\nMOVQ a+0(FP),AX\nMOVQ mask+8(FP),CX\n", index)
+			assembly.WriteString("MOVQ SP,BP\nADDQ $64,BP\nANDQ $-64,BP\n")
+			assembly.WriteString("MOVQ $0x5a5a5a5a5a5a5a5a,DX\nMOVQ DX,248(BP)\n")
+			fmt.Fprintf(&assembly, "MOVQ DX,%d(BP)\n", 256+width)
+			for offset := 0; offset < width; offset += 8 {
+				fmt.Fprintf(&assembly, "MOVQ DX,%d(BP)\n", 256+offset)
+			}
+			for offset := 0; offset < width; offset += 8 {
+				fmt.Fprintf(&assembly, "MOVQ $%d,DX\nMOVQ DX,%d(BP)\n", int64(0x102030405060708)+int64(offset), 128+offset)
+			}
+			if word >= 0 && word < width/8 {
+				fmt.Fprintf(&assembly, "MOVQ AX,%d(BP)\n", 128+word*8)
+			}
+			first, last := bank+"0", bank+"1"
+			fmt.Fprintf(&assembly, "%s 256(BP),%s\n%s 256(BP),%s\n", opcode, first, opcode, last)
+			mask, effective := "", opcode
+			if mode != 0 {
+				assembly.WriteString("KMOVQ CX,K7\n")
+				mask = "K7,"
+			}
+			if mode == 2 {
+				effective += ".Z"
+			}
+			fmt.Fprintf(&assembly, "%s 128(BP),%s%s\n%s %s,%s%s\n", effective, mask, first, effective, first, mask, last)
+			if mode == 2 {
+				mask = "" // Observe inactive zeroed bytes, not retained memory.
+			}
+			fmt.Fprintf(&assembly, "%s %s,%s256(BP)\nMOVQ %d(BP),AX\nMOVQ AX,ret+16(FP)\nRET\n", opcode, last, mask, 256+word*8)
+		}
+	}
+	for _, opcode := range []string{"MOVO", "MOVOA", "MOVOU", "MOVAPS", "MOVAPD", "MOVUPS", "MOVUPD"} {
+		add(opcode, "X", 16, 8, 0)
+	}
+	if all {
+		for _, row := range fixedLocalPackedMoveOracle {
+			width, bank, bits := 32, "Y", 8
+			if row.evex {
+				width, bank = 64, "Z"
+			}
+			switch row.name {
+			case "VMOVAPD", "VMOVUPD", "VMOVDQA64", "VMOVDQU64":
+				bits = 64
+			case "VMOVAPS", "VMOVUPS", "VMOVDQA32", "VMOVDQU32":
+				bits = 32
+			case "VMOVDQU16":
+				bits = 16
+			}
+			add(row.name, bank, width, bits, 0)
+			if row.evex {
+				add(row.name, bank, width, bits, 1)
+				add(row.name, bank, width, bits, 2)
+			}
+		}
+	}
+	return assembly.String(), declarations.String(), cases
+}
+
+func fixedLocalPackedRuntimeOracles(cases []fixedLocalPackedRuntimeCase, triple string) (string, string) {
+	var goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, row := range cases {
+		fmt.Fprintf(&goRows, "{Value%d,%d,%d,%d,%d},\n", index, row.width, row.bits, row.word, row.mode)
+		fmt.Fprintf(&cRows, "{value%d,%d,%d,%d,%d},\n", index, row.width, row.bits, row.word, row.mode)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t,uint64_t) __asm__(\"%sexample.invalid/framefixture.Value%d\");\n", index, prefix, index)
+	}
+	goOracle := `package framefixture
+import "testing"
+func TestOriginal(t *testing.T) {
+    cases := []struct {
+        call func(uint64,uint64) uint64
+        width, bits, word, mode int
+    }{
+` + goRows.String() + `
+    }
+    values := []uint64{0,1,^uint64(0),0x8000000000000000,0x123456789abcdef0,0x7ff81234567890ab}
+    masks := []uint64{0,1,^uint64(0),0x5555555555555555,0xaaaaaaaaaaaaaaaa,0x8000000000000000}
+    for index, row := range cases {
+        for _, value := range values {
+            for _, mask := range masks {
+                want := uint64(0x5a5a5a5a5a5a5a5a)
+                if row.word >= 0 && row.word < row.width/8 {
+                    want = 0
+                    for bit := 0; bit < 64; bit++ {
+                        input := uint64(0x5a5a5a5a5a5a5a5a)
+                        if row.mode == 0 || mask >> uint((row.word*64+bit)/row.bits)&1 != 0 {
+                            input = value
+                        } else if row.mode == 2 {
+                            input = 0
+                        }
+                        want |= input & (uint64(1) << uint(bit))
+                    }
+                }
+                if got := row.call(value,mask); got != want {
+                    t.Fatalf("case=%d input=%x mask=%x got=%x want=%x",index,value,mask,got,want)
+                }
+            }
+        }
+    }
+}
+`
+	cOracle := `#include <stdint.h>
+#include <stdio.h>
+` + cDeclarations.String() + `
+struct entry {
+    uint64_t (*call)(uint64_t,uint64_t);
+    int width,bits,word,mode;
+};
+static const struct entry cases[]={
+` + cRows.String() + `
+};
+int main(void) {
+    const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),UINT64_C(0x123456789abcdef0),UINT64_C(0x7ff81234567890ab)};
+    const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x5555555555555555),UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_C(0x8000000000000000)};
+    for(unsigned n=0;n<sizeof(cases)/sizeof(cases[0]);n++) {
+        struct entry row=cases[n];
+        for(unsigned v=0;v<6;v++) for(unsigned m=0;m<6;m++) {
+            uint64_t want=UINT64_C(0x5a5a5a5a5a5a5a5a);
+            if(row.word>=0 && row.word<row.width/8) {
+                want=0;
+                for(unsigned bit=0;bit<64;bit++) {
+                    uint64_t source=UINT64_C(0x5a5a5a5a5a5a5a5a);
+                    unsigned lane=((unsigned)row.word*64+bit)/(unsigned)row.bits;
+                    if(row.mode==0 || (masks[m]>>lane)&1) source=values[v];
+                    else if(row.mode==2) source=0;
+                    want|=source&(UINT64_C(1)<<bit);
+                }
+            }
+            uint64_t got=row.call(values[v],masks[m]);
+            if(got!=want) {
+                fprintf(stderr,"case=%u value=%llx mask=%llx got=%llx want=%llx\n",n,(unsigned long long)values[v],(unsigned long long)masks[m],(unsigned long long)got,(unsigned long long)want);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	return goOracle, cOracle
+}
+
+func fixedLocalPackedRuntime(t *testing.T, execution x86FloatCompareExecution, all, execute bool) {
+	t.Helper()
+	fixedLocalPackedRuntimeAPIs(t, execution, all, execute, []string{"Translate", "Module", "GoModule"})
+}
+
+func fixedLocalPackedBatchSelection(total int, selected ...int) ([]int, error) {
+	if total <= 0 || len(selected) > 1 {
+		return nil, fmt.Errorf("packed source owner needs a nonempty inventory and at most one batch: total=%d selected=%v",
+			total, selected)
+	}
+	if len(selected) == 1 {
+		if selected[0] < 0 || selected[0] >= total {
+			return nil, fmt.Errorf("packed source batch outside complete inventory: total=%d selected=%v", total, selected)
+		}
+		return []int{selected[0]}, nil
+	}
+	var indices []int
+	for index := 0; index < total; index++ {
+		indices = append(indices, index)
+	}
+	return indices, nil
+}
+
+func fixedLocalPackedRuntimeAPIs(t *testing.T, execution x86FloatCompareExecution, all, execute bool, apis []string, selected ...int) {
+	t.Helper()
+	batches := fixedLocalPackedLeaseBatches(t, all, execution.triple)
+	indices, err := fixedLocalPackedBatchSelection(len(batches), selected...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Share only disposable compiler artifacts, never a source observation.
+	t.Setenv("GOCACHE", t.TempDir())
+	assembly, declarations, cases := fixedLocalPackedRuntimeProgram(all)
+	goOracle, cOracle := fixedLocalPackedRuntimeOracles(cases, execution.triple)
+	// Compile/execute the unchanged whole original before starting any API
+	// lease. The following batches are complete independent source packages.
+	fixedLocalPackedRunOriginal(t, execution, assembly, declarations, goOracle, execute)
+	if !execute {
+		dir := t.TempDir()
+		input, output := filepath.Join(dir, "oracle.c"), filepath.Join(dir, "oracle.o")
+		if err := os.WriteFile(input, []byte(cOracle), 0600); err != nil {
+			t.Fatal(err)
+		}
+		command := append([]string(nil), execution.compiler...)
+		command = append(command, "-O2", "-c", input, "-o", output)
+		x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+	}
+	for _, index := range indices {
+		batch := batches[index]
+		t.Run(fmt.Sprintf("batch%d", index), func(t *testing.T) {
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, batch.assembly, batch.declarations,
+				runtime.GOOS+"/amd64", execution.triple)
+			fixedLocalConversionPrepareToolCache(t, request)
+			fixedLocalFreshAPIs(t, pkg, request, options, apis, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				var names []string
+				for member := batch.start; member < batch.end; member++ {
+					names = append(names, fmt.Sprintf("example.invalid/framefixture.Value%d", member))
+				}
+				for _, pipeline := range []struct {
+					name, level string
+					optimize    bool
+				}{
+					{"backend_O0", "-O0", false},
+					{"backend_O2", "-O2", false},
+					{"IR_O2/backend_O2", "-O2", true},
+				} {
+					t.Run(pipeline.name, func(t *testing.T) {
+						input := ir
+						if pipeline.optimize {
+							input = x86MulDivRoundOptimize(t, ir)
+						}
+						x86CompactExpandRequireAllDefinitions(t, input, names)
+						if execute {
+							execution.compileAndRunLLVM(t, "packed-native-frame", input, batch.oracle, pipeline.level)
+						} else {
+							x86PackedStringCompileObject(t, execution.llc, execution.triple, input, pipeline.level)
+						}
+						t.Logf("complete packed oracle [%d,%d): %d kernels x 6 values x 6 masks x 64 result bits; execute=%v",
+							batch.start, batch.end, batch.end-batch.start, execute)
+					})
+				}
+			})
+		})
+	}
+	t.Logf("cases=%d original Go + APIs=%v; complete source batches=%d selected=%v execute=%v native-wide=%v",
+		len(cases), apis, len(batches), indices, execute, all)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedSSE(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	fixedLocalPackedRuntime(t, execution, false, true)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("Rosetta SSE diagnostic, not native AVX/AVX512 execution")
+	}
+}
+
+func TestGoAMD64FixedLocalPackedWideRuntimeOracleCompileOnly(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	fixedLocalPackedRuntimeAPIs(t, execution, true, false, []string{"Translate"})
+	t.Log("full wide oracle compiled, not executed; required Linux/amd64 root owns native coverage")
+}
+
+func TestGoAMD64FixedLocalPackedWideRuntimeOracleModuleCompileOnly(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	fixedLocalPackedRuntimeAPIs(t, execution, true, false, []string{"Module"})
+	t.Log("full wide oracle compiled, not executed; required Linux/amd64 root owns native coverage")
+}
+
+func TestGoAMD64FixedLocalPackedWideRuntimeOracleGoModuleCompileOnly(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	fixedLocalPackedRuntimeAPIs(t, execution, true, false, []string{"GoModule"})
+	t.Log("full wide oracle compiled, not executed; required Linux/amd64 root owns native coverage")
+}
+
+// Object compilation needs a real compiler and target headers, not an x86 CPU
+// or executable transport. This value must never be used to claim execution.
+func fixedLocalPackedCompileOnlyTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required for complete packed object compilation")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	compiler := []string{clang, "-target", triple}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	if runtime.GOOS == "linux" && runtime.GOARCH != "amd64" && runtime.GOARCH != "386" {
+		const root = "/usr/x86_64-linux-gnu"
+		include := filepath.Join(root, "include")
+		if info, err := os.Stat(include); err != nil || !info.IsDir() {
+			t.Fatalf("required AMD64 C target sysroot headers %s: %v", include, err)
+		}
+		compiler = append(compiler, "--sysroot="+root, "-isystem", include)
+	}
+	return x86FloatCompareExecution{llc: llc, triple: triple, compiler: compiler}
+}
+
+func TestGoAMD64FixedLocalPackedRuntimeOwnership(t *testing.T) {
+	for _, row := range []struct {
+		all   bool
+		count int
+	}{{false, 28}, {true, 340}} {
+		_, declarations, cases := fixedLocalPackedRuntimeProgram(row.all)
+		if len(cases) != row.count || strings.Count(declarations, "func Value") != row.count {
+			t.Fatalf("runtime row ownership all=%v: got %d want %d", row.all, len(cases), row.count)
+		}
+	}
+	source, err := os.ReadFile("amd64_fixed_local_packed_native_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalPackedRequireNativeBatchOwners(t)
+	if strings.Contains(string(source), "t.Skip") {
+		t.Fatal("native wide runtime coverage must not silently skip")
+	}
+}
diff --git a/amd64_fixed_local_packed_test.go b/amd64_fixed_local_packed_test.go
new file mode 100644
index 000000000..22df0e209
--- /dev/null
+++ b/amd64_fixed_local_packed_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Independent names/widths, not iteration over the implementation map.
+var fixedLocalPackedMoveOracle = []struct {
+	name string
+	evex bool
+}{
+	{"VMOVDQA", false}, {"VMOVDQU", false},
+	{"VMOVAPD", true}, {"VMOVAPS", true},
+	{"VMOVUPD", true}, {"VMOVUPS", true},
+	{"VMOVDQA32", true}, {"VMOVDQA64", true},
+	{"VMOVDQU8", true}, {"VMOVDQU16", true},
+	{"VMOVDQU32", true}, {"VMOVDQU64", true},
+}
+
+func fixedLocalPackedAssembly(operation string) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·Value(SB),4,$256-16\nMOVQ a+0(FP),AX\n")
+	source.WriteString("MOVQ SP,BP\nADDQ $64,BP\nANDQ $-64,BP\n")
+	for offset := 64; offset < 192; offset += 8 {
+		fmt.Fprintf(&source, "MOVQ AX,%d(BP)\n", offset)
+	}
+	source.WriteString(operation + "\n")
+	source.WriteString("MOVQ 128(BP),AX\nMOVQ AX,ret+8(FP)\nRET\n")
+	return source.String()
+}
+
+func fixedLocalPackedFixture(t *testing.T, operation string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	assembly := fixedLocalPackedAssembly(operation)
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a uint64) uint64", assembly)
+	sig, err := DeriveGoFuncABI0Signature(pkg.Path+".Value", pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, request, file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+		Sigs:       map[string]FuncSig{sig.Name: sig},
+	}
+}
+
+func TestGoAMD64FixedLocalPackedMoveTypedFamilyProof(t *testing.T) {
+	var original strings.Builder
+	count := 0
+	for _, row := range fixedLocalPackedMoveOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if bank == "Z" && !row.evex {
+				continue
+			}
+			for _, masked := range []bool{false, true} {
+				if masked && !row.evex {
+					continue
+				}
+				name := fmt.Sprintf("%s/%s/masked=%v", row.name, bank, masked)
+				load, copy, store := "64(BP),"+bank+"0", bank+"0,"+bank+"1", bank+"1,128(BP)"
+				prefix := ""
+				if masked {
+					prefix = "KMOVQ AX,K1\n"
+					// Defined merge input and destination memory are independent.
+					prefix += fmt.Sprintf("%s 64(BP),%s0\n%s 64(BP),%s1\n", row.name, bank, row.name, bank)
+					load, copy, store = "64(BP),K1,"+bank+"0", bank+"0,K1,"+bank+"1", bank+"1,K1,128(BP)"
+				}
+				operation := prefix + fmt.Sprintf("%s %s\n%s %s\n%s %s", row.name, load, row.name, copy, row.name, store)
+				assembly := fixedLocalPackedAssembly(operation)
+				original.WriteString(strings.Replace(assembly, "·Value", fmt.Sprintf("·Value%d", count), 1))
+				count++
+				t.Run(name, func(t *testing.T) {
+					pkg, _, file, options := fixedLocalPackedFixture(t, operation)
+					if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") ||
+						GoAMD64FixedLocalFrameBindingNeeded(file, "386") {
+						t.Error("physical private-frame transport needs its original backing regardless of alignment")
+					}
+					if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+						t.Fatalf("initialized pure numeric packed-frame proof: %v", err)
+					}
+				})
+			}
+		}
+	}
+	if count != 64 {
+		t.Fatalf("independent full family fixture count changed: %d", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalPackedMoveActualOriginalObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		for _, operation := range []string{
+			"VMOVDQA 64(BP),Y0\nVMOVDQA Y0,128(BP)",
+			"VMOVDQA64 64(BP),Z31\nVMOVDQA64 Z31,128(BP)",
+		} {
+			t.Run(target.name+"/"+strings.Fields(operation)[0], func(t *testing.T) {
+				pkg, request, file, options := fixedLocalPackedFixture(t, operation)
+				request.Target, options.TargetTriple = target.name, target.triple
+				source := requireGoAMD64FrameCapture(t, pkg, request)
+				observed := source.functions[pkg.Path+".Value"]
+				if observed.locals != 264 || observed.args != 16 || len(observed.code) == 0 {
+					t.Fatal("missing original automatic frame/object witness")
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+					if err != nil || !strings.Contains(ir, "fixed_local_native") || !strings.Contains(ir, "asm sideeffect") {
+						t.Fatalf("actual local certificate was not consumed: %v", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "packed-frame.ll", "packed-frame.o", ir)
+				})
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalBPPrivateOriginOnly(t *testing.T) {
+	operation := "MOVOU 64(BP),X0\nPADDQ 64(BP),X0\nMOVOU X0,128(BP)"
+	pkg, _, file, options := fixedLocalPackedFixture(t, operation)
+	sig := options.Sigs[pkg.Path+".Value"]
+	if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+		t.Fatalf("BP private affine source: %v", err)
+	}
+	for name, assembly := range map[string]string{
+		"numeric BP": strings.Replace(fixedLocalPackedAssembly(operation), "MOVQ SP,BP", "MOVQ AX,BP", 1),
+		"unknown BP": strings.Replace(fixedLocalPackedAssembly(operation), "MOVQ SP,BP", "MOVQ DX,BP", 1),
+		"narrow BP":  strings.Replace(fixedLocalPackedAssembly(operation), "MOVQ SP,BP", "MOVL SP,BP", 1),
+		"escaped BP": strings.Replace(fixedLocalPackedAssembly(operation), "MOVQ AX,ret+8(FP)", "MOVQ BP,ret+8(FP)", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if name == "numeric BP" {
+				fixedLocalRequireNumericControl(t, changed.Funcs[0], sig, assembly, "func Value(a uint64) uint64",
+					"PADDQ 64(BP),X0", 0, 16, false, "paddq")
+				return
+			}
+			if _, err := proveX86FixedLocal(changed.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown/numeric/escaping BP obtained local authority: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_pointer_choice_dead_test.go b/amd64_fixed_local_pointer_choice_dead_test.go
new file mode 100644
index 000000000..446cd3838
--- /dev/null
+++ b/amd64_fixed_local_pointer_choice_dead_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalFiveWayPointerBody(final string, spill bool) string {
+	var body strings.Builder
+	join := "JMP joined\n"
+	if spill {
+		join = "MOVQ CX,8(SP)\n" + join
+	}
+	for index := 0; index < 4; index++ {
+		fmt.Fprintf(&body, "CMPQ AX,$%d\nJE choice%d\n", index, index)
+	}
+	body.WriteString("LEAQ choice<>+32(SB),CX\n" + join)
+	for index := 0; index < 4; index++ {
+		fmt.Fprintf(&body, "choice%d:\nLEAQ choice<>+%d(SB),CX\n%s", index, index*8, join)
+	}
+	body.WriteString("joined:\n" + final)
+	return body.String()
+}
+
+type fixedLocalPointerChoiceCFGCase struct {
+	name, final  string
+	spill, fails bool
+}
+
+func fixedLocalPointerChoiceCFGCases() []fixedLocalPointerChoiceCFGCase {
+	return []fixedLocalPointerChoiceCFGCase{
+		{"dead address", "", false, false},
+		{"fully overwritten address", "MOVQ $99,CX\nMOVQ CX,AX", false, false},
+		{"unknown address is not NUM", "MOVQ CX,AX", false, true},
+		{"more than four addresses remain readable", "MOVQ (CX),AX", false, false},
+		{"dead pointer spill", "", true, false},
+		{"fully overwritten spill", "MOVQ $99,8(SP)\nMOVQ 8(SP),AX", true, false},
+		{"unknown spill is not NUM", "MOVQ 8(SP),AX", true, true},
+		{"more than four spilled addresses remain readable", "MOVQ 8(SP),CX\nMOVQ (CX),AX", true, false},
+	}
+}
+
+func fixedLocalPointerChoiceAllPositiveCases() []fixedLocalPointerChoiceCase {
+	rows := fixedLocalPointerChoiceCases()
+	for _, row := range fixedLocalPointerChoiceCFGCases() {
+		if !row.fails {
+			rows = append(rows, fixedLocalPointerChoiceCase{row.name, fixedLocalFiveWayPointerBody(row.final, row.spill)})
+		}
+	}
+	return rows
+}
+
+func TestGoAMD64FixedLocalPointerChoiceDeadCFGOrigins(t *testing.T) {
+	var original strings.Builder
+	original.WriteString(fixedLocalChoiceData)
+	for index, row := range fixedLocalPointerChoiceCFGCases() {
+		fn, sig, source := fixedLocalPointerChoiceFixture(t, fixedLocalFiveWayPointerBody(row.final, row.spill))
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			_, err := proveX86FixedLocal(fn, sig)
+			if row.fails {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("CFG address acquired a numerical value", err)
+				}
+			} else if err != nil {
+				t.Fatal("unused or overwritten CFG address became a new rejection", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
diff --git a/amd64_fixed_local_pointer_choice_objects_go127_test.go b/amd64_fixed_local_pointer_choice_objects_go127_test.go
new file mode 100644
index 000000000..acc40a040
--- /dev/null
+++ b/amd64_fixed_local_pointer_choice_objects_go127_test.go
@@ -0,0 +1,16 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+// Mixed DATA uses the existing audited Go 1.27 object producer. Older SDKs
+// retain the native-only object gate and an explicit producer rejection test.
+func TestGoAMD64FixedLocalPointerChoiceObjects(t *testing.T) {
+	rows := fixedLocalPointerChoiceAllPositiveCases()
+	if len(rows) != 25 {
+		t.Fatal("expected 19 address-choice and 6 complete CFG functions", len(rows))
+	}
+	assembly, declarations := fixedLocalPointerChoiceProgram(t, fixedLocalChoiceData, rows)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(rows))
+}
diff --git a/amd64_fixed_local_pointer_choice_objects_legacy_test.go b/amd64_fixed_local_pointer_choice_objects_legacy_test.go
new file mode 100644
index 000000000..f9adbb91d
--- /dev/null
+++ b/amd64_fixed_local_pointer_choice_objects_legacy_test.go
@@ -0,0 +1,41 @@
+//go:build !go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalPointerChoicesNeedAuditedDATAProducer(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	rows := append(fixedLocalPointerChoiceAllPositiveCases(), fixedLocalNativeAddressCases()...)
+	if len(rows) != 42 {
+		t.Fatal("complete mixed-DATA source inventory changed", len(rows))
+	}
+	assembly, declarations := fixedLocalPointerChoiceProgram(t, fixedLocalChoiceData, rows)
+	// Original Go accepts the complete source. Only the independently audited
+	// object producer is unavailable; this is not an instruction rejection.
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, _ := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil {
+				if closeErr := source.Close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "mixed DATA needs its independent actual Go object producer") {
+				t.Fatal("unaudited mixed-DATA producer did not retain its exact boundary", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_pointer_choice_objects_test.go b/amd64_fixed_local_pointer_choice_objects_test.go
new file mode 100644
index 000000000..3810dc158
--- /dev/null
+++ b/amd64_fixed_local_pointer_choice_objects_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalPointerChoiceProgram(t *testing.T, data string, rows []fixedLocalPointerChoiceCase) (string, string) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	assembly.WriteString(data)
+	for index, row := range rows {
+		_, _, source := fixedLocalPointerChoiceFixture(t, row.body)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p,q *uint64,a uint64) uint64\n", name)
+		t.Logf("complete function example.invalid/framefixture.%s: %s", name, row.name)
+	}
+	t.Logf("complete assembly: functions=%d sha256=%x", len(rows), sha256.Sum256([]byte(assembly.String())))
+	return assembly.String(), declarations.String()
+}
+
+func TestGoAMD64FixedLocalNativePointerChoiceObjects(t *testing.T) {
+	rows := fixedLocalNativePointerChoiceCases()
+	if len(rows) != 3 {
+		t.Fatal("expected one native-input CMOV and two CFG joins", len(rows))
+	}
+	assembly, declarations := fixedLocalPointerChoiceProgram(t, "", rows)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, len(rows))
+}
diff --git a/amd64_fixed_local_pointer_choice_runtime_go127_test.go b/amd64_fixed_local_pointer_choice_runtime_go127_test.go
new file mode 100644
index 000000000..2118b747a
--- /dev/null
+++ b/amd64_fixed_local_pointer_choice_runtime_go127_test.go
@@ -0,0 +1,152 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func fixedLocalPointerChoiceRuntimeProgram(t *testing.T, triple string) (assembly, declarations, original, driver string) {
+	t.Helper()
+	rows := append(fixedLocalPointerChoiceAllPositiveCases(), fixedLocalNativeAddressCases()...)
+	rows = append(rows, fixedLocalMachineAddressCases()...)
+	if len(rows) != 48 {
+		t.Fatal("complete pointer-choice runtime inventory changed", len(rows))
+	}
+	assembly, declarations = fixedLocalPointerChoiceProgram(t, fixedLocalChoiceData, rows)
+	inputs := []uint64{0, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 1 << 63, ^uint64(0)}
+	var goInputs, cInputs, goCalls, cCalls, cDeclarations strings.Builder
+	for _, value := range inputs {
+		fmt.Fprintf(&goInputs, "0x%x,", value)
+		fmt.Fprintf(&cInputs, "UINT64_C(0x%x),", value)
+	}
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index := range rows {
+		label := runtimeCAsmLabel(prefix + fmt.Sprintf("example.invalid/framefixture.Value%d", index))
+		fmt.Fprintf(&cDeclarations, "extern uint64_t value%d(uint64_t*,uint64_t*,uint64_t) __asm__(%s);\n", index, label)
+		fmt.Fprintf(&goCalls, "check(%d,Value%d)\n", index, index)
+		fmt.Fprintf(&cCalls, "check(%d,value%d);\n", index, index)
+	}
+	original = `package main
+import "fmt"
+var inputs = []uint64{` + goInputs.String() + `}
+func check(index int, fn func(*uint64, *uint64, uint64) uint64) {
+    for sample, input := range inputs {
+        for alias := 0; alias < 2; alias++ {
+            var left, right [32]uint64
+            for i := range left {
+                left[i] = uint64(i+1)*0x0102030405060708 ^ input
+                right[i] = ^left[i] ^ 0x96a5b4c3d2e1f087
+            }
+
+            p, q := &left[2], &right[2]
+            if alias != 0 {
+                q = p
+            }
+            value := fn(p, q, input)
+
+            fmt.Printf("%d %d %d %016x", index, sample, alias, value)
+            for _, buffer := range [2][32]uint64{left, right} {
+                for _, value := range buffer {
+                    fmt.Printf(" %016x", value)
+                }
+            }
+            fmt.Println()
+        }
+    }
+}
+` + declarations + "func main() {\n" + goCalls.String() + "}\n"
+	driver = "#include <stdint.h>\n#include <stdio.h>\n" + runtimeCAsmLabelPreamble +
+		cDeclarations.String() + "static const uint64_t inputs[]={" + cInputs.String() + `};
+static void check(int index, uint64_t (*fn)(uint64_t *, uint64_t *, uint64_t)) {
+    for (unsigned sample = 0; sample < 16; sample++) {
+        uint64_t input = inputs[sample];
+        for (unsigned alias = 0; alias < 2; alias++) {
+            uint64_t left[32], right[32];
+            for (unsigned i = 0; i < 32; i++) {
+                left[i] = (uint64_t)(i+1)*UINT64_C(0x0102030405060708)^input;
+                right[i] = ~left[i]^UINT64_C(0x96a5b4c3d2e1f087);
+            }
+
+            uint64_t *p = &left[2], *q = alias ? p : &right[2];
+            uint64_t value = fn(p, q, input);
+
+            printf("%d %u %u %016llx", index, sample, alias, (unsigned long long)value);
+            for (unsigned i = 0; i < 32; i++) {
+                printf(" %016llx", (unsigned long long)left[i]);
+            }
+            for (unsigned i = 0; i < 32; i++) {
+                printf(" %016llx", (unsigned long long)right[i]);
+            }
+            putchar('\n');
+        }
+    }
+}
+int main(void) {
+` + cCalls.String() + "return 0;\n}\n"
+	return
+}
+
+func fixedLocalPointerChoiceRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly, declarations, original, driver := fixedLocalPointerChoiceRuntimeProgram(t, execution.triple)
+	var want []string
+	if execute {
+		output := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original)
+		want = strings.Split(strings.TrimSpace(string(output)), "\n")
+		if len(want) != 48*16*2 {
+			t.Fatal("original Go pointer-choice runtime output inventory changed", len(want))
+		}
+	} else {
+		x86COMICompileOriginalGo(t, map[string]string{
+			"go.mod": "module pointerchoices\ngo 1.20\n", "main.go": original, "original_amd64.s": assembly,
+		}, false)
+	}
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations,
+		runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly,
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					if !execute {
+						execution.compileLLVM(t, "pointer-choices", input, driver, level)
+						return
+					}
+					output := execution.compileAndRunLLVM(t, "pointer-choices", input, driver, level)
+					got := strings.Split(strings.TrimSpace(string(output)), "\n")
+					if len(got) != len(want) {
+						t.Fatal("LLVM pointer-choice output inventory changed", len(got), len(want))
+					}
+					for index := range want {
+						if got[index] != want[index] {
+							t.Fatalf("pointer-choice kernel=%d sample=%d alias=%d: original=%s LLVM=%s",
+								index/32, index/2%16, index%2, want[index], got[index])
+						}
+					}
+				})
+			}
+		})
+	t.Logf("48 complete functions, 16 input patterns, two pointer alias relations, return and both 256-byte buffers; execute=%v", execute)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPointerChoices(t *testing.T) {
+	fixedLocalPointerChoiceRuntime(t, x86FloatCompareRuntimeTools(t, x86FloatCompareSSE), true)
+}
+
+func TestGoAMD64FixedLocalPointerChoiceRuntimeObjects(t *testing.T) {
+	fixedLocalPointerChoiceRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
diff --git a/amd64_fixed_local_pointer_choices_test.go b/amd64_fixed_local_pointer_choices_test.go
new file mode 100644
index 000000000..7d79a7837
--- /dev/null
+++ b/amd64_fixed_local_pointer_choices_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const fixedLocalChoiceData = "DATA choice<>+0(SB)/8,$11\n" +
+	"DATA choice<>+56(SB)/8,$19\nGLOBL choice<>(SB),8,$64\n" +
+	"DATA other<>+0(SB)/8,$23\nGLOBL other<>(SB),8,$64\n" +
+	"DATA twin<>+0(SB)/8,$11\nDATA twin<>+56(SB)/8,$19\nGLOBL twin<>(SB),8,$64\n"
+
+const fixedLocalChoicePrefix = "LEAQ choice<>(SB),R8\nMOVQ SI,CX\nCMPQ AX,$0\nCMOVQEQ R8,CX\n"
+
+type fixedLocalPointerChoiceCase struct{ name, body string }
+
+func fixedLocalChoiceCountBody(count int) string {
+	var body strings.Builder
+	body.WriteString("LEAQ choice<>(SB),CX\n")
+	for index := 1; index < count; index++ {
+		fmt.Fprintf(&body, "LEAQ choice<>+%d(SB),R8\nCMPQ AX,$%d\nCMOVQEQ R8,CX\n", index*8, index)
+	}
+	body.WriteString("MOVQ (CX),AX")
+	return body.String()
+}
+
+func fixedLocalNativePointerChoiceCases() []fixedLocalPointerChoiceCase {
+	return []fixedLocalPointerChoiceCase{
+		{"two native inputs", "MOVQ SI,CX\nCMPQ AX,$0\nCMOVQEQ DI,CX\nMOVQ (CX),AX"},
+		{"affine native input join", "CMPQ AX,$0\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ DI,CX\njoin:\nMOVQ (CX),AX"},
+		{"memory native input join", "CMPQ AX,$1\nJEQ left\nMOVQ SI,CX\nJMP join\nleft:\nMOVQ DI,CX\njoin:\nMOVQ (CX),AX"},
+	}
+}
+
+func fixedLocalPointerChoiceCases() []fixedLocalPointerChoiceCase {
+	rows := []fixedLocalPointerChoiceCase{
+		{"conditional read", fixedLocalChoicePrefix + "MOVQ (CX),AX"},
+		{"reverse conditional operands", "LEAQ choice<>(SB),CX\nCMPQ AX,$0\nCMOVQNE SI,CX\nMOVQ (CX),AX"},
+	}
+	rows = append(rows, fixedLocalNativePointerChoiceCases()...)
+	return append(rows, []fixedLocalPointerChoiceCase{
+		{"two literals", "LEAQ choice<>(SB),CX\nLEAQ other<>(SB),DX\nCMPQ AX,$0\nCMOVQEQ DX,CX\nMOVQ (CX),AX"},
+		{"identical contents retain address identity", "LEAQ choice<>(SB),CX\nLEAQ twin<>(SB),DX\nCMPQ CX,DX\nSETNE AL\nMOVBLZX AL,AX"},
+		{"two offsets", "LEAQ choice<>(SB),CX\nLEAQ choice<>+8(SB),DX\nCMPQ AX,$0\nCMOVQEQ DX,CX\nMOVOU 32(CX),X0\nMOVQ X0,AX"},
+		{"four bounded choices", fixedLocalChoiceCountBody(4)},
+		{"CFG join", "CMPQ AX,$0\nJE literal\nMOVQ SI,CX\nJMP joined\nliteral:\nLEAQ choice<>(SB),CX\njoined:\nMOVQ (CX),AX"},
+		{"private pointer spill", fixedLocalChoicePrefix + "MOVQ CX,8(SP)\nMOVQ 8(SP),DX\nMOVQ (DX),AX"},
+		{"conditional pointer spill read", "LEAQ choice<>(SB),R8\nMOVQ R8,8(SP)\nMOVQ SI,CX\nCMPQ AX,$0\nCMOVQEQ 8(SP),CX\nMOVQ (CX),AX"},
+		{"exchange pointer spill", fixedLocalChoicePrefix + "MOVQ CX,8(SP)\nMOVQ DI,DX\nXCHGQ DX,8(SP)\nMOVQ (DX),AX"},
+		{"bounded affine shift", fixedLocalChoicePrefix + "ADDQ $8,CX\nMOVQ 48(CX),AX"},
+		{"sentinel excludes readonly write", fixedLocalChoicePrefix + "CMPQ CX,R8\nJE done\nMOVQ AX,(CX)\ndone:"},
+		{"sentinel excludes literal extent", fixedLocalChoicePrefix + "CMPQ CX,R8\nJE done\nMOVQ 64(CX),AX\ndone:"},
+		{"captured comparator value", fixedLocalChoicePrefix + "CMPQ CX,R8\nMOVQ DI,R8\nJE done\nMOVQ 64(CX),AX\ndone:"},
+		{"compared value exchanged", fixedLocalChoicePrefix + "CMPQ CX,R8\nXCHGQ CX,DX\nJE done\nMOVQ 64(DX),AX\ndone:"},
+		{"finite sentinel loop", "LEAQ choice<>(SB),R8\nMOVQ SI,CX\nagain:\nCMPQ CX,R8\nJE done\nMOVQ 64(CX),AX\nMOVQ R8,CX\nJMP again\ndone:"},
+	}...)
+}
+
+func fixedLocalPointerChoiceFixture(t *testing.T, body string) (Func, FuncSig, string) {
+	t.Helper()
+	fn, sig, source := fixedLocalInputFixture(t, "MOVQ AX,DX\n"+body)
+	// Internal replay only; the public object gates capture complete sources
+	// through the existing actual Go source/object producer.
+	sig.x86FixedLocal = &x86FixedLocalBinding{literalData: map[string]x86FixedLocalData{
+		"choice<>": {size: 64, alignment: 16},
+		"other<>":  {size: 64, alignment: 16},
+		"twin<>":   {size: 64, alignment: 16},
+	}}
+	return fn, sig, source
+}
+
+func TestGoAMD64FixedLocalPointerChoicesCompleteSources(t *testing.T) {
+	var original strings.Builder
+	original.WriteString(fixedLocalChoiceData)
+	for index, row := range fixedLocalPointerChoiceCases() {
+		fn, sig, assembly := fixedLocalPointerChoiceFixture(t, row.body)
+		original.WriteString(strings.Replace(assembly, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("individually bounded pointer alternatives rejected", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalPointerChoicesRetainBoundaries(t *testing.T) {
+	t.Run("native pointer bits are numerical", func(t *testing.T) {
+		fn, sig, _ := fixedLocalPointerChoiceFixture(t, fixedLocalChoicePrefix+"XORQ CX,AX")
+		if _, err := proveX86FixedLocal(fn, sig); err != nil {
+			t.Fatal("complete native arithmetic source rejected", err)
+		}
+	})
+	for _, row := range []fixedLocalPointerChoiceCase{
+		{"exact address exceeds extent", "LEAQ choice<>(SB),CX\nMOVQ 64(CX),AX"},
+		{"exact vector access crosses extent", "LEAQ choice<>(SB),CX\nMOVOU 56(CX),X0\nMOVQ X0,AX"},
+		{"one candidate is readonly", fixedLocalChoicePrefix + "MOVQ AX,(CX)"},
+		{"partial pointer read", fixedLocalChoicePrefix + "MOVL CX,DX\nMOVQ (DX),AX"},
+		{"partial pointer spill overwrite", fixedLocalChoicePrefix + "MOVQ CX,8(SP)\nMOVB $1,9(SP)\nMOVQ 8(SP),DX\nMOVQ (DX),AX"},
+		{"private relocation is separate", "LEAQ 8(SP),CX\nCMPQ AX,$0\nCMOVQEQ SI,CX\nMOVQ (CX),AX"},
+		{"unknown value is not parameter zero", "CMPQ AX,$0\nCMOVQEQ SI,R12\nMOVQ (R12),AX"},
+		{"stale equality flags", fixedLocalChoicePrefix + "CMPQ CX,R8\nCMPQ AX,$1\nJE done\nMOVQ AX,(CX)\ndone:"},
+		{"compared register overwritten", fixedLocalChoicePrefix + "CMPQ CX,R8\nMOVQ R8,CX\nJE done\nMOVQ 64(CX),AX\ndone:"},
+		{"ordered literal comparison", fixedLocalChoicePrefix + "CMPQ CX,R8\nJAE done\nMOVQ AX,(CX)\ndone:"},
+		{"other literal cannot remove candidate", fixedLocalChoicePrefix + "LEAQ other<>(SB),R9\nCMPQ CX,R9\nJE done\nMOVQ AX,(CX)\ndone:"},
+		{"other offset cannot remove candidate", fixedLocalChoicePrefix + "LEAQ choice<>+8(SB),R9\nCMPQ CX,R9\nJE done\nMOVQ AX,(CX)\ndone:"},
+		{"equality does not grant readonly write", fixedLocalChoicePrefix + "CMPQ CX,R8\nJNE done\nMOVQ AX,(CX)\ndone:"},
+		{"label does not prove identity", fixedLocalChoicePrefix + "native:\nJNE done\nMOVQ AX,(CX)\ndone:"},
+		{"loop reintroduces literal", "LEAQ choice<>(SB),R8\nMOVQ SI,CX\nagain:\nCMPQ CX,R8\nJE done\nMOVQ R8,CX\nMOVQ 64(CX),AX\nJMP again\ndone:"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalPointerChoiceFixture(t, row.body)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("conditional pointer invented an origin, access or predicate", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_portability_test.go b/amd64_fixed_local_portability_test.go
new file mode 100644
index 000000000..75f0c1cf9
--- /dev/null
+++ b/amd64_fixed_local_portability_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"testing"
+)
+
+func TestFixedLocalSharedHelpersBuildOnAllHosts(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			context := build.Default
+			context.GOOS, context.GOARCH = goos, "amd64"
+			found := map[string]int{}
+			for _, name := range []string{
+				"amd64_fixed_local_runtime_test.go",
+				"amd64_fixed_local_packed_runtime_test.go",
+				"amd64_fixed_local_original_test.go",
+			} {
+				if _, err := os.Stat(name); os.IsNotExist(err) {
+					continue
+				}
+				included, err := context.MatchFile(".", name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !included {
+					continue
+				}
+				file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, declaration := range file.Decls {
+					switch declaration := declaration.(type) {
+					case *ast.FuncDecl:
+						found[declaration.Name.Name]++
+					case *ast.GenDecl:
+						for _, spec := range declaration.Specs {
+							if value, ok := spec.(*ast.ValueSpec); ok {
+								for _, name := range value.Names {
+									found[name.Name]++
+								}
+							}
+						}
+					}
+				}
+			}
+			for _, name := range []string{"fixedLocalNativeOperations", "fixedLocalPackedRunOriginal"} {
+				if found[name] != 1 {
+					t.Errorf("portable tests require exactly one %s, found %d", name, found[name])
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_private_leaf.go b/amd64_fixed_local_private_leaf.go
new file mode 100644
index 000000000..3280a861e
--- /dev/null
+++ b/amd64_fixed_local_private_leaf.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+// Both consumers share the source graph, callsite expansion and per-root
+// limits. Total work may span more roots; the authenticated source inventory
+// and each proof's work bounds remain unchanged. Memory and result facts still
+// come from the existing fixed-local transfer and replay.
+func newX86FixedLocalLeafGraph(file *File, options Options, binding *x86FixedLocalBinding) (*x86DirectTailGraph, error) {
+	if len(binding.leaves) == 0 {
+		return nil, nil
+	}
+	helpers := make(map[string]bool, len(binding.leaves))
+	for symbol := range binding.leaves {
+		helpers[symbol] = true
+	}
+	graph, byName, err := newX86DirectTailGraph(file, options, helpers, "amd64")
+	if err != nil {
+		return nil, err
+	}
+	graph.fixedLocal = binding
+	reached := make(map[string]bool)
+	for index, fn := range graph.original.Funcs {
+		if helpers[fn.Sym] || !x86DirectTailRootTargets(fn, helpers, nil) {
+			continue
+		}
+		if !binding.frames[graph.symbols[fn.Sym]] {
+			return nil, goAMD64FrameContext("private leaf caller lacks its independently observed nonzero root frame")
+		}
+		view, err := graph.root(index, byName, 4096, true)
+		if err != nil {
+			return nil, err
+		}
+		// Keep only the original root identity. Each consumer expands one root
+		// in its own function scope; the complete source is never cropped.
+		graph.roots[fn.Sym] = &x86DirectTailRoot{graph: graph, text: index}
+		for _, point := range view.points {
+			reached[graph.original.Funcs[point.text].Sym] = true
+		}
+	}
+	for symbol := range helpers {
+		if !reached[symbol] {
+			return nil, goAMD64FrameContext("observed private leaf has no complete framed caller")
+		}
+	}
+	return graph, nil
+}
+
+// The shared constructor still checks the 4096-node limit before allocating.
+// Its returned view is local to one proof/renderer/reference operation, never
+// installed in the complete file or retained in the graph's root directory.
+func (graph *x86DirectTailGraph) fixedLocalRoot(symbol string) (*x86DirectTailRoot, error) {
+	if graph == nil || graph.fixedLocal == nil {
+		return nil, nil
+	}
+	root := graph.roots[symbol]
+	if root == nil {
+		return nil, nil
+	}
+	if graph.revoked.Load() || root.graph != graph || root.text < 0 || root.text >= len(graph.original.Funcs) ||
+		graph.original.Funcs[root.text].Sym != symbol {
+		return nil, goAMD64FrameContext("private leaf original root identity changed")
+	}
+	return graph.root(root.text, graph.texts, 4096, true)
+}
+
+func proveX86FixedLocalRoot(fn Func, sig FuncSig, graph *x86DirectTailGraph) (Func, error) {
+	view, err := graph.fixedLocalRoot(fn.Sym)
+	if err != nil {
+		return fn, err
+	}
+	fn.x86DirectTailRoot = view
+	return proveX86FixedLocal(fn, sig)
+}
+
+func prepareX86FixedLocalLeafSource(file *File, options Options) (*File, bool, error) {
+	for _, sig := range options.Sigs {
+		binding := sig.x86FixedLocal
+		if binding == nil || len(binding.leaves) == 0 {
+			continue
+		}
+		if graph := file.x86DirectTails; graph != nil {
+			if graph.fixedLocal != binding {
+				return nil, true, goAMD64FrameContext("private leaf graph belongs to another frame owner")
+			}
+			return file, true, graph.verify(file, options)
+		}
+		if _, err := verifyX86FixedLocalBindings(file, options); err != nil {
+			return nil, true, err
+		}
+		graph, err := newX86FixedLocalLeafGraph(file, options, binding)
+		if err != nil {
+			return nil, true, err
+		}
+		request := x86DirectTailSnapshot(file)
+		request.x86DirectTails = graph
+		return request, true, graph.verify(request, options)
+	}
+	return file, false, nil
+}
+
+func fixedLocalProofFunction(fn Func) Func {
+	if view := fn.x86DirectTailRoot; view != nil {
+		fn.Instrs = view.instructions
+	}
+	return fn
+}
+
+// Selection only: the live fixed-local binder and full replay still validate
+// this caller. Its canonical result must not be reclassified as a custom call.
+func fixedLocalPrivateLeafCaller(fn Func, sig FuncSig) bool {
+	binding := sig.x86FixedLocal
+	return binding != nil && len(binding.leaves) != 0 && binding.frames[sig.Name] && binding.symbols[fn.Sym] == sig.Name
+}
+
+// Signature selection only. A transported real root binding identifies which
+// source TEXTs must remain non-callable; the complete live binding is still
+// verified before preparation/lowering and cannot be manufactured by a name.
+func goFixedLocalLeafSymbols(file *File, resolve func(string) string, manual func(string) (FuncSig, bool)) map[string]bool {
+	if manual == nil {
+		return nil
+	}
+	var leaves map[string]bool
+	for _, fn := range file.Funcs {
+		name := resolve(goTextSymbolForResolution(fn.Sym))
+		sig, supplied := goLookupManualSig(manual, name)
+		if !supplied || !fixedLocalPrivateLeafCaller(fn, sig) {
+			continue
+		}
+		if leaves == nil {
+			leaves = make(map[string]bool)
+		}
+		for symbol := range sig.x86FixedLocal.leaves {
+			leaves[symbol] = true
+		}
+	}
+	return leaves
+}
diff --git a/amd64_fixed_local_private_leaf_go127_test.go b/amd64_fixed_local_private_leaf_go127_test.go
new file mode 100644
index 000000000..4c18805eb
--- /dev/null
+++ b/amd64_fixed_local_private_leaf_go127_test.go
@@ -0,0 +1,285 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func fixedLocalPrivateLeafCases() []struct{ name, body, helper string } {
+	return []struct{ name, body, helper string }{
+		{"two_calls", "CALL leaf<>(SB)\n MOVQ $3,BX\n CALL leaf<>(SB)",
+			"ADDQ BX,(BP)\n MOVQ (BP),AX"},
+		{"incoming_flags", "CMPQ AX,BX\n CALL leaf<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+			"MOVQ AX,DX\n MOVQ (BP),AX"},
+		{"outgoing_flags", "CALL leaf<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+			"CMPQ AX,BX"},
+		{"distinct_call_addresses", "CALL leaf<>(SB)\n MOVQ AX,DX\n LEAQ 24(SP),BP\n CALL leaf<>(SB)\n ADDQ DX,AX",
+			"ADDQ $1,(BP)\n MOVQ (BP),AX"},
+		{"ordinary_address_register", "LEAQ 16(SP),SI\n CALL leaf<>(SB)",
+			"MOVQ (SI),AX\n ADDQ BX,AX\n MOVQ AX,(SI)"},
+	}
+}
+
+func fixedLocalPrivateLeafSource(body, helper string) string {
+	return `TEXT ·Value(SB),4,$80-16
+ MOVQ a+0(FP),AX
+ MOVQ AX,16(SP)
+ MOVQ $7,BX
+ MOVQ BX,24(SP)
+ LEAQ 16(SP),BP
+ ` + body + `
+ MOVQ AX,ret+8(FP)
+ RET
+TEXT leaf<>(SB),4,$0
+ ` + helper + `
+ RET
+`
+}
+
+func fixedLocalPrivateLeafFixture(t *testing.T, assembly string, declarations ...string) (GoPackage, GoAMD64FrameCaptureRequest, Options) {
+	t.Helper()
+	declaration := "func Value(a uint64) uint64"
+	if len(declarations) == 1 {
+		declaration = declarations[0]
+	} else if len(declarations) != 0 {
+		t.Fatal("expected at most one actual Go declaration")
+	}
+	pkg, request := goAMD64FrameTypedFixture(t, declaration, assembly)
+	decl := pkg.Types.Scope().Lookup("Value").(*types.Func)
+	sig, err := DeriveGoFuncABI0Signature(pkg.Path+".Value", decl, "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, request, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: testResolveSym(pkg.Path), Sigs: map[string]FuncSig{sig.Name: sig},
+	}
+}
+
+func TestGoAMD64FixedLocalPrivateLeafCanonicalResult(t *testing.T) {
+	assembly := strings.NewReplacer("$80-16", "$80-9", "MOVQ AX,ret+8(FP)", "MOVB AX,ret+8(FP)").Replace(
+		fixedLocalPrivateLeafSource("CALL leaf<>(SB)\n SETCS AL", "CMPQ AX,BX"))
+	x86InsertExtractGoListing(t, "amd64", assembly)
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly, "func Value(a uint64) bool")
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil || strings.Count(ir, "define ") != 1 {
+				t.Fatal("actual framed canonical result did not retain its ordinary owner", err, ir)
+			}
+			fixedLocalPrivateLeafObjects(t, ir)
+		})
+}
+
+func TestGoAMD64FixedLocalPrivateLeafBareSymbol(t *testing.T) {
+	assembly := strings.ReplaceAll(fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "MOVQ (BP),AX"), "leaf<>", "leaf")
+	x86InsertExtractGoListing(t, "amd64", assembly)
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil || strings.Count(ir, "define ") != 1 {
+				t.Fatal("same-source bare leaf lost its observed source role", err, ir)
+			}
+			fixedLocalPrivateLeafObjects(t, ir)
+		})
+}
+
+func TestGoAMD64FixedLocalPrivateLeafWholeVectorResults(t *testing.T) {
+	// Both qwords cross CALL, change in the leaf, and return separately.
+	// This exercises private vector transport without claiming that the
+	// separate GP-to-XMM MOVQ fixed-local owner gap has been implemented.
+	assembly := `TEXT ·Value(SB),4,$80-24
+ MOVQ a+0(FP),AX
+ MOVQ AX,16(SP)
+ MOVQ $7,BX
+ MOVQ BX,24(SP)
+ MOVOU 16(SP),X0
+ CALL leaf<>(SB)
+ MOVOU X0,32(SP)
+ MOVQ 32(SP),AX
+ MOVQ 40(SP),BX
+ MOVQ AX,first+8(FP)
+ MOVQ BX,second+16(FP)
+ RET
+TEXT leaf<>(SB),4,$0
+ PADDQ X0,X0
+ RET
+`
+	x86InsertExtractGoListing(t, "amd64", assembly)
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly, "func Value(a uint64) (first, second uint64)")
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil || strings.Count(ir, "define ") != 1 {
+				t.Fatal("complete vector did not return both independent typed results", err, ir)
+			}
+			fixedLocalPrivateLeafObjects(t, ir)
+		})
+}
+
+func TestGoAMD64FixedLocalPrivateLeafCompleteSources(t *testing.T) {
+	for _, row := range fixedLocalPrivateLeafCases() {
+		t.Run(row.name, func(t *testing.T) {
+			assembly := fixedLocalPrivateLeafSource(row.body, row.helper)
+			// Exact valid FP labels and all original helper TEXTs are assembled
+			// before testing the observer or the translator's private contract.
+			listing := x86InsertExtractGoListing(t, "amd64", assembly)
+			if !strings.Contains(string(listing), "CALL") || !strings.Contains(string(listing), "leaf") {
+				t.Fatal("original Go omitted the complete helper call")
+			}
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("nonzero root and original zero-frame leaf are not composed", err)
+					}
+					if strings.Count(ir, "define ") != 1 || !strings.Contains(ir, "fixed_local_native") ||
+						strings.Contains(ir, "call void @\"leaf") || strings.Contains(ir, "define void @\"leaf") {
+						t.Fatal("leaf acquired an independent ABI or lost its root frame", ir)
+					}
+					fixedLocalPrivateLeafObjects(t, ir)
+				})
+		})
+	}
+}
+
+func fixedLocalPrivateLeafObjects(t *testing.T, ir string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const target = "x86_64-unknown-linux-gnu"
+	compileLLVMToObject(t, llc, target, "private-leaf.ll", "private-leaf.o", ir)
+	compileLLVMToObject(t, llc, target, "private-leaf-opt.ll", "private-leaf-opt.o", x86MulDivRoundOptimize(t, ir))
+}
+
+func TestGoAMD64FixedLocalPrivateLeafBoundaries(t *testing.T) {
+	valid := fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "MOVQ (BP),AX")
+	for _, row := range []struct{ name, source string }{
+		{"undefined_input", strings.Replace(valid, "MOVQ (BP),AX", "MOVQ R8,AX", 1)},
+		{"uninitialized_private", strings.Replace(valid, "MOVQ AX,16(SP)", "NOP", 1)},
+		{"outside_private_extent", strings.Replace(valid, "MOVQ (BP),AX", "MOVQ 80(BP),AX", 1)},
+		{"callee_SP", strings.Replace(valid, "MOVQ (BP),AX", "MOVQ 16(SP),AX", 1)},
+		{"callee_FP", strings.Replace(valid, "MOVQ (BP),AX", "MOVQ a+0(FP),AX", 1)},
+		{"callee_nonzero_frame", strings.Replace(valid, "TEXT leaf<>(SB),4,$0", "TEXT leaf<>(SB),4,$8", 1)},
+		{"callee_negative_frame", strings.Replace(valid, "TEXT leaf<>(SB),4,$0", "TEXT leaf<>(SB),4,$-8", 1)},
+		{"callee_nonleaf", strings.Replace(valid, "MOVQ (BP),AX", "CALL second<>(SB)", 1) + "TEXT second<>(SB),4,$0\n RET\n"},
+		{"indirect_call", strings.Replace(valid, "CALL leaf<>(SB)", "CALL AX", 1)},
+		{"address_escape", strings.Replace(valid, "CALL leaf<>(SB)", "LEAQ leaf<>(SB),AX\n CALL AX", 1)},
+		{"dead_unclosed_helper", valid + "TEXT unused<>(SB),4,$8\n RET\n"},
+		{"recursive", strings.Replace(valid, "MOVQ (BP),AX", "CALL leaf<>(SB)", 1)},
+		{"missing_flags", strings.Replace(valid, "MOVQ (BP),AX", "SETCS CL\n MOVBLZX CL,AX", 1)},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			x86InsertExtractGoListing(t, "amd64", row.source)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, row.source)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			switch row.name {
+			case "undefined_input", "uninitialized_private", "outside_private_extent", "missing_flags":
+				if err != nil {
+					t.Fatal("semantic negative requires successful complete original capture", err)
+				}
+			}
+			if err == nil {
+				defer owner.Close()
+				expanded, readErr := owner.preprocess(request.AssemblyFile, []byte(row.source))
+				if readErr != nil {
+					t.Fatal(readErr)
+				}
+				file, parseErr := Parse(ArchAMD64, expanded)
+				if parseErr != nil {
+					t.Fatal(parseErr)
+				}
+				_, err = owner.BindFixedLocal(ctx, pkg, file, options)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unclosed helper/frame/state became authorized", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPrivateLeafRejectsSuppliedSignature(t *testing.T) {
+	for _, symbol := range []string{"leaf<>", "leaf"} {
+		t.Run(symbol, func(t *testing.T) {
+			assembly := strings.ReplaceAll(fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "MOVQ (BP),AX"), "leaf<>", symbol)
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("complete original source precondition", err)
+			}
+			defer owner.Close()
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := options.ResolveSym(symbol)
+			options.Sigs[name] = FuncSig{Name: name, Ret: Void}
+			if _, err := owner.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "private leaf cannot acquire a supplied callable signature") {
+				t.Fatal("public binding silently discarded a caller-supplied helper ABI", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64SDKFramePrivateLeafWholeOriginalSource(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "vendor/golang.org/x/crypto/chacha20poly1305")
+	original, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete actual SDK precondition", err)
+	}
+	defer original.Close()
+	pkg := sdkAMD64FrameActualPackage(t, original.source)
+	owner, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, Target: request.Target,
+		AssemblyFile: "chacha20poly1305_amd64.s", Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("complete original leaf and declared root observation", err)
+	}
+	defer owner.Close()
+	if len(owner.functions) != 3 || len(owner.declarations) != 2 {
+		t.Fatal("complete original TEXT inventory or actual declarations changed",
+			len(owner.functions), len(owner.declarations))
+	}
+	for _, name := range []string{"chacha20Poly1305Open", "chacha20Poly1305Seal"} {
+		fn, found := owner.functions[pkg.Path+"."+name]
+		if !found || fn.signature.Name != pkg.Path+"."+name || fn.locals != 296 {
+			t.Fatal("root lost its actual Go signature or physical frame", name)
+		}
+	}
+	leaves := 0
+	for name, fn := range owner.functions {
+		if strings.Contains(name, "polyHashADInternal") {
+			leaves++
+			if fn.signature.Name != "" || len(fn.code) == 0 {
+				t.Fatal("leaf gained a Go signature or lost original bytes", name)
+			}
+		}
+	}
+	if leaves != 1 {
+		t.Fatal("complete original inventory lost or duplicated its leaf", leaves)
+	}
+	for _, cpp := range owner.sdkFrame.owner.source.observation.CPP {
+		file, err := Parse(ArchAMD64, cpp.Output)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, fn := range file.Funcs {
+			t.Logf("complete original TEXT %s: %d parsed non-label instructions", fn.Sym, len(x86DirectTailInstructions(fn)))
+		}
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("all %d original TEXTs observed; this capture alone is not translation coverage", len(owner.functions))
+}
diff --git a/amd64_fixed_local_private_leaf_identity_go127_test.go b/amd64_fixed_local_private_leaf_identity_go127_test.go
new file mode 100644
index 000000000..d9c6048c4
--- /dev/null
+++ b/amd64_fixed_local_private_leaf_identity_go127_test.go
@@ -0,0 +1,109 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64FixedLocalPrivateLeafOriginalCallIdentity(t *testing.T) {
+	assembly := fixedLocalPrivateLeafSource("CALL leaf<>(SB)\n CALL other<>(SB)", "MOVQ (BP),AX") +
+		"TEXT other<>(SB),4,$0\n ADDQ $2,AX\n RET\n"
+	x86InsertExtractGoListing(t, "amd64", assembly)
+	pkg, request, _ := fixedLocalPrivateLeafFixture(t, assembly)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	expanded, err := owner.preprocess(request.AssemblyFile, []byte(assembly))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := owner.fixedLocalDataObservation(request.AssemblyFile, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	listing, err := owner.read(filepath.Join(owner.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	check := func(data *gostaticstorage.AMD64AssemblyData, listing []byte, file *File) error {
+		functions, err := goAMD64FrameListingWithDataObject(listing, file, pkg, owner.origins, data, nil,
+			request.Target, request.Directory, "")
+		if err != nil {
+			return err
+		}
+		return goAMD64FrameDataTextJoin(functions, data, request.Directory, owner.origins, "")
+	}
+	if err := check(data, listing, file); err != nil {
+		t.Fatal("complete actual original source/object/listing control", err)
+	}
+	root := data.TextOrder[0].ObjectOrdinal
+	if root == 0 || len(data.Member.Texts[root].Relocations) != 2 {
+		t.Fatal("fixture did not exercise separate static/nonstatic banks and both CALLs")
+	}
+	encoded, err := json.Marshal(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{
+		"valid_other_leaf", "wrong_bank", "wrong_relative", "unknown_ABI", "call_addend", "call_width",
+		"call_field_inside_opcode", "missing_CALL", "missing_source_association", "reordered_source_association", "missing_parsed_TEXT",
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gostaticstorage.AMD64AssemblyData
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			input := bytes.Clone(listing)
+			parsed := *file
+			relocation := &changed.Member.Texts[root].Relocations[0]
+			switch name {
+			case "valid_other_leaf":
+				before := goAMD64FrameDataRelocationLine(*relocation, &changed)
+				relocation.Target = changed.Member.Texts[root].Relocations[1].Target
+				after := goAMD64FrameDataRelocationLine(*relocation, &changed)
+				if before == "" || after == "" || before == after {
+					t.Fatal("mutation did not retain another valid actual local object target")
+				}
+				input = bytes.Replace(input, []byte(before), []byte(after), 1)
+			case "wrong_bank":
+				relocation.Target.PackageIndex++
+			case "wrong_relative":
+				relocation.Target.SymbolIndex++
+			case "unknown_ABI":
+				relocation.Target.ABIKnown = false
+			case "call_addend":
+				relocation.Add++
+			case "call_width":
+				relocation.Size++
+			case "call_field_inside_opcode":
+				relocation.Offset--
+			case "missing_CALL":
+				changed.Member.Texts[root].Relocations = changed.Member.Texts[root].Relocations[1:]
+			case "missing_source_association":
+				changed.TextOrder = changed.TextOrder[:len(changed.TextOrder)-1]
+			case "reordered_source_association":
+				changed.TextOrder[1], changed.TextOrder[2] = changed.TextOrder[2], changed.TextOrder[1]
+			case "missing_parsed_TEXT":
+				parsed.Funcs = parsed.Funcs[:len(parsed.Funcs)-1]
+			}
+			if err := check(&changed, input, &parsed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed complete source/native CALL identity was accepted", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_private_leaf_lifetime_go127_test.go b/amd64_fixed_local_private_leaf_lifetime_go127_test.go
new file mode 100644
index 000000000..5e0285636
--- /dev/null
+++ b/amd64_fixed_local_private_leaf_lifetime_go127_test.go
@@ -0,0 +1,411 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func fixedLocalLeafLifetimeFixture(t *testing.T, roots, adds, frame int) (GoPackage, GoAMD64FrameCaptureRequest, Options, string) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	names := make([]string, roots)
+	for index := range names {
+		name := "Value"
+		if index != 0 {
+			name = fmt.Sprintf("Other%d", index)
+		}
+		names[index] = name
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$%d-16\n", name, frame)
+		assembly.WriteString(" MOVQ a+0(FP),AX\n MOVQ AX,16(SP)\n LEAQ 16(SP),BP\n")
+		assembly.WriteString(strings.Repeat(" ADDQ $1,AX\n", adds))
+		assembly.WriteString(" CALL leaf<>(SB)\n MOVQ AX,ret+8(FP)\n RET\n")
+	}
+	assembly.WriteString("TEXT leaf<>(SB),4,$0\n ADDQ AX,(BP)\n MOVQ (BP),AX\n RET\n")
+	source := assembly.String()
+	listing := x86InsertExtractGoListing(t, "amd64", source)
+	t.Logf("actual Go accepted complete source: sha256=%x listing_bytes=%d roots=%d", sha256.Sum256([]byte(source)), len(listing), roots)
+	pkg, request, options := fixedLocalPrivateLeafFixture(t, source, declarations.String())
+	for _, name := range names {
+		sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name,
+			pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	return pkg, request, options, source
+}
+
+func fixedLocalLeafLifetimeBinding(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest,
+	options Options, assembly string) (*File, Options, error) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	t.Cleanup(cancel)
+	owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("complete original source observation must precede the graph bound", err)
+	}
+	t.Cleanup(func() {
+		if err := owner.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	expanded, err := owner.preprocess(request.AssemblyFile, []byte(assembly))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != len(options.Sigs)+1 || len(owner.functions) != len(file.Funcs) {
+		t.Fatal("whole original root and leaf inventory was not retained")
+	}
+	bound, err := owner.BindFixedLocal(ctx, pkg, file, options)
+	return file, bound, err
+}
+
+func fixedLocalLeafLifetimeObjects(t *testing.T, expectedRoots int, ir string, err error) {
+	t.Helper()
+	if err != nil || strings.Count(ir, "define ") != expectedRoots {
+		t.Fatal("complete original roots did not all translate", err)
+	}
+	fixedLocalPrivateLeafObjects(t, ir)
+}
+
+func TestGoAMD64FixedLocalPrivateLeafPreservesPerRootWorkBudget(t *testing.T) {
+	pkg, request, options, source := fixedLocalLeafLifetimeFixture(t, 2, 1500, 2048)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) { fixedLocalLeafLifetimeObjects(t, 2, ir, err) })
+	t.Run("actual_replay_work", func(t *testing.T) {
+		file, bound, err := fixedLocalLeafLifetimeBinding(t, pkg, request, options, source)
+		if err != nil {
+			t.Fatal("old complete source must remain accepted", err)
+		}
+		prepared, err := PrepareX86DirectTailSource(file, bound)
+		if err != nil {
+			t.Fatal(err)
+		}
+		graph := prepared.x86DirectTails
+		byName := make(map[string]int)
+		for index, fn := range graph.original.Funcs {
+			byName[fn.Sym] = index
+		}
+		totalNodes, totalBytes := 0, int64(0)
+		for index, original := range graph.original.Funcs {
+			if graph.helpers[original.Sym] {
+				continue
+			}
+			// Use the real graph builder and transfer budget. This is a work
+			// measurement, not a substitute certificate for the public API above.
+			view, err := graph.root(index, byName, 4096, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := original
+			fn.x86DirectTailRoot = view
+			fn = fixedLocalProofFunction(fn)
+			sig := bound.Sigs[bound.ResolveSym(original.Sym)]
+			proof := &x86FixedLocalProof{binding: sig.x86FixedLocal, frame: fn.FrameSize}
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			for phase := 0; phase < 2; phase++ {
+				current := fn
+				current.Instrs = append([]Instr(nil), fn.Instrs...)
+				effects, err := fixedLocalEffectPlan(current, sig.x86FixedLocal)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for residue := 0; residue < 8; residue++ {
+					if err := replayX86FixedLocal(&current, sig, proof, residue, &budget, effects, nil); err != nil {
+						t.Fatal("unchanged per-proof work bound rejected the old source", err)
+					}
+				}
+			}
+			steps, bytes := (1<<18)-budget.steps, (64<<20)-budget.bytes
+			if steps != 16*len(view.points) || bytes != int64(steps)*fn.FrameSize || budget.bytes <= 0 {
+				t.Fatal("actual straight-line replay consumption differs", original.Sym, steps, bytes)
+			}
+			t.Logf("actual %s expansion=%d replay_steps=%d byte_work=%d", original.Sym, len(view.points), steps, bytes)
+			totalNodes += len(view.points)
+			totalBytes += bytes
+		}
+		if totalNodes > 4096 || totalBytes <= 64<<20 {
+			t.Fatal("old accepted source no longer distinguishes per-proof from shared work", totalNodes, totalBytes)
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalPrivateLeafSequentialRootCapacity(t *testing.T) {
+	pkg, request, options, _ := fixedLocalLeafLifetimeFixture(t, 2, 2200, 80)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) { fixedLocalLeafLifetimeObjects(t, 2, ir, err) })
+}
+
+func TestGoAMD64FixedLocalPrivateLeafSingleRootCapacity(t *testing.T) {
+	for _, adds := range []int{4087, 4088} {
+		t.Run(fmt.Sprint(adds+9), func(t *testing.T) {
+			pkg, request, options, source := fixedLocalLeafLifetimeFixture(t, 1, adds, 80)
+			file, bound, err := fixedLocalLeafLifetimeBinding(t, pkg, request, options, source)
+			if adds == 4088 {
+				if !errors.Is(err, ErrProbeNeedsContext) ||
+					!strings.Contains(err.Error(), "oversized source continuation instruction budget") {
+					t.Fatal("one oversized original root escaped its unchanged bound", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal("root at the actual existing node bound was rejected", err)
+			}
+			ir, err := Translate(file, bound)
+			fixedLocalLeafLifetimeObjects(t, 1, ir, err)
+		})
+	}
+}
+
+// Count the real retained expansion arrays, not original source text, total
+// allocation or a GC-dependent heap estimate. Shared backing arrays are counted
+// once; independently owned instruction/certificate arrays remain separate.
+type fixedLocalLeafRetained struct{ views, points, instructions, ordinals, edges, tails, accesses int }
+
+func fixedLocalLeafRetainedArrays(file *File) fixedLocalLeafRetained {
+	var retained fixedLocalLeafRetained
+	seen := make(map[*x86DirectTailRoot]bool)
+	points := make(map[*x86DirectTailPoint]bool)
+	instructions := make(map[*Instr]bool)
+	ordinals := make(map[*int]bool)
+	edges := make(map[*[]int]bool)
+	targets := make(map[*int]bool)
+	tails := make(map[*bool]bool)
+	add := func(view *x86DirectTailRoot) {
+		if view == nil || seen[view] {
+			return
+		}
+		seen[view] = true
+		if len(view.points) != 0 || len(view.instructions) != 0 {
+			retained.views++
+		}
+		if cap(view.points) != 0 && !points[&view.points[:cap(view.points)][0]] {
+			points[&view.points[:cap(view.points)][0]] = true
+			retained.points += cap(view.points)
+		}
+		if cap(view.instructions) != 0 && !instructions[&view.instructions[:cap(view.instructions)][0]] {
+			instructions[&view.instructions[:cap(view.instructions)][0]] = true
+			retained.instructions += cap(view.instructions)
+			for _, ins := range view.instructions {
+				retained.accesses += len(ins.x86FixedLocalMemory)
+			}
+		}
+		if cap(view.ordinals) != 0 && !ordinals[&view.ordinals[:cap(view.ordinals)][0]] {
+			ordinals[&view.ordinals[:cap(view.ordinals)][0]] = true
+			retained.ordinals += cap(view.ordinals)
+		}
+		if cap(view.edges) != 0 && !edges[&view.edges[:cap(view.edges)][0]] {
+			edges[&view.edges[:cap(view.edges)][0]] = true
+			retained.edges += cap(view.edges)
+		}
+		for _, edge := range view.edges {
+			if cap(edge) != 0 && !targets[&edge[:cap(edge)][0]] {
+				targets[&edge[:cap(edge)][0]] = true
+				retained.edges += cap(edge)
+			}
+		}
+		if cap(view.externalTails) != 0 && !tails[&view.externalTails[:cap(view.externalTails)][0]] {
+			tails[&view.externalTails[:cap(view.externalTails)][0]] = true
+			retained.tails += cap(view.externalTails)
+		}
+	}
+	if file.x86DirectTails != nil {
+		for _, view := range file.x86DirectTails.roots {
+			add(view)
+		}
+	}
+	for _, fn := range file.Funcs {
+		add(fn.x86DirectTailRoot)
+	}
+	return retained
+}
+
+func TestGoAMD64FixedLocalPrivateLeafRetainedRootViews(t *testing.T) {
+	var scopeBaseline fixedLocalLeafRetained
+	for _, count := range []int{2, 8} {
+		t.Run(fmt.Sprint(count), func(t *testing.T) {
+			pkg, request, options, source := fixedLocalLeafLifetimeFixture(t, count, 8, 80)
+			file, bound, err := fixedLocalLeafLifetimeBinding(t, pkg, request, options, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := PrepareX86DirectTailSource(file, bound)
+			if err != nil {
+				t.Fatal(err)
+			}
+			measure := func(stage string, current *File) {
+				retained := fixedLocalLeafRetainedArrays(current)
+				t.Logf("roots=%d stage=%s actual retained expansion arrays=%+v", count, stage, retained)
+				if retained != (fixedLocalLeafRetained{}) {
+					t.Errorf("%s retained root expansions outside a single-function scope: %+v", stage, retained)
+				}
+			}
+			measure("prepared", prepared)
+			normalized, err := normalizeX86RawFile(prepared, "amd64", bound)
+			if err != nil {
+				t.Fatal(err)
+			}
+			measure("normalized", normalized)
+			binding := bound.Sigs[pkg.Path+".Value"].x86FixedLocal
+			snapshot, err := newX86FixedLocalResultSnapshot(binding, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, original := range file.Funcs {
+				if prepared.x86DirectTailHelper(original.Sym) {
+					continue
+				}
+				retained := snapshot.functions[bound.ResolveSym(original.Sym)].function
+				if len(retained.Instrs) != len(original.Instrs) || retained.x86DirectTailRoot != nil {
+					t.Errorf("result snapshot retained expanded instructions for %s: got %d original %d",
+						original.Sym, len(retained.Instrs), len(original.Instrs))
+				}
+				sig := bound.Sigs[bound.ResolveSym(original.Sym)]
+				current, err := proveX86FixedLocalRoot(original, sig, prepared.x86DirectTails)
+				if err != nil {
+					t.Fatal(err)
+				}
+				entry := snapshot.functions[sig.Name]
+				reference, err := entry.graph.fixedLocalRoot(original.Sym)
+				if err != nil || reference == nil || len(current.x86DirectTailRoot.points) > 4096 || len(reference.points) > 4096 {
+					t.Fatal("current root/reference exceeded the unchanged node bound", err)
+				}
+				// Measure the actual proof and independent reference owners of a
+				// single consumer scope. This temporary container is never sent to
+				// translation and does not crop the authenticated input source.
+				referenceFunc := entry.function
+				referenceFunc.x86DirectTailRoot = reference
+				scope := *prepared
+				scope.Funcs = []Func{current, referenceFunc}
+				live := fixedLocalLeafRetainedArrays(&scope)
+				t.Logf("roots=%d current=%s proof+reference retained arrays=%+v", count, original.Sym, live)
+				if scopeBaseline.views == 0 {
+					scopeBaseline = live
+				}
+				if live.views != 2 || live != scopeBaseline {
+					t.Fatal("single-root retained work grew with complete-file root count", live, scopeBaseline)
+				}
+			}
+			measure("after_root_scopes", prepared)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPrivateLeafScopedControlIdentity(t *testing.T) {
+	pkg, request, options, source := fixedLocalLeafLifetimeFixture(t, 1, 2, 80)
+	file, bound, err := fixedLocalLeafLifetimeBinding(t, pkg, request, options, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := PrepareX86DirectTailSource(file, bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := bound.Sigs[pkg.Path+".Value"]
+	fn, err := proveX86FixedLocalRoot(prepared.Funcs[0], sig, prepared.x86DirectTails)
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot, err := newX86FixedLocalResultSnapshot(sig.x86FixedLocal, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	entry := snapshot.functions[sig.Name]
+	check := func(function Func) error {
+		var output strings.Builder
+		consumer := newX86Ctx(&output, function, sig, bound.ResolveSym, bound.Sigs, "amd64", bound.TargetTriple, false)
+		consumer.fixedLocalResult = snapshot
+		consumer.fpFeatureAttrs, consumer.sig.Attrs = entry.inferred, entry.attributes
+		return consumer.checkFixedLocalResultInitialization()
+	}
+	if err := check(fn); err != nil {
+		t.Fatal("independent complete source/reference precondition", err)
+	}
+	for _, axis := range []string{"text", "point", "ordinal", "edge", "return", "external_tail"} {
+		t.Run(axis, func(t *testing.T) {
+			changed := fn
+			view := *fn.x86DirectTailRoot
+			changed.x86DirectTailRoot = &view
+			switch axis {
+			case "text":
+				view.text++
+			case "point":
+				view.points = append([]x86DirectTailPoint(nil), view.points...)
+				view.points[0].instruction++
+			case "ordinal":
+				view.ordinals = append([]int(nil), view.ordinals...)
+				view.ordinals[0]++
+			case "edge", "return":
+				view.edges = append([][]int(nil), view.edges...)
+				pc := 0
+				if axis == "return" {
+					pc = len(view.instructions) - 1 // The private helper's RET.
+					if view.instructions[pc].Op != OpRET || len(view.edges[pc]) != 1 {
+						t.Fatal("fixture lost its distinct private return continuation")
+					}
+				}
+				view.edges[pc] = []int{0}
+			case "external_tail":
+				view.externalTails = append([]bool(nil), view.externalTails...)
+				view.externalTails[0] = true
+			}
+			if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "original private root control/source coordinates differ") {
+				t.Fatal("unchanged instruction bytes hid a changed private control graph", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPrivateLeafRootDirectoryIdentity(t *testing.T) {
+	pkg, request, options, source := fixedLocalLeafLifetimeFixture(t, 1, 2, 80)
+	file, bound, err := fixedLocalLeafLifetimeBinding(t, pkg, request, options, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := PrepareX86DirectTailSource(file, bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	graph := prepared.x86DirectTails
+	if view, err := graph.fixedLocalRoot("·Value"); err != nil || view == nil {
+		t.Fatal("complete original directory precondition", err)
+	}
+	original := graph.texts
+	for _, axis := range []string{"missing", "negative", "outside", "different_symbol"} {
+		t.Run(axis, func(t *testing.T) {
+			changed := make(map[string]int, len(original))
+			for name, index := range original {
+				changed[name] = index
+			}
+			switch axis {
+			case "missing":
+				delete(changed, "leaf<>")
+			case "negative":
+				changed["leaf<>"] = -1
+			case "outside":
+				changed["leaf<>"] = len(graph.original.Funcs)
+			case "different_symbol":
+				changed["leaf<>"] = original["·Value"]
+			}
+			graph.texts = changed
+			t.Cleanup(func() { graph.texts = original })
+			if _, err := graph.fixedLocalRoot("·Value"); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "tail target is not an original source TEXT") {
+				t.Fatal("retained source directory selected a different or invalid helper index", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_private_leaf_selection_go127_test.go b/amd64_fixed_local_private_leaf_selection_go127_test.go
new file mode 100644
index 000000000..aea8f1502
--- /dev/null
+++ b/amd64_fixed_local_private_leaf_selection_go127_test.go
@@ -0,0 +1,117 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoAMD64FixedLocalPrivateLeafSelectionBoundary(t *testing.T) {
+	for _, sibling := range []struct {
+		name, value string
+		valid       bool
+	}{
+		{"defined_sibling", "$17", true},
+		{"undefined_sibling", "R8", false},
+	} {
+		t.Run(sibling.name, func(t *testing.T) {
+			assembly := fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "MOVQ (BP),AX") +
+				"TEXT ·Other(SB),4,$0-8\n MOVQ " + sibling.value + ",AX\n MOVQ AX,ret+0(FP)\n RET\n"
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly,
+				"func Value(a uint64) uint64\nfunc Other() uint64")
+			other, err := DeriveGoFuncABI0Signature(pkg.Path+".Other",
+				pkg.Types.Scope().Lookup("Other").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			options.Sigs[other.Name] = other
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("complete original sibling observation must succeed", err)
+			}
+			defer owner.Close()
+			expanded, err := owner.preprocess(request.AssemblyFile, []byte(assembly))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(file.Funcs) != 3 || len(owner.functions) != 3 {
+				t.Fatal("complete original root, leaf and sibling inventory changed")
+			}
+			bound, err := owner.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("sibling semantics must reach the public translation consumer", err)
+			}
+			for _, selection := range []string{"complete", "keep_all", "omit_sibling"} {
+				t.Run(selection, func(t *testing.T) {
+					queries := make(map[string]int)
+					opt := GoModuleOptions{
+						GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple, ResolveSym: bound.ResolveSym,
+						ManualSig: func(name string) (FuncSig, bool) {
+							sig, found := bound.Sigs[name]
+							return sig, found
+						},
+					}
+					if selection != "complete" {
+						opt.KeepFunc = func(symbol, name string) bool {
+							queries[symbol]++
+							return selection == "keep_all" || name != other.Name
+						}
+					}
+					context := llvm.NewContext()
+					defer context.Dispose()
+					result, err := translateGoModuleInContext(context, pkg, []byte(expanded), opt)
+					if result != nil && !result.Module.IsNil() {
+						defer result.Module.Dispose()
+					}
+					if selection != "complete" {
+						if len(queries) != len(file.Funcs) {
+							t.Fatal("KeepFunc did not observe the complete original inventory", queries)
+						}
+						for _, fn := range file.Funcs {
+							if queries[fn.Sym] != 1 {
+								t.Fatal("KeepFunc omitted or repeated an original TEXT", fn.Sym, queries)
+							}
+						}
+					}
+					if selection == "omit_sibling" {
+						// This route currently rejects even valid partial selection.
+						// It does not claim semantic auditing before filtering.
+						if result != nil || !errors.Is(err, ErrProbeNeedsContext) ||
+							!strings.Contains(err.Error(), "fixed local consumer original/normalized source changed") {
+							t.Fatal("cropping a sibling reused a complete-source frame binding", err)
+						}
+						return
+					}
+					if !sibling.valid {
+						if result != nil || !errors.Is(err, ErrProbeNeedsContext) ||
+							!strings.Contains(err.Error(), "result initialization") ||
+							!strings.Contains(err.Error(), "MOVQ R8,AX") {
+							t.Fatal("complete source hid an undefined ordinary sibling result", err)
+						}
+						return
+					}
+					if err != nil || result == nil || result.Module.IsNil() {
+						t.Fatal("complete valid root, leaf and sibling source was rejected", err)
+					}
+					ir := result.Module.String()
+					if strings.Count(ir, "define ") != 2 || !strings.Contains(ir, other.Name) {
+						t.Fatal("complete valid source omitted its ordinary sibling", ir)
+					}
+					fixedLocalPrivateLeafObjects(t, ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_proof.go b/amd64_fixed_local_proof.go
new file mode 100644
index 000000000..d140a67f5
--- /dev/null
+++ b/amd64_fixed_local_proof.go
@@ -0,0 +1,1288 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"reflect"
+)
+
+var errFixedLocalLayoutJoin = goAMD64FrameContext("fixed local CFG address identity disagrees")
+
+// Local offsets are from the observed post-prologue Go SP, not incoming FP,
+// saved BP/return slots, a caller allocation or an arbitrary native address.
+type x86FixedLocalProof struct {
+	binding  *x86FixedLocalBinding
+	frame    int64
+	function [32]byte
+	accesses map[int]map[int]x86FixedLocalAccess
+	ordinal  int // private builder cursor; never trusted by a consumer
+}
+
+type x86FixedLocalAccess struct {
+	owner       *x86FixedLocalProof
+	shape       [32]byte
+	width       int64
+	write       bool
+	nativeInput bool     // Typed source address, not a private extent/alignment proof.
+	offset      [8]int64 // The first access; a counted loop retains its complete series below.
+	ordinal     int
+	// Counted iterations and private layouts retain a complete stable series.
+	iterationOffsets [][8]int64
+}
+
+type x86FixedLocalState struct {
+	pointers     map[Reg]int64
+	opaque       map[Reg]x86FixedLocalOrigins
+	opaqueCells  map[int64]x86FixedLocalOrigins
+	booleans     map[Reg]uint8
+	booleanBytes x86FixedLocalByteSet
+	constants    map[Reg]int64
+	ranges       map[Reg]x86UnsignedRange
+	comparison   x86FixedLocalComparison
+	known        map[Reg]uint8
+	vectors      map[Reg]uint64
+	masks        map[Reg]bool
+	bytes        x86FixedLocalByteSet
+	addresses    map[int64]int64
+	results      map[int]bool
+	flags        uint8
+	savedBP      *x86FixedLocalSavedBP // Immutable facts for the active observed leaf call.
+}
+
+func cloneFixedLocalState(input x86FixedLocalState) x86FixedLocalState {
+	clone := input
+	clone.pointers = make(map[Reg]int64, len(input.pointers))
+	clone.opaque = cloneFixedLocalOrigins(input.opaque)
+	clone.opaqueCells = cloneFixedLocalOrigins(input.opaqueCells)
+	clone.booleans = x86CloneCallerKnown(input.booleans)
+	clone.booleanBytes = append(x86FixedLocalByteSet(nil), input.booleanBytes...)
+	clone.constants = make(map[Reg]int64, len(input.constants))
+	clone.ranges = cloneFixedLocalRanges(input.ranges)
+	clone.addresses = make(map[int64]int64, len(input.addresses))
+	clone.results = make(map[int]bool, len(input.results))
+	for key, value := range input.pointers {
+		clone.pointers[key] = value
+	}
+	for key, value := range input.constants {
+		clone.constants[key] = value
+	}
+	for key, value := range input.addresses {
+		clone.addresses[key] = value
+	}
+	for key, value := range input.results {
+		clone.results[key] = value
+	}
+	clone.known = x86CloneCallerKnown(input.known)
+	clone.vectors, clone.masks = x86CloneCallerVectorState(input.vectors, input.masks)
+	clone.bytes = append(x86FixedLocalByteSet(nil), input.bytes...)
+	return clone
+}
+
+func proveX86FixedLocal(fn Func, sig FuncSig) (Func, error) {
+	if view := fn.x86DirectTailRoot; view != nil {
+		if view.graph == nil || view.graph.revoked.Load() || view.graph.fixedLocal != sig.x86FixedLocal {
+			return fn, goAMD64FrameContext("private leaf CFG has a foreign root/frame owner")
+		}
+		root := view.graph.roots[fn.Sym]
+		if root == nil || root.graph != view.graph || root.text != view.text {
+			return fn, goAMD64FrameContext("private leaf CFG has a foreign root/frame owner")
+		}
+		proven, err := proveX86FixedLocalBody(fixedLocalProofFunction(fn), sig)
+		if err != nil {
+			return fn, err
+		}
+		copy := *view
+		copy.instructions = proven.Instrs
+		fn.x86DirectTailRoot, fn.x86FixedLocal = &copy, proven.x86FixedLocal
+		return fn, nil
+	}
+	return proveX86FixedLocalBody(fn, sig)
+}
+
+func proveX86FixedLocalBody(fn Func, sig FuncSig) (Func, error) {
+	voidReturn := sig.Ret == Void && len(sig.Frame.Results) == 0
+	valueReturn := sig.Ret != "" && sig.Ret != Void && len(sig.Frame.Results) > 0 && len(sig.Frame.Results) <= 4096
+	if fn.FrameSize <= 0 || fn.FrameSize > 64<<10 || fn.FrameSize%8 != 0 ||
+		len(fn.Instrs) == 0 || len(fn.Instrs) > 8192 ||
+		len(fn.X86RawText) != 0 || len(sig.ArgRegs) != 0 || sig.ARMEntry != nil ||
+		sig.ARM64GoRegisterABI != nil || sig.x86CallerRegions != nil || !voidReturn && !valueReturn {
+		return fn, goAMD64FrameContext("fixed local source has an unbound frame or entry contract")
+	}
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	proven, err := proveX86FixedLocalAttempt(fn, sig, &budget, false)
+	if errors.Is(err, errFixedLocalLayoutJoin) {
+		return proveX86FixedLocalAttempt(fn, sig, &budget, true)
+	}
+	return proven, err
+}
+
+// Only a private-layout join retries the complete residue/final replay, once,
+// with the remaining budget. Ordinary sources retain their original schedule.
+func proveX86FixedLocalAttempt(fn Func, sig FuncSig, budget *x86FixedLocalBudget, partitioned bool) (Func, error) {
+	copyFn := fn
+	copyFn.Instrs = append([]Instr(nil), fn.Instrs...)
+	proof := &x86FixedLocalProof{binding: sig.x86FixedLocal, frame: fn.FrameSize, accesses: make(map[int]map[int]x86FixedLocalAccess)}
+	for index := range copyFn.Instrs {
+		copyFn.Instrs[index].Args = append([]Operand(nil), fn.Instrs[index].Args...)
+		copyFn.Instrs[index].x86FixedLocalMemory = nil
+	}
+	effects, err := fixedLocalEffectPlan(copyFn, proof.binding)
+	if err != nil {
+		return fn, err
+	}
+	var layouts *x86FixedLocalLayoutGraph
+	if partitioned {
+		layouts = &x86FixedLocalLayoutGraph{}
+	}
+	for residue := 0; residue < 8; residue++ {
+		if err := replayX86FixedLocal(&copyFn, sig, proof, residue, budget, effects, layouts); err != nil {
+			return fn, err
+		}
+	}
+	// Independent final replay must recreate exactly the same access set and
+	// offset in every possible word-aligned original Go SP congruence class.
+	final := copyFn
+	final.Instrs = append([]Instr(nil), copyFn.Instrs...)
+	for index := range final.Instrs {
+		final.Instrs[index].x86FixedLocalMemory = nil
+	}
+	effects, err = fixedLocalEffectPlan(final, proof.binding)
+	if err != nil {
+		return fn, err
+	}
+	var firstLayouts []x86FixedLocalLayoutNode
+	if layouts != nil {
+		firstLayouts = layouts.nodes
+		*layouts = x86FixedLocalLayoutGraph{retained: int64(cap(firstLayouts))*32 + layouts.series}
+	}
+	for residue := 0; residue < 8; residue++ {
+		if err := replayX86FixedLocal(&final, sig, proof, residue, budget, effects, layouts); err != nil {
+			return fn, err
+		}
+	}
+	if layouts != nil && !reflect.DeepEqual(firstLayouts, layouts.nodes) {
+		return fn, goAMD64FrameContext("fixed local final layout replay changed")
+	}
+	for index := range final.Instrs {
+		if !reflect.DeepEqual(final.Instrs[index].x86FixedLocalMemory, copyFn.Instrs[index].x86FixedLocalMemory) {
+			return fn, goAMD64FrameContext("fixed local final access replay changed")
+		}
+		if len(final.Instrs[index].x86FixedLocalMemory) != 0 {
+			proof.accesses[index] = cloneX86ReplayFixedLocalMemory(final.Instrs[index].x86FixedLocalMemory)
+		}
+	}
+	if err := fixedLocalRelocationAliases(proof.accesses); err != nil {
+		return fn, err
+	}
+	proof.function, err = x86CallerSourceFingerprint(final)
+	if err != nil {
+		return fn, goAMD64FrameContext("fixed local normalized function cannot be bound: %v", err)
+	}
+	final.x86FixedLocal = proof
+	return final, nil
+}
+
+// This call-local plan holds forms and immutable DATA byte dependencies, never
+// a live source verification result. Each independent eight-residue replay
+// constructs its own plan under the original binding's complete lifetime guards.
+func fixedLocalEffectPlan(fn Func, binding *x86FixedLocalBinding) (map[int]x86TypedByteEffect, error) {
+	var effects map[int]x86TypedByteEffect
+	for index, ins := range fn.Instrs {
+		if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86AddressBits != 0 || ins.x86SegmentPrefix != 0 {
+			return nil, goAMD64FrameContext("fixed local source contains raw/native effects")
+		}
+		if fn.x86DirectTailRoot.privateCallTransition(index) {
+			continue // Complete private source graph owns only this control edge.
+		}
+		if _, ordinary := fixedLocalOrdinaryCall(ins, binding); ordinary {
+			continue // Exact outgoing layout and state are checked by the transfer.
+		}
+		if effect, known, err := fixedLocalVectorByteEffect(ins); known {
+			if err != nil {
+				return nil, err
+			}
+			if effects == nil {
+				effects = make(map[int]x86TypedByteEffect)
+			}
+			effects[index] = fixedLocalLogicalLiteralEffect(ins, effect, binding)
+		} else {
+			shape := ins
+			if x86LEAWidth(ins.Op, "amd64") != 0 && len(ins.Args) == 2 && ins.Args[0].Kind == OpMem {
+				address, err := fixedLocalMemoryAddress(ins, 0, fn.FrameSize)
+				if err != nil {
+					return nil, err
+				}
+				shape.Args = append([]Operand(nil), ins.Args...)
+				shape.Args[0].Mem = address
+			}
+			if !fixedLocalInstructionShape(shape) {
+				return nil, goAMD64FrameContext("fixed local complete source has an unregistered instruction shape: %s", ins.Op)
+			}
+		}
+	}
+	return effects, nil
+}
+
+// Every reachable access, including initialization stores and private address
+// spills, contributes all its bytes. Each original residue must induce a
+// bijection on those bytes: equal bytes remain equal and distinct bytes stay
+// distinct. Different distances between permanently disjoint accesses are
+// unobservable because the source cannot expose numeric addresses or flags.
+func fixedLocalRelocationAliases(accesses map[int]map[int]x86FixedLocalAccess) error {
+	var forward, reverse [8]map[int64]int64
+	for residue := range forward {
+		forward[residue] = make(map[int64]int64)
+		reverse[residue] = make(map[int64]int64)
+	}
+	var total int64
+	for _, operands := range accesses {
+		for _, access := range operands {
+			offsets := access.iterationOffsets
+			if len(offsets) == 0 {
+				offsets = [][8]int64{access.offset}
+			}
+			if access.width <= 0 || access.width > ((1<<20)-total)/int64(len(offsets)) {
+				return goAMD64FrameContext("fixed local complete access-byte budget exceeded")
+			}
+			total += access.width * int64(len(offsets))
+			if access.nativeInput {
+				continue // Native input addresses are never relocated.
+			}
+			for _, offset := range offsets {
+				for byteIndex := int64(0); byteIndex < access.width; byteIndex++ {
+					original := offset[0] + byteIndex
+					for residue := range forward {
+						current := offset[residue] + byteIndex
+						if mapped, found := forward[residue][original]; found && mapped != current {
+							return goAMD64FrameContext("fixed local overlapping-byte identity depends on original SP residue")
+						}
+						if mapped, found := reverse[residue][current]; found && mapped != original {
+							return goAMD64FrameContext("fixed local distinct-byte identity depends on original SP residue")
+						}
+						forward[residue][original] = current
+						reverse[residue][current] = original
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func fixedLocalInstructionShape(ins Instr) bool {
+	if form, known, err := x86GPSIMDTransferProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx && !form.spec.rawOnly
+	}
+	if _, _, known, err := x86SwapProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := fixedLocalConversionProperties(ins); known {
+		return err == nil && !form.mmx
+	}
+	if _, known, err := fixedLocalScalarLaneProperties(ins); known {
+		return err == nil
+	}
+	if _, known, err := x86ConditionalSetProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if ins.x86NumericalRead != nil {
+		_, valid := x86NumericalReadEffect(ins, "amd64")
+		return valid
+	}
+	if _, known, err := amd64PackedVectorMoveProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && !form.trap
+	}
+	if _, known, err := x86OrderingHintProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86VectorZeroProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known := amd64MaskMoveSpecs[ins.Op]; known {
+		return amd64MaskMoveOperandsValid(ins, "amd64")
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && amd64VectorByteWidth(operand.Reg) != 0 {
+			index, valid := amd64VectorRegisterIndex(operand.Reg, 16)
+			if !valid || index > 15 {
+				return false
+			}
+		}
+	}
+	if ins.Op == OpTEXT || ins.Op == OpLABEL {
+		return true // Parser/complete CFG separately binds TEXT and label operands.
+	}
+	if ins.Op == OpRET {
+		return len(ins.Args) == 0
+	}
+	if isAMD64ConditionalBranch(ins.Op) || ins.Op == OpJMP {
+		_, named := fixedLocalBranchLabel(ins)
+		return named
+	}
+	if x86RawReturnScalarMoveBytes(x86SourceMoveInstruction(ins, "amd64").Op) != 0 {
+		return len(ins.Args) == 2
+	}
+	if _, address := fixedLocalStaticAddress(ins); address {
+		return true
+	}
+	if effect, known, err := fixedLocalGPByteEffect(ins); known {
+		return err == nil && !effect.dynamicMemory
+	}
+	if _, known, err := x86SHAProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86AESProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && form.byteWidth == 16
+	}
+	if _, known, err := fixedLocalVectorByteEffect(ins); known {
+		return err == nil
+	}
+	if form, known, err := x86FloatCompareProperties(ins, "amd64"); known {
+		return err == nil && form.legacy && !form.scalar && form.byteWidth == 16
+	}
+	return false
+}
+
+func fixedLocalBranchLabel(ins Instr) (string, bool) {
+	if len(ins.Args) != 1 {
+		return "", false
+	}
+	operand := ins.Args[0]
+	if operand.Kind == OpLabel && operand.Sym != "" {
+		return operand.Sym, true
+	}
+	if operand.Kind == OpIdent && operand.Ident != "" {
+		return operand.Ident, true
+	}
+	return "", false
+}
+
+func fixedLocalEdges(fn Func) (map[int][]int, []int, error) {
+	if view := fn.x86DirectTailRoot; view != nil {
+		if len(fn.Instrs) != len(view.points) || len(view.edges) != len(view.points) {
+			return nil, nil, goAMD64FrameContext("private leaf CFG instruction inventory differs")
+		}
+		edges, instructions := make(map[int][]int, len(view.edges)), make([]int, len(view.points))
+		for pc, targets := range view.edges {
+			instructions[pc], edges[pc] = pc, targets
+		}
+		return edges, instructions, nil
+	}
+	labels := make(map[string]int)
+	var instructions []int
+	for index, ins := range fn.Instrs {
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+				return nil, nil, goAMD64FrameContext("malformed local label")
+			}
+			name := ins.Args[0].Sym
+			if _, exists := labels[name]; exists {
+				return nil, nil, goAMD64FrameContext("duplicate local label")
+			}
+			labels[name] = len(instructions)
+		} else {
+			instructions = append(instructions, index)
+		}
+	}
+	if len(instructions) == 0 || len(instructions) > 8192 {
+		return nil, nil, goAMD64FrameContext("fixed local CFG lacks a bounded instruction inventory")
+	}
+	edges := make(map[int][]int)
+	for pc, index := range instructions {
+		ins := fn.Instrs[index]
+		if ins.Op == OpRET {
+			continue
+		}
+		next := []int{pc + 1}
+		if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+			label, named := fixedLocalBranchLabel(ins)
+			if !named {
+				return nil, nil, goAMD64FrameContext("fixed local branch needs a complete named target")
+			}
+			target, found := labels[label]
+			if !found || target >= len(instructions) {
+				return nil, nil, goAMD64FrameContext("fixed local branch target is missing an instruction")
+			}
+			if ins.Op == OpJMP {
+				next = []int{target}
+			} else {
+				next = append(next, target)
+			}
+		}
+		edges[pc] = next
+	}
+	return edges, instructions, nil
+}
+
+// All congruence classes and the independent final replay share these limits.
+// A cyclic source cannot obtain an unbounded analysis or a partial certificate.
+type x86FixedLocalBudget struct {
+	steps int
+	bytes int64
+}
+
+func (budget *x86FixedLocalBudget) consume(frame int64) error {
+	if budget.steps <= 0 || frame > budget.bytes {
+		return goAMD64FrameContext("fixed local CFG work/byte bound exceeded")
+	}
+	budget.steps--
+	budget.bytes -= frame
+	return nil
+}
+
+func (budget *x86FixedLocalBudget) consumeOrigins(bytes int64) error {
+	if bytes > budget.bytes {
+		return goAMD64FrameContext("fixed local opaque state byte bound exceeded")
+	}
+	budget.bytes -= bytes
+	return nil
+}
+
+// Partitioned replay charges actual state payload at copies and meets. This
+// saturating logical charge includes map entries, not allocator/RSS overhead.
+func fixedLocalStateWork(state x86FixedLocalState) int64 {
+	const limit int64 = 64 << 20
+	var bytes int64
+	if state.savedBP != nil {
+		bytes = 128
+	}
+	for _, group := range []struct {
+		unit   int64
+		counts []int
+	}{
+		{8, []int{len(state.bytes), len(state.booleanBytes)}},
+		{64, []int{len(state.pointers), len(state.opaque), len(state.opaqueCells), len(state.booleans),
+			len(state.constants), len(state.ranges), len(state.known), len(state.vectors), len(state.masks),
+			len(state.addresses), len(state.results)}},
+	} {
+		for _, count := range group.counts {
+			if int64(count) > (limit-bytes)/group.unit {
+				return limit + 1
+			}
+			bytes += int64(count) * group.unit
+		}
+	}
+	return bytes
+}
+
+// Only the existing closed vector plan calls this cost projection. The step
+// debit remains mandatory; this grants no input or storage permission.
+func fixedLocalVectorRegisterWork(effect x86TypedByteEffect) bool {
+	if effect.dynamicMemory || effect.vector.memoryAlignment <= 0 ||
+		effect.vector.upperWrite != x86TypedVectorUpperPreserve && effect.vector.upperWrite != x86TypedVectorUpperZero {
+		return false
+	}
+	for _, operand := range effect.operands {
+		if operand.operand.Kind != OpReg && operand.operand.Kind != OpImm {
+			return false
+		}
+	}
+	return true
+}
+
+// Cost only: the ordinary transfer still owns pointer, FLAGS and input facts.
+// Keep original address syntax conservative even if its effect becomes Regs.
+func fixedLocalGPRegisterWork(ins Instr) (x86TypedByteEffect, bool) {
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return x86TypedByteEffect{}, false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg && operand.Kind != OpImm {
+			return x86TypedByteEffect{}, false
+		}
+	}
+	effect, known, err := fixedLocalGPByteEffect(ins)
+	if !known || err != nil || effect.dynamicMemory {
+		return x86TypedByteEffect{}, false
+	}
+	for _, operand := range effect.operands {
+		if operand.operand.Kind != OpReg && operand.operand.Kind != OpImm {
+			return x86TypedByteEffect{}, false
+		}
+	}
+	return effect, true
+}
+
+func replayX86FixedLocal(fn *Func, sig FuncSig, proof *x86FixedLocalProof, residue int, budget *x86FixedLocalBudget,
+	effects map[int]x86TypedByteEffect, layouts *x86FixedLocalLayoutGraph) error {
+	edges, instructions, err := fixedLocalEdges(*fn)
+	if err != nil {
+		return err
+	}
+	linear := fixedLocalLinearEdges(*fn, edges, instructions)
+	err = replayX86FixedLocalCFG(fn, sig, proof, residue, budget, effects, edges, instructions, linear, nil, layouts)
+	if err == nil {
+		return nil // A stronger loop model must not reject existing generic CFG proofs.
+	}
+	loops := fixedLocalCountedLoops(*fn, edges, instructions)
+	if len(loops) == 0 {
+		return err
+	}
+	// Failed attempts publish no access annotations. Reuse the original source,
+	// transfer and remaining budget; this is not recursive translation or caching.
+	countedErr := replayX86FixedLocalCFG(fn, sig, proof, residue, budget, effects, edges, instructions, linear, loops, layouts)
+	if layouts == nil && errors.Is(err, errFixedLocalLayoutJoin) && countedErr != nil {
+		return fmt.Errorf("%w; counted replay: %v", err, countedErr)
+	}
+	return countedErr
+}
+
+// Keep states at control-flow boundaries. A sole fallthrough predecessor has
+// no meet: its private transfer state can flow directly to the next instruction.
+// Count all CFG predecessors, including unreachable edges and repeated targets;
+// branch destinations and PC zero retain their independent entry state.
+func fixedLocalLinearEdges(fn Func, edges map[int][]int, instructions []int) []bool {
+	predecessors := make([]int, len(instructions))
+	for _, targets := range edges {
+		for _, target := range targets {
+			if target >= 0 && target < len(predecessors) {
+				predecessors[target]++
+			}
+		}
+	}
+	linear := make([]bool, len(instructions))
+	for pc, targets := range edges {
+		op := fn.Instrs[instructions[pc]].Op
+		linear[pc] = op != OpJMP && op != OpRET && op != OpCALL && !isAMD64ConditionalBranch(op) &&
+			len(targets) == 1 && targets[0] == pc+1 && pc+1 < len(instructions) && predecessors[pc+1] == 1
+	}
+	return linear
+}
+
+// A nil linear mask retains the all-instruction reference schedule. Both paths
+// use the same transfer, meet, work budgets and final access publication.
+func replayX86FixedLocalCFG(fn *Func, sig FuncSig, proof *x86FixedLocalProof, residue int, budget *x86FixedLocalBudget,
+	effects map[int]x86TypedByteEffect, edges map[int][]int, instructions []int, linear []bool,
+	loops map[int]x86FixedLocalCountedLoop, graph *x86FixedLocalLayoutGraph) error {
+	if proof.frame <= 0 || proof.frame > 1<<20 {
+		return goAMD64FrameContext("fixed local retained state storage budget exceeded")
+	}
+	state := x86FixedLocalState{
+		pointers: map[Reg]int64{SP: 0}, constants: make(map[Reg]int64), known: make(map[Reg]uint8),
+		opaque: make(map[Reg]x86FixedLocalOrigins), opaqueCells: make(map[int64]x86FixedLocalOrigins), booleans: make(map[Reg]uint8),
+		booleanBytes: newFixedLocalByteSet(proof.frame),
+		vectors:      make(map[Reg]uint64), masks: make(map[Reg]bool),
+		bytes: newFixedLocalByteSet(proof.frame), addresses: make(map[int64]int64), results: make(map[int]bool),
+	}
+	// All GP entry bytes except the private SP origin remain unknown. ABI0
+	// does not supply an initialized R14/g value; the observed nonzero-frame
+	// prologue/epilogue independently preserves BP. Explicit definitions may
+	// use either register without importing its entry value or native role.
+	states := map[int]x86FixedLocalState{0: state}
+	work := []int{0}
+	queued := map[int]bool{0: true}
+	accesses := make(map[int]map[int]x86FixedLocalAccess)
+	var layouts *x86FixedLocalLayouts
+	var observations map[int]map[int]map[int]x86FixedLocalAccess
+	returned := false
+	retainedBytes := proof.frame
+	if graph != nil {
+		current := newFixedLocalLayouts(graph.nodes)
+		layouts = &current
+		observations = make(map[int]map[int]map[int]x86FixedLocalAccess)
+		retainedBytes += graph.retained + graph.series + int64(len(layouts.nodes))*fixedLocalLayoutNodeBytes
+	}
+	if retainedBytes > 1<<20 {
+		return goAMD64FrameContext("fixed local retained state storage budget exceeded")
+	}
+	for head := 0; head < len(work); head++ {
+		node := work[head]
+		pc, alternative := node, false
+		currentAccesses := accesses
+		if layouts != nil {
+			pc = layouts.nodes[node].pc
+			alternative = node != layouts.at[pc][0]
+			currentAccesses = make(map[int]map[int]x86FixedLocalAccess)
+		}
+		queued[node] = false
+		if pc < 0 || pc >= len(instructions) {
+			return goAMD64FrameContext("fixed local fallthrough lacks a source return")
+		}
+		copyWork := fixedLocalOriginStorage(states[node])
+		if layouts != nil {
+			copyWork = 2 * fixedLocalStateWork(states[node])
+		}
+		if err := budget.consumeOrigins(copyWork); err != nil {
+			return err
+		}
+		current := cloneFixedLocalState(states[node])
+		var active *x86FixedLocalCountedLoop
+		var number uint64
+		iteration := 0
+		var targets []int
+		for {
+			effect, planned := effects[instructions[pc]]
+			var gp *x86TypedByteEffect
+			workBytes := proof.frame
+			if layouts != nil && planned && fixedLocalVectorRegisterWork(effect) {
+				workBytes = 0
+			} else if layouts != nil && !planned {
+				if parsed, cheap := fixedLocalGPRegisterWork(fn.Instrs[instructions[pc]]); cheap {
+					workBytes, gp = 0, &parsed
+				}
+			}
+			if err := budget.consume(workBytes); err != nil {
+				return err
+			}
+			if active == nil {
+				if loop, found := loops[pc]; found {
+					if value, known := loop.number(&current); known {
+						active, number = &loop, value
+					}
+				}
+			}
+			// Transfer a private instruction copy: provisional loop states must
+			// never publish accesses, including certificates from another residue.
+			ins := fn.Instrs[instructions[pc]]
+			ins.x86FixedLocalMemory = nil
+			proof.ordinal = instructions[pc]
+			var err error
+			transition := fn.x86DirectTailRoot.privateCallTransition(pc)
+			if transition {
+				err = fixedLocalFrameTransition(fn.x86DirectTailRoot, pc, &current)
+			} else if planned {
+				err = fixedLocalTypedByteStep(&ins, &current, FuncSig{}, proof, residue, effect)
+			} else {
+				err = fixedLocalStepWithGP(&ins, &current, sig, proof, residue, gp)
+			}
+			if err != nil {
+				return fmt.Errorf("%s: %q: %w", fn.Sym, ins.Raw, err)
+			}
+			if active != nil {
+				if pc == active.update {
+					number, err = active.next(number)
+					if err != nil {
+						return err
+					}
+				}
+				if value, known := active.number(&current); !known || value != number {
+					return goAMD64FrameContext("fixed local counted-loop counter changed outside its unique update")
+				}
+				if err := fixedLocalCountedAccesses(currentAccesses[pc], ins.x86FixedLocalMemory, iteration); err != nil {
+					return err
+				}
+			}
+			if alternative {
+				retainedBytes += fixedLocalLayoutAccessBytes(ins.x86FixedLocalMemory) - fixedLocalLayoutAccessBytes(currentAccesses[pc])
+				if retainedBytes > 1<<20 {
+					return goAMD64FrameContext("fixed local retained state storage budget exceeded")
+				}
+			}
+			if layouts == nil || len(ins.x86FixedLocalMemory) != 0 {
+				currentAccesses[pc] = ins.x86FixedLocalMemory
+			}
+			returned = returned || ins.Op == OpRET && !transition
+			if active != nil {
+				if pc == active.latch {
+					if active.continues(number) {
+						iteration++
+						pc = active.header
+						continue
+					}
+					targets = edges[pc][:1] // The actual known comparison has reached the false latch.
+					break
+				}
+				pc++
+				continue
+			}
+			if linear == nil || !linear[pc] {
+				break
+			}
+			pc++
+		}
+		if targets == nil {
+			targets = edges[pc]
+		}
+		if alternative {
+			for _, old := range observations[node] {
+				retainedBytes -= fixedLocalLayoutAccessBytes(old)
+			}
+		}
+		if layouts != nil {
+			observations[node] = currentAccesses
+			layouts.nodes[node].end = pc
+			layouts.nodes[node].targets = [2]int{-1, -1}
+		}
+		for edge, target := range targets {
+			if edge >= 2 || target < 0 || target >= len(instructions) {
+				return goAMD64FrameContext("fixed local fallthrough lacks a source return")
+			}
+			next := current
+			if isAMD64ConditionalBranch(fn.Instrs[instructions[pc]].Op) {
+				var feasible bool
+				next, feasible = fixedLocalRangeEdge(current, fn.Instrs[instructions[pc]].Op, edge == 1)
+				if !feasible {
+					continue
+				}
+				comparison := current.comparison
+				if comparison.literal.symbol != "" && !next.opaque[comparison.register].equal(current.opaque[comparison.register]) {
+					if err := budget.consumeOrigins(fixedLocalOriginMapStorage(next.opaque)); err != nil {
+						return err
+					}
+				}
+			}
+			terminal := fn.Instrs[instructions[target]]
+			if terminal.Op == OpRET && !fn.x86DirectTailRoot.privateCallTransition(target) {
+				// A final return has no successor that could consume dead local
+				// identities. Check every incoming SP/result state independently;
+				// a helper return still resumes its caller through the usual CFG.
+				if err := budget.consume(proof.frame); err != nil {
+					return err
+				}
+				if err := fixedLocalStep(&terminal, &next, sig, proof, residue); err != nil {
+					return fmt.Errorf("%s: %q: %w", fn.Sym, terminal.Raw, err)
+				}
+				returned = true
+				if layouts != nil {
+					layouts.nodes[node].targets[edge] = -2
+				}
+				continue
+			}
+			if layouts != nil {
+				previousNodes := len(layouts.nodes)
+				var err error
+				target, err = layouts.target(states, node, edge, target, next, budget)
+				if err != nil {
+					return err
+				}
+				retainedBytes += int64(len(layouts.nodes)-previousNodes) * fixedLocalLayoutNodeBytes
+			}
+			changed := true
+			if previous, found := states[target]; found {
+				if layouts != nil {
+					if err := budget.consumeOrigins(2*fixedLocalStateWork(previous) + fixedLocalStateWork(next)); err != nil {
+						return err
+					}
+				}
+				var err error
+				changed, err = mergeFixedLocalState(&previous, next)
+				if err != nil {
+					return err
+				}
+				states[target] = previous
+			} else {
+				// Only control-flow boundaries retain complete frame states.
+				// Keep the original frame-state product cap on actual storage;
+				// the independent per-instruction work budgets remain unchanged.
+				originBytes := fixedLocalOriginStorage(next)
+				if proof.frame+originBytes > (1<<20)-retainedBytes {
+					return goAMD64FrameContext("fixed local retained state storage budget exceeded")
+				}
+				retainedBytes += proof.frame + originBytes
+				copyWork := originBytes
+				if layouts != nil {
+					copyWork = 2 * fixedLocalStateWork(next)
+				}
+				if err := budget.consumeOrigins(copyWork); err != nil {
+					return err
+				}
+				states[target] = cloneFixedLocalState(next)
+			}
+			if changed && !queued[target] {
+				queued[target] = true
+				work = append(work, target)
+			}
+		}
+	}
+	if !returned {
+		return goAMD64FrameContext("fixed local source has no reachable return")
+	}
+	// Each node contributes only its final transfer, in frozen edge identity
+	// order. Counted iterations remain ordered within that node's observations.
+	var seriesBytes int64
+	if layouts != nil {
+		if err := layouts.finish(); err != nil {
+			return err
+		}
+		var err error
+		accesses, seriesBytes, err = collectFixedLocalLayoutAccesses(len(layouts.nodes), observations, (1<<20)-retainedBytes)
+		if err != nil {
+			return err
+		}
+	}
+	// An empty worklist means each retained transfer consumed the final input
+	// state: every changed meet requeued its consumer. Publish those local
+	// annotations only now, without repeating every instruction in a DAG.
+	// Entry state remains a predecessor of PC zero, including backedges.
+	for pc, index := range instructions {
+		current, reachable := accesses[pc]
+		if !reachable {
+			continue
+		}
+		previous := fn.Instrs[index].x86FixedLocalMemory
+		if residue != 0 && len(previous) != len(current) {
+			return goAMD64FrameContext("fixed local access inventory depends on original SP residue")
+		}
+		for operand, access := range current {
+			if residue == 0 {
+				continue
+			}
+			prior, found := previous[operand]
+			if !found || !fixedLocalAccessShapeEqual(prior, access) ||
+				len(prior.iterationOffsets) != len(access.iterationOffsets) {
+				return goAMD64FrameContext("fixed local access shape depends on original SP residue")
+			}
+			prior.offset[residue] = access.offset[residue]
+			prior.iterationOffsets = append([][8]int64(nil), prior.iterationOffsets...)
+			for index, offset := range access.iterationOffsets {
+				prior.iterationOffsets[index][residue] = offset[residue]
+			}
+			current[operand] = prior
+		}
+	}
+	for pc, current := range accesses {
+		fn.Instrs[instructions[pc]].x86FixedLocalMemory = current
+	}
+	if graph != nil {
+		graph.nodes, graph.series = layouts.nodes, seriesBytes
+	}
+	return nil
+}
+
+func mergeFixedLocalState(previous *x86FixedLocalState, current x86FixedLocalState) (bool, error) {
+	// Private relocation identities must agree. Incoming origins are a separate
+	// must-domain: losing one leaves unknown bytes, never numerical knowledge.
+	if !reflect.DeepEqual(previous.pointers, current.pointers) || !reflect.DeepEqual(previous.addresses, current.addresses) {
+		if err := fixedLocalLayoutRoles(*previous, current); err != nil {
+			return false, err
+		}
+		return false, errFixedLocalLayoutJoin
+	}
+	changed, err := mergeFixedLocalSavedBP(previous, current)
+	if err != nil {
+		return false, err
+	}
+	changed = intersectFixedLocalOrigins(previous.constants, current.constants) || changed
+	changed = mergeFixedLocalRanges(previous, current) || changed
+	merged, err := mergeFixedLocalOrigins(previous.opaque, current.opaque)
+	if err != nil {
+		return false, err
+	}
+	changed = changed || merged
+	merged, err = mergeFixedLocalOrigins(previous.opaqueCells, current.opaqueCells)
+	if err != nil {
+		return false, err
+	}
+	changed = changed || merged
+	flags := previous.flags & current.flags
+	changed = changed || flags != previous.flags
+	previous.flags = flags
+	for reg, bits := range previous.known {
+		value := bits & current.known[reg]
+		changed = changed || value != bits
+		previous.known[reg] = value
+	}
+	for reg, bits := range previous.booleans {
+		value := bits & current.booleans[reg]
+		changed = changed || value != bits
+		previous.booleans[reg] = value
+	}
+	for reg, bits := range previous.vectors {
+		value := bits & current.vectors[reg]
+		changed = changed || value != bits
+		previous.vectors[reg] = value
+	}
+	for reg, known := range previous.masks {
+		value := known && current.masks[reg]
+		changed = changed || value != known
+		previous.masks[reg] = value
+	}
+	changed = previous.bytes.intersect(current.bytes) || changed
+	changed = previous.booleanBytes.intersect(current.booleanBytes) || changed
+	for index, written := range previous.results {
+		value := written && current.results[index]
+		changed = changed || value != written
+		previous.results[index] = value
+	}
+	return changed, nil
+}
+
+func fixedLocalMemory(ins *Instr, index int, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int, width, alignment int64, write, pointer bool) (int64, error) {
+	if index < 0 || index >= len(ins.Args) || ins.Args[index].Kind != OpMem || width <= 0 {
+		return 0, goAMD64FrameContext("fixed local access lacks native memory")
+	}
+	memory, err := fixedLocalMemoryAddress(*ins, index, proof.frame)
+	if err != nil {
+		return 0, err
+	}
+	offset, found := fixedLocalPrivateOffset(memory, state)
+	if !found {
+		return 0, goAMD64FrameContext("fixed local access has unknown/escaping address provenance")
+	}
+	if offset < 0 || offset > proof.frame || width > proof.frame-offset || alignment <= 0 ||
+		(int64(residue*8)+offset)%alignment != 0 {
+		return 0, goAMD64FrameContext("fixed local access crosses storage or has residue-dependent native alignment")
+	}
+	if !write && !pointer {
+		if !state.bytes.all(offset, width) {
+			return 0, goAMD64FrameContext("fixed local native read contains uninitialized or address bytes")
+		}
+	}
+	return offset, fixedLocalRecordAccess(ins, index, proof, residue, width, write, false, offset)
+}
+
+// Native input addresses retain ordinary faulting memory semantics. Their Go
+// pointer type proves only provenance, never a pointee extent or alignment.
+func fixedLocalMemoryAccess(ins *Instr, index int, state *x86FixedLocalState, proof *x86FixedLocalProof,
+	residue int, width, alignment int64, write, pointer bool) (int64, x86FixedLocalMemoryRole, error) {
+	if index >= 0 && index < len(ins.Args) && ins.Args[index].Kind == OpMem {
+		memory := ins.Args[index].Mem
+		if origins, input := state.opaque[memory.Base]; input {
+			root, valid := x86CallerGP(memory.Base)
+			displacement, known, numerical := fixedLocalNativeDisplacement(memory, state)
+			if !valid || !origins.valid() || root != memory.Base || root == SP || width <= 0 || alignment <= 0 || pointer || !numerical {
+				return 0, x86FixedLocalNativeInput, goAMD64FrameContext("fixed local native address requires a full typed base and numerical index")
+			}
+			if !fixedLocalOriginOwners(origins, proof) || write && origins.readonly() {
+				return 0, x86FixedLocalNativeInput, goAMD64FrameContext("fixed local native address lacks its original storage or write role")
+			}
+			if literal, exact := origins.literal(); exact && known {
+				literal.offset += displacement
+				if !fixedLocalLiteralRange(proof.binding, literal, width, alignment) {
+					return 0, x86FixedLocalLiteralMemory, goAMD64FrameContext("fixed local exact DATA read exceeds original identity, extent or alignment")
+				}
+			}
+			return 0, x86FixedLocalNativeInput, fixedLocalRecordAccess(ins, index, proof, residue, width, write, true, 0)
+		}
+	}
+	// Defined machine address bits retain their ordinary native access. They
+	// are neither a relocated private pointer nor a reusable pointee fact.
+	if index >= 0 && index < len(ins.Args) && ins.Args[index].Kind == OpMem &&
+		x86ResultNamedPredicateInstruction(*ins) && !pointer && width > 0 && alignment > 0 {
+		memory := ins.Args[index].Mem
+		root, valid := x86CallerGP(memory.Base)
+		if valid && root == memory.Base && fixedLocalNumericRead(Operand{Kind: OpReg, Reg: root}, 8, state) {
+			if _, _, numerical := fixedLocalNativeDisplacement(memory, state); numerical {
+				return 0, x86FixedLocalNativeInput, fixedLocalRecordAccess(ins, index, proof, residue, width, write, true, 0)
+			}
+		}
+	}
+	offset, err := fixedLocalMemory(ins, index, state, proof, residue, width, alignment, write, pointer)
+	return offset, x86FixedLocalPrivateMemory, err
+}
+
+func fixedLocalRecordAccess(ins *Instr, index int, proof *x86FixedLocalProof, residue int,
+	width int64, write, nativeInput bool, offset int64) error {
+	if ins.x86FixedLocalMemory == nil {
+		ins.x86FixedLocalMemory = make(map[int]x86FixedLocalAccess)
+	}
+	shape, err := fixedLocalInstructionDigest(*ins)
+	if err != nil {
+		return err
+	}
+	access, found := ins.x86FixedLocalMemory[index]
+	if !found {
+		access = x86FixedLocalAccess{owner: proof, shape: shape, width: width, write: write, nativeInput: nativeInput, ordinal: proof.ordinal}
+	}
+	if access.owner != proof || access.shape != shape || access.width != width || access.write != write || access.nativeInput != nativeInput {
+		return goAMD64FrameContext("fixed local access shape changed")
+	}
+	access.offset[residue] = offset
+	ins.x86FixedLocalMemory[index] = access
+	return nil
+}
+
+func fixedLocalStep(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int) error {
+	return fixedLocalStepWithGP(ins, state, sig, proof, residue, nil)
+}
+
+func fixedLocalStepWithGP(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int,
+	gp *x86TypedByteEffect) error {
+	fail := func() error {
+		return goAMD64FrameContext("unproved fixed local width/initialization/address/control effect: %s", ins.Op)
+	}
+	if ins.Op == OpTEXT {
+		return nil
+	}
+	if ins.Op == OpCALL {
+		return fixedLocalOrdinaryCallStep(*ins, state, proof)
+	}
+	if _, known, err := x86OrderingHintProperties(ins.Op, *ins, "amd64"); known {
+		return err // Exact native fences change no byte, pointer or FLAGS facts.
+	}
+	if form, known, err := x86VectorZeroProperties(*ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		x86VectorZeroDefinedBytes(form, state.vectors)
+		return nil
+	}
+	if ins.Op == OpRET {
+		sp, found := state.pointers[SP]
+		if len(ins.Args) != 0 || !found || sp != 0 {
+			return fail()
+		}
+		for index := range sig.Frame.Results {
+			if !state.results[index] {
+				return fail()
+			}
+		}
+		return nil
+	}
+	if _, counter := x86CounterControlPropertiesForOpcode(ins.Op); counter {
+		return fail() // This storage owner supplies no numerical counter domain.
+	}
+	if isAMD64ConditionalBranch(ins.Op) {
+		needed := x86ByteBranchFlags(ins.Op)
+		if needed == 0 || state.flags&needed != needed {
+			return fail()
+		}
+		return nil
+	}
+	if ins.Op == OpJMP {
+		return nil
+	}
+	if known, err := fixedLocalNumericalReadStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalStaticAddressStep(*ins, state, proof); known {
+		return err
+	}
+	if known, err := fixedLocalGPSIMDTransferStep(ins, state, sig, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalPrivateAddressStep(*ins, state, proof); known {
+		return err
+	}
+	if width := x86RawReturnScalarMoveBytes(x86SourceMoveInstruction(*ins, "amd64").Op); width != 0 {
+		return fixedLocalMove(ins, state, sig, proof, residue, width)
+	}
+	if known, err := fixedLocalExchangeStep(ins, state, sig, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalConditionalSetStep(ins, state, sig, proof, residue); known {
+		return err
+	}
+	if (ins.Op == "ADDQ" || ins.Op == "ANDQ") && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		reg := ins.Args[1].Reg
+		value := ins.Args[0].Imm
+		known := ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" && !ins.Args[0].ImmIsFloat
+		if ins.Args[0].Kind == OpReg {
+			value, known = state.constants[ins.Args[0].Reg]
+		}
+		if offset, pointer := state.pointers[reg]; pointer {
+			if !known {
+				return fail()
+			}
+			if ins.Op == "ANDQ" {
+				// Only an exact power-of-two residue projection preserves the
+				// same private address origin. No pointer bit becomes numeric.
+				if value != -8 && value != -16 && value != -32 && value != -64 {
+					return fail()
+				}
+				offset = (offset+int64(residue*8))&value - int64(residue*8)
+			} else {
+				if value > 0 && offset > math.MaxInt64-value || value < 0 && offset < math.MinInt64-value {
+					return fail()
+				}
+				offset += value
+			}
+			if offset < -64 || offset > proof.frame {
+				return fail()
+			}
+			state.pointers[reg] = offset
+			state.flags = 0 // Relocated pointer arithmetic flags are opaque.
+			state.comparison = x86FixedLocalComparison{}
+			return nil
+		}
+	}
+	if known, err := fixedLocalConditionalMoveStep(ins, state, sig, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalInputAddressStep(ins, state, sig, proof, residue); known {
+		return err
+	}
+	var effect x86TypedByteEffect
+	var err error
+	known := gp != nil
+	if known {
+		effect = *gp
+	} else {
+		effect, known, err = fixedLocalGPByteEffect(*ins)
+	}
+	if known {
+		if err != nil {
+			return err
+		}
+		root, value, constant := fixedLocalConstantArithmetic(*ins, effect, state)
+		rangeReg, bounds, comparison := fixedLocalRangeEffect(*ins, effect, state)
+		if err := fixedLocalTypedByteStep(ins, state, sig, proof, residue, effect); err != nil {
+			return err
+		}
+		if constant {
+			state.constants[root] = value
+			fixedLocalWriteBooleans(state, root, 8, fixedLocalConstantBooleans(value, 8))
+		}
+		if rangeReg != "" {
+			state.setRange(rangeReg, bounds)
+		}
+		if comparison.register != "" {
+			state.comparison = comparison
+		}
+		return nil
+	}
+	if known, err := fixedLocalSHAStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalAESByteStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalPackedMoveStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalMaskMoveStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalConversionStep(ins, state, proof, residue); known {
+		return err
+	}
+	if known, err := fixedLocalScalarLaneStep(ins, state, proof, residue); known {
+		return err
+	}
+	return fixedLocalVectorStep(ins, state, proof, residue)
+}
+
+func fixedLocalNumericRead(operand Operand, width int64, state *x86FixedLocalState) bool {
+	if operand.Kind == OpImm {
+		return operand.ImmRaw == "" && !operand.ImmIsFloat
+	}
+	if operand.Kind != OpReg {
+		return false
+	}
+	root, valid := x86CallerGP(operand.Reg)
+	_, pointer := state.pointers[root]
+	_, opaque := state.opaque[root]
+	mask := x86CallerByteMask(operand.Reg, width)
+	return valid && root != SP && !pointer && !opaque && mask != 0 && state.known[root]&mask == mask
+}
+
+func fixedLocalMove(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int, width int64) error {
+	if len(ins.Args) != 2 {
+		return goAMD64FrameContext("unproved fixed local scalar move")
+	}
+	value, err := fixedLocalReadValue(ins, 0, state, sig, proof, residue, width, false)
+	if err != nil {
+		return err
+	}
+	return fixedLocalWriteValue(ins, 1, 0, value, state, sig, proof, residue, width)
+}
+
+func fixedLocalVectorStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) error {
+	if effect, known, err := fixedLocalVectorByteEffect(*ins); known {
+		if err != nil {
+			return err
+		}
+		return fixedLocalTypedByteStep(ins, state, FuncSig{}, proof, residue, effect)
+	}
+	width := uint64(65535)
+	first, second, destination, memory := 0, 1, 1, -1
+	if form, known, err := x86FloatCompareProperties(*ins, "amd64"); known {
+		if err != nil || !form.legacy || form.scalar || form.byteWidth != 16 {
+			return goAMD64FrameContext("fixed local compare shape is not closed")
+		}
+		first, second, destination, memory = form.first, form.second, form.destination, form.memory
+	} else {
+		return goAMD64FrameContext("fixed local source has an unregistered typed vector effect: %s", ins.Op)
+	}
+	if state.vectors[x86CallerVectorRoot(ins.Args[second].Reg)]&width != width {
+		return goAMD64FrameContext("fixed local vector operation reads undefined destination bytes")
+	}
+	if memory >= 0 {
+		if _, _, err := fixedLocalReadMemory(ins, memory, state, proof, residue, 16, 16); err != nil {
+			return err
+		}
+	} else if state.vectors[x86CallerVectorRoot(ins.Args[first].Reg)]&width != width {
+		return goAMD64FrameContext("fixed local vector operation reads undefined source bytes")
+	}
+	state.vectors[x86CallerVectorRoot(ins.Args[destination].Reg)] |= width
+	return nil
+}
+
+func (c *amd64Ctx) fixedLocalMemoryCertified(ins Instr, index int) bool {
+	access, valid := c.fixedLocalMemoryAccess(ins, index)
+	return valid && !access.nativeInput
+}
+
+// Structural reachability is an emission projection, never an access role.
+// Private expansions and address-taken/indirect entries keep their own graphs.
+func (c *amd64Ctx) fixedLocalBlockReachability() ([]bool, error) {
+	if c.fixedLocal == nil || c.goarch != "amd64" || c.directTail != nil || c.indirectABI0 != nil ||
+		len(c.continuations) != 0 || len(c.indirectLabels) != 0 || c.fpScalarSource.x86ContinuationFlow != nil {
+		return nil, nil
+	}
+	edges, instructions, err := fixedLocalEdges(c.fpScalarSource)
+	if err != nil {
+		return nil, err
+	}
+	seen := make([]bool, len(instructions))
+	work := []int{0}
+	for head := 0; head < len(work); head++ {
+		pc := work[head]
+		if pc < 0 || pc >= len(seen) {
+			return nil, goAMD64FrameContext("fixed local emission reaches an unbound instruction")
+		}
+		if !seen[pc] {
+			seen[pc] = true
+			work = append(work, edges[pc]...)
+		}
+	}
+	if len(c.blockBase) != len(c.blocks) {
+		return nil, goAMD64FrameContext("fixed local emission block mapping differs")
+	}
+	reachable := make([]bool, len(c.blocks))
+	dead := false
+	pc := 0
+	for index, base := range c.blockBase {
+		if base != pc || pc > len(seen) {
+			return nil, goAMD64FrameContext("fixed local emission block has no source instruction")
+		}
+		// Empty adjacent labels share the following instruction's PC. A
+		// trailing unused label has no successor and remains unreachable.
+		reachable[index] = pc < len(seen) && seen[pc]
+		dead = dead || !reachable[index]
+		pc += len(c.blocks[index].instrs)
+	}
+	if pc != len(instructions) {
+		return nil, goAMD64FrameContext("fixed local emission source inventory is incomplete")
+	}
+	if !dead {
+		return nil, nil
+	}
+	// Reuse the complete live binding, declaration, fingerprint, grammar and
+	// independent replay checks before omitting any original instruction.
+	if err := c.checkFixedLocalResultInitialization(); err != nil {
+		return nil, err
+	}
+	pc = 0
+	for _, block := range c.blocks {
+		for _, ins := range block.instrs {
+			if pc >= len(instructions) || !reflect.DeepEqual(ins, c.fpScalarSource.Instrs[instructions[pc]]) {
+				return nil, goAMD64FrameContext("fixed local emission instruction differs from its source")
+			}
+			pc++
+		}
+	}
+	if pc != len(instructions) {
+		return nil, goAMD64FrameContext("fixed local emission source inventory is incomplete")
+	}
+	return reachable, nil
+}
+
+func (c *amd64Ctx) fixedLocalMemoryAccess(ins Instr, index int) (x86FixedLocalAccess, bool) {
+	access, found := ins.x86FixedLocalMemory[index]
+	shape, err := fixedLocalInstructionDigest(ins)
+	if !found || c.fixedLocal == nil || access.owner != c.fixedLocal || ins.x86Encoded ||
+		ins.x86SourceRaw != nil || ins.x86AddressBits != 0 || ins.x86SegmentPrefix != 0 ||
+		err != nil || access.shape != shape || access.width <= 0 {
+		return x86FixedLocalAccess{}, false
+	}
+	expected, bound := c.fixedLocal.accesses[access.ordinal][index]
+	return access, bound && reflect.DeepEqual(access, expected)
+}
diff --git a/amd64_fixed_local_range.go b/amd64_fixed_local_range.go
new file mode 100644
index 000000000..85aed5dae
--- /dev/null
+++ b/amd64_fixed_local_range.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import "math"
+
+type x86FixedLocalComparison struct {
+	register Reg
+	constant uint64
+	literal  x86StaticSBAddress
+}
+
+func cloneFixedLocalRanges(input map[Reg]x86UnsignedRange) map[Reg]x86UnsignedRange {
+	if len(input) == 0 {
+		return nil
+	}
+	copy := make(map[Reg]x86UnsignedRange, len(input))
+	for reg, value := range input {
+		copy[reg] = value
+	}
+	return copy
+}
+
+func (state *x86FixedLocalState) setRange(reg Reg, value x86UnsignedRange) {
+	if state.ranges == nil {
+		state.ranges = make(map[Reg]x86UnsignedRange)
+	}
+	state.ranges[reg] = value
+}
+
+func (state *x86FixedLocalState) revokeRange(reg Reg) {
+	delete(state.ranges, reg)
+	if state.comparison.register == reg {
+		state.comparison = x86FixedLocalComparison{}
+	}
+}
+
+// Called around the existing typed GP transfer, never as a second executor.
+// Other writes revoke bounds at the same shared register-write boundaries.
+func fixedLocalRangeEffect(ins Instr, effect x86TypedByteEffect, state *x86FixedLocalState) (Reg, x86UnsignedRange, x86FixedLocalComparison) {
+	// The existing effect distinguishes read-only comparisons from GP writes;
+	// unrelated arithmetic never re-enters the complete comparison grammar.
+	if len(effect.operands) == 2 && !effect.operands[0].write && !effect.operands[1].write {
+		if form, known, err := x86ScalarCompareProperties(ins.Op, ins, "amd64"); known && err == nil && form.bits == 64 {
+			first, second := form.args[0], form.args[1]
+			if first.Kind == OpReg && fixedLocalNumericRead(first, 8, state) {
+				if !form.test && second.Kind == OpImm {
+					return "", x86UnsignedRange{}, x86FixedLocalComparison{register: first.Reg, constant: uint64(second.Imm)}
+				}
+				if form.test && second.Kind == OpReg && first.Reg == second.Reg {
+					return "", x86UnsignedRange{}, x86FixedLocalComparison{register: first.Reg}
+				}
+			}
+		}
+	}
+	stem, bits, shiftFamily := amd64ScalarShiftRotateProperties(string(ins.Op))
+	if shiftFamily && bits == 64 && (stem == "SHL" || stem == "SAL") {
+		if form, known, err := x86ScalarShiftProperties(ins.Op, ins, "amd64"); known && err == nil &&
+			!form.double && form.count.Kind == OpImm && form.destination.Kind == OpReg {
+			value, bounded := state.ranges[form.destination.Reg]
+			shift := uint(form.maskedCount())
+			if bounded && value.maximum <= math.MaxUint64>>shift {
+				return form.destination.Reg, x86UnsignedRange{value.minimum << shift, value.maximum << shift}, x86FixedLocalComparison{}
+			}
+		}
+	}
+	return "", x86UnsignedRange{}, x86FixedLocalComparison{}
+}
+
+func fixedLocalRangeEdge(state x86FixedLocalState, op Op, taken bool) (x86FixedLocalState, bool) {
+	comparison := state.comparison
+	if comparison.register == "" {
+		return state, true
+	}
+	if comparison.literal.symbol != "" {
+		return fixedLocalLiteralEdge(state, op, taken)
+	}
+	value, bounded := state.ranges[comparison.register]
+	if !bounded {
+		value.maximum = math.MaxUint64
+	}
+	next, feasible := value.refine(op, taken, comparison.constant)
+	if !feasible || next == value {
+		return state, feasible
+	}
+	state.ranges = cloneFixedLocalRanges(state.ranges)
+	state.setRange(comparison.register, next)
+	return state, feasible
+}
+
+func mergeFixedLocalRanges(previous *x86FixedLocalState, current x86FixedLocalState) bool {
+	changed := false
+	for reg, old := range previous.ranges {
+		value, found := current.ranges[reg]
+		if !found {
+			delete(previous.ranges, reg)
+			changed = true
+			continue
+		}
+		value = value.hull(old)
+		previous.ranges[reg] = value
+		changed = changed || value != old
+	}
+	if previous.comparison != current.comparison && previous.comparison.register != "" {
+		previous.comparison = x86FixedLocalComparison{}
+		changed = true
+	}
+	return changed
+}
diff --git a/amd64_fixed_local_range_go127_test.go b/amd64_fixed_local_range_go127_test.go
new file mode 100644
index 000000000..2f233d8bc
--- /dev/null
+++ b/amd64_fixed_local_range_go127_test.go
@@ -0,0 +1,97 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalReadonlyRangeProgram(t *testing.T) (string, string, []fixedLocalRangeCase) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	for offset := 0; offset < 240; offset += 8 {
+		// Each source qword advances all eight bytes independently. Runtime
+		// expectations construct a byte array instead of parsing these DATA.
+		word := uint64(0x0807060504030201) + uint64(offset)*0x0101010101010101
+		fmt.Fprintf(&assembly, "DATA literal<>+%d(SB)/8,$0x%016x\n", offset, word)
+	}
+	assembly.WriteString("GLOBL literal<>(SB),8,$240\n")
+	rows := fixedLocalRangeCases()
+	if len(rows) != 48 {
+		t.Fatal("complete readonly range source inventory changed", len(rows))
+	}
+	for index, row := range rows {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(fixedLocalConstantIndexFunction(name, row.body))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+	}
+	return assembly.String(), declarations.String(), rows
+}
+
+func TestGoAMD64FixedLocalReadonlyRangeObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, rows := fixedLocalReadonlyRangeProgram(t)
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			var names []string
+			for index := range rows {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("original bounded readonly DATA index rejected", err)
+					}
+					if !strings.Contains(ir, "internal constant [240 x i8]") {
+						t.Fatal("the original complete readonly DATA allocation was lost")
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "readonly-range.ll", "readonly-range.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "readonly-range-opt.ll", "readonly-range-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalReadonlyRangeOwnerLifetime(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	assembly := fixedLocalRangeData + fixedLocalConstantIndexFunction("Value", fixedLocalRangePrefix+fixedLocalRangeLoad)
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+		"func Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+	fixedLocalDataAPIs(t, pkg, file, assembly, options, fixedLocalRequireContext)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ old, replacement string }{
+		{",8,$240", ",8,$256"},
+		{"CMPQ R9,$16", "CMPQ R9,$17"},
+		{"0x0102030405060708", "0x0102030405060709"},
+		{fixedLocalRangeData, ""},
+	} {
+		input := strings.Replace(assembly, mutation.old, mutation.replacement, 1)
+		parsed, err := Parse(ArchAMD64, input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fixedLocalDataAPIs(t, pkg, parsed, input, bound, fixedLocalRequireContext)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalDataAPIs(t, pkg, file, assembly, bound, fixedLocalRequireContext)
+}
diff --git a/amd64_fixed_local_range_runtime_go127_test.go b/amd64_fixed_local_range_runtime_go127_test.go
new file mode 100644
index 000000000..55607c1b9
--- /dev/null
+++ b/amd64_fixed_local_range_runtime_go127_test.go
@@ -0,0 +1,44 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalReadonlyRange(t *testing.T) {
+	assembly, declarations, cases := fixedLocalReadonlyRangeProgram(t)
+	inputs := []uint64{0, 1, 2, 14, 15, 16, 17, 31}
+	var data [240]byte
+	for index := range data {
+		data[index] = byte(index + 1)
+	}
+	var expected [][]string
+	for _, input := range inputs {
+		var values []string
+		for _, row := range cases {
+			index, stride := input, uint64(16)
+			switch row.name {
+			case "generic loop before bound":
+				index %= 16
+			case "scale/1":
+				stride = 1
+			case "scale/2":
+				stride = 2
+			case "scale/4":
+				stride = 4
+			case "scale/8":
+				stride = 8
+			}
+			value := input // Every rejected boundary preserves the original AX.
+			if index > 0 && index < 16 {
+				value = binary.LittleEndian.Uint64(data[(index-1)*stride:])
+			}
+			values = append(values, fmt.Sprintf("%016x", value))
+		}
+		expected = append(expected, values)
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
diff --git a/amd64_fixed_local_range_test.go b/amd64_fixed_local_range_test.go
new file mode 100644
index 000000000..b4d8d2333
--- /dev/null
+++ b/amd64_fixed_local_range_test.go
@@ -0,0 +1,275 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+	"testing"
+)
+
+const fixedLocalRangeData = "DATA literal<>+0(SB)/8,$0x0102030405060708\n" +
+	"DATA literal<>+232(SB)/8,$0x3132333435363738\nGLOBL literal<>(SB),8,$240\n"
+
+const fixedLocalRangePrefix = "MOVQ AX,R9\nCMPQ R9,$16\nJAE done\nTESTQ R9,R9\nJE done\n"
+const fixedLocalRangeLoad = "MOVQ R9,R11\nSHLQ $4,R11\nLEAQ literal<>(SB),R10\n" +
+	"MOVOU -16(R10)(R11*1),X0\nMOVQ X0,AX\ndone:"
+
+type fixedLocalRangeCase struct{ name, body string }
+
+func fixedLocalRangeCases() []fixedLocalRangeCase {
+	var cases []fixedLocalRangeCase
+	aliases := x86ConditionalBranchAliasOracle()
+	var names []string
+	for alias := range aliases {
+		names = append(names, alias)
+	}
+	sort.Strings(names)
+	for _, alias := range names {
+		var guard string
+		switch aliases[alias] {
+		case "JCS":
+			guard = "CMPQ R9,$16\n" + alias + " bounded\nJMP done\nbounded:\n"
+		case "JCC":
+			guard = "CMPQ R9,$16\n" + alias + " done\n"
+		case "JLS":
+			guard = "CMPQ R9,$15\n" + alias + " bounded\nJMP done\nbounded:\n"
+		case "JHI":
+			guard = "CMPQ R9,$15\n" + alias + " done\n"
+		case "JEQ":
+			guard = "CMPQ R9,$16\nJAE done\nTESTQ R9,R9\n" + alias + " done\n"
+		case "JNE":
+			guard = "CMPQ R9,$16\nJAE done\nTESTQ R9,R9\n" + alias + " nonzero\nJMP done\nnonzero:\n"
+		default:
+			continue
+		}
+		if aliases[alias] != "JEQ" && aliases[alias] != "JNE" {
+			guard += "TESTQ R9,R9\nJE done\n"
+		}
+		cases = append(cases, fixedLocalRangeCase{"condition/" + alias, "MOVQ AX,R9\n" + guard + fixedLocalRangeLoad})
+	}
+	for _, register := range strings.Fields("AX BX CX DX DI SI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+		body := strings.ReplaceAll(fixedLocalRangePrefix+fixedLocalRangeLoad, "R9", register)
+		cases = append(cases, fixedLocalRangeCase{"index/" + register, body})
+	}
+	for _, scale := range []int{1, 2, 4, 8} {
+		body := fixedLocalRangePrefix + fmt.Sprintf("LEAQ literal<>(SB),R10\nMOVOU -%d(R10)(R9*%d),X0\nMOVQ X0,AX\ndone:", scale, scale)
+		cases = append(cases, fixedLocalRangeCase{fmt.Sprintf("scale/%d", scale), body})
+	}
+	cases = append(cases,
+		fixedLocalRangeCase{"compare lower endpoint", strings.Replace(fixedLocalRangePrefix, "TESTQ R9,R9\nJE done", "CMPQ R9,$1\nJB done", 1) + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"flags preserved before branch", strings.Replace(fixedLocalRangePrefix, "JAE done", "MOVQ AX,R8\nNOP\nJAE done", 1) + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"range survives later flags", fixedLocalRangePrefix + "CMPQ AX,$12\nJE join\nNOP\njoin:\n" + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"unrelated partial write", fixedLocalRangePrefix + "MOVB $0,CL\n" + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"two bounded incoming paths", "MOVQ AX,R9\nTESTQ AX,AX\nJE small\nCMPQ R9,$16\nJAE done\nJMP bounded\nsmall:\nCMPQ R9,$8\nJAE done\nbounded:\nTESTQ R9,R9\nJE done\n" + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"generic loop before bound", "MOVQ AX,R9\nagain:\nCMPQ R9,$16\nJB tail\nSUBQ $16,R9\nJMP again\ntail:\nTESTQ R9,R9\nJE done\n" + fixedLocalRangeLoad},
+		fixedLocalRangeCase{"wide numerical shift count", fixedLocalRangePrefix + strings.Replace(fixedLocalRangeLoad, "SHLQ $4", "SHLQ $68", 1)},
+		fixedLocalRangeCase{"equivalent arithmetic shift spelling", fixedLocalRangePrefix + strings.Replace(fixedLocalRangeLoad, "SHLQ", "SALQ", 1)},
+	)
+	return cases
+}
+
+func fixedLocalRangeFixture(t *testing.T, body string) (Func, FuncSig, string) {
+	t.Helper()
+	fn, sig, source := fixedLocalGPFixture(t, body)
+	// This is an internal replay fixture, not a public source binding. The
+	// separate three-API object matrix captures the complete original DATA.
+	sig.x86FixedLocal = &x86FixedLocalBinding{literalData: map[string]x86FixedLocalData{
+		"literal<>": {size: 240, alignment: 16},
+	}}
+	return fn, sig, source
+}
+
+func TestGoAMD64FixedLocalReadonlyRangeComplete(t *testing.T) {
+	var original strings.Builder
+	original.WriteString(fixedLocalRangeData)
+	rows := fixedLocalRangeCases()
+	if len(rows) != 48 {
+		t.Fatal("unsigned/equality aliases, complete GP bank and scale inventory changed", len(rows))
+	}
+	for index, row := range rows {
+		fn, sig, source := fixedLocalRangeFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			proved, err := proveX86FixedLocal(fn, sig)
+			if err != nil {
+				t.Fatal("complete numerical range lost its readonly DATA access", err)
+			}
+			found := false
+			for _, instruction := range proved.Instrs {
+				if instruction.Op != "MOVOU" {
+					continue
+				}
+				found = true
+				access, present := instruction.x86FixedLocalMemory[0]
+				if !present || access.owner != proved.x86FixedLocal || access.width != 16 || access.write || !access.nativeInput {
+					t.Fatal("readonly numerical envelope acquired private storage or lost its complete tuple", access)
+				}
+			}
+			if !found {
+				t.Fatal("fixture has no complete indexed vector read")
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoAMD64FixedLocalReadonlyRangeGuards(t *testing.T) {
+	valid := fixedLocalRangePrefix + fixedLocalRangeLoad
+	rows := []fixedLocalRangeCase{
+		{"zero not excluded", strings.Replace(valid, "TESTQ R9,R9\nJE done\n", "", 1)},
+		{"upper edge reversed", strings.Replace(valid, "JAE done", "JB done", 1)},
+		{"sixteen admitted", strings.Replace(valid, "CMPQ R9,$16", "CMPQ R9,$17", 1)},
+		{"stale unsigned flags", strings.Replace(valid, "JAE done", "CMPQ AX,$32\nJAE done", 1)},
+		{"stale zero flags", strings.Replace(valid, "JE done", "CMPQ AX,$32\nJE done", 1)},
+		{"compared value overwritten", strings.Replace(valid, "JAE done", "MOVQ 0(SP),R9\nJAE done", 1)},
+		{"partial comparison", strings.Replace(valid, "CMPQ R9,$16", "CMPL R9,$16", 1)},
+		{"partial index overwrite", fixedLocalRangePrefix + "MOVB $0,R9\n" + fixedLocalRangeLoad},
+		{"loaded index loses range", fixedLocalRangePrefix + "MOVQ 0(SP),R9\n" + fixedLocalRangeLoad},
+		{"numerical arithmetic loses range", fixedLocalRangePrefix + "ADDQ $16,R9\n" + fixedLocalRangeLoad},
+		{"shift overflow", strings.Replace(valid, "SHLQ $4", "SHLQ $63", 1)},
+		{"lower bound before object", strings.Replace(valid, "MOVOU -16(", "MOVOU -17(", 1)},
+		{"complete vector after object", strings.Replace(valid, "MOVOU -16(", "MOVOU -15(", 1)},
+		{"wider complete tuple", strings.Replace(valid, "MOVOU -16(R10)(R11*1),X0", "VMOVDQU -16(R10)(R11*1),Y0", 1)},
+		{"alignment not inferred from interval", strings.Replace(valid, "SHLQ $4,R11", "SHLQ $0,R11", 1)},
+		{"unbounded incoming path", strings.Replace(valid, "CMPQ R9,$16", "CMPQ AX,$0\nJE unchecked\nCMPQ R9,$16", 1)},
+		{"private base is not literal", strings.Replace(valid, "LEAQ literal<>(SB),R10", "MOVQ SP,R10", 1)},
+		{"pointer cannot be numerical index", strings.Replace(valid, "MOVQ AX,R9", "MOVQ SP,R9", 1)},
+		{"missing upper numerical bytes", strings.Replace(valid, "MOVQ AX,R9", "MOVW AX,R9", 1)},
+		{"foreign readonly owner", strings.Replace(valid, "LEAQ literal<>(SB),R10", "LEAQ other<>(SB),R10", 1)},
+		{"readonly write", strings.Replace(valid, "MOVOU -16(R10)(R11*1),X0", "PXOR X0,X0\nMOVOU X0,-16(R10)(R11*1)", 1)},
+	}
+	var original strings.Builder
+	original.WriteString(fixedLocalRangeData + "GLOBL other<>(SB),8,$240\n")
+	// Dynamic native reads retain their original effective address. Their
+	// translation does not assert that every possible caller index is safe.
+	// Private relocation, initialization and storage ownership remain required.
+	rejected := map[string]bool{
+		"private base is not literal":       true,
+		"pointer cannot be numerical index": true,
+		"missing upper numerical bytes":     true,
+		"foreign readonly owner":            true,
+		"readonly write":                    true,
+	}
+	for index, row := range rows {
+		if row.name == "unbounded incoming path" {
+			row.body = strings.Replace(row.body, "MOVQ R9,R11", "unchecked:\nMOVQ R9,R11", 1)
+		}
+		if row.name == "alignment not inferred from interval" {
+			row.body = strings.Replace(row.body, "MOVOU -16(", "MOVO 0(", 1)
+		}
+		fn, sig, source := fixedLocalRangeFixture(t, row.body)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.name, func(t *testing.T) {
+			_, err := proveX86FixedLocal(fn, sig)
+			if !rejected[row.name] {
+				if err != nil {
+					t.Fatal("dynamic machine address incorrectly required a caller bounds proof", err)
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("private, undefined or readonly storage acquired permission", err)
+			}
+			for _, instruction := range fn.Instrs {
+				if len(instruction.x86FixedLocalMemory) != 0 {
+					t.Fatal("failed range proof published provisional accesses")
+				}
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+}
+
+func TestGoX86SDKLiteralUnsignedRangeEdges(t *testing.T) {
+	// A small exhaustive value oracle is independent of the interval formulas.
+	// It includes zero, interior exclusions and the unsigned overflow endpoint.
+	for alias, canonical := range x86ConditionalBranchAliasOracle() {
+		if canonical != "JCS" && canonical != "JCC" && canonical != "JLS" && canonical != "JHI" && canonical != "JEQ" && canonical != "JNE" {
+			continue
+		}
+		t.Run(alias, func(t *testing.T) {
+			for _, extent := range [][2]uint64{{0, 0}, {1, 1}, {15, 15}, {16, 16}, {0, 15}, {0, 31}, {1, 15}, {math.MaxUint64 - 2, math.MaxUint64}} {
+				for _, bound := range []uint64{0, 1, 15, 16, math.MaxUint64} {
+					for _, taken := range []bool{false, true} {
+						minimum, maximum, feasible := uint64(0), uint64(0), false
+						for value := extent[0]; ; value++ {
+							var result bool
+							switch canonical {
+							case "JCS":
+								result = value < bound
+							case "JCC":
+								result = value >= bound
+							case "JLS":
+								result = value <= bound
+							case "JHI":
+								result = value > bound
+							case "JEQ":
+								result = value == bound
+							case "JNE":
+								result = value != bound
+							}
+							if result == taken {
+								if !feasible {
+									minimum = value
+								}
+								maximum, feasible = value, true
+							}
+							if value == extent[1] {
+								break
+							}
+						}
+						state := x86SDKLiteralState{comparison: 0, compared: true, constant: bound}
+						state.gp[0] = x86SDKLiteralValue{width: 8, minimum: extent[0], maximum: extent[1]}
+						actual := x86SDKLiteralRefineEdge(Op(alias), taken, &state)
+						if actual != feasible || feasible && (state.gp[0].minimum != minimum || state.gp[0].maximum != maximum) {
+							t.Fatal("unsigned edge differs from enumerated values", extent, bound, taken, state.gp[0], actual, minimum, maximum, feasible)
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalReadonlyRangeWriteRevocation(t *testing.T) {
+	for _, row := range []string{
+		"MOVB $0,R9", "MOVQ AX,R9", "MOVL AX,R9", "ADDQ $1,R9",
+		"LEAQ 16(SP),R9", "LEAQ literal<>(SB),R9", "CMOVQEQ AX,R9",
+		"SETNE R9", "KMOVQ K1,R9", "VPEXTRQ $0,X0,R9", "MOVQ X0,R9",
+	} {
+		t.Run(row, func(t *testing.T) {
+			state := x86FixedLocalState{
+				pointers: map[Reg]int64{SP: 0}, opaque: make(map[Reg]x86FixedLocalOrigins),
+				constants: map[Reg]int64{AX: 7, "R9": 3}, booleans: make(map[Reg]uint8),
+				known: map[Reg]uint8{AX: 255, "R9": 255}, vectors: map[Reg]uint64{"Z0": ^uint64(0)},
+				masks: map[Reg]bool{"K1": true}, flags: x86ByteFlagsAll,
+				ranges: map[Reg]x86UnsignedRange{"R9": {1, 15}}, comparison: x86FixedLocalComparison{register: "R9", constant: 16},
+			}
+			proof := &x86FixedLocalProof{frame: 64, binding: &x86FixedLocalBinding{
+				literalData: map[string]x86FixedLocalData{"literal<>": {size: 240, alignment: 16}},
+			}}
+			ins := x86ScalarLaneInstruction(t, row)
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, proof, 0); err != nil {
+				t.Fatal("registered write fixture rejected", err)
+			}
+			if _, stale := state.ranges["R9"]; stale || state.comparison.register != "" {
+				t.Fatal("GP writer retained a stale numerical range or FLAGS relation", state.ranges, state.comparison)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalUnsignedRangeDeadBackedge(t *testing.T) {
+	// TEST clears CF regardless of the input, so JB cannot revisit the store.
+	// The previous CMP must neither force three iterations nor reject this
+	// actual one-pass function merely because its source contains a backedge.
+	const body = "MOVQ $0,SI\nloop:\nMOVQ AX,16(SP)(SI*8)\nADDQ $1,SI\n" +
+		"CMPQ SI,$3\nTESTQ AX,AX\nJB loop\nMOVQ AX,AX"
+	fn, sig, source := fixedLocalCountedLoopFixture(t, body)
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	if _, err := proveX86FixedLocal(fn, sig); err != nil {
+		t.Fatal("a provably dead backedge rejected an ordinary one-pass private access", err)
+	}
+}
diff --git a/amd64_fixed_local_replay_test.go b/amd64_fixed_local_replay_test.go
new file mode 100644
index 000000000..5f36cff85
--- /dev/null
+++ b/amd64_fixed_local_replay_test.go
@@ -0,0 +1,306 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func fixedLocalReplaySource(body string) string {
+	return "TEXT ·Value(SB),4,$64-16\nMOVQ a+0(FP),AX\n" +
+		"MOVQ AX,0(SP)\nMOVQ AX,8(SP)\nMOVOU 0(SP),X0\nMOVOU X0,X1\n" +
+		body + "\nMOVQ X0,AX\nMOVQ AX,ret+8(FP)\nRET\n"
+}
+
+// These analysis-only fixtures deliberately exclude source capture, subprocesses
+// and LLVM construction. Their complete proof must succeed before timing starts.
+func fixedLocalReplayFixture(t testing.TB, body string) (Func, FuncSig) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, fixedLocalReplaySource(body))
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "Value", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}}
+	return file.Funcs[0], sig
+}
+
+func fixedLocalReplayBody(shape string, length int) string {
+	const instruction = "PADDQ X1,X0\n"
+	switch shape {
+	case "linear":
+		return strings.Repeat(instruction, length)
+	case "diamond":
+		return "CMPQ AX,AX\nJEQ left\n" + strings.Repeat(instruction, length/2) +
+			"JMP joined\nleft:\n" + strings.Repeat(instruction, length-length/2) + "joined:\n"
+	case "loop":
+		return "MOVQ $3,CX\nagain:\n" + strings.Repeat(instruction, length) +
+			"SUBQ $1,CX\nJNE again\n"
+	default:
+		panic("unknown fixed-local replay fixture shape")
+	}
+}
+
+func TestGoAMD64FixedLocalReplayInstructionBudget(t *testing.T) {
+	for _, length := range []int{8, 128, 1024, 5000} {
+		t.Run(fmt.Sprint(length), func(t *testing.T) {
+			fn, sig := fixedLocalReplayFixture(t, fixedLocalReplayBody("linear", length))
+			effects, err := fixedLocalEffectPlan(fn, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, instructions, err := fixedLocalEdges(fn)
+			if err != nil {
+				t.Fatal(err)
+			}
+			count := len(instructions)
+			for _, deficit := range []string{"none", "step", "byte"} {
+				t.Run(deficit, func(t *testing.T) {
+					current := fn
+					current.Instrs = append([]Instr(nil), fn.Instrs...)
+					proof := &x86FixedLocalProof{frame: fn.FrameSize}
+					budget := x86FixedLocalBudget{steps: count, bytes: int64(count) * fn.FrameSize}
+					if deficit == "step" {
+						budget.steps--
+					}
+					if deficit == "byte" {
+						budget.bytes--
+					}
+					err := replayX86FixedLocal(&current, sig, proof, 0, &budget, effects, nil)
+					if deficit == "none" {
+						if err != nil || budget.steps != 0 || budget.bytes != 0 {
+							t.Fatalf("complete transfer: budget=%+v, error=%v", budget, err)
+						}
+						accesses := 0
+						for _, ins := range current.Instrs {
+							accesses += len(ins.x86FixedLocalMemory)
+						}
+						if accesses != 3 {
+							t.Fatalf("got %d private accesses, want both stores and complete vector load", accesses)
+						}
+						return
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("exhausted %s budget returned %v", deficit, err)
+					}
+					for _, ins := range current.Instrs {
+						if len(ins.x86FixedLocalMemory) != 0 {
+							t.Fatal("incomplete replay published a provisional access")
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func fixedLocalReplayControlCases() []struct {
+	name  string
+	body  string
+	valid bool
+} {
+	return []struct {
+		name  string
+		body  string
+		valid bool
+	}{
+		{"linear", fixedLocalReplayBody("linear", 8), true},
+		{"diamond", fixedLocalReplayBody("diamond", 8), true},
+		{"loop", fixedLocalReplayBody("loop", 8), true},
+		{"duplicate successor", "CMPQ AX,AX\nJEQ next\nnext:\nPADDQ X1,X0", true},
+		{"interior target", "CMPQ AX,AX\nJEQ middle\nPADDQ X1,X0\nmiddle:\nPADDQ X1,X0", true},
+		{"two returns", "CMPQ AX,AX\nJEQ other\nMOVQ AX,ret+8(FP)\nRET\nother:\nPADDQ X1,X0", true},
+		{"unreachable read", "JMP done\nMOVQ 24(SP),AX\ndone:\nPADDQ X1,X0", true},
+		{"equal private origins", "MOVQ SP,BX\nCMPQ AX,AX\nJEQ left\nADDQ $8,BX\nJMP joined\nleft:\nADDQ $8,BX\njoined:\nNOP", true},
+		{"different private origins", "MOVQ SP,BX\nCMPQ AX,AX\nJEQ left\nADDQ $8,BX\nJMP joined\nleft:\nADDQ $16,BX\njoined:\nNOP", true},
+		{"different address cells", "MOVQ SP,BX\nMOVQ BX,24(SP)\nCMPQ AX,AX\nJEQ joined\nMOVQ $0,24(SP)\njoined:\nNOP", false},
+		{"missing predecessor bytes", "CMPQ AX,AX\nJEQ joined\nMOVQ AX,24(SP)\njoined:\nMOVQ 24(SP),AX", false},
+		{"missing first iteration", "again:\nPADDQ X2,X0\nMOVOU X1,X2\nCMPQ AX,AX\nJNE again", false},
+		{"lost backedge flags", "CMPQ AX,AX\nagain:\nSETNE CL\nIMULQ $3,AX\nJCS again", false},
+		{"drifting private origin", "MOVQ SP,BX\nagain:\nADDQ $8,BX\nCMPQ AX,AX\nJNE again", false},
+		{"one return missing result", "CMPQ AX,AX\nJEQ other\nRET\nother:\nPADDQ X1,X0", false},
+		{"no reachable return", "again:\nJMP again", false},
+	}
+}
+
+func TestGoAMD64FixedLocalReplayControlFlow(t *testing.T) {
+	for _, row := range fixedLocalReplayControlCases() {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig := fixedLocalReplayFixture(t, row.body)
+			_, err := proveX86FixedLocal(fn, sig)
+			if (err == nil) != row.valid {
+				t.Fatalf("valid=%v: %v", row.valid, err)
+			}
+			if err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unexpected rejection: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalReplayDistinctPrivateLayoutsObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, row := range fixedLocalReplayControlCases() {
+		if row.name != "different private origins" {
+			continue
+		}
+		// Both paths keep BX private, and its different offsets are dead at
+		// the join. Retain the original stores, vector load and ABI0 result.
+		source := fixedLocalReplaySource(row.body)
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, target := range []struct{ name, triple string }{
+			{"linux/amd64", "x86_64-unknown-linux-gnu"},
+			{"darwin/amd64", "x86_64-apple-darwin"},
+			{"windows/amd64", "x86_64-pc-windows-msvc"},
+		} {
+			t.Run(target.name, func(t *testing.T) {
+				pkg, request, _, options := fixedLocalTransportFixture(t, source,
+					"func Value(a uint64) uint64\n", target.name, target.triple)
+				fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+					func(t *testing.T, ir string, err error) {
+						if err != nil {
+							t.Fatal("complete private-layout source failed", err)
+						}
+						x86CompactExpandRequireAllDefinitions(t, ir, []string{pkg.Path + ".Value"})
+						compileLLVMToObject(t, llc, target.triple, "layout.ll", "layout.o", ir)
+						compileLLVMToObject(t, llc, target.triple, "layout-opt.ll", "layout-opt.o", x86MulDivRoundOptimize(t, ir))
+					})
+			})
+		}
+		return
+	}
+	t.Fatal("original distinct-private-layout source is missing")
+}
+
+func TestGoAMD64FixedLocalReplayLinearBoundaries(t *testing.T) {
+	for _, row := range []struct {
+		name   string
+		body   string
+		linear []bool
+	}{
+		{"straight", "NOP\nNOP\nRET", []bool{true, true, true, false}},
+		{"label", "NOP\nunused:\nNOP\nRET", []bool{true, true, true, false}},
+		{"jump", "JMP next\nnext:\nNOP\nRET", []bool{true, false, true, false}},
+		{"duplicate edge", "JEQ next\nnext:\nNOP\nRET", []bool{true, false, true, false}},
+		{"interior target", "JEQ next\nNOP\nnext:\nNOP\nRET", []bool{true, false, false, true, false}},
+		{"backedge", "again:\nNOP\nNOP\nJMP again", []bool{false, true, true, false}},
+		{"unreachable predecessor", "JMP done\nNOP\ndone:\nRET", []bool{true, false, false, false}},
+		{"missing return", "NOP", []bool{true, false}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-0\n"+row.body+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			edges, instructions, err := fixedLocalEdges(fn)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := fixedLocalLinearEdges(fn, edges, instructions); !reflect.DeepEqual(got, row.linear) {
+				t.Fatalf("linear edges = %v, want %v", got, row.linear)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalReplayMatchesInstructionSchedule(t *testing.T) {
+	for _, row := range fixedLocalReplayControlCases() {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig := fixedLocalReplayFixture(t, row.body)
+			edges, instructions, err := fixedLocalEdges(fn)
+			if err != nil {
+				t.Fatal(err)
+			}
+			effects, err := fixedLocalEffectPlan(fn, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof := &x86FixedLocalProof{frame: fn.FrameSize}
+			var results [2]Func
+			for schedule := range results {
+				current := fn
+				current.Instrs = append([]Instr(nil), fn.Instrs...)
+				var linear []bool
+				if schedule == 1 {
+					linear = fixedLocalLinearEdges(fn, edges, instructions)
+				}
+				budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+				var layouts x86FixedLocalLayoutGraph
+				for residue := 0; residue < 8; residue++ {
+					err = replayX86FixedLocalCFG(&current, sig, proof, residue, &budget, effects, edges, instructions, linear, nil, &layouts)
+					if (err == nil) != row.valid {
+						t.Fatalf("schedule=%d residue=%d valid=%v: %v", schedule, residue, row.valid, err)
+					}
+					if err != nil {
+						if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(current.Instrs, fn.Instrs) {
+							t.Fatalf("schedule=%d invalid replay changed input or rejection class: %v", schedule, err)
+						}
+						break
+					}
+				}
+				results[schedule] = current
+			}
+			if !reflect.DeepEqual(results[0], results[1]) {
+				t.Fatal("linear replay changed a source instruction or its eight-residue access certificate")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalReplayAllocations(t *testing.T) {
+	fn, sig := fixedLocalReplayFixture(t, fixedLocalReplayBody("linear", 128))
+	edges, instructions, err := fixedLocalEdges(fn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	effects, err := fixedLocalEffectPlan(fn, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	measure := func(linear []bool) float64 {
+		return testing.AllocsPerRun(3, func() {
+			current := fn
+			current.Instrs = append([]Instr(nil), fn.Instrs...)
+			proof := &x86FixedLocalProof{frame: fn.FrameSize}
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+			if err := replayX86FixedLocalCFG(&current, sig, proof, 0, &budget, effects, edges, instructions, linear, nil, nil); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	reference := measure(nil)
+	blocks := measure(fixedLocalLinearEdges(fn, edges, instructions))
+	if blocks >= reference/2 {
+		t.Fatalf("linear state copies still dominate: %.0f allocations versus %.0f for instruction scheduling", blocks, reference)
+	}
+}
+
+func BenchmarkFixedLocalReplayProof(b *testing.B) {
+	for _, shape := range []string{"linear", "diamond", "loop"} {
+		for _, length := range []int{8, 128, 1024, 5000} {
+			b.Run(fmt.Sprintf("%s/%d", shape, length), func(b *testing.B) {
+				fn, sig := fixedLocalReplayFixture(b, fixedLocalReplayBody(shape, length))
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					b.Fatalf("fixture must complete before timing: %v", err)
+				}
+				b.ReportAllocs()
+				b.ResetTimer()
+				for n := 0; n < b.N; n++ {
+					if _, err := proveX86FixedLocal(fn, sig); err != nil {
+						b.Fatal(err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fixed_local_result.go b/amd64_fixed_local_result.go
new file mode 100644
index 000000000..9a9d0106f
--- /dev/null
+++ b/amd64_fixed_local_result.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"reflect"
+)
+
+// Fixed-local physical SP and its initialized result already have a complete
+// native source/CFG proof. Revalidate that exact role instead of reinterpreting
+// its private access annotations as logical AUTO bytes. A proof pointer alone
+// is not permission, and this route supplies no new native/caller capability.
+func (c *amd64Ctx) checkFixedLocalResultInitialization() error {
+	fn, sig, proof := c.fpScalarSource, c.fpSourceSig, c.fixedLocal
+	binding := sig.x86FixedLocal
+	fail := func(reason string) error { return goAMD64FrameContext("fixed local result consumer: %s", reason) }
+	if binding == nil || proof == nil || fn.x86FixedLocal != proof || proof.binding != binding ||
+		c.goarch != "amd64" || c.targetTriple != binding.target || fn.FrameSize != proof.frame || c.frameSize != fn.FrameSize {
+		return fail("source/proof/target/frame role differs")
+	}
+	fn = fixedLocalProofFunction(fn)
+	if c.fixedLocalResult == nil {
+		if err := binding.verify(); err != nil {
+			return err
+		}
+	}
+	emitted := c.sig
+	emitted.Attrs = sig.Attrs // Checked against the actual complete renderer inventory below.
+	if !reflect.DeepEqual(emitted, sig) {
+		return fail("emitted logical signature differs from the original declaration")
+	}
+	expected, declared := binding.signatures[binding.symbols[fn.Sym]]
+	sig.x86FixedLocal = nil
+	if !declared || !reflect.DeepEqual(sig, expected) {
+		return fail("actual declaration/signature differs")
+	}
+	sig.x86FixedLocal = binding
+	snapshot := c.fixedLocalResult
+	if snapshot == nil {
+		var err error
+		snapshot, err = newX86FixedLocalResultSnapshot(binding, c.goarch)
+		if err != nil {
+			return err
+		}
+	}
+	if snapshot.binding != binding || snapshot.file != binding.file {
+		return fail("complete source snapshot belongs to a different binding")
+	}
+	original, valid := snapshot.functions[sig.Name]
+	if !valid || c.sig.Attrs != original.attributes || c.fpFeatureAttrs != original.inferred {
+		return fail("emitted attributes are not the exact complete-source renderer projection")
+	}
+	fingerprint, err := x86CallerSourceFingerprint(fn)
+	if err != nil || fingerprint != proof.function {
+		return fail("complete normalized function fingerprint differs")
+	}
+	plain := fn
+	plain.Instrs = append([]Instr(nil), fn.Instrs...)
+	for ordinal, ins := range fn.Instrs {
+		if len(ins.x86FixedLocalMemory) != len(proof.accesses[ordinal]) {
+			return fail("instruction access inventory differs")
+		}
+		for operand, access := range ins.x86FixedLocalMemory {
+			_, valid := c.fixedLocalMemoryAccess(ins, operand)
+			if access.ordinal != ordinal || !valid {
+				return fail("instruction access owner/shape/ordinal differs")
+			}
+		}
+		plain.Instrs[ordinal].x86FixedLocalMemory = nil
+	}
+	for ordinal := range proof.accesses {
+		if ordinal < 0 || ordinal >= len(fn.Instrs) {
+			return fail("access ordinal is outside the complete function")
+		}
+	}
+	instructions, err := x86ResultAUTOReplayInstructions(plain, c.goarch)
+	if err != nil {
+		return err
+	}
+	reference := original.function
+	view, err := original.graph.fixedLocalRoot(reference.Sym)
+	if err != nil {
+		return err
+	}
+	if view != nil {
+		actual := fn.x86DirectTailRoot
+		if actual == nil || view.text != actual.text || !reflect.DeepEqual(view.points, actual.points) ||
+			!reflect.DeepEqual(view.ordinals, actual.ordinals) || !reflect.DeepEqual(view.edges, actual.edges) ||
+			!reflect.DeepEqual(view.externalTails, actual.externalTails) {
+			return fail("original private root control/source coordinates differ")
+		}
+		reference = view.features()
+	} else if fn.x86DirectTailRoot != nil {
+		return fail("ordinary source acquired a private root view")
+	}
+	if reference.Sym != fn.Sym || reference.FrameSize != fn.FrameSize ||
+		reference.ArgSize != fn.ArgSize || !reflect.DeepEqual(reference.Instrs, instructions) {
+		return fail("original TEXT/source instruction roles differ")
+	}
+	replayed, err := proveX86FixedLocal(plain, sig)
+	if err != nil {
+		return err
+	}
+	for ordinal, accesses := range proof.accesses {
+		if len(accesses) != len(replayed.x86FixedLocal.accesses[ordinal]) {
+			return fail("recomputed access inventory differs")
+		}
+		for operand, access := range accesses {
+			recomputed, found := replayed.x86FixedLocal.accesses[ordinal][operand]
+			access.owner, recomputed.owner = nil, nil // Compare effects, not new builder identity.
+			if !found || !reflect.DeepEqual(access, recomputed) {
+				return fail("recomputed access byte effects differ")
+			}
+		}
+	}
+	if len(proof.accesses) != len(replayed.x86FixedLocal.accesses) {
+		return fail("recomputed function access inventory differs")
+	}
+	if c.fixedLocalResult == nil {
+		return binding.verify()
+	}
+	return nil
+}
+
+// A module-call-local index of independently parsed source, not a live source
+// verification result or a new permission. Only the module's existing complete
+// pre/post guards permit sharing it between function consumers. Standalone
+// consumers construct their own index inside the original live guards.
+type x86FixedLocalResultSnapshot struct {
+	binding   *x86FixedLocalBinding
+	file      [32]byte
+	functions map[string]x86FixedLocalResultFunction
+}
+
+type x86FixedLocalResultFunction struct {
+	function   Func
+	graph      *x86DirectTailGraph // Original source/indices only; no retained expansion.
+	attributes string
+	inferred   string
+}
+
+func newX86FixedLocalResultSnapshot(binding *x86FixedLocalBinding, arch string) (*x86FixedLocalResultSnapshot, error) {
+	fail := func(reason string) (*x86FixedLocalResultSnapshot, error) {
+		return nil, goAMD64FrameContext("fixed local result consumer: %s", reason)
+	}
+	if binding == nil || binding.source == nil {
+		return fail("missing complete original source binding")
+	}
+	// Replay actual guarded CPP, not a mutually consistent replacement of the
+	// binding's private assembly/fingerprint. No caller callback runs under mu.
+	binding.source.mu.Lock()
+	if !binding.source.ready {
+		binding.source.mu.Unlock()
+		return fail("original source is closed or revoked")
+	}
+	original, err := binding.source.read(filepath.Join(binding.source.request.Directory, binding.source.request.AssemblyFile))
+	var expanded string
+	if err == nil {
+		expanded, err = binding.source.preprocess(binding.source.request.AssemblyFile, original)
+	}
+	binding.source.mu.Unlock()
+	if err != nil || expanded != binding.assembly {
+		return fail("expanded assembly differs from the actual guarded source")
+	}
+	actual, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		return fail("complete original assembly cannot be parsed")
+	}
+	fingerprint, err := x86CallerSourceFingerprint(actual)
+	if err != nil || fingerprint != binding.file {
+		return fail("complete original assembly fingerprint differs")
+	}
+	functions, valid := fixedLocalResultFunctions(actual, binding, arch)
+	if !valid {
+		return fail("complete source feature inventory is missing or ambiguous")
+	}
+	return &x86FixedLocalResultSnapshot{binding: binding, file: fingerprint, functions: functions}, nil
+}
+
+// Reproduce the renderer's complete source-order feature allocation once. The
+// reference spelling alone is not proof, and supplied attributes never pass
+// through the inference registry or become a removable source difference.
+func fixedLocalResultFunctions(file *File, binding *x86FixedLocalBinding, arch string) (map[string]x86FixedLocalResultFunction, bool) {
+	if len(binding.leaves) != 0 {
+		signatures, err := cloneFixedLocalSigs(binding.signatures)
+		if err != nil {
+			return nil, false
+		}
+		for name, sig := range signatures {
+			if binding.frames[name] {
+				sig.x86FixedLocal = binding
+				signatures[name] = sig
+			}
+		}
+		options := Options{Goarch: arch, Sigs: signatures,
+			ResolveSym: func(symbol string) string { return binding.symbols[symbol] }}
+		graph, err := newX86FixedLocalLeafGraph(file, options, binding)
+		if err != nil {
+			return nil, false
+		}
+		copy := *file
+		copy.x86DirectTails = graph
+		file = &copy
+	}
+	registry := newFeatureAttrRegistry()
+	functions := make(map[string]x86FixedLocalResultFunction, len(file.Funcs))
+	for _, fn := range file.Funcs {
+		if file.x86DirectTailHelper(fn.Sym) {
+			continue
+		}
+		resolved, found := binding.symbols[fn.Sym]
+		sig, declared := binding.signatures[resolved]
+		_, duplicate := functions[resolved]
+		if !found || !declared || duplicate || len(fn.X86RawText) != 0 || amd64IsRelocationAnchor(fn, sig) {
+			return nil, false
+		}
+		features := fn
+		view, err := file.x86DirectTails.fixedLocalRoot(fn.Sym)
+		if err != nil {
+			return nil, false
+		}
+		if view != nil {
+			features = view.features()
+		}
+		derived := ""
+		if sig.Attrs == "" {
+			derived = registry.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, arch, features))
+		}
+		attributes := sig.Attrs
+		if attributes == "" {
+			attributes = derived
+		}
+		functions[resolved] = x86FixedLocalResultFunction{
+			function: fn, graph: file.x86DirectTails, attributes: attributes, inferred: derived,
+		}
+	}
+	return functions, true
+}
diff --git a/amd64_fixed_local_result_selection_test.go b/amd64_fixed_local_result_selection_test.go
new file mode 100644
index 000000000..35787d4f7
--- /dev/null
+++ b/amd64_fixed_local_result_selection_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoAMD64FixedLocalResultCompleteMembersAndSelectionBoundary(t *testing.T) {
+	pkg, request, _, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	first, _, _ := x86PrivateAlignedFrameAuditFixture(t, "PADDQ 16(SP),X0")
+	second, _, _ := x86PrivateAlignedFrameAuditFixture(t, "AESENC 16(SP),X0")
+	second = strings.Replace(second, "·Value", "·Other", 1)
+	second = strings.Replace(second, "#include \"textflag.h\"\n", "", 1)
+	assembly := first + "\n" + second
+	declarations := "package framefixture\nfunc Value(a, b, c, d uint64) uint64\nfunc Other(a, b, c, d uint64) uint64\n"
+	for name, data := range map[string]string{"value.go": declarations, request.AssemblyFile: assembly} {
+		if err := os.WriteFile(filepath.Join(request.Directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "value.go", declarations, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg.Types, pkg.Syntax = typed, []*ast.File{syntax}
+	for _, name := range []string{"Value", "Other"} {
+		sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, typed.Scope().Lookup(name).(*types.Func), "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("complete two-member actual original object/declaration precondition", err)
+	}
+	for _, api := range []string{"text", "context", "go-module"} {
+		t.Run(api, func(t *testing.T) {
+			var ir string
+			if api == "text" {
+				ir, err = Translate(file, bound)
+			} else {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				var module llvm.Module
+				if api == "context" {
+					module, err = TranslateModuleInContext(context, file, bound)
+				} else {
+					result, translateErr := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+						GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple, ResolveSym: bound.ResolveSym,
+						ManualSig: func(name string) (FuncSig, bool) { sig, found := bound.Sigs[name]; return sig, found },
+					})
+					err = translateErr
+					if result != nil {
+						module = result.Module
+					}
+				}
+				if !module.IsNil() {
+					defer module.Dispose()
+					ir = module.String()
+				}
+			}
+			if err != nil || !strings.Contains(ir, pkg.Path+".Value") || !strings.Contains(ir, pkg.Path+".Other") {
+				t.Fatal("complete original member/renderer projection failed", err)
+			}
+		})
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	queries := 0
+	result, err := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+		GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple, ResolveSym: bound.ResolveSym,
+		ManualSig: func(name string) (FuncSig, bool) { sig, found := bound.Sigs[name]; return sig, found },
+		KeepFunc:  func(_, name string) bool { queries++; return name == pkg.Path+".Other" },
+	})
+	if result != nil {
+		if !result.Module.IsNil() {
+			result.Module.Dispose()
+		}
+		t.Fatal("partial selection retained a whole-file native capability")
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || queries != 2 {
+		t.Fatal("unsupported partial native selection was admitted or KeepFunc was repeated", queries, err)
+	}
+}
diff --git a/amd64_fixed_local_result_test.go b/amd64_fixed_local_result_test.go
new file mode 100644
index 000000000..3a11e8160
--- /dev/null
+++ b/amd64_fixed_local_result_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalResultFeatureAttrs(file *File, binding *x86FixedLocalBinding, name, arch string) (string, string, bool) {
+	functions, valid := fixedLocalResultFunctions(file, binding, arch)
+	function, found := functions[name]
+	return function.attributes, function.inferred, valid && found
+}
+
+func TestX86FixedLocalFeatureProjectionUsesCompleteSourceOrder(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·First(SB),4,$0\nAESENC X0,X1\nRET\nTEXT ·Second(SB),4,$0\nPSHUFB X0,X1\nRET")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		binding := &x86FixedLocalBinding{symbols: map[string]string{"·First": "First", "·Second": "Second"},
+			signatures: map[string]FuncSig{"First": {Name: "First"}, "Second": {Name: "Second"}}}
+		for index, name := range []string{"First", "Second"} {
+			attrs, inferred, valid := fixedLocalResultFeatureAttrs(file, binding, name, arch)
+			if !valid || attrs != fmt.Sprintf("#%d", featureAttrBase+index) || inferred != attrs {
+				t.Fatal("complete renderer reference/order differs", arch, name, attrs, inferred, valid)
+			}
+		}
+		binding.signatures["First"] = FuncSig{Name: "First", Attrs: "nounwind"}
+		attrs, inferred, valid := fixedLocalResultFeatureAttrs(file, binding, "First", arch)
+		if !valid || attrs != "nounwind" || inferred != "" {
+			t.Fatal("supplied attributes became removable inferred metadata")
+		}
+		attrs, inferred, valid = fixedLocalResultFeatureAttrs(file, binding, "Second", arch)
+		if !valid || attrs != fmt.Sprintf("#%d", featureAttrBase) || inferred != attrs {
+			t.Fatal("supplied attributes incorrectly consumed a renderer reference")
+		}
+		delete(binding.symbols, "·First")
+		if _, _, valid := fixedLocalResultFeatureAttrs(file, binding, "Second", arch); valid {
+			t.Fatal("incomplete unrelated source inventory accepted")
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalResultConsumerExactProofHandoff(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64", bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, sig := normalized.Funcs[0], bound.Sigs[pkg.Path+".Value"]
+	attributes, inferred, valid := fixedLocalResultFeatureAttrs(file, sig.x86FixedLocal, sig.Name, "amd64")
+	if !valid {
+		t.Fatal("actual complete renderer inventory precondition")
+	}
+	snapshot, err := newX86FixedLocalResultSnapshot(sig.x86FixedLocal, "amd64")
+	if err != nil || snapshot == nil || len(snapshot.functions) != 1 {
+		t.Fatal("independent call-local original source index", err)
+	}
+	create := func(fn Func) *amd64Ctx {
+		var output strings.Builder
+		lower := newX86Ctx(&output, fn, sig, bound.ResolveSym, bound.Sigs, "amd64", bound.TargetTriple, false)
+		lower.fpFeatureAttrs, lower.sig.Attrs = inferred, attributes
+		return lower
+	}
+	if err := create(fn).checkLoweredScalarFPResultInitialization(); err != nil {
+		t.Fatal("exact existing fixed-local result proof was stolen by logical AUTO replay", err)
+	}
+	scoped := create(fn)
+	scoped.fixedLocalResult = snapshot
+	if err := scoped.checkLoweredScalarFPResultInitialization(); err != nil {
+		t.Fatal("call-local original source index changed result proof", err)
+	}
+	if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("private source query gained physical-frame permission", err)
+	}
+	for name, mutate := range map[string]func(*amd64Ctx){
+		"wrong target":           func(c *amd64Ctx) { c.targetTriple = "x86_64-pc-windows-msvc" },
+		"wrong mode":             func(c *amd64Ctx) { c.goarch = "386" },
+		"missing proof":          func(c *amd64Ctx) { c.fixedLocal = nil },
+		"changed declaration":    func(c *amd64Ctx) { c.fpSourceSig.Ret = I32 },
+		"changed emitted type":   func(c *amd64Ctx) { c.sig.Ret = I32 },
+		"changed emitted attrs":  func(c *amd64Ctx) { c.sig.Attrs = "readnone" },
+		"changed inferred attrs": func(c *amd64Ctx) { c.fpFeatureAttrs = "#999" },
+		"changed supplied attrs": func(c *amd64Ctx) { c.fpSourceSig.Attrs = "nounwind" },
+		"changed frame":          func(c *amd64Ctx) { c.fpScalarSource.FrameSize += 8 },
+		"changed emitter frame":  func(c *amd64Ctx) { c.frameSize += 8 },
+		"changed raw role":       func(c *amd64Ctx) { c.fpScalarSource.Instrs[1].x86Encoded = true },
+		"unknown literal role":   func(c *amd64Ctx) { c.fpScalarSource.Instrs[1].x86SDKLiteral = &x86SDKLiteralCertificate{} },
+		"foreign snapshot binding": func(c *amd64Ctx) {
+			copy, foreign := *snapshot, *snapshot.binding
+			copy.binding = &foreign
+			c.fixedLocalResult = &copy
+		},
+		"foreign snapshot file": func(c *amd64Ctx) {
+			copy := *snapshot
+			copy.file[0] ^= 1
+			c.fixedLocalResult = &copy
+		},
+		"changed complete source": func(c *amd64Ctx) {
+			last := len(c.fpScalarSource.Instrs) - 1
+			c.fpScalarSource.Instrs[last] = Instr{Op: "NOP", Raw: "NOP"}
+		},
+		"missing access": func(c *amd64Ctx) {
+			for index := range c.fpScalarSource.Instrs {
+				if len(c.fpScalarSource.Instrs[index].x86FixedLocalMemory) != 0 {
+					c.fpScalarSource.Instrs[index].x86FixedLocalMemory = nil
+					return
+				}
+			}
+			t.Fatal("actual access missing")
+		},
+		"changed access ordinal": func(c *amd64Ctx) {
+			for index := range c.fpScalarSource.Instrs {
+				ins := &c.fpScalarSource.Instrs[index]
+				if len(ins.x86FixedLocalMemory) != 0 {
+					ins.x86FixedLocalMemory = cloneX86ReplayFixedLocalMemory(ins.x86FixedLocalMemory)
+					for operand, access := range ins.x86FixedLocalMemory {
+						access.ordinal++
+						ins.x86FixedLocalMemory[operand] = access
+						return
+					}
+				}
+			}
+			t.Fatal("actual access missing")
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, scoped := range []bool{false, true} {
+				copy := fn
+				copy.Instrs = append([]Instr(nil), fn.Instrs...)
+				lower := create(copy)
+				if scoped {
+					lower.fixedLocalResult = snapshot
+				}
+				mutate(lower)
+				if err := lower.checkFixedLocalResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed native/source/private role borrowed original result proof", scoped, err)
+				}
+			}
+		})
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("negative consumers changed actual source owner", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := create(fn).checkFixedLocalResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("closed actual frame owner retained result proof", err)
+	}
+}
diff --git a/amd64_fixed_local_runtime_test.go b/amd64_fixed_local_runtime_test.go
new file mode 100644
index 000000000..f02cf83d7
--- /dev/null
+++ b/amd64_fixed_local_runtime_test.go
@@ -0,0 +1,267 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func fixedLocalCompleteFixture(t *testing.T, target string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options, string) {
+	t.Helper()
+	_, request := goAMD64FrameSourceFixture(t)
+	request.Target = target
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package framefixture\n")
+	for index, operation := range fixedLocalNativeOperations {
+		fmt.Fprintf(&declarations, "func Value%d(a, b, c, d uint64) uint64\n", index)
+		source, _, _ := x86PrivateAlignedFrameAuditFixture(t, operation)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	for name, content := range map[string]string{"value.go": declarations.String(), "value_amd64.s": assembly.String()} {
+		if err := os.WriteFile(filepath.Join(request.Directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "value.go", declarations.String(), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("example.invalid/framefixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, name := range typed.Scope().Names() {
+		sig, err := DeriveGoFuncABI0Signature(typed.Path()+"."+name, typed.Scope().Lookup(name).(*types.Func), "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[sig.Name] = sig
+	}
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", typed.Path()+".", 1) }
+	triple := "x86_64-unknown-linux-gnu"
+	if strings.HasPrefix(target, "darwin/") {
+		triple = "x86_64-apple-darwin"
+	}
+	if strings.HasPrefix(target, "windows/") {
+		triple = "x86_64-pc-windows-msvc"
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}, request, file,
+		Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}, declarations.String()
+}
+
+// Integer-only independent expected values; the comparison inputs remain raw
+// IEEE bits, including signed zero, infinities, NaNs and subnormals.
+const fixedLocalGoMath = `
+func equalBits(a,b uint64,bits uint, daz bool) bool {
+ exp,frac,sign:=uint64(0x7ff0000000000000),uint64(0xfffffffffffff),uint64(1)<<63
+ if bits==32 { exp,frac,sign=0x7f800000,0x7fffff,1<<31; a=uint64(uint32(a)); b=uint64(uint32(b)) }
+ if a&exp==exp && a&frac!=0 || b&exp==exp && b&frac!=0 { return false }
+ if daz && a&exp==0 { a &= sign }; if daz && b&exp==0 { b &= sign }
+ return a==b || a&^sign==0 && b&^sign==0
+}
+func expected(op int,a,c uint64) uint64 {
+ if op<4 {
+  width:=uint(8)<<uint(op); var result uint64
+  mask:=^uint64(0); if width<64 { mask=(uint64(1)<<width)-1 }
+  for shift:=uint(0);shift<64;shift+=width { result|=((a>>shift)+(c>>shift))&mask<<shift }
+  return result
+ }
+ if op==4 {
+  var result uint64
+  for shift:=uint(0);shift<64;shift+=32 {
+   x,y:=int64(int16(a>>shift)),int64(int16(a>>(shift+16)))
+   u,v:=int64(int16(c>>shift)),int64(int16(c>>(shift+16)))
+   result|=uint64(uint32(x*u+y*v))<<shift
+  }; return result
+ }
+ if op==5 {
+  var result uint64
+  for shift:=uint(0);shift<64;shift+=32 { if equalBits(a>>shift,c>>shift,32,false) { result|=uint64(0xffffffff)<<shift } }
+  return result
+ }
+ if equalBits(a,c,64,false) { return ^uint64(0) }; return 0
+}
+`
+
+func fixedLocalOriginalGoValues(t *testing.T, request GoAMD64FrameCaptureRequest, declarations string) {
+	t.Helper()
+	dir := t.TempDir()
+	assembly, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var calls strings.Builder
+	for index := range fixedLocalNativeOperations {
+		fmt.Fprintf(&calls, "if got:=Value%d(input.data[0],input.data[1],input.data[2],input.data[3]); got!=expected(%d,input.data[0],input.data[2]) || snapshot(&input)!=before { t.Fatalf(\"original opcode %d seed=%%d got=%%x\",seed,got) }\n", index, index, index)
+	}
+	testSource := `package framefixture
+import "testing"
+type guarded struct { before [4]uint64; data [4]uint64; after [4]uint64 }
+//go:noinline
+func snapshot(p *guarded) guarded { return *p }
+` + fixedLocalGoMath + `
+func TestOriginalLocalNativeValues(t *testing.T) {
+ values:=[]uint64{0,1,^uint64(0),0x8000800080008000,0x7fff7fff7fff7fff,0x3f8000003f800000,0x7fc012347f801234,0x3ff0000000000000,0x8000000000000000,0x123456789abcdef0}
+ for seed:=0;seed<128;seed++ {
+  input:=guarded{before:[4]uint64{11,17,29,53},data:[4]uint64{values[seed%len(values)],values[(seed+1)%len(values)],values[(seed*3)%len(values)],values[(seed*7+1)%len(values)]},after:[4]uint64{0xaabbccdd,0x12345678,0x87654321,^uint64(0)}}
+  before:=snapshot(&input)
+` + calls.String() + `
+ }
+}
+`
+	for name, data := range map[string][]byte{
+		"go.mod": []byte("module example.invalid/framefixture\ngo 1.20\n"), "value.go": []byte(declarations),
+		"value_amd64.s": assembly, "value_test.go": []byte(testSource),
+	} {
+		if strings.HasSuffix(name, ".go") {
+			data, err = format.Source(data)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("safe first-party original Go local-frame math/canaries: %v\n%s", err, output)
+	}
+	t.Log("original Go: 896 actual scalar-ABI calls, integer/IEEE-bit independent expectations and noinline full guarded-memory snapshots; not an external-library runtime witness")
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalNativeBackingMathAndBuffers(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 fixed-local counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang missing")
+	}
+	pkg, request, file, options, declarations := fixedLocalCompleteFixture(t, runtime.GOOS+"/amd64")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, bound)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalOriginalGoValues(t, request, declarations)
+	var declarationsC strings.Builder
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	for index := range fixedLocalNativeOperations {
+		fmt.Fprintf(&declarationsC, "extern uint64_t value%d(uint64_t,uint64_t,uint64_t,uint64_t) __asm__(\"%sexample.invalid/framefixture.Value%d\");\n", index, prefix, index)
+	}
+	main := fixedLocalCOracle(declarationsC.String())
+	var runPrefix []string
+	if crossRosetta {
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "fixed-local-native", options.TargetTriple, ir, main, runPrefix)
+	t.Log("LLVM/C: exact SSE opcode results+complete MXCSR compared for 4 RC ×4 DAZ/FTZ ×3 sticky seeds ×128 inputs ×7 operations; volatile whole input/canary memory reread")
+	if crossRosetta {
+		t.Log("Darwin/Rosetta diagnostic, not native Intel fault/trap proof")
+	}
+}
+
+func fixedLocalCOracle(declarations string) string {
+	var cases, opcodes strings.Builder
+	for index, operation := range fixedLocalNativeOperations {
+		mnemonic := strings.ToLower(strings.Fields(operation)[0])
+		if mnemonic == "paddl" {
+			mnemonic = "paddd"
+		}
+		if mnemonic == "pmaddwl" {
+			mnemonic = "pmaddwd"
+		}
+		immediate := ""
+		if strings.HasPrefix(mnemonic, "cmp") {
+			immediate = "$0, "
+		}
+		fmt.Fprintf(&opcodes, "case %d: __asm__ volatile(\"%s %s%%1,%%0\" : \"+x\"(value) : \"m\"(input) : \"memory\"); break;\n", index, mnemonic, immediate)
+		fmt.Fprintf(&cases, "case %d: got=value%d(data[0],data[1],data[2],data[3]); break;\n", index, index)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <immintrin.h>
+` + declarations + `
+static __attribute__((noinline)) uint64_t readword(const volatile uint64_t *p) { return *p; }
+static __attribute__((noinline)) uint64_t reference(int op,const uint64_t *data) {
+ _Alignas(16) uint64_t input[2]={data[0],data[1]};
+ __m128i value=_mm_set_epi64x((long long)data[3],(long long)data[2]);
+ switch(op) {
+` + opcodes.String() + `
+ }
+ return (uint64_t)_mm_cvtsi128_si64(value);
+}
+int main(void) {
+ const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000800080008000),UINT64_C(0x7fff7fff7fff7fff),UINT64_C(0x3f8000003f800000),UINT64_C(0x7fc012347f801234),UINT64_C(0x3ff0000000000000),UINT64_C(0x8000000000000000),UINT64_C(0x123456789abcdef0)};
+ unsigned saved=_mm_getcsr();
+ /* Controlled first-party storage realizes all four word-aligned source
+    residues. This is an independent exact-SSE witness of the refused alias
+    fragment, not a claim that these are the actual Go runtime entry SPs. */
+ const uint64_t aliasWant[4][2]={{6,10},{7,8},{7,10},{7,10}};
+ for(int residue=0;residue<4;residue++) {
+  _Alignas(32) unsigned char memory[256]={0};
+  unsigned char *sp=memory+32+residue*8;
+  unsigned char *aligned=(unsigned char*)(((uintptr_t)sp&~(uintptr_t)31)+32);
+  uint64_t input[2]={2,3}, other[2]={5,7}, one=1, observed[2];
+  memcpy(aligned+16,input,16); memcpy(aligned+48,other,16);
+  memcpy(sp+48,&one,8);
+  __m128i vector; memcpy(&vector,aligned+48,16);
+  __asm__ volatile("paddq %1,%0" : "+x"(vector) : "m"(*(const unsigned char (*)[16])(aligned+16)) : "memory");
+  memcpy(observed,&vector,16);
+  if(observed[0]!=aliasWant[residue][0] || observed[1]!=aliasWant[residue][1]) return 3;
+ }
+ for(int seed=0;seed<128;seed++) {
+  volatile uint64_t guarded[12]={11,17,29,53,values[seed%10],values[(seed+1)%10],values[(seed*3)%10],values[(seed*7+1)%10],0xaabbccdd,0x12345678,0x87654321,UINT64_MAX};
+  uint64_t data[4],before[12];
+  for(int i=0;i<12;i++) before[i]=readword(&guarded[i]);
+  for(int i=0;i<4;i++) data[i]=readword(&guarded[i+4]);
+  for(int op=0;op<7;op++) for(int rc=0;rc<4;rc++) for(int ctl=0;ctl<4;ctl++) for(int sticky=0;sticky<3;sticky++) {
+   unsigned start=0x1f80u|(unsigned)rc<<13|(ctl&1?0x40u:0)|(ctl&2?0x8000u:0)|(sticky==1?1u:sticky==2?0x3fu:0);
+   _mm_setcsr(start); uint64_t want=reference(op,data); unsigned wantCSR=_mm_getcsr();
+   _mm_setcsr(start); uint64_t got=0;
+   switch(op) {
+` + cases.String() + `
+   }
+   unsigned gotCSR=_mm_getcsr();
+   if(got!=want || gotCSR!=wantCSR) { fprintf(stderr,"op=%d seed=%d RC=%d ctl=%d sticky=%d got=%llx/%x want=%llx/%x\n",op,seed,rc,ctl,sticky,(unsigned long long)got,gotCSR,(unsigned long long)want,wantCSR); return 1; }
+   for(int i=0;i<12;i++) if(readword(&guarded[i])!=before[i]) return 2;
+  }
+ }
+ _mm_setcsr(saved); return 0;
+}
+`
+}
diff --git a/amd64_fixed_local_scalar_lane.go b/amd64_fixed_local_scalar_lane.go
new file mode 100644
index 000000000..e7bcd7aa2
--- /dev/null
+++ b/amd64_fixed_local_scalar_lane.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+// Reuse the complete scalar-lane grammar, including Go's GP-number spellings.
+// This owner binds only low physical X registers and ordinary memory. Logical
+// FP fields and EVEX high banks retain their independent entry contracts.
+func fixedLocalScalarLaneProperties(ins Instr) (x86ScalarLaneForm, bool, error) {
+	form, known, err := x86ScalarLaneProperties(ins, "amd64")
+	if !known {
+		return form, false, nil
+	}
+	valid := err == nil
+	if valid && form.memory >= 0 {
+		kind := ins.Args[form.memory].Kind
+		valid = kind == OpMem || kind == OpSym
+	}
+	if valid {
+		vectors := [2]int{form.source, -1}
+		if form.insert {
+			vectors = [2]int{form.base, form.destination}
+		}
+		for _, index := range vectors {
+			if index >= 0 {
+				register, physical := amd64ParseXReg(ins.Args[index].Reg)
+				valid = valid && physical && register < 16
+			}
+		}
+	}
+	if !valid {
+		return form, true, goAMD64FrameContext("fixed local scalar-lane form lacks a bound physical role: %s", ins.Op)
+	}
+	return form, true, nil
+}
+
+func fixedLocalScalarLaneStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, known, err := fixedLocalScalarLaneProperties(*ins)
+	if !known || err != nil {
+		return known, err
+	}
+	width := int64(form.bits / 8)
+	selected := x86CallerVectorByteMask(width)
+	if form.insert {
+		if form.memory >= 0 {
+			// Scalar m8/m16/m32/m64 accesses stay exact and unaligned. Their
+			// native volatile emitter does not grant future pointee facts.
+			if _, _, err := fixedLocalReadMemory(ins, form.memory, state, proof, residue, width, 1); err != nil {
+				return true, err
+			}
+		} else if !fixedLocalNumericRead(Operand{Kind: OpReg, Reg: form.transferReg}, width, state) {
+			return true, goAMD64FrameContext("fixed local scalar insert reads undefined or address bytes")
+		}
+		base := state.vectors[x86CallerVectorRoot(ins.Args[form.base].Reg)]
+		destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+		state.vectors[destination] = x86ScalarLaneInsertKnown(form, base, selected, state.vectors[destination])
+		return true, nil
+	}
+	source := state.vectors[x86CallerVectorRoot(ins.Args[form.source].Reg)]
+	if source>>uint(form.offset)&selected != selected {
+		return true, goAMD64FrameContext("fixed local scalar extract reads undefined selected bytes")
+	}
+	if form.memory >= 0 {
+		offset, role, err := fixedLocalMemoryAccess(ins, form.memory, state, proof, residue, width, 1, true, false)
+		if err != nil {
+			return true, err
+		}
+		if role == x86FixedLocalPrivateMemory {
+			fixedLocalNumericalStore(state, offset, width, true)
+		}
+		return true, nil
+	}
+	// GP extraction reuses the ordinary dword/qword writer, including zero
+	// extension and revocation of constants, booleans and address identities.
+	effect := x86TypedByteEffect{operands: []x86TypedByteOperand{{
+		index: form.destination, operand: Operand{Kind: OpReg, Reg: form.transferReg},
+		width: int64(form.gpBits / 8), write: true,
+	}}}
+	return true, fixedLocalTypedByteStep(ins, state, FuncSig{}, proof, residue, effect)
+}
diff --git a/amd64_fixed_local_scalar_lane_test.go b/amd64_fixed_local_scalar_lane_test.go
new file mode 100644
index 000000000..bdb37fad4
--- /dev/null
+++ b/amd64_fixed_local_scalar_lane_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalScalarLaneCases() []string {
+	var rows []string
+	for _, prefix := range []string{"", "V"} {
+		for _, suffix := range []string{"B", "W", "D", "Q"} {
+			for _, selector := range []int{0, 255} {
+				for _, transfer := range []string{"AX", "65(BP)", "1(SI)"} {
+					insert := fmt.Sprintf("%sPINSR%s $%d,%s,X1", prefix, suffix, selector, transfer)
+					if prefix != "" {
+						insert += ",X2"
+					}
+					rows = append(rows, insert, fmt.Sprintf("%sPEXTR%s $%d,X1,%s", prefix, suffix, selector, transfer))
+				}
+				if prefix != "" {
+					rows = append(rows, fmt.Sprintf("VPINSR%s $%d,AX,X1,X1", suffix, selector))
+				} else if suffix != "W" {
+					// These Go Ymm spellings encode GP registers, not MMX reads.
+					rows = append(rows, fmt.Sprintf("PINSR%s $%d,M0,X1", suffix, selector),
+						fmt.Sprintf("PEXTR%s $%d,X1,M0", suffix, selector))
+				}
+			}
+			if prefix != "" {
+				rows = append(rows, fmt.Sprintf("VPEXTR%s $-128,X1,AX", suffix), fmt.Sprintf("VPEXTR%s $-1,X1,65(BP)", suffix))
+			}
+			// Only the inserted lane is observed. Unrelated old X7 bytes
+			// remain unknown through lowering as well as the direct proof.
+			partial := fmt.Sprintf("%sPINSR%s $255,AX,X7", prefix, suffix)
+			if prefix != "" {
+				partial += ",X7"
+			}
+			rows = append(rows, partial+fmt.Sprintf("\n%sPEXTR%s $255,X7,AX\nMOVQ AX,128(BP)", prefix, suffix))
+		}
+	}
+	return rows
+}
+
+func TestGoAMD64FixedLocalScalarLaneCompleteFamilies(t *testing.T) {
+	rows := fixedLocalScalarLaneCases()
+	if len(rows) != 132 {
+		t.Fatal("scalar-lane source/selector/alias inventory changed", len(rows))
+	}
+	var original strings.Builder
+	for index, row := range rows {
+		original.WriteString(strings.Replace(fixedLocalVEXAssembly(row), "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, row)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("original Go scalar-lane source lacks fixed-local support", err)
+			}
+			if !strings.Contains(row, "\n") && strings.Contains(row, "(BP)") {
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$256-0\n"+row+"\nRET\n")
+				if err != nil || !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+					t.Fatal("isolated physical scalar-lane access did not request frame capture", err)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalScalarLaneInsertDefinedBytes(t *testing.T) {
+	for _, prefix := range []string{"", "V"} {
+		for size, suffix := range []string{"B", "W", "D", "Q"} {
+			width := 1 << uint(size)
+			for _, destination := range []string{"X1", "X2"} {
+				if prefix == "" && destination != "X1" {
+					continue
+				}
+				t.Run(prefix+suffix+"/"+destination, func(t *testing.T) {
+					for immediate := 0; immediate < 256; immediate++ {
+						row := fmt.Sprintf("%sPINSR%s $%d,AX,X1", prefix, suffix, immediate)
+						if prefix != "" {
+							row += "," + destination
+						}
+						ins := x86ScalarLaneInstruction(t, row)
+						root := x86CallerVectorRoot(Reg(destination))
+						offset := (immediate % (16 / width)) * width
+						selected := (uint64(1)<<uint(width) - 1) << uint(offset)
+						for missing := -1; missing < 8; missing++ {
+							state := x86FixedLocalState{
+								known: map[Reg]uint8{AX: 255}, vectors: map[Reg]uint64{"Z1": 0x1000000000005555, "Z2": 0x200000000000aaaa},
+								flags: x86ByteFlagsAll,
+							}
+							if missing >= 0 {
+								state.known[AX] &^= 1 << uint(missing)
+							}
+							input := state.known[AX]
+							old := state.vectors[root]
+							err := fixedLocalStep(&ins, &state, FuncSig{}, nil, 0)
+							if missing >= 0 && missing < width {
+								if !errors.Is(err, ErrProbeNeedsContext) || state.vectors[root] != old {
+									t.Fatal("undefined GP source acquired vector bytes", row, missing, err)
+								}
+								continue
+							}
+							want := uint64(0x5555)&^selected | selected
+							if prefix == "" {
+								want |= old &^ 0xffff
+							} else {
+								want |= ^uint64(0xffff)
+							}
+							if err != nil || state.vectors[root] != want || state.flags != x86ByteFlagsAll || state.known[AX] != input {
+								t.Fatal("insert lost preserved unknown lanes, upper aliases or FLAGS", row, missing, err, state)
+							}
+							if destination == "X2" && state.vectors["Z1"] != 0x1000000000005555 {
+								t.Fatal("insert changed its separate base register", row)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalScalarLaneExtractSelectedBytes(t *testing.T) {
+	for _, prefix := range []string{"", "V"} {
+		for size, suffix := range []string{"B", "W", "D", "Q"} {
+			width := 1 << uint(size)
+			t.Run(prefix+suffix, func(t *testing.T) {
+				for immediate := 0; immediate < 256; immediate++ {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%sPEXTR%s $%d,X1,AX", prefix, suffix, immediate))
+					offset := (immediate % (16 / width)) * width
+					selected := (uint64(1)<<uint(width) - 1) << uint(offset)
+					for missing := -1; missing < 16; missing++ {
+						state := x86FixedLocalState{
+							known: map[Reg]uint8{}, booleans: map[Reg]uint8{AX: 255}, constants: map[Reg]int64{AX: 42},
+							vectors: map[Reg]uint64{"Z1": selected | 1<<60}, flags: x86ByteFlagsAll,
+						}
+						if missing >= 0 {
+							state.vectors["Z1"] &^= 1 << uint(missing)
+						}
+						before := state.vectors["Z1"]
+						err := fixedLocalStep(&ins, &state, FuncSig{}, nil, 0)
+						if missing >= offset && missing < offset+width {
+							if !errors.Is(err, ErrProbeNeedsContext) || state.known[AX] != 0 {
+								t.Fatal("undefined selected lane acquired GP result", ins, missing, err)
+							}
+							continue
+						}
+						_, constant := state.constants[AX]
+						zeroBytes := uint8(0xf0)
+						if width == 8 {
+							zeroBytes = 0
+						}
+						if err != nil || state.known[AX] != 255 || constant || state.booleans[AX] != zeroBytes || state.vectors["Z1"] != before || state.flags != x86ByteFlagsAll {
+							t.Fatal("extract read unselected bytes or changed unrelated state", ins, missing, err, state)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalScalarLaneExactMemory(t *testing.T) {
+	for _, prefix := range []string{"", "V"} {
+		for size, suffix := range []string{"B", "W", "D", "Q"} {
+			width := 1 << uint(size)
+			for _, insert := range []bool{false, true} {
+				row, memory := prefix+"PEXTR"+suffix+" $255,X1,(BP)", 2
+				if insert {
+					row, memory = prefix+"PINSR"+suffix+" $255,(BP),X1", 1
+					if prefix != "" {
+						row += ",X2"
+					}
+				}
+				t.Run(row, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row)
+					native := x86FixedLocalState{
+						opaque: map[Reg]x86FixedLocalOrigins{BP: fixedLocalOrigin(x86FixedLocalOrigin{})}, vectors: map[Reg]uint64{"Z1": 0xffff},
+						bytes: newFixedLocalByteSet(32), flags: x86ByteFlagsAll,
+					}
+					proof := &x86FixedLocalProof{frame: 32}
+					if err := fixedLocalStep(&ins, &native, FuncSig{}, proof, 0); err != nil {
+						t.Fatal("ordinary native scalar access was rejected", err)
+					}
+					access := ins.x86FixedLocalMemory[memory]
+					if access.owner != proof || access.width != int64(width) || access.write == insert || !access.nativeInput || native.flags != x86ByteFlagsAll {
+						t.Fatal("native scalar role became private extent or wrong width", access)
+					}
+					for index := int64(0); index < 32; index++ {
+						if native.bytes.has(index) {
+							t.Fatal("native access acquired private initialized bytes")
+						}
+					}
+					for _, offset := range []int{1, 32 - width, 33 - width} {
+						for missing := -1; missing < 32; missing++ {
+							ins := x86ScalarLaneInstruction(t, row)
+							state := x86FixedLocalState{
+								pointers: map[Reg]int64{BP: int64(offset)}, vectors: map[Reg]uint64{"Z1": 0xffff},
+								bytes: newFixedLocalByteSet(32), booleanBytes: newFixedLocalByteSet(32), flags: x86ByteFlagsAll,
+							}
+							for index := 0; index < 32; index++ {
+								state.bytes.set(int64(index), index != missing)
+							}
+							proof := &x86FixedLocalProof{frame: 32}
+							err := fixedLocalStep(&ins, &state, FuncSig{}, proof, 0)
+							wantPass := offset+width <= 32 && (!insert || missing < offset || missing >= offset+width)
+							if (err == nil) != wantPass || !wantPass && !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("exact native tuple/initialization mismatch", offset, missing, err)
+							}
+							if wantPass {
+								access := ins.x86FixedLocalMemory[memory]
+								if access.owner != proof || access.width != int64(width) || access.write == insert || access.nativeInput || state.flags != x86ByteFlagsAll {
+									t.Fatal("scalar memory certificate widened or changed FLAGS", access)
+								}
+							}
+							if missing >= 0 && state.bytes.has(int64(missing)) != (wantPass && !insert && missing >= offset && missing < offset+width) {
+								t.Fatal("unrelated private byte initialized", offset, missing, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalScalarLaneBoundaries(t *testing.T) {
+	for _, row := range []string{
+		"PINSRB $0,SI,X1", "PINSRQ $0,BP,X1", "PINSRB $0,R15,X1",
+		"PINSRB $0,(AX),X1", "PINSRQ $0,256(BP),X1", "PEXTRQ $0,X1,256(BP)",
+		"PINSRB $0,a+8(FP),X1", "PEXTRB $0,X1,a+8(FP)", "PEXTRB $0,X1,(AX)",
+		"PEXTRB $0,X7,AX", "PINSRB $0,AX,X7\nPEXTRB $1,X7,AX",
+		"PINSRB $0,AX,X7\nMOVOU X7,128(BP)", "PEXTRQ $0,X1,SP", "PEXTRD $0,X1,BP",
+		"PINSRW $0,M0,X1", "PEXTRW $0,X1,M0", "VPINSRB $0,M0,X1,X2",
+		"VPINSRB $0,AX,X1,X16", "VPEXTRB $0,X16,AX", "VPINSRD $0,AX,X1,K1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			fn, sig, source := fixedLocalVEXFixture(t, row)
+			if row == "PINSRB $0,(AX),X1" || row == "PEXTRB $0,X1,(AX)" {
+				operand, write := 1, false
+				emitted := "load volatile i8"
+				if row == "PEXTRB $0,X1,(AX)" {
+					operand, write = 2, true
+					emitted = "store volatile i8"
+				}
+				fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64) uint64",
+					row, operand, 1, write, emitted)
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound scalar-lane form acquired frame permissions", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalScalarLaneObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	rows := fixedLocalScalarLaneCases()
+	for index, row := range rows {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(row), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64, a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(rows))
+}
diff --git a/amd64_fixed_local_shift_test.go b/amd64_fixed_local_shift_test.go
new file mode 100644
index 000000000..3bf456fd7
--- /dev/null
+++ b/amd64_fixed_local_shift_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func fixedLocalLegacyShiftNames() []string {
+	return strings.Fields("PSLLW PSLLL PSLLQ PSRLW PSRLL PSRLQ PSRAW PSRAL PSLLO PSLLDQ PSRLO PSRLDQ")
+}
+
+func TestGoAMD64FixedLocalShiftOfficialRows(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	uniform := []goasmrules.X86LegacyOperand{
+		{RowIndex: 0, Classes: []string{"Ymm", "Ymr"}, ZCase: "Zm_r_xm", ZOffset: 1, UnmatchedOffset: 0},
+		{RowIndex: 1, Classes: []string{"Yi8", "Ymr"}, ZCase: "Zibo_m_xm", ZOffset: 2, UnmatchedOffset: 1},
+		{RowIndex: 2, Classes: []string{"Yxm", "Yxr"}, ZCase: "Zm_r_xm", ZOffset: 2, UnmatchedOffset: 3},
+		{RowIndex: 3, Classes: []string{"Yi8", "Yxr"}, ZCase: "Zibo_m_xm", ZOffset: 3, UnmatchedOffset: 5},
+	}
+	byteRows := []goasmrules.X86LegacyOperand{
+		{RowIndex: 0, Classes: []string{"Yi8", "Yxr"}, ZCase: "Zibo_m", ZOffset: 2, UnmatchedOffset: 0},
+	}
+	seen := make(map[string]bool)
+	for _, opcode := range catalog.Optab {
+		if !strings.HasPrefix(opcode.Opcode, "PSLL") && !strings.HasPrefix(opcode.Opcode, "PSRL") && !strings.HasPrefix(opcode.Opcode, "PSRA") {
+			continue
+		}
+		want, table, prefix := uniform, "yps", "Py3"
+		if opcode.Opcode == "PSLLO" || opcode.Opcode == "PSRLO" {
+			want, table, prefix = byteRows, "ypsdq", "Pq"
+		}
+		if seen[opcode.Opcode] || opcode.Ytab != table || opcode.Prefix != prefix || !reflect.DeepEqual(opcode.Rows, want) {
+			t.Fatalf("unmodeled original packed-shift rows: %+v", opcode)
+		}
+		seen[opcode.Opcode] = true
+	}
+	if len(seen) != 10 {
+		t.Fatal("original packed-shift denominator changed", len(seen))
+	}
+	for _, pair := range [][2]string{{"PSLLO", "PSLLDQ"}, {"PSRLO", "PSRLDQ"}} {
+		code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", pair[0]+" $7,X1\n"+pair[1]+" $7,X1\nRET")
+		if len(pcs) != 3 || !bytes.Equal(code[pcs[0]:pcs[1]], code[pcs[1]:pcs[2]]) {
+			t.Fatal("Go byte-shift alias no longer selects identical original bytes", pair)
+		}
+	}
+}
+
+func fixedLocalLegacyShiftCases() []string {
+	var operations []string
+	for index, name := range fixedLocalLegacyShiftNames() {
+		for _, count := range []int{-128, 0, 1, 15, 31, 63, 127} {
+			operations = append(operations, fmt.Sprintf("%s $%d,X2", name, count))
+		}
+		if index < 8 {
+			for _, count := range []string{"X1", "X2", "64(BP)", "(SI)"} {
+				operations = append(operations, name+" "+count+",X2")
+			}
+		}
+	}
+	return operations
+}
+
+func TestGoAMD64FixedLocalShiftCompleteFamilies(t *testing.T) {
+	operations := fixedLocalLegacyShiftCases()
+	if len(operations) != 116 {
+		t.Fatal("complete legacy packed-shift inventory changed", len(operations))
+	}
+	var assembly strings.Builder
+	for index, operation := range operations {
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(operation), "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	for _, operation := range operations {
+		t.Run(operation, func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, operation)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("original Go accepted packed-shift source but its frame effect is missing", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalShiftImmediateDomainAndAliases(t *testing.T) {
+	for index, name := range fixedLocalLegacyShiftNames() {
+		t.Run(name, func(t *testing.T) {
+			for count := -128; count <= 127; count++ {
+				ins := x86YMMReadSource(t, fmt.Sprintf("%s $%d,X2", name, count))
+				state := x86FixedLocalState{vectors: map[Reg]uint64{"Z2": 0xffff | uint64(1)<<60, "Z7": 123}, flags: x86ByteFlagsAll}
+				// Oversized logical/byte shifts do not consume data bits.
+				if index != 6 && index != 7 && uint8(count) >= 128 {
+					state.vectors["Z2"] = uint64(1) << 60
+				}
+				if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+					t.Fatal("valid immediate domain or constant-zero result rejected", count, err)
+				}
+				if state.vectors["Z2"] != 0xffff|uint64(1)<<60 || state.vectors["Z7"] != 123 || state.flags != x86ByteFlagsAll {
+					t.Fatal("legacy shift changed upper aliases, unrelated storage or FLAGS", count, state)
+				}
+			}
+			if index >= 8 {
+				return
+			}
+			ins := x86YMMReadSource(t, name+" X1,X2")
+			for _, known := range []uint64{255, 127} {
+				state := x86FixedLocalState{vectors: map[Reg]uint64{"Z1": known, "Z2": 0xffff}}
+				err := fixedLocalVectorStep(&ins, &state, nil, 0)
+				if (err == nil) != (known == 255) {
+					t.Fatal("uniform register count must consume exactly its low qword", known, err)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalShiftGuards(t *testing.T) {
+	for index, name := range fixedLocalLegacyShiftNames() {
+		forms := []string{"$128,X2", "$-129,X2", "$1,Y2", "$1,X16", "$1,M2", "$1,X7"}
+		if index < 8 {
+			forms = append(forms, "X7,X2", "65(BP),X2", "256(BP),X2", "(AX),X2")
+		} else {
+			forms = append(forms, "X1,X2", "64(BP),X2")
+		}
+		for _, args := range forms {
+			t.Run(name+" "+args, func(t *testing.T) {
+				operation := name + " " + args
+				fn, sig, source := fixedLocalVEXFixture(t, operation)
+				if args == "(AX),X2" {
+					mnemonic := strings.ToLower(name)
+					if strings.HasSuffix(mnemonic, "l") {
+						mnemonic = strings.TrimSuffix(mnemonic, "l") + "d"
+					}
+					fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64) uint64",
+						operation, 0, 16, false, mnemonic)
+					return
+				}
+				if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unbound form, memory or register acquired a frame effect", err)
+				}
+			})
+		}
+		if index < 8 {
+			t.Run(name+"/whole-count-memory", func(t *testing.T) {
+				_, sig, source := fixedLocalVEXFixture(t, name+" 64(BP),X2")
+				changed := strings.ReplaceAll(source, "VMOVDQU 64(BP)", "VMOVDQU 128(BP)")
+				if changed == source {
+					t.Fatal("register initialization was not moved away from count memory")
+				}
+				source = strings.Replace(changed, "MOVQ AX,72(BP)\n", "", 1)
+				if source == changed {
+					t.Fatal("upper count qword initialization was not removed")
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("low-qword count replaced the full m128 read", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalShiftVEXSharedDependencies(t *testing.T) {
+	for _, name := range strings.Fields("VPSLLW VPSLLD VPSLLQ VPSRLW VPSRLD VPSRLQ VPSRAW VPSRAD") {
+		for _, bank := range []string{"X", "Y"} {
+			t.Run(name+"/"+bank, func(t *testing.T) {
+				ins := x86YMMReadSource(t, name+" X1,"+bank+"2,"+bank+"3")
+				for _, known := range []uint64{255, 127} {
+					state := x86FixedLocalState{vectors: map[Reg]uint64{"Z1": known, "Z2": ^uint64(0), "Z3": 0}, flags: x86ByteFlagsAll}
+					err := fixedLocalVectorStep(&ins, &state, nil, 0)
+					if (err == nil) != (known == 255) {
+						t.Fatal("VEX count must share the complete low-qword dependency", known, err)
+					}
+					if err == nil && (state.vectors["Z3"] != ^uint64(0) || state.flags != x86ByteFlagsAll) {
+						t.Fatal("VEX shared shift lost upper zeros or FLAGS", state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalShiftObjects(t *testing.T) {
+	operations := fixedLocalLegacyShiftCases()
+	var assembly, declarations strings.Builder
+	for index, operation := range operations {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(operation), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(operations))
+}
diff --git a/amd64_fixed_local_shuffle_test.go b/amd64_fixed_local_shuffle_test.go
new file mode 100644
index 000000000..772cb068d
--- /dev/null
+++ b/amd64_fixed_local_shuffle_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent source names, including Go's separate PSHUFL spelling.
+// The physical MMX-only PSHUFW row is inventoried below, not authorized.
+func fixedLocalShuffleNames() []string {
+	return []string{"PSHUFB", "PSHUFD", "PSHUFL", "PSHUFHW", "PSHUFLW"}
+}
+
+func TestGoAMD64FixedLocalShuffleOfficialRows(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string]string{"PSHUFB": "Zm2_r:Yxm,Yxr", "PSHUFW": "Zibm_r:Yi8,Ymm,Ymr"}
+	for _, name := range fixedLocalShuffleNames()[1:] {
+		wanted[name] = "Zibm_r:Yu8,Yxm,Yxr"
+	}
+	seen := make(map[string]bool)
+	for _, opcode := range catalog.Optab {
+		if !strings.HasPrefix(opcode.Opcode, "PSHUF") {
+			continue
+		}
+		shape, found := wanted[opcode.Opcode]
+		if !found {
+			t.Fatalf("new original legacy shuffle opcode requires an explicit row audit: %+v", opcode)
+		}
+		if seen[opcode.Opcode] || len(opcode.Rows) != 1 ||
+			opcode.Rows[0].ZCase+":"+strings.Join(opcode.Rows[0].Classes, ",") != shape {
+			t.Fatalf("unmodeled original shuffle row: %+v", opcode)
+		}
+		seen[opcode.Opcode] = true
+	}
+	if len(seen) != 6 {
+		t.Fatalf("official shuffle denominator changed: %d, want 5 XMM + 1 MMX", len(seen))
+	}
+}
+
+func fixedLocalShuffleOperation(name, input, immediate string) string {
+	if name == "PSHUFB" {
+		return name + " " + input + ",X0"
+	}
+	return name + " $" + immediate + "," + input + ",X0"
+}
+
+func fixedLocalShuffleFixture(t *testing.T, operation string, oldDestination bool) (string, FuncSig) {
+	t.Helper()
+	source, sig, _ := x86PrivateAlignedFrameAuditFixture(t, "MOVOU 16(SP),X1\n"+operation)
+	if !oldDestination {
+		changed := strings.Replace(source, "MOVOU 48(SP),X0\n", "", 1)
+		if changed == source {
+			t.Fatal("old-destination fixture did not change the source")
+		}
+		source = changed
+	}
+	return source, sig
+}
+
+type fixedLocalShuffleCase struct {
+	operation      string
+	oldDestination bool
+}
+
+func fixedLocalShuffleCases() []fixedLocalShuffleCase {
+	var cases []fixedLocalShuffleCase
+	for _, name := range fixedLocalShuffleNames() {
+		immediates := []string{"0", "1", "27", "228", "255"}
+		if name == "PSHUFB" {
+			immediates = []string{""}
+		}
+		for _, immediate := range immediates {
+			for _, input := range []string{"16(SP)", "X1", "X0"} {
+				operation := fixedLocalShuffleOperation(name, input, immediate)
+				cases = append(cases, fixedLocalShuffleCase{operation, true})
+				if name != "PSHUFB" && input != "X0" {
+					cases = append(cases, fixedLocalShuffleCase{operation, false})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func fixedLocalShuffleProgram(t *testing.T) (string, string, int) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	cases := fixedLocalShuffleCases()
+	for index, row := range cases {
+		source, _ := fixedLocalShuffleFixture(t, row.operation, row.oldDestination)
+		function := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+function, 1))
+		fmt.Fprintf(&declarations, "func %s(a,b,c,d uint64) uint64\n", function)
+	}
+	return assembly.String(), declarations.String(), len(cases)
+}
+
+func TestGoAMD64FixedLocalShuffleCompleteFamilies(t *testing.T) {
+	assembly, _, count := fixedLocalShuffleProgram(t)
+	if count != 103 {
+		t.Fatal("complete shuffle register/memory/immediate/old-destination denominator changed", count)
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	for _, row := range fixedLocalShuffleCases() {
+		t.Run(fmt.Sprintf("%s/old=%t", row.operation, row.oldDestination), func(t *testing.T) {
+			source, sig := fixedLocalShuffleFixture(t, row.operation, row.oldDestination)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proved, err := proveX86FixedLocal(file.Funcs[0], sig)
+			if err != nil {
+				t.Fatal("original Go accepted complete shuffle source but fixed-frame effect is missing", err)
+			}
+			observed := 0
+			for _, ins := range proved.Instrs {
+				if !strings.HasPrefix(row.operation, string(ins.Op)+" ") {
+					continue
+				}
+				observed++
+				index := 1
+				if ins.Op == "PSHUFB" {
+					index = 0
+				}
+				access, found := ins.x86FixedLocalMemory[index]
+				if found != strings.Contains(row.operation, "16(SP)") || found &&
+					(access.width != 16 || access.write || access.nativeInput || access.owner != proved.x86FixedLocal) {
+					t.Fatalf("shuffle changed the exact private source extent or owner: %+v", access)
+				}
+			}
+			if observed != 1 {
+				t.Fatal("complete proof did not retain exactly one original shuffle", observed)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalShuffleImmediateDomainAndAliases(t *testing.T) {
+	for _, name := range fixedLocalShuffleNames() {
+		t.Run(name, func(t *testing.T) {
+			limit := 256
+			if name == "PSHUFB" {
+				limit = 1
+			}
+			for immediate := 0; immediate < limit; immediate++ {
+				operation := fixedLocalShuffleOperation(name, "X1", fmt.Sprint(immediate))
+				ins := x86YMMReadSource(t, operation)
+				for _, upper := range []uint64{0, 0x8040201000000000, ^uint64(0xffff)} {
+					old := upper
+					if name == "PSHUFB" {
+						old |= 0xffff // Byte shuffle reads its old data destination.
+					}
+					state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": old, "Z1": 0xffff}, flags: x86ByteFlagsAll}
+					if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+						t.Fatalf("%s immediate=%d: %v", name, immediate, err)
+					}
+					if state.vectors["Z0"] != upper|0xffff || state.vectors["Z1"] != 0xffff || state.flags != x86ByteFlagsAll {
+						t.Fatalf("%s changed upper aliases, source or FLAGS: %+v", operation, state)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalShuffleSharedMetadata(t *testing.T) {
+	for _, name := range fixedLocalShuffleNames() {
+		ins := x86YMMReadSource(t, fixedLocalShuffleOperation(name, "X1", "0"))
+		effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+		if !known || err != nil || effect.vector.upperWrite != x86TypedVectorUpperPreserve ||
+			effect.vector.memoryAlignment != 16 {
+			t.Fatalf("%s is not described by the common typed family: %+v %v", name, effect, err)
+		}
+		readSource, readDestination, writeDestination := false, false, false
+		for _, operand := range effect.operands {
+			if operand.operand.Kind != OpReg {
+				continue
+			}
+			if operand.width != 16 {
+				t.Fatal("shuffle lost the complete XMM input/output width", name, operand)
+			}
+			switch operand.operand.Reg {
+			case "X1":
+				readSource = readSource || operand.read
+			case "X0":
+				readDestination = readDestination || operand.read
+				writeDestination = writeDestination || operand.write
+			}
+		}
+		if !readSource || !writeDestination || readDestination != (name == "PSHUFB") {
+			t.Fatal("shuffle confused old destination with its sole immediate source", name, effect)
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalShuffleBoundaries(t *testing.T) {
+	for _, name := range fixedLocalShuffleNames() {
+		for _, row := range []struct{ name, input, from, to string }{
+			{"unknown source", "X2", "", ""},
+			{"unknown aliased source", "X0", "MOVOU 48(SP),X0", "MOVOU 48(SP),X2"},
+			{"missing memory byte", "16(SP)", "MOVQ CX,24(SP)", "MOVB CX,24(SP)"},
+			{"unaligned memory", "17(SP)", "", ""},
+			{"outside frame", "160(SP)", "", ""},
+			{"MMX source", "M0", "", ""},
+			{"high bank", "X16", "", ""},
+			{"unknown dynamic control", "X1", "MOVOU 16(SP),X1", "MOVOU 16(SP),X2"},
+		} {
+			t.Run(name+"/"+row.name, func(t *testing.T) {
+				operation := fixedLocalShuffleOperation(name, row.input, "0")
+				source, sig := fixedLocalShuffleFixture(t, operation, true)
+				if row.from != "" {
+					changed := strings.Replace(source, row.from, row.to, 1)
+					if changed == source {
+						t.Fatal("negative fixture did not change the complete source")
+					}
+					source = changed
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unproved shuffle input acquired private frame authority", err)
+				}
+			})
+		}
+	}
+	invalid := []string{"PSHUFW $0,M0,M1", "PSHUFB.Z X1,X0", "PSHUFB $0,X1,X0"}
+	for _, name := range fixedLocalShuffleNames()[1:] {
+		for _, immediate := range []string{"-129", "-128", "-1", "256", "257", "1.0", "missing"} {
+			invalid = append(invalid, fixedLocalShuffleOperation(name, "X1", immediate))
+		}
+	}
+	for _, operation := range invalid {
+		t.Run(operation, func(t *testing.T) {
+			ins := x86YMMReadSource(t, operation)
+			effect, known, err := fixedLocalVectorByteEffect(ins)
+			if known && err == nil {
+				t.Fatalf("non-XMM or invalid immediate/format gained effect: %+v", effect)
+			}
+		})
+	}
+	t.Run("byte shuffle still reads old data", func(t *testing.T) {
+		source, sig := fixedLocalShuffleFixture(t, "PSHUFB X1,X0", false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := proveX86FixedLocal(file.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("PSHUFB acquired numerical data from its initialized control alone", err)
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalShuffleObjects(t *testing.T) {
+	assembly, declarations, count := fixedLocalShuffleProgram(t)
+	if count != 103 {
+		t.Fatal("complete-source shuffle denominator changed", count)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, count)
+}
diff --git a/amd64_fixed_local_snapshot_test.go b/amd64_fixed_local_snapshot_test.go
new file mode 100644
index 000000000..62a3ccece
--- /dev/null
+++ b/amd64_fixed_local_snapshot_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type fixedLocalCountingContext struct {
+	context.Context
+	deadlines  atomic.Int64
+	onDeadline func(int64)
+}
+
+func (ctx *fixedLocalCountingContext) Deadline() (time.Time, bool) {
+	samples := ctx.deadlines.Add(1)
+	if ctx.onDeadline != nil {
+		ctx.onDeadline(samples)
+	}
+	return ctx.Context.Deadline()
+}
+
+func TestGoAMD64FixedLocalSnapshotFinalCallbackMutationRevokes(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalSnapshotFixture(t, 4)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			ctx := &fixedLocalCountingContext{Context: stage}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx.deadlines.Store(0)
+			if err := bound.Sigs[pkg.Path+".Value0"].x86FixedLocal.verify(); err != nil {
+				t.Fatal(err)
+			}
+			perRound := ctx.deadlines.Swap(0)
+			if perRound == 0 {
+				t.Fatal("live source verification omitted its caller lifetime")
+			}
+			mutated := false
+			ctx.onDeadline = func(samples int64) {
+				if samples == 2*perRound {
+					// With a call-local snapshot this is the terminal callback in
+					// module completion, after IR emission and the locked commands.
+					path := filepath.Join(request.Directory, request.AssemblyFile)
+					if err := os.WriteFile(path, []byte("changed original source\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					mutated = true
+				}
+			}
+			fixedLocalAPI(t, pkg, file, bound, api, func(t *testing.T, ir string, err error) {
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("late source mutation returned translated IR: %v", err)
+				}
+			})
+			if !mutated || source.ready {
+				t.Fatal("terminal callback was omitted or its mutated source remained live")
+			}
+		})
+	}
+}
+
+func fixedLocalSnapshotFixture(t *testing.T, functions int) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	for index := 0; index < functions; index++ {
+		fmt.Fprintf(&declarations, "func Value%d(a uint64) uint64\n", index)
+		fmt.Fprintf(&assembly, `TEXT ·Value%d(SB),4,$64-16
+MOVQ a+0(FP),AX
+MOVQ AX,0(SP)
+ADDQ $1,0(SP)
+MOVQ 0(SP),AX
+MOVQ AX,ret+8(FP)
+RET
+`, index)
+	}
+	return fixedLocalTransportFixture(t, assembly.String(), declarations.String(),
+		"linux/amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestGoAMD64FixedLocalSnapshotVerificationDoesNotScaleWithFunctions(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			for _, functions := range []int{1, 4} {
+				t.Run(fmt.Sprint(functions), func(t *testing.T) {
+					pkg, request, file, options := fixedLocalSnapshotFixture(t, functions)
+					source := requireGoAMD64FrameCapture(t, pkg, request)
+					stage, cancel := runtimeOracleStageContext(t)
+					defer cancel()
+					ctx := &fixedLocalCountingContext{Context: stage}
+					bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+					if err != nil {
+						t.Fatal(err)
+					}
+					// Calibrate one real verification round. Only this source owns
+					// the original context; subprocesses use private standard ones.
+					// These samples measure rounds, not elapsed time or tool bytes.
+					ctx.deadlines.Store(0)
+					binding := bound.Sigs[pkg.Path+".Value0"].x86FixedLocal
+					if err := binding.verify(); err != nil {
+						t.Fatal(err)
+					}
+					perRound := ctx.deadlines.Swap(0)
+					if perRound == 0 {
+						t.Fatal("live source verification did not sample its caller lifetime")
+					}
+					started := time.Now()
+					fixedLocalAPI(t, pkg, file, bound, api, func(t *testing.T, ir string, err error) {
+						if err != nil || ir == "" {
+							t.Fatalf("complete fixed-local translation: %v", err)
+						}
+						for index := 0; index < functions; index++ {
+							name := fmt.Sprintf("%s.Value%d", pkg.Path, index)
+							if !strings.Contains(ir, llvmGlobal(name)) {
+								t.Fatalf("translation omitted %s", name)
+							}
+						}
+					})
+					t.Logf("%d functions: API duration %s, %d caller lifetime samples (%d per live verification round)",
+						functions, time.Since(started), ctx.deadlines.Load(), perRound)
+					if samples := ctx.deadlines.Load(); samples != 2*perRound {
+						t.Fatalf("%d functions sampled %d lifetimes, want two live module boundaries (%d samples per round)",
+							functions, samples, perRound)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_state_budget_test.go b/amd64_fixed_local_state_budget_test.go
new file mode 100644
index 000000000..1e597d234
--- /dev/null
+++ b/amd64_fixed_local_state_budget_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalLargeLinearFrameState(t *testing.T) {
+	for _, shape := range []string{"linear", "diamond"} {
+		t.Run(shape, func(t *testing.T) {
+			fn, sig := fixedLocalReplayFixture(t, fixedLocalReplayBody(shape, 1600))
+			fn.FrameSize = 1408
+			if fn.FrameSize*int64(len(fn.Instrs)) <= 1<<20 {
+				t.Fatal("fixture no longer exceeds the old per-instruction state estimate")
+			}
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("long basic blocks must not reserve a frame state per instruction", err)
+			}
+		})
+	}
+}
+
+func fixedLocalRetainedStateBudgetFixture(t *testing.T) (Func, FuncSig) {
+	t.Helper()
+	var body strings.Builder
+	for index := 0; index < 20; index++ {
+		fmt.Fprintf(&body, "CMPQ AX,AX\nJEQ next%d\nNOP\nnext%d:\n", index, index)
+	}
+	fn, sig := fixedLocalReplayFixture(t, body.String())
+	fn.FrameSize = 64 << 10
+	return fn, sig
+}
+
+func TestGoAMD64FixedLocalRetainedStateBudgetIsAtomic(t *testing.T) {
+	fn, sig := fixedLocalRetainedStateBudgetFixture(t)
+	proof := &x86FixedLocalProof{frame: fn.FrameSize}
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, nil)
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "state storage budget") {
+		t.Fatal("actual retained frame states exceeded the storage cap", err)
+	}
+	if budget.steps <= 0 || budget.bytes <= 0 {
+		t.Fatal("fixture must hit retained storage before the independent work budgets")
+	}
+	for _, ins := range fn.Instrs {
+		if len(ins.x86FixedLocalMemory) != 0 {
+			t.Fatal("state-budget failure published a provisional access")
+		}
+	}
+}
diff --git a/amd64_fixed_local_target_test.go b/amd64_fixed_local_target_test.go
new file mode 100644
index 000000000..afb2a4046
--- /dev/null
+++ b/amd64_fixed_local_target_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalDarwinTripleClosure(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	request.Target = "darwin/amd64"
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-apple-macosx"} {
+		t.Run(triple, func(t *testing.T) {
+			options.TargetTriple = triple
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatalf("actual Darwin frame rejected its exact LLVM target spelling: %v", err)
+			}
+			if bound.TargetTriple != triple {
+				t.Fatal("binding rewrote the consumer's actual triple")
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "triple.ll", "triple.o", ir)
+				compileLLVMToObject(t, llc, triple, "triple-opt.ll", "triple-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+			// Equivalent initial target spellings cannot mutate an already
+			// bound consumer. Every certificate still pins its exact options.
+			changed := bound
+			changed.TargetTriple = "x86_64-apple-macosx"
+			if changed.TargetTriple == triple {
+				changed.TargetTriple = "x86_64-apple-darwin"
+			}
+			if _, err := Translate(file, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("retargeted fixed-local certificate survived: %v", err)
+			}
+		})
+	}
+	for _, triple := range []string{
+		"", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+		"arm64-apple-macosx", "i386-apple-macosx", "aarch64-apple-darwin",
+		"x86_64-unknown-macosx", "x86_64-apple-ios", "x86_64-apple-macosx-junk",
+		"x86_64-apple-darwin-junk", "x86_64-apple-macosx11.0.0", "x86_64-apple-darwin20.0.0",
+		"prefix-x86_64-apple-macosx", "x86_64-apple-macosx ",
+	} {
+		t.Run("reject/"+triple, func(t *testing.T) {
+			options.TargetTriple = triple
+			if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("foreign or unregistered triple acquired a Darwin native frame: %q: %v", triple, err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_terminal_native_linux_amd64_test.go b/amd64_fixed_local_terminal_native_linux_amd64_test.go
new file mode 100644
index 000000000..62917d3be
--- /dev/null
+++ b/amd64_fixed_local_terminal_native_linux_amd64_test.go
@@ -0,0 +1,31 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTerminalReturns(t *testing.T) {
+	assembly, declarations := fixedLocalTerminalReturnProgram()
+	inputs := []uint64{0, 1, 2, ^uint64(0)}
+	var expected [][]string
+	for range inputs {
+		expected = append(expected, []string{"0000000000000007", "0000000000000007"})
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+	t.Log("native terminal inventory: functions=2 inputs=4 observations_per_program=8 APIs=3 optimizations=2 execute=true")
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalLayoutPartitions(t *testing.T) {
+	assembly, declarations := fixedLocalLayoutPartitionProgram()
+	inputs := []uint64{0, 1, 2, 3, 4, 9, 16}
+	var expected [][]string
+	for _, input := range inputs {
+		value := fmt.Sprintf("%016x", input+1)
+		expected = append(expected, []string{value, value, value})
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+	t.Log("native private-layout inventory: functions=3 inputs=7 observations_per_program=21 APIs=3 optimizations=2 execute=true")
+}
diff --git a/amd64_fixed_local_transport.go b/amd64_fixed_local_transport.go
new file mode 100644
index 000000000..c170dcb58
--- /dev/null
+++ b/amd64_fixed_local_transport.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+// Opaque inputs identify ABI0 pointer components, not pointee allocations.
+// They may be copied through full-width GP/local cells and pointer results.
+// They never enter the private-SP address map or numerical initialized bytes.
+// Boolean masks independently record bytes whose values are exactly zero/one.
+// This is needed because an ABI0 bool occupies one byte, but LLVM uses i1.
+func fixedLocalTransportRole(role goAMD64FrameTransport) bool {
+	return role == goAMD64FrameNumericTransport || role == goAMD64FrameCompositeTransport
+}
+
+func fixedLocalTransportSlot(offset, width int64, slots []FrameSlot) (FrameSlot, int, bool) {
+	for index, slot := range slots {
+		switch slot.Type {
+		case I1, I8, I16, I32, I64, Ptr:
+		default:
+			continue
+		}
+		if slot.Offset == offset && frameTypeSize(slot.Type, 8) == width {
+			return slot, index, true
+		}
+	}
+	return FrameSlot{}, 0, false
+}
+
+func fixedLocalBooleanShift(reg Reg) uint {
+	if _, bits, alias := amd64ByteAlias(reg); alias {
+		return bits / 8
+	}
+	return 0
+}
+
+func fixedLocalConstantBooleans(value int64, width int64) uint8 {
+	var mask uint8
+	for index := int64(0); index < width; index++ {
+		if byte(uint64(value)>>uint(index*8)) <= 1 {
+			mask |= 1 << uint(index)
+		}
+	}
+	return mask
+}
+
+func fixedLocalBooleanRead(operand Operand, width int64, state *x86FixedLocalState) uint8 {
+	if operand.Kind == OpImm {
+		return fixedLocalConstantBooleans(operand.Imm, width)
+	}
+	if operand.Kind == OpReg {
+		root, _ := x86CallerGP(operand.Reg)
+		return state.booleans[root] >> fixedLocalBooleanShift(operand.Reg) & uint8((1<<uint(width))-1)
+	}
+	return 0
+}
+
+func fixedLocalMemoryBooleans(state *x86FixedLocalState, offset, width int64) uint8 {
+	var mask uint8
+	for index := int64(0); index < width; index++ {
+		if state.booleanBytes.has(offset + index) {
+			mask |= 1 << uint(index)
+		}
+	}
+	return mask
+}
+
+func fixedLocalWriteBooleans(state *x86FixedLocalState, reg Reg, width int64, values uint8) {
+	root, _ := x86CallerGP(reg)
+	state.revokeRange(root) // Every GP write, including partial aliases, invalidates its old value.
+	mask := x86CallerByteMask(reg, width)
+	values <<= fixedLocalBooleanShift(reg)
+	if width == 4 {
+		mask, values = 255, values|240 // Architectural zero extension.
+	}
+	state.booleans[root] = state.booleans[root]&^mask | values&mask
+}
+
+func fixedLocalRevokeSpillRoles(state *x86FixedLocalState, offset, width int64) {
+	for start := range state.addresses {
+		if offset < start+8 && start < offset+width {
+			delete(state.addresses, start)
+		}
+	}
+	for start := range state.opaqueCells {
+		if offset < start+8 && start < offset+width {
+			delete(state.opaqueCells, start)
+		}
+	}
+	state.booleanBytes.setRange(offset, width, false)
+}
+
+func fixedLocalConditionalSetStep(ins *Instr, state *x86FixedLocalState, sig FuncSig, proof *x86FixedLocalProof, residue int) (bool, error) {
+	form, known, err := x86ConditionalSetProperties(ins.Op, *ins, "amd64")
+	if !known {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, goAMD64FrameContext("fixed local SETcc lacks initialized flags or typed destination")
+	}
+	needed := x86ByteConditionFlags(form.condition)
+	if err != nil || needed == 0 || state.flags&needed != needed {
+		return fail()
+	}
+	destination := form.destination
+	switch destination.Kind {
+	case OpReg:
+		root, valid := x86CallerGP(destination.Reg)
+		if !valid || root == SP {
+			return fail()
+		}
+		if _, private := state.pointers[root]; private {
+			return fail()
+		}
+		delete(state.opaque, root)
+		delete(state.constants, root)
+		state.known[root] |= x86CallerByteMask(destination.Reg, 1)
+		fixedLocalWriteBooleans(state, destination.Reg, 1, 1)
+	case OpMem:
+		offset, role, err := fixedLocalMemoryAccess(ins, 0, state, proof, residue, 1, 1, true, false)
+		if err != nil {
+			return true, err
+		}
+		if role == x86FixedLocalPrivateMemory {
+			fixedLocalNumericalStore(state, offset, 1, true)
+			state.booleanBytes.set(offset, true)
+		}
+	case OpFP:
+		sp, original := state.pointers[SP]
+		_, index, found := fixedLocalTransportSlot(destination.FPOffset, 1, sig.Frame.Results)
+		if !original || sp != 0 || !found {
+			return fail()
+		}
+		state.results[index] = true
+	default:
+		return fail()
+	}
+	return true, nil
+}
diff --git a/amd64_fixed_local_transport_runtime_test.go b/amd64_fixed_local_transport_runtime_test.go
new file mode 100644
index 000000000..018b029d7
--- /dev/null
+++ b/amd64_fixed_local_transport_runtime_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTransportByteValues(t *testing.T) {
+	t.Setenv("GOCACHE", t.TempDir())
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	declarations := `func Bool(a []byte, p *uint64, b bool, n uint64) bool
+func Pointer(a []byte, p *uint64, b bool, n uint64) *uint64
+func Slice(a []byte, p *uint64, b bool, n uint64) []byte
+`
+	assembly := fixedLocalTransportAssembly("Bool", 49, fixedLocalTransportBoolBody)
+	assembly += fixedLocalTransportAssembly("Pointer", 56, "MOVQ p+24(FP),CX\nMOVQ CX,128(BP)\nMOVQ 128(BP),DX\nMOVQ DX,ret+48(FP)")
+	assembly += fixedLocalTransportAssembly("Slice", 72, "MOVQ a_base+0(FP),CX\nMOVQ a_len+8(FP),DX\nMOVQ a_cap+16(FP),BX\nMOVQ CX,128(BP)\nMOVQ 128(BP),CX\nMOVQ CX,ret_base+48(FP)\nMOVQ DX,ret_len+56(FP)\nMOVQ BX,ret_cap+64(FP)")
+	// Only the unchanged legacy SSE move is executed on the local Rosetta
+	// counterpart. The separate three-OS object matrix covers the Y form.
+	assembly = strings.ReplaceAll(assembly, "VMOVDQA", "MOVOA")
+	assembly = strings.ReplaceAll(assembly, "Y14", "X14")
+	conditions, conditionDeclarations, originalObservers, observerDeclarations, goConditions, llvmConditions, cConditions := fixedLocalTransportConditionOracles()
+	assembly += conditions
+	declarations += conditionDeclarations
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalConversionPrepareToolCache(t, request)
+	goOracle := `package framefixture
+import "testing"
+func TestOriginal(t *testing.T) {
+    checkConditions(t)
+    buffer := [4]byte{0x11,0x22,0x33,0x44}
+    word := uint64(0x123456789abcdef0)
+    for _, a := range [][]byte{nil,buffer[:2],buffer[:4]} {
+        for _, p := range []*uint64{nil,&word} {
+            for _, b := range []bool{false,true} {
+                for _, n := range []uint64{0,1,^uint64(0),0x8000000000000000} {
+                    if Bool(a,p,b,n)!=b || Pointer(a,p,b,n)!=p { t.Fatal("scalar transport") }
+                    s:=Slice(a,p,b,n)
+                    if len(s)!=len(a)||cap(s)!=cap(a) { t.Fatal("slice component") }
+                    if len(a)>0 && &s[0]!=&a[0] { t.Fatal("slice identity") }
+                    if a==nil && s!=nil { t.Fatal("nil identity") }
+                    if buffer!=[4]byte{0x11,0x22,0x33,0x44}||word!=0x123456789abcdef0 { t.Fatal("pointee mutation") }
+                }
+            }
+        }
+    }
+}
+` + goConditions
+	fixedLocalPackedRunOriginal(t, execution, assembly+originalObservers, declarations+observerDeclarations, goOracle, true)
+	// Call the translated aggregate ABI from an exact LLVM wrapper, not a
+	// guessed C struct ABI. C only crosses a scalar wrapper signature.
+	const wrapper = `
+define i32 @transport_probe(ptr %data, i64 %len, i64 %cap, ptr %p, i1 %b, i64 %n) {
+entry:
+  %a0 = insertvalue {ptr,i64,i64} zeroinitializer, ptr %data, 0
+  %a1 = insertvalue {ptr,i64,i64} %a0, i64 %len, 1
+  %a2 = insertvalue {ptr,i64,i64} %a1, i64 %cap, 2
+  %b2 = call i1 @"example.invalid/framefixture.Bool"({ptr,i64,i64} %a2, ptr %p, i1 %b, i64 %n)
+  %p2 = call ptr @"example.invalid/framefixture.Pointer"({ptr,i64,i64} %a2, ptr %p, i1 %b, i64 %n)
+  %s2 = call {ptr,i64,i64} @"example.invalid/framefixture.Slice"({ptr,i64,i64} %a2, ptr %p, i1 %b, i64 %n)
+  %d2 = extractvalue {ptr,i64,i64} %s2, 0
+  %l2 = extractvalue {ptr,i64,i64} %s2, 1
+  %c2 = extractvalue {ptr,i64,i64} %s2, 2
+  %badb = icmp ne i1 %b2, %b
+  %badp = icmp ne ptr %p2, %p
+  %badd = icmp ne ptr %d2, %data
+  %badl = icmp ne i64 %l2, %len
+  %badc = icmp ne i64 %c2, %cap
+  %bad0 = or i1 %badb, %badp
+  %bad1 = or i1 %bad0, %badd
+  %bad2 = or i1 %bad1, %badl
+  %bad3 = or i1 %bad2, %badc
+  %result = zext i1 %bad3 to i32
+  ret i32 %result
+}
+`
+	oracle := `#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+` + cConditions + `
+extern int transport_probe(void *,uint64_t,uint64_t,void *,bool,uint64_t);
+int main(void) {
+    if(check_conditions()) return 3;
+    volatile uint8_t buffer[4]={0x11,0x22,0x33,0x44};
+    volatile uint64_t word=UINT64_C(0x123456789abcdef0);
+    uint64_t inputs[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000)};
+    for(unsigned a=0;a<3;a++) for(unsigned p=0;p<2;p++)
+    for(unsigned b=0;b<2;b++) for(unsigned n=0;n<4;n++) {
+        void *data=a?(void *)buffer:0;
+        uint64_t len=a==1?2:a==2?4:0,cap=a?4:0;
+        if(transport_probe(data,len,cap,p?(void *)&word:0,b,inputs[n])) return 1;
+        if(buffer[0]!=0x11||buffer[1]!=0x22||buffer[2]!=0x33||buffer[3]!=0x44||word!=UINT64_C(0x123456789abcdef0)) return 2;
+    }
+    return 0;
+}
+`
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, optimized := range []bool{false, true} {
+			input, level := ir+wrapper+llvmConditions, "-O0"
+			if optimized {
+				input, level = x86MulDivRoundOptimize(t, input), "-O2"
+			}
+			execution.compileAndRunLLVM(t, fmt.Sprintf("transport-%v", optimized), input, oracle, level)
+		}
+	})
+	t.Log("48 inputs x bool/pointer/slice plus all16 SETcc true/false and original physical bool-byte canaries; LLVM three APIs O0/O2; pointees unchanged")
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		t.Log("Rosetta SSE diagnostic, not native AVX/AVX512 execution")
+	}
+}
+
+func fixedLocalTransportConditionOracles() (string, string, string, string, string, string, string) {
+	var assembly, declarations, observers, observerDeclarations strings.Builder
+	var goRows, llvmRows, cDeclarations, cRows strings.Builder
+	names := strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS")
+	var bodies []string
+	for _, name := range names {
+		bodies = append(bodies, "MOVQ a_len+8(FP),DX\nCMPQ AX,DX\n"+name+" BX\nMOVB BX,ret+48(FP)")
+	}
+	bodies = append(bodies, fixedLocalCanonicalBoolBodies...)
+	bodies = append(bodies, "MOVQ $-1,BX\nMOVB $1,BX\nMOVB BX,ret+48(FP)")
+	for index, body := range bodies {
+		function := fmt.Sprintf("Condition%d", index)
+		kernel := fixedLocalTransportAssembly(function, 49, body)
+		kernel = strings.ReplaceAll(strings.ReplaceAll(kernel, "VMOVDQA", "MOVOA"), "Y14", "X14")
+		assembly.WriteString(kernel)
+		fmt.Fprintf(&declarations, "func %s(%s) bool\n", function, fixedLocalTransportParams)
+		fmt.Fprintf(&observerDeclarations, "func Observe%d(%s) (raw, adjacent, input uint64)\n", index, fixedLocalTransportParams)
+		// Original-only ABI0 adapter. The callee and this NOSPLIT observer
+		// contain no Go calls, allocation or pointee access. It snapshots the
+		// actual output word and neighbors, not a Go-normalized bool value.
+		fmt.Fprintf(&observers, `TEXT ·Observe%d(SB),4,$64-72
+MOVQ a_base+0(FP),AX
+MOVQ AX,0(SP)
+MOVQ a_len+8(FP),AX
+MOVQ AX,8(SP)
+MOVQ a_cap+16(FP),AX
+MOVQ AX,16(SP)
+MOVQ p+24(FP),AX
+MOVQ AX,24(SP)
+MOVB b+32(FP),AX
+MOVB AX,32(SP)
+MOVQ n+40(FP),AX
+MOVQ AX,40(SP)
+MOVQ $0x5a5a5a5a5a5a5a5a,AX
+MOVQ AX,48(SP)
+MOVQ $0x6b6b6b6b6b6b6b6b,AX
+MOVQ AX,56(SP)
+CALL ·%s(SB)
+MOVQ 48(SP),AX
+MOVQ AX,raw+48(FP)
+MOVQ 56(SP),AX
+MOVQ AX,adjacent+56(FP)
+MOVQ 40(SP),AX
+MOVQ AX,input+64(FP)
+RET
+`, index, function)
+		fmt.Fprintf(&goRows, "{Condition%d,Observe%d},\n", index, index)
+		fmt.Fprintf(&llvmRows, `
+define i32 @condition_probe%d(i64 %%n, i64 %%len) {
+  %%a0 = insertvalue {ptr,i64,i64} zeroinitializer, i64 %%len, 1
+  %%a1 = insertvalue {ptr,i64,i64} %%a0, i64 %%len, 2
+  %%flag = trunc i64 %%len to i1
+  %%b = call i1 @"example.invalid/framefixture.%s"({ptr,i64,i64} %%a1, ptr null, i1 %%flag, i64 %%n)
+  %%result = zext i1 %%b to i32
+  ret i32 %%result
+}
+`, index, function)
+		fmt.Fprintf(&cDeclarations, "extern int condition_probe%d(uint64_t,uint64_t);\n", index)
+		fmt.Fprintf(&cRows, "condition_probe%d,", index)
+	}
+	goOracle := `
+func checkConditions(t *testing.T) {
+    rows:=[]struct{
+        call func([]byte,*uint64,bool,uint64) bool
+        observe func([]byte,*uint64,bool,uint64)(uint64,uint64,uint64)
+    }{
+` + goRows.String() + `
+    }
+    inputs:=[]uint64{0,1,2,3,1<<63,(1<<63)-1,^uint64(0)}
+    buffer:=[4]byte{1,2,3,4}
+    for i,row:=range rows {
+        seen:=0
+        for _,a:=range inputs { for b:=uint64(0);b<4;b++ {
+            r:=a-b
+            cf,zf,sf:=a<b,r==0,r>>63!=0
+            of:=(a^b)&(a^r)>>63!=0
+            parity:=byte(r); parity^=parity>>4; parity^=parity>>2; parity^=parity>>1
+            pf:=parity&1==0
+            want:=[]bool{!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf,false,true,true,b&1!=0,a==0,a==0,a==0,true}[i]
+            if row.call(buffer[:b],nil,b&1!=0,a)!=want { t.Fatalf("condition %%d",i) }
+            value:=uint64(0); if want { value=1 }
+            raw,adjacent,input:=row.observe(buffer[:b],nil,b&1!=0,a)
+            if raw!=0x5a5a5a5a5a5a5a00|value||adjacent!=0x6b6b6b6b6b6b6b6b||input!=a { t.Fatalf("physical byte/canary %%d %%x %%x %%x",i,raw,adjacent,input) }
+            seen|=1<<value
+        } }
+        if i<16 && seen!=3 { t.Fatalf("condition %%d lacked both outcomes",i) }
+    }
+}
+`
+	goOracle = strings.ReplaceAll(goOracle, "%%", "%")
+	cOracle := cDeclarations.String() + `
+static int (*condition_probes[])(uint64_t,uint64_t)={` + cRows.String() + `};
+static int check_conditions(void) {
+    const uint64_t inputs[]={0,1,2,3,UINT64_C(0x8000000000000000),UINT64_C(0x7fffffffffffffff),UINT64_MAX};
+    for(unsigned i=0;i<sizeof(condition_probes)/sizeof(condition_probes[0]);i++) {
+        unsigned seen=0;
+        for(unsigned v=0;v<7;v++) for(uint64_t b=0;b<4;b++) {
+            uint64_t a=inputs[v],r=a-b;
+            bool cf=a<b,zf=r==0,sf=r>>63,of=((a^b)&(a^r))>>63;
+            uint8_t parity=r; parity^=parity>>4; parity^=parity>>2; parity^=parity>>1;
+            bool pf=(parity&1)==0;
+            bool want[]={!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf,false,true,true,(b&1)!=0,a==0,a==0,a==0,true};
+            int actual=condition_probes[i](a,b);
+            if(actual!=want[i]) {
+                fprintf(stderr,"condition=%u a=%llx b=%llx actual=%d expected=%d\n",i,(unsigned long long)a,(unsigned long long)b,(int)actual,(int)want[i]);
+                return 1;
+            }
+            seen|=1U<<want[i];
+        }
+        if(i<16 && seen!=3) return 2;
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), observers.String(), observerDeclarations.String(), goOracle, llvmRows.String(), cOracle
+}
diff --git a/amd64_fixed_local_transport_test.go b/amd64_fixed_local_transport_test.go
new file mode 100644
index 000000000..e23c8c4d1
--- /dev/null
+++ b/amd64_fixed_local_transport_test.go
@@ -0,0 +1,321 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func fixedLocalTransportAssembly(name string, args int, body string) string {
+	return fmt.Sprintf(`TEXT ·%s(SB),4,$256-%d
+MOVQ SP,BP
+ADDQ $64,BP
+ANDQ $-64,BP
+MOVQ n+40(FP),AX
+MOVQ AX,64(BP)
+MOVQ AX,72(BP)
+MOVQ AX,80(BP)
+MOVQ AX,88(BP)
+VMOVDQA 64(BP),Y14
+VMOVDQA Y14,96(BP)
+%s
+RET
+`, name, args, body)
+}
+
+func fixedLocalTransportFixture(t *testing.T, assembly, declarations, target, triple string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	pkg, request := goAMD64FrameTypedFixture(t, declarations, assembly)
+	request.Target = target
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, name := range pkg.Types.Scope().Names() {
+		function, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			continue
+		}
+		sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, function, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[sig.Name] = sig
+	}
+	return pkg, request, file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) }}
+}
+
+const fixedLocalTransportParams = "a []byte, p *uint64, b bool, n uint64"
+
+const fixedLocalTransportBoolBody = `MOVQ a_base+0(FP),CX
+MOVQ CX,128(BP)
+MOVQ 128(BP),DX
+MOVQ p+24(FP),R8
+MOVB b+32(FP),BX
+MOVB BX,160(BP)
+MOVB 160(BP),BX
+MOVB BX,ret+48(FP)`
+
+func TestGoAMD64FixedLocalTransportActualObjects(t *testing.T) {
+	t.Setenv("GOCACHE", t.TempDir())
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	var assembly, declarations strings.Builder
+	cases := []struct {
+		result string
+		args   int
+		body   string
+	}{
+		{"bool", 49, fixedLocalTransportBoolBody},
+		{"bool", 49, strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8",
+			"CMPQ AX,$0\nJE join\nMOVQ p+24(FP),DX\njoin:\nMOVQ (DX),AX", 1)},
+		{"*uint64", 56, "MOVQ p+24(FP),CX\nMOVQ CX,128(BP)\nMOVQ 128(BP),DX\nMOVQ DX,ret+48(FP)"},
+		{"[]byte", 72, "MOVQ a_base+0(FP),CX\nMOVQ a_len+8(FP),DX\nMOVQ a_cap+16(FP),BX\nMOVQ CX,128(BP)\nMOVQ 128(BP),CX\nMOVQ CX,ret_base+48(FP)\nMOVQ DX,ret_len+56(FP)\nMOVQ BX,ret_cap+64(FP)"},
+		{"(r []byte, ok bool)", 73, "MOVQ a_base+0(FP),CX\nMOVQ a_len+8(FP),DX\nMOVQ a_cap+16(FP),BX\nMOVQ CX,r_base+48(FP)\nMOVQ DX,r_len+56(FP)\nMOVQ BX,r_cap+64(FP)\nMOVB b+32(FP),CX\nMOVB CX,ok+72(FP)"},
+		{"", 48, "MOVQ a_base+0(FP),CX\nMOVQ CX,128(BP)\nMOVQ 128(BP),CX\nMOVQ p+24(FP),R8"},
+	}
+	for _, condition := range strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS") {
+		cases = append(cases, struct {
+			result string
+			args   int
+			body   string
+		}{"bool", 49, "CMPQ AX,$0\n" + condition + " BX\nMOVB BX,ret+48(FP)"})
+	}
+	for _, body := range fixedLocalCanonicalBoolBodies {
+		cases = append(cases, struct {
+			result string
+			args   int
+			body   string
+		}{"bool", 49, body})
+	}
+	args := make([]int, len(cases))
+	for i, test := range cases {
+		args[i] = test.args
+		name := fmt.Sprintf("Value%d", i)
+		assembly.WriteString(fixedLocalTransportAssembly(name, test.args, test.body))
+		fmt.Fprintf(&declarations, "func %s(%s) %s\n", name, fixedLocalTransportParams, test.result)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+		{"windows/amd64", "x86_64-w64-windows-gnu"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			fixedLocalConversionPrepareToolCache(t, request)
+			fixedLocalTransportRequireOriginalFrames(t, pkg, request, args)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil || strings.Count(ir, "%fixed_local_native = alloca") != len(cases) {
+					t.Fatal("typed transport lost original private-frame proof", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "transport.ll", "transport.o", ir)
+				compileLLVMToObject(t, llc, target.triple, "transport-opt.ll", "transport-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+		})
+	}
+}
+
+// The original physical frame certificate is an independent prior. Close it
+// before any API starts; it cannot supply or extend a consumer's binding.
+func fixedLocalTransportRequireOriginalFrames(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest, args []int) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	if len(source.functions) != len(args) {
+		t.Fatal("missing complete original object functions")
+	}
+	for i, want := range args {
+		observed := source.functions[fmt.Sprintf("%s.Value%d", pkg.Path, i)]
+		if observed.args != int64(want) || observed.locals != 264 || len(observed.code) == 0 {
+			t.Fatalf("actual Go ABI0 frame differs: %+v", observed)
+		}
+		wantOffsets := []int64{0, 8, 16, 24, 32, 40}
+		if len(observed.signature.Frame.Params) != len(wantOffsets) {
+			t.Fatal("slice ABI0 component inventory changed")
+		}
+		for j, slot := range observed.signature.Frame.Params {
+			if slot.Offset != wantOffsets[j] {
+				t.Fatal("actual component offset differs", slot)
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalTransportAuthorityNegatives(t *testing.T) {
+	base := fixedLocalTransportAssembly("Value", 49, fixedLocalTransportBoolBody)
+	declaration := "func Value(" + fixedLocalTransportParams + ") bool"
+	t.Run("incoming arithmetic", func(t *testing.T) {
+		body := strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "ADDQ CX,DX", 1)
+		assembly := strings.Replace(base, fixedLocalTransportBoolBody, body, 1)
+		pkg, _, file, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", "x86_64-unknown-linux-gnu")
+		if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+			t.Fatal("unused native-address arithmetic changed canonical bool transport", err)
+		}
+	})
+	for name, body := range map[string]string{
+		"undefined incoming index": strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "MOVQ (DX)(R9*2),AX", 1),
+		"incoming comparison":      strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "CMPQ DX,R8", 1),
+		"incoming mask":            strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "KMOVQ DX,K1", 1),
+		"incoming partial":         strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", "MOVL 128(BP),DX", 1),
+		"incoming numeric spill":   strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "VMOVDQA 128(BP),Y0", 1),
+		"bool noncanonical":        strings.Replace(fixedLocalTransportBoolBody, "MOVB BX,ret+48(FP)", "MOVB $2,BX\nMOVB BX,ret+48(FP)", 1),
+		"bool unknown":             strings.Replace(fixedLocalTransportBoolBody, "MOVB BX,ret+48(FP)", "MOVB AX,ret+48(FP)", 1),
+		"bool wide FP":             strings.Replace(fixedLocalTransportBoolBody, "MOVB b+32(FP),BX", "MOVQ b+32(FP),BX", 1),
+		"missing result":           strings.Replace(fixedLocalTransportBoolBody, "MOVB BX,ret+48(FP)", "", 1),
+		"private pointer result":   "MOVQ BP,ret+48(FP)",
+		"false SET flags":          "SETEQ BX\nMOVB BX,ret+48(FP)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(base, fixedLocalTransportBoolBody, body, 1)
+			pkg, _, file, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", "x86_64-unknown-linux-gnu")
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("typed transport granted unproved numerical/memory/result authority", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTransportPartialWritesAndJoins(t *testing.T) {
+	base := fixedLocalTransportAssembly("Value", 49, fixedLocalTransportBoolBody)
+	declaration := "func Value(" + fixedLocalTransportParams + ") bool"
+	cases := map[string]string{
+		"opaque integer result": "MOVQ a_base+0(FP),CX\nMOVQ CX,ret+48(FP)",
+		"opaque SP replacement": strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", "MOVQ 128(BP),SP", 1),
+		"opaque BP replacement": strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", "MOVQ 128(BP),BP", 1),
+		"opaque narrow GP":      strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", "MOVQ 128(BP),DX\nMOVB DX,AX", 1),
+		"pointer and NUM join":  strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", "CMPQ AX,$0\nJE join\nMOVQ AX,DX\njoin:\nMOVQ (DX),AX", 1),
+		"bool lost in CMOV":     strings.Replace(fixedLocalTransportBoolBody, "MOVB BX,ret+48(FP)", "MOVQ $0,BX\nCMPQ AX,$0\nCMOVQEQ AX,BX\nMOVB BX,ret+48(FP)", 1),
+		"bool unknown join":     strings.Replace(fixedLocalTransportBoolBody, "MOVB BX,ret+48(FP)", "CMPQ AX,$0\nJE join\nMOVB AX,BX\njoin:\nMOVB BX,ret+48(FP)", 1),
+	}
+	for index := 0; index < 8; index++ {
+		cases[fmt.Sprintf("opaque spill byte %d", index)] = strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", fmt.Sprintf("MOVB $0,%d(BP)\nMOVQ 128(BP),DX", 128+index), 1)
+	}
+	for _, mask := range []string{"KMOVQ AX,K1", "MOVQ $0,R9\nKMOVQ R9,K1"} {
+		cases["masked opaque spill/"+mask] = strings.Replace(fixedLocalTransportBoolBody, "MOVQ 128(BP),DX", mask+"\nVMOVDQU8 Y14,K1,128(BP)\nMOVQ 128(BP),DX", 1)
+	}
+	for name, body := range cases {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(base, fixedLocalTransportBoolBody, body, 1)
+			decl := declaration
+			if name == "opaque integer result" {
+				decl = "func Value(" + fixedLocalTransportParams + ") uint64"
+				assembly = strings.Replace(assembly, "$256-49", "$256-56", 1)
+			}
+			pkg, _, file, options := fixedLocalTransportFixture(t, assembly, decl, "linux/amd64", "x86_64-unknown-linux-gnu")
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("overwritten or conflicting typed transport survived", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTransportDerivedAndUnusedPointers(t *testing.T) {
+	// These sources used to be negative fixtures before affine inputs and
+	// unused differing-origin joins were supported. Retain their exact bodies
+	// as positive controls; the negative siblings now consume a real missing
+	// NUM operand, unknown comparison input or unresolved pointer identity.
+	for name, replacement := range map[string]string{
+		"incoming numerical index": "MOVQ (DX)(AX*2),AX",
+		"incoming arithmetic":      "ADDQ $8,DX",
+		"incoming comparison":      "CMPQ DX,$0",
+		"unused pointer join":      "CMPQ AX,$0\nJE join\nMOVQ p+24(FP),DX\njoin:",
+		"different pointer join":   "CMPQ AX,$0\nJE join\nMOVQ p+24(FP),DX\njoin:\nMOVQ (DX),AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			body := strings.Replace(fixedLocalTransportBoolBody, "MOVQ p+24(FP),R8", replacement, 1)
+			assembly := fixedLocalTransportAssembly("Value", 49, body)
+			declaration := "func Value(" + fixedLocalTransportParams + ") bool"
+			pkg, _, file, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", "x86_64-unknown-linux-gnu")
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+				t.Fatal("safe derived or unused pointer source regressed", err)
+			}
+		})
+	}
+}
+
+var fixedLocalCanonicalBoolBodies = []string{
+	"MOVB $0,ret+48(FP)", "MOVB $1,ret+48(FP)",
+	"MOVW $256,AX\nMOVB AH,ret+48(FP)",
+	"MOVB b+32(FP),AH\nMOVB AH,160(BP)\nMOVB 160(BP),AL\nMOVB AL,ret+48(FP)",
+	"MOVQ $0,BX\nMOVQ $1,DX\nCMPQ AX,$0\nCMOVQEQ DX,BX\nMOVB BX,ret+48(FP)",
+	"CMPQ AX,$0\nSETEQ 160(BP)\nMOVB 160(BP),BX\nMOVB BX,ret+48(FP)",
+	"CMPQ AX,$0\nSETEQ ret+48(FP)",
+}
+
+func TestGoAMD64FixedLocalTransportCanonicalBoolBytes(t *testing.T) {
+	for _, body := range fixedLocalCanonicalBoolBodies {
+		t.Run(body, func(t *testing.T) {
+			assembly := fixedLocalTransportAssembly("Value", 49, body)
+			pkg, _, file, options := fixedLocalTransportFixture(t, assembly, "func Value("+fixedLocalTransportParams+") bool", "linux/amd64", "x86_64-unknown-linux-gnu")
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); err != nil {
+				t.Fatal("canonical physical bool byte was lost", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTransportLanguageAndLifetime(t *testing.T) {
+	for _, declaration := range []string{
+		"func Value(a []bool, p *bool, b bool, n uint64) bool",
+		"func Value(a []int8, p *int8, b bool, n uint64) bool",
+		"func Value(a []uint16, p *[4]uint16, b bool, n uint64) bool",
+		"func Value(a []*uint64, p **uint64, b bool, n uint64) bool",
+		"type B bool\ntype S []bool\ntype P *[2]bool\nfunc Value(a S, p P, b B, n uint64) B",
+		"type B = bool\ntype S = []byte\ntype P = *[2]bool\nfunc Value(a S, p P, b B, n uint64) B",
+		"type Packet struct { B bool; N uint64; Tail [0]byte }\nfunc Value(a []Packet, p *Packet, b bool, n uint64) bool",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			assembly := fixedLocalTransportAssembly("Value", 49, fixedLocalTransportBoolBody)
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declaration, "linux/amd64", "x86_64-unknown-linux-gnu")
+			owner := requireGoAMD64FrameCapture(t, pkg, request)
+			if !errors.Is(owner.numericDeclarations(pkg), ErrProbeNeedsContext) {
+				t.Fatal("opaque observation was relabeled as a numeric declaration")
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := owner.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("complete named/alias/element language identity was lost", err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "fixed_local_native") {
+					t.Fatal("opaque language contract did not reach complete consumer", err)
+				}
+			})
+			if err := owner.Close(); err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTransportEveryResultComponent(t *testing.T) {
+	const body = "MOVQ a_base+0(FP),CX\nMOVQ a_len+8(FP),DX\nMOVQ a_cap+16(FP),BX\nMOVQ CX,r_base+48(FP)\nMOVQ DX,r_len+56(FP)\nMOVQ BX,r_cap+64(FP)\nMOVB b+32(FP),CX\nMOVB CX,ok+72(FP)"
+	for _, missing := range []string{"MOVQ CX,r_base+48(FP)", "MOVQ DX,r_len+56(FP)", "MOVQ BX,r_cap+64(FP)", "MOVB CX,ok+72(FP)"} {
+		t.Run(missing, func(t *testing.T) {
+			assembly := fixedLocalTransportAssembly("Value", 73, strings.Replace(body, missing, "", 1))
+			pkg, _, file, options := fixedLocalTransportFixture(t, assembly, "func Value("+fixedLocalTransportParams+") (r []byte, ok bool)", "linux/amd64", "x86_64-unknown-linux-gnu")
+			if _, err := proveX86FixedLocal(file.Funcs[0], options.Sigs[pkg.Path+".Value"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("missing result component acquired initialized aggregate", err)
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_typed_fp_test.go b/amd64_fixed_local_typed_fp_test.go
new file mode 100644
index 000000000..42dd25d53
--- /dev/null
+++ b/amd64_fixed_local_typed_fp_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixedLocalTypedFPCase struct {
+	typ, operation string
+}
+
+// Independent source families and legal memory-read positions from Go's
+// yaddl/ycmpl/ytestl/yml_rl, ymovbe, yimul and VEX GP tables. The production
+// effect registry must not decide this input inventory.
+func fixedLocalTypedFPCases() []fixedLocalTypedFPCase {
+	var rows []fixedLocalTypedFPCase
+	for _, width := range []struct{ suffix, typ string }{
+		{"B", "uint8"}, {"W", "uint16"}, {"L", "uint32"}, {"Q", "uint64"},
+	} {
+		add := func(operation string) {
+			rows = append(rows, fixedLocalTypedFPCase{width.typ, operation})
+		}
+		for _, stem := range []string{"ADD", "ADC", "SUB", "SBB", "AND", "OR", "XOR"} {
+			add(stem + width.suffix + " x+0(FP),AX")
+		}
+		for _, operands := range []string{"x+0(FP),AX", "AX,x+0(FP)", "x+0(FP),$1"} {
+			add("CMP" + width.suffix + " " + operands)
+		}
+		for _, operands := range []string{"x+0(FP),AX", "AX,x+0(FP)", "$1,x+0(FP)"} {
+			add("TEST" + width.suffix + " " + operands)
+		}
+		for _, stem := range []string{"MUL", "IMUL"} {
+			add(stem + width.suffix + " x+0(FP)")
+		}
+		if width.suffix != "B" {
+			add("IMUL" + width.suffix + " x+0(FP),AX")
+			add("IMUL3" + width.suffix + " $3,x+0(FP),AX")
+			for _, stem := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+				add(stem + width.suffix + " x+0(FP),AX")
+			}
+			add("MOVBE" + width.suffix + " x+0(FP),AX")
+			add("MOVBE" + width.suffix + width.suffix + " x+0(FP),AX")
+			add("BT" + width.suffix + " $1,x+0(FP)")
+			for _, condition := range []string{
+				"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS",
+				"LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS",
+			} {
+				add("CMOV" + width.suffix + condition + " x+0(FP),AX")
+			}
+		}
+		if width.suffix == "L" || width.suffix == "Q" {
+			for _, stem := range []string{"ADCX", "ADOX", "BLSI", "BLSMSK", "BLSR"} {
+				add(stem + width.suffix + " x+0(FP),AX")
+			}
+			for _, stem := range []string{"ANDN", "PDEP", "PEXT", "MULX"} {
+				add(stem + width.suffix + " x+0(FP),CX,AX")
+			}
+			for _, stem := range []string{"BEXTR", "BZHI", "SHLX", "SHRX", "SARX"} {
+				add(stem + width.suffix + " CX,x+0(FP),AX")
+			}
+			add("RORX" + width.suffix + " $3,x+0(FP),AX")
+		}
+	}
+	for _, extension := range []struct{ typ, sizes string }{
+		{"uint8", "BW"}, {"uint8", "BL"}, {"uint8", "BQ"},
+		{"uint16", "WL"}, {"uint16", "WQ"}, {"uint32", "LQ"},
+	} {
+		for _, kind := range []string{"SX", "ZX"} {
+			rows = append(rows, fixedLocalTypedFPCase{extension.typ,
+				"MOV" + extension.sizes + kind + " x+0(FP),AX"})
+		}
+	}
+	return rows
+}
+
+func fixedLocalTypedFPFixture(t *testing.T, typ, body string) (Func, FuncSig, string) {
+	t.Helper()
+	_, _, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x "+typ+") uint64",
+		"MOVQ $0x123456789abcdef,AX\nMOVQ $3,CX\nMOVQ $7,DX\nMOVQ AX,0(SP)\n"+
+			body+"\nMOVQ AX,ret+8(FP)\nRET")
+	source = strings.Replace(source, "$0-16", "$64-16", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestGoAMD64FixedLocalTypedFPReads(t *testing.T) {
+	rows := fixedLocalTypedFPCases()
+	if len(rows) != 174 {
+		t.Fatal("independent typed GP FP-read inventory changed", len(rows))
+	}
+	var assembly strings.Builder
+	for index, row := range rows {
+		fn, sig, source := fixedLocalTypedFPFixture(t, row.typ, "CMPQ AX,AX\n"+row.operation)
+		assembly.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		t.Run(row.operation, func(t *testing.T) {
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("complete numerical FP input was rejected", err)
+			}
+		})
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+}
+
+func TestGoAMD64FixedLocalTypedFPBoundaries(t *testing.T) {
+	t.Run("pointer machine bits multiply", func(t *testing.T) {
+		fn, sig, _ := fixedLocalTypedFPFixture(t, "*uint64", "MULQ x+0(FP)")
+		if _, err := proveX86FixedLocal(fn, sig); err != nil {
+			t.Fatal("complete typed pointer machine multiply rejected", err)
+		}
+	})
+	for _, row := range []struct {
+		name, typ, body string
+	}{
+		{"pointer is not NUM", "*uint64", "ADDQ x+0(FP),AX"},
+		{"pointer is not conditional NUM", "*uint64", "CMPQ AX,AX\nCMOVQEQ x+0(FP),AX"},
+		{"partial pointer", "*uint64", "ADDL x+0(FP),AX"},
+		{"partial numerical slot", "uint64", "ADDL x+0(FP),AX"},
+		{"interior numerical slot", "uint64", "ADDL x+4(FP),AX"},
+		{"cross parameter boundary", "uint64", "ADDQ x+1(FP),AX"},
+		{"narrow parameter overread", "uint32", "ADDQ x+0(FP),AX"},
+		{"padding", "uint8", "ADDB x+1(FP),AX"},
+		{"negative slot", "uint64", "ADDQ x-8(FP),AX"},
+		{"unwritten result is not input", "uint64", "ADDQ ret+8(FP),AX"},
+		{"result transport is not input", "uint64", "MOVQ AX,ret+8(FP)\nADDQ ret+8(FP),AX"},
+		{"parameter RMW is not import", "uint64", "ADDQ AX,x+0(FP)"},
+		{"parameter unary write", "uint64", "INCQ x+0(FP)"},
+		{"result RMW is not import", "uint64", "ADDQ AX,ret+8(FP)"},
+		{"bit write is not import", "uint64", "BTSQ $1,x+0(FP)"},
+		{"missing carry", "uint64", "ADCQ x+0(FP),AX"},
+		{"missing conditional flags", "uint64", "CMOVQEQ x+0(FP),AX"},
+		{"undefined register input", "uint64", "ADDQ x+0(FP),R12"},
+		{"private destination is not NUM", "uint64", "LEAQ 8(SP),AX\nADDQ x+0(FP),AX"},
+		{"changed SP cannot import FP", "uint64", "ADDQ $8,SP\nADDQ x+0(FP),AX\nADDQ $-8,SP"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, _ := fixedLocalTypedFPFixture(t, row.typ, row.body)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("FP read acquired unrelated bytes or write permission", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedFPLogicalInputs(t *testing.T) {
+	for _, row := range []struct{ declaration, body string }{
+		{"func Value(x bool) uint64", "MOVQ $0,AX\nTESTB $1,x+0(FP)\nSETNE AL\nMOVQ AX,ret+8(FP)\nRET"},
+		{"func Value(prefix uint64,x []byte) uint64", "MOVQ prefix+0(FP),AX\nADDQ x_len+16(FP),AX\nADCQ x_cap+24(FP),AX\nMOVQ AX,ret+32(FP)\nRET"},
+	} {
+		t.Run(row.declaration, func(t *testing.T) {
+			_, _, sig, source := x86ResultInitializationFixture(t, "amd64", row.declaration, row.body)
+			source = strings.Replace(source, "$0-", "$64-", 1)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			if _, err := proveX86FixedLocal(file.Funcs[0], sig); err != nil {
+				t.Fatal("logical numeric component lost its declared FP input", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedFPCompleteObjects(t *testing.T) {
+	rows := fixedLocalTypedFPCases()
+	var assembly, declarations strings.Builder
+	for index, row := range rows {
+		_, _, source := fixedLocalTypedFPFixture(t, row.typ, "CMPQ AX,AX\n"+row.operation)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(x %s) uint64\n", name, row.typ)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(rows))
+}
diff --git a/amd64_fixed_local_typed_role_test.go b/amd64_fixed_local_typed_role_test.go
new file mode 100644
index 000000000..cfdf4596b
--- /dev/null
+++ b/amd64_fixed_local_typed_role_test.go
@@ -0,0 +1,262 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalTypedRoleNumericActualWitness(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	name := pkg.Path + ".Value"
+	observed, declaration := source.functions[name], source.declarations[name]
+	if observed.transport != goAMD64FrameNumericTransport || declaration.transport != goAMD64FrameNumericTransport ||
+		observed.languageType == "" || observed.languageType != declaration.languageType {
+		t.Fatal("actual numeric object has no matching complete language witness")
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+		if err != nil || !strings.Contains(ir, "fixed_local_native") {
+			t.Fatalf("actual numeric witness did not reach its existing private consumer: %v", err)
+		}
+	})
+}
+
+func TestGoAMD64FixedLocalTypedRoleCompositeObservationsNeedCompleteBinding(t *testing.T) {
+	for _, test := range []struct {
+		name, declaration string
+		args, n, result   int64
+	}{
+		{"pointer", "func Value(a *uint64, n uint64) uint64", 24, 8, 16},
+		{"slice", "func Value(a []byte, n uint64) uint64", 40, 24, 32},
+		{"pointer to array", "func Value(a *[64]byte, n uint64) uint64", 24, 8, 16},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			// This complete object reads only the numeric parameter. Its
+			// pointer/slice ABI slots are observations, not input permissions.
+			assembly := fmt.Sprintf("TEXT ·Value(SB),4,$160-%d\nMOVQ n+%d(FP),AX\nMOVQ AX,ret+%d(FP)\nRET\n", test.args, test.n, test.result)
+			pkg, request := goAMD64FrameTypedFixture(t, test.declaration, assembly)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			observed := source.functions[pkg.Path+".Value"]
+			if observed.transport != goAMD64FrameCompositeTransport || observed.languageType == "" || len(observed.code) == 0 {
+				t.Fatal("actual composite object was not captured as observation-only")
+			}
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig, err := DeriveGoFuncABI0Signature(pkg.Path+".Value", pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{sig.Name: sig},
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil || len(bound.Sigs) != 1 {
+				t.Fatalf("complete original composite source lacked its independent local proof: %v", err)
+			}
+			t.Logf("complete binding retained opaque transport: transport=%d args=%d locals=%d code_bytes=%d", observed.transport, observed.args, observed.locals, len(observed.code))
+			// A stale private role must not overrule the independent complete
+			// original language typecheck, even if both role records agree.
+			declaration := source.declarations[sig.Name]
+			declaration.transport = goAMD64FrameNumericTransport
+			observed.transport = goAMD64FrameNumericTransport
+			source.declarations[sig.Name], source.functions[sig.Name] = declaration, observed
+			bound, err = source.BindFixedLocal(ctx, pkg, file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) || len(bound.Sigs) != 0 {
+				t.Fatalf("paired numeric role claims replaced actual composite source: %v", err)
+			}
+		})
+	}
+	// By-value arrays have no Step B observation contract at all. Do not
+	// confuse a pointer-to-array observation with machine aggregate layout.
+	t.Run("by-value array", func(t *testing.T) {
+		pkg, request := goAMD64FrameTypedFixture(t, "func Value(a [2]uint64, n uint64) uint64", "TEXT ·Value(SB),4,$160-32\nRET\n")
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+		if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("by-value array acquired an invented observation contract: %v", err)
+		}
+	})
+}
+
+// These mutations simulate an internal stale role/model, not a public way to
+// write opaque fields. The independent original typecheck must remain the
+// authority even when two private observations are changed consistently.
+func fixedLocalTypedRoleMutation(t *testing.T, source *GoAMD64FrameSource, name, mutation string) {
+	t.Helper()
+	function, declaration := source.functions[name], source.declarations[name]
+	t.Cleanup(func() {
+		source.functions[name] = function
+		source.declarations[name] = declaration
+	})
+	changedFunction, changedDeclaration := function, declaration
+	switch mutation {
+	case "object role":
+		changedFunction.transport = goAMD64FrameCompositeTransport
+	case "object missing language":
+		changedFunction.languageType = ""
+	case "object changed language":
+		changedFunction.languageType += "changed"
+	case "declaration role":
+		changedDeclaration.transport = goAMD64FrameCompositeTransport
+	case "declaration missing language":
+		changedDeclaration.languageType = ""
+	case "declaration changed language":
+		changedDeclaration.languageType += "changed"
+	case "paired changed language":
+		changedFunction.languageType += "changed"
+		changedDeclaration.languageType = changedFunction.languageType
+	case "missing declaration":
+		delete(source.declarations, name)
+		return
+	default:
+		t.Fatalf("unknown fixture mutation %q", mutation)
+	}
+	source.functions[name], source.declarations[name] = changedFunction, changedDeclaration
+}
+
+var fixedLocalTypedRoleMutations = []string{
+	"object role", "object missing language", "object changed language",
+	"declaration role", "declaration missing language", "declaration changed language",
+	"paired changed language", "missing declaration",
+}
+
+func TestGoAMD64FixedLocalTypedRoleBindRejectsStaleLanguage(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, mutation := range fixedLocalTypedRoleMutations {
+		t.Run(mutation, func(t *testing.T) {
+			fixedLocalTypedRoleMutation(t, source, pkg.Path+".Value", mutation)
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) || len(bound.Sigs) != 0 {
+				t.Fatalf("stale private observation overrode actual numeric source: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedRoleConsumerRejectsStaleLanguage(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range fixedLocalTypedRoleMutations {
+		t.Run(mutation, func(t *testing.T) {
+			fixedLocalTypedRoleMutation(t, source, pkg.Path+".Value", mutation)
+			fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedRoleSuppliedTypeIdentityRemainsExact(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, declaration := range []string{
+		"func Value(a, b, c, d int64) int64",
+		"func Value(a, b, c, d uintptr) uint64",
+		"func Value(a, b, c, renamed uint64) uint64",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, "changed.go", "package framefixture\n"+declaration+"\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			typed, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			changed := pkg
+			changed.Types, changed.Syntax = typed, []*ast.File{syntax}
+			bound, err := source.BindFixedLocal(ctx, changed, file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) || len(bound.Sigs) != 0 {
+				t.Fatalf("same-width supplied type/parameter identity replaced actual original source: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedRoleBindingWitnessCannotDrift(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := pkg.Path + ".Value"
+	binding := bound.Sigs[name].x86FixedLocal
+	original := binding.declarations[name]
+	for _, mutation := range []string{"role", "language", "missing witness"} {
+		t.Run(mutation, func(t *testing.T) {
+			t.Cleanup(func() { binding.declarations[name] = original })
+			changed := original
+			switch mutation {
+			case "role":
+				changed.transport = goAMD64FrameCompositeTransport
+			case "language":
+				changed.languageType += "changed"
+			case "missing witness":
+				delete(binding.declarations, name)
+			}
+			if mutation != "missing witness" {
+				binding.declarations[name] = changed
+			}
+			fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalTypedRoleJSONCannotSupplyPrivateWitness(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	encoded, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var clone GoAMD64FrameSource
+	if err := json.Unmarshal(encoded, &clone); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := clone.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("JSON recovered an authenticated object/language token: %v", err)
+	}
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+}
diff --git a/amd64_fixed_local_unaligned_candidate_test.go b/amd64_fixed_local_unaligned_candidate_test.go
new file mode 100644
index 000000000..aa47b741e
--- /dev/null
+++ b/amd64_fixed_local_unaligned_candidate_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalUnalignedTransportCandidateRoles(t *testing.T) {
+	_, _, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", "RET")
+	for _, opcode := range []string{"MOVOU", "MOVUPS", "MOVUPD", "VMOVDQU", "VMOVUPS", "VMOVUPD",
+		"VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+		for _, direction := range []string{"load", "store"} {
+			for _, row := range []struct {
+				address string
+				want    bool
+			}{
+				{"16(SP)", true}, {"(SP)", true}, {"16(BP)", true},
+				{"spill-16(SP)", false}, {"spill-(8+8)(SP)", false},
+				{"input+0(FP)", false}, {"(AX)", false}, {"constant<>(SB)", false},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", opcode, direction, row.address)
+				t.Run(name, func(t *testing.T) {
+					operands := row.address + ",X0"
+					if direction == "store" {
+						operands = "X0," + row.address
+					}
+					source := "TEXT ·Value(SB),4,$160-8\n" + opcode + " " + operands +
+						"\nMOVQ X0,AX\nMOVQ AX,ret0+0(FP)\nRET\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if got := GoAMD64FixedLocalFrameBindingNeeded(file, "amd64"); got != row.want {
+						t.Fatalf("physical scratch query = %v, want %v", got, row.want)
+					}
+					if GoAMD64FixedLocalFrameBindingNeeded(file, "386") {
+						t.Fatal("AMD64 source observer claimed mode32 backing")
+					}
+					if row.want {
+						_, err := Translate(file, Options{
+							Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+							Sigs:       map[string]FuncSig{"Value": sig},
+							ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+						})
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("candidate query supplied backing or initialized bytes: %v", err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_fixed_local_unrelated_types_test.go b/amd64_fixed_local_unrelated_types_test.go
new file mode 100644
index 000000000..2bbc50dfe
--- /dev/null
+++ b/amd64_fixed_local_unrelated_types_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalUnrelatedGoTypesObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const declarations = `
+type XOF interface { Read([]byte) (int, error); Clone() XOF }
+type Callback func([]byte) error
+type Cache map[string][]byte
+type Queue chan []byte
+type Scalar float64
+type Node struct { Next *Node; Value uint64 }
+type Box[T any] struct { Value T }
+type Reader = interface { Read([]byte) (int, error) }
+`
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			name := filepath.Join(request.Directory, "value.go")
+			original, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data := append(original, []byte(declarations)...)
+			if err := os.WriteFile(name, data, 0600); err != nil {
+				t.Fatal(err)
+			}
+			set := token.NewFileSet()
+			syntax, err := parser.ParseFile(set, name, data, parser.ParseComments)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg.Syntax = []*ast.File{syntax}
+			pkg.Types, err = (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check(pkg.Path, set, pkg.Syntax, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			request.Target = target.name
+			options.TargetTriple = target.triple
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "types.ll", "types.o", ir)
+				compileLLVMToObject(t, llc, target.triple, "types-opt.ll", "types-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+			if len(bound.Sigs) != 1 || len(source.declarations) != 1 || len(source.functions) != 1 {
+				t.Fatal("unrelated ordinary types acquired assembly transport or frame authority")
+			}
+		})
+	}
+}
diff --git a/amd64_fixed_local_value.go b/amd64_fixed_local_value.go
new file mode 100644
index 000000000..0dfad0f3f
--- /dev/null
+++ b/amd64_fixed_local_value.go
@@ -0,0 +1,210 @@
+package plan9asm
+
+// Scalar transport carries one complete typed value, never additional memory
+// permission. MOV, CMOV and XCHG share the same read/write boundaries; exchanges
+// snapshot both operands before changing any register or private spill.
+type fixedLocalScalarValue struct {
+	address         int64
+	pointer, opaque bool
+	identity        x86FixedLocalOrigins
+	booleans        uint8
+	constant        int64
+	constantKnown   bool
+	bounds          x86UnsignedRange
+	bounded         bool
+}
+
+// Selection retains only facts true of both possible values. Private offsets
+// must agree. Opaque addresses share the same machine-address domain;
+// joining them never supplies a numerical value or private-frame permission.
+func mergeFixedLocalScalarValues(first, last fixedLocalScalarValue) (fixedLocalScalarValue, bool) {
+	if first.pointer != last.pointer || first.opaque != last.opaque ||
+		first.pointer && first.address != last.address {
+		return fixedLocalScalarValue{}, false
+	}
+	if first.opaque {
+		var valid bool
+		first.identity, valid = first.identity.union(last.identity)
+		if !valid {
+			return fixedLocalScalarValue{}, false
+		}
+	}
+	first.booleans &= last.booleans
+	first.constantKnown = first.constantKnown && last.constantKnown && first.constant == last.constant
+	first.bounded = first.bounded && last.bounded
+	if first.bounded {
+		first.bounds = first.bounds.hull(last.bounds)
+	}
+	return first, true
+}
+
+func fixedLocalReadValue(ins *Instr, index int, state *x86FixedLocalState, sig FuncSig,
+	proof *x86FixedLocalProof, residue int, width int64, write bool) (fixedLocalScalarValue, error) {
+	var value fixedLocalScalarValue
+	fail := func() error { return goAMD64FrameContext("unproved fixed local scalar read") }
+	source := ins.Args[index]
+	switch source.Kind {
+	case OpReg:
+		value.address, value.pointer = state.pointers[source.Reg]
+		value.identity, value.opaque = state.opaque[source.Reg]
+		if value.opaque && !value.identity.valid() {
+			return value, fail()
+		}
+		if value.pointer || value.opaque {
+			if width != 8 {
+				return value, fail()
+			}
+		} else if amd64VectorByteWidth(source.Reg) == 16 {
+			if width != 8 || state.vectors[x86CallerVectorRoot(source.Reg)]&255 != 255 {
+				return value, fail()
+			}
+		} else {
+			if !fixedLocalNumericRead(source, width, state) {
+				return value, fail()
+			}
+			value.constant, value.constantKnown = state.constants[source.Reg]
+			// Narrow moves truncate or preserve a destination's old upper
+			// bytes. They cannot transport a complete 64-bit address mask.
+			value.constantKnown = value.constantKnown && width == 8
+			value.bounds, value.bounded = state.ranges[source.Reg]
+			value.bounded = value.bounded && width == 8
+			value.booleans = fixedLocalBooleanRead(source, width, state)
+		}
+	case OpImm:
+		if !fixedLocalNumericRead(source, width, state) {
+			return value, fail()
+		}
+		value.constant, value.constantKnown = source.Imm, width == 8
+		value.booleans = fixedLocalBooleanRead(source, width, state)
+	case OpFP:
+		sp, original := state.pointers[SP]
+		slot, _, found := fixedLocalTransportSlot(source.FPOffset, width, sig.Frame.Params)
+		if !original || sp != 0 || !found {
+			return value, fail()
+		}
+		if slot.Type == Ptr {
+			value.opaque, value.identity = true, fixedLocalOrigin(x86FixedLocalOrigin{parameter: slot.Offset})
+		} else if slot.Type == I1 {
+			value.booleans = 1
+		}
+	case OpSym:
+		if write {
+			return value, fail()
+		}
+		if _, _, err := fixedLocalReadMemory(ins, index, state, proof, residue, width, 1); err != nil {
+			return value, err
+		}
+	case OpMem:
+		memory, err := fixedLocalMemoryAddress(*ins, index, proof.frame)
+		if err != nil {
+			return value, err
+		}
+		offset, found := fixedLocalPrivateOffset(memory, state)
+		if found {
+			value.address, value.pointer = state.addresses[offset]
+			value.identity, value.opaque = state.opaqueCells[offset]
+		}
+		if value.opaque && !value.identity.valid() {
+			return value, fail()
+		}
+		if (value.pointer || value.opaque) && width != 8 {
+			return value, fail()
+		}
+		offset, role, err := fixedLocalMemoryAccess(ins, index, state, proof, residue, width, 1, write, value.pointer || value.opaque)
+		if err != nil {
+			return value, err
+		}
+		if role == x86FixedLocalPrivateMemory && !value.pointer && !value.opaque {
+			if write {
+				if !state.bytes.all(offset, width) {
+					return value, fail()
+				}
+			}
+			value.booleans = fixedLocalMemoryBooleans(state, offset, width)
+		}
+	default:
+		return value, fail()
+	}
+	return value, nil
+}
+
+func fixedLocalWriteValue(ins *Instr, index, sourceIndex int, value fixedLocalScalarValue, state *x86FixedLocalState,
+	sig FuncSig, proof *x86FixedLocalProof, residue int, width int64) error {
+	fail := func() error { return goAMD64FrameContext("unproved fixed local scalar write") }
+	destination, source := ins.Args[index], ins.Args[sourceIndex]
+	switch destination.Kind {
+	case OpReg:
+		root, valid := x86CallerGP(destination.Reg)
+		if !valid || (value.pointer || value.opaque) && (width != 8 || destination.Reg != root) {
+			return fail()
+		}
+		if root == SP && !value.pointer {
+			return fail()
+		}
+		if _, oldPointer := state.pointers[root]; oldPointer && width != 8 {
+			return fail()
+		}
+		delete(state.pointers, root)
+		delete(state.opaque, root)
+		delete(state.constants, root)
+		fixedLocalWriteBooleans(state, destination.Reg, width, value.booleans)
+		if value.pointer {
+			state.pointers[root] = value.address
+			state.known[root] = 0
+		} else if value.opaque {
+			state.opaque[root] = value.identity
+			state.known[root] = 0
+		} else {
+			mask := x86CallerByteMask(destination.Reg, width)
+			if mask == 0 {
+				return fail()
+			}
+			if width == 4 {
+				mask = 255
+			}
+			state.known[root] |= mask
+			if value.constantKnown {
+				state.constants[root] = value.constant
+			}
+			if value.bounded {
+				state.setRange(root, value.bounds)
+			}
+		}
+	case OpMem:
+		if source.Kind == OpMem {
+			return fail()
+		}
+		offset, role, err := fixedLocalMemoryAccess(ins, index, state, proof, residue, width, 1, true, false)
+		if err != nil {
+			return err
+		}
+		if role == x86FixedLocalNativeInput {
+			if value.pointer || value.opaque {
+				return fail() // Neither private nor input pointers escape as bytes.
+			}
+			return nil
+		}
+		fixedLocalRevokeSpillRoles(state, offset, width)
+		state.bytes.setRange(offset, width, !value.pointer && !value.opaque)
+		for index := offset; index < offset+width; index++ {
+			state.booleanBytes.set(index, value.booleans&(1<<uint(index-offset)) != 0)
+		}
+		if value.pointer {
+			state.addresses[offset] = value.address
+		}
+		if value.opaque {
+			state.opaqueCells[offset] = value.identity
+		}
+	case OpFP:
+		sp, original := state.pointers[SP]
+		slot, index, found := fixedLocalTransportSlot(destination.FPOffset, width, sig.Frame.Results)
+		if !original || sp != 0 || value.pointer || value.identity.hasLiteral() || !found || source.Kind != OpReg && source.Kind != OpImm ||
+			value.opaque != (slot.Type == Ptr) || slot.Type == I1 && value.booleans&1 == 0 {
+			return fail()
+		}
+		state.results[index] = true
+	default:
+		return fail()
+	}
+	return nil
+}
diff --git a/amd64_fixed_local_vector_effect.go b/amd64_fixed_local_vector_effect.go
new file mode 100644
index 000000000..37d14307d
--- /dev/null
+++ b/amd64_fixed_local_vector_effect.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "strings"
+
+// Only descriptors with explicit vector storage/alias metadata participate.
+// MMX, unregistered upper writes and wider banks keep their separate owners.
+func fixedLocalVectorByteEffect(ins Instr) (x86TypedByteEffect, bool, error) {
+	if ins.x86NumericalRead != nil {
+		return x86TypedByteEffect{}, false, nil // Preserve the existing owner-specific consumer.
+	}
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if _, known := amd64Reciprocal14Specs[Op(base)]; known {
+		return x86TypedFloatingHelperByteEffect(ins.Op, ins, "amd64")
+	}
+	parse := x86PackedBinaryByteEffect
+	if strings.HasPrefix(strings.ToUpper(string(ins.Op)), "V") {
+		parse = x86UnmaskedVEXByteEffect
+	}
+	effect, known, err := parse(ins.Op, ins, "amd64")
+	if !known {
+		effect, known, err = x86TypedPackedIntegerCompareByteEffect(ins.Op, ins, "amd64")
+	}
+	if !known {
+		return effect, false, nil
+	}
+	if err != nil {
+		return x86TypedByteEffect{}, true, goAMD64FrameContext("fixed local vector form is not closed: %v", err)
+	}
+	valid := effect.vector.upperWrite == x86TypedVectorUpperPreserve && effect.vector.memoryAlignment == 16 ||
+		effect.vector.upperWrite == x86TypedVectorUpperZero && effect.vector.memoryAlignment == 1
+	for _, operand := range effect.operands {
+		switch operand.operand.Kind {
+		case OpReg:
+			width := amd64VectorByteWidth(operand.operand.Reg)
+			index, vector := amd64VectorRegisterIndex(operand.operand.Reg, width)
+			valid = valid && vector && index < 16 && operand.width == int64(width)
+		case OpMem, OpSym:
+			valid = valid && operand.width > 0
+		case OpImm:
+			valid = valid && operand.read && !operand.write && fixedLocalNumericRead(operand.operand, operand.width, nil)
+		default:
+			valid = false
+		}
+	}
+	if !valid {
+		return x86TypedByteEffect{}, true, goAMD64FrameContext("fixed local vector effect has an unbound storage or alias role: %s", ins.Op)
+	}
+	return effect, true, nil
+}
diff --git a/amd64_fixed_local_vex_effect_test.go b/amd64_fixed_local_vex_effect_test.go
new file mode 100644
index 000000000..34d7c8238
--- /dev/null
+++ b/amd64_fixed_local_vex_effect_test.go
@@ -0,0 +1,391 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type fixedLocalVEXWitness struct {
+	owner, source string
+}
+
+// The scope is independent of the translator's registration maps. Keep every
+// original VEX row, including overlapping signed/unsigned immediate classes.
+// EVEX rows are inventoried separately and do not acquire permission here.
+func fixedLocalVEXWitnesses(t *testing.T) []fixedLocalVEXWitness {
+	return fixedLocalVEXFamilyWitnesses(t,
+		`^(VPADD(B|W|D|Q|SB|SW|USB|USW)|VPALIGNR|V(BLENDP[DS]|PBLEND[WD])|V(ANDN?|OR|XOR)P[DS]|VP(ANDN?|OR|XOR)|VMOV(AP[DS]|UP[DS]|DQ[AU])|VPERM2[FI]128|VPS(LL|RL|RA)(W|D|Q|V[WDQ]|DQ)|VPSHUFB|VZERO(UPPER|ALL))$`,
+		146, 354)
+}
+
+func fixedLocalVEXBinaryWitnesses(t *testing.T) []fixedLocalVEXWitness {
+	return fixedLocalVEXFamilyWitnesses(t,
+		`^VP(SUB(B|W|D|Q|SB|SW|USB|USW)|MUL(LD|LQ|LW|HW|HUW|HRSW|DQ|UDQ)|AVG(B|W)|MADD(WD|UBSW)|(MIN|MAX)[SU][BWDQ])$`,
+		62, 186)
+}
+
+func fixedLocalVEXFamilyWitnesses(t *testing.T, pattern string, wantRows, wantWitnesses int) []fixedLocalVEXWitness {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	family := regexp.MustCompile(pattern)
+	var witnesses []fixedLocalVEXWitness
+	rows := 0
+	for _, rule := range rules {
+		if !family.MatchString(rule.Opcode) || !strings.HasPrefix(rule.ZCase, "Zvex") {
+			continue
+		}
+		rows++
+		if rule.Prefix != "Pavx" || rule.EncodingOffset < 0 || rule.EncodingOffset+2 > len(rule.OpBytes) {
+			t.Fatalf("unmodeled official VEX attributes: %+v", rule)
+		}
+		var args []string
+		memory := -1
+		for index, class := range rule.Classes {
+			switch class {
+			case "Yxr", "Yxm", "Yyr", "Yym":
+				bank := "X"
+				if class[1] == 'y' {
+					bank = "Y"
+				}
+				args = append(args, fmt.Sprintf("%s%d", bank, index))
+				if class[2] == 'm' {
+					if memory >= 0 {
+						t.Fatalf("unexpected two-memory VEX row: %+v", rule)
+					}
+					memory = index
+				}
+			case "Yi8":
+				args = append(args, "$-128")
+			case "Yu8":
+				args = append(args, "$255")
+			default:
+				t.Fatalf("unmodeled original VEX operand class: %+v", rule)
+			}
+		}
+		inputs := []string{""}
+		if memory >= 0 {
+			inputs = []string{args[memory], "64(BP)", "(SI)"}
+		}
+		for _, input := range inputs {
+			if memory >= 0 {
+				args[memory] = input
+			}
+			witnesses = append(witnesses, fixedLocalVEXWitness{
+				owner:  fmt.Sprintf("%s/row%d/%s", rule.Opcode, rule.RowIndex, input),
+				source: strings.TrimSpace(rule.Opcode + " " + strings.Join(args, ",")),
+			})
+		}
+	}
+	if rows != wantRows || len(witnesses) != wantWitnesses {
+		t.Fatalf("official non-masked VEX inventory changed: rows=%d witnesses=%d, want %d/%d", rows, len(witnesses), wantRows, wantWitnesses)
+	}
+	return witnesses
+}
+
+func fixedLocalVEXFixture(t *testing.T, operation string) (Func, FuncSig, string) {
+	t.Helper()
+	source := fixedLocalVEXAssembly(operation)
+	_, _, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *uint64, a uint64) uint64", "RET")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func fixedLocalVEXAssembly(operation string) string {
+	// Reuse the complete aligned scratch fixture. Input pointers are typed,
+	// not inferred from numerical register contents or private frame offsets.
+	source := fixedLocalPackedAssembly("VMOVDQU 64(BP),Y0\nVMOVDQU 64(BP),Y1\n" +
+		"VMOVDQU 64(BP),Y2\nVMOVDQU 64(BP),Y3\n" + operation)
+	source = strings.Replace(source, "$256-16", "$256-24", 1)
+	source = strings.Replace(source, "MOVQ a+0(FP),AX", "MOVQ p+0(FP),SI\nMOVQ a+8(FP),AX", 1)
+	source = strings.Replace(source, "ret+8(FP)", "ret+16(FP)", 1)
+	return source
+}
+
+func TestGoAMD64FixedLocalVEXOfficialEncodings(t *testing.T) {
+	fixedLocalCheckVEXEncodings(t, fixedLocalVEXWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXBinaryOfficialEncodings(t *testing.T) {
+	fixedLocalCheckVEXEncodings(t, fixedLocalVEXBinaryWitnesses(t))
+}
+
+func fixedLocalCheckVEXEncodings(t *testing.T, witnesses []fixedLocalVEXWitness) {
+	t.Helper()
+	rows := make([]string, len(witnesses))
+	for index, row := range witnesses {
+		rows[index] = row.source
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", strings.Join(rows, "\n")+"\nRET")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("Go changed the complete source instruction inventory", len(pcs), len(rows))
+	}
+	for index, row := range witnesses {
+		instruction := code[pcs[index]:pcs[index+1]]
+		if len(instruction) < 3 || instruction[0] != 0xc4 && instruction[0] != 0xc5 {
+			t.Fatalf("%s selected non-VEX bytes %x", row.owner, instruction)
+		}
+	}
+	t.Logf("%d legal original Go source witnesses; VEX generation check, not exact row-encoding or execution proof", len(witnesses))
+}
+
+func TestGoAMD64FixedLocalVEXCompleteFamilies(t *testing.T) {
+	fixedLocalCheckVEXFamilies(t, fixedLocalVEXWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXBinaryCompleteFamilies(t *testing.T) {
+	fixedLocalCheckVEXFamilies(t, fixedLocalVEXBinaryWitnesses(t))
+}
+
+func fixedLocalCheckVEXFamilies(t *testing.T, witnesses []fixedLocalVEXWitness) {
+	t.Helper()
+	for _, row := range witnesses {
+		t.Run(row.owner, func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, row.source)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("initialized complete VEX source rejected", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXPhysicalBoundaries(t *testing.T) {
+	fixedLocalCheckVEXPhysicalBoundaries(t, fixedLocalVEXWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXBinaryPhysicalBoundaries(t *testing.T) {
+	fixedLocalCheckVEXPhysicalBoundaries(t, fixedLocalVEXBinaryWitnesses(t))
+}
+
+func fixedLocalCheckVEXPhysicalBoundaries(t *testing.T, witnesses []fixedLocalVEXWitness) {
+	t.Helper()
+	rows := make([]string, len(witnesses))
+	for index, row := range witnesses {
+		rows[index] = row.source
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", strings.Join(rows, "\n")+"\nRET")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("Go changed the complete source instruction inventory", len(pcs), len(rows))
+	}
+	for index, row := range witnesses {
+		t.Run(row.owner, func(t *testing.T) {
+			instruction := code[pcs[index]:pcs[index+1]]
+			boundaries, scalar, err := x86NumericalNativeBoundaries(instruction, 64)
+			if err != nil || len(boundaries) != 1 || boundaries[0].Length != len(instruction) || len(scalar) != 0 {
+				t.Fatalf("original Go boundary for %s (%x): %v %v %v", row.source, instruction, boundaries, scalar, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXBoundaries(t *testing.T) {
+	for _, row := range []struct{ name, operation string }{
+		{"unknown source", "VPADDQ Y7,Y1,Y2"},
+		{"missing count upper qword", "VPSRLQ 184(BP),Y1,Y2"},
+		{"outside private frame", "VPSHUFB 256(BP),Y1,Y2"},
+		{"numeric pointer", "VPOR (AX),Y1,Y2"},
+		{"unbound FP", "VPAND a+8(FP),Y1,Y2"},
+		{"EVEX high register", "VPADDQ X16,X1,X2"},
+		{"EVEX width", "VPADDQ Z0,Z1,Z2"},
+		{"EVEX mask", "KMOVQ AX,K1\nVPADDQ Y0,Y1,K1,Y2"},
+		{"EVEX broadcast", "VPADDQ.BCST (SI),Y1,Y2"},
+		{"EVEX-only member", "VPSRAQ $1,Y1,Y2"},
+		{"EVEX immediate memory", "VPSRLQ $1,64(BP),Y2"},
+		{"MMX", "PADDQ M0,M1"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig, source := fixedLocalVEXFixture(t, row.operation)
+			if row.name == "numeric pointer" {
+				fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64) uint64",
+					row.operation, 0, 32, false, "load volatile <32 x i8>")
+				return
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved form acquired fixed-local permission", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXUpperAliases(t *testing.T) {
+	for _, operation := range []string{
+		"VPADDQ X0,X1,X2", "VPOR X0,X1,X2", "VPSHUFB X0,X1,X2",
+		"VPSRLQ $3,X1,X2", "VPALIGNR $3,X0,X1,X2", "VPBLENDD $3,X0,X1,X2",
+		"VPERM2F128 $3,Y0,Y1,Y2", "VPERM2I128 $3,Y0,Y1,Y2",
+	} {
+		t.Run(operation, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, operation)
+			state := x86FixedLocalState{vectors: map[Reg]uint64{
+				"Z0": 0xffffffff, "Z1": 0xffffffff, "Z2": 0,
+			}, flags: x86ByteFlagCF}
+			if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+				t.Fatal(err)
+			}
+			if state.vectors["Z2"] != ^uint64(0) || state.vectors["Z0"] != 0xffffffff ||
+				state.vectors["Z1"] != 0xffffffff || state.flags != x86ByteFlagCF {
+				t.Fatal("VEX did not define upper zeros independently of the old destination", state)
+			}
+		})
+	}
+	for _, op := range []string{"VZEROALL", "VZEROUPPER"} {
+		t.Run(op, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, op)
+			state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": 3, "Z16": 5}, flags: x86ByteFlagCF}
+			if err := fixedLocalStep(&ins, &state, FuncSig{}, nil, 0); err != nil {
+				t.Fatal(err)
+			}
+			want := ^uint64(0)
+			if op == "VZEROUPPER" {
+				want = ^uint64(65535) | 3
+			}
+			if state.vectors["Z0"] != want || state.vectors["Z16"] != 5 || state.flags != x86ByteFlagCF {
+				t.Fatal("VZERO changed an unaffected low/high-bank byte or FLAGS", state)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXBinaryInputAndAliasEffects(t *testing.T) {
+	names := make(map[string]bool)
+	for _, row := range fixedLocalVEXBinaryWitnesses(t) {
+		names[strings.Fields(row.source)[0]] = true
+	}
+	if len(names) != 31 {
+		t.Fatalf("official VEX binary members=%d, want 31", len(names))
+	}
+	for name := range names {
+		for width, bank := range map[int]string{16: "X", 32: "Y"} {
+			t.Run(name+"/"+bank, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s0,%s1,%s2", name, bank, bank, bank))
+				mask := x86CallerVectorByteMask(int64(width))
+				state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": mask, "Z1": mask}, flags: x86ByteFlagCF}
+				if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+					t.Fatal("complete VEX inputs rejected", err)
+				}
+				if state.vectors["Z2"] != ^uint64(0) || state.vectors["Z0"] != mask ||
+					state.vectors["Z1"] != mask || state.flags != x86ByteFlagCF {
+					t.Fatal("VEX did not read inputs before defining result/upper zeros", state)
+				}
+				state.vectors["Z0"] &^= uint64(1) << (width - 1)
+				state.vectors["Z2"] = 0
+				if err := fixedLocalVectorStep(&ins, &state, nil, 0); !errors.Is(err, ErrProbeNeedsContext) ||
+					state.vectors["Z2"] != 0 {
+					t.Fatal("missing input byte published VEX result or upper-zero knowledge", err, state)
+				}
+			})
+		}
+	}
+	for _, operation := range []string{
+		"VPMULLQ X0,X1,X2", "VPMINSQ X0,X1,X2", "VPMINUQ Y0,Y1,Y2",
+		"VPMAXSQ X0,X1,X2", "VPMAXUQ Y0,Y1,Y2",
+		"VPSUBW Z0,Z1,Z2", "VPMULHW X16,X1,X2", "VPAVGB X0,X1,K1,X2",
+		"VPMADDWD.Z X0,X1,K1,X2", "VPMINSD.BCST (SI),X1,X2",
+	} {
+		t.Run(operation, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, operation)
+			if _, known, err := fixedLocalVectorByteEffect(ins); known && err == nil {
+				t.Fatal("separate EVEX form acquired a VEX effect before input checks")
+			}
+			fn, sig, _ := fixedLocalVEXFixture(t, operation)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("separate EVEX width/mask/broadcast acquired VEX permission", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXCompleteObjects(t *testing.T) {
+	fixedLocalCheckVEXObjects(t, fixedLocalVEXWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXBinaryCompleteObjects(t *testing.T) {
+	fixedLocalCheckVEXObjects(t, fixedLocalVEXBinaryWitnesses(t))
+}
+
+func fixedLocalCheckVEXObjects(t *testing.T, witnesses []fixedLocalVEXWitness) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	passed := 0
+	for start := 0; start < len(witnesses); start += 32 {
+		end := start + 32
+		if end > len(witnesses) {
+			end = len(witnesses)
+		}
+		if t.Run(fmt.Sprintf("batch%d", start/32), func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			for index := start; index < end; index++ {
+				name := fmt.Sprintf("Value%d", index)
+				assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(witnesses[index].source), "·Value", "·"+name, 1))
+				fmt.Fprintf(&declarations, "func %s(p *uint64, a uint64) uint64\n", name)
+			}
+			const triple = "x86_64-unknown-linux-gnu"
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), "linux/amd64", triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "vex.ll", "vex.o", ir)
+					compileLLVMToObject(t, llc, triple, "vex-opt.ll", "vex-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		}) {
+			passed += end - start
+		}
+	}
+	if passed != len(witnesses) {
+		t.Fatalf("three-API LLVM22 object witnesses passed=%d total=%d", passed, len(witnesses))
+	}
+	t.Logf("all %d non-masked VEX source witnesses passed three APIs and LLVM22 objects; not execution evidence", passed)
+}
+
+func BenchmarkGoAMD64FixedLocalVEXCandidate(b *testing.B) {
+	// This is the candidate query, not successful source proof, LLVM or
+	// native execution. No earlier scalar scratch store may short-circuit
+	// the register-only negative filter this benchmark measures.
+	source := "TEXT ·Value(SB),4,$256-0\n" + strings.Repeat("VPADDQ Y0,Y0,Y1\n", 32) +
+		"VMOVDQU 64(BP),Y0\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for index := 0; index < b.N; index++ {
+		if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+			b.Fatal("complete scratch source lost its candidate role")
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalVEXCandidateAllocations(t *testing.T) {
+	source := "TEXT ·Value(SB),4,$256-0\n" + strings.Repeat("VPADDQ Y0,Y0,Y1\n", 32) +
+		"VMOVDQU 64(BP),Y0\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+		t.Fatal("complete scratch source lost its candidate role")
+	}
+	allocations := testing.AllocsPerRun(100, func() {
+		GoAMD64FixedLocalFrameBindingNeeded(file, "amd64")
+	})
+	if allocations != 0 {
+		t.Fatalf("candidate query allocated for register-only noncandidates: %g", allocations)
+	}
+}
diff --git a/amd64_fixed_local_vex_native_linux_amd64_test.go b/amd64_fixed_local_vex_native_linux_amd64_test.go
new file mode 100644
index 000000000..6725da6dd
--- /dev/null
+++ b/amd64_fixed_local_vex_native_linux_amd64_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// This required native owner is never registered on a Windows/macOS host.
+// Objects from those hosts cannot substitute for original Go execution.
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalVEX(t *testing.T) {
+	fixedLocalVEXRuntime(t, fixedLocalVEXNativeTools(t), true)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalShuffle(t *testing.T) {
+	kernels := fixedLocalShuffleRuntimeKernels()
+	if len(kernels) != 41 {
+		t.Fatal("legacy and VEX shuffle runtime inventory changed", len(kernels))
+	}
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, kernels)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalShift(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, fixedLocalShiftRuntimeKernels(t))
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalScalarLane(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalVEXNativeTools(t), true, fixedLocalScalarLaneRuntimeKernels(t))
+	x87IA32RequireNativeHost(t)
+}
+
+func fixedLocalVEXNativeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	if len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("fixed-frame VEX differential execution requires native AMD64")
+	}
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "avx2.c"), filepath.Join(directory, "avx2")
+	const preflight = `#include <stdio.h>
+__attribute__((target("avx2"))) static int original_avx2(void) {
+    unsigned bits;
+    __asm__ volatile("vpcmpeqb %%ymm0,%%ymm0,%%ymm0; "
+                     "vpmovmskb %%ymm0,%0; vzeroupper"
+                     : "=r"(bits) :: "ymm0");
+    return bits==0xffffffffu;
+}
+int main(void) {
+    __builtin_cpu_init();
+    int avx=!!__builtin_cpu_supports("avx");
+    int avx2=!!__builtin_cpu_supports("avx2");
+    printf("fixed-frame native AVX=%d AVX2=%d\n",avx,avx2);
+    return avx && avx2 && original_avx2() ? 0 : 1;
+}
+`
+	if err := os.WriteFile(source, []byte(preflight), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("%s", execution.run(t, executable))
+	return execution
+}
diff --git a/amd64_fixed_local_vex_runtime_test.go b/amd64_fixed_local_vex_runtime_test.go
new file mode 100644
index 000000000..eebae066a
--- /dev/null
+++ b/amd64_fixed_local_vex_runtime_test.go
@@ -0,0 +1,456 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type fixedLocalVEXRuntimeKernel struct {
+	shape      string
+	operations []string
+}
+
+// A kernel owns one real register/width/immediate shape. Equivalent signed
+// and unsigned immediate table rows share it; register/private/native memory
+// sources and destination aliases remain separate observable operations.
+func fixedLocalVEXRuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	witnesses := append(fixedLocalVEXWitnesses(t), fixedLocalVEXBinaryWitnesses(t)...)
+	var kernels []fixedLocalVEXRuntimeKernel
+	rows, shapes := make(map[string]string), make(map[string]int)
+	seen := make(map[string]bool)
+	for _, witness := range witnesses {
+		parts := strings.SplitN(witness.source, " ", 2)
+		var args []string
+		if len(parts) == 2 {
+			args = strings.Split(parts[1], ",")
+		}
+		for index, argument := range args {
+			if strings.HasPrefix(argument, "$") {
+				args[index] = "$3"
+				if strings.HasPrefix(parts[0], "VPERM2") {
+					args[index] = "$49"
+				} else if parts[0] == "VPALIGNR" {
+					args[index] = "$17"
+				}
+			}
+		}
+		operation := strings.TrimSpace(parts[0] + " " + strings.Join(args, ","))
+		owner := strings.Split(witness.owner, "/")
+		row := owner[0] + "/" + owner[1]
+		shape, exists := rows[row]
+		if !exists {
+			// The official witness builder emits the register choice first.
+			if strings.Contains(operation, "(") {
+				t.Fatal("runtime row lost its independent register witness", witness.owner)
+			}
+			shape, rows[row] = operation, operation
+		}
+		index, exists := shapes[shape]
+		if !exists {
+			index, shapes[shape] = len(kernels), len(kernels)
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: shape})
+		}
+		add := func(source string) {
+			key := shape + "\n" + source
+			if !seen[key] {
+				seen[key] = true
+				kernels[index].operations = append(kernels[index].operations, source)
+			}
+		}
+		add(operation)
+		if len(args) < 2 || (!strings.HasPrefix(args[len(args)-1], "X") && !strings.HasPrefix(args[len(args)-1], "Y")) {
+			continue
+		}
+		for _, argument := range args[:len(args)-1] {
+			if !strings.HasPrefix(argument, "X") && !strings.HasPrefix(argument, "Y") {
+				continue
+			}
+			alias := append([]string(nil), args...)
+			alias[len(alias)-1] = args[len(args)-1][:1] + argument[1:]
+			add(parts[0] + " " + strings.Join(alias, ","))
+		}
+	}
+	return kernels
+}
+
+// Each operation observes Y0..Y3 in full, including the upper 128 bits of an
+// X destination, and all three scratch vectors (left canary/source/right).
+// Input memory and the outer output canaries are printed by both drivers.
+func fixedLocalVEXRuntimeProgram(kernels []fixedLocalVEXRuntimeKernel, triple string) (string, string, string, string) {
+	var assembly, declarations, goRows, cRows, cDeclarations strings.Builder
+	prefix := ""
+	if strings.Contains(triple, "apple") {
+		prefix = "_"
+	}
+	for index, kernel := range kernels {
+		name := fmt.Sprintf("Value%d", index)
+		fmt.Fprintf(&declarations, "func %s(out *uint64, input *[16]uint64)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$256-16\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),SI\n", name)
+		assembly.WriteString("MOVQ SP,BP\nADDQ $64,BP\nANDQ $-64,BP\n")
+		for observation, operation := range kernel.operations {
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&assembly, "VMOVDQU %d(SI),Y%d\n", register*32, register)
+			}
+			assembly.WriteString("VMOVDQU Y3,32(BP)\nVMOVDQU Y0,64(BP)\nVMOVDQU Y2,96(BP)\n")
+			assembly.WriteString(operation + "\n")
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&assembly, "VMOVDQU Y%d,%d(DI)\n", register, observation*224+register*32)
+			}
+			for vector := 0; vector < 3; vector++ {
+				fmt.Fprintf(&assembly, "VMOVDQU %d(BP),Y4\nVMOVDQU Y4,%d(DI)\n",
+					32+vector*32, observation*224+128+vector*32)
+			}
+		}
+		assembly.WriteString("VZEROUPPER\nRET\n")
+		fmt.Fprintf(&goRows, "{%s,%d},\n", name, len(kernel.operations)*28)
+		fmt.Fprintf(&cRows, "{value%d,%d},\n", index, len(kernel.operations)*28)
+		label := runtimeCAsmLabel(prefix + "example.invalid/framefixture." + name)
+		fmt.Fprintf(&cDeclarations, "extern void value%d(uint64_t*,uint64_t*) __asm__(%s);\n", index, label)
+	}
+	const values = `0,1,7,15,16,31,32,63,64,65,0x7f7f7f7f7f7f7f7f,
+0x8080808080808080,0x7fff7fff7fff7fff,0x8000800080008000,
+0xffffffffffffffff,0x0123456789abcdef`
+	original := `package main
+import ("fmt"; "unsafe")
+` + declarations.String() + `
+func main() {
+    rows := []struct { call func(*uint64,*[16]uint64); words int }{
+` + goRows.String() + `
+    }
+    values := []uint64{` + values + `}
+    for row, entry := range rows {
+        for sample := range values {
+            var storage [24]uint64
+            input := (*[16]uint64)(unsafe.Pointer((uintptr(unsafe.Pointer(&storage[0]))+63)&^uintptr(63)))
+            for index := range input {
+                input[index] = values[(sample+index)%len(values)]
+            }
+            output := make([]uint64,entry.words+8)
+            for index := range output {
+                output[index] = 0xc3c3c3c3c3c3c300+uint64(index)
+            }
+            entry.call(&output[4],input)
+            fmt.Printf("%d %d",row,sample)
+            for _, value := range output {
+                fmt.Printf(" %016x",value)
+            }
+            for _, value := range input {
+                fmt.Printf(" %016x",value)
+            }
+            fmt.Println()
+        }
+    }
+}
+`
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+int main(void) {
+    const struct { void (*call)(uint64_t*,uint64_t*); size_t words; } rows[] = {
+` + cRows.String() + `
+    };
+    const uint64_t values[] = {` + values + `};
+    const size_t samples = sizeof(values)/sizeof(values[0]);
+    for (size_t row = 0; row < sizeof(rows)/sizeof(rows[0]); row++) {
+        for (size_t sample = 0; sample < samples; sample++) {
+            _Alignas(64) uint64_t input[16];
+            for (size_t index = 0; index < 16; index++) {
+                input[index] = values[(sample+index)%samples];
+            }
+            const size_t words = rows[row].words+8;
+            uint64_t *output = malloc(words*sizeof(*output));
+            if (!output) return 2;
+            for (size_t index = 0; index < words; index++) {
+                output[index] = UINT64_C(0xc3c3c3c3c3c3c300)+index;
+            }
+            rows[row].call(output+4,input);
+            printf("%zu %zu",row,sample);
+            for (size_t index = 0; index < words; index++) {
+                printf(" %016llx",(unsigned long long)output[index]);
+            }
+            for (size_t index = 0; index < 16; index++) {
+                printf(" %016llx",(unsigned long long)input[index]);
+            }
+            puts("");
+            free(output);
+        }
+    }
+    return 0;
+}
+`
+	return assembly.String(), declarations.String(), original, driver
+}
+
+func fixedLocalVEXRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	fixedLocalVectorRuntime(t, execution, execute, fixedLocalVEXRuntimeKernels(t))
+}
+
+func fixedLocalVectorRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool, kernels []fixedLocalVEXRuntimeKernel) {
+	t.Helper()
+	goAMD64FramePrepareOwnedToolCache(t)
+	for start := 0; start < len(kernels); start += 32 {
+		end := start + 32
+		if end > len(kernels) {
+			end = len(kernels)
+		}
+		t.Run(fmt.Sprintf("batch%d", start/32), func(t *testing.T) {
+			assembly, declarations, original, driver := fixedLocalVEXRuntimeProgram(kernels[start:end], execution.triple)
+			var want []string
+			if execute {
+				output := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original)
+				want = strings.Split(strings.TrimSpace(string(output)), "\n")
+				if len(want) != (end-start)*16 {
+					t.Fatalf("original Go emitted %d observations, want %d", len(want), (end-start)*16)
+				}
+			} else {
+				x86COMICompileOriginalGo(t, map[string]string{
+					"go.mod": "module vexframe\ngo 1.20\n", "main.go": original, "original_amd64.s": assembly,
+				}, false)
+			}
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations,
+				runtime.GOOS+"/amd64", execution.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							input := ir
+							if level == "-O2" {
+								input = x86MulDivRoundOptimize(t, ir)
+							}
+							if !execute {
+								execution.compileLLVM(t, "private-vex", input, driver, level)
+								return
+							}
+							output := execution.compileAndRunLLVM(t, "private-vex", input, driver, level)
+							got := strings.Split(strings.TrimSpace(string(output)), "\n")
+							if len(got) != len(want) {
+								t.Fatalf("LLVM emitted %d observations, original Go %d", len(got), len(want))
+							}
+							for index := range want {
+								if got[index] != want[index] {
+									t.Fatalf("kernel=%s sample=%d original=%s LLVM=%s", kernels[start+index/16].shape,
+										index%16, want[index], got[index])
+								}
+							}
+						})
+					}
+				})
+		})
+	}
+	t.Logf("%d vector shape kernels, 16 input patterns; original Go and three LLVM APIs execute=%v", len(kernels), execute)
+}
+
+// Immediate-domain tests cover all selectors separately. These kernels compare
+// original execution for four distinct selector patterns, both widths, memory and
+// alias forms, and preserved/zeroed upper bytes. Memory canaries remain visible.
+func fixedLocalShuffleRuntimeKernels() []fixedLocalVEXRuntimeKernel {
+	var kernels []fixedLocalVEXRuntimeKernel
+	names := []string{"PSHUFB", "PSHUFD", "PSHUFL", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"}
+	for _, name := range names {
+		banks := []string{"X"}
+		if strings.HasPrefix(name, "V") {
+			banks = append(banks, "Y")
+		}
+		selectors := []string{"0", "27", "78", "255"}
+		if name == "PSHUFB" {
+			selectors = []string{""}
+		}
+		for _, bank := range banks {
+			for _, selector := range selectors {
+				prefix := name + " "
+				if selector != "" {
+					prefix += "$" + selector + ","
+				}
+				operations := []string{
+					prefix + bank + "0," + bank + "2",
+					prefix + bank + "0," + bank + "0",
+					prefix + "64(BP)," + bank + "2",
+					prefix + "0(SI)," + bank + "2",
+				}
+				if strings.HasPrefix(name, "V") {
+					operations = append(operations, prefix+"65(BP),"+bank+"2", prefix+"1(SI),"+bank+"2")
+				}
+				kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: operations[0], operations: operations})
+			}
+		}
+	}
+	return kernels
+}
+
+func TestGoAMD64FixedLocalShuffleRuntimeObjects(t *testing.T) {
+	kernels := fixedLocalShuffleRuntimeKernels()
+	if len(kernels) != 41 {
+		t.Fatal("legacy and VEX shuffle runtime inventory changed", len(kernels))
+	}
+	fixedLocalVectorRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, kernels)
+}
+
+func fixedLocalCLMULRuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	var kernels []fixedLocalVEXRuntimeKernel
+	operations := 0
+	for _, kind := range []string{"legacy", "X", "Y"} {
+		for _, selector := range []int{0, 1, 16, 17, 238, 255} {
+			var rows []string
+			if kind == "legacy" {
+				for _, source := range []string{"X1", "X2", "64(BP)", "(SI)"} {
+					rows = append(rows, fmt.Sprintf("PCLMULQDQ $%d,%s,X2", selector, source))
+				}
+			} else {
+				for _, source := range []string{kind + "1", "64(BP)", "(SI)", "65(BP)", "1(SI)"} {
+					rows = append(rows, fmt.Sprintf("VPCLMULQDQ $%d,%s,%s2,%s3", selector, source, kind, kind))
+				}
+				for _, destination := range []string{kind + "1", kind + "2"} {
+					rows = append(rows, fmt.Sprintf("VPCLMULQDQ $%d,%s1,%s2,%s", selector, kind, kind, destination))
+				}
+				for _, destination := range []string{kind + "3", kind + "2"} {
+					rows = append(rows, fmt.Sprintf("VPCLMULQDQ $%d,%s2,%s2,%s", selector, kind, kind, destination))
+				}
+			}
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: rows[0], operations: rows})
+			operations += len(rows)
+		}
+	}
+	if len(kernels) != 18 || operations != 132 {
+		t.Fatal("CLMUL original-execution inventory changed", len(kernels), operations)
+	}
+	return kernels
+}
+
+// AVX2 does not imply VPCLMULQDQ's Y-width instruction. The native owner
+// checks both features and executes actual legacy/X and VEX/Y instructions;
+// compile-only hosts build this preflight without claiming CPU availability.
+func fixedLocalCLMULRuntimePreflight(t *testing.T, execution x86FloatCompareExecution) string {
+	t.Helper()
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "clmul.c"), filepath.Join(directory, "clmul")
+	const program = `#include <stdio.h>
+__attribute__((target("avx2,pclmul,vpclmulqdq"))) static int original_clmul(void) {
+    unsigned legacy, wide;
+    __asm__ volatile("pxor %%xmm0,%%xmm0; "
+                     "pclmulqdq $0,%%xmm0,%%xmm0; pmovmskb %%xmm0,%0; "
+                     "vpxor %%ymm0,%%ymm0,%%ymm0; "
+                     "vpclmulqdq $0,%%ymm0,%%ymm0,%%ymm0; "
+                     "vpmovmskb %%ymm0,%1; vzeroupper"
+                     : "=r"(legacy), "=r"(wide) :: "ymm0");
+    return legacy==0 && wide==0;
+}
+int main(void) {
+    __builtin_cpu_init();
+    int pclmul=!!__builtin_cpu_supports("pclmul");
+    int vpclmul=!!__builtin_cpu_supports("vpclmulqdq");
+    printf("fixed-frame native PCLMUL=%d VPCLMULQDQ=%d\n",pclmul,vpclmul);
+    return pclmul && vpclmul && original_clmul() ? 0 : 1;
+}
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	return executable
+}
+
+func TestGoAMD64FixedLocalCLMULRuntimeObjects(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	fixedLocalCLMULRuntimePreflight(t, execution)
+	fixedLocalVectorRuntime(t, execution, false, fixedLocalCLMULRuntimeKernels(t))
+}
+
+func TestGoAMD64FixedLocalVEXRuntimeObjects(t *testing.T) {
+	fixedLocalVEXRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
+
+func TestGoAMD64FixedLocalVEXRuntimeInventory(t *testing.T) {
+	kernels := fixedLocalVEXRuntimeKernels(t)
+	var witnesses []fixedLocalVEXWitness
+	for _, kernel := range kernels {
+		if len(kernel.operations) == 0 {
+			t.Fatal("runtime kernel has no observable operation", kernel.shape)
+		}
+		for _, source := range kernel.operations {
+			witnesses = append(witnesses, fixedLocalVEXWitness{owner: kernel.shape, source: source})
+		}
+	}
+	fixedLocalCheckVEXEncodings(t, witnesses)
+	t.Logf("540 official source witnesses grouped into %d real shape kernels, %d original-Go VEX operations including destination aliases",
+		len(kernels), len(witnesses))
+}
+
+func fixedLocalShiftRuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	var kernels []fixedLocalVEXRuntimeKernel
+	operations := 0
+	for index, name := range fixedLocalLegacyShiftNames() {
+		for _, count := range []int{0, 1, 15, 127} {
+			operation := fmt.Sprintf("%s $%d,X2", name, count)
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: operation, operations: []string{operation}})
+			operations++
+		}
+		if index >= 8 {
+			continue // Whole-byte shifts have only an immediate count.
+		}
+		var rows []string
+		for _, count := range []string{"X0", "X2", "64(BP)", "(SI)"} {
+			rows = append(rows, name+" "+count+",X2")
+		}
+		kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: rows[0], operations: rows})
+		operations += len(rows)
+	}
+	if len(kernels) != 56 || operations != 80 {
+		t.Fatal("complete legacy shift runtime inventory changed", len(kernels), operations)
+	}
+	return kernels
+}
+
+func TestGoAMD64FixedLocalShiftRuntimeObjects(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, fixedLocalShiftRuntimeKernels(t))
+}
+
+func fixedLocalScalarLaneRuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	rows := fixedLocalScalarLaneCases()
+	var kernels []fixedLocalVEXRuntimeKernel
+	owners := make(map[string]int)
+	for _, row := range rows {
+		first, _, _ := strings.Cut(row, "\n")
+		name, operands, _ := strings.Cut(first, " ")
+		index, exists := owners[name]
+		if !exists {
+			index, owners[name] = len(kernels), len(kernels)
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{shape: name})
+		}
+		operation := "MOVQ (SI),AX\n" + row
+		if strings.Contains(name, "INSR") {
+			args := strings.Split(operands, ",")
+			extract := strings.Replace(name, "INSR", "EXTR", 1)
+			operation += fmt.Sprintf("\n%s %s,%s,AX", extract, args[0], args[len(args)-1])
+		}
+		// The existing scratch observation includes this separate full-GP
+		// result slot. It exposes the high zeros of byte/word/dword extracts.
+		// Y0 immediately observes native stores; Y1/Y2 retain the insert's
+		// lane and upper-alias effects. Private transfers use bytes 65..72,
+		// so neither the GP slot nor its surrounding canaries overlap them.
+		operation += "\nMOVQ AX,88(BP)\nVMOVDQU (SI),Y0"
+		kernels[index].operations = append(kernels[index].operations, operation)
+	}
+	if len(rows) != 132 || len(kernels) != 16 {
+		t.Fatal("complete scalar-lane original-execution inventory changed", len(rows), len(kernels))
+	}
+	return kernels
+}
+
+func TestGoAMD64FixedLocalScalarLaneRuntimeObjects(t *testing.T) {
+	fixedLocalVectorRuntime(t, fixedLocalPackedCompileOnlyTools(t), false, fixedLocalScalarLaneRuntimeKernels(t))
+}
diff --git a/amd64_fixed_local_vex_shuffle_test.go b/amd64_fixed_local_vex_shuffle_test.go
new file mode 100644
index 000000000..9ebaab477
--- /dev/null
+++ b/amd64_fixed_local_vex_shuffle_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalVEXShuffleWitnesses(t *testing.T) []fixedLocalVEXWitness {
+	t.Helper()
+	// This existing audit checks all 30 VEX/EVEX rows, including the
+	// dword-only broadcast attribute; only 12 VEX rows enter this scope.
+	x86OfficialImmediateShuffleRows(t)
+	return fixedLocalVEXFamilyWitnesses(t, `^VPSHUF(D|HW|LW)$`, 12, 36)
+}
+
+func TestGoAMD64FixedLocalVEXShuffleOfficialEncodings(t *testing.T) {
+	fixedLocalCheckVEXEncodings(t, fixedLocalVEXShuffleWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXShufflePhysicalBoundaries(t *testing.T) {
+	fixedLocalCheckVEXPhysicalBoundaries(t, fixedLocalVEXShuffleWitnesses(t))
+}
+
+func TestGoAMD64FixedLocalVEXShuffleCompleteFamilies(t *testing.T) {
+	fixedLocalCheckVEXFamilies(t, fixedLocalVEXShuffleWitnesses(t))
+	for _, name := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, bank := range []string{"X", "Y"} {
+			t.Run(name+"/unaligned/"+bank, func(t *testing.T) {
+				fn, sig, _ := fixedLocalVEXFixture(t, name+" $255,65(BP),"+bank+"2")
+				if _, err := proveX86FixedLocal(fn, sig); err != nil {
+					t.Fatal("VEX full tuple incorrectly inherited legacy alignment", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalVEXShuffleImmediateDomainAndUpperZeros(t *testing.T) {
+	for _, name := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, bank := range []string{"X", "Y"} {
+			for _, alias := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/alias=%t", name, bank, alias), func(t *testing.T) {
+					destination := bank + "2"
+					if alias {
+						destination = bank + "1"
+					}
+					width := 16
+					if bank == "Y" {
+						width = 32
+					}
+					input := uint64(0x8040201000000000) | x86CallerVectorByteMask(int64(width))
+					for immediate := -128; immediate <= 255; immediate++ {
+						operation := fmt.Sprintf("%s $%d,%s1,%s", name, immediate, bank, destination)
+						ins := x86YMMReadSource(t, operation)
+						state := x86FixedLocalState{vectors: map[Reg]uint64{"Z1": input, "Z2": 0}, flags: x86ByteFlagsAll}
+						if err := fixedLocalVectorStep(&ins, &state, nil, 0); err != nil {
+							t.Fatal("complete VEX immediate domain or source-only dependency rejected", operation, err)
+						}
+						if state.vectors[x86CallerVectorRoot(Reg(destination))] != ^uint64(0) ||
+							!alias && state.vectors["Z1"] != input || state.flags != x86ByteFlagsAll {
+							t.Fatal("VEX shuffle failed upper-zero/source/FLAGS contract", operation, state)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalVEXShuffleBoundaries(t *testing.T) {
+	for _, name := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		t.Run(name+"/dispatch identity", func(t *testing.T) {
+			ins := x86YMMReadSource(t, "PSHUFD $0,X1,X2")
+			if _, known, err := x86UnmaskedVEXByteEffect(Op(name), ins, "amd64"); !known || err == nil {
+				t.Fatal("VEX dispatch changed a legacy source's upper-write contract", known, err)
+			}
+		})
+		for _, suffix := range []string{
+			" $0,Z1,Z2", " $0,X16,X2", " $0,X1,X16", " $0,X1,K1,X2",
+			".Z $0,X1,K1,X2", ".BCST $0,(SI),X2", " $0,M0,M1",
+			" $-129,X1,X2", " $256,X1,X2", " $0.5,X1,X2", " $missing,X1,X2",
+		} {
+			operation := name + suffix
+			t.Run(operation, func(t *testing.T) {
+				ins := x86YMMReadSource(t, operation)
+				if effect, known, err := fixedLocalVectorByteEffect(ins); known && err == nil {
+					t.Fatal("separate EVEX/MMX or invalid syntax acquired VEX metadata", operation, effect)
+				}
+			})
+		}
+		for _, args := range []string{
+			"$0,X7,X2", "$0,184(BP),X2", "$0,184(BP),Y2", "$0,256(BP),X2",
+			"$0,(AX),X2", "$0,a+8(FP),X2",
+		} {
+			t.Run(name+"/unproved/"+args, func(t *testing.T) {
+				operation := name + " " + args
+				fn, sig, source := fixedLocalVEXFixture(t, operation)
+				if args == "$0,(AX),X2" {
+					fixedLocalRequireNumericControl(t, fn, sig, source, "func Value(p *uint64,a uint64) uint64",
+						operation, 1, 16, false, "shufflevector <16 x i8>")
+					return
+				}
+				if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("uninitialized vector/private extent/numerical address gained backing", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalVEXShuffleObjects(t *testing.T) {
+	witnesses := fixedLocalVEXShuffleWitnesses(t)
+	for _, name := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, bank := range []string{"X", "Y"} {
+			witnesses = append(witnesses, fixedLocalVEXWitness{source: name + " $255,65(BP)," + bank + "2"})
+		}
+	}
+	if len(witnesses) != 42 {
+		t.Fatal("complete VEX shuffle source denominator changed", len(witnesses))
+	}
+	var assembly, declarations strings.Builder
+	for index, row := range witnesses {
+		source := fixedLocalVEXAssembly(row.source)
+		changed := strings.Replace(source, "VMOVDQU 64(BP),Y2\n", "", 1)
+		if changed == source {
+			t.Fatal("old destination removal did not change complete source")
+		}
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(changed, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(witnesses))
+}
diff --git a/amd64_fixed_local_vex_zero_runtime_linux_amd64_test.go b/amd64_fixed_local_vex_zero_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..047d25d42
--- /dev/null
+++ b/amd64_fixed_local_vex_zero_runtime_linux_amd64_test.go
@@ -0,0 +1,27 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalVEXLogicalZero(t *testing.T) {
+	// The Y-width integer identities require AVX2. The existing native probe
+	// checks the CPU, OS register state and actual AVX2 execution before Go.
+	fixedLocalVEXNativeTools(t)
+	assembly, declarations, count := fixedLocalVEXZeroProgram(t)
+	inputs := []uint64{0, 1, ^uint64(0), 0x0123456789abcdef}
+	var expected [][]string
+	for _, input := range inputs {
+		values := make([]string, count)
+		for index := range values {
+			// All four Y qwords must be zero, including an X result's upper
+			// alias. Only the independently stored input canary contributes.
+			values[index] = fmt.Sprintf("%016x", input)
+		}
+		expected = append(expected, values)
+	}
+	fixedLocalResultsRuntimeISA(t, assembly, declarations, inputs, expected, x86FloatCompareVEX)
+}
diff --git a/amd64_fixed_local_vex_zero_test.go b/amd64_fixed_local_vex_zero_test.go
new file mode 100644
index 000000000..567ee5540
--- /dev/null
+++ b/amd64_fixed_local_vex_zero_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type fixedLocalVEXZeroCase struct {
+	instruction         string
+	bank                string
+	source, destination int
+}
+
+func fixedLocalVEXZeroCases() []fixedLocalVEXZeroCase {
+	var cases []fixedLocalVEXZeroCase
+	for _, name := range x86LegacyLogicalMemoryNames {
+		if !fixedLocalLogicalZeroName(name) {
+			continue
+		}
+		for _, bank := range []string{"X", "Y"} {
+			for source := 0; source < 16; source++ {
+				for _, destination := range []int{source, (source + 1) % 16} {
+					instruction := fmt.Sprintf("V%s %s%d,%s%d,%s%d", name, bank, source, bank, source, bank, destination)
+					cases = append(cases, fixedLocalVEXZeroCase{instruction, bank, source, destination})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func fixedLocalVEXZeroBody(row fixedLocalVEXZeroCase) string {
+	// Read the complete Y alias even after an X-width zero, then consume all
+	// four qwords and the separately initialized input canary at 0(SP).
+	// OR prevents incorrect nonzero lanes from cancelling one another.
+	return row.instruction + fmt.Sprintf("\nVMOVDQU Y%d,16(SP)\n", row.destination) +
+		"MOVQ 16(SP),AX\nORQ 24(SP),AX\nORQ 32(SP),AX\nORQ 40(SP),AX\nADDQ 0(SP),AX"
+}
+
+func TestGoAMD64FixedLocalVEXLogicalZeroOfficialRows(t *testing.T) {
+	witnesses := fixedLocalVEXFamilyWitnesses(t,
+		`^V(ANDN?P[DS]|ORP[DS]|XORP[DS]|PANDN?|POR|PXOR)$`, 24, 72)
+	fixedLocalCheckVEXEncodings(t, witnesses)
+	fixedLocalCheckVEXPhysicalBoundaries(t, witnesses)
+}
+
+func TestGoAMD64FixedLocalVEXLogicalZeroComplete(t *testing.T) {
+	cases := fixedLocalVEXZeroCases()
+	if len(cases) != 384 {
+		t.Fatal("six zero identities by two widths, 16 sources and two destination aliases changed", len(cases))
+	}
+	var original strings.Builder
+	for index, row := range cases {
+		_, _, source := fixedLocalGPFixture(t, fixedLocalVEXZeroBody(row))
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, row := range cases {
+		t.Run(row.instruction, func(t *testing.T) {
+			fn, sig, _ := fixedLocalGPFixture(t, fixedLocalVEXZeroBody(row))
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("same-input logical zero acquired an undefined-input obligation", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVEXLogicalZeroConsumers(t *testing.T) {
+	for _, name := range x86LegacyLogicalMemoryNames {
+		for _, bank := range []string{"X", "Y"} {
+			for _, first := range []int{0, 1} {
+				for _, destination := range []int{0, 2} {
+					instruction := fmt.Sprintf("V%s %s%d,%s0,%s%d", name, bank, first, bank, bank, destination)
+					zero := first == 0 && fixedLocalLogicalZeroName(name)
+					t.Run(instruction, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, instruction)
+						_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64",
+							instruction+fmt.Sprintf("\nMOVQ X%d,AX\nMOVQ AX,ret0+0(FP)\nRET", destination))
+						resultErr := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "amd64")
+						if zero && resultErr != nil || !zero && !errors.Is(resultErr, ErrProbeNeedsContext) {
+							t.Fatal("ordinary result consumer changed its logical dependency", resultErr)
+						}
+						effect, known, err := x86UnmaskedVEXByteEffect(ins.Op, ins, "amd64")
+						if !known || err != nil || len(effect.operands) != 3 {
+							t.Fatal("complete VEX logical source lacks its typed effect", known, err)
+						}
+						for _, operand := range effect.operands {
+							if operand.read && zero {
+								t.Fatal("a logical zero still reads undefined register bytes", operand)
+							}
+						}
+						state := x86FixedLocalState{vectors: map[Reg]uint64{"Z0": 0, "Z1": 0, "Z2": 0, "Z16": 0xa55a}, flags: x86ByteFlagsAll}
+						before := cloneFixedLocalState(state)
+						err = fixedLocalVectorStep(&ins, &state, nil, 0)
+						if !zero {
+							if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(state.vectors, before.vectors) || state.flags != before.flags {
+								t.Fatal("nonzero logical input was invented or partially published", err, state)
+							}
+							return
+						}
+						before.vectors[Reg(fmt.Sprintf("Z%d", destination))] = ^uint64(0)
+						if err != nil || !reflect.DeepEqual(state.vectors, before.vectors) || state.flags != before.flags {
+							t.Fatal("logical zero changed a source alias, upper bytes or FLAGS", err, state)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalVEXLogicalZeroKeepsMemoryAndEncodingRoles(t *testing.T) {
+	for _, row := range []string{
+		"VPXOR 16(SP),Y0,Y0", "VANDNPS 16(SP),Y0,Y0",
+		"VXORPS X16,X16,X16", "VXORPS Y16,Y16,Y16", "VXORPS Z0,Z0,Z0",
+		"KMOVQ AX,K1\nVXORPS X0,X0,K1,X1", "KMOVQ AX,K1\nVXORPS.Z X0,X0,K1,X1",
+	} {
+		t.Run(row, func(t *testing.T) {
+			fn, sig, source := fixedLocalGPFixture(t, row+"\nMOVQ $0,AX")
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("logical zero granted memory, mask or high-bank authority", err)
+			}
+		})
+	}
+}
+
+func fixedLocalVEXZeroProgram(t *testing.T) (string, string, int) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	count := 0
+	for _, row := range fixedLocalVEXZeroCases() {
+		if row.source != 15 {
+			continue
+		}
+		_, _, source := fixedLocalGPFixture(t, fixedLocalVEXZeroBody(row))
+		name := fmt.Sprintf("Value%d", count)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		count++
+	}
+	if count != 24 {
+		t.Fatal("six zero identities by two widths and two destination aliases changed", count)
+	}
+	return assembly.String(), declarations.String(), count
+}
+
+func TestGoAMD64FixedLocalVEXLogicalZeroObjects(t *testing.T) {
+	assembly, declarations, count := fixedLocalVEXZeroProgram(t)
+	fixedLocalCompleteVectorObjects(t, assembly, declarations, count)
+}
diff --git a/amd64_fixed_local_void_test.go b/amd64_fixed_local_void_test.go
new file mode 100644
index 000000000..ea410b05d
--- /dev/null
+++ b/amd64_fixed_local_void_test.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func fixedLocalVoidFixture(t *testing.T, operation string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	original, _, _ := x86PrivateAlignedFrameAuditFixture(t, operation)
+	assembly := strings.Replace(original, "$160-40", "$160-32", 1)
+	assembly = strings.Replace(assembly, "MOVQ AX,ret+32(FP)\n", "", 1)
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a, b, c, d uint64)", assembly)
+	sig, err := DeriveGoFuncABI0Signature(pkg.Path+".Value", pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, request, file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+		Sigs:       map[string]FuncSig{sig.Name: sig},
+	}
+}
+
+func fixedLocalVoidAssembly(file *File) string {
+	var source strings.Builder
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			source.WriteString(ins.Raw + "\n")
+		}
+	}
+	return source.String()
+}
+
+func TestGoAMD64FixedLocalVoidActualTargetBoundaries(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ goTarget, triple string }{
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+		{"linux/386", "i386-unknown-linux-gnu"},
+		{"windows/386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.goTarget, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+			request.Target, options.TargetTriple = target.goTarget, target.triple
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if strings.HasSuffix(target.goTarget, "/386") || target.goTarget == "windows/amd64" && err != nil {
+				if source != nil || !errors.Is(err, ErrProbeNeedsContext) ||
+					target.goTarget == "windows/amd64" && !strings.Contains(err.Error(), "SSEHUNWINDINFO") {
+					t.Fatalf("unclosed target unexpectedly acquired void backing: %v", err)
+				}
+				t.Logf("unchanged original target observation boundary, not an LLVM object: %v", err)
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "void-target.ll", "void-target.o", ir)
+			})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVoidAllPathMemoryAndReturnNegatives(t *testing.T) {
+	pkg, _, file, options := fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+	base, sig := fixedLocalVoidAssembly(file), options.Sigs[pkg.Path+".Value"]
+	mutations := map[string]string{
+		"SP not restored":      strings.Replace(base, "MOVQ R11,SP", "MOVQ $0,R10", 1),
+		"incoming BP read":     strings.Replace(base, "MOVQ AX,16(SP)", "MOVQ BP,AX\nMOVQ AX,16(SP)", 1),
+		"incoming R14 read":    strings.Replace(base, "MOVQ AX,16(SP)", "MOVQ R14,AX\nMOVQ AX,16(SP)", 1),
+		"input FP store":       strings.Replace(base, "MOVQ X0,AX", "MOVQ AX,a+0(FP)", 1),
+		"private FP escape":    strings.Replace(base, "MOVQ X0,AX", "MOVQ R11,a+0(FP)", 1),
+		"restored input store": strings.Replace(base, "MOVQ R11,SP\nRET", "MOVQ R11,SP\nMOVQ AX,a+0(FP)\nRET", 1),
+		"restored FP escape":   strings.Replace(base, "MOVQ R11,SP\nRET", "MOVQ R11,SP\nMOVQ R11,a+0(FP)\nRET", 1),
+		"external escape":      strings.Replace(base, "MOVQ X0,AX", "MOVQ R11,(AX)", 1),
+		"unbound local alias":  strings.Replace(base, "PADDQ 16(SP)", "PADDQ 16(SI)", 1),
+		"private read extent":  strings.Replace(base, "PADDQ 16(SP)", "PADDQ 152(SP)", 1),
+		"saved BP overlap":     strings.Replace(base, "MOVQ AX,16(SP)", "MOVQ AX,160(SP)", 1),
+		"bad alignment":        strings.Replace(base, "ADDQ $32,SP", "ADDQ $33,SP", 1),
+		"pointer as numeric":   strings.Replace(base, "PADDQ 16(SP)", "PADDQ 96(SP)", 1),
+		"pointer spill torn":   strings.Replace(base, "MOVQ 96(SP),R11", "MOVB $1,96(SP)\nMOVQ 96(SP),R11", 1),
+		"raw instruction":      strings.Replace(base, "PADDQ", "BYTE $0x90\nPADDQ", 1),
+		"unknown native call":  strings.Replace(base, "PADDQ", "CALL ·Other(SB)\nPADDQ", 1),
+		"unknown dead effect":  base + "SYSCALL\n",
+		"loop unknown input":   strings.Replace(base, "MOVQ AX,16(SP)", "again:\nCMPQ AX,R10\nJNE again\nMOVQ AX,16(SP)", 1),
+		"overflow address":     strings.Replace(base, "ADDQ $32,SP", "ADDQ $9223372036854775807,SP", 1),
+	}
+	for missing := 0; missing < 16; missing++ {
+		var stores strings.Builder
+		for index := 0; index < 16; index++ {
+			if index != missing {
+				fmt.Fprintf(&stores, "MOVB $1,%d(SP)\n", 16+index)
+			}
+		}
+		mutations[fmt.Sprintf("missing local byte %02d", missing)] = strings.Replace(base, "MOVQ AX,16(SP)\nMOVQ CX,24(SP)\n", stores.String(), 1)
+	}
+	for name, source := range mutations {
+		t.Run(name, func(t *testing.T) {
+			changed, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := proveX86FixedLocal(changed.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("void return bypassed complete source safety: %v", err)
+			}
+		})
+	}
+	for _, mutation := range []string{"nonvoid no result", "void result slot", "empty return", "multiple result slots"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := sig
+			switch mutation {
+			case "nonvoid no result":
+				changed.Ret = I64
+			case "empty return":
+				changed.Ret = ""
+			case "void result slot":
+				changed.Frame.Results = []FrameSlot{{Offset: 32, Type: I64}}
+			case "multiple result slots":
+				changed.Ret = I64
+				changed.Frame.Results = []FrameSlot{{Offset: 32, Type: I64}, {Offset: 40, Type: I64}}
+			}
+			if _, err := proveX86FixedLocal(file.Funcs[0], changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("inconsistent result contract obtained a void exemption: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVoidActualDAGInitialization(t *testing.T) {
+	pkg, request, file, options := fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+	base := fixedLocalVoidAssembly(file)
+	for _, missing := range []bool{false, true} {
+		t.Run(fmt.Sprintf("missing=%v", missing), func(t *testing.T) {
+			join := "MOVQ CX,24(SP)\nCMPQ AX,CX\nJEQ joined\nMOVQ CX,24(SP)\njoined:"
+			if missing {
+				join = "CMPQ AX,CX\nJEQ joined\nMOVQ CX,24(SP)\njoined:"
+			}
+			assembly := strings.Replace(base, "MOVQ CX,24(SP)", join, 1)
+			if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			actual, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			// Complete actual Go objects accept both bodies. Only the all-path
+			// initialized body may obtain the separate private-byte certificate.
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, actual, options)
+			if missing {
+				if !errors.Is(err, ErrProbeNeedsContext) || len(bound.Sigs) != 0 {
+					t.Fatalf("void DAG bypassed a missing predecessor write: %v", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixedLocalAPIs(t, pkg, actual, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "fixed_local_native") {
+					t.Fatalf("actual initialized void DAG did not consume its certificate: %v", err)
+				}
+			})
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVoidCompositeNeedsCompleteBinding(t *testing.T) {
+	for _, test := range []struct {
+		name, declaration string
+		args, n           int64
+	}{
+		{"pointer", "func Value(a *uint64, n uint64)", 16, 8},
+		{"slice", "func Value(a []byte, n uint64)", 32, 24},
+		{"array pointer", "func Value(a *[16]byte, n uint64)", 16, 8},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := fixedLocalTransportAssembly("Value", int(test.args), "")
+			assembly = strings.Replace(assembly, "n+40(FP)", fmt.Sprintf("n+%d(FP)", test.n), 1)
+			pkg, request := goAMD64FrameTypedFixture(t, test.declaration, assembly)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			observed := source.functions[pkg.Path+".Value"]
+			if observed.transport != goAMD64FrameCompositeTransport || observed.signature.Ret != Void || len(observed.code) == 0 {
+				t.Fatal("void composite observation lost its original role/object")
+			}
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+				Sigs:       map[string]FuncSig{observed.signature.Name: observed.signature},
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			fixedLocalAPIs(t, pkg, file, options, fixedLocalRequireContext)
+			if bound, err := source.BindFixedLocal(ctx, pkg, file, options); err != nil || len(bound.Sigs) != 1 {
+				t.Fatalf("complete void composite transport lacks its independent frame proof: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalVoidThreeAPIsRequireExactLiveWitness(t *testing.T) {
+	pkg, request, file, options := fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := pkg.Path + ".Value"
+	for _, mutation := range []string{"JSON", "return", "input slot", "source"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := bound
+			changed.Sigs, err = cloneFixedLocalSigs(bound.Sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := changed.Sigs[name]
+			if mutation != "JSON" {
+				sig.x86FixedLocal = bound.Sigs[name].x86FixedLocal
+			}
+			changedFile := *file
+			changedFile.Funcs = append([]Func(nil), file.Funcs...)
+			switch mutation {
+			case "return":
+				sig.Ret = I64
+			case "input slot":
+				sig.Frame.Params[0].Offset++
+			case "source":
+				changedFile.Funcs[0].FrameSize += 8
+				changedFile.Funcs[0].Instrs = append([]Instr(nil), file.Funcs[0].Instrs...)
+				changedFile.Funcs[0].Instrs[0].Raw = strings.Replace(changedFile.Funcs[0].Instrs[0].Raw, "$160-32", "$168-32", 1)
+			}
+			changed.Sigs[name] = sig
+			fixedLocalAPIs(t, pkg, &changedFile, changed, fixedLocalRequireContext)
+		})
+	}
+	for _, mutation := range fixedLocalTypedRoleMutations {
+		t.Run(mutation, func(t *testing.T) {
+			fixedLocalTypedRoleMutation(t, source, name, mutation)
+			fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+		})
+	}
+	encoded, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var clone GoAMD64FrameSource
+	if err := json.Unmarshal(encoded, &clone); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := clone.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("JSON clone recreated void source authority: %v", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+	if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("closed observer rebound void source: %v", err)
+	}
+	// Cancellation revokes a separately captured live void binding too, not
+	// merely the already closed source used above.
+	pkg, request, file, options = fixedLocalVoidFixture(t, "PADDQ 16(SP),X0")
+	source = requireGoAMD64FrameCapture(t, pkg, request)
+	child, stop := context.WithCancel(ctx)
+	defer stop()
+	bound, err = source.BindFixedLocal(child, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stop()
+	fixedLocalAPIs(t, pkg, file, bound, fixedLocalRequireContext)
+	if source.ready {
+		t.Fatal("cancelled binding retained a live source token")
+	}
+}
+
+func TestGoAMD64FixedLocalVoidActualNumericSourceAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, operation := range fixedLocalNativeOperations {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			pkg, request, file, options := fixedLocalVoidFixture(t, operation)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			observed := source.functions[pkg.Path+".Value"]
+			if observed.transport != goAMD64FrameNumericTransport || observed.signature.Ret != Void ||
+				len(observed.signature.Frame.Results) != 0 || observed.args != 32 || observed.locals != 168 || len(observed.code) == 0 {
+				t.Fatalf("void fixture lacks complete actual numeric Go object identity: %+v", observed)
+			}
+			object := filepath.Join(source.owned, request.AssemblyFile+".o")
+			t.Logf("actual stock-Go void object: args=%d locals=%d bytes=%d object_sha=%x listing_sha=%x", observed.args, observed.locals, len(observed.code), source.inputs[object], source.inputs[object+".listing"])
+			// The ordinary translation API must still lack native backing before
+			// the live source token binds this complete numeric function.
+			fixedLocalAPIs(t, pkg, file, options, fixedLocalRequireContext)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatalf("actual Go accepted the numeric void source but its local backing is rejected: %v", err)
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "define void") || !strings.Contains(ir, "fixed_local_native") || !strings.Contains(ir, "asm sideeffect") {
+					t.Fatalf("sealed void source failed its compile-only native consumer: %v", err)
+				}
+				compileLLVMToObject(t, llc, bound.TargetTriple, "void-local.ll", "void-local.o", ir)
+				compileLLVMToObject(t, llc, bound.TargetTriple, "void-local-opt.ll", "void-local-opt.o", x86MulDivRoundOptimize(t, ir))
+			})
+			if _, err := os.Stat(object); err != nil {
+				t.Fatal(err)
+			}
+			t.Log("compile-only void local operations; no observable numerical result or external-library runtime claim")
+		})
+	}
+}
diff --git a/amd64_fixed_local_work_charge_test.go b/amd64_fixed_local_work_charge_test.go
new file mode 100644
index 000000000..6a9179eb1
--- /dev/null
+++ b/amd64_fixed_local_work_charge_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FixedLocalOrdinaryFullWorkBoundary(t *testing.T) {
+	fn, sig := fixedLocalReplayFixture(t, strings.Repeat("NOP\n", 55))
+	fn.FrameSize = 64 << 10
+	_, instructions, err := fixedLocalEdges(fn)
+	if err != nil || len(instructions) != 64 {
+		t.Fatal("independent 64-transfer ordinary fixture changed", len(instructions), err)
+	}
+	for _, deficit := range []int64{0, 1} {
+		t.Run(fmt.Sprint(deficit), func(t *testing.T) {
+			budget := x86FixedLocalBudget{steps: 1 << 18, bytes: (64 << 20) - deficit}
+			proven, err := proveX86FixedLocalAttempt(fn, sig, &budget, false)
+			if deficit == 0 {
+				if err != nil || proven.x86FixedLocal == nil || budget.bytes != 0 || budget.steps != (1<<18)-64*16 {
+					t.Fatalf("ordinary original full allowance: %+v, %v", budget, err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(proven, fn) {
+				t.Fatal("one-byte-short ordinary replay must reject atomically", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionVectorWork(t *testing.T) {
+	body := strings.Replace(fixedLocalLayoutPingPong, "ret+16(FP)", "ret+8(FP)", 1)
+	body = strings.Replace(body, "loop:\n", "loop:\n"+strings.Repeat("PADDQ X0,X0\n", 1024), 1)
+	source := "TEXT ·Value(SB),4,$4096-16\nMOVQ a+0(FP),CX\nMOVQ $0,AX\n" +
+		"MOVQ AX,0(SP)\nMOVQ AX,8(SP)\nMOVOU 0(SP),X0\n" + body
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	_, sig := fixedLocalReplayFixture(t, "")
+	budget := x86FixedLocalBudget{steps: 1 << 18, bytes: 64 << 20}
+	proven, err := proveX86FixedLocalAttempt(fn, sig, &budget, true)
+	t.Logf("partitioned vector replay: remaining_steps=%d remaining_bytes=%d error=%v", budget.steps, budget.bytes, err)
+	if err != nil || proven.x86FixedLocal == nil {
+		t.Fatal("initialized register work must not scan a whole frame per instruction", err)
+	}
+	used := (1 << 18) - budget.steps
+	if used < 16*2*1024 || budget.bytes <= 0 {
+		t.Fatal("both layouts and sixteen replays must retain instruction and byte accounting", used, budget)
+	}
+	budget = x86FixedLocalBudget{steps: used - 1, bytes: 64 << 20}
+	proven, err = proveX86FixedLocalAttempt(fn, sig, &budget, true)
+	t.Logf("partitioned step deficit: remaining_steps=%d remaining_bytes=%d error=%v", budget.steps, budget.bytes, err)
+	if !errors.Is(err, ErrProbeNeedsContext) || budget.steps != 0 || !reflect.DeepEqual(proven, fn) {
+		t.Fatal("register-only work still requires every step, with atomic failure", budget, err)
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionClonePrecharge(t *testing.T) {
+	fn, sig := fixedLocalReplayFixture(t, "")
+	proof := &x86FixedLocalProof{frame: 64}
+	// Initial state: two one-word bitmaps (16 bytes), one SP map entry (64).
+	// Reading and copying that payload costs 160 before the first instruction.
+	budget := x86FixedLocalBudget{steps: 100, bytes: 159}
+	var layouts x86FixedLocalLayoutGraph
+	err := replayX86FixedLocal(&fn, sig, proof, 0, &budget, nil, &layouts)
+	if !errors.Is(err, ErrProbeNeedsContext) || budget.steps != 100 || budget.bytes != 159 || len(layouts.nodes) != 0 {
+		t.Fatal("state copy must be charged before executing or publishing", budget, err)
+	}
+	for _, ins := range fn.Instrs {
+		if len(ins.x86FixedLocalMemory) != 0 {
+			t.Fatal("failed clone debit published an access")
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionCandidateWork(t *testing.T) {
+	for _, count := range []int{3, 17} {
+		for _, deficit := range []int64{0, 1} {
+			t.Run(fmt.Sprintf("%d/%d", count, deficit), func(t *testing.T) {
+				states := make(map[int]x86FixedLocalState)
+				layouts := x86FixedLocalLayouts{at: map[int][]int{5: {}}, nodes: make([]x86FixedLocalLayoutNode, count)}
+				for index := 0; index < count; index++ {
+					states[index] = x86FixedLocalState{
+						pointers: map[Reg]int64{SP: 0, "R14": int64(index * 8)}, known: map[Reg]uint8{AX: 255},
+						bytes: x86FixedLocalByteSet{0}, booleanBytes: x86FixedLocalByteSet{0},
+					}
+					layouts.nodes[index].pc = 5
+					layouts.at[5] = append(layouts.at[5], index)
+				}
+				// Each state has 16 bitmap bytes + three 64-byte map entries.
+				// One comparison costs 64 lookup + 2*208 prior + 208 incoming.
+				const perCandidate = 688
+				budget := x86FixedLocalBudget{steps: 100, bytes: int64(count*count*perCandidate) - deficit}
+				for query := 0; query < count; query++ {
+					before := append([]x86FixedLocalLayoutNode(nil), layouts.nodes...)
+					target, err := layouts.target(states, 0, 0, 5, states[count-1], &budget)
+					if deficit != 0 && query == count-1 {
+						if !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(before, layouts.nodes) || budget.bytes != perCandidate-1 {
+							t.Fatal("last candidate must reject before changing an edge", budget, err)
+						}
+					} else if err != nil || target != count-1 {
+						t.Fatal("complete candidate inventory must be inspected", target, err)
+					}
+				}
+				if budget.steps != 100 || deficit == 0 && budget.bytes != 0 {
+					t.Fatal("candidate comparisons require quadratic work, not instruction steps", budget)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionUnboundCandidateWork(t *testing.T) {
+	state := x86FixedLocalState{pointers: map[Reg]int64{SP: 0}, known: map[Reg]uint8{AX: 255}}
+	layouts := x86FixedLocalLayouts{
+		at: map[int][]int{5: {0, 1}}, nodes: []x86FixedLocalLayoutNode{{pc: 5}, {pc: 5}},
+	}
+	// One bound candidate costs 64+3*128, one missing state 64+128.
+	budget := x86FixedLocalBudget{steps: 10, bytes: 640}
+	target, err := layouts.target(map[int]x86FixedLocalState{0: state}, 0, 0, 5, state, &budget)
+	if err != nil || target != 0 || budget.bytes != 0 || budget.steps != 10 {
+		t.Fatal("missing candidates still require lookup and incoming-state work", target, budget, err)
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionStatePayload(t *testing.T) {
+	state := x86FixedLocalState{
+		bytes: make(x86FixedLocalByteSet, 2), booleanBytes: make(x86FixedLocalByteSet, 3),
+		pointers: map[Reg]int64{SP: 0}, opaque: map[Reg]x86FixedLocalOrigins{AX: {}},
+		opaqueCells: map[int64]x86FixedLocalOrigins{0: {}}, booleans: map[Reg]uint8{BX: 1},
+		constants: map[Reg]int64{CX: 0}, ranges: map[Reg]x86UnsignedRange{DX: {}},
+		known: map[Reg]uint8{SI: 255}, vectors: map[Reg]uint64{"X0": 255}, masks: map[Reg]bool{"K1": true},
+		addresses: map[int64]int64{8: 0}, results: map[int]bool{0: true}, savedBP: &x86FixedLocalSavedBP{},
+	}
+	if got := fixedLocalStateWork(state); got != 5*8+11*64+128 {
+		t.Fatal("both bitmaps, all eleven maps and saved BP must be counted", got)
+	}
+	if got := fixedLocalStateWork(x86FixedLocalState{}); got != 0 {
+		t.Fatal("an absent state has no payload", got)
+	}
+	// A single bounded allocation exercises saturation before multiplication.
+	large := x86FixedLocalState{bytes: make(x86FixedLocalByteSet, (64<<20)/8+1)}
+	if got := fixedLocalStateWork(large); got != (64<<20)+1 {
+		t.Fatal("oversized state work must saturate above the unchanged cap", got)
+	}
+}
+
+func TestGoAMD64FixedLocalPartitionVectorWorkProjection(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-0\nPADDQ X0,X0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	effects, err := fixedLocalEffectPlan(file.Funcs[0], nil)
+	if err != nil || len(effects) != 1 {
+		t.Fatal("complete vector grammar did not select the single effect", err)
+	}
+	var original x86TypedByteEffect
+	for _, effect := range effects {
+		original = effect
+	}
+	for _, kind := range []OperandKind{OpReg, OpImm, OpMem, OpSym, OpFP} {
+		effect := original
+		effect.operands = append([]x86TypedByteOperand(nil), original.operands...)
+		effect.operands[0].operand.Kind = kind
+		if got := fixedLocalVectorRegisterWork(effect); got != (kind == OpReg || kind == OpImm) {
+			t.Fatal("only the register/immediate projection has bounded register work", kind, got)
+		}
+	}
+	for _, contract := range []string{"dynamic", "unknown upper", "invalid upper", "missing alignment"} {
+		effect := original
+		switch contract {
+		case "dynamic":
+			effect.dynamicMemory = true
+		case "unknown upper":
+			effect.vector.upperWrite = x86TypedVectorUpperUnknown
+		case "invalid upper":
+			effect.vector.upperWrite = 255
+		case "missing alignment":
+			effect.vector.memoryAlignment = 0
+		}
+		if fixedLocalVectorRegisterWork(effect) {
+			t.Fatal("an open or memory effect acquired the register-only discount", contract)
+		}
+	}
+}
diff --git a/amd64_fixup_old_destination_test.go b/amd64_fixup_old_destination_test.go
new file mode 100644
index 000000000..5f1b930ed
--- /dev/null
+++ b/amd64_fixup_old_destination_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86FixupOriginalSourceSHA = "42757d53a686c410e0c26dd1a0b3fc046098d5b96a431553e3604bcdbf52703c"
+
+const x86FixupRuntimeDeclaration = `func fixupimmsemantics(out *[289]byte,
+	src32 *[16]uint32, table32 *[16]uint32, old32 *[16]uint32,
+	src64 *[8]uint64, table64 *[8]uint64, old64 *[8]uint64, mask uint64)`
+
+func x86FixupOriginalRuntimeSource(t *testing.T) string {
+	t.Helper()
+	source := x86X87FunctionLiteral(t, "amd64_lower_fixupimm_test.go", "qualifyAMD64FixupImmediateRuntimeSemantics", "source")
+	if actual := fmt.Sprintf("%x", sha256.Sum256([]byte(source))); actual != x86FixupOriginalSourceSHA {
+		t.Fatal("complete original FIXUPIMM source changed", actual)
+	}
+	return source
+}
+
+// Table response 0000 retains the active old DEST even with zero masking.
+// Supply the old32 input expected by the unchanged independent C reference;
+// the complete historical source remains an independent Context negative.
+func x86FixupRuntimeSource(t *testing.T, original string) string {
+	t.Helper()
+	if actual := fmt.Sprintf("%x", sha256.Sum256([]byte(original))); actual != x86FixupOriginalSourceSHA {
+		t.Fatal("foreign source acquired FIXUPIMM runtime fixture transport", actual)
+	}
+	const instruction = "\tVFIXUPIMMPS.Z $0, Z0, Z1, K1, Z3\n"
+	if strings.Count(original, instruction) != 1 {
+		t.Fatal("complete FIXUPIMM runtime lost its unique old32 destination consumer")
+	}
+	return strings.Replace(original, instruction, "\tVMOVDQU32 0(DX), Z3\n"+instruction, 1)
+}
+
+func TestX86FixupRuntimeOriginalSourceRequiresOldDestination(t *testing.T) {
+	source := x86FixupOriginalRuntimeSource(t)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, x86FixupRuntimeDeclaration,
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			x86VectorScratchCodegenControl(t, source, x86FixupRuntimeDeclaration,
+				"amd64", "x86_64-unknown-linux-gnu", ir, err)
+		})
+	}
+}
+
+func TestX86FixupRuntimeInputMatchesIndependentOldDestinationReference(t *testing.T) {
+	original := x86FixupOriginalRuntimeSource(t)
+	source := x86FixupRuntimeSource(t, original)
+	// Check the complete actual program before invoking any translator API.
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, x86FixupRuntimeDeclaration,
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("actual runtime input does not provide the old32 required by its independent C reference", err)
+			}
+		})
+	}
+}
+
+func TestX86FixupCorrectedRuntimeCompleteThreeAPITargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	original := x86FixupOriginalRuntimeSource(t)
+	source := x86FixupRuntimeSource(t, original)
+	const load = "\tVMOVDQU32 0(DX), Z3\n"
+	if strings.Count(source, load) != 1 || strings.Replace(source, load, "", 1) != original {
+		t.Fatal("runtime repair changed more than the unique old32 input load")
+	}
+	// These are complete public-program objects, not executed native semantics.
+	for _, triple := range []string{
+		"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, x86FixupRuntimeDeclaration,
+						"amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("corrected complete FIXUPIMM program did not translate", err)
+					}
+					for _, optimize := range []bool{false, true} {
+						t.Run(fmt.Sprintf("IR_O2=%t", optimize), func(t *testing.T) {
+							input := ir
+							if optimize {
+								input = x86DwordProductIROptimize(t, ir)
+							}
+							x86PackedStringCompileObject(t, llc, triple, input, "-O0")
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FixupImmediateZeroingStillReadsOldActiveDestination(t *testing.T) {
+	var directory strings.Builder
+	directory.WriteString("TEXT fixupoldinputs(SB),$0-0\n")
+	var rows []struct {
+		name, instruction string
+		active            int
+	}
+	for _, member := range go127FixupImmediateSpecs() {
+		banks := []string{"X", "Y", "Z"}
+		if member.scalar {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+			active := width
+			if member.scalar {
+				active = member.laneBits / 8
+			}
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				op, mask := member.op, ""
+				if mode != "plain" {
+					mask = ", K1"
+				}
+				if mode == "zero" {
+					op += ".Z"
+				}
+				instruction := fmt.Sprintf("%s $0, %s0, %s1%s, %s2", op, bank, bank, mask, bank)
+				fmt.Fprintf(&directory, "\t%s\n", instruction)
+				rows = append(rows, struct {
+					name, instruction string
+					active            int
+				}{member.op + "/" + bank + "/" + mode, instruction, active})
+			}
+		}
+	}
+	directory.WriteString("\tRET\n")
+	// Go's full four-name, eight-width register directory is independent of the
+	// result model. Zeroing applies to inactive lanes, not table response 0000.
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", directory.String())
+	for _, row := range rows {
+		t.Run(row.name, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction)
+			state := x86FloatingHelperInitializedState()
+			before := state.clone()
+			if accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, "amd64", true); !accepted || !known {
+				t.Fatal("complete old destination lost its initialized transfer")
+			}
+			if !reflect.DeepEqual(state, before) {
+				t.Fatal("FIXUPIMM changed independent inputs, FLAGS, DF, pointers or upper-byte knowledge")
+			}
+			for missing := 0; missing < row.active; missing++ {
+				state = before.clone()
+				state.writeVector(2, 64, state.vectorBytes(2)&^(uint64(1)<<uint(missing)), false)
+				initial := state.clone()
+				if accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, "amd64", true); accepted || !known ||
+					!reflect.DeepEqual(state, initial) {
+					t.Fatal("missing active DEST byte was invented or failure partly changed state", missing)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_float_add_sub_forms.go b/amd64_float_add_sub_forms.go
new file mode 100644
index 000000000..b8c1c541f
--- /dev/null
+++ b/amd64_float_add_sub_forms.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+type x86FloatAddSubForm = x86FloatArithmeticForm
+
+func x86FloatAddSubProperties(ins Instr, arch string) (x86FloatAddSubForm, bool, error) {
+	return x86FloatArithmeticProperties(ins, arch, x86FloatAddSubtract)
+}
diff --git a/amd64_float_add_sub_forms_test.go b/amd64_float_add_sub_forms_test.go
new file mode 100644
index 000000000..1c10e60c7
--- /dev/null
+++ b/amd64_float_add_sub_forms_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86FloatAddSubOpcodes() []string {
+	return []string{"ADDPS", "ADDPD", "ADDSS", "ADDSD", "SUBPS", "SUBPD", "SUBSS", "SUBSD", "VADDPS", "VADDPD", "VADDSS", "VADDSD", "VSUBPS", "VSUBPD", "VSUBSS", "VSUBSD"}
+}
+
+func x86FloatArithmeticFamilyCount(family x86FloatArithmeticFamily) int {
+	count := 0
+	for _, spec := range x86FloatArithmeticSpecs {
+		if spec.family() == family {
+			count++
+		}
+	}
+	return count
+}
+
+func TestX86FloatAddSubEveryGoOpcodeAttribute(t *testing.T) {
+	if x86FloatArithmeticFamilyCount(x86FloatAddSubtract) != 16 {
+		t.Fatal("incomplete floating add/sub family")
+	}
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // historical source builds still execute grammar/LLVM tests
+	}
+	dir := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	for _, filename := range []string{"asm6.go", "avx_optabs.go"} {
+		data, err := os.ReadFile(filepath.Join(dir, filename))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range x86FloatAddSubOpcodes() {
+			scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+			bits := 32
+			if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+				bits = 64
+			}
+			legacy := !strings.HasPrefix(opcode, "V")
+			if filename == "asm6.go" != legacy {
+				continue
+			}
+			mode := amd64BinaryFloatingAdd
+			if strings.Contains(opcode, "SUB") {
+				mode = amd64BinaryFloatingSub
+			}
+			want := x86FloatArithmeticSpec{bits, legacy, scalar, mode}
+			if got := x86FloatArithmeticSpecs[Op(opcode)]; got != want {
+				t.Fatalf("%s spec differs from independent mnemonic: %+v/%+v", opcode, got, want)
+			}
+			if legacy {
+				if !strings.Contains(string(data), "{A"+opcode+", yxm,") {
+					t.Fatalf("Go legacy yxm changed: %s", opcode)
+				}
+				continue
+			}
+			prefix := "{as: A" + opcode + ", ytab: "
+			start := strings.Index(string(data), prefix)
+			if start < 0 {
+				t.Fatalf("Go omits %s", opcode)
+			}
+			row := strings.SplitN(string(data)[start:], "\n\t}},", 2)[0]
+			table := "_yvaddpd"
+			if scalar {
+				table = "_yvaddsd"
+			}
+			if !strings.HasPrefix(row, prefix+table+",") {
+				t.Fatalf("Go grammar changed: %s", row)
+			}
+			seen := 0
+			for _, line := range strings.Split(row, "\n") {
+				if !strings.Contains(line, "avxEscape | evex") {
+					continue
+				}
+				seen++
+				if !strings.Contains(line, "evexZeroingEnabled") || strings.Contains(line, "evexSaeEnabled") ||
+					strings.Contains(line, "evexRoundingEnabled") != (scalar || strings.Contains(line, "evex512")) ||
+					strings.Contains(line, fmt.Sprintf("evexBcstN%d", bits/8)) != !scalar {
+					t.Fatalf("%s opcode attribute changed: %s", opcode, line)
+				}
+			}
+			if scalar && seen != 1 || !scalar && seen != 3 {
+				t.Fatalf("%s incomplete EVEX row count %d", opcode, seen)
+			}
+		}
+	}
+}
+
+func x86FloatAddSubFormats(arch string) []string {
+	var rows []string
+	for _, opcode := range x86FloatAddSubOpcodes() {
+		scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		if !strings.HasPrefix(opcode, "V") {
+			rows = append(rows, opcode+" X0,X1", opcode+" 8(AX),X1")
+			continue
+		}
+		banks := []string{"X", "Y", "Z"}
+		if scalar {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"", "merge", "zero"} {
+				if arch == "386" && mode != "" {
+					continue
+				}
+				mask, zero := "", ""
+				if mode != "" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					zero = ".Z"
+				}
+				args := bank + "0," + bank + "1," + mask + bank + "2"
+				memory := "(AX)," + bank + "1," + mask + bank + "2"
+				rows = append(rows, opcode+zero+" "+args, opcode+zero+" "+memory)
+				if !scalar {
+					rows = append(rows, opcode+".BCST"+zero+" "+memory)
+				}
+				if scalar || bank == "Z" {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						rows = append(rows, opcode+"."+rounding+zero+" "+args)
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86FloatAddSubCompleteGoGrammarAndFiveLLVMTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		sigs := map[string]FuncSig{}
+		for index, row := range x86FloatAddSubFormats(arch) {
+			name := fmt.Sprintf("addsub%d", index)
+			entry := fmt.Sprintf("TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+			file, err := Parse(ArchAMD64, entry)
+			if err != nil {
+				t.Fatal(err)
+			}
+			form, recognized, err := x86FloatAddSubProperties(file.Funcs[0].Instrs[1], arch)
+			if !recognized || err != nil || form.byteWidth == 0 {
+				t.Fatalf("%s/%s: %v", arch, row, err)
+			}
+			source.WriteString(entry)
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+		requireX86GoAssemblerResult(t, arch, source.String(), true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "addsub-formats.ll", "addsub-formats.o", ir)
+		}
+		t.Logf("%s: %d independent Go add/sub formats", arch, len(sigs))
+	}
+}
+
+func TestX86FloatAddSubRejectsMalformedBeforeEmission(t *testing.T) {
+	for _, row := range []string{
+		"ADDPS X0,Y1", "ADDSD X0,AX", "SUBSS X0,X16", "SUBPD.SAE X0,X1",
+		"VADDPS X0,X1", "VADDPD X0,Y1,Y2", "VADDSS Y0,Y1,Y2", "VSUBSD X0,X1,K0,X2",
+		"VADDPS.Z X0,X1,X2", "VADDPS.BCST X0,X1,X2", "VADDSS.BCST (AX),X1,X2",
+		"VSUBPS.SAE Z0,Z1,Z2", "VADDPS.RD_SAE X0,X1,X2", "VSUBSD.RU_SAE (AX),X1,X2",
+		"VADDPS. X0,X1,X2", "VSUBPS.Z.BCST (AX),Z1,K1,Z2",
+		"VADDPS $data(SB),X1,X2", "VSUBSS (AX)(SP*2),X1,X2", "VADDPD 2147483648(AX),X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", false)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				return // syntax rejection is also pre-emission
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerFloatAddSub(ins.Op, ins)
+			if !known || term || err == nil || output.String() != before {
+				t.Fatalf("invalid add/sub emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+}
+
+func TestX86FloatAddSubDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, opcode := range x86FloatAddSubOpcodes() {
+		args := "X0,X1"
+		if strings.HasPrefix(opcode, "V") {
+			args += ",X2"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+opcode+" "+args+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, identity := range []Op{"", Op(opcode), Op(strings.ToLower(opcode)), "UNKNOWN", "VADDPS.BCST"} {
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = identity
+			original := ins
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerFloatAddSub(Op(opcode), ins)
+			conflict := identity == "UNKNOWN" || identity == "VADDPS.BCST"
+			if !known || term || (err != nil) != conflict || conflict && output.String() != before || !reflect.DeepEqual(ins, original) {
+				t.Fatalf("%s/%s source identity changed: %t/%t/%v", opcode, identity, known, term, err)
+			}
+		}
+	}
+}
+
+func TestX86FloatAddSubDefaultAMD64ArchitectureHelperEmission(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		for _, row := range []string{"ADDSS X0,X1", "VSUBPS Y0,Y1,Y2", "VADDSD.RD_SAE X0,X1,X2"} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{TargetTriple: triple, Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "addsub-default-target.ll", "addsub-default-target.o", ir)
+		}
+	}
+}
diff --git a/amd64_float_add_sub_go_oracle_test.go b/amd64_float_add_sub_go_oracle_test.go
new file mode 100644
index 000000000..b9a5f875b
--- /dev/null
+++ b/amd64_float_add_sub_go_oracle_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86FloatAddSubOriginalGoBitOracle(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+import "testing"
+func TestOriginalGoBinaryGolden(t *testing.T) {
+`)
+	for _, bits := range []int{32, 64} {
+		for _, operation := range []string{"ADD", "SUB"} {
+			name := fmt.Sprintf("%s%d", strings.ToLower(operation), bits)
+			// gc's amd64 ABI0 result area starts at the next pointer alignment,
+			// independently of the four-byte parameter/result element width.
+			lane, move, frame, first, second, control, result, flags := "SS", "MOVSS", 24, 0, 4, 8, 16, 20
+			if bits == 64 {
+				lane, move, frame, second, control, result, flags = "SD", "MOVSD", 36, 8, 16, 24, 32
+			}
+			fmt.Fprintf(&declarations, "func %s(a,b uint%d,csr uint32) (value uint%d,flags uint32)\n", name, bits, bits)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-%d\nSTMXCSR saved-4(SP)\nLDMXCSR csr+%d(FP)\n%s a+%d(FP),X0\n%s b+%d(FP),X1\n%s%s X1,X0\n%s X0,value+%d(FP)\nSTMXCSR flags+%d(FP)\nLDMXCSR saved-4(SP)\nRET\n", name, frame, control, move, first, move, second, operation, lane, move, result, flags)
+			// Literal special-value vectors are not computed by the production
+			// helper or a host's language-level NaN canonicalization rules.
+			vectors := [][3]uint64{{0x7fc12345, 0xffc45678, 0x7fc12345}, {0x7f812345, 0xffc45678, 0x7fc12345}, {0x3f800000, 0xff845678, 0xffc45678}}
+			if bits == 64 {
+				vectors = [][3]uint64{{0x7ff8123456789abc, 0xfff8fedcba987654, 0x7ff8123456789abc}, {0x7ff0123456789abc, 0xfff8fedcba987654, 0x7ff8123456789abc}, {0x3ff0000000000000, 0xfff0fedcba987654, 0xfff8fedcba987654}}
+			}
+			for index, vector := range vectors {
+				flags := 0x1f80
+				if index > 0 {
+					flags |= 1
+				}
+				fmt.Fprintf(&tests, "if got,flags:=%s(0x%x,0x%x,0x1f80);got!=0x%x || flags!=0x%x {t.Fatalf(\"%s NaN got=%%x flags=%%x\",got,flags)}\n", name, vector[0], vector[1], vector[2], flags, name)
+			}
+			one, half, next := uint64(0x3f800000), uint64(0x33800000), uint64(0x3f800001)
+			if bits == 64 {
+				one, half, next = 0x3ff0000000000000, 0x3ca0000000000000, 0x3ff0000000000001
+			}
+			if operation == "SUB" {
+				half |= uint64(1) << (bits - 1) // 1-(-half ULP) has the same tie
+			}
+			for mode := 0; mode < 4; mode++ {
+				want := one
+				if mode == 2 {
+					want = next
+				}
+				fmt.Fprintf(&tests, "if got,flags:=%s(0x%x,0x%x,0x%x);got!=0x%x || flags!=0x%x {t.Fatalf(\"%s mode%d got=%%x flags=%%x\",got,flags)}\n", name, one, half, 0x1f80|mode<<13, want, 0x1fa0|mode<<13, name, mode)
+			}
+		}
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go SSE bit/round oracle: %v\n%s", err, output)
+	}
+}
diff --git a/amd64_float_add_sub_literal.go b/amd64_float_add_sub_literal.go
new file mode 100644
index 000000000..1fb07c91d
--- /dev/null
+++ b/amd64_float_add_sub_literal.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"math"
+	"strings"
+)
+
+func x86FloatAddSubLiteral(ins Instr, spec x86FloatArithmeticSpec) bool {
+	return x86FloatArithmeticLiteral(ins, spec.legacy, spec.scalar)
+}
+
+// obj6.progedit rewrites legacy scalar ADD/SUB/MUL/DIV constants to
+// Float32Sym/Float64Sym. A literal is not caller memory or a register input.
+// Both reviewed Go encoders use the same arithmetic rewrite, including ±0.
+func x86FloatArithmeticLiteral(ins Instr, legacy, scalar bool) bool {
+	if !legacy || !scalar || len(ins.Args) != 2 {
+		return false
+	}
+	operand := ins.Args[0]
+	if operand.Kind != OpImm || !operand.ImmIsFloat || operand.ImmRaw != "" {
+		return false
+	}
+	value := math.Float64frombits(uint64(operand.Imm))
+	if math.IsInf(value, 0) || math.IsNaN(value) {
+		return false // these are not stock Go FLOAT tokens
+	}
+	if ins.Raw == "" {
+		return true // explicitly typed finite value, without source syntax
+	}
+	_, rest := splitOpcode(ins.Raw)
+	arguments := splitTopLevelCSV(rest)
+	if len(arguments) != 2 {
+		return false
+	}
+	text := strings.TrimSpace(arguments[0])
+	if !strings.HasPrefix(text, "$") {
+		return false
+	}
+	parsed, ok := parseGoFloatLiteral(strings.TrimSpace(text[1:]))
+	return ok && math.Float64bits(parsed) == uint64(operand.Imm)
+}
diff --git a/amd64_float_add_sub_literal_runtime_test.go b/amd64_float_add_sub_literal_runtime_test.go
new file mode 100644
index 000000000..0319cb882
--- /dev/null
+++ b/amd64_float_add_sub_literal_runtime_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86AddSubLiteralNumericalSource() (declarations, assembly string) {
+	var goSource, machine strings.Builder
+	for _, opcode := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+		for _, value := range x86AddSubLiteralValues {
+			name := strings.ToLower(opcode) + value.name
+			fmt.Fprintf(&goSource, "func %s(input *[32]byte, output *[80]byte, csr uint32)\n", name)
+			fmt.Fprintf(&machine, `TEXT ·%s(SB),4,$8-20
+STMXCSR saved-4(SP)
+LDMXCSR csr+16(FP)
+MOVQ input+0(FP),AX
+MOVQ output+8(FP),BX
+VMOVUPS (AX),Y0
+%s $%s,X0
+MOVUPS X0,8(BX)
+VMOVUPS Y0,24(BX)
+STMXCSR 56(BX)
+LDMXCSR saved-4(SP)
+RET
+`, name, opcode, value.text)
+		}
+	}
+	return goSource.String(), machine.String()
+}
+
+func x86AddSubLiteralCOracle() string {
+	var declarations, checks strings.Builder
+	index := 0
+	for _, opcode := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+		bits := 32
+		if strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		for _, value := range x86AddSubLiteralValues {
+			literal := value.bits64
+			if bits == 32 {
+				literal = uint64(value.bits32)
+			}
+			name := strings.ToLower(opcode) + value.name
+			fmt.Fprintf(&declarations, "extern void %s(void*,void*,unsigned);\n", name)
+			fmt.Fprintf(&checks, "    if (check_literal(%s,%q,%d,UINT64_C(0x%x),%d)) return %d;\n", name, name, bits, literal, x86FloatAddSubBoolInt(strings.HasPrefix(opcode, "SUB")), index+1)
+			index++
+		}
+	}
+	return x86FloatAddSubSSEOracle + declarations.String() + `
+typedef void (*literal_fn)(void*,void*,unsigned);
+static int check_literal(literal_fn fn,const char *name,unsigned bits,uint64_t literal,int subtract) {
+    const uint64_t edge32[]={0,0x80000000,1,0x80000001,0x3f800000,0xbf800000,
+        0x7f7fffff,0x7f800000,0xff800000,0x7fc12345,0x7f812345};
+    const uint64_t edge64[]={0,UINT64_C(0x8000000000000000),1,UINT64_C(0x8000000000000001),
+        UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x7fefffffffffffff),
+        UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),
+        UINT64_C(0x7ff8123456789abc),UINT64_C(0x7ff0123456789abc)};
+    const unsigned controls[]={0x1f80,0x1f85,0x1fc0,0x9f80,0x9fc0,0x3f80,0x5f80,0x7f80};
+    for(unsigned sample=0;sample<11;sample++) {
+        unsigned char input[32],before[32],output[80],want[80];
+        for(unsigned byte=0;byte<32;byte++) input[byte]=(unsigned char)(byte*37+19);
+        uint64_t left=bits==32?edge32[sample]:edge64[sample];
+        memcpy(input,&left,bits/8);
+        memcpy(before,input,32);
+        for(unsigned mode=0;mode<8;mode++) {
+            unsigned ambient=0x3f85,after;
+            memset(output,0xa7,80);
+            memset(want,0xa7,80);
+            uint64_t result=sse_result(bits,left,literal,subtract,controls[mode]);
+            unsigned expectedCSR=last_sse_csr;
+            memcpy(want+8,input,16);
+            memcpy(want+24,input,32);
+            memcpy(want+8,&result,bits/8);
+            memcpy(want+24,&result,bits/8);
+            memcpy(want+56,&expectedCSR,4);
+            __asm__ volatile("ldmxcsr %0"::"m"(ambient));
+            fn(input,output,controls[mode]);
+            __asm__ volatile("stmxcsr %0":"=m"(after));
+            if(memcmp(input,before,32)||memcmp(output,want,80)||after!=ambient) {
+                fprintf(stderr,"%s bits=%u sample=%u csr=%x after=%x\n",name,bits,sample,controls[mode],after);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + `
+    unsigned csr=0x1f80;
+    __asm__ volatile("ldmxcsr %0"::"m"(csr));
+    return 0;
+}
+`
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatAddSubLiteralNumerical(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	declarations, assembly := x86AddSubLiteralNumericalSource()
+	x86ScalarLiteralGoListing(t, "amd64", assembly)
+	pkg := x86AddSubLiteralPackage(t, "amd64", declarations)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			var ir string
+			var err error
+			switch api {
+			case "text":
+				ir, err = Translate(file, options)
+			case "module":
+				var module llvm.Module
+				module, err = TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+					ir = module.String()
+				}
+			case "GoModule":
+				var translation *GoModuleTranslation
+				translation, err = translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{GOARCH: "amd64", TargetTriple: triple, ResolveSym: resolve})
+				if translation != nil && !translation.Module.IsNil() {
+					defer translation.Module.Dispose()
+					ir = translation.Module.String()
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "addsub-literal-"+api, triple, ir, x86AddSubLiteralCOracle(), prefix)
+		})
+	}
+	t.Log("56 original literal forms × 11 independent SSE bit inputs × 8 full MXCSR controls × 3 translation APIs; whole X/Y bytes and canaries")
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatAddSubLiteralOriginalGo(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	declarations, assembly := x86AddSubLiteralNumericalSource()
+	var checks strings.Builder
+	for _, opcode := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+		bits := 32
+		if strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		for _, value := range x86AddSubLiteralValues {
+			literal := value.bits64
+			if bits == 32 {
+				literal = uint64(value.bits32)
+			}
+			fmt.Fprintf(&checks, "    check(t,%s,%d,0x%x,%t)\n", strings.ToLower(opcode)+value.name, bits, literal, strings.HasPrefix(opcode, "SUB"))
+		}
+	}
+	goTest := `package literal
+import("encoding/binary";"math";"testing")
+type literalFn func(*[32]byte,*[80]byte,uint32)
+func check(t *testing.T,fn literalFn,bits int,literal uint64,subtract bool) {
+    t.Helper()
+    for _,negative:=range []bool{false,true} {
+        var input [32]byte
+        var output [80]byte
+        for i:=range input {input[i]=byte(i*37+19)}
+        for i:=range output {output[i]=0xa7}
+        var result uint64
+        if bits==32 {
+            left:=float32(4)
+            if negative {left=-left}
+            binary.LittleEndian.PutUint32(input[:4],math.Float32bits(left))
+            right:=math.Float32frombits(uint32(literal))
+            if subtract {left-=right}else{left+=right}
+            result=uint64(math.Float32bits(left))
+        }else{
+            left:=float64(4)
+            if negative {left=-left}
+            binary.LittleEndian.PutUint64(input[:8],math.Float64bits(left))
+            right:=math.Float64frombits(literal)
+            if subtract {left-=right}else{left+=right}
+            result=math.Float64bits(left)
+        }
+        before:=input
+        fn(&input,&output,0x1f80)
+        if input!=before {t.Fatal("input changed")}
+        for i,got:=range output {
+            if i>=56&&i<60 {continue} // CSR is checked independently by the C SSE oracle.
+            want:=byte(0xa7)
+            if i>=8&&i<24 {want=input[i-8]}
+            if i>=24&&i<56 {want=input[i-24]}
+            if i>=8&&i<8+bits/8 {want=byte(result>>(8*(i-8)))}
+            if i>=24&&i<24+bits/8 {want=byte(result>>(8*(i-24)))}
+            if got!=want {t.Fatalf("bits=%d literal=%x byte=%d got=%x want=%x",bits,literal,i,got,want)}
+        }
+    }
+}
+func TestOriginalLiteralNumerical(t *testing.T) {
+` + checks.String() + "}\n"
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module literal\n\ngo 1.20\n", "literal.go": "package literal\n" + declarations,
+		"literal_amd64.s": assembly, "literal_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go original literal numerical: %v\n%s", err, output)
+	}
+	t.Log("actual Go original 56 literal kernels × 2 initialized finite inputs; X/Y aliases and whole output canaries (host execution may be Rosetta)")
+}
diff --git a/amd64_float_add_sub_literal_test.go b/amd64_float_add_sub_literal_test.go
new file mode 100644
index 000000000..9eee3c08e
--- /dev/null
+++ b/amd64_float_add_sub_literal_test.go
@@ -0,0 +1,360 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86AddSubLiteralValues = []x86ScalarLiteralValue{
+	{name: "one", text: "1.0", bits32: 0x3f800000, bits64: 0x3ff0000000000000},
+	{name: "plus", text: "+1.0", bits32: 0x3f800000, bits64: 0x3ff0000000000000},
+	{name: "minus", text: "-1.0", bits32: 0xbf800000, bits64: 0xbff0000000000000},
+	{name: "zero", text: "0.0"},
+	{name: "negativeZero", text: "-0.0", bits32: 0x80000000, bits64: 0x8000000000000000},
+	{name: "hex", text: "0x1.4p+0", bits32: 0x3fa00000, bits64: 0x3ff4000000000000},
+	{name: "scientific", text: "6.25e-1", bits32: 0x3f200000, bits64: 0x3fe4000000000000},
+	{name: "parentheses", text: "(1.25)", bits32: 0x3fa00000, bits64: 0x3ff4000000000000},
+	{name: "signedParentheses", text: "(-2.5)", bits32: 0xc0200000, bits64: 0xc004000000000000},
+	{name: "roundEven", text: "1.000000059604644775390625", bits32: 0x3f800000, bits64: 0x3ff0000010000000},
+	{name: "underflow32", text: "1e-50", bits64: 0x358dee7a4ad4b81f},
+	{name: "overflow32", text: "1e40", bits32: 0x7f800000, bits64: 0x483d6329f1c35ca5},
+	{name: "underscore", text: "1_000.0", bits32: 0x447a0000, bits64: 0x408f400000000000},
+	{name: "nestedSign", text: "+(-(+1.25))", bits32: 0xbfa00000, bits64: 0xbff4000000000000},
+}
+
+func x86AddSubLiteralPackage(t *testing.T, arch, declarations string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "literal.go", "package literal\n"+declarations, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("literal", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "literal", Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func TestX86FloatAddSubLiteralActualGoObjects(t *testing.T) {
+	// This shared oracle authenticates the invoked SDK/assembler and hashes
+	// obj6/asm6/AVX tables before and after these original-source objects.
+	x86ScalarLiteralActualGoRewriteSet(t)
+	for _, name := range []string{"obj6.go", "asm6.go"} {
+		path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86", name)
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if name == "obj6.go" {
+			if err := x86AddSubLiteralRewriteSource(data); err != nil {
+				t.Fatal(err)
+			}
+		} else {
+			for _, op := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+				if !bytes.Contains(data, []byte("{A"+op+", yxm,")) {
+					t.Fatalf("actual Go no longer uses yxm for %s", op)
+				}
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		for _, op := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+			for _, value := range x86AddSubLiteralValues {
+				for _, register := range []int{0, 7, 8, 15} {
+					row := fmt.Sprintf("%s $%s,X%d", op, value.text, register)
+					entry := fmt.Sprintf("TEXT literal%d(SB),4,$0-0\n%s\nRET\n", source.Len(), row)
+					if arch == "386" && register >= 8 {
+						x86ScalarLiteralExpectedGoListing(t, arch, entry, false)
+						continue
+					}
+					source.WriteString(entry)
+				}
+			}
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, value := range x86AddSubLiteralValues {
+			for _, pool := range []string{fmt.Sprintf("$f32.%08x", value.bits32), fmt.Sprintf("$f64.%016x", value.bits64)} {
+				if !strings.Contains(listing, pool) {
+					t.Fatalf("actual Go pool rounding/sign missing %s", pool)
+				}
+			}
+		}
+		if strings.Contains(listing, "XORPS") {
+			t.Fatal("arithmetic zero literal incorrectly acquired MOV zero rewrite")
+		}
+	}
+}
+
+// Independently bind the actual encoder's complete scalar pool-rewrite body,
+// not just the presence of an opcode name somewhere in the source file.
+func x86AddSubLiteralRewriteSource(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "obj6.go", source, 0)
+	if err != nil {
+		return err
+	}
+	seen := make(map[string]int)
+	var progedit *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == "progedit" {
+			if progedit != nil || function.Body == nil {
+				return fmt.Errorf("missing or duplicate progedit body")
+			}
+			progedit = function
+		}
+	}
+	if progedit == nil {
+		return fmt.Errorf("actual Go progedit missing")
+	}
+	allowed := make(map[*ast.CaseClause]bool)
+	for _, statement := range progedit.Body.List {
+		switchStatement, ok := statement.(*ast.SwitchStmt)
+		if !ok || switchStatement.Init != nil {
+			continue
+		}
+		selector, ok := switchStatement.Tag.(*ast.SelectorExpr)
+		if !ok || selector.Sel.Name != "As" {
+			continue
+		}
+		base, ok := selector.X.(*ast.Ident)
+		if !ok || base.Name != "p" {
+			continue
+		}
+		for _, entry := range switchStatement.Body.List {
+			if clause, ok := entry.(*ast.CaseClause); ok {
+				allowed[clause] = true
+			}
+		}
+	}
+	var failure error
+	ast.Inspect(progedit.Body, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok {
+			return true
+		}
+		for _, expression := range clause.List {
+			name, ok := expression.(*ast.Ident)
+			if !ok || name.Name != "AADDSS" && name.Name != "AADDSD" && name.Name != "ASUBSS" && name.Name != "ASUBSD" {
+				continue
+			}
+			seen[name.Name]++
+			if !allowed[clause] {
+				failure = fmt.Errorf("nested or conditional literal rewrite %s", name.Name)
+			}
+			bits := 64
+			if strings.HasSuffix(name.Name, "SS") {
+				bits = 32
+			}
+			expected := fmt.Sprintf(`package p
+func f() {
+if p.From.Type == obj.TYPE_FCONST {
+	f%d := %s
+	p.From.Type = obj.TYPE_MEM
+	p.From.Name = obj.NAME_EXTERN
+	p.From.Sym = ctxt.Float%dSym(f%d)
+	p.From.Offset = 0
+}
+}`, bits, map[int]string{32: "float32(p.From.Val.(float64))", 64: "p.From.Val.(float64)"}[bits], bits, bits)
+			fixture, err := parser.ParseFile(token.NewFileSet(), "expected.go", expected, 0)
+			if err != nil {
+				failure = err
+				continue
+			}
+			body, err := x86ScalarLiteralBodySyntax(clause.Body)
+			want, wantErr := x86ScalarLiteralBodySyntax(fixture.Decls[0].(*ast.FuncDecl).Body.List)
+			if err != nil || wantErr != nil || body != want {
+				failure = fmt.Errorf("unrecognized actual Go %s literal rewrite body", name.Name)
+			}
+		}
+		return true
+	})
+	for _, name := range []string{"AADDSS", "AADDSD", "ASUBSS", "ASUBSD"} {
+		if seen[name] != 1 {
+			return fmt.Errorf("actual Go literal rewrite registration %s count=%d", name, seen[name])
+		}
+	}
+	return failure
+}
+
+func TestX86FloatAddSubLiteralRewriteSourceRejectsMutation(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/obj6.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86AddSubLiteralRewriteSource(source); err != nil {
+		t.Fatal(err)
+	}
+	before := sha256.Sum256(source)
+	for _, replacement := range [][2]string{
+		{"func progedit(", "func unrelated("},
+		{"AADDSS,", "AADDPS,"}, {"ASUBSD,", "ASUBPD,"},
+		{"ctxt.Float32Sym(f32)", "ctxt.Float64Sym(f32)"}, {"p.From.Offset = 0", "p.From.Offset = 4"},
+	} {
+		mutated := bytes.ReplaceAll(source, []byte(replacement[0]), []byte(replacement[1]))
+		if bytes.Equal(mutated, source) || x86AddSubLiteralRewriteSource(mutated) == nil {
+			t.Fatalf("unknown source rewrite accepted: %q", replacement)
+		}
+	}
+	after, err := os.ReadFile(path)
+	if err != nil || sha256.Sum256(after) != before {
+		t.Fatalf("source mutation oracle changed the real SDK: %v", err)
+	}
+}
+
+func TestX86FloatAddSubLiteralOriginalInstructionBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			opcode             string
+			prefix, opcodeByte byte
+		}{
+			{"ADDSS", 0xf3, 0x58}, {"ADDSD", 0xf2, 0x58},
+			{"SUBSS", 0xf3, 0x5c}, {"SUBSD", 0xf2, 0x5c},
+		} {
+			for _, literal := range []string{"0.0", "-0.0", "1.0", "0x1.4p0"} {
+				code := x86PackedFirstGoInstructionBytes(t, arch, row.opcode+" $"+literal+",X0")
+				if !bytes.Equal(code[:4], []byte{row.prefix, 0x0f, row.opcodeByte, 0x05}) {
+					t.Fatalf("%s %s literal %s original bytes=%x", arch, row.opcode, literal, code)
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatAddSubLiteralCallerKeepsDefinedBytes(t *testing.T) {
+	for _, opcode := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+		file, err := Parse(ArchAMD64, "TEXT literal(SB),4,$0-0\n"+opcode+" $-0.0,X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86FloatAddSubProperties(ins, "amd64")
+		if !recognized || err != nil || !form.literal || form.memory != -1 || form.memoryBytes != 0 {
+			t.Fatalf("literal confused with caller memory: %+v / %v", form, err)
+		}
+		low := x86CallerVectorByteMask(int64(form.bits / 8))
+		for _, old := range []uint64{0, low &^ 1, low, low | 0xf0000000, ^uint64(0)} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": old}, masks: map[Reg]bool{}}
+			before, _ := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerFloatAddSubStep(&ins, form, &state, nil)
+			if accepted != (old&low == low) || !accepted && !reflect.DeepEqual(before, state.vectors) || accepted && state.vectors["Z0"] != old {
+				t.Fatalf("%s invented destination/upper knowledge: old=%x state=%x accepted=%t", opcode, old, state.vectors["Z0"], accepted)
+			}
+		}
+		// Source spelling is not permission to use a different typed value.
+		ins.Args[0].Imm++
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		_, _, err = ctx.lowerFloatAddSub(ins.Op, ins)
+		if err == nil || output.String() != before {
+			t.Fatal("mismatched literal/source bits emitted IR")
+		}
+	}
+}
+
+func TestX86FloatAddSubLiteralThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var declarations, source strings.Builder
+			for _, op := range []string{"ADDSS", "ADDSD", "SUBSS", "SUBSD"} {
+				for _, value := range x86AddSubLiteralValues {
+					name := strings.ToLower(op) + value.name
+					fmt.Fprintf(&declarations, "func %s()\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\nPXOR X0,X0\n%s $%s,X0\nRET\n", name, op, value.text)
+				}
+			}
+			pkg := x86AddSubLiteralPackage(t, target.arch, declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(sym string) string { return strings.Replace(sym, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					var err error
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(ctx, pkg, []byte(source.String()), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "add-sub-literal.ll", "add-sub-literal.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86FloatAddSubLiteralRejectsNonGoFormats(t *testing.T) {
+	for _, row := range []string{
+		"ADDSD $1,X0", "ADDSS $0,X0", "SUBSD $0x3ff0000000000000,X0",
+		"ADDSD $(1.0+2.0),X0", "SUBSS $(1.0/2.0),X0", "ADDSS $1e999,X0",
+		"ADDPS $1.0,X0", "ADDPD $1.0,X0", "SUBPS $1.0,X0", "SUBPD $1.0,X0",
+		"VADDSS $1.0,X0,X1", "VADDSD $1.0,X0,X1", "VSUBSS $1.0,X0,X1", "VSUBSD $1.0,X0,X1",
+		"ADDSD.Z $1.0,X0", "ADDSS $1.0,Y0", "SUBSD $1.0,X16", "ADDSD X0,$1.0",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT literal(SB),4,$0-0\n" + row + "\nRET\n"
+			x86ScalarLiteralExpectedGoListing(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerFloatAddSub(ins.Op, ins)
+			if !known || term || err == nil || before != output.String() {
+				t.Fatalf("non-Go literal emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+}
diff --git a/amd64_float_add_sub_numerical_test.go b/amd64_float_add_sub_numerical_test.go
new file mode 100644
index 000000000..94efa6b03
--- /dev/null
+++ b/amd64_float_add_sub_numerical_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This oracle executes real legacy SSE under an explicitly saved/restored
+// MXCSR. It is independent of the translated opcode table and numerical
+// accumulator, including NaN payload priority and DAZ/FTZ signed zeros.
+const x86FloatAddSubSSEOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+static unsigned last_sse_csr;
+static uint64_t sse_result(unsigned width,uint64_t left,uint64_t right,int sub,unsigned csr) {
+ unsigned saved; __asm__ volatile("stmxcsr %0":"=m"(saved));
+ __asm__ volatile("ldmxcsr %0"::"m"(csr));
+ uint64_t bits=0;
+ if(width==32) {
+  uint32_t l=(uint32_t)left,r=(uint32_t)right,out; float a,b;
+  memcpy(&a,&l,4);memcpy(&b,&r,4);
+  if(sub) __asm__ volatile("subss %1,%0":"+x"(a):"x"(b));
+  else __asm__ volatile("addss %1,%0":"+x"(a):"x"(b));
+  memcpy(&out,&a,4);bits=out;
+ } else {
+  double a,b;memcpy(&a,&left,8);memcpy(&b,&right,8);
+  if(sub) __asm__ volatile("subsd %1,%0":"+x"(a):"x"(b));
+  else __asm__ volatile("addsd %1,%0":"+x"(a):"x"(b));
+  memcpy(&bits,&a,8);
+ }
+ __asm__ volatile("stmxcsr %0":"=m"(last_sse_csr));
+ __asm__ volatile("ldmxcsr %0"::"m"(saved)); return bits;
+}
+`
+
+func x86FloatAddSubRuntimeTools(t *testing.T) (llc, clang, triple string, prefix []string) {
+	t.Helper()
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires amd64 numerical counterpart")
+	}
+	var found bool
+	llc, clang, found = findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang missing")
+	}
+	triple = testTargetTriple(runtime.GOOS, "amd64")
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	return
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatAddSubFixedRoundSSEExtremes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var ir strings.Builder
+	ir.WriteString("declare i128 @llvm.ctlz.i128(i128, i1)\n")
+	for _, bits := range []int{32, 64} {
+		typ := amd64FMA3LLVMType(1, bits)
+		fmt.Fprintf(&ir, "declare %s @llvm.fma.f%d(%s,%s,%s)\n", typ, bits, typ, typ, typ)
+		emitAMD64FMA3RoundingHelper(&ir, bits)
+		emitX86FloatAddSubRoundingHelper(&ir, bits)
+		fmt.Fprintf(&ir, "define i%d @addsub_round%d(i%d %%a,i%d %%b,i1 %%sub,i32 %%mode,i32 %%csr){\n %%a_float=bitcast i%d %%a to %s\n %%b_float=bitcast i%d %%b to %s\n %%value=call %s @__plan9asm_add_sub_round_f%d(%s %%a_float,%s %%b_float,i1 %%sub,i32 %%mode,i32 %%csr)\n %%bits=bitcast %s %%value to i%d\n ret i%d %%bits\n}\n", bits, bits, bits, bits, bits, typ, bits, typ, typ, bits, typ, typ, typ, bits, bits)
+	}
+	main := x86FloatAddSubSSEOracle + `
+extern uint32_t addsub_round32(uint32_t,uint32_t,_Bool,unsigned,unsigned);
+extern uint64_t addsub_round64(uint64_t,uint64_t,_Bool,unsigned,unsigned);
+int main(void) {
+ const uint64_t edges32[]={0,0x80000000,1,0x80000001,0x7fffff,0x800000,
+  0x7f7fffff,0xff7fffff,0x3f800000,0xbf800000,0x3f800001,0x33800000,
+  0x7f800000,0xff800000,0x7fc12345,0xffc45678,0x7f812345,0xff845678};
+ const uint64_t edges64[]={0,UINT64_C(0x8000000000000000),1,
+  UINT64_C(0x8000000000000001),UINT64_C(0xfffffffffffff),UINT64_C(0x10000000000000),
+  UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),UINT64_C(0x3ff0000000000000),
+  UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000001),UINT64_C(0x3ca0000000000000),
+  UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),UINT64_C(0x7ff8123456789abc),
+  UINT64_C(0xfff8fedcba987654),UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff0fedcba987654)};
+ const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+ uint64_t state=UINT64_C(0x7182329ab3293821);
+ for(unsigned width=32;width<=64;width+=32) for(unsigned pair=0;pair<1000;pair++) {
+  const uint64_t *edges=width==32?edges32:edges64;
+  uint64_t a=edges[pair%18],b=edges[(pair/18)%18];
+  if(pair>=324){ state^=state<<13;state^=state>>7;state^=state<<17;a=state;
+   state^=state<<13;state^=state>>7;state^=state<<17;b=state; }
+  for(unsigned sub=0;sub<2;sub++) for(unsigned mode=0;mode<4;mode++)
+   for(unsigned ambient=0;ambient<4;ambient++) for(unsigned control=0;control<6;control++) {
+    unsigned csr=controls[control],ambientCSR=csr|(ambient<<13),after;
+    __asm__ volatile("ldmxcsr %0"::"m"(ambientCSR));
+    uint64_t got=width==32?addsub_round32(a,b,sub,mode,csr):addsub_round64(a,b,sub,mode,csr);
+    __asm__ volatile("stmxcsr %0":"=m"(after));
+    uint64_t want=sse_result(width,a,b,sub,csr|(mode<<13));
+    if(got!=want || after!=ambientCSR) {
+     fprintf(stderr,"binary width/sub/mode/ambient/csr=%u/%u/%u/%u/%x a=%llx b=%llx got=%llx want=%llx after=%x\n",
+      width,sub,mode,ambient,csr,(unsigned long long)a,(unsigned long long)b,(unsigned long long)got,(unsigned long long)want,after);return 1;
+    }
+   }
+ }
+ unsigned csr=0x1f80;__asm__ volatile("ldmxcsr %0"::"m"(csr));return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "binary-fixed-sse", triple, ir.String(), main, prefix)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatAddSubCompletePhysicalSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, row := range x86FloatAddSubFormats("amd64") {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		form, _, err := x86FloatAddSubProperties(file.Funcs[0].Instrs[1], "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		fixedMode := -1
+		for mode, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+			if form.rounding == suffix {
+				fixedMode = mode
+			}
+		}
+		name := fmt.Sprintf("binary%d", count)
+		count++
+		row = strings.Replace(row, "8(AX)", "(BX)", 1)
+		row = strings.Replace(row, "(AX)", "(BX)", 1)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nRET\n", name, row, map[bool]int{true: 1, false: 2}[form.spec.legacy])
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*,uint64_t);\n", name)
+		arithmeticBytes := form.byteWidth
+		if form.spec.scalar {
+			arithmeticBytes = form.spec.bits / 8
+		}
+		opcode := strings.Split(strings.Fields(row)[0], ".")[0]
+		independentSubtract := strings.Contains(opcode, "SUB")
+		// Only legacy packed native memory has m128 alignment semantics.
+		// Keep scalar/VEX/EVEX inputs unaligned; the separate exact-opcode
+		// fault oracle retains every old mod16 case instead of erasing it.
+		aligned := form.legacy && !form.scalar && form.memory >= 0
+		fmt.Fprintf(&checks, `
+ for(int round=0;round<4;round++) for(int m=0;m<4;m++) for(int control=0;control<6;control++) for(int ambient=0;ambient<4;ambient++) {
+  uint8_t aStorage[96] __attribute__((aligned(16))),bStorage[68],out[67];uint8_t *a=aStorage+(%[13]d?16:1),*b=bStorage+3;
+  memset(aStorage,0xa7,96);memset(bStorage,0xb9,68);memset(out,0xc3,67);
+  for(int i=0;i<64/%[2]d;i++) { uint64_t av=%[3]d==32?UINT64_C(0x3f000001)+i*0x12345+round*0x10000:UINT64_C(0x3fe0000000000001)+i*0x123456789;
+   uint64_t bv=%[3]d==32?UINT64_C(0xbf800001)+i*0x12345:UINT64_C(0xbff0000000000001)+i*0x2345678;
+   if(round==1){av=%[3]d==32?UINT64_C(0x7fc12345)+i:UINT64_C(0x7ff8123456789abc)+i;bv=%[3]d==32?UINT64_C(0xffc45678)+i:UINT64_C(0xfff8fedcba987654)+i;}
+   if(round==2){av=%[3]d==32?UINT64_C(0x7f812345)+i:UINT64_C(0x7ff0123456789abc)+i;bv=%[3]d==32?UINT64_C(0xff800000):UINT64_C(0xfff0000000000000);}
+   if(round==3){av=1+i;bv=(%[3]d==32?UINT64_C(0x80000000):UINT64_C(0x8000000000000000))|i;}
+   memcpy(a+i*%[2]d,&av,%[2]d);memcpy(b+i*%[2]d,&bv,%[2]d); }
+  unsigned csr=controls[control]|(ambient<<13),observed,expectedFlags=0;
+  __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+  uint64_t mask=masks[m];%[1]s(out+1,a,b,mask);
+  __asm__ volatile("stmxcsr %%0":"=m"(observed));
+  for(int i=0;i<64/%[2]d;i++) {
+   uint64_t av=0,bv=0,got=0;memcpy(&av,a+(%[4]d?0:i*%[2]d),%[2]d);memcpy(&bv,b+i*%[2]d,%[2]d);memcpy(&got,out+1+i*%[2]d,%[2]d);
+   int active=%[5]d<0 || ((mask>>i)&1);
+   unsigned operationCSR=%[12]d<0?csr:((csr&~0x6000u)|((unsigned)%[12]d<<13));
+   uint64_t want=i*%[2]d<%[6]d?(active?sse_result(%[3]d,bv,av,%[7]d,operationCSR):(%[8]d?0:bv)):(%[9]d || (%[10]d && i*%[2]d<16)?bv:0);
+   if(i*%[2]d<%[6]d && active && %[12]d<0)expectedFlags|=last_sse_csr&63;
+   if(got!=want){fprintf(stderr,"%[1]s lane=%%d got=%%llx want=%%llx\n",i,(unsigned long long)got,(unsigned long long)want);return %[11]d;}
+  }
+  if(observed!=(csr|expectedFlags)){fprintf(stderr,"%[1]s sticky observed=%%x expected=%%x\n",observed,csr|expectedFlags);return 3;}
+  if(out[0]!=0xc3 || out[65]!=1 || out[66]!=0xc3 || a[-1]!=0xa7 || a[64]!=0xa7 || bStorage[2]!=0xb9 || bStorage[67]!=0xb9)return 2;
+ }
+`, name, form.spec.bits/8, form.spec.bits, x86FloatAddSubBoolInt(form.broadcast), form.mask, arithmeticBytes, x86FloatAddSubBoolInt(independentSubtract), x86FloatAddSubBoolInt(form.zeroing), x86FloatAddSubBoolInt(form.spec.legacy), x86FloatAddSubBoolInt(form.spec.scalar), count+10, fixedMode, x86FloatAddSubBoolInt(aligned))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86FloatAddSubSSEOracle + declarations.String() + "int main(void){const uint64_t masks[]={0,1,0x55aa55aa55aa55aaULL,~0ULL}; const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};\n" + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "binary-complete-semantics", triple, ir, main, prefix)
+	t.Logf("%d independent opcode/width/memory/mask programs x384 IEEE/MXCSR/canary inputs", count)
+}
+
+func x86FloatAddSubBoolInt(value bool) int {
+	if value {
+		return 1
+	}
+	return 0
+}
diff --git a/amd64_float_add_sub_runtime_test.go b/amd64_float_add_sub_runtime_test.go
new file mode 100644
index 000000000..fc24a049c
--- /dev/null
+++ b/amd64_float_add_sub_runtime_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatAddSubPhysicalAliasesAndInactiveMemory(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang missing")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	for _, fixture := range []struct {
+		name, body, checks string
+	}{
+		{"packed upper aliases", "VADDPS X1,X0,X2", "for(int i=0;i<16;i++) if(out[i]!=(i<4?5.0f:0.0f)) return 11;"},
+		{"scalar second-source passthrough", "VSUBSS X1,X0,X2", "for(int i=0;i<16;i++) if(out[i]!=(i==0?-1.0f:i<4?2.0f:0.0f)) return 12;"},
+		{"inactive memory", "MOVQ $0,DX\nKMOVQ DX,K1\nVADDPS.Z (CX),X0,K1,X2", "for(int i=0;i<16;i++) if(out[i]!=0.0f) return 13;"},
+		{"inactive scalar memory", "MOVQ $0,DX\nKMOVQ DX,K1\nVSUBSD.Z (CX),X0,K1,X2", "for(int i=0;i<16;i++) if(out[i]!=(i<2?0.0f:i<4?2.0f:0.0f)) return 14;"},
+		{"inactive broadcast memory", "MOVQ $0,DX\nKMOVQ DX,K1\nVADDPD.BCST.Z (CX),Z0,K1,Z2", "for(int i=0;i<16;i++) if(out[i]!=0.0f) return 15;"},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			source := "TEXT addsub(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (BX),Z0\nVMOVUPS (BX),Z2\n"
+			if !strings.HasPrefix(fixture.name, "inactive") {
+				source += "VMOVUPS (CX),Z1\n"
+			}
+			source += fixture.body + "\nVMOVUPS Z2,(AX)\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"addsub": {Name: "addsub", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			argument := "b"
+			if strings.HasPrefix(fixture.name, "inactive") {
+				argument = "0"
+			}
+			main := fmt.Sprintf("extern void addsub(float*,const float*,const float*);\nint main(void){float a[16],b[16],out[16]; for(int i=0;i<16;i++){a[i]=2;b[i]=3;} addsub(out,a,%s); %s return 0;}\n", argument, fixture.checks)
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "addsub-alias", triple, ir, strings.TrimSpace(main), prefix)
+		})
+	}
+}
+
+func TestX86FloatAddSubFixedRoundingIgnoresAmbientMode(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang missing")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for mode, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+		name := fmt.Sprintf("roundadd%d", mode)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVSS (BX),X0\nMOVSS (CX),X1\nVADDSS.%s X1,X0,X2\nMOVSS X2,(AX)\nRET\n", name, suffix)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint32_t*,const uint32_t*,const uint32_t*);\n", name)
+		expected := uint32(0x3f800000)
+		if mode == 2 {
+			expected++
+		}
+		fmt.Fprintf(&checks, "for(int ambient=0;ambient<4;ambient++){if(fesetround(modes[ambient]))return 2; uint32_t a=0x3f800000,b=0x33800000,out=0; %s(&out,&a,&b); if(out!=0x%x)return %d;}\n", name, expected, mode+10)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <fenv.h>\n" + declarations.String() + "int main(void){const int modes[]={FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};\n" + checks.String() + "return fesetround(FE_TONEAREST)!=0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "addsub-fixed-ambient", triple, ir, main, prefix)
+}
diff --git a/amd64_float_arithmetic_forms.go b/amd64_float_arithmetic_forms.go
new file mode 100644
index 000000000..c76ffea5a
--- /dev/null
+++ b/amd64_float_arithmetic_forms.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86FloatArithmeticFamily string
+
+const (
+	x86FloatAddSubtract    x86FloatArithmeticFamily = "add/sub"
+	x86FloatMultiplyDivide x86FloatArithmeticFamily = "mul/div"
+	x86FloatMinimumMaximum x86FloatArithmeticFamily = "min/max"
+)
+
+type x86FloatArithmeticSpec struct {
+	bits           int
+	legacy, scalar bool
+	mode           amd64BinaryFloatingMode
+}
+
+// These are the complete six yxm/VEX/EVEX arithmetic pairs. Operand shapes
+// share one grammar; operation tags retain distinct arithmetic and FP effects.
+var x86FloatArithmeticSpecs = map[Op]x86FloatArithmeticSpec{
+	"ADDPS": {32, true, false, amd64BinaryFloatingAdd}, "ADDPD": {64, true, false, amd64BinaryFloatingAdd},
+	"ADDSS": {32, true, true, amd64BinaryFloatingAdd}, "ADDSD": {64, true, true, amd64BinaryFloatingAdd},
+	"SUBPS": {32, true, false, amd64BinaryFloatingSub}, "SUBPD": {64, true, false, amd64BinaryFloatingSub},
+	"SUBSS": {32, true, true, amd64BinaryFloatingSub}, "SUBSD": {64, true, true, amd64BinaryFloatingSub},
+	"VADDPS": {32, false, false, amd64BinaryFloatingAdd}, "VADDPD": {64, false, false, amd64BinaryFloatingAdd},
+	"VADDSS": {32, false, true, amd64BinaryFloatingAdd}, "VADDSD": {64, false, true, amd64BinaryFloatingAdd},
+	"VSUBPS": {32, false, false, amd64BinaryFloatingSub}, "VSUBPD": {64, false, false, amd64BinaryFloatingSub},
+	"VSUBSS": {32, false, true, amd64BinaryFloatingSub}, "VSUBSD": {64, false, true, amd64BinaryFloatingSub},
+	"MULPS": {32, true, false, amd64BinaryFloatingMul}, "MULPD": {64, true, false, amd64BinaryFloatingMul},
+	"MULSS": {32, true, true, amd64BinaryFloatingMul}, "MULSD": {64, true, true, amd64BinaryFloatingMul},
+	"DIVPS": {32, true, false, amd64BinaryFloatingDiv}, "DIVPD": {64, true, false, amd64BinaryFloatingDiv},
+	"DIVSS": {32, true, true, amd64BinaryFloatingDiv}, "DIVSD": {64, true, true, amd64BinaryFloatingDiv},
+	"VMULPS": {32, false, false, amd64BinaryFloatingMul}, "VMULPD": {64, false, false, amd64BinaryFloatingMul},
+	"VMULSS": {32, false, true, amd64BinaryFloatingMul}, "VMULSD": {64, false, true, amd64BinaryFloatingMul},
+	"VDIVPS": {32, false, false, amd64BinaryFloatingDiv}, "VDIVPD": {64, false, false, amd64BinaryFloatingDiv},
+	"VDIVSS": {32, false, true, amd64BinaryFloatingDiv}, "VDIVSD": {64, false, true, amd64BinaryFloatingDiv},
+	"MINPS": {32, true, false, amd64BinaryFloatingMin}, "MINPD": {64, true, false, amd64BinaryFloatingMin},
+	"MINSS": {32, true, true, amd64BinaryFloatingMin}, "MINSD": {64, true, true, amd64BinaryFloatingMin},
+	"MAXPS": {32, true, false, amd64BinaryFloatingMax}, "MAXPD": {64, true, false, amd64BinaryFloatingMax},
+	"MAXSS": {32, true, true, amd64BinaryFloatingMax}, "MAXSD": {64, true, true, amd64BinaryFloatingMax},
+	"VMINPS": {32, false, false, amd64BinaryFloatingMin}, "VMINPD": {64, false, false, amd64BinaryFloatingMin},
+	"VMINSS": {32, false, true, amd64BinaryFloatingMin}, "VMINSD": {64, false, true, amd64BinaryFloatingMin},
+	"VMAXPS": {32, false, false, amd64BinaryFloatingMax}, "VMAXPD": {64, false, false, amd64BinaryFloatingMax},
+	"VMAXSS": {32, false, true, amd64BinaryFloatingMax}, "VMAXSD": {64, false, true, amd64BinaryFloatingMax},
+}
+
+func (spec x86FloatArithmeticSpec) family() x86FloatArithmeticFamily {
+	switch spec.mode {
+	case amd64BinaryFloatingAdd, amd64BinaryFloatingSub:
+		return x86FloatAddSubtract
+	case amd64BinaryFloatingMul, amd64BinaryFloatingDiv:
+		return x86FloatMultiplyDivide
+	case amd64BinaryFloatingMin, amd64BinaryFloatingMax:
+		return x86FloatMinimumMaximum
+	}
+	panic("non-arithmetic floating operation in arithmetic catalog")
+}
+
+type x86FloatArithmeticForm struct {
+	x86FloatBinaryForm
+	spec x86FloatArithmeticSpec
+}
+
+func x86FloatArithmeticProperties(ins Instr, arch string, family x86FloatArithmeticFamily) (x86FloatArithmeticForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86FloatArithmeticSpecs[Op(base)]
+	if !known || family != "" && spec.family() != family {
+		return x86FloatArithmeticForm{}, false, nil
+	}
+	family = spec.family()
+	form := x86FloatArithmeticForm{spec: spec}
+	shape := ins
+	literal := false
+	sae := false
+	if family == x86FloatMinimumMaximum {
+		controls, valid := parseAMD64BinaryFloatingSuffix(suffix)
+		sae, form.sae = controls.sae, controls.sae
+		if !valid || dotted && suffix == "" || controls.rounding != "" || spec.legacy && dotted {
+			return form, true, fmt.Errorf("%s %s has invalid MIN/MAX operands or controls: %q", arch, ins.Op, ins.Raw)
+		}
+		// Strip only the independently validated SAE control from this local
+		// shape. Original operands/opcode remain the source and emitter input.
+		if sae {
+			shape.Op = Op(base)
+			if controls.zeroing {
+				shape.Op += ".Z"
+			}
+		}
+	} else {
+		literal = x86FloatArithmeticLiteral(ins, spec.legacy, spec.scalar)
+	}
+	var err error
+	form.x86FloatBinaryForm, err = x86FloatBinaryOperandProperties(shape, arch, spec.bits, spec.legacy, spec.scalar, literal, string(family))
+	form.sae = sae
+	if err != nil {
+		return form, true, err
+	}
+	if family == x86FloatMinimumMaximum {
+		if sae && (ins.Args[0].Kind != OpReg || !spec.scalar && form.byteWidth != 64) {
+			return form, true, fmt.Errorf("%s %s has invalid MIN/MAX operands or controls: %q", arch, ins.Op, ins.Raw)
+		}
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func (c *amd64Ctx) lowerFloatArithmetic(op Op, ins Instr, family x86FloatArithmeticFamily) (bool, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86FloatArithmeticProperties(local, c.goarch, family)
+	if !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		name := string(form.spec.family())
+		if form.spec.family() == x86FloatMinimumMaximum {
+			name = "MIN/MAX"
+		}
+		return true, false, fmt.Errorf("floating %s dispatch/source opcode mismatch: %s/%s", name, op, ins.Op)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	switch form.spec.family() {
+	case x86FloatAddSubtract:
+		return c.lowerFloatAddSubForm(local, form)
+	case x86FloatMultiplyDivide:
+		return c.lowerFloatMulDivForm(local, form)
+	case x86FloatMinimumMaximum:
+		return c.lowerFloatMinMaxForm(local, form)
+	}
+	panic("unregistered floating arithmetic family")
+}
diff --git a/amd64_float_arithmetic_mode32_test.go b/amd64_float_arithmetic_mode32_test.go
new file mode 100644
index 000000000..b65f288d7
--- /dev/null
+++ b/amd64_float_arithmetic_mode32_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatArithmeticMode32PhysicalRegisterBoundary(t *testing.T) {
+	names := append(x86FloatAddSubOpcodes(), x86FloatMulDivOpcodes()...)
+	for _, member := range x86FloatingMinMaxCases {
+		names = append(names, member.op)
+	}
+	var rows []string
+	for _, name := range names {
+		if !strings.HasPrefix(name, "V") {
+			continue
+		}
+		banks := []string{"X"}
+		if strings.HasSuffix(name, "PS") || strings.HasSuffix(name, "PD") {
+			banks = append(banks, "Y")
+		}
+		for _, bank := range banks {
+			for high := 0; high < 3; high++ {
+				registers := []string{bank + "0", bank + "1", bank + "2"}
+				registers[high] = fmt.Sprint(bank, high+8)
+				rows = append(rows, name+" "+strings.Join(registers, ","))
+			}
+		}
+	}
+	if len(rows) != 108 {
+		t.Fatal("complete arithmetic operation/width/input-output role inventory changed", len(rows))
+	}
+	// A stock-Go spelling is not proof of physical high-register identity in
+	// mode32. Keep that frontend observation separate from both source modes.
+	assembly := "TEXT boundary(SB),4,$0-0\n" + strings.Join(rows, "\n") + "\nRET\n"
+	requireX86GoAssemblerResult(t, "386", assembly, true)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT boundary(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			if _, known, err := x86FloatArithmeticProperties(instruction, "386", ""); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("mode32 spelling acquired physical high-register authority: known=%v err=%v", known, err)
+			}
+			if _, known, err := x86FloatArithmeticProperties(instruction, "amd64", ""); !known || err != nil {
+				t.Fatalf("amd64 high-register positive control changed: known=%v err=%v", known, err)
+			}
+		})
+	}
+}
diff --git a/amd64_float_arithmetic_pipeline_bench_test.go b/amd64_float_arithmetic_pipeline_bench_test.go
new file mode 100644
index 000000000..ba606f760
--- /dev/null
+++ b/amd64_float_arithmetic_pipeline_bench_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Keep the public translation workload independent of the production registry.
+// Every arithmetic family and precision remains present before and after a
+// normalization change; no source/tool subprocess runs inside the timer.
+func BenchmarkX86FloatingArithmeticTranslate(b *testing.B) {
+	var source strings.Builder
+	source.WriteString("TEXT arithmetic(SB),4,$0-0\nVPXOR Y0,Y0,Y0\nVPXOR Y1,Y1,Y1\nVPXOR Y2,Y2,Y2\n")
+	var names []string
+	names = append(names, x86FloatAddSubOpcodes()...)
+	names = append(names, x86FloatMulDivOpcodes()...)
+	for _, member := range x86FloatingMinMaxCases {
+		names = append(names, member.op)
+	}
+	if len(names) != 48 {
+		b.Fatal("complete named floating arithmetic inventory changed", len(names))
+	}
+	for _, name := range names {
+		operands := "X1,X2"
+		if strings.HasPrefix(name, "V") {
+			operands = "X0,X1,X2"
+		}
+		fmt.Fprintf(&source, "%s %s\n", name, operands)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		b.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"arithmetic": {Name: "arithmetic", Ret: Void}}}
+	if _, err := Translate(file, options); err != nil {
+		b.Fatal(err)
+	}
+	b.ReportAllocs()
+	b.SetBytes(int64(source.Len()))
+	b.ResetTimer()
+	for index := 0; index < b.N; index++ {
+		if _, err := Translate(file, options); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/amd64_float_binary_forms.go b/amd64_float_binary_forms.go
new file mode 100644
index 000000000..3222c9d64
--- /dev/null
+++ b/amd64_float_binary_forms.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's yxm, _yvaddpd and _yvaddsd shapes are shared by binary floating
+// arithmetic. Operation semantics are deliberately not part of this grammar.
+type x86FloatBinaryForm struct {
+	bits                                     int
+	legacy, scalar                           bool
+	first, second, destination, mask, memory int
+	byteWidth, memoryBytes                   int
+	broadcast, zeroing                       bool
+	literal                                  bool // family-authorized Go constant-pool rewrite
+	sae                                      bool // independently validated standalone suppression
+	rounding                                 string
+}
+
+// Parse only shared operand axes. The registered family supplies precision
+// and encoding generation; its lowerer retains operation-specific semantics.
+func x86FloatBinaryOperandProperties(ins Instr, goarch string, bits int, legacy, scalar, literal bool, family string) (x86FloatBinaryForm, error) {
+	return x86FloatOperandProperties(ins, goarch, bits, legacy, scalar, literal, false, family)
+}
+
+// Unary packed arithmetic shares the width, memory and EVEX control axes,
+// but has no second numerical input and allows three-operand masks on 386.
+func x86FloatOperandProperties(ins Instr, goarch string, bits int, legacy, scalar, literal, unary bool, family string) (x86FloatBinaryForm, error) {
+	_, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	form := x86FloatBinaryForm{
+		bits: bits, legacy: legacy, scalar: scalar, literal: literal,
+		first: 0, second: 1, destination: len(ins.Args) - 1, mask: -1, memory: -1,
+	}
+	if unary {
+		form.second = form.destination
+	}
+	fail := func() (x86FloatBinaryForm, error) {
+		return form, fmt.Errorf("%s %s operands/suffix outside Go floating %s grammar: %q", goarch, ins.Op, family, ins.Raw)
+	}
+	if goarch != "386" && goarch != "amd64" {
+		return fail()
+	}
+	if legacy {
+		if dotted || len(ins.Args) != 2 {
+			return fail()
+		}
+		form.byteWidth = 16
+	} else {
+		operands := 3
+		if unary {
+			operands = 2
+		}
+		properties, valid := parseAMD64FMA3Suffix(suffix)
+		if !valid || dotted && suffix == "" || scalar && properties.broadcast || len(ins.Args) != operands && len(ins.Args) != operands+1 {
+			return fail()
+		}
+		form.broadcast, form.zeroing, form.rounding = properties.broadcast, properties.zeroing, properties.rounding
+		if len(ins.Args) == operands+1 {
+			if goarch == "386" && operands == 3 && !ins.x86Encoded || !amd64NonzeroKOperand(ins.Args[operands-1]) {
+				return fail()
+			}
+			form.mask = operands - 1
+		} else if form.zeroing {
+			return fail()
+		}
+		form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+		if scalar && form.byteWidth != 16 || form.rounding != "" && !scalar && form.byteWidth != 64 {
+			return fail()
+		}
+	}
+	register := func(operand Operand) bool {
+		if legacy {
+			index, valid := amd64ParseXReg(operand.Reg)
+			return operand.Kind == OpReg && valid && (goarch == "amd64" && index < 16 || goarch == "386" && index < 8)
+		}
+		return amd64GoPackedVectorMoveRegister(operand, form.byteWidth, goarch)
+	}
+	if !register(ins.Args[form.second]) || !register(ins.Args[form.destination]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if literal {
+		if !legacy || !scalar || first.Kind != OpImm || !first.ImmIsFloat || first.ImmRaw != "" {
+			return fail()
+		}
+	} else if isAMD64MemoryOperand(first) {
+		if form.rounding != "" {
+			return fail()
+		}
+		if first.Kind == OpSym {
+			symbol := strings.TrimSpace(first.Sym)
+			_, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if first.Kind == OpMem {
+			displacement := first.Mem.Off
+			if displacement != int64(int32(displacement)) && (goarch != "386" || displacement != int64(uint32(displacement))) ||
+				!x86MemoryRegistersValidForArch(first.Mem, goarch) || first.Mem.Index != "" &&
+				(first.Mem.Index == SP || first.Mem.Scale != 1 && first.Mem.Scale != 2 && first.Mem.Scale != 4 && first.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		form.memory, form.memoryBytes = 0, form.byteWidth
+		if scalar || form.broadcast {
+			form.memoryBytes = bits / 8
+		}
+	} else if form.broadcast || !register(first) {
+		return fail()
+	}
+	return form, nil
+}
diff --git a/amd64_float_binary_fp_load.go b/amd64_float_binary_fp_load.go
new file mode 100644
index 000000000..a2569bbfd
--- /dev/null
+++ b/amd64_float_binary_fp_load.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import "fmt"
+
+// FP operands describe checked virtual ABI0 fields. Loading one field using
+// the whole instruction width loses later fields (or reads past an alloca).
+func (c *amd64Ctx) loadFloatBinaryFPBits(source Operand, bits int) (string, error) {
+	bytes, err := c.loadFPVectorBytes(source.FPOffset, bits/8)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, bits/8, bytes, bits)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) loadFloatBinaryScalar(source Operand, bits int, mask string) (string, error) {
+	if source.Kind != OpFP {
+		if x86OrdinaryNativeMemoryOperand(source, c.goarch) {
+			// Preserve the source read even for a dead numerical result or
+			// a literal null address. It supplies no pointee-validity fact.
+			return c.loadFMA3ObservableScalar(source, bits, mask)
+		}
+		return c.loadFMA3Scalar(source, bits, mask)
+	}
+	if err := c.validateFPVectorSpan(source.FPOffset, bits/8); err != nil {
+		return "", err
+	}
+	load := func() (string, error) { return c.loadFloatBinaryFPBits(source, bits) }
+	var value string
+	var err error
+	if mask == "" {
+		value, err = load()
+	} else {
+		value, err = c.loadX86ScalarIf(bits, amd64MaskBitI1(c, mask, 0), load)
+	}
+	if err != nil {
+		return "", err
+	}
+	floating := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to %s\n", floating, bits, value, amd64FMA3LLVMType(1, bits))
+	return "%" + floating, nil
+}
+
+func (c *amd64Ctx) loadFloatBinaryPacked(source Operand, width, bits int, broadcast bool, mask string) (string, error) {
+	if source.Kind != OpFP {
+		return c.loadMaskedPackedCompareLanes(source, width, bits, broadcast, mask)
+	}
+	memoryBytes := width
+	if broadcast {
+		memoryBytes = bits / 8
+	}
+	if err := c.validateFPVectorSpan(source.FPOffset, memoryBytes); err != nil {
+		return "", err
+	}
+	lanes := width * 8 / bits
+	if broadcast {
+		load := func() (string, error) { return c.loadFloatBinaryFPBits(source, bits) }
+		var value string
+		var err error
+		if mask == "" {
+			value, err = load()
+		} else {
+			relevant, active := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", relevant, mask, uint64(1)<<uint(lanes)-1)
+			fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, relevant)
+			value, err = c.loadX86ScalarIf(bits, "%"+active, load)
+		}
+		if err != nil {
+			return "", err
+		}
+		return amd64SplatInteger(c, lanes, bits, value), nil
+	}
+	if mask == "" {
+		return c.loadPackedCompareLanes(source, width, bits, false)
+	}
+	// Do not turn separately declared fields into an invented native pointer.
+	// Each active lane loads its complete checked byte span independently.
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		part := source
+		part.FPOffset += int64(lane * bits / 8)
+		value, err := c.loadX86ScalarIf(bits, amd64MaskBitI1(c, mask, lane), func() (string, error) {
+			return c.loadFloatBinaryFPBits(part, bits)
+		})
+		if err != nil {
+			return "", err
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, lanes, bits, result, bits, value, lane)
+		result = "%" + inserted
+	}
+	return result, nil
+}
diff --git a/amd64_float_binary_fp_span_test.go b/amd64_float_binary_fp_span_test.go
new file mode 100644
index 000000000..46777003e
--- /dev/null
+++ b/amd64_float_binary_fp_span_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type x86FloatBinaryFPFixture struct {
+	name, opcode, operation, declaration, assembly string
+	bits, bytes, resultOffset                      int
+	sig                                            FuncSig
+}
+
+// Derive these layouts from actual Go declarations. Aggregate byte fields have
+// separate virtual slots, not a pointer to one contiguous native FP word.
+func x86FloatBinaryFPFixtures(t *testing.T) []x86FloatBinaryFPFixture {
+	t.Helper()
+	var fixtures []x86FloatBinaryFPFixture
+	var declarations strings.Builder
+	declarations.WriteString("package oracle\n")
+	for _, operation := range []string{"ADD", "SUB", "MUL", "DIV"} {
+		for _, bits := range []int{32, 64} {
+			for _, spelling := range []string{"legacy", "vex", "broadcast"} {
+				fixture := x86FloatBinaryFPFixture{operation: operation, bits: bits, bytes: bits / 8}
+				fixture.name = fmt.Sprintf("%s%d%s", strings.ToLower(operation), bits, spelling)
+				fixture.declaration = fmt.Sprintf("func %s(source [%d]byte,left uint%d) uint%d\n", fixture.name, fixture.bytes, bits, bits)
+				declarations.WriteString(fixture.declaration)
+				fixtures = append(fixtures, fixture)
+			}
+		}
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "value.go", declarations.String(), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	pkg, err := (&types.Config{Sizes: sizes}).Check("oracle", set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i := range fixtures {
+		fixture := &fixtures[i]
+		fixture.sig, err = DeriveGoFuncABI0Signature(fixture.name, pkg.Scope().Lookup(fixture.name).(*types.Func), "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fixture.resultOffset = int(fixture.sig.Frame.Results[0].Offset)
+		if fixture.resultOffset != 2*fixture.bytes || len(fixture.sig.Frame.Params) != fixture.bytes+1 {
+			t.Fatalf("independent Go ABI0 frame changed: %+v", fixture.sig.Frame)
+		}
+		move, suffix := "MOVSS", "SS"
+		if fixture.bits == 64 {
+			move, suffix = "MOVSD", "SD"
+		}
+		fixture.opcode = fixture.operation + suffix
+		row, destination := fixture.opcode+" source+0(FP),X0", "X0"
+		if strings.HasSuffix(fixture.name, "vex") {
+			fixture.opcode = "V" + fixture.opcode
+			row, destination = fixture.opcode+" source+0(FP),X0,X2", "X2"
+		} else if strings.HasSuffix(fixture.name, "broadcast") {
+			packedSuffix := "PS"
+			if fixture.bits == 64 {
+				packedSuffix = "PD"
+			}
+			fixture.opcode = "V" + fixture.operation + packedSuffix + ".BCST"
+			row, destination = fixture.opcode+" source+0(FP),X0,X2", "X2"
+		}
+		fixture.assembly = fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s left+%d(FP),X0\n%s\n%s %s,ret+%d(FP)\nRET\n",
+			fixture.name, fixture.resultOffset+fixture.bytes, move, fixture.bytes, row, move, destination, fixture.resultOffset)
+	}
+	return fixtures
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatBinaryOriginalGoFPByteFields(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	checks.WriteString("package oracle\nimport \"testing\"\nfunc TestOriginalByteFields(t *testing.T){\n")
+	for _, fixture := range x86FloatBinaryFPFixtures(t) {
+		declarations.WriteString(fixture.declaration)
+		// asmdecl refuses scalar arithmetic on array types even when its byte
+		// size matches. A vetted LEAQ exposes the same original Go FP bytes;
+		// the floating opcode, operand order and independently known bits stay
+		// unchanged. The translator test below keeps the direct FP spelling.
+		memoryRow := fixture.opcode + " source+0(FP)"
+		addressedRow := "LEAQ source+0(FP),CX\n" + fixture.opcode + " (CX)"
+		assembly.WriteString(strings.Replace(fixture.assembly, memoryRow, addressedRow, 1))
+		// The original executable uses baseline SSE only. Go still assembles
+		// every VEX/EVEX form; LLVM software lanes are checked separately.
+		if !strings.HasSuffix(fixture.name, "legacy") {
+			continue
+		}
+		left, source := uint64(0x3f800000), uint64(0x40200000)
+		want := map[string]uint64{"ADD": 0x40600000, "SUB": 0xbfc00000, "MUL": 0x40200000, "DIV": 0x3ecccccd}[fixture.operation]
+		if fixture.bits == 64 {
+			left, source = 0x3ff0000000000000, 0x4004000000000000
+			want = map[string]uint64{"ADD": 0x400c000000000000, "SUB": 0xbff8000000000000, "MUL": 0x4004000000000000, "DIV": 0x3fd999999999999a}[fixture.operation]
+		}
+		var args []string
+		for i := 0; i < fixture.bytes; i++ {
+			args = append(args, fmt.Sprint(byte(source>>uint(i*8))))
+		}
+		arguments := fmt.Sprintf("[%d]byte{%s},uint%d(0x%x)", fixture.bytes, strings.Join(args, ","), fixture.bits, left)
+		fmt.Fprintf(&checks, "if got:=%s(%s);got!=0x%x{t.Fatalf(%q,got)}\n", fixture.name, arguments, want, fixture.name+" got=%x")
+	}
+	checks.WriteString("}\n")
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": checks.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=asmdecl", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go cross-field floating memory oracle: %v\n%s", err, output)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatBinaryFPByteFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, wrappers, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, fixture := range x86FloatBinaryFPFixtures(t) {
+		assembly.WriteString(fixture.assembly)
+		sigs[fixture.name] = fixture.sig
+		// A bit-carrier wrapper constructs the LLVM array argument explicitly;
+		// C aggregate calling conventions are not the translated Go signature.
+		fmt.Fprintf(&wrappers, "define i%d @check_%s(i%d %%right,i%d %%left){\n", fixture.bits, fixture.name, fixture.bits, fixture.bits)
+		packed := "poison"
+		for i := 0; i < fixture.bytes; i++ {
+			fmt.Fprintf(&wrappers, " %%shift%d=lshr i%d %%right,%d\n %%byte%d=trunc i%d %%shift%d to i8\n %%pack%d=insertvalue [%d x i8] %s,i8 %%byte%d,%d\n",
+				i, fixture.bits, i*8, i, fixture.bits, i, i, fixture.bytes, packed, i, i)
+			packed = fmt.Sprintf("%%pack%d", i)
+		}
+		fmt.Fprintf(&wrappers, " %%result=call i%d @%s([%d x i8] %s,i%d %%left)\n ret i%d %%result\n}\n", fixture.bits, fixture.name, fixture.bytes, packed, fixture.bits, fixture.bits)
+		fmt.Fprintf(&declarations, "extern uint%d_t check_%s(uint%d_t,uint%d_t);\n", fixture.bits, fixture.name, fixture.bits, fixture.bits)
+		oracle, flags, secondOperation := "sse_result", "last_sse_csr", fixture.operation == "SUB"
+		if fixture.operation == "MUL" || fixture.operation == "DIV" {
+			oracle, flags, secondOperation = "sse_muldiv_result", "last_sse_muldiv_csr", fixture.operation == "DIV"
+		}
+		fmt.Fprintf(&checks, `
+ for(unsigned rc=0;rc<4;rc++) for(unsigned index=0;index<64;index++) {
+  uint64_t left=%[1]d==32?UINT64_C(0x3f800001)+index*3571:UINT64_C(0x3ff0000000000001)+index*7912347;
+  uint64_t right=%[1]d==32?UINT64_C(0x40200001)+index*761:UINT64_C(0x4004000000000001)+index*1234567;
+  unsigned csr=0x1f80|(rc<<13),after;
+  __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+  uint64_t got=check_%[2]s(right,left);
+  __asm__ volatile("stmxcsr %%0":"=m"(after));
+  uint64_t want=%[3]s(%[1]d,left,right,%[4]d,csr);
+  if(got!=want || after!=%[5]s){fprintf(stderr,"%[2]s rc=%%u got=%%llx want=%%llx after=%%x expectedCSR=%%x\n",rc,(unsigned long long)got,(unsigned long long)want,after,%[5]s);return 1;}
+ }
+`, fixture.bits, fixture.name, oracle, x86FloatAddSubBoolInt(secondOperation), flags)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mulDivOracle := strings.NewReplacer("subss", "divss", "subsd", "divsd", "addss", "mulss", "addsd", "mulsd",
+		"sse_result", "sse_muldiv_result", "last_sse_csr", "last_sse_muldiv_csr").Replace(x86FloatAddSubSSEOracle)
+	main := x86FloatAddSubSSEOracle + mulDivOracle + declarations.String() + "int main(void){\n" + checks.String() +
+		"unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "float-binary-fp-bytes", triple, ir+wrappers.String(), main, prefix)
+}
diff --git a/amd64_float_compare_forms.go b/amd64_float_compare_forms.go
new file mode 100644
index 000000000..3f2a08064
--- /dev/null
+++ b/amd64_float_compare_forms.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86FloatCompareSpec struct {
+	bits           int
+	legacy, scalar bool
+}
+
+var x86FloatCompareSpecs = map[Op]x86FloatCompareSpec{
+	"CMPPS": {32, true, false}, "CMPPD": {64, true, false},
+	"CMPSS": {32, true, true}, "CMPSD": {64, true, true},
+	"VCMPPS": {32, false, false}, "VCMPPD": {64, false, false},
+	"VCMPSS": {32, false, true}, "VCMPSD": {64, false, true},
+}
+
+// Compare has an immediate position and a K-result generation distinct from
+// binary arithmetic. The shared source-width axes do not imply merge/zero
+// destination semantics or shared floating exception policy.
+type x86FloatCompareForm struct {
+	spec x86FloatCompareSpec
+	x86FloatBinaryForm
+	immediate       uint8
+	maskResult, sae bool
+}
+
+func (form x86FloatCompareForm) inputByteWidth() int {
+	if form.scalar {
+		return form.bits / 8
+	}
+	return form.byteWidth
+}
+
+// Both callers and result analysis use the same architectural byte writes.
+// These are definedness facts, not predicate values or native memory rights.
+func (form x86FloatCompareForm) resultDefinedBytes(second, previous uint64) uint64 {
+	active := x86CallerVectorByteMask(int64(form.inputByteWidth()))
+	if form.legacy {
+		return previous | active
+	}
+	if form.scalar {
+		return ^uint64(0xffff) | active | second&(0xffff&^active)
+	}
+	return ^uint64(0)
+}
+
+func x86FloatCompareProperties(ins Instr, goarch string) (x86FloatCompareForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86FloatCompareSpecs[Op(base)]
+	if !known {
+		return x86FloatCompareForm{}, false, nil
+	}
+	form := x86FloatCompareForm{spec: spec, x86FloatBinaryForm: x86FloatBinaryForm{
+		bits: spec.bits, legacy: spec.legacy, scalar: spec.scalar,
+		mask: -1, memory: -1,
+	}}
+	fail := func() (x86FloatCompareForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go floating compare grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "386" && goarch != "amd64" {
+		return fail()
+	}
+	if spec.legacy {
+		if dotted || len(ins.Args) != 3 {
+			return fail()
+		}
+		if ins.Args[2].Kind == OpImm && (ins.Args[2].ImmIsFloat || ins.Args[2].ImmRaw != "") {
+			return fail()
+		}
+		immediate, valid := amd64LegacyFloatingCompareImmediate(ins.Args[2])
+		if !valid || immediate < -128 || immediate > 127 {
+			return fail()
+		}
+		form.immediate = uint8(immediate)
+		form.first, form.second, form.destination, form.byteWidth = 0, 1, 1, 16
+	} else {
+		if goarch == "386" && !ins.x86Encoded || len(ins.Args) != 4 && len(ins.Args) != 5 ||
+			dotted && suffix != "BCST" && suffix != "SAE" || ins.Args[0].Kind != OpImm || ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+			return fail()
+		}
+		form.immediate = uint8(ins.Args[0].Imm)
+		form.first, form.second, form.destination = 1, 2, len(ins.Args)-1
+		form.broadcast, form.sae = suffix == "BCST", suffix == "SAE"
+		form.maskResult = amd64IsKOperand(ins.Args[form.destination])
+		if form.maskResult {
+			form.byteWidth = amd64VectorByteWidth(ins.Args[form.second].Reg)
+			if len(ins.Args) == 5 {
+				if !amd64NonzeroKOperand(ins.Args[3]) {
+					return fail()
+				}
+				form.mask = 3
+			}
+		} else {
+			form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+			if dotted || len(ins.Args) != 4 || form.byteWidth != 16 && form.byteWidth != 32 {
+				return fail()
+			}
+		}
+		if spec.scalar && form.byteWidth != 16 || form.byteWidth != 16 && form.byteWidth != 32 && form.byteWidth != 64 {
+			return fail()
+		}
+	}
+	register := func(operand Operand) bool {
+		if operand.Kind != OpReg || amd64VectorByteWidth(operand.Reg) != form.byteWidth {
+			return false
+		}
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		limit := 16
+		if goarch == "386" {
+			limit = 8
+		} else if form.maskResult {
+			limit = 32
+		}
+		return valid && index < limit
+	}
+	if !register(ins.Args[form.second]) || !form.maskResult && !register(ins.Args[form.destination]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) {
+		if form.sae {
+			return fail()
+		}
+		if first.Kind == OpSym {
+			symbol := strings.TrimSpace(first.Sym)
+			_, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if first.Kind == OpMem {
+			displacement := first.Mem.Off
+			if displacement != int64(int32(displacement)) && (goarch != "386" || displacement != int64(uint32(displacement))) ||
+				!x86MemoryRegistersValidForArch(first.Mem, goarch) || first.Mem.Index != "" &&
+				(first.Mem.Index == SP || first.Mem.Scale != 1 && first.Mem.Scale != 2 && first.Mem.Scale != 4 && first.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		form.memory, form.memoryBytes = form.first, form.byteWidth
+		if spec.scalar || form.broadcast {
+			form.memoryBytes = spec.bits / 8
+		}
+	} else if !register(first) || form.broadcast {
+		return fail()
+	}
+	if form.broadcast && (spec.scalar || !form.maskResult) || form.sae && (!form.maskResult || !spec.scalar && form.byteWidth != 64) {
+		return fail()
+	}
+	return form, true, nil
+}
diff --git a/amd64_float_compare_forms_test.go b/amd64_float_compare_forms_test.go
new file mode 100644
index 000000000..7174dcf3c
--- /dev/null
+++ b/amd64_float_compare_forms_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86FloatCompareOpcodes() []string {
+	return []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"}
+}
+
+// Enumerate independently from the production grammar: yxcmpi has one
+// signed-imm8 row, _yvcmppd has eight rows, and _yvcmpsd has three rows.
+func x86FloatCompareGoForms(arch string) []string {
+	var rows []string
+	for _, opcode := range x86FloatCompareOpcodes() {
+		scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		if !strings.HasPrefix(opcode, "V") {
+			for _, source := range []string{"X0", "8(AX)", "(AX)(CX*4)"} {
+				for _, immediate := range []int{-128, -1, 0, 7, 127} {
+					rows = append(rows, fmt.Sprintf("%s %s,X1,$%d", opcode, source, immediate))
+				}
+			}
+			continue
+		}
+		if arch == "386" {
+			continue // Go rejects named VCMP; physical raw forms are separate.
+		}
+		widths := []string{"X", "Y"}
+		if scalar {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			for _, source := range []string{width + "0", "8(AX)", "(AX)(CX*4)"} {
+				for _, immediate := range []int{0, 31, 255} {
+					rows = append(rows, fmt.Sprintf("%s $%d,%s,%s1,%s2", opcode, immediate, source, width, width))
+				}
+			}
+		}
+		widths = []string{"X", "Y", "Z"}
+		if scalar {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			for _, mask := range []string{"", "K1,"} {
+				for _, destination := range []string{"K0", "K7"} {
+					for _, source := range []string{width + "20", "8(AX)", "(AX)(CX*4)"} {
+						rows = append(rows, fmt.Sprintf("%s $255,%s,%s21,%s%s", opcode, source, width, mask, destination))
+					}
+					if !scalar {
+						rows = append(rows, fmt.Sprintf("%s.BCST $31,8(AX),%s21,%s%s", opcode, width, mask, destination))
+					}
+					if scalar || width == "Z" {
+						rows = append(rows, fmt.Sprintf("%s.SAE $31,%s20,%s21,%s%s", opcode, width, width, mask, destination))
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86FloatingCompareCompleteGoGrammarFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index, row := range x86FloatCompareGoForms(arch) {
+			name := fmt.Sprintf("compare_form%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-macosx", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			ir := x86FloatingCompareUnboundFormatObject(t, source.String(), arch, triple)
+			compileLLVMToObject(t, llc, triple, "compare-formats.ll", "compare-formats.o", ir)
+		}
+		t.Logf("%s: %d original Go compare formats; public Context and emitter-only objects", arch, len(x86FloatCompareGoForms(arch)))
+	}
+}
+
+func TestX86FloatingCompareMalformedAndDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, row := range []string{
+		"CMPPS X0,X1,$128", "CMPSD X0,Y1,$0", "CMPSS $0,X1,$0", "CMPPD.SAE X0,X1,$0",
+		"VCMPPS $256,X0,X1,X2", "VCMPPD $0,X0,X1,Z2", "VCMPSS.Z $0,X0,X1,K2",
+		"VCMPPD $0,X0,X1,K0,K2", "VCMPPS.BCST $0,X0,X1,K2", "VCMPSS.BCST $0,(AX),X1,K2",
+		"VCMPPS.SAE $0,Y0,Y1,K2", "VCMPSS.SAE $0,(AX),X1,K2", "VCMPPS $0,X0,X1,X17",
+		"CMPPS (AX)(SP*2),X1,$0", "VCMPPS $0,(AX)(SP*2),X1,X2", "VCMPPS $0,$data(SB),X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				return
+			}
+			context, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			context.goarch = "amd64"
+			instruction := file.Funcs[0].Instrs[1]
+			before := output.Len()
+			known, term, err := context.lowerFloatingCompare(instruction.Op, instruction)
+			if !known || term || err == nil || output.Len() != before {
+				t.Fatalf("malformed compare emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+	for _, opcode := range x86FloatCompareOpcodes() {
+		row := opcode + " X0,X1,$0"
+		if strings.HasPrefix(opcode, "V") {
+			row = opcode + " $0,X0,X1,X2"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		context, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		context.goarch = "amd64"
+		instruction := file.Funcs[0].Instrs[1]
+		instruction.Op = "MULSS"
+		before := output.Len()
+		if known, term, err := context.lowerFloatingCompare(Op(opcode), instruction); !known || term || err == nil || output.Len() != before {
+			t.Fatalf("conflicting compare identity emitted IR: %s/%t/%t/%v", opcode, known, term, err)
+		}
+	}
+}
diff --git a/amd64_float_compare_fp_runtime_test.go b/amd64_float_compare_fp_runtime_test.go
new file mode 100644
index 000000000..a81a5d3bd
--- /dev/null
+++ b/amd64_float_compare_fp_runtime_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Only fixture layout uses the ordinary Go ABI derivation. Neither numerical
+// truth nor MXCSR expectations use the production compare implementation.
+type x86FloatCompareFPOracle struct {
+	name, declaration, row string
+	bits, predicate        int
+	mask                   bool
+	axis                   x86FloatCompareRuntimeISA
+	sig                    FuncSig
+}
+
+func x86FloatCompareFPOracles(t *testing.T) []x86FloatCompareFPOracle {
+	t.Helper()
+	var fixtures []x86FloatCompareFPOracle
+	var declarations strings.Builder
+	declarations.WriteString("package oracle\n")
+	for _, bits := range []int{32, 64} {
+		for _, spelling := range []string{"legacy", "vex", "evex"} {
+			for predicate := 0; predicate < 8; predicate++ {
+				fixture := x86FloatCompareFPOracle{
+					name: fmt.Sprintf("fp%d%s%d", bits, spelling, predicate),
+					bits: bits, predicate: predicate, mask: spelling == "evex",
+					axis: map[string]x86FloatCompareRuntimeISA{"legacy": x86FloatCompareSSE, "vex": x86FloatCompareVEX, "evex": x86FloatCompareEVEX}[spelling],
+				}
+				fixture.declaration = fmt.Sprintf("func %s(out *[20]byte,source [%d]byte,left uint%d)\n", fixture.name, bits/8, bits)
+				declarations.WriteString(fixture.declaration)
+				opcode := "CMPSS"
+				if bits == 64 {
+					opcode = "CMPSD"
+				}
+				fixture.row = fmt.Sprintf("%s source+8(FP),X0,$%d", opcode, predicate)
+				if spelling == "vex" {
+					fixture.row = fmt.Sprintf("V%s $%d,source+8(FP),X0,X2", opcode, predicate)
+				} else if spelling == "evex" {
+					fixture.row = fmt.Sprintf("V%s $%d,source+8(FP),X0,K1,K2", opcode, predicate)
+				}
+				fixtures = append(fixtures, fixture)
+			}
+		}
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "oracle.go", declarations.String(), 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	pkg, err := (&types.Config{Sizes: sizes}).Check("oracle", set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index := range fixtures {
+		fixture := &fixtures[index]
+		fixture.sig, err = DeriveGoFuncABI0Signature(fixture.name, pkg.Scope().Lookup(fixture.name).(*types.Func), "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(fixture.sig.Frame.Params) != fixture.bits/8+2 {
+			t.Fatalf("Go array did not derive independent byte fields: %+v", fixture.sig.Frame)
+		}
+	}
+	return fixtures
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpans(t *testing.T) {
+	x86FloatCompareFPScalarByteSpansRuntime(t, x86FloatCompareSSE)
+}
+
+func x86FloatCompareFPAssembly(fixtures []x86FloatCompareFPOracle) (string, map[string]FuncSig) {
+	var assembly strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, fixture := range fixtures {
+		move, destination := "MOVSS", "X0"
+		if fixture.bits == 64 {
+			move = "MOVSD"
+		}
+		if fixture.axis == x86FloatCompareVEX {
+			destination = "X2"
+		}
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVQ out+0(FP),AX\n%s left+%d(FP),X0\nMOVQ $1,DX\nKMOVQ DX,K1\n%s\n",
+			fixture.name, 8+2*(fixture.bits/8), move, 8+fixture.bits/8, fixture.row)
+		if fixture.mask {
+			assembly.WriteString("KMOVQ K2,(AX)\n")
+		} else {
+			fmt.Fprintf(&assembly, "MOVOU %s,(AX)\n", destination)
+		}
+		assembly.WriteString("STMXCSR 16(AX)\nRET\n")
+		sigs[fixture.name] = fixture.sig
+	}
+	return assembly.String(), sigs
+}
+
+func x86FloatCompareFPScalarByteSpansRuntime(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	var fixtures []x86FloatCompareFPOracle
+	for _, fixture := range x86FloatCompareFPOracles(t) {
+		if fixture.axis == axis {
+			fixtures = append(fixtures, fixture)
+		}
+	}
+	if len(fixtures) != 16 {
+		t.Fatal("incomplete scalar FP-byte-field execution axis", axis, len(fixtures))
+	}
+	assembly, sigs := x86FloatCompareFPAssembly(fixtures)
+	var wrappers, declarations, checks strings.Builder
+	for index, fixture := range fixtures {
+
+		// A C bit carrier is converted into the precise LLVM array value. C's
+		// aggregate calling convention is not assumed to match Go's signature.
+		fmt.Fprintf(&wrappers, "define void @check_%s(ptr %%out,i64 %%right,i64 %%left){\n", fixture.name)
+		packed := "poison"
+		for field := 0; field < fixture.bits/8; field++ {
+			fmt.Fprintf(&wrappers, " %%shift%d=lshr i64 %%right,%d\n %%byte%d=trunc i64 %%shift%d to i8\n %%pack%d=insertvalue [%d x i8] %s,i8 %%byte%d,%d\n",
+				field, field*8, field, field, field, fixture.bits/8, packed, field, field)
+			packed = fmt.Sprintf("%%pack%d", field)
+		}
+		left := "%left"
+		if fixture.bits == 32 {
+			wrappers.WriteString(" %left32=trunc i64 %left to i32\n")
+			left = "%left32"
+		}
+		fmt.Fprintf(&wrappers, " call void @%s(ptr %%out,[%d x i8] %s,i%d %s)\n ret void\n}\n", fixture.name, fixture.bits/8, packed, fixture.bits, left)
+		fmt.Fprintf(&declarations, "extern void check_%s(void*,uint64_t,uint64_t);\n", fixture.name)
+		fmt.Fprintf(&checks, "if(check(check_%s,%d,%d,%d))return %d;\n", fixture.name, fixture.bits, fixture.predicate,
+			x86FloatAddSubBoolInt(fixture.mask), index+1)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const check = `
+typedef void(*compare_fp)(void*,uint64_t,uint64_t);
+static int check(compare_fp call,unsigned bits,unsigned predicate,unsigned mask_result){
+ const uint64_t *edges=bits==32?edges32:edges64;
+ unsigned saved;__asm__ volatile("stmxcsr %0":"=m"(saved));
+ for(unsigned i=0;i<18;i++)for(unsigned j=0;j<18;j++)for(unsigned c=0;c<6;c++){
+  uint8_t output[22],expected[20];memset(output,0xc3,sizeof(output));memset(expected,0,20);
+  unsigned bytes=bits/8,csr=controls[c];
+  int truth=independent_compare(bits,edges[i],edges[j],predicate,csr);
+  if(mask_result){memset(expected+8,0xc3,8);expected[0]=(uint8_t)truth;}
+  else memset(expected,truth?255:0,bytes);
+  unsigned effect=original_effect(bits,edges[i],edges[j],predicate,csr);
+  memcpy(expected+16,&effect,4);
+  __asm__ volatile("ldmxcsr %0"::"m"(csr));
+  call(output+1,edges[j],edges[i]);
+  __asm__ volatile("ldmxcsr %0"::"m"(saved));
+  if(output[0]!=0xc3||output[21]!=0xc3||memcmp(output+1,expected,20)){
+   fprintf(stderr,"FP compare bits=%u pred=%u i=%u j=%u csr=%x mask=%u observed=%llx wanted=%llx\n",
+    bits,predicate,i,j,csr,mask_result,(unsigned long long)read_bits(output+1,8),(unsigned long long)read_bits(expected,8));
+   return 1;
+  }
+ }
+ return 0;
+}
+`
+	main := x86FloatCompareIndependentC + declarations.String() + check + "int main(void){\n" + checks.String() + "return 0;}\n"
+	execution.compileAndRunLLVM(t, "compare-fp-scalar-bytes", ir+wrappers.String(), main, "-O2")
+	t.Logf("%d scalar compare programs ISA-axis=%d, independently allocated 4/8 FP byte fields ×1944 inputs; actual transport=%v", len(fixtures), axis, execution.prefix)
+}
diff --git a/amd64_float_compare_immediate_class_test.go b/amd64_float_compare_immediate_class_test.go
new file mode 100644
index 000000000..fe6a5a9dc
--- /dev/null
+++ b/amd64_float_compare_immediate_class_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingCompareIntegerImmediateClassBeforeEmission(t *testing.T) {
+	for _, opcode := range x86FloatCompareOpcodes() {
+		row, index := opcode+" X0,X1,$0.0", 2
+		if strings.HasPrefix(opcode, "V") {
+			row, index = opcode+" $0.0,X0,X1,X2", 0
+		}
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, unresolved := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/unresolved=%t", opcode, unresolved), func(t *testing.T) {
+				ins := file.Funcs[0].Instrs[1]
+				ins.Args = append([]Operand(nil), ins.Args...)
+				if unresolved {
+					ins.Args[index] = Operand{Kind: OpImm, ImmRaw: "$UNRESOLVED_PREDICATE"}
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				before := output.Len()
+				if known, term, err := ctx.lowerFloatingCompare(ins.Op, ins); !known || term || err == nil || output.Len() != before {
+					t.Fatalf("floating/symbolic predicate acquired integer comparison or emitted IR: %t/%t/%v", known, term, err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_float_compare_isa_audit_test.go b/amd64_float_compare_isa_audit_test.go
new file mode 100644
index 000000000..fd67bad84
--- /dev/null
+++ b/amd64_float_compare_isa_audit_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// Observation only: no ISA permission or substitute numerical verdict.
+func TestX86FloatingCompareActualExecutionISAAudit(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	directory := t.TempDir()
+	source := filepath.Join(directory, "isa.c")
+	executable := filepath.Join(directory, "isa")
+	const program = `#include <stdint.h>
+#include <stdio.h>
+#include <cpuid.h>
+int main(void) {
+    unsigned a, b, c, d;
+    uint64_t xcr0 = 0;
+    unsigned osxsave = 0, raw_avx = 0, raw_f = 0, raw_vl = 0;
+    if (__get_cpuid(1, &a, &b, &c, &d)) {
+        osxsave = (c >> 27) & 1;
+        raw_avx = (c >> 28) & 1;
+        if (osxsave) {
+            unsigned low, high;
+            __asm__ volatile("xgetbv" : "=a"(low), "=d"(high) : "c"(0));
+            xcr0 = ((uint64_t)high << 32) | low;
+        }
+    }
+    if (__get_cpuid_count(7, 0, &a, &b, &c, &d)) {
+        raw_f = (b >> 16) & 1;
+        raw_vl = (b >> 31) & 1;
+    }
+    __builtin_cpu_init();
+    printf("SSE2=%d AVX=%d AVX2=%d AVX512F=%d AVX512VL=%d "
+           "rawAVX=%u rawAVX512F=%u rawAVX512VL=%u OSXSAVE=%u XCR0=%llx\n",
+           !!__builtin_cpu_supports("sse2"), !!__builtin_cpu_supports("avx"),
+           !!__builtin_cpu_supports("avx2"), !!__builtin_cpu_supports("avx512f"),
+           !!__builtin_cpu_supports("avx512vl"), raw_avx, raw_f, raw_vl,
+           osxsave, (unsigned long long)xcr0);
+    return 0;
+}
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	output := execution.run(t, executable)
+	t.Logf("actual execution host=%s/%s triple=%s prefix=%q: %s",
+		runtime.GOOS, runtime.GOARCH, execution.triple, execution.prefix, output)
+}
diff --git a/amd64_float_compare_native.go b/amd64_float_compare_native.go
new file mode 100644
index 000000000..eecfa705a
--- /dev/null
+++ b/amd64_float_compare_native.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A relation-only fcmp (including constrained fcmp/fcmps) is not the source
+// CMP immediate's MXCSR contract. Keep a single sideeffecting native instruction:
+// its complete vector, immediate, active mask and SAE decide IA/DE and traps.
+// In particular, a per-lane loop changes packed exception priority.
+func (c *amd64Ctx) emitNativeFloatingCompare(ins Instr, f x86FloatCompareForm) error {
+	first := ins.Args[f.first]
+	if first.Kind == OpFP && !f.scalar {
+		return fmt.Errorf("%w: %s packed FP comparison needs original contiguous native storage", ErrProbeNeedsContext, ins.Op)
+	}
+	if !f.scalar && first.Kind == OpMem && !c.nativeMemoryOperand(ins, f.first) && !c.fixedLocalMemoryCertified(ins, f.first) {
+		// A word-aligned virtual source stack is neither the original native
+		// address nor an m128 alignment witness. Do not strengthen its alloca
+		// alignment or synthesize a native shadow to suppress source faults.
+		return fmt.Errorf("%w: %s packed source stack lacks original native backing", ErrProbeNeedsContext, ins.Op)
+	}
+	if ins.x86AddressBits != 0 {
+		return fmt.Errorf("%w: %s native compare needs its original address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	if first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, f.bits/8); err != nil {
+			return err
+		}
+	}
+
+	mask := ""
+	if f.mask >= 0 {
+		value, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return err
+		}
+		mask = value
+	}
+	typ := amd64FloatingVectorType(f.byteWidth*8/f.bits, f.bits)
+	second, err := c.loadFloatingVectorOperand(ins.Args[f.second], f.byteWidth, f.byteWidth*8/f.bits, f.bits)
+	if err != nil {
+		return err
+	}
+	firstValue, firstType, firstConstraint, firstTemplate, err := c.nativeFloatingCompareSource(first, f, typ, mask)
+	if err != nil {
+		return err
+	}
+	if !f.maskResult && firstConstraint == "v" {
+		// A mixed function can also contain EVEX and therefore enable AVX512.
+		// Legacy/VEX still cannot encode registers 16-31 in this operand.
+		firstConstraint = "x"
+	}
+	mnemonic := strings.ToLower(strings.Split(string(ins.Op), ".")[0])
+	immediate := f.immediate
+	result := c.newTmp()
+	clobbers := "~{memory},~{fpsr}"
+
+	if f.maskResult {
+		// The K result is private physical scratch. Inputs/outputs remain
+		// virtual; real k1/k2 do not become public caller transports.
+		assembly := ""
+		constraints := "=r," + firstConstraint + ",v"
+		args := fmt.Sprintf("%s %s, %s %s", firstType, firstValue, typ, second)
+		if mask != "" {
+			assembly = "kmovw ${3:k}, %k2; "
+			constraints += ",r,~{k2}"
+			args += ", i32 " + c.approximateMathMask32(mask)
+		}
+		assembly += fmt.Sprintf("%s $$%d, ", mnemonic, immediate)
+		if f.sae {
+			assembly += "{sae}, "
+		}
+		if f.broadcast {
+			firstTemplate += fmt.Sprintf(" {1to%d}", f.byteWidth*8/f.bits)
+		}
+		assembly += firstTemplate + ", $2, %k1"
+		if mask != "" {
+			assembly += " {%k2}"
+		}
+		assembly += "; kmovw %k1, ${0:k}"
+		fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q(%s)\n", result, assembly, constraints+",~{k1},"+clobbers, args)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		return c.storeK(ins.Args[f.destination].Reg, "%"+wide)
+	}
+
+	assembly := fmt.Sprintf("%s $$%d, ", mnemonic, immediate)
+	constraints := "=x,"
+	args := ""
+	if f.legacy {
+		// Tie the full old X value: scalar compares preserve upper X bytes.
+		assembly += strings.Replace(firstTemplate, "$1", "$2", 1) + ", $0"
+		constraints += "0," + firstConstraint
+		args = fmt.Sprintf("%s %s, %s %s", typ, second, firstType, firstValue)
+	} else {
+		assembly += firstTemplate + ", $2, $0"
+		constraints += firstConstraint + ",x"
+		args = fmt.Sprintf("%s %s, %s %s", firstType, firstValue, typ, second)
+	}
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+","+clobbers, args)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, f.byteWidth)
+	if f.legacy {
+		return c.storeLegacyXViews(ins.Args[f.destination].Reg, "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[f.destination], f.byteWidth, "%"+bytes)
+}
+
+func (c *amd64Ctx) nativeFloatingCompareSource(source Operand, f x86FloatCompareForm, typ, mask string) (value, sourceType, constraint, template string, err error) {
+	if source.Kind == OpFP {
+		// Scalar compare observes only the low field. Assemble its checked
+		// bytes as integer data, not a fabricated contiguous native FP pointer.
+		bits, loadErr := c.loadFloatBinaryScalar(source, f.bits, mask)
+		if loadErr != nil {
+			return "", "", "", "", loadErr
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s zeroinitializer, %s %s, i32 0\n", inserted, typ, amd64FloatingScalarType(f.bits), bits)
+		return "%" + inserted, typ, "v", "$1", nil
+	}
+	if source.Kind == OpReg {
+		value, err = c.loadFloatingVectorOperand(source, f.byteWidth, f.byteWidth*8/f.bits, f.bits)
+		return value, typ, "v", "$1", err
+	}
+	if source.Kind != OpMem && source.Kind != OpSym {
+		return "", "", "", "", fmt.Errorf("%w: native compare source lacks original memory binding", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", "", "", "", err
+	}
+	segment := ""
+	if source.Kind == OpMem && source.Mem.Segment != "" {
+		segment = "%" + strings.ToLower(string(source.Mem.Segment)) + ":"
+	}
+	return pointer, fmt.Sprintf("%s elementtype([%d x i8])", pointerType, f.memoryBytes), "*m", segment + "$1", nil
+}
diff --git a/amd64_float_compare_native_test.go b/amd64_float_compare_native_test.go
new file mode 100644
index 000000000..c8b858851
--- /dev/null
+++ b/amd64_float_compare_native_test.go
@@ -0,0 +1,311 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestX86FloatCompareNativeOriginalInstruction(t *testing.T) {
+	for _, row := range []string{
+		"CMPPS X0,X1,$3", "CMPSD 3(AX),X1,$1",
+		"VCMPPS $11,Y0,Y1,Y2", "VCMPPD $15,Z0,Z1,K3,K2",
+		"VCMPPS.BCST $31,3(AX),Z1,K3,K2", "VCMPSS.SAE $31,X0,X1,K3,K2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			ir := x86FloatingCompareUnboundFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+			opcode := strings.ToLower(strings.Split(row, " ")[0])
+			opcode = strings.Split(opcode, ".")[0]
+			if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, opcode+" $$") || strings.Contains(ir, " = fcmp ") {
+				t.Fatalf("original whole instruction/CSR effect missing:\n%s", ir)
+			}
+		})
+	}
+}
+
+func TestX86FloatCompareNativeAllPredicatesObjectsAndDeadO2(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source strings.Builder
+	count := 0
+	for _, opcode := range x86FloatCompareOpcodes() {
+		for _, row := range x86FloatCompareOracleCases(opcode) {
+			name := fmt.Sprintf("native_compare%d", count)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row.row)
+			count++
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	for _, triple := range []string{"x86_64-apple-macosx", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		ir := x86FloatingCompareUnboundFormatObject(t, source.String(), "amd64", triple)
+		if strings.Count(ir, "asm sideeffect") != count {
+			t.Fatalf("whole-instruction sideeffects=%d want=%d", strings.Count(ir, "asm sideeffect"), count)
+		}
+		compileLLVMToObject(t, llc, triple, "native-compare.ll", "native-compare.o", ir)
+		path := filepath.Join(t.TempDir(), "dead.ll")
+		if err := os.WriteFile(path, []byte(ir), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+		command := exec.CommandContext(ctx, llc, "-O2", "-mtriple="+triple, "-filetype=asm", path, "-o", "-")
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("dead native effect object: %v\n%s", err, output)
+		}
+		// LLVM's assembly printer canonicalizes CMP-immediate mnemonics to
+		// predicate aliases (cmpeqps, vcmptrue_uspd, ...). Count those actual
+		// instructions, not the source spelling, after optimizing dead results.
+		compares := regexp.MustCompile(`(?m)^\s+v?cmp[a-z0-9_]*(ps|pd|ss|sd)\s+`).FindAll(output, -1)
+		if len(compares) != count {
+			t.Fatalf("dead O2 retained %d native comparisons, want %d", len(compares), count)
+		}
+	}
+	t.Logf("%d independent 8/32-predicate forms: 3 objects plus dead O2 native emission", count)
+}
+
+func TestX86FloatCompareNativePhysicalMemoryAndPrefixContract(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index, row := range []string{
+			"CMPPS 16(AX)(CX*4),X1,$127", "CMPSS 3(FS),X1,$-128",
+			"CMPPD 16(GS),X1,$-1", "CMPSD 256,X1,$7",
+		} {
+			name := fmt.Sprintf("memory%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		triples := []string{"x86_64-apple-macosx", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			ir := x86FloatingCompareUnboundFormatObject(t, source.String(), arch, triple)
+			for _, want := range []string{"%fs:$2", "%gs:$2", "elementtype([16 x i8])", "elementtype([4 x i8])", "elementtype([8 x i8])", "$$127", "$$128", "$$255"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s original memory/predicate contract lost %s:\n%s", arch, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "native-memory.ll", "native-memory.o", ir)
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nCMPPS (AX),X1,$0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+	ctx.goarch = "amd64"
+	ins := file.Funcs[0].Instrs[1]
+	ins.x86AddressBits = 32
+	before := output.Len()
+	if _, _, err := ctx.lowerFloatingCompare(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != before {
+		t.Fatalf("unbound native address prefix emitted compare IR: %v", err)
+	}
+}
+
+func TestX86FloatCompareNativeRawMode32HighBanksRemainContext(t *testing.T) {
+	for _, code := range [][]byte{
+		encodeX86VEXVectorFloatCompare(0, false, 8, 1, 0, 0),
+		encodeX86VEXVectorFloatCompare(1, true, 2, 8, 0, 0),
+		encodeX86VEXVectorFloatCompare(2, false, 2, 1, 8, 0),
+		encodeX86EVEXVectorFloatCompare(0, 2, false, 3, 2, 8, 0, 0),
+		encodeX86EVEXVectorFloatCompare(1, 0, false, 3, 2, 1, 8, 0),
+		encodeX86EVEXVectorFloatCompare(2, 0, false, 3, 2, 1, 16, 0),
+	} {
+		if _, _, known, err := decodedX86VectorFloatCompareInstruction(code, 32); !known || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("mode32 high-bank %x gained a native binding: %v", code, err)
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nVCMPPS $0,X0,X1,X2\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "386", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); err == nil {
+		t.Fatal("named mode32 source impersonated private raw decoding")
+	}
+}
+
+func TestX86FloatCompareNativeRawMode32PhysicalForms(t *testing.T) {
+	mc, llc := findLLVM22Tool("llvm-mc"), findLLVM22Tool("llc")
+	if mc == "" || llc == "" {
+		t.Fatal("LLVM22 mc/llc required")
+	}
+	var source strings.Builder
+	count := 0
+	for pp := byte(0); pp < 4; pp++ {
+		widths := []byte{0, 1, 2}
+		if pp >= 2 {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			for predicate := byte(0); predicate < 32; predicate++ {
+				var codes [][]byte
+				if width != 2 {
+					codes = append(codes, encodeX86VEXVectorFloatCompare(pp, width == 1, 2, 1, 0, predicate))
+				}
+				codes = append(codes, encodeX86EVEXVectorFloatCompare(pp, width, false, 3, 2, 1, 0, predicate))
+				if pp >= 2 || width == 2 {
+					codes = append(codes, encodeX86EVEXVectorFloatCompare(pp, width, true, 3, 2, 1, 0, predicate))
+				}
+				for _, code := range codes {
+					ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+					command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=i386-unknown-linux-gnu", "--mattr=+avx,+avx512f,+avx512vl")
+					var hex strings.Builder
+					for _, b := range code {
+						fmt.Fprintf(&hex, "0x%02x ", b)
+					}
+					command.Stdin = strings.NewReader(hex.String())
+					output, err := runtimeOracleCombinedOutput(ctx, command)
+					cancel()
+					if err != nil || strings.Contains(string(output), "warning:") || !strings.Contains(string(output), "vcmp") {
+						t.Fatalf("physical i386 compare %x: %v\n%s", code, err, output)
+					}
+					name := fmt.Sprintf("raw_native%d", count)
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", name)
+					for _, b := range code {
+						fmt.Fprintf(&source, "BYTE $%d\n", b)
+					}
+					source.WriteString("RET\n")
+					count++
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "386", source.String(), "", true)
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir := x86FloatingCompareUnboundFormatObject(t, source.String(), "386", triple)
+		compileLLVMToObject(t, llc, triple, "raw-native-compare.ll", "raw-native-compare.o", ir)
+	}
+	t.Logf("%d physical low-bank i386 forms independently decoded by LLVM22; 2 objects", count)
+}
+
+func TestX86FloatCompareNativePackedVirtualFPNeedsContext(t *testing.T) {
+	for _, row := range []string{
+		"CMPPS a+0(FP),X1,$0", "VCMPPD $3,a+0(FP),Y1,Y2", "VCMPPS.BCST $3,a+0(FP),Z1,K2",
+		"CMPPS 16(SP),X1,$0", "CMPPD 16(BP),X1,$0", "VCMPPS $0,16(SP),Z1,K2", "VCMPPD $0,(AX)(BP*4),Y1,Y2",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": {Ret: Void}}})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s fabricated native backing: %v", row, err)
+		}
+	}
+}
+
+func TestX86FloatCompareNativeScalarFPIndependentByteFields(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, opcode := range []string{"CMPSS", "CMPSD", "VCMPSS", "VCMPSD"} {
+		width := 4
+		if strings.HasSuffix(opcode, "SD") {
+			width = 8
+		}
+		row := opcode + " a+0(FP),X1,$3"
+		if strings.HasPrefix(opcode, "V") {
+			row = opcode + " $3,a+0(FP),X1,K3,K2"
+		}
+		original := "TEXT f(SB),4,$0-8\n" + row + "\nRET\n"
+		sig := FuncSig{Ret: Void}
+		var names []string
+		for index := 0; index < width; index++ {
+			sig.Args = append(sig.Args, I8)
+			sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(index), Type: I8, Index: index, Field: -1})
+			names = append(names, string(rune('a'+index)))
+		}
+		declaration := "func f(" + strings.Join(names, ",") + " uint8)"
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", original)
+		prefix := "PXOR X1,X1\n"
+		if strings.HasPrefix(opcode, "V") {
+			prefix += "MOVL $1,AX\nKMOVW AX,K3\n"
+		}
+		source := strings.Replace(original, row+"\n", prefix+row+"\n", 1)
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, original, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if strings.HasPrefix(opcode, "V") {
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original FP format invented its mask input", opcode, api, err)
+				}
+			} else {
+				x86VectorScratchCodegenControl(t, original, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			}
+			ir, err = x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "elementtype(") || !strings.Contains(ir, "asm sideeffect") || strings.Count(ir, "load i8, ptr %fp_") != width {
+				t.Fatalf("%s invented contiguous native FP backing or omitted field bytes:\n%s", row, ir)
+			}
+			compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "scalar-fp.ll", "scalar-fp.o", ir)
+		}
+		// Even an inactive EVEX mask cannot bless an invalid source span.
+		sig.Frame.Params = sig.Frame.Params[:width-1]
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": sig}}); err == nil {
+			t.Fatalf("%s missing final FP byte accepted", row)
+		}
+	}
+}
+
+func TestX86FloatCompareNativeMixedISAUsesLowVEXConstraints(t *testing.T) {
+	const source = "TEXT f(SB),4,$0-0\nCMPSS X0,X1,$3\nVCMPPS $3,Y0,Y1,Y2\nVCMPPS $3,Z0,Z1,K2\nRET\n"
+	ir := x86FloatingCompareUnboundFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, `"=x,0,x,`) || !strings.Contains(ir, `"=x,x,x,`) || !strings.Contains(ir, `"=r,v,v,`) {
+		t.Fatalf("mixed EVEX function widened a legacy/VEX physical register class:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "mixed-isa.ll", "mixed-isa.o", ir)
+}
+
+func TestX86FloatCompareNativeValidatedPrivateFeatures(t *testing.T) {
+	for _, tc := range []struct{ row, want string }{
+		{"CMPPS X0,X1,$0", "+sse"},
+		{"CMPSD X0,X1,$0", "+sse2"},
+		{"VCMPPS $0,Y0,Y1,Y2", "+avx"},
+		{"VCMPPS $0,X0,X1,K2", "+avx512f,+avx512vl"},
+		{"VCMPSS $0,X0,X1,K2", "+avx512f"},
+		{"VCMPPS $0,Z0,Z1,K2", "+avx512f"},
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+tc.row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", file.Funcs[0]); got != tc.want {
+			t.Errorf("%s features=%q want=%q", tc.row, got, tc.want)
+		}
+	}
+	for _, row := range []string{"VCMPPS $256,Z0,Z1,K2", "VCMPPS.Z $0,Z0,Z1,K2", "VCMPSS $0,X0,Y1,K2"} {
+		file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT f(SB),4,$0-0\n%s\nRET\n", row))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", file.Funcs[0]); got != "" {
+			t.Errorf("malformed source gained ISA permission: %s/%s", row, got)
+		}
+	}
+}
diff --git a/amd64_float_compare_numerical_test.go b/amd64_float_compare_numerical_test.go
new file mode 100644
index 000000000..4bd3cf317
--- /dev/null
+++ b/amd64_float_compare_numerical_test.go
@@ -0,0 +1,257 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86FloatCompareOracleCase struct {
+	row                           string
+	bits, width, predicate        int
+	scalar, legacy, maskResult    bool
+	memory, broadcast, suppressed bool
+	destination                   int
+}
+
+// Enumerate this matrix from explicit architectural axes, not the production
+// grammar, predicate table, memory-shape classifier or caller effect registry.
+func x86FloatCompareOracleCases(opcode string) []x86FloatCompareOracleCase {
+	bits := 32
+	if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+		bits = 64
+	}
+	scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+	legacy := !strings.HasPrefix(opcode, "V")
+	predicates := 32
+	if legacy {
+		predicates = 8
+	}
+	var cases []x86FloatCompareOracleCase
+	for predicate := 0; predicate < predicates; predicate++ {
+		for variant := 0; variant < 2; variant++ {
+			width := 16
+			if !legacy && !scalar && predicate%2 != 0 {
+				width = 32
+			}
+			bank := map[int]string{16: "X", 32: "Y"}[width]
+			first, destination := bank+"1", predicate%3
+			if variant == 1 {
+				first = "(CX)"
+			}
+			row := fmt.Sprintf("%s $%d,%s,%s0,%s%d", opcode, predicate, first, bank, bank, destination)
+			if legacy {
+				destination = 0
+				row = fmt.Sprintf("%s %s,X0,$%d", opcode, first, predicate)
+			}
+			cases = append(cases, x86FloatCompareOracleCase{row: row, bits: bits, width: width,
+				predicate: predicate, scalar: scalar, legacy: legacy, memory: variant == 1, destination: destination})
+		}
+		if legacy {
+			continue
+		}
+		for variant := 0; variant < 4; variant++ {
+			width := []int{16, 32, 64}[predicate%3]
+			if scalar {
+				width = 16
+			}
+			if variant == 3 && !scalar {
+				width = 64 // Go only permits packed SAE at Z width.
+			}
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			first, operation := bank+"1", opcode
+			memory, broadcast := variant == 1 || variant == 2, variant == 2 && !scalar
+			if memory {
+				first = "(CX)"
+			}
+			if broadcast {
+				operation += ".BCST"
+			}
+			if variant == 3 {
+				operation += ".SAE"
+			}
+			row := fmt.Sprintf("%s $%d,%s,%s0,K1,K2", operation, predicate, first, bank)
+			cases = append(cases, x86FloatCompareOracleCase{row: row, bits: bits, width: width,
+				predicate: predicate, scalar: scalar, maskResult: true, memory: memory,
+				broadcast: broadcast, suppressed: variant == 3})
+		}
+	}
+	return cases
+}
+
+func x86FloatCompareOracleAssembly(cases []x86FloatCompareOracleCase, dead bool) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, c := range cases {
+		name := fmt.Sprintf("compare%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (BX),Z0\nVMOVUPS (BX),Z2\n", name)
+		if !c.memory {
+			source.WriteString("VMOVUPS (CX),Z1\n")
+		}
+		source.WriteString("KMOVQ DX,K1\nKMOVQ DX,K2\nSTC\n" + c.row + "\n")
+		if !dead {
+			if c.maskResult {
+				source.WriteString("KMOVQ K2,8(AX)\n")
+			} else {
+				fmt.Fprintf(&source, "VMOVUPS Z%d,8(AX)\n", c.destination)
+			}
+		}
+		source.WriteString("SETCS 72(AX)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+	}
+	return source.String(), sigs
+}
+
+func x86FloatCompareOracleMain(cases []x86FloatCompareOracleCase, dead bool) string {
+	var declarations, descriptors strings.Builder
+	for index, c := range cases {
+		fmt.Fprintf(&declarations, "extern void compare%d(void*,const void*,const void*,uint64_t);\n", index)
+		fmt.Fprintf(&descriptors, "{compare%d,%d,%d,%d,%d,%d,%d,%d,%d,%d},\n", index, c.bits, c.width, c.predicate,
+			x86FloatAddSubBoolInt(c.scalar), x86FloatAddSubBoolInt(c.legacy), x86FloatAddSubBoolInt(c.maskResult),
+			x86FloatAddSubBoolInt(c.memory), x86FloatAddSubBoolInt(c.broadcast), x86FloatAddSubBoolInt(c.suppressed))
+	}
+	return x86FloatCompareIndependentC + declarations.String() + `
+typedef void (*compare_fn)(void*,const void*,const void*,uint64_t);
+struct comparison {compare_fn call;unsigned bits,width,predicate,scalar,legacy,mask_result,memory,broadcast,sae;};
+static const struct comparison comparisons[]={
+` + descriptors.String() + fmt.Sprintf(`
+};
+int main(void){
+ const uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX};
+ unsigned saved;__asm__ volatile("stmxcsr %%0":"=m"(saved));
+ for(unsigned index=0;index<sizeof(comparisons)/sizeof(comparisons[0]);index++){
+  const struct comparison *c=comparisons+index;unsigned bytes=c->bits/8;
+  const uint64_t *edges=c->bits==32?edges32:edges64;
+  for(unsigned pair=0;pair<18;pair++) for(unsigned m=0;m<4;m++) for(unsigned control=0;control<6;control++){
+   _Alignas(64) uint8_t aStorage[192],bStorage[192];
+   uint8_t *a=aStorage+64,*b=bStorage+64,out[81],want[64];
+   memset(aStorage,0xa7,sizeof(aStorage));memset(bStorage,0xb9,sizeof(bStorage));memset(out,0xc3,sizeof(out));
+   for(unsigned lane=0;lane<64/bytes;lane++){
+    uint64_t av=edges[(pair+lane)%%18],bv=edges[(pair*7+lane*3+1)%%18];
+    // Extended predicates have no actual AVX512 execution oracle here. Keep
+    // denormal and NaN coverage, but do not mix them in a single extended
+    // comparison: the diagnostic SSE class representative is not a proof of
+    // that exception-priority corner (the original legacy matrix retains it).
+    if(c->predicate>=8 && ((is_denormal(c->bits,av)&&is_nan(c->bits,bv)) ||
+       (is_nan(c->bits,av)&&is_denormal(c->bits,bv)))) {
+     if(is_denormal(c->bits,av))av=0;
+     if(is_denormal(c->bits,bv))bv=0;
+    }
+    memcpy(a+lane*bytes,&av,bytes);memcpy(b+lane*bytes,&bv,bytes);
+   }
+   uint8_t beforeA[192],beforeB[192];memcpy(beforeA,aStorage,192);memcpy(beforeB,bStorage,192);
+   unsigned csr=controls[control],after,expectedCSR=csr;uint64_t expectedMask=0;
+   memset(want,0,64);
+   if(c->legacy)memcpy(want,a,64);else if(c->scalar)memcpy(want,a,16);
+   unsigned lanes=c->scalar?1:c->width/bytes;
+   for(unsigned lane=0;lane<lanes;lane++){
+    int active=!c->mask_result || ((masks[m]>>lane)&1);
+    if(!active)continue;
+    uint64_t av=read_bits(a+lane*bytes,bytes),bv=read_bits(b+(c->broadcast?0:lane*bytes),bytes);
+    int truth=independent_compare(c->bits,av,bv,c->predicate,csr);
+    if(truth)expectedMask|=UINT64_C(1)<<lane;
+    memset(want+lane*bytes,truth?255:0,bytes);
+    if(!c->sae)expectedCSR|=original_effect(c->bits,av,bv,c->predicate,csr)&63;
+   }
+   __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+   const uint8_t *input=c->mask_result&&c->memory&&m==0?0:b;
+   c->call(out,a,input,masks[m]);
+   __asm__ volatile("stmxcsr %%0":"=m"(after));
+   __asm__ volatile("ldmxcsr %%0"::"m"(saved));
+   if(after!=expectedCSR){fprintf(stderr,"compare%%u pred=%%u mxcsr=%%x want=%%x mask=%%llx\n",index,c->predicate,after,expectedCSR,(unsigned long long)masks[m]);return 10;}
+   if(out[72]!=1||memcmp(aStorage,beforeA,192)||memcmp(bStorage,beforeB,192))return 11;
+   for(unsigned byte=0;byte<81;byte++){
+    uint8_t expected=0xc3;
+    if(byte==72)expected=1;
+    if(!%d&&byte>=8&&byte<72){
+     if(c->mask_result){if(byte<16)expected=(uint8_t)(expectedMask>>(8*(byte-8)));}
+     else expected=want[byte-8];
+    }
+    if(out[byte]!=expected){fprintf(stderr,"compare%%u pred=%%u byte=%%u got=%%x want=%%x\n",index,c->predicate,byte,out[byte],expected);return 12;}
+   }
+  }
+ }
+ __asm__ volatile("ldmxcsr %%0"::"m"(saved));return 0;
+}
+`, x86FloatAddSubBoolInt(dead))
+}
+
+// Keep optimized-away results separate: a compare still has MXCSR/trap and
+// memory effects. Both optimization levels execute the same independent C.
+func x86FloatCompareRunOptimization(t *testing.T, execution x86FloatCompareExecution, ir, main, level string) {
+	t.Helper()
+	execution.compileAndRunLLVM(t, "compare-effects", ir, main, level)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSR(t *testing.T) {
+	x86FloatCompareIndependentRuntime(t, x86FloatCompareSSE)
+}
+
+func x86FloatCompareIndependentRuntime(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		cases := x86FloatCompareRuntimeCases(opcode, axis)
+		if len(cases) == 0 {
+			continue
+		}
+		t.Run(opcode, func(t *testing.T) {
+			assembly, sigs := x86FloatCompareOracleAssembly(cases, false)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			main := x86FloatCompareOracleMain(cases, false)
+			execution.compileAndRunLLVM(t, "compare-ieee", ir, main, "-O2")
+			t.Logf("%s ISA-axis=%d: %d independently enumerated programs ×432 IEEE/DAZ/full-MXCSR/mask/upper-alias/canary inputs; extended NaN+denormal priority is not covered; actual transport=%v", opcode, axis, len(cases), execution.prefix)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffects(t *testing.T) {
+	x86FloatCompareDeadResultRuntime(t, x86FloatCompareSSE)
+}
+
+func x86FloatCompareDeadPredicate(predicate int) bool {
+	return predicate == 0 || predicate == 1 || predicate == 11 || predicate == 15 || predicate == 27 || predicate == 31
+}
+
+func x86FloatCompareDeadResultRuntime(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			var cases []x86FloatCompareOracleCase
+			for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+				for _, c := range x86FloatCompareRuntimeCases(opcode, axis) {
+					if x86FloatCompareDeadPredicate(c.predicate) {
+						cases = append(cases, c)
+					}
+				}
+			}
+			assembly, sigs := x86FloatCompareOracleAssembly(cases, true)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86FloatCompareRunOptimization(t, execution, ir, x86FloatCompareOracleMain(cases, true), level)
+			t.Logf("dead-result ISA-axis=%d: %d complete programs ×432 inputs, %s, actual transport=%v", axis, len(cases), level, execution.prefix)
+		})
+	}
+}
diff --git a/amd64_float_compare_oracle_test.go b/amd64_float_compare_oracle_test.go
new file mode 100644
index 000000000..b70309cee
--- /dev/null
+++ b/amd64_float_compare_oracle_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// Intel SDM Vol.2A Table 3-1 supplies the relation truth columns and signaling
+// column. The relation reference uses only integer IEEE encodings; neither it
+// nor the native original scalar CMP exception oracle calls a production helper.
+// COMIS/UCOMIS and quiet imm0 are not substituted for legacy predicates: their
+// observed exception priority differs for NaN/denormal pairs under Rosetta.
+const x86FloatCompareIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static const unsigned relation_truth[32]={
+ 4,2,6,8,11,13,9,7,12,10,14,0,3,5,1,15,
+ 4,2,6,8,11,13,9,7,12,10,14,0,3,5,1,15};
+static int is_nan(unsigned bits,uint64_t a) {
+ uint64_t fraction=bits==32?0x7fffff:UINT64_C(0xfffffffffffff);
+ uint64_t exponent=bits==32?0x7f800000:UINT64_C(0x7ff0000000000000);
+ return (a&exponent)==exponent && (a&fraction)!=0;
+}
+static uint64_t normalized(unsigned bits,uint64_t a,unsigned csr) {
+ uint64_t sign=bits==32?0x80000000:UINT64_C(0x8000000000000000);
+ uint64_t exponent=bits==32?0x7f800000:UINT64_C(0x7ff0000000000000);
+ if(bits==32) a&=UINT64_C(0xffffffff);
+ if((csr&64) && !(a&exponent)) a&=sign;
+ return a;
+}
+static int independent_compare(unsigned bits,uint64_t a,uint64_t b,unsigned pred,unsigned csr) {
+ a=normalized(bits,a,csr); b=normalized(bits,b,csr);
+ unsigned relation;
+ if(is_nan(bits,a)||is_nan(bits,b)) relation=8;
+ else {
+  uint64_t sign=bits==32?0x80000000:UINT64_C(0x8000000000000000);
+  uint64_t mask=bits==32?UINT64_C(0xffffffff):UINT64_MAX;
+  if(a==b || (!(a&~sign)&&!(b&~sign))) relation=4;
+  else {
+   uint64_t ak=(a&sign)?(~a&mask):(a^sign);
+   uint64_t bk=(b&sign)?(~b&mask):(b^sign);
+   relation=ak<bk?2:1;
+  }
+ }
+ return (relation_truth[pred&31]&relation)!=0;
+}
+static unsigned original_effect(unsigned bits,uint64_t a,uint64_t b,unsigned pred,unsigned csr) {
+ unsigned saved,after;
+ __asm__ volatile("stmxcsr %0":"=m"(saved));
+ __asm__ volatile("ldmxcsr %0"::"m"(csr));
+ // The eight original SSE predicates have actual, independently emitted
+ // instructions. Extended predicates use only the documented quiet/signaling
+ // class for inputs without the diagnostic NaN/denormal ambiguity.
+ unsigned native_pred=pred<8?pred:((UINT32_C(0x99996666)>>(pred&31))&1);
+#define CMP_EFFECT(op) do { \
+ switch(native_pred) { \
+ case 0: __asm__ volatile(op " $0,%1,%0":"+x"(x):"x"(y));break; \
+ case 1: __asm__ volatile(op " $1,%1,%0":"+x"(x):"x"(y));break; \
+ case 2: __asm__ volatile(op " $2,%1,%0":"+x"(x):"x"(y));break; \
+ case 3: __asm__ volatile(op " $3,%1,%0":"+x"(x):"x"(y));break; \
+ case 4: __asm__ volatile(op " $4,%1,%0":"+x"(x):"x"(y));break; \
+ case 5: __asm__ volatile(op " $5,%1,%0":"+x"(x):"x"(y));break; \
+ case 6: __asm__ volatile(op " $6,%1,%0":"+x"(x):"x"(y));break; \
+ case 7: __asm__ volatile(op " $7,%1,%0":"+x"(x):"x"(y));break; \
+ } \
+} while(0)
+ if(bits==32) {
+  uint32_t av=(uint32_t)a,bv=(uint32_t)b; float x,y;
+  memcpy(&x,&av,4); memcpy(&y,&bv,4);
+  CMP_EFFECT("cmpss");
+ } else {
+  double x,y; memcpy(&x,&a,8); memcpy(&y,&b,8);
+  CMP_EFFECT("cmpsd");
+ }
+#undef CMP_EFFECT
+ __asm__ volatile("stmxcsr %0":"=m"(after));
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));
+ return after;
+}
+static int is_denormal(unsigned bits,uint64_t a) {
+ uint64_t fraction=bits==32?0x7fffff:UINT64_C(0xfffffffffffff);
+ uint64_t exponent=bits==32?0x7f800000:UINT64_C(0x7ff0000000000000);
+ return !(a&exponent) && (a&fraction)!=0;
+}
+static const uint64_t edges32[]={0,0x80000000,1,0x80000001,0x7fffff,0x800000,
+ 0x3f800000,0xbf800000,0x3f800001,0x7f7fffff,0xff7fffff,0x7f800000,
+ 0xff800000,0x7fc12345,0xffc45678,0x7f812345,0xff845678,0x7fffffff};
+static const uint64_t edges64[]={0,UINT64_C(0x8000000000000000),1,
+ UINT64_C(0x8000000000000001),UINT64_C(0xfffffffffffff),UINT64_C(0x10000000000000),
+ UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000001),
+ UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),UINT64_C(0x7ff0000000000000),
+ UINT64_C(0xfff0000000000000),UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff8fedcba987654),
+ UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff0fedcba987654),UINT64_C(0x7fffffffffffffff)};
+static const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1fbf,0x7fc5};
+static uint64_t read_bits(const uint8_t *p,unsigned bytes) {
+ uint64_t value=0; memcpy(&value,p,bytes); return value;
+}
+`
+
+// An actual SSE instruction has a compile-time immediate. This switch covers
+// all eight legacy predicates, independently of LLVM's predicate selection.
+func x86FloatCompareOriginalC() string {
+	var source strings.Builder
+	source.WriteString(x86FloatCompareIndependentC)
+	for index, op := range []string{"cmpps", "cmppd", "cmpss", "cmpsd"} {
+		fmt.Fprintf(&source, "static void original%d(uint8_t *out,const uint8_t *a,const uint8_t *b,unsigned pred,unsigned csr){\n unsigned saved,after; __asm__ volatile(\"stmxcsr %%0\":\"=m\"(saved));\n __asm__ volatile(\"ldmxcsr %%0\"::\"m\"(csr));\n typedef uint8_t v16 __attribute__((vector_size(16))); v16 x,y; memcpy(&x,a,16); memcpy(&y,b,16);\n switch(pred){\n", index)
+		for pred := 0; pred < 8; pred++ {
+			fmt.Fprintf(&source, " case %d: __asm__ volatile(\"%s $%d,%%1,%%0\":\"+x\"(x):\"x\"(y)); break;\n", pred, op, pred)
+		}
+		source.WriteString(" }\n __asm__ volatile(\"stmxcsr %0\":\"=m\"(after));\n __asm__ volatile(\"ldmxcsr %0\"::\"m\"(saved)); memcpy(out,&x,16); memcpy(out+16,&after,4);\n}\n")
+	}
+	source.WriteString("typedef void (*original_fn)(uint8_t*,const uint8_t*,const uint8_t*,unsigned,unsigned);\n static original_fn originals[]={original0,original1,original2,original3};\n")
+	return source.String()
+}
+
+func x86FloatCompareCaptureCommand(t *testing.T, command *exec.Cmd) []byte {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	// Keep one lifecycle/deadline per actual command, including the original-Go
+	// driver and the independently compiled native SSE reference.
+	bounded := exec.CommandContext(ctx, command.Path, command.Args[1:]...)
+	bounded.Dir, bounded.Env = command.Dir, command.Env
+	output, err := runtimeOracleCombinedOutput(ctx, bounded)
+	if err != nil {
+		t.Fatalf("compare oracle command %q: %v\n%s", command.Args, err, output)
+	}
+	return output
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareOriginalLegacyPredicates(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	var assembly, declarations strings.Builder
+	assembly.WriteString("#include \"textflag.h\"\n")
+	for index, op := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD"} {
+		for pred := 0; pred < 8; pred++ {
+			name := fmt.Sprintf("legacy%d_%d", index, pred)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),NOSPLIT,$8-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nSTMXCSR 0(SP)\nLDMXCSR csr+24(FP)\nMOVOU (BX),X0\nMOVOU (CX),X1\n%s X1,X0,$%d\nMOVOU X0,(AX)\nSTMXCSR 16(AX)\nLDMXCSR 0(SP)\nRET\n", name, op, pred)
+			fmt.Fprintf(&declarations, "func %s(out,a,b *[20]byte,csr uint32)\n", name)
+		}
+	}
+	var functions strings.Builder
+	for index := 0; index < 4; index++ {
+		for pred := 0; pred < 8; pred++ {
+			fmt.Fprintf(&functions, "legacy%d_%d,", index, pred)
+		}
+	}
+	const goDriver = `package main
+import("encoding/binary";"fmt")
+func main(){
+ functions:=[]func(*[20]byte,*[20]byte,*[20]byte,uint32){FUNCTIONS}
+ edges32:=[]uint64{0,0x80000000,1,0x80000001,0x7fffff,0x800000,0x3f800000,0xbf800000,0x3f800001,0x7f7fffff,0xff7fffff,0x7f800000,0xff800000,0x7fc12345,0xffc45678,0x7f812345,0xff845678,0x7fffffff}
+ edges64:=[]uint64{0,0x8000000000000000,1,0x8000000000000001,0xfffffffffffff,0x10000000000000,0x3ff0000000000000,0xbff0000000000000,0x3ff0000000000001,0x7fefffffffffffff,0xffefffffffffffff,0x7ff0000000000000,0xfff0000000000000,0x7ff8123456789abc,0xfff8fedcba987654,0x7ff0123456789abc,0xfff0fedcba987654,0x7fffffffffffffff}
+ controls:=[]uint32{0x1f80,0x1fc0,0x9f80,0x9fc0,0x1fbf,0x7fc5}
+ hash:=uint64(1469598103934665603)
+ for index,fn:=range functions{
+  bytes,edges:=4,edges32
+  if index/8==1||index/8==3{bytes,edges=8,edges64}
+  for _,av:=range edges{for _,bv:=range edges{for _,csr:=range controls{
+   var a,b [20]byte
+   out:=struct{before byte;data [20]byte;after byte}{before:0xa7,after:0xb9}
+   for i:=0;i<16;i+=bytes{
+    if bytes==4{binary.LittleEndian.PutUint32(a[i:],uint32(av));binary.LittleEndian.PutUint32(b[i:],uint32(bv))}else{binary.LittleEndian.PutUint64(a[i:],av);binary.LittleEndian.PutUint64(b[i:],bv)}
+   }
+   beforeA,beforeB:=a,b;fn(&out.data,&a,&b,csr)
+   if a!=beforeA||b!=beforeB||out.before!=0xa7||out.after!=0xb9{panic("input/output canary mutation")}
+   for _,v:=range out.data{hash^=uint64(v);hash*=1099511628211}
+  }}}
+ }
+ fmt.Printf("%016x\n",hash)
+}
+`
+	for name, source := range map[string]string{
+		"go.mod":           "module originalcompare\n\ngo 1.20\n",
+		"main.go":          strings.Replace(goDriver, "FUNCTIONS", functions.String(), 1) + declarations.String(),
+		"original_amd64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goExecutable := filepath.Join(dir, gotoolchain.HostExecutable("original-go"))
+	command := exec.Command("go", "build", "-p=2", "-o", goExecutable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0", "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	actualGo := execution.run(t, goExecutable)
+	const main = `
+int main(void){
+ uint64_t hash=UINT64_C(1469598103934665603);
+ for(unsigned op=0;op<4;op++) for(unsigned pred=0;pred<8;pred++){
+  unsigned bytes=(op==1||op==3)?8:4; const uint64_t *edges=bytes==4?edges32:edges64;
+  for(unsigned i=0;i<18;i++) for(unsigned j=0;j<18;j++) for(unsigned c=0;c<6;c++){
+   uint8_t a[20]={0},b[20]={0},storage[22],want[16];
+   uint8_t *out=storage+1;memset(storage,0xc3,sizeof(storage));
+   for(unsigned lane=0;lane<16;lane+=bytes){memcpy(a+lane,edges+i,bytes);memcpy(b+lane,edges+j,bytes);}
+   uint8_t beforeA[20],beforeB[20];memcpy(beforeA,a,20);memcpy(beforeB,b,20);
+   originals[op](out,a,b,pred,controls[c]); memcpy(want,a,16);
+   if(storage[0]!=0xc3||storage[21]!=0xc3||memcmp(a,beforeA,20)||memcmp(b,beforeB,20))return 2;
+   unsigned compared=op>=2?bytes:16;
+   for(unsigned lane=0;lane<compared;lane+=bytes) memset(want+lane,independent_compare(bytes*8,edges[i],edges[j],pred,controls[c])?255:0,bytes);
+   unsigned expected=original_effect(bytes*8,edges[i],edges[j],pred,controls[c]);
+   if(memcmp(out,want,16)||read_bits(out+16,4)!=expected){fprintf(stderr,"original SSE truth/effect op=%u pred=%u a=%llx b=%llx csr=%x observed=%llx scalar-CMP-policy=%x mask=%llx want=%llx\n",op,pred,(unsigned long long)edges[i],(unsigned long long)edges[j],controls[c],(unsigned long long)read_bits(out+16,4),expected,(unsigned long long)read_bits(out,bytes),(unsigned long long)read_bits(want,bytes));return 1;}
+   for(unsigned k=0;k<20;k++){hash^=out[k];hash*=UINT64_C(1099511628211);}
+  }
+ }
+ printf("%016llx\n",(unsigned long long)hash);return 0;
+}
+`
+	cSource, cExecutable := filepath.Join(dir, "original.c"), filepath.Join(dir, "original-c")
+	if err := os.WriteFile(cSource, []byte(x86FloatCompareOriginalC()+main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, cSource, cExecutable)
+	actualC := execution.run(t, cExecutable)
+	if string(actualGo) != string(actualC) || len(actualC) != 17 {
+		t.Fatalf("actual Go/native SSE original mismatch Go=%q C=%q", actualGo, actualC)
+	}
+	t.Logf("32 actual Go legacy programs ×1944 input/control pairs; independent original SSE, bit truth and complete same-predicate scalar CMP MXCSR agree: %s transport=%v", strings.TrimSpace(string(actualC)), execution.prefix)
+}
diff --git a/amd64_float_compare_original_vector_linux_test.go b/amd64_float_compare_original_vector_linux_test.go
new file mode 100644
index 000000000..2a42f984f
--- /dev/null
+++ b/amd64_float_compare_original_vector_linux_test.go
@@ -0,0 +1,12 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import "testing"
+
+// The Darwin/arm64 Rosetta preflight has AVX=0. This required Linux axis runs
+// original AVX machine code, not the translator's former software emulation.
+// Missing tools or a guest without AVX fail in the fixture, never skip.
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareOriginalVectorPredicates(t *testing.T) {
+	x86FloatCompareOriginalVectorRuntime(t)
+}
diff --git a/amd64_float_compare_original_vector_test.go b/amd64_float_compare_original_vector_test.go
new file mode 100644
index 000000000..e035f638f
--- /dev/null
+++ b/amd64_float_compare_original_vector_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+type x86FloatCompareOriginalVector struct {
+	opcode      string
+	bits, width int
+	scalar      bool
+}
+
+func x86FloatCompareOriginalVectors() []x86FloatCompareOriginalVector {
+	return []x86FloatCompareOriginalVector{
+		{"VCMPPS", 32, 16, false}, {"VCMPPS", 32, 32, false},
+		{"VCMPPD", 64, 16, false}, {"VCMPPD", 64, 32, false},
+		{"VCMPSS", 32, 16, true}, {"VCMPSD", 64, 16, true},
+	}
+}
+
+func x86FloatCompareOriginalVectorC() string {
+	var source strings.Builder
+	source.WriteString(x86FloatCompareIndependentC)
+	for index, fixture := range x86FloatCompareOriginalVectors() {
+		fmt.Fprintf(&source, `
+__attribute__((target("avx"))) static void vector%d(uint8_t *out,const uint8_t *a,const uint8_t *b,unsigned predicate,unsigned csr){
+ typedef uint8_t vector __attribute__((vector_size(%d)));
+ vector x,y,result;memcpy(&x,a,sizeof(x));memcpy(&y,b,sizeof(y));
+ unsigned saved,after;uint8_t carry;
+ __asm__ volatile("stmxcsr %%0":"=m"(saved));
+ __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+ switch(predicate){
+`, index, fixture.width)
+		for predicate := 0; predicate < 32; predicate++ {
+			fmt.Fprintf(&source, " case %d: __asm__ volatile(\"stc; %s $%d,%%3,%%2,%%0; setc %%1\":\"=x\"(result),\"=qm\"(carry):\"x\"(x),\"x\"(y):\"cc\");break;\n",
+				predicate, strings.ToLower(fixture.opcode), predicate)
+		}
+		source.WriteString(" }\n __asm__ volatile(\"stmxcsr %0\":\"=m\"(after));\n __asm__ volatile(\"ldmxcsr %0\"::\"m\"(saved));\n memcpy(out,&result,sizeof(result));memcpy(out+sizeof(result),&after,4);out[sizeof(result)+4]=carry;\n}\n")
+	}
+	source.WriteString("typedef void(*vector_fn)(uint8_t*,const uint8_t*,const uint8_t*,unsigned,unsigned);\nstatic vector_fn vectors[]={vector0,vector1,vector2,vector3,vector4,vector5};\n")
+	return source.String()
+}
+
+// This original-Go driver and the C opcode reference execute complete native
+// VEX instructions. In particular NaN/denormal pairs occur in both orders and
+// the full instruction's CSR is compared, not a per-lane COMI/class union.
+func x86FloatCompareOriginalVectorSources() (source, decls, calls, metadata string) {
+	var assembly, declarations, functions, descriptors strings.Builder
+	assembly.WriteString("#include \"textflag.h\"\n")
+	for index, fixture := range x86FloatCompareOriginalVectors() {
+		bank := "X"
+		if fixture.width == 32 {
+			bank = "Y"
+		}
+		for predicate := 0; predicate < 32; predicate++ {
+			name := fmt.Sprintf("vector%d_%d", index, predicate)
+			fmt.Fprintf(&assembly, `TEXT ·%s(SB),NOSPLIT,$8-32
+MOVQ out+0(FP),AX
+MOVQ a+8(FP),BX
+MOVQ b+16(FP),CX
+STMXCSR 0(SP)
+LDMXCSR csr+24(FP)
+VMOVUPS (BX),%s0
+VMOVUPS (CX),%s1
+STC
+%s $%d,%s1,%s0,%s%d
+VMOVUPS %s%d,(AX)
+STMXCSR %d(AX)
+SETCS %d(AX)
+LDMXCSR 0(SP)
+RET
+`, name, bank, bank, fixture.opcode, predicate, bank, bank, bank, predicate%3,
+				bank, predicate%3, fixture.width, fixture.width+4)
+			fmt.Fprintf(&declarations, "func %s(out,a,b *[40]byte,csr uint32)\n", name)
+			fmt.Fprintf(&functions, "%s,\n", name)
+			fmt.Fprintf(&descriptors, "{%d,%d},\n", fixture.bits, fixture.width)
+		}
+	}
+	return assembly.String(), declarations.String(), functions.String(), descriptors.String()
+}
+
+func TestX86FloatingCompareOriginalVectorAssemblerPrograms(t *testing.T) {
+	assembly, _, _, _ := x86FloatCompareOriginalVectorSources()
+	if strings.Count(assembly, "TEXT ·vector") != 192 {
+		t.Fatal("incomplete native VEX predicate fixture inventory")
+	}
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(input, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := exec.Command("go", "tool", "asm", "-p", "originalvectorcompare", "-I",
+		filepath.Join(runtime.GOROOT(), "pkg", "include"), "-o", object, input)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	if info, err := os.Lstat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("actual Go VEX assembler missing regular nonempty object: %v", err)
+	}
+}
+
+// Exercise the generated first-party driver with ordinary Go callees before
+// requiring an ISA. This is a buffer-lifetime/reset contract, not a comparison
+// oracle: the original-opcode Go/C test independently checks those results.
+func TestX86FloatingCompareOriginalVectorBufferLifetime(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_float_compare_original_vector_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var driver string
+	ast.Inspect(file, func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || declaration.Names[0].Name != "goDriver" {
+			return true
+		}
+		literal, ok := declaration.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			t.Fatal("original Go driver must retain its literal source")
+		}
+		driver, err = strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return false
+	})
+	if driver == "" {
+		t.Fatal("missing original Go vector driver")
+	}
+	_, _, functions, descriptors := x86FloatCompareOriginalVectorSources()
+	var callees strings.Builder
+	for index, fixture := range x86FloatCompareOriginalVectors() {
+		for predicate := 0; predicate < 32; predicate++ {
+			fmt.Fprintf(&callees, "func vector%d_%d(out,a,b *[40]byte,csr uint32){check(%d,%d,%d,out,a,b,csr)}\n",
+				index, predicate, index*32+predicate, fixture.bits, fixture.width)
+		}
+	}
+	const check = `
+var seen [192][3]*[40]byte
+var calls int
+func check(index,bits,width int,out,a,b *[40]byte,csr uint32){
+ const perFunction=18*18*6
+ if index!=calls/perFunction{panic("sample/function matrix order")}
+ if calls%perFunction==0{seen[index]=[3]*[40]byte{out,a,b}}
+ if seen[index]!=[3]*[40]byte{out,a,b}{panic("buffers allocated per sample")}
+ for _,v:=range out{if v!=0xc3{panic("output was not fully reset")}}
+ for i:=width;i<40;i++{if a[i]!=0||b[i]!=0{panic("input tail was not fully reset")}}
+ for lane:=bits/8;lane<width;lane++{
+  if a[lane]!=a[lane%(bits/8)]||b[lane]!=b[lane%(bits/8)]{panic("input lanes were not initialized")}
+ }
+ for i:=0;i<width+4;i++{out[i]=byte(calls+i)}
+ out[width+4]=1
+ calls++
+}
+`
+	source := strings.NewReplacer("FUNCTIONS", functions, "DESCRIPTORS", descriptors).Replace(driver)
+	source = strings.Replace(source, "fmt.Printf(\"%016x\\n\",hash)",
+		"if calls!=192*18*18*6{panic(\"incomplete sample matrix\")};fmt.Printf(\"%016x\\n\",hash)", 1)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module vectorbufferlifetime\n\ngo 1.20\n", "main.go": source + callees.String() + check,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	command := exec.Command("go", "run", "-p=2", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	output := x86FloatCompareCaptureCommand(t, command)
+	if len(output) != 17 {
+		t.Fatalf("buffer-lifetime oracle output: %q", output)
+	}
+	t.Log("192 functions ×1944 samples reuse independent input/output buffers with complete reset/canary checks")
+}
+
+func x86FloatCompareOriginalVectorRuntime(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	x86FloatCompareVerifyArguments(t, execution)
+	dir := t.TempDir()
+	assembly, declarations, functions, descriptors := x86FloatCompareOriginalVectorSources()
+	const goDriver = `package main
+import("encoding/binary";"fmt")
+func main(){
+ functions:=[]func(*[40]byte,*[40]byte,*[40]byte,uint32){FUNCTIONS}
+ descriptors:=[][2]int{DESCRIPTORS}
+ edges32:=[]uint64{0,0x80000000,1,0x80000001,0x7fffff,0x800000,0x3f800000,0xbf800000,0x3f800001,0x7f7fffff,0xff7fffff,0x7f800000,0xff800000,0x7fc12345,0xffc45678,0x7f812345,0xff845678,0x7fffffff}
+ edges64:=[]uint64{0,0x8000000000000000,1,0x8000000000000001,0xfffffffffffff,0x10000000000000,0x3ff0000000000000,0xbff0000000000000,0x3ff0000000000001,0x7fefffffffffffff,0xffefffffffffffff,0x7ff0000000000000,0xfff0000000000000,0x7ff8123456789abc,0xfff8fedcba987654,0x7ff0123456789abc,0xfff0fedcba987654,0x7fffffffffffffff}
+ controls:=[]uint32{0x1f80,0x1fc0,0x9f80,0x9fc0,0x1fbf,0x7fc5}
+ hash:=uint64(1469598103934665603)
+ for index,fn:=range functions{
+  bits,width:=descriptors[index][0],descriptors[index][1]
+ bytes,edges:=bits/8,edges32
+  if bits==64{edges=edges64}
+  var a,b [40]byte
+  var output struct{before byte;data [40]byte;after byte}
+  for _,av:=range edges{for _,bv:=range edges{for _,csr:=range controls{
+   a,b=[40]byte{},[40]byte{}
+   output=struct{before byte;data [40]byte;after byte}{before:0xa7,after:0xb9}
+   for i:=range output.data{output.data[i]=0xc3}
+   for i:=0;i<width;i+=bytes{
+    if bits==32{
+     binary.LittleEndian.PutUint32(a[i:],uint32(av));binary.LittleEndian.PutUint32(b[i:],uint32(bv))
+    }else{
+     binary.LittleEndian.PutUint64(a[i:],av);binary.LittleEndian.PutUint64(b[i:],bv)
+    }
+   }
+   beforeA,beforeB:=a,b;fn(&output.data,&a,&b,csr)
+   if a!=beforeA||b!=beforeB||output.before!=0xa7||output.after!=0xb9{panic("input/output canary mutation")}
+   for _,v:=range output.data[width+5:]{if v!=0xc3{panic("output extent")}}
+   if output.data[width+4]!=1{panic("EFLAGS carry")}
+   for _,v:=range output.data[:width+5]{hash^=uint64(v);hash*=1099511628211}
+  }}}
+ }
+ fmt.Printf("%016x\n",hash)
+}
+`
+	goSource := strings.NewReplacer("FUNCTIONS", functions, "DESCRIPTORS", descriptors).Replace(goDriver)
+	for name, source := range map[string]string{
+		"go.mod": "module originalvectorcompare\n\ngo 1.20\n", "main.go": goSource + declarations,
+		"original_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goExecutable := filepath.Join(dir, gotoolchain.HostExecutable("original-go"))
+	command := exec.Command("go", "build", "-p=2", "-o", goExecutable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	actualGo := execution.run(t, goExecutable)
+	const main = `
+int main(void){
+ const unsigned bits[]={32,32,64,64,32,64},widths[]={16,32,16,32,16,16};
+ uint64_t hash=UINT64_C(1469598103934665603);
+ for(unsigned op=0;op<6;op++)for(unsigned predicate=0;predicate<32;predicate++){
+  unsigned bytes=bits[op]/8,width=widths[op];const uint64_t *edges=bytes==4?edges32:edges64;
+  for(unsigned i=0;i<18;i++)for(unsigned j=0;j<18;j++)for(unsigned c=0;c<6;c++){
+   uint8_t a[40]={0},b[40]={0},storage[42],expected[32],beforeA[40],beforeB[40];
+   uint8_t *out=storage+1;memset(storage,0xc3,sizeof(storage));
+   for(unsigned lane=0;lane<width;lane+=bytes){memcpy(a+lane,edges+i,bytes);memcpy(b+lane,edges+j,bytes);}
+   memcpy(beforeA,a,40);memcpy(beforeB,b,40);memcpy(expected,a,width);
+   unsigned compared=op>=4?bytes:width;
+   for(unsigned lane=0;lane<compared;lane+=bytes)
+    memset(expected+lane,independent_compare(bits[op],edges[i],edges[j],predicate,controls[c])?255:0,bytes);
+   vectors[op](out,a,b,predicate,controls[c]);
+   if(memcmp(out,expected,width)||out[width+4]!=1||storage[0]!=0xc3||storage[41]!=0xc3||
+      memcmp(a,beforeA,40)||memcmp(b,beforeB,40)){
+    fprintf(stderr,"original VEX op=%u pred=%u i=%u j=%u csr=%x mask=%llx want=%llx\n",
+     op,predicate,i,j,controls[c],(unsigned long long)read_bits(out,bytes),(unsigned long long)read_bits(expected,bytes));return 1;
+   }
+   for(unsigned byte=width+5;byte<40;byte++)if(out[byte]!=0xc3)return 2;
+   for(unsigned byte=0;byte<width+5;byte++){hash^=out[byte];hash*=UINT64_C(1099511628211);}
+  }
+ }
+ printf("%016llx\n",(unsigned long long)hash);return 0;
+}
+`
+	cSource, cExecutable := filepath.Join(dir, "original.c"), filepath.Join(dir, "original-c")
+	if err := os.WriteFile(cSource, []byte(x86FloatCompareOriginalVectorC()+main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, cSource, cExecutable)
+	actualC := execution.run(t, cExecutable)
+	if string(actualGo) != string(actualC) || len(actualC) != 17 {
+		t.Fatalf("actual Go/original VEX full result+MXCSR+CF mismatch: Go=%q C=%q", actualGo, actualC)
+	}
+	t.Logf("192 actual Go VEX programs ×1944 complete IEEE/DAZ/MXCSR pairs including NaN×denormal in both orders; same original native opcode C+integer truth agree: %s route=%v; EVEX execution not covered",
+		strings.TrimSpace(string(actualC)), execution.prefix)
+}
diff --git a/amd64_float_compare_predicate_byte_test.go b/amd64_float_compare_predicate_byte_test.go
new file mode 100644
index 000000000..fb8892426
--- /dev/null
+++ b/amd64_float_compare_predicate_byte_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingCompareGrammarPreservesWholePredicateByte(t *testing.T) {
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		t.Run(opcode, func(t *testing.T) {
+			for immediate := 0; immediate < 256; immediate++ {
+				row := fmt.Sprintf("%s X1,X0,$%d", opcode, int8(immediate))
+				if strings.HasPrefix(opcode, "V") {
+					row = fmt.Sprintf("%s $%d,X1,X0,X2", opcode, immediate)
+				}
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, known, err := x86FloatCompareProperties(file.Funcs[0].Instrs[1], "amd64")
+				if !known || err != nil {
+					t.Fatalf("accepted predicate byte %d was not represented: %s: %v", immediate, row, err)
+				}
+				if form.immediate != uint8(immediate) {
+					t.Fatalf("typed grammar folded source predicate byte: %s: got=%d want=%d", row, form.immediate, immediate)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_float_compare_preflight_portability_test.go b/amd64_float_compare_preflight_portability_test.go
new file mode 100644
index 000000000..760c86adf
--- /dev/null
+++ b/amd64_float_compare_preflight_portability_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingComparePreflightWindowsResourceBoundary(t *testing.T) {
+	_, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("actual LLVM22 clang required for preflight preprocessing")
+	}
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "sys"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	// These headers deliberately supply only declarations. This is actual
+	// LLVM22 preprocessing/object compilation of the entire original helper,
+	// not a MinGW SDK, Windows link/runtime or synthetic ISA capability grant.
+	for name, contents := range map[string]string{
+		"stdint.h":       "typedef unsigned long long uint64_t;\n",
+		"stdio.h":        "typedef struct FILE FILE;\nextern FILE *stdout;\nint printf(const char*,...);\nint fflush(FILE*);\n",
+		"cpuid.h":        "int __get_cpuid(unsigned,unsigned*,unsigned*,unsigned*,unsigned*);\nint __get_cpuid_count(unsigned,unsigned,unsigned*,unsigned*,unsigned*,unsigned*);\n",
+		"sys/resource.h": "#error plan9asm_portability_poison_resource_header\n",
+		"preflight.c":    "#define REQUIRED_AXIS 1\n" + x86FloatCompareOpcodePreflightC,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	command := func(flags ...string) ([]byte, error) {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		args := []string{"-target", "x86_64-unknown-linux-gnu", "-nostdinc", "-I", dir}
+		args = append(args, flags...)
+		args = append(args, filepath.Join(dir, "preflight.c"))
+		return runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, clang, args...))
+	}
+
+	t.Run("windows-poison-header", func(t *testing.T) {
+		output, err := command("-D_WIN32=1", "-E", "-P")
+		if err != nil {
+			t.Fatalf("_WIN32 preflight accessed unavailable POSIX header: %v\n%s", err, output)
+		}
+		for _, token := range []string{"setrlimit", "RLIMIT_CORE", "struct rlimit"} {
+			if strings.Contains(string(output), token) {
+				t.Fatal("Windows preflight retained a POSIX resource operation", token)
+			}
+		}
+		for _, opcode := range []string{"vcmpps $0", "vcmppd $0", "vcmpss $0", "vcmpsd $0", "xgetbv", "required_state(axis"} {
+			if !strings.Contains(string(output), opcode) {
+				t.Fatal("platform guard reduced original capability/opcode preflight", opcode)
+			}
+		}
+		object := filepath.Join(dir, "windows-macro.o")
+		if output, err := command("-D_WIN32=1", "-O0", "-c", "-o", object); err != nil {
+			t.Fatalf("actual compiler could not compile full Windows-macro preflight: %v\n%s", err, output)
+		}
+		if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+			t.Fatal("missing actual compiler object", err)
+		}
+	})
+
+	t.Run("posix-poison-header", func(t *testing.T) {
+		output, err := command("-U_WIN32", "-E", "-P")
+		// A plain concrete compiler rejection, not a timeout/cleanup/tool error,
+		// proves POSIX still consumes the very header forbidden under _WIN32.
+		exit, ok := err.(*exec.ExitError)
+		// Clang joins the exact -I argument with the slash-spelled include,
+		// also on Windows; filepath.Join would invent backslashes in the tail.
+		if !ok || exit.ExitCode() != 1 || !strings.Contains(string(output), dir+"/sys/resource.h:1:2: error: plan9asm_portability_poison_resource_header") {
+			t.Fatalf("lost exact POSIX header-selection witness: %v\n%s", err, output)
+		}
+	})
+
+	t.Run("posix-core-zero-preserved", func(t *testing.T) {
+		const checked = "struct rlimit { unsigned long rlim_cur, rlim_max; };\n#define RLIMIT_CORE 9917\n#define setrlimit plan9asm_posix_setrlimit_fixture\nint plan9asm_posix_setrlimit_fixture(int,const struct rlimit*);\n"
+		if err := os.WriteFile(filepath.Join(dir, "sys", "resource.h"), []byte(checked), 0600); err != nil {
+			t.Fatal(err)
+		}
+		output, err := command("-U_WIN32", "-E", "-P")
+		if err != nil {
+			t.Fatalf("POSIX checked resource header failed: %v\n%s", err, output)
+		}
+		compact := strings.Join(strings.Fields(string(output)), "")
+		if !strings.Contains(compact, "structrlimitno_core={0,0};if(plan9asm_posix_setrlimit_fixture(9917,&no_core))return77;") {
+			t.Fatal("POSIX preflight changed its zero soft/hard limit or error exit")
+		}
+		irPath := filepath.Join(dir, "posix-core.ll")
+		if output, err := command("-U_WIN32", "-O0", "-S", "-emit-llvm", "-o", irPath); err != nil {
+			t.Fatalf("POSIX resource consumer did not compile: %v\n%s", err, output)
+		}
+		ir, err := os.ReadFile(irPath)
+		if err != nil || strings.Count(string(ir), "call i32 @plan9asm_posix_setrlimit_fixture(") != 1 {
+			t.Fatalf("actual compiled POSIX preflight lost the resource consumer: %v\n%s", err, ir)
+		}
+	})
+}
diff --git a/amd64_float_compare_regression_test.go b/amd64_float_compare_regression_test.go
new file mode 100644
index 000000000..4c27c32c1
--- /dev/null
+++ b/amd64_float_compare_regression_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFloatingCompareOriginalSourceReachesObjects(t *testing.T) {
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		t.Run(opcode, func(t *testing.T) {
+			row, destination := opcode+" X0,X1,$0", "X1"
+			if strings.HasPrefix(opcode, "V") {
+				row, destination = opcode+" $0,X0,X1,X2", "X2"
+			}
+			body := "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\n" + row + "\nVMOVSS " + destination + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareLegacyUpperAliases(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD"} {
+		name := fmt.Sprintf("compare_alias%d", index)
+		bits, scalar := 32, strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nSTC\n%s X0,X1,$0\nVMOVUPS Z1,(AX)\nSETCS 64(AX)\nRET\n", name, opcode)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*);\n", name)
+		fmt.Fprintf(&checks, `
+ {
+  uint8_t a[64], b[64], out[67], expected[64];
+  for(int i=0; i<64; i++) a[i]=b[i]=(uint8_t)(i*29+11);
+  memset(out,0xc3,sizeof(out));
+  memcpy(expected,b,64);
+  int compared=%d ? %d : 16;
+  memset(expected,0xff,compared);
+  %s(out+1,a,b);
+  for(int i=0;i<64;i++) {
+   if(out[i+1]!=expected[i]) {
+    fprintf(stderr,"%s byte=%%d got=%%x expected=%%x\n",i,out[i+1],expected[i]);
+    return 10;
+   }
+  }
+  if(out[0]!=0xc3 || out[65]!=1 || out[66]!=0xc3) return 11;
+ }
+`, x86FloatAddSubBoolInt(scalar), bits/8, name, opcode)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + "int main(void){\n" + checks.String() + "return 0;}\n"
+	execution.compileAndRunLLVM(t, "floating-compare-legacy-alias", ir, main, "-O2")
+}
diff --git a/amd64_float_compare_runtime_axes_test.go b/amd64_float_compare_runtime_axes_test.go
new file mode 100644
index 000000000..91c1fb627
--- /dev/null
+++ b/amd64_float_compare_runtime_axes_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+type x86FloatCompareRuntimeISA uint8
+
+const (
+	x86FloatCompareSSE x86FloatCompareRuntimeISA = iota + 1
+	x86FloatCompareVEX
+	x86FloatCompareEVEX
+)
+
+// These are independent fixture axes, not production grammar or permission.
+func (fixture x86FloatCompareOracleCase) executionISA() x86FloatCompareRuntimeISA {
+	if fixture.legacy {
+		return x86FloatCompareSSE
+	}
+	if fixture.maskResult {
+		return x86FloatCompareEVEX
+	}
+	return x86FloatCompareVEX
+}
+
+func x86FloatCompareRuntimeCases(opcode string, axis x86FloatCompareRuntimeISA) []x86FloatCompareOracleCase {
+	var selected []x86FloatCompareOracleCase
+	for _, fixture := range x86FloatCompareOracleCases(opcode) {
+		if fixture.executionISA() == axis {
+			selected = append(selected, fixture)
+		}
+	}
+	return selected
+}
+
+func x86FloatCompareRuntimeTools(t *testing.T, axis x86FloatCompareRuntimeISA) x86FloatCompareExecution {
+	t.Helper()
+	if axis < x86FloatCompareSSE || axis > x86FloatCompareEVEX {
+		t.Fatal("unknown compare execution ISA", axis)
+	}
+	if axis != x86FloatCompareSSE && (runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") {
+		t.Fatal("VEX/EVEX comparison must consume its required Linux execution counterpart")
+	}
+	if axis == x86FloatCompareEVEX && runtime.GOARCH != "amd64" {
+		t.Fatal("EVEX requires actual native Linux AMD64, not an emulator or Rosetta")
+	}
+	execution := x86FloatCompareExecutionTools(t)
+	if axis == x86FloatCompareEVEX && (len(execution.prefix) != 0 || execution.preserveArgv0) {
+		t.Fatal("EVEX native counterpart cannot use a guest execution route")
+	}
+	x86FloatCompareVerifyArguments(t, execution)
+	if axis == x86FloatCompareVEX {
+		execution.requireAVX(t)
+	}
+	x86FloatCompareRequireOpcodeISA(t, execution, axis)
+	return execution
+}
+
+// CPUID and enabled OS register state are both required. The original whole
+// opcodes execute only after this check; their results are consumed. This is
+// an execution preflight, not a production source/ISA authorization token.
+const x86FloatCompareOpcodePreflightC = `#include <stdint.h>
+#include <stdio.h>
+#include <cpuid.h>
+#if !defined(_WIN32)
+#include <sys/resource.h>
+#endif
+
+static int required_state(unsigned axis, unsigned sse2, unsigned avx,
+                          unsigned osxsave, unsigned f, unsigned vl, uint64_t xcr0) {
+    if (axis==1) return sse2!=0;
+    if (!sse2 || !avx || !osxsave || (xcr0&6)!=6) return 0;
+    if (axis==2) return 1;
+    return axis==3 && f && vl && (xcr0&0xe6)==0xe6;
+}
+
+__attribute__((target("avx"))) static unsigned original_vex(void) {
+    unsigned mask;
+    __asm__ volatile("vxorps %%xmm0,%%xmm0,%%xmm0; "
+                     "vcmpps $0,%%xmm0,%%xmm0,%%xmm1; "
+                     "vmovmskps %%xmm1,%0" : "=r"(mask) :: "xmm0","xmm1");
+    return mask;
+}
+
+__attribute__((target("avx512f,avx512vl"))) static int original_evex(void) {
+    unsigned ps,pd,ss,sd,active;
+    __asm__ volatile("vxorps %%zmm0,%%zmm0,%%zmm0; "
+                     "vcmpps $0,%%zmm0,%%zmm0,%%k1; kmovw %%k1,%0; "
+                     "vcmppd $0,%%zmm0,%%zmm0,%%k1; kmovw %%k1,%1; "
+                     "vcmpss $0,%%xmm0,%%xmm0,%%k1; kmovw %%k1,%2; "
+                     "vcmpsd $0,%%xmm0,%%xmm0,%%k1; kmovw %%k1,%3; "
+                     "movl $1,%4; kmovw %4,%%k2; "
+                     "vcmpps $0,%%zmm0,%%zmm0,%%k1%{%%k2%}; kmovw %%k1,%4"
+                     : "=r"(ps),"=r"(pd),"=r"(ss),"=r"(sd),"=r"(active)
+                     :: "zmm0","k1","k2");
+    return ps==0xffff && pd==0xff && ss==1 && sd==1 && active==1;
+}
+
+int main(void) {
+#if !defined(_WIN32)
+    struct rlimit no_core={0,0};
+    if (setrlimit(RLIMIT_CORE,&no_core)) return 77;
+#endif
+    unsigned a,b,c,d,sse2=0,avx=0,osxsave=0,f=0,vl=0;
+    uint64_t xcr0=0;
+    if (__get_cpuid(1,&a,&b,&c,&d)) {
+        sse2=(d>>26)&1; avx=(c>>28)&1; osxsave=(c>>27)&1;
+        if (osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) {
+        f=(b>>16)&1; vl=(b>>31)&1;
+    }
+    unsigned axis=REQUIRED_AXIS;
+    printf("axis=%u SSE2=%u AVX=%u OSXSAVE=%u AVX512F=%u AVX512VL=%u XCR0=%llx\n",
+           axis,sse2,avx,osxsave,f,vl,(unsigned long long)xcr0);
+    fflush(stdout);
+    if (!required_state(axis,sse2,avx,osxsave,f,vl,xcr0)) return 78;
+    if (axis==2 && original_vex()!=15) return 79;
+    if (axis==3 && !original_evex()) return 80;
+    return 0;
+}
+`
+
+func x86FloatCompareRequireOpcodeISA(t *testing.T, execution x86FloatCompareExecution, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	dir := t.TempDir()
+	source, executable := filepath.Join(dir, "preflight.c"), filepath.Join(dir, "preflight")
+	program := fmt.Sprintf("#define REQUIRED_AXIS %d\n", axis) + x86FloatCompareOpcodePreflightC
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	output := execution.run(t, executable)
+	t.Logf("actual CPU/OS-state and original-opcode preflight: %s", output)
+}
+
+func TestX86FloatingCompareRuntimeCaseUnion(t *testing.T) {
+	counts, dead := [3]int{}, [3]int{}
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		complete := x86FloatCompareOracleCases(opcode)
+		// Scalar variant 1/2 intentionally have identical memory spellings.
+		// Preserve their original multiplicity instead of dropping a fixture.
+		remaining := make(map[x86FloatCompareOracleCase]int)
+		for _, fixture := range complete {
+			remaining[fixture]++
+		}
+		for _, axis := range []x86FloatCompareRuntimeISA{x86FloatCompareSSE, x86FloatCompareVEX, x86FloatCompareEVEX} {
+			for _, fixture := range x86FloatCompareRuntimeCases(opcode, axis) {
+				if remaining[fixture] == 0 {
+					t.Fatal("duplicated runtime case", fixture.row)
+				}
+				remaining[fixture]--
+				counts[axis-1]++
+				if x86FloatCompareDeadPredicate(fixture.predicate) {
+					dead[axis-1]++
+				}
+			}
+		}
+		for fixture, count := range remaining {
+			if count != 0 {
+				t.Fatal("missing runtime case", opcode, fixture.row, count)
+			}
+		}
+	}
+	if counts != [3]int{64, 256, 512} || dead != [3]int{16, 48, 96} {
+		t.Fatalf("changed complete fixture denominators: IEEE=%v dead=%v", counts, dead)
+	}
+	var fp [3]int
+	for _, fixture := range x86FloatCompareFPOracles(t) {
+		fp[fixture.axis-1]++
+	}
+	if fp != [3]int{16, 16, 16} {
+		t.Fatal("changed FP byte-field runtime denominator", fp)
+	}
+}
+
+func TestX86FloatingCompareCompleteRuntimeOriginalGoInventory(t *testing.T) {
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		t.Run(opcode, func(t *testing.T) {
+			assembly, _ := x86FloatCompareOracleAssembly(x86FloatCompareOracleCases(opcode), false)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		})
+	}
+	var dead []x86FloatCompareOracleCase
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		for _, fixture := range x86FloatCompareOracleCases(opcode) {
+			if x86FloatCompareDeadPredicate(fixture.predicate) {
+				dead = append(dead, fixture)
+			}
+		}
+	}
+	assembly, _ := x86FloatCompareOracleAssembly(dead, true)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	assembly, _ = x86FloatCompareFPAssembly(x86FloatCompareFPOracles(t))
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	t.Log("actual stock Go objects bind 832 independent IEEE, 160 dead-result and all 48 scalar FP-byte-field programs; object evidence does not imply ISA execution")
+}
+
+func TestX86FloatingCompareOpcodePreflightCapabilities(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source, executable := filepath.Join(dir, "capabilities.c"), filepath.Join(dir, "capabilities")
+	// Execute the exact preflight predicate against independent missing-feature
+	// cases, without substituting synthetic capabilities for an actual ISA run.
+	const checks = `
+#undef main
+int main(void) {
+    if (!required_state(1,1,0,0,0,0,0) || required_state(1,0,1,1,1,1,0xe6)) return 1;
+    if (!required_state(2,1,1,1,0,0,6) || !required_state(3,1,1,1,1,1,0xe6)) return 2;
+    if (required_state(0,1,1,1,1,1,0xe6) || required_state(4,1,1,1,1,1,0xe6)) return 3;
+    for (unsigned axis=2;axis<=3;axis++) {
+        if (required_state(axis,0,1,1,1,1,0xe6) || required_state(axis,1,0,1,1,1,0xe6) ||
+            required_state(axis,1,1,0,1,1,0xe6)) return 4;
+        if (required_state(axis,1,1,1,1,1,0xe6&~2) ||
+            required_state(axis,1,1,1,1,1,0xe6&~4)) return 5;
+    }
+    if (required_state(3,1,1,1,0,1,0xe6) || required_state(3,1,1,1,1,0,0xe6)) return 6;
+    for (unsigned bit=5;bit<=7;bit++) {
+        if (required_state(3,1,1,1,1,1,0xe6&~(1u<<bit))) return 7;
+    }
+    return 0;
+}
+`
+	program := "#define REQUIRED_AXIS 1\n#define main actual_preflight_main\n" + x86FloatCompareOpcodePreflightC + checks
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	execution.run(t, executable)
+}
diff --git a/amd64_float_compare_runtime_linux_amd64_test.go b/amd64_float_compare_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..52e975293
--- /dev/null
+++ b/amd64_float_compare_runtime_linux_amd64_test.go
@@ -0,0 +1,23 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansEVEX(t *testing.T) {
+	x86FloatCompareFPScalarByteSpansRuntime(t, x86FloatCompareEVEX)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSREVEX(t *testing.T) {
+	x86FloatCompareIndependentRuntime(t, x86FloatCompareEVEX)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsEVEX(t *testing.T) {
+	x86FloatCompareDeadResultRuntime(t, x86FloatCompareEVEX)
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64ConformanceNativeAVX512(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	amd64ConformanceOriginalWideGo(t, execution)
+	amd64ConformanceLLVMRuntime(t, execution, true)
+}
diff --git a/amd64_float_compare_runtime_linux_test.go b/amd64_float_compare_runtime_linux_test.go
new file mode 100644
index 000000000..a29557a04
--- /dev/null
+++ b/amd64_float_compare_runtime_linux_test.go
@@ -0,0 +1,17 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansVEX(t *testing.T) {
+	x86FloatCompareFPScalarByteSpansRuntime(t, x86FloatCompareVEX)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSRVEX(t *testing.T) {
+	x86FloatCompareIndependentRuntime(t, x86FloatCompareVEX)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsVEX(t *testing.T) {
+	x86FloatCompareDeadResultRuntime(t, x86FloatCompareVEX)
+}
diff --git a/amd64_float_compare_runtime_policy_test.go b/amd64_float_compare_runtime_policy_test.go
new file mode 100644
index 000000000..a661cd182
--- /dev/null
+++ b/amd64_float_compare_runtime_policy_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingCompareRuntimeRetainsOptimizationLevels(t *testing.T) {
+	// The old shared helper omitted -O, whose llc default is O2. Explicit
+	// transport must preserve that level, rather than weaken the numerical gate.
+	for _, fixture := range []struct{ file, program string }{
+		{"amd64_conformance_test.go", "amd64_conformance"},
+		{"amd64_float_compare_numerical_test.go", "compare-ieee"},
+		{"amd64_float_compare_fp_runtime_test.go", "compare-fp-scalar-bytes"},
+		{"amd64_float_compare_regression_test.go", "floating-compare-legacy-alias"},
+		{"amd64_lower_convert_double_dword_test.go", "packed_double_dword"},
+		{"amd64_lower_convert_double_dword_test.go", "raw_packed_double_dword"},
+		{"amd64_insert_extract_native_runtime_test.go", "masked-native-extract"},
+	} {
+		t.Run(fixture.program, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), fixture.file, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			matches := 0
+			ast.Inspect(file, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok || len(call.Args) != 5 {
+					return true
+				}
+				callee, ok := call.Fun.(*ast.SelectorExpr)
+				if !ok || callee.Sel.Name != "compileAndRunLLVM" {
+					return true
+				}
+				name, ok := call.Args[1].(*ast.BasicLit)
+				if !ok || name.Kind != token.STRING {
+					return true
+				}
+				program, err := strconv.Unquote(name.Value)
+				if err != nil || program != fixture.program {
+					return true
+				}
+				matches++
+				level, ok := call.Args[4].(*ast.BasicLit)
+				if !ok || level.Kind != token.STRING || level.Value != `"-O2"` {
+					t.Error("ordinary numerical runtime must retain explicit llc O2")
+				}
+				return true
+			})
+			if matches != 1 {
+				t.Fatalf("expected one actual numerical consumer, found %d", matches)
+			}
+		})
+	}
+}
+
+func TestX86FloatingCompareRuntimeRequiresExplicitISAAxes(t *testing.T) {
+	for _, fixture := range []struct{ file, root, helper, axis string }{
+		{"amd64_float_compare_fp_runtime_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpans", "x86FloatCompareFPScalarByteSpansRuntime", "x86FloatCompareSSE"},
+		{"amd64_float_compare_numerical_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSR", "x86FloatCompareIndependentRuntime", "x86FloatCompareSSE"},
+		{"amd64_float_compare_numerical_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffects", "x86FloatCompareDeadResultRuntime", "x86FloatCompareSSE"},
+		{"amd64_float_compare_runtime_linux_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansVEX", "x86FloatCompareFPScalarByteSpansRuntime", "x86FloatCompareVEX"},
+		{"amd64_float_compare_runtime_linux_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSRVEX", "x86FloatCompareIndependentRuntime", "x86FloatCompareVEX"},
+		{"amd64_float_compare_runtime_linux_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsVEX", "x86FloatCompareDeadResultRuntime", "x86FloatCompareVEX"},
+		{"amd64_float_compare_runtime_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansEVEX", "x86FloatCompareFPScalarByteSpansRuntime", "x86FloatCompareEVEX"},
+		{"amd64_float_compare_runtime_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSREVEX", "x86FloatCompareIndependentRuntime", "x86FloatCompareEVEX"},
+		{"amd64_float_compare_runtime_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsEVEX", "x86FloatCompareDeadResultRuntime", "x86FloatCompareEVEX"},
+	} {
+		t.Run(fixture.root, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), fixture.file, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var body *ast.BlockStmt
+			for _, declaration := range file.Decls {
+				if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == fixture.root {
+					body = fn.Body
+				}
+			}
+			if body == nil || len(body.List) != 1 {
+				t.Fatal("required runtime root must directly consume its complete explicit ISA fixture")
+			}
+			statement, ok := body.List[0].(*ast.ExprStmt)
+			if !ok {
+				t.Fatal("required runtime root cannot return or substitute a skip")
+			}
+			call, ok := statement.X.(*ast.CallExpr)
+			if !ok || len(call.Args) != 2 {
+				t.Fatal("required runtime fixture must receive the explicit ISA axis")
+			}
+			callee, ok := call.Fun.(*ast.Ident)
+			axis, axisOK := call.Args[1].(*ast.Ident)
+			if !ok || callee.Name != fixture.helper || !axisOK || axis.Name != fixture.axis {
+				t.Fatalf("required runtime root does not consume %s with %s", fixture.helper, fixture.axis)
+			}
+		})
+	}
+}
+
+func TestX86FloatingCompareRequiredLinuxBuildSelection(t *testing.T) {
+	for _, qualified := range []bool{false, true} {
+		for _, target := range []struct{ os, arch string }{
+			{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"}, {"linux", "arm64"},
+			{"js", "wasm"}, {"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+		} {
+			for _, file := range []string{"amd64_float_compare_runtime_linux_test.go", "amd64_float_compare_runtime_linux_amd64_test.go", "amd64_insert_extract_native_runtime_linux_amd64_test.go", "amd64_packed_double_dword_native_linux_amd64_test.go"} {
+				t.Run(fmt.Sprintf("selection/qualified=%t/%s-%s/%s", qualified, target.os, target.arch, file), func(t *testing.T) {
+					ctx := ciNativeAVX512BuildContext(target.os, target.arch, qualified)
+					actual, err := ctx.MatchFile(".", file)
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := target.os == "linux" && (target.arch == "amd64" || target.arch == "arm64")
+					if file != "amd64_float_compare_runtime_linux_test.go" {
+						want = qualified && target.os == "linux" && target.arch == "amd64"
+					}
+					if actual != want {
+						t.Fatalf("%s on %s/%s qualified=%v selected=%v want=%v", file, target.os, target.arch, qualified, actual, want)
+					}
+				})
+			}
+		}
+	}
+	contents, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	selector, err := x86FloatCompareLinuxCISelector(string(contents))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, axis := range []string{"VEX", "EVEX"} {
+		for _, family := range []string{"FPScalarByteSpans", "IndependentIEEEAndMXCSR", "DeadResultEffects"} {
+			if !selector.MatchString("TestCrossLinuxRuntimeMatrixX86FloatingCompare" + family + axis) {
+				t.Fatal("required Linux CI does not select complete compare fixture", family, axis)
+			}
+		}
+	}
+	if !selector.MatchString("TestCrossLinuxRuntimeMatrixAMD64ConformanceNativeAVX512") {
+		t.Fatal("required Linux CI does not select original-Go/LLVM native wide conformance")
+	}
+	if !selector.MatchString("TestCrossLinuxRuntimeMatrixX86InsertExtractMaskedNativeMemory") {
+		t.Fatal("required Linux CI does not select all masked native memory extract cases")
+	}
+	if !selector.MatchString("TestCrossLinuxRuntimeMatrixAMD64PackedDoubleDwordNativeAVX512") {
+		t.Fatal("required Linux CI does not select complete named/raw original-Go/LLVM double/dword conversions")
+	}
+}
+
+func x86FloatCompareLinuxCISelector(workflow string) (*regexp.Regexp, error) {
+	job, found := ciWorkflowJob(workflow, "cross-runtime")
+	if !found || !strings.Contains(job, "ubuntu-latest") {
+		return nil, fmt.Errorf("required Linux native AMD64 runtime job is absent")
+	}
+	// CI now uses exhaustive owners, not the previous single go-test command.
+	// Match the actual runner invocation only inside this exact job; an
+	// aggregate's selector or a commented command cannot replace execution.
+	command := regexp.MustCompile(`(?m)^          go run \./cmd/plan9asmtest [^\r\n]+\\\r?\n[ \t]+-ci-selector '([^']+)'[ \t]+\\`)
+	matches := command.FindAllStringSubmatch(job, -1)
+	if len(matches) != 1 {
+		return nil, fmt.Errorf("required Linux runtime has %d actual partition selectors, want one", len(matches))
+	}
+	selector, err := regexp.Compile(matches[0][1])
+	if err != nil {
+		return nil, fmt.Errorf("invalid actual Linux runtime selector: %w", err)
+	}
+	return selector, nil
+}
+
+func TestX86FloatingCompareLinuxCISelectorCannotBorrowAnotherJob(t *testing.T) {
+	contents, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// ciWorkflowJob accepts LF and CRLF but returns an LF job. Keep the
+	// mutation input in the same representation, then exercise both formats.
+	workflow := strings.ReplaceAll(string(contents), "\r\n", "\n")
+	job, found := ciWorkflowJob(workflow, "cross-runtime")
+	if !found {
+		t.Fatal("original cross-runtime job is missing")
+	}
+	for _, source := range []string{workflow, strings.ReplaceAll(workflow, "\n", "\r\n")} {
+		if _, err := x86FloatCompareLinuxCISelector(source); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, mutation := range []struct {
+		name string
+		edit func(string) string
+	}{
+		{"different_job", func(text string) string {
+			return strings.Replace(text, "\n  cross-runtime:\n", "\n  removed-runtime:\n", 1)
+		}},
+		{"aggregate_only_selector", func(text string) string {
+			changed := strings.Replace(job, "-ci-selector", "-removed-selector", 1)
+			return strings.Replace(text, job, changed, 1)
+		}},
+		{"commented_command", func(text string) string {
+			return strings.Replace(text, "          go run ./cmd/plan9asmtest -out _out/cross-runtime-owner",
+				"          # go run ./cmd/plan9asmtest -out _out/cross-runtime-owner", 1)
+		}},
+		{"non_linux_host", func(text string) string {
+			changed := strings.Replace(job, "ubuntu-latest", "windows-latest", 1)
+			return strings.Replace(text, job, changed, 1)
+		}},
+		{"invalid_expression", func(text string) string {
+			changed := regexp.MustCompile(`-ci-selector '[^']+'`).ReplaceAllString(job, "-ci-selector '['")
+			return strings.Replace(text, job, changed, 1)
+		}},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			changed := mutation.edit(workflow)
+			if changed == workflow {
+				t.Fatal("mutation did not change the actual workflow")
+			}
+			for _, source := range []string{changed, strings.ReplaceAll(changed, "\n", "\r\n")} {
+				if _, err := x86FloatCompareLinuxCISelector(source); err == nil {
+					t.Fatal("absent, foreign or invalid runtime execution was accepted")
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64ConformanceWideRuntimeIsRequired(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_float_compare_runtime_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == "TestCrossLinuxRuntimeMatrixAMD64ConformanceNativeAVX512" {
+			body = fn.Body
+		}
+	}
+	if body == nil || len(body.List) != 3 {
+		t.Fatal("original Go and LLVM wide conformance must both consume required native preflight")
+	}
+	assignment, ok := body.List[0].(*ast.AssignStmt)
+	if !ok || len(assignment.Rhs) != 1 {
+		t.Fatal("native wide preflight is missing")
+	}
+	call, ok := assignment.Rhs[0].(*ast.CallExpr)
+	if !ok || len(call.Args) != 2 {
+		t.Fatal("native wide preflight must bind the explicit EVEX execution axis")
+	}
+	callee, ok := call.Fun.(*ast.Ident)
+	axis, axisOK := call.Args[1].(*ast.Ident)
+	if !ok || callee.Name != "x86FloatCompareRuntimeTools" || !axisOK || axis.Name != "x86FloatCompareEVEX" {
+		t.Fatal("native wide conformance cannot borrow ordinary/guest tools")
+	}
+	for index, name := range []string{"amd64ConformanceOriginalWideGo", "amd64ConformanceLLVMRuntime"} {
+		statement, ok := body.List[index+1].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("native wide conformance cannot substitute an early return or skip")
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok {
+			t.Fatal("native wide conformance is not consumed")
+		}
+		callee, ok := call.Fun.(*ast.Ident)
+		if !ok || callee.Name != name || len(call.Args) < 2 {
+			t.Fatal("native wide conformance consumer is missing", name)
+		}
+		tools, ok := call.Args[1].(*ast.Ident)
+		if !ok || tools.Name != "execution" {
+			t.Fatal("native wide conformance dropped its validated execution route")
+		}
+		if index == 1 {
+			if len(call.Args) != 3 {
+				t.Fatal("native wide LLVM conformance must execute its full wide assertions")
+			}
+			wide, ok := call.Args[2].(*ast.Ident)
+			if !ok || wide.Name != "true" {
+				t.Fatal("native wide LLVM conformance was disabled")
+			}
+		}
+	}
+}
diff --git a/amd64_float_compare_table_binding_test.go b/amd64_float_compare_table_binding_test.go
new file mode 100644
index 000000000..8b22263d6
--- /dev/null
+++ b/amd64_float_compare_table_binding_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingCompareSpecsBindCompleteGoTables(t *testing.T) {
+	dir := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(x86FloatCompareSpecs) != 8 {
+		t.Fatalf("comparison family has %d names, want 8", len(x86FloatCompareSpecs))
+	}
+	const legacyTable = "var yxcmpi = []ytab{\n\t{Zm_r_i_xm, 2, argList{Yxm, Yxr, Yi8}},\n}"
+	if !strings.Contains(string(legacy), legacyTable) {
+		t.Fatal("Go changed the complete signed-imm8 legacy compare grammar")
+	}
+	const packedTable = `var _yvcmppd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yym, Yyr, Yyr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, Yzm, Yzr, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, Yzm, Yzr, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, Yk}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YymEvex, YyrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YymEvex, YyrEvex, Yknot0, Yk}},
+}`
+	const scalarTable = `var _yvcmpsd = []ytab{
+	{zcase: Zvex_i_rm_v_r, zoffset: 2, args: argList{Yu8, Yxm, Yxr, Yxr}},
+	{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, YxmEvex, YxrEvex, Yk}},
+	{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, YxmEvex, YxrEvex, Yknot0, Yk}},
+}`
+	for _, table := range []string{packedTable, scalarTable} {
+		if !strings.Contains(string(avx), table) {
+			t.Fatalf("Go changed complete compare table: %s", strings.SplitN(table, "\n", 2)[0])
+		}
+	}
+	for _, opcode := range x86FloatCompareOpcodes() {
+		bits := 32
+		if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		scalar, old := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD"), !strings.HasPrefix(opcode, "V")
+		if got := x86FloatCompareSpecs[Op(opcode)]; got != (x86FloatCompareSpec{bits, old, scalar}) {
+			t.Fatalf("independent compare axes differ: %s %+v", opcode, got)
+		}
+		if old {
+			if !strings.Contains(string(legacy), "{A"+opcode+", yxcmpi,") {
+				t.Fatalf("Go legacy opcode no longer binds yxcmpi: %s", opcode)
+			}
+			continue
+		}
+		table := "_yvcmppd"
+		if scalar {
+			table = "_yvcmpsd"
+		}
+		marker := "{as: A" + opcode + ", ytab: " + table + ", prefix: Pavx, op: opBytes{"
+		start := strings.Index(string(avx), marker)
+		if start < 0 {
+			t.Fatalf("missing Go compare opcode/table binding: %s", opcode)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		vex, evex := 0, 0
+		for _, line := range strings.Split(row, "\n") {
+			if strings.Contains(line, "avxEscape | vex") {
+				vex++
+				continue
+			}
+			if !strings.Contains(line, "avxEscape | evex") {
+				continue
+			}
+			evex++
+			width := 16
+			if strings.Contains(line, "evex256") {
+				width = 32
+			} else if strings.Contains(line, "evex512") {
+				width = 64
+			}
+			memory := width
+			if scalar {
+				memory = bits / 8
+			}
+			if !strings.Contains(line, fmt.Sprintf("evexN%d", memory)) ||
+				strings.Contains(line, fmt.Sprintf("evexBcstN%d", bits/8)) != !scalar ||
+				strings.Contains(line, "evexSaeEnabled") != (scalar || width == 64) ||
+				strings.Contains(line, "evexZeroingEnabled") || strings.Contains(line, "evexRoundingEnabled") {
+				t.Fatalf("changed compare tuple/BCST/SAE/no-zero/no-round attributes: %s", line)
+			}
+		}
+		wantVex, wantEvex := 2, 3
+		if scalar {
+			wantVex, wantEvex = 1, 1
+		}
+		if vex != wantVex || evex != wantEvex {
+			t.Fatalf("%s encoding rows=%d/%d want=%d/%d", opcode, vex, evex, wantVex, wantEvex)
+		}
+	}
+	for _, source := range []string{string(legacy), string(avx)} {
+		for _, match := range regexp.MustCompile(`\{(?:as: )?A(V?CMP(?:PS|PD|SS|SD)),`).FindAllStringSubmatch(source, -1) {
+			if _, exists := x86FloatCompareSpecs[Op(match[1])]; !exists {
+				t.Fatalf("Go added an unregistered compare opcode: %s", match[1])
+			}
+		}
+	}
+}
diff --git a/amd64_float_compare_transport_test.go b/amd64_float_compare_transport_test.go
new file mode 100644
index 000000000..31a4fc6f5
--- /dev/null
+++ b/amd64_float_compare_transport_test.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+type x86FloatCompareExecution struct {
+	llc, triple   string
+	compiler      []string
+	prefix        []string
+	preserveArgv0 bool
+}
+
+func (execution x86FloatCompareExecution) command(executable string, arguments ...string) []string {
+	command := append([]string(nil), execution.prefix...)
+	command = append(command, executable)
+	if execution.preserveArgv0 {
+		command = append(command, executable)
+	}
+	return append(command, arguments...)
+}
+
+// This is a test-only execution route, not a production ISA permission. The
+// pinned binfmt artifact's special argv transport applies only after its exact
+// binary identity is checked; Rosetta and ordinary native execution differ.
+func x86FloatCompareExecutionTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	if runtime.GOOS != "linux" || runtime.GOARCH != "arm64" {
+		llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+		return x86FloatCompareExecution{llc: llc, triple: triple,
+			compiler: []string{clang, "-target", triple}, prefix: prefix}
+	}
+	llc, _, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	qemu, err := exec.LookPath("qemu-x86_64")
+	if err != nil {
+		t.Fatal("required explicit QEMU x86 execution:", err)
+	}
+	contents, err := os.ReadFile(qemu)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Official linux-arm64 deploy/v10.2.3-68 release, archive ca19f8d2...;
+	// the setup driver separately authenticates the complete archive checksum.
+	const pinnedSHA = "f04e3597ebf2ba6fe98bfb8f453dcbb1b767695e0283ceb7fa265af94d66fc19"
+	if actual := fmt.Sprintf("%x", sha256.Sum256(contents)); actual != pinnedSHA {
+		t.Fatalf("QEMU binary identity: got %s, want %s", actual, pinnedSHA)
+	}
+	version := x86FloatCompareCaptureCommand(t, exec.Command(qemu, "--version"))
+	if !strings.HasPrefix(string(version), "qemu-x86_64 version 10.2.3 ") {
+		t.Fatalf("required QEMU10.2.3: %s", version)
+	}
+	compiler, err := exec.LookPath("x86_64-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required AMD64 ELF cross compiler:", err)
+	}
+	if info, err := os.Stat("/usr/x86_64-linux-gnu"); err != nil || !info.IsDir() {
+		t.Fatalf("required AMD64 guest sysroot: %v", err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{compiler, "-no-pie"},
+		prefix:   []string{qemu, "-cpu", "max", "-L", "/usr/x86_64-linux-gnu"}, preserveArgv0: true}
+	t.Logf("explicit authenticated guest transport=%q (not Rosetta/binfmt execution)", execution.prefix)
+	return execution
+}
+
+func (execution x86FloatCompareExecution) compileC(t *testing.T, source, output string) {
+	t.Helper()
+	command := append([]string(nil), execution.compiler...)
+	process := runtimeOracleProcessSource(t, filepath.Dir(output))
+	command = append(command, "-O2", source, process, "-o", output)
+	x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+}
+
+func (execution x86FloatCompareExecution) run(t *testing.T, executable string, arguments ...string) []byte {
+	t.Helper()
+	command := execution.command(executable, arguments...)
+	return x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+}
+
+// Keep the authenticated guest argv transport through the final executable,
+// not merely through the original-Go preflight. Each external stage has its
+// own bounded lifecycle; no LLVM module or context survives between fixtures.
+func (execution x86FloatCompareExecution) compileAndRunLLVM(t *testing.T, name, ir, main, level string) []byte {
+	t.Helper()
+	return execution.run(t, execution.compileLLVM(t, name, ir, main, level))
+}
+
+// The caller owns this test's temporary directory until all independent
+// invocations finish. Fault observers need the executable, not a helper that
+// treats every genuine native exception as an ordinary command failure.
+func (execution x86FloatCompareExecution) compileLLVM(t *testing.T, name, ir, main, level string) string {
+	t.Helper()
+	if execution.llc == "" || len(execution.compiler) == 0 {
+		t.Fatal("comparison runtime requires its actual LLVM22 and C compiler")
+	}
+	if level != "-O0" && level != "-O2" {
+		t.Fatalf("unsupported comparison optimization level %q", level)
+	}
+	dir := t.TempDir()
+	input := filepath.Join(dir, name+".ll")
+	object := filepath.Join(dir, name+".o")
+	source := filepath.Join(dir, "main.c")
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("comparison"))
+	if strings.Contains(execution.triple, "windows") {
+		main = "int _fltused = 0;\n" + main
+	}
+	process := runtimeOracleProcessSource(t, dir)
+	for path, contents := range map[string]string{input: ir, source: main} {
+		if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(execution.llc, level,
+		"-mtriple="+execution.triple, "-relocation-model=pic", "-filetype=obj", input, "-o", object))
+	compiler := append([]string(nil), execution.compiler...)
+	compiler = append(compiler, object, source, process, "-O2", "-o", executable)
+	if !strings.Contains(execution.triple, "windows") {
+		compiler = append(compiler, "-lm")
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(compiler[0], compiler[1:]...))
+	return executable
+}
+
+func (execution x86FloatCompareExecution) requireAVX(t *testing.T) {
+	t.Helper()
+	dir := t.TempDir()
+	source, executable := filepath.Join(dir, "isa.c"), filepath.Join(dir, "isa")
+	const preflight = `#include <stdio.h>
+int main(void) {
+ __builtin_cpu_init();
+ int avx=!!__builtin_cpu_supports("avx");
+ int avx2=!!__builtin_cpu_supports("avx2");
+ int avx512=!!__builtin_cpu_supports("avx512f");
+ printf("AVX=%d AVX2=%d AVX512F=%d\n",avx,avx2,avx512);
+ return avx?0:1;
+}
+`
+	if err := os.WriteFile(source, []byte(preflight), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("actual guest CPUID/XCR0 preflight: %s", strings.TrimSpace(string(execution.run(t, executable))))
+}
+
+func TestX86FloatingCompareExecutionTransport(t *testing.T) {
+	for _, test := range []struct {
+		name      string
+		execution x86FloatCompareExecution
+		want      []string
+	}{
+		{"native", x86FloatCompareExecution{}, []string{"/guest", "numeric", "with space"}},
+		{"rosetta", x86FloatCompareExecution{prefix: []string{"arch", "-x86_64"}},
+			[]string{"arch", "-x86_64", "/guest", "numeric", "with space"}},
+		{"pinned", x86FloatCompareExecution{prefix: []string{"qemu", "-cpu", "max"}, preserveArgv0: true},
+			[]string{"qemu", "-cpu", "max", "/guest", "/guest", "numeric", "with space"}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			arguments := []string{"numeric", "with space"}
+			before := append([]string(nil), test.execution.prefix...)
+			if actual := test.execution.command("/guest", arguments...); !reflect.DeepEqual(actual, test.want) {
+				t.Fatalf("guest arguments: got %q, want %q", actual, test.want)
+			}
+			if !reflect.DeepEqual(before, test.execution.prefix) || !reflect.DeepEqual(arguments, []string{"numeric", "with space"}) {
+				t.Fatal("execution argument construction mutated its inputs")
+			}
+		})
+	}
+}
+
+func x86FloatCompareVerifyArguments(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":  "module comparearguments\n\ngo 1.20\n",
+		"main.go": "package main\nimport(\"fmt\";\"os\")\nfunc main(){fmt.Printf(\"%q\\n\",os.Args)}\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("arguments"))
+	command := exec.Command("go", "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	for _, arguments := range [][]string{nil, {"numeric", "with space"}} {
+		want := fmt.Sprintf("%q\n", append([]string{executable}, arguments...))
+		if actual := string(execution.run(t, executable, arguments...)); actual != want {
+			t.Fatalf("actual guest argument witness: got %q, want %q", actual, want)
+		}
+	}
+}
diff --git a/amd64_float_compare_vex_numerical_linux_test.go b/amd64_float_compare_vex_numerical_linux_test.go
new file mode 100644
index 000000000..7fbf00d0b
--- /dev/null
+++ b/amd64_float_compare_vex_numerical_linux_test.go
@@ -0,0 +1,11 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import "testing"
+
+// This mandatory axis executes the translated actual whole VEX compare against
+// the independent original opcode. QEMU has AVX/AVX2 but not native AVX512.
+func TestCrossLinuxRuntimeMatrixX86FloatingCompareVEXWholeIEEEAndMXCSR(t *testing.T) {
+	x86FloatCompareVEXWholeRuntime(t)
+}
diff --git a/amd64_float_compare_vex_numerical_test.go b/amd64_float_compare_vex_numerical_test.go
new file mode 100644
index 000000000..8cfb3d4aa
--- /dev/null
+++ b/amd64_float_compare_vex_numerical_test.go
@@ -0,0 +1,365 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This matrix is independent of the production operand/predicate registries.
+// All six native VEX widths have every predicate and both first-source roles;
+// destination aliases rotate through both sources and an independent register.
+func x86FloatCompareVEXOracleCases() []x86FloatCompareOracleCase {
+	var cases []x86FloatCompareOracleCase
+	for _, fixture := range x86FloatCompareOriginalVectors() {
+		bank := "X"
+		if fixture.width == 32 {
+			bank = "Y"
+		}
+		for predicate := 0; predicate < 32; predicate++ {
+			for _, memory := range []bool{false, true} {
+				first := bank + "1"
+				if memory {
+					first = "(CX)"
+				}
+				cases = append(cases, x86FloatCompareOracleCase{
+					row:  fmt.Sprintf("%s $%d,%s,%s0,%s%d", fixture.opcode, predicate, first, bank, bank, predicate%3),
+					bits: fixture.bits, width: fixture.width, predicate: predicate,
+					scalar: fixture.scalar, memory: memory, destination: predicate % 3,
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func x86FloatCompareVEXOracleAssembly(cases []x86FloatCompareOracleCase) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, fixture := range cases {
+		name := fmt.Sprintf("vex_compare%d", index)
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-24
+MOVQ out+0(FP),AX
+MOVQ a+8(FP),BX
+MOVQ b+16(FP),CX
+VMOVUPS (BX),Y0
+VMOVUPS (BX),Y2
+`, name)
+		if !fixture.memory {
+			source.WriteString("VMOVUPS (CX),Y1\n")
+		}
+		source.WriteString("STC\n" + fixture.row + "\n")
+		// Z is a translated shadow-view observation, not a native AVX512
+		// instruction in the original-opcode reference. The expected high bytes
+		// are independently zero for VEX X/Y writes. No EVEX compare is run.
+		fmt.Fprintf(&source, "VMOVUPS Z%d,8(AX)\nSETCS 72(AX)\nRET\n", fixture.destination)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+	}
+	return source.String(), sigs
+}
+
+// Emit the actual requested whole VCMP opcode and full native memory tuple.
+// Its MXCSR is an independent original-instruction reference, not a union of
+// per-lane quiet/signaling representatives. IEEE truth remains integer-only.
+func x86FloatCompareVEXWholeReferenceC() string {
+	var source strings.Builder
+	source.WriteString(x86FloatCompareIndependentC)
+	for index, fixture := range x86FloatCompareOriginalVectors() {
+		for variant := 0; variant < 2; variant++ {
+			fmt.Fprintf(&source, `
+__attribute__((target("avx"))) static void reference%d(uint8_t *out,const uint8_t *a,const uint8_t *b,unsigned predicate,unsigned csr,unsigned *after){
+ typedef uint8_t vector __attribute__((vector_size(%d)));
+ vector left,right,result;
+ memcpy(&left,a,sizeof(left));memcpy(&right,b,sizeof(right));
+ unsigned saved;uint8_t carry;
+ __asm__ volatile("stmxcsr %%0":"=m"(saved));
+ __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+ switch(predicate){
+`, index*2+variant, fixture.width)
+			operand := "\"x\"(right)"
+			if variant == 1 {
+				bytes := fixture.width
+				if fixture.scalar {
+					bytes = fixture.bits / 8
+				}
+				operand = fmt.Sprintf("\"m\"(*(const uint8_t(*)[%d])b)", bytes)
+			}
+			for predicate := 0; predicate < 32; predicate++ {
+				fmt.Fprintf(&source, " case %d: __asm__ volatile(\"stc; %s $%d,%%3,%%2,%%0; setc %%1\":\"=x\"(result),\"=qm\"(carry):\"x\"(left),%s:\"cc\");break;\n",
+					predicate, strings.ToLower(fixture.opcode), predicate, operand)
+			}
+			source.WriteString(` }
+ __asm__ volatile("stmxcsr %0":"=m"(*after));
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));
+ memset(out,0,64);memcpy(out,&result,sizeof(result));out[64]=carry;
+}
+`)
+		}
+	}
+	source.WriteString("typedef void(*reference_fn)(uint8_t*,const uint8_t*,const uint8_t*,unsigned,unsigned,unsigned*);\nstatic reference_fn references[]={")
+	for index := 0; index < 12; index++ {
+		fmt.Fprintf(&source, "reference%d,", index)
+	}
+	source.WriteString("};\n")
+	return source.String()
+}
+
+func x86FloatCompareVEXWholeMain(cases []x86FloatCompareOracleCase) string {
+	var declarations, descriptors strings.Builder
+	for index, fixture := range cases {
+		fmt.Fprintf(&declarations, "extern void vex_compare%d(void*,const void*,const void*);\n", index)
+		fmt.Fprintf(&descriptors, "{vex_compare%d,%d,%d,%d,%d,%d},\n", index, index/64*2+x86FloatAddSubBoolInt(fixture.memory),
+			fixture.bits, fixture.width, fixture.predicate, x86FloatAddSubBoolInt(fixture.scalar))
+	}
+	return x86FloatCompareVEXWholeReferenceC() + declarations.String() + `
+typedef void(*translated_fn)(void*,const void*,const void*);
+struct comparison{translated_fn call;unsigned reference,bits,width,predicate,scalar;};
+static const struct comparison comparisons[]={
+` + descriptors.String() + `
+};
+int main(void){
+ unsigned saved;__asm__ volatile("stmxcsr %0":"=m"(saved));
+ uint64_t samples=0;
+ for(unsigned index=0;index<sizeof(comparisons)/sizeof(comparisons[0]);index++){
+  const struct comparison *c=comparisons+index;
+  unsigned bytes=c->bits/8;const uint64_t *edges=bytes==4?edges32:edges64;
+  for(unsigned mode=0;mode<2;mode++)for(unsigned i=0;i<18;i++)for(unsigned j=0;j<18;j++)for(unsigned control=0;control<6;control++){
+   uint8_t aStorage[192],bStorage[192],out[81],expected[65],truth[64];
+   uint8_t *a=aStorage+65,*b=bStorage+65;
+   memset(aStorage,0xa7,sizeof(aStorage));memset(bStorage,0xb9,sizeof(bStorage));memset(out,0xc3,sizeof(out));
+   for(unsigned lane=0;lane<64/bytes;lane++){
+    uint64_t av=edges[(i+(mode?lane:0))%18],bv=edges[(j+(mode?lane*5:0))%18];
+    memcpy(a+lane*bytes,&av,bytes);memcpy(b+lane*bytes,&bv,bytes);
+   }
+   uint8_t beforeA[192],beforeB[192];memcpy(beforeA,aStorage,192);memcpy(beforeB,bStorage,192);
+   unsigned csr=controls[control],expectedCSR,after;
+   references[c->reference](expected,a,b,c->predicate,csr,&expectedCSR);
+   memset(truth,0,64);if(c->scalar)memcpy(truth,a,16);
+   unsigned compared=c->scalar?bytes:c->width;
+   for(unsigned lane=0;lane<compared;lane+=bytes){
+    int value=independent_compare(c->bits,read_bits(a+lane,bytes),read_bits(b+lane,bytes),c->predicate,csr);
+    memset(truth+lane,value?255:0,bytes);
+   }
+   if(memcmp(truth,expected,64)||expected[64]!=1){
+    fprintf(stderr,"original VEX truth/CF index=%u pred=%u mode=%u i=%u j=%u csr=%x\n",index,c->predicate,mode,i,j,csr);return 10;
+   }
+   __asm__ volatile("ldmxcsr %0"::"m"(csr));
+   c->call(out,a,b);
+   __asm__ volatile("stmxcsr %0":"=m"(after));
+   __asm__ volatile("ldmxcsr %0"::"m"(saved));
+   if(after!=expectedCSR||memcmp(aStorage,beforeA,192)||memcmp(bStorage,beforeB,192)){
+    fprintf(stderr,"translated VEX MXCSR/input index=%u pred=%u mode=%u i=%u j=%u csr=%x got=%x want=%x\n",index,c->predicate,mode,i,j,csr,after,expectedCSR);return 11;
+   }
+   for(unsigned byte=0;byte<81;byte++){
+    uint8_t want=byte>=8&&byte<=72?expected[byte-8]:0xc3;
+    if(out[byte]!=want){
+     fprintf(stderr,"translated VEX alias/canary index=%u pred=%u mode=%u i=%u j=%u byte=%u got=%x want=%x\n",index,c->predicate,mode,i,j,byte,out[byte],want);return 12;
+    }
+   }
+   samples++;
+  }
+ }
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));
+ printf("384 VEX forms, %llu full IEEE/MXCSR/CF/64-alias/canary samples\n",(unsigned long long)samples);
+ return samples==UINT64_C(1492992)?0:13;
+}
+`
+}
+
+func TestX86FloatingCompareVEXWholeOracleInventory(t *testing.T) {
+	cases := x86FloatCompareVEXOracleCases()
+	if len(cases) != 384 {
+		t.Fatalf("VEX forms=%d want384", len(cases))
+	}
+	source, _ := x86FloatCompareVEXOracleAssembly(cases)
+	if strings.Contains(source, "KMOV") || strings.Contains(source, ".SAE") || strings.Contains(source, ".BCST") {
+		t.Fatal("non-VEX compare prerequisites entered native VEX oracle")
+	}
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	if strings.Contains(x86FloatCompareVEXWholeMain(cases), "original_effect(") {
+		// The shared relation source declares this older diagnostic helper but
+		// the whole-vector driver must not call it or substitute sample values.
+		main := strings.Split(x86FloatCompareVEXWholeMain(cases), "int main(void){")[1]
+		if strings.Contains(main, "original_effect(") || strings.Contains(main, "is_denormal(") {
+			t.Fatal("whole native effect reference was replaced by a class/lane policy")
+		}
+	}
+}
+
+func TestX86FloatingCompareVEXWholeEffectsIR(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	cases := x86FloatCompareVEXOracleCases()
+	var physicalSource strings.Builder
+	var physicalBytes strings.Builder
+	for index, fixture := range cases {
+		name := fmt.Sprintf("physical_vex%d", index)
+		fmt.Fprintf(&physicalSource, "TEXT %s(SB),4,$0-0\n", name)
+		for _, b := range x86FloatCompareVEXOriginalBytes(t, fixture.row) {
+			fmt.Fprintf(&physicalSource, "BYTE $%d\n", b)
+			fmt.Fprintf(&physicalBytes, "0x%02x ", b)
+		}
+		physicalBytes.WriteString("\n")
+		// This is only a physical mode32 format harness. Unknown incoming
+		// pointers cannot borrow a native return contract from that byte marker.
+		physicalSource.WriteString("UNDEF\n")
+	}
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=i386-unknown-linux-gnu", "--mattr=+avx")
+	command.Stdin = strings.NewReader(physicalBytes.String())
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go mode32 byte validation: %v\n%s", err, output)
+	}
+	physical := regexp.MustCompile(`(?m)^\s+vcmp[a-z0-9_]*(ps|pd|ss|sd)\s+`).FindAll(output, -1)
+	if len(physical) != 384 || strings.Contains(string(output), "warning:") {
+		t.Fatalf("original AMD64 Go bytes lack complete physical mode32 LLVM-MC identity:\n%s", output)
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-macosx"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source, sigs := x86FloatCompareVEXOracleAssembly(cases)
+			if target.arch == "386" {
+				// The original mode32 byte fixture has neither initialized
+				// vectors nor native pointer inputs. Keep its original Go
+				// objects and public Context controls, then check only its
+				// complete physical syntax through the private emitter.
+				ir := x86FloatingCompareUnboundFormatObject(t, physicalSource.String(), target.arch, target.triple)
+				if strings.Contains(ir, " = fcmp ") || strings.Count(ir, "asm sideeffect \"vcmp") != len(cases) ||
+					strings.Count(ir, "asm sideeffect \"ud2\"") != len(cases) {
+					t.Fatal("physical mode32 VEX formats lost original comparison side effects")
+				}
+				compileLLVMToObject(t, llc, target.triple, "vex-whole-format.ll", "vex-whole-format.o", ir)
+				return
+			}
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := func() string {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs})
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				return module.String()
+			}()
+			if strings.Contains(ir, " = fcmp ") || strings.Count(ir, "asm sideeffect") < 384 {
+				t.Fatal("full native VEX predicate/width side effects were replaced by relation-only fcmp")
+			}
+			compileLLVMToObject(t, llc, target.triple, "vex-whole.ll", "vex-whole.o", ir)
+		})
+	}
+}
+
+func x86FloatCompareVEXOriginalBytes(t *testing.T, row string) []byte {
+	t.Helper()
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+	if err != nil {
+		t.Fatalf("original Go VEX encoding: %v\n%s", err, listing)
+	}
+	length := 0
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 4 && fields[len(fields)-1] == "RET" {
+			length, err = strconv.Atoi(fields[1])
+			if err != nil || length < 1 || length > 15 {
+				t.Fatalf("original VEX native width: %v\n%s", err, listing)
+			}
+		}
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if length == 0 || len(fields) <= length || fields[0] != "0x0000" || len(fields[1]) != 2 {
+			continue
+		}
+		code := make([]byte, length)
+		for index := range code {
+			value, err := strconv.ParseUint(fields[index+1], 16, 8)
+			if err != nil {
+				t.Fatal(err)
+			}
+			code[index] = byte(value)
+		}
+		return code
+	}
+	t.Fatalf("original VEX machine bytes unavailable:\n%s", listing)
+	return nil
+}
+
+func TestX86FloatingCompareVEXWholeOriginalCObject(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "original.c"), filepath.Join(dir, "original.o")
+	contents := x86FloatCompareVEXWholeMain(x86FloatCompareVEXOracleCases())
+	// These two headers belong to older fault fixtures, not this numerical
+	// reference. Keep the ordinary C object portable to Windows as well.
+	contents = strings.NewReplacer("#include <sys/mman.h>\n", "", "#include <unistd.h>\n", "").Replace(contents)
+	if err := os.WriteFile(source, []byte(contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	arguments := append(append([]string(nil), execution.compiler...), "-O2", "-c", source, "-o", object)
+	command := exec.Command(arguments[0], arguments[1:]...)
+	x86FloatCompareCaptureCommand(t, command)
+}
+
+func x86FloatCompareVEXWholeRuntime(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	x86FloatCompareVerifyArguments(t, execution)
+	cases := x86FloatCompareVEXOracleCases()
+	source, sigs := x86FloatCompareVEXOracleAssembly(cases)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := func() string {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := TranslateModuleInContext(ctx, file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		return module.String()
+	}()
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "vex-whole-compare", ir, x86FloatCompareVEXWholeMain(cases), level)
+			const expected = "384 VEX forms, 1492992 full IEEE/MXCSR/CF/64-alias/canary samples"
+			if strings.TrimSpace(string(output)) != expected {
+				t.Fatalf("whole native VEX oracle output: %q", output)
+			}
+			t.Logf("%s: %s transport=%v", level, expected, execution.prefix)
+		})
+	}
+	t.Log("384 register/memory VEX forms ×3888 full Cartesian/mixed-lane samples per optimization level; no EVEX execution")
+}
diff --git a/amd64_float_min_max_forms.go b/amd64_float_min_max_forms.go
new file mode 100644
index 000000000..26b07709e
--- /dev/null
+++ b/amd64_float_min_max_forms.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+type x86FloatMinMaxForm = x86FloatArithmeticForm
+
+func x86FloatMinMaxNativeEVEX(ins Instr, f x86FloatMinMaxForm) bool {
+	if f.legacy {
+		return false
+	}
+	if ins.x86FloatMinMaxEVEX || f.byteWidth == 64 || f.mask >= 0 || f.broadcast || f.sae {
+		return true
+	}
+	for _, operand := range ins.Args {
+		if index, valid := amd64VectorRegisterIndex(operand.Reg, f.byteWidth); operand.Kind == OpReg && valid && index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+func x86FloatMinMaxProperties(ins Instr, arch string) (x86FloatMinMaxForm, bool, error) {
+	return x86FloatArithmeticProperties(ins, arch, x86FloatMinimumMaximum)
+}
diff --git a/amd64_float_min_max_forms_test.go b/amd64_float_min_max_forms_test.go
new file mode 100644
index 000000000..dbcb1a1d9
--- /dev/null
+++ b/amd64_float_min_max_forms_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86FloatingMinMaxFormats(arch string) []string {
+	var rows []string
+	for _, member := range x86FloatingMinMaxCases {
+		if member.legacy {
+			rows = append(rows, member.op+" X0,X1", member.op+" (AX),X1")
+			continue
+		}
+		banks := []string{"X", "Y", "Z"}
+		if member.scalar {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"", "merge", "zero"} {
+				if arch == "386" && mode != "" {
+					continue // Go's named four-operand frontend cap, not a physical ISA claim.
+				}
+				mask, zero := "", ""
+				if mode != "" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					zero = ".Z"
+				}
+				registers := bank + "0," + bank + "1," + mask + bank + "2"
+				memory := "(AX)," + bank + "1," + mask + bank + "2"
+				rows = append(rows, member.op+zero+" "+registers, member.op+zero+" "+memory)
+				if !member.scalar {
+					rows = append(rows, member.op+".BCST"+zero+" "+memory)
+				}
+				if member.scalar || bank == "Z" {
+					rows = append(rows, member.op+".SAE"+zero+" "+registers)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86FloatingMinMaxIndependentCompleteEncoderRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n}") {
+		t.Fatal("complete original MIN/MAX yxm table changed")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if x86FloatArithmeticFamilyCount(x86FloatMinimumMaximum) != len(x86FloatingMinMaxCases) {
+		t.Fatal("incomplete typed MIN/MAX family")
+	}
+	for _, member := range x86FloatingMinMaxCases {
+		prefix, w, opcode := "", 0, "0x5D"
+		if member.bits == 64 {
+			prefix, w = "66", 1
+		}
+		if member.scalar {
+			prefix = map[int]string{32: "F3", 64: "F2"}[member.bits]
+		}
+		if strings.Contains(member.op, "MAX") {
+			opcode = "0x5F"
+		}
+		if member.legacy {
+			p := map[string]string{"": "Pm", "66": "Pe", "F2": "Pf2", "F3": "Pf3"}[prefix]
+			row := fmt.Sprintf("{A%s, yxm, %s, opBytes{%s}}", member.op, p, strings.ToLower(opcode))
+			if !strings.Contains(string(legacy), row) {
+				t.Fatal("original legacy MIN/MAX prefix or opcode changed", row)
+			}
+			continue
+		}
+		table := "_yvaddpd"
+		vexWidths, evexWidths := []int{128, 256}, []int{512, 128, 256}
+		if member.scalar {
+			table, vexWidths, evexWidths = "_yvaddsd", []int{128}, []int{128}
+		}
+		var expected []goasmrules.X86AVXRule
+		var encoding []string
+		offset := 0
+		add := func(zcase string, advance int, classes string) {
+			expected = append(expected, goasmrules.X86AVXRule{Opcode: member.op, Ytab: table, Prefix: "Pavx",
+				Classes: strings.Split(classes, ","), RowIndex: len(expected), ZCase: zcase,
+				ZOffset: advance, EncodingOffset: offset})
+			offset += advance
+		}
+		pp := func(generation string) string {
+			if prefix == "" {
+				return ""
+			}
+			return " | " + generation + prefix
+		}
+		for _, width := range vexWidths {
+			bank := map[int]string{128: "x", 256: "y"}[width]
+			add("Zvex_rm_v_r", 2, "Y"+bank+"m,Y"+bank+"r,Y"+bank+"r")
+			encoding = append(encoding, fmt.Sprintf("avxEscape | vex%d%s | vex0F | vexW0", width, pp("vex")), opcode)
+		}
+		for _, width := range evexWidths {
+			bank := map[int]string{128: "x", 256: "y", 512: "z"}[width]
+			memory, register := "Y"+bank+"mEvex", "Y"+bank+"rEvex"
+			if width == 512 {
+				memory, register = "Yzm", "Yzr"
+			}
+			add("Zevex_rm_v_r", 0, memory+","+register+","+register)
+			add("Zevex_rm_v_k_r", 3, memory+","+register+",Yknot0,"+register)
+			attributes := fmt.Sprintf("evexN%d | evexBcstN%d", width/8, member.bits/8)
+			if member.scalar {
+				attributes = fmt.Sprintf("evexN%d", member.bits/8)
+			}
+			if member.scalar || width == 512 {
+				attributes += " | evexSaeEnabled"
+			}
+			attributes += " | evexZeroingEnabled"
+			encoding = append(encoding, fmt.Sprintf("avxEscape | evex%d%s | evex0F | evexW%d", width, pp("evex"), w), attributes, opcode)
+		}
+		for index := range expected {
+			expected[index].OpBytes = encoding
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == member.op {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("%s complete original encoding changed:\ngot %+v\nwant %+v", member.op, actual, expected)
+		}
+	}
+}
+
+func TestX86FloatingMinMaxCompleteNamedGrammar(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86FloatingMinMaxFormats(arch)
+		want := 68
+		if arch == "amd64" {
+			want = 172
+		}
+		if len(rows) != want {
+			t.Fatal("independent MIN/MAX format denominator changed", arch, len(rows))
+		}
+		requireX86GoAssemblerResult(t, arch, "TEXT Forms(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", true)
+		for _, row := range rows {
+			ins := x86ScalarLaneInstruction(t, row)
+			f, known, err := x86FloatMinMaxProperties(ins, arch)
+			if !known || err != nil || f.byteWidth == 0 || f.rounding != "" {
+				t.Fatal("complete typed MIN/MAX grammar lost an original row", arch, row, err)
+			}
+			if f.memory >= 0 {
+				logical := ins
+				logical.Args = append([]Operand(nil), ins.Args...)
+				logical.Args[f.memory] = Operand{Kind: OpFP}
+				width, write, valid := X86FPAccessBytes(logical, f.memory, arch)
+				if !valid || write || width != int64(f.memoryBytes) {
+					t.Fatal("SDK/native-width observer diverged from the complete typed tuple", arch, row, width, valid)
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatingMinMaxMalformedAndDispatchBeforeIR(t *testing.T) {
+	for _, row := range []string{
+		"MINPS X0,Y1", "MAXSD X0,AX", "MINSS X0,X16", "MAXPD.SAE X0,X1",
+		"VMINPS X0,X1", "VMAXPD X0,Y1,Y2", "VMINSS Y0,Y1,Y2", "VMAXSD X0,X1,K0,X2",
+		"VMINPS.Z X0,X1,X2", "VMAXPS.BCST X0,X1,X2", "VMINSS.BCST (AX),X1,X2",
+		"VMAXPS.RN_SAE Z0,Z1,Z2", "VMINPS.SAE X0,X1,X2", "VMAXSD.SAE (AX),X1,X2",
+		"VMINPS. X0,X1,X2", "VMAXPS.Z.BCST (AX),Z1,K1,Z2", "VMINSD $1.5,X1,X2",
+		"VMINPS $data(SB),X1,X2", "VMAXSS (AX)(SP*2),X1,X2", "VMINPD 2147483648(AX),X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, terminated, err := ctx.lowerFloatMinMax(ins.Op, ins)
+			if !known || terminated || err == nil || output.String() != before {
+				t.Fatal("malformed MIN/MAX emitted IR", known, terminated, err)
+			}
+		})
+	}
+	for _, member := range x86FloatingMinMaxCases {
+		row := member.op + " X0,X1,X2"
+		if member.legacy {
+			row = member.op + " X0,X1"
+		}
+		ins := x86ScalarLaneInstruction(t, row)
+		file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+row+"\nRET\n")
+		ins.Op = "UNKNOWN"
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		known, terminated, err := ctx.lowerFloatMinMax(Op(member.op), ins)
+		if !known || terminated || err == nil || output.String() != before {
+			t.Fatal("MIN/MAX dispatch changed original identity", member.op, err)
+		}
+	}
+}
diff --git a/amd64_float_mul_div_forms.go b/amd64_float_mul_div_forms.go
new file mode 100644
index 000000000..5390a7ddc
--- /dev/null
+++ b/amd64_float_mul_div_forms.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+type x86FloatMulDivForm = x86FloatArithmeticForm
+
+func x86FloatMulDivProperties(ins Instr, arch string) (x86FloatMulDivForm, bool, error) {
+	return x86FloatArithmeticProperties(ins, arch, x86FloatMultiplyDivide)
+}
diff --git a/amd64_float_mul_div_forms_test.go b/amd64_float_mul_div_forms_test.go
new file mode 100644
index 000000000..388791be1
--- /dev/null
+++ b/amd64_float_mul_div_forms_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86FloatMulDivOpcodes() []string {
+	return []string{
+		"MULPS", "MULPD", "MULSS", "MULSD",
+		"DIVPS", "DIVPD", "DIVSS", "DIVSD",
+		"VMULPS", "VMULPD", "VMULSS", "VMULSD",
+		"VDIVPS", "VDIVPD", "VDIVSS", "VDIVSD",
+	}
+}
+
+func x86FloatMulDivFormats(arch string) []string {
+	// All eight opcode attributes are independently checked below. Go uses
+	// the same yxm/_yvaddpd/_yvaddsd operand grammars as ADD/SUB, not merely
+	// the same vector widths. Reuse the independent shape-axis inventory.
+	rows := x86FloatAddSubFormats(arch)
+	for i, row := range rows {
+		rows[i] = strings.NewReplacer("ADD", "MUL", "SUB", "DIV").Replace(row)
+	}
+	return rows
+}
+
+func TestX86FloatMulDivEveryGoOpcodeAttribute(t *testing.T) {
+	if x86FloatArithmeticFamilyCount(x86FloatMultiplyDivide) != 16 {
+		t.Fatal("incomplete floating MUL/DIV family")
+	}
+	for _, opcode := range x86FloatMulDivOpcodes() {
+		bits := 32
+		if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		mode := amd64BinaryFloatingMul
+		if strings.Contains(opcode, "DIV") {
+			mode = amd64BinaryFloatingDiv
+		}
+		want := x86FloatArithmeticSpec{bits, !strings.HasPrefix(opcode, "V"),
+			strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD"), mode}
+		if got, found := x86FloatArithmeticSpecs[Op(opcode)]; !found || got != want {
+			t.Fatalf("%s typed specification differs from independent mnemonic: %+v/%+v", opcode, got, want)
+		}
+	}
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // The current-toolchain gate owns encoder-table completeness.
+	}
+	dir := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	for _, filename := range []string{"asm6.go", "avx_optabs.go"} {
+		data, err := os.ReadFile(filepath.Join(dir, filename))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range x86FloatMulDivOpcodes() {
+			legacy := !strings.HasPrefix(opcode, "V")
+			if (filename == "asm6.go") != legacy {
+				continue
+			}
+			if legacy {
+				if !strings.Contains(string(data), "{A"+opcode+", yxm,") {
+					t.Fatalf("Go legacy grammar changed: %s", opcode)
+				}
+				continue
+			}
+			scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+			bits := 32
+			if strings.HasSuffix(opcode, "PD") || strings.HasSuffix(opcode, "SD") {
+				bits = 64
+			}
+			prefix := "{as: A" + opcode + ", ytab: "
+			start := strings.Index(string(data), prefix)
+			if start < 0 {
+				t.Fatalf("Go omits %s", opcode)
+			}
+			row := strings.SplitN(string(data)[start:], "\n\t}},", 2)[0]
+			table := "_yvaddpd"
+			if scalar {
+				table = "_yvaddsd"
+			}
+			if !strings.HasPrefix(row, prefix+table+",") {
+				t.Fatalf("Go grammar changed: %s", row)
+			}
+			seen := 0
+			for _, line := range strings.Split(row, "\n") {
+				if !strings.Contains(line, "avxEscape | evex") {
+					continue
+				}
+				seen++
+				if !strings.Contains(line, "evexZeroingEnabled") || strings.Contains(line, "evexSaeEnabled") ||
+					strings.Contains(line, "evexRoundingEnabled") != (scalar || strings.Contains(line, "evex512")) ||
+					strings.Contains(line, fmt.Sprintf("evexBcstN%d", bits/8)) != !scalar {
+					t.Fatalf("%s opcode attribute changed: %s", opcode, line)
+				}
+			}
+			if scalar && seen != 1 || !scalar && seen != 3 {
+				t.Fatalf("%s incomplete EVEX row count %d", opcode, seen)
+			}
+		}
+	}
+}
+
+func TestX86FloatMulDivCompleteGoGrammarAndFiveLLVMTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		var declarations strings.Builder
+		declarations.WriteString("package shapes\n")
+		sigs := map[string]FuncSig{}
+		for index, row := range x86FloatMulDivFormats(arch) {
+			name := fmt.Sprintf("muldiv%d", index)
+			entry := fmt.Sprintf("TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+			file, err := Parse(ArchAMD64, entry)
+			if err != nil {
+				t.Fatal(err)
+			}
+			form, recognized, err := x86FloatMulDivProperties(file.Funcs[0].Instrs[1], arch)
+			if !recognized || err != nil || form.bits == 0 || form.byteWidth == 0 {
+				t.Fatalf("%s/%s: %v", arch, row, err)
+			}
+			source.WriteString(entry)
+			fmt.Fprintf(&declarations, "func %s()\n", name)
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			options := Options{Goarch: arch, TargetTriple: triple, Sigs: sigs}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			func() {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				goSource := strings.ReplaceAll(source.String(), "TEXT muldiv", "TEXT ·muldiv")
+				result, err := translateGoModuleInContext(context, x86FloatMulDivShapesPackage(t, declarations.String(), arch),
+					[]byte(goSource), GoModuleOptions{GOARCH: arch, TargetTriple: triple})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				for api, body := range []string{ir, module.String(), result.Module.String()} {
+					name := fmt.Sprintf("muldiv-formats-api%d", api)
+					compileLLVMToObject(t, llc, triple, name+".ll", name+".o", body)
+				}
+			}()
+		}
+		t.Logf("%s: %d independent Go MUL/DIV formats", arch, len(sigs))
+	}
+}
+
+func x86FloatMulDivShapesPackage(t *testing.T, source, arch string) GoPackage {
+	t.Helper()
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "shapes.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("shapes", set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: pkg.Path(), Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func TestX86FloatMulDivRejectsMalformedBeforeEmission(t *testing.T) {
+	for _, row := range []string{
+		"MULPS X0,Y1", "MULSD X0,AX", "DIVSS X0,X16", "DIVPD.SAE X0,X1",
+		"VMULPS X0,X1", "VMULPD X0,Y1,Y2", "VMULSS Y0,Y1,Y2", "VDIVSD X0,X1,K0,X2",
+		"VMULPS.Z X0,X1,X2", "VMULPS.BCST X0,X1,X2", "VMULSS.BCST (AX),X1,X2",
+		"VDIVPS.SAE Z0,Z1,Z2", "VMULPS.RD_SAE X0,X1,X2", "VDIVSD.RU_SAE (AX),X1,X2",
+		"VMULPS. X0,X1,X2", "VDIVPS.Z.BCST (AX),Z1,K1,Z2",
+		"VMULPS $data(SB),X1,X2", "VDIVSS (AX)(SP*2),X1,X2", "VMULPD 2147483648(AX),X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			oldReservedZeroing := row == "VMULPS.Z X0,X1,X2" && !goToolchainAtLeast(runtime.Version(), 1, 21)
+			goAssemblerOracleOutput(t, "amd64", source, "", oldReservedZeroing)
+			if oldReservedZeroing {
+				listing := x86InsertExtractGoListing(t, "amd64", source)
+				var code []byte
+				for _, line := range strings.Split(string(listing), "\n") {
+					code = append(code, x86InsertExtractListedBytes(line)...)
+				}
+				if !bytes.Equal(code, []byte{0x62, 0xf1, 0x74, 0x88, 0x59, 0xd0, 0xc3}) {
+					t.Fatalf("old Go reserved EVEX.z/aaa=0 observation changed: %x", code)
+				}
+				if _, _, known, err := decodedX86EVEXBinaryFloatInstruction(code, 0, 64, "", false); !known || err == nil {
+					t.Fatal("old Go reserved zeroing bytes acquired valid raw semantics")
+				}
+				t.Log("old Go accepted reserved EVEX.z/aaa=0; both named and raw validators still reject it")
+			}
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				return // Parser rejection also occurs before IR emission.
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.Len()
+			var known, term bool
+			if strings.HasPrefix(row, "V") {
+				known, term, err = ctx.lowerBinaryFloating(ins.Op, ins)
+			} else {
+				known, term, err = ctx.lowerFP(ins.Op, ins)
+			}
+			if !known || term || err == nil || output.Len() != before {
+				t.Fatalf("invalid MUL/DIV emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+}
diff --git a/amd64_float_mul_div_literal_runtime_test.go b/amd64_float_mul_div_literal_runtime_test.go
new file mode 100644
index 000000000..5d7a6f535
--- /dev/null
+++ b/amd64_float_mul_div_literal_runtime_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86MulDivLiteralNumericalSource() (declarations, assembly string) {
+	var goSource, machine strings.Builder
+	for _, opcode := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+		for _, value := range x86MulDivLiteralValues {
+			name := strings.ToLower(opcode) + value.name
+			fmt.Fprintf(&goSource, "func %s(input *[32]byte, output *[80]byte, csr uint32)\n", name)
+			fmt.Fprintf(&machine, `TEXT ·%s(SB),4,$8-20
+STMXCSR saved-4(SP)
+LDMXCSR csr+16(FP)
+MOVQ input+0(FP),AX
+MOVQ output+8(FP),BX
+VMOVUPS (AX),Y0
+MOVQ $0x7fffffffffffffff,DX
+ADDQ $1,DX
+STC
+%s $%s,X0
+MOVUPS X0,8(BX)
+VMOVUPS Y0,24(BX)
+STMXCSR 56(BX)
+SETCS 60(BX)
+SETOS 61(BX)
+LDMXCSR saved-4(SP)
+RET
+`, name, opcode, value.text)
+		}
+	}
+	return goSource.String(), machine.String()
+}
+
+func x86MulDivLiteralOptimizedObject(t *testing.T, llc, triple, ir string) {
+	t.Helper()
+	directory := t.TempDir()
+	source, object := filepath.Join(directory, "literal.ll"), filepath.Join(directory, "literal.o")
+	if err := os.WriteFile(source, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, llc, "-O2", "-mtriple="+triple, "-filetype=obj", source, "-o", object)
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("LLVM22 optimized literal object: %v\n%s", err, output)
+	}
+	info, err := os.Stat(object)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("LLVM22 optimized literal object missing/nonregular/empty: %v", err)
+	}
+}
+
+func x86MulDivLiteralCOracle() string {
+	var declarations, checks strings.Builder
+	index := 0
+	for _, opcode := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+		bits := 32
+		if strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		for _, value := range x86MulDivLiteralValues {
+			literal := value.bits64
+			if bits == 32 {
+				literal = uint64(value.bits32)
+			}
+			name := strings.ToLower(opcode) + value.name
+			fmt.Fprintf(&declarations, "extern void %s(void*,void*,unsigned);\n", name)
+			fmt.Fprintf(&checks, "    if (check_literal(%s,%q,%d,UINT64_C(0x%x),%d)) return %d;\n", name, name, bits, literal, x86FloatAddSubBoolInt(strings.HasPrefix(opcode, "DIV")), index+1)
+			index++
+		}
+	}
+	return x86FloatMulDivSSEOracle + declarations.String() + `
+typedef void (*literal_fn)(void*,void*,unsigned);
+static int check_literal(literal_fn fn,const char *name,unsigned bits,uint64_t literal,int divide) {
+    const uint64_t edge32[]={0,0x80000000,1,0x80000001,0x3f800000,0xbf800000,
+        0x7f7fffff,0x7f800000,0xff800000,0x7fc12345,0x7f812345};
+    const uint64_t edge64[]={0,UINT64_C(0x8000000000000000),1,UINT64_C(0x8000000000000001),
+        UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x7fefffffffffffff),
+        UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),
+        UINT64_C(0x7ff8123456789abc),UINT64_C(0x7ff0123456789abc)};
+    const unsigned controls[]={0x1f80,0x1f85,0x1fc0,0x9f80,0x9fc0,0x3f80,0x5f80,0x7f80};
+    for(unsigned sample=0;sample<11;sample++) {
+        unsigned char input[32],before[32],output[80],want[80];
+        for(unsigned byte=0;byte<32;byte++) input[byte]=(unsigned char)(byte*37+19);
+        uint64_t left=bits==32?edge32[sample]:edge64[sample];
+        memcpy(input,&left,bits/8);
+        memcpy(before,input,32);
+        for(unsigned mode=0;mode<8;mode++) {
+            unsigned ambient=0x3f85,after;
+            memset(output,0xa7,80);
+            memset(want,0xa7,80);
+            uint64_t result=sse_result(bits,left,literal,divide,controls[mode]);
+            unsigned expectedCSR=last_sse_csr;
+            memcpy(want+8,input,16);
+            memcpy(want+24,input,32);
+            memcpy(want+8,&result,bits/8);
+            memcpy(want+24,&result,bits/8);
+            memcpy(want+56,&expectedCSR,4);
+            want[60]=1;
+            want[61]=1;
+            __asm__ volatile("ldmxcsr %0"::"m"(ambient));
+            fn(input,output,controls[mode]);
+            __asm__ volatile("stmxcsr %0":"=m"(after));
+            if(memcmp(input,before,32)||memcmp(output,want,80)||after!=ambient) {
+                fprintf(stderr,"%s bits=%u sample=%u csr=%x after=%x\n",name,bits,sample,controls[mode],after);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + `
+    unsigned csr=0x1f80;
+    __asm__ volatile("ldmxcsr %0"::"m"(csr));
+    return 0;
+}
+`
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivLiteralNumerical(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	declarations, assembly := x86MulDivLiteralNumericalSource()
+	x86ScalarLiteralGoListing(t, "amd64", assembly)
+	pkg := x86MulDivLiteralPackage(t, "amd64", declarations)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			var ir string
+			var err error
+			switch api {
+			case "text":
+				ir, err = Translate(file, options)
+			case "module":
+				var module llvm.Module
+				module, err = TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+					ir = module.String()
+				}
+			case "GoModule":
+				var translation *GoModuleTranslation
+				translation, err = translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{GOARCH: "amd64", TargetTriple: triple, ResolveSym: resolve})
+				if translation != nil && !translation.Module.IsNil() {
+					defer translation.Module.Dispose()
+					ir = translation.Module.String()
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "muldiv-literal-"+api, triple, ir, x86MulDivLiteralCOracle(), prefix)
+		})
+	}
+	t.Logf("%d original literal forms × 11 independent SSE bit inputs × 8 full MXCSR controls × 3 translation APIs; whole X/Y bytes, CF/OF=1 and canaries", 4*len(x86MulDivLiteralValues))
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivLiteralOriginalGo(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	declarations, assembly := x86MulDivLiteralNumericalSource()
+	var checks strings.Builder
+	for _, opcode := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+		bits := 32
+		if strings.HasSuffix(opcode, "SD") {
+			bits = 64
+		}
+		for _, value := range x86MulDivLiteralValues {
+			literal := value.bits64
+			if bits == 32 {
+				literal = uint64(value.bits32)
+			}
+			fmt.Fprintf(&checks, "    check(t,%s,%d,0x%x,%t)\n", strings.ToLower(opcode)+value.name, bits, literal, strings.HasPrefix(opcode, "DIV"))
+		}
+	}
+	goTest := `package literal
+import("encoding/binary";"math";"testing")
+type literalFn func(*[32]byte,*[80]byte,uint32)
+func check(t *testing.T,fn literalFn,bits int,literal uint64,divide bool) {
+    t.Helper()
+    for _,negative:=range []bool{false,true} {
+        var input [32]byte
+        var output [80]byte
+        for i:=range input {input[i]=byte(i*37+19)}
+        for i:=range output {output[i]=0xa7}
+        var result uint64
+        if bits==32 {
+            left:=float32(4)
+            if negative {left=-left}
+            binary.LittleEndian.PutUint32(input[:4],math.Float32bits(left))
+            right:=math.Float32frombits(uint32(literal))
+            if divide {left/=right}else{left*=right}
+            result=uint64(math.Float32bits(left))
+        }else{
+            left:=float64(4)
+            if negative {left=-left}
+            binary.LittleEndian.PutUint64(input[:8],math.Float64bits(left))
+            right:=math.Float64frombits(literal)
+            if divide {left/=right}else{left*=right}
+            result=math.Float64bits(left)
+        }
+        before:=input
+        fn(&input,&output,0x1f80)
+        if input!=before {t.Fatal("input changed")}
+        for i,got:=range output {
+            if i>=56&&i<60 {continue} // CSR is checked independently by the C SSE oracle.
+            want:=byte(0xa7)
+            if i>=8&&i<24 {want=input[i-8]}
+            if i>=24&&i<56 {want=input[i-24]}
+            if i>=8&&i<8+bits/8 {want=byte(result>>(8*(i-8)))}
+            if i>=24&&i<24+bits/8 {want=byte(result>>(8*(i-24)))}
+            if i==60||i==61 {want=1}
+            if got!=want {t.Fatalf("bits=%d literal=%x byte=%d got=%x want=%x",bits,literal,i,got,want)}
+        }
+    }
+}
+func TestOriginalLiteralNumerical(t *testing.T) {
+` + checks.String() + "}\n"
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module literal\n\ngo 1.20\n", "literal.go": "package literal\n" + declarations,
+		"literal_amd64.s": assembly, "literal_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go original literal numerical: %v\n%s", err, output)
+	}
+	t.Logf("actual Go original %d literal kernels × 2 initialized finite inputs; X/Y aliases, CF/OF=1 and whole output canaries (host execution may be Rosetta)", 4*len(x86MulDivLiteralValues))
+}
diff --git a/amd64_float_mul_div_literal_test.go b/amd64_float_mul_div_literal_test.go
new file mode 100644
index 000000000..75f91dbb3
--- /dev/null
+++ b/amd64_float_mul_div_literal_test.go
@@ -0,0 +1,506 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86MulDivLiteralValues = []x86ScalarLiteralValue{
+	{name: "reduce", text: "0.0625", bits32: 0x3d800000, bits64: 0x3fb0000000000000},
+	{name: "one", text: "1.0", bits32: 0x3f800000, bits64: 0x3ff0000000000000},
+	{name: "plus", text: "+1.0", bits32: 0x3f800000, bits64: 0x3ff0000000000000},
+	{name: "minus", text: "-1.0", bits32: 0xbf800000, bits64: 0xbff0000000000000},
+	{name: "zero", text: "0.0"},
+	{name: "negativeZero", text: "-0.0", bits32: 0x80000000, bits64: 0x8000000000000000},
+	{name: "hex", text: "0x1.4p+0", bits32: 0x3fa00000, bits64: 0x3ff4000000000000},
+	{name: "scientific", text: "6.25e-1", bits32: 0x3f200000, bits64: 0x3fe4000000000000},
+	{name: "parentheses", text: "(1.25)", bits32: 0x3fa00000, bits64: 0x3ff4000000000000},
+	{name: "signedParentheses", text: "(-2.5)", bits32: 0xc0200000, bits64: 0xc004000000000000},
+	{name: "roundEven", text: "1.000000059604644775390625", bits32: 0x3f800000, bits64: 0x3ff0000010000000},
+	{name: "underflow32", text: "1e-50", bits64: 0x358dee7a4ad4b81f},
+	{name: "overflow32", text: "1e40", bits32: 0x7f800000, bits64: 0x483d6329f1c35ca5},
+	{name: "underscore", text: "1_000.0", bits32: 0x447a0000, bits64: 0x408f400000000000},
+	{name: "nestedSign", text: "+(-(+1.25))", bits32: 0xbfa00000, bits64: 0xbff4000000000000},
+	{name: "leadingDot", text: ".5", bits32: 0x3f000000, bits64: 0x3fe0000000000000},
+	{name: "trailingDot", text: "1.", bits32: 0x3f800000, bits64: 0x3ff0000000000000},
+	{name: "exponent", text: "1E+2", bits32: 0x42c80000, bits64: 0x4059000000000000},
+	{name: "hexExponent", text: "0x1p-4", bits32: 0x3d800000, bits64: 0x3fb0000000000000},
+	{name: "doubleNegativeZero", text: "--0.0"},
+	{name: "unaryNegativeZero", text: "-(0.0)", bits32: 0x80000000, bits64: 0x8000000000000000},
+	{name: "negativeUnderflow32", text: "-1e-50", bits32: 0x80000000, bits64: 0xb58dee7a4ad4b81f},
+	{name: "negativeOverflow32", text: "-1e40", bits32: 0xff800000, bits64: 0xc83d6329f1c35ca5},
+}
+
+func TestX86FloatMulDivLiteralMathArchExp(t *testing.T) {
+	x86ScalarLiteralActualGoRewriteSet(t)
+	path := filepath.Join(runtime.GOROOT(), "src/math/exp_amd64.s")
+	original, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := sha256.Sum256(original)
+	row := "MULSD   $0.0625, X0"
+	if bytes.Count(original, []byte(row)) != 2 {
+		t.Fatal("original math.archExp no longer contains both literal reductions")
+	}
+	// The source row is original. The surrounding first-party function has
+	// an explicit initialized scalar parameter/result, not guessed math ABI.
+	source := "TEXT ·Reduce(SB),4,$0-16\nMOVSD input+0(FP),X0\n" + row + "\nMOVSD X0,ret+8(FP)\nRET\n"
+	x86ScalarLiteralGoListing(t, "amd64", source)
+	pkg := x86MulDivLiteralPackage(t, "amd64", "func Reduce(input float64) float64\n")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}); err != nil {
+		t.Fatal(err)
+	}
+	after, err := os.ReadFile(path)
+	if err != nil || sha256.Sum256(after) != before {
+		t.Fatalf("actual original math source changed: %v", err)
+	}
+	t.Logf("original math.archExp source SHA256=%x; both reduction rows retain initialized scalar semantics", before)
+}
+
+func x86MulDivLiteralPackage(t *testing.T, arch, declarations string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "literal.go", "package literal\n"+declarations, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("literal", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "literal", Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func TestX86FloatMulDivLiteralActualGoObjects(t *testing.T) {
+	// This shared oracle authenticates the invoked SDK/assembler and hashes
+	// obj6/asm6/AVX tables before and after these original-source objects.
+	x86ScalarLiteralActualGoRewriteSet(t)
+	for _, name := range []string{"obj6.go", "asm6.go"} {
+		path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86", name)
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if name == "obj6.go" {
+			if err := x86MulDivLiteralRewriteSource(data); err != nil {
+				t.Fatal(err)
+			}
+		} else {
+			for _, op := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+				if !bytes.Contains(data, []byte("{A"+op+", yxm,")) {
+					t.Fatalf("actual Go no longer uses yxm for %s", op)
+				}
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		for _, op := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+			for _, value := range x86MulDivLiteralValues {
+				for _, register := range []int{0, 7, 8, 15} {
+					row := fmt.Sprintf("%s $%s,X%d", op, value.text, register)
+					entry := fmt.Sprintf("TEXT literal%d(SB),4,$0-0\n%s\nRET\n", source.Len(), row)
+					if arch == "386" && register >= 8 {
+						x86ScalarLiteralExpectedGoListing(t, arch, entry, false)
+						continue
+					}
+					source.WriteString(entry)
+				}
+			}
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, value := range x86MulDivLiteralValues {
+			for _, pool := range []struct {
+				name  string
+				bits  uint64
+				width int
+			}{
+				{fmt.Sprintf("$f32.%08x", value.bits32), uint64(value.bits32), 4},
+				{fmt.Sprintf("$f64.%016x", value.bits64), value.bits64, 8},
+			} {
+				if !strings.Contains(listing, pool.name) {
+					t.Fatalf("actual Go pool rounding/sign missing %s", pool.name)
+				}
+				start := strings.Index(listing, pool.name+" SRODATA")
+				if start < 0 {
+					t.Fatalf("actual Go pool has no original DATA payload: %s", pool.name)
+				}
+				var payload []byte
+				for _, line := range strings.Split(listing[start:], "\n")[1:] {
+					data := x86InsertExtractListedBytes(line)
+					if len(data) == 0 {
+						break
+					}
+					payload = append(payload, data...)
+				}
+				var want [8]byte
+				binary.LittleEndian.PutUint64(want[:], pool.bits)
+				if !bytes.Equal(payload, want[:pool.width]) {
+					t.Fatalf("actual original pool %s bytes=%x want=%x", pool.name, payload, want[:pool.width])
+				}
+			}
+		}
+		if strings.Contains(listing, "XORPS") {
+			t.Fatal("arithmetic zero literal incorrectly acquired MOV zero rewrite")
+		}
+	}
+}
+
+func TestX86FloatMulDivLiteralCallerSourceContracts(t *testing.T) {
+	for _, opcode := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+		move, result := "MOVSS", "float32"
+		if strings.HasSuffix(opcode, "SD") {
+			move, result = "MOVSD", "float64"
+		}
+		body := fmt.Sprintf("%s (DI),X15\n%s $0.0625,X15\n%s X15,(DX)", move, opcode, move)
+		for _, target := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			t.Run(opcode+"/"+target, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, strings.ReplaceAll(x86CallerFixtureSource, "float32", result), assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, target); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+		for name, unsafe := range map[string]string{
+			"undefined low bytes":      fmt.Sprintf("%s $1.0,X0\n%s X0,(DX)", opcode, move),
+			"pointer input":            fmt.Sprintf("MOVQ DI,X0\n%s $1.0,X0\n%s X0,(DX)", opcode, move),
+			"private stack bits":       fmt.Sprintf("MOVQ SP,X0\n%s $1.0,X0\n%s X0,(DX)", opcode, move),
+			"read-only input store":    strings.Replace(body, "(DX)", "(DI)", 1),
+			"one-byte result overflow": strings.Replace(body, "(DX)", "1(DX)", 1),
+			"unproved source memory":   strings.Replace(body, "(DI)", "(BX)", 1),
+			"FP pointer contents":      fmt.Sprintf("%s a+0(FP),X0\n%s $1.0,X0\n%s X0,(DX)", move, opcode, move),
+			"join lacks input":         fmt.Sprintf("CMPQ AX,$0\nJE joined\n%s (DI),X15\njoined:\n%s $1.0,X15\n%s X15,(DX)", move, opcode, move),
+		} {
+			t.Run(opcode+"/"+name, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", unsafe, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, strings.ReplaceAll(x86CallerFixtureSource, "float32", result), assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("literal invented source/extent/escape evidence: %v", err)
+				}
+			})
+		}
+	}
+}
+
+// Independently bind the actual encoder's complete scalar pool-rewrite body,
+// not just the presence of an opcode name somewhere in the source file.
+func x86MulDivLiteralRewriteSource(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "obj6.go", source, 0)
+	if err != nil {
+		return err
+	}
+	seen := make(map[string]int)
+	var progedit *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == "progedit" {
+			if progedit != nil || function.Body == nil {
+				return fmt.Errorf("missing or duplicate progedit body")
+			}
+			progedit = function
+		}
+	}
+	if progedit == nil {
+		return fmt.Errorf("actual Go progedit missing")
+	}
+	allowed := make(map[*ast.CaseClause]bool)
+	for _, statement := range progedit.Body.List {
+		switchStatement, ok := statement.(*ast.SwitchStmt)
+		if !ok || switchStatement.Init != nil {
+			continue
+		}
+		selector, ok := switchStatement.Tag.(*ast.SelectorExpr)
+		if !ok || selector.Sel.Name != "As" {
+			continue
+		}
+		base, ok := selector.X.(*ast.Ident)
+		if !ok || base.Name != "p" {
+			continue
+		}
+		for _, entry := range switchStatement.Body.List {
+			if clause, ok := entry.(*ast.CaseClause); ok {
+				allowed[clause] = true
+			}
+		}
+	}
+	var failure error
+	ast.Inspect(progedit.Body, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok {
+			return true
+		}
+		for _, expression := range clause.List {
+			name, ok := expression.(*ast.Ident)
+			if !ok || name.Name != "AMULSS" && name.Name != "AMULSD" && name.Name != "ADIVSS" && name.Name != "ADIVSD" {
+				continue
+			}
+			seen[name.Name]++
+			if !allowed[clause] {
+				failure = fmt.Errorf("nested or conditional literal rewrite %s", name.Name)
+			}
+			bits := 64
+			if strings.HasSuffix(name.Name, "SS") {
+				bits = 32
+			}
+			expected := fmt.Sprintf(`package p
+func f() {
+if p.From.Type == obj.TYPE_FCONST {
+	f%d := %s
+	p.From.Type = obj.TYPE_MEM
+	p.From.Name = obj.NAME_EXTERN
+	p.From.Sym = ctxt.Float%dSym(f%d)
+	p.From.Offset = 0
+}
+}`, bits, map[int]string{32: "float32(p.From.Val.(float64))", 64: "p.From.Val.(float64)"}[bits], bits, bits)
+			fixture, err := parser.ParseFile(token.NewFileSet(), "expected.go", expected, 0)
+			if err != nil {
+				failure = err
+				continue
+			}
+			body, err := x86ScalarLiteralBodySyntax(clause.Body)
+			want, wantErr := x86ScalarLiteralBodySyntax(fixture.Decls[0].(*ast.FuncDecl).Body.List)
+			if err != nil || wantErr != nil || body != want {
+				failure = fmt.Errorf("unrecognized actual Go %s literal rewrite body", name.Name)
+			}
+		}
+		return true
+	})
+	for _, name := range []string{"AMULSS", "AMULSD", "ADIVSS", "ADIVSD"} {
+		if seen[name] != 1 {
+			return fmt.Errorf("actual Go literal rewrite registration %s count=%d", name, seen[name])
+		}
+	}
+	return failure
+}
+
+func TestX86FloatMulDivLiteralRewriteSourceRejectsMutation(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/obj6.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86MulDivLiteralRewriteSource(source); err != nil {
+		t.Fatal(err)
+	}
+	before := sha256.Sum256(source)
+	for _, replacement := range [][2]string{
+		{"func progedit(", "func unrelated("},
+		{"AMULSS,", "AMULPS,"}, {"ADIVSD,", "ADIVPD,"},
+		{"ctxt.Float32Sym(f32)", "ctxt.Float64Sym(f32)"}, {"p.From.Offset = 0", "p.From.Offset = 4"},
+	} {
+		mutated := bytes.ReplaceAll(source, []byte(replacement[0]), []byte(replacement[1]))
+		if bytes.Equal(mutated, source) || x86MulDivLiteralRewriteSource(mutated) == nil {
+			t.Fatalf("unknown source rewrite accepted: %q", replacement)
+		}
+	}
+	after, err := os.ReadFile(path)
+	if err != nil || sha256.Sum256(after) != before {
+		t.Fatalf("source mutation oracle changed the real SDK: %v", err)
+	}
+}
+
+func TestX86FloatMulDivLiteralOriginalInstructionBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			opcode             string
+			prefix, opcodeByte byte
+		}{
+			{"MULSS", 0xf3, 0x59}, {"MULSD", 0xf2, 0x59},
+			{"DIVSS", 0xf3, 0x5e}, {"DIVSD", 0xf2, 0x5e},
+		} {
+			for _, literal := range []string{"0.0", "-0.0", "1.0", "0x1.4p0"} {
+				code := x86PackedFirstGoInstructionBytes(t, arch, row.opcode+" $"+literal+",X0")
+				if !bytes.Equal(code[:4], []byte{row.prefix, 0x0f, row.opcodeByte, 0x05}) {
+					t.Fatalf("%s %s literal %s original bytes=%x", arch, row.opcode, literal, code)
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatMulDivLiteralCallerKeepsDefinedBytes(t *testing.T) {
+	for _, opcode := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+		file, err := Parse(ArchAMD64, "TEXT literal(SB),4,$0-0\n"+opcode+" $-0.0,X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86FloatMulDivProperties(ins, "amd64")
+		if !recognized || err != nil || !form.literal || form.memory != -1 || form.memoryBytes != 0 {
+			t.Fatalf("literal confused with caller memory: %+v / %v", form, err)
+		}
+		low := x86CallerVectorByteMask(int64(form.bits / 8))
+		for _, old := range []uint64{0, low &^ 1, low, low | 0xf0000000, ^uint64(0)} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": old}, masks: map[Reg]bool{}}
+			before, _ := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerFloatBinaryStep(&ins, form.x86FloatBinaryForm, &state, nil)
+			if accepted != (old&low == low) || !accepted && !reflect.DeepEqual(before, state.vectors) || accepted && state.vectors["Z0"] != old {
+				t.Fatalf("%s invented destination/upper knowledge: old=%x state=%x accepted=%t", opcode, old, state.vectors["Z0"], accepted)
+			}
+		}
+		// Source spelling is not permission to use a different typed value.
+		ins.Args[0].Imm++
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		_, _, err = ctx.lowerFloatMulDiv(ins.Op, ins)
+		if err == nil || output.String() != before {
+			t.Fatal("mismatched literal/source bits emitted IR")
+		}
+	}
+}
+
+func TestX86FloatMulDivLiteralThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var declarations, source strings.Builder
+			for _, op := range []string{"MULSS", "MULSD", "DIVSS", "DIVSD"} {
+				for _, value := range x86MulDivLiteralValues {
+					name := strings.ToLower(op) + value.name
+					fmt.Fprintf(&declarations, "func %s()\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\nPXOR X0,X0\n%s $%s,X0\nRET\n", name, op, value.text)
+				}
+			}
+			pkg := x86MulDivLiteralPackage(t, target.arch, declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(sym string) string { return strings.Replace(sym, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					var err error
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(ctx, pkg, []byte(source.String()), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "mul-div-literal.ll", "mul-div-literal.o", ir)
+					x86MulDivLiteralOptimizedObject(t, llc, target.triple, ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86FloatMulDivLiteralRejectsNonGoFormats(t *testing.T) {
+	for _, row := range []string{
+		"MULSD $1,X0", "MULSS $0,X0", "DIVSD $0x3ff0000000000000,X0",
+		"MULSD $(1.0+2.0),X0", "DIVSS $(1.0/2.0),X0", "MULSS $1e999,X0",
+		"MULPS $1.0,X0", "MULPD $1.0,X0", "DIVPS $1.0,X0", "DIVPD $1.0,X0",
+		"VMULSS $1.0,X0,X1", "VMULSD $1.0,X0,X1", "VDIVSS $1.0,X0,X1", "VDIVSD $1.0,X0,X1",
+		"MULSD.Z $1.0,X0", "MULSS $1.0,Y0", "DIVSD $1.0,X16", "MULSD X0,$1.0",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT literal(SB),4,$0-0\n" + row + "\nRET\n"
+			x86ScalarLiteralExpectedGoListing(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerFloatMulDiv(ins.Op, ins)
+			if !known || term || err == nil || before != output.String() {
+				t.Fatalf("non-Go literal emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+}
+
+// Keep this consumer's lifecycle inventory independent of the shared file,
+// which has another writer. The actual original-Go test still uses the same
+// bounded owned command helper as all other native numerical oracles.
+func TestX86FloatMulDivLiteralCommandLifecycle(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_float_mul_div_literal_runtime_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	commands, consumers := 0, 0
+	ast.Inspect(file, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if function, ok := call.Fun.(*ast.Ident); ok && function.Name == "runtimeOracleCombinedOutput" {
+			consumers++
+		}
+		if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+			if owner, ok := method.X.(*ast.Ident); ok && owner.Name == "exec" && method.Sel.Name == "CommandContext" {
+				commands++
+			}
+			switch method.Sel.Name {
+			case "CombinedOutput", "Output", "Start", "Run":
+				if owner, ok := method.X.(*ast.Ident); !ok || owner.Name != "t" {
+					t.Errorf("literal oracle bypasses owned lifecycle: %s", method.Sel.Name)
+				}
+			}
+		}
+		return true
+	})
+	if commands != 2 || consumers != 2 {
+		t.Fatalf("original-Go literal command lifecycle missing: commands=%d consumers=%d", commands, consumers)
+	}
+}
diff --git a/amd64_float_mul_div_mode32_test.go b/amd64_float_mul_div_mode32_test.go
new file mode 100644
index 000000000..a8123ca5e
--- /dev/null
+++ b/amd64_float_mul_div_mode32_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatMulDivMode32HighNamesStayUnlowered(t *testing.T) {
+	for _, opcode := range x86FloatMulDivOpcodes() {
+		if !strings.HasPrefix(opcode, "V") {
+			continue
+		}
+		widths := []string{"X", "Y", "Z"}
+		if strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD") {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			for _, index := range []int{8, 15, 16, 29, 31} {
+				row := fmt.Sprintf("%s %s%d,%s1,%s2", opcode, width, index, width, width)
+				t.Run(row, func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+					goAccepted := width != "Z"
+					goAssemblerOracleOutput(t, "386", source, "", goAccepted)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					context, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					context.goarch = "386"
+					before := output.Len()
+					known, term, err := context.lowerFloatMulDiv(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+					if !known || term || err == nil || goAccepted && !errors.Is(err, ErrProbeNeedsContext) || output.Len() != before {
+						t.Fatalf("mode32 high bank acquired a physical value: %t/%t/%v", known, term, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FloatMulDivMode32KeepsActualMXCSRInstructions(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 llc/llvm-objdump required")
+	}
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, opcode := range x86FloatMulDivOpcodes() {
+		if strings.HasSuffix(opcode, "PS") || strings.HasSuffix(opcode, "PD") {
+			continue
+		}
+		bits, typ := 32, I32
+		load, resultOffset := "MOVSS", 8
+		if strings.HasSuffix(opcode, "SD") {
+			bits, typ, load, resultOffset = 64, I64, "MOVSD", 16
+		}
+		name := strings.ToLower(opcode)
+		row, destination := opcode+" X1,X0", "X0"
+		if strings.HasPrefix(opcode, "V") {
+			row, destination = opcode+" X1,X0,X2", "X2"
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s a+0(FP),X0\n%s b+%d(FP),X1\n%s\n%s %s,result+%d(FP)\nRET\n",
+			name, resultOffset+bits/8, load, load, bits/8, row, load, destination, resultOffset)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{typ, typ}, Ret: typ,
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}, {Offset: int64(bits / 8), Type: typ, Index: 1, Field: -1}},
+				Results: []FrameSlot{{Offset: int64(resultOffset), Type: typ, Field: -1}},
+			}}
+	}
+	goAssemblerOracleOutput(t, "386", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "386", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		dir := t.TempDir()
+		input, object := filepath.Join(dir, "mode32.ll"), filepath.Join(dir, "mode32.o")
+		if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, llc, "-O2", "-mtriple="+triple, "-filetype=obj", input, "-o", object)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("actual mode32 object: %v\n%s", err, output)
+		}
+		ctx, cancel = runtimeOracleStageContext(t)
+		command = exec.CommandContext(ctx, disassembler, "-d", object)
+		output, err = runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("actual mode32 machine instructions: %v\n%s", err, output)
+		}
+		for _, opcode := range []string{"mulss", "mulsd", "divss", "divsd"} {
+			if strings.Count(string(output), "\t"+opcode+"\t") != 2 {
+				t.Fatalf("%s lost %s/MXCSR to another FP environment:\n%s", triple, opcode, output)
+			}
+		}
+		if strings.Contains(string(output), "fmul") || strings.Contains(string(output), "fdiv") {
+			t.Fatalf("mode32 MUL/DIV used x87 instead of source MXCSR:\n%s", output)
+		}
+	}
+}
diff --git a/amd64_float_mul_div_numerical_test.go b/amd64_float_mul_div_numerical_test.go
new file mode 100644
index 000000000..8f042cb27
--- /dev/null
+++ b/amd64_float_mul_div_numerical_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The arithmetic reference is actual independent legacy SSE. No production
+// opcode/rounding helper supplies expected numerical bits or MXCSR flags.
+var x86FloatMulDivSSEOracle = strings.NewReplacer("subss", "divss", "subsd", "divsd", "addss", "mulss", "addsd", "mulsd").Replace(x86FloatAddSubSSEOracle)
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivDefaultPhysicalSemantics(t *testing.T) {
+	testX86FloatMulDivPhysicalSemantics(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivFixedRoundPhysicalSemantics(t *testing.T) {
+	testX86FloatMulDivPhysicalSemantics(t, true)
+}
+
+func testX86FloatMulDivPhysicalSemantics(t *testing.T, fixed bool) {
+	t.Helper()
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, row := range x86FloatMulDivFormats("amd64") {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		form, _, err := x86FloatMulDivProperties(file.Funcs[0].Instrs[1], "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if (form.rounding != "") != fixed {
+			continue
+		}
+		fixedMode := -1
+		for mode, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+			if form.rounding == suffix {
+				fixedMode = mode
+			}
+		}
+		name := fmt.Sprintf("binary%d", count)
+		count++
+		row = strings.Replace(row, "8(AX)", "(BX)", 1)
+		row = strings.Replace(row, "(AX)", "(BX)", 1)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nRET\n", name, row, map[bool]int{true: 1, false: 2}[form.spec.legacy])
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*,uint64_t);\n", name)
+		arithmeticBytes := form.byteWidth
+		if form.spec.scalar {
+			arithmeticBytes = form.spec.bits / 8
+		}
+		opcode := strings.Split(strings.Fields(row)[0], ".")[0]
+		independentDivide := strings.Contains(opcode, "DIV")
+		aligned := form.legacy && !form.scalar && form.memory >= 0
+		fmt.Fprintf(&checks, `
+ for(int round=0;round<4;round++) for(int m=0;m<4;m++) for(int control=0;control<6;control++) for(int ambient=0;ambient<4;ambient++) {
+  uint8_t aStorage[96] __attribute__((aligned(16))),bStorage[68],out[67];uint8_t *a=aStorage+(%[13]d?16:1),*b=bStorage+3;
+  memset(aStorage,0xa7,96);memset(bStorage,0xb9,68);memset(out,0xc3,67);
+  for(int i=0;i<64/%[2]d;i++) { uint64_t av=%[3]d==32?UINT64_C(0x3f000001)+i*0x12345+round*0x10000:UINT64_C(0x3fe0000000000001)+i*0x123456789;
+   uint64_t bv=%[3]d==32?UINT64_C(0xbf800001)+i*0x12345:UINT64_C(0xbff0000000000001)+i*0x2345678;
+   if(round==1){av=%[3]d==32?UINT64_C(0x7fc12345)+i:UINT64_C(0x7ff8123456789abc)+i;bv=%[3]d==32?UINT64_C(0xffc45678)+i:UINT64_C(0xfff8fedcba987654)+i;}
+   if(round==2){av=%[3]d==32?UINT64_C(0x7f812345)+i:UINT64_C(0x7ff0123456789abc)+i;bv=%[3]d==32?UINT64_C(0xff800000):UINT64_C(0xfff0000000000000);}
+   if(round==3){av=1+i;bv=(%[3]d==32?UINT64_C(0x80000000):UINT64_C(0x8000000000000000))|i;}
+   memcpy(a+i*%[2]d,&av,%[2]d);memcpy(b+i*%[2]d,&bv,%[2]d); }
+  unsigned csr=controls[control]|(ambient<<13),observed,expectedFlags=0;
+  __asm__ volatile("ldmxcsr %%0"::"m"(csr));
+  uint64_t mask=masks[m];%[1]s(out+1,a,b,mask);
+  __asm__ volatile("stmxcsr %%0":"=m"(observed));
+  for(int i=0;i<64/%[2]d;i++) {
+   uint64_t av=0,bv=0,got=0;memcpy(&av,a+(%[4]d?0:i*%[2]d),%[2]d);memcpy(&bv,b+i*%[2]d,%[2]d);memcpy(&got,out+1+i*%[2]d,%[2]d);
+   int active=%[5]d<0 || ((mask>>i)&1);
+   unsigned operationCSR=%[12]d<0?csr:((csr&~0x6000u)|((unsigned)%[12]d<<13));
+   uint64_t want=i*%[2]d<%[6]d?(active?sse_result(%[3]d,bv,av,%[7]d,operationCSR):(%[8]d?0:bv)):(%[9]d || (%[10]d && i*%[2]d<16)?bv:0);
+   if(i*%[2]d<%[6]d && active && %[12]d<0)expectedFlags|=last_sse_csr&63;
+   if(got!=want){fprintf(stderr,"%[1]s lane=%%d got=%%llx want=%%llx\n",i,(unsigned long long)got,(unsigned long long)want);return %[11]d;}
+  }
+  if(observed!=(csr|expectedFlags)){fprintf(stderr,"%[1]s sticky observed=%%x expected=%%x\n",observed,csr|expectedFlags);return 3;}
+  if(out[0]!=0xc3 || out[65]!=1 || out[66]!=0xc3 || a[-1]!=0xa7 || a[64]!=0xa7 || bStorage[2]!=0xb9 || bStorage[67]!=0xb9)return 2;
+ }
+`, name, form.spec.bits/8, form.spec.bits, x86FloatAddSubBoolInt(form.broadcast), form.mask, arithmeticBytes, x86FloatAddSubBoolInt(independentDivide), x86FloatAddSubBoolInt(form.zeroing), x86FloatAddSubBoolInt(form.spec.legacy), x86FloatAddSubBoolInt(form.spec.scalar), count+10, fixedMode, x86FloatAddSubBoolInt(aligned))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86FloatMulDivSSEOracle + declarations.String() + "int main(void){const uint64_t masks[]={0,1,0x55aa55aa55aa55aaULL,~0ULL}; const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};\n" + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mul-div-default-semantics", triple, ir, main, prefix)
+	t.Logf("%d independent opcode/width/memory/mask programs x384 IEEE/MXCSR/canary inputs", count)
+}
diff --git a/amd64_float_mul_div_regression_test.go b/amd64_float_mul_div_regression_test.go
new file mode 100644
index 000000000..57df156f8
--- /dev/null
+++ b/amd64_float_mul_div_regression_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFloatMulDivOriginalSourceReachesObjects(t *testing.T) {
+	for _, opcode := range []string{"MULSS", "DIVSS", "VMULSS", "VDIVSS"} {
+		t.Run(opcode, func(t *testing.T) {
+			row := opcode + " X0,X1"
+			if strings.HasPrefix(opcode, "V") {
+				row += ",X2"
+			}
+			destination := "X1"
+			if strings.HasPrefix(opcode, "V") {
+				destination = "X2"
+			}
+			body := "VMOVSS (DI),X0\nVMOVSS (SI),X1\n" + row + "\nVMOVSS " + destination + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivConstantMXCSR(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, opcode := range []string{"MULSS", "DIVSS", "VMULSS", "VDIVSS"} {
+		name := strings.ToLower(opcode)
+		left, right := uint32(0x3f800001), uint32(0x3f800001)
+		if strings.Contains(opcode, "DIV") {
+			left, right = 0x3f800000, 0x40400000
+		}
+		row, destination := opcode+" X1,X0", "X0"
+		if strings.HasPrefix(opcode, "V") {
+			row, destination = opcode+" X1,X0,X2", "X2"
+		}
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-4\nMOVL $0x%x,AX\nMOVD AX,X0\nMOVL $0x%x,AX\nMOVD AX,X1\n%s\nMOVSS %s,ret+0(FP)\nRET\n", name, left, right, row, destination)
+		sigs[name] = FuncSig{Name: name, Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I32, Field: -1}}}}
+		fmt.Fprintf(&declarations, "extern uint32_t %s(void);\n", name)
+		fmt.Fprintf(&checks, "failed|=check(%s,0x%x,0x%x,%d,%q);\n", name, left, right, x86FloatAddSubBoolInt(strings.Contains(opcode, "DIV")), opcode)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const oracle = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef uint32_t(*binary_constant)(void);
+static int check(binary_constant fn,uint32_t left,uint32_t right,int divide,const char *name) {
+ unsigned saved; __asm__ volatile("stmxcsr %0":"=m"(saved));
+ int failed=0;
+ for(unsigned mode=0;mode<4;mode++) {
+  unsigned csr=0x1f80|(mode<<13),wantCSR,gotCSR;
+  float a,b;memcpy(&a,&left,4);memcpy(&b,&right,4);
+  __asm__ volatile("ldmxcsr %0"::"m"(csr));
+  if(divide)__asm__ volatile("divss %1,%0":"+x"(a):"x"(b));
+  else __asm__ volatile("mulss %1,%0":"+x"(a):"x"(b));
+  uint32_t want;memcpy(&want,&a,4);
+  __asm__ volatile("stmxcsr %0":"=m"(wantCSR));
+  __asm__ volatile("ldmxcsr %0"::"m"(csr));
+  uint32_t got=fn();__asm__ volatile("stmxcsr %0":"=m"(gotCSR));
+  if(got!=want||gotCSR!=wantCSR) {
+   fprintf(stderr,"%s RC%u got=%x/%x original-SSE=%x/%x\n",name,mode,got,gotCSR,want,wantCSR);
+   failed=1;
+  }
+ }
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));return failed;
+}
+`
+	main := oracle + declarations.String() + "int main(void){int failed=0;\n" + checks.String() + "return failed;}\n"
+	t.Run("original-ir", func(t *testing.T) {
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "mul-div-constant-mxcsr", triple, ir, main, prefix)
+	})
+	t.Run("optimized-ir", func(t *testing.T) {
+		opt := findLLVM22Tool("opt")
+		if opt == "" {
+			t.Fatal("LLVM22 opt missing")
+		}
+		dir := t.TempDir()
+		input, output := filepath.Join(dir, "source.ll"), filepath.Join(dir, "optimized.ll")
+		if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, opt, "-S", "-passes=default<O2>", input, "-o", output)
+		message, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("LLVM22 O2: %v\n%s", err, message)
+		}
+		optimized, err := os.ReadFile(output)
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "mul-div-constant-mxcsr-o2", triple, string(optimized), main, prefix)
+	})
+}
diff --git a/amd64_float_zero_mask_epoch_test.go b/amd64_float_zero_mask_epoch_test.go
new file mode 100644
index 000000000..144f6120b
--- /dev/null
+++ b/amd64_float_zero_mask_epoch_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The Go encoder tables do not express this helper rule. Go 1.20 could
+// assemble EVEX.z=1/aaa=0; issue 57952 closed that bug in Go 1.21. Those
+// historical objects are observations of invalid bytes, never legal forms.
+func TestX86BinaryFloatZeroingRequiresNonzeroMaskAcrossAssemblerEpochs(t *testing.T) {
+	oldAssembler := !goToolchainAtLeast(runtime.Version(), 1, 21)
+	for _, arch := range []string{"386", "amd64"} {
+		for operation, opcode := range map[string]byte{
+			"ADD": 0x58, "SUB": 0x5c, "MUL": 0x59, "DIV": 0x5e,
+		} {
+			for pp, suffix := range []string{"PS", "PD", "SS", "SD"} {
+				widths := []string{"X", "Y", "Z"}
+				if pp >= 2 {
+					widths = widths[:1]
+				}
+				for width, bank := range widths {
+					name := "V" + operation + suffix
+					row := fmt.Sprintf("%s.Z %s0,%s1,%s2", name, bank, bank, bank)
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+						goAssemblerOracleOutput(t, arch, source, "", oldAssembler)
+
+						// Independent register encoding: source0, source1,
+						// destination2; EVEX.v'=1 and the requested vector length.
+						p1 := byte(0x74 | pp)
+						if pp&1 != 0 {
+							p1 |= 0x80
+						}
+						code := []byte{0x62, 0xf1, p1, 0x88 | byte(width<<5), opcode, 0xd0}
+						if oldAssembler {
+							listing := x86InsertExtractGoListing(t, arch, source)
+							var observed []byte
+							for _, line := range strings.Split(string(listing), "\n") {
+								observed = append(observed, x86InsertExtractListedBytes(line)...)
+							}
+							want := append(append([]byte(nil), code...), 0xc3)
+							if !bytes.Equal(observed, want) {
+								t.Fatalf("historical assembler observation changed: got %x want %x", observed, want)
+							}
+							t.Logf("actual old Go emitted reserved z=1/aaa=0 bytes %x", code)
+						}
+						mode := 64
+						if arch == "386" {
+							mode = 32
+						}
+						if _, _, known, err := decodedX86EVEXBinaryFloatInstruction(code, 0, mode, "", false); !known || err == nil ||
+							!strings.Contains(err.Error(), "zeroing requires a nonzero mask") {
+							t.Fatalf("reserved zeroing acquired raw semantics: known=%t err=%v", known, err)
+						}
+						x86RequireZeroMaskAPIOutcome(t, arch, source, false)
+						x86RequireZeroMaskAPIOutcome(t, arch, x86RawINSERTPSSource("f", code), false)
+
+						explicit := fmt.Sprintf("%s.Z %s0,%s1,K0,%s2", name, bank, bank, bank)
+						goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+explicit+"\nRET\n", "", false)
+						x86RequireZeroMaskAPIOutcome(t, arch, "TEXT f(SB),4,$0-0\n"+explicit+"\nRET\n", false)
+
+						if arch == "amd64" {
+							valid := fmt.Sprintf("%s.Z %s0,%s1,K1,%s2", name, bank, bank, bank)
+							goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+valid+"\nRET\n", "", true)
+							control := append([]byte(nil), code...)
+							control[3] |= 1
+							ins, size, known, err := decodedX86EVEXBinaryFloatInstruction(control, 0, 64, "", false)
+							if !known || err != nil || size != len(control) || ins.Op != Op(name+".Z") ||
+								len(ins.Args) != 4 || ins.Args[2].Reg != "K1" {
+								t.Fatalf("nonzero-mask control rejected: %+v size=%d known=%t err=%v", ins, size, known, err)
+							}
+							x86RequireZeroMaskAPIOutcome(t, arch, "TEXT f(SB),4,$0-0\n"+valid+"\nRET\n", true)
+							x86RequireZeroMaskAPIOutcome(t, arch, x86RawINSERTPSSource("f", control), true)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86RequireZeroMaskAPIOutcome(t *testing.T, arch, source string, wantSuccess bool) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal("fixture must reach the semantic validators", err)
+	}
+	triples := []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+	if arch == "amd64" {
+		triples = []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+	}
+	pkg := x86FloatMulDivShapesPackage(t, "package shapes\nfunc f()\n", arch)
+	for _, triple := range triples {
+		options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}}
+		if ir, err := Translate(file, options); (err == nil) != wantSuccess || err == nil && ir == "" {
+			t.Fatalf("%s text API outcome wantSuccess=%t err=%v", triple, wantSuccess, err)
+		}
+		func() {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := TranslateModuleInContext(context, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if (err == nil) != wantSuccess || err == nil && module.IsNil() {
+				t.Fatalf("%s module API outcome wantSuccess=%t err=%v", triple, wantSuccess, err)
+			}
+			goSource := strings.Replace(source, "TEXT f(SB)", "TEXT ·f(SB)", 1)
+			result, err := translateGoModuleInContext(context, pkg, []byte(goSource),
+				GoModuleOptions{GOARCH: arch, TargetTriple: triple})
+			if result != nil && !result.Module.IsNil() {
+				defer result.Module.Dispose()
+			}
+			if (err == nil) != wantSuccess || err == nil && (result == nil || result.Module.IsNil()) {
+				t.Fatalf("%s Go API outcome wantSuccess=%t err=%v", triple, wantSuccess, err)
+			}
+		}()
+	}
+}
diff --git a/amd64_floating_helper_forms.go b/amd64_floating_helper_forms.go
new file mode 100644
index 000000000..d934e7043
--- /dev/null
+++ b/amd64_floating_helper_forms.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These families share operand and native-effect axes, not floating-point
+// arithmetic. Existing operation registrations remain the mnemonic inventory.
+type x86FloatingHelperSpec struct {
+	bits, bytes                            int
+	scalar, immediate, second              bool
+	readDestination, maskResult, round, dq bool
+	estimate14, estimate28                 bool
+}
+
+func x86FloatingHelperSpecFor(op Op) (x86FloatingHelperSpec, bool) {
+	if spec, known := amd64ApproximateMathSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, estimate28: true}, true
+	}
+	if spec, known := amd64Reciprocal14Specs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, estimate14: true}, true
+	}
+	if spec, known := amd64GetExpSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar}, true
+	}
+	if spec, known := amd64GetMantSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, immediate: true}, true
+	}
+	if spec, known := amd64BinaryFloatingSpecs[op]; known && spec.mode == amd64BinaryFloatingScale {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, second: true, round: true}, true
+	}
+	if spec, known := amd64FloatingRangeSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, immediate: true, second: true, dq: true}, true
+	}
+	if spec, known := amd64FixupImmediateSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, immediate: true, second: true, readDestination: true}, true
+	}
+	if spec, known := amd64ScaledRoundSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, scalar: spec.scalar, immediate: true, dq: spec.mode == amd64Reduce}, true
+	}
+	if spec, known := amd64FPClassSpecs[op]; known {
+		return x86FloatingHelperSpec{bits: spec.laneBits, bytes: spec.bytes, scalar: spec.scalar, immediate: true, maskResult: true, dq: true}, true
+	}
+	return x86FloatingHelperSpec{}, false
+}
+
+type x86FloatingHelperForm struct {
+	spec                                     x86FloatingHelperSpec
+	first, second, destination, mask, memory int
+	byteWidth, memoryBytes                   int
+	immediate                                uint8
+	properties                               amd64BinaryFloatingSuffix
+}
+
+func x86FloatingHelperProperties(ins Instr, arch string) (x86FloatingHelperForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86FloatingHelperSpecFor(Op(base))
+	form := x86FloatingHelperForm{spec: spec, second: -1, mask: -1, memory: -1}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86FloatingHelperForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go floating-helper grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	properties, valid := parseAMD64BinaryFloatingSuffix(suffix)
+	if !valid || dotted && suffix == "" || arch != "386" && arch != "amd64" ||
+		spec.scalar && properties.broadcast || spec.round && properties.sae ||
+		!spec.round && properties.rounding != "" || spec.estimate14 && properties.sae || spec.maskResult && (properties.sae || properties.zeroing) {
+		return fail()
+	}
+	form.properties = properties
+	if spec.immediate {
+		if len(ins.Args) == 0 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" ||
+			ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+			return fail()
+		}
+		form.first, form.immediate = 1, uint8(ins.Args[0].Imm)
+	}
+	operands := form.first + 2
+	if !spec.maskResult && (spec.second || spec.scalar) {
+		form.second = form.first + 1
+		operands++
+	}
+	if len(ins.Args) != operands && len(ins.Args) != operands+1 || arch == "386" && len(ins.Args) > 3 && !ins.x86Encoded {
+		return fail()
+	}
+	form.destination = len(ins.Args) - 1
+	if len(ins.Args) == operands+1 {
+		form.mask = form.destination - 1
+		if !amd64NonzeroKOperand(ins.Args[form.mask]) {
+			return fail()
+		}
+	} else if properties.zeroing {
+		return fail()
+	}
+	destination := ins.Args[form.destination]
+	form.byteWidth = amd64VectorByteWidth(destination.Reg)
+	if spec.maskResult {
+		if !amd64IsKOperand(destination) {
+			return fail()
+		}
+		form.byteWidth = spec.bytes
+	}
+	if form.byteWidth != 16 && form.byteWidth != 32 && form.byteWidth != 64 || spec.scalar && form.byteWidth != 16 ||
+		spec.estimate28 && !spec.scalar && form.byteWidth != 64 ||
+		(properties.sae || properties.rounding != "") && !spec.scalar && form.byteWidth != 64 {
+		return fail()
+	}
+	register := func(operand Operand) bool {
+		return amd64GoPackedVectorMoveRegister(operand, form.byteWidth, arch)
+	}
+	if !spec.maskResult && !register(destination) || form.second >= 0 && !register(ins.Args[form.second]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) {
+		if properties.sae || properties.rounding != "" {
+			return fail()
+		}
+		if first.Kind == OpMem {
+			if x86SymbolIndexedMemoryError(first.Mem, arch) != nil || first.Mem.OffRaw != "" || first.Mem.IndexExt != "" ||
+				first.Mem.Off != int64(int32(first.Mem.Off)) && (arch != "386" || first.Mem.Off != int64(uint32(first.Mem.Off))) ||
+				!x86MemoryRegistersValidForArch(first.Mem, arch) || first.Mem.Index != "" &&
+				(first.Mem.Index == SP || first.Mem.Scale != 1 && first.Mem.Scale != 2 && first.Mem.Scale != 4 && first.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		if first.Kind == OpSym {
+			symbol := strings.TrimSpace(first.Sym)
+			address, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil ||
+				absolute == nil && address != int64(int32(address)) && (arch != "386" || address != int64(uint32(address))) {
+				return fail()
+			}
+		}
+		form.memory, form.memoryBytes = form.first, form.byteWidth
+		if spec.scalar || properties.broadcast {
+			form.memoryBytes = spec.bits / 8
+		}
+	} else if properties.broadcast || !register(first) {
+		return fail()
+	}
+	// Go's named high banks on 386 are pre-encoding syntax, not initialized
+	// physical registers. Check this only after validating the entire grammar.
+	if arch == "386" {
+		for _, operand := range ins.Args {
+			if index, vector := amd64VectorRegisterIndex(operand.Reg, form.byteWidth); operand.Kind == OpReg && vector && index >= 8 {
+				return form, true, fmt.Errorf("%w: %s has no physical mode32 binding for %s", ErrProbeNeedsContext, ins.Op, operand.Reg)
+			}
+		}
+	}
+	return form, true, nil
+}
+
+func (form x86FloatingHelperForm) activeBytes() int {
+	if form.spec.scalar {
+		return form.spec.bits / 8
+	}
+	return form.byteWidth
+}
+
+func (form x86FloatingHelperForm) nativeMnemonic(ins Instr) string {
+	name, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	if form.spec.maskResult && !form.spec.scalar && (form.memory < 0 || form.properties.broadcast) {
+		name = name[:len(name)-1] // Go specializes FPCLASS's source width.
+	}
+	return name
+}
+
+func x86TypedFloatingHelperByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86FloatingHelperProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		err = fmt.Errorf("floating-helper dispatch/source opcode mismatch")
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	firstWidth := int64(form.activeBytes())
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	outputWidth := int64(form.byteWidth)
+	if form.spec.maskResult {
+		outputWidth = 8
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+	}}
+	if form.spec.estimate14 || form.spec.estimate28 {
+		effect.vector.upperWrite = x86TypedVectorUpperZero
+		// Native estimates accept unaligned memory. Their original
+		// masked access/fault behavior still executes in the native helper;
+		// this alignment metadata supplies no private/caller storage authority.
+		effect.vector.memoryAlignment = 1
+	}
+	if form.second >= 0 {
+		// A scalar upper source is copied as bits. Sparse numerical knowledge
+		// is retained separately by the precise result-byte transfer.
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.second, operand: ins.Args[form.second], width: int64(form.byteWidth), read: true,
+		})
+		if (form.spec.estimate14 || form.spec.estimate28) && form.spec.scalar {
+			effect.operands[len(effect.operands)-1].requiredBytes = 0xffff &^ x86CallerVectorByteMask(int64(form.activeBytes()))
+		}
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{
+		index: form.destination, operand: ins.Args[form.destination], width: outputWidth,
+		read: !form.spec.maskResult && (form.spec.readDestination || form.mask >= 0 && !form.properties.zeroing), write: true,
+	})
+	if (form.spec.estimate14 || form.spec.estimate28) && form.spec.scalar && form.mask >= 0 && !form.properties.zeroing {
+		effect.operands[len(effect.operands)-1].requiredBytes = x86CallerVectorByteMask(int64(form.activeBytes()))
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.mask, operand: ins.Args[form.mask], width: 8, read: true,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_floating_helper_go_rows_test.go b/amd64_floating_helper_go_rows_test.go
new file mode 100644
index 000000000..60981c7fd
--- /dev/null
+++ b/amd64_floating_helper_go_rows_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86FloatingHelperCompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	members := make(map[string]x86FloatingHelperOracleMember)
+	for _, member := range x86FloatingHelperOracleMembers() {
+		members[member.name] = member
+	}
+	counts := make(map[string]int)
+	for _, rule := range rules {
+		member, wanted := members[rule.Opcode]
+		if !wanted {
+			continue
+		}
+		ordinal := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		widths := []int{512, 128, 256}
+		if member.scalar {
+			widths = []int{128}
+		} else if member.maskResult {
+			widths = []int{map[string]int{"X": 128, "Y": 256, "Z": 512}[member.bank]}
+		}
+		if ordinal >= len(widths)*2 {
+			t.Fatal("unexpected extra floating-helper Go row", rule)
+		}
+		bits, word := 32, "0"
+		if strings.Contains(member.name, "PD") || strings.HasSuffix(member.name, "SD") {
+			bits, word = 64, "1"
+		}
+		family, opcode, opcodeScalar, encodingMap := "", "", "", "evex0F3A"
+		switch {
+		case strings.HasPrefix(member.name, "VGETEXP"):
+			family, opcode, opcodeScalar, encodingMap = "_yvcvtpd2qq", "0x42", "0x43", "evex0F38"
+		case strings.HasPrefix(member.name, "VGETMANT"):
+			family, opcode, opcodeScalar = "_yvgetmantpd", "0x26", "0x27"
+		case strings.HasPrefix(member.name, "VSCALEF"):
+			family, opcode, opcodeScalar, encodingMap = "_yvscalefpd", "0x2C", "0x2D", "evex0F38"
+		case strings.HasPrefix(member.name, "VRANGE"):
+			family, opcode, opcodeScalar = "_yvfixupimmpd", "0x50", "0x51"
+		case strings.HasPrefix(member.name, "VFIXUPIMM"):
+			family, opcode, opcodeScalar = "_yvfixupimmpd", "0x54", "0x55"
+		case strings.HasPrefix(member.name, "VRNDSCALE"):
+			family, opcode, opcodeScalar = "_yvgetmantpd", "0x08", "0x0A"
+			if bits == 64 {
+				opcode, opcodeScalar = "0x09", "0x0B"
+			}
+		case strings.HasPrefix(member.name, "VREDUCE"):
+			family, opcode, opcodeScalar = "_yvgetmantpd", "0x56", "0x57"
+		case member.maskResult:
+			family = "_yvfpclasspd" + strings.ToLower(member.bank)
+			opcode, opcodeScalar = "0x66", "0x67"
+		}
+		if member.scalar {
+			family, opcode = "_yvgetexpsd", opcodeScalar
+			if member.immediate {
+				family = "_yvfixupimmsd"
+			}
+			if member.maskResult {
+				family = "_yvfpclasspdx"
+			}
+		}
+		var bytes []string
+		for _, width := range widths {
+			tuple := width / 8
+			if member.scalar {
+				tuple = bits / 8
+			}
+			attributes := fmt.Sprintf("evexN%d", tuple)
+			if !member.scalar {
+				attributes += fmt.Sprintf(" | evexBcstN%d", bits/8)
+			}
+			if !member.maskResult {
+				if width == 512 || member.scalar {
+					control := "evexSaeEnabled"
+					if strings.HasPrefix(member.name, "VSCALEF") {
+						control = "evexRoundingEnabled"
+					}
+					attributes += " | " + control
+				}
+				attributes += " | evexZeroingEnabled"
+			}
+			bytes = append(bytes, fmt.Sprintf("avxEscape | evex%d | evex66 | %s | evexW%s", width, encodingMap, word), attributes, opcode)
+		}
+		width := widths[ordinal/2]
+		memory, vector := "YxmEvex", "YxrEvex"
+		if width == 256 {
+			memory, vector = "YymEvex", "YyrEvex"
+		} else if width == 512 {
+			memory, vector = "Yzm", "Yzr"
+		}
+		var classes []string
+		zcase := "Zevex_"
+		if member.immediate {
+			classes = append(classes, "Yu8")
+			zcase += "i_"
+		}
+		classes = append(classes, memory)
+		zcase += "rm_"
+		if !member.maskResult && (member.second || member.scalar) {
+			classes = append(classes, vector)
+			zcase += "v_"
+		} else if !member.immediate && ordinal%2 == 0 {
+			zcase += "v_"
+		}
+		offset := 0
+		if ordinal%2 != 0 {
+			classes = append(classes, "Yknot0")
+			zcase += "k_"
+			offset = 3
+		}
+		zcase += "r"
+		destination := vector
+		if member.maskResult {
+			destination = "Yk"
+		}
+		classes = append(classes, destination)
+		if rule.RowIndex != ordinal || rule.Ytab != family || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != offset || rule.EncodingOffset != ordinal/2*3 ||
+			!reflect.DeepEqual(rule.Classes, classes) || !reflect.DeepEqual(rule.OpBytes, bytes) {
+			t.Fatal("complete independent floating-helper Go row/attribute changed", rule,
+				"want", family, zcase, classes, bytes)
+		}
+	}
+	for name, member := range members {
+		want := 6
+		if member.scalar || member.maskResult {
+			want = 2
+		}
+		if counts[name] != want {
+			t.Fatal("floating-helper family row denominator changed", name, counts[name], want)
+		}
+	}
+}
diff --git a/amd64_floating_helper_native.go b/amd64_floating_helper_native.go
new file mode 100644
index 000000000..61109bc2a
--- /dev/null
+++ b/amd64_floating_helper_native.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// One complete native instruction preserves packed exception priority, ambient
+// MXCSR, immediate exception controls, masked access and dead-result effects.
+// A software value formula is not a replacement for any of those obligations.
+func (c *amd64Ctx) lowerNativeFloatingHelper(op Op, ins Instr) (bool, bool, error) {
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("floating-helper dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86FloatingHelperProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return true, false, c.emitNativeFloatingHelper(ins, form)
+}
+
+func (c *amd64Ctx) emitNativeFloatingHelper(ins Instr, form x86FloatingHelperForm) error {
+	first := ins.Args[form.first]
+	if ins.x86AddressBits != 0 || first.Kind == OpFP && !form.spec.scalar || first.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, form.first) && !c.fixedLocalMemoryCertified(ins, form.first) {
+		return fmt.Errorf("%w: %s needs its original native source backing", ErrProbeNeedsContext, ins.Op)
+	}
+	if form.spec.maskResult {
+		return c.emitNativeFloatingClass(ins, form)
+	}
+	typ := amd64FloatingVectorType(form.byteWidth*8/form.spec.bits, form.spec.bits)
+	load := func(index int) (string, error) {
+		bytes, err := c.loadPackedCompareBytes(ins.Args[index], form.byteWidth)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, form.byteWidth, bytes, typ)
+		return "%" + value, nil
+	}
+	old := "zeroinitializer"
+	if form.spec.readDestination || form.mask >= 0 && !form.properties.zeroing {
+		var err error
+		old, err = load(form.destination)
+		if err != nil {
+			return err
+		}
+	}
+	mask := ""
+	if form.mask >= 0 {
+		var err error
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+	}
+	input, inputType, inputConstraint, inputTemplate, err := c.nativeFloatingCompareSource(first,
+		x86FloatCompareForm{x86FloatBinaryForm: x86FloatBinaryForm{
+			bits: form.spec.bits, byteWidth: form.byteWidth, memoryBytes: form.memoryBytes, scalar: form.spec.scalar,
+		}}, typ, mask)
+	if err != nil {
+		return err
+	}
+	// Source helper's $1 refers to its own first explicit argument. Here
+	// operand one is the tied old destination, and the source is operand two.
+	inputTemplate = strings.ReplaceAll(inputTemplate, "$1", "$2")
+	args := fmt.Sprintf("%s %s, %s %s", typ, old, inputType, input)
+	constraints := "=v,0," + inputConstraint
+	operands := inputTemplate
+	maskOrdinal := 3
+	if form.second >= 0 {
+		second, err := load(form.second)
+		if err != nil {
+			return err
+		}
+		args += ", " + typ + " " + second
+		constraints += ",v"
+		operands += ", $3"
+		maskOrdinal++
+	}
+	if form.properties.broadcast {
+		operands = strings.Replace(operands, inputTemplate,
+			inputTemplate+fmt.Sprintf(" {1to%d}", form.byteWidth*8/form.spec.bits), 1)
+	}
+	assembly := "{evex} " + form.nativeMnemonic(ins) + " "
+	if form.spec.immediate {
+		assembly += fmt.Sprintf("$$%d, ", form.immediate)
+	}
+	if form.properties.sae {
+		assembly += "{sae}, "
+	} else if form.properties.rounding != "" {
+		assembly += "{" + strings.ToLower(strings.TrimSuffix(form.properties.rounding, "_SAE")) + "-sae}, "
+	}
+	assembly += operands + ", $0"
+	if form.mask >= 0 {
+		assembly = fmt.Sprintf("kmovw ${%d:k}, %%k1; ", maskOrdinal) + assembly + " {%k1}"
+		if form.properties.zeroing {
+			assembly += " {z}"
+		}
+		constraints += ",r,~{k1}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly,
+		constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, form.byteWidth)
+	return c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+bytes)
+}
+
+func (c *amd64Ctx) emitNativeFloatingClass(ins Instr, form x86FloatingHelperForm) error {
+	typ := amd64FloatingVectorType(form.byteWidth*8/form.spec.bits, form.spec.bits)
+	mask := ""
+	if form.mask >= 0 {
+		var err error
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+	}
+	input, inputType, inputConstraint, inputTemplate, err := c.nativeFloatingCompareSource(ins.Args[form.first],
+		x86FloatCompareForm{x86FloatBinaryForm: x86FloatBinaryForm{
+			bits: form.spec.bits, byteWidth: form.byteWidth, memoryBytes: form.memoryBytes, scalar: form.spec.scalar,
+		}}, typ, mask)
+	if err != nil {
+		return err
+	}
+	if form.properties.broadcast {
+		inputTemplate += fmt.Sprintf(" {1to%d}", form.byteWidth*8/form.spec.bits)
+	}
+	args := inputType + " " + input
+	constraints := "=r," + inputConstraint
+	assembly := fmt.Sprintf("{evex} %s $$%d, %s, %%k1", form.nativeMnemonic(ins), form.immediate, inputTemplate)
+	if form.mask >= 0 {
+		assembly = "kmovw ${2:k}, %k2; " + assembly + " {%k2}"
+		constraints += ",r,~{k2}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	assembly += "; kmovw %k1, ${0:k}"
+	result, wide := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q(%s)\n", result, assembly,
+		constraints+",~{k1},~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+	return c.storeK(ins.Args[form.destination].Reg, "%"+wide)
+}
diff --git a/amd64_floating_helper_native_test.go b/amd64_floating_helper_native_test.go
new file mode 100644
index 000000000..2c226c046
--- /dev/null
+++ b/amd64_floating_helper_native_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This is an independent inventory, not an iteration over the implementation
+// registration. FPCLASS's X/Y/Z opcode spellings differ from LLVM's mnemonic.
+type x86FloatingHelperOracleMember struct {
+	name, mnemonic string
+	immediate      bool
+	second         bool
+	scalar         bool
+	maskResult     bool
+	bank           string
+}
+
+func TestX86FloatingHelperInitializedFiveTargetThreeAPIObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, member := range x86FloatingHelperOracleMembers() {
+				instruction := x86FloatingHelperOracleInstruction(member, false)
+				ins := x86ScalarLaneInstruction(t, instruction)
+				if target.arch == "386" && len(ins.Args) > 3 {
+					continue
+				}
+				name := fmt.Sprintf("F%d", count)
+				count++
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\n", name, instruction)
+				if member.maskResult {
+					source.WriteString("KMOVD K2,AX\n")
+				} else {
+					source.WriteString("PEXTRD $0,X2,AX\n")
+				}
+				source.WriteString("MOVL AX,ret+0(FP)\nRET\n")
+				fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+			}
+			want := 36
+			if target.arch == "386" {
+				want = 22
+			}
+			if count != want {
+				t.Fatal("initialized named family omitted an applicable member", target, count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized floating family failed public translation", api, err)
+				}
+				if got := strings.Count(ir, "asm sideeffect"); got != count {
+					t.Fatal("public translation lost original floating instructions", api, got, count)
+				}
+				compileLLVMToObject(t, llc, target.triple, api+"-helpers.ll", api+"-helpers.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86FloatingHelperVoidAndUnusedBoolCannotSupplyInputs(t *testing.T) {
+	for _, member := range x86FloatingHelperOracleMembers() {
+		instruction := x86FloatingHelperOracleInstruction(member, false)
+		for _, unusedBool := range []bool{false, true} {
+			declaration, extent := "func Missing()", 0
+			if unusedBool {
+				declaration, extent = "func Missing(unused bool)", 1
+			}
+			source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s\nRET\n", extent, instruction)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if unusedBool {
+					x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					continue
+				}
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("empty Void invented missing floating inputs", member.name, unusedBool, api, err)
+				}
+			}
+		}
+	}
+}
+
+func x86FloatingHelperOracleMembers() []x86FloatingHelperOracleMember {
+	var members []x86FloatingHelperOracleMember
+	for _, family := range []struct {
+		name      string
+		immediate bool
+		second    bool
+	}{
+		{"VGETEXP", false, false},
+		{"VGETMANT", true, false},
+		{"VSCALEF", false, true},
+		{"VRANGE", true, true},
+		{"VFIXUPIMM", true, true},
+		{"VRNDSCALE", true, false},
+		{"VREDUCE", true, false},
+	} {
+		for _, suffix := range []string{"PS", "PD", "SS", "SD"} {
+			members = append(members, x86FloatingHelperOracleMember{
+				name: family.name + suffix, mnemonic: strings.ToLower(family.name + suffix),
+				immediate: family.immediate, second: family.second,
+				scalar: suffix == "SS" || suffix == "SD", bank: "X",
+			})
+		}
+	}
+	for _, precision := range []string{"PS", "PD"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			members = append(members, x86FloatingHelperOracleMember{
+				name: "VFPCLASS" + precision + bank, mnemonic: "vfpclass" + strings.ToLower(precision),
+				immediate: true, maskResult: true, bank: bank,
+			})
+		}
+	}
+	for _, precision := range []string{"SS", "SD"} {
+		members = append(members, x86FloatingHelperOracleMember{
+			name: "VFPCLASS" + precision, mnemonic: "vfpclass" + strings.ToLower(precision),
+			immediate: true, scalar: true, maskResult: true, bank: "X",
+		})
+	}
+	return members
+}
+
+// Retain the entire original Go source and its public Context classification.
+// An unbound high-bank mode32 source cannot supply a physical LLVM object;
+// independent initialized low-bank sources own that separate positive axis.
+func x86FloatingHelperOriginalFormatObject(t *testing.T, source, name, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	if arch == "386" {
+		for _, function := range file.Funcs {
+			for _, ins := range function.Instrs {
+				if x86Mode32VectorRegisterContext(ins, arch) != nil {
+					t.Log("complete original Go object and public Context retained; named high vector bank has no physical mode32 binding")
+					return ""
+				}
+			}
+		}
+	}
+	return x86ScalarFormatObjectUnit(t, file, signatures, arch, triple, 0)
+}
+
+func x86FloatingHelperOracleInstruction(member x86FloatingHelperOracleMember, memory bool) string {
+	var args []string
+	if member.immediate {
+		args = append(args, "$255")
+	}
+	source := member.bank + "0"
+	if memory {
+		source = "8(AX)"
+	}
+	args = append(args, source)
+	if !member.maskResult && (member.second || member.scalar) {
+		args = append(args, member.bank+"1")
+	}
+	destination := member.bank + "2"
+	if member.maskResult {
+		destination = "K2"
+	}
+	return member.name + " " + strings.Join(append(args, destination), ",")
+}
+
+func TestX86FloatingHelperCompleteNativeOpcodes(t *testing.T) {
+	members := x86FloatingHelperOracleMembers()
+	if len(members) != 36 {
+		t.Fatal("independent floating-helper family denominator changed", len(members))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			signatures := make(map[string]FuncSig)
+			var expected []string
+			for _, member := range members {
+				// Go's named mode32 frontend has no four-operand forms. Its
+				// physical encodings are a separate decoder test obligation.
+				if target.arch == "386" && (member.immediate && (member.second || member.scalar) && !member.maskResult) {
+					continue
+				}
+				for _, memory := range []bool{false, true} {
+					name := fmt.Sprintf("F%d", len(signatures))
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name,
+						x86FloatingHelperOracleInstruction(member, memory))
+					signatures[name] = FuncSig{Name: name, Ret: Void}
+					mnemonic := member.mnemonic
+					if memory && member.maskResult && !member.scalar {
+						mnemonic += strings.ToLower(member.bank)
+					}
+					expected = append(expected, mnemonic)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			// These deliberately unbound original formats own only emitter
+			// objects. They do not claim typed inputs or a public translation.
+			ir := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+			if got := strings.Count(ir, "asm sideeffect"); got != len(expected) {
+				t.Fatalf("floating helpers lost original native MXCSR/exception/access effects: %d native instructions, want %d", got, len(expected))
+			}
+			for ordinal, mnemonic := range expected {
+				start := strings.Index(ir, fmt.Sprintf("@InstructionFormat%d(", ordinal))
+				if start < 0 {
+					t.Fatal("missing original format function", ordinal)
+				}
+				body, _, _ := strings.Cut(ir[start:], "\n}")
+				if !strings.Contains(body, mnemonic+" ") || !strings.Contains(body, "~{fpsr}") ||
+					!strings.Contains(body, "~{memory}") {
+					t.Fatal("native source opcode or observable clobbers lost", ordinal, mnemonic)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "floating-helper-native.ll", "floating-helper-native.o", ir)
+		})
+	}
+}
diff --git a/amd64_floating_helper_runtime_policy_test.go b/amd64_floating_helper_runtime_policy_test.go
new file mode 100644
index 000000000..a7f89e4de
--- /dev/null
+++ b/amd64_floating_helper_runtime_policy_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Bind the existing complete assembly builders and independent C references.
+// A transport repair must not replace them with a smaller passing program.
+var x86FloatingHelperOriginalRuntimeOwners = []struct {
+	root, file, sourceSHA, cSHA string
+}{
+	{
+		root: "TestAMD64GetExpRuntimeSemantics", file: "amd64_lower_getexp_test.go",
+		sourceSHA: "e984e60362c11b28189a43d2e24efc2a25d9ef7df5d7ba750632dffc2ada582c",
+		cSHA:      "755b471dca11961ef94e8103f354d27b1b737d265886465f6cca9ce18a953f88",
+	},
+	{
+		root: "TestAMD64GetMantRuntimeSemantics", file: "amd64_lower_getmant_test.go",
+		sourceSHA: "631e669e6d8ff1c65192ad74a54f7d5ba3bc847e3b0c64dac64d94f44c1dcbbe",
+		cSHA:      "c9bf0ab8f11e0317569d87c4ec72a9815afddcdf599c6b05195f4ecd9f94a19e",
+	},
+	{
+		root: "TestAMD64ScaleFRuntimeSemantics", file: "amd64_lower_scalef_test.go",
+		sourceSHA: "9e0547ef11ff18488d9f093641beff6f2f88405e6c6aa8884d7b79bde75307ab",
+		cSHA:      "3cec89474463e1884cc2979aea89520dd011589ab73d3c6051bfebc61bcc31c9",
+	},
+	{
+		root: "TestAMD64FloatingRangeRuntimeSemantics", file: "amd64_lower_range_test.go",
+		sourceSHA: "5ec0b3b10d651607d57d18991cb9dd1d91aeea18c6bbbaaa540c0c2970370cbb",
+		cSHA:      "f8b2c3f77cb8f4c6902308df47a1a832c3d03a981471ffe44a837c93b457b359",
+	},
+	{
+		root: "TestAMD64FloatingRangeDoubleAndScalarRuntimeSemantics", file: "amd64_lower_range_test.go",
+		sourceSHA: "a5fac93bf84e828725448f9d6fdef423baf0ac0f1e1bdc7ce30537bbeb4f4377",
+		cSHA:      "5dfe99148f760b1df90c2633526437cf02e932f2f98068d6fdb15eb6cee67409",
+	},
+	{
+		root: "TestAMD64FixupImmediateRuntimeSemantics", file: "amd64_lower_fixupimm_test.go",
+		sourceSHA: "6ba976350729649f866150d52bc624bc5e5628524295d544c3d5df2bbe79b3fd",
+		cSHA:      "147083a3eb84d95f929c67ac71d7ef42932b2bbdc4c8d5b2d3eee81ed7ac5a27",
+	},
+	{
+		root: "TestAMD64ScaledRoundRuntimeSemantics", file: "amd64_lower_scaled_round_test.go",
+		sourceSHA: "c53a42b278d22ca13a3144f75dd58be991b8971ab70754f4bcffbbe952f2c413",
+		cSHA:      "090f1b1990362807062dfe8709bd4094cfad1fcb2b6b9470ea0c56e516429db9",
+	},
+	{
+		root: "TestAMD64FPClassRuntimeSemantics", file: "amd64_lower_fpclass_test.go",
+		sourceSHA: "754b23dc03e28506f8036180859683c6a07f49355752f846d8f5afcb56e4f078",
+		cSHA:      "92e86c32eddff2266c607b5ca64b9616e86c46be09e1a9ca2948d1e51306bff8",
+	},
+}
+
+func TestX86FloatingHelperRuntimeNativeOwnerAndPipelinePolicy(t *testing.T) {
+	if len(x86FloatingHelperOriginalRuntimeOwners) != 8 {
+		t.Fatal("complete original runtime owner inventory changed")
+	}
+	for _, owner := range x86FloatingHelperOriginalRuntimeOwners {
+		t.Run(owner.root, func(t *testing.T) {
+			data, err := os.ReadFile(owner.file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			positions := token.NewFileSet()
+			file, err := parser.ParseFile(positions, owner.file, data, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := x86OriginalFloatingPolicyFunction(t, file, owner.root)
+			if function == nil || function.Body == nil {
+				t.Fatal("missing original runtime owner")
+			}
+			start, end := token.NoPos, token.NoPos
+			cSource := ""
+			calls := make(map[string]int)
+			for _, statement := range function.Body.List {
+				ast.Inspect(statement, func(node ast.Node) bool {
+					if identifier, ok := node.(*ast.Ident); ok && identifier.Name == "source" && start == token.NoPos {
+						start = statement.Pos()
+					}
+					if call, ok := node.(*ast.CallExpr); ok {
+						if identifier, ok := call.Fun.(*ast.Ident); ok {
+							calls[identifier.Name]++
+							if identifier.Name == "requireX86GoAssemblerResult" && end == token.NoPos {
+								end = statement.Pos()
+							}
+						}
+					}
+					if specification, ok := node.(*ast.ValueSpec); ok && len(specification.Names) == 1 &&
+						specification.Names[0].Name == "mainC" && len(specification.Values) == 1 {
+						if literal, ok := specification.Values[0].(*ast.BasicLit); ok && literal.Kind == token.STRING {
+							cSource, err = strconv.Unquote(literal.Value)
+						}
+					}
+					return true
+				})
+			}
+			if start == token.NoPos || end <= start || cSource == "" || err != nil {
+				t.Fatal("original complete source/reference boundaries lost", err)
+			}
+			assemblyBuilder := strings.TrimSpace(string(data[positions.Position(start).Offset:positions.Position(end).Offset]))
+			if actual := fmt.Sprintf("%x", sha256.Sum256([]byte(assemblyBuilder))); actual != owner.sourceSHA {
+				t.Fatal("original complete assembly source builder changed", actual, owner.sourceSHA)
+			}
+			if actual := fmt.Sprintf("%x", sha256.Sum256([]byte(cSource))); actual != owner.cSHA {
+				t.Fatal("independent original C values/reference changed", actual, owner.cSHA)
+			}
+			if calls["x86FloatingHelperRuntimeTools"] != 1 || calls["x86FloatingHelperRunNativePipelines"] != 1 ||
+				calls["rosettaAvailable"] != 0 || calls["compileAndRunRuntimeTestForTarget"] != 0 {
+				t.Fatal("original runtime must use its required native EVEX/DQ owner and all three execution pipelines", calls)
+			}
+		})
+	}
+}
+
+func TestX86FloatingHelperRuntimeNativeDriverPolicy(t *testing.T) {
+	data, err := os.ReadFile("amd64_floating_helper_runtime_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	positions := token.NewFileSet()
+	file, err := parser.ParseFile(positions, "amd64_floating_helper_runtime_test.go", data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			functions[function.Name.Name] = function
+		}
+	}
+	tools := functions["x86FloatingHelperRuntimeTools"]
+	pipelines := functions["x86FloatingHelperRunNativePipelines"]
+	if tools == nil || pipelines == nil {
+		t.Fatal("required native tools or complete pipeline driver missing")
+	}
+	calls := func(function *ast.FuncDecl) map[string]int {
+		result := make(map[string]int)
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				switch target := call.Fun.(type) {
+				case *ast.Ident:
+					result[target.Name]++
+				case *ast.SelectorExpr:
+					result[target.Sel.Name]++
+				}
+			}
+			return true
+		})
+		return result
+	}
+	toolsCalls, pipelineCalls := calls(tools), calls(pipelines)
+	if toolsCalls["x86FloatCompareRuntimeTools"] != 1 || toolsCalls["compileC"] != 1 || toolsCalls["run"] != 1 ||
+		toolsCalls["Skip"] != 1 || pipelineCalls["compileAndRunLLVM"] != 1 ||
+		pipelineCalls["x86DwordProductIROptimize"] != 1 || pipelineCalls["Run"] != 1 || pipelineCalls["Skip"] != 0 {
+		t.Fatal("native preflight or actual compiler/run obligations changed", toolsCalls, pipelineCalls)
+	}
+	if len(tools.Body.List) < 3 {
+		t.Fatal("native host and EVEX checks missing")
+	}
+	host, ok := tools.Body.List[1].(*ast.IfStmt)
+	if !ok {
+		t.Fatal("native host exclusion is not an explicit platform boundary")
+	}
+	condition := string(data[positions.Position(host.Cond.Pos()).Offset:positions.Position(host.Cond.End()).Offset])
+	if condition != `runtime.GOOS != "linux" || runtime.GOARCH != "amd64"` {
+		t.Fatal("native platform exclusion became a CPU/tool skip", condition)
+	}
+	var actual []string
+	ast.Inspect(pipelines.Body, func(node ast.Node) bool {
+		loop, ok := node.(*ast.RangeStmt)
+		if !ok {
+			return true
+		}
+		rows, ok := loop.X.(*ast.CompositeLit)
+		if !ok {
+			t.Fatal("native execution pipelines lost their complete explicit inventory")
+		}
+		for _, element := range rows.Elts {
+			row, ok := element.(*ast.CompositeLit)
+			if !ok {
+				t.Fatal("native pipeline row is not a complete fixture")
+			}
+			values := make(map[string]string)
+			for _, field := range row.Elts {
+				pair, ok := field.(*ast.KeyValueExpr)
+				if !ok {
+					t.Fatal("native pipeline lacks explicit axes")
+				}
+				key, ok := pair.Key.(*ast.Ident)
+				if !ok {
+					t.Fatal("native pipeline key is not bound")
+				}
+				values[key.Name] = string(data[positions.Position(pair.Value.Pos()).Offset:positions.Position(pair.Value.End()).Offset])
+			}
+			actual = append(actual, values["name"]+"/"+values["backend"]+"/"+values["optimizeIR"])
+		}
+		return true
+	})
+	want := []string{`"backend_O0"/"-O0"/`, `"backend_O2"/"-O2"/`, `"IR_O2/backend_O2"/"-O2"/true`}
+	if strings.Join(actual, "\n") != strings.Join(want, "\n") {
+		t.Fatal("native execution narrowed or changed backend/IR optimization axes", actual)
+	}
+	for _, required := range []string{
+		`x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)`,
+		`if (!f || !dq || !vl || !osxsave || (xcr0&0xe6)!=0xe6) return 1;`,
+		`if (!original_dq()) return 2;`,
+		`vfpclassps $2,%%zmm0,%%k1;`,
+		`vfpclassps $2,%%xmm0,%%k1;`,
+		`vfpclasssd $2,%%xmm0,%%k1;`,
+	} {
+		if !strings.Contains(string(data), required) {
+			t.Fatal("native CPU, original opcode or OS state obligation missing", required)
+		}
+	}
+}
diff --git a/amd64_floating_helper_runtime_test.go b/amd64_floating_helper_runtime_test.go
new file mode 100644
index 000000000..05a120990
--- /dev/null
+++ b/amd64_floating_helper_runtime_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func x86FloatingHelperRuntimeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Skip("required native Linux/amd64 floating-helper execution counterpart; objects remain tested on every target")
+	}
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	// The shared EVEX owner already checks actual F/VL, OSXSAVE, XCR0,
+	// original opcodes and native argv transport. RANGE/REDUCE/FPCLASS also
+	// require DQ; neither an old receipt nor the host model name supplies it.
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "dq.c"), filepath.Join(directory, "dq")
+	if err := os.WriteFile(source, []byte(x86FloatingHelperDQPreflightC), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("actual native floating-helper DQ/original-opcode preflight: %s", execution.run(t, executable))
+	return execution
+}
+
+const x86FloatingHelperDQPreflightC = `#include <stdint.h>
+#include <stdio.h>
+#include <cpuid.h>
+
+__attribute__((target("avx512f,avx512dq,avx512vl")))
+static int original_dq(void) {
+    unsigned packed, narrow, scalar;
+    __asm__ volatile("vpxord %%zmm0,%%zmm0,%%zmm0; "
+                     "vfpclassps $2,%%zmm0,%%k1; kmovw %%k1,%0; "
+                     "vfpclassps $2,%%xmm0,%%k1; kmovw %%k1,%1; "
+                     "vfpclasssd $2,%%xmm0,%%k1; kmovw %%k1,%2"
+                     : "=r"(packed),"=r"(narrow),"=r"(scalar)
+                     :: "zmm0","k1","memory");
+    return packed==0xffff && narrow==0xf && scalar==1;
+}
+
+int main(void) {
+    unsigned a,b,c,d,f=0,dq=0,vl=0,osxsave=0;
+    uint64_t xcr0=0;
+    if (__get_cpuid(1,&a,&b,&c,&d)) {
+        osxsave=(c>>27)&1;
+        if (osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) {
+        f=(b>>16)&1; dq=(b>>17)&1; vl=(b>>31)&1;
+    }
+    printf("AVX512F=%u AVX512DQ=%u AVX512VL=%u OSXSAVE=%u XCR0=%llx\n",
+           f,dq,vl,osxsave,(unsigned long long)xcr0);
+    fflush(stdout);
+    if (!f || !dq || !vl || !osxsave || (xcr0&0xe6)!=0xe6) return 1;
+    if (!original_dq()) return 2;
+    puts("FLOATING_HELPER_NATIVE_DQ_OK");
+    return 0;
+}
+`
+
+func x86FloatingHelperRunNativePipelines(t *testing.T, execution x86FloatCompareExecution, name, ir, mainC string) {
+	t.Helper()
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || execution.triple != "x86_64-unknown-linux-gnu" ||
+		len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("floating-helper native execution cannot borrow a guest or foreign target")
+	}
+	for _, pipeline := range []struct {
+		name, backend string
+		optimizeIR    bool
+	}{
+		{name: "backend_O0", backend: "-O0"},
+		{name: "backend_O2", backend: "-O2"},
+		{name: "IR_O2/backend_O2", backend: "-O2", optimizeIR: true},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			input := ir
+			if pipeline.optimizeIR {
+				input = x86DwordProductIROptimize(t, ir)
+			}
+			execution.compileAndRunLLVM(t, name, input, mainC, pipeline.backend)
+		})
+	}
+}
diff --git a/amd64_fma3_forms.go b/amd64_fma3_forms.go
new file mode 100644
index 000000000..ed3e1d26c
--- /dev/null
+++ b/amd64_fma3_forms.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FMA3Form struct {
+	spec        amd64FMA3Spec
+	suffix      amd64FMA3Suffix
+	byteWidth   int
+	memoryBytes int
+	destination int
+	mask        int // -1 when unmasked
+	memory      int // -1 for a register first source
+}
+
+// Original physical generation wins over an indistinguishable named spelling.
+// Named controls/register banks remain the fallback only when that observation
+// is absent. Neither this selector nor CPU features admit raw numerical inputs.
+func x86FMA3NativeEVEX(ins Instr, form amd64FMA3Form) bool {
+	switch ins.x86FMA3Encoding {
+	case x86RawFMA3EVEX:
+		return true
+	case x86RawFMA3VEX:
+		return false
+	}
+	if form.byteWidth == 64 || form.mask >= 0 || form.suffix.broadcast || form.suffix.rounding != "" {
+		return true
+	}
+	for _, operand := range ins.Args {
+		if index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth); operand.Kind == OpReg && valid && index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+func x86TypedFMA3ByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+		if _, known := amd64FMA3Specs[Op(base)]; known {
+			return x86TypedByteEffect{}, true, fmt.Errorf("FMA3 effect/source opcode mismatch: %s/%s", op, ins.Op)
+		}
+		return x86TypedByteEffect{}, false, nil
+	}
+	ins.Op = op
+	form, known, err := amd64FMA3Properties(ins, arch)
+	if !known || form.spec.rawOnly {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	active := int64(form.byteWidth)
+	if form.spec.scalar {
+		active = int64(form.spec.laneBits / 8)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for index, operand := range ins.Args {
+		width := active
+		if index == form.memory {
+			width = int64(form.memoryBytes)
+		} else if index == form.mask {
+			width = 8
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: index, operand: operand, width: width, read: true,
+		})
+	}
+	// Scalar active inputs and the full destination write are distinct axes.
+	// Numerical upper-X passthrough is handled by the shared result transfer.
+	effect.operands = append(effect.operands, x86TypedByteOperand{
+		index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth), write: true,
+	})
+	return effect, true, nil
+}
+
+// The complete _yvaddpd/_yvaddsd axes are independent of numerical input,
+// caller-memory, initialized-mask and source-stack continuation proofs. FP16
+// shares the architectural grammar but keeps its raw-encoding-only boundary.
+func amd64FMA3Properties(ins Instr, goarch string) (amd64FMA3Form, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := amd64FMA3Specs[Op(base)]
+	if !recognized {
+		return amd64FMA3Form{}, false, nil
+	}
+	form := amd64FMA3Form{
+		spec: spec, destination: len(ins.Args) - 1, mask: -1, memory: -1,
+	}
+	fail := func() (amd64FMA3Form, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix are outside the FMA3 grammar: %q", goarch, base, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" || spec.rawOnly && !ins.x86Encoded ||
+		dotted && suffix == "" || len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return fail()
+	}
+	if ins.x86FMA3Encoding != x86RawFMA3Absent &&
+		(spec.rawOnly || ins.x86FMA3Encoding != x86RawFMA3VEX && ins.x86FMA3Encoding != x86RawFMA3EVEX) {
+		return fail()
+	}
+	properties, valid := parseAMD64FMA3Suffix(suffix)
+	if !valid || spec.scalar && properties.broadcast {
+		return fail()
+	}
+	form.suffix = properties
+	if len(ins.Args) == 4 {
+		if goarch == "386" && !ins.x86Encoded && ins.x86FMA3Encoding != x86RawFMA3EVEX || !amd64NonzeroKOperand(ins.Args[2]) {
+			return fail()
+		}
+		form.mask = 2
+	} else if properties.zeroing {
+		return fail()
+	}
+	form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+	if spec.scalar && form.byteWidth != 16 ||
+		!amd64GoPackedVectorMoveRegister(ins.Args[form.destination], form.byteWidth, goarch) ||
+		!amd64GoPackedVectorMoveRegister(ins.Args[1], form.byteWidth, goarch) ||
+		properties.rounding != "" && !spec.scalar && form.byteWidth != 64 {
+		return fail()
+	}
+	first := ins.Args[0]
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(first) {
+			return fail()
+		}
+	} else if first.Kind == OpReg {
+		if !amd64GoPackedVectorMoveRegister(first, form.byteWidth, goarch) {
+			return fail()
+		}
+	} else if properties.rounding != "" || !isAMD64MemoryOperand(first) {
+		return fail()
+	}
+	if isAMD64MemoryOperand(first) {
+		if !x86PackedShiftMemoryValid(first, goarch) {
+			return fail()
+		}
+		if first.Kind == OpMem {
+			if err := x86SymbolIndexedMemoryError(first.Mem, goarch); err != nil {
+				return form, true, err
+			}
+			if first.Mem.OffRaw != "" || first.Mem.IndexExt != "" {
+				return fail()
+			}
+		}
+		form.memory = 0
+		form.memoryBytes = form.byteWidth
+		if spec.scalar || properties.broadcast {
+			form.memoryBytes = spec.laneBits / 8
+		}
+	}
+	if ins.x86FMA3Encoding == x86RawFMA3VEX {
+		if form.byteWidth == 64 || form.mask >= 0 || properties.broadcast || properties.rounding != "" {
+			return fail()
+		}
+		for _, operand := range ins.Args {
+			if index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth); operand.Kind == OpReg && valid && index >= 16 {
+				return fail()
+			}
+		}
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, goarch)
+}
diff --git a/amd64_fma3_forms_test.go b/amd64_fma3_forms_test.go
new file mode 100644
index 000000000..a189705af
--- /dev/null
+++ b/amd64_fma3_forms_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86FMA3GrammarMatchesEveryCurrentGoTableMember(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := make(map[string]int)
+	wanted := make(map[Op]bool)
+	ast.Inspect(file, func(node ast.Node) bool {
+		if value, ok := node.(*ast.ValueSpec); ok && len(value.Names) == 1 && len(value.Values) == 1 {
+			name := value.Names[0].Name
+			if name == "_yvaddpd" || name == "_yvaddsd" {
+				literal, ok := value.Values[0].(*ast.CompositeLit)
+				if !ok {
+					t.Fatalf("Go FMA3 grammar changed shape: %s", name)
+				}
+				rows[name] = len(literal.Elts)
+			}
+		}
+		literal, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return true
+		}
+		var opcode, table string
+		for _, item := range literal.Elts {
+			pair, ok := item.(*ast.KeyValueExpr)
+			if !ok {
+				continue
+			}
+			key, keyOK := pair.Key.(*ast.Ident)
+			value, valueOK := pair.Value.(*ast.Ident)
+			if !keyOK || !valueOK {
+				continue
+			}
+			if key.Name == "as" {
+				opcode = value.Name
+			} else if key.Name == "ytab" {
+				table = value.Name
+			}
+		}
+		if strings.HasPrefix(opcode, "AVFM") || strings.HasPrefix(opcode, "AVFNM") {
+			if table != "_yvaddpd" && table != "_yvaddsd" {
+				t.Fatalf("Go FMA3 acquired an unreviewed grammar: %s/%s", opcode, table)
+			}
+			wanted[Op(strings.TrimPrefix(opcode, "A"))] = table == "_yvaddsd"
+		}
+		return true
+	})
+	if len(wanted) != 60 || !reflect.DeepEqual(rows, map[string]int{"_yvaddpd": 8, "_yvaddsd": 3}) {
+		t.Fatalf("current Go FMA3 family changed: opcodes=%d rows=%v", len(wanted), rows)
+	}
+	named := 0
+	for opcode, spec := range amd64FMA3Specs {
+		if spec.rawOnly {
+			if _, exists := wanted[opcode]; exists {
+				t.Fatalf("raw-only opcode is now a Go named format: %s", opcode)
+			}
+			continue
+		}
+		scalar, exists := wanted[opcode]
+		if !exists || scalar != spec.scalar {
+			t.Fatalf("Go opcode omitted or changed: %s/%+v", opcode, spec)
+		}
+		named++
+	}
+	if named != len(wanted) {
+		t.Fatalf("named family count mismatch: %d/%d", named, len(wanted))
+	}
+	x86FMA3CheckCompleteEncoderAttributes(t)
+}
+
+// Independent opcode enumeration and format axes. Every form has a separate
+// entry, so an earlier trap/return cannot remove a later LLVM object witness.
+func TestX86FMA3FixedRoundingDefaultArchitecture(t *testing.T) {
+	const source = "TEXT defaultFMA(SB),4,$0-0\nVFMADD132SD.RD_SAE X0,X1,X2\nRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"defaultFMA": {Name: "defaultFMA", Ret: Void}},
+	})
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("default-architecture format source invented its missing FMA inputs", err)
+	}
+	file, signatures := x86UnboundVoidFormatSource(t, source, "defaultFMA", "amd64", "x86_64-unknown-linux-gnu")
+	ir = x86ScalarFormatObjectUnit(t, file, signatures, "amd64", "x86_64-unknown-linux-gnu", 0)
+	llc, _, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "default-fma.ll", "default-fma.o", ir)
+}
+
+func x86FMA3NamedFormats(arch string) []string {
+	var instructions []string
+	ops := append(go127FMA3PackedOps(), go127FMA3ScalarOps()...)
+	for _, opcode := range ops {
+		scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		banks := []string{"X", "Y", "Z"}
+		if scalar {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"", "merge", "zero"} {
+				if arch == "386" && mode != "" {
+					continue
+				}
+				mask, zero := "", ""
+				if mode != "" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					zero = ".Z"
+				}
+				operands := bank + "0," + bank + "1," + mask + bank + "2"
+				memory := "(AX)," + bank + "1," + mask + bank + "2"
+				instructions = append(instructions, opcode+zero+" "+operands, opcode+zero+" "+memory)
+				if !scalar {
+					instructions = append(instructions, opcode+".BCST"+zero+" "+memory)
+				}
+				if scalar || bank == "Z" {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						instructions = append(instructions, opcode+"."+rounding+zero+" "+operands)
+					}
+				}
+			}
+		}
+	}
+	return instructions
+}
+
+func TestX86FMA3GrammarAxesActualGoAndFiveLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		sigs := make(map[string]FuncSig)
+		for index, instruction := range x86FMA3NamedFormats(arch) {
+			name := fmt.Sprintf("fmaformat%d", index)
+			entry := fmt.Sprintf("TEXT %s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+			file, err := Parse(ArchAMD64, entry)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, recognized, err := amd64FMA3Properties(ins, arch)
+			if err != nil || !recognized || form.spec.rawOnly || form.destination != len(ins.Args)-1 {
+				t.Fatalf("%s %s: incomplete grammar %+v/%t/%v", arch, instruction, form, recognized, err)
+			}
+			if form.memory >= 0 {
+				want := form.byteWidth
+				if strings.Contains(instruction, ".BCST") || strings.HasSuffix(strings.Split(string(ins.Op), ".")[0], "SS") ||
+					strings.HasSuffix(strings.Split(string(ins.Op), ".")[0], "SD") {
+					want = 4
+					if strings.Contains(string(ins.Op), "PD") || strings.Contains(string(ins.Op), "SD") {
+						want = 8
+					}
+				}
+				if form.memory != 0 || form.memoryBytes != want {
+					t.Fatalf("%s changed native read extent: %+v; want %d", instruction, form, want)
+				}
+			}
+			source.WriteString(entry)
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+		wanted := map[string]int{"amd64": 1836, "386": 612}[arch]
+		if len(sigs) != wanted {
+			t.Fatal("complete original FMA3 format denominator changed", arch, len(sigs), wanted)
+		}
+		requireX86GoAssemblerResult(t, arch, source.String(), true)
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			file, observed := x86UnboundVoidFormatSources(t, source.String(), arch, triple)
+			if !reflect.DeepEqual(observed, sigs) {
+				t.Fatal("complete original FMA format inventory changed its function signatures")
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, sigs, arch, triple, 0)
+			compileLLVMToObject(t, llc, triple, "fma-formats.ll", "fma-formats.o", ir)
+		}
+		t.Logf("%s: %d independently emitted original-Go format entries", arch, len(sigs))
+	}
+}
+
+func TestX86FMA3DispatchPreservesOriginalSourceIdentity(t *testing.T) {
+	for opcode, spec := range amd64FMA3Specs {
+		for _, identity := range []Op{"", opcode, Op(strings.ToLower(string(opcode)))} {
+			ins := Instr{Op: identity, x86Encoded: spec.rawOnly, Args: []Operand{
+				{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"},
+			}}
+			original := ins
+			ctx, _ := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			recognized, terminated, err := ctx.lowerFMA3(opcode, ins)
+			if !recognized || terminated || err != nil || !reflect.DeepEqual(ins, original) {
+				t.Fatalf("%s/%s legacy dispatch changed source/failed: %t/%t/%v", opcode, identity, recognized, terminated, err)
+			}
+		}
+		for _, conflict := range []Op{"VMOVUPS", "VFMADD132PS.BCST", opcode + ".Z"} {
+			ins := Instr{Op: conflict, x86Encoded: spec.rawOnly, Args: []Operand{
+				{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"},
+			}}
+			original := ins
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			before := output.String()
+			recognized, _, err := ctx.lowerFMA3(opcode, ins)
+			if !recognized || err == nil || output.String() != before || !reflect.DeepEqual(ins, original) {
+				t.Fatalf("%s/%s conflicting dispatch changed source/emitted IR: %t/%v", opcode, conflict, recognized, err)
+			}
+		}
+	}
+}
diff --git a/amd64_fma3_round_runtime_test.go b/amd64_fma3_round_runtime_test.go
new file mode 100644
index 000000000..3adcddfd2
--- /dev/null
+++ b/amd64_fma3_round_runtime_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This separately exercises the production numerical helper on every host.
+// Original instruction acceptance and caller/LLVM objects are independently
+// covered by the complete Go-format oracle, not inferred from this helper.
+func TestCrossLinuxRuntimeMatrixX86FMA3FixedRoundingExtremes(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var ir strings.Builder
+	ir.WriteString("declare i128 @llvm.ctlz.i128(i128, i1)\n")
+	for _, bits := range []int{32, 64} {
+		floatType := amd64FMA3LLVMType(1, bits)
+		fmt.Fprintf(&ir, "declare %s @llvm.fma.f%d(%s, %s, %s)\n", floatType, bits, floatType, floatType, floatType)
+		emitAMD64FMA3RoundingHelper(&ir, bits)
+		fmt.Fprintf(&ir, "define i%d @fma_round%d(i%d %%a, i%d %%b, i%d %%c, i32 %%mode, i32 %%mxcsr) {\n", bits, bits, bits, bits, bits)
+		for _, operand := range []string{"a", "b", "c"} {
+			fmt.Fprintf(&ir, "  %%%s_float = bitcast i%d %%%s to %s\n", operand, bits, operand, floatType)
+		}
+		fmt.Fprintf(&ir, "  %%value = call %s @__plan9asm_fma3_round_f%d(%s %%a_float, %s %%b_float, %s %%c_float, i32 %%mode, i32 %%mxcsr)\n", floatType, bits, floatType, floatType, floatType)
+		fmt.Fprintf(&ir, "  %%bits = bitcast %s %%value to i%d\n  ret i%d %%bits\n}\n", floatType, bits, bits)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "fma3-fixed-round-extremes", triple, ir.String(), x86FMA3RoundingExtremeOracle, nil)
+}
+
+const x86FMA3RoundingExtremeOracle = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <fenv.h>
+#pragma STDC FENV_ACCESS ON
+
+extern uint32_t fma_round32(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t);
+extern uint64_t fma_round64(uint64_t,uint64_t,uint64_t,uint32_t,uint32_t);
+
+static uint64_t state=UINT64_C(0x71b32dd678098deb);
+static uint64_t random_bits(void) {
+    state^=state<<13; state^=state>>7; state^=state<<17;
+    return state;
+}
+
+static uint64_t flush_input(uint64_t bits, uint64_t exponent, uint64_t sign, unsigned csr) {
+    return (csr&64) && !(bits&exponent) ? bits&sign : bits;
+}
+
+static int check(unsigned width, uint64_t a, uint64_t b, uint64_t c,
+                 unsigned mode, unsigned ambient, unsigned csr) {
+    const int modes[]={FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};
+    uint64_t sign=width==32 ? UINT64_C(0x80000000) : UINT64_C(0x8000000000000000);
+    uint64_t exponent=width==32 ? UINT64_C(0x7f800000) : UINT64_C(0x7ff0000000000000);
+    uint64_t got, expected=0;
+    if (fesetround(modes[ambient])) return 1;
+    if (feclearexcept(FE_ALL_EXCEPT)) return 5;
+    if (width==32) got=fma_round32((uint32_t)a,(uint32_t)b,(uint32_t)c,mode,csr);
+    else got=fma_round64(a,b,c,mode,csr);
+    if (fegetround()!=modes[ambient]) return 2;
+    if (fetestexcept(FE_ALL_EXCEPT)) return 6;
+    a=flush_input(a,exponent,sign,csr);
+    b=flush_input(b,exponent,sign,csr);
+    c=flush_input(c,exponent,sign,csr);
+    if (fesetround(modes[mode])) return 3;
+    if (width==32) {
+        uint32_t aa=(uint32_t)a, bb=(uint32_t)b, cc=(uint32_t)c, result_bits;
+        float first, second, addend;
+        memcpy(&first,&aa,4); memcpy(&second,&bb,4); memcpy(&addend,&cc,4);
+        float result=fmaf(first,second,addend);
+        memcpy(&result_bits,&result,4); expected=result_bits;
+    } else {
+        double first, second, addend;
+        memcpy(&first,&a,8); memcpy(&second,&b,8); memcpy(&addend,&c,8);
+        double result=fma(first,second,addend);
+        memcpy(&expected,&result,8);
+    }
+    if ((csr&32768) && !(expected&exponent)) expected&=sign;
+    if (got!=expected) {
+        fprintf(stderr,"FMA rounding width/mode/ambient/csr %u/%u/%u/%x inputs=%llx,%llx,%llx got=%llx expected=%llx\n",
+                width,mode,ambient,csr,(unsigned long long)a,(unsigned long long)b,
+                (unsigned long long)c,(unsigned long long)got,(unsigned long long)expected);
+        return 4;
+    }
+    return 0;
+}
+
+int main(void) {
+    const uint64_t edges32[]={0,0x80000000,1,0x80000001,0x7fffff,0x800000,
+        0x800001,0x7f7fffff,0xff7fffff,0x3f000000,0xbf000000,0x3f800000,
+        0xbf800000,0x3f800001,0xbf800002};
+    const uint64_t edges64[]={0,UINT64_C(0x8000000000000000),1,
+        UINT64_C(0x8000000000000001),UINT64_C(0xfffffffffffff),
+        UINT64_C(0x10000000000000),UINT64_C(0x10000000000001),
+        UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),
+        UINT64_C(0x3fe0000000000000),UINT64_C(0xbfe0000000000000),
+        UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),
+        UINT64_C(0x3ff0000000000001),UINT64_C(0xbff0000000000002)};
+    const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0};
+    for (unsigned width=32; width<=64; width+=32) {
+        const uint64_t *edges=width==32 ? edges32 : edges64;
+        const uint64_t exponent=width==32 ? UINT64_C(0x7f800000) : UINT64_C(0x7ff0000000000000);
+        const uint64_t exponent_low=width==32 ? UINT64_C(0x800000) : UINT64_C(0x10000000000000);
+        for (unsigned i=0; i<5000; i++) {
+            uint64_t a, b, c;
+            if (i<3375) {
+                a=edges[i%15]; b=edges[(i/15)%15]; c=edges[(i/225)%15];
+            } else {
+                a=random_bits(); b=random_bits(); c=random_bits();
+                if (width==32) { a=(uint32_t)a; b=(uint32_t)b; c=(uint32_t)c; }
+                if ((a&exponent)==exponent) a^=exponent_low;
+                if ((b&exponent)==exponent) b^=exponent_low;
+                if ((c&exponent)==exponent) c^=exponent_low;
+            }
+            for (unsigned mode=0; mode<4; mode++) {
+                for (unsigned ambient=0; ambient<4; ambient++) {
+                    for (unsigned control=0; control<4; control++) {
+                        if (check(width,a,b,c,mode,ambient,controls[control])) return 1;
+                    }
+                }
+            }
+        }
+    }
+    return fesetround(FE_TONEAREST) ? 1 : 0;
+}
+`
diff --git a/amd64_four_source_forms.go b/amd64_four_source_forms.go
new file mode 100644
index 000000000..c91b5d8ba
--- /dev/null
+++ b/amd64_four_source_forms.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FourSourceMode uint8
+
+const (
+	amd64FourSourceFMA amd64FourSourceMode = iota
+	amd64FourSourceDotWords
+)
+
+type amd64FourSourceSpec struct {
+	mode       amd64FourSourceMode
+	scalar     bool
+	negative   bool
+	saturating bool
+}
+
+// These are all six Go AVX512_4FMAPS/4VNNIW names. Their complete shared
+// grammar is m128, a four-register range, optional K1-K7 and accumulator;
+// only masked register zeroing is supported, not broadcast, ER or SAE.
+var amd64FourSourceSpecs = map[Op]amd64FourSourceSpec{
+	"V4FMADDPS":  {mode: amd64FourSourceFMA},
+	"V4FMADDSS":  {mode: amd64FourSourceFMA, scalar: true},
+	"V4FNMADDPS": {mode: amd64FourSourceFMA, negative: true},
+	"V4FNMADDSS": {mode: amd64FourSourceFMA, scalar: true, negative: true},
+	"VP4DPWSSD":  {mode: amd64FourSourceDotWords},
+	"VP4DPWSSDS": {mode: amd64FourSourceDotWords, saturating: true},
+}
+
+type amd64FourSourceForm struct {
+	spec        amd64FourSourceSpec
+	memory      Operand
+	sourceBase  int
+	destination Operand
+	maskIndex   int
+	zeroing     bool
+}
+
+func (form amd64FourSourceForm) byteWidth() int {
+	if form.spec.scalar {
+		return 16
+	}
+	return 64
+}
+
+func (form amd64FourSourceForm) inputBytes() int64 {
+	if form.spec.scalar {
+		return 4
+	}
+	return 64
+}
+
+func (form amd64FourSourceForm) source(index int) Operand {
+	bank := "Z"
+	if form.spec.scalar {
+		bank = "X"
+	}
+	return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", bank, form.sourceBase+index))}
+}
+
+func x86FourSourceProperties(op Op, ins Instr, arch string) (amd64FourSourceForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64FourSourceSpecs[Op(base)]
+	form := amd64FourSourceForm{spec: spec, maskIndex: -1, zeroing: suffix == "Z"}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (amd64FourSourceForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go four-source grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		dotted && suffix == "" || suffix != "" && suffix != "Z" || len(ins.Args) != 3 && len(ins.Args) != 4 ||
+		arch == "386" && len(ins.Args) == 4 || suffix == "Z" && len(ins.Args) != 4 {
+		return fail()
+	}
+	form.memory, form.destination = ins.Args[0], ins.Args[len(ins.Args)-1]
+	if !isAMD64MemoryOperand(form.memory) || !x86PackedShiftMemoryValid(form.memory, arch) ||
+		x86NamedMultiplyMemoryError(form.memory, arch) != nil {
+		return fail()
+	}
+	if form.memory.Kind == OpMem && form.memory.Mem.IndexExt != "" {
+		return fail()
+	}
+	rangeOperand := ins.Args[1]
+	if rangeOperand.Kind != OpRegList || !rangeOperand.RegListRange || len(rangeOperand.RegList) != 4 {
+		return fail()
+	}
+	first := -1
+	for position, register := range rangeOperand.RegList {
+		index, valid := amd64VectorRegisterIndex(register, form.byteWidth())
+		if !valid || arch == "386" && index >= 8 || position != 0 && index != first+position {
+			return fail()
+		}
+		if position == 0 {
+			first = index
+		}
+	}
+	index, valid := amd64VectorRegisterIndex(form.destination.Reg, form.byteWidth())
+	if form.destination.Kind != OpReg || !valid || arch == "386" && index >= 8 {
+		return fail()
+	}
+	if len(ins.Args) == 4 {
+		if !amd64NonzeroKOperand(ins.Args[2]) {
+			return fail()
+		}
+		form.maskIndex = 2
+	}
+	// Hardware selects the aligned block containing the encoded first
+	// register, not necessarily the literal spelling's four registers.
+	form.sourceBase = first &^ 3
+	return form, true, nil
+}
+
+func x86TypedFourSourceByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86FourSourceProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.memory, width: 16, read: true},
+		{index: len(ins.Args) - 1, operand: form.destination, width: int64(form.byteWidth()), read: true, write: true},
+	}}
+	for position := 0; position < 4; position++ {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: 1, operand: form.source(position), width: form.inputBytes(), read: true,
+		})
+	}
+	if form.maskIndex >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.maskIndex, operand: ins.Args[form.maskIndex], width: 8, read: true,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_fp16_binary_forms.go b/amd64_fp16_binary_forms.go
new file mode 100644
index 000000000..f8bdd11a2
--- /dev/null
+++ b/amd64_fp16_binary_forms.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86FP16BinaryForm struct {
+	x86FloatBinaryForm
+	spec amd64BinaryFloatingSpec
+	sae  bool
+}
+
+// The twelve raw MAP5 binary members share the existing floating operand
+// grammar. MIN/MAX allow SAE, not arithmetic's embedded rounding modes.
+func x86FP16BinaryProperties(ins Instr, arch string) (x86FP16BinaryForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64BinaryFloatingSpecs[Op(base)]
+	if !known || !spec.rawOnly || spec.mode == amd64BinaryFloatingSqrt {
+		return x86FP16BinaryForm{}, false, nil
+	}
+	controls, valid := parseAMD64BinaryFloatingSuffix(suffix)
+	f := x86FP16BinaryForm{spec: spec, sae: controls.sae}
+	fail := func() (x86FP16BinaryForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s has invalid raw FP16 binary operands or controls: %q", arch, ins.Op, ins.Raw)
+	}
+	if !ins.x86Encoded || !valid || dotted && suffix == "" ||
+		spec.sae && controls.rounding != "" || !spec.sae && controls.sae {
+		return fail()
+	}
+	shape := ins
+	if controls.sae {
+		shape.Op = Op(base)
+		if controls.zeroing {
+			shape.Op += ".Z"
+		}
+	}
+	var err error
+	f.x86FloatBinaryForm, err = x86FloatBinaryOperandProperties(shape, arch, 16, false, spec.scalar, false, "FP16 binary")
+	if err != nil {
+		return f, true, err
+	}
+	if controls.sae && (ins.Args[0].Kind != OpReg || !spec.scalar && f.byteWidth != 64) {
+		return fail()
+	}
+	if ins.Args[0].Kind == OpMem {
+		memory := ins.Args[0].Mem
+		if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+			return f, true, err
+		}
+		if memory.OffRaw != "" || memory.IndexExt != "" {
+			return fail()
+		}
+	}
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func (c *amd64Ctx) lowerFP16Binary(op Op, ins Instr) (bool, bool, error) {
+	local := ins
+	local.Op = op
+	f, known, err := x86FP16BinaryProperties(local, c.goarch)
+	if !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return true, false, fmt.Errorf("FP16 binary dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	ins = local
+	controls := amd64FMA3Suffix{broadcast: f.broadcast, zeroing: f.zeroing, rounding: f.rounding}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		lanes := f.byteWidth / 2
+		if f.scalar {
+			lanes = 1
+		}
+		return true, false, c.emitNativeFP16ThreeOperand(ins, x86NativeFP16ThreeOperand{
+			byteWidth: f.byteWidth, lanes: lanes, memoryBytes: f.memoryBytes,
+			second: f.second, destination: f.destination, mask: f.mask,
+			controls: controls, sae: f.sae,
+		})
+	}
+	// Keep cross-target numerical values separate from original x86 effects.
+	mask := ""
+	if f.mask >= 0 {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	properties := amd64BinaryFloatingSuffix{
+		broadcast: f.broadcast, zeroing: f.zeroing, rounding: f.rounding, sae: f.sae,
+	}
+	if f.scalar {
+		return c.lowerScalarBinaryFloating(f.spec, properties, ins, ins.Args[f.destination], mask)
+	}
+	return c.lowerPackedBinaryFloating(f.spec, properties, ins, ins.Args[f.destination], f.byteWidth, mask)
+}
diff --git a/amd64_fp16_conversion_forms.go b/amd64_fp16_conversion_forms.go
new file mode 100644
index 000000000..7c4bb11c9
--- /dev/null
+++ b/amd64_fp16_conversion_forms.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The six raw-only FP16 floating conversions share source, mask and control
+// axes. Physical carrier widths are distinct from active input/output bytes.
+type x86FP16ConversionForm struct {
+	spec                                amd64HalfConversionSpec
+	controls                            amd64FMA3Suffix
+	sae                                 bool
+	lanes, inputBytes, outputBytes      int
+	sourceBytes, byteWidth, memoryBytes int
+	destination, mask, upper            int
+}
+
+func x86FP16ConversionProperties(ins Instr, arch string) (x86FP16ConversionForm, bool, error) {
+	base, suffix, dotted := strings.Cut(string(ins.Op), ".")
+	spec, known := amd64HalfConversionSpecs[base]
+	if !known || !spec.rawOnly {
+		return x86FP16ConversionForm{}, false, nil
+	}
+	f := x86FP16ConversionForm{spec: spec, destination: len(ins.Args) - 1, mask: -1, upper: -1}
+	fail := func() (x86FP16ConversionForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s has invalid raw FP16 conversion operands or controls: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || !ins.x86Encoded || dotted && suffix == "" {
+		return fail()
+	}
+	operands := 2
+	f.lanes = ins.x86VectorBytes / 4
+	if spec.scalar {
+		operands, f.lanes, f.upper = 3, 1, 1
+	} else if ins.x86VectorBytes != 16 && ins.x86VectorBytes != 32 && ins.x86VectorBytes != 64 {
+		return fail()
+	}
+	if len(ins.Args) != operands && len(ins.Args) != operands+1 {
+		return fail()
+	}
+	f.sae = suffix == "SAE" || suffix == "SAE.Z"
+	if f.sae {
+		suffix = strings.TrimPrefix(strings.TrimPrefix(suffix, "SAE"), ".")
+	}
+	var valid bool
+	f.controls, valid = parseAMD64FMA3Suffix(suffix)
+	if !valid || spec.inputBits == 16 && f.controls.rounding != "" || spec.outputBits == 16 && f.sae ||
+		spec.scalar && f.controls.broadcast {
+		return fail()
+	}
+	if len(ins.Args) == operands+1 {
+		f.mask = operands - 1
+		if !amd64NonzeroKOperand(ins.Args[f.mask]) {
+			return fail()
+		}
+	} else if f.controls.zeroing {
+		return fail()
+	}
+	f.inputBytes, f.outputBytes = f.lanes*spec.inputBits/8, f.lanes*spec.outputBits/8
+	f.sourceBytes, f.byteWidth = f.inputBytes, f.outputBytes
+	if f.sourceBytes < 16 {
+		f.sourceBytes = 16
+	}
+	if f.byteWidth < 16 {
+		f.byteWidth = 16
+	}
+	if !amd64GoPackedVectorMoveRegister(ins.Args[f.destination], f.byteWidth, arch) ||
+		f.upper >= 0 && !amd64GoPackedVectorMoveRegister(ins.Args[f.upper], 16, arch) {
+		return fail()
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		if !amd64GoPackedVectorMoveRegister(source, f.sourceBytes, arch) || f.controls.broadcast {
+			return fail()
+		}
+	} else if !x86PackedShiftMemoryValid(source, arch) || f.sae || f.controls.rounding != "" {
+		return fail()
+	}
+	if source.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+			return f, true, err
+		}
+		if source.Mem.OffRaw != "" || source.Mem.IndexExt != "" {
+			return fail()
+		}
+	}
+	if !spec.scalar && (f.sae || f.controls.rounding != "") && ins.x86VectorBytes != 64 {
+		return fail()
+	}
+	f.memoryBytes = f.inputBytes
+	if f.controls.broadcast {
+		f.memoryBytes = spec.inputBits / 8
+	}
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
diff --git a/amd64_fp16_conversion_native.go b/amd64_fp16_conversion_native.go
new file mode 100644
index 000000000..9b85e40e4
--- /dev/null
+++ b/amd64_fp16_conversion_native.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) emitNativeFP16Conversion(ins Instr, f x86FP16ConversionForm) error {
+	source := ins.Args[0]
+	if source.Kind == OpFP || ins.x86AddressBits != 0 || source.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, 0) {
+		return fmt.Errorf("%w: FP16 conversion needs original native backing", ErrProbeNeedsContext)
+	}
+	if f.spec.scalar {
+		return c.emitNativeFP16ThreeOperand(ins, x86NativeFP16ThreeOperand{
+			byteWidth: 16, lanes: 1, memoryBytes: f.memoryBytes, second: f.upper,
+			destination: f.destination, mask: f.mask,
+			controls: f.controls, sae: f.sae,
+		})
+	}
+	mnemonic, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	if source.Kind != OpReg && f.spec.outputBits == 16 && !f.controls.broadcast && f.sourceBytes < 64 {
+		mnemonic += map[int]string{16: "x", 32: "y"}[f.sourceBytes]
+	}
+	return c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: f.byteWidth, sourceBytes: f.sourceBytes, memoryBytes: f.memoryBytes,
+		outputBits:  32, // Bit carrier only: the original opcode selects FP16/FP32.
+		destination: f.destination, mask: f.mask, lanes: f.lanes, evex: true,
+		broadcast: f.controls.broadcast, zeroing: f.controls.zeroing,
+		rounding: f.controls.rounding, sae: f.sae, mnemonic: mnemonic,
+	})
+}
+
+// Existing FP16 clients retain their own grammar and source permissions. Only
+// the actual native operand transport is shared with other floating families.
+type x86NativeFP16ThreeOperand = x86NativeFloatingOperands
+
+func (c *amd64Ctx) emitNativeFP16ThreeOperand(ins Instr, f x86NativeFP16ThreeOperand) error {
+	return c.emitNativeFloatingOperands(ins, f)
+}
diff --git a/amd64_fp_address.go b/amd64_fp_address.go
new file mode 100644
index 000000000..0724d17be
--- /dev/null
+++ b/amd64_fp_address.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import "fmt"
+
+// boundFPAddress addresses a declared field's backing storage, never its
+// current value. An unbound source address needs a physical frame contract;
+// inventing a zero pointer or extending an alloca into padding is not one.
+func (c *amd64Ctx) boundFPAddress(off int64) (string, error) {
+	slot, result, ok := c.fpVectorSlot(off)
+	if !ok {
+		return "", fmt.Errorf("%w: %s FP address at +%d(FP) requires bound typed frame storage", ErrProbeNeedsContext, c.goarch, off)
+	}
+	if x86FrameScalarBytes(slot.Type, c.goarch) == 0 {
+		// The vector lookup's conservative aggregate-size fallback is not a
+		// storage-width proof. Scalar bool fields use canonical i8 backing.
+		return "", fmt.Errorf("%w: %s FP address at +%d(FP) lacks a scalar byte-storage contract for %s", ErrProbeNeedsContext, c.goarch, off, slot.Type)
+	}
+	if result {
+		c.markFPResultAddrTaken(slot.Offset)
+	}
+	var pointer string
+	if c.classicFrame != "" {
+		pointer = c.classicFramePtr(off)
+	} else {
+		if result {
+			pointer, _, ok = c.fpResultAlloca(slot.Offset)
+		} else {
+			pointer = c.fpParamAlloca[slot.Offset]
+			ok = pointer != ""
+		}
+		if !ok {
+			return "", fmt.Errorf("%w: %s FP address at +%d(FP) has no backing storage", ErrProbeNeedsContext, c.goarch, off)
+		}
+		if off != slot.Offset {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds i8, ptr %s, i64 %d\n", adjusted, pointer, off-slot.Offset)
+			pointer = "%" + adjusted
+		}
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", address, pointer)
+	return "%" + address, nil
+}
+
+func x86FrameScalarBytes(typ LLVMType, goarch string) int64 {
+	switch typ {
+	case I1, I8, I16, I32, I64, Ptr, LLVMType("float"), LLVMType("double"):
+		pointerSize := int64(8)
+		if goarch == "386" {
+			pointerSize = 4
+		}
+		return frameTypeSize(typ, pointerSize)
+	default:
+		return 0
+	}
+}
diff --git a/amd64_fp_address_test.go b/amd64_fp_address_test.go
new file mode 100644
index 000000000..65240549c
--- /dev/null
+++ b/amd64_fp_address_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LEAFPAddressesRequireBoundStorage(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W", "L"}
+		if target.arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, prefix := range []string{"", "$"} {
+				for _, offset := range []int64{0, 1, 8, 9, 4, 12} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%d", target.triple, width, prefix, offset), func(t *testing.T) {
+						// Storage-address validity is independent of result
+						// initialization. The original unwritten-result source is
+						// retained as a separate complete negative regression.
+						source := fmt.Sprintf("TEXT Address(SB),4,$0-16\nMOVL $7,r+8(FP)\nLEA%s %sr+%d(FP),AX\nRET\n", width, prefix, offset)
+						requireX86GoAssemblerResult(t, target.arch, source, prefix == "")
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{"Address": {
+								Name: "Address", Args: []LLVMType{I32}, Ret: I32,
+								Frame: FrameLayout{
+									Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+									Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1, Name: "r"}},
+								},
+							}},
+						}
+						ir, err := Translate(file, opt)
+						if prefix == "$" {
+							if err == nil {
+								t.Fatal("accepted TYPE_ADDR outside Go's LEA Ym/Yrl row")
+							}
+							return
+						}
+						if offset == 4 || offset == 12 {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("unbound FP address became success/zero: %v", err)
+							}
+							return
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						if !strings.Contains(ir, "ptrtoint ptr") {
+							t.Fatalf("LEA used the parameter value instead of its storage:\n%s", ir)
+						}
+						compileLLVMToObject(t, llc, target.triple, "fp-address.ll", "fp-address.o", ir)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LEAFPAddressCannotInventScalarBacking(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		lea, triple := "LEAQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			lea, triple = "LEAL", "i386-unknown-linux-gnu"
+		}
+		for _, typ := range []LLVMType{"{ i8 }", "{}", "<8 x i8>"} {
+			t.Run(arch+"/"+string(typ), func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Address(SB),4,$0-16\n"+lea+" x+0(FP),AX\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: arch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"Address": {
+						Name: "Address", Args: []LLVMType{typ}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}}},
+					}},
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("address lacks a scalar/canonical-byte contract, got %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_fp_bool_storage_test.go b/amd64_fp_bool_storage_test.go
new file mode 100644
index 000000000..1a8981bb1
--- /dev/null
+++ b/amd64_fp_bool_storage_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// A Go bool occupies one canonical byte in ABI0 memory, even though its LLVM
+// argument and result have type i1. These sources exercise the actual byte
+// backing, including indirect writes through LEA, not just the SSA value.
+func x86BoolFrameSource(arch string) string {
+	lea, word := "LEAQ", 8
+	if arch == "386" {
+		lea, word = "LEAL", 4
+	}
+	source := fmt.Sprintf(`TEXT ·ReadByte(SB),4,$0-%d
+%s x+0(FP),AX
+MOVB (AX),BX
+MOVB BX,ret+%d(FP)
+RET
+TEXT ·WriteParam(SB),4,$0-%d
+%s x+0(FP),AX
+MOVB $1,(AX)
+MOVB x+0(FP),BX
+MOVB BX,ret+%d(FP)
+RET
+TEXT ·WriteResult(SB),4,$0-%d
+MOVB x+0(FP),BX
+%s ret+%d(FP),AX
+MOVB BX,(AX)
+RET
+TEXT ·WriteDirect(SB),4,$0-%d
+MOVB $0,x+0(FP)
+MOVB x+0(FP),BX
+MOVB BX,ret+%d(FP)
+RET
+`, word+1, lea, word, word+1, lea, word, word+1, lea, word, word+1, word)
+	source += fmt.Sprintf(`TEXT ·BoolCallee(SB),4,$0-%d
+%s x+0(FP),AX
+MOVB (AX),BX
+MOVB BX,ret+%d(FP)
+RET
+TEXT ·BoolCaller(SB),4,$16-%d
+MOVB x+0(FP),AX
+MOVB AX,0(SP)
+CALL ·BoolCallee(SB)
+MOVB %d(SP),AX
+MOVB AX,ret+%d(FP)
+RET
+TEXT ·BoolField(SB),4,$0-%d
+%s p_flag+1(FP),AX
+MOVB (AX),BX
+MOVB BX,ret+%d(FP)
+RET
+`, word+1, lea, word, word+1, word, word, word+1, lea, word)
+	return source
+}
+
+func x86BoolFrameIR(t *testing.T, arch, triple string) string {
+	t.Helper()
+	source := x86BoolFrameSource(arch)
+	requireX86GoAssemblerResult(t, arch, source, true)
+	pkg := mustGoPackage(t, "example.com/boolframe", `package boolframe
+func ReadByte(x bool) uint8
+func WriteParam(x bool) bool
+func WriteResult(x bool) bool
+func WriteDirect(x bool) bool
+func BoolCallee(x bool) bool
+func BoolCaller(x bool) bool
+func BoolField(p struct { Pad uint8; Flag bool }) bool
+`)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: arch, TargetTriple: triple,
+		ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	ir := translation.Module.String()
+	for _, unsafeBacking := range []string{
+		"%fp_arg_0 = alloca i1", "%fp_ret_0 = alloca i1",
+	} {
+		if strings.Contains(ir, unsafeBacking) {
+			t.Fatalf("Go bool uses a sub-byte backing store: %s", unsafeBacking)
+		}
+	}
+	// This LLVM caller keeps the exact aggregate type. A C struct parameter
+	// would use C's ABI coercions and is not an oracle for this LLVM boundary.
+	return ir + `
+define i1 @BoolFieldWrapper(i1 %flag) {
+entry:
+  %pad = insertvalue { i8, i1 } undef, i8 17, 0
+  %input = insertvalue { i8, i1 } %pad, i1 %flag, 1
+  %result = call i1 @BoolField({ i8, i1 } %input)
+  ret i1 %result
+}
+`
+}
+
+func TestX86BoolFrameCanonicalByteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86BoolFrameIR(t, target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "bool-frame.ll", "bool-frame.o", ir)
+		})
+	}
+}
+
+func x86BoolFrameGoOracle(t *testing.T, arch string, runPrefix []string) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":              "module example.com/boolframe\n\ngo 1.20\n",
+		"bool_" + arch + ".s": x86BoolFrameSource(arch),
+		"bool_test.go": `package boolframe
+import "testing"
+func ReadByte(x bool) uint8
+func WriteParam(x bool) bool
+func WriteResult(x bool) bool
+func WriteDirect(x bool) bool
+func BoolCallee(x bool) bool
+func BoolCaller(x bool) bool
+func BoolField(p struct { Pad uint8; Flag bool }) bool
+func TestCanonicalBytes(t *testing.T) {
+  for i := 0; i < 1024; i++ {
+    for _, x := range []bool{false, true} {
+      want := uint8(0)
+      if x { want = 1 }
+      if ReadByte(x) != want || !WriteParam(x) || WriteResult(x) != x || WriteDirect(x) {
+        t.Fatalf("canonical Go bool frame failed for %v", x)
+      }
+      if BoolCallee(x) != x || BoolCaller(x) != x || BoolField(struct { Pad uint8; Flag bool }{17, x}) != x {
+        t.Fatalf("canonical Go bool call/aggregate failed for %v", x)
+      }
+    }
+  }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"test", "-vet=off", "-count=1"}
+	if len(runPrefix) != 0 {
+		args = append(args, "-exec", strings.Join(runPrefix, " "))
+	}
+	cmd := exec.Command("go", append(args, ".")...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH="+arch)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("Go %s bool byte oracle: %v\n%s", arch, err, out)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86BoolFrameCanonicalBytes(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("x86 byte ABI oracle runs in the required Linux/amd64 cross-runtime gate")
+	}
+	x86BoolFrameGoOracle(t, "amd64", nil)
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var runPrefix []string
+	if crossRosetta {
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	const main = `#include <stdbool.h>
+#include <stdint.h>
+extern uint8_t ReadByte(bool);
+extern bool WriteParam(bool), WriteResult(bool), WriteDirect(bool);
+extern bool BoolCallee(bool), BoolCaller(bool), BoolFieldWrapper(bool);
+int main(void) {
+  for (unsigned i = 0; i < 1024; i++) {
+    for (unsigned x = 0; x < 2; x++) {
+      volatile uint64_t canary = UINT64_C(0x123456789abcdef0);
+      if (ReadByte(x) != x || !WriteParam(x) || WriteResult(x) != x || WriteDirect(x)) return 1;
+      if (canary != UINT64_C(0x123456789abcdef0)) return 2;
+      if (BoolCallee(x) != x || BoolCaller(x) != x || BoolFieldWrapper(x) != x) return 3;
+    }
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bool_frame", triple,
+		x86BoolFrameIR(t, "amd64", triple), main, runPrefix)
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" {
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+			t.Fatal("PLAN9ASM_CROSS_EXEC bool matrix requires Linux/amd64")
+		}
+		prefix := []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"}
+		x86BoolFrameGoOracle(t, "386", prefix)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc", "-no-pie"},
+			"bool_frame386", "i386-unknown-linux-gnu", x86BoolFrameIR(t, "386", "i386-unknown-linux-gnu"), main, prefix)
+	}
+}
diff --git a/amd64_fp_storage.go b/amd64_fp_storage.go
new file mode 100644
index 000000000..8d8991f9a
--- /dev/null
+++ b/amd64_fp_storage.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "fmt"
+
+// Go ABI0 bool fields occupy a whole canonical byte. LLVM's i1 describes the
+// logical argument, not byte-addressable storage: writing i1 alone does not
+// establish the other seven bits for subsequent assembly byte loads.
+func x86FPStorageType(typ LLVMType) LLVMType {
+	if typ == I1 {
+		return I8
+	}
+	return typ
+}
+
+func (c *amd64Ctx) storeFPStorage(typ LLVMType, value, pointer, alignment, metadata string) {
+	if typ == I1 {
+		byteValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i8\n", byteValue, value)
+		value = "%" + byteValue
+	}
+	fmt.Fprintf(c.b, "  store %s %s, ptr %s%s%s\n", x86FPStorageType(typ), value, pointer, alignment, metadata)
+}
+
+func (c *amd64Ctx) loadFPStorage(typ LLVMType, pointer, alignment string) string {
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s%s\n", loaded, x86FPStorageType(typ), pointer, alignment)
+	if typ == I1 {
+		logical := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i8 %%%s to i1\n", logical, loaded)
+		return "%" + logical
+	}
+	return "%" + loaded
+}
diff --git a/amd64_frame_input_digest_test.go b/amd64_frame_input_digest_test.go
new file mode 100644
index 000000000..2d7d586ed
--- /dev/null
+++ b/amd64_frame_input_digest_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// Private verifier unit only. This does not construct a public source/frame
+// observation, actual compiler selection or an ASM permission.
+func frameInputDigestFixture(t *testing.T, size int) (*GoAMD64FrameSource, string, byte) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := filepath.Join(directory, "input")
+	data := bytes.Repeat([]byte{0x5a}, size)
+	if err := os.WriteFile(name, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	info, err := os.Lstat(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoAMD64FrameSource{request: GoAMD64FrameCaptureRequest{Directory: directory},
+		owned: directory, ownedInfo: info, directoryInfo: info,
+		entries: []string{"input"}, inputs: map[string][32]byte{name: sha256.Sum256(data)}}
+	if err := source.verifyInputs(); err != nil {
+		t.Fatal("unchanged complete verifier control failed", err)
+	}
+	return source, name, 0x5a
+}
+
+func TestGoAMD64FrameInputVerificationHasBoundedAllocations(t *testing.T) {
+	source, _, _ := frameInputDigestFixture(t, 8<<20)
+	runtime.GC()
+	var before, after runtime.MemStats
+	runtime.ReadMemStats(&before)
+	for round := 0; round < 3; round++ {
+		if err := source.verifyInputs(); err != nil {
+			t.Fatal(err)
+		}
+	}
+	runtime.ReadMemStats(&after)
+	allocated := after.TotalAlloc - before.TotalAlloc
+	t.Logf("three complete 8-MiB file verifications allocated %d bytes", allocated)
+	if allocated > 4<<20 {
+		t.Fatal("digest-only verification allocated whole-file buffers", allocated)
+	}
+}
+
+func TestGoAMD64FrameInputVerificationReadsTailDespiteSameMetadata(t *testing.T) {
+	source, name, original := frameInputDigestFixture(t, 1<<20)
+	info, err := os.Stat(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := os.OpenFile(name, os.O_WRONLY, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, writeErr := file.WriteAt([]byte{original ^ 1}, info.Size()-1)
+	if err := errors.Join(writeErr, file.Close()); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chtimes(name, info.ModTime(), info.ModTime()); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.verifyInputs(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("same-size same-time tail mutation escaped complete content verification", err)
+	}
+}
+
+func TestGoAMD64FrameInputVerificationRetainsInputRole(t *testing.T) {
+	for _, mutation := range []string{"missing", "directory", "growth", "truncation"} {
+		t.Run(mutation, func(t *testing.T) {
+			source, name, _ := frameInputDigestFixture(t, 128)
+			switch mutation {
+			case "missing":
+				if err := os.Remove(name); err != nil {
+					t.Fatal(err)
+				}
+			case "directory":
+				if err := os.Remove(name); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(name, 0700); err != nil {
+					t.Fatal(err)
+				}
+			case "growth":
+				if err := os.Truncate(name, 129); err != nil {
+					t.Fatal(err)
+				}
+			case "truncation":
+				if err := os.Truncate(name, 127); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.verifyInputs(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed physical input retained its verifier role", err)
+			}
+		})
+	}
+}
diff --git a/amd64_frame_vector.go b/amd64_frame_vector.go
new file mode 100644
index 000000000..d170435ad
--- /dev/null
+++ b/amd64_frame_vector.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import "fmt"
+
+// fpVectorSlot locates the scalar ABI0 field containing one byte of a vector
+// memory operand. Aggregate parameters have several independently allocated
+// fields on amd64; treating the first field as a contiguous pointer is wrong.
+func (c *amd64Ctx) fpVectorSlot(off int64) (FrameSlot, bool, bool) {
+	for _, slot := range c.sig.Frame.Params {
+		size := x86FrameTypeSize(slot.Type)
+		if slot.Type == Ptr {
+			size = int64(goWordSize(c.goarch))
+		}
+		if off >= slot.Offset && off < slot.Offset+size {
+			return slot, false, true
+		}
+	}
+	for _, slot := range c.fpResults {
+		size := x86FrameTypeSize(slot.Type)
+		if slot.Type == Ptr {
+			size = int64(goWordSize(c.goarch))
+		}
+		if off >= slot.Offset && off < slot.Offset+size {
+			return slot, true, true
+		}
+	}
+	return FrameSlot{}, false, false
+}
+
+func (c *amd64Ctx) validateFPVectorSpan(off int64, byteWidth int) error {
+	for i := 0; i < byteWidth; i++ {
+		if _, _, ok := c.fpVectorSlot(off + int64(i)); !ok {
+			return fmt.Errorf("undeclared FP vector byte at +%d(FP)", off+int64(i))
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) loadFPVectorBytes(off int64, byteWidth int) (string, error) {
+	return c.loadFPVectorBytesMode(off, byteWidth, false)
+}
+
+// Integer byte views may observe an intermediate noncanonical bool byte, but
+// only after their independent whole-function canonical result proof. Existing
+// SIMD views keep their old logical-field policy and never acquire this mode.
+func (c *amd64Ctx) loadFPVectorField(slot FrameSlot, result, physicalBool bool) (string, LLVMType, error) {
+	if physicalBool && slot.Type == I1 {
+		if !c.abi0BoolResultByteStorage() {
+			return "", "", fmt.Errorf("%w: FP bool byte lacks a checked storage role", ErrProbeNeedsContext)
+		}
+		pointer := c.fpParamAlloca[slot.Offset]
+		if result {
+			pointer, _, _ = c.fpResultAlloca(slot.Offset)
+		}
+		if c.classicFrame != "" {
+			pointer = c.classicFramePtr(slot.Offset)
+		}
+		if pointer == "" {
+			return "", "", fmt.Errorf("missing physical FP bool storage at +%d(FP)", slot.Offset)
+		}
+		return c.loadFPStorage(I8, pointer, ", align 1"), I8, nil
+	}
+	if result {
+		value, err := c.loadFPResult(slot)
+		return value, slot.Type, err
+	}
+	value, err := c.loadFPParamValue(slot)
+	return value, slot.Type, err
+}
+
+func (c *amd64Ctx) loadFPVectorBytesMode(off int64, byteWidth int, physicalBool bool) (string, error) {
+	if err := c.validateFPVectorSpan(off, byteWidth); err != nil {
+		return "", err
+	}
+	value := "zeroinitializer"
+	words := make(map[int64]string)
+	for i := 0; i < byteWidth; i++ {
+		slot, result, _ := c.fpVectorSlot(off + int64(i))
+		word, found := words[slot.Offset]
+		if !found {
+			scalar, typ, err := c.loadFPVectorField(slot, result, physicalBool)
+			if err != nil {
+				return "", err
+			}
+			word, err = c.fpVectorScalarBits(typ, scalar)
+			if err != nil {
+				return "", err
+			}
+			words[slot.Offset] = word
+		}
+		shift := (off + int64(i) - slot.Offset) * 8
+		if shift != 0 {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", shifted, word, shift)
+			word = "%" + shifted
+		}
+		part := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", part, word)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i8> %s, i8 %%%s, i32 %d\n", inserted, byteWidth, value, part, i)
+		value = "%" + inserted
+	}
+	return value, nil
+}
+
+func (c *amd64Ctx) fpVectorScalarBits(typ LLVMType, scalar string) (string, error) {
+	switch typ {
+	case I64:
+		return scalar, nil
+	case Ptr:
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", converted, scalar)
+		return "%" + converted, nil
+	case LLVMType("double"):
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", converted, scalar)
+		return "%" + converted, nil
+	case LLVMType("float"):
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits, scalar)
+		scalar = "%" + bits
+		typ = I32
+	}
+	bits, ok := amd64IntegerTypeBits(typ)
+	if !ok {
+		return "", fmt.Errorf("unsupported FP vector field type %s", typ)
+	}
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", wide, bits, scalar)
+	return "%" + wide, nil
+}
+
+func (c *amd64Ctx) storeFPVectorBytes(off int64, byteWidth int, value, metadata string) error {
+	return c.storeFPVectorBytesMode(off, byteWidth, value, metadata, false)
+}
+
+func (c *amd64Ctx) storeFPVectorBytesMode(off int64, byteWidth int, value, metadata string, physicalBool bool) error {
+	if err := c.validateFPVectorSpan(off, byteWidth); err != nil {
+		return err
+	}
+	if physicalBool && !c.abi0BoolResultByteStorage() {
+		for i := 0; i < byteWidth; i++ {
+			if slot, _, _ := c.fpVectorSlot(off + int64(i)); slot.Type == I1 {
+				return fmt.Errorf("%w: FP bool byte lacks a checked storage role", ErrProbeNeedsContext)
+			}
+		}
+	}
+	if c.classicFrame != "" {
+		for i := 0; i < byteWidth; i++ {
+			part := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", part, byteWidth, value, i)
+			fmt.Fprintf(c.b, "  store i8 %%%s, ptr %s, align 1%s\n", part, c.classicFramePtr(off+int64(i)), metadata)
+			if slot, result, ok := c.fpVectorSlot(off + int64(i)); ok && result {
+				c.markFPResultWritten(slot.Offset)
+			}
+		}
+		return nil
+	}
+
+	updated := make(map[int64]string)
+	order := make([]FrameSlot, 0, byteWidth/4)
+	for i := 0; i < byteWidth; i++ {
+		current := off + int64(i)
+		slot, result, _ := c.fpVectorSlot(current)
+		bits, found := updated[slot.Offset]
+		if !found {
+			scalar, typ, err := c.loadFPVectorField(slot, result, physicalBool)
+			if err != nil {
+				return err
+			}
+			bits, err = c.fpVectorScalarBits(typ, scalar)
+			if err != nil {
+				return err
+			}
+			order = append(order, slot)
+		}
+		part := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", part, byteWidth, value, i)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", wide, part)
+		shift := (current - slot.Offset) * 8
+		inserted := "%" + wide
+		if shift != 0 {
+			tmp := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", tmp, inserted, shift)
+			inserted = "%" + tmp
+		}
+		cleared := c.newTmp()
+		mask := ^(uint64(0xff) << uint(shift))
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", cleared, bits, mask)
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", merged, cleared, inserted)
+		updated[slot.Offset] = "%" + merged
+	}
+	for _, slot := range order {
+		bits := updated[slot.Offset]
+		converted := bits
+		typ := slot.Type
+		if physicalBool && typ == I1 {
+			typ = I8
+		}
+		switch typ {
+		case I64:
+		case Ptr:
+			tmp := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", tmp, bits)
+			converted = "%" + tmp
+		case LLVMType("double"):
+			tmp := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", tmp, bits)
+			converted = "%" + tmp
+		case LLVMType("float"):
+			narrow, tmp := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, bits)
+			fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", tmp, narrow)
+			converted = "%" + tmp
+		default:
+			width, ok := amd64IntegerTypeBits(typ)
+			if !ok || width > 64 {
+				return fmt.Errorf("unsupported FP vector field type %s", slot.Type)
+			}
+			tmp := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", tmp, bits, width)
+			converted = "%" + tmp
+		}
+		if err := c.storeFPResultWithMetadata(slot.Offset, typ, converted, metadata); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/amd64_gfni_forms.go b/amd64_gfni_forms.go
new file mode 100644
index 000000000..884100d25
--- /dev/null
+++ b/amd64_gfni_forms.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86GFNIForm struct {
+	x86PackedBinaryForm
+	spec      amd64GFNISpec
+	immediate uint8
+}
+
+func x86GFNIProperties(op Op, ins Instr, arch string) (x86GFNIForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64GFNISpecs[Op(base)]
+	form := x86GFNIForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return form, true, fmt.Errorf("GFNI dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	local := ins
+	local.Op = op
+	offset := 0
+	if spec.immediate {
+		if len(ins.Args) == 0 || !amd64UnsignedImmediate(ins.Args[0], 8) {
+			return form, true, fmt.Errorf("%s %s requires a resolved unsigned imm8: %q", arch, op, ins.Raw)
+		}
+		if arch == "386" && !ins.x86Encoded {
+			return form, true, fmt.Errorf("386 %s exceeds cmd/asm's named operand limit: %q", op, ins.Raw)
+		}
+		form.immediate, offset = uint8(ins.Args[0].Imm), 1
+		local.Args = ins.Args[1:]
+	}
+	local, contextual := x86VectorValueMemoryInput(local, arch)
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}
+	if spec.broadcast {
+		grammar.broadcastBytes = 8
+	}
+	var err error
+	form.x86PackedBinaryForm, err = x86PackedBinaryOperandGrammar(local, arch, grammar, ins.x86Encoded)
+	if err != nil {
+		return form, true, err
+	}
+	form.first += offset
+	form.second += offset
+	form.destination += offset
+	if form.mask >= 0 {
+		form.mask += offset
+	}
+	if form.memory >= 0 {
+		form.memory += offset
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && amd64VectorByteWidth(operand.Reg) != 0 &&
+			!amd64GoPackedVectorMoveRegister(operand, form.byteWidth, arch) {
+			return form, true, fmt.Errorf("%s %s has an unbound physical vector register: %q", arch, op, ins.Raw)
+		}
+	}
+	if form.memory >= 0 && !contextual && !x86PackedShiftMemoryValid(ins.Args[form.memory], arch) {
+		return form, true, fmt.Errorf("%s %s has an unbound memory operand: %q", arch, op, ins.Raw)
+	}
+	if contextual {
+		return form, true, x86VectorValueMemoryContext(ins)
+	}
+	return form, true, nil
+}
+
+func x86ResultGFNIStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86GFNIProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ResultFixedVectorInputs(ins, form.x86PackedBinaryForm, false, state, owned, arch), true
+}
diff --git a/amd64_go_argument_alias_go122_test.go b/amd64_go_argument_alias_go122_test.go
new file mode 100644
index 000000000..e4113eb89
--- /dev/null
+++ b/amd64_go_argument_alias_go122_test.go
@@ -0,0 +1,141 @@
+//go:build go1.22
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/token"
+	"go/types"
+	"reflect"
+	"testing"
+)
+
+func amd64ArgumentAlias(typ types.Type, count int) types.Type {
+	for index := 0; index < count; index++ {
+		typ = types.NewAlias(types.NewTypeName(token.NoPos, nil, "Alias", nil), typ)
+	}
+	return typ
+}
+
+func amd64ArgumentAliasSignature(typ types.Type) *types.Signature {
+	return types.NewSignatureType(nil, nil, nil,
+		types.NewTuple(types.NewVar(token.NoPos, nil, "value", typ)), nil, false)
+}
+
+func TestAMD64GoArgumentPlanAliasesPreserveConcreteIdentity(t *testing.T) {
+	for _, count := range []int{1, 2, 32} {
+		typ := amd64ArgumentAlias(types.Typ[types.Uint32], count)
+		plan, err := planAMD64GoArguments(amd64ArgumentAliasSignature(typ))
+		if !amd64ArgumentAliasHasActualRHS(typ) {
+			if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("opaque alias acquired a concrete argument plan at depth %d: %#v, %v", count, plan, err)
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		argument := plan.Arguments[0]
+		if argument.Type != typ || argument.Stack || len(argument.Carriers) != 1 ||
+			argument.Carriers[0].Type != I32 || argument.Carriers[0].Width != 4 || argument.Carriers[0].Register != AX {
+			t.Fatalf("concrete alias/group identity was lost at depth %d: %#v", count, argument)
+		}
+	}
+	boolean := amd64ArgumentAlias(types.Typ[types.Bool], 2)
+	floating := amd64ArgumentAlias(types.Typ[types.Float32], 1)
+	aggregate := amd64ArgumentAlias(types.NewStruct([]*types.Var{
+		types.NewField(token.NoPos, nil, "B", boolean, false),
+		types.NewField(token.NoPos, nil, "F", floating, false),
+	}, nil), 2)
+	plan, err := planAMD64GoArguments(amd64ArgumentAliasSignature(aggregate))
+	if !amd64ArgumentAliasHasActualRHS(aggregate) {
+		if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("opaque alias descendants acquired concrete byte kinds: %#v, %v", plan, err)
+		}
+		return
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []amd64GoArgumentCarrier{
+		{Path: []int{0}, Offset: 0, Width: 1, Type: I1, Kind: amd64GoArgumentBoolean, Register: AX},
+		{Path: []int{1}, Offset: 4, Width: 4, Type: "float", Kind: amd64GoArgumentFloating, Register: "X0"},
+	}
+	if plan.Arguments[0].Type != aggregate || !reflect.DeepEqual(plan.Arguments[0].Carriers, want) {
+		t.Fatalf("alias descendants changed their concrete byte kinds: %#v", plan)
+	}
+}
+
+func TestAMD64GoArgumentPlanAliasesRejectUnresolvedAndUnboundedRHS(t *testing.T) {
+	parameter := types.NewTypeParam(types.NewTypeName(token.NoPos, nil, "T", nil), types.NewInterfaceType(nil, nil).Complete())
+	generic := types.NewNamed(types.NewTypeName(token.NoPos, nil, "Generic", nil), types.Typ[types.Uint64], nil)
+	generic.SetTypeParams([]*types.TypeParam{types.NewTypeParam(types.NewTypeName(token.NoPos, nil, "U", nil), types.NewInterfaceType(nil, nil).Complete())})
+	for _, test := range []struct {
+		name string
+		typ  types.Type
+	}{
+		{"type-parameter", amd64ArgumentAlias(parameter, 1)},
+		{"alias-of-alias-type-parameter", amd64ArgumentAlias(parameter, 2)},
+		{"generic-named-RHS", amd64ArgumentAlias(generic, 2)},
+		{"alias-depth", amd64ArgumentAlias(types.Typ[types.Uint64], 33)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			plan, err := planAMD64GoArguments(amd64ArgumentAliasSignature(test.typ))
+			if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unsupported alias RHS acquired a partial plan: %#v, %v", plan, err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentIssuerAliasesRetainResultBoundary(t *testing.T) {
+	for _, count := range []int{1, 2, 32} {
+		for _, scalar := range []types.Type{types.Typ[types.Bool], types.Typ[types.Uint8], types.Typ[types.Uint16],
+			types.Typ[types.Uint32], types.Typ[types.Uint64]} {
+			t.Run(fmt.Sprintf("%s/depth-%d", scalar, count), func(t *testing.T) {
+				input := amd64ArgumentEntryModel(t, "a float64")
+				result := amd64ArgumentAlias(scalar, count)
+				pkg := types.NewPackage(input.Package.Path(), input.Package.Name())
+				signature := types.NewSignatureType(nil, nil, nil,
+					input.Declaration.Type().(*types.Signature).Params(),
+					types.NewTuple(types.NewVar(token.NoPos, nil, "r", result)), false)
+				input.Declaration = types.NewFunc(token.NoPos, pkg, "Entry", signature)
+				pkg.Scope().Insert(input.Declaration)
+				input.Package = pkg
+				var err error
+				input.Signature, err = DeriveGoFuncABI0Signature(input.Native, input.Declaration, "amd64", types.SizesFor("gc", "amd64"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				language, err := numericalSDKDeclarationLanguage(input.Declaration, types.SizesFor("gc", "amd64"), true)
+				if !amd64ArgumentAliasHasActualRHS(result) {
+					if language != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("opaque scalar result alias acquired a language identity", language, err)
+					}
+					if plan, err := amd64GoArgumentEntryPlan(input); plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("opaque scalar result alias acquired an independent transport", plan, err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal("concrete scalar result alias lost its language identity", err)
+				}
+				if _, err := amd64GoArgumentEntryPlan(input); err != nil {
+					t.Fatal("concrete scalar result alias lost its independent transport", err)
+				}
+			})
+		}
+	}
+	for _, count := range []int{1, 2} {
+		calls := 0
+		result := amd64ArgumentAlias(&amd64ArgumentCallbackType{calls: &calls}, count)
+		signature := types.NewSignatureType(nil, nil, nil, nil,
+			types.NewTuple(types.NewVar(token.NoPos, nil, "r", result)), false)
+		function := types.NewFunc(token.NoPos, nil, "Entry", signature)
+		calls = 0 // Only issuer sampling, not fixture construction, is observed.
+		if _, err := numericalSDKDeclarationLanguage(function, types.SizesFor("gc", "amd64"), true); !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+			t.Fatalf("alias RHS reached caller type callbacks at depth %d: err=%v, calls=%d", count, err, calls)
+		}
+	}
+}
diff --git a/amd64_go_argument_alias_rhs_go122_test.go b/amd64_go_argument_alias_rhs_go122_test.go
new file mode 100644
index 000000000..bc888ffb6
--- /dev/null
+++ b/amd64_go_argument_alias_rhs_go122_test.go
@@ -0,0 +1,76 @@
+//go:build go1.22
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/token"
+	"go/types"
+	"testing"
+)
+
+// Go1.22 exposes Alias but not its immediate RHS. Underlying/Unalias cannot
+// replace the independently bounded complete chain observed by these roles.
+func amd64ArgumentAliasHasActualRHS(typ types.Type) bool {
+	_, available := typ.(interface{ Rhs() types.Type })
+	return goAMD64FrameIsAlias(typ) && available
+}
+
+func TestAMD64GoArgumentAliasConsumersRequireActualRHS(t *testing.T) {
+	sizes := types.SizesFor("gc", "amd64")
+	named := types.NewNamed(types.NewTypeName(token.NoPos, nil, "NamedWord", nil), types.Typ[types.Uint32], nil)
+	for _, count := range []int{1, 2, 32} {
+		for _, scalar := range []types.Type{types.Typ[types.Bool], types.Typ[types.Uint32],
+			types.Typ[types.Float32], types.Typ[types.Float64], named} {
+			t.Run(fmt.Sprintf("%s/depth-%d", scalar, count), func(t *testing.T) {
+				typ := amd64ArgumentAlias(scalar, count)
+				available := amd64ArgumentAliasHasActualRHS(typ)
+				check := func(role string, expectConcrete, complete bool, err error) {
+					t.Helper()
+					if expectConcrete {
+						if !complete || err != nil {
+							t.Fatal("actual concrete alias RHS was lost", role, complete, err)
+						}
+					} else if complete || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("alias acquired an unobserved or over-depth RHS contract", role, complete, err)
+					}
+				}
+				plan, err := planAMD64GoArguments(amd64ArgumentAliasSignature(typ))
+				check("argument layout", available, plan != nil, err)
+				// A language identity retains the Named node and its underlying
+				// node separately. After 32 aliases, the latter is depth 33;
+				// the argument layout's scalar shape does not add that node.
+				languageAvailable := available && (scalar != named || count < 32)
+				language, err := goAMD64LanguageTypeRole(typ, sizes, true, true)
+				check("argument language", languageAvailable, language != "", err)
+				language, err = goAMD64NumericalScalarLanguageType(typ, sizes, true)
+				check("ordinary numerical scalar language", languageAvailable, language != "", err)
+				if scalar == types.Typ[types.Float32] || scalar == types.Typ[types.Float64] {
+					if _, err := goAMD64FrameLanguageType(typ, sizes); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("alias API availability expanded the ordinary frame's floating role", err)
+					}
+				}
+			})
+		}
+	}
+	for _, count := range []int{1, 2, 32} {
+		t.Run(fmt.Sprintf("no-callback/depth-%d", count), func(t *testing.T) {
+			calls := 0
+			typ := amd64ArgumentAlias(&amd64ArgumentCallbackType{calls: &calls}, count)
+			calls = 0 // Fixture construction is not an observer or source capability.
+			plan, err := planAMD64GoArguments(amd64ArgumentAliasSignature(typ))
+			if plan != nil || !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+				t.Fatal("opaque argument alias invoked caller callbacks", plan, err, calls)
+			}
+			language, err := goAMD64LanguageTypeRole(typ, sizes, true, true)
+			if language != "" || !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+				t.Fatal("opaque argument language invoked caller callbacks", language, err, calls)
+			}
+			language, err = goAMD64NumericalScalarLanguageType(typ, sizes, true)
+			if language != "" || !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+				t.Fatal("opaque numerical scalar language invoked caller callbacks", language, err, calls)
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_binding.go b/amd64_go_argument_binding.go
new file mode 100644
index 000000000..aaf6f12e9
--- /dev/null
+++ b/amd64_go_argument_binding.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"go/types"
+	"reflect"
+)
+
+// Only a complete numerical source binder or the call-local GoModule issuer
+// creates this private token. It authenticates declared argument carriers,
+// not physical stack, closure, caller, call target, pointer extent or result
+// transport permissions.
+type amd64GoArgumentBinding struct {
+	identity    *amd64GoArgumentBinding
+	owner       *GoX86NumericalReadBinding
+	virtual     *amd64GoVirtualArguments
+	declaration *types.Func
+	symbol      string
+	signature   FuncSig
+	plan        *amd64GoArgumentPlan
+	seal        [32]byte
+}
+
+func (entry *amd64GoArgumentBinding) digest() ([32]byte, error) {
+	type argument struct {
+		Index    int
+		Carriers []amd64GoArgumentCarrier
+	}
+	var arguments []argument
+	if entry.plan != nil {
+		for _, input := range entry.plan.Arguments {
+			arguments = append(arguments, argument{input.Index, input.Carriers})
+		}
+	}
+	data, err := json.Marshal(struct {
+		Symbol    string
+		Signature FuncSig
+		Arguments []argument
+	}{entry.symbol, entry.signature, arguments})
+	return sha256.Sum256(data), err
+}
+
+func (entry *amd64GoArgumentBinding) valid(fn Func, sig FuncSig, arch string) bool {
+	if entry != nil && entry.virtual != nil {
+		if entry.identity != entry || entry.owner != nil || entry.declaration == nil || entry.plan == nil || entry.virtual.entries[sig.Name] != entry ||
+			entry.virtual.live() != nil || arch != "amd64" || fn.Sym != entry.symbol || fn.FrameSize != 0 ||
+			len(fn.X86RawText) != 0 || fn.x86FixedLocal != nil || fn.x86SourceStack != nil {
+			return false
+		}
+		return entry.matches(sig)
+	}
+	if entry == nil || entry.identity != entry || entry.owner == nil || arch != "amd64" || fn.Sym != entry.symbol ||
+		entry.owner.originalBinding != entry.owner || entry.owner.source == nil || entry.owner.source != entry.owner.originalSource ||
+		entry.declaration == nil || entry.plan == nil || entry.owner.originalTypes == nil ||
+		entry.owner.originalTypes.Scope().Lookup(entry.declaration.Name()) != entry.declaration ||
+		entry.owner.capabilities[sig.Name].arguments != entry || entry.owner.options.Sigs[sig.Name].amd64GoArguments != entry {
+		return false
+	}
+	source := entry.owner.source
+	source.mu.Lock()
+	ready := source.identity == source && source.ready && !source.revoked.Load()
+	source.mu.Unlock()
+	if !ready || fn.FrameSize != 0 || len(fn.X86RawText) != 0 || fn.x86FixedLocal != nil || fn.x86SourceStack != nil {
+		return false
+	}
+	return entry.matches(sig)
+}
+
+func (entry *amd64GoArgumentBinding) matches(sig FuncSig) bool {
+	// Feature references are rendered after the complete public options check.
+	// They are not part of a language argument's physical carrier assignment.
+	shape := numericalSignatureShape(sig)
+	shape.Attrs = entry.signature.Attrs
+	if !reflect.DeepEqual(shape, entry.signature) {
+		return false
+	}
+	declaration, valid := entry.declaration.Type().(*types.Signature)
+	if !valid {
+		return false
+	}
+	plan, err := planAMD64GoArguments(declaration)
+	if err != nil || plan.requireRegisters() != nil || !reflect.DeepEqual(plan, entry.plan) {
+		return false
+	}
+	for index, argument := range plan.Arguments {
+		if argument.Type != entry.plan.Arguments[index].Type {
+			return false
+		}
+	}
+	digest, err := entry.digest()
+	if entry.virtual != nil {
+		return err == nil && digest == entry.seal && entry.virtual.live() == nil
+	}
+	source := entry.owner.source
+	source.mu.Lock()
+	ready := source.identity == source && source.ready && !source.revoked.Load()
+	source.mu.Unlock()
+	return err == nil && digest == entry.seal && ready
+}
+
+func amd64GoArgumentInitialState(plan *amd64GoArgumentPlan) (x86ResultState, bool) {
+	var initial x86ResultState
+	if plan == nil || plan.requireRegisters() != nil {
+		return initial, false
+	}
+	for _, argument := range plan.Arguments {
+		for _, carrier := range argument.Carriers {
+			if carrier.Kind == amd64GoArgumentFloating {
+				index, valid := amd64ParseXReg(carrier.Register)
+				if !valid || index >= 15 || carrier.Width != 4 && carrier.Width != 8 {
+					return x86ResultState{}, false
+				}
+				initial.xmm[index] = uint16(1<<uint(carrier.Width)) - 1
+				continue
+			}
+			reg, mask, valid := x86ResultGP(carrier.Register, carrier.Width, "amd64")
+			if !valid || carrier.Register == DX {
+				return x86ResultState{}, false
+			}
+			switch carrier.Kind {
+			case amd64GoArgumentPointer:
+				initial.pointerGP[reg], initial.callerAddressGP[reg] = true, true
+			case amd64GoArgumentBoolean:
+				initial.gp[reg], initial.canonicalGP[reg] = mask, mask
+			case amd64GoArgumentInteger:
+				initial.gp[reg] = mask
+			default:
+				return x86ResultState{}, false
+			}
+		}
+	}
+	return initial, true
+}
diff --git a/amd64_go_argument_compiler_fixture_test.go b/amd64_go_argument_compiler_fixture_test.go
new file mode 100644
index 000000000..222e6674e
--- /dev/null
+++ b/amd64_go_argument_compiler_fixture_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"encoding/hex"
+	"fmt"
+	"go/format"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type amd64ArgumentOracleCarrier struct {
+	parameter string
+	offset    int64
+	register  Reg
+	width     int64
+}
+
+type amd64ArgumentOracleFixture struct {
+	name, parameters, arguments string
+	carriers                    []amd64ArgumentOracleCarrier
+}
+
+func amd64ArgumentOracleFixtures() []amd64ArgumentOracleFixture {
+	fixtures := []amd64ArgumentOracleFixture{
+		{"Strings", "a,b string", "a,b", []amd64ArgumentOracleCarrier{
+			{"a", 0, AX, 8}, {"a", 8, BX, 8}, {"b", 0, CX, 8}, {"b", 8, DI, 8},
+		}},
+		{"Slices", "a,b []byte", "a,b", []amd64ArgumentOracleCarrier{
+			{"a", 0, AX, 8}, {"a", 8, BX, 8}, {"a", 16, CX, 8},
+			{"b", 0, DI, 8}, {"b", 8, SI, 8}, {"b", 16, "R8", 8},
+		}},
+		{"Mixed", "f float64,a byte,b bool,c float32,d uint16,p *byte", "f,a,b,c,d,p", []amd64ArgumentOracleCarrier{
+			{"f", 0, "X0", 8}, {"a", 0, AX, 1}, {"b", 0, BX, 1},
+			{"c", 0, "X1", 4}, {"d", 0, CX, 2}, {"p", 0, DI, 8},
+		}},
+		{"Nested", "a struct { B byte; F [1]float32; N uint16 },last uint64", "a,last", []amd64ArgumentOracleCarrier{
+			{"a", 0, AX, 1}, {"a", 4, "X0", 4}, {"a", 8, BX, 2}, {"last", 0, CX, 8},
+		}},
+		{"Widths", "a byte,b uint16,c uint32,d uint64,e bool,f float32,g float64", "a,b,c,d,e,f,g", []amd64ArgumentOracleCarrier{
+			{"a", 0, AX, 1}, {"b", 0, BX, 2}, {"c", 0, CX, 4}, {"d", 0, DI, 8},
+			{"e", 0, SI, 1}, {"f", 0, "X0", 4}, {"g", 0, "X1", 8},
+		}},
+	}
+	gp := []Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"}
+	for _, bank := range []string{"GP", "FP"} {
+		fixture := amd64ArgumentOracleFixture{name: bank + "Bank"}
+		count, typ, width := 9, "uint64", int64(8)
+		if bank == "FP" {
+			count, typ = 15, "float64"
+		}
+		var parameters, arguments []string
+		for index := 0; index < count; index++ {
+			name := fmt.Sprintf("a%d", index)
+			parameters = append(parameters, name+" "+typ)
+			arguments = append(arguments, name)
+			register := Reg(fmt.Sprintf("X%d", index))
+			if bank == "GP" {
+				register = gp[index]
+			}
+			fixture.carriers = append(fixture.carriers, amd64ArgumentOracleCarrier{name, 0, register, width})
+		}
+		fixture.parameters, fixture.arguments = strings.Join(parameters, ","), strings.Join(arguments, ",")
+		fixtures = append(fixtures, fixture)
+		rollback := fixture
+		rollback.name, rollback.carriers = bank+"Rollback", append([]amd64ArgumentOracleCarrier(nil), fixture.carriers[:count-1]...)
+		parameters, arguments = parameters[:count-1], arguments[:count-1]
+		if bank == "GP" {
+			parameters = append(parameters, "spilled struct { F float64; A,B uint64 }", "next float64", "last uint64")
+			arguments = append(arguments, "spilled", "next", "last")
+			rollback.carriers = append(rollback.carriers, amd64ArgumentOracleCarrier{"next", 0, "X0", 8}, amd64ArgumentOracleCarrier{"last", 0, "R11", 8})
+		} else {
+			parameters = append(parameters, "spilled struct { P *byte; Z complex128 }", "next uint64", "last float64")
+			arguments = append(arguments, "spilled", "next", "last")
+			rollback.carriers = append(rollback.carriers, amd64ArgumentOracleCarrier{"next", 0, AX, 8}, amd64ArgumentOracleCarrier{"last", 0, "X14", 8})
+		}
+		rollback.parameters, rollback.arguments = strings.Join(parameters, ","), strings.Join(arguments, ",")
+		fixtures = append(fixtures, rollback)
+	}
+	return fixtures
+}
+
+func amd64ArgumentOracleSource(fixtures []amd64ArgumentOracleFixture) ([]byte, error) {
+	var source strings.Builder
+	source.WriteString("package carrieroracle\n")
+	for _, fixture := range fixtures {
+		fmt.Fprintf(&source, "//go:noinline\nfunc Target%s(%s) uint64 { return 1 }\n", fixture.name, fixture.parameters)
+		fmt.Fprintf(&source, "//go:noinline\nfunc Caller%s(%s) uint64 { return Target%s(%s) }\n", fixture.name, fixture.parameters, fixture.name, fixture.arguments)
+	}
+	return format.Source([]byte(source.String()))
+}
+
+type amd64ArgumentCompilerFunction struct {
+	spills []amd64ArgumentOracleCarrier
+	code   []byte
+	calls  map[string]int64
+}
+
+var (
+	amd64ArgumentCompilerText  = regexp.MustCompile(`\bTEXT\s+([^\s(]+)\(SB\),\s+([A-Za-z0-9_|]+),`)
+	amd64ArgumentCompilerStore = regexp.MustCompile(`\b(MOVB|MOVW|MOVL|MOVQ|MOVSS|MOVSD)\s+([A-Z0-9]+),\s+[^\s,]+\.([A-Za-z][A-Za-z0-9_]*)\+(-?[0-9]+)\((?:SP|FP)\)`)
+	amd64ArgumentCompilerBytes = regexp.MustCompile(`^\s+0x([0-9a-f]+)\s+((?:[0-9a-f]{2} ){1,16})`)
+	amd64ArgumentCompilerCall  = regexp.MustCompile(`^\s+rel ([0-9]+)\+4 t=R_CALL ([^\s+]+)\+0\s*$`)
+)
+
+// This test-only listing reader observes receiving spill stores, not actual
+// incoming stack arguments or a public storage/entry certificate. -N/-l are
+// confined to the independent ordinary compiler fixture, never the SDK profile.
+func amd64ArgumentCompilerFunctions(listing []byte) (map[string]*amd64ArgumentCompilerFunction, error) {
+	if len(listing) == 0 || len(listing) > 32<<20 {
+		return nil, fmt.Errorf("missing/oversized compiler listing")
+	}
+	functions := make(map[string]*amd64ArgumentCompilerFunction)
+	var current *amd64ArgumentCompilerFunction
+	for _, line := range strings.Split(string(listing), "\n") {
+		if row := amd64ArgumentCompilerText.FindStringSubmatch(line); row != nil {
+			flags := make(map[string]bool)
+			for _, flag := range strings.Split(row[2], "|") {
+				if flags[flag] {
+					return nil, fmt.Errorf("duplicate compiler TEXT flag")
+				}
+				flags[flag] = true
+				switch flag {
+				case "ABIInternal", "NOSPLIT", "NOFRAME", "DUPOK":
+				default:
+					return nil, fmt.Errorf("unregistered compiler TEXT flag %s", flag)
+				}
+			}
+			if !flags["ABIInternal"] {
+				return nil, fmt.Errorf("compiler argument fixture has a non-ABIInternal entry")
+			}
+			if functions[row[1]] != nil || len(functions) >= 256 {
+				return nil, fmt.Errorf("duplicate/oversized compiler TEXT inventory")
+			}
+			current = &amd64ArgumentCompilerFunction{calls: make(map[string]int64)}
+			functions[row[1]] = current
+		} else if len(line) != 0 && line[0] != ' ' && line[0] != '\t' {
+			current = nil // A new named data or TEXT record, not the prior body.
+		}
+		if current == nil {
+			continue
+		}
+		if row := amd64ArgumentCompilerStore.FindStringSubmatch(line); row != nil {
+			register := Reg(row[2])
+			if base, valid := amd64FullRegBase(register); valid {
+				register = base
+			}
+			offset, err := strconv.ParseInt(row[4], 10, 64)
+			if err != nil || len(current.spills) >= 4096 {
+				return nil, fmt.Errorf("invalid compiler argument store")
+			}
+			width := map[string]int64{"MOVB": 1, "MOVW": 2, "MOVL": 4, "MOVQ": 8, "MOVSS": 4, "MOVSD": 8}[row[1]]
+			current.spills = append(current.spills, amd64ArgumentOracleCarrier{row[3], offset, register, width})
+		}
+		if row := amd64ArgumentCompilerBytes.FindStringSubmatch(line); row != nil {
+			offset, err := strconv.ParseInt(row[1], 16, 64)
+			bytes, decode := hex.DecodeString(strings.ReplaceAll(row[2], " ", ""))
+			if err != nil || decode != nil || offset != int64(len(current.code)) || len(current.code) > 1<<20 {
+				return nil, fmt.Errorf("noncontiguous compiler code")
+			}
+			current.code = append(current.code, bytes...)
+		}
+		if row := amd64ArgumentCompilerCall.FindStringSubmatch(line); row != nil {
+			offset, err := strconv.ParseInt(row[1], 10, 64)
+			if _, duplicate := current.calls[row[2]]; err != nil || duplicate {
+				return nil, fmt.Errorf("duplicate/invalid compiler call")
+			}
+			current.calls[row[2]] = offset
+		}
+	}
+	return functions, nil
+}
diff --git a/amd64_go_argument_compiler_go127_test.go b/amd64_go_argument_compiler_go127_test.go
new file mode 100644
index 000000000..8f58ec5c4
--- /dev/null
+++ b/amd64_go_argument_compiler_go127_test.go
@@ -0,0 +1,119 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestAMD64GoArgumentCompilerCallsiteBanksAndWidths(t *testing.T) {
+	fixtures := amd64ArgumentOracleFixtures()
+	source, err := amd64ArgumentOracleSource(fixtures)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "arguments.go"), filepath.Join(directory, "arguments.o")
+	if err := os.WriteFile(input, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, binary, "tool", "compile", "-N", "-l", "-S", "-p", "example.invalid/carrieroracle", "-o", object, input)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "GOAMD64=v1", "GOEXPERIMENT=", "GOFLAGS=", "GOENV=off", "GOWORK=off", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	stdout, stderr, err := runtimeOracleMachineOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual independent ordinary compiler fixture: %v\n%s\n%s", err, stdout, stderr)
+	}
+	listing := append(append([]byte(nil), stdout...), stderr...)
+	functions, err := amd64ArgumentCompilerFunctions(listing)
+	if err != nil {
+		t.Fatalf("complete actual compiler listing: %v\n%s", err, listing)
+	}
+	compiled, err := os.ReadFile(object)
+	if err != nil || len(compiled) == 0 {
+		t.Fatal("missing complete actual compiler object", err)
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, input, source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check("example.invalid/carrieroracle", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fixture := range fixtures {
+		t.Run(fixture.name, func(t *testing.T) {
+			name := "example.invalid/carrieroracle.Target" + fixture.name
+			target, caller := functions[name], functions["example.invalid/carrieroracle.Caller"+fixture.name]
+			if target == nil || caller == nil || len(target.code) == 0 || len(caller.code) == 0 ||
+				!bytes.Contains(compiled, target.code) || !bytes.Contains(compiled, caller.code) {
+				t.Fatalf("original named ABIInternal compiler bodies/code are absent\n%s", listing)
+			}
+			call, found := caller.calls[name]
+			if !found || call < 1 || call > int64(len(caller.code))-4 || caller.code[call-1] != 0xe8 {
+				t.Fatal("ordinary original caller lost its unique actual E8/R_CALL target")
+			}
+			got := append([]amd64ArgumentOracleCarrier(nil), target.spills...)
+			bases := make(map[string]int64)
+			for _, spill := range got {
+				base, found := bases[spill.parameter]
+				if !found || spill.offset < base {
+					bases[spill.parameter] = spill.offset
+				}
+			}
+			for index := range got {
+				got[index].offset -= bases[got[index].parameter]
+			}
+			if !reflect.DeepEqual(got, fixture.carriers) {
+				t.Fatalf("independent actual incoming register spill observations\n got %#v\nwant %#v\n%s", got, fixture.carriers, listing)
+			}
+			sig := pkg.Scope().Lookup("Target" + fixture.name).Type().(*types.Signature)
+			plan, err := planAMD64GoArguments(sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var modeled []amd64ArgumentOracleCarrier
+			for _, argument := range plan.Arguments {
+				for _, carrier := range argument.Carriers {
+					modeled = append(modeled, amd64ArgumentOracleCarrier{sig.Params().At(argument.Index).Name(), carrier.Offset, carrier.Register, carrier.Width})
+				}
+			}
+			if !reflect.DeepEqual(modeled, fixture.carriers) {
+				t.Fatalf("compiler-independent parameter grouping/bank/width matrix differs: %#v", modeled)
+			}
+			t.Logf("actual original ABIInternal target=%s receivingStores=%+v uniqueE8CallOffset=%d callerCodeSHA=%x targetCodeSHA=%x; no incoming stack/carrier permission", name, got, call, sha256.Sum256(caller.code), sha256.Sum256(target.code))
+			if strings.Contains(fixture.name, "Rollback") && plan.requireRegisters() == nil {
+				t.Fatal("oracle spill observations became a register-only entry permission")
+			}
+		})
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(source) {
+		t.Fatal("original ordinary fixture changed", err)
+	}
+	t.Logf("complete original ordinary fixture: %d source functions, %d observed compiler TEXTs, sourceSHA=%x objectSHA=%x; receiving spill stores are NOT incoming stack authority", 2*len(fixtures), len(functions), sha256.Sum256(source), sha256.Sum256(compiled))
+}
diff --git a/amd64_go_argument_compiler_model_test.go b/amd64_go_argument_compiler_model_test.go
new file mode 100644
index 000000000..1d97ff2c5
--- /dev/null
+++ b/amd64_go_argument_compiler_model_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64GoArgumentCompilerFixtureAndListingGuards(t *testing.T) {
+	fixtures := amd64ArgumentOracleFixtures()
+	source, err := amd64ArgumentOracleSource(fixtures)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "arguments.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check("example.invalid/carrieroracle", fset, []*ast.File{file}, nil)
+	if err != nil || len(fixtures) != 9 || len(pkg.Scope().Names()) != 18 {
+		t.Fatal("whole independent ordinary fixture inventory", err)
+	}
+	for _, fixture := range fixtures {
+		t.Run("independent-matrix/"+fixture.name, func(t *testing.T) {
+			sig := pkg.Scope().Lookup("Target" + fixture.name).Type().(*types.Signature)
+			plan, err := planAMD64GoArguments(sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var got []amd64ArgumentOracleCarrier
+			for _, argument := range plan.Arguments {
+				for _, carrier := range argument.Carriers {
+					got = append(got, amd64ArgumentOracleCarrier{sig.Params().At(argument.Index).Name(), carrier.Offset, carrier.Register, carrier.Width})
+				}
+			}
+			if !reflect.DeepEqual(got, fixture.carriers) {
+				t.Fatalf("independent ordinary matrix: %#v != %#v", got, fixture.carriers)
+			}
+			if strings.Contains(fixture.name, "Rollback") && plan.requireRegisters() == nil {
+				t.Fatal("compiler oracle enabled incoming spill storage")
+			}
+		})
+	}
+	// Synthetic parser controls never become source/compiler/entry authority.
+	const listing = "target STEXT size=1\n\t0x0000 00000 TEXT target(SB), ABIInternal, $0-8\n\t0x0000 00000 MOVB AL, fixture.a+16(SP)\n\t0x0000 c3 \ncaller STEXT size=6\n\t0x0000 00000 TEXT caller(SB), ABIInternal, $0-8\n\t0x0000 e8 00 00 00 00 c3 \n\trel 1+4 t=R_CALL target+0\n"
+	observed, err := amd64ArgumentCompilerFunctions([]byte(listing))
+	if err != nil || len(observed) != 2 || len(observed["target"].spills) != 1 || observed["target"].spills[0].register != AX || observed["caller"].calls["target"] != 1 {
+		t.Fatal("complete compiler parser model", err)
+	}
+	for _, flags := range []string{"NOSPLIT|ABIInternal", "ABIInternal|NOSPLIT", "DUPOK|NOSPLIT|NOFRAME|ABIInternal"} {
+		withFlags := strings.Replace(listing, "TEXT target(SB), ABIInternal,", "TEXT target(SB), "+flags+",", 1)
+		if functions, err := amd64ArgumentCompilerFunctions([]byte(withFlags)); err != nil || len(functions) != 2 || functions["target"] == nil {
+			t.Errorf("compiler TEXT flags lost an original ABIInternal target (%s): %v", flags, err)
+		}
+	}
+	for name, invalid := range map[string]string{
+		"duplicate-flags": strings.Replace(listing, "TEXT target(SB), ABIInternal,", "TEXT target(SB), ABIInternal|ABIInternal,", 1),
+		"unknown-flags":   strings.Replace(listing, "TEXT target(SB), ABIInternal,", "TEXT target(SB), ABIInternal|UNKNOWN,", 1),
+		"ABI0":            strings.Replace(listing, "TEXT target(SB), ABIInternal,", "TEXT target(SB), ABI0,", 1),
+		"duplicate-TEXT":  listing + "\t0x0000 00000 TEXT target(SB), ABIInternal, $0-8\n",
+		"code-hole":       strings.Replace(listing, "0x0000 c3", "0x0001 c3", 1),
+		"duplicate-call":  listing + "\trel 1+4 t=R_CALL target+0\n",
+		"empty":           "",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := amd64ArgumentCompilerFunctions([]byte(invalid)); err == nil {
+				t.Fatal("partial/ambiguous compiler listing was accepted")
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_consumer_test.go b/amd64_go_argument_consumer_test.go
new file mode 100644
index 000000000..7afdd4337
--- /dev/null
+++ b/amd64_go_argument_consumer_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Deliberately synthetic private comparison state. Public consumers below
+// reject it: it has no live tool/source guard, archive or compiler producer.
+func amd64ArgumentBoundModel(t *testing.T, parameters, body string, result ...types.Type) (Func, FuncSig, *amd64GoArgumentBinding) {
+	t.Helper()
+	input := amd64ArgumentEntryModel(t, parameters)
+	if len(result) == 1 {
+		pkg := types.NewPackage(input.Package.Path(), input.Package.Name())
+		sig := types.NewSignatureType(nil, nil, nil, input.Declaration.Type().(*types.Signature).Params(),
+			types.NewTuple(types.NewVar(token.NoPos, nil, "", result[0])), false)
+		input.Package = pkg
+		input.Declaration = types.NewFunc(token.NoPos, pkg, "Entry", sig)
+		pkg.Scope().Insert(input.Declaration)
+		var err error
+		input.Signature, err = DeriveGoFuncABI0Signature(input.Native, input.Declaration, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	plan, err := amd64GoArgumentEntryPlan(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·Entry<ABIInternal>(SB),4,$0-128\n"+body+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoX86NumericalReadSource{ready: true}
+	source.identity = source
+	owner := &GoX86NumericalReadBinding{source: source, originalSource: source, originalTypes: input.Package,
+		options: Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: make(map[string]FuncSig)}}
+	owner.originalBinding = owner
+	entry := &amd64GoArgumentBinding{owner: owner, declaration: input.Declaration, symbol: file.Funcs[0].Sym, signature: input.Signature, plan: plan}
+	entry.identity = entry
+	entry.seal, err = entry.digest()
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := input.Signature
+	sig.amd64GoArguments = entry
+	owner.options.Sigs[sig.Name] = sig
+	owner.capabilities = numericalCapabilities(owner.options.Sigs)
+	return file.Funcs[0], sig, entry
+}
+
+func TestAMD64GoArgumentEntryDeclaredBytesAndConsumerRevocation(t *testing.T) {
+	input := amd64ArgumentEntryModel(t, "a byte, b bool, p *byte, f float32, d float64")
+	plan, err := amd64GoArgumentEntryPlan(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	state, valid := amd64GoArgumentInitialState(plan)
+	if !valid || state.gp[0] != 1 || state.gp[3] != 1 || state.canonicalGP[3] != 1 ||
+		!state.pointerGP[1] || !state.callerAddressGP[1] || state.gp[1] != 0 ||
+		state.xmm[0] != 0xf || state.xmm[1] != 0xff || state.gp[2] != 0 || state.pointerGP[2] ||
+		len(state.fp) != 0 || len(state.auto) != 0 || state.flags != 0 {
+		t.Fatalf("entry gained upper bytes, native backing, DX, FLAGS or stack facts: %#v", state)
+	}
+	for _, test := range []struct {
+		name, parameters, body string
+		accept                 bool
+	}{
+		{"slice-length", "a []byte", "MOVQ BX,AX", true},
+		{"string-length", "a string", "MOVQ BX,AX", true},
+		{"float64-bits", "a float64", "MOVQ X0,AX", true},
+		{"integer32-overwrite", "a uint32", "MOVL AX,AX", true},
+		{"bool-byte", "a bool", "MOVBQZX AL,AX", true},
+		{"unknown-byte-upper", "a byte", "MOVQ AX,AX", false},
+		{"unknown-float-upper", "a float32", "MOVQ X0,AX", false},
+		{"pointer-not-numeric", "a *byte", "MOVQ AX,AX", false},
+		{"unknown-DX-closure", "a []byte", "MOVQ 8(DX),AX", false},
+		{"unknown-stack", "a []byte", "MOVQ (SP),AX", false},
+		{"no-ABI0-parameter-home", "a []byte", "MOVQ a+0(FP),AX", false},
+		{"unknown-FLAGS", "a bool", "SETEQ AL\nMOVBQZX AL,AX", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			fn, sig, _ := amd64ArgumentBoundModel(t, test.parameters, test.body)
+			err := checkAMD64RegisterResultInitialization(fn, sig,
+				func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+					return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+				})
+			if test.accept && err != nil || !test.accept && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("declared-byte-only result proof: %v", err)
+			}
+		})
+	}
+	for _, name := range []string{"closed", "revoked-restored", "copied-token", "signature", "original-type", "carrier", "capability", "frame"} {
+		t.Run(name, func(t *testing.T) {
+			fn, sig, entry := amd64ArgumentBoundModel(t, "a string", "MOVQ BX,AX")
+			if !entry.valid(fn, sig, "amd64") {
+				t.Fatal("complete private comparison model was not usable")
+			}
+			switch name {
+			case "closed":
+				entry.owner.source.ready = false
+			case "revoked-restored":
+				entry.owner.source.revoked.Store(true)
+				entry.owner.source.ready = true
+			case "copied-token":
+				copied := *entry
+				entry = &copied
+			case "signature":
+				sig.Args = []LLVMType{I64}
+			case "original-type":
+				entry.plan.Arguments[0].Type = nil
+			case "carrier":
+				entry.plan.Arguments[0].Carriers[1].Register = DX
+			case "capability":
+				entry.owner.capabilities = nil
+			case "frame":
+				fn.FrameSize = 8
+			}
+			if entry.valid(fn, sig, "amd64") {
+				t.Fatal("changed/revoked private argument association survived")
+			}
+		})
+	}
+	for _, test := range []struct {
+		body   string
+		accept bool
+	}{{"MOVB AL,AL", true}, {"XORL AX,AX", true}, {"MOVB $2,AL", false}} {
+		t.Run("bool-result/"+test.body, func(t *testing.T) {
+			fn, sig, _ := amd64ArgumentBoundModel(t, "a bool", test.body, types.Typ[types.Bool])
+			ctx := newX86Ctx(new(strings.Builder), fn, sig, nil, nil, "amd64", "x86_64-unknown-linux-gnu", false)
+			err := ctx.scalarFPResultInitialized()
+			if test.accept && err != nil || !test.accept && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("argument role widened canonical bool result", err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentEntryEmissionUsesGroupedIndependentBanks(t *testing.T) {
+	fn, sig, _ := amd64ArgumentBoundModel(t, "f float64, a struct { N byte; V [1]float32 }, b bool, s string",
+		"MOVBQZX AL,AX\nMOVBQZX BL,BX\nMOVQ CX,CX\nMOVQ DI,DI\nMOVQ X0,R8\nMOVL X1,R9\nMOVQ $1,AX")
+	var output strings.Builder
+	ctx := newX86Ctx(&output, fn, sig, nil, nil, "amd64", "x86_64-unknown-linux-gnu", false)
+	if err := ctx.emitAMD64GoArguments(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("prologue bypassed whole-source proof", err)
+	}
+	if err := ctx.scalarFPResultInitialized(); err != nil {
+		t.Fatal("complete typed argument source proof", err)
+	}
+	if err := ctx.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	ir := output.String()
+	for _, fragment := range []string{
+		"bitcast double %arg0 to i64", "extractvalue { i8, [1 x float] } %arg1, 0",
+		"extractvalue { i8, [1 x float] } %arg1, 1, 0", "zext i1 %arg2 to i64",
+		"extractvalue { ptr, i64 } %arg3, 0", "extractvalue { ptr, i64 } %arg3, 1",
+		"ptr %reg_AX", "ptr %reg_BX", "ptr %reg_CX", "ptr %reg_DI", "ptr %x0", "ptr %x1",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Errorf("missing grouped carrier %q in\n%s", fragment, ir)
+		}
+	}
+	if strings.Contains(ir, "DX") || strings.Contains(ir, "inbounds") || strings.Contains(ir, "noalias") {
+		t.Fatal("argument emission invented hidden/backing/alias authority", ir)
+	}
+}
+
+func TestAMD64GoArgumentEntryPublicConsumersRequireLiveBinding(t *testing.T) {
+	fn, sig, _ := amd64ArgumentBoundModel(t, "a string", "MOVQ BX,AX")
+	file := &File{Arch: ArchAMD64, Funcs: []Func{fn}}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(string) string { return sig.Name }, Sigs: map[string]FuncSig{sig.Name: sig}}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			var err error
+			switch api {
+			case "text":
+				_, err = Translate(file, options)
+			case "module":
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, failure := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					module.Dispose()
+				}
+				err = failure
+			case "Go":
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, failure := translateGoModuleInContext(context, GoPackage{Path: sig.amd64GoArguments.declaration.Pkg().Path(), Types: sig.amd64GoArguments.declaration.Pkg()},
+					[]byte("TEXT ·Entry<ABIInternal>(SB),4,$0-24\nMOVQ BX,AX\nRET\n"), GoModuleOptions{GOARCH: "amd64", TargetTriple: options.TargetTriple,
+						ResolveSym: options.ResolveSym, ManualSig: func(string) (FuncSig, bool) { return sig, true }})
+				if module != nil && !module.Module.IsNil() {
+					module.Module.Dispose()
+				}
+				err = failure
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s borrowed a private comparison model without live original compiler/source proof: %v", api, err)
+			}
+		})
+	}
+	t.Run("no-direct-module-bypass", func(t *testing.T) {
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err := translateModuleDirectInContext(context, file, options)
+		if !module.IsNil() {
+			module.Dispose()
+		}
+		if !errors.Is(err, errDirectModuleUnsupported) {
+			t.Fatal("linear module path bypassed typed whole-source proof", err)
+		}
+	})
+	clone, err := numericalCloneSignatures(options.Sigs)
+	if err != nil || clone[sig.Name].amd64GoArguments != sig.amd64GoArguments ||
+		!reflect.DeepEqual(numericalSignatureShape(clone[sig.Name]), numericalSignatureShape(sig)) {
+		t.Fatal("owned private identity and language shape were confused", fmt.Sprint(err))
+	}
+}
diff --git a/amd64_go_argument_emit.go b/amd64_go_argument_emit.go
new file mode 100644
index 000000000..dba3d38c6
--- /dev/null
+++ b/amd64_go_argument_emit.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) emitAMD64GoArguments() error {
+	entry := c.sig.amd64GoArguments
+	if entry != nil && entry.virtual != nil {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if entry == nil || !entry.valid(c.fpScalarSource, c.sig, c.goarch) || !c.fpScalarChecked || c.fpScalarCheckErr != nil {
+		return amd64GoArgumentContext("entry emission lacks its complete live source-byte proof")
+	}
+	for _, argument := range entry.plan.Arguments {
+		for _, carrier := range argument.Carriers {
+			value := fmt.Sprintf("%%arg%d", argument.Index)
+			if len(carrier.Path) != 0 {
+				var path []string
+				for _, field := range carrier.Path {
+					path = append(path, fmt.Sprint(field))
+				}
+				temporary := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %s\n", temporary, c.sig.Args[argument.Index], value, strings.Join(path, ", "))
+				value = "%" + temporary
+			}
+			if carrier.Kind != amd64GoArgumentFloating {
+				slot, used := c.regSlot[carrier.Register]
+				if !used {
+					continue
+				}
+				integer, valid, err := amd64ValueAsI64(c, carrier.Type, value)
+				if err != nil || !valid {
+					return amd64GoArgumentContext("declared GP carrier lost its LLVM scalar transport")
+				}
+				fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", integer, slot)
+				continue
+			}
+			index, valid := amd64ParseXReg(carrier.Register)
+			if !valid {
+				return amd64GoArgumentContext("invalid declared FP carrier")
+			}
+			if _, used := c.xRegSlot[index]; !used {
+				continue
+			}
+			bits := carrier.Width * 8
+			integer, lane, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", integer, carrier.Type, value, bits)
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %%%s, i32 0\n", lane, 128/bits, bits, bits, integer)
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, 128/bits, bits, lane)
+			if err := c.storeX(carrier.Register, "%"+bytes); err != nil {
+				return err
+			}
+		}
+	}
+	// The virtual slots use a deterministic representative for unused bytes.
+	// The complete source proof initialized only each declared scalar width,
+	// never the representative upper GP/X bytes or the native ABI spill homes.
+	return nil
+}
diff --git a/amd64_go_argument_entry.go b/amd64_go_argument_entry.go
new file mode 100644
index 000000000..9ecd4a708
--- /dev/null
+++ b/amd64_go_argument_entry.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// This comparison model cannot create a binding or source token. The live
+// factory supplies its complete original type graph and independently observed
+// assembler definition, after verifying the registered compiler ABI rules.
+type amd64GoArgumentEntryInput struct {
+	Package                        *types.Package
+	Declaration                    *types.Func
+	Signature                      FuncSig
+	Native, Target, Goarch         string
+	GOAMD64, GOEXPERIMENT, GOFLAGS string
+	SymABI                         []byte
+	Original, Expanded             gostaticstorage.TextRecord
+	Aliases                        *numericalCompilerAliasDirectory
+	Standard                       bool
+}
+
+func amd64GoArgumentEntryPlan(input amd64GoArgumentEntryInput) (*amd64GoArgumentPlan, error) {
+	fail := func() (*amd64GoArgumentPlan, error) {
+		return nil, amd64GoArgumentContext("original declaration/compiler ABI/profile association differs")
+	}
+	fn, pkg := input.Declaration, input.Package
+	if pkg == nil || fn == nil || fn.Pkg() != pkg || pkg.Scope().Lookup(fn.Name()) != fn ||
+		input.Goarch != "amd64" || !strings.HasSuffix(input.Target, "/amd64") || numericalSDKTargetTriple(input.Target) == "" ||
+		input.GOAMD64 != "v1" || input.GOEXPERIMENT != "" || input.GOFLAGS != "" {
+		return fail()
+	}
+	declaration, valid := fn.Type().(*types.Signature)
+	if !valid {
+		return fail()
+	}
+	plan, err := planAMD64GoArguments(declaration)
+	if err != nil || plan.requireRegisters() != nil {
+		return fail() // Neither actual stack arguments nor reserved spill homes.
+	}
+	if declaration.Results().Len() != 1 {
+		return fail()
+	}
+	resultBuilder := amd64GoArgumentBuilder{sizes: types.SizesFor("gc", "amd64")}
+	result, err := resultBuilder.shape(declaration.Results().At(0).Type(), 0)
+	if err != nil || result.stack || len(result.leaves) != 1 || len(result.leaves[0].Path) != 0 ||
+		(result.leaves[0].Kind != amd64GoArgumentInteger && result.leaves[0].Kind != amd64GoArgumentBoolean) {
+		return fail() // LLVM flattening is not a scalar Go result declaration.
+	}
+	expected, err := DeriveGoFuncABI0Signature(input.Native, fn, "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil || !reflect.DeepEqual(numericalSignatureShape(input.Signature), expected) || len(expected.Frame.Results) != 1 {
+		return fail()
+	}
+	switch expected.Ret {
+	case I1, I8, I16, I32, I64:
+	default:
+		return fail() // Results retain their independently closed existing role.
+	}
+	if input.Native != gosym.PackagePrefix(pkg.Path())+"."+fn.Name() &&
+		(input.Aliases == nil || input.Aliases.association(input.Native, 1, input.Standard) != nil) {
+		return fail()
+	}
+	if !amd64GoArgumentDefinition(input.SymABI, input.Native) {
+		return fail()
+	}
+	original := input.Original
+	if original.Name != input.Native || original.ABI != 1 || original.Kind != 1 ||
+		original.Namespace != gostaticstorage.TextSymbolNonpkgDefinition || original.Size <= 0 ||
+		original.Size != int64(len(original.Code)) || !reflect.DeepEqual(original, input.Expanded) {
+		return fail()
+	}
+	return plan, nil
+}
+
+func amd64GoArgumentDefinition(symABI []byte, native string) bool {
+	if len(symABI) == 0 || len(symABI) > 16<<20 || native == "" {
+		return false
+	}
+	definitions := make(map[string]bool)
+	found := false
+	for _, line := range strings.Split(string(symABI), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) != 3 || fields[0] != "def" && fields[0] != "ref" ||
+			fields[2] != "ABI0" && fields[2] != "ABIInternal" {
+			return false
+		}
+		if fields[0] != "def" {
+			continue
+		}
+		if definitions[fields[1]] || len(definitions) >= gostaticstorage.ObjectSymbolInventoryLimit {
+			return false
+		}
+		definitions[fields[1]] = true
+		if fields[1] == native {
+			found = fields[2] == "ABIInternal"
+		}
+	}
+	return found
+}
diff --git a/amd64_go_argument_entry_test.go b/amd64_go_argument_entry_test.go
new file mode 100644
index 000000000..f0612e95c
--- /dev/null
+++ b/amd64_go_argument_entry_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This is an independent comparison model, not a live compiler/source token.
+func amd64ArgumentEntryModel(t *testing.T, parameters string) amd64GoArgumentEntryInput {
+	t.Helper()
+	typed := amd64ArgumentTestSignature(t, parameters)
+	pkg := types.NewPackage("example.invalid/carriers", "carriers")
+	fn := types.NewFunc(token.NoPos, pkg, "Entry", typed)
+	pkg.Scope().Insert(fn)
+	native := pkg.Path() + ".Entry"
+	sig, err := DeriveGoFuncABI0Signature(native, fn, "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := gostaticstorage.TextRecord{Name: native, ABI: 1, Kind: 1,
+		Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Size: 1, Code: []byte{0xc3}}
+	return amd64GoArgumentEntryInput{Package: pkg, Declaration: fn, Signature: sig,
+		Native: native, Target: "linux/amd64", Goarch: "amd64", GOAMD64: "v1", GOEXPERIMENT: "", GOFLAGS: "",
+		SymABI: []byte("def " + native + " ABIInternal\n"), Original: text, Expanded: text}
+}
+
+func TestAMD64GoArgumentEntryCompleteCompilerAssociation(t *testing.T) {
+	for _, parameters := range []string{
+		"a,b string", "a,b []byte", "a float64, b bool, c struct { X byte; Y [1]float32; P *byte }",
+		"a,b,c,d,e,f,g,h,i uint64", "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o float64",
+	} {
+		t.Run(parameters, func(t *testing.T) {
+			input := amd64ArgumentEntryModel(t, parameters)
+			plan, err := amd64GoArgumentEntryPlan(input)
+			if err != nil || plan == nil || plan.requireRegisters() != nil || len(plan.Arguments) != len(input.Signature.Args) {
+				t.Fatalf("complete declared compiler-derived transport: %#v, %v", plan, err)
+			}
+		})
+	}
+	for _, standard := range []bool{false, true} {
+		input := amd64ArgumentEntryModel(t, "a,b string")
+		alias := numericalCompilerAliasModel(standard)
+		input.Native, input.Signature.Name, input.Standard = alias.Native, alias.Native, standard
+		input.Original.Name, input.Expanded.Name, input.SymABI = alias.Native, alias.Native, alias.SymABI
+		input.Aliases, _ = numericalCompilerAliasIndex(alias.SymABI, alias.Generated, alias.Selected)
+		if _, err := amd64GoArgumentEntryPlan(input); err != nil {
+			t.Fatal("complete separately observed foreign compiler association did not join", err)
+		}
+		input.Aliases = nil
+		if plan, err := amd64GoArgumentEntryPlan(input); plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("foreign spelling/SymABI without original compiler alias acquired arguments", err)
+		}
+	}
+}
+
+func TestAMD64GoArgumentEntryLanguageRoleDoesNotWidenOrdinaryFrame(t *testing.T) {
+	sizes := types.SizesFor("gc", "amd64")
+	for _, parameters := range []string{"a float32", "a float64", "a string", "a struct { S [1]string; F float64 }"} {
+		t.Run(parameters, func(t *testing.T) {
+			typ := amd64ArgumentTestSignature(t, parameters).Params().At(0).Type()
+			if _, err := goAMD64FrameLanguageTypeRole(typ, sizes, true); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ordinary frame language query acquired the private argument transport", err)
+			}
+			first, err := goAMD64LanguageTypeRole(typ, sizes, true, true)
+			if err != nil || first == "" {
+				t.Fatal("bounded argument language comparison rejected its declared type", err)
+			}
+			secondType := amd64ArgumentTestSignature(t, strings.ReplaceAll(parameters, "float64", "uint64")).Params().At(0).Type()
+			second, err := goAMD64LanguageTypeRole(secondType, sizes, true, true)
+			if strings.Contains(parameters, "float64") && (err != nil || first == second) {
+				t.Fatal("same-size integer/FP typegraph drift was erased", err)
+			}
+		})
+	}
+	for _, result := range []types.Type{types.Typ[types.Float64], types.NewPointer(types.Typ[types.Byte]), types.NewStruct(nil, nil)} {
+		input := amd64ArgumentEntryModel(t, "a string")
+		declaration := types.NewSignatureType(nil, nil, nil, input.Declaration.Type().(*types.Signature).Params(),
+			types.NewTuple(types.NewVar(token.NoPos, nil, "", result)), false)
+		pkg := types.NewPackage(input.Package.Path(), input.Package.Name())
+		input.Declaration = types.NewFunc(token.NoPos, pkg, "Entry", declaration)
+		pkg.Scope().Insert(input.Declaration)
+		input.Package = pkg
+		input.Signature, _ = DeriveGoFuncABI0Signature(input.Native, input.Declaration, "amd64", sizes)
+		if plan, err := amd64GoArgumentEntryPlan(input); plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("argument type comparison silently widened result transport", err)
+		}
+	}
+}
+
+func TestAMD64GoArgumentEntryRejectsChangedSourceTypeABIProfile(t *testing.T) {
+	for name, mutate := range map[string]func(*amd64GoArgumentEntryInput){
+		"missing-package": func(v *amd64GoArgumentEntryInput) { v.Package = nil },
+		"foreign-package": func(v *amd64GoArgumentEntryInput) { v.Package = types.NewPackage(v.Package.Path(), v.Package.Name()) },
+		"shadowed-declaration": func(v *amd64GoArgumentEntryInput) {
+			v.Declaration = types.NewFunc(token.NoPos, v.Package, "Entry", v.Declaration.Type().(*types.Signature))
+		},
+		"foreign-native":   func(v *amd64GoArgumentEntryInput) { v.Native = "runtime.other" },
+		"missing-def":      func(v *amd64GoArgumentEntryInput) { v.SymABI = []byte("ref " + v.Native + " ABIInternal\n") },
+		"ABI0-def":         func(v *amd64GoArgumentEntryInput) { v.SymABI = []byte("def " + v.Native + " ABI0\n") },
+		"duplicate-def":    func(v *amd64GoArgumentEntryInput) { v.SymABI = append(v.SymABI, v.SymABI...) },
+		"unknown-row":      func(v *amd64GoArgumentEntryInput) { v.SymABI = append(v.SymABI, []byte("garbage\n")...) },
+		"native-ABI0":      func(v *amd64GoArgumentEntryInput) { v.Original.ABI = 0 },
+		"changed-expanded": func(v *amd64GoArgumentEntryInput) { v.Expanded.Flags ^= 1 },
+		"missing-code":     func(v *amd64GoArgumentEntryInput) { v.Original.Code = nil },
+		"private-TEXT":     func(v *amd64GoArgumentEntryInput) { v.Original.Namespace = gostaticstorage.TextSymbolSelf },
+		"wrong-target":     func(v *amd64GoArgumentEntryInput) { v.Target = "linux/386" },
+		"wrong-mode":       func(v *amd64GoArgumentEntryInput) { v.Goarch = "386" },
+		"feature-profile":  func(v *amd64GoArgumentEntryInput) { v.GOAMD64 = "v3" },
+		"experiment":       func(v *amd64GoArgumentEntryInput) { v.GOEXPERIMENT = "regabiargs" },
+		"flags":            func(v *amd64GoArgumentEntryInput) { v.GOFLAGS = "-N" },
+		"argument-group":   func(v *amd64GoArgumentEntryInput) { v.Signature.Args = []LLVMType{Ptr, I64, Ptr, I64} },
+		"result-width":     func(v *amd64GoArgumentEntryInput) { v.Signature.Ret = I32 },
+		"manual-registers": func(v *amd64GoArgumentEntryInput) { v.Signature.ArgRegs = []Reg{AX, BX} },
+		"frame-layout":     func(v *amd64GoArgumentEntryInput) { v.Signature.Frame.Params[0].Offset++ },
+	} {
+		t.Run(name, func(t *testing.T) {
+			input := amd64ArgumentEntryModel(t, "a,b string")
+			mutate(&input)
+			if plan, err := amd64GoArgumentEntryPlan(input); plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed association gained a carrier plan: %#v, %v", plan, err)
+			}
+		})
+	}
+	for _, parameters := range []string{
+		"a,b,c,d,e,f,g,h uint64, s string, last uint64",
+		"a,b,c,d,e,f,g,h,i,j,k,l,m,n float64, z complex128, last float64",
+		"a [2]uint32", "a struct{}",
+	} {
+		t.Run("stack/"+strings.ReplaceAll(parameters, "/", "_"), func(t *testing.T) {
+			if plan, err := amd64GoArgumentEntryPlan(amd64ArgumentEntryModel(t, parameters)); plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("spill homes or true stack arguments became entry authority: %#v, %v", plan, err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_go_module_test.go b/amd64_go_argument_go_module_test.go
new file mode 100644
index 000000000..6869089ca
--- /dev/null
+++ b/amd64_go_argument_go_module_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestAMD64GoArgumentGoModuleGraphSignatureTransport(t *testing.T) {
+	// This model exercises only the existing signature/graph comparison seam.
+	// It cannot pass a public source consumer without the real live producer.
+	fn, bound, entry := amd64ArgumentBoundModel(t, "a string, f float32", "MOVQ BX,AX")
+	original, err := numericalCloneSignatures(entry.owner.options.Sigs)
+	if err != nil {
+		t.Fatal(err)
+	}
+	derived := map[string]FuncSig{bound.Name: numericalSignatureShape(bound)}
+	if derived[bound.Name].amd64GoArguments != nil {
+		t.Fatal("a fresh language signature retained private entry metadata")
+	}
+
+	transported, err := numericalGoSignatures(entry.owner, derived)
+	if err != nil || transported[bound.Name].amd64GoArguments != entry ||
+		!entry.valid(fn, transported[bound.Name], "amd64") {
+		t.Fatal("the authenticated signature identity was lost before the graph consumer", err)
+	}
+	if derived[bound.Name].amd64GoArguments != nil ||
+		!reflect.DeepEqual(entry.owner.options.Sigs, original) {
+		t.Fatal("transport changed the caller's fresh signatures or the owner's inventory")
+	}
+
+	file := &File{Arch: ArchAMD64, Funcs: []Func{fn}}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: transported, ResolveSym: func(string) string { return bound.Name }}
+	graph, _, err := newX86DirectTailGraph(file, options, nil, "amd64")
+	if err != nil || graph.signatures[bound.Name].amd64GoArguments != entry {
+		t.Fatal("a graph snapshot replaced its existing bound argument identity", err)
+	}
+	if err := graph.verify(file, options); err != nil {
+		t.Fatal("the exact signature snapshot did not survive the final graph comparison", err)
+	}
+
+	options.Sigs = derived
+	if !errors.Is(graph.verify(file, options), ErrProbeNeedsContext) {
+		t.Fatal("the final graph comparison accepted language shapes in place of private identities")
+	}
+	if !graph.revoked.Load() {
+		t.Fatal("signature substitution did not revoke the graph")
+	}
+
+	for _, name := range []string{"missing", "extra", "name", "argument", "result", "layout"} {
+		t.Run(name, func(t *testing.T) {
+			changed, err := numericalCloneSignatures(derived)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := changed[bound.Name]
+			switch name {
+			case "missing":
+				delete(changed, bound.Name)
+			case "extra":
+				changed["unrelated"] = sig
+			case "name":
+				sig.Name = "unrelated"
+			case "argument":
+				sig.Args[1] = I32
+			case "result":
+				sig.Ret = Ptr
+			case "layout":
+				sig.Frame.Params[0].Offset++
+			}
+			if name != "missing" && name != "extra" {
+				changed[bound.Name] = sig
+			}
+			if _, err := numericalGoSignatures(entry.owner, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Go signature transport accepted changed declarations/layout", err)
+			}
+		})
+	}
+
+	t.Run("supplied-token-is-not-authority", func(t *testing.T) {
+		forged := *entry
+		sig := derived[bound.Name]
+		sig.amd64GoArguments = &forged
+		transported, err := numericalGoSignatures(entry.owner, map[string]FuncSig{bound.Name: sig})
+		if err != nil || transported[bound.Name].amd64GoArguments != entry ||
+			transported[bound.Name].amd64GoArguments == &forged {
+			t.Fatal("caller metadata replaced the original live binding identity", err)
+		}
+	})
+}
diff --git a/amd64_go_argument_ir_test.go b/amd64_go_argument_ir_test.go
new file mode 100644
index 000000000..6b8cee8be
--- /dev/null
+++ b/amd64_go_argument_ir_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Inspect the actual LLVM values. LLVM legitimately omits quotes around
+// runtime.cmpstring while retaining them around internal/bytealg.Compare.
+func amd64ArgumentCompareEntryTypes(module llvm.Module) error {
+	for _, row := range []struct {
+		name   string
+		fields int
+	}{
+		{"internal/bytealg.Compare", 3},
+		{"runtime.cmpstring", 2},
+	} {
+		function := module.NamedFunction(row.name)
+		if function.IsNil() || function.IsDeclaration() || function.BasicBlocksCount() == 0 {
+			return fmt.Errorf("missing complete entry definition %s", row.name)
+		}
+		typ := function.GlobalValueType()
+		result := typ.ReturnType()
+		if result.TypeKind() != llvm.IntegerTypeKind || result.IntTypeWidth() != 64 ||
+			typ.IsFunctionVarArg() || typ.ParamTypesCount() != 2 {
+			return fmt.Errorf("entry signature differs for %s", row.name)
+		}
+		for _, parameter := range typ.ParamTypes() {
+			if parameter.TypeKind() != llvm.StructTypeKind || parameter.IsStructPacked() ||
+				parameter.IsStructOpaque() || parameter.StructElementTypesCount() != row.fields {
+				return fmt.Errorf("argument grouping differs for %s", row.name)
+			}
+			for index, field := range parameter.StructElementTypes() {
+				valid := field.TypeKind() == llvm.PointerTypeKind
+				if index != 0 {
+					valid = field.TypeKind() == llvm.IntegerTypeKind && field.IntTypeWidth() == 64
+				}
+				if !valid {
+					return fmt.Errorf("argument field %d differs for %s", index, row.name)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func TestAMD64GoArgumentIRUsesActualEntryIdentityAndTypes(t *testing.T) {
+	const source = `define i64 @"internal/bytealg.Compare"({ ptr, i64, i64 } %a, { ptr, i64, i64 } %b) {
+  ret i64 0
+}
+define i64 @runtime.cmpstring({ ptr, i64 } %a, { ptr, i64 } %b) {
+  ret i64 0
+}
+`
+	for _, row := range []struct {
+		name, ir string
+		failure  bool
+	}{
+		{"canonical-printer", source, false},
+		{"quoted-identifier", strings.ReplaceAll(source, "@runtime.cmpstring", "@\"runtime.cmpstring\""), false},
+		{"renamed-entry", strings.ReplaceAll(source, "runtime.cmpstring", "runtime.other"), true},
+		{"missing-entry", strings.Split(source, "define i64 @runtime")[0], true},
+		{"wrong-result", strings.ReplaceAll(source, "i64", "i32"), true},
+		{"wrong-length-width", strings.ReplaceAll(source, "ptr, i64", "ptr, i32"), true},
+		{"pointer-bits", strings.ReplaceAll(source, "ptr,", "i64,"), true},
+		{"collapsed-group", strings.ReplaceAll(source, "{ ptr, i64, i64 }", "{ ptr, i64 }"), true},
+		{"packed-group", strings.ReplaceAll(source, "{ ptr, i64 }", "<{ ptr, i64 }>"), true},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := parseIRModuleInContext(context, row.ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal("signature-only test fixture is not valid LLVM IR", err)
+			}
+			if err := amd64ArgumentCompareEntryTypes(module); (err != nil) != row.failure {
+				t.Fatalf("signature check error=%v; want failure=%t", err, row.failure)
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_issuer_test.go b/amd64_go_argument_issuer_test.go
new file mode 100644
index 000000000..a73acad3e
--- /dev/null
+++ b/amd64_go_argument_issuer_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/token"
+	"go/types"
+	"testing"
+)
+
+func TestAMD64GoArgumentIssuerDoesNotExtendResultLanguage(t *testing.T) {
+	sizes := types.SizesFor("gc", "amd64")
+	for _, parameter := range []string{"byte", "uint16", "uint32", "uint64", "*byte"} {
+		for _, result := range []struct{ name, declarations, spelling string }{
+			{"float32", "", "float32"},
+			{"float64", "", "float64"},
+			{"complex64", "", "complex64"},
+			{"complex128", "", "complex128"},
+			{"struct-float", "", "struct { Value float64 }"},
+			{"array-complex", "", "[1]complex128"},
+			{"pointer-float", "", "*float64"},
+			{"slice-float", "", "[]float32"},
+			{"named-float", "type Result float64\n", "Result"},
+			{"alias-complex", "type Result = complex64\n", "Result"},
+		} {
+			t.Run(parameter+"/"+result.name, func(t *testing.T) {
+				pkg := mustGoPackage(t, "example.invalid/issuer",
+					"package issuer\n"+result.declarations+fmt.Sprintf("func Entry(a %s) %s\n", parameter, result.spelling))
+				fn := pkg.Types.Scope().Lookup("Entry").(*types.Func)
+				sig, err := DeriveGoFuncABI0Signature("example.invalid/issuer.Entry", fn, "amd64", sizes)
+				if err != nil {
+					t.Fatal("valid original Go language declaration did not derive", err)
+				}
+				if amd64GoArgumentNeedsBinding(sig) {
+					t.Fatal("fixture no longer covers the scalar-only issuer branch")
+				}
+				if _, err := numericalSDKDeclarationLanguage(fn, sizes, false); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("the original result-language role unexpectedly accepted this fixture", err)
+				}
+				if _, err := numericalSDKDeclarationLanguage(fn, sizes, true); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("argument-only issuer extended result language while its result entry guard was skipped", err)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64GoArgumentIssuerKeepsParameterAndResultRolesIndependent(t *testing.T) {
+	sizes := types.SizesFor("gc", "amd64")
+	for _, parameter := range []string{"byte", "uint16", "uint32", "uint64", "*byte"} {
+		for _, result := range []string{"bool", "uint8", "uint16", "uint32", "uint64"} {
+			t.Run("old-scalar/"+parameter+"/"+result, func(t *testing.T) {
+				pkg := mustGoPackage(t, "example.invalid/issuer", fmt.Sprintf("package issuer\nfunc Entry(a %s) %s\n", parameter, result))
+				fn := pkg.Types.Scope().Lookup("Entry").(*types.Func)
+				original, err := numericalSDKDeclarationLanguage(fn, sizes, false)
+				if err != nil {
+					t.Fatal("the original scalar language role was lost", err)
+				}
+				actual, err := numericalSDKDeclarationLanguage(fn, sizes, true)
+				if err != nil || actual != original {
+					t.Fatal("argument role changed the old scalar/result identity", err)
+				}
+			})
+		}
+	}
+	for _, parameter := range []string{"a bool", "a float32", "a float64", "a complex64", "a complex128",
+		"a string", "a []byte", "a [1]float64", "a struct { F float32; N uint64 }"} {
+		t.Run("argument-only/"+parameter, func(t *testing.T) {
+			input := amd64ArgumentEntryModel(t, parameter)
+			if _, err := numericalSDKDeclarationLanguage(input.Declaration, sizes, true); err != nil {
+				t.Fatal("the separately validated parameter language role was removed", err)
+			}
+			if _, err := amd64GoArgumentEntryPlan(input); err != nil {
+				t.Fatal("original integer result and register-only argument model were lost", err)
+			}
+		})
+	}
+	for _, result := range []string{"bool", "uint8", "uint16", "uint32", "uint64"} {
+		t.Run("named-scalar-result/"+result, func(t *testing.T) {
+			input := amd64ArgumentEntryModel(t, "a float64")
+			pkg := mustGoPackage(t, input.Package.Path(), fmt.Sprintf("package args\ntype Result %s\nfunc Entry(a float64) Result\n", result))
+			input.Package = pkg.Types
+			input.Declaration = pkg.Types.Scope().Lookup("Entry").(*types.Func)
+			var err error
+			input.Signature, err = DeriveGoFuncABI0Signature(input.Native, input.Declaration, "amd64", sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := numericalSDKDeclarationLanguage(input.Declaration, sizes, true); err != nil {
+				t.Fatal("the original named scalar language identity was lost", err)
+			}
+			if _, err := amd64GoArgumentEntryPlan(input); err != nil {
+				t.Fatal("named scalar result was confused with an aggregate transport", err)
+			}
+		})
+	}
+	for _, result := range []string{"*byte", "string", "[]byte", "struct { N uint64 }", "[1]uint64",
+		"struct { B bool }", "[1]bool", "(uint64, uint64)"} {
+		t.Run("language-is-not-result-transport/"+result, func(t *testing.T) {
+			input := amd64ArgumentEntryModel(t, "a float64")
+			pkg := mustGoPackage(t, input.Package.Path(), fmt.Sprintf("package args\nfunc Entry(a float64) %s\n", result))
+			input.Package = pkg.Types
+			input.Declaration = pkg.Types.Scope().Lookup("Entry").(*types.Func)
+			var err error
+			input.Signature, err = DeriveGoFuncABI0Signature(input.Native, input.Declaration, "amd64", sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := numericalSDKDeclarationLanguage(input.Declaration, sizes, true); err != nil {
+				t.Fatal("old result language identity was confused with entry transport", err)
+			}
+			if _, err := amd64GoArgumentEntryPlan(input); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a language comparison granted a pointer/aggregate/multiple result transport", err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentIssuerRejectsResultCallbacksBeforeSampling(t *testing.T) {
+	for _, role := range []string{"language", "entry"} {
+		t.Run(role, func(t *testing.T) {
+			calls := 0
+			result := &amd64ArgumentCallbackType{calls: &calls}
+			input := amd64ArgumentEntryModel(t, "a uint64")
+			signature := types.NewSignatureType(nil, nil, nil,
+				input.Declaration.Type().(*types.Signature).Params(),
+				types.NewTuple(types.NewVar(token.NoPos, nil, "r", result)), false)
+			pkg := types.NewPackage(input.Package.Path(), input.Package.Name())
+			input.Declaration = types.NewFunc(token.NoPos, pkg, "Entry", signature)
+			pkg.Scope().Insert(input.Declaration)
+			input.Package = pkg
+			var err error
+			if role == "language" {
+				value, failure := numericalSDKDeclarationLanguage(input.Declaration, types.SizesFor("gc", "amd64"), true)
+				err = failure
+				if value != "" {
+					t.Fatal("caller-controlled type gained language identity", value)
+				}
+			} else {
+				plan, failure := amd64GoArgumentEntryPlan(input)
+				err = failure
+				if plan != nil {
+					t.Fatal("caller-controlled result acquired an entry plan", plan)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+				t.Fatalf("result type reached a callback before rejection: err=%v, calls=%d", err, calls)
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_plan.go b/amd64_go_argument_plan.go
new file mode 100644
index 000000000..9c0944257
--- /dev/null
+++ b/amd64_go_argument_plan.go
@@ -0,0 +1,308 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+)
+
+// amd64GoArgumentPlan is a private language-layout calculation, not an entry
+// certificate. In particular, it supplies no initialized bytes, native pointer
+// backing, FP/spill storage, closure context, or permission to lower a source.
+// The private entry consumer separately authenticates the actual declaration,
+// selected compiler/ABI, LLVM transport and complete source before using it.
+type amd64GoArgumentPlan struct {
+	Arguments []amd64GoArgumentAssignment
+	GPUsed    int
+	FPUsed    int
+}
+
+type amd64GoArgumentAssignment struct {
+	Index    int
+	Type     types.Type // Preserve the original Go parameter grouping and identity.
+	Stack    bool       // Descriptive only: there is no stack/backing model here.
+	Carriers []amd64GoArgumentCarrier
+}
+
+type amd64GoArgumentKind uint8
+
+const (
+	amd64GoArgumentInteger amd64GoArgumentKind = iota + 1
+	amd64GoArgumentBoolean
+	amd64GoArgumentPointer
+	amd64GoArgumentFloating
+)
+
+type amd64GoArgumentCarrier struct {
+	Path     []int // extractvalue path relative to this one LLVM argument.
+	Offset   int64 // Go language-model byte offset, not a native memory grant.
+	Width    int64 // Only these physical bytes carry the declared scalar value.
+	Type     LLVMType
+	Kind     amd64GoArgumentKind
+	Register Reg
+}
+
+const amd64GoArgumentPlanLimit = 4096
+
+func amd64GoArgumentContext(reason string) error {
+	return fmt.Errorf("%w: AMD64 Go argument plan: %s", ErrProbeNeedsContext, reason)
+}
+
+func planAMD64GoArguments(sig *types.Signature) (*amd64GoArgumentPlan, error) {
+	if sig == nil || sig.Recv() != nil || sig.Variadic() || sig.TypeParams().Len() != 0 || sig.RecvTypeParams().Len() != 0 {
+		return nil, amd64GoArgumentContext("requires a fixed monomorphic direct function")
+	}
+	if sig.Params().Len() > amd64GoArgumentPlanLimit {
+		return nil, amd64GoArgumentContext("parameter inventory exceeds the bounded plan")
+	}
+	plan := &amd64GoArgumentPlan{}
+	builder := amd64GoArgumentBuilder{sizes: types.SizesFor("gc", "amd64")}
+	registers := [...]Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"}
+	for index := 0; index < sig.Params().Len(); index++ {
+		typ := sig.Params().At(index).Type()
+		shape, err := builder.shape(typ, 0)
+		if err != nil {
+			return nil, err
+		}
+		argument := amd64GoArgumentAssignment{Index: index, Type: typ}
+		gp, fp := 0, 0
+		for _, leaf := range shape.leaves {
+			if leaf.Kind == amd64GoArgumentFloating {
+				fp++
+			} else {
+				gp++
+			}
+		}
+		// Go's abiutils.tryAllocRegs checks the complete parameter before
+		// allocateRegs advances either bank. A failure consumes neither bank;
+		// a subsequent parameter may still use the remaining registers.
+		argument.Stack = shape.size == 0 || shape.stack || gp > len(registers)-plan.GPUsed || fp > 15-plan.FPUsed
+		if !argument.Stack {
+			argument.Carriers = shape.leaves
+			for leaf := range argument.Carriers {
+				carrier := &argument.Carriers[leaf]
+				if carrier.Kind == amd64GoArgumentFloating {
+					carrier.Register = Reg(fmt.Sprintf("X%d", plan.FPUsed))
+					plan.FPUsed++
+				} else {
+					carrier.Register = registers[plan.GPUsed]
+					plan.GPUsed++
+				}
+			}
+		}
+		plan.Arguments = append(plan.Arguments, argument)
+	}
+	return plan, nil
+}
+
+type amd64GoArgumentShape struct {
+	size, align int64
+	stack       bool
+	leaves      []amd64GoArgumentCarrier
+}
+
+type amd64GoArgumentBuilder struct {
+	sizes         types.Sizes
+	nodes, leaves int
+}
+
+// This models the ordinary Go language types in cmd/compile's ABI assignment:
+// abiutils.allocateRegs/tryAllocRegs and types.CalcArraySize. Compiler-intrinsic
+// SIMD types and an actual compiler's physical layout still need their own
+// producer validation. go/types sizes below are language-model offsets only;
+// notably, an older go/types model is not native pointee or spill extent.
+func (builder *amd64GoArgumentBuilder) shape(typ types.Type, depth int) (amd64GoArgumentShape, error) {
+	var shape amd64GoArgumentShape
+	builder.nodes++
+	if typ == nil || depth > 32 || builder.nodes > amd64GoArgumentPlanLimit {
+		return shape, amd64GoArgumentContext("recursive or unbounded parameter type")
+	}
+	// Preserve argument.Type above, but inspect the actual RHS before using
+	// Underlying: an alias of a TypeParam otherwise looks like its constraint
+	// interface and can reach Sizes with no concrete layout. Rhs is expressed
+	// as a private interface so the base planner still compiles with Go1.20.
+	for {
+		// A user-supplied Type implementation can execute arbitrary callbacks
+		// from Underlying/String/TypeParams. Only concrete parser/compiler
+		// go/types nodes may reach a live source's serialized declaration query.
+		switch typ.(type) {
+		case *types.Basic, *types.Named, *types.Pointer, *types.Array, *types.Slice,
+			*types.Struct, *types.Map, *types.Chan, *types.Signature, *types.Interface, *types.TypeParam:
+		default:
+			if !goAMD64FrameIsAlias(typ) {
+				return shape, amd64GoArgumentContext("argument type is not an original concrete go/types node")
+			}
+		}
+		if generic, ok := typ.(interface{ TypeParams() *types.TypeParamList }); ok && generic.TypeParams().Len() != 0 {
+			return shape, amd64GoArgumentContext("generic parameter needs its separate type contract")
+		}
+		if !goAMD64FrameIsAlias(typ) {
+			break
+		}
+		alias, valid := typ.(interface{ Rhs() types.Type })
+		if !valid {
+			return shape, amd64GoArgumentContext("alias lacks its actual RHS")
+		}
+		typ = alias.Rhs()
+		depth++
+		builder.nodes++
+		if typ == nil || depth > 32 || builder.nodes > amd64GoArgumentPlanLimit {
+			return shape, amd64GoArgumentContext("recursive or unbounded alias RHS")
+		}
+	}
+	if _, parameter := typ.(*types.TypeParam); parameter {
+		return shape, amd64GoArgumentContext("unresolved type parameter has no concrete argument layout")
+	}
+	add := func(llvm LLVMType, kind amd64GoArgumentKind, width, offset int64, path []int) error {
+		builder.leaves++
+		if builder.leaves > amd64GoArgumentPlanLimit {
+			return amd64GoArgumentContext("scalar carrier inventory exceeds the bounded plan")
+		}
+		shape.leaves = append(shape.leaves, amd64GoArgumentCarrier{
+			Path: path, Offset: offset, Width: width, Type: llvm, Kind: kind,
+		})
+		return nil
+	}
+	finishLeaf := func(llvm LLVMType, kind amd64GoArgumentKind, width, offset int64, path []int) (amd64GoArgumentShape, error) {
+		err := add(llvm, kind, width, offset, path)
+		return builder.finish(typ, shape, err)
+	}
+	appendChild := func(child amd64GoArgumentShape, index int, offset int64) {
+		shape.stack = shape.stack || child.stack
+		for _, leaf := range child.leaves {
+			leaf.Path = append([]int{index}, leaf.Path...)
+			leaf.Offset += offset
+			shape.leaves = append(shape.leaves, leaf)
+		}
+	}
+	switch underlying := typ.Underlying().(type) {
+	case *types.Basic:
+		var llvm LLVMType
+		kind, width := amd64GoArgumentInteger, int64(0)
+		switch underlying.Kind() {
+		case types.Bool:
+			llvm, kind, width = I1, amd64GoArgumentBoolean, 1
+		case types.Int8, types.Uint8:
+			llvm, width = I8, 1
+		case types.Int16, types.Uint16:
+			llvm, width = I16, 2
+		case types.Int32, types.Uint32:
+			llvm, width = I32, 4
+		case types.Int, types.Uint, types.Uintptr, types.Int64, types.Uint64:
+			llvm, width = I64, 8
+		case types.UnsafePointer:
+			llvm, kind, width = Ptr, amd64GoArgumentPointer, 8
+		case types.Float32:
+			llvm, kind, width = "float", amd64GoArgumentFloating, 4
+		case types.Float64:
+			llvm, kind, width = "double", amd64GoArgumentFloating, 8
+		case types.Complex64, types.Complex128:
+			llvm, kind, width = "float", amd64GoArgumentFloating, 4
+			if underlying.Kind() == types.Complex128 {
+				llvm, width = "double", 8
+			}
+			if err := add(llvm, kind, width, 0, []int{0}); err != nil {
+				return shape, err
+			}
+			return finishLeaf(llvm, kind, width, width, []int{1})
+		case types.String:
+			if err := add(Ptr, amd64GoArgumentPointer, 8, 0, []int{0}); err != nil {
+				return shape, err
+			}
+			return finishLeaf(I64, amd64GoArgumentInteger, 8, 8, []int{1})
+		default:
+			return shape, amd64GoArgumentContext("unsupported or untyped scalar parameter")
+		}
+		return finishLeaf(llvm, kind, width, 0, nil)
+	case *types.Pointer, *types.Map, *types.Chan, *types.Signature:
+		// Pointer-shaped values are opaque carriers. Do not inspect or grant
+		// numerical bytes, canonical bools, callable bodies or pointee bounds.
+		return finishLeaf(Ptr, amd64GoArgumentPointer, 8, 0, nil)
+	case *types.Interface:
+		if !underlying.IsMethodSet() {
+			return shape, amd64GoArgumentContext("constraint interface is not a concrete argument value")
+		}
+		for index := 0; index < 2; index++ {
+			if err := add(Ptr, amd64GoArgumentPointer, 8, int64(index)*8, []int{index}); err != nil {
+				return shape, err
+			}
+		}
+	case *types.Slice:
+		if err := add(Ptr, amd64GoArgumentPointer, 8, 0, []int{0}); err != nil {
+			return shape, err
+		}
+		for index := 1; index < 3; index++ {
+			if err := add(I64, amd64GoArgumentInteger, 8, int64(index)*8, []int{index}); err != nil {
+				return shape, err
+			}
+		}
+	case *types.Array:
+		child, err := builder.shape(underlying.Elem(), depth+1)
+		if err != nil {
+			return shape, err
+		}
+		n := underlying.Len()
+		const maxInt64 = int64(1<<63 - 1)
+		if n < 0 || child.size > maxInt64-(child.align-1) {
+			return shape, amd64GoArgumentContext("unrepresentable array parameter layout")
+		}
+		stride := (child.size + child.align - 1) / child.align * child.align
+		if n > 0 && stride != 0 && n-1 > (maxInt64-child.size)/stride {
+			return shape, amd64GoArgumentContext("array parameter layout overflows")
+		}
+		switch n {
+		case 0:
+		case 1:
+			appendChild(child, 0, 0)
+		default:
+			shape.stack = true
+		}
+	case *types.Struct:
+		if underlying.NumFields() > amd64GoArgumentPlanLimit-builder.nodes {
+			return shape, amd64GoArgumentContext("field inventory exceeds the bounded plan")
+		}
+		fields := make([]*types.Var, underlying.NumFields())
+		children := make([]amd64GoArgumentShape, len(fields))
+		for index := range fields {
+			fields[index] = underlying.Field(index)
+			child, err := builder.shape(fields[index].Type(), depth+1)
+			if err != nil {
+				return shape, err
+			}
+			children[index] = child
+		}
+		// Descendants are concrete and bounded before go/types traverses them.
+		offsets := builder.sizes.Offsetsof(fields)
+		for index, child := range children {
+			if offsets[index] < 0 || child.size > (1<<63-1)-offsets[index] {
+				return shape, amd64GoArgumentContext("struct parameter layout overflows")
+			}
+			appendChild(child, index, offsets[index])
+		}
+	default:
+		return shape, amd64GoArgumentContext("unsupported concrete parameter type")
+	}
+	return builder.finish(typ, shape, nil)
+}
+
+func (builder *amd64GoArgumentBuilder) finish(typ types.Type, shape amd64GoArgumentShape, err error) (amd64GoArgumentShape, error) {
+	if err != nil {
+		return shape, err
+	}
+	shape.size, shape.align = builder.sizes.Sizeof(typ), builder.sizes.Alignof(typ)
+	if shape.size < 0 || shape.align <= 0 {
+		return shape, amd64GoArgumentContext("parameter lacks a representable language layout")
+	}
+	return shape, nil
+}
+
+func (plan *amd64GoArgumentPlan) requireRegisters() error {
+	if plan == nil {
+		return amd64GoArgumentContext("missing complete argument plan")
+	}
+	for _, argument := range plan.Arguments {
+		if argument.Stack {
+			return amd64GoArgumentContext("stack-assigned argument needs an independent backing contract")
+		}
+	}
+	return nil
+}
diff --git a/amd64_go_argument_plan_test.go b/amd64_go_argument_plan_test.go
new file mode 100644
index 000000000..79774b6ab
--- /dev/null
+++ b/amd64_go_argument_plan_test.go
@@ -0,0 +1,417 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func amd64ArgumentTestSignature(t *testing.T, parameters string) *types.Signature {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "arguments.go", "package arguments\nfunc Entry("+parameters+") int", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check("example.invalid/arguments", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg.Scope().Lookup("Entry").Type().(*types.Signature)
+}
+
+func TestAMD64GoArgumentPlanIndependentTypedCarriers(t *testing.T) {
+	type expected struct {
+		parameter int
+		path      []int
+		offset    int64
+		width     int64
+		typ       LLVMType
+		kind      amd64GoArgumentKind
+		register  Reg
+	}
+	tests := []struct {
+		name       string
+		parameters string
+		gp, fp     int
+		want       []expected
+	}{
+		{"strings", "a, b string", 4, 0, []expected{
+			{0, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, AX},
+			{0, []int{1}, 8, 8, I64, amd64GoArgumentInteger, BX},
+			{1, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, CX},
+			{1, []int{1}, 8, 8, I64, amd64GoArgumentInteger, DI},
+		}},
+		{"slices", "a, b []byte", 6, 0, []expected{
+			{0, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, AX},
+			{0, []int{1}, 8, 8, I64, amd64GoArgumentInteger, BX},
+			{0, []int{2}, 16, 8, I64, amd64GoArgumentInteger, CX},
+			{1, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, DI},
+			{1, []int{1}, 8, 8, I64, amd64GoArgumentInteger, SI},
+			{1, []int{2}, 16, 8, I64, amd64GoArgumentInteger, "R8"},
+		}},
+		{"independent-banks", "f float64, n uint32, b bool, s string", 4, 1, []expected{
+			{0, nil, 0, 8, "double", amd64GoArgumentFloating, "X0"},
+			{1, nil, 0, 4, I32, amd64GoArgumentInteger, AX},
+			{2, nil, 0, 1, I1, amd64GoArgumentBoolean, BX},
+			{3, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, CX},
+			{3, []int{1}, 8, 8, I64, amd64GoArgumentInteger, DI},
+		}},
+		{"nested-padding-and-array-one", "a struct { B byte; F struct { X float32; N uint16 }; P [1]*byte }", 3, 1, []expected{
+			{0, []int{0}, 0, 1, I8, amd64GoArgumentInteger, AX},
+			{0, []int{1, 0}, 4, 4, "float", amd64GoArgumentFloating, "X0"},
+			{0, []int{1, 1}, 8, 2, I16, amd64GoArgumentInteger, BX},
+			{0, []int{2, 0}, 16, 8, Ptr, amd64GoArgumentPointer, CX},
+		}},
+		{"complex-and-opaque-handles", "z complex64, p *byte, m map[int]int, c chan byte, f func(), i interface{}", 6, 2, []expected{
+			{0, []int{0}, 0, 4, "float", amd64GoArgumentFloating, "X0"},
+			{0, []int{1}, 4, 4, "float", amd64GoArgumentFloating, "X1"},
+			{1, nil, 0, 8, Ptr, amd64GoArgumentPointer, AX},
+			{2, nil, 0, 8, Ptr, amd64GoArgumentPointer, BX},
+			{3, nil, 0, 8, Ptr, amd64GoArgumentPointer, CX},
+			{4, nil, 0, 8, Ptr, amd64GoArgumentPointer, DI},
+			{5, []int{0}, 0, 8, Ptr, amd64GoArgumentPointer, SI},
+			{5, []int{1}, 8, 8, Ptr, amd64GoArgumentPointer, "R8"},
+		}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			sig := amd64ArgumentTestSignature(t, test.parameters)
+			plan, err := planAMD64GoArguments(sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if plan.GPUsed != test.gp || plan.FPUsed != test.fp || len(plan.Arguments) != sig.Params().Len() {
+				t.Fatalf("incorrect complete grouping/banks: %#v", plan)
+			}
+			var got []expected
+			for _, argument := range plan.Arguments {
+				if argument.Type != sig.Params().At(argument.Index).Type() || argument.Stack {
+					t.Fatalf("original parameter identity/group lost: %#v", argument)
+				}
+				for _, carrier := range argument.Carriers {
+					got = append(got, expected{argument.Index, carrier.Path, carrier.Offset, carrier.Width, carrier.Type, carrier.Kind, carrier.Register})
+				}
+			}
+			if !reflect.DeepEqual(got, test.want) {
+				t.Fatalf("carrier map\n got %#v\nwant %#v", got, test.want)
+			}
+			if err := plan.requireRegisters(); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanWholeArgumentSpillRollback(t *testing.T) {
+	for _, test := range []struct {
+		name, parameters string
+		spilled, next    int
+		register         Reg
+		gp, fp           int
+	}{
+		{"gp-string", "a,b,c,d,e,f,g,h uint64, s string, last uint64", 8, 9, "R11", 9, 0},
+		{"fp-complex", "a,b,c,d,e,f,g,h,i,j,k,l,m,n float64, z complex128, last float64", 14, 15, "X14", 0, 15},
+		{"both-bank-rollback", "a,b,c,d,e,f,g,h uint64, s struct { F float64; A,B uint64 }, last float64, n uint64", 8, 9, "X0", 9, 1},
+		{"fp-failure-does-not-consume-gp", "a,b,c,d,e,f,g,h,i,j,k,l,m,n float64, s struct { P *byte; Z complex128 }, last uint64", 14, 15, AX, 1, 14},
+		{"nontrivial-array", "a [2]uint32, n uint64", 0, 1, AX, 1, 0},
+		{"nested-array", "a struct { N uint64; V [2]float64 }, n uint64", 0, 1, AX, 1, 0},
+		{"zero-size", "a struct{}, n uint64", 0, 1, AX, 1, 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			plan, err := planAMD64GoArguments(amd64ArgumentTestSignature(t, test.parameters))
+			if err != nil {
+				t.Fatal(err)
+			}
+			spill := plan.Arguments[test.spilled]
+			if !spill.Stack || len(spill.Carriers) != 0 {
+				t.Fatalf("whole argument was partially assigned: %#v", spill)
+			}
+			next := plan.Arguments[test.next]
+			if next.Stack || len(next.Carriers) != 1 || next.Carriers[0].Register != test.register || plan.GPUsed != test.gp || plan.FPUsed != test.fp {
+				t.Fatalf("failed parameter consumed registers: %#v", plan)
+			}
+			if err := plan.requireRegisters(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("stack assignment acquired register/backing permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanPreservesGroupingAndZeroFields(t *testing.T) {
+	grouped, err := planAMD64GoArguments(amd64ArgumentTestSignature(t, "a,b,c,d,e,f,g,h uint64, pair struct { X,Y uint64 }"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	separate, err := planAMD64GoArguments(amd64ArgumentTestSignature(t, "a,b,c,d,e,f,g,h uint64, x,y uint64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(grouped.Arguments) != 9 || !grouped.Arguments[8].Stack || grouped.GPUsed != 8 ||
+		len(separate.Arguments) != 10 || separate.Arguments[8].Stack || !separate.Arguments[9].Stack ||
+		separate.Arguments[8].Carriers[0].Register != "R11" {
+		t.Fatal("flattening changed the original all-or-nothing parameter boundary")
+	}
+	for _, test := range []struct {
+		parameters string
+		stack      bool
+		path       []int
+	}{
+		{"a struct { Z [0]uint64; N uint64 }", false, []int{1}},
+		{"a struct { Z struct{}; N uint64 }", false, []int{1}},
+		{"a struct { Z [1]struct{}; N uint64 }", false, []int{1}},
+		// CalcArraySize makes even a zero-sized nontrivial array unsuitable
+		// for recursive register assignment of this nonzero-sized struct.
+		{"a struct { Z [2]struct{}; N uint64 }", true, nil},
+	} {
+		t.Run(test.parameters, func(t *testing.T) {
+			plan, err := planAMD64GoArguments(amd64ArgumentTestSignature(t, test.parameters))
+			if err != nil {
+				t.Fatal(err)
+			}
+			argument := plan.Arguments[0]
+			if argument.Stack != test.stack {
+				t.Fatalf("incorrect zero-field classification: %#v", argument)
+			}
+			if !test.stack && (len(argument.Carriers) != 1 || !reflect.DeepEqual(argument.Carriers[0].Path, test.path) || argument.Carriers[0].Offset != 0) {
+				t.Fatalf("zero field acquired storage/carriers or changed the field path: %#v", argument)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanCompleteScalarKindsAndRegisterBanks(t *testing.T) {
+	for _, test := range []struct {
+		typ   types.BasicKind
+		width int64
+		llvm  LLVMType
+		kind  amd64GoArgumentKind
+	}{
+		{types.Bool, 1, I1, amd64GoArgumentBoolean},
+		{types.Int8, 1, I8, amd64GoArgumentInteger}, {types.Uint8, 1, I8, amd64GoArgumentInteger},
+		{types.Int16, 2, I16, amd64GoArgumentInteger}, {types.Uint16, 2, I16, amd64GoArgumentInteger},
+		{types.Int32, 4, I32, amd64GoArgumentInteger}, {types.Uint32, 4, I32, amd64GoArgumentInteger},
+		{types.Int64, 8, I64, amd64GoArgumentInteger}, {types.Uint64, 8, I64, amd64GoArgumentInteger},
+		{types.Int, 8, I64, amd64GoArgumentInteger}, {types.Uint, 8, I64, amd64GoArgumentInteger},
+		{types.Uintptr, 8, I64, amd64GoArgumentInteger}, {types.UnsafePointer, 8, Ptr, amd64GoArgumentPointer},
+		{types.Float32, 4, "float", amd64GoArgumentFloating}, {types.Float64, 8, "double", amd64GoArgumentFloating},
+	} {
+		t.Run(types.Typ[test.typ].Name(), func(t *testing.T) {
+			parameter := types.NewVar(token.NoPos, nil, "value", types.Typ[test.typ])
+			sig := types.NewSignatureType(nil, nil, nil, types.NewTuple(parameter), nil, false)
+			plan, err := planAMD64GoArguments(sig)
+			if err != nil {
+				t.Fatal(err)
+			}
+			carriers := plan.Arguments[0].Carriers
+			if len(carriers) != 1 || carriers[0].Width != test.width || carriers[0].Type != test.llvm || carriers[0].Kind != test.kind {
+				t.Fatalf("scalar kind/byte extent differs: %#v", carriers)
+			}
+		})
+	}
+	for _, test := range []struct {
+		name      string
+		typ       string
+		registers []Reg
+	}{
+		{"GP", "uint64", []Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"}},
+		{"FP", "float64", []Reg{"X0", "X1", "X2", "X3", "X4", "X5", "X6", "X7", "X8", "X9", "X10", "X11", "X12", "X13", "X14"}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			parameters := strings.TrimSuffix(strings.Repeat(test.typ+",", len(test.registers)), ",")
+			plan, err := planAMD64GoArguments(amd64ArgumentTestSignature(t, parameters))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, argument := range plan.Arguments {
+				if argument.Stack || len(argument.Carriers) != 1 || argument.Carriers[0].Register != test.registers[index] {
+					t.Fatalf("incorrect bank order at %d: %#v", index, argument)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanRejectsUnsupportedAndUnboundedTypes(t *testing.T) {
+	signature := func(typ types.Type) *types.Signature {
+		return types.NewSignatureType(nil, nil, nil, types.NewTuple(types.NewVar(token.NoPos, nil, "value", typ)), nil, false)
+	}
+	deep := types.Type(types.Typ[types.Uint64])
+	for index := 0; index < 34; index++ {
+		deep = types.NewArray(deep, 1)
+	}
+	parameter := types.NewTypeParam(types.NewTypeName(token.NoPos, nil, "T", nil), types.NewInterfaceType(nil, nil).Complete())
+	generic := types.NewNamed(types.NewTypeName(token.NoPos, nil, "Generic", nil), types.Typ[types.Uint64], nil)
+	generic.SetTypeParams([]*types.TypeParam{types.NewTypeParam(types.NewTypeName(token.NoPos, nil, "U", nil), types.NewInterfaceType(nil, nil).Complete())})
+	constraint := types.NewInterfaceType(nil, []types.Type{types.NewUnion([]*types.Term{types.NewTerm(true, types.Typ[types.Int])})}).Complete()
+	tests := map[string]*types.Signature{
+		"nil":             nil,
+		"variadic":        amd64ArgumentTestSignature(t, "values ...byte"),
+		"type-parameter":  signature(parameter),
+		"generic-named":   signature(generic),
+		"constraint":      signature(constraint),
+		"untyped-integer": signature(types.Typ[types.UntypedInt]),
+		"invalid":         signature(types.Typ[types.Invalid]),
+		"unbounded-depth": signature(deep),
+		"array-overflow":  signature(types.NewArray(types.Typ[types.Uint64], 1<<62)),
+		"method": types.NewSignatureType(types.NewVar(token.NoPos, nil, "receiver", types.Typ[types.Int]), nil, nil,
+			types.NewTuple(), nil, false),
+		"generic-function": types.NewSignatureType(nil, nil, []*types.TypeParam{parameter}, types.NewTuple(), nil, false),
+	}
+	for name, sig := range tests {
+		t.Run(name, func(t *testing.T) {
+			plan, err := planAMD64GoArguments(sig)
+			if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unsupported shape got a partial plan: %#v, %v", plan, err)
+			}
+		})
+	}
+	if err := (*amd64GoArgumentPlan)(nil).requireRegisters(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("nil plan acquired a register role: %v", err)
+	}
+}
+
+func TestAMD64GoArgumentPlanIndependentInventoryBudgets(t *testing.T) {
+	makeSignature := func(count int, typ types.Type) *types.Signature {
+		parameters := make([]*types.Var, count)
+		for index := range parameters {
+			parameters[index] = types.NewVar(token.NoPos, nil, "", typ)
+		}
+		return types.NewSignatureType(nil, nil, nil, types.NewTuple(parameters...), nil, false)
+	}
+	for _, count := range []int{4096, 4097} {
+		t.Run(fmt.Sprintf("parameters-%d", count), func(t *testing.T) {
+			plan, err := planAMD64GoArguments(makeSignature(count, types.Typ[types.Uint64]))
+			if count == 4096 {
+				if err != nil || len(plan.Arguments) != count || plan.GPUsed != 9 {
+					t.Fatalf("exact parameter boundary: %#v, %v", plan, err)
+				}
+			} else if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized parameter inventory: %#v, %v", plan, err)
+			}
+		})
+	}
+	for _, count := range []int{2048, 2049} {
+		t.Run(fmt.Sprintf("complex-carriers-%d", count), func(t *testing.T) {
+			plan, err := planAMD64GoArguments(makeSignature(count, types.Typ[types.Complex128]))
+			if count == 2048 {
+				if err != nil || len(plan.Arguments) != count || plan.FPUsed != 14 {
+					t.Fatalf("exact carrier boundary: %#v, %v", plan, err)
+				}
+			} else if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized carrier inventory: %#v, %v", plan, err)
+			}
+		})
+	}
+	for _, count := range []int{4095, 4096} {
+		t.Run(fmt.Sprintf("struct-nodes-%d", count+1), func(t *testing.T) {
+			fields := make([]*types.Var, count)
+			for index := range fields {
+				fields[index] = types.NewField(token.NoPos, nil, fmt.Sprintf("N%d", index), types.Typ[types.Uint64], false)
+			}
+			plan, err := planAMD64GoArguments(makeSignature(1, types.NewStruct(fields, nil)))
+			if count == 4095 {
+				if err != nil || len(plan.Arguments) != 1 || !plan.Arguments[0].Stack {
+					t.Fatalf("exact node boundary: %#v, %v", plan, err)
+				}
+			} else if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized node inventory: %#v, %v", plan, err)
+			}
+		})
+	}
+	for _, count := range []int{32, 33} {
+		t.Run(fmt.Sprintf("depth-%d", count), func(t *testing.T) {
+			typ := types.Type(types.Typ[types.Uint64])
+			for index := 0; index < count; index++ {
+				typ = types.NewArray(typ, 1)
+			}
+			plan, err := planAMD64GoArguments(makeSignature(1, typ))
+			if count == 32 {
+				if err != nil || len(plan.Arguments[0].Carriers[0].Path) != count {
+					t.Fatalf("exact depth boundary: %#v, %v", plan, err)
+				}
+			} else if plan != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized depth: %#v, %v", plan, err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanRetainsNamedIdentityAndIndependentPaths(t *testing.T) {
+	first := types.NewNamed(types.NewTypeName(token.NoPos, nil, "First", nil), types.Typ[types.Uint32], nil)
+	second := types.NewNamed(types.NewTypeName(token.NoPos, nil, "Second", nil), types.Typ[types.Uint32], nil)
+	aggregate := types.NewStruct([]*types.Var{
+		types.NewField(token.NoPos, nil, "A", first, false),
+		types.NewField(token.NoPos, nil, "B", second, false),
+	}, nil)
+	sig := types.NewSignatureType(nil, nil, nil,
+		types.NewTuple(types.NewVar(token.NoPos, nil, "value", aggregate)), nil, false)
+	plan, err := planAMD64GoArguments(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if plan.Arguments[0].Type != aggregate || aggregate.Field(0).Type() != first || aggregate.Field(1).Type() != second {
+		t.Fatal("same-width original language identities were replaced")
+	}
+	plan.Arguments[0].Carriers[0].Path[0] = 99
+	again, err := planAMD64GoArguments(sig)
+	if err != nil || again.Arguments[0].Carriers[0].Path[0] != 0 || plan.Arguments[0].Carriers[1].Path[0] != 1 {
+		t.Fatal("one plan or sibling carrier mutated another owned path")
+	}
+}
+
+func TestAMD64GoArgumentPlanDoesNotAuthorizeExistingSourceConsumers(t *testing.T) {
+	for _, parameters := range []string{"value string", "value []byte", "value float64", "value bool", "value struct { N uint64 }"} {
+		t.Run(parameters, func(t *testing.T) {
+			declaration := amd64ArgumentTestSignature(t, parameters)
+			plan, err := planAMD64GoArguments(declaration)
+			if err != nil || plan.requireRegisters() != nil {
+				t.Fatalf("valid private model was not calculated: %#v, %v", plan, err)
+			}
+			fn := types.NewFunc(token.NoPos, nil, "Entry", declaration)
+			sig, err := DeriveGoFuncABI0Signature("Entry", fn, "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, "TEXT ·Entry<ABIInternal>(SB),4,$0-64\nMOVQ $1,AX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: sig, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("private allocation plan widened the existing register entry: %v", err)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("private allocation plan became ABI0 result storage: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64GoArgumentPlanEveryScalarWidthAndNoHiddenDX(t *testing.T) {
+	sig := amd64ArgumentTestSignature(t, "a int8, b uint16, c int32, d uint64, e bool, p *byte, f float32, g float64")
+	plan, err := planAMD64GoArguments(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	widths := []int64{1, 2, 4, 8, 1, 8, 4, 8}
+	kinds := []amd64GoArgumentKind{amd64GoArgumentInteger, amd64GoArgumentInteger, amd64GoArgumentInteger, amd64GoArgumentInteger,
+		amd64GoArgumentBoolean, amd64GoArgumentPointer, amd64GoArgumentFloating, amd64GoArgumentFloating}
+	for index, argument := range plan.Arguments {
+		if len(argument.Carriers) != 1 || argument.Carriers[0].Width != widths[index] || argument.Carriers[0].Kind != kinds[index] {
+			t.Fatalf("incorrect declared byte kind/width at %d: %#v", index, argument)
+		}
+		if argument.Carriers[0].Register == DX {
+			t.Fatal("hidden DX context was assigned as an ordinary argument")
+		}
+	}
+	if strings.Contains(types.TypeString(sig, nil), "DX") {
+		t.Fatal("planner mutated the original logical declaration")
+	}
+}
diff --git a/amd64_go_argument_sdk_go127_test.go b/amd64_go_argument_sdk_go127_test.go
new file mode 100644
index 000000000..f0ce92925
--- /dev/null
+++ b/amd64_go_argument_sdk_go127_test.go
@@ -0,0 +1,186 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func amd64SDKArgumentTranslate(t *testing.T, api string, pkg GoPackage, file *File, options Options) (string, error) {
+	t.Helper()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	var module llvm.Module
+	var err error
+	if api == "module" {
+		module, err = TranslateModuleInContext(context, file, options)
+	} else {
+		source := options.NumericalReads.source
+		original, failure := os.ReadFile(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+		if failure != nil {
+			t.Fatal(failure)
+		}
+		goos, _, _ := strings.Cut(source.request.Target, "/")
+		result, failure := translateGoModuleInContext(context, pkg, original, GoModuleOptions{
+			GOARCH: options.Goarch, GOOS: goos, TargetTriple: options.TargetTriple, FileName: source.request.AssemblyFile,
+			NumericalReads: options.NumericalReads, ResolveSym: options.ResolveSym,
+		})
+		err = failure
+		if result != nil {
+			module = result.Module
+		}
+	}
+	if !module.IsNil() {
+		defer module.Dispose()
+		if err == nil {
+			return module.String(), nil
+		}
+	}
+	return "", err
+}
+
+func amd64SDKTypedArgumentsWholeSource(t *testing.T, member string, apis ...string) {
+	t.Helper()
+	if len(apis) == 0 {
+		apis = []string{"text", "module", "go-module"}
+	}
+	seen := make(map[string]bool)
+	for _, api := range apis {
+		if api != "text" && api != "module" && api != "go-module" || seen[api] {
+			t.Fatal("invalid or repeated complete-source API", api)
+		}
+		seen[api] = true
+	}
+	var llc string
+	if member == "compare_amd64.s" {
+		llc = findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("complete original Compare objects require LLVM22 llc")
+		}
+	}
+	ctx, request, metadata, _ := numericalSDKAssemblyFixture(t)
+	request.AssemblyFile = member
+	original, err := os.ReadFile(filepath.Join(request.Directory, member))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("unchanged complete original SDK source/compiler/CPU join", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	pkg, file, options := numericalSDKOriginalTypedPackage(t, metadata, member)
+	if len(file.Funcs) != 3 || len(file.Data)+len(file.Globl) != 0 || len(source.reads) != 1 ||
+		len(metadata.observation.Objects.Sources) != len(metadata.guard.selection.SFiles) {
+		t.Fatal("complete original three TEXT/all selected ASM/CPU inventory changed")
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	options.Sigs, err = goSigsForAsmFile(pkg, file, options.ResolveSym, "amd64", sizes, sizes, nil)
+	if err != nil || len(options.Sigs) != 2 {
+		t.Fatal("actual full original declaration inventory", err)
+	}
+	before, err := x86CallerSourceFingerprint(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("complete original typed carrier/compiler/source binding", err)
+	}
+	for _, api := range apis {
+		t.Run(api, func(t *testing.T) {
+			ir, err := amd64SDKArgumentTranslate(t, api, pkg, file, bound)
+			if member == "equal_amd64.s" {
+				// The complete source also has a custom tail-entry obligation;
+				// either may reject before the unbound 8(DX) closure read.
+				// The declared-byte consumer matrix independently checks that
+				// exact hidden read. Neither rejection is whole-file success.
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("whole equal source acquired an unproved entry or closure contract", err)
+				}
+				t.Log("complete original equal source remains Context (NOT file pass):", err)
+				return
+			}
+			if err != nil || ir == "" {
+				t.Fatal("whole original Compare source still needs an independent contract", err)
+			}
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := parseIRModuleInContext(context, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal("complete translated Compare module did not parse", err)
+			}
+			if err := amd64ArgumentCompareEntryTypes(module); err != nil {
+				t.Fatal("complete original grouped entry transport differs", err)
+			}
+			for _, optimizeIR := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR_O2=%t", optimizeIR), func(t *testing.T) {
+					input := ir
+					if optimizeIR {
+						input = x86MulDivRoundOptimize(t, input)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run("backend"+level, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, options.TargetTriple, input, level)
+						})
+					}
+				})
+			}
+		})
+	}
+	after, err := x86CallerSourceFingerprint(file)
+	if err != nil || after != before {
+		t.Fatal("consumer changed the original source", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("final original numerical source Verify", err)
+	}
+	if err := metadata.Verify(ctx); err != nil {
+		t.Fatal("final original complete header/archive Verify", err)
+	}
+	afterBytes, err := os.ReadFile(filepath.Join(request.Directory, member))
+	if err != nil || sha256.Sum256(afterBytes) != sha256.Sum256(original) {
+		t.Fatal("original SDK bytes changed", err)
+	}
+	role := "Context only; no object/native/closure/stack proof"
+	if member == "compare_amd64.s" {
+		role = fmt.Sprintf("%d LLVM22 object axes; no native/closure/stack proof", 4*len(apis))
+	}
+	t.Logf("member=%s APIs=%v completeTEXTs=3 declaredEntries=2 allSelectedASM=%d sourceSHA=%x; %s", member, apis, len(metadata.guard.selection.SFiles), sha256.Sum256(original), role)
+}
+
+// Each API owns a fresh complete capture, before/final verification and all
+// four object axes. Scheduling them independently avoids spending one shared
+// five-minute source lease across three expensive compiler observations.
+// Together these roots retain the entire original three-TEXT, twelve-object
+// scope; they do not cache or share mutable source observations.
+func TestGoX86SDKAMD64CompareTypedArgumentsWholeSource(t *testing.T) {
+	amd64SDKTypedArgumentsWholeSource(t, "compare_amd64.s", "text")
+}
+
+func TestGoX86SDKAMD64CompareTypedArgumentsWholeSourceModule(t *testing.T) {
+	amd64SDKTypedArgumentsWholeSource(t, "compare_amd64.s", "module")
+}
+
+func TestGoX86SDKAMD64CompareTypedArgumentsWholeSourceGoModule(t *testing.T) {
+	amd64SDKTypedArgumentsWholeSource(t, "compare_amd64.s", "go-module")
+}
+
+func TestGoX86SDKAMD64EqualTypedArgumentsWholeSource(t *testing.T) {
+	amd64SDKTypedArgumentsWholeSource(t, "equal_amd64.s")
+}
diff --git a/amd64_go_argument_sdk_partitions_test.go b/amd64_go_argument_sdk_partitions_test.go
new file mode 100644
index 000000000..6c6d027ce
--- /dev/null
+++ b/amd64_go_argument_sdk_partitions_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"testing"
+)
+
+// Check scheduling ownership without loading LLVM or capturing an SDK source.
+// Actual source, translation, object and lifetime checks remain in each owner.
+func TestAMD64SDKCompareAPIIndependentOwners(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_go_argument_sdk_go127_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			functions[function.Name.Name] = function
+		}
+	}
+	for _, owner := range []struct{ name, api string }{
+		{"TestGoX86SDKAMD64CompareTypedArgumentsWholeSource", "text"},
+		{"TestGoX86SDKAMD64CompareTypedArgumentsWholeSourceModule", "module"},
+		{"TestGoX86SDKAMD64CompareTypedArgumentsWholeSourceGoModule", "go-module"},
+	} {
+		t.Run(owner.api, func(t *testing.T) {
+			function := functions[owner.name]
+			if function == nil {
+				t.Fatal("missing independent complete-source API owner", owner.name)
+			}
+			calls := 0
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				callee, ok := call.Fun.(*ast.Ident)
+				if !ok || callee.Name != "amd64SDKTypedArgumentsWholeSource" {
+					return true
+				}
+				calls++
+				if len(call.Args) != 3 {
+					t.Error("owner must select exactly one complete-source API")
+					return false
+				}
+				for index, want := range map[int]string{1: "compare_amd64.s", 2: owner.api} {
+					literal, ok := call.Args[index].(*ast.BasicLit)
+					if !ok || literal.Kind != token.STRING {
+						t.Error("member/API selection must be a literal")
+						continue
+					}
+					got, err := strconv.Unquote(literal.Value)
+					if err != nil || got != want {
+						t.Errorf("selection = %q, want %q", got, want)
+					}
+				}
+				return false
+			})
+			if calls != 1 {
+				t.Errorf("complete-source helper calls = %d, want one", calls)
+			}
+		})
+	}
+}
diff --git a/amd64_go_argument_type_callback_test.go b/amd64_go_argument_type_callback_test.go
new file mode 100644
index 000000000..8b681f82a
--- /dev/null
+++ b/amd64_go_argument_type_callback_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/token"
+	"go/types"
+	"testing"
+)
+
+type amd64ArgumentCallbackType struct{ calls *int }
+
+func (typ *amd64ArgumentCallbackType) Underlying() types.Type {
+	*typ.calls++
+	return types.Typ[types.Uint64]
+}
+func (typ *amd64ArgumentCallbackType) String() string                   { *typ.calls++; return "uint64" }
+func (typ *amd64ArgumentCallbackType) TypeParams() *types.TypeParamList { *typ.calls++; return nil }
+
+func TestAMD64GoArgumentEntryRejectsCallerTypeCallbacksBeforeSampling(t *testing.T) {
+	calls := 0
+	typ := &amd64ArgumentCallbackType{&calls}
+	sig := types.NewSignatureType(nil, nil, nil, types.NewTuple(types.NewVar(token.NoPos, nil, "x", typ)), nil, false)
+	defer func() {
+		if failure := recover(); failure != nil {
+			t.Errorf("caller-controlled type reached compiler layout/panicked: %v (callbacks=%d)", failure, calls)
+		}
+	}()
+	plan, err := planAMD64GoArguments(sig)
+	if plan != nil || !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+		t.Fatalf("non-source go/types implementation reached callback under a future owner lock: %#v, %v, calls=%d", plan, err, calls)
+	}
+}
diff --git a/amd64_go_argument_wrapper_inventory_go127_test.go b/amd64_go_argument_wrapper_inventory_go127_test.go
new file mode 100644
index 000000000..182a408ea
--- /dev/null
+++ b/amd64_go_argument_wrapper_inventory_go127_test.go
@@ -0,0 +1,119 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Reuse the existing complete live SDK producer. No extra assembly reference,
+// declaration, compiler flag or synthetic wrapper is added to the SDK. This is
+// an inventory, not a carrier-placement proof or successful file translation.
+func amd64SDKArgumentWrapperInventory(t *testing.T, member string) {
+	t.Helper()
+	ctx, request, metadata, _ := numericalSDKAssemblyFixture(t)
+	request.AssemblyFile = member
+	before, err := os.ReadFile(filepath.Join(request.Directory, member))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete original compiler/source/CPU observation", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	pkg, file, options := numericalSDKOriginalTypedPackage(t, metadata, member)
+	if len(file.Funcs) != 3 || len(file.Data) != 0 || len(file.Globl) != 0 {
+		t.Fatal("original complete assembly member changed; no TEXT may be cropped")
+	}
+	if metadata.observation.Objects == nil || len(metadata.observation.Objects.Members) < 2 ||
+		len(metadata.observation.Objects.Sources) != len(metadata.guard.selection.SFiles) ||
+		len(metadata.guard.selection.SFiles) == 0 || len(source.native.ArchiveMembers) != len(metadata.observation.Objects.Members) ||
+		!reflect.DeepEqual(source.native.ArchiveMembers[1].Texts, metadata.observation.Objects.Members[1].Texts) {
+		t.Fatal("inventory lacks the complete selected package assembly/compiler archive")
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	options.Sigs, err = goSigsForAsmFile(pkg, file, options.ResolveSym, "amd64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal("actual complete declaration signatures", err)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil || bound.NumericalReads == nil {
+		t.Fatal("original declaration/compiler/native association", err)
+	}
+	names, err := numericalGoDeclarationLinknames(pkg.Syntax, pkg.Types)
+	if err != nil {
+		t.Fatal(err)
+	}
+	entries, _, err := numericalTypedSourceDeclarations(file, pkg.Path, "amd64", source.role, names, source.native.CompilerAliases)
+	if err != nil || len(entries) != len(options.Sigs) {
+		t.Fatal("actual bodyless entry inventory differs from original source", err)
+	}
+	generated, err := gostaticstorage.ObserveX86SDKCompilerText(metadata.observation.Header.CompilerObject,
+		metadata.observation.ObjectInputs.BuiltinSource, request.Target, metadata.observation.ObjectInputs.Referenced)
+	if err != nil {
+		t.Fatal("existing complete header compiler object", err)
+	}
+	selected := metadata.observation.Objects.Members[1].Texts
+	var ordered []string
+	for native := range entries {
+		ordered = append(ordered, native)
+	}
+	sort.Strings(ordered)
+	present := 0
+	var absent []string
+	for _, native := range ordered {
+		entry := entries[native]
+		declaration, valid := pkg.Types.Scope().Lookup(entry.local).(*types.Func)
+		if !valid {
+			t.Fatal("inventory entry lacks its original typed declaration", native)
+		}
+		plan, err := planAMD64GoArguments(declaration.Type().(*types.Signature))
+		if err != nil || plan.requireRegisters() != nil {
+			t.Fatal("original argument shape exceeds this private register-only model", native, err)
+		}
+		wrapper, found, err := amd64ArgumentWrapperInventory(generated, selected, native)
+		if err != nil {
+			t.Fatal("actual generated/selected wrapper inventory differs", native, err)
+		}
+		if !found {
+			absent = append(absent, native)
+			t.Logf("native=%q local=%q parameters=%d GP=%d FP=%d wrapper=ABSENT; no carrier evidence", native, entry.local, len(plan.Arguments), plan.GPUsed, plan.FPUsed)
+			continue
+		}
+		present++
+		t.Logf("native=%q local=%q parameters=%d GP=%d FP=%d wrapperABI=%d namespace=%d flags=%d/%d bytes=%x relocations=%+v; placement UNPROVED",
+			native, entry.local, len(plan.Arguments), plan.GPUsed, plan.FPUsed, wrapper.ABI, wrapper.Namespace, wrapper.Flags, wrapper.Flags2, wrapper.Code, wrapper.Relocations)
+	}
+	if present+len(absent) != len(entries) {
+		t.Fatal("wrapper inventory omitted an original declared entry")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete original numerical source final verification", err)
+	}
+	if err := metadata.Verify(ctx); err != nil {
+		t.Fatal("borrowed complete SDK source/header/archive final verification", err)
+	}
+	after, err := os.ReadFile(filepath.Join(request.Directory, member))
+	if err != nil || sha256.Sum256(before) != sha256.Sum256(after) {
+		t.Fatal("inventory changed the unchanged original assembly", err)
+	}
+	t.Logf("inventory-only member=%s originalTEXTs=%d selectedASM=%d entries=%d wrapperCandidates=%d explicitlyAbsent=%v; no translation or entry permission",
+		member, len(file.Funcs), len(metadata.guard.selection.SFiles), len(entries), present, absent)
+}
+
+func TestGoX86SDKAMD64CompareArgumentWrapperInventory(t *testing.T) {
+	amd64SDKArgumentWrapperInventory(t, "compare_amd64.s")
+}
+
+func TestGoX86SDKAMD64EqualArgumentWrapperInventory(t *testing.T) {
+	amd64SDKArgumentWrapperInventory(t, "equal_amd64.s")
+}
diff --git a/amd64_go_argument_wrapper_inventory_test.go b/amd64_go_argument_wrapper_inventory_test.go
new file mode 100644
index 000000000..6d3ccbb3d
--- /dev/null
+++ b/amd64_go_argument_wrapper_inventory_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This test-only inventory checks retained records, not argument placement or
+// source authority. In particular, no wrapper is manufactured when one is
+// absent, and a returned record never becomes a carrier or entry certificate.
+func amd64ArgumentWrapperInventory(generated, selected []gostaticstorage.TextRecord, native string) (gostaticstorage.TextRecord, bool, error) {
+	fail := func() (gostaticstorage.TextRecord, bool, error) {
+		return gostaticstorage.TextRecord{}, false, amd64GoArgumentContext("incomplete or ambiguous original wrapper inventory")
+	}
+	if native == "" || len(generated) == 0 || len(selected) == 0 ||
+		len(generated) > gostaticstorage.ObjectSymbolInventoryLimit || len(selected) > gostaticstorage.ObjectSymbolInventoryLimit {
+		return fail()
+	}
+	find := func(records []gostaticstorage.TextRecord) (gostaticstorage.TextRecord, int) {
+		var result gostaticstorage.TextRecord
+		count := 0
+		for _, record := range records {
+			if record.Name == native && record.ABI == 0 {
+				result, count = record, count+1
+			}
+		}
+		return result, count
+	}
+	first, firstCount := find(generated)
+	second, secondCount := find(selected)
+	if firstCount == 0 && secondCount == 0 {
+		return gostaticstorage.TextRecord{}, false, nil // An explicit absence, not a successful placement proof.
+	}
+	if firstCount != 1 || secondCount != 1 || first.Kind != 1 || first.Flags2&64 == 0 ||
+		first.Namespace != gostaticstorage.TextSymbolSelf && first.Namespace != gostaticstorage.TextSymbolNonpkgDefinition ||
+		first.Size <= 0 || first.Size != int64(len(first.Code)) || first.Namespace != second.Namespace ||
+		first.Kind != second.Kind || first.Flags != second.Flags || first.Flags2 != second.Flags2 ||
+		first.Size != second.Size || !bytes.Equal(first.Code, second.Code) || !reflect.DeepEqual(first.Relocations, second.Relocations) {
+		return fail()
+	}
+	calls := 0
+	for _, relocation := range first.Relocations {
+		if relocation.Target.Name != native {
+			continue
+		}
+		// Go1.27's already registered R_CALL record must identify an actual
+		// direct near CALL field. This does not decode or certify its inputs.
+		if relocation.Type != 7 || relocation.Size != 4 || relocation.Add != 0 ||
+			relocation.Offset < 1 || relocation.Offset > int64(len(first.Code))-4 ||
+			first.Code[relocation.Offset-1] != 0xe8 || !relocation.Target.ABIKnown || relocation.Target.ABI != 1 {
+			return fail()
+		}
+		calls++
+	}
+	if calls != 1 {
+		return fail()
+	}
+	return first, true, nil
+}
+
+func TestAMD64GoArgumentWrapperInventoryCompleteRecords(t *testing.T) {
+	for _, namespace := range []gostaticstorage.TextSymbolNamespace{gostaticstorage.TextSymbolSelf, gostaticstorage.TextSymbolNonpkgDefinition} {
+		input := numericalCompilerAliasModel(false)
+		input.Generated[0].Namespace = namespace
+		input.Selected[0].Namespace = namespace
+		if namespace == gostaticstorage.TextSymbolSelf {
+			input.Generated[0].Flags2, input.Selected[0].Flags2 = 64, 64
+		}
+		if _, present, err := amd64ArgumentWrapperInventory(input.Generated, input.Selected, input.Native); err != nil || !present {
+			t.Fatal("matched original candidate was not inventoried", err)
+		}
+		if record, present, err := amd64ArgumentWrapperInventory(input.Generated, input.Selected, "example.invalid/remote.Absent"); err != nil || present || record.Name != "" {
+			t.Fatal("absence was replaced with a manufactured wrapper", record, present, err)
+		}
+	}
+}
+
+func TestAMD64GoArgumentWrapperInventoryRejectsPartialOrAmbiguousRecords(t *testing.T) {
+	for name, mutate := range map[string]func(*numericalCompilerAliasInput){
+		"missing-generated": func(input *numericalCompilerAliasInput) { input.Generated = nil },
+		"missing-selected":  func(input *numericalCompilerAliasInput) { input.Selected = nil },
+		"one-sided-absence": func(input *numericalCompilerAliasInput) { input.Generated[0].Name += "Other" },
+		"duplicate-generated": func(input *numericalCompilerAliasInput) {
+			input.Generated = append(input.Generated, input.Generated[0])
+		},
+		"duplicate-selected": func(input *numericalCompilerAliasInput) {
+			input.Selected = append(input.Selected, input.Selected[0])
+		},
+		"not-wrapper": func(input *numericalCompilerAliasInput) { input.Generated[0].Flags2 &^= 64 },
+		"wrong-kind":  func(input *numericalCompilerAliasInput) { input.Generated[0].Kind = 2 },
+		"wrong-code":  func(input *numericalCompilerAliasInput) { input.Generated[0].Code = []byte{0xcc} },
+		"namespace": func(input *numericalCompilerAliasInput) {
+			input.Generated[0].Namespace = gostaticstorage.TextSymbolHashed
+		},
+		"not-call-opcode": func(input *numericalCompilerAliasInput) {
+			input.Generated[0].Code = []byte{0xe9, 0, 0, 0, 0, 0xc3}
+			input.Selected[0].Code = append([]byte(nil), input.Generated[0].Code...)
+		},
+		"wrong-call-relocation": func(input *numericalCompilerAliasInput) {
+			input.Generated[0].Relocations = append([]gostaticstorage.TextRelocation(nil), input.Generated[0].Relocations...)
+			input.Generated[0].Relocations[0].Type = 14
+			input.Selected[0].Relocations = append([]gostaticstorage.TextRelocation(nil), input.Generated[0].Relocations...)
+		},
+		"unknown-call-ABI": func(input *numericalCompilerAliasInput) {
+			input.Generated[0].Relocations = append([]gostaticstorage.TextRelocation(nil), input.Generated[0].Relocations...)
+			input.Generated[0].Relocations[0].Target.ABIKnown = false
+			input.Selected[0].Relocations = append([]gostaticstorage.TextRelocation(nil), input.Generated[0].Relocations...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			input := numericalCompilerAliasModel(false)
+			mutate(&input)
+			if _, present, err := amd64ArgumentWrapperInventory(input.Generated, input.Selected, input.Native); present || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("partial records became an original wrapper candidate", present, err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_assembler_test.go b/amd64_go_assembler_test.go
new file mode 100644
index 000000000..16f2a8485
--- /dev/null
+++ b/amd64_go_assembler_test.go
@@ -0,0 +1,18 @@
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+// requireX86GoAssemblerResult keeps the Go 1.27 table oracle available to
+// tests that must remain visible to llgo. Older compatibility toolchains still
+// exercise parsing, translation, and LLVM compilation, but cannot define the
+// current operand grammar.
+func requireX86GoAssemblerResult(t *testing.T, goarch, src string, wantSuccess bool) {
+	t.Helper()
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return
+	}
+	goAssemblerOracleOutput(t, goarch, src, "", wantSuccess)
+}
diff --git a/amd64_go_caller_acyclic_domain_test.go b/amd64_go_caller_acyclic_domain_test.go
new file mode 100644
index 000000000..8ef5a191e
--- /dev/null
+++ b/amd64_go_caller_acyclic_domain_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"math"
+	"reflect"
+	"testing"
+)
+
+func x86CallerJoinDomainState() (x86SourceStackState, *x86GoCallerRegionProof) {
+	proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{
+		{kind: x86CallerSliceInput, width: 4}, {kind: x86CallerSliceInput, width: 4},
+		{kind: x86CallerFreshResult, width: 4}, {kind: x86CallerLocalLength, width: 8},
+	}}
+	state := x86SourceStackState{
+		bp: x86SourceStackAddress{original: true}, numericFlags: true, gOriginal: true,
+		callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}, SI: {argument: 1}, DX: {argument: 2}, CX: {argument: 3}},
+		known:   map[Reg]uint8{AX: 0xff}, vectors: map[Reg]uint64{"Z0": ^uint64(0)}, masks: map[Reg]bool{"K1": true},
+	}
+	return state, proof
+}
+
+func TestX86GoCallerAcyclicJoinDomainIntersectionAndNoAliasing(t *testing.T) {
+	left, proof := x86CallerJoinDomainState()
+	left.cells = []x86SourceStackCell{{offset: -8, width: 8,
+		bp: &x86SourceStackAddress{original: true}, caller: &x86CallerPointerValue{argument: 0}}}
+	right := x86CloneCallerState(left)
+	right.callers[DI] = x86CallerPointerValue{argument: 0, offset: 4}
+	right.known[AX] = 1
+	right.known[BX] = 0xff
+	right.vectors["Z0"] = 0xf
+	right.vectors["Z1"] = ^uint64(0)
+	delete(right.masks, "K1")
+	right.masks["K2"] = true
+	beforeLeft, beforeRight := x86CloneCallerState(left), x86CloneCallerState(right)
+	merged, valid := x86CallerAcyclicMerge(left, right, proof)
+	if !valid || merged.callers[DI] != (x86CallerPointerValue{argument: 0, span: 4}) ||
+		merged.known[AX] != 1 || merged.known[BX] != 0 || merged.vectors["Z0"] != 0xf ||
+		merged.vectors["Z1"] != 0 || merged.masks["K1"] || merged.masks["K2"] {
+		t.Fatalf("not an all-path same-origin intersection: %+v, %t", merged, valid)
+	}
+	reversed, valid := x86CallerAcyclicMerge(right, left, proof)
+	if !valid || !reflect.DeepEqual(merged, reversed) {
+		t.Fatal("merge depends on predecessor arrival order")
+	}
+	merged.callers[DI] = x86CallerPointerValue{}
+	merged.known[AX] = 0
+	merged.vectors["Z0"] = 0
+	merged.masks["K1"] = true
+	merged.cells[0].bp.offset = 7
+	merged.cells[0].caller.offset = 7
+	if !reflect.DeepEqual(left, beforeLeft) || !reflect.DeepEqual(right, beforeRight) {
+		t.Fatal("merged state aliases a predecessor map, cell or saved pointer")
+	}
+}
+
+func TestX86GoCallerAcyclicJoinDomainRejectsChangedFixedOrigins(t *testing.T) {
+	for _, change := range []string{
+		"missing origin", "different argument", "result offset", "length offset", "SP", "BP", "g", "flags", "saved cell",
+		"span on result", "negative span", "overflow span", "past offset cap", "past end cap",
+	} {
+		t.Run(change, func(t *testing.T) {
+			left, proof := x86CallerJoinDomainState()
+			right := x86CloneCallerState(left)
+			switch change {
+			case "missing origin":
+				delete(right.callers, DI)
+			case "different argument":
+				right.callers[DI] = x86CallerPointerValue{argument: 1}
+			case "result offset":
+				right.callers[DX] = x86CallerPointerValue{argument: 2, offset: 1}
+			case "length offset":
+				right.callers[CX] = x86CallerPointerValue{argument: 3, offset: 1}
+			case "SP":
+				right.sp = -8
+			case "BP":
+				right.bp.original = false
+			case "g":
+				right.gOriginal = false
+			case "flags":
+				right.numericFlags = false
+			case "saved cell":
+				right.cells = []x86SourceStackCell{{offset: -8, width: 8}}
+			case "span on result":
+				left.callers[DX] = x86CallerPointerValue{argument: 2, span: 1}
+				right.callers[DX] = left.callers[DX]
+			case "negative span":
+				right.callers[DI] = x86CallerPointerValue{argument: 0, span: -1}
+			case "overflow span":
+				right.callers[DI] = x86CallerPointerValue{argument: 0, offset: 1, span: math.MaxInt64}
+			case "past offset cap":
+				right.callers[DI] = x86CallerPointerValue{argument: 0, offset: -x86SourceStackLimit - 1}
+			case "past end cap":
+				right.callers[DI] = x86CallerPointerValue{argument: 0, offset: x86SourceStackLimit, span: 1}
+			}
+			if _, valid := x86CallerAcyclicMerge(left, right, proof); valid {
+				t.Fatal("changed fixed state or invalid span acquired a join")
+			}
+		})
+	}
+}
+
+func TestX86GoCallerAcyclicJoinPointerArithmeticBounds(t *testing.T) {
+	for _, test := range []struct {
+		pointer x86CallerPointerValue
+		delta   int64
+		valid   bool
+	}{
+		{x86CallerPointerValue{offset: -4, span: 8}, 4, true},
+		{x86CallerPointerValue{offset: -x86SourceStackLimit, span: 2 * x86SourceStackLimit}, 0, true},
+		{x86CallerPointerValue{offset: x86SourceStackLimit - 4, span: 4}, 1, false},
+		{x86CallerPointerValue{offset: -x86SourceStackLimit, span: 4}, -1, false},
+		{x86CallerPointerValue{offset: 1, span: 4}, math.MaxInt64, false},
+		{x86CallerPointerValue{offset: -1, span: 4}, math.MinInt64, false},
+		{x86CallerPointerValue{offset: math.MaxInt64, span: 1}, 0, false},
+	} {
+		shifted, valid := x86CallerPointerShift(test.pointer, test.delta)
+		if valid != test.valid || valid && shifted.span != test.pointer.span {
+			t.Fatalf("shift %+v by %d: %+v/%t", test.pointer, test.delta, shifted, valid)
+		}
+	}
+}
+
+func TestX86GoCallerAcyclicJoinDomainCannotRecoverUnknownFacts(t *testing.T) {
+	left, proof := x86CallerJoinDomainState()
+	unknown := x86CloneCallerState(left)
+	delete(unknown.known, AX)
+	delete(unknown.vectors, "Z0")
+	delete(unknown.masks, "K1")
+	joined, valid := x86CallerAcyclicMerge(left, unknown, proof)
+	if !valid {
+		t.Fatal("same origins with unknown numerical bytes should intersect")
+	}
+	joined, valid = x86CallerAcyclicMerge(joined, left, proof)
+	if !valid || joined.known[AX] != 0 || joined.vectors["Z0"] != 0 || joined.masks["K1"] {
+		t.Fatal("later predecessor recovered an erased all-path fact")
+	}
+}
+
+func TestX86GoCallerAcyclicJoinDomainAllPredecessorPermutations(t *testing.T) {
+	first, proof := x86CallerJoinDomainState()
+	second, third := x86CloneCallerState(first), x86CloneCallerState(first)
+	second.callers[DI] = x86CallerPointerValue{argument: 0, offset: -4}
+	third.callers[DI] = x86CallerPointerValue{argument: 0, offset: 12}
+	second.known[AX] = 0xf
+	third.known[AX] = 3
+	second.vectors["Z0"] = 0xff
+	third.vectors["Z0"] = 0xf
+	second.known[BX], third.known[BX] = 0xff, 0xff
+	second.vectors["Z1"], third.vectors["Z1"] = 0xff, 0xff
+	second.masks["K2"], third.masks["K2"] = true, true
+	third.masks["K1"] = false
+	states := []x86SourceStackState{first, second, third}
+	var expected *x86SourceStackState
+	for _, order := range [][3]int{{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, {1, 2, 0}, {2, 0, 1}, {2, 1, 0}} {
+		joined, valid := x86CallerAcyclicMerge(states[order[0]], states[order[1]], proof)
+		if valid {
+			joined, valid = x86CallerAcyclicMerge(joined, states[order[2]], proof)
+		}
+		if !valid || joined.callers[DI] != (x86CallerPointerValue{argument: 0, offset: -4, span: 16}) ||
+			joined.known[AX] != 3 || joined.known[BX] != 0 || joined.vectors["Z0"] != 0xf ||
+			joined.vectors["Z1"] != 0 || joined.masks["K1"] || joined.masks["K2"] {
+			t.Fatalf("permutation %v recovered a missing fact: %+v/%t", order, joined, valid)
+		}
+		if expected != nil && !reflect.DeepEqual(*expected, joined) {
+			t.Fatalf("three-predecessor merge depends on order %v", order)
+		}
+		copy := x86CloneCallerState(joined)
+		expected = &copy
+	}
+}
+
+func TestX86GoCallerAcyclicJoinGraphRequiresCompleteReachableDAG(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		acyclic    bool
+	}{
+		{"fallthrough", "MOVL $1,AX\nRET", true},
+		{"diamond", "CMPQ AX,$0\nJE other\nMOVL $1,AX\nJMP done\nother:\nMOVL $2,AX\ndone:\nRET", true},
+		{"dead cycle", "JMP done\ndead:\nJMP dead\ndone:\nRET", true},
+		{"reachable cycle", "loop:\nCMPQ AX,$0\nJNE loop\nRET", false},
+		{"cycle beyond join", "CMPQ AX,$0\nJE joined\nMOVL $1,AX\njoined:\nloop:\nJMP loop", false},
+		{"PC forward", "JMP 1(PC)\nRET", true},
+		{"PC self", "JMP 0(PC)", false},
+		{"PC out of source", "JMP 3(PC)\nRET", false},
+		{"unknown indirect target", "JMP AX\nRET", false},
+		{"unknown label", "JMP missing\nRET", false},
+		{"fall off source", "MOVL $1,AX", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·graph(SB),4,$0-0\n"+test.body+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			labels := map[string]int{}
+			var instructions []int
+			for index, ins := range fn.Instrs {
+				if ins.Op == OpLABEL {
+					labels[ins.Args[0].Sym] = len(instructions)
+				} else {
+					instructions = append(instructions, index)
+				}
+			}
+			if got := x86CallerReachableAcyclic(fn, instructions, labels); got != test.acyclic {
+				t.Fatalf("reachable graph acyclic=%t, want %t", got, test.acyclic)
+			}
+		})
+	}
+	if x86CallerReachableAcyclic(Func{}, nil, nil) ||
+		x86CallerReachableAcyclic(Func{}, make([]int, 8193), nil) {
+		t.Fatal("empty or over-budget source acquired a new merge")
+	}
+}
diff --git a/amd64_go_caller_acyclic_join.go b/amd64_go_caller_acyclic_join.go
new file mode 100644
index 000000000..82c687f7f
--- /dev/null
+++ b/amd64_go_caller_acyclic_join.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"math"
+	"reflect"
+)
+
+// A span is an abstract set of offsets from the same authenticated input.
+// It is not an allocation extent or a promise that an unsafe read cannot fault.
+func x86CallerPointerEnd(pointer x86CallerPointerValue) (int64, bool) {
+	if pointer.span < 0 || pointer.offset > math.MaxInt64-pointer.span {
+		return 0, false
+	}
+	end := pointer.offset + pointer.span
+	return end, pointer.offset >= -x86SourceStackLimit && end <= x86SourceStackLimit
+}
+
+func x86CallerPointerShift(pointer x86CallerPointerValue, delta int64) (x86CallerPointerValue, bool) {
+	if _, valid := x86CallerPointerEnd(pointer); !valid ||
+		delta > 0 && pointer.offset > math.MaxInt64-delta ||
+		delta < 0 && pointer.offset < math.MinInt64-delta {
+		return pointer, false
+	}
+	pointer.offset += delta
+	_, valid := x86CallerPointerEnd(pointer)
+	return pointer, valid
+}
+
+func x86CloneCallerState(state x86SourceStackState) x86SourceStackState {
+	if state.cells != nil {
+		cells := make([]x86SourceStackCell, len(state.cells))
+		copy(cells, state.cells)
+		state.cells = cells
+	}
+	for index := range state.cells {
+		if state.cells[index].bp != nil {
+			value := *state.cells[index].bp
+			state.cells[index].bp = &value
+		}
+		if state.cells[index].caller != nil {
+			value := *state.cells[index].caller
+			state.cells[index].caller = &value
+		}
+	}
+	state.callers = x86CloneCallerPointers(state.callers)
+	state.known = x86CloneCallerKnown(state.known)
+	state.vectors, state.masks = x86CloneCallerVectorState(state.vectors, state.masks)
+	return state
+}
+
+// Only numerical definedness and same-origin read-only input offsets merge.
+// Neither a missing origin nor a fixed local, stack or continuation can borrow
+// this domain. Return a fresh deep clone, never edit either predecessor.
+func x86CallerAcyclicMerge(left, right x86SourceStackState, proof *x86GoCallerRegionProof) (x86SourceStackState, bool) {
+	if proof == nil || left.sp != right.sp || left.bp != right.bp ||
+		left.numericFlags != right.numericFlags || left.partialNumericFlags != right.partialNumericFlags || left.gOriginal != right.gOriginal ||
+		!reflect.DeepEqual(left.cells, right.cells) || len(left.callers) != len(right.callers) {
+		return x86SourceStackState{}, false
+	}
+	merged := x86CloneCallerState(left)
+	for reg, a := range left.callers {
+		b, present := right.callers[reg]
+		if !present || a.argument != b.argument || a.argument < 0 || a.argument >= len(proof.arguments) {
+			return x86SourceStackState{}, false
+		}
+		aEnd, aValid := x86CallerPointerEnd(a)
+		bEnd, bValid := x86CallerPointerEnd(b)
+		if !aValid || !bValid {
+			return x86SourceStackState{}, false
+		}
+		if proof.arguments[a.argument].kind != x86CallerSliceInput {
+			if a != b || a.span != 0 {
+				return x86SourceStackState{}, false
+			}
+			continue
+		}
+		if b.offset < a.offset {
+			a.offset = b.offset
+		}
+		if bEnd > aEnd {
+			aEnd = bEnd
+		}
+		a.span = aEnd - a.offset // Both endpoints already have the 1 MiB bound.
+		merged.callers[reg] = a
+	}
+	// Include absent facts as zero, including on a later predecessor. Retain
+	// zero entries so replays do not depend on which predecessor arrived first.
+	for reg, value := range right.known {
+		merged.known[reg] = left.known[reg] & value
+	}
+	for reg, value := range left.known {
+		merged.known[reg] = value & right.known[reg]
+	}
+	for reg, value := range right.vectors {
+		merged.vectors[reg] = left.vectors[reg] & value
+	}
+	for reg, value := range left.vectors {
+		merged.vectors[reg] = value & right.vectors[reg]
+	}
+	for reg, value := range right.masks {
+		merged.masks[reg] = left.masks[reg] && value
+	}
+	for reg, value := range left.masks {
+		merged.masks[reg] = value && right.masks[reg]
+	}
+	return merged, true
+}
+
+// A new merge cannot establish any cyclic invariant. This deliberately checks
+// the entire reachable graph, not only the current edge or label's spelling.
+func x86CallerReachableAcyclic(fn Func, instructions []int, labels map[string]int) bool {
+	if len(instructions) == 0 || len(instructions) > 8192 {
+		return false
+	}
+	edges := make(map[int][]int)
+	seen := make(map[int]bool)
+	work := []int{0}
+	for len(work) != 0 {
+		pc := work[0]
+		work = work[1:]
+		if pc < 0 || pc >= len(instructions) {
+			return false
+		}
+		if seen[pc] {
+			continue
+		}
+		seen[pc] = true
+		ins := fn.Instrs[instructions[pc]]
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		if op == OpRET {
+			continue
+		}
+		next := []int{pc + 1}
+		if op == OpJMP || isAMD64ConditionalBranch(op) {
+			if len(ins.Args) != 1 {
+				return false
+			}
+			operand := ins.Args[0]
+			label := operand.Sym
+			if operand.Kind == OpIdent {
+				label = operand.Ident
+			}
+			target, valid := labels[label]
+			if operand.Kind == OpMem && operand.Mem.Base == PC && operand.Mem.Index == "" &&
+				operand.Mem.Sym == "" && operand.Mem.Off >= -int64(len(instructions)) && operand.Mem.Off <= int64(len(instructions)) {
+				target, valid = pc+int(operand.Mem.Off), true
+			} else if operand.Kind != OpLabel && operand.Kind != OpIdent {
+				return false
+			}
+			if !valid {
+				return false
+			}
+			if op == OpJMP {
+				next = []int{target}
+			} else {
+				next = append(next, target)
+			}
+		}
+		edges[pc] = next
+		work = append(work, next...)
+	}
+	indegree := make(map[int]int, len(seen))
+	for _, next := range edges {
+		for _, pc := range next {
+			indegree[pc]++
+		}
+	}
+	work = work[:0]
+	for pc := range seen {
+		if indegree[pc] == 0 {
+			work = append(work, pc)
+		}
+	}
+	removed := 0
+	for len(work) != 0 {
+		pc := work[0]
+		work = work[1:]
+		removed++
+		for _, next := range edges[pc] {
+			indegree[next]--
+			if indegree[next] == 0 {
+				work = append(work, next)
+			}
+		}
+	}
+	return removed == len(seen)
+}
diff --git a/amd64_go_caller_acyclic_join_test.go b/amd64_go_caller_acyclic_join_test.go
new file mode 100644
index 000000000..e6b0647ed
--- /dev/null
+++ b/amd64_go_caller_acyclic_join_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerAcyclicJoinAssembly(body string) string {
+	return strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+}
+
+func TestX86GoCallerAcyclicJoinActualSourceInputs(t *testing.T) {
+	for name, body := range map[string]string{
+		"same input offsets":     "MOVQ (CX),AX\nCMPQ AX,$1\nJE other\nADDQ $4,DI\nCMPQ AX,$1\nother:\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"copy and affine range":  "MOVQ (CX),AX\nCMPQ AX,$1\nJE other\nADDQ $4,DI\nCMPQ AX,$1\nother:\nMOVQ DI,BX\nLEAQ 4(BX),R11\nSUBQ $4,R11\nMOVL (R11),AX\nMOVL AX,(DX)",
+		"all path low GP bytes":  "MOVQ (CX),AX\nCMPQ AX,$1\nJE narrow\nMOVL $42,BX\nJMP joined\nnarrow:\nMOVB $42,BL\njoined:\nMOVB BL,(DX)",
+		"unused SIMD definition": "VMOVUPS (DI),X0\nMOVQ (CX),AX\nCMPQ AX,$1\nJE joined\nVMOVUPS (SI),X1\njoined:\nVMOVSS X0,(DX)",
+		"unused mask definition": "MOVQ (CX),AX\nCMPQ AX,$1\nJE joined\nKMOVQ AX,K1\njoined:\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := x86CallerAcyclicJoinAssembly(body)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatalf("complete actual source acyclic join %s: %v", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedLoopOriginalBackedgeNeedsFiniteProof(t *testing.T) {
+	// These are unchanged consecutive original directives and the actual
+	// backedge in Weaviate dot_avx256_amd64.s. The acyclic mechanism still cannot
+	// prove them; the new private finite replay proves only this bounded region,
+	// not the complete external function or its later unbounded loops.
+	body := `MOVQ (CX),R9
+LONG $0xff418d45
+LONG $0x03c1f641
+JE done
+WORD $0x8944; BYTE $0xc8
+WORD $0xe083; BYTE $0x03
+LONG $0xc057f8c5
+WORD $0xc931
+LBB0_4:
+LONG $0x0f10fac5
+LONG $0xb971e2c4; BYTE $0x06
+LONG $0x04c78348
+LONG $0x04c68348
+LONG $0x01c18348
+WORD $0xc839
+JNE LBB0_4
+done:
+MOVL $7,AX
+MOVL AX,(DX)`
+	assembly := x86CallerAcyclicJoinAssembly(body)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var instructions []int
+	labels := map[string]int{}
+	for index, ins := range decoded.Instrs {
+		if ins.Op == OpLABEL {
+			labels[ins.Args[0].Sym] = len(instructions)
+		} else {
+			instructions = append(instructions, index)
+		}
+	}
+	if x86CallerReachableAcyclic(decoded, instructions, labels) {
+		t.Fatal("a natural backedge acquired DAG admission")
+	}
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatalf("source-bound finite replay of only the first region: %v", err)
+	}
+	// Preserve the bounded but outside-budget variant as a real source Context,
+	// without hiding its original directives or adding a wrapper length check.
+	outsideBudget := strings.Replace(assembly, "WORD $0xe083; BYTE $0x03", "WORD $0xe083; BYTE $0x07", 1)
+	unsafePkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, outsideBudget)
+	if err := x86CallerCoreTranslate(t, unsafePkg, outsideBudget, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("bound outside finite mechanism admitted: %v", err)
+	}
+}
+
+func TestX86GoCallerAcyclicJoinRetainsUnknownPermissions(t *testing.T) {
+	for name, body := range map[string]string{
+		"different base":                     "CMPQ AX,$0\nJE joined\nMOVQ SI,DI\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"lost pointer":                       "CMPQ AX,$0\nJE joined\nMOVQ $0,DI\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"readonly write":                     "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nMOVL AX,(DI)",
+		"result offset":                      "CMPQ AX,$0\nJE joined\nADDQ $1,DX\nCMPQ AX,$0\njoined:\nMOVB AX,(DX)",
+		"length offset":                      "CMPQ AX,$0\nJE joined\nADDQ $1,CX\nCMPQ AX,$0\njoined:\nMOVL (CX),AX\nMOVL AX,(DX)",
+		"upper range cap":                    "CMPQ AX,$0\nJE joined\nADDQ $1048576,DI\nCMPQ AX,$0\njoined:\nLEAQ 1(DI),BX\nMOVL (BX),AX\nMOVL AX,(DX)",
+		"partial pointer":                    "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nMOVW DI,BX\nMOVL (BX),AX\nMOVL AX,(DX)",
+		"truncated pointer":                  "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nLEAL (DI),DI\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"stack escape":                       "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nMOVQ DI,SP\nMOVL AX,(DX)",
+		"input escapes as data":              "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nMOVQ DI,(DX)",
+		"unknown length":                     "MOVQ R11,AX\nCMPQ AX,$0\nJE joined\nADDQ $4,DI\njoined:\nMOVL AX,(DX)",
+		"late unknown GP":                    "CMPQ AX,$0\nJE missing\nMOVQ $7,BX\nJMP joined\nmissing:\nMOVB $7,BL\njoined:\nMOVQ BX,AX\nMOVL AX,(DX)",
+		"late unknown vector":                "CMPQ AX,$0\nJE missing\nVMOVUPS (DI),Y0\nJMP joined\nmissing:\nMOVSS (DI),X0\njoined:\nVEXTRACTF128 $1,Y0,X1\nVMOVSS X1,(DX)",
+		"late unknown mask":                  "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nKMOVQ AX,K1\njoined:\nVPADDD.Z Z0,Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"mask0 cannot grant source":          "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nCMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nVPADDD.Z (DX),Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"stale address flags":                "CMPQ AX,$0\nJE joined\nADDQ $4,DI\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"same state loop cannot borrow span": "CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nCMPQ AX,$0\nJNE joined\nMOVL (DI),AX\nMOVL AX,(DX)",
+		"unknown dead instruction":           "JMP joined\nRDTSC\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := x86CallerAcyclicJoinAssembly(body)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown permission acquired a finite input span: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerAcyclicJoinRevokesProvisionalCertificatesForLateUnknown(t *testing.T) {
+	// The short predecessor can reach and certify the input load before the
+	// other predecessor arrives. A longer path then removes numerical bytes;
+	// neither the early certificate nor arrival order may admit the function.
+	for _, knownFirst := range []bool{true, false} {
+		fast, slow := "MOVQ $7,BX", "MOVB $7,BL"
+		if !knownFirst {
+			fast, slow = slow, fast
+		}
+		body := "CMPQ AX,$0\nJE slow\n" + fast + "\nJMP joined\nslow:\n" +
+			"MOVL $1,R10\nMOVL $2,R10\nMOVL $3,R10\nMOVL $4,R10\n" + slow +
+			"\njoined:\nMOVL (DI),AX\nMOVQ BX,AX\nMOVL AX,(DX)"
+		assembly := x86CallerAcyclicJoinAssembly(body)
+		requireX86GoAssemblerResult(t, "amd64", assembly, true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized := normalizeX86RawReturnSourceStack(decoded, Options{
+			Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs,
+		}, true, file.Funcs[0])
+		if normalized.x86SourceStack != nil || !strings.Contains(normalized.x86SourceStackFailure, "unproved caller-region effect: MOVQ") {
+			t.Fatalf("late unknown path acquired source permission: %s", normalized.x86SourceStackFailure)
+		}
+		for _, ins := range normalized.Instrs {
+			if len(ins.x86CallerMemory) != 0 || len(ins.x86SourceStackFP) != 0 {
+				t.Fatal("failed final source proof leaked a provisional instruction certificate")
+			}
+		}
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("late unknown predecessor was hidden by a prior proof: %v", err)
+		}
+	}
+}
+
+func TestX86GoCallerAcyclicJoinFinalCertificatesAndSourceMutations(t *testing.T) {
+	body := "MOVQ (CX),AX\nCMPQ AX,$1\nJE joined\nADDQ $4,DI\nCMPQ AX,$1\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)"
+	for _, change := range []string{"none", "access width", "operand", "missing caller", "actual caller bytes"} {
+		t.Run(change, func(t *testing.T) {
+			assembly := x86CallerAcyclicJoinAssembly(body)
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+			normalized, err := normalizeX86RawFile(file, "amd64", options)
+			if err != nil || normalized.Funcs[0].x86SourceStack == nil {
+				t.Fatalf("complete final source proof: %v", err)
+			}
+			found := false
+			for index := range normalized.Funcs[0].Instrs {
+				ins := &normalized.Funcs[0].Instrs[index]
+				if ins.Op != "MOVL" || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem {
+					continue
+				}
+				found = true
+				if !x86CallerMemoryCertified(*ins, 0) {
+					t.Fatal("final merged input read lacks a recomputed complete-width certificate")
+				}
+				if change == "access width" {
+					access := ins.x86CallerMemory[0]
+					access.width++
+					ins.x86CallerMemory[0] = access
+					if x86CallerMemoryCertified(*ins, 0) || x86RawReturnMemoryBound(normalized.Funcs[0], normalized, options, true) {
+						t.Fatal("changed provisional access acquired final admission")
+					}
+					// Editing a private certificate also invalidates the sealed
+					// normalized snapshot; recapture must start from original source.
+				} else if change == "operand" {
+					ins.Args[0].Mem.Base = DX
+				}
+			}
+			if !found {
+				t.Fatal("missing final original input load")
+			}
+			if change == "missing caller" {
+				sig := sigs["caller.kernel"]
+				sig.x86CallerRegions = nil
+				sigs[sig.Name] = sig
+			}
+			if change == "actual caller bytes" {
+				pkg.SourceSelection.GoSources["caller.go"] = []byte(x86CallerFixtureSource + "\nvar exposed = kernel\n")
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("changed producer caller source retained its original permission: %v", err)
+				}
+				return
+			}
+			_, err = Translate(normalized, options)
+			if change == "none" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("edited %s acquired a final caller proof: %v", change, err)
+			}
+			if change == "access width" {
+				fresh, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(fresh, options); err != nil {
+					t.Fatalf("recapture from unchanged original source: %v", err)
+				}
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, options.TargetTriple); err != nil {
+					t.Fatalf("fresh actual caller source and LLVM object: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerAcyclicJoinFiveTargetsRetain386Boundary(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			if target.arch == "amd64" {
+				assembly := x86CallerAcyclicJoinAssembly("CMPQ AX,$0\nJE joined\nADDQ $4,DI\nCMPQ AX,$0\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)")
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, target.triple); err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			// The actual caller producer remains AMD64-only. A 386 object is
+			// the existing independent scalar ABI0 control, not a copied span.
+			pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+			if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "386"); !errors.Is(err, ErrProbeNeedsContext) || proof != nil {
+				t.Fatal("AMD64 input-origin proof was borrowed by mode32")
+			}
+			source, scalarSig, _ := x86SourceStackNumericalFixture("386", "@MOV @WORD(SP),AX\nCMPL AX,$0\nJE done\nADDL $7,AX\ndone:\n@MOV AX,@RESULT(SP)\nBYTE $0xc3")
+			requireX86GoAssemblerResult(t, "386", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, x86SourceStackOptions("386", target.triple, scalarSig))
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "mode32-control.ll", "mode32-control.o", module.String())
+		})
+	}
+}
diff --git a/amd64_go_caller_acyclic_runtime_test.go b/amd64_go_caller_acyclic_runtime_test.go
new file mode 100644
index 000000000..3a8290e32
--- /dev/null
+++ b/amd64_go_caller_acyclic_runtime_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerAcyclicRuntimeSources() (goSource, assembly, goTest, cOracle string) {
+	forms := []struct {
+		name, body string
+		width      int
+	}{
+		{"inputjoin", "CMPQ AX,$1\nJE joined\nADDQ $4,DI\nCMPQ AX,$1\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)", 4},
+		{"copyjoin", "CMPQ AX,$1\nJE joined\nADDQ $4,DI\nCMPQ AX,$1\njoined:\nMOVQ DI,BX\nLEAQ 8(BX),R11\nSUBQ $8,R11\nMOVL (R11),AX\nMOVL AX,(DX)", 4},
+		{"reversedjoin", "CMPQ AX,$1\nJNE changed\nJMP joined\nchanged:\nADDQ $4,DI\nCMPQ AX,$1\njoined:\nMOVL (DI),AX\nMOVL AX,(DX)", 4},
+		{"lowjoin", "CMPQ AX,$1\nJE narrow\nMOVL $42,BX\nJMP joined\nnarrow:\nMOVB $42,BL\njoined:\nMOVB BL,(DX)", 1},
+	}
+	var declarations, machine, tests, c strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	tests.WriteString(`package caller
+import "testing"
+func TestOriginalAcyclicCallerValues(t *testing.T) {
+ values := []uint32{0,1,7,0x80000000,0xffffffff,0x12345678}
+ for _, value := range values {
+  for length:=1; length<=4; length++ {
+   x := []uint32{value,value^0xaabbccdd,19,23}
+   y := []uint32{31,37,41,43}
+   originalX, originalY := [4]uint32{x[0],x[1],x[2],x[3]}, [4]uint32{31,37,41,43}
+   canary := [4]uint64{11,17,29,53}
+   want := x[0]
+   if length!=1 { want=x[1] }
+`)
+	c.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for _, form := range forms {
+		declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint32")
+		declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+		declaration = strings.ReplaceAll(declaration, "kernel", form.name)
+		declaration = strings.Replace(declaration, "func Call(", "func Call"+form.name+"(", 1)
+		declarations.WriteString(declaration)
+		source := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+form.name)
+		source = strings.Replace(source, "MOVL $7,AX", "MOVQ (CX),AX", 1)
+		machine.WriteString(strings.Replace(source, "MOVL AX,(DX)", form.body, 1))
+		want := "want"
+		if form.width == 1 {
+			want = "uint32(42)"
+		}
+		fmt.Fprintf(&tests, `
+   if got:=Call%s(x[:length],y); got!=%s ||
+    [4]uint32{x[0],x[1],x[2],x[3]}!=originalX || [4]uint32{y[0],y[1],y[2],y[3]}!=originalY ||
+    canary!=[4]uint64{11,17,29,53} { t.Fatalf("%s length=%%d got=%%#x",length,got) }
+`, form.name, want, form.name)
+		fmt.Fprintf(&c, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", form.name, form.name)
+	}
+	tests.WriteString("  }\n }\n}\n")
+	c.WriteString(`int main(void) {
+ const uint32_t values[]={0,1,7,0x80000000u,0xffffffffu,0x12345678u};
+ for (unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+  for (uint64_t length=1;length<=4;length++) {
+   uint8_t a[33],b[35],output[29],before[29],a_before[33],b_before[35];
+   uint32_t x[4]={values[i],values[i]^0xaabbccddu,19,23},y[4]={31,37,41,43};
+   memset(a,0xa3,sizeof(a));memset(b,0xb7,sizeof(b));
+   memcpy(a+1,x,sizeof(x));memcpy(b+3,y,sizeof(y));
+   memcpy(a_before,a,sizeof(a));memcpy(b_before,b,sizeof(b));
+   const uint64_t old_length=length;
+`)
+	for _, form := range forms {
+		want := "x[length==1?0:1]"
+		if form.width == 1 {
+			want = "42"
+		}
+		fmt.Fprintf(&c, `
+   memset(output,0xc9,sizeof(output));memcpy(before,output,sizeof(output));
+   { uint32_t want=%s;memcpy(before+5,&want,%d);
+     %s(a+1,b+3,output+5,&length);
+     if (memcmp(output,before,sizeof(output)) || memcmp(a,a_before,sizeof(a)) ||
+      memcmp(b,b_before,sizeof(b)) || length!=old_length) return 1;
+   }
+`, want, form.width, form.name)
+	}
+	c.WriteString("  }\n }\n return 0;\n}\n")
+	return declarations.String(), machine.String(), tests.String(), c.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerAcyclicJoinValuesAndCanaries(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 caller runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	goSource, assembly, goTest, cOracle := x86CallerAcyclicRuntimeSources()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": goSource,
+		"value_amd64.s": assembly, "value_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go caller branch/canary oracle: %v\n%s", err, output)
+	}
+	pkg := x86CallerRuntimePackage(t, goSource, assembly)
+	llvmContext := llvm.NewContext()
+	defer llvmContext.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(llvmContext, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if translation != nil && !translation.Module.IsNil() {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "caller_acyclic_join", triple, translation.Module.String(), cOracle, runner)
+}
diff --git a/amd64_go_caller_add_sub.go b/amd64_go_caller_add_sub.go
new file mode 100644
index 000000000..ba9c4a877
--- /dev/null
+++ b/amd64_go_caller_add_sub.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+func x86CallerFloatAddSubStep(ins *Instr, form x86FloatAddSubForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	return x86CallerFloatBinaryStep(ins, form.x86FloatBinaryForm, state, proof)
+}
+
+func x86CallerFloatBinaryStep(ins *Instr, form x86FloatBinaryForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := int64(form.byteWidth)
+	if form.scalar {
+		width = int64(form.bits / 8)
+	}
+	required := x86CallerVectorByteMask(width)
+	if form.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+		return false
+	}
+	for _, index := range []int{form.first, form.second} {
+		if form.literal && index == form.first {
+			continue
+		}
+		if index != form.memory && state.vectors[x86CallerVectorRoot(ins.Args[index].Reg)]&required != required {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	// A merely initialized mask does not prove any lane active. Merge needs
+	// the old numerical lane(s), zeroing does not; neither invents inputs.
+	if form.mask >= 0 && !form.zeroing && old&required != required {
+		return false
+	}
+	known := ^uint64(0)
+	if form.legacy {
+		known = old | required
+	} else if form.scalar {
+		upperX := x86CallerVectorByteMask(16) &^ required
+		second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)]
+		known = ^x86CallerVectorByteMask(16) | required | second&upperX
+	}
+	state.vectors[destination] = known
+	return true
+}
diff --git a/amd64_go_caller_add_sub_test.go b/amd64_go_caller_add_sub_test.go
new file mode 100644
index 000000000..f085f46a6
--- /dev/null
+++ b/amd64_go_caller_add_sub_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFloatAddSubOriginalSourceReachesObjects(t *testing.T) {
+	for _, fixture := range []struct {
+		name string
+		body string
+	}{
+		{"original VADDPS LONG", "VMOVUPS (DI),Y2\nVMOVUPS (SI),Y3\nLONG $0xd358ecc5\nVMOVSS X2,(DX)"},
+		{"named VADDPS", "VMOVUPS (DI),Y2\nVMOVUPS (SI),Y3\nVADDPS Y3,Y2,Y2\nVMOVSS X2,(DX)"},
+		{"original VSUBSS family", "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVSUBSS X0,X1,X2\nVMOVSS X2,(DX)"},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", fixture.body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerFloatAddSubWholeFamilyByteEffects(t *testing.T) {
+	for _, row := range x86FloatAddSubFormats("amd64") {
+		if strings.Contains(row, "(AX)") || strings.Contains(row, "8(AX)") {
+			continue
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86FloatAddSubProperties(ins, "amd64")
+		if !recognized || err != nil || !x86CallerVectorMoveKnown(ins) {
+			t.Fatalf("missing shared family effect %s: %v", row, err)
+		}
+		for _, missing := range []int{-1, form.first, form.second, form.destination, 4} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+			if missing >= 0 && missing < len(ins.Args) && ins.Args[missing].Kind == OpReg {
+				state.vectors[x86CallerVectorRoot(ins.Args[missing].Reg)] &^= 1
+			}
+			if missing == 4 {
+				state.masks["K1"] = false
+			}
+			before, beforeMasks := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerFloatAddSubStep(&ins, form, &state, nil)
+			want := missing == -1 || missing == form.destination && !form.spec.legacy && (form.mask < 0 || form.zeroing) || missing == 4 && form.mask < 0
+			if accepted != want || !reflect.DeepEqual(state.masks, beforeMasks) || !accepted && !reflect.DeepEqual(state.vectors, before) {
+				t.Fatalf("%s missing %d: %t want %t, invented numerical/mask evidence", row, missing, accepted, want)
+			}
+		}
+		width := int64(form.byteWidth)
+		if form.spec.scalar {
+			width = int64(form.spec.bits / 8)
+		}
+		low := x86CallerVectorByteMask(width)
+		for _, old := range []uint64{0, 0xff00, 0xff00000000, ^uint64(0)} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": low, "Z1": low | old, "Z2": low | old}, masks: map[Reg]bool{"K1": true}}
+			if !x86CallerFloatAddSubStep(&ins, form, &state, nil) {
+				t.Fatalf("low arithmetic requires unrelated unknown bytes: %s", row)
+			}
+			destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+			want := ^uint64(0)
+			if form.spec.legacy {
+				want = low | old
+			} else if form.spec.scalar {
+				want = ^x86CallerVectorByteMask(16) | low | old&(x86CallerVectorByteMask(16)&^low)
+			}
+			if state.vectors[destination] != want {
+				t.Fatalf("%s physical byte definitions %x want %x", row, state.vectors[destination], want)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerFloatAddSubDoesNotInventValuesOrCallerPermissions(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown arithmetic source":        "VADDPS X0,X1,X2\nVMOVSS X2,(DX)",
+		"SUB is not an integer zero idiom": "VSUBPS X0,X0,X2\nVMOVSS X2,(DX)",
+		"unknown destructive destination":  "VMOVUPS (DI),X0\nADDPS X0,X1\nVMOVSS X1,(DX)",
+		"unknown merge":                    "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nKMOVQ AX,K1\nVADDPS X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"unknown mask":                     "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVADDPS.Z X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"mask pointer bits":                "VMOVUPS (DI),X0\nKMOVQ DI,K1\nVSUBPS.Z X0,X0,K1,X2\nVMOVSS X2,(DX)",
+		"unknown memory":                   "VMOVUPS (DI),X0\nVADDPS (BX),X0,X2\nVMOVSS X2,(DX)",
+		"physical stack":                   "VMOVUPS (DI),X0\nVADDPS 0(SP),X0,X2\nVMOVSS X2,(DX)",
+		"FP pointer contents":              "VMOVUPS (DI),X0\nVADDPS a+0(FP),X0,X2\nVMOVSS X2,(DX)",
+		"read length as vector":            "VMOVUPS (DI),X0\nVADDPS (CX),X0,X2\nVMOVSS X2,(DX)",
+		"read g":                           "VMOVUPS (DI),X0\nVADDPS (R14),X0,X2\nVMOVSS X2,(DX)",
+		"wide output":                      "VMOVUPS (DI),X0\nVADDPS X0,X0,X2\nVMOVUPS X2,(DX)",
+		"write input":                      "VMOVUPS (DI),X0\nVADDPS X0,X0,X2\nVMOVSS X2,(DI)",
+		"unknown CFG join":                 "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),X0\njoined:\nVADDPS X0,X0,X2\nVMOVSS X2,(DX)",
+		"scalar unknown upper reused":      "VMOVSS (DI),X0\nVADDSS X0,X3,X2\nVADDPS X2,X2,X2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved add/sub source passed: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerFloatAddSubAllOpcodesInitializedMemory(t *testing.T) {
+	for _, opcode := range x86FloatAddSubOpcodes() {
+		t.Run(opcode, func(t *testing.T) {
+			args := "(DI),X1"
+			destination := "X1"
+			if strings.HasPrefix(opcode, "V") {
+				args += ",X2"
+				destination = "X2"
+			}
+			body := fmt.Sprintf("VMOVUPS (SI),Z1\n%s %s\nVMOVSS %s,(DX)", opcode, args, destination)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_aes.go b/amd64_go_caller_aes.go
new file mode 100644
index 000000000..f502016f5
--- /dev/null
+++ b/amd64_go_caller_aes.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+func x86CallerAESByteStep(ins *Instr, f x86AESForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	width := x86CallerVectorByteMask(int64(f.byteWidth))
+	source := state.vectors[x86CallerVectorRoot(ins.Args[f.source].Reg)] & width
+	if f.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.byteWidth), false) {
+			return false
+		}
+		source = width
+	}
+	input := uint64(0)
+	if f.state >= 0 {
+		input = state.vectors[x86CallerVectorRoot(ins.Args[f.state].Reg)] & width
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	defined := x86AESDefinedBytes(f, source, input)
+	if !f.spec.vector {
+		state.vectors[destination] = state.vectors[destination]&^width | defined
+	} else {
+		state.vectors[destination] = ^width | defined
+	}
+	return true
+}
diff --git a/amd64_go_caller_binding.go b/amd64_go_caller_binding.go
new file mode 100644
index 000000000..339cf9377
--- /dev/null
+++ b/amd64_go_caller_binding.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+// GoX86RawReturnCallerBindingNeeded is only a loader cost predicate. A true
+// result proves neither a caller region nor a valid source continuation.
+func GoX86RawReturnCallerBindingNeeded(file *File, goarch string, resolve func(string) string, sigs map[string]FuncSig) bool {
+	if file == nil || goarch != "amd64" || resolve == nil {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		if x86GoCallerRegionCandidate(fn, sigs[resolve(goTextSymbolForResolution(fn.Sym))]) {
+			return true
+		}
+	}
+	return false
+}
+
+// BindGoX86RawReturnCallerRegions consumes the compiler's complete actual
+// typed package selection. It returns new signatures with private source
+// evidence; the whole-source normalizer must still prove every stack, memory
+// effect and return. Pointer/noescape types or JSON hashes are insufficient.
+func BindGoX86RawReturnCallerRegions(pkg GoPackage, file *File, goarch string, resolve func(string) string, sigs map[string]FuncSig) (map[string]FuncSig, error) {
+	if !GoX86RawReturnCallerBindingNeeded(file, goarch, resolve, sigs) {
+		return sigs, nil
+	}
+	if pkg.SourceSelection == nil {
+		return nil, fmt.Errorf("%w: bounded raw-return caller binding requires actual selected source", ErrProbeNeedsContext)
+	}
+	bound := make(map[string]FuncSig, len(sigs))
+	for name, sig := range sigs {
+		bound[name] = sig
+	}
+	for _, fn := range file.Funcs {
+		name := resolve(goTextSymbolForResolution(fn.Sym))
+		sig := bound[name]
+		if !x86GoCallerRegionCandidate(fn, sig) {
+			continue
+		}
+		proof, err := deriveX86GoCallerRegions(pkg, *pkg.SourceSelection, fn, sig, goarch)
+		if err != nil {
+			return nil, err
+		}
+		sig.x86CallerRegions = proof
+		bound[name] = sig
+	}
+	return bound, nil
+}
diff --git a/amd64_go_caller_binding_test.go b/amd64_go_caller_binding_test.go
new file mode 100644
index 000000000..30b05c53a
--- /dev/null
+++ b/amd64_go_caller_binding_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerRegionBindingRequiresCompleteTypedSelection(t *testing.T) {
+	for _, change := range []string{"none", "missing selection", "missing sizes", "wrong sizes", "changed source", "missing assembly"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, selected, _, sig := x86CallerFixture(t, x86CallerFixtureSource)
+			file := selected.Assembly["kernel_amd64.s"]
+			pkg.SourceSelection = &selected
+			sigs := map[string]FuncSig{sig.Name: sig}
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			switch change {
+			case "missing selection":
+				pkg.SourceSelection = nil
+			case "missing sizes":
+				selected.Sizes = nil
+			case "wrong sizes":
+				selected.Sizes = types.SizesFor("gc", "386")
+			case "changed source":
+				selected.GoSources["caller.go"] = []byte(x86CallerFixtureSource + "\nvar exposed = kernel\n")
+			case "missing assembly":
+				selected.SelectedAssemblyFiles = nil
+			}
+			bound, err := BindGoX86RawReturnCallerRegions(pkg, file, "amd64", resolve, sigs)
+			if change == "none" {
+				if err != nil || bound[sig.Name].x86CallerRegions == nil {
+					t.Fatalf("actual selection acquired no private binding: %v", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || bound != nil {
+				t.Fatalf("%s obtained complete/partial binding: %+v, %v", change, bound, err)
+			}
+			if sigs[sig.Name].x86CallerRegions != nil {
+				t.Fatal("caller-owned signature map was mutated")
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_counted_loop.go b/amd64_go_caller_counted_loop.go
new file mode 100644
index 000000000..d8901ae41
--- /dev/null
+++ b/amd64_go_caller_counted_loop.go
@@ -0,0 +1,496 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"strings"
+)
+
+// This private plan partitions numerical low bits, not allocation bounds. It
+// never supplies a pointer, initial GP value, public option or serialized proof.
+type x86CallerCountedPlan struct {
+	edges                [][]int
+	loops                []x86CallerCountedLoop
+	headers, latches     map[int]int
+	original, normalized [32]byte
+}
+
+type x86CallerCountedLoop struct {
+	body                  map[int]bool
+	header, latch, update int
+	counter, bound        Reg
+}
+
+func x86CallerCountedEdges(fn Func, instructions []int, labels map[string]int) ([][]int, bool) {
+	if len(instructions) == 0 || len(instructions) > 8192 {
+		return nil, false
+	}
+	edges := make([][]int, len(instructions))
+	for pc, index := range instructions {
+		ins := fn.Instrs[index]
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		if op == OpRET {
+			continue
+		}
+		edges[pc] = []int{pc + 1}
+		if op == OpJMP || isAMD64ConditionalBranch(op) {
+			if len(ins.Args) != 1 {
+				return nil, false
+			}
+			arg := ins.Args[0]
+			label := arg.Sym
+			if arg.Kind == OpIdent {
+				label = arg.Ident
+			}
+			target, valid := labels[label]
+			if arg.Kind == OpMem && arg.Mem.Base == PC && arg.Mem.Index == "" && arg.Mem.Sym == "" &&
+				arg.Mem.Off >= -int64(len(instructions)) && arg.Mem.Off <= int64(len(instructions)) {
+				target, valid = pc+int(arg.Mem.Off), true
+			} else if arg.Kind != OpLabel && arg.Kind != OpIdent {
+				return nil, false
+			}
+			if !valid {
+				return nil, false
+			}
+			if op == OpJMP {
+				edges[pc] = []int{target}
+			} else {
+				edges[pc] = append(edges[pc], target)
+			}
+		}
+		for _, next := range edges[pc] {
+			if next < 0 || next >= len(instructions) {
+				return nil, false
+			}
+		}
+	}
+	return edges, true
+}
+
+// Each SCC must retain the original one-loop rule: one entry edge, one exact
+// adjacent comparison/latch, an immutable bound and one unavoidable +1 update.
+// Its remaining edges must be a DAG, not an inferred cyclic merge invariant.
+func deriveX86CallerCountedLoop(fn Func, instructions []int, edges [][]int, reachable []bool,
+	body map[int]bool, header, latchPC int) *x86CallerCountedLoop {
+	plan := &x86CallerCountedLoop{body: body, header: header, latch: latchPC, update: -1}
+	if plan.latch == 0 || !plan.body[plan.latch-1] {
+		return nil
+	}
+	latch := fn.Instrs[instructions[plan.latch]]
+	compare := fn.Instrs[instructions[plan.latch-1]]
+	if latch.Op != "JNE" || len(edges[plan.latch]) != 2 || edges[plan.latch][1] != plan.header ||
+		(compare.Op != "CMPL" && compare.Op != "CMPQ") || len(compare.Args) != 2 ||
+		compare.Args[0].Kind != OpReg || compare.Args[1].Kind != OpReg {
+		return nil
+	}
+	left, leftOK := x86CallerGP(compare.Args[0].Reg)
+	right, rightOK := x86CallerGP(compare.Args[1].Reg)
+	if !leftOK || !rightOK || left == right || left != compare.Args[0].Reg || right != compare.Args[1].Reg {
+		return nil
+	}
+	entries, updates := 0, 0
+	for pc, nexts := range edges {
+		if !reachable[pc] {
+			continue
+		}
+		for _, next := range nexts {
+			if next == plan.latch && pc != plan.latch-1 {
+				return nil // The latch must consume this exact adjacent comparison.
+			}
+			if !plan.body[pc] && plan.body[next] {
+				if next != plan.header {
+					return nil
+				}
+				entries++
+			}
+			if plan.body[pc] && !plan.body[next] && pc != plan.latch {
+				return nil
+			}
+		}
+		if !plan.body[pc] {
+			continue
+		}
+		ins := fn.Instrs[instructions[pc]]
+		if (ins.Op == "ADDL" || ins.Op == "ADDQ") && len(ins.Args) == 2 &&
+			ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" && ins.Args[0].Imm == 1 &&
+			ins.Args[1].Kind == OpReg && (ins.Args[1].Reg == left || ins.Args[1].Reg == right) {
+			updates++
+			plan.update, plan.counter = pc, ins.Args[1].Reg
+		}
+	}
+	if entries != 1 || updates != 1 {
+		return nil
+	}
+	plan.bound = left
+	if plan.counter == left {
+		plan.bound = right
+	}
+	// Every body path must pass the one update; both live values stay immutable
+	// otherwise. Conservatively reject even an unmodeled read of these registers.
+	for pc := range plan.body {
+		ins := fn.Instrs[instructions[pc]]
+		if pc == plan.update || ins.Op == "CMPL" || ins.Op == "CMPQ" || isAMD64ConditionalBranch(ins.Op) || ins.Op == OpJMP {
+			continue
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind == OpReg {
+				root, _ := x86CallerGP(arg.Reg)
+				if root == plan.counter || root == plan.bound {
+					return nil
+				}
+			}
+		}
+	}
+	seen := map[int]bool{}
+	work := []int{plan.header}
+	for len(work) != 0 {
+		pc := work[0]
+		work = work[1:]
+		if pc == plan.update || seen[pc] {
+			continue
+		}
+		if pc == plan.latch {
+			return nil
+		}
+		seen[pc] = true
+		work = append(work, edges[pc]...)
+	}
+	return plan
+}
+
+type x86CallerCountedNumber struct {
+	source, version int
+	mask, value     uint64
+	known           bool
+}
+
+type x86CallerCountedFlags struct {
+	pc           int
+	op           Op
+	regs         [2]Reg
+	versions     [2]int
+	equal, known bool
+}
+
+type x86CallerCountedNumbers struct {
+	regs             map[Reg]x86CallerCountedNumber
+	flags            x86CallerCountedFlags
+	source, sequence int
+}
+
+func (facts x86CallerCountedNumbers) clone() x86CallerCountedNumbers {
+	copy := facts
+	copy.regs = make(map[Reg]x86CallerCountedNumber, len(facts.regs))
+	for reg, value := range facts.regs {
+		copy.regs[reg] = value
+	}
+	return copy
+}
+
+// Relational evidence is independent of numericFlags. Unknown upper bits stay
+// unknown; only a real readonly local-length load supplies the partition source.
+func (facts *x86CallerCountedNumbers) step(pc, residue int, ins Instr, before x86SourceStackState, proof *x86GoCallerRegionProof) {
+	op := Op(normalizeInstructionOpcode(x86SourceMoveInstruction(ins, "amd64").Op))
+	if effect, known, err := x86TypedCounterControlByteEffect(ins.Op, ins, "amd64"); known {
+		if err != nil {
+			for register := range facts.regs {
+				delete(facts.regs, register)
+			}
+			facts.flags = x86CallerCountedFlags{}
+			facts.sequence++
+			return
+		}
+		for _, operand := range effect.operands {
+			if operand.write && operand.operand.Kind == OpReg {
+				facts.sequence++
+				if register, valid := x86CallerGP(operand.operand.Reg); valid {
+					delete(facts.regs, register)
+				}
+			}
+		}
+		return // Preserve actual FLAGS, but never retain a decremented exact value/version.
+	}
+	if op == OpTEXT || op == OpRET || op == OpJMP || isAMD64ConditionalBranch(op) {
+		return
+	}
+	facts.sequence++
+	if (op == "CMPL" || op == "CMPQ" || op == "TESTB" || op == "TESTW" || op == "TESTL" || op == "TESTQ") && len(ins.Args) == 2 {
+		facts.flags = x86CallerCountedFlags{pc: pc, op: op}
+		values := [2]x86CallerCountedNumber{}
+		for index, arg := range ins.Args {
+			if arg.Kind == OpImm && arg.ImmRaw == "" {
+				values[index] = x86CallerCountedNumber{source: -1, value: uint64(arg.Imm), known: true}
+			} else if arg.Kind == OpReg {
+				root, valid := x86CallerGP(arg.Reg)
+				if !valid || arg.Reg != root {
+					return
+				}
+				var present bool
+				values[index], present = facts.regs[root]
+				if !present {
+					return
+				}
+				facts.flags.regs[index], facts.flags.versions[index] = root, values[index].version
+			} else {
+				return
+			}
+		}
+		if strings.HasPrefix(string(op), "TEST") {
+			for index := range values {
+				other := values[1-index]
+				if !values[index].known && values[index].source == facts.source && facts.source >= 0 && other.known && other.value <= 3 {
+					values[index].value, values[index].known = uint64(residue), true
+				}
+			}
+			mask := uint64(math.MaxUint64)
+			switch op {
+			case "TESTB":
+				mask = math.MaxUint8
+			case "TESTW":
+				mask = math.MaxUint16
+			case "TESTL":
+				mask = math.MaxUint32
+			}
+			facts.flags.equal = values[0].value&values[1].value&mask == 0
+		} else {
+			if op == "CMPL" {
+				values[0].value, values[1].value = uint64(uint32(values[0].value)), uint64(uint32(values[1].value))
+			}
+			facts.flags.equal = values[0].value == values[1].value
+		}
+		facts.flags.known = values[0].known && values[1].known
+		return
+	}
+	move := op == "MOVL" || op == "MOVQ"
+	_, conditionalMove, conditionalMoveError := x86ConditionalMoveProperties(op, ins, "amd64")
+	if !move && !(conditionalMove && conditionalMoveError == nil) && x86LEAWidth(op, "amd64") == 0 && op != "PUSHQ" && op != "POPQ" &&
+		!strings.HasPrefix(string(op), "MOV") && !strings.HasPrefix(string(op), "VMOV") {
+		facts.flags = x86CallerCountedFlags{}
+	}
+	if len(ins.Args) == 0 || ins.Args[len(ins.Args)-1].Kind != OpReg {
+		return
+	}
+	arg := ins.Args[len(ins.Args)-1]
+	reg, valid := x86CallerGP(arg.Reg)
+	if !valid {
+		return
+	}
+	old, oldPresent := facts.regs[reg]
+	delete(facts.regs, reg)
+	if arg.Reg != reg || len(ins.Args) != 2 {
+		return
+	}
+	source := ins.Args[0]
+	value := x86CallerCountedNumber{source: -1, version: facts.sequence}
+	if move {
+		switch source.Kind {
+		case OpImm:
+			if source.ImmRaw != "" || source.ImmIsFloat {
+				return
+			}
+			value.value, value.known = uint64(source.Imm), true
+		case OpReg:
+			root, ok := x86CallerGP(source.Reg)
+			if !ok || root != source.Reg {
+				return
+			}
+			if root == reg {
+				value = old
+			} else {
+				var present bool
+				value, present = facts.regs[root]
+				if !present {
+					return
+				}
+			}
+			if !oldPresent && root == reg {
+				return
+			}
+		case OpMem:
+			pointer, present := before.callers[source.Mem.Base]
+			if op != "MOVQ" || !present || pointer.offset != 0 || pointer.span != 0 ||
+				pointer.argument < 0 || pointer.argument >= len(proof.arguments) || proof.arguments[pointer.argument].kind != x86CallerLocalLength ||
+				source.Mem.Off != 0 || source.Mem.Index != "" || source.Mem.Sym != "" || source.Mem.Segment != "" {
+				return
+			}
+			value.source = pc
+			if facts.source < 0 {
+				facts.source = pc
+			}
+		default:
+			return
+		}
+		if op == "MOVL" && value.known {
+			value.value = uint64(uint32(value.value))
+		}
+	} else if (op == "XORL" || op == "XORQ") && source.Kind == OpReg && source.Reg == reg {
+		value.value, value.known = 0, true
+	} else if (op == "ANDL" || op == "ANDQ") && oldPresent && source.Kind == OpImm && source.ImmRaw == "" {
+		value = old
+		if old.known {
+			value.value &= uint64(source.Imm)
+		} else if old.source == facts.source && facts.source >= 0 && source.Imm > 0 && source.Imm <= 3 {
+			value.mask, value.value, value.known = uint64(source.Imm), uint64(residue)&uint64(source.Imm), true
+		} else {
+			return
+		}
+	} else if (op == "ADDL" || op == "ADDQ") && oldPresent && old.known && source.Kind == OpImm && source.ImmRaw == "" {
+		limit := uint64(math.MaxUint64)
+		if op == "ADDL" {
+			limit = math.MaxUint32
+		}
+		if source.Imm < 0 || old.value > limit || uint64(source.Imm) > limit-old.value {
+			return
+		}
+		value.value, value.known = old.value+uint64(source.Imm), true
+	} else {
+		return
+	}
+	if (op == "ANDL" || op == "ADDL") && value.known {
+		value.value = uint64(uint32(value.value))
+	}
+	value.version = facts.sequence
+	facts.regs[reg] = value
+}
+
+type x86CallerCountedVisit struct {
+	pc, residue, iteration, loop int
+	state                        x86SourceStackState
+	numbers                      x86CallerCountedNumbers
+}
+
+type x86CallerCountedWork struct {
+	x86CallerCountedVisit
+	bound x86CallerCountedNumber
+	entry x86SourceStackState
+}
+
+func x86CallerCountedOrigins(entry, current x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if entry.sp != current.sp || entry.bp != current.bp || entry.gOriginal != current.gOriginal ||
+		!reflect.DeepEqual(entry.cells, current.cells) || len(entry.callers) != len(current.callers) {
+		return false
+	}
+	for reg, pointer := range entry.callers {
+		other, present := current.callers[reg]
+		if !present || pointer.argument != other.argument || pointer.argument < 0 || pointer.argument >= len(proof.arguments) {
+			return false
+		}
+		if _, valid := x86CallerPointerEnd(other); !valid {
+			return false
+		}
+		if proof.arguments[pointer.argument].kind != x86CallerSliceInput && pointer != other {
+			return false
+		}
+	}
+	return true
+}
+
+type x86CallerCountedTransfer func(int, *Instr, *x86SourceStackState) (bool, string)
+
+// Each feasible path keeps a fresh state, so no predecessor can supply another
+// path's permission. The finite visit cap fails; it never widens a loop state.
+func replayX86CallerCountedPlan(plan *x86CallerCountedPlan, fn *Func, instructions []int, initial x86SourceStackState,
+	proof *x86GoCallerRegionProof, transfer x86CallerCountedTransfer) ([]x86CallerCountedVisit, string) {
+	var visits []x86CallerCountedVisit
+	returned := 0
+	for residue := 0; residue <= 3; residue++ {
+		work := []x86CallerCountedWork{{x86CallerCountedVisit: x86CallerCountedVisit{
+			residue: residue, iteration: -1, loop: -1, state: x86CloneCallerState(initial),
+			numbers: x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{}, source: -1},
+		}}}
+		for len(work) != 0 {
+			if len(visits) >= 8192 {
+				return nil, "counted-loop finite path budget exhausted"
+			}
+			item := work[0]
+			work = work[1:]
+			pc := item.pc
+			if loopIndex, header := plan.headers[pc]; header {
+				loop := plan.loops[loopIndex]
+				bound, bOK := item.numbers.regs[loop.bound]
+				counter, cOK := item.numbers.regs[loop.counter]
+				if item.loop != -1 && item.loop != loopIndex {
+					return nil, "counted-loop entry crosses an active SCC"
+				}
+				if item.loop == -1 {
+					item.loop = loopIndex
+					item.iteration, item.bound = 0, bound
+					item.entry = x86CloneCallerState(item.state)
+				}
+				if !bOK || !cOK || !bound.known || !counter.known || bound.value == 0 || bound.value > 3 ||
+					bound.source != item.numbers.source || bound.source < 0 || bound.mask == 0 || bound.mask > 3 ||
+					!reflect.DeepEqual(bound, item.bound) || counter.value != uint64(item.iteration) || item.iteration >= 3 {
+					return nil, "counted-loop entry lacks immutable bounded value and zero-based counter"
+				}
+			}
+			visits = append(visits, item.x86CallerCountedVisit)
+			state, numbers := x86CloneCallerState(item.state), item.numbers.clone()
+			ins := &fn.Instrs[instructions[pc]]
+			ins.x86CallerMemory, ins.x86SourceStackFP = nil, nil
+			isReturn, reason := transfer(pc, ins, &state)
+			if reason != "" {
+				return nil, fmt.Sprintf("normalized instruction %d: %s", instructions[pc], reason)
+			}
+			if isReturn {
+				if item.loop != -1 {
+					return nil, "counted-loop return bypasses its exact latch"
+				}
+				returned++
+				continue
+			}
+			numbers.step(pc, residue, *ins, item.state, proof)
+			nexts := plan.edges[pc]
+			if loopIndex, latch := plan.latches[pc]; latch {
+				loop := plan.loops[loopIndex]
+				flags, counter, bound := numbers.flags, numbers.regs[loop.counter], numbers.regs[loop.bound]
+				if item.loop != loopIndex {
+					return nil, "counted-loop latch lacks its original SCC entry"
+				}
+				if !flags.known || flags.pc != pc-1 || !counter.known || counter.value != uint64(item.iteration+1) ||
+					!reflect.DeepEqual(bound, item.bound) || !x86CallerCountedOrigins(item.entry, state, proof) {
+					return nil, "counted-loop latch lacks exact counter, bound and comparison versions"
+				}
+				for index, reg := range flags.regs {
+					if (reg != loop.counter && reg != loop.bound) || flags.versions[index] != numbers.regs[reg].version {
+						return nil, "counted-loop comparison observes stale operand versions"
+					}
+				}
+			}
+			if (ins.Op == "JE" || ins.Op == "JNE") && numbers.flags.known {
+				taken := numbers.flags.equal == (ins.Op == "JE")
+				if taken {
+					nexts = nexts[1:]
+				} else {
+					nexts = nexts[:1]
+				}
+			}
+			for _, next := range nexts {
+				iteration, loopIndex := item.iteration, item.loop
+				bound, entry := item.bound, item.entry
+				if item.loop >= 0 {
+					loop := plan.loops[item.loop]
+					if pc == loop.latch && next == loop.header {
+						iteration++
+					} else if !loop.body[next] {
+						if pc != loop.latch {
+							return nil, "counted-loop exit bypasses its exact latch"
+						}
+						// Clear only this loop's control witness. All source origins,
+						// initialized bytes, numerical versions and flags survive.
+						iteration, loopIndex = -1, -1
+						bound, entry = x86CallerCountedNumber{}, x86SourceStackState{}
+					}
+				}
+				work = append(work, x86CallerCountedWork{x86CallerCountedVisit: x86CallerCountedVisit{
+					pc: next, residue: residue, iteration: iteration, loop: loopIndex,
+					state: x86CloneCallerState(state), numbers: numbers.clone(),
+				}, bound: bound, entry: x86CloneCallerState(entry)})
+			}
+		}
+	}
+	if returned == 0 {
+		return nil, "counted-loop replay has no original source return"
+	}
+	return visits, ""
+}
diff --git a/amd64_go_caller_counted_loop_boundary_test.go b/amd64_go_caller_counted_loop_boundary_test.go
new file mode 100644
index 000000000..7aefb5bc0
--- /dev/null
+++ b/amd64_go_caller_counted_loop_boundary_test.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerCountedLoopRejectedChanges() map[string][2]string {
+	return map[string][2]string{
+		"missing nonzero guard":    {"JE done\n", ""},
+		"reversed guard":           {"JE done", "JNE done"},
+		"stale guard flags":        {"JE done", "ADDL $1,R10\nJE done"},
+		"different guard bits":     {"TESTB $3,R9", "TESTB $4,R9"},
+		"byte flags truncate":      {"TESTB $3,R9\nJE done", "MOVL $256,R8\nTESTB R8,R8\nJNE done"},
+		"unmapped length":          {"MOVQ (CX),R9", "MOVQ (SI),R9"},
+		"unknown length":           {"MOVQ (CX),R9", "MOVQ R12,R9"},
+		"bound four":               {"ANDL $3,AX", "ANDL $7,AX"},
+		"unrelated bound":          {"MOVL R9,AX", "MOVL $2,AX"},
+		"partial bound":            {"MOVL R9,AX", "MOVW R9,AX"},
+		"bound overwritten":        {"MOVL (DI),BX", "ANDL $3,AX\nMOVL (DI),BX"},
+		"bound alias":              {"ANDL $3,AX", "ANDL $3,CX"},
+		"counter absent":           {"XORL CX,CX", ""},
+		"counter nonzero":          {"XORL CX,CX", "MOVQ $1,CX"},
+		"counter high bits":        {"XORL CX,CX", "MOVQ $0x100000000,CX"},
+		"partial counter":          {"XORL CX,CX", "XORW CX,CX"},
+		"zero stride":              {"ADDQ $1,CX", "ADDQ $0,CX"},
+		"negative stride":          {"ADDQ $1,CX", "SUBQ $1,CX"},
+		"two stride":               {"ADDQ $1,CX", "ADDQ $2,CX"},
+		"double update":            {"ADDQ $1,CX", "ADDQ $1,CX\nADDQ $1,CX"},
+		"update bypass":            {"ADDQ $1,CX", "TESTL BX,BX\nJE compare\nADDQ $1,CX\ncompare:"},
+		"stale latch flags":        {"JNE again", "ADDL $1,R10\nJNE again"},
+		"different latch operands": {"CMPL CX,AX", "CMPL BX,AX"},
+		"side entry":               {"JE done", "JE again"},
+		"nested loop":              {"MOVL (DI),BX", "inner:\nCMPQ R9,$0\nJNE inner\nMOVL (DI),BX"},
+		"unknown indirect target":  {"JNE again", "JNE again\nJMP R12"},
+		"unknown dead effect":      {"again:", "JMP again\nRDTSC\nagain:"},
+		"different input origin":   {"ADDQ $4,DI", "MOVQ SI,DI"},
+		"missing input origin":     {"ADDQ $4,DI", "MOVQ $0,DI"},
+		"readonly write":           {"MOVL (DI),BX", "MOVL R10,(DI)\nMOVL (DI),BX"},
+		"result displacement":      {"ADDQ $4,DI", "ADDQ $1,DX\nADDQ $4,DI"},
+		"source stack escape":      {"ADDQ $4,DI", "MOVQ DI,SP\nADDQ $4,DI"},
+		"input cap":                {"ADDQ $4,DI", "ADDQ $1048576,DI"},
+		"pointer truncation":       {"ADDQ $4,DI", "LEAL 4(DI),DI"},
+		"unknown first GP":         {"ADDL R11,BX", "ADDL R12,BX"},
+		"late first GP":            {"MOVL (DI),BX", "ADDL BX,R10\nMOVL (DI),BX"},
+		"unknown first vector":     {"MOVL (DI),BX", "VEXTRACTF128 $1,Y0,X1\nMOVL (DI),BX"},
+		"unknown first mask":       {"MOVL (DI),BX", "VMOVUPS (DI),Z0\nVPADDD.Z Z0,Z0,K1,Z1\nMOVL (DI),BX"},
+		"mask zero no rights":      {"MOVL (DI),BX", "VMOVUPS (DI),Z0\nMOVL $0,BX\nKMOVQ BX,K1\nVPADDD.Z (DX),Z0,K1,Z1\nMOVL (DI),BX"},
+	}
+}
+
+func TestX86GoCallerCountedLoopRetainsUnprovedPaths(t *testing.T) {
+	original := x86CallerCountedLoopScalarAssembly(false)
+	for name, change := range x86CallerCountedLoopRejectedChanges() {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(original, change[0], change[1], 1)
+			if assembly == original {
+				t.Fatal("negative failed to change its original source")
+			}
+			pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved %s admitted: %v", name, err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedLoopSealsAllPartitionsAndSource(t *testing.T) {
+	for _, change := range []string{"none", "original", "normalized", "missing caller", "certificate width"} {
+		t.Run(change, func(t *testing.T) {
+			assembly := x86CallerCountedLoopScalarAssembly(true)
+			pkg, file := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+			normalized, err := normalizeX86RawFile(file, "amd64", options)
+			if err != nil || normalized.Funcs[0].x86SourceStack == nil {
+				t.Fatalf("complete finite source proof: %v", err)
+			}
+			proof := normalized.Funcs[0].x86SourceStack
+			if proof.countedIterations != [4]int{0, 1, 2, 3} {
+				t.Fatalf("missing or altered feasible residue visits: %v", proof.countedIterations)
+			}
+			actualHash, err := x86CallerSourceFingerprint(normalized.Funcs[0])
+			if err != nil || actualHash != proof.normalized {
+				t.Fatal("complete normalized identity was not sealed")
+			}
+			if change == "original" {
+				file.Funcs[0].Instrs[1].Args[0].FPOffset++
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				failed := normalizeX86RawReturnSourceStack(decoded, options, true, file.Funcs[0])
+				if failed.x86SourceStack != nil {
+					t.Fatal("changed original source borrowed its old caller identity")
+				}
+				return
+			}
+			for index := range normalized.Funcs[0].Instrs {
+				ins := &normalized.Funcs[0].Instrs[index]
+				if ins.Op != "MOVL" || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem {
+					continue
+				}
+				if !x86CallerMemoryCertified(*ins, 0) {
+					t.Fatal("original full-width read lacks a final replay certificate")
+				}
+				if change == "certificate width" {
+					access := ins.x86CallerMemory[0]
+					access.width++
+					ins.x86CallerMemory[0] = access
+					if x86CallerMemoryCertified(*ins, 0) || x86RawReturnMemoryBound(normalized.Funcs[0], normalized, options, true) {
+						t.Fatal("mutated private width acquired admission")
+					}
+				} else if change == "normalized" {
+					ins.Args[0].Mem.Base = DX
+				}
+			}
+			if change == "missing caller" {
+				sig := sigs["caller.kernel"]
+				sig.x86CallerRegions = nil
+				sigs[sig.Name] = sig
+			}
+			_, err = Translate(normalized, options)
+			if change == "none" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("edited %s retained final proof: %v", change, err)
+			}
+			if change == "certificate width" {
+				fresh, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(fresh, options); err != nil {
+					t.Fatalf("recapture from unchanged original source: %v", err)
+				}
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, options.TargetTriple); err != nil {
+					t.Fatalf("fresh actual caller source and LLVM object: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedLoopFinitePathBudgetFailsClosed(t *testing.T) {
+	var body strings.Builder
+	for index := 0; index < 14; index++ {
+		fmt.Fprintf(&body, "CMPL BX,$0\nJE branch%d\nMOVL $7,R11\nbranch%d:\n", index, index)
+	}
+	original := x86CallerCountedLoopScalarAssembly(false)
+	assembly := strings.Replace(original, "MOVL (DI),BX", "MOVL (DI),BX\n"+body.String(), 1)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+	err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "budget exhausted") {
+		t.Fatalf("unproved/exhausted path set acquired a certificate: %v", err)
+	}
+}
+
+func TestX86GoCallerCountedLoopStatusWidthsUseActualLowBits(t *testing.T) {
+	for _, item := range []struct {
+		op    Op
+		value uint64
+	}{
+		{"TESTB", 1 << 8}, {"TESTW", 1 << 16}, {"TESTL", 1 << 32}, {"TESTQ", 0},
+	} {
+		t.Run(string(item.op), func(t *testing.T) {
+			assembly := fmt.Sprintf("TEXT ·status(SB),4,$0-0\nMOVQ $%d,R8\n%s R8,R8\nRET\n", item.value, item.op)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts := x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{}, source: -1}
+			for pc, ins := range file.Funcs[0].Instrs {
+				facts.step(pc, 0, ins, x86SourceStackState{}, nil)
+			}
+			if !facts.flags.known || !facts.flags.equal {
+				t.Fatalf("actual %s truncation to zero did not prove ZF: %+v", item.op, facts.flags)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedLoopAbsentNumericalFactStaysUnknown(t *testing.T) {
+	facts := x86CallerCountedNumbers{
+		regs: map[Reg]x86CallerCountedNumber{}, source: 0,
+	}
+	facts.step(1, 0, Instr{Op: "TESTQ", Args: []Operand{
+		{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: Reg("R8")},
+	}}, x86SourceStackState{}, nil)
+	if facts.flags.known {
+		t.Fatal("an absent numerical fact borrowed the first partition source")
+	}
+}
+
+func TestX86GoCallerCountedLoopAlternateRegistersAndWidths(t *testing.T) {
+	for _, counterWidth := range []string{"L", "Q"} {
+		for _, compareWidth := range []string{"L", "Q"} {
+			t.Run(counterWidth+compareWidth, func(t *testing.T) {
+				assembly := x86CallerCountedLoopScalarAssembly(false)
+				assembly = strings.NewReplacer(
+					"JE done", "JE empty_final", "done:", "empty_final:",
+					"again:", "generic_body:", "JNE again", "JNE generic_body",
+					"MOVL R9,AX", "MOVL R9,R13", "ANDL $3,AX", "ANDL $3,R13",
+					"XORL CX,CX", "XORL R12,R12", "ADDQ $1,CX", "ADD"+counterWidth+" $1,R12",
+					"CMPL CX,AX", "CMP"+compareWidth+" R12,R13",
+				).Replace(assembly)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+				for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+					if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+						t.Fatal(err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerCountedLoopFiveTargetsKeepAMD64Authority(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			if target.arch == "amd64" {
+				assembly := x86CallerCountedLoopScalarAssembly(false)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, target.triple); err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			// These two objects are the existing ordinary 386 scalar contract.
+			// They are not copied AMD64 input or finite-loop authority.
+			pkg, selected, fn, sig := x86CallerFixture(t, x86CallerCountedLoopScalarSource())
+			if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "386"); !errors.Is(err, ErrProbeNeedsContext) || proof != nil {
+				t.Fatal("mode32 borrowed the AMD64 caller input contract")
+			}
+			source, scalarSig, _ := x86SourceStackNumericalFixture("386", "@MOV @WORD(SP),AX\nADDL $7,AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3")
+			requireX86GoAssemblerResult(t, "386", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, x86SourceStackOptions("386", target.triple, scalarSig))
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "mode32-counted-boundary.ll", "mode32-counted-boundary.o", module.String())
+		})
+	}
+}
diff --git a/amd64_go_caller_counted_loop_runtime_test.go b/amd64_go_caller_counted_loop_runtime_test.go
new file mode 100644
index 000000000..5cdee233e
--- /dev/null
+++ b/amd64_go_caller_counted_loop_runtime_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerCountedLoopOriginalInitializedValues(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 caller runtime counterpart")
+	}
+	runX86CallerCountedLoopOriginalValues(t, []string{"MOVQ"})
+}
+
+func runX86CallerCountedLoopOriginalValues(t *testing.T, aliases []string) {
+	t.Helper()
+	var source, assembly, calls strings.Builder
+	source.WriteString("package caller\nimport \"unsafe\"\n")
+	for _, alias := range aliases {
+		for _, raw := range []bool{false, true} {
+			for _, separateExit := range []bool{false, true} {
+				name := fmt.Sprintf("counted%s%t%t", alias, raw, separateExit)
+				declaration := x86CallerCountedLoopScalarSource()
+				declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+				declaration = strings.ReplaceAll(declaration, "kernel", name)
+				declaration = strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1)
+				source.WriteString(declaration)
+				machine := x86CallerCountedLoopScalarAssembly(raw)
+				if separateExit {
+					machine = x86CallerCountedLoopSeparateExitAssembly(raw)
+				}
+				machine = x86SourceAliasCountedAssembly(machine, alias)
+				assembly.WriteString(strings.ReplaceAll(machine, "·kernel", "·"+name))
+				fmt.Fprintf(&calls, `
+ if got:=Call%s(x.data[:length],y.data[:]); got!=want ||
+  snapshot(&x)!=originalX || snapshot(&y)!=originalY {
+  t.Fatalf("%s length=%%d got=%%#x want=%%#x",length,got,want)
+ }
+`, name, name)
+			}
+		}
+	}
+	goTest := `package caller
+import "testing"
+
+type guardedInput struct {
+ before [4]uint32
+ data [16]uint32
+ after [4]uint32
+}
+
+//go:noinline
+func snapshot(input *guardedInput) guardedInput { return *input }
+
+func TestOriginalInitializedCountedValues(t *testing.T) {
+ for repeat:=0; repeat<4; repeat++ {
+  for _, value:=range []uint32{0,1,7,0x80000000,0xffffffff,0x12345678} {
+   for length:=0; length<16; length++ {
+    x := guardedInput{
+     before: [4]uint32{11,17,29,53},
+     data: [16]uint32{value,value^0xaabbccdd,19,23,29,31,37,41,43,47,53,59,61,67,71,73},
+     after: [4]uint32{0xaabbccdd,0x12345678,0x87654321,0xffffffff},
+    }
+    y := guardedInput{
+     before: x.after,
+     data: [16]uint32{31,37,value,43,47,53,59,61,67,71,73,79,83,89,97,101},
+     after: x.before,
+    }
+    originalX,originalY:=snapshot(&x),snapshot(&y)
+    var want uint32
+    for index:=0;index<length&3;index++ { want+=x.data[index]+y.data[index] }
+` + calls.String() + `
+   }
+  }
+ }
+}
+`
+	dir := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": source.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": goTest,
+	} {
+		bytes := []byte(content)
+		if strings.HasSuffix(name, ".go") {
+			var err error
+			bytes, err = format.Source(bytes)
+			if err != nil {
+				t.Fatalf("format generated %s: %v", name, err)
+			}
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), bytes, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("first-party original Go counted integer/canary oracle: %v\n%s", err, output)
+	}
+	t.Logf("original Go scalar oracle: %d initialized calls; bound zero/one/two/three, u32 wrap, both shared/separate exits; noinline full-memory snapshots compare both data buffers and adjacent canaries, not a physical source-stack witness; Darwin/Rosetta is diagnostic, not Intel hardware evidence", 1536*len(aliases))
+	t.Run("serial SCC composition", func(t *testing.T) { runX86CallerCountedSCCOriginalValues(t, aliases...) })
+}
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerCountedLoopValuesAndMemoryCanaries(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 caller runtime counterpart")
+	}
+	runX86CallerCountedLoopLLVMValues(t, []string{"MOVQ"})
+}
+
+func runX86CallerCountedLoopLLVMValues(t *testing.T, aliases []string) {
+	t.Helper()
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, assembly, oracle strings.Builder
+	source.WriteString("package caller\nimport \"unsafe\"\n")
+	oracle.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	var calls strings.Builder
+	for _, alias := range aliases {
+		for _, raw := range []bool{false, true} {
+			for _, separateExit := range []bool{false, true} {
+				name := fmt.Sprintf("counted%s%t%t", alias, raw, separateExit)
+				declaration := x86CallerCountedLoopScalarSource()
+				declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+				declaration = strings.ReplaceAll(declaration, "kernel", name)
+				source.WriteString(strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1))
+				machine := x86CallerCountedLoopScalarAssembly(raw)
+				if separateExit {
+					machine = x86CallerCountedLoopSeparateExitAssembly(raw)
+				}
+				machine = x86SourceAliasCountedAssembly(machine, alias)
+				assembly.WriteString(strings.ReplaceAll(machine, "·kernel", "·"+name))
+				fmt.Fprintf(&oracle, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+				fmt.Fprintf(&calls, `
+    memset(output,0xc9,sizeof(output));memcpy(expected,output,sizeof(output));
+    memcpy(expected+5,&want,sizeof(want));
+    %s(a+1,b+3,output+5,&length);
+    if (memcmp(output,expected,sizeof(output)) || memcmp(a,original_a,sizeof(a)) ||
+        memcmp(b,original_b,sizeof(b)) || length!=original_length) return 1;
+    calls++;
+`, name)
+			}
+		}
+	}
+	oracle.WriteString(`int main(void) {
+ const uint32_t values[]={0,1,7,0x80000000u,0xffffffffu,0x12345678u};
+ unsigned calls=0;
+ for (unsigned repeat=0;repeat<4;repeat++) {
+  for (unsigned value=0;value<sizeof(values)/sizeof(values[0]);value++) {
+   for (uint64_t length=0;length<16;length++) {
+    uint32_t x[16]={values[value],values[value]^0xaabbccddu,19,23,29,31,37,41,43,47,53,59,61,67,71,73};
+    uint32_t y[16]={31,37,values[value],43,47,53,59,61,67,71,73,79,83,89,97,101};
+    uint8_t a[97],b[99],original_a[97],original_b[99],output[29],expected[29];
+    memset(a,0xa3,sizeof(a));memset(b,0xb7,sizeof(b));
+    memcpy(a+1,x,sizeof(x));memcpy(b+3,y,sizeof(y));
+    memcpy(original_a,a,sizeof(a));memcpy(original_b,b,sizeof(b));
+    const uint64_t original_length=length;
+    uint32_t want=0;
+    for (unsigned index=0;index<(length&3);index++) want+=x[index]+y[index];
+`)
+	oracle.WriteString(calls.String())
+	fmt.Fprintf(&oracle, "   }\n  }\n }\n return calls==%d?0:2;\n}\n", 1536*len(aliases))
+	goSource, err := format.Source([]byte(source.String()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := x86CallerRuntimePackage(t, string(goSource), assembly.String())
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if translation != nil && !translation.Module.IsNil() {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compiler := []string{clang}
+	if triple != testTargetTriple(runtime.GOOS, runtime.GOARCH) {
+		compiler = append(compiler, "-target", triple)
+	}
+	for _, level := range []int{0, 2} {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "caller_counted_loop", triple, translation.Module.String(), oracle.String(), runner, level)
+	}
+	t.Logf("%d independent unsigned mathematical results; both input buffers and all output/adjacent guard bytes unchanged, length immutable; Rosetta is diagnostic only", 1536*len(aliases))
+	t.Run("serial SCC composition", func(t *testing.T) { runX86CallerCountedSCCLLVMValues(t, aliases...) })
+}
diff --git a/amd64_go_caller_counted_loop_test.go b/amd64_go_caller_counted_loop_test.go
new file mode 100644
index 000000000..8d2fdb215
--- /dev/null
+++ b/amd64_go_caller_counted_loop_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86CallerCountedLoopScalarAssembly(raw bool) string {
+	control := "TESTB $3,R9\nJE done\nMOVL R9,AX\nANDL $3,AX\nXORL CX,CX"
+	latch := "ADDQ $1,CX\nCMPL CX,AX\nJNE again"
+	if raw {
+		// The guard, bound, counter and latch are unchanged encodings from
+		// the discovered dot_avx256 first loop. The body below is first-party
+		// initialized integer arithmetic, not execution of that external source.
+		control = "LONG $0x03c1f641\nJE done\nWORD $0x8944; BYTE $0xc8\nWORD $0xe083; BYTE $0x03\nWORD $0xc931"
+		latch = "LONG $0x01c18348\nWORD $0xc839\nJNE again"
+	}
+	body := "MOVQ (CX),R9\nXORL R10,R10\n" + control + `
+again:
+MOVL (DI),BX
+MOVL (SI),R11
+ADDL R11,BX
+ADDL BX,R10
+ADDQ $4,DI
+ADDQ $4,SI
+` + latch + `
+done:
+MOVL R10,(DX)`
+	return strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", body, 1)
+}
+
+func x86CallerCountedLoopScalarSource() string {
+	return strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint32")
+}
+
+func x86CallerCountedLoopSeparateExitAssembly(raw bool) string {
+	assembly := strings.Replace(x86CallerCountedLoopScalarAssembly(raw), "JE done", "JE empty", 1)
+	epiloque := strings.SplitN(x86CallerFixtureAssembly, "MOVL AX,(DX)\n", 2)[1]
+	return assembly + "empty:\nMOVL R10,(DX)\n" + epiloque
+}
+
+func TestX86GoCallerCountedLoopActualDecodedCounterAndGuard(t *testing.T) {
+	assembly := x86CallerCountedLoopScalarAssembly(true)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var effects []string
+	for _, ins := range decoded.Instrs {
+		if ins.Op == "TESTB" || ins.Op == "ANDL" || ins.Op == "XORL" ||
+			ins.Op == "CMPL" || ins.Op == "ADDQ" || ins.Op == "JE" || ins.Op == "JNE" {
+			effects = append(effects, fmt.Sprintf("%s %v", ins.Op, ins.Args))
+		}
+	}
+	t.Logf("actual raw-decoder guard/counter/latch effects: %s", strings.Join(effects, "; "))
+	for _, want := range []struct {
+		op   Op
+		args []Operand
+	}{
+		{"TESTB", []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: Reg("R9")}}},
+		{"ANDL", []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: AX}}},
+		{"XORL", []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: CX}}},
+		{"ADDQ", []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: CX}}},
+		{"CMPL", []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}},
+	} {
+		found := false
+		for _, ins := range decoded.Instrs {
+			if ins.Op != want.op || len(ins.Args) != len(want.args) {
+				continue
+			}
+			matched := true
+			for index, arg := range ins.Args {
+				if arg.Kind != want.args[index].Kind || arg.Reg != want.args[index].Reg || arg.Imm != want.args[index].Imm {
+					matched = false
+				}
+			}
+			found = found || matched
+		}
+		if !found {
+			t.Fatalf("source-bound decoder lacks exact effect %s %v", want.op, want.args)
+		}
+	}
+}
+
+func TestX86GoCallerCountedLoopSafeInitializedSourceReachesObjects(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			assembly := x86CallerCountedLoopScalarAssembly(raw)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Errorf("bounded original-source integer loop %s: %v", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedLoopSafeSeparateExitReachesObjects(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			assembly := x86CallerCountedLoopSeparateExitAssembly(raw)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Errorf("bounded original-source backedge %s: %v", triple, err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_counted_scc.go b/amd64_go_caller_counted_scc.go
new file mode 100644
index 000000000..14d7090d0
--- /dev/null
+++ b/amd64_go_caller_counted_scc.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+// The SCC graph is only a structural decomposition. Each cyclic component
+// still needs the existing bounded numerical proof, and replay keeps every
+// feasible path separate. It never joins states or invents a loop invariant.
+func deriveX86CallerCountedPlan(original, fn Func, instructions []int, labels map[string]int) *x86CallerCountedPlan {
+	edges, valid := x86CallerCountedEdges(fn, instructions, labels)
+	if !valid {
+		return nil
+	}
+
+	// Tarjan visits only source-reachable nodes, in original successor order.
+	index, low := make([]int, len(edges)), make([]int, len(edges))
+	onStack, reachable := make([]bool, len(edges)), make([]bool, len(edges))
+	for pc := range index {
+		index[pc] = -1
+	}
+	var stack []int
+	var components [][]int
+	sequence := 0
+	var visit func(int)
+	visit = func(pc int) {
+		index[pc], low[pc], sequence = sequence, sequence, sequence+1
+		reachable[pc], onStack[pc] = true, true
+		stack = append(stack, pc)
+		for _, next := range edges[pc] {
+			if index[next] < 0 {
+				visit(next)
+				if low[next] < low[pc] {
+					low[pc] = low[next]
+				}
+			} else if onStack[next] && index[next] < low[pc] {
+				low[pc] = index[next]
+			}
+		}
+		if low[pc] != index[pc] {
+			return
+		}
+		var component []int
+		for {
+			node := stack[len(stack)-1]
+			stack = stack[:len(stack)-1]
+			onStack[node] = false
+			component = append(component, node)
+			if node == pc {
+				break
+			}
+		}
+		components = append(components, component)
+	}
+	visit(0)
+
+	plan := &x86CallerCountedPlan{edges: edges, headers: map[int]int{}, latches: map[int]int{}}
+	for _, component := range components {
+		cyclic := len(component) > 1
+		for _, next := range edges[component[0]] {
+			cyclic = cyclic || next == component[0]
+		}
+		if !cyclic {
+			continue
+		}
+		body := make(map[int]bool, len(component))
+		for _, pc := range component {
+			body[pc] = true
+		}
+		header, latch := -1, -1
+		entries, exits := 0, 0
+		for pc, nexts := range edges {
+			if !reachable[pc] {
+				continue
+			}
+			for _, next := range nexts {
+				if !body[pc] && body[next] {
+					entries++
+					header = next
+				}
+				if body[pc] && !body[next] {
+					exits++
+					latch = pc
+				}
+			}
+		}
+		if entries != 1 || exits != 1 {
+			return nil
+		}
+		loop := deriveX86CallerCountedLoop(fn, instructions, edges, reachable, body, header, latch)
+		if loop == nil || !x86CallerCountedBodyDAG(*loop, edges) {
+			return nil
+		}
+		plan.headers[header], plan.latches[latch] = len(plan.loops), len(plan.loops)
+		plan.loops = append(plan.loops, *loop)
+	}
+	if len(plan.loops) == 0 {
+		return nil
+	}
+	var err error
+	plan.original, err = x86CallerSourceFingerprint(original)
+	if err != nil {
+		return nil
+	}
+	plan.normalized, err = x86CallerSourceFingerprint(fn)
+	if err != nil {
+		return nil
+	}
+	return plan
+}
+
+// Removing exactly the proved latch backedge must eliminate every body cycle.
+// A nested/alternate cycle cannot borrow another SCC's finite iteration cap.
+func x86CallerCountedBodyDAG(loop x86CallerCountedLoop, edges [][]int) bool {
+	indegree := map[int]int{}
+	for pc := range loop.body {
+		for _, next := range edges[pc] {
+			if loop.body[next] && !(pc == loop.latch && next == loop.header) {
+				indegree[next]++
+			}
+		}
+	}
+	var work []int
+	for pc := range loop.body {
+		if indegree[pc] == 0 {
+			work = append(work, pc)
+		}
+	}
+	removed := 0
+	for len(work) > 0 {
+		pc := work[0]
+		work = work[1:]
+		removed++
+		for _, next := range edges[pc] {
+			if loop.body[next] && !(pc == loop.latch && next == loop.header) {
+				indegree[next]--
+				if indegree[next] == 0 {
+					work = append(work, next)
+				}
+			}
+		}
+	}
+	return removed == len(loop.body)
+}
diff --git a/amd64_go_caller_counted_scc_boundary_test.go b/amd64_go_caller_counted_scc_boundary_test.go
new file mode 100644
index 000000000..b6de21566
--- /dev/null
+++ b/amd64_go_caller_counted_scc_boundary_test.go
@@ -0,0 +1,257 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerCountedSCCRejectThreeAPIs(t *testing.T, assembly string) {
+	t.Helper()
+	pkg, file := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+	before := fmt.Sprintf("%#v %#v", file, sigs)
+	t.Run("Translate", func(t *testing.T) {
+		if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved SCC source acquired text permission: %v", err)
+		}
+	})
+	t.Run("Module", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved SCC source acquired module permission: %v", err)
+		}
+	})
+	t.Run("GoModule", func(t *testing.T) {
+		if err := x86CallerCoreTranslate(t, pkg, assembly, options.TargetTriple); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved SCC source acquired Go module permission: %v", err)
+		}
+	})
+	if before != fmt.Sprintf("%#v %#v", file, sigs) {
+		t.Fatal("failed SCC replay mutated caller/source inputs")
+	}
+}
+
+func x86CallerCountedSCCRejectedChanges() map[string][2]string {
+	return map[string][2]string{
+		"second missing guard":       {"JE done\n", ""},
+		"second reversed guard":      {"JE done", "JNE done"},
+		"second unknown bound":       {"MOVL R9,R13", "MOVL BX,R13"},
+		"second unrelated bound":     {"MOVL R9,R13", "MOVL $2,R13"},
+		"second fresh length source": {"MOVL R9,R13", "MOVQ length+24(FP),R8\nMOVQ (R8),R9\nMOVL R9,R13"},
+		"second wider partition":     {"ANDL $3,R13", "ANDL $7,R13"},
+		"second partial bound":       {"MOVL R9,R13", "MOVW R9,R13"},
+		"second missing counter":     {"XORL R12,R12", ""},
+		"second nonzero counter":     {"XORL R12,R12", "MOVL $1,R12"},
+		"second partial counter":     {"XORL R12,R12", "XORW R12,R12"},
+		"second stride zero":         {"ADDQ $1,R12", "ADDQ $0,R12"},
+		"second stride two":          {"ADDQ $1,R12", "ADDQ $2,R12"},
+		"second decrement":           {"ADDQ $1,R12", "SUBQ $1,R12"},
+		"second double update":       {"ADDQ $1,R12", "ADDQ $1,R12\nADDQ $1,R12"},
+		"second update bypass":       {"ADDQ $1,R12", "TESTL BX,BX\nJE second_compare\nADDQ $1,R12\nsecond_compare:"},
+		"second stale flags":         {"JNE second_body", "ADDL $1,R10\nJNE second_body"},
+		"second side entry":          {"JE done", "JE second_body"},
+		"second early exit":          {"second_body:", "second_body:\nTESTL BX,BX\nJE done"},
+		"second nested cycle":        {"second_body:", "second_body:\ninner:\nTESTL BX,BX\nJNE inner"},
+		"dead unknown effect":        {"second_body:", "JMP second_body\nRDTSC\nsecond_body:"},
+		"first unknown GP":           {"ADDL R11,BX", "ADDL R8,BX"},
+		"diamond missing GP":         {"MOVL $5,R11", "MOVL R8,R11"},
+		"diamond missing vector":     {"MOVL $5,R11", "VEXTRACTF128 $1,Y0,X1\nMOVL $5,R11"},
+		"diamond missing mask":       {"MOVL $5,R11", "VMOVUPS (DI),Z0\nVPADDD.Z Z0,Z0,K1,Z1\nMOVL $5,R11"},
+		"diamond readonly write":     {"MOVL $5,R11", "MOVL $5,(DI)\nMOVL $5,R11"},
+		"diamond unknown origin":     {"MOVL $5,R11", "MOVQ R8,DI\nMOVL $5,R11"},
+		"diamond lost result":        {"MOVL $5,R11", "MOVQ DI,DX\nMOVL $5,R11"},
+		"diamond displaced result":   {"MOVL $5,R11", "ADDQ $1,DX\nMOVL $5,R11"},
+		"diamond SP escape":          {"MOVL $5,R11", "MOVQ DI,SP\nMOVL $5,R11"},
+		"diamond BP escape":          {"MOVL $5,R11", "MOVQ DI,BP\nMOVL $5,R11"},
+		"diamond g clobber":          {"MOVL $5,R11", "MOVQ $0,R14\nMOVL $5,R11"},
+	}
+}
+
+func TestX86GoCallerCountedSCCRetainsEveryPathAndOrigin(t *testing.T) {
+	original := x86CallerCountedSCCAssembly(false, true)
+	for name, change := range x86CallerCountedSCCRejectedChanges() {
+		t.Run(name, func(t *testing.T) {
+			if strings.Count(original, change[0]) == 0 {
+				t.Fatal("negative does not name original source")
+			}
+			assembly := strings.Replace(original, change[0], change[1], 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			x86CallerCountedSCCRejectThreeAPIs(t, assembly)
+		})
+	}
+}
+
+func TestX86GoCallerCountedSCCCannotCloseUnknownCallers(t *testing.T) {
+	for name, change := range map[string][2]string{
+		"indirect exit": {"done:", "done:\nJMP R8"},
+		"unknown call":  {"first_done:", "first_done:\nCALL ·unregistered(SB)"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerCountedSCCAssembly(false, false), change[0], change[1], 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, file := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			if _, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed caller graph supplied a producer: %v", err)
+			}
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed caller graph translated: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerCountedSCCDoesNotMergeDifferentReadonlyPaths(t *testing.T) {
+	// These paths are individually legal. Replay must keep their different
+	// authenticated input origins rather than deriving a synthetic common one.
+	assembly := strings.Replace(x86CallerCountedSCCAssembly(false, true), "MOVL $5,R11", "MOVQ SI,DI\nMOVL $5,R11", 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	x86CallerCountedSCCObjects(t, x86CallerCountedLoopScalarSource(), assembly, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86GoCallerCountedSCCPreservesResidueAndSourceSeals(t *testing.T) {
+	assembly := x86CallerCountedSCCAssembly(true, false)
+	pkg, file := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+	normalized, err := normalizeX86RawFile(file, "amd64", options)
+	if err != nil || normalized.Funcs[0].x86SourceStack == nil {
+		t.Fatalf("complete SCC replay proof missing: %v", err)
+	}
+	proof := normalized.Funcs[0].x86SourceStack
+	if proof.countedIterations != [4]int{0, 2, 4, 6} {
+		t.Fatalf("multiple SCCs changed residue denominator: %v", proof.countedIterations)
+	}
+	if fingerprint, err := x86CallerSourceFingerprint(normalized.Funcs[0]); err != nil || fingerprint != proof.normalized {
+		t.Fatal("normalized identity not sealed")
+	}
+	for _, name := range []string{"original source", "normalized source", "missing caller", "access width"} {
+		t.Run(name, func(t *testing.T) {
+			_, original := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+			copy, err := normalizeX86RawFile(original, "amd64", options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch name {
+			case "original source":
+				original.Funcs[0].Instrs[1].Args[0].FPOffset++
+				decoded, err := decodeX86RawDirectives(original.Funcs[0], "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				failed := normalizeX86RawReturnSourceStack(decoded, options, true, original.Funcs[0])
+				if failed.x86SourceStack != nil {
+					t.Fatal("modified original acquired stale SCC permission")
+				}
+				return
+			case "missing caller":
+				privateOptions := options
+				privateOptions.Sigs = map[string]FuncSig{}
+				for symbol, sig := range sigs {
+					sig.x86CallerRegions = nil
+					privateOptions.Sigs[symbol] = sig
+				}
+				if _, err := Translate(copy, privateOptions); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("lost caller identity acquired SCC permission: %v", err)
+				}
+				return
+			}
+			for index := range copy.Funcs[0].Instrs {
+				ins := &copy.Funcs[0].Instrs[index]
+				if ins.Op != "MOVL" || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.x86CallerMemory == nil {
+					continue
+				}
+				if !x86CallerMemoryCertified(*ins, 0) {
+					t.Fatal("complete read certificate missing")
+				}
+				if name == "access width" {
+					access := ins.x86CallerMemory[0]
+					access.width++
+					ins.x86CallerMemory[0] = access
+					if x86CallerMemoryCertified(*ins, 0) || x86RawReturnMemoryBound(copy.Funcs[0], copy, options, true) {
+						t.Fatal("tampered read width borrowed SCC permission")
+					}
+					return
+				}
+				ins.Args[0].Mem.Base = DX
+				if _, err := Translate(copy, options); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("modified normalized source retained SCC permission: %v", err)
+				}
+				return
+			}
+			t.Fatal("no source access selected for negative")
+		})
+	}
+}
+
+func TestX86GoCallerCountedSCCMasksAndWidths(t *testing.T) {
+	for _, mask := range []int{1, 2, 3} {
+		for _, width := range []string{"L", "Q"} {
+			t.Run(fmt.Sprintf("mask%d/%s", mask, width), func(t *testing.T) {
+				assembly := strings.ReplaceAll(x86CallerCountedSCCAssembly(false, false), "$3,", fmt.Sprintf("$%d,", mask))
+				assembly = strings.NewReplacer("ADDQ $1,CX", "ADD"+width+" $1,CX",
+					"ADDQ $1,R12", "ADD"+width+" $1,R12", "CMPL CX,AX", "CMP"+width+" CX,AX",
+					"CMPL R12,R13", "CMP"+width+" R12,R13").Replace(assembly)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				x86CallerCountedSCCObjects(t, x86CallerCountedLoopScalarSource(), assembly, "x86_64-unknown-linux-gnu")
+			})
+		}
+	}
+}
+
+func TestX86GoCallerCountedSCCIndependentMasksAndBodyDiamonds(t *testing.T) {
+	for _, masks := range [][2]int{{1, 2}, {2, 3}, {3, 1}} {
+		t.Run(fmt.Sprintf("%d/%d", masks[0], masks[1]), func(t *testing.T) {
+			assembly := x86CallerCountedSCCAssembly(false, false)
+			assembly = strings.NewReplacer("TESTB $3,R9\nJE first_done", fmt.Sprintf("TESTB $%d,R9\nJE first_done", masks[0]),
+				"ANDL $3,AX", fmt.Sprintf("ANDL $%d,AX", masks[0]),
+				"TESTB $3,R9\nJE done", fmt.Sprintf("TESTB $%d,R9\nJE done", masks[1]),
+				"ANDL $3,R13", fmt.Sprintf("ANDL $%d,R13", masks[1])).Replace(assembly)
+			// Both arms of this internal diamond are known numerical writes.
+			// The +1 update still dominates every path to the exact latch.
+			assembly = strings.Replace(assembly, "ADDQ $1,R12", `TESTL BX,BX
+JE zero_value
+MOVL $3,R11
+JMP body_join
+zero_value:
+MOVL $5,R11
+body_join:
+ADDL R11,R10
+ADDQ $1,R12`, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			x86CallerCountedSCCObjects(t, x86CallerCountedLoopScalarSource(), assembly, "x86_64-unknown-linux-gnu")
+		})
+	}
+}
+
+func TestX86GoCallerCountedSCCKeepsWholeReplayBudget(t *testing.T) {
+	var diamond strings.Builder
+	for index := 0; index < 14; index++ {
+		fmt.Fprintf(&diamond, "TESTL BX,BX\nJE budget%d\nMOVL $7,R11\nbudget%d:\n", index, index)
+	}
+	assembly := strings.Replace(x86CallerCountedSCCAssembly(false, false), "ADDQ $1,R12", diamond.String()+"ADDQ $1,R12", 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "finite path budget exhausted") {
+		t.Fatalf("SCC composition expanded or bypassed the finite replay budget: %v", err)
+	}
+}
diff --git a/amd64_go_caller_counted_scc_runtime_test.go b/amd64_go_caller_counted_scc_runtime_test.go
new file mode 100644
index 000000000..72660020e
--- /dev/null
+++ b/amd64_go_caller_counted_scc_runtime_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Both existing required counted-loop runtime roots consume these fixtures.
+// Their host/runner policy is unchanged; Rosetta remains diagnostic rather
+// than evidence of native Linux execution or physical source-stack identity.
+func x86CallerCountedSCCRuntimeFixtures(aliases ...string) (string, string, []string) {
+	if len(aliases) == 0 {
+		aliases = []string{"MOVQ"}
+	}
+	var source, assembly strings.Builder
+	source.WriteString("package caller\nimport \"unsafe\"\n")
+	var names []string
+	for _, alias := range aliases {
+		for _, raw := range []bool{false, true} {
+			for _, diamond := range []bool{false, true} {
+				name := fmt.Sprintf("scc%s%t%t", alias, raw, diamond)
+				declaration := x86CallerCountedLoopScalarSource()
+				declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+				declaration = strings.ReplaceAll(declaration, "kernel", name)
+				source.WriteString(strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1))
+				machine := x86SourceAliasCountedAssembly(x86CallerCountedSCCAssembly(raw, diamond), alias)
+				assembly.WriteString(strings.ReplaceAll(machine, "·kernel", "·"+name))
+				names = append(names, name)
+			}
+		}
+	}
+	return source.String(), assembly.String(), names
+}
+
+func runX86CallerCountedSCCOriginalValues(t *testing.T, aliases ...string) {
+	source, assembly, names := x86CallerCountedSCCRuntimeFixtures(aliases...)
+	var calls strings.Builder
+	for index, name := range names {
+		fmt.Fprintf(&calls, `
+   {
+    want := sum
+    if %t {
+     if x.data[bound] == 0 { want += 5 } else { want += 3 }
+    }
+    if got := Call%s(x.data[:length],y.data[:]); got != want ||
+     snapshot(&x) != originalX || snapshot(&y) != originalY {
+     t.Fatalf("%s length=%%d got=%%#x want=%%#x",length,got,want)
+    }
+    calls++
+   }
+`, index%2 == 1, name, name)
+	}
+	testSource := `package caller
+import "testing"
+type guardedInput struct { before [4]uint32; data [16]uint32; after [4]uint32 }
+//go:noinline
+func snapshot(input *guardedInput) guardedInput { return *input }
+func TestOriginalSCCValues(t *testing.T) {
+ calls := 0
+ for repeat := 0; repeat < 4; repeat++ {
+  for _, value := range []uint32{0,1,7,0x80000000,0xffffffff,0x12345678} {
+   for length := 0; length < 16; length++ {
+    x := guardedInput{
+     before: [4]uint32{11,17,29,53},
+     data: [16]uint32{value,0,value^0xaabbccdd,0,29,31,37,41,43,47,53,59,61,67,71,73},
+     after: [4]uint32{0xaabbccdd,0x12345678,0x87654321,0xffffffff},
+    }
+    y := guardedInput{before:x.after,
+     data:[16]uint32{31,37,value,43,47,53,59,61,67,71,73,79,83,89,97,101},after:x.before}
+    originalX,originalY := snapshot(&x),snapshot(&y)
+    bound := length & 3
+    var sum uint32
+    for index := 0; index < 2*bound; index++ { sum += x.data[index]+y.data[index] }
+` + calls.String() + `
+   }
+  }
+ }
+` + fmt.Sprintf(" if calls != %d { t.Fatalf(\"calls=%%d\", calls) }\n", 384*len(names)) + `
+}
+`
+	dir := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": source,
+		"value_amd64.s": assembly, "value_test.go": testSource,
+	} {
+		bytes := []byte(content)
+		if strings.HasSuffix(name, ".go") {
+			var err error
+			bytes, err = format.Source(bytes)
+			if err != nil {
+				t.Fatalf("format generated %s: %v", name, err)
+			}
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), bytes, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("first-party original Go serial SCC integer/canary oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d original Go calls: two serial bounded loops, raw/named controls, both diamond arms, u32 wrap and complete guarded input snapshots", 384*len(names))
+}
+
+func runX86CallerCountedSCCLLVMValues(t *testing.T, aliases ...string) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	source, assembly, names := x86CallerCountedSCCRuntimeFixtures(aliases...)
+	var oracle, calls strings.Builder
+	oracle.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for index, name := range names {
+		fmt.Fprintf(&oracle, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+		fmt.Fprintf(&calls, `
+    {
+     uint32_t want = sum;
+     if (%d) want += x[bound] == 0 ? 5 : 3;
+     memset(output,0xc9,sizeof(output)); memcpy(expected,output,sizeof(output));
+     memcpy(expected+5,&want,sizeof(want));
+     %s(a+1,b+3,output+5,&length);
+     if (memcmp(output,expected,sizeof(output)) || memcmp(a,original_a,sizeof(a)) ||
+         memcmp(b,original_b,sizeof(b)) || length != original_length) return 1;
+     calls++;
+    }
+`, index%2, name)
+	}
+	oracle.WriteString(`int main(void) {
+ const uint32_t values[]={0,1,7,0x80000000u,0xffffffffu,0x12345678u};
+ unsigned calls=0;
+ for (unsigned repeat=0;repeat<4;repeat++) {
+  for (unsigned value=0;value<sizeof(values)/sizeof(values[0]);value++) {
+   for (uint64_t length=0;length<16;length++) {
+    uint32_t x[16]={values[value],0,values[value]^0xaabbccddu,0,29,31,37,41,43,47,53,59,61,67,71,73};
+    uint32_t y[16]={31,37,values[value],43,47,53,59,61,67,71,73,79,83,89,97,101};
+    uint8_t a[97],b[99],original_a[97],original_b[99],output[29],expected[29];
+    memset(a,0xa3,sizeof(a)); memset(b,0xb7,sizeof(b));
+    memcpy(a+1,x,sizeof(x)); memcpy(b+3,y,sizeof(y));
+    memcpy(original_a,a,sizeof(a)); memcpy(original_b,b,sizeof(b));
+    const uint64_t original_length=length;
+    const unsigned bound=length&3;
+    uint32_t sum=0;
+    for (unsigned index=0;index<2*bound;index++) sum+=x[index]+y[index];
+`)
+	oracle.WriteString(calls.String())
+	fmt.Fprintf(&oracle, "   }\n  }\n }\n return calls==%d?0:2;\n}\n", 384*len(names))
+	goSource, err := format.Source([]byte(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := x86CallerRuntimePackage(t, string(goSource), assembly)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if translation != nil && !translation.Module.IsNil() {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	var runner []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compiler := []string{clang}
+	if triple != testTargetTriple(runtime.GOOS, runtime.GOARCH) {
+		compiler = append(compiler, "-target", triple)
+	}
+	for _, level := range []int{0, 2} {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "caller_counted_scc", triple, translation.Module.String(), oracle.String(), runner, level)
+	}
+	t.Logf("%d independent integer results plus full input/output canaries and immutable length; required Linux counterpart remains independently executable, Rosetta diagnostic is not native evidence", 384*len(names))
+}
diff --git a/amd64_go_caller_counted_scc_test.go b/amd64_go_caller_counted_scc_test.go
new file mode 100644
index 000000000..700087489
--- /dev/null
+++ b/amd64_go_caller_counted_scc_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The two loops use the same authenticated local length, without supplying an
+// allocation extent. Every body read and result byte still needs caller proof.
+func x86CallerCountedSCCAssembly(raw, diamond bool) string {
+	first := "TESTB $3,R9\nJE first_done\nMOVL R9,AX\nANDL $3,AX\nXORL CX,CX"
+	latch := "ADDQ $1,CX\nCMPL CX,AX\nJNE first_body"
+	if raw {
+		first = "LONG $0x03c1f641\nJE first_done\nWORD $0x8944; BYTE $0xc8\nWORD $0xe083; BYTE $0x03\nWORD $0xc931"
+		latch = "LONG $0x01c18348\nWORD $0xc839\nJNE first_body"
+	}
+	body := "MOVQ (CX),R9\nXORL R10,R10\n" + first + `
+first_body:
+MOVL (DI),BX
+MOVL (SI),R11
+ADDL R11,BX
+ADDL BX,R10
+ADDQ $4,DI
+ADDQ $4,SI
+` + latch + "\nfirst_done:\n"
+	if diamond {
+		// The input value is numerically defined but not a partition constant.
+		// Both feasible predecessors must initialize the value consumed below.
+		body += `MOVL (DI),BX
+CMPL BX,$0
+JE other
+MOVL $3,R11
+JMP joined
+other:
+MOVL $5,R11
+joined:
+ADDL R11,R10
+`
+	}
+	body += `TESTB $3,R9
+JE done
+MOVL R9,R13
+ANDL $3,R13
+XORL R12,R12
+second_body:
+MOVL (DI),BX
+MOVL (SI),R11
+ADDL R11,BX
+ADDL BX,R10
+ADDQ $4,DI
+ADDQ $4,SI
+ADDQ $1,R12
+CMPL R12,R13
+JNE second_body
+done:
+MOVL R10,(DX)`
+	return strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", body, 1)
+}
+
+func x86CallerCountedSCCObjects(t *testing.T, source, assembly, triple string) {
+	t.Helper()
+	pkg, file := x86CallerCoreFixture(t, source, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	before := fmt.Sprintf("%#v %#v", file, sigs)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileLLVMToObject(t, llc, triple, "scc-text.ll", "scc-text.o", ir)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileLLVMToObject(t, llc, triple, "scc-module.ll", "scc-module.o", module.String())
+	if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+		t.Fatal(err)
+	}
+	if before != fmt.Sprintf("%#v %#v", file, sigs) {
+		t.Fatal("independent replay mutated original source or caller signatures")
+	}
+}
+
+func TestX86GoCallerCountedSCCSerialLoopsAndDiamondThreeAPIs(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		for _, diamond := range []bool{false, true} {
+			assembly := x86CallerCountedSCCAssembly(raw, diamond)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				t.Run(fmt.Sprintf("raw=%t/diamond=%t/%s", raw, diamond, triple), func(t *testing.T) {
+					x86CallerCountedSCCObjects(t, x86CallerCountedLoopScalarSource(), assembly, triple)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_dword_product.go b/amd64_go_caller_dword_product.go
new file mode 100644
index 000000000..6b64e9f86
--- /dev/null
+++ b/amd64_go_caller_dword_product.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+func x86CallerDwordProductStep(ins *Instr, form x86DwordProductForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := state.vectors[x86CallerVectorRoot(form.source.Reg)] & width
+	if form.memory >= 0 {
+		// Even dwords are the numerical inputs, but the possible native read
+		// remains m128/m256/m512 or m64bcst, independent of the mask value.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	var known uint64
+	for start := 0; start < form.byteWidth; start += 8 {
+		input := uint64(15) << uint(start)
+		output := uint64(255) << uint(start)
+		if first&input == input && second&input == input {
+			known |= output
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_dword_product_test.go b/amd64_go_caller_dword_product_test.go
new file mode 100644
index 000000000..fb34ac7a3
--- /dev/null
+++ b/amd64_go_caller_dword_product_test.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerDwordProductIndependentSourceEffect(t *testing.T) {
+	for _, row := range []string{"PMULDQ X0,X1", "PMULULQ X0,X1", "VPMULDQ Y0,Y1,Y2", "VPMULUDQ Y0,Y1,Y2"} {
+		t.Run(row, func(t *testing.T) {
+			result := "X2"
+			if !strings.HasPrefix(row, "V") {
+				result = "X1"
+			}
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\n" + row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerDwordProductCompleteMaskBroadcastAndMemoryForms(t *testing.T) {
+	rows := []string{"PMULDQ X0,X1", "PMULDQ X1,X1", "PMULDQ (DI),X1", "PMULULQ X0,X1", "PMULULQ X1,X1", "PMULULQ (DI),X1"}
+	for _, name := range x86DwordProductOracleNames[2:] {
+		for _, row := range x86OfficialPackedBinaryWitnesses(t)[name] {
+			rows = append(rows, strings.Replace(row, "(AX)", "(DI)", 1))
+		}
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			result := "X2"
+			if !strings.HasPrefix(row, "V") {
+				result = "X1"
+			}
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal("complete signed/unsigned family caller failed", row, triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerDwordProductEveryPotentialByteAndUpperAliases(t *testing.T) {
+	for _, row := range []string{"PMULDQ X0,X1", "PMULULQ X0,X1", "VPMULDQ X0,X1,X2", "VPMULUDQ Y0,Y1,Y2", "VPMULDQ Z0,Z1,K1,Z2", "VPMULUDQ.Z Z0,Z1,K1,Z2"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86DwordProductProperties(ins.Op, ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, missing := range []Reg{"Z0", "Z1", "Z2"} {
+			for index := 0; index < 64; index++ {
+				t.Run(fmt.Sprintf("%s/missing%s/byte%d", row, missing, index), func(t *testing.T) {
+					state := &x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+					state.vectors[missing] &^= uint64(1) << uint(index)
+					old := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]
+					if !x86CallerDwordProductStep(&ins, form, state, nil) {
+						t.Fatal("register-only numerical effect failed")
+					}
+					var want uint64
+					for output := 0; output < 64; output++ {
+						known := true
+						if output >= form.byteWidth {
+							known = !form.legacy || old&(uint64(1)<<uint(output)) != 0
+						} else {
+							start := output / 8 * 8
+							// Independent reference: output qword j depends only
+							// on bytes 8j..8j+3 of each input, never 8j+4..8j+7.
+							if missing == "Z0" || missing == "Z1" {
+								known = index < start || index >= start+4
+							}
+							if form.mask >= 0 && !form.zeroing && missing == x86CallerVectorRoot(ins.Args[form.destination].Reg) && index == output {
+								known = false
+							}
+						}
+						if known {
+							want |= uint64(1) << uint(output)
+						}
+					}
+					if got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]; got != want {
+						t.Fatalf("potential input/merge/upper byte lost: got=%016x want=%016x", got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerDwordProductExactMemoryCertificates(t *testing.T) {
+	for _, row := range []string{"PMULDQ (DI),X0", "PMULULQ (DI),X0", "VPMULDQ (DI),Y0,Y2", "VPMULUDQ.Z (DI),Z0,K1,Z2", "VPMULDQ.BCST.Z (DI),Z0,K1,Z2", "VPMULUDQ.BCST (DI),X0,X2"} {
+		result := "X2"
+		if !strings.HasPrefix(row, "V") {
+			result = "X0"
+		}
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86DwordProductProperties(ins.Op, ins, "amd64")
+			if !known || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			index := form.memory
+			access, exists := ins.x86CallerMemory[index]
+			wantWidth := form.byteWidth
+			if strings.Contains(row, ".BCST") {
+				wantWidth = 8
+			}
+			if !exists || access.width != int64(wantWidth) || access.write || !x86CallerMemoryCertified(ins, index) {
+				t.Fatal("zero mask/selected dwords shrank native envelope", row, access)
+			}
+			for _, mutation := range []string{"opcode", "width", "direction", "address", "destination", "mask", "address size"} {
+				changed := ins
+				changedAccess := access
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+				switch mutation {
+				case "opcode":
+					changed.Op = "VPMULDQ"
+					if strings.Contains(row, "PMULDQ") {
+						changed.Op = "VPMULUDQ"
+					}
+				case "width":
+					changedAccess.width--
+					changed.x86CallerMemory[index] = changedAccess
+				case "direction":
+					changedAccess.write = true
+					changed.x86CallerMemory[index] = changedAccess
+				case "address":
+					changed.Args[index].Mem.Off++
+				case "destination":
+					changed.Args[form.destination].Reg = "X7"
+				case "mask":
+					if form.mask >= 0 {
+						changed.Args[form.mask].Reg = "K7"
+					} else {
+						changed.Args = append(changed.Args, Operand{Kind: OpReg, Reg: "K7"})
+					}
+				case "address size":
+					changed.x86AddressBits = 32
+				}
+				if x86CallerMemoryCertified(changed, index) {
+					t.Fatal("stale native read certificate survived", row, mutation)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("normalized source omitted dword product", row)
+		}
+	}
+}
+
+func TestX86GoCallerDwordProductUnprovedInputsAndGuardsRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":        "VMOVUPS (DI),Y1\nVPMULDQ Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":       "VMOVUPS (DI),Y0\nVPMULUDQ Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"partial even dword":   "MOVSS (DI),X3\nMOVSS X3,X0\nVMOVUPS (SI),Z1\nVPMULDQ Z0,Z1,Z2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":         "VMOVUPS (DI),Z0\nVPMULDQ.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":        "VMOVUPS (DI),Z0\nKMOVQ AX,K1\nVPMULUDQ Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":         "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPMULDQ.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask full tuple": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPMULDQ.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"broadcast full qword": "VMOVUPS (DI),Z0\nVPMULUDQ.BCST (DX),Z0,Z2\nVMOVSS X2,(DX)",
+		"unknown address":      "VMOVUPS (DI),Z0\nVPMULDQ (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"private SP":           "VMOVUPS (DI),Z0\nVPMULDQ (SP),Z0,Z2\nVMOVSS X2,(DX)",
+		"SP alias":             "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPMULDQ (BX),X0\nVMOVSS X0,(DX)",
+		"BP alias":             "VMOVUPS (DI),Z0\nMOVQ BP,BX\nPMULULQ (BX),X0\nVMOVSS X0,(DX)",
+		"g use":                "VMOVUPS (DI),Z0\nVPMULDQ (R14),Z0,Z2\nVMOVSS X2,(DX)",
+		"input write":          "VMOVUPS (DI),Z0\nVPMULDQ Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"MMX caller":           "PMULULQ M0,M1\nVMOVSS X1,(DX)",
+		"unknown CFG join":     "VMOVUPS (DI),Y0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Y1\njoined:\nVPMULDQ Y0,Y1,Y2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved input/native/caller guard acquired permission", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerDwordProductRawTuplesBindNativeReadWidths(t *testing.T) {
+	for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				op, tuple := name, width
+				if broadcast {
+					op, tuple = name+".BCST", 8
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				for _, offset := range []int{-tuple, 64 - tuple, 64} {
+					row := fmt.Sprintf("%s %d(DI),%s1,K1,%s2", op, offset, bank, bank)
+					t.Run(row, func(t *testing.T) {
+						original := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+row+"\nRET\n")
+						body := "VMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nMOVQ $1,AX\nKMOVQ AX,K1\n" + x86DwordProductDirectives(original[:len(original)-1]) + "VMOVSS X2,(DX)"
+						assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+						goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+						pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+						if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+							t.Fatal("original raw tuple lost existing readonly slice role", row, err)
+						}
+						// The input is a dynamic slice role, not an observed fixed
+						// 64-byte allocation. Certify only the exact possible native
+						// instruction read, preserving native faulting addresses.
+						resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+						sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+						if err != nil {
+							t.Fatal(err)
+						}
+						normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+						if err != nil {
+							t.Fatal(err)
+						}
+						found := false
+						for _, ins := range normalized.Funcs[0].Instrs {
+							form, known, err := x86DwordProductProperties(ins.Op, ins, "amd64")
+							if !known || err != nil {
+								continue
+							}
+							found = true
+							access, ok := ins.x86CallerMemory[0]
+							if !ins.x86Encoded || form.memory != 0 || ins.Args[0].Mem.Base != DI || ins.Args[0].Mem.Off != int64(offset) || !ok || access.width != int64(tuple) || access.write || !x86CallerMemoryCertified(ins, 0) {
+								t.Fatal("raw source tuple/address/native-width certificate drift", row, ins, access)
+							}
+						}
+						if !found {
+							t.Fatal("original raw source omitted from normalized proof", row)
+						}
+						// Conversely the fresh result is a real bounded four-byte
+						// region: no full-vector or m64bcst read fits this role.
+						boundedRow := strings.Replace(row, "(DI)", "(DX)", 1)
+						bounded := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+boundedRow+"\nRET\n")
+						boundedBody := strings.Replace(body, x86DwordProductDirectives(original[:len(original)-1]), x86DwordProductDirectives(bounded[:len(bounded)-1]), 1)
+						boundedAssembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", boundedBody, 1)
+						boundedPkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, boundedAssembly)
+						if err := x86CallerCoreTranslate(t, boundedPkg, boundedAssembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual raw tuple gained bounded result-object permission", boundedRow, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_explicit_imul.go b/amd64_go_caller_explicit_imul.go
new file mode 100644
index 000000000..75e05bfda
--- /dev/null
+++ b/amd64_go_caller_explicit_imul.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+// Only the existing validated explicit IMUL descriptor is consumed here. This
+// supplies byte-definedness, not a new pointer, frame or memory capability.
+func x86CallerExplicitIMULStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) (recognized, valid bool) {
+	if _, known, err := x86ExplicitIMULProperties(ins.Op, *ins, "amd64"); !known || err != nil {
+		return known, false
+	}
+	effect, known, err := x86TypedGPByteEffect(ins.Op, *ins, "amd64")
+	if !known || err != nil || effect.dynamicMemory {
+		return true, false
+	}
+	// All ordered source bytes (including the two-operand old destination)
+	// must be defined before any destination can overwrite their evidence.
+	for _, operand := range effect.operands {
+		if !operand.read {
+			continue
+		}
+		if operand.operand.Kind == OpMem {
+			if proof == nil || !x86CallerOrdinaryMemoryStep(ins, operand.index, state, proof, operand.width, false) {
+				return true, false
+			}
+		} else if !x86CallerNumericRead(operand.operand, operand.width, state) {
+			return true, false
+		}
+	}
+	for _, operand := range effect.operands {
+		if operand.write && (operand.operand.Kind != OpReg || !x86CallerNumericWrite(operand.operand.Reg, operand.width, state)) {
+			return true, false
+		}
+	}
+	return true, true
+}
+
+func x86SourceStackNumericFlagMask(state *x86SourceStackState) uint8 {
+	if state.numericFlags {
+		return x86ByteFlagsAll // Preserve the pre-existing complete-flags witness.
+	}
+	return state.partialNumericFlags
+}
+
+func x86SourceStackNumericFlagsRead(state *x86SourceStackState, required uint8) bool {
+	return required != 0 && x86SourceStackNumericFlagMask(state)&required == required
+}
+
+func x86SourceStackSetNumericFlags(state *x86SourceStackState, mask uint8) {
+	state.numericFlags = mask == x86ByteFlagsAll
+	state.partialNumericFlags = 0
+	if !state.numericFlags {
+		state.partialNumericFlags = mask
+	}
+}
diff --git a/amd64_go_caller_explicit_imul_test.go b/amd64_go_caller_explicit_imul_test.go
new file mode 100644
index 000000000..34d8f5884
--- /dev/null
+++ b/amd64_go_caller_explicit_imul_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This directory is independent of the typed effect descriptor. It exercises
+// all explicit yimul/yimul3 source classes; one-operand IMUL is not in it.
+var x86CallerExplicitIMULRows = []struct {
+	name, instruction string
+	three             bool
+}{
+	{"register", "IMUL@ AX,BX", false},
+	{"memory", "IMUL@ (DI),BX", false},
+	{"immediate8", "IMUL@ $-7,BX", false},
+	{"immediate32", "IMUL@ $65537,BX", false},
+	{"three-register8", "IMUL3@ $-7,AX,BX", true},
+	{"three-register32", "IMUL3@ $65537,AX,BX", true},
+	{"three-memory8", "IMUL3@ $-7,(DI),BX", true},
+	{"three-memory32", "IMUL3@ $65537,(DI),BX", true},
+}
+
+func x86CallerExplicitIMULFixture(t *testing.T, body string) (GoPackage, *File, string, Options) {
+	t.Helper()
+	declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint64")
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", body+"\nMOVQ BX,(DX)", 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, declaration, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// goSigsForAsmFile already binds the complete actual SourceSelection.
+	if sigs["caller.kernel"].x86CallerRegions == nil {
+		t.Fatalf("actual complete typed caller precondition failed: %v", err)
+	}
+	if !x86CallerRegionSourceMatches(sigs["caller.kernel"], file.Funcs[0], "amd64") {
+		t.Fatal("actual complete typed caller does not match its original source/signature")
+	}
+	return pkg, file, assembly, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+}
+
+func TestX86GoCallerExplicitIMULRawReturnRegisteredForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, suffix := range []string{"W", "L", "Q"} {
+		for _, row := range x86CallerExplicitIMULRows {
+			t.Run(suffix+"/"+row.name, func(t *testing.T) {
+				body := "MOVQ $7,AX\n"
+				// W preserves the old upper bytes. Two-operand IMUL also reads
+				// the old low result; IMUL3L/Q must not require that old result.
+				if suffix == "W" || !row.three {
+					body += "MOVQ $3,BX\n"
+				}
+				body += strings.ReplaceAll(row.instruction, "@", suffix)
+				pkg, file, assembly, options := x86CallerExplicitIMULFixture(t, body)
+				for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+					// Separate format and API/target axes: two representative
+					// rows cover all APIs/targets; every row covers text/Linux.
+					allAPIs := suffix == "Q" && row.name == "register" || suffix == "L" && row.name == "three-memory32"
+					if !allAPIs && triple != "x86_64-unknown-linux-gnu" {
+						continue
+					}
+					options.TargetTriple = triple
+					t.Run(triple+"/text", func(t *testing.T) {
+						ir, err := Translate(file, options)
+						if err != nil {
+							t.Fatalf("Go-accepted explicit multiply lacks source/caller effect: %v", err)
+						}
+						compileLLVMToObject(t, llc, triple, "imul-caller.ll", "imul-caller.o", ir)
+					})
+					if !allAPIs {
+						continue
+					}
+					t.Run(triple+"/module", func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						module, err := TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, triple, "imul-caller-module.ll", "imul-caller-module.o", module.String())
+					})
+					t.Run(triple+"/go", func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+							FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: triple, ResolveSym: options.ResolveSym,
+						})
+						if translated != nil && !translated.Module.IsNil() {
+							defer translated.Module.Dispose()
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, triple, "imul-caller-go.ll", "imul-caller-go.o", translated.Module.String())
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86SourceStackExplicitIMULKillsOldComparisonFlags(t *testing.T) {
+	for _, op := range []string{"IMULW", "IMULL", "IMULQ", "IMUL3W", "IMUL3L", "IMUL3Q"} {
+		t.Run(op, func(t *testing.T) {
+			row := op + " AX,BX"
+			if strings.HasPrefix(op, "IMUL3") {
+				row = op + " $7,AX,BX"
+			}
+			ins := x86YMMReadSource(t, row)
+			state := x86SourceStackState{numericFlags: true, callers: map[Reg]x86CallerPointerValue{}}
+			if !x86SourceStackFlagsStep(ins, &state) || state.numericFlags {
+				t.Fatal("IMUL retained complete old CMP flags instead of only CF/OF")
+			}
+			for _, branch := range []string{"JE", "JNE", "JLT", "JGE", "JLE", "JGT", "JMI", "JPL", "JHI", "JLS", "JPS", "JPC", "JCS", "JCC", "JOS", "JOC"} {
+				accepted := x86SourceStackFlagsStep(Instr{Op: Op(branch)}, &state)
+				want := branch == "JCS" || branch == "JCC" || branch == "JOS" || branch == "JOC"
+				if accepted != want {
+					t.Fatalf("%s after %s: accepted=%t want=%t", branch, op, accepted, want)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerExplicitIMULRetainsContext(t *testing.T) {
+	for _, test := range []struct{ name, body string }{
+		{"undefined-input", "MOVQ $7,BX\nIMULQ AX,BX"},
+		{"undefined-old-destination", "MOVQ $7,AX\nIMULQ AX,BX"},
+		{"partial-input", "MOVB $7,AX\nIMULQ AX,BX"},
+		{"partial-word-result", "MOVQ $7,AX\nIMUL3W $7,AX,BX"},
+		{"pointer-input", "MOVQ $7,BX\nIMULQ DI,BX"},
+		{"pointer-old-destination", "MOVQ DI,BX\nIMULQ $7,BX"},
+		{"pointer-survives-word-result", "MOVQ DI,BX\nMOVQ $7,AX\nIMUL3W $7,AX,BX"},
+		{"unknown-memory", "MOVQ $7,BX\nIMULQ (R11),BX"},
+		{"wide-length-read", "MOVQ $7,BX\nIMULQ 1(CX),BX"},
+		{"native-return-pc", "MOVQ $7,BX\nIMULQ 8(BP),BX"},
+		{"FP-pointer-input", "MOVQ $7,BX\nIMULQ a+0(FP),BX"},
+		{"g-input", "MOVQ $7,BX\nIMULQ R14,BX"},
+		{"g-unrestored", "MOVQ $7,AX\nIMUL3Q $7,AX,R14\nMOVQ R14,BX"},
+		{"SP-destination", "MOVQ $7,BX\nIMULQ BX,SP"},
+		{"BP-input", "MOVQ $7,BX\nIMULQ BP,BX"},
+		{"implicit-IMUL", "MOVQ $7,AX\nMOVQ $7,BX\nIMULQ BX"},
+		{"implicit-MUL", "MOVQ $7,AX\nMOVQ $7,BX\nMULQ BX"},
+		{"implicit-DIV", "MOVQ $7,AX\nMOVQ $7,BX\nMOVQ $0,DX\nDIVQ BX"},
+		{"implicit-IDIV", "MOVQ $7,AX\nMOVQ $7,BX\nMOVQ $0,DX\nIDIVQ BX"},
+		{"unknown-CFG-input", "MOVQ $7,BX\nCMPQ BX,$0\nJE joined\nMOVQ $7,AX\njoined:\nIMULQ AX,BX"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			pkg, file, assembly, options := x86CallerExplicitIMULFixture(t, test.body)
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved IMUL effect acquired authority: %v", err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("module accepted unproved IMUL: %v", err)
+			}
+			ctx = llvm.NewContext()
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+				FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym,
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				translated.Module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Go API accepted unproved IMUL: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerExplicitIMULActualInitializedLocalRead(t *testing.T) {
+	// The retained actual caller declares `var res uint64`: Go initializes
+	// those complete numerical bytes before the call. This is not an unknown
+	// native entry region, nor permission to read an arbitrary result pointer.
+	_, file, _, options := x86CallerExplicitIMULFixture(t, "MOVQ $7,BX\nIMULQ (DX),BX")
+	if _, err := Translate(file, options); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86GoCallerExplicitIMULFlagsAndSavedFlags(t *testing.T) {
+	for _, condition := range []string{"CC", "CS", "EQ", "NE", "GE", "LT", "GT", "LE", "HI", "LS", "MI", "PL", "OC", "OS", "PC", "PS"} {
+		for _, consumer := range []string{"SET", "CMOVQ", "J"} {
+			t.Run(consumer+condition, func(t *testing.T) {
+				body := "MOVQ $7,AX\nMOVQ $3,BX\nCMPQ AX,$0\nIMULQ AX,BX\n"
+				switch consumer {
+				case "SET":
+					body += "SET" + condition + " BL"
+				case "CMOVQ":
+					body += "CMOVQ" + condition + " AX,BX"
+				case "J":
+					body += "J" + condition + " joined\njoined:"
+				}
+				_, file, _, options := x86CallerExplicitIMULFixture(t, body)
+				_, err := Translate(file, options)
+				defined := condition == "CC" || condition == "CS" || condition == "OC" || condition == "OS"
+				if defined && err != nil || !defined && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("IMUL flag consumer defined=%t: %v", defined, err)
+				}
+			})
+		}
+	}
+	for _, test := range []struct {
+		name, body string
+		accepted   bool
+	}{
+		{"restore-complete", "CMPQ AX,$0\nPUSHFQ\nIMULQ AX,BX\nPOPFQ\nSETEQ BL", true},
+		{"restore-partial", "IMULQ AX,BX\nPUSHFQ\nCMPQ AX,$0\nPOPFQ\nSETEQ BL", false},
+		{"restore-CF", "IMULQ AX,BX\nPUSHFQ\nCMPQ AX,$0\nPOPFQ\nSETCS BL", true},
+		{"carry-after-multiply", "IMULQ AX,BX\nADCQ $1,BX", true},
+		{"CMP-redefines-flags", "IMULQ AX,BX\nCMPQ AX,$0\nSETEQ BL", true},
+		{"shift-does-not-resurrect-OF", "IMULQ AX,BX\nSHLQ $2,BX\nSETOS BL", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, file, _, options := x86CallerExplicitIMULFixture(t, "MOVQ $7,AX\nMOVQ $3,BX\n"+test.body)
+			_, err := Translate(file, options)
+			if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("FLAGS dependency accepted=%t: %v", test.accepted, err)
+			}
+		})
+	}
+}
+
+func TestX86SourceStackExplicitIMULWithoutCallerRemainsContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			if arch == "386" && suffix == "Q" {
+				continue // Independently Go-rejected Q rows are in the encoder oracle.
+			}
+			for _, three := range []bool{false, true} {
+				body := "@MOV $7,AX\n@MOV $3,BX\nIMUL" + suffix + " AX,BX\n@MOV BX,@RESULT(SP)\nBYTE $0xc3"
+				if three {
+					body = strings.Replace(body, "IMUL"+suffix+" AX,BX", "IMUL3"+suffix+" $7,AX,BX", 1)
+				}
+				t.Run(fmt.Sprintf("%s/%s/three=%t", arch, suffix, three), func(t *testing.T) {
+					source, sig, _ := x86SourceStackNumericalFixture(arch, body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := Translate(file, x86SourceStackOptions(arch, "", sig)); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("declaration-only source acquired complete numerical input proof: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_float_compare.go b/amd64_go_caller_float_compare.go
new file mode 100644
index 000000000..b96dbcda5
--- /dev/null
+++ b/amd64_go_caller_float_compare.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+// Comparison writes either complete predicate lanes or a fully defined K
+// result. A K destination is never an old merge input; its optional source
+// mask must still be initialized, even when source and destination alias.
+func x86CallerFloatCompareStep(ins *Instr, form x86FloatCompareForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	required := x86CallerVectorByteMask(int64(form.inputByteWidth()))
+	if form.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+		return false
+	}
+	for _, index := range []int{form.first, form.second} {
+		if index != form.memory && state.vectors[x86CallerVectorRoot(ins.Args[index].Reg)]&required != required {
+			return false
+		}
+	}
+	if form.maskResult {
+		state.masks[ins.Args[form.destination].Reg] = true
+		return true
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	second := x86CallerVectorRoot(ins.Args[form.second].Reg)
+	state.vectors[destination] = form.resultDefinedBytes(state.vectors[second], state.vectors[destination])
+	return true
+}
diff --git a/amd64_go_caller_float_compare_test.go b/amd64_go_caller_float_compare_test.go
new file mode 100644
index 000000000..d73712371
--- /dev/null
+++ b/amd64_go_caller_float_compare_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFloatingCompareCompleteInitializedForms(t *testing.T) {
+	for _, original := range x86FloatCompareGoForms("amd64") {
+		t.Run(original, func(t *testing.T) {
+			row := strings.NewReplacer("8(AX)", "8(DI)", "(AX)(CX*4)", "(DI)").Replace(original)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, recognized, err := x86FloatCompareProperties(ins, "amd64")
+			if !recognized || err != nil {
+				t.Fatalf("independent source form not recognized: %v", err)
+			}
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z20\nVMOVUPS (SI),Z21\nKMOVQ AX,K1\n" + row
+			destination := ins.Args[form.destination].Reg
+			if form.maskResult {
+				body += "\nKMOVD " + string(destination) + ",(DX)"
+			} else {
+				index, _ := amd64VectorRegisterIndex(destination, form.byteWidth)
+				body += fmt.Sprintf("\nVMOVSS X%d,(DX)", index)
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerFloatingCompareRegisterKnowledgeAndMasks(t *testing.T) {
+	rows := x86FloatCompareGoForms("amd64")
+	rows = append(rows, "VCMPPS $0,Z0,Z1,K1,K1", "VCMPSS $255,X0,X1,K1,K1")
+	for _, row := range rows {
+		if strings.Contains(row, "(AX)") {
+			continue
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86FloatCompareProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		width := form.byteWidth
+		if form.scalar {
+			width = form.bits / 8
+		}
+		required := x86CallerVectorByteMask(int64(width))
+		first, second := x86CallerVectorRoot(ins.Args[form.first].Reg), x86CallerVectorRoot(ins.Args[form.second].Reg)
+		for seed := 0; seed < 64; seed++ {
+			upper := uint64(seed) * 0x391072d5e64b8a0f
+			state := x86SourceStackState{
+				vectors: map[Reg]uint64{first: required, second: required | upper},
+				masks:   map[Reg]bool{"K1": true},
+			}
+			if !x86CallerVectorMoveKnown(ins) || !x86CallerVectorMoveStep(&ins, &state, nil) {
+				t.Fatalf("complete registered compare effect rejected %s", row)
+			}
+			if form.maskResult {
+				if !state.masks[ins.Args[form.destination].Reg] || state.vectors[first] != required || state.vectors[second] != required|upper {
+					t.Fatalf("K-result changed input vectors or required old mask contents: %s", row)
+				}
+				continue
+			}
+			want := ^uint64(0)
+			if form.legacy {
+				want = required | upper
+			} else if form.scalar {
+				want = ^x86CallerVectorByteMask(16) | required | upper&(x86CallerVectorByteMask(16)&^required)
+			}
+			if got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]; got != want {
+				t.Fatalf("%s seed%d defined bytes=%#x want=%#x", row, seed, got, want)
+			}
+		}
+		for _, missing := range []int{form.first, form.second, form.mask} {
+			if missing < 0 {
+				continue
+			}
+			state := x86SourceStackState{
+				vectors: map[Reg]uint64{first: required, second: required},
+				masks:   map[Reg]bool{"K1": true},
+			}
+			if missing == form.mask {
+				state.masks[ins.Args[missing].Reg] = false
+			} else {
+				state.vectors[x86CallerVectorRoot(ins.Args[missing].Reg)] &^= 1
+			}
+			vectors, masks := x86CloneCallerVectorState(state.vectors, state.masks)
+			if x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state.vectors, vectors) || !reflect.DeepEqual(state.masks, masks) {
+				t.Fatalf("%s missing role%d invented evidence or updated partial state", row, missing)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerFloatingCompareRejectsUnprovedInputAndEnvelope(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown source":        "CMPPS X0,X1,$0\nVMOVSS X1,(DX)",
+		"unknown mask":          "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVCMPPS $0,Z0,Z1,K1,K2\nKMOVD K2,(DX)",
+		"unknown old K is read": "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVCMPPS $0,Z0,Z1,K1,K1\nKMOVD K1,(DX)",
+		"pointer mask":          "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ DI,K1\nVCMPPS $0,Z0,Z1,K1,K2\nKMOVD K2,(DX)",
+		"unknown base":          "VMOVUPS (SI),X1\nCMPPS (BX),X1,$0\nVMOVSS X1,(DX)",
+		"native stack":          "VMOVUPS (SI),X1\nCMPPS (SP),X1,$0\nVMOVSS X1,(DX)",
+		"pointer FP":            "VMOVUPS (SI),X1\nCMPPS a+0(FP),X1,$0\nVMOVSS X1,(DX)",
+		"read scalar length":    "VMOVUPS (SI),X1\nCMPPS (CX),X1,$0\nVMOVSS X1,(DX)",
+		"read output":           "VMOVUPS (SI),X1\nCMPPS (DX),X1,$0\nVMOVSS X1,(DX)",
+		"write source":          "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nCMPPS X0,X1,$0\nVMOVSS X1,(DI)",
+		"wide output":           "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nCMPPS X0,X1,$0\nVMOVUPS X1,(DX)",
+		// A VEX memory load defines zero upper bytes. Legacy register MOVSS
+		// preserves X1's unknown upper bytes, which scalar VCMP copies and
+		// the following packed VCMP genuinely reads.
+		"unknown upper reused": "VMOVSS (DI),X0\nMOVSS X0,X1\nVCMPSS $0,X0,X1,X2\nVCMPPS $0,X2,X2,X3\nVMOVSS X3,(DX)",
+		"mixed CFG":            "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),X0\njoined:\nVMOVUPS (SI),X1\nCMPPS X0,X1,$0\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved compare acquired caller continuation: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_fma3.go b/amd64_go_caller_fma3.go
new file mode 100644
index 000000000..33564eaeb
--- /dev/null
+++ b/amd64_go_caller_fma3.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+func x86CallerFMA3Step(ins *Instr, form amd64FMA3Form, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.spec.rawOnly || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := int64(form.byteWidth)
+	if form.spec.scalar {
+		width = int64(form.spec.laneBits / 8)
+	}
+	required := x86CallerVectorByteMask(width)
+	if form.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+		return false
+	}
+	// All three operands participate in every order, including the old
+	// destination in zeroing forms. An initialized unknown-valued mask is
+	// not a proof of inactive lanes; arithmetic cannot invent missing bytes.
+	for _, index := range []int{0, 1, form.destination} {
+		if index == form.memory {
+			continue
+		}
+		root := x86CallerVectorRoot(ins.Args[index].Reg)
+		if state.vectors[root]&required != required {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	known := ^uint64(0)
+	if form.spec.scalar {
+		// Scalar FMA preserves the old destination's remaining XMM bytes,
+		// independently of its low-lane mask, and zeroes higher Y/Z aliases.
+		upperX := x86CallerVectorByteMask(16) &^ required
+		known = ^x86CallerVectorByteMask(16) | required | state.vectors[destination]&upperX
+	}
+	state.vectors[destination] = known
+	return true
+}
diff --git a/amd64_go_caller_fma3_runtime_test.go b/amd64_go_caller_fma3_runtime_test.go
new file mode 100644
index 000000000..2e6a9b097
--- /dev/null
+++ b/amd64_go_caller_fma3_runtime_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func qualifyCrossLinuxRuntimeMatrixX86FMA3GoCallerNumericalFamily(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 FMA3 caller runtime oracle")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	formats := x86FMA3NamedFormats("amd64")
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	x86OriginalFloatingRuntimeRequireCPU(t, "fma-caller", clang, testTargetTriple(runtime.GOOS, "amd64"), runner)
+	// Caller proofs fingerprint the complete source selection. Keep that
+	// selection bounded instead of repeatedly hashing a giant fixture for
+	// every function. Each format still has its own actual typed Go caller,
+	// translation and numerical oracle; every batch releases its LLVM objects.
+	const batchSize = 64
+	attempted, passed := 0, 0
+	for start := 0; start < len(formats); start += batchSize {
+		end := start + batchSize
+		if end > len(formats) {
+			end = len(formats)
+		}
+		t.Run(fmt.Sprintf("formats_%04d_%04d", start, end), func(t *testing.T) {
+			attempted += end - start
+			runX86FMA3GoCallerNumericalBatch(t, llc, clang, formats[start:end], start, runner)
+			passed += end - start
+		})
+	}
+	t.Logf("%d/%d attempted FMA3 formats passed (%d available): numerical low result, directed rounding, unknown-valued initialized mask, read-only inputs and full output canaries", passed, attempted, len(formats))
+}
+
+func runX86FMA3GoCallerNumericalBatch(t *testing.T, llc, clang string, formats []string, first int, runner []string) {
+	t.Helper()
+	var goSource, assembly, declarations, checks strings.Builder
+	goSource.WriteString("package caller\nimport \"unsafe\"\n")
+	for index, instruction := range formats {
+		name := fmt.Sprintf("fmacase%d", first+index)
+		opcode := strings.Fields(instruction)[0]
+		base := strings.Split(opcode, ".")[0]
+		bits := 32
+		if strings.HasSuffix(base, "PD") || strings.HasSuffix(base, "SD") {
+			bits = 64
+		}
+		declaration := x86CallerFixtureSource[strings.Index(x86CallerFixtureSource, "//go:noescape"):]
+		declaration = strings.ReplaceAll(declaration, "kernel", name)
+		declaration = strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1)
+		if bits == 64 {
+			declaration = strings.ReplaceAll(declaration, "float32", "float64")
+		}
+		goSource.WriteString(declaration)
+
+		bank := "X"
+		if strings.Contains(instruction, "Y1") {
+			bank = "Y"
+		} else if strings.Contains(instruction, "Z1") {
+			bank = "Z"
+		}
+		body := fmt.Sprintf("VMOVUPS (DI),%s0\nVMOVUPS (SI),%s1\nVMOVUPS 64(SI),%s2\nKMOVQ AX,K1\n", bank, bank, bank)
+		body += strings.ReplaceAll(instruction, "(AX)", "(DI)") + "\n"
+		store := "VMOVSS X2,(DX)"
+		if bits == 64 {
+			store = "VMOVSD X2,(DX)"
+		}
+		body += store
+		machine := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+name)
+		machine = strings.Replace(machine, "MOVL $7,AX", "MOVQ (CX),AX", 1)
+		assembly.WriteString(strings.Replace(machine, "MOVL AX,(DX)", body, 1))
+		fmt.Fprintf(&declarations, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+
+		order, err := strconv.Atoi(base[len(base)-5 : len(base)-2])
+		if err != nil {
+			t.Fatal(err)
+		}
+		mode := 0
+		switch {
+		case strings.HasPrefix(base, "VFMADDSUB"):
+			mode = 4
+		case strings.HasPrefix(base, "VFMSUBADD"):
+			mode = 5
+		case strings.HasPrefix(base, "VFNMADD"):
+			mode = 2
+		case strings.HasPrefix(base, "VFNMSUB"):
+			mode = 3
+		case strings.HasPrefix(base, "VFMSUB"):
+			mode = 1
+		}
+		rounding := 0
+		for suffix, value := range map[string]int{".RD_SAE": 1, ".RU_SAE": 2, ".RZ_SAE": 3} {
+			if strings.Contains(opcode, suffix) {
+				rounding = value
+			}
+		}
+		fmt.Fprintf(&checks, "    if (check(%s,%q,%d,%d,%d,%t,%t,%d)) return 1;\n",
+			name, instruction, bits, order, mode, strings.Contains(instruction, "K1"), strings.HasSuffix(opcode, ".Z"), rounding)
+	}
+	// Actual Go accepts every original instruction and supplies the exact
+	// typed caller. Portable LLVM/C execution is not native AVX512 execution
+	// and is not a whole third-party library/ledger pass.
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	pkg := x86CallerRuntimePackage(t, goSource.String(), assembly.String())
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	oracle := x86FMA3CallerCOracle + declarations.String() + "\nint main(void) {\n" + checks.String() + "    return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "fma3-caller-numerical", triple, translation.Module.String(), oracle, runner)
+}
+
+const x86FMA3CallerCOracle = `#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <fenv.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+
+#pragma STDC FENV_ACCESS ON
+static int check(void (*fn)(void*,void*,void*,void*), const char *instruction, unsigned bits,
+                 unsigned order, unsigned mode, bool masked, bool zero,
+                 unsigned rounding) {
+    const int modes[] = {FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};
+    for (uint64_t length=64; length<68; length++) {
+        uint8_t first[512], second[512], before_first[512], before_second[512];
+        uint8_t output[48], expected[48];
+        for (unsigned i=0; i<512/(bits/8); i++) {
+            if (bits == 32) {
+                float a=1.00000011920928955078125f;
+                float b=-1.0000002384185791015625f;
+                if (i != 0) { a=(float)((int)(i%7)-3)/4; b=(float)((int)(i%5)-2)/8; }
+                memcpy(first+i*4,&a,4); memcpy(second+i*4,&b,4);
+            } else {
+                double a=1.0000000000000002220446049250313;
+                double b=-1.0000000000000004440892098500626;
+                if (i != 0) { a=(double)((int)(i%7)-3)/4; b=(double)((int)(i%5)-2)/8; }
+                memcpy(first+i*8,&a,8); memcpy(second+i*8,&b,8);
+            }
+        }
+        memcpy(before_first,first,512); memcpy(before_second,second,512);
+        memset(output,0xa5,48); memcpy(expected,output,48);
+        const uint64_t original_length=length;
+        fn(first,second,output+16,&length);
+        if (length != original_length) return 1;
+        if (fesetround(modes[rounding])) return 2;
+        if (bits == 32) {
+            float first_value, second_value, old, a, b, c, result;
+            memcpy(&first_value,first,4); memcpy(&second_value,second,4); memcpy(&old,second+64,4);
+            a=old; b=first_value; c=second_value;
+            if (order == 213) { a=second_value; b=old; c=first_value; }
+            if (order == 231) { a=second_value; b=first_value; c=old; }
+            if (mode == 2 || mode == 3) a=-a;
+            if (mode == 1 || mode == 3 || mode == 4) c=-c;
+            result=fmaf(a,b,c);
+            if (masked && !(length&1)) result=zero ? 0 : old;
+            memcpy(expected+16,&result,4);
+        } else {
+            double first_value, second_value, old, a, b, c, result;
+            memcpy(&first_value,first,8); memcpy(&second_value,second,8); memcpy(&old,second+64,8);
+            a=old; b=first_value; c=second_value;
+            if (order == 213) { a=second_value; b=old; c=first_value; }
+            if (order == 231) { a=second_value; b=first_value; c=old; }
+            if (mode == 2 || mode == 3) a=-a;
+            if (mode == 1 || mode == 3 || mode == 4) c=-c;
+            result=fma(a,b,c);
+            if (masked && !(length&1)) result=zero ? 0 : old;
+            memcpy(expected+16,&result,8);
+        }
+        if (fesetround(FE_TONEAREST)) return 3;
+        if (memcmp(output,expected,48) || memcmp(first,before_first,512) ||
+            memcmp(second,before_second,512)) {
+            fprintf(stderr,"FMA3 %s bits/order/mode/mask/zero/rounding/length %u/%u/%u/%u/%u/%u/%llu\n",
+                    instruction,bits,order,mode,masked,zero,rounding,(unsigned long long)length);
+            for (unsigned i=16; i<16+bits/8; i++) {
+                fprintf(stderr,"%02x/%02x ",output[i],expected[i]);
+            }
+            fprintf(stderr,"\n");
+            return 4;
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_go_caller_fma3_test.go b/amd64_go_caller_fma3_test.go
new file mode 100644
index 000000000..707d6bb78
--- /dev/null
+++ b/amd64_go_caller_fma3_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFMA3InitializedNumericalInputs(t *testing.T) {
+	for _, body := range []string{
+		"VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVFMADD231SS (DI),X0,X1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Y0\nVMOVUPS (SI),Y1\nVFMADD132PS (DI),Y0,Y1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVFNMADD213PD.BCST (DI),Z0,Z1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\nVFMADDSUB231PS.Z Z0,Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVFMSUBADD132PD.RD_SAE Z0,Z0,Z1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", ";"), func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerFMA3CompleteFamilyRegisterEffects(t *testing.T) {
+	for _, instruction := range x86FMA3NamedFormats("amd64") {
+		if strings.Contains(instruction, "(AX)") {
+			continue // Actual typed caller-memory/objects are checked separately.
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		if !x86CallerVectorMoveKnown(ins) {
+			t.Fatalf("complete named FMA3 format has no shared effect: %s", instruction)
+		}
+		form, _, err := amd64FMA3Properties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, missing := range []int{-1, 0, 1, 2} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{
+				"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0),
+			}, masks: map[Reg]bool{"K1": true}}
+			if missing >= 0 {
+				state.vectors[Reg(fmt.Sprintf("Z%d", missing))] &^= 1
+			}
+			before, masks := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerFMA3Step(&ins, form, &state, nil)
+			if accepted != (missing == -1) || !reflect.DeepEqual(state.masks, masks) ||
+				!accepted && !reflect.DeepEqual(state.vectors, before) {
+				t.Fatalf("%s missing input %d: invented numerical data or changed masks: %t/%v", instruction, missing, accepted, state.vectors)
+			}
+		}
+	}
+	for opcode, spec := range amd64FMA3Specs {
+		if !spec.rawOnly {
+			continue
+		}
+		ins := Instr{Op: opcode, x86Encoded: true, Args: []Operand{
+			{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"},
+		}}
+		if x86CallerVectorMoveKnown(ins) {
+			t.Fatalf("raw-only FP16 acquired a Go-named caller contract: %s", opcode)
+		}
+	}
+}
+
+func TestX86GoCallerFMA3ScalarPreservesUnknownUpperXBytes(t *testing.T) {
+	for _, instruction := range []string{
+		"VFMADD132SS X0,X1,X2", "VFMSUB213SD.RD_SAE X0,X1,X2",
+		"VFNMADD231SS.Z X0,X1,K1,X2", "VFNMSUB132SD.RU_SAE.Z X0,X1,K1,X2",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := amd64FMA3Properties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		low := x86CallerVectorByteMask(int64(form.spec.laneBits / 8))
+		for _, oldUpper := range []uint64{0, 0xff00, 0xff000, ^uint64(0)} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{
+				"Z0": low, "Z1": low, "Z2": low | oldUpper,
+			}, masks: map[Reg]bool{"K1": true}}
+			if !x86CallerFMA3Step(&ins, form, &state, nil) {
+				t.Fatalf("initialized low inputs incorrectly require unknown upper X data: %s", instruction)
+			}
+			var expected uint64
+			for index := 0; index < 64; index++ {
+				bit := uint64(1) << uint(index)
+				if index >= 16 || index < form.spec.laneBits/8 || oldUpper&bit != 0 {
+					expected |= bit
+				}
+			}
+			if state.vectors["Z2"] != expected {
+				t.Fatalf("%s changed byte %x initialization: got %x want %x", instruction, oldUpper, state.vectors["Z2"], expected)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerFMA3CannotInventNumericalInputs(t *testing.T) {
+	for _, body := range []string{
+		"VFMADD231SS (DI),X0,X1\nVMOVSS X1,(DX)",
+		"VMOVSS (DI),X0\nVFMADD231SS X0,X0,X1\nVMOVSS X1,(DX)",
+		"VMOVSS (DI),X0\nVFMADD231SS.Z X0,X0,K1,X0\nVMOVSS X0,(DX)",
+		"VMOVSS (DI),X0\nKMOVQ DI,K1\nVFMADD231SS.Z X0,X0,K1,X0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS (BX),Y0,Y0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS a+0(FP),Y0,Y0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS (CX),Y0,Y0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS (R14),Y0,Y0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS 0(SP),Y0,Y0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVFMADD231PS (DI),Y0,Y0\nVMOVUPS Y0,(DX)",
+		"CMPQ AX,$0\nJE joined\nVMOVUPS (DI),Y0\njoined:\nVFMADD231PS (DI),Y0,Y0\nVMOVSS X0,(DX)",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", ";"), func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved FMA input acquired caller continuation: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_gp_simd_transfer.go b/amd64_go_caller_gp_simd_transfer.go
new file mode 100644
index 000000000..2f087815b
--- /dev/null
+++ b/amd64_go_caller_gp_simd_transfer.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+func x86CallerGPSIMDTransferStep(ins *Instr, f x86GPSIMDTransferForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if f.mmx || f.spec.rawOnly {
+		return false
+	}
+	width := int64(f.bits / 8)
+	lowMask := x86CallerVectorByteMask(width)
+	var known uint64
+	if f.sourceX {
+		known = state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)] & lowMask
+	} else if f.memory < 0 {
+		root, valid := x86CallerGP(ins.Args[0].Reg)
+		_, pointer := state.callers[root]
+		if ins.Args[0].Kind != OpReg || !valid || root == SP || root == BP || pointer {
+			return false
+		}
+		known = uint64(state.known[root]) & lowMask
+	} else {
+		known = lowMask
+	}
+	if !f.destinationX && known != lowMask {
+		return false
+	}
+	if f.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, width, f.memoryWrite) {
+		return false
+	}
+	if f.destinationX {
+		root := x86CallerVectorRoot(ins.Args[1].Reg)
+		state.vectors[root] = f.definedVectorBytes(known, state.vectors[root])
+		return true
+	}
+	if f.memoryWrite {
+		return true
+	}
+	return x86CallerNumericWrite(ins.Args[1].Reg, width, state)
+}
diff --git a/amd64_go_caller_horizontal_float.go b/amd64_go_caller_horizontal_float.go
new file mode 100644
index 000000000..36c23d6b4
--- /dev/null
+++ b/amd64_go_caller_horizontal_float.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+func x86CallerHorizontalFloatStep(ins *Instr, form x86HorizontalFloatForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.memory >= 0 {
+		// SSE3's legacy m128 requires alignment. A slice/nonalias witness
+		// does not establish that; VEX forms allow unaligned memory.
+		if !form.spec.vector || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.byteWidth), false) {
+			return false
+		}
+	}
+	required := x86CallerVectorByteMask(int64(form.byteWidth))
+	for _, index := range []int{form.first, form.second} {
+		if index != form.memory && state.vectors[x86CallerVectorRoot(ins.Args[index].Reg)]&required != required {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	known := ^uint64(0)
+	if !form.spec.vector {
+		known = state.vectors[destination] | required
+	}
+	state.vectors[destination] = known
+	return true
+}
diff --git a/amd64_go_caller_horizontal_float_test.go b/amd64_go_caller_horizontal_float_test.go
new file mode 100644
index 000000000..bd7b4ca70
--- /dev/null
+++ b/amd64_go_caller_horizontal_float_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerHorizontalFloatOriginalSourceReachesObjects(t *testing.T) {
+	for _, body := range []string{
+		"VMOVUPS (DI),Y0\nLONG $0xc07cffc5\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Y0\nVMOVUPS (SI),Y1\nVHADDPS Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nHSUBPD X0,X1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(strings.Split(body, "\n")[1], func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerHorizontalFloatWholeFamilyByteEffects(t *testing.T) {
+	for _, row := range x86HorizontalFloatFormats() {
+		if strings.Contains(row, "(BX)") {
+			continue
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86HorizontalFloatProperties(ins, "amd64")
+		if !recognized || err != nil || !x86CallerVectorMoveKnown(ins) {
+			t.Fatalf("missing shared effect %s: %v", row, err)
+		}
+		required := x86CallerVectorByteMask(int64(form.byteWidth))
+		for _, missing := range []int{-1, form.first, form.second, form.destination} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": required, "Z1": required, "Z2": 0}}
+			if missing >= 0 {
+				state.vectors[x86CallerVectorRoot(ins.Args[missing].Reg)] &^= uint64(1) << uint(form.byteWidth-1)
+			}
+			before, _ := x86CloneCallerVectorState(state.vectors, nil)
+			accepted := x86CallerHorizontalFloatStep(&ins, form, &state, nil)
+			want := missing == -1 || missing == form.destination && form.spec.vector
+			if accepted != want || !accepted && !reflect.DeepEqual(state.vectors, before) {
+				t.Fatalf("%s missing %d: %t want %t, invented high source bytes", row, missing, accepted, want)
+			}
+		}
+		for _, upper := range []uint64{0, 0xff00000000, ^required} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": required, "Z1": required | upper, "Z2": upper}}
+			if !x86CallerHorizontalFloatStep(&ins, form, &state, nil) {
+				t.Fatal("fully initialized sources rejected")
+			}
+			want := ^uint64(0)
+			if !form.spec.vector {
+				want = required | upper
+			}
+			if got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]; got != want {
+				t.Fatalf("%s definitions %x want %x", row, got, want)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerHorizontalFloatAllOpcodesAndMemoryBounds(t *testing.T) {
+	for _, row := range x86HorizontalFloatFormats() {
+		memory := strings.Contains(row, "(BX)")
+		legacy := !strings.HasPrefix(row, "V")
+		row = strings.Replace(row, "(BX)", "(DI)", 1)
+		destination := "X1"
+		if !legacy {
+			destination = "X2"
+		}
+		body := fmt.Sprintf("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\n%s\nVMOVSS %s,(DX)", row, destination)
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		requireX86GoAssemblerResult(t, "amd64", assembly, true)
+		pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			err := x86CallerCoreTranslate(t, pkg, assembly, triple)
+			if legacy && memory {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved legacy alignment: %s: %v", row, err)
+				}
+			} else if err != nil {
+				t.Fatalf("%s/%s: %v", row, triple, err)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerHorizontalFloatDoesNotInventPermissions(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown source":                  "VHADDPS X0,X1,X2\nVMOVSS X2,(DX)",
+		"not a zero idiom":                "VHSUBPS X0,X0,X2\nVMOVSS X2,(DX)",
+		"unknown destructive destination": "VMOVUPS (DI),X0\nHSUBPD X0,X1\nVMOVSS X1,(DX)",
+		"partially defined source":        "VMOVSS X0,X1,X2\nVMOVUPS (DI),X0\nVHADDPS X0,X2,X1\nVMOVSS X1,(DX)",
+		"unknown input":                   "VMOVUPS (DI),X0\nVHADDPD (BX),X0,X1\nVMOVSS X1,(DX)",
+		"physical SP":                     "VMOVUPS (DI),X0\nVHADDPS 0(SP),X0,X1\nVMOVSS X1,(DX)",
+		"FP pointer bits":                 "VMOVUPS (DI),X0\nVHSUBPS a+0(FP),X0,X1\nVMOVSS X1,(DX)",
+		"length as vector":                "VMOVUPS (DI),X0\nVHADDPD (CX),X0,X1\nVMOVSS X1,(DX)",
+		"g as input":                      "VMOVUPS (DI),X0\nVHADDPS (R14),X0,X1\nVMOVSS X1,(DX)",
+		"result wider than output":        "VMOVUPS (DI),Y0\nVHADDPS Y0,Y0,Y1\nVMOVUPS Y1,(DX)",
+		"write original input":            "VMOVUPS (DI),X0\nVHADDPS X0,X0,X1\nVMOVSS X1,(DI)",
+		"CFG missing incoming value":      "CMPQ AX,$0\nJE join\nVMOVUPS (DI),X0\njoin:\nVHADDPS X0,X0,X1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved horizontal state passed: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_horizontal_integer_test.go b/amd64_go_caller_horizontal_integer_test.go
new file mode 100644
index 000000000..0a87f3f68
--- /dev/null
+++ b/amd64_go_caller_horizontal_integer_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This first-party caller closes its own source/ABI boundary. The horizontal
+// operation has no exemption from the original raw-return stack certificate.
+func TestX86GoCallerHorizontalIntegerOriginalSourceThreeAPIs(t *testing.T) {
+	for _, body := range []string{
+		"VMOVDQU (DI),Y0\nVMOVDQU (SI),Y1\nVPHADDD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"VMOVDQU (SI),Y1\nVPHADDD (DI),Y1,Y2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(strings.Split(body, "\n")[1], func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs, ResolveSym: resolve}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			if ir, err := Translate(file, options); err != nil {
+				t.Error("text", err)
+			} else {
+				compileLLVMToObject(t, llc, options.TargetTriple, "horizontal-caller-text.ll", "horizontal-caller-text.o", ir)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Error("module", err)
+			} else {
+				compileLLVMToObject(t, llc, options.TargetTriple, "horizontal-caller-module.ll", "horizontal-caller-module.o", module.String())
+			}
+			if err := x86CallerCoreTranslate(t, pkg, assembly, options.TargetTriple); err != nil {
+				t.Error("selected Go caller", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerHorizontalIntegerCompleteNamedAndRawThreeAPIs(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		var body strings.Builder
+		for _, op := range x86HorizontalIntegerOpcodes {
+			rows := []string{op + " X0,X1"}
+			for _, bank := range []string{"X", "Y"} {
+				rows = append(rows, fmt.Sprintf("V%s %s0,%s1,%s2", op, bank, bank, bank), fmt.Sprintf("V%s (DI),%s1,%s2", op, bank, bank))
+			}
+			for _, row := range rows {
+				body.WriteString("VMOVDQU (DI),Y0\nVMOVDQU (SI),Y1\n")
+				if raw {
+					code := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if len(code) < 2 || code[len(code)-1] != 0xc3 {
+						t.Fatal("original Go horizontal bytes have no exact near RET", row, code)
+					}
+					for _, value := range code[:len(code)-1] {
+						fmt.Fprintf(&body, "BYTE $0x%02x\n", value)
+					}
+				} else {
+					body.WriteString(row + "\n")
+				}
+				result := "X2"
+				if !strings.HasPrefix(row, "V") {
+					result = "X1"
+				}
+				fmt.Fprintf(&body, "VMOVSS %s,(DX)\n", result)
+			}
+		}
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body.String(), 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM22 llc required")
+		}
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(fmt.Sprint(raw, "/", triple), func(t *testing.T) {
+				options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "horizontal-caller-text.ll", "horizontal-caller-text.o", ir)
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "horizontal-caller-module.ll", "horizontal-caller-module.o", module.String())
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerHorizontalIntegerCompleteMemoryCertificates(t *testing.T) {
+	for _, op := range x86HorizontalIntegerOpcodes {
+		for _, bank := range []string{"X", "Y"} {
+			row := fmt.Sprintf("V%s (DI),%s0,%s1", op, bank, bank)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVDQU (SI),Y0\n"+row+"\nVMOVSS X1,(DX)", 1)
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs, ResolveSym: resolve})
+			if err != nil {
+				t.Fatal(err)
+			}
+			found := false
+			for _, ins := range normalized.Funcs[0].Instrs {
+				form, known, err := x86HorizontalIntegerProperties(ins, "amd64")
+				if !known || err != nil || form.memory < 0 {
+					continue
+				}
+				found = true
+				access, exists := ins.x86CallerMemory[form.memory]
+				if !exists || access.width != int64(form.byteWidth) || access.write || !x86CallerMemoryCertified(ins, form.memory) {
+					t.Fatal("full horizontal source envelope lost its instruction identity", row)
+				}
+				for _, change := range []string{"opcode", "source", "destination", "width", "address", "direction", "address size"} {
+					access := access
+					local := ins
+					local.Args = append([]Operand(nil), ins.Args...)
+					local.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+					switch change {
+					case "opcode":
+						local.Op = "VPHADDSW"
+						if local.Op == ins.Op {
+							local.Op = "VPHSUBSW"
+						}
+					case "source":
+						local.Args[form.second].Reg = Reg(bank + "7")
+					case "destination":
+						local.Args[form.destination].Reg = Reg(bank + "7")
+					case "width":
+						access.width--
+						local.x86CallerMemory[form.memory] = access
+					case "address":
+						local.Args[form.memory].Mem.Off++
+					case "direction":
+						access.write = true
+						local.x86CallerMemory[form.memory] = access
+					case "address size":
+						local.x86AddressBits = 32
+					}
+					if x86CallerMemoryCertified(local, form.memory) {
+						t.Fatal("edited horizontal instruction borrowed stale memory identity", row, change)
+					}
+				}
+			}
+			if !found {
+				t.Fatal("fixture did not consume horizontal memory", row)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerHorizontalIntegerRetainsContextBoundaries(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":                     "VMOVDQU (DI),Y1\nVPHADDD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":                    "VMOVDQU (DI),Y0\nVPHSUBW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown destructive destination":   "VMOVDQU (DI),X0\nPHADDSW X0,X1\nVMOVSS X1,(DX)",
+		"unknown same subtract":             "VPHSUBD Y0,Y0,Y2\nVMOVSS X2,(DX)",
+		"partial upper input":               "MOVUPS (DI),X0\nVMOVDQU (SI),Y1\nVPHADDW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown pointer":                   "VMOVDQU (SI),Y0\nVPHADDD (BX),Y0,Y1\nVMOVSS X1,(DX)",
+		"full width length envelope":        "VMOVDQU (SI),Y0\nVPHADDW (CX),Y0,Y1\nVMOVSS X1,(DX)",
+		"full width scalar result envelope": "VMOVDQU (SI),Y0\nVPHSUBSW (DX),Y0,Y1\nVMOVSS X1,(DX)",
+		"physical SP":                       "VMOVDQU (SI),Y0\nVPHADDD (SP),Y0,Y1\nVMOVSS X1,(DX)",
+		"physical BP":                       "VMOVDQU (SI),Y0\nVPHSUBD (BP),Y0,Y1\nVMOVSS X1,(DX)",
+		"private stack alias":               "MOVQ SP,BX\nVMOVDQU (SI),Y0\nVPHADDW (BX),Y0,Y1\nVMOVSS X1,(DX)",
+		"g memory":                          "VMOVDQU (SI),Y0\nVPHADDSW (R14),Y0,Y1\nVMOVSS X1,(DX)",
+		"FP pointer data":                   "VMOVDQU (SI),X0\nVPHADDD a+0(FP),X0,X1\nVMOVSS X1,(DX)",
+		"legacy native alignment":           "VMOVDQU (SI),X0\nPHADDW (DI),X0\nVMOVSS X0,(DX)",
+		"MMX state":                         "PHADDD M0,M1\nMOVL AX,(DX)",
+		"pointer input write":               "VMOVDQU (DI),Y0\nVPHADDD Y0,Y0,Y1\nVMOVSS X1,(DI)",
+		"wide result write":                 "VMOVDQU (DI),Y0\nVPHADDD Y0,Y0,Y1\nVMOVDQU Y1,(DX)",
+		"unrestored SP":                     "VMOVDQU (DI),Y0\nVPHADDD Y0,Y0,Y1\nVMOVSS X1,(DX)",
+		"CFG missing source":                "VMOVDQU (DI),Y0\nCMPQ AX,$0\nJE join\nVMOVDQU (SI),Y1\njoin:\nVPHADDD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown effect":                    "VMOVDQU (DI),Y0\nVPHADDD Y0,Y0,Y1\nXCHGL AX,(DI)\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			if name == "unrestored SP" {
+				assembly = strings.Replace(assembly, "BYTE $0xc3", "SUBQ $8,SP\nBYTE $0xc3", 1)
+			}
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved %s acquired source/caller privilege: %v", name, err)
+			}
+		})
+	}
+	ins := x86YMMReadSource(t, "PHADDD M0,M1")
+	state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0)}}
+	state = x86CloneCallerState(state)
+	before := x86CloneCallerState(state)
+	if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(before, state) {
+		t.Fatal("MMX grammar inherited a physical caller state proof")
+	}
+}
diff --git a/amd64_go_caller_immediate_shuffle.go b/amd64_go_caller_immediate_shuffle.go
new file mode 100644
index 000000000..f52ff0c46
--- /dev/null
+++ b/amd64_go_caller_immediate_shuffle.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+// Byte availability follows the exact immediate permutation. No unused byte,
+// initialized mask, or shadow zero value establishes additional input data.
+func x86CallerImmediateShuffleStep(ins *Instr, form x86ImmediateShuffleForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.spec.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	var source uint64
+	if form.memory >= 0 {
+		// Caller-region identity does not promise legacy m128 alignment.
+		// E4NF memory keeps its full native tuple, including at mask zero.
+		if form.spec.legacy || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		source = x86CallerVectorByteMask(int64(form.memoryBytes))
+	} else {
+		source = state.vectors[x86CallerVectorRoot(form.source.Reg)]
+	}
+	known := uint64(0)
+	for byteIndex := 0; byteIndex < form.byteWidth; byteIndex++ {
+		known |= (source >> uint(form.sourceByte(byteIndex)) & 1) << uint(byteIndex)
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.mask >= 0 && !form.zeroing {
+		known &= old // Unknown initialized K may retain any old lane.
+	}
+	if form.spec.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_insert_extract.go b/amd64_go_caller_insert_extract.go
new file mode 100644
index 000000000..fb4e57e32
--- /dev/null
+++ b/amd64_go_caller_insert_extract.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+func x86CallerInsertExtractStep(ins *Instr, f x86InsertExtractForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if f.mask >= 0 && !state.masks[ins.Args[f.mask].Reg] || f.mask >= 0 && f.memoryWrite {
+		return false
+	}
+	if f.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.spec.chunk), f.memoryWrite) {
+		return false
+	}
+	source := state.vectors[x86CallerVectorRoot(ins.Args[f.source].Reg)]
+	low := x86CallerVectorByteMask(int64(f.spec.chunk))
+	if !f.spec.insert {
+		if source>>uint(f.offset)&low != low {
+			return false
+		}
+		if f.memoryWrite {
+			return true
+		}
+		if f.spec.scalar {
+			return x86CallerNumericWrite(ins.Args[f.destination].Reg, 8, state)
+		}
+		known := low
+		destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+		if f.mask >= 0 && !f.zeroing {
+			known &= state.vectors[destination]
+		}
+		state.vectors[destination] = ^low | known
+		return true
+	}
+	base := state.vectors[x86CallerVectorRoot(ins.Args[f.base].Reg)]
+	outputMask := x86CallerVectorByteMask(int64(f.output))
+	if f.spec.scalar {
+		insertLane := int(f.immediate>>4) & 3
+		insertMask := uint64(15) << uint(insertLane*4)
+		knownSource := source >> uint((f.immediate>>6)*4) & 15
+		if f.memory >= 0 {
+			knownSource = 15
+		}
+		known := base&^insertMask | knownSource<<uint(insertLane*4)
+		for lane := 0; lane < 4; lane++ {
+			if f.immediate&(1<<lane) != 0 {
+				known |= uint64(15) << uint(lane*4)
+			}
+		}
+		upper := ^outputMask
+		if f.spec.legacy {
+			upper &= state.vectors[x86CallerVectorRoot(ins.Args[f.destination].Reg)]
+		}
+		state.vectors[x86CallerVectorRoot(ins.Args[f.destination].Reg)] = upper | known&outputMask
+		return true
+	}
+	if f.memory < 0 && source&low != low {
+		return false
+	}
+	insertMask := low << uint(f.offset)
+	known := base&^insertMask | insertMask
+	if f.mask >= 0 && !f.zeroing {
+		known &= state.vectors[x86CallerVectorRoot(ins.Args[f.destination].Reg)]
+	}
+	state.vectors[x86CallerVectorRoot(ins.Args[f.destination].Reg)] = ^outputMask | known&outputMask
+	return true
+}
diff --git a/amd64_go_caller_insert_extract_test.go b/amd64_go_caller_insert_extract_test.go
new file mode 100644
index 000000000..268e58c29
--- /dev/null
+++ b/amd64_go_caller_insert_extract_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerInsertExtractOriginalSourceReachesObjects(t *testing.T) {
+	for _, body := range []string{
+		"VMOVUPS (DI),Y0\nLONG $0x197de3c4\nWORD $0x01c1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Z0\nVEXTRACTF64X4 $1,Z0,Y1\nVMOVSS X1,(DX)",
+		"VMOVUPS (DI),Y0\nVMOVUPS (SI),X1\nVINSERTF128 $1,X1,Y0,Y2\nVMOVSS X2,(DX)",
+		"VMOVUPS (DI),X0\nVEXTRACTPS $3,X0,AX\nMOVL AX,(DX)",
+		"VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVINSERTPS $64,X1,X0,X2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(strings.Split(body, "\n")[1], func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerInsertExtractWholeFamilyByteKnowledge(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		f, recognized, err := x86InsertExtractProperties(ins, "amd64")
+		if !recognized || err != nil {
+			t.Fatal(err)
+		}
+		if f.memory >= 0 {
+			continue
+		}
+		if f.spec.scalar && !f.spec.insert {
+			continue // full typed scalar-state coverage is exercised via public API below
+		}
+		for _, missing := range []int{-1, 0, 7, 15, 16, 31, 32, 63} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+			if missing >= 0 {
+				state.vectors[x86CallerVectorRoot(ins.Args[f.source].Reg)] &^= uint64(1) << uint(missing)
+			}
+			accepted := x86CallerInsertExtractStep(&ins, f, &state, nil)
+			if !f.spec.insert {
+				want := missing < f.offset || missing >= f.offset+f.output
+				if accepted != want {
+					t.Fatalf("%s missing source byte %d: %t want %t", row, missing, accepted, want)
+				}
+			} else if !f.spec.scalar && accepted != (missing < 0 || missing >= f.spec.chunk) {
+				t.Fatalf("%s missing insertion byte %d: %t", row, missing, accepted)
+			}
+		}
+	}
+	for _, row := range []string{"VEXTRACTF128 $1,Y1,X0", "VINSERTI128 $1,X0,Y1,Y2", "VINSERTPS $0,X0,X1,X2"} {
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		f, _, _ := x86InsertExtractProperties(ins, "amd64")
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0xffff, "Z1": ^uint64(0), "Z2": 0}, masks: map[Reg]bool{}}
+		if !x86CallerInsertExtractStep(&ins, f, &state, nil) || state.vectors[x86CallerVectorRoot(ins.Args[f.destination].Reg)] != ^uint64(0) {
+			t.Fatalf("complete inputs did not establish physical upper-zero: %s", row)
+		}
+	}
+}
+
+func TestX86GoCallerInsertExtractAllOpcodesAndUnknownPermissions(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		row = strings.Replace(row, "(BX)", "(DI)", 1)
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		f, _, _ := x86InsertExtractProperties(ins, "amd64")
+		if f.memoryWrite {
+			continue // caller's scalar result is only four bytes, not vector output
+		}
+		store := fmt.Sprintf("VMOVSS X%d,(DX)", ins.Args[f.destination].Reg[len(ins.Args[f.destination].Reg)-1]-'0')
+		if f.spec.scalar && !f.spec.insert {
+			store = "MOVL AX,(DX)"
+		}
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nKMOVQ AX,K1\n"+row+"\n"+store, 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+			t.Fatalf("%s: %v", row, err)
+		}
+	}
+	for name, body := range map[string]string{
+		"unknown selected extract":         "VEXTRACTF128 $1,Y0,X1\nVMOVSS X1,(DX)",
+		"unknown inserted bytes":           "VMOVUPS (DI),Y1\nVINSERTF128 $1,X0,Y1,Y2\nVEXTRACTF128 $1,Y2,X2\nVMOVSS X2,(DX)",
+		"uninitialized retained base":      "VMOVUPS (DI),X0\nVINSERTI128 $1,X0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown mask":                     "VMOVUPS (DI),Z0\nVEXTRACTI32X4.Z $0,Z0,K1,X1\nVMOVSS X1,(DX)",
+		"unknown masked merge destination": "VMOVUPS (DI),Z0\nKMOVQ AX,K1\nVEXTRACTF32X4 $0,Z0,K1,X1\nVMOVSS X1,(DX)",
+		"pointer FP not numerical":         "VMOVUPS (DI),Y1\nVINSERTF128 $0,a+0(FP),Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown memory even zero mask":    "VMOVUPS (DI),Z1\nMOVQ $0,AX\nKMOVQ AX,K1\nVINSERTF32X4.Z $0,(BX),Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"read source SP":                   "VMOVUPS (DI),Y1\nVINSERTI128 $0,(SP),Y1,Y2\nVMOVSS X2,(DX)",
+		"source length too narrow":         "VMOVUPS (DI),Y1\nVINSERTF128 $0,(CX),Y1,Y2\nVMOVSS X2,(DX)",
+		"write input":                      "VMOVUPS (DI),X0\nVEXTRACTPS $0,X0,(DI)",
+		"write g":                          "VMOVUPS (DI),X0\nVEXTRACTPS $0,X0,R14",
+		"CFG incomplete":                   "CMPQ AX,$0\nJE join\nVMOVUPS (DI),Y0\njoin:\nVEXTRACTF128 $1,Y0,X1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown source permission invented: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_lea_runtime_test.go b/amd64_go_caller_lea_runtime_test.go
new file mode 100644
index 000000000..a1fc2e2ac
--- /dev/null
+++ b/amd64_go_caller_lea_runtime_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86CallerLEARuntimeForm struct {
+	name, suffix string
+	bits, scale  int
+}
+
+func x86CallerLEARuntimeForms() []x86CallerLEARuntimeForm {
+	var forms []x86CallerLEARuntimeForm
+	for _, width := range []struct {
+		suffix string
+		bits   int
+	}{{"W", 16}, {"L", 32}, {"Q", 64}} {
+		for _, scale := range []int{1, 2, 4, 8} {
+			forms = append(forms, x86CallerLEARuntimeForm{
+				name: fmt.Sprintf("kernel%s%d", width.suffix, scale), suffix: width.suffix,
+				bits: width.bits, scale: scale,
+			})
+		}
+	}
+	return forms
+}
+
+func x86CallerLEARuntimeSources() (goSource, assembly, goTest, cOracle string) {
+	var declarations, machine, tests, c strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	tests.WriteString(`package caller
+import "testing"
+func TestOriginalLEAMathematics(t *testing.T) {
+ values := []uint64{0, 1, 7, 19, 65535, 1<<16, 1<<31, 1<<32-1, 1<<32, 1<<63, ^uint64(0)}
+`)
+	c.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for _, form := range x86CallerLEARuntimeForms() {
+		fmt.Fprintf(&declarations, `
+//go:noescape
+func %[1]s(a, b, res, length unsafe.Pointer)
+func Call%[1]s(x, y []uint64) uint64 {
+ var res uint64
+ length := len(x)
+ %[1]s(unsafe.Pointer(unsafe.SliceData(x)), unsafe.Pointer(unsafe.SliceData(y)),
+  unsafe.Pointer(&res), unsafe.Pointer(&length))
+ return res
+}
+`, form.name)
+		fmt.Fprintf(&machine, `TEXT ·%s(SB),4,$0-32
+MOVQ a+0(FP),DI
+MOVQ b+8(FP),SI
+MOVQ res+16(FP),DX
+MOVQ length+24(FP),CX
+BYTE $0x55
+WORD $0x8948
+BYTE $0xe5
+LONG $0xf8e48348
+MOVQ (DI),R9
+MOVQ (SI),BX
+MOVQ $0x1122334455667788,AX
+LEA%s -7(R9)(BX*%d),AX
+MOVQ AX,(DX)
+WORD $0x8948
+BYTE $0xec
+BYTE $0x5d
+BYTE $0xc3
+`, form.name, form.suffix, form.scale)
+		fmt.Fprintf(&tests, `
+ for _, x := range values {
+  for _, y := range values {
+   a, b := []uint64{x, 23}, []uint64{y, 37}
+   canary := [4]uint64{11, 41, 53, 67}
+   want := x + y*%[1]d - 7
+`, form.scale)
+		switch form.bits {
+		case 16:
+			tests.WriteString("   want = 0x1122334455660000 | uint64(uint16(want))\n")
+		case 32:
+			tests.WriteString("   want = uint64(uint32(want))\n")
+		}
+		fmt.Fprintf(&tests, `
+   if got := Call%[1]s(a, b); got != want || a[0] != x || a[1] != 23 || b[0] != y || b[1] != 37 ||
+    canary != [4]uint64{11, 41, 53, 67} {
+    t.Fatalf("%[1]s x=%%#x y=%%#x got=%%#x want=%%#x", x, y, got, want)
+   }
+  }
+ }
+`, form.name)
+		fmt.Fprintf(&c, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", form.name, form.name)
+	}
+	tests.WriteString("}\n")
+	c.WriteString(`int main(void) {
+ const uint64_t values[] = {0,1,7,19,65535,UINT64_C(1)<<16,UINT64_C(1)<<31,UINT32_MAX,
+  UINT64_C(1)<<32,UINT64_C(1)<<63,UINT64_MAX};
+`)
+	for _, form := range x86CallerLEARuntimeForms() {
+		fmt.Fprintf(&c, `
+ for (unsigned i=0; i<sizeof(values)/sizeof(values[0]); i++) {
+  for (unsigned j=0; j<sizeof(values)/sizeof(values[0]); j++) {
+   uint8_t a[17], b[19], output[33], before[33];
+   uint64_t x=values[i], y=values[j], length=1, got=0;
+   memset(a,0xa3,sizeof(a)); memset(b,0xb7,sizeof(b));
+   memcpy(a+1,&x,8); memcpy(b+3,&y,8);
+   memset(output,0xc9,sizeof(output)); memcpy(before,output,sizeof(output));
+   uint64_t want = x + y*%d - 7;
+`, form.scale)
+		switch form.bits {
+		case 16:
+			c.WriteString("   want = UINT64_C(0x1122334455660000) | (uint16_t)want;\n")
+		case 32:
+			c.WriteString("   want = (uint32_t)want;\n")
+		}
+		fmt.Fprintf(&c, `
+   %s(a+1,b+3,output+5,&length);
+   memcpy(&got,output+5,8); memcpy(before+5,&want,8);
+   if (got!=want || memcmp(output,before,sizeof(output)) || length!=1) return 1;
+   uint64_t after_x=0,after_y=0;
+   memcpy(&after_x,a+1,8); memcpy(&after_y,b+3,8);
+   if (after_x!=x || after_y!=y || a[0]!=0xa3 || a[9]!=0xa3 || b[2]!=0xb7 || b[11]!=0xb7) return 2;
+  }
+ }
+`, form.name)
+	}
+	c.WriteString(" return 0;\n}\n")
+	return declarations.String(), machine.String(), tests.String(), c.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerLEAModuloAndCanaries(t *testing.T) {
+	testX86CallerLEAModuloAndCanaries(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawLEADisplacementModuloAndCanaries(t *testing.T) {
+	testX86CallerLEAModuloAndCanaries(t, true)
+}
+
+func testX86CallerLEAModuloAndCanaries(t *testing.T, raw bool) {
+	t.Helper()
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("LEA execution requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	goSource, assembly, goTest, cOracle := x86CallerLEARuntimeSources()
+	if raw {
+		for _, form := range x86CallerLEARuntimeForms() {
+			rex := byte(0x41) // numerical R9 base; destination AX, index BX.
+			var encoding []byte
+			if form.bits == 16 {
+				encoding = append(encoding, 0x66)
+			} else if form.bits == 64 {
+				rex |= 8
+			}
+			scale := map[int]byte{1: 0, 2: 1, 4: 2, 8: 3}[form.scale]
+			encoding = append(encoding, rex, 0x8d, 0x84, scale<<6|3<<3|1)
+			encoding = binary.LittleEndian.AppendUint32(encoding, 0xfffffff9)
+			named := fmt.Sprintf("LEA%s -7(R9)(BX*%d),AX", form.suffix, form.scale)
+			if strings.Count(assembly, named) != 1 {
+				t.Fatalf("raw LEA fixture lost its independent named form: %s", named)
+			}
+			assembly = strings.Replace(assembly, named, x86RawDisplacementDirectives(encoding), 1)
+		}
+	}
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": goSource,
+		"value_amd64.s": assembly, "value_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go LEA modulo/canary oracle: %v\n%s", err, output)
+	}
+	pkg := x86CallerRuntimePackage(t, goSource, assembly)
+	llvmContext := llvm.NewContext()
+	defer llvmContext.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(llvmContext, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "caller_lea", triple, translation.Module.String(), cOracle, runner)
+}
diff --git a/amd64_go_caller_lea_test.go b/amd64_go_caller_lea_test.go
new file mode 100644
index 000000000..1cea3bffa
--- /dev/null
+++ b/amd64_go_caller_lea_test.go
@@ -0,0 +1,357 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86LEAActualTargetGoObject(t *testing.T, arch, triple, source string) *x86LEAGoObjectReceipt {
+	t.Helper()
+	goos := "linux"
+	if strings.Contains(triple, "apple") {
+		goos = "darwin"
+	} else if strings.Contains(triple, "windows") {
+		goos = "windows"
+	}
+	dir := t.TempDir()
+	path := filepath.Join(dir, "lea.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	include := filepath.Join(filepath.Dir(filepath.Dir(driver)), "pkg", "include")
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-I", include,
+		"-p", "sourceframe", "-o", filepath.Join(dir, "lea.o"), path)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch, "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go %s/%s LEA object: %v\n%s", goos, arch, err, output)
+	}
+	return x86LEAReadObjectReceipt(t, arch, goos, source, path, driver, driverHash, filepath.Join(dir, "lea.o"))
+}
+
+// These raw LEAL instructions are the original forms in Weaviate's
+// dot_avx256_amd64.s. The address base is a loaded numerical length, not the
+// caller's pointer to that length. LEA does not dereference either register.
+func TestX86GoCallerLEANumericalLengthOriginalRawForms(t *testing.T) {
+	for _, form := range []struct {
+		name, instructions string
+	}{
+		{"minus-one", "LONG $0xff418d45\nMOVL R8,AX"},
+		{"minus-thirty-two", "LONG $0xe0498d41\nMOVL CX,AX"},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX",
+				"MOVQ (CX),R9\n"+form.instructions, 1)
+			requireLEANativeGoObject(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerLEACompleteNumericalWidthsAndAddressForms(t *testing.T) {
+	for _, width := range []struct{ suffix, copy string }{
+		{"W", "MOVW"}, {"L", "MOVL"}, {"Q", "MOVQ"},
+	} {
+		for _, address := range []string{
+			"-1(R9)", "19(R9)", "-7(R9)(BX*1)", "-7(R9)(BX*2)",
+			"-7(R9)(BX*4)", "-7(R9)(BX*8)", "-7(BX*4)",
+		} {
+			for _, triple := range []string{
+				"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+			} {
+				t.Run(width.suffix+"/"+address+"/"+triple, func(t *testing.T) {
+					body := "MOVQ (CX),R9\nMOVQ $19,BX\nLEA" + width.suffix + " " + address + ",R8\n" + width.copy + " R8,AX\nMOVL AX,(DX)"
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					requireLEANativeGoObject(t, "amd64", assembly, true)
+					pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+					if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerLEADefinedBytesAndPointerTaint(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		accepted   bool
+	}{
+		{"word-low-input", "MOVW $9,BX\nLEAW -7(BX),R8\nMOVW R8,AX", true},
+		{"word-unknown-upper", "MOVW $9,BX\nLEAW -7(BX),R8\nMOVL R8,AX", false},
+		{"word-preserves-upper", "MOVQ $19,R8\nMOVW $9,BX\nLEAW -7(BX),R8\nMOVQ R8,AX", true},
+		{"word-pointer-upper", "LEAW -7(R9),DX", false},
+		{"word-pointer-source", "LEAW -7(DI),R8\nMOVW R8,AX", false},
+		{"long-word-only-input", "MOVW $9,BX\nLEAL -7(BX),R8\nMOVL R8,AX", false},
+		{"long-zeroes-upper", "MOVL $9,BX\nLEAL -7(BX),R8\nMOVQ R8,AX", true},
+		{"long-pointer-alias", "LEAL -7(DI),DI\nMOVL DI,AX", false},
+		{"long-pointer-copy", "MOVQ DI,BX\nLEAL -7(BX),R8\nMOVL R8,AX", false},
+		{"long-clobbers-pointer", "MOVL $9,BX\nLEAL -7(BX),CX\nMOVQ CX,AX", true},
+		{"long-encoding-truncates-disp", "MOVL $9,BX\nLEAL 0x100000002(BX),R8\nMOVQ R8,AX", true},
+		{"quad-word-only-input", "MOVW $9,BX\nLEAQ -7(BX),R8\nMOVL R8,AX", false},
+		{"quad-zeroextended-input", "MOVL $9,BX\nLEAQ -7(BX),R8\nMOVL R8,AX", true},
+		{"quad-numeric-alias", "LEAQ -7(R9),R9\nMOVL R9,AX", true},
+		{"unknown-base", "LEAL -7(BX),R8\nMOVL R8,AX", false},
+		{"unknown-index", "LEAL -7(R9)(BX*4),R8\nMOVL R8,AX", false},
+		{"pointer-index", "LEAL -7(R9)(DI*4),R8\nMOVL R8,AX", false},
+		{"pointer-affine-index", "MOVL $0,BX\nLEAQ (DI)(BX*4),R8\nMOVL (R8),AX", false},
+		{"pointer-affine-origin", "LEAQ 1(DX),BX\nMOVB $7,AX\nMOVB AX,(BX)", true},
+		{"pointer-affine-out-of-envelope", "LEAQ 4(DX),BX\nMOVL AX,(BX)", false},
+		{"pointer-affine-input-write", "LEAQ 1(DI),BX\nMOVB AX,(BX)", false},
+		{"pointer-as-data", "LEAQ 1(DI),BX\nMOVL BX,AX", false},
+		{"word-SP-escape", "LEAW (SP),R8\nMOVW R8,AX", false},
+		{"long-SP-escape", "LEAL (SP),R8\nMOVL R8,AX", false},
+		{"quad-SP-escape", "LEAQ (SP),R8\nMOVL R8,AX", false},
+		{"word-BP-escape", "LEAW (BP),R8\nMOVW R8,AX", false},
+		{"long-stack-index", "LEAL (R9)(SP*1),R8\nMOVL R8,AX", false},
+		{"word-SP-write", "LEAW 0(SP),SP", false},
+		{"long-SP-write", "LEAL 0(SP),SP", false},
+		{"quad-caller-to-SP", "LEAQ 0(DI),SP", false},
+		{"quad-caller-to-BP", "LEAQ 0(DI),BP", false},
+		{"typed-FP-address", "LEAQ a+0(FP),R8\nMOVL R8,AX", false},
+		{"unknown-symbol", "LEAQ outsider(SB),R8\nMOVL R8,AX", false},
+		{"raw-RIP-code-address", "LONG $0x00058d48\nWORD $0\nBYTE $0\nMOVL AX,(DX)", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			body := "MOVQ (CX),R9\n" + test.body + "\nMOVL AX,(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			// SP is not an encodable SIB index. All other negative cases are
+			// actual Go inputs rejected for missing semantic provenance.
+			requireLEANativeGoObject(t, "amd64", assembly, test.name != "long-stack-index")
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if test.name == "raw-RIP-code-address" {
+				if err == nil || !strings.Contains(err.Error(), "raw x86 local address target byte 7") {
+					t.Fatalf("out-of-group raw RIP address lost its existing decoder rejection: %v", err)
+				}
+				return
+			}
+			if test.accepted && err != nil {
+				t.Fatal(err)
+			}
+			if !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved address acquired numeric/pointer permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86RawReturnSourceStackLEANativeOrCallerContractAcrossFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			if x86LEAWidth(Op("LEA"+suffix), target.arch) == 0 {
+				continue // Go has no 64-bit LEA encoding in 386 mode.
+			}
+			t.Run(target.triple+"/"+suffix, func(t *testing.T) {
+				push, pop := "PUSHQ", "POPQ"
+				if target.arch == "386" {
+					push, pop = "PUSHL", "POPL"
+				}
+				body := "@MOV x+0(FP),AX\n" + push + " BP\n@MOV SP,BP\n@MOV $19,BX\nLEA" + suffix +
+					" -7(AX)(BX*4),AX\n@MOV BP,SP\n" + pop + " BP\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3"
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, body)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := x86SourceStackOptions(target.arch, target.triple, sig)
+				ir, err := Translate(file, options)
+				if suffix != strings.TrimPrefix(push, "PUSH") {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("ordinary types/stack proof invented numerical GP permissions: %v", err)
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := TranslateModuleInContext(ctx, file, options)
+					if err == nil {
+						module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("module API invented numerical GP permissions: %v", err)
+					}
+					translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+						GOARCH: target.arch, TargetTriple: target.triple,
+					})
+					if translation != nil {
+						translation.Module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("actual declaration API invented numerical GP permissions: %v", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "source-lea.ll", "source-lea.o", ir)
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer module.Dispose()
+				compileLLVMToObject(t, llc, target.triple, "source-lea-module.ll", "source-lea-module.o", module.String())
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple,
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer translation.Module.Dispose()
+				compileLLVMToObject(t, llc, target.triple, "source-lea-go-module.ll", "source-lea-go-module.o", translation.Module.String())
+			})
+		}
+	}
+}
+
+func TestX86CallerLEAStatePreservesExactDefinitionAndPointerOrigin(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		known       uint8
+		pointer     bool
+		accepted    bool
+	}{
+		{"LEAW -7(AX),BX", 0xa3, false, true},
+		{"LEAL -7(AX),BX", 0xff, false, true},
+		{"LEAQ -7(AX),BX", 0xff, false, true},
+		{"LEAL -7(AX),AX", 0xff, false, true},
+		{"LEAW -7(AX),DX", 0, true, false},
+		{"LEAL -7(DX),DX", 0, true, false},
+		{"LEAQ -7(DX),BX", 0, true, true},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT kernel(SB),4,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			state := x86SourceStackState{
+				callers: map[Reg]x86CallerPointerValue{DX: {argument: 2, offset: 8}},
+				known:   map[Reg]uint8{AX: 0xff, BX: 0xa0}, numericFlags: true,
+			}
+			instruction := &file.Funcs[0].Instrs[1]
+			if got := x86CallerLEAStep(instruction, &state); got != test.accepted {
+				t.Fatalf("LEA acceptance = %v, want %v", got, test.accepted)
+			}
+			if !test.accepted {
+				if state.callers[DX] != (x86CallerPointerValue{argument: 2, offset: 8}) || state.known[BX] != 0xa0 {
+					t.Fatal("rejected LEA mutated provenance")
+				}
+				return
+			}
+			destination := instruction.Args[1].Reg
+			pointer, present := state.callers[destination]
+			if state.known[destination] != test.known || present != test.pointer || !state.numericFlags {
+				t.Fatalf("wrong byte/flags definition: %+v", state)
+			}
+			if present && pointer != (x86CallerPointerValue{argument: 2, offset: 1}) {
+				t.Fatalf("affine LEA changed caller origin: %+v", pointer)
+			}
+		})
+	}
+}
+
+func TestX86LEADisplacementEncodingUsesActualGoRules(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			for _, displacement := range []int64{-1 << 31, 1<<31 - 1, 1 << 31, 1<<32 - 1, 1 << 32, -1<<31 - 1} {
+				t.Run(fmt.Sprintf("%s/%s/%d", target.triple, suffix, displacement), func(t *testing.T) {
+					width := x86LEAWidth(Op("LEA"+suffix), target.arch)
+					accepted := width != 0 && (displacement == int64(int32(displacement)) ||
+						target.arch == "amd64" && suffix == "L" || target.arch == "386" && displacement == int64(uint32(displacement)))
+					source := fmt.Sprintf("TEXT Value(SB),4,$0-0\nMOVL $9,AX\nLEA%s %d(AX),BX\nRET\n", suffix, displacement)
+					requireLEANativeGoObject(t, target.arch, source, accepted)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}})
+					if !accepted {
+						if err == nil {
+							t.Fatal("accepted displacement rejected by actual Go")
+						}
+						return
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, target.triple, "lea-displacement.ll", "lea-displacement.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestX86LEASharedGrammarRejectsGoInvalidSIBFields(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, address := range []string{"8(AX)(BX*0)", "8(AX)(BX*3)", "8(AX)(BX*16)", "8(AX)(SP*1)", "outsider", "$outsider(SB)"} {
+			t.Run(arch+"/"+address, func(t *testing.T) {
+				source := "TEXT Value(SB),4,$0-0\nLEAL " + address + ",CX\nRET\n"
+				requireLEANativeGoObject(t, arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{Goarch: arch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}}); err == nil {
+					t.Fatal("shared LEA grammar accepted Go-invalid SIB index/scale")
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnLEANewWidthsCannotInventNumericGPInitialization(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		suffixes := []string{"W", "L"}
+		push, pop, native := "PUSHQ", "POPQ", "Q"
+		if target.arch == "386" {
+			push, pop, native = "PUSHL", "POPL", "L"
+		}
+		for _, suffix := range suffixes {
+			if suffix == native {
+				continue // This test guards this batch's newly admitted widths.
+			}
+			t.Run(target.triple+"/"+suffix, func(t *testing.T) {
+				body := push + " BP\n@MOV SP,BP\nLEA" + suffix + " (BX),AX\n@MOV BP,SP\n" +
+					pop + " BP\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3"
+				source, sig, _ := x86SourceStackNumericalFixture(target.arch, body)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, x86SourceStackOptions(target.arch, target.triple, sig)); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("a frame/type declaration invented unknown BX/upper-AX inputs: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_go_caller_legacy_moves.go b/amd64_go_caller_legacy_moves.go
new file mode 100644
index 000000000..1386d4221
--- /dev/null
+++ b/amd64_go_caller_legacy_moves.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+// Only the whole-source caller proof consumes this transfer. The shared Go
+// grammar supplies width/direction; neither recognition nor a numerical vector
+// supplies pointer, backing, native alignment or allocation-extent authority.
+func x86CallerLegacyPackedMoveStep(ins *Instr, form x86LegacyPackedMoveForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	const width = int64(16)
+	mask := x86CallerVectorByteMask(width)
+	var known uint64
+	if form.memory >= 0 {
+		// Preserve the existing packed-move boundary: ordinary numerical
+		// SliceData is not proof of the aligned opcode's native address.
+		if form.aligned {
+			return false
+		}
+		if form.memoryWrite && state.vectors[x86CallerVectorRoot(form.source.Reg)]&mask != mask {
+			return false
+		}
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, width, form.memoryWrite) {
+			return false
+		}
+		if form.memoryWrite {
+			return true
+		}
+		known = mask
+	} else {
+		// Register copies propagate unknown source bytes without making
+		// them numeric. A later observable consumer still needs its bytes.
+		known = state.vectors[x86CallerVectorRoot(form.source.Reg)] & mask
+	}
+	destination := x86CallerVectorRoot(form.destination.Reg)
+	state.vectors[destination] = state.vectors[destination]&^mask | known
+	return true // Legacy writes preserve every upper Y/Z byte and all FLAGS.
+}
diff --git a/amd64_go_caller_legacy_moves_test.go b/amd64_go_caller_legacy_moves_test.go
new file mode 100644
index 000000000..e3dc579a9
--- /dev/null
+++ b/amd64_go_caller_legacy_moves_test.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The independent Go directory includes all twelve yxmov opcodes and MOVOA's
+// frontend alias. Sharing yxmov does not share lane, source or memory effects.
+var x86CallerLegacyMoveDirectory = []struct {
+	name, prefix, bytes string
+	width               int64
+	half, aligned       bool
+}{
+	{"MOVAPD", "Pe", "0x28, 0x29", 16, false, true},
+	{"MOVAPS", "Pm", "0x28, 0x29", 16, false, true},
+	{"MOVO", "Pe", "0x6f, 0x7f", 16, false, true},
+	{"MOVOU", "Pf3", "0x6f, 0x7f", 16, false, false},
+	{"MOVHPD", "Pe", "0x16, 0x17", 8, true, false},
+	{"MOVHPS", "Pm", "0x16, 0x17", 8, true, false},
+	{"MOVLPD", "Pe", "0x12, 0x13", 8, true, false},
+	{"MOVLPS", "Pm", "0x12, 0x13", 8, true, false},
+	{"MOVSD", "Pf2", "0x10, 0x11", 8, false, false},
+	{"MOVSS", "Pf3", "0x10, 0x11", 4, false, false},
+	{"MOVUPD", "Pe", "0x10, 0x11", 16, false, false},
+	{"MOVUPS", "Pm", "0x10, 0x11", 16, false, false},
+	{"MOVOA", "Pe", "0x6f, 0x7f", 16, false, true},
+}
+
+func TestX86GoCallerLegacyMoveCompleteGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A(MOV\w+), yxmov, (\w+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 12 {
+		t.Fatalf("actual Go yxmov opcode/attribute inventory changed: %d", len(rows))
+	}
+	for index, row := range rows {
+		want := x86CallerLegacyMoveDirectory[index]
+		if row[1] != want.name || row[2] != want.prefix || row[3] != want.bytes {
+			t.Fatalf("actual Go opcode attributes differ: %v want %+v", row, want)
+		}
+	}
+	table := regexp.MustCompile(`(?s)var yxmov = \[\]ytab\{\n(.*?)\n\}`).FindSubmatch(data)
+	if len(table) != 2 || strings.Join(strings.Fields(string(table[1])), " ") !=
+		"{Zm_r_xm, 1, argList{Yxm, Yxr}}, {Zr_m_xm, 1, argList{Yxr, Yxm}}," {
+		t.Fatal("actual Go operand classes, zcases or row-byte advances changed")
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil || !strings.Contains(string(aliases), `instructions["MOVOA"] = x86.AMOVO`) {
+		t.Fatal("actual Go MOVOA frontend identity changed", err)
+	}
+}
+
+func x86CallerLegacyMoveInstruction(t *testing.T, text string) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+text+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86GoCallerLegacyMoveRegisteredEffects(t *testing.T) {
+	// A transfer-domain model, not a package/caller authority producer. Complete
+	// actual source/signature binding is tested separately below. Input slices
+	// retain the existing numerical-origin/nonalias contract, not allocation bounds.
+	proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{
+		{kind: x86CallerSliceInput, width: 4},
+		{kind: x86CallerFreshResult, width: 8},
+	}}
+	for _, row := range x86CallerLegacyMoveDirectory {
+		for _, operands := range []string{"X0,X1", "(DI),X1", "X0,(DX)"} {
+			t.Run(row.name+"/"+operands, func(t *testing.T) {
+				ins := x86CallerLegacyMoveInstruction(t, row.name+" "+operands)
+				original := fmt.Sprintf("%#v", ins)
+				if known := x86CallerVectorMoveKnown(ins); known == row.half {
+					t.Errorf("caller known axis: got %t, half-unregistered=%t", known, row.half)
+				}
+				if x86SourceStackInstructionKnown(ins, "MOVQ", "Q", "amd64") {
+					t.Error("a move shape alone acquired non-caller source-stack admission")
+				}
+				if original != fmt.Sprintf("%#v", ins) {
+					t.Fatal("known/grammar observation changed original instruction")
+				}
+				state := x86SourceStackState{
+					callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}, DX: {argument: 1}},
+					vectors: map[Reg]uint64{"Z0": 0xffff, "Z1": 1 << 40},
+					known:   map[Reg]uint8{}, masks: map[Reg]bool{}, partialNumericFlags: x86ByteFlagCF | x86ByteFlagOF,
+				}
+				wantValid := !row.half && (!row.aligned || operands == "X0,X1") &&
+					(operands != "X0,(DX)" || row.width <= 8)
+				if valid := x86CallerVectorMoveStep(&ins, &state, proof); valid != wantValid {
+					t.Errorf("caller step axis: got %t want %t", valid, wantValid)
+				}
+				if !x86SourceStackFlagsStep(ins, &state) || x86SourceStackNumericFlagMask(&state) != x86ByteFlagCF|x86ByteFlagOF {
+					t.Error("legacy move changed or fabricated numerical flags")
+				}
+				memory := -1
+				if operands == "(DI),X1" {
+					memory = 0
+				} else if operands == "X0,(DX)" {
+					memory = 1
+				}
+				if memory >= 0 {
+					width, write, known := x86InstructionMemoryShape(ins, memory, "amd64")
+					if known == row.half || known && (width != row.width || write != (memory == 1)) {
+						t.Errorf("memory-shape axis differs: %d/%t/%t", width, write, known)
+					}
+					if wantValid && (!x86CallerMemoryCertified(ins, memory) || ins.x86CallerMemory[memory].width != row.width) {
+						t.Error("accepted read/write lacks its exact instruction-local native width")
+					}
+				} else if !row.half {
+					want := uint64(1)<<40 | 0xffff
+					if row.width < 16 {
+						want = uint64(1)<<40 | x86CallerVectorByteMask(row.width)
+					}
+					if state.vectors["Z1"] != want {
+						t.Errorf("register transfer fabricated/cleared old X/Y/Z bytes: %x want %x", state.vectors["Z1"], want)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerLegacyMoveActualSourceProducer(t *testing.T) {
+	for _, row := range x86CallerLegacyMoveDirectory {
+		t.Run(row.name, func(t *testing.T) {
+			body := row.name + " (DI),X1"
+			if row.aligned {
+				// The current caller contract has no native alignment witness.
+				// Register recognition must not authorize aligned memory.
+				body = "VMOVUPS (DI),X1\n" + row.name + " X1,X2"
+			}
+			assembly := "TEXT ·kernel(SB),4,$0-32\nMOVQ a+0(FP),DI\n" + body + "\nBYTE $0xc3\n"
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := sigs["caller.kernel"]
+			if sig.Ret != Void || len(sig.Frame.Results) != 0 || sig.x86CallerRegions == nil ||
+				!x86CallerRegionSourceMatches(sig, file.Funcs[0], "amd64") {
+				t.Fatal("actual original source and pointer-only Void signature prerequisite missing")
+			}
+			decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", ResolveSym: resolve, Sigs: sigs}
+			proved := normalizeX86RawReturnSourceStack(decoded, options, true, file.Funcs[0])
+			if row.half {
+				if proved.x86SourceStack != nil {
+					t.Fatal("half-vector move inherited an unproved caller byte effect")
+				}
+				return
+			}
+			if proved.x86SourceStack == nil || !x86CallerNormalizedSourceMatches(proved, sig) {
+				t.Fatalf("existing typed move lacks whole-source caller producer hook: %s", proved.x86SourceStackFailure)
+			}
+			for _, ins := range proved.Instrs {
+				if !row.aligned && ins.Op == Op(row.name) && (!x86CallerMemoryCertified(ins, 0) || ins.x86CallerMemory[0].width != row.width) {
+					t.Fatal("actual instruction did not retain exact numerical-source read width")
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerLegacyMoveDoesNotBorrowUnknownBytesOrRegions(t *testing.T) {
+	for _, row := range x86CallerLegacyMoveDirectory {
+		if row.half {
+			continue
+		}
+		for _, text := range []string{row.name + " X0,X1", row.name + " (BX),X1", row.name + " X0,(DI)", row.name + " X0,1(DX)"} {
+			t.Run(text, func(t *testing.T) {
+				ins := x86CallerLegacyMoveInstruction(t, text)
+				proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{
+					{kind: x86CallerSliceInput, width: 4}, {kind: x86CallerFreshResult, width: row.width},
+				}}
+				state := x86SourceStackState{
+					callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}, DX: {argument: 1}},
+					vectors: map[Reg]uint64{"Z0": x86CallerVectorByteMask(row.width) &^ 1},
+					known:   map[Reg]uint8{}, masks: map[Reg]bool{},
+				}
+				valid := x86CallerVectorMoveStep(&ins, &state, proof)
+				if text == row.name+" X0,X1" {
+					// A register copy may propagate unknown bytes. It may never
+					// turn those bytes into a numerically initialized output.
+					if valid && state.vectors["Z1"]&x86CallerVectorByteMask(row.width) == x86CallerVectorByteMask(row.width) {
+						t.Fatal("register transfer fabricated a missing source byte")
+					}
+					ins = x86CallerLegacyMoveInstruction(t, row.name+" X1,(DX)")
+					valid = x86CallerVectorMoveStep(&ins, &state, proof)
+				}
+				if valid {
+					t.Fatal("move acquired unknown numerical byte/address or exceeded the fresh result envelope")
+				}
+				if !reflect.DeepEqual(state.callers, map[Reg]x86CallerPointerValue{DI: {argument: 0}, DX: {argument: 1}}) {
+					t.Fatal("failed numerical transfer changed pointer provenance")
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_go_caller_logical.go b/amd64_go_caller_logical.go
new file mode 100644
index 000000000..1ea3a8ccc
--- /dev/null
+++ b/amd64_go_caller_logical.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+// Packed bitwise operations do not write flags or GP/stack state. Their byte
+// availability is independent of the shared operand grammar. MMX has no
+// reviewed private caller move bank and must not be aliased to virtual Z0.
+func x86CallerPackedLogicalStep(ins *Instr, form x86PackedLogicalForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := uint64(0)
+	if form.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := x86PackedLogicalDefinedBytes(*ins, form, first, second, old)
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		// Every VEX/EVEX width clears all higher physical register bits.
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_logical_runtime_test.go b/amd64_go_caller_logical_runtime_test.go
new file mode 100644
index 000000000..16eefe33c
--- /dev/null
+++ b/amd64_go_caller_logical_runtime_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86GoLogicalAndNotOperandOrder(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires Linux/amd64 runtime counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools missing")
+	}
+	var declarations, assembly, tests, oracle strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	tests.WriteString(`package caller
+import "testing"
+func TestOriginalLogicalMathematics(t *testing.T) {
+ values:=[]uint64{0,1,7,0x0ff00ff0a55aa55a,0x33cc55aa5aa5f00f,1<<63,^uint64(0)}
+`)
+	oracle.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for _, op := range []string{"ANDNPS", "ANDNPD", "PANDN"} {
+		name := strings.ToLower(op)
+		fmt.Fprintf(&declarations, `
+//go:noescape
+func %[1]s(a,b,res,length unsafe.Pointer)
+func Call%[1]s(x,y []uint64) uint64 {
+ var res uint64
+ length:=len(x)
+ %[1]s(unsafe.Pointer(unsafe.SliceData(x)),unsafe.Pointer(unsafe.SliceData(y)),unsafe.Pointer(&res),unsafe.Pointer(&length))
+ return res
+}
+`, name)
+		body := "MOVSD (DI),X0\nMOVSD (SI),X1\n" + op + " X0,X1\nMOVSD X1,(DX)"
+		machine := strings.Replace(x86CallerFixtureAssembly, "·kernel", "·"+name, 1)
+		machine = strings.Replace(machine, "MOVL AX,(DX)", body, 1)
+		assembly.WriteString(machine)
+		fmt.Fprintf(&tests, `
+ for _,a:=range values { for _,b:=range values {
+  x,y:=[]uint64{a,17},[]uint64{b,23}
+  got:=Call%[1]s(x[:1],y[:1]); want:=a &^ b
+  if got!=want || x[0]!=a || x[1]!=17 || y[0]!=b || y[1]!=23 { t.Fatalf("%[1]s(%%x,%%x)=%%x want %%x",a,b,got,want) }
+ } }
+`, name)
+		fmt.Fprintf(&oracle, "extern void %s(const void*,const void*,void*,const void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+	}
+	tests.WriteString("}\n")
+	oracle.WriteString(`int main(void) {
+ const uint64_t values[]={0,1,7,UINT64_C(0x0ff00ff0a55aa55a),UINT64_C(0x33cc55aa5aa5f00f),UINT64_C(1)<<63,UINT64_MAX};
+`)
+	for _, name := range []string{"andnps", "andnpd", "pandn"} {
+		fmt.Fprintf(&oracle, `
+ for(int i=0;i<7;++i) for(int j=0;j<7;++j) {
+  uint8_t a[18],b[18],out[18],before[18]; uint64_t length=1,got;
+  memset(a,0xa7,18); memset(b,0xb9,18); memset(out,0xc3,18); memcpy(before,out,18);
+  memcpy(a+1,values+i,8); memcpy(b+3,values+j,8);
+  %s(a+1,b+3,out+5,&length);
+  uint64_t want=values[i]&~values[j]; memcpy(&got,out+5,8); memcpy(before+5,&want,8);
+  if(got!=want || memcmp(before,out,18) || length!=1 || a[0]!=0xa7 || a[9]!=0xa7 || b[2]!=0xb9 || b[11]!=0xb9) return 1;
+ }
+`, name)
+	}
+	oracle.WriteString("return 0;\n}\n")
+	dir := t.TempDir()
+	for name, src := range map[string]string{"go.mod": "module caller\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(src), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go ANDNOT operand order: %v\n%s", err, output)
+	}
+	pkg := x86CallerRuntimePackage(t, declarations.String(), assembly.String())
+	llvmContext := llvm.NewContext()
+	defer llvmContext.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(llvmContext, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple, ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "logical_andnot_order", triple, translation.Module.String(), oracle.String(), prefix)
+}
diff --git a/amd64_go_caller_logical_test.go b/amd64_go_caller_logical_test.go
new file mode 100644
index 000000000..5d2e0f76a
--- /dev/null
+++ b/amd64_go_caller_logical_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerLogicalOriginalZeroLiterals(t *testing.T) {
+	for _, literal := range []struct{ name, word string }{
+		{"VXORPS", "0xc057f8c5"}, {"VPXOR", "0xc0eff9c5"},
+	} {
+		t.Run(literal.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "LONG $"+literal.word+"\nVMOVSS X0,(DX)", 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerLogicalCompleteFamilyInitializedForms(t *testing.T) {
+	for _, op := range x86LogicalOpcodeNames() {
+		spec := x86PackedLogicalSpecs[op]
+		for _, row := range x86LogicalAcceptedForms(op, "amd64") {
+			if strings.Contains(row, "M7") {
+				continue
+			} // No private MMX bank.
+			t.Run(row, func(t *testing.T) {
+				row = strings.NewReplacer("(AX)", "(DI)", "X15", "X2", "X31", "X2", "Y31", "Y2", "Z31", "Z2").Replace(row)
+				instruction := strings.Split(row, " ")[1]
+				operands := strings.Split(instruction, ",")
+				destination := operands[len(operands)-1]
+				index := destination[1:]
+				init := fmt.Sprintf("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z%s\nKMOVQ AX,K1\nKMOVQ AX,K7\n", index)
+				// Legacy destructive destinations must be initialized just as
+				// masked merge destinations; register spelling grants nothing.
+				if spec.encoding <= x86PackedLogicalLegacyInteger && destination == "X2" {
+					init += "VMOVUPS (SI),Z2\n"
+				}
+				body := init + row + "\nVMOVSS X" + index + ",(DX)"
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerLogicalRetainsUnknownSourceAndEnvelopeFailures(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown source":                  "VANDPS X0,X1,X2\nVMOVSS X2,(DX)",
+		"unknown destructive destination": "VMOVUPS (DI),X0\nANDPS X0,X1\nVMOVSS X1,(DX)",
+		"masked unknown merge":            "KMOVQ AX,K1\nVXORPS X0,X0,K1,X2\nVMOVSS X2,(DX)",
+		"unknown mask":                    "VXORPS.Z X0,X0,K1,X2\nVMOVSS X2,(DX)",
+		"mask from pointer":               "KMOVQ DI,K1\nVXORPS.Z X0,X0,K1,X2\nVMOVSS X2,(DX)",
+		"private stack":                   "VXORPS 0(SP),X0,X0\nVMOVSS X0,(DX)",
+		"unknown address":                 "VXORPS (BX),X0,X0\nVMOVSS X0,(DX)",
+		"FP pointer bits":                 "VXORPS a+0(FP),X0,X0\nVMOVSS X0,(DX)",
+		"length full vector":              "VMOVUPS (DI),X0\nVPAND (CX),X0,X0\nVMOVSS X0,(DX)",
+		"oversized broadcast":             "VMOVUPS (DI),X0\nVANDPD.BCST (DX),X0,X0\nVMOVSS X0,(DX)",
+		"source data write":               "VXORPS X0,X0,X0\nVMOVSS X0,(DI)",
+		"wide result":                     "VXORPS Y0,Y0,Y0\nVMOVUPS Y0,(DX)",
+		"CFG undefined join":              "CMPQ AX,$0\nJE joined\nVXORPS X0,X0,X0\njoined:\nVORPS X0,X0,X1\nVMOVSS X1,(DX)",
+		"legacy undefined other input":    "XORPS X0,X0\nVORPS Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"MMX zero cannot borrow Z0":       "PXOR M0,M0\nVMOVSS X0,(DX)",
+		"MMX memory bank":                 "PAND (DI),M0\nMOVQ M0,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved logical value/region passed: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerLogicalByteAvailabilityMatchesPhysicalEncoding(t *testing.T) {
+	for _, op := range x86LogicalOpcodeNames() {
+		spec := x86PackedLogicalSpecs[op]
+		for _, width := range []int{16, 32, 64} {
+			if spec.encoding <= x86PackedLogicalLegacyInteger && width != 16 || spec.encoding == x86PackedLogicalVEX && width == 64 {
+				continue
+			}
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, maskMode := range []string{"none", "merge", "zero"} {
+				if maskMode != "none" && spec.broadcastBytes == 0 {
+					continue
+				}
+				for _, zeroIdiom := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%d/%s/zero=%v", op, width, maskMode, zeroIdiom), func(t *testing.T) {
+						row := string(op) + " " + bank + "0," + bank + "1"
+						if zeroIdiom {
+							row = string(op) + " " + bank + "0," + bank + "0"
+						}
+						if spec.encoding > x86PackedLogicalLegacyInteger {
+							if maskMode != "none" {
+								row += ",K1"
+							}
+							row += "," + bank + "2"
+							if maskMode == "zero" {
+								row = strings.Replace(row, string(op), string(op)+".Z", 1)
+							}
+						}
+						file, err := Parse(ArchAMD64, "TEXT one(SB),$0-0\n"+row+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						form, _, err := x86PackedLogicalProperties(ins, "amd64")
+						if err != nil {
+							t.Fatal(err)
+						}
+						state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0x0f, "Z1": 0x07, "Z2": 0x05}, masks: map[Reg]bool{"K1": true}}
+						if !x86CallerPackedLogicalStep(&ins, form, &state, nil) {
+							t.Fatal("register effect rejected")
+						}
+						known := uint64(0x07)
+						if zeroIdiom {
+							known = 0x0f
+							if strings.Contains(string(op), "XOR") || strings.Contains(string(op), "ANDN") {
+								known = x86CallerVectorByteMask(int64(width))
+							}
+						}
+						dest := "Z2"
+						if form.legacy {
+							dest = "Z1"
+							if zeroIdiom {
+								dest = "Z0"
+							}
+						} else {
+							if maskMode == "merge" {
+								known &= 0x05
+							}
+							known |= ^x86CallerVectorByteMask(int64(width))
+						}
+						if state.vectors[Reg(dest)] != known {
+							t.Fatalf("defined bytes %#x want %#x", state.vectors[Reg(dest)], known)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerLogicalReadCertificatesRetainExactSource(t *testing.T) {
+	for _, row := range []string{"VPXOR (DI),X0,X1", "VANDPD.BCST (DI),Z0,K1,Z1"} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVUPS (SI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\n"+row+"\nVMOVSS X1,(DX)", 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, instruction := range normalized.Funcs[0].Instrs {
+			form, recognized, err := x86PackedLogicalProperties(instruction, "amd64")
+			if !recognized || err != nil || form.memory < 0 {
+				continue
+			}
+			index := form.memory
+			access, exists := instruction.x86CallerMemory[index]
+			if !exists || access.write || access.width != int64(form.memoryBytes) || !x86CallerMemoryCertified(instruction, index) {
+				t.Fatal("missing exact read certificate")
+			}
+			found = true
+			for _, change := range []string{"opcode", "suffix", "width", "mask", "address", "source", "direction", "address-size"} {
+				mutated := instruction
+				mutated.Args = append([]Operand(nil), instruction.Args...)
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+				switch change {
+				case "opcode":
+					mutated.Op = "VANDPS"
+				case "suffix":
+					mutated.Op = Op(string(mutated.Op) + ".Z")
+				case "width":
+					access.width++
+					mutated.x86CallerMemory[index] = access
+				case "mask":
+					if form.mask >= 0 {
+						mutated.Args[form.mask].Reg = "K2"
+					} else {
+						mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K2"})
+					}
+				case "address":
+					mutated.Args[index].Mem.Off++
+				case "source":
+					mutated.Args[1].Reg = "X4"
+				case "direction":
+					access.write = true
+					mutated.x86CallerMemory[index] = access
+				case "address-size":
+					mutated.x86AddressBits = 32
+				}
+				if x86CallerMemoryCertified(mutated, index) {
+					t.Fatalf("%s retained stale read certificate: %s", row, change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("logical source never acquired its independent actual read certificate")
+		}
+	}
+}
diff --git a/amd64_go_caller_low_multiply_test.go b/amd64_go_caller_low_multiply_test.go
new file mode 100644
index 000000000..3324f1303
--- /dev/null
+++ b/amd64_go_caller_low_multiply_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerLowMultiplyUnknownInputsRemainContext(t *testing.T) {
+	for _, name := range []string{"VPMULLD", "VPMULLQ"} {
+		for reason, body := range map[string]string{
+			"unknown first":          "VMOVUPS (DI),Z1\n%s Z0,Z1,Z2\nVMOVSS X2,(DX)",
+			"unknown second":         "VMOVUPS (DI),Z0\n%s Z0,Z1,Z2\nVMOVSS X2,(DX)",
+			"partial source":         "MOVSS (DI),X0\nVMOVUPS (SI),Z1\n%s Z0,Z1,Z2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+			"unknown mask":           "VMOVUPS (DI),Z0\n%s.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+			"unknown merge":          "VMOVUPS (DI),Z0\nMOVL $1,AX\nKMOVQ AX,K1\n%s Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+			"pointer mask":           "VMOVUPS (DI),Z0\nKMOVQ DI,K1\n%s.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+			"zero mask lacks region": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n%s.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+			"unknown address":        "VMOVUPS (DI),Z0\n%s (BX),Z0,Z2\nVMOVSS X2,(DX)",
+			"input write":            "VMOVUPS (DI),Z0\n%s Z0,Z0,Z2\nVMOVSS X2,(DI)",
+			"join missing second":    "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\n%s Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		} {
+			t.Run(name+"/"+reason, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", fmt.Sprintf(body, name), 1)
+				goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("low product acquired unproved input/caller memory", err)
+				}
+			})
+		}
+	}
+}
+
+// Keep this independent of the external package which exposed the missing
+// source-stack effect. The original Go caller owns every input/result region.
+func TestX86GoCallerLowMultiplyCompleteForms(t *testing.T) {
+	for _, name := range []string{"PMULLW", "VPMULLW", "PMULLD", "VPMULLD", "VPMULLQ"} {
+		banks := []string{"X"}
+		vector := strings.HasPrefix(name, "V")
+		if vector {
+			banks = append(banks, "Y", "Z")
+		}
+		for _, bank := range banks {
+			for _, memory := range []bool{false, true} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && (!memory || !vector || strings.HasSuffix(name, "W")) {
+						continue
+					}
+					for mode := 0; mode < 3; mode++ {
+						if !vector && mode != 0 {
+							continue
+						}
+						first, opcode := bank+"0", name
+						if memory {
+							first = "(DI)"
+						}
+						if broadcast {
+							opcode += ".BCST"
+						}
+						args, result := first+","+bank+"1", "X1"
+						if vector {
+							if mode != 0 {
+								args += ",K1"
+							}
+							if mode == 2 {
+								opcode += ".Z"
+							}
+							args += "," + bank + "2"
+							result = "X2"
+						}
+						row := opcode + " " + args
+						t.Run(row, func(t *testing.T) {
+							body := fmt.Sprintf("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n%s\nVMOVSS %s,(DX)", row, result)
+							assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+							goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+							pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+							for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+								if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+									t.Fatal(err)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_maddword.go b/amd64_go_caller_maddword.go
new file mode 100644
index 000000000..05cbbb55b
--- /dev/null
+++ b/amd64_go_caller_maddword.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+func x86CallerWordMultiplyAddStep(ins *Instr, form x86PackedMultiplyAddForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	if form.memory >= 0 {
+		// E4NF.nb retains the complete source read even for a zero mask. The
+		// native legacy bridge consumes this same actual pointer and opcode;
+		// the caller witness grants a read envelope, not alignment/no-fault.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	var known uint64
+	groupBytes := form.spec.outputBits / 8
+	for byteIndex := 0; byteIndex < form.byteWidth; byteIndex += groupBytes {
+		pair := (uint64(1)<<uint(groupBytes) - 1) << uint(byteIndex)
+		if first&pair == pair && second&pair == pair {
+			known |= pair
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_maddword_runtime_test.go b/amd64_go_caller_maddword_runtime_test.go
new file mode 100644
index 000000000..05e7908aa
--- /dev/null
+++ b/amd64_go_caller_maddword_runtime_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86WordMultiplyAddActualTypedCaller(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	checks.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for index, bank := range []string{"legacy", "X", "Y", "Z"} {
+		name := fmt.Sprintf("madd%d", index)
+		goSource := strings.ReplaceAll(x86CallerFixtureSource, "kernel", name)
+		goSource = strings.TrimPrefix(goSource, "package caller\nimport \"unsafe\"\n")
+		goSource = strings.Replace(goSource, "func Call(", "func Call"+name+"(", 1)
+		goSource = strings.Replace(goSource, ") float32 {", ") uint32 {", 1)
+		goSource = strings.Replace(goSource, "var res float32", "var res uint32", 1)
+		declarations.WriteString(goSource)
+		body := "MOVSS (DI),X0\nMOVSS (SI),X1\nPMADDWL X0,X1\nMOVSS X1,(DX)"
+		if bank != "legacy" {
+			body = "VMOVUPS (DI)," + bank + "0\nVMOVUPS (SI)," + bank + "1\nVPMADDWD " + bank + "0," + bank + "1," + bank + "2\nVMOVSS X2,(DX)"
+		}
+		machine := strings.Replace(x86CallerFixtureAssembly, "·kernel", "·"+name, 1)
+		machine = strings.Replace(machine, "MOVL AX,(DX)", body, 1)
+		assembly.WriteString(machine)
+		fmt.Fprintf(&checks, "extern void %s(const void*,const void*,void*,const void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+	}
+	goTests := `package caller
+import("testing";"unsafe")
+func TestOriginalSSEPair(t *testing.T) {
+ values:=[]uint32{0,1,0x80008000,0x7fff7fff,0xffff0001,0x1234abcd,0xfffe8000}
+ signed:=func(v uint32) int64 {x:=int64(v&65535);if x>=32768{x-=65536};return x}
+ for _,a:=range values {for _,b:=range values {
+  var x,y [16]float32
+  *(*uint32)(unsafe.Pointer(&x[0]))=a;*(*uint32)(unsafe.Pointer(&y[0]))=b
+  got:=Callmadd0(x[:],y[:]);want:=uint32(signed(a)*signed(b)+signed(a>>16)*signed(b>>16))
+  if got!=want || *(*uint32)(unsafe.Pointer(&x[0]))!=a || *(*uint32)(unsafe.Pointer(&y[0]))!=b {t.Fatalf("pair %x/%x got%x want%x",a,b,got,want)}
+ }}
+}
+`
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module caller\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": goTests} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original actual typed SSE caller: %v\n%s", err, output)
+	}
+	checks.WriteString(`
+static int64_t signedWord(uint32_t bits) {uint32_t v=bits&65535;return v<32768 ? (int64_t)v : (int64_t)v-65536;}
+int main(void) {
+ const uint32_t values[]={0,1,0x80008000,0x7fff7fff,0xffff0001,0x1234abcd,0xfffe8000};
+`)
+	for index := 0; index < 4; index++ {
+		fmt.Fprintf(&checks, `
+ for(int i=0;i<7;++i) for(int j=0;j<7;++j) {
+  uint8_t a[70],b[70],out[12],before[12];uint64_t length=16;uint32_t got;
+  memset(a,0xa7,sizeof(a));memset(b,0xb9,sizeof(b));memset(out,0xc3,sizeof(out));memcpy(before,out,sizeof(out));
+  memcpy(a+1,values+i,4);memcpy(b+3,values+j,4);
+  madd%d(a+1,b+3,out+5,&length);
+  uint32_t want=(uint32_t)(signedWord(values[i])*signedWord(values[j])+signedWord(values[i]>>16)*signedWord(values[j]>>16));
+  memcpy(&got,out+5,4);memcpy(before+5,&want,4);
+  if(got!=want || memcmp(before,out,sizeof(out)) || length!=16 || a[0]!=0xa7 || a[65]!=0xa7 || b[2]!=0xb9 || b[67]!=0xb9) return 1;
+ }
+`, index)
+	}
+	checks.WriteString("return 0;\n}\n")
+	pkg := x86CallerRuntimePackage(t, declarations.String(), assembly.String())
+	llvmContext := llvm.NewContext()
+	defer llvmContext.Dispose()
+	translation, err := translateGoModuleInContext(llvmContext, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		if translation != nil && !translation.Module.IsNil() {
+			translation.Module.Dispose()
+		}
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := translation.Module.String()
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "word-madd-actual-caller", triple, text, checks.String(), prefix)
+		})
+	}
+}
diff --git a/amd64_go_caller_maddword_test.go b/amd64_go_caller_maddword_test.go
new file mode 100644
index 000000000..29ae6ed7c
--- /dev/null
+++ b/amd64_go_caller_maddword_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerWordMultiplyAddOriginalRawEffect(t *testing.T) {
+	// This is the unchanged raw instruction from Weaviate's dot_byte_256.
+	// The independent fixture supplies actual typed, complete selected callers;
+	// it does not borrow the external function's unclosed pointer loop.
+	body := "VMOVDQU (DI),Y2\nVMOVDQU (SI),Y4\nLONG $0xd4f5edc5\nVMOVSS X2,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86GoCallerWordMultiplyAddOriginalFollowingAddEffect(t *testing.T) {
+	// Consecutive unchanged LONGs from dot_byte_avx256.s. Each arithmetic
+	// family now has its separate complete typed caller effect.
+	body := "VMOVDQU (DI),Y2\nVMOVDQU (SI),Y4\nVPXOR Y0,Y0,Y0\nLONG $0xd4f5edc5\nLONG $0xc0feedc5\nVMOVSS X0,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86GoCallerWordMultiplyAddCompleteActualSourceConsumers(t *testing.T) {
+	rows := []string{"PMADDWL X0,X1", "PMADDWL X1,X1", "PMADDWL (DI),X1"}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, first := range []string{bank + "0", "(DI)"} {
+			rows = append(rows,
+				"VPMADDWD "+first+","+bank+"1,"+bank+"2",
+				"VPMADDWD "+first+","+bank+"1,K1,"+bank+"2",
+				"VPMADDWD.Z "+first+","+bank+"1,K1,"+bank+"2")
+		}
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			result := "X2"
+			if strings.HasPrefix(row, "PMADDWL") {
+				result = "X1"
+			}
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatalf("actual typed caller %s: %v", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerWordMultiplyAddRetainsUnknownSourceFailures(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":       "VMOVUPS (DI),Y1\nVPMADDWD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":      "VMOVUPS (DI),Y0\nVPMADDWD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown upper pairs": "MOVSS (DI),X0\nMOVSS (SI),X1\nVPMADDWD Y0,Y1,Y2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":        "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVPMADDWD.Z Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":       "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\nVPMADDWD Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":        "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPMADDWD.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask full read": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPMADDWD.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":     "VMOVUPS (DI),Z0\nVPMADDWD (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"private stack":       "VMOVUPS (DI),Z0\nVPMADDWD (SP),Z0,Z2\nVMOVSS X2,(DX)",
+		"legacy SP alias":     "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPMADDWL (BX),X0\nVMOVSS X0,(DX)",
+		"legacy BP alias":     "VMOVUPS (DI),Z0\nMOVQ BP,BX\nPMADDWL (BX),X0\nVMOVSS X0,(DX)",
+		"input write":         "VMOVUPS (DI),Z0\nVPMADDWD Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"MMX separate bank":   "PMADDWL M0,M1\nVMOVSS X1,(DX)",
+		"undefined branch":    "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\nVPMADDWD Z0,Z1,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved packed multiply-add became caller permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerWordMultiplyAddMemoryCertificatesRetainExactFullRead(t *testing.T) {
+	for _, row := range []string{"PMADDWL (DI),X0", "VPMADDWD.Z (DI),Z0,K1,Z2", "PMADDUBSW (DI),X0", "VPMADDUBSW.Z (DI),Z0,K1,Z2"} {
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS X2,(DX)"
+		if strings.HasPrefix(row, "PMADD") {
+			body = strings.Replace(body, "VMOVSS X2", "VMOVSS X0", 1)
+		}
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, recognized, err := x86PackedMultiplyAddProperties(ins.Op, ins, "amd64")
+			if !recognized || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			index := form.memory
+			access, exists := ins.x86CallerMemory[index]
+			if !exists || access.write || access.width != int64(form.memoryBytes) || !x86CallerMemoryCertified(ins, index) {
+				t.Fatal("original legacy or zero-mask E4NF lost exact native full-read witness")
+			}
+			for _, change := range []string{"opcode", "width", "address", "destination", "direction", "mask", "address size"} {
+				mutated := ins
+				mutated.Args = append([]Operand(nil), ins.Args...)
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+				switch change {
+				case "opcode":
+					mutated.Op = "VPMADDUBSW"
+					if strings.Contains(row, "UBSW") {
+						mutated.Op = "VPMADDWD"
+					}
+				case "width":
+					access.width--
+					mutated.x86CallerMemory[index] = access
+				case "address":
+					mutated.Args[index].Mem.Off++
+				case "destination":
+					mutated.Args[form.destination].Reg = "X7"
+				case "direction":
+					access.write = true
+					mutated.x86CallerMemory[index] = access
+				case "mask":
+					if form.mask >= 0 {
+						mutated.Args[form.mask].Reg = "K7"
+					} else {
+						mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K1"})
+					}
+				case "address size":
+					mutated.x86AddressBits = 32
+				}
+				if x86CallerMemoryCertified(mutated, index) {
+					t.Fatalf("%s stale %s native read permission survived", row, change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("normalized source omitted actual multiply-add")
+		}
+	}
+}
diff --git a/amd64_go_caller_mask_vector_test.go b/amd64_go_caller_mask_vector_test.go
new file mode 100644
index 000000000..81b842ff7
--- /dev/null
+++ b/amd64_go_caller_mask_vector_test.go
@@ -0,0 +1,355 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The denominator comes from every original Go encoder row, not the caller
+// registry or the library which first exposed its missing effect registration.
+func x86OfficialMaskVectorRows(t *testing.T) []string {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	family := map[string]bool{
+		"VPMOVM2B": true, "VPMOVM2W": true, "VPMOVM2D": true, "VPMOVM2Q": true,
+		"VPMOVB2M": true, "VPMOVW2M": true, "VPMOVD2M": true, "VPMOVQ2M": true,
+	}
+	var rows []string
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if !family[rule.Opcode] {
+			continue
+		}
+		toVector := strings.HasPrefix(rule.Opcode, "VPMOVM2")
+		vectorIndex, maskIndex := 0, 1
+		if toVector {
+			vectorIndex, maskIndex = 1, 0
+		}
+		if len(rule.Classes) != 2 || rule.Classes[maskIndex] != "Yk" ||
+			rule.Prefix != "Pavx" || rule.ZCase != "Zevex_rm_v_r" ||
+			rule.ZOffset != 3 || rule.EncodingOffset != rule.RowIndex*3 || len(rule.OpBytes) != 9 {
+			t.Fatalf("unmodeled official mask/vector row: %+v", rule)
+		}
+		bank := map[string]string{"YxrEvex": "X", "YyrEvex": "Y", "Yzr": "Z"}[rule.Classes[vectorIndex]]
+		bits := map[string]string{"X": "128", "Y": "256", "Z": "512"}[bank]
+		w := "evexW0"
+		if strings.HasSuffix(rule.Opcode, "W") || strings.HasSuffix(rule.Opcode, "Q") ||
+			strings.Contains(rule.Opcode, "W2M") || strings.Contains(rule.Opcode, "Q2M") {
+			w = "evexW1"
+		}
+		terms := strings.Split(rule.OpBytes[rule.EncodingOffset], " | ")
+		opcode := "0x28"
+		if strings.Contains(rule.Opcode, "D") || strings.Contains(rule.Opcode, "Q") {
+			opcode = "0x38"
+		}
+		if !toVector {
+			opcode = map[string]string{"0x28": "0x29", "0x38": "0x39"}[opcode]
+		}
+		if bank == "" || !reflect.DeepEqual(terms, []string{"avxEscape", "evex" + bits, "evexF3", "evex0F38", w}) ||
+			rule.OpBytes[rule.EncodingOffset+1] != "0" || !strings.EqualFold(rule.OpBytes[rule.EncodingOffset+2], opcode) {
+			t.Fatalf("unmodeled encoding generation/attributes: %+v", rule)
+		}
+		operands := bank + "1,K1"
+		if toVector {
+			operands = "K1," + bank + "1"
+		}
+		rows = append(rows, rule.Opcode+" "+operands)
+		counts[rule.Opcode]++
+	}
+	for opcode := range family {
+		if counts[opcode] != 3 {
+			t.Fatalf("%s complete X/Y/Z denominator changed: %d", opcode, counts[opcode])
+		}
+	}
+	if len(rows) != 24 {
+		t.Fatalf("complete mask/vector Go-row denominator changed: %d", len(rows))
+	}
+	return rows
+}
+
+func TestX86GoCallerMaskVectorCompleteOfficialEffectRegistration(t *testing.T) {
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !x86CallerVectorMoveKnown(file.Funcs[0].Instrs[1]) {
+				t.Fatal("Go-accepted complete mask/vector row lacks its caller effect")
+			}
+		})
+	}
+}
+
+func TestX86GoCallerMaskVectorActualTypedSourceAndObjects(t *testing.T) {
+	for index, row := range x86OfficialMaskVectorRows(t) {
+		t.Run(fmt.Sprintf("%02d/%s", index, row), func(t *testing.T) {
+			body := "KMOVQ AX,K1\nVMOVUPS (DI),Z1\n" + row + "\n"
+			if strings.HasPrefix(row, "VPMOVM2") {
+				body += "VMOVSS X1,(DX)"
+			} else {
+				body += "KMOVQ K1,AX\nMOVL AX,(DX)"
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "mask-vector-text.ll", "mask-vector-text.o", ir)
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "mask-vector-module.ll", "mask-vector-module.o", module.String())
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal("actual selected typed caller/LLVM object failed", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskVectorGrammarKeepsModeAndDispatchBoundaries(t *testing.T) {
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if !strings.Contains(row, bank+"1") {
+				continue
+			}
+			for _, index := range []int{0, 7, 8, 31} {
+				spelling := strings.Replace(row, bank+"1", fmt.Sprint(bank, index), 1)
+				t.Run(spelling, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+spelling+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					for _, arch := range []string{"amd64", "386"} {
+						_, known, err := x86MaskVectorProperties(ins, arch)
+						if !known {
+							t.Fatal("recognized family fell through")
+						}
+						if arch == "386" && index >= 8 {
+							if bank == "Z" {
+								goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+spelling+"\nRET\n", "", false)
+								if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("Go-invalid mode32 Z bank became a physical binding")
+								}
+							} else {
+								goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+spelling+"\nRET\n", "", true)
+								if !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("unproved physical mode32 X/Y binding was accepted", err)
+								}
+							}
+						} else if err != nil {
+							t.Fatal("valid physical bank rejected", err)
+						}
+					}
+				})
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nVPMOVM2B K1,X1\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := file.Funcs[0].Instrs[1]
+	ins.Op = "vpmovm2b"
+	var output strings.Builder
+	ctx := amd64Ctx{b: &output, goarch: "amd64"}
+	if known, _, err := ctx.lowerMaskVectorMove("VPMOVM2B", ins); !known || err != nil {
+		t.Fatal("equivalent case-normalized opcode lost its existing dispatch", err)
+	}
+	output.Reset()
+	if known, _, err := ctx.lowerMaskVectorMove("VPMOVM2W", ins); !known || err == nil || output.Len() != 0 {
+		t.Fatal("contradictory dispatch emitted a different opcode", err)
+	}
+}
+
+func TestX86GoCallerMaskVectorInitializationAndUnaffectedState(t *testing.T) {
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		t.Run(row, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, recognized, err := x86MaskVectorProperties(ins, "amd64")
+			if !recognized || err != nil {
+				t.Fatal("shared grammar lost official row", err)
+			}
+			initial := x86SourceStackState{
+				bp: x86SourceStackAddress{original: true}, gOriginal: true, numericFlags: true,
+				callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}}, known: map[Reg]uint8{AX: 0xff},
+				vectors: map[Reg]uint64{"Z1": ^uint64(0), "Z31": 0x55},
+				masks:   map[Reg]bool{"K1": true, "K0": false, "K7": true},
+			}
+			state, want := x86CloneCallerState(initial), x86CloneCallerState(initial)
+			if form.spec.maskToVector {
+				want.vectors["Z1"] = ^uint64(0)
+			} else {
+				want.masks["K1"] = true
+			}
+			if !x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state, want) {
+				t.Fatalf("mask/vector effect changed unrelated state: got=%+v want=%+v", state, want)
+			}
+			for missing := 0; missing < form.byteWidth; missing++ {
+				state = x86CloneCallerState(initial)
+				if form.spec.maskToVector {
+					state.masks["K1"] = false
+				} else {
+					state.vectors["Z1"] &^= uint64(1) << uint(missing)
+				}
+				before := x86CloneCallerState(state)
+				required := form.spec.maskToVector || x86MaskVectorSignBytes(row, form.byteWidth)&(uint64(1)<<uint(missing)) != 0
+				if !required {
+					before.masks["K1"] = true
+				}
+				if x86CallerVectorMoveStep(&ins, &state, nil) == required || !reflect.DeepEqual(before, state) {
+					t.Fatalf("missing input %d acquired effect or mutated state", missing)
+				}
+			}
+			if form.spec.maskToVector {
+				state = x86CloneCallerState(initial)
+				state.vectors["Z1"] = 0
+				if !x86CallerVectorMoveStep(&ins, &state, nil) || state.vectors["Z1"] != ^uint64(0) {
+					t.Fatal("EVEX overwrite did not define low data and clear wider aliases")
+				}
+			} else {
+				state = x86CloneCallerState(initial)
+				state.vectors["Z1"] = x86CallerVectorByteMask(int64(form.byteWidth))
+				state.masks["K1"] = false
+				if !x86CallerVectorMoveStep(&ins, &state, nil) || !state.masks["K1"] {
+					t.Fatal("complete selected vector requires no unrelated upper aliases or old destination mask")
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerMaskVectorRejectsUninitializedActualSources(t *testing.T) {
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		t.Run(row, func(t *testing.T) {
+			var body string
+			if strings.HasPrefix(row, "VPMOVM2") {
+				body = row + "\nVMOVSS X1,(DX)"
+			} else {
+				body = row + "\nKMOVQ K1,AX\nMOVL AX,(DX)"
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown entry mask/vector acquired raw-return permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerMaskVectorK0IsInitializedDataNotWritemasking(t *testing.T) {
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		if !strings.HasPrefix(row, "VPMOVM2") {
+			continue
+		}
+		row = strings.ReplaceAll(row, "K1", "K0")
+		for _, initialized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/initialized=%t", row, initialized), func(t *testing.T) {
+				body := row + "\nVMOVSS X1,(DX)"
+				if initialized {
+					body = "KMOVQ AX,K0\n" + body
+				}
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+				if initialized && err != nil || !initialized && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("K0 acquired implicit all-one/zero value or lost defined data: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskVectorGrammarRejectsEverySiblingInvalidForm(t *testing.T) {
+	for _, opcode := range []string{
+		"VPMOVM2B", "VPMOVM2W", "VPMOVM2D", "VPMOVM2Q",
+		"VPMOVB2M", "VPMOVW2M", "VPMOVD2M", "VPMOVQ2M",
+	} {
+		toVector := strings.HasPrefix(opcode, "VPMOVM2")
+		args := []string{"K1,Z1", "K1,K2", "K1,0(AX)", "X1,Z1", "K8,Z1", "K1,Z32", "K1,K2,Z1", "K1"}
+		if !toVector {
+			args = []string{"Z1,K1", "K1,K2", "0(AX),K1", "Z1,X1", "Z1,K8", "Z32,K1", "Z1,K2,K1", "Z1"}
+		}
+		for index, operands := range args {
+			spelling := opcode + " " + operands
+			if index == 0 {
+				spelling = opcode + ".Z " + operands
+			}
+			t.Run(spelling, func(t *testing.T) {
+				for _, arch := range []string{"amd64", "386"} {
+					source := "TEXT f(SB),4,$0-0\n" + spelling + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						continue // Source parser rejection grants no supported form.
+					}
+					ins := file.Funcs[0].Instrs[1]
+					if _, known, err := x86MaskVectorProperties(ins, arch); !known || err == nil {
+						t.Fatal("invalid sibling form escaped the shared grammar", err)
+					}
+					if x86CallerVectorMoveKnown(ins) {
+						t.Fatal("Go-rejected sibling acquired a caller effect")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskVectorOfficialRowsThreeAPIsFiveTargets(t *testing.T) {
+	rows := x86OfficialMaskVectorRows(t)
+	var assembly strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&assembly, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", index, row)
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			file, sigs := x86UnboundVoidFormatSources(t, assembly.String(), target.arch, target.triple)
+			x86ScalarFormatObjectUnit(t, file, sigs, target.arch, target.triple, 0)
+			t.Log("24 unchanged unbound Go rows; three public Context controls and emitter-only objects; initialized programs have a separate owner")
+		})
+	}
+}
diff --git a/amd64_go_caller_mul_div_test.go b/amd64_go_caller_mul_div_test.go
new file mode 100644
index 000000000..d55b9fcf0
--- /dev/null
+++ b/amd64_go_caller_mul_div_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerFloatMulDivWholeFamilyByteEffects(t *testing.T) {
+	for _, row := range x86FloatMulDivFormats("amd64") {
+		if strings.Contains(row, "(AX)") {
+			continue
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86FloatMulDivProperties(ins, "amd64")
+		if !recognized || err != nil || !x86CallerVectorMoveKnown(ins) {
+			t.Fatalf("missing registered family effect %s: %v", row, err)
+		}
+		for _, missing := range []int{-1, form.first, form.second, form.destination, 4} {
+			state := x86SourceStackState{
+				vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)},
+				masks:   map[Reg]bool{"K1": true},
+			}
+			if missing >= 0 && missing < len(ins.Args) && ins.Args[missing].Kind == OpReg {
+				state.vectors[x86CallerVectorRoot(ins.Args[missing].Reg)] &^= 1
+			}
+			if missing == 4 {
+				state.masks["K1"] = false
+			}
+			before, masksBefore := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerVectorMoveStep(&ins, &state, nil)
+			want := missing == -1 || missing == form.destination && !form.legacy && (form.mask < 0 || form.zeroing) || missing == 4 && form.mask < 0
+			if accepted != want || !reflect.DeepEqual(state.masks, masksBefore) || !accepted && !reflect.DeepEqual(state.vectors, before) {
+				t.Fatalf("%s missing %d: %t want %t, invented numerical/mask evidence", row, missing, accepted, want)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerFloatMulDivCannotInventValuesOrPermissions(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown source":       "VMULPS X0,X1,X2\nVMOVSS X2,(DX)",
+		"division no identity": "VDIVPS X0,X0,X2\nVMOVSS X2,(DX)",
+		"unknown merge":        "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nKMOVQ AX,K1\nVMULPS X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"unknown mask":         "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVDIVPS.Z X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"pointer mask":         "VMOVUPS (DI),X0\nKMOVQ DI,K1\nVMULPS.Z X0,X0,K1,X2\nVMOVSS X2,(DX)",
+		"physical stack":       "VMOVUPS (DI),X0\nVMULPS (SP),X0,X2\nVMOVSS X2,(DX)",
+		"FP pointer":           "VMOVUPS (DI),X0\nVDIVPS a+0(FP),X0,X2\nVMOVSS X2,(DX)",
+		"unknown memory":       "VMOVUPS (DI),X0\nVMULPS (R11),X0,X2\nVMOVSS X2,(DX)",
+		"g read":               "VMOVUPS (DI),X0\nVDIVPS (R14),X0,X2\nVMOVSS X2,(DX)",
+		"wide result":          "VMOVUPS (DI),X0\nVMULPS X0,X0,X2\nVMOVUPS X2,(DX)",
+		"input write":          "VMOVUPS (DI),X0\nVDIVPS X0,X0,X2\nVMOVSS X2,(DI)",
+		"unknown CFG join":     "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),X0\njoined:\nVMULPS X0,X0,X2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved MUL/DIV source passed: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_packed_add.go b/amd64_go_caller_packed_add.go
new file mode 100644
index 000000000..c2d68c8cd
--- /dev/null
+++ b/amd64_go_caller_packed_add.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+func x86CallerPackedWrappingAddStep(ins *Instr, form x86PackedAddForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	return x86CallerPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, form.spec.laneBits, state, proof)
+}
+
+// Each complete input lane determines one output lane for wrapping or
+// saturating integer add/subtract or low-product multiplication. Form sharing
+// grants no address permission.
+func x86CallerPackedLaneArithmeticStep(ins *Instr, form x86PackedBinaryForm, bits int, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	if form.memory >= 0 {
+		// Source permission still requires the full original possible access
+		// envelope; an initialized K mask does not prove a smaller region.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	var known uint64
+	step := bits / 8
+	for index := 0; index < form.byteWidth; index += step {
+		lane := x86CallerVectorByteMask(int64(step)) << uint(index)
+		if first&lane == lane && second&lane == lane {
+			known |= lane
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_packed_add_runtime_test.go b/amd64_go_caller_packed_add_runtime_test.go
new file mode 100644
index 000000000..4f8b41678
--- /dev/null
+++ b/amd64_go_caller_packed_add_runtime_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedWrappingAddActualTypedCaller(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var goSource, assembly, declarations, checks strings.Builder
+	goSource.WriteString("package caller\nimport \"unsafe\"\n")
+	declarations.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	count := 0
+	for opcodeIndex, opcode := range x86WrappingAddOpcodes {
+		banks := []string{"X"}
+		if strings.HasPrefix(opcode, "V") {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			name := fmt.Sprintf("calleradd%d", count)
+			count++
+			declaration := x86CallerFixtureSource[strings.Index(x86CallerFixtureSource, "//go:noescape"):]
+			declaration = strings.ReplaceAll(declaration, "kernel", name)
+			declaration = strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1)
+			declaration = strings.Replace(declaration, ") float32 {", ") uint32 {", 1)
+			declaration = strings.Replace(declaration, "var res float32", "var res uint32", 1)
+			goSource.WriteString(declaration)
+			body := "MOVSS (DI),X0\nMOVSS (SI),X1\n" + opcode + " X0,X1\nMOVSS X1,(DX)"
+			if strings.HasPrefix(opcode, "V") {
+				body = "VMOVUPS (DI)," + bank + "0\nVMOVUPS (SI)," + bank + "1\n" + opcode + " " + bank + "0," + bank + "1," + bank + "2\nVMOVSS X2,(DX)"
+			}
+			machine := strings.Replace(x86CallerFixtureAssembly, "·kernel", "·"+name, 1)
+			assembly.WriteString(strings.Replace(machine, "MOVL AX,(DX)", body, 1))
+			fmt.Fprintf(&declarations, "extern void %s(const void*,const void*,void*,const void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+			fmt.Fprintf(&checks, `
+ for(int round=0;round<32;++round) {
+  uint8_t a[70],b[70],out[12],before[12];uint64_t length=16;
+  memset(a,0xa7,70);memset(b,0xb9,70);memset(out,0xc3,12);memcpy(before,out,12);
+  for(int i=0;i<64;++i){a[i+1]=(uint8_t)(i*17+round*31);b[i+3]=(uint8_t)(i*23+round*41);}
+  %[1]s(a+1,b+3,out+5,&length);
+  for(int i=0;i<4;i+=%[2]d) {
+   uint64_t sum=0,av=0,bv=0;int bytes=%[2]d;
+   if(bytes>4)bytes=4;
+   for(int j=0;j<bytes;++j){av|=(uint64_t)a[i+j+1]<<(8*j);bv|=(uint64_t)b[i+j+3]<<(8*j);}
+   sum=av+bv;for(int j=0;j<bytes;++j)before[i+j+5]=(uint8_t)(sum>>(8*j));
+  }
+  if(memcmp(out,before,12)||length!=16||a[0]!=0xa7||a[65]!=0xa7||b[2]!=0xb9||b[67]!=0xb9)return 1;
+ }
+`, name, 1<<uint(opcodeIndex%4))
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	pkg := x86CallerRuntimePackage(t, goSource.String(), assembly.String())
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if translation != nil && !translation.Module.IsNil() {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := declarations.String() + "int main(void){\n" + checks.String() + "return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := translation.Module.String()
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-add-typed-caller", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d actual complete typed original caller programs × 32 independent numerical/canary cases at O0/O2", count)
+}
diff --git a/amd64_go_caller_packed_add_test.go b/amd64_go_caller_packed_add_test.go
new file mode 100644
index 000000000..5d2e8af14
--- /dev/null
+++ b/amd64_go_caller_packed_add_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedAddOriginalConsecutiveRawEffects(t *testing.T) {
+	// The exact consecutive words in Weaviate dot_byte_avx256.s. Complete
+	// selected typed callers are independent of its still-unclosed pointer loop.
+	body := "VMOVDQU (DI),Y2\nVMOVDQU (SI),Y4\nVPXOR Y0,Y0,Y0\nLONG $0xd4f5edc5\nLONG $0xc0feedc5\nVMOVSS X0,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86GoCallerPackedAddCompleteOriginalTypedConsumers(t *testing.T) {
+	for _, opcode := range append(append([]string(nil), x86WrappingAddOpcodes...), "PADDD") {
+		banks := []string{"X"}
+		if strings.HasPrefix(opcode, "V") {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			for _, first := range []string{bank + "0", "(DI)"} {
+				for mode := 0; mode < 3; mode++ {
+					if !strings.HasPrefix(opcode, "V") && mode != 0 {
+						continue
+					}
+					row, result := opcode+" "+first+",X1", "X1"
+					if strings.HasPrefix(opcode, "V") {
+						row, result = opcode+" "+first+","+bank+"1", "X2"
+						if mode == 2 {
+							row = opcode + ".Z " + first + "," + bank + "1"
+						}
+						if mode != 0 {
+							row += ",K1"
+						}
+						row += "," + bank + "2"
+					}
+					t.Run(row, func(t *testing.T) {
+						body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+						assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+						requireX86GoAssemblerResult(t, "amd64", assembly, true)
+						pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+						for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+							if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+								t.Fatal(err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedAddEveryLaneByteKnowledge(t *testing.T) {
+	for _, opcode := range x86WrappingAddOpcodes {
+		for _, mode := range []string{"", "merge", "zero"} {
+			if !strings.HasPrefix(opcode, "V") && mode != "" {
+				continue
+			}
+			row := opcode + " X0,X1"
+			if strings.HasPrefix(opcode, "V") {
+				row = opcode + " Z0,Z1,Z2"
+				if mode != "" {
+					row = opcode + " Z0,Z1,K1,Z2"
+				}
+				if mode == "zero" {
+					row = strings.Replace(row, " ", ".Z ", 1)
+				}
+			}
+			file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			instruction := file.Funcs[0].Instrs[1]
+			form, _, err := x86PackedWrappingAddProperties(instruction, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			width := x86CallerVectorByteMask(int64(form.byteWidth))
+			step := form.spec.laneBits / 8
+			for operand := 0; operand < 2; operand++ {
+				for missing := -1; missing < form.byteWidth; missing++ {
+					vectors := map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}
+					if missing >= 0 {
+						root := x86CallerVectorRoot(instruction.Args[operand].Reg)
+						vectors[root] &^= uint64(1) << uint(missing)
+					}
+					state := &x86SourceStackState{vectors: vectors, masks: map[Reg]bool{"K1": true}}
+					if !x86CallerPackedWrappingAddStep(&instruction, form, state, nil) {
+						t.Fatal("register grammar rejected")
+					}
+					want := ^uint64(0)
+					if missing >= 0 {
+						want &^= x86CallerVectorByteMask(int64(step)) << uint(missing/step*step)
+					}
+					got := state.vectors[x86CallerVectorRoot(instruction.Args[form.destination].Reg)]
+					// Legacy preserves its old upper view, while each vector form
+					// defines it to zero. Both start fully known in this axis.
+					if got != want || got&^width != want&^width {
+						t.Fatalf("%s/%s missing%d input%d known=%x want=%x", opcode, mode, missing, operand, got, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedAddUnknownBoundariesRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":            "VMOVUPS (DI),Y1\nVPADDD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":           "VMOVUPS (DI),Y0\nVPADDQ Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown high byte":        "MOVSS (DI),X0\nMOVSS (SI),X1\nVPADDQ Y0,Y1,Y2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":             "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVPADDB.Z Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":            "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\nVPADDW Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":             "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPADDQ.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask no permission":  "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPADDD.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":          "VMOVUPS (DI),Z0\nVPADDB (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"private stack":            "VMOVUPS (DI),Z0\nVPADDW (SP),Z0,Z2\nVMOVSS X2,(DX)",
+		"legacy SP alias":          "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPADDL (BX),X0\nVMOVSS X0,(DX)",
+		"input store":              "VMOVUPS (DI),Z0\nVPADDQ Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"MMX":                      "PADDB M0,M1\nVMOVSS X1,(DX)",
+		"saturating separate":      "VMOVUPS (DI),Z0\nVPADDSW Z0,Z0,Z2\nVMOVSS X2,(DX)",
+		"unknown joined bank":      "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\nVPADDW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"different pointer offset": "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nADDQ $4,DI\njoined:\nVPADDD (DI),Z0,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s escaped actual source boundary: %v", name, err)
+			}
+		})
+	}
+	// Independent caller effect shape does not allow another opcode or a
+	// narrowed masked source to reuse a private instruction certificate.
+	for _, row := range []string{"PADDL (DI),X0", "VPADDQ.BCST.Z (DI),Z0,K1,Z2"} {
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS X0,(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86PackedWrappingAddProperties(ins, "amd64")
+			if !known || err != nil {
+				continue
+			}
+			access := ins.x86CallerMemory[form.memory]
+			if access.width != int64(form.memoryBytes) || access.write || !x86CallerMemoryCertified(ins, form.memory) {
+				t.Fatalf("missing full possible source extent for %s", row)
+			}
+			for _, mutation := range []string{"opcode", "width", "direction", "address"} {
+				changedAccess := access
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+				switch mutation {
+				case "opcode":
+					changed.Op = "VPSUBQ"
+				case "width":
+					changedAccess.width--
+					changed.x86CallerMemory[form.memory] = changedAccess
+				case "direction":
+					changedAccess.write = true
+					changed.x86CallerMemory[form.memory] = changedAccess
+				case "address":
+					changed.Args[form.memory].Mem.Off++
+				}
+				if x86CallerMemoryCertified(changed, form.memory) {
+					t.Fatal(fmt.Sprintf("%s stale %s witness", row, mutation))
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAddLegacyVirtualMemoryCannotForgeNativeAlignment(t *testing.T) {
+	for _, row := range []string{"PADDB source+0(FP),X0", "PADDW (SP),X0", "PADDL (BP),X0", "PADDQ source+0(FP),X0"} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-64\n" + row + "\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := x86WordMaddFPType(t)
+			_, err = Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": sig}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("virtual storage acquired physical aligned m128 permission: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_packed_moves_test.go b/amd64_go_caller_packed_moves_test.go
new file mode 100644
index 000000000..309f424c7
--- /dev/null
+++ b/amd64_go_caller_packed_moves_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedMovesPreserveNumericalInputBytes(t *testing.T) {
+	for _, form := range []struct{ name, body string }{
+		{"VEX input", "VMOVDQU (DI),Y0\nVMOVSS X0,(DX)"},
+		{"EVEX input", "VMOVDQU8 (DI),Z31\nVMOVSS X31,(DX)"},
+		{"EVEX zero mask", "KMOVQ AX,K1\nVMOVUPS.Z (DI),K1,Z0\nVMOVSS X0,(DX)"},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", form.body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPackedMovesCompleteFamilyRegisterCopies(t *testing.T) {
+	var opcodes []string
+	for opcode := range amd64PackedVectorMoveSpecs {
+		opcodes = append(opcodes, string(opcode))
+	}
+	sort.Strings(opcodes)
+	for _, opcode := range opcodes {
+		spec := amd64PackedVectorMoveSpecs[Op(opcode)]
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if bank == "Z" && spec.encoding == amd64PackedMoveVEX {
+				continue
+			}
+			for _, mode := range []string{"unmasked", "merge", "zero"} {
+				if mode != "unmasked" && spec.encoding == amd64PackedMoveVEX {
+					continue
+				}
+				body := fmt.Sprintf("VMOVDQU8 (DI),%s0\n", bank)
+				name, mask := opcode, ""
+				if mode != "unmasked" {
+					body += fmt.Sprintf("VMOVDQU8 (SI),%s1\nKMOVQ AX,K1\n", bank)
+					mask = "K1,"
+					if mode == "zero" {
+						name += ".Z"
+					}
+				}
+				body += fmt.Sprintf("%s %s0,%s%s1\nVMOVSS X1,(DX)", name, bank, mask, bank)
+				t.Run(opcode+"/"+bank+"/"+mode, func(t *testing.T) {
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					requireX86GoAssemblerResult(t, "amd64", assembly, true)
+					pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+					if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedMovesRetainUnknownAndBoundedMemoryFailures(t *testing.T) {
+	for _, example := range []struct{ name, body string }{
+		{"unknown source", "VMOVUPS X0,X1\nVMOVSS X1,(DX)"},
+		{"unknown mask", "VMOVUPS.Z (DI),K1,Z0\nVMOVSS X0,(DX)"},
+		{"pointer mask", "KMOVQ DI,K1\nVMOVUPS.Z (DI),K1,Z0\nVMOVSS X0,(DX)"},
+		{"unknown merge destination", "KMOVQ AX,K1\nVMOVUPS (DI),K1,Z0\nVMOVSS X0,(DX)"},
+		{"unknown source in zero mask", "KMOVQ AX,K1\nVMOVUPS.Z Z0,K1,Z1\nVMOVSS X1,(DX)"},
+		{"unknown base", "VMOVUPS (BX),Y0\nVMOVSS X0,(DX)"},
+		{"pointer argument bits", "VMOVUPS a+0(FP),X0\nVMOVSS X0,(DX)"},
+		{"saved BP bytes", "VMOVUPS 0(SP),X0\nVMOVSS X0,(DX)"},
+		{"unknown input alignment", "VMOVAPS (DI),X0\nVMOVSS X0,(DX)"},
+		{"unknown integer alignment", "VMOVDQA32 (DI),Y0\nVMOVSS X0,(DX)"},
+		{"input write", "VMOVUPS (DI),Y0\nVMOVUPS Y0,(SI)\nVMOVSS X0,(DX)"},
+		{"length read too wide", "VMOVUPS (CX),X0\nVMOVSS X0,(DX)"},
+		{"length write", "VMOVUPS (DI),X0\nVMOVUPS X0,(CX)\nVMOVSS X0,(DX)"},
+		{"wide fresh result", "VMOVUPS (DI),X0\nVMOVUPS X0,(DX)"},
+		{"masked wide fresh result", "KMOVQ AX,K1\nVMOVUPS (DI),X0\nVMOVUPS X0,K1,(DX)"},
+		{"invalid zero memory store", "KMOVQ AX,K1\nVMOVUPS (DI),X0\nVMOVUPS.Z X0,K1,(DX)"},
+		{"indexed fresh result", "VMOVUPS (DI),X0\nVMOVUPS X0,(DX)(AX*1)"},
+		{"SP escape", "MOVQ SP,BX\nVMOVUPS (BX),X0\nVMOVSS X0,(DX)"},
+		{"g carrier", "VMOVUPS (R14),X0\nVMOVSS X0,(DX)"},
+		{"different initialized bytes at join", "CMPQ AX,$0\nJE join\nVMOVUPS (DI),Z0\njoin:\nVMOVSS X0,(DX)"},
+	} {
+		t.Run(example.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", example.body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved packed move acquired continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86PackedMoveInvalidStoreCannotAcquireCallerMemoryCertificate(t *testing.T) {
+	for _, opcode := range x86PackedZeroStoreOpcodes {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			t.Run(opcode+"/"+bank, func(t *testing.T) {
+				instruction := fmt.Sprintf("%s.Z %s0,K1,(DX)", opcode, bank)
+				parsed, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := parsed.Funcs[0].Instrs[1]
+				state := x86SourceStackState{
+					vectors: map[Reg]uint64{"Z0": ^uint64(0)}, masks: map[Reg]bool{"K1": true},
+				}
+				if strings.Contains(opcode, "COMPRESS") {
+					form, known, err := x86PackedCompactProperties(ins.Op, ins, "amd64")
+					if !known || err != nil || !form.undefinedOpcode() {
+						t.Fatal("compact syntax lost its independent #UD effect", err)
+					}
+					if _, known, err := x86TypedCompactExpandByteEffect(ins.Op, ins, "amd64"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("#UD compact form acquired ordinary numerical effects", err)
+					}
+				} else {
+					form, known, err := amd64PackedVectorMoveProperties(ins, "amd64")
+					if !known || err != nil || !form.undefinedOpcode() {
+						t.Fatal("move syntax lost its independent #UD effect", err)
+					}
+					if x86CallerPackedVectorMoveStep(&ins, form, &state, nil) {
+						t.Fatal("#UD instruction acquired caller continuation")
+					}
+				}
+				if x86CallerVectorMoveKnown(ins) {
+					t.Fatal("#UD instruction acquired an ordinary move effect")
+				}
+				if _, _, valid := x86CallerMoveMemoryShape(ins, 2); valid {
+					t.Fatal("#UD instruction acquired a memory certificate shape")
+				}
+				if x86CallerVectorMoveStep(&ins, &state, nil) || x86CallerMemoryCertified(ins, 2) {
+					t.Fatal("#UD instruction acquired a caller memory certificate")
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerPackedMoveByteKnowledgeIncludesMaskAndZeroUpperViews(t *testing.T) {
+	for _, encoding := range []struct {
+		op    string
+		width int
+	}{
+		{"VMOVUPS", 16}, {"VMOVUPD", 32}, {"VMOVDQU8", 64},
+		{"VMOVDQU16", 16}, {"VMOVDQU32", 32}, {"VMOVDQU64", 64},
+	} {
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[encoding.width]
+		for _, sourceKnown := range []uint64{0, 0xf, 0xff, ^uint64(0)} {
+			for _, oldKnown := range []uint64{0, 0xff, ^uint64(0)} {
+				for _, mode := range []string{"", "merge", "zero"} {
+					name, mask := encoding.op, ""
+					if mode != "" {
+						mask = "K1,"
+						if mode == "zero" {
+							name += ".Z"
+						}
+					}
+					instruction := fmt.Sprintf("%s %s0,%s%s1", name, bank, mask, bank)
+					parsed, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := parsed.Funcs[0].Instrs[1]
+					form, recognized, err := amd64PackedVectorMoveProperties(ins, "amd64")
+					if !recognized || err != nil {
+						t.Fatalf("known transfer form: %v", err)
+					}
+					state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": sourceKnown, "Z1": oldKnown}, masks: map[Reg]bool{"K1": true}}
+					if !x86CallerPackedVectorMoveStep(&ins, form, &state, nil) {
+						t.Fatal("register-only effect unexpectedly requires a caller region")
+					}
+					var expected uint64
+					for index := 0; index < 64; index++ {
+						bit := uint64(1) << uint(index)
+						if index >= encoding.width || sourceKnown&bit != 0 && (mode != "merge" || oldKnown&bit != 0) {
+							expected |= bit
+						}
+					}
+					if state.vectors["Z1"] != expected || state.vectors["Z0"] != sourceKnown || !reflect.DeepEqual(state.masks, map[Reg]bool{"K1": true}) {
+						t.Fatalf("%s changed initialized-byte/mask state: %+v; want %x", instruction, state, expected)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_packed_narrow.go b/amd64_go_caller_packed_narrow.go
new file mode 100644
index 000000000..c4c3757fa
--- /dev/null
+++ b/amd64_go_caller_packed_narrow.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+func x86CallerPackedNarrowStep(ins *Instr, form x86PackedNarrowForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	if form.memory >= 0 {
+		// E4NF/.nb requires the complete tuple, even when every output mask
+		// bit is zero. The form supplies a width, never a pointer permission.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := x86PackedNarrowDefinedBytes(form, first, second, old)
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_packed_narrow_alias_test.go b/amd64_go_caller_packed_narrow_alias_test.go
new file mode 100644
index 000000000..180e03057
--- /dev/null
+++ b/amd64_go_caller_packed_narrow_alias_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedNarrowDestinationAliasesKeepOriginalInputs(t *testing.T) {
+	// Whole-source initialization isolates concatenation and alias ordering
+	// from the finer per-input-byte dependency test. Expected half masks are
+	// independent constants, repeated once for each 128-bit chunk.
+	for _, name := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		for bankIndex, bank := range []string{"X", "Y", "Z"} {
+			for _, mask := range []string{"", "merge", "zero"} {
+				for destination := 0; destination < 3; destination++ {
+					opcode, operands := name, bank+"0,"+bank+"1"
+					if mask != "" {
+						operands += ",K1"
+					}
+					if mask == "zero" {
+						opcode += ".Z"
+					}
+					operands += fmt.Sprintf(",%s%d", bank, destination)
+					row := opcode + " " + operands
+					t.Run(row, func(t *testing.T) {
+						goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+						file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						width := x86CallerVectorByteMask(int64(16 << bankIndex))
+						for _, sample := range []struct{ first, second, halves uint64 }{
+							{0, ^uint64(0), 0x00ff00ff00ff00ff},
+							{^uint64(0), 0, 0xff00ff00ff00ff00},
+							{^uint64(0), ^uint64(0), ^uint64(0)},
+							{0, 0, 0},
+						} {
+							ins := file.Funcs[0].Instrs[1]
+							state := &x86SourceStackState{
+								vectors: map[Reg]uint64{"Z0": sample.first, "Z1": sample.second, "Z2": 0xaaaaaaaaaaaaaaaa},
+								masks:   map[Reg]bool{"K1": true},
+							}
+							root := Reg(fmt.Sprintf("Z%d", destination))
+							old := state.vectors[root]
+							want := sample.halves & width
+							if mask == "merge" {
+								want &= old
+							}
+							want |= ^width
+							if !x86CallerVectorMoveStep(&ins, state, nil) || state.vectors[root] != want {
+								t.Fatalf("source/destination alias grant %s first=%x second=%x got=%x want=%x",
+									row, sample.first, sample.second, state.vectors[root], want)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedNarrowLegacyUpperBytesDoNotBecomeInitialized(t *testing.T) {
+	for _, name := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB"} {
+		row := name + " X0,X1"
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": 0xffff}}
+		ins := file.Funcs[0].Instrs[1]
+		if !x86CallerVectorMoveStep(&ins, state, nil) || state.vectors["Z1"] != 0xffff {
+			t.Fatal("legacy PACK borrowed VEX upper-zero initialization", row, state.vectors["Z1"])
+		}
+		// A following YMM use cannot inherit initialized upper bytes from
+		// the instruction's legal XMM-only grammar.
+		next := Instr{Op: "VPACKSSDW", Args: []Operand{
+			{Kind: OpReg, Reg: "Y1"}, {Kind: OpReg, Reg: "Y1"}, {Kind: OpReg, Reg: "Y2"},
+		}}
+		if !x86CallerVectorMoveStep(&next, state, nil) || state.vectors["Z2"]&0xffff0000 != 0 {
+			t.Fatal(strings.Join([]string{"legacy PACK initialized an unrelated YMM upper chunk", row}, ": "))
+		}
+	}
+}
diff --git a/amd64_go_caller_packed_narrow_permissions_test.go b/amd64_go_caller_packed_narrow_permissions_test.go
new file mode 100644
index 000000000..b665df192
--- /dev/null
+++ b/amd64_go_caller_packed_narrow_permissions_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedNarrowUnknownValuesAndRegionsRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown second":           "VMOVUPS (DI),Z0\nVPACKSSDW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"unknown first high half":  "VMOVUPS (SI),Z1\nVPACKSSDW X0,X1,X2\nVPSRLDQ $8,X2,X3\nVMOVSS X3,(DX)",
+		"partial second":           "MOVSS (DI),X3\nMOVSS X3,X1\nVMOVUPS (SI),Z0\nVPACKSSDW X0,X1,X2\nVMOVSS X2,(DX)",
+		"unknown mask":             "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVPACKUSWB.Z Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":            "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nMOVL $1,AX\nKMOVQ AX,K1\nVPACKSSWB Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":             "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPACKUSDW.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask full tuple":     "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPACKSSDW.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask broadcast span": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPACKUSDW.BCST.Z 1(DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":          "VMOVUPS (DI),Z0\nVPACKUSWB (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"stack alias":              "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPACKSSWB (BX),X0\nVMOVSS X0,(DX)",
+		"BP alias":                 "VMOVUPS (DI),Z0\nMOVQ BP,BX\nPACKUSWB (BX),X0\nVMOVSS X0,(DX)",
+		"input write":              "VMOVUPS (DI),Z0\nVPACKSSDW Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"MMX separate bank":        "PACKSSLW M0,M1\nVMOVSS X1,(DX)",
+		"join missing second":      "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\nVPACKSSDW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved PACK acquired caller permission", err)
+			}
+		})
+	}
+	// The first input contributes only the high half of each 128-bit chunk.
+	// Unknown unused bytes must not forbid this initialized low-half write.
+	body := "VMOVUPS (SI),Z1\nVPACKSSDW Z0,Z1,Z2\nVMOVSS X2,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal("independent initialized low half was lost", err)
+	}
+}
+
+func TestX86GoCallerPackedNarrowFullReadCertificateIdentity(t *testing.T) {
+	for _, name := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB",
+		"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		banks := []string{"X"}
+		if strings.HasPrefix(name, "V") {
+			banks = append(banks, "Y", "Z")
+		}
+		for index, bank := range banks {
+			broadcasts := []bool{false}
+			if name == "VPACKSSDW" || name == "VPACKUSDW" {
+				broadcasts = append(broadcasts, true)
+			}
+			for _, broadcast := range broadcasts {
+				row, result, width := name+" (DI),X0", "X0", int64(16<<index)
+				if strings.HasPrefix(name, "V") {
+					suffix := ".Z"
+					if broadcast {
+						suffix, width = ".BCST.Z", 4
+					}
+					row, result = name+suffix+" (DI),"+bank+"0,K1,"+bank+"2", "X2"
+				}
+				t.Run(row, func(t *testing.T) {
+					body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+					pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+					resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", ResolveSym: resolve, Sigs: sigs})
+					if err != nil {
+						t.Fatal(err)
+					}
+					found := false
+					for _, ins := range normalized.Funcs[0].Instrs {
+						form, known, err := x86PackedNarrowProperties(ins, "amd64")
+						if !known || err != nil || form.memory < 0 {
+							continue
+						}
+						found = true
+						access, present := ins.x86CallerMemory[form.memory]
+						if !present || access.width != width || access.write || !x86CallerMemoryCertified(ins, form.memory) {
+							t.Fatal("zero mask shrank the independent complete memory envelope", width)
+						}
+						for _, change := range []string{"op", "base", "offset", "width", "direction", "destination", "mask", "address size"} {
+							mutated := ins
+							mutated.Args = append([]Operand(nil), ins.Args...)
+							mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+							switch change {
+							case "op":
+								mutated.Op = "MOVOU"
+							case "base":
+								mutated.Args[form.memory].Mem.Base = BX
+							case "offset":
+								mutated.Args[form.memory].Mem.Off++
+							case "width":
+								changed := access
+								changed.width--
+								mutated.x86CallerMemory[form.memory] = changed
+							case "direction":
+								changed := access
+								changed.write = true
+								mutated.x86CallerMemory[form.memory] = changed
+							case "destination":
+								mutated.Args[form.destination].Reg = "X7"
+							case "mask":
+								if form.mask >= 0 {
+									mutated.Args[form.mask].Reg = "K7"
+								} else {
+									mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K7"})
+								}
+							case "address size":
+								mutated.x86AddressBits = 32
+							}
+							if x86CallerMemoryCertified(mutated, form.memory) {
+								t.Fatal(fmt.Sprintf("stale complete instruction certificate survived %s", change))
+							}
+						}
+					}
+					if !found {
+						t.Fatal("actual PACK memory proof absent")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_packed_narrow_test.go b/amd64_go_caller_packed_narrow_test.go
new file mode 100644
index 000000000..e739ee395
--- /dev/null
+++ b/amd64_go_caller_packed_narrow_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86NarrowCallerRows(t *testing.T) []string {
+	t.Helper()
+	rows := x86OfficialPackedNarrowRows(t, "amd64")
+	for _, name := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB"} {
+		rows = append(rows, name+" X0,X1", name+" (DI),X1")
+	}
+	if len(rows) != 98 {
+		t.Fatalf("independent current Go narrow denominator changed: %d", len(rows))
+	}
+	return rows
+}
+
+func TestX86GoCallerPackedNarrowRecognizesEveryOfficialVectorForm(t *testing.T) {
+	for _, row := range x86NarrowCallerRows(t) {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !x86CallerVectorMoveKnown(file.Funcs[0].Instrs[1]) {
+				t.Fatal("accepted complete narrow grammar has no caller consumer")
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPackedNarrowActualTypedCallerAndObjects(t *testing.T) {
+	for index, original := range x86NarrowCallerRows(t) {
+		t.Run(fmt.Sprintf("%d/%s", index, original), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+original+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			var args []string
+			for position, arg := range ins.Args {
+				if arg.Kind == OpReg && amd64VectorByteWidth(arg.Reg) != 0 {
+					// Rebind only the physical index; bank, memory, mask and
+					// opcode attributes remain the independent Go row shape.
+					arg.Reg = Reg(fmt.Sprintf("%c%d", arg.Reg[0], position))
+				}
+				if arg.Kind == OpMem {
+					arg.Mem.Base, arg.Mem.Index, arg.Mem.Sym = DI, "", ""
+					arg.Mem.Off, arg.Mem.Scale = 0, 0
+				}
+				args = append(args, arg.String())
+			}
+			row := string(ins.Op) + " " + strings.Join(args, ",")
+			result := "X" + fmt.Sprint(len(ins.Args)-1)
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nVMOVUPS (SI),Z3\n" +
+				"MOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal("actual typed caller/LLVM object consumer failed", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPackedNarrowIndependentPerOutputByteDependencies(t *testing.T) {
+	for _, name := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB",
+		"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		legacy := !strings.HasPrefix(name, "V")
+		banks := []string{"X", "Y", "Z"}
+		if legacy {
+			banks = banks[:1]
+		}
+		inputBytes := 2
+		if strings.HasSuffix(name, "DW") || name == "PACKSSLW" {
+			inputBytes = 4
+		}
+		for bankIndex, bank := range banks {
+			for _, mask := range []string{"", "merge", "zero"} {
+				if legacy && mask != "" {
+					continue
+				}
+				opcode, args := name, bank+"0,"+bank+"1"
+				if !legacy {
+					if mask != "" {
+						args += ",K1"
+					}
+					if mask == "zero" {
+						opcode += ".Z"
+					}
+					args += "," + bank + "2"
+				}
+				row := opcode + " " + args
+				t.Run(row, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					width := 16 << bankIndex
+					widthMask := x86CallerVectorByteMask(int64(width))
+					for _, first := range []uint64{0, 1, 3, 15, 0xffff, 0xff00ff00ff00ff00, ^uint64(0)} {
+						for _, second := range []uint64{0, 7, 0xffff, 0x5555555555555555, ^uint64(0)} {
+							old := uint64(0xaaaaaaaaaaaaaaaa)
+							destination := Reg("Z2")
+							if legacy {
+								destination, old = "Z1", second
+							}
+							state := &x86SourceStackState{
+								vectors: map[Reg]uint64{"Z0": first, "Z1": second, "Z2": old},
+								masks:   map[Reg]bool{"K1": true},
+							}
+							// Each 128-bit chunk contains second's narrowed
+							// low half, then first's narrowed high half. One
+							// missing input byte revokes its whole output lane.
+							var want uint64
+							for output := 0; output < width; output += inputBytes / 2 {
+								chunk, local := output/16*16, output%16
+								input, source := chunk+(local%8)/(inputBytes/2)*inputBytes, second
+								if local >= 8 {
+									source = first
+								}
+								needed := uint64(1<<uint(inputBytes)-1) << uint(input)
+								if source&needed == needed {
+									want |= uint64(1<<uint(inputBytes/2)-1) << uint(output)
+								}
+							}
+							if mask == "merge" {
+								want &= old
+							}
+							if legacy {
+								want |= old &^ widthMask
+							} else {
+								want |= ^widthMask
+							}
+							if !x86CallerVectorMoveStep(&ins, state, nil) {
+								t.Fatal("pure narrow byte consumer is unregistered")
+							}
+							if got := state.vectors[destination]; got != want {
+								t.Fatalf("dependency/alias grant %s first=%x second=%x got=%x want=%x", row, first, second, got, want)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_packed_runtime_test.go b/amd64_go_caller_packed_runtime_test.go
new file mode 100644
index 000000000..374c7ce95
--- /dev/null
+++ b/amd64_go_caller_packed_runtime_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedGoCallerNumericalResults(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 packed caller runtime oracle")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var goSource, assembly, declarations, checks strings.Builder
+	goSource.WriteString("package caller\nimport \"unsafe\"\n")
+	for _, specification := range []struct {
+		opcode   string
+		laneBits int
+		vex      bool
+		aligned  bool
+	}{
+		{"VMOVDQA", 8, true, true}, {"VMOVDQU", 8, true, false},
+		{"VMOVAPD", 64, false, true}, {"VMOVAPS", 32, false, true},
+		{"VMOVUPD", 64, false, false}, {"VMOVUPS", 32, false, false},
+		{"VMOVDQA32", 32, false, true}, {"VMOVDQA64", 64, false, true},
+		{"VMOVDQU8", 8, false, false}, {"VMOVDQU16", 16, false, false},
+		{"VMOVDQU32", 32, false, false}, {"VMOVDQU64", 64, false, false},
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if specification.vex && bank == "Z" {
+				continue
+			}
+			for _, mode := range []string{"unmasked", "merge", "zero", "loadmerge", "loadzero"} {
+				if specification.vex && mode != "unmasked" || specification.aligned && strings.HasPrefix(mode, "load") {
+					continue // Aligned memory has no caller-address alignment witness.
+				}
+				name := "packed" + specification.opcode + bank + mode
+				declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint32")
+				declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+				declaration = strings.ReplaceAll(declaration, "kernel", name)
+				declaration = strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1)
+				goSource.WriteString(declaration)
+
+				body := fmt.Sprintf("VMOVUPS (DI),%s0\nVMOVUPS (SI),%s1\n", bank, bank)
+				opcode, source, mask := specification.opcode, bank+"0", ""
+				if mode != "unmasked" {
+					body += "KMOVQ AX,K1\n"
+					mask = "K1,"
+				}
+				if strings.HasPrefix(mode, "load") {
+					source = "(DI)"
+				}
+				if strings.HasSuffix(mode, "zero") {
+					opcode += ".Z"
+				}
+				body += fmt.Sprintf("%s %s,%s%s1\nVMOVSS X1,(DX)", opcode, source, mask, bank)
+				machine := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+name)
+				machine = strings.Replace(machine, "MOVL $7,AX", "MOVQ (CX),AX", 1)
+				assembly.WriteString(strings.Replace(machine, "MOVL AX,(DX)", body, 1))
+				fmt.Fprintf(&declarations, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", name, name)
+				fmt.Fprintf(&checks, "    if (check(%s, %d, %t, %t)) return 1;\n", name, specification.laneBits/8, mode == "unmasked", strings.HasSuffix(mode, "zero"))
+			}
+		}
+	}
+	// This is original-Go assembly acceptance and actual typed caller metadata,
+	// not native AVX512 execution or a third-party whole-library runtime pass.
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	pkg := x86CallerRuntimePackage(t, goSource.String(), assembly.String())
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	oracle := `#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+` + declarations.String() + `
+static int check(void (*fn)(void*,void*,void*,void*), unsigned lane, bool unmasked, bool zero) {
+    for (uint64_t length = 64; length < 68; length++) {
+        uint8_t input[512], old[512], output[48], before[48];
+        for (unsigned i = 0; i < 512; i++) {
+            input[i] = (uint8_t)(i*7 + length*13);
+            old[i] = (uint8_t)(i*11 + length*17);
+        }
+        memset(output, 0xa5, sizeof(output));
+        memcpy(before, output, sizeof(output));
+        const uint64_t original_length = length;
+        fn(input, old, output+16, &length);
+        if (length != original_length) return 1;
+        for (unsigned i = 0; i < sizeof(output); i++) {
+            uint8_t want = before[i];
+            if (i >= 16 && i < 20) {
+                const unsigned byte = i-16;
+                const bool active = unmasked || ((length >> (byte/lane)) & 1);
+                want = active ? input[byte] : zero ? 0 : old[byte];
+            }
+            if (output[i] != want) return 2;
+        }
+        for (unsigned i = 0; i < 512; i++) {
+            if (input[i] != (uint8_t)(i*7 + length*13) ||
+                old[i] != (uint8_t)(i*11 + length*17)) return 3;
+        }
+    }
+    return 0;
+}
+
+int main(void) {
+` + checks.String() + "    return 0;\n}\n"
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-caller-numerical", triple, translation.Module.String(), oracle, runner)
+}
diff --git a/amd64_go_caller_packed_shift.go b/amd64_go_caller_packed_shift.go
new file mode 100644
index 000000000..86bb33928
--- /dev/null
+++ b/amd64_go_caller_packed_shift.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+// Availability is separate from encoding. No count, mask, or zero-valued
+// shadow register is evidence that an incoming vector contains numeric data.
+func x86CallerPackedShiftStep(ins *Instr, form x86PackedShiftForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	if form.memory >= 0 {
+		// Legacy XMM uniform count loads still need an independently bound
+		// native-address/fault contract. A slice identity alone does not
+		// establish it; the original opcode, not MOVDQA, governs faults.
+		if form.legacy || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	data := width
+	if form.data != form.memory {
+		data = state.vectors[x86CallerVectorRoot(ins.Args[form.data].Reg)] & width
+	}
+	if data != width {
+		return false
+	}
+	counts := ^uint64(0)
+	if ins.Args[form.count].Kind != OpImm && form.count != form.memory {
+		countWidth := int64(form.byteWidth)
+		if form.countMode == x86PackedShiftUniform {
+			countWidth = 8 // The native register's upper count qword is ignored.
+		}
+		needed := x86CallerVectorByteMask(countWidth)
+		counts = state.vectors[x86CallerVectorRoot(ins.Args[form.count].Reg)]
+		if counts&needed != needed {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	// The caller-entry contract deliberately retains its complete input
+	// requirements above. Sharing numerical dependencies does not relax them.
+	known := x86PackedShiftDefinedBytes(form, data, counts, old)
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_packed_shift_test.go b/amd64_go_caller_packed_shift_test.go
new file mode 100644
index 000000000..73284a23e
--- /dev/null
+++ b/amd64_go_caller_packed_shift_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86GoCallerPackedShiftWeaviateOriginalBytes(t *testing.T) {
+	// Original dot_byte_avx256.s uses c5 ed 71 d1 08 at its first
+	// VPSRLW. Keep the complete encoded instruction, not a named surrogate.
+	body := "VMOVDQU (DI),Y1\nLONG $0xd171edc5\nBYTE $0x08\nVMOVSS X2,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, bound := range []bool{true, false} {
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if !bound {
+				pkg.SourceSelection = nil
+			}
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+			ir, err := Translate(file, options)
+			if bound {
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, findLLVM22Tool("llc"), triple, "original.ll", "original.o", ir)
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("uncontracted Translate: %v", err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if bound && err != nil || !bound && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("bound=%t module: %v", bound, err)
+			}
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); bound && err != nil || !bound && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("bound=%t GoModule: %v", bound, err)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedShiftWholeFamilyEffects(t *testing.T) {
+	for _, op := range x86PackedShiftNames() {
+		for _, row := range x86PackedShiftRows(op, "amd64") {
+			if strings.Contains(row, "(AX)") || strings.Contains(row, "M0") || strings.Contains(row, "M1") {
+				continue
+			}
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, recognized, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+			if !recognized || err != nil || !x86CallerVectorMoveKnown(ins) {
+				t.Fatalf("missing effect %s: %v", row, err)
+			}
+			width := x86CallerVectorByteMask(int64(form.byteWidth))
+			for _, missing := range []string{"none", "data", "count", "mask"} {
+				state := x86SourceStackState{
+					vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": 0},
+					masks:   map[Reg]bool{"K1": true, "K7": true},
+				}
+				applicable := true
+				switch missing {
+				case "data":
+					state.vectors[x86CallerVectorRoot(ins.Args[form.data].Reg)] &^= uint64(1) << uint(form.byteWidth-1)
+				case "count":
+					applicable = ins.Args[form.count].Kind != OpImm
+					if applicable {
+						state.vectors[x86CallerVectorRoot(ins.Args[form.count].Reg)] &^= 1
+					}
+				case "mask":
+					applicable = form.mask >= 0
+					if applicable {
+						delete(state.masks, ins.Args[form.mask].Reg)
+					}
+				}
+				if !applicable {
+					continue
+				}
+				before, _ := x86CloneCallerVectorState(state.vectors, state.masks)
+				accepted := x86CallerPackedShiftStep(&ins, form, &state, nil)
+				if accepted != (missing == "none") || !accepted && !reflect.DeepEqual(before, state.vectors) {
+					t.Fatalf("%s missing %s accepted=%t", row, missing, accepted)
+				}
+				if accepted {
+					want := ^uint64(0)
+					if form.mask >= 0 && !form.zeroing {
+						want = ^width
+					}
+					if got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]; got != want {
+						t.Fatalf("%s known=%x want %x", row, got, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedShiftMemoryShapesAndTargets(t *testing.T) {
+	for _, op := range x86PackedShiftNames() {
+		for _, row := range x86PackedShiftRows(op, "amd64") {
+			if strings.Contains(row, "M0") || strings.Contains(row, "M1") {
+				continue
+			}
+			row = strings.ReplaceAll(row, "(AX)", "(DI)")
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, _, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if form.memory >= 0 {
+				width, write, valid := x86CallerMoveMemoryShape(ins, form.memory)
+				if !valid || write || int(width) != form.memoryBytes {
+					t.Fatalf("incorrect read envelope %s: %d/%t/%t", row, width, write, valid)
+				}
+			}
+			body := fmt.Sprintf("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVQ $-1,AX\nKMOVQ AX,K1\nKMOVQ AX,K7\n%s\nVMOVSS X2,(DX)", row)
+			if form.legacy {
+				body = strings.Replace(body, "VMOVSS X2,(DX)", "VMOVSS X1,(DX)", 1)
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			// Compile one bounded corpus per target below; individual forms here
+			// also exercise the actual caller transport, not a public Ptr noalias.
+			err = x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if form.legacy && form.memory >= 0 {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved legacy native-memory contract passed %s: %v", row, err)
+				}
+			} else if err != nil {
+				t.Fatalf("%s: %v", row, err)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedShiftUnprovedInputsRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown data":              "VPSRLW $8,Y1,Y2\nVMOVSS X2,(DX)",
+		"zero count unknown data":   "VPSRLW $0,Y1,Y2\nVMOVSS X2,(DX)",
+		"saturated unknown data":    "VPSRLW $255,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown count":             "VMOVUPS (DI),Y1\nVPSRLW X0,Y1,Y2\nVMOVSS X2,(DX)",
+		"partial count":             "MOVL $1,AX\nMOVD AX,X0\nVMOVUPS (DI),Y1\nVPSRLVW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown mask":              "VMOVUPS (DI),Y1\nVPSRLW.Z $8,Y1,K1,Y2\nVMOVSS X2,(DX)",
+		"merge unknown destination": "VMOVUPS (DI),Y1\nMOVL $1,AX\nKMOVW AX,K1\nVPSRLW $8,Y1,K1,Y2\nVMOVSS X2,(DX)",
+		"physical SP":               "VMOVUPS (DI),Y1\nVPSRLW 0(SP),Y1,Y2\nVMOVSS X2,(DX)",
+		"FP pointer bytes":          "VMOVUPS (DI),Y1\nVPSRLW a+0(FP),Y1,Y2\nVMOVSS X2,(DX)",
+		"g":                         "VMOVUPS (DI),Y1\nVPSRLW (R14),Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown base":              "VMOVUPS (DI),Y1\nVPSRLW (BX),Y1,Y2\nVMOVSS X2,(DX)",
+		"length m128":               "VMOVUPS (DI),Y1\nVPSRLW (CX),Y1,Y2\nVMOVSS X2,(DX)",
+		"partial output":            "VMOVUPS (DI),Y1\nVPSRLW $8,Y1,Y2\nVMOVUPS Y2,(DX)",
+		"input write":               "VMOVUPS (DI),Y1\nVPSRLW $8,Y1,Y2\nVMOVSS X2,(DI)",
+		"branch join":               "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),Y1\njoined:\nVPSRLW $8,Y1,Y2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved source accepted: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_packed_subtract_test.go b/amd64_go_caller_packed_subtract_test.go
new file mode 100644
index 000000000..f8315051f
--- /dev/null
+++ b/amd64_go_caller_packed_subtract_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These rows come from cmd/internal/obj/x86's yxm and _yvandnpd tables.
+// Saturation changes arithmetic, not the operand availability obligation.
+func x86PackedSubtractCallerRows() []string {
+	var rows []string
+	for _, opcode := range []string{
+		"PSUBB", "PSUBW", "PSUBL", "PSUBQ",
+		"PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW",
+	} {
+		rows = append(rows, opcode+" X0,X15", opcode+" (DI),X15")
+	}
+	for _, opcode := range []string{
+		"VPSUBB", "VPSUBW", "VPSUBD", "VPSUBQ",
+		"VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW",
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			rows = append(rows,
+				fmt.Sprintf("%s %s0,%s1,%s2", opcode, bank, bank, bank),
+				fmt.Sprintf("%s (DI),%s1,%s2", opcode, bank, bank),
+				fmt.Sprintf("%s %s20,%s21,%s22", opcode, bank, bank, bank),
+			)
+			for _, suffix := range []string{"", ".Z"} {
+				rows = append(rows,
+					fmt.Sprintf("%s%s %s20,%s21,K1,%s22", opcode, suffix, bank, bank, bank),
+					fmt.Sprintf("%s%s (DI),%s21,K1,%s22", opcode, suffix, bank, bank),
+				)
+			}
+			if opcode == "VPSUBD" || opcode == "VPSUBQ" {
+				rows = append(rows,
+					fmt.Sprintf("%s.BCST (DI),%s21,%s22", opcode, bank, bank),
+					fmt.Sprintf("%s.BCST (DI),%s21,K1,%s22", opcode, bank, bank),
+					fmt.Sprintf("%s.BCST.Z (DI),%s21,K1,%s22", opcode, bank, bank),
+				)
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86GoCallerPackedSubtractCompleteOriginalTypedConsumers(t *testing.T) {
+	rows := x86PackedSubtractCallerRows()
+	if len(rows) != 202 {
+		t.Fatalf("complete Go subtract surface changed: %d rows", len(rows))
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			operands := strings.Split(strings.Fields(row)[1], ",")
+			destination := operands[len(operands)-1]
+			result := "X" + destination[1:]
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\n" +
+				"VMOVUPS (SI),Z15\nVMOVUPS (DI),Z20\nVMOVUPS (SI),Z21\n" +
+				"VMOVUPS (DI),Z22\nMOVL $1,AX\nKMOVQ AX,K1\n" +
+				row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{
+				"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+			} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedSubtractMaskedLoadsRetainActiveLaneEffects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, opcode := range []string{
+		"VPSUBB", "VPSUBW", "VPSUBD", "VPSUBQ",
+		"VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW",
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, suffix := range []string{".Z", ".BCST.Z"} {
+				if suffix == ".BCST.Z" && opcode != "VPSUBD" && opcode != "VPSUBQ" {
+					continue
+				}
+				row := fmt.Sprintf("%s%s (AX),%s1,K1,%s2", opcode, suffix, bank, bank)
+				t.Run(row, func(t *testing.T) {
+					assembly := "TEXT maskedsubtract(SB),4,$0-0\n" + row + "\nRET\n"
+					ir := x86UnboundVoidScalarFormatObject(t, assembly, "maskedsubtract", "amd64", "x86_64-unknown-linux-gnu")
+					if !strings.Contains(ir, "load volatile") || !strings.Contains(ir, "br i1") {
+						t.Fatal("masked source needs conditional volatile active-lane reads, not an unconditional vector load")
+					}
+					compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "masked-subtract.ll", "masked-subtract.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedSubtractEveryLaneByteKnowledge(t *testing.T) {
+	for _, row := range x86PackedSubtractCallerRows() {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		form, _, err := x86PackedSubtractProperties(instruction, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if form.memory >= 0 {
+			continue // Actual source extents are covered by the typed consumers.
+		}
+		for operand := 0; operand < 2; operand++ {
+			for missing := -1; missing < form.byteWidth; missing++ {
+				vectors := make(map[Reg]uint64)
+				for _, arg := range instruction.Args {
+					if amd64VectorByteWidth(arg.Reg) != 0 {
+						vectors[x86CallerVectorRoot(arg.Reg)] = ^uint64(0)
+					}
+				}
+				if missing >= 0 {
+					vectors[x86CallerVectorRoot(instruction.Args[operand].Reg)] &^= uint64(1) << uint(missing)
+				}
+				state := &x86SourceStackState{vectors: vectors, masks: map[Reg]bool{"K1": true}}
+				if !x86CallerVectorMoveStep(&instruction, state, nil) {
+					t.Fatalf("registered subtract shape rejected: %s", row)
+				}
+				want := ^uint64(0)
+				if missing >= 0 {
+					bytes := form.laneBits / 8
+					want &^= x86CallerVectorByteMask(int64(bytes)) << uint(missing/bytes*bytes)
+				}
+				got := state.vectors[x86CallerVectorRoot(instruction.Args[form.destination].Reg)]
+				if got != want {
+					t.Fatalf("%s missing byte%d input%d: known=%x want=%x", row, missing, operand, got, want)
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedSubtractUnknownBoundariesRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":            "VMOVUPS (DI),Y1\nVPSUBD Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":           "VMOVUPS (DI),Y0\nVPSUBQ Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown high byte":        "MOVSS (DI),X0\nMOVSS (SI),X1\nVPSUBQ Y0,Y1,Y2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":             "VMOVUPS (DI),Z0\nVPSUBSB.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":            "VMOVUPS (DI),Z0\nMOVL $1,AX\nKMOVQ AX,K1\nVPSUBSW Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":             "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPSUBUSB.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask no permission":  "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPSUBUSW.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":          "VMOVUPS (DI),Z0\nVPSUBB (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"private stack":            "VMOVUPS (DI),Z0\nVPSUBW (SP),Z0,Z2\nVMOVSS X2,(DX)",
+		"legacy SP alias":          "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPSUBL (BX),X0\nVMOVSS X0,(DX)",
+		"input store":              "VMOVUPS (DI),Z0\nVPSUBQ Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"unknown joined bank":      "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\nVPSUBW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"different pointer offset": "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nADDQ $4,DI\njoined:\nVPSUBD (DI),Z0,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved source boundary accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86PackedSubtractLegacyVirtualMemoryCannotForgeNativeAlignment(t *testing.T) {
+	for _, opcode := range []string{
+		"PSUBB", "PSUBW", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW",
+	} {
+		for _, source := range []string{"source+0(FP)", "(SP)", "(BP)"} {
+			row := opcode + " " + source + ",X0"
+			t.Run(row, func(t *testing.T) {
+				assembly := "TEXT f(SB),4,$0-64\n" + row + "\nRET\n"
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{
+					Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"f": x86WordMaddFPType(t)},
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("virtual storage acquired native alignment permission: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerPackedSubtractMemoryWitnessBindsExactInstruction(t *testing.T) {
+	for _, row := range []string{"PSUBL (DI),X0", "VPSUBQ.BCST.Z (DI),Z0,K1,Z2"} {
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS X0,(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{
+			Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs,
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86PackedSubtractProperties(ins, "amd64")
+			if !known || err != nil {
+				continue
+			}
+			found = true
+			access := ins.x86CallerMemory[form.memory]
+			if access.width != int64(form.memoryBytes) || access.write || !x86CallerMemoryCertified(ins, form.memory) {
+				t.Fatalf("missing complete possible source extent for %s", row)
+			}
+			for _, mutation := range []string{"opcode", "width", "direction", "address"} {
+				changedAccess := access
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+				switch mutation {
+				case "opcode":
+					changed.Op = "PSUBQ"
+					if form.broadcast {
+						changed.Op = "VPSUBQ.BCST"
+					}
+				case "width":
+					changedAccess.width--
+					changed.x86CallerMemory[form.memory] = changedAccess
+				case "direction":
+					changedAccess.write = true
+					changed.x86CallerMemory[form.memory] = changedAccess
+				case "address":
+					changed.Args[form.memory].Mem.Off++
+				}
+				if x86CallerMemoryCertified(changed, form.memory) {
+					t.Fatalf("%s reused a stale %s witness", row, mutation)
+				}
+			}
+		}
+		if !found {
+			t.Fatalf("source subtract disappeared from normalization: %s", row)
+		}
+	}
+}
diff --git a/amd64_go_caller_region_core.go b/amd64_go_caller_region_core.go
new file mode 100644
index 000000000..a0e93abe0
--- /dev/null
+++ b/amd64_go_caller_region_core.go
@@ -0,0 +1,418 @@
+package plan9asm
+
+import "reflect"
+
+// A pointer is never recovered from arbitrary integer data. The region and
+// affine offset survive only exact full-register copies/address arithmetic.
+type x86CallerPointerValue struct {
+	argument int
+	offset   int64
+	span     int64
+}
+
+// Instruction-local access, not a function-wide memory exemption. The final
+// guard compares the complete operands, effect direction and native width.
+type x86CallerMemoryAccess struct {
+	op    Op
+	args  []Operand
+	width int64
+	write bool
+}
+
+func x86CallerSignatureMatches(sig FuncSig, proof *x86GoCallerRegionProof) bool {
+	if proof == nil || proof.calls == 0 || proof.symbol != sig.Name || len(proof.arguments) != len(sig.Args) {
+		return false
+	}
+	sig.x86CallerRegions = nil
+	return reflect.DeepEqual(sig, proof.signature)
+}
+
+func x86CallerRegionSourceMatches(sig FuncSig, source Func, arch string) bool {
+	if arch != "amd64" || !x86CallerSignatureMatches(sig, sig.x86CallerRegions) {
+		return false
+	}
+	fingerprint, err := x86CallerSourceFingerprint(source)
+	if err != nil {
+		return false
+	}
+	if fingerprint == sig.x86CallerRegions.source {
+		return true
+	}
+	// Module/text lowering normalize more than once. Only the exact result of
+	// an earlier complete proof may be re-proved; edited public operands cannot
+	// inherit its private metadata or the original source fingerprint.
+	previous := source.x86SourceStack
+	return previous != nil && previous.caller == sig.x86CallerRegions && fingerprint == previous.normalized
+}
+
+func x86CallerNormalizedSourceMatches(fn Func, sig FuncSig) bool {
+	proof := fn.x86SourceStack
+	if proof == nil || proof.caller == nil || proof.caller != sig.x86CallerRegions || !x86CallerSignatureMatches(sig, proof.caller) {
+		return false
+	}
+	fingerprint, err := x86CallerSourceFingerprint(fn)
+	return err == nil && fingerprint == proof.normalized
+}
+
+func x86CallerGP(reg Reg) (Reg, bool) {
+	// This class includes R14, not numerical knowledge of incoming g. The
+	// complete source-stack proof separately requires its opaque identity at
+	// every return; only actual source definitions add numerical/pointer bits.
+	root, valid := amd64FullRegBase(reg)
+	if !valid {
+		return "", false
+	}
+	switch root {
+	case AX, BX, CX, DX, DI, SI, SP, BP, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+		return root, true
+	default:
+		return "", false
+	}
+}
+
+func x86CallerScalarOperands(ins Instr) bool {
+	for _, operand := range ins.Args {
+		if operand.Kind == OpImm && (operand.ImmIsFloat || operand.ImmRaw != "") {
+			return false
+		}
+		if operand.Kind == OpReg {
+			if _, valid := x86CallerGP(operand.Reg); !valid {
+				return false
+			}
+		}
+		if operand.Kind == OpMem {
+			for _, reg := range []Reg{operand.Mem.Base, operand.Mem.Index} {
+				if reg != "" && reg != PC {
+					if _, valid := x86CallerGP(reg); !valid {
+						return false
+					}
+				}
+			}
+		}
+	}
+	return true
+}
+
+func x86CloneCallerPointers(source map[Reg]x86CallerPointerValue) map[Reg]x86CallerPointerValue {
+	copy := make(map[Reg]x86CallerPointerValue, len(source))
+	for reg, value := range source {
+		copy[reg] = value
+	}
+	return copy
+}
+
+func x86CloneCallerKnown(source map[Reg]uint8) map[Reg]uint8 {
+	copy := make(map[Reg]uint8, len(source))
+	for reg, value := range source {
+		copy[reg] = value
+	}
+	return copy
+}
+
+func x86CallerByteMask(reg Reg, width int64) uint8 {
+	if width < 1 || width > 8 {
+		return 0
+	}
+	shift := uint(0)
+	if _, bits, alias := amd64ByteAlias(reg); alias {
+		if width != 1 {
+			return 0
+		}
+		shift = bits / 8
+	}
+	return uint8((uint16(1)<<uint(width) - 1) << shift)
+}
+
+func x86CallerNumericRead(operand Operand, width int64, state *x86SourceStackState) bool {
+	if operand.Kind == OpImm {
+		return operand.ImmRaw == "" && !operand.ImmIsFloat
+	}
+	if operand.Kind != OpReg {
+		return false
+	}
+	root, valid := x86CallerGP(operand.Reg)
+	if !valid || root == SP || root == BP {
+		return false
+	}
+	if _, pointer := state.callers[root]; pointer {
+		return false
+	}
+	mask := x86CallerByteMask(operand.Reg, width)
+	return mask != 0 && state.known[root]&mask == mask
+}
+
+func x86CallerNumericWrite(reg Reg, width int64, state *x86SourceStackState) bool {
+	root, valid := x86CallerGP(reg)
+	if !valid || root == SP || root == BP {
+		return false
+	}
+	mask := x86CallerByteMask(reg, width)
+	if mask == 0 {
+		return false
+	}
+	if _, pointer := state.callers[root]; pointer && width < 4 {
+		return false // A partial write cannot wash surviving pointer bits.
+	}
+	delete(state.callers, root)
+	if width == 4 || width == 8 {
+		state.known[root] = 0xff // A native L write zeroes the upper GP half.
+	} else {
+		state.known[root] |= mask
+	}
+	return true
+}
+
+func x86CallerRecordMemory(ins *Instr, index int, width int64, write bool) {
+	if ins.x86CallerMemory == nil {
+		ins.x86CallerMemory = make(map[int]x86CallerMemoryAccess)
+	}
+	ins.x86CallerMemory[index] = x86CallerMemoryAccess{
+		op: ins.Op, args: append([]Operand(nil), ins.Args...), width: width, write: write,
+	}
+}
+
+func x86CallerMemoryStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof, width int64) bool {
+	for index, operand := range ins.Args {
+		switch operand.Kind {
+		case OpSym:
+			// A static object may have its own old raw-return bounds, but it is
+			// not one of this caller's read inputs or independent result locals.
+			return false
+		case OpFP:
+			// Parameter pointers are imported once as complete words. Stores or
+			// partial scalar reads cannot invent a different pointee contract.
+			if index != 0 || len(ins.Args) != 2 || width != 8 || operand.FPOffset < 0 ||
+				operand.FPOffset%8 != 0 || operand.FPOffset/8 >= int64(len(proof.arguments)) ||
+				ins.Args[1].Kind != OpReg {
+				return false
+			}
+			root, valid := x86CallerGP(ins.Args[1].Reg)
+			if !valid || root != ins.Args[1].Reg || root == SP || root == BP {
+				return false
+			}
+			x86CallerRecordMemory(ins, index, width, false)
+		case OpMem:
+			// The existing stack proof separately maps complete physical SP
+			// argument words to actual FP slots, excluding the native return PC.
+			if offset, mapped := ins.x86SourceStackFP[index]; mapped {
+				if index != 0 || len(ins.Args) != 2 || width != 8 || offset < 0 || offset%8 != 0 ||
+					offset/8 >= int64(len(proof.arguments)) || ins.Args[1].Kind != OpReg {
+					return false
+				}
+				root, valid := x86CallerGP(ins.Args[1].Reg)
+				if !valid || root != ins.Args[1].Reg || root == SP || root == BP {
+					return false
+				}
+				x86CallerRecordMemory(ins, index, width, false)
+				continue
+			}
+			if len(ins.Args) != 2 || !x86CallerOrdinaryMemoryStep(ins, index, state, proof, width, index == 1) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func x86CallerOrdinaryMemoryStep(ins *Instr, index int, state *x86SourceStackState, proof *x86GoCallerRegionProof, width int64, write bool) bool {
+	if index < 0 || index >= len(ins.Args) || ins.Args[index].Kind != OpMem || width <= 0 {
+		return false
+	}
+	if _, parameter := ins.x86SourceStackFP[index]; parameter {
+		return false // Only the scalar GP import above can consume pointer slots.
+	}
+	memory := ins.Args[index].Mem
+	if memory.Sym != "" || memory.Segment != "" || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		memory.Off < -x86SourceStackLimit || memory.Off > x86SourceStackLimit {
+		return false
+	}
+	base, valid := x86CallerGP(memory.Base)
+	pointer, known := state.callers[base]
+	if !valid || base != memory.Base || !known || pointer.argument < 0 || pointer.argument >= len(proof.arguments) {
+		return false
+	}
+	region := proof.arguments[pointer.argument]
+	if _, valid := x86CallerPointerEnd(pointer); !valid || pointer.span != 0 && region.kind != x86CallerSliceInput {
+		return false
+	}
+	if memory.Index != "" {
+		if write || region.kind != x86CallerSliceInput ||
+			memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 ||
+			!x86CallerNumericRead(Operand{Kind: OpReg, Reg: memory.Index}, 8, state) {
+			return false
+		}
+	}
+	offset := pointer.offset + memory.Off
+	if write {
+		if region.kind != x86CallerFreshResult || offset < 0 || offset > region.width || width > region.width-offset {
+			return false
+		}
+	} else if region.kind != x86CallerSliceInput {
+		if offset < 0 || offset > region.width || width > region.width-offset {
+			return false
+		}
+	}
+	x86CallerRecordMemory(ins, index, width, write)
+	return true
+}
+
+// The existing complete source stack handles all SP/BP transformations and
+// returns. This additional transfer tracks only actual caller pointer regions
+// and numerical byte initialization; it grants no unknown instruction effects.
+func x86CallerScalarStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) (pointerFlags, valid bool) {
+	if accepted, recognized := x86CallerNumericalReadStep(*ins, state); recognized {
+		return false, accepted
+	}
+	if _, known, err := x86OrderingHintProperties(ins.Op, *ins, "amd64"); known {
+		return false, err == nil
+	}
+	op := Op(normalizeInstructionOpcode(x86SourceMoveInstruction(*ins, "amd64").Op))
+	if effect, known, err := x86TypedCounterControlByteEffect(ins.Op, *ins, "amd64"); known {
+		if err != nil {
+			return false, false
+		}
+		// The already registered caller supplies NUM; the descriptor grants no role.
+		for _, operand := range effect.operands {
+			if operand.read && !x86CallerNumericRead(operand.operand, operand.width, state) {
+				return false, false
+			}
+		}
+		for _, operand := range effect.operands {
+			if operand.write && (operand.operand.Kind != OpReg ||
+				!x86CallerNumericWrite(operand.operand.Reg, operand.width, state)) {
+				return false, false
+			}
+		}
+		return false, true // The source-stack FLAGS consumer separately checks flagsRead.
+	}
+	if op == OpTEXT || op == OpLABEL || op == OpRET || op == OpJMP || isAMD64ConditionalBranch(op) {
+		return false, !isAMD64CounterZeroBranch(op) || x86CallerNumericRead(Operand{Kind: OpReg, Reg: CX}, 8, state)
+	}
+	if _, stack := amd64StackWidthSpecs[op]; stack {
+		return false, true // Exact saved values/flags are tracked by the stack step.
+	}
+	if recognized, valid := x86CallerExplicitIMULStep(ins, state, proof); recognized {
+		return false, valid
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+			return false, true // Only the preceding exact address step admits this.
+		}
+	}
+	if recognized, valid := x86CallerExtensionStep(ins, state, proof); recognized {
+		return false, valid
+	}
+	if recognized, valid := x86CallerConditionalSetStep(ins, state, proof); recognized {
+		return false, valid
+	}
+	if recognized, valid := x86CallerConditionalMoveStep(ins, state, proof); recognized {
+		return false, valid
+	}
+	width := x86RawReturnScalarMoveBytes(op)
+	if width != 0 {
+		if len(ins.Args) != 2 || !x86CallerMemoryStep(ins, state, proof, width) {
+			return false, false
+		}
+		source, destination := ins.Args[0], ins.Args[1]
+		if isAMD64MemoryOperand(source) && isAMD64MemoryOperand(destination) {
+			return false, false
+		}
+		var pointer x86CallerPointerValue
+		hasPointer := false
+		if source.Kind == OpFP {
+			pointer = x86CallerPointerValue{argument: int(source.FPOffset / 8)}
+			hasPointer = true
+		} else if source.Kind == OpMem {
+			if offset, mapped := ins.x86SourceStackFP[0]; mapped {
+				pointer = x86CallerPointerValue{argument: int(offset / 8)}
+				hasPointer = true
+			}
+		} else if source.Kind == OpReg {
+			root, _ := x86CallerGP(source.Reg)
+			pointer, hasPointer = state.callers[root]
+		}
+		if hasPointer {
+			root, full := x86CallerGP(destination.Reg)
+			sourceRoot, _ := x86CallerGP(source.Reg)
+			if width != 8 || source.Kind == OpReg && source.Reg != sourceRoot ||
+				destination.Kind != OpReg || !full || root != destination.Reg {
+				return false, false // Pointer-as-data stores and partial copies stay unknown.
+			}
+			state.callers[root] = pointer
+			delete(state.known, root)
+			return false, true
+		}
+		if source.Kind != OpMem && !x86CallerNumericRead(source, width, state) {
+			return false, false
+		}
+		if destination.Kind == OpReg {
+			return false, x86CallerNumericWrite(destination.Reg, width, state)
+		}
+		return false, destination.Kind == OpMem
+	}
+	if x86LEAWidth(ins.Op, "amd64") != 0 {
+		return false, x86CallerLEAStep(ins, state)
+	}
+	name := string(op)
+	if len(name) < 2 {
+		return false, false
+	}
+	base, suffix := name[:len(name)-1], name[len(name)-1:]
+	switch suffix {
+	case "B":
+		width = 1
+	case "W":
+		width = 2
+	case "L":
+		width = 4
+	case "Q":
+		width = 8
+	default:
+		return false, false
+	}
+	if len(ins.Args) == 2 && (op == "ADDQ" || op == "SUBQ") && ins.Args[0].Kind == OpImm &&
+		ins.Args[0].ImmRaw == "" && !ins.Args[0].ImmIsFloat && ins.Args[1].Kind == OpReg {
+		root, _ := x86CallerGP(ins.Args[1].Reg)
+		if pointer, present := state.callers[root]; present {
+			if root != ins.Args[1].Reg {
+				return false, false
+			}
+			delta := int64(ins.Args[0].Imm)
+			if delta < -x86SourceStackLimit || delta > x86SourceStackLimit {
+				return false, false
+			}
+			if op == "SUBQ" {
+				delta = -delta
+			}
+			var valid bool
+			pointer, valid = x86CallerPointerShift(pointer, delta)
+			if !valid {
+				return false, false
+			}
+			state.callers[root] = pointer
+			return true, true // Private local addresses cannot define numerical flags.
+		}
+	}
+	zero := base == "XOR" && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg && reflect.DeepEqual(ins.Args[0], ins.Args[1])
+	for _, argument := range ins.Args {
+		if !zero && !x86CallerNumericRead(argument, width, state) {
+			return false, false
+		}
+	}
+	if base == "CMP" || base == "TEST" {
+		return false, true
+	}
+	if len(ins.Args) == 0 || ins.Args[len(ins.Args)-1].Kind != OpReg {
+		return false, false
+	}
+	return false, x86CallerNumericWrite(ins.Args[len(ins.Args)-1].Reg, width, state)
+}
+
+func x86CallerMemoryCertified(ins Instr, index int) bool {
+	access, found := ins.x86CallerMemory[index]
+	width, write, valid := x86CallerMoveMemoryShape(ins, index)
+	// Producer memory proofs admit only native/default addressing. A later
+	// address-size override cannot reuse even otherwise identical operands.
+	return found && valid && ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && access.op == ins.Op && reflect.DeepEqual(access.args, ins.Args) &&
+		access.width == width && width > 0 && access.write == write
+}
diff --git a/amd64_go_caller_region_core_test.go b/amd64_go_caller_region_core_test.go
new file mode 100644
index 000000000..59950c26c
--- /dev/null
+++ b/amd64_go_caller_region_core_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerCoreFixture(t *testing.T, source, assembly string) (GoPackage, *File) {
+	t.Helper()
+	pkg, selected, _, _ := x86CallerFixture(t, source)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected.Assembly["kernel_amd64.s"] = file
+	pkg.SourceSelection = &selected
+	return pkg, file
+}
+
+func x86CallerCoreTranslate(t *testing.T, pkg GoPackage, assembly, triple string) error {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		return err
+	}
+	defer translated.Module.Dispose()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "caller-regions.ll", "caller-regions.o", translated.Module.String())
+	return nil
+}
+
+func TestX86GoCallerRegionCoreConsumesFreshScalarWrites(t *testing.T) {
+	for _, form := range []struct{ typ, move string }{
+		{"uint8", "MOVB"}, {"uint16", "MOVW"}, {"uint32", "MOVL"}, {"uint64", "MOVQ"},
+	} {
+		source := strings.Replace(x86CallerFixtureSource, "var res float32", "var res "+form.typ, 1)
+		source = strings.Replace(source, ") float32 {", ") "+form.typ+" {", 1)
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", form.move+" $7,AX\n"+form.move+" AX,(DX)", 1)
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(form.move+"/"+triple, func(t *testing.T) {
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, source, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerRegionCoreDoesNotCertifyBadStackOrWrites(t *testing.T) {
+	for name, replacement := range map[string]string{
+		"input write":               "MOVL AX,(DI)",
+		"length write":              "MOVL AX,(CX)",
+		"wide result":               "MOVQ AX,(DX)",
+		"one byte overlap":          "MOVL AX,1(DX)",
+		"negative offset":           "MOVL AX,-1(DX)",
+		"unknown base":              "MOVL AX,(BX)",
+		"indexed result":            "MOVL AX,(DX)(BX*1)",
+		"pointer as data":           "MOVL DI,(DX)",
+		"partial pointer":           "MOVL DX,BX\nMOVL AX,(BX)",
+		"fresh pointer join":        "CMPQ AX,$0\nJE joined\nMOVQ DI,DX\njoined:\nMOVL AX,(DX)",
+		"return PC":                 "MOVQ AX,8(BP)",
+		"saved BP":                  "MOVB AX,0(BP)",
+		"SP escape":                 "MOVQ SP,AX\nMOVL AX,(DX)",
+		"input pointer to SP":       "MOVQ DI,SP\nMOVL AX,(DX)",
+		"input pointer to BP":       "MOVQ DI,BP\nMOVL AX,(DX)",
+		"input address to SP":       "LEAQ 0(DI),SP\nMOVL AX,(DX)",
+		"input address to BP":       "LEAQ 0(DI),BP\nMOVL AX,(DX)",
+		"g use":                     "MOVQ R14,AX\nMOVL AX,(DX)",
+		"g overwrite":               "MOVQ $0,R14\nMOVL AX,(DX)",
+		"pointer FP store":          "MOVQ AX,res+16(FP)\nMOVL AX,(DX)",
+		"unknown numeric input":     "MOVL BX,(DX)",
+		"partial address clobber":   "MOVW $0,DX\nMOVL AX,(DX)",
+		"pointer flags":             "ADDQ $0,DX\nJE joined\njoined:\nMOVL AX,(DX)",
+		"different pointer offsets": "CMPQ AX,$0\nJE joined\nADDQ $1,DX\njoined:\nMOVB AX,(DX)",
+		"unrestored SP":             "MOVL AX,(DX)",
+		"unknown store effect":      "XCHGL AX,(DX)",
+		"vector effect":             "VMOVSS X0,(DX)",
+		"floating immediate":        "MOVQ $1.25,AX\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", replacement, 1)
+			if name == "unrestored SP" {
+				assembly = strings.Replace(assembly, "BYTE $0xc3", "SUBQ $8,SP\nBYTE $0xc3", 1)
+			}
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if name == "floating immediate" {
+				// Go's FLOAT class has no MOVQ row; this is invalid source,
+				// not a native caller privilege that a later producer can grant.
+				goAssemblerOracleOutput(t, "amd64", assembly, "", false)
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-rejected FLOAT source became Context or success: %v", err)
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("bad source acquired caller-region continuation: %v", err)
+			}
+		})
+	}
+	// An actual producer snapshot is mandatory; a pointer signature remains
+	// the original failure rather than acquiring source memory privileges.
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, x86CallerFixtureAssembly)
+	pkg.SourceSelection = nil
+	if err := x86CallerCoreTranslate(t, pkg, x86CallerFixtureAssembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("missing caller selection acquired pointer-store proof: %v", err)
+	}
+}
+
+func TestX86GoCallerRegionCoreDoesNotStoreInputPointerAsFullWidthData(t *testing.T) {
+	source := strings.NewReplacer(
+		"var res float32", "var res uint64", ") float32 {", ") uint64 {",
+	).Replace(x86CallerFixtureSource)
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "MOVQ DI,(DX)", 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, source, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("input pointer escaped through a correctly sized fresh result: %v", err)
+	}
+}
+
+func TestX86GoCallerRegionCoreTracksScalarCopiesOffsetsAndInputs(t *testing.T) {
+	for name, replacement := range map[string]string{
+		"input load":           "MOVL (DI),AX\nADDL $7,AX\nMOVL AX,(DX)",
+		"length load":          "MOVQ (CX),AX\nMOVL AX,(DX)",
+		"pointer copy":         "MOVQ DX,BX\nMOVL AX,(BX)",
+		"pointer offset":       "ADDQ $1,DX\nMOVB AX,(DX)",
+		"LEA offset":           "LEAQ 3(DX),BX\nMOVB AX,(BX)",
+		"safe adjacent":        "MOVB AX,3(DX)",
+		"byte alias":           "MOVB $7,AH\nMOVB AH,(DX)",
+		"indexed input":        "MOVQ $0,BX\nMOVL (DI)(BX*4),AX\nMOVL AX,(DX)",
+		"copy input offset":    "MOVQ DI,BX\nADDQ $4,BX\nMOVL (BX),AX\nMOVL AX,(DX)",
+		"saved result pointer": "PUSHQ DX\nMOVQ DI,DX\nPOPQ DX\nMOVL AX,(DX)",
+		"identical join":       "MOVQ DX,BX\nCMPQ AX,$0\nJE joined\nMOVQ DX,BX\njoined:\nMOVL AX,(BX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", replacement, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	physical := strings.NewReplacer(
+		"a+0(FP)", "8(SP)", "b+8(FP)", "16(SP)",
+		"res+16(FP)", "24(SP)", "length+24(FP)", "32(SP)",
+	).Replace(x86CallerFixtureAssembly)
+	leaf := strings.NewReplacer(
+		"BYTE $0x55\nWORD $0x8948\nBYTE $0xe5\nLONG $0xf8e48348\n", "",
+		"WORD $0x8948\nBYTE $0xec\nBYTE $0x5d\n", "",
+	).Replace(x86CallerFixtureAssembly)
+	for name, assembly := range map[string]string{"actual physical FP": physical, "stack-unobserving leaf": leaf} {
+		t.Run(name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerRegionCoreRejectsDifferentCompilerDataLayout(t *testing.T) {
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, x86CallerFixtureAssembly)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(x86CallerFixtureAssembly), GoModuleOptions{
+		GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sizes: types.SizesFor("gc", "386"), FrameSizes: types.SizesFor("gc", "amd64"),
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if translation != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		if translation != nil {
+			translation.Module.Dispose()
+		}
+		t.Fatalf("typed Args/FP slots concealed a different local int/pointer layout: %v", err)
+	}
+}
+
+func TestX86GoCallerRegionCoreRejectsStaleSourceSignatureAndAccess(t *testing.T) {
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	for _, change := range []string{"original source", "normalized source", "signature", "slot", "memory access", "missing caller"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, x86CallerFixtureAssembly)
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+			normalized, err := normalizeX86RawFile(file, "amd64", options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if change != "original source" {
+				file = normalized
+			}
+			sig := sigs["caller.kernel"]
+			switch change {
+			case "original source", "normalized source":
+				for index := range file.Funcs[0].Instrs {
+					instruction := &file.Funcs[0].Instrs[index]
+					if instruction.Op == "MOVL" && len(instruction.Args) == 2 && instruction.Args[1].Kind == OpMem {
+						instruction.Args[1].Mem.Off++
+					}
+				}
+			case "signature":
+				sig.Args[0] = I64
+			case "slot":
+				sig.Frame.Params[0].Offset = 8
+			case "missing caller":
+				sig.x86CallerRegions = nil
+			case "memory access":
+				for index := range file.Funcs[0].Instrs {
+					instruction := &file.Funcs[0].Instrs[index]
+					for operand, access := range instruction.x86CallerMemory {
+						access.width++
+						instruction.x86CallerMemory[operand] = access
+					}
+				}
+				if x86RawReturnMemoryBound(file.Funcs[0], file, options, true) {
+					t.Fatal("edited access inherited a whole-function memory permission")
+				}
+				// This checks private access revocation. Public normalization
+				// requires a fresh original source, not the edited sealed snapshot.
+				return
+			}
+			sigs["caller.kernel"] = sig
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed %s borrowed a caller continuation: %v", change, err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerRegionCoreCannotBorrowPhysicalFPWithoutAccessProof(t *testing.T) {
+	assembly := strings.NewReplacer(
+		"a+0(FP)", "8(SP)", "b+8(FP)", "16(SP)",
+		"res+16(FP)", "24(SP)", "length+24(FP)", "32(SP)",
+	).Replace(x86CallerFixtureAssembly)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+	normalized, err := normalizeX86RawFile(file, "amd64", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	removed := false
+	for index := range normalized.Funcs[0].Instrs {
+		instruction := &normalized.Funcs[0].Instrs[index]
+		for operand := range instruction.x86SourceStackFP {
+			delete(instruction.x86CallerMemory, operand)
+			removed = true
+		}
+	}
+	if !removed {
+		t.Fatal("fixture did not exercise a physical-SP imported parameter")
+	}
+	if x86RawReturnMemoryBound(normalized.Funcs[0], normalized, options, true) {
+		t.Fatal("missing caller access borrowed the old numerical FP continuation")
+	}
+}
+
+func TestX86GoCallerRegionCoreDoesNotExportScalarOrFloatingStackPermissions(t *testing.T) {
+	for name, assembly := range map[string]string{
+		"external scalar write": strings.Replace(x86CallerFixtureAssembly,
+			"MOVL AX,(DX)", "MOVL AX,global(SB)\nMOVL AX,(DX)", 1) + "GLOBL global(SB),8,$4\n",
+		"floating stack adjustment": strings.Replace(x86CallerFixtureAssembly,
+			"BYTE $0xc3", "ADDQ $0.5,SP\nBYTE $0xc3", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved permission acquired a caller continuation: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_region_diagnostic_test.go b/amd64_go_caller_region_diagnostic_test.go
new file mode 100644
index 000000000..adc8b5dbc
--- /dev/null
+++ b/amd64_go_caller_region_diagnostic_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerRegionRejectedEffectsRetainInstructionDiagnostic(t *testing.T) {
+	for _, example := range []struct {
+		name, replacement, diagnostic string
+	}{
+		{
+			name: "uninitialized vector arithmetic", replacement: "VFMADD231SS (DI),X0,X1\nVMOVSS X1,(DX)",
+			diagnostic: "unproved caller-region effect: VFMADD231SS",
+		},
+		{
+			name: "pointer as scalar data", replacement: "MOVL DI,(DX)",
+			diagnostic: "unproved caller-region effect: MOVL",
+		},
+		{
+			name:        "different input origins",
+			replacement: "CMPQ AX,$0\nJE joined\nMOVQ SI,DI\nCMPQ AX,$0\njoined:\nMOVL AX,(DX)",
+			diagnostic:  "different source-stack or caller-region states at join",
+		},
+	} {
+		t.Run(example.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", example.replacement, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), example.diagnostic) {
+				t.Fatalf("source rejection lost its actual instruction/state cause: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_region_runtime_test.go b/amd64_go_caller_region_runtime_test.go
new file mode 100644
index 000000000..7f6bb287b
--- /dev/null
+++ b/amd64_go_caller_region_runtime_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86CallerRuntimeForm struct {
+	name  string
+	bits  int
+	move  string
+	stack string
+}
+
+func x86CallerRuntimeForms() []x86CallerRuntimeForm {
+	var forms []x86CallerRuntimeForm
+	for _, width := range []struct {
+		bits int
+		move string
+	}{{8, "MOVB"}, {16, "MOVW"}, {32, "MOVL"}, {64, "MOVQ"}} {
+		for _, stack := range []string{"Leaf", "Balanced", "SavedPointer"} {
+			forms = append(forms, x86CallerRuntimeForm{
+				name: fmt.Sprintf("kernel%d%s", width.bits, stack),
+				bits: width.bits, move: width.move, stack: stack,
+			})
+		}
+	}
+	return forms
+}
+
+func x86CallerRuntimeSource() (goSource, assembly string) {
+	var declarations, machine strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	for _, form := range x86CallerRuntimeForms() {
+		fmt.Fprintf(&declarations, `
+//go:noescape
+func %[1]s(a, b, res, length unsafe.Pointer)
+
+func Call%[1]s(x, y []uint64) uint%[2]d {
+	var res uint%[2]d
+	length := len(x)
+	%[1]s(
+		unsafe.Pointer(unsafe.SliceData(x)),
+		unsafe.Pointer(unsafe.SliceData(y)),
+		unsafe.Pointer(&res),
+		unsafe.Pointer(&length))
+	return res
+}
+`, form.name, form.bits)
+		fmt.Fprintf(&machine, "TEXT ·%s(SB),4,$0-32\n", form.name)
+		machine.WriteString("MOVQ a+0(FP),DI\nMOVQ b+8(FP),SI\nMOVQ res+16(FP),DX\nMOVQ length+24(FP),CX\n")
+		if form.stack != "Leaf" {
+			machine.WriteString("BYTE $0x55\nWORD $0x8948\nBYTE $0xe5\nLONG $0xf8e48348\n")
+		}
+		if form.stack == "SavedPointer" {
+			machine.WriteString("PUSHQ DX\nMOVQ DI,DX\nPOPQ DX\n")
+		}
+		suffix := strings.TrimPrefix(form.move, "MOV")
+		fmt.Fprintf(&machine, "%s (DI),AX\n%s 8(SI),BX\nADD%s BX,AX\nMOVQ (CX),BX\nADD%s BX,AX\nADD%s $7,AX\n%s AX,(DX)\n",
+			form.move, form.move, suffix, suffix, suffix, form.move)
+		if form.stack != "Leaf" {
+			machine.WriteString("WORD $0x8948\nBYTE $0xec\nBYTE $0x5d\n")
+		}
+		machine.WriteString("BYTE $0xc3\n")
+	}
+	return declarations.String(), machine.String()
+}
+
+func x86CallerRuntimePackage(t *testing.T, goSource, assembly string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "value.go", goSource, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{
+		Types: make(map[ast.Expr]types.TypeAndValue),
+		Defs:  make(map[*ast.Ident]types.Object),
+		Uses:  make(map[*ast.Ident]types.Object),
+	}
+	typed, err := (&types.Config{
+		Importer: x86CallerTestImporter{}, Sizes: types.SizesFor("gc", "amd64"),
+	}).Check("caller", fset, []*ast.File{syntax}, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{
+		Path: "caller", Types: typed, Syntax: []*ast.File{syntax},
+		SourceSelection: &GoSourceSelection{
+			Fset: fset, TypesInfo: info, Sizes: types.SizesFor("gc", "amd64"),
+			SelectedGoFiles: []string{"value.go"}, GoSources: map[string][]byte{"value.go": []byte(goSource)},
+			SelectedAssemblyFiles: []string{"value_amd64.s"}, Assembly: map[string]*File{"value_amd64.s": file},
+		},
+	}
+}
+
+func x86CallerActualGoOracle(t *testing.T, goSource, assembly string) {
+	t.Helper()
+	var tests strings.Builder
+	tests.WriteString("package caller\nimport \"testing\"\nfunc TestActualCallers(t *testing.T) {\n")
+	for _, form := range x86CallerRuntimeForms() {
+		fmt.Fprintf(&tests, `
+	for iteration := 0; iteration < 64; iteration++ {
+		for _, input := range []uint64{0, 1, 127, 255, 65535, 1<<31, 1<<63, ^uint64(0)} {
+			x := []uint64{input, 0x1122334455667788}
+			y := []uint64{0x8877665544332211, input ^ 0x9876543210abcdef}
+			originalX := [2]uint64{x[0], x[1]}
+			originalY := [2]uint64{y[0], y[1]}
+			canary := [4]uint64{11, 23, 37, 41}
+			want := uint%[1]d(x[0]) + uint%[1]d(y[1]) + uint%[1]d(len(x)) + 7
+			got := Call%[2]s(x, y)
+			if got != want || x[0] != originalX[0] || x[1] != originalX[1] ||
+				y[0] != originalY[0] || y[1] != originalY[1] || canary != [4]uint64{11, 23, 37, 41} {
+				t.Fatalf("%[2]s got=%%#x want=%%#x x=%%#v y=%%#v canary=%%#v", got, want, x, y, canary)
+			}
+		}
+	}
+`, form.bits, form.name)
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": goSource,
+		"value_amd64.s": assembly, "value_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	command.WaitDelay = 2 * time.Second
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go original caller-region oracle: %v\n%s", err, output)
+	}
+}
+
+func x86CallerCOracle() string {
+	var source strings.Builder
+	source.WriteString(`#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for _, form := range x86CallerRuntimeForms() {
+		fmt.Fprintf(&source, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", form.name, form.name)
+	}
+	source.WriteString("int main(void) {\n")
+	for _, form := range x86CallerRuntimeForms() {
+		fmt.Fprintf(&source, `
+	for (unsigned iteration = 0; iteration < 64; iteration++) {
+		const uint64_t inputs[] = {0, 1, 127, 255, 65535, UINT64_C(1)<<31, UINT64_C(1)<<63, UINT64_MAX};
+		for (unsigned index = 0; index < sizeof(inputs)/sizeof(inputs[0]); index++) {
+			uint64_t x[] = {inputs[index], UINT64_C(0x1122334455667788)};
+			uint64_t y[] = {UINT64_C(0x8877665544332211), inputs[index] ^ UINT64_C(0x9876543210abcdef)};
+			uint64_t original_x[2], original_y[2], length = 2;
+			unsigned char output[48], before[48];
+			memcpy(original_x, x, sizeof(x));
+			memcpy(original_y, y, sizeof(y));
+			for (unsigned byte = 0; byte < sizeof(output); byte++) {
+				output[byte] = byte + iteration;
+			}
+			memset(output + 16, 0, %[1]d);
+			memcpy(before, output, sizeof(output));
+			const uint64_t want = (x[0] + y[1] + length + 7) & UINT%[2]d_MAX;
+			%[3]s(x, y, output + 16, &length);
+			for (unsigned byte = 0; byte < sizeof(output); byte++) {
+				unsigned char expected = before[byte];
+				if (byte >= 16 && byte < 16 + %[1]d) {
+					expected = want >> (8*(byte-16));
+				}
+				if (output[byte] != expected) {
+					return 1;
+				}
+			}
+			if (memcmp(x, original_x, sizeof(x)) || memcmp(y, original_y, sizeof(y)) || length != 2) {
+				return 2;
+			}
+		}
+	}
+`, form.bits/8, form.bits, form.name)
+	}
+	source.WriteString("\treturn 0;\n}\n")
+	return source.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerRegions(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("caller-region execution requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	goSource, assembly := x86CallerRuntimeSource()
+	x86CallerActualGoOracle(t, goSource, assembly)
+	pkg := x86CallerRuntimePackage(t, goSource, assembly)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "caller_regions", triple,
+		translation.Module.String(), x86CallerCOracle(), runner)
+}
diff --git a/amd64_go_caller_regions.go b/amd64_go_caller_regions.go
new file mode 100644
index 000000000..991da4dbd
--- /dev/null
+++ b/amd64_go_caller_regions.go
@@ -0,0 +1,519 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+)
+
+// GoSourceSelection carries a compiler's complete, actual selected package,
+// not a user-supplied noalias assertion. The inventories must come from the
+// same load/profile as Types, Syntax and TypesInfo. Every selected source is
+// mandatory; a per-translation subset cannot establish a closed caller graph.
+// Assembly contains the corresponding fully preprocessed source files.
+type GoSourceSelection struct {
+	Fset                  *token.FileSet
+	TypesInfo             *types.Info
+	Sizes                 types.Sizes
+	SelectedGoFiles       []string
+	GoSources             map[string][]byte
+	SelectedAssemblyFiles []string
+	Assembly              map[string]*File
+}
+
+type x86CallerRegionKind uint8
+
+const (
+	x86CallerSliceInput x86CallerRegionKind = iota + 1
+	x86CallerFreshResult
+	x86CallerLocalLength
+)
+
+type x86CallerArgumentRegion struct {
+	kind  x86CallerRegionKind
+	width int64
+	slot  int64
+}
+
+// Only the actual Go producer can construct this private proof. It does not
+// establish a source stack, an instruction effect or a return continuation.
+// The subsequent whole-source CFG proof must consume the exact signature,
+// parameter slots and output envelope before it can admit a raw return.
+type x86GoCallerRegionProof struct {
+	symbol    string
+	arguments []x86CallerArgumentRegion
+	calls     int
+	goSources map[string][32]byte
+	assembly  map[string][32]byte
+	signature FuncSig
+	source    [32]byte
+}
+
+func x86GoCallerRegionCandidate(fn Func, sig FuncSig) bool {
+	if sig.Ret != Void || len(sig.Args) == 0 {
+		return false
+	}
+	for _, argument := range sig.Args {
+		if argument != Ptr {
+			return false
+		}
+	}
+	decoded, err := decodeX86RawDirectives(fn, "amd64")
+	if err != nil {
+		return false // The normal decoder still reports the actual failure.
+	}
+	for _, ins := range decoded.Instrs {
+		if ins.x86RawNearReturn != nil {
+			return true
+		}
+	}
+	return false
+}
+
+func deriveX86GoCallerRegions(pkg GoPackage, selected GoSourceSelection, fn Func, sig FuncSig, arch string) (*x86GoCallerRegionProof, error) {
+	fail := func(reason string) (*x86GoCallerRegionProof, error) {
+		return nil, fmt.Errorf("%w: bounded raw-return caller source: %s", ErrProbeNeedsContext, reason)
+	}
+	if arch != "amd64" || pkg.Types == nil || selected.Fset == nil || selected.TypesInfo == nil || !x86CallerTargetSizesValid(selected.Sizes) ||
+		len(sig.ArgRegs) != 0 || sig.Ret != Void || len(sig.Frame.Results) != 0 ||
+		sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMNative || sig.WASMContext != "" ||
+		fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || len(sig.Args) == 0 || len(sig.Args) > 16 {
+		return fail("needs complete ordinary AMD64 ABI0 pointer/void types and source")
+	}
+	name := strings.TrimPrefix(sig.Name, pkg.Types.Path()+".")
+	declaration, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+	if !ok || name == sig.Name || declaration.Exported() {
+		return fail("entry must be an unexported actual package declaration")
+	}
+	actual, ok := declaration.Type().(*types.Signature)
+	if !ok || actual.Recv() != nil || actual.Variadic() || actual.TypeParams().Len() != 0 ||
+		actual.Results().Len() != 0 || actual.Params().Len() != len(sig.Args) || len(sig.Frame.Params) != len(sig.Args) ||
+		fn.ArgSize != int64(8*len(sig.Args)) {
+		return fail("signature is not the complete pointer-only ABI0 declaration")
+	}
+	for index, argument := range sig.Args {
+		bound := false
+		for _, slot := range sig.Frame.Params {
+			bound = bound || slot.Offset == int64(index*8) && slot.Index == index && slot.Type == Ptr && len(frameSlotFields(slot)) == 0
+		}
+		if argument != Ptr || !types.Identical(actual.Params().At(index).Type(), types.Typ[types.UnsafePointer]) ||
+			!bound || !x86RawReturnFPBound(int64(index*8), 8, sig, arch) {
+			return fail("parameter types or exact FP slots differ from the declaration")
+		}
+	}
+	if err := x86ValidateCallerSelection(pkg, selected); err != nil {
+		return fail(err.Error())
+	}
+	if err := x86RejectAssemblyCallers(selected, fn, name, sig.Name, arch); err != nil {
+		return fail(err.Error())
+	}
+
+	proof := &x86GoCallerRegionProof{
+		symbol: sig.Name, signature: sig,
+		goSources: make(map[string][32]byte), assembly: make(map[string][32]byte),
+	}
+	// Slices and maps supplied by the compiler remain mutable. The producer
+	// owns an independent signature and byte fingerprint, never an alias of
+	// an operand or layout that a later normalization may change.
+	proof.signature.Args = append([]LLVMType(nil), sig.Args...)
+	proof.signature.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+	var err error
+	proof.source, err = x86CallerSourceFingerprint(fn)
+	if err != nil {
+		return fail("translated source cannot be pinned: " + err.Error())
+	}
+	for file, source := range selected.GoSources {
+		proof.goSources[file] = sha256.Sum256(source)
+	}
+	for file, assembly := range selected.Assembly {
+		fingerprint, err := x86CallerSourceFingerprint(assembly)
+		if err != nil {
+			return fail("selected assembly cannot be pinned: " + err.Error())
+		}
+		proof.assembly[file] = fingerprint
+	}
+	allowedUses := map[*ast.Ident]bool{}
+	declarations := 0
+	for _, file := range pkg.Syntax {
+		for _, group := range file.Comments {
+			for _, comment := range group.List {
+				if strings.Contains(comment.Text, "go:linkname") {
+					for _, field := range strings.Fields(comment.Text) {
+						if field == name || field == sig.Name {
+							return fail("linkname prevents package-local caller closure")
+						}
+					}
+				}
+			}
+		}
+		for _, node := range file.Decls {
+			function, ok := node.(*ast.FuncDecl)
+			if !ok {
+				continue
+			}
+			if selected.TypesInfo.Defs[function.Name] == declaration {
+				if function.Body != nil {
+					return fail("assembly declaration has a Go body")
+				}
+				declarations++
+				continue
+			}
+			if function.Body == nil {
+				continue
+			}
+			for statementIndex, statement := range function.Body.List {
+				expression, ok := statement.(*ast.ExprStmt)
+				if !ok {
+					continue
+				}
+				call, ok := expression.X.(*ast.CallExpr)
+				if !ok {
+					continue
+				}
+				identifier, ok := call.Fun.(*ast.Ident)
+				if !ok || selected.TypesInfo.Uses[identifier] != declaration {
+					continue
+				}
+				regions, err := x86DeriveCallerArguments(function, statementIndex, call, selected.TypesInfo)
+				if err != nil {
+					return fail(err.Error())
+				}
+				for index := range regions {
+					regions[index].slot = int64(index * 8)
+				}
+				if proof.arguments != nil && !reflect.DeepEqual(proof.arguments, regions) {
+					return fail("different callers do not share the same parameter/write envelope")
+				}
+				proof.arguments = regions
+				proof.calls++
+				allowedUses[identifier] = true
+			}
+		}
+	}
+	if declarations != 1 || proof.calls == 0 {
+		return fail("missing bodyless declaration or closed direct caller")
+	}
+	closed := true
+	for _, file := range pkg.Syntax {
+		ast.Inspect(file, func(node ast.Node) bool {
+			identifier, ok := node.(*ast.Ident)
+			if ok && selected.TypesInfo.Uses[identifier] == declaration && !allowedUses[identifier] {
+				closed = false // Address-taking, indirect and nested calls never disappear.
+			}
+			return true
+		})
+	}
+	if !closed {
+		return fail("entry has a non-direct, nested or unregistered caller")
+	}
+	return proof, nil
+}
+
+func x86CallerTargetSizesValid(sizes types.Sizes) bool {
+	if sizes == nil || sizes.Sizeof(types.Typ[types.UnsafePointer]) != 8 {
+		return false
+	}
+	for _, kind := range []types.BasicKind{
+		types.Int8, types.Uint8, types.Int16, types.Uint16, types.Int32, types.Uint32,
+		types.Int64, types.Uint64, types.Int, types.Uint, types.Float32, types.Float64,
+	} {
+		object := types.NewVar(token.NoPos, nil, "", types.Typ[kind])
+		if sizes.Sizeof(object.Type()) != x86CallerNumericWidth(object) {
+			return false
+		}
+	}
+	return true
+}
+
+func x86ValidateCallerSelection(pkg GoPackage, selected GoSourceSelection) error {
+	if len(selected.SelectedGoFiles) == 0 || len(selected.SelectedGoFiles) != len(selected.GoSources) ||
+		len(pkg.Syntax) != len(selected.SelectedGoFiles) || len(selected.SelectedAssemblyFiles) == 0 ||
+		len(selected.SelectedAssemblyFiles) != len(selected.Assembly) {
+		return fmt.Errorf("complete selected Go and assembly inventory is required")
+	}
+	seen := map[string]bool{}
+	for _, name := range selected.SelectedGoFiles {
+		source, ok := selected.GoSources[name]
+		if name == "" || seen[name] || !ok {
+			return fmt.Errorf("missing/duplicate selected Go source")
+		}
+		seen[name] = true
+		var syntax *ast.File
+		for _, file := range pkg.Syntax {
+			if selected.Fset.Position(file.Pos()).Filename == name {
+				if syntax != nil {
+					return fmt.Errorf("duplicate selected Go syntax")
+				}
+				syntax = file
+			}
+		}
+		if syntax == nil {
+			return fmt.Errorf("selected Go source has no actual typed syntax")
+		}
+		identitiesMatch := true
+		ast.Inspect(syntax, func(node ast.Node) bool {
+			if identifier, ok := node.(*ast.Ident); ok {
+				object := selected.TypesInfo.ObjectOf(identifier)
+				if object != nil && object.Name() != identifier.Name {
+					identitiesMatch = false
+				}
+			}
+			return true
+		})
+		if !identitiesMatch {
+			return fmt.Errorf("selected Go identifier differs from its actual typechecked identity")
+		}
+		fset := token.NewFileSet()
+		parsed, err := parser.ParseFile(fset, name, source, parser.ParseComments)
+		if err != nil {
+			return fmt.Errorf("selected Go source is not the typed source: %w", err)
+		}
+		var original, typed bytes.Buffer
+		if err := format.Node(&original, fset, parsed); err != nil {
+			return err
+		}
+		if err := format.Node(&typed, selected.Fset, syntax); err != nil {
+			return err
+		}
+		if !bytes.Equal(original.Bytes(), typed.Bytes()) {
+			return fmt.Errorf("selected Go bytes differ from the actual typed syntax")
+		}
+	}
+	seen = map[string]bool{}
+	for _, name := range selected.SelectedAssemblyFiles {
+		if name == "" || seen[name] || selected.Assembly[name] == nil || selected.Assembly[name].Arch != ArchAMD64 {
+			return fmt.Errorf("missing/duplicate selected assembly source")
+		}
+		seen[name] = true
+	}
+	return nil
+}
+
+func x86RejectAssemblyCallers(selected GoSourceSelection, target Func, localName, resolvedName, arch string) error {
+	entries := 0
+	for _, file := range selected.Assembly {
+		if len(file.UnlinkedPrelude) != 0 {
+			return fmt.Errorf("unregistered assembly prelude prevents caller closure")
+		}
+		for _, data := range file.Data {
+			base, _, reference := parseSBRef(strings.TrimPrefix(data.Addr, "$"))
+			if reference && (base == target.Sym || base == "·"+localName || base == resolvedName) {
+				return fmt.Errorf("assembly DATA exposes the Go entry")
+			}
+		}
+		for _, fn := range file.Funcs {
+			if len(fn.X86RawText) != 0 {
+				return fmt.Errorf("address-sensitive raw assembly prevents caller closure")
+			}
+			if fn.Sym == target.Sym {
+				if !reflect.DeepEqual(fn, target) {
+					return fmt.Errorf("selected assembly entry differs from the translated source")
+				}
+				entries++
+			}
+			decoded, err := decodeX86RawDirectives(fn, arch)
+			if err != nil {
+				return fmt.Errorf("selected assembly caller effects are not known: %w", err)
+			}
+			for _, ins := range decoded.Instrs {
+				for _, argument := range ins.Args {
+					symbol := argument.Sym
+					if argument.Kind == OpMem {
+						symbol = argument.Mem.Sym
+					}
+					symbol = strings.TrimPrefix(strings.TrimSpace(symbol), "$")
+					base, _, reference := parseSBRef(symbol)
+					if reference && (base == target.Sym || base == "·"+localName || base == resolvedName) && ins.Op != OpTEXT {
+						return fmt.Errorf("selected assembly calls or exposes the Go entry")
+					}
+				}
+				if ins.Op == OpCALL {
+					return fmt.Errorf("unknown assembly call cannot close package-local callers")
+				}
+				if ins.Op == OpJMP {
+					if len(ins.Args) != 1 {
+						return fmt.Errorf("incomplete assembly branch prevents caller closure")
+					}
+					argument := ins.Args[0]
+					if argument.Kind != OpLabel && argument.Kind != OpIdent &&
+						!(argument.Kind == OpMem && argument.Mem.Base == PC && argument.Mem.Index == "" && argument.Mem.Sym == "") {
+						return fmt.Errorf("indirect or external assembly branch prevents caller closure")
+					}
+				}
+			}
+		}
+	}
+	if entries != 1 {
+		return fmt.Errorf("translated entry is not unique in the complete selected assembly")
+	}
+	return nil
+}
+
+func x86DeriveCallerArguments(function *ast.FuncDecl, index int, call *ast.CallExpr, info *types.Info) ([]x86CallerArgumentRegion, error) {
+	if call.Ellipsis.IsValid() || len(call.Args) == 0 {
+		return nil, fmt.Errorf("direct call has incomplete argument flow")
+	}
+	parameters := map[types.Object]bool{}
+	if function.Type.Params != nil {
+		for _, field := range function.Type.Params.List {
+			for _, name := range field.Names {
+				parameters[info.Defs[name]] = true
+			}
+		}
+	}
+	locals := map[types.Object]x86CallerArgumentRegion{}
+	for _, statement := range function.Body.List[:index] {
+		switch statement := statement.(type) {
+		case *ast.DeclStmt:
+			declaration, ok := statement.Decl.(*ast.GenDecl)
+			if !ok || declaration.Tok != token.VAR {
+				continue
+			}
+			for _, spec := range declaration.Specs {
+				value, ok := spec.(*ast.ValueSpec)
+				if !ok || len(value.Values) != 0 {
+					continue
+				}
+				for _, name := range value.Names {
+					object := info.Defs[name]
+					if width := x86CallerNumericWidth(object); width != 0 {
+						locals[object] = x86CallerArgumentRegion{kind: x86CallerFreshResult, width: width}
+					}
+				}
+			}
+		case *ast.AssignStmt:
+			if statement.Tok != token.DEFINE || len(statement.Lhs) != 1 || len(statement.Rhs) != 1 {
+				continue
+			}
+			name, ok := statement.Lhs[0].(*ast.Ident)
+			length, call := statement.Rhs[0].(*ast.CallExpr)
+			if !ok || !call || len(length.Args) != 1 {
+				continue
+			}
+			builtin, ok := length.Fun.(*ast.Ident)
+			slice, sliceOK := length.Args[0].(*ast.Ident)
+			if ok && sliceOK && info.Uses[builtin] == types.Universe.Lookup("len") && parameters[info.Uses[slice]] {
+				if _, ok := info.Uses[slice].Type().Underlying().(*types.Slice); ok {
+					locals[info.Defs[name]] = x86CallerArgumentRegion{kind: x86CallerLocalLength, width: 8}
+				}
+			}
+		}
+	}
+	var regions []x86CallerArgumentRegion
+	allowedAddresses := map[*ast.Ident]bool{}
+	localObjects := map[types.Object]bool{}
+	results := 0
+	for _, argument := range call.Args {
+		conversion, ok := argument.(*ast.CallExpr)
+		if !ok || len(conversion.Args) != 1 || conversion.Ellipsis.IsValid() ||
+			!info.Types[conversion.Fun].IsType() || !types.Identical(info.TypeOf(conversion.Fun), types.Typ[types.UnsafePointer]) {
+			return nil, fmt.Errorf("argument is not an actual unsafe.Pointer conversion")
+		}
+		switch value := conversion.Args[0].(type) {
+		case *ast.UnaryExpr:
+			identifier, ok := value.X.(*ast.Ident)
+			if value.Op != token.AND || !ok {
+				return nil, fmt.Errorf("result/length address is not a fresh direct local")
+			}
+			object := info.Uses[identifier]
+			region, ok := locals[object]
+			if !ok || localObjects[object] {
+				return nil, fmt.Errorf("result/length local is missing, aliased or not fresh")
+			}
+			regions = append(regions, region)
+			localObjects[object] = true
+			allowedAddresses[identifier] = true
+			if region.kind == x86CallerFreshResult {
+				results++
+			}
+		case *ast.CallExpr:
+			selector, ok := value.Fun.(*ast.SelectorExpr)
+			if !ok || info.Uses[selector.Sel] != types.Unsafe.Scope().Lookup("SliceData") || len(value.Args) != 1 {
+				return nil, fmt.Errorf("input is not actual unsafe.SliceData")
+			}
+			identifier, ok := value.Args[0].(*ast.Ident)
+			if !ok || !parameters[info.Uses[identifier]] {
+				return nil, fmt.Errorf("slice input is not an independent typed caller parameter")
+			}
+			slice, ok := info.Uses[identifier].Type().Underlying().(*types.Slice)
+			if !ok {
+				return nil, fmt.Errorf("input is not a typed slice")
+			}
+			width := x86CallerNumericWidth(types.NewVar(token.NoPos, nil, "", slice.Elem()))
+			if width == 0 {
+				return nil, fmt.Errorf("slice element layout is not a supported numerical input")
+			}
+			regions = append(regions, x86CallerArgumentRegion{kind: x86CallerSliceInput, width: width})
+		default:
+			return nil, fmt.Errorf("unsafe arithmetic or non-direct argument flow")
+		}
+	}
+	if results == 0 {
+		return nil, fmt.Errorf("caller has no independent fresh result envelope")
+	}
+	valid := true
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		if address, ok := node.(*ast.UnaryExpr); ok && address.Op == token.AND {
+			if identifier, ok := address.X.(*ast.Ident); ok && localObjects[info.Uses[identifier]] && !allowedAddresses[identifier] {
+				valid = false
+			}
+		}
+		if assignment, ok := node.(*ast.AssignStmt); ok && assignment.Tok != token.DEFINE {
+			for _, target := range assignment.Lhs {
+				if identifier, ok := target.(*ast.Ident); ok && localObjects[info.Uses[identifier]] {
+					valid = false
+				}
+			}
+		}
+		if increment, ok := node.(*ast.IncDecStmt); ok {
+			if identifier, ok := increment.X.(*ast.Ident); ok && localObjects[info.Uses[identifier]] {
+				valid = false
+			}
+		}
+		return true
+	})
+	if !valid {
+		return nil, fmt.Errorf("fresh local address escaped or its value was reassigned")
+	}
+	return regions, nil
+}
+
+func x86CallerSourceFingerprint(source any) ([32]byte, error) {
+	// The parser's exported source operands/bytes contain only JSON-encodable
+	// values. Private decoder certificates are deliberately not source input.
+	encoded, err := json.Marshal(source)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return sha256.Sum256(encoded), nil
+}
+
+func x86CallerNumericWidth(object types.Object) int64 {
+	if object == nil {
+		return 0
+	}
+	basic, ok := object.Type().(*types.Basic)
+	if !ok {
+		return 0
+	}
+	switch basic.Kind() {
+	case types.Uint8, types.Int8:
+		return 1
+	case types.Uint16, types.Int16:
+		return 2
+	case types.Uint32, types.Int32, types.Float32:
+		return 4
+	case types.Uint64, types.Int64, types.Float64, types.Int, types.Uint:
+		return 8
+	default:
+		return 0
+	}
+}
diff --git a/amd64_go_caller_regions_test.go b/amd64_go_caller_regions_test.go
new file mode 100644
index 000000000..327e72646
--- /dev/null
+++ b/amd64_go_caller_regions_test.go
@@ -0,0 +1,319 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+type x86CallerTestImporter struct{}
+
+func (x86CallerTestImporter) Import(path string) (*types.Package, error) {
+	if path == "unsafe" {
+		return types.Unsafe, nil
+	}
+	panic("unexpected caller-region fixture import: " + path)
+}
+
+const x86CallerFixtureSource = `package caller
+import "unsafe"
+
+//go:noescape
+func kernel(a, b, res, length unsafe.Pointer)
+
+func Call(x, y []float32) float32 {
+	var res float32
+	length := len(x)
+	kernel(
+		unsafe.Pointer(unsafe.SliceData(x)),
+		unsafe.Pointer(unsafe.SliceData(y)),
+		unsafe.Pointer(&res),
+		unsafe.Pointer(&length))
+	return res
+}
+`
+
+const x86CallerFixtureAssembly = `TEXT ·kernel(SB),4,$0-32
+MOVQ a+0(FP),DI
+MOVQ b+8(FP),SI
+MOVQ res+16(FP),DX
+MOVQ length+24(FP),CX
+BYTE $0x55
+WORD $0x8948
+BYTE $0xe5
+LONG $0xf8e48348
+MOVL $7,AX
+MOVL AX,(DX)
+WORD $0x8948
+BYTE $0xec
+BYTE $0x5d
+BYTE $0xc3
+`
+
+func x86CallerFixture(t *testing.T, source string) (GoPackage, GoSourceSelection, Func, FuncSig) {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "caller.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{
+		Types: make(map[ast.Expr]types.TypeAndValue),
+		Defs:  make(map[*ast.Ident]types.Object),
+		Uses:  make(map[*ast.Ident]types.Object),
+	}
+	pkg, err := (&types.Config{
+		Importer: x86CallerTestImporter{},
+		Sizes:    types.SizesFor("gc", "amd64"),
+	}).Check("caller", fset, []*ast.File{file}, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := Parse(ArchAMD64, x86CallerFixtureAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	goPkg := GoPackage{Path: "caller", Types: pkg, Syntax: []*ast.File{file}}
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(goPkg, assembly, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := GoSourceSelection{
+		Fset:                  fset,
+		TypesInfo:             info,
+		Sizes:                 types.SizesFor("gc", "amd64"),
+		SelectedGoFiles:       []string{"caller.go"},
+		GoSources:             map[string][]byte{"caller.go": []byte(source)},
+		SelectedAssemblyFiles: []string{"kernel_amd64.s"},
+		Assembly:              map[string]*File{"kernel_amd64.s": assembly},
+	}
+	return goPkg, selected, assembly.Funcs[0], sigs["caller.kernel"]
+}
+
+func TestX86GoCallerRegionsDeriveActualTypedArguments(t *testing.T) {
+	pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+	proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proof == nil || proof.symbol != "caller.kernel" || len(proof.arguments) != 4 || proof.calls != 1 {
+		t.Fatalf("missing actual caller/parameter binding: %+v", proof)
+	}
+	wantKinds := []x86CallerRegionKind{x86CallerSliceInput, x86CallerSliceInput, x86CallerFreshResult, x86CallerLocalLength}
+	wantWidths := []int64{4, 4, 4, 8}
+	for index, argument := range proof.arguments {
+		if argument.kind != wantKinds[index] || argument.width != wantWidths[index] || argument.slot != int64(index*8) {
+			t.Fatalf("argument %d: %+v", index, argument)
+		}
+	}
+	// A caller producer by itself must not turn this into a raw-return pass.
+	file, err := Parse(ArchAMD64, x86CallerFixtureAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{sig.Name: sig},
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+	}); err == nil {
+		t.Fatal("region metadata without a whole-source control proof became a pass")
+	}
+}
+
+func TestX86GoCallerRegionsBindNumericalResultWidthsAndEveryCaller(t *testing.T) {
+	for _, result := range []struct {
+		name  string
+		width int64
+	}{
+		{name: "uint8", width: 1}, {name: "int8", width: 1},
+		{name: "uint16", width: 2}, {name: "int16", width: 2},
+		{name: "uint32", width: 4}, {name: "int32", width: 4}, {name: "float32", width: 4},
+		{name: "uint64", width: 8}, {name: "int64", width: 8}, {name: "float64", width: 8},
+	} {
+		t.Run(result.name, func(t *testing.T) {
+			source := strings.ReplaceAll(x86CallerFixtureSource, "float32", result.name)
+			caller := source[strings.Index(source, "func Call("):]
+			source += strings.Replace(caller, "func Call(", "func SecondCall(", 1)
+			pkg, selected, fn, sig := x86CallerFixture(t, source)
+			proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if proof.calls != 2 || proof.arguments[2].width != result.width {
+				t.Fatalf("actual typed callers/result envelope: %+v", proof)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerRegionsRejectIncompleteAndChangedSelection(t *testing.T) {
+	for _, change := range []string{
+		"missing types", "missing type info", "missing Go bytes", "missing Go AST", "changed Go bytes",
+		"extra Go bytes", "missing ASM", "extra ASM", "changed signature", "wrong parameter index", "custom registers", "wrong architecture", "missing sizes", "wrong actual sizes",
+	} {
+		t.Run(change, func(t *testing.T) {
+			pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+			arch := "amd64"
+			switch change {
+			case "missing types":
+				pkg.Types = nil
+			case "missing type info":
+				selected.TypesInfo = nil
+			case "missing Go bytes":
+				delete(selected.GoSources, "caller.go")
+			case "missing Go AST":
+				pkg.Syntax = nil
+			case "changed Go bytes":
+				selected.GoSources["caller.go"] = []byte(strings.Replace(x86CallerFixtureSource, "&res", "unsafe.SliceData(x)", 1))
+			case "extra Go bytes":
+				selected.GoSources["unselected.go"] = []byte("package caller\n")
+			case "missing ASM":
+				delete(selected.Assembly, "kernel_amd64.s")
+			case "extra ASM":
+				selected.Assembly["unselected.s"] = selected.Assembly["kernel_amd64.s"]
+			case "changed signature":
+				sig.Args = []LLVMType{I64, Ptr, Ptr, Ptr}
+			case "wrong parameter index":
+				sig.Frame.Params[0].Index, sig.Frame.Params[1].Index = 1, 0
+			case "custom registers":
+				sig.ArgRegs = []Reg{AX, BX, CX, DX}
+			case "wrong architecture":
+				arch = "arm64"
+			case "missing sizes":
+				selected.Sizes = nil
+			case "wrong actual sizes":
+				selected.Sizes = types.SizesFor("gc", "386")
+			}
+			if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, arch); err == nil || proof != nil {
+				t.Fatalf("incomplete/changed actual source got a caller certificate: %+v, %v", proof, err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerRegionsRejectUnclosedCallsAndUnsafeRegions(t *testing.T) {
+	for _, source := range []string{
+		x86CallerFixtureSource + "\nvar addressTaken = kernel\n",
+		strings.Replace(x86CallerFixtureSource, "//go:noescape", "//go:linkname kernel external.kernel", 1),
+		strings.Replace(x86CallerFixtureSource, "kernel(\n", "indirect := kernel\n\tindirect(\n", 1),
+		strings.Replace(x86CallerFixtureSource, "unsafe.Pointer(&res)", "unsafe.Pointer(unsafe.SliceData(x))", 1),
+		strings.Replace(x86CallerFixtureSource, "unsafe.Pointer(&res)", "unsafe.Pointer(uintptr(unsafe.Pointer(&res)) + 1)", 1),
+		strings.Replace(x86CallerFixtureSource, "length := len(x)", "length := 7", 1),
+		strings.Replace(x86CallerFixtureSource, "length := len(x)", "length := len(x)\n\tlength++", 1),
+		strings.Replace(x86CallerFixtureSource, "length := len(x)", "length := len(x)\n\tEscape(&res)", 1) + "\nfunc Escape(*float32) {}\n",
+		strings.Replace(x86CallerFixtureSource, "kernel(\n", "func() { kernel(\n", 1),
+	} {
+		// The last source is intentionally replaced with a valid closure below.
+		if strings.Contains(source, "func() { kernel") {
+			source = strings.Replace(source, "unsafe.Pointer(&length))", "unsafe.Pointer(&length)) }()", 1)
+		}
+		pkg, selected, fn, sig := x86CallerFixture(t, source)
+		if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64"); err == nil || proof != nil {
+			t.Fatalf("unclosed/unsafe source got a caller certificate:\n%s\n%+v, %v", source, proof, err)
+		}
+	}
+}
+
+func TestX86GoCallerRegionsRejectAssemblyCallersAndAddressTaking(t *testing.T) {
+	for _, body := range []string{
+		"CALL ·kernel(SB)",
+		"MOVQ $·kernel(SB),AX",
+		"JMP ·kernel(SB)",
+		"JMP external·unknown(SB)",
+		"BYTE $0xe8\nLONG $0",
+		"JMP AX",
+	} {
+		pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+		sibling, err := Parse(ArchAMD64, "TEXT ·Sibling(SB),4,$0-0\n"+body+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		selected.SelectedAssemblyFiles = append(selected.SelectedAssemblyFiles, "sibling_amd64.s")
+		selected.Assembly["sibling_amd64.s"] = sibling
+		if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64"); err == nil || proof != nil {
+			t.Fatalf("unregistered assembly caller got a certificate: %s: %+v, %v", body, proof, err)
+		}
+	}
+}
+
+func TestX86GoCallerRegionsRejectAssemblyMemorySymbolExposure(t *testing.T) {
+	pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+	sibling, err := Parse(ArchAMD64, "TEXT ·Sibling(SB),4,$0-0\nMOVQ (AX),BX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The actual parser usually spells SB references as OpSym. A compiler's
+	// selected File may also carry a symbolic memory operand; closure must
+	// inspect that representation rather than silently treating it as numeric.
+	sibling.Funcs[0].Instrs[1].Args[0].Mem.Sym = "·kernel(SB)"
+	selected.SelectedAssemblyFiles = append(selected.SelectedAssemblyFiles, "sibling_amd64.s")
+	selected.Assembly["sibling_amd64.s"] = sibling
+	if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64"); err == nil || proof != nil {
+		t.Fatalf("assembly memory exposed entry without closing its callers: %+v, %v", proof, err)
+	}
+}
+
+func TestX86GoCallerRegionsKeepIndependentSourceAndSignatureSnapshots(t *testing.T) {
+	pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+	proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := proof.source
+	fn.Instrs[1].Args[0].FPOffset = 8
+	sig.Args[0] = I64
+	sig.Frame.Params[0].Offset = 8
+	selected.GoSources["caller.go"][0] = 'X'
+	after, err := x86CallerSourceFingerprint(fn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proof.source != before || proof.source == after ||
+		proof.signature.Args[0] != Ptr || proof.signature.Frame.Params[0].Offset != 0 ||
+		proof.goSources["caller.go"] == sha256.Sum256(selected.GoSources["caller.go"]) {
+		t.Fatal("mutable compiler inputs changed an already-produced witness")
+	}
+}
+
+func TestX86CallerSourceFingerprintRejectsOpaqueInput(t *testing.T) {
+	if _, err := x86CallerSourceFingerprint(make(chan int)); err == nil {
+		t.Fatal("opaque input acquired a source fingerprint")
+	}
+}
+
+func TestX86GoCallerRegionsRejectEditedASTWithStaleTypeInfo(t *testing.T) {
+	pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+	changed := false
+	ast.Inspect(pkg.Syntax[0], func(node ast.Node) bool {
+		if changed {
+			return false
+		}
+		address, ok := node.(*ast.UnaryExpr)
+		if !ok || address.Op != token.AND {
+			return true
+		}
+		identifier, ok := address.X.(*ast.Ident)
+		if ok && identifier.Name == "res" {
+			identifier.Name = "length"
+			changed = true
+		}
+		return true
+	})
+	selected.GoSources["caller.go"] = []byte(strings.Replace(x86CallerFixtureSource, "&res", "&length", 1))
+	if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64"); err == nil || proof != nil {
+		t.Fatalf("edited AST retained stale typechecked local identity: %+v, %v", proof, err)
+	}
+}
+
+func TestX86GoCallerRegionsRejectAssemblyDataAddressTaking(t *testing.T) {
+	pkg, selected, fn, sig := x86CallerFixture(t, x86CallerFixtureSource)
+	selected.Assembly["kernel_amd64.s"].Data = []DataStmt{{
+		Sym: "entryAddress", Width: 8, Addr: "·kernel(SB)",
+	}}
+	if proof, err := deriveX86GoCallerRegions(pkg, selected, fn, sig, "amd64"); err == nil || proof != nil {
+		t.Fatalf("assembly DATA exposed a closed entry: %+v, %v", proof, err)
+	}
+}
diff --git a/amd64_go_caller_sad.go b/amd64_go_caller_sad.go
new file mode 100644
index 000000000..cebdbd4be
--- /dev/null
+++ b/amd64_go_caller_sad.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+func x86CallerSADStep(ins *Instr, form x86PackedSADForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	if form.memory >= 0 {
+		// A selected dword or zero mask does not shrink the native access.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	var known uint64
+	for output := 0; output < form.byteWidth; output += 2 {
+		a, b := form.wordInputs(output)
+		if first&a == a && second&b == b {
+			known |= uint64(3) << uint(output)
+		}
+	}
+	if form.constantZero(*ins) {
+		known = width
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_sad_test.go b/amd64_go_caller_sad_test.go
new file mode 100644
index 000000000..363137290
--- /dev/null
+++ b/amd64_go_caller_sad_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerSADOriginalRawEffect(t *testing.T) {
+	// Unchanged instruction from Weaviate v1.39.6 hamming_avx256_amd64.s:77.
+	// The independent fixture binds its own complete selected typed callers;
+	// it does not borrow the external kernel's unresolved loop/frame contract.
+	body := "VMOVDQU (DI),Y2\nVMOVDQU (SI),Y5\nLONG $0xeaf6d5c5\nVMOVSS X5,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86GoCallerSADCompleteMemoryMaskAndAliasForms(t *testing.T) {
+	for _, row := range x86SADRows("amd64") {
+		// This caller fixture binds ordinary slice data, not arbitrary SB or
+		// segment sources. Those accepted table forms have separate objects.
+		if strings.Contains(row, "(FS)") || strings.Contains(row, "(GS)") || strings.Contains(row, "(SB)") {
+			continue
+		}
+		// Rebind only register/address tokens, never the immediate selector.
+		row = strings.NewReplacer(
+			"16(AX)(BX*2)", "(DI)", "(AX)", "(DI)",
+			"X15", "X2", "Y15", "Y2", "Z15", "Z2",
+			"X31", "X1", "Y31", "Y1", "Z31", "Z1",
+			"X30", "X2", "Y30", "Y2", "Z30", "Z2",
+			"X7", "X2", "Y7", "Y2", "Z7", "Z2",
+		).Replace(row)
+		args := strings.Split(strings.SplitN(row, " ", 2)[1], ",")
+		index := args[len(args)-1][1:]
+		body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\nKMOVQ AX,K7\n" + row + "\nVMOVSS X" + index + ",(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		t.Run(row, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerSADMemoryCertificatesBindCompleteInstruction(t *testing.T) {
+	for _, row := range []string{"PSADBW (DI),X0", "MPSADBW $5,(DI),X0", "VPSADBW (DI),Y0,Y2", "VMPSADBW $37,(DI),Y0,Y2", "VDBPSADBW.Z $228,(DI),Z0,K1,Z2"} {
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS X2,(DX)"
+		if !strings.HasPrefix(row, "V") {
+			body = strings.Replace(body, "VMOVSS X2", "VMOVSS X0", 1)
+		}
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86PackedSADProperties(ins, "amd64")
+			if !known || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			access, exists := ins.x86CallerMemory[form.memory]
+			if !exists || access.write || access.width != int64(form.memoryBytes) || !x86CallerMemoryCertified(ins, form.memory) {
+				t.Fatal("SAD lost its exact native full-read witness")
+			}
+			for _, change := range []string{"opcode", "immediate", "width", "address", "destination", "direction", "mask", "address size"} {
+				mutated := ins
+				mutated.Args = append([]Operand(nil), ins.Args...)
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+				switch change {
+				case "opcode":
+					mutated.Op = "VPMADDUBSW"
+				case "immediate":
+					if form.spec.kind != amd64PackedSADBlockSum {
+						mutated.Args[0].Imm++
+					} else {
+						mutated.Args = append([]Operand{{Kind: OpImm, Imm: 1}}, mutated.Args...)
+					}
+				case "width":
+					access.width--
+					mutated.x86CallerMemory[form.memory] = access
+				case "address":
+					mutated.Args[form.memory].Mem.Off++
+				case "destination":
+					mutated.Args[form.destination].Reg = "X7"
+				case "direction":
+					access.write = true
+					mutated.x86CallerMemory[form.memory] = access
+				case "mask":
+					if form.mask >= 0 {
+						mutated.Args[form.mask].Reg = "K7"
+					} else {
+						mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K1"})
+					}
+				case "address size":
+					mutated.x86AddressBits = 32
+				}
+				if x86CallerMemoryCertified(mutated, form.memory) {
+					t.Fatalf("%s stale %s permission survived", row, change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("no consumed SAD memory instruction")
+		}
+	}
+}
+
+func TestX86GoCallerSADRetainsUnprovedSourcesAndEnvelopes(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":       "VMOVUPS (DI),Y1\nVPSADBW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown second":      "VMOVUPS (DI),Y0\nVPSADBW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+		"unknown legacy":      "MOVUPS (DI),X0\nMPSADBW $5,X0,X1\nVMOVSS X1,(DX)",
+		"unknown upper":       "MOVUPS (DI),X0\nMOVUPS (SI),X1\nVPSADBW Y0,Y1,Y2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":        "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVDBPSADBW.Z $228,Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":       "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\nVDBPSADBW $228,Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":        "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVDBPSADBW.Z $228,Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask full read": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVDBPSADBW.Z $0,(DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"selected full read":  "VMOVUPS (DI),X0\nMPSADBW $0,(CX),X0\nVMOVSS X0,(DX)",
+		"unknown address":     "VMOVUPS (DI),Y0\nVPSADBW (BX),Y0,Y1\nVMOVSS X1,(DX)",
+		"private SP":          "VMOVUPS (DI),X0\nPSADBW (SP),X0\nVMOVSS X0,(DX)",
+		"private alias":       "VMOVUPS (DI),X0\nMOVQ BP,BX\nMPSADBW $0,(BX),X0\nVMOVSS X0,(DX)",
+		"input write":         "VMOVUPS (DI),X0\nPSADBW X0,X0\nVMOVSS X0,(DI)",
+		"undefined join":      "VMOVUPS (DI),Y0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Y1\njoined:\nVPSADBW Y0,Y1,Y2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("SAD became unproved source permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerSADIndependentByteDependencies(t *testing.T) {
+	// All selectors and widths are compared to perturbations of an independent
+	// numeric reference, not expectations generated by the production masks.
+	for _, kind := range []string{"PSADBW", "MPSADBW", "VDBPSADBW"} {
+		for _, width := range []int{16, 32, 64} {
+			if kind == "MPSADBW" && width == 64 {
+				continue
+			}
+			for control := 0; control < 256; control++ {
+				form := x86PackedSADForm{spec: amd64PackedSADSpecs[Op(kind)], immediate: uint8(control)}
+				form.byteWidth = width
+				for output := 0; output < width; output += 2 {
+					var first, second uint64
+					for input := 0; input < width; input++ {
+						a, b := make([]byte, width), make([]byte, width)
+						a[input] = 1
+						if x86SADReference(kind, width, control, a, b)[output/2] != 0 {
+							first |= uint64(1) << uint(input)
+						}
+						a[input], b[input] = 0, 1
+						if x86SADReference(kind, width, control, a, b)[output/2] != 0 {
+							second |= uint64(1) << uint(input)
+						}
+					}
+					a, b := form.wordInputs(output)
+					if first != a || second != b {
+						t.Fatalf("%s width%d imm%d word%d: %x/%x != %x/%x", kind, width, control, output/2, a, b, first, second)
+					}
+				}
+			}
+		}
+	}
+	for _, row := range []string{"PSADBW X0,X1", "VPSADBW Y0,Y1,Y2", "MPSADBW $5,X0,X1", "VMPSADBW $37,Y0,Y1,Y2", "VDBPSADBW.Z $228,Z0,Z1,K1,Z2"} {
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86PackedSADProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, defined := range []uint64{0, 15, 255, 65535, 0xffffffff, ^uint64(0)} {
+			state := &x86SourceStackState{vectors: map[Reg]uint64{"Z0": defined, "Z1": defined, "Z2": 0}, masks: map[Reg]bool{"K1": true}}
+			if !x86CallerSADStep(&ins, form, state, nil) {
+				t.Fatal("register effect failed")
+			}
+			got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]
+			var want uint64
+			for output := 0; output < form.byteWidth; output += 2 {
+				first, second := form.wordInputs(output)
+				if defined&first == first && defined&second == second {
+					want |= uint64(3) << uint(output)
+				}
+			}
+			if !form.legacy {
+				want |= ^x86CallerVectorByteMask(int64(form.byteWidth))
+			} else {
+				want |= defined &^ x86CallerVectorByteMask(int64(form.byteWidth))
+			}
+			if got != want {
+				t.Fatal(fmt.Sprintf("ordered %s: %x != %x", row, got, want))
+			}
+		}
+	}
+}
+
+func TestX86GoCallerSADCompleteNamedFamily(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		result      string
+	}{
+		{"PSADBW X0,X1", "X1"},
+		{"VPSADBW Y0,Y1,Y2", "X2"},
+		{"MPSADBW $5,X0,X1", "X1"},
+		{"VMPSADBW $37,Y0,Y1,Y2", "X2"},
+		{"VDBPSADBW $228,Z0,Z1,K1,Z2", "X2"},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row.instruction + "\nVMOVSS " + row.result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_saved_g.go b/amd64_go_caller_saved_g.go
new file mode 100644
index 000000000..f64e8f339
--- /dev/null
+++ b/amd64_go_caller_saved_g.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import "strings"
+
+// Incoming g is opaque, not an initialized number or caller data pointer.
+// Only an exact native-width private PUSH/POP may save/restore its identity.
+// All non-stack uses still consume the actual caller's byte/provenance proof.
+func x86SourceGRegister(register Reg) bool {
+	root, valid := amd64FullRegBase(register)
+	return valid && root == "R14"
+}
+
+func x86SourceGOperand(instruction Instr) bool {
+	for _, operand := range instruction.Args {
+		if operand.Kind == OpReg && x86SourceGRegister(operand.Reg) ||
+			operand.Kind == OpMem && (x86SourceGRegister(operand.Mem.Base) || x86SourceGRegister(operand.Mem.Index)) {
+			return true
+		}
+	}
+	return false
+}
+
+func x86CallerGDefinition(instruction Instr, state *x86SourceStackState) {
+	op := Op(normalizeInstructionOpcode(instruction.Op))
+	if _, stack := amd64StackWidthSpecs[op]; stack {
+		return // Stack transfer already consumed its exact opaque/numeric cell.
+	}
+	if op == OpTEXT || op == OpLABEL || op == OpRET || op == OpJMP || isAMD64ConditionalBranch(op) ||
+		strings.HasPrefix(string(op), "CMP") || strings.HasPrefix(string(op), "TEST") {
+		return
+	}
+	if count := len(instruction.Args); count != 0 {
+		destination := instruction.Args[count-1]
+		if destination.Kind == OpReg && x86SourceGRegister(destination.Reg) {
+			// Called only after the registered family's complete must-defined
+			// and pointer effects succeeded. No instruction can define the
+			// original g; every source return needs an exact saved token POP.
+			state.gOriginal = false
+		}
+	}
+}
diff --git a/amd64_go_caller_saved_g_runtime_test.go b/amd64_go_caller_saved_g_runtime_test.go
new file mode 100644
index 000000000..52c769c4c
--- /dev/null
+++ b/amd64_go_caller_saved_g_runtime_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerSavedGRuntimeAssembly(assembly, mode string) string {
+	// Reuse independent W/L/Q LEA mathematics, including preservation of the
+	// initialized high bytes. The incoming g never supplies numerical data.
+	assembly = strings.ReplaceAll(assembly, "AX", "R14")
+	save, restore := "WORD $0x5641\n", "WORD $0x5e41\n"
+	if mode == "named" {
+		save, restore = "PUSHQ R14\n", "POPQ R14\n"
+	} else if mode == "nested" {
+		save = "PUSHQ R14\nMOVQ $91,R14\nPUSHQ R14\n"
+		restore = "POPQ R14\nPOPQ R14\n"
+	}
+	assembly = strings.ReplaceAll(assembly, "LONG $0xf8e48348\n", "LONG $0xf8e48348\n"+save)
+	return strings.ReplaceAll(assembly, "WORD $0x8948\nBYTE $0xec", restore+"WORD $0x8948\nBYTE $0xec")
+}
+
+func x86CallerSavedGOriginalObserver() (goTest, assembly string) {
+	var source strings.Builder
+	source.WriteString(`
+// This native observer is a separate test-only oracle, never a numerical
+// input or declaration used to authorize the translated caller's source.
+func savedGContext() (gvalue, spvalue, bpvalue uint64)
+func TestOriginalSavedGContext(t *testing.T) {
+ for iteration := 0; iteration < 64; iteration++ {
+`)
+	for _, form := range x86CallerLEARuntimeForms() {
+		fmt.Fprintf(&source, `
+  {
+   x, y := []uint64{11,23}, []uint64{29,31}
+   beforeG, beforeSP, beforeBP := savedGContext()
+   _ = Call%s(x,y)
+   afterG, afterSP, afterBP := savedGContext()
+   if beforeG == 0 || beforeG != afterG || beforeSP != afterSP || beforeBP != afterBP {
+    t.Fatalf("%s changed native caller context g=%%x/%%x SP=%%x/%%x BP=%%x/%%x",
+     beforeG,afterG,beforeSP,afterSP,beforeBP,afterBP)
+   }
+  }
+`, form.name, form.name)
+	}
+	source.WriteString(" }\n}\n")
+	return source.String(), `TEXT ·savedGContext(SB),4,$0-24
+MOVQ R14,AX
+MOVQ AX,gvalue+0(FP)
+MOVQ SP,AX
+MOVQ AX,spvalue+8(FP)
+MOVQ BP,AX
+MOVQ AX,bpvalue+16(FP)
+RET
+`
+}
+
+func TestCrossLinuxRuntimeMatrixX86GoCallerPrivateSavedG(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("saved-g execution requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, mode := range []string{"raw", "named", "nested"} {
+		t.Run(mode, func(t *testing.T) {
+			goSource, original, goTest, cOracle := x86CallerLEARuntimeSources()
+			assembly := x86CallerSavedGRuntimeAssembly(original, mode)
+			observer, observerAssembly := x86CallerSavedGOriginalObserver()
+			dir := t.TempDir()
+			for name, source := range map[string]string{
+				"go.mod": "module caller\n\ngo 1.20\n", "value.go": goSource,
+				"value_amd64.s": assembly, "value_test.go": goTest + observer,
+				"context_test_amd64.s": observerAssembly,
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(stage, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+			command.Dir = dir
+			command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+				"GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+			if output, err := runtimeOracleCombinedOutput(stage, command); err != nil {
+				t.Fatalf("actual Go saved-g numerical/context oracle: %v\n%s", err, output)
+			}
+
+			pkg := x86CallerRuntimePackage(t, goSource, assembly)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			triple := testTargetTriple(runtime.GOOS, "amd64")
+			translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+				FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer translation.Module.Dispose()
+			var runner []string
+			if crossRosetta {
+				runner = []string{"/usr/bin/arch", "-x86_64"}
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "saved_g", triple,
+				translation.Module.String(), cOracle, runner)
+		})
+	}
+}
diff --git a/amd64_go_caller_saved_g_test.go b/amd64_go_caller_saved_g_test.go
new file mode 100644
index 000000000..d917be64b
--- /dev/null
+++ b/amd64_go_caller_saved_g_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86GoCallerPrivateSavedGOriginalRawPushPop(t *testing.T) {
+	for _, form := range []struct{ name, body string }{
+		// The original dot_byte_256 / hamming_512 two-byte raw words.
+		{"original raw", "WORD $0x5641\nMOVL $7,R14\nMOVL R14,AX\nWORD $0x5e41"},
+		{"named", "PUSHQ R14\nMOVL $7,R14\nMOVL R14,AX\nPOPQ R14"},
+		{"nested numerical", "PUSHQ R14\nMOVQ $19,R14\nPUSHQ R14\nMOVL $7,R14\nPOPQ R14\nMOVL R14,AX\nPOPQ R14"},
+		{"nested original", "PUSHQ R14\nPUSHQ R14\nMOVL $7,R14\nPOPQ R14\nPOPQ R14\nMOVL $7,AX"},
+		{"defined byte", "PUSHQ R14\nMOVL $0,AX\nMOVB $7,R14\nMOVB R14,AX\nPOPQ R14"},
+		{"defined word", "PUSHQ R14\nMOVL $0,AX\nMOVW $7,R14\nMOVW R14,AX\nPOPQ R14"},
+		{"defined zero", "PUSHQ R14\nXORQ R14,R14\nMOVL R14,AX\nPOPQ R14"},
+		{"actual caller pointer", "PUSHQ R14\nMOVQ DI,R14\nMOVL (R14),AX\nPOPQ R14"},
+		{"identical joins", "PUSHQ R14\nMOVL $7,R14\nCMPQ R14,$0\nJE joined\nMOVL $7,R14\njoined:\nMOVL R14,AX\nPOPQ R14"},
+		{"both CFG arms restore", "WORD $0x5641\nMOVL $7,R14\nCMPQ R14,$0\nJE other\nWORD $0x5e41\nJMP joined\nother:\nWORD $0x5e41\njoined:\nMOVL $7,AX"},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX", form.body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPrivateSavedGDoesNotExposeOpaqueIdentity(t *testing.T) {
+	for _, form := range []struct{ name, body string }{
+		{"entry number", "MOVL R14,AX"},
+		{"entry address", "MOVL (R14),AX"},
+		{"entry flags", "CMPQ R14,$0\nMOVL $7,AX"},
+		{"no restoration", "MOVL $7,R14\nMOVL R14,AX"},
+		{"zero is not g", "XORQ R14,R14\nMOVL R14,AX"},
+		{"saved then discarded", "PUSHQ R14\nMOVL $7,R14\nMOVL R14,AX\nADDQ $8,SP"},
+		{"saved token to ordinary GP", "PUSHQ R14\nPOPQ BX\nMOVL $7,AX"},
+		{"restored token read", "PUSHQ R14\nMOVL $7,R14\nPOPQ R14\nMOVL R14,AX"},
+		{"restored token address", "PUSHQ R14\nMOVQ DI,R14\nPOPQ R14\nMOVL (R14),AX"},
+		{"narrow original save", "PUSHW R14\nMOVW $7,R14\nMOVW R14,AX\nPOPW R14"},
+		{"narrow restoration", "PUSHQ R14\nMOVL $7,R14\nMOVL R14,AX\nPOPW R14\nADDQ $6,SP"},
+		{"unknown upper numerical bytes", "PUSHQ R14\nMOVW $7,R14\nMOVQ R14,AX\nPOPQ R14"},
+		{"byte copy cannot define full result", "PUSHQ R14\nMOVB $7,R14\nMOVB R14,AX\nPOPQ R14"},
+		{"word copy cannot define full result", "PUSHQ R14\nMOVW $7,R14\nMOVW R14,AX\nPOPQ R14"},
+		{"opaque saved stack read", "PUSHQ R14\nMOVQ 0(SP),AX\nPOPQ R14"},
+		{"opaque saved stack overwrite", "PUSHQ R14\nMOVQ $0,0(SP)\nPOPQ R14\nMOVL $7,AX"},
+		{"unknown native call", "PUSHQ R14\nCALL ·unknown(SB)\nPOPQ R14\nMOVL $7,AX"},
+		{"one unbalanced CFG arm", "PUSHQ R14\nMOVL $7,R14\nCMPQ R14,$0\nJE joined\nPOPQ R14\njoined:\nMOVL $7,AX"},
+		{"one CFG arm loses g", "WORD $0x5641\nMOVL $7,R14\nCMPQ R14,$0\nJE other\nWORD $0x5e41\nJMP joined\nother:\nADDQ $8,SP\njoined:\nMOVL $7,AX"},
+		{"g is not the input pointer", "PUSHQ R14\nMOVQ DI,R14\nMOVQ R14,(DX)\nPOPQ R14\nMOVL $7,AX"},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX", form.body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("opaque or unrestored g acquired source continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPrivateSavedGRequiresActualCallerSelection(t *testing.T) {
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX",
+		"PUSHQ R14\nMOVL $7,R14\nMOVL R14,AX\nPOPQ R14", 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	pkg.SourceSelection = nil
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("bare declaration acquired numerical g permission: %v", err)
+	}
+}
+
+func TestX86GoCallerPrivateSavedGRejectsUnprovedLeafFallback(t *testing.T) {
+	for _, body := range []string{
+		"MOVQ R14,AX",
+		"MOVQ $7,R14\nMOVQ R14,AX",
+		"XORQ R14,R14\nMOVQ R14,AX",
+	} {
+		t.Run(body, func(t *testing.T) {
+			source, sig, pkg := x86SourceStackNumericalFixture("amd64",
+				body+"\nMOVQ AX,ret+8(FP)\nBYTE $0xc3")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := x86SourceStackOptions("amd64", "x86_64-unknown-linux-gnu", sig)
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("text API trusted unproved incoming/clobbered g: %v", err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if module != (llvm.Module{}) {
+				module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("module API trusted unproved incoming/clobbered g: %v", err)
+			}
+			translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			})
+			if translation != nil {
+				translation.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("declaration API trusted unproved incoming/clobbered g: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_sign_extend_test.go b/amd64_go_caller_sign_extend_test.go
new file mode 100644
index 000000000..9da80c197
--- /dev/null
+++ b/amd64_go_caller_sign_extend_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedSignExtendIndependentInitializedNamedRole(t *testing.T) {
+	// This exact body was the old "signed not inherited" negative. With the
+	// independently registered named SX family it is a valid initialized
+	// program, not permission inherited from the still-disjoint ZX registry.
+	const body = "VMOVUPS (DI),X0\nVPMOVSXBD X0,Y1\nVMOVSS X1,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	ins := x86ScalarLaneInstruction(t, "VPMOVSXBD X0,Y1")
+	if _, known, _ := x86PackedZeroExtendProperties(ins, "amd64"); known || x86RawZeroExtendSource(ins, "amd64") {
+		t.Fatal("genuine named SX silently entered the ZX membership or raw identity")
+	}
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal("original complete initialized signed caller program rejected", err)
+	}
+}
+
+func TestX86GoCallerPackedSignExtendPartialSignByteKnowledge(t *testing.T) {
+	for _, ratio := range x86PackedSignExtendOracleRatios {
+		for _, mode := range []string{"signed-known", "signed-missing", "zero-known-independent"} {
+			t.Run(ratio.suffix+"/"+mode, func(t *testing.T) {
+				at, stem := ratio.input-1, "VPMOVSX"
+				if mode != "signed-known" {
+					at++ // Only an unrelated byte is available; the first lane's sign byte is absent.
+				}
+				if mode == "zero-known-independent" {
+					stem = "VPMOVZX"
+				}
+				// Observe only the first lane's first extension byte. SX depends
+				// on its actual last input byte even when lower bytes are absent;
+				// ZX defines the same extension byte independently as zero.
+				body := fmt.Sprintf("PINSRB $%d,AX,X0\n%s%s X0,X1\nPEXTRB $%d,X1,AX\nMOVL AX,(DX)", at, stem, ratio.suffix, ratio.input)
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+				if mode == "signed-missing" {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("a missing sign byte acquired a numerical caller result", err)
+					}
+				} else if err != nil {
+					t.Fatal("independent selected sign/constant-zero byte control rejected", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_go_caller_signed_integer_float.go b/amd64_go_caller_signed_integer_float.go
new file mode 100644
index 000000000..45a4623b4
--- /dev/null
+++ b/amd64_go_caller_signed_integer_float.go
@@ -0,0 +1,20 @@
+package plan9asm
+
+func x86CallerSignedIntegerFloatStep(ins *Instr, f x86SignedIntegerFloatForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if f.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.sourceBits/8), false) {
+			return false
+		}
+	} else if !x86CallerNumericRead(ins.Args[0], int64(f.sourceBits/8), state) {
+		return false
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	low := x86CallerVectorByteMask(int64(f.spec.resultBits / 8))
+	if f.spec.legacy {
+		state.vectors[destination] |= low
+	} else {
+		upper := state.vectors[x86CallerVectorRoot(ins.Args[f.upper].Reg)]
+		state.vectors[destination] = ^x86CallerVectorByteMask(16) | low | upper&(x86CallerVectorByteMask(16)&^low)
+	}
+	return true
+}
diff --git a/amd64_go_caller_signed_integer_float_runtime_test.go b/amd64_go_caller_signed_integer_float_runtime_test.go
new file mode 100644
index 000000000..f87f2ed5e
--- /dev/null
+++ b/amd64_go_caller_signed_integer_float_runtime_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatActualCaller(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		t.Run(op, func(t *testing.T) {
+			goSource, bits, resultBits := x86CallerFixtureSource, 32, 32
+			load, store, args := "MOVL (DI),AX", "MOVSS X1,(DX)", "AX,X1"
+			if strings.Contains(op, "Q") {
+				bits, load = 64, "MOVQ (DI),AX"
+			}
+			if strings.Contains(op, "SD") {
+				resultBits, store = 64, "MOVSD X1,(DX)"
+				goSource = strings.Replace(goSource, ") float32 {", ") float64 {", 1)
+				goSource = strings.Replace(goSource, "var res float32", "var res float64", 1)
+			}
+			if strings.HasPrefix(op, "V") {
+				args = "AX,X0,X1"
+			}
+			body := load + "\n" + op + " " + args + "\n" + store
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, goSource, assembly)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+				FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+			})
+			if translation != nil && !translation.Module.IsNil() {
+				defer translation.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			main := x86SignedIntegerFloatSSEOracle + fmt.Sprintf(`
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+extern void kernel(const void*,const void*,void*,const void*) __asm__(LABEL("caller.kernel"));
+int main(void){
+ for(unsigned sample=0;sample<256;sample++)for(unsigned mode=0;mode<4;mode++){
+  uint64_t a[2]={UINT64_C(0xd31733a6287fbbc3)*sample+UINT64_C(0x1000001),UINT64_C(0x789abcdef1234567)};
+  uint64_t b[2]={12,13},aCopy[2],bCopy[2];memcpy(aCopy,a,sizeof(a));memcpy(bCopy,b,sizeof(b));
+  uint8_t out[16];memset(out,0xc3,sizeof(out));uint64_t length=4;
+  unsigned csr=0x9fc5|(mode<<13),after;uint64_t want=sse_convert(a[0],%d,%d,csr);unsigned expectedCSR=sse_csr;
+  __asm__ volatile("ldmxcsr %%0"::"m"(csr):"memory");kernel(a,b,out+1,&length);
+  __asm__ volatile("stmxcsr %%0":"=m"(after));uint64_t got=0;memcpy(&got,out+1,%d);
+  if(got!=want||after!=expectedCSR){fprintf(stderr,"actual caller %s input=%%llx got=%%llx want=%%llx csr=%%x want=%%x\n",(unsigned long long)a[0],(unsigned long long)got,(unsigned long long)want,after,expectedCSR);return 1;}
+  for(unsigned i=0;i<sizeof(out);i++)if((i==0||i>%d)&&out[i]!=0xc3)return 2;
+  if(memcmp(a,aCopy,sizeof(a))||memcmp(b,bCopy,sizeof(b))||length!=4)return 3;
+ }
+ unsigned csr=0x1f80;__asm__ volatile("ldmxcsr %%0"::"m"(csr));return 0;
+}
+`, bits, resultBits, resultBits/8, op, resultBits/8)
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-float-caller", triple, x86SignedIntegerFloatOptimize(t, translation.Module.String()), main, prefix)
+		})
+	}
+}
diff --git a/amd64_go_caller_signed_integer_float_test.go b/amd64_go_caller_signed_integer_float_test.go
new file mode 100644
index 000000000..708f54922
--- /dev/null
+++ b/amd64_go_caller_signed_integer_float_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerSignedIntegerFloatCompleteFamily(t *testing.T) {
+	for _, row := range x86SignedIntegerFloatRows("amd64") {
+		row = strings.ReplaceAll(strings.Replace(row, "8(BX)", "(DI)", 1), "(BX)(SI*4)", "(DI)")
+		body := "VMOVUPS (SI),Z0\nVMOVUPS (SI),Z1\n" + row + "\nVMOVSS X1,(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+			t.Fatalf("%s: %v", row, err)
+		}
+	}
+}
+
+func TestX86GoCallerSignedIntegerFloatByteKnowledge(t *testing.T) {
+	for _, row := range x86SignedIntegerFloatRows("amd64") {
+		if strings.Contains(row, "(BX)") {
+			continue
+		}
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		f, _, err := x86SignedIntegerFloatProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for known := uint8(0); ; known++ {
+			state := x86SourceStackState{known: map[Reg]uint8{AX: known}, callers: map[Reg]x86CallerPointerValue{}, vectors: map[Reg]uint64{"Z0": 0x5500, "Z1": 0xaaff0000}, masks: map[Reg]bool{}}
+			accepted := x86CallerSignedIntegerFloatStep(&ins, f, &state, nil)
+			mask := uint8((1 << uint(f.sourceBits/8)) - 1)
+			if accepted != (known&mask == mask) {
+				t.Fatalf("%s GP knowledge %x: %t", row, known, accepted)
+			}
+			if accepted {
+				low := x86CallerVectorByteMask(int64(f.spec.resultBits / 8))
+				want := uint64(0xaaff0000) | low
+				if !f.spec.legacy {
+					want = ^uint64(0xffff) | low | (0x5500 & (uint64(0xffff) &^ low))
+				}
+				if state.vectors["Z1"] != want {
+					t.Fatalf("%s invented upper byte knowledge: %x want %x", row, state.vectors["Z1"], want)
+				}
+			}
+			if known == 255 {
+				break
+			}
+		}
+	}
+}
+
+func TestX86GoCallerSignedIntegerFloatUnknownPermissionsRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"pointer bits":              "VCVTSI2SSL DI,X0,X1\nVMOVSS X1,(DX)",
+		"stack bits":                "CVTSQ2SS SP,X1\nVMOVSS X1,(DX)",
+		"g bits":                    "VCVTSI2SSL R14,X0,X1\nVMOVSS X1,(DX)",
+		"undefined GP":              "VCVTSI2SSQ R11,X0,X1\nVMOVSS X1,(DX)",
+		"partial GP":                "MOVB $7,R11\nCVTSL2SS R11,X1\nVMOVSS X1,(DX)",
+		"source SP":                 "VCVTSI2SSL (SP),X0,X1\nVMOVSS X1,(DX)",
+		"unknown memory":            "VCVTSI2SSL (R11),X0,X1\nVMOVSS X1,(DX)",
+		"pointer FP":                "VCVTSI2SSL a+0(FP),X0,X1\nVMOVSS X1,(DX)",
+		"unknown upper passthrough": "VCVTSI2SSL AX,X0,X1\nVEXTRACTPS $3,X1,AX\nMOVL AX,(DX)",
+		"CFG undefined GP":          "CMPQ AX,$0\nJE join\nMOVL $7,R11\njoin:\nVCVTSI2SSL R11,X0,X1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown permission became success: %v", err)
+			}
+		})
+	}
+	// A numerical low result is independent of undefined passthrough bytes.
+	for _, op := range []string{"CVTSL2SS", "VCVTSI2SSL"} {
+		args := "AX,X1"
+		if strings.HasPrefix(op, "V") {
+			args = "AX,X0,X1"
+		}
+		body := fmt.Sprintf("%s %s\nVMOVSS X1,(DX)", op, args)
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/amd64_go_caller_signed_packed_float.go b/amd64_go_caller_signed_packed_float.go
new file mode 100644
index 000000000..35f30ff85
--- /dev/null
+++ b/amd64_go_caller_signed_packed_float.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+func x86CallerSignedPackedFloatStep(ins *Instr, f x86SignedPackedFloatForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	// Virtual MMX has no complete public caller x87/tag/physical alias contract.
+	if f.mmx || f.mask >= 0 && !state.masks[ins.Args[f.mask].Reg] {
+		return false
+	}
+	if f.memory >= 0 {
+		source := ins.Args[f.memory]
+		if source.Kind == OpFP || source.Kind == OpMem &&
+			(source.Mem.Base == SP || source.Mem.Base == BP || source.Mem.Index == BP) {
+			return false
+		}
+		// The full potential tuple, even for inactive masks, is read-only input.
+		// The actual native opcode retains lane fault suppression; initialized
+		// masks do not authorize missing bytes or writable input pointers.
+		if !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.memoryBytes), false) {
+			return false
+		}
+	} else {
+		input := state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]
+		mask := x86CallerVectorByteMask(int64(f.inputBytes))
+		if input&mask != mask {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	width := x86CallerVectorByteMask(int64(f.byteWidth))
+	old := state.vectors[destination]
+	if f.mask >= 0 && !f.zeroing && old&width != width {
+		return false
+	}
+	if f.spec.legacy {
+		state.vectors[destination] = old&^width | width
+	} else {
+		state.vectors[destination] = ^uint64(0)
+	}
+	return true
+}
diff --git a/amd64_go_caller_signed_packed_float_test.go b/amd64_go_caller_signed_packed_float_test.go
new file mode 100644
index 000000000..26dfafee9
--- /dev/null
+++ b/amd64_go_caller_signed_packed_float_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86SignedPackedIntegerFloatCallerCompleteInitializedForms(t *testing.T) {
+	for _, op := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+		banks := []string{"X"}
+		if strings.HasPrefix(op, "V") {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			src := bank
+			if strings.HasSuffix(op, "PD") {
+				src = "X"
+				if bank == "Z" {
+					src = "Y"
+				}
+			}
+			modes := []string{""}
+			if strings.HasPrefix(op, "V") {
+				modes = []string{"", "K1,", "K7,"}
+			}
+			for _, input := range []string{src + "0", "(DI)"} {
+				for _, mode := range modes {
+					name := op
+					if mode == "K7," {
+						name += ".Z"
+					}
+					row := fmt.Sprintf("%s %s,%s%s1", name, input, mode, bank)
+					t.Run(row, func(t *testing.T) {
+						body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nKMOVQ AX,K1\nKMOVQ AX,K7\n" + row + "\nVMOVSS X1,(DX)"
+						assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+						goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+						pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+						if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+							t.Fatal(err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatCallerRetainsFailures(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown input":          "VCVTDQ2PS Y0,Y1\nVMOVSS X1,(DX)",
+		"partial dword":          "MOVSS (DI),X2\nMOVSS X2,X0\nCVTPL2PS X0,X1\nVMOVSS X1,(DX)",
+		"unknown merge":          "VMOVUPS (DI),Z0\nKMOVQ AX,K1\nVCVTDQ2PS Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"unknown mask":           "VMOVUPS (DI),Z0\nVCVTDQ2PS.Z Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"pointer mask":           "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVCVTDQ2PS.Z Z0,K1,Z1\nVMOVSS X1,(DX)",
+		"unknown base":           "VCVTDQ2PD (BX),Y1\nVMOVSS X1,(DX)",
+		"private stack":          "VCVTDQ2PS (SP),Y1\nVMOVSS X1,(DX)",
+		"FP pointer data":        "CVTPL2PD a+0(FP),X1\nVMOVSS X1,(DX)",
+		"zero mask envelope":     "MOVL $0,AX\nKMOVQ AX,K1\nVCVTDQ2PS.Z (DX),K1,Z1\nVMOVSS X1,(DX)",
+		"source write":           "VCVTDQ2PS (DI),Y1\nVMOVSS X1,(DI)",
+		"wide result":            "VCVTDQ2PD (DI),Y1\nVMOVUPS Y1,(DX)",
+		"join":                   "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),Y0\njoined:\nVCVTDQ2PS Y0,Y1\nVMOVSS X1,(DX)",
+		"unknown upper alias":    "VMOVUPS (DI),X0\nCVTPL2PS X0,X1\nVCVTDQ2PS Y1,Y2\nVMOVSS X2,(DX)",
+		"MMX transport":          "MOVQ (DI),M0\nCVTPL2PS M0,X1\nVMOVSS X1,(DX)",
+		"unsigned unknown upper": "MOVOU (DI),X0\nVCVTUDQ2PS Y0,Y1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved conversion got caller permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86SignedPackedIntegerFloatGPTransferDefinesCompleteXInput(t *testing.T) {
+	// MOVQ GP -> X initializes the low qword and zeroes all remaining X
+	// bytes. In contrast, the register MOVSS negative above preserves the
+	// unknown upper twelve bytes of its destination.
+	body := "MOVQ AX,X0\nCVTPL2PS X0,X1\nVMOVSS X1,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal("complete GP/X input lost its caller-defined bytes", err)
+	}
+}
+
+func TestX86SignedPackedIntegerFloatIndependentByteEffects(t *testing.T) {
+	for _, row := range x86SignedPackedFloatRows("amd64") {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		f, _, err := x86SignedPackedFloatProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if f.memory >= 0 || f.mmx {
+			continue
+		}
+		for missing := -1; missing < f.inputBytes; missing++ {
+			input := x86CallerVectorByteMask(int64(f.inputBytes))
+			if missing >= 0 {
+				input &^= uint64(1) << uint(missing)
+			}
+			for _, old := range []uint64{0, ^uint64(0)} {
+				state := x86SourceStackState{vectors: map[Reg]uint64{x86CallerVectorRoot(ins.Args[0].Reg): input}, masks: map[Reg]bool{"K1": true, "K3": true, "K7": true}}
+				destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+				if destination != x86CallerVectorRoot(ins.Args[0].Reg) {
+					state.vectors[destination] = old
+				} else {
+					old = input
+				}
+				valid := missing < 0 && (f.mask < 0 || f.zeroing || old&x86CallerVectorByteMask(int64(f.byteWidth)) == x86CallerVectorByteMask(int64(f.byteWidth)))
+				if got := x86CallerSignedPackedFloatStep(&ins, f, &state, nil); got != valid {
+					t.Fatalf("%s missing%d merge%016x got%t want%t", row, missing, old, got, valid)
+				}
+				if valid {
+					want := ^uint64(0)
+					if f.spec.legacy {
+						want = old | x86CallerVectorByteMask(16)
+					}
+					if state.vectors[destination] != want {
+						t.Fatal("alias/upper byte effect", row)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_go_caller_sqrt.go b/amd64_go_caller_sqrt.go
new file mode 100644
index 000000000..a459d71d4
--- /dev/null
+++ b/amd64_go_caller_sqrt.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+func x86CallerSqrtStep(ins *Instr, f x86FloatBinaryForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if f.bits == 16 {
+		return false // Raw FP16 retains its separate original-source continuation.
+	}
+	if f.mask >= 0 && !state.masks[ins.Args[f.mask].Reg] {
+		return false
+	}
+	input := state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]
+	if f.memory >= 0 {
+		// Ordinary caller bounds do not establish legacy m128 alignment.
+		if f.legacy && !f.scalar || !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.memoryBytes), false) {
+			return false
+		}
+		input = ^uint64(0)
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	upper := state.vectors[x86CallerVectorRoot(ins.Args[f.second].Reg)]
+	value, valid := x86SqrtDefinedBytes(f, input, upper, state.vectors[destination])
+	if !valid {
+		return false
+	}
+	state.vectors[destination] = value
+	return true
+}
diff --git a/amd64_go_caller_unpack.go b/amd64_go_caller_unpack.go
new file mode 100644
index 000000000..985082b1c
--- /dev/null
+++ b/amd64_go_caller_unpack.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+func x86CallerPackedUnpackStep(ins *Instr, form x86PackedUnpackForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	first := uint64(0)
+	if form.memory >= 0 {
+		// Legacy m128 needs native alignment, not just a slice-data identity.
+		// No initialized mask shrinks an E4NF read's complete native extent.
+		if form.legacy || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = width
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)] & width
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)] & width
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := x86PackedUnpackDefinedBytes(form, first, second, old)
+	if form.legacy {
+		state.vectors[destination] = old&^width | known
+	} else {
+		state.vectors[destination] = ^width | known
+	}
+	return true
+}
diff --git a/amd64_go_caller_unpack_test.go b/amd64_go_caller_unpack_test.go
new file mode 100644
index 000000000..f7311d298
--- /dev/null
+++ b/amd64_go_caller_unpack_test.go
@@ -0,0 +1,278 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CallerUnpackOpcodes() []string {
+	return []string{
+		"PUNPCKLBW", "PUNPCKHBW", "PUNPCKLWL", "PUNPCKHWL",
+		"PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PUNPCKHQDQ",
+		"UNPCKLPS", "UNPCKHPS", "UNPCKLPD", "UNPCKHPD",
+		"VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLWD", "VPUNPCKHWD",
+		"VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+		"VUNPCKLPS", "VUNPCKHPS", "VUNPCKLPD", "VUNPCKHPD",
+	}
+}
+
+func TestX86GoCallerUnpackCompleteInitializedGrammar(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		for _, original := range x86UnpackAcceptedForms(opcode, "amd64") {
+			t.Run(original, func(t *testing.T) {
+				row := strings.NewReplacer("8(AX)", "8(DI)", "X15", "X2", "X31", "X2", "Y31", "Y2", "Z31", "Z2").Replace(original)
+				body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nKMOVQ AX,K1\nKMOVQ AX,K7\n" + row + "\nVMOVSS X2,(DX)"
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+				needsContext := strings.Contains(row, "M7") || !strings.HasPrefix(opcode, "V") && strings.Contains(row, "(DI)")
+				if needsContext && !errors.Is(err, ErrProbeNeedsContext) || !needsContext && err != nil {
+					t.Fatalf("Context=%t: %v", needsContext, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerUnpackRetainsUnknownAndMemoryFailures(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":                       "VMOVUPS (DI),X1\nVPUNPCKLBW X0,X1,X2\nVMOVSS X2,(DX)",
+		"unknown second":                      "VMOVUPS (DI),X0\nVPUNPCKLBW X0,X1,X2\nVMOVSS X2,(DX)",
+		"unknown selected high bytes":         "MOVSS (DI),X0\nMOVSS X0,X1\nVUNPCKHPS X0,X1,X2\nVMOVSS X2,(DX)",
+		"unknown destructive input":           "VMOVUPS (DI),X0\nPUNPCKLBW X0,X1\nVMOVSS X1,(DX)",
+		"unknown merge":                       "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nKMOVQ AX,K1\nVPUNPCKLBW X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"unknown mask":                        "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nVPUNPCKLBW.Z X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"pointer mask":                        "VMOVUPS (DI),X0\nVMOVUPS (SI),X1\nKMOVQ DI,K1\nVPUNPCKLBW.Z X0,X1,K1,X2\nVMOVSS X2,(DX)",
+		"zero mask still full E4NF read":      "VMOVUPS (DI),X0\nMOVL $0,AX\nKMOVQ AX,K1\nVPUNPCKLDQ.Z (DX),X0,K1,X1\nVMOVSS X1,(DX)",
+		"zero mask broadcast still full read": "VMOVUPS (DI),X0\nMOVL $0,AX\nKMOVQ AX,K1\nVPUNPCKLQDQ.BCST.Z (DX),X0,K1,X1\nVMOVSS X1,(DX)",
+		"legacy alignment absent":             "VMOVUPS (DI),X0\nPUNPCKLBW (DI),X0\nVMOVSS X0,(DX)",
+		"private stack":                       "VMOVUPS (DI),X0\nVPUNPCKLBW (SP),X0,X0\nVMOVSS X0,(DX)",
+		"unknown address":                     "VMOVUPS (DI),X0\nVPUNPCKLBW (BX),X0,X0\nVMOVSS X0,(DX)",
+		"read beyond scalar length":           "VMOVUPS (DI),X0\nVPUNPCKLDQ (CX),X0,X0\nVMOVSS X0,(DX)",
+		"source write":                        "VMOVUPS (DI),X0\nVPUNPCKLBW X0,X0,X0\nVMOVSS X0,(DI)",
+		"wide result":                         "VMOVUPS (DI),X0\nVPUNPCKLBW X0,X0,X0\nVMOVUPS X0,(DX)",
+		"undefined CFG join":                  "VMOVUPS (DI),X0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),X1\njoined:\nVPUNPCKLBW X0,X1,X2\nVMOVSS X2,(DX)",
+		"MMX is a separate bank":              "PUNPCKLBW M0,M1\nVMOVSS X1,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved interleave acquired caller permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerUnpackIndependentByteKnowledge(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		widths := []int{16}
+		if strings.HasPrefix(opcode, "V") {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, destination := range []int{0, 1, 2} {
+				if !strings.HasPrefix(opcode, "V") && destination != 1 {
+					continue
+				}
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					if !strings.HasPrefix(opcode, "V") && mode != "unmasked" {
+						continue
+					}
+					row := opcode + " " + bank + "0," + bank + "1"
+					if strings.HasPrefix(opcode, "V") {
+						if mode != "unmasked" {
+							row += ",K1"
+						}
+						row += fmt.Sprintf(",%s%d", bank, destination)
+						if mode == "zero" {
+							row = strings.Replace(row, opcode, opcode+".Z", 1)
+						}
+					}
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					form, recognized, err := x86PackedUnpackProperties(ins, "amd64")
+					if !recognized || err != nil {
+						t.Fatalf("%s: %v", row, err)
+					}
+					for seed := 0; seed < 64; seed++ {
+						initial := []uint64{0x19ca786fe32a907b, 0xf6210c89d8ba3547, 0x4a3b27e806c591df}
+						for index := range initial {
+							initial[index] ^= uint64(seed+index) * 0x102030405060708
+						}
+						state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": initial[0], "Z1": initial[1], "Z2": initial[2]}, masks: map[Reg]bool{"K1": true}}
+						if !x86CallerPackedUnpackStep(&ins, form, &state, nil) {
+							t.Fatalf("register effect refused %s", row)
+						}
+						// Calculate each output byte from the source spelling and
+						// Intel's independent per-128-bit interleave definition.
+						var want uint64
+						lane := x86UnpackTestLaneBytes(opcode)
+						high := strings.Contains(opcode, "UNPCKH")
+						for output := 0; output < 64; output++ {
+							known := false
+							if output >= width {
+								known = strings.HasPrefix(opcode, "V") || initial[destination]>>uint(output)&1 != 0
+							} else {
+								pair := (output % 16) / (2 * lane)
+								sourceByte := output/16*16 + pair*lane + output%lane
+								if high {
+									sourceByte += 8
+								}
+								sourceRegister := 1
+								if output/lane%2 != 0 {
+									sourceRegister = 0
+								}
+								known = initial[sourceRegister]>>uint(sourceByte)&1 != 0
+								if mode == "merge" {
+									known = known && initial[destination]>>uint(output)&1 != 0
+								}
+							}
+							if known {
+								want |= uint64(1) << uint(output)
+							}
+						}
+						if got := state.vectors[Reg(fmt.Sprintf("Z%d", destination))]; got != want {
+							t.Fatalf("%s seed=%d: byte knowledge %#x want %#x", row, seed, got, want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerUnpackCompleteFamilyThreeAPIs(t *testing.T) {
+	var body strings.Builder
+	body.WriteString("VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\n")
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if strings.HasPrefix(opcode, "V") {
+			fmt.Fprintf(&body, "%s Z0,Z1,Z2\nVMOVSS X2,(DX)\n", opcode)
+		} else {
+			fmt.Fprintf(&body, "%s X0,X1\nVMOVSS X1,(DX)\n", opcode)
+		}
+	}
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body.String(), 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "unpack.ll", "unpack.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, triple, "unpack-module.ll", "unpack-module.o", module.String())
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerUnpackMemoryCertificatesBindFullE4NFSource(t *testing.T) {
+	for _, row := range []string{"VPUNPCKLBW (DI),X0,X2", "VUNPCKHPD.BCST.Z (DI),Z0,K1,Z2"} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n"+row+"\nVMOVSS X2,(DX)", 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, recognized, err := x86PackedUnpackProperties(ins, "amd64")
+			if !recognized || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			index := form.memory
+			access, exists := ins.x86CallerMemory[index]
+			if !exists || access.write || access.width != int64(form.memoryBytes) || !x86CallerMemoryCertified(ins, index) {
+				t.Fatal("missing full-width native read certificate")
+			}
+			for _, change := range []string{"opcode", "width", "address", "destination", "direction", "broadcast", "mask"} {
+				mutated := ins
+				mutated.Args = append([]Operand(nil), ins.Args...)
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+				switch change {
+				case "opcode":
+					mutated.Op = "VPUNPCKHBW"
+				case "width":
+					access.width--
+					mutated.x86CallerMemory[index] = access
+				case "address":
+					mutated.Args[index].Mem.Off++
+				case "destination":
+					mutated.Args[form.destination].Reg = "X3"
+				case "direction":
+					access.write = true
+					mutated.x86CallerMemory[index] = access
+				case "broadcast":
+					mutated.Op = Op(string(mutated.Op) + ".BCST")
+				case "mask":
+					if form.mask >= 0 {
+						mutated.Args[form.mask].Reg = "K2"
+					} else {
+						mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K2"})
+					}
+				}
+				if x86CallerMemoryCertified(mutated, index) {
+					t.Fatalf("%s mutation reused a stale interleave certificate", change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("no interleave instruction consumed its caller proof")
+		}
+	}
+}
+
+func TestX86GoCallerUnpackCompleteFamilyOriginalSource(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		t.Run(opcode, func(t *testing.T) {
+			operands, destination := "X0,X1", "X1"
+			if strings.HasPrefix(opcode, "V") {
+				operands, destination = "Y0,Y1,Y2", "X2"
+			}
+			body := fmt.Sprintf("VMOVUPS (DI),Y0\nVMOVUPS (SI),Y1\n%s %s\nVMOVSS %s,(DX)", opcode, operands, destination)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_vector_moves.go b/amd64_go_caller_vector_moves.go
new file mode 100644
index 000000000..a532a3a18
--- /dev/null
+++ b/amd64_go_caller_vector_moves.go
@@ -0,0 +1,545 @@
+package plan9asm
+
+import "fmt"
+
+func x86CallerVectorMoveKnown(ins Instr) bool {
+	if _, known, err := x86Permute128Properties(ins.Op, ins, "amd64"); known {
+		return err == nil && x86ResultNamedPredicateInstruction(ins) && !ins.x86Permute128VEX
+	}
+	if _, known, err := x86PackedDotProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && x86ResultNamedPredicateInstruction(ins)
+	}
+	if _, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86PackedAlignProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86SqrtProperties(ins, "amd64"); known {
+		return err == nil && form.bits != 16
+	}
+	if _, known, err := x86ByteShuffleProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86PackedConversionProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if form, known, err := x86CLMULProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && form.memory < 0
+	}
+	if _, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86ScalarLaneProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if _, known, err := x86AESProperties(ins.Op, ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86HorizontalIntegerProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if form, known, err := x86GPSIMDTransferProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx && !form.spec.rawOnly
+	}
+	if form, known, err := x86ImmediateShuffleProperties(ins, "amd64"); known {
+		return err == nil && !form.spec.mmx
+	}
+	if _, known, err := x86PackedFloatShuffleProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && x86ResultNamedPredicateInstruction(ins)
+	}
+	if form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, "amd64"); known && form.legacy {
+		return err == nil && form.memory < 0 && x86ResultNamedPredicateInstruction(ins)
+	}
+	if _, known, err := x86MaskVectorProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86PackedNarrowProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if form, known, err := x86DwordProductProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if _, known, err := x86PackedSADProperties(ins, "amd64"); known {
+		return err == nil
+	}
+	if form, known, err := x86PackedSubtractProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if _, recognized, err := x86FloatCompareProperties(ins, "amd64"); recognized {
+		return err == nil
+	}
+	if form, known, err := x86PackedWrappingAddProperties(ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if form, known, err := x86PackedMultiplyAddProperties(ins.Op, ins, "amd64"); known {
+		return err == nil && !form.mmx
+	}
+	if f, known, err := x86SignedPackedFloatProperties(ins, "amd64"); known {
+		return err == nil && !f.mmx
+	}
+	if _, recognized, err := x86FloatArithmeticProperties(ins, "amd64", ""); recognized {
+		return err == nil
+	}
+	if form, recognized, err := x86PackedExtendProperties(ins, "amd64"); recognized {
+		return err == nil && (!form.signed || x86ResultNamedPredicateInstruction(ins))
+	}
+	if _, recognized, err := x86VectorZeroProperties(ins, "amd64"); recognized {
+		return err == nil
+	}
+	if _, recognized, err := x86SignedIntegerFloatProperties(ins, "amd64"); recognized {
+		return err == nil
+	}
+	if f, recognized, err := x86InsertExtractProperties(ins, "amd64"); recognized {
+		return err == nil && !(f.mask >= 0 && f.memoryWrite)
+	}
+	if form, recognized, err := x86PackedShiftProperties(ins.Op, ins, "amd64"); recognized {
+		return err == nil && !form.mmx
+	}
+	if _, recognized, err := x86HorizontalFloatProperties(ins, "amd64"); recognized {
+		return err == nil
+	}
+	if form, recognized, err := x86PackedUnpackProperties(ins, "amd64"); recognized {
+		return err == nil && !form.mmx
+	}
+	if form, recognized, err := x86PackedLogicalProperties(ins, "amd64"); recognized {
+		return err == nil && !form.mmx
+	}
+	if amd64MaskMoveOperandsValid(ins, "amd64") {
+		return true
+	}
+	if form, recognized, err := amd64PackedVectorMoveProperties(ins, "amd64"); recognized {
+		return err == nil && !form.undefinedOpcode()
+	}
+	if form, recognized, err := amd64FMA3Properties(ins, "amd64"); recognized {
+		return err == nil && !form.spec.rawOnly
+	}
+	form, recognized, err := amd64ScalarVectorMoveProperties(ins, "amd64")
+	// The shared lowerer also models raw-only FP16 moves. Their caller-bank
+	// permission needs its own complete source/runtime family, not inheritance
+	// from the reviewed Go-named single/double-precision forms.
+	return recognized && err == nil && !form.spec.rawOnly
+}
+
+func x86CloneCallerVectorState(vectors map[Reg]uint64, masks map[Reg]bool) (map[Reg]uint64, map[Reg]bool) {
+	vectorCopy := make(map[Reg]uint64, len(vectors))
+	for reg, known := range vectors {
+		vectorCopy[reg] = known
+	}
+	maskCopy := make(map[Reg]bool, len(masks))
+	for reg, known := range masks {
+		maskCopy[reg] = known
+	}
+	return vectorCopy, maskCopy
+}
+
+func x86CallerVectorRoot(reg Reg) Reg {
+	index, _ := amd64VectorRegisterIndex(reg, amd64VectorByteWidth(reg))
+	return Reg(fmt.Sprintf("Z%d", index))
+}
+
+func x86CallerVectorByteMask(width int64) uint64 {
+	if width <= 0 || width > 64 {
+		return 0
+	}
+	if width == 64 {
+		return ^uint64(0)
+	}
+	return uint64(1)<<uint(width) - 1
+}
+
+func x86CallerVectorMoveStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form, known, err := x86Permute128Properties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPermute128Step(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedDotProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPackedDotStep(ins, form, state, proof)
+	}
+	if form, known, err := x86ExplicitMaskMoveProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerExplicitMaskMoveStep(ins, form, state, proof)
+	}
+	if form, known, err := x86SqrtProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerSqrtStep(ins, form, state, proof)
+	}
+	if form, known, err := x86ByteShuffleProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerByteShuffleStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedConversionProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerPackedConversionStep(ins, form, state, proof)
+	}
+	if form, known, err := x86CLMULProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerCLMULStep(*ins, form, state)
+	}
+	if form, known, err := x86LegacyPackedMoveProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerLegacyPackedMoveStep(ins, form, state, proof)
+	}
+	if form, known, err := x86ScalarLaneProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerScalarLaneStep(ins, form, state, proof)
+	}
+	if form, known, err := x86AESProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerAESByteStep(ins, form, state, proof)
+	}
+	if form, known, err := x86HorizontalIntegerProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerHorizontalIntegerStep(ins, form, state, proof)
+	}
+	if form, known, err := x86GPSIMDTransferProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerGPSIMDTransferStep(ins, form, state, proof)
+	}
+	if form, known, err := x86ImmediateShuffleProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerImmediateShuffleStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedFloatShuffleProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPackedFloatShuffleStep(ins, form, state, proof)
+	}
+	if form, known, err := x86IntegerMinMaxProperties(ins.Op, *ins, "amd64"); known && form.legacy {
+		// Existing register callers share the lane rule. A caller slice does
+		// not grant the original m128's separate native alignment contract.
+		return err == nil && form.memory < 0 && x86ResultNamedPredicateInstruction(*ins) &&
+			x86CallerPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, form.spec.laneBits, state, proof)
+	}
+	if form, known, err := x86PackedAlignProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPackedAlignStep(ins, form, state, proof)
+	}
+	if form, known, err := x86MaskVectorProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerMaskVectorStep(ins, form, state)
+	}
+	if form, known, err := x86PackedNarrowProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerPackedNarrowStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedLowMultiplyProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, form.spec.laneBits, state, proof)
+	}
+	if form, known, err := x86PackedWordMultiplyProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, 16, state, proof)
+	}
+	if form, known, err := x86DwordProductProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerDwordProductStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedSADProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerSADStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedSubtractProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, form.laneBits, state, proof)
+	}
+	if form, recognized, err := x86FloatCompareProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerFloatCompareStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedWrappingAddProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerPackedWrappingAddStep(ins, form, state, proof)
+	}
+	if form, known, err := x86PackedMultiplyAddProperties(ins.Op, *ins, "amd64"); known {
+		return err == nil && x86CallerWordMultiplyAddStep(ins, form, state, proof)
+	}
+	if f, known, err := x86SignedPackedFloatProperties(*ins, "amd64"); known {
+		return err == nil && x86CallerSignedPackedFloatStep(ins, f, state, proof)
+	}
+	if form, recognized, err := x86FloatArithmeticProperties(*ins, "amd64", ""); recognized {
+		return err == nil && x86CallerFloatBinaryStep(ins, form.x86FloatBinaryForm, state, proof)
+	}
+	if form, recognized, err := x86PackedExtendProperties(*ins, "amd64"); recognized {
+		return err == nil && (!form.signed || x86ResultNamedPredicateInstruction(*ins)) &&
+			x86CallerPackedExtendStep(ins, form, state, proof)
+	}
+	if form, recognized, err := x86VectorZeroProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerVectorZeroStep(form, state)
+	}
+	if f, recognized, err := x86SignedIntegerFloatProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerSignedIntegerFloatStep(ins, f, state, proof)
+	}
+	if f, recognized, err := x86InsertExtractProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerInsertExtractStep(ins, f, state, proof)
+	}
+	if form, recognized, err := x86PackedShiftProperties(ins.Op, *ins, "amd64"); recognized {
+		return err == nil && x86CallerPackedShiftStep(ins, form, state, proof)
+	}
+	if form, recognized, err := x86HorizontalFloatProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerHorizontalFloatStep(ins, form, state, proof)
+	}
+	if form, recognized, err := x86PackedUnpackProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerPackedUnpackStep(ins, form, state, proof)
+	}
+	if form, recognized, err := x86PackedLogicalProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerPackedLogicalStep(ins, form, state, proof)
+	}
+	if amd64MaskMoveOperandsValid(*ins, "amd64") {
+		return x86CallerMaskMoveStep(ins, state, proof)
+	}
+	if form, recognized, err := amd64PackedVectorMoveProperties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerPackedVectorMoveStep(ins, form, state, proof)
+	}
+	if form, recognized, err := amd64FMA3Properties(*ins, "amd64"); recognized {
+		return err == nil && x86CallerFMA3Step(ins, form, state, proof)
+	}
+	form, recognized, err := amd64ScalarVectorMoveProperties(*ins, "amd64")
+	if !recognized || err != nil || form.spec.rawOnly || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	width := int64(form.spec.bits / 8)
+	lowMask := x86CallerVectorByteMask(width)
+	if form.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, width, form.memoryWrite) {
+			return false
+		}
+		if form.memoryWrite {
+			source := x86CallerVectorRoot(ins.Args[form.low].Reg)
+			return state.vectors[source]&lowMask == lowMask
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	if form.spec.legacy || form.legacyZero {
+		if form.memory >= 0 || form.literal {
+			// A legacy memory load zeroes the rest of XMM but preserves the
+			// upper Y/Z aliases. Register copies preserve the old upper XMM.
+			state.vectors[destination] = old | x86CallerVectorByteMask(16)
+		} else {
+			source := x86CallerVectorRoot(ins.Args[form.low].Reg)
+			state.vectors[destination] = old&^lowMask | state.vectors[source]&lowMask
+		}
+		return true
+	}
+	known := ^uint64(0)
+	if form.memory < 0 && !form.literal {
+		low := state.vectors[x86CallerVectorRoot(ins.Args[form.low].Reg)] & lowMask
+		upperMask := x86CallerVectorByteMask(16) &^ lowMask
+		upper := state.vectors[x86CallerVectorRoot(ins.Args[form.upper].Reg)] & upperMask
+		known = ^x86CallerVectorByteMask(16) | low | upper
+	}
+	if form.mask >= 0 && !form.zeroing {
+		// The mask is initialized, not assumed all-one: either active data
+		// or the old low element may survive. Higher lanes follow the move
+		// form's upper merge/zero rules independently of that mask bit.
+		known = known&^lowMask | known&old&lowMask
+	}
+	state.vectors[destination] = known
+	return true
+}
+
+func x86CallerMaskMoveStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	bits := amd64MaskMoveSpecs[ins.Op]
+	width := int64(bits / 8)
+	source, destination := ins.Args[0], ins.Args[1]
+	if source.Kind == OpMem {
+		if !x86CallerOrdinaryMemoryStep(ins, 0, state, proof, width, false) {
+			return false
+		}
+	} else if amd64IsKOperand(source) {
+		if !state.masks[source.Reg] {
+			return false
+		}
+	} else if !x86CallerNumericRead(source, width, state) {
+		return false // In particular, GP pointer bits cannot become mask data.
+	}
+	if destination.Kind == OpMem {
+		return x86CallerOrdinaryMemoryStep(ins, 1, state, proof, width, true)
+	}
+	if amd64IsKOperand(destination) {
+		state.masks[destination.Reg] = true
+		return true
+	}
+	// All KMOV GP destinations zero-extend the transferred value, including
+	// B/W/D, so the complete GP result is numeric; SP/BP/g stay forbidden.
+	return x86CallerNumericWrite(destination.Reg, 8, state)
+}
+
+func x86CallerMoveMemoryShape(ins Instr, index int) (width int64, write, valid bool) {
+	return x86InstructionMemoryShape(ins, index, "amd64")
+}
+
+func x86InstructionMemoryShape(ins Instr, index int, arch string) (width int64, write, valid bool) {
+	if f, known, err := x86SingleSourceNarrowProperties(ins.Op, ins, arch); known {
+		return int64(f.outputBytes), true, err == nil && !f.undefinedOpcode() && f.memory >= 0 && f.memory == index
+	}
+	if form, known, err := x86PackedPrecisionProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, arch); known {
+		return int64(form.byteWidth), !form.load, err == nil && form.memory == index
+	}
+	if form, known, err := x86SqrtProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory >= 0 && form.memory == index
+	}
+	if known, _ := x86SizedNOPProperties(ins, arch); known {
+		return 0, false, false // An encoding-only ModRM operand grants no access or caller envelope.
+	}
+	if form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, arch); known {
+		return int64(form.move.byteWidth), !form.spec.load,
+			err == nil && !form.trap && form.move.memory == index
+	}
+	if form, known, err := x86CRC32Properties(ins.Op, ins, arch); known {
+		return int64(form.bits / 8), false, err == nil && index == 0 && isAMD64MemoryOperand(form.source)
+	}
+	if form, known, err := x86ScalarBitFieldProperties(ins.Op, ins, arch); known {
+		return int64(form.bits / 8), false, err == nil && index == 1 && isAMD64MemoryOperand(form.source)
+	}
+	if form, known, err := x86BLSProperties(ins.Op, ins, arch); known {
+		return int64(form.spec.bits / 8), false, err == nil && index == 0 && isAMD64MemoryOperand(form.source)
+	}
+	if form, known, err := x86ByteShuffleProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86CLMULProperties(ins.Op, ins, arch); known {
+		return int64(form.byteWidth), false, err == nil && form.memory >= 0 && index == form.memory
+	}
+	if form, known, err := x86ExplicitIMULProperties(ins.Op, ins, arch); known {
+		sourceIndex := 0
+		if form.three {
+			sourceIndex = 1
+		}
+		return int64(form.bits / 8), false, err == nil && index == sourceIndex && isAMD64MemoryOperand(form.source)
+	}
+	if form, known, err := x86AESProperties(ins.Op, ins, arch); known {
+		return int64(form.byteWidth), false, err == nil && form.memory >= 0 && form.memory == index
+	}
+	if form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch); known {
+		return int64(form.bits / 8), false, err == nil && index == 0 && isAMD64MemoryOperand(form.source)
+	}
+	if form, known, err := x86ScalarLaneProperties(ins, arch); known {
+		return int64(form.bits / 8), !form.insert, err == nil && form.memory == index
+	}
+	if form, known, err := x86HorizontalIntegerProperties(ins, arch); known {
+		return int64(form.byteWidth), false, err == nil && !form.mmx && form.spec.vector && form.memory == index
+	}
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+		return int64(form.bits / 8), form.memoryWrite, err == nil && !form.mmx && form.memory == index
+	}
+	if form, recognized, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch); recognized {
+		return 16, form.memoryWrite, err == nil && x86Mode32VectorRegisterContext(ins, arch) == nil && form.memory == index
+	}
+	if form, recognized, err := x86LegacyIntegerArithmeticProperties(ins.Op, ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if index < 0 || index >= len(ins.Args) || !isAMD64MemoryOperand(ins.Args[index]) {
+		return 0, false, false
+	}
+	if form, known, err := x86ImmediateShuffleProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && !form.spec.legacy && form.memory == index
+	}
+	if form, known, err := x86PackedFloatShuffleProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && !form.legacy && form.memory == index
+	}
+	if form, known, err := x86PackedAlignProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && !form.legacy && form.memory == index
+	}
+	if form, known, err := x86Permute128Properties(ins.Op, ins, arch); known {
+		return 32, false, err == nil && form.memory == index
+	}
+	if form, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86PackedPhysicalProperties(ins.Op, ins, arch, ""); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index &&
+			(!form.mmx || form.spec.family == x86PackedAverage)
+	}
+	if form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && !form.mmx && form.memory == index
+	}
+	if form, known, err := x86PackedTestMaskProperties(ins.Op, ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if _, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); recognized {
+		return 1, true, err == nil && index == 0
+	}
+	if form, known, err := x86PackedNarrowProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86PackedSADProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86PackedSubtractProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if form, known, err := x86PackedWrappingAddProperties(ins, arch); known {
+		return int64(form.memoryBytes), false, err == nil && !form.mmx && form.memory == index
+	}
+	if f, known, err := x86PackedConversionProperties(ins, arch); known {
+		return int64(f.memoryBytes), false, err == nil && !f.mmx && f.memory == index
+	}
+	if f, known, err := x86SignedPackedFloatProperties(ins, arch); known {
+		return int64(f.memoryBytes), false, err == nil && !f.mmx && f.memory == index
+	}
+	if form, recognized, err := x86PackedExtendProperties(ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index &&
+			(!form.signed || x86ResultNamedPredicateInstruction(ins))
+	}
+	if form, recognized, err := x86FloatCompareProperties(ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if f, recognized, err := x86SignedIntegerFloatProperties(ins, arch); recognized {
+		return int64(f.sourceBits / 8), false, err == nil && f.memory == index
+	}
+	if f, recognized, err := x86UnsignedIntegerFloatProperties(ins, arch); recognized {
+		return int64(f.sourceBits / 8), false, err == nil && f.memory == index
+	}
+	if form, recognized, err := x86FloatArithmeticProperties(ins, arch, ""); recognized {
+		return int64(form.memoryBytes), false, err == nil && form.memory == index
+	}
+	if f, recognized, err := x86InsertExtractProperties(ins, arch); recognized {
+		return int64(f.spec.chunk), f.memoryWrite, err == nil && f.memory == index && !(f.mask >= 0 && f.memoryWrite)
+	}
+	if form, recognized, err := x86PackedShiftProperties(ins.Op, ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && !form.mmx && form.memory == index
+	}
+	if form, recognized, err := x86HorizontalFloatProperties(ins, arch); recognized {
+		return int64(form.byteWidth), false, err == nil && form.spec.vector && form.memory == index
+	}
+	if form, recognized, err := x86PackedUnpackProperties(ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && !form.mmx && !form.legacy && form.memory == index
+	}
+	if form, recognized, err := x86PackedLogicalProperties(ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && !form.mmx && form.memory == index
+	}
+	if width = x86RawReturnScalarMoveBytes(Op(normalizeInstructionOpcode(x86SourceMoveInstruction(ins, arch).Op))); width != 0 && len(ins.Args) == 2 {
+		return width, index == 1, true
+	}
+	if form, recognized, err := x86ScalarExtensionProperties(ins.Op, ins, arch); recognized {
+		return int64(form.spec.sourceBits / 8), false, err == nil && index == 0
+	}
+	if amd64MaskMoveOperandsValid(ins, arch) {
+		return int64(amd64MaskMoveSpecs[ins.Op] / 8), index == 1, true
+	}
+	if form, recognized, err := amd64PackedVectorMoveProperties(ins, arch); recognized {
+		return int64(form.byteWidth), form.memoryWrite, err == nil && !form.undefinedOpcode() && form.memory == index
+	}
+	if form, recognized, err := amd64FMA3Properties(ins, arch); recognized {
+		return int64(form.memoryBytes), false, err == nil && !form.spec.rawOnly && form.memory == index
+	}
+	form, recognized, err := amd64ScalarVectorMoveProperties(ins, arch)
+	if !recognized || err != nil || form.memory != index {
+		return 0, false, false
+	}
+	return int64(form.spec.bits / 8), form.memoryWrite, true
+}
+
+func x86CallerPackedVectorMoveStep(ins *Instr, form amd64PackedVectorMoveForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.undefinedOpcode() || form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	widthMask := x86CallerVectorByteMask(int64(form.byteWidth))
+	var known uint64
+	if form.memory >= 0 {
+		// A slice-data/nonalias witness is not a SIMD alignment promise.
+		// Aligned register copies are valid, but aligned memory requires a
+		// separate actual-address proof before borrowing this continuation.
+		if form.spec.aligned || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.byteWidth), form.memoryWrite) {
+			return false
+		}
+		if form.memoryWrite {
+			return state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]&widthMask == widthMask
+		}
+		known = widthMask
+	} else {
+		known = state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)] & widthMask
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	// No initialized mask is assumed all-one. Both potential inputs matter.
+	known = form.definedActiveBytes(known, state.vectors[destination])
+	state.vectors[destination] = ^widthMask | known
+	return true
+}
diff --git a/amd64_go_caller_vector_moves_test.go b/amd64_go_caller_vector_moves_test.go
new file mode 100644
index 000000000..0f74db41c
--- /dev/null
+++ b/amd64_go_caller_vector_moves_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerVectorMovesFreshScalarResults(t *testing.T) {
+	for _, width := range []struct {
+		suffix, typ string
+	}{{"SS", "float32"}, {"SD", "float64"}} {
+		legacy, vector := "MOV"+width.suffix, "VMOV"+width.suffix
+		for _, form := range []struct {
+			name, body string
+		}{
+			{name: "legacy load/copy/store", body: fmt.Sprintf("%s (DI),X0\n%s X0,X1\n%s X1,(DX)", legacy, legacy, legacy)},
+			{name: "vector load/merge/store", body: fmt.Sprintf("%s (DI),X0\n%s X0,X0,X1\n%s X1,(DX)", vector, vector, vector)},
+			{name: "masked load zero", body: fmt.Sprintf("KMOVW AX,K1\n%s.Z (DI),K1,X0\n%s X0,(DX)", vector, vector)},
+			{name: "masked store", body: fmt.Sprintf("KMOVW AX,K1\n%s (DI),X0\n%s X0,K1,(DX)", vector, vector)},
+			{name: "masked merge", body: fmt.Sprintf("KMOVW AX,K1\n%s (DI),X0\n%s (SI),X1\n%s (DI),X2\n%s X0,X1,K1,X2\n%s X2,(DX)", vector, vector, vector, vector, vector)},
+			{name: "masked merge zero", body: fmt.Sprintf("KMOVW AX,K1\n%s (DI),X0\n%s (SI),X1\n%s.Z X0,X1,K1,X2\n%s X2,(DX)", vector, vector, vector, vector)},
+			{name: "extended vector register", body: fmt.Sprintf("%s (DI),X31\n%s X31,(DX)", vector, vector)},
+			{name: "complete numeric overwrite", body: fmt.Sprintf("%s X0,X1,X2\n%s (DI),X2\n%s X2,(DX)", vector, vector, vector)},
+		} {
+			for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+				t.Run(width.suffix+"/"+form.name+"/"+triple, func(t *testing.T) {
+					source := strings.ReplaceAll(x86CallerFixtureSource, "float32", width.typ)
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", form.body, 1)
+					requireX86GoAssemblerResult(t, "amd64", assembly, true)
+					pkg, _ := x86CallerCoreFixture(t, source, assembly)
+					if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerMaskMovesAllWidthsAndDirections(t *testing.T) {
+	for _, width := range []struct{ suffix, typ, move string }{
+		{"B", "uint8", "MOVB"}, {"W", "uint16", "MOVW"},
+		{"D", "uint32", "MOVL"}, {"Q", "uint64", "MOVQ"},
+	} {
+		maskMove := "KMOV" + width.suffix
+		for _, form := range []struct{ name, body string }{
+			{"GP to mask to memory", maskMove + " AX,K1\n" + maskMove + " K1,(DX)"},
+			{"input to mask to memory", maskMove + " (DI),K1\n" + maskMove + " K1,(DX)"},
+			{"length to mask to memory", maskMove + " (CX),K1\n" + maskMove + " K1,(DX)"},
+			{"mask copy to memory", maskMove + " AX,K1\n" + maskMove + " K1,K2\n" + maskMove + " K2,(DX)"},
+			{"mask to GP to memory", maskMove + " AX,K1\n" + maskMove + " K1,BX\n" + width.move + " BX,(DX)"},
+		} {
+			t.Run(width.suffix+"/"+form.name, func(t *testing.T) {
+				source := strings.ReplaceAll(x86CallerFixtureSource, "float32", width.typ)
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", form.body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, source, assembly)
+				for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+					if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+						t.Fatal(err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerVectorMovesDoNotWashPointersOrInventInitializedBytes(t *testing.T) {
+	for _, example := range []struct{ name, body, result string }{
+		{"unknown mask", "VMOVSS.Z (DI),K1,X0\nVMOVSS X0,(DX)", "float32"},
+		{"unknown mask source", "KMOVW BX,K1\nVMOVSS.Z (DI),K1,X0\nVMOVSS X0,(DX)", "float32"},
+		{"pointer to mask", "KMOVW DI,K1\nVMOVSS.Z (DI),K1,X0\nVMOVSS X0,(DX)", "float32"},
+		{"fixed g to mask", "KMOVQ R14,K1\nKMOVQ K1,(DX)", "uint64"},
+		{"mask to fixed g", "KMOVW AX,K1\nKMOVQ K1,R14\nMOVL AX,(DX)", "float32"},
+		{"mask to SP", "KMOVW AX,K1\nKMOVQ K1,SP\nMOVL AX,(DX)", "float32"},
+		{"mask to BP", "KMOVW AX,K1\nKMOVQ K1,BP\nMOVL AX,(DX)", "float32"},
+		{"mask replaces input pointer", "KMOVW AX,K1\nKMOVQ K1,DI\nVMOVSS (DI),X0\nVMOVSS X0,(DX)", "float32"},
+		{"GP pointer as vector data", "MOVQ DI,X0\nMOVSD X0,(DX)", "float64"},
+		{"private SP as vector data", "MOVQ SP,X0\nMOVSD X0,(DX)", "float64"},
+		{"fixed g as vector data", "MOVQ R14,X0\nMOVSD X0,(DX)", "float64"},
+		{"FP pointer as vector data", "MOVSD a+0(FP),X0\nMOVSD X0,(DX)", "float64"},
+		{"saved BP as vector data", "MOVSD 0(SP),X0\nMOVSD X0,(DX)", "float64"},
+		{"unknown vector bytes", "VMOVSS X0,(DX)", "float32"},
+		{"unknown low source", "VMOVSS (DI),X0\nVMOVSS X1,X0,X2\nVMOVSS X2,(DX)", "float32"},
+		{"legacy unknown upper bytes", "MOVSS (DI),X0\nMOVSS X0,X1\nMOVSD X1,(DX)", "float64"},
+		{"masked merge unknown destination", "KMOVW AX,K1\nVMOVSS (DI),X0\nVMOVSS (SI),X1\nVMOVSS X0,X1,K1,X2\nVMOVSS X2,(DX)", "float32"},
+		{"wide result", "VMOVSD (DI),X0\nVMOVSD X0,(DX)", "float32"},
+		{"result one byte overlap", "VMOVSS (DI),X0\nVMOVSS X0,1(DX)", "float32"},
+		{"result negative offset", "VMOVSS (DI),X0\nVMOVSS X0,-1(DX)", "float32"},
+		{"result indexed", "VMOVSS (DI),X0\nVMOVSS X0,(DX)(AX*1)", "float32"},
+		{"input write", "VMOVSS (DI),X0\nVMOVSS X0,(DI)", "float32"},
+		{"length write", "VMOVSS (DI),X0\nVMOVSS X0,(CX)", "float32"},
+		{"unknown input base", "VMOVSS (BX),X0\nVMOVSS X0,(DX)", "float32"},
+		{"mask input write", "KMOVW AX,K1\nKMOVW K1,(DI)", "uint16"},
+		{"mask wide result", "KMOVQ AX,K1\nKMOVQ K1,(DX)", "uint32"},
+		{"literal result one byte overlap", "MOVSS $1.25,X0\nMOVSS X0,1(DX)", "float32"},
+		{"literal unknown mask", "VMOVSS.Z $1.25,K1,X0\nVMOVSS X0,(DX)", "float32"},
+		{"literal mask from pointer", "KMOVW DI,K1\nVMOVSS.Z $1.25,K1,X0\nVMOVSS X0,(DX)", "float32"},
+	} {
+		t.Run(example.name, func(t *testing.T) {
+			source := strings.ReplaceAll(x86CallerFixtureSource, "float32", example.result)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", example.body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, source, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved vector/mask state acquired raw-RET continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerVectorMemoryCertificatesBindMaskWidthAndEveryOperand(t *testing.T) {
+	for _, body := range []string{
+		"KMOVW AX,K1\nVMOVSS (DI),X0\nVMOVSS X0,K1,(DX)",
+		"KMOVD AX,K1\nKMOVD K1,(DX)",
+	} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+		normalized, err := normalizeX86RawFile(file, "amd64", options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, instruction := range normalized.Funcs[0].Instrs {
+			for index, access := range instruction.x86CallerMemory {
+				if !access.write || !x86CallerMemoryCertified(instruction, index) {
+					continue
+				}
+				found = true
+				for _, change := range []string{"opcode", "source", "address", "address-bits", "width", "direction", "mask"} {
+					mutated := instruction
+					mutated.Args = append([]Operand(nil), instruction.Args...)
+					mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+					switch change {
+					case "opcode":
+						mutated.Op = "VMOVSD"
+					case "source":
+						mutated.Args[0].Reg = "X3"
+					case "address":
+						mutated.Args[index].Mem.Off++
+					case "address-bits":
+						mutated.x86AddressBits = 32
+					case "width":
+						access.width++
+						mutated.x86CallerMemory[index] = access
+					case "direction":
+						access.write = false
+						mutated.x86CallerMemory[index] = access
+					case "mask":
+						if len(mutated.Args) != 3 {
+							continue
+						}
+						mutated.Args[1].Reg = "K2"
+					}
+					if x86CallerMemoryCertified(mutated, index) {
+						t.Fatalf("%s borrowed a %s memory certificate", change, instruction.Op)
+					}
+				}
+			}
+		}
+		if !found {
+			t.Fatal("fixture produced no complete vector/mask write certificate")
+		}
+	}
+}
diff --git a/amd64_go_caller_vector_zero_test.go b/amd64_go_caller_vector_zero_test.go
new file mode 100644
index 000000000..881aacc13
--- /dev/null
+++ b/amd64_go_caller_vector_zero_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86GoCallerVectorZeroOriginalSource(t *testing.T) {
+	for _, body := range []string{
+		"VMOVUPS (DI),Z0\nVZEROUPPER\nVMOVSS X0,(DX)",
+		"VZEROALL\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),Z0\nWORD $0xf8c5\nBYTE $0x77\nVMOVSS X0,(DX)",
+		"WORD $0xfcc5\nBYTE $0x77\nVMOVSS X0,(DX)",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", "_"), func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerVectorZeroInitializedBytesAndUnaffectedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []Op{"VZEROUPPER", "VZEROALL"} {
+			for _, initial := range []uint64{0, 1, 0xffff, 0xaaaaaaaaaaaaaaaa, ^uint64(0)} {
+				state := x86SourceStackState{
+					vectors: map[Reg]uint64{}, masks: map[Reg]bool{"K1": true, "K2": false},
+					known: map[Reg]uint8{AX: 0xff}, numericFlags: true, gOriginal: true,
+				}
+				for register := 0; register < 32; register++ {
+					state.vectors[Reg(fmt.Sprintf("Z%d", register))] = initial
+				}
+				known, masks := x86CloneCallerKnown(state.known), map[Reg]bool{"K1": true, "K2": false}
+				form, recognized, err := x86VectorZeroProperties(Instr{Op: opcode}, arch)
+				if !recognized || err != nil || !x86CallerVectorZeroStep(form, &state) {
+					t.Fatalf("%s/%s grammar/effect: %t/%v", arch, opcode, recognized, err)
+				}
+				limit, added := 16, ^uint64(0xffff)
+				if arch == "386" {
+					limit = 8
+				}
+				if opcode == "VZEROALL" {
+					added = ^uint64(0)
+				}
+				for register := 0; register < 32; register++ {
+					want := initial
+					if register < limit {
+						want |= added
+					}
+					if state.vectors[Reg(fmt.Sprintf("Z%d", register))] != want {
+						t.Fatalf("%s/%s invented/lost register%d byte knowledge", arch, opcode, register)
+					}
+				}
+				if !reflect.DeepEqual(state.known, known) || !reflect.DeepEqual(state.masks, masks) || !state.numericFlags || !state.gOriginal {
+					t.Fatal("vector zero changed GP/mask/flags/g source state")
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerVectorZeroDoesNotInventPreservedLowOrHighRegisters(t *testing.T) {
+	for _, body := range []string{
+		"VZEROUPPER\nVMOVSS X0,(DX)",
+		"VZEROALL\nVMOVSS X16,(DX)",
+		"VZEROUPPER\nVMOVSS X31,(DX)",
+		"VZEROALL\nKMOVQ K1,AX\nMOVL AX,(DX)",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", "_"), func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown low/high/mask source acquired return proof: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerVectorZeroCompleteFamilyThreeAPIs(t *testing.T) {
+	const body = "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z16\nVZEROUPPER\nVMOVSS X0,(DX)\nVZEROALL\nVMOVSS X15,(DX)\nVMOVSS X16,(DX)\nWORD $0xfcc5\nBYTE $0x77\nVMOVSS X1,(DX)\n"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "zero-caller.ll", "zero-caller.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, triple, "zero-module.ll", "zero-module.o", module.String())
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_caller_word_multiply_test.go b/amd64_go_caller_word_multiply_test.go
new file mode 100644
index 000000000..ef6ebb643
--- /dev/null
+++ b/amd64_go_caller_word_multiply_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerWordMultiplyCompleteForms(t *testing.T) {
+	for _, name := range x86WordMultiplyNames {
+		banks := []string{"X"}
+		if strings.HasPrefix(name, "V") {
+			banks = append(banks, "Y", "Z")
+		}
+		for _, bank := range banks {
+			for _, first := range []string{bank + "0", "(DI)"} {
+				for _, mode := range []int{0, 1, 2} {
+					if !strings.HasPrefix(name, "V") && mode != 0 {
+						continue
+					}
+					opcode, args, result := name, first+","+bank+"1", "X1"
+					if strings.HasPrefix(name, "V") {
+						args, result = first+","+bank+"1", "X2"
+						if mode != 0 {
+							args += ",K1"
+						}
+						if mode == 2 {
+							opcode += ".Z"
+						}
+						args += "," + bank + "2"
+					}
+					row := opcode + " " + args
+					body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					t.Run(row, func(t *testing.T) {
+						goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+						pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+						for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+							if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+								t.Fatal(err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerWordMultiplyUnknownAndMemoryPermissionsRemainContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown first":          "VMOVUPS (DI),Z1\nVPMULLW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"unknown second":         "VMOVUPS (DI),Z0\nVPMULHW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"partial source":         "MOVSS (DI),X0\nVMOVUPS (SI),Z1\nVPMULHUW Z0,Z1,Z2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":           "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVPMULHRSW.Z Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":          "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nMOVL $1,AX\nKMOVQ AX,K1\nVPMULHW Z0,Z1,K1,Z2\nVMOVSS X2,(DX)",
+		"pointer mask":           "VMOVUPS (DI),Z0\nKMOVQ DI,K1\nVPMULLW.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"zero mask lacks region": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPMULHW.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":        "VMOVUPS (DI),Z0\nVPMULHUW (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"stack alias":            "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPMULLW (BX),X0\nVMOVSS X0,(DX)",
+		"BP alias":               "VMOVUPS (DI),Z0\nMOVQ BP,BX\nPMULHW (BX),X0\nVMOVSS X0,(DX)",
+		"input write":            "VMOVUPS (DI),Z0\nVPMULHRSW Z0,Z0,Z2\nVMOVSS X2,(DI)",
+		"MMX separate bank":      "PMULLW M0,M1\nVMOVSS X1,(DX)",
+		"join missing second":    "VMOVUPS (DI),Z0\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z1\njoined:\nVPMULHW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved word multiply acquired caller permission", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerWordMultiplyFullReadCertificatesAndByteAliases(t *testing.T) {
+	names := append(append([]string(nil), x86WordMultiplyNames...), "PMULLD", "VPMULLD", "VPMULLQ")
+	for _, name := range names {
+		row, result := name+" (DI),X0", "X0"
+		if strings.HasPrefix(name, "V") {
+			row, result = name+".Z (DI),Z0,K1,Z2", "X2"
+		}
+		body := "VMOVUPS (SI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, ins := range normalized.Funcs[0].Instrs {
+			form, known, err := x86LowAndWordMultiplyTestForm(ins)
+			if !known || err != nil || form.memory < 0 {
+				continue
+			}
+			found = true
+			access, exists := ins.x86CallerMemory[form.memory]
+			if !exists || access.width != int64(form.memoryBytes) || access.write || !x86CallerMemoryCertified(ins, form.memory) {
+				t.Fatal("zero mask shrank the independent possible read envelope")
+			}
+			for _, change := range []string{"op", "base", "width", "direction", "destination", "mask", "address size"} {
+				mutated := ins
+				mutated.Args = append([]Operand(nil), ins.Args...)
+				mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{form.memory: access}
+				switch change {
+				case "op":
+					mutated.Op = "MOVOU"
+				case "base":
+					mutated.Args[form.memory].Mem.Base = BX
+				case "width":
+					access.width--
+					mutated.x86CallerMemory[form.memory] = access
+				case "direction":
+					access.write = true
+					mutated.x86CallerMemory[form.memory] = access
+				case "destination":
+					mutated.Args[form.destination].Reg = "X7"
+				case "mask":
+					mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K7"})
+				case "address size":
+					mutated.x86AddressBits = 32
+				}
+				if x86CallerMemoryCertified(mutated, form.memory) {
+					t.Fatal("stale original instruction memory certificate survived", change)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("no multiply memory proof")
+		}
+	}
+	for _, name := range names {
+		operands := "X0,X1"
+		if strings.HasPrefix(name, "V") {
+			operands = "X0,X1,X2"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+name+" "+operands+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86LowAndWordMultiplyTestForm(ins)
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0xfffd, "Z1": 0xffff}, masks: map[Reg]bool{}}
+		if !x86CallerVectorMoveStep(&ins, state, nil) {
+			t.Fatal("registered pure vector effect missing")
+		}
+		want := uint64(0xfffc) // One absent source byte kills its whole word.
+		if name == "PMULLD" || name == "VPMULLD" {
+			want = 0xfff0
+		} else if name == "VPMULLQ" {
+			want = 0xff00
+		}
+		if !form.legacy {
+			want |= ^uint64(0xffff)
+		}
+		if got := state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]; got != want {
+			t.Fatal(fmt.Sprintf("incorrect word-byte/upper alias transfer %s got=%x want=%x", name, got, want))
+		}
+	}
+}
+
+func x86LowAndWordMultiplyTestForm(ins Instr) (x86PackedBinaryForm, bool, error) {
+	if form, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, "amd64"); known {
+		return form.x86PackedBinaryForm, known, err
+	}
+	form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, "amd64")
+	return form.x86PackedBinaryForm, known, err
+}
diff --git a/amd64_go_caller_zero_extend.go b/amd64_go_caller_zero_extend.go
new file mode 100644
index 000000000..c4c6afca5
--- /dev/null
+++ b/amd64_go_caller_zero_extend.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+func x86CallerPackedZeroExtendStep(ins *Instr, form x86PackedZeroExtendForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	return x86CallerPackedExtendStep(ins, form, state, proof)
+}
+
+func x86CallerPackedExtendStep(ins *Instr, form x86PackedExtendForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	var input uint64
+	if form.memory >= 0 {
+		// Mask knowledge grants no address/alignment/envelope permission.
+		// Keep the complete potential read bound even when lanes can fault-
+		// suppress. Input regions never become writable scalar results.
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		input = x86CallerVectorByteMask(int64(form.memoryBytes))
+	} else {
+		input = state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := x86PackedExtendDefinedBytes(form, input, old)
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.spec.vector {
+		state.vectors[destination] = ^width | known
+	} else {
+		state.vectors[destination] = old&^width | known
+	}
+	return true
+}
+
+// This pure byte dependency grants no memory or caller permission. Upper
+// zero bits are known independently of input bytes; mask/alias writes remain
+// distinct from the register and memory observations that precede this step.
+func x86PackedZeroExtendDefinedBytes(form x86PackedZeroExtendForm, input, old uint64) uint64 {
+	return x86PackedExtendDefinedBytes(form, input, old)
+}
+
+func x86PackedExtendDefinedBytes(form x86PackedExtendForm, input, old uint64) uint64 {
+	var known uint64
+	inputBytes, outputBytes := form.spec.inputBits/8, form.spec.outputBits/8
+	for output := 0; output < form.byteWidth; output++ {
+		part := output % outputBytes
+		if part >= inputBytes && !form.signed {
+			known |= uint64(1) << uint(output)
+			continue // ZX high bytes are numerical zero independently of input.
+		}
+		if part >= inputBytes {
+			part = inputBytes - 1 // SX high bytes each depend on the actual sign byte.
+		}
+		if input>>uint(output/outputBytes*inputBytes+part)&1 != 0 {
+			known |= uint64(1) << uint(output)
+		}
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known &= old // An initialized mask is not an all-active mask promise.
+	}
+	return known
+}
diff --git a/amd64_go_caller_zero_extend_test.go b/amd64_go_caller_zero_extend_test.go
new file mode 100644
index 000000000..5784c0db0
--- /dev/null
+++ b/amd64_go_caller_zero_extend_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GoCallerPackedZeroExtendCurrentGap(t *testing.T) {
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)",
+		"VMOVUPS (DI),X0\nVPMOVZXBD X0,Y1\nVMOVSS X1,(DX)", 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatalf("Go-accepted bounded byte widening with initialized input: %v", err)
+	}
+}
+
+func TestX86GoCallerPackedZeroExtendCompleteInitializedForms(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			for _, original := range x86ZeroExtendAcceptedForms(prefix+"MOVZX"+ratio.suffix, "amd64") {
+				t.Run(original, func(t *testing.T) {
+					row := strings.NewReplacer("(AX)", "(DI)", "X15", "X2", "X31", "X2", "Y31", "Y2", "Z31", "Z2").Replace(original)
+					body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\nKMOVQ AX,K1\nKMOVQ AX,K7\n" + row
+					if strings.HasSuffix(row, "X1") || strings.HasSuffix(row, "Y1") {
+						body += "\nVMOVSS X1,(DX)"
+					} else {
+						body += "\nVMOVSS X2,(DX)"
+					}
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					requireX86GoAssemblerResult(t, "amd64", assembly, true)
+					pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+					if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedZeroExtendRetainsUnknownAndEnvelopeFailures(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown input":           "VPMOVZXBD X0,Y1\nVMOVSS X1,(DX)",
+		"unknown merge":           "VMOVUPS (DI),X0\nKMOVQ AX,K1\nVPMOVZXBD X0,K1,Y1\nVMOVSS X1,(DX)",
+		"unknown mask":            "VMOVUPS (DI),X0\nVPMOVZXBD.Z X0,K1,Y1\nVMOVSS X1,(DX)",
+		"pointer mask":            "VMOVUPS (DI),X0\nKMOVQ DI,K1\nVPMOVZXBD.Z X0,K1,Y1\nVMOVSS X1,(DX)",
+		"unknown base":            "VPMOVZXBD (BX),Y1\nVMOVSS X1,(DX)",
+		"private stack":           "VPMOVZXBD (SP),Y1\nVMOVSS X1,(DX)",
+		"pointer FP data":         "VPMOVZXBD a+0(FP),Y1\nVMOVSS X1,(DX)",
+		"overread length":         "VPMOVZXBW (CX),Y1\nVMOVSS X1,(DX)",
+		"zero mask envelope":      "MOVL $0,AX\nKMOVQ AX,K1\nVPMOVZXBW.Z (DX),K1,Y1\nVMOVSS X1,(DX)",
+		"source write":            "VPMOVZXBD (DI),Y1\nVMOVSS X1,(DI)",
+		"wide result":             "VPMOVZXBD (DI),Y1\nVMOVUPS Y1,(DX)",
+		"undefined CFG join":      "CMPQ AX,$0\nJE joined\nVMOVUPS (DI),X0\njoined:\nVPMOVZXBD X0,Y1\nVMOVSS X1,(DX)",
+		"unknown upper alias":     "VMOVUPS (DI),X0\nPMOVZXBD X0,X1\nVPMOVZXBW Y1,Z2\nVMOVSS X2,(DX)",
+		"signed sign byte absent": "PINSRB $0,AX,X0\nVPMOVSXWQ X0,X1\nPEXTRD $1,X1,AX\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			// The upper-alias negative must observe an unknown part, not the
+			// correctly initialized low X bytes of the first widening result.
+			if name == "unknown upper alias" {
+				assembly = strings.Replace(assembly, "VMOVSS X2,(DX)", "VEXTRACTI128 $1,Y1,X2\nVMOVSS X2,(DX)", 1)
+			}
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved zero-extension acquired caller continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerPackedZeroExtendIndependentByteKnowledge(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, vector := range []bool{false, true} {
+			for _, width := range []int{16, 32, 64} {
+				if !vector && width != 16 {
+					continue
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				source := "X0"
+				if width*ratio.input/ratio.output > 16 {
+					source = "Y0"
+				}
+				for _, destination := range []int{0, 1} {
+					for mode := 0; mode < 3; mode++ {
+						if !vector && mode != 0 {
+							continue
+						}
+						name, mask := "PMOVZX"+ratio.suffix, ""
+						if vector {
+							name = "V" + name
+						}
+						if mode != 0 {
+							mask = "K1,"
+							if mode == 2 {
+								name += ".Z"
+							}
+						}
+						row := fmt.Sprintf("%s %s,%s%s%d", name, source, mask, bank, destination)
+						file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						form, _, err := x86PackedZeroExtendProperties(ins, "amd64")
+						if err != nil {
+							t.Fatal(err)
+						}
+						for seed := 0; seed < 64; seed++ {
+							input, old := uint64(seed)*0x391072d5e64b8a0f, uint64(seed+7)*0x6a89e14f30725bc1
+							initial := map[Reg]uint64{"Z0": input, "Z1": old}
+							before := initial[Reg(fmt.Sprintf("Z%d", destination))]
+							result := x86ResultState{flags: x86ByteFlagsAll}
+							result.writeVector(0, 64, input, false)
+							result.writeVector(1, 64, old, false)
+							result.masks[1] = true
+							if !x86ResultTransfer(ins, &result, nil, 0, "amd64") {
+								t.Fatal("independent result observer lacks widening byte effects", row)
+							}
+							state := x86SourceStackState{vectors: initial, masks: map[Reg]bool{"K1": true}}
+							if !x86CallerPackedZeroExtendStep(&ins, form, &state, nil) {
+								t.Fatal("register byte effect refused")
+							}
+							var want uint64
+							for output := 0; output < 64; output++ {
+								known := false
+								if output >= width {
+									known = vector || before>>uint(output)&1 != 0
+								} else {
+									part := output % ratio.output
+									known = part >= ratio.input || input>>uint(output/ratio.output*ratio.input+part)&1 != 0
+									if mode == 1 {
+										known = known && before>>uint(output)&1 != 0
+									}
+								}
+								if known {
+									want |= uint64(1) << uint(output)
+								}
+							}
+							if got := state.vectors[Reg(fmt.Sprintf("Z%d", destination))]; got != want {
+								t.Fatalf("%s seed%d: defined bytes %#x want %#x", row, seed, got, want)
+							}
+							if result.vectorBytes(destination) != want || result.flags != x86ByteFlagsAll ||
+								result.vectorBytes(1-destination) != map[int]uint64{0: input, 1: old}[1-destination] {
+								t.Fatalf("%s seed%d: result bytes %#x want %#x, or changed another register/FLAGS", row, seed, result.vectorBytes(destination), want)
+							}
+							if state.vectors[Reg(fmt.Sprintf("Z%d", 1-destination))] != map[int]uint64{0: input, 1: old}[1-destination] {
+								t.Fatal("widening changed another SIMD register")
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_go_downloaded_frame_imports.go b/amd64_go_downloaded_frame_imports.go
new file mode 100644
index 000000000..2798b47b2
--- /dev/null
+++ b/amd64_go_downloaded_frame_imports.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// The frame factory independently observes exact dependency downloads. The
+// outer package query and caller-supplied types cannot supply these origins.
+func (source *GoAMD64FrameSource) captureDownloadedDeclarationOrigins(ctx context.Context, output []byte) error {
+	if source.downloadedModule == nil {
+		return nil
+	}
+	if len(output) > 16<<20 {
+		return goAMD64FrameContext("declaration import graph exceeds its bound")
+	}
+	if err := source.verifyDownloadedOrigin(); err != nil {
+		return err
+	}
+	decoder := json.NewDecoder(bytes.NewReader(output))
+	for count := 0; ; count++ {
+		var selected goAMD64FrameSelection
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			return err
+		}
+		if count >= 4096 {
+			return goAMD64FrameContext("downloaded declaration import graph exceeds its count bound")
+		}
+		if selected.Standard {
+			continue // The SDK source/export consumer validates this role.
+		}
+		actual := selected.Module
+		if actual == nil || len(actual.Replace) != 0 && string(actual.Replace) != "null" {
+			return goAMD64FrameContext("downloaded dependency has an unbound module/replacement role")
+		}
+		if !actual.Main {
+			key := actual.Path + "@" + actual.Version
+			if _, exists := source.downloadedImports[key]; !exists {
+				if source.ready {
+					return goAMD64FrameContext("actual declaration import graph acquired a new module")
+				}
+				original, err := source.observeDownloadedModule(ctx, source.downloadedOrigin,
+					goAMD64DownloadedIdentity{module: actual.Path, version: actual.Version}, source.env["GOTMPDIR"])
+				if err != nil {
+					return err
+				}
+				if source.downloadedImports == nil {
+					source.downloadedImports = make(map[string]gooriginalsrc.Module)
+				}
+				source.downloadedImports[key] = original
+			}
+		}
+		if _, err := source.downloadedDeclarationDirectory(selected); err != nil {
+			return err
+		}
+	}
+	return source.verifyDownloadedOrigin()
+}
+
+func (source *GoAMD64FrameSource) downloadedDeclarationDirectory(selected goAMD64FrameSelection) (string, error) {
+	actual := selected.Module
+	if source.downloadedOrigin == nil || source.downloadedModule == nil || selected.Standard || actual == nil ||
+		len(actual.Replace) != 0 && string(actual.Replace) != "null" {
+		return "", goAMD64FrameContext("foreign declaration dependency needs authenticated original handoff")
+	}
+	original := *source.downloadedModule
+	version := "" // Go's actual cache-CWD main role is not its download version.
+	if !actual.Main {
+		var found bool
+		original, found = source.downloadedImports[actual.Path+"@"+actual.Version]
+		if !found {
+			return "", goAMD64FrameContext("declaration dependency lacks its exact original download")
+		}
+		version = original.SourceVersion
+	}
+	root, rootErr := sourcepath.Resolve(actual.Dir)
+	metadata, metadataErr := sourcepath.Resolve(actual.GoMod)
+	if rootErr != nil || metadataErr != nil || root != original.Root ||
+		actual.Path != original.ModulePath || actual.Version != version ||
+		actual.GoVersion != gooriginalsrc.SelectedGoVersion(original.GoVersion, actual.Main) ||
+		metadata != original.GoMod && metadata != filepath.Join(original.Root, "go.mod") {
+		return "", goAMD64FrameContext("declaration dependency differs from its original module metadata")
+	}
+	if original.GoModOrigin == golegacymod.ProxyGoModProtocol && (actual.Main || metadata != original.GoMod) {
+		return "", goAMD64FrameContext("legacy proxy metadata requires its exact dependency role")
+	}
+	directory, err := sourcepath.Resolve(selected.Dir)
+	if err != nil {
+		return "", err
+	}
+	path, err := goAMD64DownloadedPackagePath(original, directory)
+	if err != nil || path != selected.ImportPath {
+		return "", goAMD64FrameContext("declaration dependency escaped its original package namespace")
+	}
+	return directory, nil
+}
diff --git a/amd64_go_downloaded_frame_imports_test.go b/amd64_go_downloaded_frame_imports_test.go
new file mode 100644
index 000000000..da780be22
--- /dev/null
+++ b/amd64_go_downloaded_frame_imports_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+func TestGoAMD64DownloadedDeclarationMetadataRoles(t *testing.T) {
+	root := t.TempDir()
+	primary := gooriginalsrc.Module{Root: filepath.Join(root, "main"), ModulePath: "example.invalid/main", GoVersion: "1.20"}
+	foreign := gooriginalsrc.Module{Root: filepath.Join(root, "dependency"), ModulePath: "example.invalid/dependency",
+		SourceModule: "example.invalid/dependency", SourceVersion: "v1.0.0", GoVersion: "1.20"}
+	for _, original := range []*gooriginalsrc.Module{&primary, &foreign} {
+		if err := os.Mkdir(original.Root, 0700); err != nil {
+			t.Fatal(err)
+		}
+		canonical, err := filepath.EvalSymlinks(original.Root)
+		if err != nil {
+			t.Fatal(err)
+		}
+		original.Root = canonical
+		original.GoMod = filepath.Join(canonical, "go.mod")
+		if err := os.WriteFile(original.GoMod, []byte("module "+original.ModulePath+"\ngo 1.20\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, axis := range []string{"foreign", "primary", "unknown version", "namespace", "language", "main role", "root",
+		"metadata", "package directory", "package path", "replacement", "standard", "missing module", "missing owner"} {
+		t.Run(axis, func(t *testing.T) {
+			original, version, main := foreign, foreign.SourceVersion, false
+			if axis == "primary" {
+				original, version, main = primary, "", true
+			}
+			data, err := json.Marshal(map[string]any{
+				"Dir": original.Root, "ImportPath": original.ModulePath,
+				"Module": map[string]any{"Path": original.ModulePath, "Version": version, "Main": main,
+					"Dir": original.Root, "GoMod": original.GoMod, "GoVersion": original.GoVersion},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			var selected goAMD64FrameSelection
+			if err := json.Unmarshal(data, &selected); err != nil {
+				t.Fatal(err)
+			}
+			// This is metadata predicate data, deliberately not a sealed source
+			// or a real OriginSet. It cannot Verify or supply frame authority.
+			source := &GoAMD64FrameSource{downloadedOrigin: &gooriginalsrc.OriginSet{}, downloadedModule: &primary,
+				downloadedImports: map[string]gooriginalsrc.Module{foreign.ModulePath + "@" + foreign.SourceVersion: foreign}}
+			switch axis {
+			case "unknown version":
+				selected.Module.Version = "v2.0.0"
+			case "namespace":
+				selected.Module.Path = primary.ModulePath
+			case "language":
+				selected.Module.GoVersion = "1.21"
+			case "main role":
+				selected.Module.Main = true
+			case "root":
+				selected.Module.Dir = primary.Root
+			case "metadata":
+				selected.Module.GoMod = primary.GoMod
+			case "package directory":
+				selected.Dir = primary.Root
+			case "package path":
+				selected.ImportPath += "/unobserved"
+			case "replacement":
+				selected.Module.Replace = json.RawMessage(`{}`)
+			case "standard":
+				selected.Standard = true
+			case "missing module":
+				selected.Module = nil
+			case "missing owner":
+				source.downloadedOrigin = nil
+			}
+			directory, err := source.downloadedDeclarationDirectory(selected)
+			if axis == "foreign" || axis == "primary" {
+				if err != nil || directory != original.Root {
+					t.Fatalf("consistent actual role lost metadata identity: %q, %v", directory, err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || directory != "" {
+				t.Fatalf("changed original module role was accepted: %q, %v", directory, err)
+			}
+			if err := source.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("metadata predicate manufactured actual frame authority", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_downloaded_frame_source.go b/amd64_go_downloaded_frame_source.go
new file mode 100644
index 000000000..9728c9229
--- /dev/null
+++ b/amd64_go_downloaded_frame_source.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+// GoAMD64DownloadedFrameCaptureRequest names original exact cache inputs. It
+// carries no observation, checker, object, signature or permission callback.
+type GoAMD64DownloadedFrameCaptureRequest struct {
+	Original                    GoAMD64FrameCaptureRequest
+	SourceModule, SourceVersion string
+}
+
+type goAMD64DownloadedIdentity struct {
+	module, version string
+}
+
+// CaptureGoAMD64DownloadedFrameSource independently executes stock Go and
+// closes the original ZIP, extracted members, declarations and whole objects.
+// Downloaded roles retain their primary module and independently observed
+// original import graph. Capture itself grants no memory permission.
+func CaptureGoAMD64DownloadedFrameSource(ctx context.Context, pkg GoPackage, request GoAMD64DownloadedFrameCaptureRequest) (*GoAMD64FrameSource, error) {
+	if module.Check(request.SourceModule, request.SourceVersion) != nil ||
+		module.CanonicalVersion(request.SourceVersion) != request.SourceVersion {
+		return nil, goAMD64FrameContext("downloaded capture requires a canonical exact source identity")
+	}
+	return captureGoAMD64FrameSource(ctx, pkg, request.Original,
+		&goAMD64DownloadedIdentity{module: request.SourceModule, version: request.SourceVersion})
+}
+
+func (source *GoAMD64FrameSource) captureDownloadedOrigin(ctx context.Context, exact goAMD64DownloadedIdentity, temporary string) (result error) {
+	cache, err := sourcepath.Resolve(source.env["GOMODCACHE"])
+	if err != nil {
+		return err
+	}
+	origins, err := gooriginalsrc.NewOriginSet(cache, source.request.GoBinary)
+	if err != nil {
+		return err
+	}
+	original, err := source.observeDownloadedModule(ctx, origins, exact, temporary)
+	if err != nil {
+		return err
+	}
+	if _, err := goAMD64DownloadedPackagePath(original, source.request.Directory); err != nil {
+		return err
+	}
+	source.downloadedOrigin, source.downloadedModule = origins, &original
+	source.downloadedImports = map[string]gooriginalsrc.Module{original.SourceModule + "@" + original.SourceVersion: original}
+	return source.verifyDownloadedOrigin()
+}
+
+func (source *GoAMD64FrameSource) legacyDownloadedModule() bool {
+	return source.downloadedModule != nil && source.downloadedModule.GoModOrigin == golegacymod.ProxyGoModProtocol
+}
+
+func (source *GoAMD64FrameSource) runDownloadedList(ctx context.Context, args []string) ([]byte, error) {
+	if source.numericalBinding != nil {
+		return nil, goAMD64FrameContext("legacy dependency query needs its separate numerical-command binding")
+	}
+	original := source.downloadedModule
+	path, err := goAMD64DownloadedPackagePath(*original, source.request.Directory)
+	if err != nil {
+		return nil, err
+	}
+	env, err := gooriginalsrc.DependencyQueryEnvironment(source.request.Environment)
+	if err != nil {
+		return nil, err
+	}
+	arguments := append([]string(nil), args...)
+	for index, argument := range arguments {
+		switch argument {
+		case ".":
+			arguments[index] = path
+		}
+	}
+	return gooriginalsrc.RunDependencyList(ctx, source.env["GOTMPDIR"],
+		original.SourceModule, original.SourceVersion, arguments, func(directory string, arguments []string) ([]byte, []byte, error) {
+			observed, err := goasmcmd.Observe(ctx, directory, env, source.request.GoBinary, arguments...)
+			return observed.Stdout, observed.Stderr, err
+		})
+}
+
+func (source *GoAMD64FrameSource) observeDownloadedModule(ctx context.Context, origins *gooriginalsrc.OriginSet,
+	exact goAMD64DownloadedIdentity, temporary string,
+) (_ gooriginalsrc.Module, result error) {
+	if module.Check(exact.module, exact.version) != nil || module.CanonicalVersion(exact.version) != exact.version {
+		return gooriginalsrc.Module{}, goAMD64FrameContext("downloaded dependency requires a canonical exact source identity")
+	}
+	boundary, err := gooriginalsrc.NewDownloadBoundary(temporary, "plan9asm-frame-download-", "example.invalid/plan9asm-frame-download")
+	if err != nil {
+		return gooriginalsrc.Module{}, err
+	}
+	defer func() {
+		result = errors.Join(result, boundary.Close())
+	}()
+	// This private command boundary is not a copied main/source module. Its
+	// sole purpose is to prevent stock Go mutating an ancestor go.mod/go.sum.
+	if err := boundary.Prepare(); err != nil {
+		return gooriginalsrc.Module{}, err
+	}
+	commandContext, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	data, err := goasmcmd.Run(commandContext, boundary.Directory(), source.request.Environment,
+		source.request.GoBinary, "mod", "download", "-json", exact.module+"@"+exact.version)
+	err = errors.Join(err, commandContext.Err())
+	if err != nil {
+		return gooriginalsrc.Module{}, err
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	var receipt gooriginalsrc.DownloadReceipt
+	if err := decoder.Decode(&receipt); err != nil {
+		return gooriginalsrc.Module{}, err
+	}
+	var extra any
+	if decoder.Decode(&extra) != io.EOF {
+		return gooriginalsrc.Module{}, goAMD64FrameContext("actual exact download receipt has incomplete or additional JSON")
+	}
+	var proxyMetadata *golegacymod.ProxyGoModProof
+	if _, err := os.Lstat(filepath.Join(receipt.Dir, "go.mod")); os.IsNotExist(err) {
+		// Source capture pins GOPROXY=off, but authenticated public checksum
+		// metadata remains independently readable. This neither creates a ZIP
+		// member nor turns a legacy dependency into an original main module.
+		proxyMetadata, _, err = golegacymod.CaptureCachedProxyGoMod(commandContext,
+			source.env["GOMODCACHE"], "off", exact.module, exact.version,
+			receipt.Sum, receipt.GoModSum, receipt.GoMod, nil)
+		if err != nil {
+			return gooriginalsrc.Module{}, err
+		}
+	}
+	original, err := origins.ObserveLegacy(ctx, exact.module, exact.version, receipt, proxyMetadata)
+	if err != nil {
+		return gooriginalsrc.Module{}, errors.Join(goAMD64FrameContext("exact original archive/source is not closed"), err)
+	}
+	return original, nil
+}
+
+func (source *GoAMD64FrameSource) verifyDownloadedOrigin() error {
+	if source.downloadedOrigin == nil && source.downloadedModule == nil {
+		return nil
+	}
+	if source.downloadedOrigin == nil || source.downloadedModule == nil {
+		return goAMD64FrameContext("missing exact original download/source role")
+	}
+	if _, err := goAMD64DownloadedPackagePath(*source.downloadedModule, source.request.Directory); err != nil {
+		return err
+	}
+	if err := source.downloadedOrigin.Verify(); err != nil {
+		return errors.Join(goAMD64FrameContext("exact original source was changed or revoked"), err)
+	}
+	return nil
+}
+
+// The original archive namespace and the declared Go package namespace are
+// distinct. Derive the latter only from the guarded module's own go.mod and
+// the actual canonical package directory, never from an import-path prefix.
+func goAMD64DownloadedPackagePath(original gooriginalsrc.Module, directory string) (string, error) {
+	relative, err := filepath.Rel(original.Root, directory)
+	if err != nil || !filepath.IsAbs(original.Root) || !filepath.IsAbs(directory) || !filepath.IsLocal(relative) {
+		return "", goAMD64FrameContext("downloaded package must remain inside its actual exact primary cache root")
+	}
+	path := original.ModulePath
+	if relative != "." {
+		path += "/" + filepath.ToSlash(relative)
+	}
+	if module.CheckImportPath(path) != nil {
+		return "", goAMD64FrameContext("downloaded package has an invalid original module-relative identity")
+	}
+	return path, nil
+}
diff --git a/amd64_go_downloaded_package_path_test.go b/amd64_go_downloaded_package_path_test.go
new file mode 100644
index 000000000..6ce9dcbd1
--- /dev/null
+++ b/amd64_go_downloaded_package_path_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+func TestGoAMD64DownloadedPackageIdentity(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "archive.example", "mirror@v1.0.0")
+	original := gooriginalsrc.Module{Root: root, ModulePath: "example.invalid/declared"}
+	for _, test := range []struct {
+		name, directory, want string
+	}{
+		{"root alias", root, "example.invalid/declared"},
+		{"nested alias", filepath.Join(root, "internal", "kernel"), "example.invalid/declared/internal/kernel"},
+		{"parent", filepath.Dir(root), ""},
+		{"prefix sibling", root + "-other", ""},
+		{"traversal", filepath.Join(root, "..", "other"), ""},
+		{"relative", "internal/kernel", ""},
+		{"invalid import", filepath.Join(root, "bad path"), ""},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := goAMD64DownloadedPackagePath(original, test.directory)
+			if test.want == "" {
+				if err == nil || got != "" {
+					t.Fatalf("unbound path acquired an original package identity: %q, %v", got, err)
+				}
+				return
+			}
+			if err != nil || got != test.want {
+				t.Fatalf("original declared package = %q, %v; want %q", got, err, test.want)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_adx_test.go b/amd64_go_frame_adx_test.go
new file mode 100644
index 000000000..778f964fb
--- /dev/null
+++ b/amd64_go_frame_adx_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64FrameADXMachineBoundaries(t *testing.T) {
+	for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+		for _, source := range []string{"AX", "8(SP)", "128(BX)(CX*4)"} {
+			t.Run(op+"/"+source, func(t *testing.T) {
+				assembly := "TEXT value(SB),4,$64-0\n" + op + " " + source + ",DX\nRET\n"
+				listing := x86InsertExtractGoListing(t, "amd64", assembly)
+				fn := goAMD64FrameFunction{positions: make(map[int]string)}
+				adxPC := -1
+				for _, line := range strings.Split(string(listing), "\n") {
+					fn.code = append(fn.code, x86InsertExtractListedBytes(line)...)
+					row := goAMD64FrameRow.FindStringSubmatch(line)
+					if row == nil || strings.HasPrefix(row[3], "TEXT") || strings.HasPrefix(row[3], "PCDATA") {
+						continue
+					}
+					pc, err := strconv.ParseInt(row[1], 16, 64)
+					if err != nil {
+						t.Fatal(err)
+					}
+					fn.positions[int(pc)] = row[3]
+					if strings.HasPrefix(row[3], op) {
+						adxPC = int(pc)
+					}
+				}
+				if adxPC < 0 {
+					t.Fatal("original Go listing lost ADX")
+				}
+				if err := goAMD64FrameMachineShape(fn, 64); err != nil {
+					t.Error("ordinary ADX must retain its original instruction boundary", err)
+				}
+				for _, mutation := range []string{"missing position", "interior position", "bad prefix", "truncated", "unbound CALL"} {
+					t.Run(mutation, func(t *testing.T) {
+						changed := fn
+						changed.code = append([]byte(nil), fn.code...)
+						changed.positions = make(map[int]string, len(fn.positions))
+						for pc, position := range fn.positions {
+							changed.positions[pc] = position
+						}
+						switch mutation {
+						case "missing position":
+							delete(changed.positions, adxPC)
+						case "interior position":
+							changed.positions[adxPC+1] = "not an instruction boundary"
+						case "bad prefix":
+							changed.code[adxPC] = 0xf2
+						case "truncated":
+							changed.code = changed.code[:adxPC+3]
+						case "unbound CALL":
+							copy(changed.code[adxPC:], []byte{0xe8, 0, 0, 0, 0})
+						}
+						if err := goAMD64FrameMachineShape(changed, 64); err == nil {
+							t.Fatal("ADX boundary observation granted invalid machine shape")
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_go_frame_byte_listing_test.go b/amd64_go_frame_byte_listing_test.go
new file mode 100644
index 000000000..47f9919b5
--- /dev/null
+++ b/amd64_go_frame_byte_listing_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"testing"
+	"time"
+)
+
+func TestGoAMD64FrameListingHexASCII(t *testing.T) {
+	const assembly = `TEXT ·Value(SB),4,$16-16
+	MOVQ a+0(FP),AX
+	MOVQ AX,0(SP)
+	MOVQ 0(SP),AX
+	MOVQ AX,ret+8(FP)
+	RET
+TEXT ·HexASCII(SB),4,$0-0
+	XORB (R8),AH
+	RET
+`
+	pkg, request, _, _ := fixedLocalTransportFixture(t, assembly,
+		"func Value(a uint64) uint64\nfunc HexASCII()\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("complete original Go listing with hex-looking ASCII", err)
+	}
+	defer source.Close()
+	fn, found := source.functions[pkg.Path+".HexASCII"]
+	if !found || !bytes.Equal(fn.code, []byte{0x41, 0x32, 0x20, 0xc3}) {
+		t.Fatalf("Go listing ASCII was interpreted as an instruction byte: %x", fn.code)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_go_frame_call_observation_go127_test.go b/amd64_go_frame_call_observation_go127_test.go
new file mode 100644
index 000000000..f6b8f401b
--- /dev/null
+++ b/amd64_go_frame_call_observation_go127_test.go
@@ -0,0 +1,192 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The outgoing words and declarations describe the source. Observing CALL's
+// relocation does not prove a callee ABI, reachable inputs or stack ownership.
+const frameOrdinaryCallAssembly = `TEXT ·Caller(SB),4,$24-24
+	MOVQ dst+0(FP),AX
+	MOVQ AX,0(SP)
+	MOVQ src+8(FP),AX
+	MOVQ AX,8(SP)
+	MOVQ n+16(FP),AX
+	MOVQ AX,16(SP)
+	CALL ·First(SB)
+	CALL ·Second(SB)
+	RET
+`
+
+func TestGoAMD64FrameOrdinaryCallObjectListingIdentity(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		for _, data := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/DATA=%t", target, data), func(t *testing.T) {
+				assembly := frameOrdinaryCallAssembly
+				if data {
+					assembly = "DATA literal<>+0(SB)/8,$7\nGLOBL literal<>(SB),8,$8\n" + assembly
+				}
+				declarations := "func Caller(dst,src *byte,n uintptr)\nfunc First(dst,src *byte,n uintptr)\nfunc Second(dst,src *byte,n uintptr)\n"
+				pkg, request := goAMD64FrameTypedFixture(t, declarations, assembly)
+				request.Target = target
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				objectPath := filepath.Join(t.TempDir(), "original.o")
+				env := append(append([]string(nil), request.Environment...),
+					"GOOS="+strings.Split(target, "/")[0], "GOARCH=amd64", "CGO_ENABLED=0",
+					"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+				listing, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+					"tool", "asm", "-S", "-p", pkg.Path, "-o", objectPath, request.AssemblyFile)
+				if err != nil {
+					t.Fatalf("original Go CALL object: %v\n%s", err, listing)
+				}
+				object, err := os.ReadFile(objectPath)
+				if err != nil {
+					t.Fatal(err)
+				}
+				builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src/cmd/internal/goobj/builtinlist.go"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				observed, err := gostaticstorage.ObserveAMD64AssemblyData([]byte(assembly), object, builtin, pkg.Path, target)
+				if err != nil || len(observed.Member.Texts) != 1 || len(observed.Member.Texts[0].Relocations) != 2 {
+					t.Fatal("independent complete CALL object observation", err)
+				}
+				for ordinal, relocation := range observed.Member.Texts[0].Relocations {
+					t.Logf("actual original relocation %d: %+v", ordinal, relocation)
+					want := fmt.Sprintf("rel %d+4 t=R_CALL %s+0", relocation.Offset, relocation.Target.Name)
+					if relocation.Type != 7 || relocation.Size != 4 || relocation.Add != 0 ||
+						!relocation.Target.ABIKnown || relocation.Target.ABI != 0 ||
+						!strings.Contains(string(listing), want) {
+						t.Fatal("the original Go producer did not emit the expected direct ABI0 CALL format", relocation, string(listing))
+					}
+					if got := goAMD64FrameDataRelocationLine(relocation, &observed); got != want {
+						t.Error("ordinary CALL record lost exact object/listing association", got, want)
+					}
+				}
+				// This is a deliberately distinct source-contract negative. A
+				// correct observation still cannot make these external CALLs into
+				// the existing same-source private-leaf frame contract.
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := goAMD64FrameSourceInstructions(file.Funcs[0], map[string]bool{}); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("object observation granted an ordinary callee/frame role", err)
+				}
+				if target != "windows/amd64" {
+					frameOrdinaryCallListingGuards(t, pkg, request, file, assembly, listing, &observed)
+				}
+				owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+				if owner != nil {
+					if closeErr := owner.Close(); closeErr != nil {
+						t.Error(closeErr)
+					}
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "original CALL needs its complete same-source leaf") {
+					t.Fatal("ordinary CALL acquired an unaudited fixed-local frame", err)
+				}
+			})
+		}
+	}
+}
+
+func frameOrdinaryCallListingGuards(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest,
+	file *File, assembly string, listing []byte, observed *gostaticstorage.AMD64AssemblyData) {
+	t.Helper()
+	input := listing
+	if len(observed.Layouts) != 0 {
+		var err error
+		input, err = goAMD64FrameDataListing(listing, observed)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	check := func(value []byte) error {
+		_, err := goAMD64FrameListingWithDataObject(value, file, pkg,
+			map[string]int{request.AssemblyFile: strings.Count(assembly, "\n") + 1},
+			observed, nil, request.Target, request.Directory, "")
+		return err
+	}
+	if err := check(input); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "original CALL needs its complete same-source leaf") {
+		t.Fatal("exact complete CALL listing did not reach the independent source permission check", err)
+	}
+	relocations := observed.Member.Texts[0].Relocations
+	first := []byte("\t" + goAMD64FrameDataRelocationLine(relocations[0], observed) + "\n")
+	second := []byte("\t" + goAMD64FrameDataRelocationLine(relocations[1], observed) + "\n")
+	for name, replacement := range map[string][]byte{
+		"foreign":   bytes.Replace(first, []byte(pkg.Path+".First"), []byte("foreign.First"), 1),
+		"offset":    bytes.Replace(first, []byte(fmt.Sprintf("rel %d+", relocations[0].Offset)), []byte(fmt.Sprintf("rel %d+", relocations[0].Offset+1)), 1),
+		"width":     bytes.Replace(first, []byte("+4 t="), []byte("+8 t="), 1),
+		"type":      bytes.Replace(first, []byte("R_CALL"), []byte("R_PCREL"), 1),
+		"addend":    bytes.Replace(first, []byte("First+0"), []byte("First+1"), 1),
+		"missing":   nil,
+		"duplicate": append(append([]byte(nil), first...), first...),
+		"reordered": second,
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := bytes.Replace(input, first, replacement, 1)
+			err := check(changed)
+			if bytes.Equal(changed, input) || !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "object/listing relocation") {
+				t.Fatal("changed CALL listing retained its exact original association", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameCallRelocationRetainsPrivateIdentity(t *testing.T) {
+	assembly := fixedLocalPrivateLeafSource("CALL leaf<>(SB)\nCALL other<>(SB)", "MOVQ (BP),AX") +
+		"TEXT other<>(SB),4,$0\nADDQ $1,AX\nRET\n"
+	pkg, request, _ := fixedLocalPrivateLeafFixture(t, assembly)
+	owner := requireGoAMD64FrameCapture(t, pkg, request)
+	expanded, err := owner.preprocess(request.AssemblyFile, []byte(assembly))
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := owner.fixedLocalDataObservation(request.AssemblyFile, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := observed.TextOrder[0].ObjectOrdinal
+	if len(observed.Member.Texts[root].Relocations) != 2 {
+		t.Fatal("the private CALL control lost its two exact source/object targets")
+	}
+	original := observed.Member.Texts[root].Relocations[0]
+	if goAMD64FrameDataRelocationLine(original, observed) == "" {
+		t.Fatal("existing private CALL lost its observation")
+	}
+	for _, test := range []struct {
+		name string
+		edit func(*gostaticstorage.TextRelocation)
+	}{
+		{"bank", func(r *gostaticstorage.TextRelocation) { r.Target.PackageIndex++ }},
+		{"relative", func(r *gostaticstorage.TextRelocation) { r.Target.SymbolIndex++ }},
+		{"ABI", func(r *gostaticstorage.TextRelocation) { r.Target.ABI++ }},
+		{"unknown-ABI", func(r *gostaticstorage.TextRelocation) { r.Target.ABIKnown = false }},
+		{"width", func(r *gostaticstorage.TextRelocation) { r.Size = 8 }},
+		{"addend", func(r *gostaticstorage.TextRelocation) { r.Add = 1 }},
+		{"kind", func(r *gostaticstorage.TextRelocation) { r.Type = 10 }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			changed := original
+			test.edit(&changed)
+			if goAMD64FrameDataRelocationLine(changed, observed) != "" {
+				t.Fatal("ordinary CALL formatting reclassified a mismatched local identity", changed)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_command_root_test.go b/amd64_go_frame_command_root_test.go
new file mode 100644
index 000000000..8d0523bab
--- /dev/null
+++ b/amd64_go_frame_command_root_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestGoAMD64FrameSourceRetainsCommandSDKIdentity(t *testing.T) {
+	for _, mutation := range []string{"command-spelling", "physical-root"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			physical, err := sourcepath.Resolve(filepath.Dir(filepath.Dir(request.GoBinary)))
+			if err != nil {
+				t.Fatal(err)
+			}
+			alias := filepath.Join(t.TempDir(), "selected-sdk")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			link := func(target string) {
+				t.Helper()
+				if runtime.GOOS == "windows" {
+					output, err := goasmcmd.Run(ctx, "", nil, "cmd", "/c", "mklink", "/J", alias, target)
+					if err != nil {
+						t.Fatalf("create actual SDK junction: %v; %s", err, output)
+					}
+				} else if err := os.Symlink(target, alias); err != nil {
+					t.Fatal(err)
+				}
+			}
+			link(physical)
+			request.Environment = append(request.Environment, "GOROOT="+alias)
+			original, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary, "env", "GOROOT")
+			if err != nil || strings.TrimSpace(string(original)) != alias || alias == physical {
+				t.Fatalf("actual driver did not retain a distinct SDK spelling: %q; %v", original, err)
+			}
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if source.env["command/GOROOT"] != alias || source.env["GOROOT"] != physical {
+				t.Fatalf("command spelling and physical SDK were conflated: %v", source.env)
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "command-spelling":
+				// The same physical SDK under a new command spelling can change
+				// compiled builtin tools; it must not reuse the observation.
+				source.request.Environment = append(source.request.Environment, "GOROOT="+physical)
+			case "physical-root":
+				if err := os.Remove(alias); err != nil {
+					t.Fatal(err)
+				}
+				link(t.TempDir())
+			}
+			if err := source.Verify(ctx); err == nil || source.ready {
+				t.Fatalf("changed %s retained source observation: %v", mutation, err)
+			} else if mutation == "command-spelling" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed command identity was not rejected as source context: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_complete_source_test.go b/amd64_go_frame_complete_source_test.go
new file mode 100644
index 000000000..49448d041
--- /dev/null
+++ b/amd64_go_frame_complete_source_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Original Go compilation is the acceptance oracle. Additional ordinary Go
+// declarations do not themselves grant caller memory or fixed-local backing.
+func TestGoAMD64FrameSourceCompleteOrdinaryGoDeclarations(t *testing.T) {
+	// Reuse only this root's owned compiler cache, not source identities.
+	// Every case still executes actual Go and consumes its selected export.
+	// Recent Go versions build objdump lazily, even for `go tool -n`.
+	// Prepare only the compiler artifact before any bounded source lease;
+	// each case still independently discovers and verifies the actual tool.
+	goAMD64FramePrepareOwnedToolCache(t)
+
+	for _, fixture := range []struct {
+		name, imports, declarations string
+	}{
+		{"body", "", "func Reference(a uint64) uint64 { return a + 1 }"},
+		{"values", "", "const Bias uint64 = 1\nvar Counter uint64"},
+		{"unused-type", "", "type Record struct { Bytes []byte; Value uint64 }"},
+		{"unused-interface", "", "type XOF interface { Read([]byte) (int, error); Clone() XOF }"},
+		{"unused-function", "", "type Callback func([]byte) error"},
+		{"unused-map", "", "type Cache map[string][]byte"},
+		{"unused-channel", "", "type Queue chan []byte"},
+		{"unused-float", "", "type Scalar float64"},
+		{"unused-recursive", "", "type Node struct { Next *Node; Value uint64 }"},
+		{"unused-generic", "", "type Box[T any] struct { Value T }"},
+		{"unused-interface-alias", "", "type XOF = interface { Read([]byte) (int, error) }"},
+		{"sdk-import", "import \"math/bits\"", "func Reference(a uint64) uint64 { return bits.RotateLeft64(a, 1) }"},
+		{"unrelated-body-transport", "", "func Reference(a float64) float64 { return a + 1 }"},
+		{"combined", "import \"math/bits\"", "const Bias = 1\nvar Counter uint64\nfunc Reference(a uint64) uint64 { return bits.RotateLeft64(a, Bias) }"},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			_, request := goAMD64FrameSourceFixture(t)
+			text := "package framefixture\n" + fixture.imports + "\nfunc Value(a uint64) uint64\n" + fixture.declarations + "\n"
+			if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte(text), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			env := append(append([]string(nil), request.Environment...),
+				"GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOTOOLCHAIN=local",
+				"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+			command := exec.CommandContext(ctx, request.GoBinary,
+				"list", "-deps", "-export", "-compiled", "-json", "-mod=readonly", ".")
+			command.Dir, command.Env = request.Directory, env
+			output, diagnostics, err := runtimeOracleMachineOutput(ctx, command)
+			if err != nil {
+				t.Fatalf("original Go rejected complete ordinary source: %v\n%s\n%s", err, output, diagnostics)
+			}
+			var selected goAMD64FrameSelection
+			exports := make(map[string]string)
+			decoder := json.NewDecoder(bytes.NewReader(output))
+			for {
+				var member goAMD64FrameSelection
+				if err := decoder.Decode(&member); err == io.EOF {
+					break
+				} else if err != nil || member.ImportPath == "" || len(member.Error)+len(member.DepsErrors) != 0 {
+					t.Fatalf("original Go compiler graph is incomplete: %+v: %v", member, err)
+				}
+				exports[member.ImportPath] = member.Export
+				if member.Module != nil && member.Module.Main {
+					if selected.ImportPath != "" {
+						t.Fatal("original Go selected more than one owned package")
+					}
+					selected = member
+				}
+			}
+			if selected.ImportPath != "example.invalid/framefixture" || len(selected.CompiledGoFiles) != 1 || len(selected.SFiles) != 1 {
+				t.Fatalf("original Go omitted the complete Go/ASM source pair: %+v", selected)
+			}
+			export, err := os.ReadFile(selected.Export)
+			if err != nil || len(export) == 0 {
+				t.Fatalf("original Go omitted compiled package/assembly export: %v", err)
+			}
+			t.Logf("ORIGINAL_GO_COMPLETE_FRAME_SOURCE role=%s go_sha=%x export_sha=%x", fixture.name,
+				sha256.Sum256([]byte(text)), sha256.Sum256(export))
+			set := token.NewFileSet()
+			syntax, err := parser.ParseFile(set, filepath.Join(request.Directory, "value.go"), text, parser.ParseComments)
+			if err != nil {
+				t.Fatal(err)
+			}
+			actualImporter := importer.ForCompiler(set, "gc", func(path string) (io.ReadCloser, error) {
+				return os.Open(exports[path])
+			})
+			typed, err := (&types.Config{Importer: actualImporter, Sizes: types.SizesFor("gc", "amd64")}).Check(
+				selected.ImportPath, set, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatalf("Go-accepted ordinary declarations lost original frame observation: %v", err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			function, found := source.functions[pkg.Path+".Value"]
+			if !found || function.locals != 168 || function.args != 16 || function.transport != goAMD64FrameNumericTransport {
+				t.Fatalf("complete source changed the independently captured numeric ASM frame: %+v", function)
+			}
+			if len(source.functions) != 1 || len(source.declarations) != 1 {
+				t.Fatal("unrelated ordinary Go declarations became ASM frame capabilities")
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_context.go b/amd64_go_frame_context.go
new file mode 100644
index 000000000..6a0aeac07
--- /dev/null
+++ b/amd64_go_frame_context.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// Caller contexts are callbacks, not safe command contexts under an observer
+// lock. Capture only their actual lifetime outside locks; commands consume a
+// standard private context with the same (never extended) deadline/Done signal.
+// The original context remains the published binding's lifetime authority.
+type goAMD64FramePrivateContext struct {
+	context.Context
+	original context.Context
+	deadline time.Time
+	bounded  bool
+	done     <-chan struct{}
+	cancel   context.CancelFunc
+	stop     func()
+}
+
+func captureGoAMD64FramePrivateContext(original context.Context) (*goAMD64FramePrivateContext, error) {
+	if original == nil {
+		return nil, goAMD64FrameContext("missing caller context")
+	}
+	if err := original.Err(); err != nil {
+		return nil, err
+	}
+	deadline, bounded := original.Deadline()
+	done := original.Done()
+	if _, err := sampleGoSourceContext(context.Background(), original,
+		goSourceContextLifetime{deadline: deadline, bounded: bounded, done: done, checkDone: true}, false,
+		goAMD64FrameContext("caller context lifetime changed during capture")); err != nil {
+		return nil, err
+	}
+	var private context.Context
+	var cancel context.CancelFunc
+	if bounded {
+		private, cancel = context.WithDeadline(context.Background(), deadline)
+	} else {
+		private, cancel = context.WithCancel(context.Background())
+	}
+	finished, stopped := make(chan struct{}), make(chan struct{})
+	go func() {
+		defer close(stopped)
+		select {
+		case <-done:
+			cancel()
+		case <-private.Done():
+		case <-finished:
+		}
+	}()
+	return &goAMD64FramePrivateContext{Context: private, original: original,
+		deadline: deadline, bounded: bounded, done: done, cancel: cancel,
+		stop: func() {
+			close(finished)
+			cancel()
+			<-stopped
+		}}, nil
+}
+
+// Always called outside observer locks. Retain actual cancellation causes and
+// reject a caller that changes its captured lifetime while work is in flight.
+func (ctx *goAMD64FramePrivateContext) verify() error {
+	_, err := sampleGoSourceContext(ctx.Context, ctx.original,
+		goSourceContextLifetime{deadline: ctx.deadline, bounded: ctx.bounded, done: ctx.done, checkDone: true}, false,
+		goAMD64FrameContext("caller context lifetime changed during observation"))
+	if goSourceContextDone(ctx.done) {
+		ctx.cancel()
+	}
+	// Context is the privately constructed standard command context, not the
+	// original caller implementation. No user callback follows the checkpoint.
+	return errors.Join(err, ctx.Context.Err())
+}
diff --git a/amd64_go_frame_context_test.go b/amd64_go_frame_context_test.go
new file mode 100644
index 000000000..b1f1a914a
--- /dev/null
+++ b/amd64_go_frame_context_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type goAMD64FrameCallbackContext struct {
+	context.Context
+	method   string
+	armed    atomic.Bool
+	called   atomic.Bool
+	locked   atomic.Bool
+	callback func()
+}
+
+func (ctx *goAMD64FrameCallbackContext) call(method string) {
+	if ctx.method == method && ctx.armed.CompareAndSwap(true, false) {
+		ctx.called.Store(true)
+		ctx.callback()
+	}
+}
+
+func (ctx *goAMD64FrameCallbackContext) Err() error {
+	ctx.call("Err")
+	return ctx.Context.Err()
+}
+
+func (ctx *goAMD64FrameCallbackContext) Deadline() (time.Time, bool) {
+	ctx.call("Deadline")
+	return ctx.Context.Deadline()
+}
+
+func (ctx *goAMD64FrameCallbackContext) Done() <-chan struct{} {
+	ctx.call("Done")
+	return ctx.Context.Done()
+}
+
+func goAMD64FrameCloseCallback(t *testing.T, original context.Context, source *GoAMD64FrameSource, method string) *goAMD64FrameCallbackContext {
+	t.Helper()
+	ctx := &goAMD64FrameCallbackContext{Context: original, method: method}
+	ctx.callback = func() {
+		// A synchronous Close here would deadlock if the callback owns mu.
+		// Record the actual lock boundary without leaving a blocked goroutine
+		// or a deferred cleanup that can never complete in the RED test.
+		if !source.mu.TryLock() {
+			ctx.locked.Store(true)
+			return
+		}
+		source.mu.Unlock()
+		if err := source.Close(); err != nil {
+			t.Errorf("context callback could not close its original source: %v", err)
+		}
+	}
+	return ctx
+}
+
+func TestGoAMD64FrameVerifyContextCallbacksMayClose(t *testing.T) {
+	for _, method := range []string{"Err", "Deadline", "Done"} {
+		t.Run(method, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			original, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(original, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			ctx := goAMD64FrameCloseCallback(t, original, source, method)
+			ctx.armed.Store(true)
+			err = source.Verify(ctx)
+			if ctx.locked.Load() || !ctx.called.Load() {
+				t.Fatalf("caller %s callback ran under frame lock (Close would deadlock) or was never sampled", method)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("callback-closed source verified", err)
+			}
+			if err := source.Verify(original); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("callback source revocation was not permanent", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameBindRetainsOriginalContextLifetime(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	original, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := source.BindFixedLocal(original, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binding := bound.Sigs[pkg.Path+".Value"].x86FixedLocal
+	if binding == nil || binding.context != original {
+		t.Fatal("binding retained temporary private command context instead of caller lifetime")
+	}
+	if err := binding.verify(); err != nil {
+		t.Fatal("stopping private binder commands revoked the live original binding", err)
+	}
+	cancel()
+	if err := binding.verify(); !errors.Is(err, context.Canceled) {
+		t.Fatal("original caller cancellation was ignored", err)
+	}
+	if err := source.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("fresh context revived a source revoked by original binding cancellation", err)
+	}
+}
+
+type goAMD64FramePostContext struct {
+	context.Context
+	samples  int
+	callback func()
+}
+
+func (ctx *goAMD64FramePostContext) Err() error {
+	ctx.samples++
+	if ctx.samples == 3 {
+		// The first two samples capture the caller lifetime. This sample is
+		// the final callback boundary after the complete locked command round.
+		ctx.callback()
+	}
+	return ctx.Context.Err()
+}
+
+func TestGoAMD64FrameVerifyPostContextMutationRevokes(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	original, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(original, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	ctx := &goAMD64FramePostContext{Context: original, callback: func() {
+		if !source.mu.TryLock() {
+			t.Fatal("post-context callback held the frame lock")
+		}
+		source.mu.Unlock()
+		if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte("changed original source\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) || ctx.samples < 3 {
+		t.Fatal("final caller callback changed source after the last complete input guard", err)
+	}
+	if err := source.Verify(original); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("final callback mutation did not permanently revoke source", err)
+	}
+}
+
+type goAMD64FrameChangingContext struct {
+	context.Context
+	shift time.Duration
+	done  <-chan struct{}
+}
+
+func (ctx *goAMD64FrameChangingContext) Deadline() (time.Time, bool) {
+	deadline, bounded := ctx.Context.Deadline()
+	return deadline.Add(ctx.shift), bounded
+}
+
+func (ctx *goAMD64FrameChangingContext) Done() <-chan struct{} {
+	return ctx.done
+}
+
+func TestGoAMD64FramePrivateContextExactLifetime(t *testing.T) {
+	if private, err := captureGoAMD64FramePrivateContext(nil); private != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("nil caller acquired a private command context", err)
+	}
+	for _, bounded := range []bool{false, true} {
+		original := context.Background()
+		cancel := func() {}
+		if bounded {
+			original, cancel = context.WithTimeout(original, time.Minute)
+		}
+		private, err := captureGoAMD64FramePrivateContext(original)
+		if err != nil {
+			cancel()
+			t.Fatal(err)
+		}
+		want, wantBounded := original.Deadline()
+		got, gotBounded := private.Deadline()
+		if gotBounded != wantBounded || gotBounded && !got.Equal(want) || private.verify() != nil {
+			t.Fatal("private context changed actual ordinary caller lifetime")
+		}
+		private.stop()
+		if original.Err() != nil || !errors.Is(private.Err(), context.Canceled) {
+			t.Fatal("owned private cleanup canceled its original caller")
+		}
+		cancel()
+	}
+	for _, axis := range []string{"deadline", "done", "cancel"} {
+		t.Run(axis, func(t *testing.T) {
+			original, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			caller := &goAMD64FrameChangingContext{Context: original, done: original.Done()}
+			private, err := captureGoAMD64FramePrivateContext(caller)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer private.stop()
+			switch axis {
+			case "deadline":
+				caller.shift = time.Second
+			case "done":
+				caller.done = make(chan struct{})
+			case "cancel":
+				cancel()
+			}
+			if err := private.verify(); axis == "cancel" && !errors.Is(err, context.Canceled) ||
+				axis != "cancel" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed actual caller lifetime was accepted", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_data.go b/amd64_go_frame_data.go
new file mode 100644
index 000000000..ee072f79b
--- /dev/null
+++ b/amd64_go_frame_data.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func (source *GoAMD64FrameSource) frameDataObject(expanded string, object []byte) (*gostaticstorage.AMD64AssemblyData, error) {
+	if !gotoolchain.AuditedGo127(source.env["GOVERSION"]) || source.numericalBinding != nil {
+		return nil, goAMD64FrameContext("mixed DATA needs its independent actual Go object producer")
+	}
+	builtin, err := source.read(filepath.Join(source.env["GOROOT"], "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		return nil, err
+	}
+	observed, err := gostaticstorage.ObserveAMD64AssemblyData([]byte(expanded), object, builtin,
+		source.selection.ImportPath, source.request.Target)
+	if err != nil {
+		return nil, goAMD64FrameContext("complete original DATA/source object: %v", err)
+	}
+	return &observed, nil
+}
+
+// The SDK owner has already joined every original/expanded object to its actual
+// compiler archive. Reuse that same observation, not a new standalone object
+// with different producer flags. As with preprocessSDKFrame, these immutable
+// fields remain covered by the enclosing live source verification.
+func (source *GoAMD64FrameSource) fixedLocalDataObservation(name, expanded string) (*gostaticstorage.AMD64AssemblyData, error) {
+	if origin := source.sdkFrame; origin != nil {
+		if origin.identity != source || origin.owner == nil || origin.owner.source == nil {
+			return nil, goAMD64FrameContext("fixed local DATA has a foreign SDK source")
+		}
+		observation := &origin.owner.source.observation
+		for ordinal, input := range observation.ObjectInputs.Sources {
+			if input.Name != name {
+				continue
+			}
+			if observation.Objects == nil || ordinal >= len(observation.Objects.Sources) ||
+				ordinal >= len(observation.CPP) || string(input.Expanded) != expanded || observation.CPP[ordinal].Output != expanded {
+				return nil, goAMD64FrameContext("fixed local DATA lost its complete SDK source/object pairing")
+			}
+			object := observation.Objects.Sources[ordinal]
+			if object.Name != input.Name {
+				return nil, goAMD64FrameContext("fixed local DATA SDK object order changed")
+			}
+			return &gostaticstorage.AMD64AssemblyData{
+				Member: object.Original, Layouts: object.ExpandedLayouts, TextOrder: object.TextOrder,
+			}, nil
+		}
+		return nil, goAMD64FrameContext("fixed local DATA is absent from the complete SDK selection")
+	}
+	object, err := source.read(filepath.Join(source.owned, name+".o"))
+	if err != nil {
+		return nil, err
+	}
+	return source.frameDataObject(expanded, object)
+}
+
+// Consume exact complete DATA blocks, never arbitrary listing lines. TEXT and
+// Windows metadata remain in the original order for their independent parser.
+// This observation grants no permission to use a DATA address or load its bytes.
+func goAMD64FrameDataListing(listing []byte, observed *gostaticstorage.AMD64AssemblyData) ([]byte, error) {
+	if observed == nil || len(observed.Layouts) == 0 || len(listing) == 0 || listing[len(listing)-1] != '\n' {
+		return nil, goAMD64FrameContext("mixed DATA listing lacks a complete object/source inventory")
+	}
+	blocks := make(map[string][]string, len(observed.Layouts))
+	var headers []string
+	for _, layout := range observed.Layouts {
+		block, err := goAMD64FrameDataBlock(layout)
+		if err != nil {
+			return nil, err
+		}
+		if _, duplicate := blocks[block[0]]; duplicate {
+			return nil, goAMD64FrameContext("mixed DATA listing has an ambiguous complete symbol header")
+		}
+		blocks[block[0]] = block
+		headers = append(headers, block[0])
+	}
+	lines := strings.Split(string(listing), "\n")
+	var result strings.Builder
+	next := 0
+	for index := 0; index < len(lines)-1; index++ {
+		block, found := blocks[lines[index]]
+		if !found {
+			result.WriteString(lines[index] + "\n")
+			continue
+		}
+		if next >= len(headers) || block[0] != headers[next] ||
+			index+len(block) > len(lines)-1 || !reflect.DeepEqual(lines[index:index+len(block)], block) {
+			return nil, goAMD64FrameContext("mixed DATA listing bytes, extent or ordered relocations differ")
+		}
+		delete(blocks, block[0])
+		next++
+		index += len(block) - 1
+	}
+	if len(blocks) != 0 {
+		return nil, goAMD64FrameContext("mixed DATA listing omits an original definition")
+	}
+	return []byte(result.String()), nil
+}
+
+func goAMD64FrameDataBlock(layout gostaticstorage.ASMGlobalLayout) ([]string, error) {
+	definition := layout.Definition
+	kinds := map[uint8]string{3: "SRODATA", 4: "SRODATAFIPS", 5: "SNOPTRDATA", 6: "SNOPTRDATAFIPS",
+		7: "SDATA", 8: "SDATAFIPS", 9: "SBSS", 10: "SNOPTRBSS", 11: "STLSBSS"}
+	kind := kinds[definition.Kind]
+	if kind == "" || definition.Name == "" || definition.Name != layout.Name || definition.ABI != layout.ABI {
+		return nil, goAMD64FrameContext("mixed DATA header lacks its exact source/object identity")
+	}
+	header := definition.Name + " " + kind + " "
+	if layout.Static {
+		header += "static "
+	}
+	if definition.Flags&1 != 0 {
+		header += "dupok "
+	}
+	// Go's GloblPos consumes DUPOK/RODATA/NOPTR/TLSBSS only; unrelated
+	// TEXT flags, including CFunc, do not change the DATA listing header.
+	header += fmt.Sprintf("size=%d align=%#x", definition.Size, definition.Align)
+	block := []string{header}
+	for offset := 0; offset < len(definition.Data); offset += 16 {
+		var row strings.Builder
+		fmt.Fprintf(&row, "\t%#04x", offset)
+		end := offset + 16
+		if end > len(definition.Data) {
+			end = len(definition.Data)
+		}
+		for _, value := range definition.Data[offset:end] {
+			fmt.Fprintf(&row, " %02x", value)
+		}
+		row.WriteString(strings.Repeat("   ", offset+16-end) + "  ")
+		for _, value := range definition.Data[offset:end] {
+			if value < ' ' || value > '~' {
+				value = '.'
+			}
+			row.WriteByte(value)
+		}
+		block = append(block, row.String())
+	}
+	for _, relocation := range definition.Relocations {
+		if relocation.Type != 1 || !relocation.Target.ABIKnown {
+			return nil, goAMD64FrameContext("mixed DATA initializer has an unbound relocation")
+		}
+		block = append(block, fmt.Sprintf("\trel %d+%d t=R_ADDR %s+%d",
+			relocation.Offset, relocation.Size, relocation.Target.Name, relocation.Add))
+	}
+	return block, nil
+}
+
+func goAMD64FrameDataRelocationLine(relocation gostaticstorage.TextRelocation, observed *gostaticstorage.AMD64AssemblyData) string {
+	if line := goAMD64FramePrivateCallRelocation(relocation, observed); line != "" {
+		return line // Exact local TEXT identity only; the caller validates its leaf role.
+	}
+	if relocation.Type == 7 && relocation.Size == 4 && relocation.Add == 0 &&
+		relocation.Target.ABIKnown && relocation.Target.ABI == 0 && relocation.Target.Name != "" {
+		for _, text := range observed.Member.Texts {
+			if text.Name == relocation.Target.Name {
+				return "" // A mismatched local TEXT cannot become an external call.
+			}
+		}
+		// Observe the original direct CALL spelling only. Its source, callee
+		// signature and frame permissions are validated independently.
+		return fmt.Sprintf("rel %d+%d t=R_CALL %s+0",
+			relocation.Offset, relocation.Size, relocation.Target.Name)
+	}
+	if relocation.Type != 14 || relocation.Size != 4 || !relocation.Target.ABIKnown {
+		return ""
+	}
+	packageIndices := map[gostaticstorage.TextSymbolNamespace]uint32{
+		gostaticstorage.TextSymbolSelf:             2147483643,
+		gostaticstorage.TextSymbolHashed64:         2147483646,
+		gostaticstorage.TextSymbolHashed:           2147483645,
+		gostaticstorage.TextSymbolNonpkgDefinition: 2147483647,
+	}
+	for _, layout := range observed.Layouts {
+		definition := layout.Definition
+		if definition.Name != relocation.Target.Name {
+			continue
+		}
+		if definition.ABI == relocation.Target.ABI &&
+			packageIndices[definition.Namespace] == relocation.Target.PackageIndex &&
+			definition.Relative == relocation.Target.SymbolIndex {
+			return fmt.Sprintf("rel %d+%d t=R_PCREL %s+%d",
+				relocation.Offset, relocation.Size, relocation.Target.Name, relocation.Add)
+		}
+		return "" // A mismatched private definition cannot become an external role.
+	}
+	if relocation.Target.ABI == 0 && relocation.Target.Name != "" {
+		// Preserve ordinary references in the complete original TEXT inventory.
+		// This is only its exact object/listing spelling, not numerical access or
+		// address permission. Such a target is never added to private literalData.
+		return fmt.Sprintf("rel %d+%d t=R_PCREL %s+%d",
+			relocation.Offset, relocation.Size, relocation.Target.Name, relocation.Add)
+	}
+	return ""
+}
+
+func goAMD64FrameDataTextJoin(functions map[string]goAMD64FrameFunction, observed *gostaticstorage.AMD64AssemblyData,
+	directory string, origins map[string]int, root string) error {
+	if len(functions) != len(observed.Member.Texts) {
+		return goAMD64FrameContext("mixed DATA object/listing complete TEXT inventories differ")
+	}
+	for _, text := range observed.Member.Texts {
+		fn, found := functions[text.Name]
+		if !found || text.ABI != fn.nativeABI || text.Kind != 1 && text.Kind != 2 || text.Flags != fn.nativeFlags() || text.Flags2 != 0 || !bytes.Equal(text.Code, fn.code) {
+			return goAMD64FrameContext("mixed DATA object/listing TEXT ABI, flags or complete bytes differ")
+		}
+		if err := goAMD64FrameSourcePCs(text, fn, directory, origins, root); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/amd64_go_frame_data_boundaries_go127_test.go b/amd64_go_frame_data_boundaries_go127_test.go
new file mode 100644
index 000000000..fc78ed9dd
--- /dev/null
+++ b/amd64_go_frame_data_boundaries_go127_test.go
@@ -0,0 +1,53 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestGoAMD64FrameDataWholeMaskAESBoundaries(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+		rows = append(rows, op+" literal<>+1(SB),K1", op+" K1,literal<>+1(SB)")
+	}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, op := range []string{"VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST"} {
+			rows = append(rows, op+" literal<>+1(SB),"+bank+"0,"+bank+"1")
+			if bank != "Z" {
+				// Force the distinct EVEX.128/256 rows, not only VEX.
+				rows = append(rows, op+" literal<>+1(SB),"+bank+"0,"+bank+"16")
+			}
+		}
+	}
+	rows = append(rows, "VAESIMC literal<>+1(SB),X0",
+		"VAESKEYGENASSIST $255,literal<>+1(SB),X0", "VAESKEYGENASSIST $-128,literal<>+1(SB),X0")
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row+"\nRET")
+			if len(pcs) != 2 {
+				t.Fatal("independent original instruction inventory changed", pcs)
+			}
+			decode := decodedX86MaskMoveInstruction
+			if strings.HasPrefix(row, "VAES") {
+				decode = decodedX86AESInstruction
+			}
+			if _, _, known, err := decode(code, 64); !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatal("ordinary raw decoding borrowed a physical RIP source", known, err)
+			}
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+			if err != nil || len(boundaries) != 2 || boundaries[0].Length != int(pcs[1]) ||
+				len(scalar) != 1 || scalar[pcs[1]].Op != x86asm.RET {
+				t.Fatal("whole original mask/AES boundary lost physical RIP", boundaries, scalar, err)
+			}
+			for cut := 1; cut < int(pcs[1]); cut++ {
+				if values, _, err := x86NumericalNativeBoundaries(code[:cut], 64); err == nil || values != nil {
+					t.Fatal("truncated original mask/AES acquired a boundary", cut, err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_data_go127_test.go b/amd64_go_frame_data_go127_test.go
new file mode 100644
index 000000000..5dc40aafa
--- /dev/null
+++ b/amd64_go_frame_data_go127_test.go
@@ -0,0 +1,211 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64FrameDataOrdinaryReferenceIsNotPermission(t *testing.T) {
+	const assembly = `DATA literal<>+0(SB)/8,$7
+GLOBL literal<>(SB),8,$8
+TEXT ·Value(SB),4,$16-16
+	MOVQ a+0(FP),AX
+	MOVQ AX,0(SP)
+	MOVQ literal<>(SB),CX
+	MOVQ $·Global(SB),BX
+	MOVQ 0(SP),AX
+	MOVQ AX,ret+8(FP)
+	RET
+`
+	pkg, request, file, options := fixedLocalTransportFixture(t, assembly,
+		"func Global() {}\nfunc Value(a uint64) uint64\n", "linux/amd64", "x86_64-unknown-linux-gnu")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete original DATA and ordinary reference", err)
+	}
+	if _, err := source.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("observing an ordinary code reference granted a variable address role", err)
+	}
+}
+
+// DATA coexistence is an original-object observation, not a new memory,
+// address, native-entry or fixed-local permission.
+func TestGoAMD64FrameSourceMixedDataOriginalObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		for _, used := range []bool{false, true} {
+			name := "unused"
+			if used {
+				name = "referenced"
+			}
+			t.Run(target+"/"+name, func(t *testing.T) {
+				pkg, request := goAMD64FrameSourceFixture(t)
+				request.Target = target
+				assembly := "DATA literal<>+0(SB)/8,$0x102030405060708\n" +
+					"DATA literal<>+16(SB)/4,$\"abcd\"\n" +
+					"GLOBL literal<>(SB),8,$32\n" +
+					"DATA mutable<>+0(SB)/8,$0x55667788\n" +
+					"GLOBL mutable<>(SB),16,$8\n" +
+					"GLOBL zero<>(SB),16,$24\n" +
+					"DATA pointer<>+0(SB)/8,$literal<>+8(SB)\n" +
+					"GLOBL pointer<>(SB),8,$8\n" +
+					"TEXT ·Value(SB),4,$160-16\n" +
+					"MOVQ a+0(FP),AX\nMOVQ AX,16(SP)\n"
+				if used {
+					assembly += "MOVQ literal<>+8(SB),CX\n"
+				}
+				assembly += "MOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				env := append(append([]string(nil), request.Environment...),
+					"GOOS="+strings.Split(target, "/")[0], "GOARCH=amd64", "CGO_ENABLED=0",
+					"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+				listing, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+					"tool", "asm", "-S", "-p", pkg.Path, "-o", filepath.Join(t.TempDir(), "original.o"), request.AssemblyFile)
+				if err != nil {
+					t.Fatalf("independent original Go mixed TEXT/DATA control: %v\n%s", err, listing)
+				}
+				t.Logf("original Go listing:\n%s", listing)
+				source := requireGoAMD64FrameCapture(t, pkg, request)
+				if len(source.functions) != 1 || source.functions[pkg.Path+".Value"].locals != 168 {
+					t.Fatal("mixed DATA lost the original complete frame inventory")
+				}
+				if err := source.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				goAMD64FrameMixedDataJoinGuards(t, pkg, source, used)
+				changed := strings.Replace(assembly, "0x102030405060708", "0x102030405060709", 1)
+				path := filepath.Join(request.Directory, request.AssemblyFile)
+				if err := os.WriteFile(path, []byte(changed), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed original DATA retained the frame observation", err)
+				}
+				if err := os.WriteFile(path, []byte(assembly), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("restored DATA revived a revoked frame observation", err)
+				}
+			})
+		}
+	}
+}
+
+func goAMD64FrameMixedDataJoinGuards(t *testing.T, pkg GoPackage, source *GoAMD64FrameSource, used bool) {
+	t.Helper()
+	objectPath := filepath.Join(source.owned, source.request.AssemblyFile+".o")
+	object, err := source.read(objectPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	listing, err := source.read(objectPath + ".listing")
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := source.read(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := source.preprocess(source.request.AssemblyFile, original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := source.frameDataObject(expanded, object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var unwind *gostaticstorage.WindowsAMD64AssemblyUnwind
+	if source.request.Target == "windows/amd64" {
+		value, err := source.observeWindowsUnwind(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		unwind = &value
+	}
+	check := func(input []byte) error {
+		filtered, err := goAMD64FrameDataListing(input, observed)
+		if err != nil {
+			return err
+		}
+		functions, err := goAMD64FrameListingWithDataObject(filtered, file, pkg, source.origins, observed, unwind,
+			source.request.Target, source.request.Directory, "")
+		if err != nil {
+			return err
+		}
+		return goAMD64FrameDataTextJoin(functions, observed, source.request.Directory, source.origins, "")
+	}
+	if err := check(listing); err != nil {
+		t.Fatal("complete unmodified source/object/listing control", err)
+	}
+	changes := map[string][2]string{
+		"DATA kind":       {"literal SRODATA", "literal SDATA"},
+		"DATA static":     {"literal SRODATA static", "literal SRODATA"},
+		"DATA dupok":      {"literal SRODATA static", "literal SRODATA static dupok"},
+		"DATA size":       {"size=32 align=0x0", "size=33 align=0x0"},
+		"DATA alignment":  {"size=32 align=0x0", "size=32 align=0x8"},
+		"DATA byte":       {"08 07 06 05", "09 07 06 05"},
+		"DATA ASCII":      {"abcd\n", "abce\n"},
+		"DATA offset":     {"0x0010 61 62 63 64", "0x0011 61 62 63 64"},
+		"DATA relocation": {"R_ADDR literal+8", "R_ADDR literal+16"},
+		"DATA target":     {"R_ADDR literal+8", "R_ADDR mutable+8"},
+		"DATA BSS extent": {"zero SNOPTRBSS static size=24", "zero SNOPTRBSS static size=25"},
+		"TEXT bytes":      {"55 48 89 e5", "90 48 89 e5"},
+	}
+	if used {
+		changes["TEXT relocation"] = [2]string{"R_PCREL literal+8", "R_PCREL literal+16"}
+		changes["TEXT target"] = [2]string{"R_PCREL literal+8", "R_PCREL mutable+8"}
+	}
+	for name, change := range changes {
+		t.Run(name, func(t *testing.T) {
+			changed := bytes.Replace(listing, []byte(change[0]), []byte(change[1]), 1)
+			if bytes.Equal(changed, listing) {
+				t.Fatal("listing mutation did not touch the independent Go control")
+			}
+			if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed complete listing acquired an observation", err)
+			}
+		})
+	}
+	for _, suffix := range []string{"UNKNOWN_NATIVE_RECORD\n", "\trel 0+8 t=R_ADDR literal+8\n", "zero SNOPTRBSS static size=24 align=0x0\n"} {
+		if err := check(append(bytes.Clone(listing), suffix...)); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("extra DATA/listing record was ignored", err)
+		}
+	}
+	if used {
+		relocation := observed.Member.Texts[0].Relocations[0]
+		for _, mutate := range []func(*gostaticstorage.TextRelocation){
+			func(r *gostaticstorage.TextRelocation) { r.Type = 1 },
+			func(r *gostaticstorage.TextRelocation) { r.Size = 8 },
+			func(r *gostaticstorage.TextRelocation) { r.Target.ABIKnown = false },
+			func(r *gostaticstorage.TextRelocation) { r.Target.ABI = 1 },
+			func(r *gostaticstorage.TextRelocation) { r.Target.PackageIndex = 2147483647 },
+			func(r *gostaticstorage.TextRelocation) { r.Target.SymbolIndex++ },
+		} {
+			changed := relocation
+			mutate(&changed)
+			if changed == relocation || goAMD64FrameDataRelocationLine(changed, observed) != "" {
+				t.Fatal("DATA relocation lost exact object-local identity", changed)
+			}
+		}
+	}
+}
diff --git a/amd64_go_frame_fixture_flags_test.go b/amd64_go_frame_fixture_flags_test.go
new file mode 100644
index 000000000..2a495be80
--- /dev/null
+++ b/amd64_go_frame_fixture_flags_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"testing"
+)
+
+func TestGoAMD64FrameFixtureSeparatesHarnessBuildTags(t *testing.T) {
+	// The Windows LLVM harness needs this tag; the independent, pure-Go
+	// source fixture does not import LLVM and must have its own build role.
+	t.Setenv("GOFLAGS", "-tags=byollvm")
+	for _, target := range []string{"linux/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			request.Target = target
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			if os.Getenv("GOFLAGS") != "-tags=byollvm" {
+				t.Fatal("fixture changed its parent harness environment")
+			}
+			// An explicit caller request is still nonordinary. This fixture
+			// separation cannot relax production profile/source validation.
+			request.Environment = append(request.Environment, "GOFLAGS=-tags=foreign")
+			if changed, err := CaptureGoAMD64FrameSource(ctx, pkg, request); changed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("explicit foreign source profile was accepted", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_foreign_call_test.go b/amd64_go_frame_foreign_call_test.go
new file mode 100644
index 000000000..232c1b3ab
--- /dev/null
+++ b/amd64_go_frame_foreign_call_test.go
@@ -0,0 +1,358 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+type foreignABI0CallFixture struct {
+	name, target, declarations, outgoing string
+	args                                 []LLVMType
+}
+
+func foreignABI0CallFixtures() []foreignABI0CallFixture {
+	return []foreignABI0CallFixture{
+		{
+			name: "SDK-copy-pointer-pointer-word", target: "runtime.memmove",
+			declarations: "import _ \"runtime\"\nfunc Value(dst, src *byte, n uintptr) uint64\n",
+			outgoing:     "MOVQ AX,0(SP)\nMOVQ BX,8(SP)\nMOVQ CX,16(SP)\n",
+			args:         []LLVMType{Ptr, Ptr, I64},
+		},
+		{
+			name: "SDK-clear-pointer-word", target: "runtime.memclrNoHeapPointers",
+			declarations: "import _ \"runtime\"\nfunc Value(dst, src *byte, n uintptr) uint64\n",
+			outgoing:     "MOVQ AX,0(SP)\nMOVQ CX,8(SP)\n",
+			args:         []LLVMType{Ptr, I64},
+		},
+		{
+			name: "local-Go-body-pointer-pointer-word", target: "example.invalid/framefixture.Callee",
+			declarations: "func Value(dst, src *byte, n uintptr) uint64\n" +
+				"//go:noinline\nfunc Callee(dst, src *byte, n uintptr) { if n != 0 { *dst = *src } }\n",
+			outgoing: "MOVQ AX,0(SP)\nMOVQ BX,8(SP)\nMOVQ CX,16(SP)\n",
+			args:     []LLVMType{Ptr, Ptr, I64},
+		},
+	}
+}
+
+func foreignABI0CallAssembly(fixture foreignABI0CallFixture) string {
+	target := strings.ReplaceAll(fixture.target, ".", "·")
+	if strings.HasPrefix(fixture.target, "example.invalid/framefixture.") {
+		target = "·Callee"
+	}
+	return "TEXT ·Value(SB),4,$64-32\n" +
+		"MOVQ dst+0(FP),AX\nMOVQ src+8(FP),BX\nMOVQ n+16(FP),CX\n" + fixture.outgoing +
+		"MOVQ AX,24(SP)\nMOVQ BX,32(SP)\nMOVQ CX,40(SP)\nMOVQ $37,48(SP)\n" +
+		"CALL " + target + "(SB)\n" +
+		"MOVQ 24(SP),R8\nMOVQ 32(SP),R9\nMOVQ 40(SP),AX\nADDQ 48(SP),AX\n" +
+		"MOVQ AX,ret+24(FP)\nRET\n"
+}
+
+func foreignABI0Fixture(t *testing.T, fixture foreignABI0CallFixture, assembly string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	_, request := goAMD64FrameSourceFixture(t)
+	filename := filepath.Join(request.Directory, "value.go")
+	source := "package framefixture\n" + fixture.declarations
+	if err := os.WriteFile(filename, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filename, source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64"), Importer: importer.Default()}).Check(
+		"example.invalid/framefixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}, Imports: make(map[string]*types.Package)}
+	for _, dependency := range typed.Imports() {
+		pkg.Imports[dependency.Path()] = dependency
+	}
+	caller, err := DeriveGoFuncABI0Signature(pkg.Path+".Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	callee := FuncSig{Name: fixture.target, Args: append([]LLVMType(nil), fixture.args...), Ret: Void}
+	for index, typ := range fixture.args {
+		callee.Frame.Params = append(callee.Frame.Params, FrameSlot{Offset: int64(index) * 8, Type: typ, Index: index, Field: -1})
+	}
+	// ABI0 parameter metadata intentionally has empty Name fields; the real
+	// producer retains source names on flattened results, not parameters.
+	if fixture.target == pkg.Path+".Callee" {
+		actual, err := DeriveGoFuncABI0Signature(fixture.target, typed.Scope().Lookup("Callee").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil || !reflect.DeepEqual(actual, callee) {
+			t.Fatalf("actual/consumer complete ABI0 metadata differs: err=%v\nactual=%#v\nconsumer=%#v", err, actual, callee)
+		}
+		callee = actual
+	}
+	// This independent literal layout is a consumer expectation, never an SDK
+	// source/ABI certificate. Capture must derive and authenticate its own callee.
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, request, file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path),
+		Sigs: map[string]FuncSig{caller.Name: caller, callee.Name: callee},
+	}
+}
+
+func foreignABI0OriginalLink(t *testing.T, request GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	// A package archive alone leaves cross-package ABI0 references unresolved.
+	// Link an owned complete main so a missing SDK adapter is fixture failure,
+	// not translator RED. The child is not a declaration/source authority.
+	directory := filepath.Join(request.Directory, "linkprobe")
+	if err := os.Mkdir(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	main := "package main\nimport probe \"example.invalid/framefixture\"\n" +
+		"func main() { var a, b byte; if probe.Value(&a, &b, 0) != 37 { panic(\"call result\") } }\n"
+	if err := os.WriteFile(filepath.Join(directory, "main.go"), []byte(main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	env := append(append([]string(nil), request.Environment...), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+	binary := filepath.Join(t.TempDir(), "original-linked")
+	output, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary, "build", "-p=1", "-o", binary, "./linkprobe")
+	if err != nil {
+		t.Fatalf("original Go complete main did not link the actual ABI0 target (not translator RED): %v\n%s", err, output)
+	}
+	if info, err := os.Stat(binary); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatal("original Go omitted complete linked executable", err)
+	}
+}
+
+func TestGoAMD64FrameForeignABI0OriginalGoLink(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, fixture := range foreignABI0CallFixtures() {
+		t.Run(fixture.name, func(t *testing.T) {
+			_, request, _, _ := foreignABI0Fixture(t, fixture, foreignABI0CallAssembly(fixture))
+			foreignABI0OriginalLink(t, request)
+		})
+	}
+}
+
+func TestGoAMD64FrameForeignABI0PointersCaptureAndObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, fixture := range foreignABI0CallFixtures() {
+		t.Run(fixture.name, func(t *testing.T) {
+			pkg, request, file, options := foreignABI0Fixture(t, fixture, foreignABI0CallAssembly(fixture))
+			foreignABI0OriginalLink(t, request)
+			t.Run("signatures-alone", func(t *testing.T) {
+				fixedLocalAPIs(t, pkg, file, options, func(t *testing.T, ir string, err error) {
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("callee signature alone authorized a physical frame/call", err, ir)
+					}
+				})
+			})
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					foreignABI0CallObjects(t, fixture, ir, err)
+				})
+		})
+	}
+}
+
+func foreignABI0CallObjects(t *testing.T, fixture foreignABI0CallFixture, ir string, err error) {
+	t.Helper()
+	global := llvmGlobal(fixture.target)
+	// LLVM's printer can remove optional identifier quotes. Only canonicalize
+	// this exact target token to the existing formatter.
+	normalized := strings.ReplaceAll(ir, "@"+fixture.target+"(", global+"(")
+	call := "call void " + global + "(ptr "
+	if err != nil || !strings.Contains(normalized, call) || strings.Contains(normalized, "define void "+global+"(") {
+		t.Fatal("an actual separate typed ABI0 callee was rejected, dropped or privately inlined", err, ir)
+	}
+	ordinaryGoFrameCallObjects(t, ir)
+}
+
+func TestGoAMD64FrameForeignABI0SDKDefaultsStayOwnedAndStrict(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	fixture := foreignABI0CallFixtures()[0]
+	pkg, request, file, options := foreignABI0Fixture(t, fixture, foreignABI0CallAssembly(fixture))
+	expected := options.Sigs[fixture.target]
+	delete(options.Sigs, fixture.target)
+	foreignABI0OriginalLink(t, request)
+	t.Run("owner-derived-three-APIs", func(t *testing.T) {
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				foreignABI0CallObjects(t, fixture, ir, err)
+			})
+		if _, changed := options.Sigs[fixture.target]; changed {
+			t.Fatal("binding inserted a callee into the consumer's original map")
+		}
+	})
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		if err := owner.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	bound, err := owner.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil || !reflect.DeepEqual(bound.Sigs[fixture.target], expected) {
+		t.Fatalf("owner default differs from independently expected complete ABI0 metadata: %v\nactual=%#v\nexpected=%#v", err, bound.Sigs[fixture.target], expected)
+	}
+	t.Run("public-default-slices-cannot-change-owner", func(t *testing.T) {
+		changed := bound.Sigs[fixture.target]
+		changed.Frame.Params[0].Offset++
+		bound.Sigs[fixture.target] = changed
+		if !reflect.DeepEqual(owner.callees[fixture.target].signature, expected) {
+			t.Fatal("public default slices alias the private source declaration")
+		}
+		fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("mutated derived metadata retained a callable signature", err, ir)
+			}
+		})
+	})
+	t.Run("caller-signature-is-not-derived", func(t *testing.T) {
+		missing := options
+		missing.Sigs = nil
+		if _, err := owner.BindFixedLocal(ctx, pkg, file, missing); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("a foreign SDK callee granted the caller's missing signature", err)
+		}
+	})
+	t.Run("same-package-callee-stays-explicit", func(t *testing.T) {
+		local := foreignABI0CallFixtures()[2]
+		pkg, request, file, options := foreignABI0Fixture(t, local, foreignABI0CallAssembly(local))
+		delete(options.Sigs, local.target)
+		actual, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer func() {
+			if err := actual.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+		if _, err := actual.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("the foreign SDK default widened same-package consumer metadata", err)
+		}
+	})
+}
+
+func TestGoAMD64FrameForeignABI0SuppliedLayoutAndSourceBoundaries(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	fixture := foreignABI0CallFixtures()[0]
+	pkg, request, file, options := foreignABI0Fixture(t, fixture, foreignABI0CallAssembly(fixture))
+	foreignABI0OriginalLink(t, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("actual SDK callee must capture before its independent consumer negatives", err)
+	}
+	defer func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	t.Logf("actual SDK callee complete signature=%#v\nconsumer=%#v", source.callees[fixture.target].signature, options.Sigs[fixture.target])
+	for _, name := range []string{"wrong-register-ABI", "wrong-slot", "wrong-pointer-width", "foreign-resolver"} {
+		t.Run(name, func(t *testing.T) {
+			changed := options
+			changed.Sigs, err = cloneFixedLocalSigs(options.Sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := changed.Sigs[fixture.target]
+			switch name {
+			case "wrong-register-ABI":
+				sig.ArgRegs = []Reg{AX, BX, CX}
+			case "wrong-slot":
+				sig.Frame.Params[1].Offset++
+			case "wrong-pointer-width":
+				sig.Args[0], sig.Frame.Params[0].Type = I32, I32
+			case "foreign-resolver":
+				changed.ResolveSym = func(string) string { return "other.Callee" }
+			}
+			changed.Sigs[fixture.target] = sig
+			if _, err := source.BindFixedLocal(ctx, pkg, file, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("supplied ABI/resolver substituted an actual SDK call", err)
+			}
+		})
+	}
+	// A rejected consumer does not substitute for this independent source test:
+	// use a fresh producer before changing the actual declaration on disk.
+	mutationSource, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("fresh producer needed before source-mutation negative", err)
+	}
+	defer func() {
+		if err := mutationSource.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	path := filepath.Join(request.Directory, "value.go")
+	before, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	after := strings.Replace(string(before), "n uintptr", "n uint32", 1)
+	if after == string(before) {
+		t.Fatal("source mutation did not change the real declaration")
+	}
+	if err := os.WriteFile(path, []byte(after), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(mutationSource.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("mutated source retained its call lease")
+	}
+}
+
+func TestGoAMD64FrameForeignABI0SDKOwnerCannotBeRetaggedOrRevived(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	fixture := foreignABI0CallFixtures()[0]
+	pkg, request, _, _ := foreignABI0Fixture(t, fixture, foreignABI0CallAssembly(fixture))
+	foreignABI0OriginalLink(t, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("actual SDK call must capture before source-owner retagging", err)
+	}
+	defer func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	selected, found := source.imports["runtime"]
+	if !found || !selected.Standard || selected.Export == "" || !filepath.IsAbs(selected.Dir) {
+		t.Fatal("SDK target lost its actual private selected-source owner")
+	}
+	changed := selected
+	changed.Standard = false
+	source.imports["runtime"] = changed
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("retagged SDK package still authorized the callee")
+	}
+	source.imports["runtime"] = selected
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("restoring selected metadata revived a revoked SDK call owner")
+	}
+}
diff --git a/amd64_go_frame_foreign_call_transfer_test.go b/amd64_go_frame_foreign_call_transfer_test.go
new file mode 100644
index 000000000..1400cba3a
--- /dev/null
+++ b/amd64_go_frame_foreign_call_transfer_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestGoAMD64FrameForeignABI0TypedPointerTransfer(t *testing.T) {
+	sig := FuncSig{Name: "foreign.Consume", Args: []LLVMType{Ptr, I64}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}}}}
+	binding := &x86FixedLocalBinding{symbols: map[string]string{"foreign·Consume": sig.Name},
+		signatures: map[string]FuncSig{sig.Name: sig},
+		callees:    map[string]goAMD64FrameDeclaration{sig.Name: {signature: sig, transport: goAMD64FrameCompositeTransport}}}
+	proof := &x86FixedLocalProof{binding: binding, frame: 64}
+	call := x86ScalarLaneInstruction(t, "CALL foreign·Consume(SB)")
+	before := fixedLocalExchangeState()
+	origin := fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+	before.opaqueCells[0], before.opaqueCells[24] = origin, origin
+	before.bytes.setRange(8, 8, true)
+	before.bytes.setRange(40, 8, true)
+	before.addresses[48] = 56
+	before.known[AX], before.vectors["Z0"], before.masks["K1"] = 255, ^uint64(0), true
+	before.flags = x86ByteFlagCF
+	t.Run("opaque-word-and-independent-spills", func(t *testing.T) {
+		state := cloneFixedLocalState(before)
+		if err := fixedLocalOrdinaryCallStep(call, &state, proof); err != nil {
+			t.Fatal("typed opaque pointer argument was not accepted", err)
+		}
+		if state.opaqueCells[0].valid() || !state.opaqueCells[24].equal(origin) || !state.bytes.all(40, 8) ||
+			state.addresses[48] != 56 || state.bytes.all(8, 8) || len(state.known)+len(state.opaque)+len(state.vectors)+len(state.masks) != 0 || state.flags != 0 {
+			t.Fatal("CALL lost private spills or retained outgoing/scratch authority", state)
+		}
+	})
+	for _, name := range []string{"missing-pointer", "partial-numeric-word", "private-frame-pointer", "unknown-callee", "changed-SP"} {
+		t.Run(name, func(t *testing.T) {
+			state := cloneFixedLocalState(before)
+			instruction := call
+			switch name {
+			case "missing-pointer":
+				delete(state.opaqueCells, 0)
+			case "partial-numeric-word":
+				delete(state.opaqueCells, 0)
+				state.bytes.setRange(0, 7, true)
+			case "private-frame-pointer":
+				delete(state.opaqueCells, 0)
+				state.addresses[0] = 40
+			case "unknown-callee":
+				instruction = x86ScalarLaneInstruction(t, "CALL foreign·Other(SB)")
+			case "changed-SP":
+				state.pointers[SP] = 8
+			}
+			if err := fixedLocalOrdinaryCallStep(instruction, &state, proof); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("uninitialized/unbound/private pointer acquired a call contract", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_global_go127_test.go b/amd64_go_frame_global_go127_test.go
new file mode 100644
index 000000000..4071c5fdf
--- /dev/null
+++ b/amd64_go_frame_global_go127_test.go
@@ -0,0 +1,104 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+const fixedLocalGlobalAssembly = `TEXT ·Value(SB),4,$32-16
+	MOVQ a+0(FP),AX
+	MOVQ AX,0(SP)
+	MOVQ $·Table(SB),SI
+	MOVQ SI,8(SP)
+	MOVQ 8(SP),DX
+	MOVOU (DX),X0
+	ADDQ $16,DX
+	MOVOU (DX),X1
+	PADDQ X1,X0
+	MOVQ X0,CX
+	MOVQ 0(SP),AX
+	ADDQ CX,AX
+	MOVQ AX,ret+8(FP)
+	RET
+`
+
+const fixedLocalGlobalDeclarations = "var Table [4]uint64\nfunc Value(a uint64) uint64\n"
+
+func TestGoAMD64FrameOrdinaryRelocationWithoutData(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			pkg, request := goAMD64FrameTypedFixture(t, fixedLocalGlobalDeclarations, fixedLocalGlobalAssembly)
+			request.Target = target
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			object, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			listing, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			expanded, err := source.preprocess(request.AssemblyFile, []byte(fixedLocalGlobalAssembly))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed, err := source.frameDataObject(expanded, object)
+			if err != nil || len(observed.Layouts) != 0 || len(observed.Member.Texts) != 1 || len(observed.Member.Texts[0].Relocations) != 1 {
+				t.Fatal("ordinary reference changed the complete no-DATA inventory", err)
+			}
+			var unwind *gostaticstorage.WindowsAMD64AssemblyUnwind
+			if target == "windows/amd64" {
+				value, err := source.observeWindowsUnwind(object)
+				if err != nil {
+					t.Fatal(err)
+				}
+				unwind = &value
+			}
+			check := func(input []byte) error {
+				functions, err := goAMD64FrameListingWithDataObject(input, file, pkg, source.origins, observed, unwind, target, request.Directory, "")
+				if err != nil {
+					return err
+				}
+				return goAMD64FrameDataTextJoin(functions, observed, request.Directory, source.origins, "")
+			}
+			if err := check(listing); err != nil {
+				t.Fatal("complete unmodified original source/object/listing", err)
+			}
+			for name, replacement := range map[string]string{
+				"target": "foreign.Table+0", "addend": pkg.Path + ".Table+1", "missing zero": pkg.Path + ".Table",
+			} {
+				t.Run(name, func(t *testing.T) {
+					changed := bytes.Replace(listing, []byte(pkg.Path+".Table+0"), []byte(replacement), 1)
+					if bytes.Equal(changed, listing) || !errors.Is(check(changed), ErrProbeNeedsContext) {
+						t.Fatal("changed ordinary relocation retained the complete original observation")
+					}
+				})
+			}
+			relocation := []byte("\t" + goAMD64FrameDataRelocationLine(observed.Member.Texts[0].Relocations[0], observed) + "\n")
+			for name, replacement := range map[string][]byte{"missing": nil, "duplicate": append(append([]byte(nil), relocation...), relocation...)} {
+				t.Run(name, func(t *testing.T) {
+					changed := bytes.Replace(listing, relocation, replacement, 1)
+					if bytes.Equal(changed, listing) || !errors.Is(check(changed), ErrProbeNeedsContext) {
+						t.Fatal("incomplete or duplicate relocation inventory accepted")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_identity_test.go b/amd64_go_frame_identity_test.go
new file mode 100644
index 000000000..6e3da0cc9
--- /dev/null
+++ b/amd64_go_frame_identity_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestGoOriginalInputGuardCannotSupplyFrameAuthority(t *testing.T) {
+	request := GoAMD64FrameCaptureRequest{Environment: []string{"GOFLAGS="}}
+	first, second := newGoOriginalInputGuard(request), newGoOriginalInputGuard(request)
+	request.Environment[0] = "GOFLAGS=-overlay=foreign.json"
+	if first.request.Environment[0] != "GOFLAGS=" || second.request.Environment[0] != "GOFLAGS=" {
+		t.Fatal("query-only guard retained caller environment storage")
+	}
+	first.inputs["first-only"] = [32]byte{1}
+	if len(second.inputs) != 0 {
+		t.Fatal("independent query-only guards shared input maps")
+	}
+	for _, source := range []*GoAMD64FrameSource{first, second} {
+		if source.ready || source.owned != "" || len(source.functions) != 0 || len(source.declarations) != 0 ||
+			source.downloadedOrigin != nil || source.downloadedModule != nil {
+			t.Fatal("input initialization created an object or original-source capability")
+		}
+		if !errors.Is(source.Verify(context.Background()), ErrProbeNeedsContext) {
+			t.Fatal("query-only guard verified as a frame")
+		}
+		if _, err := source.BindFixedLocal(context.Background(), GoPackage{}, nil, Options{}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("query-only guard admitted fixed-local memory", err)
+		}
+		if err := source.Close(); err != nil {
+			t.Fatal("original query guard could not close its empty resource role", err)
+		}
+	}
+}
+
+func TestGoAMD64FrameSourceCopyCannotBorrowOrCleanOriginal(t *testing.T) {
+	for _, operation := range []string{"Verify", "Close"} {
+		t.Run(operation, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("actual original public factory did not verify", err)
+			}
+			owned := source.owned
+			before, err := os.Lstat(owned)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Deliberately model the public whole-value operation without hiding
+			// a mutex copy behind a constructor or serializing private fields.
+			copied := new(GoAMD64FrameSource)
+			reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(source).Elem())
+			if operation == "Verify" {
+				err = copied.Verify(ctx)
+			} else {
+				err = copied.Close()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("whole-value copied frame %s borrowed its original owner role: %v", operation, err)
+			}
+			after, err := os.Lstat(owned)
+			if err != nil || !os.SameFile(before, after) {
+				t.Error("copied frame operation removed or replaced original artifacts", err)
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Error("copied frame operation revoked its original object", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_macro_test.go b/amd64_go_frame_macro_test.go
new file mode 100644
index 000000000..ecdb769e3
--- /dev/null
+++ b/amd64_go_frame_macro_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestGoAMD64FrameSourceConditionalMacrosMatchActualObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for targetIndex, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		for _, profile := range []string{"v1", "v2", "v3", "v4"} {
+			t.Run(target+"/"+profile, func(t *testing.T) {
+				pkg, request := goAMD64FrameSourceFixture(t)
+				request.Target = target
+				request.Environment = append(request.Environment, "GOAMD64="+profile)
+				assembly := filepath.Join(request.Directory, request.AssemblyFile)
+				original, err := os.ReadFile(assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				header := `#ifndef PROFILE_GUARD
+#define PROFILE_GUARD
+#ifdef GOAMD64_v2
+#define PROFILE_VALUE 7
+#else
+#define PROFILE_VALUE 11
+#endif
+#ifdef GOOS_linux
+#define TARGET_VALUE 1
+#else
+#ifdef GOOS_darwin
+#define TARGET_VALUE 2
+#else
+#define TARGET_VALUE 3
+#endif
+#endif
+#endif
+`
+				headerFile := filepath.Join(request.Directory, "profile.h")
+				if err := os.WriteFile(headerFile, []byte(header), 0600); err != nil {
+					t.Fatal(err)
+				}
+				prefix := `#include "profile.h"
+#include "profile.h"
+#ifdef UNDEFINED_EXTERNAL_MACRO
+#include "missing_generated.h"
+#endif
+`
+				text := prefix + strings.Replace(string(original), "MOVQ AX,ret+8(FP)", "MOVQ $(PROFILE_VALUE+TARGET_VALUE),AX\nMOVQ AX,ret+8(FP)", 1)
+				if err := os.WriteFile(assembly, []byte(text), 0600); err != nil {
+					t.Fatal(err)
+				}
+				source := requireGoAMD64FrameCapture(t, pkg, request)
+				function, found := source.functions[pkg.Path+".Value"]
+				if !found {
+					t.Fatal("complete original function is missing")
+				}
+				want := int64(11 + targetIndex + 1)
+				if profile == "v2" {
+					want -= 4
+				}
+				matched := 0
+				for code := function.code; len(code) != 0; {
+					instruction, err := x86asm.Decode(code, 64)
+					if err != nil || instruction.Len == 0 {
+						t.Fatal("decode actual conditional Go object", err)
+					}
+					_, immediate := instruction.Args[1].(x86asm.Imm)
+					// Current Go encodes these small MOVQ constants as a
+					// zero-extending EAX write; Go 1.20 retains RAX's prefix.
+					valueRegister := instruction.Args[0] == x86asm.RAX || instruction.Args[0] == x86asm.EAX
+					if instruction.Op == x86asm.MOV && valueRegister && immediate {
+						if instruction.Args[1] != x86asm.Imm(want) {
+							t.Fatal("conditional branch differs from independent profile/target", instruction, want)
+						}
+						matched++
+					}
+					code = code[instruction.Len:]
+				}
+				if matched != 1 {
+					t.Fatal("missing or repeated independently observed conditional result", matched)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				expanded, err := source.preprocess(request.AssemblyFile, []byte(text))
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, expanded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}[targetIndex]
+				options := Options{Goarch: "amd64", TargetTriple: triple,
+					ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+					Sigs:       map[string]FuncSig{function.signature.Name: function.signature},
+				}
+				bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "conditional.ll", "conditional.o", ir)
+					compileLLVMToObject(t, llc, triple, "conditional-opt.ll", "conditional-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+				if err := source.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(headerFile, []byte(header+"// late mutation\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := source.Verify(ctx); err == nil {
+					t.Fatal("changed conditional header retained source authority")
+				}
+				if err := os.WriteFile(headerFile, []byte(header), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := source.Verify(ctx); err == nil {
+					t.Fatal("restored header revived a revoked observation")
+				}
+				t.Logf("actual %s/%s selected MOVQ $%d,AX", target, profile, want)
+			})
+		}
+	}
+}
+
+func TestGoAMD64FrameSourceConditionalMacrosGrantNoNumericEffects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, operand := range []string{"$7", "R11"} {
+		t.Run(operand, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			name := filepath.Join(request.Directory, request.AssemblyFile)
+			text, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Retain the original ADDQ $7 source as a positive now that its
+			// typed family is implemented. Macro selection still cannot supply
+			// the missing numerical bytes of an uninitialized register.
+			body := "#ifdef GOARCH_amd64\n" + strings.Replace(string(text), "MOVQ AX,ret+8(FP)",
+				"ADDQ "+operand+",AX\nMOVQ AX,ret+8(FP)", 1) + "#endif\n"
+			if err := os.WriteFile(name, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			expanded, err := source.preprocess(request.AssemblyFile, []byte(body))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := source.functions[pkg.Path+".Value"].signature
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+				Sigs:       map[string]FuncSig{sig.Name: sig},
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if operand == "R11" {
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "ADDQ") {
+					t.Fatal("macro selection supplied missing ADDQ input bytes", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal("initialized ADDQ frame binding failed", err)
+			}
+			ir, err := Translate(file, bound)
+			if err != nil || ir == "" {
+				t.Fatal("original initialized ADDQ lost its independently bound translation", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceCPPRequiresActualRegistration(t *testing.T) {
+	source := newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: t.TempDir()})
+	source.env = map[string]string{"GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v2"}
+	if _, err := source.preprocess("value.s", []byte("#ifdef GOAMD64_v2\nTEXT value(SB),4,$0-0\nRET\n#endif\n")); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("environment strings impersonated registered actual macro sources", err)
+	}
+}
diff --git a/amd64_go_frame_numerical_source.go b/amd64_go_frame_numerical_source.go
new file mode 100644
index 000000000..edc44c01d
--- /dev/null
+++ b/amd64_go_frame_numerical_source.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func verifyGoAMD64FrameNumericalRequest(ctx context.Context, pkg GoPackage, request GoAMD64FrameCaptureRequest) error {
+	binding := request.NumericalReads
+	if err := binding.verify(); err != nil {
+		return err
+	}
+	if ctx != binding.context || request.Target != "linux/amd64" || request.Target != binding.source.request.Target ||
+		request.GoBinary != binding.source.request.GoBinary || request.Directory != binding.source.request.Directory ||
+		request.AssemblyFile != binding.source.request.AssemblyFile || pkg.Path != binding.packageInput.Path ||
+		pkg.Types != binding.originalTypes || pkg.SourceSelection != nil || !numericalSameImports(pkg.Imports, binding.originalImports) {
+		return goAMD64FrameContext("numerical frame join has foreign complete source/package/tool/profile/context")
+	}
+	environment := func(values []string) (map[string]string, bool) {
+		result := make(map[string]string, len(values))
+		for _, pair := range values {
+			key, value, valid := strings.Cut(pair, "=")
+			if _, duplicate := result[key]; !valid || key == "" || duplicate {
+				return nil, false
+			}
+			result[key] = value
+		}
+		return result, true
+	}
+	provided, valid := environment(request.Environment)
+	original, originalValid := environment(binding.source.request.Environment)
+	if !valid || !originalValid || !reflect.DeepEqual(provided, original) {
+		return goAMD64FrameContext("numerical frame join command environment differs")
+	}
+	binding.source.mu.Lock()
+	err := numericalDeclarationSyntax(binding.source, pkg)
+	binding.source.mu.Unlock()
+	return err
+}
+
+func (source *GoAMD64FrameSource) revokeNumericalFrame() {
+	source.mu.Lock()
+	source.ready = false
+	source.mu.Unlock()
+}
+
+// No Frame lock survives an external numerical/owner verification. Close can
+// linearize during the independent frame round, but its final guard must fail.
+func (source *GoAMD64FrameSource) verifyNumericalFrameInputs(ctx context.Context) error {
+	source.mu.Lock()
+	request, binding, seal, pkg, ready, origin := source.request, source.numericalBinding, source.numericalSeal, source.numericalPackage, source.ready, source.numericalOrigin
+	selection := source.selection
+	inputs := make(map[string][32]byte, len(source.inputs))
+	for name, sum := range source.inputs {
+		inputs[name] = sum
+	}
+	environment := make(map[string]string, len(source.env))
+	for name, value := range source.env {
+		environment[name] = value
+	}
+	source.mu.Unlock()
+	if binding == nil && request.NumericalReads == nil && origin == nil {
+		return nil // Preserve every existing unbound/default role.
+	}
+	if ctx == nil {
+		return goAMD64FrameContext("numerical frame verification requires a live context")
+	}
+	if err := ctx.Err(); err != nil {
+		return fmt.Errorf("verify numerical frame context: %w", err)
+	}
+	if !ready || origin != source || binding == nil || request.NumericalReads != binding || binding.seal != seal {
+		return goAMD64FrameContext("numerical frame generation/token is closed, missing or changed")
+	}
+	if err := verifyGoAMD64FrameNumericalRequest(binding.context, pkg, request); err != nil {
+		return err
+	}
+	binding.source.mu.Lock()
+	actualSelection := binding.source.guard.selection
+	actualEnvironment := binding.source.guard.env
+	var mismatch bool
+	for _, key := range []string{"GOROOT", "GOTOOLDIR", "GOVERSION", "GOOS", "GOARCH", "GOAMD64", "GOFLAGS", "GOEXPERIMENT", "GOCACHE"} {
+		mismatch = mismatch || environment[key] != actualEnvironment[key]
+	}
+	for name, data := range binding.source.native.Sources {
+		sum, exists := inputs[name]
+		mismatch = mismatch || !exists || sum != sha256.Sum256(data)
+	}
+	binding.source.mu.Unlock()
+	if mismatch || !reflect.DeepEqual(selection, actualSelection) || len(selection.SFiles) != 1 || selection.SFiles[0] != request.AssemblyFile {
+		return goAMD64FrameContext("independent complete numerical/frame source selection or tool bytes differ")
+	}
+	// Catch Close that linearized while the independent owner checks ran.
+	source.mu.Lock()
+	live := source.ready && source.request.NumericalReads == binding && source.numericalBinding == binding
+	source.mu.Unlock()
+	if !live {
+		return goAMD64FrameContext("numerical frame closed during complete verification")
+	}
+	return nil
+}
+
+func (source *GoAMD64FrameSource) numericalFrameObject(object string, file *File) ([]gostaticstorage.TextRecord, error) {
+	data, err := source.read(object)
+	if err != nil {
+		return nil, err
+	}
+	builtin, err := source.read(filepath.Join(source.env["GOROOT"], "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		return nil, err
+	}
+	texts, err := gostaticstorage.ObserveX86AssemblyText(data, builtin, source.request.Target)
+	if err != nil {
+		return nil, err
+	}
+	binding := source.numericalBinding
+	if err := binding.verify(); err != nil {
+		return nil, err
+	}
+	fingerprint, err := x86CallerSourceFingerprint(file)
+	if err != nil || fingerprint != binding.file {
+		return nil, goAMD64FrameContext("independent numerical frame parsed source differs")
+	}
+	if err := goAMD64FrameNumericalObjectJoin(texts, binding.source.native.OriginalText, binding.reads); err != nil {
+		return nil, err
+	}
+	return texts, nil
+}
+
+// Both TEXT collections came from independently decoded actual original
+// objects. Whole records (including positions and auxiliaries) must agree;
+// every relocation must also be exactly one certified scalar read's field.
+func goAMD64FrameNumericalObjectJoin(texts, numerical []gostaticstorage.TextRecord, reads []numericalSBReadFact) error {
+	if len(texts) == 0 || !reflect.DeepEqual(texts, numerical) {
+		return goAMD64FrameContext("independent complete TEXT/code/source/ABI0/relocations differ")
+	}
+	readIndex := 0
+	for _, text := range texts {
+		if text.ABI != 0 || text.Size != int64(len(text.Code)) {
+			return goAMD64FrameContext("numerical frame has foreign ABI0 or incomplete code")
+		}
+		lastPC, lastInstruction := int64(-1), -1
+		for _, relocation := range text.Relocations {
+			if readIndex >= len(reads) {
+				return goAMD64FrameContext("missing complete numerical frame read")
+			}
+			read := reads[readIndex]
+			if read.Function != text.Name || !reflect.DeepEqual(read.Relocation, relocation) ||
+				read.PC <= lastPC || read.Instruction <= lastInstruction || read.PC >= text.Size ||
+				read.Variable.NativeName != relocation.Target.Name {
+				return goAMD64FrameContext("foreign, duplicate or reordered numerical frame read/owner")
+			}
+			native, err := x86asm.Decode(text.Code[read.PC:], 64)
+			if err != nil || native.Op == 0 || native.Len <= 0 || read.PC+int64(native.Len) > text.Size ||
+				!bytes.Equal(read.Code, text.Code[read.PC:read.PC+int64(native.Len)]) || native.MemBytes != int(read.Width) {
+				return goAMD64FrameContext("numerical frame instruction boundary/code/width differs")
+			}
+			actual, offset, err := numericalInstructionRelocation(text, read.PC, native, "amd64")
+			if err != nil || !reflect.DeepEqual(actual, relocation) || offset != read.Offset {
+				return goAMD64FrameContext("numerical frame PC displacement/type/target/ABI/addend differs")
+			}
+			lastPC, lastInstruction = read.PC, read.Instruction
+			readIndex++
+		}
+	}
+	if readIndex != len(reads) {
+		return goAMD64FrameContext("numerical frame omitted a certified original read")
+	}
+	return nil
+}
+
+func goAMD64FrameNumericalRelocationLine(relocation gostaticstorage.TextRelocation) string {
+	if relocation.Type != 14 || relocation.Size != 4 || !relocation.Target.ABIKnown || relocation.Target.ABI != 0 {
+		return "" // No other listing relocation has been authorized.
+	}
+	line := fmt.Sprintf("rel %d+%d t=R_PCREL %s", relocation.Offset, relocation.Size, relocation.Target.Name)
+	if relocation.Add != 0 {
+		line += fmt.Sprintf("%+d", relocation.Add)
+	}
+	return line
+}
diff --git a/amd64_go_frame_ordinary_call.go b/amd64_go_frame_ordinary_call.go
new file mode 100644
index 000000000..10a7ae654
--- /dev/null
+++ b/amd64_go_frame_ordinary_call.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goabi"
+)
+
+// A Go implementation is a separately compiled callable, not an assembly
+// entry or an inlineable private leaf. Select only actual direct references;
+// unrelated Go declarations retain their existing transport roles.
+func (source *GoAMD64FrameSource) ordinaryCallDeclarations(pkg GoPackage, file *File) (map[string]goAMD64FrameDeclaration, error) {
+	leaves, err := goAMD64FramePrivateLeaves(file, pkg)
+	if err != nil {
+		return nil, err
+	}
+	entries := make(map[string]bool)
+	foreign := make(map[string]map[string]bool)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			if valid && offset == 0 && leaves[name] {
+				continue
+			}
+			path, local := goReadOnlyImportedName(goAMD64FrameCallName(pkg.Path, name))
+			if !valid || offset != 0 || path == "" {
+				return nil, goAMD64FrameContext("ordinary CALL needs an exact selected Go target")
+			}
+			if path == pkg.Path {
+				entries[local] = true
+			} else {
+				if foreign[path] == nil {
+					foreign[path] = make(map[string]bool)
+				}
+				foreign[path][local] = true
+			}
+		}
+	}
+	if len(entries)+len(foreign) == 0 {
+		return nil, nil
+	}
+	declarations := make(map[string]goAMD64FrameDeclaration)
+	if len(entries) != 0 {
+		declarations, err = source.typedSourceDeclarations(pkg, false, "amd64", true, entries, false, true)
+		if err != nil {
+			return nil, err
+		}
+	}
+	for path, names := range foreign {
+		selected, err := source.ordinarySDKCallDeclarations(path, names)
+		if err != nil {
+			return nil, err
+		}
+		for name, declaration := range selected {
+			declarations[name] = declaration
+		}
+	}
+	for _, declaration := range declarations {
+		if !goAMD64FrameScalarCall(declaration.signature) {
+			return nil, goAMD64FrameContext("ordinary CALL has a non-scalar transport")
+		}
+	}
+	return declarations, nil
+}
+
+func goAMD64FrameCallName(path, symbol string) string {
+	if strings.HasPrefix(symbol, "·") {
+		symbol = path + "." + strings.TrimPrefix(symbol, "·")
+	}
+	owner, name := goReadOnlyImportedName(symbol)
+	if owner == "" {
+		return ""
+	}
+	return owner + "." + name
+}
+
+func goAMD64FrameScalarCall(sig FuncSig) bool {
+	scalar := func(typ LLVMType) bool {
+		return typ == Ptr || typ == I1 || typ == I8 || typ == I16 || typ == I32 || typ == I64
+	}
+	for _, typ := range sig.Args {
+		if !scalar(typ) {
+			return false
+		}
+	}
+	if sig.Ret == Void || scalar(sig.Ret) {
+		return true
+	}
+	fields, valid := parseLiteralStructFields(sig.Ret)
+	for _, typ := range fields {
+		valid = valid && scalar(typ)
+	}
+	return valid
+}
+
+func fixedLocalOrdinaryCall(ins Instr, binding *x86FixedLocalBinding) (FuncSig, bool) {
+	if binding == nil || ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+		return FuncSig{}, false
+	}
+	symbol, offset, valid := parseSBRef(ins.Args[0].Sym)
+	name := binding.symbols[symbol]
+	declaration, found := binding.callees[name]
+	sig, supplied := binding.signatures[name]
+	return sig, valid && offset == 0 && found && supplied &&
+		(declaration.transport == goAMD64FrameNumericTransport || declaration.transport == goAMD64FrameCompositeTransport) &&
+		goAMD64FrameScalarCall(sig) && reflect.DeepEqual(sig, declaration.signature)
+}
+
+// The existing ABI0 emitter reads outgoing slots and writes only typed result
+// slots. Opaque pointer words supply no private-frame or pointee authority.
+// A Go callee may overwrite its entire outgoing extent and every scratch bank;
+// only unescaped caller locals outside that extent remain initialized.
+func fixedLocalOrdinaryCallStep(ins Instr, state *x86FixedLocalState, proof *x86FixedLocalProof) error {
+	sig, found := fixedLocalOrdinaryCall(ins, proof.binding)
+	sp, original := state.pointers[SP]
+	if !found || !original || sp != 0 || !x86ABI0FrameLayout(sig, proof.frame, "amd64") {
+		return goAMD64FrameContext("ordinary CALL lacks its exact bound ABI0 outgoing layout")
+	}
+	_, changedBP := state.known[BP]
+	if _, privateBP := state.pointers[BP]; changedBP || privateBP || state.opaque[BP].valid() {
+		return goAMD64FrameContext("ordinary Go CALL requires the unchanged automatic frame pointer")
+	}
+	var extent int64
+	for group, slots := range [][]FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for _, slot := range slots {
+			width := frameTypeSize(slot.Type, 8)
+			if width <= 0 || slot.Offset < 0 || slot.Offset > proof.frame-width {
+				return goAMD64FrameContext("ordinary CALL slot exceeds its exact outgoing frame")
+			}
+			initialized := state.bytes.all(slot.Offset, width)
+			if slot.Type == Ptr && group == 0 {
+				origin := state.opaqueCells[slot.Offset]
+				_, private := state.addresses[slot.Offset]
+				initialized = width == 8 && !private && (initialized || origin.valid() && !origin.readonly())
+			}
+			if group == 0 && (!initialized || slot.Type == I1 && !state.booleanBytes.all(slot.Offset, width)) {
+				return goAMD64FrameContext("ordinary CALL reads uninitialized or noncanonical outgoing bytes")
+			}
+			if end := slot.Offset + width; end > extent {
+				extent = end
+			}
+		}
+	}
+	var valid bool
+	extent, valid = goabi.ABI0StackSize("amd64", extent)
+	if !valid || extent > proof.frame {
+		return goAMD64FrameContext("ordinary CALL outgoing aligned extent exceeds its private frame")
+	}
+	state.bytes.setRange(0, extent, false)
+	fixedLocalRevokeSpillRoles(state, 0, extent)
+	for _, slot := range sig.Frame.Results {
+		width := frameTypeSize(slot.Type, 8)
+		state.bytes.setRange(slot.Offset, width, slot.Type != Ptr)
+		state.booleanBytes.setRange(slot.Offset, width, slot.Type == I1)
+		if slot.Type == Ptr {
+			state.opaqueCells[slot.Offset] = fixedLocalOrigin(x86FixedLocalOrigin{})
+		}
+	}
+	// This is the existing architectural GP bank, not a native-MMX grant.
+	for _, reg := range x86NativeMMXGPRegisters {
+		if reg == SP || reg == BP {
+			continue
+		}
+		delete(state.known, reg)
+		delete(state.pointers, reg)
+		delete(state.opaque, reg)
+		delete(state.booleans, reg)
+		delete(state.constants, reg)
+		delete(state.ranges, reg)
+	}
+	for reg := range state.vectors {
+		delete(state.vectors, reg)
+	}
+	for reg := range state.masks {
+		delete(state.masks, reg)
+	}
+	state.flags, state.comparison = 0, x86FixedLocalComparison{}
+	return nil
+}
diff --git a/amd64_go_frame_ordinary_call_contract_go127_test.go b/amd64_go_frame_ordinary_call_contract_go127_test.go
new file mode 100644
index 000000000..44e1f6add
--- /dev/null
+++ b/amd64_go_frame_ordinary_call_contract_go127_test.go
@@ -0,0 +1,175 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64FrameOrdinaryCallKeepsPrivateLeafAndPrototypeBoundaries(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	t.Run("existing-private-asm", func(t *testing.T) {
+		assembly := fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "MOVQ (BP),AX")
+		pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+		ordinaryGoFrameCallOriginalPackage(t, request)
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				if err != nil || strings.Count(ir, "define ") != 1 || strings.Contains(ir, "call void @\"leaf") {
+					t.Fatal("the established same-file private leaf acquired an ordinary callable ABI", err, ir)
+				}
+				fixedLocalPrivateLeafObjects(t, ir)
+			})
+	})
+	for _, test := range []struct{ name, declaration string }{
+		{"unknown-callee", "func Value(a uint64) uint64\n"},
+		{"bodyless-prototype-only", "func Value(a uint64) uint64\nfunc Callee(a uint64) uint64\n"},
+		{"pointer-callee", "func Value(a uint64) uint64\nfunc Callee(a *uint64) uint64 { return *a }\n"},
+		{"floating-callee", "func Value(a uint64) uint64\nfunc Callee(a float64) float64 { return a }\n"},
+		{"variadic-callee", "func Value(a uint64) uint64\nfunc Callee(a ...uint64) uint64 { return uint64(len(a)) }\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			var pkg GoPackage
+			var request GoAMD64FrameCaptureRequest
+			var options Options
+			if test.name == "variadic-callee" {
+				// The actual source producer must reject this role. Do not ask
+				// the independent nonvariadic ABI builder to accept it first.
+				pkg, request = goAMD64FrameTypedFixture(t, test.declaration, ordinaryGoFrameCallAssembly)
+			} else {
+				pkg, request, _, options = ordinaryGoFrameCallFixture(t, test.declaration, ordinaryGoFrameCallAssembly)
+			}
+			frameRelocationOriginal(t, pkg, request)
+			if test.name == "bodyless-prototype-only" && options.Sigs[pkg.Path+".Callee"].Name == "" {
+				t.Fatal("the negative lost its caller-supplied typed signature")
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if owner != nil {
+				defer func() {
+					if err := owner.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+			if test.name == "pointer-callee" {
+				if err != nil {
+					t.Fatal("actual typed pointer callee source was rejected", err)
+				}
+				file, err := Parse(ArchAMD64, ordinaryGoFrameCallAssembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Run("signatures-alone", func(t *testing.T) {
+					fixedLocalAPIs(t, pkg, file, options, func(t *testing.T, ir string, err error) {
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("a pointer callee signature granted an unobserved physical caller frame", err, ir)
+						}
+					})
+				})
+				t.Run("source-bound", func(t *testing.T) {
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+						func(t *testing.T, ir string, err error) {
+							if err != nil || !strings.Contains(ir, "call i64 "+llvmGlobal(pkg.Path+".Callee")+"(ptr ") {
+								t.Fatal("an initialized word did not retain its exact opaque-pointer call", err, ir)
+							}
+							ordinaryGoFrameCallObjects(t, ir)
+						})
+				})
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an unresolved target or prototype alone granted a callee/source contract", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameOrdinaryCallObjectRejectsRelocationAndABIChanges(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request, file, _ := ordinaryGoFrameCallFixture(t,
+		ordinaryGoFrameCallDeclarations, ordinaryGoFrameCallAssembly)
+	ordinaryGoFrameCallOriginalPackage(t, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	objectPath := filepath.Join(t.TempDir(), "original.o")
+	env := append(append([]string(nil), request.Environment...),
+		"GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+	listing, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+		"tool", "asm", "-S", "-p", pkg.Path, "-o", objectPath, request.AssemblyFile)
+	if err != nil {
+		t.Fatalf("original call object: %v\n%s", err, listing)
+	}
+	object, err := os.ReadFile(objectPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := gostaticstorage.ObserveAMD64AssemblyData([]byte(ordinaryGoFrameCallAssembly), object, builtin, pkg.Path, request.Target)
+	if err != nil || len(observed.Member.Texts) != 1 || len(observed.Member.Texts[0].Relocations) != 1 {
+		t.Fatal("the independent object lost its single complete CALL", err)
+	}
+	original := observed.Member.Texts[0].Relocations[0]
+	if !original.Target.ABIKnown || original.Target.ABI != 0 || original.Target.Name != pkg.Path+".Callee" ||
+		!bytes.Contains(listing, []byte("t=R_CALL "+original.Target.Name+"+0")) ||
+		goAMD64FrameDataRelocationLine(original, &observed) == "" {
+		t.Fatal("canonical ordinary CALL no longer has an exact ABI0 object/listing observation", original)
+	}
+	for _, test := range []struct {
+		name string
+		edit func(*gostaticstorage.TextRelocation)
+	}{
+		{"wrong-ABI", func(r *gostaticstorage.TextRelocation) { r.Target.ABI = 1 }},
+		{"unknown-ABI", func(r *gostaticstorage.TextRelocation) { r.Target.ABIKnown = false }},
+		{"wrong-relocation", func(r *gostaticstorage.TextRelocation) { r.Type = 10 }},
+		{"wrong-width", func(r *gostaticstorage.TextRelocation) { r.Size = 8 }},
+		{"nonzero-addend", func(r *gostaticstorage.TextRelocation) { r.Add = 1 }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			changed := original
+			test.edit(&changed)
+			if goAMD64FrameDataRelocationLine(changed, &observed) != "" {
+				t.Fatal("a changed object role retained its ordinary ABI0 CALL observation", changed)
+			}
+		})
+	}
+	// Independently reject changed raw relocation text against the unchanged
+	// actual object. The formatter above is not the permission/admission test.
+	line := []byte("\t" + goAMD64FrameDataRelocationLine(original, &observed) + "\n")
+	if bytes.Count(listing, line) != 1 {
+		t.Fatal("the raw listing does not contain exactly one canonical CALL record")
+	}
+	for name, changed := range map[string][]byte{
+		"raw-foreign-target": bytes.Replace(line, []byte(pkg.Path+".Callee"), []byte("foreign.Callee"), 1),
+		"raw-width":          bytes.Replace(line, []byte("+4 t="), []byte("+8 t="), 1),
+		"raw-relocation":     bytes.Replace(line, []byte("R_CALL"), []byte("R_PCREL"), 1),
+		"raw-addend":         bytes.Replace(line, []byte("Callee+0"), []byte("Callee+1"), 1),
+		"raw-missing":        nil,
+		"raw-duplicate":      append(append([]byte(nil), line...), line...),
+	} {
+		t.Run(name, func(t *testing.T) {
+			mutated := bytes.Replace(listing, line, changed, 1)
+			if bytes.Equal(mutated, listing) {
+				t.Fatal("the negative did not change the producer's raw relocation")
+			}
+			_, err := goAMD64FrameListingWithDataObject(mutated, file, pkg,
+				map[string]int{request.AssemblyFile: strings.Count(ordinaryGoFrameCallAssembly, "\n") + 1},
+				&observed, nil, request.Target, request.Directory, "")
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "object/listing relocation") {
+				t.Fatal("changed raw CALL listing was not rejected by the exact-object join", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_ordinary_call_contract_test.go b/amd64_go_frame_ordinary_call_contract_test.go
new file mode 100644
index 000000000..d85619d46
--- /dev/null
+++ b/amd64_go_frame_ordinary_call_contract_test.go
@@ -0,0 +1,228 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const ordinaryGoFrameCallAssembly = `TEXT ·Value(SB),4,$48-16
+	MOVQ a+0(FP),AX
+	MOVQ AX,0(SP)
+	MOVQ $37,32(SP)
+	CALL ·Callee(SB)
+	MOVQ 8(SP),AX
+	ADDQ 32(SP),AX
+	MOVQ AX,ret+8(FP)
+	RET
+`
+
+const ordinaryGoFrameCallDeclarations = `func Value(a uint64) uint64
+//go:noinline
+func Callee(a uint64) uint64 { return (a ^ 11) + 17 }
+`
+
+func ordinaryGoFrameCallObjects(t *testing.T, ir string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const target = "x86_64-unknown-linux-gnu"
+	compileLLVMToObject(t, llc, target, "ordinary-call.ll", "ordinary-call.o", ir)
+	compileLLVMToObject(t, llc, target, "ordinary-call-opt.ll", "ordinary-call-opt.o", x86MulDivRoundOptimize(t, ir))
+}
+
+func ordinaryGoFrameCallFixture(t *testing.T, declaration, assembly string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	pkg, request := goAMD64FrameTypedFixture(t, declaration, assembly)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures := make(map[string]FuncSig)
+	for _, name := range []string{"Value", "Callee"} {
+		if fn, ok := pkg.Types.Scope().Lookup(name).(*types.Func); ok {
+			sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, fn, "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures[sig.Name] = sig
+		}
+	}
+	return pkg, request, file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: testResolveSym(pkg.Path), Sigs: signatures,
+	}
+}
+
+func ordinaryGoFrameCallOriginalPackage(t *testing.T, request GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	env := append(append([]string(nil), request.Environment...),
+		"GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+	archive := filepath.Join(t.TempDir(), "original.a")
+	output, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+		"build", "-o", archive, ".")
+	if err != nil {
+		t.Fatalf("stock Go rejected the complete Go-body/assembly package: %v\n%s", err, output)
+	}
+	if info, err := os.Stat(archive); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatal("stock Go did not produce the complete package archive", err)
+	}
+}
+
+func TestGoAMD64FrameOrdinaryGoCalleeCaptureAndObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request, file, options := ordinaryGoFrameCallFixture(t,
+		ordinaryGoFrameCallDeclarations, ordinaryGoFrameCallAssembly)
+	callee := options.Sigs[pkg.Path+".Callee"]
+	if len(callee.Args) != 1 || callee.Args[0] != I64 || callee.Ret != I64 ||
+		len(callee.Frame.Params) != 1 || callee.Frame.Params[0].Offset != 0 ||
+		len(callee.Frame.Results) != 1 || callee.Frame.Results[0].Offset != 8 {
+		t.Fatal("the independently expected ABI0 outgoing/result slots changed", callee)
+	}
+	// This compiles both the real Go callee and its assembly caller. The
+	// archive is not a claim of runtime execution or memory-effect proof.
+	ordinaryGoFrameCallOriginalPackage(t, request)
+	listing := frameRelocationOriginal(t, pkg, request)
+	if !strings.Contains(string(listing), "t=R_CALL "+pkg.Path+".Callee+0") {
+		t.Fatal("the independent assembler omitted the direct ABI0 callee identity", string(listing))
+	}
+	leaves, err := goAMD64FramePrivateLeaves(file, pkg)
+	if err != nil || len(leaves) != 0 {
+		t.Fatal("a Go implementation was reclassified as a private assembly leaf", leaves, err)
+	}
+	t.Run("unbound-three-APIs", func(t *testing.T) {
+		fixedLocalAPIs(t, pkg, file, options, func(t *testing.T, ir string, err error) {
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("callee signatures alone authorized the original physical source frame", err, ir)
+			}
+		})
+	})
+	// Each API owns its bounded capture/binding lifetime. Old production must
+	// fail here at Capture, not pass as an intentional source rejection.
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil || !strings.Contains(ir, "call i64 @\""+pkg.Path+".Callee\"(i64 ") ||
+				strings.Contains(ir, "define i64 @\""+pkg.Path+".Callee\"") {
+				t.Fatal("ordinary Go call was dropped, inlined as a private leaf, or assigned another ABI", err, ir)
+			}
+			ordinaryGoFrameCallObjects(t, ir)
+		})
+	t.Run("narrow-ABI0-slots", func(t *testing.T) {
+		declaration := "func Value(a uint64) uint64\nfunc Callee(a uint8) uint8 { return (a ^ 11) + 17 }\n"
+		assembly := strings.Replace(ordinaryGoFrameCallAssembly, "MOVQ 8(SP),AX", "MOVBQZX 8(SP),AX", 1)
+		pkg, request, _, options := ordinaryGoFrameCallFixture(t, declaration, assembly)
+		ordinaryGoFrameCallOriginalPackage(t, request)
+		fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+			func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "call i8 @\""+pkg.Path+".Callee\"(i8 ") {
+					t.Fatal("narrow argument/result transport lost its exact typed CALL", err, ir)
+				}
+				ordinaryGoFrameCallObjects(t, ir)
+			})
+	})
+}
+
+func TestGoAMD64FrameOrdinaryCallOutgoingAndClobberBoundaries(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, test := range []struct {
+		name, before, after string
+	}{
+		{"missing-argument", "\tMOVQ AX,0(SP)\n", ""},
+		{"partial-argument", "\tMOVQ AX,0(SP)\n", "\tMOVL AX,0(SP)\n"},
+		{"wrong-argument-slot", "\tMOVQ AX,0(SP)\n", "\tMOVQ AX,16(SP)\n"},
+		{"private-address-argument", "\tMOVQ AX,0(SP)\n", "\tLEAQ 32(SP),AX\n\tMOVQ AX,0(SP)\n"},
+		{"old-GP-result", "\tMOVQ 8(SP),AX\n", ""},
+		{"old-vector", "\tCALL ·Callee(SB)\n\tMOVQ 8(SP),AX\n", "\tPXOR X0,X0\n\tCALL ·Callee(SB)\n\tMOVQ X0,AX\n"},
+		{"old-FLAGS", "\tCALL ·Callee(SB)\n\tMOVQ 8(SP),AX\n", "\tCMPQ AX,$0\n\tCALL ·Callee(SB)\n\tMOVQ $0,AX\n\tSETCS AL\n"},
+		{"old-outgoing-input", "\tMOVQ 8(SP),AX\n", "\tMOVQ 0(SP),AX\n"},
+		{"overwritten-frame-pointer", "\tCALL ·Callee(SB)\n", "\tMOVQ $0,BP\n\tCALL ·Callee(SB)\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(ordinaryGoFrameCallAssembly, test.before, test.after, 1)
+			pkg, request, file, options := ordinaryGoFrameCallFixture(t, ordinaryGoFrameCallDeclarations, assembly)
+			ordinaryGoFrameCallOriginalPackage(t, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("a legal original CALL did not reach its independent state boundary", err)
+			}
+			defer func() {
+				if err := owner.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if _, err := owner.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ordinary Go CALL acquired undefined bytes or retained physical scratch facts", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameOrdinaryCallSourceAndSuppliedABIStayBound(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, change := range []string{"Go-body-mutation", "register-ABI", "result-type", "parameter-slot"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, request, file, options := ordinaryGoFrameCallFixture(t,
+				ordinaryGoFrameCallDeclarations, ordinaryGoFrameCallAssembly)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("canonical ordinary CALL must capture before testing an independent boundary", err)
+			}
+			defer func() {
+				if err := owner.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if callee, found := owner.functions[pkg.Path+".Callee"]; found && callee.privateLeaf {
+				t.Fatal("the Go body acquired a private physical entry")
+			}
+			if change == "Go-body-mutation" {
+				path := filepath.Join(request.Directory, "value.go")
+				before, err := os.ReadFile(path)
+				if err != nil {
+					t.Fatal(err)
+				}
+				after := bytes.Replace(before, []byte("+ 17"), []byte("+ 19"), 1)
+				if bytes.Equal(before, after) {
+					t.Fatal("source mutation did not alter the actual implementation")
+				}
+				if err := os.WriteFile(path, after, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("a changed implementation retained the captured call source")
+				}
+				return
+			}
+			callee := options.Sigs[pkg.Path+".Callee"]
+			switch change {
+			case "register-ABI":
+				callee.ArgRegs = []Reg{AX}
+			case "result-type":
+				callee.Ret = I32
+			case "parameter-slot":
+				callee.Frame.Params = append([]FrameSlot(nil), callee.Frame.Params...)
+				callee.Frame.Params[0].Offset++
+			}
+			options.Sigs[callee.Name] = callee
+			if _, err := owner.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("supplied signature changed the actual ABI0 callee contract", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_ordinary_call_runtime_test.go b/amd64_go_frame_ordinary_call_runtime_test.go
new file mode 100644
index 000000000..72b0899f3
--- /dev/null
+++ b/amd64_go_frame_ordinary_call_runtime_test.go
@@ -0,0 +1,63 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Actual Go archives/ABI0 objects are checked by the source owner. This
+// independent C callee executes the translated logical call on the host;
+// it does not claim original native AMD64 or Go runtime execution.
+func TestGoAMD64FrameOrdinaryCallPortableValues(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	execution := x86ScalarCountHostExecution(t)
+	pkg, request, _, options := ordinaryGoFrameCallFixture(t,
+		ordinaryGoFrameCallDeclarations, ordinaryGoFrameCallAssembly)
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	driver := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+static unsigned calls;
+uint64_t callee(uint64_t) __asm__(%q);
+uint64_t callee(uint64_t a) { ++calls; return (a ^ UINT64_C(11)) + UINT64_C(17); }
+extern uint64_t value(uint64_t) __asm__(%q);
+int main(void) {
+    const uint64_t edges[] = {0, 1, 10, 11, 12, UINT64_MAX, UINT64_C(0x8000000000000000), UINT64_C(0x7fffffffffffffff)};
+    uint64_t random = UINT64_C(0x893701ab2468cdfe);
+    for (unsigned i = 0; i < 264; ++i) {
+        random ^= random << 13; random ^= random >> 7; random ^= random << 17;
+        uint64_t input = i < 8 ? edges[i] : random;
+        uint64_t expected = (input ^ UINT64_C(11)) + UINT64_C(17) + UINT64_C(37);
+        uint64_t got = value(input);
+        if (got != expected || calls != i + 1) {
+            fprintf(stderr, "ordinary call input=%%llu got=%%llu expected=%%llu calls=%%u\n",
+                (unsigned long long)input, (unsigned long long)got, (unsigned long long)expected, calls);
+            return 1;
+        }
+    }
+    return 0;
+}
+`, prefix+pkg.Path+".Callee", prefix+pkg.Path+".Value")
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+		func(t *testing.T, ir string, err error) {
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86MulDivRoundOptimize(t, text)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+						execution.compileAndRunLLVM(t, "ordinary-call", text, driver, level)
+					})
+				}
+			}
+		})
+}
diff --git a/amd64_go_frame_ordinary_call_transfer_test.go b/amd64_go_frame_ordinary_call_transfer_test.go
new file mode 100644
index 000000000..b4e63b3f5
--- /dev/null
+++ b/amd64_go_frame_ordinary_call_transfer_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Pure typed-state tests run on the translator's minimum SDK too. They do not
+// impersonate the separately audited Go1.27 object/source producer.
+func TestGoAMD64FrameOrdinaryCallTypedTransfer(t *testing.T) {
+	sig := FuncSig{Name: "example.Callee", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Field: -1}}, Results: []FrameSlot{{Offset: 8, Type: I64, Field: -1}}}}
+	binding := &x86FixedLocalBinding{
+		symbols: map[string]string{"·Callee": sig.Name}, signatures: map[string]FuncSig{sig.Name: sig},
+		callees: map[string]goAMD64FrameDeclaration{sig.Name: {signature: sig, transport: goAMD64FrameNumericTransport}},
+	}
+	proof := &x86FixedLocalProof{binding: binding, frame: 48}
+	call := x86ScalarLaneInstruction(t, "CALL ·Callee(SB)")
+	state := fixedLocalExchangeState()
+	state.bytes.setRange(0, 48, true)
+	state.booleanBytes.setRange(0, 48, true)
+	state.bytes.setRange(8, 8, false)
+	state.addresses[8] = 32
+	state.opaqueCells[8] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+	state.known[AX], state.booleans[AX], state.constants[AX] = 255, 255, 1
+	state.ranges = map[Reg]x86UnsignedRange{AX: {minimum: 1, maximum: 1}}
+	state.comparison = x86FixedLocalComparison{register: AX, constant: 1}
+	state.pointers[BX] = 32
+	state.opaque[CX] = fixedLocalOrigin(x86FixedLocalOrigin{parameter: 0})
+	state.vectors["Z0"], state.masks["K1"] = ^uint64(0), true
+	before := cloneFixedLocalState(state)
+	if err := fixedLocalOrdinaryCallStep(call, &state, proof); err != nil {
+		t.Fatal(err)
+	}
+	if state.bytes.all(0, 8) || !state.bytes.all(8, 8) || !state.bytes.all(32, 8) ||
+		state.booleanBytes.all(0, 16) || !state.booleanBytes.all(32, 8) ||
+		len(state.addresses) != 0 || len(state.opaqueCells) != 0 ||
+		len(state.known)+len(state.booleans)+len(state.constants)+len(state.ranges)+len(state.opaque) != 0 ||
+		len(state.pointers) != 1 || state.pointers[SP] != 0 || len(state.vectors)+len(state.masks) != 0 || state.flags != 0 ||
+		state.comparison != (x86FixedLocalComparison{}) {
+		t.Fatal("CALL retained outgoing aliases/predicates/scratch or lost unescaped private bytes", state)
+	}
+	for index := int64(0); index < 16; index++ {
+		if state.booleanBytes.has(index) {
+			t.Fatal("an old outgoing bool byte survived a nonboolean call result", index)
+		}
+	}
+	for _, test := range []string{"missing-byte", "private-pointer", "unknown-call", "wrong-SP", "short-frame"} {
+		t.Run(test, func(t *testing.T) {
+			state := cloneFixedLocalState(before)
+			ins, localProof := call, *proof
+			switch test {
+			case "missing-byte":
+				state.bytes.set(7, false)
+			case "private-pointer":
+				state.bytes.setRange(0, 8, false)
+				state.addresses[0] = 32
+			case "unknown-call":
+				ins = x86ScalarLaneInstruction(t, "CALL ·Foreign(SB)")
+			case "wrong-SP":
+				state.pointers[SP] = 8
+			case "short-frame":
+				localProof.frame = 8
+			}
+			if err := fixedLocalOrdinaryCallStep(ins, &state, &localProof); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an incomplete/unbound outgoing call acquired a result", err)
+			}
+		})
+	}
+	t.Run("narrow-result-padding", func(t *testing.T) {
+		narrow := sig
+		narrow.Args, narrow.Ret = []LLVMType{I8}, I8
+		narrow.Frame = FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I8, Field: -1}}, Results: []FrameSlot{{Offset: 8, Type: I8, Field: -1}}}
+		localBinding := *binding
+		localBinding.signatures = map[string]FuncSig{sig.Name: narrow}
+		localBinding.callees = map[string]goAMD64FrameDeclaration{sig.Name: {signature: narrow, transport: goAMD64FrameNumericTransport}}
+		localProof := *proof
+		localProof.binding = &localBinding
+		state := cloneFixedLocalState(before)
+		if err := fixedLocalOrdinaryCallStep(call, &state, &localProof); err != nil {
+			t.Fatal(err)
+		}
+		for index := int64(0); index < 16; index++ {
+			if state.bytes.has(index) != (index == 8) {
+				t.Fatal("narrow result or ABI0 trailing padding acquired initialized bytes", index)
+			}
+		}
+	})
+}
diff --git a/amd64_go_frame_package_directory_test.go b/amd64_go_frame_package_directory_test.go
new file mode 100644
index 000000000..f017be148
--- /dev/null
+++ b/amd64_go_frame_package_directory_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGoAMD64FrameSourceChildDirectoriesStayOutsidePackage(t *testing.T) {
+	for _, change := range []string{"contents", "replacement", "regular file", "symlink", "removed", "new sibling", "source bytes"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			child := filepath.Join(request.Directory, "testdata")
+			if err := os.Mkdir(child, 0700); err != nil {
+				t.Fatal(err)
+			}
+			unused := filepath.Join(child, "unused.bin")
+			file, err := os.Create(unused)
+			if err != nil {
+				t.Fatal(err)
+			}
+			truncateErr := file.Truncate(17 << 20)
+			if err := errors.Join(truncateErr, file.Close()); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			if _, retained := source.inputs[unused]; retained {
+				t.Fatal("unimported descendant became a package input")
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			switch change {
+			case "contents":
+				err = os.WriteFile(unused, []byte("not a compiler input"), 0600)
+			case "replacement", "regular file", "symlink", "removed":
+				// Keep the old inode alive so replacement cannot reuse it.
+				err = os.Rename(child, filepath.Join(t.TempDir(), "original"))
+				if err == nil {
+					switch change {
+					case "replacement":
+						err = os.Mkdir(child, 0700)
+					case "regular file":
+						err = os.WriteFile(child, []byte("changed role"), 0600)
+					case "symlink":
+						err = os.Symlink(t.TempDir(), child)
+					}
+				}
+			case "new sibling":
+				err = os.Mkdir(filepath.Join(request.Directory, "new"), 0700)
+			case "source bytes":
+				err = os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package changed\n"), 0600)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = source.Verify(ctx)
+			if change == "contents" {
+				if err != nil {
+					t.Fatalf("unimported contents changed the package witness: %v", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed original input role remained valid: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_private_leaf.go b/amd64_go_frame_private_leaf.go
new file mode 100644
index 000000000..f327f4856
--- /dev/null
+++ b/amd64_go_frame_private_leaf.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This classifies original source nodes, not callable ABIs or initialized
+// inputs. A leaf cannot observe its physical frame or CALL's stack change.
+// A nonzero frame's automatic BP/FLAGS effects are checked independently.
+func goAMD64FramePrivateLeaves(file *File, pkg GoPackage) (map[string]bool, error) {
+	if file == nil || pkg.Types == nil {
+		return nil, goAMD64FrameContext("private source roles need complete parsed source and actual types")
+	}
+	leaves := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		if _, declared := pkg.Types.Scope().Lookup(strings.TrimPrefix(fn.Sym, "·")).(*types.Func); declared {
+			continue
+		}
+		name := strings.TrimSuffix(fn.Sym, "<>")
+		if name == "" || strings.ContainsAny(name, "·./<>") || fn.FrameSize < 0 || fn.FrameSize > 64<<10 ||
+			fn.FrameSize%8 != 0 || fn.ArgSize != 0 || len(fn.Instrs) == 0 {
+			return nil, goAMD64FrameContext("undeclared TEXT is not a bounded same-source leaf: %s", fn.Sym)
+		}
+		_, header := splitOpcode(fn.Instrs[0].Raw)
+		parts := strings.Split(header, ",")
+		if len(parts) != 3 {
+			return nil, goAMD64FrameContext("private leaf needs explicit original NOSPLIT flags")
+		}
+		flags, err := nativeFlags(parts[1], "NOSPLIT", "NOFRAME")
+		if err != nil || !flags["NOSPLIT"] {
+			return nil, goAMD64FrameContext("private leaf has an unclosed original prologue")
+		}
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpCALL || isX86RawDirective(ins) {
+				return nil, goAMD64FrameContext("private leaf has raw or non-leaf effects")
+			}
+			if _, stack, _ := x86StackWidthProperties(ins, "amd64"); stack {
+				return nil, goAMD64FrameContext("private leaf observes implicit stack storage")
+			}
+			for _, operand := range ins.Args {
+				if operand.Kind == OpFP || operand.Kind == OpFPAddr || operand.Kind == OpReg && operand.Reg == SP ||
+					operand.Kind == OpMem && (operand.Mem.Base == SP || operand.Mem.Index == SP) {
+					return nil, goAMD64FrameContext("private leaf observes its incoming physical frame")
+				}
+			}
+		}
+		leaves[fn.Sym] = true
+	}
+	graph := &x86DirectTailGraph{original: file, helpers: leaves}
+	if err := graph.auditReferences(); err != nil {
+		return nil, err
+	}
+	reached := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op != OpCALL && ins.Op != OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			if valid && offset == 0 && leaves[name] {
+				if ins.Op != OpCALL {
+					return nil, goAMD64FrameContext("framed root cannot tail-enter a private leaf")
+				}
+				reached[name] = true
+			}
+		}
+	}
+	for name := range leaves {
+		if !reached[name] {
+			return nil, goAMD64FrameContext("private leaf lacks a same-source declared caller: %s", name)
+		}
+	}
+	return leaves, nil
+}
+
+// Reuse the independent complete source/object association. Go orders static
+// and nonstatic symbols in separate banks; listings retain source order.
+func goAMD64FrameSourceTexts(listing []byte, data *gostaticstorage.AMD64AssemblyData) ([]gostaticstorage.TextRecord, error) {
+	if _, err := sdkAMD64FrameNativeRecordsForSource(listing, data.Member.Texts, data.TextOrder); err != nil {
+		return nil, err
+	}
+	texts := make([]gostaticstorage.TextRecord, len(data.TextOrder))
+	for index, association := range data.TextOrder {
+		texts[index] = data.Member.Texts[association.ObjectOrdinal]
+	}
+	return texts, nil
+}
+
+func goAMD64FrameLocalCallTarget(r gostaticstorage.TextRelocation, texts []gostaticstorage.TextRecord) bool {
+	if r.Type != 7 || r.Size != 4 || r.Add != 0 || !r.Target.ABIKnown {
+		return false
+	}
+	for _, text := range texts {
+		bank := uint32(2147483647) // PkgIdxNone: non-package definitions.
+		if text.Namespace == gostaticstorage.TextSymbolSelf {
+			bank = 2147483643
+		} else if text.Namespace != gostaticstorage.TextSymbolNonpkgDefinition {
+			continue
+		}
+		if r.Target.Name == text.Name && r.Target.ABI == text.ABI &&
+			r.Target.PackageIndex == bank && r.Target.SymbolIndex == text.Relative {
+			return true
+		}
+	}
+	return false
+}
+
+// Machine CALL fields must match the complete original source call order and
+// exact observed object target. Each caller supplies independently established
+// source roles; this association grants no private-leaf or ordinary-call ABI.
+// Generated split calls are outside this projection.
+func goAMD64FrameSourceCallPCs(fn goAMD64FrameFunction, original Func, text gostaticstorage.TextRecord,
+	allowed map[string]bool, names map[string]string) (map[int]bool, error) {
+	var targets []string
+	for _, ins := range original.Instrs {
+		if ins.Op != OpCALL {
+			continue
+		}
+		if len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+			return nil, goAMD64FrameContext("original CALL lacks a direct observed target")
+		}
+		name, offset, valid := parseSBRef(ins.Args[0].Sym)
+		if !valid || offset != 0 || !allowed[name] || names[name] == "" {
+			return nil, goAMD64FrameContext("original CALL target has no complete observed source role")
+		}
+		targets = append(targets, names[name])
+	}
+	calls := make(map[int]bool)
+	for _, relocation := range text.Relocations {
+		pc := int(relocation.Offset) - fn.prologue - 1
+		if relocation.Type != 7 || pc < 0 || pc >= len(fn.code) {
+			continue
+		}
+		if len(calls) >= len(targets) || relocation.Target.Name != targets[len(calls)] ||
+			relocation.Size != 4 || relocation.Add != 0 || pc+5 > len(fn.code) ||
+			fn.code[pc] != 0xe8 || !bytes.Equal(fn.code[pc+1:pc+5], []byte{0, 0, 0, 0}) ||
+			!strings.Contains(fn.positions[pc], "\tCALL\t") || calls[pc] {
+			return nil, goAMD64FrameContext("original source CALL and exact machine relocation differ")
+		}
+		calls[pc] = true
+	}
+	if len(calls) != len(targets) {
+		return nil, goAMD64FrameContext("original source CALL inventory is incomplete")
+	}
+	return calls, nil
+}
+
+func goAMD64FramePrivateCallRelocation(r gostaticstorage.TextRelocation, data *gostaticstorage.AMD64AssemblyData) string {
+	if goAMD64FrameLocalCallTarget(r, data.Member.Texts) {
+		return fmt.Sprintf("rel %d+4 t=R_CALL %s+0", r.Offset, r.Target.Name)
+	}
+	return ""
+}
diff --git a/amd64_go_frame_profile_test.go b/amd64_go_frame_profile_test.go
new file mode 100644
index 000000000..29fee414c
--- /dev/null
+++ b/amd64_go_frame_profile_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestGoAMD64FrameSourceActualCPUProfiles(t *testing.T) {
+	// Share only this root's owned build cache. Go 1.27 builds its objdump
+	// helper there; rebuilding that tool for every profile adds no coverage.
+	// Every fixture retains its own source/module/temp directories and still
+	// runs actual Go selection, export, object and post-capture verification.
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		for _, profile := range []string{"v1", "v2", "v3", "v4"} {
+			t.Run(target.name+"/"+profile, func(t *testing.T) {
+				pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+				request.Target = target.name
+				request.Environment = append(request.Environment, "GOAMD64="+profile)
+				options.TargetTriple = target.triple
+				assembly := filepath.Join(request.Directory, request.AssemblyFile)
+				original, err := os.ReadFile(assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Go must select the exact feature-tagged original file before
+				// the frame factory independently observes its native object.
+				tagged := fmt.Sprintf("//go:build amd64.%s\n\n%s", profile, original)
+				if err := os.WriteFile(assembly, []byte(tagged), 0600); err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				env := append(append([]string(nil), request.Environment...),
+					"GOOS="+strings.Split(target.name, "/")[0], "GOARCH=amd64",
+					"CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+				output, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+					"list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+				if err != nil {
+					t.Fatalf("independent actual Go profile control: %v\n%s", err, output)
+				}
+				var selected goAMD64FrameSelection
+				if err := json.Unmarshal(output, &selected); err != nil || selected.Export == "" ||
+					len(selected.SFiles) != 1 || selected.SFiles[0] != request.AssemblyFile {
+					t.Fatalf("actual Go omitted profile-selected assembly/export: %v\n%s", err, output)
+				}
+				source := requireGoAMD64FrameCapture(t, pkg, request)
+				if source.env["GOAMD64"] != profile || source.env["GOOS"]+"/"+source.env["GOARCH"] != target.name {
+					t.Fatal("capture substituted a different actual CPU/target profile")
+				}
+				bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "profile.ll", "profile.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "profile-opt.ll", "profile-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+				if err := source.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FrameSourceCPUProfileRevocation(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, profile := range []string{"v1", "v2", "v3", "v4"} {
+		t.Run(profile, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			request.Environment = append(request.Environment, "GOAMD64="+profile)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			before := append([]string(nil), source.request.Environment...)
+			replacement := "v1"
+			if profile == "v1" {
+				replacement = "v2"
+			}
+			source.request.Environment = append(source.request.Environment, "GOAMD64="+replacement)
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a different actual CPU profile retained the original observation", err)
+			}
+			source.request.Environment = before
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("restoring the CPU profile revived a revoked observation", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceCPUProfilesDoNotGrantGeneratedCPP(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, profile := range []string{"v1", "v2", "v3", "v4"} {
+		t.Run(profile, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			request.Environment = append(request.Environment, "GOAMD64="+profile)
+			name := filepath.Join(request.Directory, request.AssemblyFile)
+			original, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			conditional := fmt.Sprintf("#ifdef GOAMD64_%s\n#include \"go_asm.h\"\n%s\n#endif\n", profile, original)
+			if err := os.WriteFile(name, []byte(conditional), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil {
+				source.Close()
+				t.Fatal("conditional generated header acquired an ordinary profile observation")
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "qualified metadata") {
+				t.Fatal("generated CPP still needs its own source mapping, not CPU rejection", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_relocation_kinds_test.go b/amd64_go_frame_relocation_kinds_test.go
new file mode 100644
index 000000000..876522f4a
--- /dev/null
+++ b/amd64_go_frame_relocation_kinds_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func frameRelocationOriginal(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest) []byte {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	env := append(append([]string(nil), request.Environment...),
+		"GOOS="+strings.Split(request.Target, "/")[0], "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+	object := filepath.Join(t.TempDir(), "original.o")
+	listing, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+		"tool", "asm", "-S", "-p", pkg.Path, "-o", object, request.AssemblyFile)
+	if err != nil {
+		t.Fatalf("original Go assembly failed: %v\n%s", err, listing)
+	}
+	info, err := os.Stat(object)
+	if err != nil || info.Size() == 0 {
+		t.Fatal("successful original assembler did not produce a complete object", err)
+	}
+	t.Logf("original Go %s %s listing:\n%s", runtime.Version(), request.Target, listing)
+	return listing
+}
+
+func TestGoAMD64FrameOrdinaryCallDoesNotMintPermission(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			const assembly = "TEXT ·Caller(SB),4,$24-24\nMOVQ dst+0(FP),AX\nMOVQ AX,0(SP)\n" +
+				"MOVQ src+8(FP),AX\nMOVQ AX,8(SP)\nMOVQ n+16(FP),AX\nMOVQ AX,16(SP)\nCALL ·External(SB)\nRET\n"
+			pkg, request := goAMD64FrameTypedFixture(t, "func Caller(dst,src *byte,n uintptr)\nfunc External(dst,src *byte,n uintptr)\n", assembly)
+			request.Target = target
+			listing := frameRelocationOriginal(t, pkg, request)
+			call := "t=R_CALL " + pkg.Path + ".External+0"
+			if !gotoolchain.AuditedGo127(runtime.Version()) {
+				call = "t=7 \"\".External+0"
+			}
+			if !strings.Contains(string(listing), call) {
+				t.Fatal("original ordinary direct CALL relocation was not observed", string(listing))
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if owner != nil {
+				if closeErr := owner.Close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an ordinary relocation acquired a private-call or callee frame contract", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_requested_member_test.go b/amd64_go_frame_requested_member_test.go
new file mode 100644
index 000000000..7b890c585
--- /dev/null
+++ b/amd64_go_frame_requested_member_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// Complete package inputs remain live observations even when only one assembly
+// member is requested for a frame binding. These ordinary Go formats work on
+// both supported endpoint SDKs; no current-only object decoder is called here.
+func TestGoAMD64FrameRequestedMemberRetainsSiblingInventory(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		for _, change := range []string{"ASM", "CPP"} {
+			t.Run(target+"/"+change, func(t *testing.T) {
+				const declarations = "func Value(a uint64) uint64\nfunc Unused(dst,src *byte,n uintptr)\nfunc External(dst,src *byte,n uintptr)\n"
+				const value = "TEXT ·Value(SB),4,$24-16\nMOVQ a+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+				const unused = "#include \"textflag.h\"\n#include \"sibling.h\"\nTEXT ·Unused(SB),NOSPLIT,$24-24\nMOVQ dst+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ src+8(FP),AX\nMOVQ AX,8(SP)\nMOVQ n+16(FP),AX\nMOVQ AX,16(SP)\nADDQ $EXTRA,AX\nCALL ·External(SB)\nRET\n"
+				pkg, request := goAMD64FrameTypedFixture(t, declarations, value)
+				request.Target = target
+				sibling := filepath.Join(request.Directory, "a_unused_amd64.s")
+				header := filepath.Join(request.Directory, "sibling.h")
+				if err := os.WriteFile(sibling, []byte(unused), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(header, []byte("#define EXTRA 0\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				callRequest := request
+				callRequest.AssemblyFile = filepath.Base(sibling)
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				env := append(append([]string(nil), request.Environment...),
+					"GOOS="+strings.Split(target, "/")[0], "GOARCH=amd64", "CGO_ENABLED=0",
+					"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+				for _, member := range []string{request.AssemblyFile, callRequest.AssemblyFile} {
+					object := filepath.Join(t.TempDir(), member+".o")
+					listing, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary,
+						"tool", "asm", "-S", "-p", pkg.Path,
+						"-I", filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "pkg", "include"),
+						"-o", object, member)
+					if err != nil {
+						t.Fatalf("independent original member %s: %v\n%s", member, err, listing)
+					}
+					if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+						t.Fatal("original member lacks its complete Go object", member, err)
+					}
+				}
+				owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+				if err != nil {
+					t.Fatal("unrequested valid assembly sibling acquired a frame-proof obligation", err)
+				}
+				defer func() {
+					if err := owner.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+				if len(owner.selection.SFiles) != 2 || len(owner.functions) != 1 ||
+					owner.functions[pkg.Path+".Value"].sourceSymbol != "·Value" {
+					t.Fatal("frame observation lost the complete selection or exact requested member")
+				}
+				toolHeader := filepath.Join(owner.env["GOROOT"], "pkg", "include", "textflag.h")
+				for _, name := range []string{sibling, header, toolHeader} {
+					if _, found := owner.inputs[name]; !found {
+						t.Fatal("unrequested sibling input escaped live source verification", name)
+					}
+				}
+				if owner.origins[toolHeader] == 0 || owner.origins[header] == 0 {
+					t.Fatal("sibling-only CPP dependencies lost their actual source association")
+				}
+				if err := owner.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				callOwner, err := CaptureGoAMD64FrameSource(ctx, pkg, callRequest)
+				if callOwner != nil {
+					if closeErr := callOwner.Close(); closeErr != nil {
+						t.Error(closeErr)
+					}
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("a requested ordinary CALL acquired a callee/frame contract", err)
+				}
+				expanded, err := owner.preprocess(callRequest.AssemblyFile, []byte(unused))
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, expanded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := map[string]string{"linux/amd64": "x86_64-unknown-linux-gnu", "darwin/amd64": "x86_64-apple-darwin", "windows/amd64": "x86_64-pc-windows-msvc"}[target]
+				name := pkg.Path + ".Unused"
+				_, err = owner.BindFixedLocal(ctx, pkg, file, Options{Goarch: "amd64", TargetTriple: triple,
+					Sigs:       map[string]FuncSig{name: owner.declarations[name].signature},
+					ResolveSym: func(symbol string) string { return pkg.Path + "." + strings.TrimPrefix(symbol, "·") }})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("requested member owner authorized a different sibling's source", err)
+				}
+				if err := owner.Verify(ctx); err != nil {
+					t.Fatal("negative sibling binding invalidated the positive mutation control", err)
+				}
+				changed, data := sibling, unused+"\n"
+				if change == "CPP" {
+					changed, data = header, "#define EXTRA 1\n"
+				}
+				if err := os.WriteFile(changed, []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := owner.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unrequested selected sibling mutation retained source ownership", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_go_frame_return_cfg_go127_test.go b/amd64_go_frame_return_cfg_go127_test.go
new file mode 100644
index 000000000..dbf7ee594
--- /dev/null
+++ b/amd64_go_frame_return_cfg_go127_test.go
@@ -0,0 +1,58 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func fixedLocalReturnCFGProgram() (string, string, []string) {
+	var assembly, declarations strings.Builder
+	var expected []string
+	for _, flags := range []string{"", "4,"} {
+		for _, value := range []int{0, 7} {
+			name := fmt.Sprintf("Value%d", len(expected))
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),%s$160-16\nMOVQ $%d,AX\nMOVQ AX,8(SP)\n", name, flags, value)
+			assembly.WriteString("loop:\nTESTQ AX,AX\nJNE work\nMOVQ 8(SP),AX\nMOVQ AX,ret0+8(FP)\nRET\nwork:\nXORQ AX,AX\nJMP loop\n")
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			expected = append(expected, fmt.Sprintf("%016x", value))
+		}
+	}
+	return assembly.String(), declarations.String(), expected
+}
+
+func TestGoAMD64FixedLocalReturnCFGObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	assembly, declarations, expected := fixedLocalReturnCFGProgram()
+	if len(expected) != 4 {
+		t.Fatal("complete split/NOSPLIT and branch inventory changed", len(expected))
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalTransportFixture(t, assembly, declarations, target.name, target.triple)
+			var names []string
+			for index := range expected {
+				names = append(names, fmt.Sprintf("%s.Value%d", pkg.Path, index))
+			}
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("original source with early RET and final local backedge", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					compileLLVMToObject(t, llc, target.triple, "return-cfg.ll", "return-cfg.o", ir)
+					compileLLVMToObject(t, llc, target.triple, "return-cfg-opt.ll", "return-cfg-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
diff --git a/amd64_go_frame_return_cfg_runtime_go127_test.go b/amd64_go_frame_return_cfg_runtime_go127_test.go
new file mode 100644
index 000000000..988da06a8
--- /dev/null
+++ b/amd64_go_frame_return_cfg_runtime_go127_test.go
@@ -0,0 +1,13 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalReturnCFG(t *testing.T) {
+	assembly, declarations, expected := fixedLocalReturnCFGProgram()
+	if len(expected) != 4 {
+		t.Fatal("complete return CFG runtime inventory changed", len(expected))
+	}
+	fixedLocalConstantResultsRuntime(t, assembly, declarations, expected)
+}
diff --git a/amd64_go_frame_return_cfg_test.go b/amd64_go_frame_return_cfg_test.go
new file mode 100644
index 000000000..1716814e3
--- /dev/null
+++ b/amd64_go_frame_return_cfg_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestGoAMD64FrameReturnBeforeFinalLocalBranch(t *testing.T) {
+	for _, frame := range []int64{64, 128, 160} {
+		t.Run(fmt.Sprint(frame), func(t *testing.T) {
+			assembly := fmt.Sprintf("TEXT value(SB),4,$%d-0\nMOVQ $1,AX\nloop:\nTESTQ AX,AX\nJNE work\nRET\nwork:\nXORQ AX,AX\nJMP loop\n", frame)
+			listing := x86InsertExtractGoListing(t, "amd64", assembly)
+			fn := goAMD64FrameFunction{positions: make(map[int]string)}
+			for _, line := range strings.Split(string(listing), "\n") {
+				fn.code = append(fn.code, x86InsertExtractListedBytes(line)...)
+			}
+			last := 0
+			var starts []int
+			returnIndex := -1
+			for pc := 0; pc < len(fn.code); {
+				ins, err := x86asm.Decode(fn.code[pc:], 64)
+				if err != nil || ins.Len <= 0 {
+					t.Fatal("original Go machine fixture", err)
+				}
+				// Machine-only unit fixture; the public API matrix separately
+				// captures actual original source and object positions.
+				fn.positions[pc] = "machine-shape unit fixture"
+				if ins.Op == x86asm.RET {
+					returnIndex = len(starts)
+				}
+				starts = append(starts, pc)
+				last = pc
+				pc += ins.Len
+			}
+			if len(fn.code)-last != 2 || fn.code[last] != 0xeb {
+				t.Fatalf("expected original short local JMP, got %x", fn.code[last:])
+			}
+			if err := goAMD64FrameMachineShape(fn, frame); err != nil {
+				t.Error("conventional RET may precede a closed local backedge", err)
+			}
+			if returnIndex < 2 {
+				t.Fatal("original fixture has no complete return epilogue")
+			}
+			for _, target := range []int{0, 1, starts[1], starts[2], starts[returnIndex-1], starts[returnIndex],
+				last + 1, len(fn.code), len(fn.code) + 1, -1} {
+				changed := fn
+				changed.code = append([]byte(nil), fn.code...)
+				changed.code[last+1] = byte(target - len(fn.code))
+				if err := goAMD64FrameMachineShape(changed, frame); err == nil {
+					t.Errorf("terminal branch to prologue/nonboundary/outside target %d accepted", target)
+				}
+			}
+			changed := fn
+			changed.code = append([]byte(nil), fn.code...)
+			changed.code[last] = 0x75 // JNE has an unclosed fallthrough after the function.
+			if err := goAMD64FrameMachineShape(changed, frame); err == nil {
+				t.Error("terminal conditional branch accepted an escaping fallthrough")
+			}
+			changed = fn
+			changed.code = append([]byte(nil), fn.code...)
+			changed.code[last+1] = byte(starts[returnIndex-2] - len(fn.code))
+			if err := goAMD64FrameMachineShape(changed, frame); err != nil {
+				t.Error("branch to the complete automatic epilogue entry rejected", err)
+			}
+			for _, mutation := range []string{"no RET", "wrong POP", "wrong adjustment"} {
+				changed := fn
+				changed.code = append([]byte(nil), fn.code...)
+				switch mutation {
+				case "no RET":
+					changed.code[starts[returnIndex]] = 0x90
+				case "wrong POP":
+					changed.code[starts[returnIndex-1]] = 0x5b
+				case "wrong adjustment":
+					changed.code[starts[returnIndex-1]-1] ^= 1
+				}
+				if err := goAMD64FrameMachineShape(changed, frame); err == nil {
+					t.Errorf("terminal local JMP accepted %s", mutation)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_sdk_call.go b/amd64_go_frame_sdk_call.go
new file mode 100644
index 000000000..ae349e4bb
--- /dev/null
+++ b/amd64_go_frame_sdk_call.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The existing selected dependency graph supplies both language declarations
+// and actual ABI0 entries. Neither a supplied signature nor an SDK spelling
+// creates this role; no pointee extent or noescape property follows from it.
+func (source *GoAMD64FrameSource) ordinarySDKCallDeclarations(path string, entries map[string]bool) (map[string]goAMD64FrameDeclaration, error) {
+	selected, found := source.imports[path]
+	if !found || !selected.Standard || selected.Module != nil || selected.ImportPath != path || selected.Export == "" {
+		return nil, goAMD64FrameContext("ordinary foreign CALL lacks its actual selected SDK source: %s", path)
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range selected.GoFiles {
+		filename := filepath.Join(selected.Dir, name)
+		data, err := source.read(filename)
+		if err != nil {
+			return nil, err
+		}
+		file, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		syntax = append(syntax, file)
+	}
+	actualImporter := importer.ForCompiler(fset, "gc", func(imported string) (io.ReadCloser, error) {
+		if target, mapped := selected.ImportMap[imported]; mapped {
+			imported = target
+		}
+		dependency, present := source.imports[imported]
+		if !present || dependency.Export == "" {
+			return nil, goAMD64FrameContext("SDK CALL declaration lacks its captured compiler import: %s", imported)
+		}
+		data, err := source.read(dependency.Export)
+		return io.NopCloser(bytes.NewReader(data)), err
+	})
+	sizes := types.SizesFor("gc", "amd64")
+	config := &types.Config{Sizes: sizes, Importer: actualImporter, IgnoreFuncBodies: true}
+	typed, err := config.Check(path, fset, syntax, nil)
+	if err != nil {
+		return nil, goAMD64FrameContext("actual selected SDK CALL declarations: %v", err)
+	}
+	texts, err := source.ordinarySDKCallTexts(selected, entries)
+	if err != nil {
+		return nil, err
+	}
+	declarations := make(map[string]goAMD64FrameDeclaration, len(entries))
+	for name := range entries {
+		fn, valid := typed.Scope().Lookup(name).(*types.Func)
+		if !valid {
+			return nil, goAMD64FrameContext("SDK CALL has no actual Go function declaration: %s", name)
+		}
+		sig := fn.Type().(*types.Signature)
+		if sig.Recv() != nil || sig.Variadic() || sig.TypeParams().Len() != 0 {
+			return nil, goAMD64FrameContext("SDK CALL excludes method, variadic or generic transport")
+		}
+		var language strings.Builder
+		for _, tuple := range []*types.Tuple{sig.Params(), sig.Results()} {
+			if tuple.Len() > 4096 {
+				return nil, goAMD64FrameContext("SDK CALL declaration tuple bound")
+			}
+			language.WriteString("[")
+			for index := 0; index < tuple.Len(); index++ {
+				identity, err := goAMD64FrameLanguageTypeRole(tuple.At(index).Type(), sizes, true)
+				if err != nil {
+					return nil, err
+				}
+				fmt.Fprintf(&language, "%q:%s;", tuple.At(index).Name(), identity)
+				if language.Len() > 64<<10 {
+					return nil, goAMD64FrameContext("SDK CALL language byte bound")
+				}
+			}
+			language.WriteString("]")
+		}
+		actual, err := DeriveGoFuncABI0Signature(path+"."+name, fn, "amd64", sizes)
+		if err != nil || !goAMD64FrameScalarCall(actual) || !goAMD64FrameSDKABI0Entry(texts, actual.Name) {
+			return nil, goAMD64FrameContext("SDK CALL lacks its exact scalar ABI0 declaration/entry: %s: %v", name, err)
+		}
+		declarations[actual.Name] = goAMD64FrameDeclaration{signature: actual,
+			transport: goAMD64FrameCompositeTransport, languageType: language.String()}
+	}
+	return declarations, nil
+}
+
+func (source *GoAMD64FrameSource) ordinarySDKCallTexts(selected goAMD64FrameSelection, entries map[string]bool) ([]gostaticstorage.TextRecord, error) {
+	builtin, err := source.read(filepath.Join(source.env["GOROOT"], "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		return nil, err
+	}
+	referenced := make(map[string]gostaticstorage.SDKReferencedArchive)
+	remaining := int64(64 << 20) // Same complete-archive budget as the decoder.
+	paths := []string{selected.ImportPath}
+	for len(paths) != 0 {
+		path := paths[len(paths)-1]
+		paths = paths[:len(paths)-1]
+		if _, captured := referenced[path]; captured || path == "unsafe" {
+			continue
+		}
+		dependency, found := source.imports[path]
+		if !found || !dependency.Standard || dependency.Module != nil || dependency.Export == "" {
+			return nil, goAMD64FrameContext("SDK CALL archive lacks its actual dependency: %s", path)
+		}
+		archive, err := source.readBound(dependency.Export, remaining)
+		if err != nil {
+			return nil, err
+		}
+		remaining -= int64(len(archive))
+		referenced[path] = gostaticstorage.SDKReferencedArchive{PackagePath: path, Sources: dependency.SFiles, Archive: archive}
+		paths = append(paths, dependency.Imports...)
+	}
+	archive := referenced[selected.ImportPath].Archive
+	if len(selected.SFiles) == 0 {
+		return gostaticstorage.ObserveX86SDKCompilerText(archive, builtin, source.request.Target, referenced)
+	}
+	targets := make(map[string]bool, len(entries))
+	for name := range entries {
+		targets[selected.ImportPath+"."+name] = true
+	}
+	members, err := gostaticstorage.ObserveX86SDKCallArchiveReferences(archive, builtin, source.request.Target, selected.SFiles, referenced, targets)
+	if err != nil {
+		return nil, goAMD64FrameContext("actual SDK CALL archive: %v", err)
+	}
+	var texts []gostaticstorage.TextRecord
+	for _, member := range members {
+		texts = append(texts, member.Texts...)
+	}
+	return texts, nil
+}
+
+func goAMD64FrameSDKABI0Entry(texts []gostaticstorage.TextRecord, name string) bool {
+	// These roles belong to the existing decoder's pinned current goobj
+	// schema (objabi.IsText, goobj.SymFlagABIWrapper and objabi.R_CALL).
+	const (
+		textKind       = 1
+		fipsTextKind   = 2
+		abiWrapperFlag = 1 << 6
+		callRelocation = 7
+	)
+	var entry, internal *gostaticstorage.TextRecord
+	for index := range texts {
+		text := &texts[index]
+		if text.Name != name {
+			continue
+		}
+		if text.Kind != textKind && text.Kind != fipsTextKind || text.Size <= 0 || text.Size != int64(len(text.Code)) {
+			return false
+		}
+		switch text.ABI {
+		case 0:
+			if entry != nil {
+				return false
+			}
+			entry = text
+		case 1:
+			if internal != nil {
+				return false
+			}
+			internal = text
+		default:
+			return false
+		}
+	}
+	if entry == nil {
+		return false
+	}
+	// An original ABI0 assembly entry needs no adapter; an actual generated
+	// adapter must retain its unique ABIInternal target in the same archive.
+	if entry.Flags2&abiWrapperFlag == 0 {
+		return true
+	}
+	calls := 0
+	for _, relocation := range entry.Relocations {
+		if relocation.Type == callRelocation && relocation.Target.Name == name {
+			if !relocation.Target.ABIKnown || relocation.Target.ABI != 1 || relocation.Size != 4 || relocation.Add != 0 {
+				return false
+			}
+			calls++
+		}
+	}
+	return internal != nil && calls == 1
+}
diff --git a/amd64_go_frame_sdk_call_budget_test.go b/amd64_go_frame_sdk_call_budget_test.go
new file mode 100644
index 000000000..b006fd1a8
--- /dev/null
+++ b/amd64_go_frame_sdk_call_budget_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGoAMD64FrameForeignABI0SDKArchiveBudgetBeforeRead(t *testing.T) {
+	// These are deliberately invalid object bytes, not SDK source evidence.
+	// Observe whether the second file was read before format validation: the
+	// aggregate bound must stop an oversized graph before retaining that input.
+	for _, excess := range []bool{false, true} {
+		name := "exact-budget"
+		if excess {
+			name = "over-budget"
+		}
+		t.Run(name, func(t *testing.T) {
+			directory, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			builtin := filepath.Join(directory, "src/cmd/internal/goobj/builtinlist.go")
+			if err := os.MkdirAll(filepath.Dir(builtin), 0700); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(builtin, []byte("fixture"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			first, second := filepath.Join(directory, "first.a"), filepath.Join(directory, "second.a")
+			file, err := os.Create(first)
+			if err != nil {
+				t.Fatal(err)
+			}
+			truncateErr := file.Truncate((64 << 20) - 1)
+			closeErr := file.Close()
+			if truncateErr != nil || closeErr != nil {
+				t.Fatal(truncateErr, closeErr)
+			}
+			last := []byte{0}
+			if excess {
+				last = append(last, 0)
+			}
+			if err := os.WriteFile(second, last, 0600); err != nil {
+				t.Fatal(err)
+			}
+			selected := goAMD64FrameSelection{ImportPath: "fixture/first", Standard: true, Export: first, Imports: []string{"fixture/second"}}
+			source := &GoAMD64FrameSource{env: map[string]string{"GOROOT": directory}, inputs: make(map[string][32]byte),
+				request: GoAMD64FrameCaptureRequest{Target: "linux/amd64"},
+				imports: map[string]goAMD64FrameSelection{selected.ImportPath: selected,
+					"fixture/second": {ImportPath: "fixture/second", Standard: true, Export: second}}}
+			if _, err := source.ordinarySDKCallTexts(selected, map[string]bool{"Value": true}); err == nil {
+				t.Fatal("invalid archive fixture acquired an SDK call observation")
+			} else if excess && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("oversized input was not stopped by the source read bound", err)
+			}
+			if _, captured := source.inputs[first]; !captured {
+				t.Fatal("the first fitting file was not observed")
+			}
+			if _, captured := source.inputs[second]; captured == excess {
+				t.Fatal("the aggregate budget did not bound the next file before observation", captured, excess)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_source.go b/amd64_go_frame_source.go
new file mode 100644
index 000000000..6558b19d7
--- /dev/null
+++ b/amd64_go_frame_source.go
@@ -0,0 +1,2069 @@
+package plan9asm
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goabi"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmmacros"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// GoAMD64FrameCaptureRequest describes actual input locations, not permissions.
+type GoAMD64FrameCaptureRequest struct {
+	GoBinary, Directory, AssemblyFile, Target string
+	Environment                               []string
+	// NumericalReads joins one already authenticated original numerical-read
+	// source. It observes relocations; it grants no additional memory role.
+	NumericalReads *GoX86NumericalReadBinding
+}
+
+// GoAMD64FrameSource is a sealed actual-object observation. It does not grant
+// a native backing, caller region, memory access or return certificate.
+type GoAMD64FrameSource struct {
+	mu                 sync.Mutex
+	identity           *GoAMD64FrameSource
+	ready              bool
+	request            GoAMD64FrameCaptureRequest
+	selection          goAMD64FrameSelection
+	env                map[string]string
+	assemblerDefines   []string
+	inputs             map[string][32]byte
+	entries            []string
+	directoryInfo      os.FileInfo
+	childDirectories   map[string]os.FileInfo
+	directoryInventory *gooriginalsrc.Snapshot // Immutable complete SDK membership; no source or ASM authority.
+	owned              string
+	ownedInfo          os.FileInfo
+	functions          map[string]goAMD64FrameFunction
+	declarations       map[string]goAMD64FrameDeclaration
+	callees            map[string]goAMD64FrameDeclaration // Actual separate Go/SDK callees, never private leaves.
+	imports            map[string]goAMD64FrameSelection
+	origins            map[string]int
+	downloadedOrigin   *gooriginalsrc.OriginSet
+	downloadedModule   *gooriginalsrc.Module
+	downloadedImports  map[string]gooriginalsrc.Module
+	numericalBinding   *GoX86NumericalReadBinding
+	numericalOrigin    *GoAMD64FrameSource
+	numericalSeal      [32]byte
+	numericalPackage   GoPackage
+	numericalCapturing bool
+	numericalCommands  []numericalSBCommand // Actual capture output only; never an authority.
+	sdkFrame           *goAMD64SDKFrameOrigin
+}
+
+// newGoOriginalInputGuard initializes only private input/cleanup ownership.
+// It has no ready object, declaration, source-origin or frame capability.
+func newGoOriginalInputGuard(request GoAMD64FrameCaptureRequest) *GoAMD64FrameSource {
+	request.Environment = append([]string(nil), request.Environment...)
+	source := &GoAMD64FrameSource{request: request,
+		inputs: make(map[string][32]byte), origins: make(map[string]int)}
+	source.identity = source
+	return source
+}
+
+// Transport is an observation role, never a memory or alias permission.
+type goAMD64FrameTransport uint8
+
+const (
+	goAMD64FrameNumericTransport goAMD64FrameTransport = iota + 1
+	goAMD64FrameCompositeTransport
+	goAMD64FrameFloatingScalarTransport
+)
+
+type goAMD64FrameDeclaration struct {
+	signature    FuncSig
+	transport    goAMD64FrameTransport
+	languageType string // go/types model identity, not a native pointee extent
+}
+
+type goAMD64FrameFunction struct {
+	objectSymbol, listingSymbol string
+	sourceSymbol                string
+	privateLeaf                 bool
+	nativeABI                   uint16
+	locals, args                int64
+	split                       bool
+	prologue                    int // original byte offset, after any generated stack check
+	code                        []byte
+	positions                   map[int]string
+	sourcePositions             map[int][]goAMD64FrameSourcePosition
+	signature                   FuncSig
+	transport                   goAMD64FrameTransport
+	languageType                string
+}
+
+func (fn goAMD64FrameFunction) nativeFlags() uint8 {
+	if fn.split {
+		return 0
+	}
+	return 16 // goobj.SymFlagNoSplit, not an assembly-origin flag.
+}
+
+type goAMD64FrameSourcePosition struct {
+	file string
+	line int
+}
+
+// This is decoded only from the actual driver stdout, never from a proof file.
+type goAMD64FrameSelection struct {
+	Dir, ImportPath, Name, Export, ForTest                                                 string
+	GoFiles, CompiledGoFiles, SFiles, HFiles, CgoFiles, Imports, EmbedFiles, EmbedPatterns []string
+	IgnoredGoFiles, IgnoredOtherFiles                                                      []string
+	Standard                                                                               bool
+	ImportMap                                                                              map[string]string
+	CFiles, CXXFiles, MFiles, FFiles, SwigFiles, SwigCXXFiles, SysoFiles                   []string
+	Module                                                                                 *struct {
+		Path, Version, Dir, GoMod, GoVersion string
+		Main                                 bool
+		Replace                              json.RawMessage
+	}
+	Error      json.RawMessage
+	DepsErrors []json.RawMessage
+}
+
+func (selected goAMD64FrameSelection) nonordinaryRole() bool {
+	for _, files := range [][]string{selected.CgoFiles, selected.CFiles, selected.CXXFiles, selected.MFiles,
+		selected.FFiles, selected.SwigFiles, selected.SwigCXXFiles, selected.SysoFiles, selected.EmbedFiles, selected.EmbedPatterns} {
+		if len(files) != 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func CaptureGoAMD64FrameSource(ctx context.Context, pkg GoPackage, request GoAMD64FrameCaptureRequest) (*GoAMD64FrameSource, error) {
+	return captureGoAMD64FrameSource(ctx, pkg, request, nil)
+}
+
+func captureGoAMD64FrameSource(ctx context.Context, pkg GoPackage, request GoAMD64FrameCaptureRequest, exact *goAMD64DownloadedIdentity) (_ *GoAMD64FrameSource, captureErr error) {
+	if ctx != nil && ctx.Err() != nil {
+		if request.NumericalReads != nil {
+			return nil, fmt.Errorf("capture numerical frame context: %w", ctx.Err())
+		}
+		return nil, errors.Join(goAMD64FrameContext("requires live capture context"), ctx.Err())
+	}
+	if ctx == nil || pkg.Types == nil || pkg.Path != pkg.Types.Path() ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || filepath.Ext(request.AssemblyFile) != ".s" {
+		return nil, goAMD64FrameContext("requires live context, actual package and bounded absolute inputs")
+	}
+	parts := strings.Split(request.Target, "/")
+	if len(parts) != 2 || parts[1] != "amd64" || parts[0] != "linux" && parts[0] != "darwin" && parts[0] != "windows" {
+		return nil, goAMD64FrameContext("initial object capture supports ordinary AMD64 targets only")
+	}
+	var err error
+	request.Directory, err = sourcepath.Resolve(request.Directory)
+	if err != nil {
+		return nil, err
+	}
+	source := newGoOriginalInputGuard(request)
+	if request.NumericalReads != nil {
+		if err := verifyGoAMD64FrameNumericalRequest(ctx, pkg, source.request); err != nil {
+			return nil, err
+		}
+		source.numericalBinding = request.NumericalReads
+		source.numericalOrigin = source
+		source.numericalSeal = request.NumericalReads.seal
+		source.numericalPackage = pkg
+		source.numericalCapturing = true
+	}
+	provided := make(map[string]string)
+	for _, value := range request.Environment {
+		key, setting, valid := strings.Cut(value, "=")
+		if !valid || key == "" {
+			return nil, goAMD64FrameContext("malformed command environment")
+		}
+		provided[key] = setting
+		if (key == "GOFLAGS" || key == "GOEXPERIMENT") && setting != "" || key == "GOPACKAGESDRIVER" && setting != "" && setting != "off" {
+			return nil, goAMD64FrameContext("effective overlay, custom flags, experiments or driver require their own source mapping")
+		}
+	}
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(provided[key]) {
+			return nil, goAMD64FrameContext("explicit private %s directory is required", key)
+		}
+	}
+	settings := map[string]string{"GOOS": parts[0], "GOARCH": "amd64", "CGO_ENABLED": "0", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOPROXY": "off"}
+	var env []string
+	for _, value := range source.request.Environment {
+		key, _, _ := strings.Cut(value, "=")
+		if _, replace := settings[key]; !replace {
+			env = append(env, value)
+		}
+	}
+	for key, value := range settings {
+		env = append(env, key+"="+value)
+	}
+	source.request.Environment = env
+	if err := source.snapshotDirectory(); err != nil {
+		return nil, err
+	}
+	if err := source.observe(ctx); err != nil {
+		return nil, err
+	}
+	if exact == nil {
+		if err := source.verifyOwnedSourceDirectory(); err != nil {
+			return nil, err
+		}
+	} else {
+		inside, err := gostaticstorage.SourceDirectoryWithinRoot(request.Directory, source.env["GOROOT"])
+		if err != nil || inside {
+			return nil, errors.Join(goAMD64FrameContext("SDK source cannot acquire an exact downloaded role"), err)
+		}
+		if err := source.captureDownloadedOrigin(ctx, *exact, provided["GOTMPDIR"]); err != nil {
+			return nil, err
+		}
+	}
+	selected, err := source.load(ctx)
+	if err != nil {
+		return nil, err
+	}
+	source.selection = selected
+	if source.numericalBinding != nil && (len(selected.SFiles) != 1 || selected.SFiles[0] != request.AssemblyFile) {
+		return nil, goAMD64FrameContext("numerical frame join requires one complete original assembly selection")
+	}
+	moduleRoot := request.Directory
+	if source.downloadedModule != nil {
+		moduleRoot = source.downloadedModule.Root
+	}
+	mainRole, moduleVersion := true, ""
+	metadata := filepath.Join(moduleRoot, "go.mod")
+	if source.legacyDownloadedModule() {
+		mainRole, moduleVersion = false, source.downloadedModule.SourceVersion
+		metadata = source.downloadedModule.GoMod
+	}
+	if selected.Dir != request.Directory || selected.ImportPath != pkg.Path || selected.ForTest != "" || selected.Module == nil ||
+		selected.Module.Main != mainRole || selected.Module.Version != moduleVersion || selected.Module.Dir != moduleRoot || len(selected.Module.Replace) != 0 && string(selected.Module.Replace) != "null" ||
+		selected.nonordinaryRole() || len(selected.GoFiles) == 0 || len(selected.SFiles) == 0 {
+		return nil, goAMD64FrameContext("capture needs complete ordinary original module sources")
+	}
+	if selected.Module.GoMod != metadata {
+		return nil, goAMD64FrameContext("actual module metadata is outside the original source directory")
+	}
+	if source.downloadedModule != nil {
+		original := source.downloadedModule
+		path, err := goAMD64DownloadedPackagePath(*original, selected.Dir)
+		if err != nil {
+			return nil, err
+		}
+		if selected.Module.Path != original.ModulePath || selected.Module.GoVersion != gooriginalsrc.SelectedGoVersion(original.GoVersion, mainRole) ||
+			selected.ImportPath != path {
+			return nil, goAMD64FrameContext("exact downloaded capture requires its original primary module package")
+		}
+	}
+	source.imports, err = source.loadOriginalDeclarationImports(ctx)
+	if err != nil {
+		return nil, err
+	}
+	source.declarations, err = source.typedDeclarations(pkg, false)
+	if err != nil {
+		return nil, err
+	}
+	rules, err := goasmmacros.Capture(source.env["GOROOT"], source.env["GOVERSION"], selected.ImportPath, source.read)
+	if err != nil || rules.PackageRole != "ordinary_path" && rules.PackageRole != "legacy_no_experiment_macros" {
+		return nil, goAMD64FrameContext("ordinary assembler macro source registration: %v", err)
+	}
+	source.assemblerDefines, err = GoAssemblerDefinesForEnvironment(source.env["GOOS"], source.env["GOARCH"], source.env)
+	if err != nil {
+		return nil, err
+	}
+	source.owned, err = os.MkdirTemp(provided["TMPDIR"], "plan9asm-go-frame-object-")
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if captureErr != nil {
+			captureErr = errors.Join(captureErr, source.Close())
+		}
+	}()
+	source.ownedInfo, err = sourcepath.Lstat(source.owned)
+	if err != nil {
+		return nil, err
+	}
+	canonicalOwned, err := sourcepath.Resolve(source.owned)
+	if err != nil {
+		return nil, err
+	}
+	source.owned = canonicalOwned
+	if err := source.verifyOwned(); err != nil {
+		return nil, err
+	}
+	source.functions = make(map[string]goAMD64FrameFunction)
+	found := false
+	for _, name := range selected.SFiles {
+		found = found || name == request.AssemblyFile
+		original, err := source.read(filepath.Join(request.Directory, name))
+		if err != nil {
+			return nil, err
+		}
+		expanded, err := source.preprocess(name, original)
+		if err != nil {
+			return nil, err
+		}
+		if name != request.AssemblyFile {
+			continue // Preserve sibling inputs/CPP, without acquiring its frame role.
+		}
+		file, err := ParseWithDefines(ArchAMD64, expanded, nil)
+		if err != nil || len(file.Funcs) == 0 || len(file.UnlinkedPrelude) != 0 {
+			return nil, goAMD64FrameContext("full original assembly lacks complete TEXT: %v", err)
+		}
+		source.callees, err = source.ordinaryCallDeclarations(pkg, file)
+		if err != nil {
+			return nil, err
+		}
+		object := filepath.Join(source.owned, name+".o")
+		assemblyInput := name
+		if source.numericalBinding != nil {
+			assemblyInput = filepath.Join(request.Directory, name)
+		}
+		// The independent actual assembler and source preprocessor consume
+		// the same registered ordinary profile macros. Generated headers keep
+		// their separate source mapping; CPU identity grants no memory role.
+		args := []string{"tool", "asm", "-S", "-p", pkg.Path,
+			"-I", request.Directory, "-I", filepath.Join(source.env["GOROOT"], "pkg", "include")}
+		for _, define := range source.assemblerDefines {
+			args = append(args, "-D", define)
+		}
+		args = append(args, "-o", object, assemblyInput)
+		listing, err := source.run(ctx, args...)
+		if err != nil {
+			return nil, err
+		}
+		objectBytes, err := source.read(object)
+		if err != nil || len(objectBytes) == 0 {
+			if err == nil {
+				err = goAMD64FrameContext("actual assembler produced an empty object")
+			}
+			return nil, err
+		}
+		if err := os.WriteFile(object+".listing", listing, 0600); err != nil {
+			return nil, err
+		}
+		if _, err := source.read(object + ".listing"); err != nil {
+			return nil, err
+		}
+		var texts []gostaticstorage.TextRecord
+		if source.numericalBinding != nil {
+			texts, err = source.numericalFrameObject(object, file)
+			if err != nil {
+				return nil, err
+			}
+		}
+		var functions map[string]goAMD64FrameFunction
+		// An ordinary symbolic reference also needs its complete original
+		// relocation inventory, even when this source defines no ASM DATA.
+		if len(file.Data)+len(file.Globl) != 0 || source.numericalBinding == nil && bytes.Contains(listing, []byte("\trel ")) {
+			observed, readErr := source.frameDataObject(expanded, objectBytes)
+			if readErr != nil {
+				return nil, readErr
+			}
+			filtered := listing
+			if len(observed.Layouts) != 0 {
+				filtered, readErr = goAMD64FrameDataListing(listing, observed)
+				if readErr != nil {
+					return nil, readErr
+				}
+			}
+			var unwind *gostaticstorage.WindowsAMD64AssemblyUnwind
+			if source.request.Target == "windows/amd64" {
+				leaves, readErr := goAMD64WindowsSourceLeafTexts(file, pkg, listing, observed.Member.Texts, observed.TextOrder)
+				if readErr != nil {
+					return nil, readErr
+				}
+				value, readErr := source.observeWindowsUnwind(objectBytes, leaves)
+				if readErr != nil {
+					return nil, readErr
+				}
+				unwind = &value
+			}
+			functions, err = goAMD64FrameListingWithDataObject(filtered, file, pkg, source.origins, observed, unwind,
+				source.request.Target, source.request.Directory, "", source.callees)
+			if err == nil {
+				err = goAMD64FrameDataTextJoin(functions, observed, source.request.Directory, source.origins, "")
+			}
+			if err == nil && unwind != nil {
+				err = goAMD64FrameWindowsUnwindFunctions(functions, source.origins, source.request.Directory, *unwind)
+			}
+		} else if source.request.Target == "windows/amd64" && (gotoolchain.AuditedGo127(source.env["GOVERSION"]) ||
+			bytes.Contains(listing, []byte(" SSEHUNWINDINFO "))) {
+			builtin, readErr := source.windowsUnwindBuiltin()
+			if readErr != nil {
+				return nil, readErr
+			}
+			texts, readErr := gostaticstorage.ObserveWindowsAMD64AssemblyText(objectBytes, builtin)
+			if readErr != nil {
+				return nil, readErr
+			}
+			// The shared reader checked the exact FromAssembly object flag.
+			order, readErr := gostaticstorage.ASMSourceTextOrder([]byte(expanded), pkg.Path,
+				gostaticstorage.ASMDataMember{Flags: 4, Texts: texts})
+			if readErr != nil {
+				return nil, readErr
+			}
+			leaves, readErr := goAMD64WindowsSourceLeafTexts(file, pkg, listing, texts, order)
+			if readErr != nil {
+				return nil, readErr
+			}
+			unwind, readErr := source.observeWindowsUnwind(objectBytes, leaves)
+			if readErr != nil {
+				return nil, readErr
+			}
+			functions, err = goAMD64FrameWindowsUnwindListing(listing, file, pkg, source.origins,
+				source.request.Directory, unwind)
+		} else {
+			if source.numericalBinding == nil && goAMD64FrameSplitListing(listing) {
+				observed, readErr := source.frameDataObject(expanded, objectBytes)
+				if readErr != nil {
+					return nil, readErr
+				}
+				functions, err = goAMD64FrameListingWithSplitObject(listing, file, pkg, source.origins,
+					observed.Member.Texts, nil, source.request.Target, source.request.Directory, "")
+				if err == nil {
+					err = goAMD64FrameDataTextJoin(functions, observed, source.request.Directory, source.origins, "")
+				}
+			} else {
+				functions, err = goAMD64FrameListingWithNumericalObject(listing, file, pkg, source.origins, texts)
+			}
+		}
+		if err != nil {
+			return nil, err
+		}
+		if source.numericalBinding != nil && !bytes.Equal(listing, source.numericalBinding.source.native.OriginalListing) {
+			return nil, goAMD64FrameContext("independent complete original numerical/frame listing differs")
+		}
+		for _, text := range texts {
+			if !bytes.Equal(functions[text.Name].code, text.Code) {
+				return nil, goAMD64FrameContext("independent complete object/listing code bytes differ")
+			}
+		}
+		if err := source.verifyObjectListing(ctx, object, functions); err != nil {
+			return nil, err
+		}
+		for symbol, fn := range functions {
+			if _, duplicate := source.functions[symbol]; duplicate {
+				return nil, goAMD64FrameContext("duplicate original TEXT symbol")
+			}
+			declaration, exists := source.declarations[symbol]
+			if fn.privateLeaf {
+				if exists {
+					return nil, goAMD64FrameContext("private leaf acquired a Go declaration")
+				}
+			} else if !exists || !reflect.DeepEqual(fn.signature, declaration.signature) {
+				return nil, goAMD64FrameContext("object lacks its independently checked declaration/layout")
+			}
+			fn.transport, fn.languageType = declaration.transport, declaration.languageType
+			source.functions[symbol] = fn
+		}
+	}
+	if !found {
+		return nil, goAMD64FrameContext("requested assembly is absent from actual complete selection")
+	}
+	withFrame := false
+	for _, fn := range source.functions {
+		withFrame = withFrame || fn.locals > 0
+	}
+	if !withFrame {
+		return nil, goAMD64FrameContext("complete source has no nonzero native frame")
+	}
+	source.ready = true
+	source.numericalCapturing = false
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+// Verify rechecks actual routing/selection and all original/tool/export/artifact
+// bytes. Failure permanently revokes this observation; it grants no memory.
+func (source *GoAMD64FrameSource) Verify(ctx context.Context) (verifyErr error) {
+	if source == nil || source.identity != source {
+		return goAMD64FrameContext("missing sealed actual-object observation")
+	}
+	if source.sdkFrame != nil {
+		return source.verifySDKFrame(ctx)
+	}
+	if err := source.verifyNumericalFrameInputs(ctx); err != nil {
+		source.revokeNumericalFrame()
+		return err
+	}
+	defer func() {
+		if err := source.verifyNumericalFrameInputs(ctx); err != nil {
+			source.revokeNumericalFrame()
+			// The inner observer already revokes on failure. Its own closed
+			// generation must not relabel an actual command/cancellation
+			// failure as a source exclusion during the outer postcheck.
+			if verifyErr == nil || !errors.Is(err, ErrProbeNeedsContext) {
+				verifyErr = errors.Join(verifyErr, err)
+			}
+		}
+	}()
+	return source.verifyFrameOnly(ctx)
+}
+
+func (source *GoAMD64FrameSource) verifyFrameOnly(ctx context.Context) (verifyErr error) {
+	if source == nil {
+		return goAMD64FrameContext("missing sealed actual-object observation")
+	}
+	private, contextErr := captureGoAMD64FramePrivateContext(ctx)
+	if contextErr != nil {
+		source.mu.Lock()
+		source.ready = false
+		source.mu.Unlock()
+		if source.numericalOrigin != nil {
+			return fmt.Errorf("verify numerical frame observer context: %w", contextErr)
+		}
+		return errors.Join(goAMD64FrameContext("expired actual-object observation"), contextErr)
+	}
+	defer private.stop()
+	defer func() {
+		// Run every caller callback after the locked command/input round.
+		// A callback may Close or change original inputs; no authority may
+		// survive that final boundary even if its Err method returns nil.
+		contextErr := private.verify()
+		source.mu.Lock()
+		defer source.mu.Unlock()
+		if contextErr != nil {
+			if source.numericalOrigin != nil {
+				verifyErr = errors.Join(verifyErr, fmt.Errorf("numerical frame caller context expired after actual commands: %w", contextErr))
+			} else {
+				verifyErr = errors.Join(verifyErr, goAMD64FrameContext("caller context expired after actual commands"), contextErr)
+			}
+		}
+		if !source.ready && verifyErr == nil {
+			verifyErr = goAMD64FrameContext("source closed during caller context callbacks")
+		}
+		if verifyErr == nil {
+			verifyErr = errors.Join(source.verifyInputs(), source.verifyDownloadedOrigin())
+		}
+		if verifyErr != nil {
+			source.ready = false
+		}
+	}()
+	ctx = private
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	defer func() {
+		if verifyErr != nil {
+			source.ready = false
+		}
+	}()
+	if ctx != nil && ctx.Err() != nil {
+		if source.numericalOrigin != nil {
+			return fmt.Errorf("verify numerical frame observer context: %w", ctx.Err())
+		}
+		return errors.Join(goAMD64FrameContext("expired actual-object observation"), ctx.Err())
+	}
+	if !source.ready || ctx == nil {
+		return goAMD64FrameContext("closed, uninitialized or expired actual-object observation")
+	}
+	if err := source.verifyDownloadedOrigin(); err != nil {
+		return err
+	}
+	before := source.env
+	if err := source.observe(ctx); err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(before, source.env) {
+		return goAMD64FrameContext("actual Go environment changed")
+	}
+	if source.downloadedOrigin == nil {
+		if err := source.verifyOwnedSourceDirectory(); err != nil {
+			return err
+		}
+	}
+	if err := source.verifyInputs(); err != nil {
+		return err
+	}
+	selected, err := source.load(ctx)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(source.selection, selected) {
+		return goAMD64FrameContext("actual complete package selection/export changed")
+	}
+	imports, err := source.loadOriginalDeclarationImports(ctx)
+	if err != nil && source.numericalOrigin != nil {
+		return err
+	}
+	if err != nil || !reflect.DeepEqual(source.imports, imports) {
+		return goAMD64FrameContext("actual complete declaration import graph changed: %v", err)
+	}
+	if err := ctx.Err(); err != nil {
+		if source.numericalOrigin != nil {
+			return fmt.Errorf("numerical frame verification context expired after actual commands: %w", err)
+		}
+		return errors.Join(goAMD64FrameContext("verification context expired after actual commands"), err)
+	}
+	// The final complete input/origin check follows caller callbacks in the
+	// outer deferred boundary; do not repeat a whole-map read before it.
+	return nil
+}
+
+func (source *GoAMD64FrameSource) verifyOwnedSourceDirectory() error {
+	if err := gostaticstorage.ValidateOwnedSourceDirectory(source.request.Directory, source.env["GOROOT"], source.env["GOMODCACHE"]); err != nil {
+		return errors.Join(goAMD64FrameContext("owned source needs a distinct physical SDK/cache role"), err)
+	}
+	return nil
+}
+
+func (source *GoAMD64FrameSource) verifyInputs() error {
+	if err := source.verifyOwned(); err != nil {
+		return err
+	}
+	maximum := 256 // Ordinary owned-main retains its original member bound.
+	for name, original := range source.childDirectories {
+		info, err := os.Lstat(name)
+		if err != nil || !info.IsDir() || !os.SameFile(original, info) {
+			return goAMD64FrameContext("original child directory identity changed")
+		}
+	}
+	if inventory := source.directoryInventory; inventory != nil {
+		if err := inventory.Verify(); err != nil {
+			return goAMD64FrameContext("complete SDK directory membership changed: %v", err)
+		}
+		view := inventory.View()
+		original := view.Directories[source.request.Directory]
+		if original == nil || source.directoryInfo == nil || !os.SameFile(original, source.directoryInfo) ||
+			len(view.Entries[source.request.Directory]) != len(source.entries) {
+			return goAMD64FrameContext("complete SDK directory inventory lost its original role")
+		}
+		maximum = len(view.Entries[source.request.Directory])
+	}
+	entries, directoryInfo, err := gooriginalsrc.ReadDirectory(source.request.Directory, maximum)
+	if err != nil || source.directoryInfo == nil || !os.SameFile(source.directoryInfo, directoryInfo) {
+		return goAMD64FrameContext("original package directory inventory or identity changed: %v", err)
+	}
+	var names []string
+	for _, entry := range entries {
+		names = append(names, entry.Name())
+	}
+	if !reflect.DeepEqual(names, source.entries) {
+		return goAMD64FrameContext("original package directory inventory changed")
+	}
+	for name, expected := range source.inputs {
+		digest, err := gooriginalsrc.HashRegularFile(name, 64<<20)
+		if err != nil || digest != expected {
+			return goAMD64FrameContext("original/tool/export/object input changed: %s: %v", filepath.Base(name), err)
+		}
+	}
+	return nil
+}
+
+func (source *GoAMD64FrameSource) verifyOwned() error {
+	info, err := os.Lstat(source.owned)
+	if err != nil || source.ownedInfo == nil || !info.IsDir() || !os.SameFile(source.ownedInfo, info) {
+		return goAMD64FrameContext("factory artifact directory identity changed or is inaccessible: %v", err)
+	}
+	return nil
+}
+
+// Close invalidates the token before removing only its factory-owned artifacts.
+// Calling it again is harmless; no source, tool or cache-owned file is removed.
+func (source *GoAMD64FrameSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	if source.identity != source {
+		return goAMD64FrameContext("copied or uninitialized observation cannot dispose original artifacts")
+	}
+	if source.sdkFrame != nil {
+		return source.closeSDKFrame()
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	source.ready = false
+	if source.numericalOrigin != nil && source.numericalOrigin != source {
+		return goAMD64FrameContext("copied numerical frame cannot close the original artifact owner")
+	}
+	if source.owned == "" {
+		return nil
+	}
+	if err := source.verifyOwned(); err != nil {
+		return err
+	}
+	err := os.RemoveAll(source.owned)
+	if err == nil {
+		source.owned = ""
+		source.ownedInfo = nil
+	}
+	return err
+}
+
+func goAMD64FrameContext(format string, args ...any) error {
+	return fmt.Errorf("%w: actual Go frame source: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func (source *GoAMD64FrameSource) run(ctx context.Context, args ...string) ([]byte, error) {
+	if ctx == nil {
+		return nil, goAMD64FrameContext("actual command requires live context")
+	}
+	if err := ctx.Err(); err != nil {
+		if source.numericalOrigin != nil {
+			return nil, fmt.Errorf("numerical frame actual command context expired: %w", err)
+		}
+		return nil, errors.Join(goAMD64FrameContext("actual command context expired"), err)
+	}
+	if err := source.verifyDownloadedOrigin(); err != nil {
+		return nil, err
+	}
+	// Capture has not published the source and holds no Frame lock. Verify's
+	// existing locked command path is guarded outside the entire round instead.
+	if source.numericalCapturing {
+		if err := source.numericalBinding.verify(); err != nil {
+			return nil, err
+		}
+	}
+	ctx, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	var output []byte
+	var err error
+	if source.legacyDownloadedModule() && len(args) > 0 && args[0] == "list" {
+		output, err = source.runDownloadedList(ctx, args)
+	} else {
+		output, err = goasmcmd.Run(ctx, source.request.Directory, source.request.Environment, source.request.GoBinary, args...)
+	}
+	if source.numericalCapturing {
+		source.numericalCommands = append(source.numericalCommands, numericalSBCommand{
+			Directory: source.request.Directory, Binary: source.request.GoBinary,
+			Arguments: append([]string(nil), args...), Stdout: append([]byte(nil), output...),
+		})
+		err = errors.Join(err, source.numericalBinding.verify())
+	}
+	// Preserve both independent origins and cancellation when commands race
+	// revocation. Neither observation grants the other's source permission.
+	return output, errors.Join(err, ctx.Err(), source.verifyDownloadedOrigin())
+}
+
+func goAMD64FrameRead(name string) (_ []byte, readErr error) {
+	return goAMD64FrameReadBound(name, 64<<20)
+}
+
+func goAMD64FrameReadBound(name string, maximum int64) (_ []byte, readErr error) {
+	resolved, err := sourcepath.Resolve(name)
+	if err != nil || resolved != name {
+		return nil, goAMD64FrameContext("input path is redirected or inaccessible: %s", filepath.Base(name))
+	}
+	before, err := os.Lstat(name)
+	if err != nil || !before.Mode().IsRegular() {
+		return nil, goAMD64FrameContext("input role changed before opening")
+	}
+	file, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { readErr = errors.Join(readErr, file.Close()) }()
+	info, err := file.Stat()
+	if err != nil || !info.Mode().IsRegular() || !os.SameFile(before, info) || maximum < 0 || maximum > 64<<20 || info.Size() > maximum {
+		return nil, goAMD64FrameContext("input is not a bounded regular file")
+	}
+	data, err := io.ReadAll(io.LimitReader(file, maximum+1))
+	if err != nil || int64(len(data)) > maximum {
+		return nil, goAMD64FrameContext("input byte bound/read failure: %v", err)
+	}
+	after, err := os.Lstat(name)
+	if err != nil || !os.SameFile(info, after) || !after.Mode().IsRegular() || int64(len(data)) != info.Size() {
+		afterSize, sameFile, regular := int64(-1), false, false
+		if err == nil {
+			afterSize, sameFile, regular = after.Size(), os.SameFile(info, after), after.Mode().IsRegular()
+		}
+		return nil, goAMD64FrameContext("input role/extent changed while reading %q: opened=%d read=%d after=%d same_file=%t regular=%t after_stat=%v",
+			filepath.Base(name), info.Size(), len(data), afterSize, sameFile, regular, err)
+	}
+	return data, nil
+}
+
+func (source *GoAMD64FrameSource) read(name string) ([]byte, error) {
+	return source.readBound(name, 64<<20)
+}
+
+func (source *GoAMD64FrameSource) readBound(name string, maximum int64) ([]byte, error) {
+	data, err := goAMD64FrameReadBound(name, maximum)
+	if err != nil {
+		return nil, err
+	}
+	digest := sha256.Sum256(data)
+	if before, exists := source.inputs[name]; exists && before != digest {
+		return nil, goAMD64FrameContext("input changed during capture: %s", filepath.Base(name))
+	}
+	source.inputs[name] = digest
+	return data, nil
+}
+
+func (source *GoAMD64FrameSource) snapshotDirectory() error {
+	resolved, err := sourcepath.Resolve(source.request.Directory)
+	if err != nil || resolved != source.request.Directory {
+		return goAMD64FrameContext("requires canonical actual package directory")
+	}
+	entries, directoryInfo, err := gooriginalsrc.ReadDirectory(resolved, 256)
+	if err != nil || len(entries) == 0 || len(entries) > 256 {
+		return goAMD64FrameContext("package directory is unavailable or exceeds its bound")
+	}
+	source.directoryInfo = directoryInfo
+	source.childDirectories = make(map[string]os.FileInfo)
+	var total int
+	for _, entry := range entries {
+		source.entries = append(source.entries, entry.Name())
+		if entry.IsDir() {
+			info, err := entry.Info()
+			if err != nil || !info.IsDir() {
+				return goAMD64FrameContext("original child directory role changed during capture")
+			}
+			// Child contents belong to separately selected packages/includes.
+			// Retain identity without recursively reading unrelated testdata.
+			source.childDirectories[filepath.Join(resolved, entry.Name())] = info
+			continue
+		}
+		data, err := source.read(filepath.Join(resolved, entry.Name()))
+		if err != nil {
+			return err
+		}
+		total += len(data)
+		if total > 16<<20 {
+			return goAMD64FrameContext("original package byte inventory exceeds its bound")
+		}
+	}
+	return nil
+}
+
+func (source *GoAMD64FrameSource) observe(ctx context.Context) error {
+	if _, err := source.read(source.request.GoBinary); err != nil {
+		return err
+	}
+	data, err := source.run(ctx, "env", "-json", "GOROOT", "GOTOOLDIR", "GOCACHE", "GOMODCACHE", "GOPATH", "GOTMPDIR", "GOVERSION", "GOOS", "GOARCH", "GOFLAGS", "GOEXPERIMENT", "GOAMD64")
+	if err != nil {
+		return err
+	}
+	var env map[string]string
+	if err := json.Unmarshal(data, &env); err != nil {
+		return err
+	}
+	// Commands must keep their observed SDK spelling: changing it can rebuild
+	// builtin tools with different bytes. File reads and driver ownership use
+	// the independently resolved physical SDK. Verify compares both identities.
+	root, err := sourcepath.Resolve(env["GOROOT"])
+	if err != nil || !filepath.IsAbs(env["GOROOT"]) {
+		return goAMD64FrameContext("actual SDK root is not an accessible absolute directory: %v", err)
+	}
+	env["command/GOROOT"], env["GOROOT"] = env["GOROOT"], root
+	if env["GOOS"]+"/"+env["GOARCH"] != source.request.Target || env["GOFLAGS"] != "" || env["GOEXPERIMENT"] != "" ||
+		filepath.Join(env["GOROOT"], "bin", gotoolchain.HostExecutable("go")) != source.request.GoBinary {
+		return goAMD64FrameContext("actual driver/target/CPU/source routing needs a separate audited contract")
+	}
+	switch env["GOAMD64"] {
+	case "v1", "v2", "v3", "v4":
+		// Each actual profile retains its own selected original Go sources,
+		// exports and object bytes. Verify compares this environment exactly;
+		// no capture is relabeled or reused across different CPU profiles.
+	default:
+		return goAMD64FrameContext("unregistered actual GOAMD64 profile %q", env["GOAMD64"])
+	}
+	version, err := source.read(filepath.Join(env["GOROOT"], "VERSION"))
+	if err != nil || strings.Split(string(version), "\n")[0] != env["GOVERSION"] {
+		return goAMD64FrameContext("actual driver differs from source VERSION")
+	}
+	for _, tool := range []string{"asm", "compile", "objdump"} {
+		executable := gotoolchain.HostExecutable(tool)
+		data, err := source.run(ctx, "tool", "-n", tool)
+		if err != nil {
+			return err
+		}
+		name := strings.TrimSpace(string(data))
+		if !filepath.IsAbs(name) || strings.ContainsAny(name, "\r\n") || tool != "objdump" && name != filepath.Join(env["GOTOOLDIR"], executable) {
+			return goAMD64FrameContext("unrecognized actual %s route", tool)
+		}
+		resolved, err := sourcepath.Resolve(name)
+		if err != nil {
+			return err
+		}
+		if tool == "objdump" && name != filepath.Join(env["GOTOOLDIR"], executable) {
+			cache, err := sourcepath.Resolve(env["GOCACHE"])
+			if err != nil || !goAssemblyPathWithinRoot(cache, resolved) || filepath.Base(resolved) != executable {
+				return goAMD64FrameContext("unknown builtin object observer origin")
+			}
+		}
+		name = resolved
+		env["route/"+tool] = name
+		if _, err := source.read(name); err != nil {
+			return err
+		}
+	}
+	for _, name := range []string{"src/cmd/internal/obj/x86/obj6.go", "src/cmd/internal/obj/x86/asm6.go", "src/cmd/go/internal/work/gc.go", "src/cmd/asm/main.go", "src/cmd/go/internal/tool/tool.go", "src/cmd/internal/objabi/stack.go"} {
+		if _, err := source.read(filepath.Join(env["GOROOT"], filepath.FromSlash(name))); err != nil {
+			return err
+		}
+	}
+	source.env = env
+	return nil
+}
+
+func (source *GoAMD64FrameSource) load(ctx context.Context) (goAMD64FrameSelection, error) {
+	selected, _, err := source.loadWithRaw(ctx)
+	return selected, err
+}
+
+func (source *GoAMD64FrameSource) loadWithRaw(ctx context.Context) (goAMD64FrameSelection, []byte, error) {
+	return source.loadWithRawPackage(ctx, ".")
+}
+
+func (source *GoAMD64FrameSource) loadWithRawPackage(ctx context.Context, packageQuery string) (goAMD64FrameSelection, []byte, error) {
+	data, err := source.run(ctx, "list", "-json", "-compiled", "-export", "-mod=readonly", packageQuery)
+	if err != nil {
+		return goAMD64FrameSelection{}, data, err
+	}
+	return source.readRawPackageSelection(data)
+}
+
+// Both root-only and dependency queries retain the same complete root record
+// and physical export read. This does not authenticate a caller-supplied JSON.
+func (source *GoAMD64FrameSource) readRawPackageSelection(data []byte) (goAMD64FrameSelection, []byte, error) {
+	var selected goAMD64FrameSelection
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	if err := decoder.Decode(&selected); err != nil {
+		return selected, data, err
+	}
+	var extra any
+	if decoder.Decode(&extra) != io.EOF || len(selected.Error) != 0 || len(selected.DepsErrors) != 0 {
+		return selected, data, goAMD64FrameContext("incomplete or ambiguous actual package export")
+	}
+	if selected.Export == "" {
+		return selected, data, goAMD64FrameContext("actual package has no compiled export")
+	}
+	export, err := sourcepath.Resolve(selected.Export)
+	selected.Export = export
+	cache, cacheErr := sourcepath.Resolve(source.env["GOCACHE"])
+	if err != nil || cacheErr != nil || !goAssemblyPathWithinRoot(cache, selected.Export) {
+		return selected, data, goAMD64FrameContext("compiled export is outside the actual build cache")
+	}
+	if export, err := source.read(selected.Export); err != nil || len(export) == 0 {
+		if err == nil {
+			err = goAMD64FrameContext("actual package export is empty")
+		}
+		return selected, data, err
+	}
+	return selected, data, nil
+}
+
+func (source *GoAMD64FrameSource) numericDeclarations(pkg GoPackage) error {
+	_, err := source.typedDeclarations(pkg, true)
+	return err
+}
+
+// The numeric-only query remains strict. The fixed-local binder separately
+// checks the closed transport role and replays each actual typed component;
+// observation itself never supplies local or incoming memory permission.
+func (source *GoAMD64FrameSource) typedDeclarations(pkg GoPackage, numericOnly bool) (map[string]goAMD64FrameDeclaration, error) {
+	return source.typedDeclarationsForArch(pkg, numericOnly, "amd64")
+}
+
+// The numerical SB binding also observes 386 declarations. This helper only
+// rechecks language/ABI0 identity; it does not extend the AMD64 frame factory.
+func (source *GoAMD64FrameSource) typedDeclarationsForArch(pkg GoPackage, numericOnly bool, arch string) (map[string]goAMD64FrameDeclaration, error) {
+	return source.typedDeclarationsForArchRole(pkg, numericOnly, arch, false, nil)
+}
+
+func (source *GoAMD64FrameSource) typedDeclarationsForArchRole(pkg GoPackage, numericOnly bool, arch string,
+	opaqueUnsafePointer bool, entries map[string]bool,
+) (map[string]goAMD64FrameDeclaration, error) {
+	return source.typedDeclarationsForSourceRole(pkg, numericOnly, arch, opaqueUnsafePointer, entries, false)
+}
+
+// Numerical-source binding observes ordinary F32/F64 declaration identity and
+// ABI0 slots, not the frame factory's integer transport. This separate route
+// supplies no physical frame, caller, register-entry or numerical input facts.
+func (source *GoAMD64FrameSource) typedNumericalDeclarationsForArchRole(pkg GoPackage, arch string,
+	opaqueUnsafePointer bool, entries map[string]bool,
+) (map[string]goAMD64FrameDeclaration, error) {
+	return source.typedDeclarationsForSourceRole(pkg, false, arch, opaqueUnsafePointer, entries, true)
+}
+
+func (source *GoAMD64FrameSource) typedDeclarationsForSourceRole(pkg GoPackage, numericOnly bool, arch string,
+	opaqueUnsafePointer bool, entries map[string]bool, floatingScalars bool, globals ...map[string]goReadOnlyObject,
+) (map[string]goAMD64FrameDeclaration, error) {
+	return source.typedSourceDeclarations(pkg, numericOnly, arch, opaqueUnsafePointer, entries, floatingScalars, false, globals...)
+}
+
+func (source *GoAMD64FrameSource) typedSourceDeclarations(pkg GoPackage, numericOnly bool, arch string,
+	opaqueUnsafePointer bool, entries map[string]bool, floatingScalars, bodies bool, globals ...map[string]goReadOnlyObject,
+) (map[string]goAMD64FrameDeclaration, error) {
+	if len(globals) > 1 {
+		return nil, goAMD64FrameContext("ambiguous original Go variable inventory")
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	var compiled []string
+	bodyless := make(map[string]bool)
+	var implemented map[string]bool
+	if bodies {
+		implemented = make(map[string]bool)
+	}
+	for _, name := range source.selection.GoFiles {
+		filename := filepath.Join(source.request.Directory, name)
+		data, err := source.read(filename)
+		if err != nil {
+			return nil, err
+		}
+		file, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		for _, declaration := range file.Decls {
+			switch declaration := declaration.(type) {
+			case *ast.FuncDecl:
+				if declaration.Body == nil && declaration.Recv == nil {
+					bodyless[declaration.Name.Name] = true
+				}
+				if bodies && declaration.Body != nil && declaration.Recv == nil {
+					implemented[declaration.Name.Name] = true
+				}
+			case *ast.GenDecl:
+				if declaration.Tok != token.TYPE && declaration.Tok != token.IMPORT &&
+					declaration.Tok != token.CONST && declaration.Tok != token.VAR {
+					return nil, goAMD64FrameContext("unknown original declaration role")
+				}
+			default:
+				return nil, goAMD64FrameContext("unknown original declaration role")
+			}
+		}
+		syntax = append(syntax, file)
+		compiled = append(compiled, filename)
+	}
+	if len(pkg.Syntax) != len(syntax) {
+		return nil, goAMD64FrameContext("supplied syntax omitted complete ordinary source files")
+	}
+	if len(bodyless) == 0 {
+		return nil, goAMD64FrameContext("original source has no bodyless assembly declaration")
+	}
+	sort.Strings(compiled)
+	actual := append([]string(nil), source.selection.CompiledGoFiles...)
+	for i, name := range actual {
+		if !filepath.IsAbs(name) {
+			actual[i] = filepath.Join(source.request.Directory, name)
+		}
+	}
+	sort.Strings(actual)
+	if !reflect.DeepEqual(compiled, actual) {
+		return nil, goAMD64FrameContext("effective/generated compiled source mapping is unbound")
+	}
+	sizes := types.SizesFor("gc", arch)
+	actualImporter := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if target, mapped := source.selection.ImportMap[path]; mapped {
+			path = target
+		}
+		dependency, present := source.imports[path]
+		if !present || dependency.Export == "" {
+			return nil, goAMD64FrameContext("missing captured actual compiler export: %s", path)
+		}
+		data, err := source.read(dependency.Export)
+		if err != nil {
+			return nil, err
+		}
+		return io.NopCloser(bytes.NewReader(data)), nil
+	})
+	config := &types.Config{Sizes: sizes, Importer: actualImporter}
+	if source.legacyDownloadedModule() {
+		config.GoVersion = "go1.16"
+	}
+	typed, err := config.Check(pkg.Path, fset, syntax, nil)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(typed.Scope().Names(), pkg.Types.Scope().Names()) {
+		return nil, goAMD64FrameContext("actual selected declarations differ from supplied types")
+	}
+	if bodies {
+		names, err := numericalGoDeclarationLinknames(syntax, typed)
+		if err != nil {
+			return nil, err
+		}
+		for name := range entries {
+			if _, linked := names.localToNative[name]; linked {
+				return nil, goAMD64FrameContext("ordinary Go CALL requires its original unaliased implementation")
+			}
+		}
+	}
+	if len(globals) == 1 {
+		if err := joinFixedLocalGlobalDeclarations(typed, pkg.Types, syntax, sizes, globals[0]); err != nil {
+			return nil, err
+		}
+	}
+	languageType := goAMD64FrameLanguageTypeRole
+	if floatingScalars {
+		languageType = goAMD64NumericalScalarLanguageType
+	}
+	declarations := make(map[string]goAMD64FrameDeclaration)
+	for _, name := range typed.Scope().Names() {
+		if named, ok := typed.Scope().Lookup(name).(*types.TypeName); ok {
+			previous, supplied := pkg.Types.Scope().Lookup(name).(*types.TypeName)
+			if !supplied || named.IsAlias() != previous.IsAlias() {
+				return nil, goAMD64FrameContext("actual local type declaration differs: %s", name)
+			}
+			// The complete original Go program has already been typechecked.
+			// Unrelated interfaces, callbacks, maps or recursive/generic types
+			// do not cross an assembly ABI and must not enter its restricted
+			// transport grammar. Every type reachable from an actual assembly
+			// parameter/result is independently compared in full below.
+			continue
+		}
+		// The default table contains only bodyless assembly declarations.
+		// A requested Go-body table is independently typed and kept separate.
+		if !bodies && !bodyless[name] || bodies && !implemented[name] {
+			continue
+		}
+		if entries != nil && !entries[name] {
+			// All original sources, bodies, declarations and complete scope
+			// names were independently checked above. An unrelated bodyless
+			// runtime declaration does not enter this selected ASM entry set.
+			continue
+		}
+		fn, ok := typed.Scope().Lookup(name).(*types.Func)
+		previous, supplied := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok || !supplied {
+			return nil, goAMD64FrameContext("missing actual typed declaration")
+		}
+		signature := fn.Type().(*types.Signature)
+		priorSignature, valid := previous.Type().(*types.Signature)
+		if !valid || priorSignature == nil || signature.Recv() != nil || signature.Variadic() || signature.TypeParams().Len() != 0 ||
+			priorSignature.Recv() != nil || priorSignature.Variadic() || priorSignature.TypeParams().Len() != 0 {
+			return nil, goAMD64FrameContext("custom, generic or variadic declaration transport")
+		}
+		role := goAMD64FrameNumericTransport
+		var language strings.Builder
+		for _, tuple := range []*types.Tuple{signature.Params(), signature.Results()} {
+			if tuple.Len() > 4096 {
+				return nil, goAMD64FrameContext("declaration tuple bound")
+			}
+			language.WriteString("[")
+			for i := 0; i < tuple.Len(); i++ {
+				typ := tuple.At(i).Type()
+				switch underlying := typ.Underlying().(type) {
+				case *types.Basic:
+					if floatingScalars && goAMD64NumericalFloatingScalar(typ) {
+						if role == goAMD64FrameNumericTransport {
+							role = goAMD64FrameFloatingScalarTransport
+						}
+					} else if underlying.Kind() == types.Bool || opaqueUnsafePointer && underlying.Kind() == types.UnsafePointer {
+						role = goAMD64FrameCompositeTransport
+					} else if underlying.Info()&types.IsInteger == 0 {
+						return nil, goAMD64FrameContext("observation excludes noninteger scalar transport")
+					}
+				case *types.Pointer, *types.Slice:
+					role = goAMD64FrameCompositeTransport
+				default:
+					return nil, goAMD64FrameContext("by-value aggregate transport needs a separate observation contract")
+				}
+				identity, err := languageType(typ, sizes, opaqueUnsafePointer)
+				if err != nil {
+					return nil, err
+				}
+				fmt.Fprintf(&language, "%q:%s;", tuple.At(i).Name(), identity)
+				if language.Len() > 64<<10 {
+					return nil, goAMD64FrameContext("declaration language byte bound")
+				}
+			}
+			language.WriteString("]")
+		}
+		if numericOnly && role != goAMD64FrameNumericTransport {
+			return nil, goAMD64FrameContext("fixed-local consumer requires numeric transport, not pointer/slice observation")
+		}
+		// Named types from two independent typechecks have different object
+		// identities. Compare their complete language/layout trees, not Ptr or
+		// qualified spelling alone; underlying and pointee changes must fail.
+		priorLanguage := strings.Builder{}
+		for _, tuple := range []*types.Tuple{priorSignature.Params(), priorSignature.Results()} {
+			if tuple.Len() > 4096 {
+				return nil, goAMD64FrameContext("supplied declaration tuple bound")
+			}
+			priorLanguage.WriteString("[")
+			for i := 0; i < tuple.Len(); i++ {
+				identity, err := languageType(tuple.At(i).Type(), sizes, opaqueUnsafePointer)
+				if err != nil {
+					return nil, err
+				}
+				fmt.Fprintf(&priorLanguage, "%q:%s;", tuple.At(i).Name(), identity)
+				if priorLanguage.Len() > 64<<10 {
+					return nil, goAMD64FrameContext("supplied declaration language byte bound")
+				}
+			}
+			priorLanguage.WriteString("]")
+		}
+		if language.String() != priorLanguage.String() {
+			return nil, goAMD64FrameContext("actual language type/pointee/field identity mismatch: %s", name)
+		}
+		actual, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, fn, arch, sizes)
+		prior, priorErr := DeriveGoFuncABI0Signature(pkg.Path+"."+name, previous, arch, sizes)
+		if err != nil || priorErr != nil || !reflect.DeepEqual(actual, prior) {
+			return nil, goAMD64FrameContext("actual typed declaration/layout mismatch: %s", name)
+		}
+		declarations[actual.Name] = goAMD64FrameDeclaration{signature: actual, transport: role, languageType: language.String()}
+	}
+	if entries != nil && len(declarations) != len(entries) {
+		if bodies {
+			return nil, goAMD64FrameContext("original CALL needs its complete same-source leaf or selected Go body")
+		}
+		return nil, goAMD64FrameContext("complete selected ASM entry declaration inventory differs")
+	}
+	return declarations, nil
+}
+
+// A bounded semantic language tree distinguishes equal-sized LLVM pointers,
+// named-underlying changes and aggregate element/field models. Sizes belongs
+// to the independent go/types model, not an observation of native pointee
+// padding (Go1.20 StdSizes differs from its compiler). Only pointer/slice ABI0
+// slots are bound to the actual object. No pointee extent, alias or GC grant.
+func goAMD64FrameLanguageType(typ types.Type, sizes types.Sizes) (string, error) {
+	return goAMD64FrameLanguageTypeRole(typ, sizes, false)
+}
+
+// The SDK numerical declaration observer may retain an unsafe.Pointer only as
+// an opaque language identity. The ordinary frame observer remains strict;
+// no pointee, extent, numerical bytes, GC or physical frame follows from it.
+func goAMD64FrameLanguageTypeRole(typ types.Type, sizes types.Sizes, opaqueUnsafePointer bool) (string, error) {
+	return goAMD64LanguageTypeRole(typ, sizes, opaqueUnsafePointer, false)
+}
+
+func goAMD64NumericalFloatingScalar(typ types.Type) bool {
+	for depth := 0; depth <= 32 && typ != nil; depth++ {
+		switch concrete := typ.(type) {
+		case *types.Basic:
+			return concrete.Kind() == types.Float32 || concrete.Kind() == types.Float64
+		case *types.Named:
+			if concrete.TypeParams().Len() != 0 {
+				return false
+			}
+			typ = concrete.Underlying()
+		default:
+			if !goAMD64FrameIsAlias(typ) {
+				return false // Never sample caller-defined types.Type callbacks.
+			}
+			rhs := reflect.ValueOf(typ).MethodByName("Rhs")
+			if !rhs.IsValid() || rhs.Type().NumIn() != 0 || rhs.Type().NumOut() != 1 {
+				return false
+			}
+			var valid bool
+			typ, valid = rhs.Call(nil)[0].Interface().(types.Type)
+			if !valid {
+				return false
+			}
+		}
+	}
+	return false
+}
+
+// Only a top-level scalar (including its named/alias identity) selects this
+// language role. Pointers, slices and aggregates keep the ordinary recursive
+// restrictions; this cannot borrow the broader ABIInternal argument grammar.
+func goAMD64NumericalScalarLanguageType(typ types.Type, sizes types.Sizes, opaqueUnsafePointer bool) (string, error) {
+	return goAMD64LanguageTypeForSourceRole(typ, sizes, opaqueUnsafePointer, false, goAMD64NumericalFloatingScalar(typ))
+}
+
+// The SDK argument role compares language identities only. It never grants
+// the ordinary frame observer floating/string storage or a pointee extent.
+func goAMD64LanguageTypeRole(typ types.Type, sizes types.Sizes, opaqueUnsafePointer, argumentCarriers bool) (string, error) {
+	return goAMD64LanguageTypeForSourceRole(typ, sizes, opaqueUnsafePointer, argumentCarriers, false)
+}
+
+func goAMD64LanguageTypeForSourceRole(typ types.Type, sizes types.Sizes, opaqueUnsafePointer, argumentCarriers, floatingScalar bool) (string, error) {
+	if sizes == nil {
+		return "", goAMD64FrameContext("missing target language layout")
+	}
+	var output strings.Builder
+	active := make(map[types.Type]bool)
+	nodes := 0
+	var appendType func(types.Type, int) error
+	appendType = func(typ types.Type, depth int) error {
+		nodes++
+		if typ == nil || depth > 32 || nodes > 4096 || active[typ] || output.Len() > 64<<10 {
+			return goAMD64FrameContext("recursive or unbounded language type")
+		}
+		active[typ] = true
+		defer delete(active, typ)
+		// Check the language role before invoking Sizes: gc Sizes may panic
+		// for type parameters. An unknown or generic role is not a layout.
+		switch concrete := typ.(type) {
+		case *types.Basic:
+			if concrete.Info()&(types.IsInteger|types.IsBoolean) == 0 && !(opaqueUnsafePointer && concrete.Kind() == types.UnsafePointer) &&
+				!(argumentCarriers && concrete.Info()&(types.IsFloat|types.IsComplex|types.IsString) != 0) &&
+				!(floatingScalar && goAMD64NumericalFloatingScalar(concrete)) ||
+				concrete.Info()&types.IsUntyped != 0 {
+				return goAMD64FrameContext("unsupported noninteger or untyped language type")
+			}
+		case *types.Named:
+			if concrete.TypeParams().Len() != 0 {
+				return goAMD64FrameContext("generic language type")
+			}
+		case *types.Pointer, *types.Slice, *types.Array, *types.Struct:
+		default:
+			if !goAMD64FrameIsAlias(typ) {
+				return goAMD64FrameContext("unknown language type role")
+			}
+			if method := reflect.ValueOf(typ).MethodByName("TypeParams"); method.IsValid() {
+				parameters, ok := method.Call(nil)[0].Interface().(*types.TypeParamList)
+				if !ok || parameters.Len() != 0 {
+					return goAMD64FrameContext("generic alias language type")
+				}
+			}
+		}
+		// Composite identity is written below one node at a time. Asking
+		// TypeString to expand an anonymous DAG defeats the node/byte bound.
+		spelling := ""
+		switch typ.(type) {
+		case *types.Basic, *types.Named:
+			spelling = types.TypeString(typ, func(pkg *types.Package) string { return pkg.Path() })
+		default:
+			if goAMD64FrameIsAlias(typ) {
+				spelling = types.TypeString(typ, func(pkg *types.Package) string { return pkg.Path() })
+			}
+		}
+		fmt.Fprintf(&output, "(%q:", spelling)
+		switch typ := typ.(type) {
+		case *types.Basic:
+			if opaqueUnsafePointer && typ.Kind() == types.UnsafePointer {
+				output.WriteString("opaque_unsafe_pointer")
+			} else if typ.Kind() == types.Bool {
+				output.WriteString("bool")
+			} else if typ.Info()&types.IsInteger != 0 {
+				fmt.Fprintf(&output, "integer%d", typ.Kind())
+			} else if floatingScalar && goAMD64NumericalFloatingScalar(typ) {
+				fmt.Fprintf(&output, "floating_scalar%d", typ.Kind())
+			} else if argumentCarriers && typ.Info()&(types.IsFloat|types.IsComplex|types.IsString) != 0 {
+				fmt.Fprintf(&output, "argument_scalar%d", typ.Kind())
+			} else {
+				return goAMD64FrameContext("unsupported noninteger pointee/element")
+			}
+		case *types.Named:
+			if typ.TypeParams().Len() != 0 {
+				return goAMD64FrameContext("generic language type")
+			}
+			output.WriteString("named:")
+			if err := appendType(typ.Underlying(), depth+1); err != nil {
+				return err
+			}
+		case *types.Pointer:
+			output.WriteString("pointer:")
+			if err := appendType(typ.Elem(), depth+1); err != nil {
+				return err
+			}
+		case *types.Slice:
+			output.WriteString("slice:")
+			if err := appendType(typ.Elem(), depth+1); err != nil {
+				return err
+			}
+		case *types.Array:
+			fmt.Fprintf(&output, "array%d:", typ.Len())
+			if err := appendType(typ.Elem(), depth+1); err != nil {
+				return err
+			}
+			// Go1.20's Sizes can wrap a large array to zero. Its recorded
+			// result is not evidence of a representable concrete layout.
+			element, alignment := sizes.Sizeof(typ.Elem()), sizes.Alignof(typ.Elem())
+			const maxLayout = int64(1<<63 - 1)
+			if typ.Len() < 0 || element < 0 || alignment <= 0 || element > maxLayout-(alignment-1) {
+				return goAMD64FrameContext("array element layout is unrepresentable")
+			}
+			stride := (element + alignment - 1) / alignment * alignment
+			if typ.Len() > 0 && stride != 0 && typ.Len()-1 > (maxLayout-element)/stride {
+				return goAMD64FrameContext("array language layout overflow")
+			}
+		case *types.Struct:
+			if typ.NumFields() > 4096-nodes {
+				return goAMD64FrameContext("language field bound")
+			}
+			fields := make([]*types.Var, typ.NumFields())
+			for i := range fields {
+				fields[i] = typ.Field(i)
+			}
+			// Validate every descendant before Sizes traverses the aggregate:
+			// generic/incomplete elements are not a concrete layout.
+			for _, field := range fields {
+				if err := appendType(field.Type(), depth+1); err != nil {
+					return err
+				}
+			}
+			offsets := sizes.Offsetsof(fields)
+			output.WriteString("struct:")
+			for i, field := range fields {
+				pkg := ""
+				if field.Pkg() != nil {
+					pkg = field.Pkg().Path()
+				}
+				width := sizes.Sizeof(field.Type())
+				if offsets[i] < 0 || width < 0 || offsets[i] > (1<<63-1)-width {
+					return goAMD64FrameContext("struct language layout overflow")
+				}
+				fmt.Fprintf(&output, "%q/%q/%q/%t/%d:", pkg, field.Name(), typ.Tag(i), field.Embedded(), offsets[i])
+				if output.Len() > 64<<10 {
+					return goAMD64FrameContext("language field metadata byte bound")
+				}
+			}
+		default:
+			// Alias is newer than Go1.20. Its actual spelling and the local
+			// TypeName.IsAlias role are retained alongside the complete RHS.
+			// Underlying alone would lose a named RHS's language identity.
+			if !goAMD64FrameIsAlias(typ) {
+				return goAMD64FrameContext("unknown language type role")
+			}
+			method := reflect.ValueOf(typ).MethodByName("Rhs")
+			if !method.IsValid() || method.Type().NumIn() != 0 || method.Type().NumOut() != 1 {
+				return goAMD64FrameContext("unknown alias RHS contract")
+			}
+			rhs, ok := method.Call(nil)[0].Interface().(types.Type)
+			if !ok {
+				return goAMD64FrameContext("missing alias RHS language type")
+			}
+			output.WriteString("alias:")
+			if err := appendType(rhs, depth+1); err != nil {
+				return err
+			}
+		}
+		size, align := sizes.Sizeof(typ), sizes.Alignof(typ)
+		if size < 0 || align <= 0 {
+			return goAMD64FrameContext("language type lacks a concrete target layout")
+		}
+		fmt.Fprintf(&output, ";model_size=%d,model_align=%d)", size, align)
+		return nil
+	}
+	if err := appendType(typ, 0); err != nil {
+		return "", err
+	}
+	if output.Len() > 64<<10 {
+		return "", goAMD64FrameContext("language type byte bound")
+	}
+	return output.String(), nil
+}
+
+func goAMD64FrameIsAlias(typ types.Type) bool {
+	kind := reflect.TypeOf(typ)
+	return kind != nil && kind.Kind() == reflect.Pointer && kind.Elem().PkgPath() == "go/types" && kind.Elem().Name() == "Alias"
+}
+
+func (source *GoAMD64FrameSource) preprocess(name string, original []byte) (string, error) {
+	if source.sdkFrame != nil {
+		return source.preprocessSDKFrame(name, original)
+	}
+	if len(source.assemblerDefines) == 0 {
+		return "", goAMD64FrameContext("CPP lacks its actual assembler macro registration")
+	}
+	source.origins[filepath.Join(source.request.Directory, name)] = bytes.Count(original, []byte("\n")) + 1
+	// The owned asm command passes this exact basename from the canonical
+	// package directory; stock Go can retain that relative spelling in -S.
+	source.origins[name] = source.origins[filepath.Join(source.request.Directory, name)]
+	var expand func(string, []byte) (string, error)
+	expand = func(name string, data []byte) (string, error) {
+		return PreprocessAssemblySource(string(data), AssemblyPreprocessOptions{FileName: name, Defines: source.assemblerDefines, ReadInclude: func(parent, include string) (string, []byte, error) {
+			if filepath.Base(include) != include || include == "go_asm.h" {
+				return "", nil, goAMD64FrameContext("generated/relative CPP origin requires qualified metadata")
+			}
+			file := filepath.Join(source.request.Directory, include)
+			if _, err := os.Stat(file); os.IsNotExist(err) {
+				file = filepath.Join(source.env["GOROOT"], "pkg", "include", include)
+			}
+			data, err := source.read(file)
+			if err != nil {
+				return "", nil, err
+			}
+			source.origins[file] = bytes.Count(data, []byte("\n")) + 1
+			return file, data, nil
+		}})
+	}
+	return expand(name, original)
+}
+
+var goAMD64FrameRow = regexp.MustCompile(`^\s*0x([0-9a-f]+) [0-9]+ \((.+)\)\s+(.+)$`)
+
+// Zero-frame ordinary entries have no automatic saved-BP slot. They remain
+// in the complete source inventory without acquiring private local backing.
+func goAMD64FrameNativeLocals(frame int64) int64 {
+	if frame == 0 {
+		return 0
+	}
+	return frame + 8
+}
+
+func goAMD64FrameListing(listing []byte, file *File, pkg GoPackage, origins map[string]int) (map[string]goAMD64FrameFunction, error) {
+	return goAMD64FrameListingWithObservations(listing, file, pkg, origins, nil, nil)
+}
+
+func goAMD64FrameListingWithNumericalObject(listing []byte, file *File, pkg GoPackage, origins map[string]int, texts []gostaticstorage.TextRecord) (map[string]goAMD64FrameFunction, error) {
+	return goAMD64FrameListingWithObservations(listing, file, pkg, origins, texts, nil)
+}
+
+func goAMD64FrameListingWithWindowsUnwind(listing []byte, file *File, pkg GoPackage, origins map[string]int, unwind *gostaticstorage.WindowsAMD64AssemblyUnwind) (map[string]goAMD64FrameFunction, error) {
+	return goAMD64FrameListingWithObservations(listing, file, pkg, origins, nil, unwind)
+}
+
+// These independent, target-specific observation routes retain the strict
+// default parser. A numerical relocation does not authorize Windows metadata,
+// and Windows unwind metadata does not authorize a numerical memory read.
+func goAMD64FrameListingWithObservations(listing []byte, file *File, pkg GoPackage, origins map[string]int, texts []gostaticstorage.TextRecord, unwind *gostaticstorage.WindowsAMD64AssemblyUnwind) (map[string]goAMD64FrameFunction, error) {
+	if texts != nil && unwind != nil {
+		return nil, goAMD64FrameContext("mixed target-specific object observation roles")
+	}
+	return goAMD64FrameListingRecords(listing, file, pkg, origins, texts, unwind, nil, "", "", "")
+}
+
+func goAMD64FrameListingWithDataObject(listing []byte, file *File, pkg GoPackage, origins map[string]int,
+	data *gostaticstorage.AMD64AssemblyData, unwind *gostaticstorage.WindowsAMD64AssemblyUnwind, target, directory, root string,
+	callees ...map[string]goAMD64FrameDeclaration) (map[string]goAMD64FrameFunction, error) {
+	if data == nil || unwind != nil && !reflect.DeepEqual(data.Member.Texts, unwind.Texts) {
+		return nil, goAMD64FrameContext("mixed DATA/Windows complete object TEXT observations differ")
+	}
+	texts, err := goAMD64FrameSourceTexts(listing, data)
+	if err != nil {
+		return nil, err
+	}
+	return goAMD64FrameListingRecords(listing, file, pkg, origins, texts, unwind, data, target, directory, root, callees...)
+}
+
+func goAMD64FrameListingRecords(listing []byte, file *File, pkg GoPackage, origins map[string]int, texts []gostaticstorage.TextRecord, unwind *gostaticstorage.WindowsAMD64AssemblyUnwind, data *gostaticstorage.AMD64AssemblyData, splitTarget, splitDirectory, splitRoot string,
+	callees ...map[string]goAMD64FrameDeclaration) (map[string]goAMD64FrameFunction, error) {
+	if len(callees) > 1 {
+		return nil, goAMD64FrameContext("ambiguous ordinary Go call declarations")
+	}
+	leaves, err := goAMD64FramePrivateLeaves(file, pkg)
+	if err != nil {
+		return nil, err
+	}
+	if len(leaves) != 0 && data == nil {
+		return nil, goAMD64FrameContext("private leaf requires complete original source/object association")
+	}
+	names := make(map[string]string)
+	if data != nil {
+		if len(data.TextOrder) != len(file.Funcs) {
+			return nil, goAMD64FrameContext("complete parsed/source-object TEXT counts differ")
+		}
+		for index, fn := range file.Funcs {
+			names[fn.Sym] = data.TextOrder[index].Name
+		}
+	}
+	functions := make(map[string]goAMD64FrameFunction)
+	objects := make(map[string]gostaticstorage.TextRecord)
+	metadata := make(map[string][]byte)
+	metadataHeaders := make(map[string]string)
+	seenMetadata := make(map[string]bool)
+	if unwind != nil {
+		for _, record := range unwind.Unwind {
+			if _, duplicate := metadata[record.Name]; duplicate {
+				return nil, goAMD64FrameContext("duplicate actual Windows metadata definition")
+			}
+			metadata[record.Name] = record.Data
+			header := record.Name + " SSEHUNWINDINFO dupok size=12"
+			if unwind.ListingAlignment {
+				header += " align=0x4"
+			}
+			metadataHeaders[header] = record.Name
+		}
+	}
+	scanner := bufio.NewScanner(bytes.NewReader(listing))
+	scanner.Buffer(nil, 4<<20)
+	name := ""
+	metadataName := ""
+	var metadataBytes []byte
+	var expected int64
+	textIndex, relocationIndex := -1, 0
+	finishRelocations := func() error {
+		if texts != nil && textIndex >= 0 && relocationIndex != len(texts[textIndex].Relocations) {
+			return goAMD64FrameContext("missing complete original object/listing relocations")
+		}
+		return nil
+	}
+	for scanner.Scan() {
+		line := scanner.Text()
+		if header, valid := parseGoAMD64NativeHeader(line); valid {
+			if !header.ordinaryFrameRole() {
+				return nil, goAMD64FrameContext("native header has no ordinary/private frame entry role")
+			}
+			if !header.NoSplit && (splitTarget == "" || texts == nil) {
+				return nil, goAMD64FrameContext("automatic split layout requires its complete original object")
+			}
+			if metadataName != "" {
+				return nil, goAMD64FrameContext("Windows listing TEXT follows its metadata inventory")
+			}
+			if err := finishRelocations(); err != nil {
+				return nil, err
+			}
+			if texts != nil {
+				textIndex++
+				relocationIndex = 0
+				if textIndex >= len(texts) || texts[textIndex].Name != header.Symbol {
+					return nil, goAMD64FrameContext("reordered or foreign complete object/listing TEXT")
+				}
+				abi := uint16(0)
+				if header.Static {
+					abi = 65535
+				}
+				if texts[textIndex].Kind != header.Kind || texts[textIndex].ABI != abi ||
+					header.objectFlags() != texts[textIndex].Flags&0x19 {
+					return nil, goAMD64FrameContext("complete object/listing TEXT kind or ABI differs")
+				}
+				if splitTarget != "" && texts[textIndex].Flags != header.objectFlags() {
+					return nil, goAMD64FrameContext("complete object/listing TEXT NOSPLIT flags differ")
+				}
+				objects[header.Symbol] = texts[textIndex]
+			} else if header.Kind != 1 {
+				return nil, goAMD64FrameContext("FIPS TEXT needs its complete original object kind")
+			}
+			if name != "" && int64(len(functions[name].code)) != expected {
+				return nil, goAMD64FrameContext("partial native symbol bytes")
+			}
+			name = header.Symbol
+			if _, duplicate := functions[name]; duplicate {
+				return nil, goAMD64FrameContext("duplicate native TEXT")
+			}
+			expected = int64(header.Size)
+			functions[name] = goAMD64FrameFunction{locals: int64(header.Locals), args: header.Args, split: !header.NoSplit, positions: make(map[int]string), sourcePositions: make(map[int][]goAMD64FrameSourcePosition)}
+			continue
+		}
+		if header, exists := metadataHeaders[line]; exists {
+			if seenMetadata[header] || metadata[header] == nil ||
+				name != "" && int64(len(functions[name].code)) != expected ||
+				metadataName != "" && !bytes.Equal(metadataBytes, metadata[metadataName]) {
+				return nil, goAMD64FrameContext("unbound, duplicate or incomplete Windows metadata listing")
+			}
+			metadataName, name, metadataBytes = header, "", nil
+			seenMetadata[metadataName] = true
+			continue
+		}
+		if metadataName != "" {
+			row, err := goAMD64WindowsUnwindByteRow(line, len(metadataBytes), metadata[metadataName])
+			if err != nil {
+				return nil, err
+			}
+			metadataBytes = append(metadataBytes, row...)
+			continue
+		}
+		if name == "" {
+			return nil, goAMD64FrameContext("native listing contains unbound/unknown symbol")
+		}
+		fn := functions[name]
+		if strings.HasPrefix(strings.TrimSpace(line), "rel ") && texts != nil {
+			relocations := texts[textIndex].Relocations
+			if relocationIndex >= len(relocations) {
+				return nil, goAMD64FrameContext("extra actual object/listing relocation")
+			}
+			expectedLine := goAMD64FrameNumericalRelocationLine(relocations[relocationIndex])
+			if splitTarget != "" {
+				expectedLine = ""
+			}
+			if data != nil {
+				expectedLine = goAMD64FrameDataRelocationLine(relocations[relocationIndex], data)
+			}
+			if fn.split && splitTarget != "" {
+				if generated := goAMD64FrameSplitRelocationLine(relocations[relocationIndex], splitTarget); generated != "" {
+					expectedLine = generated
+				}
+			}
+			if expectedLine == "" || strings.Join(strings.Fields(line), " ") != expectedLine {
+				return nil, goAMD64FrameContext("foreign, duplicate or reordered actual object/listing relocation")
+			}
+			relocationIndex++
+			continue
+		}
+		if row := goAMD64FrameRow.FindStringSubmatch(line); row != nil {
+			pc, err := strconv.ParseInt(row[1], 16, 32)
+			if err != nil || pc < 0 || pc >= expected {
+				return nil, goAMD64FrameContext("invalid original instruction/source PC")
+			}
+			separator := strings.LastIndexByte(row[2], ':')
+			if separator < 0 {
+				return nil, goAMD64FrameContext("unbound original instruction/source path")
+			}
+			line, err := strconv.Atoi(row[2][separator+1:])
+			if err != nil || line <= 0 || line > origins[row[2][:separator]] {
+				return nil, goAMD64FrameContext("unbound original instruction/source line: %s", row[2])
+			}
+			fn.positions[int(pc)] += row[2] + "\t" + row[3] + "\n"
+			fn.sourcePositions[int(pc)] = append(fn.sourcePositions[int(pc)],
+				goAMD64FrameSourcePosition{row[2][:separator], line})
+		} else {
+			pc, code, err := goAssemblyListingByteRow(line)
+			if err != nil || pc != len(fn.code) || int64(pc+len(code)) > expected {
+				return nil, goAMD64FrameContext("invalid native byte record or gap/overlap: %v", err)
+			}
+			fn.code = append(fn.code, code...)
+		}
+		functions[name] = fn
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+	if err := finishRelocations(); err != nil {
+		return nil, err
+	}
+	if texts != nil && textIndex+1 != len(texts) {
+		return nil, goAMD64FrameContext("missing complete original object/listing TEXT")
+	}
+	if len(functions) != len(file.Funcs) ||
+		metadataName == "" && (name == "" || int64(len(functions[name].code)) != expected) ||
+		metadataName != "" && !bytes.Equal(metadataBytes, metadata[metadataName]) ||
+		len(seenMetadata) != len(metadata) {
+		return nil, goAMD64FrameContext("missing/incomplete original TEXT inventory")
+	}
+	bound := make(map[string]goAMD64FrameFunction)
+	for _, original := range file.Funcs {
+		symbol := pkg.Path + "." + strings.TrimPrefix(original.Sym, "·")
+		if leaves[original.Sym] {
+			symbol = names[original.Sym]
+		}
+		observed := symbol
+		fn, exists := functions[observed]
+		if !exists {
+			// Older actual Go objects retain PkgIdxSelf's empty-package
+			// spelling. Keep those observed bytes/symbols distinct from the
+			// package identity independently selected and type-checked above.
+			observed = `"".` + strings.TrimPrefix(original.Sym, "·")
+			fn, exists = functions[observed]
+		}
+		declaration, declared := pkg.Types.Scope().Lookup(strings.TrimPrefix(original.Sym, "·")).(*types.Func)
+		fn.sourceSymbol, fn.privateLeaf = original.Sym, leaves[original.Sym]
+		if text, found := objects[observed]; found {
+			fn.nativeABI = text.ABI
+		}
+		if fn.privateLeaf {
+			if !exists || declared || fn.split || fn.locals != goAMD64FrameNativeLocals(original.FrameSize) ||
+				fn.args != 0 && fn.args != -0x80000000 {
+				return nil, goAMD64FrameContext("original private leaf/native frame identity differs")
+			}
+		} else if !exists || !declared || original.FrameSize < 0 || original.FrameSize%8 != 0 || fn.locals != goAMD64FrameNativeLocals(original.FrameSize) || !goAMD64FrameArgumentsMatch(original, fn.args) || strings.Contains(original.Sym, "<") {
+			return nil, goAMD64FrameContext("original ABI0 TEXT/declaration/frame identity mismatch")
+		}
+		var err error
+		if !fn.privateLeaf {
+			fn.signature, err = DeriveGoFuncABI0Signature(symbol, declaration, "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				return nil, err
+			}
+			var end int64
+			for _, slot := range append(append([]FrameSlot(nil), fn.signature.Frame.Params...), fn.signature.Frame.Results...) {
+				if next := slot.Offset + frameTypeSize(slot.Type, 8); next > end {
+					end = next
+				}
+			}
+			if !x86TEXTArgumentsUnspecified(original) && !goabi.MatchesABI0TextSize("amd64", fn.args, end) {
+				return nil, goAMD64FrameContext("original TEXT args disagree with actual declaration")
+			}
+		}
+		callTargets, callNames := leaves, names
+		if len(callees) == 1 && len(callees[0]) != 0 && original.FrameSize > 0 && !fn.privateLeaf {
+			callTargets = make(map[string]bool, len(leaves)+len(callees[0]))
+			for name := range leaves {
+				callTargets[name] = true
+			}
+			callNames = make(map[string]string, len(names)+len(callees[0]))
+			for name, target := range names {
+				callNames[name] = target
+			}
+			for _, instruction := range original.Instrs {
+				if instruction.Op == OpCALL && len(instruction.Args) == 1 && instruction.Args[0].Kind == OpSym {
+					symbol, offset, valid := parseSBRef(instruction.Args[0].Sym)
+					name := goAMD64FrameCallName(pkg.Path, symbol)
+					if _, found := callees[0][name]; valid && offset == 0 && found {
+						callTargets[symbol], callNames[symbol] = true, name
+					}
+				}
+			}
+		}
+		if err := goAMD64FrameSourceInstructions(original, callTargets); err != nil {
+			return nil, err
+		}
+		if original.FrameSize > 0 {
+			shape := fn
+			if fn.split {
+				shape, err = goAMD64FrameSplitProjection(fn, objects[observed], original.FrameSize, splitTarget, splitDirectory, splitRoot, data)
+				if err != nil {
+					return nil, err
+				}
+				fn.prologue = shape.prologue
+			}
+			calls, err := goAMD64FrameSourceCallPCs(shape, original, objects[observed], callTargets, callNames)
+			if err != nil {
+				return nil, err
+			}
+			if err := goAMD64FrameMachineShapeWithCalls(shape, original.FrameSize, calls); err != nil {
+				return nil, err
+			}
+		} else if fn.privateLeaf {
+			if err := goAMD64FrameMachineShapeWithCalls(fn, 0, nil); err != nil {
+				return nil, err
+			}
+		} else if fn.split {
+			return nil, goAMD64FrameContext("zero-frame split entry needs its separate native layout")
+		}
+		if text, exists := objects[observed]; exists && !bytes.Equal(text.Code, fn.code) {
+			return nil, goAMD64FrameContext("complete original object/listing TEXT bytes differ")
+		}
+		fn.listingSymbol, fn.objectSymbol = observed, symbol
+		bound[symbol] = fn
+	}
+	return bound, nil
+}
+
+func goAMD64FrameSourceInstructions(fn Func, privateLeaves ...map[string]bool) error {
+	localJump := false
+	for _, ins := range fn.Instrs {
+		switch ins.Op {
+		case OpCALL:
+			if len(privateLeaves) != 1 || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				return goAMD64FrameContext("original CALL needs its complete same-source leaf")
+			}
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			if !valid || offset != 0 || !privateLeaves[0][name] {
+				return goAMD64FrameContext("original CALL needs its complete same-source leaf")
+			}
+		case "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "PCALIGNMAX":
+			return goAMD64FrameContext("raw, calling or address-sensitive original frame requires a later source contract")
+		case OpJMP:
+			localJump = true
+		case OpRET:
+			if len(ins.Args) != 0 {
+				return goAMD64FrameContext("nonordinary original RET transport")
+			}
+		}
+	}
+	if localJump {
+		// Share the complete local-label inventory with the fixed-frame CFG.
+		// A named branch within this TEXT is not an external tail-call contract.
+		_, _, err := fixedLocalEdges(fn)
+		return err
+	}
+	return nil
+}
+
+func goAMD64FrameMachineShape(fn goAMD64FrameFunction, frame int64) error {
+	return goAMD64FrameMachineShapeWithCalls(fn, frame, nil)
+}
+
+func goAMD64FrameMachineShapeWithCalls(fn goAMD64FrameFunction, frame int64, calls map[int]bool) error {
+	var instructions []x86asm.Inst
+	starts := make(map[int]bool)
+	for pc := 0; pc < len(fn.code); {
+		var ins x86asm.Inst
+		if x86NumericalVectorPrefix(fn.code[pc:], 64) {
+			length, err := x86NumericalVectorBoundary(fn.code[pc:], 64)
+			if err != nil || length <= 0 {
+				end := pc + 15
+				if end > len(fn.code) {
+					end = len(fn.code)
+				}
+				return goAMD64FrameContext("unbound original vector machine instruction at PC %d (%x): %v", pc+fn.prologue, fn.code[pc:end], err)
+			}
+			// Exact boundaries only: these cannot impersonate the scalar
+			// automatic prologue, epilogue, native CALL or return below.
+			ins.Len = length
+		} else if _, length, known, err := decodedX86SHAInstructionWithMemory(fn.code[pc:], 64, x86RawMemoryDecoder{physicalPC: true}); known || err != nil {
+			if err != nil || length <= 0 {
+				return goAMD64FrameContext("unbound original SHA machine instruction at PC %d: %v", pc+fn.prologue, err)
+			}
+			ins.Len = length // No scalar prologue, epilogue or branch authority.
+		} else if _, length, _, known, err := decodeX86RawADXWithMemory(fn.code[pc:], 0, 64, x86RawMemoryDecoder{physicalPC: true}); known || err != nil {
+			if err != nil || length <= 0 {
+				return goAMD64FrameContext("unbound original ADX machine instruction at PC %d: %v", pc+fn.prologue, err)
+			}
+			ins.Len = length // The numerical boundary decoder grants no scalar frame role.
+		} else {
+			var err error
+			ins, err = x86asm.Decode(fn.code[pc:], 64)
+			if err != nil || ins.Len == 0 || ins.Op == 0 || ins.Op == x86asm.LCALL ||
+				ins.Op == x86asm.CALL && (!calls[pc] || ins.Len != 5) {
+				return goAMD64FrameContext("unknown or calling original machine instruction in %s at PC %d (%s): %v",
+					fn.sourceSymbol, pc+fn.prologue, fn.positions[pc], err)
+			}
+		}
+		if len(fn.positions[pc]) == 0 {
+			return goAMD64FrameContext("machine instruction lacks its original source position")
+		}
+		// A projected source body must not jump back into the discarded
+		// automatic stack check or forward into its runtime retry tail.
+		if relative, ok := ins.Args[0].(x86asm.Rel); ok && fn.split && ins.Op != x86asm.CALL {
+			destination := pc + ins.Len + int(relative)
+			if destination < 0 || destination >= len(fn.code) {
+				return goAMD64FrameContext("source branch enters an automatic split region")
+			}
+		}
+		starts[pc] = true
+		instructions = append(instructions, ins)
+		pc += ins.Len
+	}
+	for pc := range fn.positions {
+		if !starts[pc] {
+			return goAMD64FrameContext("original source position is not a machine instruction boundary")
+		}
+	}
+	if frame == 0 {
+		returns := 0
+		for _, ins := range instructions {
+			if ins.Op == x86asm.PUSH || ins.Op == x86asm.POP {
+				return goAMD64FrameContext("private leaf acquired an implicit native BP/SP frame")
+			}
+			for _, arg := range ins.Args {
+				if reg, ok := arg.(x86asm.Reg); ok && (reg == x86asm.RSP || reg == x86asm.ESP || reg == x86asm.SP || reg == x86asm.SPB) {
+					return goAMD64FrameContext("private leaf machine instruction observes its physical SP")
+				}
+				if memory, ok := arg.(x86asm.Mem); ok && (memory.Base == x86asm.RSP || memory.Index == x86asm.RSP) {
+					return goAMD64FrameContext("private leaf machine memory observes its physical SP")
+				}
+			}
+			if ins.Op == x86asm.RET {
+				returns++
+			}
+		}
+		if returns == 0 {
+			return goAMD64FrameContext("private leaf has no original native return")
+		}
+		return goAMD64FrameMachineBranches(instructions, starts)
+	}
+	if len(instructions) < 6 {
+		return goAMD64FrameContext("partial automatic BP/SP frame")
+	}
+	first, second, third := instructions[0], instructions[1], instructions[2]
+	push := first.Op == x86asm.PUSH && first.Args[0] == x86asm.RBP &&
+		second.Op == x86asm.MOV && second.Args[0] == x86asm.RBP && second.Args[1] == x86asm.RSP &&
+		goAMD64FrameStackAdjustment(third, -frame)
+	slot := x86asm.Mem{Base: x86asm.RSP, Scale: 1, Disp: frame}
+	stored := goAMD64FrameStackAdjustment(first, -frame-8) &&
+		second.Op == x86asm.MOV && second.Args[0] == slot && second.Args[1] == x86asm.RBP && second.DataSize == 64 &&
+		third.Op == x86asm.LEA && third.Args[0] == x86asm.RBP && third.Args[1] == slot && third.DataSize == 64
+	if !push && !stored {
+		return goAMD64FrameContext("unrecognized automatic BP/SP prologue")
+	}
+	// Source control flow may return before the physical end of TEXT, then
+	// close the final block with a local backedge. No source edge may enter an
+	// automatic prologue or skip part of a return's automatic stack restoration.
+	starts[0], starts[first.Len], starts[first.Len+second.Len] = false, false, false
+	returns := 0
+	pc := 0
+	for i, ins := range instructions {
+		if ins.Op == x86asm.RET {
+			returns++
+			if i < 2 {
+				return goAMD64FrameContext("partial original RET epilogue")
+			}
+			penultimate, previous := instructions[i-2], instructions[i-1]
+			pushReturn := push && previous.Op == x86asm.POP && previous.Args[0] == x86asm.RBP &&
+				goAMD64FrameStackAdjustment(penultimate, frame)
+			storedReturn := stored && penultimate.Op == x86asm.MOV && penultimate.Args[0] == x86asm.RBP && penultimate.Args[1] == slot && penultimate.DataSize == 64 &&
+				goAMD64FrameStackAdjustment(previous, frame+8)
+			if !pushReturn && !storedReturn {
+				return goAMD64FrameContext("unrecognized original RET epilogue")
+			}
+			starts[pc], starts[pc-previous.Len] = false, false
+		}
+		pc += ins.Len
+	}
+	last := instructions[len(instructions)-1]
+	if returns == 0 || last.Op != x86asm.RET && last.Op != x86asm.JMP {
+		return goAMD64FrameContext("original frame has no conventional RET")
+	}
+	return goAMD64FrameMachineBranches(instructions, starts)
+}
+
+func goAMD64FrameMachineBranches(instructions []x86asm.Inst, starts map[int]bool) error {
+	pc := 0
+	for _, ins := range instructions {
+		pc += ins.Len
+		if ins.Op == x86asm.CALL {
+			continue // Exact source/relocation target, not a local body branch.
+		}
+		relative, direct := ins.Args[0].(x86asm.Rel)
+		if ins.Op == x86asm.JMP && !direct || direct && !starts[pc+int(relative)] {
+			return goAMD64FrameContext("original branch leaves the source body or enters an automatic frame interior")
+		}
+	}
+	return nil
+}
+
+// Go's ADJSP encoder chooses ADD/SUB and a signed immediate together. At
+// 128 bytes the opposite operation with -128 has the shorter encoding.
+// Validate the exact 64-bit stack delta, not one spelling of that delta.
+func goAMD64FrameStackAdjustment(ins x86asm.Inst, delta int64) bool {
+	if ins.DataSize != 64 || ins.Args[0] != x86asm.RSP || ins.Args[2] != nil || ins.Args[3] != nil {
+		return false
+	}
+	amount, immediate := ins.Args[1].(x86asm.Imm)
+	return immediate && (ins.Op == x86asm.ADD && int64(amount) == delta ||
+		ins.Op == x86asm.SUB && int64(amount) == -delta)
+}
+
+func (source *GoAMD64FrameSource) verifyObjectListing(ctx context.Context, object string, wanted map[string]goAMD64FrameFunction) error {
+	data, err := source.run(ctx, "tool", "objdump", object)
+	if err != nil {
+		return err
+	}
+	return goAMD64FrameObjectBytes(data, wanted)
+}
+
+func goAMD64FrameObjectBytes(data []byte, wanted map[string]goAMD64FrameFunction) error {
+	actual := make(map[string][]byte)
+	addresses := make(map[string]uint64)
+	name := ""
+	for _, line := range strings.Split(string(data), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 {
+			continue
+		}
+		if len(fields) == 3 && fields[0] == "TEXT" && strings.HasSuffix(fields[1], "(SB)") {
+			name = strings.TrimSuffix(fields[1], "(SB)")
+			if _, duplicate := actual[name]; duplicate {
+				return goAMD64FrameContext("duplicate actual object symbol")
+			}
+			actual[name] = nil
+			continue
+		}
+		if len(fields) < 4 || name == "" || !strings.HasPrefix(fields[1], "0x") {
+			return goAMD64FrameContext("unknown actual object disassembly record")
+		}
+		value, err := hex.DecodeString(fields[2])
+		if err != nil || len(value) == 0 {
+			return goAMD64FrameContext("invalid actual object bytes")
+		}
+		address, err := strconv.ParseUint(strings.TrimPrefix(fields[1], "0x"), 16, 64)
+		if len(actual[name]) == 0 {
+			addresses[name] = address
+		}
+		if err != nil || address != addresses[name]+uint64(len(actual[name])) {
+			return goAMD64FrameContext("actual object instruction bytes have a gap/overlap")
+		}
+		actual[name] = append(actual[name], value...)
+	}
+	if len(actual) != len(wanted) {
+		return goAMD64FrameContext("object/listing symbol inventories differ")
+	}
+	for _, fn := range wanted {
+		name := fn.objectSymbol
+		if fn.privateLeaf && fn.nativeABI == 65535 {
+			// cmd/internal/objfile.goobjName renders the actual static ABI
+			// bank as version 1. Do not strip arbitrary symbol suffixes.
+			name += "<1>"
+		}
+		if !bytes.Equal(actual[name], fn.code) {
+			return goAMD64FrameContext("object/listing physical bytes differ for %s", fn.objectSymbol)
+		}
+	}
+	return nil
+}
diff --git a/amd64_go_frame_source_ownership_test.go b/amd64_go_frame_source_ownership_test.go
new file mode 100644
index 000000000..7e538520a
--- /dev/null
+++ b/amd64_go_frame_source_ownership_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestGoAMD64FrameSourceCloseRejectsReplacedOwnedDirectory(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	temporary := t.TempDir()
+	t.Setenv("TMPDIR", temporary)
+	request.Environment = append(request.Environment, "TMPDIR="+temporary, "GOTMPDIR="+temporary)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	owned := source.owned
+	original, err := sourcepath.Lstat(owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Every path here belongs to t.TempDir. The replacement models a different
+	// owner at the same spelling; Close must not recursively remove that owner.
+	moved := filepath.Join(t.TempDir(), "original-artifacts")
+	if err := os.Rename(owned, moved); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(owned, 0700); err != nil {
+		t.Fatal(err)
+	}
+	replacement, err := sourcepath.Lstat(owned)
+	if err != nil || os.SameFile(original, replacement) {
+		t.Fatalf("fixture did not replace directory identity: %v", err)
+	}
+	canary := filepath.Join(owned, "replacement-owner.txt")
+	if err := os.WriteFile(canary, []byte("not a factory artifact\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Errorf("Close did not reject changed directory identity: %v", err)
+	}
+	if _, err := os.Stat(canary); err != nil {
+		t.Errorf("Close removed replacement owner's file: %v", err)
+	}
+	if source.ready {
+		t.Error("failed cleanup retained ready observation")
+	}
+	// Restore only our known original directory for the fixture's registered
+	// cleanup. RemoveAll is limited to this exact t.TempDir-owned replacement.
+	if err := os.RemoveAll(owned); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(moved, owned); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestGoAMD64FrameSourceRequestTemporaryOwnership(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	parentTemporary := t.TempDir()
+	requestTemporary := t.TempDir()
+	canonicalTemporary, err := filepath.EvalSymlinks(requestTemporary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("TMPDIR", parentTemporary)
+	// Like exec.Cmd, the supplied environment's last occurrence wins. Neither
+	// the inherited parent TMPDIR nor the earlier supplied value is ownership.
+	request.Environment = append(request.Environment,
+		"TMPDIR="+parentTemporary, "TMPDIR="+requestTemporary,
+		"GOTMPDIR="+requestTemporary)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	if filepath.Dir(source.owned) != canonicalTemporary {
+		t.Fatalf("factory artifacts are outside request TMPDIR: got parent %q, want %q", filepath.Dir(source.owned), canonicalTemporary)
+	}
+	if err := source.Verify(context.Background()); err != nil {
+		t.Fatal(err)
+	}
+	owned := source.owned
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatalf("Close retained factory artifacts: %v", err)
+	}
+	for _, name := range []string{parentTemporary, requestTemporary, request.Directory} {
+		if _, err := os.Stat(name); err != nil {
+			t.Fatalf("Close removed a caller-owned directory: %v", err)
+		}
+	}
+}
+
+func TestGoAMD64FrameSourceRepeatedEnvironmentActualValues(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "GOTMPDIR"} {
+		var expected string
+		for _, item := range request.Environment {
+			name, value, _ := strings.Cut(item, "=")
+			if name == key {
+				expected = value
+			}
+		}
+		if !filepath.IsAbs(expected) {
+			t.Fatalf("fixture lacks owned %s", key)
+		}
+		request.Environment = append(request.Environment, key+"="+t.TempDir(), key+"="+expected)
+	}
+	// Target and routing settings are deliberately overridden, not accepted
+	// from a different validation view of a repeated key.
+	request.Environment = append(request.Environment, "GOOS=windows", "GOOS=darwin", "GOARCH=386", "GOARCH=arm64")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "GOTMPDIR"} {
+		var expected string
+		for _, item := range source.request.Environment {
+			name, value, _ := strings.Cut(item, "=")
+			if name == key {
+				expected = value
+			}
+		}
+		if source.env[key] != expected {
+			t.Fatalf("actual %s differs from effective supplied value: %q != %q", key, source.env[key], expected)
+		}
+	}
+	if source.env["GOOS"] != "linux" || source.env["GOARCH"] != "amd64" {
+		t.Fatalf("repeated target keys changed actual target: %v", source.env)
+	}
+}
+
+func TestGoAMD64FrameSourceOwnedIdentityRejectsRedirection(t *testing.T) {
+	for _, kind := range []string{"equal-byte directory", "symlink", "missing"} {
+		t.Run(kind, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			owned := source.owned
+			moved := filepath.Join(t.TempDir(), "original-artifacts")
+			if err := os.Rename(owned, moved); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := os.RemoveAll(owned); err != nil {
+					t.Error(err)
+				}
+				if err := os.Rename(moved, owned); err != nil {
+					t.Error(err)
+				}
+			})
+			switch kind {
+			case "equal-byte directory":
+				if err := os.Mkdir(owned, 0700); err != nil {
+					t.Fatal(err)
+				}
+				entries, err := os.ReadDir(moved)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, entry := range entries {
+					data, err := os.ReadFile(filepath.Join(moved, entry.Name()))
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filepath.Join(owned, entry.Name()), data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			case "symlink":
+				if err := os.Symlink(moved, owned); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) || source.ready {
+				t.Fatalf("changed owned directory retained observation: %v", err)
+			}
+			if err := source.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Close did not reject changed ownership: %v", err)
+			}
+			if kind != "missing" {
+				if _, err := os.Lstat(owned); err != nil {
+					t.Fatalf("Close removed a replacement directory or link: %v", err)
+				}
+			}
+			if _, err := os.Stat(filepath.Join(moved, request.AssemblyFile+".o")); err != nil {
+				t.Fatalf("Close searched for or removed moved original artifacts: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceCanonicalRootAndExplicitToolPaths(t *testing.T) {
+	t.Run("resolved package root is fixed", func(t *testing.T) {
+		pkg, request := goAMD64FrameSourceFixture(t)
+		original, err := filepath.EvalSymlinks(request.Directory)
+		if err != nil {
+			t.Fatal(err)
+		}
+		alias := filepath.Join(t.TempDir(), "package-alias")
+		if err := os.Symlink(original, alias); err != nil {
+			t.Fatal(err)
+		}
+		request.Directory = alias
+		source := requireGoAMD64FrameCapture(t, pkg, request)
+		if source.request.Directory != original {
+			t.Fatalf("capture did not bind actual canonical root: %q", source.request.Directory)
+		}
+		if err := os.Remove(alias); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.Symlink(t.TempDir(), alias); err != nil {
+			t.Fatal(err)
+		}
+		if err := source.Verify(context.Background()); err != nil {
+			t.Fatalf("unconsumed caller alias changed fixed canonical source: %v", err)
+		}
+	})
+	t.Run("Go binary symlink is not a source identity", func(t *testing.T) {
+		pkg, request := goAMD64FrameSourceFixture(t)
+		alias := filepath.Join(t.TempDir(), "go")
+		if err := os.Symlink(request.GoBinary, alias); err != nil {
+			t.Fatal(err)
+		}
+		request.GoBinary = alias
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+		if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("indirected driver produced an observation: %v", err)
+		}
+	})
+}
+
+func TestGoAMD64FrameSourceRepeatedForbiddenEnvironmentStaysContext(t *testing.T) {
+	for _, key := range []string{"GOFLAGS", "GOEXPERIMENT", "GOPACKAGESDRIVER"} {
+		t.Run(key, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			// Capture conservatively rejects any requested unsupported mapping,
+			// including one shadowed by a later empty occurrence.
+			request.Environment = append(request.Environment, key+"=unbound", key+"=")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unsupported duplicate %s mapping was accepted: %v", key, err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_source_positions_test.go b/amd64_go_frame_source_positions_test.go
new file mode 100644
index 000000000..3318babee
--- /dev/null
+++ b/amd64_go_frame_source_positions_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"errors"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64FrameSDKSourcePCPaths(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "sdk")
+	file := filepath.Join(root, "src", "sample", "input.s")
+	directory := filepath.Dir(file)
+	for _, mutation := range []string{
+		"original", "absolute", "ordinary source", "different root", "missing input",
+		"wrong line", "wrong listing", "dot segment", "parent segment", "double slash",
+		"foreign file", "invalid origin",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			text := gostaticstorage.TextRecord{Name: "sample.Value", Positions: []gostaticstorage.TextPosition{
+				{Start: 0, End: 1, File: "$GOROOT/src/sample/input.s", Line: 2},
+			}}
+			fn := goAMD64FrameFunction{code: []byte{0xc3}, sourcePositions: map[int][]goAMD64FrameSourcePosition{
+				0: {{file: file, line: 2}},
+			}}
+			origins := map[string]int{file: 3}
+			capturedRoot := root
+			switch mutation {
+			case "absolute":
+				text.Positions[0].File = file
+			case "ordinary source":
+				capturedRoot = ""
+			case "different root":
+				capturedRoot = filepath.Join(root, "other")
+			case "missing input":
+				delete(origins, file)
+			case "wrong line":
+				text.Positions[0].Line = 4
+			case "wrong listing":
+				fn.sourcePositions[0][0].line = 3
+			case "dot segment":
+				text.Positions[0].File = "$GOROOT/src/sample/./input.s"
+			case "parent segment":
+				text.Positions[0].File = "$GOROOT/src/sample/../sample/input.s"
+			case "double slash":
+				text.Positions[0].File = "$GOROOT/src//sample/input.s"
+			case "foreign file":
+				text.Positions[0].File = "$GOROOT/src/sample/foreign.s"
+			case "invalid origin":
+				text.Positions[0].File = "$GOROOT/src/sample/./input.s"
+				origins[text.Positions[0].File] = 3
+				fn.sourcePositions[0][0].file = text.Positions[0].File
+			}
+			err := goAMD64FrameSourcePCs(text, fn, directory, origins, capturedRoot)
+			wantPass := mutation == "original" || mutation == "absolute"
+			if wantPass && err != nil || !wantPass && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("captured original object/listing source paths: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_source_test.go b/amd64_go_frame_source_test.go
new file mode 100644
index 000000000..2a83e3916
--- /dev/null
+++ b/amd64_go_frame_source_test.go
@@ -0,0 +1,540 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func requireGoAMD64FrameCapture(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest) *GoAMD64FrameSource {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	return source
+}
+
+func goAMD64FrameSourceFixture(t *testing.T) (GoPackage, GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	// Keep AST positions, the caller's request and strict original-file reads
+	// bound to the same physical fixture, including aliased temporary roots.
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal("cannot resolve original frame fixture directory", err)
+	}
+	source := []byte("package framefixture\nfunc Value(a uint64) uint64\n")
+	files := map[string][]byte{
+		"go.mod":        []byte("module example.invalid/framefixture\ngo 1.20\n"),
+		"value.go":      source,
+		"value_amd64.s": []byte("#include \"textflag.h\"\nTEXT ·Value(SB),NOSPLIT,$160-16\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"),
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filepath.Join(dir, "value.go"), source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	pkg, err := (&types.Config{Sizes: sizes}).Check("example.invalid/framefixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This independent pure-Go module does not inherit the translator test
+	// binary's build tags (notably Windows' LLVM byollvm tag). Remove rather
+	// than shadow them: production capture rejects repeated forbidden flags.
+	var env []string
+	for _, entry := range os.Environ() {
+		if !strings.HasPrefix(entry, "GOFLAGS=") {
+			env = append(env, entry)
+		}
+	}
+	env = append(env, "GOFLAGS=")
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(os.Getenv(key)) {
+			env = append(env, key+"="+t.TempDir())
+		}
+	}
+	return GoPackage{Path: pkg.Path(), Types: pkg, Syntax: []*ast.File{syntax}}, GoAMD64FrameCaptureRequest{
+		GoBinary: binary, Directory: dir, AssemblyFile: "value_amd64.s", Target: "linux/amd64", Environment: env,
+	}
+}
+
+func TestGoAMD64FrameSourceActualCaptureAndSealedLifecycle(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	// Independent original-Go acceptance precedes the proposed token. This
+	// object observation is not itself a native-memory authorization.
+	raw, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	listing := x86InsertExtractGoListing(t, "amd64", strings.Replace(string(raw), "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+	t.Logf("actual stock-Go original nonzero TEXT listing:\n%s", listing)
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if len(source.functions) != 1 || source.functions["example.invalid/framefixture.Value"].locals != 168 {
+		t.Fatalf("missing actual Go frame witness: %+v", source.functions)
+	}
+	encoded, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var restored GoAMD64FrameSource
+	if err := json.Unmarshal(encoded, &restored); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(restored.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("JSON recreated private frame authority")
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("closed witness retained authority")
+	}
+}
+
+func TestGoAMD64FrameSourceRefusesSelfReportedSelection(t *testing.T) {
+	for _, mutation := range []string{"wrong types", "missing sibling", "dependency", "generated header", "source changed", "same width signedness", "target", "custom flags", "conditional CPP", "raw RET", "zero frame", "pointer", "unknown tool"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			switch mutation {
+			case "wrong types":
+				pkg.Types = types.NewPackage(pkg.Path, "forged")
+			case "missing sibling":
+				if err := os.WriteFile(filepath.Join(request.Directory, "sibling_amd64.s"), []byte("TEXT ·Other(SB),4,$8-0\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				request.AssemblyFile = "sibling_amd64.s"
+			case "dependency":
+				if err := os.WriteFile(filepath.Join(request.Directory, "dep.go"), []byte("package framefixture\nimport _ \"unsafe\"\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "generated header":
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte("#include \"go_asm.h\"\nTEXT ·Value(SB),4,$160-16\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "source changed":
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\nfunc Value(a uint32) uint32\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "target":
+				request.Target = "linux/386"
+			case "same width signedness":
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\nfunc Value(a int64) int64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "custom flags":
+				request.Environment = append(request.Environment, "GOFLAGS=-tags=custom")
+			case "conditional CPP":
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte("#ifdef GOARCH_amd64\n#include \"go_asm.h\"\nTEXT ·Value(SB),4,$160-16\nRET\n#endif\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "raw RET":
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte("TEXT ·Value(SB),4,$160-16\nBYTE $0xc3\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "zero frame":
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte("TEXT ·Value(SB),4,$0-16\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "pointer":
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\nfunc Value(a *uint64) *uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "unknown tool":
+				request.GoBinary = filepath.Join(request.Directory, "not-a-go-driver")
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			proof, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if proof != nil {
+				proof.Close()
+				t.Fatal("unsupported/incomplete source produced token")
+			}
+			if err == nil {
+				t.Fatal("self-reported typed selection was accepted")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceActualTargetAndFullSiblingInventory(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			request.Target = target
+			data, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(filepath.Join(request.Directory, "sibling_amd64.s"), bytes.ReplaceAll(data, []byte("Value"), []byte("Other")), 0600); err != nil {
+				t.Fatal(err)
+			}
+			declarations := []byte("package framefixture\nfunc Value(a uint64) uint64\nfunc Other(a uint64) uint64\n")
+			if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), declarations, 0600); err != nil {
+				t.Fatal(err)
+			}
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, "value.go", declarations, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg.Types, err = (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if target == "windows/amd64" && errors.Is(err, ErrProbeNeedsContext) && strings.Contains(err.Error(), "SSEHUNWINDINFO") {
+				if source != nil {
+					t.Fatal("unsupported generated unwind role returned a token")
+				}
+				t.Logf("actual Windows auxiliary object role remains unbound: %v", err)
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if len(source.selection.SFiles) != 2 || len(source.functions) != 1 || source.env["GOOS"]+"/"+source.env["GOARCH"] != target {
+				t.Fatalf("incomplete actual target/sibling observation: %+v", source.selection)
+			}
+			if _, observed := source.functions[pkg.Path+".Other"]; observed {
+				t.Fatal("unrequested sibling acquired frame facts")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceInputMutationPermanentlyRevokes(t *testing.T) {
+	for _, kind := range []string{"Go", "ASM", "unused header", "include", "inventory", "object", "listing", "cancel"} {
+		t.Run(kind, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			header := filepath.Join(request.Directory, "fixture.h")
+			if err := os.WriteFile(header, []byte("#define FRAME 160\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if kind == "include" {
+				assembly := filepath.Join(request.Directory, request.AssemblyFile)
+				original, err := os.ReadFile(assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				original = append([]byte("#include \"fixture.h\"\n"), bytes.Replace(original, []byte("$160-16"), []byte("$FRAME-16"), 1)...)
+				if err := os.WriteFile(assembly, original, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			if kind == "include" && source.origins[filepath.Join(source.request.Directory, "fixture.h")] == 0 {
+				t.Fatal("active original CPP header was not captured")
+			}
+			filename := filepath.Join(source.request.Directory, "value.go")
+			switch kind {
+			case "ASM":
+				filename = filepath.Join(source.request.Directory, request.AssemblyFile)
+			case "unused header", "include":
+				filename = filepath.Join(source.request.Directory, "fixture.h")
+			case "inventory":
+				filename = filepath.Join(source.request.Directory, "new.h")
+			case "object":
+				filename = filepath.Join(source.owned, request.AssemblyFile+".o")
+			case "listing":
+				filename = filepath.Join(source.owned, request.AssemblyFile+".o.listing")
+			}
+			ctx := context.Background()
+			if kind == "cancel" {
+				var cancel context.CancelFunc
+				ctx, cancel = context.WithCancel(ctx)
+				cancel()
+			} else if err := os.WriteFile(filename, []byte("changed\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) || source.ready {
+				t.Fatalf("changed input retained observation: %v", err)
+			}
+			if !errors.Is(source.Verify(context.Background()), ErrProbeNeedsContext) {
+				t.Fatal("revoked observation was reopened")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceObjectListingMutations(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	listing, err := os.ReadFile(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw, err := os.ReadFile(filepath.Join(source.request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := source.preprocess(request.AssemblyFile, raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := source.functions[pkg.Path+".Value"]
+	var pcs []int
+	for pc := range fn.positions {
+		if pc > 0 {
+			pcs = append(pcs, pc)
+		}
+	}
+	sort.Ints(pcs)
+	for _, change := range []string{"source path", "source line", "interior PC", "partial bytes", "frame", "symbol", "duplicate", "relocation"} {
+		t.Run(change, func(t *testing.T) {
+			mutated := append([]byte(nil), listing...)
+			switch change {
+			case "source path":
+				mutated = bytes.ReplaceAll(mutated, []byte(request.AssemblyFile), []byte("unbound.s"))
+			case "source line":
+				mutated = bytes.ReplaceAll(mutated, []byte(".s:2)"), []byte(".s:999999)"))
+			case "interior PC":
+				before := fmt.Sprintf("0x%04x %05d", pcs[0], pcs[0])
+				after := fmt.Sprintf("0x%04x %05d", pcs[0]+1, pcs[0]+1)
+				mutated = bytes.Replace(mutated, []byte(before), []byte(after), 1)
+			case "partial bytes":
+				mutated = mutated[:bytes.LastIndex(mutated, []byte("\n\t0x"))+1]
+			case "frame":
+				mutated = bytes.Replace(mutated, []byte("locals=0xa8"), []byte("locals=0xa0"), 1)
+			case "symbol":
+				mutated = bytes.ReplaceAll(mutated, []byte(fn.listingSymbol), []byte("forged.Value"))
+			case "duplicate":
+				mutated = append(mutated, listing...)
+			case "relocation":
+				mutated = append(mutated, []byte("rel 0+4 t=R_CALL forged\n")...)
+			}
+			if _, err := goAMD64FrameListing(mutated, file, pkg, source.origins); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("mutated %s listing accepted: %v", change, err)
+			}
+		})
+	}
+	for _, locals := range []string{"fffffffffffffff8", "80000000", "ffffffff", "10000000000000000"} {
+		t.Run("foreign-locals-"+locals, func(t *testing.T) {
+			if bytes.Count(listing, []byte("locals=0xa8")) != 1 {
+				t.Fatal("actual positive-frame precondition changed")
+			}
+			mutated := bytes.Replace(listing, []byte("locals=0xa8"), []byte("locals=0x"+locals), 1)
+			if _, err := goAMD64FrameListing(mutated, file, pkg, source.origins); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("negative, noncanonical or oversized metadata replaced the actual positive frame", locals, err)
+			}
+		})
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	object := filepath.Join(source.owned, request.AssemblyFile+".o")
+	disassembly, err := source.run(ctx, "tool", "objdump", object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := goAMD64FrameObjectBytes(disassembly, source.functions); err != nil {
+		t.Fatal(err)
+	}
+	for _, change := range []string{"bytes", "symbol", "missing", "gap", "extra"} {
+		t.Run("object "+change, func(t *testing.T) {
+			mutated := append([]byte(nil), disassembly...)
+			switch change {
+			case "bytes":
+				rows := strings.Split(string(mutated), "\n")
+				fields := strings.Fields(rows[1])
+				rows[1] = strings.Replace(rows[1], fields[2], "90", 1)
+				mutated = []byte(strings.Join(rows, "\n"))
+			case "symbol":
+				mutated = bytes.ReplaceAll(mutated, []byte(fn.objectSymbol), []byte("forged.Value"))
+			case "missing":
+				mutated = mutated[:bytes.LastIndex(mutated, []byte("\n  "))+1]
+			case "gap":
+				rows := strings.Split(string(mutated), "\n")
+				fields := strings.Fields(rows[2])
+				rows[2] = strings.Replace(rows[2], fields[1], "0x0", 1)
+				mutated = []byte(strings.Join(rows, "\n"))
+			case "extra":
+				mutated = append(mutated, disassembly...)
+			}
+			if err := goAMD64FrameObjectBytes(mutated, source.functions); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("mutated %s object accepted: %v", change, err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceConcurrentVerifyClose(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	owned := source.owned
+	var workers sync.WaitGroup
+	for i := 0; i < 3; i++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			if err := source.Verify(context.Background()); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Error(err)
+			}
+		}()
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	workers.Wait()
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatalf("factory-owned artifacts survived Close: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(request.Directory, request.AssemblyFile)); err != nil {
+		t.Fatalf("Close removed original source: %v", err)
+	}
+}
+
+func TestGoAMD64FrameSourceFailedSiblingCleansOnlyOwnedObjects(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	temporary := t.TempDir()
+	t.Setenv("TMPDIR", t.TempDir())
+	request.Environment = append(request.Environment, "TMPDIR="+temporary, "GOTMPDIR="+temporary)
+	// The selected sibling cannot be bound to any actual declaration. Request
+	// it explicitly: its failure must not leak the captured object directory.
+	sibling := filepath.Join(request.Directory, "z_sibling_amd64.s")
+	if err := os.WriteFile(sibling, []byte("TEXT ·Other(SB),4,$160-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request.AssemblyFile = filepath.Base(sibling)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("partial complete-file observation accepted: %v", err)
+	}
+	entries, err := os.ReadDir(temporary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range entries {
+		if strings.HasPrefix(entry.Name(), "plan9asm-go-frame-object-") {
+			t.Fatalf("partial capture leaked %s", entry.Name())
+		}
+	}
+	if _, err := os.Stat(sibling); err != nil {
+		t.Fatalf("cleanup removed an original selected source: %v", err)
+	}
+}
+
+func TestGoAMD64FrameSourceRejectsIndirectedOriginalAndCacheFallback(t *testing.T) {
+	for _, change := range []string{"source symlink", "package subtree", "implicit cache"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			switch change {
+			case "source symlink":
+				target := filepath.Join(t.TempDir(), "source.go")
+				if err := os.WriteFile(target, []byte("package framefixture\nfunc Value(a uint64) uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				original := filepath.Join(request.Directory, "value.go")
+				if err := os.Remove(original); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(target, original); err != nil {
+					t.Fatal(err)
+				}
+			case "package subtree":
+				// Ordinary child directories have an independent positive
+				// owner. An indirected child still cannot become an input.
+				if err := os.Symlink(t.TempDir(), filepath.Join(request.Directory, "nested")); err != nil {
+					t.Fatal(err)
+				}
+			case "implicit cache":
+				request.Environment = nil
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unsupported original source/cache origin captured: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameSourceRejectsSelectedSystemObjects(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	// A genuine Go object renamed .syso is still selected by the actual driver
+	// and packed into its export. It must not be silently treated as an ASM/H
+	// source role merely because the directory and file bytes were hashed.
+	env := append(append([]string(nil), request.Environment...), "GOOS=linux", "GOARCH=amd64", "GOTOOLCHAIN=local")
+	object := filepath.Join(request.Directory, "system_amd64.syso")
+	include := filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "pkg", "include")
+	if _, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary, "tool", "asm", "-p", pkg.Path, "-I", include, "-o", object, request.AssemblyFile); err != nil {
+		t.Fatal(err)
+	}
+	source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if source != nil {
+		if closeErr := source.Close(); closeErr != nil {
+			t.Fatal(closeErr)
+		}
+		t.Fatal("actual selected .syso role was omitted from complete observation")
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unknown system-object transport did not retain Context: %v", err)
+	}
+}
diff --git a/amd64_go_frame_split.go b/amd64_go_frame_split.go
new file mode 100644
index 000000000..a6ceab1a2
--- /dev/null
+++ b/amd64_go_frame_split.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func goAMD64FrameSplitListing(listing []byte) bool {
+	for len(listing) != 0 {
+		var line []byte
+		line, listing, _ = bytes.Cut(listing, []byte{'\n'})
+		if len(line) == 0 || line[0] == '\t' || line[0] == ' ' {
+			continue
+		}
+		if header, valid := parseGoAMD64NativeHeader(string(line)); valid && !header.NoSplit {
+			return true
+		}
+	}
+	return false
+}
+
+func goAMD64FrameListingWithSplitObject(listing []byte, file *File, pkg GoPackage, origins map[string]int,
+	texts []gostaticstorage.TextRecord, unwind *gostaticstorage.WindowsAMD64AssemblyUnwind, target, directory, root string) (map[string]goAMD64FrameFunction, error) {
+	if len(texts) == 0 || target != "linux/amd64" && target != "darwin/amd64" && target != "windows/amd64" {
+		return nil, goAMD64FrameContext("automatic split layout lacks its complete object/target")
+	}
+	return goAMD64FrameListingRecords(listing, file, pkg, origins, texts, unwind, nil, target, directory, root)
+}
+
+// Listing identity is necessary but not sufficient: the complete relocation
+// inventory must subsequently match the exact generated instruction fields.
+func goAMD64FrameSplitRelocationLine(r gostaticstorage.TextRelocation, target string) string {
+	if r.Size != 4 || r.Add != 0 {
+		return ""
+	}
+	kind, name := "", r.Target.Name
+	switch {
+	case r.Type == 15 && target != "windows/amd64" && r.Target == (gostaticstorage.TextReference{}):
+		kind, name = "R_TLS_LE", "TLS"
+	case r.Type == 14 && target == "windows/amd64" && name == "runtime.tls_g" && r.Target.ABIKnown && r.Target.ABI == 0:
+		kind = "R_PCREL"
+	case r.Type == 7 && name == "runtime.morestack_noctxt" && r.Target.ABIKnown && r.Target.ABI == 0:
+		kind = "R_CALL"
+	default:
+		return ""
+	}
+	return fmt.Sprintf("rel %d+4 t=%s %s+0", r.Offset, kind, name)
+}
+
+// Go's ABI0 stack check runs before any source instruction and retries the
+// entry after growth. LLVM owns a different function frame: only the ordinary
+// body layout is projected for BP/SP validation, never a runtime call. Original
+// bytes, positions and relocations remain in the live complete source owner.
+// After either entry path, private bytes are SP+[0,frame), saved BP is at frame,
+// return PC at frame+8 and FP arguments at frame+16. Generated R12/R14/FLAGS
+// values are not supplied to the source body's existing typed input proof.
+func goAMD64FrameSplitProjection(fn goAMD64FrameFunction, text gostaticstorage.TextRecord, frame int64,
+	target, directory, root string, data *gostaticstorage.AMD64AssemblyData) (goAMD64FrameFunction, error) {
+	phase := "entry identity"
+	fail := func() (goAMD64FrameFunction, error) {
+		return goAMD64FrameFunction{}, goAMD64FrameContext("unrecognized original automatic split layout/source/relocation: %s", phase)
+	}
+	if !fn.split || text.ABI != 0 || text.Flags != fn.nativeFlags() || !bytes.Equal(fn.code, text.Code) ||
+		frame <= 0 || frame > 4096-8 {
+		return fail()
+	}
+	phase = "TEXT source position"
+	entry := goAMD64FrameSourcePosition{}
+	for _, row := range strings.Split(fn.positions[0], "\n") {
+		position, instruction, ok := strings.Cut(row, "\t")
+		if !ok || !strings.HasPrefix(instruction, "TEXT\t") {
+			continue
+		}
+		separator := strings.LastIndexByte(position, ':')
+		if separator < 0 || entry.file != "" {
+			return fail()
+		}
+		entry.file = position[:separator]
+		entry.line, _ = strconv.Atoi(position[separator+1:])
+	}
+	if entry.file == "" || entry.line <= 0 {
+		return fail()
+	}
+	entryPath := goAMD64FrameSourcePath(entry.file, directory, root)
+	if entryPath == "" {
+		return fail()
+	}
+	pc := 0
+	read := func(op x86asm.Op, args ...x86asm.Arg) bool {
+		if pc >= len(fn.code) {
+			return false
+		}
+		ins, err := x86asm.Decode(fn.code[pc:], 64)
+		if err != nil || ins.Len <= 0 || ins.Op != op {
+			return false
+		}
+		if ins.Op == x86asm.LEA && ins.AddrSize == 64 {
+			// x/arch retains disp32 as unsigned, unlike disp8. Share the
+			// decoder's physical-field normalization before exact RSP matching.
+			ins = normalizeDecodedX86MemoryDisplacements(ins)
+		}
+		for index, arg := range args {
+			if ins.Args[index] != arg {
+				return false
+			}
+		}
+		pc += ins.Len
+		return true
+	}
+	// The exact ABI0 TLS materialization differs by OS. None of these reads
+	// is source-visible or grants the body permission to read TLS or entry R14.
+	phase = "generated TLS load"
+	tlsOffset := int64(5)
+	segment := x86asm.FS
+	if target == "darwin/amd64" {
+		segment = x86asm.GS
+	}
+	if target == "windows/amd64" {
+		tlsOffset = 3
+		if !read(x86asm.MOV, x86asm.R14, x86asm.Mem{Base: x86asm.RIP}) ||
+			!read(x86asm.MOV, x86asm.R14, x86asm.Mem{Segment: x86asm.GS, Base: x86asm.R14}) ||
+			!read(x86asm.MOV, x86asm.R14, x86asm.Mem{Base: x86asm.R14}) {
+			return fail()
+		}
+	} else if target != "linux/amd64" && target != "darwin/amd64" ||
+		!read(x86asm.MOV, x86asm.R14, x86asm.Mem{Segment: segment, Scale: 1}) {
+		return fail()
+	}
+	phase = "generated stack comparison"
+	compare := x86asm.RSP
+	if frame+8 > 128 {
+		if !read(x86asm.LEA, x86asm.R12, x86asm.Mem{Base: x86asm.RSP, Scale: 1, Disp: 128 - frame - 8}) {
+			return fail()
+		}
+		compare = x86asm.R12
+	}
+	if !read(x86asm.CMP, compare, x86asm.Mem{Base: x86asm.R14, Disp: 16}) {
+		return fail()
+	}
+	phase = "generated slow-path branch"
+	if pc >= len(fn.code) {
+		return fail()
+	}
+	branch, err := x86asm.Decode(fn.code[pc:], 64)
+	jump, ok := branch.Args[0].(x86asm.Rel)
+	if err != nil || branch.Op != x86asm.JBE || !ok {
+		return fail()
+	}
+	pc += branch.Len
+	start, end := pc, pc+int(jump)
+	if end <= start || end+5 >= len(fn.code) || fn.code[end] != 0xe8 || !bytes.Equal(fn.code[end+1:end+5], make([]byte, 4)) {
+		return fail()
+	}
+	phase = "generated runtime retry"
+	pc = end + 5
+	retry, err := x86asm.Decode(fn.code[pc:], 64)
+	relative, ok := retry.Args[0].(x86asm.Rel)
+	if err != nil || retry.Op != x86asm.JMP || !ok || pc+retry.Len != len(fn.code) || pc+retry.Len+int(relative) != 0 {
+		return fail()
+	}
+	// Generated fields take precedence over ordinary DATA references, including
+	// Windows' ABI0 R_PCREL runtime.tls_g. Every other field must belong wholly
+	// to the body and retain the same complete DATA object's identity rules.
+	phase = "generated/body relocation partition"
+	generated := 0
+	var previousRelocationEnd int64
+	for _, relocation := range text.Relocations {
+		if relocation.Size != 4 || relocation.Offset < previousRelocationEnd || relocation.Offset > int64(len(fn.code))-relocation.Size {
+			return fail()
+		}
+		previousRelocationEnd = relocation.Offset + relocation.Size
+		switch relocation.Offset {
+		case tlsOffset:
+			if relocation.Type == 7 || goAMD64FrameSplitRelocationLine(relocation, target) == "" {
+				return fail()
+			}
+			generated |= 1
+		case int64(end + 1):
+			if relocation.Type != 7 || goAMD64FrameSplitRelocationLine(relocation, target) == "" {
+				return fail()
+			}
+			generated |= 2
+		default:
+			if data == nil || relocation.Offset < int64(start) || relocation.Offset > int64(end)-relocation.Size ||
+				relocation.Type != 14 && !goAMD64FrameLocalCallTarget(relocation, data.Member.Texts) ||
+				goAMD64FrameDataRelocationLine(relocation, data) == "" {
+				return fail()
+			}
+		}
+	}
+	if generated != 3 {
+		return fail()
+	}
+	// Actual object PC intervals, not just printed instruction names, bind
+	// every generated byte to the original TEXT directive's source position.
+	phase = "generated source-PC intervals"
+	var previous int64
+	for _, span := range text.Positions {
+		if span.Start != previous || span.End <= span.Start || span.End > int64(len(fn.code)) {
+			return fail()
+		}
+		previous = span.End
+		if span.Start < int64(start) || span.End > int64(end) {
+			if goAMD64FrameSourcePath(span.File, directory, root) != entryPath || int(span.Line) != entry.line {
+				return fail()
+			}
+		}
+	}
+	if previous != int64(len(fn.code)) {
+		return fail()
+	}
+	projected := fn
+	projected.code = fn.code[start:end]
+	projected.prologue = start
+	projected.positions = make(map[int]string)
+	for position, rows := range fn.positions {
+		if position >= start && position < end {
+			projected.positions[position-start] = rows
+		}
+	}
+	return projected, nil
+}
diff --git a/amd64_go_frame_split_data_test.go b/amd64_go_frame_split_data_test.go
new file mode 100644
index 000000000..5a149e305
--- /dev/null
+++ b/amd64_go_frame_split_data_test.go
@@ -0,0 +1,261 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func fixedLocalSplitDataFixture(t *testing.T, target, triple string, frame int) (GoPackage, GoAMD64FrameCaptureRequest, Options, string) {
+	t.Helper()
+	pkg, request, _, options, original := fixedLocalDataFixture(t,
+		"MOVOU literal<>(SB),X0\nPADDQ 16(SP),X0", fixedLocalLiteralData)
+	assembly := strings.Replace(original, "TEXT ·Value(SB),4,$160-40", fmt.Sprintf("TEXT ·Value(SB),$%d-40", frame), 1)
+	if assembly == original {
+		t.Fatal("fixture did not remove the source NOSPLIT flag")
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request.Target, options.TargetTriple = target, triple
+	return pkg, request, options, assembly
+}
+
+func TestGoAMD64FrameAutomaticSplitWithDataObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			for _, frame := range []int{160, 536} {
+				t.Run(fmt.Sprintf("frame%d", frame), func(t *testing.T) {
+					pkg, request, options, assembly := fixedLocalSplitDataFixture(t, target.name, target.triple, frame)
+					x86LEAActualTargetGoObject(t, "amd64", target.triple, assembly)
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+						if err != nil || !strings.Contains(ir, "internal constant [32 x i8]") ||
+							!strings.Contains(ir, "fixed_local_native") || strings.Contains(ir, "morestack") {
+							t.Fatal("complete DATA/split source lost its ordinary LLVM frame or private literal", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "split-data.ll", "split-data.o", ir)
+						compileLLVMToObject(t, llc, target.triple, "split-data-opt.ll", "split-data-opt.o", x86MulDivRoundOptimize(t, ir))
+					})
+				})
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameAutomaticSplitWithSDKDataObservation(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/internal/fips140/sha256")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	pkg := sdkAMD64FrameActualPackage(t, observed.source)
+	source, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: "sha256block_amd64.s",
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		for ordinal, object := range observed.source.observation.Objects.Sources {
+			for _, text := range object.Original.Texts {
+				if text.Name != request.PackagePath+".blockAVX2" || len(text.Code) < 64 || len(text.Positions) == 0 {
+					continue
+				}
+				t.Logf("original prefix=%x tail=%x relocations=%+v firstPC=%+v lastPC=%+v", text.Code[:64],
+					text.Code[len(text.Code)-16:], text.Relocations, text.Positions[0], text.Positions[len(text.Positions)-1])
+				rows := strings.SplitN(string(observed.source.observation.Frames[ordinal].OriginalListing), "\n", 4)
+				if len(rows) > 3 {
+					rows = rows[:3]
+				}
+				t.Log(strings.Join(rows, "\n"))
+			}
+		}
+		t.Fatal("complete original SDK split/DATA observation", err)
+	}
+	defer source.Close()
+	fn, found := source.functions[request.PackagePath+".blockAVX2"]
+	if !found || !fn.split || fn.prologue <= 0 || len(source.functions) != 2 {
+		t.Fatal("complete SDK source lost its split frame or ordinary sibling")
+	}
+	expanded := source.sdkFrame.owner.source.observation.CPP[0].Output
+	data, err := source.fixedLocalDataObservation(source.request.AssemblyFile, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var text gostaticstorage.TextRecord
+	for _, candidate := range data.Member.Texts {
+		if candidate.Name == request.PackagePath+".blockAVX2" {
+			text = candidate
+		}
+	}
+	if len(text.Positions) == 0 || !strings.HasPrefix(text.Positions[0].File, "$GOROOT/") {
+		t.Fatal("actual SDK object did not exercise captured-root source metadata")
+	}
+	tls, err := x86asm.Decode(text.Code, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	lea, err := x86asm.Decode(text.Code[tls.Len:], 64)
+	if err != nil || lea.Op != x86asm.LEA || lea.Len != 8 || lea.AddrSize != 64 {
+		t.Fatal("actual SDK prologue lacks the original disp32 LEA", err)
+	}
+	for _, displacement := range []int32{-1 << 31, -417, -415, -129, -128, -1, 0, 127, 128, 1<<31 - 1} {
+		t.Run(fmt.Sprintf("wrong displacement %d", displacement), func(t *testing.T) {
+			changed := text
+			changed.Code = append([]byte(nil), text.Code...)
+			binary.LittleEndian.PutUint32(changed.Code[tls.Len+lea.Len-4:], uint32(displacement))
+			changedFn := fn
+			changedFn.code = changed.Code
+			if _, err := goAMD64FrameSplitProjection(changedFn, changed, 536, request.Target, request.Directory, source.env["GOROOT"], data); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("wrong physical stack-check displacement was accepted", err)
+			}
+		})
+	}
+	for _, mutation := range []string{"empty root", "foreign root", "unclean metadata", "generated line"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed, root := text, source.env["GOROOT"]
+			changed.Positions = append([]gostaticstorage.TextPosition(nil), text.Positions...)
+			switch mutation {
+			case "empty root":
+				root = ""
+			case "foreign root":
+				root = t.TempDir()
+			case "unclean metadata":
+				changed.Positions[0].File = strings.Replace(changed.Positions[0].File, "$GOROOT/", "$GOROOT/../", 1)
+			case "generated line":
+				changed.Positions[0].Line++
+			}
+			if _, err := goAMD64FrameSplitProjection(fn, changed, 536, request.Target, request.Directory, root, data); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("generated SDK region borrowed an unbound source position", err)
+			}
+		})
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("live complete SDK split/DATA observation", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("complete original SHA256 source observed; this is not a whole-file translation or execution result")
+}
+
+func TestGoAMD64FrameAutomaticSplitDataRelocationPartition(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			// Both private and ordinary references belong to this original body.
+			// Capturing Global's address gives it no fixed-local read permission.
+			assembly := fixedLocalLiteralData + `TEXT ·Value(SB),$160-16
+MOVQ a+0(FP),AX
+MOVQ AX,16(SP)
+MOVQ $·Global(SB),BX
+MOVQ literal<>(SB),CX
+MOVQ 16(SP),AX
+MOVQ AX,ret+8(FP)
+RET
+`
+			pkg, request, _, _ := fixedLocalTransportFixture(t, assembly,
+				"var Global uint64\nfunc Value(a uint64) uint64\n", target.name, target.triple)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			expanded, err := source.preprocess(request.AssemblyFile, []byte(assembly))
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := source.fixedLocalDataObservation(request.AssemblyFile, expanded)
+			if err != nil || len(data.Member.Texts) != 1 {
+				t.Fatal("missing complete original object", err)
+			}
+			text, fn := data.Member.Texts[0], source.functions[pkg.Path+".Value"]
+			if len(text.Relocations) != 4 || text.Relocations[1].Target.Name != pkg.Path+".Global" || text.Relocations[2].Target.ABI != 65535 {
+				t.Fatal("actual Go object lacks both generated and body relocation roles")
+			}
+			shape, err := goAMD64FrameSplitProjection(fn, text, 160, request.Target, request.Directory, "", data)
+			if err != nil {
+				t.Fatal("complete unmodified generated/body relocation partition", err)
+			}
+			encoded, err := json.Marshal(text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, mutation := range []string{
+				"missing TLS", "missing morestack", "duplicate TLS", "duplicate morestack", "duplicate body", "reordered body",
+				"DATA in prefix", "DATA in tail", "DATA crosses body end", "body call", "private index", "private ABI",
+				"TLS ordinary fallback", "morestack ordinary fallback", "TLS field moved", "morestack field moved",
+			} {
+				t.Run(mutation, func(t *testing.T) {
+					var changed gostaticstorage.TextRecord
+					if err := json.Unmarshal(encoded, &changed); err != nil {
+						t.Fatal(err)
+					}
+					relocations := changed.Relocations
+					switch mutation {
+					case "missing TLS":
+						relocations = relocations[1:]
+					case "missing morestack":
+						relocations = relocations[:3]
+					case "duplicate TLS":
+						relocations = append([]gostaticstorage.TextRelocation{relocations[0]}, relocations...)
+					case "duplicate morestack":
+						relocations = append(relocations, relocations[3])
+					case "duplicate body":
+						relocations[2] = relocations[1]
+					case "reordered body":
+						relocations[1], relocations[2] = relocations[2], relocations[1]
+					case "DATA in prefix":
+						relocations[1].Offset = int64(shape.prologue - 4)
+					case "DATA in tail":
+						relocations[2].Offset = relocations[3].Offset + 4
+					case "DATA crosses body end":
+						relocations[2].Offset = int64(shape.prologue + len(shape.code) - 2)
+					case "body call":
+						relocations[1].Type, relocations[1].Target = relocations[3].Type, relocations[3].Target
+						if goAMD64FrameDataRelocationLine(relocations[1], data) == "" ||
+							goAMD64FrameLocalCallTarget(relocations[1], data.Member.Texts) {
+							t.Fatal("ordinary external CALL observation did not reach the independent body-role guard")
+						}
+					case "private index":
+						relocations[2].Target.SymbolIndex++
+					case "private ABI":
+						relocations[2].Target.ABI = 0
+					case "TLS ordinary fallback":
+						relocations[0].Type, relocations[0].Target = relocations[1].Type, relocations[1].Target
+						if goAMD64FrameDataRelocationLine(relocations[0], data) == "" {
+							t.Fatal("mutation did not exercise ordinary R_PCREL fallback")
+						}
+					case "morestack ordinary fallback":
+						relocations[3].Type, relocations[3].Target = relocations[1].Type, relocations[1].Target
+					case "TLS field moved":
+						relocations[0].Offset++
+					case "morestack field moved":
+						relocations[3].Offset++
+					}
+					changed.Relocations = relocations
+					if _, err := goAMD64FrameSplitProjection(fn, changed, 160, request.Target, request.Directory, "", data); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed generated/body relocation roles were accepted", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_split_test.go b/amd64_go_frame_split_test.go
new file mode 100644
index 000000000..39df47b2a
--- /dev/null
+++ b/amd64_go_frame_split_test.go
@@ -0,0 +1,232 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64FrameAutomaticSplitLayout(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		// Go's ADJSP encoder flips ADD/SUB at the signed-byte boundary.
+		// Exercise both sides, with and without generated stack checks.
+		for _, frame := range []int{64, 120, 128, 160, 256} {
+			for _, nosplit := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/frame%d/nosplit%t", target.name, frame, nosplit), func(t *testing.T) {
+					pkg, request := goAMD64FrameSourceFixture(t)
+					request.Target = target.name
+					flags := ""
+					if nosplit {
+						flags = "4,"
+					}
+					assembly := fmt.Sprintf("TEXT ·Value(SB),%s$%d-16\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n", flags, frame)
+					if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+						t.Fatal(err)
+					}
+					// The original assembler decides whether a source-level split
+					// flag actually generates a stack check (small leaves do not).
+					listing := x86InsertExtractGoListing(t, "amd64", assembly)
+					wantSplit := !nosplit && frame+8 >= 128
+					if strings.Contains(string(listing), "CALL\truntime.morestack_noctxt") != wantSplit {
+						t.Fatal("independent Go prologue did not match the frame/flag case", listing)
+					}
+					name := pkg.Path + ".Value"
+					sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: "amd64", TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{name: sig}, ResolveSym: func(string) string { return name }}
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate"}, func(t *testing.T, ir string, err error) {
+						if err != nil || !strings.Contains(ir, "%fixed_local_native = alloca") || strings.Contains(ir, "morestack") {
+							t.Fatal("ordinary source frame did not use the LLVM function frame", err)
+						}
+						compileLLVMToObject(t, llc, options.TargetTriple, "split.ll", "split.o", ir)
+						compileLLVMToObject(t, llc, options.TargetTriple, "split-opt.ll", "split-opt.o", x86MulDivRoundOptimize(t, ir))
+					})
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FrameAutomaticSplitRejectsChangedObservation(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	pkg, request := goAMD64FrameSourceFixture(t)
+	name := filepath.Join(request.Directory, request.AssemblyFile)
+	raw, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw = []byte(strings.Replace(string(raw), ",NOSPLIT,", ",", 1))
+	if err := os.WriteFile(name, raw, 0600); err != nil {
+		t.Fatal(err)
+	}
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	expanded, err := source.preprocess(request.AssemblyFile, raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	object, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := source.frameDataObject(expanded, object)
+	if err != nil || len(observed.Member.Texts) != 1 {
+		t.Fatal("missing complete original split TEXT", err)
+	}
+	fn := source.functions[pkg.Path+".Value"]
+	text := observed.Member.Texts[0]
+	encoded, err := json.Marshal(text)
+	if err != nil {
+		t.Fatal(err)
+	}
+	projection, err := goAMD64FrameSplitProjection(fn, text, 160, request.Target, request.Directory, "", nil)
+	if err != nil || projection.prologue <= 0 || len(projection.code) >= len(fn.code) {
+		t.Fatal("missing generated layout projection", err)
+	}
+	listing, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mismatch := range []string{"FIPS header", "FIPS object", "missing kind"} {
+		t.Run(mismatch, func(t *testing.T) {
+			changed, header := text, listing
+			switch mismatch {
+			case "FIPS header":
+				header = []byte(strings.Replace(string(listing), " STEXT ", " STEXTFIPS ", 1))
+			case "FIPS object":
+				changed.Kind = 2
+			case "missing kind":
+				changed.Kind = 0
+			}
+			_, err := goAMD64FrameListingWithSplitObject(header, file, pkg, source.origins,
+				[]gostaticstorage.TextRecord{changed}, nil, request.Target, request.Directory, "")
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("listing silently changed the complete object TEXT kind", err)
+			}
+		})
+	}
+	for _, mutation := range []string{
+		"TLS offset", "TLS type", "TLS target", "call offset", "call target", "call ABI", "extra relocation",
+		"prefix bytes", "branch destination", "retry destination", "generated source line", "empty positions", "position gap", "object bytes", "body branch to entry", "NOSPLIT flag", "extra flag",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			var changed gostaticstorage.TextRecord
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "TLS offset":
+				changed.Relocations[0].Offset++
+			case "TLS type":
+				changed.Relocations[0].Type = 16
+			case "TLS target":
+				changed.Relocations[0].Target.Name = "runtime.tls_g"
+			case "call offset":
+				changed.Relocations[1].Offset++
+			case "call target":
+				changed.Relocations[1].Target.Name = "runtime.morestack"
+			case "call ABI":
+				changed.Relocations[1].Target.ABI = 1
+			case "extra relocation":
+				changed.Relocations = append(changed.Relocations, changed.Relocations[1])
+			case "prefix bytes":
+				changed.Code[0] = 0x65
+			case "branch destination":
+				changed.Code[projection.prologue-1]++
+			case "retry destination":
+				changed.Code[len(changed.Code)-1]++
+			case "generated source line":
+				changed.Positions[0].Line++
+			case "empty positions":
+				changed.Positions = nil
+			case "position gap":
+				changed.Positions[0].Start++
+			case "object bytes":
+				changed.Code = changed.Code[:len(changed.Code)-1]
+			case "NOSPLIT flag":
+				changed.Flags = 16
+			case "extra flag":
+				changed.Flags = 1
+			case "body branch to entry":
+				pc := int(changed.Positions[1].Start)
+				changed.Code[pc], changed.Code[pc+1] = 0x74, byte(-pc-2)
+			}
+			changedFn := fn
+			if mutation != "object bytes" {
+				changedFn.code = changed.Code
+			}
+			shape, err := goAMD64FrameSplitProjection(changedFn, changed, 160, request.Target, request.Directory, "", nil)
+			if err == nil {
+				err = goAMD64FrameMachineShape(shape, 160)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed complete split observation accepted", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameAutomaticSplitDoesNotAuthorizeSourceRuntime(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	for _, instruction := range []string{"CALL runtime·morestack_noctxt(SB)", "MOVQ (TLS),R14", "MOVQ 168(SP),AX"} {
+		t.Run(instruction, func(t *testing.T) {
+			pkg, request, _, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+			name := filepath.Join(request.Directory, request.AssemblyFile)
+			raw, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			assembly := strings.Replace(string(raw), "TEXT ·Value(SB),4,$160-40", "TEXT ·Value(SB),$160-40\n"+instruction, 1)
+			if err := os.WriteFile(name, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil {
+				defer func() {
+					if err := source.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+				expanded, readErr := source.preprocess(request.AssemblyFile, []byte(assembly))
+				if readErr != nil {
+					t.Fatal(readErr)
+				}
+				file, parseErr := Parse(ArchAMD64, expanded)
+				if parseErr != nil {
+					t.Fatal(parseErr)
+				}
+				_, err = source.BindFixedLocal(ctx, pkg, file, options)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || strings.Contains(err.Error(), "producer") {
+				t.Fatal("automatic split check authorized a source runtime or return-slot effect", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_stack_adjust_test.go b/amd64_go_frame_stack_adjust_test.go
new file mode 100644
index 000000000..48c0ce853
--- /dev/null
+++ b/amd64_go_frame_stack_adjust_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestGoAMD64FrameMachineStackAdjustment(t *testing.T) {
+	for _, frame := range []int64{64, 120, 128, 136, 256} {
+		t.Run(fmt.Sprint(frame), func(t *testing.T) {
+			assembly := fmt.Sprintf("TEXT value(SB),4,$%d-0\nNOP\nRET\n", frame)
+			listing := x86InsertExtractGoListing(t, "amd64", assembly)
+			fn := goAMD64FrameFunction{positions: make(map[int]string)}
+			for _, line := range strings.Split(string(listing), "\n") {
+				fn.code = append(fn.code, x86InsertExtractListedBytes(line)...)
+			}
+			var starts []int
+			for pc := 0; pc < len(fn.code); {
+				ins, err := x86asm.Decode(fn.code[pc:], 64)
+				if err != nil || ins.Len <= 0 {
+					t.Fatal("independent Go object cannot be decoded", err)
+				}
+				starts = append(starts, pc)
+				// This unit test exercises machine shape only. Full capture
+				// tests independently bind real listing/source positions.
+				fn.positions[pc] = "machine-shape unit fixture"
+				pc += ins.Len
+			}
+			if len(starts) != 6 {
+				t.Fatalf("unexpected original Go prologue/epilogue: %x", fn.code)
+			}
+			if err := goAMD64FrameMachineShape(fn, frame); err != nil {
+				t.Fatal("original Go stack adjustment", err)
+			}
+			for _, index := range []int{2, 3} {
+				for _, mutation := range []string{"width", "register", "operation", "amount"} {
+					t.Run(fmt.Sprintf("instruction%d/%s", index, mutation), func(t *testing.T) {
+						changed := fn
+						changed.code = append([]byte(nil), fn.code...)
+						pc, end := starts[index], starts[index+1]
+						switch mutation {
+						case "width":
+							changed.code[pc] = 0x40 // REX without W: ESP, not RSP.
+						case "register":
+							changed.code[pc+2] &^= 7 // Same operation on AX.
+						case "operation":
+							changed.code[pc+2] ^= 0x28 // Exchange ADD and SUB.
+						case "amount":
+							changed.code[end-1] ^= 1
+						}
+						if err := goAMD64FrameMachineShape(changed, frame); err == nil {
+							t.Fatal("altered automatic frame adjustment accepted")
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_frame_standard_imports.go b/amd64_go_frame_standard_imports.go
new file mode 100644
index 000000000..c72ed24cb
--- /dev/null
+++ b/amd64_go_frame_standard_imports.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// SDK imports supply actual compiler types, never caller-memory permissions.
+// Exact downloaded modules have their own independent archive handoff;
+// nonordinary compiler roles remain separate.
+func (source *GoAMD64FrameSource) loadOriginalDeclarationImports(ctx context.Context) (map[string]goAMD64FrameSelection, error) {
+	if len(source.selection.Imports) == 0 {
+		return nil, nil
+	}
+	output, err := source.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", ".")
+	if err != nil {
+		return nil, err
+	}
+	if err := source.captureDownloadedDeclarationOrigins(ctx, output); err != nil {
+		return nil, err
+	}
+	return source.bindOriginalDeclarationImports(output)
+}
+
+// A caller retaining the actual command bytes may share the same complete
+// graph decoder. This routine observes files/exports, not frame authority.
+func (source *GoAMD64FrameSource) bindOriginalDeclarationImports(output []byte) (map[string]goAMD64FrameSelection, error) {
+	if len(output) > 16<<20 {
+		return nil, goAMD64FrameContext("declaration import graph exceeds its bound")
+	}
+	root, err := sourcepath.Resolve(source.env["GOROOT"])
+	if err != nil {
+		return nil, err
+	}
+	cache, err := sourcepath.Resolve(source.env["GOCACHE"])
+	if err != nil {
+		return nil, err
+	}
+	graph := make(map[string]goAMD64FrameSelection)
+	decoder := json.NewDecoder(bytes.NewReader(output))
+	var originalFound bool
+	var inputBytes, inputFiles int
+	for {
+		var selected goAMD64FrameSelection
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		if selected.ImportPath == "" || len(graph) >= 4096 ||
+			len(selected.Error)+len(selected.DepsErrors) != 0 || selected.ForTest != "" || selected.nonordinaryRole() {
+			return nil, goAMD64FrameContext("incomplete or nonordinary declaration import graph")
+		}
+		if selected.ImportPath == source.selection.ImportPath {
+			selected.Export, err = sourcepath.Resolve(selected.Export)
+			if err != nil || originalFound || !reflect.DeepEqual(selected, source.selection) {
+				return nil, goAMD64FrameContext("declaration graph lost the actual original package")
+			}
+			originalFound = true
+			continue
+		}
+		if _, duplicate := graph[selected.ImportPath]; duplicate ||
+			!filepath.IsLocal(filepath.FromSlash(selected.ImportPath)) {
+			return nil, goAMD64FrameContext("foreign or duplicate declaration dependency needs authenticated handoff")
+		}
+		dir, err := sourcepath.Resolve(selected.Dir)
+		var wanted string
+		var wantedErr error
+		if selected.Standard && selected.Module == nil {
+			wanted, wantedErr = sourcepath.Resolve(filepath.Join(root, "src", filepath.FromSlash(selected.ImportPath)))
+		} else {
+			wanted, wantedErr = source.downloadedDeclarationDirectory(selected)
+		}
+		if err != nil || wantedErr != nil || dir != wanted {
+			return nil, goAMD64FrameContext("actual declaration dependency escaped its original source origin: %v", wantedErr)
+		}
+		compiled := append([]string(nil), selected.CompiledGoFiles...)
+		for index, file := range compiled {
+			if filepath.IsAbs(file) {
+				relative, err := filepath.Rel(dir, file)
+				if err != nil || filepath.Base(relative) != relative {
+					return nil, goAMD64FrameContext("generated dependency compiler sources are unbound")
+				}
+				compiled[index] = relative
+			}
+		}
+		if selected.ImportPath == "unsafe" {
+			compiled = selected.GoFiles // This builtin package has no compiled export.
+		}
+		if len(selected.GoFiles) == 0 || !reflect.DeepEqual(compiled, selected.GoFiles) {
+			return nil, goAMD64FrameContext("declaration dependency omitted ordinary compiler sources")
+		}
+		for _, files := range [][]string{selected.GoFiles, selected.SFiles, selected.HFiles} {
+			for _, file := range files {
+				if filepath.Base(file) != file {
+					return nil, goAMD64FrameContext("declaration dependency source is not a package-local file")
+				}
+				data, err := source.read(filepath.Join(dir, file))
+				if err != nil {
+					return nil, err
+				}
+				inputBytes += len(data)
+				inputFiles++
+				if inputBytes > 64<<20 || inputFiles > 32768 {
+					return nil, goAMD64FrameContext("complete declaration dependency inputs exceed their bound")
+				}
+			}
+		}
+		if selected.ImportPath != "unsafe" {
+			selected.Export, err = sourcepath.Resolve(selected.Export)
+			if err != nil || !goAssemblyPathWithinRoot(cache, selected.Export) {
+				return nil, goAMD64FrameContext("declaration compiler export is outside its actual cache")
+			}
+			data, err := source.read(selected.Export)
+			if err != nil || len(data) == 0 {
+				return nil, goAMD64FrameContext("declaration compiler export is empty or changed: %v", err)
+			}
+		}
+		graph[selected.ImportPath] = selected
+	}
+	if !originalFound {
+		return nil, goAMD64FrameContext("declaration graph omitted its original package")
+	}
+	for _, selected := range append([]goAMD64FrameSelection{source.selection}, frameImportGraphValues(graph)...) {
+		for _, path := range selected.Imports {
+			if _, present := graph[path]; !present {
+				return nil, goAMD64FrameContext("declaration graph omitted an actual import")
+			}
+		}
+		for _, target := range selected.ImportMap {
+			if _, present := graph[target]; !present {
+				return nil, goAMD64FrameContext("declaration graph omitted an actual import mapping")
+			}
+		}
+	}
+	return graph, nil
+}
+
+func frameImportGraphValues(graph map[string]goAMD64FrameSelection) []goAMD64FrameSelection {
+	values := make([]goAMD64FrameSelection, 0, len(graph))
+	for _, selected := range graph {
+		values = append(values, selected)
+	}
+	return values
+}
diff --git a/amd64_go_frame_text_metadata_test.go b/amd64_go_frame_text_metadata_test.go
new file mode 100644
index 000000000..d89f14103
--- /dev/null
+++ b/amd64_go_frame_text_metadata_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Original Go object metadata and typed declarations are independent inputs.
+func TestGoAMD64FrameTEXTArgumentMetadata(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		for _, row := range []struct {
+			name, declaration, body string
+			args                    []string
+		}{
+			{"void", "func Value()", "MOVQ $7,AX\nMOVQ AX,0(SP)\n", []string{"", "-0"}},
+			{"input-result", "func Value(a uint64) uint64", "MOVQ a+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\n", []string{"", "-16"}},
+			{"result-only", "func Value() uint64", "MOVQ $7,AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+0(FP)\n", []string{"", "-8"}},
+			{"narrow-padded", "func Value(a uint8) uint32", "MOVBLZX a+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVL AX,ret+8(FP)\n", []string{"", "-12", "-16"}},
+		} {
+			for _, args := range row.args {
+				t.Run(target.name+"/"+row.name+"/24"+args, func(t *testing.T) {
+					assembly := "TEXT ·Value(SB),4,$24" + args + "\n" + row.body + "RET\n"
+					pkg, request := goAMD64FrameTypedFixture(t, row.declaration, assembly)
+					request.Target = target.name
+					listing := frameRelocationOriginal(t, pkg, request)
+					known := false
+					for _, line := range strings.Split(string(listing), "\n") {
+						if header, valid := parseGoAMD64NativeHeader(line); valid {
+							known = true
+							if header.ArgsKnown != (args != "") {
+								t.Fatal("original Go lost omitted/explicit argument metadata", header)
+							}
+						}
+					}
+					if !known {
+						t.Fatal("original Go TEXT header missing")
+					}
+					if row.name == "void" && args == "" && target.name != "windows/amd64" {
+						t.Run("known-header-cannot-replace-omission", func(t *testing.T) {
+							changed := bytes.Replace(listing, []byte("args=0xffffffff80000000"), []byte("args=0x0"), 1)
+							if bytes.Equal(changed, listing) {
+								t.Fatal("actual Go omitted-argument header was not changed")
+							}
+							file, err := Parse(ArchAMD64, assembly)
+							if err != nil {
+								t.Fatal(err)
+							}
+							_, err = goAMD64FrameListing(changed, file, pkg,
+								map[string]int{request.AssemblyFile: strings.Count(assembly, "\n") + 1})
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("a changed known-zero header replaced actual unknown metadata", err)
+							}
+						})
+					}
+					name := pkg.Path + ".Value"
+					sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: "amd64", TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{name: sig}, ResolveSym: func(string) string { return name }}
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+						func(t *testing.T, ir string, err error) {
+							if err != nil {
+								t.Fatal("actual typed declaration and original TEXT metadata failed", err)
+							}
+							compileLLVMToObject(t, llc, target.triple, "text-args.ll", "text-args.o", ir)
+							compileLLVMToObject(t, llc, target.triple, "text-args-o2.ll", "text-args-o2.o", x86MulDivRoundOptimize(t, ir))
+						})
+				})
+			}
+		}
+	}
+}
+
+func TestGoAMD64FrameTEXTExplicitArgumentMismatch(t *testing.T) {
+	for _, args := range []int{0, 8, 15, 17, 24} {
+		t.Run(fmt.Sprint(args), func(t *testing.T) {
+			assembly := fmt.Sprintf("TEXT ·Value(SB),4,$24-%d\nMOVQ a+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n", args)
+			pkg, request := goAMD64FrameTypedFixture(t, "func Value(a uint64) uint64", assembly)
+			frameRelocationOriginal(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if owner != nil {
+				if closeErr := owner.Close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || owner != nil {
+				t.Fatal("explicit incorrect TEXT acquired a typed frame extent", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameDeclaredNoFrameMetadata(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		for _, args := range []string{"", "-0"} {
+			t.Run(target+"/Idle0"+args, func(t *testing.T) {
+				assembly := "TEXT ·Idle(SB),$0" + args + "\nRET\n" +
+					"TEXT ·Value(SB),4,$24-16\nMOVQ a+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+				pkg, request := goAMD64FrameTypedFixture(t, "func Idle()\nfunc Value(a uint64) uint64", assembly)
+				request.Target = target
+				frameRelocationOriginal(t, pkg, request)
+				owner := requireGoAMD64FrameCapture(t, pkg, request)
+				idle, found := owner.functions[pkg.Path+".Idle"]
+				if !found || idle.locals != 0 || idle.privateLeaf || idle.split || len(idle.signature.Frame.Params)+len(idle.signature.Frame.Results) != 0 {
+					t.Fatal("ordinary declared no-frame entry acquired a private or incoming-frame role")
+				}
+				if value := owner.functions[pkg.Path+".Value"]; value.locals != 32 {
+					t.Fatal("framed companion lost its exact independent physical frame")
+				}
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs := make(map[string]FuncSig)
+				for _, name := range []string{"Idle", "Value"} {
+					sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name,
+						pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs[sig.Name] = sig
+				}
+				triple := map[string]string{
+					"linux/amd64":   "x86_64-unknown-linux-gnu",
+					"darwin/amd64":  "x86_64-apple-darwin",
+					"windows/amd64": "x86_64-pc-windows-msvc",
+				}[target]
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				bound, err := owner.BindFixedLocal(ctx, pkg, file, Options{
+					Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+					ResolveSym: func(symbol string) string { return pkg.Path + "." + strings.TrimPrefix(symbol, "·") },
+				})
+				if err != nil {
+					t.Fatal("ordinary no-frame companion did not retain complete source binding", err)
+				}
+				if bound.Sigs[pkg.Path+".Idle"].x86FixedLocal != nil || bound.Sigs[pkg.Path+".Value"].x86FixedLocal == nil {
+					t.Fatal("ordinary no-frame entry borrowed its companion's local backing")
+				}
+			})
+		}
+		for _, args := range []string{"", "-16"} {
+			t.Run(target+"/FPLeaf0"+args, func(t *testing.T) {
+				assembly := "TEXT ·Leaf(SB),$0" + args + "\nMOVQ a+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n" +
+					"TEXT ·Value(SB),4,$24-16\nMOVQ a+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+				pkg, request := goAMD64FrameTypedFixture(t, "func Leaf(a uint64) uint64\nfunc Value(a uint64) uint64", assembly)
+				request.Target = target
+				frameRelocationOriginal(t, pkg, request)
+				sigs := make(map[string]FuncSig)
+				for _, name := range []string{"Leaf", "Value"} {
+					sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, pkg.Types.Scope().Lookup(name).(*types.Func),
+						"amd64", types.SizesFor("gc", "amd64"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs[sig.Name] = sig
+				}
+				triple := map[string]string{
+					"linux/amd64": "x86_64-unknown-linux-gnu", "darwin/amd64": "x86_64-apple-darwin",
+					"windows/amd64": "x86_64-pc-windows-msvc",
+				}[target]
+				fixedLocalFreshAPIs(t, pkg, request, Options{
+					Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+					ResolveSym: func(symbol string) string { return pkg.Path + "." + strings.TrimPrefix(symbol, "·") },
+				}, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("ordinary frameless FP input/result lost its typed declaration", err)
+					}
+					compileLLVMToObject(t, llc, triple, "leaf.ll", "leaf.o", ir)
+					compileLLVMToObject(t, llc, triple, "leaf-o2.ll", "leaf-o2.o", x86MulDivRoundOptimize(t, ir))
+				})
+			})
+		}
+	}
+}
diff --git a/amd64_go_frame_typed_source_test.go b/amd64_go_frame_typed_source_test.go
new file mode 100644
index 000000000..5509ff271
--- /dev/null
+++ b/amd64_go_frame_typed_source_test.go
@@ -0,0 +1,490 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func goAMD64FrameTypedFixture(t *testing.T, declaration, assembly string) (GoPackage, GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	_, request := goAMD64FrameSourceFixture(t)
+	source := []byte("package framefixture\n" + declaration + "\n")
+	filename := filepath.Join(request.Directory, "value.go")
+	if err := os.WriteFile(filename, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, filename, source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check("example.invalid/framefixture", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{file}}, request
+}
+
+func TestGoAMD64FrameTypedSourceSliceObservation(t *testing.T) {
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a []byte, n uint64) uint64", "#include \"textflag.h\"\nTEXT ·Value(SB),NOSPLIT,$160-40\nMOVQ n+24(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+32(FP)\nRET\n")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	fn := source.functions[pkg.Path+".Value"]
+	if fn.args != 40 || fn.locals != 168 || len(fn.signature.Frame.Params) != 4 || fn.signature.Frame.Results[0].Offset != 32 {
+		t.Fatalf("actual slice observation lost complete original ABI0 frame: %+v", fn)
+	}
+	if fn.transport != goAMD64FrameCompositeTransport || fn.languageType == "" {
+		t.Fatal("slice observation lost its nonnumeric transport role")
+	}
+	for i, slot := range fn.signature.Frame.Params[:3] {
+		if slot.Offset != int64(i*8) || slot.Index != 0 || slot.Field != i {
+			t.Fatalf("slice field %d has an invented offset/identity: %+v", i, slot)
+		}
+	}
+	if !errors.Is(source.numericDeclarations(pkg), ErrProbeNeedsContext) {
+		t.Fatal("slice observation entered the numeric-only fixed-local contract")
+	}
+}
+
+func TestGoAMD64FrameTypedSourceActualLayoutMatrix(t *testing.T) {
+	for _, test := range []struct {
+		name, declaration string
+		args              int64
+		params, results   []int64
+		role              goAMD64FrameTransport
+	}{
+		{"integer widths", "func Value(a int8, b uint8, c int16, d uint16, e int32, f uint32, g int64, h uint64, i int, j uint, k uintptr) (r uint64)", 64, []int64{0, 1, 2, 4, 8, 12, 16, 24, 32, 40, 48}, []int64{56}, goAMD64FrameNumericTransport},
+		{"named integer", "type Count uint64\nfunc Value(a Count) Count", 16, []int64{0}, []int64{8}, goAMD64FrameNumericTransport},
+		{"integer alias", "type Count = uint64\nfunc Value(a Count) Count", 16, []int64{0}, []int64{8}, goAMD64FrameNumericTransport},
+		{"pointer", "func Value(a *uint64, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"pointer to array", "func Value(a *[64]byte, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"nested fields", "type Packet struct { Tag byte; Samples [3]int16; Tail uint64 }\nfunc Value(a *Packet, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"nested pointer fields", "type Packet struct { P *[4]uint16; S []uint32 }\nfunc Value(a *Packet, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"named pointer", "type Pointer *uint64\nfunc Value(a Pointer, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"pointer alias", "type Pointer = *uint64\nfunc Value(a Pointer, n uint64) uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"slice integer", "func Value(a []int32, n uint64) uint64", 40, []int64{0, 8, 16, 24}, []int64{32}, goAMD64FrameCompositeTransport},
+		{"slice pointer", "func Value(a []*uint64, n uint64) uint64", 40, []int64{0, 8, 16, 24}, []int64{32}, goAMD64FrameCompositeTransport},
+		{"named slice", "type Bytes []byte\nfunc Value(a Bytes, n uint64) uint64", 40, []int64{0, 8, 16, 24}, []int64{32}, goAMD64FrameCompositeTransport},
+		{"slice alias", "type Bytes = []byte\nfunc Value(a Bytes, n uint64) uint64", 40, []int64{0, 8, 16, 24}, []int64{32}, goAMD64FrameCompositeTransport},
+		{"pointer result", "func Value(a *uint64, n uint64) *uint64", 24, []int64{0, 8}, []int64{16}, goAMD64FrameCompositeTransport},
+		{"slice result", "func Value(a []byte, n uint64) []byte", 56, []int64{0, 8, 16, 24}, []int64{32, 40, 48}, goAMD64FrameCompositeTransport},
+		{"mixed results", "func Value(a *uint64, n int32) (p *uint64, count uint32)", 32, []int64{0, 8}, []int64{16, 24}, goAMD64FrameCompositeTransport},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			// Object capture does not execute the body or claim initialized
+			// results/GC safety. The independent ABI0 offsets are the oracle.
+			assembly := fmt.Sprintf("TEXT ·Value(SB),4,$160-%d\nRET\n", test.args)
+			pkg, request := goAMD64FrameTypedFixture(t, test.declaration, assembly)
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			fn := source.functions[pkg.Path+".Value"]
+			if fn.args != test.args || fn.locals != 168 || fn.transport != test.role || fn.languageType == "" {
+				t.Fatalf("actual object/transport mismatch: %+v", fn)
+			}
+			check := func(slots []FrameSlot, offsets []int64) {
+				t.Helper()
+				if len(slots) != len(offsets) {
+					t.Fatalf("complete ABI0 slots differ: %+v; want %v", slots, offsets)
+				}
+				for i, slot := range slots {
+					if slot.Offset != offsets[i] {
+						t.Fatalf("ABI0 slot %d is %+v; want offset %d", i, slot, offsets[i])
+					}
+				}
+			}
+			check(fn.signature.Frame.Params, test.params)
+			check(fn.signature.Frame.Results, test.results)
+			object := filepath.Join(source.owned, request.AssemblyFile+".o")
+			t.Logf("actual stock-Go observation: target=%s object_sha=%x listing_sha=%x code_bytes=%d args=%d locals=%d transport=%d", request.Target, source.inputs[object], source.inputs[object+".listing"], len(fn.code), fn.args, fn.locals, fn.transport)
+			err := source.numericDeclarations(pkg)
+			if test.role == goAMD64FrameNumericTransport && err != nil || test.role != goAMD64FrameNumericTransport && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("numeric-only consumer role mismatch: %v", err)
+			}
+		})
+	}
+}
+
+func goAMD64FrameTypedSelection(t *testing.T, pkg GoPackage, request GoAMD64FrameCaptureRequest) *GoAMD64FrameSource {
+	t.Helper()
+	// The production capture entry resolves the source root before binding
+	// selection paths. This internal fixture must exercise that same contract,
+	// including temporary-directory aliases supplied by the host OS.
+	canonical, err := filepath.EvalSymlinks(request.Directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	request.Directory = canonical
+	return &GoAMD64FrameSource{
+		request: request, inputs: make(map[string][32]byte),
+		selection: goAMD64FrameSelection{GoFiles: []string{"value.go"}, CompiledGoFiles: []string{filepath.Join(request.Directory, "value.go")}},
+	}
+}
+
+func TestGoAMD64FrameTypedSelectionCanonicalSourceRoot(t *testing.T) {
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a *uint64) uint64", "TEXT ·Value(SB),4,$160-16\nRET\n")
+	canonical, err := filepath.EvalSymlinks(request.Directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := goAMD64FrameTypedSelection(t, pkg, request)
+	if source.request.Directory != canonical || len(source.selection.CompiledGoFiles) != 1 ||
+		source.selection.CompiledGoFiles[0] != filepath.Join(canonical, "value.go") {
+		t.Fatal("typed fixture did not bind the production entry's canonical source root")
+	}
+	if _, err := source.typedDeclarations(pkg, false); err != nil {
+		t.Fatalf("canonical source must reach the independent language check: %v", err)
+	}
+}
+
+func TestGoAMD64FrameTypedSourceLanguageIdentityMutations(t *testing.T) {
+	for _, test := range []struct{ name, original, mutation string }{
+		{"same pointer width", "func Value(a *uint64) uint64", "func Value(a *int64) uint64"},
+		{"slice element", "func Value(a []byte) uint64", "func Value(a []uint16) uint64"},
+		{"slice versus pointer", "func Value(a []byte) uint64", "func Value(a *byte) uint64"},
+		{"array length", "func Value(a *[16]byte) uint64", "func Value(a *[32]byte) uint64"},
+		{"named underlying", "type Count uint64\nfunc Value(a *Count) uint64", "type Count int64\nfunc Value(a *Count) uint64"},
+		{"alias versus named", "type Count = uint64\nfunc Value(a *Count) uint64", "type Count uint64\nfunc Value(a *Count) uint64"},
+		{"alias RHS identity", "type A uint64\ntype B uint64\ntype Choice = A\nfunc Value(a *Choice) uint64", "type A uint64\ntype B uint64\ntype Choice = B\nfunc Value(a *Choice) uint64"},
+		{"field signedness", "type Packet struct { X uint64 }\nfunc Value(a *Packet) uint64", "type Packet struct { X int64 }\nfunc Value(a *Packet) uint64"},
+		{"field identity", "type Packet struct { X uint64 }\nfunc Value(a *Packet) uint64", "type Packet struct { Y uint64 }\nfunc Value(a *Packet) uint64"},
+		{"field order", "type Packet struct { X byte; Y uint64 }\nfunc Value(a *Packet) uint64", "type Packet struct { Y uint64; X byte }\nfunc Value(a *Packet) uint64"},
+		{"field tag", "type Packet struct { X uint64 `a` }\nfunc Value(a *Packet) uint64", "type Packet struct { X uint64 `b` }\nfunc Value(a *Packet) uint64"},
+		{"embedded identity", "type Count uint64\ntype Packet struct { Count }\nfunc Value(a *Packet) uint64", "type Count uint64\ntype Packet struct { Count Count }\nfunc Value(a *Packet) uint64"},
+		{"parameter name", "func Value(a *uint64) uint64", "func Value(b *uint64) uint64"},
+		{"result pointee", "func Value(a *uint64) *uint64", "func Value(a *uint64) *int64"},
+		{
+			"unrelated interface does not hide signedness",
+			"type XOF interface { Clone() XOF }\nfunc Value(a *uint64) uint64",
+			"type XOF interface { Clone() XOF }\nfunc Value(a *int64) uint64",
+		},
+		{
+			"unrelated recursive type does not hide extent",
+			"type Node struct { Next *Node }\nfunc Value(a *[16]byte) uint64",
+			"type Node struct { Next *Node }\nfunc Value(a *[32]byte) uint64",
+		},
+		{
+			"unrelated callback does not hide alias RHS",
+			"type Callback func()\ntype A uint64\ntype B uint64\ntype Choice = A\nfunc Value(a *Choice) uint64",
+			"type Callback func()\ntype A uint64\ntype B uint64\ntype Choice = B\nfunc Value(a *Choice) uint64",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			pkg, request := goAMD64FrameTypedFixture(t, test.original, "TEXT ·Value(SB),4,$160-16\nRET\n")
+			guard := goAMD64FrameTypedSelection(t, pkg, request)
+			if _, err := guard.typedDeclarations(pkg, false); err != nil {
+				t.Fatalf("unmutated independent typecheck failed: %v", err)
+			}
+			if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\n"+test.mutation+"\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			guard.inputs = make(map[string][32]byte)
+			if _, err := guard.typedDeclarations(pkg, false); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("stale supplied type tree accepted actual source mutation: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameTypedSourceUnsupportedRolesRemainContext(t *testing.T) {
+	for _, declaration := range []string{
+		"func Value(a float32) uint64", "func Value(a complex128) uint64",
+		"func Value(a string) uint64", "func Value(a *float64) uint64",
+		"func Value(a map[uint64]uint64) uint64", "func Value(a chan uint64) uint64",
+		"func Value(a func(uint64) uint64) uint64", "func Value(a interface{}) uint64",
+		"func Value(a [2]uint64) uint64", "func Value(a struct { X uint64 }) uint64",
+		"type Node struct { Next *Node }\nfunc Value(a *Node) uint64",
+		"type Node[T any] struct { Value T }\nfunc Value(a *Node[uint64]) uint64",
+		"func Value[T ~uint64](a T) uint64 { return uint64(a) }", "func Value(a ...uint64) uint64",
+		"func Value(a *uint64) uint64 { return *a }",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			pkg, request := goAMD64FrameTypedFixture(t, declaration, "TEXT ·Value(SB),4,$160-16\nRET\n")
+			guard := goAMD64FrameTypedSelection(t, pkg, request)
+			_, err := guard.typedDeclarations(pkg, false)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown/GC/aggregate role did not retain Context: %v", err)
+			}
+			if strings.Contains(err.Error(), "input path is redirected or inaccessible") {
+				t.Fatalf("path rejection cannot prove an unsupported language role: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameTypedSourceOrdinaryPointerValueIsObservationOnly(t *testing.T) {
+	pkg, request := goAMD64FrameTypedFixture(t,
+		"var P *uint64\nfunc Value(a *uint64) uint64",
+		"TEXT ·Value(SB),4,$160-16\nRET\n")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	if len(source.functions) != 1 || len(source.declarations) != 1 {
+		t.Fatal("ordinary pointer value created an additional frame capability")
+	}
+	function := source.functions[pkg.Path+".Value"]
+	if function.transport != goAMD64FrameCompositeTransport || function.args != 16 {
+		t.Fatalf("original pointer declaration lost its separate observation role: %+v", function)
+	}
+	if !errors.Is(source.numericDeclarations(pkg), ErrProbeNeedsContext) {
+		t.Fatal("ordinary pointer value or declaration entered numeric-only fixed-local admission")
+	}
+}
+
+func TestGoAMD64FrameTypedSourceActualCaptureRejectsStalePointee(t *testing.T) {
+	for _, test := range []struct{ original, mutation string }{
+		{"func Value(a *uint64) uint64", "func Value(a *int64) uint64"},
+		{"type Packet struct { X [4]byte }\nfunc Value(a *Packet) uint64", "type Packet struct { X [8]byte }\nfunc Value(a *Packet) uint64"},
+		{"type A uint64\ntype B uint64\ntype Choice = A\nfunc Value(a *Choice) uint64", "type A uint64\ntype B uint64\ntype Choice = B\nfunc Value(a *Choice) uint64"},
+	} {
+		t.Run(test.mutation, func(t *testing.T) {
+			pkg, request := goAMD64FrameTypedFixture(t, test.original, "TEXT ·Value(SB),4,$160-16\nRET\n")
+			if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\n"+test.mutation+"\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("actual compiler export accepted stale supplied language identity: %v", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameTypedSourceLanguageBounds(t *testing.T) {
+	sizes := types.SizesFor("gc", "amd64")
+	constraint := types.NewInterfaceType(nil, nil).Complete()
+	parameter := types.NewTypeParam(types.NewTypeName(token.NoPos, nil, "T", nil), constraint)
+	for _, typ := range []types.Type{nil, parameter, types.Typ[types.UntypedInt], types.Typ[types.Float64], types.NewMap(types.Typ[types.Uint64], types.Typ[types.Uint64])} {
+		if _, err := goAMD64FrameLanguageType(typ, sizes); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unknown language role did not fail closed: %v", err)
+		}
+	}
+	deep := types.Type(types.Typ[types.Uint64])
+	for i := 0; i < 34; i++ {
+		deep = types.NewPointer(deep)
+	}
+	fields := make([]*types.Var, 4097)
+	for i := range fields {
+		fields[i] = types.NewVar(token.NoPos, nil, fmt.Sprintf("F%d", i), types.Typ[types.Uint64])
+	}
+	for _, typ := range []types.Type{deep, types.NewStruct(fields, nil), types.NewArray(types.Typ[types.Uint64], 1<<62)} {
+		if _, err := goAMD64FrameLanguageType(typ, sizes); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unbounded or overflowing type obtained an observation: %v", err)
+		}
+	}
+	large := types.NewArray(types.Typ[types.Uint8], 1<<62)
+	fields = []*types.Var{
+		types.NewVar(token.NoPos, nil, "A", large),
+		types.NewVar(token.NoPos, nil, "B", large),
+	}
+	if _, err := goAMD64FrameLanguageType(types.NewStruct(fields, nil), sizes); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("aggregate size overflow was recorded as a layout: %v", err)
+	}
+	if _, err := goAMD64FrameLanguageType(types.Typ[types.Uint64], nil); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("missing target sizes were treated as a layout")
+	}
+}
+
+func TestGoAMD64FrameTypedSourceMissingSignatureRemainsContext(t *testing.T) {
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a []byte) uint64", "TEXT ·Value(SB),4,$160-32\nRET\n")
+	pkg.Types = types.NewPackage(pkg.Path, "framefixture")
+	pkg.Types.Scope().Insert(types.NewFunc(token.NoPos, pkg.Types, "Value", nil))
+	guard := goAMD64FrameTypedSelection(t, pkg, request)
+	if _, err := guard.typedDeclarations(pkg, false); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("missing supplied typed signature did not retain Context: %v", err)
+	}
+}
+
+func TestGoAMD64FrameTypedSourceMutationAndCloseRevocation(t *testing.T) {
+	for _, change := range []string{"source", "object", "header inventory", "cancel", "close"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, request := goAMD64FrameTypedFixture(t, "func Value(a []byte, n uint64) uint64", "TEXT ·Value(SB),4,$160-40\nRET\n")
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			switch change {
+			case "source":
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package framefixture\nfunc Value(a []uint16, n uint64) uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "object":
+				if err := os.WriteFile(filepath.Join(source.owned, request.AssemblyFile+".o"), []byte("not the original object"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "header inventory":
+				if err := os.WriteFile(filepath.Join(request.Directory, "late.h"), []byte("#define NEW 1\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "cancel":
+				cancel()
+			case "close":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.Verify(ctx); err == nil {
+				t.Fatal("changed/closed composite source retained its observation")
+			}
+			if !errors.Is(source.Verify(context.Background()), ErrProbeNeedsContext) {
+				t.Fatal("failed composite Verify did not permanently revoke the token")
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameTypedSourceNoMemoryPermissionInThreeAPIs(t *testing.T) {
+	assembly := "TEXT ·Value(SB),4,$160-40\nPXOR X0,X0\nMOVOU X0,16(SP)\nPADDQ 16(SP),X0\nRET\n"
+	pkg, request := goAMD64FrameTypedFixture(t, "func Value(a []byte, n uint64) uint64", assembly)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	sig := source.functions[pkg.Path+".Value"].signature
+	if !errors.Is(source.numericDeclarations(pkg), ErrProbeNeedsContext) {
+		t.Fatal("composite observation entered fixed-local numeric transport")
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) }
+	opt := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: map[string]FuncSig{sig.Name: sig}}
+	for _, api := range []string{"Translate", "TranslateModuleInContext", "TranslateGoModule"} {
+		t.Run(api, func(t *testing.T) {
+			var err error
+			switch api {
+			case "Translate":
+				_, err = Translate(file, opt)
+			case "TranslateModuleInContext":
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, failure := TranslateModuleInContext(ctx, file, opt)
+				err = failure
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+			case "TranslateGoModule":
+				translation, failure := TranslateGoModule(pkg, []byte(assembly), GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: opt.TargetTriple, ResolveSym: resolve})
+				err = failure
+				if translation != nil && !translation.Module.IsNil() {
+					defer translation.Module.Dispose()
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("sealed observation alone granted native local memory: %v", err)
+			}
+		})
+	}
+	encoded, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var restored GoAMD64FrameSource
+	if err := json.Unmarshal(encoded, &restored); err != nil || !errors.Is(restored.Verify(context.Background()), ErrProbeNeedsContext) {
+		t.Fatalf("public JSON recreated a composite observation: %v", err)
+	}
+	if !reflect.DeepEqual(source.declarations[sig.Name].signature, sig) {
+		t.Fatal("object signature diverged from independently typed declaration")
+	}
+}
+
+type goAMD64FrameLayoutCounter struct {
+	types.Sizes
+	structCalls int
+}
+
+func (counter *goAMD64FrameLayoutCounter) Sizeof(typ types.Type) int64 {
+	if _, ok := typ.(*types.Struct); ok {
+		counter.structCalls++
+	}
+	return counter.Sizes.Sizeof(typ)
+}
+
+func TestGoAMD64FrameTypedSourceMetadataByteBoundBeforeLayout(t *testing.T) {
+	for _, field := range []string{"name", "tag", "package"} {
+		t.Run(field, func(t *testing.T) {
+			name, tag := "Value", ""
+			pkg := types.NewPackage("example.invalid/model", "model")
+			switch field {
+			case "name":
+				name = strings.Repeat("x", 64<<10+1)
+			case "tag":
+				tag = strings.Repeat("x", 64<<10+1)
+			case "package":
+				pkg = types.NewPackage("example.invalid/"+strings.Repeat("x", 64<<10+1), "model")
+			}
+			field := types.NewVar(token.NoPos, pkg, name, types.Typ[types.Uint64])
+			structure := types.NewStruct([]*types.Var{field}, []string{tag})
+			counter := &goAMD64FrameLayoutCounter{Sizes: types.SizesFor("gc", "amd64")}
+			if _, err := goAMD64FrameLanguageType(structure, counter); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized field metadata was recorded: %v", err)
+			}
+			if counter.structCalls != 0 {
+				t.Fatalf("aggregate layout continued after metadata exceeded its bound: %d calls", counter.structCalls)
+			}
+		})
+	}
+}
+
+func TestGoAMD64FrameTypedSourcePointeeModelIsNotMachineExtent(t *testing.T) {
+	declaration := `type Packet struct { X uint64; Y byte }
+type EmptyTail struct { X uint64; Y struct{} }
+func Value(a *Packet, b *EmptyTail, n uint64) uint64`
+	pkg, request := goAMD64FrameTypedFixture(t, declaration, "TEXT ·Value(SB),4,$160-32\nRET\n")
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	header := filepath.Join(source.owned, "pointee-layout.h")
+	archive := filepath.Join(source.owned, "pointee-layout.a")
+	if _, err := source.run(ctx, "tool", "compile", "-p", pkg.Path, "-asmhdr", header, "-o", archive, "value.go"); err != nil {
+		t.Fatal(err)
+	}
+	data, err := source.read(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if data, err := source.read(archive); err != nil || len(data) == 0 {
+		t.Fatalf("actual original compiler archive missing: %v", err)
+	}
+	definitions := make(map[string]string)
+	for _, line := range strings.Split(string(data), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 3 && fields[0] == "#define" {
+			if _, duplicate := definitions[fields[1]]; duplicate {
+				t.Fatalf("duplicate original machine definition: %s", line)
+			}
+			definitions[fields[1]] = fields[2]
+		}
+	}
+	fn := source.functions[pkg.Path+".Value"]
+	for _, name := range []string{"Packet", "EmptyTail"} {
+		// This is the independently observed machine definition. The
+		// capture descriptor is deliberately only the go/types model.
+		if definitions[name+"__size"] != "16" || definitions[name+"_X"] != "0" || definitions[name+"_Y"] != "8" {
+			t.Fatalf("unexpected actual compiler padded layout for %s: %v", name, definitions)
+		}
+		typ := pkg.Types.Scope().Lookup(name).Type()
+		model := types.SizesFor("gc", "amd64").Sizeof(typ)
+		identity, err := goAMD64FrameLanguageType(typ, types.SizesFor("gc", "amd64"))
+		if err != nil || !strings.Contains(fn.languageType, identity) {
+			t.Fatalf("missing independent language model: %v", err)
+		}
+		t.Logf("%s: recorded go/types model=%d; independently observed stock-Go machine size=16", name, model)
+	}
+	if fn.transport != goAMD64FrameCompositeTransport || !errors.Is(source.numericDeclarations(pkg), ErrProbeNeedsContext) {
+		t.Fatal("language model was used as a numeric backing/pointee permission")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_go_legacy_metadata_roles_test.go b/amd64_go_legacy_metadata_roles_test.go
new file mode 100644
index 000000000..84bda8116
--- /dev/null
+++ b/amd64_go_legacy_metadata_roles_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+func TestGoAMD64LegacyDeclarationMetadataRoles(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(t.TempDir(), "legacy.mod")
+	member := filepath.Join(root, "go.mod")
+	for _, name := range []string{metadata, member} {
+		if err := os.WriteFile(name, []byte("module example.invalid/legacy\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	metadata, err = filepath.EvalSymlinks(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := gooriginalsrc.Module{Root: root, ModulePath: "example.invalid/legacy",
+		SourceModule: "example.invalid/legacy", SourceVersion: "v1.0.0", GoMod: metadata,
+		GoModOrigin: golegacymod.ProxyGoModProtocol}
+	for _, role := range []string{"dependency", "invented member", "main"} {
+		t.Run(role, func(t *testing.T) {
+			data, err := json.Marshal(map[string]any{
+				"Dir": root, "ImportPath": original.ModulePath,
+				"Module": map[string]any{"Path": original.ModulePath, "Version": original.SourceVersion,
+					"Dir": root, "GoMod": metadata},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			var selected goAMD64FrameSelection
+			if err := json.Unmarshal(data, &selected); err != nil {
+				t.Fatal(err)
+			}
+			// Predicate data only, deliberately not an actual whole-ZIP origin
+			// or frame token. The duplicate member tests source-role confusion.
+			source := &GoAMD64FrameSource{downloadedOrigin: &gooriginalsrc.OriginSet{}, downloadedModule: &original,
+				downloadedImports: map[string]gooriginalsrc.Module{original.ModulePath + "@" + original.SourceVersion: original}}
+			if role == "invented member" {
+				selected.Module.GoMod = member
+			}
+			if role == "main" {
+				selected.Module.Main = true
+				selected.Module.Version, selected.Module.GoVersion = "", "1.16"
+			}
+			_, err = source.downloadedDeclarationDirectory(selected)
+			if role == "dependency" && err != nil || role != "dependency" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("legacy metadata lost its exact dependency-only origin", err)
+			}
+			if err := source.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("module predicate data manufactured frame authority", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_native_header.go b/amd64_go_native_header.go
new file mode 100644
index 000000000..ab76e0cf7
--- /dev/null
+++ b/amd64_go_native_header.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"regexp"
+	"strconv"
+)
+
+// This is listing metadata, not native entry, local backing or ABI authority.
+// Preserve absent fields and the two official writer alignment positions.
+type goAMD64NativeHeader struct {
+	Symbol                                             string
+	Kind                                               uint8
+	Static, DupOK, CFunc, NoSplit, TopFrame, ASM, Leaf bool
+	Size, Locals, Align                                uint64
+	Args                                               int64
+	ArgsKnown, HasAlign, HasFuncID, LegacyAlign        bool
+	FuncID                                             uint8
+}
+
+var goAMD64NativeHeaderPattern = regexp.MustCompile(`^(\S+) (STEXT|STEXTFIPS)(?: (static))?(?: (dupok))?(?: (cfunc))?(?: (nosplit))?(?: (topframe))?(?: (asm))? size=([0-9]+)(?: align=0x([0-9a-f]+))? args=0x([0-9a-f]+) locals=0x([0-9a-f]+)(?: funcid=0x([0-9a-f]+))?(?: align=0x([0-9a-f]+))?(?: (leaf))?$`)
+
+func parseGoAMD64NativeHeader(line string) (goAMD64NativeHeader, bool) {
+	var header goAMD64NativeHeader
+	fields := goAMD64NativeHeaderPattern.FindStringSubmatch(line)
+	if fields == nil || fields[10] != "" && fields[14] != "" {
+		return header, false
+	}
+	size, sizeErr := strconv.ParseUint(fields[9], 10, 63)
+	args, argsErr := strconv.ParseUint(fields[11], 16, 64)
+	locals, localsErr := goAMD64FrameSignedLocals(fields[12])
+	if sizeErr != nil || argsErr != nil || localsErr != nil || uint64(int64(int32(args))) != args ||
+		int64(args) < 0 && int64(args) != -0x80000000 {
+		return header, false
+	}
+	header = goAMD64NativeHeader{Symbol: fields[1], Kind: 1, Static: fields[3] != "", DupOK: fields[4] != "",
+		CFunc: fields[5] != "", NoSplit: fields[6] != "", TopFrame: fields[7] != "", ASM: fields[8] != "", Leaf: fields[15] != "",
+		Size: size, Args: int64(args), Locals: uint64(locals), ArgsKnown: int64(args) != -0x80000000,
+		HasAlign: fields[10] != "" || fields[14] != "", HasFuncID: fields[13] != "", LegacyAlign: fields[14] != ""}
+	if fields[2] == "STEXTFIPS" {
+		header.Kind = 2
+	}
+	if header.HasFuncID {
+		funcID, err := strconv.ParseUint(fields[13], 16, 8)
+		if err != nil {
+			return goAMD64NativeHeader{}, false
+		}
+		header.FuncID = uint8(funcID)
+	}
+	if header.HasAlign {
+		raw, bits := fields[10], 15 // Current LSym.Align is a nonnegative int16.
+		if header.LegacyAlign {
+			raw, bits = fields[14], 31 // Older FuncInfo.Align is int32.
+		}
+		align, err := strconv.ParseUint(raw, 16, bits)
+		if err != nil {
+			return goAMD64NativeHeader{}, false
+		}
+		header.Align = align
+	}
+	return header, true
+}
+
+func (header goAMD64NativeHeader) objectFlags() uint8 {
+	var flags uint8
+	if header.DupOK {
+		flags |= 0x01
+	}
+	if header.Leaf {
+		flags |= 0x08
+	}
+	if header.NoSplit {
+		flags |= 0x10
+	}
+	return flags
+}
+
+// Special runtime/linker roles remain observations, outside the existing
+// ordinary ABI0 and same-source private leaf entry contracts.
+func (header goAMD64NativeHeader) ordinaryFrameRole() bool {
+	return header.ASM && header.HasFuncID && header.FuncID == 0 &&
+		!header.DupOK && !header.CFunc && !header.TopFrame && !header.Leaf
+}
diff --git a/amd64_go_native_header_grammar_go127_test.go b/amd64_go_native_header_grammar_go127_test.go
new file mode 100644
index 000000000..3c5c8fd93
--- /dev/null
+++ b/amd64_go_native_header_grammar_go127_test.go
@@ -0,0 +1,88 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestSDKAMD64NativeHeaderActualGoAttributes(t *testing.T) {
+	_, profile, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	sdk := filepath.Dir(filepath.Dir(profile.GoBinary))
+	builtin, err := os.ReadFile(filepath.Join(sdk, "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Decimal flags are independent official TEXT values: DUPOK=2,
+	// NOSPLIT=4, TOPFRAME=2048. These are metadata objects, not entries.
+	const source = `TEXT ·Ordinary(SB),4,$16-0
+	RET
+TEXT ·Duplicate(SB),6,$16-0
+	RET
+TEXT ·Top(SB),2052,$16-0
+	RET
+TEXT private<>(SB),4,$0-0
+	RET
+TEXT ·Combined(SB),2054,$16-0
+	RET
+TEXT crypto∕internal∕fips140∕headerfixture·FIPS(SB),2054,$16-0
+	RET
+TEXT runtime·goexit(SB),2052,$0-0
+	RET
+`
+	input := filepath.Join(profile.Directory, "header-attributes.s")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			env := append([]string(nil), profile.Environment...)
+			for index, pair := range env {
+				if strings.HasPrefix(pair, "GOOS=") {
+					env[index] = "GOOS=" + goos
+				}
+			}
+			objectPath := filepath.Join(t.TempDir(), "header-attributes.o")
+			listing, err := goasmcmd.Run(ctx, profile.Directory, env, profile.GoBinary,
+				"tool", "asm", "-p", "headerfixture", "-S", "-o", objectPath, input)
+			if err != nil {
+				t.Fatal("actual Go assembler precondition", err)
+			}
+			object, err := os.ReadFile(objectPath)
+			if err != nil || len(object) == 0 {
+				t.Fatal("actual complete Go object precondition", err)
+			}
+			observed, err := gostaticstorage.ObserveAMD64AssemblyData([]byte(source), object, builtin, "headerfixture", goos+"/amd64")
+			if err != nil || len(observed.Member.Texts) != 7 || len(observed.TextOrder) != 7 {
+				t.Fatal("complete original source/object association precondition", err)
+			}
+			if !bytes.Contains(listing, []byte(" dupok ")) || !bytes.Contains(listing, []byte(" topframe ")) ||
+				bytes.Count(listing, []byte(" STEXTFIPS ")) != 1 {
+				t.Fatalf("actual Go did not emit the independent attribute/kind priors:\n%s", listing)
+			}
+			records, err := sdkAMD64FrameNativeRecordsForSource(listing, observed.Member.Texts, observed.TextOrder)
+			if err != nil || len(records) != 7 {
+				t.Fatal("complete actual native headers lost their object associations", err)
+			}
+			for index, record := range records {
+				locals := uint64(24)
+				if index == 3 || index == 6 {
+					locals = 0
+				}
+				if record.Symbol != observed.TextOrder[index].Name || record.Static != (index == 3) ||
+					!record.NoSplit || !record.ASM || !record.ArgsKnown || record.Args != 0 || record.Locals != locals {
+					t.Fatal("actual header changed independent symbol/frame/argument metadata", index, record)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_native_header_grammar_test.go b/amd64_go_native_header_grammar_test.go
new file mode 100644
index 000000000..6a8764740
--- /dev/null
+++ b/amd64_go_native_header_grammar_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These are format/object-field observations, not captured source permissions.
+func nativeHeaderFixture(header string, kind, flags uint8, abi uint16) ([]byte, []gostaticstorage.TextRecord, []gostaticstorage.ASMSourceText) {
+	namespace := gostaticstorage.TextSymbolNonpkgDefinition
+	if abi == 65535 {
+		namespace = gostaticstorage.TextSymbolSelf
+	}
+	text := gostaticstorage.TextRecord{Name: "fixture.Entry", ABI: abi, Namespace: namespace,
+		Kind: kind, Flags: flags, Size: 1, Code: []byte{0xc3}}
+	order := gostaticstorage.ASMSourceText{SourceOrdinal: 0, ObjectOrdinal: 0, Name: text.Name,
+		ABI: abi, Namespace: namespace}
+	return []byte(header + "\n"), []gostaticstorage.TextRecord{text}, []gostaticstorage.ASMSourceText{order}
+}
+
+func nativeHeaderRecord(t *testing.T, header string, kind, flags uint8, abi uint16) sdkAMD64FrameNativeRecord {
+	t.Helper()
+	listing, texts, order := nativeHeaderFixture(header, kind, flags, abi)
+	before := append([]gostaticstorage.TextRecord(nil), texts...)
+	before[0].Code = append([]byte(nil), texts[0].Code...)
+	records, err := sdkAMD64FrameNativeRecordsForSource(listing, texts, order)
+	if err != nil || len(records) != 1 {
+		t.Fatalf("complete writer header lost its object association: records=%v error=%v header=%q", records, err, header)
+	}
+	if !reflect.DeepEqual(texts, before) || records[0].Symbol != "fixture.Entry" || records[0].Size != 1 {
+		t.Fatal("header parsing rewrote the original object or identity", records)
+	}
+	return records[0]
+}
+
+const nativeHeaderCurrent = "fixture.Entry STEXT nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0"
+
+func TestSDKAMD64NativeHeaderCompleteWriterForms(t *testing.T) {
+	for _, row := range []struct {
+		name, attributes, tail string
+		kind, flags            uint8
+		abi                    uint16
+	}{
+		{"current", "nosplit asm", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, 0x10, 0},
+		{"legacy", "nosplit asm", "size=1 args=0x0 locals=0x0 funcid=0x0 align=0x0", 1, 0x10, 0},
+		{"minimal-diagnostic", "asm", "size=1 args=0x0 locals=0x0", 1, 0, 0},
+		{"static", "static nosplit asm", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, 0x10, 65535},
+		{"dupok", "dupok nosplit asm", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, 0x11, 0},
+		{"cfunc", "cfunc nosplit", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, 0x10, 0},
+		{"topframe", "nosplit topframe asm", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, 0x10, 0},
+		{"leaf", "nosplit asm", "size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0 leaf", 1, 0x18, 0},
+		{"all-current", "static dupok cfunc nosplit topframe asm", "size=1 align=0x0 args=0xffffffff80000000 locals=0xfffffffffffffff8 funcid=0xff leaf", 2, 0x19, 65535},
+		{"all-legacy-format", "static dupok cfunc nosplit topframe asm", "size=1 args=0xffffffff80000000 locals=0xfffffffffffffff8 funcid=0xff align=0x0 leaf", 2, 0x19, 65535},
+		{"current-width-boundaries", "nosplit asm", "size=1 align=0x7fff args=0x7fffffff locals=0x7fffffff funcid=0xff", 1, 0x10, 0},
+		{"legacy-width-boundaries", "nosplit asm", "size=1 args=0x7fffffff locals=0x7fffffff funcid=0xff align=0x7fffffff", 1, 0x10, 0},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			kind := "STEXT"
+			if row.kind == 2 {
+				kind = "STEXTFIPS"
+			}
+			header := "fixture.Entry " + kind + " " + row.attributes + " " + row.tail
+			record := nativeHeaderRecord(t, header, row.kind, row.flags, row.abi)
+			if record.Static != (row.abi == 65535) || record.NoSplit != (row.flags&0x10 != 0) ||
+				record.ASM != strings.Contains(" "+row.attributes+" ", " asm ") {
+				t.Fatal("independent native attributes changed", record)
+			}
+			if strings.Contains(row.tail, "locals=0xfffffffffffffff8") &&
+				(record.Locals != ^uint64(7) || record.ArgsKnown || record.Args != -0x80000000) {
+				t.Fatal("writer attributes changed signed locals or the independent argument sentinel", record)
+			}
+			if strings.Contains(row.tail, "args=0x7fffffff") {
+				align := uint64(0x7fff)
+				if row.name == "legacy-width-boundaries" {
+					align = 0x7fffffff
+				}
+				if !record.ArgsKnown || record.Args != 0x7fffffff || record.Locals != 0x7fffffff ||
+					!record.HasFuncID || record.FuncID != 0xff || !record.HasAlign || record.Align != align {
+					t.Fatal("official writer numeric boundary metadata changed", record)
+				}
+			}
+		})
+	}
+}
+
+func TestSDKAMD64NativeHeaderRetainsObservedMetadata(t *testing.T) {
+	base := nativeHeaderRecord(t, nativeHeaderCurrent, 1, 0x10, 0)
+	for _, row := range []struct {
+		name, header string
+		kind, flags  uint8
+	}{
+		{"kind", strings.Replace(nativeHeaderCurrent, "STEXT", "STEXTFIPS", 1), 2, 0x10},
+		{"dupok", strings.Replace(nativeHeaderCurrent, " nosplit", " dupok nosplit", 1), 1, 0x11},
+		{"cfunc", strings.Replace(nativeHeaderCurrent, " nosplit", " cfunc nosplit", 1), 1, 0x10},
+		{"topframe", strings.Replace(nativeHeaderCurrent, " asm", " topframe asm", 1), 1, 0x10},
+		{"leaf", nativeHeaderCurrent + " leaf", 1, 0x18},
+		{"funcid", strings.Replace(nativeHeaderCurrent, "funcid=0x0", "funcid=0x1", 1), 1, 0x10},
+		{"alignment", strings.Replace(nativeHeaderCurrent, "align=0x0", "align=0x4", 1), 1, 0x10},
+		{"absent-funcid", strings.Replace(nativeHeaderCurrent, " funcid=0x0", "", 1), 1, 0x10},
+		{"absent-alignment", strings.Replace(nativeHeaderCurrent, " align=0x0", "", 1), 1, 0x10},
+		{"legacy-alignment-position", "fixture.Entry STEXT nosplit asm size=1 args=0x0 locals=0x0 funcid=0x0 align=0x0", 1, 0x10},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			changed := nativeHeaderRecord(t, row.header, row.kind, row.flags, 0)
+			if reflect.DeepEqual(base, changed) {
+				t.Fatal("distinct observed native metadata was discarded", row.name, base)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64NativeHeaderRejectsMalformedWriterForms(t *testing.T) {
+	for _, header := range []string{
+		strings.Replace(nativeHeaderCurrent, " nosplit", " nosplit nosplit", 1),
+		strings.Replace(nativeHeaderCurrent, "nosplit asm", "asm nosplit", 1),
+		strings.Replace(nativeHeaderCurrent, "nosplit asm", "nosplit dupok asm", 1),
+		strings.Replace(nativeHeaderCurrent, "nosplit asm", "nosplit asm topframe", 1),
+		strings.Replace(nativeHeaderCurrent, " nosplit", " foreign nosplit", 1),
+		strings.Replace(nativeHeaderCurrent, " nosplit", " noframe nosplit", 1),
+		strings.Replace(nativeHeaderCurrent, "STEXT", "STEXTFOREIGN", 1),
+		nativeHeaderCurrent + " leaf leaf",
+		nativeHeaderCurrent + " junk",
+		nativeHeaderCurrent + " align=0x0",
+		strings.Replace(nativeHeaderCurrent, "size=1", "size=1 size=1", 1),
+		strings.Replace(nativeHeaderCurrent, "size=1", "size=9223372036854775808", 1),
+		strings.Replace(nativeHeaderCurrent, "args=0x0", "args=0x80000000", 1),
+		strings.Replace(nativeHeaderCurrent, "args=0x0", "args=0xffffffff", 1),
+		strings.Replace(nativeHeaderCurrent, "args=0x0", "args=0xffffffffffffffff", 1),
+		strings.Replace(nativeHeaderCurrent, "locals=0x0", "locals=0x80000000", 1),
+		strings.Replace(nativeHeaderCurrent, "locals=0x0", "locals=0x10000000000000000", 1),
+		strings.Replace(nativeHeaderCurrent, "funcid=0x0", "funcid=0x100", 1),
+		strings.Replace(nativeHeaderCurrent, "align=0x0", "align=0x8000", 1),
+		"fixture.Entry STEXT nosplit asm size=1 args=0x0 locals=0x0 funcid=0x0 align=0x80000000",
+	} {
+		t.Run(header, func(t *testing.T) {
+			listing, texts, order := nativeHeaderFixture(header, 1, 0x10, 0)
+			if _, err := sdkAMD64FrameNativeRecordsForSource(listing, texts, order); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("malformed or out-of-range header acquired metadata", header, err)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64NativeHeaderObjectAttributeIdentity(t *testing.T) {
+	for _, row := range []struct {
+		name, attributes, tail string
+		mask                   uint8
+	}{
+		{"dupok", "dupok nosplit asm", "", 0x01},
+		{"nosplit", "nosplit asm", "", 0x10},
+		{"leaf", "nosplit asm", " leaf", 0x08},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			header := "fixture.Entry STEXT " + row.attributes + " size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0" + row.tail
+			flags := uint8(0x10) | row.mask
+			nativeHeaderRecord(t, header, 1, flags, 0)
+			listing, texts, order := nativeHeaderFixture(header, 1, flags^row.mask, 0)
+			if _, err := sdkAMD64FrameNativeRecordsForSource(listing, texts, order); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("header borrowed a different actual object attribute", row.name, err)
+			}
+		})
+	}
+	for _, mask := range []uint8{0x01, 0x08, 0x10} {
+		listing, texts, order := nativeHeaderFixture("fixture.Entry STEXT asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0", 1, mask, 0)
+		if _, err := sdkAMD64FrameNativeRecordsForSource(listing, texts, order); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unprinted object attribute was silently ignored", mask, err)
+		}
+	}
+}
+
+func TestGoAMD64FrameSplitSelectorUsesCompleteWriterHeader(t *testing.T) {
+	for _, attributes := range []string{"asm", "dupok asm", "cfunc asm", "topframe asm", "static dupok cfunc topframe asm"} {
+		t.Run(attributes, func(t *testing.T) {
+			header := "fixture.Entry STEXT " + attributes + " size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0\n"
+			if !goAMD64FrameSplitListing([]byte(header)) {
+				t.Fatal("complete split header disappeared before its later role check", header)
+			}
+			nosplit := strings.Replace(header, " asm ", " nosplit asm ", 1)
+			if strings.Contains(attributes, "topframe") {
+				nosplit = strings.Replace(header, " topframe ", " nosplit topframe ", 1)
+			}
+			if goAMD64FrameSplitListing([]byte(nosplit)) {
+				t.Fatal("NOSPLIT metadata was interpreted as split entry permission", nosplit)
+			}
+		})
+	}
+}
diff --git a/amd64_go_native_header_roles_test.go b/amd64_go_native_header_roles_test.go
new file mode 100644
index 000000000..79c5ae007
--- /dev/null
+++ b/amd64_go_native_header_roles_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Keep the complete actual listing and change only one independently named
+// writer role. Attribute parsing must not authorize a different entry contract.
+func nativeHeaderRoleChanges() []struct{ name, before, after string } {
+	return []struct{ name, before, after string }{
+		{"dupok", " nosplit", " dupok nosplit"},
+		{"cfunc", " nosplit", " cfunc nosplit"},
+		{"topframe", " asm", " topframe asm"},
+		{"leaf", "", " leaf"},
+		{"funcid", "funcid=0x0", "funcid=0x1"},
+		{"missing-funcid", " funcid=0x0", ""},
+		{"missing-asm", " asm", ""},
+	}
+}
+
+func nativeHeaderChangedRole(header, before, after string) string {
+	if before == "" {
+		return header + after
+	}
+	return strings.Replace(header, before, after, 1)
+}
+
+func TestGoAMD64NativeHeaderSpecialRolesKeepEntryContext(t *testing.T) {
+	pkg, request := goAMD64FrameSourceFixture(t)
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	listing, err := os.ReadFile(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := source.preprocess(request.AssemblyFile, raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := goAMD64FrameListing(listing, file, pkg, source.origins); err != nil {
+		t.Fatal("complete original ordinary listing positive", err)
+	}
+	header, body, found := bytes.Cut(listing, []byte{'\n'})
+	if !found {
+		t.Fatal("actual listing lacks its complete header")
+	}
+	for _, change := range nativeHeaderRoleChanges() {
+		t.Run(change.name, func(t *testing.T) {
+			if !strings.Contains(string(header), change.before) {
+				t.Fatal("actual ordinary header precondition changed", string(header))
+			}
+			changed := nativeHeaderChangedRole(string(header), change.before, change.after)
+			mutated := []byte(changed + "\n" + string(body))
+			if _, err := goAMD64FrameListing(mutated, file, pkg, source.origins); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("observed special or unknown header role acquired ordinary entry authority", err)
+			}
+		})
+	}
+}
+
+func TestGoAMD64NativeHeaderActualSpecialRolesStayContext(t *testing.T) {
+	for _, row := range []struct{ name, flags string }{
+		{"dupok", "6"},
+		{"topframe", "2052"},
+		{"wrapper-funcid", "36"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, request := goAMD64FrameSourceFixture(t)
+			path := filepath.Join(request.Directory, request.AssemblyFile)
+			raw, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Official TEXT bits: NOSPLIT=4, DUPOK=2, WRAPPER=32,
+			// TOPFRAME=2048. Keep every original body instruction.
+			assembly := strings.Replace(string(raw), "#include \"textflag.h\"\n", "", 1)
+			assembly = strings.Replace(assembly, "NOSPLIT", row.flags, 1)
+			x86InsertExtractGoListing(t, "amd64", assembly)
+			if err := os.WriteFile(path, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if owner != nil {
+				if closeErr := owner.Close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("actual Go special role acquired ordinary fixed-local entry authority", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_sdk_frame_binding_go127_test.go b/amd64_go_sdk_frame_binding_go127_test.go
new file mode 100644
index 000000000..87dcc75bb
--- /dev/null
+++ b/amd64_go_sdk_frame_binding_go127_test.go
@@ -0,0 +1,174 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64SDKFrameReadonlyDataComposition(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/internal/fips140/sha512")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	pkg := sdkAMD64FrameActualPackage(t, observed.source)
+	source, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: "sha512block_amd64.s",
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("complete original frame and readonly DATA observation", err)
+	}
+	defer source.Close()
+	expanded := source.sdkFrame.owner.source.observation.CPP[0].Output
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil || len(file.Globl) == 0 || len(file.Funcs) != len(source.functions) {
+		t.Fatal("complete original source inventory", err)
+	}
+	resolve := func(symbol string) string { return pkg.Path + "." + strings.TrimPrefix(symbol, "·") }
+	source.mu.Lock()
+	data, names, err := source.fixedLocalData(file, expanded, resolve)
+	source.mu.Unlock()
+	if err != nil || len(data) != len(file.Globl) || len(names) != len(file.Globl) {
+		t.Fatal("readonly DATA lost its same-source extent/symbol projection", err)
+	}
+	for _, changed := range []struct{ name, expanded string }{
+		{"missing_amd64.s", expanded},
+		{source.request.AssemblyFile, expanded + "\n"},
+	} {
+		if _, err := source.fixedLocalDataObservation(changed.name, changed.expanded); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unmatched source borrowed the complete SDK DATA observation", err)
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete live frame/DATA source", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("closed frame/DATA source revived", err)
+	}
+	t.Logf("%d complete source functions and %d readonly definitions; not a full translation result", len(file.Funcs), len(data))
+}
+
+func TestGoAMD64SDKFrameOriginalSourceCapture(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/md5")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete original SDK source/native frame precondition", err)
+	}
+	defer observed.Close()
+	pkg := sdkAMD64FrameActualPackage(t, observed.source)
+	const assembly = "md5block_amd64.s"
+	source, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: assembly,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("independent SDK-primary native frame handoff is absent", err)
+	}
+	defer source.Close()
+	fn, found := source.functions[request.PackagePath+".block"]
+	if !found || len(source.functions) != 1 || fn.locals != 16 || fn.args != 32 {
+		t.Fatal("complete original SDK frame/declaration/native layout", fn)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("live SDK-primary native frame", err)
+	}
+	// Even a fresh outer identity cannot borrow the SDK origin's live owner.
+	copy := &GoAMD64FrameSource{sdkFrame: source.sdkFrame}
+	copy.identity = copy
+	if err := copy.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("copied SDK frame acquired the original native source", err)
+	}
+	if err := copy.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("copied SDK frame removed original artifacts", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("copied SDK frame revoked the authentic original", err)
+	}
+	// Capture supplies source/layout facts, not a completed body proof. Do not
+	// freeze an obsolete unsupported-op diagnostic as a successful observation:
+	// valid new typed families may subsequently make BindFixedLocal succeed.
+	if fn.signature.x86FixedLocal != nil {
+		t.Fatal("capturing a frame implicitly supplied a complete body proof")
+	}
+	original := observed.source.observation.ObjectInputs.Sources[0].Original
+	after, err := os.ReadFile(filepath.Join(request.Directory, assembly))
+	if err != nil || !bytes.Equal(after, original) {
+		t.Fatal("SDK source was replaced or cropped", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal("SDK frame artifact cleanup", err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("closed SDK frame retained its native source lifetime", err)
+	}
+}
+
+func TestGoAMD64SDKFrameRejectsChangedProfile(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/md5")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	pkg := sdkAMD64FrameActualPackage(t, observed.source)
+	source, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, AssemblyFile: "md5block_amd64.s", Target: request.Target, Environment: request.Environment})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	// The factory owns an independent environment copy; mutating the caller's
+	// request must neither update its sealed profile nor revoke its lifetime.
+	request.Environment[0] += "changed"
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("caller environment aliases the private SDK profile", err)
+	}
+	original := source.request.Target
+	source.request.Target = "windows/amd64"
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed target retained the original SDK frame", err)
+	}
+	source.request.Target = original
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restoring a changed SDK profile revived its frame", err)
+	}
+}
+
+func TestGoAMD64SDKFrameRejectsChangedNativeWitness(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/md5")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	pkg := sdkAMD64FrameActualPackage(t, observed.source)
+	source, err := CaptureGoAMD64SDKFrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, AssemblyFile: "md5block_amd64.s", Target: request.Target, Environment: request.Environment})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	name := request.PackagePath + ".block"
+	original := source.functions[name]
+	changed := original
+	changed.locals++
+	source.functions[name] = changed
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed private native frame supplied backing", err)
+	}
+	source.functions[name] = original
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restoring native metadata revived a revoked frame", err)
+	}
+}
diff --git a/amd64_go_sdk_frame_context_go127_test.go b/amd64_go_sdk_frame_context_go127_test.go
new file mode 100644
index 000000000..ee3febf7f
--- /dev/null
+++ b/amd64_go_sdk_frame_context_go127_test.go
@@ -0,0 +1,54 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoAMD64SDKFrameBindContextCallbacksMayClose(t *testing.T) {
+	for _, method := range []string{"Err", "Deadline", "Done"} {
+		t.Run(method, func(t *testing.T) {
+			original, request := sdkASMDataRequest(t, "amd64", "crypto/md5")
+			observed, err := CaptureGoAMD64SDKFrameObservation(original, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			pkg := sdkAMD64FrameActualPackage(t, observed.source)
+			source, err := CaptureGoAMD64SDKFrameSource(original, pkg, GoAMD64FrameCaptureRequest{
+				GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: "md5block_amd64.s",
+				Target: request.Target, Environment: request.Environment,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			file, err := Parse(ArchAMD64, observed.source.observation.CPP[0].Output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := goAMD64FrameCloseCallback(t, original, source, method)
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{request.PackagePath + ".block": source.functions[request.PackagePath+".block"].signature},
+				ResolveSym: func(symbol string) string {
+					// The initial Verify has completed. The next context sample
+					// in the binder must still occur outside the observer lock.
+					ctx.armed.Store(true)
+					return request.PackagePath + "." + strings.TrimPrefix(symbol, "·")
+				}}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+			if ctx.locked.Load() || !ctx.called.Load() {
+				t.Fatalf("SDK Bind caller %s callback ran under frame lock (Close would deadlock) or was never sampled", method)
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || len(bound.Sigs) != 0 {
+				t.Fatal("callback-closed SDK source published a local binding", err)
+			}
+			if err := source.Verify(original); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("SDK Bind revived its callback-closed source", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_sdk_frame_inventory.go b/amd64_go_sdk_frame_inventory.go
new file mode 100644
index 000000000..2ceccd5d0
--- /dev/null
+++ b/amd64_go_sdk_frame_inventory.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This distinct SDK-primary role retains every direct member, including all
+// inactive candidates and child-directory identities. Child contents belong
+// to separate packages/generators, not the selected compiler package. Any
+// selected dependency retains its independent complete original source/export
+// graph; selected relative CPP headers retain their own bounded input route.
+// Root membership and child identities are rechecked before/after commands. The ordinary owned
+// flat inventory keeps its 256-member bound. The SDK retains its 16 MiB byte
+// budget and uses the shared original-source membership bound.
+func (source *GoX86SDKASMDataSource) snapshotSDKPrimaryDirectory() error {
+	return captureSDKPackageDirectoryInputs(source.guard, source.retainDirectory)
+}
+
+// SDK assembly, numerical reads and literal alignment share only this input
+// inventory. It grants neither child-package source/include authority nor any
+// frame, native entry or initialized-storage role. Each caller authenticates
+// its own complete SDK selection and retains/rechecks every child identity.
+func captureSDKPackageDirectoryInputs(guard *GoAMD64FrameSource, retainDirectory func(string) error) error {
+	resolved, err := sourcepath.Resolve(guard.request.Directory)
+	if err != nil || resolved != guard.request.Directory {
+		return sdkASMDataContext("SDK-primary package directory is not canonical")
+	}
+	inventory := gooriginalsrc.NewSnapshot()
+	if err := inventory.Directory(resolved, false); err != nil {
+		return sdkASMDataContext("SDK-primary complete package inventory: %v", err)
+	}
+	// Snapshot.Directory closes the complete EOF and applies the existing
+	// shared file/directory count budgets. Use its observed cardinality, not
+	// a newly guessed per-package cap, for the same direct member list.
+	entries, info, err := gooriginalsrc.ReadDirectory(resolved, len(inventory.View().Entries[resolved]))
+	if err != nil || len(entries) == 0 {
+		return sdkASMDataContext("SDK-primary complete package inventory changed: %v", err)
+	}
+	guard.directoryInfo = info
+	remaining := int64(16 << 20)
+	for _, entry := range entries {
+		guard.entries = append(guard.entries, entry.Name())
+		path := filepath.Join(resolved, entry.Name())
+		if entry.IsDir() {
+			if err := retainDirectory(path); err != nil {
+				return err
+			}
+			continue
+		}
+		data, err := goAMD64FrameReadBound(path, remaining)
+		if err != nil {
+			return err
+		}
+		digest := sha256.Sum256(data)
+		if previous, present := guard.inputs[path]; present && previous != digest {
+			return sdkASMDataContext("SDK-primary original inventory changed while capturing")
+		}
+		remaining -= int64(len(data))
+		guard.inputs[path] = digest
+	}
+	if err := inventory.Verify(); err != nil {
+		return sdkASMDataContext("SDK-primary input membership changed during capture: %v", err)
+	}
+	guard.directoryInventory = inventory
+	return nil
+}
+
+// The frame owner copies mutable input maps/slices, while retaining the same
+// immutable directory observation through its existing live SDK source owner.
+// Directory metadata does not supply frame, numerical or native-entry facts.
+func (source *GoAMD64FrameSource) copySDKPrimaryInputInventory(original *GoAMD64FrameSource) {
+	source.inputs = cloneSDKASMDataInputs(original.inputs)
+	source.entries = append([]string(nil), original.entries...)
+	source.directoryInfo = original.directoryInfo
+	source.directoryInventory = original.directoryInventory
+}
diff --git a/amd64_go_sdk_frame_inventory_go127_test.go b/amd64_go_sdk_frame_inventory_go127_test.go
new file mode 100644
index 000000000..9b807249e
--- /dev/null
+++ b/amd64_go_sdk_frame_inventory_go127_test.go
@@ -0,0 +1,24 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestSDKAMD64PrimaryInventoryActualCompleteMD5(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/md5")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete unchanged SDK compiler-selected source/native frame", err)
+	}
+	defer observed.Close()
+	source := observed.source
+	if source.guard.selection.Module != nil || source.guard.selection.ImportPath != request.PackagePath ||
+		len(source.observation.Frames) != 1 || len(source.observation.Frames[0].Records) != 1 ||
+		!source.observation.Frames[0].Records[0].NoSplit || source.observation.Frames[0].Records[0].Locals != 16 ||
+		source.observation.Frames[0].Records[0].Args != 32 {
+		t.Fatal("SDK-primary exact selected source or native frame inventory changed")
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("live complete SDK source with independent child identities", err)
+	}
+}
diff --git a/amd64_go_sdk_frame_inventory_test.go b/amd64_go_sdk_frame_inventory_test.go
new file mode 100644
index 000000000..921c4ff9f
--- /dev/null
+++ b/amd64_go_sdk_frame_inventory_test.go
@@ -0,0 +1,315 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSDKAMD64PrimaryInventorySeparatesChildSourceRoles(t *testing.T) {
+	root := t.TempDir()
+	if err := os.Mkdir(filepath.Join(root, "generator"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	for path, bytes := range map[string][]byte{"source.go": []byte("package fixture\n"), "ignored.s": []byte("// inactive candidate\n"),
+		"generator/source.go": []byte("package separate\n")} {
+		if err := os.WriteFile(filepath.Join(root, filepath.FromSlash(path)), bytes, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	root, err := sourcepath.Resolve(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	request := GoAMD64FrameCaptureRequest{Directory: root}
+	ordinary := newGoOriginalInputGuard(request)
+	if err := ordinary.snapshotDirectory(); err != nil {
+		t.Fatal("ordinary package omitted a bounded direct-child identity", err)
+	}
+	if !reflect.DeepEqual(ordinary.entries, []string{"generator", "ignored.s", "source.go"}) || len(ordinary.inputs) != 2 ||
+		len(ordinary.childDirectories) != 1 || ordinary.childDirectories[filepath.Join(root, "generator")] == nil {
+		t.Fatal("ordinary inventory confused direct files with child-package contents")
+	}
+	ordinary.owned, err = sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ordinary.ownedInfo, err = sourcepath.Lstat(ordinary.owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(request), directories: make(map[string]os.FileInfo)}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(source.guard.entries, []string{"generator", "ignored.s", "source.go"}) || len(source.guard.inputs) != 2 ||
+		source.directories[filepath.Join(root, "generator")] == nil {
+		t.Fatal("complete direct/inactive input or separate child identity was omitted")
+	}
+	if err := os.WriteFile(filepath.Join(root, "generator", "source.go"), []byte("package changedChild\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := ordinary.verifyInputs(); err != nil {
+		t.Fatal("ordinary selected package read separately owned child contents", err)
+	}
+	if err := os.Rename(filepath.Join(root, "generator"), filepath.Join(root, "original-generator")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(filepath.Join(root, "generator"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "generator", "source.go"), []byte("package separate\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.verifyDirectories(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("replacement child directory acquired original selected-package identity", err)
+	}
+	if err := ordinary.verifyInputs(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("replacement child directory retained the ordinary original identity", err)
+	}
+}
+
+func TestSDKAMD64PrimaryInventoryRootMembershipGuard(t *testing.T) {
+	root, owned := t.TempDir(), t.TempDir()
+	if err := os.WriteFile(filepath.Join(root, "source.go"), []byte("package fixture\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	root, err := sourcepath.Resolve(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	owned, err = sourcepath.Resolve(owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: root}), directories: make(map[string]os.FileInfo)}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	source.guard.owned, source.guard.ownedInfo = owned, nil
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		t.Fatal("unchanged complete primary membership", err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "new-inactive.s"), []byte("// new inactive input\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.guard.verifyInputs(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("new unselected root member escaped the complete input guard", err)
+	}
+}
+
+func TestSDKAMD64PrimaryInventoryByteBoundary(t *testing.T) {
+	for _, size := range []int{16 << 20, 16<<20 + 1} {
+		root := t.TempDir()
+		if err := os.WriteFile(filepath.Join(root, "source.go"), []byte(strings.Repeat(" ", size)), 0600); err != nil {
+			t.Fatal(err)
+		}
+		root, err := sourcepath.Resolve(root)
+		if err != nil {
+			t.Fatal(err)
+		}
+		source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: root}), directories: make(map[string]os.FileInfo)}
+		err = source.snapshotSDKPrimaryDirectory()
+		if size == 16<<20 {
+			if err != nil || len(source.guard.inputs) != 1 {
+				t.Fatal("exact original primary byte bound was rejected", err)
+			}
+		} else if !errors.Is(err, ErrProbeNeedsContext) || len(source.guard.inputs) != 0 {
+			t.Fatal("oversized primary source entered the unchanged byte inventory", err)
+		}
+	}
+}
+
+func TestSDKAMD64PrimaryInventoryMemberBoundary(t *testing.T) {
+	for _, count := range []int{256, 257, 300, 792} {
+		t.Run(fmt.Sprint(count), func(t *testing.T) {
+			root := t.TempDir()
+			for index := 0; index < count; index++ {
+				name, data := fmt.Sprintf("%03d.go", index), []byte("package fixture\n")
+				if index == 0 {
+					name, data = "kernel_amd64.s", []byte("TEXT ·F(SB),4,$0-0\nRET\n")
+				} else if index == 1 {
+					data = []byte("package fixture\nfunc F()\n")
+				}
+				if err := os.WriteFile(filepath.Join(root, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			root, err := sourcepath.Resolve(root)
+			if err != nil {
+				t.Fatal(err)
+			}
+			request := GoAMD64FrameCaptureRequest{Directory: root, AssemblyFile: "kernel_amd64.s"}
+			ordinary := newGoOriginalInputGuard(request)
+			err = ordinary.snapshotDirectory()
+			if count == 256 {
+				if err != nil {
+					t.Fatal("ordinary flat boundary rejected", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || len(ordinary.inputs) != 0 {
+				t.Fatal("SDK observation widened the ordinary flat input role", err)
+			}
+			source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(request), directories: make(map[string]os.FileInfo)}
+			if err := source.snapshotSDKPrimaryDirectory(); err != nil || len(source.guard.inputs) != count {
+				t.Fatal("complete SDK input inventory was rejected or truncated", err, len(source.guard.inputs), count)
+			}
+			owned, err := sourcepath.Resolve(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			source.guard.owned = owned
+			source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := source.guard.verifyInputs(); err != nil {
+				t.Fatal("unchanged complete SDK inventory failed verification", err)
+			}
+			if err := os.WriteFile(filepath.Join(root, "new-inactive.s"), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := source.guard.verifyInputs(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("larger directory became a silently accepted bounded prefix", err)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64PrimaryInventoryRejectsRedirectedChildren(t *testing.T) {
+	for _, directory := range []bool{false, true} {
+		root, outside := t.TempDir(), t.TempDir()
+		target := outside
+		if !directory {
+			target = filepath.Join(outside, "source.go")
+			if err := os.WriteFile(target, []byte("package foreign\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if err := os.Symlink(target, filepath.Join(root, "redirected")); err != nil {
+			t.Fatal("actual redirected child control", err)
+		}
+		root, err := sourcepath.Resolve(root)
+		if err != nil {
+			t.Fatal(err)
+		}
+		source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: root}), directories: make(map[string]os.FileInfo)}
+		if err := source.snapshotSDKPrimaryDirectory(); !errors.Is(err, ErrProbeNeedsContext) || len(source.guard.inputs) != 0 || len(source.directories) != 0 {
+			t.Fatal("redirected file/directory acquired a selected SDK-primary input role", err)
+		}
+	}
+}
+
+func TestSDKAMD64PrimaryInventoryDoesNotAuthorizeChildInclude(t *testing.T) {
+	root := t.TempDir()
+	if err := os.Mkdir(filepath.Join(root, "generator"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "source.s"), []byte("#include \"generator/body.h\"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "generator", "body.h"), []byte("TEXT ·F(SB),4,$0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	root, err := sourcepath.Resolve(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoX86SDKASMDataSource{request: GoX86SDKASMDataCaptureRequest{Directory: root},
+		guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: root}), directories: make(map[string]os.FileInfo)}
+	source.guard.env = map[string]string{"GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v1"}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := source.captureAssembly(context.Background(), 0, "source.s"); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "relative/foreign include") {
+		t.Fatal("observed child identity became compiler/include source authority", err)
+	}
+}
+
+// This tests the same private input transfer used by the SDK frame factory.
+// It supplies no ready frame or ABI permission and runs no compiler subprocess.
+func TestSDKAMD64PrimaryInventoryCloneRetainsCompleteMembership(t *testing.T) {
+	for _, change := range []string{"none", "add", "remove", "bytes", "replace root", "close owner", "copy inputs", "copy entries", "drop inventory"} {
+		t.Run(change, func(t *testing.T) {
+			root, err := sourcepath.Resolve(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index := 0; index < 300; index++ {
+				if err := os.WriteFile(filepath.Join(root, fmt.Sprintf("%03d.go", index)), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			request := GoAMD64FrameCaptureRequest{Directory: root}
+			source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(request), directories: make(map[string]os.FileInfo)}
+			if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+				t.Fatal(err)
+			}
+			cloned := newGoOriginalInputGuard(request)
+			cloned.copySDKPrimaryInputInventory(source.guard)
+			owned, err := sourcepath.Resolve(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, guard := range []*GoAMD64FrameSource{source.guard, cloned} {
+				guard.owned = owned
+				guard.ownedInfo, err = sourcepath.Lstat(owned)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := guard.verifyInputs(); err != nil {
+					t.Fatal("complete original or copied SDK inputs rejected", err)
+				}
+			}
+			switch change {
+			case "add":
+				err = os.WriteFile(filepath.Join(root, "added.s"), nil, 0600)
+			case "remove":
+				err = os.Remove(filepath.Join(root, "299.go"))
+			case "bytes":
+				err = os.WriteFile(filepath.Join(root, "299.go"), []byte("// changed\n"), 0600)
+			case "close owner":
+				err = source.guard.Close()
+			case "copy inputs":
+				cloned.inputs[filepath.Join(root, "299.go")] = [32]byte{}
+			case "copy entries":
+				cloned.entries[0] = "foreign.go"
+			case "drop inventory":
+				cloned.directoryInventory = nil
+			case "replace root":
+				original := root + "-original"
+				err = os.Rename(root, original)
+				if err == nil {
+					t.Cleanup(func() {
+						if err := os.RemoveAll(original); err != nil {
+							t.Error(err)
+						}
+					})
+					err = os.Mkdir(root, 0700)
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, guard := range []*GoAMD64FrameSource{source.guard, cloned} {
+				err := guard.verifyInputs()
+				copyOnly := change == "copy inputs" || change == "copy entries" || change == "drop inventory"
+				changed := change != "none" && (!copyOnly || guard == cloned)
+				if !changed && err != nil || changed && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original/copy complete-input invalidation differs", change, err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_go_sdk_frame_native.go b/amd64_go_sdk_frame_native.go
new file mode 100644
index 000000000..32bde7502
--- /dev/null
+++ b/amd64_go_sdk_frame_native.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type sdkAMD64FrameNativeRecord = goAMD64NativeHeader
+
+type sdkAMD64FrameNativeObservation struct {
+	Source                         string
+	OriginalListing, MappedListing []byte
+	Records                        []sdkAMD64FrameNativeRecord
+}
+
+// Both native listings share one explicit SDK-primary representation bound.
+// Ordinary/CPU source, CPP, event and token budgets are unchanged. Charge a
+// complete command result before retaining its command or frame projection.
+const sdkAMD64FrameListingBytes = 16 << 20
+
+func (source *GoX86SDKASMDataSource) retainSDKFrameListingBytes(bytes int) error {
+	if bytes < 0 || source.frameListingBytes < 0 || bytes > sdkAMD64FrameListingBytes-source.frameListingBytes {
+		return sdkASMDataContext("SDK-primary native listings exceed their explicit byte bound")
+	}
+	source.frameListingBytes += bytes
+	source.observation.FrameListingBytes = source.frameListingBytes
+	return nil
+}
+
+// FuncInfo.Locals is int32, but the official listing writer prints uint64.
+// Decode its canonical sign extension without interpreting it as an extent.
+func goAMD64FrameSignedLocals(raw string) (int64, error) {
+	bits, err := strconv.ParseUint(raw, 16, 64)
+	if err != nil {
+		return 0, err
+	}
+	value := int64(int32(bits))
+	if uint64(value) != bits {
+		return 0, fmt.Errorf("noncanonical signed int32 locals: %s", raw)
+	}
+	return value, nil
+}
+
+func sdkAMD64FrameNativeRecords(listing []byte, texts []gostaticstorage.TextRecord) ([]sdkAMD64FrameNativeRecord, error) {
+	return sdkAMD64FrameNativeRecordsInOrder(listing, texts, nil)
+}
+
+func sdkAMD64FrameNativeRecordsForSource(listing []byte, texts []gostaticstorage.TextRecord, order []gostaticstorage.ASMSourceText) ([]sdkAMD64FrameNativeRecord, error) {
+	if len(order) != len(texts) {
+		return nil, sdkASMDataContext("SDK-primary native source/object ordinal association is incomplete")
+	}
+	indices := make([]int, len(order))
+	seen := make(map[int]bool, len(order))
+	for ordinal, association := range order {
+		index := association.ObjectOrdinal
+		if association.SourceOrdinal != ordinal || index < 0 || index >= len(texts) || seen[index] {
+			return nil, sdkASMDataContext("SDK-primary native source/object ordinal association is duplicate or unbound")
+		}
+		text := texts[index]
+		if association.Name != text.Name || association.ABI != text.ABI || association.Namespace != text.Namespace ||
+			association.Relative != text.Relative || association.Index != text.Index {
+			return nil, sdkASMDataContext("SDK-primary native source/object physical association differs")
+		}
+		indices[ordinal], seen[index] = index, true
+	}
+	return sdkAMD64FrameNativeRecordsInOrder(listing, texts, indices)
+}
+
+// nil indices is the existing format-only diagnostic helper. Production SDK
+// capture always supplies the independently source-derived association; no
+// original TextRecord is reordered or rewritten to resemble source evidence.
+func sdkAMD64FrameNativeRecordsInOrder(listing []byte, texts []gostaticstorage.TextRecord, indices []int) ([]sdkAMD64FrameNativeRecord, error) {
+	var records []sdkAMD64FrameNativeRecord
+	scanner := bufio.NewScanner(bytes.NewReader(listing))
+	scanner.Buffer(nil, 4<<20)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.Contains(line, " STEXT ") && !strings.Contains(line, " STEXTFIPS ") {
+			continue // Complete native objects validate every other record.
+		}
+		header, valid := parseGoAMD64NativeHeader(line)
+		if !valid || len(records) >= len(texts) {
+			return nil, sdkASMDataContext("SDK-primary native frame header has an unbound role or inventory")
+		}
+		index := len(records)
+		if indices != nil {
+			index = indices[index]
+		}
+		text := texts[index]
+		if text.Size < 0 || header.Symbol != text.Name || header.Kind != text.Kind ||
+			header.Size != uint64(text.Size) || header.Size != uint64(len(text.Code)) ||
+			header.objectFlags() != text.Flags&0x19 {
+			return nil, sdkASMDataContext("SDK-primary complete native frame/object TEXT differs")
+		}
+		if indices != nil && header.Static != (text.ABI == 65535) {
+			return nil, sdkASMDataContext("SDK-primary native listing static/ABI source role differs")
+		}
+		records = append(records, header)
+	}
+	if err := scanner.Err(); err != nil || len(records) != len(texts) {
+		return nil, sdkASMDataContext("SDK-primary native frame inventory is incomplete: %v", err)
+	}
+	return records, nil
+}
+
+func (source *GoX86SDKASMDataSource) captureSDKFrameListings(ctx context.Context) error {
+	for _, role := range []string{"src/internal/abi/symtab.go", "src/cmd/asm/internal/asm/asm.go", "src/cmd/internal/obj/objfile.go"} {
+		if _, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role))); err != nil {
+			return err
+		}
+	}
+	for ordinal, input := range source.observation.ObjectInputs.Sources {
+		var objects, listings [2][]byte
+		paths := [2]string{filepath.Join(source.request.Directory, input.Name), filepath.Join(source.guard.owned, fmt.Sprintf("expanded-%d.s", ordinal))}
+		for role, path := range paths {
+			object := filepath.Join(source.guard.owned, fmt.Sprintf("frame-%d-%d.o", ordinal, role))
+			args := append(source.asmArguments(source.guard.owned), "-S", "-o", object, path)
+			listing, err := source.run(ctx, args...)
+			if err != nil {
+				return err
+			}
+			objects[role], err = source.guard.read(object)
+			if err != nil {
+				return err
+			}
+			if _, err := source.artifact(fmt.Sprintf("frame-%d-%d.listing", ordinal, role), listing); err != nil {
+				return err
+			}
+			listings[role] = listing
+		}
+		original, mapped, err := gostaticstorage.ObserveX86SDKASMDataListingObjects(source.observation.ObjectInputs, ordinal, objects[0], objects[1])
+		if err != nil {
+			return sdkASMDataContext("SDK-primary original/mapped/archive complete frame object join: %v", err)
+		}
+		order := source.observation.Objects.Sources[ordinal].TextOrder
+		first, err := sdkAMD64FrameNativeRecordsForSource(listings[0], original, order)
+		if err != nil {
+			return err
+		}
+		second, err := sdkAMD64FrameNativeRecordsForSource(listings[1], mapped, order)
+		if err != nil || !reflect.DeepEqual(first, second) {
+			return sdkASMDataContext("SDK-primary original/mapped complete native frame metadata differs: %v", err)
+		}
+		source.observation.Frames = append(source.observation.Frames, sdkAMD64FrameNativeObservation{
+			Source: input.Name, OriginalListing: listings[0], MappedListing: listings[1], Records: first,
+		})
+	}
+	return nil
+}
diff --git a/amd64_go_sdk_frame_native_go127_test.go b/amd64_go_sdk_frame_native_go127_test.go
new file mode 100644
index 000000000..e099fc471
--- /dev/null
+++ b/amd64_go_sdk_frame_native_go127_test.go
@@ -0,0 +1,204 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestSDKAMD64NativeFrameSignedLocalsActualGoObjects(t *testing.T) {
+	_, profile, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	root := filepath.Dir(filepath.Dir(profile.GoBinary))
+	builtin, err := os.ReadFile(filepath.Join(root, "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const source = "TEXT bootstrap(SB),4,$-8\nRET\nTEXT ·Ordinary(SB),4,$0-0\nRET\n"
+	path := filepath.Join(profile.Directory, "signed-locals.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			env := append([]string(nil), profile.Environment...)
+			for index, pair := range env {
+				if strings.HasPrefix(pair, "GOOS=") {
+					env[index] = "GOOS=" + goos
+				}
+			}
+			objectPath := filepath.Join(t.TempDir(), "signed-locals.o")
+			listing, err := goasmcmd.Run(ctx, profile.Directory, env, profile.GoBinary,
+				"tool", "asm", "-p", "framefixture", "-S", "-o", objectPath, path)
+			if err != nil {
+				t.Fatal("actual Go assembler", err)
+			}
+			object, err := os.ReadFile(objectPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed, err := gostaticstorage.ObserveAMD64AssemblyData([]byte(source), object, builtin, "framefixture", goos+"/amd64")
+			if err != nil || len(observed.Member.Texts) != 2 || len(observed.TextOrder) != 2 {
+				t.Fatal("complete actual source/object precondition", err)
+			}
+			if !bytes.Contains(listing, []byte("locals=0xfffffffffffffff8")) {
+				t.Fatalf("actual Go did not emit the independent signed-locals prior:\n%s", listing)
+			}
+			records, err := sdkAMD64FrameNativeRecordsForSource(listing, observed.Member.Texts, observed.TextOrder)
+			if err != nil || len(records) != 2 {
+				t.Fatal("actual signed-locals listing lost its complete original object association", err)
+			}
+			if records[0].Locals != ^uint64(7) || records[1].Locals != 0 || records[0].ArgsKnown || !records[1].ArgsKnown {
+				t.Fatal("signed locals or independent unknown-argument sentinel was rewritten", records)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64NativeFrameKindsActualGoObjects(t *testing.T) {
+	_, profile, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	root := filepath.Dir(filepath.Dir(profile.GoBinary))
+	builtin, err := os.ReadFile(filepath.Join(root, "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The encoder chooses the kinds from ordinary source symbols. This is a
+	// standalone compiler-format fixture, never an SDK provenance certificate.
+	source := []byte(`TEXT crypto∕internal∕fips140∕framefixture·First(SB),4,$16-8
+	MOVQ $11, AX
+	RET
+TEXT ·Ordinary(SB),4,$0-0
+	RET
+TEXT private<>(SB),4,$8
+	RET
+TEXT crypto∕internal∕fips140∕framefixture·Last(SB),4,$24-16
+	RET
+`)
+	path := filepath.Join(profile.Directory, "mixed.asm")
+	if err := os.WriteFile(path, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			env := append([]string(nil), profile.Environment...)
+			for index, pair := range env {
+				if strings.HasPrefix(pair, "GOOS=") {
+					env[index] = "GOOS=" + goos
+				}
+			}
+			objectPath := filepath.Join(t.TempDir(), "mixed.o")
+			listing, err := goasmcmd.Run(ctx, profile.Directory, env, profile.GoBinary,
+				"tool", "asm", "-p", "framefixture", "-S", "-o", objectPath, path)
+			if err != nil {
+				t.Fatal("actual Go assembler", err)
+			}
+			object, err := os.ReadFile(objectPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed, err := gostaticstorage.ObserveAMD64AssemblyData(source, object, builtin, "framefixture", goos+"/amd64")
+			if err != nil || len(observed.Member.Texts) != 4 || len(observed.TextOrder) != 4 {
+				t.Fatal("complete actual source/object precondition", err)
+			}
+			kinds := []uint8{2, 1, 1, 2}
+			for ordinal, entry := range observed.TextOrder {
+				if observed.Member.Texts[entry.ObjectOrdinal].Kind != kinds[ordinal] {
+					t.Fatal("actual Go object did not emit the independent mixed-kind prior", ordinal)
+				}
+			}
+			if bytes.Count(listing, []byte(" STEXTFIPS ")) != 2 || bytes.Count(listing, []byte(" STEXT ")) != 2 {
+				t.Fatal("actual assembler listing did not preserve both TEXT kinds")
+			}
+			records, err := sdkAMD64FrameNativeRecordsForSource(listing, observed.Member.Texts, observed.TextOrder)
+			if err != nil || len(records) != 4 {
+				t.Fatal("complete actual mixed-kind listing lost native frames", err)
+			}
+			if records[0].Locals != 24 || records[0].Args != 8 || records[1].Locals != 0 ||
+				!records[2].Static || records[2].ArgsKnown || records[2].Locals != 16 || records[3].Locals != 32 || records[3].Args != 16 {
+				t.Fatal("actual ordinary/FIPS/static frame metadata changed", records)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64NativeFrameFIPSCompleteOriginalSource(t *testing.T) {
+	// Share only the stock compiler cache. Each source capture retains its own
+	// complete inputs, command outputs, verification and revocable lifetime.
+	t.Setenv("GOCACHE", t.TempDir())
+	for _, pkg := range []string{
+		"crypto/internal/fips140/aes/gcm",
+		"crypto/internal/fips140/sha256",
+		"crypto/internal/fips140/sha512",
+		"crypto/internal/fips140/nistec",
+	} {
+		t.Run(pkg, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, "amd64", pkg)
+			observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+			if err != nil {
+				t.Fatal("complete original SDK source/listing/object observation", err)
+			}
+			defer observed.Close()
+			source := observed.source
+			if len(source.observation.Frames) == 0 || len(source.observation.Frames) != len(source.observation.Objects.Sources) {
+				t.Fatal("native frame source inventory differs")
+			}
+			var frames, fips int
+			for ordinal, frame := range source.observation.Frames {
+				object := source.observation.Objects.Sources[ordinal]
+				if len(frame.Records) != len(object.Original.Texts) {
+					t.Fatal("native frame TEXT inventory differs", frame.Source)
+				}
+				frames += len(frame.Records)
+				for _, text := range object.Original.Texts {
+					if text.Kind == 2 {
+						fips++
+					}
+				}
+			}
+			if fips == 0 || frames == 0 {
+				t.Fatal("actual original FIPS source precondition absent")
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal("live original source verification", err)
+			}
+			t.Logf("complete native frames=%d FIPS=%d; observation only, not translation or execution", frames, fips)
+			sdkASMDataRetain(t, source)
+		})
+	}
+}
+
+func TestSDKAMD64ReadonlyLiteralFIPSCompleteOriginalSource(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "crypto/internal/fips140/sha512")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete original SDK source/object observation", err)
+	}
+	defer observed.Close()
+	images, err := gostaticstorage.ReadonlyLiteralDataInitializers(observed.source.observation.Objects)
+	if err != nil {
+		t.Fatal("actual FIPS readonly literal definitions", err)
+	}
+	fips := 0
+	for _, image := range images {
+		if image.Definition.Kind == 4 {
+			fips++
+		}
+	}
+	if fips == 0 {
+		t.Fatal("actual Go object did not supply the FIPS readonly prior")
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("live original source verification", err)
+	}
+	t.Logf("%d literal images, %d FIPS; source/object bytes, not program execution", len(images), fips)
+}
diff --git a/amd64_go_sdk_frame_native_test.go b/amd64_go_sdk_frame_native_test.go
new file mode 100644
index 000000000..dc9dc9330
--- /dev/null
+++ b/amd64_go_sdk_frame_native_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestSDKAMD64NativeFrameSignedLocalsRepresentation(t *testing.T) {
+	for _, locals := range []int32{0, 1, 8, 0x7fffffff, -1, -8, -0x80000000} {
+		for _, kind := range []uint8{1, 2} {
+			t.Run(fmt.Sprintf("locals-%d/kind-%d", locals, kind), func(t *testing.T) {
+				label := "STEXT"
+				if kind == 2 {
+					label = "STEXTFIPS"
+				}
+				// The official writer prints uint64(FuncInfo.Locals), whose
+				// source type is int32. Preserve that exact representation.
+				bits := uint64(int64(locals))
+				listing := []byte(fmt.Sprintf("fixture.Entry %s nosplit asm size=1 args=0x0 locals=0x%x\n", label, bits))
+				texts := []gostaticstorage.TextRecord{{Name: "fixture.Entry", Kind: kind, Flags: 0x10, Size: 1, Code: []byte{0xc3}}}
+				records, err := sdkAMD64FrameNativeRecords(listing, texts)
+				if err != nil || len(records) != 1 || records[0].Locals != bits {
+					t.Fatalf("canonical signed int32 locals lost their original metadata bits: records=%v error=%v", records, err)
+				}
+				if records[0].Symbol != texts[0].Name || !records[0].NoSplit || !records[0].ASM || !records[0].ArgsKnown {
+					t.Fatal("signed locals changed an independent native frame role", records[0])
+				}
+			})
+		}
+	}
+}
+
+func TestSDKAMD64NativeFrameRejectsNoncanonicalLocals(t *testing.T) {
+	texts := []gostaticstorage.TextRecord{{Name: "fixture.Entry", Kind: 1, Flags: 0x10, Size: 1, Code: []byte{0xc3}}}
+	for _, locals := range []string{"80000000", "ffffffff", "100000000", "ffffffff7fffffff", "10000000000000000", "nothex", ""} {
+		t.Run("locals-"+locals, func(t *testing.T) {
+			listing := []byte("fixture.Entry STEXT nosplit asm size=1 args=0x0 locals=0x" + locals + "\n")
+			if _, err := sdkAMD64FrameNativeRecords(listing, texts); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("noncanonical or out-of-range signed locals acquired native metadata", locals, err)
+			}
+		})
+	}
+}
+
+func TestSDKAMD64OriginalFrameNativeCompleteMetadata(t *testing.T) {
+	texts := []gostaticstorage.TextRecord{{Name: "private", Kind: 1, Flags: 0x10, Size: 1, Code: []byte{0xc3}}, {Name: "sdk.Entry", Kind: 1, Size: 1, Code: []byte{0xc3}}}
+	listing := []byte("private STEXT static nosplit asm size=1 align=0x0 args=0xffffffff80000000 locals=0x0 funcid=0x0\n" +
+		"sdk.Entry STEXT asm size=1 align=0x0 args=0x61 locals=0x128 funcid=0x0\n")
+	records, err := sdkAMD64FrameNativeRecords(listing, texts)
+	if err != nil || len(records) != 2 || !records[0].Static || !records[0].NoSplit || records[0].ArgsKnown ||
+		records[0].Args != -0x80000000 || records[1].NoSplit || !records[1].ArgsKnown || records[1].Args != 97 || records[1].Locals != 296 {
+		t.Fatal("private unknown args or stack-split native frame was disguised as a declared leaf", records, err)
+	}
+	for _, raw := range []string{
+		"sdk.Entry STEXT asm size=1 args=0x61 locals=0x128\n",
+		"private STEXT static nosplit asm size=1 args=0xffffffff80000000 locals=0x0\n",
+		"private STEXT static nosplit asm size=2 args=0xffffffff80000000 locals=0x0\n",
+		"private STEXT foreign size=1 args=0x0 locals=0x0\n",
+		string(listing) + string(listing),
+	} {
+		if _, err := sdkAMD64FrameNativeRecords([]byte(raw), texts); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("partial, reordered, foreign or duplicate native frame inventory survived", raw, err)
+		}
+	}
+}
+
+func TestSDKAMD64NativeFrameTextKindsKeepExactObjectIdentity(t *testing.T) {
+	for _, kinds := range [][]uint8{{1, 1}, {2, 2}, {1, 2}, {2, 1}} {
+		t.Run(fmt.Sprint(kinds), func(t *testing.T) {
+			var listing strings.Builder
+			var texts []gostaticstorage.TextRecord
+			for index, kind := range kinds {
+				name := fmt.Sprintf("fixture.Entry%d", index)
+				label := "STEXT"
+				if kind == 2 {
+					label = "STEXTFIPS"
+				}
+				fmt.Fprintf(&listing, "%s %s nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0\n", name, label)
+				texts = append(texts, gostaticstorage.TextRecord{Name: name, Kind: kind, Flags: 0x10, Size: 1, Code: []byte{0xc3}})
+			}
+			raw := []byte(listing.String())
+			records, err := sdkAMD64FrameNativeRecords(raw, texts)
+			if err != nil || len(records) != len(texts) {
+				t.Fatal("complete ordinary/FIPS TEXT listing lost native frames", records, err)
+			}
+			for index, record := range records {
+				if record.Symbol != texts[index].Name || !record.NoSplit || !record.ASM || !record.ArgsKnown {
+					t.Fatal("native frame identity or attributes changed", record)
+				}
+				for _, wrongKind := range []uint8{0, 3 - texts[index].Kind, 3} {
+					changed := append([]gostaticstorage.TextRecord(nil), texts...)
+					changed[index].Kind = wrongKind
+					if _, err := sdkAMD64FrameNativeRecords(raw, changed); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("listing borrowed a different object TEXT/storage kind", index, wrongKind, err)
+					}
+				}
+			}
+			for _, changed := range []string{
+				strings.SplitAfter(listing.String(), "\n")[0],
+				listing.String() + listing.String(),
+				strings.Replace(listing.String(), " nosplit", " foreign", 1),
+				strings.Replace(listing.String(), " asm", " dupok asm", 1),
+				strings.Replace(listing.String(), "STEXT", "STEXTFOREIGN", 1),
+			} {
+				if _, err := sdkAMD64FrameNativeRecords([]byte(changed), texts); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("incomplete, duplicate or unobserved listing acquired native frames", changed, err)
+				}
+			}
+		})
+	}
+}
+
+func TestSDKAMD64OriginalFrameNativeListingByteBoundary(t *testing.T) {
+	source := &GoX86SDKASMDataSource{}
+	if err := source.retainSDKFrameListingBytes(sdkAMD64FrameListingBytes); err != nil {
+		t.Fatal("exact SDK-primary listing byte boundary", err)
+	}
+	for _, added := range []int{1, -1} {
+		if err := source.retainSDKFrameListingBytes(added); !errors.Is(err, ErrProbeNeedsContext) ||
+			source.frameListingBytes != sdkAMD64FrameListingBytes {
+			t.Fatal("oversized native listing changed its retained accounting", added, err)
+		}
+	}
+}
diff --git a/amd64_go_sdk_frame_observation.go b/amd64_go_sdk_frame_observation.go
new file mode 100644
index 000000000..72dd5c415
--- /dev/null
+++ b/amd64_go_sdk_frame_observation.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "context"
+
+// GoAMD64SDKFrameObservation is a query-only complete SDK-primary source,
+// default/config profile and native frame observation. It retains all selected
+// Go/ASM sources and native TEXTs, including private and stack-splitting bodies.
+// It grants no local backing, ABI transport, caller, loop, DATA read or extent
+// permission. Ordinary owned-main and numerical factories remain distinct.
+type GoAMD64SDKFrameObservation struct {
+	identity *GoAMD64SDKFrameObservation
+	source   *GoX86SDKASMDataSource
+}
+
+// CaptureGoAMD64SDKFrameObservation consumes the original producer environment,
+// including an actual bounded GOENV file (or off) and the observed cgo default.
+// No config, proxy, feature profile or compiler input is replaced for capture.
+func CaptureGoAMD64SDKFrameObservation(ctx context.Context, request GoX86SDKASMDataCaptureRequest) (*GoAMD64SDKFrameObservation, error) {
+	source, err := captureGoX86SDKASMDataSource(ctx, request, true)
+	if err != nil {
+		return nil, err
+	}
+	observed := &GoAMD64SDKFrameObservation{source: source}
+	observed.identity = observed
+	return observed, nil
+}
+
+func (observed *GoAMD64SDKFrameObservation) Verify(ctx context.Context) error {
+	if observed == nil || observed.identity != observed || observed.source == nil {
+		return sdkASMDataContext("missing or copied SDK-primary frame observation")
+	}
+	return observed.source.Verify(ctx)
+}
+
+// Readback returns diagnostics only. Serialized observations cannot construct
+// a live source or a frame capability.
+func (observed *GoAMD64SDKFrameObservation) Readback(ctx context.Context) ([]byte, error) {
+	if observed == nil || observed.identity != observed || observed.source == nil {
+		return nil, sdkASMDataContext("missing or copied SDK-primary frame observation")
+	}
+	return observed.source.Readback(ctx)
+}
+
+func (observed *GoAMD64SDKFrameObservation) Close() error {
+	if observed == nil {
+		return nil
+	}
+	if observed.identity != observed || observed.source == nil {
+		return sdkASMDataContext("copied SDK-primary observation cannot close its original source")
+	}
+	return observed.source.Close()
+}
diff --git a/amd64_go_sdk_frame_observation_test.go b/amd64_go_sdk_frame_observation_test.go
new file mode 100644
index 000000000..ae1ea4a4a
--- /dev/null
+++ b/amd64_go_sdk_frame_observation_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"testing"
+)
+
+func TestSDKAMD64OriginalFrameObservationMissingLifetime(t *testing.T) {
+	for _, observed := range []*GoAMD64SDKFrameObservation{nil, {}} {
+		if err := observed.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("missing observation acquired a verification role", err)
+		}
+		if data, err := observed.Readback(context.Background()); !errors.Is(err, ErrProbeNeedsContext) || data != nil {
+			t.Fatal("missing observation published a source/frame readback", err)
+		}
+	}
+	if err := (*GoAMD64SDKFrameObservation)(nil).Close(); err != nil {
+		t.Fatal("nil Close is not harmless", err)
+	}
+	if err := (&GoAMD64SDKFrameObservation{}).Close(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("uninitialized observer acquired cleanup ownership", err)
+	}
+}
diff --git a/amd64_go_sdk_frame_profile.go b/amd64_go_sdk_frame_profile.go
new file mode 100644
index 000000000..66b827f63
--- /dev/null
+++ b/amd64_go_sdk_frame_profile.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const sdkAMD64FrameConfigBytes = 64 << 10
+
+func (source *GoX86SDKASMDataSource) captureSDKFrameConfig(path string) error {
+	resolved, err := sourcepath.Resolve(path)
+	before, statErr := sourcepath.Lstat(path)
+	if err != nil || !filepath.IsAbs(path) || resolved != path || statErr != nil ||
+		!before.Mode().IsRegular() || before.Size() > sdkAMD64FrameConfigBytes {
+		return sdkASMDataContext("SDK-primary GOENV is not one bounded canonical original config")
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	opened, err := file.Stat()
+	if err != nil || !opened.Mode().IsRegular() || !os.SameFile(before, opened) || opened.Size() != before.Size() {
+		return errors.Join(sdkASMDataContext("SDK-primary GOENV role changed while opening"), file.Close())
+	}
+	data, readErr := io.ReadAll(io.LimitReader(file, sdkAMD64FrameConfigBytes+1))
+	closeErr := file.Close()
+	after, statErr := sourcepath.Lstat(path)
+	resolved, resolveErr := sourcepath.Resolve(path)
+	if err := errors.Join(readErr, closeErr); err != nil || statErr != nil || resolveErr != nil || resolved != path ||
+		len(data) > sdkAMD64FrameConfigBytes || int64(len(data)) != opened.Size() || !after.Mode().IsRegular() ||
+		after.Size() != opened.Size() || !os.SameFile(opened, after) {
+		return sdkASMDataContext("SDK-primary bounded GOENV changed while reading: %v", err)
+	}
+	source.guard.inputs[path] = sha256.Sum256(data)
+	source.originalConfig, source.originalConfigID = path, before
+	return nil
+}
+
+// The original SDK-primary role consumes the exact producer environment. It
+// never substitutes a config, proxy, cgo default, cache or CPU profile. Complete
+// actual SDK selection and compiler-source/export/object joins remain required.
+// This profile is private to the distinct SDK frame factory: ordinary owned
+// sources, public ASM DATA and numerical producers keep their existing rules.
+func sdkAMD64FrameEnvironment(request GoX86SDKASMDataCaptureRequest) (map[string]string, error) {
+	if request.Target != "linux/amd64" && request.Target != "darwin/amd64" && request.Target != "windows/amd64" {
+		return nil, sdkASMDataContext("SDK-primary frame profile requires an original AMD64 target")
+	}
+	return sdkX86OriginalSourceEnvironment(request)
+}
+
+// Original source observation does not select a native frame/entry role. The
+// AMD64 factory above retains its separate exact target check.
+func sdkX86OriginalSourceEnvironment(request GoX86SDKASMDataCaptureRequest) (map[string]string, error) {
+	if !gostaticstorage.X86SDKTarget(request.Target) {
+		return nil, sdkASMDataContext("SDK-primary source profile requires an original x86 target")
+	}
+	provided := make(map[string]string)
+	for _, pair := range request.Environment {
+		key, value, valid := strings.Cut(pair, "=")
+		if _, duplicate := provided[key]; !valid || key == "" || duplicate || strings.ContainsRune(pair, '\x00') {
+			return nil, sdkASMDataContext("SDK-primary malformed or duplicate actual command environment")
+		}
+		provided[key] = value
+	}
+	goos, arch, _ := strings.Cut(request.Target, "/")
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": arch, "GOFLAGS": "", "GOTOOLCHAIN": "local", "GOWORK": "off"} {
+		if actual, present := provided[key]; !present || actual != value {
+			return nil, sdkASMDataContext("SDK-primary unbound actual command profile: %s", key)
+		}
+	}
+	if provided["CGO_ENABLED"] != "0" && provided["CGO_ENABLED"] != "1" {
+		return nil, sdkASMDataContext("SDK-primary needs the actual explicit compiler cgo default")
+	}
+	if provided["GOENV"] != "off" && !filepath.IsAbs(provided["GOENV"]) {
+		return nil, sdkASMDataContext("SDK-primary requires the actual resolved GOENV or explicit off")
+	}
+	if provided["GOEXPERIMENT"] != "" || provided["GOPACKAGESDRIVER"] != "" && provided["GOPACKAGESDRIVER"] != "off" {
+		return nil, sdkASMDataContext("SDK-primary custom experiment or package driver needs a separate role")
+	}
+	return provided, nil
+}
diff --git a/amd64_go_sdk_frame_profile_go127_test.go b/amd64_go_sdk_frame_profile_go127_test.go
new file mode 100644
index 000000000..5a46451c8
--- /dev/null
+++ b/amd64_go_sdk_frame_profile_go127_test.go
@@ -0,0 +1,127 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSDKAMD64OriginalFrameProfileActualCompleteSource(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "vendor/golang.org/x/crypto/chacha20poly1305")
+	config := filepath.Join(t.TempDir(), "go-env")
+	// This is a separate config producer input, never a replacement SDK source.
+	if err := os.WriteFile(config, []byte("GOPROXY=https://original-config.invalid,direct\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	config, err := sourcepath.Resolve(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var env []string
+	for _, pair := range request.Environment {
+		key, _, _ := strings.Cut(pair, "=")
+		if key != "GOENV" && key != "GOPROXY" && key != "CGO_ENABLED" && key != "GOAMD64" && key != "GOEXPERIMENT" {
+			env = append(env, pair)
+		}
+	}
+	env = append(env, "GOENV="+config)
+	raw, err := goasmcmd.Run(ctx, request.Directory, env, request.GoBinary, "env", "-json", "CGO_ENABLED")
+	var defaults map[string]string
+	if err != nil || json.Unmarshal(raw, &defaults) != nil || defaults["CGO_ENABLED"] != "0" && defaults["CGO_ENABLED"] != "1" {
+		t.Fatal("actual target compiler cgo default", err)
+	}
+	request.Environment = append(env, "CGO_ENABLED="+defaults["CGO_ENABLED"])
+	original := append([]string(nil), request.Environment...)
+	public, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if public != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("new role leaked into public DATA source", err)
+	}
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("actual unchanged SDK source/profile/header/object observation", err)
+	}
+	defer observed.Close()
+	source := observed.source
+	if source.guard.env["GOENV"] != config || source.guard.env["CGO_ENABLED"] != defaults["CGO_ENABLED"] ||
+		source.guard.env["GOPROXY"] != "https://original-config.invalid,direct" ||
+		strings.Join(source.request.Environment, "\x00") != strings.Join(original, "\x00") ||
+		len(source.observation.Objects.Sources) != 1 || len(source.observation.Objects.Sources[0].Original.Texts) != 3 {
+		t.Fatal("SDK-primary source/default profile or complete three TEXT inventory changed")
+	}
+	frames := source.observation.Frames
+	if len(frames) != 1 || len(frames[0].Records) != 3 || frames[0].Records[0].ArgsKnown ||
+		frames[0].Records[0].Args != -0x80000000 || !frames[0].Records[0].Static || !frames[0].Records[0].NoSplit ||
+		frames[0].Records[1].NoSplit || frames[0].Records[1].Args != 97 || frames[0].Records[1].Locals != 296 ||
+		frames[0].Records[2].NoSplit || frames[0].Records[2].Args != 96 || frames[0].Records[2].Locals != 296 {
+		t.Fatal("complete original private helper/stack-split native metadata was omitted or relabeled", frames)
+	}
+	t.Logf("native listing bytes %d/%d; actual target CGO default %s; complete 3 TEXT frames %+v",
+		source.frameListingBytes, sdkAMD64FrameListingBytes, defaults["CGO_ENABLED"], frames[0].Records)
+	copy := *observed
+	if err := copy.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("copied SDK-primary observation acquired original lifetime", err)
+	}
+	if data, err := copy.Readback(ctx); !errors.Is(err, ErrProbeNeedsContext) || data != nil {
+		t.Fatal("copied SDK-primary observation published original source/frame readback", err)
+	}
+	if err := copy.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("copied SDK-primary observation removed original artifacts", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("live original config/profile", err)
+	}
+	before, err := os.ReadFile(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(config, bytes.ReplaceAll(before, []byte("original-config"), []byte("replaced-config")), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed original config retained SDK-primary source", err)
+	}
+	if _, err := source.Readback(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("failed config verification did not revoke SDK-primary source", err)
+	}
+}
+
+func TestSDKAMD64OriginalFrameProfileRejectsEqualByteConfigReplacement(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+	config := filepath.Join(t.TempDir(), "go-env")
+	bytes := []byte("GOPROXY=off\n")
+	if err := os.WriteFile(config, bytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	config, err := sourcepath.Resolve(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOENV=") {
+			request.Environment[index] = "GOENV=" + config
+		}
+	}
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("actual original SDK source/config", err)
+	}
+	defer observed.Close()
+	if err := os.Rename(config, config+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(config, bytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("equal-byte replacement acquired lazily captured original config identity", err)
+	}
+}
diff --git a/amd64_go_sdk_frame_profile_test.go b/amd64_go_sdk_frame_profile_test.go
new file mode 100644
index 000000000..ff1577bfa
--- /dev/null
+++ b/amd64_go_sdk_frame_profile_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSDKAMD64OriginalFrameProfilePreservesDefaults(t *testing.T) {
+	request := GoX86SDKASMDataCaptureRequest{Target: "linux/amd64", Environment: []string{
+		"GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=1", "GOENV=" + filepath.Join(t.TempDir(), "env"),
+		"GOFLAGS=", "GOTOOLCHAIN=local", "GOWORK=off",
+	}}
+	original := append([]string(nil), request.Environment...)
+	actual, err := sdkAMD64FrameEnvironment(request)
+	if err != nil || actual["CGO_ENABLED"] != "1" || actual["GOENV"] == "off" ||
+		!reflect.DeepEqual(request.Environment, original) {
+		t.Fatal("SDK-primary profile replaced the original default/config", err)
+	}
+	if _, present := actual["GOPROXY"]; present {
+		t.Fatal("SDK-primary profile invented a proxy override")
+	}
+	if _, present := actual["GOAMD64"]; present {
+		t.Fatal("SDK-primary profile invented a CPU default override")
+	}
+	if _, err := sdkASMDataEnvironment(request); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("SDK-primary request weakened the existing public DATA profile", err)
+	}
+}
+
+func TestSDKAMD64OriginalFrameConfigExactByteBoundary(t *testing.T) {
+	for _, size := range []int{sdkAMD64FrameConfigBytes, sdkAMD64FrameConfigBytes + 1} {
+		path := filepath.Join(t.TempDir(), "env")
+		if err := os.WriteFile(path, []byte(strings.Repeat("#", size)), 0600); err != nil {
+			t.Fatal(err)
+		}
+		path, err := sourcepath.Resolve(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{})}
+		err = source.captureSDKFrameConfig(path)
+		if size == sdkAMD64FrameConfigBytes {
+			if err != nil || len(source.guard.inputs) != 1 {
+				t.Fatal("exact original config bound was rejected", err)
+			}
+		} else if !errors.Is(err, ErrProbeNeedsContext) || len(source.guard.inputs) != 0 || source.originalConfigID != nil {
+			t.Fatal("oversized original config was retained", err)
+		}
+	}
+}
+
+func TestSDKAMD64OriginalFrameConfigGuardEagerIdentity(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "env")
+	data := []byte("GOPROXY=off\n")
+	if err := os.WriteFile(path, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	path, err := sourcepath.Resolve(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{})}
+	if err := source.captureSDKFrameConfig(path); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.verifyDirectories(); err != nil {
+		t.Fatal("unchanged eager config identity", err)
+	}
+	// Capture retained an open-handle ID. Byte equality cannot substitute for
+	// that identity when the next verification observes a new file at the path.
+	if err := os.Rename(path, path+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.verifyDirectories(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("equal-byte replacement acquired retained original config identity", err)
+	}
+}
+
+func TestSDKAMD64OriginalFrameProfileRejectsUnboundRoles(t *testing.T) {
+	for _, bad := range []string{"GOENV=", "GOENV=relative", "CGO_ENABLED=", "CGO_ENABLED=2", "GOFLAGS=-overlay=foreign.json",
+		"GOTOOLCHAIN=auto", "GOWORK=workspace", "GOEXPERIMENT=foreign", "GOPACKAGESDRIVER=foreign"} {
+		request := GoX86SDKASMDataCaptureRequest{Target: "linux/amd64", Environment: []string{
+			"GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOENV=off", "GOFLAGS=", "GOTOOLCHAIN=local", "GOWORK=off",
+		}}
+		key, _, _ := strings.Cut(bad, "=")
+		var env []string
+		for _, pair := range request.Environment {
+			if !strings.HasPrefix(pair, key+"=") {
+				env = append(env, pair)
+			}
+		}
+		request.Environment = append(env, bad)
+		if _, err := sdkAMD64FrameEnvironment(request); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("foreign or duplicate profile acquired SDK-primary source", bad, err)
+		}
+	}
+}
diff --git a/amd64_go_sdk_frame_source.go b/amd64_go_sdk_frame_source.go
new file mode 100644
index 000000000..a64341226
--- /dev/null
+++ b/amd64_go_sdk_frame_source.go
@@ -0,0 +1,278 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type goAMD64SDKFrameOrigin struct {
+	identity *GoAMD64FrameSource
+	owner    *GoAMD64SDKFrameObservation
+	pkg      GoPackage
+	request  GoAMD64FrameCaptureRequest
+}
+
+// CaptureGoAMD64SDKFrameSource is a distinct actual SDK-primary typed ABI0
+// native frame factory. It authenticates the whole selected source/profile,
+// compiler graph and all TEXTs, without relabeling SDK source as owned-main.
+// Entries must be Go-declared with exact logical/native names, layout and
+// source PCs. Same-source frame-unobserving leaf helpers retain no Go signature.
+// Nonzero frames also require automatic BP/SP shapes;
+// zero-frame siblings retain their ordinary ABI0 path without local backing.
+// Generated split checks are observed separately from the source body.
+// Native callers and ABI selectors require separate contracts. BindFixedLocal
+// also accounts for the observed private leaf's automatic BP/FLAGS effects and
+// proves every full-source access/initialization/CFG requirement before granting
+// local bytes.
+func CaptureGoAMD64SDKFrameSource(ctx context.Context, pkg GoPackage, request GoAMD64FrameCaptureRequest) (_ *GoAMD64FrameSource, result error) {
+	if pkg.Types == nil || pkg.Path != pkg.Types.Path() || request.NumericalReads != nil ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || filepath.Ext(request.AssemblyFile) != ".s" {
+		return nil, goAMD64FrameContext("SDK-primary requires its exact complete package/ABI0 source role")
+	}
+	owner, err := CaptureGoAMD64SDKFrameObservation(ctx, GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: pkg.Path,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		return nil, err
+	}
+	source := newGoOriginalInputGuard(request)
+	source.sdkFrame = &goAMD64SDKFrameOrigin{identity: source, owner: owner, pkg: pkg, request: source.request}
+	source.sdkFrame.request.Environment = append([]string(nil), source.request.Environment...)
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	data := owner.source
+	data.operation.Lock()
+	// Clone complete compiler state: the SDK owner's verification may update
+	// its private guard maps, and a frame must neither alias nor mutate them.
+	state := struct {
+		Selection goAMD64FrameSelection
+		Env       map[string]string
+		Imports   map[string]goAMD64FrameSelection
+	}{data.guard.selection, data.guard.env, data.guard.imports}
+	raw, err := json.Marshal(state)
+	if err == nil {
+		state.Selection, state.Env, state.Imports = goAMD64FrameSelection{}, nil, nil
+		err = json.Unmarshal(raw, &state)
+		// RawMessage's nil marshals as null but decodes as literal "null".
+		// Preserve the actual absent error projection rather than relabeling
+		// an independently observed source selection during this private copy.
+		state.Selection.Error = append(json.RawMessage(nil), data.guard.selection.Error...)
+		for path, copied := range state.Imports {
+			copied.Error = append(json.RawMessage(nil), data.guard.imports[path].Error...)
+			state.Imports[path] = copied
+		}
+	}
+	if err == nil {
+		source.selection, source.env, source.imports = state.Selection, state.Env, state.Imports
+		source.copySDKPrimaryInputInventory(data.guard)
+		source.owned, source.ownedInfo = data.guard.owned, data.guard.ownedInfo
+		source.functions, source.declarations, err = source.sdkFrameRecords()
+	}
+	data.operation.Unlock()
+	if err != nil {
+		return nil, err
+	}
+	source.ready = true
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+// Caller holds the SDK owner's operation lock. Full original/mapped/listing
+// objects are already independently joined to the actual compiler archive.
+// Reusing their native code is not permission to execute a helper or caller.
+func (source *GoAMD64FrameSource) sdkFrameRecords() (map[string]goAMD64FrameFunction, map[string]goAMD64FrameDeclaration, error) {
+	origin := source.sdkFrame
+	data := origin.owner.source
+	declarations, err := source.typedDeclarations(origin.pkg, false)
+	if err != nil {
+		return nil, nil, err
+	}
+	functions := make(map[string]goAMD64FrameFunction)
+	found := false
+	withFrame := false
+	for ordinal, input := range data.observation.ObjectInputs.Sources {
+		found = found || input.Name == source.request.AssemblyFile
+		if ordinal >= len(data.observation.CPP) || ordinal >= len(data.observation.Frames) || ordinal >= len(data.observation.Objects.Sources) {
+			return nil, nil, goAMD64FrameContext("SDK-primary complete native frame observation is missing")
+		}
+		cpp, native := data.observation.CPP[ordinal], data.observation.Frames[ordinal]
+		original, err := source.read(filepath.Join(source.request.Directory, input.Name))
+		if err != nil || !bytes.Equal(original, input.Original) || native.Source != input.Name {
+			return nil, nil, goAMD64FrameContext("SDK-primary original assembly identity changed: %v", err)
+		}
+		file, err := ParseWithDefines(ArchAMD64, cpp.Output, nil)
+		object := data.observation.Objects.Sources[ordinal]
+		texts := object.Original.Texts
+		if err != nil || len(file.Funcs) == 0 || len(file.UnlinkedPrelude) != 0 || len(file.Funcs) != len(native.Records) || len(file.Funcs) != len(texts) {
+			return nil, nil, goAMD64FrameContext("SDK-primary complete parsed/native TEXT inventory differs: %v", err)
+		}
+		leaves, err := goAMD64FramePrivateLeaves(file, origin.pkg)
+		if err != nil {
+			return nil, nil, err
+		}
+		for index, fn := range file.Funcs {
+			name := source.selection.ImportPath + "." + strings.TrimPrefix(fn.Sym, "·")
+			_, declared := declarations[name]
+			if index >= len(object.TextOrder) || object.TextOrder[index].SourceOrdinal != index ||
+				object.TextOrder[index].ObjectOrdinal < 0 || object.TextOrder[index].ObjectOrdinal >= len(texts) {
+				return nil, nil, goAMD64FrameContext("SDK-primary complete source/TEXT association differs")
+			}
+			record, text := native.Records[index], texts[object.TextOrder[index].ObjectOrdinal]
+			if !record.ordinaryFrameRole() {
+				return nil, nil, goAMD64FrameContext("SDK-primary native header has no ordinary/private frame entry role: %s", fn.Sym)
+			}
+			if leaves[fn.Sym] {
+				if declared || record.Symbol != text.Name || record.Locals != uint64(goAMD64FrameNativeLocals(fn.FrameSize)) || !record.NoSplit ||
+					record.ArgsKnown && record.Args != 0 || record.Static != strings.HasSuffix(fn.Sym, "<>") {
+					return nil, nil, goAMD64FrameContext("SDK-primary private leaf/native identity differs: %s", fn.Sym)
+				}
+				continue // All original bytes/PCs/relocations are still consumed below.
+			}
+			// Real -std assembler objects retain qualified ABI0 declarations
+			// in the non-package definition block. Its role is authenticated by
+			// the complete same-source/compiler archive join, not by the name.
+			defined := text.Namespace == gostaticstorage.TextSymbolSelf || text.Namespace == gostaticstorage.TextSymbolNonpkgDefinition
+			if !declared || strings.Contains(fn.Sym, "<") || record.Static || !record.ArgsKnown ||
+				!defined || text.ABI != 0 || name != record.Symbol || name != text.Name {
+				return nil, nil, goAMD64FrameContext("SDK-primary frame requires an exact Go-declared logical ABI0 entry; private/native helper has no role: %s (declared=%t native=%s namespace=%d ABI=%d static=%t args-known=%t)", fn.Sym, declared, record.Symbol, text.Namespace, text.ABI, record.Static, record.ArgsKnown)
+			}
+			if fn.FrameSize < 0 || fn.FrameSize > 64<<10 || fn.FrameSize%8 != 0 || record.Locals != uint64(goAMD64FrameNativeLocals(fn.FrameSize)) || record.Args != fn.ArgSize {
+				return nil, nil, goAMD64FrameContext("SDK-primary original declaration/native fixed-frame layout differs: %s", fn.Sym)
+			}
+			withFrame = withFrame || fn.FrameSize > 0
+		}
+		for _, observed := range cpp.Sources {
+			expected, captured := source.inputs[observed.File]
+			bytes, err := goAMD64FrameRead(observed.File)
+			if err != nil || !captured || sha256.Sum256(bytes) != expected {
+				return nil, nil, goAMD64FrameContext("SDK-primary native source PC lacks its original physical input: %v", err)
+			}
+			source.origins[observed.File] = strings.Count(string(bytes), "\n") + 1
+		}
+		var observed map[string]goAMD64FrameFunction
+		if len(file.Data)+len(file.Globl) != 0 || bytes.Contains(native.OriginalListing, []byte("\trel ")) {
+			data, readErr := source.fixedLocalDataObservation(input.Name, cpp.Output)
+			if readErr != nil {
+				return nil, nil, readErr
+			}
+			listing := native.OriginalListing
+			if len(data.Layouts) != 0 {
+				listing, readErr = goAMD64FrameDataListing(listing, data)
+				if readErr != nil {
+					return nil, nil, readErr
+				}
+			}
+			observed, err = goAMD64FrameListingWithDataObject(listing, file, origin.pkg, source.origins, data, nil,
+				source.request.Target, source.request.Directory, source.env["GOROOT"])
+			if err == nil {
+				err = goAMD64FrameDataTextJoin(observed, data, source.request.Directory, source.origins, source.env["GOROOT"])
+			}
+		} else if goAMD64FrameSplitListing(native.OriginalListing) {
+			observed, err = goAMD64FrameListingWithSplitObject(native.OriginalListing, file, origin.pkg, source.origins, texts, nil,
+				source.request.Target, source.request.Directory, source.env["GOROOT"])
+		} else {
+			observed, err = goAMD64FrameListingWithNumericalObject(native.OriginalListing, file, origin.pkg, source.origins, texts)
+		}
+		if err != nil {
+			return nil, nil, err
+		}
+		for name, fn := range observed {
+			declaration, declared := declarations[name]
+			if _, duplicate := functions[name]; duplicate || fn.privateLeaf && declared ||
+				!fn.privateLeaf && (!declared || !reflect.DeepEqual(fn.signature, declaration.signature)) {
+				return nil, nil, goAMD64FrameContext("SDK-primary complete native/declaration frame identity differs")
+			}
+			fn.transport, fn.languageType = declaration.transport, declaration.languageType
+			functions[name] = fn
+		}
+	}
+	if !found {
+		return nil, nil, goAMD64FrameContext("SDK-primary requested assembly is absent from complete selection")
+	}
+	if !withFrame {
+		return nil, nil, goAMD64FrameContext("SDK-primary complete source has no nonzero native frame")
+	}
+	return functions, declarations, nil
+}
+
+func (source *GoAMD64FrameSource) verifySDKFrame(ctx context.Context) (result error) {
+	origin := source.sdkFrame
+	if origin == nil || origin.identity != source || origin.owner == nil || origin.owner.source == nil {
+		return goAMD64FrameContext("copied or missing SDK-primary native frame owner")
+	}
+	defer func() {
+		if result != nil {
+			source.mu.Lock()
+			source.ready = false
+			source.mu.Unlock()
+		}
+	}()
+	// SDK Verify samples caller contexts outside all frame/operation locks.
+	if err := origin.owner.Verify(ctx); err != nil {
+		return err
+	}
+	data := origin.owner.source
+	data.operation.Lock()
+	source.mu.Lock()
+	err := func() error {
+		if !source.ready || !reflect.DeepEqual(source.request, origin.request) ||
+			!reflect.DeepEqual(source.selection, data.guard.selection) || !reflect.DeepEqual(source.env, data.guard.env) ||
+			!reflect.DeepEqual(source.imports, data.guard.imports) || !reflect.DeepEqual(source.inputs, data.guard.inputs) ||
+			source.directoryInventory != data.guard.directoryInventory {
+			return goAMD64FrameContext("SDK-primary native frame source/profile/complete input identity changed")
+		}
+		if err := source.verifyInputs(); err != nil {
+			return err
+		}
+		functions, declarations, err := source.sdkFrameRecords()
+		if err != nil || !reflect.DeepEqual(functions, source.functions) || !reflect.DeepEqual(declarations, source.declarations) {
+			return goAMD64FrameContext("SDK-primary original typed/native frame witness changed: %v", err)
+		}
+		return nil
+	}()
+	source.mu.Unlock()
+	data.operation.Unlock()
+	if err != nil {
+		return err
+	}
+	return origin.owner.Verify(ctx)
+}
+
+func (source *GoAMD64FrameSource) closeSDKFrame() error {
+	source.mu.Lock()
+	origin := source.sdkFrame
+	if origin == nil || origin.identity != source || origin.owner == nil {
+		source.mu.Unlock()
+		return goAMD64FrameContext("copied SDK-primary frame cannot close its original owner")
+	}
+	source.ready = false
+	source.mu.Unlock()
+	return origin.owner.Close()
+}
+
+// Called during the existing locked full-file binder. This immutable program
+// was authenticated in capture/Verify; the outer postcheck rejects revocation
+// or resolver-induced source changes before publishing any signature proof.
+func (source *GoAMD64FrameSource) preprocessSDKFrame(name string, original []byte) (string, error) {
+	data := source.sdkFrame.owner.source
+	for ordinal, input := range data.observation.ObjectInputs.Sources {
+		if input.Name == name && bytes.Equal(input.Original, original) && ordinal < len(data.observation.CPP) {
+			return data.observation.CPP[ordinal].Output, nil
+		}
+	}
+	return "", goAMD64FrameContext("SDK-primary fixed-local source lacks its complete original CPP identity")
+}
diff --git a/amd64_go_sdk_frame_source_go127_test.go b/amd64_go_sdk_frame_source_go127_test.go
new file mode 100644
index 000000000..3ec4f5d83
--- /dev/null
+++ b/amd64_go_sdk_frame_source_go127_test.go
@@ -0,0 +1,81 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func sdkAMD64FrameActualPackage(t *testing.T, source *GoX86SDKASMDataSource) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range source.guard.selection.GoFiles {
+		file, err := parser.ParseFile(fset, filepath.Join(source.request.Directory, name), nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	actualImports := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if mapped, found := source.guard.selection.ImportMap[path]; found {
+			path = mapped
+		}
+		dependency, found := source.guard.imports[path]
+		if !found || dependency.Export == "" {
+			return nil, fmt.Errorf("missing actual SDK export: %s", path)
+		}
+		return os.Open(dependency.Export)
+	})
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64"), Importer: actualImports, GoVersion: "go1.27"}).Check(source.request.PackagePath, fset, syntax, nil)
+	if err != nil {
+		t.Fatal("independent complete original SDK Go package", err)
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax}
+}
+
+func TestGoAMD64FrameOriginalSDKSourceObservation(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "vendor/golang.org/x/crypto/chacha20poly1305")
+	observed, err := CaptureGoAMD64SDKFrameObservation(ctx, request)
+	if err != nil {
+		t.Fatal("complete actual SDK source/header/CPP/native frame observation", err)
+	}
+	defer observed.Close()
+	data := observed.source
+	const assembly = "chacha20poly1305_amd64.s"
+	pkg := sdkAMD64FrameActualPackage(t, data)
+	declarations, err := data.guard.typedDeclarations(pkg, false)
+	if err != nil || len(declarations) != 2 || len(data.observation.Frames[0].Records) != 3 {
+		t.Fatal("private helper invented a Go declaration or complete Go/ASM scope was cropped", err)
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("live complete SDK-primary source", err)
+	}
+	frame, err := CaptureGoAMD64FrameSource(ctx, pkg, GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: assembly,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if frame != nil {
+		frame.Close()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "SDK/cache") {
+		t.Fatal("query-only SDK observation acquired an ordinary owned-main frame role", err)
+	}
+	input := data.observation.ObjectInputs.Sources[0]
+	actual, err := os.ReadFile(filepath.Join(request.Directory, assembly))
+	if err != nil || !bytes.Equal(actual, input.Original) {
+		t.Fatal("SDK role manufactured or rewrote a source fixture", err)
+	}
+}
diff --git a/amd64_go_sdk_frame_source_order_test.go b/amd64_go_sdk_frame_source_order_test.go
new file mode 100644
index 000000000..90f8f8ff6
--- /dev/null
+++ b/amd64_go_sdk_frame_source_order_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestSDKAMD64NativeFrameMixedNamespaceSourceOrder(t *testing.T) {
+	member := gostaticstorage.ASMDataMember{Flags: 4, Texts: []gostaticstorage.TextRecord{
+		{Name: "private", ABI: 65535, Namespace: gostaticstorage.TextSymbolSelf, Kind: 1, Flags: 0x10, Size: 1, Code: []byte{0xc3}},
+		{Name: "foreign.Entry", ABI: 1, Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 10, Kind: 1, Flags: 0x10, Size: 1, Code: []byte{0xc3}},
+		{Name: "fixture.Own", Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 11, Relative: 1, Kind: 1, Flags: 0x10, Size: 1, Code: []byte{0xc3}},
+	}}
+	source := []byte("TEXT foreign·Entry<ABIInternal>(SB),4,$0-0\nRET\nTEXT private<>(SB),4,$0-0\nRET\nTEXT ·Own(SB),4,$0-0\nRET\n")
+	order, err := gostaticstorage.ASMSourceTextOrder(source, "fixture", member)
+	if err != nil || len(order) != 3 {
+		t.Fatal("complete physical source association", err)
+	}
+	listing := []byte("foreign.Entry STEXT nosplit asm size=1 args=0x0 locals=0x0\nprivate STEXT static nosplit asm size=1 args=0x0 locals=0x0\nfixture.Own STEXT nosplit asm size=1 args=0x0 locals=0x0\n")
+	before := append([]gostaticstorage.TextRecord(nil), member.Texts...)
+	records, err := sdkAMD64FrameNativeRecordsForSource(listing, member.Texts, order)
+	if err != nil || len(records) != 3 {
+		t.Fatal("source-order listing must join the unchanged physical object", err)
+	}
+	if records[0].Symbol != "foreign.Entry" || records[1].Symbol != "private" || !records[1].Static ||
+		records[2].Symbol != "fixture.Own" || !reflect.DeepEqual(before, member.Texts) {
+		t.Fatal("native metadata lost source order or rewrote original evidence")
+	}
+	for _, mutate := range []func([]gostaticstorage.ASMSourceText){
+		func(m []gostaticstorage.ASMSourceText) { m[0].SourceOrdinal++ },
+		func(m []gostaticstorage.ASMSourceText) { m[0].ObjectOrdinal = m[1].ObjectOrdinal },
+		func(m []gostaticstorage.ASMSourceText) { m[0].ObjectOrdinal = 3 },
+		func(m []gostaticstorage.ASMSourceText) { m[0].Name += "foreign" },
+		func(m []gostaticstorage.ASMSourceText) { m[0].ABI = 0 },
+		func(m []gostaticstorage.ASMSourceText) { m[0].Namespace = gostaticstorage.TextSymbolSelf },
+		func(m []gostaticstorage.ASMSourceText) { m[0].Index++ },
+		func(m []gostaticstorage.ASMSourceText) { m[0].Relative++ },
+	} {
+		changed := append([]gostaticstorage.ASMSourceText(nil), order...)
+		mutate(changed)
+		if _, err := sdkAMD64FrameNativeRecordsForSource(listing, member.Texts, changed); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unclosed/duplicate physical mapping became native source metadata", err)
+		}
+	}
+	if _, err := sdkAMD64FrameNativeRecordsForSource(listing, member.Texts, order[:2]); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("missing source ordinal became native metadata", err)
+	}
+	wrongStatic := bytes.Replace(listing, []byte(" STEXT static"), []byte(" STEXT"), 1)
+	if _, err := sdkAMD64FrameNativeRecordsForSource(wrongStatic, member.Texts, order); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("static object acquired a named listing role", err)
+	}
+}
diff --git a/amd64_go_virtual_arguments.go b/amd64_go_virtual_arguments.go
new file mode 100644
index 000000000..80adbfa36
--- /dev/null
+++ b/amd64_go_virtual_arguments.go
@@ -0,0 +1,271 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"go/types"
+	"reflect"
+	"strings"
+)
+
+// This call-local issuer binds LLVM values to virtual Go registers. It is not
+// the stock compiler/archive issuer and supplies no native entry, stack home,
+// closure, pointee extent or caller capability. Closing the GoModule call also
+// closes every returned signature's private argument role.
+type amd64GoVirtualArguments struct {
+	pkg               GoPackage
+	sizes, frameSizes types.Sizes
+	syntax            []string
+	imports           map[string]*types.Package
+	file              *File
+	fingerprint       [32]byte
+	input             []byte
+	inputSHA          [32]byte
+	entries           map[string]*amd64GoArgumentBinding
+	symbols           map[string]string
+	resolve           func(string) string
+	active            bool
+	failure           error
+}
+
+func amd64VirtualArgumentDeclaration(pkg GoPackage, fn Func) *types.Func {
+	symbol := goStripABISuffix(fn.Sym)
+	name := goReadOnlyLocalName(pkg, symbol)
+	if name == "" {
+		name, _ = goDeclNameForSymbol(symbol, goLinknameRemoteToLocal(pkg.Syntax))
+	}
+	declaration, _ := pkg.Types.Scope().Lookup(name).(*types.Func)
+	return declaration
+}
+
+func amd64VirtualArgumentsNeeded(fn *types.Func) bool {
+	if fn == nil {
+		return false
+	}
+	sig, ok := fn.Type().(*types.Signature)
+	if !ok || sig.Params().Len() > 9 {
+		return true
+	}
+	for index := 0; index < sig.Params().Len(); index++ {
+		switch typ := sig.Params().At(index).Type().Underlying().(type) {
+		case *types.Basic:
+			if typ.Info()&types.IsInteger == 0 && typ.Kind() != types.UnsafePointer {
+				return true
+			}
+		case *types.Pointer, *types.Map, *types.Chan:
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+func bindAMD64GoVirtualArguments(pkg GoPackage, file *File, input []byte, inputSHA [32]byte,
+	opt GoModuleOptions, resolve func(string) string,
+) (*amd64GoVirtualArguments, error) {
+	if opt.GOARCH != "amd64" || opt.NumericalReads != nil || opt.X86TLSMoves != nil || opt.ARM64ByteCarrierSource != nil {
+		return nil, nil
+	}
+	declarations := make(map[string]*types.Func)
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+			if declaration := amd64VirtualArgumentDeclaration(pkg, fn); amd64VirtualArgumentsNeeded(declaration) {
+				declarations[fn.Sym] = declaration
+			}
+		}
+	}
+	if len(declarations) == 0 {
+		return nil, nil
+	}
+	owner := &amd64GoVirtualArguments{pkg: pkg, sizes: opt.Sizes, frameSizes: opt.FrameSizes,
+		input: input, inputSHA: inputSHA, file: x86DirectTailSnapshot(file), resolve: resolve, active: true,
+		entries: make(map[string]*amd64GoArgumentBinding), symbols: make(map[string]string), imports: make(map[string]*types.Package)}
+	if owner.sizes == nil {
+		owner.sizes = types.SizesFor("gc", "amd64")
+	}
+	if owner.frameSizes == nil {
+		owner.frameSizes = owner.sizes
+	}
+	if !x86CallerTargetSizesValid(owner.sizes) || !x86CallerTargetSizesValid(owner.frameSizes) {
+		return nil, amd64GoArgumentContext("virtual arguments need the actual AMD64 target value/frame widths")
+	}
+	var err error
+	owner.syntax, err = goReadOnlySyntax(pkg)
+	if err != nil {
+		return nil, err
+	}
+	for path, dependency := range pkg.Imports {
+		actual := false
+		for _, imported := range pkg.Types.Imports() {
+			actual = actual || imported == dependency
+		}
+		if dependency == nil || dependency.Path() != path || !dependency.Complete() || !actual {
+			return nil, amd64GoArgumentContext("virtual declaration import is not the actual complete typed dependency")
+		}
+		owner.imports[path] = dependency
+	}
+	typed, err := goReadOnlyTypedSyntax(pkg, owner.syntax, owner.sizes, nil)
+	if err != nil {
+		return nil, err
+	}
+	owner.fingerprint, err = x86CallerSourceFingerprint(owner.file)
+	if err != nil {
+		return nil, err
+	}
+	for _, fn := range file.Funcs {
+		name := resolve(goTextSymbolForResolution(fn.Sym))
+		owner.symbols[goTextSymbolForResolution(fn.Sym)] = name
+		declaration := declarations[fn.Sym]
+		if declaration == nil {
+			continue
+		}
+		actual, _ := typed.Scope().Lookup(declaration.Name()).(*types.Func)
+		if actual == nil || name == "" || fn.FrameSize != 0 || len(fn.X86RawText) != 0 || owner.entries[name] != nil {
+			return nil, amd64GoArgumentContext("virtual entry lacks one complete declaration and zero-frame source")
+		}
+		signature, err := goFuncSigForDeclaredFunc(name, declaration, "amd64", owner.sizes, owner.frameSizes, true)
+		if err != nil {
+			return nil, err
+		}
+		rechecked, err := goFuncSigForDeclaredFunc(name, actual, "amd64", owner.sizes, owner.frameSizes, true)
+		if err != nil || !reflect.DeepEqual(signature, rechecked) {
+			return nil, amd64GoArgumentContext("virtual signature differs from actual declaration syntax")
+		}
+		switch signature.Ret {
+		case I1, I8, I16, I32, I64:
+		default:
+			return nil, amd64GoArgumentContext("virtual parameters require their independent scalar result contract")
+		}
+		plan, err := planAMD64GoArguments(declaration.Type().(*types.Signature))
+		if err != nil {
+			return nil, err
+		}
+		if err := plan.requireRegisters(); err != nil {
+			return nil, err
+		}
+		entry := &amd64GoArgumentBinding{virtual: owner, declaration: declaration, symbol: fn.Sym, signature: signature, plan: plan}
+		entry.identity = entry
+		entry.seal, err = entry.digest()
+		if err != nil {
+			return nil, err
+		}
+		owner.entries[name] = entry
+	}
+	if err := owner.verify(); err != nil {
+		return nil, err
+	}
+	return owner, nil
+}
+
+// Internal lowering consumes only the private plan/source copies. This check
+// observes call lifetime and permanent revocation, not a cached successful
+// source query. Complete attach/audit/publication boundaries call verify.
+func (owner *amd64GoVirtualArguments) live() error {
+	if owner == nil || !owner.active {
+		return amd64GoArgumentContext("virtual argument call has ended")
+	}
+	return owner.failure
+}
+
+// Returned signatures keep only a closed tombstone, not the call's complete
+// source/type graph or callbacks. Clearing private entries does not alter the
+// separate public signature values or the caller-owned LLVM module.
+func (owner *amd64GoVirtualArguments) close() {
+	if owner == nil {
+		return
+	}
+	owner.active = false
+	for _, entry := range owner.entries {
+		*entry = amd64GoArgumentBinding{identity: entry, virtual: owner}
+	}
+	*owner = amd64GoVirtualArguments{}
+}
+
+func (owner *amd64GoVirtualArguments) verify() (result error) {
+	if err := owner.live(); err != nil {
+		return err
+	}
+	defer func() {
+		if result != nil {
+			owner.failure = result
+		}
+	}()
+	if err := owner.verifySource(); err != nil {
+		return err
+	}
+	for _, entry := range owner.entries {
+		actual, err := goFuncSigForDeclaredFunc(entry.signature.Name, entry.declaration, "amd64", owner.sizes, owner.frameSizes, true)
+		if err != nil || !reflect.DeepEqual(actual, entry.signature) {
+			return amd64GoArgumentContext("virtual declaration transport changed during consumption")
+		}
+	}
+	// Sizes is caller supplied and may execute code even at this final query.
+	// Recheck afterward using only concrete syntax/source/private-plan data.
+	return owner.verifySource()
+}
+
+func (owner *amd64GoVirtualArguments) verifySource() error {
+	fingerprint, err := x86CallerSourceFingerprint(owner.file)
+	syntax, syntaxErr := goReadOnlySyntax(owner.pkg)
+	if err != nil || syntaxErr != nil || fingerprint != owner.fingerprint ||
+		sha256.Sum256(owner.input) != owner.inputSHA || !reflect.DeepEqual(syntax, owner.syntax) || len(owner.imports) != len(owner.pkg.Imports) {
+		return amd64GoArgumentContext("virtual argument source changed during consumption")
+	}
+	for path, dependency := range owner.imports {
+		if owner.pkg.Imports[path] != dependency {
+			return amd64GoArgumentContext("virtual declaration import changed during consumption")
+		}
+	}
+	for _, entry := range owner.entries {
+		if owner.pkg.Types.Scope().Lookup(entry.declaration.Name()) != entry.declaration || !entry.matches(entry.signature) {
+			return amd64GoArgumentContext("virtual declaration identity changed during consumption")
+		}
+	}
+	return nil
+}
+
+func (owner *amd64GoVirtualArguments) resolveSymbol(symbol string) string {
+	actual := owner.resolve(symbol)
+	if expected, known := owner.symbols[goTextSymbolForResolution(symbol)]; known && actual != expected {
+		owner.failure = amd64GoArgumentContext("virtual entry resolver changed during consumption")
+	}
+	return actual
+}
+
+func (owner *amd64GoVirtualArguments) attach(signatures map[string]FuncSig) error {
+	if owner == nil {
+		return nil
+	}
+	if err := owner.verify(); err != nil {
+		return err
+	}
+	for name, entry := range owner.entries {
+		sig, present := signatures[name]
+		if !present || !reflect.DeepEqual(numericalSignatureShape(sig), entry.signature) || sig.amd64GoArguments != nil && sig.amd64GoArguments != entry {
+			return amd64GoArgumentContext("virtual entry lost its complete actual signature")
+		}
+		sig.amd64GoArguments = entry
+		signatures[name] = sig
+	}
+	return nil
+}
+
+func (owner *amd64GoVirtualArguments) audit(file *File, signatures map[string]FuncSig, opt GoModuleOptions, resolve func(string) string, storage *goReadOnlyStorage) error {
+	if owner == nil || file.x86DirectTails != nil {
+		return nil // The complete direct-tail producer already audited every root.
+	}
+	for _, fn := range file.Funcs {
+		sig := signatures[resolve(goTextSymbolForResolution(fn.Sym))]
+		if sig.amd64GoArguments == nil || sig.amd64GoArguments.virtual != owner {
+			continue
+		}
+		c := newX86Ctx(new(strings.Builder), fn, sig, resolve, signatures, "amd64", opt.TargetTriple, false)
+		c.goReadOnlyStorage = storage
+		c.fpScalarData = x86LoweredScalarDataReads(file, resolve, signatures, "amd64")
+		c.fpStaticAddressValues = x86LoweredStaticAddressValues(file, resolve, signatures, "amd64")
+		c.fpShiftLiterals = x86LoweredShiftLiterals(file, resolve, c.fpStaticAddressValues, "amd64")
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	return owner.verify()
+}
diff --git a/amd64_go_virtual_arguments_execution_test.go b/amd64_go_virtual_arguments_execution_test.go
new file mode 100644
index 000000000..7bb84e3b1
--- /dev/null
+++ b/amd64_go_virtual_arguments_execution_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+const amd64VirtualArgumentValueDeclarations = amd64VirtualArgumentsDeclarations + `
+func SliceLength(a []byte) uint64
+func SliceCapacity(a []byte) uint64
+func SecondSliceLength(a, b []byte) uint64
+func SecondSliceCapacity(a, b []byte) uint64
+func StringLength(a string) uint64
+`
+
+const amd64VirtualArgumentValueSource = amd64VirtualArgumentsSource + `
+TEXT ·SliceLength<ABIInternal>(SB),4,$0
+	MOVQ BX, AX
+	RET
+
+TEXT ·SliceCapacity<ABIInternal>(SB),4,$0
+	MOVQ CX, AX
+	RET
+
+TEXT ·SecondSliceLength<ABIInternal>(SB),4,$0
+	MOVQ SI, AX
+	RET
+
+TEXT ·SecondSliceCapacity<ABIInternal>(SB),4,$0
+	MOVQ R8, AX
+	RET
+
+TEXT ·StringLength<ABIInternal>(SB),4,$0
+	MOVQ BX, AX
+	RET
+`
+
+// The scalar C ABI shims construct the actual grouped LLVM arguments. They
+// append independent callers to the unchanged translated definitions; they
+// neither flatten/rewrite those definitions nor claim stock-Go native entry.
+func amd64VirtualArgumentScalarShims() string {
+	var result strings.Builder
+	for _, row := range []struct {
+		name, entry string
+		arguments   int
+		slice       bool
+	}{
+		{"virtual_compare_slices", "CompareSlices", 2, true},
+		{"virtual_compare_strings", "CompareStrings", 2, false},
+		{"virtual_slice_length", "SliceLength", 1, true},
+		{"virtual_slice_capacity", "SliceCapacity", 1, true},
+		{"virtual_second_length", "SecondSliceLength", 2, true},
+		{"virtual_second_capacity", "SecondSliceCapacity", 2, true},
+		{"virtual_string_length", "StringLength", 1, false},
+	} {
+		typ, fields := "{ ptr, i64 }", 2
+		if row.slice {
+			typ, fields = "{ ptr, i64, i64 }", 3
+		}
+		var parameters, arguments []string
+		for argument := 0; argument < row.arguments; argument++ {
+			parameters = append(parameters, fmt.Sprintf("ptr %%p%d, i64 %%n%d", argument, argument))
+			if row.slice {
+				parameters = append(parameters, fmt.Sprintf("i64 %%c%d", argument))
+			}
+			arguments = append(arguments, fmt.Sprintf("%s %%a%d_%d", typ, argument, fields-1))
+		}
+		fmt.Fprintf(&result, "\ndefine i64 @%s(%s) {\n", row.name, strings.Join(parameters, ", "))
+		for argument := 0; argument < row.arguments; argument++ {
+			fmt.Fprintf(&result, "  %%a%d_0 = insertvalue %s poison, ptr %%p%d, 0\n", argument, typ, argument)
+			fmt.Fprintf(&result, "  %%a%d_1 = insertvalue %s %%a%d_0, i64 %%n%d, 1\n", argument, typ, argument, argument)
+			if row.slice {
+				fmt.Fprintf(&result, "  %%a%d_2 = insertvalue %s %%a%d_1, i64 %%c%d, 2\n", argument, typ, argument, argument)
+			}
+		}
+		fmt.Fprintf(&result, "  %%value = call i64 @%q(%s)\n  ret i64 %%value\n}\n",
+			amd64VirtualArgumentsPackage+"."+row.entry, strings.Join(arguments, ", "))
+	}
+	return result.String()
+}
+
+func amd64VirtualArgumentValueIR(t *testing.T, triple, api string, preprocessed bool) string {
+	t.Helper()
+	pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, amd64VirtualArgumentValueDeclarations)
+	ir, err := amd64VirtualArgumentsRequest(t, pkg, []byte(amd64VirtualArgumentValueSource), triple, api, preprocessed, nil)
+	if err != nil {
+		t.Fatal("complete original virtual argument source", err)
+	}
+	if strings.Count(ir, "define ") != 7 {
+		t.Fatal("the complete seven public entries were cropped or a private node became a callable entry", ir)
+	}
+	for _, name := range []string{"CompareSlices", "CompareStrings", "SliceLength", "SliceCapacity", "SecondSliceLength", "SecondSliceCapacity", "StringLength"} {
+		if !strings.Contains(ir, "define i64 @"+fmt.Sprintf("%q", pkg.Path+"."+name)+"(") {
+			t.Fatal("original grouped entry missing", name, ir)
+		}
+	}
+	return ir
+}
+
+func TestGoModuleAMD64VirtualArgumentsCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete virtual argument objects require LLVM22 llc")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				for _, preprocessed := range []bool{false, true} {
+					ir := amd64VirtualArgumentValueIR(t, triple, api, preprocessed) + amd64VirtualArgumentScalarShims()
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, input, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("portable virtual argument execution requires LLVM22 llc/clang")
+	}
+	// This runs numerical/opaque-pointer transport on the actual LLVM host.
+	// Large descriptor lengths/capacities test word-width transport only: no
+	// memory is read, and they are not claims about live Go heap allocations.
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler := []string{clang}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+
+extern int64_t virtual_compare_slices(const void *, uint64_t, uint64_t,
+                                      const void *, uint64_t, uint64_t);
+extern int64_t virtual_compare_strings(const void *, uint64_t,
+                                       const void *, uint64_t);
+extern uint64_t virtual_slice_length(const void *, uint64_t, uint64_t);
+extern uint64_t virtual_slice_capacity(const void *, uint64_t, uint64_t);
+extern uint64_t virtual_second_length(const void *, uint64_t, uint64_t,
+                                       const void *, uint64_t, uint64_t);
+extern uint64_t virtual_second_capacity(const void *, uint64_t, uint64_t,
+                                         const void *, uint64_t, uint64_t);
+extern uint64_t virtual_string_length(const void *, uint64_t);
+
+int main(void) {
+    const uint64_t values[] = {
+        0, 1, 63, 64, UINT64_C(0x7fffffff), UINT64_C(0xffffffff),
+        UINT64_C(0x100000000), INT64_MAX
+    };
+    volatile uint8_t canaries[128];
+    for (unsigned i = 0; i < sizeof(canaries); ++i) canaries[i] = (uint8_t)(3*i+7);
+    const void *a = (const void *)&canaries[1];
+    const void *b = (const void *)&canaries[63];
+    if (virtual_compare_slices(NULL,0,0,NULL,0,0) != 0 ||
+        virtual_compare_strings(NULL,0,NULL,0) != 0 ||
+        virtual_slice_length(NULL,0,0) != 0 ||
+        virtual_slice_capacity(NULL,0,0) != 0 ||
+        virtual_string_length(NULL,0) != 0) return 3;
+    for (unsigned i = 0; i < sizeof(values)/sizeof(values[0]); ++i) {
+        for (unsigned j = 0; j < sizeof(values)/sizeof(values[0]); ++j) {
+            uint64_t al = values[i], bl = values[j];
+            uint64_t ac = al + (al < INT64_MAX);
+            uint64_t bc = bl < INT64_MAX-3 ? bl+3 : bl;
+            int64_t want = (al > bl) - (al < bl);
+            if (virtual_compare_slices(a,al,ac,b,bl,bc) != want ||
+                virtual_compare_strings(a,al,b,bl) != want ||
+                virtual_slice_length(a,al,ac) != al ||
+                virtual_slice_capacity(a,al,ac) != ac ||
+                virtual_second_length(a,al,ac,b,bl,bc) != bl ||
+                virtual_second_capacity(a,al,ac,b,bl,bc) != bc ||
+                virtual_string_length(a,al) != al) {
+                fprintf(stderr,"virtual parameter mismatch i=%u j=%u\n",i,j);
+                return 1;
+            }
+            for (unsigned k = 0; k < sizeof(canaries); ++k) {
+                if (canaries[k] != (uint8_t)(3*k+7)) {
+                    fprintf(stderr,"pointer transport wrote caller memory\n");
+                    return 2;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+	for _, api := range []string{"public", "owned-context"} {
+		ir := amd64VirtualArgumentValueIR(t, triple, api, true) + amd64VirtualArgumentScalarShims()
+		for _, optimized := range []bool{false, true} {
+			input := ir
+			if optimized {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("%s/IR_O2=%t/backendO%d", api, optimized, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler,
+						"virtual-go-arguments", triple, input, driver, nil, level)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_go_virtual_arguments_test.go b/amd64_go_virtual_arguments_test.go
new file mode 100644
index 000000000..d0e399ecb
--- /dev/null
+++ b/amd64_go_virtual_arguments_test.go
@@ -0,0 +1,429 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const amd64VirtualArgumentsPackage = "example.com/virtualargs"
+
+const amd64VirtualArgumentsDeclarations = `package virtualargs
+func CompareSlices(a, b []byte) int
+func CompareStrings(a, b string) int
+`
+
+// Two independent public declarations share the complete private continuation.
+// The fixture observes numerical lengths only: pointer identity transport must
+// not be mistaken for permission to dereference, cast or expose those pointers.
+const amd64VirtualArgumentsSource = `
+TEXT ·CompareSlices<ABIInternal>(SB),4,$0-56
+	MOVQ SI, DX
+	MOVQ AX, SI
+	JMP compareLengths<>(SB)
+
+TEXT ·CompareStrings<ABIInternal>(SB),4,$0-40
+	MOVQ AX, SI
+	MOVQ DI, DX
+	MOVQ CX, DI
+	JMP compareLengths<>(SB)
+
+TEXT compareLengths<>(SB),4,$0-0
+	CMPQ BX, DX
+	JEQ equal
+	JLT less
+	MOVQ $1, AX
+	RET
+less:
+	MOVQ $-1, AX
+	RET
+equal:
+	XORQ AX, AX
+	RET
+`
+
+func amd64VirtualArgumentsRequest(t *testing.T, pkg GoPackage, source []byte, triple, api string, preprocessed bool,
+	configure func(*GoModuleOptions),
+) (string, error) {
+	t.Helper()
+	// This helper only translates supplied declarations in the current process.
+	// It captures no stock-Go SDK, compiler archive, source lease or native ABI.
+	return importedGlobalReadRequest(t, pkg, source, "amd64", triple, api, preprocessed, configure)
+}
+
+func amd64VirtualArgumentsRequireContext(t *testing.T, ir string, err error) {
+	t.Helper()
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("virtual language arguments granted unrelated state: output=%t err=%v", ir != "", err)
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsCompleteContinuation(t *testing.T) {
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"public", "owned-context"} {
+			for _, preprocessed := range []bool{false, true} {
+				for _, linkedMain := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/preprocessed=%t/main=%t", triple, api, preprocessed, linkedMain), func(t *testing.T) {
+						pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, amd64VirtualArgumentsDeclarations)
+						if linkedMain {
+							pkg.Path = "main" // Logical linked namespace, not Types.Path().
+						}
+						ir, err := amd64VirtualArgumentsRequest(t, pkg, []byte(amd64VirtualArgumentsSource), triple, api, preprocessed, nil)
+						if err != nil || ir == "" {
+							t.Fatal("actual loaded Go declarations did not initialize their virtual ABIInternal arguments", err)
+						}
+						for _, fragment := range []string{
+							"extractvalue { ptr, i64, i64 } %arg0, 1",
+							"extractvalue { ptr, i64, i64 } %arg1, 1",
+							"extractvalue { ptr, i64 } %arg0, 1",
+							"extractvalue { ptr, i64 } %arg1, 1",
+						} {
+							if !strings.Contains(ir, fragment) {
+								t.Fatal("grouped LLVM parameters did not feed the original register leaves", fragment, ir)
+							}
+						}
+						for _, name := range []string{"CompareSlices", "CompareStrings"} {
+							found := false
+							for _, line := range strings.Split(ir, "\n") {
+								if strings.HasPrefix(line, "define i64 ") && strings.Contains(line, pkg.Path+"."+name) {
+									found = strings.Count(line, "{ ptr, i64") == 2
+								}
+							}
+							if !found {
+								t.Fatal("public grouped Go signature was flattened, renamed or omitted", name, ir)
+							}
+						}
+						if strings.Contains(ir, " nest ") || strings.Contains(ir, " swiftself ") || strings.Contains(ir, " noalias ") {
+							t.Fatal("ordinary virtual parameters acquired hidden/native alias authority", ir)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsDeclaredWidths(t *testing.T) {
+	for _, row := range []struct{ name, parameters, body, extraction string }{
+		{"slice-length", "a []byte", "MOVQ BX,AX", "extractvalue { ptr, i64, i64 } %arg0, 1"},
+		{"slice-capacity", "a []byte", "MOVQ CX,AX", "extractvalue { ptr, i64, i64 } %arg0, 2"},
+		{"second-slice-length", "a,b []byte", "MOVQ SI,AX", "extractvalue { ptr, i64, i64 } %arg1, 1"},
+		{"second-slice-capacity", "a,b []byte", "MOVQ R8,AX", "extractvalue { ptr, i64, i64 } %arg1, 2"},
+		{"string-length", "a string", "MOVQ BX,AX", "extractvalue { ptr, i64 } %arg0, 1"},
+		{"mixed-string-byte", "a string,b byte", "MOVBQZX CL,AX", ""},
+		{"mixed-string-bool", "a string,b bool", "MOVBQZX CL,AX", ""},
+		{"mixed-string-float32", "a string,b float32", "MOVL X0,AX", ""},
+		{"mixed-string-float64", "a string,b float64", "MOVQ X0,AX", ""},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry("+row.parameters+") uint64\n")
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\n" + row.body + "\nRET\n")
+			ir, err := amd64VirtualArgumentsRequest(t, pkg, source, "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			if err != nil || ir == "" || row.extraction != "" && !strings.Contains(ir, row.extraction) {
+				t.Fatal("the original grouped parameter leaf was not transported at its own width", err, ir)
+			}
+		})
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsDoNotGrantOtherState(t *testing.T) {
+	for _, row := range []struct{ name, parameters, body string }{
+		{"unused-GP", "a string", "MOVQ R11,AX"},
+		{"unused-vector", "a string", "MOVQ X0,AX"},
+		{"hidden-context", "a string", "MOVQ 8(DX),AX"},
+		{"stack", "a string", "MOVQ (SP),AX"},
+		{"ABI0-home", "a string", "MOVQ a+0(FP),AX"},
+		{"unknown-FLAGS", "a string", "SETEQ AL\nMOVBQZX AL,AX"},
+		{"pointer-not-NUM", "a string", "MOVQ AX,X0\nMOVQ X0,AX"},
+		{"byte-upper", "a string,b byte", "MOVQ CX,AX"},
+		{"bool-upper", "a string,b bool", "MOVQ CX,AX"},
+		{"float32-upper", "a string,b float32", "MOVQ X0,AX"},
+		{"whole-array-spill", "a [2]uint64", "MOVQ AX,AX"},
+		{"bank-overflow-spill", "a,b,c,d,e,f,g,h,i,j uint64", "MOVQ AX,AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry("+row.parameters+") uint64\n")
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\n" + row.body + "\nRET\n")
+			ir, err := amd64VirtualArgumentsRequest(t, pkg, source, "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			amd64VirtualArgumentsRequireContext(t, ir, err)
+		})
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsNeedActualDeclarations(t *testing.T) {
+	for _, mutation := range []string{"missing-syntax", "missing-function", "wrong-parameter", "wrong-result", "other-package"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+			declarations := map[string]string{
+				"missing-function": "package virtualargs\nfunc Another(a []byte) uint64\n",
+				"wrong-parameter":  "package virtualargs\nfunc Entry(a uint64) uint64\n",
+				"wrong-result":     "package virtualargs\nfunc Entry(a []byte) uint32\n",
+				"other-package":    "package foreign\nfunc Entry(a []byte) uint64\n",
+			}
+			pkg.Syntax = nil
+			if replacement := declarations[mutation]; replacement != "" {
+				pkg.Syntax = mustGoPackage(t, amd64VirtualArgumentsPackage, replacement).Syntax
+			}
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nRET\n")
+			ir, err := amd64VirtualArgumentsRequest(t, pkg, source, "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			amd64VirtualArgumentsRequireContext(t, ir, err)
+		})
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsCannotLendToRawAPI(t *testing.T) {
+	pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+	// Raw APIs still accept their existing low-level register model. This
+	// independent scalar/SIMD observation invokes its complete byte proof,
+	// where a grouped shape alone cannot initialize BX as a slice length.
+	source := "TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nMOVQ AX,X15\nMOVQ X15,AX\nRET\n"
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			amd64VirtualArgumentsRequireContext(t, ir, err)
+		})
+	}
+	t.Run("returned-signatures", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		resolve := testResolveSym(pkg.Path)
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", SourcePreprocessed: true, ResolveSym: resolve,
+		})
+		if err != nil || translated == nil {
+			t.Fatal("complete GoModule source failed before the borrowing control", err)
+		}
+		defer translated.Module.Dispose()
+		if err := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction); err != nil {
+			t.Fatal("invalid virtual argument module", err)
+		}
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			ResolveSym: resolve, Sigs: translated.Signatures})
+		amd64VirtualArgumentsRequireContext(t, ir, err)
+	})
+}
+
+func TestGoModuleAMD64VirtualArgumentsRecheckCallbacks(t *testing.T) {
+	for _, mutation := range []string{"control", "syntax", "source", "resolver"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nRET\n")
+			called := false
+			ir, err := amd64VirtualArgumentsRequest(t, pkg, source, "x86_64-unknown-linux-gnu", "owned-context", true, func(options *GoModuleOptions) {
+				resolve := options.ResolveSym
+				options.ResolveSym = func(symbol string) string {
+					if mutation == "resolver" && called {
+						return "foreign.Entry"
+					}
+					return resolve(symbol)
+				}
+				options.KeepFunc = func(_, _ string) bool {
+					called = true
+					if mutation == "syntax" {
+						ast.Inspect(pkg.Syntax[0], func(node ast.Node) bool {
+							if ident, ok := node.(*ast.Ident); ok && ident.Name == "byte" {
+								ident.Name = "uint64"
+							}
+							return true
+						})
+					} else if mutation == "source" {
+						source[len(source)-1] = ' '
+					}
+					return true // No source or public entry is filtered out.
+				}
+			})
+			if !called {
+				t.Fatal("the real source callback was not reached")
+			}
+			if mutation == "control" {
+				if err != nil || ir == "" {
+					t.Fatal("unmodified virtual argument source failed", err)
+				}
+			} else {
+				amd64VirtualArgumentsRequireContext(t, ir, err)
+			}
+		})
+	}
+}
+
+type amd64VirtualArgumentCountingSizes struct {
+	types.Sizes
+	queries int
+	onQuery func()
+}
+
+func (sizes *amd64VirtualArgumentCountingSizes) Sizeof(typ types.Type) int64 {
+	sizes.queries++
+	if sizes.onQuery != nil {
+		sizes.onQuery()
+	}
+	return sizes.Sizes.Sizeof(typ)
+}
+
+func (sizes *amd64VirtualArgumentCountingSizes) Alignof(typ types.Type) int64 {
+	sizes.queries++
+	return sizes.Sizes.Alignof(typ)
+}
+
+func (sizes *amd64VirtualArgumentCountingSizes) Offsetsof(fields []*types.Var) []int64 {
+	sizes.queries++
+	return sizes.Sizes.Offsetsof(fields)
+}
+
+// Internal symbol/register operations consume the private immutable plan,
+// not repeated full-package declaration observations. Complete boundaries
+// still query the live supplied inputs and revoke the call after a mutation.
+func TestGoModuleAMD64VirtualArgumentsBoundedInternalChecks(t *testing.T) {
+	for _, mutation := range []string{"control", "syntax", "source"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nRET\n")
+			file, err := Parse(ArchAMD64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := &amd64VirtualArgumentCountingSizes{Sizes: types.SizesFor("gc", "amd64")}
+			owner, err := bindAMD64GoVirtualArguments(pkg, file, source, sha256.Sum256(source),
+				GoModuleOptions{GOARCH: "amd64", Sizes: sizes}, testResolveSym(pkg.Path))
+			if err != nil || owner == nil || sizes.queries == 0 {
+				t.Fatal("the complete declaration boundary was not observed", err, sizes.queries)
+			}
+			defer func() { owner.active = false }()
+			entry := owner.entries[pkg.Path+".Entry"]
+			if entry == nil {
+				t.Fatal("actual declaration lost its private parameter plan")
+			}
+			sig := entry.signature
+			sig.amd64GoArguments = entry
+			sizes.queries = 0
+			for count := 0; count < 100; count++ {
+				if owner.resolveSymbol("·Entry") != sig.Name || !entry.valid(file.Funcs[0], sig, "amd64") {
+					t.Fatal("internal immutable-plan check failed", count)
+				}
+			}
+			if sizes.queries != 0 {
+				t.Fatal("internal resolution repeated whole declaration/layout observations", sizes.queries)
+			}
+			if mutation == "syntax" {
+				pkg.Syntax[0].Name.Name = "foreign"
+			} else if mutation == "source" {
+				source[len(source)-1] = ' '
+			}
+			err = owner.verify()
+			if mutation == "control" {
+				if err != nil || sizes.queries == 0 {
+					t.Fatal("final boundary did not recheck live declarations", err, sizes.queries)
+				}
+			} else {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("final boundary accepted changed inputs", err)
+				}
+				pkg.Syntax[0].Name.Name = "virtualargs"
+				source[len(source)-1] = '\n'
+				if entry.valid(file.Funcs[0], sig, "amd64") {
+					t.Fatal("restoring an invalidated source revived its old call-local role")
+				}
+			}
+		})
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsFinalLayoutCallbacks(t *testing.T) {
+	for _, mutation := range []string{"syntax", "source", "imports"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+			pkg.Imports = make(map[string]*types.Package)
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nRET\n")
+			file, err := Parse(ArchAMD64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := &amd64VirtualArgumentCountingSizes{Sizes: types.SizesFor("gc", "amd64")}
+			owner, err := bindAMD64GoVirtualArguments(pkg, file, source, sha256.Sum256(source),
+				GoModuleOptions{GOARCH: "amd64", Sizes: sizes}, testResolveSym(pkg.Path))
+			if err != nil || owner == nil {
+				t.Fatal("complete declaration boundary failed", err)
+			}
+			defer func() { owner.active = false }()
+			called := false
+			sizes.onQuery = func() {
+				sizes.onQuery = nil // Mutate in the final layout query, not during capture.
+				called = true
+				switch mutation {
+				case "syntax":
+					pkg.Syntax[0].Name.Name = "foreign"
+				case "source":
+					source[len(source)-1] = ' '
+				case "imports":
+					pkg.Imports["foreign"] = types.NewPackage("foreign", "foreign")
+				}
+			}
+			if err := owner.verify(); !called || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a final layout callback changed supplied inputs after their last observation", called, err)
+			}
+		})
+	}
+}
+
+func TestGoModuleAMD64VirtualArgumentsReleaseCallInputs(t *testing.T) {
+	for _, api := range []string{"public", "owned-context"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\nfunc Entry(a []byte) uint64\n")
+			pkg.SourceSelection = new(GoSourceSelection) // No raw caller consumes this object.
+			source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\nMOVQ BX,AX\nRET\n")
+			options := GoModuleOptions{GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				SourcePreprocessed: true, ResolveSym: testResolveSym(pkg.Path)}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			var translated *GoModuleTranslation
+			var err error
+			if api == "public" {
+				translated, err = TranslateGoModule(pkg, source, options)
+			} else {
+				translated, err = translateGoModuleInContext(ctx, pkg, source, options)
+			}
+			if err != nil || translated == nil {
+				t.Fatal("complete virtual argument translation failed", err)
+			}
+			defer translated.Module.Dispose()
+			if err := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("invalid returned virtual argument module", err)
+			}
+			sig := translated.Signatures[pkg.Path+".Entry"]
+			entry := sig.amd64GoArguments
+			if entry == nil || entry.virtual == nil {
+				t.Fatal("returned signatures lost their closed private-role tombstone")
+			}
+			owner := entry.virtual
+			if owner.active || !errors.Is(owner.live(), ErrProbeNeedsContext) {
+				t.Fatal("returned signature retained an active call-local role")
+			}
+			if !reflect.DeepEqual(owner.pkg, GoPackage{}) || owner.syntax != nil || owner.imports != nil ||
+				owner.input != nil || owner.file != nil || owner.entries != nil || owner.symbols != nil ||
+				owner.resolve != nil || owner.sizes != nil || owner.frameSizes != nil || entry.plan != nil || entry.declaration != nil {
+				t.Fatal("closed signature retained owned package/types/syntax/source/plan/callback inputs")
+			}
+			if len(sig.Args) != 1 || sig.Args[0] != "{ ptr, i64, i64 }" || sig.Ret != I64 || len(sig.Frame.Params) != 3 {
+				t.Fatal("releasing private call inputs changed the returned public language signature", sig)
+			}
+			file, err := Parse(ArchAMD64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: options.TargetTriple,
+				ResolveSym: options.ResolveSym, Sigs: translated.Signatures})
+			amd64VirtualArgumentsRequireContext(t, ir, err)
+		})
+	}
+}
diff --git a/amd64_go_virtual_bool_test.go b/amd64_go_virtual_bool_test.go
new file mode 100644
index 000000000..701dfa01b
--- /dev/null
+++ b/amd64_go_virtual_bool_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+const amd64VirtualBoolDeclarations = `package virtualargs
+type Flag bool
+type Pair struct { First, Second bool }
+func Identity(a bool) bool
+func Invert(a bool) bool
+func Widen(a bool) uint64
+func Second(a, b bool) bool
+func Named(a Flag) Flag
+func PairSecond(a Pair) bool
+`
+
+const amd64VirtualBoolSource = `
+TEXT ·Identity<ABIInternal>(SB),4,$0
+	RET
+TEXT ·Invert<ABIInternal>(SB),4,$0
+	XORB $1, AX
+	RET
+TEXT ·Widen<ABIInternal>(SB),4,$0
+	MOVBQZX AL, AX
+	RET
+TEXT ·Second<ABIInternal>(SB),4,$0
+	MOVB BL, AL
+	RET
+TEXT ·Named<ABIInternal>(SB),4,$0
+	RET
+TEXT ·PairSecond<ABIInternal>(SB),4,$0
+	MOVB BL, AL
+	RET
+`
+
+// These wrappers call the unchanged grouped LLVM declarations. Their i1
+// inputs represent Go bool values, not arbitrary native bytes or a stock-Go
+// register ABI. Returning i64 avoids depending on the host C bool ABI.
+func amd64VirtualBoolWrappers() string {
+	var wrappers strings.Builder
+	for _, name := range []string{"Identity", "Invert", "Widen", "Second", "Named", "PairSecond"} {
+		fmt.Fprintf(&wrappers, "\ndefine i64 @bool_%s(i32 %%a, i32 %%b) {\n", name)
+		wrappers.WriteString("  %x = icmp ne i32 %a, 0\n  %y = icmp ne i32 %b, 0\n")
+		arguments, result := "i1 %x", "i1"
+		switch name {
+		case "Second":
+			arguments = "i1 %x, i1 %y"
+		case "PairSecond":
+			wrappers.WriteString("  %first = insertvalue { i1, i1 } poison, i1 %x, 0\n")
+			wrappers.WriteString("  %pair = insertvalue { i1, i1 } %first, i1 %y, 1\n")
+			arguments = "{ i1, i1 } %pair"
+		case "Widen":
+			result = "i64"
+		}
+		fmt.Fprintf(&wrappers, "  %%value = call %s @%q(%s)\n", result, amd64VirtualArgumentsPackage+"."+name, arguments)
+		if result == "i1" {
+			wrappers.WriteString("  %wide = zext i1 %value to i64\n  ret i64 %wide\n}\n")
+		} else {
+			wrappers.WriteString("  ret i64 %value\n}\n")
+		}
+	}
+	return wrappers.String()
+}
+
+func amd64VirtualBoolIR(t *testing.T, triple, api string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, amd64VirtualBoolDeclarations)
+	ir, err := amd64VirtualArgumentsRequest(t, pkg, []byte(amd64VirtualBoolSource), triple, api, false, nil)
+	if err != nil || strings.Count(ir, "define ") != 6 {
+		t.Fatal("complete typed boolean input family was not translated", err, ir)
+	}
+	return ir + amd64VirtualBoolWrappers()
+}
+
+func TestGoModuleAMD64VirtualBoolObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("typed boolean objects require LLVM22 llc")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				x86PackedStringCompileObject(t, llc, triple, amd64VirtualBoolIR(t, triple, api), "-O2")
+			})
+		}
+	}
+}
+
+func TestGoModuleAMD64VirtualBoolPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("typed boolean execution requires LLVM22 llc/clang")
+	}
+	const driver = `#include <stdint.h>
+extern uint64_t bool_Identity(uint32_t,uint32_t), bool_Invert(uint32_t,uint32_t);
+extern uint64_t bool_Widen(uint32_t,uint32_t), bool_Second(uint32_t,uint32_t);
+extern uint64_t bool_Named(uint32_t,uint32_t), bool_PairSecond(uint32_t,uint32_t);
+int main(void) {
+    for (uint32_t a = 0; a != 2; ++a) {
+        for (uint32_t b = 0; b != 2; ++b) {
+            if (bool_Identity(a,b) != a || bool_Invert(a,b) != 1-a ||
+                bool_Widen(a,b) != a || bool_Second(a,b) != b ||
+                bool_Named(a,b) != a || bool_PairSecond(a,b) != b) return 1;
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler := []string{clang}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	for _, api := range []string{"public", "owned-context"} {
+		ir := amd64VirtualBoolIR(t, triple, api)
+		for _, optimized := range []bool{false, true} {
+			input := ir
+			if optimized {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("%s/IR_O2=%t/backendO%d", api, optimized, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "virtual-bool", triple, input, driver, nil, level)
+				})
+			}
+		}
+	}
+}
+
+func TestGoModuleAMD64VirtualBoolKeepsOtherStateUnknown(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"upper-input", "func Entry(a bool) uint64", "MOVQ AX,AX"},
+		{"upper-named-input", "type Flag bool\nfunc Entry(a Flag) uint64", "MOVQ AX,AX"},
+		{"upper-second-input", "func Entry(a,b bool) uint64", "MOVQ BX,AX"},
+		{"aggregate-result", "func Entry(a bool) (bool,bool)", "MOVB $1,AX\nMOVB $1,BX"},
+		{"noncanonical-result", "func Entry(a bool) bool", "MOVB $2,AX"},
+		{"unknown-register", "func Entry(a bool) bool", "MOVB DL,AL"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, amd64VirtualArgumentsPackage, "package virtualargs\n"+row.declaration+"\n")
+				source := []byte("TEXT ·Entry<ABIInternal>(SB),4,$0\n" + row.body + "\nRET\n")
+				ir, err := amd64VirtualArgumentsRequest(t, pkg, source, "x86_64-unknown-linux-gnu", api, false, nil)
+				amd64VirtualArgumentsRequireContext(t, ir, err)
+			})
+		}
+	}
+}
diff --git a/amd64_go_windows_private_leaf_go127_test.go b/amd64_go_windows_private_leaf_go127_test.go
new file mode 100644
index 000000000..5380f8fb3
--- /dev/null
+++ b/amd64_go_windows_private_leaf_go127_test.go
@@ -0,0 +1,201 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64WindowsPrivateLeafCompleteObjects(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, spelling := range []string{"leaf<>", "leaf"} {
+		t.Run(spelling, func(t *testing.T) {
+			assembly := fixedLocalPrivateLeafSource("CALL leaf<>(SB)", "ADDQ BX,(BP)\nMOVQ (BP),AX")
+			assembly = strings.ReplaceAll(assembly, "leaf<>", spelling)
+			pkg, request, options := fixedLocalPrivateLeafFixture(t, assembly)
+			request.Target = "windows/amd64"
+			options.TargetTriple = "x86_64-pc-windows-msvc"
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, []string{pkg.Path + ".Value"})
+					compileLLVMToObject(t, llc, options.TargetTriple, "private-leaf.ll", "private-leaf.o", ir)
+					compileLLVMToObject(t, llc, options.TargetTriple, "private-leaf-opt.ll", "private-leaf-opt.o", x86MulDivRoundOptimize(t, ir))
+				})
+		})
+	}
+}
+
+func TestGoAMD64WindowsPrivateLeafSourceRoleBoundaries(t *testing.T) {
+	for _, spelling := range []string{"leaf<>", "leaf"} {
+		t.Run(spelling, func(t *testing.T) {
+			assembly := strings.ReplaceAll(fixedLocalPrivateLeafSource("CALL leaf<>(SB)",
+				"ADDQ BX,(BP)\nMOVQ (BP),AX"), "leaf<>", spelling)
+			pkg, request, _ := fixedLocalPrivateLeafFixture(t, assembly)
+			request.Target = "windows/amd64"
+			source := requireGoAMD64FrameCapture(t, pkg, request)
+			object, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			listing, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := source.frameDataObject(assembly, object)
+			if err != nil {
+				t.Fatal(err)
+			}
+			leaves, err := goAMD64WindowsSourceLeafTexts(file, pkg, listing, data.Member.Texts, data.TextOrder)
+			if err != nil || len(leaves) != 1 {
+				t.Fatal("complete source did not retain its one exact private leaf", err)
+			}
+			observed, err := source.observeWindowsUnwind(object, leaves)
+			if err != nil || len(observed.Texts) != 2 || len(observed.Unwind) != 1 {
+				t.Fatal("framed root and zero-frame leaf lost their distinct SEH roles", err)
+			}
+			if _, err := source.observeWindowsUnwind(object); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("default metadata observation inferred a private source role", err)
+			}
+			for _, change := range nativeHeaderRoleChanges() {
+				t.Run("header-"+change.name, func(t *testing.T) {
+					rows := strings.Split(string(listing), "\n")
+					changed := false
+					for index, row := range rows {
+						if strings.HasPrefix(row, leaves[0].Name+" STEXT ") && strings.Contains(row, change.before) {
+							rows[index] = nativeHeaderChangedRole(row, change.before, change.after)
+							changed = true
+						}
+					}
+					if !changed {
+						t.Fatal("actual private header precondition changed")
+					}
+					mutated := []byte(strings.Join(rows, "\n"))
+					copyData := *data
+					copyData.Member.Texts = append([]gostaticstorage.TextRecord(nil), data.Member.Texts...)
+					for index := range copyData.Member.Texts {
+						text := &copyData.Member.Texts[index]
+						if text.Index == leaves[0].Index {
+							if change.name == "dupok" {
+								text.Flags |= 0x01
+							} else if change.name == "leaf" {
+								text.Flags |= 0x08
+							}
+						}
+					}
+					// These edited observations are mutation controls, not new
+					// Go objects. Matching metadata still grants no private role.
+					if _, err := sdkAMD64FrameNativeRecordsForSource(mutated, copyData.Member.Texts, copyData.TextOrder); err != nil {
+						t.Fatal("role control did not reach the private entry boundary", err)
+					}
+					if _, err := goAMD64WindowsSourceLeafTexts(file, pkg, mutated, copyData.Member.Texts, copyData.TextOrder); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("special or unknown metadata acquired a Windows private leaf role", err)
+					}
+				})
+			}
+			var root gostaticstorage.TextRecord
+			for _, text := range observed.Texts {
+				if text.Index != leaves[0].Index {
+					root = text
+				}
+			}
+			serialized, err := json.Marshal(leaves)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutations := map[string]func([]gostaticstorage.TextRecord) []gostaticstorage.TextRecord{
+				"missing leaf": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord { return nil },
+				"duplicate leaf": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					return append(v, v[0])
+				},
+				"framed root is not leaf": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					return []gostaticstorage.TextRecord{root}
+				},
+				"foreign name": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Name += "Other"
+					return v
+				},
+				"foreign ABI": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].ABI = 1
+					return v
+				},
+				"foreign index": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Index = root.Index
+					return v
+				},
+				"foreign namespace": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Namespace = gostaticstorage.TextSymbolHashed
+					return v
+				},
+				"changed bytes": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Code[0] ^= 1
+					return v
+				},
+				"changed source PC": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Positions[0].Line++
+					return v
+				},
+				"changed relative index": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Relative++
+					return v
+				},
+				"borrowed root auxiliary": func(v []gostaticstorage.TextRecord) []gostaticstorage.TextRecord {
+					v[0].Auxiliary = root.Auxiliary
+					return v
+				},
+			}
+			for name, mutate := range mutations {
+				t.Run(name, func(t *testing.T) {
+					var changed []gostaticstorage.TextRecord
+					if err := json.Unmarshal(serialized, &changed); err != nil {
+						t.Fatal(err)
+					}
+					if _, err := source.observeWindowsUnwind(object, mutate(changed)); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed source/object leaf descriptor acquired a metadata exception", err)
+					}
+				})
+			}
+			for name, change := range map[string][2]string{
+				"nonzero helper frame": {"TEXT " + spelling + "(SB),4,$0", "TEXT " + spelling + "(SB),4,$8"},
+				"helper SP read":       {"ADDQ BX,(BP)", "MOVQ (SP),AX"},
+				"helper stack write":   {"ADDQ BX,(BP)", "PUSHQ AX"},
+				"helper is not leaf":   {"ADDQ BX,(BP)", "CALL " + spelling + "(SB)"},
+			} {
+				t.Run(name, func(t *testing.T) {
+					changed := strings.Replace(assembly, change[0], change[1], 1)
+					if changed == assembly {
+						t.Fatal("source role control did not alter the complete source")
+					}
+					parsed, err := Parse(ArchAMD64, changed)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := goAMD64WindowsSourceLeafTexts(parsed, pkg, listing, data.Member.Texts, data.TextOrder); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("non-leaf source acquired a zero-frame metadata role", err)
+					}
+				})
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("readonly role controls changed the original capture", err)
+			}
+		})
+	}
+}
diff --git a/amd64_go_windows_unwind.go b/amd64_go_windows_unwind.go
new file mode 100644
index 000000000..00ddfd245
--- /dev/null
+++ b/amd64_go_windows_unwind.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"bytes"
+	"go/types"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func (source *GoAMD64FrameSource) observeWindowsUnwind(object []byte, privateLeaves ...[]gostaticstorage.TextRecord) (gostaticstorage.WindowsAMD64AssemblyUnwind, error) {
+	var empty gostaticstorage.WindowsAMD64AssemblyUnwind
+	builtin, err := source.windowsUnwindBuiltin()
+	if err != nil {
+		return empty, err
+	}
+	observed, err := gostaticstorage.ObserveWindowsAMD64AssemblyUnwind(object, builtin, privateLeaves...)
+	if err != nil {
+		return empty, goAMD64FrameContext("Windows unwind complete object metadata: %v", err)
+	}
+	if observed.Version != source.env["GOVERSION"] {
+		return empty, goAMD64FrameContext("Windows unwind object differs from its actual producer")
+	}
+	return observed, nil
+}
+
+func (source *GoAMD64FrameSource) windowsUnwindBuiltin() ([]byte, error) {
+	for _, declaration := range source.declarations {
+		if !fixedLocalTransportRole(declaration.transport) {
+			return nil, goAMD64FrameContext("Windows unwind join requires the closed typed ABI0 transport scope")
+		}
+	}
+	builtin, err := gostaticstorage.WindowsAMD64UnwindSources(source.env["GOVERSION"], func(name string) ([]byte, error) {
+		return source.read(filepath.Join(source.env["GOROOT"], filepath.FromSlash(name)))
+	})
+	if err != nil {
+		return nil, goAMD64FrameContext("Windows unwind actual SDK sources: %v", err)
+	}
+	return builtin, nil
+}
+
+// Only the complete original source classification can select leaf records.
+// Keep their full raw object identity, including namespace, ABI, bytes and PCs;
+// neither a static ABI number nor absent SEH metadata establishes this role.
+func goAMD64WindowsSourceLeafTexts(file *File, pkg GoPackage, listing []byte,
+	texts []gostaticstorage.TextRecord, order []gostaticstorage.ASMSourceText) ([]gostaticstorage.TextRecord, error) {
+	leaves, err := goAMD64FramePrivateLeaves(file, pkg)
+	if err != nil {
+		return nil, err
+	}
+	records, err := sdkAMD64FrameNativeRecordsForSource(listing, texts, order)
+	if err != nil || len(records) != len(file.Funcs) {
+		return nil, goAMD64FrameContext("Windows private leaf lacks a complete source/object TEXT association: %v", err)
+	}
+	var result []gostaticstorage.TextRecord
+	for index, fn := range file.Funcs {
+		if !leaves[fn.Sym] && !goAMD64DeclaredNoFrameLeaf(fn, pkg) {
+			continue
+		}
+		text := texts[order[index].ObjectOrdinal]
+		expectedName := strings.TrimSuffix(fn.Sym, "<>")
+		if !leaves[fn.Sym] {
+			expectedName = pkg.Path + "." + strings.TrimPrefix(fn.Sym, "·")
+		}
+		abi, namespace := uint16(0), gostaticstorage.TextSymbolNonpkgDefinition
+		if strings.HasSuffix(fn.Sym, "<>") {
+			abi, namespace = 65535, gostaticstorage.TextSymbolSelf
+		}
+		if text.Name != expectedName || text.ABI != abi || text.Namespace != namespace ||
+			!records[index].ordinaryFrameRole() || records[index].Locals != uint64(goAMD64FrameNativeLocals(fn.FrameSize)) {
+			return nil, goAMD64FrameContext("Windows private leaf changed its exact source symbol/ABI/namespace")
+		}
+		result = append(result, text)
+	}
+	return result, nil
+}
+
+// Match the pinned x86 producer's automatic NoFrame leaf rule. This selects
+// metadata observations only; ordinary FP slots still come from the declaration
+// and this function never establishes a private CALL or local backing role.
+func goAMD64DeclaredNoFrameLeaf(fn Func, pkg GoPackage) bool {
+	if fn.FrameSize != 0 || pkg.Types == nil {
+		return false
+	}
+	if _, declared := pkg.Types.Scope().Lookup(strings.TrimPrefix(fn.Sym, "·")).(*types.Func); !declared {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpCALL || ins.Op == "DUFFCOPY" || ins.Op == "DUFFZERO" {
+			return false
+		}
+	}
+	return true
+}
+
+func goAMD64WindowsUnwindByteRow(line string, offset int, expected []byte) ([]byte, error) {
+	pc, actual, err := goAssemblyListingByteRow(line)
+	if err != nil || len(expected) != 12 || offset != 0 || pc != 0 || !bytes.Equal(actual, expected) {
+		return nil, goAMD64FrameContext("Windows unwind listing differs from complete original binary bytes")
+	}
+	return actual, nil
+}
+
+// This private join consumes the factory's independently read whole object.
+// A public offline observation is never itself an authorization input.
+func goAMD64FrameWindowsUnwindListing(listing []byte, file *File, pkg GoPackage, origins map[string]int, directory string, observed gostaticstorage.WindowsAMD64AssemblyUnwind) (map[string]goAMD64FrameFunction, error) {
+	functions, err := goAMD64FrameListingWithSplitObject(listing, file, pkg, origins, observed.Texts, &observed, "windows/amd64", directory, "")
+	if err != nil {
+		return nil, err
+	}
+	if err := goAMD64FrameWindowsUnwindFunctions(functions, origins, directory, observed); err != nil {
+		return nil, err
+	}
+	return functions, nil
+}
+
+func goAMD64FrameWindowsUnwindFunctions(functions map[string]goAMD64FrameFunction, origins map[string]int, directory string, observed gostaticstorage.WindowsAMD64AssemblyUnwind) error {
+	if len(observed.Texts) != len(functions) {
+		return goAMD64FrameContext("Windows object/listing complete TEXT inventories differ")
+	}
+	unwind := make(map[string]gostaticstorage.WindowsAMD64UnwindRecord)
+	for _, record := range observed.Unwind {
+		unwind[record.Name] = record
+	}
+	seen := make(map[string]bool)
+	for _, text := range observed.Texts {
+		fn, exists := functions[text.Name]
+		abi := uint16(0)
+		if fn.privateLeaf {
+			abi = fn.nativeABI
+		}
+		if !exists || seen[text.Name] || text.ABI != abi || text.Kind != 1 || text.Flags != fn.nativeFlags() || text.Flags2 != observed.TextFlags2 ||
+			!bytes.Equal(text.Code, fn.code) || fn.prologue < 0 || fn.prologue >= len(fn.code) {
+			return goAMD64FrameContext("Windows object/listing TEXT name/ABI/code role differs")
+		}
+		seen[text.Name] = true
+		var metadata gostaticstorage.WindowsAMD64UnwindRecord
+		for _, aux := range text.Auxiliary {
+			if aux.Type == observed.AuxType {
+				metadata = unwind[aux.Target.Name]
+			}
+		}
+		if fn.locals == 0 {
+			if metadata.Name != "" || fn.prologue != 0 || fn.split {
+				return goAMD64FrameContext("Windows private leaf acquired an automatic frame or SEH prologue")
+			}
+			if fn.privateLeaf {
+				if err := goAMD64FrameMachineShapeWithCalls(fn, 0, nil); err != nil {
+					return err
+				}
+			}
+			if err := goAMD64FrameSourcePCs(text, fn, directory, origins, ""); err != nil {
+				return err
+			}
+			continue
+		}
+		first, err := x86asm.Decode(fn.code[fn.prologue:], 64)
+		if err != nil || first.Op != x86asm.PUSH || first.Args[0] != x86asm.RBP || fn.prologue+first.Len != int(metadata.PushEnd) {
+			return goAMD64FrameContext("Windows unwind push end differs from actual automatic prologue")
+		}
+		second, err := x86asm.Decode(fn.code[fn.prologue+first.Len:], 64)
+		if err != nil || second.Op != x86asm.MOV || second.Args[0] != x86asm.RBP || second.Args[1] != x86asm.RSP ||
+			fn.prologue+first.Len+second.Len != int(metadata.PrologueEnd) {
+			return goAMD64FrameContext("Windows unwind frame end differs from actual automatic prologue")
+		}
+		if err := goAMD64FrameSourcePCs(text, fn, directory, origins, ""); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func goAMD64FrameSourcePath(name, directory, root string) string {
+	if strings.HasPrefix(name, "$GOROOT/") {
+		if root == "" {
+			return ""
+		}
+		actual, valid := originalGoObjectSourcePath(name, root)
+		if !valid {
+			return ""
+		}
+		return actual
+	}
+	if !filepath.IsAbs(name) {
+		name = filepath.Join(directory, filepath.FromSlash(name))
+	}
+	return filepath.Clean(name)
+}
+
+func goAMD64FrameSourcePCs(text gostaticstorage.TextRecord, fn goAMD64FrameFunction, directory string, origins map[string]int, root string) error {
+	normalize := func(name string) string { return goAMD64FrameSourcePath(name, directory, root) }
+	// Go object file tables use slash paths on Windows, while captured
+	// origins retain host paths and the command's relative source spelling.
+	// Compare their already-bound paths consistently with the listing join;
+	// aliases must still agree on the complete original source extent. SDK
+	// metadata additionally uses only the captured root's strict path spelling;
+	// resolving it never adds an input to this complete original inventory.
+	linesByPath := make(map[string]int, len(origins))
+	for name, lines := range origins {
+		path := normalize(name)
+		if path == "" {
+			return goAMD64FrameContext("source origin has an unbound SDK path")
+		}
+		if previous, found := linesByPath[path]; found && previous != lines {
+			return goAMD64FrameContext("source origin aliases disagree on their original extent")
+		}
+		linesByPath[path] = lines
+	}
+	var previous int64
+	for _, span := range text.Positions {
+		if span.File == "" || span.Line <= 0 || int(span.Line) > linesByPath[normalize(span.File)] || span.Start < 0 ||
+			span.Start != previous || span.End <= span.Start || span.End > int64(len(fn.code)) {
+			return goAMD64FrameContext("object source-PC interval lacks its original file/line/extent: %s %s:%d [%d,%d)",
+				text.Name, span.File, span.Line, span.Start, span.End)
+		}
+		previous = span.End
+	}
+	if previous != int64(len(fn.code)) {
+		return goAMD64FrameContext("source-PC intervals do not cover the complete physical TEXT")
+	}
+	for pc, positions := range fn.sourcePositions {
+		matched := false
+		for _, span := range text.Positions {
+			if span.Start > int64(pc) || span.End <= int64(pc) {
+				continue
+			}
+			for _, position := range positions {
+				if normalize(position.file) == normalize(span.File) && position.line == int(span.Line) {
+					matched = true
+				}
+			}
+		}
+		if !matched {
+			return goAMD64FrameContext("object/listing source-PC file/line witness differs")
+		}
+	}
+	return nil
+}
diff --git a/amd64_go_windows_unwind_join_test.go b/amd64_go_windows_unwind_join_test.go
new file mode 100644
index 000000000..0537ed243
--- /dev/null
+++ b/amd64_go_windows_unwind_join_test.go
@@ -0,0 +1,250 @@
+//go:build go1.23
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoAMD64WindowsUnwindCompleteObjectListingJoinGuards(t *testing.T) {
+	goAMD64WindowsUnwindCompleteObjectListingJoinGuards(t)
+}
+
+func TestGoAMD64WindowsUnwindCompleteJoinTemporaryParentAlias(t *testing.T) {
+	goAMD64WindowsUnwindTemporaryParentAlias(t)
+	// A new child owns a fresh testing.TempDir root under the explicit alias.
+	// The parent's root was already created while constructing that alias.
+	t.Run("AliasedTemporaryParent", goAMD64WindowsUnwindCompleteObjectListingJoinGuards)
+}
+
+func goAMD64WindowsUnwindCompleteObjectListingJoinGuards(t *testing.T) {
+	t.Helper()
+	pkg, request := goAMD64FrameSourceFixture(t)
+	request.Target = "windows/amd64"
+	source := requireGoAMD64FrameCapture(t, pkg, request)
+	t.Logf("ACTUAL_WINDOWS_SOURCE_CAPTURE request=%q observed=%q functions=%d",
+		request.Directory, source.request.Directory, len(source.functions))
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	object, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	listing, err := source.read(filepath.Join(source.owned, request.AssemblyFile+".o.listing"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := source.read(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := source.preprocess(request.AssemblyFile, original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := source.observeWindowsUnwind(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, version := range []string{"go1.27.1", "go1.27.2", "go1.99.1"} {
+		if version == observed.Version {
+			continue
+		}
+		changed := bytes.Replace(object, []byte(observed.Version+" "), []byte(version+" "), 1)
+		if bytes.Equal(changed, object) {
+			t.Fatal("object version mutation did not replace its producer")
+		}
+		if _, err := source.observeWindowsUnwind(changed); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("object substituted another actual producer", version, err)
+		}
+	}
+	functions, err := goAMD64FrameWindowsUnwindListing(listing, file, pkg, source.origins, request.Directory, observed)
+	if err != nil {
+		t.Fatal("independent actual original metadata join control failed", err)
+	}
+	for _, spelling := range []string{"absolute", "slash absolute", "relative", "conflicting extent", "foreign directory"} {
+		t.Run("source origins/"+spelling, func(t *testing.T) {
+			origins := make(map[string]int)
+			relativeNames := 0
+			for name, lines := range source.origins {
+				if !filepath.IsAbs(name) {
+					name = filepath.Join(request.Directory, name)
+				}
+				if spelling == "slash absolute" {
+					name = filepath.ToSlash(name)
+				}
+				if spelling == "relative" {
+					relative, err := filepath.Rel(request.Directory, name)
+					if err != nil {
+						// A Windows SDK can live on another volume. That
+						// header must remain absolute; own assembly inputs
+						// below still exercise actual relative spellings.
+						if filepath.VolumeName(request.Directory) == filepath.VolumeName(name) {
+							t.Fatal(err)
+						}
+					} else {
+						name = relative
+						relativeNames++
+					}
+				}
+				if spelling == "foreign directory" {
+					name = filepath.Join(request.Directory, "foreign", filepath.Base(name))
+				}
+				origins[name] = lines
+			}
+			if spelling == "relative" && relativeNames == 0 {
+				t.Fatal("relative-source control did not exercise any relative path")
+			}
+			if spelling == "conflicting extent" {
+				origins[request.AssemblyFile] = source.origins[request.AssemblyFile] + 1
+			}
+			for _, text := range observed.Texts {
+				err := goAMD64FrameSourcePCs(text, functions[text.Name], request.Directory, origins, "")
+				if spelling == "conflicting extent" || spelling == "foreign directory" {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unbound or contradictory source origin acquired a PC witness", err)
+					}
+				} else if err != nil {
+					t.Fatal("actual source origin was lost through its host path spelling", err)
+				}
+			}
+		})
+	}
+	serialized, err := json.Marshal(observed)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// These are ordinary read-only observations, deliberately copied only for
+	// decoder negatives. None are accepted as a public Source/factory input.
+	type mutation func([]byte, *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte
+	metadataStart := bytes.Index(listing, []byte(observed.Unwind[0].Name+" SSEHUNWINDINFO"))
+	if metadataStart < 0 {
+		t.Fatal("original listing omitted its actual complete metadata section")
+	}
+	mutations := map[string]mutation{
+		"wrong metadata name": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte("go:sehuw.12."), []byte("go:sehuw.13."), 1)
+		},
+		"wrong metadata kind": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte("SSEHUNWINDINFO"), []byte("SRODATA"), 1)
+		},
+		"wrong metadata flags": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte("SSEHUNWINDINFO dupok"), []byte("SSEHUNWINDINFO"), 1)
+		},
+		"wrong metadata alignment": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte("SSEHUNWINDINFO dupok size=12"), []byte("SSEHUNWINDINFO dupok size=12 align=0x8"), 1)
+		},
+		"other SDK alignment spelling": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			if observed.ListingAlignment {
+				return bytes.Replace(v, []byte("size=12 align=0x4"), []byte("size=12"), 1)
+			}
+			return bytes.Replace(v, []byte("SSEHUNWINDINFO dupok size=12"), []byte("SSEHUNWINDINFO dupok size=12 align=0x4"), 1)
+		},
+		"wrong metadata byte": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte("01 04 02 05"), []byte("02 04 02 05"), 1)
+		},
+		"wrong metadata ASCII": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return bytes.Replace(v, []byte(".......P...."), []byte("............"), 1)
+		},
+		"missing metadata section": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte { return v[:metadataStart] },
+		"duplicate metadata section": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return append(v, v[metadataStart:]...)
+		},
+		"unknown trailing record": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			return append(v, []byte("UNKNOWN_NATIVE_RECORD\n")...)
+		},
+		"truncated metadata EOF": func(v []byte, _ *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte { return v[:len(v)-5] },
+		"different actual TEXT bytes": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Code[0] ^= 1
+			return v
+		},
+		"different actual TEXT ABI": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte { o.Texts[0].ABI = 1; return v },
+		"extra actual TEXT": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts = append(o.Texts, o.Texts[0])
+			return v
+		},
+		"missing actual TEXT": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte { o.Texts = nil; return v },
+		"wrong object source line": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Positions[0].Line++
+			return v
+		},
+		"wrong object source file": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Positions[0].File = "other.s"
+			return v
+		},
+		"object source-PC gap": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Positions[0].Start = 1
+			return v
+		},
+		"object source-PC overlap": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Positions = append(o.Texts[0].Positions, o.Texts[0].Positions[0])
+			return v
+		},
+		"object source-PC missing tail": func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			o.Texts[0].Positions = o.Texts[0].Positions[:len(o.Texts[0].Positions)-1]
+			return v
+		},
+	}
+	for _, role := range []string{"wrong push end", "wrong prologue end"} {
+		mutations[role] = func(v []byte, o *gostaticstorage.WindowsAMD64AssemblyUnwind) []byte {
+			metadata := &o.Unwind[0]
+			oldName := metadata.Name
+			if role == "wrong push end" {
+				metadata.PushEnd, metadata.Data[6] = 2, 2
+			} else {
+				metadata.PrologueEnd, metadata.Data[1], metadata.Data[4] = 5, 5, 5
+			}
+			metadata.Name = "go:sehuw.12." + base64.StdEncoding.EncodeToString(metadata.Data)
+			for index := range o.Texts[0].Auxiliary {
+				if o.Texts[0].Auxiliary[index].Type == o.AuxType {
+					o.Texts[0].Auxiliary[index].Target.Name = metadata.Name
+				}
+			}
+			v = bytes.ReplaceAll(v, []byte(oldName), []byte(metadata.Name))
+			rowStart := bytes.Index(v[metadataStart:], []byte("\n")) + metadataStart + 1
+			return append(append(v[:rowStart:rowStart], goAMD64WindowsUnwindTestByteRow(metadata.Data)...), '\n')
+		}
+	}
+	for name, change := range mutations {
+		t.Run(name, func(t *testing.T) {
+			var independent gostaticstorage.WindowsAMD64AssemblyUnwind
+			if err := json.Unmarshal(serialized, &independent); err != nil {
+				t.Fatal(err)
+			}
+			changed := change(append([]byte(nil), listing...), &independent)
+			if _, err := goAMD64FrameWindowsUnwindListing(changed, file, pkg, source.origins, request.Directory, independent); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed original Windows binary/listing join was accepted", err)
+			}
+		})
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("read-only metadata negative controls changed original source/artifacts", err)
+	}
+}
+
+func goAMD64WindowsUnwindTestByteRow(data []byte) []byte {
+	var result, ascii strings.Builder
+	result.WriteString("\t0x0000")
+	for _, value := range data {
+		fmt.Fprintf(&result, " %02x", value)
+		if value < ' ' || value > 0x7e {
+			value = '.'
+		}
+		ascii.WriteByte(value)
+	}
+	fmt.Fprintf(&result, "  %s", ascii.String())
+	return []byte(result.String())
+}
diff --git a/amd64_go_windows_unwind_source_test.go b/amd64_go_windows_unwind_source_test.go
new file mode 100644
index 000000000..c55a92afc
--- /dev/null
+++ b/amd64_go_windows_unwind_source_test.go
@@ -0,0 +1,141 @@
+//go:build go1.23
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestGoAMD64WindowsUnwindActualSourceFamily(t *testing.T) {
+	goAMD64WindowsUnwindActualSourceFamily(t)
+}
+
+// A temporary-directory alias is an ordinary host configuration, not permission
+// to relax the original object reader's canonical physical-path contract.
+func TestGoAMD64WindowsUnwindTemporaryParentAlias(t *testing.T) {
+	goAMD64WindowsUnwindTemporaryParentAlias(t)
+	goAMD64WindowsUnwindActualSourceFamily(t)
+}
+
+func goAMD64WindowsUnwindTemporaryParentAlias(t *testing.T) {
+	t.Helper()
+	parent, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	physical := filepath.Join(parent, "physical")
+	alias := filepath.Join(parent, "alias")
+	if err := os.Mkdir(physical, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(physical, alias); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("TMPDIR", alias)
+	t.Setenv("GOTMPDIR", alias)
+}
+
+func goAMD64WindowsUnwindActualSourceFamily(t *testing.T) {
+	t.Helper()
+	for _, role := range []string{"numeric", "void", "shared numeric and void"} {
+		t.Run(role, func(t *testing.T) {
+			declaration := "func Value(a uint64) uint64"
+			assembly := "TEXT ·Value(SB),4,$160-16\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			if role == "void" {
+				declaration = "func Value(a uint64)"
+				assembly = "TEXT ·Value(SB),4,$160-8\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nRET\n"
+			} else if role == "shared numeric and void" {
+				declaration += "\nfunc Other(a uint64)"
+				assembly += "TEXT ·Other(SB),4,$160-8\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nRET\n"
+			}
+			pkg, request := goAMD64FrameTypedFixture(t, declaration, assembly)
+			request.Target = "windows/amd64"
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			var environment []string
+			for _, value := range request.Environment {
+				key, _, _ := strings.Cut(value, "=")
+				if key != "GOOS" && key != "GOARCH" && key != "CGO_ENABLED" {
+					environment = append(environment, value)
+				}
+			}
+			environment = append(environment, "GOOS=windows", "GOARCH=amd64", "CGO_ENABLED=0")
+			request.Environment = environment
+			objectDirectory, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal("cannot resolve original Windows output directory", err)
+			}
+			object := filepath.Join(objectDirectory, "original-windows.o")
+			listing, err := goasmcmd.Run(ctx, request.Directory, environment, request.GoBinary,
+				"tool", "asm", "-S", "-p", pkg.Path, "-o", object, request.AssemblyFile)
+			if err != nil {
+				t.Fatal("actual original Windows assembler control failed", err)
+			}
+			info, err := os.Stat(object)
+			if err != nil || !info.Mode().IsRegular() || info.Size() <= 0 {
+				t.Fatal("actual original Windows object was not produced", err)
+			}
+			original, err := os.ReadFile(object)
+			if err != nil || int64(len(original)) != info.Size() ||
+				!bytes.Contains(listing, []byte("SSEHUNWINDINFO")) ||
+				!bytes.Contains(original, []byte("go:sehuw.12.")) {
+				t.Fatal("independent original Windows object precondition failed", err)
+			}
+			t.Logf("ACTUAL_WINDOWS_ORIGINAL_OUTPUT_EXISTS bytes=%d sha256=%x hex=%x\nACTUAL_WINDOWS_ORIGINAL_LISTING\n%s",
+				len(original), sha256.Sum256(original), original, listing)
+			data, err := goAMD64FrameRead(object)
+			if err != nil || !bytes.Equal(data, original) || !bytes.Contains(listing, []byte("SSEHUNWINDINFO")) ||
+				!bytes.Contains(data, []byte("go:sehuw.12.")) {
+				t.Fatal("actual original Windows object/listing lacks its unwind metadata", err)
+			}
+			t.Logf("ACTUAL_WINDOWS_ORIGINAL_OBJECT bytes=%d sha256=%x hex=%x\nACTUAL_WINDOWS_ORIGINAL_LISTING\n%s",
+				len(data), sha256.Sum256(data), data, listing)
+			if !t.Run("PlainParserRefusesUnboundMetadata", func(t *testing.T) {
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				origins := map[string]int{request.AssemblyFile: strings.Count(assembly, "\n") + 1}
+				if _, err := goAMD64FrameListing(listing, file, pkg, origins); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("plain listing parser borrowed Windows binary metadata authority", err)
+				}
+			}) {
+				return
+			}
+			source, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal("actual ordinary Windows numeric/void source requires its complete SEH join", err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			want := 1
+			if role == "shared numeric and void" {
+				want = 2
+			}
+			if len(source.functions) != want || source.Verify(ctx) != nil {
+				t.Fatal("complete Windows numeric/void original source did not verify")
+			}
+			copied := new(GoAMD64FrameSource)
+			reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(source).Elem())
+			if !errors.Is(copied.Verify(ctx), ErrProbeNeedsContext) ||
+				!errors.Is(copied.Close(), ErrProbeNeedsContext) || source.Verify(ctx) != nil {
+				t.Fatal("Windows metadata route bypassed exact source owner identity")
+			}
+			if _, err := os.Stat(request.Directory); err != nil {
+				t.Fatal("source owner identity control changed the original tree", err)
+			}
+		})
+	}
+}
diff --git a/amd64_gp_simd_native_result_test.go b/amd64_gp_simd_native_result_test.go
new file mode 100644
index 000000000..47c1cc8ea
--- /dev/null
+++ b/amd64_gp_simd_native_result_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86GPSIMDNativeOracle = []struct {
+	op, original string
+	width        int
+}{
+	{"MOVL", "MOVL", 4},
+	{"MOVQ", "MOVQ", 8},
+	{"MOVD", "MOVD", 8}, // Go's MOVD is the qword alias.
+	{"VMOVD", "MOVL", 4},
+	{"VMOVQ", "MOVQ", 8},
+}
+
+func x86GPSIMDNativeFixture(name, arch, op, address, destination string, lane int) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	extract := "PEXTRD"
+	if strings.HasPrefix(op, "V") {
+		extract = "VPEXTRD"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DX\nMOVL $1,BX\n%s %s,%s\n%s $%d,%s,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+		name, word+4, move, op, address, destination, extract, lane, destination, word)
+	return source, fmt.Sprintf("func %s(p *[8]byte) uint32\n", name)
+}
+
+func TestX86GPSIMDNativeResultsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86GPSIMDNativeOracle {
+				for _, address := range []string{"(DX)", "-1(DX)(BX*1)"} {
+					for _, destination := range []string{"X0", "X17"} {
+						if destination == "X17" && (target.arch == "386" || !strings.HasPrefix(row.op, "V")) {
+							continue // High banks retain their independent grammar/physical-mode checks.
+						}
+						for lane := 0; lane < 4; lane++ {
+							asm, decl := x86GPSIMDNativeFixture(fmt.Sprintf("F%d", count), target.arch, row.op, address, destination, lane)
+							source.WriteString(asm)
+							declarations.WriteString(decl)
+							count++
+						}
+					}
+				}
+			}
+			want := 56
+			if target.arch == "386" {
+				want = 40
+			}
+			if count != want {
+				t.Fatal("incomplete native GP/X source and zero-lane matrix", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("GP/X memory read lost its numerical/zero result bytes:", err)
+					}
+					if strings.Count(ir, "load volatile i") != count {
+						t.Fatal("numerical continuation lost a paired native read")
+					}
+					compileLLVMToObject(t, llc, target.triple, "gp-x-native.ll", "gp-x-native.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDNativeResultsRetainSourceBoundaries(t *testing.T) {
+	for _, row := range x86GPSIMDNativeOracle {
+		t.Run(row.op, func(t *testing.T) {
+			source, declaration := x86GPSIMDNativeFixture("Value", "amd64", row.op, "(DX)", "X0", 0)
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", strings.TrimSpace(declaration),
+				strings.ReplaceAll(strings.SplitN(source, "\n", 2)[1], "ret+8(FP)", "ret0+8(FP)"))
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone query acquired native memory", err)
+				}
+			}
+			load := row.op + " (DX),X0"
+			missing := strings.Replace(source, load, "CMPL BX,$0\nJE after\n"+load+"\nafter:", 1)
+			for name, bad := range map[string]string{
+				"unknown base":       strings.Replace(source, "(DX)", "(SI)", 1),
+				"unknown index":      strings.Replace(source, "(DX)", "(DX)(SI*1)", 1),
+				"pointer index":      strings.Replace(source, "(DX)", "(DX)(DX*1)", 1),
+				"virtual frame":      strings.Replace(source, "(DX)", "(SP)", 1),
+				"unknown static":     strings.Replace(source, "(DX)", "·external(SB)", 1),
+				"numeric base":       strings.Replace(source, load, "MOVL $42,DX\n"+load, 1),
+				"unknown store data": strings.Replace(source, load, load+"\n"+row.op+" X1,(DX)", 1),
+				"missing path":       missing,
+			} {
+				t.Run(name, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "amd64", bad, "", true)
+					if name == "numeric base" {
+						x86RequireNumericNativeSourceContext(t, bad, declaration, "amd64")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, bad, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if name == "numeric base" {
+							if err != nil || !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", row.width*8)) {
+								t.Fatal("complete NUM address lost the GP/SIMD transfer width", api, err)
+							}
+							x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+							continue
+						}
+						if name == "unknown store data" || name == "missing path" {
+							x86VectorScratchCodegenControl(t, bad, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+							continue
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unproved native transfer boundary accepted", api, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDNativeResultBytesAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86GPSIMDNativeOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" -1(DX)(BX*1),X1")
+				form, known, err := x86GPSIMDTransferProperties(ins, arch)
+				if !known || err != nil || form.bits != row.width*8 {
+					t.Fatal("native memory width changed", form, err)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				base, _, _ := x86ResultGP(DX, 4, arch)
+				index, _, _ := x86ResultGP(BX, 4, arch)
+				state.pointerGP[base], state.gp[index] = true, 0xff
+				state.writeVector(1, 64, 0x0123456789ab0080, false)
+				before := state.clone()
+				want := uint64(0x0123456789abffff)
+				if strings.HasPrefix(row.op, "V") {
+					want = ^uint64(0)
+				}
+				if !x86ResultGPSIMDTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) ||
+					state.vectorBytes(1) != want || state.flags != before.flags ||
+					state.gp != before.gp || state.pointerGP != before.pointerGP {
+					t.Fatal("native transfer lost loaded/zero bytes or changed unrelated state")
+				}
+				for _, mutation := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment"} {
+					changed, rejected := ins, before.clone()
+					switch mutation {
+					case "decoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "raw return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address":
+						changed.x86AddressBits = 32
+					case "unbound address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					}
+					if x86ResultGPSIMDTransferWithNativeMemory(changed, form, &rejected, nil, 0, arch, true) || !reflect.DeepEqual(rejected, before) {
+						t.Fatal("unbound instruction origin acquired native result bytes", mutation)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_gp_simd_native_runtime_unix_test.go b/amd64_gp_simd_native_runtime_unix_test.go
new file mode 100644
index 000000000..fcc8c9d54
--- /dev/null
+++ b/amd64_gp_simd_native_runtime_unix_test.go
@@ -0,0 +1,67 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86GPSIMDNativeResultsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	for _, row := range x86GPSIMDNativeOracle {
+		for discarded := 0; discarded < 2; discarded++ {
+			name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+			body := row.op + " -1(DX)(BX*1),X0\nPEXTRQ $0,X0,AX\n"
+			native := row.original + " (DI),X0\nMOVQ X0,AX\n"
+			if discarded == 1 {
+				body += "MOVQ $0x87654321fedcba98,AX\n"
+				native += "MOVQ $0x87654321fedcba98,AX\n"
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DX\nMOVL $1,BX\n%sMOVQ AX,ret+8(FP)\nRET\n", name, body)
+			fmt.Fprintf(&declarations, "func %s(p *[8]byte) uint64\n", name)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+native+"RET\n")
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+			fmt.Fprintf(&rows, "{%s,%s,%d,%d},\n", name, original, row.width, discarded)
+			count++
+		}
+	}
+	if count != 10 {
+		t.Fatal("incomplete live/dead GP/X family", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := fmt.Sprintf(x86NativeScalarReadRuntimeC, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "gp-x-native", text, driver, level)
+					if string(output) != "10 native scalar kernels: numerical 1280, faults 120, tripwires 2; failures 0\n" {
+						t.Fatal("original/LLVM GP/X numerical/zero bytes or read widths differ:", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_gp_simd_transfer_boundaries_test.go b/amd64_gp_simd_transfer_boundaries_test.go
new file mode 100644
index 000000000..7f28d9cc9
--- /dev/null
+++ b/amd64_gp_simd_transfer_boundaries_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GPSIMDTransferRejectsCompleteSiblingInvalidFormats(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		rows := []string{op + ".Z AX,X0", op + ".BCST (AX),X0", op + ".SAE X0,AX"}
+		for _, args := range []string{"Y0,X1", "Z0,X1", "K1,X1", "X0,Y1", "X0,Z1", "X0,K1", "$7,X1", "$1.25,X1",
+			"X32,X0", "X0,X32", "X0,K1,X1", "X0,$1", "X0,$1.25", "(AX)(SP*1),X1"} {
+			rows = append(rows, op+" "+args)
+		}
+		if op == "MOVL" || op == "VMOVD" {
+			rows = append(rows, op+" X0,X1")
+		}
+		for _, row := range rows {
+			t.Run(row, func(t *testing.T) {
+				for _, arch := range []string{"amd64", "386"} {
+					source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					ins := x86YMMReadSource(t, row)
+					if _, known, err := x86GPSIMDTransferProperties(ins, arch); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("invalid syntax became an owned valid/context form", row, arch, known, err)
+					}
+					if x86CallerVectorMoveKnown(ins) {
+						t.Fatal("invalid sibling acquired caller effect")
+					}
+					x86RequireZeroMaskAPIOutcome(t, arch, source, false)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GPSIMDTransferActualCallerKeepsSafetyBoundaries(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown GP":             "VMOVD BX,X1\nVMOVSS X1,(DX)",
+		"partial GP":             "MOVB $1,BX\nVMOVD BX,X1\nVMOVSS X1,(DX)",
+		"pointer bits":           "VMOVQ DI,X1\nVMOVSS X1,(DX)",
+		"stack identity":         "MOVQ SP,X1\nVMOVSS X1,(DX)",
+		"frame identity":         "MOVQ BP,X1\nVMOVSS X1,(DX)",
+		"undefined X":            "VMOVD X0,AX\nMOVL AX,(DX)",
+		"partial X for qword":    "MOVSS (DI),X2\nMOVSS X2,X0\nVMOVQ X0,AX\nMOVL AX,(DX)",
+		"unknown memory":         "VMOVD (BX),X1\nVMOVSS X1,(DX)",
+		"length overread":        "VMOVQ 4(CX),X1\nVMOVSS X1,(DX)",
+		"result overread":        "MOVQ (DX),X1\nVMOVSS X1,(DX)",
+		"input write":            "VMOVUPS (DI),X0\nVMOVD X0,(DI)",
+		"length write":           "VMOVUPS (DI),X0\nVMOVQ X0,(CX)",
+		"wide result":            "VMOVUPS (DI),X0\nVMOVQ X0,(DX)",
+		"result overlap":         "VMOVUPS (DI),X0\nVMOVD X0,1(DX)",
+		"pointer lost as GP":     "VMOVUPS (DI),X0\nVMOVQ X0,DI\nVMOVD (DI),X1\nVMOVSS X1,(DX)",
+		"g identity overwritten": "VMOVUPS (DI),X0\nVMOVQ X0,R14\nVMOVSS X0,(DX)",
+		"unknown join":           "CMPQ AX,$0\nJE joined\nVMOVD AX,X1\njoined:\nVMOVSS X1,(DX)",
+		"legacy upper unknown":   "MOVL AX,X1\nVEXTRACTF128 $1,Y1,X0\nVMOVSS X0,(DX)",
+		"MMX native state":       "MOVQ X0,M0\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound state acquired caller permission", err)
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDTransferParserRejectsInvalidScale(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		source := "TEXT f(SB),4,$0-0\n" + op + " X0,(AX)(CX*3)\nRET\n"
+		t.Run(op, func(t *testing.T) {
+			if _, err := Parse(ArchAMD64, source); err == nil ||
+				!strings.Contains(err.Error(), `invalid x86 symbolic address register/scale group: "(CX*3)"`) {
+				t.Fatal("parser repaired an invalid scale token", err)
+			}
+			for _, arch := range []string{"amd64", "386"} {
+				goAssemblerOracleOutput(t, arch, source, "", false)
+			}
+			for _, target := range x86RawReturnTargets {
+				if _, err := x86ScalarFPBitViewAPI(t, strings.Replace(source, "f(SB)", "·view(SB)", 1),
+					"func view()", target.arch, target.triple, "Go"); err == nil ||
+					!strings.Contains(err.Error(), `invalid x86 symbolic address register/scale group: "(CX*3)"`) {
+					t.Fatal("Go API repaired an invalid original scale", target.triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDTransferFPCompleteFieldsThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		bits := 32
+		if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+			bits = 64
+		}
+		for _, input := range []string{"uint64", fmt.Sprintf("[%d]byte", bits/8)} {
+			fixture := x86ScalarFPBitFixture{name: op + "/" + input,
+				declaration: fmt.Sprintf("func view(x %s) uint%d\n", input, bits),
+				body:        op + " x+0(FP),X1\n" + op + " X1,ret+8(FP)"}
+			for _, target := range x86RawReturnTargets {
+				t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+					source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete independent field lost its data", api, err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "transfer-fp-"+api+".ll", "transfer-fp-"+api+".o", ir)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_gp_simd_transfer_family_test.go b/amd64_gp_simd_transfer_family_test.go
new file mode 100644
index 000000000..449f3d84f
--- /dev/null
+++ b/amd64_gp_simd_transfer_family_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// This table is an independent projection of all twelve original AVX rows,
+// including their zcase/advances, W bits, transfer opcodes and memory tuples.
+func x86OfficialGPSIMDTransferRows(t *testing.T) []string {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rows []string
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VMOVD" && rule.Opcode != "VMOVQ" {
+			continue
+		}
+		classes := [][]string{{"Yxr", "Yml"}, {"Yml", "Yxr"}, {"YxrEvex", "Yml"}, {"Yml", "YxrEvex"}}
+		zCases := []string{"Zvex_r_v_rm", "Zvex_rm_v_r", "Zevex_r_v_rm", "Zevex_rm_v_r"}
+		offsets := []int{0, 2, 4, 7}
+		advances := []int{2, 2, 3, 3}
+		opcodes := []string{"0x7E", "0x6E", "0x7E", "0x6E"}
+		ws := []string{"W0", "W0", "W0", "W0"}
+		pps := []string{"66", "66", "66", "66"}
+		sources, destinations := []string{"X0", "AX", "X17", "AX"}, []string{"AX", "X1", "AX", "X17"}
+		table, count, tuple := "_yvmovd", 10, "evexN4"
+		if rule.Opcode == "VMOVQ" {
+			classes = [][]string{{"Yxr", "Yml"}, {"Yxr", "Yxm"}, {"Yml", "Yxr"}, {"Yxm", "Yxr"},
+				{"YxrEvex", "Yml"}, {"YxrEvex", "YxmEvex"}, {"Yml", "YxrEvex"}, {"YxmEvex", "YxrEvex"}}
+			zCases = []string{"Zvex_r_v_rm", "Zvex_r_v_rm", "Zvex_rm_v_r", "Zvex_rm_v_r", "Zevex_r_v_rm", "Zevex_r_v_rm", "Zevex_rm_v_r", "Zevex_rm_v_r"}
+			offsets, advances = []int{0, 2, 4, 6, 8, 11, 14, 17}, []int{2, 2, 2, 2, 3, 3, 3, 3}
+			opcodes = []string{"0x7E", "0xD6", "0x6E", "0x7E", "0x7E", "0xD6", "0x6E", "0x7E"}
+			ws, pps = []string{"W1", "W0", "W1", "W0", "W1", "W1", "W1", "W1"}, []string{"66", "66", "66", "F3", "66", "66", "66", "F3"}
+			sources, destinations = []string{"X0", "X0", "AX", "X0", "X17", "X17", "AX", "X0"}, []string{"AX", "X1", "X1", "X1", "AX", "X0", "X17", "X17"}
+			table, count, tuple = "_yvmovq", 20, "evexN8"
+		}
+		index := rule.RowIndex
+		if index < 0 || index >= len(classes) || rule.Ytab != table || rule.Prefix != "Pavx" ||
+			!reflect.DeepEqual(rule.Classes, classes[index]) || rule.ZCase != zCases[index] ||
+			rule.EncodingOffset != offsets[index] || rule.ZOffset != advances[index] || len(rule.OpBytes) != count {
+			t.Fatalf("unmodeled complete GP/SIMD transfer row: %+v", rule)
+		}
+		generation := "vex"
+		if strings.Contains(zCases[index], "evex") {
+			generation = "evex"
+		}
+		terms := []string{"avxEscape", generation + "128", generation + pps[index], generation + "0F", generation + ws[index]}
+		if !reflect.DeepEqual(strings.Split(rule.OpBytes[offsets[index]], " | "), terms) {
+			t.Fatalf("unmodeled GP/SIMD encoding generation/W/prefix: %+v", rule)
+		}
+		opcodeIndex := offsets[index] + 1
+		if generation == "evex" {
+			if rule.OpBytes[opcodeIndex] != tuple {
+				t.Fatalf("unmodeled transfer memory width/mask attributes: %+v", rule)
+			}
+			opcodeIndex++
+		}
+		if rule.OpBytes[opcodeIndex] != opcodes[index] {
+			t.Fatalf("unmodeled complete transfer opcode: %+v", rule)
+		}
+		rows = append(rows, rule.Opcode+" "+sources[index]+","+destinations[index])
+		counts[rule.Opcode]++
+	}
+	if counts["VMOVD"] != 4 || counts["VMOVQ"] != 8 || len(rows) != 12 {
+		t.Fatalf("complete original transfer denominator changed: %v", counts)
+	}
+	return rows
+}
+
+func TestX86GPSIMDTransferCompleteCallerRegistration(t *testing.T) {
+	rows := x86OfficialGPSIMDTransferRows(t)
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD"} {
+		rows = append(rows, op+" AX,X0", op+" X0,AX", op+" (DI),X0", op+" X0,(DX)")
+		if op != "MOVL" {
+			rows = append(rows, op+" X0,X1")
+		}
+	}
+	for _, op := range []string{"VMOVD", "VMOVQ"} {
+		rows = append(rows, op+" (DI),X0", op+" X0,(DX)")
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			ins := x86YMMReadSource(t, row)
+			if !x86CallerVectorMoveKnown(ins) {
+				t.Fatal("Go-accepted whole-family transfer has no caller effect", row)
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDTransferActualSelectedCallerThreeAPIs(t *testing.T) {
+	count := 0
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+		for _, direction := range []string{"gp-to-x", "x-to-gp", "memory-load", "memory-store", "x-to-x"} {
+			if direction == "x-to-x" && (op == "MOVL" || op == "VMOVD") {
+				continue
+			}
+			count++
+			t.Run(op+"/"+direction, func(t *testing.T) {
+				body := "MOVQ $7,AX\n" + op + " AX,X1\nVMOVSS X1,(DX)"
+				switch direction {
+				case "x-to-gp":
+					body = "VMOVUPS (DI),X0\n" + op + " X0,AX\nMOVL AX,(DX)"
+				case "memory-load":
+					body = op + " (DI),X1\nVMOVSS X1,(DX)"
+				case "memory-store":
+					body = "VMOVUPS (DI),X0\n" + op + " X0,(DX)"
+				case "x-to-x":
+					body = "VMOVUPS (DI),X0\n" + op + " X0,X1\nVMOVSS X1,(DX)"
+				}
+				source := x86CallerFixtureSource
+				if direction == "memory-store" && op != "MOVL" && op != "VMOVD" {
+					source = strings.NewReplacer("var res float32", "var res uint64", ") float32 {", ") uint64 {").Replace(source)
+				}
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+				pkg, file := x86CallerCoreFixture(t, source, assembly)
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs, ResolveSym: resolve}
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Error("text caller consumer", err)
+				} else {
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM22 required")
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "transfer-text.ll", "transfer-text.o", ir)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Error("module caller consumer", err)
+				} else {
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM22 required")
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "transfer-module.ll", "transfer-module.o", module.String())
+				}
+				if err := x86CallerCoreTranslate(t, pkg, assembly, options.TargetTriple); err != nil {
+					t.Error("actual selected typed caller", err)
+				}
+			})
+		}
+	}
+	// Scope denominator is independent of the typed implementation table.
+	if count != 28 {
+		t.Fatalf("caller direction denominator changed: %d", count)
+	}
+}
diff --git a/amd64_gp_simd_transfer_fault_runtime_test.go b/amd64_gp_simd_transfer_fault_runtime_test.go
new file mode 100644
index 000000000..9c2882a4b
--- /dev/null
+++ b/amd64_gp_simd_transfer_fault_runtime_test.go
@@ -0,0 +1,111 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The reference executes the actual Go object's three legacy opcodes. VEX
+// translation is compared only for its equivalent unmasked read width, not
+// claimed as original AVX/EVEX execution on Rosetta.
+func TestCrossLinuxRuntimeMatrixX86GPSIMDTransferOriginalDeadReadFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, references, pairs strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		name := fmt.Sprint("transferfault", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ p+0(FP),AX\n%s (AX),X1\nRET\n", name, op)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+		original := op
+		if op == "VMOVD" {
+			original = "MOVL"
+		} else if op == "VMOVQ" {
+			original = "MOVQ"
+		}
+		listing := x86InsertExtractGoListing(t, "amd64", "TEXT f(SB),4,$0-0\n"+original+" (DI),X1\nRET\n")
+		var code []byte
+		for _, line := range strings.Split(string(listing), "\n") {
+			code = append(code, x86InsertExtractListedBytes(line)...)
+		}
+		if len(code) < 4 || code[len(code)-1] != 0xc3 {
+			t.Fatal("original Go memory opcode did not retain its exact ordinary RET", op, code)
+		}
+		var operands []string
+		for _, value := range code[:len(code)-1] {
+			operands = append(operands, fmt.Sprintf("0x%02x", value))
+		}
+		fmt.Fprintf(&references, "extern void %s(const void*);\nstatic void original%d(const void *p) {\n", name, index)
+		fmt.Fprintf(&references, "    __asm__ volatile(\".byte %s\"::\"D\"(p):\"xmm1\",\"memory\");\n}\n", strings.Join(operands, ","))
+		if index > 0 {
+			pairs.WriteString(",")
+		}
+		width := 8
+		if op == "MOVL" || op == "VMOVD" {
+			width = 4
+		}
+		fmt.Fprintf(&pairs, "{original%d,%s,%d}", index, name, width)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + references.String() + `
+typedef void (*operation)(const void*);
+struct pair {operation original,translated;unsigned width;};
+static const struct pair pairs[]={ ` + pairs.String() + ` };
+static int outcome(operation fn,const void *p) {
+    pid_t pid=fork(); if(pid<0) return -1;
+    if(!pid) {
+        struct rlimit limit={0,0}; if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+        fn(p); _exit(0);
+    }
+    int status; if(waitpid(pid,&status,0)!=pid) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status)) return WTERMSIG(status);
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE); if(page<128) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    for(unsigned op=0;op<5;op++) for(unsigned extent=0;extent<=8;extent++) {
+        const void *p=region+page-extent;
+        int original=outcome(pairs[op].original,p),translated=outcome(pairs[op].translated,p);
+        if(original!=translated || (extent>=pairs[op].width ? original!=0 : original!=SIGSEGV && original!=SIGBUS)) {
+            fprintf(stderr,"read op=%u extent=%u original=%d translated=%d\n",op,extent,original,translated);
+            return 3;
+        }
+    }
+    for(unsigned op=0;op<5;op++) {
+        int original=outcome(pairs[op].original,0),translated=outcome(pairs[op].translated,0);
+        if(original!=translated || (original!=SIGSEGV && original!=SIGBUS)) return 4;
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "gp-simd-original-dead-faults", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_gp_simd_transfer_forms.go b/amd64_gp_simd_transfer_forms.go
new file mode 100644
index 000000000..cdbf92a22
--- /dev/null
+++ b/amd64_gp_simd_transfer_forms.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86GPSIMDTransferSpec struct {
+	bits            int
+	legacy, rawOnly bool
+}
+
+// MOVD is Go's MOVQ alias, not Intel's 32-bit MOVD. Ordinary GP-only
+// MOVL/Q/D and the separate MMX rows retain their existing scalar grammar.
+var x86GPSIMDTransferSpecs = map[Op]x86GPSIMDTransferSpec{
+	"MOVL":    {bits: 32, legacy: true},
+	"MOVQ":    {bits: 64, legacy: true},
+	"MOVD":    {bits: 64, legacy: true},
+	"MOVDQ2Q": {bits: 64, legacy: true},
+	"VMOVD":   {bits: 32},
+	"VMOVQ":   {bits: 64},
+	"VMOVW":   {bits: 16, rawOnly: true},
+}
+
+type x86GPSIMDTransferForm struct {
+	spec                       x86GPSIMDTransferSpec
+	bits, memory               int
+	sourceX, destinationX, mmx bool
+	memoryWrite                bool
+}
+
+// A scalar transfer replaces its low X bytes, zeroes the rest of X, and
+// preserves or clears wider aliases according to its original encoding.
+// Numerical availability does not supply a pointer or memory access role.
+func (f x86GPSIMDTransferForm) definedVectorBytes(source, previous uint64) uint64 {
+	low := x86CallerVectorByteMask(int64(f.bits / 8))
+	upper := ^uint64(0xffff)
+	if f.spec.legacy {
+		upper &= previous
+	}
+	return upper | (0xffff &^ low) | (source & low)
+}
+
+// Encoding/width selection grants neither initialized data nor memory backing.
+// In mode32 VEX.W is ignored for GP transfers, but Q memory/X copies stay 64-bit.
+func x86GPSIMDTransferProperties(ins Instr, arch string) (x86GPSIMDTransferForm, bool, error) {
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86GPSIMDTransferSpecs[Op(base)]
+	if !known {
+		return x86GPSIMDTransferForm{}, false, nil
+	}
+	f := x86GPSIMDTransferForm{spec: spec, bits: spec.bits, memory: -1}
+	hasX := false
+	for _, arg := range ins.Args {
+		hasX = hasX || isAMD64GoXRegister(arg)
+	}
+	if spec.legacy && !hasX {
+		return f, false, nil
+	}
+	fail := func() (x86GPSIMDTransferForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go GP/X transfer grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 || spec.rawOnly && !ins.x86Encoded {
+		return fail()
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	f.sourceX, f.destinationX = isAMD64GoXRegister(src), isAMD64GoXRegister(dst)
+	for _, arg := range ins.Args {
+		if isAMD64GoXRegister(arg) {
+			index, _ := amd64ParseXReg(arg.Reg)
+			if spec.legacy && index >= 16 {
+				return fail()
+			}
+		}
+	}
+	if f.sourceX && f.destinationX {
+		if spec.bits != 64 {
+			return fail()
+		}
+	} else if f.sourceX || f.destinationX {
+		other, index := src, 0
+		if f.sourceX {
+			other, index = dst, 1
+		}
+		if isAMD64MemoryOperand(other) && x86PackedShiftMemoryValid(other, arch) {
+			f.memory, f.memoryWrite = index, index == 1
+		} else if other.Kind == OpReg && isX86YrlRegisterForArch(other.Reg, arch) {
+			if spec.legacy && spec.bits == 64 && arch == "386" {
+				return fail()
+			}
+			if arch == "386" && !spec.legacy && f.bits > 32 {
+				f.bits = 32
+			}
+		} else if f.sourceX && spec.legacy && spec.bits == 64 && isAMD64MOVDMRegister(other) {
+			f.mmx = true // Go's MOVDQ2Q row, never a physical caller-state proof.
+		} else if !f.sourceX && other.Kind == OpImm && ins.x86RIPLiteral &&
+			!other.ImmIsFloat && other.ImmRaw == "" {
+			// Only the decoder's already-bound RIP data receipt supplies this
+			// representation. A named literal cannot acquire it.
+		} else {
+			return fail()
+		}
+	} else {
+		return fail()
+	}
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+// Preserve the original operand class before normalization can rewrite an
+// invalid register/address spelling. Direct and textual APIs share this guard.
+func validateX86GPSIMDTransferFile(file *File, arch string) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if _, known, err := x86GPSIMDTransferProperties(ins, arch); known && err != nil {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+		}
+	}
+	return nil
+}
diff --git a/amd64_gp_simd_transfer_grammar_test.go b/amd64_gp_simd_transfer_grammar_test.go
new file mode 100644
index 000000000..5eca495d9
--- /dev/null
+++ b/amd64_gp_simd_transfer_grammar_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86GPSIMDTransferCompleteLegacyOriginalTables(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []struct{ op, name, prefix, bytes, rows string }{
+		{"MOVB", "ymovb", "Pb", "0x88,0x8a,0xb0,0xc6,00", `
+		{Zr_m,1,argList{Yrb,Ymb}},{Zm_r,1,argList{Ymb,Yrb}},
+		{Zib_rp,1,argList{Yi32,Yrb}},{Zibo_m,2,argList{Yi32,Ymb}},`},
+		{"MOVW", "ymovw", "Pe", "0x89,0x8b,0xb8,0xc7,00,0", `
+		{Zr_m,1,argList{Yrl,Yml}},{Zm_r,1,argList{Yml,Yrl}},
+		{Zil_rp,1,argList{Yi32,Yrl}},{Zilo_m,2,argList{Yi32,Yml}},
+		{Zaut_r,2,argList{Yiauto,Yrl}},`},
+		{"MOVL", "ymovl", "Px", "0x89,0x8b,0xb8,0xc7,00,0x6e,0x7e,Pe,0x6e,Pe,0x7e,0", `
+		{Zr_m,1,argList{Yrl,Yml}},{Zm_r,1,argList{Yml,Yrl}},
+		{Zil_rp,1,argList{Yi32,Yrl}},{Zilo_m,2,argList{Yi32,Yml}},
+		{Zm_r_xm,1,argList{Yml,Ymr}},{Zr_m_xm,1,argList{Ymr,Yml}},
+		{Zm_r_xm,2,argList{Yml,Yxr}},{Zr_m_xm,2,argList{Yxr,Yml}},
+		{Zaut_r,2,argList{Yiauto,Yrl}},`},
+		{"MOVQ", "ymovq", "Pw8", "0x6f,0x7f,Pf2,0xd6,Pf3,0x7e,Pe,0xd6,0x89,0x8b,0xb8,0xc7,00,0x6e,0x7e,Pe,0x6e,Pe,0x7e,0", `
+		{Zm_r_xm_nr,1,argList{Ym,Ymr}},{Zr_m_xm_nr,1,argList{Ymr,Ym}},
+		{Zm_r_xm_nr,2,argList{Yxr,Ymr}},{Zm_r_xm_nr,2,argList{Yxm,Yxr}},
+		{Zr_m_xm_nr,2,argList{Yxr,Yxm}},{Zr_m,1,argList{Yrl,Yml}},
+		{Zm_r,1,argList{Yml,Yrl}},{Ziq_rp,1,argList{Yi64,Yrl}},
+		{Zilo_m,2,argList{Yi32,Yml}},{Zm_r_xm,1,argList{Ymm,Ymr}},
+		{Zr_m_xm,1,argList{Ymr,Ymm}},{Zm_r_xm,2,argList{Yml,Yxr}},
+		{Zr_m_xm,2,argList{Yxr,Yml}},{Zaut_r,1,argList{Yiauto,Yrl}},`},
+	} {
+		t.Run(table.op, func(t *testing.T) {
+			definition := regexp.MustCompile(`(?s)var ` + table.name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(source))
+			entry := regexp.MustCompile(`\{A` + table.op + `, (\w+), (\w+), opBytes\{([^}]+)\}\}`).FindStringSubmatch(string(source))
+			strip := func(text string) string {
+				text = regexp.MustCompile(`//[^\n]*`).ReplaceAllString(text, "")
+				return strings.Join(strings.Fields(text), "")
+			}
+			if len(definition) != 2 || len(entry) != 4 || entry[1] != table.name || entry[2] != table.prefix {
+				t.Fatal("complete legacy row/prefix/opcode inventory changed", entry, definition)
+			}
+			inventories := []struct{ name, rows, bytes string }{{"current", table.rows, table.bytes}}
+			if table.op == "MOVQ" {
+				// Go 1.20 has a separate signed-imm32 row before its imm64
+				// row. Pin that complete historical inventory, rather than
+				// discarding scalar rows to make the GP/X subset look equal.
+				inventories = append(inventories, struct{ name, rows, bytes string }{
+					"signed-imm32",
+					strings.Replace(table.rows, "{Ziq_rp,1,argList{Yi64,Yrl}}",
+						"{Zilo_m,2,argList{Ys32,Yrl}},{Ziq_rp,1,argList{Yi64,Yrl}}", 1),
+					"0x6f,0x7f,Pf2,0xd6,Pf3,0x7e,Pe,0xd6,0x89,0x8b,0xc7,00,0xb8,0xc7,00,0x6e,0x7e,Pe,0x6e,Pe,0x7e,0",
+				})
+			}
+			for _, inventory := range inventories {
+				if strip(definition[1]) == strip(inventory.rows) && strip(entry[3]) == inventory.bytes {
+					t.Logf("%s complete %s inventory: %s", runtime.Version(), table.op, inventory.name)
+					return
+				}
+			}
+			t.Fatal("complete legacy row/prefix/opcode inventory changed", entry, definition)
+		})
+	}
+}
+
+func TestX86GPSIMDTransferAllRegisterAndAddressAxes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var assembly strings.Builder
+			assembly.WriteString("TEXT f(SB),4,$0-0\n")
+			count := 0
+			appendRow := func(op, src, dst string) {
+				row := op + " " + src + "," + dst
+				ins := x86YMMReadSource(t, row)
+				before := fmt.Sprintf("%#v", ins)
+				if _, known, err := x86GPSIMDTransferProperties(ins, arch); !known || err != nil {
+					t.Fatal("independent valid axis not consumed", row, err)
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("grammar mutated original source")
+				}
+				fmt.Fprintln(&assembly, row)
+				count++
+			}
+			for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+				legacy := !strings.HasPrefix(op, "V")
+				gps := []string{"AX", "BX", "CX", "DX", "DI", "SI", "BP", "SP"}
+				if arch == "amd64" {
+					gps = append(gps, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+				}
+				if arch == "amd64" || !legacy || op == "MOVL" {
+					for _, gp := range gps {
+						appendRow(op, gp, "X0")
+						appendRow(op, "X0", gp)
+					}
+				}
+				limit := 8
+				if arch == "amd64" {
+					limit = 16
+					if !legacy {
+						limit = 32
+					}
+				}
+				for index := 0; index < limit; index++ {
+					x := fmt.Sprint("X", index)
+					appendRow(op, "3(AX)", x)
+					appendRow(op, x, "5(BX)")
+					if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+						appendRow(op, x, "X0")
+						appendRow(op, x, x)
+					}
+				}
+				for _, memory := range []string{"(AX)(CX*1)", "7(AX)(CX*2)", "-9(AX)(CX*4)", "11(AX)(CX*8)"} {
+					appendRow(op, memory, "X1")
+					appendRow(op, "X1", memory)
+				}
+			}
+			assembly.WriteString("RET\n")
+			goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+			want := 552
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				want, triples = 216, []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			if count != want {
+				t.Fatalf("independent register/address denominator changed: %d, want %d", count, want)
+			}
+			for _, triple := range triples {
+				t.Run(triple, func(t *testing.T) {
+					// Keep every original uninitialized axis as a Go/public-Context
+					// control, separate from initialized public object owners.
+					ir := x86UnboundVoidScalarFormatObject(t, assembly.String(), "f", arch, triple)
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDTransferPartialByteKnowledgeAndUnaffectedState(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		width := 4
+		if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+			width = 8
+		}
+		for _, direction := range []string{"gp-to-x", "x-to-gp", "x-to-x"} {
+			if direction == "x-to-x" && width == 4 {
+				continue
+			}
+			t.Run(op+"/"+direction, func(t *testing.T) {
+				for seed := 0; seed < 256; seed++ {
+					initial := x86SourceStackState{
+						bp: x86SourceStackAddress{original: true}, gOriginal: true, numericFlags: true,
+						callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}}, known: map[Reg]uint8{AX: uint8(seed), BX: 0x53},
+						vectors: map[Reg]uint64{"Z0": uint64(seed), "Z1": 0xa735de42c9156ef0, "Z31": 0x1927},
+						masks:   map[Reg]bool{"K1": true},
+					}
+					args := "AX,X1"
+					if direction == "x-to-gp" {
+						args = "X0,AX"
+					} else if direction == "x-to-x" {
+						args = "X0,X1"
+					}
+					ins := x86YMMReadSource(t, op+" "+args)
+					state, want := x86CloneCallerState(initial), x86CloneCallerState(initial)
+					low := uint64(seed) & (uint64(1)<<uint(width) - 1)
+					accepted := direction != "x-to-gp" || low == uint64(1)<<uint(width)-1
+					if accepted && direction == "x-to-gp" {
+						want.known[AX] = 0xff
+					} else if direction != "x-to-gp" {
+						known := low | 0xffff&^(uint64(1)<<uint(width)-1)
+						if strings.HasPrefix(op, "V") {
+							known |= ^uint64(0xffff)
+						} else {
+							known |= initial.vectors["Z1"] &^ 0xffff
+						}
+						want.vectors["Z1"] = known
+					}
+					if got := x86CallerVectorMoveStep(&ins, &state, nil); got != accepted || !reflect.DeepEqual(state, want) {
+						t.Fatalf("%s %s seed=%d admitted=%v/%v got=%+v want=%+v", op, args, seed, got, accepted, state, want)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86GPSIMDTransferRejectsUnboundPhysical386Banks(t *testing.T) {
+	for _, op := range []string{"VMOVD", "VMOVQ"} {
+		for _, row := range []string{op + " AX,X8", op + " X31,AX", op + " (AX),X17", op + " X17,(AX)"} {
+			t.Run(row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+				if _, known, err := x86GPSIMDTransferProperties(x86YMMReadSource(t, row), "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unbound Go-accepted mode32 bank acquired virtual semantics", err)
+				}
+				x86RequireZeroMaskAPIOutcome(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", false)
+			})
+		}
+	}
+}
diff --git a/amd64_gp_simd_transfer_memory_test.go b/amd64_gp_simd_transfer_memory_test.go
new file mode 100644
index 000000000..e6039328c
--- /dev/null
+++ b/amd64_gp_simd_transfer_memory_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86GPSIMDTransferFPSpansRejectEveryMissingByteBeforeIR(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		width := 4
+		if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+			width = 8
+		}
+		for missing := 0; missing < width; missing++ {
+			t.Run(fmt.Sprintf("%s/missing%d", op, missing), func(t *testing.T) {
+				var args []LLVMType
+				var slots []FrameSlot
+				for offset := 0; offset < width; offset++ {
+					if offset != missing {
+						slots = append(slots, FrameSlot{Offset: int64(offset), Type: I8, Index: len(args), Field: -1})
+						args = append(args, I8)
+					}
+				}
+				var output strings.Builder
+				ctx := newAMD64Ctx(&output, Func{}, FuncSig{Args: args, Ret: Void, Frame: FrameLayout{Params: slots}}, nil, nil, false)
+				ctx.goarch = "amd64"
+				ins := x86YMMReadSource(t, op+" x+0(FP),X0")
+				known, _, err := ctx.lowerVectorScalarIntegerMove(ins.Op, ins)
+				if !known || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+					t.Fatalf("missing byte acquired transfer or partial IR: %v\n%s", err, output.String())
+				}
+			})
+		}
+	}
+}
+
+func TestX86GPSIMDTransferDeadMemoryRetainsNativeWidth(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		t.Run(op, func(t *testing.T) {
+			bits := 32
+			if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+				bits = 64
+			}
+			for _, arch := range []string{"amd64", "386"} {
+				source := "TEXT f(SB),4,$0-0\n" + op + " (AX),X0\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}})
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if !strings.Contains(text, fmt.Sprintf("load volatile i%d", bits)) {
+						t.Fatalf("dead %s memory read erased or widened on %s: want observable %d-bit load\n%s", op, arch, bits, text)
+					}
+					compileLLVMToObject(t, llc, triple, "transfer-dead-read.ll", "transfer-dead-read.o", text)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_gp_simd_transfer_runtime_test.go b/amd64_gp_simd_transfer_runtime_test.go
new file mode 100644
index 000000000..c010e76d0
--- /dev/null
+++ b/amd64_gp_simd_transfer_runtime_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent full-byte results observe both directions, narrow GP extension,
+// self-aliasing and untouched upper banks. Portable AVX lowering is not a
+// physical AVX512 execution certificate; Linux executes the required counterpart.
+func TestCrossLinuxRuntimeMatrixX86GPSIMDTransferCompleteBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		width := 4
+		if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+			width = 8
+		}
+		for _, direction := range []string{"gp-to-x", "x-to-gp", "memory-load", "memory-store", "x-to-x", "self"} {
+			if (direction == "x-to-x" || direction == "self") && width == 4 {
+				continue
+			}
+			name := fmt.Sprint("gpxtransfer", count)
+			count++
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ seed+16(FP),CX\n", name)
+			source.WriteString("VMOVUPS (BX),Z0\nVMOVUPS (AX),Z1\nMOVQ $-1,R11\nCMPQ AX,AX\nSTC\n")
+			kind := 0
+			switch direction {
+			case "gp-to-x":
+				fmt.Fprintf(&source, "%s CX,X1\nVMOVUPS Z1,(AX)\n", op)
+			case "x-to-gp":
+				kind = 1
+				fmt.Fprintf(&source, "%s X0,R11\nVMOVUPS Z1,(AX)\n", op)
+			case "memory-load":
+				kind = 2
+				fmt.Fprintf(&source, "%s 3(BX),X1\nVMOVUPS Z1,(AX)\n", op)
+			case "memory-store":
+				kind = 3
+				fmt.Fprintf(&source, "VMOVUPS Z1,(AX)\n%s X0,3(AX)\n", op)
+			case "x-to-x":
+				kind = 4
+				fmt.Fprintf(&source, "%s X0,X1\nVMOVUPS Z1,(AX)\n", op)
+			case "self":
+				kind = 5
+				fmt.Fprintf(&source, "%s X1,X1\nVMOVUPS Z1,(AX)\n", op)
+			}
+			source.WriteString("MOVQ R11,64(AX)\nSETCS 72(AX)\nSETNE 73(AX)\nRET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if(check(%s,\"%s\",%d,%d,%d)) return 1;\n", name, name, width, kind,
+				x86FloatAddSubBoolInt(strings.HasPrefix(op, "V")))
+		}
+	}
+	if count != 26 {
+		t.Fatal("independent complete transfer runtime denominator changed", count)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int check(void (*program)(uint8_t*,const uint8_t*,uint64_t),const char *name,
+                 unsigned width,int kind,int vector) {
+    uint64_t seeds[]={0,UINT64_MAX,UINT64_C(0x98af3bce72510d64),UINT64_C(0x8000000000000001)};
+    for(unsigned s=0;s<4;s++) {
+        uint8_t input[82],original[82],output[84],before[84],want[84];
+        for(unsigned i=0;i<82;i++) input[i]=(uint8_t)(i*37+149);
+        for(unsigned i=0;i<84;i++) output[i]=(uint8_t)(i*19+71);
+        memcpy(original,input,sizeof(input)); memcpy(before,output,sizeof(output));
+        memcpy(want,before,sizeof(want));
+        uint64_t gp=UINT64_MAX;
+        if(kind==1) { gp=0; memcpy(&gp,input+1,width); }
+        else if(kind==3) memcpy(want+4,input+1,width);
+        else {
+            for(unsigned i=0;i<64;i++) {
+                uint8_t value=before[1+i];
+                if(i>=16) { if(vector) value=0; }
+                else if(i>=width) value=0;
+                else if(kind==0) value=(uint8_t)(seeds[s]>>(i*8));
+                else if(kind==2) value=input[4+i];
+                else if(kind==4) value=input[1+i];
+                want[1+i]=value;
+            }
+        }
+        memcpy(want+65,&gp,8); want[73]=1; want[74]=0;
+        program(output+1,input+1,seeds[s]);
+        if(memcmp(input,original,sizeof(input)) || memcmp(output,want,sizeof(output))) {
+            for(unsigned i=0;i<84;i++) if(output[i]!=want[i])
+                fprintf(stderr,"%s seed=%u byte=%u got=%x want=%x\n",name,s,i,output[i],want[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "gp-simd-transfer-complete-bytes", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_gpsimd_overwritten_store_test.go b/amd64_gpsimd_overwritten_store_test.go
new file mode 100644
index 000000000..2679f1d08
--- /dev/null
+++ b/amd64_gpsimd_overwritten_store_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Two different native writes to the same address must remain observable even
+// when no numerical consumer reads the first one. Plan 9 MOVD is the 64-bit
+// MOVQ alias; it is not Intel's 32-bit MOVD. Expected widths below are independent
+// of the production GP/SIMD transfer grammar and emitter.
+func TestX86GPSIMDOverwrittenNativeStoresThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	forms := []struct {
+		op   string
+		bits int
+	}{{"MOVL", 32}, {"MOVQ", 64}, {"MOVD", 64}, {"VMOVD", 32}, {"VMOVQ", 64}}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			declarations.WriteString("package stores\n")
+			sigs := map[string]FuncSig{}
+			pointerBytes, pointerMove := 8, "MOVQ"
+			if target.arch == "386" {
+				pointerBytes, pointerMove = 4, "MOVL"
+			}
+			for index, form := range forms {
+				for _, memory := range []bool{true, false} {
+					name := fmt.Sprintf("Store%d_%t", index, memory)
+					destination := fmt.Sprintf("sink%d<>(SB)", index)
+					sig := FuncSig{Name: name, Ret: Void}
+					frame := 0
+					if memory {
+						frame, destination = pointerBytes, "(AX)"
+						sig.Args = []LLVMType{Ptr}
+						sig.Frame = FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}
+						fmt.Fprintf(&declarations, "func %s(p *[8]byte)\n", name)
+					} else {
+						fmt.Fprintf(&declarations, "func %s()\n", name)
+						fmt.Fprintf(&assembly, "GLOBL %s,8,$8\n", destination)
+					}
+					sigs[name] = sig
+					fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\n", name, frame)
+					if memory {
+						fmt.Fprintf(&assembly, "%s p+0(FP),AX\n", pointerMove)
+					}
+					fmt.Fprintf(&assembly, "PXOR X0,X0\n%s X0,%s\nPCMPEQB X1,X1\n%s X1,%s\nRET\n", form.op, destination, form.op, destination)
+				}
+			}
+			// The original assembler independently establishes each store spelling
+			// and its real 386/amd64 operand acceptance before any translation.
+			goAssemblerOracleOutput(t, target.arch, assembly.String(), "", true)
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			textIR, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "stores", declarations.String())
+			goModule, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+			if goModule != nil && !goModule.Module.IsNil() {
+				defer goModule.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []struct{ name, ir string }{{"text", textIR}, {"module", module.String()}, {"go-module", goModule.Module.String()}} {
+				t.Run(api.name, func(t *testing.T) {
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprintf("IR_default_O2=%t", optimized), func(t *testing.T) {
+							ir := api.ir
+							if optimized {
+								ir = x86MulDivRoundOptimize(t, ir)
+							}
+							for index, form := range forms {
+								for _, memory := range []bool{true, false} {
+									name := fmt.Sprintf("Store%d_%t", index, memory)
+									t.Run(form.op+fmt.Sprintf("/OpMem=%t", memory), func(t *testing.T) {
+										x86GPSIMDCheckNativeStoreEffects(t, ir, name, form.bits)
+									})
+								}
+							}
+							// Object emission is a separate backend-O0 axis, both before
+							// and after the explicit LLVM IR default<O2> pass pipeline.
+							compileLLVMToObject(t, llc, target.triple, "native-stores.ll", "native-stores.o", ir)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86GPSIMDCheckNativeStoreEffects(t *testing.T, ir, name string, bits int) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	function := module.NamedFunction(name)
+	if function.IsNil() {
+		t.Fatal("native store function disappeared", name)
+	}
+	stores, observable := 0, 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+			if instruction.IsAStoreInst().IsNil() || x86GPSIMDStoreTargetsBackingAlloca(instruction.Operand(1)) {
+				continue // Register banks and synthesized ABI0 frames are not native writes.
+			}
+			typ := instruction.Operand(0).Type()
+			if typ.TypeKind() != llvm.IntegerTypeKind {
+				t.Fatal("native scalar write widened to a non-integer type", instruction.String())
+			}
+			stores++
+			if typ.IntTypeWidth() != bits {
+				t.Errorf("native store width=%d want=%d: %s", typ.IntTypeWidth(), bits, instruction.String())
+			}
+			if instruction.IsVolatile() {
+				observable++
+			}
+		}
+	}
+	t.Logf("native stores=%d observable=%d exact-width=%d", stores, observable, bits)
+	if stores != 2 || observable != 2 {
+		t.Errorf("overwritten native store effect lost: stores=%d observable=%d want=2/2\n%s", stores, observable, function.String())
+	}
+}
+
+func x86GPSIMDStoreTargetsBackingAlloca(pointer llvm.Value) bool {
+	for depth := 0; depth < 16; depth++ {
+		if !pointer.IsAAllocaInst().IsNil() {
+			return true
+		}
+		if pointer.IsAGetElementPtrInst().IsNil() && pointer.IsABitCastInst().IsNil() {
+			return false
+		}
+		pointer = pointer.Operand(0)
+	}
+	return false
+}
diff --git a/amd64_helper_edge_test.go b/amd64_helper_edge_test.go
index 8b3a077c9..9fc9c20c5 100644
--- a/amd64_helper_edge_test.go
+++ b/amd64_helper_edge_test.go
@@ -1,6 +1,8 @@
 package plan9asm
 
 import (
+	"errors"
+	"math"
 	"strings"
 	"testing"
 )
@@ -154,14 +156,29 @@ func TestAMD64CtxHelperEdges(t *testing.T) {
 				t.Fatalf("evalFPToI64(%d) = (%q, %v)", off, got, err)
 			}
 		}
+		if got, err := c.evalFPToF32(56); err != nil || got == "" {
+			t.Fatalf("evalFPToF32(float) = (%q, %v)", got, err)
+		}
+		if got, err := c.evalFPToF32(32); err != nil || got == "" {
+			t.Fatalf("evalFPToF32(i32 bits) = (%q, %v)", got, err)
+		}
+		if _, err := c.evalFPToF32(999); err == nil {
+			t.Fatal("evalFPToF32(missing slot) unexpectedly succeeded")
+		}
 		c.fpParams[64] = FrameSlot{Offset: 64, Type: LLVMType("v4i32"), Index: 0}
 		if _, err := c.evalFPToI64(64); err == nil {
 			t.Fatalf("evalFPToI64(unsupported type) unexpectedly succeeded")
 		}
+		if _, err := c.evalFPToF32(64); err == nil {
+			t.Fatal("evalFPToF32(unsupported type) unexpectedly succeeded")
+		}
 		c.fpParams[72] = FrameSlot{Offset: 72, Type: I64, Index: 99}
 		if _, err := c.evalFPToI64(72); err == nil {
 			t.Fatalf("evalFPToI64(invalid index) unexpectedly succeeded")
 		}
+		if _, err := c.evalFPToF32(72); err == nil {
+			t.Fatal("evalFPToF32(invalid index) unexpectedly succeeded")
+		}
 
 		if err := c.storeFPResult(80, I64, "11"); err != nil {
 			t.Fatalf("storeFPResult(i64->i32) error = %v", err)
@@ -285,8 +302,8 @@ func TestAMD64CtxHelperEdges(t *testing.T) {
 		"alloca <64 x i8>",
 		"alloca i64",
 		"ptrtoint ptr %arg0 to i64",
-		"bitcast double %arg6 to i64",
-		"bitcast float %arg7 to i32",
+		"load double, ptr %fp_arg_48",
+		"load float, ptr %fp_arg_56",
 		"trunc i64 11 to i32",
 		"inttoptr i64 12 to ptr",
 		"bitcast i64 13 to double",
@@ -356,9 +373,14 @@ func TestAMD64AtomicAndBranchEdges(t *testing.T) {
 	c.blockBase = []int{0, 1, 2}
 	c.blockByIdx = map[int]int{0: 0, 1: 1, 2: 2}
 
-	if ok, term, err := c.lowerAtomic("LOCK", Instr{Raw: "LOCK"}); !ok || term || err != nil {
+	beforeStandaloneLock := b.Len()
+	beforeLockTemporary, beforeLockPrefix := c.tmp, c.namedAtomicLock
+	if ok, term, err := c.lowerAtomic("LOCK", Instr{Raw: "LOCK"}); !ok || term || !errors.Is(err, ErrProbeNeedsContext) {
 		t.Fatalf("lowerAtomic(LOCK) = (%v, %v, %v)", ok, term, err)
 	}
+	if b.Len() != beforeStandaloneLock || c.tmp != beforeLockTemporary || c.namedAtomicLock != beforeLockPrefix {
+		t.Fatal("standalone LOCK changed IR or temporary state without a complete adjacent source operation")
+	}
 	if ok, _, err := c.lowerAtomic("CMPXCHGL", Instr{
 		Raw: "CMPXCHGL CX, 8(BX)",
 		Args: []Operand{
@@ -395,14 +417,14 @@ func TestAMD64AtomicAndBranchEdges(t *testing.T) {
 	}); !ok || err != nil {
 		t.Fatalf("lowerAtomic(XCHGQ sym) = (%v, %v)", ok, err)
 	}
-	if ok, _, err := c.lowerAtomic("ANDB", Instr{
+	if ok, _, err := c.lowerScalarMemoryRMW("ANDB", Instr{
 		Raw: "ANDB $1, 4(BX)",
 		Args: []Operand{
 			{Kind: OpImm, Imm: 1},
 			{Kind: OpMem, Mem: MemRef{Base: BX, Off: 4}},
 		},
 	}); !ok || err != nil {
-		t.Fatalf("lowerAtomic(ANDB) = (%v, %v)", ok, err)
+		t.Fatalf("lowerScalarMemoryRMW(ANDB) = (%v, %v)", ok, err)
 	}
 	if ok, term, err := c.lowerAtomic("ORQ", Instr{
 		Raw: "ORQ AX, BX",
@@ -505,16 +527,41 @@ func TestAMD64AtomicAndBranchEdges(t *testing.T) {
 	if err := c.tailCallAndRet(Operand{Kind: OpReg, Reg: AX}); err == nil {
 		t.Fatalf("tailCallAndRet(non-sym) unexpectedly succeeded")
 	}
+
+	var b386 strings.Builder
+	c386 := newX86Ctx(&b386, Func{}, FuncSig{Name: "example.ptr386", Ret: Ptr}, testResolveSym("example"), map[string]FuncSig{
+		"example.word386": {Name: "example.word386", Ret: I32},
+	}, "386", "i386-unknown-linux-gnu", false)
+	if err := c386.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	if err := c386.tailCallAndRet(Operand{Kind: OpSym, Sym: "word386(SB)"}); err != nil {
+		t.Fatalf("386 tailCallAndRet(i32 -> ptr) error = %v", err)
+	}
+	if got := b386.String(); !strings.Contains(got, "inttoptr i32") || !strings.Contains(got, "ret ptr") {
+		t.Fatalf("386 tailCallAndRet(i32 -> ptr) output:\n%s", got)
+	}
 	if err := c.tailCallIndirectAddrAndRet("123"); err != nil {
 		t.Fatalf("tailCallIndirectAddrAndRet() error = %v", err)
 	}
 
 	out := b.String()
+	if strings.Contains(out, "cmpxchg ptr") {
+		t.Fatal("native CMPXCHGL silently acquired software atomic alignment or LOCK semantics")
+	}
+	if strings.Contains(out, "atomicrmw and ptr") {
+		t.Fatal("ordinary ANDB silently acquired implicit LOCK semantics")
+	}
+	if strings.Contains(out, "lock; xadd") {
+		t.Fatal("bare XADD borrowed LOCK from the rejected standalone prefix")
+	}
 	for _, want := range []string{
-		"cmpxchg ptr",
-		"atomicrmw add ptr",
-		"atomicrmw xchg ptr",
-		"atomicrmw and ptr",
+		"asm sideeffect \"cmpxchgl $3, $2; sete $1\"",
+		"asm sideeffect \"xadd",
+		"asm sideeffect \"xchg",
+		"load volatile i8",
+		"and i8",
+		"store volatile i8",
 		"icmp eq i8",
 		"icmp slt i8",
 		"call i64",
@@ -550,19 +597,30 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 		},
 	}
 	c, b := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
-	mustLower := func(op Op, ins Instr) {
+	mustLowerWith := func(lower func(Op, Instr) (bool, bool, error), op Op, ins Instr) {
 		t.Helper()
-		if ok, term, err := c.lowerArith(op, ins); !ok || term || err != nil {
-			t.Fatalf("lowerArith(%s) = (%v, %v, %v)", op, ok, term, err)
+		if ok, term, err := lower(op, ins); !ok || term || err != nil {
+			t.Fatalf("lower(%s) = (%v, %v, %v)", op, ok, term, err)
 		}
 	}
+	mustLower := func(op Op, ins Instr) {
+		t.Helper()
+		mustLowerWith(c.lowerArith, op, ins)
+	}
+	if ok, term, err := c.lowerScalarShiftRotate("RCRQ", Instr{Raw: "RCRQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}}); !ok || term || err != nil {
+		t.Fatalf("lowerScalarShiftRotate(RCRQ) = (%v, %v, %v)", ok, term, err)
+	}
 
 	mustLower("PUSHQ", Instr{Raw: "PUSHQ $1", Args: []Operand{{Kind: OpImm, Imm: 1}}})
 	mustLower("POPQ", Instr{Raw: "POPQ CX", Args: []Operand{{Kind: OpReg, Reg: CX}}})
 	mustLower("PUSHFQ", Instr{Raw: "PUSHFQ"})
 	mustLower("POPFQ", Instr{Raw: "POPFQ"})
 	mustLower("LFENCE", Instr{Raw: "LFENCE"})
-	mustLower("UNDEF", Instr{Raw: "UNDEF"})
+	trap, trapOutput := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Ret: Void}, nil)
+	if known, terminated, err := trap.lowerArith("UNDEF", Instr{Raw: "UNDEF"}); !known || !terminated || err != nil ||
+		!strings.Contains(trapOutput.String(), "asm sideeffect \"ud2\"") {
+		t.Fatalf("UNDEF must terminate with its architectural fault: %t/%t/%v", known, terminated, err)
+	}
 	mustLower("RDTSC", Instr{Raw: "RDTSC"})
 	mustLower(OpCPUID, Instr{Raw: "CPUID"})
 	mustLower(OpXGETBV, Instr{Raw: "XGETBV"})
@@ -572,7 +630,6 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 	mustLower("STOSQ", Instr{Raw: "STOSQ"})
 	mustLower("NEGL", Instr{Raw: "NEGL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
 	mustLower("NEGL", Instr{Raw: "NEGL 4(BX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 4}}}})
-	mustLower("RCRQ", Instr{Raw: "RCRQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ADDQ", Instr{Raw: "ADDQ $2, AX", Args: []Operand{{Kind: OpImm, Imm: 2}, {Kind: OpReg, Reg: AX}}})
 	mustLower("SUBQ", Instr{Raw: "SUBQ CX, 8(BX)", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}}})
 	mustLower("XORQ", Instr{Raw: "XORQ $3, AX", Args: []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: AX}}})
@@ -581,8 +638,8 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 	mustLower("ADCQ", Instr{Raw: "ADCQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ADCB", Instr{Raw: "ADCB $1, AL", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AL}}})
 	mustLower("SBBQ", Instr{Raw: "SBBQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("ADCXQ", Instr{Raw: "ADCXQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("ADOXQ", Instr{Raw: "ADOXQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLower("ADCXQ", Instr{Raw: "ADCXQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLower("ADOXQ", Instr{Raw: "ADOXQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ADDL", Instr{Raw: "ADDL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ADDB", Instr{Raw: "ADDB CL, DX", Args: []Operand{{Kind: OpReg, Reg: CL}, {Kind: OpReg, Reg: DX}}})
 	mustLower("SUBL", Instr{Raw: "SUBL CX, 12(BX)", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 12}}}})
@@ -592,55 +649,65 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 	mustLower("XORB", Instr{Raw: "XORB $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ANDB", Instr{Raw: "ANDB $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ORB", Instr{Raw: "ORB $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("INCQ", Instr{Raw: "INCQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
-	mustLower("DECQ", Instr{Raw: "DECQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
-	mustLower("DECQ", Instr{Raw: "DECQ 96(AX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX, Off: 96}}}})
-	mustLower("INCL", Instr{Raw: "INCL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
-	mustLower("DECL", Instr{Raw: "DECL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
-	mustLower("DECL", Instr{Raw: "DECL 12(BX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 12}}}})
+	mustLowerWith(c.lowerScalarIncDec, "INCQ", Instr{Raw: "INCQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarIncDec, "DECQ", Instr{Raw: "DECQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarIncDec, "DECQ", Instr{Raw: "DECQ 96(AX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX, Off: 96}}}})
+	mustLowerWith(c.lowerScalarIncDec, "INCL", Instr{Raw: "INCL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarIncDec, "DECL", Instr{Raw: "DECL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarIncDec, "DECL", Instr{Raw: "DECL 12(BX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 12}}}})
 	mustLower("LEAQ", Instr{Raw: "LEAQ 8(BX)(CX*2), DI", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Index: CX, Scale: 2, Off: 8}}, {Kind: OpReg, Reg: DI}}})
 	mustLower("LEAL", Instr{Raw: "LEAL 4(BX), SI", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 4}}, {Kind: OpReg, Reg: SI}}})
 	mustLower("LEAQ", Instr{Raw: "LEAQ ret+16(FP), R8", Args: []Operand{{Kind: OpFP, FPOffset: 16}, {Kind: OpReg, Reg: Reg("R8")}}})
-	mustLower("LEAQ", Instr{Raw: "LEAQ $ret+16(FP), R9", Args: []Operand{{Kind: OpFPAddr, FPOffset: 16}, {Kind: OpReg, Reg: Reg("R9")}}})
+	// TYPE_ADDR is not Go's LEA Ym source; retain the former false-positive
+	// spelling as a rejection, independently checked by the full LEA oracle.
+	if _, _, err := c.lowerArith("LEAQ", Instr{Raw: "LEAQ $ret+16(FP), R9", Args: []Operand{{Kind: OpFPAddr, FPOffset: 16}, {Kind: OpReg, Reg: Reg("R9")}}}); err == nil {
+		t.Fatal("LEAQ accepted a TYPE_ADDR operand outside Go's Ym/Yrl row")
+	}
 	mustLower("LEAQ", Instr{Raw: "LEAQ global<>(SB), AX", Args: []Operand{{Kind: OpSym, Sym: "global<>(SB)"}, {Kind: OpReg, Reg: AX}}})
 	mustLower("POPCNTL", Instr{Raw: "POPCNTL AX, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}})
 	mustLower("POPCNTQ", Instr{Raw: "POPCNTQ AX, CX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}})
 	mustLower("TZCNTQ", Instr{Raw: "TZCNTQ BX, DX", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: DX}}})
+	// This is a fragment-shape test, not a module/native-entry certificate.
+	// Supply the compiler-local bridge name and its explicit target; complete
+	// public-API tests independently require the emitted no-red-zone helper.
+	oldScanNamespace, oldScanTarget := c.bitScanNS, c.targetTriple
+	c.bitScanNS, c.targetTriple = "__test_bitscan_", "x86_64-unknown-linux-gnu"
 	mustLower("BSFQ", Instr{Raw: "BSFQ AX, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}})
 	mustLower("BSRQ", Instr{Raw: "BSRQ AX, CX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}})
 	mustLower("BSWAPQ", Instr{Raw: "BSWAPQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
 	mustLower("BSFL", Instr{Raw: "BSFL AX, DX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: DX}}})
 	mustLower("BSRL", Instr{Raw: "BSRL AX, DI", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: DI}}})
-	mustLower("SETEQ", Instr{Raw: "SETEQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
-	mustLower("SETGT", Instr{Raw: "SETGT ret+8(FP)", Args: []Operand{{Kind: OpFP, FPOffset: 8}}})
-	mustLower("SETGE", Instr{Raw: "SETGE AH", Args: []Operand{{Kind: OpReg, Reg: AH}}})
-	mustLower("SETHI", Instr{Raw: "SETHI BX", Args: []Operand{{Kind: OpReg, Reg: BX}}})
-	mustLower("SETCS", Instr{Raw: "SETCS AL", Args: []Operand{{Kind: OpReg, Reg: AL}}})
-	mustLower("SETCS", Instr{Raw: "SETCS AH", Args: []Operand{{Kind: OpReg, Reg: AH}}})
-	mustLower("CMOVQEQ", Instr{Raw: "CMOVQEQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("CMOVQNE", Instr{Raw: "CMOVQNE CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("CMOVQCS", Instr{Raw: "CMOVQCS CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("CMOVQCC", Instr{Raw: "CMOVQCC CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("CMOVQGT", Instr{Raw: "CMOVQGT CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	c.bitScanNS, c.targetTriple = oldScanNamespace, oldScanTarget
+	mustLowerWith(c.lowerConditionalSet, "SETEQ", Instr{Raw: "SETEQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerConditionalSet, "SETGT", Instr{Raw: "SETGT ret+8(FP)", Args: []Operand{{Kind: OpFP, FPOffset: 8}}})
+	mustLowerWith(c.lowerConditionalSet, "SETGE", Instr{Raw: "SETGE AH", Args: []Operand{{Kind: OpReg, Reg: AH}}})
+	mustLowerWith(c.lowerConditionalSet, "SETHI", Instr{Raw: "SETHI BX", Args: []Operand{{Kind: OpReg, Reg: BX}}})
+	mustLowerWith(c.lowerConditionalSet, "SETCS", Instr{Raw: "SETCS AL", Args: []Operand{{Kind: OpReg, Reg: AL}}})
+	mustLowerWith(c.lowerConditionalSet, "SETCS", Instr{Raw: "SETCS AH", Args: []Operand{{Kind: OpReg, Reg: AH}}})
+	mustLowerWith(c.lowerConditionalMove, "CMOVQEQ", Instr{Raw: "CMOVQEQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerConditionalMove, "CMOVQNE", Instr{Raw: "CMOVQNE CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerConditionalMove, "CMOVQCS", Instr{Raw: "CMOVQCS CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerConditionalMove, "CMOVQCC", Instr{Raw: "CMOVQCC CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerConditionalMove, "CMOVQGT", Instr{Raw: "CMOVQGT CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
 	mustLower("ANDNL", Instr{Raw: "ANDNL AX, BX, CX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}}})
 	mustLower("ANDNQ", Instr{Raw: "ANDNQ AX, BX, DX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: DX}}})
 	mustLower("BEXTRQ", Instr{Raw: "BEXTRQ CX, AX, DX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: DX}}})
 	mustLower("BZHIQ", Instr{Raw: "BZHIQ DI, AX, CX", Args: []Operand{{Kind: OpReg, Reg: DI}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}})
-	mustLower("SHRQ", Instr{Raw: "SHRQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SHLQ", Instr{Raw: "SHLQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SHRQ", Instr{Raw: "SHRQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SHLQ", Instr{Raw: "SHLQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
 	mustLower("SHLXQ", Instr{Raw: "SHLXQ DI, CX, AX", Args: []Operand{{Kind: OpReg, Reg: DI}, {Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SARQ", Instr{Raw: "SARQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SARL", Instr{Raw: "SARL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SHLL", Instr{Raw: "SHLL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SHLB", Instr{Raw: "SHLB $2, R10", Args: []Operand{{Kind: OpImm, Imm: 2}, {Kind: OpReg, Reg: Reg("R10")}}})
-	mustLower("SHRL", Instr{Raw: "SHRL CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SARQ", Instr{Raw: "SARQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SARL", Instr{Raw: "SARL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SHLL", Instr{Raw: "SHLL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SHLB", Instr{Raw: "SHLB $2, R10", Args: []Operand{{Kind: OpImm, Imm: 2}, {Kind: OpReg, Reg: Reg("R10")}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SHRL", Instr{Raw: "SHRL CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
 	mustLower("SHRXQ", Instr{Raw: "SHRXQ DI, AX, CX", Args: []Operand{{Kind: OpReg, Reg: DI}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}})
-	mustLower("SALQ", Instr{Raw: "SALQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("SALL", Instr{Raw: "SALL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("ROLL", Instr{Raw: "ROLL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("ROLQ", Instr{Raw: "ROLQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
-	mustLower("RORQ", Instr{Raw: "RORQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
-	mustLower("RORL", Instr{Raw: "RORL CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SALQ", Instr{Raw: "SALQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "SALL", Instr{Raw: "SALL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "ROLL", Instr{Raw: "ROLL $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "ROLQ", Instr{Raw: "ROLQ CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "RORQ", Instr{Raw: "RORQ $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	mustLowerWith(c.lowerScalarShiftRotate, "RORL", Instr{Raw: "RORL CX, AX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: AX}}})
 	mustLower("RORXL", Instr{Raw: "RORXL $1, AX, BX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}})
 	mustLower("RORXQ", Instr{Raw: "RORXQ $1, AX, CX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: CX}}})
 	mustLower("NOTL", Instr{Raw: "NOTL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
@@ -648,9 +715,54 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 	mustLower("NOTQ", Instr{Raw: "NOTQ 20(BX)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 20}}}})
 	mustLower("BSWAPL", Instr{Raw: "BSWAPL AX", Args: []Operand{{Kind: OpReg, Reg: AX}}})
 	mustLower("MULQ", Instr{Raw: "MULQ CX", Args: []Operand{{Kind: OpReg, Reg: CX}}})
+	// MULX consumes a complete source proof. This broad fragment context has
+	// Void plus synthetic result slots, so give only MULX its own real source
+	// and matching signature. Do not lend that proof to the remaining table.
+	mulxSource, err := Parse(ArchAMD64, `TEXT mulxfragment(SB),4,$0-0
+MOVQ $7,BX
+MOVQ $3,DX
+MULXQ BX, CX, DI
+RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mulxContext, mulxOutput := newAMD64CtxWithFuncForTest(t, mulxSource.Funcs[0],
+		FuncSig{Name: "example.mulxfragment", Ret: Void}, nil)
+	if err := mulxContext.storeReg(BX, "7"); err != nil {
+		t.Fatal(err)
+	}
+	if err := mulxContext.storeReg(DX, "3"); err != nil {
+		t.Fatal(err)
+	}
+	fragmentContext := c
+	c = mulxContext
 	mustLower("MULXQ", Instr{Raw: "MULXQ BX, CX, DI", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: DI}}})
+	c = fragmentContext
+	if !strings.Contains(mulxOutput.String(), "mul i128") || !strings.Contains(mulxOutput.String(), "lshr i128") {
+		t.Fatal("complete MULX fragment lost either product half")
+	}
 	mustLower("MULL", Instr{Raw: "MULL CX", Args: []Operand{{Kind: OpReg, Reg: CX}}})
+	// This direct emitter fragment has no public entry/NUM certificate. Its
+	// trapping DIV still requires an explicit physical instruction target;
+	// missing target must fail without emitting a partial native operation.
+	beforeDivideBytes, beforeDivideTemporary := b.Len(), c.tmp
+	divide := Instr{Raw: "DIVL CX", Args: []Operand{{Kind: OpReg, Reg: CX}}}
+	known, terminated, err := c.lowerArith("DIVL", divide)
+	if !known || terminated || !errors.Is(err, ErrProbeNeedsContext) ||
+		b.Len() != beforeDivideBytes || c.tmp != beforeDivideTemporary {
+		t.Fatal("untargeted direct division acquired a native operation or partial IR", known, terminated, err)
+	}
+	oldDivideTarget := c.targetTriple
+	c.targetTriple = "x86_64-unknown-linux-gnu"
 	mustLower("DIVL", Instr{Raw: "DIVL CX", Args: []Operand{{Kind: OpReg, Reg: CX}}})
+	divideIR := b.String()[beforeDivideBytes:]
+	for _, forbidden := range []string{"udiv ", "urem ", "sdiv ", "srem "} {
+		if strings.Contains(divideIR, forbidden) {
+			t.Fatal("native division was replaced by LLVM poison-producing arithmetic", forbidden)
+		}
+	}
+	c.targetTriple = oldDivideTarget
 	mustLower("IMULQ", Instr{Raw: "IMULQ CX", Args: []Operand{{Kind: OpReg, Reg: CX}}})
 	mustLower("IMULQ", Instr{Raw: "IMULQ CX, DX", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: DX}}})
 	mustLower("IMUL3Q", Instr{Raw: "IMUL3Q $3, CX, DI", Args: []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: DI}}})
@@ -663,12 +775,11 @@ func TestAMD64ArithmeticCoverage(t *testing.T) {
 		"call i32 @llvm.ctpop.i32",
 		"call i64 @llvm.ctpop.i64",
 		"call i64 @llvm.cttz.i64",
-		"call i32 @llvm.ctlz.i32",
+		"@__test_bitscan_amd64_bsrl(",
 		"call i64 @llvm.bswap.i64",
 		"call i32 @llvm.bswap.i32",
 		"mul i128",
-		"udiv i64",
-		"urem i64",
+		`asm sideeffect "divl ${4:k}", "=&{ax},=&{dx},0,1,r,~{flags}"`,
 		"select i1",
 		"ptrtoint ptr @\"example.global\" to i64",
 		"store i8",
@@ -715,8 +826,8 @@ func TestAMD64EcosystemScalarValidationCoverage(t *testing.T) {
 			{Raw: string(op) + " X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}},
 			{Raw: string(op) + " AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}},
 		} {
-			if ok, term, err := c.lowerArith(op, ins); ok || term || err != nil {
-				t.Fatalf("lowerArith(%s) invalid form = (%v, %v, %v), want unsupported", op, ok, term, err)
+			if ok, term, err := c.lowerArith(op, ins); !ok || term || err == nil {
+				t.Fatalf("lowerArith(%s) invalid form = (%v, %v, %v), want recognized validation error", op, ok, term, err)
 			}
 		}
 	}
@@ -748,7 +859,7 @@ func TestAMD64SetCSUsesCarryFlag(t *testing.T) {
 		{Raw: "SETCS AL", Args: []Operand{{Kind: OpReg, Reg: AL}}},
 		{Raw: "SETCS AH", Args: []Operand{{Kind: OpReg, Reg: AH}}},
 	} {
-		if ok, term, err := c.lowerArith("SETCS", ins); !ok || term || err != nil {
+		if ok, term, err := c.lowerConditionalSet("SETCS", ins); !ok || term || err != nil {
 			t.Fatalf("lowerArith(%s) = (%v, %v, %v)", ins.Raw, ok, term, err)
 		}
 	}
@@ -775,7 +886,7 @@ func TestAMD64SetGEUsesSignedFlag(t *testing.T) {
 	b.WriteString("  store i1 false, ptr " + c.flagsSltSlot + "\n")
 
 	ins := Instr{Raw: "SETGE AH", Args: []Operand{{Kind: OpReg, Reg: AH}}}
-	if ok, term, err := c.lowerArith("SETGE", ins); !ok || term || err != nil {
+	if ok, term, err := c.lowerConditionalSet("SETGE", ins); !ok || term || err != nil {
 		t.Fatalf("lowerArith(%s) = (%v, %v, %v)", ins.Raw, ok, term, err)
 	}
 
@@ -814,7 +925,7 @@ func TestAMD64ADCBUsesCarryFlag(t *testing.T) {
 		"store i1 true, ptr %flags_cf",
 		"load i1, ptr %flags_cf",
 		"zext i1 %",
-		"add i8",
+		"add i16",
 		"zext i8",
 		"icmp ugt i16",
 		"shl i64",
@@ -826,6 +937,24 @@ func TestAMD64ADCBUsesCarryFlag(t *testing.T) {
 	}
 }
 
+// Exercise the actual typed owners before the residual vector dispatcher, in
+// the same order as lowerInstr. The old fixtures remain emitter-only checks.
+func lowerAMD64PackedArithmeticOrVectorForTest(c *amd64Ctx, op Op, ins Instr) (bool, bool, error) {
+	if known, terminated, err := c.lowerPackedWordMultiply(op, ins); known {
+		return known, terminated, err
+	}
+	if known, terminated, err := c.lowerPackedIntegerAdd(op, ins); known {
+		return known, terminated, err
+	}
+	if known, terminated, err := c.lowerPackedIntegerSubtract(op, ins); known {
+		return known, terminated, err
+	}
+	if known, terminated, err := c.lowerPackedMoveMask(op, ins); known {
+		return known, terminated, err
+	}
+	return c.lowerVec(op, ins)
+}
+
 func TestAMD64VectorCoverage(t *testing.T) {
 	fn := Func{
 		Instrs: []Instr{
@@ -844,17 +973,31 @@ func TestAMD64VectorCoverage(t *testing.T) {
 		},
 	}
 	c, b := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Name: "example.vec", Ret: Void}, nil)
+	// Emitter-only native vector formats still need their actual x86 backend.
+	// Complete initialized public programs have separate object owners.
+	c.targetTriple = "x86_64-unknown-linux-gnu"
 	mustLower := func(op Op, ins Instr) {
 		t.Helper()
-		if ok, term, err := c.lowerVec(op, ins); !ok || term || err != nil {
-			t.Fatalf("lowerVec(%s) = (%v, %v, %v)", op, ok, term, err)
+		if ok, term, err := lowerAMD64PackedArithmeticOrVectorForTest(c, op, ins); !ok || term || err != nil {
+			t.Fatalf("typed vector lowering(%s) = (%v, %v, %v)", op, ok, term, err)
+		}
+	}
+	mustLowerTransfer := func(op Op, ins Instr) {
+		t.Helper()
+		ins.Op = op
+		if ok, term, err := c.lowerVectorScalarIntegerMove(op, ins); !ok || term || err != nil {
+			t.Fatalf("lowerVectorScalarIntegerMove(%s) = (%v, %v, %v)", op, ok, term, err)
 		}
 	}
 
-	mustLower("MOVL", Instr{Raw: "MOVL $1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}}})
-	mustLower("MOVD", Instr{Raw: "MOVD AX, X1", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X1")}}})
-	mustLower("MOVQ", Instr{Raw: "MOVQ BX, X2", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: Reg("X2")}}})
-	mustLower("MOVQ", Instr{Raw: "MOVQ X2, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X2")}, {Kind: OpReg, Reg: AX}}})
+	goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\nMOVL $1,AX\nMOVL AX,X0\nMOVD AX,X1\nMOVQ BX,X2\nMOVQ X2,AX\nRET\n", "", true)
+	if err := c.storeReg(AX, "1"); err != nil {
+		t.Fatal(err)
+	}
+	mustLowerTransfer("MOVL", Instr{Raw: "MOVL AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}})
+	mustLowerTransfer("MOVD", Instr{Raw: "MOVD AX, X1", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X1")}}})
+	mustLowerTransfer("MOVQ", Instr{Raw: "MOVQ BX, X2", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: Reg("X2")}}})
+	mustLowerTransfer("MOVQ", Instr{Raw: "MOVQ X2, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X2")}, {Kind: OpReg, Reg: AX}}})
 	mustLower("KXORQ", Instr{Raw: "KXORQ K1, K2, K3", Args: []Operand{{Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("K2")}, {Kind: OpReg, Reg: Reg("K3")}}})
 	mustLower("KMOVB", Instr{Raw: "KMOVB AX, K1", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("K1")}}})
 	mustLower("KMOVW", Instr{Raw: "KMOVW K1, 8(BX)", Args: []Operand{{Kind: OpReg, Reg: Reg("K1")}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}}})
@@ -923,7 +1066,9 @@ func TestAMD64VectorCoverage(t *testing.T) {
 	mustLower("MOVOU", Instr{Raw: "MOVOU X0, 112(BX)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 112}}}})
 	mustLower("PXOR", Instr{Raw: "PXOR X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
 	mustLower("PAND", Instr{Raw: "PAND X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
-	mustLower("PANDN", Instr{Raw: "PANDN X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
+	if ok, term, err := c.lowerPackedAndNot("PANDN", Instr{Raw: "PANDN X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}}); !ok || term || err != nil {
+		t.Fatalf("lowerPackedAndNot(PANDN) = (%v, %v, %v)", ok, term, err)
+	}
 	mustLower("PADDL", Instr{Raw: "PADDL X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
 	mustLower("PADDQ", Instr{Raw: "PADDQ X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
 	mustLower("PSUBL", Instr{Raw: "PSUBL X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
@@ -966,9 +1111,6 @@ func TestAMD64VectorCoverage(t *testing.T) {
 	if got := llvmShiftLeftBytesMask(3); !strings.Contains(got, "i32 16") {
 		t.Fatalf("llvmShiftLeftBytesMask(3) = %q", got)
 	}
-	if got := llvmAlignRightBytesMask(20); !strings.Contains(got, "i32 20") {
-		t.Fatalf("llvmAlignRightBytesMask(20) = %q", got)
-	}
 	if got := llvmAllOnesI8Vec(4); got != "<i8 -1, i8 -1, i8 -1, i8 -1>" {
 		t.Fatalf("llvmAllOnesI8Vec(4) = %q", got)
 	}
@@ -1085,17 +1227,18 @@ func TestAMD64TranslateReturnCoverage(t *testing.T) {
 }
 
 func TestAMD64FPMovCoverage(t *testing.T) {
-	fn := Func{
-		Instrs: []Instr{
-			{Op: "MOVQ", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}},
-			{Op: "MOVQ", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}},
-			{Op: "MOVQ", Args: []Operand{{Kind: OpReg, Reg: Reg("X2")}, {Kind: OpReg, Reg: Reg("X3")}}},
-		},
-	}
+	fixture, err := Parse(ArchAMD64, "TEXT example.fpmov(SB),$0-65\n"+
+		"MOVQ arg+0(FP),AX\nMOVQ AX,BX\nPXOR X0,X0\nPXOR X2,X2\nMOVQ X0,X1\nMOVQ X2,X3\n"+
+		"MOVSD input+8(FP),X0\nMOVSD X0,ret+40(FP)\nMOVQ AX,ret+48(FP)\n"+
+		"MOVW AX,ret+56(FP)\nMOVB AX,ret+64(FP)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := fixture.Funcs[0]
 	sig := FuncSig{
 		Name: "example.fpmov",
 		Args: []LLVMType{I64, LLVMType("double"), I64, I64},
-		Ret:  Void,
+		Ret:  LLVMType("{ double, i64, i16, i8 }"),
 		Frame: FrameLayout{
 			Params: []FrameSlot{
 				{Offset: 0, Type: I64, Index: 0, Field: -1},
@@ -1112,6 +1255,7 @@ func TestAMD64FPMovCoverage(t *testing.T) {
 		},
 	}
 	c, b := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
+	c.goarch, c.targetTriple = "amd64", "x86_64-unknown-linux-gnu"
 	check := func(kind string, ins Instr, ok bool, err error) {
 		t.Helper()
 		if err != nil {
@@ -1152,7 +1296,7 @@ func TestAMD64FPMovCoverage(t *testing.T) {
 		{Op: "ANDNPD", Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}, Raw: "ANDNPD X1, X0"},
 		{Op: "ORPD", Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}, Raw: "ORPD X1, X0"},
 		{Op: "XORPS", Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}, Raw: "XORPS X1, X0"},
-		{Op: "MOVSD", Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: "X0"}}, Raw: "MOVSD $7, X0"},
+		{Op: "MOVSD", Args: []Operand{{Kind: OpImm, Imm: int64(math.Float64bits(7)), ImmIsFloat: true}, {Kind: OpReg, Reg: "X0"}}, Raw: "MOVSD $7.0, X0"},
 		{Op: "MOVSD", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 16}}}, Raw: "MOVSD X0, 16(BX)"},
 		{Op: "MOVSD", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpSym, Sym: "example.f64(SB)"}}, Raw: "MOVSD X0, example.f64(SB)"},
 		{Op: "MOVSD", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpFP, FPOffset: 40}}, Raw: "MOVSD X0, ret+40(FP)"},
@@ -1174,14 +1318,27 @@ func TestAMD64FPMovCoverage(t *testing.T) {
 		{Op: "VFMADD213SD", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"}}, Raw: "VFMADD213SD X0, X1, X2"},
 		{Op: "VFNMADD231SD", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"}}, Raw: "VFNMADD231SD X0, X1, X2"},
 	} {
+		before := b.Len()
 		ok, _, err := c.lowerFP(ins.Op, ins)
 		check("lowerFP", ins, ok, err)
+		if ins.Op == "VFMADD213SD" || ins.Op == "VFNMADD231SD" {
+			// This fragment has an explicit native target. Preserve its
+			// original fused opcode/MXCSR effects rather than demanding the
+			// separate portable numerical lowerer's fneg/llvm.fma sequence.
+			fragment := b.String()[before:]
+			native := `asm sideeffect "` + strings.ToLower(string(ins.Op)) + " "
+			if strings.Count(fragment, native) != 1 || !strings.Contains(fragment, "~{fpsr}") ||
+				!strings.Contains(fragment, "~{memory}") || !strings.Contains(fragment, ",0,") ||
+				strings.Contains(fragment, "fneg double") || strings.Contains(fragment, "@llvm.fma.") {
+				t.Fatal("native scalar FMA lost its exact fused opcode or floating effects", ins.Raw)
+			}
+		}
 	}
 
 	c.setCmpFlags("1", "2")
 	for _, ins := range []Instr{
 		{Op: "CMOVQLT", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpReg, Reg: DX}}, Raw: "CMOVQLT CX, DX"},
-		{Op: "MOVLQSX", Args: []Operand{{Kind: OpImm, Imm: 21}, {Kind: OpReg, Reg: AX}}, Raw: "MOVLQSX $21, AX"},
+		{Op: "MOVLQSX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}, Raw: "MOVLQSX AX, AX"},
 		{Op: "MOVLQSX", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}}, Raw: "MOVLQSX BX, CX"},
 		{Op: "MOVLQSX", Args: []Operand{{Kind: OpFP, FPOffset: 16}, {Kind: OpReg, Reg: DX}}, Raw: "MOVLQSX arg+16(FP), DX"},
 		{Op: "MOVLQSX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: SI, Off: 4}}, {Kind: OpReg, Reg: SI}}, Raw: "MOVLQSX 4(SI), SI"},
@@ -1245,27 +1402,29 @@ func TestAMD64FPMovCoverage(t *testing.T) {
 
 	out := b.String()
 	for _, want := range []string{
-		"fadd double",
-		"fsub double",
-		"fmul double",
-		"fdiv double",
-		"fneg double",
-		"fcmp ueq double",
+		"call double @llvm.experimental.constrained.fadd.f64",
+		"call double @__plan9asm_add_sub_special_f64",
+		"call double @llvm.experimental.constrained.fsub.f64",
+		"call double @llvm.experimental.constrained.fmul.f64",
+		"call double @llvm.experimental.constrained.fdiv.f64",
+		`call { i8, i8, i8 } asm sideeffect "comisd $3, $4; setb $0; sete $1; setp $2"`,
 		"fcmp ord double",
-		"call double @llvm.sqrt.f64",
-		"call double @llvm.rint.f64",
-		"sitofp i64",
-		"sitofp i32",
-		"fptosi double",
+		`asm sideeffect "sqrtsd $2, $0"`,
+		`call i32 asm sideeffect "cvtsd2sil $1, $0"`,
+		"@llvm.experimental.constrained.sitofp.f64.i64",
+		"@llvm.experimental.constrained.sitofp.f64.i32",
+		`call i64 asm sideeffect "cvttsd2siq $1, $0"`,
 		"select i1",
 		"bitcast i64",
 		"bitcast double",
 		"store double",
 		"store i64",
-		"store i32",
+		"store volatile i32",
 		"store i16",
 		"store i8",
-		`load <16 x i8>, ptr @"example.vec"`,
+		// Native MOVAPD must retain its aligned opcode and dead-read fault;
+		// an ordinary LLVM load is no longer the correct lowering contract.
+		`call <4 x float> asm sideeffect "movapd ($1), $0", "=x,r,~{memory}"(ptr @"example.vec")`,
 	} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
@@ -1277,10 +1436,10 @@ func TestAMD64CmpBtCoverage(t *testing.T) {
 	sig := FuncSig{
 		Name: "example.cmpbt",
 		Args: []LLVMType{I64},
-		Ret:  Void,
+		Ret:  I64,
 		Frame: FrameLayout{
-			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0}},
-			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0}},
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
 		},
 	}
 	c, b := newAMD64CtxWithFuncForTest(t, Func{}, sig, nil)
@@ -1307,13 +1466,13 @@ func TestAMD64CmpBtCoverage(t *testing.T) {
 		}
 	}
 
-	check("CMPB", Instr{Raw: "CMPB $1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}})
+	check("CMPB", Instr{Raw: "CMPB AX, $1", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpImm, Imm: 1}}})
 	check("CMPW", Instr{Raw: "CMPW 4(BX), CX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 4}}, {Kind: OpReg, Reg: CX}}})
 	check("CMPL", Instr{Raw: "CMPL arg+0(FP), DI", Args: []Operand{{Kind: OpFP, FPOffset: 0}, {Kind: OpReg, Reg: DI}}})
 	check("CMPQ", Instr{Raw: "CMPQ example.global(SB), SI", Args: []Operand{{Kind: OpSym, Sym: "example.global(SB)"}, {Kind: OpReg, Reg: SI}}})
 	check("TESTB", Instr{Raw: "TESTB AX, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}})
 	check("TESTW", Instr{Raw: "TESTW $7, arg+0(FP)", Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpFP, FPOffset: 0}}})
-	check("TESTL", Instr{Raw: "TESTL $const, 8(BX)", Args: []Operand{{Kind: OpSym, Sym: "$const"}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}}})
+	check("TESTL", Instr{Raw: "TESTL $7, 8(BX)", Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}}})
 	check("TESTQ", Instr{Raw: "TESTQ example.global(SB), DI", Args: []Operand{{Kind: OpSym, Sym: "example.global(SB)"}, {Kind: OpReg, Reg: DI}}})
 	check("BTQ", Instr{Raw: "BTQ $3, AX", Args: []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: AX}}})
 	check("BTSQ", Instr{Raw: "BTSQ DX, AX", Args: []Operand{{Kind: OpReg, Reg: DX}, {Kind: OpReg, Reg: AX}}})
@@ -1329,7 +1488,7 @@ func TestAMD64CmpBtCoverage(t *testing.T) {
 	if _, _, err := c.lowerCmpBt("TESTQ", Instr{Raw: "TESTQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}}); err == nil {
 		t.Fatalf("short TESTQ unexpectedly succeeded")
 	}
-	if _, _, err := c.lowerCmpBt("BTQ", Instr{Raw: "BTQ AX, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}}); err == nil {
+	if _, _, err := c.lowerCmpBt("BTQ", Instr{Raw: "BTQ (AX), BX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX}}, {Kind: OpReg, Reg: BX}}}); err == nil {
 		t.Fatalf("bad BTQ unexpectedly succeeded")
 	}
 	if _, _, err := c.lowerCmpBt("BTSQ", Instr{Raw: "BTSQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}}); err == nil {
@@ -1338,8 +1497,8 @@ func TestAMD64CmpBtCoverage(t *testing.T) {
 	if _, _, err := c.lowerCmpBt("BTRQ", Instr{Raw: "BTRQ AX", Args: []Operand{{Kind: OpReg, Reg: AX}}}); err == nil {
 		t.Fatalf("short BTRQ unexpectedly succeeded")
 	}
-	if got, err := c.evalIntSized(Operand{Kind: OpSym, Sym: "$const"}, I32); err != nil || got != "0" {
-		t.Fatalf("evalIntSized($const) = (%q, %v)", got, err)
+	if _, err := c.evalIntSized(Operand{Kind: OpSym, Sym: "$const"}, I32); err == nil {
+		t.Fatal("evalIntSized($const) invented a value for an unresolved constant")
 	}
 	if _, err := c.evalIntSized(Operand{Kind: OpSym, Sym: "bad"}, I32); err == nil {
 		t.Fatalf("evalIntSized(bad sym) unexpectedly succeeded")
@@ -1358,7 +1517,7 @@ func TestAMD64CmpBtCoverage(t *testing.T) {
 		"store i1 false, ptr %flags_cf",
 		"lshr i64",
 		"shl i64 1",
-		"load i64, ptr @\"example.global\"",
+		"load volatile i64, ptr @\"example.global\"",
 	} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
@@ -1370,13 +1529,20 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 	sig := FuncSig{
 		Name: "example.mov",
 		Args: []LLVMType{I64},
-		Ret:  Void,
+		Ret:  LLVMType("{ i64, i16, i8 }"),
 		Frame: FrameLayout{
-			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0}},
-			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0}, {Offset: 16, Type: I16, Index: 1}, {Offset: 24, Type: I8, Index: 2}},
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}, {Offset: 16, Type: I16, Index: 1, Field: -1}, {Offset: 24, Type: I8, Index: 2, Field: -1}},
 		},
 	}
-	c, b := newAMD64CtxWithFuncForTest(t, Func{}, sig, nil)
+	// Fragment-level emitter assertions still need a complete source when a
+	// partial logical FP view asks for the independent whole-byte proof.
+	fixture, err := Parse(ArchAMD64, "TEXT example.mov(SB),$0-25\nMOVQ arg+0(FP),AX\nMOVQ AX,ret+8(FP)\nMOVW AX,ret+16(FP)\nMOVB AX,ret+24(FP)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := fixture.Funcs[0]
+	c, b := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
 	for _, tc := range []struct {
 		r Reg
 		v string
@@ -1403,7 +1569,7 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 		}
 	}
 
-	checkMov("MOVLQSX", Instr{Raw: "MOVLQSX $7, AX", Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: AX}}})
+	checkMov("MOVLQSX", Instr{Raw: "MOVLQSX AX, AX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}})
 	checkMov("MOVLQSX", Instr{Raw: "MOVLQSX BX, CX", Args: []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}}})
 	checkMov("MOVLQSX", Instr{Raw: "MOVLQSX arg+0(FP), DX", Args: []Operand{{Kind: OpFP, FPOffset: 0}, {Kind: OpReg, Reg: DX}}})
 	checkMov("MOVLQSX", Instr{Raw: "MOVLQSX 8(BX), SI", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: SI}}})
@@ -1456,9 +1622,9 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 		t.Fatalf("MOVQ yreg dst = (%v, %v, %v)", ok, term, err)
 	}
 
-	cBadReg, _ := newAMD64CtxWithFuncForTest(t, Func{}, sig, nil)
-	if ok, term, err := cBadReg.lowerMov("MOVB", Instr{Raw: "MOVB BAD, ret+24(FP)", Args: []Operand{{Kind: OpReg, Reg: Reg("BAD")}, {Kind: OpFP, FPOffset: 24}}}); !ok || term || err != nil {
-		t.Fatalf("MOVB missing src reg = (%v, %v, %v)", ok, term, err)
+	cBadReg, _ := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
+	if ok, term, err := cBadReg.lowerMov("MOVB", Instr{Raw: "MOVB BAD, ret+24(FP)", Args: []Operand{{Kind: OpReg, Reg: Reg("BAD")}, {Kind: OpFP, FPOffset: 24}}}); !ok || term || err == nil {
+		t.Fatalf("MOVB invalid src reg = (%v, %v, %v), want handled error", ok, term, err)
 	}
 	if ok, term, err := cBadReg.lowerMov("CMOVQLT", Instr{Raw: "CMOVQLT BAD, BX", Args: []Operand{{Kind: OpReg, Reg: Reg("BAD")}, {Kind: OpReg, Reg: BX}}}); !ok || term || err != nil {
 		t.Fatalf("CMOVQLT missing regs = (%v, %v, %v)", ok, term, err)
@@ -1470,21 +1636,21 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 		t.Fatalf("MOVL missing reg = (%v, %v, %v)", ok, term, err)
 	}
 
-	cBadMem, _ := newAMD64CtxWithFuncForTest(t, Func{}, sig, nil)
-	if ok, term, err := cBadMem.lowerMov("MOVLQSX", Instr{Raw: "MOVLQSX 8(BAD), SI", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 8}}, {Kind: OpReg, Reg: SI}}}); !ok || term || err != nil {
+	cBadMem, _ := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
+	if ok, term, err := cBadMem.lowerMov("MOVLQSX", Instr{Raw: "MOVLQSX 8(BAD), SI", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 8}}, {Kind: OpReg, Reg: SI}}}); !ok || term || err == nil {
 		t.Fatalf("MOVLQSX bad mem = (%v, %v, %v)", ok, term, err)
 	}
 	if ok, term, err := cBadMem.lowerMov("MOVW", Instr{Raw: "MOVW arg+0(FP), 8(BAD)", Args: []Operand{{Kind: OpFP, FPOffset: 0}, {Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 8}}}}); !ok || term || err != nil {
 		t.Fatalf("MOVW bad dst mem = (%v, %v, %v)", ok, term, err)
 	}
-	if ok, term, err := cBadMem.lowerMov("MOVQ", Instr{Raw: "MOVQ 8(BAD), AX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 8}}, {Kind: OpReg, Reg: AX}}}); !ok || term || err != nil {
+	if ok, term, err := cBadMem.lowerMov("MOVQ", Instr{Raw: "MOVQ 8(BAD), AX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 8}}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("MOVQ bad src mem = (%v, %v, %v)", ok, term, err)
 	}
 	if ok, term, err := cBadMem.lowerMov("MOVL", Instr{Raw: "MOVL 24(BAD), example.dest(SB)", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: Reg("BAD"), Off: 24}}, {Kind: OpSym, Sym: "example.dest(SB)"}}}); !ok || term || err != nil {
 		t.Fatalf("MOVL bad src mem = (%v, %v, %v)", ok, term, err)
 	}
 
-	if ok, term, err := c.lowerMov("MOVLQSX", Instr{Raw: "MOVLQSX broken, AX", Args: []Operand{{Kind: OpSym, Sym: "broken"}, {Kind: OpReg, Reg: AX}}}); !ok || term || err != nil {
+	if ok, term, err := c.lowerMov("MOVLQSX", Instr{Raw: "MOVLQSX broken, AX", Args: []Operand{{Kind: OpSym, Sym: "broken"}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("MOVLQSX bad sym = (%v, %v, %v)", ok, term, err)
 	}
 	if ok, term, err := c.lowerMov("MOVB", Instr{Raw: "MOVB broken, AX", Args: []Operand{{Kind: OpSym, Sym: "broken"}, {Kind: OpReg, Reg: AX}}}); !ok || term || err != nil {
@@ -1504,6 +1670,7 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 	}
 
 	sysc, sysb := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.sys", Ret: Void}, nil)
+	sysc.targetTriple = "x86_64-unknown-linux-gnu" // SYSCALL has a Linux kernel ABI, not an ambient hosted convention.
 	for _, tc := range []struct {
 		r Reg
 		v string
@@ -1543,7 +1710,7 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 	if ok, term, err := sysc.lowerSyscall("BAD", Instr{}); ok || term || err != nil {
 		t.Fatalf("lowerSyscall(BAD) = (%v, %v, %v)", ok, term, err)
 	}
-	if _, _, err := sysc.lowerCrc32("CRC32B", Instr{Raw: "CRC32B AX, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}}}); err == nil {
+	if _, _, err := sysc.lowerCrc32("CRC32B", Instr{Raw: "CRC32B $1, BX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: BX}}}); err == nil {
 		t.Fatalf("bad CRC32B unexpectedly succeeded")
 	}
 	if ok, term, err := sysc.lowerCrc32("BAD", Instr{}); ok || term || err != nil {
@@ -1558,8 +1725,8 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 		"zext i8",
 		"store i16",
 		"store i32",
-		"@syscall(i64",
-		"@cliteErrno()",
+		"asm sideeffect \"syscall\"",
+		"={ax},0,{di},{si},{dx},{r10},{r8},{r9},~{rcx},~{r11}",
 		"@llvm.x86.sse42.crc32.32.8",
 		"@llvm.x86.sse42.crc32.32.16",
 		"@llvm.x86.sse42.crc32.32.32",
@@ -1570,6 +1737,9 @@ func TestAMD64MovSyscallAndCRC32Coverage(t *testing.T) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
 		}
 	}
+	if strings.Contains(sysb.String(), "@syscall(") || strings.Contains(sysb.String(), "@cliteErrno(") {
+		t.Fatal("raw Linux instruction used a hosted errno-changing wrapper", sysb.String())
+	}
 }
 
 func TestAMD64BranchCoverageDeep(t *testing.T) {
@@ -1654,7 +1824,7 @@ func TestAMD64BranchCoverageDeep(t *testing.T) {
 		"or i1",
 		"call i64 @\"example.tail\"",
 		"ret i64",
-		"br label %V1",
+		"br label %" + amd64LLVMBlockName("V1"),
 	} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
@@ -1753,10 +1923,10 @@ func TestAMD64FPExtraCoverage(t *testing.T) {
 	if _, _, err := c.lowerFP("MOVSD", Instr{Raw: "MOVSD X0, label", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpIdent, Ident: "label"}}}); err == nil {
 		t.Fatalf("MOVSD bad dst unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerFP("ADDSD", Instr{Raw: "ADDSD X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerFP("ADDSD", Instr{Raw: "ADDSD X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("ADDSD non-X dst = (%v, %v, %v)", ok, term, err)
 	}
-	if ok, term, err := c.lowerFP("SQRTSD", Instr{Raw: "SQRTSD X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerFP("SQRTSD", Instr{Raw: "SQRTSD X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("SQRTSD non-X dst = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerFP("COMISD", Instr{Raw: "COMISD X0", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}}}); err == nil {
@@ -1768,10 +1938,10 @@ func TestAMD64FPExtraCoverage(t *testing.T) {
 	if _, _, err := c.lowerFP("CMPSD", Instr{Raw: "CMPSD X0, X1, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}, {Kind: OpReg, Reg: AX}}}); err == nil {
 		t.Fatalf("CMPSD reg predicate unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerFP("CVTSQ2SD", Instr{Raw: "CVTSQ2SD AX, AX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerFP("CVTSQ2SD", Instr{Raw: "CVTSQ2SD AX, AX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("CVTSQ2SD non-X dst = (%v, %v, %v)", ok, term, err)
 	}
-	if ok, term, err := c.lowerFP("CVTSL2SD", Instr{Raw: "CVTSL2SD AX, AX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerFP("CVTSL2SD", Instr{Raw: "CVTSL2SD AX, AX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: AX}}}); !ok || term || err == nil {
 		t.Fatalf("CVTSL2SD non-X dst = (%v, %v, %v)", ok, term, err)
 	}
 
@@ -1785,8 +1955,9 @@ func TestAMD64FPExtraCoverage(t *testing.T) {
 		"fcmp uno double",
 		"fcmp une double",
 		"fcmp ugt double",
-		"fadd double",
-		"fmul double",
+		"call double @llvm.experimental.constrained.fadd.f64",
+		"call double @__plan9asm_add_sub_special_f64",
+		"call double @llvm.fma.f64",
 		"fneg double",
 	} {
 		if !strings.Contains(out, want) {
@@ -1813,7 +1984,7 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 		Args: []LLVMType{I64},
 		Ret:  Void,
 		Frame: FrameLayout{
-			Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0}},
+			Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
 		},
 	}
 	c, b := newAMD64CtxWithFuncForTest(t, fn, sig, nil)
@@ -1845,6 +2016,13 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 			t.Fatalf("lowerVec(%s %q) = (%v, %v, %v)", op, ins.Raw, ok, term, err)
 		}
 	}
+	checkTransfer := func(op Op, ins Instr) {
+		t.Helper()
+		ins.Op = op
+		if ok, term, err := c.lowerVectorScalarIntegerMove(op, ins); !ok || term || err != nil {
+			t.Fatalf("lowerVectorScalarIntegerMove(%s %q) = (%v, %v, %v)", op, ins.Raw, ok, term, err)
+		}
+	}
 
 	check("VZEROUPPER", Instr{Raw: "VZEROUPPER"})
 	check("VZEROALL", Instr{Raw: "VZEROALL"})
@@ -1859,14 +2037,14 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 	check("MOVUPS", Instr{Raw: "MOVUPS 8(BX), X0", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: Reg("X0")}}})
 	check("MOVAPS", Instr{Raw: "MOVAPS X0, 16(BX)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 16}}}})
 	check("MOVO", Instr{Raw: "MOVO X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}})
-	check("MOVQ", Instr{Raw: "MOVQ arg+0(FP), X0", Args: []Operand{{Kind: OpFP, FPOffset: 0}, {Kind: OpReg, Reg: Reg("X0")}}})
-	check("MOVQ", Instr{Raw: "MOVQ 24(BX), X1", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 24}}, {Kind: OpReg, Reg: Reg("X1")}}})
-	check("MOVQ", Instr{Raw: "MOVQ example.global(SB), X2", Args: []Operand{{Kind: OpSym, Sym: "example.global(SB)"}, {Kind: OpReg, Reg: Reg("X2")}}})
-	check("MOVQ", Instr{Raw: "MOVQ X0, 32(BX)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 32}}}})
+	checkTransfer("MOVQ", Instr{Raw: "MOVQ arg+0(FP), X0", Args: []Operand{{Kind: OpFP, FPOffset: 0}, {Kind: OpReg, Reg: Reg("X0")}}})
+	checkTransfer("MOVQ", Instr{Raw: "MOVQ 24(BX), X1", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 24}}, {Kind: OpReg, Reg: Reg("X1")}}})
+	checkTransfer("MOVQ", Instr{Raw: "MOVQ example.global(SB), X2", Args: []Operand{{Kind: OpSym, Sym: "example.global(SB)"}, {Kind: OpReg, Reg: Reg("X2")}}})
+	checkTransfer("MOVQ", Instr{Raw: "MOVQ X0, 32(BX)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 32}}}})
 	check("MOVOU", Instr{Raw: "MOVOU example.global(SB), X0", Args: []Operand{{Kind: OpSym, Sym: "example.global(SB)"}, {Kind: OpReg, Reg: Reg("X0")}}})
 	check("MOVOA", Instr{Raw: "MOVOA X0, example.out(SB)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpSym, Sym: "example.out(SB)"}}})
 	check("KMOVB", Instr{Raw: "KMOVB 8(BX), K1", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: Reg("K1")}}})
-	check("KMOVQ", Instr{Raw: "KMOVQ 8(BX), AX", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: AX}}})
+	check("KMOVD", Instr{Raw: "KMOVD K1, K7", Args: []Operand{{Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("K7")}}})
 	check("VMOVDQU64", Instr{Raw: "VMOVDQU64 example.zin(SB), Z0", Args: []Operand{{Kind: OpSym, Sym: "example.zin(SB)"}, {Kind: OpReg, Reg: Reg("Z0")}}})
 	check("VMOVDQU64", Instr{Raw: "VMOVDQU64 Z0, example.zout(SB)", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpSym, Sym: "example.zout(SB)"}}})
 	check("VMOVDQU", Instr{Raw: "VMOVDQU example.yin(SB), Y0", Args: []Operand{{Kind: OpSym, Sym: "example.yin(SB)"}, {Kind: OpReg, Reg: Reg("Y0")}}})
@@ -1875,16 +2053,16 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 	check("VMOVDQU", Instr{Raw: "VMOVDQU X0, example.xout(SB)", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpSym, Sym: "example.xout(SB)"}}})
 	check("PEXTRB", Instr{Raw: "PEXTRB $1, X1, example.byteout(SB)", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X1")}, {Kind: OpSym, Sym: "example.byteout(SB)"}}})
 
-	if _, _, err := c.lowerVec("MOVL", Instr{Raw: "MOVL label, X0", Args: []Operand{{Kind: OpIdent, Ident: "label"}, {Kind: OpReg, Reg: Reg("X0")}}}); err == nil {
+	if _, _, err := c.lowerVectorScalarIntegerMove("MOVL", Instr{Op: "MOVL", Raw: "MOVL label, X0", Args: []Operand{{Kind: OpIdent, Ident: "label"}, {Kind: OpReg, Reg: Reg("X0")}}}); err == nil {
 		t.Fatalf("MOVL bad src unexpectedly succeeded")
 	}
-	if _, _, err := c.lowerVec("MOVQ", Instr{Raw: "MOVQ label, X0", Args: []Operand{{Kind: OpIdent, Ident: "label"}, {Kind: OpReg, Reg: Reg("X0")}}}); err == nil {
+	if _, _, err := c.lowerVectorScalarIntegerMove("MOVQ", Instr{Op: "MOVQ", Raw: "MOVQ label, X0", Args: []Operand{{Kind: OpIdent, Ident: "label"}, {Kind: OpReg, Reg: Reg("X0")}}}); err == nil {
 		t.Fatalf("MOVQ bad src unexpectedly succeeded")
 	}
-	if _, _, err := c.lowerVec("MOVQ", Instr{Raw: "MOVQ X0, label", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpIdent, Ident: "label"}}}); err == nil {
+	if _, _, err := c.lowerVectorScalarIntegerMove("MOVQ", Instr{Op: "MOVQ", Raw: "MOVQ X0, label", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpIdent, Ident: "label"}}}); err == nil {
 		t.Fatalf("MOVQ bad dst unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("KXORQ", Instr{Raw: "KXORQ AX, K1, K2", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("K2")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("KXORQ", Instr{Raw: "KXORQ AX, K1, K2", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("K2")}}}); !ok || term || err == nil {
 		t.Fatalf("KXORQ non-k src = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerVec("KMOVB", Instr{Raw: "KMOVB AX", Args: []Operand{{Kind: OpReg, Reg: AX}}}); err == nil {
@@ -1902,19 +2080,19 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 	if _, _, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, 7", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpImm, Imm: 7}}}); err == nil {
 		t.Fatalf("VPERMB non-reg dst unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); !ok || term || err == nil {
 		t.Fatalf("VPERMB wrong dst reg = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, 7, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: Reg("Z2")}}}); err == nil {
 		t.Fatalf("VPERMB non-reg mask unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, AX, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z2")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("VPERMB", Instr{Raw: "VPERMB Z0, Z1, AX, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z2")}}}); !ok || term || err == nil {
 		t.Fatalf("VPERMB wrong mask reg = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerVec("VGF2P8AFFINEQB", Instr{Raw: "VGF2P8AFFINEQB Z0, Z1, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Z2")}}}); err == nil {
 		t.Fatalf("VGF2P8AFFINEQB short form unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("VGF2P8AFFINEQB", Instr{Raw: "VGF2P8AFFINEQB $1, Z0, Z1, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("VGF2P8AFFINEQB", Instr{Raw: "VGF2P8AFFINEQB $1, Z0, Z1, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); !ok || term || err == nil {
 		t.Fatalf("VGF2P8AFFINEQB wrong dst reg = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}}}); err == nil {
@@ -1923,13 +2101,13 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 	if _, _, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, 7", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpImm, Imm: 7}}}); err == nil {
 		t.Fatalf("VPERMI2B non-reg dst unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}); !ok || term || err == nil {
 		t.Fatalf("VPERMI2B wrong dst reg = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, 7, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: Reg("Z2")}}}); err == nil {
 		t.Fatalf("VPERMI2B non-reg mask unexpectedly succeeded")
 	}
-	if ok, term, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, AX, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z2")}}}); ok || term || err != nil {
+	if ok, term, err := c.lowerVec("VPERMI2B", Instr{Raw: "VPERMI2B Z0, Z1, AX, Z2", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z2")}}}); !ok || term || err == nil {
 		t.Fatalf("VPERMI2B wrong mask reg = (%v, %v, %v)", ok, term, err)
 	}
 	for _, tc := range []struct {
@@ -1938,53 +2116,60 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 		want        string
 		wantHandled bool
 	}{
-		{"VPOPCNTB", Instr{Raw: "VPOPCNTB Z0, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", false},
+		{"VPOPCNTB", Instr{Raw: "VPOPCNTB Z0, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", true},
 		{"VPCMPUQ", Instr{Raw: "VPCMPUQ $3, Z0, Z1, K1", Args: []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("K1")}}}, "bad imm", true},
 		{"VPCMPUQ", Instr{Raw: "VPCMPUQ $1, Z0, Z1, AX", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: AX}}}, "wrong dst reg", false},
-		{"VPCOMPRESSQ", Instr{Raw: "VPCOMPRESSQ Z0, AX, Z1", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z1")}}}, "wrong mask", false},
-		{"VPCOMPRESSQ", Instr{Raw: "VPCOMPRESSQ Z0, K1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", false},
+		{"VPCOMPRESSQ", Instr{Raw: "VPCOMPRESSQ Z0, AX, Z1", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Z1")}}}, "wrong mask", true},
+		{"VPCOMPRESSQ", Instr{Raw: "VPCOMPRESSQ Z0, K1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("K1")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", true},
 		{"VPXORQ", Instr{Raw: "VPXORQ Z0, Z1, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong z dst", true},
-		{"VPSHUFB", Instr{Raw: "VPSHUFB Y0, Y1, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}, {Kind: OpReg, Reg: AX}}}, "wrong dst", false},
-		{"VPSHUFD", Instr{Raw: "VPSHUFD $1, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", false},
+		{"VPSHUFB", Instr{Raw: "VPSHUFB Y0, Y1, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}, {Kind: OpReg, Reg: AX}}}, "wrong dst", true},
+		{"VPSHUFD", Instr{Raw: "VPSHUFD $1, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", true},
 		{"VPSLLD", Instr{Raw: "VPSLLD Y0, Y1", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}}}, "short form", true},
-		{"VPERM2I128", Instr{Raw: "VPERM2I128 $1, Y0, Y1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong dst", false},
-		{"VINSERTI128", Instr{Raw: "VINSERTI128 $1, X0, Y0, X1", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "wrong dst", false},
+		{"VPERM2I128", Instr{Raw: "VPERM2I128 $1, Y0, Y1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong dst", true},
+		{"VINSERTI128", Instr{Raw: "VINSERTI128 $1, X0, Y0, X1", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "wrong dst", true},
 		{"VMOVNTDQ", Instr{Raw: "VMOVNTDQ Y0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: AX}}}, "bad dst", true},
 		{"AESKEYGENASSIST", Instr{Raw: "AESKEYGENASSIST X0, X1", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "missing imm", true},
-		{"VPTEST", Instr{Raw: "VPTEST X0, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", false},
-		{"PCMPESTRI", Instr{Raw: "PCMPESTRI $1, 8(BX), X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: Reg("X0")}}}, "unsupported imm", true},
+		{"VPTEST", Instr{Raw: "VPTEST X0, Y0", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", true},
+		{"PCMPESTRI", Instr{Raw: "PCMPESTRI $-1, 8(BX), X0", Args: []Operand{{Kind: OpImm, Imm: -1}, {Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, {Kind: OpReg, Reg: Reg("X0")}}}, "invalid imm", true},
 		{"PCMPESTRI", Instr{Raw: "PCMPESTRI $0x0c, AX, X0", Args: []Operand{{Kind: OpImm, Imm: 0x0c}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}}, "bad mem operand", true},
 		{"VPBLENDD", Instr{Raw: "VPBLENDD $1, Y0, Y1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong dst", false},
 		{"VPBROADCASTB", Instr{Raw: "VPBROADCASTB Y0, Y1", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("Y1")}}}, "wrong src", false},
-		{"VPSRLDQ", Instr{Raw: "VPSRLDQ $2, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 2}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", false},
+		{"VPSRLDQ", Instr{Raw: "VPSRLDQ $2, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 2}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong src class", true},
 		{"PUNPCKLBW", Instr{Raw: "PUNPCKLBW Y0, X0", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", false},
-		{"PSHUFHW", Instr{Raw: "PSHUFHW $1, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", false},
+		{"PSHUFHW", Instr{Raw: "PSHUFHW $1, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", true},
 		{"SHUFPS", Instr{Raw: "SHUFPS $1, X0, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst", false},
 		{"MOVOU", Instr{Raw: "MOVOU AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", true},
 		{"MOVOU", Instr{Raw: "MOVOU X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}, "wrong dst class", false},
 		{"PXOR", Instr{Raw: "PXOR X0", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}}}, "short form", true},
-		{"PADDL", Instr{Raw: "PADDL X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}, "wrong dst class", false},
+		{"PADDL", Instr{Raw: "PADDL X0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}}}, "wrong dst class", true},
 		{"PSLLL", Instr{Raw: "PSLLL AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}}, "non-imm shift", true},
 		{"PCMPEQL", Instr{Raw: "PCMPEQL Y0, X0", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", false},
-		{"VPCLMULQDQ", Instr{Raw: "VPCLMULQDQ $1, Z0, Z1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong dst class", false},
-		{"VPTERNLOGD", Instr{Raw: "VPTERNLOGD $0x95, Z0, Z1, Z2", Args: []Operand{{Kind: OpImm, Imm: 0x95}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Z2")}}}, "unsupported imm", true},
-		{"VEXTRACTF32X4", Instr{Raw: "VEXTRACTF32X4 $1, X0, X1", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "wrong src class", false},
+		{"VPCLMULQDQ", Instr{Raw: "VPCLMULQDQ $1, Z0, Z1, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong dst class", true},
+		{"VPTERNLOGD", Instr{Raw: "VPTERNLOGD $0x100, Z0, Z1, Z2", Args: []Operand{{Kind: OpImm, Imm: 0x100}, {Kind: OpReg, Reg: Reg("Z0")}, {Kind: OpReg, Reg: Reg("Z1")}, {Kind: OpReg, Reg: Reg("Z2")}}}, "out-of-range imm", true},
+		{"VEXTRACTF32X4", Instr{Raw: "VEXTRACTF32X4 $1, X0, X1", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "wrong src class", true},
 		{"PCLMULQDQ", Instr{Raw: "PCLMULQDQ AX, X0, X1", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: Reg("X1")}}}, "missing imm", true},
 		{"PCMPEQB", Instr{Raw: "PCMPEQB Y0, X0", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", false},
-		{"PMOVMSKB", Instr{Raw: "PMOVMSKB Y0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: AX}}}, "wrong src class", false},
+		{"PMOVMSKB", Instr{Raw: "PMOVMSKB Y0, AX", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: AX}}}, "wrong src class", true},
 		{"PSHUFB", Instr{Raw: "PSHUFB Y0, X0", Args: []Operand{{Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong mask class", true},
 		{"PINSRQ", Instr{Raw: "PINSRQ AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}}, "short form", true},
-		{"PINSRD", Instr{Raw: "PINSRD $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", false},
-		{"PINSRW", Instr{Raw: "PINSRW $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", false},
-		{"PINSRB", Instr{Raw: "PINSRB $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", false},
+		{"PINSRD", Instr{Raw: "PINSRD $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", true},
+		{"PINSRW", Instr{Raw: "PINSRW $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", true},
+		{"PINSRB", Instr{Raw: "PINSRB $1, AX, Y0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("Y0")}}}, "wrong dst class", true},
 		{"PEXTRB", Instr{Raw: "PEXTRB AX, X0, BX", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: BX}}}, "missing imm", true},
-		{"PALIGNR", Instr{Raw: "PALIGNR $1, Y0, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", false},
-		{"PSRLDQ", Instr{Raw: "PSRLDQ $17, X0", Args: []Operand{{Kind: OpImm, Imm: 17}, {Kind: OpReg, Reg: Reg("X0")}}}, "invalid imm", true},
-		{"PSLLDQ", Instr{Raw: "PSLLDQ $17, X0", Args: []Operand{{Kind: OpImm, Imm: 17}, {Kind: OpReg, Reg: Reg("X0")}}}, "invalid imm", true},
+		{"PALIGNR", Instr{Raw: "PALIGNR $1, Y0, X0", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("Y0")}, {Kind: OpReg, Reg: Reg("X0")}}}, "wrong src class", true},
+		{"PSRLDQ", Instr{Raw: "PSRLDQ $128, X0", Args: []Operand{{Kind: OpImm, Imm: 128}, {Kind: OpReg, Reg: Reg("X0")}}}, "invalid imm", true},
+		{"PSLLDQ", Instr{Raw: "PSLLDQ $128, X0", Args: []Operand{{Kind: OpImm, Imm: 128}, {Kind: OpReg, Reg: Reg("X0")}}}, "invalid imm", true},
 		{"PSRLQ", Instr{Raw: "PSRLQ AX, X0", Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: Reg("X0")}}}, "non-imm shift", true},
 		{"PEXTRD", Instr{Raw: "PEXTRD $1, X0, label", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: Reg("X0")}, {Kind: OpIdent, Ident: "label"}}}, "bad dst kind", true},
 	} {
-		ok, term, err := c.lowerVec(tc.op, tc.ins)
+		before := b.String()
+		ok, term, err := lowerAMD64PackedArithmeticOrVectorForTest(c, tc.op, tc.ins)
+		if _, typed := x86InsertExtractSpecs[tc.op]; typed {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+tc.ins.Raw+"\nRET\n", "", false)
+			if !ok || term || err == nil || b.String() != before {
+				t.Fatalf("typed insert/extract rejection emitted IR: %s: (%v, %v, %v)", tc.ins.Raw, ok, term, err)
+			}
+		}
 		if tc.wantHandled {
 			if !ok || err == nil {
 				t.Fatalf("%s %s = (%v, %v, %v), want handled error", tc.op, tc.want, ok, term, err)
@@ -1998,8 +2183,8 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 
 	out := b.String()
 	for _, want := range []string{
-		"load i64, ptr @\"example.global\"",
-		"load i8, ptr",
+		"load volatile i64, ptr @\"example.global\"",
+		"load volatile i8, ptr",
 		"and i64",
 		"store i64",
 		"zext i8",
@@ -2012,6 +2197,40 @@ func TestAMD64VectorAliasAndErrorCoverage(t *testing.T) {
 	}
 }
 
+func TestAMD64RejectedLegacyVectorDestinationDoesNotMutateIR(t *testing.T) {
+	for _, test := range []struct {
+		op      Op
+		handled bool
+	}{
+		{op: "PSUBUSB", handled: true},
+		{op: "PABSD"},
+		{op: "PTEST", handled: true},
+	} {
+		t.Run(string(test.op), func(t *testing.T) {
+			ins := Instr{
+				Op: test.op, Raw: string(test.op) + " X0, AX",
+				Args: []Operand{{Kind: OpReg, Reg: Reg("X0")}, {Kind: OpReg, Reg: AX}},
+			}
+			c, b := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			beforeIR, beforeTmp := b.String(), c.tmp
+			ok, term, err := lowerAMD64PackedArithmeticOrVectorForTest(c, test.op, ins)
+			if test.handled {
+				if !ok || term || err == nil {
+					t.Fatalf("lowerVec(%s) = (%v, %v, %v), want handled rejection", test.op, ok, term, err)
+				}
+			} else if ok || term || err != nil {
+				t.Fatalf("lowerVec(%s) = (%v, %v, %v), want unhandled rejection", test.op, ok, term, err)
+			}
+			if got := b.String(); got != beforeIR {
+				t.Fatalf("lowerVec(%s) emitted IR before rejecting destination:\n%s", test.op, strings.TrimPrefix(got, beforeIR))
+			}
+			if c.tmp != beforeTmp {
+				t.Fatalf("lowerVec(%s) advanced temporary counter from %d to %d", test.op, beforeTmp, c.tmp)
+			}
+		})
+	}
+}
+
 func TestAMD64CtxAliasAndFPFallbackCoverage(t *testing.T) {
 	sig := FuncSig{
 		Name: "example.ctxfallback",
@@ -2055,7 +2274,7 @@ func TestAMD64CtxAliasAndFPFallbackCoverage(t *testing.T) {
 			t.Fatalf("storeRegSized(%s, %s) error = %v", tc.r, tc.ty, err)
 		}
 	}
-	for _, r := range []Reg{AL, AH, BL, BH, CL, CH, DL, DH} {
+	for _, r := range []Reg{AL, AH, BL, BH, CL, CH, DL, DH, BPB, SIB, DIB, R8B, R9B, R10B, R11B, R12B, R13B, R14B, R15B} {
 		if got, err := c.loadReg(r); err != nil || got == "" {
 			t.Fatalf("loadReg(%s) = (%q, %v)", r, got, err)
 		}
@@ -2075,6 +2294,17 @@ func TestAMD64CtxAliasAndFPFallbackCoverage(t *testing.T) {
 		{CH, "35"},
 		{DL, "20"},
 		{DH, "36"},
+		{BPB, "22"},
+		{SIB, "23"},
+		{DIB, "24"},
+		{R8B, "25"},
+		{R9B, "26"},
+		{R10B, "27"},
+		{R11B, "28"},
+		{R12B, "29"},
+		{R13B, "30"},
+		{R14B, "31"},
+		{R15B, "32"},
 	} {
 		if err := c.storeReg(tc.r, tc.v); err != nil {
 			t.Fatalf("storeReg(%s) error = %v", tc.r, err)
diff --git a/amd64_horizontal_float_arithmetic_type_test.go b/amd64_horizontal_float_arithmetic_type_test.go
new file mode 100644
index 000000000..30adcddad
--- /dev/null
+++ b/amd64_horizontal_float_arithmetic_type_test.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The arithmetic carrier must retain the same lane type as the horizontal
+// shuffles. These are the complete register rows of Go's yxm/_yvaddsubpd
+// tables, independently enumerated rather than derived from the emitter.
+func TestX86HorizontalFloatArithmeticPreservesTypedLaneWidth(t *testing.T) {
+	for _, opcode := range []string{
+		"HADDPS", "HADDPD", "HSUBPS", "HSUBPD",
+		"VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD",
+	} {
+		banks := []string{"X"}
+		vector := strings.HasPrefix(opcode, "V")
+		if vector {
+			banks = append(banks, "Y")
+		}
+		for _, bank := range banks {
+			t.Run(opcode+"/"+bank, func(t *testing.T) {
+				row := fmt.Sprintf("%s %s0,%s1", opcode, bank, bank)
+				if vector {
+					row += "," + bank + "2"
+				}
+				source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+				requireX86GoAssemblerResult(t, "amd64", source, true)
+				ir := x86UnboundVoidScalarFormatObject(t, source, "f", "amd64", "x86_64-unknown-linux-gnu")
+				width := 16
+				if bank == "Y" {
+					width = 32
+				}
+				call := fmt.Sprintf("call <%d x float> asm sideeffect", width/4)
+				if strings.Count(ir, call) != 1 || !strings.Contains(ir, strings.ToLower(opcode)+" ") || !strings.Contains(ir, "~{fpsr}") {
+					t.Fatalf("%s lost its complete typed arithmetic carrier %q", row, call)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_horizontal_float_forms.go b/amd64_horizontal_float_forms.go
new file mode 100644
index 000000000..152ba508f
--- /dev/null
+++ b/amd64_horizontal_float_forms.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86HorizontalFloatForm struct {
+	spec                               amd64HorizontalFloatingSpec
+	first, second, destination, memory int
+	byteWidth                          int
+}
+
+// Each V-prefixed opcode has exactly the two _yvaddsubpd VEX rows, not
+// EVEX rows. Sharing that ytab does not confer VADDSUB's alternating effect.
+func x86HorizontalFloatProperties(ins Instr, goarch string) (x86HorizontalFloatForm, bool, error) {
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := amd64HorizontalFloatingSpecs[Op(base)]
+	if !recognized {
+		return x86HorizontalFloatForm{}, false, nil
+	}
+	form := x86HorizontalFloatForm{spec: spec, first: 0, second: 1, destination: len(ins.Args) - 1, memory: -1, byteWidth: 16}
+	fail := func() (x86HorizontalFloatForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go horizontal floating grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if dotted || goarch != "386" && goarch != "amd64" || !spec.vector && len(ins.Args) != 2 || spec.vector && len(ins.Args) != 3 {
+		return fail()
+	}
+	if spec.vector {
+		form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+		if form.byteWidth != 16 && form.byteWidth != 32 {
+			return fail()
+		}
+	}
+	register := func(operand Operand) bool {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		return operand.Kind == OpReg && valid && (goarch == "amd64" && index < 16 || goarch == "386" && index < 8)
+	}
+	if goarch == "386" && spec.vector {
+		for _, operand := range ins.Args {
+			index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+			if operand.Kind == OpReg && valid && index >= 8 && index < 16 {
+				// Go's named VEX ytab can emit these encodings in mode32,
+				// but that does not establish extra physical SIMD registers.
+				return form, true, fmt.Errorf("%w: 386 horizontal VEX register %s has no proved physical mode32 binding", ErrProbeNeedsContext, operand.Reg)
+			}
+		}
+	}
+	if !register(ins.Args[form.second]) || !register(ins.Args[form.destination]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) {
+		if first.Kind == OpSym {
+			symbol := strings.TrimSpace(first.Sym)
+			_, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if first.Kind == OpMem {
+			displacement := first.Mem.Off
+			if displacement != int64(int32(displacement)) && (goarch != "386" || displacement != int64(uint32(displacement))) ||
+				!x86MemoryRegistersValidForArch(first.Mem, goarch) || first.Mem.Index != "" &&
+				(first.Mem.Index == SP || first.Mem.Scale != 1 && first.Mem.Scale != 2 && first.Mem.Scale != 4 && first.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		form.memory = 0
+	} else if !register(first) {
+		return fail()
+	}
+	return form, true, nil
+}
diff --git a/amd64_horizontal_float_forms_test.go b/amd64_horizontal_float_forms_test.go
new file mode 100644
index 000000000..995fce932
--- /dev/null
+++ b/amd64_horizontal_float_forms_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86HorizontalFloatEveryGoOpcodeAttribute(t *testing.T) {
+	if len(amd64HorizontalFloatingSpecs) != 8 {
+		t.Fatal("incomplete horizontal floating family")
+	}
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // older source builds still execute grammar, object and bit tests
+	}
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD", "VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD"} {
+		bits, prefix, opcode := 32, "vexF2", "0x7C"
+		if strings.HasSuffix(op, "PD") {
+			bits, prefix = 64, "vex66"
+		}
+		if strings.Contains(op, "SUB") {
+			opcode = "0x7D"
+		}
+		spec := amd64HorizontalFloatingSpecs[Op(op)]
+		if spec.laneBits != bits || spec.subtract != strings.Contains(op, "SUB") || spec.vector != strings.HasPrefix(op, "V") {
+			t.Fatalf("%s independent opcode attributes differ: %+v", op, spec)
+		}
+		if !spec.vector {
+			if !strings.Contains(string(legacy), "{A"+op+", yxm,") {
+				t.Fatalf("Go legacy yxm changed: %s", op)
+			}
+			continue
+		}
+		start := strings.Index(string(avx), "{as: A"+op+",")
+		if start < 0 {
+			t.Fatalf("Go omits %s", op)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(row, "ytab: _yvaddsubpd,") || strings.Contains(row, "evex") || strings.Contains(row, "Bcst") || strings.Contains(row, "Sae") {
+			t.Fatalf("Go VEX-only grammar changed: %s", row)
+		}
+		for _, width := range []string{"vex128", "vex256"} {
+			if !strings.Contains(row, "avxEscape | "+width+" | "+prefix+" | vex0F | vexW0, "+opcode) {
+				t.Fatalf("%s complete encoding attributes changed: %s", op, row)
+			}
+		}
+	}
+}
+
+func TestX86HorizontalFloatDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, row := range x86HorizontalFloatFormats() {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		op := file.Funcs[0].Instrs[1].Op
+		for _, identity := range []Op{"", op, Op(strings.ToLower(string(op))), "UNKNOWN", "VHADDPS.Z"} {
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = identity
+			original := ins
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerHorizontalFloating(op, ins)
+			conflict := identity == "UNKNOWN" || identity == "VHADDPS.Z"
+			if !known || term || (err != nil) != conflict || conflict && output.String() != before || !reflect.DeepEqual(ins, original) {
+				t.Fatalf("%s/%s source identity: %t/%t/%v", op, identity, known, term, err)
+			}
+		}
+	}
+}
+
+func TestX86HorizontalFloatMalformedFormsBeforeEmission(t *testing.T) {
+	for _, row := range []string{
+		"HADDPS X0,Y1", "HSUBPD X0,X16", "HADDPD.SAE X0,X1", "HSUBPS $data(SB),X1",
+		"VHADDPS X0,X1", "VHADDPD X0,Y1,Y2", "VHSUBPS Z0,Z1,Z2", "VHSUBPD X0,X1,X16",
+		"VHADDPS X0,X1,K1,X2", "VHADDPD.Z X0,X1,X2", "VHSUBPS.BCST (AX),X1,X2",
+		"VHSUBPD.RN_SAE Y0,Y1,Y2", "VHADDPS. X0,X1,X2", "VHADDPD (AX)(SP*2),X1,X2",
+		"VHSUBPS 2147483648(AX),X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerHorizontalFloating(ins.Op, ins)
+			if !known || term || err == nil || output.String() != before {
+				t.Fatalf("invalid form emitted IR: %t/%t/%v", known, term, err)
+			}
+		})
+	}
+}
+
+func TestX86HorizontalFloatGoFormatsFiveLLVMTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index, row := range x86HorizontalFloatFormats() {
+			name := fmt.Sprintf("horizontal%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), arch, triple)
+			ir := x86ScalarFormatObjectUnit(t, file, signatures, arch, triple, 0)
+			compileLLVMToObject(t, llc, triple, "horizontal-formats.ll", "horizontal-formats.o", ir)
+		}
+	}
+}
+
+func TestX86HorizontalFloatLegacyMode32ClassesMatchGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		// NOSPLIT is a CPP macro, not an assembler constant without its header.
+		goAssemblerOracleOutput(t, arch,
+			"TEXT horizontal_floating_complete_forms(SB),NOSPLIT,$0-0\nHADDPS X0,X1\nRET\n", "", false)
+	}
+	// Keep the former complete-form fixture's rejected source, rather than
+	// treating mode32 X15 as a translator-supported ordinary register.
+	for _, opcode := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD"} {
+		for _, instruction := range []string{opcode + " X15,X1", opcode + " 8(BX),X15"} {
+			t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", false)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{
+					Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}},
+				}); err == nil {
+					t.Fatal("translator accepted the original Go-rejected legacy X15 form")
+				}
+			})
+		}
+	}
+}
+
+func TestX86HorizontalFloat386VEXHighRegistersKeepPhysicalContext(t *testing.T) {
+	// Execute each compatibility Go assembler rather than trusting the current
+	// optab-only oracle. Actual objects are syntax evidence, not mode32 runtime.
+	const source = "TEXT f(SB),4,$0-0\nVHADDPS X8,X9,X10\nVHSUBPD Y8,Y9,Y10\nRET\n"
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "high.s"), filepath.Join(dir, "high.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "oracle", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), true, "386"); failure != nil {
+		t.Fatalf("actual named high-register fixture: %v\n%s", failure, output)
+	}
+	if !bytes.Contains(output, []byte("c4 41 33 7c d0 c4 41 35 7d d0 c3")) {
+		t.Fatalf("actual Go mode32 source bytes changed:\n%s", output)
+	}
+	for _, row := range []struct{ code, op, bank string }{{"c441337cd0", "VHADDPS", "X"}, {"c441357dd0", "VHSUBPD", "Y"}} {
+		code, err := hex.DecodeString(row.code)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins, length, recognized, err := decodedX86VEXHorizontalFloatInstruction(code, 64)
+		if !recognized || err != nil || length != len(code) || string(ins.Op) != row.op ||
+			ins.Args[0].Reg != Reg(row.bank+"8") || ins.Args[1].Reg != Reg(row.bank+"9") || ins.Args[2].Reg != Reg(row.bank+"10") {
+			t.Fatalf("source bytes lost physical register identities: %+v/%d/%t/%v", ins, length, recognized, err)
+		}
+		if _, _, known, err := decodedX86VEXHorizontalFloatInstruction(code, 32); !known || err == nil {
+			t.Fatal("mode32 decoder invented high physical SIMD registers")
+		}
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("named Go object laundered as physical mode32 success: %v", err)
+	}
+	goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\nHADDPS X8,X9\nRET\n", "", false)
+}
+
+func TestX86HorizontalFloatCompleteTypedFPSpanBeforeEmission(t *testing.T) {
+	for _, row := range x86HorizontalFloatFormats() {
+		if !strings.Contains(row, "(BX)") {
+			continue
+		}
+		width := 16
+		if strings.Contains(row, "Y") {
+			width = 32
+		}
+		row = strings.Replace(row, "(BX)", "a+0(FP)", 1)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-32\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, missing := range []int{-1, 0, width/8 - 1} {
+			sig := FuncSig{Name: "f", Ret: Void}
+			for index := 0; index < width/8; index++ {
+				if index == missing {
+					continue
+				}
+				sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(index * 8), Type: I64, Index: len(sig.Args), Field: -1})
+				sig.Args = append(sig.Args, I64)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			ins := file.Funcs[0].Instrs[1]
+			before := output.String()
+			known, term, err := ctx.lowerHorizontalFloating(ins.Op, ins)
+			needsContext := missing >= 0 || !strings.HasPrefix(row, "V")
+			if !known || term || (err != nil) != needsContext || needsContext && output.String() != before {
+				t.Fatalf("%s missing typed slot %d: %t/%t/%v", row, missing, known, term, err)
+			}
+		}
+	}
+}
+
+func TestX86HorizontalFloatPairsUseSingleStrictVectorOperation(t *testing.T) {
+	for _, row := range x86HorizontalFloatFormats() {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"f": {Ret: Void}}, "amd64", "x86_64-unknown-linux-gnu", 0)
+		// One original native reduction owns its joint exception, pair NaN
+		// priority and ambient MXCSR semantics. No scalar reconstruction or
+		// pure arithmetic carrier can replace it, including a dead output.
+		// The common prelude still declares unrelated constrained intrinsics.
+		// Inspect this original instruction's body, not global declarations.
+		_, body, found := strings.Cut(ir, "define void @InstructionFormat0(")
+		body, _, ended := strings.Cut(body, "\n}")
+		opcode := `asm sideeffect "` + strings.ToLower(strings.Fields(row)[0]) + ` `
+		if got := strings.Count(body, opcode); !found || !ended || got != 1 ||
+			strings.Count(body, "asm sideeffect") != 1 || !strings.Contains(body, "~{fpsr}") ||
+			!strings.Contains(body, "~{memory}") || strings.Contains(body, "@llvm.experimental.constrained") {
+			t.Fatalf("%s lost its one native strict horizontal operation (%d):\n%s", row, got, ir)
+		}
+	}
+}
diff --git a/amd64_horizontal_float_go_oracle_test.go b/amd64_horizontal_float_go_oracle_test.go
new file mode 100644
index 000000000..397b8c5b3
--- /dev/null
+++ b/amd64_horizontal_float_go_oracle_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86HorizontalFloatOriginalGoBitOracle(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+import ("encoding/binary";"testing")
+func TestOriginalHorizontalGolden(t *testing.T) {
+`)
+	for index, opcode := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD"} {
+		name, bits, move := fmt.Sprintf("horizontal%d", index), 32, "MOVUPS"
+		if strings.HasSuffix(opcode, "PD") {
+			bits, move = 64, "MOVUPD"
+		}
+		fmt.Fprintf(&declarations, "func %s(out *[20]byte,a,b *[16]byte,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\n%s (BX),X0\n%s (CX),X1\n%s X0,X1\nMOVUPS X1,(AX)\nSTMXCSR 16(AX)\nLDMXCSR saved-4(SP)\nRET\n", name, move, move, opcode)
+		// Different qNaN/sNaN payloads in both halves establish horizontal
+		// pair priority independently of the production binary helper.
+		left, right, quiet := uint64(0x7f812345), uint64(0xffc45678), uint64(0x7fc12345)
+		if bits == 64 {
+			left, right, quiet = 0x7ff0123456789abc, 0xfff8fedcba987654, 0x7ff8123456789abc
+		}
+		fmt.Fprintf(&tests, `{
+ var a,b [16]byte;var out [20]byte
+ for lane:=0;lane<16/%[2]d;lane++ {
+  value:=uint64(0x%[3]x);if lane%%2!=0 {value=0x%[4]x}
+  if %[5]d==32 {binary.LittleEndian.PutUint32(a[lane*4:],uint32(value));binary.LittleEndian.PutUint32(b[lane*4:],uint32(value))} else {binary.LittleEndian.PutUint64(a[lane*8:],value);binary.LittleEndian.PutUint64(b[lane*8:],value)}
+ }
+ %[1]s(&out,&a,&b,0x1f80)
+ for lane:=0;lane<16/%[2]d;lane++ {
+  var got uint64;if %[5]d==32 {got=uint64(binary.LittleEndian.Uint32(out[lane*4:]))}else{got=binary.LittleEndian.Uint64(out[lane*8:])}
+  if got!=0x%[6]x {t.Fatalf("%[1]s pair priority lane=%%d got=%%x",lane,got)}
+ }
+ if flags:=binary.LittleEndian.Uint32(out[16:]);flags!=0x1f81 {t.Fatalf("%[1]s sNaN flags=%%x",flags)}
+}
+`, name, bits/8, left, right, bits, quiet)
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go horizontal bit/flags oracle: %v\n%s", err, output)
+	}
+}
diff --git a/amd64_horizontal_float_numerical_test.go b/amd64_horizontal_float_numerical_test.go
new file mode 100644
index 000000000..c66db7827
--- /dev/null
+++ b/amd64_horizontal_float_numerical_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This list follows Go's four yxm and four _yvaddsubpd opcode rows. It is
+// deliberately independent of the production parser and emitter.
+func x86HorizontalFloatFormats() []string {
+	var rows []string
+	for _, op := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD"} {
+		rows = append(rows, op+" X0,X1", op+" (BX),X1")
+	}
+	for _, op := range []string{"VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD"} {
+		for _, bank := range []string{"X", "Y"} {
+			rows = append(rows, fmt.Sprintf("%s %s0,%s1,%s2", op, bank, bank, bank), fmt.Sprintf("%s (BX),%s1,%s2", op, bank, bank))
+		}
+	}
+	return rows
+}
+
+func x86HorizontalFloatSemanticsFormats() []string {
+	rows := x86HorizontalFloatFormats()
+	for _, row := range x86HorizontalFloatFormats() {
+		if !strings.HasPrefix(row, "V") || strings.Contains(row, "(BX)") {
+			continue
+		}
+		for _, destination := range []string{"0", "1"} {
+			rows = append(rows, strings.TrimSuffix(row, "2")+destination)
+		}
+	}
+	return rows
+}
+
+// A real SSE3 horizontal instruction supplies the entire 128-bit result,
+// not a scalar ADD/SUB reconstruction. VEX Y results concatenate two such
+// independent blocks. MXCSR is observed before restoring the caller state.
+const x86HorizontalFloatSSEOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+typedef uint64_t vector128 __attribute__((vector_size(16)));
+static unsigned last_horizontal_csr;
+static void horizontal_result(void *out,const void *second,const void *first,unsigned bits,int sub,unsigned csr) {
+ unsigned saved;vector128 a,b;memcpy(&a,second,16);memcpy(&b,first,16);
+ __asm__ volatile("stmxcsr %0":"=m"(saved));__asm__ volatile("ldmxcsr %0"::"m"(csr));
+ if(bits==32) {
+  if(sub)__asm__ volatile("hsubps %1,%0":"+x"(a):"x"(b));
+  else __asm__ volatile("haddps %1,%0":"+x"(a):"x"(b));
+ } else {
+  if(sub)__asm__ volatile("hsubpd %1,%0":"+x"(a):"x"(b));
+  else __asm__ volatile("haddpd %1,%0":"+x"(a):"x"(b));
+ }
+ memcpy(out,&a,16);__asm__ volatile("stmxcsr %0":"=m"(last_horizontal_csr));
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86HorizontalFloatCompletePhysicalSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range x86HorizontalFloatSemanticsFormats() {
+		op := strings.Fields(row)[0]
+		bits, width, dest, legacy := 32, 16, 2, !strings.HasPrefix(op, "V")
+		if strings.HasSuffix(op, "PD") {
+			bits = 64
+		}
+		if strings.Contains(row, "Y") {
+			width = 32
+		}
+		if legacy {
+			dest = 1
+		} else {
+			dest = int(row[len(row)-1] - '0')
+		}
+		name := fmt.Sprintf("horizontal%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nRET\n", name, row, dest)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*);\n", name)
+		fmt.Fprintf(&checks, `
+ for(unsigned vector=0;vector<20;vector++)for(unsigned mode=0;mode<4;mode++)for(unsigned control=0;control<6;control++) {
+  _Alignas(16) uint8_t aStorage[96],bStorage[96];uint8_t out[67],expected[64],beforeA[64],beforeB[64];
+  unsigned offset=%[7]d?17:16;uint8_t *a=aStorage+offset,*b=bStorage+offset;memset(aStorage,0xa7,96);memset(bStorage,0xb9,96);memset(out,0xc3,67);
+  for(unsigned lane=0;lane<64/%[2]d;lane++) {
+   uint64_t av=edges%[3]d[(vector+lane)%%20],bv=edges%[3]d[(vector*3+lane*7)%%20];
+   memcpy(a+lane*%[2]d,&av,%[2]d);memcpy(b+lane*%[2]d,&bv,%[2]d);
+  }
+  memcpy(beforeA,a,64);memcpy(beforeB,b,64);
+  unsigned csr=controls[control]|(mode<<13),observed,flags=0;
+  __asm__ volatile("ldmxcsr %%0"::"m"(csr));%[1]s(out+1,a,b);
+  __asm__ volatile("stmxcsr %%0":"=m"(observed));
+  if(%[4]d)memcpy(expected,beforeB,64);else memset(expected,0,64);
+  for(unsigned block=0;block<%[5]d;block+=16) {
+   horizontal_result(expected+block,beforeB+block,beforeA+block,%[3]d,%[6]d,csr);flags|=last_horizontal_csr&63;
+  }
+  for(unsigned byte=0;byte<64;byte++)if(out[1+byte]!=expected[byte]) {
+   fprintf(stderr,"%[1]s vector/mode/csr=%%u/%%u/%%x byte=%%u got=%%x want=%%x\n",vector,mode,csr,byte,out[1+byte],expected[byte]);return 1;
+  }
+  if(observed!=(csr|flags)){fprintf(stderr,"%[1]s MXCSR=%%x want=%%x\n",observed,csr|flags);return 2;}
+  if(out[0]!=0xc3 || out[65]!=1 || out[66]!=0xc3)return 3;
+  if(memcmp(a,beforeA,64) || memcmp(b,beforeB,64))return 5;
+  for(unsigned byte=0;byte<offset;byte++)if(aStorage[byte]!=0xa7 || bStorage[byte]!=0xb9)return 4;
+  for(unsigned byte=offset+64;byte<96;byte++)if(aStorage[byte]!=0xa7 || bStorage[byte]!=0xb9)return 4;
+ }
+`, name, bits/8, bits, x86FloatAddSubBoolInt(legacy), width, x86FloatAddSubBoolInt(strings.Contains(op, "SUB")), x86FloatAddSubBoolInt(!legacy && strings.Contains(row, "(BX)")))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86HorizontalFloatSSEOracle + declarations.String() + `int main(void) {
+ const uint64_t edges32[]={0,0x80000000,1,0x80000001,0x7fffff,0x800000,0x7f7fffff,0xff7fffff,
+  0x3f800000,0xbf800000,0x3f800001,0x33800000,0x7f800000,0xff800000,
+  0x7fc12345,0xffc45678,0x7f812345,0xff845678,0x40000000,0xc0400000};
+ const uint64_t edges64[]={0,UINT64_C(0x8000000000000000),1,UINT64_C(0x8000000000000001),
+  UINT64_C(0xfffffffffffff),UINT64_C(0x10000000000000),UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),
+  UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000001),UINT64_C(0x3ca0000000000000),
+  UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff8fedcba987654),
+  UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff0fedcba987654),UINT64_C(0x4000000000000000),UINT64_C(0xc008000000000000)};
+ const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+` + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "horizontal-complete-semantics", triple, ir, main, prefix)
+	t.Log("24 real Go formats +16 source/destination aliases x480 IEEE/MXCSR/physical-alias/canary inputs")
+}
diff --git a/amd64_horizontal_integer_family_test.go b/amd64_horizontal_integer_family_test.go
new file mode 100644
index 000000000..a4a2a51a0
--- /dev/null
+++ b/amd64_horizontal_integer_family_test.go
@@ -0,0 +1,318 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var x86HorizontalIntegerOpcodes = []string{"PHADDW", "PHADDD", "PHADDSW", "PHSUBW", "PHSUBD", "PHSUBSW"}
+
+// Independent encoder inventory: each opcode keeps all bytes, zcase, advance,
+// operand classes and offset. A shared ytab or instruction count is insufficient.
+func x86OfficialHorizontalIntegerRows(t *testing.T) []string {
+	t.Helper()
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rows []string
+	opcodes := map[string]string{"PHADDW": "0x01", "PHADDD": "0x02", "PHADDSW": "0x03", "PHSUBW": "0x05", "PHSUBD": "0x06", "PHSUBSW": "0x07"}
+	legacy := regexp.MustCompile(`\{A(PHADDW|PHADDD|PHADDSW|PHSUBW|PHSUBD|PHSUBSW), (\w+), (\w+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(string(source), -1)
+	if len(legacy) != 6 || len(amd64HorizontalIntegerSpecs) != 12 {
+		t.Fatalf("complete original horizontal opcode denominator changed: %d/%d", len(legacy), len(amd64HorizontalIntegerSpecs))
+	}
+	for _, rule := range legacy {
+		table, prefix, bytes := "yxm_q4", "Pq4", opcodes[rule[1]]
+		classes := "{Zm_r,1,argList{Yxm,Yxr}},"
+		if rule[1] == "PHADDD" {
+			table, prefix, bytes = "ymmxmm0f38", "Px", "0x0F,0x38,0x02,0,0x66,0x0F,0x38,0x02,0"
+			// Zlitm_r consumes zoffset+xo, with initial 0x0f giving xo=1:
+			// complete offsets are 0 and 4, advances 3 and 5.
+			classes = "{Zlitm_r,3,argList{Ymm,Ymr}},{Zlitm_r,5,argList{Yxm,Yxr}},"
+			rows = append(rows, "PHADDD M0,M7", "PHADDD (AX),M7")
+		}
+		definition := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(source))
+		if len(definition) != 2 || strings.Join(strings.Fields(definition[1]), "") != classes || rule[2] != table || rule[3] != prefix || strings.ReplaceAll(rule[4], " ", "") != bytes {
+			t.Fatalf("unmodeled complete horizontal legacy row: %v", rule)
+		}
+		rows = append(rows, rule[1]+" X0,X7", rule[1]+" -7(BX)(CX*4),X7")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		original := strings.TrimPrefix(rule.Opcode, "V")
+		opcode, selected := opcodes[original]
+		if !selected || rule.Opcode == original {
+			continue
+		}
+		index := rule.RowIndex
+		classes := [][]string{{"Yxm", "Yxr", "Yxr"}, {"Yym", "Yyr", "Yyr"}}
+		bytes := []string{"avxEscape | vex128 | vex66 | vex0F38 | vexW0", opcode, "avxEscape | vex256 | vex66 | vex0F38 | vexW0", opcode}
+		if index < 0 || index > 1 || rule.Ytab != "_yvaddsubpd" || rule.Prefix != "Pavx" || rule.ZCase != "Zvex_rm_v_r" || rule.ZOffset != 2 || rule.EncodingOffset != 2*index || !reflect.DeepEqual(rule.Classes, classes[index]) || !reflect.DeepEqual(rule.OpBytes, bytes) {
+			t.Fatalf("unmodeled complete horizontal VEX row: %+v", rule)
+		}
+		bank := []string{"X", "Y"}[index]
+		rows = append(rows, rule.Opcode+" "+bank+"0,"+bank+"1,"+bank+"7", rule.Opcode+" -7(BX)(CX*4),"+bank+"1,"+bank+"7")
+		counts[rule.Opcode]++
+	}
+	for _, op := range x86HorizontalIntegerOpcodes {
+		if counts["V"+op] != 2 {
+			t.Fatalf("missing complete original encoding rows for %s: %v", op, counts)
+		}
+		bits := 16
+		if op == "PHADDD" || op == "PHSUBD" {
+			bits = 32
+		}
+		for _, name := range []string{op, "V" + op} {
+			spec := amd64HorizontalIntegerSpecs[Op(name)]
+			if spec.laneBits != bits || spec.subtract != strings.Contains(name, "SUB") || spec.saturate != strings.HasSuffix(name, "SW") || spec.vector != strings.HasPrefix(name, "V") || spec.allowMMX != (name == "PHADDD") {
+				t.Fatalf("independent horizontal arithmetic attributes differ: %s %+v", name, spec)
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86HorizontalIntegerCompleteEncoderRowsThreeAPIsFiveTargets(t *testing.T) {
+	rows := x86OfficialHorizontalIntegerRows(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i") {
+				arch = "386"
+			}
+			source := "TEXT horizontal(SB),4,$0-0\n" + strings.Join(rows, "\n") + "\nRET\n"
+			if arch == "386" {
+				source = strings.Replace(source, "\nRET\n", "\nVPHSUBD 2147483648(AX),X1,X2\nRET\n", 1)
+			}
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"horizontal": {Name: "horizontal", Ret: Void}}}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("uninitialized original formats acquired numerical/MMX inputs", err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("module API invented original inputs", err)
+			}
+			translated, err := translateGoModuleInContext(ctx, x86SADGoPackage(t, arch, "()"), []byte(strings.Replace(source, "horizontal(SB)", "·sad(SB)", 1)), GoModuleOptions{GOARCH: arch, TargetTriple: triple})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Go API invented original inputs", err)
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, options.Sigs, arch, triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerHorizontalInteger(ins.Op, ins)
+				})
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86HorizontalIntegerGrammarRejectsBeforeEveryConsumer(t *testing.T) {
+	for _, row := range []string{
+		"PHADDW M0,M1", "PHADDSW X0,M1", "PHSUBD Y0,Y1", "PHADDD.Z X0,X1", "PHADDW X0,X16",
+		"VPHADDD X0,X1", "VPHADDW X0,Y1,Y2", "VPHSUBD Z0,Z1,Z2", "VPHSUBSW X0,X1,K1,X2", "VPHSUBW.Z X0,X1,X2",
+		"VPHADDD.BCST (AX),X1,X2", "VPHADDW.SAE X0,X1,X2", "VPHSUBW.RN_SAE Y0,Y1,Y2", "VPHADDD (AX)(SP*2),X1,X2", "VPHSUBD 4294967296(AX),X1,X2", "PHADDW $table(SB),X1",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT sad(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerHorizontalInteger(ins.Op, ins)
+			if !known || term || err == nil || output.String() != before || x86CallerVectorMoveKnown(ins) {
+				t.Fatal("invalid horizontal grammar emitted or registered", known, term, err)
+			}
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}}
+			state = x86CloneCallerState(state)
+			original := x86CloneCallerState(state)
+			if x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state, original) {
+				t.Fatal("invalid grammar mutated caller state")
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					arch := "amd64"
+					if strings.HasPrefix(triple, "i") {
+						arch = "386"
+					}
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"sad": {Ret: Void}}}
+					if ir, err := Translate(file, options); err == nil || ir != "" {
+						t.Fatal("invalid text API form accepted")
+					}
+					llvmCtx := llvm.NewContext()
+					defer llvmCtx.Dispose()
+					module, err := TranslateModuleInContext(llvmCtx, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err == nil {
+						t.Fatal("invalid module API form accepted")
+					}
+					translated, err := translateGoModuleInContext(llvmCtx, x86SADGoPackage(t, arch, "()"), []byte(strings.Replace(source, "sad(SB)", "·sad(SB)", 1)), GoModuleOptions{GOARCH: arch, TargetTriple: triple})
+					if translated != nil && !translated.Module.IsNil() {
+						defer translated.Module.Dispose()
+					}
+					if err == nil {
+						t.Fatal("invalid Go API form accepted")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86HorizontalIntegerDispatchAndCompleteFPSpanBeforeEmission(t *testing.T) {
+	for _, row := range x86OfficialHorizontalIntegerRows(t) {
+		ins := x86YMMReadSource(t, row)
+		for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(string(ins.Op))), "UNKNOWN", "VPHADDD.Z"} {
+			local := ins
+			local.Op = identity
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			before := output.String()
+			_, _, err := ctx.lowerHorizontalInteger(ins.Op, local)
+			if identity == "UNKNOWN" || identity == "VPHADDD.Z" {
+				if err == nil || output.String() != before {
+					t.Fatal("dispatch conflict emitted", row, identity)
+				}
+			} else if err != nil {
+				t.Fatal(row, identity, err)
+			}
+		}
+		form, _, err := x86HorizontalIntegerProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", Func{Instrs: []Instr{ins}})
+		wantFeatures := ""
+		if form.memory >= 0 && !form.spec.vector && !form.mmx {
+			wantFeatures = "+sse2,+ssse3"
+		}
+		if features != wantFeatures {
+			t.Fatalf("%s native carrier features %s != %s", row, features, wantFeatures)
+		}
+		if !strings.Contains(row, "(AX)") && !strings.Contains(row, "(BX)") {
+			continue
+		}
+		row = regexp.MustCompile(`(?:-7\(BX\)\(CX\*4\)|\(AX\))`).ReplaceAllString(row, "a+0(FP)")
+		ins = x86YMMReadSource(t, row)
+		form, _, err = x86HorizontalIntegerProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for hole := -1; hole < form.byteWidth; hole++ {
+			file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-32\n"+row+"\nRET\n")
+			sig := FuncSig{Ret: Void}
+			for at := 0; at < form.byteWidth; at++ {
+				if at == hole {
+					continue
+				}
+				sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(at), Type: I8, Index: len(sig.Args), Field: -1})
+				sig.Args = append(sig.Args, I8)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := output.String()
+			_, _, err := ctx.lowerHorizontalInteger(ins.Op, ins)
+			wantContext := !form.spec.vector && !form.mmx
+			if (err != nil) != (hole >= 0 || wantContext) || err != nil && output.String() != before || wantContext && hole < 0 && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s byte hole %d: %v", row, hole, err)
+			}
+		}
+	}
+}
+
+func TestX86HorizontalIntegerEveryInputByteAndAliasEffect(t *testing.T) {
+	for _, op := range x86HorizontalIntegerOpcodes {
+		for _, bank := range []string{"legacy", "X", "Y"} {
+			for destination := 0; destination < 3; destination++ {
+				row := op + " X0,X1"
+				if bank != "legacy" {
+					row = fmt.Sprintf("V%s %s0,%s1,%s%d", op, bank, bank, bank, destination)
+				}
+				ins := x86YMMReadSource(t, row)
+				form, known, err := x86HorizontalIntegerProperties(ins, "amd64")
+				if !known || err != nil || !x86CallerVectorMoveKnown(ins) {
+					t.Fatal("missing whole-family registration", row, err)
+				}
+				for operand := 0; operand < 2; operand++ {
+					for hole := -1; hole < form.byteWidth; hole++ {
+						state := x86SourceStackState{bp: x86SourceStackAddress{original: true}, gOriginal: true, numericFlags: true,
+							known: map[Reg]uint8{AX: 0xff}, masks: map[Reg]bool{"K1": true},
+							vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": 0x55, "Z31": 0x1234}}
+						if hole >= 0 {
+							state.vectors[x86CallerVectorRoot(ins.Args[operand].Reg)] &^= uint64(1) << uint(hole)
+						}
+						state = x86CloneCallerState(state)
+						before := x86CloneCallerState(state)
+						accepted := x86CallerVectorMoveStep(&ins, &state, nil)
+						if accepted != (hole < 0) || !accepted && !reflect.DeepEqual(state, before) {
+							t.Fatalf("%s input %d byte hole %d invented input/changed state", row, operand, hole)
+						}
+						if accepted {
+							want := x86CloneCallerState(before)
+							root := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+							want.vectors[root] = ^uint64(0)
+							if !form.spec.vector {
+								want.vectors[root] = before.vectors[root] | x86CallerVectorByteMask(int64(form.byteWidth))
+							}
+							if !reflect.DeepEqual(state, want) {
+								t.Fatal("horizontal effect altered unrelated state", row)
+							}
+						}
+					}
+				}
+				for _, upper := range []uint64{0, 0xff00000000000000, ^x86CallerVectorByteMask(int64(form.byteWidth))} {
+					mask := x86CallerVectorByteMask(int64(form.byteWidth))
+					state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": mask | upper, "Z1": mask | upper, "Z2": upper}}
+					if !x86CallerVectorMoveStep(&ins, &state, nil) {
+						t.Fatal("initialized complete input failed", row)
+					}
+					want := ^uint64(0)
+					if !form.spec.vector {
+						want = mask | upper
+					}
+					if state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)] != want {
+						t.Fatal("legacy preservation/VEX upper clearing diverged", row)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_horizontal_integer_forms.go b/amd64_horizontal_integer_forms.go
new file mode 100644
index 000000000..cbc96184b
--- /dev/null
+++ b/amd64_horizontal_integer_forms.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64HorizontalIntegerSpec struct {
+	laneBits int
+	subtract bool
+	saturate bool
+	vector   bool
+	allowMMX bool
+	// VEX.66.0F38 opcode, shared by raw decoding and typed lowering.
+	opcode byte
+}
+
+// The complete PHADD/PHSUB family has one exceptional legacy MMX row:
+// PHADDD's ymmxmm0f38. Its siblings use yxm_q4; VEX uses X/Y only.
+var amd64HorizontalIntegerSpecs = map[Op]amd64HorizontalIntegerSpec{
+	"PHADDD":   {laneBits: 32, allowMMX: true},
+	"PHADDSW":  {laneBits: 16, saturate: true},
+	"PHADDW":   {laneBits: 16},
+	"PHSUBD":   {laneBits: 32, subtract: true},
+	"PHSUBSW":  {laneBits: 16, subtract: true, saturate: true},
+	"PHSUBW":   {laneBits: 16, subtract: true},
+	"VPHADDD":  {laneBits: 32, vector: true, opcode: 0x02},
+	"VPHADDSW": {laneBits: 16, saturate: true, vector: true, opcode: 0x03},
+	"VPHADDW":  {laneBits: 16, vector: true, opcode: 0x01},
+	"VPHSUBD":  {laneBits: 32, subtract: true, vector: true, opcode: 0x06},
+	"VPHSUBSW": {laneBits: 16, subtract: true, saturate: true, vector: true, opcode: 0x07},
+	"VPHSUBW":  {laneBits: 16, subtract: true, vector: true, opcode: 0x05},
+}
+
+type x86HorizontalIntegerForm struct {
+	spec                               amd64HorizontalIntegerSpec
+	first, second, destination, memory int
+	byteWidth                          int
+	mmx                                bool
+}
+
+// Forms describe ordered bytes and encoding only; they confer no caller,
+// stack, alignment, MMX state or address permission.
+func x86HorizontalIntegerProperties(ins Instr, arch string) (x86HorizontalIntegerForm, bool, error) {
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64HorizontalIntegerSpecs[Op(base)]
+	if !known {
+		return x86HorizontalIntegerForm{}, false, nil
+	}
+	form := x86HorizontalIntegerForm{spec: spec, first: 0, second: 1, destination: len(ins.Args) - 1, memory: -1, byteWidth: 16}
+	fail := func() (x86HorizontalIntegerForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go horizontal integer grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if dotted || arch != "amd64" && arch != "386" || !spec.vector && len(ins.Args) != 2 || spec.vector && len(ins.Args) != 3 {
+		return fail()
+	}
+	if spec.allowMMX {
+		legacy, _, err := x86LegacyMMXReadProperties(ins, arch)
+		if err != nil {
+			return form, true, err
+		}
+		if err := x86LegacyMMXReadEmitterContext(ins, arch); err != nil {
+			return form, true, err
+		}
+		form.mmx, form.byteWidth = legacy.mmx, legacy.byteWidth
+		if legacy.memoryBytes != 0 {
+			form.memory = 0
+		}
+		return form, true, nil
+	}
+	if spec.vector {
+		form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+		if form.byteWidth != 16 && form.byteWidth != 32 {
+			return fail()
+		}
+	}
+	register := func(operand Operand) bool {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		return operand.Kind == OpReg && valid && index < 16 && (spec.vector || arch == "amd64" || index < 8)
+	}
+	if !register(ins.Args[form.second]) || !register(ins.Args[form.destination]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) && x86PackedShiftMemoryValid(first, arch) {
+		form.memory = form.first
+	} else if !register(first) {
+		return fail()
+	}
+	if spec.vector {
+		if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+			return form, true, err
+		}
+	}
+	return form, true, nil
+}
+
+func x86CallerHorizontalIntegerStep(ins *Instr, form x86HorizontalIntegerForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mmx {
+		return false
+	}
+	required := x86CallerVectorByteMask(int64(form.byteWidth))
+	// Require all potential input bytes before certifying memory or writing
+	// aliases. Horizontal subtract with equal operands is not a zero idiom.
+	for _, index := range []int{form.first, form.second} {
+		if index != form.memory && state.vectors[x86CallerVectorRoot(ins.Args[index].Reg)]&required != required {
+			return false
+		}
+	}
+	if form.memory >= 0 {
+		// No current caller producer supplies the actual legacy m128 alignment.
+		if !form.spec.vector || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.byteWidth), false) {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	known := ^uint64(0)
+	if !form.spec.vector {
+		known = state.vectors[destination] | required
+	}
+	state.vectors[destination] = known
+	return true
+}
diff --git a/amd64_horizontal_integer_full_alias_runtime_test.go b/amd64_horizontal_integer_full_alias_runtime_test.go
new file mode 100644
index 000000000..59874989d
--- /dev/null
+++ b/amd64_horizontal_integer_full_alias_runtime_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// All three physical vector-number views are observed after the instruction.
+// The scalar reference does not read the production grammar or lane emitter.
+// This executes portable LLVM, not original AVX/AVX512 on the host.
+func TestCrossLinuxRuntimeMatrixX86HorizontalIntegerFullAliasSentinels(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, prototypes, checks strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	count := 0
+	for _, entry := range []struct {
+		legacy, vex              string
+		lane, subtract, saturate int
+	}{
+		{"PHADDW", "VPHADDW", 2, 0, 0},
+		{"PHADDD", "VPHADDD", 4, 0, 0},
+		{"PHADDSW", "VPHADDSW", 2, 0, 1},
+		{"PHSUBW", "VPHSUBW", 2, 1, 0},
+		{"PHSUBD", "VPHSUBD", 4, 1, 0},
+		{"PHSUBSW", "VPHSUBSW", 2, 1, 1},
+	} {
+		for _, legacy := range []bool{true, false} {
+			widths := []int{16}
+			if !legacy {
+				widths = append(widths, 32)
+			}
+			for _, width := range widths {
+				bank := map[int]string{16: "X", 32: "Y"}[width]
+				for source := 0; source < 3; source++ {
+					// Distinct registers, both inputs the destructive source,
+					// and full-width memory each have independent witnesses.
+					first := bank + "0"
+					if source == 1 {
+						first = bank + "1"
+					} else if source == 2 {
+						first = "(CX)"
+					}
+					for destination := 0; destination < 3; destination++ {
+						if legacy && destination != 1 {
+							continue
+						}
+						op := entry.vex
+						args := first + "," + bank + "1"
+						if legacy {
+							op = entry.legacy
+						} else {
+							args += fmt.Sprintf(",%s%d", bank, destination)
+						}
+						name := fmt.Sprintf("H%d", count)
+						count++
+						fmt.Fprintf(&declarations, "func %s(out *[256]byte,a,b,old *[64]byte,flags uint64,csr uint32)\n", name)
+						fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-44\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nVMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nLDMXCSR csr+40(FP)\nPUSHQ flags+32(FP)\nPOPFQ\n%s %s\nVMOVUPS Z0,(AX)\nVMOVUPS Z1,64(AX)\nVMOVUPS Z2,128(AX)\nVMOVUPS Y%d,192(AX)\nVMOVUPS X%d,224(AX)\nPUSHFQ\nPOPQ R9\nMOVQ R9,240(AX)\nSTMXCSR 248(AX)\nRET\n", name, op, args, destination, destination)
+						fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t);\n", name)
+						fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,%d,%d,%d,%d,%d))return 1;\n", name, op+" "+args, width, entry.lane, entry.subtract, entry.saturate, x86FloatAddSubBoolInt(legacy), source, destination)
+					}
+				}
+			}
+		}
+	}
+	if count != 126 {
+		t.Fatal("independent legacy/VEX source and alias universe changed", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	reference := x86HorizontalIntegerFullAliasC + prototypes.String() + "int main(void){\n" + checks.String() + fmt.Sprintf("printf(\"horizontal full-alias kernels %d cases %d failures 0\\n\");return 0;}\n", count, count*97*8)
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_default_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			for _, backend := range []string{"-O0", "-O2"} {
+				t.Run("backend"+backend, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "horizontal-full-alias", text, reference, backend)
+					want := fmt.Sprintf("horizontal full-alias kernels %d cases %d failures 0\n", count, count*97*8)
+					if string(output) != want {
+						t.Fatal("full-byte alias oracle did not complete", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+	t.Log("126 independently Go-accepted legacy/VEX kernels; 97 boundary/random samples and 8 six-flag seeds per axis. All64 bytes of Z0/Z1/Z2 plus destination X/Y views, untouched sources, input/output guards and complete MXCSR; portable LLVM/Rosetta is not original AVX execution.")
+}
+
+const x86HorizontalIntegerFullAliasC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+typedef void(*Program)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t);
+struct Input {_Alignas(64) uint8_t before[64],value[64],after[64];};
+struct Output {_Alignas(64) uint8_t before[64],value[256],after[64];};
+static const uint32_t edges16[]={0,1,2,0x7ffe,0x7fff,0x8000,0x8001,0xfffe,0xffff};
+static const uint32_t edges32[]={0,1,2,0x7ffffffe,0x7fffffff,0x80000000,0x80000001,0xfffffffe,0xffffffff};
+static const uint64_t flagSeeds[]={0,0x8d5,1,4,0x10,0x40,0x80,0x800};
+static int64_t readLane(const uint8_t *p,int bytes) {
+ uint64_t value=0;for(int i=0;i<bytes;i++)value|=(uint64_t)p[i]<<(8*i);
+ return value&(UINT64_C(1)<<(bytes*8-1))?(int64_t)value-(INT64_C(1)<<(bytes*8)):(int64_t)value;
+}
+static void fill(uint8_t *a,uint8_t *b,int bytes,int sample) {
+ const uint32_t *edges=bytes==2?edges16:edges32;
+ for(int lane=0;lane<64/bytes;lane++) {
+  uint32_t x=edges[(lane%2?sample/9+(lane/2)*3:sample+lane/2)%9];
+  uint32_t y=edges[(lane%2?sample/9+(lane/2)*7+1:sample+(lane/2)*5+3)%9];
+  if(sample>=81) {x=UINT32_C(0x9e3779b9)*(unsigned)(sample*17+lane*31);y=UINT32_C(0x85ebca6b)*(unsigned)(sample*43+lane*7);}
+  for(int i=0;i<bytes;i++) {a[lane*bytes+i]=(uint8_t)(x>>(i*8));b[lane*bytes+i]=(uint8_t)(y>>(i*8));}
+ }
+}
+static int check(Program program,const char *name,int width,int lane,int sub,int sat,int legacy,int source,int destination) {
+ for(int sample=0;sample<97;sample++) for(unsigned state=0;state<sizeof(flagSeeds)/sizeof(flagSeeds[0]);state++) {
+  struct Input a,b,old;struct Output out;
+  memset(&a,0xa7,sizeof(a));memset(&b,0xb9,sizeof(b));memset(&old,0x6d,sizeof(old));memset(&out,0xc3,sizeof(out));
+  fill(a.value,b.value,lane,sample);
+  for(int i=0;i<64;i++)old.value[i]=(uint8_t)(193-i*19+sample*37);
+  struct Input savedA=a,savedB=b,savedOld=old;
+  uint8_t want[192];memcpy(want,a.value,64);memcpy(want+64,b.value,64);memcpy(want+128,old.value,64);
+  uint8_t *result=want+destination*64;
+  const uint8_t *first=source==1?b.value:a.value;
+  for(int at=0;at<width;at+=lane) {
+   int within=at%16,pair=at-within+2*(within%8);
+   const uint8_t *input=within<8?b.value:first;
+   int64_t left=readLane(input+pair,lane),right=readLane(input+pair+lane,lane);
+   int64_t value=sub?left-right:left+right;
+   if(sat) {if(value<-32768)value=-32768;if(value>32767)value=32767;}
+   for(int i=0;i<lane;i++)result[at+i]=(uint8_t)((uint64_t)value>>(8*i));
+  }
+  if(!legacy)memset(result+width,0,64-width);
+  uint64_t seed=flagSeeds[state],flags=0;uint32_t csr=0;
+  uint32_t profile=(uint32_t)(0x1f80|((sample%4)<<13)|(sample%64)),savedCSR=_mm_getcsr();
+  _mm_setcsr(profile);program(out.value,a.value,b.value,old.value,seed,profile);
+  uint32_t afterCSR=_mm_getcsr();_mm_setcsr(savedCSR);
+  memcpy(&flags,out.value+240,8);memcpy(&csr,out.value+248,4);
+  if((flags&0x8d5)!=seed||csr!=profile||afterCSR!=profile||memcmp(&a,&savedA,sizeof(a))||memcmp(&b,&savedB,sizeof(b))||memcmp(&old,&savedOld,sizeof(old))) {
+   fprintf(stderr,"%s sample%d state%u flags/CSR/input guard mismatch\n",name,sample,state);return 1;
+  }
+  for(int i=0;i<192;i++)if(out.value[i]!=want[i]) {
+   fprintf(stderr,"%s sample%d state%u physical Z%d byte%d got%x want%x\n",name,sample,state,i/64,i%64,out.value[i],want[i]);return 2;
+  }
+  for(int i=0;i<32;i++)if(out.value[192+i]!=result[i]) {
+   fprintf(stderr,"%s sample%d state%u Y%d byte%d got%x want%x\n",name,sample,state,destination,i,out.value[192+i],result[i]);return 3;
+  }
+  for(int i=0;i<16;i++)if(out.value[224+i]!=result[i]) {
+   fprintf(stderr,"%s sample%d state%u X%d byte%d got%x want%x\n",name,sample,state,destination,i,out.value[224+i],result[i]);return 4;
+  }
+  for(int i=0;i<64;i++)if(out.before[i]!=0xc3||out.after[i]!=0xc3)return 5;
+  for(int i=252;i<256;i++)if(out.value[i]!=0xc3)return 6;
+ }
+ return 0;
+}
+`
diff --git a/amd64_horizontal_integer_memory_runtime_test.go b/amd64_horizontal_integer_memory_runtime_test.go
new file mode 100644
index 000000000..a9010ddef
--- /dev/null
+++ b/amd64_horizontal_integer_memory_runtime_test.go
@@ -0,0 +1,205 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86HorizontalIntegerOriginalNativeMemory(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, originals, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	// This independent list fixes the original SSSE3 bytes and arithmetic;
+	// neither native oracle nor expected values consume the production spec.
+	for index, entry := range []struct {
+		op                    string
+		opcode                byte
+		lane, subtract, clamp int
+	}{
+		{"PHADDW", 1, 2, 0, 0}, {"PHADDD", 2, 4, 0, 0}, {"PHADDSW", 3, 2, 0, 1},
+		{"PHSUBW", 5, 2, 1, 0}, {"PHSUBD", 6, 4, 1, 0}, {"PHSUBSW", 7, 2, 1, 1},
+	} {
+		code := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+entry.op+" (SI),X1\nRET\n")
+		if !bytes.Equal(code, []byte{0x66, 0x0f, 0x38, entry.opcode, 0x0e, 0xc3}) {
+			t.Fatalf("original horizontal m128 bytes changed: %s %x", entry.op, code)
+		}
+		for _, dead := range []bool{false, true} {
+			name := fmt.Sprintf("horizontalmemory%d_%t", index, dead)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ input+8(FP),BX\nMOVOU (AX),X1\nCMPQ BX,BX\nSTC\n%s (BX),X1\n", name, entry.op)
+			tail := ""
+			if !dead {
+				source.WriteString("MOVOU X1,16(AX)\n")
+				tail = "; movdqu %%xmm1,16(%%rdi)"
+			}
+			source.WriteString("SETCS 32(AX)\nSETNE 33(AX)\nSTMXCSR 36(AX)\nRET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*);\n", name)
+			fmt.Fprintf(&originals, `static void original_%s(uint8_t *out,const uint8_t *input) {
+ __asm__ volatile("movdqu (%%%%rdi),%%%%xmm1; cmpq %%%%rsi,%%%%rsi; stc; .byte 0x66,0x0f,0x38,0x%02x,0x0e%s; setc 32(%%%%rdi); setnz 33(%%%%rdi); stmxcsr 36(%%%%rdi)" ::
+  "D"(out),"S"(input) : "xmm1","cc","memory");
+}
+`, name, entry.opcode, tail)
+			fmt.Fprintf(&checks, `
+ if(compare(original_%[1]s,%[1]s,region,0,%[2]d,%[3]d,%[4]d,%[5]d) ||
+    compare(original_%[1]s,%[1]s,boundary-16,0,%[2]d,%[3]d,%[4]d,%[5]d) ||
+    compare(original_%[1]s,%[1]s,region+1,alignmentFault,%[2]d,%[3]d,%[4]d,%[5]d) ||
+    compare(original_%[1]s,%[1]s,boundary-15,1,%[2]d,%[3]d,%[4]d,%[5]d) ||
+    compare(original_%[1]s,%[1]s,0,1,%[2]d,%[3]d,%[4]d,%[5]d)) return 1;
+`, name, entry.lane, entry.subtract, entry.clamp, x86FloatAddSubBoolInt(dead))
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + originals.String() + `
+typedef void (*memoryfn)(uint8_t*,const uint8_t*);
+static int64_t laneValue(const uint8_t *p,int lane) {
+ if(lane==2) {int16_t v;memcpy(&v,p,2);return v;}
+ int32_t v;memcpy(&v,p,4);return v;
+}
+static int observe(memoryfn fn,const uint8_t *input,int lane,int sub,int clamp,int dead) {
+ pid_t child=fork();
+ if(child<0) return -1;
+ if(child==0) {
+  struct rlimit limit={0,0};
+  if(setrlimit(RLIMIT_CORE,&limit)) _exit(2);
+  uint8_t out[48],expected[48];unsigned csr,after;
+  for(unsigned i=0;i<sizeof(out);i++) out[i]=(uint8_t)(i*79+113);
+  memcpy(expected,out,sizeof(out));
+  __asm__ volatile("stmxcsr %0":"=m"(csr));
+  fn(out+1,input);
+  if(!dead) {
+   for(int i=0;i<16/lane;i++) {
+    const uint8_t *a=i<8/lane ? expected+1 : input;
+    int at=2*(i%(8/lane))*lane;
+    int64_t left=laneValue(a+at,lane),right=laneValue(a+at+lane,lane);
+    int64_t value=sub ? left-right : left+right;
+    if(clamp) {if(value<-32768)value=-32768;if(value>32767)value=32767;}
+    uint64_t bits=(uint64_t)value;
+    for(int byte=0;byte<lane;byte++) expected[17+i*lane+byte]=(uint8_t)(bits>>(8*byte));
+   }
+  }
+  expected[33]=1;expected[34]=0;memcpy(expected+37,&csr,4);
+  __asm__ volatile("stmxcsr %0":"=m"(after));
+  if(memcmp(out,expected,sizeof(out)) || after!=csr) _exit(3);
+  _exit(0);
+ }
+ int status;
+ if(waitpid(child,&status,0)!=child) return -1;
+ if(WIFEXITED(status)) return WEXITSTATUS(status);
+ if(WIFSIGNALED(status)) return 128+WTERMSIG(status);
+ return -1;
+}
+static int compare(memoryfn reference,memoryfn translated,const uint8_t *input,int fault,int lane,int sub,int clamp,int dead) {
+ int native=observe(reference,input,lane,sub,clamp,dead),got=observe(translated,input,lane,sub,clamp,dead);
+ int memoryFault=native==128+SIGSEGV || native==128+SIGBUS;
+ int valid=fault==1 ? memoryFault : fault==-1 ? native==0 || memoryFault : native==0;
+ if(native<0 || native!=got || !valid) {
+  fprintf(stderr,"horizontal native=%d LLVM=%d input=%p fault=%d lane=%d sub=%d clamp=%d dead=%d\n",native,got,input,fault,lane,sub,clamp,dead);
+  return 1;
+ }
+ return 0;
+}
+int main(void) {
+ long page=sysconf(_SC_PAGESIZE);
+ if(page<64) return 1;
+ uint8_t *region=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(region==MAP_FAILED || mprotect(region+page,(size_t)page,PROT_NONE)) return 1;
+ for(long i=0;i<page;i++) region[i]=(uint8_t)(i*31+97);
+ uint8_t *boundary=region+page;
+#if defined(__linux__)
+ int alignmentFault=1;
+#else
+ int alignmentFault=-1;
+#endif
+` + checks.String() + `
+ return munmap(region,(size_t)page*2)!=0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "horizontal-original-memory", triple, text, oracle, prefix)
+		})
+	}
+	t.Log("12 original Go-byte/LLVM legacy live/dead programs, aligned/unaligned/NULL/guard-page reads, whole results, flags, MXCSR and canaries; Rosetta is diagnostic")
+}
+
+func TestCrossLinuxRuntimeMatrixX86HorizontalIntegerVEXDeadFullReads(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, opcode := range []string{"VPHADDW", "VPHADDD", "VPHADDSW", "VPHSUBW", "VPHSUBD", "VPHSUBSW"} {
+		for width, bank := range []string{"X", "Y"} {
+			name := fmt.Sprintf("horizontalread%d_%d", index, width)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\nVPXOR %s0,%s0,%s0\n%s (BX),%s0,%s1\nRET\n", name, bank, bank, bank, opcode, bank, bank)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+			fmt.Fprintf(&declarations, "extern void %s(const uint8_t*);\n", name)
+			fmt.Fprintf(&checks, "if(check(%s,0,1) || check(%s,boundary-%d+1,1) || check(%s,boundary-%d,0)) return 1;\n", name, name, 16<<width, name, 16<<width)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + `
+static int check(void (*program)(const uint8_t*),const uint8_t *input,int fault) {
+ pid_t child=fork();if(child<0)return 1;
+ if(child==0) {struct rlimit limit={0,0};if(setrlimit(RLIMIT_CORE,&limit))_exit(2);program(input);_exit(0);}
+ int status;if(waitpid(child,&status,0)!=child)return 1;
+ int got=WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS);
+ if(fault ? !got : !WIFEXITED(status) || WEXITSTATUS(status)!=0) {
+  fprintf(stderr,"horizontal dead read input=%p fault=%d status=%x\n",input,fault,status);return 1;
+ }
+ return 0;
+}
+int main(void) {
+ long page=sysconf(_SC_PAGESIZE);if(page<=0)return 1;
+ uint8_t *memory=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(memory==MAP_FAILED || mprotect(memory+page,(size_t)page,PROT_NONE))return 1;
+ uint8_t *boundary=memory+page;
+` + checks.String() + `return munmap(memory,(size_t)page*2)!=0;}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "horizontal-vex-dead-full-read", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_ifma_forms.go b/amd64_ifma_forms.go
new file mode 100644
index 000000000..ad931af34
--- /dev/null
+++ b/amd64_ifma_forms.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86IFMAForm struct {
+	x86PackedBinaryForm
+	spec amd64IFMASpec
+}
+
+func x86IFMAProperties(op Op, ins Instr, arch string) (x86IFMAForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64IFMASpecs[Op(base)]
+	if !known {
+		return x86IFMAForm{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86IFMAForm{}, true, fmt.Errorf("IFMA dispatch/source opcode mismatch")
+	}
+	local := ins
+	local.Op = op
+	physical := ins.x86Encoded || ins.x86SourceRaw != nil
+	form, err := x86PackedBinaryOperandGrammar(local, arch, spec.x86PackedBinarySpec, physical)
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(local, arch)
+	}
+	if err == nil && form.memory >= 0 {
+		source := ins.Args[form.memory]
+		if source.Kind == OpMem {
+			if !x86ConditionalMoveOffsetKnown(source.Mem) || source.Mem.IndexExt != "" ||
+				source.Mem.Segment != "" && source.Mem.Segment != FS && source.Mem.Segment != GS {
+				err = fmt.Errorf("IFMA source has an unresolved or foreign address")
+			} else {
+				err = x86SymbolIndexedMemoryError(source.Mem, arch)
+			}
+		}
+		if source.Kind == OpSym {
+			if address, parseErr := parseInt(strings.TrimSpace(source.Sym)); parseErr == nil &&
+				address != int64(int32(address)) && !(arch == "386" && address == int64(uint32(address))) {
+				err = fmt.Errorf("IFMA absolute source exceeds Go's disp32 extent")
+			}
+		}
+		if err == nil && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+			err = fmt.Errorf("%w: IFMA needs its original default address mode", ErrProbeNeedsContext)
+		}
+	}
+	return x86IFMAForm{form, spec}, true, err
+}
+
+func x86TypedIFMAByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86IFMAProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.byteWidth)
+	firstWidth := width
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: width, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width, read: true, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_ifma_forms_test.go b/amd64_ifma_forms_test.go
new file mode 100644
index 000000000..98dacd747
--- /dev/null
+++ b/amd64_ifma_forms_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86IFMACompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	opcodes := map[string]string{"VPMADD52HUQ": "0xB5", "VPMADD52LUQ": "0xB4"}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		opcode, wanted := opcodes[rule.Opcode]
+		if !wanted {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		classes := []string{
+			"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex",
+			"Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr",
+		}
+		var bytes []string
+		for _, width := range []int{128, 256, 512} {
+			bytes = append(bytes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW1", width),
+				fmt.Sprintf("evexN%d | evexBcstN8 | evexZeroingEnabled", width/8), opcode)
+		}
+		zcase, offset := "Zevex_rm_v_r", 0
+		if index%2 != 0 {
+			zcase, offset = "Zevex_rm_v_k_r", 3
+		}
+		if index >= 6 || rule.RowIndex != index || rule.Ytab != "_yvblendmpd" || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != offset || rule.EncodingOffset != index/2*3 ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, bytes) {
+			t.Fatal("independent complete IFMA row/tuple attributes changed", rule)
+		}
+	}
+	for name := range opcodes {
+		if counts[name] != 6 {
+			t.Fatal("complete IFMA family row denominator changed", counts)
+		}
+	}
+	if len(amd64IFMASpecs) != 2 {
+		t.Fatal("unaccounted IFMA operation")
+	}
+}
+
+func TestX86IFMAEveryNumericalSourceAndAccumulatorByte(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				ins := x86ScalarLaneInstruction(t, name+" "+bank+"0,"+bank+"1,"+bank+"2")
+				width := amd64VectorByteWidth(ins.Args[2].Reg)
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < width; missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+						for register := 0; register < 3; register++ {
+							state.writeVector(register, 64, ^uint64(0), false)
+						}
+						state.pointerGP[6], state.gp[3], state.masks[1] = true, 0x55, true
+						if missing >= 0 {
+							state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+						}
+						want := state.clone()
+						defined := x86CallerVectorByteMask(int64(width))
+						if missing >= 0 && (input == 2 || missing%8 != 7) {
+							defined &^= uint64(0xff) << uint(missing/8*8)
+						}
+						want.writeVector(2, width, defined, false)
+						accepted, known := x86ResultIFMAStep(ins, &state, nil, arch)
+						if !known || !accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("IFMA invented numerical bytes, lost meaningful subwords or changed independent state",
+								arch, name, bank, input, missing)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86IFMAZeroingStillReadsTheActualAccumulator(t *testing.T) {
+	for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			ins := x86ScalarLaneInstruction(t, name+".Z "+bank+"0,"+bank+"1,K1,"+bank+"2")
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.writeVector(0, 64, ^uint64(0), false)
+			state.writeVector(1, 64, ^uint64(0), false)
+			state.masks[1] = true
+			accepted, known := x86ResultIFMAStep(ins, &state, nil, "amd64")
+			width := amd64VectorByteWidth(ins.Args[3].Reg)
+			if !known || !accepted || state.vectorBytes(2)&x86CallerVectorByteMask(int64(width)) != 0 ||
+				state.flags != x86ByteFlagsAll {
+				t.Fatal("EVEX.z supplied the missing arithmetic accumulator or changed FLAGS", name, bank)
+			}
+		}
+	}
+}
+
+func TestX86IFMAEncodedUpperWritesCannotPreserveStaleAliases(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		var names []string
+		for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+			for _, bank := range []string{"X", "Y"} {
+				for _, raw := range []bool{false, true} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if target.arch == "386" && !raw && mode != "plain" {
+							continue // Named frontend rejects these; raw physical rows are retained.
+						}
+						op, mask := name, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							op += ".Z"
+						}
+						instruction := op + " " + bank + "0," + bank + "1," + mask + bank + "2"
+						if raw {
+							encoderArch := target.arch
+							if mode != "plain" {
+								encoderArch = "amd64"
+							}
+							instruction = x86RawNumericalInstruction(t, encoderArch, instruction)
+						}
+						function := fmt.Sprint("Upper", len(names))
+						names = append(names, function)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"+
+							"MOVL $-1,AX\nVPBROADCASTD AX,Z2\nMOVL $0,AX\nKMOVD AX,K1\n%s\n"+
+							"VEXTRACTI32X4 $3,Z2,X3\nPEXTRD $0,X3,AX\nMOVL AX,ret+0(FP)\nRET\n", function, instruction)
+						fmt.Fprintf(&declarations, "func %s()uint32\n", function)
+					}
+				}
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal("complete IFMA upper-alias source lost its initialized inputs", target, api, err)
+			}
+			x86VectorUpperRequireZeroReturns(t, ir, names)
+		}
+	}
+}
diff --git a/amd64_immediate_blend_forms.go b/amd64_immediate_blend_forms.go
new file mode 100644
index 000000000..2a5b87f6b
--- /dev/null
+++ b/amd64_immediate_blend_forms.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ImmediateBlendForm struct {
+	source, base, destination int
+	byteWidth, laneBytes      int
+	selector                  uint8
+	legacy, memory            bool
+}
+
+// Go's yxshuf and _yvblendpd supply eleven rows, not an EVEX family.
+// Physical mode32 VEX has its own decoder role; its four operands do not
+// become legal genuine named Go386 syntax.
+func x86ImmediateBlendProperties(op Op, ins Instr, arch string) (x86ImmediateBlendForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, vector, known := amd64ImmediatePackedBlendProperties(name)
+	f := x86ImmediateBlendForm{source: 1, base: 2, destination: 2, laneBytes: bits / 8, legacy: !vector}
+	if !known {
+		return f, false, nil
+	}
+	fail := func() (x86ImmediateBlendForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go immediate-blend grammar: %q", arch, op, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	if vector {
+		f.destination = 3
+	}
+	if len(ins.Args) != f.destination+1 || arch == "386" && vector && !ins.x86Encoded {
+		return fail()
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || immediate.Imm < 0 || immediate.Imm > 255 {
+		return fail()
+	}
+	f.selector = uint8(immediate.Imm)
+	f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	if f.byteWidth != 16 && (f.legacy || f.byteWidth != 32) {
+		return fail()
+	}
+	register := func(operand Operand) bool {
+		if !amd64VEXVectorRegister(operand, f.byteWidth) {
+			return false
+		}
+		index, _ := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+		return arch != "386" || index < 8
+	}
+	if !register(ins.Args[f.destination]) || !register(ins.Args[f.base]) {
+		return fail()
+	}
+	source := ins.Args[f.source]
+	f.memory = isAMD64MemoryOperand(source)
+	if !register(source) && (!f.memory || !x86PackedShiftMemoryValid(source, arch)) {
+		return fail()
+	}
+	return f, true, nil
+}
+
+func (f x86ImmediateBlendForm) selectsFirst(output int) bool {
+	return f.selector>>uint(output/f.laneBytes%8)&1 != 0
+}
+
+func x86TypedImmediateBlendByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86ImmediateBlendProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: f.source, operand: ins.Args[f.source], width: int64(f.byteWidth), read: true},
+		{index: f.base, operand: ins.Args[f.base], width: int64(f.byteWidth), read: true},
+		{index: f.destination, operand: ins.Args[f.destination], width: int64(f.byteWidth), write: true},
+	}}, true, nil
+}
diff --git a/amd64_immediate_packed_compare_forms.go b/amd64_immediate_packed_compare_forms.go
new file mode 100644
index 000000000..03304dd78
--- /dev/null
+++ b/amd64_immediate_packed_compare_forms.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ImmediatePackedCompareForm struct {
+	x86PackedIntegerCompareForm
+	unsigned  bool
+	predicate uint8
+}
+
+// All eight _yvpcmpb opcodes use the same six ordered Go rows. Operand
+// properties are shared with lowering and numerical effects; no source or
+// memory authority follows from matching this grammar.
+func x86ImmediatePackedCompareProperties(op Op, ins Instr, arch string) (x86ImmediatePackedCompareForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64ImmediatePackedCompareSpecs[base]
+	if !known {
+		return x86ImmediatePackedCompareForm{}, false, nil
+	}
+	form := x86ImmediatePackedCompareForm{unsigned: spec.unsigned}
+	form.spec.laneBits, form.maskResult = spec.laneBits, true
+	fail := func() (x86ImmediatePackedCompareForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go immediate packed compare grammar: %q", arch, op, ins.Raw)
+	}
+	// The named Go 386 frontend cannot represent these four/five-operand
+	// instructions. It does not borrow the distinct physical raw EVEX role.
+	physicalMode32 := arch == "386" && (ins.x86Encoded || ins.x86SourceRaw != nil)
+	if arch != "amd64" && !physicalMode32 || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) != 4 && len(ins.Args) != 5 {
+		return fail()
+	}
+	immediate := ins.Args[0]
+	if immediate.Kind != OpImm || immediate.ImmRaw != "" || immediate.ImmIsFloat || immediate.Imm < 0 || immediate.Imm > 255 {
+		return fail()
+	}
+	binary, valid := x86PackedMaskCompareProperties(ins, arch, 1, spec.laneBits, dotted, suffix)
+	if !valid {
+		return fail()
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, true, err
+	}
+	form.x86PackedBinaryForm = binary
+	form.source, form.predicate = ins.Args[form.first], uint8(immediate.Imm)
+	if form.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return form, true, fmt.Errorf("%w: immediate packed compare has no bound address-size override", ErrProbeNeedsContext)
+	}
+	return form, true, nil
+}
diff --git a/amd64_immediate_packed_compare_forms_test.go b/amd64_immediate_packed_compare_forms_test.go
new file mode 100644
index 000000000..6e0f66dc2
--- /dev/null
+++ b/amd64_immediate_packed_compare_forms_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ImmediatePackedCompareCompleteGoRowsAndAttributes(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := strings.Join(strings.Fields(string(source)), "")
+	rows := []string{
+		"{zcase:Zevex_i_rm_v_r,zoffset:0,args:argList{Yu8,YxmEvex,YxrEvex,Yk}}",
+		"{zcase:Zevex_i_rm_v_k_r,zoffset:3,args:argList{Yu8,YxmEvex,YxrEvex,Yknot0,Yk}}",
+		"{zcase:Zevex_i_rm_v_r,zoffset:0,args:argList{Yu8,YymEvex,YyrEvex,Yk}}",
+		"{zcase:Zevex_i_rm_v_k_r,zoffset:3,args:argList{Yu8,YymEvex,YyrEvex,Yknot0,Yk}}",
+		"{zcase:Zevex_i_rm_v_r,zoffset:0,args:argList{Yu8,Yzm,Yzr,Yk}}",
+		"{zcase:Zevex_i_rm_v_k_r,zoffset:3,args:argList{Yu8,Yzm,Yzr,Yknot0,Yk}}",
+	}
+	if !strings.Contains(actual, "var_yvpcmpb=[]ytab{"+strings.Join(rows, ",")+",}") {
+		t.Fatal("actual SDK complete ordered immediate comparison rows changed")
+	}
+	seen := map[string]bool{}
+	for _, match := range regexp.MustCompile(`\{as:A(VPCMPU?[BWDQ]),ytab:_yvpcmpb,`).FindAllStringSubmatch(actual, -1) {
+		if seen[match[1]] {
+			t.Fatal("duplicate actual SDK immediate comparison member", match[1])
+		}
+		seen[match[1]] = true
+	}
+	if len(seen) != 8 || len(amd64ImmediatePackedCompareSpecs) != 8 {
+		t.Fatal("complete immediate comparison family changed", seen)
+	}
+	for _, op := range x86ImmediateCompareResultMembers {
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		unsigned := strings.HasPrefix(op, "VPCMPU")
+		w, broadcast := "W0", ""
+		if bits == 16 || bits == 64 {
+			w = "W1"
+		}
+		if bits >= 32 {
+			broadcast = fmt.Sprintf("|evexBcstN%d", bits/8)
+		}
+		opcode := 0x3f
+		if bits >= 32 {
+			opcode = 0x1f
+		}
+		if unsigned {
+			opcode--
+		}
+		var attributes strings.Builder
+		for _, width := range []int{128, 256, 512} {
+			fmt.Fprintf(&attributes, "avxEscape|evex%d|evex66|evex0F3A|evex%s,evexN%d%s,0x%X,", width, w, width/8, broadcast, opcode)
+		}
+		if !strings.Contains(actual, "{as:A"+op+",ytab:_yvpcmpb,prefix:Pavx,op:opBytes{"+attributes.String()+"}},") {
+			t.Fatal("actual SDK immediate comparison encoding attributes changed", op)
+		}
+		spec, present := amd64ImmediatePackedCompareSpecs[op]
+		if !seen[op] || !present || spec.laneBits != bits || spec.unsigned != unsigned {
+			t.Fatal("typed spec differs from complete independent Go member", op, spec)
+		}
+	}
+}
diff --git a/amd64_immediate_shuffle_class_boundaries_test.go b/amd64_immediate_shuffle_class_boundaries_test.go
new file mode 100644
index 000000000..6c1ea3b42
--- /dev/null
+++ b/amd64_immediate_shuffle_class_boundaries_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86ImmediateShuffleRejectsNonIntegerClassesEveryConsumer(t *testing.T) {
+	for _, op := range []string{"PSHUFW", "PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, literal := range []string{"$0.0", "$1.0", "$UNKNOWN"} {
+			bank := "X"
+			if op == "PSHUFW" {
+				bank = "M"
+			}
+			row := fmt.Sprintf("%s %s,%s0,%s1", op, literal, bank, bank)
+			t.Run(row, func(t *testing.T) {
+				assembly := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+				for _, arch := range []string{"amd64", "386"} {
+					goAssemblerOracleOutput(t, arch, assembly, "", false)
+					ins := x86YMMReadSource(t, row)
+					if _, known, err := x86ImmediateShuffleProperties(ins, arch); !known || err == nil {
+						t.Error("non-integer class acquired integer grammar", arch, literal, err)
+					}
+					var output strings.Builder
+					ctx := &amd64Ctx{goarch: arch, b: &output}
+					if known, _, err := ctx.lowerPackedWordShuffle(ins.Op, ins); !known || err == nil || output.Len() != 0 {
+						t.Error("non-integer class emitted IR", arch, err, output.String())
+					}
+					state := x86CloneCallerState(x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0)}})
+					before := x86CloneCallerState(state)
+					if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state, before) {
+						t.Error("non-integer class acquired caller effects or changed state", arch)
+					}
+					result := x86ResultState{}
+					result.writeVector(0, 64, ^uint64(0), false)
+					result.writeVector(1, 64, ^uint64(0), false)
+					beforeResult := result.clone()
+					if x86ResultTransfer(ins, &result, nil, 0, arch) || !reflect.DeepEqual(result, beforeResult) {
+						t.Error("non-integer class acquired result effects or changed state", arch)
+					}
+				}
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}}
+				if _, err := Translate(file, options); err == nil {
+					t.Error("text API accepted non-integer immediate")
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err == nil {
+					t.Error("module API accepted non-integer immediate")
+				}
+				pkg := mustGoPackage(t, "example.invalid/shuffle", "package shuffle\nfunc f()\n")
+				translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+					GOARCH: "amd64", TargetTriple: options.TargetTriple,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if err == nil {
+					t.Error("actual typed declaration API accepted non-integer immediate")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImmediateShuffleGoMode32ConstantClassification(t *testing.T) {
+	// Go's oclass truncates TYPE_CONST to int32 only in I386 mode. This is
+	// source classification, not permission to invent an encoded raw operand.
+	values := []int64{4294967296, -4294967296, 4294967168, 4294967423, 4294967424, 4294967551, 4294967552, -4294967297}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			for _, op := range []string{"PSHUFW", "PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+				banks := []string{"X"}
+				if op == "PSHUFW" {
+					banks = []string{"M"}
+				} else if strings.HasPrefix(op, "V") {
+					banks = append(banks, "Z")
+				}
+				for _, bank := range banks {
+					for _, value := range values {
+						classified := value
+						if arch == "386" {
+							classified = int64(int32(value))
+						}
+						accepted := classified >= 0 && classified <= 255
+						if op == "PSHUFW" {
+							accepted = classified >= -128 && classified <= 127
+						} else if strings.HasPrefix(op, "V") && bank == "X" {
+							accepted = classified >= -128 && classified <= 255
+						}
+						row := fmt.Sprintf("%s $%d,%s0,%s1", op, value, bank, bank)
+						goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", accepted)
+						ins := x86YMMReadSource(t, row)
+						before := fmt.Sprintf("%#v", ins)
+						form, known, err := x86ImmediateShuffleProperties(ins, arch)
+						if !known || accepted != (err == nil) || accepted && form.immediate != uint8(classified) {
+							t.Errorf("Go %s accepted=%v for %s, grammar=%+v error=%v", arch, accepted, row, form, err)
+						}
+						if before != fmt.Sprintf("%#v", ins) {
+							t.Fatal("classification changed original constant/source")
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShuffleRawMMXCompleteImmediateBits(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT f(SB),4,$0-0\n")
+			var expected []byte
+			for value := 0; value < 256; value++ {
+				code := []byte{0x0f, 0x70, 0xc8, byte(value)}
+				fmt.Fprintf(&source, "PSHUFW $%d,M0,M1\n", int8(value))
+				expected = append(expected, code...)
+				decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+				if err != nil || len(decoded.Instrs) != 1 {
+					t.Fatalf("physical imm8 %x lost instruction identity: %+v %v", code, decoded, err)
+				}
+				form, known, err := x86ImmediateShuffleProperties(decoded.Instrs[0], arch)
+				if !known || err != nil || form.immediate != uint8(value) || !form.spec.mmx {
+					t.Errorf("raw PSHUFW imm8=%d lost Go Yi8 spelling: %+v %v", value, form, err)
+				}
+			}
+			source.WriteString("RET\n")
+			expected = append(expected, 0xc3)
+			if got := assembleX87ControlBytes(t, arch, source.String()); !bytes.HasPrefix(got, expected) {
+				t.Fatal("independent Go signed source did not encode the original physical imm8 bytes")
+			}
+		})
+	}
+}
diff --git a/amd64_immediate_shuffle_effects_test.go b/amd64_immediate_shuffle_effects_test.go
new file mode 100644
index 000000000..ed6850195
--- /dev/null
+++ b/amd64_immediate_shuffle_effects_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86ImmediateShuffleCompleteLegacyOriginalRows(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pattern := regexp.MustCompile(`\{A(PSHUFW|PSHUFL|PSHUFD|PSHUFHW|PSHUFLW), (\w+), (\w+), opBytes\{([^}]+)\}\}`)
+	rows := pattern.FindAllStringSubmatch(string(source), -1)
+	if len(rows) != 5 {
+		t.Fatalf("complete legacy original shuffle denominator changed: %d", len(rows))
+	}
+	for _, row := range rows {
+		prefix := map[string]string{"PSHUFW": "Pm", "PSHUFL": "Pq", "PSHUFD": "Pq", "PSHUFHW": "Pf3", "PSHUFLW": "Pf2"}[row[1]]
+		table := "yxshuf"
+		classes := "{Zibm_r,2,argList{Yu8,Yxm,Yxr}},"
+		if row[1] == "PSHUFW" {
+			table, classes = "ymshuf", "{Zibm_r,2,argList{Yi8,Ymm,Ymr}},"
+		}
+		definition := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(source))
+		if len(definition) != 2 || strings.Join(strings.Fields(definition[1]), "") != classes ||
+			row[2] != table || row[3] != prefix || row[4] != "0x70, 00" && row[4] != "0x70, 0" {
+			t.Fatal("unmodeled complete legacy prefix/operands/opcode", row)
+		}
+	}
+}
+
+func TestX86ImmediateShuffleByteKnowledgeAndUnaffectedState(t *testing.T) {
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		widths := []int{16}
+		if strings.HasPrefix(op, "V") {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if !strings.HasPrefix(op, "V") && mode != "plain" {
+					continue
+				}
+				for _, alias := range []bool{false, true} {
+					for _, immediate := range []int{0, 27, 228, 255} {
+						bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+						destination := 1
+						if alias {
+							destination = 0
+						}
+						row := op
+						if mode == "zero" {
+							row += ".Z"
+						}
+						row += fmt.Sprintf(" $%d,%s0,", immediate, bank)
+						if mode != "plain" {
+							row += "K1,"
+						}
+						row += fmt.Sprint(bank, destination)
+						t.Run(row, func(t *testing.T) {
+							ins := x86YMMReadSource(t, row)
+							for seed := 0; seed < 32; seed++ {
+								initial := x86SourceStackState{
+									bp: x86SourceStackAddress{original: true}, gOriginal: true, numericFlags: true,
+									callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}}, known: map[Reg]uint8{AX: 0xff},
+									vectors: map[Reg]uint64{"Z0": uint64(seed)*0x1937a73b15d94ca7 ^ 0x31c097642eaf859b,
+										"Z1": uint64(seed)*0xf03755e989ab7361 ^ 0xae78f9234cbad619, "Z31": 0x55},
+									masks: map[Reg]bool{"K1": true, "K0": false},
+								}
+								state, want := x86CloneCallerState(initial), x86CloneCallerState(initial)
+								var expected uint64
+								lane := 4
+								if strings.Contains(op, "HW") || strings.Contains(op, "LW") {
+									lane = 2
+								}
+								old := initial.vectors[Reg(fmt.Sprint("Z", destination))]
+								for output := 0; output < 64; output++ {
+									known := old>>uint(output)&1 != 0
+									if output >= width {
+										known = strings.HasPrefix(op, "V") || known
+									} else {
+										at := output
+										if lane == 4 {
+											at = output/16*16 + (immediate>>(2*(output%16/4))&3)*4 + output%4
+										} else if word := output % 16 / 2; word < 4 && strings.Contains(op, "LW") || word >= 4 && strings.Contains(op, "HW") {
+											half := 0
+											if strings.Contains(op, "HW") {
+												half = 8
+											}
+											at = output/16*16 + half + (immediate>>(2*(word%4))&3)*2 + output%2
+										}
+										known = initial.vectors["Z0"]>>uint(at)&1 != 0
+										if mode == "merge" {
+											known = known && old>>uint(output)&1 != 0
+										}
+									}
+									if known {
+										expected |= uint64(1) << uint(output)
+									}
+								}
+								want.vectors[Reg(fmt.Sprint("Z", destination))] = expected
+								// The independent result observer must consume the same
+								// family, not reject it after correct caller/lowering work.
+								result := x86ResultState{flags: 0x3f, fp: []bool{true, false}, auto: []bool{false, true}}
+								result.gp[0], result.pointerGP[7], result.masks[1] = 0xff, true, true
+								for _, index := range []int{0, 1, 31} {
+									result.writeVector(index, 64, initial.vectors[Reg(fmt.Sprint("Z", index))], false)
+								}
+								wantResult := result.clone()
+								wantResult.writeVector(destination, 64, expected, false)
+								if !x86ResultTransfer(ins, &result, nil, 0, "amd64") || !reflect.DeepEqual(result, wantResult) {
+									t.Fatalf("%s seed=%d lost result bytes or unrelated state: got=%+v want=%+v", row, seed, result, wantResult)
+								}
+								if !x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state, want) {
+									t.Fatalf("%s seed=%d changed byte dependencies or unrelated state: got=%+v want=%+v", row, seed, state, want)
+								}
+								state = x86CloneCallerState(initial)
+								state.masks["K1"] = false
+								before := x86CloneCallerState(state)
+								if mode != "plain" && (x86CallerVectorMoveStep(&ins, &state, nil) || !reflect.DeepEqual(state, before)) {
+									t.Fatal("unknown mask acquired data or mutated state")
+								}
+								result.masks[1] = false
+								beforeResult := result.clone()
+								if mode != "plain" && (x86ResultTransfer(ins, &result, nil, 0, "amd64") || !reflect.DeepEqual(result, beforeResult)) {
+									t.Fatal("unknown result mask acquired data or mutated state")
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImmediateShuffleActualCallerThreeAPIs(t *testing.T) {
+	var body strings.Builder
+	rows := x86OfficialImmediateShuffleRows(t)
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		rows = append(rows, op+" $255,X0,X1")
+	}
+	for _, row := range rows {
+		destination := strings.Split(row, ",")
+		vector := destination[len(destination)-1]
+		index := vector[1:]
+		fmt.Fprintf(&body, "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z%s\nKMOVQ AX,K1\n%s\nVMOVSS X%s,(DX)\n", index, row, index)
+	}
+	// Broadcast, full tuple, merge and zeroing use actual caller input regions.
+	for _, row := range []string{"VPSHUFD.BCST.Z $255,(DI),K1,Z1", "VPSHUFHW.Z $0,(DI),K1,Z1", "VPSHUFLW $27,(DI),K1,Y1"} {
+		fmt.Fprintf(&body, "VMOVUPS (SI),Z1\nKMOVQ AX,K1\n%s\nVMOVSS X1,(DX)\n", row)
+	}
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body.String(), 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "immediate-shuffle-text.ll", "immediate-shuffle-text.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "immediate-shuffle-module.ll", "immediate-shuffle-module.o", module.String())
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal("actual selected caller failed", err)
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShufflePartialSourceActualCaller(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		accepted   bool
+	}{
+		{"only selected dword", "MOVSS (DI),X0\nVPSHUFD $0,X0,Y1", false},
+		{"selected low dword", "MOVSS (DI),X2\nMOVSS X2,X0\nVPSHUFD $0,X0,X1", true},
+		{"selected unknown dword", "MOVSS (DI),X2\nMOVSS X2,X0\nVPSHUFD $255,X0,X1", false},
+		{"unused upper words", "MOVSS (DI),X2\nMOVSS X2,X0\nVPSHUFLW $0,X0,X1", true},
+		{"whole unknown vector", "VPSHUFD $0,X0,X1", false},
+		{"unknown mask", "VMOVUPS (DI),Z0\nVPSHUFD.Z $0,X0,K1,X1", false},
+		{"merge unknown destination", "VMOVUPS (DI),Z0\nKMOVQ AX,K1\nVPSHUFD $0,X0,K1,X1", false},
+		{"zeroing no old destination", "VMOVUPS (DI),Z0\nKMOVQ AX,K1\nVPSHUFD.Z $0,X0,K1,X1", true},
+		{"legacy alignment unbound", "PSHUFL $0,(DI),X1", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			// The width-mismatch case is a syntax negative, not caller Context.
+			if test.name == "only selected dword" {
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+test.body+"\nRET\n", "", false)
+				if _, known, err := x86ImmediateShuffleProperties(x86YMMReadSource(t, "VPSHUFD $0,X0,Y1"), "amd64"); !known || err == nil {
+					t.Fatal("width mismatch acquired shuffle grammar")
+				}
+				return
+			}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", test.body+"\nVMOVSS X1,(DX)", 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("partial caller accepted=%v got %v", test.accepted, err)
+			}
+		})
+	}
+
+	ins := x86YMMReadSource(t, "vpshufd $27,X0,X1")
+	var output strings.Builder
+	ctx := &amd64Ctx{goarch: "amd64", b: &output}
+	if known, _, err := ctx.lowerPackedWordShuffle("VPSHUFHW", ins); !known || err == nil || output.Len() != 0 {
+		t.Fatal("contradictory dispatch consumed source or emitted IR")
+	}
+}
diff --git a/amd64_immediate_shuffle_family_test.go b/amd64_immediate_shuffle_family_test.go
new file mode 100644
index 000000000..0e71bb8e4
--- /dev/null
+++ b/amd64_immediate_shuffle_family_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Read every original encoding row and its opcode-specific attributes. Sharing
+// _yvpshufd does not give the word shuffles dword broadcast permissions.
+func x86OfficialImmediateShuffleRows(t *testing.T) []string {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rows []string
+	counts := map[string]int{}
+	for _, rule := range rules {
+		pp := map[string]string{"VPSHUFD": "66", "VPSHUFHW": "F3", "VPSHUFLW": "F2"}[rule.Opcode]
+		if pp == "" {
+			continue
+		}
+		index := rule.RowIndex
+		classes := [][]string{
+			{"Yu8", "Yxm", "Yxr"}, {"Yi8", "Yxm", "Yxr"},
+			{"Yu8", "Yym", "Yyr"}, {"Yi8", "Yym", "Yyr"},
+			{"Yu8", "YxmEvex", "YxrEvex"}, {"Yu8", "YxmEvex", "Yknot0", "YxrEvex"},
+			{"Yu8", "YymEvex", "YyrEvex"}, {"Yu8", "YymEvex", "Yknot0", "YyrEvex"},
+			{"Yu8", "Yzm", "Yzr"}, {"Yu8", "Yzm", "Yknot0", "Yzr"},
+		}
+		zcase := "Zvex_i_rm_r"
+		if index >= 4 {
+			zcase = "Zevex_i_rm_r"
+			if index%2 == 1 {
+				zcase = "Zevex_i_rm_k_r"
+			}
+		}
+		offsets := []int{0, 0, 2, 2, 4, 4, 7, 7, 10, 10}
+		advances := []int{0, 2, 0, 2, 0, 3, 0, 3, 0, 3}
+		if index < 0 || index >= len(classes) || rule.Ytab != "_yvpshufd" || rule.Prefix != "Pavx" ||
+			!reflect.DeepEqual(rule.Classes, classes[index]) || rule.ZCase != zcase ||
+			rule.EncodingOffset != offsets[index] || rule.ZOffset != advances[index] || len(rule.OpBytes) != 13 {
+			t.Fatalf("unmodeled original shuffle row: %+v", rule)
+		}
+		generation, bits := "vex", "128"
+		if index == 2 || index == 3 || index == 6 || index == 7 {
+			bits = "256"
+		} else if index >= 8 {
+			bits = "512"
+		}
+		if index >= 4 {
+			generation = "evex"
+		}
+		terms := []string{"avxEscape", generation + bits, generation + pp, generation + "0F", generation + "W0"}
+		if !reflect.DeepEqual(strings.Split(rule.OpBytes[rule.EncodingOffset], " | "), terms) {
+			t.Fatalf("unmodeled original shuffle prefix: %+v", rule)
+		}
+		opcodeOffset := rule.EncodingOffset + 1
+		if generation == "evex" {
+			attributes := "evexN" + map[string]string{"128": "16", "256": "32", "512": "64"}[bits]
+			if rule.Opcode == "VPSHUFD" {
+				attributes += " | evexBcstN4"
+			}
+			attributes += " | evexZeroingEnabled"
+			if rule.OpBytes[opcodeOffset] != attributes {
+				t.Fatalf("unmodeled original shuffle attributes: %+v", rule)
+			}
+			opcodeOffset++
+		}
+		if rule.OpBytes[opcodeOffset] != "0x70" {
+			t.Fatalf("unmodeled original shuffle opcode: %+v", rule)
+		}
+		bank := map[string]string{"128": "X", "256": "Y", "512": "Z"}[bits]
+		immediate := "255"
+		if rule.Classes[0] == "Yi8" {
+			immediate = "-128"
+		}
+		args := "$" + immediate + "," + bank + "0,"
+		if len(rule.Classes) == 4 {
+			args += "K1,"
+		}
+		// High banks force the unmasked X/Y EVEX row instead of VEX selection.
+		destination := "1"
+		if generation == "evex" && bits != "512" {
+			destination = "17"
+		}
+		rows = append(rows, rule.Opcode+" "+args+bank+destination)
+		counts[rule.Opcode]++
+	}
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		if counts[op] != 10 {
+			t.Fatalf("%s complete original-row denominator changed: %d", op, counts[op])
+		}
+	}
+	if len(rows) != 30 {
+		t.Fatalf("complete original shuffle denominator changed: %d", len(rows))
+	}
+	return rows
+}
+
+func TestX86ImmediateShuffleOfficialCallerRegistration(t *testing.T) {
+	rows := x86OfficialImmediateShuffleRows(t)
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		rows = append(rows, op+" $255,X0,X1")
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !x86CallerVectorMoveKnown(file.Funcs[0].Instrs[1]) {
+				t.Fatal("Go-accepted original shuffle row has no caller effect")
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShuffleMemoryShapeIsPhysicalTuple(t *testing.T) {
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for bank, width := range map[string]int{"X": 16, "Y": 32, "Z": 64} {
+			for _, suffix := range []string{"", ".Z"} {
+				row := fmt.Sprintf("%s%s $0,(AX),K1,%s1", op, suffix, bank)
+				t.Run(row, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					bytes, write, valid := x86InstructionMemoryShape(file.Funcs[0].Instrs[1], 1, "amd64")
+					if !valid || write || bytes != int64(width) {
+						t.Fatalf("physical tuple read got %d/%v/%v, want %d/false/true", bytes, write, valid, width)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86ImmediateShuffleCompleteBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		widths := []int{16}
+		if strings.HasPrefix(op, "V") {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			for _, mode := range []int{0, 1, 2} {
+				if !strings.HasPrefix(op, "V") && mode != 0 {
+					continue
+				}
+				broadcasts := []bool{false}
+				if op == "VPSHUFD" {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("immshuffle%d", count)
+					count++
+					bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+					row := op
+					if broadcast {
+						row += ".BCST"
+					}
+					if mode == 2 {
+						row += ".Z"
+					}
+					input := bank + "0"
+					if broadcast {
+						input = "(BX)"
+					}
+					row += " $27," + input + ","
+					if mode != 0 {
+						row += "K1,"
+					}
+					row += bank + "1"
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ mask+16(FP),DX\n", name)
+					fmt.Fprintf(&source, "VMOVUPS (BX),Z0\nVMOVUPS (AX),Z1\nKMOVQ DX,K1\nCMPQ AX,AX\nSTC\n%s\nVMOVUPS Z1,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", row)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: I64, Index: 2, Field: -1},
+					}}}
+					kind := 0
+					if strings.Contains(op, "HW") {
+						kind = 2
+					} else if strings.Contains(op, "LW") {
+						kind = 1
+					}
+					fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+					fmt.Fprintf(&checks, "if(check(%s,\"%s\",%d,%d,%d,%d,%d)) return 1;\n", name, name, width, kind, mode,
+						x86FloatAddSubBoolInt(strings.HasPrefix(op, "V")), x86FloatAddSubBoolInt(broadcast))
+				}
+			}
+		}
+	}
+	if count != 40 {
+		t.Fatalf("independent complete runtime denominator changed: %d", count)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int check(void (*program)(uint8_t*,const uint8_t*,uint64_t),const char *name,
+                 unsigned width,int kind,int mode,int vector,int broadcast) {
+    const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x55aa55aa55aa55aa)};
+    for(unsigned m=0;m<4;m++) {
+        uint8_t input[66],original[66],output[68],before[68];
+        for(unsigned i=0;i<66;i++) input[i]=(uint8_t)(i*29+197);
+        for(unsigned i=0;i<68;i++) output[i]=(uint8_t)(i*13+71);
+        memcpy(original,input,sizeof(input)); memcpy(before,output,sizeof(output));
+        program(output+1,input+1,masks[m]);
+        if(output[0]!=before[0] || output[67]!=before[67] ||
+           output[65]!=1 || output[66]!=0 || memcmp(input,original,sizeof(input))) return 1;
+        unsigned lane=kind ? 2 : 4;
+        for(unsigned i=0;i<64;i++) {
+            uint8_t want=before[1+i];
+            if(i>=width) { if(vector) want=0; }
+            else if(mode && !(masks[m]>>(i/lane)&1)) { if(mode==2) want=0; }
+            else {
+                unsigned at=i;
+                if(broadcast) at=i%4;
+                else if(kind==0) at=(i/16)*16+((27>>(2*((i%16)/4)))&3)*4+i%4;
+                else {
+                    unsigned word=(i%16)/2;
+                    if((kind==1 && word<4) || (kind==2 && word>=4))
+                        at=(i/16)*16+(kind==2 ? 8 : 0)+((27>>(2*(word%4)))&3)*2+i%2;
+                }
+                want=input[1+at];
+            }
+            if(output[1+i]!=want) {
+                fprintf(stderr,"%s mask=%llx byte=%u got=%x want=%x\n",name,(unsigned long long)masks[m],i,output[1+i],want);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "immediate-shuffle-complete-bytes", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_immediate_shuffle_fault_test.go b/amd64_immediate_shuffle_fault_test.go
new file mode 100644
index 000000000..569cbed92
--- /dev/null
+++ b/amd64_immediate_shuffle_fault_test.go
@@ -0,0 +1,260 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ImmediateShuffleLegacyNativeMemory(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, references, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		// The C oracle executes bytes independently observed from original Go,
+		// with fixed RSI/RDI inputs. It does not reuse the production grammar.
+		original := "TEXT f(SB),4,$0-0\n" + op + " $27,(SI),X1\nRET\n"
+		listing := x86InsertExtractGoListing(t, "amd64", original)
+		var code []byte
+		for _, line := range strings.Split(string(listing), "\n") {
+			code = append(code, x86InsertExtractListedBytes(line)...)
+		}
+		prefixByte := byte(0x66)
+		if op == "PSHUFHW" {
+			prefixByte = 0xf3
+		} else if op == "PSHUFLW" {
+			prefixByte = 0xf2
+		}
+		if !bytes.Equal(code, []byte{prefixByte, 0x0f, 0x70, 0x0e, 27, 0xc3}) {
+			t.Fatalf("independent original Go m128 opcode changed: %s %x", op, code)
+		}
+		var literals []string
+		for _, value := range code[:5] {
+			literals = append(literals, fmt.Sprintf("0x%02x", value))
+		}
+		kind := 0
+		if op == "PSHUFHW" {
+			kind = 2
+		} else if op == "PSHUFLW" {
+			kind = 1
+		}
+		for _, dead := range []bool{false, true} {
+			name := fmt.Sprintf("legacymemory%d_%t", index, dead)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ input+8(FP),BX\nCMPQ BX,BX\nSTC\n%s $27,(BX),X1\n", name, op)
+			tail := ""
+			if !dead {
+				source.WriteString("MOVOU X1,(AX)\nSETCS 16(AX)\nSETNE 17(AX)\n")
+				tail = "; movdqu %%xmm1,(%%rdi); setc 16(%%rdi); setnz 17(%%rdi)"
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*);\n", name)
+			fmt.Fprintf(&references, `static void original_%s(uint8_t *out,const uint8_t *input) {
+    __asm__ volatile("cmpq %%%%rsi,%%%%rsi; stc; .byte %s%s" ::
+        "D"(out), "S"(input) : "xmm1", "cc", "memory");
+}
+`, name, strings.Join(literals, ","), tail)
+			fmt.Fprintf(&checks, `
+    if(compare(original_%[1]s,%[1]s,region,0,%[2]d,%[3]d) ||
+       compare(original_%[1]s,%[1]s,boundary-16,0,%[2]d,%[3]d) ||
+       compare(original_%[1]s,%[1]s,region+1,-1,%[2]d,%[3]d) ||
+       compare(original_%[1]s,%[1]s,boundary-15,1,%[2]d,%[3]d) ||
+       compare(original_%[1]s,%[1]s,0,1,%[2]d,%[3]d)) return 1;
+`, name, kind, x86FloatAddSubBoolInt(dead))
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + references.String() + `
+typedef void (*memoryfn)(uint8_t*,const uint8_t*);
+static int observe(memoryfn fn,const uint8_t *input,int kind,int dead) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit limit={0,0};
+        if(setrlimit(RLIMIT_CORE,&limit)) _exit(2);
+        uint8_t result[20], before[16];
+        memset(result,0xc3,sizeof(result));
+        // Copy only for a successful readable input; boundary and NULL probes
+        // must fault in the tested opcode, not in the independent reference.
+        if(input && !((uintptr_t)input & 15)) memcpy(before,input,16);
+        fn(result+1,input);
+        if(result[0]!=0xc3 || result[19]!=0xc3) _exit(3);
+        if(dead) {
+            for(unsigned i=1;i<19;i++) if(result[i]!=0xc3) _exit(4);
+        } else {
+            if(result[17]!=1 || result[18]!=0) _exit(5);
+            for(unsigned i=0;i<16;i++) {
+                unsigned at=i;
+                if(kind==0) at=((27>>(2*(i/4)))&3)*4+i%4;
+                else {
+                    unsigned word=i/2;
+                    if((kind==1 && word<4) || (kind==2 && word>=4))
+                        at=(kind==2 ? 8 : 0)+((27>>(2*(word%4)))&3)*2+i%2;
+                }
+                if(result[i+1]!=input[at]) _exit(6);
+            }
+            if(!((uintptr_t)input & 15) && memcmp(before,input,16)) _exit(7);
+        }
+        _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status)) return WEXITSTATUS(status);
+    if(WIFSIGNALED(status)) return 128+WTERMSIG(status);
+    return -1;
+}
+static int compare(memoryfn reference,memoryfn translated,const uint8_t *input,
+                   int fault,int kind,int dead) {
+    int native=observe(reference,input,kind,dead);
+    int got=observe(translated,input,kind,dead);
+    int memoryFault=native==128+SIGSEGV || native==128+SIGBUS;
+    int valid=fault==1 ? memoryFault : fault==-1 ? native==0 || memoryFault : native==0;
+    if(native<0 || native!=got || !valid) {
+        fprintf(stderr,"legacy shuffle input=%p native=%d LLVM=%d requiredFault=%d\n",input,native,got,fault);
+        return 1;
+    }
+    return 0;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<64) return 1;
+    uint8_t *region=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,(size_t)page,PROT_NONE)) return 1;
+    for(long i=0;i<page;i++) region[i]=(uint8_t)(i*29+197);
+    uint8_t *boundary=region+page;
+` + checks.String() + `
+    return munmap(region,(size_t)page*2)!=0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy-shuffle-native-memory", triple, text, oracle, prefix)
+		})
+	}
+	t.Log("8 live/dead legacy m128 programs, exact original Go/native bytes and LLVM controls; Rosetta alignment is diagnostic, not native AMD64 certification")
+}
+
+func TestCrossLinuxRuntimeMatrixX86ImmediateShuffleFullNativeReads(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, width := range []int{16, 32, 64} {
+			for _, masked := range []bool{false, true} {
+				broadcasts := []bool{false}
+				if op == "VPSHUFD" {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("shufflefault%d", count)
+					count++
+					row := op
+					bytes := width
+					if broadcast {
+						row += ".BCST"
+						bytes = 4
+					}
+					if masked {
+						row += ".Z"
+					}
+					row += " $0,(BX),"
+					if masked {
+						row += "K1,"
+					}
+					row += map[int]string{16: "X", 32: "Y", 64: "Z"}[width] + "1"
+					// The output is deliberately dead, so O2 cannot use it to keep
+					// a plain load live. Zero K still requires the full E4NF tuple.
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\nMOVL $0,CX\nKMOVQ CX,K1\n%s\nRET\n", name, row)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+					fmt.Fprintf(&declarations, "extern void %s(const uint8_t*);\n", name)
+					fmt.Fprintf(&checks, "if(check(%s,0,1) || check(%s,boundary-%d+1,1) || check(%s,boundary-%d,0)) return 1;\n", name, name, bytes, name, bytes)
+				}
+			}
+		}
+	}
+	if count != 24 {
+		t.Fatalf("full tuple/broadcast/mask denominator changed: %d", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + `
+static int check(void (*program)(const uint8_t*),const uint8_t *input,int fault) {
+    pid_t child=fork();
+    if(child<0) return 1;
+    if(child==0) {
+        struct rlimit limit={0,0};
+        if(setrlimit(RLIMIT_CORE,&limit)) _exit(2);
+        program(input);
+        _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return 1;
+    int got=WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS);
+    if(fault ? !got : !WIFEXITED(status) || WEXITSTATUS(status)!=0) {
+        fprintf(stderr,"shuffle physical-read input=%p fault=%d status=%x\n",input,fault,status);
+        return 1;
+    }
+    return 0;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<=0) return 1;
+    uint8_t *memory=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(memory==MAP_FAILED || mprotect(memory+page,(size_t)page,PROT_NONE)) return 1;
+    uint8_t *boundary=memory+page;
+` + checks.String() + `
+    return munmap(memory,(size_t)page*2)!=0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "immediate-shuffle-native-reads", triple, text, oracle, prefix)
+		})
+	}
+}
diff --git a/amd64_immediate_shuffle_forms.go b/amd64_immediate_shuffle_forms.go
new file mode 100644
index 000000000..ad80a8873
--- /dev/null
+++ b/amd64_immediate_shuffle_forms.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ImmediateShuffleSpec struct {
+	laneBytes         int
+	high, legacy, mmx bool
+}
+
+// Go's ymshuf/yxshuf and complete _yvpshufd rows share the four-element
+// selector grammar. Only the dword EVEX spelling permits m32 broadcast.
+var x86ImmediateShuffleSpecs = map[Op]x86ImmediateShuffleSpec{
+	"PSHUFW":   {2, false, true, true},
+	"PSHUFL":   {4, false, true, false},
+	"PSHUFD":   {4, false, true, false},
+	"PSHUFHW":  {2, true, true, false},
+	"PSHUFLW":  {2, false, true, false},
+	"VPSHUFD":  {4, false, false, false},
+	"VPSHUFHW": {2, true, false, false},
+	"VPSHUFLW": {2, false, false, false},
+}
+
+type x86ImmediateShuffleForm struct {
+	spec                      x86ImmediateShuffleSpec
+	source                    Operand
+	destination, mask, memory int
+	byteWidth, memoryBytes    int
+	immediate                 uint8
+	broadcast, zeroing        bool
+}
+
+// Immediate shuffles read one complete source, including the word half left
+// in place. Unlike PSHUFB, the old destination is never an input unless it
+// aliases that source. Memory extent/alignment remain separate obligations.
+func x86TypedImmediateShuffleByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86ImmediateShuffleProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("immediate-shuffle dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	if !known || err != nil || !form.spec.legacy || form.spec.mmx {
+		return x86TypedByteEffect{}, known && (err != nil || form.spec.legacy && !form.spec.mmx), err
+	}
+	return x86ImmediateShuffleDependencyEffect(ins, form), true, nil
+}
+
+// The admitted encoding chooses upper writes and memory alignment; both use
+// one source-only dependency shape. This descriptor does not admit a form.
+func x86ImmediateShuffleDependencyEffect(ins Instr, form x86ImmediateShuffleForm) x86TypedByteEffect {
+	vector := x86TypedVectorEffect{x86TypedVectorUpperPreserve, 16}
+	if !form.spec.legacy {
+		vector = x86TypedVectorEffect{x86TypedVectorUpperZero, 1}
+	}
+	return x86TypedByteEffect{
+		vector: vector,
+		operands: []x86TypedByteOperand{
+			{index: 1, operand: form.source, width: int64(form.byteWidth), read: true},
+			{index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth), write: true},
+		},
+	}
+}
+
+// This supplies encoding, native access extent and byte selectors, not source
+// values, original pointer/alignment backing or permission to borrow an ABI.
+func x86ImmediateShuffleProperties(ins Instr, arch string) (x86ImmediateShuffleForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86ImmediateShuffleSpecs[Op(base)]
+	if !known {
+		return x86ImmediateShuffleForm{}, false, nil
+	}
+	f := x86ImmediateShuffleForm{spec: spec, destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86ImmediateShuffleForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go immediate-shuffle grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return fail()
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer {
+		return fail()
+	}
+	if spec.legacy {
+		if dotted || len(ins.Args) != 3 || spec.mmx && !amd64SignedImmediate(immediate, 8) ||
+			!spec.mmx && !amd64UnsignedImmediate(immediate, 8) {
+			return fail()
+		}
+		f.byteWidth = 16
+		if spec.mmx {
+			f.byteWidth = 8
+		}
+	} else {
+		switch suffix {
+		case "":
+			if dotted {
+				return fail()
+			}
+		case "Z":
+			f.zeroing = true
+		case "BCST":
+			f.broadcast = true
+		case "BCST.Z":
+			f.broadcast, f.zeroing = true, true
+		default:
+			return fail()
+		}
+		if immediate.Imm < -128 || immediate.Imm > 255 || f.broadcast && spec.laneBytes != 4 {
+			return fail()
+		}
+		if len(ins.Args) == 4 {
+			if arch == "386" && !ins.x86Encoded || !amd64NonzeroKOperand(ins.Args[2]) {
+				return fail()
+			}
+			f.mask = 2
+		} else if f.zeroing {
+			return fail()
+		}
+		f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	}
+	register := func(operand Operand) bool {
+		if operand.Kind != OpReg {
+			return false
+		}
+		if spec.mmx {
+			_, valid := amd64ParseMReg(operand.Reg)
+			return valid
+		}
+		if spec.legacy {
+			index, valid := amd64ParseXReg(operand.Reg)
+			return valid && (arch == "amd64" && index < 16 || arch == "386" && index < 8)
+		}
+		return amd64GoPackedVectorMoveRegister(operand, f.byteWidth, arch)
+	}
+	if !register(ins.Args[f.destination]) {
+		return fail()
+	}
+	local, err := x86LegacyMMXReadInstruction(ins, arch)
+	if err != nil {
+		return f, true, err
+	}
+	f.source = local.Args[1]
+	if isAMD64MemoryOperand(f.source) && x86PackedShiftMemoryValid(f.source, arch) {
+		f.memory, f.memoryBytes = 1, f.byteWidth
+		if f.broadcast {
+			f.memoryBytes = 4
+		}
+	} else if f.broadcast || !register(f.source) {
+		return fail()
+	}
+	if !spec.legacy && immediate.Imm < 0 &&
+		(f.broadcast || amd64PackedWordShuffleRequiresEVEX(f.source, ins.Args[f.destination], f.byteWidth, f.mask >= 0)) {
+		return fail()
+	}
+	f.immediate = uint8(immediate.Imm)
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func x86ImmediateShuffleConstant(operand Operand, arch string, encoded bool) (Operand, bool) {
+	if operand.Kind != OpImm || operand.ImmIsFloat || operand.ImmRaw != "" {
+		return operand, false
+	}
+	// Go's I386 oclass classifies TYPE_CONST after signed int32 truncation;
+	// retain the original operand, but use its classified value for every row.
+	if arch == "386" && !encoded {
+		operand.Imm = int64(int32(operand.Imm))
+	}
+	return operand, true
+}
+
+// Every output byte depends on exactly one source byte; the word half not
+// shuffled still comes from the source, never the old destination.
+func (f x86ImmediateShuffleForm) sourceByte(destination int) int {
+	if f.broadcast {
+		return destination % 4
+	}
+	groupBytes := 16
+	if f.spec.mmx {
+		groupBytes = 8
+	}
+	lane := destination % groupBytes / f.spec.laneBytes
+	if f.spec.laneBytes == 2 && !f.spec.mmx && (lane < 4) == f.spec.high {
+		return destination
+	}
+	half := 0
+	if f.spec.high {
+		half = 8
+	}
+	return destination/groupBytes*groupBytes + half +
+		int(f.immediate>>(2*(lane%4))&3)*f.spec.laneBytes + destination%f.spec.laneBytes
+}
diff --git a/amd64_immediate_shuffle_grammar_test.go b/amd64_immediate_shuffle_grammar_test.go
new file mode 100644
index 000000000..6a9203142
--- /dev/null
+++ b/amd64_immediate_shuffle_grammar_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ImmediateShuffleCompleteImmediateDomains(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT probe(SB),4,$0-0\n")
+			count := 0
+			for _, op := range []string{"PSHUFW", "PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+				for value := 0; value < 256; value++ {
+					immediate, bank := value, "X"
+					if op == "PSHUFW" {
+						immediate, bank = value-128, "M"
+					}
+					row := fmt.Sprintf("%s $%d,%s0,%s1", op, immediate, bank, bank)
+					fmt.Fprintln(&source, row)
+					ins := x86YMMReadSource(t, row)
+					before := fmt.Sprintf("%#v", ins)
+					if _, known, err := x86ImmediateShuffleProperties(ins, arch); !known || err != nil {
+						t.Fatalf("complete imm8 domain missing %s: %v", row, err)
+					}
+					if before != fmt.Sprintf("%#v", ins) {
+						t.Fatal("pure grammar changed original source")
+					}
+					count++
+				}
+			}
+			source.WriteString("RET\n")
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			if count != 2048 {
+				t.Fatal("complete independent immediate denominator changed", count)
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShuffleRejectsSiblingInvalidFormats(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		for _, args := range []string{"$-1,X0,X1", "$256,X0,X1", "$0,X16,X1", "$0,X0,Y1", "$0,AX,X1", "$0,X0,(AX)", "$0,X0,K1,X1"} {
+			rows = append(rows, op+" "+args)
+		}
+		rows = append(rows, op+".Z $0,X0,X1")
+	}
+	for _, args := range []string{"$128,M0,M1", "$-129,M0,M1", "$0,X0,M1", "$0,M0,X1", "$0,M8,M1", "$0,M0,(AX)"} {
+		rows = append(rows, "PSHUFW "+args)
+	}
+	rows = append(rows, "PSHUFW.Z $0,M0,M1")
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, args := range []string{"$-129,X0,X1", "$256,X0,X1", "$-1,Z0,Z1", "$-1,X16,X1", "$-1,X0,K1,X1", "$0,X0,Y1", "$0,AX,X1", "$0,X0,(AX)", "$0,X0,K0,X1", "$0,X0,K8,X1", "$0,X0,X32"} {
+			rows = append(rows, op+" "+args)
+		}
+		rows = append(rows, op+".Z $0,X0,X1", op+".BCST $0,X0,X1", op+".SAE $0,(AX),X1")
+		if op != "VPSHUFD" {
+			rows = append(rows, op+".BCST $0,(AX),X1")
+		}
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			for _, arch := range []string{"amd64", "386"} {
+				source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+				masklessZero := row == "VPSHUFD.Z $0,X0,X1" || row == "VPSHUFHW.Z $0,X0,X1" || row == "VPSHUFLW.Z $0,X0,X1"
+				historicalReserved := masklessZero && !goToolchainAtLeast(runtime.Version(), 1, 21)
+				goAssemblerOracleOutput(t, arch, source, "", historicalReserved)
+				if masklessZero {
+					// Before Go 1.21 the encoder emitted reserved EVEX.z/aaa=0.
+					// Observe its exact original bytes; neither named nor raw
+					// translation may acquire semantics from that old acceptance.
+					pp := byte(1)
+					if strings.HasPrefix(row, "VPSHUFHW") {
+						pp = 2
+					} else if strings.HasPrefix(row, "VPSHUFLW") {
+						pp = 3
+					}
+					code := []byte{0x62, 0xf1, 0x7c | pp, 0x88, 0x70, 0xc8, 0}
+					if historicalReserved {
+						listing := x86InsertExtractGoListing(t, arch, source)
+						var observed []byte
+						for _, line := range strings.Split(string(listing), "\n") {
+							observed = append(observed, x86InsertExtractListedBytes(line)...)
+						}
+						if !bytes.Equal(observed, append(append([]byte(nil), code...), 0xc3)) {
+							t.Fatalf("historical reserved shuffle bytes changed: %x", observed)
+						}
+						t.Logf("%s/%s historical reserved z=1/aaa=0 observation; not a legal form", runtime.Version(), arch)
+					}
+					mode := 64
+					if arch == "386" {
+						mode = 32
+					}
+					if _, _, known, err := decodedX86PackedShuffleInstruction(code, mode); !known || err == nil {
+						t.Fatal("reserved raw zeroing acquired shuffle semantics", err)
+					}
+					x86RequireZeroMaskAPIOutcome(t, arch, source, false)
+					x86RequireZeroMaskAPIOutcome(t, arch, x86RawINSERTPSSource("f", code), false)
+				}
+				ins := x86YMMReadSource(t, row)
+				if _, known, err := x86ImmediateShuffleProperties(ins, arch); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go-rejected syntax became a valid/context form", row, arch, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShuffleMode32PhysicalAndMMXBoundaries(t *testing.T) {
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		for _, row := range []string{op + " $0,X16,X31", op + " $0,Y16,Y31"} {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			if _, known, err := x86ImmediateShuffleProperties(x86YMMReadSource(t, row), "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("source-only high bank acquired physical binding", row, err)
+			}
+		}
+		for _, row := range []string{op + " $0,Z8,Z0", op + " $0,X0,K1,X1"} {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			if _, known, err := x86ImmediateShuffleProperties(x86YMMReadSource(t, row), "386"); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Go-rejected mode32 form acquired physical binding", row, err)
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		ins := x86YMMReadSource(t, "PSHUFW $27,AX,M1")
+		goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n", "", true)
+		form, known, err := x86ImmediateShuffleProperties(ins, arch)
+		if !known || err != nil || form.source.Reg != "M0" || !form.spec.mmx {
+			t.Fatal("original Go Ymm spelling lost its actual MMX bank", arch, form, err)
+		}
+		if !errors.Is(x86LegacyMMXReadEmitterContext(ins, arch), ErrProbeNeedsContext) || x86CallerVectorMoveKnown(ins) {
+			t.Fatal("GP source spelling became initialized MMX data or caller permission")
+		}
+	}
+}
+
+func TestX86ImmediateShuffleNativeFeatureScope(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{"PSHUFL $0,(AX),X1", "PSHUFD $0,(AX),X1", "PSHUFHW $0,(AX),X1", "PSHUFLW $0,(AX),X1"} {
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{x86YMMReadSource(t, row)}}); got != "+sse2" {
+				t.Fatal("validated native legacy m128 needs its private SSE2 carrier", arch, row, got)
+			}
+		}
+		for _, row := range []string{"PSHUFL $-1,(AX),X1", "PSHUFL $0,X0,X1", "VPSHUFD $0,(AX),X1", "PSHUFW $0,(AX),M1"} {
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{x86YMMReadSource(t, row)}}); got != "" {
+				t.Fatal("non-native/malformed form acquired features", arch, row, got)
+			}
+		}
+	}
+}
+
+func TestX86ImmediateShuffleNativeMemoryCannotBorrowVirtualBacking(t *testing.T) {
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		for _, operand := range []string{"a+0(FP)", "(SP)", "(BP)", "(AX)(BP*2)"} {
+			row := op + " $0," + operand + ",X1"
+			t.Run(row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-16\n"+row+"\nRET\n", "", true)
+				ins := x86YMMReadSource(t, row)
+				var output strings.Builder
+				ctx := &amd64Ctx{goarch: "amd64", b: &output}
+				if known, _, err := ctx.lowerPackedWordShuffle(ins.Op, ins); !known || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+					t.Fatal("virtual/native frame acquired backing before IR", row, err, output.String())
+				}
+			})
+		}
+		for _, bits := range []int{32, 64} {
+			ins := x86YMMReadSource(t, op+" $0,(AX),X1")
+			ins.x86AddressBits = bits
+			var output strings.Builder
+			ctx := &amd64Ctx{goarch: "amd64", b: &output}
+			if known, _, err := ctx.lowerPackedWordShuffle(ins.Op, ins); !known || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+				t.Fatal("unbound address-size identity acquired native backing", bits, err)
+			}
+		}
+	}
+}
diff --git a/amd64_immediate_shuffle_objects_test.go b/amd64_immediate_shuffle_objects_test.go
new file mode 100644
index 000000000..d9468e415
--- /dev/null
+++ b/amd64_immediate_shuffle_objects_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ImmediateShuffleOfficialRowsThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86OfficialImmediateShuffleRows(t)
+			var selected []string
+			for _, row := range rows {
+				if target.arch == "386" {
+					if strings.Count(row, ",") == 3 {
+						// This is an actual frontend refusal, not a skipped test.
+						goAssemblerOracleOutput(t, target.arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+						continue
+					}
+					row = strings.NewReplacer("X17", "X1", "Y17", "Y1").Replace(row)
+				}
+				selected = append(selected, row)
+				args := strings.Split(strings.Fields(row)[1], ",")
+				args[1] = "8(AX)"
+				selected = append(selected, strings.Fields(row)[0]+" "+strings.Join(args, ","))
+			}
+			for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+				selected = append(selected, op+" $255,X0,X1", op+" $0,16(AX),X1")
+			}
+			selected = append(selected, "PSHUFW $-128,M0,M1", "PSHUFW $127,8(AX),M1")
+			if target.arch == "386" {
+				for _, op := range []string{"PSHUFW", "PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+					bank, values := "X", []int{0, 27, 255}
+					if op == "PSHUFW" {
+						bank, values = "M", []int{0, -1, 127}
+					} else if strings.HasPrefix(op, "V") {
+						values = []int{0, -1, 255}
+					}
+					for _, value := range values {
+						selected = append(selected, fmt.Sprintf("%s $%d,%s0,%s1", op, int64(4294967296)+int64(value), bank, bank))
+					}
+				}
+			}
+			for _, bank := range []string{"X", "Y", "Z"} {
+				selected = append(selected, "VPSHUFD.BCST $0,8(AX),"+bank+"1")
+				if target.arch == "amd64" {
+					selected = append(selected, "VPSHUFD.BCST.Z $255,8(AX),K1,"+bank+"1")
+				}
+			}
+			want := 76
+			if target.arch == "386" {
+				want = 79
+			}
+			if len(selected) != want {
+				t.Fatal("official row/operand variation denominator changed", len(selected), want)
+			}
+			var source strings.Builder
+			for index, row := range selected {
+				name := fmt.Sprintf("F%d", index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, row)
+			}
+			// Preserve every original uninitialized row, including the unclosed
+			// MMX sources. Syntax objects cannot supply numerical or x87 state.
+			file, sigs := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			before := fmt.Sprintf("%#v %#v", file, sigs)
+			ir := x86ScalarFormatObjectUnit(t, file, sigs, target.arch, target.triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+			if before != fmt.Sprintf("%#v %#v", file, sigs) {
+				t.Fatal("object verification mutated original input or signatures")
+			}
+			t.Logf("%d original Go forms, three public Context checks and emitter-only LLVM22 objects; initialized caller/MMX owners are separate", len(selected))
+		})
+	}
+}
diff --git a/amd64_immediate_shuffle_result.go b/amd64_immediate_shuffle_result.go
new file mode 100644
index 000000000..b48fde068
--- /dev/null
+++ b/amd64_immediate_shuffle_result.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+func x86ResultImmediateShuffleStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultImmediateShuffleStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultImmediateShuffleStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86ImmediateShuffleProperties(ins, arch)
+	if !known || err != nil || form.spec.mmx {
+		return false, known // Physical MMX does not alias the SIMD result bank.
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	var source uint64
+	if form.memory >= 0 {
+		// A selected byte or zero mask cannot shrink the native memory tuple.
+		// Legacy m128 also needs native alignment/backing; a logical FP/AUTO
+		// allocation is not that witness. The paired original legacy opcode
+		// retains alignment faults; continued execution asserts no alignment.
+		if _, static := x86StaticSBReadAddress(form.source, arch); form.spec.legacy && !static &&
+			(!nativeRead || !x86OrdinaryNativeMemoryOperand(form.source, arch)) {
+			return false, true
+		}
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+		source = x86CallerVectorByteMask(int64(form.memoryBytes))
+	} else {
+		index, _ := amd64VectorRegisterIndex(form.source.Reg, form.byteWidth)
+		source = state.vectorBytes(index)
+	}
+	var defined uint64
+	for output := 0; output < form.byteWidth; output++ {
+		defined |= (source >> uint(form.sourceByte(output)) & 1) << uint(output)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if form.mask >= 0 && !form.zeroing {
+		defined &= state.vectorBytes(destination)
+	}
+	state.writeVector(destination, form.byteWidth, defined, form.spec.legacy)
+	return true, true
+}
diff --git a/amd64_immediate_shuffle_result_test.go b/amd64_immediate_shuffle_result_test.go
new file mode 100644
index 000000000..58e100569
--- /dev/null
+++ b/amd64_immediate_shuffle_result_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ImmediateShuffleResultMemoryExtent(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		bytes       int
+	}{
+		{"VPSHUFD $0,value+0(FP),X1", 16},
+		{"VPSHUFHW.Z $0,value+0(FP),K1,Y1", 32},
+		{"VPSHUFLW.Z $0,value+0(FP),K1,Z1", 64},
+		{"VPSHUFD.BCST.Z $0,value+0(FP),K1,Z1", 4},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			ins := x86YMMReadSource(t, row.instruction)
+			for missing := -1; missing < 64; missing++ {
+				state := x86ResultState{fp: make([]bool, 64)}
+				owned := make([]bool, 64)
+				for index := range owned {
+					owned[index], state.fp[index] = true, index != missing
+				}
+				state.masks[1] = true
+				accepted := x86ResultTransfer(ins, &state, owned, 64, "amd64")
+				if want := missing < 0 || missing >= row.bytes; accepted != want {
+					t.Fatalf("full original tuple bytes=%d missing=%d accepted=%v", row.bytes, missing, accepted)
+				}
+			}
+		})
+	}
+	for _, row := range []string{
+		"PSHUFHW $0,value+0(FP),X1", "VPSHUFD $0,(AX),X1",
+		"VPSHUFD $0,unknown<>(SB),X1", "PSHUFW $0,M0,M1",
+	} {
+		state := x86ResultState{fp: make([]bool, 16)}
+		owned := make([]bool, 16)
+		for index := range owned {
+			owned[index], state.fp[index] = true, true
+		}
+		state.pointerGP[0] = true
+		if x86ResultTransfer(x86YMMReadSource(t, row), &state, owned, 16, "amd64") {
+			t.Fatal("logical storage, pointer or SIMD state acquired native backing/MMX authority", row)
+		}
+	}
+}
+
+func amd64ImmediateShuffleResultMatrix() (source, declarations, harness string) {
+	var asm, decl, prototypes, checks strings.Builder
+	index := 0
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		width, start := 4, 0
+		if strings.HasSuffix(op, "HW") || strings.HasSuffix(op, "LW") {
+			width = 2
+		}
+		if strings.HasSuffix(op, "HW") {
+			start = 8
+		}
+		for _, immediate := range []int{0, 27, 228, 255} {
+			for _, destination := range []string{"X0", "X1"} {
+				name := fmt.Sprint("shuffle", index)
+				fmt.Fprintf(&asm, "TEXT ·%s<ABIInternal>(SB),4,$0-24\nMOVQ AX,X0\nPINSRQ $1,BX,X0\n%s $%d,X0,%s\nPEXTRQ $1,%s,CX\nMOVQ %s,AX\nXORQ CX,AX\nRET\n",
+					name, op, immediate, destination, destination, destination)
+				fmt.Fprintf(&decl, "func %s(a,b uint64) uint64\n", name)
+				fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t,uint64_t);\n", name)
+				fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d)){fprintf(stderr,\"%s failed\\n\");return 1;}\n", name, width, start, immediate, name)
+				index++
+			}
+		}
+	}
+	const reference = `
+static int check(uint64_t (*fn)(uint64_t,uint64_t), unsigned width,
+                 unsigned start, unsigned imm) {
+  const uint64_t values[]={0,UINT64_MAX,UINT64_C(0x1020304050607080),UINT64_C(0xfedcba9876543210)};
+  for(unsigned a=0;a<4;a++) {
+    for(unsigned b=0;b<4;b++) {
+      uint8_t input[16],output[16];
+      uint64_t low,high;
+      memcpy(input,&values[a],8);
+      memcpy(input+8,&values[b],8);
+      memcpy(output,input,16);
+      for(unsigned lane=0;lane<4;lane++) {
+        unsigned selected=(imm>>(2*lane))&3;
+        memcpy(output+start+width*lane,input+start+width*selected,width);
+      }
+      memcpy(&low,output,8);
+      memcpy(&high,output+8,8);
+      if(fn(values[a],values[b])!=(low^high)) return 1;
+    }
+  }
+  return 0;
+}
+`
+	return asm.String(), decl.String(), "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		prototypes.String() + reference + "int main(void){\n" + checks.String() + "return 0; }\n"
+}
+
+func TestAMD64ImmediateShuffleRegisterResultsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	source, declarations, _ := amd64ImmediateShuffleResultMatrix()
+	requireAMD64RegisterResultGoObject(t, source)
+	for _, target := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", target, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target, ir, "shuffle-result")
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64ImmediateShuffleRegisterResults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	source, declarations, harness := amd64ImmediateShuffleResultMatrix()
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimize := range []bool{false, true} {
+				text := ir
+				if optimize {
+					text = x86MulDivRoundOptimize(t, text)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "shuffle-results", triple, text, harness, prefix)
+			}
+		})
+	}
+}
diff --git a/amd64_implicit_divide.go b/amd64_implicit_divide.go
new file mode 100644
index 000000000..fffeecd78
--- /dev/null
+++ b/amd64_implicit_divide.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ImplicitDivideSpec struct {
+	bits   int
+	signed bool
+}
+
+// Complete Go ydivb/Ymb and ydivl/Yml rows. Division has trapping semantics,
+// not multiply's ordinary numerical transfer or a generic LLVM div/rem rule.
+var x86ImplicitDivideSpecs = map[Op]x86ImplicitDivideSpec{
+	"DIVB": {8, false}, "DIVW": {16, false}, "DIVL": {32, false}, "DIVQ": {64, false},
+	"IDIVB": {8, true}, "IDIVW": {16, true}, "IDIVL": {32, true}, "IDIVQ": {64, true},
+}
+
+type x86ImplicitDivideForm struct {
+	spec   x86ImplicitDivideSpec
+	source Operand
+}
+
+func x86ImplicitDivideProperties(op Op, ins Instr, arch string) (x86ImplicitDivideForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ImplicitDivideSpecs[Op(name)]
+	form := x86ImplicitDivideForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86ImplicitDivideForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go implicit division source grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 || dotted || len(ins.Args) != 1 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) ||
+		!isX86ScalarMultiplyDivideSource(ins.Args[0], spec.bits, arch) {
+		return fail()
+	}
+	form.source = ins.Args[0]
+	if form.source.Kind == OpReg {
+		return form, true, nil
+	}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, form.source, arch); segment {
+		if err != nil {
+			return form, true, err
+		}
+		form.source = projected
+	}
+	if form.source.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(form.source.Mem, arch); err != nil {
+			return form, true, err
+		}
+	}
+	if !x86ScalarCompareMemoryValid(form.source, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func (c *amd64Ctx) lowerImplicitDivide(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86ImplicitDivideProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+		!x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return true, false, fmt.Errorf("%w: division needs its named x86 target and original address size", ErrProbeNeedsContext)
+	}
+	if form.source.Kind == OpReg {
+		if x86LogicalSourceFrameRegister(form.source.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%w: division cannot consume an unbound physical SP/BP source", ErrProbeNeedsContext)
+		}
+	} else if form.source.Kind != OpFP && !c.nativeMemoryOperand(ins, 0) {
+		return true, false, fmt.Errorf("%w: division needs owned logical FP bytes or original native memory backing", ErrProbeNeedsContext)
+	}
+	return true, false, c.emitNativeImplicitDivide(form)
+}
+
+// The original opcode owns zero-divisor and quotient-overflow #DE as well as
+// exact memory fault priority. Pure LLVM div/rem can become poison or truncate
+// an overflowing quotient; llvm.trap would raise the wrong native exception.
+// Early-clobber outputs keep the divisor/address distinct from the tied old
+// AX/DX inputs, including AL/AH aliases. No result is read before the call.
+func (c *amd64Ctx) emitNativeImplicitDivide(form x86ImplicitDivideForm) error {
+	width := amd64IntegerTypeForBits(form.spec.bits)
+	accumulatorType := width
+	if form.spec.bits == 8 {
+		accumulatorType = I16
+	}
+	accumulator, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, accumulatorType)
+	if err != nil {
+		return err
+	}
+	name := "div"
+	if form.spec.signed {
+		name = "idiv"
+	}
+	name += map[int]string{8: "b", 16: "w", 32: "l", 64: "q"}[form.spec.bits]
+	outputType, constraints, arguments := string(accumulatorType), "=&{ax},0", string(accumulatorType)+" "+accumulator
+	operandIndex := 2
+	if form.spec.bits != 8 {
+		high, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, width)
+		if err != nil {
+			return err
+		}
+		outputType = fmt.Sprintf("{ %s, %s }", width, width)
+		constraints, arguments = "=&{ax},=&{dx},0,1", fmt.Sprintf("%s %s, %s %s", width, accumulator, width, high)
+		operandIndex = 4
+	}
+	assembly, memoryClobber := "", ""
+	if form.source.Kind == OpReg || form.source.Kind == OpFP {
+		value, err := c.implicitDivideRegisterValue(form.source, width)
+		if err != nil {
+			return err
+		}
+		constraint := "r"
+		if form.spec.bits == 8 {
+			constraint = "q"
+		}
+		constraints += "," + constraint
+		arguments += fmt.Sprintf(", %s %s", width, value)
+		modifier := map[int]string{8: "b", 16: "w", 32: "k", 64: "q"}[form.spec.bits]
+		assembly = fmt.Sprintf("%s ${%d:%s}", name, operandIndex, modifier)
+	} else {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+		if err != nil {
+			return err
+		}
+		segment := ""
+		if pointerType == "ptr addrspace(256)" {
+			segment = "%gs:"
+		} else if pointerType == "ptr addrspace(257)" {
+			segment = "%fs:"
+		}
+		constraints += ",r"
+		arguments += fmt.Sprintf(", %s %s", pointerType, pointer)
+		assembly, memoryClobber = fmt.Sprintf("%s %s($%d)", name, segment, operandIndex), ",~{memory}"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, outputType, assembly,
+		constraints+",~{flags}"+memoryClobber, arguments)
+	if form.spec.bits == 8 {
+		return c.storeRegSized(AX, I16, "%"+result)
+	}
+	for index, register := range []Reg{AX, DX} {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, outputType, result, index)
+		if err := c.storeRegSized(register, width, "%"+value); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Logical FP is a collection of separately owned scalar fields, not native
+// contiguous stack backing. Gather its exact initialized bits into the same
+// register-source opcode used above. The opcode, rather than LLVM arithmetic,
+// still owns zero-divisor and quotient-overflow #DE, including dead results.
+func (c *amd64Ctx) implicitDivideRegisterValue(source Operand, width LLVMType) (string, error) {
+	if source.Kind != OpFP {
+		return c.evalIntSized(source, width)
+	}
+	value, handled, err := c.loadIntegerFPBytesMode(source.FPOffset, width, true)
+	if err != nil {
+		return "", err
+	}
+	if !handled {
+		return "", fmt.Errorf("%w: division divisor lacks exact owned logical FP bytes", ErrProbeNeedsContext)
+	}
+	return value, nil
+}
+
+// This descriptor is deliberately not in x86TypedInstructionByteEffect.
+// Only the paired native lowerer supplies a numerical continuation. The two
+// post-transfer footprint consumers may still revoke exactly the GP outputs.
+func x86ImplicitDivideWrites(form x86ImplicitDivideForm) []x86TypedByteOperand {
+	if form.spec.bits == 8 {
+		return []x86TypedByteOperand{{operand: Operand{Kind: OpReg, Reg: AX}, width: 2, write: true}}
+	}
+	width := int64(form.spec.bits / 8)
+	return []x86TypedByteOperand{
+		{operand: Operand{Kind: OpReg, Reg: AX}, width: width, write: true},
+		{operand: Operand{Kind: OpReg, Reg: DX}, width: width, write: true},
+	}
+}
+
+func x86LoweredImplicitDivideStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		form.source.Kind == OpReg && x86LogicalSourceFrameRegister(form.source.Reg, arch) {
+		return false, true
+	}
+	if form.source.Kind != OpReg && form.source.Kind != OpFP && !x86RegisterAddressedNativeMemoryOperand(form.source, arch) {
+		return false, true
+	}
+	width, accumulatorWidth := int64(form.spec.bits/8), int64(form.spec.bits/8)
+	if form.spec.bits == 8 {
+		accumulatorWidth = 2
+	}
+	if !x86ResultReadWithNativeContinuation(ins, form.source, width, state, owned, arch, true) ||
+		!x86ResultRead(Operand{Kind: OpReg, Reg: AX}, accumulatorWidth, state, owned, arch) ||
+		form.spec.bits != 8 && !x86ResultRead(Operand{Kind: OpReg, Reg: DX}, width, state, owned, arch) {
+		return false, true
+	}
+	for _, output := range x86ImplicitDivideWrites(form) {
+		if !x86ResultStore(output.operand, output.width, state, owned, 0, arch) {
+			return false, true
+		}
+		index, mask, _ := x86ResultGP(output.operand.Reg, output.width, arch)
+		state.canonicalGP[index] &^= mask
+		if output.width == 4 && arch == "amd64" {
+			state.canonicalGP[index] |= 0xf0
+		}
+		state.callerAddressGP[index] = false
+	}
+	state.flags = 0 // All six status flags are architecturally undefined; DF/ID stay unchanged.
+	return true, true
+}
diff --git a/amd64_implicit_mask_move_forms.go b/amd64_implicit_mask_move_forms.go
new file mode 100644
index 000000000..ef89050ee
--- /dev/null
+++ b/amd64_implicit_mask_move_forms.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func x86ImplicitMaskMoveProperties(op Op, ins Instr, arch string) (amd64ImplicitMaskMoveSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64ImplicitMaskMoveSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (amd64ImplicitMaskMoveSpec, bool, error) {
+		return spec, true, fmt.Errorf("%s %s outside complete Go implicit mask-store grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg {
+			return fail()
+		}
+		if spec.byteWidth == 8 {
+			if _, valid := amd64ParseMReg(operand.Reg); !valid {
+				return fail()
+			}
+			continue
+		}
+		index, valid := amd64ParseXReg(operand.Reg)
+		if !valid || index >= 16 || arch == "386" && index >= 8 {
+			return fail()
+		}
+	}
+	return spec, true, nil
+}
+
+func x86TypedImplicitMaskMoveByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86ImplicitMaskMoveProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(spec.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: width, read: true},
+		{index: 1, operand: ins.Args[1], width: width, read: true},
+		{index: -1, operand: Operand{Kind: OpMem, Mem: MemRef{Base: DI}}, width: width, write: true},
+	}}, true, nil
+}
+
+// MASKMOVQ belongs exclusively to its complete physical MMX/EMMS region.
+// SIMD stores also need the actual paired opcode and incoming DI identity;
+// an encoding, numerical address or zero mask provides neither storage nor
+// initialized bytes. A masked write establishes no new memory facts.
+func x86ResultImplicitMaskMoveStep(ins Instr, state *x86ResultState, arch string, native bool) (bool, bool) {
+	spec, known, err := x86ImplicitMaskMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	if !native || spec.byteWidth == 8 {
+		return false, true
+	}
+	required := x86CallerVectorByteMask(int64(spec.byteWidth))
+	for _, operand := range ins.Args {
+		index, _ := amd64ParseXReg(operand.Reg)
+		if state.vectorBytes(index)&required != required {
+			return false, true
+		}
+	}
+	return x86ResultIncomingPointerAddressIdentity(Operand{Kind: OpMem, Mem: MemRef{Base: DI}}, state, arch), true
+}
diff --git a/amd64_indexed_permute_forms.go b/amd64_indexed_permute_forms.go
new file mode 100644
index 000000000..16fb70225
--- /dev/null
+++ b/amd64_indexed_permute_forms.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// _yvblendmpd is the existing complete EVEX binary grammar. The mode adds
+// old-destination dependencies, not another register/memory/suffix parser.
+func x86IndexedPermuteProperties(op Op, ins Instr, arch string) (x86PackedBinaryForm, amd64IndexedPermuteSpec, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64IndexedPermuteSpecs[Op(base)]
+	if !known {
+		return x86PackedBinaryForm{}, spec, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86PackedBinaryForm{}, spec, true, fmt.Errorf("indexed permute dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	local, contextual := x86VectorValueMemoryInput(ins, arch)
+	local.Op = op
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, zeroing: true}
+	if spec.broadcast {
+		grammar.broadcastBytes = spec.laneBits / 8
+	}
+	form, err := x86PackedBinaryProperties(local, arch, grammar)
+	if err == nil && contextual {
+		err = x86VectorValueMemoryContext(ins)
+	}
+	return form, spec, true, err
+}
+
+func x86ResultIndexedPermuteStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, spec, known, err := x86IndexedPermuteProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	return x86ResultFixedVectorInputs(ins, form, spec.mode != amd64IndexedPermuteSingle, state, owned, arch), true
+}
diff --git a/amd64_insert_extract_forms.go b/amd64_insert_extract_forms.go
new file mode 100644
index 000000000..9d83c3835
--- /dev/null
+++ b/amd64_insert_extract_forms.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86InsertExtractSpec struct {
+	insert, scalar, vex, legacy bool
+	chunk, laneBits             int
+	allowY, allowZ              bool
+}
+
+var x86InsertExtractSpecs = map[Op]x86InsertExtractSpec{
+	"EXTRACTPS":     {scalar: true, legacy: true, chunk: 4, laneBits: 32},
+	"INSERTPS":      {insert: true, scalar: true, legacy: true, chunk: 4, laneBits: 32},
+	"VEXTRACTF128":  {vex: true, chunk: 16, laneBits: 8, allowY: true},
+	"VEXTRACTI128":  {vex: true, chunk: 16, laneBits: 8, allowY: true},
+	"VEXTRACTF32X4": {chunk: 16, laneBits: 32, allowY: true, allowZ: true},
+	"VEXTRACTI32X4": {chunk: 16, laneBits: 32, allowY: true, allowZ: true},
+	"VEXTRACTF64X2": {chunk: 16, laneBits: 64, allowY: true, allowZ: true},
+	"VEXTRACTI64X2": {chunk: 16, laneBits: 64, allowY: true, allowZ: true},
+	"VEXTRACTF32X8": {chunk: 32, laneBits: 32, allowZ: true},
+	"VEXTRACTI32X8": {chunk: 32, laneBits: 32, allowZ: true},
+	"VEXTRACTF64X4": {chunk: 32, laneBits: 64, allowZ: true},
+	"VEXTRACTI64X4": {chunk: 32, laneBits: 64, allowZ: true},
+	"VINSERTF128":   {insert: true, vex: true, chunk: 16, laneBits: 8, allowY: true},
+	"VINSERTI128":   {insert: true, vex: true, chunk: 16, laneBits: 8, allowY: true},
+	"VINSERTF32X4":  {insert: true, chunk: 16, laneBits: 32, allowY: true, allowZ: true},
+	"VINSERTI32X4":  {insert: true, chunk: 16, laneBits: 32, allowY: true, allowZ: true},
+	"VINSERTF64X2":  {insert: true, chunk: 16, laneBits: 64, allowY: true, allowZ: true},
+	"VINSERTI64X2":  {insert: true, chunk: 16, laneBits: 64, allowY: true, allowZ: true},
+	"VINSERTF32X8":  {insert: true, chunk: 32, laneBits: 32, allowZ: true},
+	"VINSERTI32X8":  {insert: true, chunk: 32, laneBits: 32, allowZ: true},
+	"VINSERTF64X4":  {insert: true, chunk: 32, laneBits: 64, allowZ: true},
+	"VINSERTI64X4":  {insert: true, chunk: 32, laneBits: 64, allowZ: true},
+	"VEXTRACTPS":    {scalar: true, chunk: 4, laneBits: 32},
+	"VINSERTPS":     {insert: true, scalar: true, chunk: 4, laneBits: 32},
+}
+
+type x86InsertExtractForm struct {
+	spec                                    x86InsertExtractSpec
+	source, base, destination, mask, memory int
+	width, output, offset                   int
+	immediate                               byte
+	zeroing, memoryWrite                    bool
+}
+
+func (form x86InsertExtractForm) undefinedOpcode() bool {
+	// Go emits EVEX.z for a memory destination, but the ISA makes that
+	// encoding terminal #UD rather than a zeroing store.
+	return form.zeroing && form.memoryWrite
+}
+
+// Block transfers read the inserted/selected chunk and, for insertion, only
+// the retained base bytes. This describes numerical inputs, not memory extent.
+func (form x86InsertExtractForm) blockInputBytes() (source, base uint64) {
+	chunk := x86CallerVectorByteMask(int64(form.spec.chunk))
+	selected := chunk << uint(form.offset)
+	if form.spec.insert {
+		return chunk, x86CallerVectorByteMask(int64(form.width)) &^ selected
+	}
+	return selected, 0
+}
+
+func x86InsertExtractProperties(ins Instr, goarch string) (x86InsertExtractForm, bool, error) {
+	op, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86InsertExtractSpecs[Op(op)]
+	if !recognized {
+		return x86InsertExtractForm{}, false, nil
+	}
+	f := x86InsertExtractForm{spec: spec, source: 1, base: -1, destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86InsertExtractForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s operands/suffix outside Go insert/extract grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	count := 3
+	if spec.insert {
+		count, f.base = 4, 2
+		if spec.legacy {
+			count = 3
+		}
+	}
+	// Go's 386 frontend cannot represent a four-operand named insertion.
+	// A validated physical VINSERTPS has its independent mode32 register and
+	// encoding checks; a textual Raw annotation cannot create that identity.
+	physicalScalarInsert := spec.insert && spec.scalar && ins.x86Encoded
+	if goarch != "amd64" && goarch != "386" || spec.insert && !spec.legacy && goarch == "386" && !physicalScalarInsert || len(ins.Args) != count && len(ins.Args) != count+1 ||
+		len(ins.Args) == count+1 && (spec.vex || spec.scalar) || dotted && (suffix != "Z" || spec.vex || spec.scalar) ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return fail()
+	}
+	if len(ins.Args) == count+1 {
+		f.mask = count - 1
+		if !amd64NonzeroKOperand(ins.Args[f.mask]) {
+			return fail()
+		}
+	}
+	if goarch == "386" && f.mask >= 0 {
+		return fail()
+	}
+	f.zeroing = dotted
+	if f.zeroing && f.mask < 0 {
+		return fail()
+	}
+	minimum := int64(0)
+	if !spec.insert && spec.vex {
+		minimum = -128
+	}
+	if spec.scalar && !spec.insert && !spec.legacy {
+		index, valid := amd64VectorRegisterIndex(ins.Args[1].Reg, 16)
+		if valid && index < 16 {
+			minimum = -128
+		}
+	}
+	maximum := int64(255)
+	if spec.legacy && !spec.insert {
+		maximum = 3
+	}
+	if ins.Args[0].Imm < minimum || ins.Args[0].Imm > maximum {
+		return fail()
+	}
+	f.immediate = byte(ins.Args[0].Imm)
+	f.width, f.output = 16, spec.chunk
+	large := ins.Args[f.source]
+	if spec.insert {
+		large = ins.Args[f.base]
+	}
+	if !spec.scalar {
+		f.width = amd64VectorByteWidth(large.Reg)
+		if large.Kind != OpReg || !(f.width == 32 && spec.allowY || f.width == 64 && spec.allowZ) {
+			return fail()
+		}
+		f.offset = (int(f.immediate) & (f.width/spec.chunk - 1)) * spec.chunk
+	} else {
+		f.offset = int(f.immediate&3) * 4
+	}
+	if spec.insert {
+		f.output = f.width
+	}
+	highMode32 := Reg("")
+	register := func(arg Operand, width int) bool {
+		index, valid := amd64VectorRegisterIndex(arg.Reg, width)
+		limit := 32
+		if spec.vex || spec.legacy {
+			limit = 16
+		}
+		if goarch == "386" && spec.legacy {
+			limit = 8
+		}
+		if arg.Kind != OpReg || !valid || index >= limit {
+			return false
+		}
+		if goarch == "386" && index >= 8 {
+			highMode32 = arg.Reg
+		}
+		return true
+	}
+	if !register(large, f.width) {
+		return fail()
+	}
+	if spec.insert && !register(ins.Args[f.destination], f.output) {
+		return fail()
+	}
+	transfer := ins.Args[f.destination]
+	if spec.insert {
+		transfer = ins.Args[f.source]
+	}
+	if isAMD64MemoryOperand(transfer) {
+		f.memory, f.memoryWrite = f.destination, !spec.insert
+		if spec.insert {
+			f.memory = f.source
+		}
+		if transfer.Kind == OpSym {
+			_, absolute := parseInt(strings.TrimSpace(transfer.Sym))
+			if strings.HasPrefix(strings.TrimSpace(transfer.Sym), "$") || !strings.HasSuffix(transfer.Sym, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if transfer.Kind == OpMem && (!x86MemoryRegistersValidForArch(transfer.Mem, goarch) ||
+			transfer.Mem.Index != "" && (transfer.Mem.Index == SP || transfer.Mem.Scale != 1 && transfer.Mem.Scale != 2 && transfer.Mem.Scale != 4 && transfer.Mem.Scale != 8) ||
+			transfer.Mem.Off != int64(int32(transfer.Mem.Off)) && (goarch != "386" || transfer.Mem.Off != int64(uint32(transfer.Mem.Off)))) {
+			return fail()
+		}
+	} else if !spec.insert && spec.scalar {
+		if transfer.Kind != OpReg || !isX86YrlRegisterForArch(transfer.Reg, goarch) {
+			return fail()
+		}
+	} else {
+		width := spec.chunk
+		if spec.scalar {
+			width = 16
+		}
+		if !register(transfer, width) {
+			return fail()
+		}
+	}
+	if highMode32 != "" {
+		// Go can encode named VEX/EVEX high SIMD registers in mode32.
+		// Its syntax/object acceptance does not supply physical register
+		// identities which the independent mode32 raw decoder rejects.
+		return f, true, fmt.Errorf("%w: 386 insert/extract register %s has no proved physical mode32 binding", ErrProbeNeedsContext, highMode32)
+	}
+	return f, true, nil
+}
+
+func (c *amd64Ctx) bindInsertExtractForm(op Op, ins Instr) (Instr, x86InsertExtractForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86InsertExtractSpecs[Op(base)]; !known {
+		return ins, x86InsertExtractForm{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return ins, x86InsertExtractForm{}, true, fmt.Errorf("insert/extract dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	f, known, err := x86InsertExtractProperties(ins, c.goarch)
+	if err == nil && !f.undefinedOpcode() && f.memory >= 0 && ins.Args[f.memory].Kind == OpFP {
+		err = c.validateFPVectorSpan(ins.Args[f.memory].FPOffset, f.spec.chunk)
+	}
+	return ins, f, known, err
+}
diff --git a/amd64_insert_extract_forms_test.go b/amd64_insert_extract_forms_test.go
new file mode 100644
index 000000000..e8d1c504f
--- /dev/null
+++ b/amd64_insert_extract_forms_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// Independent full opcode/ytab axes, not a rendering of the production map.
+func x86InsertExtractFormats() []string {
+	var rows []string
+	for _, action := range []string{"EXTRACT", "INSERT"} {
+		for _, kind := range []string{"F", "I"} {
+			for _, size := range []string{"128", "32X4", "64X2", "32X8", "64X4"} {
+				op, small := "V"+action+kind+size, "X"
+				widths := []string{"Y", "Z"}
+				if size == "128" {
+					widths = []string{"Y"}
+				}
+				if strings.HasSuffix(size, "X8") || strings.HasSuffix(size, "X4") && strings.HasPrefix(size, "64") {
+					small, widths = "Y", []string{"Z"}
+				}
+				for _, wide := range widths {
+					for _, memory := range []bool{false, true} {
+						for _, masking := range []string{"", "merge", "zero"} {
+							if size == "128" && masking != "" || action == "EXTRACT" && memory && masking == "zero" {
+								continue
+							}
+							mnemonic, mask := op, ""
+							if masking != "" {
+								mask = ",K1"
+							}
+							if masking == "zero" {
+								mnemonic += ".Z"
+							}
+							transfer := small + "0"
+							if memory {
+								transfer = "(BX)"
+							}
+							if action == "INSERT" {
+								rows = append(rows, fmt.Sprintf("%s $255,%s,%s1%s,%s2", mnemonic, transfer, wide, mask, wide))
+							} else {
+								rows = append(rows, fmt.Sprintf("%s $255,%s1%s,%s", mnemonic, wide, mask, transfer))
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return append(rows, "VEXTRACTPS $255,X1,AX", "VEXTRACTPS $255,X1,(BX)", "VINSERTPS $255,X0,X1,X2", "VINSERTPS $255,(BX),X1,X2",
+		"EXTRACTPS $3,X1,AX", "EXTRACTPS $3,X1,(BX)", "INSERTPS $255,X0,X1", "INSERTPS $255,(BX),X1")
+}
+
+func TestX86InsertExtractEveryGoOpcodeAttribute(t *testing.T) {
+	if len(x86InsertExtractSpecs) != 24 {
+		t.Fatal("incomplete family")
+	}
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := map[string]string{
+		"VEXTRACTF128": "vexW0, 0x19", "VEXTRACTI128": "vexW0, 0x39",
+		"VEXTRACTF32X4": "evexW0, evexN16", "VEXTRACTI32X4": "evexW0, evexN16",
+		"VEXTRACTF64X2": "evexW1, evexN16", "VEXTRACTI64X2": "evexW1, evexN16",
+		"VEXTRACTF32X8": "evexW0, evexN32", "VEXTRACTI32X8": "evexW0, evexN32",
+		"VEXTRACTF64X4": "evexW1, evexN32", "VEXTRACTI64X4": "evexW1, evexN32",
+		"VINSERTF128": "vexW0, 0x18", "VINSERTI128": "vexW0, 0x38",
+		"VINSERTF32X4": "evexW0, evexN16", "VINSERTI32X4": "evexW0, evexN16",
+		"VINSERTF64X2": "evexW1, evexN16", "VINSERTI64X2": "evexW1, evexN16",
+		"VINSERTF32X8": "evexW0, evexN32", "VINSERTI32X8": "evexW0, evexN32",
+		"VINSERTF64X4": "evexW1, evexN32", "VINSERTI64X4": "evexW1, evexN32",
+		"VEXTRACTPS": "evexW0, evexN4", "VINSERTPS": "evexW0, evexN4",
+	}
+	var observed []string
+	for _, row := range strings.Split(string(data), "{as: A") {
+		op := strings.SplitN(row, ",", 2)[0]
+		if !strings.HasPrefix(op, "VEXTRACT") && !strings.HasPrefix(op, "VINSERT") {
+			continue
+		}
+		observed = append(observed, op)
+		body := strings.SplitN(row, "\n\t}},", 2)[0]
+		spec, exists := x86InsertExtractSpecs[Op(op)]
+		if !exists {
+			t.Fatalf("unregistered actual Go opcode: %s", op)
+		}
+		if strings.Contains(body, "Bcst") || strings.Contains(body, "Sae") ||
+			strings.Contains(body, "evexZeroingEnabled") != (!spec.scalar && !spec.vex) {
+			t.Fatalf("per-opcode flags changed: %s", body)
+		}
+		if spec.vex && strings.Contains(body, "evex") || !spec.vex && !strings.Contains(body, "evex") {
+			t.Fatalf("encoding identity changed: %s", body)
+		}
+		if attribute, exists := expected[op]; !exists || !strings.Contains(body, attribute) ||
+			!strings.Contains(body, "0F3A") || spec.allowY != strings.Contains(body, "256") || spec.allowZ != strings.Contains(body, "512") {
+			t.Fatalf("per-opcode W/tuple/native width attributes changed: %s", body)
+		}
+	}
+	sort.Strings(observed)
+	if len(observed) != 22 {
+		t.Fatalf("actual Go family: %v", observed)
+	}
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{AEXTRACTPS, yextractps, Pq, opBytes{0x3a, 0x17, 0}}",
+		"{AINSERTPS, yxshuf, Pq, opBytes{0x3a, 0x21, 0}}",
+		"var yextractps = []ytab{\n\t{Zibr_m, 2, argList{Yu2, Yxr, Yml}}",
+		"var yxshuf = []ytab{\n\t{Zibm_r, 2, argList{Yu8, Yxm, Yxr}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatalf("actual Go legacy PS row changed: %s", row)
+		}
+	}
+}
+
+func TestX86InsertExtractFormatsAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		for index, row := range x86InsertExtractFormats() {
+			if arch == "386" && (strings.HasPrefix(row, "VINSERT") || strings.Contains(row, "K1")) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+				continue
+			}
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, known, err := x86InsertExtractProperties(file.Funcs[0].Instrs[1], arch)
+			if !known || err != nil {
+				t.Fatalf("%s/%s: %v", arch, row, err)
+			}
+			goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			name := fmt.Sprintf("transfer%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+		}
+		triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			t.Run(triple, func(t *testing.T) {
+				// Preserve every original uninitialized row as Go/public-Context
+				// and emitter-object coverage. Complete initialized programs have
+				// separate public object and executed-byte owners.
+				file, signatures := x86UnboundVoidFormatSources(t, source.String(), arch, triple)
+				ir := x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+					func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+						return c.lowerInsertExtractFamily(ins.Op, ins)
+					})
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		}
+	}
+}
+
+func TestX86InsertExtractDispatchIdentityAndGrammarBeforeEmission(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(string(ins.Op))), "UNKNOWN", "VEXTRACTPS.Z"} {
+			copy := ins
+			copy.Op = identity
+			original := copy
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerInsertExtractFamily(ins.Op, copy)
+			failure := identity == "UNKNOWN" || identity == "VEXTRACTPS.Z"
+			if !known || term || (err != nil) != failure || failure && output.String() != before || !reflect.DeepEqual(copy, original) {
+				t.Fatalf("%s/%s: %t/%t/%v", row, identity, known, term, err)
+			}
+		}
+	}
+	for _, row := range []string{
+		"VEXTRACTF128 $256,Y0,X1", "VEXTRACTF128 $-129,Y0,X1", "VEXTRACTF128 $0,Y16,X1",
+		"VEXTRACTF64X4 $-1,Z0,Y1", "VEXTRACTF32X4.Z $0,Z0,X1", "VEXTRACTI32X4 $0,Z0,K0,X1",
+		"VEXTRACTPS $-1,X31,AX", "VEXTRACTPS $0,X0,X1", "VINSERTPS $-1,X0,X1,X2",
+		"VINSERTI128 $0,X0,Y0,Y16", "VINSERTF32X8.BCST $0,(AX),Z0,Z1",
+		"VINSERTF64X2.RN_SAE $0,X0,Z0,Z1", "VINSERTI64X4.Z $0,Y0,Z0,Z1",
+		"VINSERTPS $0,(AX)(SP*2),X0,X1", "VINSERTPS $0,2147483648(AX),X0,X1",
+		"VEXTRACTF32X4 $0,Z0,$data(SB)",
+		"VEXTRACTF128 $selector,Y0,X1", "VINSERTPS $1.5,X0,X1,X2",
+		"INSERTPS $selector,X0,X1", "EXTRACTPS $1.5,X0,AX", "EXTRACTPS $4,X0,AX",
+		"INSERTPS $0,X16,X0", "EXTRACTPS $0,X16,AX", "INSERTPS.Z $0,X0,X1",
+	} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		// Go 1.20 emitted the reserved EVEX.z=1/aaa=0 combination for
+		// this unchanged negative. Current Go rejects it. Syntax acceptance
+		// cannot authorize that physical invalid-opcode form.
+		reservedZeroMask := row == "VEXTRACTF32X4.Z $0,Z0,X1" || row == "VINSERTI64X4.Z $0,Y0,Z0,Z1"
+		if reservedZeroMask {
+			x86InsertExtractReservedZeroMaskGoObservation(t, source)
+		} else {
+			goAssemblerOracleOutput(t, "amd64", source, "", false)
+		}
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			continue
+		}
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		known, _, err := ctx.lowerInsertExtractFamily(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+		if !known || err == nil || output.String() != before {
+			t.Fatalf("malformed source emitted IR: %s: %v", row, err)
+		}
+	}
+}
+
+func TestX86InsertExtractCompleteTypedFPSpanBeforeEmission(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		if !strings.Contains(row, "(BX)") {
+			continue
+		}
+		row = strings.Replace(row, "(BX)", "a+0(FP)", 1)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-32\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86InsertExtractProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		width := form.spec.chunk
+		if form.spec.scalar && !form.spec.insert {
+			// The PS writer now consumes the full source-byte proof too.
+			// Keep this test about complete spans, not unknown X input data.
+			file.Funcs[0].Instrs = append([]Instr{
+				file.Funcs[0].Instrs[0], x86ScalarLaneInstruction(t, "PXOR X1,X1"),
+			}, file.Funcs[0].Instrs[1:]...)
+		}
+		for _, missing := range []int{-1, 0, width - 1} {
+			sig := FuncSig{Name: "f", Ret: Void}
+			for index := 0; index < width; index++ {
+				if index != missing {
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(index), Type: I8, Index: len(sig.Args), Field: -1})
+					sig.Args = append(sig.Args, I8)
+				}
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := output.String()
+			known, term, err := ctx.lowerInsertExtractFamily(ins.Op, ins)
+			// Native E6NF requires a physical contiguous destination. Typed
+			// individual ABI0 shadow cells do not supply it, even if every
+			// slot is bound. This remains Context, not fabricated memory.
+			failure := missing >= 0 || form.memoryWrite && form.mask >= 0
+			if !known || term || (err != nil) != failure || failure && output.String() != before {
+				t.Fatalf("%s missing FP byte %d: %t/%t/%v", row, missing, known, term, err)
+			}
+		}
+	}
+}
diff --git a/amd64_insert_extract_go_oracle_test.go b/amd64_insert_extract_go_oracle_test.go
new file mode 100644
index 000000000..a7fd6d38b
--- /dev/null
+++ b/amd64_insert_extract_go_oracle_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86InsertExtractGoListing(t *testing.T, arch, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "oracle", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), true, arch); failure != nil {
+		t.Fatalf("actual original assembler listing: %v\n%s", failure, output)
+	}
+	return output
+}
+
+// Parse only concrete byte columns, not assembly mnemonic text. Go's listing
+// starts its columns with 0xNNNN; llvm-objdump uses NNNN:. Both are independent
+// physical object observations, rather than a rendering of the typed table.
+func x86InsertExtractListedBytes(line string) []byte {
+	fields := strings.Fields(line)
+	if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") && !strings.HasSuffix(fields[0], ":") {
+		return nil
+	}
+	if strings.HasPrefix(fields[0], "0x") {
+		_, code, err := goAssemblyListingByteRow(line)
+		if err != nil {
+			return nil
+		}
+		return code
+	}
+	var result []byte
+	for _, field := range fields[1:] {
+		if len(field) != 2 {
+			break
+		}
+		value, err := hex.DecodeString(field)
+		if err != nil {
+			break
+		}
+		result = append(result, value[0])
+	}
+	return result
+}
+
+func TestX86InsertExtract386HighRegistersKeepPhysicalContext(t *testing.T) {
+	const source = "TEXT f(SB),4,$0-0\nVEXTRACTF128 $1,Y8,X9\nVEXTRACTPS $3,X8,AX\nRET\n"
+	listing := x86InsertExtractGoListing(t, "386", source)
+	var code []byte
+	for _, line := range strings.Split(string(listing), "\n") {
+		code = append(code, x86InsertExtractListedBytes(line)...)
+	}
+	if !bytes.Equal(code, []byte{0xc4, 0x43, 0x7d, 0x19, 0xc1, 1, 0xc4, 0x63, 0x79, 0x17, 0xc0, 3, 0xc3}) {
+		t.Fatalf("actual Go named mode32 bytes changed: %x", code)
+	}
+	for _, op := range []Op{"VEXTRACTF128", "VEXTRACTPS"} {
+		decode := decodedX86VEXTRACT128Instruction
+		if op == "VEXTRACTPS" {
+			decode = decodedX86PackedScalarExtractInstruction
+		}
+		ins, size, recognized, err := decode(code, 64)
+		if !recognized || err != nil || ins.Op != op || ins.Args[1].Reg != map[Op]Reg{"VEXTRACTF128": "Y8", "VEXTRACTPS": "X8"}[op] {
+			t.Fatalf("actual Go high-register bytes %x lost source identity: %+v/%v", code, ins, err)
+		}
+		if _, _, recognized, err := decode(code[:size], 32); !recognized || err == nil {
+			t.Fatal("mode32 decoder invented high physical SIMD registers")
+		}
+		t.Logf("actual Go accepted %s bytes %x; mode32 physical binding remains Context", op, code[:size])
+		code = code[size:]
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("Go's mode32 accepted bytes acquired ordinary physical meaning: %v", err)
+	}
+}
+
+func TestX86InsertExtractNativeMaskedStorePhysicalObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump are required")
+	}
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	want := map[string]int{}
+	count := 0
+	for _, row := range x86InsertExtractFormats() {
+		if !strings.HasPrefix(row, "VEXTRACT") || !strings.Contains(row, "K1,(BX)") {
+			continue
+		}
+		listing := x86InsertExtractGoListing(t, "amd64", "TEXT f(SB),4,$0-0\n"+strings.Replace(row, "1,K1", "0,K1", 1)+"\nRET\n")
+		matched := false
+		for _, line := range strings.Split(string(listing), "\n") {
+			code := x86InsertExtractListedBytes(line)
+			ins, _, recognized, err := decodedX86VEXTRACT128Instruction(code, 64)
+			if recognized {
+				if err != nil || ins.Args[0].Imm != 255 || ins.Args[2].Reg != "K1" || ins.Args[3].Kind != OpMem {
+					t.Fatalf("Go masked store identity: %+v/%v", ins, err)
+				}
+				matched = true
+				want[string(ins.Op)+":"+string(ins.Args[1].Reg)]++
+			}
+		}
+		if !matched {
+			t.Fatalf("Go listing has no concrete E6NF bytes:\n%s", listing)
+		}
+		name := fmt.Sprintf("store%d", count)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ destination+0(FP),BX\nMOVQ mask+8(FP),AX\nKMOVQ AX,K1\nVPXORD Z1,Z1,Z1\n%s\nRET\n", name, row)
+		sigs[name] = FuncSig{Ret: Void, Args: []LLVMType{Ptr, I64}, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}}}}
+		count++
+	}
+	if count != 12 {
+		t.Fatalf("incomplete EVEX masked memory width/opcode family: %d", count)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Count(ir, "~{zmm0},~{k1},~{memory}") != count || strings.Contains(ir, "target-features") {
+			t.Fatal("native instruction bridge lost explicit private clobbers or enabled global ISA")
+		}
+		dir := t.TempDir()
+		input, object := filepath.Join(dir, "store.ll"), filepath.Join(dir, "store.o")
+		if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, llc, "-O2", "-mtriple="+triple, "-filetype=obj", input, "-o", object)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("LLVM22 native E6NF object: %v\n%s", err, output)
+		}
+		ctx, cancel = runtimeOracleStageContext(t)
+		command = exec.CommandContext(ctx, objdump, "-d", object)
+		output, err = runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("LLVM22 native E6NF disassembly: %v\n%s", err, output)
+		}
+		observed := 0
+		got := map[string]int{}
+		for _, line := range strings.Split(string(output), "\n") {
+			code := x86InsertExtractListedBytes(line)
+			ins, size, recognized, err := decodedX86VEXTRACT128Instruction(code, 64)
+			if !recognized {
+				continue
+			}
+			if err != nil || size != len(code) || ins.Args[0].Imm != 255 || ins.Args[1].Reg != "Y0" && ins.Args[1].Reg != "Z0" || ins.Args[2].Reg != "K1" || ins.Args[3].Kind != OpMem {
+				t.Fatalf("LLVM native write-only instruction identity %s: %+v/%v", line, ins, err)
+			}
+			observed++
+			got[string(ins.Op)+":"+string(ins.Args[1].Reg)]++
+		}
+		if observed != count || !reflect.DeepEqual(got, want) {
+			t.Fatalf("%s: native masked stores observed %d want %d\n%s", triple, observed, count, output)
+		}
+	}
+}
+
+func x86InsertExtractReservedZeroMaskGoObservation(t *testing.T, source string, expectedCode ...byte) {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "reserved.s"), filepath.Join(dir, "reserved.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), err == nil, "amd64"); failure != nil {
+		t.Fatalf("reserved zero-mask source observation: %v\n%s", failure, output)
+	}
+	if err != nil {
+		return // actual concrete source rejection; never an unknown tool failure
+	}
+	code := []byte{0x62, 0xf3, 0x7d, 0xc8, 0x19, 0xc1, 0}
+	decode := decodedX86VEXTRACT128Instruction
+	if strings.Contains(source, "VINSERT") {
+		code = []byte{0x62, 0xf3, 0xfd, 0xc8, 0x3a, 0xc8, 0}
+		decode = decodedX86EVEXPackedInsertInstruction
+	}
+	if len(expectedCode) != 0 {
+		code = expectedCode
+	}
+	var listing strings.Builder
+	for _, value := range code {
+		fmt.Fprintf(&listing, "%02x ", value)
+	}
+	if !bytes.Contains(output, []byte(strings.TrimSpace(listing.String()))) {
+		t.Fatalf("accepted old Go reserved bytes changed:\n%s", output)
+	}
+	if _, _, recognized, err := decode(code, 64); !recognized || err == nil {
+		t.Fatal("reserved EVEX.z with aaa=0 acquired valid physical meaning")
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86InsertExtractOriginalGoPSOracle(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	checks.WriteString(`package oracle
+import ("encoding/binary";"testing")
+func TestOriginalPSBits(t *testing.T) {
+ a:=[4]uint32{0x7f812345,0x80000000,0xffc45678,0x01234567}
+ b:=[4]uint32{0x89abcdef,0x7fc11111,0x7f800000,1}
+`)
+	for index, immediate := range []int{0, 16, 32, 48, 64, 128, 192, 1, 2, 4, 8, 15, 255} {
+		name := fmt.Sprintf("insert%d", index)
+		fmt.Fprintf(&declarations, "func %s(out,a,b *[4]uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVUPS (BX),X0\nMOVUPS (CX),X1\nINSERTPS $%d,X0,X1\nMOVUPS X1,(AX)\nRET\n", name, immediate)
+		fmt.Fprintf(&checks, "{var out [4]uint32;want:=b;want[%d]=a[%d];for lane:=0;lane<4;lane++{if %d&(1<<lane)!=0{want[lane]=0}};%s(&out,&a,&b);if out!=want{t.Fatalf(%q, out,want)}}\n", immediate>>4&3, immediate>>6&3, immediate, name, name+" got=%x want=%x")
+	}
+	for lane := 0; lane < 4; lane++ {
+		name := fmt.Sprintf("extract%d", lane)
+		fmt.Fprintf(&declarations, "func %s(out *[8]byte,a *[4]uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVUPS (BX),X0\nEXTRACTPS $%d,X0,CX\nMOVQ CX,(AX)\nRET\n", name, lane)
+		fmt.Fprintf(&checks, "{var out [8]byte;%s(&out,&a);if binary.LittleEndian.Uint64(out[:])!=uint64(a[%d]){t.Fatalf(%q,out)}}\n", name, lane, name+" zero-extension got=%x")
+	}
+	declarations.WriteString("func fpFields(a,b,c,d byte) uint32\nfunc fpStores(a,b,c,d byte) uint32\n")
+	// ABI0 aligns the result area to the AMD64 stack word independently of
+	// the four byte parameters; the actual Go wrapper reads ret+8(FP).
+	assembly.WriteString("TEXT ·fpFields(SB),4,$0-12\nPXOR X0,X0\nINSERTPS $0,a+0(FP),X0\nEXTRACTPS $0,X0,ret+8(FP)\nRET\n" +
+		"TEXT ·fpStores(SB),4,$0-12\nMOVL $0x87654321,CX\nMOVD CX,X1\nEXTRACTPS $0,X1,a+0(FP)\nMOVBLZX a+0(FP),AX\nMOVBLZX b+1(FP),BX\nSHLL $8,BX\nORL BX,AX\nMOVBLZX c+2(FP),BX\nSHLL $16,BX\nORL BX,AX\nMOVBLZX d+3(FP),BX\nSHLL $24,BX\nORL BX,AX\nMOVL AX,ret+8(FP)\nRET\n")
+	checks.WriteString(`for i:=0;i<256;i++ {
+ a,b,c,d:=byte(i),byte(i*37),byte(i*59),byte(i*71)
+ want:=uint32(a)|uint32(b)<<8|uint32(c)<<16|uint32(d)<<24
+ if got:=fpFields(a,b,c,d);got!=want{t.Fatalf("original Go FP fields got=%x want=%x",got,want)}
+ if got:=fpStores(a,b,c,d);got!=0x87654321{t.Fatalf("original Go FP stores got=%x",got)}
+}
+`)
+	checks.WriteString("}\n")
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	dir := t.TempDir()
+	for file, contents := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": checks.String()} {
+		if err := os.WriteFile(filepath.Join(dir, file), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=asmdecl", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go PS original bit-transfer oracle: %v\n%s", err, output)
+	}
+}
diff --git a/amd64_insert_extract_native_runtime_linux_amd64_test.go b/amd64_insert_extract_native_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..28a564f5c
--- /dev/null
+++ b/amd64_insert_extract_native_runtime_linux_amd64_test.go
@@ -0,0 +1,9 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86InsertExtractMaskedNativeMemory(t *testing.T) {
+	x86InsertExtractMaskedMemoryRuntime(t)
+}
diff --git a/amd64_insert_extract_native_runtime_test.go b/amd64_insert_extract_native_runtime_test.go
new file mode 100644
index 000000000..433ccb756
--- /dev/null
+++ b/amd64_insert_extract_native_runtime_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This is exactly the subset deliberately excluded by the portable byte
+// oracle: E6NF masked memory destinations execute a physical native opcode.
+func x86InsertExtractMaskedMemoryRows() []string {
+	var rows []string
+	for _, row := range x86InsertExtractFormats() {
+		if strings.HasPrefix(row, "VEXTRACT") && strings.Contains(row, "(BX)") && strings.Contains(row, "K1") {
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86InsertExtractMaskedMemoryAssembly() (string, map[string]FuncSig) {
+	var assembly strings.Builder
+	signatures := map[string]FuncSig{}
+	for index, row := range x86InsertExtractMaskedMemoryRows() {
+		name := fmt.Sprintf("masked%d", index)
+		row = strings.Replace(row, "(BX)", "(AX)", 1)
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),R9\nKMOVQ R9,K1\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nSTC\n%s\nSETCS 64(AX)\nRET\n", name, row)
+		signatures[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+	}
+	return assembly.String(), signatures
+}
+
+func x86InsertExtractMaskedMemoryShape(row string) (chunk, width, lane int) {
+	chunk, width, lane = 16, 32, 4
+	if strings.Contains(row, "32X8") || strings.Contains(row, "64X4") {
+		chunk = 32
+	}
+	if strings.Contains(row, ",Z") {
+		width = 64
+	}
+	if strings.Contains(row, "64X") {
+		lane = 8
+	}
+	return
+}
+
+func TestX86InsertExtractMaskedMemoryRequiredInventory(t *testing.T) {
+	rows := x86InsertExtractMaskedMemoryRows()
+	if len(rows) != 12 || len(x86InsertExtractFormats()) != 148 {
+		t.Fatalf("changed complete/native fixture denominator: %d/%d", len(x86InsertExtractFormats()), len(rows))
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_insert_extract_native_runtime_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == "TestCrossLinuxRuntimeMatrixX86InsertExtractMaskedNativeMemory" {
+			body = fn.Body
+		}
+	}
+	if body == nil || len(body.List) != 1 {
+		t.Fatal("all masked-memory extract cases require the native execution consumer")
+	}
+	statement, ok := body.List[0].(*ast.ExprStmt)
+	if !ok {
+		t.Fatal("native extract counterpart cannot return or skip")
+	}
+	call, ok := statement.X.(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		t.Fatal("native extract counterpart does not consume its full fixture")
+	}
+	callee, ok := call.Fun.(*ast.Ident)
+	if !ok || callee.Name != "x86InsertExtractMaskedMemoryRuntime" {
+		t.Fatal("native extract counterpart substituted another consumer")
+	}
+	assembly, signatures := x86InsertExtractMaskedMemoryAssembly()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	parsed, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		ir, err := Translate(parsed, Options{Goarch: "amd64", TargetTriple: triple, Sigs: signatures})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "masked-extract.ll", "masked-extract.o", ir)
+	}
+	// The complete original Go oracle must compile even on a portable host;
+	// only its required native counterpart may execute these AVX512 bytes.
+	dir := x86InsertExtractMaskedOriginalPackage(t)
+	command := exec.Command("go", "test", "-p=2", "-c", "-o", filepath.Join(dir, "original"), ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	x86FloatCompareCaptureCommand(t, command)
+	t.Log("148 original formats preserved: all 12 excluded native memory-mask cases now have stock Go objects, 3 LLVM target objects and a mandatory Linux AMD64 runtime counterpart (not executed here)")
+}
+
+// Intel Vol2 KMOVQ r64,k requires AVX512BW; the extract forms additionally
+// require F/DQ/VL. Checking F alone cannot authorize this existing bridge.
+const x86InsertExtractNativePreflightC = `
+#undef main
+__attribute__((target("avx512f,avx512dq,avx512bw,avx512vl")))
+static int original_extract(void) {
+    uint8_t input[64],output[34];
+    for (unsigned i=0;i<64;i++) input[i]=(uint8_t)(i*13+0x27);
+    for (unsigned i=0;i<34;i++) output[i]=0xc3;
+    uint64_t mask=1;
+    __asm__ volatile("vmovdqu64 (%0),%%zmm0; kmovq %1,%%k1; "
+                     "vextracti32x8 $1,%%zmm0,(%2)%{%%k1%}"
+                     :: "r"(input),"r"(mask),"r"(output+1) : "zmm0","k1","memory");
+    for (unsigned i=0;i<34;i++) {
+        uint8_t want=i>=1 && i<=4 ? input[31+i] : 0xc3;
+        if (output[i]!=want) return 0;
+    }
+    return 1;
+}
+static int extract_required_state(unsigned dq,unsigned bw) { return dq && bw; }
+int main(void) {
+    int failure=compare_preflight_main();
+    if (failure) return failure;
+    unsigned a,b,c,d,dq=0,bw=0;
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) { dq=(b>>17)&1; bw=(b>>30)&1; }
+    printf("masked extract AVX512DQ=%u AVX512BW=%u\n",dq,bw);
+    fflush(stdout);
+    if (!extract_required_state(dq,bw)) return 81;
+    return original_extract() ? 0 : 82;
+}
+`
+
+func x86InsertExtractMaskedMemoryRuntime(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	dir := t.TempDir()
+	source, binary := filepath.Join(dir, "extract-preflight.c"), filepath.Join(dir, "extract-preflight")
+	program := "#define REQUIRED_AXIS 3\n#define main compare_preflight_main\n" + x86FloatCompareOpcodePreflightC + x86InsertExtractNativePreflightC
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, binary)
+	t.Logf("original native extract preflight: %s", execution.run(t, binary))
+	original := x86InsertExtractMaskedOriginalPackage(t)
+	command := exec.Command("go", "test", "-p=2", "-count=1", "-run", "^TestOriginalMaskedExtract$", "-v", ".")
+	command.Dir = original
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	t.Logf("original Go native masked extract: %s", x86FloatCompareCaptureCommand(t, command))
+	assembly, signatures := x86InsertExtractMaskedMemoryAssembly()
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: signatures})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declarations, calls strings.Builder
+	for index, row := range x86InsertExtractMaskedMemoryRows() {
+		chunk, width, lane := x86InsertExtractMaskedMemoryShape(row)
+		fmt.Fprintf(&declarations, "extern void masked%d(void*,const void*,const void*,uint64_t);\n", index)
+		fmt.Fprintf(&calls, "    if (check(masked%d,%d,%d,%d)) return %d;\n", index, chunk, width, lane, index+1)
+	}
+	execution.compileAndRunLLVM(t, "masked-native-extract", ir, x86InsertExtractMaskedMemoryC+declarations.String()+"int main(void) {\n"+calls.String()+"    return 0;\n}\n", "-O2")
+	t.Log("all 12 native masked-memory extract programs x40 byte/MXCSR/CF/input-output-canary cases executed by original Go and translated LLVM")
+}
+
+func TestX86InsertExtractNativeOpcodePreflightContract(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source, binary := filepath.Join(dir, "extract-capabilities.c"), filepath.Join(dir, "extract-capabilities")
+	// Compile the actual original-opcode preflight, but execute only its exact
+	// extra capability predicate here. Synthetic bits never permit ISA execution.
+	program := "#define REQUIRED_AXIS 3\n#define main compare_preflight_main\n" + x86FloatCompareOpcodePreflightC +
+		strings.Replace(x86InsertExtractNativePreflightC, "int main(void)", "int actual_extract_main(void)", 1) + `
+int main(void) {
+    if (!extract_required_state(1,1) || extract_required_state(0,1) ||
+        extract_required_state(1,0) || extract_required_state(0,0)) return 1;
+    return 0;
+}
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, binary)
+	execution.run(t, binary)
+}
+
+func x86InsertExtractMaskedOriginalPackage(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	assembly, _ := x86InsertExtractMaskedMemoryAssembly()
+	assembly = strings.ReplaceAll(assembly, "TEXT masked", "TEXT ·masked")
+	assembly += "TEXT ·setCSR(SB),4,$0-4\nLDMXCSR csr+0(FP)\nRET\nTEXT ·getCSR(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\n"
+	var declarations, cases strings.Builder
+	for index, row := range x86InsertExtractMaskedMemoryRows() {
+		chunk, width, lane := x86InsertExtractMaskedMemoryShape(row)
+		fmt.Fprintf(&declarations, "func masked%d(out *[65]byte,a,b *[64]byte,mask uint64)\n", index)
+		fmt.Fprintf(&cases, "        {masked%d,%d,%d,%d},\n", index, chunk, width, lane)
+	}
+	for name, contents := range map[string]string{
+		"go.mod": "module nativemaskedextract\n\ngo 1.20\n", "original_amd64.s": assembly,
+		"original_test.go": "package original\nimport (\"testing\"; \"runtime\")\n" + declarations.String() + "func setCSR(csr uint32)\nfunc getCSR() uint32\n" + strings.Replace(x86InsertExtractMaskedMemoryGo, "REQUIRED_CASES", cases.String(), 1),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+const x86InsertExtractMaskedMemoryGo = `
+func TestOriginalMaskedExtract(t *testing.T) {
+    runtime.LockOSThread()
+    defer runtime.UnlockOSThread()
+    defer setCSR(getCSR())
+    cases:=[]struct{fn func(*[65]byte,*[64]byte,*[64]byte,uint64); chunk,width,lane int}{
+REQUIRED_CASES
+    }
+    masks:=[]uint64{0,1,0xaaaaaaaaaaaaaaaa,0xffffffffffffffff,0xffff000000000000}
+    for index,fixture:=range cases {
+        for vector:=0;vector<8;vector++ {
+            for _,mask:=range masks {
+                var a,b,out [67]byte
+                for i:=range a {
+                    a[i]=0xa7
+                    b[i]=0xb9
+                    out[i]=0xc3
+                }
+                for i:=0;i<64;i++ {
+                    a[i+1]=byte((i*31+vector*17)^0x81)
+                    b[i+1]=byte((i*13+vector*29)^0x27)
+                }
+                aCopy,bCopy:=a,b
+                want:=out
+                offset:=(255&(fixture.width/fixture.chunk-1))*fixture.chunk
+                for i:=0;i<fixture.chunk;i++ {
+                    if mask&(uint64(1)<<uint(i/fixture.lane))!=0 {
+                        want[i+1]=b[offset+i+1]
+                    }
+                }
+                want[65]=1
+                setCSR(0x9fc5)
+                fixture.fn((*[65]byte)(out[1:66]),(*[64]byte)(a[1:65]),(*[64]byte)(b[1:65]),mask)
+                if out!=want || a!=aCopy || b!=bCopy || getCSR()!=0x9fc5 {
+                    t.Fatalf("original extract %d mask=%x out=%x want=%x",index,mask,out,want)
+                }
+            }
+        }
+    }
+}
+`
+
+// The old reference's byte selection and five masks are preserved. A masked
+// memory destination leaves inactive output bytes untouched (0xc3), unlike
+// the old register-destination cases which merge their prior vector value.
+const x86InsertExtractMaskedMemoryC = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+typedef void(*transfer)(void*,const void*,const void*,uint64_t);
+static int check(transfer fn,unsigned chunk,unsigned width,unsigned laneBytes) {
+    const uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX,UINT64_C(0xffff000000000000)};
+    for (unsigned vector=0;vector<8;vector++) {
+        for (unsigned m=0;m<5;m++) {
+            uint8_t as[67],bs[67],out[67],want[67],aCopy[67],bCopy[67];
+            uint8_t *a=as+1,*b=bs+1;
+            memset(as,0xa7,67); memset(bs,0xb9,67); memset(out,0xc3,67);
+            for (unsigned i=0;i<64;i++) {
+                a[i]=(i*31+vector*17)^0x81;
+                b[i]=(i*13+vector*29)^0x27;
+            }
+            memcpy(aCopy,as,67); memcpy(bCopy,bs,67); memcpy(want,out,67);
+            unsigned offset=(255&(width/chunk-1))*chunk;
+            for (unsigned i=0;i<chunk;i++) {
+                if (masks[m]&(UINT64_C(1)<<(i/laneBytes))) want[i+1]=b[offset+i];
+            }
+            want[65]=1;
+            unsigned csr=0x9fc5,observed;
+            __asm__ volatile("ldmxcsr %0"::"m"(csr));
+            fn(out+1,a,b,masks[m]);
+            __asm__ volatile("stmxcsr %0":"=m"(observed));
+            if (memcmp(out,want,67)||memcmp(as,aCopy,67)||memcmp(bs,bCopy,67)||observed!=csr) {
+                fprintf(stderr,"native extract chunk=%u width=%u lane=%u mask=%llx CSR=%x\n",chunk,width,laneBytes,(unsigned long long)masks[m],observed);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_insert_extract_numerical_test.go b/amd64_insert_extract_numerical_test.go
new file mode 100644
index 000000000..6c7eff07a
--- /dev/null
+++ b/amd64_insert_extract_numerical_test.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86InsertExtractIndependentFPFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	const source = "TEXT fields(SB),4,$0-12\nPXOR X0,X0\nVINSERTPS $0,a+0(FP),X0,X1\nVEXTRACTPS $0,X1,ret+8(FP)\nRET\n" +
+		"TEXT stores(SB),4,$0-12\nMOVL $0x87654321,CX\nMOVD CX,X1\nVEXTRACTPS $0,X1,a+0(FP)\nMOVBLZX a+0(FP),AX\nMOVBLZX b+1(FP),BX\nSHLL $8,BX\nORL BX,AX\nMOVBLZX c+2(FP),BX\nSHLL $16,BX\nORL BX,AX\nMOVBLZX d+3(FP),BX\nSHLL $24,BX\nORL BX,AX\nMOVL AX,ret+8(FP)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	pkg := mustGoPackage(t, "oracle", "package oracle\nfunc fields(a,b,c,d byte) uint32\nfunc stores(a,b,c,d byte) uint32\n")
+	sigs := map[string]FuncSig{}
+	for _, name := range []string{"fields", "stores"} {
+		decl := pkg.Types.Scope().Lookup(name).(*types.Func)
+		sig, err := DeriveGoFuncABI0Signature(name, decl, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(sig.Frame.Params) != 4 || len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 8 {
+			t.Fatalf("actual AMD64 ABI0 four-byte fields/result layout changed: %+v", sig.Frame)
+		}
+		sigs[name] = sig
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t fields(uint8_t,uint8_t,uint8_t,uint8_t);
+extern uint32_t stores(uint8_t,uint8_t,uint8_t,uint8_t);
+int main(void) {
+ for(unsigned i=0;i<256;i++) {
+  uint8_t a=i,b=i*37,c=i*59,d=i*71;
+  uint32_t want=(uint32_t)a|((uint32_t)b<<8)|((uint32_t)c<<16)|((uint32_t)d<<24);
+  uint32_t got=fields(a,b,c,d);
+  if(got!=want){fprintf(stderr,"independent FP fields got=%x want=%x\n",got,want);return 1;}
+  got=stores(a,b,c,d);
+  if(got!=UINT32_C(0x87654321)){fprintf(stderr,"independent FP stores got=%x\n",got);return 2;}
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "insert-extract-independent-fp", triple, ir, reference, prefix)
+}
+
+func x86InsertExtractNumericalRows() []string {
+	rows := x86InsertExtractFormats()
+	// Actual source/destination aliases plus every imm8 selector bit for the
+	// PS forms. Chunk immediates ignore their high bits, independently tested.
+	for _, row := range x86InsertExtractFormats() {
+		if strings.Contains(row, "(BX)") || strings.Contains(row, "K1") || strings.Contains(row, "PS ") {
+			continue
+		}
+		if strings.HasPrefix(row, "VINSERT") {
+			rows = append(rows, strings.TrimSuffix(row, "2")+"1", strings.TrimSuffix(row, "2")+"0")
+		} else {
+			rows = append(rows, strings.TrimSuffix(row, "0")+"1")
+		}
+		rows = append(rows, strings.Replace(row, "$255", "$0", 1))
+	}
+	for _, imm := range []int{0, 16, 32, 48, 64, 128, 192, 1, 2, 4, 8, 15, 255} {
+		rows = append(rows, fmt.Sprintf("VINSERTPS $%d,X0,X1,X2", imm), fmt.Sprintf("VINSERTPS $%d,(BX),X1,X1", imm), fmt.Sprintf("VEXTRACTPS $%d,X1,R8", imm))
+		rows = append(rows, fmt.Sprintf("INSERTPS $%d,X0,X1", imm), fmt.Sprintf("INSERTPS $%d,(BX),X1", imm))
+	}
+	for lane := 0; lane < 4; lane++ {
+		rows = append(rows, fmt.Sprintf("EXTRACTPS $%d,X1,R8", lane))
+	}
+	rows = append(rows, "INSERTPS $128,X1,X1", "INSERTPS $192,X1,X0", "INSERTPS $64,X0,X0")
+	return rows
+}
+
+func x86InsertExtractRuntimeCheck(name string, parameters ...int) string {
+	var call strings.Builder
+	fmt.Fprintf(&call, "if(check(%s", name)
+	for _, parameter := range parameters {
+		fmt.Fprintf(&call, ",%d", parameter)
+	}
+	// Preserve the case identity in text; a process exit status must never
+	// wrap a large generated index to zero on Unix.
+	fmt.Fprintf(&call, ")) { fprintf(stderr, %q); return 1; }\n", name+" numerical/canary failure\n")
+	return call.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86InsertExtractByteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	rows := x86InsertExtractNumericalRows()
+	for index, row := range rows {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		op := strings.Fields(row)[0]
+		insert, scalar, memory, masked := strings.Contains(op, "INSERT"), strings.HasSuffix(op, "PS"), strings.Contains(row, "(BX)"), strings.Contains(row, "K1")
+		if !insert && memory && masked {
+			continue // physical native E6NF objects are checked separately; AVX512 execution is not available here
+		}
+		chunk, width, laneBytes := 16, 32, 4
+		if strings.Contains(op, "X8") || strings.Contains(op, "64X4") {
+			chunk = 32
+		}
+		if strings.Contains(op, "64X") {
+			laneBytes = 8
+		}
+		if strings.Contains(row, ",Z") {
+			width = 64
+		}
+		if scalar {
+			chunk, width = 4, 16
+		}
+		destination := ins.Args[len(ins.Args)-1]
+		store := ""
+		if destination.Kind == OpReg {
+			if scalar && !insert {
+				// AX is the output address, so choose a non-address GP result.
+				row = strings.TrimSuffix(row, string(destination.Reg)) + "R8"
+				store = "MOVQ R8,(AX)\n"
+			} else {
+				store = fmt.Sprintf("VMOVUPS %s,(AX)\n", x86CallerVectorRoot(destination.Reg))
+			}
+		} else {
+			row = strings.Replace(row, "(BX)", "(AX)", 1)
+		}
+		name := fmt.Sprintf("transfer%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),R9\nKMOVQ R9,K1\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nSTC\n%s\n%sSETCS 64(AX)\nRET\n", name, row, store)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*,uint64_t);\n", name)
+		checks.WriteString(x86InsertExtractRuntimeCheck(name,
+			x86FloatAddSubBoolInt(insert), x86FloatAddSubBoolInt(scalar), chunk, width, laneBytes, int(ins.Args[0].Imm),
+			x86FloatAddSubBoolInt(memory), x86FloatAddSubBoolInt(masked), x86FloatAddSubBoolInt(strings.Contains(op, ".Z")), x86FloatAddSubBoolInt(destination.Kind == OpReg), x86FloatAddSubBoolInt(!strings.HasPrefix(op, "V")),
+			x86FloatAddSubBoolInt(ins.Args[1].Reg == "X1"), x86FloatAddSubBoolInt(!strings.HasPrefix(op, "V") && destination.Reg == "X0")))
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+typedef void(*transfer)(void*,const void*,const void*,uint64_t);
+__attribute__((noinline)) static int check(transfer fn,int insert,int scalar,int chunk,int width,int laneBytes,unsigned imm,int memory,int masked,int zero,int reg,int legacy,int sourceB,int baseA) {
+ const uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_C(0xffffffffffffffff),UINT64_C(0xffff000000000000)};
+ for(unsigned vector=0;vector<8;vector++)for(unsigned m=0;m<5;m++) {
+  uint8_t as[67],bs[67],out[67],want[64],aCopy[67],bCopy[67];uint8_t *a=as+1,*b=bs+1;
+  memset(as,0xa7,67);memset(bs,0xb9,67);memset(out,0xc3,67);
+  for(unsigned i=0;i<64;i++){a[i]=(i*31+vector*17)^0x81;b[i]=(i*13+vector*29)^0x27;}
+  memcpy(aCopy,as,67);memcpy(bCopy,bs,67);memset(want,reg&&!(scalar&&!insert)?0:0xc3,64);
+  const uint8_t *base=baseA?a:b,*insertSource=sourceB?b:a;
+  if(legacy&&insert)memcpy(want,base,64);
+  unsigned offset=(imm&(width/chunk-1))*chunk;
+  if(insert) {
+   memcpy(want,base,width);
+   if(scalar){offset=((imm>>4)&3)*4;memcpy(want+offset,insertSource+(memory?0:((imm>>6)&3)*4),4);
+    for(unsigned lane=0;lane<4;lane++)if(imm&(1u<<lane))memset(want+lane*4,0,4);
+   } else memcpy(want+offset,insertSource,chunk);
+  } else {memcpy(want,b+offset,chunk);if(scalar&&reg)memset(want+4,0,4);}
+  unsigned result=insert?width:chunk;
+  if(masked)for(unsigned lane=0;lane<result/laneBytes;lane++)if(!(masks[m]&(UINT64_C(1)<<lane))) {
+   if(zero)memset(want+lane*laneBytes,0,laneBytes);else memcpy(want+lane*laneBytes,(insert?b:a)+lane*laneBytes,laneBytes);
+  }
+  unsigned csr=0x9fc5,observed;__asm__ volatile("ldmxcsr %0"::"m"(csr));
+  fn(out+1,a,b,masks[m]);__asm__ volatile("stmxcsr %0":"=m"(observed));
+  for(unsigned i=0;i<64;i++)if(out[i+1]!=want[i]){fprintf(stderr,"transfer byte %u got=%x want=%x insert=%d scalar=%d chunk=%d width=%d imm=%u mask=%llx\n",i,out[i+1],want[i],insert,scalar,chunk,width,imm,(unsigned long long)masks[m]);return 1;}
+  if(out[0]!=0xc3||out[65]!=1||out[66]!=0xc3||memcmp(as,aCopy,67)||memcmp(bs,bCopy,67)||observed!=csr)return 2;
+ }
+ return 0;
+}
+`
+	main := reference + declarations.String() + "int main(void){\n" + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "insert-extract-byte-semantics", triple, ir, main, prefix)
+	t.Logf("%d independent original-Go forms/aliases/immediates x40 byte/MXCSR/CF/upper-zero/input-output canary vectors", len(sigs))
+}
+
+func x86InactiveInsertFaultSource(name, row string) string {
+	// Legacy INSERTPS preserves wider aliases even if all four X lanes are
+	// zeroed. The following complete Z store must not observe unknown bytes.
+	return fmt.Sprintf("TEXT %s(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ input+8(FP),BX\nMOVQ $0,CX\nKMOVQ CX,K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nVMOVUPS Z2,(AX)\nRET\n", name, row)
+}
+
+func TestX86LegacyInsertCannotInventObservedUpperBytes(t *testing.T) {
+	source := x86InactiveInsertFaultSource("fault", "INSERTPS $15,(BX),X2")
+	const seed = "VPXORD Z2,Z2,Z2\n"
+	if strings.Count(source, seed) != 1 {
+		t.Fatal("complete legacy fault fixture lost its unique wide source definition")
+	}
+	source = strings.Replace(source, seed, "", 1)
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func fault(out,input *byte)", "amd64", target.triple, api)
+				x86VectorScratchCodegenControl(t, source, "func fault(out,input *byte)", "amd64", target.triple, ir, err)
+			})
+		}
+	}
+}
+
+func TestX86InactiveInsertFaultSourceDefinesEveryObservedVectorByte(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, row := range []string{
+		"VINSERTF32X4.Z $1,(BX),Y1,K1,Y2", "VINSERTI64X4.Z $1,(BX),Z1,K1,Z2", "VINSERTPS $15,(BX),X1,X2", "INSERTPS $15,(BX),X2",
+	} {
+		source := x86InactiveInsertFaultSource("fault", row)
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+		for _, target := range x86RawReturnTargets {
+			if target.arch != "amd64" {
+				continue // These original fixture rows include AMD64 EVEX forms.
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func fault(out,input *byte)", "amd64", target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original fault fixture observes undefined vector bytes", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86InsertInactiveMemoryStillFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, rows strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range []string{
+		"VINSERTF32X4.Z $1,(BX),Y1,K1,Y2", "VINSERTI64X4.Z $1,(BX),Z1,K1,Z2", "VINSERTPS $15,(BX),X1,X2", "INSERTPS $15,(BX),X2",
+	} {
+		name := fmt.Sprintf("fault%d", index)
+		source.WriteString(x86InactiveInsertFaultSource(name, row))
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*);\n", name)
+		fmt.Fprintf(&declarations, `static int observe%d(const uint8_t *input) {
+    uint8_t output[66];
+    memset(output, 0xc3, sizeof(output));
+    %s(output + 1, input);
+    return output[0] != 0xc3 || output[65] != 0xc3;
+}
+`, index, name)
+		width := []int{16, 32, 4, 4}[index]
+		fmt.Fprintf(&rows, "{observe%d, %d, %d},\n", index, width, width/2)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86MemoryFaultDriver(declarations.String(), rows.String())
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "insert-inactive-memory-fault", ir, main, level)
+			x86CheckMemoryFaultMatrix(t, execution, executable, 4)
+		})
+	}
+}
diff --git a/amd64_insert_extract_oracle_test.go b/amd64_insert_extract_oracle_test.go
new file mode 100644
index 000000000..bc3abda9d
--- /dev/null
+++ b/amd64_insert_extract_oracle_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86InsertExtractOracleCannotWrapFailureToSuccess(t *testing.T) {
+	rows := x86InsertExtractNumericalRows()
+	if len(rows) != 290 {
+		t.Fatalf("complete independent insert/extract matrix: got %d, want 290", len(rows))
+	}
+	// This is a live entry, not one of the separately owned masked native
+	// stores. Its old index+1 exit status was 256 and wrapped to success.
+	if strings.Contains(rows[255], "K1") {
+		t.Fatalf("selected mutation no longer belongs to this runtime matrix: %s", rows[255])
+	}
+	program := `#include <stdio.h>
+static void transfer255(void) {}
+static int check(void (*fn)(void), ...) { return 1; }
+int main(void) {
+` + x86InsertExtractRuntimeCheck("transfer255", make([]int, 13)...) + "return 0;\n}\n"
+	requireX86GeneratedOracleFailure(t, program, "transfer255 numerical/canary failure")
+}
diff --git a/amd64_insert_extract_sdk_source_test.go b/amd64_insert_extract_sdk_source_test.go
new file mode 100644
index 000000000..c37f87a87
--- /dev/null
+++ b/amd64_insert_extract_sdk_source_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestX86InsertExtractActualSDKTablesAreMandatory(t *testing.T) {
+	const rootName = "TestX86InsertExtractEveryGoOpcodeAttribute"
+	for _, name := range []string{"avx_optabs.go", "asm6.go"} {
+		t.Run(name, func(t *testing.T) {
+			// Execute the actual attribute root from this SDK's test binary.
+			// A partial fixture GOROOT supplies no replacement encoder evidence.
+			fixture := t.TempDir()
+			directory := filepath.Join(fixture, "src", "cmd", "internal", "obj", "x86")
+			if err := os.MkdirAll(directory, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if name == "asm6.go" {
+				original, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "avx_optabs.go"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(directory, "avx_optabs.go"), original, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			missing := filepath.Join(directory, name)
+			if _, err := os.ReadFile(missing); !os.IsNotExist(err) {
+				t.Fatalf("missing-table fixture is not absent: %v", err)
+			}
+
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+			defer cancel()
+			command := exec.CommandContext(ctx, os.Args[0], "-test.run=^"+rootName+"$", "-test.count=1", "-test.timeout=20s")
+			for _, item := range os.Environ() {
+				if !strings.HasPrefix(item, "GOROOT=") {
+					command.Env = append(command.Env, item)
+				}
+			}
+			command.Env = append(command.Env, "GOROOT="+fixture)
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			exit, plainExit := err.(*exec.ExitError)
+			if ctx.Err() != nil || !plainExit || exit.ProcessState == nil ||
+				!exit.ProcessState.Exited() || exit.ExitCode() != 1 {
+				t.Fatalf("actual SDK-table root did not fail with plain exit 1: %v (context %v)\n%s", err, ctx.Err(), output)
+			}
+
+			// Bind the complete failure to this one root, its real source file,
+			// and the exact missing table. Panics, cleanup errors, extra failures,
+			// unrelated diagnostics and a PASS from version-return are not evidence.
+			_, missingErr := os.ReadFile(missing)
+			if !os.IsNotExist(missingErr) {
+				t.Fatalf("missing-table fixture changed during the child: %v", missingErr)
+			}
+			if !x86InsertExtractMissingTableOutput(output, rootName, missingErr.Error(), testing.CoverMode() != "") {
+				t.Fatalf("unbound actual SDK-table failure (want %s):\n%s", missing, output)
+			}
+			t.Logf("actual %s child: plain exit 1, exact %s diagnostic\n%s", runtime.Version(), name, output)
+		})
+	}
+}
+
+func x86InsertExtractMissingTableOutput(output []byte, root, diagnostic string, covered bool) bool {
+	pattern := fmt.Sprintf(`\A--- FAIL: %s \([0-9]+\.[0-9]+s\)\n    amd64_insert_extract_forms_test\.go:[0-9]+: %s\nFAIL\n`,
+		regexp.QuoteMeta(root), regexp.QuoteMeta(diagnostic))
+	if covered {
+		// The child is this same instrumented test binary. Require Go's one
+		// coverage trailer only in that role; never strip arbitrary output.
+		// Go 1.20's coverage writer also prints this exact package prefix.
+		pattern += `(?:\tgithub\.com/xgo-dev/plan9asm\t)?coverage: (?:(?:[0-9]|[1-9][0-9])\.[0-9]|100\.0)% of statements\n`
+	}
+	return regexp.MustCompile(pattern + `\z`).Match(output)
+}
+
+func TestX86InsertExtractMissingTableOutputGrammar(t *testing.T) {
+	const root, diagnostic = "TestActualTable", "open exact/asm6.go: missing table"
+	base := "--- FAIL: " + root + " (0.01s)\n    amd64_insert_extract_forms_test.go:66: " + diagnostic + "\nFAIL\n"
+	const trailer = "coverage: 0.2% of statements\n"
+	for _, covered := range []bool{false, true} {
+		valid := base
+		if covered {
+			valid += trailer
+		}
+		if !x86InsertExtractMissingTableOutput([]byte(valid), root, diagnostic, covered) {
+			t.Fatalf("exact original failure rejected (coverage=%v)", covered)
+		}
+		for _, invalid := range []string{
+			valid + "PASS\n", "panic: unrelated\n" + valid, valid + trailer,
+			strings.Replace(valid, "exact/asm6.go", "other/asm6.go", 1),
+			strings.Replace(valid, root, "TestAnotherRoot", 1),
+		} {
+			if x86InsertExtractMissingTableOutput([]byte(invalid), root, diagnostic, covered) {
+				t.Fatalf("unbound child failure accepted (coverage=%v): %q", covered, invalid)
+			}
+		}
+	}
+	if x86InsertExtractMissingTableOutput([]byte(base), root, diagnostic, true) ||
+		x86InsertExtractMissingTableOutput([]byte(base+trailer), root, diagnostic, false) {
+		t.Fatal("child borrowed the wrong coverage instrumentation role")
+	}
+	if !x86InsertExtractMissingTableOutput([]byte(base+"\tgithub.com/xgo-dev/plan9asm\t"+trailer), root, diagnostic, true) ||
+		x86InsertExtractMissingTableOutput([]byte(base+"\tother/package\t"+trailer), root, diagnostic, true) {
+		t.Fatal("historical coverage trailer lost its exact package identity")
+	}
+}
diff --git a/amd64_integer_lane_mask_test.go b/amd64_integer_lane_mask_test.go
new file mode 100644
index 000000000..111b274dd
--- /dev/null
+++ b/amd64_integer_lane_mask_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Include narrow conversion results as well as whole X/Y/Z carriers. This
+// independent helper domain is a superset of the current typed callers, not an
+// inventory or execution certificate for the instructions which call it.
+func x86IntegerLaneMaskShapes() []struct{ lanes, bits int } {
+	var shapes []struct{ lanes, bits int }
+	for _, bits := range []int{8, 16, 32, 64} {
+		for lanes := 1; lanes <= 64 && lanes*bits <= 512; lanes *= 2 {
+			shapes = append(shapes, struct{ lanes, bits int }{lanes, bits})
+		}
+	}
+	return shapes
+}
+
+func TestX86IntegerLaneMaskBoundedVectorIR(t *testing.T) {
+	for _, shape := range x86IntegerLaneMaskShapes() {
+		for _, zeroing := range []bool{false, true} {
+			name := fmt.Sprintf("%dxi%d/zeroing=%t", shape.lanes, shape.bits, zeroing)
+			t.Run(name, func(t *testing.T) {
+				var body strings.Builder
+				ctx := &amd64Ctx{b: &body}
+				result := amd64ApplyIntegerLaneMask(ctx, shape.lanes, shape.bits,
+					"%computed", "%unavailableOld", "%mask", zeroing)
+				ir := body.String()
+				if got := strings.Count(ir, " = "); got != 5 {
+					t.Fatalf("mask helper emitted %d instructions; want five independent of lane count:\n%s", got, ir)
+				}
+				for _, forbidden := range []string{"extractelement", "select i1 ", "bitcast i64", "lshr i64"} {
+					if strings.Contains(ir, forbidden) {
+						t.Fatalf("lane mask expanded scalar operations or used endian-dependent packing %q:\n%s", forbidden, ir)
+					}
+				}
+				for _, want := range []string{
+					fmt.Sprintf("lshr <%d x i64>", shape.lanes),
+					fmt.Sprintf("trunc <%d x i64>", shape.lanes),
+					fmt.Sprintf("select <%d x i1>", shape.lanes),
+				} {
+					if !strings.Contains(ir, want) {
+						t.Fatalf("mask predicate lacks %q:\n%s", want, ir)
+					}
+				}
+				if zeroing && strings.Contains(ir, "%unavailableOld") {
+					t.Fatal("zeroing read the unavailable old destination")
+				}
+				if !zeroing && strings.Count(ir, "%unavailableOld") != 1 {
+					t.Fatal("merge must select the old vector exactly once")
+				}
+				if !strings.Contains(ir, result+" = select ") {
+					t.Fatal("helper did not return the selected vector")
+				}
+			})
+		}
+	}
+}
+
+func TestX86IntegerLaneMaskEmptyShape(t *testing.T) {
+	for _, lanes := range []int{-1, 0} {
+		for _, zeroing := range []bool{false, true} {
+			var body strings.Builder
+			ctx := &amd64Ctx{b: &body}
+			want := "%old"
+			if zeroing {
+				want = "zeroinitializer"
+			}
+			got := amd64ApplyIntegerLaneMask(ctx, lanes, 8, "%computed", "%old", "%mask", zeroing)
+			if got != want || body.Len() != 0 {
+				t.Fatalf("empty shape lanes=%d zeroing=%t emitted %q, %q", lanes, zeroing, got, body.String())
+			}
+		}
+	}
+}
+
+// Exercise the helper's emitted LLVM with an independent byte-selection C
+// oracle. No native ISA attributes or scalar-mask bitcasts are needed. Physical
+// x86 instruction behavior and active-lane memory faults retain separate owners.
+func TestX86IntegerLaneMaskPortableSemantics(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var module, prototypes, checks strings.Builder
+	count := 0
+	for _, shape := range x86IntegerLaneMaskShapes() {
+		for _, zeroing := range []bool{false, true} {
+			name := fmt.Sprintf("laneMask%d", count)
+			count++
+			vec := fmt.Sprintf("<%d x i%d>", shape.lanes, shape.bits)
+			fmt.Fprintf(&module, "define void @%s(ptr %%out, ptr %%input, ptr %%prior, i64 %%mask) {\n", name)
+			fmt.Fprintf(&module, "  %%computed = load %s, ptr %%input, align 1\n", vec)
+			if !zeroing {
+				fmt.Fprintf(&module, "  %%old = load %s, ptr %%prior, align 1\n", vec)
+			}
+			ctx := &amd64Ctx{b: &module}
+			result := amd64ApplyIntegerLaneMask(ctx, shape.lanes, shape.bits, "%computed", "%old", "%mask", zeroing)
+			fmt.Fprintf(&module, "  store %s %s, ptr %%out, align 1\n  ret void\n}\n", vec, result)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "    if (check(%s, %q, %d, %d, %t)) return 1;\n",
+				name, name, shape.lanes, shape.bits/8, zeroing)
+		}
+	}
+	if count != 44 {
+		t.Fatal("incomplete independent lane-mask shape/mode union", count)
+	}
+	driver := strings.NewReplacer("PROTOTYPES", prototypes.String(), "CHECKS", checks.String()).Replace(x86IntegerLaneMaskDriver)
+	ir := module.String()
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu"} {
+		t.Run("baseline-object/"+triple, func(t *testing.T) {
+			x86ResultInitializationObject(t, execution.llc, triple, ir, "lane-mask-baseline")
+		})
+	}
+	for _, optimized := range []bool{false, true} {
+		text := ir
+		if optimized {
+			text = x86MulDivRoundOptimize(t, ir)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(fmt.Sprintf("IR-O2=%t/%s", optimized, level), func(t *testing.T) {
+				execution.compileAndRunLLVM(t, "integer-lane-mask", text, driver, level)
+			})
+		}
+	}
+}
+
+const x86IntegerLaneMaskDriver = `
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+
+static int check(void (*fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t),
+                 const char *name, unsigned lanes, unsigned bytes, bool zeroing) {
+    uint64_t masks[69] = {0, UINT64_MAX, UINT64_C(0xaaaaaaaaaaaaaaaa), UINT64_C(0x5555555555555555)};
+    for (unsigned bit = 0; bit < 64; ++bit) {
+        masks[4+bit] = UINT64_C(1) << bit;
+    }
+    masks[68] = lanes == 64 ? 0 : UINT64_MAX << lanes;
+    for (unsigned sample = 0; sample < 8; ++sample) {
+        uint8_t input[66], prior[66], originalInput[66], originalPrior[66], output[66];
+        for (unsigned i = 0; i < 66; ++i) {
+            input[i] = (uint8_t)(sample*71 + i*29 + 1);
+            prior[i] = (uint8_t)(sample*13 - i*47 + 128);
+        }
+        memcpy(originalInput, input, sizeof(input));
+        memcpy(originalPrior, prior, sizeof(prior));
+        for (unsigned m = 0; m < 69; ++m) {
+            memset(output, 0xa7, sizeof(output));
+            fn(output+1, input+1, zeroing ? NULL : prior+1, masks[m]);
+            for (unsigned offset = 0; offset < 64; ++offset) {
+                uint8_t want = 0xa7;
+                if (offset < lanes*bytes) {
+                    unsigned active = (unsigned)((masks[m] >> (offset/bytes)) & 1);
+                    if (active) {
+                        want = input[offset+1];
+                    } else if (zeroing) {
+                        want = 0;
+                    } else {
+                        want = prior[offset+1];
+                    }
+                }
+                if (output[offset+1] != want) {
+                    fprintf(stderr, "%s sample=%u mask=%llx byte=%u got=%x want=%x\n",
+                            name, sample, (unsigned long long)masks[m], offset, output[offset+1], want);
+                    return 1;
+                }
+            }
+            if (output[0] != 0xa7 || output[65] != 0xa7 ||
+                memcmp(input, originalInput, sizeof(input)) || memcmp(prior, originalPrior, sizeof(prior))) {
+                fprintf(stderr, "%s changed inputs or output canaries\n", name);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+int main(void) {
+CHECKS
+    return 0;
+}
+`
diff --git a/amd64_integer_minmax_forms.go b/amd64_integer_minmax_forms.go
new file mode 100644
index 000000000..10c139bea
--- /dev/null
+++ b/amd64_integer_minmax_forms.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86IntegerMinMaxForm struct {
+	x86PackedBinaryForm
+	spec amd64PackedIntegerMinMaxSpec
+}
+
+func x86IntegerMinMaxProperties(op Op, ins Instr, arch string) (x86IntegerMinMaxForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedIntegerMinMaxSpecs[base]
+	legacy := false
+	if !known && (strings.HasPrefix(base, "PMIN") || strings.HasPrefix(base, "PMAX")) {
+		// The twelve legacy B/W/D names have the same operation as their
+		// V siblings, but Go's yxm/yxm_q4 rows admit only X, not MMX/Q.
+		spec, known = amd64PackedIntegerMinMaxSpecs["V"+base]
+		known = known && spec.laneBits <= 32
+		legacy = known
+	}
+	form := x86IntegerMinMaxForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return form, true, fmt.Errorf("min/max dispatch/source opcode mismatch")
+	}
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}
+	if legacy {
+		grammar = x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}
+	} else if spec.laneBits == 64 {
+		grammar.encoding = x86PackedLogicalEVEX
+	}
+	if spec.broadcast && !legacy {
+		grammar.broadcastBytes = spec.laneBits / 8
+	}
+	local := ins
+	local.Op = op
+	// Physical mode32 EVEX bytes have mask operands even though Go's named
+	// frontend caps instruction arity at three. Preserve that decoder-only
+	// shape; whole-function replay and numerical inputs remain separate checks.
+	physical := !legacy && ins.x86Encoded && x86RawOrdinaryVectorSource(ins, arch)
+	var err error
+	form.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, grammar, physical)
+	return form, true, err
+}
+
+func x86TypedIntegerMinMaxByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86IntegerMinMaxProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: width, read: true, write: form.legacy},
+	}}
+	if !form.legacy {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.destination, operand: ins.Args[form.destination], width: width,
+			read: form.mask >= 0 && !form.zeroing, write: true,
+		})
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_integer_splat_test.go b/amd64_integer_splat_test.go
new file mode 100644
index 000000000..b45f539c3
--- /dev/null
+++ b/amd64_integer_splat_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestLLVMIntegerSplatsPreserveExactText(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		bits    int
+		value   int64
+		element string
+	}{
+		{"zero", 8, 0, "i8 0"},
+		{"boolean", 1, 1, "i1 1"},
+		{"negative-byte", 8, -128, "i8 -128"},
+		{"negative-saturation", 32, -32768, "i32 -32768"},
+		{"positive-saturation", 32, 32767, "i32 32767"},
+		{"all-ones", 64, -1, "i64 -1"},
+		{"minimum", 64, -1 << 63, "i64 -9223372036854775808"},
+		{"maximum", 64, 1<<63 - 1, "i64 9223372036854775807"},
+		{"wide-carrier", 128, -1 << 63, "i128 -9223372036854775808"},
+	} {
+		t.Run("signed/"+test.name, func(t *testing.T) {
+			checkIntegerSplatText(t, test.element, func(lanes int) string {
+				return llvmSplatSignedInteger(lanes, test.bits, test.value)
+			})
+		})
+	}
+	for _, test := range []struct {
+		name    string
+		bits    int
+		value   uint64
+		element string
+	}{
+		{"zero", 8, 0, "i8 0"},
+		{"boolean", 1, 1, "i1 1"},
+		{"byte-mask", 8, 255, "i8 255"},
+		{"word-mask", 16, 65535, "i16 65535"},
+		{"dword-mask", 32, 4294967295, "i32 4294967295"},
+		{"high-bit", 64, 1 << 63, "i64 9223372036854775808"},
+		{"maximum", 64, ^uint64(0), "i64 18446744073709551615"},
+		{"wide-carrier", 128, ^uint64(0), "i128 18446744073709551615"},
+	} {
+		t.Run("unsigned/"+test.name, func(t *testing.T) {
+			checkIntegerSplatText(t, test.element, func(lanes int) string {
+				return llvmSplatInteger(lanes, test.bits, test.value)
+			})
+		})
+	}
+}
+
+// The decimal spellings above are independent literal expectations. This
+// oracle constructs a slice and joins it; it does not reuse the formatter or
+// production builder, and includes the existing empty result for lanes <= 0.
+func checkIntegerSplatText(t *testing.T, element string, splat func(int) string) {
+	t.Helper()
+	for _, lanes := range []int{-2, 0, 1, 2, 4, 16, 64, 256} {
+		t.Run(fmt.Sprint(lanes), func(t *testing.T) {
+			var elements []string
+			for lane := 0; lane < lanes; lane++ {
+				elements = append(elements, element)
+			}
+			want := "<" + strings.Join(elements, ", ") + ">"
+			if got := splat(lanes); got != want {
+				t.Fatalf("splat(%d): got %q, want %q", lanes, got, want)
+			}
+		})
+	}
+}
+
+func TestLLVMIntegerSplatsHaveBoundedAllocationGrowth(t *testing.T) {
+	for _, test := range integerSplatAllocationCases() {
+		t.Run(test.name, func(t *testing.T) {
+			var result string
+			small := testing.AllocsPerRun(20, func() {
+				result = test.splat(1)
+			})
+			large := testing.AllocsPerRun(20, func() {
+				result = test.splat(256)
+			})
+			if strings.Count(result, ", ") != 255 {
+				t.Fatal("allocation check did not produce all 256 lanes")
+			}
+			// Formatting and output storage may allocate a small constant
+			// amount. Neither per-lane boxing nor repeated builder growth is
+			// part of the contract; retain room for SDK formatting overhead.
+			if large > small+1 || large > 8 {
+				t.Fatalf("allocations grow with lane count: 1 lane=%g, 256 lanes=%g", small, large)
+			}
+		})
+	}
+}
+
+func integerSplatAllocationCases() []struct {
+	name  string
+	splat func(int) string
+} {
+	return []struct {
+		name  string
+		splat func(int) string
+	}{
+		{"signed-min", func(lanes int) string { return llvmSplatSignedInteger(lanes, 64, -1<<63) }},
+		{"signed-saturation", func(lanes int) string { return llvmSplatSignedInteger(lanes, 32, -32768) }},
+		{"unsigned-max", func(lanes int) string { return llvmSplatInteger(lanes, 64, ^uint64(0)) }},
+		{"unsigned-byte", func(lanes int) string { return llvmSplatInteger(lanes, 8, 255) }},
+	}
+}
+
+var integerSplatBenchmarkSink string
+
+func BenchmarkLLVMIntegerSplats(b *testing.B) {
+	for _, test := range integerSplatAllocationCases() {
+		b.Run(test.name, func(b *testing.B) {
+			for _, lanes := range []int{1, 16, 64, 256} {
+				b.Run(fmt.Sprint(lanes), func(b *testing.B) {
+					b.SetBytes(int64(len(test.splat(lanes))))
+					b.ReportAllocs()
+					b.ResetTimer()
+					for iteration := 0; iteration < b.N; iteration++ {
+						integerSplatBenchmarkSink = test.splat(lanes)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_lea_byte_effects.go b/amd64_lea_byte_effects.go
new file mode 100644
index 000000000..a6b2b3f55
--- /dev/null
+++ b/amd64_lea_byte_effects.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// This describes only the pure numerical effective-address subset of Go's
+// complete ym_rl grammar. The register dependencies are read before the
+// destination is overwritten; no memory is read and FLAGS are unchanged.
+// Modulo-W/L/Q arithmetic needs only those low input bytes. A W write keeps
+// the other bytes, while L clears upper32 through the existing write consumer.
+// Actual initialization and pointer exclusion remain consumers' obligations.
+func x86TypedLEAByteEffect(op Op, original Instr, arch string) (x86TypedByteEffect, bool, error) {
+	effect, known, err := x86NamedLEAByteEffect(op, original, arch)
+	if !known || err != nil {
+		return effect, known, err
+	}
+	// Ordinary source consumers leave physical frame registers to their
+	// independently bound stack route. This is a role constraint, not part
+	// of the complete encoding grammar used by fixed-frame consumers.
+	for _, operand := range effect.operands {
+		if x86LogicalSourceFrameRegister(operand.operand.Reg, arch) {
+			return x86TypedByteEffect{}, false, nil
+		}
+	}
+	return effect, true, nil
+}
+
+func x86NamedLEAByteEffect(op Op, original Instr, arch string) (x86TypedByteEffect, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	if name != "LEAW" && name != "LEAL" && name != "LEAQ" {
+		return x86TypedByteEffect{}, false, nil
+	}
+	// A decoded physical instruction belongs to its existing separate effect
+	// consumers. Do not intercept it with this named-source registration.
+	if original.x86Encoded || original.x86SourceRaw != nil || original.x86RawNearReturn != nil ||
+		original.x86AddressBits != 0 || original.x86UnboundAddressOverride || original.x86SegmentPrefix != 0 {
+		return x86TypedByteEffect{}, false, nil
+	}
+	fail := func() (x86TypedByteEffect, bool, error) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: %s %s needs a named Go effective-address form: %q", ErrProbeNeedsContext, arch, op, original.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		original.Op != "" && !strings.EqualFold(string(original.Op), name) {
+		return fail()
+	}
+	ins := original
+	ins.Op = Op(name)
+	ins = x86LEASourceInstruction(ins)
+	width, err := x86LEAOperandWidth(ins, arch)
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	if ins.Args[0].Kind != OpMem {
+		return fail()
+	}
+	memory := ins.Args[0].Mem
+	if memory.Sym != "" || memory.OffRaw != "" || memory.Segment != "" || memory.IndexExt != "" ||
+		memory.Index == "" && memory.Scale != 0 {
+		return fail()
+	}
+	effect := x86TypedByteEffect{}
+	for _, register := range []Reg{memory.Base, memory.Index} {
+		if register == "" {
+			continue
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: 0, operand: Operand{Kind: OpReg, Reg: register}, width: width, read: true,
+		})
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{
+		index: 1, operand: ins.Args[1], width: width, write: true,
+	})
+	return effect, true, nil
+}
diff --git a/amd64_lea_dispatch_test.go b/amd64_lea_dispatch_test.go
new file mode 100644
index 000000000..8c160d7e8
--- /dev/null
+++ b/amd64_lea_dispatch_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LEADispatchBindsCompleteWidths(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []Op{"LEAW", "LEAL", "LEAQ"} {
+			for _, instructionOp := range []Op{"", op, Op(strings.ToLower(string(op)))} {
+				t.Run(fmt.Sprintf("%s/%s/op=%q", arch, op, instructionOp), func(t *testing.T) {
+					instruction := Instr{Op: instructionOp, Args: []Operand{
+						{Kind: OpMem, Mem: MemRef{Base: BX, Index: CX, Scale: 2, Off: 8}},
+						{Kind: OpReg, Reg: AX},
+					}}
+					registered := instruction
+					registered.Op = op
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{registered}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := output.String()
+					ok, terminated, err := ctx.lowerArith(op, instruction)
+					if arch == "386" && op == "LEAQ" {
+						if !ok || terminated || err == nil || output.String() != before {
+							t.Fatalf("386 LEAQ must reject before emission: (%v, %v, %v)", ok, terminated, err)
+						}
+						return
+					}
+					if !ok || terminated || err != nil {
+						t.Fatalf("LEA dispatch = (%v, %v, %v)", ok, terminated, err)
+					}
+					if instruction.Op != instructionOp {
+						t.Fatal("dispatch mutated the caller's original instruction identity")
+					}
+					if op == "LEAW" && !strings.Contains(output.String()[len(before):], "to i16") ||
+						op == "LEAL" && !strings.Contains(output.String()[len(before):], "to i32") {
+						t.Fatal("LEA used a different destination width than the dispatch")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LEADispatchRejectsContradictoryIdentityBeforeEmission(t *testing.T) {
+	for _, dispatch := range []Op{"LEAW", "LEAL", "LEAQ"} {
+		for _, source := range []Op{"LEAW", "LEAL", "LEAQ", "LEAL.Z", "MOVQ", "UNKNOWN"} {
+			if source == dispatch {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/source=%s", dispatch, source), func(t *testing.T) {
+				instruction := Instr{Op: source, Args: []Operand{
+					{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}},
+					{Kind: OpReg, Reg: AX},
+				}}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+				before := output.String()
+				ok, terminated, err := ctx.lowerArith(dispatch, instruction)
+				if !ok || terminated || err == nil {
+					t.Fatalf("accepted an unknown/contradictory LEA identity: (%v, %v, %v)", ok, terminated, err)
+				}
+				if output.String() != before {
+					t.Fatal("contradictory LEA emitted address loads/truncation/stores before rejection")
+				}
+			})
+		}
+	}
+}
+
+func TestX86LEADispatchUnknownOpcodeCannotConsumeKnownInstruction(t *testing.T) {
+	for _, dispatch := range []Op{"UNKNOWN", "LEAL.Z", "leal"} {
+		for _, source := range []Op{"", "LEAW", "LEAL", "LEAQ", "UNKNOWN"} {
+			t.Run(fmt.Sprintf("%s/source=%q", dispatch, source), func(t *testing.T) {
+				instruction := Instr{Op: source, Args: []Operand{
+					{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}},
+					{Kind: OpReg, Reg: AX},
+				}}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+				before := output.String()
+				ok, terminated, _ := ctx.lowerArith(dispatch, instruction)
+				if ok || terminated || output.String() != before {
+					t.Fatal("unknown arithmetic dispatch was treated as an emitted LEA")
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lea_effects.go b/amd64_lea_effects.go
new file mode 100644
index 000000000..91780bbcb
--- /dev/null
+++ b/amd64_lea_effects.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Go 1.27's ALEAW/ALEAL/ALEAQ rows all use ym_rl (Ym, Yrl). Address
+// calculation and destination width are independent: W preserves the upper
+// register, L zero-extends, and Q is available only in 64-bit mode.
+func x86LEAWidth(op Op, arch string) int64 {
+	switch op {
+	case "LEAW":
+		return 2
+	case "LEAL":
+		return 4
+	case "LEAQ":
+		if arch != "386" {
+			return 8
+		}
+	}
+	return 0
+}
+
+func x86LEAOperandWidth(ins Instr, arch string) (int64, error) {
+	ins = x86LEASourceInstruction(ins)
+	width := x86LEAWidth(ins.Op, arch)
+	if width == 0 {
+		return 0, fmt.Errorf("%s %s has no Go LEA width: %q", arch, ins.Op, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg || !isX86YrlRegisterForArch(ins.Args[1].Reg, arch) {
+		return 0, fmt.Errorf("%s %s expects Ym address and Yrl destination: %q", arch, ins.Op, ins.Raw)
+	}
+	if bits := ins.x86AddressBits; bits != 0 && (ins.Args[0].Kind != OpMem ||
+		!(arch == "386" && bits == 16 || arch != "386" && bits == 32)) {
+		return 0, fmt.Errorf("%w: %s %s has an unbound physical address size %d", ErrProbeNeedsContext, arch, ins.Op, bits)
+	}
+	switch ins.Args[0].Kind {
+	case OpMem:
+		memory := ins.Args[0].Mem
+		if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+			return 0, err
+		}
+		if arch == "386" && strings.HasSuffix(memory.Sym, "(SB)") {
+			memory.Base = "" // Go's named-memory encoder discards Reg.
+		}
+		if !x86MemoryRegistersValidForArch(memory, arch) {
+			return 0, fmt.Errorf("%s %s source uses an out-of-range address register: %q", arch, ins.Op, ins.Raw)
+		}
+		if memory.Index != "" && (memory.Index == SP ||
+			memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8) {
+			return 0, fmt.Errorf("%s %s source has an unencodable SIB index/scale: %q", arch, ins.Op, ins.Raw)
+		}
+		// asm6.go:asmandsz truncates an AMD64 LEAL displacement to int32.
+		// Other AMD64 widths require signed int32; 386 also accepts uint32.
+		signed32 := memory.Off == int64(int32(memory.Off))
+		unsigned32 := memory.Off == int64(uint32(memory.Off))
+		if !(arch != "386" && width == 4) && !signed32 && !(arch == "386" && unsigned32) {
+			return 0, fmt.Errorf("%s %s displacement is outside Go's encoded address range: %q", arch, ins.Op, ins.Raw)
+		}
+	case OpSym:
+		if !strings.HasSuffix(strings.TrimSpace(ins.Args[0].Sym), "(SB)") || strings.HasPrefix(strings.TrimSpace(ins.Args[0].Sym), "$") {
+			return 0, fmt.Errorf("%s %s source is not a Go SB memory expression: %q", arch, ins.Op, ins.Raw)
+		}
+		fallthrough
+	case OpFP:
+		// Bound FP storage and symbol identity remain the actual lowerer's
+		// responsibility; this row does not establish pointer provenance.
+	default:
+		return 0, fmt.Errorf("%s %s expects Ym address and Yrl destination: %q", arch, ins.Op, ins.Raw)
+	}
+	return width, nil
+}
+
+// A bare integer expression is Go's TYPE_MEM/NAME_NONE displacement, not a
+// symbol or a dereference for LEA. Normalize only this local operand copy;
+// the original opcode, Raw and source/certificate identity remain unchanged.
+// Unknown expressions, address immediates and physical decoder roles retain
+// their separate grammar instead of acquiring a guessed zero displacement.
+func x86LEASourceInstruction(ins Instr) Instr {
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpSym || ins.x86Encoded || ins.x86SourceRaw != nil ||
+		ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return ins
+	}
+	if ins.Op != "LEAW" && ins.Op != "LEAL" && ins.Op != "LEAQ" {
+		return ins
+	}
+	value, resolved := parseImmExpr(strings.TrimSpace(ins.Args[0].Sym))
+	if !resolved {
+		return ins
+	}
+	ins.Args = append([]Operand(nil), ins.Args...)
+	ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Off: int64(value)}}
+	return ins
+}
+
+// Named TYPE_ADDR PARAM/AUTO moves form addresses, never DATA reads. Go's
+// progedit rewrites L/Q before table selection; W's Zaut_r emits word LEA.
+// This local view keeps the actual Op/Raw untouched for source replay. It
+// supplies syntax/width only, not a frame, initialized data or numerical bits.
+func x86NamedFrameMoveAddressInstruction(ins Instr, arch string) (Instr, bool, error) {
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpFPAddr && ins.Args[0].Kind != OpSym {
+		return ins, false, nil
+	}
+	op := x86SourceMoveInstruction(ins, arch).Op
+	if (op != "MOVW" && op != "MOVL" && op != "MOVQ") || !x86ResultNamedPredicateInstruction(ins) {
+		return ins, false, nil
+	}
+	var address Operand
+	switch source := ins.Args[0]; source.Kind {
+	case OpFPAddr:
+		if !validPPIdentifier(source.FPName) || x86SymbolGoRegisterName(source.FPName) ||
+			source.FPName == "FP" || source.FPName == "SB" || source.FPName == "PC" || arch == "amd64" && source.FPName == "g" {
+			return ins, true, fmt.Errorf("%w: named MOV FP address requires an original Go symbol", ErrProbeNeedsContext)
+		}
+		address = source
+		address.Kind = OpFP
+	case OpSym:
+		body := strings.TrimSpace(source.Sym)
+		if !strings.HasPrefix(body, "$") {
+			return ins, false, nil
+		}
+		body = strings.TrimSpace(strings.TrimPrefix(body, "$"))
+		literal := x86ResultAUTOLiteral.FindStringSubmatch(body)
+		if literal == nil {
+			return ins, false, nil // SB and unnamed addresses retain their own consumers.
+		}
+		prefix := strings.TrimSpace(literal[1])
+		_, named := parseNamedStackConstantOffset(prefix)
+		if validPPIdentifier(prefix) {
+			named = true
+		}
+		if !named {
+			return ins, false, nil // MOVW NAME_NONE falls through to TYPE_CONST, not Zaut_r.
+		}
+		var err error
+		address, err = parseOperandForArch(ArchAMD64, body)
+		if err != nil || address.Kind != OpMem || address.Mem.Base != SP {
+			return ins, true, fmt.Errorf("named MOV frame address has no complete AUTO operand")
+		}
+	default:
+		return ins, false, nil
+	}
+	// A local opcode view cannot repair stale parsed operands or discard the
+	// descriptive Go name. Replay the complete original two-operand spelling.
+	rawOp, rest := splitOpcode(ins.Raw)
+	literals := splitTopLevelCSV(rest)
+	if !strings.EqualFold(rawOp, string(ins.Op)) || len(literals) != len(ins.Args) {
+		return ins, true, fmt.Errorf("%w: named MOV frame address lacks its original spelling", ErrProbeNeedsContext)
+	}
+	for index, literal := range literals {
+		parsed, err := parseOperandForArch(Arch(arch), literal)
+		if err != nil || !reflect.DeepEqual(parsed, ins.Args[index]) {
+			return ins, true, fmt.Errorf("%w: named MOV frame address differs from its original operands", ErrProbeNeedsContext)
+		}
+	}
+	view := ins
+	view.Op = Op("LEA" + string(op)[3:])
+	view.Args = append([]Operand(nil), ins.Args...)
+	view.Args[0] = address
+	_, err := x86LEAOperandWidth(view, arch)
+	return view, true, err
+}
+
+func x86CallerLEAStep(ins *Instr, state *x86SourceStackState) bool {
+	form := x86LEASourceInstruction(*ins)
+	width, err := x86LEAOperandWidth(form, "amd64")
+	if err != nil || form.Args[0].Kind != OpMem || ins.x86AddressBits != 0 {
+		return false
+	}
+	memory := form.Args[0].Mem
+	destination, full := x86CallerGP(ins.Args[1].Reg)
+	if !full || destination != ins.Args[1].Reg || destination == SP || destination == BP ||
+		memory.Sym != "" || memory.Segment != "" {
+		return false
+	}
+	base, _ := x86CallerGP(memory.Base)
+	if pointer, present := state.callers[base]; present {
+		// Only the full, independently bound caller address survives. A
+		// narrowed address must not become numerical initialization; a
+		// variable offset cannot borrow this constant-offset certificate.
+		if width != 8 || memory.Base != base || memory.Index != "" ||
+			memory.Off < -x86SourceStackLimit || memory.Off > x86SourceStackLimit {
+			return false
+		}
+		var valid bool
+		pointer, valid = x86CallerPointerShift(pointer, memory.Off)
+		if !valid {
+			return false
+		}
+		state.callers[destination] = pointer
+		delete(state.known, destination)
+		return true
+	}
+	// Arithmetic modulo the result width depends only on those low input
+	// bytes. Multiplication/addition carry cannot invent any higher input
+	// dependency. NumericRead still rejects *all* pointer-derived inputs,
+	// including an index or a source/destination alias.
+	for _, register := range []Reg{memory.Base, memory.Index} {
+		if register != "" && !x86CallerNumericRead(Operand{Kind: OpReg, Reg: register}, width, state) {
+			return false
+		}
+	}
+	return x86CallerNumericWrite(destination, width, state)
+}
diff --git a/amd64_lea_go_oracle_receipt_test.go b/amd64_lea_go_oracle_receipt_test.go
new file mode 100644
index 000000000..37e9b9ae9
--- /dev/null
+++ b/amd64_lea_go_oracle_receipt_test.go
@@ -0,0 +1,204 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// A test-only observation of this invocation, not a frame or caller capability.
+type x86LEAGoObjectReceipt struct {
+	Target, GoVersion      string
+	Source, Driver, Object [sha256.Size]byte
+}
+
+// These existing LEAW/L/Q source forms also belong to the historical SDK.
+// The generic current-table helper remains unchanged for other families.
+func requireLEANativeGoObject(t *testing.T, arch, source string, wantSuccess bool) {
+	t.Helper()
+	if wantSuccess {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, source)
+	} else {
+		x86LEAActualSDKDriver(t)
+		goAssemblerOracleOutput(t, arch, source, "", false)
+	}
+}
+
+func x86LEAActualSDKDriver(t *testing.T) (string, [sha256.Size]byte) {
+	t.Helper()
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err = filepath.EvalSymlinks(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root, err := filepath.EvalSymlinks(runtime.GOROOT())
+	if err != nil || driver != x86LEASDKDriverPath(root, runtime.GOOS) {
+		t.Fatalf("LEA oracle must invoke this SDK's driver: %s: %v", driver, err)
+	}
+	driverBytes, err := os.ReadFile(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return driver, sha256.Sum256(driverBytes)
+}
+
+func x86LEASDKDriverPath(root, hostGOOS string) string {
+	filename := "go"
+	if hostGOOS == "windows" {
+		filename = "go.exe"
+	}
+	return filepath.Join(root, "bin", filename)
+}
+
+func TestX86LEAActualSDKDriverPathUsesHostToolSuffix(t *testing.T) {
+	root := filepath.Join("selected-sdk", "root")
+	for _, test := range []struct {
+		goos, filename string
+	}{
+		{"windows", "go.exe"},
+		{"darwin", "go"},
+		{"linux", "go"},
+	} {
+		t.Run(test.goos, func(t *testing.T) {
+			got := x86LEASDKDriverPath(root, test.goos)
+			want := filepath.Join(root, "bin", test.filename)
+			if got != want {
+				t.Fatalf("actual SDK driver for host %s = %q, want %q", test.goos, got, want)
+			}
+		})
+	}
+}
+
+func x86LEAReadObjectReceipt(t *testing.T, arch, goos, source, input, driver string, driverHash [sha256.Size]byte, object string) *x86LEAGoObjectReceipt {
+	t.Helper()
+	info, err := os.Lstat(object)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("actual LEA oracle lacks a regular nonempty object: %v", err)
+	}
+	data, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	header := strings.Fields(string(bytes.SplitN(data, []byte("\n"), 2)[0]))
+	if len(header) < 5 || header[0] != "go" || header[1] != "object" ||
+		header[2] != goos || header[3] != arch || header[4] != runtime.Version() {
+		t.Fatalf("LEA object does not bind the actual target/SDK: %q", header)
+	}
+	inputBytes, err := os.ReadFile(input)
+	if err != nil || !bytes.Equal(inputBytes, []byte(source)) {
+		t.Fatalf("actual LEA source changed during the tool invocation: %v", err)
+	}
+	driverBytes, err := os.ReadFile(driver)
+	if err != nil || sha256.Sum256(driverBytes) != driverHash {
+		t.Fatalf("actual LEA driver changed during the tool invocation: %v", err)
+	}
+	receipt := &x86LEAGoObjectReceipt{
+		Target: goos + "/" + arch, GoVersion: header[4],
+		Source: sha256.Sum256(inputBytes), Driver: driverHash,
+		Object: sha256.Sum256(data),
+	}
+	t.Logf("actual LEA source/object receipt: SDK=%s target=%s source=%x driver=%x object=%x",
+		receipt.GoVersion, receipt.Target, receipt.Source, receipt.Driver, receipt.Object)
+	return receipt
+}
+
+func TestX86LEAActualGoOracleCannotSilentlyReturnBeforeTool(t *testing.T) {
+	for name, filename := range map[string]string{
+		"x86LEAActualTargetGoObject": "amd64_go_caller_lea_test.go",
+		"requireLEANativeGoObject":   "amd64_lea_go_oracle_receipt_test.go",
+	} {
+		file, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ast.Inspect(file, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if ok {
+				if identifier, ok := call.Fun.(*ast.Ident); ok && identifier.Name == "requireX86GoAssemblerResult" {
+					t.Errorf("%s uses a current-table helper instead of its actual applicable LEA tool oracle", filename)
+				}
+			}
+			return true
+		})
+		found := false
+		for _, declaration := range file.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Name.Name != name {
+				continue
+			}
+			found = true
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				if statement, ok := node.(*ast.ReturnStmt); ok {
+					missing := len(statement.Results) == 0
+					if len(statement.Results) == 1 {
+						value, ok := statement.Results[0].(*ast.Ident)
+						missing = ok && value.Name == "nil"
+					}
+					if missing {
+						t.Errorf("%s has a silent return instead of its actual tool receipt", name)
+					}
+				}
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				if identifier, ok := call.Fun.(*ast.Ident); ok &&
+					(identifier.Name == "goToolchainAtLeast" || identifier.Name == "currentGoMinorAtLeast") {
+					t.Errorf("%s silently gates its actual tool invocation by build version", name)
+				}
+				if selector, ok := call.Fun.(*ast.SelectorExpr); ok &&
+					(selector.Sel.Name == "Skip" || selector.Sel.Name == "Skipf" || selector.Sel.Name == "SkipNow") {
+					t.Errorf("%s cannot skip an applicable LEA source oracle", name)
+				}
+				return true
+			})
+		}
+		if !found {
+			t.Fatalf("actual LEA oracle %s is missing", name)
+		}
+	}
+}
+
+func TestX86LEAActualGoOracleRequiresToolAndObjectReceipt(t *testing.T) {
+	targets := map[string]string{
+		"x86_64-apple-darwin":      "darwin/amd64",
+		"x86_64-unknown-linux-gnu": "linux/amd64",
+		"x86_64-pc-windows-msvc":   "windows/amd64",
+		"i386-unknown-linux-gnu":   "linux/386",
+		"i686-pc-windows-msvc":     "windows/386",
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			if x86LEAWidth(Op("LEA"+suffix), target.arch) == 0 {
+				continue // No LEAQ physical encoding in 386 mode.
+			}
+			t.Run(target.triple+"/"+suffix, func(t *testing.T) {
+				source := "TEXT lea(SB),4,$0-0\nLEA" + suffix + " 19(AX)(BX*4),AX\nRET\n"
+				receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				if receipt == nil {
+					t.Fatal("actual LEA oracle omitted its selected SDK tool/object invocation")
+				}
+				zero := [sha256.Size]byte{}
+				if receipt.GoVersion != runtime.Version() || receipt.Source != sha256.Sum256([]byte(source)) ||
+					receipt.Driver == zero || receipt.Object == zero || receipt.Target != targets[target.triple] {
+					t.Fatalf("actual LEA receipt is incomplete or misbound: %+v", receipt)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_legacy_alternating_round_memory.go b/amd64_legacy_alternating_round_memory.go
new file mode 100644
index 000000000..9925939c3
--- /dev/null
+++ b/amd64_legacy_alternating_round_memory.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A paired legacy whole opcode supplies numerical bytes only on continuation.
+// It grants no pointee extent, stack backing, source or raw-entry permission.
+func x86LegacyAlternatingRoundMemorySource(ins Instr, source Operand, arch string) bool {
+	return x86ResultNamedPredicateInstruction(ins) &&
+		(source.Kind == OpMem || source.Kind == OpSym) && x86OrdinaryNativeMemoryOperand(source, arch)
+}
+
+// Both families consume their already normalized form. A ROUND immediate
+// distinguishes its unary packed result from ADDSUB's old-destination input;
+// scalar ROUND reads only copied upper bytes, not its overwritten low lane.
+func (c *amd64Ctx) emitLegacyAlternatingRoundMemory(ins Instr, form x86FloatBinaryForm, immediate *uint8) error {
+	source := ins.Args[form.first]
+	if !form.legacy || form.byteWidth != 16 || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+		!x86ResultNamedPredicateInstruction(ins) || !c.nativeMemoryOperand(ins, form.first) {
+		return fmt.Errorf("%w: %s needs its original ordinary legacy memory source", ErrProbeNeedsContext, ins.Op)
+	}
+	typ := amd64FMA3LLVMType(128/form.bits, form.bits)
+	input, inputType, constraint, template, err := c.nativeFloatingCompareSource(source,
+		x86FloatCompareForm{x86FloatBinaryForm: form}, typ, "")
+	if err != nil {
+		return err
+	}
+	args, constraints := inputType+" "+input, "=x,"+constraint
+	if immediate == nil || form.scalar {
+		old, err := c.loadX(ins.Args[form.destination].Reg)
+		if err != nil {
+			return err
+		}
+		carrier := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", carrier, old, typ)
+		args, constraints = typ+" %"+carrier+", "+args, "=x,0,"+constraint
+		template = strings.ReplaceAll(template, "$1", "$2")
+	}
+	assembly := strings.ToLower(string(ins.Op)) + " "
+	if immediate != nil {
+		assembly += fmt.Sprintf("$$%d, ", *immediate)
+	}
+	assembly += template + ", $0"
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, typ, result)
+	return c.storeX(ins.Args[form.destination].Reg, "%"+bytes)
+}
diff --git a/amd64_legacy_float_memory_context_test.go b/amd64_legacy_float_memory_context_test.go
new file mode 100644
index 000000000..14a972625
--- /dev/null
+++ b/amd64_legacy_float_memory_context_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86LegacyPackedFloatingNativeMemoryUnboundSourcesBeforeEmission(t *testing.T) {
+	for _, op := range []Op{"ADDPS", "ADDPD", "SUBPS", "SUBPD", "MULPS", "MULPD", "DIVPS", "DIVPD"} {
+		for _, operand := range []Operand{
+			{Kind: OpMem, Mem: MemRef{Base: SP, Off: 16}},
+			{Kind: OpMem, Mem: MemRef{Base: BP, Off: -32}},
+			{Kind: OpMem, Mem: MemRef{Base: AX, Index: BP, Scale: 1}},
+			{Kind: OpFP, FPOffset: 0},
+		} {
+			t.Run(string(op)+"/"+operand.String(), func(t *testing.T) {
+				ins := Instr{Op: op, Args: []Operand{operand, {Kind: OpReg, Reg: "X0"}}}
+				c, ir := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				before := ir.String()
+				form := x86LegacyPackedFloatContextForm(t, ins)
+				if err := c.lowerLegacyPackedFloatingMemory(ins, form); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unbound native memory source accepted: %v", err)
+				}
+				if ir.String() != before {
+					t.Fatal("unbound source rejection emitted IR side effects")
+				}
+			})
+		}
+		for _, addressBits := range []int{16, 32} {
+			ins := Instr{
+				Op: op, Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX}}, {Kind: OpReg, Reg: "X0"}},
+				x86AddressBits: addressBits,
+			}
+			c, ir := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			before := ir.String()
+			if err := c.lowerLegacyPackedFloatingMemory(ins, x86LegacyPackedFloatContextForm(t, ins)); !errors.Is(err, ErrProbeNeedsContext) || ir.String() != before {
+				t.Fatalf("address-size %d bypassed native source binding or emitted IR: %v", addressBits, err)
+			}
+		}
+	}
+}
+
+func x86LegacyPackedFloatContextForm(t *testing.T, ins Instr) x86FloatBinaryForm {
+	t.Helper()
+	addsub, known, err := x86FloatAddSubProperties(ins, "amd64")
+	if known {
+		if err != nil {
+			t.Fatal(err)
+		}
+		return addsub.x86FloatBinaryForm
+	}
+	muldiv, known, err := x86FloatMulDivProperties(ins, "amd64")
+	if !known || err != nil {
+		t.Fatalf("missing complete typed legacy form: known=%t err=%v", known, err)
+	}
+	return muldiv.x86FloatBinaryForm
+}
+
+func TestX86LegacyPackedFloatingNativeMemoryUnboundSourcesFiveTargets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"ADDPS", "ADDPD", "SUBPS", "SUBPD", "MULPS", "MULPD", "DIVPS", "DIVPD"} {
+			for _, operand := range []string{"16(SP)", "-32(BP)", "(AX)(BP*1)"} {
+				t.Run(target.triple+"/"+op+"/"+operand, func(t *testing.T) {
+					source, sig, pkg := x86OrdinaryBPNativeFixture(t, target.arch, "Value", op+" "+operand+",X0", operand, 0)
+					x86InsertExtractGoListing(t, target.arch, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					opt := x86SourceStackOptions(target.arch, target.triple, sig)
+					t.Run("Translate", func(t *testing.T) {
+						ir, err := Translate(file, opt)
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, operand, ir, err)
+					})
+					t.Run("TranslateModuleInContext", func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						module, err := TranslateModuleInContext(ctx, file, opt)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						ir := ""
+						if !module.IsNil() {
+							ir = module.String()
+						}
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, operand, ir, err)
+					})
+					t.Run("TranslateGoModule", func(t *testing.T) {
+						translation, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+							GOARCH: target.arch, TargetTriple: target.triple,
+							ResolveSym: opt.ResolveSym,
+						})
+						if translation != nil && !translation.Module.IsNil() {
+							defer translation.Module.Dispose()
+						}
+						ir := ""
+						if translation != nil && !translation.Module.IsNil() {
+							ir = translation.Module.String()
+						}
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, operand, ir, err)
+					})
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingNativeMemoryUnboundAddressSizeActualGo(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			opcode  string
+			prefix  string
+			machine int
+		}{
+			{"ADDPS", "", 0x58}, {"ADDPD", "BYTE $0x66\n", 0x58},
+			{"SUBPS", "", 0x5c}, {"SUBPD", "BYTE $0x66\n", 0x5c},
+			{"MULPS", "", 0x59}, {"MULPD", "BYTE $0x66\n", 0x59},
+			{"DIVPS", "", 0x5e}, {"DIVPD", "BYTE $0x66\n", 0x5e},
+		} {
+			t.Run(target.triple+"/"+row.opcode, func(t *testing.T) {
+				body := row.prefix + fmt.Sprintf("BYTE $0x67\nBYTE $0x0f\nBYTE $%d\nBYTE $0x03\nRET", row.machine)
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, body)
+				x86InsertExtractGoListing(t, target.arch, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := x86SourceStackOptions(target.arch, target.triple, sig)
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				wantBits := 32
+				if target.arch == "386" {
+					wantBits = 16
+				}
+				if len(decoded.Instrs) != 3 || decoded.Instrs[0].Op != "TEXT" ||
+					string(decoded.Instrs[1].Op) != row.opcode || decoded.Instrs[1].x86AddressBits != wantBits ||
+					decoded.Instrs[1].x86SourceRaw == nil || decoded.Instrs[2].Op != "RET" {
+					t.Fatalf("physical address-size/opcode identity lost: %+v", decoded.Instrs)
+				}
+				t.Run("Translate", func(t *testing.T) {
+					_, err := Translate(file, opt)
+					x86LegacyFloatMemoryRequireContext(t, err)
+				})
+				t.Run("TranslateModuleInContext", func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := TranslateModuleInContext(ctx, file, opt)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					x86LegacyFloatMemoryRequireContext(t, err)
+				})
+				t.Run("TranslateGoModule", func(t *testing.T) {
+					translation, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+						GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: opt.ResolveSym,
+					})
+					if translation != nil && !translation.Module.IsNil() {
+						defer translation.Module.Dispose()
+					}
+					x86LegacyFloatMemoryRequireContext(t, err)
+				})
+			})
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingNativeMemoryUnboundAddressSizeProducerIdentity(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for index, opcode := range x86LegacyFloatMemoryOpcodes() {
+			for _, input := range []struct {
+				name, body string
+				raw        bool
+			}{
+				{"native_memory", "BYTE $0x0f\nBYTE $@OP\nBYTE $0x03", true},
+				{"register_override", "BYTE $0x67\nBYTE $0x0f\nBYTE $@OP\nBYTE $0xc3", true},
+				{"forged_raw_comment", opcode + " (AX),X0 // decoded from BYTE $0x67", false},
+			} {
+				t.Run(arch+"/"+opcode+"/"+input.name, func(t *testing.T) {
+					body := input.body
+					if input.raw {
+						body = strings.ReplaceAll(body, "@OP", fmt.Sprint([]int{0x58, 0x5c, 0x59, 0x5e}[index/2]))
+						if index%2 != 0 {
+							body = "BYTE $0x66\n" + body
+						}
+					}
+					source := "TEXT f(SB),4,$0-0\n" + body + "\nRET\n"
+					x86InsertExtractGoListing(t, arch, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					decoded, err := decodeX86RawDirectives(file.Funcs[0], arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(decoded.Instrs) != 3 || string(decoded.Instrs[1].Op) != opcode {
+						t.Fatalf("lost complete default/register form: %+v", decoded.Instrs)
+					}
+					instruction := decoded.Instrs[1]
+					if instruction.x86AddressBits != 0 || (instruction.x86SourceRaw != nil) != input.raw {
+						t.Fatalf("default/register/forged-comment form acquired an override or raw origin: %+v", instruction)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86LegacyFloatMemoryRequireContext(t *testing.T, err error) {
+	t.Helper()
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("actual Go accepted source acquired native virtual-stack permission: %v", err)
+	}
+}
diff --git a/amd64_legacy_float_memory_runtime_test.go b/amd64_legacy_float_memory_runtime_test.go
new file mode 100644
index 000000000..d742b1e4a
--- /dev/null
+++ b/amd64_legacy_float_memory_runtime_test.go
@@ -0,0 +1,139 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86LegacyFloatMemoryProgram(t *testing.T, triple string, dead bool) string {
+	t.Helper()
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for i, opcode := range x86LegacyFloatMemoryOpcodes() {
+		name := fmt.Sprintf("memory%d", i)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (BX),Z0\n%s (CX),X0\n", name, opcode)
+		if !dead {
+			source.WriteString("VMOVUPS Z0,(AX)\n")
+		}
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+// The independent reference executes each original m128 opcode, rather than
+// MOVDQA or a register-only arithmetic substitute. The original physical
+// operation supplies the expected typed status, without guessing a vendor,
+// emulator, signal mapping, or machine-control setting. The required native
+// CI counterpart has the same test root; Rosetta is not native hardware proof.
+func TestCrossLinuxRuntimeMatrixX86LegacyPackedFloatingNativeMemory(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var references, table strings.Builder
+	for i, opcode := range x86LegacyFloatMemoryOpcodes() {
+		fmt.Fprintf(&references, `extern void memory%d(void*,const void*,const void*);
+static __attribute__((noinline)) void reference%d(void *out,const void *a,const void *b) {
+ uint8_t low[16];
+ __asm__ volatile("movups (%%1),%%%%xmm0; %s (%%2),%%%%xmm0; movups %%%%xmm0,(%%0)"::"r"(low),"r"(a),"r"(b):"xmm0","memory");
+ memmove(out,a,64);memcpy(out,low,16);
+}
+`, i, i, strings.ToLower(opcode))
+		if i > 0 {
+			table.WriteString(",")
+		}
+		fmt.Fprintf(&table, "{reference%d,memory%d,%d}", i, i, 32+32*(i%2))
+	}
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + references.String() + `
+typedef void (*operation)(void*,const void*,const void*);
+struct pair {operation original,translated;int bits;};
+static const struct pair pairs[]={ ` + table.String() + ` };
+struct outcome {int kind,exit_code,signal,core;};
+static struct outcome fault(operation fn,const void *b) {
+ struct outcome result={0,0,0,0};pid_t pid=fork();if(pid<0)return result;
+ if(!pid){struct rlimit limit={0,0};if(setrlimit(RLIMIT_CORE,&limit))_exit(120);
+  uint8_t a[64] __attribute__((aligned(16)))={0},out[64];unsigned csr=0x1f80;
+  __asm__ volatile("ldmxcsr %0"::"m"(csr));fn(out,a,b);_exit(0);}
+ int status;if(waitpid(pid,&status,0)!=pid)return result;
+ if(WIFSIGNALED(status)){result.kind=2;result.signal=WTERMSIG(status);result.core=!!WCOREDUMP(status);}
+ else if(WIFEXITED(status)){result.kind=1;result.exit_code=WEXITSTATUS(status);}
+ return result;
+}
+static int same_status(struct outcome original,struct outcome translated) {
+ if(!original.kind||!translated.kind||original.exit_code||translated.exit_code)return 0;
+ return original.kind==translated.kind&&original.exit_code==translated.exit_code&&original.signal==translated.signal&&original.core==translated.core;
+}
+int main(void) {
+ const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+ const uint64_t edges32[]={0,0x80000000,1,0x00800000,0x3f800001,0xbf800001,0x7f800000,0xff800000,0x7fc12345,0x7f812345};
+ const uint64_t edges64[]={0,0x8000000000000000ULL,1,0x0010000000000000ULL,0x3ff0000000000001ULL,0xbff0000000000001ULL,0x7ff0000000000000ULL,0xfff0000000000000ULL,0x7ff8123456789abcULL,0x7ff0123456789abcULL};
+ uint8_t bStorage[96] __attribute__((aligned(16)))={0};
+ for(int op=0;op<8;op++) {
+  for(int offset=0;offset<16;offset++) {
+   struct outcome original=fault(pairs[op].original,bStorage+offset),translated=fault(pairs[op].translated,bStorage+offset);
+   if(!same_status(original,translated)){fprintf(stderr,"opcode=%d mod16=%d original=%d/%d/%d/%d translated=%d/%d/%d/%d\n",op,offset,original.kind,original.exit_code,original.signal,original.core,translated.kind,translated.exit_code,translated.signal,translated.core);return 1;}
+  }
+#if !DEAD_RESULT
+  for(int round=0;round<4;round++)for(int control=0;control<6;control++)for(int edge=0;edge<10;edge++)for(int alias=0;alias<3;alias++) {
+   uint8_t a[64] __attribute__((aligned(16))),b[64] __attribute__((aligned(16))),original[66],translated[66];
+   for(int j=0;j<64;j++){a[j]=(uint8_t)(j*13+edge);b[j]=0xb7;}
+   const uint64_t *edges=pairs[op].bits==32?edges32:edges64;int bytes=pairs[op].bits/8;
+   for(int lane=0;lane<16/bytes;lane++){memcpy(a+lane*bytes,&edges[(edge+lane)%10],bytes);memcpy(b+lane*bytes,&edges[(edge+lane+3)%10],bytes);}
+   memset(original,0xc3,66);memset(translated,0xc3,66);
+   unsigned csr=controls[control]|(round<<13),expected,actual;
+   uint8_t originalA[64] __attribute__((aligned(16))),originalB[64] __attribute__((aligned(16))),translatedA[64] __attribute__((aligned(16))),translatedB[64] __attribute__((aligned(16)));
+   memcpy(originalA,a,64);memcpy(originalB,b,64);memcpy(translatedA,a,64);memcpy(translatedB,b,64);
+   void *originalOut=alias==1?originalA:alias==2?originalB:original+1,*translatedOut=alias==1?translatedA:alias==2?translatedB:translated+1;
+   __asm__ volatile("ldmxcsr %0"::"m"(csr));pairs[op].original(originalOut,originalA,originalB);__asm__ volatile("stmxcsr %0":"=m"(expected));
+   __asm__ volatile("ldmxcsr %0"::"m"(csr));pairs[op].translated(translatedOut,translatedA,translatedB);__asm__ volatile("stmxcsr %0":"=m"(actual));
+   if(alias){memcpy(original+1,originalOut,64);memcpy(translated+1,translatedOut,64);}
+   if(memcmp(original,translated,66)||expected!=actual){fprintf(stderr,"opcode=%d round=%d control=%d edge=%d CSR=%x/%x\n",op,round,control,edge,expected,actual);return 3;}
+   if(memcmp(originalA,translatedA,64)||memcmp(originalB,translatedB,64)||(!alias&&(memcmp(translatedA,a,64)||memcmp(translatedB,b,64))))return 8;
+  }
+#endif
+ }
+ long page=sysconf(_SC_PAGESIZE);if(page<128)return 4;
+ uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+ if(region==MAP_FAILED||mprotect(region+page,page,PROT_NONE))return 5;
+ for(int op=0;op<8;op++)for(int extent=0;extent<=16;extent++) {
+  const void *pointer=region+page-extent;struct outcome original=fault(pairs[op].original,pointer),translated=fault(pairs[op].translated,pointer);
+  if(!same_status(original,translated)){fprintf(stderr,"guard opcode=%d extent=%d original=%d/%d/%d/%d translated=%d/%d/%d/%d\n",op,extent,original.kind,original.exit_code,original.signal,original.core,translated.kind,translated.exit_code,translated.signal,translated.core);return 6;}
+ }
+ if(munmap(region,2*page))return 7;
+ unsigned csr=0x1f80;__asm__ volatile("ldmxcsr %0"::"m"(csr));return 0;
+}
+`
+	for _, dead := range []bool{false, true} {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("dead=%t/O2=%t", dead, optimized), func(t *testing.T) {
+				ir := x86LegacyFloatMemoryProgram(t, triple, dead)
+				if optimized {
+					ir = x86MulDivRoundOptimize(t, ir)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy-float-memory", triple, ir, fmt.Sprintf("#define DEAD_RESULT %d\n", x86FloatAddSubBoolInt(dead))+main, prefix)
+			})
+		}
+	}
+}
diff --git a/amd64_legacy_float_memory_test.go b/amd64_legacy_float_memory_test.go
new file mode 100644
index 000000000..61aee3629
--- /dev/null
+++ b/amd64_legacy_float_memory_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86LegacyFloatMemoryOpcodes() []string {
+	return []string{"ADDPS", "ADDPD", "SUBPS", "SUBPD", "MULPS", "MULPD", "DIVPS", "DIVPD"}
+}
+
+func TestX86LegacyPackedFloatingMemoryActualGoOpcodeBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for i, opcode := range x86LegacyFloatMemoryOpcodes() {
+			listing := x86InsertExtractGoListing(t, arch, "TEXT f(SB),4,$0-0\n"+opcode+" (AX),X1\nRET\n")
+			var actual []byte
+			for _, line := range strings.Split(string(listing), "\n") {
+				actual = append(actual, x86InsertExtractListedBytes(line)...)
+			}
+			want := []byte{0x0f, []byte{0x58, 0x5c, 0x59, 0x5e}[i/2], 0x08, 0xc3}
+			if i%2 != 0 {
+				want = append([]byte{0x66}, want...)
+			}
+			if !bytes.Equal(actual, want) {
+				t.Fatalf("%s/%s actual Go bytes=%x independent SSE=%x", arch, opcode, actual, want)
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryRetainsOriginalOpcode(t *testing.T) {
+	for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, source := range []string{"(AX)", "16(AX)(BX*2)", "data(SB)", "(FS)", "(GS)"} {
+				t.Run(opcode+"/"+arch+"/"+source, func(t *testing.T) {
+					assembly := "TEXT f(SB),4,$0-0\n" + opcode + " " + source + ",X1\nRET\n"
+					requireX86GoAssemblerResult(t, arch, assembly, true)
+					file, err := Parse(ArchAMD64, assembly)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err := Translate(file, Options{Goarch: arch, TargetTriple: testTargetTriple("linux", arch),
+						Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(opcode)+" ") || strings.Contains(ir, "movdqa") {
+						t.Fatal("native m128 source lost its exact original observable opcode")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryFiveTargetsKeepNativeOpcodes(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		var source strings.Builder
+		sigs := map[string]FuncSig{}
+		for i, opcode := range x86LegacyFloatMemoryOpcodes() {
+			for j, operand := range []string{"(AX)", "16(AX)(BX*2)", "data(SB)", "(FS)", "(GS)"} {
+				name := fmt.Sprintf("memory_%d_%d", i, j)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s %s,X1\nRET\n", name, opcode, operand)
+				sigs[name] = FuncSig{Name: name, Ret: Void}
+			}
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/O2=%t", triple, optimized), func(t *testing.T) {
+				ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: sigs})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if optimized {
+					ir = x86MulDivRoundOptimize(t, ir)
+				}
+				dir := t.TempDir()
+				input, object := filepath.Join(dir, "memory.ll"), filepath.Join(dir, "memory.o")
+				if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+					t.Fatal(err)
+				}
+				level := "-O0"
+				if optimized {
+					level = "-O2"
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", object))
+				cancel()
+				if err != nil {
+					t.Fatalf("native memory object: %v\n%s", err, output)
+				}
+				ctx, cancel = runtimeOracleStageContext(t)
+				output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, objdump, "-d", object))
+				cancel()
+				if err != nil {
+					t.Fatalf("native memory disassembly: %v\n%s", err, output)
+				}
+				for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+					pattern := regexp.MustCompile(`(?m)\b` + strings.ToLower(opcode) + `\s+[^\n]*\([^\n]*\),\s*%xmm`)
+					if count := len(pattern.FindAll(output, -1)); count != 5 {
+						t.Fatalf("%s count=%d, original memory opcode lost:\n%s", opcode, count, output)
+					}
+				}
+				if !strings.Contains(string(output), "%fs:") || !strings.Contains(string(output), "%gs:") {
+					t.Fatal("native FS/GS source prefixes lost")
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryCallerPermissionsAndNativeWidth(t *testing.T) {
+	for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+		for _, operand := range []string{"(DI)", "16(DI)", "(BX)", "(SP)", "a+0(FP)", "(R14)", "(CX)"} {
+			body := fmt.Sprintf("VMOVUPS (SI),Z1\n%s %s,X1\nVMOVSS X1,(DX)", opcode, operand)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			want := operand == "(DI)" || operand == "16(DI)"
+			if want && err != nil || !want && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s/%s actual source permission=%v want admitted=%t", opcode, operand, err, want)
+			}
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+opcode+" (DI),X1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, extent := range []int64{15, 16} {
+			ins := file.Funcs[0].Instrs[1]
+			proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{{kind: x86CallerFreshResult, width: extent}}}
+			state := x86SourceStackState{callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}}, vectors: map[Reg]uint64{"Z1": ^uint64(0)}}
+			accepted := x86CallerVectorMoveStep(&ins, &state, proof)
+			if accepted != (extent == 16) {
+				t.Fatalf("%s certified a partial m128 source extent=%d accepted=%t", opcode, extent, accepted)
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryIdentityAndMalformedBeforeEmission(t *testing.T) {
+	for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+		valid, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+opcode+" (AX),X1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, sourceOp := range []Op{"", Op(opcode), Op(strings.ToLower(opcode)), "UNKNOWN", "ADDPS.Z", "DIVPS"} {
+			ins := valid.Funcs[0].Instrs[1]
+			ins.Op = sourceOp
+			ctx, output := newAMD64CtxWithFuncForTest(t, valid.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.Len()
+			var known, term bool
+			if strings.HasPrefix(opcode, "ADD") || strings.HasPrefix(opcode, "SUB") {
+				known, term, err = ctx.lowerFloatAddSub(Op(opcode), ins)
+			} else {
+				known, term, err = ctx.lowerFloatMulDiv(Op(opcode), ins)
+			}
+			conflict := sourceOp != "" && !strings.EqualFold(string(sourceOp), opcode)
+			if !known || term || (err != nil) != conflict || conflict && output.Len() != before || ins.Op != sourceOp {
+				t.Fatalf("%s/%s changed identity or emitted before rejection: %t/%t/%v", opcode, sourceOp, known, term, err)
+			}
+		}
+		for _, row := range []string{opcode + " (AX),Y1", opcode + " (AX),X16", opcode + ".Z (AX),X1", opcode + " $data(SB),X1", opcode + " (AX),X1,X2"} {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				continue
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.Len()
+			ins := file.Funcs[0].Instrs[1]
+			var known bool
+			var term bool
+			if strings.HasPrefix(opcode, "ADD") || strings.HasPrefix(opcode, "SUB") {
+				known, term, err = ctx.lowerFloatAddSub(ins.Op, ins)
+			} else {
+				known, term, err = ctx.lowerFloatMulDiv(ins.Op, ins)
+			}
+			if !known || term || err == nil || before != output.Len() {
+				t.Fatalf("malformed %s emitted native IR: %t/%t/%v", row, known, term, err)
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryMode32FeaturesAreFormBound(t *testing.T) {
+	for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+		for _, row := range []string{opcode + " (AX),X1", opcode + " (AX),X8", opcode + ".Z (AX),X1", opcode + " value+0(FP),X1"} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			bits := x86LegacyPackedFloatingNativeMemoryBits(file.Funcs[0].Instrs[1], "386")
+			want := 0
+			if row == opcode+" (AX),X1" {
+				want = 32
+				if strings.HasSuffix(opcode, "PD") {
+					want = 64
+				}
+			}
+			if bits != want {
+				t.Fatalf("unvalidated source form acquired SSE transport: %s %d/%d", row, bits, want)
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedFloatingMemoryVirtualFPIsNotNativeStorage(t *testing.T) {
+	for _, opcode := range x86LegacyFloatMemoryOpcodes() {
+		assembly := fmt.Sprintf("TEXT f(SB),4,$0-16\n%s source+0(FP),X1\nRET\n", opcode)
+		file, err := Parse(ArchAMD64, assembly)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := FuncSig{Name: "f", Args: []LLVMType{I64, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1},
+		}}}
+		_, err = Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": sig}})
+		if err == nil || !strings.Contains(err.Error(), "contiguous original FP") {
+			t.Fatalf("%s invented native m128 alignment/backing from independent virtual fields: %v", opcode, err)
+		}
+	}
+}
diff --git a/amd64_legacy_integer_arithmetic_effects.go b/amd64_legacy_integer_arithmetic_effects.go
new file mode 100644
index 000000000..1a80a50c1
--- /dev/null
+++ b/amd64_legacy_integer_arithmetic_effects.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86LegacyIntegerArithmeticForm struct {
+	x86PackedBinaryForm
+	source, destination Operand
+}
+
+// Reuse the arithmetic specifications and Go operand rows already owned by
+// lowering. This descriptor adds no frame, source, caller or initialized bank.
+func x86LegacyIntegerArithmeticProperties(op Op, ins Instr, arch string) (x86LegacyIntegerArithmeticForm, bool, error) {
+	spec, known := x86PackedArithmeticSpecForOp(op, x86PackedArithmeticAdd|x86PackedArithmeticSubtract)
+	if !known || spec.encoding != x86PackedLogicalLegacyFP && spec.encoding != x86PackedLogicalLegacyInteger {
+		return x86LegacyIntegerArithmeticForm{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86LegacyIntegerArithmeticForm{}, true, fmt.Errorf("legacy integer arithmetic dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	local := ins
+	local.Op = op
+	encoding := spec.encoding
+	if encoding == x86PackedLogicalLegacyInteger {
+		var err error
+		local, err = x86LegacyMMXReadInstruction(local, arch)
+		if err != nil {
+			return x86LegacyIntegerArithmeticForm{}, true, err
+		}
+	}
+	form, err := x86PackedBinaryProperties(local, arch, x86PackedBinarySpec{encoding: encoding})
+	result := x86LegacyIntegerArithmeticForm{x86PackedBinaryForm: form}
+	if err == nil {
+		result.source, result.destination = local.Args[0], local.Args[1]
+	}
+	return result, true, err
+}
+
+func x86LegacyIntegerArithmeticEmitterContext(form x86LegacyIntegerArithmeticForm, ins Instr) error {
+	if form.mmx && ins.Args[0].Kind == OpReg && ins.Args[0].Reg != form.source.Reg {
+		return fmt.Errorf("%w: legacy integer arithmetic GP spelling encodes an MMX source without its physical bank transport", ErrProbeNeedsContext)
+	}
+	return nil
+}
diff --git a/amd64_legacy_integer_arithmetic_forms_test.go b/amd64_legacy_integer_arithmetic_forms_test.go
new file mode 100644
index 000000000..91d7b3247
--- /dev/null
+++ b/amd64_legacy_integer_arithmetic_forms_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86LegacyIntegerArithmeticTestOpcodes = []byte{
+	0xfc, 0xfd, 0xfe, 0xfe, 0xd4, 0xec, 0xed, 0xdc, 0xdd,
+	0xf8, 0xf9, 0xfa, 0xfb, 0xe8, 0xe9, 0xd8, 0xd9,
+}
+
+func TestX86LegacyIntegerArithmeticGrammarEffectsAndNativeWidths(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			for _, operands := range []string{"X0,X1", "X0,X0", "(AX),X1", "8(AX)(CX*4),X1", "a+0(FP),X1", "value-32(SP),X1", "·data(SB),X1", "(FS),X1", "(GS),X1"} {
+				t.Run(arch+"/"+op+" "+operands, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-64\n"+op+" "+operands+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					before := fmt.Sprintf("%#v", ins)
+					form, recognized, err := x86LegacyIntegerArithmeticProperties(ins.Op, ins, arch)
+					if !recognized || err != nil || form.byteWidth != 16 || form.mmx {
+						t.Fatal("full accepted XMM row lost", form, err)
+					}
+					effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !recognized || err != nil || len(effect.operands) != 2 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+						t.Fatal("legacy arithmetic lost its two inputs or unchanged flags", effect, err)
+					}
+					for index, role := range effect.operands {
+						if role.index != index || role.width != 16 || !role.read || role.write != (index == 1) || !reflect.DeepEqual(role.operand, ins.Args[index]) {
+							t.Fatalf("wrong ordered input/output bytes: %#v", role)
+						}
+						width, write, known := x86InstructionMemoryShape(ins, index, arch)
+						if known != (form.memory == index) || known && (width != 16 || write) {
+							t.Fatal("descriptor and native memory reader differ", width, write, known)
+						}
+						if ins.Args[index].Kind == OpFP {
+							width, write, known = X86FPAccessBytes(ins, index, arch)
+							if !known || width != 16 || write {
+								t.Fatal("FP observer does not preserve full native read", width, write, known)
+							}
+						}
+					}
+					if strings.HasPrefix(op, "PADDS") || strings.HasPrefix(op, "PADDUS") {
+						if x86CallerVectorMoveKnown(ins) || x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+							t.Fatal("pure descriptor granted unproved saturating caller transport")
+						}
+					}
+					if before != fmt.Sprintf("%#v", ins) {
+						t.Fatal("shape observer changed original source")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyIntegerArithmeticActualGoBytesAndMMXBank(t *testing.T) {
+	for opIndex, op := range x86LegacyIntegerArithmeticTestNames {
+		for _, arch := range []string{"amd64", "386"} {
+			for _, operands := range []struct {
+				text  string
+				modrm byte
+			}{
+				{"X1,X0", 0xc1}, {"X0,X7", 0xf8}, {"(AX),X1", 0x08},
+			} {
+				t.Run(arch+"/"+op+" "+operands.text, func(t *testing.T) {
+					source := "TEXT probe(SB),4,$0-0\n" + op + " " + operands.text + "\nRET\n"
+					want := []byte{0x66, 0x0f, x86LegacyIntegerArithmeticTestOpcodes[opIndex], operands.modrm, 0xc3}
+					if got := x86PackedShiftActualGoBytes(t, arch, source); !bytes.Equal(got, want) {
+						t.Fatalf("original source width/opcode differs: %x want %x", got, want)
+					}
+				})
+			}
+		}
+		if !strings.HasPrefix(op, "PADD") || op == "PADDQ" {
+			continue
+		}
+		for index, spelling := range []string{"M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			t.Run("mmx/"+op+" "+spelling, func(t *testing.T) {
+				source := "TEXT probe(SB),4,$0-0\n" + op + " " + spelling + ",M7\nRET\n"
+				want := []byte{0x0f, x86LegacyIntegerArithmeticTestOpcodes[opIndex], 0xf8 | byte(index&7), 0xc3}
+				if index >= 16 {
+					want = append([]byte{0x41}, want...)
+				}
+				if got := x86PackedShiftActualGoBytes(t, "amd64", source); !bytes.Equal(got, want) {
+					t.Fatalf("Go's GP spelling must name the physical MMX bank: %x want %x", got, want)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !recognized || err != nil || effect.operands[0].width != 8 || effect.operands[0].operand.Reg != Reg(fmt.Sprintf("M%d", index&7)) {
+					t.Fatal("pure effects confused a numeric GP with a physical MMX input", effect, err)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for i := range state.gp {
+					state.gp[i] = 0xff
+				}
+				if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("initialized GP bytes fabricated MMX input/output permission")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultLegacyIntegerArithmeticPartialBytesAndFlags(t *testing.T) {
+	for _, op := range x86LegacyIntegerArithmeticTestNames {
+		ins := Instr{Op: Op(op), Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}}
+		for source := 0; source < 2; source++ {
+			for missing := 0; missing < 16; missing++ {
+				t.Run(fmt.Sprintf("%s/input%d/byte%d", op, source, missing), func(t *testing.T) {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+					state.xmm[1-source] &^= uint16(1) << uint(missing)
+					if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatal("read-modify-write borrowed one missing input byte")
+					}
+				})
+			}
+		}
+		for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+			state := x86ResultState{flags: flags}
+			state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+			if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || state.flags != flags || state.xmm[0] != 0xffff || state.xmm[1] != 0xffff {
+				t.Fatal("legacy lane arithmetic altered flags or byte aliases", op, flags, state)
+			}
+		}
+		body := "MOVSS a+0(FP),X1\nMOVL $1,AX\nCMPL AX,$0\nJE partial\nMOVSD a+0(FP),X0\nJMP joined\npartial:\nMOVSS X1,X0\njoined:\n" + op + " X1,X0\nMOVSD X0,ret0+8(FP)\nRET"
+		file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value(a uint64) uint64", 64, body)
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("partial destination path became initialized", op, err)
+		}
+	}
+}
+
+func TestX86LegacyIntegerArithmeticThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				body := "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\n" + op + " X1,X0\n" + op + " X0,X0\nMOVSD X0,ret0+32(FP)\nRET"
+				pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(a,b,c,d uint64) uint64", body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+					ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+				before := fmt.Sprintf("%#v %#v", file, sig)
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+				if before != fmt.Sprintf("%#v %#v", file, sig) {
+					t.Fatal("API changed original inputs")
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyIntegerArithmeticMalformedFormsAndIdentity(t *testing.T) {
+	for _, op := range x86LegacyIntegerArithmeticTestNames {
+		for _, operands := range []string{"$1,X0", "X0,(AX)", "Y0,Y1", "Z0,Z1", "X16,X0", "(AX),(BX)", "X0,K1,X1"} {
+			file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+op+" "+operands+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64"); !recognized || err == nil {
+				t.Fatal("malformed row acquired effects", ins, err)
+			}
+		}
+		file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+op+" X0,X1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, identity := range []Op{"", Op(op), Op(strings.ToLower(op))} {
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = identity
+			if _, recognized, err := x86LegacyIntegerArithmeticProperties(Op(op), ins, "amd64"); !recognized || err != nil {
+				t.Fatal("matching dispatch lost compatibility", identity, err)
+			}
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ins.Op = "MOVQ"
+		if _, recognized, err := x86TypedInstructionByteEffect(Op(op), ins, "amd64"); !recognized || err == nil {
+			t.Fatal("contradictory dispatch obtained effects", err)
+		}
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		var known bool
+		if strings.HasPrefix(op, "PADD") {
+			known, _, err = ctx.lowerPackedIntegerAdd(Op(op), ins)
+		} else {
+			known, _, err = ctx.lowerPackedIntegerSubtract(Op(op), ins)
+		}
+		if !known || err == nil || output.String() != before {
+			t.Fatal("contradictory dispatch changed IR before rejection", op, known, err)
+		}
+		for _, operands := range []string{"X8,X0", "X0,X15"} {
+			source := "TEXT probe(SB),4,$0-0\n" + op + " " + operands + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !recognized || err == nil {
+				t.Fatal("mode32 acquired an unavailable physical X bank", op, err)
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultLegacyIntegerArithmeticDoesNotBorrowPermission(t *testing.T) {
+	for _, op := range x86LegacyIntegerArithmeticTestNames {
+		for name, body := range map[string]string{
+			"source unknown":          "MOVSD a+0(FP),X0\n" + op + " X2,X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"old destination unknown": "MOVSD a+0(FP),X1\n" + op + " X1,X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"native pointer":          "MOVSD a+0(FP),X0\nMOVQ a+0(FP),AX\n" + op + " (AX),X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"AUTO partial":            "MOVSD a+0(FP),X0\nMOVQ $1,value-32(SP)\n" + op + " value-32(SP),X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"FP gap or result":        "MOVSD a+0(FP),X0\n" + op + " b+28(FP),X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"call kills facts":        "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\nCALL ·Other(SB)\n" + op + " X1,X0\nMOVSD X0,ret0+32(FP)\nRET",
+			"dead unbound call":       "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\n" + op + " X1,X0\nMOVSD X0,ret0+32(FP)\nRET\nCALL ·Unknown(SB)\nRET",
+			"escape logical AUTO":     "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\nLEAQ value-32(SP),AX\n" + op + " X1,X0\nMOVSD X0,ret0+32(FP)\nRET",
+		} {
+			t.Run(op+"/"+name, func(t *testing.T) {
+				file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value(a,b,c,d uint64) uint64", 64, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("pure arithmetic effects fabricated initialization or backing", err)
+				}
+			})
+		}
+		t.Run(op+"/dead modeled timestamp", func(t *testing.T) {
+			// RDTSC has a complete implicit-output effect now. Retain its
+			// positive source-wide control instead of calling it unknown.
+			body := "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\n" + op +
+				" X1,X0\nMOVSD X0,ret0+32(FP)\nRET\nRDTSC\nRET"
+			file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value(a,b,c,d uint64) uint64", 64, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatal("modeled dead timestamp lost its closed source effect", err)
+			}
+		})
+	}
+}
diff --git a/amd64_legacy_integer_arithmetic_runtime_test.go b/amd64_legacy_integer_arithmetic_runtime_test.go
new file mode 100644
index 000000000..1989326c5
--- /dev/null
+++ b/amd64_legacy_integer_arithmetic_runtime_test.go
@@ -0,0 +1,422 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Independent mathematical attributes, not emitted from the production specs.
+var x86LegacyIntegerArithmeticTestBytes = []int{1, 2, 4, 4, 8, 1, 2, 1, 2, 1, 2, 4, 8, 1, 2, 1, 2}
+var x86LegacyIntegerArithmeticTestModes = []int{0, 0, 0, 0, 0, 1, 1, 2, 2, 0, 0, 0, 0, 1, 1, 2, 2}
+
+const x86LegacyIntegerArithmeticGoMath = `
+func lane(value []byte) uint64 {
+ var result uint64
+ for i,b := range value { result |= uint64(b)<<uint(i*8) }
+ return result
+}
+func math(a,b uint64,n,mode int,subtract bool) uint64 {
+ if mode==0 {
+  if subtract { return b-a }
+  return b+a
+ }
+ if mode==2 {
+  max := (uint64(1)<<uint(n*8))-1
+  if subtract {
+   if b<a { return 0 }
+   return b-a
+  }
+  if a>max-b { return max }
+  return a+b
+ }
+ sign := int64(1)<<uint(n*8-1)
+ left,right := int64(a),int64(b)
+ if left&sign!=0 { left-=sign*2 }
+ if right&sign!=0 { right-=sign*2 }
+ result := right+left
+ if subtract { result=right-left }
+ if result < -sign { result=-sign }
+ if result > sign-1 { result=sign-1 }
+ return uint64(result)
+}
+func fill(value []byte,n,sample,side int) {
+ max := ^uint64(0)
+ if n<8 { max=(uint64(1)<<uint(n*8))-1 }
+ choices := []uint64{0,1,max,max>>1,(max>>1)+1,max-1,2,(max>>1)-1}
+ for offset:=0;offset<16;offset+=n {
+  number:=uint64(sample*71+offset*37+side*19)*0x11223344556677
+  if sample<64 { number=choices[(sample/(1+side*7)+offset/n)%len(choices)] }
+  for j:=0;j<n;j++ { value[offset+j]=byte(number>>uint(j*8)) }
+ }
+}
+`
+
+const x86LegacyIntegerArithmeticCMath = `
+static uint64_t lane(const uint8_t *value,int n) {
+ uint64_t result=0;
+ for(int i=0;i<n;i++) result|=(uint64_t)value[i]<<(i*8);
+ return result;
+}
+static uint64_t math(uint64_t a,uint64_t b,int n,int mode,int subtract) {
+ if(!mode) return subtract?b-a:b+a;
+ if(mode==2) {
+  uint64_t max=(UINT64_C(1)<<(n*8))-1;
+  if(subtract) return b<a?0:b-a;
+  return a>max-b?max:a+b;
+ }
+ int64_t sign=INT64_C(1)<<(n*8-1),left=(int64_t)a,right=(int64_t)b;
+ if(left&sign) left-=sign*2;
+ if(right&sign) right-=sign*2;
+ int64_t result=subtract?right-left:right+left;
+ if(result< -sign) result= -sign;
+ if(result>sign-1) result=sign-1;
+ return (uint64_t)result;
+}
+static void fill(uint8_t *value,int n,int sample,int side) {
+ uint64_t max=n==8?UINT64_MAX:(UINT64_C(1)<<(n*8))-1;
+ uint64_t choices[]={0,1,max,max>>1,(max>>1)+1,max-1,2,(max>>1)-1};
+ for(int offset=0;offset<16;offset+=n) {
+  uint64_t number=(uint64_t)(sample*71+offset*37+side*19)*UINT64_C(0x11223344556677);
+  if(sample<64) number=choices[(sample/(1+side*7)+offset/n)%8];
+  for(int j=0;j<n;j++) value[offset+j]=(uint8_t)(number>>(j*8));
+ }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86LegacyIntegerArithmeticOriginalMathFlagsAndCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, goTable, cTable, cDeclarations strings.Builder
+	declarations.WriteString("package packedarithmetic\nfunc ReadCSR() uint32\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\n")
+	for index, op := range x86LegacyIntegerArithmeticTestNames {
+		for _, kind := range []string{"Register", "Alias", "Memory"} {
+			name := op + kind
+			source := "X1"
+			if kind == "Alias" {
+				source = "X0"
+			} else if kind == "Memory" {
+				source = "(AX)"
+			}
+			fmt.Fprintf(&declarations, "func %s(out,x,y *[16]byte,flags *uint64,seed uint64)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DX\nMOVQ x+8(FP),AX\nMOVQ y+16(FP),CX\nMOVOU (AX),X1\nMOVOU (CX),X0\nPUSHQ seed+32(FP)\nPOPFQ\n%s %s,X0\nMOVOU X0,(DX)\nPUSHFQ\nPOPQ BX\nMOVQ flags+24(FP),SI\nMOVQ BX,(SI)\nRET\n", name, op, source)
+			fmt.Fprintf(&goTable, "{%q,%s,%d,%d,%t,%t},\n", name, name,
+				x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestModes[index], index >= 9, kind == "Alias")
+			fmt.Fprintf(&cDeclarations, "extern void %s(uint8_t*,uint8_t*,uint8_t*,uint64_t*,uint64_t);\n", name)
+			fmt.Fprintf(&cTable, "{%q,%s,%d,%d,%d,%d},\n", name, name,
+				x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestModes[index], x86FloatAddSubBoolInt(index >= 9), x86FloatAddSubBoolInt(kind == "Alias"))
+		}
+	}
+	goTest := `package packedarithmetic
+import (
+ "testing"
+ "unsafe"
+)
+` + x86LegacyIntegerArithmeticGoMath + `
+func aligned(value *[80]byte) (*[16]byte,int) {
+ offset:=16+int((-uintptr(unsafe.Pointer(&value[16])))&15)
+ return (*[16]byte)(unsafe.Pointer(&value[offset])),offset
+}
+
+func TestOriginal(t *testing.T) {
+ kernels:=[]struct {
+  name string
+  call func(*[16]byte,*[16]byte,*[16]byte,*uint64,uint64)
+  n,mode int
+  subtract,alias bool
+ }{
+` + goTable.String() + ` }
+ for _,kernel:=range kernels {
+  for sample:=0;sample<257;sample++ {
+   var x,y,out [80]byte
+   xp,_:=aligned(&x);yp,_:=aligned(&y);op,offset:=aligned(&out)
+   for i:=range x { x[i]=0xb9;y[i]=0xa7 }
+   fill(xp[:],kernel.n,sample,0);fill(yp[:],kernel.n,sample,1)
+   originalX,originalY:=x,y
+   for _,seed:=range []uint64{0,0x8d5} {
+    for i:=range out { out[i]=0xa5 }
+    box:=struct{before,value,after uint64}{0x1122334455667788,0,0x8877665544332211}
+    csr:=ReadCSR()
+    kernel.call(op,xp,yp,&box.value,seed)
+    if box.value&0x8d5!=seed||box.before!=0x1122334455667788||box.after!=0x8877665544332211||ReadCSR()!=csr||x!=originalX||y!=originalY {
+     t.Fatalf("%s state/canary sample%d flags%x",kernel.name,sample,box.value)
+    }
+    var want [16]byte
+    for i:=0;i<16;i+=kernel.n {
+     a,b:=lane(xp[i:i+kernel.n]),lane(yp[i:i+kernel.n])
+     if kernel.alias { a=b }
+     value:=math(a,b,kernel.n,kernel.mode,kernel.subtract)
+     for j:=0;j<kernel.n;j++ { want[i+j]=byte(value>>uint(j*8)) }
+    }
+    for i,value:=range out {
+     expected:=byte(0xa5)
+     if i>=offset&&i<offset+16 { expected=want[i-offset] }
+     if value!=expected { t.Fatalf("%s sample%d byte%d got%x want%x",kernel.name,sample,i,value,expected) }
+    }
+   }
+  }
+ }
+}
+`
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+struct Aligned { _Alignas(16) uint8_t before[16],value[16],after[16]; };
+` + cDeclarations.String() + x86LegacyIntegerArithmeticCMath + `
+static const struct Kernel {
+ const char *name;
+ void (*call)(uint8_t*,uint8_t*,uint8_t*,uint64_t*,uint64_t);
+ int n,mode,subtract,alias;
+} kernels[]={
+` + cTable.String() + `};
+int main(void) {
+ for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++) {
+  const struct Kernel *kernel=&kernels[k];
+  for(int sample=0;sample<257;sample++) {
+   struct Aligned x,y,out;
+   memset(&x,0xb9,sizeof(x));memset(&y,0xa7,sizeof(y));
+   fill(x.value,kernel->n,sample,0);fill(y.value,kernel->n,sample,1);
+   struct Aligned originalX=x,originalY=y;
+   for(int status=0;status<2;status++) {
+    uint64_t seed=status?UINT64_C(0x8d5):0;
+    memset(&out,0xa5,sizeof(out));
+    struct {uint64_t before,value,after;} flags={UINT64_C(0x1122334455667788),0,UINT64_C(0x8877665544332211)};
+    uint32_t csr=_mm_getcsr();
+    kernel->call(out.value,x.value,y.value,&flags.value,seed);
+    if((flags.value&UINT64_C(0x8d5))!=seed||flags.before!=UINT64_C(0x1122334455667788)||flags.after!=UINT64_C(0x8877665544332211)||_mm_getcsr()!=csr||memcmp(&x,&originalX,sizeof(x))||memcmp(&y,&originalY,sizeof(y))) {
+     fprintf(stderr,"%s state/input/canary sample%d flags%llx\n",kernel->name,sample,(unsigned long long)flags.value);return 1;
+    }
+    for(int i=0;i<16;i+=kernel->n) {
+     uint64_t a=lane(x.value+i,kernel->n),b=lane(y.value+i,kernel->n);
+     if(kernel->alias) a=b;
+     uint64_t expected=math(a,b,kernel->n,kernel->mode,kernel->subtract);
+     for(int j=0;j<kernel->n;j++) if(out.value[i+j]!=(uint8_t)(expected>>(j*8))) {
+      fprintf(stderr,"%s sample%d byte%d got%x want%x\n",kernel->name,sample,i+j,out.value[i+j],(unsigned)(uint8_t)(expected>>(j*8)));return 2;
+     }
+    }
+    for(int i=0;i<16;i++) if(out.before[i]!=0xa5||out.after[i]!=0xa5) return 3;
+   }
+  }
+ }
+ return 0;
+}
+`
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module packedarithmetic\n\ngo 1.20\n", "arithmetic.go": declarations.String(),
+		"arithmetic_amd64.s": assembly.String(), "arithmetic_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("original Go legacy arithmetic lacks successful terminal: %s", output)
+	}
+	pkg := mustGoPackage(t, "example.invalid/packedarithmetic", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "legacy-integer-arithmetic", ir, main, level)
+		})
+	}
+	if !t.Failed() {
+		t.Log("51 original-Go/LLVM XMM kernels ×257 initialized boundary/random samples ×2 full-six-flag seeds, complete bytes/inputs/MXCSR/canaries; Darwin/Rosetta is not native AMD64/386 fault proof.")
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86LegacyIntegerArithmeticOriginalMMXBank(t *testing.T) {
+	// Go's GP-looking source is an MMX ModRM spelling, not an ABI GP input.
+	// This original-Go-only oracle does not initialize the LLVM/MMX observer.
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, table strings.Builder
+	declarations.WriteString("package packedmmx\nfunc ReadCSR() uint32\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\n")
+	spellings := []string{"M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for opIndex, op := range x86LegacyIntegerArithmeticTestNames {
+		if !strings.HasPrefix(op, "PADD") || op == "PADDQ" {
+			continue
+		}
+		for index, spelling := range spellings {
+			name := fmt.Sprintf("%sBank%d", op, index)
+			fmt.Fprintf(&declarations, "func %s(a,b,c,d,e,f,v,h uint64,flags *uint64,seed uint64) uint64\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-88\n", name)
+			for bank, parameter := range []string{"a", "b", "c", "d", "e", "f", "v", "h"} {
+				fmt.Fprintf(&assembly, "MOVQ %s+%d(FP),M%d\n", parameter, bank*8, bank)
+			}
+			// Do not change native SP/BP/g. Other GP values deliberately do not
+			// match any initialized MMX value.
+			for _, reg := range []string{"AX", "CX", "DX", "BX", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R15"} {
+				fmt.Fprintf(&assembly, "MOVQ $0x5a5a5a5a,%s\n", reg)
+			}
+			fmt.Fprintf(&assembly, "PUSHQ seed+72(FP)\nPOPFQ\n%s %s,M7\nMOVQ M7,ret0+80(FP)\nEMMS\nPUSHFQ\nPOPQ AX\nMOVQ flags+64(FP),DX\nMOVQ AX,(DX)\nRET\n", op, spelling)
+			fmt.Fprintf(&table, "{%q,%s,%d,%d,%d},\n", name, name, index&7,
+				x86LegacyIntegerArithmeticTestBytes[opIndex], x86LegacyIntegerArithmeticTestModes[opIndex])
+		}
+	}
+	goTest := `package packedmmx
+import "testing"
+` + x86LegacyIntegerArithmeticGoMath + `
+func TestOriginal(t *testing.T) {
+ kernels:=[]struct {
+  name string
+  call func(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,*uint64,uint64) uint64
+  bank,n,mode int
+ }{
+` + table.String() + ` }
+ for _,kernel:=range kernels {
+  for sample:=0;sample<33;sample++ {
+   var values [8]uint64
+   for bank:=range values {
+    var bytes [16]byte
+    fill(bytes[:],kernel.n,sample,bank)
+    values[bank]=lane(bytes[:8])
+   }
+   var want uint64
+   for offset:=0;offset<8;offset+=kernel.n {
+    mask:=(uint64(1)<<uint(kernel.n*8))-1
+    a:=(values[kernel.bank]>>uint(offset*8))&mask
+    b:=(values[7]>>uint(offset*8))&mask
+    value:=math(a,b,kernel.n,kernel.mode,false)&mask
+    want|=value<<uint(offset*8)
+   }
+   for _,seed:=range []uint64{0,0x8d5} {
+    box:=struct{before,value,after uint64}{0x123456789abcdef0,0,0xfedcba9876543210}
+    csr:=ReadCSR()
+    got:=kernel.call(values[0],values[1],values[2],values[3],values[4],values[5],values[6],values[7],&box.value,seed)
+    if got!=want||box.value&0x8d5!=seed||ReadCSR()!=csr||box.before!=0x123456789abcdef0||box.after!=0xfedcba9876543210 {
+     t.Fatalf("%s sample%d result%x want%x flags%x",kernel.name,sample,got,want,box.value)
+    }
+   }
+  }
+ }
+}
+`
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module packedmmx\n\ngo 1.20\n", "mmx.go": declarations.String(),
+		"mmx_amd64.s": assembly.String(), "mmx_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("original Go MMX bank oracle lacks successful terminal: %s", output)
+	}
+	t.Log("192 initialized original-Go MMX/GP-spelling kernels ×33 samples ×2 flags; no LLVM MMX/caller/native admission.")
+}
+
+func TestX86LegacyIntegerArithmeticWiderSoftwareAliasPreservation(t *testing.T) {
+	// A directly initialized software shadow, not native Go Z-register code.
+	execution := x86ScalarCountHostExecution(t)
+	var ir, reference, checks strings.Builder
+	profiles := make(map[string]string)
+	ir.WriteString("target triple = \"" + execution.triple + "\"\n")
+	reference.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + x86LegacyIntegerArithmeticCMath)
+	constant := func(multiplier, addend int) string {
+		var values []string
+		for index := 0; index < 64; index++ {
+			values = append(values, fmt.Sprintf("i8 %d", byte(index*multiplier+addend)))
+		}
+		return "<" + strings.Join(values, ",") + ">"
+	}
+	for index, op := range x86LegacyIntegerArithmeticTestNames {
+		profiles[op+"Shadow"] = ""
+		ins := Instr{Op: Op(op), Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}}
+		fn := Func{Instrs: []Instr{{Op: "VMOVUPS", Args: []Operand{{Kind: OpReg, Reg: "Z0"}, {Kind: OpReg, Reg: "Z1"}}}, ins}}
+		ctx, output := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Ret: Void}, nil)
+		ctx.goarch = "amd64"
+		if err := ctx.storeZ("Z0", constant(37, 11)); err != nil {
+			t.Fatal(err)
+		}
+		if err := ctx.storeZ("Z1", constant(19, 71)); err != nil {
+			t.Fatal(err)
+		}
+		known, term, err := ctx.lowerPackedIntegerAdd(ins.Op, ins)
+		if !known {
+			known, term, err = ctx.lowerPackedIntegerSubtract(ins.Op, ins)
+		}
+		if !known || term || err != nil {
+			t.Fatal("legacy lowerer did not consume typed X bank", known, term, err)
+		}
+		first, err := ctx.loadZ("Z0")
+		if err != nil {
+			t.Fatal(err)
+		}
+		second, err := ctx.loadZ("Z1")
+		if err != nil {
+			t.Fatal(err)
+		}
+		fmt.Fprintf(&ir, "define void @%sShadow(ptr %%out) {\n%s  store <64 x i8> %s, ptr %%out, align 1\n  %%next = getelementptr i8, ptr %%out, i64 64\n  store <64 x i8> %s, ptr %%next, align 1\n  ret void\n}\n", op, output.String(), first, second)
+		fmt.Fprintf(&reference, "extern void %sShadow(uint8_t*);\n", op)
+		fmt.Fprintf(&checks, ` {
+  memset(out,0xa5,sizeof(out));
+  %sShadow(out+16);
+  uint8_t a[64],b[64];
+  for(int i=0;i<64;i++){a[i]=(uint8_t)(i*19+71);b[i]=(uint8_t)(i*37+11);}
+  for(int offset=0;offset<16;offset+=%d){
+   uint64_t value=math(lane(a+offset,%d),lane(b+offset,%d),%d,%d,%d);
+   for(int j=0;j<%d;j++)b[offset+j]=(uint8_t)(value>>(j*8));
+  }
+  if(memcmp(out+16,b,64)||memcmp(out+80,a,64)){fprintf(stderr,"%s alias\n");return 1;}
+  for(int i=0;i<16;i++)if(out[i]!=0xa5||out[144+i]!=0xa5)return 2;
+ }
+`, op, x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestBytes[index], x86LegacyIntegerArithmeticTestModes[index], x86FloatAddSubBoolInt(index >= 9), x86LegacyIntegerArithmeticTestBytes[index], op)
+	}
+	reference.WriteString("int main(void){uint8_t out[160];\n" + checks.String() + "return 0;}\n")
+	// The private shadow has no ISA attributes. Use the same strict body guard
+	// as public portable oracles so new native effects cannot silently enter it.
+	text, err := x86PackedShiftPortableFeatureProjection(ir.String(), profiles)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("amd64-object", func(t *testing.T) {
+		const triple = "x86_64-unknown-linux-gnu"
+		crossIR := strings.Replace(text, "target triple = \""+execution.triple+"\"\n",
+			"target triple = \""+triple+"\"\n", 1)
+		x86ResultInitializationObject(t, execution.llc, triple, crossIR, "legacy-integer-arithmetic-alias")
+	})
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "legacy-integer-arithmetic-alias", text, reference.String(), level)
+		})
+	}
+	t.Log("17 historical software-shadow operations retain all 128 alias bytes and canaries; host execution and AMD64 object, not public/native opcode execution")
+}
diff --git a/amd64_legacy_logical_memory_linux_amd64_test.go b/amd64_legacy_logical_memory_linux_amd64_test.go
new file mode 100644
index 000000000..df2003b39
--- /dev/null
+++ b/amd64_legacy_logical_memory_linux_amd64_test.go
@@ -0,0 +1,9 @@
+package plan9asm
+
+import "testing"
+
+// Required by the cross-runtime CI prefix. The native Linux axis additionally
+// checks the original aligned-m128 contract, which Rosetta does not reproduce.
+func TestCrossLinuxRuntimeMatrixX86LegacyLogicalMemoryNativeFaults(t *testing.T) {
+	x86LegacyLogicalMemoryRuntime(t, true)
+}
diff --git a/amd64_legacy_logical_memory_runtime_unix_test.go b/amd64_legacy_logical_memory_runtime_unix_test.go
new file mode 100644
index 000000000..581ae33a7
--- /dev/null
+++ b/amd64_legacy_logical_memory_runtime_unix_test.go
@@ -0,0 +1,143 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute only first-party, initialized storage. The original reference uses
+// actual stock-Go opcode bytes, not a compiler intrinsic or reconstructed math.
+// Rosetta is a diagnostic transport; required Linux/amd64 executes this root.
+func TestCrossLinuxRuntimeMatrixX86LegacyLogicalMemoryOriginalFaultsAndBytes(t *testing.T) {
+	x86LegacyLogicalMemoryRuntime(t, false)
+}
+
+func x86LegacyLogicalMemoryRuntime(t *testing.T, nativeAlignment bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, kernels, checks strings.Builder
+	signatures := map[string]FuncSig{}
+	for index, name := range x86LegacyLogicalMemoryNames {
+		code := x86LegacyLogicalOriginalBytes(t, "amd64", name)
+		literal := make([]string, len(code))
+		for i, value := range code {
+			literal[i] = fmt.Sprintf("0x%02x", value)
+		}
+		fmt.Fprintf(&kernels, `
+static __attribute__((noinline)) void original%d(uint8_t *out,const uint8_t *a,const uint8_t *b) {
+ __asm__ volatile("movups (%%1),%%%%xmm0\n\tstc\n\t.byte %s\n\tmovups %%%%xmm0,(%%2)\n\tsetc 16(%%2)"
+  : : "a"(a),"r"(b),"r"(out) : "xmm0","memory","cc");
+}
+`, index, strings.Join(literal, ","))
+		for _, dead := range []bool{false, true} {
+			fn := fmt.Sprintf("logical%d_%t", index, dead)
+			fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVUPS (CX),X0\nSTC\n%s (BX),X0\n", fn, name)
+			if !dead {
+				assembly.WriteString("MOVUPS X0,(AX)\n")
+			}
+			assembly.WriteString("SETCS 16(AX)\nRET\n")
+			signatures[fn] = FuncSig{Name: fn, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*);\n", fn)
+		}
+		mode := []int{0, 0, 1, 1, 2, 2, 3, 3, 0, 1, 2, 3}[index]
+		fmt.Fprintf(&checks, `{
+ if(check_values(original%[1]d,logical%[1]d_false,%[2]d)) return %[3]d;
+ for(int kind=%[5]d;kind<3;++kind) {
+  int original_fault=observe_fault(original%[1]d,kind);
+  if(original_fault!=SIGSEGV && original_fault!=SIGBUS) { fprintf(stderr,"%[4]s original fault kind%%d=%%d\n",kind,original_fault); return %[3]d; }
+  if(observe_fault(logical%[1]d_false,kind)!=original_fault || observe_fault(logical%[1]d_true,kind)!=original_fault) return %[3]d;
+ }
+}
+`, index, mode, index+10, name, map[bool]int{false: 1, true: 0}[nativeAlignment])
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: signatures})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const helper = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <xmmintrin.h>
+typedef void (*kernel)(uint8_t*,const uint8_t*,const uint8_t*);
+static int observe_fault(kernel call,int kind) {
+ _Alignas(16) uint8_t a[48],b[48],out[48];
+ memset(a,0x35,sizeof(a)); memset(b,0x71,sizeof(b)); memset(out,0xa7,sizeof(out));
+ long page=sysconf(_SC_PAGESIZE);
+ if(page<=0) return -3;
+ uint8_t *area=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_ANON|MAP_PRIVATE,-1,0);
+ if(area==MAP_FAILED) return -4;
+ if(mprotect(area+page,(size_t)page,PROT_NONE)) { munmap(area,(size_t)page*2); return -5; }
+ pid_t child=fork(); if(child<0) return -1;
+ if(!child) {
+  struct rlimit no_core={0,0};
+  if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+  const uint8_t *source=kind==0?a+1:kind==1?0:area+page;
+  call(out+1,source,b+1);
+  _exit(91);
+ }
+ int status=0;
+ if(waitpid(child,&status,0)!=child) return -2;
+ if(munmap(area,(size_t)page*2)) return -6;
+ return WIFSIGNALED(status)?WTERMSIG(status):-(WEXITSTATUS(status)+100);
+}
+static int check_values(kernel original,kernel translated,int mode) {
+ for(int sample=0;sample<257;++sample) for(int rc=0;rc<4;++rc) {
+  _Alignas(16) uint8_t a[48],b[48],go[48],llvm[48];
+  memset(a,0xa7,sizeof(a)); memset(b,0xb9,sizeof(b));
+  memset(go,0xc3,sizeof(go)); memset(llvm,0xc3,sizeof(llvm));
+  for(int i=0;i<16;++i) { a[i+16]=(uint8_t)(sample*71+i*19); b[i+1]=(uint8_t)(sample*31-i*59); }
+  uint8_t original_a[48],original_b[48]; memcpy(original_a,a,48); memcpy(original_b,b,48);
+  uint32_t saved=_mm_getcsr(),csr=0x1f80|(rc<<13)|(sample&63);
+  _mm_setcsr(csr); original(go+1,a+16,b+1); uint32_t go_csr=_mm_getcsr();
+  _mm_setcsr(csr); translated(llvm+1,a+16,b+1); uint32_t llvm_csr=_mm_getcsr(); _mm_setcsr(saved);
+  if(go_csr!=csr || llvm_csr!=csr || memcmp(a,original_a,48) || memcmp(b,original_b,48) || memcmp(go,llvm,48)) return 1;
+  if(go[17]!=1) return 2;
+  for(int i=0;i<48;++i) if((i<1 || i>17) && go[i]!=0xc3) return 2;
+  for(int i=0;i<16;++i) {
+   uint8_t x=a[i+16],y=b[i+1],want;
+   /* Two PS/PD encodings per operation; the last four are integer aliases. */
+   if(mode==0) want=x&y;
+   else if(mode==1) want=x&(uint8_t)~y;
+   else if(mode==2) want=x|y;
+   else if(mode==3) want=x^y;
+   else return 3;
+   if(go[i+1]!=want) return 4;
+  }
+ }
+ return 0;
+}
+`
+	driver := helper + kernels.String() + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "legacy-logical-native", ir, driver, level)
+		})
+	}
+	t.Logf("12 original memory opcodes: 257×4 initialized byte/CF/MXCSR/canary inputs; live/dead NULL+guard-page faults at O0/O2; native alignment=%t; host=%s/%s", nativeAlignment, runtime.GOOS, runtime.GOARCH)
+}
+
+func TestX86LegacyLogicalMemoryFaultChildDisablesCore(t *testing.T) {
+	if err := runtimeOracleFaultCorePolicy(runtimeOracleFaultC(t, "amd64_legacy_logical_memory_runtime_unix_test.go")); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_legacy_logical_memory_test.go b/amd64_legacy_logical_memory_test.go
new file mode 100644
index 000000000..f0d5fe2f1
--- /dev/null
+++ b/amd64_legacy_logical_memory_test.go
@@ -0,0 +1,312 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86LegacyLogicalOriginalBytes(t *testing.T, arch, name string) []byte {
+	t.Helper()
+	listing := x86InsertExtractGoListing(t, arch, "TEXT original(SB),4,$0-0\n"+name+" (AX),X0\nRET\n")
+	var code []byte
+	for _, line := range strings.Split(string(listing), "\n") {
+		code = append(code, x86InsertExtractListedBytes(line)...)
+	}
+	// Independent Intel encoding, not obtained from the translator's spec.
+	opcode := map[string]byte{
+		"ANDPS": 0x54, "ANDPD": 0x54, "ANDNPS": 0x55, "ANDNPD": 0x55,
+		"ORPS": 0x56, "ORPD": 0x56, "XORPS": 0x57, "XORPD": 0x57,
+		"PAND": 0xdb, "PANDN": 0xdf, "POR": 0xeb, "PXOR": 0xef,
+	}[name]
+	want := []byte{0x0f, opcode, 0x00, 0xc3}
+	if strings.HasSuffix(name, "PD") || strings.HasPrefix(name, "P") {
+		want = append([]byte{0x66}, want...)
+	}
+	if !bytes.Equal(code, want) {
+		t.Fatalf("%s/%s actual Go memory opcode=%x independent encoding=%x", arch, name, code, want)
+	}
+	t.Logf("%s/%s original complete opcode+RET=%x", arch, name, code)
+	return append([]byte(nil), code[:len(code)-1]...)
+}
+
+func TestX86LegacyLogicalMemoryOriginalGoBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range x86LegacyLogicalMemoryNames {
+			t.Run(arch+"/"+name, func(t *testing.T) { x86LegacyLogicalOriginalBytes(t, arch, name) })
+		}
+	}
+}
+
+func TestX86LegacyLogicalMemoryRequiredNativeSelection(t *testing.T) {
+	const file = "amd64_legacy_logical_memory_linux_amd64_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "arm64"}, {"linux", "386"},
+		{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", file)
+		if err != nil || selected != (target.os == "linux" && target.arch == "amd64") {
+			t.Fatalf("stock Go required native selection %s/%s: %t/%v", target.os, target.arch, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), file, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(syntax.Decls) != 2 {
+		t.Fatal("native wrapper must contain only its import and required root")
+	}
+	function, ok := syntax.Decls[1].(*ast.FuncDecl)
+	if !ok || function.Name.Name != "TestCrossLinuxRuntimeMatrixX86LegacyLogicalMemoryNativeFaults" || len(function.Body.List) != 1 {
+		t.Fatal("native root registration changed or became optional")
+	}
+	statement, ok := function.Body.List[0].(*ast.ExprStmt)
+	if !ok {
+		t.Fatal("native root bypassed its mandatory helper")
+	}
+	call, ok := statement.X.(*ast.CallExpr)
+	if !ok || len(call.Args) != 2 {
+		t.Fatal("native root must call the full fault helper")
+	}
+	callee, ok := call.Fun.(*ast.Ident)
+	if !ok || callee.Name != "x86LegacyLogicalMemoryRuntime" {
+		t.Fatal("native root changed helper")
+	}
+	argument, ok := call.Args[1].(*ast.Ident)
+	if !ok || argument.Name != "true" {
+		t.Fatal("native root omitted its alignment axis")
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") {
+		t.Fatalf("required cross-runtime prefix missing: %v", err)
+	}
+}
+
+func TestX86LegacyLogicalMemoryUnboundAddressSizeBeforeEmission(t *testing.T) {
+	for _, name := range x86LegacyLogicalMemoryNames {
+		file, err := Parse(ArchAMD64, "TEXT view(SB),4,$0-0\n"+name+" (AX),X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, bits := range []int{32, 64} {
+			ins := file.Funcs[0].Instrs[1]
+			ins.x86AddressBits = bits
+			var output strings.Builder
+			context := &amd64Ctx{goarch: "amd64", b: &output}
+			known, terminal, err := context.lowerPackedLogicalFamily(ins.Op, ins)
+			if !known || terminal || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+				t.Fatalf("%s unbound address-size%d emitted IR: %t/%t/%v", name, bits, known, terminal, err)
+			}
+		}
+	}
+}
+
+// Independent legacy namespace: these twelve Go names all have an m128
+// source whose original SSE instruction requires aligned native storage.
+var x86LegacyLogicalMemoryNames = []string{
+	"ANDPS", "ANDPD", "ANDNPS", "ANDNPD", "ORPS", "ORPD",
+	"XORPS", "XORPD", "PAND", "PANDN", "POR", "PXOR",
+}
+
+var x86LegacyLogicalMemoryTargets = []struct{ arch, triple string }{
+	{"amd64", "x86_64-apple-darwin"},
+	{"amd64", "x86_64-unknown-linux-gnu"},
+	{"amd64", "x86_64-pc-windows-msvc"},
+	{"386", "i386-unknown-linux-gnu"},
+	{"386", "i686-pc-windows-msvc"},
+}
+
+func TestX86LegacyLogicalMemoryFPNeedsNativeBacking(t *testing.T) {
+	for _, target := range x86LegacyLogicalMemoryTargets {
+		for _, name := range x86LegacyLogicalMemoryNames {
+			source := "TEXT ·view(SB),4,$0-16\nMOVOU a+0(FP),X0\n" + name + " a+0(FP),X0\nRET\n"
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+name+"/"+api, func(t *testing.T) {
+					_, err := x86ScalarFPBitViewAPI(t, source, "func view(a,b uint64)", target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "original native storage") {
+						t.Fatalf("independent FP bytes fabricated native m128 backing/alignment: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyLogicalMemoryVirtualStackNeedsCertificate(t *testing.T) {
+	for _, target := range x86LegacyLogicalMemoryTargets {
+		for _, name := range x86LegacyLogicalMemoryNames {
+			for _, address := range []string{"16(SP)", "16(BP)", "16(AX)(BP*1)"} {
+				source := x86OrdinaryBPNativeSource(target.arch, "view", name+" "+address+",X0", address, 0)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+name+"/"+address+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *byte)", target.arch, target.triple, api)
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, address, ir, err)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LegacyLogicalMemoryNativeOpcodeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86LegacyLogicalMemoryTargets {
+		var source, ordinary, declaration strings.Builder
+		source.WriteString("GLOBL ·data(SB),8,$16\n")
+		ordinary.WriteString("GLOBL ·data(SB),8,$16\n")
+		declaration.WriteString("var data [16]byte\n")
+		for _, name := range x86LegacyLogicalMemoryNames {
+			move, size := "MOVQ", 8
+			if target.arch == "386" {
+				move, size = "MOVL", 4
+			}
+			for i, address := range []string{"(AX)", "16(AX)(CX*2)", "·data(SB)", "(FS)", "(GS)"} {
+				fn := fmt.Sprintf("%s%d", strings.ToLower(name), i)
+				body := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n"+
+					"%s p+0(FP),AX\n%s index+%d(FP),CX\nPXOR X0,X0\n%s %s,X0\nRET\n",
+					fn, size*2, move, move, size, name, address)
+				source.WriteString(body)
+				if i < 3 {
+					ordinary.WriteString(body)
+				}
+				fmt.Fprintf(&declaration, "func %s(p *byte,index uintptr)\n", fn)
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := mustGoPackage(t, "logical", "package logical\n"+declaration.String())
+		resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+		signatures, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+		if err != nil || len(file.Funcs) != 60 {
+			t.Fatal("original logical-memory format inventory changed", err)
+		}
+		// Original FS/GS operands have no Go TLS/segment contract. Keep all
+		// sixty formats as emitter objects and public Context, not public success.
+		formatIR := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+		for _, name := range x86LegacyLogicalMemoryNames {
+			for _, segment := range []string{"fs", "gs"} {
+				want := "asm sideeffect \"" + strings.ToLower(name) + " %" + segment + ":($2), $0\""
+				if !strings.Contains(formatIR, want) {
+					t.Fatal("original native segment format lost its prefix", name, segment)
+				}
+			}
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, target.triple, formatIR, level)
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, ordinary.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration.String(), target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original segmented source acquired an unbound TLS contract", api, err)
+				}
+				ir, err = x86ScalarFPBitViewAPI(t, ordinary.String(), declaration.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, name := range x86LegacyLogicalMemoryNames {
+					want := "asm sideeffect \"" + strings.ToLower(name) + " ($2), $0\", \"=x,0,r,~{memory}\""
+					if !strings.Contains(ir, want) {
+						t.Fatalf("dead result lost original single native %s memory effect", name)
+					}
+				}
+				compileLLVMToObject(t, llc, target.triple, "logical-native.ll", "logical-native.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86LegacyLogicalMemoryPSRetainsSSE1Carrier(t *testing.T) {
+	var source strings.Builder
+	for _, name := range []string{"ANDPS", "ANDNPS", "ORPS", "XORPS"} {
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\nMOVUPS (AX),X0\n%s (AX),X0\nMOVUPS X0,(BX)\nRET\n", strings.ToLower(name), name)
+	}
+	file, signatures := x86UnboundVoidFormatSources(t, source.String(), "386", "i386-unknown-linux-gnu")
+	ir := x86ScalarFormatObjectUnit(t, file, signatures, "386", "i386-unknown-linux-gnu", 0)
+	x86LegacyLogicalSSE1Objects(t, ir)
+}
+
+func TestX86LegacyLogicalMemoryPSInitializedSSE1Objects(t *testing.T) {
+	var source, declaration strings.Builder
+	for _, name := range []string{"ANDPS", "ANDNPS", "ORPS", "XORPS"} {
+		fn := strings.ToLower(name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\n"+
+			"MOVL p+0(FP),AX\nMOVL out+4(FP),BX\nMOVUPS (AX),X0\n"+
+			"%s (AX),X0\nMOVUPS X0,(BX)\nRET\n", fn, name)
+		fmt.Fprintf(&declaration, "func %s(p,out *byte)\n", fn)
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		x86LEAActualTargetGoObject(t, "386", triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration.String(), "386", triple, api)
+				if err != nil {
+					t.Fatal("initialized SSE1 native-memory program", err)
+				}
+				x86LegacyLogicalSSE1Objects(t, ir)
+			})
+		}
+	}
+}
+
+func x86LegacyLogicalSSE1Objects(t *testing.T, ir string) {
+	t.Helper()
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and objdump required")
+	}
+	if !strings.Contains(ir, "call <4 x float> asm sideeffect") || strings.Contains(ir, "+sse2") {
+		t.Fatal("PS native carrier silently requires SSE2")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			directory := t.TempDir()
+			input, object := filepath.Join(directory, "sse1.ll"), filepath.Join(directory, "sse1.o")
+			if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, llc, level, "-filetype=obj", input, "-o", object))
+			cancel()
+			if err != nil {
+				t.Fatalf("SSE1 object: %v\n%s", err, output)
+			}
+			ctx, cancel = runtimeOracleStageContext(t)
+			output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, objdump, "-d", object))
+			cancel()
+			if err != nil {
+				t.Fatalf("SSE1 disassembly: %v\n%s", err, output)
+			}
+			for _, name := range []string{"andps", "andnps", "orps", "xorps"} {
+				if !strings.Contains(string(output), name) {
+					t.Fatalf("SSE1 object lost %s", name)
+				}
+			}
+			for _, forbidden := range []string{"movdqa", "movdqu", "pand", "pxor", "por", "movapsd", "movq\t%xmm"} {
+				if strings.Contains(string(output), forbidden) {
+					t.Fatalf("SSE1 source introduced %s:\n%s", forbidden, output)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_legacy_mmx_bank.go b/amd64_legacy_mmx_bank.go
new file mode 100644
index 000000000..30d108a22
--- /dev/null
+++ b/amd64_legacy_mmx_bank.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86LegacyMMXTable uint8
+
+const (
+	x86LegacyMMXBinary x86LegacyMMXTable = iota
+	x86LegacyMMXHorizontal
+	x86LegacyMMXShuffle
+	x86LegacyMMXCount
+)
+
+type x86LegacyMMXReadSpec struct {
+	table                                x86LegacyMMXTable
+	opcode, immediateOpcode, opcodeDigit byte
+}
+
+// This is the complete integer MMX-read class in Go's ymm, ymmxmm0f38,
+// ymshuf and yps tables. MOVQ, PINSR, PEXTR and floating conversions have
+// different ordered operand roles and must not use this bank selector.
+var x86LegacyMMXReadSpecs = map[Op]x86LegacyMMXReadSpec{
+	"PACKSSLW":  {opcode: 0x6b},
+	"PACKSSWB":  {opcode: 0x63},
+	"PACKUSWB":  {opcode: 0x67},
+	"PADDB":     {opcode: 0xfc},
+	"PADDL":     {opcode: 0xfe},
+	"PADDW":     {opcode: 0xfd},
+	"PADDSB":    {opcode: 0xec},
+	"PADDSW":    {opcode: 0xed},
+	"PADDUSB":   {opcode: 0xdc},
+	"PADDUSW":   {opcode: 0xdd},
+	"PAND":      {opcode: 0xdb},
+	"PANDN":     {opcode: 0xdf},
+	"POR":       {opcode: 0xeb},
+	"PXOR":      {opcode: 0xef},
+	"PAVGB":     {opcode: 0xe0},
+	"PAVGW":     {opcode: 0xe3},
+	"PCMPEQB":   {opcode: 0x74},
+	"PCMPEQW":   {opcode: 0x75},
+	"PCMPEQL":   {opcode: 0x76},
+	"PCMPGTB":   {opcode: 0x64},
+	"PCMPGTW":   {opcode: 0x65},
+	"PCMPGTL":   {opcode: 0x66},
+	"PMADDWL":   {opcode: 0xf5},
+	"PMULLW":    {opcode: 0xd5},
+	"PMULHW":    {opcode: 0xe5},
+	"PMULHUW":   {opcode: 0xe4},
+	"PMULULQ":   {opcode: 0xf4},
+	"PUNPCKHBW": {opcode: 0x68},
+	"PUNPCKHWL": {opcode: 0x69},
+	"PUNPCKHLQ": {opcode: 0x6a},
+	"PUNPCKLBW": {opcode: 0x60},
+	"PUNPCKLWL": {opcode: 0x61},
+	"PUNPCKLLQ": {opcode: 0x62},
+	"PHADDD":    {table: x86LegacyMMXHorizontal, opcode: 0x02},
+	"PSHUFW":    {table: x86LegacyMMXShuffle, opcode: 0x70},
+	"PSLLW":     {x86LegacyMMXCount, 0xf1, 0x71, 6},
+	"PSLLL":     {x86LegacyMMXCount, 0xf2, 0x72, 6},
+	"PSLLQ":     {x86LegacyMMXCount, 0xf3, 0x73, 6},
+	"PSRLW":     {x86LegacyMMXCount, 0xd1, 0x71, 2},
+	"PSRLL":     {x86LegacyMMXCount, 0xd2, 0x72, 2},
+	"PSRLQ":     {x86LegacyMMXCount, 0xd3, 0x73, 2},
+	"PSRAW":     {x86LegacyMMXCount, 0xe1, 0x71, 4},
+	"PSRAL":     {x86LegacyMMXCount, 0xe2, 0x72, 4},
+}
+
+type x86LegacyMMXEncodingRow struct {
+	classes             []string
+	zcase               string
+	zoffset, byteOffset int
+}
+
+func (s x86LegacyMMXReadSpec) encoderRows() (string, string, []byte, []x86LegacyMMXEncodingRow) {
+	switch s.table {
+	case x86LegacyMMXBinary:
+		return "ymm", "Py1", []byte{s.opcode, 0x66, s.opcode}, []x86LegacyMMXEncodingRow{
+			{[]string{"Ymm", "Ymr"}, "Zm_r_xm", 1, 0},
+			{[]string{"Yxm", "Yxr"}, "Zm_r_xm", 2, 1},
+		}
+	case x86LegacyMMXHorizontal:
+		// Go advances z by zoffset+xo; the initial 0x0f makes xo=1.
+		return "ymmxmm0f38", "Px", []byte{0x0f, 0x38, s.opcode, 0, 0x66, 0x0f, 0x38, s.opcode, 0}, []x86LegacyMMXEncodingRow{
+			{[]string{"Ymm", "Ymr"}, "Zlitm_r", 3, 0},
+			{[]string{"Yxm", "Yxr"}, "Zlitm_r", 5, 4},
+		}
+	case x86LegacyMMXShuffle:
+		return "ymshuf", "Pm", []byte{s.opcode, 0}, []x86LegacyMMXEncodingRow{
+			{[]string{"Yi8", "Ymm", "Ymr"}, "Zibm_r", 2, 0},
+		}
+	default:
+		return "yps", "Py3", []byte{s.opcode, s.immediateOpcode, s.opcodeDigit,
+			0x66, s.opcode, 0x66, s.immediateOpcode, s.opcodeDigit}, []x86LegacyMMXEncodingRow{
+			{[]string{"Ymm", "Ymr"}, "Zm_r_xm", 1, 0},
+			{[]string{"Yi8", "Ymr"}, "Zibo_m_xm", 2, 1},
+			{[]string{"Yxm", "Yxr"}, "Zm_r_xm", 2, 3},
+			{[]string{"Yi8", "Yxr"}, "Zibo_m_xm", 3, 5},
+		}
+	}
+}
+
+type x86LegacyMMXReadForm struct {
+	canonical                Op
+	spec                     x86LegacyMMXReadSpec
+	row                      int
+	sourceIndex, destination int
+	source                   Operand
+	byteWidth, memoryBytes   int
+	mmx, gpSpelling          bool
+}
+
+func x86LegacyMMXGPBank(reg Reg, arch string) (Reg, bool) {
+	for index, register := range [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI,
+		"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		if reg == register && (arch == "amd64" || arch == "386" && index < 8) {
+			return [...]Reg{"M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7"}[index&7], true
+		}
+	}
+	return "", false
+}
+
+// The selected Go row records physical source identity only. It does not
+// define any M register, authorize a native address, model x87 state or
+// supply an incoming/caller contract. Raw physical instructions never turn
+// a GP source into MMX through Go's source-only ycover compatibility.
+func x86LegacyMMXReadProperties(ins Instr, arch string) (x86LegacyMMXReadForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if name == "PADDD" {
+		name = "PADDL"
+	}
+	spec, known := x86LegacyMMXReadSpecs[Op(name)]
+	if !known {
+		return x86LegacyMMXReadForm{}, false, nil
+	}
+	form := x86LegacyMMXReadForm{canonical: Op(name), spec: spec, sourceIndex: 0,
+		destination: len(ins.Args) - 1, byteWidth: 16}
+	fail := func() (x86LegacyMMXReadForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go integer Ymm read rows: %q", arch, ins.Op, ins.Raw)
+	}
+	want := 2
+	if spec.table == x86LegacyMMXShuffle {
+		want, form.sourceIndex = 3, 1
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != want || ins.Args[form.destination].Kind != OpReg {
+		return fail()
+	}
+	destination := ins.Args[form.destination]
+	_, form.mmx = amd64ParseMReg(destination.Reg)
+	if form.mmx {
+		form.byteWidth = 8
+		if arch == "386" && !ins.x86Encoded && (spec.table == x86LegacyMMXBinary || spec.table == x86LegacyMMXCount) {
+			return fail()
+		}
+	} else {
+		index, valid := amd64ParseXReg(destination.Reg)
+		if !valid || index >= 16 || arch == "386" && index >= 8 || spec.table == x86LegacyMMXShuffle {
+			return fail()
+		}
+	}
+	form.source = ins.Args[form.sourceIndex]
+	immediate := spec.table == x86LegacyMMXCount && form.source.Kind == OpImm
+	if spec.table == x86LegacyMMXShuffle || immediate {
+		operand, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+		if !integer || !amd64SignedImmediate(operand, 8) {
+			return fail()
+		}
+	}
+	switch {
+	case immediate:
+		// An immediate count has no source-bank read.
+	case form.source.Kind == OpReg && form.mmx:
+		if _, valid := amd64ParseMReg(form.source.Reg); !valid {
+			register, valid := x86LegacyMMXGPBank(form.source.Reg, arch)
+			if !valid || ins.x86Encoded {
+				return fail()
+			}
+			form.source.Reg, form.gpSpelling = register, true
+		}
+	case form.source.Kind == OpReg:
+		index, valid := amd64ParseXReg(form.source.Reg)
+		if !valid || index >= 16 || arch == "386" && index >= 8 {
+			return fail()
+		}
+	case isAMD64MemoryOperand(form.source) && x86PackedShiftMemoryValid(form.source, arch):
+		form.memoryBytes = form.byteWidth
+		if form.mmx && (name == "PUNPCKLBW" || name == "PUNPCKLWL" || name == "PUNPCKLLQ") {
+			form.memoryBytes = 4
+		}
+	default:
+		return fail()
+	}
+	if spec.table == x86LegacyMMXCount {
+		if form.mmx {
+			if immediate {
+				form.row = 1
+			}
+		} else {
+			form.row = 2
+			if immediate {
+				form.row = 3
+			}
+		}
+	} else if !form.mmx {
+		form.row = 1
+	}
+	return form, true, nil
+}
+
+func x86LegacyMMXReadInstruction(ins Instr, arch string) (Instr, error) {
+	form, known, err := x86LegacyMMXReadProperties(ins, arch)
+	if !known || err != nil {
+		return ins, err
+	}
+	local := ins
+	local.Args = append([]Operand(nil), ins.Args...)
+	local.Args[form.sourceIndex] = form.source
+	return local, nil
+}
+
+func x86LegacyMMXReadEmitterContext(ins Instr, arch string) error {
+	form, known, err := x86LegacyMMXReadProperties(ins, arch)
+	if !known || err != nil {
+		return err
+	}
+	if form.gpSpelling {
+		return fmt.Errorf("%w: %s source %s encodes %s without a proved initialized physical MMX bank transport",
+			ErrProbeNeedsContext, ins.Op, ins.Args[form.sourceIndex].Reg, form.source.Reg)
+	}
+	return nil
+}
diff --git a/amd64_legacy_mmx_bank_test.go b/amd64_legacy_mmx_bank_test.go
new file mode 100644
index 000000000..7bf5b6bde
--- /dev/null
+++ b/amd64_legacy_mmx_bank_test.go
@@ -0,0 +1,549 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// This census is independent of the implementation. Ordered Go tables,
+// opcode prefixes and all opBytes remain available to each comparison.
+type x86YMMOriginalRule struct {
+	name, table, prefix, opBytes string
+}
+
+func x86YMMOriginalRules(t *testing.T) []x86YMMOriginalRule {
+	t.Helper()
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rules []x86YMMOriginalRule
+	pattern := regexp.MustCompile(`\{A([A-Z0-9]+), (ymm|ymmxmm0f38|ymshuf|yps), (\w+), opBytes\{([^}]+)\}\}`)
+	for _, row := range pattern.FindAllStringSubmatch(string(source), -1) {
+		rules = append(rules, x86YMMOriginalRule{row[1], row[2], row[3], row[4]})
+	}
+	if len(rules) != 43 {
+		t.Fatalf("complete integer MMX-read rule census changed: %d", len(rules))
+	}
+	return rules
+}
+
+func x86YMMReadSource(t *testing.T, row string) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+row+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86YMMExistingDescriptorsOriginalBank(t *testing.T) {
+	var names []string
+	for _, rule := range x86YMMOriginalRules(t) {
+		if strings.HasPrefix(rule.name, "PUNPCK") || rule.name == "PAND" || rule.name == "PANDN" ||
+			rule.name == "POR" || rule.name == "PXOR" || rule.table == "yps" && !strings.HasPrefix(rule.name, "PSRA") {
+			names = append(names, rule.name)
+		}
+	}
+	sort.Strings(names)
+	if len(names) != 16 {
+		t.Fatal("logical/unpack/uniform logical-shift descriptor class changed", names)
+	}
+	for _, name := range names {
+		for index, source := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			t.Run(name+"/"+source, func(t *testing.T) {
+				ins := x86YMMReadSource(t, name+" "+source+",M1")
+				before := fmt.Sprintf("%#v", ins)
+				var known bool
+				var err error
+				var selected Operand
+				switch {
+				case strings.HasPrefix(name, "PUNPCK"):
+					var form x86PackedUnpackForm
+					form, known, err = x86PackedUnpackProperties(ins, "amd64")
+					selected = form.source
+				case strings.HasPrefix(name, "PS"):
+					var form x86PackedShiftForm
+					form, known, err = x86PackedShiftProperties(ins.Op, ins, "amd64")
+					selected = form.countOperand
+				default:
+					var form x86PackedLogicalForm
+					form, known, err = x86PackedLogicalProperties(ins, "amd64")
+					selected = form.source
+				}
+				if !known || err != nil {
+					t.Errorf("actual Go MMX-read spelling is absent from pure descriptor: %t/%v", known, err)
+				}
+				if err == nil && (selected.Kind != OpReg || selected.Reg != Reg(fmt.Sprintf("M%d", index&7))) {
+					t.Errorf("family descriptor retained the source GP bank: %+v", selected)
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("pure descriptor mutated original source")
+				}
+			})
+		}
+	}
+}
+
+func TestX86YMMOriginalGoIntegerReadBanks(t *testing.T) {
+	registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15", "M0", "M7"}
+	var rows []string
+	var expected []x86asm.Reg
+	for _, rule := range x86YMMOriginalRules(t) {
+		for index, source := range registers {
+			prefix := ""
+			if rule.table == "ymshuf" {
+				prefix = "$27,"
+			}
+			rows = append(rows, rule.name+" "+prefix+source+",M1")
+			bank := index & 7
+			if source == "M0" {
+				bank = 0
+			} else if source == "M7" {
+				bank = 7
+			}
+			expected = append(expected, x86asm.M0+x86asm.Reg(bank))
+		}
+	}
+	// Alias has independent original Go evidence, not a prefix-name inference.
+	rows = append(rows, "PADDD AX,M1")
+	expected = append(expected, x86asm.M0)
+	code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n")
+	t.Logf("complete original Go bytes=%x SHA256=%x", code, sha256.Sum256(code))
+	for index, row := range rows {
+		physical, err := x86asm.Decode(code, 64)
+		if err != nil {
+			t.Fatal("original object cannot be decoded", row, err)
+		}
+		if physical.Args[0] != x86asm.M1 || physical.Args[1] != expected[index] {
+			t.Fatalf("original Go selected different physical register bank: %s bytes=%x operands=%v expected M1/%s",
+				row, code[:physical.Len], physical.Args, expected[index])
+		}
+		decoded, err := decodeX86RawDirectiveGroup(code[:physical.Len], 64, 0, row, map[string]bool{})
+		if err != nil || len(decoded) != 1 {
+			t.Fatal("actual physical Go instruction did not decode as one typed row", row, decoded, err)
+		}
+		form, known, err := x86LegacyMMXReadProperties(decoded[0], "amd64")
+		if !known || err != nil || form.gpSpelling || form.source.Reg != Reg(expected[index].String()) {
+			t.Fatal("raw decoder changed the actual MMX bank into a source spelling", row, decoded, form, known, err)
+		}
+		code = code[physical.Len:]
+	}
+	if len(code) == 0 || code[0] != 0xc3 || !bytes.Equal(bytes.Trim(code[1:], "\x00"), nil) {
+		t.Fatalf("original complete native instruction sequence has an unexpected tail: %x", code)
+	}
+	t.Logf("actual Go integer MMX-read rows=%d, physical M input independent of GP spelling", len(rows))
+}
+
+func TestX86YMMSelectorReusableDescriptorBanks(t *testing.T) {
+	for _, rule := range x86YMMOriginalRules(t) {
+		for index, register := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI",
+			"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			row := rule.name + " " + register + ",M1"
+			if rule.table == "ymshuf" {
+				row = rule.name + " $27," + register + ",M1"
+			}
+			ins := x86YMMReadSource(t, row)
+			form, known, err := x86LegacyMMXReadProperties(ins, "amd64")
+			if !known || err != nil || !form.gpSpelling || !form.mmx || form.row != 0 ||
+				form.source.Reg != Reg(fmt.Sprintf("M%d", index&7)) {
+				t.Fatal("complete selector lost physical source bank", row, form, known, err)
+			}
+			effect, known, err := x86PackedBinaryByteEffect(ins.Op, ins, "amd64")
+			if known {
+				if err != nil || len(effect.operands) != 2 || effect.operands[0].operand.Reg != form.source.Reg ||
+					effect.operands[0].width != 8 || !effect.operands[0].read || effect.operands[0].write {
+					t.Fatal("existing byte descriptor does not share encoded bank selection", row, effect, err)
+				}
+			}
+			if strings.HasPrefix(rule.name, "PACK") {
+				pack, known, err := x86PackedNarrowProperties(ins, "amd64")
+				if !known || err != nil || pack.source.Reg != form.source.Reg {
+					t.Fatal("pack descriptor does not share encoded bank selection", row, pack, known, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86YMMSelectorContextIsBeforeIRAndKeepsInput(t *testing.T) {
+	for _, rule := range x86YMMOriginalRules(t) {
+		prefix := ""
+		if rule.table == "ymshuf" {
+			prefix = "$27,"
+		}
+		ins := x86YMMReadSource(t, rule.name+" "+prefix+"AX,M1")
+		file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before, original := output.String(), fmt.Sprintf("%#v", ins)
+		terminated, err := ctx.lowerInstr(0, 0, ins, nil, nil)
+		if terminated || !errors.Is(err, ErrProbeNeedsContext) || before != output.String() || original != fmt.Sprintf("%#v", ins) {
+			t.Fatal("source-bank Context was late or mutated the source/IR", rule.name, terminated, err)
+		}
+	}
+}
+
+func TestX86YMMSelectorCompleteOriginalOrderedRules(t *testing.T) {
+	bytesSource, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(bytesSource)
+	if len(x86LegacyMMXReadSpecs) != 43 {
+		t.Fatal("selector class does not have exactly 43 canonical names")
+	}
+	for _, rule := range x86YMMOriginalRules(t) {
+		t.Run(rule.name, func(t *testing.T) {
+			spec, found := x86LegacyMMXReadSpecs[Op(rule.name)]
+			if !found {
+				t.Fatal("complete original integer read class lacks a selector")
+			}
+			table, prefix, opcodeBytes, rows := spec.encoderRows()
+			var originalBytes []byte
+			for _, token := range strings.Split(rule.opBytes, ",") {
+				token = strings.TrimSpace(token)
+				if token == "Pe" {
+					token = "0x66"
+				}
+				value, err := strconv.ParseUint(token, 0, 8)
+				if err != nil {
+					t.Fatal("unknown original opBytes expression", token, err)
+				}
+				originalBytes = append(originalBytes, byte(value))
+			}
+			if table != rule.table || prefix != rule.prefix || !bytes.Equal(opcodeBytes, originalBytes) {
+				t.Fatalf("selected encoding metadata differs from original Go: %s/%s %x; original=%+v %x",
+					table, prefix, opcodeBytes, rule, originalBytes)
+			}
+			block := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(source)
+			if len(block) != 2 {
+				t.Fatal("original ordered table was not found", table)
+			}
+			pattern := regexp.MustCompile(`\{(Z\w+), (\d+), argList\{([^}]+)\}\}`)
+			originalRows := pattern.FindAllStringSubmatch(block[1], -1)
+			if len(rows) != len(originalRows) {
+				t.Fatal("original ordered table row count changed")
+			}
+			byteOffset, xo := 0, 0
+			if originalBytes[0] == 0x0f {
+				xo = 1
+			}
+			for index, original := range originalRows {
+				zoffset, _ := strconv.Atoi(original[2])
+				classes := strings.Split(strings.ReplaceAll(original[3], " ", ""), ",")
+				row := rows[index]
+				if row.zcase != original[1] || row.zoffset != zoffset || row.byteOffset != byteOffset ||
+					!reflect.DeepEqual(row.classes, classes) {
+					t.Fatalf("ordered row %d differs: %+v original=%v offset=%d", index, row, original, byteOffset)
+				}
+				byteOffset += zoffset + xo
+			}
+		})
+	}
+}
+
+func TestX86YMMSelectorCompleteRolesAndImmutability(t *testing.T) {
+	for _, rule := range x86YMMOriginalRules(t) {
+		for destination := 0; destination < 8; destination++ {
+			for source := 0; source < 8; source++ {
+				prefix := ""
+				if rule.table == "ymshuf" {
+					prefix = "$27,"
+				}
+				ins := x86YMMReadSource(t, fmt.Sprintf("%s %sM%d,M%d", rule.name, prefix, source, destination))
+				before := fmt.Sprintf("%#v", ins)
+				form, known, err := x86LegacyMMXReadProperties(ins, "amd64")
+				if !known || err != nil || !form.mmx || form.gpSpelling || form.row != 0 ||
+					form.byteWidth != 8 || form.memoryBytes != 0 || form.source.Reg != Reg(fmt.Sprintf("M%d", source)) {
+					t.Fatal("literal MMX source/destination role changed", ins, form, known, err)
+				}
+				local, err := x86LegacyMMXReadInstruction(ins, "amd64")
+				if err != nil || before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("selector mutated original", err)
+				}
+				local.Args[form.sourceIndex].Reg = "M6"
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("normalized operand slice aliases original")
+				}
+			}
+		}
+		prefix := ""
+		if rule.table == "ymshuf" {
+			prefix = "$27,"
+		}
+		for _, bank := range []string{"M", "X"} {
+			if bank == "X" && rule.table == "ymshuf" {
+				continue
+			}
+			ins := x86YMMReadSource(t, rule.name+" "+prefix+"(AX),"+bank+"1")
+			form, known, err := x86LegacyMMXReadProperties(ins, "amd64")
+			want := 16
+			if bank == "M" {
+				want = 8
+				if strings.HasPrefix(rule.name, "PUNPCKL") {
+					want = 4
+				}
+			}
+			if !known || err != nil || form.memoryBytes != want || form.gpSpelling {
+				t.Fatal("complete native read shape changed", ins, form, known, err)
+			}
+			if rule.table == "yps" {
+				for _, count := range []int{-128, 0, 127} {
+					ins = x86YMMReadSource(t, fmt.Sprintf("%s $%d,%s1", rule.name, count, bank))
+					form, known, err = x86LegacyMMXReadProperties(ins, "amd64")
+					if !known || err != nil || form.row != 1 && form.row != 3 || form.memoryBytes != 0 || form.gpSpelling {
+						t.Fatal("immediate row borrowed a bank read", ins, form, known, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86YMMSelectorActualGoModeAndRoleBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, rule := range x86YMMOriginalRules(t) {
+			prefix := ""
+			if rule.table == "ymshuf" {
+				prefix = "$27,"
+			}
+			row := rule.name + " " + prefix + "AX,M1"
+			source := "TEXT probe(SB),4,$0-0\n" + row + "\nRET\n"
+			want := arch == "amd64" || rule.table == "ymshuf" || rule.table == "ymmxmm0f38"
+			goAssemblerOracleOutput(t, arch, source, "", want)
+			form, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), arch)
+			if !known || (err == nil) != want || want && (form.source.Reg != "M0" || !form.gpSpelling) {
+				t.Fatal("actual named mode admission differs from selector", arch, row, form, known, err)
+			}
+			if want {
+				code := x86PackedShiftActualGoBytes(t, arch, source)
+				mode := 64
+				if arch == "386" {
+					mode = 32
+				}
+				physical, err := x86asm.Decode(code, mode)
+				if err != nil || physical.Args[0] != x86asm.M1 || physical.Args[1] != x86asm.M0 {
+					t.Fatal("actual accepted mode did not select physical MMX", arch, row, physical, err)
+				}
+			}
+		}
+	}
+	for _, row := range []string{"PAND M0,X1", "PAND X0,M1", "PAND AX,X1", "PAND M0,AX",
+		"PAND R8,M1", "PSHUFW $128,M0,M1", "PSHUFW $-129,M0,M1", "PSRLW $128,X1"} {
+		arch := "amd64"
+		if row == "PAND R8,M1" {
+			arch = "386"
+		}
+		goAssemblerOracleOutput(t, arch, "TEXT probe(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		_, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), arch)
+		if !known || err == nil {
+			t.Fatal("original Go rejected row obtained a pure bank form", arch, row, known, err)
+		}
+	}
+}
+
+func TestX86YMMSelectorActualMode32GPSpellings(t *testing.T) {
+	for _, name := range []string{"PHADDD", "PSHUFW"} {
+		for index, register := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI",
+			"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			prefix := ""
+			if name == "PSHUFW" {
+				prefix = "$27,"
+			}
+			row := name + " " + prefix + register + ",M1"
+			source := "TEXT probe(SB),4,$0-0\n" + row + "\nRET\n"
+			want := index < 8
+			goAssemblerOracleOutput(t, "386", source, "", want)
+			form, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), "386")
+			if !known || (err == nil) != want || want && form.source.Reg != Reg(fmt.Sprintf("M%d", index)) {
+				t.Fatal("mode32 original GP class does not match selected MMX bank", row, form, known, err)
+			}
+		}
+	}
+}
+
+func TestX86YMMSelectorExcludesRealGPRolesAndPhysicalForgery(t *testing.T) {
+	for _, row := range []string{"MOVQ AX,M1", "PINSRB $0,AX,X1", "PINSRD $0,AX,X1", "PINSRQ $0,AX,X1",
+		"PEXTRB $0,X1,AX", "PEXTRD $0,X1,AX", "PEXTRQ $0,X1,AX", "CVTPL2PS M0,X1", "CVTPL2PD M0,X1"} {
+		_, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), "amd64")
+		if known || err != nil {
+			t.Fatal("different ordered GP/x87 role was claimed by integer read selector", row, known, err)
+		}
+	}
+	for _, rule := range x86YMMOriginalRules(t) {
+		prefix := ""
+		if rule.table == "ymshuf" {
+			prefix = "$27,"
+		}
+		ins := x86YMMReadSource(t, rule.name+" "+prefix+"AX,M1")
+		ins.x86Encoded = true
+		if _, known, err := x86LegacyMMXReadProperties(ins, "amd64"); !known || err == nil {
+			t.Fatal("physical decoder identity acquired source-only GP compatibility", rule.name)
+		}
+		ins.Args[len(ins.Args)-2].Reg = "M0"
+		if form, known, err := x86LegacyMMXReadProperties(ins, "386"); !known || err != nil || form.gpSpelling {
+			t.Fatal("actual physical MMX input was changed into a source alias", rule.name, form, known, err)
+		}
+	}
+	for _, row := range []string{"PAND.BAD AX,M1", "PAND AX,M8", "PSHUFW $0,AX,X1"} {
+		if _, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), "amd64"); !known || err == nil {
+			t.Fatal("malformed selector identity was accepted", row)
+		}
+	}
+}
+
+func TestX86YMMSelectorDoesNotGrantEmitterOrCallerAuthority(t *testing.T) {
+	for _, rule := range x86YMMOriginalRules(t) {
+		prefix := ""
+		if rule.table == "ymshuf" {
+			prefix = "$27,"
+		}
+		row := rule.name + " " + prefix + "AX,M1"
+		ins := x86YMMReadSource(t, row)
+		if !errors.Is(x86LegacyMMXReadEmitterContext(ins, "amd64"), ErrProbeNeedsContext) || x86CallerVectorMoveKnown(ins) {
+			t.Fatal("bank identity alone acquired transport or caller permission", row)
+		}
+		ins.Args[len(ins.Args)-2].Reg = "M0"
+		state := x86SourceStackState{vectors: map[Reg]uint64{}, masks: map[Reg]bool{}}
+		if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &state, &x86GoCallerRegionProof{}) {
+			t.Fatal("undefined MMX input acquired a caller value", rule.name)
+		}
+		pkg := mustGoPackage(t, "probe", "package probe\nfunc probe()\n")
+		source := "TEXT ·probe(SB),4,$0-0\n" + row + "\nRET\n"
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{"probe": {Ret: Void}},
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("text API granted unproved MMX source transport", row, triple, err)
+			}
+			context := llvm.NewContext()
+			func() {
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("module API granted unproved MMX source transport", row, triple, err)
+				}
+				result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "amd64", TargetTriple: triple, ResolveSym: options.ResolveSym})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go API granted unproved MMX source transport", row, triple, err)
+				}
+			}()
+		}
+	}
+}
+
+func TestX86YMMSelectorFiveTargetRegisteredXMMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+		"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		source := "TEXT ·probe(SB),4,$0-16\nMOVOU value+0(FP),X0\nMOVOU value+0(FP),X1\n"
+		count := 0
+		for _, rule := range x86YMMOriginalRules(t) {
+			if rule.table == "ymshuf" {
+				continue // This original row is MMX-only, not an XMM grant.
+			}
+			source += rule.name + " X0,X1\n"
+			count++
+		}
+		source += "RET\n"
+		if count != 42 {
+			t.Fatal("complete original XMM subdomain changed", count)
+		}
+		goAssemblerOracleOutput(t, arch, source, "", true)
+		pkg := mustGoPackage(t, "probe", "package probe\nfunc probe(value [16]byte)\n")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig, err := DeriveGoFuncABI0Signature("probe", pkg.Types.Scope().Lookup("probe").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: arch, TargetTriple: triple,
+			Sigs:       map[string]FuncSig{"probe": sig},
+			ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+		ir, err := Translate(file, options)
+		if err != nil {
+			t.Fatal(triple, err)
+		}
+		x86ResultInitializationObject(t, llc, triple, ir, "ymm-selector-text")
+		context := llvm.NewContext()
+		func() {
+			defer context.Dispose()
+			module, err := TranslateModuleInContext(context, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(triple, err)
+			}
+			x86ResultInitializationObject(t, llc, triple, module.String(), "ymm-selector-module")
+			result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+				GOARCH: arch, TargetTriple: triple, ResolveSym: options.ResolveSym})
+			if result != nil && !result.Module.IsNil() {
+				defer result.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(triple, err)
+			}
+			x86ResultInitializationObject(t, llc, triple, result.Module.String(), "ymm-selector-go")
+		}()
+	}
+}
+
+func TestX86YMMOriginalGoOrderedGPControls(t *testing.T) {
+	for _, row := range []string{"MOVQ AX,M1", "PINSRB $0,AX,X1", "PINSRD $0,AX,X1", "PINSRQ $0,AX,X1",
+		"PEXTRB $0,X1,AX", "PEXTRD $0,X1,AX", "PEXTRQ $0,X1,AX"} {
+		t.Run(row, func(t *testing.T) {
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+row+"\nRET\n")
+			physical, err := x86asm.Decode(code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, arg := range physical.Args {
+				if arg == x86asm.M0 {
+					t.Fatal("actual transfer/insertion/extraction GP role was changed to MMX", physical)
+				}
+			}
+			if reflect.DeepEqual(physical.Args, x86asm.Args{}) {
+				t.Fatal("control has no actual decoded operands")
+			}
+		})
+	}
+}
diff --git a/amd64_legacy_mmx_mode32_test.go b/amd64_legacy_mmx_mode32_test.go
new file mode 100644
index 000000000..d57e394d0
--- /dev/null
+++ b/amd64_legacy_mmx_mode32_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86YMMMode32LegacyShiftActualGoRows(t *testing.T) {
+	var names []string
+	for _, rule := range x86YMMOriginalRules(t) {
+		if rule.table == "yps" {
+			names = append(names, rule.name)
+		}
+	}
+	if len(names) != 8 {
+		t.Fatal("complete original yps class changed", names)
+	}
+
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range names {
+			for _, bank := range []string{"M", "X"} {
+				for _, source := range []string{"$3", bank + "0", "8(AX)"} {
+					row := fmt.Sprintf("%s %s,%s1", name, source, bank)
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						text := "TEXT probe(SB),4,$0-0\n" + row + "\nRET\n"
+						want := arch == "amd64" || bank == "X"
+						goAssemblerOracleOutput(t, arch, text, "", want)
+						t.Logf("original source SHA256=%x accepted=%t", sha256.Sum256([]byte(text)), want)
+						if want {
+							code := x86PackedShiftActualGoBytes(t, arch, text)
+							mode := 64
+							if arch == "386" {
+								mode = 32
+							}
+							physical, err := x86asm.Decode(code, mode)
+							destination := x86asm.M1
+							if bank == "X" {
+								destination = x86asm.X1
+							}
+							if err != nil || physical.Args[0] != destination {
+								t.Fatal("original Go selected a different physical destination", row, code, physical, err)
+							}
+							t.Logf("original Go bytes=%x SHA256=%x physical=%v", code, sha256.Sum256(code), physical)
+						}
+
+						form, known, err := x86LegacyMMXReadProperties(x86YMMReadSource(t, row), arch)
+						if !known || (err == nil) != want {
+							t.Fatal("named Go mode admission differs from pure selector", row, form, known, err)
+						}
+						if !want {
+							file, err := Parse(ArchAMD64, text)
+							if err != nil {
+								t.Fatal(err)
+							}
+							if _, err := Translate(file, Options{
+								Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+								Sigs: map[string]FuncSig{"probe": {Name: "probe", Ret: Void}},
+							}); err == nil {
+								t.Fatal("Go-rejected named mode32 MMX row produced LLVM IR", row)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_legacy_move_native_linux_amd64_test.go b/amd64_legacy_move_native_linux_amd64_test.go
new file mode 100644
index 000000000..2a593e373
--- /dev/null
+++ b/amd64_legacy_move_native_linux_amd64_test.go
@@ -0,0 +1,9 @@
+package plan9asm
+
+import "testing"
+
+// Unlike Rosetta diagnostics, this required native CI axis also compares the
+// original aligned-SSE faults for every nonzero misalignment.
+func TestCrossLinuxRuntimeMatrixX86LegacyMoveNativeAlignment(t *testing.T) {
+	x86LegacyMoveNativeRuntime(t, true)
+}
diff --git a/amd64_legacy_move_native_runtime_unix_test.go b/amd64_legacy_move_native_runtime_unix_test.go
new file mode 100644
index 000000000..ed8a32d3e
--- /dev/null
+++ b/amd64_legacy_move_native_runtime_unix_test.go
@@ -0,0 +1,201 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86LegacyMoveNativeBytesAndFaults(t *testing.T) {
+	x86LegacyMoveNativeRuntime(t, false)
+}
+
+func x86LegacyMoveNativeRuntime(t *testing.T, nativeAlignment bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	boolInt := func(value bool) int {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	var source, declarations, originals, pairs strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range x86LegacyMoveNativeOracle {
+		for _, store := range []bool{false, true} {
+			for _, dead := range []bool{false, true} {
+				name := fmt.Sprintf("move%d_%t_%t", index, store, dead)
+				source.WriteString(x86LegacyMoveNativeSource("amd64", name, row.name, store, dead))
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					}}}
+				fmt.Fprintf(&declarations, "extern void %s(uint8_t*,uint8_t*);\n", name)
+				operands := "(DI),X1"
+				before, after := "stc\\n\\t", "movups %%xmm1,(%1)\\n\\t"
+				if store {
+					operands = "X1,(DI)"
+					before, after = "movups (%1),%%xmm1\\n\\tstc\\n\\t", ""
+				} else if dead {
+					after = ""
+				}
+				code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row.name+" "+operands+"\nRET\n")
+				if len(code) < 4 || code[len(code)-1] != 0xc3 {
+					t.Fatal("missing original Go opcode and ordinary RET", code)
+				}
+				var bytes []string
+				for _, value := range code[:len(code)-1] {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+				}
+				fmt.Fprintf(&originals, `static void original_%s(uint8_t *p,uint8_t *out) {
+    __asm__ volatile("%s.byte %s\n\t%ssetc 16(%%1)"
+        : : "D"(p),"r"(out) : "xmm1","memory","cc");
+}
+`, name, before, strings.Join(bytes, ","), after)
+				fmt.Fprintf(&pairs, "{original_%s,%s,%d,%d,%d,16,0},\n", name, name,
+					boolInt(row.aligned), boolInt(store), boolInt(dead))
+			}
+		}
+		for lane := 0; lane < 4; lane++ {
+			name := fmt.Sprintf("move_result%d_%d", index, lane)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-12\nMOVQ p+0(FP),AX\n%s (AX),X1\nPEXTRD $%d,X1,CX\nMOVL CX,ret+8(FP)\nRET\n", name, row.name, lane)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: I32,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}},
+				}}
+			fmt.Fprintf(&declarations, `extern uint32_t %s(uint8_t*);
+static void translated_%s(uint8_t *p,uint8_t *out) {
+    uint32_t value=%s(p); memcpy(out,&value,4); out[16]=1;
+}
+`, name, name, name)
+			code := x86PackedShiftActualGoBytes(t, "amd64", fmt.Sprintf("TEXT f(SB),4,$0-0\n%s (DI),X1\nPEXTRD $%d,X1,AX\nRET\n", row.name, lane))
+			if len(code) < 8 || code[len(code)-1] != 0xc3 {
+				t.Fatal("missing original Go load/extract/RET", code)
+			}
+			var bytes []string
+			for _, value := range code[:len(code)-1] {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+			}
+			fmt.Fprintf(&originals, `static void original_%s(uint8_t *p,uint8_t *out) {
+    uint32_t value;
+    __asm__ volatile(".byte %s" : "=a"(value) : "D"(p) : "xmm1","memory");
+    memcpy(out,&value,4); out[16]=1;
+}
+`, name, strings.Join(bytes, ","))
+			fmt.Fprintf(&pairs, "{original_%s,translated_%s,%d,0,0,4,%d},\n", name, name, boolInt(row.aligned), lane*4)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const helper = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <xmmintrin.h>
+typedef void (*operation)(uint8_t*,uint8_t*);
+struct pair { operation original,translated; int aligned,store,dead,width,offset; };
+static int outcome(operation fn,uint8_t *p) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        uint8_t data[32]; memset(data,0x53,sizeof(data));
+        fn(p,data); _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    return WIFSIGNALED(status)?WTERMSIG(status):-2;
+}
+static int check_bytes(struct pair pair,int offset) {
+    for(int sample=0;sample<257;++sample) for(int rc=0;rc<4;++rc) {
+        _Alignas(16) uint8_t a[64],b[64],x[64],y[64];
+        for(int i=0;i<64;++i) {
+            a[i]=b[i]=(uint8_t)(sample*71+i*19);
+            x[i]=y[i]=(uint8_t)(sample*31-i*59);
+        }
+        uint8_t before_a[64],before_x[64];
+        memcpy(before_a,a,64); memcpy(before_x,x,64);
+        uint32_t saved=_mm_getcsr(),csr=0x1f80|(rc<<13)|(sample&63);
+        _mm_setcsr(csr); pair.original(a+offset,x+1); uint32_t original_csr=_mm_getcsr();
+        _mm_setcsr(csr); pair.translated(b+offset,y+1); uint32_t translated_csr=_mm_getcsr();
+        _mm_setcsr(saved);
+        if(original_csr!=csr || translated_csr!=csr || memcmp(a,b,64) || memcmp(x,y,64)) return 1;
+        for(int i=0;i<64;++i) {
+            uint8_t want_a=pair.store && i>=offset && i<offset+16?before_x[1+i-offset]:before_a[i];
+            uint8_t want_x=!pair.store && !pair.dead && i>=1 && i<1+pair.width?before_a[offset+pair.offset+i-1]:before_x[i];
+            if(i==17) want_x=1;
+            if(a[i]!=want_a || x[i]!=want_x) return 2;
+        }
+    }
+    return 0;
+}
+`
+	main := fmt.Sprintf("#define CHECK_ALIGNMENT %d\n", boolInt(nativeAlignment)) + helper + declarations.String() + originals.String() + "static const struct pair pairs[]={\n" + pairs.String() + `};
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    for(unsigned op=0;op<sizeof(pairs)/sizeof(*pairs);++op) {
+        struct pair pair=pairs[op];
+        if(check_bytes(pair,pair.aligned?16:17)) return 3;
+        if(CHECK_ALIGNMENT) for(int offset=1;offset<16;++offset) {
+            /* Fully mapped storage isolates alignment from page bounds. */
+            int a=outcome(pair.original,region+offset),b=outcome(pair.translated,region+offset);
+            if(a!=b || (pair.aligned ? a!=SIGSEGV && a!=SIGBUS : a!=0)) {
+                fprintf(stderr,"op=%u misalignment=%d original=%d translated=%d\n",op,offset,a,b);
+                return 6;
+            }
+        }
+        for(int extent=0;extent<=16;++extent) {
+            /* Non-native transports need not reproduce aligned-SSE faults. */
+            if(!CHECK_ALIGNMENT && pair.aligned && extent!=0 && extent!=16) continue;
+            uint8_t *p=region+page-extent;
+            int a=outcome(pair.original,p),b=outcome(pair.translated,p);
+            if(a!=b || (extent==16 ? a!=0 : a!=SIGSEGV && a!=SIGBUS)) {
+                fprintf(stderr,"op=%u extent=%d original=%d translated=%d\n",op,extent,a,b);
+                return 4;
+            }
+        }
+        int a=outcome(pair.original,0),b=outcome(pair.translated,0);
+        if(a!=b || (a!=SIGSEGV && a!=SIGBUS)) return 5;
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			execution.compileAndRunLLVM(t, "legacy-move-native", text, main, "-O2")
+		})
+	}
+	t.Logf("7 opcodes, both directions/live-dead, 257x4 byte/CF/MXCSR/canary values and null/guard faults; transport=%s/%s", runtime.GOOS, runtime.GOARCH)
+}
+
+func TestX86LegacyMoveNativeFaultChildrenDisableCore(t *testing.T) {
+	if err := runtimeOracleFaultCorePolicy(runtimeOracleFaultC(t, "amd64_legacy_move_native_runtime_unix_test.go")); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_legacy_move_native_test.go b/amd64_legacy_move_native_test.go
new file mode 100644
index 000000000..6b186fb41
--- /dev/null
+++ b/amd64_legacy_move_native_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent of the production descriptor: these are the six real opcodes
+// and Go's MOVOA spelling of MOVO, for both yxmov directions.
+var x86LegacyMoveNativeOracle = []struct {
+	name, native string
+	aligned      bool
+}{
+	{"MOVOU", "movdqu", false},
+	{"MOVOA", "movdqa", true},
+	{"MOVO", "movdqa", true},
+	{"MOVUPS", "movups", false},
+	{"MOVAPS", "movaps", true},
+	{"MOVUPD", "movupd", false},
+	{"MOVAPD", "movapd", true},
+}
+
+func TestX86LegacyMoveNativeAddressForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		source.WriteString("GLOBL ·data(SB),8,$64\n")
+		declarations.WriteString("var data [64]byte\n")
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86LegacyMoveNativeOracle {
+			for index, address := range []string{"(AX)", "16(AX)(CX*2)", "·data+16(SB)", "(FS)", "(GS)"} {
+				name := fmt.Sprintf("%s%d", strings.ToLower(row.name), index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s index+%d(FP),CX\n%s %s,X1\n%s X1,%s\nRET\n",
+					name, word*2, move, move, word, row.name, address, row.name, address)
+				fmt.Fprintf(&declarations, "func %s(p *byte,index uintptr)\n", name)
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, row := range x86LegacyMoveNativeOracle {
+					for _, segment := range []string{"fs", "gs"} {
+						for _, operands := range []string{"%" + segment + ":($1), $0", "$0, %" + segment + ":($1)"} {
+							if !strings.Contains(ir, "asm sideeffect \""+row.native+" "+operands+"\"") {
+								t.Errorf("lost original %s native segment/direction: %s", row.name, operands)
+							}
+						}
+					}
+				}
+				compileLLVMToObject(t, llc, target.triple, "legacy-addresses.ll", "legacy-addresses.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86LegacyMoveNativeUnboundAddressFailsBeforeEmission(t *testing.T) {
+	for _, row := range x86LegacyMoveNativeOracle {
+		for _, operands := range []string{"(AX),X0", "X0,(AX)"} {
+			original := x86YMMReadSource(t, row.name+" "+operands)
+			for _, bits := range []int{32, 64} {
+				for _, unbound := range []bool{false, true} {
+					ins := original
+					ins.x86AddressBits, ins.x86UnboundAddressOverride = bits, unbound
+					var output strings.Builder
+					ctx := &amd64Ctx{goarch: "amd64", b: &output}
+					known, term, err := ctx.lowerLegacyPackedMove(ins.Op, ins)
+					if !known || term || !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 || ctx.tmp != 0 {
+						t.Fatalf("unbound native address emitted partial IR: %s %d %t: %v", ins.Raw, bits, unbound, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86LegacyMoveNativeOwnISA(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86LegacyMoveNativeOracle {
+			for _, operands := range []string{"(AX),X0", "X0,(AX)"} {
+				ins := x86YMMReadSource(t, row.name+" "+operands)
+				want := "+sse2"
+				if row.name == "MOVUPS" || row.name == "MOVAPS" {
+					want = "+sse"
+				}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); got != want {
+					t.Errorf("%s %s: source ISA=%q want=%q", arch, ins.Raw, got, want)
+				}
+			}
+		}
+	}
+}
+
+func x86LegacyMoveNativeSource(arch, name, op string, store, dead bool) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n%s p+0(FP),AX\n%s out+%d(FP),BX\nSTC\n", name, word*2, move, move, word)
+	if store {
+		source += "MOVOU (BX),X1\n" + op + " X1,(AX)\n"
+	} else {
+		source += op + " (AX),X1\n"
+		if !dead {
+			source += "MOVOU X1,(BX)\n"
+		}
+	}
+	return source + "SETCS 16(BX)\nRET\n"
+}
+
+func TestX86LegacyMoveNativeThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86LegacyMoveNativeOracle {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index, store := range []bool{false, true} {
+					name := fmt.Sprintf("view%d", index)
+					source.WriteString(x86LegacyMoveNativeSource(target.arch, "·"+name, row.name, store, false))
+					fmt.Fprintf(&declarations, "func %s(p, out *byte)\n", name)
+				}
+				goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, instruction := range []string{row.native + " ($1), $0", row.native + " $0, ($1)"} {
+							if !strings.Contains(ir, "asm sideeffect \""+instruction+"\"") {
+								t.Errorf("missing original observable native instruction %q", instruction)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "legacy-native.ll", "legacy-native.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_legacy_packed_move_forms.go b/amd64_legacy_packed_move_forms.go
new file mode 100644
index 000000000..073a8a663
--- /dev/null
+++ b/amd64_legacy_packed_move_forms.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These seven names are the whole-128-bit subset of Go's yxmov table.
+// Scalar and half-register moves share the table, not this byte effect.
+var x86LegacyPackedMoveNames = map[Op]bool{
+	"MOVOU": true, "MOVOA": true, "MOVO": true,
+	"MOVUPS": true, "MOVAPS": true, "MOVUPD": true, "MOVAPD": true,
+}
+
+type x86LegacyPackedMoveForm struct {
+	source, destination Operand
+	memory              int // -1 for a register copy
+	memoryWrite         bool
+	aligned             bool // Native m128 requires a separate actual-address proof.
+}
+
+// This is Go operand shape only. In particular, accepting a memory operand
+// does not prove backing, initialization, alignment or caller permissions.
+// These legacy rows reject high X registers in mode32; VEX/EVEX's different
+// named-bank acceptance cannot be borrowed by this grammar.
+func x86LegacyPackedMoveProperties(op Op, ins Instr, arch string) (x86LegacyPackedMoveForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	if !x86LegacyPackedMoveNames[Op(name)] {
+		return x86LegacyPackedMoveForm{}, false, nil
+	}
+	form := x86LegacyPackedMoveForm{memory: -1}
+	switch Op(name) {
+	case "MOVOA", "MOVO", "MOVAPS", "MOVAPD":
+		form.aligned = true
+	}
+	fail := func() (x86LegacyPackedMoveForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go whole-128 legacy move grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || suffix != "" || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	vector := func(operand Operand) bool {
+		index, valid := amd64ParseXReg(operand.Reg)
+		return operand.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+	}
+	form.source, form.destination = ins.Args[0], ins.Args[1]
+	if vector(form.source) && vector(form.destination) {
+		return form, true, nil
+	}
+	if vector(form.source) && isAMD64MemoryOperand(form.destination) {
+		form.memory, form.memoryWrite = 1, true
+	} else if isAMD64MemoryOperand(form.source) && vector(form.destination) {
+		form.memory = 0
+	} else {
+		return fail()
+	}
+	memory := ins.Args[form.memory]
+	if memory.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(memory.Mem, arch); err != nil {
+			return form, true, err
+		}
+		if memory.Mem.OffRaw != "" || memory.Mem.IndexExt != "" {
+			return fail()
+		}
+		if arch == "386" && strings.HasSuffix(memory.Mem.Sym, "(SB)") {
+			memory.Mem.Base = "" // Go ignores this annotation, not a value input.
+		}
+	}
+	if !x86PackedShiftMemoryValid(memory, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86TypedLegacyPackedMoveByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, recognized, err := x86LegacyPackedMoveProperties(op, ins, arch)
+	if !recognized || err != nil {
+		return x86TypedByteEffect{}, recognized, err
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: 16, read: true},
+		{index: 1, operand: form.destination, width: 16, write: true},
+	}}, true, nil
+}
+
+func x86TypedInstructionByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if effect, known, err := x86TypedAlternatingFloatByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedRoundByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedImmediateBlendByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedNamedHalfByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedPrecisionByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedExtendByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedBlendMinposByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedXLATByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedFourSourceByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedFMA3ByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarPrecisionByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedUnsignedIntegerFloatByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedExplicitMaskMoveByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMaskMoveByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedImplicitMaskMoveByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedAbsSignByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedTernaryLogicByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarReciprocalByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedReciprocalByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedUnalignedLoadByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMoveHalfByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedReductionByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedSegmentQueryByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedIntegerMinMaxByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMaskBlendByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedWaitPackageByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedRegisterQueryByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedCompactExpandByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMXCSRByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedByteShuffleEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedConversionByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedCOMIByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarFloatIntegerByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedSHAByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedAESByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedVectorTestByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedIFMAByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedDotByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPermute128ByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedElementPermuteByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedShuffle128BitBlocksByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedQwordLookupByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedFloatingHelperByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedSingleSourceNarrowByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedConflictFunnelByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedRotateByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedAlignByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedPackedFloatShuffleByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if _, known, err := x86OrderingHintProperties(op, ins, arch); known {
+		return x86TypedByteEffect{}, true, err
+	}
+	if effect, recognized, err := x86TypedGPByteEffect(op, ins, arch); recognized {
+		// Only this local summary adds a routing obligation. The GP directory
+		// and caller/frame consumers retain their original admission/effects.
+		if err == nil && x86GPByteEffectReadsMemory(effect) {
+			effect.requiresResultProof = true
+		}
+		return effect, recognized, err
+	}
+	if effect, known, err := x86TypedImplicitMultiplyByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedAccumulatorSignExtendByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedCRC32ByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, recognized, err := x86PackedBinaryByteEffect(op, ins, arch); recognized {
+		return effect, recognized, err
+	}
+	if effect, recognized, err := x86TypedPackedIntegerCompareByteEffect(op, ins, arch); recognized {
+		return effect, recognized, err
+	}
+	if effect, known, err := x86TypedPackedTestMaskByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	return x86TypedLegacyPackedMoveByteEffect(op, ins, arch)
+}
+
+// The old direct emitter API returns unhandled for a non-X destination.
+// Retaining that rejection shape grants no effect and emits no partial IR.
+func (c *amd64Ctx) validateLegacyPackedMove(op Op, ins Instr) (bool, error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	_, recognized, err := x86LegacyPackedMoveProperties(op, ins, arch)
+	if !recognized {
+		return false, nil
+	}
+	if err != nil && ins.Op == "" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg && !isAMD64XReg(ins.Args[1].Reg) {
+		return false, nil
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(ins, arch)
+	}
+	return true, err
+}
diff --git a/amd64_legacy_packed_move_forms_test.go b/amd64_legacy_packed_move_forms_test.go
new file mode 100644
index 000000000..4354dd614
--- /dev/null
+++ b/amd64_legacy_packed_move_forms_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86LegacyPackedMoveGrammarEffectAndMemoryShapeAgree(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyPackedMoveTestNames {
+			for _, operands := range []string{
+				"X0,X1", "(AX),X1", "8(AX)(CX*4),X1", "a+0(FP),X1", "value-32(SP),X1", "·data(SB),X1",
+				"X0,(AX)", "X0,8(AX)(CX*4)", "X0,a+0(FP)", "X0,value-32(SP)", "X0,·data(SB)",
+			} {
+				t.Run(arch+"/"+op+" "+operands, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$64-64\n"+op+" "+operands+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					before := fmt.Sprintf("%#v", ins)
+					form, recognized, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+					if !recognized || err != nil {
+						t.Fatal("accepted Go shape lost", form, err)
+					}
+					effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !recognized || err != nil || len(effect.operands) != 2 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+						t.Fatal("whole move gained arithmetic or lost effects", effect, err)
+					}
+					for index, role := range effect.operands {
+						if role.index != index || role.width != 16 || role.read != (index == 0) || role.write != (index == 1) ||
+							!reflect.DeepEqual(role.operand, ins.Args[index]) {
+							t.Fatalf("incomplete ordered byte effect: %#v", role)
+						}
+						width, write, known := x86InstructionMemoryShape(ins, index, arch)
+						if known != (form.memory == index) || known && (width != 16 || write != form.memoryWrite) {
+							t.Fatalf("memory shape differs from descriptor: %d/%t/%t %#v", width, write, known, form)
+						}
+						if ins.Args[index].Kind == OpFP {
+							width, write, known := X86FPAccessBytes(ins, index, arch)
+							if !known || width != 16 || write != (index == 1) {
+								t.Fatal("FP observer has a different native width", width, write, known)
+							}
+						}
+						// Typed caller recognition is not a standalone source-stack
+						// or memory permission; the complete actual caller remains
+						// mandatory before the private transfer can be consumed.
+						if !x86CallerVectorMoveKnown(ins) || x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+							t.Fatal("legacy move lost typed caller registration or granted a non-caller source stack")
+						}
+					}
+					if before != fmt.Sprintf("%#v", ins) {
+						t.Fatal("descriptor changed original source/operands")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveActualGoCompleteOpcodeBytes(t *testing.T) {
+	// Independent opcode bytes, not a table generated by the descriptor.
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name        string
+			prefix      []byte
+			load, store byte
+		}{
+			{"MOVOU", []byte{0xf3}, 0x6f, 0x7f}, {"MOVOA", []byte{0x66}, 0x6f, 0x7f}, {"MOVO", []byte{0x66}, 0x6f, 0x7f},
+			{"MOVUPS", nil, 0x10, 0x11}, {"MOVAPS", nil, 0x28, 0x29},
+			{"MOVUPD", []byte{0x66}, 0x10, 0x11}, {"MOVAPD", []byte{0x66}, 0x28, 0x29},
+		} {
+			for _, operands := range []struct {
+				text  string
+				modrm byte
+				store bool
+			}{
+				{"X1,X0", 0xc1, false}, {"X0,X7", 0xf8, false},
+				{"(AX),X1", 0x08, false}, {"X1,(AX)", 0x08, true},
+			} {
+				t.Run(arch+"/"+row.name+" "+operands.text, func(t *testing.T) {
+					source := "TEXT probe(SB),4,$0-0\n" + row.name + " " + operands.text + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					want := append([]byte(nil), row.prefix...)
+					opcode := row.load
+					if operands.store {
+						opcode = row.store
+					}
+					want = append(want, 0x0f, opcode, operands.modrm, 0xc3)
+					if got := x86PackedShiftActualGoBytes(t, arch, source); !bytes.Equal(got, want) {
+						t.Fatalf("original Go machine bank/width differs: %x want %x", got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveMode32BanksMatchOriginalGo(t *testing.T) {
+	for _, op := range x86LegacyPackedMoveTestNames {
+		for _, operands := range []string{"X8,X0", "X0,X15", "a+0(FP),X8", "X15,a+0(FP)"} {
+			t.Run(op+" "+operands, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-32\n" + op + " " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", false)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if _, recognized, err := x86LegacyPackedMoveProperties(ins.Op, ins, "amd64"); !recognized || err != nil {
+					t.Fatal("AMD64 high-bank accepted format omitted", err)
+				}
+				if _, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !recognized || err == nil {
+					t.Fatal("mode32 name acquired a fake physical value", err)
+				}
+				for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+					options := Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"Value": {Ret: Void}},
+						ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+					if _, err := Translate(file, options); err == nil {
+						t.Fatal("text API granted physical high X", err)
+					}
+					ctx := llvm.NewContext()
+					func() {
+						defer ctx.Dispose()
+						module, err := TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						if err == nil {
+							t.Fatal("module API granted physical high X", err)
+						}
+						pkg := mustGoPackage(t, "example.invalid/move", "package move\nfunc Value(a,b,c,d uint64)\n")
+						translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+							GOARCH: "386", TargetTriple: triple, ResolveSym: options.ResolveSym,
+						})
+						if translated != nil && !translated.Module.IsNil() {
+							defer translated.Module.Dispose()
+						}
+						if err == nil {
+							t.Fatal("Go API granted physical high X", err)
+						}
+					}()
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		for _, op := range x86LegacyPackedMoveTestNames {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				// This is the numerical FP/result contract. Native memory
+				// opcodes have their own complete three-API object matrix.
+				fpMove := op
+				if op == "MOVO" || op == "MOVOA" || op == "MOVAPS" || op == "MOVAPD" {
+					fpMove = "MOVOU"
+				}
+				body := "MOVSD c+16(FP),X1\n" + fpMove + " a+0(FP),X0\n" + op + " X1,X0\n" + op + " X0,X0\nMOVSD X0,ret0+32(FP)\nRET"
+				pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(a,b,c,d uint64) uint64", body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+					ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+				before := fmt.Sprintf("%#v %#v", file, sig)
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+				if before != fmt.Sprintf("%#v %#v", file, sig) {
+					t.Fatal("API changed original source or signature")
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveDispatchAndMalformedFormsDoNotEmit(t *testing.T) {
+	for _, op := range x86LegacyPackedMoveTestNames {
+		for _, operands := range []string{"M0,M1", "AX,X0", "X0,AX", "$1,X0", "Y0,Y1", "Z0,Z1", "X16,X0", "(AX),(BX)", "X0,K1,X1"} {
+			file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+op+" "+operands+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64"); !recognized || err == nil {
+				t.Fatal("Go-rejected form acquired a byte effect", ins, err)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before, temporary := output.String(), ctx.tmp
+			if known, term, err := ctx.lowerVec(ins.Op, ins); !known || term || err == nil || output.String() != before || ctx.tmp != temporary {
+				t.Fatal("malformed whole move emitted partial IR", known, term, err)
+			}
+		}
+		file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+op+" X0,X1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, identity := range []Op{"", Op(op), Op(strings.ToLower(op))} {
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = identity
+			if _, recognized, err := x86LegacyPackedMoveProperties(Op(op), ins, "amd64"); !recognized || err != nil {
+				t.Fatal("legacy matching dispatch changed", identity, err)
+			}
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ins.Op = "MOVQ"
+		if _, recognized, err := x86TypedInstructionByteEffect(Op(op), ins, "amd64"); !recognized || err == nil {
+			t.Fatal("contradictory instruction got an effect", err)
+		}
+	}
+}
diff --git a/amd64_legacy_packed_move_fp_test.go b/amd64_legacy_packed_move_fp_test.go
new file mode 100644
index 000000000..8a10e709a
--- /dev/null
+++ b/amd64_legacy_packed_move_fp_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86LegacyPackedMoveLogicalFPAlignment(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			opcode  string
+			aligned bool
+		}{
+			{"MOVOU", false}, {"MOVUPS", false}, {"MOVUPD", false},
+			{"MOVO", true}, {"MOVOA", true}, {"MOVAPS", true}, {"MOVAPD", true},
+		} {
+			for _, direction := range []struct{ name, operands, declaration string }{
+				{"load", "a+0(FP),X1", "func F(a,b,c,d float32)\n"},
+				{"store", "X1,a+0(FP)", "func F() (a,b uint64)\n"},
+			} {
+				t.Run(target.triple+"/"+row.opcode+"/"+direction.name, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·F(SB),4,$0-16\nPXOR X1,X1\n%s %s\nRET\n", row.opcode, direction.operands)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source,
+								direction.declaration, target.arch, target.triple, api)
+							if row.aligned {
+								if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Fatal("logical FP fields supplied native alignment without its backing", err)
+								}
+							} else if err != nil || ir == "" {
+								t.Fatal("unaligned logical FP byte transport failed", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveNativeMemoryThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []string{"MOVOU", "MOVUPS", "MOVUPD", "MOVO", "MOVOA", "MOVAPS", "MOVAPD"} {
+			t.Run(target.triple+"/"+opcode, func(t *testing.T) {
+				move, word := "MOVQ", 8
+				if target.arch == "386" {
+					move, word = "MOVL", 4
+				}
+				source := fmt.Sprintf("TEXT ·F(SB),4,$0-%d\n%s p+0(FP),AX\n%s (AX),X1\n%s X1,(AX)\nRET\n",
+					word, move, opcode, opcode)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func F(p *[16]byte)\n",
+							target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "packed-native.ll", "packed-native.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86LegacyPackedMoveFPResults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, opcode := range []string{"MOVOU", "MOVUPS", "MOVUPD"} {
+		t.Run(opcode, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT ·F(SB),4,$0-32\n%s a+0(FP),X1\n%s X1,r0+16(FP)\nRET\n", opcode, opcode)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func F(a,b uint64) (r0,r1,r2,r3 uint32)\n", "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					// An LLVM wrapper observes each tuple field without assuming
+					// that a C struct and a raw LLVM aggregate share a return ABI.
+					ir += `
+define void @observe(ptr %out) {
+  %value = call { i32, i32, i32, i32 } @F(i64 8589934593, i64 17179869187)
+  store { i32, i32, i32, i32 } %value, ptr %out, align 4
+  ret void
+}
+`
+					const main = `#include <stdint.h>
+#include <stdio.h>
+extern void observe(uint32_t*);
+int main(void) {
+    uint32_t out[6] = {77,0,0,0,0,88};
+    observe(out+1);
+    for(unsigned i=1;i<=4;i++) if(out[i]!=i) {
+        fprintf(stderr,"result field %u: got %u, want %u\n",i-1,out[i],i);
+        return 1;
+    }
+    return out[0]!=77 || out[5]!=88;
+}
+`
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							execution.compileAndRunLLVM(t, "packed-fp-results", ir, main, level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_legacy_packed_move_runtime_test.go b/amd64_legacy_packed_move_runtime_test.go
new file mode 100644
index 000000000..8dad27d8f
--- /dev/null
+++ b/amd64_legacy_packed_move_runtime_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86LegacyPackedMoveOriginalBytesAndCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, goTest, reference, checks strings.Builder
+	declarations.WriteString("package packedmove\nfunc ReadCSR() uint32\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\n")
+	goTest.WriteString(`package packedmove
+import (
+ "testing"
+ "unsafe"
+)
+func aligned(value *[80]byte) (*[16]byte,int) {
+ offset:=16+int((-uintptr(unsafe.Pointer(&value[16])))&15)
+ return (*[16]byte)(unsafe.Pointer(&value[offset])),offset
+}
+func TestOriginal(t *testing.T) {
+ for sample:=0;sample<257;sample++ { for _,seed:=range []uint64{0,0x8d5} {
+  var x,y,out [80]byte
+  xp,_:=aligned(&x);yp,_:=aligned(&y);op,offset:=aligned(&out)
+  for i:=range x { x[i]=byte(sample*71+i*37);y[i]=byte(sample*19+i*11);out[i]=0xa5 }
+  originalX,originalY:=x,y
+`)
+	reference.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+struct Aligned { _Alignas(16) uint8_t before[16],value[16],after[16]; };
+`)
+	for _, op := range x86LegacyPackedMoveTestNames {
+		for _, kind := range []string{"Register", "Alias", "Load", "Store"} {
+			name := op + kind
+			operation, input := op+" X1,X0\nMOVOU X0,(DX)", "xp"
+			switch kind {
+			case "Alias":
+				operation, input = op+" X0,X0\nMOVOU X0,(DX)", "yp"
+			case "Load":
+				operation = op + " (AX),X0\nMOVOU X0,(DX)"
+			case "Store":
+				operation = op + " X1,(DX)"
+			}
+			fmt.Fprintf(&declarations, "func %s(out,x,y *[16]byte,flags *uint64,seed uint64)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DX\nMOVQ x+8(FP),AX\nMOVQ y+16(FP),CX\nMOVOU (AX),X1\nMOVOU (CX),X0\nPUSHQ seed+32(FP)\nPOPFQ\n%s\nPUSHFQ\nPOPQ BX\nMOVQ flags+24(FP),SI\nMOVQ BX,(SI)\nRET\n", name, operation)
+			fmt.Fprintf(&goTest, `{
+   for i:=range out { out[i]=0xa5 }
+   box:=struct{before,value,after uint64}{0x1122334455667788,0,0x8877665544332211}
+   csr:=ReadCSR()
+   %s(op,xp,yp,&box.value,seed)
+   if box.value&0x8d5!=seed||box.before!=0x1122334455667788||box.after!=0x8877665544332211||ReadCSR()!=csr||x!=originalX||y!=originalY { t.Fatalf("%s state/canary sample%%d flags%%x",sample,box.value) }
+   for i,value:=range out {
+    want:=byte(0xa5)
+    if i>=offset&&i<offset+16 { want=%s[i-offset] }
+    if value!=want { t.Fatalf("%s sample%%d byte%%d got%%x want%%x",sample,i,value,want) }
+   }
+  }
+`, name, name, input, name)
+			fmt.Fprintf(&reference, "extern void %s(uint8_t*,uint8_t*,uint8_t*,uint64_t*,uint64_t);\n", name)
+			cinput := "x.value"
+			if kind == "Alias" {
+				cinput = "y.value"
+			}
+			fmt.Fprintf(&checks, `{
+ memset(&out,0xa5,sizeof(out));
+ struct {uint64_t before,value,after;} flags={UINT64_C(0x1122334455667788),0,UINT64_C(0x8877665544332211)};
+ uint32_t csr=_mm_getcsr();
+ %s(out.value,x.value,y.value,&flags.value,seed);
+ if((flags.value&UINT64_C(0x8d5))!=seed||flags.before!=UINT64_C(0x1122334455667788)||flags.after!=UINT64_C(0x8877665544332211)||_mm_getcsr()!=csr||memcmp(&x,&originalX,sizeof(x))||memcmp(&y,&originalY,sizeof(y))) {fprintf(stderr,"%s flags/input/MXCSR sample%%d flags%%llx\n",sample,(unsigned long long)flags.value);return 1;}
+ for(int i=0;i<16;i++) if(out.value[i]!=%s[i]||out.before[i]!=0xa5||out.after[i]!=0xa5) {fprintf(stderr,"%s full-byte/canary sample%%d byte%%d\n",sample,i);return 2;}
+}
+`, name, name, cinput, name)
+		}
+	}
+	goTest.WriteString("}}\n}\n")
+	reference.WriteString(`int main(void) {
+ for(int sample=0;sample<257;sample++) { for(int status=0;status<2;status++) {
+  uint64_t seed=status?UINT64_C(0x8d5):0;
+  struct Aligned x,y,out;
+  for(int i=0;i<sizeof(x);i++) {((uint8_t*)&x)[i]=(uint8_t)(sample*71+i*37);((uint8_t*)&y)[i]=(uint8_t)(sample*19+i*11);}
+  struct Aligned originalX=x,originalY=y;
+` + checks.String() + "}}\nreturn 0;}\n")
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module packedmove\n\ngo 1.20\n", "move.go": declarations.String(),
+		"move_amd64.s": assembly.String(), "move_test.go": goTest.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("original Go whole-128 moves have no successful terminal: %s", output)
+	}
+	pkg := mustGoPackage(t, "example.invalid/packedmove", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "legacy-packed-move", ir, reference.String(), level)
+		})
+	}
+	if !t.Failed() {
+		t.Log("28 original-Go/LLVM kernels ×257 initialized aligned samples ×2 six-flag seeds; full 16 bytes, MXCSR, inputs and canaries. Rosetta execution is diagnostic, not native AMD64/386 or unaligned fault proof.")
+	}
+}
+
+func TestX86LegacyPackedMoveWiderSoftwareAliasPreservation(t *testing.T) {
+	// This directly initialized LLVM-shadow fixture is not an execution of
+	// original Go Z-register code and grants no physical bank or ABI input.
+	execution := x86FloatCompareExecutionTools(t)
+	var ir, reference, checks strings.Builder
+	ir.WriteString("target triple = \"" + execution.triple + "\"\n")
+	reference.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	constant := func(multiplier, addend int) string {
+		var values []string
+		for index := 0; index < 64; index++ {
+			values = append(values, fmt.Sprintf("i8 %d", byte(index*multiplier+addend)))
+		}
+		return "<" + strings.Join(values, ",") + ">"
+	}
+	for _, op := range x86LegacyPackedMoveTestNames {
+		ins := Instr{Op: Op(op), Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}}
+		fn := Func{Instrs: []Instr{
+			{Op: "VMOVUPS", Args: []Operand{{Kind: OpReg, Reg: "Z0"}, {Kind: OpReg, Reg: "Z1"}}}, ins,
+		}}
+		ctx, output := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Ret: Void}, nil)
+		if err := ctx.storeZ("Z0", constant(37, 11)); err != nil {
+			t.Fatal(err)
+		}
+		if err := ctx.storeZ("Z1", constant(19, 71)); err != nil {
+			t.Fatal(err)
+		}
+		known, term, err := ctx.lowerFP(ins.Op, ins)
+		if !known {
+			known, term, err = ctx.lowerVec(ins.Op, ins)
+		}
+		if !known || term || err != nil {
+			t.Fatal("legacy lowerer did not consume its typed X-bank shape", known, term, err)
+		}
+		first, err := ctx.loadZ("Z0")
+		if err != nil {
+			t.Fatal(err)
+		}
+		second, err := ctx.loadZ("Z1")
+		if err != nil {
+			t.Fatal(err)
+		}
+		fmt.Fprintf(&ir, "define void @%sShadow(ptr %%out) {\n%s  store <64 x i8> %s, ptr %%out, align 1\n  %%next = getelementptr i8, ptr %%out, i64 64\n  store <64 x i8> %s, ptr %%next, align 1\n  ret void\n}\n", op, output.String(), first, second)
+		fmt.Fprintf(&reference, "extern void %sShadow(uint8_t*);\n", op)
+		fmt.Fprintf(&checks, "{memset(out,0xa5,sizeof(out));%sShadow(out+16);for(int i=0;i<64;i++){uint8_t want=(uint8_t)(i<16?i*19+71:i*37+11);if(out[16+i]!=want||out[80+i]!=(uint8_t)(i*19+71)){fprintf(stderr,\"%s shadow byte%%d\\n\",i);return 1;}}for(int i=0;i<16;i++)if(out[i]!=0xa5||out[144+i]!=0xa5)return 2;}\n", op, op)
+	}
+	reference.WriteString("int main(void){uint8_t out[160];\n" + checks.String() + "return 0;}\n")
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "legacy-packed-move-alias", ir.String(), reference.String(), level)
+		})
+	}
+}
diff --git a/amd64_legacy_ps_insert_extract_test.go b/amd64_legacy_ps_insert_extract_test.go
new file mode 100644
index 000000000..fba8a59f5
--- /dev/null
+++ b/amd64_legacy_ps_insert_extract_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86LegacyPSIndependentFPFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	const source = "TEXT fields(SB),4,$0-12\nPXOR X0,X0\nINSERTPS $0,a+0(FP),X0\nEXTRACTPS $0,X0,ret+8(FP)\nRET\n" +
+		"TEXT stores(SB),4,$0-12\nMOVL $0x87654321,CX\nMOVD CX,X1\nEXTRACTPS $0,X1,a+0(FP)\nMOVBLZX a+0(FP),AX\nMOVBLZX b+1(FP),BX\nSHLL $8,BX\nORL BX,AX\nMOVBLZX c+2(FP),BX\nSHLL $16,BX\nORL BX,AX\nMOVBLZX d+3(FP),BX\nSHLL $24,BX\nORL BX,AX\nMOVL AX,ret+8(FP)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	pkg := mustGoPackage(t, "oracle", "package oracle\nfunc fields(a,b,c,d byte) uint32\nfunc stores(a,b,c,d byte) uint32\n")
+	sigs := map[string]FuncSig{}
+	for _, name := range []string{"fields", "stores"} {
+		decl := pkg.Types.Scope().Lookup(name).(*types.Func)
+		sig, err := DeriveGoFuncABI0Signature(name, decl, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(sig.Frame.Params) != 4 || len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 8 {
+			t.Fatalf("actual AMD64 ABI0 four-byte fields/result layout changed: %+v", sig.Frame)
+		}
+		sigs[name] = sig
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t fields(uint8_t,uint8_t,uint8_t,uint8_t);
+extern uint32_t stores(uint8_t,uint8_t,uint8_t,uint8_t);
+int main(void) {
+ unsigned failures=0;
+ for(unsigned i=0;i<256;i++) {
+  uint8_t a=i,b=i*37,c=i*59,d=i*71;
+  uint32_t want=(uint32_t)a|((uint32_t)b<<8)|((uint32_t)c<<16)|((uint32_t)d<<24);
+  uint32_t got=fields(a,b,c,d);
+  if(got!=want){if(!(failures&1))fprintf(stderr,"legacy FP fields got=%x want=%x\n",got,want);failures|=1;}
+  got=stores(a,b,c,d);
+  if(got!=UINT32_C(0x87654321)){if(!(failures&2))fprintf(stderr,"legacy FP stores got=%x\n",got);failures|=2;}
+ }
+ return failures;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy-ps-independent-fp", triple, ir, reference, prefix)
+}
+
+func TestX86LegacyPSInsertExtractSourceCallerReachesObjects(t *testing.T) {
+	for _, body := range []string{
+		"VMOVUPS (DI),Z0\nVMOVUPS (SI),X1\nINSERTPS $64,X1,X0\nVMOVSS X0,(DX)",
+		"VMOVUPS (DI),X0\nEXTRACTPS $3,X0,AX\nMOVL AX,(DX)",
+	} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+			t.Fatalf("%s: %v", body, err)
+		}
+	}
+}
+
+func TestX86LegacyPSInsertedByteKnowledgePreservesUpper(t *testing.T) {
+	for _, missing := range []int{-1, 0, 12, 16, 31, 63} {
+		const row = "INSERTPS $0,X0,X1"
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		f, recognized, err := x86InsertExtractProperties(ins, "amd64")
+		if !recognized || err != nil {
+			t.Fatalf("legacy shared grammar missing: %t/%v", recognized, err)
+		}
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 15, "Z1": ^uint64(0)}, masks: map[Reg]bool{}}
+		if missing >= 0 {
+			state.vectors["Z1"] &^= uint64(1) << uint(missing)
+		}
+		if !x86CallerInsertExtractStep(&ins, f, &state, nil) {
+			t.Fatal("defined inserted bytes rejected")
+		}
+		want := ^uint64(0)
+		if missing >= 4 {
+			want &^= uint64(1) << uint(missing)
+		}
+		if got := state.vectors["Z1"]; got != want {
+			t.Fatal(fmt.Sprintf("legacy upper knowledge %d: got%x want%x", missing, got, want))
+		}
+	}
+}
+
+func TestX86LegacyPSCallerUnknownInputsAndPermissions(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown inserted lane":         "VMOVUPS (DI),X1\nINSERTPS $64,X0,X1\nVMOVSS X1,(DX)",
+		"unknown retained base":         "VMOVUPS (DI),X0\nINSERTPS $16,X0,X1\nVMOVSS X1,(DX)",
+		"unknown extract lane":          "EXTRACTPS $0,X0,AX\nMOVL AX,(DX)",
+		"unknown memory even all clear": "INSERTPS $15,(BX),X0\nVMOVSS X0,(DX)",
+		"pointer FP source":             "VMOVUPS (DI),X1\nINSERTPS $0,a+0(FP),X1\nVMOVSS X1,(DX)",
+		"source SP":                     "VMOVUPS (DI),X1\nINSERTPS $0,(SP),X1\nVMOVSS X1,(DX)",
+		"input write":                   "VMOVUPS (DI),X0\nEXTRACTPS $0,X0,(DI)",
+		"g write":                       "VMOVUPS (DI),X0\nEXTRACTPS $0,X0,R14",
+		"missing CFG source":            "CMPQ AX,$0\nJE join\nVMOVUPS (DI),X0\njoin:\nEXTRACTPS $0,X0,AX\nMOVL AX,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("legacy unknown source acquired caller permission: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_legacy_scalar_move_alias_runtime_test.go b/amd64_legacy_scalar_move_alias_runtime_test.go
new file mode 100644
index 000000000..52044a034
--- /dev/null
+++ b/amd64_legacy_scalar_move_alias_runtime_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type x86LegacyScalarAliasForm struct {
+	name, move string
+	width      int
+	register   bool
+	self       bool
+}
+
+func x86LegacyScalarAliasForms() []x86LegacyScalarAliasForm {
+	return []x86LegacyScalarAliasForm{
+		{name: "loadSS", move: "MOVSS", width: 4},
+		{name: "copySS", move: "MOVSS", width: 4, register: true},
+		{name: "selfSS", move: "MOVSS", width: 4, register: true, self: true},
+		{name: "loadSD", move: "MOVSD", width: 8},
+		{name: "copySD", move: "MOVSD", width: 8, register: true},
+		{name: "selfSD", move: "MOVSD", width: 8, register: true, self: true},
+	}
+}
+
+func x86LegacyScalarAliasAssembly(wide int, goarch string) string {
+	var source strings.Builder
+	word, pointerMove := 8, "MOVQ"
+	if goarch == "386" {
+		word, pointerMove = 4, "MOVL"
+	}
+	register := "Y0"
+	if wide == 64 {
+		register = "Z0"
+	}
+	for _, form := range x86LegacyScalarAliasForms() {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),AX\n%s output+%d(FP),BX\nVMOVUPS (AX),%s\n",
+			form.name, word*2, pointerMove, pointerMove, word, register)
+		switch {
+		case form.self:
+			fmt.Fprintf(&source, "%s X0,X0\n", form.move)
+		case form.register:
+			fmt.Fprintf(&source, "%s 64(AX),X1\n%s X1,X0\n", form.move, form.move)
+		default:
+			fmt.Fprintf(&source, "%s 64(AX),X0\n", form.move)
+		}
+		// A store must not alter the register or any overlapping view.
+		fmt.Fprintf(&source, "%s X0,128(BX)\nMOVUPS X0,(BX)\nVMOVUPS Y0,16(BX)\n", form.move)
+		if wide == 64 {
+			source.WriteString("VMOVUPS Z0,48(BX)\n")
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String()
+}
+
+func x86LegacyScalarAliasIR(t *testing.T, wide int, goarch, triple string) string {
+	t.Helper()
+	assembly := x86LegacyScalarAliasAssembly(wide, goarch)
+	requireX86GoAssemblerResult(t, goarch, assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	word := int64(8)
+	if goarch == "386" {
+		word = 4
+	}
+	for _, form := range x86LegacyScalarAliasForms() {
+		symbol := "scalar." + form.name
+		sigs[symbol] = FuncSig{
+			Name: symbol, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: word, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: goarch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "scalar.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestX86LegacyScalarMoveAliasFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, wide := range []int{32, 64} {
+		for _, target := range []struct{ goarch, triple string }{
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i386-pc-windows-msvc"},
+		} {
+			t.Run(fmt.Sprintf("%d/%s", wide, target.triple), func(t *testing.T) {
+				ir := x86LegacyScalarAliasIR(t, wide, target.goarch, target.triple)
+				compileLLVMToObject(t, llc, target.triple, "legacy-alias.ll", "legacy-alias.o", ir)
+			})
+		}
+	}
+}
+
+func x86LegacyScalarAliasActualGoOracle(t *testing.T, wide int) {
+	t.Helper()
+	var declarations, tests strings.Builder
+	declarations.WriteString("package scalar\nimport \"unsafe\"\n")
+	tests.WriteString("package scalar\nimport (\"testing\"; \"unsafe\")\nfunc TestFullViews(t *testing.T) {\n")
+	for _, form := range x86LegacyScalarAliasForms() {
+		fmt.Fprintf(&declarations, "func %s(input, output unsafe.Pointer)\n", form.name)
+		fmt.Fprintf(&tests, `
+	for iteration := 0; iteration < 64; iteration++ {
+		var input [80]byte
+		var output [160]byte
+		for index := range input {
+			input[index] = byte(index*17 + iteration)
+		}
+		for index := range output {
+			output[index] = byte(index*7 + iteration)
+		}
+		beforeInput, want := input, output
+		for _, view := range [][2]int{{0,16},{16,32},{48,%[4]d}} {
+			if view[0] == 48 && %[4]d != 64 {
+				continue
+			}
+			for lane := 0; lane < view[1]; lane++ {
+				value := input[lane]
+				if !%[3]t && lane < %[2]d {
+					value = input[64+lane]
+				} else if !%[3]t && !%[5]t && lane < 16 {
+					value = 0
+				}
+				want[16+view[0]+lane] = value
+			}
+		}
+		for lane := 0; lane < %[2]d; lane++ {
+			value := input[64+lane]
+			if %[3]t {
+				value = input[lane]
+			}
+			want[144+lane] = value
+		}
+		%[1]s(unsafe.Pointer(&input[0]), unsafe.Pointer(&output[16]))
+		if output != want || input != beforeInput {
+			t.Fatalf("%[1]s iteration=%%d got=%%x want=%%x inputChanged=%%t", iteration, output, want, input != beforeInput)
+		}
+	}
+`, form.name, form.width, form.self, wide, form.register)
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module scalar\n\ngo 1.20\n", "scalar.go": declarations.String(),
+		"scalar_amd64.s": x86LegacyScalarAliasAssembly(wide, "amd64"), "scalar_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	command.WaitDelay = 2 * time.Second
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go %d-byte legacy alias oracle: %v\n%s", wide, err, output)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86LegacyScalarMoveAliasViews(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	// This original Go counterpart requires AVX, not AVX512. ZMM encodings
+	// below are independently Go-assembled and portable LLVM/C checked; that
+	// does not claim that the host executes those original AVX512 instructions.
+	x86LegacyScalarAliasActualGoOracle(t, 32)
+	for _, wide := range []int{32, 64} {
+		var source strings.Builder
+		source.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+		for _, form := range x86LegacyScalarAliasForms() {
+			fmt.Fprintf(&source, "extern void %s(void*,void*) __asm__(LABEL(\"scalar.%s\"));\n", form.name, form.name)
+		}
+		source.WriteString("int main(void) {\n")
+		for _, form := range x86LegacyScalarAliasForms() {
+			register, self := 0, 0
+			if form.register {
+				register = 1
+			}
+			if form.self {
+				self = 1
+			}
+			fmt.Fprintf(&source, `
+	for (unsigned iteration = 0; iteration < 64; iteration++) {
+		uint8_t input[80], output[160], before_input[80], want[160];
+		for (unsigned index = 0; index < sizeof(input); index++) {
+			input[index] = index*17 + iteration;
+		}
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			output[index] = index*7 + iteration;
+		}
+		memcpy(before_input, input, sizeof(input));
+		memcpy(want, output, sizeof(output));
+		const unsigned offsets[] = {0,16,48}, widths[] = {16,32,%[4]d};
+		for (unsigned view = 0; view < (%[4]d == 64 ? 3 : 2); view++) {
+			for (unsigned lane = 0; lane < widths[view]; lane++) {
+				uint8_t value = input[lane];
+				if (!%[3]d && lane < %[2]d) {
+					value = input[64+lane];
+				} else if (!%[3]d && !%[5]d && lane < 16) {
+					value = 0;
+				}
+				want[16+offsets[view]+lane] = value;
+			}
+		}
+		for (unsigned lane = 0; lane < %[2]d; lane++) {
+			want[144+lane] = input[(%[3]d ? 0 : 64)+lane];
+		}
+		%[1]s(input, output + 16);
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			if (output[index] != want[index]) {
+				fprintf(stderr, "%[1]s wide=%[4]d iteration=%%u byte=%%u got=%%02x want=%%02x\n", iteration, index, output[index], want[index]);
+				return 1;
+			}
+		}
+		if (memcmp(input, before_input, sizeof(input))) {
+			return 2;
+		}
+	}
+`, form.name, form.width, self, wide, register)
+		}
+		source.WriteString("\treturn 0;\n}\n")
+		triple := testTargetTriple(runtime.GOOS, "amd64")
+		var runner []string
+		if crossRosetta {
+			runner = []string{"/usr/bin/arch", "-x86_64"}
+		}
+		compileAndRunRuntimeTestForTarget(t, llc, clang, fmt.Sprintf("legacy_alias_%d", wide), triple,
+			x86LegacyScalarAliasIR(t, wide, "amd64", triple), source.String(), runner)
+	}
+}
diff --git a/amd64_legacy_scalar_move_native.go b/amd64_legacy_scalar_move_native.go
new file mode 100644
index 000000000..89454a8c1
--- /dev/null
+++ b/amd64_legacy_scalar_move_native.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import "fmt"
+
+// Only the complete legacy MOVSS/MOVSD source grammar selects this loader.
+// FP fields, constants and register copies retain their existing bit-view
+// contracts. Native memory is an exact unaligned, mandatory m32/m64 read.
+func (c *amd64Ctx) loadLegacyScalarMoveSource(ins Instr, bits int) (string, error) {
+	form, known, err := amd64ScalarVectorMoveProperties(ins, c.goarch)
+	if err != nil {
+		return "", err
+	}
+	if !known || !form.spec.legacy || form.spec.bits != bits {
+		return "", fmt.Errorf("%s does not have the required legacy scalar move source", ins.Op)
+	}
+	source := ins.Args[form.low]
+	if form.memory != 0 || source.Kind != OpMem && source.Kind != OpSym {
+		if bits == 32 {
+			return c.evalF32(source)
+		}
+		return c.evalF64(source)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return "", fmt.Errorf("%w: %s needs its original native address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	loaded, scalar := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", loaded, bits, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %%%s to %s\n", scalar, bits, loaded, amd64FloatingScalarType(bits))
+	return "%" + scalar, nil
+}
+
+// The public observer keeps logical-only storage. Only the paired legacy
+// volatile emitter can continue an actual incoming-pointer m32/m64 access.
+// Register copies preserve old high X bytes; memory copies zero those bytes.
+// Both preserve every bit above 127, with no new storage or pointer facts.
+func x86ResultLegacyScalarMoveStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, native bool) (bool, bool) {
+	form, recognized, err := amd64ScalarVectorMoveProperties(ins, arch)
+	if !recognized || !form.spec.legacy {
+		return false, false
+	}
+	if err != nil || form.mask >= 0 || len(ins.Args) != 2 {
+		return false, true
+	}
+	width := int64(form.spec.bits / 8)
+	mask := uint16(1)<<uint(width) - 1
+	xreg := func(operand Operand) (int, bool) {
+		index, valid := amd64ParseXReg(operand.Reg)
+		return index, operand.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+	}
+	first, last := ins.Args[0], ins.Args[1]
+	if source, valid := xreg(first); valid {
+		if state.xmm[source]&mask != mask {
+			return false, true
+		}
+	} else if !form.literal && !x86ResultReadWithNativeContinuation(ins, first, width, state, owned, arch, native) {
+		return false, true
+	}
+	if destination, valid := xreg(last); valid {
+		known := state.xmm[destination] | mask
+		if form.memory == 0 || form.legacyZero {
+			known = 0xffff
+		}
+		state.writeVector(destination, 16, uint64(known), true)
+		return true, true
+	}
+	if x86ResultScalarLaneNativeStore(ins, last, state, arch, native) {
+		// The selected source bytes were checked above. The exact native
+		// write defines no logical bytes or reusable memory/address fact.
+		return true, true
+	}
+	return x86ResultStore(last, width, state, owned, resultOffset, arch), true
+}
diff --git a/amd64_legacy_scalar_move_upper_runtime_test.go b/amd64_legacy_scalar_move_upper_runtime_test.go
new file mode 100644
index 000000000..c4fc91fad
--- /dev/null
+++ b/amd64_legacy_scalar_move_upper_runtime_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type x86LegacyScalarMoveUpperForm struct {
+	name, move string
+	width      int
+	register   bool
+}
+
+func x86LegacyScalarMoveUpperForms() []x86LegacyScalarMoveUpperForm {
+	return []x86LegacyScalarMoveUpperForm{
+		{name: "loadSS", move: "MOVSS", width: 4},
+		{name: "copySS", move: "MOVSS", width: 4, register: true},
+		{name: "loadSD", move: "MOVSD", width: 8},
+		{name: "copySD", move: "MOVSD", width: 8, register: true},
+	}
+}
+
+func x86LegacyScalarMoveUpperAssembly(goarch string) string {
+	word, pointerMove := 8, "MOVQ"
+	if goarch == "386" {
+		word, pointerMove = 4, "MOVL"
+	}
+	var source strings.Builder
+	for _, form := range x86LegacyScalarMoveUpperForms() {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),AX\n%s output+%d(FP),BX\nMOVUPS (AX),X0\n",
+			form.name, word*2, pointerMove, pointerMove, word)
+		if form.register {
+			fmt.Fprintf(&source, "%s 16(AX),X1\n%s X1,X0\n", form.move, form.move)
+		} else {
+			fmt.Fprintf(&source, "%s 16(AX),X0\n", form.move)
+		}
+		source.WriteString("MOVUPS X0,(BX)\nRET\n")
+	}
+	return source.String()
+}
+
+func x86LegacyScalarMoveUpperIR(t *testing.T, goarch, triple string) string {
+	t.Helper()
+	assembly := x86LegacyScalarMoveUpperAssembly(goarch)
+	requireX86GoAssemblerResult(t, goarch, assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	word := int64(8)
+	if goarch == "386" {
+		word = 4
+	}
+	sigs := make(map[string]FuncSig)
+	for _, form := range x86LegacyScalarMoveUpperForms() {
+		symbol := "scalar." + form.name
+		sigs[symbol] = FuncSig{
+			Name: symbol, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: word, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: goarch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "scalar.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestX86LegacyScalarMoveUpperFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ goarch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i386-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86LegacyScalarMoveUpperIR(t, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "scalar-upper.ll", "scalar-upper.o", ir)
+		})
+	}
+}
+
+func x86LegacyScalarMoveActualGoUpperOracle(t *testing.T) {
+	t.Helper()
+	var declarations, tests strings.Builder
+	declarations.WriteString("package scalar\nimport \"unsafe\"\n")
+	tests.WriteString("package scalar\nimport (\"testing\"; \"unsafe\")\nfunc TestFullBytes(t *testing.T) {\n")
+	for _, form := range x86LegacyScalarMoveUpperForms() {
+		fmt.Fprintf(&declarations, "func %s(input, output unsafe.Pointer)\n", form.name)
+		fmt.Fprintf(&tests, `
+	for iteration := 0; iteration < 128; iteration++ {
+		var input [32]byte
+		var output [48]byte
+		for index := range input {
+			input[index] = byte(index*17 + iteration)
+		}
+		for index := range output {
+			output[index] = byte(index*7 + iteration)
+		}
+		beforeInput, beforeOutput := input, output
+		%[1]s(unsafe.Pointer(&input[0]), unsafe.Pointer(&output[16]))
+		for index := range output {
+			want := beforeOutput[index]
+			if index >= 16 && index < 32 {
+				lane := index - 16
+				want = 0
+				if lane < %[2]d {
+					want = input[16+lane]
+				} else if %[3]t {
+					want = input[lane]
+				}
+			}
+			if output[index] != want {
+				t.Fatalf("%[1]s iteration=%%d byte=%%d got=%%#x want=%%#x", iteration, index, output[index], want)
+			}
+		}
+		if input != beforeInput {
+			t.Fatal("%[1]s changed input")
+		}
+	}
+`, form.name, form.width, form.register)
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module scalar\n\ngo 1.20\n", "scalar.go": declarations.String(),
+		"scalar_amd64.s": x86LegacyScalarMoveUpperAssembly("amd64"), "scalar_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	command.WaitDelay = 2 * time.Second
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go full-byte scalar move oracle: %v\n%s", err, output)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86LegacyScalarMoveUpperBytes(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	x86LegacyScalarMoveActualGoUpperOracle(t)
+	var source strings.Builder
+	source.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	for _, form := range x86LegacyScalarMoveUpperForms() {
+		fmt.Fprintf(&source, "extern void %s(void*,void*) __asm__(LABEL(\"scalar.%s\"));\n", form.name, form.name)
+	}
+	source.WriteString("int main(void) {\n")
+	for _, form := range x86LegacyScalarMoveUpperForms() {
+		register := 0
+		if form.register {
+			register = 1
+		}
+		fmt.Fprintf(&source, `
+	for (unsigned iteration = 0; iteration < 128; iteration++) {
+		uint8_t input[32], output[48], before_input[32], before_output[48];
+		for (unsigned index = 0; index < sizeof(input); index++) {
+			input[index] = index*17 + iteration;
+		}
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			output[index] = index*7 + iteration;
+		}
+		memcpy(before_input, input, sizeof(input));
+		memcpy(before_output, output, sizeof(output));
+		%[1]s(input, output + 16);
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			uint8_t want = before_output[index];
+			if (index >= 16 && index < 32) {
+				unsigned lane = index - 16;
+				want = lane < %[2]d ? input[16+lane] : (%[3]d ? input[lane] : 0);
+			}
+			if (output[index] != want) {
+				fprintf(stderr, "%[1]s iteration=%%u byte=%%u got=%%02x want=%%02x\n", iteration, index, output[index], want);
+				return 1;
+			}
+		}
+		if (memcmp(input, before_input, sizeof(input))) {
+			return 2;
+		}
+	}
+`, form.name, form.width, register)
+	}
+	source.WriteString("\treturn 0;\n}\n")
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_upper_bytes", triple,
+		x86LegacyScalarMoveUpperIR(t, "amd64", triple), source.String(), runner)
+}
diff --git a/amd64_local_label_collision_test.go b/amd64_local_label_collision_test.go
new file mode 100644
index 000000000..b27dff95a
--- /dev/null
+++ b/amd64_local_label_collision_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86LocalLabelsDoNotCollideWithIRValues(t *testing.T) {
+	for _, target := range []struct {
+		arch, triple, mov string
+	}{
+		{"amd64", "x86_64-apple-darwin", "MOVQ"},
+		{"amd64", "x86_64-unknown-linux-gnu", "MOVQ"},
+		{"amd64", "x86_64-pc-windows-msvc", "MOVQ"},
+		{"386", "i386-unknown-linux-gnu", "MOVL"},
+		{"386", "i686-pc-windows-msvc", "MOVL"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source := fmt.Sprintf(`TEXT collision(SB),4,$0-0
+PXOR X1,X1
+JMP x1
+x1:
+%s X1,AX
+JMP t1
+t1:
+JMP reg_AX
+reg_AX:
+JMP bb_foo
+bb_foo:
+RET
+`, target.mov)
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.arch,
+				TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"collision": {
+					Name: "collision", Ret: Void,
+				}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "local-label.ll", "local-label.o", ir)
+		})
+	}
+}
diff --git a/amd64_lock_scalar_rmw_backend_test.go b/amd64_lock_scalar_rmw_backend_test.go
new file mode 100644
index 000000000..bab48bdf5
--- /dev/null
+++ b/amd64_lock_scalar_rmw_backend_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86LockScalarRMWNativeBackendFollowsActualCalls(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		native, otherMode := testTargetTriple("linux", arch), "i386-unknown-linux-gnu"
+		if arch == "386" {
+			otherMode = "x86_64-unknown-linux-gnu"
+		}
+		for _, row := range []struct{ instruction, mnemonic string }{
+			{"ADCL CX,1(SI)", "adcl"},
+			{"ADDB $1,1(SI)", "addb"},
+			{"NOTL 1(SI)", "notl"},
+			{"BTCL $1,1(SI)", "btcl"},
+		} {
+			source := x86NamedLockOracleSource(arch, "CMPL AX,AX\nLOCK\n"+row.instruction)
+			x86LockScalarOriginalInstruction(t, arch, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.instruction+"/"+api+"/native", func(t *testing.T) {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\nfunc locked(p *[16]byte)\n", arch, native)
+					if err != nil {
+						t.Fatal("complete native LOCK request rejected", err)
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := parseIRModuleInContext(ctx, ir)
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer module.Dispose()
+					caller := module.NamedFunction("locked")
+					if caller.IsNil() {
+						t.Fatal("public LOCK source body is absent")
+					}
+					calls := 0
+					for block := caller.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+						for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+							if instruction.IsACallInst().IsNil() {
+								continue
+							}
+							helper := instruction.CalledValue()
+							if !strings.HasPrefix(helper.Name(), "__plan9asm_lock_rmw_") {
+								continue
+							}
+							calls++
+							if helper.FirstUse().IsNil() || helper.FirstBasicBlock().IsNil() {
+								t.Fatal("caller did not reference a defined native helper")
+							}
+							nativeUse := false
+							for body := helper.FirstBasicBlock(); !body.IsNil(); body = llvm.NextBasicBlock(body) {
+								for emitted := body.FirstInstruction(); !emitted.IsNil(); emitted = llvm.NextInstruction(emitted) {
+									for index := 0; index < emitted.OperandsCount(); index++ {
+										assembly := emitted.Operand(index).IsAInlineAsm()
+										if assembly.IsNil() {
+											continue
+										}
+										info := assembly.InlineAsmInfo()
+										if info.HasSideEffects && strings.Contains(info.Assembly, "lock; "+row.mnemonic) {
+											nativeUse = true
+										}
+									}
+								}
+							}
+							if !nativeUse {
+								t.Fatal("actually called helper lost its native atomic instruction")
+							}
+						}
+					}
+					if calls != 1 {
+						t.Fatal("source body must call exactly one complete LOCK helper", calls)
+					}
+				})
+				for _, triple := range []string{"", otherMode, "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					t.Run(arch+"/"+row.instruction+"/"+api+"/"+triple, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source,
+							"package ordering\nfunc locked(p *[16]byte)\n", arch, triple)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "inline assembly") {
+							t.Fatal("complete native LOCK escaped an absent or foreign backend", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LockScalarRMWPortableNonLOCKDoesNotAcquireHelpers(t *testing.T) {
+	source := "TEXT ·plain(SB),4,$0-0\nMOVL $1,AX\nMOVL $2,BX\nADDL AX,BX\nRET\n"
+	for _, arch := range []string{"amd64", "386"} {
+		goAssemblerOracleOutput(t, arch, source, "", true)
+		for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func plain()", arch, triple, api)
+					if err != nil || ir == "" || strings.Contains(ir, "__plan9asm_lock_rmw_") {
+						t.Fatal("portable unprefixed scalar operation acquired a native helper or backend", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_bank_test.go b/amd64_lock_scalar_rmw_bank_test.go
new file mode 100644
index 000000000..58a650140
--- /dev/null
+++ b/amd64_lock_scalar_rmw_bank_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86LockScalarRMWByteSourcePhysicalBank(t *testing.T) {
+	for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR"} {
+		for _, source := range []string{"AH", "CH", "DH", "BH"} {
+			for _, address := range []struct {
+				name, setup, memory string
+				rex                 bool
+			}{
+				{"SI", "", "(SI)", false},
+				{"R8", "MOVQ SI,R8\n", "(R8)", true},
+				{"R15", "MOVQ SI,R15\n", "(R15)", true},
+				{"R8-index", "MOVQ $0,R8\n", "(SI)(R8*1)", true},
+				{"R15-index", "MOVQ $0,R15\n", "(SI)(R15*1)", true},
+			} {
+				t.Run(stem+"/"+source+"/"+address.name, func(t *testing.T) {
+					assembly := x86NamedLockOracleSource("amd64", address.setup+
+						"CLC\nLOCK\n"+stem+"B "+source+","+address.memory)
+					code := x86LockScalarOriginalInstruction(t, "amd64", assembly)
+					physical, err := x86asm.Decode(code, 64)
+					if err != nil {
+						t.Fatal(err)
+					}
+					t.Logf("actual original Go bytes=%x operands=%s", code, x86asm.GoSyntax(physical, 0, nil))
+					want := map[string]x86asm.Reg{"AH": x86asm.AH, "CH": x86asm.CH,
+						"DH": x86asm.DH, "BH": x86asm.BH}[source]
+					if address.rex {
+						want = map[string]x86asm.Reg{"AH": x86asm.SPB, "CH": x86asm.BPB,
+							"DH": x86asm.SIB, "BH": x86asm.DIB}[source]
+					}
+					if physical.Args[1] != want {
+						t.Fatalf("actual source physical bank=%v, want %v", physical.Args[1], want)
+					}
+					triple := "x86_64-unknown-linux-gnu"
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, assembly,
+								"package ordering\nfunc locked(p *[16]byte)\n", "amd64", triple)
+							if !address.rex {
+								if err != nil || !strings.Contains(ir, "lock; "+strings.ToLower(stem)+"b") {
+									t.Fatal("native high byte without REX lost its actual source bank", err)
+								}
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("source high-byte spelling borrowed a different REX physical bank", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_boundaries_test.go b/amd64_lock_scalar_rmw_boundaries_test.go
new file mode 100644
index 000000000..5432cc8f8
--- /dev/null
+++ b/amd64_lock_scalar_rmw_boundaries_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWTypedRolesAgreeWithoutMemoryPermission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LockScalarOracleForms(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-0\n"+row.text+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(file.Funcs[0].Instrs) != 3 || file.Funcs[0].Instrs[0].Op != OpTEXT {
+					t.Fatal("complete fixture lost its TEXT/RMW/RET roles")
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if err != nil || !known {
+					t.Fatal("complete accepted grammar row lost its typed form", err)
+				}
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if err != nil || !known || len(effect.operands) != len(ins.Args) {
+					t.Fatal("accepted lowering row lacks its complete ordered byte effect", err)
+				}
+				for index, operand := range effect.operands {
+					if operand.index != index || operand.width != int64(form.spec.bits/8) || !operand.read ||
+						operand.write != (index == len(ins.Args)-1) {
+						t.Fatal("read/write/native width role changed", effect)
+					}
+				}
+				stem := row.op[:len(row.op)-1]
+				defined, killed, read := x86ByteFlagsAll, uint8(0), uint8(0)
+				switch stem {
+				case "ADC", "SBB":
+					read = x86ByteFlagCF
+				case "AND", "OR", "XOR":
+					defined &^= x86ByteFlagAF
+					killed = x86ByteFlagAF
+				case "INC", "DEC":
+					defined &^= x86ByteFlagCF
+				case "NOT":
+					defined = 0
+				case "BTC", "BTR", "BTS":
+					defined = x86ByteFlagCF
+					killed = x86ByteFlagOF | x86ByteFlagSF | x86ByteFlagAF | x86ByteFlagPF
+				}
+				bitRegister := strings.HasPrefix(stem, "BT") && ins.Args[0].Kind == OpReg
+				if effect.flagsRead != read || effect.flagsDefined != defined || effect.flagsKilled != killed ||
+					effect.dynamicMemory != bitRegister {
+					t.Fatal("defined/preserved/killed flags or full bit-string memory role changed", effect)
+				}
+				for _, address := range []string{"p+0(FP)", "local-16(SP)", "0(SP)", "0(BP)", "1(SI)(BP*1)"} {
+					body := strings.Replace(row.text, "1(SI)", address, 1)
+					source := strings.Replace(x86NamedLockOracleSource(arch, "CLC\nLOCK\n"+body), "$0-", "$32-", 1)
+					x86LockScalarOriginalInstruction(t, arch, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source,
+							"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("pure effect borrowed virtual FP/AUTO native backing", api, address, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86LockScalarRMWNativeBoundaryCannotBorrowVirtualOrMixedProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LockScalarOracleForms(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$32-0\n"+row.text+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if err != nil || !known {
+					t.Fatal(err)
+				}
+				// These are consumer-input mutations, not additional Go syntax
+				// acceptance claims. In particular, SP as an index is invalid.
+				for _, memory := range []MemRef{
+					{Base: SP}, {Base: BP}, {Base: SI, Index: SP, Scale: 1},
+					{Base: SI, Index: BP, Scale: 1}, {Base: SP, Sym: "local", Off: -16},
+				} {
+					changed := form
+					changed.destination = Operand{Kind: OpMem, Mem: memory}
+					if err := x86LockScalarNativeMemoryBound(changed, ins, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native form boundary borrowed virtual frame backing", memory, err)
+					}
+				}
+				ins.x86UnboundAddressOverride = true
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch, ctx.namedAtomicLock, ctx.lockScalarNS = arch, true, "__bound_"
+				before, temporary := output.String(), ctx.tmp
+				known, terminated, err := ctx.lowerLockScalarRMW(ins.Op, ins)
+				if !known || terminated || !errors.Is(err, ErrProbeNeedsContext) ||
+					before != output.String() || temporary != ctx.tmp {
+					t.Fatal("mixed unbound native marker borrowed another form's bridge", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LockScalarRMWMalformedSourceAndDispatchRejectBeforeIR(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, body := range []string{
+			"ADDL CX", "ADDL (SI),(DI)", "ADDL X0,(SI)", "ADDL CX,$1",
+			"ADDL $1.0,(SI)", "ADDL.BAD CX,(SI)", "BTCL $128,(SI)",
+			"BTCL $-129,(SI)", "INCL $1", "NOTL (SI),(DI)",
+			"ADDL CX,(SI)(SP*1)", "ADDL CX,(SI)(DI*3)",
+		} {
+			t.Run(arch+"/"+body, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch, "CLC\nLOCK\n"+body)
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+					if err == nil || ir != "" {
+						t.Fatal("malformed complete source emitted IR", api, err)
+					}
+				}
+			})
+		}
+	}
+	ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+	ctx.namedAtomicLock, ctx.lockScalarNS = true, "__bound_"
+	before, temporary := output.String(), ctx.tmp
+	ins := Instr{Op: "SUBL", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpMem, Mem: MemRef{Base: SI}}}}
+	known, terminated, err := ctx.lowerLockScalarRMW("ADDL", ins)
+	if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+		t.Fatal("contradictory dispatch mutated IR or temporary state", known, terminated, err)
+	}
+}
+
+func TestX86LockScalarRMWCarryDoesNotAuthorizeFrameReads(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, address := range []string{"0(SP)", "0(BP)", "missing+32(FP)"} {
+			t.Run(arch+"/"+address, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch, "CMPL "+address+",AX\nLOCK\nADCL CX,(SI)")
+				x86LockScalarOriginalInstruction(t, arch, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("CF observation borrowed an unproved stack/frame read", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_carry.go b/amd64_lock_scalar_rmw_carry.go
new file mode 100644
index 000000000..35ed7cfca
--- /dev/null
+++ b/amd64_lock_scalar_rmw_carry.go
@@ -0,0 +1,358 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// This domain proves only the source of the CF value consumed by a named
+// locked ADC/SBB. It grants no register, memory, frame or caller permission.
+// GP byte facts prevent a default-zero alloca or an empty flags stack from
+// becoming an incoming carry. The ordinary consumers still check operands.
+type x86LockCarryState struct {
+	carry        bool
+	gp           [16]uint8
+	stack        []x86LockCarryCell
+	stackUnbound bool
+}
+
+type x86LockCarryCell struct {
+	bits       int
+	valueKnown bool
+	carryKnown bool
+}
+
+func (state x86LockCarryState) clone() x86LockCarryState {
+	state.stack = append([]x86LockCarryCell(nil), state.stack...)
+	return state
+}
+
+func (state x86LockCarryState) intersect(other x86LockCarryState) x86LockCarryState {
+	state = state.clone()
+	state.carry = state.carry && other.carry
+	state.stackUnbound = state.stackUnbound || other.stackUnbound
+	for index := range state.gp {
+		state.gp[index] &= other.gp[index]
+	}
+	if len(state.stack) != len(other.stack) {
+		state.stack = nil
+		state.stackUnbound = true
+	} else {
+		for index := range state.stack {
+			if state.stack[index].bits != other.stack[index].bits {
+				state.stack = nil
+				state.stackUnbound = true
+				break
+			}
+			state.stack[index].valueKnown = state.stack[index].valueKnown && other.stack[index].valueKnown
+			state.stack[index].carryKnown = state.stack[index].carryKnown && other.stack[index].carryKnown
+		}
+	}
+	if state.stackUnbound {
+		state.stack = nil
+	}
+	return state
+}
+
+func (c *amd64Ctx) lockCarryRead(operand Operand, width int64, state x86LockCarryState) bool {
+	if operand.Kind == OpFP {
+		for _, slot := range c.sig.Frame.Params {
+			bytes := x86FrameScalarBytes(slot.Type, c.goarch)
+			if bytes > 0 && operand.FPOffset >= slot.Offset &&
+				operand.FPOffset-slot.Offset <= bytes-width && width > 0 {
+				return true // Actual typed argument bits, not pointee/backing facts.
+			}
+		}
+		return false
+	}
+	if operand.Kind == OpMem || operand.Kind == OpSym {
+		// A native instruction reads actual memory bits; this does not prove
+		// its address or authorize the read. The final memory guards do that.
+		return operand.Kind == OpSym && !strings.HasPrefix(operand.Sym, "$") ||
+			operand.Kind == OpMem && operand.Mem.Sym == "" && operand.Mem.Base != SP && operand.Mem.Base != BP
+	}
+	return x86ResultRead(operand, width, &x86ResultState{gp: state.gp}, nil, c.goarch)
+}
+
+func (c *amd64Ctx) lockCarryWrite(operand Operand, width int64, known bool, state *x86LockCarryState) {
+	if operand.Kind == OpMem || operand.Kind == OpSym || operand.Kind == OpFP {
+		// No numerical/address fact here establishes nonaliasing with an
+		// outstanding source PUSH. Even an independently allowed native store
+		// cannot preserve a stack cell without a separate exact alias proof.
+		state.stack = nil
+		return
+	}
+	if operand.Kind != OpReg {
+		return
+	}
+	if base, valid := x86CallerGP(operand.Reg); valid && base == SP {
+		// Explicit SP replacement/adjustment is not an ordinary balanced
+		// PUSH/POP. This domain cannot recover its original physical identity,
+		// even if a later instruction defines the pushed GP value again.
+		state.stack = nil
+		state.stackUnbound = true
+	}
+	index, mask, valid := x86ResultGP(operand.Reg, width, c.goarch)
+	if !valid {
+		state.gp = [16]uint8{}
+		return
+	}
+	state.gp[index] &^= mask
+	if known {
+		state.gp[index] |= mask
+	}
+	if width == 4 || width == 8 {
+		state.gp[index] = 0
+		if known {
+			state.gp[index] = 0xff
+		}
+	}
+}
+
+func (c *amd64Ctx) lockCarryTransfer(ins Instr, state x86LockCarryState) x86LockCarryState {
+	ins = x86SourceMoveInstruction(ins, c.goarch) // Local numerical dispatch, never source/certificate identity.
+	op := Op(strings.ToUpper(string(ins.Op)))
+	if op == OpTEXT || op == OpRET || op == "LOCK" && len(ins.Args) == 0 ||
+		op == OpJMP || isAMD64ConditionalBranch(op) || op == "LOOP" {
+		return state
+	}
+	if (op == "CLC" || op == "STC" || op == "CMC") && len(ins.Args) == 0 {
+		state.carry = op != "CMC" || state.carry
+		return state
+	}
+	if width := x86RawReturnScalarMoveBytes(op); width != 0 &&
+		op == ins.Op && len(ins.Args) == 2 && !(width == 8 && c.goarch == "386") {
+		known := c.lockCarryRead(ins.Args[0], width, state)
+		c.lockCarryWrite(ins.Args[1], width, known, &state)
+		return state
+	}
+	if spec, found := amd64StackWidthSpecs[op]; found {
+		validMode := spec.bits == 16 || spec.bits == 32 && c.goarch == "386" || spec.bits == 64 && c.goarch == "amd64"
+		validCount := len(ins.Args) == 0
+		if spec.mode == amd64StackPushValue || spec.mode == amd64StackPopValue {
+			validCount = len(ins.Args) == 1
+		}
+		if !validMode || !validCount {
+			return x86LockCarryState{stackUnbound: true}
+		}
+		if spec.mode == amd64StackPushValue || spec.mode == amd64StackPushFlags {
+			if len(state.stack) >= 64 {
+				return x86LockCarryState{stackUnbound: true}
+			}
+			cell := x86LockCarryCell{bits: spec.bits, carryKnown: state.carry}
+			if spec.mode == amd64StackPushValue {
+				cell.valueKnown = c.lockCarryRead(ins.Args[0], int64(spec.bits/8), state)
+				cell.carryKnown = cell.valueKnown
+			}
+			if state.stackUnbound {
+				cell.valueKnown, cell.carryKnown = false, false
+			}
+			// PUSHF captures a flags word, but this domain proves only its CF.
+			// POP into GP must not promote unknown OF or other bits to numeric
+			// byte facts. A direct POPF may independently consume known CF.
+			state.stack = append(state.stack, cell)
+			return state
+		}
+		cell := x86LockCarryCell{}
+		if len(state.stack) != 0 {
+			cell = state.stack[len(state.stack)-1]
+			state.stack = state.stack[:len(state.stack)-1]
+			if cell.bits != spec.bits {
+				cell = x86LockCarryCell{}
+			}
+		}
+		if spec.mode == amd64StackPopFlags {
+			state.carry = cell.carryKnown
+		} else {
+			c.lockCarryWrite(ins.Args[0], int64(spec.bits/8), cell.valueKnown, &state)
+		}
+		return state
+	}
+	if effect, recognized, err := x86TypedInstructionByteEffect(op, ins, c.goarch); recognized {
+		if err != nil {
+			return x86LockCarryState{stackUnbound: true}
+		}
+		known := effect.flagsRead&x86ByteFlagCF == 0 || state.carry
+		for _, operand := range effect.operands {
+			if operand.read {
+				known = known && c.lockCarryRead(operand.operand, operand.width, state)
+			}
+		}
+		for _, operand := range effect.operands {
+			if operand.write {
+				c.lockCarryWrite(operand.operand, operand.width, known, &state)
+			}
+		}
+		if effect.flagsKilled&x86ByteFlagCF != 0 {
+			state.carry = false
+		}
+		if effect.flagsDefined&x86ByteFlagCF != 0 {
+			state.carry = known
+		}
+		return state
+	}
+	if (op == "CMPB" || op == "CMPW" || op == "CMPL" || op == "CMPQ" ||
+		op == "TESTB" || op == "TESTW" || op == "TESTL" || op == "TESTQ") && len(ins.Args) == 2 {
+		bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[string(op)[len(op)-1]]
+		valid := validateAMD64ScalarAddSubOperands(c.goarch, string(op), bits, ins.Args[0], ins.Args[1], ins) == nil
+		if strings.HasPrefix(string(op), "CMP") {
+			valid = valid || validateAMD64ScalarAddSubOperands(c.goarch, string(op), bits, ins.Args[1], ins.Args[0], ins) == nil
+		}
+		if !(bits == 64 && c.goarch == "386") && valid {
+			state.carry = c.lockCarryRead(ins.Args[0], int64(bits/8), state) && c.lockCarryRead(ins.Args[1], int64(bits/8), state)
+			return state
+		}
+	}
+	if op == "STMXCSR" && len(ins.Args) == 1 && isAMD64MemoryOperand(ins.Args[0]) {
+		c.lockCarryWrite(ins.Args[0], 4, false, &state)
+		return state
+	}
+	if op == "NOP" && len(ins.Args) == 0 {
+		return state
+	}
+	// Calls, native/raw effects and unregistered forms have no incoming flags
+	// preservation contract. A later explicit definition may start a new fact.
+	return x86LockCarryState{stackUnbound: true}
+}
+
+func (c *amd64Ctx) verifyNamedLockCarry() error {
+	var required [][2]int
+	for block, body := range c.blocks {
+		for index := 1; index < len(body.instrs); index++ {
+			previous, ins := body.instrs[index-1], body.instrs[index]
+			if previous.Op != "LOCK" || len(previous.Args) != 0 {
+				continue
+			}
+			form, known, err := x86LockScalarRMWProperties(ins.Op, ins, c.goarch)
+			if known && err == nil && (form.spec.stem == "ADC" || form.spec.stem == "SBB") {
+				required = append(required, [2]int{block, index})
+			}
+		}
+	}
+	if len(required) == 0 {
+		return nil // Unrelated translations retain their existing contracts.
+	}
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: named LOCK incoming carry is not source-defined: %s", ErrProbeNeedsContext, reason)
+	}
+	if len(c.blocks) > 4096 {
+		return fail("source CFG exceeds the bounded proof domain")
+	}
+	steps := 0
+	states := map[int]x86LockCarryState{0: {}}
+	queue := []int{0}
+	inputs := make(map[[2]int]bool)
+	for visits := 0; len(queue) != 0; visits++ {
+		if visits >= 32768 {
+			return fail("source CFG fixed-point budget exhausted")
+		}
+		block := queue[0]
+		queue = queue[1:]
+		state := states[block].clone()
+		for index, ins := range c.blocks[block].instrs {
+			steps++
+			if steps > 262144 {
+				return fail("combined source instruction work budget exhausted")
+			}
+			inputs[[2]int{block, index}] = state.carry
+			state = c.lockCarryTransfer(ins, state)
+		}
+		successors, valid := c.lockCarrySuccessors(block)
+		if !valid {
+			return fail("indirect, external or unresolved source control flow")
+		}
+		for _, target := range successors {
+			if previous, found := states[target]; found {
+				stateAtTarget := previous.intersect(state)
+				if reflect.DeepEqual(previous, stateAtTarget) {
+					continue
+				}
+				states[target] = stateAtTarget
+			} else {
+				states[target] = state.clone()
+			}
+			queue = append(queue, target)
+		}
+	}
+	for _, location := range required {
+		if !inputs[location] {
+			return fail("a complete ADC/SBB has an unknown predecessor CF value")
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) lockCarrySuccessors(block int) ([]int, bool) {
+	return c.sourceBlockSuccessors(block, nil)
+}
+
+// This decodes only ordinary source control flow. It supplies no LOCK, carry,
+// memory or entry authority. A complete label index avoids repeated scans for
+// consumers whose analysis must remain linear in source nodes and edges.
+func (c *amd64Ctx) sourceBlockSuccessors(block int, labels map[string]int) ([]int, bool) {
+	body := c.blocks[block].instrs
+	if len(body) == 0 {
+		if block+1 < len(c.blocks) {
+			return []int{block + 1}, true
+		}
+		return nil, true
+	}
+	ins := body[len(body)-1]
+	op := Op(strings.ToUpper(string(ins.Op)))
+	if op == OpRET {
+		return nil, len(ins.Args) == 0
+	}
+	if op != OpJMP && op != "LOOP" && !isAMD64ConditionalBranch(op) {
+		if block+1 < len(c.blocks) {
+			return []int{block + 1}, true
+		}
+		return nil, false
+	}
+	args := ins.Args
+	if op != OpJMP && op != "LOOP" && !isAMD64CounterZeroBranch(op) &&
+		len(args) == 2 && args[0].Kind == OpImm && (args[0].Imm == 0 || args[0].Imm == 1) {
+		args = args[1:]
+	}
+	if len(args) != 1 {
+		return nil, false
+	}
+	target, found := -1, false
+	if args[0].Kind == OpMem && args[0].Mem.Base == PC && args[0].Mem.OffRaw == "" {
+		base := int64(c.blockBase[block] + len(body) - 1)
+		if args[0].Mem.Off > 1<<63-1-base {
+			return nil, false
+		}
+		pc := base + args[0].Mem.Off
+		if pc >= 0 && pc <= int64(^uint(0)>>1) {
+			target, found = c.blockByIdx[int(pc)]
+		}
+	} else {
+		label := ""
+		switch args[0].Kind {
+		case OpLabel, OpSym:
+			label = args[0].Sym
+		case OpIdent:
+			label = args[0].Ident
+		case OpReg:
+			label = string(args[0].Reg)
+		}
+		if labels != nil {
+			target, found = labels[label]
+		} else {
+			for index, candidate := range c.blocks {
+				if candidate.name == label {
+					target, found = index, true
+					break
+				}
+			}
+		}
+	}
+	if !found || target < 0 || target >= len(c.blocks) {
+		return nil, false
+	}
+	if op == OpJMP {
+		return []int{target}, true
+	}
+	return []int{target, block + 1}, block+1 < len(c.blocks)
+}
diff --git a/amd64_lock_scalar_rmw_carry_alias_test.go b/amd64_lock_scalar_rmw_carry_alias_test.go
new file mode 100644
index 000000000..27616f720
--- /dev/null
+++ b/amd64_lock_scalar_rmw_carry_alias_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWCarryStackAliasesAndIdentityStayContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		for _, width := range []string{"W", word} {
+			push, pop := "PUSH"+width+" DX\n", "\nPOPF"+width
+			for _, control := range []struct{ name, body string }{
+				{"explicit stack store", push + "MOV" + width + " BP,0(SP)" + pop},
+				{"derived stack store", push + "MOV" + word + " SP,BX\nMOV" + width + " BP,(BX)" + pop},
+				{"unknown vector store", push + "MOVOU X0,0(SP)" + pop},
+				{"CSR stack store", push + "STMXCSR 0(SP)" + pop},
+				{"SP replacement before push", "MOV" + word + " $0,SP\nMOVL $5,DX\n" + push + "POPF" + width},
+				{"POP SP before new push", "PUSH" + word + " BP\nPOP" + word + " SP\nMOVL $5,DX\n" + push + "POPF" + width},
+				{"LEA SP before push", "LEA" + word + " 0(SP),SP\nMOVL $5,DX\n" + push + "POPF" + width},
+				{"balanced SP adjustment", "SUB" + word + " $16,SP\nMOVL $5,DX\n" + push + "POPF" + width + "\nADD" + word + " $16,SP"},
+			} {
+				t.Run(arch+"/"+width+"/"+control.name, func(t *testing.T) {
+					// These accepted objects are unsafe/unknown-input tripwires.
+					// They are never executed as numerical or caller evidence.
+					source := x86NamedLockOracleSource(arch, control.body+"\nLOCK\nADCL CX,(SI)")
+					x86LockScalarOriginalInstruction(t, arch, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					if err := ctx.verifyNamedLockCarry(); !errors.Is(err, ErrProbeNeedsContext) ||
+						output.String() != before || ctx.tmp != temporary {
+						t.Error("pure CF domain retained stale stack bits or regained replaced SP identity", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source,
+								"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("a stale stack value or replaced SP authorized carry", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LockScalarRMWCarryInvalidStackDoesNotInvalidateExplicitCF(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		for _, seed := range []string{"CLC", "STC"} {
+			source := x86NamedLockOracleSource(arch, "MOV"+word+" $0,SP\n"+seed+"\nLOCK\nADCL CX,(SI)")
+			x86LockScalarOriginalInstruction(t, arch, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ctx.goarch = arch
+			before, temporary := output.String(), ctx.tmp
+			if err := ctx.verifyNamedLockCarry(); err != nil || output.String() != before || ctx.tmp != temporary {
+				t.Fatal("explicit CF fact was lost or granted an IR/memory permission", err)
+			}
+			if strings.Contains(output.String(), "lock;") {
+				t.Fatal("a CF-only observation emitted an atomic object")
+			}
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_carry_stack_test.go b/amd64_lock_scalar_rmw_carry_stack_test.go
new file mode 100644
index 000000000..dc9f7bfec
--- /dev/null
+++ b/amd64_lock_scalar_rmw_carry_stack_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWCarryStackDoesNotInventWholeFlagsWord(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, counter := "Q", "JCXZQ"
+		if arch == "386" {
+			word, counter = "L", "JCXZL"
+		}
+		for _, suffix := range []string{"W", word} {
+			compare := "AND" + suffix + " $2048,AX\nCMP" + suffix + " AX,$1"
+			for _, control := range []struct {
+				name, body string
+				known      bool
+			}{
+				{"unknown OF through flags word", "CLC\nPUSHF" + suffix + "\nPOP" + suffix + " AX\n" + compare, false},
+				{"CF-only flags roundtrip", "CLC\nPUSHF" + suffix + "\nPOPF" + suffix, true},
+				{"defined whole numerical word", "PUSH" + suffix + " DX\nPOP" + suffix + " AX\n" + compare, true},
+				{"mixed flags and numerical join", "CLC\n" + counter + " flags\nPUSH" + suffix + " DX\nPOP" + suffix + " AX\nJMP compare\nflags:\nPUSHF" + suffix + "\nPOP" + suffix + " AX\ncompare:\n" + compare, false},
+				{"partial flags word through GP", "CLC\nPUSHF" + suffix + "\nPOP" + suffix + " AX\nPUSH" + suffix + " AX\nPOPF" + suffix, false},
+			} {
+				t.Run(arch+"/"+suffix+"/"+control.name, func(t *testing.T) {
+					source := x86NamedLockOracleSource(arch, control.body+"\nLOCK\nADCL CX,(SI)")
+					x86LockScalarOriginalInstruction(t, arch, source)
+					triple := testTargetTriple("linux", arch)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source,
+								"package ordering\nfunc locked(p *[16]byte)\n", arch, triple)
+							if control.known {
+								if err != nil || !strings.Contains(ir, "lock; adcl") {
+									t.Fatal("known numerical word or CF roundtrip was lost", err)
+								}
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("CF-only PUSHF falsely defined unknown GP/OF bits", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_carry_test.go b/amd64_lock_scalar_rmw_carry_test.go
new file mode 100644
index 000000000..dcfabe3c3
--- /dev/null
+++ b/amd64_lock_scalar_rmw_carry_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWUnknownIncomingCarryNeedsContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		widths := "BWL"
+		if arch == "amd64" {
+			widths += "Q"
+		}
+		for _, stem := range []string{"ADC", "SBB"} {
+			for _, width := range widths {
+				register := "CX"
+				if width == 'B' {
+					register = "CL"
+				}
+				body := "LOCK\n\t" + stem + string(width) + " " + register + ",(SI)"
+				t.Run(arch+"/"+stem+string(width), func(t *testing.T) {
+					source := x86NamedLockOracleSource(arch, body)
+					machine := x86LockScalarOriginalInstruction(t, arch, source)
+					t.Logf("actual Go accepts original instruction=%x; incoming CF remains undefined by the source", machine)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source,
+								"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+							// The unchanged source initializes its GP operands but
+							// supplies no CF producer. The public error phase/text
+							// is not part of this missing-input contract.
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("native carry-dependent memory effect borrowed an undefined entry flag: %v", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LockScalarRMWCarryCFGAndStackSources(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		suffix, counter := "Q", "JCXZQ"
+		if arch == "386" {
+			suffix, counter = "L", "JCXZL"
+		}
+		for _, control := range []struct {
+			name, body string
+			known      bool
+		}{
+			{"CLC", "CLC", true},
+			{"STC CMC", "STC\nCMC", true},
+			{"initialized CMP", "CMPL AX,$0", true},
+			{"undefined CMC", "CMC", false},
+			{"undefined compare", "CMPL BP,$0", false},
+			{"explicit stack seed", "PUSH" + suffix + " DX\nPOPF" + suffix, true},
+			{"unknown stack seed", "PUSH" + suffix + " BP\nPOPF" + suffix, false},
+			{"unseeded join", counter + " join\nCLC\njoin:", false},
+			{"seeded join", "STC\n" + counter + " join\nCLC\njoin:", true},
+			{"call clobber", "STC\nCALL ·other(SB)", false},
+			{"undefined divide flags", "STC\nDIVL CX", false},
+			{"loop retains seed", "STC\nloop:\nNOP\nLOOP loop", true},
+		} {
+			t.Run(arch+"/"+control.name, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch,
+					control.body+"\nLOCK\nADCL CX,(SI)")
+				x86LockScalarOriginalInstruction(t, arch, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before, temporary := output.String(), ctx.tmp
+				carryErr := ctx.verifyNamedLockCarry()
+				if output.String() != before || ctx.tmp != temporary {
+					t.Fatal("carry-only proof changed emitted code")
+				}
+				if control.known {
+					if carryErr != nil {
+						t.Fatal("defined source carry was lost", carryErr)
+					}
+				} else if !errors.Is(carryErr, ErrProbeNeedsContext) {
+					t.Fatal("independent carry proof accepted an undefined source", carryErr)
+				}
+				// The public proof may reject an earlier undefined stack value
+				// before reaching LOCK. Its phase is not the carry-only contract.
+				triple := testTargetTriple("linux", arch)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source,
+							"package ordering\nfunc locked(p *[16]byte)\nfunc other()\n", arch, triple)
+						if control.known {
+							if err != nil || !strings.Contains(ir, "lock; adcl") {
+								t.Fatal("independent defined carry was not retained", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("unclosed carry acquired a numerical value", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LockScalarRMWCarryBudgetAndInputsRemainUnchanged(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86NamedLockOracleSource("amd64", "CLC\nLOCK\nADCL CX,(SI)"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+	before, temporary := output.String(), ctx.tmp
+	source := fmt.Sprintf("%#v", file)
+	for count := 0; count != 2; count++ {
+		if err := ctx.verifyNamedLockCarry(); err != nil || before != output.String() || temporary != ctx.tmp || source != fmt.Sprintf("%#v", file) {
+			t.Fatal("CF proof modified IR, temporary state or input source", err)
+		}
+	}
+	ctx.blocks = make([]amd64Block, 4097)
+	ctx.blocks[0].instrs = []Instr{{Op: "LOCK"}, {Op: "ADCL", Args: []Operand{{Kind: OpReg, Reg: CX}, {Kind: OpMem, Mem: MemRef{Base: SI}}}}}
+	if err := ctx.verifyNamedLockCarry(); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "bounded") {
+		t.Fatal("oversized CF domain did not fail closed", err)
+	}
+	ctx.blocks = nil
+	// Synthetic empty/mismatched cells are consumer tripwires, not Go source
+	// acceptance evidence: stock Go rejects a bare POPF as an unbalanced pop.
+	if state := ctx.lockCarryTransfer(Instr{Op: "POPFQ"}, x86LockCarryState{carry: true}); state.carry {
+		t.Fatal("synthetic empty stack supplied carry")
+	}
+	state := x86LockCarryState{carry: true, stack: []x86LockCarryCell{{bits: 16, valueKnown: true, carryKnown: true}}}
+	if state = ctx.lockCarryTransfer(Instr{Op: "POPFQ"}, state); state.carry {
+		t.Fatal("synthetic mismatched-width stack cell supplied carry")
+	}
+}
diff --git a/amd64_lock_scalar_rmw_dispatch_test.go b/amd64_lock_scalar_rmw_dispatch_test.go
new file mode 100644
index 000000000..131210031
--- /dev/null
+++ b/amd64_lock_scalar_rmw_dispatch_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A correct but uncalled helper is not instruction coverage. Independently
+// follow every public source body through dispatch and both IR levels.
+func TestX86LockScalarRMWPublicBodiesCallCompleteNativeHelpers(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86LockScalarOracleForms(target.arch)
+			want := 90
+			if target.arch == "386" {
+				want = 66
+			}
+			if len(rows) != want {
+				t.Fatal("incomplete independent scalar LOCK family", len(rows), want)
+			}
+			var source, declarations strings.Builder
+			declarations.WriteString("package ordering\n")
+			names := make([]string, len(rows))
+			helpers := make([]string, len(rows))
+			for index, row := range rows {
+				names[index] = fmt.Sprintf("locked%d", index)
+				original := x86NamedLockOracleSource(target.arch, "CMPL AX,AX\nLOCK\n"+row.text)
+				source.WriteString(strings.Replace(original, "·locked", "·"+names[index], 1))
+				fmt.Fprintf(&declarations, "func %s(p *[16]byte)\n", names[index])
+				bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+				stem := strings.ToLower(row.op[:len(row.op)-1])
+				helpers[index] = fmt.Sprintf("__plan9asm_lock_rmw_0_%s_%s%d_native", target.arch, stem, bits)
+				if strings.Contains(row.text, "$1") {
+					helpers[index] += "_imm_0000000000000001"
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []int{0, 2} {
+						t.Run(fmt.Sprintf("IR%d", level), func(t *testing.T) {
+							text := ir
+							if level == 2 {
+								text = x86MulDivRoundOptimize(t, text)
+							}
+							bodies := x86StringMemoryFunctions(t, text, names)
+							for index, name := range names {
+								t.Run(rows[index].text, func(t *testing.T) {
+									body := bodies[name]
+									if strings.Count(body, "@"+helpers[index]+"(") != 1 {
+										t.Fatal("public body bypassed its complete native LOCK helper", name, helpers[index], body)
+									}
+								})
+							}
+							for _, backend := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, backend)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_lock_scalar_rmw_encoder_test.go b/amd64_lock_scalar_rmw_encoder_test.go
new file mode 100644
index 000000000..7d0b989d6
--- /dev/null
+++ b/amd64_lock_scalar_rmw_encoder_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This independent carrier binds every ordered row, operand class, zcase,
+// offset, prefix and opcode byte. It does not establish an address permission
+// or assert which overlapping row an actual source instruction selects.
+func x86LockScalarEncoderCarrier(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "asm6.go", source, 0)
+	if err != nil {
+		return err
+	}
+	variables := make(map[string]*ast.CompositeLit)
+	for _, declaration := range file.Decls {
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok || general.Tok != token.VAR {
+			continue
+		}
+		for _, spec := range general.Specs {
+			value := spec.(*ast.ValueSpec)
+			for index, name := range value.Names {
+				if index < len(value.Values) {
+					if literal, ok := value.Values[index].(*ast.CompositeLit); ok {
+						variables[name.Name] = literal
+					}
+				}
+			}
+		}
+	}
+	canonical := func(node ast.Node) string {
+		var output bytes.Buffer
+		if err := format.Node(&output, token.NewFileSet(), node); err != nil {
+			return ""
+		}
+		return output.String()
+	}
+	parse := func(source string) (ast.Expr, error) {
+		return parser.ParseExpr(source)
+	}
+	tables := map[string]string{
+		"yxorb": `[]ytab{
+			{Zib_, 1, argList{Yi32, Yal}},
+			{Zibo_m, 2, argList{Yi32, Ymb}},
+			{Zr_m, 1, argList{Yrb, Ymb}},
+			{Zm_r, 1, argList{Ymb, Yrb}},
+		}`,
+		"yaddl": `[]ytab{
+			{Zibo_m, 2, argList{Yi8, Yml}},
+			{Zil_, 1, argList{Yi32, Yax}},
+			{Zilo_m, 2, argList{Yi32, Yml}},
+			{Zr_m, 1, argList{Yrl, Yml}},
+			{Zm_r, 1, argList{Yml, Yrl}},
+		}`,
+		"yincl":  `[]ytab{{Z_rp, 1, argList{Yrl}}, {Zo_m, 2, argList{Yml}}}`,
+		"yincq":  `[]ytab{{Zo_m, 2, argList{Yml}}}`,
+		"yscond": `[]ytab{{Zo_m, 2, argList{Ymb}}}`,
+		"ybtl":   `[]ytab{{Zibo_m, 2, argList{Yi8, Yml}}, {Zr_m, 1, argList{Yrl, Yml}}}`,
+	}
+	for name, text := range tables {
+		want, err := parse(text)
+		if err != nil {
+			return err
+		}
+		actual := variables[name]
+		if actual == nil || canonical(actual) != canonical(want) {
+			return fmt.Errorf("complete ordered Go encoder table changed: %s", name)
+		}
+	}
+	optab := variables["optab"]
+	if optab == nil {
+		return fmt.Errorf("Go encoder has no complete optab")
+	}
+	pattern := regexp.MustCompile(`^A(?:ADC|ADD|AND|OR|SBB|SUB|XOR|INC|DEC|NEG|NOT|BTC|BTR|BTS)[BWLQ]$`)
+	rows := make(map[string]string)
+	for _, entry := range optab.Elts {
+		row, ok := entry.(*ast.CompositeLit)
+		if !ok || len(row.Elts) == 0 {
+			continue
+		}
+		name := canonical(row.Elts[0])
+		if !pattern.MatchString(name) {
+			continue
+		}
+		if _, exists := rows[name]; exists {
+			return fmt.Errorf("duplicate encoder row: %s", name)
+		}
+		rows[name] = canonical(row)
+	}
+	if len(rows) != 53 {
+		return fmt.Errorf("complete opcode carrier has %d rows, want 53", len(rows))
+	}
+	// The native byte formulas below are independent of the typed production
+	// spec. Group numbers are written in the actual Go table's octal spelling.
+	for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR", "INC", "DEC", "NEG", "NOT", "BTC", "BTR", "BTS"} {
+		for _, width := range "BWLQ" {
+			if strings.HasPrefix(stem, "BT") && width == 'B' {
+				continue
+			}
+			name := "A" + stem + string(width)
+			table, prefix := "yaddl", map[rune]string{'B': "Pb", 'W': "Pe", 'L': "Px", 'Q': "Pw"}[width]
+			encoding := ""
+			switch stem {
+			case "INC", "DEC":
+				group, short := 0, 0x40
+				if stem == "DEC" {
+					group, short = 1, 0x48
+				}
+				table = "yincq"
+				encoding = fmt.Sprintf("0xff, %02o", group)
+				if width == 'B' {
+					table, encoding = "yscond", fmt.Sprintf("0xfe, %02o", group)
+				} else if width == 'L' {
+					table, prefix, encoding = "yincl", "Px1", fmt.Sprintf("0x%02x, 0xff, %02o", short, group)
+				}
+			case "NEG", "NOT":
+				group, opcode := 3, 0xf7
+				if stem == "NOT" {
+					group = 2
+				}
+				if width == 'B' {
+					opcode = 0xf6
+				}
+				table, encoding = "yscond", fmt.Sprintf("0x%02x, %02o", opcode, group)
+			case "BTC", "BTR", "BTS":
+				group, opcode := map[string]int{"BTC": 7, "BTR": 6, "BTS": 5}[stem], map[string]int{"BTC": 0xbb, "BTR": 0xb3, "BTS": 0xab}[stem]
+				table, encoding = "ybtl", fmt.Sprintf("0xba, %02o, 0x%02x", group, opcode)
+				prefix = "Pm"
+				if width == 'W' {
+					prefix = "Pq"
+				} else if width == 'Q' {
+					prefix, encoding = "Pw", fmt.Sprintf("0x0f, 0xba, %02o, 0x0f, 0x%02x", group, opcode)
+				}
+			default:
+				group := map[string]int{"ADD": 0, "OR": 1, "ADC": 2, "SBB": 3, "AND": 4, "SUB": 5, "XOR": 6}[stem]
+				base := group * 8
+				encoding = fmt.Sprintf("0x83, %02o, 0x%02x, 0x81, %02o, 0x%02x, 0x%02x", group, base+5, group, base+1, base+3)
+				if width == 'B' {
+					table, encoding = "yxorb", fmt.Sprintf("0x%02x, 0x80, %02o, 0x%02x, 0x%02x", base+4, group, base, base+2)
+				}
+			}
+			want, err := parse("[]Optab{{" + name + ", " + table + ", " + prefix + ", opBytes{" + encoding + "}}}")
+			if err != nil {
+				return err
+			}
+			if rows[name] != canonical(want.(*ast.CompositeLit).Elts[0]) {
+				return fmt.Errorf("opcode-specific complete encoder attributes changed: %s", name)
+			}
+		}
+	}
+	return nil
+}
+
+func TestX86LockScalarRMWEncoderCarrierRejectsRuleMutation(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86LockScalarEncoderCarrier(source); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ name, from, to string }{
+		{"class", "{Zib_, 1, argList{Yi32, Yal}}", "{Zib_, 1, argList{Yi8, Yal}}"},
+		{"operand-count", "{Zib_, 1, argList{Yi32, Yal}}", "{Zib_, 1, argList{Yi32, Yal, Ymb}}"},
+		{"zcase", "{Zib_, 1, argList{Yi32, Yal}}", "{Zil_, 1, argList{Yi32, Yal}}"},
+		{"zoffset", "{Zib_, 1, argList{Yi32, Yal}}", "{Zib_, 2, argList{Yi32, Yal}}"},
+		{"row-order", "{Zib_, 1, argList{Yi32, Yal}},\n\t{Zibo_m, 2, argList{Yi32, Ymb}}", "{Zibo_m, 2, argList{Yi32, Ymb}},\n\t{Zib_, 1, argList{Yi32, Yal}}"},
+		{"extra-row", "var yincq = []ytab{", "var yincq = []ytab{\n{Zo_m, 2, argList{Ymb}},"},
+		{"prefix", "{AADCB, yxorb, Pb,", "{AADCB, yxorb, Px,"},
+		{"opcode-bytes", "{AADCB, yxorb, Pb, opBytes{0x14,", "{AADCB, yxorb, Pb, opBytes{0x15,"},
+		{"table-binding", "{AADCB, yxorb, Pb,", "{AADCB, yaddl, Pb,"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			if !strings.Contains(string(source), mutation.from) {
+				t.Fatal("mutation no longer binds its actual Go source")
+			}
+			changed := strings.Replace(string(source), mutation.from, mutation.to, 1)
+			if err := x86LockScalarEncoderCarrier([]byte(changed)); err == nil {
+				t.Fatal("full Go encoder carrier admitted a changed rule")
+			}
+		})
+	}
+}
diff --git a/amd64_lock_scalar_rmw_forms.go b/amd64_lock_scalar_rmw_forms.go
new file mode 100644
index 000000000..015cf77b1
--- /dev/null
+++ b/amd64_lock_scalar_rmw_forms.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// This is an operand/effect record, not an atomic, pointer or frame capability.
+// LOCK requires the independent complete source-adjacency consumer.
+type x86LockScalarRMWSpec struct {
+	stem         string
+	bits         int
+	unary        bool
+	bitString    bool
+	carryInput   bool
+	flagsDefined uint8
+	flagsKilled  uint8
+}
+
+type x86LockScalarRMWForm struct {
+	spec        x86LockScalarRMWSpec
+	source      Operand
+	destination Operand
+}
+
+// Numerical output bytes are independent of FLAGS preservation. INC/DEC do
+// not read CF to compute data, while ADC/SBB do. Arithmetic carry/borrow flows
+// only toward higher bytes; the four logical operations are byte-local.
+func (s x86LockScalarRMWSpec) numericalByteInputs(output int) (mask uint8, carry bool) {
+	if output < 0 || output >= s.bits/8 {
+		return 0, false
+	}
+	switch s.stem {
+	case "AND", "OR", "XOR", "NOT":
+		return 1 << uint(output), false
+	case "ADC", "SBB":
+		return uint8((uint16(1) << uint(output+1)) - 1), true
+	case "ADD", "SUB", "INC", "DEC", "NEG":
+		return uint8((uint16(1) << uint(output+1)) - 1), false
+	default:
+		return 0, false // Bit-string indexes retain their separate dependencies.
+	}
+}
+
+var x86LockScalarRMWSpecs = func() map[Op]x86LockScalarRMWSpec {
+	result := make(map[Op]x86LockScalarRMWSpec)
+	for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR", "INC", "DEC", "NEG", "NOT", "BTC", "BTR", "BTS"} {
+		for index, suffix := range "BWLQ" {
+			spec := x86LockScalarRMWSpec{stem: stem, bits: []int{8, 16, 32, 64}[index], flagsDefined: x86ByteFlagsAll}
+			switch stem {
+			case "ADC", "SBB":
+				spec.carryInput = true
+			case "AND", "OR", "XOR":
+				spec.flagsDefined &^= x86ByteFlagAF
+				spec.flagsKilled = x86ByteFlagAF
+			case "INC", "DEC":
+				spec.unary, spec.carryInput = true, true
+				spec.flagsDefined &^= x86ByteFlagCF
+			case "NEG":
+				spec.unary = true
+			case "NOT":
+				spec.unary, spec.flagsDefined = true, 0
+			case "BTC", "BTR", "BTS":
+				if suffix == 'B' {
+					continue
+				}
+				spec.bitString = true
+				spec.flagsDefined = x86ByteFlagCF
+				spec.flagsKilled = x86ByteFlagOF | x86ByteFlagSF | x86ByteFlagAF | x86ByteFlagPF
+			}
+			result[Op(stem+string(suffix))] = spec
+		}
+	}
+	return result
+}()
+
+func x86LockScalarRMWProperties(op Op, ins Instr, arch string) (x86LockScalarRMWForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base, _, _ := strings.Cut(name, ".")
+	spec, recognized := x86LockScalarRMWSpecs[Op(base)]
+	if !recognized {
+		return x86LockScalarRMWForm{}, false, nil
+	}
+	if spec.bitString {
+		form, _, err := x86BitTestProperties(op, ins, arch)
+		return x86LockScalarRMWForm{spec: spec, source: form.index, destination: form.destination}, true, err
+	}
+	fail := func(reason string) (x86LockScalarRMWForm, bool, error) {
+		return x86LockScalarRMWForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if name != base || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) ||
+		arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 {
+		return fail("has an invalid suffix, dispatch identity or machine mode")
+	}
+	count := 2
+	if spec.unary {
+		count = 1
+	}
+	if len(ins.Args) != count {
+		return fail("has an incomplete operand list")
+	}
+	form := x86LockScalarRMWForm{spec: spec, destination: ins.Args[count-1]}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, form.destination, arch); segment {
+		if err != nil {
+			return form, true, err
+		}
+		form.destination = projected
+	}
+	if form.destination.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(form.destination.Sym), "$") {
+		return fail("requires writable memory, not a symbol address literal")
+	}
+	if !spec.unary {
+		form.source = ins.Args[0]
+		if projected, segment, err := x86NamedSegmentMemorySource(ins, form.source, arch); segment {
+			if err != nil {
+				return form, true, err
+			}
+			form.source = projected
+		}
+	}
+	if spec.unary {
+		if form.destination.Kind == OpReg {
+			allowed := isX86YrlRegisterForArch(form.destination.Reg, arch)
+			if spec.stem == "NEG" || spec.stem == "NOT" || spec.bits == 8 {
+				allowed = isGoYmbRegisterForArch(form.destination.Reg, arch)
+			}
+			if !allowed {
+				return fail("destination is outside its complete Go register class")
+			}
+			if spec.stem == "NEG" || spec.stem == "NOT" {
+				form.destination.Reg = amd64YmbEffectiveRegister(form.destination.Reg, spec.bits)
+			}
+		} else if !isAMD64MemoryOperand(form.destination) {
+			return fail("destination is outside the Go memory class")
+		}
+	} else {
+		if err := validateAMD64ScalarAddSubOperands(arch, base, spec.bits, form.source, form.destination, ins); err != nil {
+			return x86LockScalarRMWForm{}, true, err
+		}
+		if form.source.Kind == OpImm {
+			form.source.Imm = amd64ScalarAddSubImmediateInt64(form.source.Imm, spec.bits)
+		}
+	}
+	needsTLS := false
+	for _, operand := range []Operand{form.source, form.destination} {
+		if operand.Kind == OpImm && (operand.ImmRaw != "" || operand.ImmIsFloat) {
+			return fail("requires a resolved integer immediate")
+		}
+		if operand.Kind != OpMem {
+			continue
+		}
+		if x86SourceTLSMemoryRole(operand, arch) {
+			needsTLS = true
+			continue
+		}
+		memory := operand.Mem
+		if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+			return x86LockScalarRMWForm{}, true, err
+		}
+		if arch == "386" && strings.HasSuffix(memory.Sym, "(SB)") {
+			memory.Base = "" // Only the actual Go ignored annotation is discarded.
+		}
+		if !x86MemoryRegistersValidForArch(memory, arch) || memory.OffRaw != "" ||
+			memory.Index == SP || memory.Index != "" && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 ||
+			memory.Off != int64(int32(memory.Off)) && !(arch == "386" && memory.Off == int64(uint32(memory.Off))) {
+			return fail("has an unencodable or unresolved native memory operand")
+		}
+	}
+	if needsTLS {
+		// Validate the complete operand row before preserving TLS's source
+		// role. It is not an ordinary SIB address or a native memory grant.
+		return form, true, fmt.Errorf("%w: %s %s TLS memory needs its actual Go OS/arch/shared address contract: %q",
+			ErrProbeNeedsContext, arch, op, ins.Raw)
+	}
+	if arch == "amd64" && spec.bits == 8 && x86CompareExchangeHasREXByteView(x86CompareExchangeForm{
+		source: form.source, destination: form.destination,
+	}) {
+		// Go emits these original Ymb spellings with their raw ModRM number.
+		// A REX prefix selects SP/BP/SI/DI's low byte instead of AH/CH/DH/BH.
+		// Recording the physical view does not bind a source/native input.
+		for _, operand := range []*Operand{&form.source, &form.destination} {
+			if operand.Kind == OpReg && (operand.Reg == AH || operand.Reg == CH || operand.Reg == DH || operand.Reg == BH) {
+				operand.Reg = amd64YmbEffectiveRegister(operand.Reg, 16)
+			}
+		}
+	}
+	return form, true, nil
+}
+
+func x86LockScalarNativeMemoryBound(form x86LockScalarRMWForm, ins Instr, arch string) error {
+	if form.destination.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(form.destination.Sym), "$") {
+		return fmt.Errorf("%s LOCK RMW address literal is not writable native memory", arch)
+	}
+	if form.destination.Kind != OpMem && form.destination.Kind != OpSym || ins.x86UnboundAddressOverride {
+		return fmt.Errorf("%w: %s LOCK RMW needs its bound native memory destination, not a virtual FP/AUTO span", ErrProbeNeedsContext, arch)
+	}
+	if form.destination.Kind == OpMem {
+		memory := form.destination.Mem
+		if memory.Base == SP || memory.Base == BP || memory.Index == SP || memory.Index == BP {
+			// Numeric source slots and LLVM's private SP allocation do not
+			// establish the original instruction's physical native address.
+			return fmt.Errorf("%w: %s LOCK RMW needs independent native SP/BP backing", ErrProbeNeedsContext, arch)
+		}
+	}
+	if arch == "amd64" && form.spec.bits == 8 && form.source.Kind == OpReg &&
+		len(ins.Args) == 2 && form.source.Reg != ins.Args[0].Reg {
+		return fmt.Errorf("%w: amd64 LOCK byte source needs its original Go REX physical register view", ErrProbeNeedsContext)
+	}
+	if arch == "386" && form.spec.bits == 8 && form.source.Kind == OpReg {
+		switch form.source.Reg {
+		case AX, BX, CX, DX, AL, AH, BL, BH, CL, CH, DL, DH:
+		default:
+			return fmt.Errorf("%w: 386 LOCK byte source requires Go's original scratch-register expansion", ErrProbeNeedsContext)
+		}
+	}
+	return nil
+}
diff --git a/amd64_lock_scalar_rmw_forms_test.go b/amd64_lock_scalar_rmw_forms_test.go
new file mode 100644
index 000000000..f32842ebf
--- /dev/null
+++ b/amd64_lock_scalar_rmw_forms_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+type x86LockScalarOracleForm struct {
+	op   string
+	text string
+}
+
+// This inventory is independent of the production dispatch. Intel's complete
+// LOCK list contains these fourteen stems plus the five existing exchange and
+// compare-exchange stems. Go's yxorb/yaddl/yscond/yincl/yincq/ybtl ordered tables
+// determine their immediate, register and memory operand forms.
+func x86LockScalarOracleForms(arch string) []x86LockScalarOracleForm {
+	widths := "BWL"
+	if arch == "amd64" {
+		widths += "Q"
+	}
+	var forms []x86LockScalarOracleForm
+	for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR"} {
+		for _, width := range widths {
+			op, register := stem+string(width), "CX"
+			if width == 'B' {
+				register = "CL"
+			}
+			for _, source := range []string{register, "$1"} {
+				forms = append(forms, x86LockScalarOracleForm{op, op + " " + source + ",1(SI)"})
+			}
+		}
+	}
+	for _, stem := range []string{"INC", "DEC", "NEG", "NOT"} {
+		for _, width := range widths {
+			op := stem + string(width)
+			forms = append(forms, x86LockScalarOracleForm{op, op + " 1(SI)"})
+		}
+	}
+	for _, stem := range []string{"BTC", "BTR", "BTS"} {
+		for _, width := range strings.TrimPrefix(widths, "B") {
+			op := stem + string(width)
+			for _, source := range []string{"CX", "$1"} {
+				forms = append(forms, x86LockScalarOracleForm{op, op + " " + source + ",1(SI)"})
+			}
+		}
+	}
+	return forms
+}
+
+func TestX86LockScalarRMWCompleteGoTables(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86LockScalarEncoderCarrier(data); err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`(?m)^\s*\{A((?:ADC|ADD|AND|OR|SBB|SUB|XOR|INC|DEC|NEG|NOT|BTC|BTR|BTS)[BWLQ]),\s*(\w+),`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 53 {
+		t.Fatalf("complete scalar LOCK opcode inventory changed: %d", len(rows))
+	}
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		op, table := row[1], row[2]
+		if seen[op] {
+			t.Fatal("duplicate Go opcode registration", op)
+		}
+		seen[op] = true
+		width, stem := op[len(op)-1], op[:len(op)-1]
+		want := "yaddl"
+		switch stem {
+		case "BTC", "BTR", "BTS":
+			want = "ybtl"
+		case "INC", "DEC":
+			want = "yincq"
+			if width == 'B' {
+				want = "yscond"
+			} else if width == 'L' {
+				want = "yincl"
+			}
+		case "NEG", "NOT":
+			want = "yscond"
+		default:
+			if width == 'B' {
+				want = "yxorb"
+			}
+		}
+		if table != want {
+			t.Fatalf("Go ordered-table role changed: %s/%s, want %s", op, table, want)
+		}
+	}
+	for _, form := range x86LockScalarOracleForms("amd64") {
+		if !seen[form.op] {
+			t.Fatal("independent syntax inventory is absent from actual Go tables", form.op)
+		}
+	}
+}
+
+func x86LockScalarOriginalInstruction(t *testing.T, arch, source string) []byte {
+	t.Helper()
+	code := x86OrderingHintGoBytes(t, arch, source)
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	for offset := 0; offset < len(code); {
+		instruction, err := x86asm.Decode(code[offset:], mode)
+		if err != nil || instruction.Len <= 0 {
+			t.Fatalf("actual original Go bytes cannot be decoded at %d: %v", offset, err)
+		}
+		if code[offset] == 0xf0 {
+			return append([]byte(nil), code[offset:offset+instruction.Len]...)
+		}
+		offset += instruction.Len
+	}
+	t.Fatalf("actual complete Go object lacks its LOCK-prefixed instruction: %x", code)
+	return nil
+}
+
+func TestX86LockScalarRMWWholeSourceAdmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		forms := x86LockScalarOracleForms(arch)
+		want := 90
+		if arch == "386" {
+			want = 66
+		}
+		if len(forms) != want {
+			t.Fatal("complete accepted operand-form denominator changed", arch, len(forms))
+		}
+		for _, form := range forms {
+			t.Run(arch+"/"+form.text, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch, "CMPL AX,AX\n\tLOCK\n\t"+form.text)
+				machine := x86LockScalarOriginalInstruction(t, arch, source)
+				t.Logf("actual original LOCK object bytes=%x", machine)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source,
+							"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+						if err != nil || !strings.Contains(ir, "lock; "+strings.ToLower(form.op)) {
+							t.Fatalf("actual Go accepted whole scalar LOCK RMW lacks its ordered atomic effect: %v", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LockScalarRMWRawWholeInstructionRetainsContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, form := range x86LockScalarOracleForms(arch) {
+			t.Run(arch+"/"+form.text, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch, "CMPL AX,AX\n\tLOCK\n\t"+form.text)
+				machine := x86LockScalarOriginalInstruction(t, arch, source)
+				var body strings.Builder
+				for _, value := range machine {
+					fmt.Fprintf(&body, "BYTE $%d\n", value)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api,
+							x86NamedLockOracleSource(arch, "CMPL AX,AX\n\t"+body.String()),
+							"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("raw LOCK lost its unresolved whole physical-prefix contract", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_linux_amd64_test.go b/amd64_lock_scalar_rmw_linux_amd64_test.go
new file mode 100644
index 000000000..8767104de
--- /dev/null
+++ b/amd64_lock_scalar_rmw_linux_amd64_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// These are required native execution axes. Darwin/Rosetta and QEMU numerical
+// observations do not establish native Linux arithmetic or atomic semantics.
+func TestCrossLinuxRuntimeMatrixX86LockScalarRMWNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	TestCrossLinuxRuntimeMatrixX86LockScalarRMWOriginalAndLLVM(t)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86LockScalarRMWNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("required LLVM22 and IA32 static compiler unavailable", err)
+	}
+	declarations, assembly, driver, reference, count := x86LockScalarRuntimeFixture("386")
+	if count != 129 {
+		t.Fatal("complete IA32 kernel denominator changed", count)
+	}
+	want := fmt.Sprintf("lock observations %d\n", count*292*2*8)
+	dir := t.TempDir()
+	original := x86OrderingHintBuildOriginal(t, dir, "linux", "386", declarations, assembly, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != want {
+		t.Fatalf("actual original Go native IA32 full arithmetic/status/canary oracle: %q", output)
+	}
+	mode := "i386-unknown-linux-gnu"
+	ir, err := x86OrderingHintTranslateAPI(t, "Go", assembly, declarations, "386", mode)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := filepath.Join(dir, "lock"+level+".ll")
+			object := filepath.Join(dir, "lock"+level+".o")
+			main := filepath.Join(dir, "main.c")
+			executable := filepath.Join(dir, "lock"+level)
+			for name, contents := range map[string]string{input: ir, main: reference} {
+				if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(llc, level,
+				"-mtriple="+mode, "-filetype=obj", input, "-o", object))
+			x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie",
+				object, main, "-O2", "-o", executable))
+			sealed, err := x87IA32StaticExecutable(executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != want {
+				t.Fatalf("native LLVM IA32 full-width/flags/MXCSR/canary oracle: %q", output)
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_lock_scalar_rmw_namespace_test.go b/amd64_lock_scalar_rmw_namespace_test.go
new file mode 100644
index 000000000..fe217310d
--- /dev/null
+++ b/amd64_lock_scalar_rmw_namespace_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWNoCandidateDoesNotResolveLocals(t *testing.T) {
+	for _, body := range []string{
+		"MOVQ value+0(FP),AX\nloop:\nRET",
+		"LOCK\nADDL AX,BX\nRET",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-8\n"+body+"\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		var calls []string
+		namespace := x86LockScalarNamespace(file, "amd64", func(symbol string) string {
+			calls = append(calls, symbol)
+			return strings.TrimPrefix(symbol, "·")
+		}, map[string]FuncSig{"f": {Name: "f", Ret: Void}})
+		if namespace != "" || len(calls) != 0 {
+			t.Fatalf("no legal helper must not allocate names or call the user resolver: namespace=%q calls=%v", namespace, calls)
+		}
+	}
+}
+
+func TestX86LockScalarRMWNamespaceUsesFinalGlobalsOnly(t *testing.T) {
+	file, err := Parse(ArchAMD64, `TEXT ·f(SB),4,$0-8
+	MOVQ value+0(FP),SI
+	MOVL $1,AX
+	LOCK
+	ADDL AX,(SI)
+done:
+	RET
+DATA ·table+0(SB)/8,$·imported(SB)
+GLOBL ·table(SB),8,$8
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	final := map[string]string{
+		"·f":        "__plan9asm_lock_rmw_0_amd64_add32_native",
+		"·table":    "__plan9asm_lock_rmw_1_amd64_add32_native",
+		"·imported": "imported",
+	}
+	var unknown []string
+	resolve := func(symbol string) string {
+		if name, ok := final[symbol]; ok {
+			return name
+		}
+		unknown = append(unknown, symbol)
+		return symbol
+	}
+	sigs := map[string]FuncSig{
+		final["·f"]: {Name: final["·f"], Ret: Void},
+		"imported":  {Name: "__plan9asm_lock_rmw_2_amd64_add32_native", Ret: Void},
+	}
+	if namespace := x86LockScalarNamespace(file, "amd64", resolve, sigs); namespace != "__plan9asm_lock_rmw_3_" || len(unknown) != 0 {
+		t.Fatalf("helper namespace must bind final function/data/import names, not FP or local labels: namespace=%q unknown=%v", namespace, unknown)
+	}
+}
+
+func TestX86LockScalarRMWUnrelatedTranslationKeepsResolverDomain(t *testing.T) {
+	file, err := Parse(ArchAMD64, `TEXT ·f(SB),4,$0-8
+	MOVQ value+0(FP),AX
+done:
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var calls, unknown []string
+	resolve := func(symbol string) string {
+		calls = append(calls, symbol)
+		if symbol != "·f" {
+			unknown = append(unknown, symbol)
+		}
+		return strings.TrimPrefix(symbol, "·")
+	}
+	sig := FuncSig{Name: "f", Args: []LLVMType{I64}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+	ir, err := Translate(file, Options{Goarch: "amd64", ResolveSym: resolve, Sigs: map[string]FuncSig{"f": sig}})
+	if err != nil || len(unknown) != 0 || len(calls) != 6 || strings.Contains(ir, "__plan9asm_lock_rmw_") {
+		t.Fatalf("a no-LOCK translation changed its existing resolver domain/count: error=%v calls=%v", err, calls)
+	}
+}
diff --git a/amd64_lock_scalar_rmw_native.go b/amd64_lock_scalar_rmw_native.go
new file mode 100644
index 000000000..054ee6b21
--- /dev/null
+++ b/amd64_lock_scalar_rmw_native.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+// A namespace is a compiler name allocation, never a source certificate.
+func x86LockScalarNamespace(file *File, arch string, resolve func(string) string, sigs map[string]FuncSig) string {
+	if len(x86LockScalarRMWHelperForms(file, arch)) == 0 {
+		return ""
+	}
+	return x86CompilerHelperNamespace(file, resolve, sigs, "lock_rmw")
+}
+
+func x86LockScalarHelperName(namespace string, form x86LockScalarRMWForm, arch string) string {
+	segment := "native"
+	if form.destination.Kind == OpMem && form.destination.Mem.Segment != "" {
+		segment = strings.ToLower(string(form.destination.Mem.Segment))
+	}
+	name := namespace + arch + "_" + strings.ToLower(form.spec.stem) + fmt.Sprint(form.spec.bits) + "_" + segment
+	if form.source.Kind == OpImm {
+		name += fmt.Sprintf("_imm_%016x", uint64(form.source.Imm))
+	}
+	return name
+}
+
+func x86LockScalarPointerType(form x86LockScalarRMWForm) string {
+	if form.destination.Kind == OpMem {
+		switch form.destination.Mem.Segment {
+		case FS:
+			return "ptr addrspace(257)"
+		case GS:
+			return "ptr addrspace(256)"
+		}
+	}
+	return "ptr"
+}
+
+func x86LockScalarRMWHelperForms(file *File, arch string) map[string]x86LockScalarRMWForm {
+	forms := make(map[string]x86LockScalarRMWForm)
+	if file == nil || file.Arch != ArchAMD64 || arch != "amd64" && arch != "386" {
+		return forms
+	}
+	for _, fn := range file.Funcs {
+		for _, block := range amd64SplitBlocks(fn) {
+			for index := 1; index < len(block.instrs); index++ {
+				prefix, body := block.instrs[index-1], block.instrs[index]
+				if !strings.EqualFold(string(prefix.Op), "LOCK") || len(prefix.Args) != 0 {
+					continue
+				}
+				form, recognized, err := x86LockScalarRMWProperties(body.Op, body, arch)
+				if !recognized || err != nil || x86LockScalarNativeMemoryBound(form, body, arch) != nil {
+					continue // The ordinary final consumer retains the actual error.
+				}
+				forms[x86LockScalarHelperName("", form, arch)] = form
+			}
+		}
+	}
+	return forms
+}
+
+func emitX86LockScalarRMWHelpers(b *strings.Builder, file *File, arch, namespace string) {
+	if namespace == "" {
+		return
+	}
+	forms := x86LockScalarRMWHelperForms(file, arch)
+	names := make([]string, 0, len(forms))
+	for name := range forms {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		emitX86LockScalarRMWHelper(b, namespace+name, forms[name], arch)
+	}
+}
+
+func emitX86LockScalarRMWHelper(b *strings.Builder, name string, form x86LockScalarRMWForm, arch string) {
+	spec := form.spec
+	typ, word := amd64IntegerTypeForBits(spec.bits), I64
+	push, pop, carryTest := "pushfq", "popq", "btq"
+	if arch == "386" {
+		word, push, pop, carryTest = I32, "pushfl", "popl", "btl"
+	}
+	pointer := x86LockScalarPointerType(form)
+	fmt.Fprintf(b, "define internal %s @%s(%s %%memory, %s %%source, %s %%carry) noinline noredzone {\nentry:\n",
+		word, name, pointer, typ, word)
+	width := map[int]string{8: "b", 16: "w", 32: "l", 64: "q"}[spec.bits]
+	segment := ""
+	if form.destination.Kind == OpMem && form.destination.Mem.Segment != "" {
+		segment = "%" + strings.ToLower(string(form.destination.Mem.Segment)) + ":"
+	}
+	// The only native stack use is balanced within this compiler-owned helper.
+	// noinline+noredzone prevents a later inliner/red-zone allocation from
+	// invalidating it. No source SP/FP allocation or extra LAHF ISA is borrowed.
+	if spec.stem == "NOT" {
+		fmt.Fprintf(b, "  call void asm sideeffect \"lock; not%s %s$0\", \"=*m,*m,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s elementtype(%s) %%memory, %s elementtype(%s) %%memory)\n",
+			width, segment, pointer, typ, pointer, typ)
+		fmt.Fprintf(b, "  ret %s 0\n}\n\n", word)
+		return
+	}
+	opcode := "lock; " + strings.ToLower(spec.stem) + width + " "
+	if spec.unary {
+		opcode += segment + "$1"
+	} else {
+		opcode += "$2, " + segment + "$1"
+	}
+	if spec.carryInput {
+		opcode = carryTest + " $$0, $3; " + opcode
+	}
+	opcode += "; " + push + "; " + pop + " $0"
+	register := "r"
+	if spec.bits == 8 {
+		register = "q"
+	}
+	source := "%source"
+	if form.source.Kind == OpImm {
+		register, source = "i", fmt.Sprint(form.source.Imm)
+	}
+	// Keep fixed operand numbering even for unary forms. The unused source is
+	// a compile-time zero, not an invented machine input. Output flags are
+	// written after every input is consumed; indirect *m is read/write.
+	fmt.Fprintf(b, "  %%flags = call %s asm sideeffect \"%s\", \"=r,=*m,%s,r,*m,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s elementtype(%s) %%memory, %s %s, %s %%carry, %s elementtype(%s) %%memory)\n",
+		word, opcode, register, pointer, typ, typ, source, word, pointer, typ)
+	fmt.Fprintf(b, "  ret %s %%flags\n}\n\n", word)
+}
+
+func (c *amd64Ctx) lowerLockScalarRMW(op Op, ins Instr) (bool, bool, error) {
+	if !c.namedAtomicLock {
+		return false, false, nil
+	}
+	form, recognized, err := x86LockScalarRMWProperties(op, ins, c.goarch)
+	if !recognized {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if err := x86LockScalarNativeMemoryBound(form, ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	if c.lockScalarNS == "" {
+		return true, false, fmt.Errorf("%w: scalar LOCK has no compiler-owned complete bridge", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, err := c.compareExchangePointer(form.destination)
+	if err != nil {
+		return true, false, err
+	}
+	if pointerType != x86LockScalarPointerType(form) {
+		return true, false, fmt.Errorf("%w: scalar LOCK native address space changed", ErrProbeNeedsContext)
+	}
+	typ, word := amd64IntegerTypeForBits(form.spec.bits), I64
+	if c.goarch == "386" {
+		word = I32
+	}
+	source := "0"
+	if !form.spec.unary {
+		if form.source.Kind == OpImm {
+			source = fmt.Sprint(form.source.Imm)
+		} else if source, err = c.evalIntSized(form.source, typ); err != nil {
+			return true, false, err
+		}
+	}
+	carry := "0"
+	if form.spec.carryInput {
+		flag := c.loadFlag(c.flagsCFSlot)
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to %s\n", name, flag, word)
+		carry = "%" + name
+	}
+	flags := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, %s %s)\n", flags, word,
+		x86LockScalarHelperName(c.lockScalarNS, form, c.goarch), pointerType, pointer, typ, source, word, carry)
+	for _, flag := range []struct {
+		mask uint8
+		bit  int
+		slot string
+	}{
+		{x86ByteFlagCF, 0, c.flagsCFSlot},
+		{x86ByteFlagPF, 2, c.flagsPFSlot},
+		{x86ByteFlagAF, 4, c.flagsAFSlot},
+		{x86ByteFlagZF, 6, c.flagsZSlot},
+		{x86ByteFlagSF, 7, c.flagsSltSlot},
+		{x86ByteFlagOF, 11, c.flagsOFSlot},
+	} {
+		if form.spec.flagsDefined&flag.mask == 0 {
+			continue // Preserved/undefined bits are not forged into defined facts.
+		}
+		shift, value := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n", shift, word, flags, flag.bit)
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i1\n", value, word, shift)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", value, flag.slot)
+	}
+	return true, false, nil
+}
diff --git a/amd64_lock_scalar_rmw_objects_test.go b/amd64_lock_scalar_rmw_objects_test.go
new file mode 100644
index 000000000..0707b8c55
--- /dev/null
+++ b/amd64_lock_scalar_rmw_objects_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86LockScalarRMWThreeAPIsFiveTargetsNativeObjects(t *testing.T) {
+	x86LockScalarRMWNativeObjectMatrix(t, false)
+}
+
+func TestX86LockScalarRMWIndexedSegmentsThreeAPIsFiveTargetsObjects(t *testing.T) {
+	x86LockScalarRMWNativeObjectMatrix(t, true)
+}
+
+func x86LockScalarRMWNativeObjectMatrix(t *testing.T, indexed bool) {
+	t.Helper()
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 compiler and disassembler are required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		var source, declarations strings.Builder
+		declarations.WriteString("package ordering\n")
+		type expectedInstruction struct {
+			op      string
+			bits    int
+			segment x86asm.Reg
+		}
+		want := make(map[string]expectedInstruction)
+		for index, row := range x86LockScalarOracleForms(target.arch) {
+			for _, segment := range []string{"native", "FS", "GS"} {
+				memory := "1(SI)"
+				if segment != "native" {
+					memory = "1(" + segment + ")"
+					if indexed {
+						memory = "1(AX)(" + segment + "*4)"
+					}
+				}
+				body := strings.Replace(row.text, "1(SI)", memory, 1)
+				name := fmt.Sprintf("rmw%d_%s", index, strings.ToLower(segment))
+				original := strings.Replace(x86NamedLockOracleSource(target.arch,
+					"CMPL AX,AX\n\tLOCK\n\t"+body), "·locked", "·"+name, 1)
+				x86LockScalarOriginalInstruction(t, target.arch, original)
+				source.WriteString(original)
+				fmt.Fprintf(&declarations, "func %s(p *[16]byte)\n", name)
+
+				bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+				stem := strings.ToLower(row.op[:len(row.op)-1])
+				helper := "__plan9asm_lock_rmw_0_" + target.arch + "_" +
+					stem + fmt.Sprint(bits) + "_" + strings.ToLower(segment)
+				if strings.Contains(row.text, "$1") {
+					helper += "_imm_0000000000000001"
+				}
+				physicalSegment := x86asm.Reg(0)
+				if segment == "FS" {
+					physicalSegment = x86asm.FS
+				} else if segment == "GS" {
+					physicalSegment = x86asm.GS
+				}
+				want[helper] = expectedInstruction{strings.ToUpper(stem), bits, physicalSegment}
+			}
+		}
+
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(),
+					declarations.String(), target.arch, target.triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if strings.Contains(ir, "atomicrmw ") || strings.Contains(ir, " = cmpxchg ") {
+					t.Fatal("source RMW acquired a guessed LLVM atomic alignment or software replacement")
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(level, func(t *testing.T) {
+						dir := t.TempDir()
+						input, object := filepath.Join(dir, "lock.ll"), filepath.Join(dir, "lock.o")
+						if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+							t.Fatal(err)
+						}
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level,
+							"-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+						listing := x86FloatCompareCaptureCommand(t,
+							exec.Command(disassembler, "--disassemble", object))
+						sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <([^>]+)>:\n`).FindAllSubmatchIndex(listing, -1)
+						seen := make(map[string]bool)
+						for index, section := range sections {
+							name := string(listing[section[2]:section[3]])
+							if strings.HasPrefix(name, "___plan9asm_lock_rmw_") {
+								name = strings.TrimPrefix(name, "_") // Mach-O/COFF leading underscore.
+							}
+							expected, known := want[name]
+							if !known {
+								continue
+							}
+							if seen[name] {
+								t.Fatal("duplicate compiler helper", name)
+							}
+							end := len(listing)
+							if index+1 < len(sections) {
+								end = sections[index+1][0]
+							}
+							var code []byte
+							for _, line := range strings.Split(string(listing[section[1]:end]), "\n") {
+								fields := strings.Fields(line)
+								if len(fields) < 2 || !strings.HasSuffix(fields[0], ":") {
+									continue
+								}
+								for _, field := range fields[1:] {
+									if len(field) != 2 {
+										break
+									}
+									value, err := hex.DecodeString(field)
+									if err != nil {
+										break
+									}
+									code = append(code, value[0])
+								}
+							}
+							mode := 64
+							if target.arch == "386" {
+								mode = 32
+							}
+							count := 0
+							for len(code) != 0 {
+								physical, err := x86asm.Decode(code, mode)
+								if err != nil || physical.Len <= 0 || physical.Len > len(code) {
+									t.Fatalf("incomplete physical helper %s: %x %v", name, code, err)
+								}
+								machine := code[:physical.Len]
+								code = code[physical.Len:]
+								locked, segmentPrefixes := false, 0
+								for _, prefix := range physical.Prefix {
+									if byte(prefix) == 0xf0 {
+										locked = true
+									}
+									if byte(prefix) == 0x64 || byte(prefix) == 0x65 {
+										segmentPrefixes++
+									}
+								}
+								if !locked {
+									continue
+								}
+								count++
+								var memory x86asm.Mem
+								foundMemory := false
+								for _, argument := range physical.Args {
+									if value, ok := argument.(x86asm.Mem); ok {
+										memory, foundMemory = value, true
+									}
+								}
+								wantSegments := 0
+								if expected.segment != 0 {
+									wantSegments = 1
+								}
+								if physical.Op.String() != expected.op || !foundMemory ||
+									physical.MemBytes*8 != expected.bits ||
+									memory.Segment != expected.segment || segmentPrefixes != wantSegments ||
+									physical.AddrSize != mode {
+									t.Fatalf("native width/segment/address/prefix identity changed: %s bytes=%x decoded=%s memBytes=%d segmentPrefixes=%d expected=%+v",
+										name, machine, x86asm.GoSyntax(physical, 0, nil), physical.MemBytes, segmentPrefixes, expected)
+								}
+							}
+							if count != 1 {
+								t.Fatalf("%s helper has %d complete native RMW instructions", name, count)
+							}
+							seen[name] = true
+						}
+						if len(seen) != len(want) {
+							t.Fatalf("emitted %d/%d complete native helpers\n%s", len(seen), len(want), listing)
+						}
+						t.Logf("actual %s object independently decoded %d whole native RMW helpers", target.triple, len(seen))
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lock_scalar_rmw_runtime_test.go b/amd64_lock_scalar_rmw_runtime_test.go
new file mode 100644
index 000000000..8d346dafb
--- /dev/null
+++ b/amd64_lock_scalar_rmw_runtime_test.go
@@ -0,0 +1,476 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86LockScalarRuntimeCase struct {
+	name, stem, body string
+	width            int
+	immediate        bool
+	literal          uint64
+}
+
+func x86ScalarRuntimeStatusMask(stem string) int {
+	switch stem {
+	case "BTC", "BTR", "BTS":
+		return 0x41 // CF is defined; ZF is preserved. Other status bits are undefined.
+	case "AND", "OR", "XOR":
+		return 0x8c5 // AF is undefined, not a numerical zero.
+	default:
+		return 0x8d5
+	}
+}
+
+func x86LockScalarRuntimeCases(arch string) []x86LockScalarRuntimeCase {
+	var rows []x86LockScalarRuntimeCase
+	for _, form := range x86LockScalarOracleForms(arch) {
+		width := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[form.op[len(form.op)-1]]
+		stem := form.op[:len(form.op)-1]
+		immediate := strings.Contains(form.text, "$1")
+		rows = append(rows, x86LockScalarRuntimeCase{
+			name: fmt.Sprintf("sample%d", len(rows)), stem: stem,
+			body:  strings.ReplaceAll(strings.Replace(form.text, "1(SI)", "(SI)", 1), "CL,", "CX,"),
+			width: width, immediate: immediate, literal: 1,
+		})
+		if !immediate || stem == "BTC" || stem == "BTR" || stem == "BTS" {
+			continue
+		}
+		// Independent Yi32 boundaries and equal-bit-pattern spellings. Native Q
+		// sign-extends imm32; the smaller widths retain their low encoded bits.
+		for _, literal := range []uint64{0x7fffffff, 0x80000000, 0xffffffff} {
+			rows = append(rows, x86LockScalarRuntimeCase{
+				name: fmt.Sprintf("sample%d", len(rows)), stem: stem,
+				body: strings.Replace(strings.Replace(form.text, "1(SI)", "(SI)", 1),
+					"$1,", fmt.Sprintf("$%d,", literal), 1),
+				width: width, immediate: true, literal: literal,
+			})
+		}
+	}
+	return rows
+}
+
+func x86LockScalarRuntimeFixture(arch string) (declarations, assembly, driver, reference string, count int) {
+	rows := x86LockScalarRuntimeCases(arch)
+	word, suffix, slot := "uint64", "Q", 8
+	if arch == "386" {
+		word, suffix, slot = "uint32", "L", 4
+	}
+	var decl, source, goRows, prototypes, cRows strings.Builder
+	decl.WriteString("package main\n")
+	for _, row := range rows {
+		fmt.Fprintf(&decl, "func %s(memory *[128]byte, output *[8]uint64, offset %s, value %s, seed %s)\n",
+			row.name, word, word, word)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", row.name, slot*5)
+		fmt.Fprintf(&source, "MOV%s memory+0(FP),SI\nMOV%s output+%d(FP),DI\nMOV%s offset+%d(FP),AX\n",
+			suffix, suffix, slot, suffix, slot*2)
+		fmt.Fprintf(&source, "ADD%s AX,SI\nMOV%s value+%d(FP),CX\nMOV%s seed+%d(FP),DX\n",
+			suffix, suffix, slot*3, suffix, slot*4)
+		fmt.Fprintf(&source, "PUSH%s DX\nPOPF%s\nSTMXCSR 24(DI)\nLOCK\n%s\nPUSHF%s\nPOP%s AX\n",
+			suffix, suffix, row.body, suffix, suffix)
+		// Refine the original saved word before observing it as numerical
+		// output. A mask in the C/Go reference cannot define missing source bits.
+		fmt.Fprintf(&source, "AND%s $%d,AX\nMOV%s AX,0(DI)\nMOV%s CX,8(DI)\nMOV%s DX,16(DI)\nSTMXCSR 32(DI)\nRET\n",
+			suffix, x86ScalarRuntimeStatusMask(row.stem), suffix, suffix, suffix)
+		fmt.Fprintf(&goRows, "{%s,%q,%d,%t,%d},\n", row.name, row.stem, row.width, row.immediate, row.literal)
+		cWord := "uint64_t"
+		if arch == "386" {
+			cWord = "uint32_t"
+		}
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t *, uint64_t *, %s, %s, %s);\n", row.name, cWord, cWord, cWord)
+		imm := 0
+		if row.immediate {
+			imm = 1
+		}
+		fmt.Fprintf(&cRows, "{%s,%q,%d,%d,UINT64_C(%d)},\n", row.name, row.stem, row.width, imm, row.literal)
+	}
+	driver = strings.NewReplacer("@WORD@", word, "@ROWS@", goRows.String()).Replace(x86LockScalarOriginalReference)
+	cWord := "uint64_t"
+	if arch == "386" {
+		cWord = "uint32_t"
+	}
+	reference = strings.NewReplacer("@WORD@", cWord, "@PROTOTYPES@", prototypes.String(), "@ROWS@", cRows.String()).Replace(x86LockScalarIndependentC)
+	return decl.String(), source.String(), driver, reference, len(rows)
+}
+
+func TestCrossLinuxRuntimeMatrixX86LockScalarRMWOriginalAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, assembly, driver, reference, count := x86LockScalarRuntimeFixture("amd64")
+	if count != 174 {
+		t.Fatal("independent complete runtime kernel denominator changed", count)
+	}
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), runtime.GOOS, "amd64", declarations, assembly, driver)
+	want := fmt.Sprintf("lock observations %d\n", count*292*2*8)
+	if output := execution.run(t, original); string(output) != want {
+		t.Fatalf("actual original Go initialized-memory/defined-flags/canary oracle: %q, want %q", output, want)
+	}
+	t.Logf("actual original Go: %d kernels / %d complete initialized-memory observations", count, count*292*2*8)
+	ir := x86NarrowOracleIR(t, assembly, declarations, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			if output := execution.compileAndRunLLVM(t, "lock-rmw", ir, reference, level); string(output) != want {
+				t.Fatalf("independent integer arithmetic/bit-string/memory/flags/canary oracle: %q", output)
+			}
+			t.Logf("%d complete observations: all initialized memory bytes, defined/preserved status bits, source registers, MXCSR and canaries", count*292*2*8)
+		})
+	}
+}
+
+func TestX86LockScalarRMWOriginal386StaticELFCompileOnly(t *testing.T) {
+	declarations, assembly, driver, _, count := x86LockScalarRuntimeFixture("386")
+	if count != 129 {
+		t.Fatal("complete mode-32 runtime kernel denominator changed", count)
+	}
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386", declarations, assembly, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual original Go %d-kernel static IA32 ELF: %d bytes SHA256=%x; execution is a distinct required native axis",
+		count, sealed.size, sealed.hash)
+}
+
+const x86LockScalarOriginalReference = `package main
+
+import (
+	"fmt"
+	"math/bits"
+	"runtime"
+)
+
+type word = @WORD@
+type kernel struct {
+	fn func(*[128]byte, *[8]uint64, word, word, word)
+	op string
+	width int
+	immediate bool
+	literal uint64
+}
+var kernels = []kernel{
+	@ROWS@
+}
+
+func load(p *[128]byte, offset, width int) uint64 {
+	var value uint64
+	for i := 0; i < width/8; i++ {
+		value |= uint64(p[offset+i]) << (8*i)
+	}
+	return value
+}
+
+func store(p *[128]byte, offset, width int, value uint64) {
+	for i := 0; i < width/8; i++ {
+		p[offset+i] = byte(value >> (8*i))
+	}
+}
+
+func reference(k kernel, memory *[128]byte, offset int, b, seed uint64) (uint64, uint64) {
+	mask := ^uint64(0)
+	if k.width < 64 {
+		mask = (uint64(1) << k.width) - 1
+	}
+	if k.immediate {
+		b = uint64(int64(int32(k.literal)))
+	}
+	b &= mask
+	if k.op == "BTC" || k.op == "BTR" || k.op == "BTS" {
+		index := int64(b)
+		if k.width == 16 {
+			index = int64(int16(b))
+		} else if k.width == 32 {
+			index = int64(int32(b))
+		}
+		if k.immediate {
+			index = int64(k.literal % uint64(k.width))
+		}
+		quotient, bit := index/int64(k.width), index%int64(k.width)
+		if bit < 0 {
+			quotient--
+			bit += int64(k.width)
+		}
+		offset += int(quotient) * (k.width / 8)
+		a := load(memory, offset, k.width)
+		cf := (a >> uint(bit)) & 1
+		switch k.op {
+		case "BTC":
+			a ^= uint64(1) << uint(bit)
+		case "BTR":
+			a &^= uint64(1) << uint(bit)
+		case "BTS":
+			a |= uint64(1) << uint(bit)
+		}
+		store(memory, offset, k.width, a)
+		return cf | seed&64, 65 // Other status bits are architecturally undefined.
+	}
+	a := load(memory, offset, k.width)
+	if k.op == "NOT" {
+		store(memory, offset, k.width, ^a)
+		return seed & 0x8d5, 0x8d5
+	}
+	if k.op == "AND" || k.op == "OR" || k.op == "XOR" {
+		switch k.op {
+		case "AND":
+			a &= b
+		case "OR":
+			a |= b
+		case "XOR":
+			a ^= b
+		}
+		a &= mask
+		store(memory, offset, k.width, a)
+		flags := uint64(0)
+		if bits.OnesCount8(uint8(a))%2 == 0 { flags |= 4 }
+		if a == 0 { flags |= 64 }
+		if a>>(k.width-1) != 0 { flags |= 128 }
+		return flags, 0x8c5 // AF is undefined, not preserved or forced to zero.
+	}
+	carry := uint64(0)
+	if k.op == "ADC" || k.op == "SBB" {
+		carry = seed & 1
+	}
+	add := k.op == "ADD" || k.op == "ADC" || k.op == "INC"
+	if k.op == "INC" || k.op == "DEC" { b = 1 }
+	if k.op == "NEG" { b, a = a, 0 }
+	result, cf := bits.Sub64(a, b, carry)
+	af := (a & 15) < (b & 15) + carry
+	if add {
+		result, cf = bits.Add64(a, b, carry)
+		if k.width < 64 && result > mask { cf = 1 }
+		af = (a & 15) + (b & 15) + carry > 15
+	}
+	result &= mask
+	sign := uint64(1) << (k.width - 1)
+	overflow := (a^b)&(a^result)&sign != 0
+	if add { overflow = ^(a^b)&(a^result)&sign != 0 }
+	if k.op == "INC" || k.op == "DEC" { cf = seed & 1 }
+	flags := cf
+	if bits.OnesCount8(uint8(result))%2 == 0 { flags |= 4 }
+	if af { flags |= 16 }
+	if result == 0 { flags |= 64 }
+	if result&sign != 0 { flags |= 128 }
+	if overflow { flags |= 2048 }
+	store(memory, offset, k.width, result)
+	return flags, 0x8d5
+}
+
+func main() {
+	runtime.LockOSThread()
+	edges := []uint64{0,1,15,16,17,127,128,255,256,32767,32768,65535,
+		0x7fffffff,0x80000000,0xffffffff,0x7fffffffffffffff,0x8000000000000000,^uint64(0)}
+	const sentinel = uint64(0xa7a7a7a7a7a7a7a7)
+	observations := 0
+	var memory, expected [128]byte
+	var out [8]uint64
+	for _, k := range kernels {
+		for sample := 0; sample < 292; sample++ {
+			a, b := uint64(sample/16), uint64(sample%16)
+			if sample >= 256 {
+				a = edges[(sample-256)/2]
+				b = edges[((sample-256)/2 + 1 + 6*(sample%2))%len(edges)]
+			}
+			if (k.op == "BTC" || k.op == "BTR" || k.op == "BTS") && !k.immediate {
+				index := []int{-2*k.width-1,-k.width,-1,0,1,k.width-1,k.width,k.width+1,2*k.width}
+				b = uint64(int64(index[sample%len(index)]))
+			}
+			b = uint64(word(b))
+			for _, seed := range []uint64{0x8c7, 0x12} {
+				for unaligned := 0; unaligned < 8; unaligned++ {
+					for i := range memory { memory[i] = byte(i*73+19) ^ byte(sample*29) }
+					offset := 64 + unaligned
+					store(&memory, offset, k.width, a)
+					expected = memory
+					for i := range out { out[i] = sentinel }
+					flags, valid := reference(k, &expected, offset, b, seed)
+					k.fn(&memory, &out, word(offset), word(b), word(seed))
+					wordMask := uint64(^word(0))
+					if memory != expected || out[0]&valid != flags ||
+						out[1]&wordMask != b || out[2]&wordMask != seed ||
+						uint32(out[3]) != uint32(out[4]) {
+						panic(fmt.Sprintf("%s/%d imm=%t literal=%x sample=%d unaligned=%d b=%x seed=%x flags=%x/%x mask=%x out=%x",
+							k.op,k.width,k.immediate,k.literal,sample,unaligned,b,seed,out[0],flags,valid,out))
+					}
+					for i := 0; i < 3; i++ {
+						if out[i]&^wordMask != sentinel&^wordMask { panic("upper output canary") }
+					}
+					if out[3]>>32 != sentinel>>32 || out[4]>>32 != sentinel>>32 ||
+						out[5] != sentinel || out[6] != sentinel || out[7] != sentinel {
+						panic("output extent canary")
+					}
+					observations++
+				}
+			}
+		}
+	}
+	fmt.Printf("lock observations %d\n", observations)
+}
+`
+
+// Shared independent arithmetic only. Each execution driver separately owns
+// its memory, FLAGS and platform-specific observations.
+const x86ScalarMemoryIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#if defined(__i386__)
+// The largest IA32 operation is 32 bits; 64-bit intermediates close its carry
+// and signed-overflow bounds without relying on unsupported int128 on i386.
+typedef uint64_t wide_unsigned;
+typedef int64_t wide_signed;
+#else
+typedef __uint128_t wide_unsigned;
+typedef __int128 wide_signed;
+#endif
+
+@PROTOTYPES@
+typedef @WORD@ word;
+typedef void (*function)(uint8_t *, uint64_t *, word, word, word);
+struct kernel {
+	function fn;
+	const char *op;
+	unsigned width, immediate;
+	uint64_t literal;
+};
+static const struct kernel kernels[] = {
+	@ROWS@
+};
+
+static uint64_t load(const uint8_t *memory, int offset, unsigned width) {
+	uint64_t value = 0;
+	for (unsigned i = 0; i < width / 8; i++) {
+		value |= (uint64_t)memory[offset + i] << (8 * i);
+	}
+	return value;
+}
+static void store(uint8_t *memory, int offset, unsigned width, uint64_t value) {
+	for (unsigned i = 0; i < width / 8; i++) {
+		memory[offset + i] = value >> (8 * i);
+	}
+}
+static uint64_t reference(const struct kernel *k, uint8_t *memory,
+		int offset, uint64_t b, uint64_t seed, uint64_t *valid) {
+	uint64_t mask = k->width == 64 ? UINT64_MAX : (UINT64_C(1) << k->width) - 1;
+	if (k->immediate) {
+		b = (uint64_t)(int64_t)(int32_t)k->literal;
+	}
+	b &= mask;
+	if (!strcmp(k->op, "BTC") || !strcmp(k->op, "BTR") || !strcmp(k->op, "BTS")) {
+		int64_t index = (int64_t)b;
+		if (k->width == 16) { index = (int16_t)b; }
+		if (k->width == 32) { index = (int32_t)b; }
+		if (k->immediate) { index = k->literal % k->width; }
+		int64_t quotient = index / (int64_t)k->width;
+		int64_t bit = index % (int64_t)k->width;
+		if (bit < 0) {
+			quotient--;
+			bit += k->width;
+		}
+		offset += quotient * (k->width / 8);
+		uint64_t a = load(memory, offset, k->width), cf = (a >> bit) & 1;
+		uint64_t selected = UINT64_C(1) << bit;
+		if (!strcmp(k->op, "BTC")) { a ^= selected; }
+		if (!strcmp(k->op, "BTR")) { a &= ~selected; }
+		if (!strcmp(k->op, "BTS")) { a |= selected; }
+		store(memory, offset, k->width, a);
+		*valid = 65;
+		return cf | (seed & 64);
+	}
+	uint64_t a = load(memory, offset, k->width), result;
+	*valid = 0x8d5;
+	if (!strcmp(k->op, "NOT")) {
+		store(memory, offset, k->width, ~a);
+		return seed & *valid;
+	}
+	unsigned cf = 0, af = 0, of = 0;
+	if (!strcmp(k->op, "AND") || !strcmp(k->op, "OR") || !strcmp(k->op, "XOR")) {
+		result = !strcmp(k->op, "AND") ? a & b : !strcmp(k->op, "OR") ? a | b : a ^ b;
+		*valid = 0x8c5;
+	} else {
+		unsigned carry = !strcmp(k->op, "ADC") || !strcmp(k->op, "SBB") ? seed & 1 : 0;
+		unsigned add = !strcmp(k->op, "ADD") || !strcmp(k->op, "ADC") || !strcmp(k->op, "INC");
+		if (!strcmp(k->op, "INC") || !strcmp(k->op, "DEC")) { b = 1; }
+		if (!strcmp(k->op, "NEG")) { b = a; a = 0; }
+		wide_unsigned wide = add ? (wide_unsigned)a + b + carry : (wide_unsigned)a - b - carry;
+		result = wide & mask;
+		cf = add ? wide > mask : (wide_unsigned)a < (wide_unsigned)b + carry;
+		af = add ? (a & 15) + (b & 15) + carry > 15 : (a & 15) < (b & 15) + carry;
+		wide_signed sign = (wide_signed)1 << (k->width - 1);
+		wide_signed sa = (a & (uint64_t)sign) ? (wide_signed)a - 2 * sign : a;
+		wide_signed sb = (b & (uint64_t)sign) ? (wide_signed)b - 2 * sign : b;
+		wide_signed signed_wide = add ? sa + sb + carry : sa - sb - carry;
+		of = signed_wide < -sign || signed_wide >= sign;
+		if (!strcmp(k->op, "INC") || !strcmp(k->op, "DEC")) { cf = seed & 1; }
+	}
+	result &= mask;
+	unsigned ones = 0;
+	for (unsigned bit = 0; bit < 8; bit++) { ones += (result >> bit) & 1; }
+	uint64_t flags = cf | ((ones % 2 == 0) << 2) | (af << 4) |
+		((result == 0) << 6) | ((result >> (k->width - 1)) << 7) | (of << 11);
+	store(memory, offset, k->width, result);
+	return flags;
+}
+
+`
+
+const x86LockScalarIndependentC = x86ScalarMemoryIndependentC + `int main(void) {
+	static const uint64_t edges[] = {0,1,15,16,17,127,128,255,256,32767,32768,65535,
+		0x7fffffff,0x80000000,0xffffffff,0x7fffffffffffffff,0x8000000000000000,UINT64_MAX};
+	const uint64_t sentinel = UINT64_C(0xa7a7a7a7a7a7a7a7);
+	unsigned observations = 0;
+	for (unsigned kernel = 0; kernel < sizeof(kernels) / sizeof(kernels[0]); kernel++) {
+		const struct kernel *k = &kernels[kernel];
+		for (unsigned sample = 0; sample < 292; sample++) {
+			uint64_t a = sample / 16, b = sample % 16;
+			if (sample >= 256) {
+				a = edges[(sample - 256) / 2];
+				b = edges[((sample - 256) / 2 + 1 + 6 * (sample % 2)) % 18];
+			}
+			if ((!strcmp(k->op, "BTC") || !strcmp(k->op, "BTR") || !strcmp(k->op, "BTS")) && !k->immediate) {
+				const int index[] = {-2*(int)k->width-1,-(int)k->width,-1,0,1,
+					(int)k->width-1,(int)k->width,(int)k->width+1,2*(int)k->width};
+				b = (uint64_t)(int64_t)index[sample % 9];
+			}
+			b = (word)b;
+			for (unsigned s = 0; s < 2; s++) {
+				uint64_t seed = s ? 0x12 : 0x8c7;
+				for (unsigned unaligned = 0; unaligned < 8; unaligned++) {
+					uint8_t memory[128], expected[128];
+					uint64_t out[8];
+					for (unsigned i = 0; i < 128; i++) { memory[i] = (i*73+19) ^ (sample*29); }
+					int offset = 64 + unaligned;
+					store(memory, offset, k->width, a);
+					memcpy(expected, memory, 128);
+					for (unsigned i = 0; i < 8; i++) { out[i] = sentinel; }
+					uint64_t valid, flags = reference(k, expected, offset, b, seed, &valid);
+					unsigned before_csr, after_csr;
+					__asm__ volatile("stmxcsr %0" : "=m"(before_csr));
+					k->fn(memory, out, offset, b, seed);
+					__asm__ volatile("stmxcsr %0" : "=m"(after_csr));
+					uint64_t word_mask = (word)~(word)0;
+					if (memcmp(memory, expected, 128) || (out[0] & valid) != flags ||
+							(out[1] & word_mask) != b || (out[2] & word_mask) != seed ||
+							(uint32_t)out[3] != before_csr || (uint32_t)out[4] != before_csr ||
+							after_csr != before_csr) {
+						fprintf(stderr, "%s/%u imm=%u literal=%llx sample=%u unaligned=%u b=%llx seed=%llx flags=%llx/%llx mask=%llx\n",
+							k->op,k->width,k->immediate,(unsigned long long)k->literal,sample,unaligned,
+							(unsigned long long)b,(unsigned long long)seed,(unsigned long long)out[0],
+							(unsigned long long)flags,(unsigned long long)valid);
+						return 1;
+					}
+					for (unsigned i = 0; i < 3; i++) {
+						if ((out[i] & ~word_mask) != (sentinel & ~word_mask)) { return 2; }
+					}
+					if (out[3] >> 32 != sentinel >> 32 || out[4] >> 32 != sentinel >> 32 ||
+							out[5] != sentinel || out[6] != sentinel || out[7] != sentinel) { return 3; }
+					observations++;
+				}
+			}
+		}
+	}
+	printf("lock observations %u\n", observations);
+	return 0;
+}
+`
diff --git a/amd64_lock_scalar_rmw_sdk_test.go b/amd64_lock_scalar_rmw_sdk_test.go
new file mode 100644
index 000000000..bdbaa70f2
--- /dev/null
+++ b/amd64_lock_scalar_rmw_sdk_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWActualSDKOr8(t *testing.T) {
+	var data []byte
+	var sourcePath string
+	for _, relative := range []string{
+		"src/internal/runtime/atomic/atomic_amd64.s",
+		"src/runtime/internal/atomic/atomic_amd64.s",
+	} {
+		path := filepath.Join(runtime.GOROOT(), filepath.FromSlash(relative))
+		actual, err := os.ReadFile(path)
+		if os.IsNotExist(err) {
+			continue // Actual SDK source layout, not an encoder-version guess.
+		}
+		if err != nil || sourcePath != "" {
+			t.Fatal("actual SDK atomic source is missing or ambiguous", err)
+		}
+		sourcePath, data = path, actual
+	}
+	start := strings.Index(string(data), "TEXT ·Or8(SB)")
+	if sourcePath == "" || start < 0 {
+		t.Fatal("actual SDK lacks the discovering Or8 source")
+	}
+	end := strings.Index(string(data[start:]), "\nTEXT ")
+	if end < 0 {
+		t.Fatal("SDK Or8 has no complete next-TEXT boundary")
+	}
+	body := string(data[start:start+end]) + "\n"
+	header, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "pkg/include/textflag.h"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The original body is unchanged. The actual stock header, not a manual
+	// NOSPLIT substitution, supplies the same Go assembler definitions.
+	original := string(header) + "\n" + body
+	machine := x86LockScalarOriginalInstruction(t, "amd64", original)
+	t.Logf("actual %s Or8 source SHA256=%x header SHA256=%x whole native instruction=%x",
+		runtime.Version(), sha256.Sum256(data), sha256.Sum256(header), machine)
+	expanded, err := PreprocessAssemblySource(original, AssemblyPreprocessOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required for the actual SDK sample")
+	}
+	for _, target := range x86OrderingHintTargets {
+		if target.arch != "amd64" {
+			continue // This original SDK file is explicitly AMD64.
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, expanded,
+					"package ordering\nfunc Or8(ptr *uint8, val uint8)\n", "amd64", target.triple)
+				if err != nil || !strings.Contains(ir, "lock; orb") {
+					t.Fatal("actual SDK Or8 retains its whole-source atomic effect", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "or8.ll", fmt.Sprintf("or8-%s.o", api), ir)
+			})
+		}
+	}
+	if after, err := os.ReadFile(sourcePath); err != nil || sha256.Sum256(after) != sha256.Sum256(data) {
+		t.Fatal("actual SDK source changed during sample proof", err)
+	}
+}
diff --git a/amd64_lock_scalar_rmw_symbol_test.go b/amd64_lock_scalar_rmw_symbol_test.go
new file mode 100644
index 000000000..31b5cf66d
--- /dev/null
+++ b/amd64_lock_scalar_rmw_symbol_test.go
@@ -0,0 +1,210 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LockScalarRMWAddressLiteralIsNotMemory(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LockScalarOracleForms(arch) {
+			body := strings.Replace(row.text, "1(SI)", "$·cell(SB)", 1)
+			t.Run(arch+"/"+body, func(t *testing.T) {
+				source := "GLOBL ·cell(SB),8,$16\n" +
+					x86NamedLockOracleSource(arch, "CLC\nLOCK\n"+body)
+				// An emitted address literal is Go TYPE_ADDR, not writable
+				// memory. This is actual assembler rejection, not execution.
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[len(file.Funcs[0].Instrs)-2]
+				form, recognized, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if !recognized || err == nil {
+					t.Error("typed memory grammar accepted an address literal", form, err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source,
+						"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+					if err == nil || ir != "" {
+						t.Error("address literal became a locked memory object", api, err)
+					}
+				}
+				ordinary := strings.Replace(source, "$·cell(SB)", "·cell(SB)", 1)
+				x86LockScalarOriginalInstruction(t, arch, ordinary)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86OrderingHintTranslateAPI(t, api, ordinary,
+						"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+					// This exact original source declares RODATA. Go format
+					// acceptance does not make its storage writable.
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Error("original readonly SB source acquired a write permission", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticBitStringLockedAndVolatileObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, locked := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/locked=%t", target.triple, locked), func(t *testing.T) {
+				var source, declarations strings.Builder
+				source.WriteString("DATA ·cell+0(SB)/8,$0x1234\nDATA ·cell+8(SB)/8,$0x5678\nGLOBL ·cell(SB),16,$16\n")
+				declarations.WriteString("package ordering\n")
+				var names []string
+				for _, row := range x86LockScalarOracleForms(target.arch) {
+					if !strings.HasPrefix(row.op, "BT") {
+						continue
+					}
+					name := fmt.Sprintf("staticBit%d", len(names))
+					names = append(names, name)
+					body := strings.Replace(row.text, "1(SI)", "·cell(SB)", 1)
+					if locked {
+						body = "LOCK\n" + body
+					}
+					original := x86NamedLockOracleSource(target.arch, "CLC\n"+body)
+					original = strings.Replace(original, "·locked", "·"+name, 1)
+					// The register-indexed rows consume an actual unbounded Go
+					// numerical input. No constant or fixed-span range is assumed.
+					if target.arch == "amd64" {
+						original = strings.Replace(original, "$0-8", "$0-16", 1)
+						original = strings.Replace(original, "MOVL $4,CX", "MOVQ index+8(FP),CX", 1)
+						fmt.Fprintf(&declarations, "func %s(p *[16]byte, index uint64)\n", name)
+					} else {
+						original = strings.Replace(original, "$0-4", "$0-8", 1)
+						original = strings.Replace(original, "MOVL $4,CX", "MOVL index+4(FP),CX", 1)
+						fmt.Fprintf(&declarations, "func %s(p *[16]byte, index uint32)\n", name)
+					}
+					source.WriteString(original)
+				}
+				want := 18
+				if target.arch == "386" {
+					want = 12
+				}
+				if len(names) != want || len(names) > 32 {
+					t.Fatal("complete original bit-string object batch changed", len(names), want)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+						if err != nil {
+							t.Fatal("complete native static bit-string source", err)
+						}
+						if !locked {
+							for _, name := range names {
+								body := x86StringMemoryFunction(t, ir, name)
+								if !strings.Contains(body, "load volatile") || !strings.Contains(body, "store volatile") {
+									t.Fatal("unlocked bit-string lost an actual native memory effect", name)
+								}
+							}
+						}
+						for _, level := range []int{0, 2} {
+							text := ir
+							if level == 2 {
+								text = x86MulDivRoundOptimize(t, ir)
+							}
+							x86PackedStringCompileObject(t, llc, target.triple, text, fmt.Sprintf("-O%d", level))
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+// Keep the original readonly/address-literal source above. These are new
+// positive TDD controls, not evidence that the current consumer supports them.
+// Partitioning preserves all original forms, including signed dynamic indexes.
+func TestX86LockScalarRMWMutableSBOriginalForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		forms := x86LockScalarOracleForms(arch)
+		groups := make(map[string][]x86LockScalarOracleForm)
+		for _, row := range forms {
+			partition := "scalar"
+			if strings.HasPrefix(row.op, "BTC") || strings.HasPrefix(row.op, "BTR") || strings.HasPrefix(row.op, "BTS") {
+				operands := strings.SplitN(row.text, " ", 2)
+				if len(operands) != 2 {
+					t.Fatal("original bit-string row lost its operands", row.text)
+				}
+				index := strings.SplitN(operands[1], ",", 2)[0]
+				switch index {
+				case "$1":
+					partition = "bit-immediate"
+				case "CX":
+					partition = "bit-register"
+				default:
+					t.Fatal("original bit-string index inventory changed", row.text)
+				}
+			}
+			groups[partition] = append(groups[partition], row)
+		}
+		wantAll, wantScalar, wantBits := 90, 72, 9
+		if arch == "386" {
+			wantAll, wantScalar, wantBits = 66, 54, 6
+		}
+		if len(forms) != wantAll || len(groups["scalar"]) != wantScalar ||
+			len(groups["bit-immediate"]) != wantBits || len(groups["bit-register"]) != wantBits {
+			t.Fatal("complete original scalar/bit-string partition changed", arch,
+				len(forms), len(groups["scalar"]), len(groups["bit-immediate"]), len(groups["bit-register"]))
+		}
+		for _, partition := range []string{"scalar", "bit-immediate", "bit-register"} {
+			t.Run(arch+"/"+partition, func(t *testing.T) {
+				for _, row := range groups[partition] {
+					body := strings.Replace(row.text, "1(SI)", "·cell(SB)", 1)
+					if body == row.text {
+						t.Fatal("original memory operand was not replaced", row.text)
+					}
+					t.Run(body, func(t *testing.T) {
+						// DATA covers the actual complete 16-byte mutable object.
+						// This does not prove a register-indexed bit string's range.
+						source := "DATA ·cell+0(SB)/8,$0x1234\n" +
+							"DATA ·cell+8(SB)/8,$0x5678\n" +
+							"GLOBL ·cell(SB),16,$16\n" +
+							x86NamedLockOracleSource(arch, "CLC\nLOCK\n"+body)
+						listing, err := x86ScalarLiteralGoListing(t, arch, source)
+						if err != nil {
+							t.Fatal("complete mutable original Go object", err)
+						}
+						x86GPSegmentListingBytes(t, listing, []string{"locked"})
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source,
+								"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+							if err != nil {
+								t.Error("complete mutable original SB row lacks its atomic effect", api, err)
+								continue
+							}
+							// A module containing an uncalled helper is not coverage.
+							// Follow this exact public body to its actual native helper.
+							caller := x86StringMemoryFunction(t, ir, "locked")
+							const prefix = "@__plan9asm_lock_rmw_"
+							if strings.Count(caller, prefix) != 1 {
+								t.Error("mutable original SB body bypassed its complete helper", api)
+								continue
+							}
+							call := caller[strings.Index(caller, prefix)+1:]
+							end := strings.Index(call, "(")
+							if end < 0 {
+								t.Fatal("called native helper lacks its argument list", api)
+							}
+							helper := x86StringMemoryFunction(t, ir, call[:end])
+							if !strings.Contains(helper, "asm sideeffect") ||
+								!strings.Contains(helper, "lock; "+strings.ToLower(row.op)) {
+								t.Error("actually called helper lost the exact native SB effect", api)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_logical_auto_storage.go b/amd64_logical_auto_storage.go
new file mode 100644
index 000000000..202165318
--- /dev/null
+++ b/amd64_logical_auto_storage.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import "fmt"
+
+// Ordinary logical AUTO bytes use immutable entry SP plus the frame extent,
+// not addresses below the mutable physical/private SP. Private PUSH storage
+// must not overwrite them. This consumes an existing complete source proof;
+// independently bound native/caller storage keeps its own address projection.
+func (c *amd64Ctx) prepareLogicalAUTOStorage() error {
+	fn := c.fpScalarSource
+	if !c.fpScalarChecked || c.fpScalarCheckErr != nil || c.sourceStack != nil || c.fixedLocal != nil ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86BoolCalls != nil {
+		return nil
+	}
+	if _, scopedControl := x86X87ScopedControlScratchExtent(fn, c.goarch); scopedControl {
+		if c.frameSize != 0 {
+			return fmt.Errorf("%w: scoped x87 scratch lost its original zero frame", ErrProbeNeedsContext)
+		}
+		// Keep actual negative SP offsets in the existing bounded private
+		// stack object. Do not manufacture positive logical AUTO storage.
+		return nil
+	}
+	stack, err := x86ResultPrivateFlagsSource(fn, c.goarch)
+	if err != nil {
+		return err
+	}
+	c.privateFlagsStack = stack != nil
+	extent, err := x86ResultAUTOExtentWithPrivateStack(fn, c.goarch, c.privateFlagsStack)
+	if err != nil {
+		return err
+	}
+	if extent != 0 && int64(extent) != c.frameSize {
+		return fmt.Errorf("%w: logical AUTO emitter lost its original frame extent", ErrProbeNeedsContext)
+	}
+	c.logicalAUTOExtent = extent
+	return nil
+}
+
+func (c *amd64Ctx) logicalAUTOAddress(mem MemRef) (string, bool, error) {
+	if c.logicalAUTOExtent == 0 || mem.Base != SP {
+		return "", false, nil
+	}
+	if c.privateFlagsStack && mem.Off >= 0 && mem.Sym == "" && mem.OffRaw == "" &&
+		mem.Index == "" && mem.IndexExt == "" && mem.Segment == "" && mem.Scale == 0 {
+		return "", false, nil // Reaching PUSH depth, rather than the immutable AUTO base, owns this access.
+	}
+	if _, static := x86SBMemoryAddressRole(Operand{Kind: OpMem, Mem: mem}, c.goarch); static {
+		return "", false, nil
+	}
+	offset, valid := x86ResultAUTOOffset(Operand{Kind: OpMem, Mem: mem}, 1, c.logicalAUTOExtent)
+	if !valid || c.logicalAUTOBase == "" {
+		return "", true, fmt.Errorf("%w: logical AUTO address no longer matches its complete source", ErrProbeNeedsContext)
+	}
+	if offset == 0 {
+		return c.logicalAUTOBase, true, nil
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", address, c.logicalAUTOBase, offset)
+	return "%" + address, true, nil
+}
diff --git a/amd64_lower_abs_sign.go b/amd64_lower_abs_sign.go
new file mode 100644
index 000000000..04e16bbb6
--- /dev/null
+++ b/amd64_lower_abs_sign.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The complete shared grammar retains each source/data/mask role. Legacy
+// Type4 keeps its original aligned m128 instruction; VEX is unaligned and
+// EVEX E4 suppresses only inactive lanes. These access rules are distinct.
+func (c *amd64Ctx) lowerPackedAbsSign(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedAbsSignProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	if form.legacy && form.memory >= 0 {
+		return true, false, c.lowerLegacyAbsSignMemory(ins, form)
+	}
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	bits, width := form.spec.laneBits, form.byteWidth
+	first, err := c.loadX86PackedShiftLanes(ins.Args[form.first], width, bits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	result := ""
+	if form.spec.sign {
+		data, err := c.loadPackedCompareLanes(ins.Args[form.second], width, bits, false)
+		if err != nil {
+			return true, false, err
+		}
+		result = c.emitPackedSign(first, data, width, bits)
+	} else {
+		result = c.emitPackedAbs(first, width, bits)
+	}
+	lanes := width * 8 / bits
+	destination := ins.Args[form.destination]
+	if form.mask >= 0 {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			oldBytes, err := c.loadPackedCompareBytes(destination, width)
+			if err != nil {
+				return true, false, err
+			}
+			old = c.bitcastVectorBytesToIntegerLanes(width, lanes, bits, oldBytes)
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, bits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, bits, result, width)
+	if form.legacy {
+		return true, false, c.storeLegacyXViews(destination.Reg, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, width, "%"+out)
+}
+
+// Intel Type4's legacy SSE m128 alignment exception applies to all six
+// PABS[BWD]/PSIGN[BWD] names, unlike their VEX counterparts. A volatile
+// align-1 read followed by arithmetic loses that exception, and align16 is
+// merely an LLVM precondition, not a runtime check. Keep the actual opcode
+// even for a dead result. Virtual FP bytes are not original native storage.
+func (c *amd64Ctx) lowerLegacyAbsSignMemory(ins Instr, form x86PackedAbsSignForm) error {
+	source := ins.Args[form.first]
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || source.Kind == OpFP {
+		return fmt.Errorf("%w: legacy ABS/sign m128 needs its original native x86 storage and alignment", ErrProbeNeedsContext)
+	}
+	bits := form.spec.laneBits
+	mnemonic := strings.ToLower(string(ins.Op))
+	var result string
+	var err error
+	if form.spec.sign {
+		data, failure := c.loadPackedCompareLanes(ins.Args[form.second], 16, bits, false)
+		if failure != nil {
+			return failure
+		}
+		result, err = c.emitPackedBinaryNativeMemory(source, bits, data, mnemonic)
+	} else {
+		// Unary ABS has no old-destination input. Do not manufacture one just
+		// to reuse the tied binary carrier used by PSIGN and other families.
+		pointer, pointerType, _, failure := c.packedVectorMemoryPointer(source)
+		if failure != nil {
+			return failure
+		}
+		segment := ""
+		if pointerType == "ptr addrspace(256)" {
+			segment = "%gs:"
+		} else if pointerType == "ptr addrspace(257)" {
+			segment = "%fs:"
+		}
+		call, lanes := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s %s)\n",
+			call, mnemonic+" "+segment+"($1), $0", "=x,r,~{memory}", pointerType, pointer)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <%d x i%d>\n", lanes, call, 128/bits, bits)
+		result = "%" + lanes
+	}
+	if err != nil {
+		return err
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <16 x i8>\n", bytes, 128/bits, bits, result)
+	return c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+}
+
+func (c *amd64Ctx) emitPackedAbs(values string, byteWidth, laneBits int) string {
+	lanes := byteWidth * 8 / laneBits
+	negative := c.newTmp()
+	negated := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt <%d x i%d> %s, zeroinitializer\n", negative, lanes, laneBits, values)
+	// No nsw: ABS of the most negative signed value wraps to itself.
+	fmt.Fprintf(c.b, "  %%%s = sub <%d x i%d> zeroinitializer, %s\n", negated, lanes, laneBits, values)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %%%s, <%d x i%d> %s\n", result, lanes, negative, lanes, laneBits, negated, lanes, laneBits, values)
+	return "%" + result
+}
+
+func (c *amd64Ctx) emitPackedSign(control, data string, width, bits int) string {
+	lanes := width * 8 / bits
+	positive := c.newTmp()
+	negative := c.newTmp()
+	negated := c.newTmp()
+	nonpositive := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt <%d x i%d> %s, zeroinitializer\n", positive, lanes, bits, control)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt <%d x i%d> %s, zeroinitializer\n", negative, lanes, bits, control)
+	fmt.Fprintf(c.b, "  %%%s = sub <%d x i%d> zeroinitializer, %s\n", negated, lanes, bits, data)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %%%s, <%d x i%d> zeroinitializer\n", nonpositive, lanes, negative, lanes, bits, negated, lanes, bits)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %s, <%d x i%d> %%%s\n", result, lanes, positive, lanes, bits, data, lanes, bits, nonpositive)
+	return "%" + result
+}
diff --git a/amd64_lower_abs_sign_test.go b/amd64_lower_abs_sign_test.go
new file mode 100644
index 000000000..4801a8e4e
--- /dev/null
+++ b/amd64_lower_abs_sign_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedAbsSignCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses yxm_q4 for the legacy PABS*/PSIGN* rows,
+	// _yvmovddup for VPABSB/W/D, _yvexpandpd for VPABSQ, and
+	// _yvaddsubpd for the VEX-only VPSIGN* rows.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedabssignforms(SB),NOSPLIT,$0-0\n")
+			for index, suffix := range []string{"B", "W", "D"} {
+				fmt.Fprintf(&source, "\tPABS%s X0, X1\n", suffix)
+				fmt.Fprintf(&source, "\tPABS%s %d(AX), X2\n", suffix, 16*index)
+				fmt.Fprintf(&source, "\tPSIGN%s X3, X4\n", suffix)
+				fmt.Fprintf(&source, "\tPSIGN%s %d(AX), X5\n", suffix, 48+16*index)
+				fmt.Fprintf(&source, "\tVPABS%s X6, X7\n", suffix)
+				fmt.Fprintf(&source, "\tVPABS%s %d(AX), Y1\n", suffix, 96+32*index)
+				fmt.Fprintf(&source, "\tVPABS%s X20, X21\n", suffix)
+				fmt.Fprintf(&source, "\tVPABS%s X8, K1, X9\n", suffix)
+				fmt.Fprintf(&source, "\tVPABS%s.Z %d(AX), K2, Y3\n", suffix, 192+32*index)
+				fmt.Fprintf(&source, "\tVPABS%s Z4, K3, Z5\n", suffix)
+				fmt.Fprintf(&source, "\tVPSIGN%s X8, X9, X10\n", suffix)
+				fmt.Fprintf(&source, "\tVPSIGN%s %d(AX), Y11, Y12\n", suffix, 288+32*index)
+			}
+			source.WriteString(`	VPABSD.BCST 384(AX), Y11
+	VPABSD.BCST.Z 388(AX), K4, Z6
+	VPABSQ X0, X1
+	VPABSQ 400(AX), Y2
+	VPABSQ Z3, K5, Z4
+	VPABSQ.Z 464(AX), K6, Z5
+	VPABSQ.BCST 472(AX), X6
+	VPABSQ.BCST.Z 480(AX), K7, Y7
+	RET
+`)
+			physical := x86PhysicalMode32ObjectSource(t, source.String(), target.goarch)
+			ll := x86UnboundVoidScalarFormatObject(t, physical, "packedabssignforms", target.goarch, target.triple)
+			for _, want := range []string{"icmp slt <", "icmp sgt <", "sub <", "select <"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("packed abs/sign IR is missing %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-abs-sign-"+target.name+".ll", "packed-abs-sign-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedAbsSignRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PABSB Y0, X1",
+		"PABSQ X0, X1",
+		"PABSD.Z X0, X1",
+		"VPABSB X0, Y1",
+		"VPABSW Y0, X1",
+		"VPABSD Z0, Y1",
+		"VPABSQ X0, Y1",
+		"VPABSQ X0, K0, X1",
+		"VPABSB.Z X0, X1",
+		"VPABSW.BCST (AX), X1",
+		"VPABSQ.BCST X0, X1",
+		"PSIGNB Y0, X1",
+		"PSIGNQ X0, X1",
+		"VPSIGNB X0, X1",
+		"VPSIGNW Z0, Z1, Z2",
+		"VPSIGND X0, K1, X1, X2",
+		"VPSIGNB.Z X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedAbsSignRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PABSB X8, X0",
+		"PABSW X0, X8",
+		"PSIGND X8, X0",
+	} {
+		assertX86PackedAbsSignRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86PackedAbsSignRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed abs/sign tables", instruction)
+	}
+}
+
+func qualifyAMD64PackedAbsSignRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT packedabssign(SB),NOSPLIT,$0-40
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ control+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ mask+32(FP), SI
+	KMOVQ SI, K1
+
+	MOVOU (BX), X0
+	PABSB X0, X0
+	MOVOU X0, 0(AX)
+
+	MOVOU (BX), X0
+	PSIGNW (CX), X0
+	MOVOU X0, 16(AX)
+
+	VMOVDQU (DX), Y1
+	VPABSD.BCST (BX), K1, Y1
+	VMOVDQU Y1, 32(AX)
+
+	VMOVDQU (BX), Y0
+	VPSIGND (CX), Y0, Y2
+	VMOVDQU Y2, 64(AX)
+
+	VMOVDQU64 (BX), Z0
+	VPABSQ.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 96(AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: I64, Index: 4, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packedabssign": {
+				Name: "packedabssign", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+extern void packedabssign(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static uint8_t abs8(uint8_t v) { return (v & 0x80) ? (uint8_t)(0-v) : v; }
+static int16_t sign16(int16_t value, int16_t control) {
+  return control > 0 ? value : control < 0 ? (int16_t)(0-(uint16_t)value) : 0;
+}
+static int32_t sign32(int32_t value, int32_t control) {
+  return control > 0 ? value : control < 0 ? (int32_t)(0-(uint32_t)value) : 0;
+}
+static int32_t abs32(int32_t value) { return value < 0 ? (int32_t)(0-(uint32_t)value) : value; }
+static int64_t abs64(int64_t value) { return value < 0 ? (int64_t)(0-(uint64_t)value) : value; }
+int main(void) {
+  union { uint8_t b[64]; int16_t w[32]; int32_t d[16]; int64_t q[8]; } source, control, old;
+  uint8_t out[160];
+  for (int i = 0; i < 64; i++) {
+    source.b[i] = (uint8_t)(i * 29 + 0x80);
+    control.b[i] = (uint8_t)(i * 17 - 71);
+    old.b[i] = (uint8_t)(0xf0 - i);
+  }
+  control.w[0] = 1; control.w[1] = 0; control.w[2] = -1; control.w[3] = INT16_MIN;
+  control.d[0] = 1; control.d[1] = 0; control.d[2] = -1; control.d[3] = INT32_MIN;
+  memset(out, 0xcc, sizeof(out));
+  const uint64_t mask = 0xa5;
+  packedabssign(out, source.b, control.b, old.b, mask);
+  for (int i = 0; i < 16; i++) if (out[i] != abs8(source.b[i])) return 10+i;
+  const int16_t *got16 = (const int16_t *)(out+16);
+  for (int i = 0; i < 8; i++) if (got16[i] != sign16(source.w[i], control.w[i])) return 40+i;
+  const int32_t *gotAbs32 = (const int32_t *)(out+32);
+  int32_t broadcast = abs32(source.d[0]);
+  for (int i = 0; i < 8; i++) {
+    int32_t want = (mask >> i) & 1 ? broadcast : old.d[i];
+    if (gotAbs32[i] != want) return 60+i;
+  }
+  const int32_t *gotSign32 = (const int32_t *)(out+64);
+  for (int i = 0; i < 8; i++) if (gotSign32[i] != sign32(source.d[i], control.d[i])) return 80+i;
+  const int64_t *gotAbs64 = (const int64_t *)(out+96);
+  for (int i = 0; i < 8; i++) {
+    int64_t want = (mask >> i) & 1 ? abs64(source.q[i]) : 0;
+    if (gotAbs64[i] != want) return 100+i;
+  }
+  return 0;
+}
+`
+	x86OriginalFloatingRuntimeRequireCPU(t, "packed-abs-sign", clang, triple, runPrefix)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_abs_sign", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_accumulator_sign_extend.go b/amd64_lower_accumulator_sign_extend.go
new file mode 100644
index 000000000..c27ff4c66
--- /dev/null
+++ b/amd64_lower_accumulator_sign_extend.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+import "fmt"
+
+// lowerAccumulatorSignExtend implements the complete Go 1.27 ynone family
+// sharing opcodes 98/99: CBW/CWDE/CDQE extend into AX/EAX/RAX, while
+// CWD/CDQ/CQO produce the sign half in DX/EDX/RDX. None of them modify flags.
+func (c *amd64Ctx) lowerAccumulatorSignExtend(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, known, err := x86AccumulatorSignExtendProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	sourceType := amd64IntegerTypeForBits(int(spec.sourceBytes * 8))
+	targetType := amd64IntegerTypeForBits(int(spec.destinationBytes * 8))
+	value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, sourceType)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if spec.destination == AX {
+		fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", result, sourceType, value, targetType)
+	} else {
+		bits, _ := amd64IntegerTypeBits(sourceType)
+		fmt.Fprintf(c.b, "  %%%s = ashr %s %s, %d\n", result, sourceType, value, bits-1)
+	}
+	return true, false, c.storeRegSized(spec.destination, targetType, "%"+result)
+}
diff --git a/amd64_lower_accumulator_sign_extend_test.go b/amd64_lower_accumulator_sign_extend_test.go
new file mode 100644
index 000000000..2f97e7e17
--- /dev/null
+++ b/amd64_lower_accumulator_sign_extend_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86AccumulatorSignExtendCompleteFormsSource(goarch string) string {
+	ops := []string{"CBW", "CWDE", "CWD", "CDQ"}
+	if goarch == "amd64" {
+		ops = append(ops, "CDQE", "CQO")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT signextendforms(SB),$0-0\n")
+	for _, op := range ops {
+		source.WriteString("\t" + op + "\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86AccumulatorSignExtendCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86AccumulatorSignExtendCompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "signextendforms", target.goarch, target.triple)
+			for _, want := range []string{"sext i8", "sext i16", "ashr i16", "ashr i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("accumulator sign-extension lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, want := range []string{"sext i32", "ashr i64"} {
+					if !strings.Contains(ir, want) {
+						t.Fatalf("amd64 accumulator sign-extension lowering omitted %q:\n%s", want, ir)
+					}
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "accumulator-sign-extend-"+target.name+".ll", "accumulator-sign-extend-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86AccumulatorSignExtendRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "CBW AX"},
+		{goarch: "amd64", instruction: "CWDE $1"},
+		{goarch: "amd64", instruction: "CDQ AX, DX"},
+		{goarch: "amd64", instruction: "CWD.Z"},
+		{goarch: "386", instruction: "CDQE"},
+		{goarch: "386", instruction: "CQO"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ynone tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64AccumulatorSignExtendRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT signextendsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+
+	MOVQ $0x1122334455660080, AX
+	CBW
+	MOVQ AX, 0(DI)
+
+	MOVQ $0x1122334455667788, DX
+	MOVW $0x8001, AX
+	CWD
+	MOVQ DX, 8(DI)
+
+	MOVQ $0x1122334455668001, AX
+	CWDE
+	MOVQ AX, 16(DI)
+
+	MOVL $0x80000001, AX
+	MOVQ $0x1122334455667788, DX
+	CDQ
+	MOVQ DX, 24(DI)
+
+	MOVL $0x80000001, AX
+	CDQE
+	MOVQ AX, 32(DI)
+
+	MOVQ $0x8000000000000001, AX
+	CQO
+	MOVQ DX, 40(DI)
+
+	SETCS 48(DI)
+	SETOS 49(DI)
+	SETEQ 50(DI)
+	SETMI 51(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"signextendsemantics": {
+				Name: "signextendsemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void signextendsemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[56] = {0};
+  signextendsemantics(out);
+  if (load64(out+0) != UINT64_C(0x112233445566ff80)) return 10;
+  if (load64(out+8) != UINT64_C(0x112233445566ffff)) return 11;
+  if (load64(out+16) != UINT64_C(0x00000000ffff8001)) return 12;
+  if (load64(out+24) != UINT64_C(0x00000000ffffffff)) return 13;
+  if (load64(out+32) != UINT64_C(0xffffffff80000001)) return 14;
+  if (load64(out+40) != UINT64_C(0xffffffffffffffff)) return 15;
+  if (out[48] != 1 || out[49] != 1 || out[50] != 0 || out[51] != 1) return 16;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "accumulator_sign_extend_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_adc_sbb.go b/amd64_lower_adc_sbb.go
new file mode 100644
index 000000000..72105d8fb
--- /dev/null
+++ b/amd64_lower_adc_sbb.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerScalarADCSBB implements every operand row in Go 1.27's yxorb (B)
+// and yaddl (W/L/Q) tables for add-with-carry and subtract-with-borrow.
+func (c *amd64Ctx) lowerScalarADCSBB(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	add, bits, recognized := amd64ScalarADCSBBProperties(baseOp)
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && bits == 64 {
+		return true, false, fmt.Errorf("386 %s is illegal in 32-bit mode: %q", baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("%s %s expects source and destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if err := validateAMD64ScalarAddSubOperands(c.goarch, baseOp, bits, ins.Args[0], ins.Args[1], ins); err != nil {
+		return true, false, err
+	}
+
+	source, destination := ins.Args[0], ins.Args[1]
+	typ := amd64IntegerTypeForBits(bits)
+	var sourceValue string
+	if source.Kind == OpImm {
+		sourceValue = amd64ScalarAddSubImmediate(source.Imm, bits)
+	} else {
+		sourceValue, destination, err = c.evalScalarArithmeticSource(ins, typ)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	destinationValue, store, err := c.loadScalarRMWDestination(op, ins, destination, typ)
+	if err != nil {
+		return true, false, err
+	}
+
+	wideType := LLVMType(fmt.Sprintf("i%d", bits*2))
+	widen := func(value string) string {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", wide, typ, value, wideType)
+		return "%" + wide
+	}
+	wideDestination := widen(destinationValue)
+	wideSource := widen(sourceValue)
+	carry := c.loadFlag(c.flagsCFSlot)
+	wideCarryName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to %s\n", wideCarryName, carry, wideType)
+	wideCarry := "%" + wideCarryName
+
+	partial := c.newTmp()
+	wideResult := c.newTmp()
+	var carryOut string
+	if add {
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", partial, wideType, wideDestination, wideSource)
+		fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %s\n", wideResult, wideType, partial, wideCarry)
+		carryOut = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %%%s, %s\n", carryOut, wideType, wideResult, amd64UnsignedMaximum(bits))
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", partial, wideType, wideSource, wideCarry)
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, %%%s\n", wideResult, wideType, wideDestination, partial)
+		carryOut = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult %s %s, %%%s\n", carryOut, wideType, wideDestination, partial)
+	}
+
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, wideResult, typ)
+	resultValue := "%" + result
+	if err := store(resultValue); err != nil {
+		return true, false, err
+	}
+	c.setScalarADCSBBFlags(typ, add, destinationValue, sourceValue, resultValue, "%"+carryOut)
+	return true, false, nil
+}
+
+func amd64ScalarADCSBBProperties(op string) (add bool, bits int, ok bool) {
+	switch op {
+	case "ADCB":
+		return true, 8, true
+	case "ADCW":
+		return true, 16, true
+	case "ADCL":
+		return true, 32, true
+	case "ADCQ":
+		return true, 64, true
+	case "SBBB":
+		return false, 8, true
+	case "SBBW":
+		return false, 16, true
+	case "SBBL":
+		return false, 32, true
+	case "SBBQ":
+		return false, 64, true
+	default:
+		return false, 0, false
+	}
+}
+
+func amd64UnsignedMaximum(bits int) string {
+	switch bits {
+	case 8:
+		return "255"
+	case 16:
+		return "65535"
+	case 32:
+		return "4294967295"
+	case 64:
+		return "18446744073709551615"
+	default:
+		panic(fmt.Sprintf("unsupported x86 integer width %d", bits))
+	}
+}
+
+func (c *amd64Ctx) setScalarADCSBBFlags(typ LLVMType, add bool, destination, source, result, carry string) {
+	c.setAuxiliaryCarryFlag(typ, destination, source, result)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", carry, c.flagsCFSlot)
+
+	xorOperands := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorOperands, typ, destination, source)
+	overflowInput := "%" + xorOperands
+	if add {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, typ, overflowInput)
+		overflowInput = "%" + inverted
+	}
+	xorResult := c.newTmp()
+	overflowBits := c.newTmp()
+	overflow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorResult, typ, destination, result)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", overflowBits, typ, overflowInput, xorResult)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", overflow, typ, overflowBits)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", overflow, c.flagsOFSlot)
+
+	zero := c.newTmp()
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", sign, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	c.setParityFlagSized(typ, result)
+}
diff --git a/amd64_lower_adc_sbb_test.go b/amd64_lower_adc_sbb_test.go
new file mode 100644
index 000000000..19c3e5c1b
--- /dev/null
+++ b/amd64_lower_adc_sbb_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ADCSBBCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT adcsbbforms(SB),NOSPLIT,$32-0\n")
+			for _, stem := range []string{"ADC", "SBB"} {
+				for _, width := range []string{"B", "W", "L", "Q"} {
+					if target.goarch == "386" && width == "Q" {
+						continue
+					}
+					op := stem + width
+					srcReg, dstReg := "BX", "AX"
+					if width == "B" {
+						srcReg, dstReg = "BL", "AL"
+					}
+					fmt.Fprintf(&source, "\t%s $1, %s\n", op, dstReg)
+					fmt.Fprintf(&source, "\t%s %s, %s\n", op, srcReg, dstReg)
+					fmt.Fprintf(&source, "\t%s 8(BX), %s\n", op, dstReg)
+					fmt.Fprintf(&source, "\t%s $1, 16(BX)\n", op)
+					fmt.Fprintf(&source, "\t%s %s, 24(BX)\n", op, srcReg)
+					if target.goarch == "386" && width != "B" {
+						fmt.Fprintf(&source, "\t%s $0, SP\n", op)
+					}
+					if target.goarch == "amd64" && width == "Q" {
+						fmt.Fprintf(&source, "\t%s $4294967295, AX\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, "#include \"textflag.h\"\n"+source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func adcsbbforms()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original ADC/SBB forms invented carry, numerical/native inputs or SP", api, err)
+				}
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"adcsbbforms": {Name: "adcsbbforms", Ret: Void}},
+				target.goarch, target.triple, 32)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, ir := range []string{ll, x86DwordProductIROptimize(t, ll)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86ADCSBBRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ADCB SP, AL"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SBBB AL, SP"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ADCQ 0(BX), 8(CX)"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "SBBL X0, AX"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ADCW.Z AX, BX"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ADCQ $4294967296, AX"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "ADCQ AX, BX"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "SBBQ $1, 0(BX)"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "ADCL R8, AX"},
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+test.instruction+"\n\tRET\n")
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: test.triple,
+					Goarch:       test.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ADC/SBB tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestAMD64ADCSBBMemoryRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT adcsbbmemory(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0xffffffffffffffff, 0(DI)
+	CLC
+	ADCQ $1, 0(DI)
+	SETCS 32(DI)
+	SBBQ $0, 0(DI)
+	SETCS 33(DI)
+	MOVL $0x7fffffff, 8(DI)
+	STC
+	ADCL $0, 8(DI)
+	SETOS 34(DI)
+	MOVW $0, 16(DI)
+	STC
+	SBBW $0, 16(DI)
+	SETCS 35(DI)
+	MOVB $0xff, 24(DI)
+	CLC
+	ADCB $1, 24(DI)
+	SETCS 36(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"adcsbbmemory": {Name: "adcsbbmemory", Args: []LLVMType{Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void adcsbbmemory(uint8_t *);
+int main(void) {
+  uint8_t out[40] = {0};
+  adcsbbmemory(out);
+  if (*(uint64_t *)(out+0) != UINT64_MAX) return 10;
+  if (*(uint32_t *)(out+8) != 0x80000000U) return 11;
+  if (*(uint16_t *)(out+16) != 0xffffU) return 12;
+  if (out[24] != 0) return 13;
+  for (int i = 32; i <= 36; i++) if (out[i] != 1) return 20+i;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "adc_sbb_memory", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_addsub.go b/amd64_lower_addsub.go
new file mode 100644
index 000000000..2295e6d7f
--- /dev/null
+++ b/amd64_lower_addsub.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerScalarAddSub implements all operand rows in Go 1.27's yxorb (B) and
+// yaddl (W/L/Q) tables for ADD and SUB.
+func (c *amd64Ctx) lowerScalarAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	add, bits, recognized := amd64ScalarAddSubProperties(baseOp)
+	if !recognized {
+		return false, false, nil
+	}
+	if err := validateAMD64ScalarAddSubInstruction(c.goarch, ins); err != nil {
+		return true, false, err
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	typ := amd64IntegerTypeForBits(bits)
+	var sourceValue string
+	if source.Kind == OpImm {
+		sourceValue = amd64ScalarAddSubImmediate(source.Imm, bits)
+	} else {
+		sourceValue, destination, err = c.evalScalarArithmeticSource(ins, typ)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	destinationValue, store, err := c.loadScalarRMWDestination(op, ins, destination, typ)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	llvmOp := "sub"
+	if add {
+		llvmOp = "add"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, llvmOp, typ, destinationValue, sourceValue)
+	resultValue := "%" + result
+	if err := store(resultValue); err != nil {
+		return true, false, err
+	}
+	c.setScalarAddSubFlags(typ, add, destinationValue, sourceValue, resultValue)
+	return true, false, nil
+}
+
+// validateAMD64ScalarAddSubInstruction is deliberately independent of a
+// lowering context so the same Go-assembler table is enforced before either
+// the direct/linear path or the CFG path is selected.
+func validateAMD64ScalarAddSubInstruction(goarch string, ins Instr) error {
+	rawOp := strings.ToUpper(string(ins.Op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	_, bits, recognized := amd64ScalarAddSubProperties(baseOp)
+	if !recognized {
+		return nil
+	}
+	if rawOp != baseOp {
+		return fmt.Errorf("%s %s does not accept instruction suffixes: %q", goarch, baseOp, ins.Raw)
+	}
+	if goarch == "386" && bits == 64 {
+		return fmt.Errorf("386 %s is illegal in 32-bit mode: %q", baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 2 {
+		return fmt.Errorf("%s %s expects source and destination: %q", goarch, baseOp, ins.Raw)
+	}
+	return validateAMD64ScalarAddSubOperands(goarch, baseOp, bits, ins.Args[0], ins.Args[1], ins)
+}
+
+func validateAMD64ScalarAddSubFunction(goarch string, fn Func) error {
+	for _, ins := range fn.Instrs {
+		if err := validateAMD64ScalarAddSubInstruction(goarch, ins); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func amd64ScalarAddSubProperties(op string) (add bool, bits int, ok bool) {
+	switch op {
+	case "ADDB":
+		return true, 8, true
+	case "ADDW":
+		return true, 16, true
+	case "ADDL":
+		return true, 32, true
+	case "ADDQ":
+		return true, 64, true
+	case "SUBB":
+		return false, 8, true
+	case "SUBW":
+		return false, 16, true
+	case "SUBL":
+		return false, 32, true
+	case "SUBQ":
+		return false, 64, true
+	default:
+		return false, 0, false
+	}
+}
+
+func validateAMD64ScalarAddSubOperands(goarch, baseOp string, bits int, source, destination Operand, ins Instr) error {
+	registerAllowed := func(reg Reg) bool {
+		if bits == 8 {
+			// Although SP is in the wider general-register class, Go's
+			// ADD/SUB byte tables do not accept it as a direct byte operand.
+			return reg != SP && isGoYmbRegisterForArch(reg, goarch)
+		}
+		return isX86YrlRegisterForArch(reg, goarch)
+	}
+	destinationRegister := destination.Kind == OpReg && registerAllowed(destination.Reg)
+	destinationMemory := isAMD64MemoryOperand(destination)
+	if !destinationRegister && !destinationMemory {
+		return fmt.Errorf("%s %s destination is outside Go 1.27's Ymb/Yml classes: %q", goarch, baseOp, ins.Raw)
+	}
+	switch source.Kind {
+	case OpImm:
+		if goarch != "386" && (source.Imm < -2147483648 || source.Imm > 4294967295) {
+			return fmt.Errorf("amd64 %s immediate is outside Go 1.27's Yi32 class: %q", baseOp, ins.Raw)
+		}
+	case OpReg:
+		if !registerAllowed(source.Reg) {
+			return fmt.Errorf("%s %s source is outside Go 1.27's Yrb/Yrl classes: %q", goarch, baseOp, ins.Raw)
+		}
+	case OpSym:
+		if x86AbsoluteRelocationSource(source, goarch, bits) {
+			return nil // Yi32 address, not a TYPE_MEM read; retain the source operand.
+		}
+		fallthrough
+	default:
+		if !isAMD64MemoryOperand(source) || !destinationRegister {
+			return fmt.Errorf("%s %s operands do not match Go 1.27's register/memory rows: %q", goarch, baseOp, ins.Raw)
+		}
+	}
+	return nil
+}
+
+// The assembler emits only the low operand-width bits. Q-width immediates are
+// encoded as imm32 and sign-extended by the CPU.
+func amd64ScalarAddSubImmediate(immediate int64, bits int) string {
+	return fmt.Sprintf("%d", amd64ScalarAddSubImmediateInt64(immediate, bits))
+}
+
+func amd64ScalarAddSubImmediateInt64(immediate int64, bits int) int64 {
+	var normalized int64
+	switch bits {
+	case 8:
+		normalized = int64(int8(uint8(immediate)))
+	case 16:
+		normalized = int64(int16(uint16(immediate)))
+	case 32, 64:
+		normalized = int64(int32(uint32(immediate)))
+	}
+	return normalized
+}
+
+func (c *amd64Ctx) setScalarAddSubFlags(typ LLVMType, add bool, destination, source, result string) {
+	c.setAuxiliaryCarryFlag(typ, destination, source, result)
+	carry := c.newTmp()
+	if add {
+		fmt.Fprintf(c.b, "  %%%s = icmp ult %s %s, %s\n", carry, typ, result, destination)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = icmp ult %s %s, %s\n", carry, typ, destination, source)
+	}
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+
+	xorOperands := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorOperands, typ, destination, source)
+	overflowInput := "%" + xorOperands
+	if add {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, typ, overflowInput)
+		overflowInput = "%" + inverted
+	}
+	xorResult := c.newTmp()
+	overflowBits := c.newTmp()
+	overflow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorResult, typ, destination, result)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", overflowBits, typ, overflowInput, xorResult)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", overflow, typ, overflowBits)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", overflow, c.flagsOFSlot)
+
+	zero := c.newTmp()
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", sign, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	c.setParityFlagSized(typ, result)
+}
diff --git a/amd64_lower_addsub_float.go b/amd64_lower_addsub_float.go
new file mode 100644
index 000000000..af56215ee
--- /dev/null
+++ b/amd64_lower_addsub_float.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import "fmt"
+
+// lowerAlternatingFloatingAddSubtract implements the complete Go 1.27 yxm
+// and _yvaddsubpd families. Even lanes subtract the Plan 9 first source from
+// the destination/base source; odd lanes add it.
+func (c *amd64Ctx) lowerAlternatingFloatingAddSubtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86AlternatingFloatProperties(local, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.legacy && form.memory >= 0 && ins.Args[form.first].Kind != OpFP {
+		return true, false, c.emitLegacyAlternatingRoundMemory(local, form, nil)
+	}
+	first, err := c.loadAlternatingRoundFloat(ins.Args[form.first], form.byteWidth, form.bits, !form.legacy)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadHorizontalFloatingOperand(ins.Args[form.second], form.byteWidth, form.bits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitAlternatingFloatingAddSubtract(form.byteWidth, form.bits, first, second)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, amd64FMA3LLVMType(form.byteWidth*8/form.bits, form.bits), result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeX(ins.Args[form.destination].Reg, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitAlternatingFloatingAddSubtract(byteWidth, laneBits int, first, second string) string {
+	lanes := byteWidth * 8 / laneBits
+	typeName := amd64FMA3LLVMType(lanes, laneBits)
+	elementType := amd64FMA3LLVMType(1, laneBits)
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		left := c.newTmp()
+		right := c.newTmp()
+		value := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", left, typeName, second, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", right, typeName, first, lane)
+		operation := "fsub"
+		if lane%2 == 1 {
+			operation = "fadd"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %%%s\n", value, operation, elementType, left, right)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, typeName, result, elementType, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_addsub_float_test.go b/amd64_lower_addsub_float_test.go
new file mode 100644
index 000000000..f77113b3d
--- /dev/null
+++ b/amd64_lower_addsub_float_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86AlternatingFloatingAddSubtractCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT alternatingfloataddsubforms(SB),NOSPLIT,$0-0\n")
+			for _, element := range []string{"PS", "PD"} {
+				op := "ADDSUB" + element
+				fmt.Fprintf(&src, "\t%s X0, X1\n", op)
+				fmt.Fprintf(&src, "\t%s (AX), X7\n", op)
+				vop := "V" + op
+				fmt.Fprintf(&src, "\t%s X0, X1, X2\n", vop)
+				fmt.Fprintf(&src, "\t%s (AX), X14, X15\n", vop)
+				fmt.Fprintf(&src, "\t%s Y0, Y1, Y2\n", vop)
+				fmt.Fprintf(&src, "\t%s (AX), Y14, Y15\n", vop)
+			}
+			src.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, src.String(), "alternatingfloataddsubforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "alternating-float-addsub-"+target.name+".ll", "alternating-float-addsub-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86AlternatingFloatingAddSubtractRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, op := range []string{"ADDSUBPS", "ADDSUBPD", "VADDSUBPS", "VADDSUBPD"} {
+		forms := []string{"X0", "Y0, Y1", "X0, X1, X2"}
+		valid := "X0, X1"
+		if strings.HasPrefix(op, "V") {
+			forms = []string{"X0", "X0, X1", "X0, Y1, Y2", "Z0, Z1, Z2", "X0, X1, K1, X2"}
+			valid = "X0, X1, X2"
+		}
+		for _, operands := range forms {
+			instruction := op + " " + operands
+			t.Run(strings.NewReplacer(" ", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+				assertX86AlternatingAddSubRejected(t, instruction)
+			})
+		}
+		for _, suffix := range []string{".Z", ".BCST", ".SAE", ".RN_SAE"} {
+			instruction := op + suffix + " " + valid
+			t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+				assertX86AlternatingAddSubRejected(t, instruction)
+			})
+		}
+	}
+}
+
+func assertX86AlternatingAddSubRejected(t *testing.T, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's yxm/_yvaddsubpd tables", instruction)
+	}
+}
diff --git a/amd64_lower_addvec.go b/amd64_lower_addvec.go
new file mode 100644
index 000000000..c49f9fcf7
--- /dev/null
+++ b/amd64_lower_addvec.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type amd64PackedAddMode = x86PackedArithmeticMode
+
+const (
+	amd64PackedAddWrap               = x86PackedWrap
+	amd64PackedAddSignedSaturating   = x86PackedSignedSaturating
+	amd64PackedAddUnsignedSaturating = x86PackedUnsignedSaturating
+)
+
+// lowerPackedIntegerAdd implements the complete Go 1.27 packed-integer add
+// family: the legacy ymm/yxm tables and the _yvandnpd VEX/EVEX table.
+func (c *amd64Ctx) lowerPackedIntegerAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerPackedIntegerAddForm(op, ins)
+}
+
+func (c *amd64Ctx) loadLegacyMMXPackedSource(src Operand) (string, error) {
+	if src.Kind == OpReg {
+		if _, ok := amd64ParseMReg(src.Reg); !ok {
+			return "", fmt.Errorf("expected MMX register or memory, got %s", src.String())
+		}
+		return c.loadReg(src.Reg)
+	}
+	if !isAMD64MemoryOperand(src) {
+		return "", fmt.Errorf("expected MMX register or memory, got %s", src.String())
+	}
+	return c.evalIntSized(src, I64)
+}
+
+func (c *amd64Ctx) bitcastI64ToIntegerLanes(lanes, laneBits int, value string) string {
+	cast := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <%d x i%d>\n", cast, value, lanes, laneBits)
+	return "%" + cast
+}
+
+func (c *amd64Ctx) emitPackedIntegerAdd(lanes, laneBits int, first, second string, mode amd64PackedAddMode) string {
+	vecType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	if mode == amd64PackedAddWrap {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", result, vecType, second, first)
+		return "%" + result
+	}
+
+	wideBits := laneBits * 2
+	wideType := fmt.Sprintf("<%d x i%d>", lanes, wideBits)
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	extend := "sext"
+	if mode == amd64PackedAddUnsignedSaturating {
+		extend = "zext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", firstWide, extend, vecType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", secondWide, extend, vecType, second, wideType)
+	sum := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", sum, wideType, secondWide, firstWide)
+
+	max := int64((uint64(1) << laneBits) - 1)
+	predicate := "ugt"
+	if mode == amd64PackedAddSignedSaturating {
+		max = int64((uint64(1) << (laneBits - 1)) - 1)
+		predicate = "sgt"
+	}
+	above := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %%%s, %s\n", above, predicate, wideType, sum, llvmSplatSignedInteger(lanes, wideBits, max))
+	capped := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %%%s\n", capped, lanes, above, wideType, llvmSplatSignedInteger(lanes, wideBits, max), wideType, sum)
+	clamped := "%" + capped
+	if mode == amd64PackedAddSignedSaturating {
+		min := -int64(uint64(1) << (laneBits - 1))
+		below := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, %s\n", below, wideType, clamped, llvmSplatSignedInteger(lanes, wideBits, min))
+		bounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", bounded, lanes, below, wideType, llvmSplatSignedInteger(lanes, wideBits, min), wideType, clamped)
+		clamped = "%" + bounded
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", result, wideType, clamped, vecType)
+	return "%" + result
+}
+
+func llvmSplatSignedInteger(lanes, bits int, value int64) string {
+	return llvmSplatIntegerText(lanes, bits, strconv.FormatInt(value, 10))
+}
diff --git a/amd64_lower_adx.go b/amd64_lower_adx.go
new file mode 100644
index 000000000..eea63cb40
--- /dev/null
+++ b/amd64_lower_adx.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import "fmt"
+
+type amd64ADXCarry uint8
+
+const (
+	amd64ADXCarryCF amd64ADXCarry = iota
+	amd64ADXCarryOF
+)
+
+type amd64ADXSpec struct {
+	bits   int
+	prefix byte
+	carry  amd64ADXCarry
+}
+
+// Go 1.27 asm6.go uses yml_rl for every ADX form. One spec binds the
+// register/memory grammar, encoded mandatory prefix, width and carry chain.
+var amd64ADXSpecs = map[Op]amd64ADXSpec{
+	"ADCXL": {bits: 32, prefix: 0x66, carry: amd64ADXCarryCF},
+	"ADCXQ": {bits: 64, prefix: 0x66, carry: amd64ADXCarryCF},
+	"ADOXL": {bits: 32, prefix: 0xf3, carry: amd64ADXCarryOF},
+	"ADOXQ": {bits: 64, prefix: 0xf3, carry: amd64ADXCarryOF},
+}
+
+// lowerADX implements ADCXL/Q and ADOXL/Q. All four opcodes use Go 1.27's
+// yml_rl row: register/memory source and register destination. ADCX consumes
+// and updates CF; ADOX independently consumes and updates OF.
+func (c *amd64Ctx) lowerADX(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86ADXProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	bits, flagSlot := form.spec.bits, c.flagsCFSlot
+	if form.spec.carry == amd64ADXCarryOF {
+		flagSlot = c.flagsOFSlot
+	}
+	source, destination := form.source, form.destination
+	typ := amd64IntegerTypeForBits(bits)
+	sourceValue, err := c.evalSizedNativeGPSource(source, typ, ins.x86AddressBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationValue, err := c.evalIntSized(destination, typ)
+	if err != nil {
+		return true, false, err
+	}
+	carryIn := c.loadFlag(flagSlot)
+	carryValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to %s\n", carryValue, carryIn, typ)
+	sum := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", sum, typ, destinationValue, sourceValue)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", result, typ, sum, carryValue)
+	carryFromOperands := c.newTmp()
+	carryFromInput := c.newTmp()
+	carryOut := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %%%s, %s\n", carryFromOperands, typ, sum, destinationValue)
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %%%s, %%%s\n", carryFromInput, typ, result, sum)
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", carryOut, carryFromOperands, carryFromInput)
+	if err := c.storeRegSized(destination.Reg, typ, "%"+result); err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carryOut, flagSlot)
+	return true, false, nil
+}
diff --git a/amd64_lower_adx_test.go b/amd64_lower_adx_test.go
new file mode 100644
index 000000000..dd9aad2db
--- /dev/null
+++ b/amd64_lower_adx_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86ADXCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	symbol := "adxdata"
+	size := 8
+	if goarch == "386" {
+		symbol = "adxdata386"
+		size = 4
+	}
+	fmt.Fprintf(&source, "DATA %s+0(SB)/%d, $1\n", symbol, size)
+	fmt.Fprintf(&source, "GLOBL %s(SB), $%d\n", symbol, size)
+	source.WriteString("TEXT adxforms(SB),$0-0\n")
+	widths := []string{"L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	for _, stem := range []string{"ADCX", "ADOX"} {
+		for _, width := range widths {
+			op := stem + width
+			fmt.Fprintf(&source, "\t%s AX, BX\n", op)
+			fmt.Fprintf(&source, "\t%s 8(BX), CX\n", op)
+			fmt.Fprintf(&source, "\t%s %s(SB), DX\n", op, symbol)
+			if goarch == "amd64" {
+				fmt.Fprintf(&source, "\t%s R11, R12\n", op)
+			} else {
+				fmt.Fprintf(&source, "\t%s AX, SP\n", op)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86ADXCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86ADXCompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ll := x86UnboundVoidScalarFormatObject(t, source, "adxforms", target.goarch, target.triple)
+			for _, want := range []string{"add i32", "icmp ult i32", `"target-features"="+adx"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ADX lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ll, "add i64") {
+				t.Fatalf("ADX Q-width lowering omitted add i64:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "adx-"+target.name+".ll", "adx-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ADXRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "ADCXQ $1, AX"},
+		{goarch: "amd64", instruction: "ADOXL AX, 0(BX)"},
+		{goarch: "amd64", instruction: "ADCXL X0, AX"},
+		{goarch: "amd64", instruction: "ADOXQ AX, X0"},
+		{goarch: "amd64", instruction: "ADCXQ AX"},
+		{goarch: "amd64", instruction: "ADOXL.Z AX, BX"},
+		{goarch: "386", instruction: "ADCXL R8, AX"},
+		{goarch: "386", instruction: "ADOXQ AX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ADX yml_rl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64ADXRuntimeSemanticsAndIndependentFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86ADXOriginalRuntimeSource
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	mainC := x86ADXOriginalRuntimeDriver
+	rawSource := x86ADXOriginalRawSource(source)
+	for _, form := range []struct{ name, source string }{{"text", source}, {"raw", rawSource}} {
+		t.Run(form.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, form.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"adxsemantics": {
+						Name: "adxsemantics", Args: []LLVMType{Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+					},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "adx_semantics_"+form.name, triple, ir, mainC, runPrefix)
+		})
+	}
+}
diff --git a/amd64_lower_aes.go b/amd64_lower_aes.go
new file mode 100644
index 000000000..bf70d9cb9
--- /dev/null
+++ b/amd64_lower_aes.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64AESRoundIntrinsics = map[Op]string{
+	"AESENC":     "@llvm.x86.aesni.aesenc",
+	"AESENCLAST": "@llvm.x86.aesni.aesenclast",
+	"AESDEC":     "@llvm.x86.aesni.aesdec",
+	"AESDECLAST": "@llvm.x86.aesni.aesdeclast",
+}
+
+// lowerAES implements the complete Go 1.27 AES/VAES family. Wide VAES round
+// instructions apply the corresponding 128-bit AES operation independently
+// to every lane.
+func (c *amd64Ctx) lowerAES(rawOp Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86AESProperties(rawOp, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	source, destination := f.sourceOperand, ins.Args[f.destination]
+	for _, slot := range c.fpResults {
+		if c.fixedLocal != nil {
+			break
+		} // its independent whole-source proof owns native local reads/results
+		if slot.Type == I8 || slot.Type == I16 || slot.Type == I32 || slot.Type == I64 || slot.Type == LLVMType("float") || slot.Type == LLVMType("double") {
+			// An intervening X→GP move, unrelated FP store or RET fallback
+			// cannot bypass the whole original-source must-initialized proof.
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return true, false, err
+			}
+			break
+		}
+	}
+	if f.memory >= 0 {
+		// Native stack bytes need their independent exact backing certificate.
+		// Type 4 retains a 16-byte alignment exception for legacy SSE. A
+		// logical FP value is not the original physical address and cannot
+		// preserve that exception. VAES has no corresponding alignment fault.
+		if !f.spec.vector && source.Kind == OpFP {
+			return true, false, fmt.Errorf("%w: legacy AES FP source needs its original native storage and alignment", ErrProbeNeedsContext)
+		}
+		if source.Kind == OpMem &&
+			!c.nativeMemoryOperand(ins, f.memory) &&
+			!x86CallerMemoryCertified(ins, f.memory) && !c.fixedLocalMemoryCertified(ins, f.memory) {
+			return true, false, fmt.Errorf("%w: AES native stack source has no original storage certificate", ErrProbeNeedsContext)
+		}
+		if source.Kind == OpFP {
+			if err := c.validateX86PackedShiftFPSpan(source.FPOffset, f.byteWidth); err != nil {
+				return true, false, err
+			}
+			readResult := false
+			for offset := source.FPOffset; offset < source.FPOffset+int64(f.byteWidth); offset++ {
+				slot, result, _ := c.fpVectorSlot(offset)
+				if slot.Type != I8 && slot.Type != I16 && slot.Type != I32 && slot.Type != I64 && slot.Type != LLVMType("float") && slot.Type != LLVMType("double") {
+					return true, false, fmt.Errorf("%w: AES FP byte is not declared numerical storage", ErrProbeNeedsContext)
+				}
+				readResult = readResult || result
+			}
+			if readResult {
+				if err := c.scalarFPResultInitialized(); err != nil {
+					return true, false, err
+				}
+			}
+		}
+	}
+	var value string
+	if f.memory >= 0 && !f.spec.vector && source.Kind != OpFP {
+		value, err = c.emitAESNativeMemory(ins, f)
+	} else {
+		// VAES has no fault-suppression rows. Even a dead key-assist result
+		// reads all m128 bytes, not only its numerical dwords 1 and 3.
+		var key string
+		key, err = c.loadX86PackedShiftBytes(source, f.byteWidth, true)
+		if err == nil && f.spec.operation < x86AESInverseMix {
+			var state string
+			state, err = c.loadPackedCompareBytes(ins.Args[f.state], f.byteWidth)
+			if err == nil {
+				legacyOp := Op(strings.TrimPrefix(strings.ToUpper(string(rawOp)), "V"))
+				value = c.emitAESRound(f.byteWidth, state, key, amd64AESRoundIntrinsics[legacyOp])
+			}
+		} else if err == nil {
+			carrier, call, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", carrier, key)
+			if f.spec.operation == x86AESInverseMix {
+				fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.aesni.aesimc(<2 x i64> %%%s)\n", call, carrier)
+			} else {
+				fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.aesni.aeskeygenassist(<2 x i64> %%%s, i8 %d)\n", call, carrier, uint8(ins.Args[0].Imm))
+			}
+			fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, call)
+			value = "%" + bytes
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if !f.spec.vector {
+		return true, false, c.storeLegacyPackedLogical(destination, value)
+	}
+	return true, false, c.storePackedMoveOperand(destination, f.byteWidth, value)
+}
+
+// Retain the original legacy opcode and its complete memory envelope even
+// when the result is dead, including legacy SSE's Type 4 alignment exception.
+func (c *amd64Ctx) emitAESNativeMemory(ins Instr, f x86AESForm) (string, error) {
+	source := f.sourceOperand
+	if f.spec.operation < x86AESInverseMix {
+		data, err := c.loadPackedCompareLanes(ins.Args[f.state], 16, 64, false)
+		if err != nil {
+			return "", err
+		}
+		result, err := c.emitPackedBinaryNativeMemory(source, 64, data, strings.ToLower(string(ins.Op)))
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %s to <16 x i8>\n", value, result)
+		return "%" + value, nil
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	assembly := strings.ToLower(string(ins.Op)) + " " + segment + "($1), $0"
+	if f.spec.operation == x86AESKeyAssist {
+		assembly = fmt.Sprintf("aeskeygenassist $$%d, %s($1), $0", uint8(ins.Args[0].Imm), segment)
+	}
+	call, value := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x i32> asm sideeffect %q, \"=x,r,~{memory}\"(%s %s)\n", call, assembly, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", value, call)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) emitAESRound(byteWidth int, stateBytes, keyBytes, intrinsic string) string {
+	qwords := byteWidth / 8
+	state := c.newTmp()
+	key := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i64>\n", state, byteWidth, stateBytes, qwords)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i64>\n", key, byteWidth, keyBytes, qwords)
+	result := "zeroinitializer"
+	for lane := 0; lane < byteWidth/16; lane++ {
+		laneState := c.newTmp()
+		laneKey := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i64> %%%s, <%d x i64> poison, <2 x i32> <i32 %d, i32 %d>\n", laneState, qwords, state, qwords, lane*2, lane*2+1)
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i64> %%%s, <%d x i64> poison, <2 x i32> <i32 %d, i32 %d>\n", laneKey, qwords, key, qwords, lane*2, lane*2+1)
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> %s(<2 x i64> %%%s, <2 x i64> %%%s)\n", call, intrinsic, laneState, laneKey)
+		for word := 0; word < 2; word++ {
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 %d\n", extracted, call, word)
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i64> %s, i64 %%%s, i32 %d\n", inserted, qwords, result, extracted, lane*2+word)
+			result = "%" + inserted
+		}
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", bytes, qwords, result, byteWidth)
+	return "%" + bytes
+}
diff --git a/amd64_lower_aes_test.go b/amd64_lower_aes_test.go
new file mode 100644
index 000000000..24ff01270
--- /dev/null
+++ b/amd64_lower_aes_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86AESCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			zLast := 31
+			if target.goarch == "386" {
+				legacyLast = 7
+				zLast = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT aesforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST"} {
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+				vop := "V" + op
+				source.WriteString("\t" + vop + " X0, X1, X2\n")
+				source.WriteString("\t" + vop + " 16(AX), X1, X2\n")
+				source.WriteString("\t" + vop + " Y0, Y1, Y2\n")
+				source.WriteString("\t" + vop + " 32(AX), Y1, Y2\n")
+				if target.goarch == "amd64" {
+					source.WriteString("\t" + vop + " X16, X30, X31\n")
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z1, Z%d\n", vop, zLast)
+			}
+			fmt.Fprintf(&source, "\tAESIMC X0, X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tAESIMC 8(AX), X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tVAESIMC X0, X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tVAESIMC 8(AX), X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tAESKEYGENASSIST $0, X0, X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tAESKEYGENASSIST $255, 8(AX), X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tVAESKEYGENASSIST $-128, X0, X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tVAESKEYGENASSIST $255, 8(AX), X%d\n", legacyLast)
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"aesforms": {Name: "aesforms", Ret: Void}},
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original AES formats invented vector or native-pointer inputs", err)
+			}
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+source.String())
+			ll = x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"aesforms": {Name: "aesforms", Ret: Void}}, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerAES(ins.Op, ins) })
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "aes-"+target.name+".ll", "aes-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86AESRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"AESENC Y0, X1",
+		"AESENC X0, X16",
+		"AESENC.Z X0, X1",
+		"AESIMC X0, (AX)",
+		"AESKEYGENASSIST $-1, X0, X1",
+		"AESKEYGENASSIST $256, X0, X1",
+		"VAESENC X0, Y1, Y2",
+		"VAESENC X0, X1",
+		"VAESENC X0, X1, K1, X2",
+		"VAESENC.Z X0, X1, X2",
+		"VAESENC X0, X1, (AX)",
+		"VAESIMC Y0, Y1",
+		"VAESIMC X16, X1",
+		"VAESKEYGENASSIST $-129, X0, X1",
+		"VAESKEYGENASSIST $256, X0, X1",
+		"VAESKEYGENASSIST $1, Y0, Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86AESRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"AESENC X8, X0",
+		"AESIMC X0, X8",
+		"AESKEYGENASSIST $1, X8, X0",
+		"VAESIMC X8, X0",
+		"VAESKEYGENASSIST $1, X0, X8",
+		"VAESENC Z8, Z0, Z1",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86AESRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86AESRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's AES/VAES tables for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_align_elements.go b/amd64_lower_align_elements.go
new file mode 100644
index 000000000..1f5bdadbe
--- /dev/null
+++ b/amd64_lower_align_elements.go
@@ -0,0 +1,17 @@
+package plan9asm
+
+import "strings"
+
+// Preserve the original family registry for source-op extraction.
+var amd64VectorAlignSpecs = map[Op]int{
+	"VALIGND": 32,
+	"VALIGNQ": 64,
+}
+
+func (c *amd64Ctx) lowerVectorAlign(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64VectorAlignSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	return c.lowerPackedAlignFamily(op, ins)
+}
diff --git a/amd64_lower_align_elements_test.go b/amd64_lower_align_elements_test.go
new file mode 100644
index 000000000..3ffe244f8
--- /dev/null
+++ b/amd64_lower_align_elements_test.go
@@ -0,0 +1,200 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateAMD64VectorAlignCompleteGo127Forms(t *testing.T) {
+	// VALIGND/Q share Go 1.27's six-row _yvalignd table: X/Y/Z,
+	// each with an unmasked and K1-K7 masked row. Their EVEX attributes add
+	// D/Q scalar broadcast and zeroing.
+	var source strings.Builder
+	source.WriteString("TEXT vector_align_forms(SB),$0-0\n")
+	for _, op := range []string{"VALIGND", "VALIGNQ"} {
+		for _, width := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&source, "\t%s $0, %s0, %s1, %s2\n", op, width, width, width)
+			fmt.Fprintf(&source, "\t%s $255, 8(BX), %s3, %s4\n", op, width, width)
+			fmt.Fprintf(&source, "\t%s $1, %s5, %s6, K1, %s7\n", op, width, width, width)
+			fmt.Fprintf(&source, "\t%s.Z $2, 16(BX), %s8, K2, %s9\n", op, width, width)
+			fmt.Fprintf(&source, "\t%s.BCST $3, 24(BX), %s10, %s11\n", op, width, width)
+			fmt.Fprintf(&source, "\t%s.BCST.Z $4, 32(BX), %s12, K3, %s13\n", op, width, width)
+		}
+		fmt.Fprintf(&source, "\t%s $5, X29, X30, X31\n", op)
+		fmt.Fprintf(&source, "\t%s $6, Y29, Y30, Y31\n", op)
+		fmt.Fprintf(&source, "\t%s $7, Z29, Z30, Z31\n", op)
+	}
+	source.WriteString("\tRET\n")
+
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), "amd64", target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, "amd64", target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerVectorAlign(ins.Op, ins) })
+			compileLLVMToObject(t, llc, target.triple, "vector-align-"+target.name+".ll", "vector-align-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateAMD64VectorAlignRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VALIGND X0, X1, X2",
+		"VALIGND $0, X0, X1",
+		"VALIGNQ $0, X0, X1, X2, X3, X4",
+		"VALIGND $-1, X0, X1, X2",
+		"VALIGNQ $256, X0, X1, X2",
+		"VALIGND AX, X0, X1, X2",
+		"VALIGND $0, Y0, X1, X2",
+		"VALIGNQ $0, X0, Y1, X2",
+		"VALIGND $0, X0, X1, Y2",
+		"VALIGNQ $0, X0, 8(BX), X2",
+		"VALIGND $0, X0, X1, 8(BX)",
+		"VALIGND $0, X0, X1, K0, X2",
+		"VALIGNQ $0, X0, X1, K8, X2",
+		"VALIGND.Z $0, X0, X1, X2",
+		"VALIGNQ.BCST $0, X0, X1, X2",
+		"VALIGND.BCST.Z $0, 8(BX), X1, X2",
+		"VALIGNQ.Z.BCST $0, 8(BX), X1, K1, X2",
+		"VALIGND.SAE $0, X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VALIGND/Q table", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslate386VectorAlignMatchesGoAssemblerOperandLimit(t *testing.T) {
+	for _, instruction := range []string{
+		"VALIGND $0, X0, X1, X2",
+		"VALIGNQ $255, 8(BX), Y1, Y2",
+		"VALIGND.Z $1, Z0, Z1, K1, Z2",
+		"VALIGNQ.BCST.Z $2, 16(BX), X1, K7, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if _, err := Translate(file, Options{
+					Goarch:       "386",
+					TargetTriple: triple,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("Translate accepted 386 %q although Go 1.27 rejects its operand count", instruction)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64VectorAlignRuntimeSemantics(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable integer oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT vectorAlignSemantics(SB),NOSPLIT,$0-40
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	MOVQ scalar+24(FP), DX
+	VMOVDQU32 (BX), X0
+	VMOVDQU32 (CX), X1
+	VALIGND $1, X0, X1, X2
+	VMOVDQU32 X2, 0(AX)
+	VALIGND $255, X0, X1, X3
+	VMOVDQU32 X3, 16(AX)
+	VALIGNQ $1, X0, X1, X4
+	VMOVDQU32 X4, 32(AX)
+	KMOVQ mask+32(FP), K1
+	VMOVDQU32 X0, X5
+	VALIGND $1, X0, X1, K1, X5
+	VMOVDQU32 X5, 48(AX)
+	VALIGND.Z $1, X0, X1, K1, X6
+	VMOVDQU32 X6, 64(AX)
+	VALIGND.BCST $1, (DX), X1, X7
+	VMOVDQU32 X7, 80(AX)
+	RET
+`
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", "#include \"textflag.h\"\n"+source)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: I64, Index: 4, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"vectorAlignSemantics": {
+				Name:  "vectorAlignSemantics",
+				Args:  []LLVMType{Ptr, Ptr, Ptr, Ptr, I64},
+				Ret:   Void,
+				Frame: frame,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorAlignSemantics(uint32_t *, const uint32_t *, const uint32_t *, const uint32_t *, uint64_t);
+int main(void) {
+  uint32_t first[4] = {10, 11, 12, 13};
+  uint32_t second[4] = {20, 21, 22, 23};
+  uint32_t scalar = 99;
+  uint32_t out[24] = {0};
+  const uint32_t want[24] = {
+    11, 12, 13, 20,
+    13, 20, 21, 22,
+    12, 13, 20, 21,
+    11, 11, 13, 13,
+    11, 0, 13, 0,
+    99, 99, 99, 20,
+  };
+  vectorAlignSemantics(out, first, second, &scalar, 5);
+  for (int i = 0; i < 24; i++) if (out[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "vector_align", triple, ir, mainC)
+}
diff --git a/amd64_lower_align_right.go b/amd64_lower_align_right.go
new file mode 100644
index 000000000..ef430a292
--- /dev/null
+++ b/amd64_lower_align_right.go
@@ -0,0 +1,19 @@
+package plan9asm
+
+import "strings"
+
+// Keep both original dispatcher entries on the complete shared grammar.
+func (c *amd64Ctx) lowerPackedAlignRight(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if base != "PALIGNR" && base != "VPALIGNR" {
+		return false, false, nil
+	}
+	return c.lowerPackedAlignFamily(op, ins)
+}
+
+func amd64UnsignedImmediate(operand Operand, bits int) bool {
+	if operand.Kind != OpImm || operand.ImmIsFloat || operand.ImmRaw != "" || bits <= 0 || bits >= 63 {
+		return false
+	}
+	return operand.Imm >= 0 && operand.Imm < int64(uint64(1)<<bits)
+}
diff --git a/amd64_lower_align_right_test.go b/amd64_lower_align_right_test.go
new file mode 100644
index 000000000..91632db8e
--- /dev/null
+++ b/amd64_lower_align_right_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedAlignRightCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			fmt.Fprintf(&source, "TEXT packedalignrightforms(SB),$0-0\n\tPALIGNR $0, X0, X%d\n\tPALIGNR $255, 8(AX), X%d\n", last, last)
+			if target.goarch == "amd64" {
+				source.WriteString("\tVPALIGNR $0, X0, X1, X2\n")
+				source.WriteString("\tVPALIGNR $1, 8(AX), X1, X2\n")
+				source.WriteString("\tVPALIGNR $2, Y0, Y1, Y2\n")
+				source.WriteString("\tVPALIGNR $3, 8(AX), Y1, Y2\n")
+				source.WriteString("\tVPALIGNR $4, Z0, Z1, Z2\n")
+				source.WriteString("\tVPALIGNR $5, 8(AX), Z1, Z2\n")
+				source.WriteString("\tVPALIGNR $6, X16, X31, X0\n")
+				source.WriteString("\tVPALIGNR $7, X16, X31, K1, X0\n")
+				source.WriteString("\tVPALIGNR.Z $8, 16(AX), Y31, K2, Y0\n")
+				source.WriteString("\tVPALIGNR $9, Z16, Z31, K3, Z0\n")
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			ll := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerPackedAlignRight(ins.Op, ins) })
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-align-right-"+target.name+".ll", "packed-align-right-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedAlignRightRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PALIGNR $-1, X0, X1",
+		"PALIGNR $256, X0, X1",
+		"PALIGNR $1, M0, M1",
+		"PALIGNR $1, X16, X1",
+		"PALIGNR $1, Y0, Y1",
+		"PALIGNR.Z $1, X0, X1",
+		"PALIGNR $1, X0, (AX)",
+		"VPALIGNR $-1, X0, X1, X2",
+		"VPALIGNR $256, X0, X1, X2",
+		"VPALIGNR $1, X0, Y1, Y2",
+		"VPALIGNR $1, X0, X1, K0, X2",
+		"VPALIGNR.Z $1, X0, X1, X2",
+		"VPALIGNR.BCST $1, X0, X1, X2",
+		"VPALIGNR $1, X0, (AX), X2",
+		"VPALIGNR $1, X0, X1, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedAlignRightRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PALIGNR $1, X8, X0",
+		"PALIGNR $1, X0, X8",
+		"VPALIGNR $1, X0, X1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedAlignRightRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedAlignRightRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's PALIGNR/VPALIGNR tables for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64PackedAlignRightRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT alignrightlegacy(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ low+8(FP), BX
+	MOVQ high+16(FP), CX
+	MOVOU (CX), X0
+	PALIGNR $8, (BX), X0
+	MOVOU X0, (AX)
+	RET
+TEXT alignrightvector(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ low+8(FP), BX
+	MOVQ high+16(FP), CX
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPALIGNR $8, Y0, Y1, Y2
+	VMOVDQU Y2, (AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"alignrightlegacy": {Name: "alignrightlegacy", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+			"alignrightvector": {Name: "alignrightvector", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void alignrightlegacy(uint8_t *, const uint8_t *, const uint8_t *);
+extern void alignrightvector(uint8_t *, const uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t low[32], high[32], out[32];
+  for (int i = 0; i < 32; i++) { low[i] = (uint8_t)i; high[i] = (uint8_t)(100+i); out[i] = 0; }
+  alignrightlegacy(out, low, high);
+  for (int i = 0; i < 8; i++) if (out[i] != low[i+8]) return 10+i;
+  for (int i = 8; i < 16; i++) if (out[i] != high[i-8]) return 30+i;
+  for (int i = 0; i < 32; i++) out[i] = 0;
+  alignrightvector(out, low, high);
+  for (int lane = 0; lane < 2; lane++) {
+    int base = lane*16;
+    for (int i = 0; i < 8; i++) if (out[base+i] != low[base+i+8]) return 60+base+i;
+    for (int i = 8; i < 16; i++) if (out[base+i] != high[base+i-8]) return 100+base+i;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_align_right", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_andn.go b/amd64_lower_andn.go
new file mode 100644
index 000000000..d6be17817
--- /dev/null
+++ b/amd64_lower_andn.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerANDN(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86TernaryGPProperties(op, ins, c.goarch)
+	if !known || form.spec.operation != x86TernaryANDN {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	typ := amd64IntegerTypeForBits(form.spec.bits)
+	first, err := c.evalSizedNativeGPSource(form.first, typ, ins.x86AddressBits)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.evalIntSized(form.second, typ)
+	if err != nil {
+		return true, false, err
+	}
+	inverted, result := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, typ, second)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", result, typ, inverted, first)
+	if typ == I64 {
+		c.setZSFlagsFromI64("%" + result)
+	} else {
+		c.setZSFlagsFromI32("%" + result)
+	}
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	return true, false, c.storeRegSized(form.destination.Reg, typ, "%"+result)
+}
diff --git a/amd64_lower_andn_test.go b/amd64_lower_andn_test.go
new file mode 100644
index 000000000..6d23acae1
--- /dev/null
+++ b/amd64_lower_andn_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RawANDNReportedEncoding(t *testing.T) {
+	const source = `
+TEXT rawANDN(SB),$0-0
+	BYTE $0xc4
+	BYTE $0x42
+	BYTE $0x38
+	BYTE $0xf2
+	BYTE $0xe2
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			if !strings.Contains(ir, `"target-features"="+bmi"`) {
+				t.Fatalf("raw ANDN did not infer BMI1 target feature:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-andn.ll", "raw-andn.o", ir)
+		})
+	}
+}
+
+func TestX86ANDNCompleteGo127FormsAcrossTargets(t *testing.T) {
+	registers386 := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+	registersAMD64 := append(append([]string{}, registers386...), "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	targets := []struct {
+		name      string
+		goarch    string
+		triple    string
+		registers []string
+	}{
+		{name: "386-linux", goarch: "386", triple: "i386-unknown-linux-gnu", registers: registers386},
+		{name: "386-windows", goarch: "386", triple: "i686-pc-windows-msvc", registers: registers386},
+		{name: "amd64-darwin", goarch: "amd64", triple: "x86_64-apple-darwin", registers: registersAMD64},
+		{name: "amd64-linux", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registers: registersAMD64},
+		{name: "amd64-windows", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registers: registersAMD64},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT andnall(SB),$0-0\n")
+			for _, width := range []string{"L", "Q"} {
+				for index, first := range target.registers {
+					second := target.registers[(index+3)%len(target.registers)]
+					destination := target.registers[(index+5)%len(target.registers)]
+					fmt.Fprintf(&source, "\tANDN%s %s, %s, %s\n", width, first, second, destination)
+				}
+				fmt.Fprintf(&source, "\tANDN%s 8(AX), CX, DX\n", width)
+				fmt.Fprintf(&source, "\tANDN%s 16(AX)(CX*4), DX, BX\n", width)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "andnall", target.goarch, target.triple)
+			if !strings.Contains(ir, `"target-features"="+bmi"`) {
+				t.Fatalf("ANDN family did not infer BMI1 target feature:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "andn-family.ll", "andn-family.o", ir)
+		})
+	}
+}
+
+func TestX86RawANDNCompleteRegisterFields(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		registerCount := 8
+		if mode == 64 {
+			registerCount = 16
+		}
+		for _, width64 := range []bool{false, true} {
+			for first := 0; first < registerCount; first++ {
+				for second := 0; second < registerCount; second++ {
+					for destination := 0; destination < registerCount; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 | 1<<6 | byte((^first>>3)&1)<<5 | 2
+						p1 := byte((^second)&15) << 3
+						if width64 {
+							p1 |= 0x80
+						}
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0xc4, p0, p1, 0xf2, modRM}
+						instruction, length, ok, err := decodedX86ANDNInstruction(encoding, mode)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("mode=%d width64=%v first=%d second=%d destination=%d: ok=%v length=%d err=%v", mode, width64, first, second, destination, ok, length, err)
+						}
+						wantOp := Op("ANDNL")
+						if width64 && mode == 64 {
+							wantOp = "ANDNQ"
+						}
+						wantFirst, _ := decodedX86GeneralRegister(first)
+						wantSecond, _ := decodedX86GeneralRegister(second)
+						wantDestination, _ := decodedX86GeneralRegister(destination)
+						if instruction.Op != wantOp || len(instruction.Args) != 3 || instruction.Args[0].Reg != wantFirst || instruction.Args[1].Reg != wantSecond || instruction.Args[2].Reg != wantDestination {
+							t.Fatalf("encoding %x decoded as %#v", encoding, instruction)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawANDNMemoryForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		encoding []byte
+	}{
+		{name: "direct", encoding: []byte{0xc4, 0xe2, 0x30, 0xf2, 0x13}},
+		{name: "extended base", encoding: []byte{0xc4, 0xc2, 0x30, 0xf2, 0x13}},
+		{name: "sib disp8", encoding: []byte{0xc4, 0x82, 0x88, 0xf2, 0x54, 0x88, 0x10}},
+		{name: "base less", encoding: []byte{0xc4, 0xe2, 0x30, 0xf2, 0x14, 0x25, 0x78, 0x56, 0x34, 0x12}},
+		{name: "segment", encoding: []byte{0x64, 0xc4, 0xe2, 0x30, 0xf2, 0x54, 0x48, 0x08}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86ANDNInstruction(test.encoding, 64)
+			if !ok || err != nil || length != len(test.encoding) || len(instruction.Args) != 3 || instruction.Args[0].Kind != OpMem {
+				t.Fatalf("encoding %x: instruction=%#v ok=%v length=%d err=%v", test.encoding, instruction, ok, length, err)
+			}
+		})
+	}
+}
+
+func TestX86RawANDNRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+	}{
+		{name: "vex l", mode: 64, encoding: []byte{0xc4, 0xe2, 0x34, 0xf2, 0xd2}},
+		{name: "vex pp", mode: 64, encoding: []byte{0xc4, 0xe2, 0x31, 0xf2, 0xd2}},
+		{name: "missing modrm", mode: 64, encoding: []byte{0xc4, 0xe2, 0x30, 0xf2}},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0xc4, 0xe2, 0x30, 0xf2, 0xd2}},
+		{name: "rip relative", mode: 64, encoding: []byte{0xc4, 0xe2, 0x30, 0xf2, 0x15, 0, 0, 0, 0}},
+		{name: "extended first 386", mode: 32, encoding: []byte{0xc4, 0xc2, 0x70, 0xf2, 0xc0}},
+		{name: "extended second 386", mode: 32, encoding: []byte{0xc4, 0xe2, 0x38, 0xf2, 0xc0}},
+		{name: "extended destination 386", mode: 32, encoding: []byte{0xc4, 0x62, 0x70, 0xf2, 0xc0}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86ANDNInstruction(test.encoding, test.mode)
+			if !ok || err == nil {
+				t.Fatalf("encoding %x: ok=%v err=%v, want recognized rejection", test.encoding, ok, err)
+			}
+		})
+	}
+}
+
+func TestX86ANDNRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86ANDNOriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"andnsemantics": {Name: "andnsemantics", Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := x86ANDNOriginalRuntimeDriver
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "andn_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_approximate_math.go b/amd64_lower_approximate_math.go
new file mode 100644
index 000000000..a469dc0df
--- /dev/null
+++ b/amd64_lower_approximate_math.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ApproximateMathMode uint8
+
+const (
+	amd64ApproximateExp2 amd64ApproximateMathMode = iota
+	amd64ApproximateReciprocal28
+	amd64ApproximateReciprocalSqrt28
+)
+
+type amd64ApproximateMathSpec struct {
+	laneBits int
+	scalar   bool
+	mode     amd64ApproximateMathMode
+}
+
+// amd64ApproximateMathSpecs models the complete AVX512ER family exposed by
+// Go 1.27's _yvexp2pd and _yvgetexpsd tables. The type axes describe the
+// mathematical operation, lane type, and packed/scalar operand shape; the
+// parser below derives every legal mask, zero, broadcast, and SAE form.
+var amd64ApproximateMathSpecs = map[Op]amd64ApproximateMathSpec{
+	"VEXP2PS":    {laneBits: 32, mode: amd64ApproximateExp2},
+	"VEXP2PD":    {laneBits: 64, mode: amd64ApproximateExp2},
+	"VRCP28PS":   {laneBits: 32, mode: amd64ApproximateReciprocal28},
+	"VRCP28PD":   {laneBits: 64, mode: amd64ApproximateReciprocal28},
+	"VRCP28SS":   {laneBits: 32, scalar: true, mode: amd64ApproximateReciprocal28},
+	"VRCP28SD":   {laneBits: 64, scalar: true, mode: amd64ApproximateReciprocal28},
+	"VRSQRT28PS": {laneBits: 32, mode: amd64ApproximateReciprocalSqrt28},
+	"VRSQRT28PD": {laneBits: 64, mode: amd64ApproximateReciprocalSqrt28},
+	"VRSQRT28SS": {laneBits: 32, scalar: true, mode: amd64ApproximateReciprocalSqrt28},
+	"VRSQRT28SD": {laneBits: 64, scalar: true, mode: amd64ApproximateReciprocalSqrt28},
+}
+
+// All ten EVEX approximation members share the existing typed native helper.
+// The original instruction owns SAE/MXCSR, masking and the actual memory access;
+// source data is never eagerly loaded before a masked native instruction.
+func (c *amd64Ctx) lowerApproximateMath(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64ApproximateMathSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	return c.lowerNativeFloatingHelper(op, ins)
+}
+
+func (c *amd64Ctx) approximateMathMask32(mask string) string {
+	truncated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncated, mask)
+	return "%" + truncated
+}
diff --git a/amd64_lower_approximate_math_test.go b/amd64_lower_approximate_math_test.go
new file mode 100644
index 000000000..b395d9426
--- /dev/null
+++ b/amd64_lower_approximate_math_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type approximateMathTestSpec struct {
+	op       string
+	laneBits int
+	scalar   bool
+	mode     amd64ApproximateMathMode
+}
+
+func go127ApproximateMathSpecs() []approximateMathTestSpec {
+	return []approximateMathTestSpec{
+		{op: "VEXP2PS", laneBits: 32, mode: amd64ApproximateExp2},
+		{op: "VEXP2PD", laneBits: 64, mode: amd64ApproximateExp2},
+		{op: "VRCP28PS", laneBits: 32, mode: amd64ApproximateReciprocal28},
+		{op: "VRCP28PD", laneBits: 64, mode: amd64ApproximateReciprocal28},
+		{op: "VRCP28SS", laneBits: 32, scalar: true, mode: amd64ApproximateReciprocal28},
+		{op: "VRCP28SD", laneBits: 64, scalar: true, mode: amd64ApproximateReciprocal28},
+		{op: "VRSQRT28PS", laneBits: 32, mode: amd64ApproximateReciprocalSqrt28},
+		{op: "VRSQRT28PD", laneBits: 64, mode: amd64ApproximateReciprocalSqrt28},
+		{op: "VRSQRT28SS", laneBits: 32, scalar: true, mode: amd64ApproximateReciprocalSqrt28},
+		{op: "VRSQRT28SD", laneBits: 64, scalar: true, mode: amd64ApproximateReciprocalSqrt28},
+	}
+}
+
+func TestAMD64ApproximateMathGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := go127ApproximateMathSpecs()
+	if len(amd64ApproximateMathSpecs) != len(expected) {
+		t.Fatalf("approximate-math grammar has %d entries, want %d", len(amd64ApproximateMathSpecs), len(expected))
+	}
+	for _, want := range expected {
+		got, ok := amd64ApproximateMathSpecs[Op(want.op)]
+		if !ok {
+			t.Errorf("approximate-math grammar omitted %s", want.op)
+			continue
+		}
+		if got.laneBits != want.laneBits || got.scalar != want.scalar || got.mode != want.mode {
+			t.Errorf("approximate-math grammar %s = %+v, want laneBits=%d scalar=%v mode=%d", want.op, got, want.laneBits, want.scalar, want.mode)
+		}
+	}
+}
+
+func TestTranslateX86ApproximateMathCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			vectorDestination := 23
+			if target.goarch == "386" {
+				vectorDestination = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT approximatemathforms(SB),$0-0\n")
+			for index, spec := range go127ApproximateMathSpecs() {
+				if spec.scalar {
+					fmt.Fprintf(&source, "\t%s X1, X2, X23\n", spec.op)
+					fmt.Fprintf(&source, "\t%s %d(AX), X2, X23\n", spec.op, index*8)
+					fmt.Fprintf(&source, "\t%s.SAE X1, X2, X23\n", spec.op)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s X1, X2, K1, X23\n", spec.op)
+						fmt.Fprintf(&source, "\t%s.Z %d(AX), X2, K2, X23\n", spec.op, index*8)
+						fmt.Fprintf(&source, "\t%s.SAE.Z X1, X2, K3, X23\n", spec.op)
+					}
+					continue
+				}
+				fmt.Fprintf(&source, "\t%s Z1, Z%d\n", spec.op, vectorDestination)
+				fmt.Fprintf(&source, "\t%s %d(AX), Z%d\n", spec.op, index*8, vectorDestination)
+				fmt.Fprintf(&source, "\t%s Z1, K1, Z%d\n", spec.op, vectorDestination)
+				fmt.Fprintf(&source, "\t%s.Z %d(AX), K2, Z%d\n", spec.op, index*8, vectorDestination)
+				fmt.Fprintf(&source, "\t%s.BCST %d(AX), Z%d\n", spec.op, index*8, vectorDestination)
+				fmt.Fprintf(&source, "\t%s.BCST.Z %d(AX), K3, Z%d\n", spec.op, index*8, vectorDestination)
+				fmt.Fprintf(&source, "\t%s.SAE Z1, Z%d\n", spec.op, vectorDestination)
+				fmt.Fprintf(&source, "\t%s.SAE.Z Z1, K4, Z%d\n", spec.op, vectorDestination)
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			// Keep the complete original uninitialized source and its actual
+			// Go acceptance. Neither the grammar nor a private register slot
+			// supplies the missing vector, mask or native address inputs.
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func approximatemathforms()",
+					target.goarch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original unbound approximation formats invented their inputs", api, err)
+				}
+			}
+			counterpart := source.String()
+			if target.goarch == "386" {
+				// Go's original high-X syntax above remains a separate source
+				// observation. The initialized physical counterpart uses X7.
+				counterpart = strings.ReplaceAll(counterpart, "X23", "X7")
+			}
+			initialized, declaration, count := x86Reciprocal14InitializeOriginalShapes(t, counterpart, target.goarch)
+			want := 72
+			if target.goarch == "386" {
+				want = 60
+			}
+			if count != want {
+				t.Fatal("original approximation shape counterpart omitted an instruction", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, initialized)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, declaration, target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized original approximation shapes rejected", api, err)
+					}
+					for _, mnemonic := range []string{"vexp2ps", "vexp2pd", "vrcp28ps", "vrcp28pd", "vrcp28ss", "vrcp28sd", "vrsqrt28ps", "vrsqrt28pd", "vrsqrt28ss", "vrsqrt28sd"} {
+						if !strings.Contains(ir, mnemonic) {
+							t.Fatalf("translation omitted inline %s:\n%s", mnemonic, ir)
+						}
+					}
+					for _, fragment := range []string{"kmovw", "{%k1}", "{sae}", `"target-features"="+avx512f"`} {
+						if !strings.Contains(ir, fragment) {
+							t.Fatalf("translation omitted %q:\n%s", fragment, ir)
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "approximate-math-"+target.name+"-"+api+".ll", "approximate-math-"+target.name+"-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateX86ApproximateMathRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VEXP2PS X0, X1"},
+		{goarch: "amd64", instruction: "VEXP2PD Y0, Y1"},
+		{goarch: "amd64", instruction: "VRCP28PS Z0, K0, Z1"},
+		{goarch: "amd64", instruction: "VRSQRT28PD.Z Z0, Z1"},
+		{goarch: "amd64", instruction: "VEXP2PS.BCST Z0, Z1"},
+		{goarch: "amd64", instruction: "VRCP28PD.SAE 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VRCP28SS X0, X1"},
+		{goarch: "amd64", instruction: "VRSQRT28SD Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VRCP28SS.BCST 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VRSQRT28SD.SAE 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VEXP2PS.RN_SAE Z0, Z1"},
+		{goarch: "386", instruction: "VEXP2PS Z0, Z8"},
+		{goarch: "386", instruction: "VRCP28SS X0, X1, K1, X2"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's approximate-math tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_arith.go b/amd64_lower_arith.go
index 2a25025ce..06f5511c0 100644
--- a/amd64_lower_arith.go
+++ b/amd64_lower_arith.go
@@ -24,6 +24,17 @@ func (c *amd64Ctx) loadIntDestination(dst Operand, ty LLVMType) (string, func(st
 			fmt.Fprintf(c.b, "  store %s %s, %s %s, align 1\n", ty, out, ptrType, p)
 			return nil
 		}, nil
+	case OpFP:
+		value, err := c.evalFPToI64(dst.FPOffset)
+		if err != nil {
+			return "", nil, err
+		}
+		if ty != I64 {
+			value = c.truncI64(value, ty)
+		}
+		return value, func(out string) error {
+			return c.storeFPResult(dst.FPOffset, ty, out)
+		}, nil
 	case OpSym:
 		p, err := c.ptrFromSB(dst.Sym)
 		if err != nil {
@@ -45,22 +56,65 @@ type x86FlagSlot struct {
 	bit  uint
 }
 
-func (c *amd64Ctx) x86FlagSlots() []x86FlagSlot {
-	flags := []x86FlagSlot{
+type x86StatusFlagMask uint16
+
+const (
+	x86StatusCF  x86StatusFlagMask = 1 << 0
+	x86StatusPF  x86StatusFlagMask = 1 << 2
+	x86StatusAF  x86StatusFlagMask = 1 << 4
+	x86StatusZF  x86StatusFlagMask = 1 << 6
+	x86StatusSF  x86StatusFlagMask = 1 << 7
+	x86StatusOF  x86StatusFlagMask = 1 << 11
+	x86StatusAll                   = x86StatusCF | x86StatusPF | x86StatusAF | x86StatusZF | x86StatusSF | x86StatusOF
+)
+
+func (c *amd64Ctx) x86StatusFlagSlots() []x86FlagSlot {
+	return []x86FlagSlot{
 		{c.flagsCFSlot, 0},
+		{c.flagsPFSlot, 2},
+		{c.flagsAFSlot, 4},
 		{c.flagsZSlot, 6},
 		{c.flagsSltSlot, 7},
+		{c.flagsOFSlot, 11},
 	}
+}
+
+func (c *amd64Ctx) x86FlagSlots() []x86FlagSlot {
+	flags := c.x86StatusFlagSlots()
 	if c.directionSlot != "" {
 		flags = append(flags, x86FlagSlot{c.directionSlot, 10})
 	}
-	flags = append(flags, x86FlagSlot{c.flagsOFSlot, 11})
 	if c.flagsIDSlot != "" {
 		flags = append(flags, x86FlagSlot{c.flagsIDSlot, 21})
 	}
 	return flags
 }
 
+// Clear exactly the ISA-defined status bits. Reusing the complete slot model
+// prevents a consumer's hand-written subset from silently omitting AF.
+func (c *amd64Ctx) clearX86StatusFlags(mask x86StatusFlagMask) {
+	for _, flag := range c.x86StatusFlagSlots() {
+		if mask&(1<<flag.bit) != 0 {
+			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", flag.slot)
+		}
+	}
+}
+
+// The carry/borrow into bit 4 equals bit 4 of a XOR b XOR result. The final
+// result includes any ADC/SBB carry input, so the same width-independent rule
+// covers binary arithmetic, comparison, unary increment/decrement and exchange.
+func (c *amd64Ctx) setAuxiliaryCarryFlag(typ LLVMType, a, b, result string) {
+	xorOperands := c.newTmp()
+	xorResult := c.newTmp()
+	bit := c.newTmp()
+	flag := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorOperands, typ, a, b)
+	fmt.Fprintf(c.b, "  %%%s = xor %s %%%s, %s\n", xorResult, typ, xorOperands, result)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 16\n", bit, typ, xorResult)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, 0\n", flag, typ, bit)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", flag, c.flagsAFSlot)
+}
+
 func (c *amd64Ctx) packX86Flags() string {
 	packed := "2" // architectural bit 1 is always set
 	for _, flag := range c.x86FlagSlots() {
@@ -80,8 +134,13 @@ func (c *amd64Ctx) packX86Flags() string {
 	return packed
 }
 
-func (c *amd64Ctx) unpackX86Flags(packed string) {
+func (c *amd64Ctx) unpackX86Flags(packed string, operandBits int) {
 	for _, flag := range c.x86FlagSlots() {
+		// A word pop replaces FLAGS, not the upper EFLAGS/RFLAGS bits.
+		// In particular, the ID bit remains unchanged by POPFW.
+		if flag.bit >= uint(operandBits) {
+			continue
+		}
 		shifted := packed
 		if flag.bit != 0 {
 			shift := c.newTmp()
@@ -100,68 +159,118 @@ func (c *amd64Ctx) truncI64(v string, ty LLVMType) string {
 	return "%" + t
 }
 
-func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	switch op {
-	case "PUSHL":
-		if c.goarch != "386" {
-			return true, false, fmt.Errorf("amd64 PUSHL requires GOARCH=386")
-		}
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 PUSHL expects src: %q", ins.Raw)
-		}
-		v32, err := c.evalIntSized(ins.Args[0], I32)
-		if err != nil {
-			return true, false, err
-		}
-		return true, false, c.pushI32(v32)
-	case "POPL":
-		if c.goarch != "386" {
-			return true, false, fmt.Errorf("amd64 POPL requires GOARCH=386")
-		}
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 POPL expects dst: %q", ins.Raw)
-		}
-		v32, err := c.popI32()
-		if err != nil {
-			return true, false, err
-		}
-		switch ins.Args[0].Kind {
-		case OpReg:
-			return true, false, c.storeRegSized(ins.Args[0].Reg, I32, v32)
-		case OpMem:
-			p, ptrType, err := c.ptrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			fmt.Fprintf(c.b, "  store i32 %s, %s %s, align 1\n", v32, ptrType, p)
-			return true, false, nil
+func isGoYmbRegisterForArch(r Reg, goarch string) bool {
+	if goarch == "386" {
+		// Go classifies SP/BP/SI/DI as Yrl32 in 386 mode, so they do not
+		// directly cover Ymb. Its assembler nevertheless accepts BP/SI/DI
+		// and synthesizes an equivalent sequence through BX; only a direct
+		// SP spelling remains invalid.
+		switch r {
+		case AX, BX, CX, DX, BP, SI, DI, AL, AH, BL, BH, CL, CH, DL, DH:
+			return true
 		default:
-			return true, false, fmt.Errorf("amd64 POPL expects reg/mem dst: %q", ins.Raw)
-		}
-	case "PUSHFL":
-		if c.goarch != "386" {
-			return true, false, fmt.Errorf("amd64 PUSHFL requires GOARCH=386")
+			return false
 		}
-		if len(ins.Args) != 0 {
-			return true, false, fmt.Errorf("amd64 PUSHFL takes no operands: %q", ins.Raw)
-		}
-		flags := c.truncI64(c.packX86Flags(), I32)
-		return true, false, c.pushI32(flags)
-	case "POPFL":
-		if c.goarch != "386" {
-			return true, false, fmt.Errorf("amd64 POPFL requires GOARCH=386")
-		}
-		if len(ins.Args) != 0 {
-			return true, false, fmt.Errorf("amd64 POPFL takes no operands: %q", ins.Raw)
-		}
-		flags32, err := c.popI32()
-		if err != nil {
-			return true, false, err
+	}
+	if isX86YrlRegisterForArch(r, goarch) {
+		return true
+	}
+	switch r {
+	case AL, AH, BL, BH, CL, CH, DL, DH,
+		BPB, SIB, DIB, R8B, R9B, R10B, R11B, R12B, R13B, R14B, R15B:
+		return true
+	default:
+		return false
+	}
+}
+
+// amd64YmbEffectiveRegister mirrors the raw ModRM numbering used when Go's
+// broad Ymb table accepts a byte-register spelling for a wider NEG/NOT opcode.
+func amd64YmbEffectiveRegister(r Reg, bits int) Reg {
+	if bits == 8 {
+		return r
+	}
+	switch r {
+	case AL:
+		return AX
+	case CL:
+		return CX
+	case DL:
+		return DX
+	case BL:
+		return BX
+	case AH:
+		return SP
+	case CH:
+		return BP
+	case DH:
+		return SI
+	case BH:
+		return DI
+	default:
+		if base, _, ok := amd64ByteAlias(r); ok {
+			return base
 		}
-		flags64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", flags64, flags32)
-		c.unpackX86Flags("%" + flags64)
-		return true, false, nil
+		return r
+	}
+}
+
+func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, terminated, err := c.lowerByteSwap(op, ins); known {
+		return true, terminated, err
+	}
+	if known, terminated, err := c.lowerScalarBitScan(op, ins); known {
+		return true, terminated, err
+	}
+	if ok, terminated, err := c.lowerX86CPUQuery(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerX86OrderingHint(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerStackWidth(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerAccumulatorSignExtend(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerBZHI(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerBEXTR(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerADX(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerMULX(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerANDN(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerScalarBitCount(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerBMI2ShiftRotate(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerScalarUnaryYmb(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerLowestSetBitManipulation(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerHardwareRandom(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerScalarADCSBB(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerScalarMultiplyDivide(op, ins); ok {
+		return ok, terminated, err
+	}
+	switch op {
 	case "PUSHAL":
 		if c.goarch != "386" {
 			return true, false, fmt.Errorf("amd64 PUSHAL requires GOARCH=386")
@@ -223,140 +332,35 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 			}
 		}
 		return true, false, nil
-	case "PUSHQ":
-		// Stack-manipulation appears in syscall asm stubs (e.g. preserve return
-		// address register around SYSCALL). Lower to the local virtual stack.
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 PUSHQ expects src: %q", ins.Raw)
+	case "PREFETCHNTA", "PREFETCHT0", "PREFETCHT1", "PREFETCHT2",
+		"PREFETCHRST2", "PREFETCHIT0", "PREFETCHIT1":
+		// Go 1.27's shared yprefetch table has exactly one memory operand for
+		// each named locality hint. The raw-only 0F 18 /4, /6 and /7 forms
+		// share that one-memory-operand grammar. Cache hints have no
+		// SSA-visible result.
+		if len(ins.Args) != 1 || !isAMD64MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("%s %s expects one memory operand: %q", c.goarch, op, ins.Raw)
 		}
-		v, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		c.pushI64(v)
-		return true, false, nil
-	case "POPQ":
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 POPQ expects dstReg: %q", ins.Raw)
-		}
-		v := c.popI64()
-		if err := c.storeReg(ins.Args[0].Reg, v); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-	case "PUSHFQ":
-		// Keep the historical amd64 stack-shape model. The 32-bit PUSHFL path
-		// above carries flags because 386 runtime asm consumes them.
-		c.pushI64("0")
-		return true, false, nil
-	case "POPFQ":
-		_ = c.popI64()
-		return true, false, nil
-	case "LFENCE", "MFENCE", "SFENCE", "PAUSE":
-		if c.goarch == "386" {
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", strings.ToLower(string(op)), "~{memory}")
-		}
-		return true, false, nil
-	case "PREFETCHNTA", "EMMS":
-		// Prefetch does not change SSA-visible values. MMX registers are modeled
-		// as ordinary integers, so there is no hardware x87 tag state to clear.
 		return true, false, nil
+	case "EMMS":
+		// A closed native MMX region owns its actual EMMS before generic
+		// dispatch. Never turn an unbound physical tag-state operation into
+		// a successful logical-register no-op.
+		return true, false, fmt.Errorf("%w: EMMS needs its source-bound native MMX/x87 continuation", ErrProbeNeedsContext)
 	case "UNDEF":
-		if c.goarch == "386" {
-			c.emitX86Trap()
-			return true, true, nil
-		}
-		// Preserve the historical amd64 approximation.
-		return true, false, nil
-	case "RDTSC":
-		if c.goarch == "386" {
-			if len(ins.Args) != 0 {
-				return true, false, fmt.Errorf("386 RDTSC takes no operands: %q", ins.Raw)
-			}
-			return true, false, c.lower386Timestamp(false)
-		}
-		if err := c.storeReg(AX, "0"); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(DX, "0"); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-	case OpCPUID:
-		eax64, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		ecx64, err := c.loadReg(CX)
-		if err != nil {
-			return true, false, err
-		}
-		eax32 := c.newTmp()
-		ecx32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", eax32, eax64)
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", ecx32, ecx64)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call { i32, i32, i32, i32 } asm sideeffect \"cpuid\", \"={ax},={bx},={cx},={dx},{ax},{cx},~{dirflag},~{fpsr},~{flags}\"(i32 %%%s, i32 %%%s)\n", call, eax32, ecx32)
-		storeOut := func(idx int, reg Reg) error {
-			part := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue { i32, i32, i32, i32 } %%%s, %d\n", part, call, idx)
-			wide := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, part)
-			return c.storeReg(reg, "%"+wide)
-		}
-		if err := storeOut(0, AX); err != nil {
-			return true, false, err
-		}
-		if err := storeOut(1, BX); err != nil {
-			return true, false, err
-		}
-		if err := storeOut(2, CX); err != nil {
-			return true, false, err
-		}
-		if err := storeOut(3, DX); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-	case OpXGETBV:
-		ecx64, err := c.loadReg(CX)
-		if err != nil {
-			return true, false, err
-		}
-		ecx32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", ecx32, ecx64)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call { i32, i32 } asm sideeffect \"xgetbv\", \"={ax},={dx},{cx},~{dirflag},~{fpsr},~{flags}\"(i32 %%%s)\n", call, ecx32)
-		storeOut := func(idx int, reg Reg) error {
-			part := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue { i32, i32 } %%%s, %d\n", part, call, idx)
-			wide := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, part)
-			return c.storeReg(reg, "%"+wide)
-		}
-		if err := storeOut(0, AX); err != nil {
-			return true, false, err
-		}
-		if err := storeOut(1, DX); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-	case "RDTSCP":
-		if c.goarch == "386" {
-			if len(ins.Args) != 0 {
-				return true, false, fmt.Errorf("386 RDTSCP takes no operands: %q", ins.Raw)
-			}
-			return true, false, c.lower386Timestamp(true)
-		}
-		if err := c.storeReg(AX, "0"); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(DX, "0"); err != nil {
-			return true, false, err
+		return c.lowerX86UndefinedTrap(op, ins)
+	case "RDTSC", "RDTSCP":
+		return c.lowerX86Timestamp(op, ins)
+	case "RDPID":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 1 || ins.Args[0].Kind != OpReg || !isAMD64YrlRegister(ins.Args[0].Reg) {
+			return true, false, fmt.Errorf("%s RDPID expects one general register with no suffix: %q", c.goarch, ins.Raw)
 		}
-		if err := c.storeReg(CX, "0"); err != nil {
-			return true, false, err
+		if c.goarch == "386" && amd64IsExtendedGPRegister(ins.Args[0].Reg) {
+			return true, false, fmt.Errorf("386 RDPID destination is outside the 386 register file: %q", ins.Raw)
 		}
-		return true, false, nil
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.rdpid()\n", value)
+		return true, false, c.storeRegSized(ins.Args[0].Reg, I32, "%"+value)
 	case "MOVSB":
 		si, err := c.loadReg(SI)
 		if err != nil {
@@ -424,101 +428,25 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 			return true, false, err
 		}
 		return true, false, nil
-	case "NEGL":
-		// 32-bit negate with x86 semantics: write back low 32 bits and zero-extend.
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 NEGL expects dst: %q", ins.Raw)
-		}
-		switch ins.Args[0].Kind {
-		case OpReg:
-			dv, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			t32 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t32, dv)
-			neg := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i32 0, %%%s\n", neg, t32)
-			cf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", cf, t32)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-			z := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, neg)
-			if err := c.storeReg(ins.Args[0].Reg, "%"+z); err != nil {
-				return true, false, err
-			}
-			c.setZSFlagsFromI32("%" + neg)
-			return true, false, nil
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", ld, p)
-			neg := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i32 0, %%%s\n", neg, ld)
-			cf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", cf, ld)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-			fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s, align 1\n", neg, p)
-			c.setZSFlagsFromI32("%" + neg)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 NEGL expects reg/mem dst: %q", ins.Raw)
-		}
-	case "RCRQ":
-		// Rotate through carry right (count=1) used by runtime time division path.
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm {
-			return true, false, fmt.Errorf("amd64 RCRQ expects $count, dstReg: %q", ins.Raw)
-		}
-		if ins.Args[0].Imm != 1 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 RCRQ currently supports $1, reg: %q", ins.Raw)
-		}
-		dv, err := c.loadReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		oldCF := c.loadFlag(c.flagsCFSlot)
-		lsb := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 1\n", lsb, dv)
-		newCF := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", newCF, lsb)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", newCF, c.flagsCFSlot)
-		shr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 1\n", shr, dv)
-		cf64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", cf64, oldCF)
-		cfhi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 63\n", cfhi, cf64)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", out, shr, cfhi)
-		if err := c.storeReg(ins.Args[1].Reg, "%"+out); err != nil {
-			return true, false, err
-		}
-		c.setZSFlagsFromI64("%" + out)
-		return true, false, nil
-
 	case "ADDQ", "SUBQ", "XORQ", "ANDQ", "ORQ":
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
 		}
-		src, err := c.evalI64(ins.Args[0])
+		src, destination, err := c.evalScalarArithmeticSource(ins, I64)
 		if err != nil {
 			return true, false, err
 		}
 		loadDst := func() (string, func(string) error, error) {
-			switch ins.Args[1].Kind {
+			switch destination.Kind {
 			case OpReg:
-				dst := ins.Args[1].Reg
+				dst := destination.Reg
 				dv, err := c.loadReg(dst)
 				if err != nil {
 					return "", nil, err
 				}
 				return dv, func(v string) error { return c.storeReg(dst, v) }, nil
 			case OpMem:
-				addr, err := c.addrFromMem(ins.Args[1].Mem)
+				addr, err := c.addrFromMem(destination.Mem)
 				if err != nil {
 					return "", nil, err
 				}
@@ -566,244 +494,25 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		default:
 			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
 		}
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-		c.setZSFlagsFromI64(r)
-		return true, false, nil
-
-	case "ADCL", "SBBL":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
-		}
-		src, err := c.evalIntSized(ins.Args[0], I32)
-		if err != nil {
-			return true, false, err
-		}
-		dst, storeDst, err := c.loadIntDestination(ins.Args[1], I32)
-		if err != nil {
-			return true, false, err
-		}
-		carry := c.loadFlag(c.flagsCFSlot)
-		carry64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", carry64, carry)
-		src64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", src64, src)
-		dst64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", dst64, dst)
-		result64 := c.newTmp()
-		if op == "ADCL" {
-			partial := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", partial, dst64, src64)
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", result64, partial, carry64)
-		} else {
-			partial := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", partial, src64, carry64)
-			fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, %%%s\n", result64, dst64, partial)
-		}
-		result := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", result, result64)
-		if err := storeDst("%" + result); err != nil {
-			return true, false, err
-		}
-		newCarry := c.newTmp()
-		if op == "ADCL" {
-			fmt.Fprintf(c.b, "  %%%s = icmp ugt i64 %%%s, 4294967295\n", newCarry, result64)
+		if op == "ADDQ" || op == "SUBQ" {
+			xorOperands := c.newTmp()
+			xorResult := c.newTmp()
+			overflowBits := c.newTmp()
+			overflow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", xorOperands, dv, src)
+			if op == "ADDQ" {
+				inverted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = xor i64 %%%s, -1\n", inverted, xorOperands)
+				xorOperands = inverted
+			}
+			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", xorResult, dv, r)
+			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %%%s\n", overflowBits, xorOperands, xorResult)
+			fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %%%s, 0\n", overflow, overflowBits)
+			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", overflow, c.flagsOFSlot)
 		} else {
-			subtrahend := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", subtrahend, src64, carry64)
-			fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %%%s\n", newCarry, dst64, subtrahend)
-		}
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", newCarry, c.flagsCFSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-		c.setZSFlagsFromI32("%" + result)
-		return true, false, nil
-
-	case "ADCQ", "SBBQ":
-		// Add/subtract with carry/borrow: src, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		cfIn := c.loadFlag(c.flagsCFSlot)
-		cf64t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", cf64t, cfIn)
-		cf64 := "%" + cf64t
-
-		dv128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", dv128, dv)
-		src128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", src128, src)
-		cf128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", cf128, cf64)
-
-		if op == "ADCQ" {
-			sum := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", sum, dv, src)
-			res := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %s\n", res, sum, cf64)
-			out := "%" + res
-			if err := c.storeReg(dst, out); err != nil {
-				return true, false, err
-			}
-
-			total1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i128 %%%s, %%%s\n", total1, dv128, src128)
-			total2 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i128 %%%s, %%%s\n", total2, total1, cf128)
-			cf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp ugt i128 %%%s, 18446744073709551615\n", cf, total2)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
 			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-			c.setZSFlagsFromI64(out)
-			return true, false, nil
-		}
-
-		subtr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i128 %%%s, %%%s\n", subtr, src128, cf128)
-		borrow := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i128 %%%s, %%%s\n", borrow, dv128, subtr)
-		res := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %s\n", res, dv, src)
-		res2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, %s\n", res2, res, cf64)
-		out := "%" + res2
-		if err := c.storeReg(dst, out); err != nil {
-			return true, false, err
-		}
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", borrow, c.flagsCFSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-		c.setZSFlagsFromI64(out)
-		return true, false, nil
-
-	case "ADCB":
-		// 8-bit add with carry: src, dstReg/mem.
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
-		}
-		var d8 string
-		var storeDst func(string) error
-		switch ins.Args[1].Kind {
-		case OpReg:
-			dst := ins.Args[1].Reg
-			dv64, err := c.loadReg(dst)
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", t, dv64)
-			d8 = "%" + t
-			storeDst = func(v8 string) error {
-				return c.storeRegSized(dst, I8, v8)
-			}
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[1].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s, align 1\n", ld, p)
-			d8 = "%" + ld
-			storeDst = func(v8 string) error {
-				fmt.Fprintf(c.b, "  store i8 %s, ptr %s, align 1\n", v8, p)
-				return nil
-			}
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects reg/mem dst: %q", op, ins.Raw)
-		}
-
-		s8, err := c.evalIntSized(ins.Args[0], I8)
-		if err != nil {
-			return true, false, err
-		}
-		cfIn := c.loadFlag(c.flagsCFSlot)
-		cf8t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i8\n", cf8t, cfIn)
-		cf8 := "%" + cf8t
-
-		sum := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i8 %s, %s\n", sum, d8, s8)
-		res := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i8 %%%s, %s\n", res, sum, cf8)
-		out8 := "%" + res
-		if err := storeDst(out8); err != nil {
-			return true, false, err
-		}
-
-		d16 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i8 %s to i16\n", d16, d8)
-		s16 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i8 %s to i16\n", s16, s8)
-		cf16 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i8 %s to i16\n", cf16, cf8)
-		total1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i16 %%%s, %%%s\n", total1, d16, s16)
-		total2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i16 %%%s, %%%s\n", total2, total1, cf16)
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ugt i16 %%%s, 255\n", cf, total2)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-		zf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i8 %%%s, 0\n", zf, res)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-		sf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp slt i8 %%%s, 0\n", sf, res)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sf, c.flagsSltSlot)
-		return true, false, nil
-
-	case "ADCXQ", "ADOXQ":
-		// BMI2 add-with-carry chains.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		carryIn := c.loadFlag(c.flagsCFSlot)
-		flagOut := c.flagsCFSlot
-		if op == "ADOXQ" {
-			carryIn = c.loadFlag(c.flagsOFSlot)
-			flagOut = c.flagsOFSlot
-		}
-		cf64t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", cf64t, carryIn)
-		cf64 := "%" + cf64t
-		sum := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", sum, dv, src)
-		res := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %s\n", res, sum, cf64)
-		out := "%" + res
-		if err := c.storeReg(dst, out); err != nil {
-			return true, false, err
 		}
-		dv128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", dv128, dv)
-		src128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", src128, src)
-		cf128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", cf128, cf64)
-		total1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i128 %%%s, %%%s\n", total1, dv128, src128)
-		total2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i128 %%%s, %%%s\n", total2, total1, cf128)
-		carry := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ugt i128 %%%s, 18446744073709551615\n", carry, total2)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, flagOut)
-		// ADCX/ADOX do not define ZF/SF in the same way as ADD; keep current bits.
+		c.setZSFlagsFromI64(r)
 		return true, false, nil
 
 	case "ADDL", "SUBL", "XORL", "ANDL", "ORL":
@@ -811,11 +520,11 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
 		}
-		s32, err := c.evalIntSized(ins.Args[0], I32)
+		s32, destination, err := c.evalScalarArithmeticSource(ins, I32)
 		if err != nil {
 			return true, false, err
 		}
-		dtr, storeDst, err := c.loadIntDestination(ins.Args[1], I32)
+		dtr, storeDst, err := c.loadIntDestination(destination, I32)
 		if err != nil {
 			return true, false, err
 		}
@@ -857,11 +566,11 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
 		}
-		d8, storeDst, err := c.loadIntDestination(ins.Args[1], I8)
+		s8, destination, err := c.evalScalarArithmeticSource(ins, I8)
 		if err != nil {
 			return true, false, err
 		}
-		s8, err := c.evalIntSized(ins.Args[0], I8)
+		d8, storeDst, err := c.loadIntDestination(destination, I8)
 		if err != nil {
 			return true, false, err
 		}
@@ -923,17 +632,18 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		sf := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = icmp slt i8 %%%s, 0\n", sf, x)
 		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sf, c.flagsSltSlot)
+		c.setParityFlagSized(I8, "%"+x)
 		return true, false, nil
 
 	case "ANDW", "ORW", "XORW", "ADDW", "SUBW":
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
 		}
-		src, err := c.evalIntSized(ins.Args[0], I16)
+		src, destination, err := c.evalScalarArithmeticSource(ins, I16)
 		if err != nil {
 			return true, false, err
 		}
-		dst, storeDst, err := c.loadIntDestination(ins.Args[1], I16)
+		dst, storeDst, err := c.loadIntDestination(destination, I16)
 		if err != nil {
 			return true, false, err
 		}
@@ -977,120 +687,37 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
 		}
 		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+		c.setParityFlagSized(I16, "%"+out)
 		return true, false, nil
 
-	case "INCQ", "DECQ":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 %s expects dst: %q", op, ins.Raw)
+	case "LEAW", "LEAL", "LEAQ":
+		// All three widths use Go 1.27's sole ym_rl row: an addressable
+		// memory expression and an in-range general-register destination.
+		if ins.Op != "" && Op(strings.ToUpper(string(ins.Op))) != op {
+			return true, false, fmt.Errorf("%s LEA dispatch %q disagrees with instruction %q", c.goarch, op, ins.Op)
 		}
-		var v string
-		var storeDst func(string) error
-		switch ins.Args[0].Kind {
-		case OpReg:
-			r := ins.Args[0].Reg
-			dv, err := c.loadReg(r)
-			if err != nil {
-				return true, false, err
-			}
-			v = dv
-			storeDst = func(out string) error { return c.storeReg(r, out) }
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-			v = "%" + ld
-			storeDst = func(out string) error {
-				fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", out, p)
-				return nil
-			}
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects reg/mem dst: %q", op, ins.Raw)
-		}
-		t := c.newTmp()
-		if op == "INCQ" {
-			fmt.Fprintf(c.b, "  %%%s = add i64 %s, 1\n", t, v)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = sub i64 %s, 1\n", t, v)
-		}
-		out := "%" + t
-		if err := storeDst(out); err != nil {
-			return true, false, err
-		}
-		c.setZSFlagsFromI64(out)
-		return true, false, nil
-
-	case "INCL", "DECL":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 %s expects dst: %q", op, ins.Raw)
-		}
-		var v64 string
-		var storeDst func(string) error
-		switch ins.Args[0].Kind {
-		case OpReg:
-			r := ins.Args[0].Reg
-			dv, err := c.loadReg(r)
-			if err != nil {
-				return true, false, err
-			}
-			v64 = dv
-			storeDst = func(out32 string) error {
-				z := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", z, out32)
-				return c.storeReg(r, "%"+z)
-			}
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", ld, p)
-			v64 = "%" + ld
-			storeDst = func(out32 string) error {
-				fmt.Fprintf(c.b, "  store i32 %s, ptr %s, align 1\n", out32, p)
-				return nil
-			}
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects reg/mem dst: %q", op, ins.Raw)
-		}
-		tr := c.newTmp()
-		if ins.Args[0].Kind == OpMem {
-			fmt.Fprintf(c.b, "  %%%s = add i32 0, %s\n", tr, v64)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, v64)
-		}
-		x := c.newTmp()
-		if op == "INCL" {
-			fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, 1\n", x, tr)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, 1\n", x, tr)
-		}
-		if err := storeDst("%" + x); err != nil {
-			return true, false, err
-		}
-		c.setZSFlagsFromI32("%" + x)
-		return true, false, nil
-
-	case "LEAQ", "LEAL":
-		// LEA{Q,L} srcAddr, dstReg
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects srcAddr, dstReg: %q", op, ins.Raw)
+		// Internal helpers may omit Instr.Op. Bind only this local copy so
+		// grammar validation and destination emission use one identity; the
+		// original source/caller instruction remains independently required.
+		ins.Op = op
+		ins = x86LEASourceInstruction(ins)
+		if _, err := x86LEAOperandWidth(ins, c.goarch); err != nil {
+			return true, false, err
 		}
 		dst := ins.Args[1].Reg
 		storeLEA := func(addr string) error {
-			if op == "LEAL" {
+			switch op {
+			case "LEAW":
+				t := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i16\n", t, addr)
+				return c.storeRegSized(dst, I16, "%"+t)
+			case "LEAL":
 				t := c.newTmp()
 				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t, addr)
-				z := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, t)
-				return c.storeReg(dst, "%"+z)
+				return c.storeRegSized(dst, I32, "%"+t)
+			default:
+				return c.storeRegSized(dst, I64, addr)
 			}
-			return c.storeReg(dst, addr)
 		}
 		switch ins.Args[0].Kind {
 		case OpMem:
@@ -1098,46 +725,24 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 			if err != nil {
 				return true, false, err
 			}
+			if bits := ins.x86AddressBits; bits != 0 {
+				// Address size is independent of the result register width.
+				// Narrow the complete sum first, then zero-extend that effective
+				// offset before W/L/Q destination preservation/extension.
+				typ := I32
+				if bits == 16 {
+					typ = I16
+				}
+				low := c.truncI64(addr, typ)
+				wide := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, typ, low)
+				addr = "%" + wide
+			}
 			return true, false, storeLEA(addr)
 		case OpFP:
-			if c.classicFrame != "" {
-				c.markFPResultAddrTaken(ins.Args[0].FPOffset)
-				addr := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", addr, c.classicFramePtr(ins.Args[0].FPOffset))
-				return true, false, storeLEA("%" + addr)
-			}
-			// LEA of a return slot, e.g. "LEAQ ret+32(FP), R8".
-			alloca, _, ok := c.fpResultAlloca(ins.Args[0].FPOffset)
-			if ok {
-				c.markFPResultAddrTaken(ins.Args[0].FPOffset)
-				t := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, alloca)
-				return true, false, storeLEA("%" + t)
-			}
-			// Fallback: treat FP slot value as pointer-like integer address.
-			v, err := c.evalFPToI64(ins.Args[0].FPOffset)
+			v, err := c.boundFPAddress(ins.Args[0].FPOffset)
 			if err != nil {
-				v = "0"
-			}
-			return true, false, storeLEA(v)
-		case OpFPAddr:
-			if c.classicFrame != "" {
-				c.markFPResultAddrTaken(ins.Args[0].FPOffset)
-				addr := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", addr, c.classicFramePtr(ins.Args[0].FPOffset))
-				return true, false, storeLEA("%" + addr)
-			}
-			// Address of a return slot alloca.
-			alloca, _, ok := c.fpResultAlloca(ins.Args[0].FPOffset)
-			if ok {
-				c.markFPResultAddrTaken(ins.Args[0].FPOffset)
-				t := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, alloca)
-				return true, false, storeLEA("%" + t)
-			}
-			v, err := c.evalFPToI64(ins.Args[0].FPOffset)
-			if err != nil {
-				v = "0"
+				return true, false, err
 			}
 			return true, false, storeLEA(v)
 		case OpSym:
@@ -1152,1312 +757,6 @@ func (c *amd64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 			return true, false, fmt.Errorf("amd64 %s unsupported src: %q", op, ins.Raw)
 		}
 
-	case "POPCNTL", "POPCNTQ":
-		// POPCNT{L,Q} src, dstReg accepts the same register-or-memory source
-		// family as the Go x86 assembler.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-		}
-		validFullReg := func(r Reg) bool {
-			if _, _, ok := amd64ByteAlias(r); ok || r == FS || r == GS {
-				return false
-			}
-			_, ok := amd64FullRegBase(r)
-			return ok
-		}
-		if !validFullReg(ins.Args[1].Reg) {
-			return false, false, nil
-		}
-		src := ins.Args[0]
-		switch src.Kind {
-		case OpReg:
-			if !validFullReg(src.Reg) {
-				return false, false, nil
-			}
-		case OpMem, OpFP:
-		case OpSym:
-			if strings.HasPrefix(strings.TrimSpace(src.Sym), "$") {
-				return false, false, nil
-			}
-		default:
-			return false, false, nil
-		}
-		if op == "POPCNTL" {
-			srcv, err := c.evalIntSized(src, I32)
-			if err != nil {
-				return true, false, err
-			}
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.ctpop.i32(i32 %s)\n", call, srcv)
-			z := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-			return true, false, c.storeReg(ins.Args[1].Reg, "%"+z)
-		}
-		srcv, err := c.evalIntSized(src, I64)
-		if err != nil {
-			return true, false, err
-		}
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.ctpop.i64(i64 %s)\n", call, srcv)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+call)
-
-	case "TZCNTQ":
-		// TZCNTQ srcReg, dstReg.
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 TZCNTQ expects srcReg, dstReg: %q", ins.Raw)
-		}
-		srcv, err := c.loadReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.cttz.i64(i64 %s, i1 false)\n", call, srcv)
-		if err := c.storeReg(ins.Args[1].Reg, "%"+call); err != nil {
-			return true, false, err
-		}
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", cf, srcv)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		c.setZSFlagsFromI64("%" + call)
-		return true, false, nil
-
-	case "BSFW", "BSRW":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.evalIntSized(ins.Args[0], I16)
-		if err != nil {
-			return true, false, err
-		}
-		zf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i16 %s, 0\n", zf, src)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-		ext := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i16 %s to i32\n", ext, src)
-		var result string
-		if op == "BSFW" {
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.cttz.i32(i32 %%%s, i1 false)\n", call, ext)
-			result = "%" + call
-		} else {
-			clz := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.ctlz.i32(i32 %%%s, i1 false)\n", clz, ext)
-			sub := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i32 31, %%%s\n", sub, clz)
-			result = "%" + sub
-		}
-		tr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", tr, result)
-		return true, false, c.storeRegSized(ins.Args[1].Reg, I16, "%"+tr)
-
-	case "BSFQ", "BSRQ", "BSWAPQ", "BSFL", "BSRL":
-		// Bit scans accept register or memory sources. BSWAPQ is register-only.
-		sv := ""
-		dst := Reg("")
-		switch len(ins.Args) {
-		case 1:
-			if op != "BSWAPQ" || ins.Args[0].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 %s expects reg or srcReg,dstReg: %q", op, ins.Raw)
-			}
-			dst = ins.Args[0].Reg
-			var err error
-			sv, err = c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-		case 2:
-			if op == "BSWAPQ" || ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-			}
-			dst = ins.Args[1].Reg
-			srcType := I64
-			if op == "BSFL" || op == "BSRL" {
-				srcType = I32
-			}
-			var err error
-			sv, err = c.evalIntSized(ins.Args[0], srcType)
-			if err != nil {
-				return true, false, err
-			}
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects 1 or 2 operands: %q", op, ins.Raw)
-		}
-		switch op {
-		case "BSFQ":
-			// ZF is set when src == 0.
-			zf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", zf, sv)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-			// dst = cttz(src). Use non-poison form for src==0.
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.cttz.i64(i64 %s, i1 false)\n", call, sv)
-			return true, false, c.storeReg(dst, "%"+call)
-		case "BSRQ":
-			// ZF is set when src == 0.
-			zf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", zf, sv)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-			// dst = 63 - ctlz(src). Use non-poison form for src==0.
-			clz := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.ctlz.i64(i64 %s, i1 false)\n", clz, sv)
-			sub := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i64 63, %%%s\n", sub, clz)
-			return true, false, c.storeReg(dst, "%"+sub)
-		case "BSWAPQ":
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.bswap.i64(i64 %s)\n", call, sv)
-			return true, false, c.storeReg(dst, "%"+call)
-		case "BSFL":
-			// ZF is set when the 32-bit source is zero.
-			zf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", zf, sv)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-			// dst = zext(cttz(src)). Use non-poison form for src==0.
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.cttz.i32(i32 %s, i1 false)\n", call, sv)
-			z := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-			return true, false, c.storeReg(dst, "%"+z)
-		case "BSRL":
-			// ZF is set when the 32-bit source is zero.
-			zf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", zf, sv)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-			// dst = zext(31 - ctlz(src)). Use non-poison form for src==0.
-			clz := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.ctlz.i32(i32 %s, i1 false)\n", clz, sv)
-			sub := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i32 31, %%%s\n", sub, clz)
-			z := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, sub)
-			return true, false, c.storeReg(dst, "%"+z)
-		}
-		return true, false, fmt.Errorf("amd64: unsupported bit op %s", op)
-
-	case "SETEQ", "SETLT", "SETGT", "SETGE", "SETHI", "SETCS":
-		// SETcc dst: set byte based on flags.
-		// Register, memory, and FP result destinations all occur in Go's x86
-		// assembly sources.
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 %s expects one destination: %q", op, ins.Raw)
-		}
-		cond := ""
-		switch op {
-		case "SETEQ":
-			cond = c.loadFlag(c.flagsZSlot)
-		case "SETLT":
-			cond = c.loadFlag(c.flagsSltSlot)
-		case "SETGT":
-			// signed >
-			slt := c.loadFlag(c.flagsSltSlot)
-			z := c.loadFlag(c.flagsZSlot)
-			t1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t1, slt, z)
-			t2 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", t2, t1)
-			cond = "%" + t2
-		case "SETGE":
-			slt := c.loadFlag(c.flagsSltSlot)
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, slt)
-			cond = "%" + t
-		case "SETHI":
-			// unsigned >
-			cf := c.loadFlag(c.flagsCFSlot)
-			z := c.loadFlag(c.flagsZSlot)
-			t1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t1, cf, z)
-			t2 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", t2, t1)
-			cond = "%" + t2
-		case "SETCS":
-			cond = c.loadFlag(c.flagsCFSlot)
-		}
-		switch ins.Args[0].Kind {
-		case OpReg:
-			sel := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i8 1, i8 0\n", sel, cond)
-			return true, false, c.storeRegSized(ins.Args[0].Reg, I8, "%"+sel)
-		case OpFP:
-			return true, false, c.storeFPResult(ins.Args[0].FPOffset, I1, cond)
-		case OpMem:
-			p, ptrType, err := c.ptrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			sel := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i8 1, i8 0\n", sel, cond)
-			fmt.Fprintf(c.b, "  store i8 %%%s, %s %s, align 1\n", sel, ptrType, p)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects reg, mem, or fp destination: %q", op, ins.Raw)
-		}
-
-	case "CMOVQEQ", "CMOVQNE", "CMOVQCS", "CMOVQCC", "CMOVQGT":
-		// Conditional move: src, dstReg
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dst := ins.Args[1].Reg
-		cur, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		cond := ""
-		switch op {
-		case "CMOVQEQ":
-			cond = c.loadFlag(c.flagsZSlot)
-		case "CMOVQNE":
-			z := c.loadFlag(c.flagsZSlot)
-			nz := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", nz, z)
-			cond = "%" + nz
-		case "CMOVQCS":
-			cond = c.loadFlag(c.flagsCFSlot)
-		case "CMOVQCC":
-			cf := c.loadFlag(c.flagsCFSlot)
-			nc := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", nc, cf)
-			cond = "%" + nc
-		case "CMOVQGT":
-			slt := c.loadFlag(c.flagsSltSlot)
-			z := c.loadFlag(c.flagsZSlot)
-			t1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t1, slt, z)
-			t2 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", t2, t1)
-			cond = "%" + t2
-		}
-		sel := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", sel, cond, src, cur)
-		return true, false, c.storeReg(dst, "%"+sel)
-
-	case "ANDNL", "ANDNQ":
-		// BMI1 ANDN: dst = ~src2 & src1
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src1, src2, dstReg: %q", op, ins.Raw)
-		}
-		src1, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		src2, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dst := ins.Args[2].Reg
-		if op == "ANDNQ" {
-			n := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, -1\n", n, src2)
-			a := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %s\n", a, n, src1)
-			return true, false, c.storeReg(dst, "%"+a)
-		}
-		s1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", s1, src1)
-		s2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", s2, src2)
-		n := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i32 %%%s, -1\n", n, s2)
-		a := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %%%s\n", a, n, s1)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, a)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "BEXTRQ":
-		// BMI1 bit field extract: control, src, dst.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 BEXTRQ expects control, src, dstReg: %q", ins.Raw)
-		}
-		ctrl, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		src, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		start := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 255\n", start, ctrl)
-		lenShift := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 8\n", lenShift, ctrl)
-		length := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 255\n", length, lenShift)
-		startOK := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, 64\n", startOK, start)
-		safeStart := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 63\n", safeStart, startOK, start)
-		shifted := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %%%s\n", shifted, src, safeStart)
-		rawLen := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 0\n", rawLen, startOK, length)
-		remain := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 64, %%%s\n", remain, safeStart)
-		useRawLen := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %%%s\n", useRawLen, rawLen, remain)
-		effLen := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %%%s\n", effLen, useRawLen, rawLen, remain)
-		isFull := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, 64\n", isFull, effLen)
-		safeLen := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", safeLen, effLen)
-		one := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 1, %%%s\n", one, safeLen)
-		maskTmp := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, -1\n", maskTmp, one)
-		mask := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 -1, i64 %%%s\n", mask, isFull, maskTmp)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %%%s\n", out, shifted, mask)
-		return true, false, c.storeReg(ins.Args[2].Reg, "%"+out)
-
-	case "BZHIQ":
-		// BMI2 zero high bits: index, src, dst.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 BZHIQ expects index, src, dstReg: %q", ins.Raw)
-		}
-		idx, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		src, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		valid := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, 64\n", valid, idx)
-		isZero := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", isZero, idx)
-		safeIdx := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 63\n", safeIdx, idx)
-		one := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 1, %%%s\n", one, safeIdx)
-		maskTmp := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, -1\n", maskTmp, one)
-		maskOrZero := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 0, i64 %%%s\n", maskOrZero, isZero, maskTmp)
-		mask := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 -1\n", mask, valid, maskOrZero)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %%%s\n", out, src, mask)
-		return true, false, c.storeReg(ins.Args[2].Reg, "%"+out)
-
-	case "SHRQ", "SHLQ", "SARQ", "SHLL", "SHRL", "SARL", "SALQ", "SALL":
-		// Shift ops:
-		// - 2-operand: amt, dst (in-place)
-		// - 3-operand SHL/SHR: amt, src, dst (x86 SHLD/SHRD)
-		if len(ins.Args) == 3 {
-			switch op {
-			case "SHLL", "SHLQ", "SHRL", "SHRQ":
-				return true, false, c.lowerDoubleShift(op, ins)
-			default:
-				return true, false, fmt.Errorf("amd64 %s has no three-operand form: %q", op, ins.Raw)
-			}
-		}
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects amt,dst: %q", op, ins.Raw)
-		}
-		if ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s destination must be reg: %q", op, ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		amtMask := int64(63)
-		valTy := I64
-		if op == "SHLL" || op == "SHRL" || op == "SARL" || op == "SALL" {
-			amtMask = 31
-			valTy = I32
-		}
-		amtI64 := ""
-		switch ins.Args[0].Kind {
-		case OpImm:
-			amtI64 = fmt.Sprintf("%d", ins.Args[0].Imm&amtMask)
-		case OpReg:
-			av, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", m, av, amtMask)
-			amtI64 = "%" + m
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported shift amt: %q", op, ins.Raw)
-		}
-
-		if valTy == I64 {
-			t := c.newTmp()
-			switch op {
-			case "SHRQ":
-				fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %s\n", t, dv, amtI64)
-			case "SHLQ", "SALQ":
-				fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %s\n", t, dv, amtI64)
-			case "SARQ":
-				fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, %s\n", t, dv, amtI64)
-			}
-			return true, false, c.storeReg(dst, "%"+t)
-		}
-
-		// 32-bit shifts: operate on low 32, zero-extend to 64.
-		tr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, dv)
-		amt32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", amt32, amtI64)
-		sh := c.newTmp()
-		if op == "SHLL" || op == "SALL" {
-			fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %%%s\n", sh, tr, amt32)
-		} else if op == "SARL" {
-			fmt.Fprintf(c.b, "  %%%s = ashr i32 %%%s, %%%s\n", sh, tr, amt32)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = lshr i32 %%%s, %%%s\n", sh, tr, amt32)
-		}
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, sh)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "SHLW", "SHRW", "SARW", "SALW":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects amt, dstReg: %q", op, ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.evalIntSized(ins.Args[1], I16)
-		if err != nil {
-			return true, false, err
-		}
-		var amt string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			amt = fmt.Sprintf("%d", ins.Args[0].Imm&31)
-		case OpReg:
-			av, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			masked := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 31\n", masked, av)
-			amt = "%" + masked
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported shift amt: %q", op, ins.Raw)
-		}
-		inRange := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, 16\n", inRange, amt)
-		safeAmt := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 15\n", safeAmt, inRange, amt)
-		amt16 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i16\n", amt16, safeAmt)
-		shifted := c.newTmp()
-		switch op {
-		case "SHLW", "SALW":
-			fmt.Fprintf(c.b, "  %%%s = shl i16 %s, %%%s\n", shifted, dv, amt16)
-		case "SARW":
-			fmt.Fprintf(c.b, "  %%%s = ashr i16 %s, %%%s\n", shifted, dv, amt16)
-		case "SHRW":
-			fmt.Fprintf(c.b, "  %%%s = lshr i16 %s, %%%s\n", shifted, dv, amt16)
-		}
-		result := "%" + shifted
-		if op != "SARW" {
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %%%s, i16 0\n", out, inRange, shifted)
-			result = "%" + out
-		}
-		return true, false, c.storeRegSized(dst, I16, result)
-
-	case "SHLB":
-		// 8-bit logical left shift: amt, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 SHLB expects amt, dstReg: %q", ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv64, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		d8 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", d8, dv64)
-		var amt string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			amt = fmt.Sprintf("%d", ins.Args[0].Imm&31)
-		case OpReg:
-			av, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 31\n", m, av)
-			amt = "%" + m
-		default:
-			return true, false, fmt.Errorf("amd64 SHLB unsupported shift amt: %q", ins.Raw)
-		}
-		inRange := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, 8\n", inRange, amt)
-		safeAmt := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 7\n", safeAmt, inRange, amt)
-		amt8 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i8\n", amt8, safeAmt)
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i8 %%%s, %%%s\n", sh, d8, amt8)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i8 %%%s, i8 0\n", out, inRange, sh)
-		return true, false, c.storeRegSized(dst, I8, "%"+out)
-
-	case "SHLXQ", "SHRXQ":
-		// BMI2 variable shifts: amt, src, dst.
-		if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects amt, srcReg, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.loadReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		var amt string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			amt = fmt.Sprintf("%d", ins.Args[0].Imm&63)
-		case OpReg:
-			av, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 63\n", m, av)
-			amt = "%" + m
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported shift amt: %q", op, ins.Raw)
-		}
-		t := c.newTmp()
-		if op == "SHLXQ" {
-			fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %s\n", t, src, amt)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %s\n", t, src, amt)
-		}
-		return true, false, c.storeReg(ins.Args[2].Reg, "%"+t)
-
-	case "ROLL":
-		// 32-bit rotate-left: count, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 ROLL expects count, dstReg: %q", ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv64, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		dv32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", dv32, dv64)
-
-		var cnt32 string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			cnt32 = fmt.Sprintf("%d", uint32(ins.Args[0].Imm))
-		case OpReg:
-			cv64, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			tr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, cv64)
-			cnt32 = "%" + tr
-		default:
-			return true, false, fmt.Errorf("amd64 ROLL unsupported count: %q", ins.Raw)
-		}
-
-		cm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %s, 31\n", cm, cnt32)
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i32 32, %%%s\n", neg, cm)
-		nm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", nm, neg)
-		lhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %%%s\n", lhs, dv32, cm)
-		rhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i32 %%%s, %%%s\n", rhs, dv32, nm)
-		rot := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", rot, lhs, rhs)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, rot)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "ROLQ":
-		// 64-bit rotate-left: count, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 ROLQ expects count, dstReg: %q", ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		var cnt string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			cnt = fmt.Sprintf("%d", uint64(ins.Args[0].Imm)&63)
-		case OpReg:
-			cv, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 63\n", m, cv)
-			cnt = "%" + m
-		default:
-			return true, false, fmt.Errorf("amd64 ROLQ unsupported count: %q", ins.Raw)
-		}
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 64, %s\n", neg, cnt)
-		nm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", nm, neg)
-		lhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %s\n", lhs, dv, cnt)
-		rhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %%%s\n", rhs, dv, nm)
-		rot := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", rot, lhs, rhs)
-		return true, false, c.storeReg(dst, "%"+rot)
-
-	case "RORQ":
-		// 64-bit rotate-right: count, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 RORQ expects count, dstReg: %q", ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		var cnt string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			cnt = fmt.Sprintf("%d", uint64(ins.Args[0].Imm)&63)
-		case OpReg:
-			cv, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 63\n", m, cv)
-			cnt = "%" + m
-		default:
-			return true, false, fmt.Errorf("amd64 RORQ unsupported count: %q", ins.Raw)
-		}
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 64, %s\n", neg, cnt)
-		nm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", nm, neg)
-		lhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %s\n", lhs, dv, cnt)
-		rhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %%%s\n", rhs, dv, nm)
-		rot := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", rot, lhs, rhs)
-		return true, false, c.storeReg(dst, "%"+rot)
-
-	case "RORL":
-		// 32-bit rotate-right: count, dstReg.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 RORL expects count, dstReg: %q", ins.Raw)
-		}
-		dst := ins.Args[1].Reg
-		dv64, err := c.loadReg(dst)
-		if err != nil {
-			return true, false, err
-		}
-		dv32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", dv32, dv64)
-		var cnt32 string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			cnt32 = fmt.Sprintf("%d", uint32(ins.Args[0].Imm)&31)
-		case OpReg:
-			cv64, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			tr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, cv64)
-			cm := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", cm, tr)
-			cnt32 = "%" + cm
-		default:
-			return true, false, fmt.Errorf("amd64 RORL unsupported count: %q", ins.Raw)
-		}
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i32 32, %s\n", neg, cnt32)
-		nm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", nm, neg)
-		lhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i32 %%%s, %s\n", lhs, dv32, cnt32)
-		rhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %%%s\n", rhs, dv32, nm)
-		rot := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", rot, lhs, rhs)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, rot)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "RORXL", "RORXQ":
-		// BMI2 rotate-right without flags:
-		// - RORXL $imm, srcReg, dstReg (32-bit)
-		// - RORXQ $imm, srcReg, dstReg (64-bit)
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, srcReg, dstReg: %q", op, ins.Raw)
-		}
-		src, err := c.loadReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		dst := ins.Args[2].Reg
-		if op == "RORXQ" {
-			n := uint64(ins.Args[0].Imm) & 63
-			neg := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i64 64, %d\n", neg, n)
-			nm := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", nm, neg)
-			lhs := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", lhs, src, n)
-			rhs := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %%%s\n", rhs, src, nm)
-			rot := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", rot, lhs, rhs)
-			return true, false, c.storeReg(dst, "%"+rot)
-		}
-		n := uint32(ins.Args[0].Imm) & 31
-		tr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, src)
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i32 32, %d\n", neg, n)
-		nm := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", nm, neg)
-		lhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i32 %%%s, %d\n", lhs, tr, n)
-		rhs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %%%s\n", rhs, tr, nm)
-		rot := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", rot, lhs, rhs)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, rot)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "NOTB":
-		// NOT does not modify flags. For a register operand, only the selected
-		// low byte is changed and the remaining register bits are preserved.
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 NOTB expects one operand: %q", ins.Raw)
-		}
-		switch ins.Args[0].Kind {
-		case OpReg:
-			r := ins.Args[0].Reg
-			v64, err := c.loadReg(r)
-			if err != nil {
-				return true, false, err
-			}
-			v8 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", v8, v64)
-			not := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i8 %%%s, -1\n", not, v8)
-			return true, false, c.storeRegSized(r, I8, "%"+not)
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			load := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s, align 1\n", load, p)
-			not := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i8 %%%s, -1\n", not, load)
-			fmt.Fprintf(c.b, "  store i8 %%%s, ptr %s, align 1\n", not, p)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 NOTB expects reg or mem: %q", ins.Raw)
-		}
-
-	case "NOTL":
-		// 32-bit bitwise NOT, result zero-extended to 64-bit.
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 NOTL expects reg: %q", ins.Raw)
-		}
-		r := ins.Args[0].Reg
-		v64, err := c.loadReg(r)
-		if err != nil {
-			return true, false, err
-		}
-		tr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, v64)
-		x := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i32 %%%s, -1\n", x, tr)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, x)
-		return true, false, c.storeReg(r, "%"+z)
-
-	case "NOTQ":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 NOTQ expects one operand: %q", ins.Raw)
-		}
-		switch ins.Args[0].Kind {
-		case OpReg:
-			r := ins.Args[0].Reg
-			v, err := c.loadReg(r)
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, -1\n", t, v)
-			return true, false, c.storeReg(r, "%"+t)
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i64 %%%s, -1\n", t, ld)
-			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s, align 1\n", t, p)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 NOTQ expects reg or mem: %q", ins.Raw)
-		}
-
-	case "BSWAPL":
-		// BSWAPL reg: byte swap low 32 bits and zero-extend result to i64.
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 BSWAPL expects reg: %q", ins.Raw)
-		}
-		r := ins.Args[0].Reg
-		v64, err := c.loadReg(r)
-		if err != nil {
-			return true, false, err
-		}
-		tr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, v64)
-		bswap := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.bswap.i32(i32 %%%s)\n", bswap, tr)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, bswap)
-		return true, false, c.storeReg(r, "%"+z)
-
-	case "MULQ":
-		// MULQ src: RDX:RAX = RAX * src (unsigned).
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 MULQ expects src: %q", ins.Raw)
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		ax, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		a128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", a128, ax)
-		b128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", b128, src)
-		p := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", p, a128, b128)
-		lo := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", lo, p)
-		hiShift := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", hiShift, p)
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", hi, hiShift)
-		if err := c.storeReg(AX, "%"+lo); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(DX, "%"+hi); err != nil {
-			return true, false, err
-		}
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", cf, hi)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		return true, false, nil
-
-	case "MULXQ":
-		// BMI2 MULXQ src, loDst, hiDst: {hi,lo} = RDX * src (unsigned).
-		if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 MULXQ expects src, loDst, hiDst: %q", ins.Raw)
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dx, err := c.loadReg(DX)
-		if err != nil {
-			return true, false, err
-		}
-		a128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", a128, dx)
-		b128 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", b128, src)
-		p := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", p, a128, b128)
-		lo := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", lo, p)
-		hiShift := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", hiShift, p)
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", hi, hiShift)
-		if err := c.storeReg(ins.Args[1].Reg, "%"+lo); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(ins.Args[2].Reg, "%"+hi); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-
-	case "MULL":
-		// MULL src: EDX:EAX = EAX * src (unsigned 32-bit)
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 MULL expects src: %q", ins.Raw)
-		}
-		src32, err := c.evalIntSized(ins.Args[0], I32)
-		if err != nil {
-			return true, false, err
-		}
-		ax64, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		ax32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", ax32, ax64)
-		az := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", az, ax32)
-		bz := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", bz, src32)
-		p := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", p, az, bz)
-		lo32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", lo32, p)
-		hiShift := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 32\n", hiShift, p)
-		hi32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi32, hiShift)
-		lo64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", lo64, lo32)
-		hi64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", hi64, hi32)
-		if err := c.storeReg(AX, "%"+lo64); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(DX, "%"+hi64); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-
-	case "DIVL":
-		// DIVL src: unsigned divide EDX:EAX by src; quotient->EAX remainder->EDX.
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("amd64 DIVL expects src: %q", ins.Raw)
-		}
-		src32, err := c.evalIntSized(ins.Args[0], I32)
-		if err != nil {
-			return true, false, err
-		}
-		ax64, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		dx64, err := c.loadReg(DX)
-		if err != nil {
-			return true, false, err
-		}
-		ax32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", ax32, ax64)
-		dx32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", dx32, dx64)
-		az := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", az, ax32)
-		dz := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", dz, dx32)
-		divisor := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", divisor, src32)
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", hi, dz)
-		dividend := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", dividend, hi, az)
-		q := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = udiv i64 %%%s, %%%s\n", q, dividend, divisor)
-		r := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = urem i64 %%%s, %%%s\n", r, dividend, divisor)
-		q32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", q32, q)
-		r32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", r32, r)
-		q64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", q64, q32)
-		r64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", r64, r32)
-		if err := c.storeReg(AX, "%"+q64); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(DX, "%"+r64); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-
-	case "IMULL", "IMUL3L":
-		// Signed 32-bit multiply. The one-operand form writes DX:AX; the two-
-		// and three-operand forms write the low word to their explicit dst.
-		switch len(ins.Args) {
-		case 1:
-			src, err := c.evalIntSized(ins.Args[0], I32)
-			if err != nil {
-				return true, false, err
-			}
-			ax, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, I32)
-			if err != nil {
-				return true, false, err
-			}
-			a64 := c.newTmp()
-			b64 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", a64, ax)
-			fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", b64, src)
-			product := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", product, a64, b64)
-			lo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", lo, product)
-			hiShift := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = ashr i64 %%%s, 32\n", hiShift, product)
-			hi := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi, hiShift)
-			if err := c.storeRegSized(AX, I32, "%"+lo); err != nil {
-				return true, false, err
-			}
-			return true, false, c.storeRegSized(DX, I32, "%"+hi)
-		case 2:
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 IMULL expects src, dstReg: %q", ins.Raw)
-			}
-			src, err := c.evalIntSized(ins.Args[0], I32)
-			if err != nil {
-				return true, false, err
-			}
-			dst, err := c.evalIntSized(ins.Args[1], I32)
-			if err != nil {
-				return true, false, err
-			}
-			product := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, dst, src)
-			return true, false, c.storeRegSized(ins.Args[1].Reg, I32, "%"+product)
-		case 3:
-			if op != "IMUL3L" || ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 %s expects imm, src, dstReg: %q", op, ins.Raw)
-			}
-			a, err := c.evalIntSized(ins.Args[0], I32)
-			if err != nil {
-				return true, false, err
-			}
-			bv, err := c.evalIntSized(ins.Args[1], I32)
-			if err != nil {
-				return true, false, err
-			}
-			product := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, bv, a)
-			return true, false, c.storeRegSized(ins.Args[2].Reg, I32, "%"+product)
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported operand count: %q", op, ins.Raw)
-		}
-
-	case "IMULQ", "IMUL3Q":
-		// IMULQ src         -> RDX:RAX = signed RAX*src
-		// IMULQ src, dst    -> dst = signed(dst*src)
-		// IMUL3Q imm,src,dst -> dst = signed(src*imm)
-		switch len(ins.Args) {
-		case 1:
-			src, err := c.evalI64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			ax, err := c.loadReg(AX)
-			if err != nil {
-				return true, false, err
-			}
-			a128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", a128, ax)
-			b128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", b128, src)
-			p := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", p, a128, b128)
-			lo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", lo, p)
-			hiShift := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = ashr i128 %%%s, 64\n", hiShift, p)
-			hi := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", hi, hiShift)
-			if err := c.storeReg(AX, "%"+lo); err != nil {
-				return true, false, err
-			}
-			if err := c.storeReg(DX, "%"+hi); err != nil {
-				return true, false, err
-			}
-			return true, false, nil
-		case 2:
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 IMULQ expects src, dstReg: %q", ins.Raw)
-			}
-			src, err := c.evalI64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			dst := ins.Args[1].Reg
-			dv, err := c.loadReg(dst)
-			if err != nil {
-				return true, false, err
-			}
-			a128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", a128, dv)
-			b128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", b128, src)
-			p := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", p, a128, b128)
-			lo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", lo, p)
-			return true, false, c.storeReg(dst, "%"+lo)
-		case 3:
-			if op != "IMUL3Q" || ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 %s expects imm, src, dstReg: %q", op, ins.Raw)
-			}
-			imm, err := c.evalI64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			src, err := c.evalI64(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			a128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", a128, src)
-			b128 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sext i64 %s to i128\n", b128, imm)
-			p := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", p, a128, b128)
-			lo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", lo, p)
-			return true, false, c.storeReg(ins.Args[2].Reg, "%"+lo)
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects 1/2/3 operands: %q", op, ins.Raw)
-		}
-
-	case "NEGQ":
-		// NEGQ reg
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 NEGQ expects reg: %q", ins.Raw)
-		}
-		r := ins.Args[0].Reg
-		v, err := c.loadReg(r)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 0, %s\n", t, v)
-		out := "%" + t
-		if err := c.storeReg(r, out); err != nil {
-			return true, false, err
-		}
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %s, 0\n", cf, v)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		c.setZSFlagsFromI64(out)
-		return true, false, nil
 	}
 	return false, false, nil
 }
-
-func (c *amd64Ctx) lowerDoubleShift(op Op, ins Instr) error {
-	if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg {
-		return fmt.Errorf("amd64 %s expects amt, srcReg, dst: %q", op, ins.Raw)
-	}
-	ty := I64
-	mask := int64(63)
-	left := op == "SHLQ"
-	if op == "SHLL" || op == "SHRL" {
-		ty = I32
-		mask = 31
-		left = op == "SHLL"
-	}
-
-	src, err := c.evalIntSized(ins.Args[1], ty)
-	if err != nil {
-		return err
-	}
-	dst, storeDst, err := c.loadIntDestination(ins.Args[2], ty)
-	if err != nil {
-		return err
-	}
-
-	count64 := ""
-	switch ins.Args[0].Kind {
-	case OpImm:
-		count64 = fmt.Sprintf("%d", ins.Args[0].Imm&mask)
-	case OpReg:
-		value, err := c.loadReg(ins.Args[0].Reg)
-		if err != nil {
-			return err
-		}
-		masked := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, value, mask)
-		count64 = "%" + masked
-	default:
-		return fmt.Errorf("amd64 %s unsupported shift amount: %q", op, ins.Raw)
-	}
-
-	count := count64
-	if ty == I32 {
-		truncated := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncated, count64)
-		count = "%" + truncated
-	}
-	inverseNeg := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", inverseNeg, ty, count)
-	inverse := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", inverse, ty, inverseNeg, mask)
-	zero := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, ty, count)
-
-	dstPart := c.newTmp()
-	srcPart := c.newTmp()
-	if left {
-		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", dstPart, ty, dst, count)
-		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", srcPart, ty, src, inverse)
-	} else {
-		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", dstPart, ty, dst, count)
-		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", srcPart, ty, src, inverse)
-	}
-	merged := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", merged, ty, dstPart, srcPart)
-	out := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %s, %s %%%s\n", out, zero, ty, dst, ty, merged)
-	return storeDst("%" + out)
-}
-
-func (c *amd64Ctx) lower386Timestamp(serialized bool) error {
-	asm := "rdtsc"
-	resultType := "{ i32, i32 }"
-	constraints := "={ax},={dx},~{dirflag},~{fpsr},~{flags},~{memory}"
-	regs := []Reg{AX, DX}
-	if serialized {
-		asm = "rdtscp"
-		resultType = "{ i32, i32, i32 }"
-		constraints = "={ax},={dx},={cx},~{dirflag},~{fpsr},~{flags},~{memory}"
-		regs = append(regs, CX)
-	}
-	call := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n", call, resultType, asm, constraints)
-	for i, reg := range regs {
-		value := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, resultType, call, i)
-		if err := c.storeRegSized(reg, I32, "%"+value); err != nil {
-			return err
-		}
-	}
-	return nil
-}
diff --git a/amd64_lower_arithmetic_shift.go b/amd64_lower_arithmetic_shift.go
new file mode 100644
index 000000000..9f8dd4655
--- /dev/null
+++ b/amd64_lower_arithmetic_shift.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import "fmt"
+
+// The complete uniform arithmetic family shares yps/_yvpslld operand shapes
+// with logical shifts. VPSRAQ has only the unsigned-immediate EVEX rows.
+// These descriptors grant no register input, native backing or caller role.
+var amd64PackedArithmeticShiftSpecs = map[Op]amd64PackedLogicalShiftSpec{
+	"PSRAW":  {laneBits: 16},
+	"PSRAL":  {laneBits: 32},
+	"VPSRAW": {laneBits: 16, vector: true},
+	"VPSRAD": {laneBits: 32, vector: true},
+	"VPSRAQ": {laneBits: 64, vector: true},
+}
+
+func (c *amd64Ctx) lowerPackedArithmeticRightShift(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerX86PackedShift(op, ins)
+}
+
+func (c *amd64Ctx) emitPackedArithmeticRightShift(lanes, laneBits int, data, count64 string) string {
+	valid, safe := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %d\n", valid, count64, laneBits)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 %d\n", safe, valid, count64, laneBits-1)
+	count := "%" + safe
+	if laneBits < 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, count, laneBits)
+		count = "%" + narrow
+	}
+	counts := amd64SplatInteger(c, lanes, laneBits, count)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = ashr <%d x i%d> %s, %s\n", result, lanes, laneBits, data, counts)
+	return "%" + result
+}
diff --git a/amd64_lower_arithmetic_shift_test.go b/amd64_lower_arithmetic_shift_test.go
new file mode 100644
index 000000000..5c03f3859
--- /dev/null
+++ b/amd64_lower_arithmetic_shift_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedArithmeticRightShiftCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast, zLast := 15, 22
+			if target.goarch == "386" {
+				legacyLast, zLast = 7, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedarithmeticrightshiftforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"PSRAW", "PSRAL"} {
+				// Go's Py3 MMX rows are named-source mode64 only. Their
+				// complete mode32 rejection controls are independently
+				// exercised by TestX86YMMMode32LegacyShiftActualGoRows.
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $3, M1\n", op)
+					fmt.Fprintf(&source, "\t%s M0, M1\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M1\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s $-1, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VPSRAW", "VPSRAD", "VPSRAQ"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s $3, %s20, %s21\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s $3, 8(AX), %s21\n", op, width)
+					fmt.Fprintf(&source, "\t%s X0, %s20, %s21\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s20, %s21\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s $3, %s20, K1, %s22\n", op, width, width)
+						fmt.Fprintf(&source, "\t%s.Z X0, %s20, K7, %s22\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s $3, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s $3, 8(AX), Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s X0, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", op, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $3, Z20, K2, Z22\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z20, K6, Z22\n", op)
+				}
+				if op != "VPSRAW" {
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), X21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), Z%d\n", op, zLast)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST.Z $3, 8(AX), K5, Z22\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedarithmeticrightshiftforms": {Name: "packedarithmeticrightshiftforms", Ret: Void},
+				},
+			}
+			goAssemblerOracleOutput(t, target.goarch, strings.ReplaceAll(source.String(), "NOSPLIT", "4"), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				original := strings.Replace(source.String(), "packedarithmeticrightshiftforms(SB)", "·view(SB)", 1)
+				if ir, err := x86ScalarFPBitViewAPI(t, original, "func view()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("uninitialized original formats acquired MMX/numerical/native inputs", api, err)
+				}
+			}
+			if target.goarch == "386" {
+				// Go emits high-bank EVEX spellings in mode32, but those
+				// physical registers do not exist. Retain the original Go
+				// objects/Context above; LLVM format objects use this explicit
+				// low-bank counterpart, not an invented high-bank permission.
+				counterpart := strings.NewReplacer("X20", "X5", "X21", "X6", "Y20", "Y5", "Y21", "Y6").Replace(source.String())
+				goAssemblerOracleOutput(t, target.goarch, strings.ReplaceAll(counterpart, "NOSPLIT", "4"), "", true)
+				file, err = Parse(ArchAMD64, counterpart)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			ll := x86InstructionFormatObjectUnit(t, file, options.Sigs, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPackedArithmeticRightShift(ins.Op, ins)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-arithmetic-right-shift-"+target.name+".ll", "packed-arithmetic-right-shift-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedArithmeticRightShiftRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PSRAW.Z $3, X0",
+		"PSRAL $3",
+		"PSRAW M0, X1",
+		"PSRAL X0, M1",
+		"PSRAQ $3, X0",
+		"PSRAW $3, Y0",
+		"VPSRAW R8, X1, X2",
+		"VPSRAD Y0, X1, X2",
+		"VPSRAQ X0, 8(AX), X2",
+		"VPSRAW.BCST $3, 8(AX), X2",
+		"VPSRAD.BCST X0, X1, X2",
+		"VPSRAQ.BCST $3, X1, X2",
+		"VPSRAW.Z $3, X1, X2",
+		"VPSRAD $3, X1, K0, X2",
+		"VPSRAQ $3, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedArithmeticRightShiftRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PSRAW X8, X0",
+		"PSRAL X0, X8",
+		"VPSRAW $3, Z8, Z1",
+		"VPSRAD X0, Z1, Z8",
+		"VPSRAQ $3, X1, K1, X2",
+		"VPSRAW.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedArithmeticRightShiftRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedArithmeticRightShiftRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed arithmetic-right-shift forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_atomic.go b/amd64_lower_atomic.go
index c2783260b..e2bb314e5 100644
--- a/amd64_lower_atomic.go
+++ b/amd64_lower_atomic.go
@@ -3,283 +3,23 @@ package plan9asm
 import "fmt"
 
 func (c *amd64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, terminated, err := c.lowerLockScalarRMW(op, ins); known {
+		return known, terminated, err
+	}
+	if spec, recognized := amd64ExchangeSpecs[Op(normalizeInstructionOpcode(op))]; recognized {
+		return c.lowerExchange(op, spec, ins)
+	}
+	if _, _, recognized := amd64CompareExchangeProperties(normalizeInstructionOpcode(op)); recognized {
+		return c.lowerCompareExchange(op, ins)
+	}
 	switch op {
 	case "LOCK":
-		// LOCK is a prefix in Plan 9 syntax. Our lowering emits atomic IR for
-		// the following memory RMW instruction, so the prefix itself is a no-op.
-		return true, false, nil
-
-	case "CMPXCHG8B":
-		if len(ins.Args) != 1 || ins.Args[0].Kind != OpMem {
-			return true, false, fmt.Errorf("amd64 CMPXCHG8B expects mem: %q", ins.Raw)
-		}
-		word := func(r Reg) (string, error) {
-			return c.evalIntSized(Operand{Kind: OpReg, Reg: r}, I32)
-		}
-		ax, err := word(AX)
-		if err != nil {
-			return true, false, err
-		}
-		dx, err := word(DX)
-		if err != nil {
-			return true, false, err
-		}
-		bx, err := word(BX)
-		if err != nil {
-			return true, false, err
-		}
-		cx, err := word(CX)
-		if err != nil {
-			return true, false, err
-		}
-		pair := func(lo, hi string) string {
-			lo64 := c.newTmp()
-			hi64 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", lo64, lo)
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", hi64, hi)
-			shifted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", shifted, hi64)
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", out, shifted, lo64)
-			return "%" + out
-		}
-		expected := pair(ax, dx)
-		desired := pair(bx, cx)
-		ptr, ptrType, err := c.ptrFromMem(ins.Args[0].Mem)
-		if err != nil {
-			return true, false, err
-		}
-		if ptrType != "ptr" {
-			return true, false, fmt.Errorf("amd64 CMPXCHG8B does not support segment-relative memory: %q", ins.Raw)
-		}
-		result := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, i64 %s, i64 %s seq_cst seq_cst, align 8\n", result, ptr, expected, desired)
-		old := c.newTmp()
-		success := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i1 } %%%s, 0\n", old, result)
-		fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i1 } %%%s, 1\n", success, result)
-		oldLo := c.newTmp()
-		oldHiShift := c.newTmp()
-		oldHi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", oldLo, old)
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 32\n", oldHiShift, old)
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", oldHi, oldHiShift)
-		if err := c.storeRegSized(AX, I32, "%"+oldLo); err != nil {
-			return true, false, err
-		}
-		if err := c.storeRegSized(DX, I32, "%"+oldHi); err != nil {
-			return true, false, err
-		}
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", success, c.flagsZSlot)
-		return true, false, nil
-
-	case "CMPXCHGL", "CMPXCHGQ":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpMem {
-			return true, false, fmt.Errorf("amd64 %s expects src, mem: %q", op, ins.Raw)
-		}
-		ty := I32
-		align := 4
-		if op == "CMPXCHGQ" {
-			ty = I64
-			align = 8
-		}
-
-		expAX, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		exp, err := c.amd64AtomicTruncFromI64(expAX, ty)
-		if err != nil {
-			return true, false, err
-		}
-		newv64, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		newv, err := c.amd64AtomicTruncFromI64(newv64, ty)
-		if err != nil {
-			return true, false, err
-		}
-		ptr, err := c.amd64AtomicPtrFromMem(ins.Args[1].Mem)
-		if err != nil {
-			return true, false, err
-		}
-		cx := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, %s %s, %s %s seq_cst seq_cst, align %d\n", cx, ptr, ty, exp, ty, newv, align)
-		old := c.newTmp()
-		okv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 0\n", old, ty, cx)
-		fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 1\n", okv, ty, cx)
-		old64, err := c.amd64AtomicExtendToI64("%"+old, ty)
-		if err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(AX, old64); err != nil {
-			return true, false, err
-		}
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", okv, c.flagsZSlot)
-		return true, false, nil
-
-	case "XADDL", "XADDQ":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpMem {
-			return true, false, fmt.Errorf("amd64 %s expects srcReg, mem: %q", op, ins.Raw)
-		}
-		srcReg := ins.Args[0]
-		if srcReg.Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects register src: %q", op, ins.Raw)
-		}
-		ty := I32
-		if op == "XADDQ" {
-			ty = I64
-		}
-		src64, err := c.loadReg(srcReg.Reg)
-		if err != nil {
-			return true, false, err
-		}
-		src, err := c.amd64AtomicTruncFromI64(src64, ty)
-		if err != nil {
-			return true, false, err
-		}
-		ptr, err := c.amd64AtomicPtrFromMem(ins.Args[1].Mem)
-		if err != nil {
-			return true, false, err
-		}
-		old := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = atomicrmw add ptr %s, %s %s seq_cst\n", old, ptr, ty, src)
-		old64, err := c.amd64AtomicExtendToI64("%"+old, ty)
-		if err != nil {
-			return true, false, err
-		}
-		return true, false, c.storeReg(srcReg.Reg, old64)
-
-	case "XCHGB", "XCHGL", "XCHGQ":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects srcReg, dst: %q", op, ins.Raw)
-		}
-		srcReg := ins.Args[0]
-		if srcReg.Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects register src: %q", op, ins.Raw)
-		}
-		ty := I8
-		switch op {
-		case "XCHGL":
-			ty = I32
-		case "XCHGQ":
-			ty = I64
-		}
-		src64, err := c.loadReg(srcReg.Reg)
-		if err != nil {
-			return true, false, err
-		}
-		if ins.Args[1].Kind == OpReg {
-			dstReg := ins.Args[1].Reg
-			dst64, err := c.loadReg(dstReg)
-			if err != nil {
-				return true, false, err
-			}
-			switch ty {
-			case I64:
-				if err := c.storeReg(srcReg.Reg, dst64); err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeReg(dstReg, src64)
-			case I32:
-				s32 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", s32, src64)
-				d32 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", d32, dst64)
-				sz := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", sz, s32)
-				dz := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", dz, d32)
-				if err := c.storeReg(srcReg.Reg, "%"+dz); err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeReg(dstReg, "%"+sz)
-			default:
-				s8 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", s8, src64)
-				d8 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", d8, dst64)
-				sz := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", sz, s8)
-				dz := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", dz, d8)
-				if err := c.storeReg(srcReg.Reg, "%"+dz); err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeReg(dstReg, "%"+sz)
-			}
-		}
-		if ins.Args[1].Kind != OpMem && ins.Args[1].Kind != OpSym {
-			return true, false, fmt.Errorf("amd64 %s expects srcReg, mem/reg: %q", op, ins.Raw)
-		}
-		src, err := c.amd64AtomicTruncFromI64(src64, ty)
-		if err != nil {
-			return true, false, err
-		}
-		ptr := ""
-		if ins.Args[1].Kind == OpMem {
-			ptr, err = c.amd64AtomicPtrFromMem(ins.Args[1].Mem)
-			if err != nil {
-				return true, false, err
-			}
-		} else {
-			ptr, err = c.ptrFromSB(ins.Args[1].Sym)
-			if err != nil {
-				return true, false, err
-			}
-		}
-		old := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = atomicrmw xchg ptr %s, %s %s seq_cst\n", old, ptr, ty, src)
-		old64, err := c.amd64AtomicExtendToI64("%"+old, ty)
-		if err != nil {
-			return true, false, err
-		}
-		return true, false, c.storeReg(srcReg.Reg, old64)
-
-	case "ORB", "ANDB", "ORL", "ANDL", "ORQ", "ANDQ":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpMem {
-			return false, false, nil
-		}
-		ty := I8
-		switch op {
-		case "ORL", "ANDL":
-			ty = I32
-		case "ORQ", "ANDQ":
-			ty = I64
-		}
-		src64, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		src, err := c.amd64AtomicTruncFromI64(src64, ty)
-		if err != nil {
-			return true, false, err
-		}
-		ptr, err := c.amd64AtomicPtrFromMem(ins.Args[1].Mem)
-		if err != nil {
-			return true, false, err
-		}
-		rmw := "or"
-		if op == "ANDB" || op == "ANDL" || op == "ANDQ" {
-			rmw = "and"
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("%w: LOCK operands cannot substitute for a complete following atomic instruction: %q", ErrProbeNeedsContext, ins.Raw)
 		}
-		tmp := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = atomicrmw %s ptr %s, %s %s seq_cst\n", tmp, rmw, ptr, ty, src)
-		// atomicrmw returns the old value, while x86 logical instructions set
-		// flags from the new value. LOCK does not alter that flag behavior.
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %s\n", out, rmw, ty, tmp, src)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
-		zf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, 0\n", zf, ty, out)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zf, c.flagsZSlot)
-		sf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", sf, ty, out)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sf, c.flagsSltSlot)
-		return true, false, nil
+		// Only the whole-source consumer can bind this prefix to an adjacent
+		// complete native operation. An isolated helper has no such body.
+		return true, false, fmt.Errorf("%w: standalone LOCK has no source-adjacent complete atomic operation", ErrProbeNeedsContext)
 	}
 	return false, false, nil
 }
diff --git a/amd64_lower_average.go b/amd64_lower_average.go
new file mode 100644
index 000000000..5a49eb389
--- /dev/null
+++ b/amd64_lower_average.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerPackedUnsignedAverage(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedPhysical(op, ins, x86PackedAverage)
+}
+
+func (c *amd64Ctx) lowerPackedAverageForm(op Op, ins Instr, form x86PackedPhysicalForm) (bool, bool, error) {
+	ins.Op = op
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	first, second, destination := form.source, ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		// A virtual FP/SP/BP view is not the source's native aligned m128.
+		// Only the existing exact fixed-local certificate supplies that backing.
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem {
+			virtual = !c.nativeMemoryOperand(ins, form.first) && !c.fixedLocalMemoryCertified(ins, form.memory)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed average m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	bits := form.spec.outputBits
+	lanes := form.byteWidth * 8 / bits
+	if form.mmx {
+		var a string
+		var err error
+		if first.Kind == OpReg {
+			a, err = c.loadReg(first.Reg)
+		} else {
+			// Exact m64 bytes, including independent logical FP fields. Native
+			// reads stay observable without inventing an x87/tag-state bridge.
+			a, err = c.loadPackedUnpackMMXSource(first, 8)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		value := c.emitPackedUnsignedAverage(lanes, bits, c.bitcastI64ToIntegerLanes(lanes, bits, a), c.bitcastI64ToIntegerLanes(lanes, bits, b))
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", out, lanes, bits, value)
+		return true, false, c.storeReg(destination.Reg, "%"+out)
+	}
+	mnemonic := "pavgb"
+	if bits == 16 {
+		mnemonic = "pavgw"
+	}
+	return true, false, c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, form.spec.memoryBits,
+		mnemonic, c.emitPackedUnsignedAverage)
+}
+
+func (c *amd64Ctx) emitPackedUnsignedAverage(lanes, laneBits int, first, second string) string {
+	narrowType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	wideBits := laneBits * 2
+	wideType := fmt.Sprintf("<%d x i%d>", lanes, wideBits)
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", firstWide, narrowType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", secondWide, narrowType, second, wideType)
+	sum := c.newTmp()
+	rounded := c.newTmp()
+	average := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", sum, wideType, firstWide, secondWide)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %s\n", rounded, wideType, sum, llvmSplatSignedInteger(lanes, wideBits, 1))
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %s\n", average, wideType, rounded, llvmSplatSignedInteger(lanes, wideBits, 1))
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, average, narrowType)
+	return "%" + result
+}
diff --git a/amd64_lower_average_test.go b/amd64_lower_average_test.go
new file mode 100644
index 000000000..7b9a3e8eb
--- /dev/null
+++ b/amd64_lower_average_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedUnsignedAverageCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast, zLast := 15, 22
+			if target.goarch == "386" {
+				legacyLast, zLast = 7, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedunsignedaverageforms(SB),4,$0-0\n")
+			for _, stem := range []string{"PAVGB", "PAVGW"} {
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s M0, M1\n", stem)
+					fmt.Fprintf(&source, "\t%s 8(AX), M2\n", stem)
+				}
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", stem, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", stem, legacyLast)
+				vector := "V" + stem
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", vector, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s6, %s7\n", vector, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", vector, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z 8(AX), %s21, K7, %s22\n", vector, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z6, Z%d\n", vector, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", vector, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s Z20, Z21, K2, Z22\n", vector)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z21, K6, Z22\n", vector)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			goAssemblerOracleOutput(t, target.goarch, source.String(), "", true)
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedunsignedaverageforms": {Name: "packedunsignedaverageforms", Ret: Void},
+				},
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("uninitialized original average formats acquired numerical or memory inputs", err)
+			}
+			ll = x86AverageFormatObjectUnit(t, file, map[string]FuncSig{
+				"packedunsignedaverageforms": {Name: "packedunsignedaverageforms", Ret: Void},
+			}, target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-unsigned-average-"+target.name+".ll", "packed-unsigned-average-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedUnsignedAverageRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PAVGB.Z X0, X1",
+		"PAVGW X0",
+		"PAVGB M0, X1",
+		"PAVGW X0, M1",
+		"PAVGB Y0, Y1",
+		"PAVGW X0, (AX)",
+		"VPAVGB X0, X1",
+		"VPAVGW X0, Y1, Y2",
+		"VPAVGB X0, X1, (AX)",
+		"VPAVGW.BCST 8(AX), X1, X2",
+		"VPAVGB.Z X0, X1, X2",
+		"VPAVGW X0, X1, K0, X2",
+		"VPAVGB X0, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedUnsignedAverageRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PAVGB X8, X0",
+		"PAVGW X0, X8",
+		"VPAVGB Z8, Z1, Z2",
+		"VPAVGW Z0, Z1, Z8",
+		"VPAVGB X0, X1, K1, X2",
+		"VPAVGW.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedUnsignedAverageRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedUnsignedAverageRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed unsigned-average forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_bextr.go b/amd64_lower_bextr.go
new file mode 100644
index 000000000..55fd91049
--- /dev/null
+++ b/amd64_lower_bextr.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import "fmt"
+
+// lowerBEXTR implements Go 1.27's complete _ybextrl operand row for BEXTRL/Q:
+// register control, register/memory source, and register destination.
+func (c *amd64Ctx) lowerBEXTR(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86BEXTRProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	bits := form.bits
+	typ := amd64IntegerTypeForBits(bits)
+	controlValue, err := c.evalIntSized(form.control, typ)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, err := c.evalScalarBitFieldSource(ins, form, typ)
+	if err != nil {
+		return true, false, err
+	}
+	start := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, 255\n", start, typ, controlValue)
+	lengthShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, 8\n", lengthShift, typ, controlValue)
+	length := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 255\n", length, typ, lengthShift)
+	startOK := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %%%s, %d\n", startOK, typ, start, bits)
+	safeStart := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %d\n", safeStart, startOK, typ, start, typ, bits-1)
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", shifted, typ, sourceValue, safeStart)
+	rawLength := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s 0\n", rawLength, startOK, typ, length, typ)
+	remaining := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s %d, %%%s\n", remaining, typ, bits, safeStart)
+	useRawLength := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %%%s, %%%s\n", useRawLength, typ, rawLength, remaining)
+	effectiveLength := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %%%s\n", effectiveLength, useRawLength, typ, rawLength, typ, remaining)
+	isFullWidth := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %d\n", isFullWidth, typ, effectiveLength, bits)
+	safeLength := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", safeLength, typ, effectiveLength, bits-1)
+	one := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s 1, %%%s\n", one, typ, safeLength)
+	partialMask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, -1\n", partialMask, typ, one)
+	mask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s -1, %s %%%s\n", mask, isFullWidth, typ, typ, partialMask)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", result, typ, shifted, mask)
+	if err := c.storeRegSized(form.destination.Reg, typ, "%"+result); err != nil {
+		return true, false, err
+	}
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, 0\n", zero, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	return true, false, nil
+}
+
+func (c *amd64Ctx) evalScalarBitFieldSource(ins Instr, form x86ScalarBitFieldForm, typ LLVMType) (string, error) {
+	if form.source.Kind == OpFP && x86ResultNamedPredicateInstruction(ins) {
+		if value, handled, err := c.loadIntegerFPBytesMode(form.source.FPOffset, typ, true); handled || err != nil {
+			return value, err
+		}
+	}
+	if isAMD64MemoryOperand(form.source) && form.source.Kind != OpFP &&
+		(c.nativeMemoryOperand(ins, 1) ||
+			x86CallerMemoryCertified(ins, 1) || c.fixedLocalMemoryCertified(ins, 1)) {
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return "", fmt.Errorf("%w: %s needs its original native address size", ErrProbeNeedsContext, ins.Op)
+		}
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		// Preserve the full physical read even for zero controls/dead outputs.
+		// Alignment, bounds and pointee validity are not optimizer assumptions.
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+		return "%" + value, nil
+	}
+	return c.evalIntSized(form.source, typ)
+}
diff --git a/amd64_lower_bextr_test.go b/amd64_lower_bextr_test.go
new file mode 100644
index 000000000..95e41ee64
--- /dev/null
+++ b/amd64_lower_bextr_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86BEXTRCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA bextrdata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL bextrdata(SB), $8\n")
+	source.WriteString("TEXT bextrforms(SB),$0-0\n")
+	for _, width := range []string{"L", "Q"} {
+		op := "BEXTR" + width
+		fmt.Fprintf(&source, "\t%s AX, BX, CX\n", op)
+		fmt.Fprintf(&source, "\t%s DX, 8(BX), SI\n", op)
+		fmt.Fprintf(&source, "\t%s CX, bextrdata(SB), DX\n", op)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\t%s R11, R12, R13\n", op)
+		} else {
+			fmt.Fprintf(&source, "\t%s AX, BX, SP\n", op)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86BEXTRCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86BEXTRCompleteFormsSource(target.goarch)
+			// Preserve every original row, including unknown inputs and the
+			// physical SP destination. A syntax object is not an ABI proof.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "bextrforms", target.goarch, target.triple)
+			wantIR := []string{"lshr i32", `"target-features"="+bmi"`}
+			if target.goarch == "amd64" {
+				wantIR = append(wantIR, "lshr i64")
+			} else if strings.Contains(ir, "lshr i64") {
+				t.Fatal("mode32 Q spelling used a fictitious 64-bit extraction")
+			}
+			for _, want := range wantIR {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("BEXTR lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if strings.Contains(ir, "+bmi2") {
+				t.Fatalf("BEXTR is BMI1 but inferred BMI2:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "bextr-"+target.name+".ll", "bextr-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86BEXTRRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "BEXTRL $1, AX, BX"},
+		{goarch: "amd64", instruction: "BEXTRQ 0(AX), BX, CX"},
+		{goarch: "amd64", instruction: "BEXTRQ AX, $1, CX"},
+		{goarch: "amd64", instruction: "BEXTRL AX, BX, 0(CX)"},
+		{goarch: "amd64", instruction: "BEXTRQ X0, AX, BX"},
+		{goarch: "amd64", instruction: "BEXTRQ AX, X0, BX"},
+		{goarch: "amd64", instruction: "BEXTRQ AX, BX, X0"},
+		{goarch: "amd64", instruction: "BEXTRQ AX, BX"},
+		{goarch: "amd64", instruction: "BEXTRQ.Z AX, BX, CX"},
+		{goarch: "386", instruction: "BEXTRL R8, AX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _ybextrl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64BEXTRRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = x86BEXTROriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"bextrsemantics": {
+				Name:  "bextrsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bextr_semantics", triple, ir, x86BEXTROriginalRuntimeDriver, runPrefix)
+}
+
+const x86BEXTROriginalRuntimeSource = `TEXT bextrsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVL $0x0804, AX
+	MOVL $0x1234, BX
+	BEXTRL AX, BX, CX
+	MOVQ CX, 0(DI)
+	SETCS 8(DI)
+	SETOS 9(DI)
+	SETEQ 10(DI)
+
+	MOVL $0x0120, AX
+	MOVL $-1, BX
+	BEXTRL AX, BX, CX
+	MOVQ CX, 16(DI)
+	SETEQ 24(DI)
+
+	MOVQ $0x083c, AX
+	MOVQ $-1, 32(DI)
+	BEXTRQ AX, 32(DI), CX
+	MOVQ CX, 40(DI)
+
+	MOVQ $0x0404, AX
+	MOVQ $0xf0, BX
+	BEXTRQ AX, BX, AX
+	MOVQ AX, 48(DI)
+	RET
+`
+
+const x86BEXTROriginalRuntimeDriver = `
+#include <stdint.h>
+#include <string.h>
+extern void bextrsemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[56] = {0};
+  bextrsemantics(out);
+  if (load64(out + 0) != UINT64_C(0x23)) return 10;
+  if (out[8] != 0 || out[9] != 0 || out[10] != 0) return 11;
+  if (load64(out + 16) != 0 || out[24] != 1) return 12;
+  if (load64(out + 40) != UINT64_C(0xf)) return 13;
+  if (load64(out + 48) != UINT64_C(0xf)) return 14;
+  return 0;
+}
+`
diff --git a/amd64_lower_bf16_convert.go b/amd64_lower_bf16_convert.go
new file mode 100644
index 000000000..da42e06a2
--- /dev/null
+++ b/amd64_lower_bf16_convert.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64BF16ConvertSourceBytes = map[Op]int{
+	"VCVTNEPS2BF16X": 16,
+	"VCVTNEPS2BF16Y": 32,
+	"VCVTNEPS2BF16":  64,
+}
+
+func (c *amd64Ctx) lowerBF16Convert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base := Op(strings.SplitN(string(op), ".", 2)[0])
+	sourceBytes := amd64BF16ConvertSourceBytes[base]
+	if sourceBytes == 0 {
+		return false, false, nil
+	}
+	if !ins.x86Encoded {
+		return true, false, fmt.Errorf("%s has no named Go 1.27 encoder form: %q", base, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("%s expects source, [K mask,] destination: %q", base, ins.Raw)
+	}
+	broadcast := strings.Contains(string(op), ".BCST")
+	zeroing := strings.HasSuffix(string(op), ".Z")
+	masked := len(ins.Args) == 3
+	if zeroing && !masked || broadcast && !isAMD64MemoryOperand(ins.Args[0]) {
+		return true, false, fmt.Errorf("%s has invalid mask or broadcast operands: %q", base, ins.Raw)
+	}
+	if masked && !amd64NonzeroKOperand(ins.Args[1]) {
+		return true, false, fmt.Errorf("%s requires K1-K7 for masking: %q", base, ins.Raw)
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	destinationBytes := sourceBytes / 2
+	if destinationBytes < 16 {
+		destinationBytes = 16
+	}
+	if destination.Kind != OpReg || amd64VectorByteWidth(destination.Reg) != destinationBytes {
+		return true, false, fmt.Errorf("%s requires a %d-byte destination register: %q", base, destinationBytes, ins.Raw)
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg && amd64VectorByteWidth(source.Reg) != sourceBytes ||
+		source.Kind != OpReg && !isAMD64MemoryOperand(source) {
+		return true, false, fmt.Errorf("%s requires a %d-byte vector or memory source: %q", base, sourceBytes, ins.Raw)
+	}
+
+	lanes := sourceBytes / 4
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	inputBits, err := c.loadMaskedPackedCompareLanes(source, sourceBytes, 32, broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	input := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x float>\n", input, lanes, inputBits, lanes)
+	resultLanes := lanes
+	if resultLanes < 8 {
+		resultLanes = 8
+	}
+	intrinsic := map[int]string{
+		16: "llvm.x86.vcvtneps2bf16128",
+		32: "llvm.x86.vcvtneps2bf16256",
+		64: "llvm.x86.avx512bf16.cvtneps2bf16.512",
+	}[sourceBytes]
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x bfloat> @%s(<%d x float> %%%s)\n",
+		converted, resultLanes, intrinsic, lanes, input)
+	computed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x bfloat> %%%s to <%d x i16>\n",
+		computed, resultLanes, converted, resultLanes)
+	result := "%" + computed
+	if lanes < resultLanes {
+		low := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i16> %s, <%d x i16> poison, <%d x i32> <",
+			low, resultLanes, result, resultLanes, lanes)
+		for lane := 0; lane < lanes; lane++ {
+			if lane != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", lane)
+		}
+		c.b.WriteString(">\n")
+		result = "%" + low
+	}
+	if masked {
+		old, loadErr := c.loadPackedExtendInputs(destination, destinationBytes, lanes, 16)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, 16, result, old, mask, zeroing)
+	}
+	outputBytes := lanes * 2
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x i8>\n",
+		bytesValue, lanes, result, outputBytes)
+	return true, false, c.storePackedHalfResult(destination, destinationBytes, outputBytes, "%"+bytesValue)
+}
diff --git a/amd64_lower_binary_float.go b/amd64_lower_binary_float.go
new file mode 100644
index 000000000..7e9db9138
--- /dev/null
+++ b/amd64_lower_binary_float.go
@@ -0,0 +1,322 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64BinaryFloatingMode uint8
+
+const (
+	amd64BinaryFloatingAdd amd64BinaryFloatingMode = iota
+	amd64BinaryFloatingSub
+	amd64BinaryFloatingMul
+	amd64BinaryFloatingDiv
+	amd64BinaryFloatingMax
+	amd64BinaryFloatingMin
+	amd64BinaryFloatingSqrt
+	amd64BinaryFloatingScale
+)
+
+type amd64BinaryFloatingSpec struct {
+	laneBits int
+	mode     amd64BinaryFloatingMode
+	scalar   bool
+	sae      bool
+	rawOnly  bool
+}
+
+// The residual catalog owns raw FP16 and SCALEF. Named f32/f64 arithmetic
+// and SQRT dispatch through their complete typed source grammars first.
+var amd64BinaryFloatingSpecs = map[Op]amd64BinaryFloatingSpec{
+	"VADDPH":    {laneBits: 16, mode: amd64BinaryFloatingAdd, rawOnly: true},
+	"VSUBPH":    {laneBits: 16, mode: amd64BinaryFloatingSub, rawOnly: true},
+	"VMULPH":    {laneBits: 16, mode: amd64BinaryFloatingMul, rawOnly: true},
+	"VDIVPH":    {laneBits: 16, mode: amd64BinaryFloatingDiv, rawOnly: true},
+	"VMINPH":    {laneBits: 16, mode: amd64BinaryFloatingMin, sae: true, rawOnly: true},
+	"VMAXPH":    {laneBits: 16, mode: amd64BinaryFloatingMax, sae: true, rawOnly: true},
+	"VADDSH":    {laneBits: 16, mode: amd64BinaryFloatingAdd, scalar: true, rawOnly: true},
+	"VSUBSH":    {laneBits: 16, mode: amd64BinaryFloatingSub, scalar: true, rawOnly: true},
+	"VMULSH":    {laneBits: 16, mode: amd64BinaryFloatingMul, scalar: true, rawOnly: true},
+	"VDIVSH":    {laneBits: 16, mode: amd64BinaryFloatingDiv, scalar: true, rawOnly: true},
+	"VMINSH":    {laneBits: 16, mode: amd64BinaryFloatingMin, scalar: true, sae: true, rawOnly: true},
+	"VMAXSH":    {laneBits: 16, mode: amd64BinaryFloatingMax, scalar: true, sae: true, rawOnly: true},
+	"VSQRTSH":   {laneBits: 16, mode: amd64BinaryFloatingSqrt, scalar: true, rawOnly: true},
+	"VSCALEFPS": {laneBits: 32, mode: amd64BinaryFloatingScale},
+	"VSCALEFPD": {laneBits: 64, mode: amd64BinaryFloatingScale},
+	"VSCALEFSS": {laneBits: 32, mode: amd64BinaryFloatingScale, scalar: true},
+	"VSCALEFSD": {laneBits: 64, mode: amd64BinaryFloatingScale, scalar: true},
+}
+
+type amd64BinaryFloatingSuffix struct {
+	broadcast bool
+	zeroing   bool
+	rounding  string
+	sae       bool
+}
+
+func parseAMD64BinaryFloatingSuffix(suffix string) (amd64BinaryFloatingSuffix, bool) {
+	switch suffix {
+	case "":
+		return amd64BinaryFloatingSuffix{}, true
+	case "Z":
+		return amd64BinaryFloatingSuffix{zeroing: true}, true
+	case "BCST":
+		return amd64BinaryFloatingSuffix{broadcast: true}, true
+	case "BCST.Z":
+		return amd64BinaryFloatingSuffix{broadcast: true, zeroing: true}, true
+	case "SAE":
+		return amd64BinaryFloatingSuffix{sae: true}, true
+	case "SAE.Z":
+		return amd64BinaryFloatingSuffix{sae: true, zeroing: true}, true
+	case "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE":
+		return amd64BinaryFloatingSuffix{rounding: suffix}, true
+	case "RN_SAE.Z", "RD_SAE.Z", "RU_SAE.Z", "RZ_SAE.Z":
+		return amd64BinaryFloatingSuffix{rounding: strings.TrimSuffix(suffix, ".Z"), zeroing: true}, true
+	default:
+		return amd64BinaryFloatingSuffix{}, false
+	}
+}
+
+func (c *amd64Ctx) lowerBinaryFloating(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, term, err := c.lowerFP16Binary(op, ins); known {
+		return known, term, err
+	}
+	if known, term, err := c.lowerSqrt(op, ins); known {
+		return known, term, err
+	}
+	if ok, term, err := c.lowerFloatArithmetic(op, ins, ""); ok {
+		return ok, term, err
+	}
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64BinaryFloatingSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if spec.mode == amd64BinaryFloatingScale && x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	if spec.rawOnly && !ins.x86Encoded {
+		return true, false, fmt.Errorf("%s has no named Go assembler form: %q", baseOp, ins.Raw)
+	}
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix {
+		return true, false, fmt.Errorf("%s %s has a suffix absent from Go 1.27's binary floating optab: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.scalar && properties.broadcast {
+		return true, false, fmt.Errorf("%s %s scalar forms do not support broadcast: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.sae {
+		if properties.rounding != "" {
+			return true, false, fmt.Errorf("%s %s supports SAE, not explicit rounding: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if properties.sae {
+		return true, false, fmt.Errorf("%s %s supports explicit rounding, not SAE: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("%s %s expects src1, src2, [K mask,] destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == 4
+	if c.goarch == "386" && masked && !spec.rawOnly {
+		return true, false, fmt.Errorf("386 %s mask forms exceed Go 1.27's assembler operand limit: %q", baseOp, ins.Raw)
+	}
+	if properties.zeroing && !masked {
+		return true, false, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s destination must be a vector register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	if spec.scalar {
+		if byteWidth != 16 {
+			return true, false, fmt.Errorf("%s %s scalar destination must be an X register: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 {
+		return true, false, fmt.Errorf("%s %s packed destination must be an X, Y, or Z register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if !c.isGoEVEXVectorRegister(destination, byteWidth) || !c.isGoEVEXVectorRegister(ins.Args[1], byteWidth) {
+		return true, false, fmt.Errorf("%s %s second source and destination must be same-width Go 1.27 vector registers: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if (properties.rounding != "" || properties.sae) && !spec.scalar && byteWidth != 64 {
+		return true, false, fmt.Errorf("%s %s packed rounding/SAE is available only for Z registers: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a memory first source: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if ins.Args[0].Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(ins.Args[0], byteWidth) {
+			return true, false, fmt.Errorf("%s %s first source must match the destination width and register class: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if properties.rounding != "" || properties.sae {
+		return true, false, fmt.Errorf("%s %s explicit rounding/SAE requires a register first source: %q", c.goarch, baseOp, ins.Raw)
+	} else if !isAMD64MemoryOperand(ins.Args[0]) {
+		return true, false, fmt.Errorf("%s %s first source must be a vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	var mask string
+	if masked {
+		if !amd64NonzeroKOperand(ins.Args[2]) {
+			return true, false, fmt.Errorf("amd64 %s masked form expects K1-K7: %q", baseOp, ins.Raw)
+		}
+		loadedMask, loadErr := c.loadK(ins.Args[2].Reg)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		mask = loadedMask
+	}
+	if spec.scalar {
+		return c.lowerScalarBinaryFloating(spec, properties, ins, destination, mask)
+	}
+	return c.lowerPackedBinaryFloating(spec, properties, ins, destination, byteWidth, mask)
+}
+
+func (c *amd64Ctx) lowerPackedBinaryFloating(spec amd64BinaryFloatingSpec, properties amd64BinaryFloatingSuffix, ins Instr, destination Operand, byteWidth int, mask string) (bool, bool, error) {
+	if spec.mode == amd64BinaryFloatingScale {
+		return c.lowerPackedScaleF(spec, properties, ins.Args[0], ins.Args[1], destination, byteWidth, mask)
+	}
+	// The typed f32/f64 owners return before this fallback. Its remaining
+	// arithmetic consumers are raw FP16, including portable target lowering.
+	lanes := byteWidth * 8 / spec.laneBits
+	llvmType := amd64FMA3LLVMType(lanes, spec.laneBits)
+	load := func(operand Operand, allowBroadcast bool) (string, error) {
+		sourceMask := ""
+		if allowBroadcast {
+			sourceMask = mask
+		}
+		bits, err := c.loadMaskedPackedCompareLanes(operand, byteWidth, spec.laneBits, allowBroadcast && properties.broadcast, sourceMask)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", value, lanes, spec.laneBits, bits, llvmType)
+		return "%" + value, nil
+	}
+	first, err := load(ins.Args[0], true)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := load(ins.Args[1], false)
+	if err != nil {
+		return true, false, err
+	}
+	computed := c.emitBinaryFloating(spec, llvmType, lanes, second, first, properties.rounding)
+	if mask != "" {
+		computedBits := c.bitcastFloatingToIntegerLanes(llvmType, lanes, spec.laneBits, computed)
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		oldBits := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		masked := amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computedBits, oldBits, mask, properties.zeroing)
+		back := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", back, lanes, spec.laneBits, masked, llvmType)
+		computed = "%" + back
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, llvmType, computed, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarBinaryFloating(spec amd64BinaryFloatingSpec, properties amd64BinaryFloatingSuffix, ins Instr, destination Operand, mask string) (bool, bool, error) {
+	if spec.mode == amd64BinaryFloatingScale {
+		return c.lowerScalarScaleF(spec, properties, ins.Args[0], ins.Args[1], destination, mask)
+	}
+	// SCALEF has returned; only the portable raw half-precision path remains.
+	var firstBits, secondBits string
+	var err error
+	if ins.Args[0].Kind == OpReg {
+		firstBits, err = c.loadXLowInteger(ins.Args[0].Reg, 16)
+	} else if mask != "" {
+		firstBits, err = c.loadVectorScalarMemory(ins.Args[0], 16, mask)
+	} else {
+		firstBits, err = c.evalIntSized(ins.Args[0], "i16")
+	}
+	if err == nil {
+		secondBits, err = c.loadXLowInteger(ins.Args[1].Reg, 16)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	firstTemp, secondTemp := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i16 %s to half\n", firstTemp, firstBits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i16 %s to half\n", secondTemp, secondBits)
+	first, second := "%"+firstTemp, "%"+secondTemp
+	llvmType := amd64FMA3LLVMType(1, spec.laneBits)
+	computed := c.emitBinaryFloating(spec, llvmType, 1, second, first, properties.rounding)
+	computedBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", computedBits, llvmType, computed, spec.laneBits)
+	secondBytes, err := c.loadX(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, secondBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+computedBits, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) emitBinaryFloating(spec amd64BinaryFloatingSpec, llvmType string, lanes int, left, right, rounding string) string {
+	result := c.newTmp()
+	switch spec.mode {
+	case amd64BinaryFloatingSqrt:
+		if rounding == "" {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.sqrt.%s(%s %s)\n", result, llvmType, amd64BinaryFloatingIntrinsicSuffix(lanes, spec.laneBits), llvmType, right)
+		} else {
+			intrinsic := fmt.Sprintf("llvm.experimental.constrained.sqrt.%s", amd64BinaryFloatingIntrinsicSuffix(lanes, spec.laneBits))
+			fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, metadata !\"%s\", metadata !\"fpexcept.ignore\")\n", result, llvmType, intrinsic, llvmType, right, amd64FMA3RoundingMetadata(rounding))
+		}
+	case amd64BinaryFloatingMax, amd64BinaryFloatingMin:
+		predicate := "ogt"
+		if spec.mode == amd64BinaryFloatingMin {
+			predicate = "olt"
+		}
+		comparison := c.newTmp()
+		predicateType := "i1"
+		if lanes > 1 {
+			predicateType = fmt.Sprintf("<%d x i1>", lanes)
+		}
+		fmt.Fprintf(c.b, "  %%%s = fcmp %s %s %s, %s\n", comparison, predicate, llvmType, left, right)
+		fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", result, predicateType, comparison, llvmType, left, llvmType, right)
+	default:
+		operation := "fadd"
+		switch spec.mode {
+		case amd64BinaryFloatingSub:
+			operation = "fsub"
+		case amd64BinaryFloatingMul:
+			operation = "fmul"
+		case amd64BinaryFloatingDiv:
+			operation = "fdiv"
+		}
+		if rounding == "" {
+			fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, operation, llvmType, left, right)
+		} else {
+			intrinsic := fmt.Sprintf("llvm.experimental.constrained.%s.%s", operation, amd64BinaryFloatingIntrinsicSuffix(lanes, spec.laneBits))
+			fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, metadata !\"%s\", metadata !\"fpexcept.ignore\")\n", result, llvmType, intrinsic, llvmType, left, llvmType, right, amd64FMA3RoundingMetadata(rounding))
+		}
+	}
+	return "%" + result
+}
+
+func (c *amd64Ctx) bitcastFloatingToIntegerLanes(llvmType string, lanes, laneBits int, value string) string {
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i%d>\n", result, llvmType, value, lanes, laneBits)
+	return "%" + result
+}
+
+func amd64BinaryFloatingIntrinsicSuffix(lanes, laneBits int) string {
+	suffix := "f32"
+	if laneBits == 16 {
+		suffix = "f16"
+	} else if laneBits == 64 {
+		suffix = "f64"
+	}
+	if lanes > 1 {
+		return fmt.Sprintf("v%d%s", lanes, suffix)
+	}
+	return suffix
+}
diff --git a/amd64_lower_bittest.go b/amd64_lower_bittest.go
new file mode 100644
index 000000000..ca04dd1ba
--- /dev/null
+++ b/amd64_lower_bittest.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import "fmt"
+
+// lowerBitTestFamily implements the complete Go 1.27 ybtl table. BTW/L/Q,
+// BTCW/L/Q, BTRW/L/Q, and BTSW/L/Q all accept exactly either a signed imm8 or
+// a Yrl register bit index followed by a Yml register/memory destination.
+func (c *amd64Ctx) lowerBitTestFamily(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86BitTestProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.destination.Kind != OpReg && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return true, false, fmt.Errorf("%w: bit string needs its original native address size", ErrProbeNeedsContext)
+	}
+	stem, bits := form.stem, form.bits
+	typ := amd64IntegerTypeForBits(bits)
+	bitIndex, memoryWordOffset, registerIndex, err := c.bitTestIndex(form.index, bits, typ)
+	if err != nil {
+		return true, false, err
+	}
+	value, store, err := c.loadBitTestDestination(form.destination, typ, memoryWordOffset, registerIndex)
+	if err != nil {
+		return true, false, err
+	}
+
+	shifted := c.newTmp()
+	bit := c.newTmp()
+	carry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shifted, typ, value, bitIndex)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 1\n", bit, typ, shifted)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, 0\n", carry, typ, bit)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+	if stem == "BT" {
+		return true, false, nil
+	}
+
+	bitMask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s 1, %s\n", bitMask, typ, bitIndex)
+	result := c.newTmp()
+	switch stem {
+	case "BTC":
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %%%s\n", result, typ, value, bitMask)
+	case "BTR":
+		inverseMask := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %%%s, -1\n", inverseMask, typ, bitMask)
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", result, typ, value, inverseMask)
+	case "BTS":
+		fmt.Fprintf(c.b, "  %%%s = or %s %s, %%%s\n", result, typ, value, bitMask)
+	}
+	return true, false, store("%" + result)
+}
+
+func amd64BitTestProperties(op string) (stem string, bits int, ok bool) {
+	switch op {
+	case "BTW":
+		return "BT", 16, true
+	case "BTL":
+		return "BT", 32, true
+	case "BTQ":
+		return "BT", 64, true
+	case "BTCW":
+		return "BTC", 16, true
+	case "BTCL":
+		return "BTC", 32, true
+	case "BTCQ":
+		return "BTC", 64, true
+	case "BTRW":
+		return "BTR", 16, true
+	case "BTRL":
+		return "BTR", 32, true
+	case "BTRQ":
+		return "BTR", 64, true
+	case "BTSW":
+		return "BTS", 16, true
+	case "BTSL":
+		return "BTS", 32, true
+	case "BTSQ":
+		return "BTS", 64, true
+	}
+	return "", 0, false
+}
+
+// bitTestIndex returns the within-word index and, for a register index, the
+// signed byte offset used when a memory destination is treated as an unbounded
+// bit string. The index register has the same width as the instruction.
+// Intel SDM Vol.2A, Bit(BitBase, BitOffset) and BT/BTC/BTR/BTS:
+// https://cdrdv2-public.intel.com/812383/253666-sdm-vol-2a.pdf
+// Immediate high bits are ignored by the CPU; unlike some assemblers, actual
+// Go does not fold them into a new displacement (tested for every imm8).
+func (c *amd64Ctx) bitTestIndex(index Operand, bits int, typ LLVMType) (bitIndex, memoryWordOffset string, registerIndex bool, err error) {
+	if index.Kind == OpImm {
+		return fmt.Sprintf("%d", index.Imm&int64(bits-1)), "", false, nil
+	}
+	value, err := c.evalIntSized(index, typ)
+	if err != nil {
+		return "", "", false, err
+	}
+	withinWord := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %d\n", withinWord, typ, value, bits-1)
+	bitIndex = "%" + withinWord
+
+	signedIndex := value
+	if bits != 64 {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext %s %s to i64\n", extended, typ, value)
+		signedIndex = "%" + extended
+	}
+	wordIndex := c.newTmp()
+	byteOffset := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, %d\n", wordIndex, signedIndex, bitTestLog2(bits))
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", byteOffset, wordIndex, bits/8)
+	return bitIndex, "%" + byteOffset, true, nil
+}
+
+func bitTestLog2(bits int) int {
+	switch bits {
+	case 16:
+		return 4
+	case 32:
+		return 5
+	default:
+		return 6
+	}
+}
+
+func (c *amd64Ctx) loadBitTestDestination(destination Operand, typ LLVMType, memoryWordOffset string, registerIndex bool) (string, func(string) error, error) {
+	if destination.Kind == OpReg {
+		return c.loadIntDestination(destination, typ)
+	}
+	if destination.Kind == OpFP {
+		if registerIndex {
+			return "", nil, fmt.Errorf("%w: a register-indexed FP bit string has no fixed logical byte span", ErrProbeNeedsContext)
+		}
+		return c.loadBitTestFPDestination(destination, typ)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(destination)
+	if err != nil {
+		return "", nil, err
+	}
+	if registerIndex {
+		adjusted := c.newTmp()
+		// Signed floor division selects the complete containing word. Keep
+		// the original pointer address space and its target-width wrapping.
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %s\n", adjusted, pointerType, pointer, memoryWordOffset)
+		pointer = "%" + adjusted
+	}
+	loaded := c.newTmp()
+	// Intel SDM Vol.2A BT/BTC/BTR/BTS: even a dead CF retains the complete
+	// native read/fault; modifying forms also retain their write, including
+	// when the selected bit already has the requested value. This is not LOCK.
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", loaded, typ, pointerType, pointer)
+	return "%" + loaded, func(value string) error {
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+		return nil
+	}, nil
+}
+
+func (c *amd64Ctx) loadBitTestFPDestination(destination Operand, typ LLVMType) (string, func(string) error, error) {
+	bits, _ := amd64IntegerTypeBits(typ)
+	width := bits / 8
+	result, err := c.bitTestFPSpan(destination.FPOffset, width)
+	if err != nil {
+		return "", nil, err
+	}
+	if result {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return "", nil, err
+		}
+	}
+	bytes, err := c.loadX86PackedShiftBytes(destination, width, true)
+	if err != nil {
+		return "", nil, err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, width, bytes, typ)
+	return "%" + value, func(value string) error {
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, typ, value, width)
+		return c.storeFPVectorBytes(destination.FPOffset, width, "%"+bytes, "")
+	}, nil
+}
+
+func (c *amd64Ctx) bitTestFPSpan(off int64, width int) (bool, error) {
+	if err := c.validateX86PackedShiftFPSpan(off, width); err != nil {
+		return false, err
+	}
+	result := false
+	for offset := off; offset < off+int64(width); offset++ {
+		slot, output, _ := c.fpVectorSlot(offset)
+		if slot.Type == Ptr || slot.Type == I1 {
+			return false, fmt.Errorf("%w: FP bit string needs declared numerical bytes", ErrProbeNeedsContext)
+		}
+		result = result || output
+	}
+	return result, nil
+}
diff --git a/amd64_lower_blend_imm.go b/amd64_lower_blend_imm.go
new file mode 100644
index 000000000..ca0938fcc
--- /dev/null
+++ b/amd64_lower_blend_imm.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerImmediatePackedBlend implements the complete Go 1.27 immediate
+// packed-blend family. The legacy instructions use yxshuf, while all four
+// V-prefixed instructions use _yvblendpd and therefore have VEX X/Y forms
+// only (no EVEX Z, mask, zeroing, broadcast, or SAE forms).
+func (c *amd64Ctx) lowerImmediatePackedBlend(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86ImmediateBlendProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if f.legacy && f.memory {
+		return true, false, c.lowerLegacyImmediateBlendMemory(ins, f)
+	}
+	first, err := c.loadX86PackedShiftBytes(ins.Args[f.source], f.byteWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	base, err := c.loadPackedCompareBytes(ins.Args[f.base], f.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitImmediatePackedBlend(f.byteWidth, f.laneBytes*8, f.selector, first, base)
+	if f.legacy {
+		return true, false, c.storeLegacyXViews(ins.Args[f.destination].Reg, result)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[f.destination], f.byteWidth, result)
+}
+
+func amd64ImmediatePackedBlendProperties(op string) (laneBits int, vector, ok bool) {
+	switch op {
+	case "PBLENDW":
+		return 16, false, true
+	case "BLENDPS":
+		return 32, false, true
+	case "BLENDPD":
+		return 64, false, true
+	case "VPBLENDW":
+		return 16, true, true
+	case "VPBLENDD", "VBLENDPS":
+		return 32, true, true
+	case "VBLENDPD":
+		return 64, true, true
+	default:
+		return 0, false, false
+	}
+}
+
+// Legacy Type4 m128 retains its original alignment/fault behavior, including
+// imm8=0 and dead results. Logical FP bytes are not native aligned backing.
+func (c *amd64Ctx) lowerLegacyImmediateBlendMemory(ins Instr, f x86ImmediateBlendForm) error {
+	source := ins.Args[f.source]
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || source.Kind == OpFP {
+		return fmt.Errorf("%w: legacy immediate blend needs original native m128 storage", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	base, err := c.loadPackedCompareBytes(ins.Args[f.base], 16)
+	if err != nil {
+		return err
+	}
+	carrier, result, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x float>\n", carrier, base)
+	assembly := fmt.Sprintf("%s $$%d, %s($2), $0", strings.ToLower(string(ins.Op)), f.selector, segment)
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(<4 x float> %%%s, %s %s)\n",
+		result, assembly, "=x,0,r,~{memory}", carrier, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, result)
+	return c.storeLegacyXViews(ins.Args[f.destination].Reg, "%"+bytes)
+}
+
+// emitImmediatePackedBlend selects the first (r/m) source when the immediate
+// bit is one and the second source when it is zero. VPBLENDW repeats the eight
+// immediate bits independently in each 128-bit lane of a Y register.
+func (c *amd64Ctx) emitImmediatePackedBlend(byteWidth, laneBits int, imm uint8, firstBytes, secondBytes string) string {
+	lanes := byteWidth * 8 / laneBits
+	first := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, firstBytes)
+	second := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, secondBytes)
+	mask := make([]string, 0, lanes)
+	for lane := 0; lane < lanes; lane++ {
+		if imm&(1<<uint(lane%8)) != 0 {
+			mask = append(mask, fmt.Sprintf("i32 %d", lane))
+		} else {
+			mask = append(mask, fmt.Sprintf("i32 %d", lanes+lane))
+		}
+	}
+	shuffled := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> %s, <%d x i32> <%s>\n",
+		shuffled, lanes, laneBits, first, lanes, laneBits, second, lanes, strings.Join(mask, ", "))
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <%d x i8>\n", out, lanes, laneBits, shuffled, byteWidth)
+	return "%" + out
+}
diff --git a/amd64_lower_blend_mask.go b/amd64_lower_blend_mask.go
new file mode 100644
index 000000000..167ff5a90
--- /dev/null
+++ b/amd64_lower_blend_mask.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import "fmt"
+
+type amd64MaskBlendSpec struct {
+	laneBits  int
+	broadcast bool
+}
+
+// amd64MaskBlendSpecs is the complete shared _yvblendmpd grammar for the
+// floating-point and integer mask-blend families.
+var amd64MaskBlendSpecs = map[Op]amd64MaskBlendSpec{
+	"VBLENDMPS": {laneBits: 32, broadcast: true},
+	"VBLENDMPD": {laneBits: 64, broadcast: true},
+	"VPBLENDMB": {laneBits: 8},
+	"VPBLENDMW": {laneBits: 16},
+	"VPBLENDMD": {laneBits: 32, broadcast: true},
+	"VPBLENDMQ": {laneBits: 64, broadcast: true},
+}
+
+// lowerMaskBlend implements Go 1.27's complete _yvblendmpd operand table for
+// VBLENDM{PS,PD} and VPBLENDM{B,W,D,Q}. A set K bit selects the first Plan 9
+// (Intel r/m) source; an unset bit selects the second source, or zero for .Z.
+func (c *amd64Ctx) lowerMaskBlend(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86MaskBlendProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	// E4 suppresses only inactive memory elements. The shared volatile reader
+	// retains active faults even when all result bytes are discarded after O2.
+	first, err := c.loadX86PackedShiftLanes(ins.Args[form.first], form.byteWidth, form.spec.laneBits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	result := first
+	lanes := form.byteWidth * 8 / form.spec.laneBits
+	if form.mask >= 0 {
+		second := "zeroinitializer"
+		if !form.zeroing {
+			second, err = c.loadPackedCompareLanes(ins.Args[form.second], form.byteWidth, form.spec.laneBits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.spec.laneBits, first, second, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.spec.laneBits, result, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+out)
+}
diff --git a/amd64_lower_blend_mask_test.go b/amd64_lower_blend_mask_test.go
new file mode 100644
index 000000000..d8ec2557f
--- /dev/null
+++ b/amd64_lower_blend_mask_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64MaskBlendGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64MaskBlendSpec{
+		"VBLENDMPS": {laneBits: 32, broadcast: true},
+		"VBLENDMPD": {laneBits: 64, broadcast: true},
+		"VPBLENDMB": {laneBits: 8},
+		"VPBLENDMW": {laneBits: 16},
+		"VPBLENDMD": {laneBits: 32, broadcast: true},
+		"VPBLENDMQ": {laneBits: 64, broadcast: true},
+	}
+	if len(amd64MaskBlendSpecs) != len(expected) {
+		t.Fatalf("mask-blend grammar has %d entries, want %d", len(amd64MaskBlendSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64MaskBlendSpecs[op]; !ok {
+			t.Errorf("mask-blend grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("mask-blend grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86MaskBlendCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 shares _yvblendmpd across VBLENDM{PS,PD} and
+	// VPBLENDM{B,W,D,Q}: matching X/Y/Z sources and destination, optional
+	// K1-K7 selection mask, and .Z. PS/PD/D/Q additionally enable
+	// scalar-memory broadcast on the first Plan 9 source.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 20
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT maskblendforms(SB),$0-0\n")
+			for _, family := range []struct {
+				op        string
+				broadcast bool
+			}{
+				{op: "VBLENDMPS", broadcast: true},
+				{op: "VBLENDMPD", broadcast: true},
+				{op: "VPBLENDMB"},
+				{op: "VPBLENDMW"},
+				{op: "VPBLENDMD", broadcast: true},
+				{op: "VPBLENDMQ", broadcast: true},
+			} {
+				op := family.op
+				fmt.Fprintf(&source, "\t%s X1, X20, X21\n", op)
+				fmt.Fprintf(&source, "\t%s 8(AX), Y20, Y21\n", op)
+				fmt.Fprintf(&source, "\t%s Z1, Z2, Z%d\n", op, lastZ)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X20, K1, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z Y1, Y20, K2, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 40(AX), Z20, K3, Z21\n", op)
+				}
+				if family.broadcast {
+					fmt.Fprintf(&source, "\t%s.BCST 104(AX), X20, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 112(AX), Y20, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 120(AX), Z2, Z%d\n", op, lastZ)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST.Z 128(AX), Z20, K4, Z21\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(),
+				"maskblendforms", target.goarch, target.triple)
+			ll := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch,
+				target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					// Go accepts EVEX high banks in named mode32 fixtures;
+					// this private emitter view does not bind public registers.
+					arch := c.goarch
+					if arch == "386" && x86Mode32VectorRegisterContext(ins, arch) != nil {
+						c.goarch = "amd64"
+						defer func() { c.goarch = arch }()
+					}
+					return c.lowerMaskBlend(ins.Op, ins)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "mask-blend-"+target.name+".ll", "mask-blend-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestAMD64FloatingMaskBlendRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT floatingmaskblendsemantics(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VBLENDMPS Z0, Z1, K1, Z2
+	VMOVDQU64 Z2, 0(AX)
+	VBLENDMPD.Z Z0, Z1, K1, Z2
+	VMOVDQU64 Z2, 64(AX)
+	VBLENDMPS.BCST 0(BX), Z1, K1, Z2
+	VMOVDQU64 Z2, 128(AX)
+	VBLENDMPD.BCST.Z 0(BX), Z1, K1, Z2
+	VMOVDQU64 Z2, 192(AX)
+	STC
+	VBLENDMPS Z0, Z1, K1, Z2
+	SETCS 256(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"floatingmaskblendsemantics": {
+			Name: "floatingmaskblendsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void floatingmaskblendsemantics(uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+int main(void) {
+  uint32_t first32[16], second32[16]; uint8_t out[257] = {0};
+  const uint64_t mask = UINT64_C(0xa55a);
+  for (int i=0;i<16;i++) { first32[i]=UINT32_C(0x7f000000)+i; second32[i]=UINT32_C(0x3f000000)+i; }
+  floatingmaskblendsemantics(out,(const uint8_t *)first32,(const uint8_t *)second32,mask);
+  uint32_t *ps=(uint32_t *)(out+0), *psbcst=(uint32_t *)(out+128);
+  for (int i=0;i<16;i++) {
+    uint32_t want=(mask>>i)&1 ? first32[i] : second32[i]; if (ps[i]!=want) return 10+i;
+    want=(mask>>i)&1 ? first32[0] : second32[i]; if (psbcst[i]!=want) return 30+i;
+  }
+  uint64_t first64[8], second64[8], pdzero[8], pdbczero[8];
+  memcpy(first64,first32,64); memcpy(second64,second32,64);
+  memcpy(pdzero,out+64,64); memcpy(pdbczero,out+192,64);
+  for (int i=0;i<8;i++) {
+    uint64_t want=(mask>>i)&1 ? first64[i] : 0; if (pdzero[i]!=want) return 50+i;
+    want=(mask>>i)&1 ? first64[0] : 0; if (pdbczero[i]!=want) return 70+i;
+  }
+  if (out[256]!=1) return 90;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "floating_mask_blend_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateX86MaskBlendRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VBLENDMPS X0, Y1, Y2",
+		"VBLENDMPD X0, X1, K0, X2",
+		"VBLENDMPS.BCST X0, X1, X2",
+		"VBLENDMPD.RN_SAE X0, X1, X2",
+		"VPBLENDMQ X0, X1",
+		"VPBLENDMQ X0, Y1, Y2",
+		"VPBLENDMQ X0, (AX), X2",
+		"VPBLENDMQ X0, X1, K0, X2",
+		"VPBLENDMQ X0, X1, AX",
+		"VPBLENDMQ.Z X0, X1, X2",
+		"VPBLENDMQ.BCST X0, X1, X2",
+		"VPBLENDMB.BCST (AX), X1, X2",
+		"VPBLENDMW.BCST (AX), X1, X2",
+		"VPBLENDMQ.Z.BCST (AX), X1, K1, X2",
+		"VPBLENDMQ.RN_SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			assertX86MaskBlendRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\tVPBLENDMQ X0, X1, K1, X2\n\tRET\n", false)
+	assertX86MaskBlendRejected(t, "386", "i386-unknown-linux-gnu", "VPBLENDMQ X0, X1, K1, X2")
+	requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\tVPBLENDMQ Z0, Z1, Z8\n\tRET\n", false)
+	assertX86MaskBlendRejected(t, "386", "i386-unknown-linux-gnu", "VPBLENDMQ Z0, Z1, Z8")
+}
+
+func assertX86MaskBlendRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VPBLENDM forms", instruction)
+	}
+}
diff --git a/amd64_lower_blend_variable.go b/amd64_lower_blend_variable.go
new file mode 100644
index 000000000..d7b298ea5
--- /dev/null
+++ b/amd64_lower_blend_variable.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64VariableBlendSpec struct {
+	laneBits int
+	vector   bool
+	opcode   int
+}
+
+// Go's yblendvpd and _yvblendvpd differ only in implicit/explicit mask,
+// destructive/non-destructive destination and the available vector widths.
+// The VEX raw decoder consumes the same opcode table as named lowering.
+var amd64VariableBlendSpecs = map[Op]amd64VariableBlendSpec{
+	"BLENDVPS":  {laneBits: 32, opcode: 0x14},
+	"BLENDVPD":  {laneBits: 64, opcode: 0x15},
+	"PBLENDVB":  {laneBits: 8, opcode: 0x10},
+	"VBLENDVPS": {laneBits: 32, vector: true, opcode: 0x4a},
+	"VBLENDVPD": {laneBits: 64, vector: true, opcode: 0x4b},
+	"VPBLENDVB": {laneBits: 8, vector: true, opcode: 0x4c},
+}
+
+// lowerVariableBlend implements Go 1.27's complete yblendvpd and _yvblendvpd
+// families. Each opcode tests the high bit of its mask lane: false selects the
+// base/destination lane and true selects the register-or-memory source lane.
+func (c *amd64Ctx) lowerVariableBlend(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, recognized, err := x86BlendMinposProperties(op, ins, c.goarch)
+	if !recognized || form.minimum {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	laneBits, byteWidth := form.laneBits, form.byteWidth
+	maskArg, source := ins.Args[form.mask], ins.Args[form.source]
+	base, destination := ins.Args[form.base], ins.Args[form.destination]
+	if form.legacy && form.memory {
+		return true, false, c.lowerLegacyBlendMinposMemory(ins, form)
+	}
+	maskBytes, err := c.loadPackedCompareBytes(maskArg, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	sourceBytes, err := c.loadX86PackedShiftBytes(source, byteWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	baseBytes, err := c.loadPackedCompareBytes(base, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / laneBits
+	maskLanes := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, maskBytes)
+	sourceLanes := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, sourceBytes)
+	baseLanes := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, baseBytes)
+	selectedMask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt <%d x i%d> %s, zeroinitializer\n", selectedMask, lanes, laneBits, maskLanes)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %s, <%d x i%d> %s\n", result, lanes, selectedMask, lanes, laneBits, sourceLanes, lanes, laneBits, baseLanes)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <%d x i8>\n", out, lanes, laneBits, result, byteWidth)
+	if !form.legacy {
+		return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+	}
+	return true, false, c.storeLegacyXViews(destination.Reg, "%"+out)
+}
diff --git a/amd64_lower_blend_variable_test.go b/amd64_lower_blend_variable_test.go
new file mode 100644
index 000000000..b97d5046d
--- /dev/null
+++ b/amd64_lower_blend_variable_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86VariableBlendCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's yblendvpd and _yvblendvpd tables are shared by the
+	// PS (dword lanes), PD (qword lanes), and PBLENDVB (byte lanes) variants.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT variableblendforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"BLENDVPS", "BLENDVPD", "PBLENDVB"} {
+				fmt.Fprintf(&src, "\t%s X0, (AX), X1\n", op)
+				fmt.Fprintf(&src, "\t%s X0, X2, X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VBLENDVPS", "VBLENDVPD", "VPBLENDVB"} {
+				fmt.Fprintf(&src, "\t%s X0, (AX), X1, X2\n", op)
+				fmt.Fprintf(&src, "\t%s X12, X13, X14, X15\n", op)
+				fmt.Fprintf(&src, "\t%s Y0, 32(AX), Y1, Y2\n", op)
+				fmt.Fprintf(&src, "\t%s Y12, Y13, Y14, Y15\n", op)
+			}
+			src.WriteString("\tRET\n")
+			var ll string
+			if target.goarch == "386" {
+				ll = x86BlendMinposOriginal386NamedFormats(t, src.String(), target.triple)
+			} else {
+				ll = x86UnboundBlendMinposFormatObject(t, src.String(), target.goarch, target.triple)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "variable-blend-"+target.name+".ll", "variable-blend-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86VariableBlendRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"BLENDVPS X1, X2, X3",
+		"BLENDVPD X0, Y1, X2",
+		"PBLENDVB X0, X1, Y2",
+		"BLENDVPS.Z X0, X1, X2",
+		"VBLENDVPS X0, X1, X2",
+		"VBLENDVPD X0, X1, X2, X3, X4",
+		"VPBLENDVB (AX), X1, X2, X3",
+		"VBLENDVPS X0, Y1, X2, X3",
+		"VBLENDVPD Y0, Y1, X2, Y3",
+		"VPBLENDVB Y0, Y1, Y2, X3",
+		"VBLENDVPS.Z X0, X1, X2, X3",
+		"VBLENDVPD X16, X1, X2, X3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86VariableBlendRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"BLENDVPS X0, X8, X1",
+		"BLENDVPD X0, X1, X8",
+		"PBLENDVB X8, X1, X2",
+	} {
+		assertX86VariableBlendRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86VariableBlendRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's variable blend tables", instruction)
+	}
+}
diff --git a/amd64_lower_bls.go b/amd64_lower_bls.go
new file mode 100644
index 000000000..17fb6b9b5
--- /dev/null
+++ b/amd64_lower_bls.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "fmt"
+
+// lowerLowestSetBitManipulation implements Go 1.27's complete _yblsil table:
+// BLSI, BLSMSK, and BLSR at L/Q widths, with a Yml register-or-memory source
+// and a Yrl destination register.
+func (c *amd64Ctx) lowerLowestSetBitManipulation(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86BLSProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	typ := amd64IntegerTypeForBits(form.spec.bits)
+	value, err := c.evalBLSSource(ins, form, typ)
+	if err != nil {
+		return true, false, err
+	}
+	minusOne := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s %s, 1\n", minusOne, typ, value)
+	result := c.newTmp()
+	carry := ""
+	switch form.spec.kind {
+	case x86BLSIsolate:
+		negative := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", negative, typ, value)
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", result, typ, value, negative)
+		carry = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %s, 0\n", carry, typ, value)
+	case x86BLSMask:
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %%%s\n", result, typ, value, minusOne)
+		carry = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", carry, typ, value)
+	case x86BLSReset:
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", result, typ, value, minusOne)
+		carry = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", carry, typ, value)
+	}
+
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+	if form.spec.kind == x86BLSMask {
+		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsZSlot)
+	} else {
+		zero := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, 0\n", zero, typ, result)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	}
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", sign, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	return true, false, c.storeRegSized(form.destination.Reg, typ, "%"+result)
+}
diff --git a/amd64_lower_bls_test.go b/amd64_lower_bls_test.go
new file mode 100644
index 000000000..fcefdd328
--- /dev/null
+++ b/amd64_lower_bls_test.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RawBLSMSKReportedEncoding(t *testing.T) {
+	const source = `TEXT rawBLSMSK(SB), NOSPLIT, $0-0
+	BYTE $0xc4
+	BYTE $0xe2
+	BYTE $0x88
+	BYTE $0xf3
+	BYTE $0xd2
+	RET
+`
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, `"target-features"="+bmi"`) {
+		t.Fatalf("raw BLSMSK did not infer BMI1 target feature:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-blsmsk-reported.ll", "raw-blsmsk-reported.o", ir)
+}
+
+func TestTranslateX86BLSCompleteGoAssemblerForms(t *testing.T) {
+	registers386 := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+	registersAMD64 := append(append([]string{}, registers386...), "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	targets := []struct {
+		name      string
+		goarch    string
+		triple    string
+		widths    []string
+		registers []string
+	}{
+		{name: "386-linux", goarch: "386", triple: "i386-unknown-linux-gnu", widths: []string{"L", "Q"}, registers: registers386},
+		{name: "386-windows", goarch: "386", triple: "i686-pc-windows-msvc", widths: []string{"L", "Q"}, registers: registers386},
+		{name: "amd64-darwin", goarch: "amd64", triple: "x86_64-apple-darwin", widths: []string{"L", "Q"}, registers: registersAMD64},
+		{name: "amd64-linux", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", widths: []string{"L", "Q"}, registers: registersAMD64},
+		{name: "amd64-windows", goarch: "amd64", triple: "x86_64-pc-windows-msvc", widths: []string{"L", "Q"}, registers: registersAMD64},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT blsforms(SB),$0-0\n")
+			for _, family := range []string{"BLSI", "BLSMSK", "BLSR"} {
+				for _, width := range target.widths {
+					op := family + width
+					for index, register := range target.registers {
+						other := target.registers[(index+5)%len(target.registers)]
+						fmt.Fprintf(&source, "\t%s %s, %s\n", op, register, other)
+						fmt.Fprintf(&source, "\t%s %s, %s\n", op, other, register)
+					}
+					fmt.Fprintf(&source, "\t%s 8(AX), DX\n", op)
+					fmt.Fprintf(&source, "\t%s 16(AX)(CX*4), BX\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "blsforms", target.goarch, target.triple)
+			if !strings.Contains(ir, `"target-features"="+bmi"`) {
+				t.Fatalf("BLS family did not infer BMI1 target feature:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "bls-family.ll", "bls-family.o", ir)
+		})
+	}
+}
+
+func TestTranslateX86BLSRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "386", instruction: "BLSIL R8, AX"},
+		{goarch: "386", instruction: "BLSIQ R8, AX"},
+		{goarch: "386", instruction: "BLSIL AX, R8"},
+		{goarch: "386", instruction: "BLSIQ AX, R8"},
+		{goarch: "amd64", instruction: "BLSIW AX, DX"},
+		{goarch: "amd64", instruction: "BLSIL AL, DX"},
+		{goarch: "amd64", instruction: "BLSIL X0, DX"},
+		{goarch: "amd64", instruction: "BLSIL $1, DX"},
+		{goarch: "amd64", instruction: "BLSIL AX, 0(DX)"},
+		{goarch: "amd64", instruction: "BLSIL AX"},
+		{goarch: "amd64", instruction: "BLSIL AX, DX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{Goarch: test.goarch, TargetTriple: triple, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yblsil table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestX86RawBLSCompleteRegisterFields(t *testing.T) {
+	families := []struct {
+		digit byte
+		name  string
+	}{
+		{digit: 1, name: "BLSR"},
+		{digit: 2, name: "BLSMSK"},
+		{digit: 3, name: "BLSI"},
+	}
+	for _, mode := range []int{32, 64} {
+		registerCount := 8
+		widths := []bool{false, true}
+		if mode == 64 {
+			registerCount = 16
+		}
+		for _, family := range families {
+			for _, width64 := range widths {
+				for destinationNumber := 0; destinationNumber < registerCount; destinationNumber++ {
+					for sourceNumber := 0; sourceNumber < registerCount; sourceNumber++ {
+						vex1 := byte(0xe2)
+						if sourceNumber >= 8 {
+							vex1 &^= 0x20
+						}
+						vex2 := byte((^destinationNumber & 15) << 3)
+						if width64 {
+							vex2 |= 0x80
+						}
+						modRM := byte(0xc0 | int(family.digit)<<3 | sourceNumber&7)
+						code := []byte{0xc4, vex1, vex2, 0xf3, modRM}
+						instruction, length, ok, err := decodedX86BLSInstruction(code, mode)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("mode=%d %x: instruction=%#v length=%d ok=%v err=%v", mode, code, instruction, length, ok, err)
+						}
+						width := "L"
+						if width64 && mode == 64 {
+							width = "Q"
+						}
+						source, _ := decodedX86GeneralRegister(sourceNumber)
+						destination, _ := decodedX86GeneralRegister(destinationNumber)
+						if instruction.Op != Op(family.name+width) || len(instruction.Args) != 2 || instruction.Args[0].Reg != source || instruction.Args[1].Reg != destination {
+							t.Fatalf("mode=%d %x decoded as %#v, want %s%s %s, %s", mode, code, instruction, family.name, width, source, destination)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawBLSCompleteMemoryFormsAndTargets(t *testing.T) {
+	targets := []struct {
+		name      string
+		goarch    string
+		triple    string
+		encodings [][]byte
+	}{
+		{
+			name: "386-linux", goarch: "386", triple: "i386-unknown-linux-gnu",
+			encodings: [][]byte{
+				{0xc4, 0xe2, 0x70, 0xf3, 0x18},                         // BLSIL 0(AX), CX
+				{0xc4, 0xe2, 0x68, 0xf3, 0x54, 0x48, 0x08},             // BLSMSKL 8(AX)(CX*2), DX
+				{0xc4, 0xe2, 0x60, 0xf3, 0x0d, 0x78, 0x56, 0x34, 0x12}, // BLSRL 0x12345678, BX
+			},
+		},
+		{
+			name: "386-windows", goarch: "386", triple: "i686-pc-windows-msvc",
+			encodings: [][]byte{
+				{0xc4, 0xe2, 0x70, 0xf3, 0x18},
+				{0xc4, 0xe2, 0x68, 0xf3, 0x54, 0x48, 0x08},
+				{0xc4, 0xe2, 0x60, 0xf3, 0x0d, 0x78, 0x56, 0x34, 0x12},
+			},
+		},
+		{
+			name: "amd64-darwin", goarch: "amd64", triple: "x86_64-apple-darwin",
+			encodings: [][]byte{
+				{0xc4, 0xe2, 0x88, 0xf3, 0xd2},                               // reported BLSMSKQ DX, R14
+				{0xc4, 0x82, 0x88, 0xf3, 0x5c, 0x88, 0x10},                   // BLSIQ 16(R8)(R9*4), R14
+				{0x64, 0xc4, 0xe2, 0x80, 0xf3, 0x4c, 0x48, 0x08},             // BLSRQ FS:8(AX)(CX*2), R15
+				{0xc4, 0xe2, 0x80, 0xf3, 0x1c, 0x25, 0x78, 0x56, 0x34, 0x12}, // BLSIQ 0x12345678, R15
+			},
+		},
+		{
+			name: "amd64-linux", goarch: "amd64", triple: "x86_64-unknown-linux-gnu",
+			encodings: [][]byte{
+				{0xc4, 0xe2, 0x88, 0xf3, 0xd2},
+				{0xc4, 0x82, 0x88, 0xf3, 0x5c, 0x88, 0x10},
+				{0x64, 0xc4, 0xe2, 0x80, 0xf3, 0x4c, 0x48, 0x08},
+				{0xc4, 0xe2, 0x80, 0xf3, 0x1c, 0x25, 0x78, 0x56, 0x34, 0x12},
+			},
+		},
+		{
+			name: "amd64-windows", goarch: "amd64", triple: "x86_64-pc-windows-msvc",
+			encodings: [][]byte{
+				{0xc4, 0xe2, 0x88, 0xf3, 0xd2},
+				{0xc4, 0x82, 0x88, 0xf3, 0x5c, 0x88, 0x10},
+				{0x64, 0xc4, 0xe2, 0x80, 0xf3, 0x4c, 0x48, 0x08},
+				{0xc4, 0xe2, 0x80, 0xf3, 0x1c, 0x25, 0x78, 0x56, 0x34, 0x12},
+			},
+		},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			for index, encoding := range target.encodings {
+				name := fmt.Sprintf("rawBLS_%d", index)
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+				for _, value := range encoding {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+				source.WriteString("\tRET\n")
+			}
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-bls.ll", "raw-bls.o", ir)
+		})
+	}
+}
+
+func TestX86RawBLSRejectsInvalidOrLayoutDependentForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+	}{
+		{name: "vex_l", mode: 64, encoding: []byte{0xc4, 0xe2, 0x8c, 0xf3, 0xd2}},
+		{name: "vex_prefix", mode: 64, encoding: []byte{0xc4, 0xe2, 0x89, 0xf3, 0xd2}},
+		{name: "invalid_digit", mode: 64, encoding: []byte{0xc4, 0xe2, 0x88, 0xf3, 0xc2}},
+		{name: "extended_destination_386", mode: 32, encoding: []byte{0xc4, 0xe2, 0x38, 0xf3, 0xd2}},
+		{name: "address_size_override", mode: 64, encoding: []byte{0x67, 0xc4, 0xe2, 0x88, 0xf3, 0x54, 0x48, 0x08}},
+		{name: "rip_relative", mode: 64, encoding: []byte{0xc4, 0xe2, 0x88, 0xf3, 0x15, 0, 0, 0, 0}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86BLSInstruction(test.encoding, test.mode)
+			if test.name == "vex_l" || test.name == "vex_prefix" {
+				if ok {
+					t.Fatalf("reserved VEX encoding %x was recognized: %v", test.encoding, err)
+				}
+				return
+			}
+			if !ok || err == nil {
+				t.Fatalf("encoding %x: ok=%v err=%v, want recognized rejection", test.encoding, ok, err)
+			}
+		})
+	}
+}
+
+func TestAMD64BLSRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = x86BLSOriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"blssemantics": {Name: "blssemantics", Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = x86BLSOriginalRuntimeDriver
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bls_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_bmi2_shift.go b/amd64_lower_bmi2_shift.go
new file mode 100644
index 000000000..8aa294aed
--- /dev/null
+++ b/amd64_lower_bmi2_shift.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import "fmt"
+
+type amd64BMI2ShiftSpec struct {
+	bits      int
+	prefix    int
+	kind      string
+	immediate bool
+}
+
+var amd64BMI2ShiftSpecs = map[Op]amd64BMI2ShiftSpec{
+	"SARXL": {bits: 32, prefix: 2, kind: "ashr"},
+	"SARXQ": {bits: 64, prefix: 2, kind: "ashr"},
+	"SHLXL": {bits: 32, prefix: 1, kind: "shl"},
+	"SHLXQ": {bits: 64, prefix: 1, kind: "shl"},
+	"SHRXL": {bits: 32, prefix: 3, kind: "lshr"},
+	"SHRXQ": {bits: 64, prefix: 3, kind: "lshr"},
+	"RORXL": {bits: 32, prefix: 3, kind: "rotate", immediate: true},
+	"RORXQ": {bits: 64, prefix: 3, kind: "rotate", immediate: true},
+}
+
+// All eight L/Q shifts and rotates consume the shared complete _ybextrl or
+// _yrorxl grammar, exact source width and count mask. None changes FLAGS.
+func (c *amd64Ctx) lowerBMI2ShiftRotate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, supported := amd64BMI2ShiftSpecs[op]
+	if !supported {
+		return false, false, nil
+	}
+	form, _, err := x86ScalarShiftProperties(op, ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	typ := amd64IntegerTypeForBits(form.bits)
+	countValue, err := c.evalIntSized(form.count, typ)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, _, err := c.loadScalarShiftOperand(ins, 1, typ)
+	if err != nil {
+		return true, false, err
+	}
+	maskedCount := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %d\n", maskedCount, typ, countValue, form.bits-1)
+	result := c.newTmp()
+	if spec.immediate {
+		// Both shifts stay in range at count zero; LLVM must never see poison.
+		negative, reverse := c.newTmp(), c.newTmp()
+		low, high := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s 0, %%%s\n", negative, typ, maskedCount)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", reverse, typ, negative, form.bits-1)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", low, typ, sourceValue, maskedCount)
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", high, typ, sourceValue, reverse)
+		fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", result, typ, low, high)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, spec.kind, typ, sourceValue, maskedCount)
+	}
+	if err := c.storeRegSized(form.destination.Reg, typ, "%"+result); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
diff --git a/amd64_lower_bmi2_shift_test.go b/amd64_lower_bmi2_shift_test.go
new file mode 100644
index 000000000..4496a3f84
--- /dev/null
+++ b/amd64_lower_bmi2_shift_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86BMI2VariableShiftFormsSource(goarch string) string {
+	var source strings.Builder
+	symbol := "bmi2shiftdata"
+	size := 8
+	if goarch == "386" {
+		symbol = "bmi2shiftdata386"
+		size = 4
+	}
+	fmt.Fprintf(&source, "DATA %s+0(SB)/%d, $1\n", symbol, size)
+	fmt.Fprintf(&source, "GLOBL %s(SB), $%d\n", symbol, size)
+	source.WriteString("TEXT bmi2shiftforms(SB),$0-0\n")
+	for _, stem := range []string{"SARX", "SHLX", "SHRX"} {
+		for _, width := range []string{"L", "Q"} {
+			op := stem + width
+			fmt.Fprintf(&source, "\t%s AX, BX, CX\n", op)
+			fmt.Fprintf(&source, "\t%s DX, 8(BX), SI\n", op)
+			fmt.Fprintf(&source, "\t%s CX, %s(SB), DX\n", op, symbol)
+			if goarch == "amd64" {
+				fmt.Fprintf(&source, "\t%s R11, R12, R13\n", op)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86BMI2VariableShiftCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86BMI2VariableShiftFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ll := x86UnboundVoidScalarFormatObject(t, source, "bmi2shiftforms", target.goarch, target.triple)
+			operations := []string{"ashr i32", "shl i32", "lshr i32", `"target-features"="+bmi2"`}
+			if target.goarch == "amd64" {
+				operations = append(operations, "ashr i64", "shl i64", "lshr i64")
+			} else if strings.Contains(ll, "ashr i64") || strings.Contains(ll, "shl i64") || strings.Contains(ll, "lshr i64") {
+				t.Fatal("386 BMI2 shift used 64-bit arithmetic")
+			}
+			for _, want := range operations {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("BMI2 variable-shift lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "bmi2-shift-"+target.name+".ll", "bmi2-shift-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86BMI2VariableShiftRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "SHLXQ $1, AX, BX"},
+		{goarch: "amd64", instruction: "SHRXQ 0(BX), AX, CX"},
+		{goarch: "amd64", instruction: "SARXL AX, BX, 0(CX)"},
+		{goarch: "amd64", instruction: "SHLXL X0, AX, BX"},
+		{goarch: "amd64", instruction: "SHRXQ AX, X0, BX"},
+		{goarch: "amd64", instruction: "SARXQ AX, BX"},
+		{goarch: "amd64", instruction: "SHLXQ.Z AX, BX, CX"},
+		{goarch: "386", instruction: "SHLXL R8, AX, BX"},
+		{goarch: "386", instruction: "SHRXQ AX, R8, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _ybextrl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64BMI2VariableShiftRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT bmi2shiftsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $36, AX
+	MOVQ $0x12345678, BX
+	SHLXL AX, BX, CX
+	MOVQ CX, 0(DI)
+	MOVQ $-81985529216486896, 8(DI)
+	MOVQ $72, AX
+	SHRXQ AX, 8(DI), CX
+	MOVQ CX, 8(DI)
+	MOVQ $0x80000000, BX
+	SARXL AX, BX, CX
+	MOVQ CX, 16(DI)
+	MOVQ $-9223372036854775808, BX
+	SARXQ AX, BX, CX
+	MOVQ CX, 24(DI)
+	MOVQ $1, AX
+	MOVQ $3, BX
+	CMPQ BX, BX
+	STC
+	SHLXQ AX, BX, AX
+	MOVQ AX, 32(DI)
+	SETCS 40(DI)
+	SETEQ 41(DI)
+	RET
+`
+	// Preserve the original literal above as an independent Go-rejected
+	// counterexample. Only the unencodable imm64 memory store is repaired.
+	repaired := x86BMI2VariableShiftRepairedRuntimeSource(t)
+	if repaired == source {
+		t.Fatal("BMI2 fixture repair did not change its invalid store")
+	}
+	file, err := Parse(ArchAMD64, repaired)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"bmi2shiftsemantics": {
+				Name:  "bmi2shiftsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void bmi2shiftsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[48] = {0};
+  bmi2shiftsemantics(out);
+  if (*(uint64_t *)(out+0) != UINT64_C(0x23456780)) return 10;
+  if (*(uint64_t *)(out+8) != UINT64_C(0x00fedcba98765432)) return 11;
+  if (*(uint64_t *)(out+16) != UINT64_C(0xff800000)) return 12;
+  if (*(uint64_t *)(out+24) != UINT64_C(0xff80000000000000)) return 13;
+  if (*(uint64_t *)(out+32) != 6) return 14;
+  if (out[40] != 1 || out[41] != 1) return 15;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bmi2_shift_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_bound.go b/amd64_lower_bound.go
new file mode 100644
index 000000000..bd5f55a4c
--- /dev/null
+++ b/amd64_lower_bound.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64BoundOperandBits = map[Op]int{
+	"BOUNDW": 16,
+	"BOUNDL": 32,
+}
+
+// lowerBound implements Go 1.27's complete yrl_m family. BOUND is valid only
+// in 16/32-bit x86 modes, so plan9asm preserves the exact faulting instruction
+// as constrained inline assembly rather than approximating its exception.
+func (c *amd64Ctx) lowerBound(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	raw := strings.ToUpper(string(op))
+	base := raw
+	if dot := strings.IndexByte(raw, '.'); dot >= 0 {
+		base = raw[:dot]
+	}
+	bits, recognized := amd64BoundOperandBits[Op(base)]
+	if !recognized {
+		return false, false, nil
+	}
+	if raw != base {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, base, ins.Raw)
+	}
+	if c.goarch != "386" {
+		return true, false, fmt.Errorf("%s %s is unavailable outside 32-bit x86 mode: %q", c.goarch, base, ins.Raw)
+	}
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("386 %s expects GP register and bounds memory: %q", base, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpReg || !isX86YrlRegisterForArch(ins.Args[0].Reg, c.goarch) {
+		return true, false, fmt.Errorf("386 %s source is outside Go 1.27's Yrl class: %q", base, ins.Raw)
+	}
+	if !isAMD64MemoryOperand(ins.Args[1]) {
+		return true, false, fmt.Errorf("386 %s second operand must be Go 1.27 Ym memory: %q", base, ins.Raw)
+	}
+	typeName := I32
+	if bits == 16 {
+		typeName = I16
+	}
+	value, err := c.evalIntSized(ins.Args[0], typeName)
+	if err != nil {
+		return true, false, err
+	}
+	pointer, pointerType, err := c.x86DescriptorMemoryPointer(ins.Args[1])
+	if err != nil {
+		return true, false, err
+	}
+	// LLVM 22's integrated assembler no longer recognizes the BOUND mnemonic,
+	// even for an i386 triple. Constrain the value and bounds pointer to AX/CX
+	// and emit 62 /r with ModRM 00:000:001. The 66 prefix selects BOUNDW.
+	encoding := ".byte 0x62, 0x01"
+	if bits == 16 {
+		encoding = ".byte 0x66, 0x62, 0x01"
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s, %s %s)\n",
+		encoding, "{ax},{cx},~{memory},~{dirflag},~{fpsr},~{flags}", typeName, value, pointerType, pointer)
+	return true, false, nil
+}
diff --git a/amd64_lower_bound_test.go b/amd64_lower_bound_test.go
new file mode 100644
index 000000000..329d1d487
--- /dev/null
+++ b/amd64_lower_bound_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslate386BoundCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "linux-386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := "TEXT boundforms(SB),NOSPLIT,$16-0\n"
+			for _, op := range []string{"BOUNDW", "BOUNDL"} {
+				for _, reg := range []string{"AX", "BX", "CX", "DX", "SP", "BP", "SI", "DI"} {
+					source += "\t" + op + " " + reg + ", 0(SP)\n"
+				}
+				source += "\t" + op + " AX, 8(BX)\n"
+			}
+			source += "\tRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"boundforms": {Name: "boundforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{".byte 0x66, 0x62, 0x01", ".byte 0x62, 0x01", `"{ax},{cx},~{memory},~{dirflag},~{fpsr},~{flags}"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("translated BOUND family missing %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "bound-"+target.name+".ll", "bound-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86BoundRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "BOUNDW AX, 0(BX)"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "BOUNDL AX, 0(BX)"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "BOUNDL X0, 0(BX)"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "BOUNDW $1, 0(BX)"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "BOUNDL AX, BX"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "BOUNDL.Z AX, 0(BX)"},
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+test.instruction+"\n\tRET\n")
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: test.triple,
+					Goarch:       test.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's BOUND tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_branch.go b/amd64_lower_branch.go
index 345ec225a..f54ebfef1 100644
--- a/amd64_lower_branch.go
+++ b/amd64_lower_branch.go
@@ -8,6 +8,16 @@ import (
 func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64EmitBr, emitCondBr amd64EmitCondBr) (ok bool, terminated bool, err error) {
 	switch op {
 	case "CALL":
+		if c.directTail.privateCallTransition(bi) {
+			if ii != 0 || c.directTail.instructions[bi].Op != OpCALL {
+				return true, false, x86DirectTailContext("CALL lost its original source point")
+			}
+			if err := c.lowerPrivateFrameTransition(bi); err != nil {
+				return true, false, err
+			}
+			emitBr(c.blocks[c.directTail.edges[bi][0]].name)
+			return true, true, nil
+		}
 		if len(ins.Args) != 1 {
 			return true, false, fmt.Errorf("amd64 CALL expects 1 operand: %q", ins.Raw)
 		}
@@ -34,6 +44,16 @@ func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64Emi
 			}
 			return true, false, nil
 		case OpSym:
+			if strings.HasPrefix(strings.TrimSpace(ins.Args[0].Sym), "*") {
+				addr, err := c.loadIndirectSymbolAddr(ins.Args[0].Sym)
+				if err != nil {
+					return true, false, err
+				}
+				if err := c.callIndirectAddr(addr); err != nil {
+					return true, false, err
+				}
+				return true, false, nil
+			}
 			if err := c.callSym(ins.Args[0]); err != nil {
 				return true, false, err
 			}
@@ -42,16 +62,21 @@ func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64Emi
 			return true, false, fmt.Errorf("amd64 CALL expects reg or symbol(SB) target: %q", ins.Raw)
 		}
 
-	case "JMP",
-		"JE", "JEQ", "JZ", "JNE", "JNZ",
-		"JL", "JLT", "JLE", "JG", "JGT", "JGE", "JS", "JNS",
-		"JA", "JHI", "JAE", "JHS", "JB", "JLO", "JBE", "JLS", "JNA",
-		"JC", "JNC", "JCC":
-		// ok
 	default:
-		return false, false, nil
+		if op != "JMP" && op != "LOOP" && !isAMD64ConditionalBranch(op) {
+			return false, false, nil
+		}
 	}
-	if len(ins.Args) != 1 {
+	counter, counterKnown, counterErr := x86CounterControlProperties(op, ins, c.goarch)
+	if counterKnown && counterErr != nil {
+		return true, false, counterErr
+	}
+	// The Go assembler accepts a legacy x86 branch-hint operand such as
+	// JEQ $1, target. It is not part of the encoded instruction on current
+	// toolchains. Share its complete resolved-integer grammar with the source
+	// CFG observers; floating/unresolved tokens cannot become zero hints.
+	args := x86DirectTailBranchArgs(ins)
+	if len(args) != 1 {
 		return true, false, fmt.Errorf("amd64 %s expects 1 operand: %q", op, ins.Raw)
 	}
 	target := ""
@@ -65,65 +90,99 @@ func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64Emi
 		}
 		return false
 	}
-	switch ins.Args[0].Kind {
-	case OpIdent:
-		target = ins.Args[0].Ident
-	case OpReg:
-		// Labels like V1 may be tokenized as registers. Prefer block labels;
-		// otherwise treat JMP reg as an indirect tail jump.
-		name := string(ins.Args[0].Reg)
-		if knownBlock(name) {
-			target = name
-			break
-		}
-		if op == "JMP" {
-			addr, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
+	if c.directTail != nil {
+		if bi >= 0 && bi < len(c.directTail.externalTails) && c.directTail.externalTails[bi] && ii == 0 {
+			if op != OpJMP || len(args) != 1 || args[0].Kind != OpSym {
+				return true, false, x86DirectTailContext("typed terminal lost its original source branch")
 			}
-			if err := c.tailCallIndirectAddrAndRet(addr); err != nil {
+			if err := c.tailCallAndRet(args[0]); err != nil {
 				return true, false, err
 			}
 			return true, true, nil
 		}
-		return true, false, fmt.Errorf("amd64 %s invalid register target: %q", op, ins.Raw)
-	case OpSym:
-		s := strings.TrimSpace(ins.Args[0].Sym)
-		// Treat JMP foo(SB) as a tailcall to another TEXT (common in stdlib asm).
-		if op == "JMP" && strings.HasSuffix(s, "(SB)") {
-			if err := c.tailCallAndRet(ins.Args[0]); err != nil {
-				return true, false, err
-			}
-			return true, true, nil
+		if bi < 0 || bi >= len(c.directTail.edges) || ii != 0 || len(c.directTail.edges[bi]) == 0 {
+			return true, false, x86DirectTailContext("branch lost its original source node")
 		}
-		// Local labels sometimes appear with "<>" or (SB) suffix.
-		s = strings.TrimSuffix(strings.TrimSuffix(s, "(SB)"), "<>")
-		target = s
-	case OpMem:
-		// PC-relative branches like "JEQ 2(PC)" are used as a compact way to skip
-		// the next instruction. Handle them by mapping the offset to our block
-		// sequence (blocks are split at terminators, so the pattern works well).
-		if strings.EqualFold(string(ins.Args[0].Mem.Base), "PC") {
-			pcRel = true
-			pcOff = ins.Args[0].Mem.Off
-			break
-		}
-		if op == "JMP" {
-			addr, err := c.addrFromMem(ins.Args[0].Mem)
-			if err != nil {
-				return true, false, err
+		edges := c.directTail.edges[bi]
+		target = c.blocks[edges[len(edges)-1]].name
+	} else {
+		switch args[0].Kind {
+		case OpIdent:
+			target = args[0].Ident
+		case OpReg:
+			// Labels like V1 may be tokenized as registers. Prefer block labels;
+			// otherwise treat JMP reg as an indirect tail jump.
+			name := string(args[0].Reg)
+			if knownBlock(name) {
+				target = name
+				break
 			}
-			p := c.ptrFromAddrI64(addr)
-			fnptr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", fnptr, p)
-			if err := c.tailCallIndirectAddrAndRet("%" + fnptr); err != nil {
-				return true, false, err
+			if op == "JMP" {
+				addr, err := c.loadReg(args[0].Reg)
+				if err != nil {
+					return true, false, err
+				}
+				if err := c.tailCallIndirectAddrAndRet(addr); err != nil {
+					return true, false, err
+				}
+				return true, true, nil
 			}
-			return true, true, nil
+			return true, false, fmt.Errorf("amd64 %s invalid register target: %q", op, ins.Raw)
+		case OpSym:
+			s := strings.TrimSpace(args[0].Sym)
+			if op == "JMP" && strings.HasPrefix(s, "*") {
+				addr, err := c.loadIndirectSymbolAddr(s)
+				if err != nil {
+					return true, false, err
+				}
+				if err := c.tailCallIndirectAddrAndRet(addr); err != nil {
+					return true, false, err
+				}
+				return true, true, nil
+			}
+			// Treat JMP foo(SB) as a tailcall to another TEXT (common in stdlib asm).
+			if op == "JMP" && strings.HasSuffix(s, "(SB)") {
+				if err := c.tailCallAndRet(args[0]); err != nil {
+					return true, false, err
+				}
+				return true, true, nil
+			}
+			// Local labels sometimes appear with "<>" or (SB) suffix.
+			s = strings.TrimSuffix(strings.TrimSuffix(s, "(SB)"), "<>")
+			target = s
+		case OpMem:
+			// PC-relative branches like "JEQ 2(PC)" are used as a compact way to skip
+			// the next instruction. Handle them by mapping the offset to our block
+			// sequence (blocks are split at terminators, so the pattern works well).
+			if strings.EqualFold(string(args[0].Mem.Base), "PC") {
+				pcRel = true
+				pcOff = args[0].Mem.Off
+				break
+			}
+			if op == "JMP" {
+				addr, err := c.addrFromMem(args[0].Mem)
+				if err != nil {
+					return true, false, err
+				}
+				p := c.ptrFromAddrI64(addr)
+				fnptr := c.newTmp()
+				if c.goarch == "386" {
+					fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", fnptr, p)
+					wide := c.newTmp()
+					fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, fnptr)
+					fnptr = wide
+				} else {
+					fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", fnptr, p)
+				}
+				if err := c.tailCallIndirectAddrAndRet("%" + fnptr); err != nil {
+					return true, false, err
+				}
+				return true, true, nil
+			}
+			fallthrough
+		default:
+			return true, false, fmt.Errorf("amd64 %s invalid target: %q", op, ins.Raw)
 		}
-		fallthrough
-	default:
-		return true, false, fmt.Errorf("amd64 %s invalid target: %q", op, ins.Raw)
 	}
 	if !pcRel && target == "" {
 		return true, false, fmt.Errorf("amd64 %s empty target: %q", op, ins.Raw)
@@ -149,70 +208,17 @@ func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64Emi
 	}
 	fall := c.blocks[bi+1].name
 	cond := ""
-	switch op {
-	case "JE", "JEQ", "JZ":
-		cond = c.loadFlag(c.flagsZSlot)
-	case "JNE", "JNZ":
-		z := c.loadFlag(c.flagsZSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, z)
-		cond = "%" + t
-	case "JL", "JLT":
-		cond = c.loadFlag(c.flagsSltSlot)
-	case "JGE":
-		slt := c.loadFlag(c.flagsSltSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, slt)
-		cond = "%" + t
-	case "JS":
-		cond = c.loadFlag(c.flagsSltSlot)
-	case "JNS":
-		slt := c.loadFlag(c.flagsSltSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, slt)
-		cond = "%" + t
-	case "JLE":
-		slt := c.loadFlag(c.flagsSltSlot)
-		z := c.loadFlag(c.flagsZSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t, slt, z)
-		cond = "%" + t
-	case "JG", "JGT":
-		slt := c.loadFlag(c.flagsSltSlot)
-		z := c.loadFlag(c.flagsZSlot)
-		t1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t1, slt, z)
-		t2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", t2, t1)
-		cond = "%" + t2
-	case "JB", "JLO", "JC":
-		cond = c.loadFlag(c.flagsCFSlot)
-	case "JNC", "JCC":
-		cf := c.loadFlag(c.flagsCFSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, cf)
-		cond = "%" + t
-	case "JAE", "JHS":
-		cf := c.loadFlag(c.flagsCFSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", t, cf)
-		cond = "%" + t
-	case "JBE", "JLS", "JNA":
-		cf := c.loadFlag(c.flagsCFSlot)
-		z := c.loadFlag(c.flagsZSlot)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t, cf, z)
-		cond = "%" + t
-	case "JA", "JHI":
-		cf := c.loadFlag(c.flagsCFSlot)
-		z := c.loadFlag(c.flagsZSlot)
-		t1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", t1, cf, z)
-		t2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", t2, t1)
-		cond = "%" + t2
-	default:
-		return true, false, fmt.Errorf("amd64: unsupported branch %s", op)
+	if counterKnown {
+		cond, err = c.counterControlCondition(counter)
+	} else {
+		condition := x86BranchCondition(op)
+		if condition == "" {
+			return true, false, fmt.Errorf("amd64: unsupported branch %s", op)
+		}
+		cond, err = c.x86Condition(condition)
+	}
+	if err != nil {
+		return true, false, err
 	}
 
 	if err := emitCondBr(cond, target, fall); err != nil {
@@ -221,9 +227,42 @@ func (c *amd64Ctx) lowerBranch(bi int, ii int, op Op, ins Instr, emitBr amd64Emi
 	return true, true, nil
 }
 
+func (c *amd64Ctx) loadIndirectSymbolAddr(sym string) (string, error) {
+	sym = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(sym), "*"))
+	if !strings.HasSuffix(sym, "(SB)") {
+		return "", fmt.Errorf("amd64 indirect branch expects register, memory, or *symbol(SB), got %q", sym)
+	}
+	ptr, err := c.ptrFromSB(sym)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	if c.goarch == "386" {
+		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", value, ptr)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, value)
+		return "%" + wide, nil
+	}
+	fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", value, ptr)
+	return "%" + value, nil
+}
+
 func (c *amd64Ctx) callIndirectAddr(addr string) error {
 	fptr := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", fptr, addr)
+	if sig := c.indirectABI0; sig != nil {
+		args, err := c.abi0CallArgs("indirect callback", *sig)
+		if err != nil {
+			return err
+		}
+		if sig.Ret == Void {
+			fmt.Fprintf(c.b, "  call void %%%s(%s)\n", fptr, strings.Join(args, ", "))
+			return nil
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s %%%s(%s)\n", result, sig.Ret, fptr, strings.Join(args, ", "))
+		return c.storeABI0CallResult("indirect callback", *sig, "%"+result)
+	}
 	di, _ := c.loadReg(DI)
 	si, _ := c.loadReg(SI)
 	dx, _ := c.loadReg(DX)
@@ -237,6 +276,15 @@ func (c *amd64Ctx) callIndirectAddr(addr string) error {
 }
 
 func (c *amd64Ctx) tailCallIndirectAddrAndRet(addr string) error {
+	if len(c.indirectLabels) != 0 {
+		ptr := c.ptrFromAddrI64(addr)
+		labels := make([]string, len(c.indirectLabels))
+		for i, label := range c.indirectLabels {
+			labels[i] = "label %" + amd64LLVMBlockName(label)
+		}
+		fmt.Fprintf(c.b, "  indirectbr ptr %s, [%s]\n", ptr, strings.Join(labels, ", "))
+		return nil
+	}
 	if err := c.callIndirectAddr(addr); err != nil {
 		return err
 	}
@@ -294,11 +342,12 @@ func (c *amd64Ctx) callSym(symOp Operand) error {
 	if !strings.HasSuffix(s, "(SB)") {
 		return fmt.Errorf("amd64 call expects (SB) symbol, got %q", s)
 	}
+	internalABI := strings.HasSuffix(strings.TrimSuffix(s, "(SB)"), "<ABIInternal>")
 	s = strings.TrimSuffix(s, "(SB)")
 	callee := c.resolve(s)
 	// Syscall stubs invoke runtime entersyscall/exitsyscall around SYSCALL.
 	// llgo runtime does not require these scheduler hooks at this layer.
-	if callee == "runtime.entersyscall" || callee == "runtime.exitsyscall" {
+	if arm64ElidesSchedulerHook(callee) {
 		return nil
 	}
 
@@ -310,6 +359,25 @@ func (c *amd64Ctx) callSym(symOp Operand) error {
 	}
 	callee = funcSigSymbol(callee, csig)
 
+	stackABI := !internalABI && len(csig.ArgRegs) == 0 &&
+		(len(csig.Frame.Params) != 0 || len(csig.Frame.Results) != 0)
+	if stackABI {
+		args, err := c.abi0CallArgs(callee, csig)
+		if err != nil {
+			return err
+		}
+		if csig.Ret == Void {
+			fmt.Fprintf(c.b, "  call void %s(%s)\n", llvmGlobal(callee), strings.Join(args, ", "))
+			return nil
+		}
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s %s(%s)\n", t, csig.Ret, llvmGlobal(callee), strings.Join(args, ", "))
+		if len(csig.Frame.Results) != 0 {
+			return c.storeABI0CallResult(callee, csig, "%"+t)
+		}
+		return fmt.Errorf("amd64 call %q: ABI0 result %s has no frame slot", callee, csig.Ret)
+	}
+
 	args := make([]string, 0, len(csig.Args))
 	goABI := []Reg{AX, BX, CX, DI, SI, Reg("R8"), Reg("R9"), Reg("R10"), Reg("R11")}
 	regCursor := 0
@@ -418,12 +486,13 @@ func (c *amd64Ctx) tailCallAndRet(symOp Operand) error {
 		// If ArgRegs is empty, default to register-based passing (ABIInternal-ish)
 		// because most intra-asm tailcalls depend on explicit register setup.
 		//
-		// Exception: for tailcalls to Go functions with an identical signature,
+		// Exception: for tailcalls to Go functions with identical argument types,
 		// use the current function's LLVM args. This matches stdlib patterns like
 		// "JMP ·countGeneric(SB)" that happen before any register shuffling and
-		// are stack-ABI tailcalls in the original asm.
+		// are stack-ABI tailcalls in the original asm. The return types may differ
+		// while using ABI-equivalent physical result slots.
 		useLLVMArgs := false
-		if len(csig.ArgRegs) == 0 && len(csig.Args) == len(c.sig.Args) && csig.Ret == c.sig.Ret {
+		if len(csig.ArgRegs) == 0 && len(csig.Args) == len(c.sig.Args) {
 			same := true
 			for j := 0; j < len(csig.Args); j++ {
 				if csig.Args[j] != c.sig.Args[j] {
@@ -527,8 +596,22 @@ func (c *amd64Ctx) tailCallAndRet(symOp Operand) error {
 		return nil
 	}
 	if c.sig.Ret != csig.Ret {
+		if adapted, ok, err := c.adaptTailCallAggregateReturn("%"+t, csig.Ret, c.sig.Ret); err != nil {
+			return fmt.Errorf("amd64 tailcall return type mismatch for %q: %w", callee, err)
+		} else if ok {
+			fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, adapted)
+			return nil
+		}
 		conv := c.newTmp()
 		switch {
+		case c.goarch == "386" && csig.Ret == I32 && c.sig.Ret == Ptr:
+			fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %%%s to ptr\n", conv, t)
+			fmt.Fprintf(c.b, "  ret ptr %%%s\n", conv)
+			return nil
+		case c.goarch == "386" && csig.Ret == Ptr && c.sig.Ret == I32:
+			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i32\n", conv, t)
+			fmt.Fprintf(c.b, "  ret i32 %%%s\n", conv)
+			return nil
 		case csig.Ret == I64 && (c.sig.Ret == I1 || c.sig.Ret == I8 || c.sig.Ret == I16 || c.sig.Ret == I32):
 			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to %s\n", conv, t, c.sig.Ret)
 			fmt.Fprintf(c.b, "  ret %s %%%s\n", c.sig.Ret, conv)
@@ -552,3 +635,47 @@ func (c *amd64Ctx) tailCallAndRet(symOp Operand) error {
 	fmt.Fprintf(c.b, "  ret %s %%%s\n", c.sig.Ret, t)
 	return nil
 }
+
+func (c *amd64Ctx) adaptTailCallAggregateReturn(value string, fromTy, toTy LLVMType) (string, bool, error) {
+	fromFields, fromAggregate := parseLiteralStructFields(fromTy)
+	toFields, toAggregate := parseLiteralStructFields(toTy)
+	if !fromAggregate || !toAggregate {
+		return "", false, nil
+	}
+	if len(fromFields) != len(toFields) {
+		return "", false, fmt.Errorf("caller %s and callee %s use different aggregate field counts", toTy, fromTy)
+	}
+
+	wordTy := I64
+	if c.goarch == "386" {
+		wordTy = I32
+	}
+	for i := range fromFields {
+		from, to := fromFields[i], toFields[i]
+		if from == to || (from == wordTy && to == Ptr) || (from == Ptr && to == wordTy) {
+			continue
+		}
+		return "", false, fmt.Errorf("caller field %d has type %s but callee field has ABI-incompatible type %s", i, to, from)
+	}
+
+	result := "undef"
+	for i := range fromFields {
+		from, to := fromFields[i], toFields[i]
+		extracted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, fromTy, value, i)
+		field := "%" + extracted
+		if from != to {
+			converted := c.newTmp()
+			if from == wordTy && to == Ptr {
+				fmt.Fprintf(c.b, "  %%%s = inttoptr %s %s to ptr\n", converted, wordTy, field)
+			} else {
+				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to %s\n", converted, field, wordTy)
+			}
+			field = "%" + converted
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %s, %d\n", inserted, toTy, result, to, field, i)
+		result = "%" + inserted
+	}
+	return result, true, nil
+}
diff --git a/amd64_lower_branch_test.go b/amd64_lower_branch_test.go
index da0c48225..ebf12e273 100644
--- a/amd64_lower_branch_test.go
+++ b/amd64_lower_branch_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
diff --git a/amd64_lower_broadcast.go b/amd64_lower_broadcast.go
new file mode 100644
index 000000000..4bf364f2a
--- /dev/null
+++ b/amd64_lower_broadcast.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerPackedScalarBroadcast implements the complete Go 1.27
+// _yvpbroadcastb operand table shared by VPBROADCASTB/W/D/Q.
+func (c *amd64Ctx) lowerPackedScalarBroadcast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86BroadcastProperties(op, ins, c.goarch)
+	if !known || f.kind != x86BroadcastInteger {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	baseOp, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	laneBits, byteWidth := f.laneBits, f.byteWidth
+	dstArg := ins.Args[f.destination]
+	masked, zeroing := f.mask >= 0, f.zeroing
+	var mask string
+	if masked {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	load := func() (string, error) {
+		return c.loadPackedBroadcastScalar(ins.Args[0], laneBits, ins.x86Encoded)
+	}
+	var scalar string
+	if masked && ins.Args[0].Kind != OpReg {
+		// Any active destination lane enables the one scalar read. Irrelevant
+		// high K bits must not turn a fully masked memory source into a load.
+		lanes := byteWidth * 8 / laneBits
+		relevant, active := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", relevant, mask, uint64(1)<<uint(lanes)-1)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, relevant)
+		scalar, err = c.loadX86ScalarIf(laneBits, "%"+active, load)
+	} else {
+		scalar, err = load()
+	}
+	if err != nil {
+		return true, false, fmt.Errorf("amd64 %s source: %w", baseOp, err)
+	}
+	lanes := byteWidth * 8 / laneBits
+	result := amd64SplatInteger(c, lanes, laneBits, scalar)
+	if masked {
+		oldBytes, err := c.loadPackedCompareBytes(dstArg, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, laneBits, result, old, mask, zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(dstArg, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) loadPackedBroadcastScalar(src Operand, laneBits int, rawEncoded bool) (string, error) {
+	if src.Kind == OpImm && rawEncoded {
+		value := src.Imm
+		switch laneBits {
+		case 8:
+			value = int64(int8(value))
+		case 16:
+			value = int64(int16(value))
+		case 32:
+			value = int64(int32(value))
+		}
+		return fmt.Sprintf("%d", value), nil
+	}
+	if src.Kind == OpReg {
+		if isAMD64XReg(src.Reg) {
+			bytesValue, err := c.loadX(src.Reg)
+			if err != nil {
+				return "", err
+			}
+			lanes := 128 / laneBits
+			laneVector := c.bitcastVectorBytesToIntegerLanes(16, lanes, laneBits, bytesValue)
+			low := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 0\n", low, lanes, laneBits, laneVector)
+			return "%" + low, nil
+		}
+		if !isAMD64YrlRegister(src.Reg) {
+			return "", fmt.Errorf("expected an X register, GP register, or memory, got %s", src.String())
+		}
+		return c.evalIntSized(src, amd64IntegerTypeForBits(laneBits))
+	}
+	if !isAMD64MemoryOperand(src) {
+		return "", fmt.Errorf("expected an X register, GP register, or memory, got %s", src.String())
+	}
+	bytes, err := c.loadX86PackedShiftBytes(src, laneBits/8, true)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, laneBits/8, bytes, laneBits)
+	return "%" + value, nil
+}
+
+// isAMD64YrlRegister mirrors Go's amd64 Yrl register class. Byte aliases,
+// vector, mask, MMX, and x87 registers are deliberately excluded.
+func isAMD64YrlRegister(r Reg) bool {
+	switch strings.ToUpper(string(r)) {
+	case "AX", "BX", "CX", "DX", "SP", "BP", "SI", "DI",
+		"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+		return true
+	default:
+		return false
+	}
+}
diff --git a/amd64_lower_broadcast_block.go b/amd64_lower_broadcast_block.go
new file mode 100644
index 000000000..89b6f01b3
--- /dev/null
+++ b/amd64_lower_broadcast_block.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedBlockBroadcastSpec struct {
+	sourceBytes       int
+	laneBits          int
+	allowXSource      bool
+	vexMemoryOnly     bool
+	allowDestinations map[int]bool
+}
+
+var amd64PackedBlockBroadcastSpecs = map[string]amd64PackedBlockBroadcastSpec{
+	"VBROADCASTF128":  {sourceBytes: 16, laneBits: 64, vexMemoryOnly: true, allowDestinations: map[int]bool{32: true}},
+	"VBROADCASTI128":  {sourceBytes: 16, laneBits: 64, vexMemoryOnly: true, allowDestinations: map[int]bool{32: true}},
+	"VBROADCASTF32X2": {sourceBytes: 8, laneBits: 32, allowXSource: true, allowDestinations: map[int]bool{32: true, 64: true}},
+	"VBROADCASTI32X2": {sourceBytes: 8, laneBits: 32, allowXSource: true, allowDestinations: map[int]bool{16: true, 32: true, 64: true}},
+	"VBROADCASTF32X4": {sourceBytes: 16, laneBits: 32, allowDestinations: map[int]bool{32: true, 64: true}},
+	"VBROADCASTF64X2": {sourceBytes: 16, laneBits: 64, allowDestinations: map[int]bool{32: true, 64: true}},
+	"VBROADCASTI32X4": {sourceBytes: 16, laneBits: 32, allowDestinations: map[int]bool{32: true, 64: true}},
+	"VBROADCASTI64X2": {sourceBytes: 16, laneBits: 64, allowDestinations: map[int]bool{32: true, 64: true}},
+	"VBROADCASTF32X8": {sourceBytes: 32, laneBits: 32, allowDestinations: map[int]bool{64: true}},
+	"VBROADCASTF64X4": {sourceBytes: 32, laneBits: 64, allowDestinations: map[int]bool{64: true}},
+	"VBROADCASTI32X8": {sourceBytes: 32, laneBits: 32, allowDestinations: map[int]bool{64: true}},
+	"VBROADCASTI64X4": {sourceBytes: 32, laneBits: 64, allowDestinations: map[int]bool{64: true}},
+}
+
+// lowerPackedBlockBroadcast implements all Go 1.27 EVEX packed-block
+// broadcast tables. The X2 forms copy the low 64 source bits; the X4 and X8
+// forms accept only 128- and 256-bit memory sources respectively.
+func (c *amd64Ctx) lowerPackedBlockBroadcast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86BroadcastProperties(op, ins, c.goarch)
+	if !known || f.kind != x86BroadcastBlock {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	baseOp, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec := amd64PackedBlockBroadcastSpecs[baseOp]
+	source, destination := ins.Args[0], ins.Args[f.destination]
+	destinationBytes := f.byteWidth
+	masked, zeroing := f.mask >= 0, f.zeroing
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	var block string
+	if mask != "" && source.Kind != OpReg {
+		// E6 suppresses each source element unless at least one repeated
+		// destination lane selects it. Fold the destination mask onto the
+		// source tuple before reusing the exact guarded volatile lane reader.
+		sourceLanes := spec.sourceBytes * 8 / spec.laneBits
+		folded := mask
+		for shift := sourceLanes; shift < destinationBytes*8/spec.laneBits; shift += sourceLanes {
+			high, combined := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", high, mask, shift)
+			fmt.Fprintf(c.b, "  %%%s = or i64 %s, %%%s\n", combined, folded, high)
+			folded = "%" + combined
+		}
+		lanes, readErr := c.loadX86PackedShiftLanes(source, spec.sourceBytes, spec.laneBits, false, folded)
+		err = readErr
+		if err == nil {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n",
+				value, sourceLanes, spec.laneBits, lanes, spec.sourceBytes)
+			block = "%" + value
+		}
+	} else {
+		block, err = c.loadPackedBlockBroadcastSource(source, spec.sourceBytes)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	broadcast := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> %s\n",
+		broadcast, spec.sourceBytes, block, spec.sourceBytes, block, destinationBytes, llvmRepeatI8Mask(spec.sourceBytes, destinationBytes))
+	result := "%" + broadcast
+
+	if masked {
+		lanes := destinationBytes * 8 / spec.laneBits
+		computed := c.bitcastVectorBytesToIntegerLanes(destinationBytes, lanes, spec.laneBits, result)
+		oldBytes, err := c.loadPackedCompareBytes(destination, destinationBytes)
+		if err != nil {
+			return true, false, err
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(destinationBytes, lanes, spec.laneBits, oldBytes)
+		maskedResult := amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computed, old, mask, zeroing)
+		cast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", cast, lanes, spec.laneBits, maskedResult, destinationBytes)
+		result = "%" + cast
+	}
+	return true, false, c.storePackedMoveOperand(destination, destinationBytes, result)
+}
+
+func amd64PackedBlockXSourceHint(allowed bool) string {
+	if allowed {
+		return " or X-register source"
+	}
+	return ""
+}
+
+func (c *amd64Ctx) loadPackedBlockBroadcastSource(source Operand, sourceBytes int) (string, error) {
+	if source.Kind == OpReg {
+		value, err := c.loadX(source.Reg)
+		if err != nil {
+			return "", err
+		}
+		words := c.newTmp()
+		low := c.newTmp()
+		bytesValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", words, value)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", low, words)
+		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %%%s to <8 x i8>\n", bytesValue, low)
+		return "%" + bytesValue, nil
+	}
+
+	return c.loadX86PackedShiftBytes(source, sourceBytes, true)
+}
diff --git a/amd64_lower_broadcast_block_test.go b/amd64_lower_broadcast_block_test.go
new file mode 100644
index 000000000..a8c019ae7
--- /dev/null
+++ b/amd64_lower_broadcast_block_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedBlockBroadcastCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 exposes the complete VEX/EVEX packed-block broadcast family as:
+	//
+	//   VBROADCASTF128   m128   -> Y
+	//   VBROADCASTI128   m128   -> Y
+	//   VBROADCASTF32X2  X/m64  -> Y/Z
+	//   VBROADCASTI32X2  X/m64  -> X/Y/Z
+	//   VBROADCASTF32X4  m128   -> Y/Z
+	//   VBROADCASTF64X2  m128   -> Y/Z
+	//   VBROADCASTI32X4  m128   -> Y/Z
+	//   VBROADCASTI64X2  m128   -> Y/Z
+	//   VBROADCASTF32X8  m256   -> Z
+	//   VBROADCASTF64X4  m256   -> Z
+	//   VBROADCASTI32X8  m256   -> Z
+	//   VBROADCASTI64X4  m256   -> Z
+	//
+	// Every form also accepts K1-K7 merge masking and .Z zero masking.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastY := 15
+			lastZ := 21
+			if target.goarch == "386" {
+				lastY, lastZ = 7, 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT packedblockbroadcastforms(SB),$0-0\n")
+			fmt.Fprintf(&src, "\tVBROADCASTF128 0(AX), Y%d\n", lastY)
+			fmt.Fprintf(&src, "\tVBROADCASTI128 16(AX), Y%d\n", lastY)
+			src.WriteString("\tVBROADCASTF32X2 X20, Y21\n")
+			src.WriteString("\tVBROADCASTF32X2 8(AX), K1, Y20\n")
+			fmt.Fprintf(&src, "\tVBROADCASTF32X2.Z X20, K2, Z%d\n", lastZ)
+			src.WriteString("\tVBROADCASTI32X2 X20, X21\n")
+			src.WriteString("\tVBROADCASTI32X2 16(AX), K3, Y20\n")
+			fmt.Fprintf(&src, "\tVBROADCASTI32X2.Z X20, K4, Z%d\n", lastZ)
+			for _, op := range []string{
+				"VBROADCASTF32X4", "VBROADCASTF64X2",
+				"VBROADCASTI32X4", "VBROADCASTI64X2",
+			} {
+				fmt.Fprintf(&src, "\t%s 24(AX), Y20\n", op)
+				fmt.Fprintf(&src, "\t%s 40(AX), K5, Y21\n", op)
+				fmt.Fprintf(&src, "\t%s.Z 56(AX), K6, Z%d\n", op, lastZ)
+			}
+			for _, op := range []string{
+				"VBROADCASTF32X8", "VBROADCASTF64X4",
+				"VBROADCASTI32X8", "VBROADCASTI64X4",
+			} {
+				fmt.Fprintf(&src, "\t%s 72(AX), Z%d\n", op, lastZ)
+				fmt.Fprintf(&src, "\t%s.Z 104(AX), K7, Z%d\n", op, lastZ)
+			}
+			src.WriteString("\tRET\n")
+			source := src.String()
+			if target.goarch == "386" {
+				// High Go spellings have no physical mode32 binding. The
+				// independent authority controls retain their Context cases.
+				source = strings.NewReplacer("X20", "X3", "X21", "X4", "Y20", "Y3", "Y21", "Y4").Replace(source)
+			}
+			ll := x86UnboundVoidScalarFormatObject(t, source, "packedblockbroadcastforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-block-broadcast-"+target.name+".ll", "packed-block-broadcast-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedBlockBroadcastRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VBROADCASTF128 (AX), Y16",
+		"VBROADCASTI128 (AX), Y16",
+		"VBROADCASTF128 X0, Y1",
+		"VBROADCASTI128 X0, Y1",
+		"VBROADCASTF128 (AX), X1",
+		"VBROADCASTI128 (AX), Z1",
+		"VBROADCASTF128 (AX), K1, Y1",
+		"VBROADCASTI128.Z (AX), K1, Y1",
+		"VBROADCASTF32X2 X0, X1",
+		"VBROADCASTF32X2 Y0, Y1",
+		"VBROADCASTI32X2 Y0, Y1",
+		"VBROADCASTF32X4 X0, Y1",
+		"VBROADCASTF64X2 X0, Y1",
+		"VBROADCASTI32X4 X0, Y1",
+		"VBROADCASTI64X2 X0, Y1",
+		"VBROADCASTF32X4 (AX), X1",
+		"VBROADCASTF32X8 (AX), Y1",
+		"VBROADCASTF64X4 Y0, Z1",
+		"VBROADCASTI32X8 Y0, Z1",
+		"VBROADCASTI64X4 (AX), Y1",
+		"VBROADCASTI32X4 (AX), K0, Y1",
+		"VBROADCASTI32X4.Z (AX), Y1",
+		"VBROADCASTI32X4.BCST (AX), Y1",
+		"VBROADCASTI32X4 (AX), K1, K2, Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			assertX86PackedBlockBroadcastRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VBROADCASTF128 (AX), Y16",
+		"VBROADCASTI128 (AX), Y16",
+		"VBROADCASTI32X2 X20, Z8",
+		"VBROADCASTI32X4 (AX), Z20",
+	} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+		assertX86PackedBlockBroadcastRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86PackedBlockBroadcastRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed-block broadcast forms", instruction)
+	}
+}
+
+func TestAMD64LegacyBlockBroadcastRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT legacyblockbroadcast(SB),$0-16
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	VBROADCASTF128 (BX), Y0
+	VMOVDQU Y0, 0(AX)
+	VBROADCASTI128 (BX), Y1
+	VMOVDQU Y1, 32(AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"legacyblockbroadcast": {Name: "legacyblockbroadcast", Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+extern void legacyblockbroadcast(uint8_t *, const uint8_t *);
+int main(void) {
+  const uint8_t source[16] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff};
+  uint8_t out[64] = {0};
+  legacyblockbroadcast(out, source);
+  for (int block = 0; block < 2; block++) {
+    if (memcmp(out + 32*block, source, 16) || memcmp(out + 32*block + 16, source, 16)) return block + 1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy_block_broadcast", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_broadcast_float.go b/amd64_lower_broadcast_float.go
new file mode 100644
index 000000000..5b15db794
--- /dev/null
+++ b/amd64_lower_broadcast_float.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// lowerScalarFloatBroadcast implements all Go 1.27 _yvbroadcastss and
+// _yvbroadcastsd operand forms, including EVEX mask merge and zeroing.
+func (c *amd64Ctx) lowerScalarFloatBroadcast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86BroadcastProperties(op, ins, c.goarch)
+	if !known || f.kind != x86BroadcastFloat {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	laneBits, byteWidth := f.laneBits, f.byteWidth
+	source, dst := ins.Args[0], ins.Args[f.destination]
+	masked, zeroing := f.mask >= 0, f.zeroing
+	var mask string
+	if masked {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	var scalar string
+	if source.Kind == OpReg {
+		scalar, err = c.loadXLowInteger(source.Reg, laneBits)
+	} else if source.Kind == OpImm {
+		scalar, err = c.evalIntSized(source, amd64IntegerTypeForBits(laneBits))
+	} else {
+		if masked {
+			// Broadcasting reads the scalar only if any destination lane is
+			// active. High K bits outside this vector's lane count do not
+			// enable the load; checking only mask bit zero is also incorrect.
+			lanes := byteWidth * 8 / laneBits
+			relevant, active := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", relevant, mask, uint64(1)<<uint(lanes)-1)
+			fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, relevant)
+			scalar, err = c.loadX86ScalarIf(laneBits, "%"+active, func() (string, error) {
+				return c.loadPackedBroadcastScalar(source, laneBits, false)
+			})
+		} else {
+			scalar, err = c.loadPackedBroadcastScalar(source, laneBits, false)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+
+	lanes := byteWidth * 8 / laneBits
+	result := amd64SplatInteger(c, lanes, laneBits, scalar)
+	if masked {
+		oldBytes, err := c.loadPackedCompareBytes(dst, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, laneBits, result, old, mask, zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(dst, byteWidth, "%"+out)
+}
diff --git a/amd64_lower_broadcast_mask.go b/amd64_lower_broadcast_mask.go
new file mode 100644
index 000000000..5fbdec76a
--- /dev/null
+++ b/amd64_lower_broadcast_mask.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64MaskBroadcastSpec struct {
+	sourceBits int
+	laneBits   int
+}
+
+// amd64MaskBroadcastSpecs is the complete Go 1.27 _yvpbroadcastmb2q grammar.
+// The low byte/word of a K register is zero-extended and broadcast into every
+// qword/dword lane of an EVEX X, Y, or Z destination.
+var amd64MaskBroadcastSpecs = map[Op]amd64MaskBroadcastSpec{
+	"VPBROADCASTMB2Q": {sourceBits: 8, laneBits: 64},
+	"VPBROADCASTMW2D": {sourceBits: 16, laneBits: 32},
+}
+
+func (c *amd64Ctx) lowerMaskRegisterBroadcast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86BroadcastProperties(op, ins, c.goarch)
+	if !known || f.kind != x86BroadcastMask {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	spec := amd64MaskBroadcastSpecs[Op(strings.ToUpper(string(op)))]
+	byteWidth := f.byteWidth
+	mask, err := c.loadK(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, mask, spec.sourceBits)
+	scalar := "%" + narrow
+	if spec.sourceBits != spec.laneBits {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i%d\n", wide, spec.sourceBits, scalar, spec.laneBits)
+		scalar = "%" + wide
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	result := amd64SplatInteger(c, lanes, spec.laneBits, scalar)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(ins.Args[1], byteWidth, "%"+out)
+}
diff --git a/amd64_lower_broadcast_mask_test.go b/amd64_lower_broadcast_mask_test.go
new file mode 100644
index 000000000..0cdde793d
--- /dev/null
+++ b/amd64_lower_broadcast_mask_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64MaskBroadcastGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64MaskBroadcastSpec{
+		"VPBROADCASTMB2Q": {sourceBits: 8, laneBits: 64},
+		"VPBROADCASTMW2D": {sourceBits: 16, laneBits: 32},
+	}
+	if len(amd64MaskBroadcastSpecs) != len(expected) {
+		t.Fatalf("mask-broadcast grammar has %d entries, want %d", len(amd64MaskBroadcastSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64MaskBroadcastSpecs[op]; !ok {
+			t.Errorf("mask-broadcast grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("mask-broadcast grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86MaskBroadcastCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			xyLast, zLast := 31, 31
+			if target.goarch == "386" {
+				xyLast, zLast = 7, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT maskbroadcastforms(SB),$0-0\n")
+			for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+				fmt.Fprintf(&source, "\t%s K0, X%d\n", op, xyLast)
+				fmt.Fprintf(&source, "\t%s K7, Y%d\n", op, xyLast)
+				fmt.Fprintf(&source, "\t%s K1, Z%d\n", op, zLast)
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "maskbroadcastforms", target.goarch, target.triple)
+			for _, want := range []string{"<2 x i64>", "<8 x i32>", "<8 x i64>", "<16 x i32>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("mask broadcast lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "mask-broadcast-"+target.name+".ll", "mask-broadcast-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86MaskBroadcastRejectsFormsOutsideGoTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPBROADCASTMB2Q AX, X0",
+		"VPBROADCASTMW2D K8, X0",
+		"VPBROADCASTMB2Q K1, K2",
+		"VPBROADCASTMW2D.Z K1, X0",
+		"VPBROADCASTMB2Q K1, K2, X0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvpbroadcastmb2q table", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64MaskBroadcastRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT maskbroadcastsemantics(SB),$0-16
+	MOVQ out+0(FP), CX
+	MOVQ mask+8(FP), AX
+	KMOVQ AX, K1
+	STC
+	VPBROADCASTMB2Q K1, X0
+	MOVUPS X0, 0(CX)
+	VPBROADCASTMW2D K1, X1
+	MOVUPS X1, 16(CX)
+	SETCS 32(CX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"maskbroadcastsemantics": {
+			Name: "maskbroadcastsemantics", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void maskbroadcastsemantics(uint8_t *, uint64_t);
+int main(void) {
+  uint8_t out[33] = {0};
+  uint64_t q[2]; uint32_t d[4];
+  maskbroadcastsemantics(out, UINT64_C(0x1234beefa5));
+  memcpy(q, out, 16); memcpy(d, out + 16, 16);
+  if (q[0] != UINT64_C(0xa5) || q[1] != UINT64_C(0xa5)) return 10;
+  for (int i = 0; i < 4; i++) if (d[i] != UINT32_C(0xefa5)) return 11 + i;
+  if (out[32] != 1) return 20;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mask_broadcast_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_byte_shift.go b/amd64_lower_byte_shift.go
new file mode 100644
index 000000000..7f235c2bf
--- /dev/null
+++ b/amd64_lower_byte_shift.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// lowerPackedByteShift implements Go 1.27's PSLLO/PSRLO aliases and
+// PSLLDQ/PSRLDQ vector family. Every operation shifts bytes independently
+// within each 128-bit lane and fills vacated bytes with zero.
+func (c *amd64Ctx) lowerPackedByteShift(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerX86PackedShift(op, ins)
+}
+
+func amd64SignedImmediate(operand Operand, bits int) bool {
+	if operand.Kind != OpImm || operand.ImmIsFloat || operand.ImmRaw != "" || bits <= 0 || bits >= 63 {
+		return false
+	}
+	limit := int64(1) << (bits - 1)
+	return operand.Imm >= -limit && operand.Imm < limit
+}
+
+func amd64VectorByteShiftImmediate(operand Operand) bool {
+	return operand.Kind == OpImm && !operand.ImmIsFloat && operand.ImmRaw == "" && operand.Imm >= -128 && operand.Imm <= 255
+}
+
+func amd64PackedByteShiftRequiresEVEX(source, destination Operand, byteWidth int) bool {
+	if byteWidth == 64 || isAMD64MemoryOperand(source) {
+		return true
+	}
+	for _, operand := range []Operand{source, destination} {
+		index, ok := amd64VectorRegisterIndex(operand.Reg, byteWidth)
+		if !ok || index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *amd64Ctx) emitPackedByteShift(byteWidth int, source string, count uint8, left bool) string {
+	if count >= 16 {
+		return "zeroinitializer"
+	}
+	result := "zeroinitializer"
+	for laneBase := 0; laneBase < byteWidth; laneBase += 16 {
+		for destinationByte := 0; destinationByte < 16; destinationByte++ {
+			sourceByte := destinationByte + int(count)
+			if left {
+				sourceByte = destinationByte - int(count)
+			}
+			if sourceByte < 0 || sourceByte >= 16 {
+				continue
+			}
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", extracted, byteWidth, source, laneBase+sourceByte)
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i8> %s, i8 %%%s, i32 %d\n", inserted, byteWidth, result, extracted, laneBase+destinationByte)
+			result = "%" + inserted
+		}
+	}
+	return result
+}
diff --git a/amd64_lower_byte_shift_test.go b/amd64_lower_byte_shift_test.go
new file mode 100644
index 000000000..958b0b34f
--- /dev/null
+++ b/amd64_lower_byte_shift_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedByteShiftCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			zSource, zDestination := 16, 31
+			if target.goarch == "386" {
+				legacyLast = 7
+				zSource, zDestination = 6, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedbyteshiftforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"PSLLO", "PSLLDQ", "PSRLO", "PSRLDQ"} {
+				fmt.Fprintf(&source, "\t%s $-128, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s $127, X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VPSLLDQ", "VPSRLDQ"} {
+				source.WriteString("\t" + op + " $-128, X0, X1\n")
+				source.WriteString("\t" + op + " $255, Y0, Y1\n")
+				source.WriteString("\t" + op + " $1, 8(AX), X2\n")
+				source.WriteString("\t" + op + " $2, 16(AX), Y2\n")
+				fmt.Fprintf(&source, "\t%s $3, X%d, X%d\n", op, zSource, zDestination)
+				fmt.Fprintf(&source, "\t%s $4, Z%d, Z%d\n", op, zSource, zDestination)
+			}
+			source.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "packedbyteshiftforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-byte-shift-"+target.name+".ll", "packed-byte-shift-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedByteShiftRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PSLLO $-129, X0",
+		"PSLLDQ $128, X0",
+		"PSRLO $1, X16",
+		"PSRLDQ $1, Y0",
+		"PSLLDQ.Z $1, X0",
+		"VPSLLDQ $-129, X0, X1",
+		"VPSRLDQ $256, X0, X1",
+		"VPSLLDQ $-1, 8(AX), X1",
+		"VPSRLDQ $-1, X16, X1",
+		"VPSLLDQ $-1, Z0, Z1",
+		"VPSRLDQ $1, X0, Y1",
+		"VPSLLDQ $1, X0, K1, X1",
+		"VPSRLDQ.Z $1, X0, X1",
+		"VPSLLDQ $1, X0, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedByteShiftRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PSLLO $1, X8",
+		"PSRLO $1, X15",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedByteShiftRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedByteShiftRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed byte-shift tables for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64PackedByteShiftRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT packedbyteshift(SB),NOSPLIT,$0-16
+	MOVQ out+0(FP), AX
+	MOVQ in+8(FP), BX
+	VMOVDQU (BX), Y0
+	VPSLLDQ $3, Y0, Y1
+	VMOVDQU Y1, 0(AX)
+	VPSRLDQ $5, Y0, Y1
+	VMOVDQU Y1, 32(AX)
+	VPSLLDQ $-1, Y0, Y1
+	VMOVDQU Y1, 64(AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packedbyteshift": {Name: "packedbyteshift", Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void packedbyteshift(uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t in[32], out[96];
+  for (int i = 0; i < 32; i++) in[i] = (uint8_t)(i+1);
+  for (int i = 0; i < 96; i++) out[i] = 0xff;
+  packedbyteshift(out, in);
+  for (int lane = 0; lane < 2; lane++) for (int i = 0; i < 16; i++) {
+    int base = lane*16;
+    uint8_t left = i < 3 ? 0 : in[base+i-3];
+    uint8_t right = i+5 >= 16 ? 0 : in[base+i+5];
+    if (out[base+i] != left) return 10+base+i;
+    if (out[32+base+i] != right) return 50+base+i;
+    if (out[64+base+i] != 0) return 90+base+i;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_byte_shift", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_bzhi.go b/amd64_lower_bzhi.go
new file mode 100644
index 000000000..318593e13
--- /dev/null
+++ b/amd64_lower_bzhi.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import "fmt"
+
+// lowerBZHI implements Go 1.27's complete _ybextrl operand row for BZHIL/Q:
+// register index, register/memory source, and register destination.
+func (c *amd64Ctx) lowerBZHI(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86ScalarBitFieldFamilyProperties(op, ins, c.goarch, x86BitFieldZeroHigh)
+	if !known || err != nil {
+		return known, false, err
+	}
+
+	bits := form.bits
+	typ := amd64IntegerTypeForBits(bits)
+	indexValue, err := c.evalIntSized(form.control, typ)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, err := c.evalScalarBitFieldSource(ins, form, typ)
+	if err != nil {
+		return true, false, err
+	}
+	indexLowByte := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, 255\n", indexLowByte, typ, indexValue)
+	indexInRange := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %%%s, %d\n", indexInRange, typ, indexLowByte, bits)
+	safeIndex := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", safeIndex, typ, indexLowByte, bits-1)
+	one := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s 1, %%%s\n", one, typ, safeIndex)
+	partialMask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, -1\n", partialMask, typ, one)
+	mask := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s -1\n", mask, indexInRange, typ, partialMask, typ)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", result, typ, sourceValue, mask)
+	if err := c.storeRegSized(form.destination.Reg, typ, "%"+result); err != nil {
+		return true, false, err
+	}
+	carry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", carry, indexInRange)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, 0\n", zero, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", sign, typ, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	return true, false, nil
+}
diff --git a/amd64_lower_bzhi_test.go b/amd64_lower_bzhi_test.go
new file mode 100644
index 000000000..cc53e5d48
--- /dev/null
+++ b/amd64_lower_bzhi_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86BZHICompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA bzhidata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL bzhidata(SB), $8\n")
+	source.WriteString("TEXT bzhiforms(SB),$0-0\n")
+	for _, width := range []string{"L", "Q"} {
+		op := "BZHI" + width
+		fmt.Fprintf(&source, "\t%s AX, BX, CX\n", op)
+		fmt.Fprintf(&source, "\t%s DX, 8(BX), SI\n", op)
+		fmt.Fprintf(&source, "\t%s CX, bzhidata(SB), DX\n", op)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\t%s R11, R12, R13\n", op)
+		} else {
+			fmt.Fprintf(&source, "\t%s AX, BX, SP\n", op)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86BZHICompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86BZHICompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			// Preserve every original format, including its unbound registers
+			// and mode32 SP destination. These are not complete source entries.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "bzhiforms", target.goarch, target.triple)
+			wants := []string{"shl i32", `"target-features"="+bmi2"`}
+			if target.goarch == "amd64" {
+				wants = append(wants, "shl i64")
+			} else if strings.Contains(ir, "shl i64") {
+				t.Fatal("mode32 Q spelling used a fictitious 64-bit zero-high operation")
+			}
+			for _, want := range wants {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("BZHI lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "bzhi-"+target.name+".ll", "bzhi-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86BZHIRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "BZHIL $1, AX, BX"},
+		{goarch: "amd64", instruction: "BZHIQ 0(AX), BX, CX"},
+		{goarch: "amd64", instruction: "BZHIQ AX, $1, CX"},
+		{goarch: "amd64", instruction: "BZHIL AX, BX, 0(CX)"},
+		{goarch: "amd64", instruction: "BZHIQ X0, AX, BX"},
+		{goarch: "amd64", instruction: "BZHIQ AX, X0, BX"},
+		{goarch: "amd64", instruction: "BZHIQ AX, BX, X0"},
+		{goarch: "amd64", instruction: "BZHIQ AX, BX"},
+		{goarch: "amd64", instruction: "BZHIQ.Z AX, BX, CX"},
+		{goarch: "386", instruction: "BZHIL R8, AX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _ybextrl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64BZHIRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT bzhisemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	MOVL $8, AX
+	MOVL $0x1234, BX
+	BZHIL AX, BX, CX
+	MOVQ CX, 0(DI)
+	SETCS 8(DI)
+	SETOS 9(DI)
+	SETEQ 10(DI)
+	SETMI 11(DI)
+
+	MOVL $31, AX
+	MOVL $0x80000000, BX
+	BZHIL AX, BX, CX
+	MOVQ CX, 16(DI)
+	SETEQ 24(DI)
+
+	MOVL $32, AX
+	MOVL $0x80000000, BX
+	BZHIL AX, BX, CX
+	MOVQ CX, 32(DI)
+	SETCS 40(DI)
+	SETMI 41(DI)
+
+	MOVQ $0x1000000000000004, AX
+	MOVQ $-1, 48(DI)
+	BZHIQ AX, 48(DI), CX
+	MOVQ CX, 56(DI)
+
+	MOVQ $64, AX
+	MOVQ $0x1234, BX
+	BZHIQ AX, BX, AX
+	MOVQ AX, 64(DI)
+	SETCS 72(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"bzhisemantics": {
+				Name:  "bzhisemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void bzhisemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[80] = {0};
+  bzhisemantics(out);
+  if (load64(out + 0) != UINT64_C(0x34)) return 10;
+  if (out[8] != 0 || out[9] != 0 || out[10] != 0 || out[11] != 0) return 11;
+  if (load64(out + 16) != 0 || out[24] != 1) return 12;
+  if (load64(out + 32) != UINT64_C(0x80000000) || out[40] != 1 || out[41] != 1) return 13;
+  if (load64(out + 56) != UINT64_C(0xf)) return 14;
+  if (load64(out + 64) != UINT64_C(0x1234) || out[72] != 1) return 15;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "bzhi_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_cache_line.go b/amd64_lower_cache_line.go
new file mode 100644
index 000000000..57dbc2054
--- /dev/null
+++ b/amd64_lower_cache_line.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86CacheLineWritebackOps = map[string]struct{}{
+	"CLFLUSH":    {},
+	"CLFLUSHOPT": {},
+	"CLWB":       {},
+}
+
+// lowerCacheLineWriteback covers Go 1.27's complete x86 yclflush operand
+// table. All three instructions accept exactly one Ym memory operand on both
+// 386 and amd64. Preserve the architectural cache operation as inline
+// assembly: replacing it with an ordinary load would lose ordering and
+// persistence semantics.
+func (c *amd64Ctx) lowerCacheLineWriteback(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	if _, ok := x86CacheLineWritebackOps[baseOp]; !ok {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 1 || !isAMD64MemoryOperand(ins.Args[0]) {
+		return true, false, fmt.Errorf("%s %s expects one Go 1.27 Ym memory operand: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	ptr, ptrType, err := c.x86DescriptorMemoryPointer(ins.Args[0])
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype(i8) %s)\n",
+		strings.ToLower(baseOp)+" $0", "*m,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, ptr)
+	return true, false, nil
+}
diff --git a/amd64_lower_cache_line_test.go b/amd64_lower_cache_line_test.go
new file mode 100644
index 000000000..52f173bdb
--- /dev/null
+++ b/amd64_lower_cache_line_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86CacheLineWritebackCompleteGoAssemblerForms(t *testing.T) {
+	const source = `
+TEXT cachelinewriteback(SB),$16-0
+	CLFLUSH (AX)
+	CLFLUSHOPT 8(BX)
+	CLWB local+0(SP)
+	RET
+`
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "386", triple: "i686-pc-windows-msvc"},
+		{goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.goarch+"/"+target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: target.triple, Goarch: target.goarch,
+				Sigs: map[string]FuncSig{"cachelinewriteback": {Name: "cachelinewriteback", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, mnemonic := range []string{"clflush $0", "clflushopt $0", "clwb $0"} {
+				if !strings.Contains(ir, mnemonic) {
+					t.Fatalf("cache-line lowering omitted %q:\n%s", mnemonic, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "x86-cache-line-writeback.ll", "x86-cache-line-writeback.o", ir)
+		})
+	}
+}
+
+func TestTranslateX86CacheLineWritebackRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64"} {
+		triple := "i386-unknown-linux-gnu"
+		if goarch == "amd64" {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		for _, instruction := range []string{
+			"CLFLUSH",
+			"CLFLUSH AX",
+			"CLFLUSH $1",
+			"CLFLUSH (AX), (BX)",
+			"CLFLUSH.X (AX)",
+			"CLFLUSHOPT AX",
+			"CLWB AX",
+		} {
+			t.Run(goarch+"/"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+				source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, goarch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{
+					TargetTriple: triple, Goarch: goarch,
+					Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+				if err == nil {
+					t.Fatalf("Translate accepted form rejected by Go 1.27: %s", instruction)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lower_call_abi0_test.go b/amd64_lower_call_abi0_test.go
new file mode 100644
index 000000000..8346f9523
--- /dev/null
+++ b/amd64_lower_call_abi0_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ABI0CallUsesOutgoingStackFrame(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		triple string
+		mov    string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", mov: "MOVQ"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", mov: "MOVL"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			source := "TEXT ·abi0Caller(SB),$48-0\n" +
+				"\t" + target.mov + " $1, AX\n" +
+				"\t" + target.mov + " AX, 0(SP)\n" +
+				"\t" + target.mov + " $2, AX\n" +
+				"\t" + target.mov + " AX, 8(SP)\n" +
+				"\t" + target.mov + " $3, AX\n" +
+				"\t" + target.mov + " AX, 16(SP)\n" +
+				"\tMOVL $0x3fc00000, 24(SP)\n" +
+				"\t" + target.mov + " $4, AX\n" +
+				"\t" + target.mov + " AX, 32(SP)\n" +
+				"\tCALL ·abi0Callee(SB)\n" +
+				"\t" + target.mov + " 40(SP), AX\n" +
+				"\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			word := I64
+			if target.goarch == "386" {
+				word = I32
+			}
+			aggregate := LLVMType("{ " + string(Ptr) + ", " + string(word) + ", " + string(word) + " }")
+			callee := FuncSig{
+				Name: "abi0Callee",
+				Args: []LLVMType{aggregate, LLVMType("float"), LLVMType("double")},
+				Ret:  word,
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: 0},
+						{Offset: 8, Type: word, Index: 0, Field: 1},
+						{Offset: 16, Type: word, Index: 0, Field: 2},
+						{Offset: 24, Type: LLVMType("float"), Index: 1, Field: -1},
+						{Offset: 32, Type: LLVMType("double"), Index: 2, Field: -1},
+					},
+					Results: []FrameSlot{{Offset: 40, Type: word, Index: 0, Field: -1}},
+				},
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"abi0Caller": {Name: "abi0Caller", Ret: Void},
+					"abi0Callee": callee,
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"load ptr", "load float", "load double", "call " + string(word) + " @abi0Callee", "store " + string(word)} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ABI0 call omitted %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "abi0-call-"+target.goarch+".ll", "abi0-call-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86IndirectBranchCompatibilitySyntax(t *testing.T) {
+	const source = `
+TEXT ·indirectCallRegister(SB),$0-0
+	CALL *AX
+	RET
+
+TEXT ·indirectCallSymbol(SB),$0-0
+	CALL *·pointer(SB)
+	RET
+
+TEXT ·indirectJumpRegister(SB),$0-0
+	JMP *AX
+`
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"indirectCallRegister": {Name: "indirectCallRegister", Ret: Void},
+					"indirectCallSymbol":   {Name: "indirectCallSymbol", Ret: Void},
+					"indirectJumpRegister": {Name: "indirectJumpRegister", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, "call i64 %"); got != 3 {
+				t.Fatalf("indirect CALL/JMP count = %d, want 3:\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "indirect-branch-"+target.goarch+".ll", "indirect-branch-"+target.goarch+".o", ll)
+		})
+	}
+}
diff --git a/amd64_lower_carry_flag_test.go b/amd64_lower_carry_flag_test.go
new file mode 100644
index 000000000..186758247
--- /dev/null
+++ b/amd64_lower_carry_flag_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86CarryFlagControlCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT carryflagforms(SB),NOSPLIT,$0-0\n\tCLC\n\tSTC\n\tCMC\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"carryflagforms": {Name: "carryflagforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"store i1 false, ptr %flags_cf", "store i1 true, ptr %flags_cf", "xor i1"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("carry flag lowering missing %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "carry-flag-"+target.name+".ll", "carry-flag-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86CarryFlagControlRejectsOperands(t *testing.T) {
+	for _, instruction := range []string{"CLC AX", "STC $1", "CMC 0(BX)", "CLC.Z"} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: "x86_64-unknown-linux-gnu",
+					Goarch:       "amd64",
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's carry-control ynone table", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64CarryFlagControlRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT carryflagsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	CLC
+	MOVQ $0, AX
+	ADCQ $0, AX
+	MOVQ AX, 0(DI)
+	STC
+	MOVQ $0, AX
+	ADCQ $0, AX
+	MOVQ AX, 8(DI)
+	CLC
+	CMC
+	MOVQ $0, AX
+	ADCQ $0, AX
+	MOVQ AX, 16(DI)
+	STC
+	CMC
+	MOVQ $0, AX
+	ADCQ $0, AX
+	MOVQ AX, 24(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"carryflagsemantics": {Name: "carryflagsemantics", Args: []LLVMType{Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void carryflagsemantics(uint64_t *);
+int main(void) {
+  uint64_t out[4] = {9, 9, 9, 9};
+  const uint64_t want[4] = {0, 1, 1, 0};
+  carryflagsemantics(out);
+  for (int i = 0; i < 4; i++) if (out[i] != want[i]) return 10+i;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "carry_flag_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_carry_rotate_test.go b/amd64_lower_carry_rotate_test.go
new file mode 100644
index 000000000..b0daf861a
--- /dev/null
+++ b/amd64_lower_carry_rotate_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86CarryRotateCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			widths := []string{"B", "W", "L"}
+			if target.goarch == "amd64" {
+				widths = append(widths, "Q")
+			}
+			var source strings.Builder
+			source.WriteString("TEXT carryrotateforms(SB),NOSPLIT,$0-0\n")
+			for _, stem := range []string{"RCL", "RCR"} {
+				for _, width := range widths {
+					op := stem + width
+					reg := "AX"
+					if width == "B" {
+						reg = "AH"
+					}
+					fmt.Fprintf(&source, "\t%s $1, %s\n", op, reg)
+					fmt.Fprintf(&source, "\t%s $255, 8(BX)\n", op)
+					fmt.Fprintf(&source, "\t%s CL, %s\n", op, reg)
+					fmt.Fprintf(&source, "\t%s CX, 16(BX)\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			// Counts, CF, data and native addresses are intentionally absent.
+			// Preserve every original Go row and private emitter object, not
+			// a public numerical or caller-memory contract.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "carryrotateforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "carry-rotate-"+target.name+".ll", "carry-rotate-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86CarryRotateRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"RCLB $-1, AL",
+		"RCRW $256, AX",
+		"RCLL AX, BX",
+		"RCRQ (AX), BX",
+		"RCLQ $1, X0",
+		"RCRB.Z $1, AL",
+		"RCLL $1, AX, BX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86CarryRotateRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"RCLQ $1, AX",
+		"RCRQ CL, (BX)",
+		"RCLB $1, SP",
+		"RCRL $1, R8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86CarryRotateRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86CarryRotateRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's RCL/RCR tables for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_clmul.go b/amd64_lower_clmul.go
new file mode 100644
index 000000000..4781c6126
--- /dev/null
+++ b/amd64_lower_clmul.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import "fmt"
+
+// lowerPackedCarrylessMultiply implements Go 1.27's complete legacy and
+// vector PCLMULQDQ tables. VPCLMULQDQ applies one independent 64x64->128
+// carryless multiplication to every 128-bit lane.
+func (c *amd64Ctx) lowerPackedCarrylessMultiply(rawOp Op, ins Instr) (ok bool, terminated bool, err error) {
+	f, known, err := x86CLMULProperties(rawOp, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if f.legacy && f.memory >= 0 {
+		return true, false, c.lowerLegacyCLMULMemory(ins, f)
+	}
+	second, err := c.loadX86PackedShiftBytes(ins.Args[f.source], f.byteWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	first, err := c.loadPackedCompareBytes(ins.Args[f.second], f.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitPackedCarrylessMultiply(f.byteWidth, first, second, f.immediate)
+	if f.legacy {
+		return true, false, c.storeX(ins.Args[f.destination].Reg, result)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[f.destination], f.byteWidth, result)
+}
+
+// The legacy m128 opcode, not its selected numerical qword, determines the
+// native memory/alignment/fault effect. Retain the whole original instruction
+// even when its product is dead; virtual FP/SP/BP storage is not that address.
+func (c *amd64Ctx) lowerLegacyCLMULMemory(ins Instr, f x86CLMULForm) error {
+	source := ins.Args[f.source]
+	virtual := source.Kind == OpFP
+	if source.Kind == OpMem && !x86CallerMemoryCertified(ins, f.source) && !c.fixedLocalMemoryCertified(ins, f.source) {
+		virtual = !c.nativeMemoryOperand(ins, f.source)
+	}
+	if virtual {
+		return fmt.Errorf("%w: legacy carryless multiply m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return err
+	}
+	first, err := c.loadPackedCompareLanes(ins.Args[f.second], 16, 64, false)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	assembly := fmt.Sprintf("pclmulqdq $$%d, %s($2), $0", f.immediate, segment)
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <2 x i64> asm sideeffect %q, %q(<2 x i64> %s, %s %s)\n",
+		result, assembly, "=x,0,r,~{memory}", first, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, result)
+	return c.storeX(ins.Args[f.destination].Reg, "%"+bytes)
+}
+
+func (c *amd64Ctx) emitPackedCarrylessMultiply(byteWidth int, firstBytes, secondBytes string, immediate uint8) string {
+	qwords := byteWidth / 8
+	first := c.newTmp()
+	second := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i64>\n", first, byteWidth, firstBytes, qwords)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i64>\n", second, byteWidth, secondBytes, qwords)
+	result := "zeroinitializer"
+	for lane := 0; lane < byteWidth/16; lane++ {
+		firstLane := c.newTmp()
+		secondLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i64> %%%s, <%d x i64> poison, <2 x i32> <i32 %d, i32 %d>\n", firstLane, qwords, first, qwords, lane*2, lane*2+1)
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i64> %%%s, <%d x i64> poison, <2 x i32> <i32 %d, i32 %d>\n", secondLane, qwords, second, qwords, lane*2, lane*2+1)
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.pclmulqdq(<2 x i64> %%%s, <2 x i64> %%%s, i8 %d)\n", product, firstLane, secondLane, immediate)
+		for word := 0; word < 2; word++ {
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 %d\n", extracted, product, word)
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i64> %s, i64 %%%s, i32 %d\n", inserted, qwords, result, extracted, lane*2+word)
+			result = "%" + inserted
+		}
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", bytes, qwords, result, byteWidth)
+	return "%" + bytes
+}
diff --git a/amd64_lower_clmul_test.go b/amd64_lower_clmul_test.go
new file mode 100644
index 000000000..b92772964
--- /dev/null
+++ b/amd64_lower_clmul_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedCarrylessMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			fmt.Fprintf(&source, "TEXT carrylessmultiplyforms(SB),NOSPLIT,$0-0\n\tPCLMULQDQ $0, X0, X%d\n\tPCLMULQDQ $255, 8(AX), X%d\n", last, last)
+			if target.goarch == "amd64" {
+				source.WriteString("\tVPCLMULQDQ $0, X0, X1, X2\n")
+				source.WriteString("\tVPCLMULQDQ $1, 8(AX), X1, X2\n")
+				source.WriteString("\tVPCLMULQDQ $16, Y0, Y1, Y2\n")
+				source.WriteString("\tVPCLMULQDQ $17, 8(AX), Y1, Y2\n")
+				source.WriteString("\tVPCLMULQDQ $127, Z0, Z1, Z2\n")
+				source.WriteString("\tVPCLMULQDQ $128, 8(AX), Z1, Z2\n")
+				source.WriteString("\tVPCLMULQDQ $255, X16, X31, X0\n")
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"carrylessmultiplyforms": {Name: "carrylessmultiplyforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-carryless-multiply-"+target.name+".ll", "packed-carryless-multiply-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedCarrylessMultiplyRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PCLMULQDQ $-1, X0, X1",
+		"PCLMULQDQ $256, X0, X1",
+		"PCLMULQDQ $1, X16, X1",
+		"PCLMULQDQ $1, Y0, Y1",
+		"PCLMULQDQ.Z $1, X0, X1",
+		"PCLMULQDQ $1, X0, (AX)",
+		"VPCLMULQDQ $-1, X0, X1, X2",
+		"VPCLMULQDQ $256, X0, X1, X2",
+		"VPCLMULQDQ $1, X0, Y1, Y2",
+		"VPCLMULQDQ $1, X0, X1, K1, X2",
+		"VPCLMULQDQ.Z $1, X0, X1, X2",
+		"VPCLMULQDQ $1, X0, (AX), X2",
+		"VPCLMULQDQ $1, X0, X1, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedCarrylessMultiplyRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PCLMULQDQ $1, X8, X0",
+		"PCLMULQDQ $1, X0, X8",
+		"VPCLMULQDQ $1, X0, X1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedCarrylessMultiplyRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedCarrylessMultiplyRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's PCLMULQDQ/VPCLMULQDQ tables for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64PackedCarrylessMultiplyRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT carrylessmultiply(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPCLMULQDQ $0x10, Y0, Y1, Y2
+	VMOVDQU Y2, (AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"carrylessmultiply": {Name: "carrylessmultiply", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void carrylessmultiply(uint64_t *, const uint64_t *, const uint64_t *);
+static void clmul(uint64_t a, uint64_t b, uint64_t *lo, uint64_t *hi) {
+  uint64_t l = 0, h = 0;
+  for (unsigned i = 0; i < 64; i++) if ((b >> i) & 1) {
+    l ^= a << i;
+    if (i) h ^= a >> (64-i);
+  }
+  *lo = l; *hi = h;
+}
+int main(void) {
+  uint64_t a[4] = {0x123456789abcdef0ULL, 0xfedcba9876543210ULL, 0x1111222233334444ULL, 0x5555666677778888ULL};
+  uint64_t b[4] = {0x0123456789abcdefULL, 0x0f1e2d3c4b5a6978ULL, 0x9999aaaabbbbccccULL, 0xddddeeeeffff0001ULL};
+  uint64_t out[4] = {0}, want[4] = {0};
+	clmul(b[0], a[1], &want[0], &want[1]);
+	clmul(b[2], a[3], &want[2], &want[3]);
+  carrylessmultiply(out, a, b);
+  for (int i = 0; i < 4; i++) if (out[i] != want[i]) return 10+i;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_carryless_multiply", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_cmov.go b/amd64_lower_cmov.go
new file mode 100644
index 000000000..a2e62bb9f
--- /dev/null
+++ b/amd64_lower_cmov.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import "fmt"
+
+// lowerConditionalMove implements the complete Go 1.27 yml_rl conditional
+// move table: every x86 condition code at W/L/Q width, with a register or
+// memory source and a GP-register destination.
+func (c *amd64Ctx) lowerConditionalMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86ConditionalMoveProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ty := amd64IntegerTypeForBits(form.bits)
+	src, err := c.loadConditionalMoveSource(form, ins)
+	if err != nil {
+		return true, false, err
+	}
+	cur, err := c.evalIntSized(form.destination, ty)
+	if err != nil {
+		return true, false, err
+	}
+	condition, err := c.x86Condition(form.condition)
+	if err != nil {
+		return true, false, err
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %s, %s %s\n", selected, condition, ty, src, ty, cur)
+	// Select only the operand width, then apply the architectural writeback.
+	// In particular a false L predicate still zeroes GP bits 63:32.
+	return true, false, c.storeRegSized(form.destination.Reg, ty, "%"+selected)
+}
+
+func (c *amd64Ctx) loadConditionalMoveSource(form x86ConditionalMoveForm, ins Instr) (string, error) {
+	source := form.source
+	if source.Kind == OpReg {
+		return c.evalIntSized(source, amd64IntegerTypeForBits(form.bits))
+	}
+	if source.Kind == OpMem && !c.nativeMemoryOperand(ins, 0) &&
+		!x86CallerMemoryCertified(ins, 0) && !c.fixedLocalMemoryCertified(ins, 0) {
+		return "", fmt.Errorf("%w: CMOV native stack source lacks its original storage certificate", ErrProbeNeedsContext)
+	}
+	if source.Kind == OpFP {
+		// Only existing declared numerical ABI0 fields supply logical bytes.
+		// Neither pointer fields, holes nor an unknown native frame are inputs.
+		if err := c.validateX86PackedShiftFPSpan(source.FPOffset, form.bits/8); err != nil {
+			return "", err
+		}
+		result := false
+		for offset := source.FPOffset; offset < source.FPOffset+int64(form.bits/8); offset++ {
+			slot, output, _ := c.fpVectorSlot(offset)
+			if slot.Type != I8 && slot.Type != I16 && slot.Type != I32 && slot.Type != I64 && slot.Type != LLVMType("float") && slot.Type != LLVMType("double") {
+				return "", fmt.Errorf("%w: CMOV FP byte is not declared numerical storage", ErrProbeNeedsContext)
+			}
+			result = result || output
+		}
+		if result {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return "", err
+			}
+		}
+	}
+	// The shared FP loader bitcasts floating slots before extracting bytes;
+	// NaN payloads and signed zero are not floating-to-integer conversions.
+	// Intel CMOVcc reads the complete memory source unconditionally, even for
+	// a false predicate or dead result. Preserve the original width and fault.
+	bytes, err := c.loadX86PackedShiftBytes(source, form.bits/8, true)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, form.bits/8, bytes, form.bits)
+	if source.Kind != OpFP || c.classicFrame != "" {
+		// LLVM22's x86 select expansion can sink even a volatile load into
+		// one branch. An unconditional register use keeps the actual source
+		// read before that expansion without emitting an instruction or
+		// granting a new memory/FP permission. A false CMOV must still fault.
+		fmt.Fprintf(c.b, "  call void asm sideeffect \"\", \"r\"(i%d %%%s)\n", form.bits, value)
+	}
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) x86Condition(code string) (string, error) {
+	invert := func(value string) string {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", out, value)
+		return "%" + out
+	}
+	combine := func(instruction, left, right string) string {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i1 %s, %s\n", out, instruction, left, right)
+		return "%" + out
+	}
+
+	switch code {
+	case "CC":
+		return invert(c.loadFlag(c.flagsCFSlot)), nil
+	case "CS":
+		return c.loadFlag(c.flagsCFSlot), nil
+	case "EQ":
+		return c.loadFlag(c.flagsZSlot), nil
+	case "GE", "GT", "LE", "LT":
+		signedLess := combine("xor", c.loadFlag(c.flagsSltSlot), c.loadFlag(c.flagsOFSlot))
+		switch code {
+		case "LT":
+			return signedLess, nil
+		case "GE":
+			return invert(signedLess), nil
+		case "LE":
+			return combine("or", c.loadFlag(c.flagsZSlot), signedLess), nil
+		case "GT":
+			return invert(combine("or", c.loadFlag(c.flagsZSlot), signedLess)), nil
+		}
+	case "HI":
+		return combine("and", invert(c.loadFlag(c.flagsCFSlot)), invert(c.loadFlag(c.flagsZSlot))), nil
+	case "LS":
+		return combine("or", c.loadFlag(c.flagsCFSlot), c.loadFlag(c.flagsZSlot)), nil
+	case "MI":
+		return c.loadFlag(c.flagsSltSlot), nil
+	case "NE":
+		return invert(c.loadFlag(c.flagsZSlot)), nil
+	case "OC":
+		return invert(c.loadFlag(c.flagsOFSlot)), nil
+	case "OS":
+		return c.loadFlag(c.flagsOFSlot), nil
+	case "PC":
+		return invert(c.loadFlag(c.flagsPFSlot)), nil
+	case "PL":
+		return invert(c.loadFlag(c.flagsSltSlot)), nil
+	case "PS":
+		return c.loadFlag(c.flagsPFSlot), nil
+	}
+	return "", fmt.Errorf("unsupported x86 condition code %q", code)
+}
diff --git a/amd64_lower_cmpbt.go b/amd64_lower_cmpbt.go
index 3b9369859..e82f6bb64 100644
--- a/amd64_lower_cmpbt.go
+++ b/amd64_lower_cmpbt.go
@@ -6,179 +6,87 @@ import (
 )
 
 func (c *amd64Ctx) lowerCmpBt(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	switch op {
-	case "CMPB", "CMPW", "CMPL", "CMPQ":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 CMPQ expects 2 operands: %q", ins.Raw)
-		}
-		ty := I64
-		switch op {
-		case "CMPB":
-			ty = I8
-		case "CMPW":
-			ty = I16
-		case "CMPL":
-			ty = I32
-		case "CMPQ":
-			ty = I64
-		}
-		a, err := c.evalIntSized(ins.Args[0], ty)
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.evalIntSized(ins.Args[1], ty)
-		if err != nil {
-			return true, false, err
-		}
-		c.setCmpFlagsSized(ty, a, b)
-		return true, false, nil
-
-	case "TESTB", "TESTW", "TESTL", "TESTQ":
-		// TEST* a,b sets flags based on (a & b) without storing the result.
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects 2 operands: %q", op, ins.Raw)
-		}
-		ty := I64
-		switch op {
-		case "TESTB":
-			ty = I8
-		case "TESTW":
-			ty = I16
-		case "TESTL":
-			ty = I32
-		case "TESTQ":
-			ty = I64
-		}
-		a, err := c.evalIntSized(ins.Args[0], ty)
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.evalIntSized(ins.Args[1], ty)
-		if err != nil {
-			return true, false, err
-		}
-		c.setTestFlagsSized(ty, a, b)
-		return true, false, nil
-
-	case "BTQ":
-		// BTQ $imm, reg (sets CF to selected bit)
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 BTQ expects $imm, reg: %q", ins.Raw)
-		}
-		v, err := c.loadReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		amt := ins.Args[0].Imm & 63
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", sh, v, amt)
-		and := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 1\n", and, sh)
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", cf, and)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		return true, false, nil
-
-	case "BTSQ", "BTRQ":
-		// BTSQ/BTRQ src, dstReg|dstMem: CF = old bit, then set or
-		// clear the selected destination bit.
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
+	if ok, terminated, err := c.lowerBitTestFamily(op, ins); ok {
+		return ok, terminated, err
+	}
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86ScalarCompareProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	for index, operand := range form.args {
+		if operand.Kind == OpReg && operand.Reg == SP && ins.Args[index].Reg != SP {
+			return true, false, fmt.Errorf("%w: Go REX byte view needs the original physical SP", ErrProbeNeedsContext)
 		}
-		var amt string
-		var registerIndex string
-		switch ins.Args[0].Kind {
-		case OpImm:
-			amt = fmt.Sprintf("%d", ins.Args[0].Imm&63)
-		case OpReg:
-			av, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
+	}
+	native := form.memory >= 0 && (c.nativeMemoryOperand(ins, form.memory) ||
+		x86CallerMemoryCertified(ins, form.memory) || c.fixedLocalMemoryCertified(ins, form.memory))
+	if native && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return true, false, fmt.Errorf("%w: scalar comparison needs its original native address size", ErrProbeNeedsContext)
+	}
+	typ := LLVMType(fmt.Sprintf("i%d", form.bits))
+	var values [2]string
+	for index, operand := range form.args {
+		if index == form.memory && native {
+			if source := c.goReadOnlyStorage; source != nil {
+				address, named := x86StaticSBSourceAddress(operand, arch)
+				if named && source.object(address.symbol).variable != nil &&
+					!source.allows(operand, int64(form.bits/8), arch) {
+					return true, false, goReadOnlyContext("comparison exceeds the declared numerical span")
+				}
 			}
-			m := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 63\n", m, av)
-			amt = "%" + m
-			registerIndex = av
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects imm/reg bit index: %q", op, ins.Raw)
-		}
-
-		var dst string
-		var storeDst func(string) error
-		switch ins.Args[1].Kind {
-		case OpReg:
-			dv, err := c.loadReg(ins.Args[1].Reg)
-			if err != nil {
-				return true, false, err
+			pointer, pointerType, _, pointerErr := c.packedVectorMemoryPointer(operand)
+			if pointerErr != nil {
+				return true, false, pointerErr
 			}
-			dst = dv
-			storeDst = func(v string) error { return c.storeReg(ins.Args[1].Reg, v) }
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[1].Mem)
+			loaded := c.newTmp()
+			// A compare whose flags are dead must still perform the exact
+			// native read (and fault). No backing/alignment assumption follows.
+			fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", loaded, typ, pointerType, pointer)
+			values[index] = "%" + loaded
+		} else {
+			values[index], err = c.evalIntSized(operand, typ)
 			if err != nil {
 				return true, false, err
 			}
-			// A register bit index on a memory operand selects a bit in an
-			// unbounded bit string, not merely within the first qword. Adjust
-			// the address by floor(index/64)*8 and retain index&63 within it.
-			if registerIndex != "" {
-				word := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, 6\n", word, registerIndex)
-				byteOff := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 3\n", byteOff, word)
-				adjusted := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", adjusted, addr, byteOff)
-				addr = "%" + adjusted
-			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-			dst = "%" + ld
-			storeDst = func(v string) error {
-				fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", v, p)
-				return nil
-			}
-		default:
-			return true, false, fmt.Errorf("amd64 %s expects reg/mem dst: %q", op, ins.Raw)
-		}
-
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %s\n", sh, dst, amt)
-		and := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 1\n", and, sh)
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", cf, and)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		one := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 1, %s\n", one, amt)
-		out := c.newTmp()
-		if op == "BTSQ" {
-			fmt.Fprintf(c.b, "  %%%s = or i64 %s, %%%s\n", out, dst, one)
-		} else {
-			mask := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i64 %%%s, -1\n", mask, one)
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %%%s\n", out, dst, mask)
-		}
-		if err := storeDst("%" + out); err != nil {
-			return true, false, err
 		}
-		return true, false, nil
 	}
-	return false, false, nil
+	if form.test {
+		c.setTestFlagsSized(typ, values[0], values[1])
+	} else {
+		c.setCmpFlagsSized(typ, values[0], values[1])
+	}
+	return true, false, nil
 }
 
 func (c *amd64Ctx) setCmpFlagsSized(ty LLVMType, a, b string) {
 	// Unlike most Plan 9 x86 instructions, CMP spells its operands in
 	// comparison order: CMP a,b sets flags for a-b.
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", result, ty, a, b)
+	c.setAuxiliaryCarryFlag(ty, a, b, "%"+result)
 	zt := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %s\n", zt, ty, a, b)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zt, c.flagsZSlot)
-	slt := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, %s\n", slt, ty, a, b)
-	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", slt, c.flagsSltSlot)
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", sign, ty, result)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
 	ult := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %s, %s\n", ult, ty, a, b)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", ult, c.flagsCFSlot)
+	xorOperands := c.newTmp()
+	xorResult := c.newTmp()
+	overflowBits := c.newTmp()
+	overflow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", xorOperands, ty, a, b)
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %%%s\n", xorResult, ty, a, result)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", overflowBits, ty, xorOperands, xorResult)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", overflow, ty, overflowBits)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", overflow, c.flagsOFSlot)
+	c.setParityFlagSized(ty, "%"+result)
 }
 
 func (c *amd64Ctx) setTestFlagsSized(ty LLVMType, a, b string) {
@@ -192,9 +100,23 @@ func (c *amd64Ctx) setTestFlagsSized(ty LLVMType, a, b string) {
 	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", slt, ty, and)
 	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", slt, c.flagsSltSlot)
 	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	c.setParityFlagSized(ty, "%"+and)
 }
 
 func (c *amd64Ctx) evalIntSized(op Operand, ty LLVMType) (string, error) {
+	if err := unresolvedSymbolicImmediateErrorForArch(op, ArchAMD64); err != nil {
+		return "", err
+	}
+	if read := c.goReadOnlyOperand; read != nil && ty == LLVMType(fmt.Sprintf("i%d", read.width*8)) && read.allows(op, read.width) {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(op)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, ty, pointerType, pointer)
+		return "%" + value, nil
+	}
 	switch op.Kind {
 	case OpImm:
 		// LLVM will interpret the literal in the destination integer width.
@@ -233,6 +155,18 @@ func (c *amd64Ctx) evalIntSized(op Operand, ty LLVMType) (string, error) {
 		s := strings.TrimSpace(op.Sym)
 		if strings.HasPrefix(s, "$") {
 			address := strings.TrimSpace(strings.TrimPrefix(s, "$"))
+			if memory, matched, err := parseX86SymbolIndexedMemory(address); matched {
+				if err != nil {
+					return "", err
+				}
+				wide, err := c.addrFromSymbolIndexedAddress(memory)
+				if err != nil || ty == I64 {
+					return wide, err
+				}
+				value := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", value, wide, ty)
+				return "%" + value, nil
+			}
 			if strings.HasSuffix(address, "(SB)") {
 				p, err := c.ptrFromSB(address)
 				if err != nil {
@@ -247,10 +181,14 @@ func (c *amd64Ctx) evalIntSized(op Operand, ty LLVMType) (string, error) {
 				fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to %s\n", value, wide, ty)
 				return "%" + value, nil
 			}
-			// Macro-style symbolic immediates (e.g. $const_avxSupported) may
-			// survive preprocessing when include constants are unavailable.
-			// Keep translation progressing with a conservative zero value.
-			return "0", nil
+			return "", fmt.Errorf("unresolved symbolic immediate %q", op.Sym)
+		}
+		// Go's x86 syntax treats a bare integer as absolute memory. Keep
+		// this distinct from the '$' immediate spelling above.
+		if address, parseErr := parseInt(s); parseErr == nil {
+			t := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", t, ty, c.ptrFromAddrI64(fmt.Sprintf("%d", address)))
+			return "%" + t, nil
 		}
 		if strings.HasSuffix(s, "(SB)") {
 			p, err := c.ptrFromSB(s)
diff --git a/amd64_lower_cmps_test.go b/amd64_lower_cmps_test.go
new file mode 100644
index 000000000..ae3fb32f2
--- /dev/null
+++ b/amd64_lower_cmps_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86CMPSCompleteFormsSource(goarch string) string {
+	widths := []string{"B", "W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT cmpsforms(SB),$0-0\n")
+	for _, width := range widths {
+		op := "CMPS" + width
+		fmt.Fprintf(&source, "\t%s\n", op)
+		fmt.Fprintf(&source, "\tCLD; REP; %s\n", op)
+		fmt.Fprintf(&source, "\tSTD; REPN; %s\n", op)
+		source.WriteString("\tCLD\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86CMPSCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86CMPSCompleteFormsSource(target.goarch)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "cmpsforms", target.goarch, target.triple)
+			for _, width := range []string{"b", "w", "l"} {
+				if want := "@__plan9asm_rep_cmps" + width; !strings.Contains(ir, want) {
+					t.Fatalf("CMPS lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "@__plan9asm_rep_cmpsq") {
+				t.Fatalf("CMPSQ lowering omitted qword helper:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "cmps-"+target.name+".ll", "cmps-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86CMPSRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "CMPSB AX"},
+		{goarch: "amd64", instruction: "CMPSW AX, BX"},
+		{goarch: "amd64", instruction: "CMPSL.Z"},
+		{goarch: "386", instruction: "CMPSQ"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's CMPS ynone table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64CMPSRuntimeSemanticsPrefixesDirectionAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT cmpssemantics(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), R8
+	MOVQ left+8(FP), R9
+	MOVQ right+16(FP), R10
+
+	MOVQ R9, SI
+	MOVQ R10, DI
+	MOVQ $4, CX
+	CLD
+	REP; CMPSB
+	MOVQ SI, 0(R8)
+	MOVQ DI, 8(R8)
+	MOVQ CX, 16(R8)
+	SETCS 24(R8)
+	SETEQ 25(R8)
+	SETMI 26(R8)
+	SETOS 27(R8)
+	SETPS 28(R8)
+
+	MOVQ R9, SI
+	ADDQ $8, SI
+	MOVQ R10, DI
+	ADDQ $8, DI
+	MOVQ $3, CX
+	REPN; CMPSW
+	MOVQ SI, 32(R8)
+	MOVQ DI, 40(R8)
+	MOVQ CX, 48(R8)
+	SETCS 56(R8)
+	SETEQ 57(R8)
+
+	MOVQ R9, SI
+	ADDQ $28, SI
+	MOVQ R10, DI
+	ADDQ $28, DI
+	STD
+	CMPSL
+	CLD
+	MOVQ SI, 64(R8)
+	MOVQ DI, 72(R8)
+	SETCS 80(R8)
+	SETEQ 81(R8)
+	SETMI 82(R8)
+	SETOS 83(R8)
+
+	MOVQ R9, SI
+	ADDQ $40, SI
+	MOVQ R10, DI
+	ADDQ $40, DI
+	CMPSQ
+	MOVQ SI, 88(R8)
+	MOVQ DI, 96(R8)
+	SETEQ 104(R8)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"cmpssemantics": {
+				Name: "cmpssemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void cmpssemantics(uint8_t *, uint8_t *, uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t left[56] = {1,2,9,4};
+  uint8_t right[56] = {1,2,3,4};
+  const uint16_t leftw[3] = {5,7,8}, rightw[3] = {6,7,9};
+  memcpy(left + 8, leftw, sizeof(leftw));
+  memcpy(right + 8, rightw, sizeof(rightw));
+  const uint32_t leftl[2] = {0,1}, rightl[2] = {0,2};
+  memcpy(left + 24, leftl, sizeof(leftl));
+  memcpy(right + 24, rightl, sizeof(rightl));
+  const uint64_t q = UINT64_C(0x0123456789abcdef);
+  memcpy(left + 40, &q, sizeof(q));
+  memcpy(right + 40, &q, sizeof(q));
+  uint8_t out[112] = {0};
+  cmpssemantics(out, left, right);
+	if (load64(out+0) != (uintptr_t)(left+3)) return 10;
+	if (load64(out+8) != (uintptr_t)(right+3)) return 11;
+	if (load64(out+16) != 1) return 12;
+  if (out[24] != 0 || out[25] != 0 || out[26] != 0 || out[27] != 0 || out[28] != 1) return 11;
+  if (load64(out+32) != (uintptr_t)(left+12) || load64(out+40) != (uintptr_t)(right+12) || load64(out+48) != 1) return 12;
+  if (out[56] != 0 || out[57] != 1) return 13;
+  if (load64(out+64) != (uintptr_t)(left+24) || load64(out+72) != (uintptr_t)(right+24)) return 14;
+  if (out[80] != 1 || out[81] != 0 || out[82] != 1 || out[83] != 0) return 15;
+  if (load64(out+88) != (uintptr_t)(left+48) || load64(out+96) != (uintptr_t)(right+48) || out[104] != 1) return 16;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "cmps_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_cmpxchg.go b/amd64_lower_cmpxchg.go
new file mode 100644
index 000000000..3cf59ce4b
--- /dev/null
+++ b/amd64_lower_cmpxchg.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import "fmt"
+
+// lowerCompareExchange implements every operand row in Go 1.27's yrb_mb,
+// yrl_ml, and yscond tables for the CMPXCHG family.
+func (c *amd64Ctx) lowerCompareExchange(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, recognized, err := x86CompareExchangeProperties(op, ins, c.goarch)
+	if !recognized {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.spec.pair {
+		return c.lowerPairCompareExchange(string(op), form.spec.bits, ins)
+	}
+	return c.lowerScalarCompareExchange(string(op), form.spec.bits, ins)
+}
+
+func amd64CompareExchangeProperties(op string) (kind string, bits int, ok bool) {
+	spec, recognized := x86CompareExchangeSpecs[Op(op)]
+	if !recognized {
+		return "", 0, false
+	}
+	kind = "scalar"
+	if spec.pair {
+		kind = "pair"
+	}
+	return kind, spec.bits, true
+}
+
+func (c *amd64Ctx) lowerScalarCompareExchange(baseOp string, bits int, ins Instr) (bool, bool, error) {
+	form, recognized, err := x86CompareExchangeProperties(Op(baseOp), ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if !recognized || form.spec.pair || form.spec.bits != bits {
+		return true, false, fmt.Errorf("%s %s has no matching scalar compare-exchange width", c.goarch, baseOp)
+	}
+	source, destination := form.source, form.destination
+	if err := c.validateCompareExchangeFP(destination, bits); err != nil {
+		return true, false, err
+	}
+
+	typ := amd64IntegerTypeForBits(bits)
+	accumulator, err := c.loadReg(AX)
+	if err != nil {
+		return true, false, err
+	}
+	expected, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, typ)
+	if err != nil {
+		return true, false, err
+	}
+	desired, err := c.evalIntSized(source, typ)
+	if err != nil {
+		return true, false, err
+	}
+
+	var old, success string
+	if destination.Kind == OpReg {
+		old, err = c.evalIntSized(destination, typ)
+		if err != nil {
+			return true, false, err
+		}
+		equal := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %s\n", equal, typ, expected, old)
+		success = "%" + equal
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %s, %s %s\n", selected, success, typ, desired, typ, old)
+		if err := c.storeRegSized(destination.Reg, typ, "%"+selected); err != nil {
+			return true, false, err
+		}
+	} else {
+		ptr, ptrType, err := c.compareExchangePointer(destination)
+		if err != nil {
+			return true, false, err
+		}
+		old, success = c.emitScalarCompareExchangeNative(bits, destination, ptr, ptrType, expected, desired)
+	}
+
+	// On failure the accumulator receives the destination. On success it is not
+	// written at all. In particular, CMPXCHGL zero-extends EAX only on failure;
+	// a successful compare must preserve the original high half of RAX.
+	if destination.Kind != OpReg || !amd64CompareExchangeDestinationIsAccumulator(destination.Reg, bits) {
+		if err := c.storeScalarCompareExchangeAccumulator(accumulator, expected, old, success, typ); err != nil {
+			return true, false, err
+		}
+	}
+	difference := c.newTmp()
+	// CMPXCHG compares the accumulator with the destination, so its arithmetic
+	// flags come from accumulator - destination (Intel's temporary result).
+	fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", difference, typ, expected, old)
+	c.setScalarAddSubFlags(typ, false, expected, old, "%"+difference)
+	// Keep the equality result authoritative even for unusual aliasing forms.
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", success, c.flagsZSlot)
+	return true, false, nil
+}
+
+func (c *amd64Ctx) storeScalarCompareExchangeAccumulator(accumulator, expected, failureValue, success string, typ LLVMType) error {
+	if typ == I32 {
+		failure64 := c.newTmp()
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", failure64, failureValue)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %%%s\n", selected, success, accumulator, failure64)
+		return c.storeReg(AX, "%"+selected)
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %s, %s %s\n", selected, success, typ, expected, typ, failureValue)
+	return c.storeRegSized(AX, typ, "%"+selected)
+}
+
+func amd64CompareExchangeDestinationIsAccumulator(reg Reg, bits int) bool {
+	if bits == 8 {
+		return reg == AX || reg == AL
+	}
+	return reg == AX
+}
+
+func (c *amd64Ctx) lowerPairCompareExchange(baseOp string, bits int, ins Instr) (bool, bool, error) {
+	form, recognized, err := x86CompareExchangeProperties(Op(baseOp), ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if !recognized || !form.spec.pair || form.spec.bits != bits {
+		return true, false, fmt.Errorf("%s %s has no matching pair compare-exchange width", c.goarch, baseOp)
+	}
+	destination := form.destination
+	if err := c.validateCompareExchangeFP(destination, bits); err != nil {
+		return true, false, err
+	}
+
+	ax, err := c.loadReg(AX)
+	if err != nil {
+		return true, false, err
+	}
+	dx, err := c.loadReg(DX)
+	if err != nil {
+		return true, false, err
+	}
+	bx, err := c.loadReg(BX)
+	if err != nil {
+		return true, false, err
+	}
+	cx, err := c.loadReg(CX)
+	if err != nil {
+		return true, false, err
+	}
+	ptr, ptrType, err := c.compareExchangePointer(destination)
+	if err != nil {
+		return true, false, err
+	}
+	old, success := c.emitPairCompareExchangeNative(bits, destination, ptr, ptrType, ax, dx, bx, cx)
+
+	oldLow, oldHigh := c.compareExchangeSplitPair(old, bits)
+	if err := c.storeCompareExchangePairAccumulator(AX, ax, oldLow, success, bits); err != nil {
+		return true, false, err
+	}
+	if err := c.storeCompareExchangePairAccumulator(DX, dx, oldHigh, success, bits); err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", success, c.flagsZSlot)
+	return true, false, nil
+}
+
+func (c *amd64Ctx) validateCompareExchangeFP(destination Operand, bits int) error {
+	if destination.Kind != OpFP {
+		return nil
+	}
+	context := func(reason string) error {
+		return fmt.Errorf("%w: %s CMPXCHG FP native write at +%d(FP): %s", ErrProbeNeedsContext, c.goarch, destination.FPOffset, reason)
+	}
+	if bits == 128 {
+		return context("logical FP storage has no original CMPXCHG16B native address/alignment identity")
+	}
+	width := bits / 8
+	if err := c.validateFPVectorSpan(destination.FPOffset, width); err != nil {
+		return context(err.Error())
+	}
+	if c.classicFrame != "" {
+		return nil
+	}
+	slot, _, ok := c.fpVectorSlot(destination.FPOffset)
+	if !ok || slot.Offset != destination.FPOffset || x86FrameTypeSize(slot.Type) < int64(width) {
+		return context("native access is not an existing complete contiguous shadow slot")
+	}
+	return nil
+}
+
+func (c *amd64Ctx) compareExchangeJoinPair(low, high string, bits int) string {
+	partType := LLVMType("i32")
+	pairType := LLVMType("i64")
+	shift := 32
+	if bits == 128 {
+		partType = I64
+		pairType = LLVMType("i128")
+		shift = 64
+	}
+	lowPart, highPart := low, high
+	if partType == I32 {
+		lowPart = c.truncI64(low, I32)
+		highPart = c.truncI64(high, I32)
+	}
+	lowWide := c.newTmp()
+	highWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", lowWide, partType, lowPart, pairType)
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", highWide, partType, highPart, pairType)
+	shifted := c.newTmp()
+	joined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %d\n", shifted, pairType, highWide, shift)
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", joined, pairType, shifted, lowWide)
+	return "%" + joined
+}
+
+func (c *amd64Ctx) compareExchangeSplitPair(pair string, bits int) (low, high string) {
+	pairType := LLVMType("i64")
+	partType := LLVMType("i32")
+	shift := 32
+	if bits == 128 {
+		pairType = LLVMType("i128")
+		partType = I64
+		shift = 64
+	}
+	lowName := c.newTmp()
+	highShift := c.newTmp()
+	highName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", lowName, pairType, pair, partType)
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %d\n", highShift, pairType, pair, shift)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", highName, pairType, highShift, partType)
+	return "%" + lowName, "%" + highName
+}
+
+func (c *amd64Ctx) storeCompareExchangePairAccumulator(reg Reg, original, failurePart, success string, bits int) error {
+	failure64 := failurePart
+	if bits == 64 {
+		widened := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", widened, failurePart)
+		failure64 = "%" + widened
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", selected, success, original, failure64)
+	return c.storeReg(reg, "%"+selected)
+}
+
+func (c *amd64Ctx) compareExchangePointer(destination Operand) (ptr, ptrType string, err error) {
+	switch destination.Kind {
+	case OpMem:
+		return c.ptrFromMem(destination.Mem)
+	case OpSym:
+		ptr, err := c.ptrFromSB(destination.Sym)
+		return ptr, "ptr", err
+	case OpFP:
+		if c.classicFrame != "" {
+			return c.classicFramePtr(destination.FPOffset), "ptr", nil
+		}
+		if ptr := c.fpParamAlloca[destination.FPOffset]; ptr != "" {
+			return ptr, "ptr", nil
+		}
+		if ptr, _, ok := c.fpResultAlloca(destination.FPOffset); ok {
+			return ptr, "ptr", nil
+		}
+		return "", "", fmt.Errorf("CMPXCHG FP operand has no mutable slot at +%d(FP)", destination.FPOffset)
+	default:
+		return "", "", fmt.Errorf("CMPXCHG expected memory destination, got %s", destination.String())
+	}
+}
diff --git a/amd64_lower_compare_float.go b/amd64_lower_compare_float.go
new file mode 100644
index 000000000..e5aad5888
--- /dev/null
+++ b/amd64_lower_compare_float.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// lowerFloatingCompare implements the complete Go 1.27 floating-point
+// immediate-compare family: legacy CMP{PD,PS,SD,SS}, the VEX vector-result
+// forms, and the EVEX K-result forms of VCMP{PD,PS,SD,SS}.
+func (c *amd64Ctx) lowerFloatingCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86FloatCompareSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("floating compare dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86FloatCompareProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return true, false, c.emitNativeFloatingCompare(ins, form)
+}
+
+func amd64FloatingCompareProperties(op string) (elemBits int, packed, vector, ok bool) {
+	switch op {
+	case "CMPPD":
+		return 64, true, false, true
+	case "CMPPS":
+		return 32, true, false, true
+	case "CMPSD":
+		return 64, false, false, true
+	case "CMPSS":
+		return 32, false, false, true
+	case "VCMPPD":
+		return 64, true, true, true
+	case "VCMPPS":
+		return 32, true, true, true
+	case "VCMPSD":
+		return 64, false, true, true
+	case "VCMPSS":
+		return 32, false, true, true
+	default:
+		return 0, false, false, false
+	}
+}
+
+func amd64LegacyFloatingCompareImmediate(arg Operand) (int64, bool) {
+	if arg.Kind == OpImm {
+		return arg.Imm, true
+	}
+	// The pre-Go-1.5 x86 assembler wrote CMP{PD,PS,SD,SS} predicates as a
+	// bare decimal operand. Keep this compatibility confined to the legacy
+	// compare family's predicate position instead of accepting bare integers
+	// as immediates throughout the parser.
+	var text string
+	switch arg.Kind {
+	case OpIdent:
+		text = arg.Ident
+	case OpSym:
+		text = arg.Sym
+	default:
+		return 0, false
+	}
+	value, err := strconv.ParseInt(strings.TrimSpace(text), 10, 64)
+	return value, err == nil
+}
+
+func (c *amd64Ctx) isGoLegacyXReg(r Reg) bool {
+	index, ok := amd64ParseXReg(r)
+	if !ok {
+		return false
+	}
+	if c.goarch == "386" {
+		return index < 8
+	}
+	return index < 16
+}
+
+func dstArgOperand(r Reg) Operand {
+	return Operand{Kind: OpReg, Reg: r}
+}
+
+func amd64VEXVectorRegister(op Operand, byteWidth int) bool {
+	if op.Kind != OpReg || amd64VectorByteWidth(op.Reg) != byteWidth {
+		return false
+	}
+	index, ok := amd64VectorRegisterIndex(op.Reg, byteWidth)
+	return ok && index < 16
+}
+
+func amd64EVEXVectorRegister(op Operand, byteWidth int) bool {
+	if op.Kind != OpReg || amd64VectorByteWidth(op.Reg) != byteWidth {
+		return false
+	}
+	index, ok := amd64VectorRegisterIndex(op.Reg, byteWidth)
+	return ok && index < 32
+}
+
+func amd64VectorRegisterIndex(r Reg, byteWidth int) (int, bool) {
+	switch byteWidth {
+	case 16:
+		return amd64ParseXReg(r)
+	case 32:
+		return amd64ParseYReg(r)
+	case 64:
+		return amd64ParseZReg(r)
+	default:
+		return 0, false
+	}
+}
+
+func amd64FloatingComparePredicate(immediate uint8) string {
+	return [...]string{
+		"oeq", "olt", "ole", "uno", "une", "uge", "ugt", "ord",
+		"ueq", "ult", "ule", "false", "one", "oge", "ogt", "true",
+		"oeq", "olt", "ole", "uno", "une", "uge", "ugt", "ord",
+		"ueq", "ult", "ule", "false", "one", "oge", "ogt", "true",
+	}[immediate&31]
+}
+
+func (c *amd64Ctx) loadFloatingVectorOperand(op Operand, byteWidth, lanes, elemBits int) (string, error) {
+	bytesValue, err := c.loadPackedCompareBytes(op, byteWidth)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, byteWidth, bytesValue, amd64FloatingVectorType(lanes, elemBits))
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) loadFloatingScalarOperand(op Operand, elemBits int) (string, error) {
+	if elemBits == 64 {
+		return c.evalF64(op)
+	}
+	return c.evalF32(op)
+}
+
+func (c *amd64Ctx) splatFloatingScalar(value string, lanes, elemBits int) string {
+	vectorType := amd64FloatingVectorType(lanes, elemBits)
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %s, i32 %d\n", inserted, vectorType, result, amd64FloatingScalarType(elemBits), value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) packFloatingCompareMask(compared string, lanes int) string {
+	if lanes == 1 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", wide, compared)
+		return "%" + wide
+	}
+	packedType := fmt.Sprintf("i%d", lanes)
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %s to %s\n", packed, lanes, compared, packedType)
+	if lanes == 64 {
+		return "%" + packed
+	}
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %%%s to i64\n", wide, packedType, packed)
+	return "%" + wide
+}
+
+func amd64FloatingScalarType(elemBits int) string {
+	if elemBits == 64 {
+		return "double"
+	}
+	return "float"
+}
+
+func amd64FloatingVectorType(lanes, elemBits int) string {
+	return fmt.Sprintf("<%d x %s>", lanes, amd64FloatingScalarType(elemBits))
+}
diff --git a/amd64_lower_compare_float_historical_test.go b/amd64_lower_compare_float_historical_test.go
new file mode 100644
index 000000000..644717991
--- /dev/null
+++ b/amd64_lower_compare_float_historical_test.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import "testing"
+
+func TestTranslateAMD64LegacyFloatingCompareHistoricalBarePredicate(t *testing.T) {
+	source := "TEXT historicalcompare(SB),NOSPLIT,$0-0\n" +
+		"\tCMPPD X1, X0, 1\n" +
+		"\tCMPPS 8(AX), X0, 2\n" +
+		"\tCMPSD X1, X0, 5\n" +
+		"\tCMPSS 8(AX), X0, -1\n" +
+		"\tRET\n"
+	ll := x86UnboundVoidScalarFormatObject(t, source, "historicalcompare", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "historical-floating-compare.ll", "historical-floating-compare.o", ll)
+}
+
+func TestTranslateAMD64LegacyFloatingCompareRejectsInvalidBarePredicate(t *testing.T) {
+	for _, instruction := range []string{
+		"CMPPD X1, X0, predicate",
+		"CMPPS X1, X0, 128",
+		"CMPSD X1, X0, -129",
+		"CMPSS X1, X0, 1+1",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "x86_64-unknown-linux-gnu",
+			Goarch:       "amd64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted invalid historical predicate %q", instruction)
+		}
+	}
+}
diff --git a/amd64_lower_compare_greater_test.go b/amd64_lower_compare_greater_test.go
new file mode 100644
index 000000000..647b04cc3
--- /dev/null
+++ b/amd64_lower_compare_greater_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedSignedGreaterThanCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast, vectorLeft, vectorRight, zLast := 15, 20, 21, 22
+			if target.goarch == "386" {
+				legacyLast, vectorLeft, vectorRight, zLast = 7, 6, 7, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedsignedgreaterthanforms(SB),4,$0-0\n")
+			for _, op := range []string{"PCMPGTB", "PCMPGTW", "PCMPGTL"} {
+				// Py1's MMX encoder row is amd64-only. A frontend-accepted
+				// high vector spelling is likewise not a physical 386 bank.
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s M0, M1\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M2\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+			}
+			fmt.Fprintf(&source, "\tPCMPGTQ X0, X%d\n", legacyLast)
+			fmt.Fprintf(&source, "\tPCMPGTQ 8(AX), X%d\n", legacyLast)
+			for _, op := range []string{"VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s1, %s2\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s %s%d, %s%d, K3\n", op, width, vectorLeft, width, vectorRight)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, K3\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z6, K3\n", op)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, K0\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s Z20, Z21, K2, K3\n", op)
+				} else {
+					fmt.Fprintf(&source, "\t%s Z0, Z6, K%d\n", op, zLast)
+				}
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					for _, width := range []string{"X", "Y", "Z"} {
+						fmt.Fprintf(&source, "\t%s.BCST 8(AX), %s%d, K3\n", op, width, vectorRight)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "packedsignedgreaterthanforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-signed-greater-than-"+target.name+".ll", "packed-signed-greater-than-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedSignedGreaterThanRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PCMPGTB.Z X0, X1",
+		"PCMPGTW X0",
+		"PCMPGTL M0, X1",
+		"PCMPGTQ M0, M1",
+		"PCMPGTB Y0, Y1",
+		"PCMPGTW X0, (AX)",
+		"VPCMPGTB X0, X1",
+		"VPCMPGTW X0, Y1, Y2",
+		"VPCMPGTD Z0, Z1, Z2",
+		"VPCMPGTQ X0, X1, K0, K2",
+		"VPCMPGTB.Z X0, X1, K2",
+		"VPCMPGTW.BCST 8(AX), X1, K2",
+		"VPCMPGTD.BCST X0, X1, K2",
+		"VPCMPGTQ.BCST 8(AX), X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedSignedGreaterThanRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PCMPGTW X8, X0",
+		"PCMPGTL X0, X8",
+		"VPCMPGTB X16, X1, X2",
+		"VPCMPGTW X0, X1, X16",
+		"VPCMPGTD Z8, Z1, K2",
+		"VPCMPGTQ Z0, Z1, K1, K2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedSignedGreaterThanRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, op := range []string{"PCMPGTB", "PCMPGTW", "PCMPGTL"} {
+		for _, operands := range []string{"M0, M1", "8(AX), M2"} {
+			instruction := op + " " + operands
+			goAssemblerOracleOutput(t, "386", "TEXT bad(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			assertX86PackedSignedGreaterThanRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		}
+	}
+}
+
+func assertX86PackedSignedGreaterThanRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed signed greater-than forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_compare_legacy_equal_test.go b/amd64_lower_compare_legacy_equal_test.go
new file mode 100644
index 000000000..f9238a184
--- /dev/null
+++ b/amd64_lower_compare_legacy_equal_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86LegacyPackedEqualityActualGoEncoderRows(t *testing.T) {
+	body, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := strings.Join(strings.Fields(string(body)), "")
+	for _, definition := range []string{
+		"var ymm = []ytab{ {Zm_r_xm, 1, argList{Ymm, Ymr}}, {Zm_r_xm, 2, argList{Yxm, Yxr}}, }",
+		"var yxm_q4 = []ytab{ {Zm_r, 1, argList{Yxm, Yxr}}, }",
+		"{APCMPEQB, ymm, Py1, opBytes{0x74, Pe, 0x74}}",
+		"{APCMPEQW, ymm, Py1, opBytes{0x75, Pe, 0x75}}",
+		"{APCMPEQL, ymm, Py1, opBytes{0x76, Pe, 0x76}}",
+		"{APCMPEQQ, yxm_q4, Pq4, opBytes{0x29}}",
+	} {
+		if !strings.Contains(actual, strings.Join(strings.Fields(definition), "")) {
+			t.Fatalf("selected Go SDK packed-equality encoding row changed: %s", definition)
+		}
+	}
+}
+
+func TestTranslateX86LegacyPackedEqualityCompleteGoAssemblerForms(t *testing.T) {
+	// PCMPEQ{B,W,L} use Go's ymm table (MMX/memory -> MMX and X/memory
+	// -> X). Py1 admits the MMX row only in amd64; 386 must use X0-X7.
+	// PCMPEQQ uses yxm_q4, which has only the X/memory -> X row.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastX := 15
+			if target.goarch == "386" {
+				lastX = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT legacypackedequalityforms(SB),4,$0-0\n")
+			for _, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL"} {
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s M0, M1\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M2\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, lastX)
+				fmt.Fprintf(&source, "\t%s 16(AX), X%d\n", op, lastX)
+			}
+			fmt.Fprintf(&source, "\tPCMPEQQ X0, X%d\n", lastX)
+			fmt.Fprintf(&source, "\tPCMPEQQ 24(AX), X%d\n", lastX)
+			source.WriteString("\tRET\n")
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "legacypackedequalityforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "legacy-packed-equality-"+target.name+".ll", "legacy-packed-equality-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86LegacyPackedEqualityRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PCMPEQQ M0, M1",
+		"PCMPEQQ X0, M1",
+		"PCMPEQW M0, X1",
+		"PCMPEQL X0, M1",
+		"PCMPEQB Y0, X1",
+		"PCMPEQQ X0, Y1",
+		"PCMPEQQ.Z X0, X1",
+		"PCMPEQQ X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86LegacyPackedEqualityRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86LegacyPackedEqualityRejected(t, "386", "i386-unknown-linux-gnu", "PCMPEQQ X8, X0")
+	assertX86LegacyPackedEqualityRejected(t, "386", "i386-unknown-linux-gnu", "PCMPEQQ X0, X8")
+	for _, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL"} {
+		for _, operands := range []string{"M0, M1", "8(AX), M2"} {
+			assertX86LegacyPackedEqualityRejected(t, "386", "i386-unknown-linux-gnu", op+" "+operands)
+		}
+	}
+}
+
+func assertX86LegacyPackedEqualityRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	source := "TEXT bad(SB),4,$0-0\n\t" + instruction + "\n\tRET\n"
+	goAssemblerOracleOutput(t, goarch, source, "", false)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return
+	}
+	if ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil || ir != "" {
+		t.Fatalf("Translate accepted %q outside Go 1.27's legacy packed equality forms", instruction)
+	}
+}
diff --git a/amd64_lower_compare_mask.go b/amd64_lower_compare_mask.go
new file mode 100644
index 000000000..9f218496a
--- /dev/null
+++ b/amd64_lower_compare_mask.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ImmediatePackedCompareSpec struct {
+	laneBits int
+	unsigned bool
+}
+
+var amd64ImmediatePackedCompareSpecs = map[string]amd64ImmediatePackedCompareSpec{
+	"VPCMPB":  {laneBits: 8},
+	"VPCMPW":  {laneBits: 16},
+	"VPCMPD":  {laneBits: 32},
+	"VPCMPQ":  {laneBits: 64},
+	"VPCMPUB": {laneBits: 8, unsigned: true},
+	"VPCMPUW": {laneBits: 16, unsigned: true},
+	"VPCMPUD": {laneBits: 32, unsigned: true},
+	"VPCMPUQ": {laneBits: 64, unsigned: true},
+}
+
+// lowerImmediatePackedCompare implements the complete Go 1.27 _yvpcmpb
+// operand table and all eight signed/unsigned element-width mnemonics.
+func (c *amd64Ctx) lowerImmediatePackedCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86ImmediatePackedCompareProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	writeMask := ""
+	if form.mask >= 0 {
+		writeMask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	// Use the existing E4 lane reader: active native reads remain volatile
+	// even for constant predicates/dead K outputs, and actual inactive mask
+	// lanes alone suppress their accesses. FP spans stay independently checked.
+	if form.source.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(form.source.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	firstValue, err := c.loadX86PackedShiftLanes(form.source, form.byteWidth, form.spec.laneBits, form.broadcast, writeMask)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, err := c.loadPackedCompareLanes(ins.Args[form.second], form.byteWidth, form.spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.byteWidth * 8 / form.spec.laneBits
+	compared := c.emitImmediatePackedComparePredicate(lanes, form.spec.laneBits, secondValue, firstValue, form.predicate, form.unsigned)
+	packedType := fmt.Sprintf("i%d", lanes)
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %s to %s\n", packed, lanes, compared, packedType)
+	result := "%" + packed
+	if lanes < 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, packedType, result)
+		result = "%" + wide
+	}
+	if writeMask != "" {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, result, writeMask)
+		result = "%" + masked
+	}
+	return true, false, c.storeK(ins.Args[form.destination].Reg, result)
+}
+
+func (c *amd64Ctx) emitImmediatePackedComparePredicate(lanes, laneBits int, left, right string, immediate uint8, unsigned bool) string {
+	switch immediate & 7 {
+	case 3:
+		return "zeroinitializer"
+	case 7:
+		return llvmAllTrueI1VectorValue(lanes)
+	}
+	predicates := [8]string{"eq", "slt", "sle", "", "ne", "sge", "sgt", ""}
+	if unsigned {
+		predicates = [8]string{"eq", "ult", "ule", "", "ne", "uge", "ugt", ""}
+	}
+	compared := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", compared, predicates[immediate&7], lanes, laneBits, left, right)
+	return "%" + compared
+}
+
+func llvmAllTrueI1VectorValue(lanes int) string {
+	var value strings.Builder
+	value.WriteByte('<')
+	for lane := 0; lane < lanes; lane++ {
+		if lane != 0 {
+			value.WriteString(", ")
+		}
+		value.WriteString("i1 true")
+	}
+	value.WriteByte('>')
+	return value.String()
+}
diff --git a/amd64_lower_compare_mask_test.go b/amd64_lower_compare_mask_test.go
new file mode 100644
index 000000000..cc6bf783b
--- /dev/null
+++ b/amd64_lower_compare_mask_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ImmediatePackedCompareCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 gives VPCMP{B,W,D,Q,UB,UW,UD,UQ} the same _yvpcmpb
+	// table: unsigned-byte immediate, X/Y/Z r/m first source, matching vector
+	// second source, optional K1-K7 write mask, and K destination. D/Q forms
+	// additionally enable scalar-memory broadcast.
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT immediatepackedcompareforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{
+				"VPCMPB", "VPCMPW", "VPCMPD", "VPCMPQ",
+				"VPCMPUB", "VPCMPUW", "VPCMPUD", "VPCMPUQ",
+			} {
+				fmt.Fprintf(&source, "\t%s $0, X1, X20, K0\n", op)
+				fmt.Fprintf(&source, "\t%s $1, 8(AX), X20, K1, K2\n", op)
+				fmt.Fprintf(&source, "\t%s $2, Y1, Y20, K3\n", op)
+				fmt.Fprintf(&source, "\t%s $3, 40(AX), Y20, K4, K5\n", op)
+				fmt.Fprintf(&source, "\t%s $7, Z1, Z20, K6\n", op)
+				fmt.Fprintf(&source, "\t%s $255, 104(AX), Z20, K7, K0\n", op)
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					fmt.Fprintf(&source, "\t%s.BCST $4, 168(AX), X20, K1\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST $5, 176(AX), Y20, K2, K3\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST $6, 184(AX), Z20, K4\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			// Retain every original row as a Go object and public Context
+			// control. Emitter-only objects grant no unknown input; complete
+			// initialized public objects have their separate native-read owner.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(),
+				"immediatepackedcompareforms", "amd64", target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "immediate-packed-compare-"+target.name+".ll", "immediate-packed-compare-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ImmediatePackedCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPCMPUD X0, X1, K1",
+		"VPCMPUD $256, X0, X1, K1",
+		"VPCMPUD $1, X0, Y1, K1",
+		"VPCMPUD $1, X0, (AX), K1",
+		"VPCMPUD $1, X0, X1, K0, K1",
+		"VPCMPUD $1, X0, X1, AX",
+		"VPCMPUD.Z $1, X0, X1, K1",
+		"VPCMPUB.BCST $1, (AX), X1, K1",
+		"VPCMPUW.BCST $1, (AX), X1, K1",
+		"VPCMPUD.BCST $1, X0, X1, K1",
+		"VPCMPUQ $1, X32, X1, K1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ImmediatePackedCompareRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	// cmd/asm's 386 frontend rejects this table's four- and five-operand
+	// spellings before its shared x86 optab is reached.
+	assertX86ImmediatePackedCompareRejected(t, "386", "i386-unknown-linux-gnu", "VPCMPUD $1, Y2, Y0, K2")
+}
+
+func assertX86ImmediatePackedCompareRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's immediate packed compare forms", instruction)
+	}
+}
diff --git a/amd64_lower_compare_vec.go b/amd64_lower_compare_vec.go
new file mode 100644
index 000000000..833258656
--- /dev/null
+++ b/amd64_lower_compare_vec.go
@@ -0,0 +1,354 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedIntegerCompareSpec struct {
+	laneBits          int
+	greater           bool
+	mapNumber, opcode int
+}
+
+// Every Go _yvpcmpeqb entry: X/Y VEX vector results, X/Y/Z EVEX K
+// results, optional K1-7 mask, and memory-only D/Q broadcast. Raw decode
+// consumes the same lane and encoding axes as the named lowerer.
+var amd64PackedIntegerCompareSpecs = map[Op]amd64PackedIntegerCompareSpec{
+	"VPCMPEQB": {8, false, 1, 0x74},
+	"VPCMPEQW": {16, false, 1, 0x75},
+	"VPCMPEQD": {32, false, 1, 0x76},
+	"VPCMPEQQ": {64, false, 2, 0x29},
+	"VPCMPGTB": {8, true, 1, 0x64},
+	"VPCMPGTW": {16, true, 1, 0x65},
+	"VPCMPGTD": {32, true, 1, 0x66},
+	"VPCMPGTQ": {64, true, 2, 0x37},
+}
+
+// lowerPackedIntegerCompare implements the legacy PCMPGT{B,W,L,Q} family and
+// the complete Go 1.27 _yvpcmpeqb operand family shared by VPCMPEQ{B,W,D,Q}
+// and VPCMPGT{B,W,D,Q}.
+// VEX forms write X/Y vectors. EVEX forms compare X/Y/Z lanes into a K
+// register, optionally gated by a non-K0 mask; D/Q memory operands can be
+// broadcast for the EVEX forms.
+func (c *amd64Ctx) lowerPackedIntegerCompare(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedIntegerCompareProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ins.Op = op
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if form.legacy {
+		local := ins
+		local.Args = append([]Operand(nil), ins.Args...)
+		local.Args[form.first] = form.source
+		if form.memory >= 0 && !form.mmx {
+			virtual := form.source.Kind == OpFP
+			if form.source.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+				virtual = !c.nativeMemoryOperand(ins, form.first)
+			}
+			if virtual {
+				return true, false, fmt.Errorf("%w: legacy packed integer compare m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+			}
+		}
+		return c.lowerLegacyPackedIntegerCompare(base, form.spec.laneBits, form.spec.mmx, local)
+	}
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if form.maskResult {
+		return true, false, c.emitPackedIntegerMaskCompare(base, form.spec.laneBits, form.byteWidth,
+			form.source, ins.Args[form.second], ins.Args[form.destination].Reg, mask, form.broadcast)
+	}
+	return true, false, c.emitPackedIntegerVectorCompare(base, form.spec.laneBits, form.byteWidth,
+		form.source, ins.Args[form.second], ins.Args[form.destination].Reg)
+}
+
+func (c *amd64Ctx) lowerLegacyPackedIntegerCompare(baseOp string, laneBits int, allowMMX bool, ins Instr) (bool, bool, error) {
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s expects packed source, packed destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	destination := ins.Args[1].Reg
+	if _, mmx := amd64ParseMReg(destination); mmx {
+		if !allowMMX {
+			return true, false, fmt.Errorf("%s %s has no MMX form in Go 1.27's yxm_q4 table: %q", c.goarch, baseOp, ins.Raw)
+		}
+		if ins.Args[0].Kind == OpReg {
+			if _, ok := amd64ParseMReg(ins.Args[0].Reg); !ok {
+				return true, false, fmt.Errorf("%s %s MMX form requires an MMX source: %q", c.goarch, baseOp, ins.Raw)
+			}
+		} else if !isAMD64MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("%s %s MMX form requires MMX or memory source: %q", c.goarch, baseOp, ins.Raw)
+		}
+		firstBits, err := c.loadLegacyMMXPackedSource(ins.Args[0])
+		if err != nil {
+			return true, false, err
+		}
+		secondBits, err := c.loadReg(destination)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := 64 / laneBits
+		first := c.bitcastI64ToIntegerLanes(lanes, laneBits, firstBits)
+		second := c.bitcastI64ToIntegerLanes(lanes, laneBits, secondBits)
+		result := c.emitLegacyPackedIntegerCompare(baseOp, lanes, laneBits, first, second)
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", bits, lanes, laneBits, result)
+		return true, false, c.storeReg(destination, "%"+bits)
+	}
+
+	if !c.isGoLegacyXReg(destination) {
+		return true, false, fmt.Errorf("%s %s destination must be an in-range MMX or X register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if ins.Args[0].Kind == OpReg && !c.isGoLegacyXReg(ins.Args[0].Reg) {
+		return true, false, fmt.Errorf("%s %s XMM form requires an in-range X source: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpReg && !isAMD64MemoryOperand(ins.Args[0]) {
+		return true, false, fmt.Errorf("%s %s XMM form requires X or memory source: %q", c.goarch, baseOp, ins.Raw)
+	}
+	secondBytes, err := c.loadX(destination)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / laneBits
+	second := c.bitcastVectorBytesToIntegerLanes(16, lanes, laneBits, secondBytes)
+	var result string
+	if isAMD64MemoryOperand(ins.Args[0]) {
+		mnemonic := strings.ToLower(baseOp)
+		if laneBits == 32 {
+			mnemonic = strings.TrimSuffix(mnemonic, "l") + "d"
+		}
+		result, err = c.emitPackedBinaryNativeMemory(ins.Args[0], laneBits, second, mnemonic)
+	} else {
+		firstBytes, loadErr := c.loadXVecOperand(ins.Args[0])
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		first := c.bitcastVectorBytesToIntegerLanes(16, lanes, laneBits, firstBytes)
+		result = c.emitLegacyPackedIntegerCompare(baseOp, lanes, laneBits, first, second)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <16 x i8>\n", out, lanes, laneBits, result)
+	return true, false, c.storeLegacyPackedLogical(ins.Args[1], "%"+out)
+}
+
+func (c *amd64Ctx) emitLegacyPackedIntegerCompare(baseOp string, lanes, laneBits int, first, second string) string {
+	compared := c.newTmp()
+	result := c.newTmp()
+	predicate := "eq"
+	if strings.HasPrefix(baseOp, "PCMPGT") {
+		predicate = "sgt"
+	}
+	fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", compared, predicate, lanes, laneBits, second, first)
+	fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %%%s to <%d x i%d>\n", result, lanes, compared, lanes, laneBits)
+	return "%" + result
+}
+
+func (c *amd64Ctx) isGoVEXVectorRegister(arg Operand, byteWidth int, allowMemory bool) bool {
+	if allowMemory && isAMD64MemoryOperand(arg) {
+		return true
+	}
+	if !amd64VEXVectorRegister(arg, byteWidth) {
+		return false
+	}
+	if c.goarch == "386" {
+		index, _ := amd64VectorRegisterIndex(arg.Reg, byteWidth)
+		return index < 8
+	}
+	return true
+}
+
+func amd64PackedCompareWidth(op Operand) (int, bool) {
+	if op.Kind != OpReg {
+		return 0, false
+	}
+	switch {
+	case isAMD64XReg(op.Reg):
+		return 16, true
+	case isAMD64YReg(op.Reg):
+		return 32, true
+	case isAMD64ZReg(op.Reg):
+		return 64, true
+	default:
+		return 0, false
+	}
+}
+
+func (c *amd64Ctx) loadPackedCompareBytes(op Operand, byteWidth int) (string, error) {
+	if op.Kind == OpReg {
+		width, ok := amd64PackedCompareWidth(op)
+		if !ok || width != byteWidth {
+			return "", fmt.Errorf("expected %d-byte vector register, got %s", byteWidth, op.String())
+		}
+		switch byteWidth {
+		case 16:
+			return c.loadX(op.Reg)
+		case 32:
+			return c.loadY(op.Reg)
+		case 64:
+			return c.loadZ(op.Reg)
+		}
+	}
+	if op.Kind == OpFP {
+		return c.loadFPVectorBytes(op.FPOffset, byteWidth)
+	}
+	if op.Kind == OpSym {
+		// As in Go's x86 assembler, an unprefixed integer denotes an
+		// absolute memory address rather than an immediate value.
+		if address, parseErr := parseInt(strings.TrimSpace(op.Sym)); parseErr == nil {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load <%d x i8>, ptr %s, align 1\n", value, byteWidth, c.ptrFromAddrI64(fmt.Sprintf("%d", address)))
+			return "%" + value, nil
+		}
+	}
+	if !isAMD64MemoryOperand(op) {
+		return "", fmt.Errorf("expected vector register or memory, got %s", op.String())
+	}
+	switch byteWidth {
+	case 16:
+		return c.loadXVecOperand(op)
+	case 32:
+		return c.loadYVecOperand(op)
+	case 64:
+		return c.loadZVecOperand(op)
+	default:
+		return "", fmt.Errorf("unsupported packed compare width %d", byteWidth)
+	}
+}
+
+func (c *amd64Ctx) loadPackedCompareLanes(op Operand, byteWidth, laneBits int, broadcast bool) (string, error) {
+	lanes := byteWidth * 8 / laneBits
+	if broadcast {
+		value, err := c.evalIntSized(op, amd64IntegerTypeForBits(laneBits))
+		if err != nil {
+			return "", err
+		}
+		return amd64SplatInteger(c, lanes, laneBits, value), nil
+	}
+	bytesValue, err := c.loadPackedCompareBytes(op, byteWidth)
+	if err != nil {
+		return "", err
+	}
+	lanesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i%d>\n", lanesValue, byteWidth, bytesValue, lanes, laneBits)
+	return "%" + lanesValue, nil
+}
+
+func (c *amd64Ctx) comparePackedIntegerLanes(baseOp string, laneBits, byteWidth int, first, second Operand, broadcast bool, mask string) (string, error) {
+	// E4/E4.nb permits only inactive native lanes to suppress their accesses.
+	// Keep active reads observable even when the compare result is dead.
+	// Independent virtual FP fields still require the full checked byte span.
+	if first.Kind == OpFP {
+		width := byteWidth
+		if broadcast {
+			width = laneBits / 8
+		}
+		if err := c.validateX86PackedShiftFPSpan(first.FPOffset, width); err != nil {
+			return "", err
+		}
+	}
+	firstValue, err := c.loadX86PackedShiftLanes(first, byteWidth, laneBits, broadcast, mask)
+	if err != nil {
+		return "", err
+	}
+	secondValue, err := c.loadPackedCompareLanes(second, byteWidth, laneBits, false)
+	if err != nil {
+		return "", err
+	}
+	predicate := "eq"
+	if amd64PackedIntegerCompareSpecs[Op(baseOp)].greater {
+		predicate = "sgt"
+	}
+	lanes := byteWidth * 8 / laneBits
+	compared := c.newTmp()
+	// Go/Plan 9 lists the Intel r/m operand first: dst = second cmp first.
+	fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", compared, predicate, lanes, laneBits, secondValue, firstValue)
+	return "%" + compared, nil
+}
+
+func (c *amd64Ctx) emitPackedIntegerVectorCompare(baseOp string, laneBits, byteWidth int, first, second Operand, dst Reg) error {
+	compared, err := c.comparePackedIntegerLanes(baseOp, laneBits, byteWidth, first, second, false, "")
+	if err != nil {
+		return err
+	}
+	lanes := byteWidth * 8 / laneBits
+	allBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %s to <%d x i%d>\n", allBits, lanes, compared, lanes, laneBits)
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <%d x i8>\n", bytesValue, lanes, laneBits, allBits, byteWidth)
+	return c.storePackedMoveOperand(Operand{Kind: OpReg, Reg: dst}, byteWidth, "%"+bytesValue)
+}
+
+func (c *amd64Ctx) emitPackedIntegerMaskCompare(baseOp string, laneBits, byteWidth int, first, second Operand, dst Reg, writeMask string, broadcast bool) error {
+	compared, err := c.comparePackedIntegerLanes(baseOp, laneBits, byteWidth, first, second, broadcast, writeMask)
+	if err != nil {
+		return err
+	}
+	lanes := byteWidth * 8 / laneBits
+	packedType := fmt.Sprintf("i%d", lanes)
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %s to %s\n", packed, lanes, compared, packedType)
+	result := "%" + packed
+	if lanes < 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, packedType, result)
+		result = "%" + wide
+	}
+	if writeMask != "" {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, result, writeMask)
+		result = "%" + masked
+	}
+	return c.storeK(dst, result)
+}
+
+func (c *amd64Ctx) loadMaskedPackedCompareLanes(source Operand, byteWidth, laneBits int, broadcast bool, mask string) (string, error) {
+	// FP describes independent checked virtual slots, not one contiguous
+	// native allocation. Keep per-slot loads; never form a vector pointer
+	// from only the first slot, even when its address happens to be available.
+	if source.Kind == OpFP && !broadcast {
+		for offset := source.FPOffset; offset < source.FPOffset+int64(byteWidth); offset += 8 {
+			_, parameter := c.fpParam(offset)
+			_, _, result := c.fpResultAlloca(offset)
+			if !parameter && !result {
+				return "", fmt.Errorf("%s packed compare uses an undeclared FP vector slot at +%d(FP)", c.goarch, offset)
+			}
+		}
+	}
+	if mask == "" || source.Kind == OpReg || source.Kind == OpFP {
+		return c.loadPackedCompareLanes(source, byteWidth, laneBits, broadcast)
+	}
+	lanes := byteWidth * 8 / laneBits
+	if broadcast {
+		relevant, active := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", relevant, mask, uint64(1)<<uint(lanes)-1)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, relevant)
+		value, err := c.loadX86ScalarMemoryIf(source, laneBits, "%"+active)
+		if err != nil {
+			return "", err
+		}
+		return amd64SplatInteger(c, lanes, laneBits, value), nil
+	}
+	pointer, pointerType, suffix, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	if suffix == "" {
+		suffix = ".p0"
+	}
+	predicate := amd64IntegerMaskVector(c, lanes, mask)
+	value := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.masked.load.v%di%d%s(%s align 1 %s, <%d x i1> %s, %s zeroinitializer)\n", value, vectorType, lanes, laneBits, suffix, pointerType, pointer, lanes, predicate, vectorType)
+	return "%" + value, nil
+}
diff --git a/amd64_lower_compress.go b/amd64_lower_compress.go
new file mode 100644
index 000000000..2bc4f343b
--- /dev/null
+++ b/amd64_lower_compress.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64PackedCompressLaneBits = map[Op]int{
+	"VCOMPRESSPS": 32,
+	"VCOMPRESSPD": 64,
+	"VPCOMPRESSB": 8,
+	"VPCOMPRESSW": 16,
+	"VPCOMPRESSD": 32,
+	"VPCOMPRESSQ": 64,
+}
+
+// lowerPackedCompress implements the complete Go 1.27 _yvcompresspd table.
+// Masked register forms compact selected source lanes and merge/zero only the
+// tail. Masked memory forms write selected lanes contiguously and leave every
+// byte after the compacted tail untouched. Go's accepted EVEX.z memory spelling
+// instead raises #UD before any mask, source or address access.
+func (c *amd64Ctx) lowerPackedCompress(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86PackedCompactProperties(op, ins, c.goarch)
+	if !known || form.expand {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.undefinedOpcode() {
+		return c.lowerSyscall("UD2", Instr{Op: "UD2"})
+	}
+	if form.memory >= 0 && c.nativeMemoryOperand(ins, form.memory) {
+		return true, false, c.lowerNativeCompactMemory(ins, form)
+	}
+	laneBits, byteWidth := form.laneBits, form.byteWidth
+	source, destination := ins.Args[0], ins.Args[form.destination]
+
+	sourceBytes, err := c.loadPackedCompareBytes(source, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask < 0 {
+		return true, false, c.storePackedMoveOperand(destination, byteWidth, sourceBytes)
+	}
+	mask, err := c.loadK(ins.Args[form.mask].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / laneBits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	sourceValue := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, sourceBytes)
+	maskVector := amd64IntegerMaskVector(c, lanes, mask)
+	if destination.Kind != OpReg && destination.Kind != OpFP {
+		pointer, pointerType, intrinsicSuffix, err := c.packedVectorMemoryPointer(destination)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void @llvm.masked.compressstore.v%di%d%s(%s %s, %s %s, <%d x i1> %s)\n",
+			lanes, laneBits, intrinsicSuffix, vectorType, sourceValue, pointerType, pointer, lanes, maskVector)
+		return true, false, nil
+	}
+	passthrough := "zeroinitializer"
+	if !form.zeroing {
+		oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		passthrough = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, oldBytes)
+	}
+	compressed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.experimental.vector.compress.v%di%d(%s %s, <%d x i1> %s, %s %s)\n",
+		compressed, vectorType, lanes, laneBits, vectorType, sourceValue, lanes, maskVector, vectorType, passthrough)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", out, vectorType, compressed, byteWidth)
+	// FP results are separate scalar fields, not one contiguous native alloca.
+	// The old complete span supplies the untouched compacted tail above.
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func amd64IntegerMaskVector(c *amd64Ctx, lanes int, mask string) string {
+	packed := mask
+	if lanes < 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, mask, lanes)
+		packed = "%" + narrow
+	}
+	vector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to <%d x i1>\n", vector, lanes, packed, lanes)
+	return "%" + vector
+}
+
+func (c *amd64Ctx) packedVectorMemoryPointer(operand Operand) (ptr, ptrType, intrinsicSuffix string, err error) {
+	switch operand.Kind {
+	case OpMem:
+		ptr, ptrType, err = c.ptrFromMem(operand.Mem)
+		if err != nil {
+			return "", "", "", err
+		}
+		switch ptrType {
+		case "ptr":
+			return ptr, ptrType, "", nil
+		case "ptr addrspace(256)":
+			return ptr, ptrType, ".p256", nil
+		case "ptr addrspace(257)":
+			return ptr, ptrType, ".p257", nil
+		default:
+			return "", "", "", fmt.Errorf("unsupported packed-vector pointer type %s", ptrType)
+		}
+	case OpSym:
+		if address, parseErr := parseInt(strings.TrimSpace(operand.Sym)); parseErr == nil {
+			return c.ptrFromAddrI64(fmt.Sprintf("%d", address)), "ptr", "", nil
+		}
+		ptr, err = c.ptrFromSB(operand.Sym)
+		return ptr, "ptr", "", err
+	case OpFP:
+		if c.classicFrame != "" {
+			return c.classicFramePtr(operand.FPOffset), "ptr", "", nil
+		}
+		if ptr = c.fpParamAlloca[operand.FPOffset]; ptr != "" {
+			return ptr, "ptr", "", nil
+		}
+		if ptr, _, ok := c.fpResultAlloca(operand.FPOffset); ok {
+			return ptr, "ptr", "", nil
+		}
+		return "", "", "", fmt.Errorf("%s %s FP operand has no addressable slot", c.goarch, operand.String())
+	default:
+		return "", "", "", fmt.Errorf("%s expected a packed-vector memory operand, got %s", c.goarch, operand.String())
+	}
+}
diff --git a/amd64_lower_compress_test.go b/amd64_lower_compress_test.go
new file mode 100644
index 000000000..88fac4826
--- /dev/null
+++ b/amd64_lower_compress_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedCompressCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedcompressforms(SB),$0-0\n")
+			for _, op := range []string{"VCOMPRESSPS", "VCOMPRESSPD", "VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					sourceReg, destinationReg := 20, 22
+					if target.goarch == "386" && width == "Z" {
+						sourceReg, destinationReg = 6, 7
+					}
+					fmt.Fprintf(&source, "\t%s %s%d, %s%d\n", op, width, sourceReg, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s %s%d, 8(AX)\n", op, width, sourceReg)
+					fmt.Fprintf(&source, "\t%s %s%d, K1, %s%d\n", op, width, sourceReg, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s.Z %s%d, K7, %s%d\n", op, width, sourceReg, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s %s%d, K2, 8(AX)\n", op, width, sourceReg)
+					fmt.Fprintf(&source, "\t%s.Z %s%d, K3, 8(AX)\n", op, width, sourceReg)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedcompressforms": {Name: "packedcompressforms", Ret: Void},
+				},
+			}
+			for _, api := range []string{"text", "module", "owned-module"} {
+				if ir, err := x86X87UnboundOriginalAPI(t, file, options, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("original format-only source acquired undefined vector/mask/address inputs", api, err)
+				}
+			}
+			ll := x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "PackedCompressEmitterObjectUnit",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerVec(instruction.Op, instruction)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-compress-"+target.name+".ll", "packed-compress-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedCompressRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VCOMPRESSPS 8(AX), X1",
+		"VCOMPRESSPD X0, Y1",
+		"VCOMPRESSPS X0, K0, X1",
+		"VCOMPRESSPD.Z Z0, Z1",
+		"VPCOMPRESSB 8(AX), X1",
+		"VPCOMPRESSW X0, Y1",
+		"VPCOMPRESSD X0, K0, X1",
+		"VPCOMPRESSQ.Z Z0, Z1",
+		"VPCOMPRESSB.BCST X0, X1",
+		"VPCOMPRESSW X0, AX",
+		"VPCOMPRESSD AX, X1",
+		"VPCOMPRESSQ Z0, K1, K2, Z1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			if currentGoMinorAtLeast(27) {
+				requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			}
+			assertX86PackedCompressRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VPCOMPRESSB Z8, Z0",
+		"VPCOMPRESSW Z0, Z8",
+		"VPCOMPRESSD Z8, K1, 8(AX)",
+		"VPCOMPRESSQ Z0, K1, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			if currentGoMinorAtLeast(27) {
+				requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			}
+			assertX86PackedCompressRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedCompressRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's _yvcompresspd forms for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64PackedCompressRuntimeSemantics(t *testing.T) {
+	// This oracle executes portable LLVM semantics on the actual host. It
+	// does not execute AVX512 opcodes or certify original-Go native execution.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT packedcompress(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 (BX), Z0
+	VMOVDQU64 (CX), Z1
+	VPCOMPRESSB Z0, K1, Z1
+	VMOVDQU64 Z1, 0(AX)
+	VMOVDQU64 (CX), Z1
+	VPCOMPRESSW.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 64(AX)
+	VMOVDQU64 (CX), Z1
+	VPCOMPRESSD Z0, K1, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VMOVDQU64 (CX), Z1
+	VPCOMPRESSQ.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 192(AX)
+	VPCOMPRESSB Z0, K1, 256(AX)
+	VPCOMPRESSW Z0, K1, 320(AX)
+	VPCOMPRESSD Z0, K1, 384(AX)
+	VPCOMPRESSQ Z0, K1, 448(AX)
+	VMOVDQU64 (CX), Z1
+	VCOMPRESSPS Z0, K1, Z1
+	VMOVDQU64 Z1, 512(AX)
+	VMOVDQU64 (CX), Z1
+	VCOMPRESSPD.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 576(AX)
+	VCOMPRESSPS Z0, K1, 640(AX)
+	VCOMPRESSPD Z0, K1, 704(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: I64, Index: 3, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packedcompress": {Name: "packedcompress", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+extern void packedcompress(uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static int check_group(const uint8_t *got, const uint8_t *source, const uint8_t *old, int lane_bytes, uint64_t mask, int zero_tail, int memory) {
+  int lanes = 64 / lane_bytes, packed = 0;
+  for (int lane = 0; lane < lanes; lane++) if ((mask >> lane) & 1) {
+    if (memcmp(got + packed*lane_bytes, source + lane*lane_bytes, lane_bytes)) return 10 + lane;
+    packed++;
+  }
+  for (int lane = packed; lane < lanes; lane++) {
+    const uint8_t *want = old + lane*lane_bytes;
+    uint8_t zeros[8] = {0}, untouched[8]; memset(untouched, 0xcc, sizeof(untouched));
+    if (memory) want = untouched; else if (zero_tail) want = zeros;
+    if (memcmp(got + lane*lane_bytes, want, lane_bytes)) return 80 + lane;
+  }
+  return 0;
+}
+int main(void) {
+  uint8_t source[64], old[64], out[768];
+  const uint64_t mask = 0xa55aa55aa55aa55aULL;
+  for (int i = 0; i < 64; i++) { source[i] = (uint8_t)(i * 29 + 7); old[i] = (uint8_t)(0xf0 - i); }
+  memset(out, 0xcc, sizeof(out));
+  packedcompress(out, source, old, mask);
+  int r;
+  if ((r = check_group(out+0, source, old, 1, mask, 0, 0))) return 100+r;
+  if ((r = check_group(out+64, source, old, 2, mask, 1, 0))) return 200+r;
+  if ((r = check_group(out+128, source, old, 4, mask, 0, 0))) return 300+r;
+  if ((r = check_group(out+192, source, old, 8, mask, 1, 0))) return 400+r;
+  if ((r = check_group(out+256, source, old, 1, mask, 0, 1))) return 500+r;
+  if ((r = check_group(out+320, source, old, 2, mask, 0, 1))) return 600+r;
+  if ((r = check_group(out+384, source, old, 4, mask, 0, 1))) return 700+r;
+  if ((r = check_group(out+448, source, old, 8, mask, 0, 1))) return 800+r;
+  if ((r = check_group(out+512, source, old, 4, mask, 0, 0))) return 900+r;
+  if ((r = check_group(out+576, source, old, 8, mask, 1, 0))) return 1000+r;
+  if ((r = check_group(out+640, source, old, 4, mask, 0, 1))) return 1100+r;
+  if ((r = check_group(out+704, source, old, 8, mask, 0, 1))) return 1200+r;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_compress", triple, ll, mainC, nil)
+}
diff --git a/amd64_lower_conflict.go b/amd64_lower_conflict.go
new file mode 100644
index 000000000..6bfd1e65a
--- /dev/null
+++ b/amd64_lower_conflict.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64PackedConflictSpec struct {
+	laneBits int
+}
+
+// amd64PackedConflictSpecs is the complete Go 1.27 VPCONFLICTD/Q grammar.
+// Both instructions use _yvexpandpd: EVEX X/Y/Z register-or-memory sources,
+// optional K1-K7 merge/.Z masking, and scalar-memory broadcast.
+var amd64PackedConflictSpecs = map[Op]amd64PackedConflictSpec{
+	"VPCONFLICTD": {laneBits: 32},
+	"VPCONFLICTQ": {laneBits: 64},
+}
+
+func (c *amd64Ctx) lowerPackedConflict(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86PackedConflictProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	destination := ins.Args[form.destination]
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	// Intel's current E4NF class retains the entire source tuple (or the
+	// independent m32/m64 broadcast), including zero masks and dead results.
+	values, err := c.loadX86PackedShiftLanes(ins.Args[form.first], byteWidth, spec.laneBits, form.broadcast, "")
+	if err != nil {
+		return true, false, err
+	}
+	computed := c.emitPackedConflict(values, lanes, spec.laneBits)
+	result := computed
+	if form.mask >= 0 {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+			if err != nil {
+				return true, false, err
+			}
+			old = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computed, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitPackedConflict(values string, lanes, laneBits int) string {
+	elements := make([]string, lanes)
+	for lane := 0; lane < lanes; lane++ {
+		extracted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", extracted, lanes, laneBits, values, lane)
+		elements[lane] = "%" + extracted
+	}
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		conflicts := "0"
+		for prior := 0; prior < lane; prior++ {
+			equal := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %s, %s\n", equal, laneBits, elements[lane], elements[prior])
+			bit := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d 0\n", bit, equal, laneBits, uint64(1)<<prior, laneBits)
+			merged := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or i%d %s, %%%s\n", merged, laneBits, conflicts, bit)
+			conflicts = "%" + merged
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, lanes, laneBits, result, laneBits, conflicts, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_conflict_test.go b/amd64_lower_conflict_test.go
new file mode 100644
index 000000000..584439a8c
--- /dev/null
+++ b/amd64_lower_conflict_test.go
@@ -0,0 +1,210 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedConflictGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64PackedConflictSpec{
+		"VPCONFLICTD": {laneBits: 32},
+		"VPCONFLICTQ": {laneBits: 64},
+	}
+	if len(amd64PackedConflictSpecs) != len(expected) {
+		t.Fatalf("packed-conflict grammar has %d entries, want %d", len(amd64PackedConflictSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64PackedConflictSpecs[op]; !ok {
+			t.Errorf("packed-conflict grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("packed-conflict grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86PackedConflictCompleteGoFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedconflictforms(SB),$0-0\n")
+			for _, op := range []string{"VPCONFLICTD", "VPCONFLICTQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s0, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(R9), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s %s1, K1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.Z 16(R9), K7, %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST 24(R9), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST.Z 32(R9), K2, %s%d\n", op, width, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			if target.goarch == "386" {
+				// Original accepted X31/Y31 and R9 source spellings do not
+				// establish physical mode32 banks or an incoming address.
+				// The independent initialized low-bank family owns objects.
+				return
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerPackedConflict(ins.Op, ins) })
+			for _, want := range []string{"icmp eq", "select i1", "<16 x i32>", "<8 x i64>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("packed-conflict lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-conflict-"+target.name+".ll", "packed-conflict-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedConflictRejectsFormsOutsideGoTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPCONFLICTD X0, Y1"},
+		{goarch: "amd64", instruction: "VPCONFLICTQ Y0, Z1"},
+		{goarch: "amd64", instruction: "VPCONFLICTD X0, K0, X1"},
+		{goarch: "amd64", instruction: "VPCONFLICTQ.Z X0, X1"},
+		{goarch: "amd64", instruction: "VPCONFLICTD.BCST X0, X1"},
+		{goarch: "amd64", instruction: "VPCONFLICTQ.Z.BCST 0(AX), K1, X1"},
+		{goarch: "amd64", instruction: "VPCONFLICTD.RN_SAE X0, X1"},
+		{goarch: "amd64", instruction: "VPCONFLICTQ X0, 0(AX)"},
+		{goarch: "amd64", instruction: "VPCONFLICTD X0, K1, K2, X1"},
+		{goarch: "386", instruction: "VPCONFLICTD Z8, Z0"},
+		{goarch: "386", instruction: "VPCONFLICTQ Z0, K1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvexpandpd conflict table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64PackedConflictRuntimeSemantics(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable integer oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT packedconflictsemantics(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	STC
+	VPCONFLICTD Z0, Z2
+	VMOVDQU64 Z2, 0(AX)
+	VPCONFLICTQ Z0, Z2
+	VMOVDQU64 Z2, 64(AX)
+	VPCONFLICTD Z0, K1, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VMOVDQU64 0(CX), Z1
+	VPCONFLICTQ.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 192(AX)
+	VPCONFLICTD.BCST 0(BX), Z2
+	VMOVDQU64 Z2, 256(AX)
+	VPCONFLICTQ.BCST 0(BX), Z2
+	VMOVDQU64 Z2, 320(AX)
+	SETCS 384(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"packedconflictsemantics": {
+			Name: "packedconflictsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void packedconflictsemantics(uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+int main(void) {
+  uint32_t source32[16], old32[16]; uint8_t out[385] = {0};
+  for (int i = 0; i < 16; i++) { source32[i] = (uint32_t)(i % 4); old32[i] = 0x90000000u + (uint32_t)i; }
+  const uint64_t mask = UINT64_C(0xa55a);
+  packedconflictsemantics(out, (const uint8_t *)source32, (const uint8_t *)old32, mask);
+  uint32_t *plain32 = (uint32_t *)(out + 0), *merge32 = (uint32_t *)(out + 128), *broadcast32 = (uint32_t *)(out + 256);
+  for (int i = 0; i < 16; i++) {
+    uint32_t conflict = 0;
+    for (int j = 0; j < i; j++) if (source32[j] == source32[i]) conflict |= UINT32_C(1) << j;
+    if (plain32[i] != conflict) return 10 + i;
+    uint32_t merged = (mask >> i) & 1 ? conflict : old32[i];
+    if (merge32[i] != merged) return 30 + i;
+    uint32_t broadcast = i == 0 ? 0 : ((UINT32_C(1) << i) - 1);
+    if (broadcast32[i] != broadcast) return 50 + i;
+  }
+  uint64_t source64[8], old64[8], plain64[8], zero64[8], broadcast64[8];
+  memcpy(source64, source32, 64); memcpy(old64, old32, 64);
+  memcpy(plain64, out + 64, 64); memcpy(zero64, out + 192, 64); memcpy(broadcast64, out + 320, 64);
+  for (int i = 0; i < 8; i++) {
+    uint64_t conflict = 0;
+    for (int j = 0; j < i; j++) if (source64[j] == source64[i]) conflict |= UINT64_C(1) << j;
+    if (plain64[i] != conflict) return 70 + i;
+    uint64_t masked = (mask >> i) & 1 ? conflict : 0;
+    if (zero64[i] != masked) return 80 + i;
+    uint64_t broadcast = i == 0 ? 0 : ((UINT64_C(1) << i) - 1);
+    if (broadcast64[i] != broadcast) return 90 + i;
+  }
+  if (out[384] != 1) return 100;
+  return 0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "packed_conflict_semantics", triple, ir, mainC)
+}
diff --git a/amd64_lower_convert.go b/amd64_lower_convert.go
new file mode 100644
index 000000000..e72459aff
--- /dev/null
+++ b/amd64_lower_convert.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+)
+
+func amd64ParseMReg(r Reg) (idx int, ok bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "M") {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "M"))
+	if err != nil || n < 0 || n > 7 {
+		return 0, false
+	}
+	return n, true
+}
+
+// Legacy named entries use the complete shared typed/native family.
+func (c *amd64Ctx) lowerPackedFloatToDword(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedNumericConversion(op, ins)
+}
+
+func (c *amd64Ctx) lowerPackedSingleToDouble(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if base != "CVTPS2PD" && base != "VCVTPS2PD" {
+		return false, false, nil
+	}
+	return c.lowerPackedPrecisionConvert(op, ins)
+}
diff --git a/amd64_lower_convert_double_dword.go b/amd64_lower_convert_double_dword.go
new file mode 100644
index 000000000..8c859a82c
--- /dev/null
+++ b/amd64_lower_convert_double_dword.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedDoubleDwordMode uint8
+
+const (
+	amd64PackedDwordToDouble amd64PackedDoubleDwordMode = iota
+	amd64PackedDoubleToDword
+)
+
+type amd64PackedDoubleDwordSpec struct {
+	mode         amd64PackedDoubleDwordMode
+	legacy       bool
+	truncate     bool
+	sourceBytes  int
+	destBytes    int
+	resultLanes  int
+	explicitMode string
+}
+
+// This table is both the translation dispatch and the source of truth used by
+// cmd/plan9asmll's supported-opcode extractor.
+var amd64PackedDoubleDwordOps = map[string]amd64PackedDoubleDwordSpec{
+	"CVTPD2PL":    {mode: amd64PackedDoubleToDword, legacy: true, sourceBytes: 16, destBytes: 16, resultLanes: 2},
+	"CVTTPD2PL":   {mode: amd64PackedDoubleToDword, legacy: true, truncate: true, sourceBytes: 16, destBytes: 16, resultLanes: 2},
+	"VCVTDQ2PD":   {mode: amd64PackedDwordToDouble},
+	"VCVTPD2DQ":   {mode: amd64PackedDoubleToDword, sourceBytes: 64, destBytes: 32, resultLanes: 8, explicitMode: "rounding"},
+	"VCVTPD2DQX":  {mode: amd64PackedDoubleToDword, sourceBytes: 16, destBytes: 16, resultLanes: 2},
+	"VCVTPD2DQY":  {mode: amd64PackedDoubleToDword, sourceBytes: 32, destBytes: 16, resultLanes: 4},
+	"VCVTTPD2DQ":  {mode: amd64PackedDoubleToDword, truncate: true, sourceBytes: 64, destBytes: 32, resultLanes: 8, explicitMode: "sae"},
+	"VCVTTPD2DQX": {mode: amd64PackedDoubleToDword, truncate: true, sourceBytes: 16, destBytes: 16, resultLanes: 2},
+	"VCVTTPD2DQY": {mode: amd64PackedDoubleToDword, truncate: true, sourceBytes: 32, destBytes: 16, resultLanes: 4},
+}
+
+type amd64PackedDoubleDwordSuffix struct {
+	broadcast bool
+	rounding  string
+	sae       bool
+	zeroing   bool
+}
+
+func parseAMD64PackedDoubleDwordSuffix(rawOp, baseOp string) (amd64PackedDoubleDwordSuffix, error) {
+	var result amd64PackedDoubleDwordSuffix
+	if rawOp == baseOp {
+		return result, nil
+	}
+	suffixes := strings.Split(strings.TrimPrefix(rawOp, baseOp+"."), ".")
+	for index, suffix := range suffixes {
+		switch suffix {
+		case "BCST":
+			if result.broadcast || result.rounding != "" || result.sae || result.zeroing || index != 0 {
+				return result, fmt.Errorf("amd64 %s has invalid or duplicate .BCST suffix", baseOp)
+			}
+			result.broadcast = true
+		case "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE":
+			if result.broadcast || result.rounding != "" || result.sae || result.zeroing || index != 0 {
+				return result, fmt.Errorf("amd64 %s has invalid or duplicate .%s suffix", baseOp, suffix)
+			}
+			result.rounding = suffix
+		case "SAE":
+			if result.broadcast || result.rounding != "" || result.sae || result.zeroing || index != 0 {
+				return result, fmt.Errorf("amd64 %s has invalid or duplicate .SAE suffix", baseOp)
+			}
+			result.sae = true
+		case "Z":
+			if result.zeroing || index != len(suffixes)-1 {
+				return result, fmt.Errorf("amd64 %s has invalid or misplaced .Z suffix", baseOp)
+			}
+			result.zeroing = true
+		default:
+			return result, fmt.Errorf("amd64 %s has unsupported suffix .%s", baseOp, suffix)
+		}
+	}
+	return result, nil
+}
+
+// Dword-to-double retains its reviewed source/caller grammar; the remaining
+// eight names use the complete packed numeric conversion family.
+func (c *amd64Ctx) lowerPackedDoubleDword(op Op, ins Instr) (bool, bool, error) {
+	if _, known, _ := x86SignedPackedFloatProperties(ins, c.goarch); known {
+		return c.lowerSignedPackedIntegerFloat(op, ins)
+	}
+	return c.lowerPackedNumericConversion(op, ins)
+}
+
+func (c *amd64Ctx) lowIntegerLanes(value string, physicalLanes, resultLanes, laneBits int) string {
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> poison, <%d x i32> <", low, physicalLanes, laneBits, value, physicalLanes, laneBits, resultLanes)
+	for lane := 0; lane < resultLanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", lane)
+	}
+	c.b.WriteString(">\n")
+	return "%" + low
+}
diff --git a/amd64_lower_convert_double_dword_test.go b/amd64_lower_convert_double_dword_test.go
new file mode 100644
index 000000000..56278766c
--- /dev/null
+++ b/amd64_lower_convert_double_dword_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedDoubleDwordCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			high := 20
+			conversionHigh, conversionBroadcast := 20, 9
+			zBroadcast, zRound, zRoundMask := 8, 9, 11
+			if target.goarch == "386" {
+				high = 4
+				zBroadcast, zRound, zRoundMask = 0, 1, 3
+				conversionHigh, conversionBroadcast = 4, 6
+			}
+			source := fmt.Sprintf(`
+TEXT packeddoubledwordforms(SB),$0-0
+	CVTPD2PL X0, X1
+	CVTTPD2PL 16(AX), X2
+	VCVTDQ2PD X0, X1
+	VCVTDQ2PD 32(AX), Y2
+	VCVTDQ2PD Y3, Z4
+	VCVTDQ2PD X%d, K1, X%d
+	VCVTDQ2PD.Z 64(AX), K2, Y7
+	VCVTDQ2PD.BCST 80(AX), Z%d
+	VCVTDQ2PD.BCST.Z 84(AX), K3, X%d
+	VCVTPD2DQX X0, X1
+	VCVTPD2DQX 88(AX), X2
+	VCVTPD2DQX X%d, K1, X%d
+	VCVTPD2DQX 96(AX), K1, X2
+	VCVTPD2DQX.Z 104(AX), K2, X3
+	VCVTPD2DQX.BCST 112(AX), X4
+	VCVTPD2DQX.BCST.Z 120(AX), K3, X5
+	VCVTPD2DQY Y%d, X%d
+	VCVTPD2DQY 128(AX), X4
+	VCVTPD2DQY Y3, K1, X4
+	VCVTPD2DQY.Z 128(AX), K2, X5
+	VCVTPD2DQY.BCST 136(AX), X6
+	VCVTPD2DQY.BCST.Z 144(AX), K3, X7
+	VCVTPD2DQ Z6, Y7
+	VCVTPD2DQ 160(AX), K1, Y8
+	VCVTPD2DQ.Z 168(AX), K2, Y9
+	VCVTPD2DQ.BCST 176(AX), Y10
+	VCVTPD2DQ.BCST.Z 184(AX), K3, Y11
+	VCVTPD2DQ.RN_SAE Z%d, Y10
+	VCVTPD2DQ.RD_SAE.Z Z%d, K3, Y12
+	VCVTPD2DQ.RU_SAE Z%d, Y13
+	VCVTPD2DQ.RZ_SAE.Z Z%d, K4, Y14
+	VCVTTPD2DQX X0, X1
+	VCVTTPD2DQX 216(AX), X2
+	VCVTTPD2DQX X%d, K1, X%d
+	VCVTTPD2DQX 224(AX), K1, X2
+	VCVTTPD2DQX.Z 232(AX), K2, X3
+	VCVTTPD2DQX.BCST 240(AX), X4
+	VCVTTPD2DQX.BCST.Z 248(AX), K3, X5
+	VCVTTPD2DQY Y%d, X%d
+	VCVTTPD2DQY 256(AX), X4
+	VCVTTPD2DQY Y3, K1, X4
+	VCVTTPD2DQY.Z 256(AX), K2, X5
+	VCVTTPD2DQY.BCST 264(AX), X6
+	VCVTTPD2DQY.BCST.Z 272(AX), K3, X7
+	VCVTTPD2DQ Z6, Y7
+	VCVTTPD2DQ 288(AX), K1, Y8
+	VCVTTPD2DQ.Z 296(AX), K2, Y9
+	VCVTTPD2DQ.BCST 304(AX), Y10
+	VCVTTPD2DQ.BCST.Z 312(AX), K3, Y11
+	VCVTTPD2DQ.SAE Z%d, Y10
+	VCVTTPD2DQ.SAE.Z Z%d, K3, Y12
+	RET
+`, conversionHigh, conversionHigh+1, zBroadcast, conversionBroadcast,
+				high, high+1, high, high+1, zRound, zRoundMask, zRound, zRoundMask,
+				high, high+1, high, high+1, zRound, zRoundMask)
+			if target.goarch == "386" {
+				for n := 8; n <= 14; n++ {
+					source = strings.ReplaceAll(source, fmt.Sprintf("Y%d", n), fmt.Sprintf("Y%d", n%8))
+				}
+			}
+			ll := x86UnboundVoidScalarFormatObject(t, source, "packeddoubledwordforms", target.goarch, target.triple)
+			for _, want := range []string{"vcvtdq2pd", "cvtpd2dq", "vcvttpd2dq"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("packed double/dword IR is missing %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-double-dword-"+target.name+".ll", "packed-double-dword-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedDoubleDwordRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTPD2PL Y0, X1",
+		"CVTTPD2PL X0, Y1",
+		"CVTTPD2PL.Z X0, X1",
+		"VCVTDQ2PD Y0, X1",
+		"VCVTDQ2PD X0, Z1",
+		"VCVTDQ2PD.BCST X0, X1",
+		"VCVTDQ2PD.RN_SAE Y0, Z1",
+		"VCVTPD2DQ X0, X1",
+		"VCVTPD2DQY X0, X1",
+		"VCVTPD2DQX Y0, X1",
+		"VCVTPD2DQY.BCST X0, X1",
+		"VCVTPD2DQ.RN_SAE 0(AX), Y1",
+		"VCVTTPD2DQX.SAE X0, X1",
+		"VCVTTPD2DQ.SAE 0(AX), Y1",
+		"VCVTTPD2DQ.Z Z0, Y1",
+		"VCVTTPD2DQ Z0, K0, Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedDoubleDwordRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86PackedDoubleDwordRejected(t, "386", "i386-unknown-linux-gnu", "VCVTPD2DQ Z8, Y1")
+}
+
+func assertX86PackedDoubleDwordRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed double/dword tables", instruction)
+	}
+}
+
+func TestAMD64PackedDoubleDwordRuntimeSemantics(t *testing.T) {
+	amd64PackedDoubleDwordRuntime(t, x86FloatCompareRuntimeTools(t, x86FloatCompareSSE), false)
+}
+
+func x86PackedDoubleDwordOriginalAssembly() string {
+	return `
+TEXT packeddoubledword(SB),NOSPLIT,$0-40
+	MOVQ out+0(FP), AX
+	MOVQ doubles+8(FP), BX
+	MOVQ dwords+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ mask+32(FP), SI
+	KMOVQ SI, K1
+
+	VMOVDQU64 (DX), Z1
+	VCVTDQ2PD (CX), K1, Z1
+	VMOVDQU64 Z1, 0(AX)
+
+	VCVTTPD2DQY (BX), X2
+	VMOVDQU X2, 64(AX)
+
+	VMOVDQU64 (BX), Z0
+	VCVTPD2DQ.RD_SAE.Z Z0, K1, Y3
+	VMOVDQU Y3, 80(AX)
+
+	MOVOU (BX), X4
+	CVTPD2PL X4, X0
+	MOVQ X0, 112(AX)
+	VZEROUPPER
+	RET
+`
+}
+
+func x86PackedDoubleDwordRawAssembly(source string) string {
+	return strings.NewReplacer(
+		"TEXT packeddoubledword(SB),NOSPLIT,$0-40", "TEXT packeddoubledword(SB),4,$0-40",
+		"VCVTDQ2PD (CX), K1, Z1", "BYTE $0x62; BYTE $0xf1; BYTE $0x7e; BYTE $0x49; BYTE $0xe6; BYTE $0x09",
+		"VCVTTPD2DQY (BX), X2", "BYTE $0xc5; BYTE $0xfd; BYTE $0xe6; BYTE $0x13",
+		"VCVTPD2DQ.RD_SAE.Z Z0, K1, Y3", "BYTE $0x62; BYTE $0xf1; BYTE $0xff; BYTE $0xb9; BYTE $0xe6; BYTE $0xd8",
+		"CVTPD2PL X4, X0", "BYTE $0xf2; BYTE $0x0f; BYTE $0xe6; BYTE $0xc4",
+	).Replace(source)
+}
+
+func x86PackedDoubleDwordSSEAssembly(t *testing.T) string {
+	t.Helper()
+	source := x86PackedDoubleDwordOriginalAssembly()
+	preamble := strings.Index(source, "\tKMOVQ SI, K1")
+	legacy := strings.Index(source, "\tMOVOU (BX), X4")
+	wideExit := strings.Index(source, "\tVZEROUPPER")
+	if preamble < 0 || legacy <= preamble || wideExit <= legacy {
+		t.Fatal("original complete double/dword fixture lost its explicit SSE block")
+	}
+	return source[:preamble] + source[legacy:wideExit] + "\tRET\n"
+}
+
+func amd64PackedDoubleDwordRuntime(t *testing.T, execution x86FloatCompareExecution, nativeWide bool) {
+	t.Helper()
+	source := x86PackedDoubleDwordOriginalAssembly()
+	if !nativeWide {
+		source = x86PackedDoubleDwordSSEAssembly(t)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: I64, Index: 4, Field: -1},
+	}}
+	triple := execution.triple
+	translationOptions := Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packeddoubledword": {
+				Name: "packeddoubledword", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame,
+			},
+		},
+	}
+	ll, err := Translate(file, translationOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The entire original named and raw functions still reach Go and LLVM
+	// objects in the portable lane. Only their execution requires native ISA.
+	for _, complete := range []string{x86PackedDoubleDwordOriginalAssembly(), x86PackedDoubleDwordRawAssembly(x86PackedDoubleDwordOriginalAssembly())} {
+		goAssemblerOracleOutput(t, "amd64", x86PackedDoubleDwordGoAssemblerSource(complete), "", true)
+		parsed, err := Parse(ArchAMD64, complete)
+		if err != nil {
+			t.Fatal(err)
+		}
+		objectIR, err := Translate(parsed, translationOptions)
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, execution.llc, triple, "complete-double-dword.ll", "complete-double-dword.o", objectIR)
+	}
+	mainC := fmt.Sprintf("#define NATIVE_WIDE %d\n", x86FloatAddSubBoolInt(nativeWide)) + `
+#include <stdint.h>
+#include <string.h>
+#include <math.h>
+#include <limits.h>
+extern void packeddoubledword(uint8_t *, const double *, const int32_t *, const double *, uint64_t);
+int main(void) {
+  const double doubles[8] = {1.75, -2.75, 2147483648.0, NAN, -2147483648.0, -2147483649.0, 3.0, -0.0};
+  const int32_t dwords[8] = {0, 1, -1, INT32_MAX, INT32_MIN, 123456789, -987654321, 42};
+  const double old[8] = {100.5, 101.5, 102.5, 103.5, 104.5, 105.5, 106.5, 107.5};
+  const uint64_t mask = 0xa5;
+  uint8_t out[120]; memset(out, 0xcc, sizeof(out));
+  packeddoubledword(out, doubles, dwords, old, mask);
+
+#if NATIVE_WIDE
+  const double *widened = (const double *)(out+0);
+  for (int i = 0; i < 8; i++) {
+    double want = (mask >> i) & 1 ? (double)dwords[i] : old[i];
+    if (widened[i] != want) return 10+i;
+  }
+  const int32_t *truncated = (const int32_t *)(out+64);
+  const int32_t wantTruncated[4] = {1, -2, INT32_MIN, INT32_MIN};
+  for (int i = 0; i < 4; i++) if (truncated[i] != wantTruncated[i]) return 30+i;
+
+  const int32_t *roundedDown = (const int32_t *)(out+80);
+  const int32_t wantRoundedDown[8] = {1, 0, INT32_MIN, 0, 0, INT32_MIN, 0, 0};
+  for (int i = 0; i < 8; i++) if (roundedDown[i] != wantRoundedDown[i]) return 50+i;
+#endif
+
+  const int32_t *legacy = (const int32_t *)(out+112);
+  if (legacy[0] != 2 || legacy[1] != -3) return 70;
+  return 0;
+}
+`
+	execution.compileAndRunLLVM(t, "packed_double_dword", ll, mainC, "-O2")
+
+	rawSource := x86PackedDoubleDwordRawAssembly(source)
+	goAssemblerOracleOutput(t, "amd64", x86PackedDoubleDwordGoAssemblerSource(rawSource), "", true)
+	rawFile, err := Parse(ArchAMD64, rawSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rawIR, err := Translate(rawFile, translationOptions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	execution.compileAndRunLLVM(t, "raw_packed_double_dword", rawIR, mainC, "-O2")
+	t.Logf("complete named/raw objects; SSE legacy output executed; full 120-byte native-wide assertions=%v", nativeWide)
+}
diff --git a/amd64_lower_convert_fp16.go b/amd64_lower_convert_fp16.go
new file mode 100644
index 000000000..6738236e8
--- /dev/null
+++ b/amd64_lower_convert_fp16.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import "fmt"
+
+// FP16 map5/map6 conversions are both load forms. The lane types determine
+// access and result widths; encoded VL distinguishes the two X destinations.
+func (c *amd64Ctx) lowerRawFP16Conversion(ins Instr) (bool, bool, error) {
+	f, known, err := x86FP16ConversionProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, c.emitNativeFP16Conversion(ins, f)
+	}
+	// Preserve the existing cross-target numerical implementation. It is not
+	// an x86 MXCSR/exception execution oracle; matching x86 targets use the
+	// original opcode above, even when the numerical result is dead.
+	spec, properties := f.spec, f.controls
+	if spec.scalar {
+		return c.lowerRawScalarHalfConversion(ins, f)
+	}
+	source, destination := ins.Args[0], ins.Args[f.destination]
+	lanes, inputBytes, outputBytes := f.lanes, f.inputBytes, f.outputBytes
+	sourceRegisterBytes, destinationRegisterBytes := f.sourceBytes, f.byteWidth
+	masked := f.mask >= 0
+
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	var input string
+	if source.Kind == OpReg || !masked && !properties.broadcast {
+		input, err = c.loadPackedExtendInputs(source, sourceRegisterBytes, lanes, spec.inputBits)
+	} else {
+		input, err = c.loadMaskedPackedCompareLanes(source, inputBytes, spec.inputBits, properties.broadcast, mask)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitHalfConversion(lanes, spec, input, properties.rounding)
+	if masked {
+		old, err := c.loadPackedExtendInputs(destination, destinationRegisterBytes, lanes, spec.outputBits)
+		if err != nil {
+			return true, false, err
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.outputBits, result, old, mask, properties.zeroing)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, spec.outputBits, result, outputBytes)
+	return true, false, c.storePackedHalfResult(destination, destinationRegisterBytes, outputBytes, "%"+bytes)
+}
+
+func (c *amd64Ctx) emitHalfConversion(lanes int, spec amd64HalfConversionSpec, input, rounding string) string {
+	inputType := amd64FMA3LLVMType(1, spec.inputBits)
+	outputType := amd64FMA3LLVMType(1, spec.outputBits)
+	conversion := "fpext"
+	if spec.outputBits == 16 {
+		conversion = "fptrunc"
+	}
+	floats, converted, bits := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x %s>\n", floats, lanes, spec.inputBits, input, lanes, inputType)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %%%s to <%d x %s>\n", converted, conversion, lanes, inputType, floats, lanes, outputType)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <%d x i%d>\n", bits, lanes, outputType, converted, lanes, spec.outputBits)
+	result := "%" + bits
+	if spec.outputBits == 16 {
+		result = c.adjustFP16NarrowRounding(lanes, inputType, "%"+floats, "%"+converted, result, rounding)
+	}
+	return result
+}
+
+// Directed rounding differs from nearest-even by at most one half ULP.
+// Comparing the exactly widened result lets integer correction preserve
+// signed zero, subnormals, NaNs and directed overflow without changing the
+// host FP environment. LLVM 22's AArch64 constrained fptrunc does not honor
+// these static rounding modes for half, so it cannot serve as this oracle.
+func (c *amd64Ctx) adjustFP16NarrowRounding(lanes int, inputType, original, halves, bits, rounding string) string {
+	if rounding == "" || rounding == "RN_SAE" {
+		return bits
+	}
+	widened, below, above, negative := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fpext <%d x half> %s to <%d x %s>\n", widened, lanes, halves, lanes, inputType)
+	fmt.Fprintf(c.b, "  %%%s = fcmp olt <%d x %s> %%%s, %s\n", below, lanes, inputType, widened, original)
+	fmt.Fprintf(c.b, "  %%%s = fcmp ogt <%d x %s> %%%s, %s\n", above, lanes, inputType, widened, original)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt <%d x i16> %s, zeroinitializer\n", negative, lanes, bits)
+	one := amd64SplatInteger(c, lanes, 16, "1")
+	plus, minus := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add <%d x i16> %s, %s\n", plus, lanes, bits, one)
+	fmt.Fprintf(c.b, "  %%%s = sub <%d x i16> %s, %s\n", minus, lanes, bits, one)
+	condition, adjusted := "%"+above, "%"+minus
+	choice := c.newTmp()
+	switch rounding {
+	case "RD_SAE":
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i16> %%%s, <%d x i16> %%%s\n", choice, lanes, negative, lanes, plus, lanes, minus)
+		adjusted = "%" + choice
+	case "RU_SAE":
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i16> %%%s, <%d x i16> %%%s\n", choice, lanes, negative, lanes, minus, lanes, plus)
+		condition, adjusted = "%"+below, "%"+choice
+	case "RZ_SAE":
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i1> %%%s, <%d x i1> %%%s\n", choice, lanes, negative, lanes, below, lanes, above)
+		condition = "%" + choice
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %s, <%d x i16> %s, <%d x i16> %s\n", result, lanes, condition, lanes, adjusted, lanes, bits)
+	return "%" + result
+}
diff --git a/amd64_lower_convert_fp16_scalar.go b/amd64_lower_convert_fp16_scalar.go
new file mode 100644
index 000000000..53dd94300
--- /dev/null
+++ b/amd64_lower_convert_fp16_scalar.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerRawScalarHalfConversion(ins Instr, f x86FP16ConversionForm) (bool, bool, error) {
+	spec, properties := f.spec, f.controls
+	source, upper, destination := ins.Args[0], ins.Args[f.upper], ins.Args[f.destination]
+	mask := ""
+	var err error
+	if f.mask >= 0 {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	value, err := c.loadFMA3Scalar(source, spec.inputBits, mask)
+	if err != nil {
+		return true, false, err
+	}
+	inputType := amd64FMA3LLVMType(1, spec.inputBits)
+	vector, bits := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x %s> poison, %s %s, i32 0\n", vector, inputType, inputType, value)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <1 x %s> %%%s to <1 x i%d>\n", bits, inputType, vector, spec.inputBits)
+	result := c.emitHalfConversion(1, spec, "%"+bits, properties.rounding)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.outputBits, result)
+	upperBytes, err := c.loadX(upper.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.outputBits, spec.outputBits, upperBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.outputBits, "%"+low, base, mask, properties.zeroing)
+}
diff --git a/amd64_lower_convert_half.go b/amd64_lower_convert_half.go
new file mode 100644
index 000000000..435b5de0b
--- /dev/null
+++ b/amd64_lower_convert_half.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64HalfConversionSuffix struct {
+	sae     bool
+	zeroing bool
+}
+
+type amd64HalfConversionSpec struct {
+	inputBits, outputBits int
+	rawOnly               bool
+	scalar                bool
+}
+
+var amd64HalfConversionSpecs = map[string]amd64HalfConversionSpec{
+	"VCVTPH2PS":  {inputBits: 16, outputBits: 32},
+	"VCVTPS2PH":  {inputBits: 32, outputBits: 16},
+	"VCVTPH2PSX": {inputBits: 16, outputBits: 32, rawOnly: true},
+	"VCVTPS2PHX": {inputBits: 32, outputBits: 16, rawOnly: true},
+	"VCVTSH2SS":  {inputBits: 16, outputBits: 32, rawOnly: true, scalar: true},
+	"VCVTSS2SH":  {inputBits: 32, outputBits: 16, rawOnly: true, scalar: true},
+	"VCVTSH2SD":  {inputBits: 16, outputBits: 64, rawOnly: true, scalar: true},
+	"VCVTSD2SH":  {inputBits: 64, outputBits: 16, rawOnly: true, scalar: true},
+}
+
+func parseAMD64HalfConversionSuffix(rawOp, baseOp string) (amd64HalfConversionSuffix, error) {
+	var result amd64HalfConversionSuffix
+	if rawOp == baseOp {
+		return result, nil
+	}
+	suffixes := strings.Split(strings.TrimPrefix(rawOp, baseOp+"."), ".")
+	for index, suffix := range suffixes {
+		switch suffix {
+		case "SAE":
+			if result.sae || index != 0 {
+				return result, fmt.Errorf("amd64 %s has invalid or duplicate .SAE suffix", baseOp)
+			}
+			result.sae = true
+		case "Z":
+			if result.zeroing || index != len(suffixes)-1 {
+				return result, fmt.Errorf("amd64 %s has invalid or duplicate .Z suffix", baseOp)
+			}
+			result.zeroing = true
+		default:
+			return result, fmt.Errorf("amd64 %s has unsupported suffix .%s", baseOp, suffix)
+		}
+	}
+	return result, nil
+}
+
+// lowerPackedHalfConversion implements every Go 1.27 _yvcvtph2ps and
+// _yvcvtps2ph row, including VEX signed immediates, EVEX masks, zeroing, SAE,
+// exact-width memory accesses, and the distinct X/Y/Z narrowing widths.
+func (c *amd64Ctx) lowerPackedHalfConversion(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, supported := amd64HalfConversionSpecs[baseOp]
+	if !supported {
+		return false, false, nil
+	}
+	if spec.rawOnly {
+		if !strings.EqualFold(string(op), string(ins.Op)) {
+			return true, false, fmt.Errorf("raw FP16 conversion opcode identity mismatch: %s versus %s", op, ins.Op)
+		}
+		return c.lowerRawFP16Conversion(ins)
+	}
+	return c.lowerNamedHalfConversion(op, ins)
+}
+
+func amd64HalfConversionHighRegister(operand Operand) bool {
+	if operand.Kind != OpReg {
+		return false
+	}
+	width := amd64VectorByteWidth(operand.Reg)
+	index, ok := amd64VectorRegisterIndex(operand.Reg, width)
+	return ok && index >= 16
+}
+
+func (c *amd64Ctx) storePackedHalfResult(destination Operand, registerBytes, outputBytes int, value string) error {
+	if destination.Kind != OpReg {
+		return c.storeVectorBytesOperand(destination, outputBytes, value)
+	}
+	if outputBytes == registerBytes {
+		return c.storePackedMoveOperand(destination, registerBytes, value)
+	}
+	widened := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> <", widened, outputBytes, value, outputBytes, registerBytes)
+	for lane := 0; lane < registerBytes; lane++ {
+		if lane > 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", lane)
+	}
+	c.b.WriteString(">\n")
+	return c.storePackedMoveOperand(destination, registerBytes, "%"+widened)
+}
diff --git a/amd64_lower_convert_half_test.go b/amd64_lower_convert_half_test.go
new file mode 100644
index 000000000..3730563e2
--- /dev/null
+++ b/amd64_lower_convert_half_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedHalfConversionCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 defines the whole F16C/AVX-512 FP16 conversion pair in
+	// _yvcvtph2ps and _yvcvtps2ph:
+	//
+	//   VCVTPH2PS X/m -> X or Y; Y/m -> Z
+	//   VCVTPS2PH imm8, X -> X/m; Y -> X/m; Z -> Y/m
+	//
+	// EVEX forms additionally accept K1-K7 and register-destination zeroing.
+	// The VEX VCVTPS2PH rows accept both signed and unsigned imm8 spellings.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString(`TEXT halfconversionforms(SB),NOSPLIT,$0-0
+	VCVTPH2PS X0, X1
+	VCVTPH2PS 8(AX), X2
+	VCVTPH2PS X20, X21
+	VCVTPH2PS X3, K1, X4
+	VCVTPH2PS.Z 16(AX), K2, X5
+	VCVTPH2PS X6, Y7
+	VCVTPH2PS 32(AX), Y8
+	VCVTPH2PS X20, K3, Y21
+	VCVTPH2PS.Z 48(AX), K4, Y9
+	VCVTPH2PS Y10, Z1
+	VCVTPH2PS 64(AX), Z2
+	VCVTPH2PS Y20, K5, Z3
+	VCVTPH2PS.Z 96(AX), K6, Z4
+	VCVTPH2PS.SAE Y10, Z5
+	VCVTPH2PS.SAE.Z Y11, K7, Z6
+	VCVTPS2PH $0, X0, X1
+	VCVTPS2PH $-1, X2, 128(AX)
+	VCVTPS2PH $255, Y3, X4
+	VCVTPS2PH $-128, Y5, 160(AX)
+	VCVTPS2PH $7, Z1, Y2
+	VCVTPS2PH.SAE $8, Z3, Y4
+`)
+			// Go 1.27's 386 assembler accepts the EVEX VCVTPH2PS mask
+			// rows, but its operand parser does not expose the four-operand
+			// masked VCVTPS2PH rows. Keep this difference visible here.
+			if target.goarch == "amd64" {
+				source.WriteString(`	VCVTPS2PH $126, X7, K5, X17
+	VCVTPS2PH.Z $126, X7, K5, X17
+	VCVTPS2PH $126, X7, K5, 192(AX)
+	VCVTPS2PH $94, Y1, K7, X15
+	VCVTPS2PH.Z $94, Y1, K7, X15
+	VCVTPS2PH $94, Y1, K7, 224(AX)
+	VCVTPS2PH $121, Z5, K7, Y28
+	VCVTPS2PH.SAE.Z $13, Z2, K6, Y13
+	VCVTPS2PH $121, Z5, K7, 256(AX)
+`)
+			}
+			source.WriteString("\tRET\n")
+			ll := x86NamedHalfOriginalFormatObject(t, source.String(), target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-half-conversion-"+target.name+".ll", "packed-half-conversion-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedHalfConversionRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VCVTPH2PS X0",
+		"VCVTPH2PS X0, X1, X2",
+		"VCVTPH2PS Y0, X1",
+		"VCVTPH2PS X0, Z1",
+		"VCVTPH2PS X0, K0, X1",
+		"VCVTPH2PS.Z X0, X1",
+		"VCVTPH2PS.BCST (AX), X1",
+		"VCVTPS2PH X0, X1",
+		"VCVTPS2PH $256, X0, X1",
+		"VCVTPS2PH $0, Z0, X1",
+		"VCVTPS2PH $0, X0, Y1",
+		"VCVTPS2PH $0, X0, K0, X1",
+		"VCVTPS2PH.Z $0, X0, X1",
+		"VCVTPS2PH.BCST $0, X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedHalfConversionRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VCVTPS2PH $-1, X20, X21",
+		"VCVTPS2PH $-1, Y20, X21",
+		"VCVTPS2PH $0, X0, K1, X1",
+		"VCVTPS2PH $0, Y0, K1, X1",
+		"VCVTPS2PH $0, Z0, K1, Y1",
+	} {
+		assertX86PackedHalfConversionRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86PackedHalfConversionRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT bad(SB),NOSPLIT,$0-0\n\t%s\n\tRET\n", instruction))
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VCVTPH2PS/VCVTPS2PH tables", instruction)
+	}
+}
diff --git a/amd64_lower_convert_integer_float.go b/amd64_lower_convert_integer_float.go
new file mode 100644
index 000000000..a75e4167f
--- /dev/null
+++ b/amd64_lower_convert_integer_float.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerLegacyIntegerToFloat implements Go 1.27's complete legacy integer to
+// floating-point conversion group: yxcvlf/yxcvqf scalar conversions and the
+// two yxcvm2 packed conversions.
+func (c *amd64Ctx) lowerLegacyIntegerToFloat(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, known, _ := x86SignedPackedFloatProperties(ins, c.goarch); known {
+		return c.lowerSignedPackedIntegerFloat(op, ins)
+	}
+	rawOp := strings.ToUpper(string(op))
+	if strings.Contains(rawOp, ".") {
+		base := strings.SplitN(rawOp, ".", 2)[0]
+		switch base {
+		case "CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "CVTPL2PS", "CVTPL2PD":
+			return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", base, ins.Raw)
+		}
+	}
+	switch rawOp {
+	case "CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD":
+		return c.lowerLegacyScalarIntegerToFloat(rawOp, ins)
+	case "CVTPL2PS", "CVTPL2PD":
+		return c.lowerLegacyPackedIntegerToFloat(rawOp, ins)
+	default:
+		return false, false, nil
+	}
+}
+
+func (c *amd64Ctx) lowerLegacyScalarIntegerToFloat(op string, ins Instr) (bool, bool, error) {
+	return c.lowerSignedIntegerScalarFloat(Op(op), ins)
+}
+
+func (c *amd64Ctx) lowerLegacyPackedIntegerToFloat(op string, ins Instr) (bool, bool, error) {
+	return c.lowerSignedPackedIntegerFloat(Op(op), ins)
+}
diff --git a/amd64_lower_convert_narrow.go b/amd64_lower_convert_narrow.go
new file mode 100644
index 000000000..ded5f1767
--- /dev/null
+++ b/amd64_lower_convert_narrow.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import "strings"
+
+func (c *amd64Ctx) lowerPackedDoubleToSingle(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if base != "CVTPD2PS" && base != "VCVTPD2PSX" && base != "VCVTPD2PSY" && base != "VCVTPD2PS" {
+		return false, false, nil
+	}
+	return c.lowerPackedPrecisionConvert(op, ins)
+}
diff --git a/amd64_lower_convert_narrow_test.go b/amd64_lower_convert_narrow_test.go
new file mode 100644
index 000000000..7ffcb3f88
--- /dev/null
+++ b/amd64_lower_convert_narrow_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedDoubleToSingleCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses four related tables for this family:
+	//   CVTPD2PS:  X/m128 -> X
+	//   VCVTPD2PSX: X/m128 -> X
+	//   VCVTPD2PSY: Y/m256 -> X
+	//   VCVTPD2PS:  Z/m512 -> Y
+	// The EVEX forms accept scalar-double broadcast and K1-K7 masking. Only
+	// the 512-bit source form accepts explicit rounding.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			// Go permits EVEX X/Y registers through 31 in 386 mode, while a
+			// Z source (the Yzm class) remains limited to Z0-Z7 there.
+			lastZ := 21
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT packeddoubletosingleforms(SB),NOSPLIT,$0-0\n")
+			src.WriteString("\tCVTPD2PS X0, X1\n")
+			src.WriteString("\tCVTPD2PS 8(AX), X2\n")
+			src.WriteString("\tVCVTPD2PSX X20, X0\n")
+			src.WriteString("\tVCVTPD2PSX (AX), X1\n")
+			src.WriteString("\tVCVTPD2PSX X20, K1, X21\n")
+			src.WriteString("\tVCVTPD2PSX.Z 16(AX), K2, X3\n")
+			src.WriteString("\tVCVTPD2PSX.BCST 24(AX), X4\n")
+			src.WriteString("\tVCVTPD2PSX.BCST.Z 32(AX), K3, X5\n")
+			src.WriteString("\tVCVTPD2PSY Y20, X0\n")
+			src.WriteString("\tVCVTPD2PSY (AX), X1\n")
+			src.WriteString("\tVCVTPD2PSY Y20, K4, X21\n")
+			src.WriteString("\tVCVTPD2PSY.Z 40(AX), K5, X3\n")
+			src.WriteString("\tVCVTPD2PSY.BCST 48(AX), X4\n")
+			src.WriteString("\tVCVTPD2PSY.BCST.Z 56(AX), K6, X5\n")
+			fmt.Fprintf(&src, "\tVCVTPD2PS Z%d, Y0\n", lastZ)
+			src.WriteString("\tVCVTPD2PS (AX), Y1\n")
+			fmt.Fprintf(&src, "\tVCVTPD2PS Z%d, K1, Y21\n", lastZ)
+			src.WriteString("\tVCVTPD2PS.Z 64(AX), K2, Y3\n")
+			src.WriteString("\tVCVTPD2PS.BCST 72(AX), Y4\n")
+			src.WriteString("\tVCVTPD2PS.BCST.Z 80(AX), K3, Y5\n")
+			for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				fmt.Fprintf(&src, "\tVCVTPD2PS.%s Z%d, Y6\n", rounding, lastZ)
+			}
+			fmt.Fprintf(&src, "\tVCVTPD2PS.RN_SAE.Z Z%d, K7, Y6\n", lastZ)
+			src.WriteString("\tRET\n")
+
+			// Preserve the entire original table and independent Go object.
+			// Missing inputs and mode32 high banks are public Context, not
+			// initialized programs. All bound rows retain private LLVM objects.
+			ll := x86PackedPrecisionOriginalFormatObject(t, src.String(), "packeddoubletosingleforms",
+				target.goarch, target.triple, false, 25, 5)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-double-to-single-"+target.name+".ll", "packed-double-to-single-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedDoubleToSingleRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTPD2PS X0",
+		"CVTPD2PS Y0, X1",
+		"CVTPD2PS X0, (AX)",
+		"CVTPD2PS.Z X0, X1",
+		"VCVTPD2PSX Y0, X1",
+		"VCVTPD2PSX X0, Y1",
+		"VCVTPD2PSY X0, X1",
+		"VCVTPD2PSY Y0, Y1",
+		"VCVTPD2PS Z0, X1",
+		"VCVTPD2PS Y0, Y1",
+		"VCVTPD2PS Z0, Z1",
+		"VCVTPD2PSX X0, K0, X1",
+		"VCVTPD2PSY.Z Y0, X1",
+		"VCVTPD2PS.Z Z0, Y1",
+		"VCVTPD2PSX.BCST X0, X1",
+		"VCVTPD2PSY.BCST Y0, X1",
+		"VCVTPD2PS.BCST Z0, Y1",
+		"VCVTPD2PSX.RN_SAE X0, X1",
+		"VCVTPD2PSY.RD_SAE Y0, X1",
+		"VCVTPD2PS.RU_SAE (AX), Y1",
+		"VCVTPD2PS.SAE Z0, Y1",
+		"VCVTPD2PS.BCST.RN_SAE (AX), Y1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedDoubleToSingleRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+
+	for _, instruction := range []string{
+		"CVTPD2PS X8, X0",
+		"CVTPD2PS X0, X8",
+		"VCVTPD2PS Z8, Y0",
+		"VCVTPD2PS Z20, K1, Y0",
+	} {
+		assertX86PackedDoubleToSingleRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86PackedDoubleToSingleRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed double-to-single forms", instruction)
+	}
+}
diff --git a/amd64_lower_convert_samewidth.go b/amd64_lower_convert_samewidth.go
new file mode 100644
index 000000000..c333884c7
--- /dev/null
+++ b/amd64_lower_convert_samewidth.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64SameWidthConversionMode uint8
+
+const (
+	amd64SameWidthIntToFloat amd64SameWidthConversionMode = iota
+	amd64SameWidthFloatToInt
+	amd64SameWidthFloatToIntTruncate
+	amd64SameWidthSqrt
+)
+
+type amd64SameWidthConversionSpec struct {
+	laneBits int
+	mode     amd64SameWidthConversionMode
+	sae      bool
+	rawOnly  bool
+}
+
+var amd64SameWidthConversionSpecs = map[Op]amd64SameWidthConversionSpec{
+	"VCVTDQ2PS":  {laneBits: 32, mode: amd64SameWidthIntToFloat},
+	"VCVTPS2DQ":  {laneBits: 32, mode: amd64SameWidthFloatToInt},
+	"VCVTTPS2DQ": {laneBits: 32, mode: amd64SameWidthFloatToIntTruncate, sae: true},
+	"VSQRTPD":    {laneBits: 64, mode: amd64SameWidthSqrt},
+	"VSQRTPS":    {laneBits: 32, mode: amd64SameWidthSqrt},
+	"VSQRTPH":    {laneBits: 16, mode: amd64SameWidthSqrt, rawOnly: true},
+}
+
+// lowerSameWidthPackedConversion implements all five opcodes sharing Go
+// 1.27's _yvcvtdq2ps table. Although the table is shared, VCVTTPS2DQ enables
+// SAE while the other four opcodes enable explicit rounding on Z forms.
+func (c *amd64Ctx) lowerSameWidthPackedConversion(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, term, err := c.lowerSqrt(op, ins); known {
+		return known, term, err
+	}
+	if handled, terminated, err := c.lowerPackedNumericConversion(op, ins); handled {
+		return handled, terminated, err
+	}
+	if _, known, _ := x86SignedPackedFloatProperties(ins, c.goarch); known {
+		return c.lowerSignedPackedIntegerFloat(op, ins)
+	}
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64SameWidthConversionSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if spec.mode == amd64SameWidthIntToFloat {
+		return c.lowerSignedPackedIntegerFloat(op, ins)
+	}
+	if spec.rawOnly && !ins.x86Encoded {
+		return true, false, fmt.Errorf("%s is absent from Go's named assembler table; raw encoding required", baseOp)
+	}
+
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix {
+		return true, false, fmt.Errorf("%s %s suffix is absent from Go 1.27's _yvcvtdq2ps encodings: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.sae {
+		if properties.rounding != "" {
+			return true, false, fmt.Errorf("%s %s supports SAE, not explicit rounding: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if properties.sae {
+		return true, false, fmt.Errorf("%s %s supports explicit rounding, not SAE: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("%s %s expects source, [K mask,] destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == 3
+	if properties.zeroing && !masked {
+		return true, false, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if masked && !amd64NonzeroKOperand(ins.Args[1]) {
+		return true, false, fmt.Errorf("%s %s masked form expects K1-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s destination must be X, Y, or Z: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 || !c.isGoEVEXVectorRegister(destination, byteWidth) {
+		return true, false, fmt.Errorf("%s %s destination is outside Go 1.27's vector-register class: %q", c.goarch, baseOp, ins.Raw)
+	}
+	source := ins.Args[0]
+	explicitControl := properties.rounding != "" || properties.sae
+	if explicitControl && (byteWidth != 64 || source.Kind != OpReg) {
+		return true, false, fmt.Errorf("%s %s explicit rounding/SAE requires a Z register source: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(source) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a scalar memory source: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if source.Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(source, byteWidth) {
+			return true, false, fmt.Errorf("%s %s source must match the destination width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return true, false, fmt.Errorf("%s %s source must be a matching vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	lanes := byteWidth * 8 / spec.laneBits
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	sourceBits, err := c.loadMaskedPackedCompareLanes(source, byteWidth, spec.laneBits, properties.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	computedBits := c.emitSameWidthPackedConversion(spec, sourceBits, byteWidth, properties)
+	if masked {
+		oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		computedBits = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computedBits, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, computedBits, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitSameWidthPackedConversion(spec amd64SameWidthConversionSpec, sourceBits string, byteWidth int, properties amd64BinaryFloatingSuffix) string {
+	lanes := byteWidth * 8 / spec.laneBits
+	integerType := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	floatType := amd64FMA3LLVMType(lanes, spec.laneBits)
+	switch spec.mode {
+	case amd64SameWidthSqrt:
+		floating := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", floating, integerType, sourceBits, floatType)
+		computed := c.newTmp()
+		if properties.rounding != "" {
+			name := fmt.Sprintf("llvm.experimental.constrained.sqrt.v%df%d", lanes, spec.laneBits)
+			fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %%%s, metadata !\"%s\", metadata !\"fpexcept.ignore\")\n", computed, floatType, name, floatType, floating, amd64FMA3RoundingMetadata(properties.rounding))
+		} else {
+			name := fmt.Sprintf("llvm.sqrt.v%df%d", lanes, spec.laneBits)
+			fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %%%s)\n", computed, floatType, name, floatType, floating)
+		}
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", bits, floatType, computed, integerType)
+		return "%" + bits
+	}
+	panic("unreachable same-width packed conversion mode")
+}
diff --git a/amd64_lower_convert_samewidth_test.go b/amd64_lower_convert_samewidth_test.go
new file mode 100644
index 000000000..cf233a4e1
--- /dev/null
+++ b/amd64_lower_convert_samewidth_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86SameWidthPackedConversionCompleteGoAssemblerForms(t *testing.T) {
+	// These five opcodes share Go 1.27's _yvcvtdq2ps table. All accept X/Y/Z
+	// register or memory sources, scalar-memory broadcast, and K1-K7 masks.
+	// The Z forms of all but VCVTTPS2DQ accept explicit rounding; the
+	// truncating conversion accepts SAE instead.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			zLast := 21
+			if target.goarch == "386" {
+				zLast = 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT samewidthpackedconversionforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VCVTDQ2PS", "VCVTPS2DQ", "VCVTTPS2DQ", "VSQRTPD", "VSQRTPS"} {
+				high := 20
+				if strings.HasPrefix(op, "VCVT") && target.goarch == "386" {
+					// The exact native conversion cannot borrow the wider
+					// software bank used by the other conversion families.
+					high = 4
+				}
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&src, "\t%s %s0, %s1\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s (AX), %s2\n", op, width)
+					fmt.Fprintf(&src, "\t%s %s%d, %s%d\n", op, width, high, width, high+1)
+					fmt.Fprintf(&src, "\t%s %s%d, K1, %s%d\n", op, width, high, width, high+1)
+					fmt.Fprintf(&src, "\t%s.Z (AX), K2, %s%d\n", op, width, high+2)
+					fmt.Fprintf(&src, "\t%s.BCST 8(AX), %s%d\n", op, width, high+2)
+					fmt.Fprintf(&src, "\t%s.BCST.Z 8(AX), K3, %s%d\n", op, width, high+3)
+				}
+				fmt.Fprintf(&src, "\t%s Z0, Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s (AX), Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s Z6, K4, Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s.Z (AX), K5, Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s.BCST 8(AX), Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s.BCST.Z 8(AX), K6, Z%d\n", op, zLast)
+				if op == "VCVTTPS2DQ" {
+					fmt.Fprintf(&src, "\t%s.SAE Z6, Z%d\n", op, zLast)
+					fmt.Fprintf(&src, "\t%s.SAE.Z Z6, K7, Z%d\n", op, zLast)
+				} else {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						fmt.Fprintf(&src, "\t%s.%s Z6, Z%d\n", op, rounding, zLast)
+					}
+					fmt.Fprintf(&src, "\t%s.RN_SAE.Z Z6, K7, Z%d\n", op, zLast)
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			ll := x86SqrtOriginalFormatObjects(t, src.String(), "samewidthpackedconversionforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "same-width-packed-conversion-"+target.name+".ll", "same-width-packed-conversion-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86SameWidthPackedConversionRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VCVTDQ2PS X0",
+		"VCVTPS2DQ X0, Y1",
+		"VCVTTPS2DQ X0, (AX)",
+		"VSQRTPD X0, K0, X1",
+		"VSQRTPS.Z X0, X1",
+		"VCVTDQ2PS.BCST X0, X1",
+		"VCVTPS2DQ.SAE Z0, Z1",
+		"VCVTTPS2DQ.RN_SAE Z0, Z1",
+		"VSQRTPD.RN_SAE X0, X1",
+		"VSQRTPS.RN_SAE (AX), Z1",
+		"VCVTDQ2PS.BCST.RN_SAE (AX), Z1",
+		"VCVTTPS2DQ.BCST.SAE (AX), Z1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86SameWidthPackedConversionRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+
+	for _, instruction := range []string{
+		"VCVTDQ2PS Z8, Z0",
+		"VCVTPS2DQ Z0, Z8",
+		"VCVTTPS2DQ.SAE Z8, Z0",
+		"VSQRTPD.RN_SAE Z0, Z8",
+		"VSQRTPS Z0, K1, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86SameWidthPackedConversionRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86SameWidthPackedConversionRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's _yvcvtdq2ps forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_counter_zero_branch_test.go b/amd64_lower_counter_zero_branch_test.go
new file mode 100644
index 000000000..072056ca1
--- /dev/null
+++ b/amd64_lower_counter_zero_branch_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86CounterZeroBranchCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := "TEXT counterzerobranchforms(SB),NOSPLIT,$0-0\n" +
+				"\tJCXZW width16\n" +
+				"width16:\n" +
+				"\tJCXZL width32\n" +
+				"width32:\n" +
+				"\tJCXZQ width64\n" +
+				"width64:\n" +
+				"\tRET\n"
+			// Preserve the exact original source as a Go-format and missing-CX
+			// control; a bare register read does not establish its input bytes.
+			x86UnboundVoidFormatSources(t, source, target.goarch, target.triple)
+			move := "MOVQ"
+			if target.goarch == "386" {
+				move = "MOVL"
+			}
+			initialized := strings.Replace(source, "\tJCXZW", "\t"+move+" $1,CX\n\tJCXZW", 1)
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+initialized)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ll, err := x86ScalarFPBitViewAPI(t, initialized, "func counterzerobranchforms()", target.goarch, target.triple, api)
+				if err != nil {
+					t.Fatal("same original branches with actual numerical CX", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ll, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86CounterZeroBranchMatchesGoAssemblerAddressWidths(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+		widths map[string]string
+	}{
+		{
+			name: "amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu",
+			widths: map[string]string{"JCXZW": "i64", "JCXZL": "i32", "JCXZQ": "i64"},
+		},
+		{
+			name: "386", goarch: "386", triple: "i386-unknown-linux-gnu",
+			widths: map[string]string{"JCXZW": "i32", "JCXZL": "i16", "JCXZQ": "i32"},
+		},
+	} {
+		for op, width := range target.widths {
+			t.Run(target.name+"_"+op, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT counterzero(SB),NOSPLIT,$0-0\n\t%s zero\n\tRET\nzero:\n\tRET\n", op)
+				x86UnboundVoidFormatSources(t, source, target.goarch, target.triple)
+				move := "MOVQ"
+				if target.goarch == "386" {
+					move = "MOVL"
+				}
+				initialized := strings.Replace(source, "\t"+op, "\t"+move+" $1,CX\n\t"+op, 1)
+				for _, api := range []string{"text", "module", "Go"} {
+					ll, err := x86ScalarFPBitViewAPI(t, initialized, "func counterzero()", target.goarch, target.triple, api)
+					if err != nil {
+						t.Fatal("same original branch with actual numerical CX", api, err)
+					}
+					if !strings.Contains(ll, "icmp eq "+width) {
+						t.Fatalf("%s/%s/%s did not test Go's %s counter width:\n%s", target.goarch, op, api, width, ll)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86CounterZeroBranchRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"JCXZW",
+		"JCXZL $1, done",
+		"JCXZQ done, other",
+		"JCXZQ AX",
+		"JCXZQ.Z done",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),NOSPLIT,$0-0\n\t" + instruction + "\ndone:\nother:\n\tRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: "x86_64-unknown-linux-gnu",
+					Goarch:       "amd64",
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's yloop table", instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_crc32.go b/amd64_lower_crc32.go
index 054f910af..476eb80a2 100644
--- a/amd64_lower_crc32.go
+++ b/amd64_lower_crc32.go
@@ -3,69 +3,60 @@ package plan9asm
 import "fmt"
 
 func (c *amd64Ctx) lowerCrc32(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	switch op {
-	case "CRC32B", "CRC32W", "CRC32L", "CRC32Q":
-		// ok
-	default:
-		return false, false, nil
+	form, known, err := x86CRC32Properties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
 	}
-	if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg {
-		return true, false, fmt.Errorf("amd64 %s expects mem, reg: %q", op, ins.Raw)
+	if form.source.Kind == OpReg && (form.source.Reg == SP || form.source.Reg == BP) &&
+		form.source.Reg != ins.Args[0].Reg {
+		return true, false, fmt.Errorf("%w: Go CRC32 REX byte view needs its original physical SP/BP input", ErrProbeNeedsContext)
 	}
-	src := ins.Args[0].Mem
-	dst := ins.Args[1].Reg
-
-	addr, err := c.addrFromMem(src)
+	sourceType := amd64IntegerTypeForBits(form.bits)
+	intrinsic := fmt.Sprintf("llvm.x86.sse42.crc32.32.%d", form.bits)
+	resultType := I32
+	if form.bits == 64 {
+		resultType = I64
+		intrinsic = "llvm.x86.sse42.crc32.64.64"
+	}
+	sourceValue, err := c.evalCRC32Source(ins, form, sourceType)
 	if err != nil {
 		return true, false, err
 	}
-	p := c.ptrFromAddrI64(addr)
-
-	dv, err := c.loadReg(dst)
+	crcValue, err := c.evalIntSized(form.destination, I32)
 	if err != nil {
 		return true, false, err
 	}
+	if resultType == I64 {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", extended, crcValue)
+		crcValue = "%" + extended // Unknown old high32 never enter the intrinsic.
+	}
+	call := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s)\n", call, resultType, intrinsic, resultType, crcValue, sourceType, sourceValue)
+	return true, false, c.storeRegSized(form.destination.Reg, resultType, "%"+call)
+}
 
-	switch op {
-	case "CRC32Q":
-		ld := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.x86.sse42.crc32.64.64(i64 %s, i64 %%%s)\n", call, dv, ld)
-		return true, false, c.storeReg(dst, "%"+call)
-
-	case "CRC32L":
-		ld := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", ld, p)
-		crc32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", crc32, dv)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse42.crc32.32.32(i32 %%%s, i32 %%%s)\n", call, crc32, ld)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "CRC32W":
-		ld := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s, align 1\n", ld, p)
-		crc32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", crc32, dv)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse42.crc32.32.16(i32 %%%s, i16 %%%s)\n", call, crc32, ld)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-		return true, false, c.storeReg(dst, "%"+z)
-
-	case "CRC32B":
-		ld := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s, align 1\n", ld, p)
-		crc32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", crc32, dv)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse42.crc32.32.8(i32 %%%s, i8 %%%s)\n", call, crc32, ld)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-		return true, false, c.storeReg(dst, "%"+z)
+func (c *amd64Ctx) evalCRC32Source(ins Instr, form x86CRC32Form, typ LLVMType) (string, error) {
+	if form.source.Kind == OpFP && x86ResultNamedPredicateInstruction(ins) {
+		if value, handled, err := c.loadIntegerFPBytesMode(form.source.FPOffset, typ, true); handled || err != nil {
+			return value, err
+		}
+	}
+	if isAMD64MemoryOperand(form.source) && form.source.Kind != OpFP &&
+		(c.nativeMemoryOperand(ins, 0) ||
+			x86CallerMemoryCertified(ins, 0) || c.fixedLocalMemoryCertified(ins, 0)) {
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return "", fmt.Errorf("%w: CRC32 needs its original native address size", ErrProbeNeedsContext)
+		}
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		// Even a zero accumulator or dead result retains the complete native
+		// source read. No backing, extent or alignment follows from continuing.
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+		return "%" + value, nil
 	}
-	return true, false, fmt.Errorf("amd64: unknown CRC32 op %s", op)
+	return c.evalIntSized(form.source, typ)
 }
diff --git a/amd64_lower_crc32_complete_test.go b/amd64_lower_crc32_complete_test.go
new file mode 100644
index 000000000..90bae49cb
--- /dev/null
+++ b/amd64_lower_crc32_complete_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86CRC32CompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA crc32data+0(SB)/8, $1\n")
+	source.WriteString("GLOBL crc32data(SB), $8\n")
+	source.WriteString("TEXT crc32forms(SB),$0-0\n")
+	for _, width := range []string{"B", "W", "L"} {
+		op := "CRC32" + width
+		sourceRegister := "AX"
+		if width == "B" {
+			sourceRegister = "AL"
+		}
+		fmt.Fprintf(&source, "\t%s %s, BX\n", op, sourceRegister)
+		fmt.Fprintf(&source, "\t%s 8(BX), CX\n", op)
+		fmt.Fprintf(&source, "\t%s crc32data(SB), DX\n", op)
+		if width == "B" {
+			fmt.Fprintf(&source, "\t%s AX, DI\n", op)
+		}
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\t%s R11, R12\n", op)
+		} else {
+			fmt.Fprintf(&source, "\t%s %s, SP\n", op, sourceRegister)
+		}
+	}
+	if goarch == "amd64" {
+		for _, form := range []string{
+			"CRC32Q AX, BX",
+			"CRC32Q 8(BX), CX",
+			"CRC32Q crc32data(SB), DX",
+			"CRC32Q R11, R12",
+		} {
+			fmt.Fprintf(&source, "\t%s\n", form)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86CRC32CompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86CRC32CompleteFormsSource(target.goarch)
+			// Preserve the complete original mixed bank/memory source.
+			// Its unknown accumulators and physical SP cannot supply a public
+			// entry. Initialized public objects have their separate CRC32 owner.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "crc32forms", target.goarch, target.triple)
+			for _, want := range []string{
+				"@llvm.x86.sse42.crc32.32.8",
+				"@llvm.x86.sse42.crc32.32.16",
+				"@llvm.x86.sse42.crc32.32.32",
+				`"target-features"="+crc32,+sse4.2"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("CRC32 lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "@llvm.x86.sse42.crc32.64.64") {
+				t.Fatalf("CRC32Q lowering omitted i64 intrinsic:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "crc32-"+target.name+".ll", "crc32-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86CRC32RejectsFormsOutsideGo127Optabs(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "CRC32B $1, AX"},
+		{goarch: "amd64", instruction: "CRC32W AL, AX"},
+		{goarch: "amd64", instruction: "CRC32L X0, AX"},
+		{goarch: "amd64", instruction: "CRC32Q AX, 0(BX)"},
+		{goarch: "amd64", instruction: "CRC32L AX, X0"},
+		{goarch: "amd64", instruction: "CRC32L AX, AL"},
+		{goarch: "amd64", instruction: "CRC32L AX"},
+		{goarch: "amd64", instruction: "CRC32L.Z AX, BX"},
+		{goarch: "386", instruction: "CRC32Q AX, BX"},
+		{goarch: "386", instruction: "CRC32L R8, AX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ycrc32b/ycrc32l tables", test.instruction)
+			}
+		})
+	}
+}
+
+func x86CRC32RuntimeSemanticsSource() string {
+	return `TEXT crc32semantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+
+	MOVL $0x12345678, BX
+	MOVL $0xab00, AX
+	CRC32B AH, BX
+	MOVQ BX, 0(DI)
+
+	MOVL $0x23456789, BX
+	MOVL $0xcdef, AX
+	CRC32W AX, BX
+	MOVQ BX, 8(DI)
+
+	MOVL $0x3456789a, BX
+	MOVL $0x89abcdef, 40(DI)
+	CRC32L 40(DI), BX
+	MOVQ BX, 16(DI)
+
+	MOVL $0x456789ab, BX
+	MOVQ $0x0123456789abcdef, CX
+	MOVQ CX, 48(DI)
+	CRC32Q 48(DI), BX
+	MOVQ BX, 24(DI)
+
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVL $0, BX
+	CRC32B AL, BX
+	SETCS 32(DI)
+	SETOS 33(DI)
+	SETEQ 34(DI)
+	SETMI 35(DI)
+	RET
+`
+}
+
+func TestX86CRC32RuntimeFixtureUsesOriginalGoEncoding(t *testing.T) {
+	source := x86CRC32RuntimeSemanticsSource()
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+source, "", true)
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The original complete fixture includes CRC32Q, not a Go386 GP row.
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func crc32semantics(out *byte)", "amd64", target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete original CRC32 numerical/flags fixture rejected", err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc required")
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64CRC32RuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86CRC32RuntimeSemanticsSource()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"crc32semantics": {
+				Name:  "crc32semantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void crc32semantics(uint8_t *);
+static uint32_t crc32c(uint32_t crc, uint64_t value, unsigned bytes) {
+  for (unsigned i = 0; i < bytes; i++) {
+    crc ^= (uint8_t)value;
+    value >>= 8;
+    for (unsigned bit = 0; bit < 8; bit++)
+      crc = (crc >> 1) ^ (UINT32_C(0x82f63b78) & (uint32_t)-(int32_t)(crc & 1));
+  }
+  return crc;
+}
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[64] = {0};
+  crc32semantics(out);
+  if (load64(out + 0) != crc32c(UINT32_C(0x12345678), UINT64_C(0xab), 1)) return 10;
+  if (load64(out + 8) != crc32c(UINT32_C(0x23456789), UINT64_C(0xcdef), 2)) return 11;
+  if (load64(out + 16) != crc32c(UINT32_C(0x3456789a), UINT64_C(0x89abcdef), 4)) return 12;
+  if (load64(out + 24) != crc32c(UINT32_C(0x456789ab), UINT64_C(0x0123456789abcdef), 8)) return 13;
+  if (out[32] != 1 || out[33] != 1 || out[34] != 0 || out[35] != 1) return 14;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "crc32_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_descriptor.go b/amd64_lower_descriptor.go
new file mode 100644
index 000000000..5d8cf6f98
--- /dev/null
+++ b/amd64_lower_descriptor.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86DescriptorOps = map[string]struct{}{
+	"LGDT": {}, "LIDT": {}, "SGDT": {}, "SIDT": {},
+	"LLDT": {}, "LTR": {}, "LMSW": {},
+	"SLDTW": {}, "SLDTL": {}, "SLDTQ": {},
+	"SMSWW": {}, "SMSWL": {}, "SMSWQ": {},
+	"STRW": {}, "STRL": {}, "STRQ": {},
+}
+
+// lowerDescriptorTable covers Go 1.27's complete x86 descriptor-table and
+// system-selector family. These instructions are privileged or may be blocked
+// by UMIP, so the lowering preserves them as LLVM inline assembly rather than
+// approximating their machine-state effects.
+func (c *amd64Ctx) lowerDescriptorTable(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerSegmentQuery(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerFarPointer(op, ins); ok {
+		return ok, terminated, err
+	}
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	if _, ok := x86DescriptorOps[baseOp]; !ok {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 1 {
+		return true, false, fmt.Errorf("%s %s expects one operand: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && strings.HasSuffix(baseOp, "Q") {
+		return true, false, fmt.Errorf("386 %s is illegal in 32-bit mode: %q", baseOp, ins.Raw)
+	}
+
+	operand := ins.Args[0]
+	switch baseOp {
+	case "LGDT", "LIDT":
+		if !isAMD64MemoryOperand(operand) {
+			return true, false, fmt.Errorf("%s %s expects Go 1.27 Ym memory: %q", c.goarch, baseOp, ins.Raw)
+		}
+		ptr, ptrType, err := c.x86DescriptorMemoryPointer(operand)
+		if err != nil {
+			return true, false, err
+		}
+		bytes := 10
+		if c.goarch == "386" {
+			bytes = 6
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype([%d x i8]) %s)\n",
+			strings.ToLower(baseOp)+" $0", "*m,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, bytes, ptr)
+		return true, false, nil
+
+	case "SGDT", "SIDT":
+		if !isAMD64MemoryOperand(operand) {
+			return true, false, fmt.Errorf("%s %s expects Go 1.27 Ym memory: %q", c.goarch, baseOp, ins.Raw)
+		}
+		ptr, ptrType, err := c.x86DescriptorMemoryPointer(operand)
+		if err != nil {
+			return true, false, err
+		}
+		bytes := 10
+		if c.goarch == "386" {
+			bytes = 6
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype([%d x i8]) %s)\n",
+			strings.ToLower(baseOp)+" $0", "=*m,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, bytes, ptr)
+		return true, false, nil
+
+	case "LLDT", "LTR", "LMSW":
+		if operand.Kind != OpReg && !isAMD64MemoryOperand(operand) {
+			return true, false, fmt.Errorf("%s %s expects Go 1.27 Yml register or memory: %q", c.goarch, baseOp, ins.Raw)
+		}
+		if operand.Kind == OpReg {
+			if !isX86YrlRegisterForArch(operand.Reg, c.goarch) {
+				return true, false, fmt.Errorf("%s %s register is outside Go 1.27's Yml class: %q", c.goarch, baseOp, ins.Raw)
+			}
+			value, err := c.evalIntSized(operand, I16)
+			if err != nil {
+				return true, false, err
+			}
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i16 %s)\n",
+				strings.ToLower(baseOp)+" $0", "r,~{memory},~{dirflag},~{fpsr},~{flags}", value)
+			return true, false, nil
+		}
+		ptr, ptrType, err := c.x86DescriptorMemoryPointer(operand)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype(i16) %s)\n",
+			strings.ToLower(baseOp)+" $0", "*m,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, ptr)
+		return true, false, nil
+
+	case "SLDTW", "SLDTL", "SLDTQ", "SMSWW", "SMSWL", "SMSWQ", "STRW", "STRL", "STRQ":
+		return true, false, c.lowerDescriptorResult(baseOp, operand, ins)
+	default:
+		panic("descriptor opcode precheck drift")
+	}
+}
+
+func (c *amd64Ctx) lowerDescriptorResult(op string, destination Operand, ins Instr) error {
+	if destination.Kind != OpReg && !isAMD64MemoryOperand(destination) {
+		return fmt.Errorf("%s %s expects Go 1.27 Yml register or memory: %q", c.goarch, op, ins.Raw)
+	}
+	if destination.Kind == OpReg && !isX86YrlRegisterForArch(destination.Reg, c.goarch) {
+		return fmt.Errorf("%s %s register is outside Go 1.27's Yml class: %q", c.goarch, op, ins.Raw)
+	}
+	typ := I16
+	switch op[len(op)-1] {
+	case 'L':
+		typ = I32
+	case 'Q':
+		typ = I64
+	}
+	asm := strings.ToLower(op) + " $0"
+	if destination.Kind == OpReg {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n",
+			result, typ, asm, "=r,~{memory},~{dirflag},~{fpsr},~{flags}")
+		return c.storeRegSized(destination.Reg, typ, "%"+result)
+	}
+	ptr, ptrType, err := c.x86DescriptorMemoryPointer(destination)
+	if err != nil {
+		return err
+	}
+	// Intel defines every memory destination as m16 even when Go selects the
+	// L/Q spelling (the operand-size prefix only affects a register target).
+	// LLVM's integrated assembler consequently rejects sldtl/sldtq, smswl/q,
+	// and strl/q with memory, so emit the architectural unsuffixed m16 form.
+	memoryAsm := strings.ToLower(op[:len(op)-1]) + " $0"
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype(%s) %s)\n",
+		memoryAsm, "=*m,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, I16, ptr)
+	return nil
+}
+
+func (c *amd64Ctx) x86DescriptorMemoryPointer(operand Operand) (ptr, ptrType string, err error) {
+	switch operand.Kind {
+	case OpMem:
+		return c.ptrFromMem(operand.Mem)
+	case OpSym:
+		ptr, err := c.ptrFromSB(operand.Sym)
+		return ptr, "ptr", err
+	case OpFP:
+		if c.classicFrame != "" {
+			return c.classicFramePtr(operand.FPOffset), "ptr", nil
+		}
+		if ptr := c.fpParamAlloca[operand.FPOffset]; ptr != "" {
+			return ptr, "ptr", nil
+		}
+		if ptr, _, ok := c.fpResultAlloca(operand.FPOffset); ok {
+			return ptr, "ptr", nil
+		}
+		return "", "", fmt.Errorf("%s descriptor memory operand has no mutable FP slot at +%d(FP)", c.goarch, operand.FPOffset)
+	default:
+		return "", "", fmt.Errorf("%s descriptor instruction expected memory, got %s", c.goarch, operand.String())
+	}
+}
diff --git a/amd64_lower_dot_float.go b/amd64_lower_dot_float.go
new file mode 100644
index 000000000..84f5172e2
--- /dev/null
+++ b/amd64_lower_dot_float.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+type amd64PackedFloatingDotForm uint8
+
+const (
+	// amd64PackedFloatingDotLegacy is Go's yxshuf table: imm8, X/m128, X.
+	amd64PackedFloatingDotLegacy amd64PackedFloatingDotForm = iota
+	// amd64PackedFloatingDotVEX128 is Go's _yvdppd table: imm8, X/m128,
+	// X, X. The Go 386 frontend cannot represent the four operands.
+	amd64PackedFloatingDotVEX128
+	// amd64PackedFloatingDotVEX128Or256 is Go's _yvblendpd table, adding
+	// the corresponding Y/m256, Y, Y row.
+	amd64PackedFloatingDotVEX128Or256
+)
+
+type amd64PackedFloatingDotSpec struct {
+	form     amd64PackedFloatingDotForm
+	laneBits int
+}
+
+// amd64PackedFloatingDotSpecs is the complete Go 1.27 grammar for the SSE4.1
+// and AVX floating dot-product family. The form class captures operand count,
+// legal vector widths, and the 386 frontend restriction; laneBits selects the
+// hardware intrinsic and immediate-bit interpretation.
+var amd64PackedFloatingDotSpecs = map[Op]amd64PackedFloatingDotSpec{
+	"DPPD":  {form: amd64PackedFloatingDotLegacy, laneBits: 64},
+	"DPPS":  {form: amd64PackedFloatingDotLegacy, laneBits: 32},
+	"VDPPD": {form: amd64PackedFloatingDotVEX128, laneBits: 64},
+	"VDPPS": {form: amd64PackedFloatingDotVEX128Or256, laneBits: 32},
+}
+
+func (c *amd64Ctx) lowerPackedFloatingDot(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerNativePackedReduction(op, ins)
+}
diff --git a/amd64_lower_dot_float_test.go b/amd64_lower_dot_float_test.go
new file mode 100644
index 000000000..130ca6719
--- /dev/null
+++ b/amd64_lower_dot_float_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedFloatingDotGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64PackedFloatingDotSpec{
+		"DPPD":  {form: amd64PackedFloatingDotLegacy, laneBits: 64},
+		"DPPS":  {form: amd64PackedFloatingDotLegacy, laneBits: 32},
+		"VDPPD": {form: amd64PackedFloatingDotVEX128, laneBits: 64},
+		"VDPPS": {form: amd64PackedFloatingDotVEX128Or256, laneBits: 32},
+	}
+	if len(amd64PackedFloatingDotSpecs) != len(expected) {
+		t.Fatalf("floating dot grammar has %d entries, want %d", len(amd64PackedFloatingDotSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64PackedFloatingDotSpecs[op]; !ok {
+			t.Errorf("floating dot grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("floating dot grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86PackedFloatingDotCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			var sourceBuilder strings.Builder
+			sourceBuilder.WriteString("TEXT floatdotforms(SB),$0-0\n")
+			fmt.Fprintf(&sourceBuilder, "\tDPPD $0x31, X0, X%d\n", last)
+			fmt.Fprintf(&sourceBuilder, "\tDPPD $0x31, 0(AX), X%d\n", last)
+			fmt.Fprintf(&sourceBuilder, "\tDPPS $0xf1, X0, X%d\n", last)
+			fmt.Fprintf(&sourceBuilder, "\tDPPS $0xf1, 16(AX), X%d\n", last)
+			if target.goarch == "amd64" {
+				fmt.Fprintf(&sourceBuilder, "\tVDPPD $0x31, X0, X1, X%d\n", last)
+				fmt.Fprintf(&sourceBuilder, "\tVDPPD $0x31, 32(AX), X1, X%d\n", last)
+				fmt.Fprintf(&sourceBuilder, "\tVDPPS $0xf1, X0, X1, X%d\n", last)
+				fmt.Fprintf(&sourceBuilder, "\tVDPPS $0xf1, 48(AX), X1, X%d\n", last)
+				fmt.Fprintf(&sourceBuilder, "\tVDPPS $0xf1, Y0, Y1, Y%d\n", last)
+				fmt.Fprintf(&sourceBuilder, "\tVDPPS $0xf1, 64(AX), Y1, Y%d\n", last)
+			}
+			sourceBuilder.WriteString("\tRET\n")
+			source := sourceBuilder.String()
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "floatdotforms", target.goarch, target.triple)
+			for _, want := range []string{
+				"dppd ", "dpps ", "asm sideeffect", "~{fpsr}",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("packed floating dot lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" && (!strings.Contains(ir, "call <8 x float> asm sideeffect") || !strings.Contains(ir, "vdpps ")) {
+				t.Fatalf("packed floating dot lowering omitted Y-width original opcode:\n%s", ir)
+			}
+			wantFeatures := `"target-features"="+sse4.1"`
+			if target.goarch == "amd64" {
+				wantFeatures = `"target-features"="+avx,+sse4.1"`
+			}
+			if !strings.Contains(ir, wantFeatures) {
+				t.Fatalf("packed floating dot lowering omitted %s:\n%s", wantFeatures, ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "float-dot-"+target.name+".ll", "float-dot-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedFloatingDotRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "DPPD $-1, X0, X1"},
+		{goarch: "amd64", instruction: "DPPD $256, X0, X1"},
+		{goarch: "amd64", instruction: "DPPS.Z $1, X0, X1"},
+		{goarch: "amd64", instruction: "DPPD $1, Y0, Y1"},
+		{goarch: "amd64", instruction: "VDPPD $1, Y0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VDPPS $1, Z0, Z1, Z2"},
+		{goarch: "amd64", instruction: "VDPPS $1, X0, Y1, Y2"},
+		{goarch: "386", instruction: "DPPD $1, X0, X8"},
+		{goarch: "386", instruction: "VDPPS $1, Y0, Y1, Y2"},
+		{goarch: "386", instruction: "VDPPS $1, Y0, Y1, Y8"},
+		{goarch: "386", instruction: "VDPPS $1, 8(R9), Y1, Y2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside the Go table for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestAMD64PackedFloatingDotRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT floatdotsemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), CX
+	MOVQ b+16(FP), DX
+	MOVUPS 0(CX), X0
+	MOVUPS 0(DX), X1
+	STC
+	DPPS $0xf1, X0, X1
+	MOVUPS X1, 0(AX)
+	SETCS 16(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"floatdotsemantics": {
+				Name: "floatdotsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void floatdotsemantics(uint8_t *, const float *, const float *);
+int main(void) {
+  uint8_t out[17] = {0};
+  const float a[4] = {1.0f, 2.0f, 3.0f, 4.0f};
+  const float b[4] = {5.0f, 6.0f, 7.0f, 8.0f};
+  float got[4];
+  floatdotsemantics(out, a, b);
+  memcpy(got, out, 16);
+  if (got[0] != 70.0f || got[1] != 0.0f || got[2] != 0.0f || got[3] != 0.0f) return 10;
+  if (out[16] != 1) return 11;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_float_dot_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_dot_product.go b/amd64_lower_dot_product.go
new file mode 100644
index 000000000..619151280
--- /dev/null
+++ b/amd64_lower_dot_product.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedDotProductSpec struct {
+	inputBits int
+	opcode    byte
+	saturate  bool
+	bfloat    bool
+}
+
+var amd64PackedDotProductSpecs = map[Op]amd64PackedDotProductSpec{
+	"VPDPBUSD":  {inputBits: 8, opcode: 0x50},
+	"VPDPBUSDS": {inputBits: 8, opcode: 0x51, saturate: true},
+	"VPDPWSSD":  {inputBits: 16, opcode: 0x52},
+	"VPDPWSSDS": {inputBits: 16, opcode: 0x53, saturate: true},
+	"VDPBF16PS": {inputBits: 16, bfloat: true},
+}
+
+// lowerPackedDotProduct implements the four VNNI dot-product opcodes sharing
+// Go 1.27's _yvblendmpd table. Plan 9 lists the signed r/m source first and
+// the encoded V source second; VPDPBUSD treats that second source as unsigned.
+func (c *amd64Ctx) lowerPackedDotProduct(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64PackedDotProductSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if !spec.bfloat {
+		return c.lowerIntegerPackedDotProduct(op, ins)
+	}
+	if spec.bfloat && !ins.x86Encoded {
+		return true, false, fmt.Errorf("%s has no named Go encoder form; raw encoding required", baseOp)
+	}
+
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix || properties.sae || properties.rounding != "" {
+		return true, false, fmt.Errorf("%s %s suffix is absent from Go 1.27's _yvblendmpd encodings: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("%s %s expects source2, source1, [K mask,] accumulator: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == 4
+	if c.goarch == "386" && masked && !ins.x86Encoded {
+		return true, false, fmt.Errorf("386 %s mask forms exceed the Go assembler frontend's three-operand limit: %q", baseOp, ins.Raw)
+	}
+	if properties.zeroing && !masked {
+		return true, false, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if masked && !amd64NonzeroKOperand(ins.Args[2]) {
+		return true, false, fmt.Errorf("amd64 %s masked form expects K1-K7 as its third operand: %q", baseOp, ins.Raw)
+	}
+
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s accumulator must be X, Y, or Z: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 ||
+		!c.isGoPackedVectorMoveRegister(destination, byteWidth) ||
+		!c.isGoPackedVectorMoveRegister(ins.Args[1], byteWidth) {
+		return true, false, fmt.Errorf("%s %s source1 and accumulator must be matching Go vector registers: %q", c.goarch, baseOp, ins.Raw)
+	}
+	rmSource := ins.Args[0]
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(rmSource) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a scalar memory source2: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if rmSource.Kind == OpReg {
+		if !c.isGoPackedVectorMoveRegister(rmSource, byteWidth) {
+			return true, false, fmt.Errorf("%s %s source2 register must match the accumulator width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(rmSource) {
+		return true, false, fmt.Errorf("%s %s source2 must be a matching vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	dwordLanes := byteWidth / 4
+	inputLanes := byteWidth * 8 / spec.inputBits
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[2].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	// One mask bit controls a complete output dword and its input pair/group.
+	rmDwords, err := c.loadMaskedPackedCompareLanes(rmSource, byteWidth, 32, properties.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	rmValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x i%d>\n", rmValue, dwordLanes, rmDwords, inputLanes, spec.inputBits)
+	vBytes, err := c.loadPackedCompareBytes(ins.Args[1], byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	rm := "%" + rmValue
+	v := c.bitcastVectorBytesToIntegerLanes(byteWidth, inputLanes, spec.inputBits, vBytes)
+	old := c.bitcastVectorBytesToIntegerLanes(byteWidth, dwordLanes, 32, oldBytes)
+	computed := c.emitPackedDotProduct(spec, dwordLanes, rm, v, old)
+	if masked {
+		computed = amd64ApplyI32LaneMask(c, dwordLanes, computed, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x i8>\n", out, dwordLanes, computed, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+// LLVM's dedicated intrinsic preserves the instruction's RNE, DAZ/FTZ and
+// NaN-priority semantics independently of MXCSR. Generic fmul/fadd cannot.
+func (c *amd64Ctx) emitBF16DotProduct(lanes int, rm, v, accumulator string) string {
+	left, right, old := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x bfloat>\n", left, lanes*2, v, lanes*2)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x bfloat>\n", right, lanes*2, rm, lanes*2)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x float>\n", old, lanes, accumulator, lanes)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x float> @llvm.x86.avx512bf16.dpbf16ps.%d(<%d x float> %%%s, <%d x bfloat> %%%s, <%d x bfloat> %%%s)\n",
+		result, lanes, lanes*32, lanes, old, lanes*2, left, lanes*2, right)
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x float> %%%s to <%d x i32>\n", bits, lanes, result, lanes)
+	return "%" + bits
+}
+
+func (c *amd64Ctx) emitPackedDotProduct(spec amd64PackedDotProductSpec, dwordLanes int, rm, v, accumulator string) string {
+	if spec.bfloat {
+		return c.emitBF16DotProduct(dwordLanes, rm, v, accumulator)
+	}
+	inputsPerDword := 32 / spec.inputBits
+	result := "poison"
+	for lane := 0; lane < dwordLanes; lane++ {
+		accumulatorLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i32> %s, i32 %d\n", accumulatorLane, dwordLanes, accumulator, lane)
+		wideAccumulator := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext i32 %%%s to i64\n", wideAccumulator, accumulatorLane)
+		total := "%" + wideAccumulator
+		for item := 0; item < inputsPerDword; item++ {
+			inputLane := lane*inputsPerDword + item
+			rmLane := c.newTmp()
+			vLane := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", rmLane, dwordLanes*inputsPerDword, spec.inputBits, rm, inputLane)
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", vLane, dwordLanes*inputsPerDword, spec.inputBits, v, inputLane)
+			wideRM := c.newTmp()
+			wideV := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext i%d %%%s to i64\n", wideRM, spec.inputBits, rmLane)
+			if spec.inputBits == 8 {
+				fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", wideV, vLane)
+			} else {
+				fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i64\n", wideV, vLane)
+			}
+			product := c.newTmp()
+			next := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", product, wideRM, wideV)
+			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", next, total, product)
+			total = "%" + next
+		}
+		if spec.saturate {
+			above := c.newTmp()
+			below := c.newTmp()
+			capped := c.newTmp()
+			bounded := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp sgt i64 %s, 2147483647\n", above, total)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 2147483647, i64 %s\n", capped, above, total)
+			fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %%%s, -2147483648\n", below, capped)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 -2147483648, i64 %%%s\n", bounded, below, capped)
+			total = "%" + bounded
+		}
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, total)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i32> %s, i32 %%%s, i32 %d\n", inserted, dwordLanes, result, narrow, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_dot_product_test.go b/amd64_lower_dot_product_test.go
new file mode 100644
index 000000000..230fe5b93
--- /dev/null
+++ b/amd64_lower_dot_product_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedDotProductCompleteGoAssemblerForms(t *testing.T) {
+	// These four opcodes share Go 1.27's six-row _yvblendmpd table. Each
+	// width accepts register/memory source 2, register source 1, and an
+	// accumulator destination; amd64 additionally accepts K1-K7 merge/.Z.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			zLast := 22
+			if target.goarch == "386" {
+				zLast = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packeddotproductforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VPDPBUSD", "VPDPBUSDS", "VPDPWSSD", "VPDPWSSDS"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s20, %s21\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s.BCST 12(AX), %s20, %s22\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", op, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z 8(AX), %s21, K7, %s22\n", op, width, width)
+						fmt.Fprintf(&source, "\t%s.BCST.Z 12(AX), %s21, K2, %s22\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s.BCST 12(AX), Z6, Z%d\n", op, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s Z20, Z21, K3, Z22\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z21, K4, Z22\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST.Z 12(AX), Z21, K5, Z22\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			// The original complete source has no data, accumulator, mask
+			// or pointer inputs. Preserve its Go and private emitter objects
+			// plus all three public Context controls; initialized public
+			// counterparts have separate complete-family owners.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "packeddotproductforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-dot-product-"+target.name+".ll", "packed-dot-product-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedDotProductRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPDPBUSD X0, X1",
+		"VPDPBUSDS X0, X1, (AX)",
+		"VPDPWSSD X0, Y1, X2",
+		"VPDPWSSDS Z0, Z1, Y2",
+		"VPDPBUSD X0, X1, K0, X2",
+		"VPDPBUSD X0, K1, X1, X2",
+		"VPDPBUSD.Z X0, X1, X2",
+		"VPDPBUSDS.SAE X0, X1, X2",
+		"VPDPWSSD.BCST X0, X1, X2",
+		"VPDPWSSDS.BCST 8(AX), Y1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedDotProductRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VPDPBUSD Z8, Z0, Z1",
+		"VPDPBUSDS Z0, Z8, Z1",
+		"VPDPWSSD Z0, Z1, Z8",
+		"VPDPWSSDS X0, X1, K1, X2",
+		"VPDPBUSD.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedDotProductRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedDotProductRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's _yvblendmpd forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_duplicate.go b/amd64_lower_duplicate.go
new file mode 100644
index 000000000..d51cc3902
--- /dev/null
+++ b/amd64_lower_duplicate.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerDuplicateMove(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86DuplicateMoveProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ins.Op = op
+	return true, false, c.emitDuplicateMove(ins, form)
+}
+
+func (c *amd64Ctx) emitDuplicateMove(ins Instr, form x86DuplicateMoveForm) error {
+	destination := ins.Args[form.destination]
+	if form.legacy && form.spec.laneBytes == 4 && form.memory >= 0 {
+		if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+			form.source.Kind == OpFP || form.source.Kind == OpMem &&
+			!c.nativeMemoryOperand(ins, form.memory) &&
+			!x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			return fmt.Errorf("%w: legacy duplicate m128 needs its original native alignment and storage", ErrProbeNeedsContext)
+		}
+		return c.emitLegacyDuplicateMemory(ins.Op, form, destination)
+	}
+	laneBits := form.spec.laneBytes * 8
+	lanes, sourceBytes := form.byteWidth/form.spec.laneBytes, form.byteWidth
+	if form.memory >= 0 {
+		sourceBytes = form.memoryBytes
+	}
+	bytes, err := c.loadDuplicateMoveSource(form)
+	if err != nil {
+		return err
+	}
+	cast := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i%d>\n", cast, sourceBytes, bytes,
+		sourceBytes/form.spec.laneBytes, laneBits)
+	// X-width m64 DDUP's source has one lane; every other source is full
+	// width. Register and memory forms share exactly the same lane selector.
+	indices := make([]int, lanes)
+	for lane := range indices {
+		indices[lane] = form.sourceByte(lane*form.spec.laneBytes) / form.spec.laneBytes
+	}
+	shuffle := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %%%s, <%d x i%d> poison, <%d x i32> %s\n",
+		shuffle, sourceBytes/form.spec.laneBytes, laneBits, cast,
+		sourceBytes/form.spec.laneBytes, laneBits, lanes, llvmI32Mask(indices))
+	result := "%" + shuffle
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, laneBits, false)
+			if err != nil {
+				return err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, laneBits, result, form.byteWidth)
+	if form.legacy {
+		return c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) loadDuplicateMoveSource(form x86DuplicateMoveForm) (string, error) {
+	if form.source.Kind == OpReg {
+		return c.loadPackedCompareBytes(form.source, form.byteWidth)
+	}
+	if form.source.Kind == OpFP {
+		return c.loadFPVectorBytes(form.source.FPOffset, form.memoryBytes)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	// E4NF.nb and E5NF retain the complete access even for a dead result or
+	// zero mask. No alignment or initialized-pointee assumption is introduced.
+	fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, %s %s, align 1\n", value, form.memoryBytes, pointerType, pointer)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) emitLegacyDuplicateMemory(op Op, form x86DuplicateMoveForm, destination Operand) error {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	loaded, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s %s)\n", loaded,
+		strings.ToLower(string(op))+" "+segment+"($1), $0", "=x,r,~{memory}", pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, loaded)
+	return c.storeLegacyPackedLogical(destination, "%"+bytes)
+}
+
+func llvmI32Mask(indices []int) string {
+	var b strings.Builder
+	b.WriteByte('<')
+	for i, index := range indices {
+		if i != 0 {
+			b.WriteString(", ")
+		}
+		fmt.Fprintf(&b, "i32 %d", index)
+	}
+	b.WriteByte('>')
+	return b.String()
+}
diff --git a/amd64_lower_enqueue.go b/amd64_lower_enqueue.go
new file mode 100644
index 000000000..8e1c839f3
--- /dev/null
+++ b/amd64_lower_enqueue.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86EnqueueOps = map[string]byte{
+	"ENQCMD":  0xf2,
+	"ENQCMDS": 0xf3,
+}
+
+// Keep the 64-byte device enqueue operation in hardware. An ordinary memory
+// copy cannot implement PASID handling, atomic submission, or retry status.
+func (c *amd64Ctx) lowerEnqueue(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86EnqueueProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	source := form.source
+	assemblySource := "$1"
+	if source.Kind == OpMem && source.Mem.Segment != "" {
+		switch source.Mem.Segment {
+		case FS, GS:
+			// LLVM inline-asm memory operands do not preserve the pointer's
+			// segment address space. Spell the prefix explicitly and pass
+			// its offset, not an ordinary unsegmented effective address.
+			assemblySource = "%" + strings.ToLower(string(source.Mem.Segment)) + ":$1"
+			source.Mem.Segment = ""
+		default:
+			return true, false, fmt.Errorf("unsupported enqueue source segment %s", source.Mem.Segment)
+		}
+	}
+	ptr, ptrType, err := c.x86DescriptorMemoryPointer(source)
+	if err != nil {
+		return true, false, err
+	}
+	wordType := amd64IntegerTypeForBits(form.wordBits)
+	destination, err := c.evalIntSized(form.destination, wordType)
+	if err != nil {
+		return true, false, err
+	}
+	if bits := form.addressBits; bits != form.wordBits {
+		// Truncate the effective offset before hardware applies any explicit
+		// source-segment override.
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint %s %s to i%d\n", address, ptrType, ptr, bits)
+		wrapped := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i%d %%%s to %s\n", wrapped, bits, address, ptrType)
+		ptr = "%" + wrapped
+		low, extended := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to i%d\n", low, wordType, destination, bits)
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to %s\n", extended, bits, low, wordType)
+		destination = "%" + extended
+	}
+
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i8 asm sideeffect %q, %q(%s elementtype([64 x i8]) %s, %s %s)\n",
+		status, form.native+" "+assemblySource+", $2; sete $0",
+		"=q,*m,r,~{memory},~{dirflag},~{fpsr},~{flags}", ptrType, ptr, wordType, destination)
+	c.storeSegmentQueryZF("%" + status)
+	c.clearX86StatusFlags(x86StatusAll &^ x86StatusZF)
+	return true, false, nil
+}
diff --git a/amd64_lower_exchange.go b/amd64_lower_exchange.go
new file mode 100644
index 000000000..61e07bd26
--- /dev/null
+++ b/amd64_lower_exchange.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ExchangeKind uint8
+
+const (
+	amd64ExchangeSwap amd64ExchangeKind = iota
+	amd64ExchangeAdd
+)
+
+type amd64ExchangeSpec struct {
+	kind amd64ExchangeKind
+	bits int
+}
+
+// The complete Go yrb_mb/yrl_ml (XADD) and yml_mb/yxchg (XCHG) families.
+// Width selects register classes; kind selects operand symmetry and flags.
+var amd64ExchangeSpecs = map[Op]amd64ExchangeSpec{
+	"XADDB": {amd64ExchangeAdd, 8},
+	"XADDW": {amd64ExchangeAdd, 16},
+	"XADDL": {amd64ExchangeAdd, 32},
+	"XADDQ": {amd64ExchangeAdd, 64},
+	"XCHGB": {amd64ExchangeSwap, 8},
+	"XCHGW": {amd64ExchangeSwap, 16},
+	"XCHGL": {amd64ExchangeSwap, 32},
+	"XCHGQ": {amd64ExchangeSwap, 64},
+}
+
+type amd64ExchangeForm struct {
+	register Operand
+	other    Operand
+	nop      bool
+}
+
+// The swap consumers use the same complete Go grammar as the emitter. Width
+// and operand symmetry come from the existing exchange family, not a second
+// opcode directory in each provenance or byte observer.
+func x86SwapProperties(ins Instr, arch string) (amd64ExchangeForm, int64, bool, error) {
+	name := strings.ToUpper(string(ins.Op))
+	base, _, _ := strings.Cut(name, ".")
+	spec, known := amd64ExchangeSpecs[Op(base)]
+	if !known || spec.kind != amd64ExchangeSwap {
+		return amd64ExchangeForm{}, 0, false, nil
+	}
+	form, err := parseAMD64ExchangeForm(arch, Op(name), spec, ins)
+	return form, int64(spec.bits / 8), true, err
+}
+
+func parseAMD64ExchangeForm(goarch string, op Op, spec amd64ExchangeSpec, ins Instr) (amd64ExchangeForm, error) {
+	invalid := func(reason string) (amd64ExchangeForm, error) {
+		return amd64ExchangeForm{}, fmt.Errorf("%s %s %s: %q", goarch, op, reason, ins.Raw)
+	}
+	if strings.Contains(string(op), ".") {
+		return invalid("does not accept instruction suffixes")
+	}
+	if registered, ok := amd64ExchangeSpecs[op]; !ok || registered != spec ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return invalid("does not have its registered source identity and width")
+	}
+	if goarch != "amd64" && goarch != "386" {
+		return invalid("requires a registered x86 mode")
+	}
+	if goarch == "386" && spec.bits == 64 {
+		return invalid("is illegal in 32-bit mode")
+	}
+	if len(ins.Args) != 2 {
+		return invalid("expects two operands")
+	}
+	first, second := ins.Args[0], ins.Args[1]
+	if spec.kind == amd64ExchangeSwap && isAMD64MemoryOperand(first) {
+		first, second = second, first
+	}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, second, goarch); segment {
+		if err != nil {
+			return amd64ExchangeForm{}, err
+		}
+		second = projected
+	}
+	registerAllowed := func(reg Reg) bool {
+		if spec.bits == 8 {
+			return isGoYmbRegisterForArch(reg, goarch)
+		}
+		return isX86YrlRegisterForArch(reg, goarch)
+	}
+	if first.Kind != OpReg || !registerAllowed(first.Reg) {
+		return invalid("requires a source in Go's byte/general-register class")
+	}
+	if second.Kind == OpReg {
+		if !registerAllowed(second.Reg) {
+			return invalid("destination is outside Go's byte/general-register class")
+		}
+	} else if !isAMD64MemoryOperand(second) {
+		return invalid("expects a register or memory destination")
+	} else if second.Kind == OpMem && !x86MemoryRegistersValidForArch(second.Mem, goarch) {
+		return invalid("uses an out-of-range address register")
+	}
+	form := amd64ExchangeForm{register: first, other: second}
+	if goarch == "amd64" && spec.bits == 8 && x86CompareExchangeHasREXByteView(x86CompareExchangeForm{
+		source: first, destination: second,
+	}) {
+		for _, operand := range []Operand{first, second} {
+			if operand.Kind == OpReg && (operand.Reg == AH || operand.Reg == CH || operand.Reg == DH || operand.Reg == BH) {
+				return amd64ExchangeForm{}, fmt.Errorf("%w: %s %s Go's REX encoding changes a high-byte spelling to an unbound low-byte physical view: %q", ErrProbeNeedsContext, goarch, op, ins.Raw)
+			}
+		}
+	}
+	if spec.kind == amd64ExchangeSwap {
+		// Go's accumulator/accumulator W/L/Q rows emit opcode 90 (with
+		// their width prefix), a NOP. In particular, EAX/EAX does not clear
+		// the upper RAX bytes as a genuine ModRM r32 exchange would.
+		form.nop = spec.bits != 8 && first.Kind == OpReg && second.Kind == OpReg && first.Reg == AX && second.Reg == AX
+	}
+	return form, nil
+}
+
+func (c *amd64Ctx) lowerExchange(op Op, spec amd64ExchangeSpec, ins Instr) (bool, bool, error) {
+	form, err := parseAMD64ExchangeForm(c.goarch, op, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	if form.nop {
+		return true, false, nil
+	}
+	typ := amd64IntegerTypeForBits(spec.bits)
+	value, err := c.evalIntSized(form.register, typ)
+	if err != nil {
+		return true, false, err
+	}
+	var old string
+	if form.other.Kind == OpReg {
+		old, err = c.evalIntSized(form.other, typ)
+	} else {
+		old, err = c.emitExchangeMemory(spec, form.other, value)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	result := value
+	if spec.kind == amd64ExchangeAdd {
+		sum := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", sum, typ, old, value)
+		result = "%" + sum
+	}
+	// Read both operands before writeback. Source-first order preserves identical
+	// register XADD and overlapping AH/AL exchanges, including partial writes.
+	if err := c.storeRegSized(form.register.Reg, typ, old); err != nil {
+		return true, false, err
+	}
+	if form.other.Kind == OpReg {
+		if err := c.storeRegSized(form.other.Reg, typ, result); err != nil {
+			return true, false, err
+		}
+	}
+	if spec.kind == amd64ExchangeAdd {
+		c.setScalarAddSubFlags(typ, true, old, value, result)
+	}
+	return true, false, nil
+}
+
+func (c *amd64Ctx) emitExchangeMemory(spec amd64ExchangeSpec, memory Operand, value string) (string, error) {
+	ptr, ptrType, err := c.compareExchangePointer(memory)
+	if err != nil {
+		return "", err
+	}
+	typ := amd64IntegerTypeForBits(spec.bits)
+	width := map[int]string{8: "b", 16: "w", 32: "l", 64: "q"}[spec.bits]
+	mnemonic := "xchg" + width // A memory XCHG is implicitly locked.
+	if spec.kind == amd64ExchangeAdd {
+		mnemonic = "xadd" + width
+		if c.namedAtomicLock {
+			mnemonic = "lock; " + mnemonic
+		}
+	}
+	registerClass := "r"
+	if spec.bits == 8 {
+		registerClass = "q"
+	}
+	segment := ""
+	if memory.Kind == OpMem && memory.Mem.Segment != "" {
+		// LLVM's inline-asm memory operand does not print the address space's
+		// FS/GS override; preserve it explicitly in the instruction template.
+		segment = "%" + strings.ToLower(string(memory.Mem.Segment)) + ":"
+	}
+	// Native x86 exchanges support unaligned memory. LLVM atomicrmw align 1
+	// can introduce libatomic calls, while claiming natural alignment is false.
+	// Explicit read/write memory constraints and the tied register model the
+	// native operation without imposing an alignment precondition. Keep memory
+	// clobbering for synchronization and preserve segment-relative pointer types.
+	old := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect \"%s $0, %s$1\", \"=%s,=*m,0,*m,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s elementtype(%s) %s, %s %s, %s elementtype(%s) %s)\n",
+		old, typ, mnemonic, segment, registerClass, ptrType, typ, ptr, typ, value, ptrType, typ, ptr)
+	return "%" + old, nil
+}
diff --git a/amd64_lower_expand.go b/amd64_lower_expand.go
new file mode 100644
index 000000000..70c9743ec
--- /dev/null
+++ b/amd64_lower_expand.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64PackedExpandSpec struct {
+	laneBits int
+}
+
+// amd64PackedExpandSpecs is the complete Go 1.27 _yvexpandpd grammar for the
+// packed floating-point and integer expand families. None of these optabs has
+// an EVEX broadcast attribute.
+var amd64PackedExpandSpecs = map[Op]amd64PackedExpandSpec{
+	"VEXPANDPD": {laneBits: 64},
+	"VEXPANDPS": {laneBits: 32},
+	"VPEXPANDB": {laneBits: 8},
+	"VPEXPANDW": {laneBits: 16},
+	"VPEXPANDD": {laneBits: 32},
+	"VPEXPANDQ": {laneBits: 64},
+}
+
+// lowerPackedExpand implements all six _yvexpandpd rows for every instruction
+// above: X/Y/Z register or memory sources and the corresponding K1-K7 merge or
+// .Z forms. Logical FP fields are reconstructed independently; only native
+// memory uses a pointer to the compact source array.
+func (c *amd64Ctx) lowerPackedExpand(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86PackedCompactProperties(op, ins, c.goarch)
+	if !known || !form.expand {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.memory >= 0 && c.nativeMemoryOperand(ins, form.memory) {
+		return true, false, c.lowerNativeCompactMemory(ins, form)
+	}
+	byteWidth, laneBits := form.byteWidth, form.laneBits
+	source, destination := ins.Args[0], ins.Args[form.destination]
+	if form.mask < 0 {
+		sourceBytes, err := c.loadPackedCompareBytes(source, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storePackedMoveOperand(destination, byteWidth, sourceBytes)
+	}
+
+	mask, err := c.loadK(ins.Args[form.mask].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / laneBits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	maskVector := amd64IntegerMaskVector(c, lanes, mask)
+	passthrough := "zeroinitializer"
+	if !form.zeroing {
+		oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		passthrough = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, oldBytes)
+	}
+
+	result := ""
+	if isAMD64MemoryOperand(source) && source.Kind != OpFP {
+		pointer, pointerType, intrinsicSuffix, err := c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return true, false, err
+		}
+		expanded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.masked.expandload.v%di%d%s(%s %s, <%d x i1> %s, %s %s)\n",
+			expanded, vectorType, lanes, laneBits, intrinsicSuffix, pointerType, pointer, lanes, maskVector, vectorType, passthrough)
+		result = "%" + expanded
+	} else {
+		sourceBytes, err := c.loadPackedCompareBytes(source, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		sourceLanes := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, sourceBytes)
+		result = c.expandPackedRegisterLanes(lanes, laneBits, sourceLanes, passthrough, mask, maskVector)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, vectorType, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+// expandPackedRegisterLanes is the register-source inverse of vector
+// compression. For destination lane i, the compact source index is the number
+// of set mask bits below i. Building each lane from the original source before
+// the final store keeps source/destination aliasing safe.
+func (c *amd64Ctx) expandPackedRegisterLanes(lanes, laneBits int, source, passthrough, mask, maskVector string) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	result := passthrough
+	for lane := 0; lane < lanes; lane++ {
+		active := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i1> %s, i32 %d\n", active, lanes, maskVector, lane)
+		sourceIndex := "0"
+		if lane != 0 {
+			below := c.newTmp()
+			count := c.newTmp()
+			index := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", below, mask, (uint64(1)<<lane)-1)
+			fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.ctpop.i64(i64 %%%s)\n", count, below)
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", index, count)
+			sourceIndex = "%" + index
+		}
+		sourceLane := c.newTmp()
+		oldLane := c.newTmp()
+		selected := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %s\n", sourceLane, vectorType, source, sourceIndex)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", oldLane, vectorType, result, lane)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", selected, active, laneBits, sourceLane, laneBits, oldLane)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n", inserted, vectorType, result, laneBits, selected, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_expand_test.go b/amd64_lower_expand_test.go
new file mode 100644
index 000000000..a66f7bd1a
--- /dev/null
+++ b/amd64_lower_expand_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedExpandGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64PackedExpandSpec{
+		"VEXPANDPD": {laneBits: 64},
+		"VEXPANDPS": {laneBits: 32},
+		"VPEXPANDB": {laneBits: 8},
+		"VPEXPANDW": {laneBits: 16},
+		"VPEXPANDD": {laneBits: 32},
+		"VPEXPANDQ": {laneBits: 64},
+	}
+	if len(amd64PackedExpandSpecs) != len(expected) {
+		t.Fatalf("packed-expand grammar has %d entries, want %d", len(amd64PackedExpandSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64PackedExpandSpecs[op]; !ok {
+			t.Errorf("packed-expand grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("packed-expand grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86PackedExpandCompleteGoFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedexpandforms(SB),$0-0\n")
+			for _, op := range []string{"VEXPANDPD", "VEXPANDPS", "VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					sourceReg, destinationReg := 29, 31
+					if target.goarch == "386" && width == "Z" {
+						sourceReg, destinationReg = 6, 7
+					}
+					fmt.Fprintf(&source, "\t%s %s%d, %s%d\n", op, width, sourceReg, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s 8(R9), %s%d\n", op, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s %s%d, K1, %s%d\n", op, width, sourceReg, width, destinationReg)
+					fmt.Fprintf(&source, "\t%s.Z 16(R9), K7, %s%d\n", op, width, destinationReg)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"packedexpandforms": {Name: "packedexpandforms", Ret: Void}},
+			}
+			for _, api := range []string{"text", "module", "owned-module"} {
+				if ir, err := x86X87UnboundOriginalAPI(t, file, options, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("original format-only source acquired undefined vector/mask/address inputs", api, err)
+				}
+			}
+			ir := x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "PackedExpandEmitterObjectUnit",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerVec(instruction.Op, instruction)
+				})
+			for _, want := range []string{"@llvm.masked.expandload.v", "extractelement", "select i1"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("packed-expand lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-expand-"+target.name+".ll", "packed-expand-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedExpandRejectsFormsOutsideGoTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPEXPANDB X0, Y1"},
+		{goarch: "amd64", instruction: "VPEXPANDW Y0, Z1"},
+		{goarch: "amd64", instruction: "VPEXPANDD X0, K0, X1"},
+		{goarch: "amd64", instruction: "VPEXPANDQ.Z X0, X1"},
+		{goarch: "amd64", instruction: "VEXPANDPS.BCST 0(AX), X1"},
+		{goarch: "amd64", instruction: "VEXPANDPD.SAE X0, X1"},
+		{goarch: "amd64", instruction: "VPEXPANDB X0, 0(AX)"},
+		{goarch: "amd64", instruction: "VPEXPANDW AX, X1"},
+		{goarch: "amd64", instruction: "VPEXPANDD X0, K1, K2, X1"},
+		{goarch: "386", instruction: "VPEXPANDB Z8, Z0"},
+		{goarch: "386", instruction: "VEXPANDPD Z0, K1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvexpandpd table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64PackedExpandRuntimeSemantics(t *testing.T) {
+	// Portable LLVM execution, not an original-Go/native AVX512 certificate.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT packedexpandsemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VPEXPANDB Z0, K1, Z1
+	VMOVDQU64 Z1, 0(AX)
+	VMOVDQU64 0(CX), Z1
+	VPEXPANDW.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 64(AX)
+	VMOVDQU64 0(CX), Z1
+	VPEXPANDD 0(BX), K1, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VMOVDQU64 0(CX), Z1
+	VPEXPANDQ.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 192(AX)
+	VMOVDQU64 0(CX), Z1
+	VEXPANDPS Z0, K1, Z1
+	VMOVDQU64 Z1, 256(AX)
+	VMOVDQU64 0(CX), Z1
+	VEXPANDPD.Z 0(BX), K1, Z1
+	VMOVDQU64 Z1, 320(AX)
+	VMOVDQU64 0(BX), Z1
+	VPEXPANDD Z1, K1, Z1
+	VMOVDQU64 Z1, 384(AX)
+	MOVQ null+32(FP), DX
+	XORQ R8, R8
+	KMOVQ R8, K2
+	VMOVDQU64 0(CX), Z1
+	STC
+	VPEXPANDB 0(DX), K2, Z1
+	VMOVDQU64 Z1, 448(AX)
+	SETCS CL
+	MOVB CL,512(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"packedexpandsemantics": {
+			Name: "packedexpandsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void packedexpandsemantics(uint8_t *, const uint8_t *, const uint8_t *, uint64_t, const uint8_t *);
+static int check(const uint8_t *got, const uint8_t *source, const uint8_t *old,
+                 int lane_bytes, uint64_t mask, int zeroing) {
+  int lanes = 64 / lane_bytes, packed = 0;
+  for (int lane = 0; lane < lanes; lane++) {
+    const uint8_t *want = zeroing ? (const uint8_t[8]){0} : old + lane*lane_bytes;
+    if ((mask >> lane) & 1) want = source + packed++*lane_bytes;
+    if (memcmp(got + lane*lane_bytes, want, lane_bytes)) return 10 + lane;
+  }
+  return 0;
+}
+int main(void) {
+  uint8_t source[64], old[64], out[513];
+  const uint64_t mask = UINT64_C(0xa55aa55aa55aa55a);
+  for (int i = 0; i < 64; i++) { source[i] = (uint8_t)(i*37 + 9); old[i] = (uint8_t)(0xe0 - i); }
+  memset(out, 0xcc, sizeof(out));
+  packedexpandsemantics(out, source, old, mask, 0);
+  int r;
+  if ((r = check(out+0, source, old, 1, mask, 0))) return 100+r;
+  if ((r = check(out+64, source, old, 2, mask, 1))) return 200+r;
+  if ((r = check(out+128, source, old, 4, mask, 0))) return 300+r;
+  if ((r = check(out+192, source, old, 8, mask, 1))) return 400+r;
+  if ((r = check(out+256, source, old, 4, mask, 0))) return 500+r;
+  if ((r = check(out+320, source, old, 8, mask, 1))) return 600+r;
+  if ((r = check(out+384, source, source, 4, mask, 0))) return 700+r;
+  if (memcmp(out+448, old, 64)) return 800;
+  if (out[512] != 1) return 801;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_expand_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_explicit_mask_move.go b/amd64_lower_explicit_mask_move.go
new file mode 100644
index 000000000..9397d3850
--- /dev/null
+++ b/amd64_lower_explicit_mask_move.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerExplicitMaskMove(op Op, ins Instr) (bool, bool, error) {
+	f, known, err := x86ExplicitMaskMoveProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := x86Mode32VectorRegisterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		!x86ResultNamedPredicateInstruction(ins) && !x86RawExplicitMaskMoveSource(ins, c.goarch) &&
+			ins.x86NumericalRead == nil && ins.x86SDKLiteral == nil {
+		return true, false, fmt.Errorf("%w: explicit mask move needs its exact physical source", ErrProbeNeedsContext)
+	}
+	if ins.Args[f.memory].Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(ins.Args[f.memory].FPOffset, f.byteWidth); err != nil {
+			return true, false, err
+		}
+	} else if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) &&
+		(c.nativeMemoryOperand(ins, f.memory) ||
+			x86CallerMemoryCertified(ins, f.memory) || c.fixedLocalMemoryCertified(ins, f.memory)) {
+		return true, false, c.lowerNativeExplicitMaskMove(op, ins, f)
+	}
+	return true, false, c.lowerPortableExplicitMaskMove(ins, f)
+}
+
+// Type 6 masks suppress only the corresponding lane's memory faults. Preserve
+// the whole original VEX operation even with a dead output. The pointer stays
+// opaque: no alignment, extent, initialization or pointee promise is asserted.
+// Intel SDM Vol.2C, VMASKMOV/VPMASKMOV: no SIMD FP exceptions and no AC#.
+// https://cdrdv2-public.intel.com/835757/325383-sdm-vol-2abcd.pdf
+func (c *amd64Ctx) lowerNativeExplicitMaskMove(op Op, ins Instr, f x86ExplicitMaskMoveForm) error {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(ins.Args[f.memory])
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	typ := fmt.Sprintf("<%d x float>", f.byteWidth/4) // Bit carrier, not FP arithmetic.
+	vector := func(operand Operand) (string, error) {
+		bytes, err := c.loadPackedCompareBytes(operand, f.byteWidth)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, f.byteWidth, bytes, typ)
+		return "%" + value, nil
+	}
+	mask, err := vector(ins.Args[1])
+	if err != nil {
+		return err
+	}
+	mnemonic := strings.ToLower(string(op))
+	if !f.load {
+		data, err := vector(ins.Args[0])
+		if err != nil {
+			return err
+		}
+		assembly := mnemonic + " $0, $1, " + segment + "($2)"
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s, %s %s, %s %s)\n",
+			assembly, "x,x,r,~{memory}", typ, data, typ, mask, pointerType, pointer)
+		return nil
+	}
+	loaded, bytes := c.newTmp(), c.newTmp()
+	assembly := mnemonic + " " + segment + "($2), $1, $0"
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s)\n",
+		loaded, typ, assembly, "=x,x,r,~{memory}", typ, mask, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, loaded, f.byteWidth)
+	return c.storePackedMoveOperand(ins.Args[2], f.byteWidth, "%"+bytes)
+}
+
+// The other-target/value-field path has guarded volatile lane accesses. This
+// is portable access/value evidence, not execution of the original x86 opcode.
+// An inactive lane must not even eagerly read the old memory contents.
+func (c *amd64Ctx) lowerPortableExplicitMaskMove(ins Instr, f x86ExplicitMaskMoveForm) error {
+	bits, width := f.spec.laneBits, f.byteWidth
+	lanes := width * 8 / bits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, bits)
+	mask, err := c.loadPackedCompareLanes(ins.Args[1], width, bits, false)
+	if err != nil {
+		return err
+	}
+	value := "zeroinitializer"
+	if !f.load {
+		value, err = c.loadPackedCompareLanes(ins.Args[0], width, bits, false)
+		if err != nil {
+			return err
+		}
+	}
+	memory := ins.Args[f.memory]
+	pointer, pointerType := "", ""
+	if memory.Kind != OpFP {
+		pointer, pointerType, _, err = c.packedVectorMemoryPointer(memory)
+		if err != nil {
+			return err
+		}
+	}
+	for lane := 0; lane < lanes; lane++ {
+		element, active := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", element, vectorType, mask, lane)
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %%%s, 0\n", active, bits, element)
+		field := memory
+		address := ""
+		if memory.Kind == OpFP {
+			field.FPOffset += int64(lane * bits / 8)
+		} else {
+			address = c.newTmp()
+			// No inbounds: masked-off null and page-boundary lanes need no allocation.
+			fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %d\n", address, pointerType, pointer, lane*bits/8)
+		}
+		if f.load {
+			loaded, err := c.loadX86ScalarIf(bits, "%"+active, func() (string, error) {
+				loaded := c.newTmp()
+				if memory.Kind == OpFP {
+					bytes, err := c.loadX86PackedShiftBytes(field, bits/8, true)
+					if err != nil {
+						return "", err
+					}
+					fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", loaded, bits/8, bytes, bits)
+				} else {
+					fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %%%s, align 1\n", loaded, bits, pointerType, address)
+				}
+				return "%" + loaded, nil
+			})
+			if err != nil {
+				return err
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, value, bits, loaded, lane)
+			value = "%" + inserted
+			continue
+		}
+		data, store, join := c.newTmp(), c.newTmp()+"_mask_store", c.newTmp()+"_mask_join"
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", data, vectorType, value, lane)
+		fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n%s:\n", active, store, join, store)
+		if memory.Kind == OpFP {
+			bytes := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i%d %%%s to <%d x i8>\n", bytes, bits, data, bits/8)
+			if err := c.storeVectorBytesOperand(field, bits/8, "%"+bytes); err != nil {
+				return err
+			}
+		} else {
+			fmt.Fprintf(c.b, "  store volatile i%d %%%s, %s %%%s, align 1\n", bits, data, pointerType, address)
+		}
+		fmt.Fprintf(c.b, "  br label %%%s\n%s:\n", join, join)
+	}
+	if !f.load {
+		return nil
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, vectorType, value, width)
+	return c.storePackedMoveOperand(ins.Args[2], width, "%"+bytes)
+}
diff --git a/amd64_lower_explicit_mask_move_test.go b/amd64_lower_explicit_mask_move_test.go
new file mode 100644
index 000000000..ff689bad7
--- /dev/null
+++ b/amd64_lower_explicit_mask_move_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64ExplicitMaskMoveGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64ExplicitMaskMoveSpec{
+		"VMASKMOVPS": {laneBits: 32},
+		"VMASKMOVPD": {laneBits: 64},
+		"VPMASKMOVD": {laneBits: 32},
+		"VPMASKMOVQ": {laneBits: 64},
+	}
+	if len(amd64ExplicitMaskMoveSpecs) != len(expected) {
+		t.Fatalf("explicit-mask-move grammar has %d entries, want %d", len(amd64ExplicitMaskMoveSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64ExplicitMaskMoveSpecs[op]; !ok {
+			t.Errorf("explicit-mask-move grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("explicit-mask-move grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86ExplicitMaskMoveCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT explicitmaskmoveforms(SB),$0-0\n")
+			for _, op := range []string{"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ"} {
+				for _, width := range []string{"X", "Y"} {
+					last := 15
+					fmt.Fprintf(&source, "\t%s 8(AX), %s1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s %s%d, %s1, 16(AX)\n", op, width, last, width)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures := map[string]FuncSig{"explicitmaskmoveforms": {Name: "explicitmaskmoveforms", Ret: Void}}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: signatures,
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound original formats acquired mask/data/address inputs", err)
+			}
+			if target.goarch == "386" {
+				// Keep every original accepted high-bank named row. Its mode32
+				// physical-bank boundary is not an object success; independently
+				// initialized low-bank owners cover all sixteen rows on both
+				// 386 targets without changing this original source.
+				for _, ins := range file.Funcs[0].Instrs {
+					if _, known, _ := x86ExplicitMaskMoveProperties(ins.Op, ins, target.goarch); known &&
+						!errors.Is(x86Mode32VectorRegisterContext(ins, target.goarch), ErrProbeNeedsContext) {
+						t.Fatal("original accepted high-bank named row lost its physical mode32 boundary")
+					}
+				}
+				return
+			}
+			// Direct units preserve every original format and exact native
+			// opcode, but supply neither public input nor execution evidence.
+			ir = x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			for _, op := range []string{"vmaskmovps ", "vmaskmovpd ", "vpmaskmovd ", "vpmaskmovq "} {
+				if !strings.Contains(ir, op) || !strings.Contains(ir, "asm sideeffect") {
+					t.Fatal("original direct format unit lost its complete Type6 native opcode", op)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "explicit-mask-move-"+target.name+".ll", "explicit-mask-move-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ExplicitMaskMoveRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPMASKMOVD (AX), X0"},
+		{goarch: "amd64", instruction: "VPMASKMOVD X0, X1, X2"},
+		{goarch: "amd64", instruction: "VPMASKMOVD (AX), X0, (BX)"},
+		{goarch: "amd64", instruction: "VPMASKMOVD X0, (AX), X1"},
+		{goarch: "amd64", instruction: "VPMASKMOVD (AX), X0, Y1"},
+		{goarch: "amd64", instruction: "VPMASKMOVD (AX), Z0, Z1"},
+		{goarch: "amd64", instruction: "VPMASKMOVD.Z (AX), X0, X1"},
+		{goarch: "amd64", instruction: "VMASKMOVPD (AX), X0, AX"},
+		{goarch: "386", instruction: "VPMASKMOVQ (AX), X16, X0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's explicit-mask-move table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64ExplicitMaskMoveRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT explicitmaskmovesemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ loadmem+8(FP), BX
+	MOVQ data+16(FP), CX
+	MOVQ mask+24(FP), DX
+	MOVQ storemem+32(FP), R8
+	VMOVDQU 0(CX), Y0
+	VMOVDQU 0(DX), Y1
+	STC
+	VPMASKMOVD 0(BX), Y1, Y2
+	VMOVDQU Y2, 0(AX)
+	VPMASKMOVD Y0, Y1, 0(R8)
+	VPMASKMOVQ 0(BX), Y1, Y3
+	VMOVDQU Y3, 32(AX)
+	VPMASKMOVQ Y0, Y1, 32(R8)
+	VMASKMOVPS 0(BX), Y1, Y4
+	VMOVDQU Y4, 64(AX)
+	VMASKMOVPS Y0, Y1, 64(R8)
+	VMASKMOVPD 0(BX), Y1, Y5
+	VMOVDQU Y5, 96(AX)
+	VMASKMOVPD Y0, Y1, 96(R8)
+	SETCS 128(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"explicitmaskmovesemantics": {
+			Name: "explicitmaskmovesemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void explicitmaskmovesemantics(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint8_t *);
+static uint32_t u32(const uint8_t *p) { uint32_t v; memcpy(&v,p,4); return v; }
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  uint32_t load32[8], data32[8], mask32[8];
+  uint8_t out[129]={0}, store[128];
+  for (int i=0;i<8;i++) {
+    load32[i]=UINT32_C(0x10203040)+(uint32_t)i;
+    data32[i]=UINT32_C(0xa0b0c000)+(uint32_t)i;
+    mask32[i]=(i==1||i==2||i==5)?UINT32_C(0x80000000):UINT32_C(0x7fffffff);
+  }
+  memset(store,0x5a,sizeof(store));
+  explicitmaskmovesemantics(out,(uint8_t*)load32,(uint8_t*)data32,(uint8_t*)mask32,store);
+  for (int i=0;i<8;i++) {
+    int enabled=(int32_t)mask32[i]<0;
+    if (u32(out+4*i)!=(enabled?load32[i]:0)) return 10;
+    if (u32(store+4*i)!=(enabled?data32[i]:UINT32_C(0x5a5a5a5a))) return 11;
+    if (u32(out+64+4*i)!=(enabled?load32[i]:0)) return 12;
+    if (u32(store+64+4*i)!=(enabled?data32[i]:UINT32_C(0x5a5a5a5a))) return 13;
+  }
+  for (int i=0;i<4;i++) {
+    int enabled=(int64_t)u64((uint8_t*)mask32+8*i)<0;
+    if (u64(out+32+8*i)!=(enabled?u64((uint8_t*)load32+8*i):0)) return 20;
+    if (u64(store+32+8*i)!=(enabled?u64((uint8_t*)data32+8*i):UINT64_C(0x5a5a5a5a5a5a5a5a))) return 21;
+    if (u64(out+96+8*i)!=(enabled?u64((uint8_t*)load32+8*i):0)) return 22;
+    if (u64(store+96+8*i)!=(enabled?u64((uint8_t*)data32+8*i):UINT64_C(0x5a5a5a5a5a5a5a5a))) return 23;
+  }
+  if (out[128]!=1) return 30;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "explicit_mask_move_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_extract.go b/amd64_lower_extract.go
new file mode 100644
index 000000000..e48dae899
--- /dev/null
+++ b/amd64_lower_extract.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import "fmt"
+
+// lowerVectorLaneExtract implements all Go 1.27 forms in _yvextractf128,
+// _yvextractf32x4, and _yvextractf32x8 for their F/I lane-extract mnemonics.
+func (c *amd64Ctx) lowerVectorLaneExtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerInsertExtractFamily(op, ins)
+}
+
+func (c *amd64Ctx) storeVectorBytesOperand(dst Operand, byteWidth int, value string) error {
+	return c.storeVectorBytesOperandWithMetadata(dst, byteWidth, value, "")
+}
+
+func (c *amd64Ctx) storeVectorBytesOperandWithMetadata(dst Operand, byteWidth int, value, metadata string) error {
+	if dst.Kind == OpReg {
+		if metadata != "" {
+			return fmt.Errorf("vector register destination cannot carry store metadata: %s", dst.String())
+		}
+		if !amd64VectorRegisterHasWidth(dst, byteWidth) {
+			return fmt.Errorf("expected %d-byte vector register, got %s", byteWidth, dst.String())
+		}
+		return c.storeVectorBytes(dst.Reg, byteWidth, value)
+	}
+	switch dst.Kind {
+	case OpMem:
+		addr, err := c.addrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <%d x i8> %s, ptr %s, align 1%s\n", byteWidth, value, c.ptrFromAddrI64(addr), metadata)
+		return nil
+	case OpSym:
+		p, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <%d x i8> %s, ptr %s, align 1%s\n", byteWidth, value, p, metadata)
+		return nil
+	case OpFP:
+		return c.storeFPVectorBytes(dst.FPOffset, byteWidth, value, metadata)
+	default:
+		return fmt.Errorf("expected vector register or memory destination, got %s", dst.String())
+	}
+}
diff --git a/amd64_lower_extract_scalar.go b/amd64_lower_extract_scalar.go
new file mode 100644
index 000000000..af7d9471d
--- /dev/null
+++ b/amd64_lower_extract_scalar.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedScalarExtractSpec struct {
+	bits         int
+	vector       bool
+	maxImmediate int64
+	allowMMX     bool
+}
+
+var amd64PackedScalarExtractSpecs = map[Op]amd64PackedScalarExtractSpec{
+	"EXTRACTPS":  {bits: 32, maxImmediate: 3},
+	"VEXTRACTPS": {bits: 32, vector: true, maxImmediate: 255},
+	"PEXTRB":     {bits: 8, maxImmediate: 255, allowMMX: true},
+	"PEXTRW":     {bits: 16, maxImmediate: 255},
+	"PEXTRD":     {bits: 32, maxImmediate: 255, allowMMX: true},
+	"PEXTRQ":     {bits: 64, maxImmediate: 255, allowMMX: true},
+	"VPEXTRB":    {bits: 8, vector: true, maxImmediate: 255},
+	"VPEXTRW":    {bits: 16, vector: true, maxImmediate: 255},
+	"VPEXTRD":    {bits: 32, vector: true, maxImmediate: 255},
+	"VPEXTRQ":    {bits: 64, vector: true, maxImmediate: 255},
+}
+
+func (c *amd64Ctx) lowerPackedScalarExtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64PackedScalarExtractSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	var f x86ScalarLaneForm
+	if base == "EXTRACTPS" || base == "VEXTRACTPS" {
+		var ps x86InsertExtractForm
+		ins, ps, _, err = c.bindInsertExtractForm(op, ins)
+		f = x86ScalarLaneForm{bits: 32, gpBits: 32, source: ps.source, destination: ps.destination, offset: ps.offset, memory: ps.memory}
+		if len(ins.Args) == 3 && ins.Args[2].Kind == OpReg {
+			f.transferReg = ins.Args[2].Reg
+		}
+	} else {
+		ins, f, _, err = c.bindScalarLaneForm(op, ins)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	destination := ins.Args[f.destination]
+	if (base == "EXTRACTPS" || base == "VEXTRACTPS") && destination.Kind == OpFP {
+		// Complete destination fields never initialize unknown source lanes.
+		// Check before emitting any IR, including the source-register load.
+		if _, err := c.scalarFPSpan(destination.FPOffset, 32); err != nil {
+			return true, false, err
+		}
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return true, false, err
+		}
+	}
+
+	source, err := c.loadX(ins.Args[f.source].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / f.bits
+	laneVector, extracted := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x i%d>\n", laneVector, source, lanes, f.bits)
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %%%s, i32 %d\n", extracted, lanes, f.bits, laneVector, f.offset/(f.bits/8))
+	value := "%" + extracted
+	if destination.Kind == OpReg {
+		destination.Reg = f.transferReg
+		if f.gpBits > f.bits {
+			widened := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i%d\n", widened, f.bits, value, f.gpBits)
+			value = "%" + widened
+		} else if f.gpBits < f.bits {
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i%d %s to i%d\n", truncated, f.bits, value, f.gpBits)
+			value = "%" + truncated
+		}
+		return true, false, c.storeRegSized(destination.Reg, amd64IntegerTypeForBits(f.gpBits), value)
+	}
+	if (base == "EXTRACTPS" || base == "VEXTRACTPS") && destination.Kind == OpFP {
+		// Parameter copies and result fields share the existing logical byte
+		// writer. Neither source syntax nor a complete destination makes an
+		// unknown selected X lane initialized, or a pointer/padding numeric.
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to <4 x i8>\n", bytes, value)
+		return true, false, c.storeFPVectorBytes(destination.FPOffset, 4, "%"+bytes, "")
+	}
+	return true, false, c.storePackedScalarExtractMemory(destination, amd64IntegerTypeForBits(f.bits), value)
+}
+
+func amd64MMXEncodingGP(index int) Reg {
+	return [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI}[index]
+}
+
+func (c *amd64Ctx) storePackedScalarExtractMemory(destination Operand, typ LLVMType, value string) error {
+	bits := map[LLVMType]int{I8: 8, I16: 16, I32: 32, I64: 64}[typ]
+	if destination.Kind == OpFP {
+		return c.storeScalarLaneFPBits(destination.FPOffset, bits, value)
+	}
+	return c.storeVMOVIntegerScalar(destination, bits, value)
+}
diff --git a/amd64_lower_far_pointer.go b/amd64_lower_far_pointer.go
new file mode 100644
index 000000000..95b71a520
--- /dev/null
+++ b/amd64_lower_far_pointer.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FarPointerSpec struct {
+	segment Reg
+	bits    int
+}
+
+// amd64FarPointerSpecs is the complete Go 1.27 LFS/LGS/LSS grammar. Segment
+// selection and offset width are data; memory shape, destination class, and
+// architecture availability are parsed once for all nine opcodes.
+var amd64FarPointerSpecs = map[Op]amd64FarPointerSpec{
+	"LFSW": {segment: FS, bits: 16},
+	"LFSL": {segment: FS, bits: 32},
+	"LFSQ": {segment: FS, bits: 64},
+	"LGSW": {segment: GS, bits: 16},
+	"LGSL": {segment: GS, bits: 32},
+	"LGSQ": {segment: GS, bits: 64},
+	"LSSW": {segment: SS, bits: 16},
+	"LSSL": {segment: SS, bits: 32},
+	"LSSQ": {segment: SS, bits: 64},
+}
+
+type amd64FarPointerForm struct {
+	memory      Operand
+	destination Reg
+}
+
+func (c *amd64Ctx) lowerFarPointer(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64FarPointerSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.bits == 64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	form, err := c.parseFarPointerForm(baseOp, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitFarPointer(spec, form)
+}
+
+func (c *amd64Ctx) parseFarPointerForm(op string, ins Instr) (amd64FarPointerForm, error) {
+	var form amd64FarPointerForm
+	if len(ins.Args) != 2 {
+		return form, fmt.Errorf("%s %s expects far-pointer memory and GP destination: %q", c.goarch, op, ins.Raw)
+	}
+	memory, destination := ins.Args[0], ins.Args[1]
+	if !isAMD64MemoryOperand(memory) {
+		return form, fmt.Errorf("%s %s source must be Go 1.27 Ym memory: %q", c.goarch, op, ins.Raw)
+	}
+	if memory.Kind == OpMem && !x86MemoryRegistersValidForArch(memory.Mem, c.goarch) {
+		return form, fmt.Errorf("%s %s source address uses an out-of-range register: %q", c.goarch, op, ins.Raw)
+	}
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, c.goarch) {
+		return form, fmt.Errorf("%s %s destination must be a Go 1.27 Yrl register: %q", c.goarch, op, ins.Raw)
+	}
+	return amd64FarPointerForm{memory: memory, destination: destination.Reg}, nil
+}
+
+func (c *amd64Ctx) emitFarPointer(spec amd64FarPointerSpec, form amd64FarPointerForm) (bool, bool, error) {
+	pointer, pointerType, err := c.x86DescriptorMemoryPointer(form.memory)
+	if err != nil {
+		return true, false, err
+	}
+	typ := amd64IntegerTypeForBits(spec.bits)
+	memoryBytes := spec.bits/8 + 2
+	width := map[int]string{16: "w", 32: "l", 64: "q"}[spec.bits]
+	result := c.newTmp()
+	assembly := "l" + strings.ToLower(string(spec.segment)) + width + " $1, $0"
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s elementtype([%d x i8]) %s)\n",
+		result, typ, assembly, "=r,*m,~{memory},~{dirflag},~{fpsr},~{flags}", pointerType, memoryBytes, pointer)
+	if err := c.storeRegSized(form.destination, typ, "%"+result); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
diff --git a/amd64_lower_far_pointer_test.go b/amd64_lower_far_pointer_test.go
new file mode 100644
index 000000000..45e8b3f64
--- /dev/null
+++ b/amd64_lower_far_pointer_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FarPointerGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64FarPointerSpecs))
+	for op := range amd64FarPointerSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{"LFSL", "LFSQ", "LFSW", "LGSL", "LGSQ", "LGSW", "LSSL", "LSSQ", "LSSW"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("far-pointer grammar opcodes = %v, want %v", got, want)
+	}
+}
+
+func TestTranslateX86FarPointerCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			destination := "DI"
+			base := "BX"
+			if target.goarch == "amd64" {
+				destination = "R12"
+				base = "R13"
+			}
+			source := "TEXT farpointerforms(SB),$0-0\n"
+			for _, family := range []string{"LFS", "LGS", "LSS"} {
+				source += "\t" + family + "W 0(BX), AX\n"
+				source += "\t" + family + "W 2(" + base + "), " + destination + "\n"
+				source += "\t" + family + "L 4(BX), DX\n"
+				if target.goarch == "amd64" {
+					source += "\t" + family + "Q 8(" + base + "), " + destination + "\n"
+				} else {
+					source += "\t" + family + "L 8(BX), SP\n"
+				}
+			}
+			source += "\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"farpointerforms": {Name: "farpointerforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "far-pointer-"+target.name+".ll", "far-pointer-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FarPointerRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LFSW AX, DX"},
+		{goarch: "amd64", instruction: "LFSL (BX), (CX)"},
+		{goarch: "amd64", instruction: "LGSQ (BX), X0"},
+		{goarch: "amd64", instruction: "LSSW.Z (BX), DX"},
+		{goarch: "386", instruction: "LFSQ (BX), AX"},
+		{goarch: "386", instruction: "LGSL (R11), AX"},
+		{goarch: "386", instruction: "LSSL (BX), R11"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's far-pointer tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_far_return.go b/amd64_lower_far_return.go
new file mode 100644
index 000000000..205ebc36c
--- /dev/null
+++ b/amd64_lower_far_return.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FarReturnKind uint8
+
+const (
+	amd64InterruptReturn amd64FarReturnKind = iota
+	amd64FarReturn
+)
+
+type amd64FarReturnSpec struct {
+	kind           amd64FarReturnKind
+	bits           int
+	allowImmediate bool
+}
+
+// amd64FarReturnSpecs is the complete Go 1.27 interrupt/far-return grammar.
+// Every RETF width accepts both the operand-free CB encoding and Go's Yi32
+// immediate row, whose value is truncated to the architectural imm16. Q-width
+// rows are absent from the 386 encoder even though W/L rows are shared.
+var amd64FarReturnSpecs = map[Op]amd64FarReturnSpec{
+	"IRETW": {kind: amd64InterruptReturn, bits: 16},
+	"IRETL": {kind: amd64InterruptReturn, bits: 32},
+	"IRETQ": {kind: amd64InterruptReturn, bits: 64},
+	"RETFW": {kind: amd64FarReturn, bits: 16, allowImmediate: true},
+	"RETFL": {kind: amd64FarReturn, bits: 32, allowImmediate: true},
+	"RETFQ": {kind: amd64FarReturn, bits: 64, allowImmediate: true},
+}
+
+type amd64FarReturnForm struct {
+	hasImmediate bool
+	immediate    uint16
+}
+
+func (c *amd64Ctx) lowerFarReturn(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64FarReturnSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.bits == 64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	form, err := c.parseFarReturnForm(baseOp, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n",
+		spec.encoding(form), "~{memory},~{dirflag},~{fpsr},~{flags}")
+	c.b.WriteString("  unreachable\n")
+	return true, true, nil
+}
+
+func (c *amd64Ctx) parseFarReturnForm(op string, spec amd64FarReturnSpec, ins Instr) (amd64FarReturnForm, error) {
+	var form amd64FarReturnForm
+	if len(ins.Args) == 0 {
+		return form, nil
+	}
+	if !spec.allowImmediate || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm ||
+		ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" {
+		return form, fmt.Errorf("%s %s expects no operands or one Go 1.27 Yi32 immediate: %q", c.goarch, op, ins.Raw)
+	}
+	value := ins.Args[0].Imm
+	if c.goarch != "386" && (value < -2147483648 || value > 4294967295) {
+		return form, fmt.Errorf("amd64 %s immediate is outside Go 1.27's Yi32 class: %q", op, ins.Raw)
+	}
+	form.hasImmediate = true
+	form.immediate = uint16(value)
+	return form, nil
+}
+
+func (spec amd64FarReturnSpec) encoding(form amd64FarReturnForm) string {
+	bytes := make([]byte, 0, 4)
+	switch spec.bits {
+	case 16:
+		bytes = append(bytes, 0x66)
+	case 32:
+	case 64:
+		bytes = append(bytes, 0x48)
+	default:
+		panic("unknown amd64 far-return width")
+	}
+	if spec.kind == amd64InterruptReturn {
+		bytes = append(bytes, 0xcf)
+	} else if form.hasImmediate {
+		bytes = append(bytes, 0xca, byte(form.immediate), byte(form.immediate>>8))
+	} else {
+		bytes = append(bytes, 0xcb)
+	}
+	parts := make([]string, len(bytes))
+	for index, value := range bytes {
+		parts[index] = fmt.Sprintf("0x%02x", value)
+	}
+	return ".byte " + strings.Join(parts, ", ")
+}
diff --git a/amd64_lower_far_return_test.go b/amd64_lower_far_return_test.go
new file mode 100644
index 000000000..6a8033f67
--- /dev/null
+++ b/amd64_lower_far_return_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FarReturnGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64FarReturnSpec{
+		"IRETW": {kind: amd64InterruptReturn, bits: 16},
+		"IRETL": {kind: amd64InterruptReturn, bits: 32},
+		"IRETQ": {kind: amd64InterruptReturn, bits: 64},
+		"RETFW": {kind: amd64FarReturn, bits: 16, allowImmediate: true},
+		"RETFL": {kind: amd64FarReturn, bits: 32, allowImmediate: true},
+		"RETFQ": {kind: amd64FarReturn, bits: 64, allowImmediate: true},
+	}
+	if !reflect.DeepEqual(amd64FarReturnSpecs, want) {
+		t.Fatalf("far-return grammar = %+v, want %+v", amd64FarReturnSpecs, want)
+	}
+}
+
+func TestAMD64FarReturnSplitsFollowingInstructions(t *testing.T) {
+	source := "TEXT splitfarreturn(SB),$0-0\n\tIRETL\n\tMOVL $1, AX\n\tRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"splitfarreturn": {Name: "splitfarreturn", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, amd64LLVMBlockName("anon_1")+":") || !strings.Contains(ir, "zext i32 1 to i64") {
+		t.Fatalf("instruction after IRETL was not retained in its own block:\n%s", ir)
+	}
+}
+
+func TestTranslateX86FarReturnCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			forms := []struct {
+				op  string
+				arg string
+			}{
+				{op: "IRETW"},
+				{op: "IRETL"},
+				{op: "RETFW"},
+				{op: "RETFW", arg: "$4"},
+				{op: "RETFL"},
+				{op: "RETFL", arg: "$4294967295"},
+			}
+			if target.goarch == "386" {
+				forms = append(forms, struct {
+					op  string
+					arg string
+				}{op: "RETFL", arg: "$4294967296"})
+			} else {
+				forms = append(forms,
+					struct {
+						op  string
+						arg string
+					}{op: "IRETQ"},
+					struct {
+						op  string
+						arg string
+					}{op: "RETFQ"},
+					struct {
+						op  string
+						arg string
+					}{op: "RETFQ", arg: "$4294967295"},
+				)
+			}
+			var source strings.Builder
+			sigs := make(map[string]FuncSig, len(forms))
+			for index, form := range forms {
+				name := fmt.Sprintf("farreturnform%d", index)
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n\t%s", name, form.op)
+				if form.arg != "" {
+					fmt.Fprintf(&source, " %s", form.arg)
+				}
+				source.WriteByte('\n')
+				sigs[name] = FuncSig{Name: name, Ret: Void}
+			}
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`.byte 0x66, 0xcf`,
+				`.byte 0xcf`,
+				`.byte 0x66, 0xcb`,
+				`.byte 0x66, 0xca, 0x04, 0x00`,
+				`.byte 0xcb`,
+				`.byte 0xca, 0xff, 0xff`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "386" {
+				if !strings.Contains(ir, `.byte 0xca, 0x00, 0x00`) {
+					t.Errorf("386 IR is missing truncated Yi32 compatibility encoding:\n%s", ir)
+				}
+			} else {
+				for _, want := range []string{`.byte 0x48, 0xcf`, `.byte 0x48, 0xcb`, `.byte 0x48, 0xca, 0xff, 0xff`} {
+					if !strings.Contains(ir, want) {
+						t.Errorf("amd64 IR is missing %s:\n%s", want, ir)
+					}
+				}
+			}
+			if got := strings.Count(ir, "unreachable"); got != len(forms) {
+				t.Errorf("unreachable count = %d, want %d", got, len(forms))
+			}
+			compileLLVMToObject(t, llc, target.triple, "far-return-"+target.name+".ll", "far-return-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FarReturnRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "IRETW AX"},
+		{goarch: "amd64", instruction: "IRETL.P"},
+		{goarch: "amd64", instruction: "IRETQ $4"},
+		{goarch: "amd64", instruction: "RETFW AX"},
+		{goarch: "amd64", instruction: "RETFL $-2147483649"},
+		{goarch: "amd64", instruction: "RETFQ $4294967296"},
+		{goarch: "amd64", instruction: "RETFL $1, $2"},
+		{goarch: "386", instruction: "IRETQ"},
+		{goarch: "386", instruction: "RETFQ"},
+		{goarch: "386", instruction: "RETFQ $4"},
+	} {
+		t.Run(test.goarch+"_"+strings.ReplaceAll(test.instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's far-return tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_fixed_system.go b/amd64_lower_fixed_system.go
new file mode 100644
index 000000000..afa579ef7
--- /dev/null
+++ b/amd64_lower_fixed_system.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FixedSystemEffect uint8
+
+const (
+	amd64FixedSystemContinue amd64FixedSystemEffect = iota
+	amd64FixedSystemTrap
+	amd64FixedSystemControlTransfer
+)
+
+type amd64FixedSystemSpec struct {
+	encoding string
+	effect   amd64FixedSystemEffect
+	rawOnly  bool
+}
+
+// amd64FixedSystemSpecs is the complete Go 1.27 operand-free system/state
+// family that has no modeled GP-register data flow, plus raw-only ENDBR32.
+// Exact bytes keep Go's
+// accepted 386 compatibility rows (notably ENDBR64 and SWAPGS) object-level
+// compatible even when LLVM's mnemonic matcher applies architectural mode
+// restrictions. Effects remain typed so traps and non-returning RSM cannot
+// accidentally acquire ordinary fallthrough.
+var amd64FixedSystemSpecs = map[Op]amd64FixedSystemSpec{
+	"CLAC":    {encoding: ".byte 0x0f, 0x01, 0xca"},
+	"CLI":     {encoding: ".byte 0xfa"},
+	"CLTS":    {encoding: ".byte 0x0f, 0x06"},
+	"ENDBR32": {encoding: ".byte 0xf3, 0x0f, 0x1e, 0xfb", rawOnly: true},
+	"ENDBR64": {encoding: ".byte 0xf3, 0x0f, 0x1e, 0xfa"},
+	"ICEBP":   {encoding: ".byte 0xf1", effect: amd64FixedSystemTrap},
+	"INVD":    {encoding: ".byte 0x0f, 0x08"},
+	"RSM":     {encoding: ".byte 0x0f, 0xaa", effect: amd64FixedSystemControlTransfer},
+	"STAC":    {encoding: ".byte 0x0f, 0x01, 0xcb"},
+	"STI":     {encoding: ".byte 0xfb"},
+	"SWAPGS":  {encoding: ".byte 0x0f, 0x01, 0xf8"},
+	"UD1":     {encoding: ".byte 0x0f, 0xb9, 0x00", effect: amd64FixedSystemTrap},
+	"WBINVD":  {encoding: ".byte 0x0f, 0x09"},
+}
+
+func (c *amd64Ctx) lowerFixedSystem(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64FixedSystemSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if spec.rawOnly && !ins.x86Encoded {
+		return true, false, fmt.Errorf("%s %s has no Go assembler mnemonic; use its raw encoding: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n",
+		spec.encoding, "~{memory},~{dirflag},~{fpsr},~{flags}")
+	if spec.effect == amd64FixedSystemContinue {
+		return true, false, nil
+	}
+	c.b.WriteString("  unreachable\n")
+	return true, true, nil
+}
diff --git a/amd64_lower_fixed_system_test.go b/amd64_lower_fixed_system_test.go
new file mode 100644
index 000000000..0598f9072
--- /dev/null
+++ b/amd64_lower_fixed_system_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FixedSystemGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64FixedSystemSpec{
+		"CLAC":    {encoding: ".byte 0x0f, 0x01, 0xca"},
+		"CLI":     {encoding: ".byte 0xfa"},
+		"CLTS":    {encoding: ".byte 0x0f, 0x06"},
+		"ENDBR32": {encoding: ".byte 0xf3, 0x0f, 0x1e, 0xfb", rawOnly: true},
+		"ENDBR64": {encoding: ".byte 0xf3, 0x0f, 0x1e, 0xfa"},
+		"ICEBP":   {encoding: ".byte 0xf1", effect: amd64FixedSystemTrap},
+		"INVD":    {encoding: ".byte 0x0f, 0x08"},
+		"RSM":     {encoding: ".byte 0x0f, 0xaa", effect: amd64FixedSystemControlTransfer},
+		"STAC":    {encoding: ".byte 0x0f, 0x01, 0xcb"},
+		"STI":     {encoding: ".byte 0xfb"},
+		"SWAPGS":  {encoding: ".byte 0x0f, 0x01, 0xf8"},
+		"UD1":     {encoding: ".byte 0x0f, 0xb9, 0x00", effect: amd64FixedSystemTrap},
+		"WBINVD":  {encoding: ".byte 0x0f, 0x09"},
+	}
+	if !reflect.DeepEqual(amd64FixedSystemSpecs, want) {
+		t.Fatalf("fixed-system grammar = %+v, want %+v", amd64FixedSystemSpecs, want)
+	}
+}
+
+func TestTranslateX86FixedSystemCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT fixedsystemforms(SB),$0-0
+	CLAC
+	CLI
+	CLTS
+	ENDBR64
+	INVD
+	STAC
+	STI
+	SWAPGS
+	WBINVD
+	RET
+TEXT fixedsystemicebp(SB),$0-0
+	ICEBP
+TEXT fixedsystemrsm(SB),$0-0
+	RSM
+TEXT fixedsystemud1(SB),$0-0
+	UD1
+`
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"fixedsystemforms": {Name: "fixedsystemforms", Ret: Void},
+					"fixedsystemicebp": {Name: "fixedsystemicebp", Ret: Void},
+					"fixedsystemrsm":   {Name: "fixedsystemrsm", Ret: Void},
+					"fixedsystemud1":   {Name: "fixedsystemud1", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`.byte 0x0f, 0x01, 0xca`,
+				`.byte 0xfa`,
+				`.byte 0x0f, 0x06`,
+				`.byte 0xf3, 0x0f, 0x1e, 0xfa`,
+				`.byte 0x0f, 0x08`,
+				`.byte 0x0f, 0x01, 0xcb`,
+				`.byte 0xfb`,
+				`.byte 0x0f, 0x01, 0xf8`,
+				`.byte 0x0f, 0x09`,
+				`.byte 0xf1`,
+				`.byte 0x0f, 0xaa`,
+				`.byte 0x0f, 0xb9, 0x00`,
+				`unreachable`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			if got := strings.Count(ir, "unreachable"); got != 3 {
+				t.Errorf("unreachable count = %d, want 3", got)
+			}
+			compileLLVMToObject(t, llc, target.triple, "fixed-system-"+target.name+".ll", "fixed-system-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FixedSystemRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "CLAC AX"},
+		{goarch: "amd64", instruction: "CLI.P"},
+		{goarch: "amd64", instruction: "CLTS AX"},
+		{goarch: "amd64", instruction: "ENDBR64 AX"},
+		{goarch: "amd64", instruction: "ICEBP AX"},
+		{goarch: "amd64", instruction: "INVD AX"},
+		{goarch: "amd64", instruction: "RSM AX"},
+		{goarch: "amd64", instruction: "STAC AX"},
+		{goarch: "amd64", instruction: "STI AX"},
+		{goarch: "amd64", instruction: "SWAPGS AX"},
+		{goarch: "amd64", instruction: "UD1 AX"},
+		{goarch: "amd64", instruction: "WBINVD AX"},
+		{goarch: "386", instruction: "ENDBR64.P"},
+		{goarch: "386", instruction: "SWAPGS AX"},
+	} {
+		t.Run(test.goarch+"_"+strings.ReplaceAll(test.instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's fixed-system tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_fixupimm.go b/amd64_lower_fixupimm.go
new file mode 100644
index 000000000..06a082dac
--- /dev/null
+++ b/amd64_lower_fixupimm.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FixupImmediateSpec struct {
+	laneBits int
+	scalar   bool
+}
+
+var amd64FixupImmediateSpecs = map[Op]amd64FixupImmediateSpec{
+	"VFIXUPIMMPS": {laneBits: 32},
+	"VFIXUPIMMPD": {laneBits: 64},
+	"VFIXUPIMMSS": {laneBits: 32, scalar: true},
+	"VFIXUPIMMSD": {laneBits: 64, scalar: true},
+}
+
+func (c *amd64Ctx) lowerFixupImmediate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64FixupImmediateSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	shape := amd64UnaryImmediateFloatingShape{laneBits: spec.laneBits, scalar: spec.scalar, twoSource: true}
+	form, err := c.parseUnaryImmediateFloatingForm(baseOp, suffix, shape, ins)
+	if err != nil {
+		return true, false, err
+	}
+	daz := c.loadMXCSRDAZ()
+	if spec.scalar {
+		return c.lowerScalarFixupImmediate(spec, form, daz)
+	}
+	return c.lowerPackedFixupImmediate(spec, form, daz)
+}
+
+func (c *amd64Ctx) lowerPackedFixupImmediate(spec amd64FixupImmediateSpec, form amd64UnaryImmediateFloatingForm, daz string) (bool, bool, error) {
+	lanes := form.byteWidth * 8 / spec.laneBits
+	table, err := c.loadPackedCompareLanes(form.source, form.byteWidth, spec.laneBits, form.properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	classified, err := c.loadPackedCompareLanes(form.passthrough, form.byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	oldBytes, err := c.loadPackedCompareBytes(form.destination, form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	old := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, spec.laneBits, oldBytes)
+	result := c.emitFixupImmediateBits(lanes, spec.laneBits, classified, table, old, daz)
+	if form.mask != "" {
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, form.mask, form.properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(form.destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarFixupImmediate(spec amd64FixupImmediateSpec, form amd64UnaryImmediateFloatingForm, daz string) (bool, bool, error) {
+	tableBits, err := c.loadFloatingScalarBits(form.source, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	classifiedBytes, err := c.loadX(form.passthrough.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	classifiedVector := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, classifiedBytes)
+	classifiedLow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 0\n", classifiedLow, 128/spec.laneBits, spec.laneBits, classifiedVector)
+	oldLow, err := c.loadXLowInteger(form.destination.Reg, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	tableVector, classifiedOne, oldVector := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", tableVector, spec.laneBits, spec.laneBits, tableBits)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %%%s, i32 0\n", classifiedOne, spec.laneBits, spec.laneBits, classifiedLow)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", oldVector, spec.laneBits, spec.laneBits, oldLow)
+	result := c.emitFixupImmediateBits(1, spec.laneBits, "%"+classifiedOne, "%"+tableVector, "%"+oldVector, daz)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	return true, false, c.storeScalarMoveRegister(form.destination.Reg, spec.laneBits, "%"+low, classifiedVector, form.mask, form.properties.zeroing)
+}
+
+// emitFixupImmediateBits implements the data-result portion of Intel's
+// FIXUPIMM_SP/FIXUPIMM_DP grammar. imm8 controls only MXCSR exception
+// reporting; plan9asm does not currently expose floating exception state.
+func (c *amd64Ctx) emitFixupImmediateBits(lanes, laneBits int, classified, table, old, daz string) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	signBit := uint64(0x80000000)
+	positiveOne := uint64(0x3f800000)
+	constants := [16]uint64{
+		0, 0, 0, 0xffc00000,
+		0xff800000, 0x7f800000, 0, 0x80000000,
+		0, 0xbf800000, 0x3f800000, 0x3f000000,
+		0x42b40000, 0x3fc90fdb, 0x7f7fffff, 0xff7fffff,
+	}
+	if laneBits == 64 {
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+		signBit = uint64(0x8000000000000000)
+		positiveOne = uint64(0x3ff0000000000000)
+		constants = [16]uint64{
+			0, 0, 0, 0xfff8000000000000,
+			0xfff0000000000000, 0x7ff0000000000000, 0, 0x8000000000000000,
+			0, 0xbff0000000000000, 0x3ff0000000000000, 0x3fe0000000000000,
+			0x4056800000000000, 0x3ff921fb54442d18, 0x7fefffffffffffff, 0xffefffffffffffff,
+		}
+	}
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		raw, tableLane, oldLane := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", raw, vectorType, classified, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", tableLane, vectorType, table, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", oldLane, vectorType, old, lane)
+		rawExponent, exponentZero, dazZero := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", rawExponent, laneBits, raw, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", exponentZero, laneBits, rawExponent)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %s\n", dazZero, exponentZero, daz)
+		effective := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 0, i%d %%%s\n", effective, dazZero, laneBits, laneBits, raw)
+
+		exponent, mantissa, sign, absolute := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", exponent, laneBits, effective, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", mantissa, laneBits, effective, mantissaMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", sign, laneBits, effective, signBit)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", absolute, laneBits, effective, signBit-1)
+		exponentOnes, mantissaZero, mantissaNonzero, negative, zero := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", exponentOnes, laneBits, exponent, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", mantissaZero, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", mantissaNonzero, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", negative, laneBits, sign)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", zero, laneBits, absolute)
+		isNaN, isInfinity, quietSet := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isNaN, exponentOnes, mantissaNonzero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isInfinity, exponentOnes, mantissaZero)
+		quietValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", quietValue, laneBits, mantissa, quietBit)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", quietSet, laneBits, quietValue)
+		notQuiet, signalingNaN, quietNaN := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notQuiet, quietSet)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", signalingNaN, isNaN, notQuiet)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", quietNaN, isNaN, quietSet)
+		negativeInfinity, positiveInfinity, notNegative := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", negativeInfinity, isInfinity, negative)
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notNegative, negative)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", positiveInfinity, isInfinity, notNegative)
+		positiveOneValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", positiveOneValue, laneBits, effective, positiveOne)
+
+		token := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 6, i%d 7\n", token, negative, laneBits, laneBits)
+		for _, selection := range []struct {
+			predicate string
+			value     int
+		}{
+			{predicate: positiveInfinity, value: 5},
+			{predicate: negativeInfinity, value: 4},
+			{predicate: positiveOneValue, value: 3},
+			{predicate: zero, value: 2},
+			{predicate: signalingNaN, value: 1},
+			{predicate: quietNaN, value: 0},
+		} {
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %%%s\n", selected, selection.predicate, laneBits, selection.value, laneBits, token)
+			token = selected
+		}
+		shift, shiftedTable, response := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %%%s, 2\n", shift, laneBits, token)
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %%%s\n", shiftedTable, laneBits, tableLane, shift)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, 15\n", response, laneBits, shiftedTable)
+
+		quieted, signedInfinity := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", quieted, laneBits, effective, exponentMask|quietBit)
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", signedInfinity, laneBits, sign, exponentMask)
+		responseValues := [16]string{
+			"%" + oldLane, "%" + effective, "%" + quieted,
+			fmt.Sprintf("%d", constants[3]), fmt.Sprintf("%d", constants[4]), fmt.Sprintf("%d", constants[5]), "%" + signedInfinity,
+			fmt.Sprintf("%d", constants[7]), fmt.Sprintf("%d", constants[8]), fmt.Sprintf("%d", constants[9]), fmt.Sprintf("%d", constants[10]),
+			fmt.Sprintf("%d", constants[11]), fmt.Sprintf("%d", constants[12]), fmt.Sprintf("%d", constants[13]), fmt.Sprintf("%d", constants[14]), fmt.Sprintf("%d", constants[15]),
+		}
+		laneResult := responseValues[0]
+		for responseValue := 1; responseValue < len(responseValues); responseValue++ {
+			matches, selected := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", matches, laneBits, response, responseValue)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %s, i%d %s\n", selected, matches, laneBits, responseValues[responseValue], laneBits, laneResult)
+			laneResult = "%" + selected
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, result, laneBits, laneResult, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_fixupimm_test.go b/amd64_lower_fixupimm_test.go
new file mode 100644
index 000000000..86b4a5bdb
--- /dev/null
+++ b/amd64_lower_fixupimm_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type fixupImmediateTestSpec struct {
+	op       string
+	laneBits int
+	scalar   bool
+}
+
+func go127FixupImmediateSpecs() []fixupImmediateTestSpec {
+	return []fixupImmediateTestSpec{
+		{op: "VFIXUPIMMPS", laneBits: 32},
+		{op: "VFIXUPIMMPD", laneBits: 64},
+		{op: "VFIXUPIMMSS", laneBits: 32, scalar: true},
+		{op: "VFIXUPIMMSD", laneBits: 64, scalar: true},
+	}
+}
+
+func TestAMD64FixupImmediateGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := go127FixupImmediateSpecs()
+	if len(amd64FixupImmediateSpecs) != len(expected) {
+		t.Fatalf("FIXUPIMM grammar has %d entries, want %d", len(amd64FixupImmediateSpecs), len(expected))
+	}
+	for _, want := range expected {
+		got, ok := amd64FixupImmediateSpecs[Op(want.op)]
+		if !ok {
+			t.Errorf("FIXUPIMM grammar omitted %s", want.op)
+			continue
+		}
+		if got.laneBits != want.laneBits || got.scalar != want.scalar {
+			t.Errorf("FIXUPIMM grammar %s = %+v, want laneBits=%d scalar=%v", want.op, got, want.laneBits, want.scalar)
+		}
+	}
+}
+
+func TestTranslateX86FixupImmediateCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT fixupimmforms(SB),$0-0\n")
+			for index, spec := range go127FixupImmediateSpecs() {
+				if spec.scalar {
+					fmt.Fprintf(&source, "\t%s $%d, X0, X1, X23\n", spec.op, index)
+					fmt.Fprintf(&source, "\t%s $%d, %d(AX), X1, X23\n", spec.op, index+16, index*8)
+					fmt.Fprintf(&source, "\t%s $%d, X2, X1, K1, X23\n", spec.op, index+32)
+					fmt.Fprintf(&source, "\t%s.Z $%d, %d(AX), X1, K2, X23\n", spec.op, index+48, index*8)
+					fmt.Fprintf(&source, "\t%s.SAE $%d, X3, X1, X23\n", spec.op, index+64)
+					fmt.Fprintf(&source, "\t%s.SAE.Z $%d, X4, X1, K3, X23\n", spec.op, index+80)
+					continue
+				}
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&source, "\t%s $%d, %s0, %s1, %s23\n", spec.op, index, width, width, width)
+					fmt.Fprintf(&source, "\t%s $%d, %d(AX), %s1, %s23\n", spec.op, index+16, index*8, width, width)
+					fmt.Fprintf(&source, "\t%s.BCST $%d, %d(AX), %s1, %s23\n", spec.op, index+32, index*8, width, width)
+					fmt.Fprintf(&source, "\t%s $%d, %s2, %s1, K1, %s23\n", spec.op, index+48, width, width, width)
+					fmt.Fprintf(&source, "\t%s.BCST.Z $%d, %d(AX), %s1, K2, %s23\n", spec.op, index+64, index*8, width, width)
+				}
+				fmt.Fprintf(&source, "\t%s.SAE $%d, Z3, Z1, Z23\n", spec.op, index+80)
+				fmt.Fprintf(&source, "\t%s.SAE.Z $%d, Z4, Z1, K3, Z23\n", spec.op, index+96)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "fixupimmforms", "amd64", target.triple)
+			compileLLVMToObject(t, llc, target.triple, "fixupimm-"+target.name+".ll", "fixupimm-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FixupImmediateRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VFIXUPIMMPS $-1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS $256, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS.Z $1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS $1, X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS.SAE $1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS.SAE $1, 0(AX), Z1, Z2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMPS $1, X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMSS.BCST $1, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VFIXUPIMMSS.SAE $1, 0(AX), X1, X2"},
+		{goarch: "386", instruction: "VFIXUPIMMPS $1, X0, X1, X2"},
+		{goarch: "386", instruction: "VFIXUPIMMSS $1, X0, X1, X2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's FIXUPIMM tables", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64FixupImmediateRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	const source = `TEXT fixupimmsemantics(SB),$0-64
+	MOVQ out+0(FP), AX
+	MOVQ src32+8(FP), BX
+	MOVQ table32+16(FP), CX
+	MOVQ old32+24(FP), DX
+	MOVQ src64+32(FP), R8
+	MOVQ table64+40(FP), R9
+	MOVQ old64+48(FP), R10
+	MOVQ mask+56(FP), R11
+	KMOVQ R11, K1
+	VMOVDQU32 0(BX), Z1
+	VMOVDQU32 0(CX), Z0
+	VMOVDQU32 0(DX), Z2
+	STC
+	VFIXUPIMMPS $0, Z0, Z1, Z2
+	VMOVDQU32 Z2, 0(AX)
+	VMOVDQU32 0(DX), Z2
+	VFIXUPIMMPS $0, Z0, Z1, K1, Z2
+	VMOVDQU32 Z2, 64(AX)
+	VFIXUPIMMPS.Z $0, Z0, Z1, K1, Z3
+	VMOVDQU32 Z3, 128(AX)
+	VMOVDQU64 0(R8), Z5
+	VMOVDQU64 0(R9), Z4
+	VMOVDQU64 0(R10), Z6
+	VFIXUPIMMPD $0, Z4, Z5, Z6
+	VMOVDQU64 Z6, 192(AX)
+	VMOVDQU64 0(R8), X5
+	VMOVDQU64 0(R9), X4
+	VMOVDQU64 0(R10), X6
+	VFIXUPIMMSD $0, X4, X5, X6
+	VMOVDQU64 X6, 256(AX)
+	VMOVDQU32 0(BX), X1
+	VMOVDQU32 0(CX), X0
+	VMOVDQU32 0(DX), X2
+	VFIXUPIMMSS $0, X0, X1, X2
+	VMOVDQU32 X2, 272(AX)
+	SETCS 288(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	runtimeSource := x86FixupRuntimeSource(t, source)
+	requireX86GoAssemblerResult(t, "amd64", runtimeSource, true)
+	file, err := Parse(ArchAMD64, runtimeSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"fixupimmsemantics": {
+			Name: "fixupimmsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+				{Offset: 56, Type: I64, Index: 7, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void fixupimmsemantics(uint8_t *, const uint32_t *, const uint32_t *, const uint32_t *, const uint64_t *, const uint64_t *, const uint64_t *, uint64_t);
+static unsigned token32(uint32_t x, int daz) {
+  if (daz && (x & UINT32_C(0x7f800000)) == 0) x = 0;
+  uint32_t a=x&UINT32_C(0x7fffffff),m=x&UINT32_C(0x007fffff),e=x&UINT32_C(0x7f800000);
+  if(e==UINT32_C(0x7f800000)&&m) return m&UINT32_C(0x00400000)?0:1;
+  if(a==0)return 2;if(x==UINT32_C(0x3f800000))return 3;
+  if(a==UINT32_C(0x7f800000))return x>>31?4:5;return x>>31?6:7;
+}
+static unsigned token64(uint64_t x, int daz) {
+  if (daz && (x & UINT64_C(0x7ff0000000000000)) == 0) x = 0;
+  uint64_t a=x&UINT64_C(0x7fffffffffffffff),m=x&UINT64_C(0x000fffffffffffff),e=x&UINT64_C(0x7ff0000000000000);
+  if(e==UINT64_C(0x7ff0000000000000)&&m) return m&UINT64_C(0x0008000000000000)?0:1;
+  if(a==0)return 2;if(x==UINT64_C(0x3ff0000000000000))return 3;
+  if(a==UINT64_C(0x7ff0000000000000))return x>>63?4:5;return x>>63?6:7;
+}
+static uint32_t effective32(uint32_t x,int daz){return daz&&(x&UINT32_C(0x7f800000))==0?0:x;}
+static uint64_t effective64(uint64_t x,int daz){return daz&&(x&UINT64_C(0x7ff0000000000000))==0?0:x;}
+static uint32_t fix32(uint32_t old,uint32_t x,uint32_t table,int daz){
+  x=effective32(x,daz);unsigned r=(table>>(4*token32(x,0)))&15;
+  static const uint32_t c[16]={0,0,0,UINT32_C(0xffc00000),UINT32_C(0xff800000),UINT32_C(0x7f800000),0,UINT32_C(0x80000000),0,UINT32_C(0xbf800000),UINT32_C(0x3f800000),UINT32_C(0x3f000000),UINT32_C(0x42b40000),UINT32_C(0x3fc90fdb),UINT32_C(0x7f7fffff),UINT32_C(0xff7fffff)};
+  if(r==0)return old;if(r==1)return x;if(r==2)return x|UINT32_C(0x7fc00000);if(r==6)return (x&UINT32_C(0x80000000))|UINT32_C(0x7f800000);return c[r];
+}
+static uint64_t fix64(uint64_t old,uint64_t x,uint64_t table,int daz){
+  x=effective64(x,daz);unsigned r=(table>>(4*token64(x,0)))&15;
+  static const uint64_t c[16]={0,0,0,UINT64_C(0xfff8000000000000),UINT64_C(0xfff0000000000000),UINT64_C(0x7ff0000000000000),0,UINT64_C(0x8000000000000000),0,UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000000),UINT64_C(0x3fe0000000000000),UINT64_C(0x4056800000000000),UINT64_C(0x3ff921fb54442d18),UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff)};
+  if(r==0)return old;if(r==1)return x;if(r==2)return x|UINT64_C(0x7ff8000000000000);if(r==6)return (x&UINT64_C(0x8000000000000000))|UINT64_C(0x7ff0000000000000);return c[r];
+}
+int main(void){
+  const uint32_t src32[16]={UINT32_C(0x7fc12345),1,UINT32_C(0xc0200001),0,UINT32_C(0xff800000),UINT32_C(0x7f800000),UINT32_C(0xc0000000),UINT32_C(0x40000000),UINT32_C(0x80000000),UINT32_C(0x3f800000),UINT32_C(0x7f812345),UINT32_C(0x80000001),UINT32_C(0x40400000),UINT32_C(0xc0800000),UINT32_C(0x3f400000),UINT32_C(0xbf400000)};
+  const uint64_t src64[8]={UINT64_C(0x7ff8123456789abc),1,UINT64_C(0xc004000000000001),0,UINT64_C(0xfff0000000000000),UINT64_C(0x7ff0000000000000),UINT64_C(0xc000000000000000),UINT64_C(0x4000000000000000)};
+  uint32_t old32[16],table32[16],got32[48],want32[48];uint64_t old64[8],table64[8],got64[10],want64[10];uint8_t out[289];
+  const uint64_t mask=UINT64_C(0xa55a);unsigned original=_mm_getcsr();
+  for(int i=0;i<16;i++)old32[i]=UINT32_C(0x41000000)+i;for(int i=0;i<8;i++)old64[i]=UINT64_C(0x4020000000000000)+i;
+  for(int daz=0;daz<2;daz++){
+    _mm_setcsr((original&~64u)|(daz?64u:0));memset(out,0,sizeof(out));
+    for(int i=0;i<16;i++)table32[i]=(uint32_t)i<<(4*token32(src32[i],daz));
+    for(int i=0;i<8;i++)table64[i]=(uint64_t)(i+8)<<(4*token64(src64[i],daz));
+    fixupimmsemantics(out,src32,table32,old32,src64,table64,old64,mask);memcpy(got32,out,192);memcpy(got64,out+192,80);
+    for(int i=0;i<16;i++){uint32_t v=fix32(old32[i],src32[i],table32[i],daz);want32[i]=v;want32[16+i]=(mask>>i)&1?v:old32[i];want32[32+i]=(mask>>i)&1?v:0;}
+    for(int i=0;i<8;i++)want64[i]=fix64(old64[i],src64[i],table64[i],daz);want64[8]=fix64(old64[0],src64[0],table64[0],daz);want64[9]=src64[1];
+    for(int i=0;i<48;i++)if(got32[i]!=want32[i])return 10+daz;
+    for(int i=0;i<10;i++)if(got64[i]!=want64[i])return 20+daz;
+    uint32_t scalar32[4];memcpy(scalar32,out+272,16);if(scalar32[0]!=fix32(old32[0],src32[0],table32[0],daz)||scalar32[1]!=src32[1]||scalar32[2]!=src32[2]||scalar32[3]!=src32[3])return 30+daz;
+    if(out[288]!=1)return 40+daz;
+  }
+  _mm_setcsr(original);return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "fixupimm_semantics", ir, mainC)
+}
diff --git a/amd64_lower_float_add_sub.go b/amd64_lower_float_add_sub.go
new file mode 100644
index 000000000..048464c34
--- /dev/null
+++ b/amd64_lower_float_add_sub.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+func (c *amd64Ctx) lowerFloatAddSub(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerFloatArithmetic(op, ins, x86FloatAddSubtract)
+}
+
+func (c *amd64Ctx) lowerFloatAddSubForm(ins Instr, form x86FloatAddSubForm) (bool, bool, error) {
+	return c.lowerFloatBinaryOperands(ins, form.x86FloatBinaryForm, func(lanes int, left, right, mask string) string {
+		return c.emitFloatAddSub(form, lanes, left, right, mask)
+	})
+}
+
+// Shared yxm/VEX/EVEX source loading and alias writes. Each family supplies
+// its arithmetic emitter, so a common shape grants no numerical behavior.
+func (c *amd64Ctx) lowerFloatBinaryOperands(ins Instr, form x86FloatBinaryForm, emit func(int, string, string, string) string) (bool, bool, error) {
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.scalar && form.memory >= 0 {
+		return true, false, c.lowerLegacyPackedFloatingMemory(ins, form)
+	}
+	if first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	var mask string
+	var err error
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	bits := form.bits
+	if form.scalar {
+		var a string
+		var err error
+		if form.literal {
+			if bits == 32 {
+				a, err = c.evalF32(first)
+			} else {
+				a, err = c.evalF64(first)
+			}
+		} else {
+			a, err = c.loadFloatBinaryScalar(first, bits, mask)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadFMA3Scalar(second, bits, "")
+		if err != nil {
+			return true, false, err
+		}
+		value := emit(1, b, a, mask)
+		integer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", integer, amd64FMA3LLVMType(1, bits), value, bits)
+		upper, err := c.loadX(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := 128 / bits
+		base := c.bitcastVectorBytesToIntegerLanes(16, lanes, bits, upper)
+		if !form.legacy {
+			return true, false, c.storeScalarMoveRegister(destination.Reg, bits, "%"+integer, base, mask, form.zeroing)
+		}
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 0\n", merged, lanes, bits, base, bits, integer)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, lanes, bits, merged)
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+bytes)
+	}
+	lanes := form.byteWidth * 8 / bits
+	a, err := c.loadFloatBinaryPacked(first, form.byteWidth, bits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	b, err := c.loadPackedCompareLanes(second, form.byteWidth, bits, false)
+	if err != nil {
+		return true, false, err
+	}
+	floatType := amd64FMA3LLVMType(lanes, bits)
+	aFloat, bFloat := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", aFloat, lanes, bits, a, floatType)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", bFloat, lanes, bits, b, floatType)
+	value := emit(lanes, "%"+bFloat, "%"+aFloat, mask)
+	result := c.bitcastFloatingToIntegerLanes(floatType, lanes, bits, value)
+	if form.mask >= 0 {
+		old, err := c.loadPackedCompareLanes(destination, form.byteWidth, bits, false)
+		if err != nil {
+			return true, false, err
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, bits, result, old, mask, form.zeroing)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, bits, result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+bytes)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+bytes)
+}
+
+func (c *amd64Ctx) emitFloatAddSub(form x86FloatAddSubForm, lanes int, left, right, mask string) string {
+	if form.rounding != "" {
+		return c.emitRoundedFloatAddSub(lanes, form.spec.bits, left, right, (form.spec.mode == amd64BinaryFloatingSub), form.rounding)
+	}
+	// Do not grant fast-math, reassociation or an ambient-rounding assumption.
+	// Dynamic strict operations retain x86 rounding/DAZ/FTZ/exception behavior.
+	operation := "fadd"
+	if form.spec.mode == amd64BinaryFloatingSub {
+		operation = "fsub"
+	}
+	return c.emitStrictFloatBinary(form.x86FloatBinaryForm, operation, lanes, left, right, mask, func(lanes int, left, right, value string) string {
+		return c.emitFloatAddSubSpecial(form.spec.bits, lanes, left, right, (form.spec.mode == amd64BinaryFloatingSub), value)
+	})
+}
+
+// Strict operations must remain observable under middle-end optimization.
+// The correction callback handles each family's native NaN result priority
+// without replacing the actual hardware rounding or exception side effects.
+func (c *amd64Ctx) emitStrictFloatBinary(form x86FloatBinaryForm, operation string, lanes int, left, right, mask string, correct func(int, string, string, string) string) string {
+	typ := amd64FMA3LLVMType(lanes, form.bits)
+	if mask != "" {
+		// EVEX suppresses arithmetic exceptions as well as memory faults for
+		// inactive lanes. Selecting after an eager strict fadd is not enough.
+		scalarType := amd64FMA3LLVMType(1, form.bits)
+		result := "poison"
+		for lane := 0; lane < lanes; lane++ {
+			values := []string{left, right}
+			if lanes > 1 {
+				for index, value := range values {
+					extracted := c.newTmp()
+					fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", extracted, typ, value, lane)
+					values[index] = "%" + extracted
+				}
+			}
+			active := amd64MaskBitI1(c, mask, lane)
+			integer, _ := c.loadX86ScalarIf(form.bits, active, func() (string, error) {
+				value, bits := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = call %s @llvm.experimental.constrained.%s.f%d(%s %s, %s %s, metadata !\"round.dynamic\", metadata !\"fpexcept.strict\")\n", value, scalarType, operation, form.bits, scalarType, values[0], scalarType, values[1])
+				corrected := correct(1, values[0], values[1], "%"+value)
+				fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", bits, scalarType, corrected, form.bits)
+				return "%" + bits, nil
+			})
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to %s\n", value, form.bits, integer, scalarType)
+			if lanes == 1 {
+				return "%" + value
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, typ, result, scalarType, value, lane)
+			result = "%" + inserted
+		}
+		return result
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.experimental.constrained.%s.%s(%s %s, %s %s, metadata !\"round.dynamic\", metadata !\"fpexcept.strict\")\n", result, typ, operation, amd64BinaryFloatingIntrinsicSuffix(lanes, form.bits), typ, left, typ, right)
+	return correct(lanes, left, right, "%"+result)
+}
+
+// LLVM's commutative add legalization can swap NaN operands even for a
+// constrained operation. Preserve its real hardware exception/rounding
+// effects, but restore x86 binary source-order payload/indefinite results.
+func (c *amd64Ctx) emitFloatAddSubSpecial(bits, lanes int, left, right string, subtract bool, hardware string) string {
+	scalarType, typ := amd64FMA3LLVMType(1, bits), amd64FMA3LLVMType(lanes, bits)
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		values := []string{left, right, hardware}
+		if lanes > 1 {
+			for index, value := range values {
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", extracted, typ, value, lane)
+				values[index] = "%" + extracted
+			}
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @__plan9asm_add_sub_special_f%d(%s %s, %s %s, i1 %t, %s %s)\n", value, scalarType, bits, scalarType, values[0], scalarType, values[1], subtract, scalarType, values[2])
+		if lanes == 1 {
+			return "%" + value
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, typ, result, scalarType, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_float_add_sub_round.go b/amd64_lower_float_add_sub_round.go
new file mode 100644
index 000000000..8eca3ad81
--- /dev/null
+++ b/amd64_lower_float_add_sub_round.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Classify binary x86 special values using integer operations only. This is
+// also used after a real strict operation without changing its MXCSR effects.
+func emitX86FloatAddSubSpecialBits(e *amd64FMA3IntegerEmitter, bits int) (special, result, rightSigned string) {
+	fraction, exponent := 23, uint64(0x7f800000)
+	if bits == 64 {
+		fraction, exponent = 52, 0x7ff0000000000000
+	}
+	typ := amd64FMA3LLVMType(1, bits)
+	left := e.value("bitcast %s %%left to i%d", typ, bits)
+	right := e.value("bitcast %s %%right to i%d", typ, bits)
+	sign := uint64(1) << (bits - 1)
+	leftAbs := e.value("and i%d %s, %d", bits, left, sign-1)
+	rightAbs := e.value("and i%d %s, %d", bits, right, sign-1)
+	leftNaN := e.value("icmp ugt i%d %s, %d", bits, leftAbs, exponent)
+	rightNaN := e.value("icmp ugt i%d %s, %d", bits, rightAbs, exponent)
+	leftInf := e.value("icmp eq i%d %s, %d", bits, leftAbs, exponent)
+	rightInf := e.value("icmp eq i%d %s, %d", bits, rightAbs, exponent)
+	special = e.value("or i1 %s, %s", leftNaN, rightNaN)
+	special = e.value("or i1 %s, %s", special, leftInf)
+	special = e.value("or i1 %s, %s", special, rightInf)
+	negated := e.value("xor i%d %s, %d", bits, right, sign)
+	rightSigned = e.value("select i1 %%subtract, i%d %s, i%d %s", bits, negated, bits, right)
+	quiet := uint64(1) << (fraction - 1)
+	leftQuiet := e.value("or i%d %s, %d", bits, left, quiet)
+	rightQuiet := e.value("or i%d %s, %d", bits, right, quiet)
+	// SUB never toggles a NaN's sign/payload, only its finite/inf operand sign.
+	nan := e.value("select i1 %s, i%d %s, i%d %s", leftNaN, bits, leftQuiet, bits, rightQuiet)
+	anyNaN := e.value("or i1 %s, %s", leftNaN, rightNaN)
+	signs := e.value("xor i%d %s, %s", bits, left, rightSigned)
+	opposite := e.value("icmp slt i%d %s, 0", bits, signs)
+	bothInf := e.value("and i1 %s, %s", leftInf, rightInf)
+	invalid := e.value("and i1 %s, %s", bothInf, opposite)
+	infinity := e.value("select i1 %s, i%d %s, i%d %s", leftInf, bits, left, bits, rightSigned)
+	infinity = e.value("select i1 %s, i%d %d, i%d %s", invalid, bits, sign|exponent|quiet, bits, infinity)
+	result = e.value("select i1 %s, i%d %s, i%d %s", anyNaN, bits, nan, bits, infinity)
+	return
+}
+
+func emitX86FloatAddSubSpecialHelper(b *strings.Builder, bits int) {
+	typ := amd64FMA3LLVMType(1, bits)
+	fmt.Fprintf(b, "define internal %s @__plan9asm_add_sub_special_f%d(%s %%left, %s %%right, i1 %%subtract, %s %%hardware) {\nentry:\n", typ, bits, typ, typ, typ)
+	e := amd64FMA3IntegerEmitter{b: b}
+	special, result, _ := emitX86FloatAddSubSpecialBits(&e, bits)
+	floatResult := e.value("bitcast i%d %s to %s", bits, result, typ)
+	selected := e.value("select i1 %s, %s %s, %s %%hardware", special, typ, floatResult, typ)
+	fmt.Fprintf(b, "  ret %s %s\n}\n\n", typ, selected)
+}
+
+// Embedded rounding suppresses exceptions. Only finite binary arithmetic
+// uses the reviewed exact accumulator (a*1+b); special results remain ADD/SUB
+// semantics rather than FMA's operand priority.
+func emitX86FloatAddSubRoundingHelper(b *strings.Builder, bits int) {
+	typ := amd64FMA3LLVMType(1, bits)
+	fmt.Fprintf(b, "define internal %s @__plan9asm_add_sub_round_f%d(%s %%left, %s %%right, i1 %%subtract, i32 %%mode, i32 %%mxcsr) {\nentry:\n", typ, bits, typ, typ)
+	e := amd64FMA3IntegerEmitter{b: b}
+	special, result, rightSigned := emitX86FloatAddSubSpecialBits(&e, bits)
+	fmt.Fprintf(b, "  br i1 %s, label %%special, label %%finite\nspecial:\n", special)
+	floatResult := e.value("bitcast i%d %s to %s", bits, result, typ)
+	fmt.Fprintf(b, "  ret %s %s\nfinite:\n", typ, floatResult)
+	rightFloat := e.value("bitcast i%d %s to %s", bits, rightSigned, typ)
+	finite := e.value("call %s @__plan9asm_fma3_round_f%d(%s %%left, %s 1.0, %s %s, i32 %%mode, i32 %%mxcsr)", typ, bits, typ, typ, typ, rightFloat)
+	fmt.Fprintf(b, "  ret %s %s\n}\n\n", typ, finite)
+}
+
+func (c *amd64Ctx) emitRoundedFloatAddSub(lanes, bits int, left, right string, subtract bool, rounding string) string {
+	typ, vectorType := amd64FMA3LLVMType(1, bits), amd64FMA3LLVMType(lanes, bits)
+	mode, mxcsr := c.packedNumericRoundingMode(rounding), c.loadMXCSR()
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		values := []string{left, right}
+		if lanes > 1 {
+			for index, value := range values {
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", extracted, vectorType, value, lane)
+				values[index] = "%" + extracted
+			}
+		}
+		computed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @__plan9asm_add_sub_round_f%d(%s %s, %s %s, i1 %t, i32 %s, i32 %s)\n", computed, typ, bits, typ, values[0], typ, values[1], subtract, mode, mxcsr)
+		if lanes == 1 {
+			return "%" + computed
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, vectorType, result, typ, computed, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_float_min_max.go b/amd64_lower_float_min_max.go
new file mode 100644
index 000000000..2f4aaf5cc
--- /dev/null
+++ b/amd64_lower_float_min_max.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+func (c *amd64Ctx) lowerFloatMinMax(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerFloatArithmetic(op, ins, x86FloatMinimumMaximum)
+}
+
+func (c *amd64Ctx) lowerFloatMinMaxForm(ins Instr, f x86FloatMinMaxForm) (bool, bool, error) {
+	if (ins.x86Encoded || ins.x86SourceRaw != nil) && !x86RawFloatMinMaxEncodingSource(ins, c.goarch) {
+		return true, false, fmt.Errorf("%w: MIN/MAX original physical source identity changed", ErrProbeNeedsContext)
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		if f.legacy && !f.scalar && f.memory >= 0 {
+			return true, false, c.lowerLegacyPackedFloatingMemory(ins, f.x86FloatBinaryForm)
+		}
+		lanes := f.byteWidth * 8 / f.bits
+		logicalFPBits := 0
+		if f.scalar {
+			lanes = 1
+			logicalFPBits = f.bits
+		}
+		evex := x86FloatMinMaxNativeEVEX(ins, f)
+		return true, false, c.emitNativeFloatingOperands(ins, x86NativeFloatingOperands{
+			byteWidth: f.byteWidth, lanes: lanes, memoryBytes: f.memoryBytes,
+			second: f.second, destination: f.destination, mask: f.mask,
+			controls: amd64FMA3Suffix{broadcast: f.broadcast, zeroing: f.zeroing},
+			sae:      f.sae, legacy: f.legacy, logicalFPBits: logicalFPBits,
+			lowBank: !evex, forceEVEX: evex && f.byteWidth < 64 && f.mask < 0 && !f.sae && !f.broadcast,
+		})
+	}
+	// Portable numerical values do not certify x86 MXCSR or native exceptions.
+	return c.lowerFloatBinaryOperands(ins, f.x86FloatBinaryForm,
+		func(lanes int, left, right, _ string) string {
+			typ := amd64FMA3LLVMType(lanes, f.bits)
+			predicate := "ogt"
+			if f.spec.mode == amd64BinaryFloatingMin {
+				predicate = "olt"
+			}
+			condition, value := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = fcmp %s %s %s, %s\n", condition, predicate, typ, left, right)
+			predicateType := "i1"
+			if lanes > 1 {
+				predicateType = fmt.Sprintf("<%d x i1>", lanes)
+			}
+			// Native MIN/MAX chooses the first explicit Go source for equal
+			// values and unordered pairs. Keep its original NaN/zero bits.
+			fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", value, predicateType, condition, typ, left, typ, right)
+			return "%" + value
+		})
+}
diff --git a/amd64_lower_float_movemask_test.go b/amd64_lower_float_movemask_test.go
new file mode 100644
index 000000000..995424748
--- /dev/null
+++ b/amd64_lower_float_movemask_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86FloatingMoveMaskCompleteGoAssemblerForms(t *testing.T) {
+	// MOVMSK{PS,PD} uses Go's legacy yxrrl table (X -> Yrl), while the
+	// VMOVMSK forms use _yvmovmskpd (X/Y -> Yrl). Neither table accepts
+	// memory, EVEX registers, masks, or opcode suffixes.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastLegacyX := 15
+			if target.goarch == "386" {
+				lastLegacyX = 7
+			}
+			source := fmt.Sprintf(`
+TEXT floatingmovemaskforms(SB),NOSPLIT,$0-0
+	MOVMSKPS X%d, AX
+	MOVMSKPD X%d, BX
+	VMOVMSKPS X15, CX
+	VMOVMSKPS Y15, DX
+	VMOVMSKPD X15, SI
+	VMOVMSKPD Y15, DI
+	RET
+`, lastLegacyX, lastLegacyX)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"floatingmovemaskforms": {Name: "floatingmovemaskforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "floating-movemask-"+target.name+".ll", "floating-movemask-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86FloatingMoveMaskRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVMSKPS Y0, AX",
+		"MOVMSKPD (AX), BX",
+		"MOVMSKPS X16, AX",
+		"VMOVMSKPS Z0, AX",
+		"VMOVMSKPD X16, AX",
+		"VMOVMSKPS Y16, AX",
+		"VMOVMSKPD (AX), BX",
+		"VMOVMSKPS X0, X1",
+		"VMOVMSKPD X0, K1, AX",
+		"MOVMSKPS.Z X0, AX",
+		"VMOVMSKPD.BCST Y0, AX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86FloatingMoveMaskRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86FloatingMoveMaskRejected(t, "386", "i386-unknown-linux-gnu", "MOVMSKPS X8, AX")
+}
+
+func assertX86FloatingMoveMaskRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's floating movemask forms", instruction)
+	}
+}
diff --git a/amd64_lower_float_mul_div.go b/amd64_lower_float_mul_div.go
new file mode 100644
index 000000000..2b08e2e98
--- /dev/null
+++ b/amd64_lower_float_mul_div.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerFloatMulDiv(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerFloatArithmetic(op, ins, x86FloatMultiplyDivide)
+}
+
+func (c *amd64Ctx) lowerFloatMulDivForm(ins Instr, form x86FloatMulDivForm) (bool, bool, error) {
+	return c.lowerFloatBinaryOperands(ins, form.x86FloatBinaryForm, func(lanes int, left, right, mask string) string {
+		if form.rounding != "" {
+			return c.emitRoundedFloatMulDiv(form, lanes, left, right)
+		}
+		operation := "fmul"
+		if form.spec.mode == amd64BinaryFloatingDiv {
+			operation = "fdiv"
+		}
+		return c.emitStrictFloatBinary(form.x86FloatBinaryForm, operation, lanes, left, right, mask, func(lanes int, left, right, value string) string {
+			return c.emitFloatBinaryNaNPriority(form.bits, lanes, left, right, value)
+		})
+	})
+}
+
+// LLVM may commute strict multiplication during legalization. Restore x86's
+// first-source NaN payload without executing another floating operation or
+// changing the real strict operation's sticky/rounding/DAZ/FTZ effects.
+func (c *amd64Ctx) emitFloatBinaryNaNPriority(bits, lanes int, left, right, hardware string) string {
+	typ := amd64FMA3LLVMType(lanes, bits)
+	integerType := fmt.Sprintf("<%d x i%d>", lanes, bits)
+	if lanes == 1 {
+		integerType = fmt.Sprintf("i%d", bits)
+	}
+	exponent, quiet := uint64(0x7f800000), uint64(0x400000)
+	if bits == 64 {
+		exponent, quiet = 0x7ff0000000000000, 0x8000000000000
+	}
+	constant := func(value uint64) string {
+		if lanes == 1 {
+			return fmt.Sprint(value)
+		}
+		values := make([]string, lanes)
+		for lane := range values {
+			values[lane] = fmt.Sprintf("i%d %d", bits, value)
+		}
+		return "<" + strings.Join(values, ", ") + ">"
+	}
+	values, nan, quieted := [2]string{left, right}, [2]string{}, [2]string{}
+	for index, value := range values {
+		raw, magnitude, isNaN, withQuiet := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", raw, typ, value, integerType)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", magnitude, integerType, raw, constant(uint64(1)<<(bits-1)-1))
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %%%s, %s\n", isNaN, integerType, magnitude, constant(exponent))
+		fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %s\n", withQuiet, integerType, raw, constant(quiet))
+		nan[index], quieted[index] = "%"+isNaN, "%"+withQuiet
+	}
+	predicateType := "i1"
+	if lanes > 1 {
+		predicateType = fmt.Sprintf("<%d x i1>", lanes)
+	}
+	anyNaN, chosen, selected, rawHardware := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %s, %s\n", anyNaN, predicateType, nan[0], nan[1])
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", chosen, predicateType, nan[0], integerType, quieted[0], integerType, quieted[1])
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", rawHardware, typ, hardware, integerType)
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %%%s, %s %%%s\n", selected, predicateType, anyNaN, integerType, chosen, integerType, rawHardware)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", result, integerType, selected, typ)
+	return "%" + result
+}
+
+func (c *amd64Ctx) emitRoundedFloatMulDiv(form x86FloatMulDivForm, lanes int, left, right string) string {
+	typ, vectorType := amd64FMA3LLVMType(1, form.bits), amd64FMA3LLVMType(lanes, form.bits)
+	mode, mxcsr := c.packedNumericRoundingMode(form.rounding), c.loadMXCSR()
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		values := [2]string{left, right}
+		if lanes > 1 {
+			for index, value := range values {
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", extracted, vectorType, value, lane)
+				values[index] = "%" + extracted
+			}
+		}
+		for index, floating := range values {
+			raw := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", raw, typ, floating, form.bits)
+			values[index] = "%" + raw
+		}
+		raw, value := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i%d @__plan9asm_mul_div_round_f%d(i%d %s, i%d %s, i1 %t, i32 %s, i32 %s)\n", raw, form.bits, form.bits, form.bits, values[0], form.bits, values[1], (form.spec.mode == amd64BinaryFloatingDiv), mode, mxcsr)
+		fmt.Fprintf(c.b, "  %%%s = bitcast i%d %%%s to %s\n", value, form.bits, raw, typ)
+		if lanes == 1 {
+			return "%" + value
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, vectorType, result, typ, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_fma3.go b/amd64_lower_fma3.go
new file mode 100644
index 000000000..9f620ed3e
--- /dev/null
+++ b/amd64_lower_fma3.go
@@ -0,0 +1,432 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FMA3Mode uint8
+
+const (
+	amd64FMA3Add amd64FMA3Mode = iota
+	amd64FMA3Sub
+	amd64FMA3NegAdd
+	amd64FMA3NegSub
+	amd64FMA3AddSub
+	amd64FMA3SubAdd
+)
+
+type amd64FMA3Spec struct {
+	laneBits int
+	order    int
+	mode     amd64FMA3Mode
+	scalar   bool
+	rawOnly  bool
+}
+
+// amd64FMA3Specs is the complete Go 1.27 FMA3 family. The 36 packed
+// instructions use _yvaddpd and the 24 scalar instructions use _yvaddsd.
+// The additional 30 MAP6 FP16 forms are accepted only from raw bytes.
+var amd64FMA3Specs = map[Op]amd64FMA3Spec{
+	"VFMADD132PS":    {laneBits: 32, order: 132, mode: amd64FMA3Add},
+	"VFMADD132PD":    {laneBits: 64, order: 132, mode: amd64FMA3Add},
+	"VFMADD132SS":    {laneBits: 32, order: 132, mode: amd64FMA3Add, scalar: true},
+	"VFMADD132SD":    {laneBits: 64, order: 132, mode: amd64FMA3Add, scalar: true},
+	"VFMADD213PS":    {laneBits: 32, order: 213, mode: amd64FMA3Add},
+	"VFMADD213PD":    {laneBits: 64, order: 213, mode: amd64FMA3Add},
+	"VFMADD213SS":    {laneBits: 32, order: 213, mode: amd64FMA3Add, scalar: true},
+	"VFMADD213SD":    {laneBits: 64, order: 213, mode: amd64FMA3Add, scalar: true},
+	"VFMADD231PS":    {laneBits: 32, order: 231, mode: amd64FMA3Add},
+	"VFMADD231PD":    {laneBits: 64, order: 231, mode: amd64FMA3Add},
+	"VFMADD231SS":    {laneBits: 32, order: 231, mode: amd64FMA3Add, scalar: true},
+	"VFMADD231SD":    {laneBits: 64, order: 231, mode: amd64FMA3Add, scalar: true},
+	"VFMSUB132PS":    {laneBits: 32, order: 132, mode: amd64FMA3Sub},
+	"VFMSUB132PD":    {laneBits: 64, order: 132, mode: amd64FMA3Sub},
+	"VFMSUB132SS":    {laneBits: 32, order: 132, mode: amd64FMA3Sub, scalar: true},
+	"VFMSUB132SD":    {laneBits: 64, order: 132, mode: amd64FMA3Sub, scalar: true},
+	"VFMSUB213PS":    {laneBits: 32, order: 213, mode: amd64FMA3Sub},
+	"VFMSUB213PD":    {laneBits: 64, order: 213, mode: amd64FMA3Sub},
+	"VFMSUB213SS":    {laneBits: 32, order: 213, mode: amd64FMA3Sub, scalar: true},
+	"VFMSUB213SD":    {laneBits: 64, order: 213, mode: amd64FMA3Sub, scalar: true},
+	"VFMSUB231PS":    {laneBits: 32, order: 231, mode: amd64FMA3Sub},
+	"VFMSUB231PD":    {laneBits: 64, order: 231, mode: amd64FMA3Sub},
+	"VFMSUB231SS":    {laneBits: 32, order: 231, mode: amd64FMA3Sub, scalar: true},
+	"VFMSUB231SD":    {laneBits: 64, order: 231, mode: amd64FMA3Sub, scalar: true},
+	"VFNMADD132PS":   {laneBits: 32, order: 132, mode: amd64FMA3NegAdd},
+	"VFNMADD132PD":   {laneBits: 64, order: 132, mode: amd64FMA3NegAdd},
+	"VFNMADD132SS":   {laneBits: 32, order: 132, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMADD132SD":   {laneBits: 64, order: 132, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMADD213PS":   {laneBits: 32, order: 213, mode: amd64FMA3NegAdd},
+	"VFNMADD213PD":   {laneBits: 64, order: 213, mode: amd64FMA3NegAdd},
+	"VFNMADD213SS":   {laneBits: 32, order: 213, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMADD213SD":   {laneBits: 64, order: 213, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMADD231PS":   {laneBits: 32, order: 231, mode: amd64FMA3NegAdd},
+	"VFNMADD231PD":   {laneBits: 64, order: 231, mode: amd64FMA3NegAdd},
+	"VFNMADD231SS":   {laneBits: 32, order: 231, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMADD231SD":   {laneBits: 64, order: 231, mode: amd64FMA3NegAdd, scalar: true},
+	"VFNMSUB132PS":   {laneBits: 32, order: 132, mode: amd64FMA3NegSub},
+	"VFNMSUB132PD":   {laneBits: 64, order: 132, mode: amd64FMA3NegSub},
+	"VFNMSUB132SS":   {laneBits: 32, order: 132, mode: amd64FMA3NegSub, scalar: true},
+	"VFNMSUB132SD":   {laneBits: 64, order: 132, mode: amd64FMA3NegSub, scalar: true},
+	"VFNMSUB213PS":   {laneBits: 32, order: 213, mode: amd64FMA3NegSub},
+	"VFNMSUB213PD":   {laneBits: 64, order: 213, mode: amd64FMA3NegSub},
+	"VFNMSUB213SS":   {laneBits: 32, order: 213, mode: amd64FMA3NegSub, scalar: true},
+	"VFNMSUB213SD":   {laneBits: 64, order: 213, mode: amd64FMA3NegSub, scalar: true},
+	"VFNMSUB231PS":   {laneBits: 32, order: 231, mode: amd64FMA3NegSub},
+	"VFNMSUB231PD":   {laneBits: 64, order: 231, mode: amd64FMA3NegSub},
+	"VFNMSUB231SS":   {laneBits: 32, order: 231, mode: amd64FMA3NegSub, scalar: true},
+	"VFNMSUB231SD":   {laneBits: 64, order: 231, mode: amd64FMA3NegSub, scalar: true},
+	"VFMADDSUB132PS": {laneBits: 32, order: 132, mode: amd64FMA3AddSub},
+	"VFMADDSUB132PD": {laneBits: 64, order: 132, mode: amd64FMA3AddSub},
+	"VFMADDSUB213PS": {laneBits: 32, order: 213, mode: amd64FMA3AddSub},
+	"VFMADDSUB213PD": {laneBits: 64, order: 213, mode: amd64FMA3AddSub},
+	"VFMADDSUB231PS": {laneBits: 32, order: 231, mode: amd64FMA3AddSub},
+	"VFMADDSUB231PD": {laneBits: 64, order: 231, mode: amd64FMA3AddSub},
+	"VFMSUBADD132PS": {laneBits: 32, order: 132, mode: amd64FMA3SubAdd},
+	"VFMSUBADD132PD": {laneBits: 64, order: 132, mode: amd64FMA3SubAdd},
+	"VFMSUBADD213PS": {laneBits: 32, order: 213, mode: amd64FMA3SubAdd},
+	"VFMSUBADD213PD": {laneBits: 64, order: 213, mode: amd64FMA3SubAdd},
+	"VFMSUBADD231PS": {laneBits: 32, order: 231, mode: amd64FMA3SubAdd},
+	"VFMSUBADD231PD": {laneBits: 64, order: 231, mode: amd64FMA3SubAdd},
+	"VFMADD132PH":    {laneBits: 16, order: 132, mode: amd64FMA3Add, rawOnly: true},
+	"VFMADD132SH":    {laneBits: 16, order: 132, mode: amd64FMA3Add, scalar: true, rawOnly: true},
+	"VFMSUB132PH":    {laneBits: 16, order: 132, mode: amd64FMA3Sub, rawOnly: true},
+	"VFMSUB132SH":    {laneBits: 16, order: 132, mode: amd64FMA3Sub, scalar: true, rawOnly: true},
+	"VFNMADD132PH":   {laneBits: 16, order: 132, mode: amd64FMA3NegAdd, rawOnly: true},
+	"VFNMADD132SH":   {laneBits: 16, order: 132, mode: amd64FMA3NegAdd, scalar: true, rawOnly: true},
+	"VFNMSUB132PH":   {laneBits: 16, order: 132, mode: amd64FMA3NegSub, rawOnly: true},
+	"VFNMSUB132SH":   {laneBits: 16, order: 132, mode: amd64FMA3NegSub, scalar: true, rawOnly: true},
+	"VFMADDSUB132PH": {laneBits: 16, order: 132, mode: amd64FMA3AddSub, rawOnly: true},
+	"VFMSUBADD132PH": {laneBits: 16, order: 132, mode: amd64FMA3SubAdd, rawOnly: true},
+	"VFMADD213PH":    {laneBits: 16, order: 213, mode: amd64FMA3Add, rawOnly: true},
+	"VFMADD213SH":    {laneBits: 16, order: 213, mode: amd64FMA3Add, scalar: true, rawOnly: true},
+	"VFMSUB213PH":    {laneBits: 16, order: 213, mode: amd64FMA3Sub, rawOnly: true},
+	"VFMSUB213SH":    {laneBits: 16, order: 213, mode: amd64FMA3Sub, scalar: true, rawOnly: true},
+	"VFNMADD213PH":   {laneBits: 16, order: 213, mode: amd64FMA3NegAdd, rawOnly: true},
+	"VFNMADD213SH":   {laneBits: 16, order: 213, mode: amd64FMA3NegAdd, scalar: true, rawOnly: true},
+	"VFNMSUB213PH":   {laneBits: 16, order: 213, mode: amd64FMA3NegSub, rawOnly: true},
+	"VFNMSUB213SH":   {laneBits: 16, order: 213, mode: amd64FMA3NegSub, scalar: true, rawOnly: true},
+	"VFMADDSUB213PH": {laneBits: 16, order: 213, mode: amd64FMA3AddSub, rawOnly: true},
+	"VFMSUBADD213PH": {laneBits: 16, order: 213, mode: amd64FMA3SubAdd, rawOnly: true},
+	"VFMADD231PH":    {laneBits: 16, order: 231, mode: amd64FMA3Add, rawOnly: true},
+	"VFMADD231SH":    {laneBits: 16, order: 231, mode: amd64FMA3Add, scalar: true, rawOnly: true},
+	"VFMSUB231PH":    {laneBits: 16, order: 231, mode: amd64FMA3Sub, rawOnly: true},
+	"VFMSUB231SH":    {laneBits: 16, order: 231, mode: amd64FMA3Sub, scalar: true, rawOnly: true},
+	"VFNMADD231PH":   {laneBits: 16, order: 231, mode: amd64FMA3NegAdd, rawOnly: true},
+	"VFNMADD231SH":   {laneBits: 16, order: 231, mode: amd64FMA3NegAdd, scalar: true, rawOnly: true},
+	"VFNMSUB231PH":   {laneBits: 16, order: 231, mode: amd64FMA3NegSub, rawOnly: true},
+	"VFNMSUB231SH":   {laneBits: 16, order: 231, mode: amd64FMA3NegSub, scalar: true, rawOnly: true},
+	"VFMADDSUB231PH": {laneBits: 16, order: 231, mode: amd64FMA3AddSub, rawOnly: true},
+	"VFMSUBADD231PH": {laneBits: 16, order: 231, mode: amd64FMA3SubAdd, rawOnly: true},
+}
+
+type amd64FMA3Suffix struct {
+	broadcast bool
+	zeroing   bool
+	rounding  string
+}
+
+func parseAMD64FMA3Suffix(suffix string) (amd64FMA3Suffix, bool) {
+	switch suffix {
+	case "":
+		return amd64FMA3Suffix{}, true
+	case "Z":
+		return amd64FMA3Suffix{zeroing: true}, true
+	case "BCST":
+		return amd64FMA3Suffix{broadcast: true}, true
+	case "BCST.Z":
+		return amd64FMA3Suffix{broadcast: true, zeroing: true}, true
+	case "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE":
+		return amd64FMA3Suffix{rounding: suffix}, true
+	case "RN_SAE.Z", "RD_SAE.Z", "RU_SAE.Z", "RZ_SAE.Z":
+		return amd64FMA3Suffix{zeroing: true, rounding: strings.TrimSuffix(suffix, ".Z")}, true
+	default:
+		return amd64FMA3Suffix{}, false
+	}
+}
+
+func (c *amd64Ctx) lowerFMA3(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, recognized := amd64FMA3Specs[Op(base)]; !recognized {
+		return false, false, nil
+	}
+	// Bind only a local copy for legacy helpers. A dispatch/source conflict
+	// must be rejected before reading a register or emitting any LLVM IR.
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("FMA3 dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := amd64FMA3Properties(ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	spec, properties := form.spec, form.suffix
+	dstArg, byteWidth := ins.Args[form.destination], form.byteWidth
+	if spec.rawOnly && x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		lanes := byteWidth * 8 / spec.laneBits
+		if spec.scalar {
+			lanes = 1
+		}
+		return true, false, c.emitNativeFP16ThreeOperand(ins, x86NativeFP16ThreeOperand{
+			byteWidth: byteWidth, lanes: lanes, memoryBytes: form.memoryBytes,
+			second: 1, destination: form.destination, mask: form.mask,
+			controls: properties, readDestination: true,
+		})
+	}
+	named := x86ResultNamedPredicateInstruction(ins) && ins.x86FMA3Encoding == x86RawFMA3Absent
+	raw := !spec.rawOnly && (x86RawFMA3Source(ins, c.goarch) || x86RawFMA3LiteralForm(ins, c.goarch))
+	if !spec.rawOnly && (named || raw) && x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		lanes, logicalFPBits := byteWidth*8/spec.laneBits, 0
+		if spec.scalar {
+			lanes, logicalFPBits = 1, spec.laneBits
+		}
+		evex := x86FMA3NativeEVEX(ins, form)
+		return true, false, c.emitNativeFloatingOperands(ins, x86NativeFloatingOperands{
+			byteWidth: byteWidth, lanes: lanes, memoryBytes: form.memoryBytes,
+			second: 1, destination: form.destination, mask: form.mask,
+			controls: properties, readDestination: true, logicalFPBits: logicalFPBits,
+			lowBank: !evex, forceEVEX: evex && byteWidth < 64 && form.mask < 0 &&
+				!properties.broadcast && properties.rounding == "",
+		})
+	}
+	if !spec.rawOnly && !named {
+		return true, false, fmt.Errorf("%w: %s requires its exact original FMA source and native x86 target", ErrProbeNeedsContext, ins.Op)
+	}
+
+	// Portable numerical arithmetic is not an x86 MXCSR/native-exception
+	// certificate. Raw F32/F64 still requires its independent source owner.
+	var mask string
+	if form.mask >= 0 {
+		loadedMask, loadErr := c.loadK(ins.Args[form.mask].Reg)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		mask = loadedMask
+	}
+	if spec.scalar {
+		return c.lowerScalarFMA3(spec, properties, ins, dstArg, mask)
+	}
+	return c.lowerPackedFMA3(spec, properties, ins, dstArg, byteWidth, mask)
+}
+
+func (c *amd64Ctx) lowerPackedFMA3(spec amd64FMA3Spec, properties amd64FMA3Suffix, ins Instr, dstArg Operand, byteWidth int, mask string) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	llvmType := amd64FMA3LLVMType(lanes, spec.laneBits)
+	loadLanes := c.loadMaskedPackedCompareLanes
+	if !spec.rawOnly && x86ResultNamedPredicateInstruction(ins) &&
+		(ins.Args[0].Kind == OpMem || ins.Args[0].Kind == OpSym) {
+		// This portable continuation still owes the original native access,
+		// including dead results and per-lane/broadcast mask suppression.
+		// Logical FP slots and independently owned raw forms stay separate.
+		loadLanes = c.loadX86PackedShiftLanes
+	}
+	load := func(arg Operand, allowBroadcast bool) (string, error) {
+		sourceMask := ""
+		if allowBroadcast {
+			sourceMask = mask
+		}
+		bits, err := loadLanes(arg, byteWidth, spec.laneBits, allowBroadcast && properties.broadcast, sourceMask)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", value, lanes, spec.laneBits, bits, llvmType)
+		return "%" + value, nil
+	}
+	first, err := load(ins.Args[0], true)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := load(ins.Args[1], false)
+	if err != nil {
+		return true, false, err
+	}
+	old, err := load(dstArg, false)
+	if err != nil {
+		return true, false, err
+	}
+	computed := c.emitFMA3(spec, llvmType, lanes, first, second, old, properties.rounding)
+	if mask != "" {
+		computedBits := c.newTmp()
+		oldBits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i%d>\n", computedBits, llvmType, computed, lanes, spec.laneBits)
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i%d>\n", oldBits, llvmType, old, lanes, spec.laneBits)
+		masked := amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, "%"+computedBits, "%"+oldBits, mask, properties.zeroing)
+		back := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to %s\n", back, lanes, spec.laneBits, masked, llvmType)
+		computed = "%" + back
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, llvmType, computed, byteWidth)
+	return true, false, c.storePackedMoveOperand(dstArg, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarFMA3(spec amd64FMA3Spec, properties amd64FMA3Suffix, ins Instr, dstArg Operand, mask string) (bool, bool, error) {
+	loadFirst := c.loadFMA3Scalar
+	if !spec.rawOnly && x86ResultNamedPredicateInstruction(ins) &&
+		(ins.Args[0].Kind == OpMem || ins.Args[0].Kind == OpSym) {
+		loadFirst = c.loadFMA3ObservableScalar
+	}
+	first, err := loadFirst(ins.Args[0], spec.laneBits, mask)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadFMA3Scalar(ins.Args[1], spec.laneBits, "")
+	if err != nil {
+		return true, false, err
+	}
+	old, err := c.loadFMA3Scalar(dstArg, spec.laneBits, "")
+	if err != nil {
+		return true, false, err
+	}
+	llvmType := amd64FMA3LLVMType(1, spec.laneBits)
+	computed := c.emitFMA3(spec, llvmType, 1, first, second, old, properties.rounding)
+	destinationBytes, err := c.loadX(dstArg.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / spec.laneBits
+	base := c.bitcastVectorBytesToIntegerLanes(16, lanes, spec.laneBits, destinationBytes)
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", bits, llvmType, computed, spec.laneBits)
+	return true, false, c.storeScalarMoveRegister(dstArg.Reg, spec.laneBits, "%"+bits, base, mask, properties.zeroing)
+}
+
+// Only the already validated named FMA memory continuation uses this reader.
+// One guarded volatile lane preserves its exact m32/m64 access independently
+// of the numerical result. It does not certify x86 MXCSR or FP exceptions.
+func (c *amd64Ctx) loadFMA3ObservableScalar(source Operand, laneBits int, mask string) (string, error) {
+	bits, err := c.loadX86PackedShiftLanes(source, laneBits/8, laneBits, false, mask)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <1 x i%d> %s to %s\n", value, laneBits, bits, amd64FMA3LLVMType(1, laneBits))
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) loadFMA3Scalar(arg Operand, laneBits int, mask string) (string, error) {
+	var bits string
+	var err error
+	if arg.Kind == OpReg {
+		bits, err = c.loadXLowInteger(arg.Reg, laneBits)
+	} else if mask != "" {
+		bits, err = c.loadVectorScalarMemory(arg, laneBits, mask)
+	} else {
+		bits, err = c.evalIntSized(arg, amd64IntegerTypeForBits(laneBits))
+	}
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to %s\n", value, laneBits, bits, amd64FMA3LLVMType(1, laneBits))
+	return "%" + value, nil
+}
+
+func amd64FMA3LLVMType(lanes, laneBits int) string {
+	element := "float"
+	if laneBits == 16 {
+		element = "half"
+	} else if laneBits == 64 {
+		element = "double"
+	}
+	if lanes == 1 {
+		return element
+	}
+	return fmt.Sprintf("<%d x %s>", lanes, element)
+}
+
+func (c *amd64Ctx) splatFMA3Scalar(lanes, laneBits int, scalar string) string {
+	typeName := amd64FMA3LLVMType(lanes, laneBits)
+	element := amd64FMA3LLVMType(1, laneBits)
+	seed := c.newTmp()
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, %s %s, i32 0\n", seed, typeName, element, scalar)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <%d x i32> zeroinitializer\n", splat, typeName, seed, typeName, lanes)
+	return "%" + splat
+}
+
+func (c *amd64Ctx) emitFMA3(spec amd64FMA3Spec, llvmType string, lanes int, first, second, old, rounding string) string {
+	a, b, addend := old, first, second
+	switch spec.order {
+	case 213:
+		a, b, addend = second, old, first
+	case 231:
+		a, b, addend = second, first, old
+	}
+	if spec.mode == amd64FMA3NegAdd || spec.mode == amd64FMA3NegSub {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negated, llvmType, a)
+		a = "%" + negated
+	}
+	switch spec.mode {
+	case amd64FMA3Sub, amd64FMA3NegSub:
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negated, llvmType, addend)
+		addend = "%" + negated
+	case amd64FMA3AddSub, amd64FMA3SubAdd:
+		addend = c.alternateFMA3Addend(llvmType, lanes, addend, spec.mode == amd64FMA3AddSub)
+	}
+	if rounding != "" && !spec.rawOnly {
+		return c.emitRoundedFMA3(lanes, spec.laneBits, a, b, addend, rounding)
+	}
+	result := c.newTmp()
+	intrinsic := amd64FMA3IntrinsicName(lanes, spec.laneBits, rounding != "")
+	if rounding == "" {
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, %s %s)\n", result, llvmType, intrinsic, llvmType, a, llvmType, b, llvmType, addend)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, %s %s, metadata !\"%s\", metadata !\"fpexcept.ignore\")\n", result, llvmType, intrinsic, llvmType, a, llvmType, b, llvmType, addend, amd64FMA3RoundingMetadata(rounding))
+	}
+	return "%" + result
+}
+
+func (c *amd64Ctx) alternateFMA3Addend(llvmType string, lanes int, addend string, negateEven bool) string {
+	negated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negated, llvmType, addend)
+	var mask strings.Builder
+	mask.WriteByte('<')
+	for lane := 0; lane < lanes; lane++ {
+		if lane > 0 {
+			mask.WriteString(", ")
+		}
+		selected := lane%2 == 0
+		if !negateEven {
+			selected = !selected
+		}
+		fmt.Fprintf(&mask, "i1 %t", selected)
+	}
+	mask.WriteByte('>')
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %s, %s %%%s, %s %s\n", result, lanes, mask.String(), llvmType, negated, llvmType, addend)
+	return "%" + result
+}
+
+func amd64FMA3IntrinsicName(lanes, laneBits int, constrained bool) string {
+	prefix := "llvm.fma."
+	if constrained {
+		prefix = "llvm.experimental.constrained.fma."
+	}
+	suffix := "f32"
+	if laneBits == 16 {
+		suffix = "f16"
+	} else if laneBits == 64 {
+		suffix = "f64"
+	}
+	if lanes > 1 {
+		suffix = fmt.Sprintf("v%d%s", lanes, suffix)
+	}
+	return prefix + suffix
+}
+
+func amd64FMA3RoundingMetadata(rounding string) string {
+	switch rounding {
+	case "RD_SAE":
+		return "round.downward"
+	case "RU_SAE":
+		return "round.upward"
+	case "RZ_SAE":
+		return "round.towardzero"
+	default:
+		return "round.tonearest"
+	}
+}
diff --git a/amd64_lower_fma3_round.go b/amd64_lower_fma3_round.go
new file mode 100644
index 000000000..1498a0083
--- /dev/null
+++ b/amd64_lower_fma3_round.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// LLVM 22 can lower fixed-rounding constrained FMA to an ambient-rounding
+// libcall. Accumulate the exact product and addend with guard/sticky bits
+// instead. The product needs at most 106 bits; a 128-bit accumulator retains
+// every cancellation bit and enough low bits for one final IEEE rounding.
+type amd64FMA3IntegerEmitter struct {
+	b    *strings.Builder
+	next int
+}
+
+func (e *amd64FMA3IntegerEmitter) value(format string, args ...any) string {
+	name := fmt.Sprintf("%%fma%d", e.next)
+	e.next++
+	fmt.Fprintf(e.b, "  %s = %s\n", name, fmt.Sprintf(format, args...))
+	return name
+}
+
+type amd64FMA3IntegerInput struct {
+	negative, magnitude, exponent, finite, floating string
+}
+
+func (e *amd64FMA3IntegerEmitter) input(bits int, value, daz string) amd64FMA3IntegerInput {
+	fractionBits, bias := 23, 127
+	if bits == 64 {
+		fractionBits, bias = 52, 1023
+	}
+	fractionMask := uint64(1)<<fractionBits - 1
+	exponentMask := 2*bias + 1
+	raw := e.value("bitcast %s %s to i%d", amd64FMA3LLVMType(1, bits), value, bits)
+	negative := e.value("icmp slt i%d %s, 0", bits, raw)
+	fraction := e.value("and i%d %s, %d", bits, raw, fractionMask)
+	shifted := e.value("lshr i%d %s, %d", bits, raw, fractionBits)
+	exponent := e.value("and i%d %s, %d", bits, shifted, exponentMask)
+	subnormal := e.value("icmp eq i%d %s, 0", bits, exponent)
+	normalMantissa := e.value("or i%d %s, %d", bits, fraction, uint64(1)<<fractionBits)
+	mantissa := e.value("select i1 %s, i%d %s, i%d %s", subnormal, bits, fraction, bits, normalMantissa)
+	flush := e.value("and i1 %s, %s", subnormal, daz)
+	signBits := e.value("and i%d %s, %d", bits, raw, uint64(1)<<(bits-1))
+	flushedBits := e.value("select i1 %s, i%d %s, i%d %s", flush, bits, signBits, bits, raw)
+	floating := e.value("bitcast i%d %s to %s", bits, flushedBits, amd64FMA3LLVMType(1, bits))
+	mantissa = e.value("select i1 %s, i%d 0, i%d %s", flush, bits, bits, mantissa)
+	magnitude := e.value("zext i%d %s to i128", bits, mantissa)
+	effectiveExponent := e.value("select i1 %s, i%d 1, i%d %s", subnormal, bits, bits, exponent)
+	if bits == 64 {
+		effectiveExponent = e.value("trunc i64 %s to i32", effectiveExponent)
+	}
+	unit := e.value("sub i32 %s, %d", effectiveExponent, bias+fractionBits)
+	finite := e.value("icmp ne i%d %s, %d", bits, exponent, exponentMask)
+	return amd64FMA3IntegerInput{negative, magnitude, unit, finite, floating}
+}
+
+// Shift right with jamming, never a poison out-of-range shift. Lost bits are
+// represented by bit zero. When loss occurs the other operand has at least
+// 21 exact trailing bits, so cancellation cannot erase the sticky witness.
+func (e *amd64FMA3IntegerEmitter) align(magnitude, exponent, unit string) string {
+	delta := e.value("sub i32 %s, %s", exponent, unit)
+	left := e.value("icmp sge i32 %s, 0", delta)
+	leftCount := e.value("select i1 %s, i32 %s, i32 0", left, delta)
+	leftFar := e.value("icmp ugt i32 %s, 127", leftCount)
+	leftCount = e.value("select i1 %s, i32 127, i32 %s", leftFar, leftCount)
+	leftCount = e.value("zext i32 %s to i128", leftCount)
+	shiftedLeft := e.value("shl i128 %s, %s", magnitude, leftCount)
+	rightCount := e.value("sub i32 0, %s", delta)
+	rightCount = e.value("select i1 %s, i32 0, i32 %s", left, rightCount)
+	tooFar := e.value("icmp uge i32 %s, 128", rightCount)
+	safe := e.value("select i1 %s, i32 127, i32 %s", tooFar, rightCount)
+	safe = e.value("zext i32 %s to i128", safe)
+	shiftedRight := e.value("lshr i128 %s, %s", magnitude, safe)
+	shiftedRight = e.value("select i1 %s, i128 0, i128 %s", tooFar, shiftedRight)
+	mask := e.value("shl i128 1, %s", safe)
+	mask = e.value("sub i128 %s, 1", mask)
+	lost := e.value("and i128 %s, %s", magnitude, mask)
+	lost = e.value("select i1 %s, i128 %s, i128 %s", tooFar, magnitude, lost)
+	sticky := e.value("icmp ne i128 %s, 0", lost)
+	sticky = e.value("zext i1 %s to i128", sticky)
+	jammed := e.value("or i128 %s, %s", shiftedRight, sticky)
+	return e.value("select i1 %s, i128 %s, i128 %s", left, shiftedLeft, jammed)
+}
+
+func emitAMD64FMA3RoundingHelpers(b *strings.Builder, file *File, goarch string) {
+	needed := make(map[int]bool)
+	addSubNeeded := make(map[int]bool)
+	addSubSpecial := make(map[int]bool)
+	mulDivNeeded := make(map[int]bool)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if form, known, err := x86FloatingHelperProperties(ins, goarch); known && err == nil {
+				base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+				if spec, scaled := amd64ScaledRoundSpecs[Op(base)]; scaled && spec.mode == amd64Reduce {
+					needed[form.spec.bits], addSubNeeded[form.spec.bits] = true, true
+				}
+			}
+			if form, known, err := x86FloatMulDivProperties(ins, goarch); known && err == nil && form.rounding != "" {
+				mulDivNeeded[form.bits] = true
+			}
+			if form, known, err := x86FloatAddSubProperties(ins, goarch); known && err == nil {
+				addSubSpecial[form.spec.bits] = true
+				if form.rounding != "" {
+					needed[form.spec.bits], addSubNeeded[form.spec.bits] = true, true
+				}
+			}
+			form, known, err := amd64FMA3Properties(ins, goarch)
+			if known && err == nil && form.suffix.rounding != "" && !form.spec.rawOnly {
+				needed[form.spec.laneBits] = true
+			}
+		}
+	}
+	if len(needed) == 0 && len(addSubSpecial) == 0 && len(mulDivNeeded) == 0 {
+		return
+	}
+	if len(needed) > 0 || len(mulDivNeeded) > 0 {
+		b.WriteString("declare i128 @llvm.ctlz.i128(i128, i1)\n")
+	}
+	for _, bits := range []int{32, 64} {
+		if mulDivNeeded[bits] {
+			emitX86FloatMulDivRoundingHelper(b, bits)
+		}
+		if addSubSpecial[bits] {
+			emitX86FloatAddSubSpecialHelper(b, bits)
+		}
+		if needed[bits] {
+			emitAMD64FMA3RoundingHelper(b, bits)
+			if addSubNeeded[bits] {
+				emitX86FloatAddSubRoundingHelper(b, bits)
+			}
+		}
+	}
+}
+
+func emitAMD64FMA3RoundingHelper(b *strings.Builder, bits int) {
+	fractionBits, bias := 23, 127
+	if bits == 64 {
+		fractionBits, bias = 52, 1023
+	}
+	floatType := amd64FMA3LLVMType(1, bits)
+	name := fmt.Sprintf("__plan9asm_fma3_round_f%d", bits)
+	fmt.Fprintf(b, "define internal %s @%s(%s %%a, %s %%b, %s %%c, i32 %%mode, i32 %%mxcsr) {\nentry:\n", floatType, name, floatType, floatType, floatType)
+	e := amd64FMA3IntegerEmitter{b: b}
+	daz := e.value("and i32 %%mxcsr, 64")
+	daz = e.value("icmp ne i32 %s, 0", daz)
+	a, multiplier, addend := e.input(bits, "%a", daz), e.input(bits, "%b", daz), e.input(bits, "%c", daz)
+	finite := e.value("and i1 %s, %s", a.finite, multiplier.finite)
+	finite = e.value("and i1 %s, %s", finite, addend.finite)
+	fmt.Fprintf(b, "  br i1 %s, label %%finite, label %%special\nspecial:\n", finite)
+	// Preserve the existing target's NaN/infinity behavior without executing
+	// a floating operation on the finite software path or changing host fenv.
+	fmt.Fprintf(b, "  %%special_result = call %s @llvm.fma.f%d(%s %s, %s %s, %s %s)\n  ret %s %%special_result\nfinite:\n", floatType, bits, floatType, a.floating, floatType, multiplier.floating, floatType, addend.floating, floatType)
+	product := e.value("mul i128 %s, %s", a.magnitude, multiplier.magnitude)
+	productExponent := e.value("add i32 %s, %s", a.exponent, multiplier.exponent)
+	productSign := e.value("xor i1 %s, %s", a.negative, multiplier.negative)
+	productTop := e.value("add i32 %s, %d", productExponent, 2*fractionBits+1)
+	addendTop := e.value("add i32 %s, %d", addend.exponent, fractionBits)
+	largerTop := e.value("icmp sgt i32 %s, %s", productTop, addendTop)
+	top := e.value("select i1 %s, i32 %s, i32 %s", largerTop, productTop, addendTop)
+	// A zero contribution has no exponent. In particular, a huge operand
+	// multiplied by zero must not erase a tiny nonzero addend into sticky.
+	originalTop := top
+	productZero := e.value("icmp eq i128 %s, 0", product)
+	addendZero := e.value("icmp eq i128 %s, 0", addend.magnitude)
+	top = e.value("select i1 %s, i32 %s, i32 %s", productZero, addendTop, top)
+	top = e.value("select i1 %s, i32 %s, i32 %s", addendZero, productTop, top)
+	bothZero := e.value("and i1 %s, %s", productZero, addendZero)
+	top = e.value("select i1 %s, i32 %s, i32 %s", bothZero, originalTop, top)
+	unit := e.value("sub i32 %s, 126", top)
+	product = e.align(product, productExponent, unit)
+	add := e.align(addend.magnitude, addend.exponent, unit)
+	sameSign := e.value("icmp eq i1 %s, %s", productSign, addend.negative)
+	productLarger := e.value("icmp uge i128 %s, %s", product, add)
+	sum := e.value("add i128 %s, %s", product, add)
+	difference := e.value("sub i128 %s, %s", product, add)
+	reverseDifference := e.value("sub i128 %s, %s", add, product)
+	difference = e.value("select i1 %s, i128 %s, i128 %s", productLarger, difference, reverseDifference)
+	magnitude := e.value("select i1 %s, i128 %s, i128 %s", sameSign, sum, difference)
+	negative := e.value("select i1 %s, i1 %s, i1 %s", productLarger, productSign, addend.negative)
+	zero := e.value("icmp eq i128 %s, 0", magnitude)
+	downward := e.value("icmp eq i32 %%mode, 1")
+	zeroSign := e.value("select i1 %s, i1 %s, i1 %s", sameSign, productSign, downward)
+	negative = e.value("select i1 %s, i1 %s, i1 %s", zero, zeroSign, negative)
+	leading := e.value("call i128 @llvm.ctlz.i128(i128 %s, i1 false)", magnitude)
+	leading = e.value("trunc i128 %s to i32", leading)
+	highest := e.value("sub i32 127, %s", leading)
+	normalShift := e.value("sub i32 %s, %d", highest, fractionBits)
+	subnormalShift := e.value("sub i32 %d, %s", 1-bias-fractionBits, unit)
+	isSubnormal := e.value("icmp sgt i32 %s, %s", subnormalShift, normalShift)
+	shift := e.value("select i1 %s, i32 %s, i32 %s", isSubnormal, subnormalShift, normalShift)
+	positiveShift := e.value("icmp sgt i32 %s, 0", shift)
+	far := e.value("icmp sge i32 %s, 128", shift)
+	safeRight := e.value("select i1 %s, i32 %s, i32 0", positiveShift, shift)
+	safeRight = e.value("select i1 %s, i32 127, i32 %s", far, safeRight)
+	safeRight = e.value("zext i32 %s to i128", safeRight)
+	right := e.value("lshr i128 %s, %s", magnitude, safeRight)
+	right = e.value("select i1 %s, i128 0, i128 %s", far, right)
+	leftCount := e.value("sub i32 0, %s", shift)
+	leftCount = e.value("select i1 %s, i32 0, i32 %s", positiveShift, leftCount)
+	leftCount = e.value("zext i32 %s to i128", leftCount)
+	left := e.value("shl i128 %s, %s", magnitude, leftCount)
+	unrounded := e.value("select i1 %s, i128 %s, i128 %s", positiveShift, right, left)
+	mask := e.value("shl i128 1, %s", safeRight)
+	mask = e.value("sub i128 %s, 1", mask)
+	remainder := e.value("and i128 %s, %s", magnitude, mask)
+	remainder = e.value("select i1 %s, i128 %s, i128 %s", far, magnitude, remainder)
+	inexact := e.value("icmp ne i128 %s, 0", remainder)
+	halfCount := e.value("sub i32 %s, 1", shift)
+	halfCount = e.value("select i1 %s, i32 %s, i32 0", positiveShift, halfCount)
+	halfFar := e.value("icmp ugt i32 %s, 127", halfCount)
+	halfCount = e.value("select i1 %s, i32 127, i32 %s", halfFar, halfCount)
+	halfCount = e.value("zext i32 %s to i128", halfCount)
+	half := e.value("shl i128 1, %s", halfCount)
+	above := e.value("icmp ugt i128 %s, %s", remainder, half)
+	tied := e.value("icmp eq i128 %s, %s", remainder, half)
+	odd := e.value("and i128 %s, 1", unrounded)
+	odd = e.value("icmp ne i128 %s, 0", odd)
+	tied = e.value("and i1 %s, %s", tied, odd)
+	nearest := e.value("or i1 %s, %s", above, tied)
+	validHalf := e.value("xor i1 %s, true", halfFar)
+	validHalf = e.value("and i1 %s, %s", validHalf, positiveShift)
+	nearest = e.value("and i1 %s, %s", nearest, validHalf)
+	upward := e.value("icmp eq i32 %%mode, 2")
+	positive := e.value("xor i1 %s, true", negative)
+	directed := e.value("and i1 %s, %s", downward, negative)
+	upwardPositive := e.value("and i1 %s, %s", upward, positive)
+	directed = e.value("or i1 %s, %s", directed, upwardPositive)
+	awayFromZero := directed
+	directed = e.value("and i1 %s, %s", directed, inexact)
+	isNearest := e.value("icmp eq i32 %%mode, 0")
+	increment := e.value("select i1 %s, i1 %s, i1 %s", isNearest, nearest, directed)
+	increment = e.value("zext i1 %s to i128", increment)
+	rounded := e.value("add i128 %s, %s", unrounded, increment)
+	carry := e.value("icmp uge i128 %s, %d", rounded, uint64(1)<<(fractionBits+1))
+	carried := e.value("lshr i128 %s, 1", rounded)
+	rounded = e.value("select i1 %s, i128 %s, i128 %s", carry, carried, rounded)
+	carry32 := e.value("zext i1 %s to i32", carry)
+	exponent := e.value("add i32 %s, %s", unit, shift)
+	exponent = e.value("add i32 %s, %d", exponent, fractionBits+bias)
+	exponent = e.value("add i32 %s, %s", exponent, carry32)
+	stillSubnormal := e.value("icmp ult i128 %s, %d", rounded, uint64(1)<<fractionBits)
+	exponent = e.value("select i1 %s, i32 0, i32 %s", stillSubnormal, exponent)
+	encodedExponent := exponent
+	if bits == 64 {
+		encodedExponent = e.value("zext i32 %s to i64", exponent)
+	}
+	encodedExponent = e.value("shl i%d %s, %d", bits, encodedExponent, fractionBits)
+	fraction := e.value("trunc i128 %s to i%d", rounded, bits)
+	fraction = e.value("and i%d %s, %d", bits, fraction, uint64(1)<<fractionBits-1)
+	encoded := e.value("or i%d %s, %s", bits, encodedExponent, fraction)
+	overflow := e.value("icmp sge i32 %s, %d", exponent, 2*bias+1)
+	toInfinity := e.value("or i1 %s, %s", isNearest, awayFromZero)
+	infBits := uint64(2*bias+1) << fractionBits
+	overflowBits := e.value("select i1 %s, i%d %d, i%d %d", toInfinity, bits, infBits, bits, infBits-1)
+	encoded = e.value("select i1 %s, i%d %s, i%d %s", overflow, bits, overflowBits, bits, encoded)
+	ftz := e.value("and i32 %%mxcsr, 32768")
+	ftz = e.value("icmp ne i32 %s, 0", ftz)
+	flush := e.value("and i1 %s, %s", ftz, stillSubnormal)
+	encoded = e.value("select i1 %s, i%d 0, i%d %s", flush, bits, bits, encoded)
+	sign := e.value("select i1 %s, i%d %d, i%d 0", negative, bits, uint64(1)<<(bits-1), bits)
+	encoded = e.value("or i%d %s, %s", bits, encoded, sign)
+	result := e.value("bitcast i%d %s to %s", bits, encoded, floatType)
+	fmt.Fprintf(b, "  ret %s %s\n}\n\n", floatType, result)
+}
+
+func (c *amd64Ctx) emitRoundedFMA3(lanes, bits int, a, b, addend, rounding string) string {
+	floatType := amd64FMA3LLVMType(1, bits)
+	vectorType := amd64FMA3LLVMType(lanes, bits)
+	mode := c.packedNumericRoundingMode(rounding)
+	mxcsr := c.loadMXCSR()
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		values := []string{a, b, addend}
+		if lanes > 1 {
+			for index, value := range values {
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", extracted, vectorType, value, lane)
+				values[index] = "%" + extracted
+			}
+		}
+		computed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @__plan9asm_fma3_round_f%d(%s %s, %s %s, %s %s, i32 %s, i32 %s)\n", computed, floatType, bits, floatType, values[0], floatType, values[1], floatType, values[2], mode, mxcsr)
+		if lanes == 1 {
+			return "%" + computed
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %%%s, i32 %d\n", inserted, vectorType, result, floatType, computed, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_four_source.go b/amd64_lower_four_source.go
new file mode 100644
index 000000000..865f3d443
--- /dev/null
+++ b/amd64_lower_four_source.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerFourSource(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86FourSourceProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || form.memory.Kind == OpFP {
+		return true, false, fmt.Errorf("%w: %s needs original x86 four-source memory and exception behavior", ErrProbeNeedsContext, op)
+	}
+	if err := c.validateConflictFunnelMemory(ins, x86PackedBinaryForm{memory: 0, memoryBytes: 16}); err != nil {
+		return true, false, err
+	}
+	return true, false, c.emitNativeFourSource(op, ins, form)
+}
+
+// Snapshot the complete logical source block and old accumulator before the
+// write. A private fixed 0..3 block plus accumulator4 is only an inline-asm
+// transport: source/destination aliasing in the original register file remains
+// modeled by the caller's byte values and the final single writeback.
+//
+// Keep one original opcode rather than four LLVM FMA/dot expressions. Each
+// floating iteration has ambient MXCSR rounding and ordered exceptions, and
+// the original mask suppresses either the whole m128 access or none of it.
+// Even a dead result retains those exact native effects.
+func (c *amd64Ctx) emitNativeFourSource(op Op, ins Instr, form amd64FourSourceForm) error {
+	width := form.byteWidth()
+	typ := amd64FloatingVectorType(width/4, 32) // Bit-preserving transport, including integer dot products.
+	load := func(operand Operand) (string, error) {
+		return c.loadFloatingVectorOperand(operand, width, width/4, 32)
+	}
+	old, err := load(form.destination)
+	if err != nil {
+		return err
+	}
+	bank := "zmm"
+	if form.spec.scalar {
+		bank = "xmm"
+	}
+	constraints := "={" + bank + "4},0"
+	arguments := typ + " " + old
+	for position := 0; position < 4; position++ {
+		source, err := load(form.source(position))
+		if err != nil {
+			return err
+		}
+		constraints += fmt.Sprintf(",{%s%d}", bank, position)
+		arguments += ", " + typ + " " + source
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.memory)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	constraints += ",r"
+	arguments += ", " + pointerType + " " + pointer
+	mnemonic, _, _ := strings.Cut(strings.ToLower(string(op)), ".")
+	assembly := fmt.Sprintf("%s %s($6), %%%s0, %%%s4", mnemonic, segment, bank, bank)
+	if form.maskIndex >= 0 {
+		mask, err := c.loadK(ins.Args[form.maskIndex].Reg)
+		if err != nil {
+			return err
+		}
+		assembly = "kmovw ${7:k}, %k1; " + assembly + " {%k1}"
+		if form.zeroing {
+			assembly += " {z}"
+		}
+		constraints += ",r,~{k1}"
+		arguments += ", i32 " + c.approximateMathMask32(mask)
+	}
+	constraints += ",~{memory}"
+	if form.spec.mode == amd64FourSourceFMA {
+		constraints += ",~{fpsr}"
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints, arguments)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, width)
+	return c.storePackedMoveOperand(form.destination, width, "%"+bytes)
+}
diff --git a/amd64_lower_four_source_test.go b/amd64_lower_four_source_test.go
new file mode 100644
index 000000000..162ef946d
--- /dev/null
+++ b/amd64_lower_four_source_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FourSourceGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64FourSourceSpecs))
+	for op := range amd64FourSourceSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{"V4FMADDPS", "V4FMADDSS", "V4FNMADDPS", "V4FNMADDSS", "VP4DPWSSD", "VP4DPWSSDS"}
+	if strings.Join(got, ",") != strings.Join(want, ",") {
+		t.Fatalf("four-source grammar opcodes = %v, want %v", got, want)
+	}
+}
+
+func TestTranslateX86FourSourceCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT foursourceforms(SB),$0-0
+	V4FMADDPS (BX), [Z0-Z3], Z4
+	V4FNMADDPS 32(BX), [Z0-Z3], Z5
+	V4FMADDSS 64(BX), [X0-X3], X4
+	V4FNMADDSS 96(BX), [X0-X3], X5
+	VP4DPWSSD 128(BX), [Z0-Z3], Z6
+	VP4DPWSSDS 160(BX), [Z0-Z3], Z7
+`
+			if target.goarch == "amd64" {
+				source += `	V4FMADDPS 8(BX), [Z2-Z5], K7, Z4
+	V4FMADDPS.Z 16(BX), [Z2-Z5], K1, Z4
+	V4FNMADDPS 40(BX), [Z2-Z5], K7, Z5
+	V4FNMADDPS.Z 48(BX), [Z2-Z5], K2, Z5
+	V4FMADDSS 72(BX), [X2-X5], K7, X4
+	V4FMADDSS.Z 80(BX), [X2-X5], K3, X4
+	V4FNMADDSS 104(BX), [X2-X5], K7, X5
+	V4FNMADDSS.Z 112(BX), [X2-X5], K4, X5
+	VP4DPWSSD 136(BX), [Z2-Z5], K7, Z6
+	VP4DPWSSD.Z 144(BX), [Z2-Z5], K5, Z6
+	VP4DPWSSDS 168(BX), [Z2-Z5], K7, Z7
+	VP4DPWSSDS.Z 176(BX), [Z2-Z5], K6, Z7
+`
+			}
+			source += "\tRET\n"
+			// Preserve this entire original format and actual Go object.
+			// It does not initialize BX, sources, accumulator or K inputs;
+			// the three public APIs must retain Context, not fake success.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "foursourceforms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "four-source-"+target.name+".ll", "four-source-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FourSourceRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "V4FMADDPS Z0, [Z0-Z3], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS (AX), [Z0-Z2], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS (AX), [Z0,Z1,Z2,Z3], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS (AX), [X0-X3], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS (AX), [Z0-Z3], K0, Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS.Z (AX), [Z0-Z3], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDPS.BCST (AX), [Z0-Z3], Z4"},
+		{goarch: "amd64", instruction: "V4FMADDSS (AX), [X0-X3], Z4"},
+		{goarch: "amd64", instruction: "VP4DPWSSD (AX), [Z0-Z3], X4"},
+		{goarch: "386", instruction: "VP4DPWSSD (AX), [Z6-Z9], Z4"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's four-source tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64FourSourceRuntimeSemantics(t *testing.T) {
+	const source = `TEXT foursourcesemantics(SB),NOSPLIT,$0-24
+	MOVQ in+0(FP), AX
+	MOVQ out+8(FP), BX
+	MOVQ mask+16(FP), CX
+	VBROADCASTSS 0(AX), Z0
+	VBROADCASTSS 16(AX), Z1
+	VBROADCASTSS 32(AX), Z2
+	VBROADCASTSS 48(AX), Z3
+	VBROADCASTSS 64(AX), Z4
+	V4FMADDPS 128(AX), [Z2-Z5], Z4
+	VMOVUPS Z4, 0(BX)
+	VBROADCASTSS 64(AX), Z5
+	KMOVQ CX, K1
+	V4FNMADDPS.Z 128(AX), [Z0-Z3], K1, Z5
+	VMOVUPS Z5, 64(BX)
+	MOVUPS 0(AX), X0
+	MOVUPS 16(AX), X1
+	MOVUPS 32(AX), X2
+	MOVUPS 48(AX), X3
+	MOVUPS 64(AX), X6
+	V4FMADDSS 128(AX), [X0-X3], X6
+	MOVUPS X6, 128(BX)
+	VMOVDQU64 192(AX), Z0
+	VMOVDQU64 256(AX), Z1
+	VMOVDQU64 320(AX), Z2
+	VMOVDQU64 384(AX), Z3
+	VMOVDQU64 448(AX), Z7
+	VP4DPWSSD 144(AX), [Z0-Z3], Z7
+	VMOVDQU64 Z7, 144(BX)
+	VMOVDQU64 448(AX), Z7
+	VP4DPWSSDS 144(AX), [Z0-Z3], Z7
+	VMOVDQU64 Z7, 208(BX)
+	RET
+
+TEXT foursourcefaultsuppression(SB),NOSPLIT,$0-24
+	MOVQ memory+0(FP), AX
+	MOVQ out+8(FP), BX
+	MOVQ mask+16(FP), CX
+	KMOVQ CX, K1
+	V4FMADDPS.Z (AX), [Z0-Z3], K1, Z4
+	VMOVUPS Z4, 0(BX)
+	V4FMADDSS.Z (AX), [X0-X3], K1, X4
+	MOVUPS X4, 64(BX)
+	VP4DPWSSD.Z (AX), [Z0-Z3], K1, Z5
+	VMOVUPS Z5, 80(BX)
+	RET
+`
+	const mainC = `
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+extern void foursourcesemantics(void *, void *, uint64_t);
+extern void foursourcefaultsuppression(void *, void *, uint64_t);
+static void putf(uint8_t *p, float v) { memcpy(p, &v, 4); }
+static float getf(const uint8_t *p) { float v; memcpy(&v, p, 4); return v; }
+static void put16(uint8_t *p, int16_t v) { memcpy(p, &v, 2); }
+static void put32(uint8_t *p, int32_t v) { memcpy(p, &v, 4); }
+static int32_t get32(const uint8_t *p) { int32_t v; memcpy(&v, p, 4); return v; }
+int main(void) {
+  uint8_t in[512] = {0}, out[272] = {0}, faultOut[144] = {1};
+  for (int r=0;r<4;r++) for (int lane=0;lane<4;lane++) putf(in+r*16+lane*4, (float)(r+1));
+  for (int lane=0;lane<4;lane++) putf(in+64+lane*4, 10.0f+(float)lane);
+  putf(in+128, 1); putf(in+132, 2); putf(in+136, 3); putf(in+140, 4);
+  for (int r=0;r<4;r++) for (int lane=0;lane<32;lane++) put16(in+192+r*64+lane*2, (int16_t)(r+1));
+  put16(in+144, 1); put16(in+146, 2); put16(in+148, 3); put16(in+150, 4);
+  put16(in+152, 5); put16(in+154, 6); put16(in+156, 7); put16(in+158, 8);
+  for (int lane=0;lane<16;lane++) put32(in+448+lane*4, lane==0 ? INT_MAX-5 : lane);
+  foursourcesemantics(in, out, 5);
+  foursourcefaultsuppression(0, faultOut, 0);
+	if (getf(out) != 40 || getf(out+4) != 40 || getf(out+8) != 40 || getf(out+12) != 40) return 10;
+	if (getf(out+64) != -20) return 21;
+	if (getf(out+68) != 0) return 22;
+	if (getf(out+72) != -20) return 23;
+	if (getf(out+76) != 0) return 24;
+  if (getf(out+128) != 40 || getf(out+132) != 11 || getf(out+136) != 12 || getf(out+140) != 13) return 12;
+	if (get32(out+144) != INT_MIN+104 || get32(out+148) != 111) return 13;
+	if (get32(out+208) != INT_MAX || get32(out+212) != 111) return 14;
+	for (int i=0;i<144;i++) if (faultOut[i] != 0) return 15;
+	return 0;
+}
+`
+	x86FourSourceOriginalMathCompanion(t, source, mainC)
+}
diff --git a/amd64_lower_fp.go b/amd64_lower_fp.go
index 58f7fdf0c..492fb955c 100644
--- a/amd64_lower_fp.go
+++ b/amd64_lower_fp.go
@@ -2,164 +2,236 @@ package plan9asm
 
 import (
 	"fmt"
+	"math"
 	"strconv"
 	"strings"
 )
 
 func (c *amd64Ctx) lowerFP(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	switch op {
-	case "MOVSD", "MOVAPD", "ANDPD", "ANDNPD", "ORPD", "XORPS",
-		"ADDSD", "SUBSD", "MULSD", "DIVSD", "MAXSD", "MINSD", "SQRTSD",
-		"COMISD", "CMPSD", "VADDSD", "VFMADD213SD", "VFNMADD231SD",
-		"CVTSD2SL", "CVTSL2SD", "CVTSQ2SD", "CVTTSD2SQ":
-		// handled below
-	default:
-		return false, false, nil
+	if known, term, err := c.lowerSqrt(op, ins); known {
+		return known, term, err
 	}
-
-	switch op {
-	case "MOVAPD", "ANDPD", "ANDNPD", "ORPD", "XORPS":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, Xdst: %q", op, ins.Raw)
+	if known, term, err := c.lowerLegacyPackedMove(op, ins); known {
+		return known, term, err
+	}
+	if ok, term, err := c.lowerSignedIntegerScalarFloat(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerFloatArithmetic(op, ins, ""); ok {
+		return ok, term, err
+	}
+	if spec, recognized := amd64ScalarVectorMoveSpecs[op]; recognized && spec.legacy {
+		if _, _, err := amd64ScalarVectorMoveProperties(ins, c.goarch); err != nil {
+			return true, false, err
 		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
+	}
+	if ok, term, err := c.lowerApproximateMath(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerFixupImmediate(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerScaledRound(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerGetMant(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerGetExp(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerFPClass(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerFloatingRange(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerReciprocal14(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerReciprocalEstimate(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerRound(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerScalarFloatToInteger(op, ins); ok {
+		return ok, term, err
+	}
+	if raw := strings.ToUpper(string(op)); raw != "" {
+		base := raw
+		if dot := strings.IndexByte(raw, '.'); dot >= 0 {
+			base = raw[:dot]
 		}
-		dst := ins.Args[1].Reg
-		srcv, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
+		if _, recognized := amd64HorizontalFloatingSpecs[Op(base)]; recognized {
+			return c.lowerHorizontalFloating(op, ins)
 		}
-		if op == "MOVAPD" {
-			return true, false, c.storeX(dst, srcv)
+		if _, recognized := amd64BinaryFloatingSpecs[Op(base)]; recognized {
+			return c.lowerBinaryFloating(op, ins)
 		}
-		dstv, err := c.loadX(dst)
-		if err != nil {
-			return true, false, err
+		if _, recognized := amd64FMA3Specs[Op(base)]; recognized {
+			return c.lowerFMA3(op, ins)
 		}
-		t := c.newTmp()
-		switch op {
-		case "ANDPD":
-			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %s, %s\n", t, dstv, srcv)
-		case "ORPD":
-			fmt.Fprintf(c.b, "  %%%s = or <16 x i8> %s, %s\n", t, dstv, srcv)
-		case "XORPS":
-			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", t, dstv, srcv)
-		case "ANDNPD":
-			notv := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", notv, dstv, llvmAllOnesI8Vec(16))
-			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %%%s, %s\n", t, notv, srcv)
-		}
-		return true, false, c.storeX(dst, "%"+t)
+		if _, recognized := x86PackedLogicalSpecs[Op(base)]; recognized {
+			return c.lowerPackedFloatingLogical(op, ins)
+		}
+		if _, known := x86ScalarPrecisionSpecs[Op(base)]; known {
+			return c.lowerScalarPrecisionConvert(op, ins)
+		}
+	}
+	switch op {
+	case "MOVSS", "MOVSD", "MOVAPD", "MOVUPD",
+		"MOVLHPS", "MOVHLPS", "MOVLPS", "MOVHPS", "MOVLPD", "MOVHPD",
+		"VMOVLPS", "VMOVHPS", "VMOVLPD", "VMOVHPD", "SHUFPD", "UNPCKLPS", "UNPCKHPD",
+		"COMISS", "UCOMISS", "COMISD", "UCOMISD", "CMPSD",
+		"CVTSL2SD", "CVTSQ2SD":
+		// handled below
+	default:
+		return false, false, nil
+	}
 
-	case "MOVSD":
+	switch op {
+	case "MOVSS":
 		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 MOVSD expects src, dst: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 MOVSS expects src, dst: %q", ins.Raw)
 		}
-		v, err := c.evalF64(ins.Args[0])
+		v, err := c.loadLegacyScalarMoveSource(ins, 32)
 		if err != nil {
 			return true, false, err
 		}
 		switch ins.Args[1].Kind {
 		case OpReg:
 			if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-				return true, false, fmt.Errorf("amd64 MOVSD expects X-reg destination: %q", ins.Raw)
+				return true, false, fmt.Errorf("amd64 MOVSS expects X-reg destination: %q", ins.Raw)
 			}
-			return true, false, c.storeXLowF64(ins.Args[1].Reg, v)
+			return true, false, c.storeLegacyScalarMoveRegister(ins.Args[1].Reg, v, 32, ins.Args[0].Kind == OpReg)
 		case OpFP:
-			return true, false, c.storeFPResult(ins.Args[1].FPOffset, LLVMType("double"), v)
+			return true, false, c.storeScalarFPFloat(ins.Args[1].FPOffset, 32, v)
 		case OpMem:
 			addr, err := c.addrFromMem(ins.Args[1].Mem)
 			if err != nil {
 				return true, false, err
 			}
-			p := c.ptrFromAddrI64(addr)
-			fmt.Fprintf(c.b, "  store double %s, ptr %s, align 1\n", v, p)
+			fmt.Fprintf(c.b, "  store volatile float %s, ptr %s, align 1\n", v, c.ptrFromAddrI64(addr))
 			return true, false, nil
 		case OpSym:
 			p, err := c.ptrFromSB(ins.Args[1].Sym)
 			if err != nil {
 				return true, false, err
 			}
-			fmt.Fprintf(c.b, "  store double %s, ptr %s, align 1\n", v, p)
+			fmt.Fprintf(c.b, "  store float %s, ptr %s, align 1\n", v, p)
 			return true, false, nil
 		default:
-			return true, false, fmt.Errorf("amd64 MOVSD unsupported destination: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 MOVSS unsupported destination: %q", ins.Raw)
 		}
 
-	case "ADDSD", "SUBSD", "MULSD", "DIVSD", "MAXSD", "MINSD":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src, Xdst: %q", op, ins.Raw)
+	case "MOVLHPS", "MOVHLPS":
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
 		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
+		src, err := c.loadXAsI64x2(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
 		}
-		src, err := c.evalF64(ins.Args[0])
+		dst, err := c.loadXAsI64x2(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		dst, err := c.loadXLowF64(ins.Args[1].Reg)
+		mask := "<i32 0, i32 2>"
+		if op == "MOVHLPS" {
+			mask = "<i32 3, i32 1>"
+		}
+		shuffled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %s, <2 x i64> %s, <2 x i32> %s\n", shuffled, dst, src, mask)
+		return true, false, c.storeXFromI64x2(ins.Args[1].Reg, "%"+shuffled)
+
+	case "MOVLPS", "MOVHPS", "MOVLPD", "MOVHPD", "VMOVLPS", "VMOVHPS", "VMOVLPD", "VMOVHPD":
+		return c.lowerMOVHalf(op, ins)
+
+	case "SHUFPD":
+		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 SHUFPD expects $imm, Xsrc, Xdst: %q", ins.Raw)
+		}
+		src, err := c.loadXAsI64x2(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		t := c.newTmp()
-		switch op {
-		case "ADDSD":
-			fmt.Fprintf(c.b, "  %%%s = fadd double %s, %s\n", t, dst, src)
-		case "SUBSD":
-			fmt.Fprintf(c.b, "  %%%s = fsub double %s, %s\n", t, dst, src)
-		case "MULSD":
-			fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", t, dst, src)
-		case "DIVSD":
-			fmt.Fprintf(c.b, "  %%%s = fdiv double %s, %s\n", t, dst, src)
-		case "MAXSD":
-			cmp := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = fcmp ogt double %s, %s\n", cmp, dst, src)
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, double %s, double %s\n", t, cmp, dst, src)
-		case "MINSD":
-			cmp := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = fcmp olt double %s, %s\n", cmp, dst, src)
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, double %s, double %s\n", t, cmp, dst, src)
+		dst, err := c.loadXAsI64x2(ins.Args[2].Reg)
+		if err != nil {
+			return true, false, err
 		}
-		return true, false, c.storeXLowF64(ins.Args[1].Reg, "%"+t)
+		lo := ins.Args[0].Imm & 1
+		hi := 2 + ((ins.Args[0].Imm >> 1) & 1)
+		shuffled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %s, <2 x i64> %s, <2 x i32> <i32 %d, i32 %d>\n", shuffled, dst, src, lo, hi)
+		return true, false, c.storeXFromI64x2(ins.Args[2].Reg, "%"+shuffled)
 
-	case "SQRTSD":
+	case "UNPCKLPS", "UNPCKHPD":
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 SQRTSD expects src, Xdst: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 %s expects src, Xdst: %q", op, ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
 		}
-		src, err := c.evalF64(ins.Args[0])
+		vectorType := "<4 x float>"
+		maskType := "<4 x i32>"
+		mask := "<i32 0, i32 4, i32 1, i32 5>"
+		if op == "UNPCKHPD" {
+			vectorType = "<2 x double>"
+			maskType = "<2 x i32>"
+			mask = "<i32 1, i32 3>"
+		}
+		src, err := c.loadXTypedVectorOperand(ins.Args[0], vectorType)
 		if err != nil {
 			return true, false, err
 		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call double @llvm.sqrt.f64(double %s)\n", t, src)
-		return true, false, c.storeXLowF64(ins.Args[1].Reg, "%"+t)
+		dst, err := c.loadXTypedVectorOperand(ins.Args[1], vectorType)
+		if err != nil {
+			return true, false, err
+		}
+		shuffled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s %s, %s %s\n", shuffled, vectorType, dst, vectorType, src, maskType, mask)
+		bytesValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytesValue, vectorType, shuffled)
+		return true, false, c.storeX(ins.Args[1].Reg, "%"+bytesValue)
 
-	case "COMISD":
+	case "MOVSD":
 		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 COMISD expects src, dst: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 MOVSD expects src, dst: %q", ins.Raw)
 		}
-		src, err := c.evalF64(ins.Args[0])
+		v, err := c.loadLegacyScalarMoveSource(ins, 64)
 		if err != nil {
 			return true, false, err
 		}
-		dst, err := c.evalF64(ins.Args[1])
-		if err != nil {
-			return true, false, err
+		switch ins.Args[1].Kind {
+		case OpReg:
+			if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
+				return true, false, fmt.Errorf("amd64 MOVSD expects X-reg destination: %q", ins.Raw)
+			}
+			return true, false, c.storeLegacyScalarMoveRegister(ins.Args[1].Reg, v, 64, ins.Args[0].Kind == OpReg)
+		case OpFP:
+			return true, false, c.storeScalarFPFloat(ins.Args[1].FPOffset, 64, v)
+		case OpMem:
+			addr, err := c.addrFromMem(ins.Args[1].Mem)
+			if err != nil {
+				return true, false, err
+			}
+			p := c.ptrFromAddrI64(addr)
+			fmt.Fprintf(c.b, "  store volatile double %s, ptr %s, align 1\n", v, p)
+			return true, false, nil
+		case OpSym:
+			p, err := c.ptrFromSB(ins.Args[1].Sym)
+			if err != nil {
+				return true, false, err
+			}
+			fmt.Fprintf(c.b, "  store double %s, ptr %s, align 1\n", v, p)
+			return true, false, nil
+		default:
+			return true, false, fmt.Errorf("amd64 MOVSD unsupported destination: %q", ins.Raw)
 		}
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fcmp ueq double %s, %s\n", z, dst, src)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", z, c.flagsZSlot)
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fcmp ult double %s, %s\n", cf, dst, src)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		lt := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fcmp olt double %s, %s\n", lt, dst, src)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", lt, c.flagsSltSlot)
-		return true, false, nil
+
+	case "COMISS", "UCOMISS", "COMISD", "UCOMISD":
+		return c.lowerVectorScalarFlagCompare(op, ins)
 
 	case "CMPSD":
 		if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg {
@@ -213,136 +285,6 @@ func (c *amd64Ctx) lowerFP(op Op, ins Instr) (ok bool, terminated bool, err erro
 		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 -1, i64 0\n", mask, cmp)
 		return true, false, c.storeXLowI64(ins.Args[1].Reg, "%"+mask)
 
-	case "CVTTSD2SQ":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 CVTTSD2SQ expects src, dstReg: %q", ins.Raw)
-		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fptosi double %s to i64\n", t, src)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+t)
-
-	case "CVTSQ2SD":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 CVTSQ2SD expects src, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sitofp i64 %s to double\n", t, src)
-		return true, false, c.storeXLowF64(ins.Args[1].Reg, "%"+t)
-
-	case "CVTSD2SL":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 CVTSD2SL expects src, dstReg: %q", ins.Raw)
-		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		round := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call double @llvm.rint.f64(double %s)\n", round, src)
-		i32v := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fptosi double %%%s to i32\n", i32v, round)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, i32v)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+z)
-
-	case "CVTSL2SD":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 CVTSL2SD expects srcReg, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.evalI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		i32v := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", i32v, src)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sitofp i32 %%%s to double\n", t, i32v)
-		return true, false, c.storeXLowF64(ins.Args[1].Reg, "%"+t)
-
-	case "VADDSD":
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VADDSD expects src1, src2, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		s1, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		s2, err := c.evalF64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fadd double %s, %s\n", t, s2, s1)
-		return true, false, c.storeXLowF64(ins.Args[2].Reg, "%"+t)
-
-	case "VFMADD213SD":
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VFMADD213SD expects src1, src2, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		s1, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		s2, err := c.evalF64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.loadXLowF64(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		mul := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", mul, dst, s2)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fadd double %%%s, %s\n", t, mul, s1)
-		return true, false, c.storeXLowF64(ins.Args[2].Reg, "%"+t)
-
-	case "VFNMADD231SD":
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VFNMADD231SD expects src1, src2, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		s1, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		s2, err := c.evalF64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.loadXLowF64(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		mul := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", mul, s1, s2)
-		neg := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fneg double %%%s\n", neg, mul)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fadd double %%%s, %s\n", t, neg, dst)
-		return true, false, c.storeXLowF64(ins.Args[2].Reg, "%"+t)
 	}
 	return false, false, nil
 }
@@ -371,11 +313,43 @@ func (c *amd64Ctx) loadXVecOperand(op Operand) (string, error) {
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", t, p)
 		return "%" + t, nil
+	case OpFP:
+		// ABI0 fields need not be two contiguous uint64 values. Assemble
+		// every declared byte, including adjacent float32 and narrow fields.
+		return c.loadFPVectorBytes(op.FPOffset, 16)
 	default:
 		return "", fmt.Errorf("amd64: unsupported X-vector operand %s", op.String())
 	}
 }
 
+func (c *amd64Ctx) storeXVecOperand(op Operand, value string) error {
+	switch op.Kind {
+	case OpReg:
+		if !isAMD64XReg(op.Reg) {
+			return fmt.Errorf("expected X register, got %s", op.String())
+		}
+		return c.storeX(op.Reg, value)
+	case OpMem:
+		addr, err := c.addrFromMem(op.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", value, c.ptrFromAddrI64(addr))
+		return nil
+	case OpSym:
+		p, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", value, p)
+		return nil
+	case OpFP:
+		return c.storeFPVectorBytes(op.FPOffset, 16, value, "")
+	default:
+		return fmt.Errorf("unsupported X-vector destination %s", op.String())
+	}
+}
+
 func (c *amd64Ctx) loadYVecOperand(op Operand) (string, error) {
 	switch op.Kind {
 	case OpReg:
@@ -456,6 +430,20 @@ func (c *amd64Ctx) loadXLowF64(r Reg) (string, error) {
 	return "%" + t, nil
 }
 
+func (c *amd64Ctx) loadXLowF32(r Reg) (string, error) {
+	xv, err := c.loadX(r)
+	if err != nil {
+		return "", err
+	}
+	words := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", words, xv)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %%%s, i32 0\n", low, words)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", value, low)
+	return "%" + value, nil
+}
+
 func (c *amd64Ctx) storeXLowI64(r Reg, low string) error {
 	cur, err := c.loadX(r)
 	if err != nil {
@@ -480,6 +468,231 @@ func (c *amd64Ctx) storeXLowF64(r Reg, v string) error {
 	return c.storeXLowI64(r, "%"+t)
 }
 
+// Legacy scalar moves preserve bits above 127 in every physical alias. The
+// source class separately determines whether the upper XMM lanes survive.
+// Do not use this helper for VEX/EVEX writes, which zero their wider views.
+func (c *amd64Ctx) storeLegacyScalarMoveRegister(r Reg, value string, bits int, preserve bool) error {
+	var store func(Reg, string) error
+	switch bits {
+	case 32:
+		store = c.storeXLowF32ClearingUpper
+		if preserve {
+			store = c.storeXLowF32
+		}
+	case 64:
+		store = c.storeXLowF64ClearingUpper
+		if preserve {
+			store = c.storeXLowF64
+		}
+	default:
+		return fmt.Errorf("invalid legacy scalar move width %d", bits)
+	}
+	if err := store(r, value); err != nil {
+		return err
+	}
+	xmm, err := c.loadX(r)
+	if err != nil {
+		return err
+	}
+	return c.storeLegacyXViews(r, xmm)
+}
+
+func (c *amd64Ctx) storeXLowF64ClearingUpper(r Reg, v string) error {
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", bits, v)
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %%%s, i32 0\n", inserted, bits)
+	back := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", back, inserted)
+	return c.storeX(r, "%"+back)
+}
+
+func (c *amd64Ctx) storeXLowF32(r Reg, v string) error {
+	cur, err := c.loadX(r)
+	if err != nil {
+		return err
+	}
+	words := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", words, cur)
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits, v)
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %%%s, i32 0\n", inserted, words, bits)
+	back := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", back, inserted)
+	return c.storeX(r, "%"+back)
+}
+
+func (c *amd64Ctx) storeXLowF32ClearingUpper(r Reg, v string) error {
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits, v)
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> zeroinitializer, i32 %%%s, i32 0\n", inserted, bits)
+	back := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", back, inserted)
+	return c.storeX(r, "%"+back)
+}
+
+func (c *amd64Ctx) loadXTypedVectorOperand(op Operand, vectorType string) (string, error) {
+	bytesValue, err := c.loadXVecOperand(op)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", value, bytesValue, vectorType)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) loadXAsI64x2(r Reg) (string, error) {
+	if _, ok := amd64ParseXReg(r); !ok {
+		return "", fmt.Errorf("amd64: expected X register, got %s", r)
+	}
+	bytesValue, err := c.loadX(r)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", value, bytesValue)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeXFromI64x2(r Reg, value string) error {
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %s to <16 x i8>\n", bytesValue, value)
+	return c.storeX(r, "%"+bytesValue)
+}
+
+type amd64MoveHalfSpec struct {
+	high         bool
+	vector       bool
+	registerOnly bool
+}
+
+// The memory halves use yxmov/_yvmovhpd. The explicit register-only aliases
+// add yxr/_yvmovhlps while sharing the selected source/base/output halves.
+// VEX/EVEX memory halves still accept only m64 loads or stores.
+var amd64MoveHalfSpecs = map[Op]amd64MoveHalfSpec{
+	"MOVHLPS":  {registerOnly: true},
+	"MOVLHPS":  {high: true, registerOnly: true},
+	"VMOVHLPS": {vector: true, registerOnly: true},
+	"VMOVLHPS": {high: true, vector: true, registerOnly: true},
+	"MOVLPS":   {},
+	"MOVHPS":   {high: true},
+	"MOVLPD":   {},
+	"MOVHPD":   {high: true},
+	"VMOVLPS":  {vector: true},
+	"VMOVHPS":  {high: true, vector: true},
+	"VMOVLPD":  {vector: true},
+	"VMOVHPD":  {high: true, vector: true},
+}
+
+func (c *amd64Ctx) lowerMOVHalf(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86MoveHalfProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.undocumentedPDRegister {
+		return true, false, fmt.Errorf("%w: %s's Go register encoding lacks documented Intel PD semantics", ErrProbeNeedsContext, op)
+	}
+	return true, false, c.emitMoveHalf(form, ins)
+}
+
+func (c *amd64Ctx) emitMoveHalf(form x86MoveHalfForm, ins Instr) error {
+	if form.store {
+		source, err := c.loadXAsI64x2(ins.Args[form.source].Reg)
+		if err != nil {
+			return err
+		}
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %s, i32 %d\n", bits, source, form.sourceLane)
+		return c.storePackedScalarExtractMemory(ins.Args[form.destination], I64, "%"+bits)
+	}
+	var bits string
+	if form.memory >= 0 {
+		var err error
+		if source := ins.Args[form.source]; source.Kind == OpFP {
+			bits, err = c.loadScalarLaneFPBits(source.FPOffset, 64)
+		} else {
+			bits, err = c.evalSizedNativeGPSource(source, I64, ins.x86AddressBits)
+		}
+		if err != nil {
+			return err
+		}
+	} else {
+		source, err := c.loadXAsI64x2(ins.Args[form.source].Reg)
+		if err != nil {
+			return err
+		}
+		extracted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %s, i32 %d\n", extracted, source, form.sourceLane)
+		bits = "%" + extracted
+	}
+	base, err := c.loadXAsI64x2(ins.Args[form.base].Reg)
+	if err != nil {
+		return err
+	}
+	inserted, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %s, i64 %s, i32 %d\n", inserted, base, bits, form.outputLane)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, inserted)
+	if form.spec.vector {
+		return c.storePackedMoveOperand(ins.Args[form.destination], 16, "%"+bytes)
+	}
+	return c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+}
+
+func (c *amd64Ctx) evalF32(op Operand) (string, error) {
+	switch op.Kind {
+	case OpReg:
+		if _, ok := amd64ParseXReg(op.Reg); !ok {
+			return "", fmt.Errorf("amd64: expected X register for f32 operand, got %s", op.String())
+		}
+		return c.loadXLowF32(op.Reg)
+	case OpImm:
+		bits := c.newTmp()
+		if op.ImmIsFloat {
+			// The parser retains the original float64 constant. Go's
+			// Float32Sym rounds its numeric value, not its low 32 bits.
+			rounded := math.Float32bits(float32(math.Float64frombits(uint64(op.Imm))))
+			fmt.Fprintf(c.b, "  %%%s = bitcast i32 %d to float\n", bits, rounded)
+			return "%" + bits, nil
+		}
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %d to i32\n", bits, op.Imm)
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", value, bits)
+		return "%" + value, nil
+	case OpFP:
+		return c.evalFPToF32(op.FPOffset)
+	case OpMem:
+		p, ptrType, err := c.ptrFromMem(op.Mem)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load float, %s %s, align 1\n", value, ptrType, p)
+		return "%" + value, nil
+	case OpSym:
+		p, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load float, ptr %s, align 1\n", value, p)
+		return "%" + value, nil
+	default:
+		return "", fmt.Errorf("amd64: unsupported f32 operand %s", op.String())
+	}
+}
+
+func (c *amd64Ctx) evalFPToF32(off int64) (string, error) {
+	bits, err := c.loadScalarFPBits(off, 32)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to float\n", value, bits)
+	return "%" + value, nil
+}
+
 func (c *amd64Ctx) evalF64(op Operand) (string, error) {
 	switch op.Kind {
 	case OpReg:
@@ -515,34 +728,11 @@ func (c *amd64Ctx) evalF64(op Operand) (string, error) {
 }
 
 func (c *amd64Ctx) evalFPToF64(off int64) (string, error) {
-	slot, ok := c.fpParam(off)
-	if !ok {
-		return "", fmt.Errorf("unsupported FP read slot for f64: +%d(FP)", off)
-	}
-	idx := slot.Index
-	if idx < 0 || idx >= len(c.sig.Args) {
-		return "", fmt.Errorf("FP read slot for f64: invalid arg index %d at +%d(FP)", idx, off)
-	}
-	arg := fmt.Sprintf("%%arg%d", idx)
-	ty := slot.Type
-	if c.classicFrame != "" {
-		loaded := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", loaded, ty, c.classicFramePtr(off))
-		arg = "%" + loaded
-	} else if slot.Field >= 0 {
-		aggTy := c.sig.Args[idx]
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, aggTy, arg, slot.Field)
-		arg = "%" + t
-	}
-	switch ty {
-	case LLVMType("double"):
-		return arg, nil
-	case I64:
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", t, arg)
-		return "%" + t, nil
-	default:
-		return "", fmt.Errorf("FP read unsupported type %q for f64 at +%d(FP)", ty, off)
+	bits, err := c.loadScalarFPBits(off, 64)
+	if err != nil {
+		return "", err
 	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", value, bits)
+	return "%" + value, nil
 }
diff --git a/amd64_lower_fpclass.go b/amd64_lower_fpclass.go
new file mode 100644
index 000000000..dc12c9514
--- /dev/null
+++ b/amd64_lower_fpclass.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FPClassSpec struct {
+	laneBits int
+	bytes    int
+	scalar   bool
+}
+
+// amd64FPClassSpecs mirrors the width-specialized opcode names in Go 1.27's
+// _yvfpclasspdx/_yvfpclasspdy/_yvfpclasspdz tables. Classification itself is
+// shared across every packed and scalar form.
+var amd64FPClassSpecs = map[Op]amd64FPClassSpec{
+	"VFPCLASSPDX": {laneBits: 64, bytes: 16},
+	"VFPCLASSPDY": {laneBits: 64, bytes: 32},
+	"VFPCLASSPDZ": {laneBits: 64, bytes: 64},
+	"VFPCLASSPSX": {laneBits: 32, bytes: 16},
+	"VFPCLASSPSY": {laneBits: 32, bytes: 32},
+	"VFPCLASSPSZ": {laneBits: 32, bytes: 64},
+	"VFPCLASSSD":  {laneBits: 64, bytes: 16, scalar: true},
+	"VFPCLASSSS":  {laneBits: 32, bytes: 16, scalar: true},
+}
+
+func (c *amd64Ctx) lowerFPClass(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64FPClassSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	broadcast := suffix == "BCST"
+	if suffix != "" && !broadcast {
+		return true, false, fmt.Errorf("%s %s has a suffix absent from Go 1.27's FPCLASS optab: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.scalar && broadcast {
+		return true, false, fmt.Errorf("%s %s scalar forms do not support broadcast: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("%s %s expects immediate, source, [K mask,] K destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+		return true, false, fmt.Errorf("%s %s immediate must be an unsigned byte: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == 4
+	if c.goarch == "386" && masked {
+		return true, false, fmt.Errorf("386 %s mask forms exceed the Go assembler frontend's three-operand limit: %q", baseOp, ins.Raw)
+	}
+	if masked && !amd64NonzeroKOperand(ins.Args[2]) {
+		return true, false, fmt.Errorf("%s %s input mask must be K1-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	if !amd64IsKOperand(destination) {
+		return true, false, fmt.Errorf("%s %s destination must be K0-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+	source := ins.Args[1]
+	if broadcast {
+		if !isAMD64MemoryOperand(source) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a scalar memory source: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if source.Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(source, spec.bytes) {
+			return true, false, fmt.Errorf("%s %s source register does not match its opcode width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return true, false, fmt.Errorf("%s %s source must be its named vector width or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	lanes := spec.bytes * 8 / spec.laneBits
+	var bits string
+	if spec.scalar {
+		scalarBits, loadErr := c.loadFloatingScalarBits(source, spec.laneBits)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", inserted, spec.laneBits, spec.laneBits, scalarBits)
+		bits = "%" + inserted
+		lanes = 1
+	} else {
+		bits, err = c.loadPackedCompareLanes(source, spec.bytes, spec.laneBits, broadcast)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	classified := c.emitFPClassPredicate(lanes, spec.laneBits, bits, uint8(ins.Args[0].Imm))
+	var result string
+	if lanes == 1 {
+		low := c.newTmp()
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i1> %s, i32 0\n", low, classified)
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", wide, low)
+		result = "%" + wide
+	} else {
+		result = c.packFloatingCompareMask(classified, lanes)
+	}
+	if masked {
+		writeMask, loadErr := c.loadK(ins.Args[2].Reg)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		maskedResult := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", maskedResult, result, writeMask)
+		result = "%" + maskedResult
+	}
+	return true, false, c.storeK(destination.Reg, result)
+}
+
+func (c *amd64Ctx) emitFPClassPredicate(lanes, laneBits int, bits string, immediate uint8) string {
+	integerType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	predicateType := fmt.Sprintf("<%d x i1>", lanes)
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	if laneBits == 64 {
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+	}
+	exponent, mantissa, quiet := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", exponent, integerType, bits, llvmSplatInteger(lanes, laneBits, exponentMask))
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", mantissa, integerType, bits, llvmSplatInteger(lanes, laneBits, mantissaMask))
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", quiet, integerType, bits, llvmSplatInteger(lanes, laneBits, quietBit))
+	exponentOnes, exponentNotOnes := c.newTmp(), c.newTmp()
+	exponentZero, exponentNotZero := c.newTmp(), c.newTmp()
+	mantissaZero, mantissaNonzero := c.newTmp(), c.newTmp()
+	quietSet, quietClear := c.newTmp(), c.newTmp()
+	negative, nonnegative := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %s\n", exponentOnes, integerType, exponent, llvmSplatInteger(lanes, laneBits, exponentMask))
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, %s\n", exponentNotOnes, integerType, exponent, llvmSplatInteger(lanes, laneBits, exponentMask))
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", exponentZero, integerType, exponent)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", exponentNotZero, integerType, exponent)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", mantissaZero, integerType, mantissa)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", mantissaNonzero, integerType, mantissa)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", quietSet, integerType, quiet)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", quietClear, integerType, quiet)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, zeroinitializer\n", negative, integerType, bits)
+	fmt.Fprintf(c.b, "  %%%s = icmp sge %s %s, zeroinitializer\n", nonnegative, integerType, bits)
+	daz := c.loadMXCSRDAZ()
+	dazClear := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i1 %s, false\n", dazClear, daz)
+	dazSetVector := amd64SplatI1(c, lanes, daz)
+	dazClearVector := amd64SplatI1(c, lanes, "%"+dazClear)
+	and := func(first, second string) string {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", value, predicateType, first, second)
+		return "%" + value
+	}
+	categories := [8]string{}
+	nan := and("%"+exponentOnes, "%"+mantissaNonzero)
+	categories[0] = and(nan, "%"+quietSet)
+	effectiveMantissaZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %s\n", effectiveMantissaZero, predicateType, mantissaZero, dazSetVector)
+	zero := and("%"+exponentZero, "%"+effectiveMantissaZero)
+	categories[1] = and(zero, "%"+nonnegative)
+	categories[2] = and(zero, "%"+negative)
+	infinity := and("%"+exponentOnes, "%"+mantissaZero)
+	categories[3] = and(infinity, "%"+nonnegative)
+	categories[4] = and(infinity, "%"+negative)
+	effectiveMantissaNonzero := and("%"+mantissaNonzero, dazClearVector)
+	categories[5] = and("%"+exponentZero, effectiveMantissaNonzero)
+	negativeFinite := and("%"+negative, "%"+exponentNotOnes)
+	effectiveNonzero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %s\n", effectiveNonzero, predicateType, exponentNotZero, effectiveMantissaNonzero)
+	categories[6] = and(negativeFinite, "%"+effectiveNonzero)
+	categories[7] = and(nan, "%"+quietClear)
+	result := "zeroinitializer"
+	for category, predicate := range categories {
+		if immediate&(1<<category) == 0 {
+			continue
+		}
+		if result == "zeroinitializer" {
+			result = predicate
+			continue
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or %s %s, %s\n", combined, predicateType, result, predicate)
+		result = "%" + combined
+	}
+	return result
+}
+
+func (c *amd64Ctx) loadMXCSRDAZ() string {
+	mxcsr := c.loadMXCSR()
+	dazBits := c.newTmp()
+	daz := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 64\n", dazBits, mxcsr)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", daz, dazBits)
+	return "%" + daz
+}
+
+func (c *amd64Ctx) loadMXCSR() string {
+	mxcsrSlot, mxcsr := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = alloca i32\n", mxcsrSlot)
+	fmt.Fprintf(c.b, "  call void @llvm.x86.sse.stmxcsr(ptr %%%s)\n", mxcsrSlot)
+	fmt.Fprintf(c.b, "  %%%s = load i32, ptr %%%s\n", mxcsr, mxcsrSlot)
+	return "%" + mxcsr
+}
diff --git a/amd64_lower_fpclass_test.go b/amd64_lower_fpclass_test.go
new file mode 100644
index 000000000..028fd9a51
--- /dev/null
+++ b/amd64_lower_fpclass_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FPClassGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64FPClassSpec{
+		"VFPCLASSPDX": {laneBits: 64, bytes: 16},
+		"VFPCLASSPDY": {laneBits: 64, bytes: 32},
+		"VFPCLASSPDZ": {laneBits: 64, bytes: 64},
+		"VFPCLASSPSX": {laneBits: 32, bytes: 16},
+		"VFPCLASSPSY": {laneBits: 32, bytes: 32},
+		"VFPCLASSPSZ": {laneBits: 32, bytes: 64},
+		"VFPCLASSSD":  {laneBits: 64, bytes: 16, scalar: true},
+		"VFPCLASSSS":  {laneBits: 32, bytes: 16, scalar: true},
+	}
+	if len(amd64FPClassSpecs) != len(expected) {
+		t.Fatalf("FPCLASS grammar has %d entries, want %d", len(amd64FPClassSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64FPClassSpecs[op]; !ok {
+			t.Errorf("FPCLASS grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("FPCLASS grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86FPClassCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT fpclassforms(SB),$0-0\n")
+			for _, test := range []struct {
+				op     string
+				width  string
+				packed bool
+			}{
+				{op: "VFPCLASSPDX", width: "X", packed: true},
+				{op: "VFPCLASSPDY", width: "Y", packed: true},
+				{op: "VFPCLASSPDZ", width: "Z", packed: true},
+				{op: "VFPCLASSPSX", width: "X", packed: true},
+				{op: "VFPCLASSPSY", width: "Y", packed: true},
+				{op: "VFPCLASSPSZ", width: "Z", packed: true},
+				{op: "VFPCLASSSD", width: "X"},
+				{op: "VFPCLASSSS", width: "X"},
+			} {
+				last := 31
+				if target.goarch == "386" && test.width == "Z" {
+					last = 7
+				}
+				fmt.Fprintf(&source, "\t%s $0, %s%d, K0\n", test.op, test.width, last)
+				fmt.Fprintf(&source, "\t%s $255, 8(AX), K7\n", test.op)
+				if test.packed {
+					fmt.Fprintf(&source, "\t%s.BCST $1, 16(AX), K6\n", test.op)
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $2, %s%d, K1, K5\n", test.op, test.width, last)
+					fmt.Fprintf(&source, "\t%s $3, 24(AX), K2, K4\n", test.op)
+					if test.packed {
+						fmt.Fprintf(&source, "\t%s.BCST $4, 32(AX), K3, K0\n", test.op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "fpclassforms", target.goarch, target.triple)
+			if ir == "" {
+				return // Go/public-Context coverage, not an LLVM object claim.
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "fpclass-"+target.name+".ll", "fpclass-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FPClassRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VFPCLASSPSX $-1, X0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX $256, X0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX X0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX $1, Y0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSY $1, X0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPDZ $1, Y0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSZ.BCST $1, Z0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSSS.BCST $1, 0(AX), K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX.Z $1, X0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX $1, X0, K0, K1"},
+		{goarch: "amd64", instruction: "VFPCLASSPSX $1, X0, X1"},
+		{goarch: "386", instruction: "VFPCLASSPSX $1, X0, K1, K2"},
+		{goarch: "386", instruction: "VFPCLASSPSX $1, X32, K1"},
+		{goarch: "386", instruction: "VFPCLASSPSZ $1, Z8, K1"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's FPCLASS table", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64FPClassRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	var source strings.Builder
+	source.WriteString(`TEXT fpclasssemantics(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source32+8(FP), BX
+	MOVQ source64+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	STC
+`)
+	for category := 0; category < 8; category++ {
+		immediate := 1 << category
+		fmt.Fprintf(&source, "\tVFPCLASSPSZ $%d, 0(BX), K2\n", immediate)
+		fmt.Fprintf(&source, "\tKMOVQ K2, %d(AX)\n", category*8)
+		fmt.Fprintf(&source, "\tVFPCLASSPDZ $%d, 0(CX), K2\n", immediate)
+		fmt.Fprintf(&source, "\tKMOVQ K2, %d(AX)\n", 64+category*8)
+		fmt.Fprintf(&source, "\tVFPCLASSSS $%d, %d(BX), K2\n", immediate, category*4)
+		fmt.Fprintf(&source, "\tKMOVQ K2, %d(AX)\n", 128+category*8)
+		fmt.Fprintf(&source, "\tVFPCLASSSD $%d, %d(CX), K2\n", immediate, category*8)
+		fmt.Fprintf(&source, "\tKMOVQ K2, %d(AX)\n", 192+category*8)
+	}
+	source.WriteString(`	VFPCLASSPSZ $255, 0(BX), K1, K2
+	KMOVQ K2, 256(AX)
+	VFPCLASSPSZ.BCST $1, 0(BX), K2
+	KMOVQ K2, 264(AX)
+	SETCS 272(AX)
+	RET
+`)
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"fpclasssemantics": {
+			Name: "fpclasssemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void fpclasssemantics(uint8_t *, const uint32_t *, const uint64_t *, uint64_t);
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  const uint32_t source32[16]={
+    0x7fc12345,0x00000000,0x80000000,0x7f800000,
+    0xff800000,0x00000001,0xbf800000,0x7f812345,
+    0x3f800000,0x40000000,0x00800000,0x7f7fffff,
+    0x3f000000,0x40400000,0x3f800001,0x3f800002};
+  const uint64_t source64[8]={
+    UINT64_C(0x7ff8123456789abc),UINT64_C(0),UINT64_C(0x8000000000000000),UINT64_C(0x7ff0000000000000),
+    UINT64_C(0xfff0000000000000),UINT64_C(1),UINT64_C(0xbff0000000000000),UINT64_C(0x7ff0123456789abc)};
+  uint8_t out[273]={0}, outDaz[273]={0};
+  fpclasssemantics(out,source32,source64,UINT64_C(0xa5));
+	unsigned oldCsr=_mm_getcsr();
+	_mm_setcsr(oldCsr|UINT32_C(0x40));
+	fpclasssemantics(outDaz,source32,source64,UINT64_C(0xa5));
+	_mm_setcsr(oldCsr);
+  for (int category=0;category<8;category++) {
+    uint64_t bit=UINT64_C(1)<<category;
+    if (u64(out+category*8)!=bit) return 10+category;
+    if (u64(out+64+category*8)!=bit) return 20+category;
+    if (u64(out+128+category*8)!=1) return 30+category;
+    if (u64(out+192+category*8)!=1) return 40+category;
+  }
+  if (u64(out+256)!=UINT64_C(0xa5)) return 50;
+  if (u64(out+264)!=UINT64_C(0xffff)) return 51;
+  if (out[272]!=1) return 52;
+  if (u64(outDaz+8)!=UINT64_C(0x22) || u64(outDaz+40)!=0) return 53;
+  if (u64(outDaz+72)!=UINT64_C(0x22) || u64(outDaz+104)!=0) return 54;
+  if (u64(outDaz+168)!=0 || u64(outDaz+232)!=0) return 55;
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "fpclass_semantics", ir, mainC)
+}
diff --git a/amd64_lower_funnel_shift.go b/amd64_lower_funnel_shift.go
new file mode 100644
index 000000000..58e6591f2
--- /dev/null
+++ b/amd64_lower_funnel_shift.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64FunnelShiftSpec struct {
+	laneBits int
+	left     bool
+	variable bool
+}
+
+// amd64FunnelShiftSpecs is the complete Go 1.27 VBMI2 funnel-shift family:
+// left/right, immediate/per-lane counts, and word/dword/qword lanes.
+var amd64FunnelShiftSpecs = map[Op]amd64FunnelShiftSpec{
+	"VPSHLDW":  {laneBits: 16, left: true},
+	"VPSHLDD":  {laneBits: 32, left: true},
+	"VPSHLDQ":  {laneBits: 64, left: true},
+	"VPSHLDVW": {laneBits: 16, left: true, variable: true},
+	"VPSHLDVD": {laneBits: 32, left: true, variable: true},
+	"VPSHLDVQ": {laneBits: 64, left: true, variable: true},
+	"VPSHRDW":  {laneBits: 16},
+	"VPSHRDD":  {laneBits: 32},
+	"VPSHRDQ":  {laneBits: 64},
+	"VPSHRDVW": {laneBits: 16, variable: true},
+	"VPSHRDVD": {laneBits: 32, variable: true},
+	"VPSHRDVQ": {laneBits: 64, variable: true},
+}
+
+func (c *amd64Ctx) lowerFunnelShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86FunnelShiftProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	destination := ins.Args[form.destination]
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	// Every VBMI2 member is E4: retain exact volatile active-lane reads,
+	// including discarded data/counts, and suppress only masked-off lanes.
+	first, err := c.loadX86PackedShiftLanes(ins.Args[form.first], byteWidth, spec.laneBits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadPackedCompareLanes(ins.Args[form.second], byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	old := "zeroinitializer"
+	if spec.variable || form.mask >= 0 && !form.zeroing {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+	}
+
+	count := first
+	leftInput, rightInput := old, second
+	if !spec.variable {
+		count = amd64SplatInteger(c, lanes, spec.laneBits, fmt.Sprintf("%d", uint8(ins.Args[0].Imm)))
+		leftInput, rightInput = second, first
+	}
+	intrinsic := "fshl"
+	firstArgument, secondArgument := leftInput, rightInput
+	if !spec.left {
+		intrinsic = "fshr"
+		firstArgument, secondArgument = rightInput, leftInput
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	computedName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.v%di%d(%s %s, %s %s, %s %s)\n",
+		computedName, vectorType, intrinsic, lanes, spec.laneBits,
+		vectorType, firstArgument, vectorType, secondArgument, vectorType, count)
+	computed := "%" + computedName
+	if form.mask >= 0 {
+		computed = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computed, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, vectorType, computed, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
diff --git a/amd64_lower_funnel_shift_test.go b/amd64_lower_funnel_shift_test.go
new file mode 100644
index 000000000..b5c2ec36d
--- /dev/null
+++ b/amd64_lower_funnel_shift_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86FunnelShiftCompleteGo127Forms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT funnel_shift_forms(SB),$0-0\n")
+			if target.goarch == "amd64" {
+				for _, op := range []string{"VPSHLDW", "VPSHLDD", "VPSHLDQ", "VPSHRDW", "VPSHRDD", "VPSHRDQ"} {
+					broadcast := !strings.HasSuffix(op, "W")
+					for _, width := range []string{"X", "Y", "Z"} {
+						fmt.Fprintf(&source, "\t%s $0, %s0, %s1, %s2\n", op, width, width, width)
+						fmt.Fprintf(&source, "\t%s $255, 8(BX), %s3, %s4\n", op, width, width)
+						fmt.Fprintf(&source, "\t%s $1, %s20, %s21, K1, %s22\n", op, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z $2, 16(BX), %s23, K7, %s24\n", op, width, width)
+						if broadcast {
+							fmt.Fprintf(&source, "\t%s.BCST $3, 24(BX), %s25, %s26\n", op, width, width)
+							fmt.Fprintf(&source, "\t%s.BCST.Z $4, 32(BX), %s27, K2, %s28\n", op, width, width)
+						}
+					}
+				}
+			}
+			for _, op := range []string{"VPSHLDVW", "VPSHLDVD", "VPSHLDVQ", "VPSHRDVW", "VPSHRDVD", "VPSHRDVQ"} {
+				broadcast := !strings.HasSuffix(op, "VW")
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					if broadcast {
+						fmt.Fprintf(&source, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					}
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", op, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z 24(BX), %s23, K7, %s24\n", op, width, width)
+						if broadcast {
+							fmt.Fprintf(&source, "\t%s.BCST.Z 32(BX), %s25, K2, %s26\n", op, width, width)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerFunnelShift(ins.Op, ins) })
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "funnel-shift-"+target.name+".ll", "funnel-shift-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FunnelShiftRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPSHRDQ $0, X0, X1",
+		"VPSHLDW $-1, X0, X1, X2",
+		"VPSHRDD $256, X0, X1, X2",
+		"VPSHLDQ AX, X0, X1, X2",
+		"VPSHRDW $0, Y0, X1, X2",
+		"VPSHLDVD Y0, X1, X2",
+		"VPSHRDVQ X0, Y1, X2",
+		"VPSHLDVW X0, X1, Y2",
+		"VPSHRDQ $0, X0, 8(BX), X2",
+		"VPSHLDVD X0, 8(BX), X2",
+		"VPSHRDVQ X0, X1, 8(BX)",
+		"VPSHLDQ $0, X0, X1, K0, X2",
+		"VPSHRDVD X0, K1, X1, X2",
+		"VPSHLDW.Z $0, X0, X1, X2",
+		"VPSHRDVW.Z X0, X1, X2",
+		"VPSHLDW.BCST $0, 8(BX), X1, X2",
+		"VPSHRDVW.BCST 8(BX), X1, X2",
+		"VPSHLDQ.BCST X0, X1, X2",
+		"VPSHRDVD.BCST X0, X1, X2",
+		"VPSHLDQ.Z.BCST $0, 8(BX), X1, K1, X2",
+		"VPSHRDVQ.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's funnel-shift tables", instruction)
+			}
+		})
+	}
+	for _, instruction := range []string{
+		"VPSHRDQ $0, X0, X1, X2",
+		"VPSHLDW $0, 8(BX), Y1, Y2",
+		"VPSHRDVD X0, X1, K1, X2",
+		"VPSHLDVQ.Z 8(BX), Y1, K7, Y2",
+		"VPSHRDVD.BCST.Z 16(BX), Z1, K2, Z2",
+		"VPSHLDVW Z8, Z0, Z1",
+		"VPSHRDVQ Z0, Z8, Z1",
+		"VPSHLDVD Z0, Z1, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "386",
+				TargetTriple: "i386-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted 386 %q outside Go 1.27's frontend boundary", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64FunnelShiftRuntimeSemantics(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable integer oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT funnelShiftSemantics(SB),$0-64
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ counts+32(FP), SI
+	MOVQ scalarCount+40(FP), R8
+	MOVQ scalarData+48(FP), R9
+	VMOVDQU64 (BX), X0
+	VMOVDQU64 (CX), X1
+	VMOVDQU64 (SI), X3
+	VPSHLDW $4, X0, X1, X4
+	VMOVDQU64 X4, 0(AX)
+	VPSHRDW $4, X0, X1, X5
+	VMOVDQU64 X5, 16(AX)
+	VPSHLDD $8, X0, X1, X6
+	VMOVDQU64 X6, 32(AX)
+	VPSHRDD $8, X0, X1, X7
+	VMOVDQU64 X7, 48(AX)
+	VPSHLDQ $13, X0, X1, X8
+	VMOVDQU64 X8, 64(AX)
+	VPSHRDQ $32, X0, X1, X9
+	VMOVDQU64 X9, 80(AX)
+	VMOVDQU64 (DX), X10
+	VPSHLDVW X3, X1, X10
+	VMOVDQU64 X10, 96(AX)
+	VMOVDQU64 (DX), X11
+	VPSHRDVD X3, X1, X11
+	VMOVDQU64 X11, 112(AX)
+	VMOVDQU64 (DX), X12
+	VPSHLDVQ X3, X1, X12
+	VMOVDQU64 X12, 128(AX)
+	KMOVQ mask+56(FP), K1
+	VMOVDQU64 (DX), X13
+	VPSHRDQ $32, X0, X1, K1, X13
+	VMOVDQU64 X13, 144(AX)
+	VMOVDQU64 (DX), X14
+	VPSHRDQ.Z $32, X0, X1, K1, X14
+	VMOVDQU64 X14, 160(AX)
+	VMOVDQU64 (DX), X15
+	VPSHLDVD.BCST (R8), X1, X15
+	VMOVDQU64 X15, 176(AX)
+	VPSHRDD.BCST $8, (R9), X1, X16
+	VMOVDQU64 X16, 192(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+		{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+		{Offset: 56, Type: I64, Index: 7, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"funnelShiftSemantics": {
+				Name:  "funnelShiftSemantics",
+				Args:  []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64},
+				Ret:   Void,
+				Frame: frame,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+typedef union { uint8_t b[16]; uint16_t w[8]; uint32_t d[4]; uint64_t q[2]; } V;
+extern void funnelShiftSemantics(V *, const V *, const V *, const V *, const V *, const uint32_t *, const uint32_t *, uint64_t);
+static uint16_t shl16(uint16_t a, uint16_t b, unsigned c) { c &= 15; return c ? (uint16_t)((a << c) | (b >> (16-c))) : a; }
+static uint16_t shr16(uint16_t a, uint16_t b, unsigned c) { c &= 15; return c ? (uint16_t)((a >> c) | (b << (16-c))) : a; }
+static uint32_t shl32(uint32_t a, uint32_t b, unsigned c) { c &= 31; return c ? (a << c) | (b >> (32-c)) : a; }
+static uint32_t shr32(uint32_t a, uint32_t b, unsigned c) { c &= 31; return c ? (a >> c) | (b << (32-c)) : a; }
+static uint64_t shl64(uint64_t a, uint64_t b, unsigned c) { c &= 63; return c ? (a << c) | (b >> (64-c)) : a; }
+static uint64_t shr64(uint64_t a, uint64_t b, unsigned c) { c &= 63; return c ? (a >> c) | (b << (64-c)) : a; }
+int main(void) {
+  V first = {.q = {UINT64_C(0x0123456789abcdef), UINT64_C(0xfedcba9876543210)}};
+  V second = {.q = {UINT64_C(0x8877665544332211), UINT64_C(0x1020304050607080)}};
+  V old = {.q = {UINT64_C(0x0f1e2d3c4b5a6978), UINT64_C(0x8796a5b4c3d2e1f0)}};
+  V counts = {.q = {UINT64_C(0x001f000800030000), UINT64_C(0x0041002000110004)}};
+  uint32_t scalarCount = 37;
+  uint32_t scalarData = UINT32_C(0xa1b2c3d4);
+  V out[13] = {0}, want[13] = {0};
+  for (int i = 0; i < 8; i++) {
+    want[0].w[i] = shl16(second.w[i], first.w[i], 4);
+    want[1].w[i] = shr16(second.w[i], first.w[i], 4);
+    want[6].w[i] = shl16(old.w[i], second.w[i], counts.w[i]);
+  }
+  for (int i = 0; i < 4; i++) {
+    want[2].d[i] = shl32(second.d[i], first.d[i], 8);
+    want[3].d[i] = shr32(second.d[i], first.d[i], 8);
+    want[7].d[i] = shr32(old.d[i], second.d[i], counts.d[i]);
+    want[11].d[i] = shl32(old.d[i], second.d[i], scalarCount);
+    want[12].d[i] = shr32(second.d[i], scalarData, 8);
+  }
+  for (int i = 0; i < 2; i++) {
+    want[4].q[i] = shl64(second.q[i], first.q[i], 13);
+    want[5].q[i] = shr64(second.q[i], first.q[i], 32);
+    want[8].q[i] = shl64(old.q[i], second.q[i], counts.q[i]);
+  }
+  want[9].q[0] = want[5].q[0]; want[9].q[1] = old.q[1];
+  want[10].q[0] = want[5].q[0]; want[10].q[1] = 0;
+  funnelShiftSemantics(out, &first, &second, &old, &counts, &scalarCount, &scalarData, 1);
+  return memcmp(out, want, sizeof(out)) == 0 ? 0 : 1;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "funnel_shift", triple, ir, mainC)
+}
diff --git a/amd64_lower_gather.go b/amd64_lower_gather.go
new file mode 100644
index 000000000..b9a0cb0cc
--- /dev/null
+++ b/amd64_lower_gather.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import "fmt"
+
+type amd64GatherTable uint8
+
+const (
+	amd64GatherDPS amd64GatherTable = iota
+	amd64GatherDPD
+	amd64GatherQPS
+)
+
+type amd64GatherSpec struct {
+	table     amd64GatherTable
+	elemBits  int
+	indexBits int
+}
+
+// amd64GatherSpecs is the complete Go 1.27 data-gather family. The eight
+// spellings share _yvgatherdps, _yvgatherdpd, and _yvgatherqps.
+var amd64GatherSpecs = map[Op]amd64GatherSpec{
+	"VGATHERDPS": {table: amd64GatherDPS, elemBits: 32, indexBits: 32},
+	"VGATHERQPD": {table: amd64GatherDPS, elemBits: 64, indexBits: 64},
+	"VPGATHERDD": {table: amd64GatherDPS, elemBits: 32, indexBits: 32},
+	"VPGATHERQQ": {table: amd64GatherDPS, elemBits: 64, indexBits: 64},
+	"VGATHERDPD": {table: amd64GatherDPD, elemBits: 64, indexBits: 32},
+	"VPGATHERDQ": {table: amd64GatherDPD, elemBits: 64, indexBits: 32},
+	"VGATHERQPS": {table: amd64GatherQPS, elemBits: 32, indexBits: 64},
+	"VPGATHERQD": {table: amd64GatherQPS, elemBits: 32, indexBits: 64},
+}
+
+type amd64VSIBPrefetchDirection uint8
+
+const (
+	amd64VSIBPrefetchGather amd64VSIBPrefetchDirection = iota
+	amd64VSIBPrefetchScatter
+)
+
+type amd64VSIBPrefetchSpec struct {
+	direction  amd64VSIBPrefetchDirection
+	hint       int
+	elemBits   int
+	indexBits  int
+	indexBytes int
+}
+
+// amd64VSIBPrefetchSpecs is the complete Go 1.27 gather/scatter prefetch
+// grammar. Direction, cache hint, element width, and VSIB index width are data;
+// all sixteen opcodes share one exact operand validator. These instructions
+// are architectural hints, so lowering has no observable IR side effect.
+var amd64VSIBPrefetchSpecs = map[Op]amd64VSIBPrefetchSpec{
+	"VGATHERPF0DPD":  {direction: amd64VSIBPrefetchGather, hint: 0, elemBits: 64, indexBits: 32, indexBytes: 32},
+	"VGATHERPF0DPS":  {direction: amd64VSIBPrefetchGather, hint: 0, elemBits: 32, indexBits: 32, indexBytes: 64},
+	"VGATHERPF0QPD":  {direction: amd64VSIBPrefetchGather, hint: 0, elemBits: 64, indexBits: 64, indexBytes: 64},
+	"VGATHERPF0QPS":  {direction: amd64VSIBPrefetchGather, hint: 0, elemBits: 32, indexBits: 64, indexBytes: 64},
+	"VGATHERPF1DPD":  {direction: amd64VSIBPrefetchGather, hint: 1, elemBits: 64, indexBits: 32, indexBytes: 32},
+	"VGATHERPF1DPS":  {direction: amd64VSIBPrefetchGather, hint: 1, elemBits: 32, indexBits: 32, indexBytes: 64},
+	"VGATHERPF1QPD":  {direction: amd64VSIBPrefetchGather, hint: 1, elemBits: 64, indexBits: 64, indexBytes: 64},
+	"VGATHERPF1QPS":  {direction: amd64VSIBPrefetchGather, hint: 1, elemBits: 32, indexBits: 64, indexBytes: 64},
+	"VSCATTERPF0DPD": {direction: amd64VSIBPrefetchScatter, hint: 0, elemBits: 64, indexBits: 32, indexBytes: 32},
+	"VSCATTERPF0DPS": {direction: amd64VSIBPrefetchScatter, hint: 0, elemBits: 32, indexBits: 32, indexBytes: 64},
+	"VSCATTERPF0QPD": {direction: amd64VSIBPrefetchScatter, hint: 0, elemBits: 64, indexBits: 64, indexBytes: 64},
+	"VSCATTERPF0QPS": {direction: amd64VSIBPrefetchScatter, hint: 0, elemBits: 32, indexBits: 64, indexBytes: 64},
+	"VSCATTERPF1DPD": {direction: amd64VSIBPrefetchScatter, hint: 1, elemBits: 64, indexBits: 32, indexBytes: 32},
+	"VSCATTERPF1DPS": {direction: amd64VSIBPrefetchScatter, hint: 1, elemBits: 32, indexBits: 32, indexBytes: 64},
+	"VSCATTERPF1QPD": {direction: amd64VSIBPrefetchScatter, hint: 1, elemBits: 64, indexBits: 64, indexBytes: 64},
+	"VSCATTERPF1QPS": {direction: amd64VSIBPrefetchScatter, hint: 1, elemBits: 32, indexBits: 64, indexBytes: 64},
+}
+
+func (c *amd64Ctx) lowerGather(op Op, ins Instr) error {
+	local := ins
+	local.Op = op
+	form, known, err := x86VSIBProperties(local, c.goarch)
+	if err != nil {
+		return err
+	}
+	if !known || form.scatter && !form.prefetch {
+		return fmt.Errorf("amd64 %s is not a gather or VSIB prefetch: %q", op, ins.Raw)
+	}
+	if form.prefetch {
+		return nil
+	}
+	return c.emitGather(form.spec, form.memory.Mem, form.mask, form.data.Reg, form.dataBytes, form.indexBytes, form.evex)
+}
+
+func amd64GatherTableAllows(table amd64GatherTable, evex bool, destinationBytes, indexBytes int) bool {
+	allowed := false
+	switch table {
+	case amd64GatherDPS:
+		allowed = (destinationBytes == 16 && indexBytes == 16) ||
+			(destinationBytes == 32 && indexBytes == 32) ||
+			(destinationBytes == 64 && indexBytes == 64)
+	case amd64GatherDPD:
+		allowed = (destinationBytes == 16 && indexBytes == 16) ||
+			(destinationBytes == 32 && indexBytes == 16) ||
+			(destinationBytes == 64 && indexBytes == 32)
+	case amd64GatherQPS:
+		allowed = (destinationBytes == 16 && (indexBytes == 16 || indexBytes == 32)) ||
+			(destinationBytes == 32 && indexBytes == 64)
+	}
+	if !allowed {
+		return false
+	}
+	if !evex {
+		return destinationBytes != 64
+	}
+	return true
+}
+
+func amd64GatherRegisterIndex(register Reg, byteWidth int, evex bool, goarch string, index bool) (int, bool) {
+	var registerIndex int
+	var ok bool
+	switch byteWidth {
+	case 16:
+		registerIndex, ok = amd64ParseXReg(register)
+	case 32:
+		registerIndex, ok = amd64ParseYReg(register)
+	case 64:
+		registerIndex, ok = amd64ParseZReg(register)
+	}
+	if !ok {
+		return 0, false
+	}
+	limit := 15
+	if evex {
+		limit = 31
+	}
+	if goarch == "386" && (index || byteWidth == 64) {
+		limit = 7
+	}
+	return registerIndex, registerIndex <= limit
+}
+
+func (c *amd64Ctx) emitGather(spec amd64GatherSpec, memory MemRef, mask Operand, destination Reg, destinationBytes, indexBytes int, evex bool) error {
+	destinationValue, err := c.loadGatherVector(destination, destinationBytes)
+	if err != nil {
+		return err
+	}
+	destinationLanes := destinationBytes * 8 / spec.elemBits
+	destinationType := fmt.Sprintf("<%d x i%d>", destinationLanes, spec.elemBits)
+	destinationValues := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", destinationValues, destinationBytes, destinationValue, destinationType)
+	result := "%" + destinationValues
+
+	indexValue, err := c.loadGatherVector(memory.Index, indexBytes)
+	if err != nil {
+		return err
+	}
+	indexLanes := indexBytes * 8 / spec.indexBits
+	indexType := fmt.Sprintf("<%d x i%d>", indexLanes, spec.indexBits)
+	indexValues := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", indexValues, indexBytes, indexValue, indexType)
+	activeLanes := destinationLanes
+	if indexLanes < activeLanes {
+		activeLanes = indexLanes
+		// QPS/QD with an X index has two active dword lanes and architecturally
+		// zeroes the upper two lanes of the X destination.
+		for lane := activeLanes; lane < destinationLanes; lane++ {
+			zeroed := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d 0, i32 %d\n", zeroed, destinationType, result, spec.elemBits, lane)
+			result = "%" + zeroed
+		}
+	}
+
+	var maskValues string
+	var kMask string
+	if evex {
+		kMask, err = c.loadK(mask.Reg)
+	} else {
+		maskBytes, err := c.loadGatherVector(mask.Reg, destinationBytes)
+		if err != nil {
+			return err
+		}
+		maskValues = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", maskValues, destinationBytes, maskBytes, destinationType)
+		maskValues = "%" + maskValues
+	}
+
+	base, err := c.gatherBaseAddress(memory)
+	if err != nil {
+		return err
+	}
+	for lane := 0; lane < activeLanes; lane++ {
+		indexLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", indexLane, indexType, indexValues, lane)
+		wideIndex := "%" + indexLane
+		if spec.indexBits == 32 {
+			extended := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext i32 %%%s to i64\n", extended, indexLane)
+			wideIndex = "%" + extended
+		}
+		if memory.Scale != 0 && memory.Scale != 1 {
+			scaled := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %d\n", scaled, wideIndex, memory.Scale)
+			wideIndex = "%" + scaled
+		}
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", address, base, wideIndex)
+		pointer, pointerType := c.gatherPointer(memory, "%"+address)
+
+		condition := ""
+		if evex {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", shifted, kMask, lane)
+			bit := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 1\n", bit, shifted)
+			set := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", set, bit)
+			condition = "%" + set
+		} else {
+			maskLane := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", maskLane, destinationType, maskValues, lane)
+			set := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %%%s, 0\n", set, spec.elemBits, maskLane)
+			condition = "%" + set
+		}
+
+		oldLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", oldLane, destinationType, result, lane)
+		loadLabel := c.newTmp() + "_gather_load"
+		skipLabel := c.newTmp() + "_gather_skip"
+		joinLabel := c.newTmp() + "_gather_join"
+		loaded := c.newTmp()
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n", condition, loadLabel, skipLabel)
+		fmt.Fprintf(c.b, "%s:\n", loadLabel)
+		// An active architectural access still faults when its result is dead.
+		// Keep the access inside its lane predicate so inactive lanes stay suppressed.
+		fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", loaded, spec.elemBits, pointerType, pointer)
+		fmt.Fprintf(c.b, "  br label %%%s\n", joinLabel)
+		fmt.Fprintf(c.b, "%s:\n", skipLabel)
+		fmt.Fprintf(c.b, "  br label %%%s\n", joinLabel)
+		fmt.Fprintf(c.b, "%s:\n", joinLabel)
+		fmt.Fprintf(c.b, "  %%%s = phi i%d [ %%%s, %%%s ], [ %%%s, %%%s ]\n", selected, spec.elemBits, loaded, loadLabel, oldLane, skipLabel)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n", inserted, destinationType, result, spec.elemBits, selected, lane)
+		result = "%" + inserted
+	}
+
+	bytesResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytesResult, destinationType, result, destinationBytes)
+	if err := c.storePackedMoveOperand(Operand{Kind: OpReg, Reg: destination}, destinationBytes, "%"+bytesResult); err != nil {
+		return err
+	}
+	if evex {
+		return c.storeK(mask.Reg, "0")
+	}
+	return c.storePackedMoveOperand(mask, destinationBytes, "zeroinitializer")
+}
+
+func (c *amd64Ctx) loadGatherVector(register Reg, byteWidth int) (string, error) {
+	switch byteWidth {
+	case 16:
+		return c.loadX(register)
+	case 32:
+		return c.loadY(register)
+	case 64:
+		return c.loadZ(register)
+	default:
+		return "", fmt.Errorf("unsupported gather vector width %d", byteWidth)
+	}
+}
+
+func (c *amd64Ctx) gatherBaseAddress(memory MemRef) (string, error) {
+	base := "0"
+	if memory.Base != "" {
+		value, err := c.loadReg(memory.Base)
+		if err != nil {
+			return "", err
+		}
+		base = value
+	}
+	if memory.Off != 0 {
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", adjusted, base, memory.Off)
+		base = "%" + adjusted
+	}
+	return base, nil
+}
+
+func (c *amd64Ctx) gatherPointer(memory MemRef, address string) (string, string) {
+	if memory.Segment == "" {
+		return c.ptrFromAddrI64(address), "ptr"
+	}
+	addressSpace := 257
+	if memory.Segment == GS {
+		addressSpace = 256
+	}
+	pointerType := fmt.Sprintf("ptr addrspace(%d)", addressSpace)
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to %s\n", pointer, address, pointerType)
+	return "%" + pointer, pointerType
+}
diff --git a/amd64_lower_getexp.go b/amd64_lower_getexp.go
new file mode 100644
index 000000000..5b8a156e9
--- /dev/null
+++ b/amd64_lower_getexp.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64GetExpSpec struct {
+	laneBits int
+	scalar   bool
+}
+
+var amd64GetExpSpecs = map[Op]amd64GetExpSpec{
+	"VGETEXPPS": {laneBits: 32},
+	"VGETEXPPD": {laneBits: 64},
+	"VGETEXPSS": {laneBits: 32, scalar: true},
+	"VGETEXPSD": {laneBits: 64, scalar: true},
+}
+
+func (c *amd64Ctx) lowerGetExp(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64GetExpSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix || properties.rounding != "" {
+		return true, false, fmt.Errorf("%s %s has a suffix absent from Go 1.27's GETEXP optab: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.scalar && properties.broadcast {
+		return true, false, fmt.Errorf("%s %s scalar forms do not support broadcast: %q", c.goarch, baseOp, ins.Raw)
+	}
+	wantArgs := 2
+	if spec.scalar {
+		wantArgs = 3
+	}
+	if len(ins.Args) != wantArgs && len(ins.Args) != wantArgs+1 {
+		return true, false, fmt.Errorf("%s %s has the wrong operand count for its packed/scalar grammar: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == wantArgs+1
+	if c.goarch == "386" && spec.scalar && masked {
+		return true, false, fmt.Errorf("386 %s mask form exceeds the Go assembler frontend's three-operand limit: %q", baseOp, ins.Raw)
+	}
+	if properties.zeroing && !masked {
+		return true, false, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+	maskIndex := len(ins.Args) - 2
+	if masked && !amd64NonzeroKOperand(ins.Args[maskIndex]) {
+		return true, false, fmt.Errorf("%s %s masked form expects K1-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s destination must be a vector register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	if spec.scalar {
+		if byteWidth != 16 || !c.isGoEVEXVectorRegister(destination, 16) || !c.isGoEVEXVectorRegister(ins.Args[1], 16) {
+			return true, false, fmt.Errorf("%s %s scalar pass-through and destination must be X registers: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 || !c.isGoEVEXVectorRegister(destination, byteWidth) {
+		return true, false, fmt.Errorf("%s %s packed destination must be an in-range X, Y, or Z register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	source := ins.Args[0]
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(source) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a scalar memory source: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if source.Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(source, byteWidth) {
+			return true, false, fmt.Errorf("%s %s source register must match the destination width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return true, false, fmt.Errorf("%s %s source must be a matching vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.sae {
+		if source.Kind != OpReg || !spec.scalar && byteWidth != 64 {
+			return true, false, fmt.Errorf("%s %s.SAE requires a register source and scalar or Z form: %q", c.goarch, baseOp, ins.Raw)
+		}
+	}
+
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[maskIndex].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	daz := c.loadMXCSRDAZ()
+	if spec.scalar {
+		return c.lowerScalarGetExp(spec, properties, source, ins.Args[1], destination, mask, daz)
+	}
+	return c.lowerPackedGetExp(spec, properties, source, destination, byteWidth, mask, daz)
+}
+
+func (c *amd64Ctx) lowerPackedGetExp(spec amd64GetExpSpec, properties amd64BinaryFloatingSuffix, source, destination Operand, byteWidth int, mask, daz string) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	input, err := c.loadPackedCompareLanes(source, byteWidth, spec.laneBits, properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitGetExpBits(lanes, spec.laneBits, input, daz)
+	if mask != "" {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarGetExp(spec amd64GetExpSpec, properties amd64BinaryFloatingSuffix, source, passthrough, destination Operand, mask, daz string) (bool, bool, error) {
+	sourceBits, err := c.loadFloatingScalarBits(source, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	input := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", input, spec.laneBits, spec.laneBits, sourceBits)
+	result := c.emitGetExpBits(1, spec.laneBits, "%"+input, daz)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	passthroughBytes, err := c.loadX(passthrough.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, passthroughBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+low, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) emitGetExpBits(lanes, laneBits int, input, daz string) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	floatType := amd64FloatingScalarType(laneBits)
+	mantissaBits, bias, denormalOffset := 23, 127, 149
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	signBit := uint64(0x80000000)
+	if laneBits == 64 {
+		mantissaBits, bias, denormalOffset = 52, 1023, 1074
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+		signBit = uint64(0x8000000000000000)
+	}
+	positiveInfinity := exponentMask
+	negativeInfinity := signBit | exponentMask
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		bits, exponent, mantissa := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", bits, vectorType, input, lane)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", exponent, laneBits, bits, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", mantissa, laneBits, bits, mantissaMask)
+		exponentZero, exponentOnes := c.newTmp(), c.newTmp()
+		mantissaZero, mantissaNonzero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", exponentZero, laneBits, exponent)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", exponentOnes, laneBits, exponent, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", mantissaZero, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", mantissaNonzero, laneBits, mantissa)
+		isNaN, isInfinity, isDenormal := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isNaN, exponentOnes, mantissaNonzero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isInfinity, exponentOnes, mantissaZero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isDenormal, exponentZero, mantissaNonzero)
+		zeroOrDAZ, isEffectiveZero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %s\n", zeroOrDAZ, mantissaZero, daz)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isEffectiveZero, exponentZero, zeroOrDAZ)
+
+		normalField, normalExponent := c.newTmp(), c.newTmp()
+		leadingZeros, highestBit, denormalExponent := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %d\n", normalField, laneBits, exponent, mantissaBits)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, %d\n", normalExponent, laneBits, normalField, bias)
+		fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.ctlz.i%d(i%d %%%s, i1 false)\n", leadingZeros, laneBits, laneBits, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %d, %%%s\n", highestBit, laneBits, laneBits-1, leadingZeros)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, %d\n", denormalExponent, laneBits, highestBit, denormalOffset)
+		exponentValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", exponentValue, isDenormal, laneBits, denormalExponent, laneBits, normalExponent)
+		exponentFloat, exponentBits := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sitofp i%d %%%s to %s\n", exponentFloat, laneBits, exponentValue, floatType)
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to i%d\n", exponentBits, floatType, exponentFloat, laneBits)
+		withInfinity, withZero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %%%s\n", withInfinity, isInfinity, laneBits, positiveInfinity, laneBits, exponentBits)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %%%s\n", withZero, isEffectiveZero, laneBits, negativeInfinity, laneBits, withInfinity)
+		quietNaN := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", quietNaN, laneBits, bits, quietBit)
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", selected, isNaN, laneBits, quietNaN, laneBits, withZero)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n", inserted, vectorType, result, laneBits, selected, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_getexp_test.go b/amd64_lower_getexp_test.go
new file mode 100644
index 000000000..f3fc2d4f5
--- /dev/null
+++ b/amd64_lower_getexp_test.go
@@ -0,0 +1,254 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64GetExpGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64GetExpSpec{
+		"VGETEXPPS": {laneBits: 32},
+		"VGETEXPPD": {laneBits: 64},
+		"VGETEXPSS": {laneBits: 32, scalar: true},
+		"VGETEXPSD": {laneBits: 64, scalar: true},
+	}
+	if len(amd64GetExpSpecs) != len(expected) {
+		t.Fatalf("GETEXP grammar has %d entries, want %d", len(amd64GetExpSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64GetExpSpecs[op]; !ok {
+			t.Errorf("GETEXP grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("GETEXP grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86GetExpCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT getexpforms(SB),$0-0\n")
+			for _, op := range []string{"VGETEXPPS", "VGETEXPPD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST 16(AX), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s %s1, K1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.Z 24(AX), K2, %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST.Z 32(AX), K3, %s%d\n", op, width, last)
+					if width == "Z" {
+						fmt.Fprintf(&source, "\t%s.SAE Z1, Z%d\n", op, last)
+						fmt.Fprintf(&source, "\t%s.SAE.Z Z1, K4, Z%d\n", op, last)
+					}
+				}
+			}
+			for _, op := range []string{"VGETEXPSS", "VGETEXPSD"} {
+				last := 31
+				fmt.Fprintf(&source, "\t%s X1, X2, X%d\n", op, last)
+				fmt.Fprintf(&source, "\t%s 40(AX), X2, X%d\n", op, last)
+				fmt.Fprintf(&source, "\t%s.SAE X1, X2, X%d\n", op, last)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X2, K5, X%d\n", op, last)
+					fmt.Fprintf(&source, "\t%s.Z 48(AX), X2, K6, X%d\n", op, last)
+					fmt.Fprintf(&source, "\t%s.SAE.Z X1, X2, K7, X%d\n", op, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "getexpforms", target.goarch, target.triple)
+			if ir == "" {
+				return // Go/public-Context coverage, not an LLVM object claim.
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "getexp-"+target.name+".ll", "getexp-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86GetExpRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VGETEXPPS X0"},
+		{goarch: "amd64", instruction: "VGETEXPPS X0, Y1"},
+		{goarch: "amd64", instruction: "VGETEXPPS.BCST X0, X1"},
+		{goarch: "amd64", instruction: "VGETEXPPS.SAE X0, X1"},
+		{goarch: "amd64", instruction: "VGETEXPPS.SAE 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VGETEXPPS.RN_SAE Z0, Z1"},
+		{goarch: "amd64", instruction: "VGETEXPPS.Z X0, X1"},
+		{goarch: "amd64", instruction: "VGETEXPPS X0, K0, X1"},
+		{goarch: "amd64", instruction: "VGETEXPSS Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VGETEXPSS.BCST 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VGETEXPSD X0, X1, Y2"},
+		{goarch: "386", instruction: "VGETEXPSS X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VGETEXPPS Z8, Z0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's GETEXP table", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64GetExpRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	const source = `TEXT getexpsemantics(SB),$0-56
+	MOVQ out+0(FP), AX
+	MOVQ source32+8(FP), BX
+	MOVQ source64+16(FP), CX
+	MOVQ old32+24(FP), DX
+	MOVQ old64+32(FP), R8
+	MOVQ upper+40(FP), R9
+	MOVQ mask+48(FP), R10
+	KMOVQ R10, K1
+	STC
+	VGETEXPPS 0(BX), Z0
+	VMOVDQU32 Z0, 0(AX)
+	VMOVDQU32 0(DX), Z1
+	VGETEXPPS 0(BX), K1, Z1
+	VMOVDQU32 Z1, 64(AX)
+	VGETEXPPS.Z 0(BX), K1, Z1
+	VMOVDQU32 Z1, 128(AX)
+	VGETEXPPS.BCST 0(BX), Z1
+	VMOVDQU32 Z1, 192(AX)
+	VGETEXPPD 0(CX), Z2
+	VMOVDQU64 Z2, 256(AX)
+	VMOVDQU64 0(R8), Z3
+	VGETEXPPD 0(CX), K1, Z3
+	VMOVDQU64 Z3, 320(AX)
+	VGETEXPPD.Z 0(CX), K1, Z3
+	VMOVDQU64 Z3, 384(AX)
+	VGETEXPPD.BCST 0(CX), Z3
+	VMOVDQU64 Z3, 448(AX)
+	VMOVDQU64 0(R9), X4
+	VGETEXPSS 40(BX), X4, X5
+	VMOVDQU64 X5, 512(AX)
+	VGETEXPSD 40(CX), X4, X6
+	VMOVDQU64 X6, 528(AX)
+	SETCS 544(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"getexpsemantics": {
+			Name: "getexpsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: I64, Index: 6, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void getexpsemantics(uint8_t *, const uint32_t *, const uint64_t *, const uint32_t *, const uint64_t *, const uint64_t *, uint64_t);
+static uint32_t f32bits(float f) { uint32_t u; memcpy(&u,&f,4); return u; }
+static uint64_t f64bits(double f) { uint64_t u; memcpy(&u,&f,8); return u; }
+static uint32_t getexp32(uint32_t u, int daz) {
+  uint32_t exp=u&UINT32_C(0x7f800000), mant=u&UINT32_C(0x007fffff);
+  if (exp==UINT32_C(0x7f800000)) return mant?(u|UINT32_C(0x00400000)):UINT32_C(0x7f800000);
+  if (exp==0 && (mant==0||daz)) return UINT32_C(0xff800000);
+  int e;
+  if (exp) e=(int)(exp>>23)-127;
+  else { int p=31-__builtin_clz(mant); e=p-149; }
+  return f32bits((float)e);
+}
+static uint64_t getexp64(uint64_t u, int daz) {
+  uint64_t exp=u&UINT64_C(0x7ff0000000000000), mant=u&UINT64_C(0x000fffffffffffff);
+  if (exp==UINT64_C(0x7ff0000000000000)) return mant?(u|UINT64_C(0x0008000000000000)):UINT64_C(0x7ff0000000000000);
+  if (exp==0 && (mant==0||daz)) return UINT64_C(0xfff0000000000000);
+  int e;
+  if (exp) e=(int)(exp>>52)-1023;
+  else { int p=63-__builtin_clzll(mant); e=p-1074; }
+  return f64bits((double)e);
+}
+int main(void) {
+  const uint32_t source32[16]={
+    0x3f800000,0x40000000,0x3f400000,0xc1000000,0,0x80000000,0x7f800000,0xff800000,
+    0x7fc12345,0x7f812345,1,0x007fffff,0x80000001,0x00800000,0x7f7fffff,0x3e800000};
+  const uint64_t source64[8]={
+    UINT64_C(0x3ff0000000000000),UINT64_C(0x4000000000000000),UINT64_C(0x3fe8000000000000),UINT64_C(0xc020000000000000),
+    0,1,UINT64_C(0x000fffffffffffff),UINT64_C(0x8000000000000001)};
+  uint32_t old32[16]; uint64_t old64[8];
+  const uint64_t upper[2]={UINT64_C(0x1122334455667788),UINT64_C(0x99aabbccddeeff00)};
+  uint8_t out[545]={0}, outDaz[545]={0}; const uint64_t mask=UINT64_C(0xa55a);
+  for (int i=0;i<16;i++) old32[i]=UINT32_C(0x41000000)+(uint32_t)i;
+  for (int i=0;i<8;i++) old64[i]=UINT64_C(0x4020000000000000)+(uint64_t)i;
+  getexpsemantics(out,source32,source64,old32,old64,upper,mask);
+  unsigned csr=_mm_getcsr(); _mm_setcsr(csr|UINT32_C(0x40));
+  getexpsemantics(outDaz,source32,source64,old32,old64,upper,mask); _mm_setcsr(csr);
+  for (int i=0;i<16;i++) {
+    uint32_t want=getexp32(source32[i],0), got; memcpy(&got,out+4*i,4); if (got!=want) return 10;
+    memcpy(&got,out+64+4*i,4); if (got!=(((mask>>i)&1)?want:old32[i])) return 11;
+    memcpy(&got,out+128+4*i,4); if (got!=(((mask>>i)&1)?want:0)) return 12;
+    memcpy(&got,out+192+4*i,4); if (got!=getexp32(source32[0],0)) return 13;
+  }
+  for (int i=0;i<8;i++) {
+    uint64_t want=getexp64(source64[i],0), got; memcpy(&got,out+256+8*i,8); if (got!=want) return 20;
+    memcpy(&got,out+320+8*i,8); if (got!=(((mask>>i)&1)?want:old64[i])) return 21;
+    memcpy(&got,out+384+8*i,8); if (got!=(((mask>>i)&1)?want:0)) return 22;
+    memcpy(&got,out+448+8*i,8); if (got!=getexp64(source64[0],0)) return 23;
+  }
+  uint32_t scalar32; memcpy(&scalar32,out+512,4); if (scalar32!=getexp32(source32[10],0)) return 30;
+  if (memcmp(out+516,(uint8_t*)upper+4,12)) return 31;
+  uint64_t scalar64; memcpy(&scalar64,out+528,8); if (scalar64!=getexp64(source64[5],0)) return 32;
+  if (memcmp(out+536,(uint8_t*)upper+8,8)) return 33;
+  if (out[544]!=1) return 34;
+  uint32_t daz32; memcpy(&daz32,outDaz+40,4); if (daz32!=UINT32_C(0xff800000)) return 40;
+  uint64_t daz64; memcpy(&daz64,outDaz+296,8); if (daz64!=UINT64_C(0xfff0000000000000)) return 41;
+  memcpy(&daz32,outDaz+512,4); if (daz32!=UINT32_C(0xff800000)) return 42;
+  memcpy(&daz64,outDaz+528,8); if (daz64!=UINT64_C(0xfff0000000000000)) return 43;
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "getexp_semantics", ir, mainC)
+}
diff --git a/amd64_lower_getmant.go b/amd64_lower_getmant.go
new file mode 100644
index 000000000..4a68c58e5
--- /dev/null
+++ b/amd64_lower_getmant.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64GetMantSpec = amd64UnaryImmediateFloatingShape
+
+var amd64GetMantSpecs = map[Op]amd64GetMantSpec{
+	"VGETMANTPS": {laneBits: 32},
+	"VGETMANTPD": {laneBits: 64},
+	"VGETMANTSS": {laneBits: 32, scalar: true},
+	"VGETMANTSD": {laneBits: 64, scalar: true},
+}
+
+func (c *amd64Ctx) lowerGetMant(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64GetMantSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	form, err := c.parseUnaryImmediateFloatingForm(baseOp, suffix, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	daz := c.loadMXCSRDAZ()
+	if spec.scalar {
+		return c.lowerScalarGetMant(spec, form.properties, form.source, form.passthrough, form.destination, form.mask, daz, form.immediate)
+	}
+	return c.lowerPackedGetMant(spec, form.properties, form.source, form.destination, form.byteWidth, form.mask, daz, form.immediate)
+}
+
+func (c *amd64Ctx) lowerPackedGetMant(spec amd64GetMantSpec, properties amd64BinaryFloatingSuffix, source, destination Operand, byteWidth int, mask, daz string, immediate uint8) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	input, err := c.loadPackedCompareLanes(source, byteWidth, spec.laneBits, properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitGetMantBits(lanes, spec.laneBits, input, daz, immediate)
+	if mask != "" {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarGetMant(spec amd64GetMantSpec, properties amd64BinaryFloatingSuffix, source, passthrough, destination Operand, mask, daz string, immediate uint8) (bool, bool, error) {
+	sourceBits, err := c.loadFloatingScalarBits(source, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	input := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", input, spec.laneBits, spec.laneBits, sourceBits)
+	result := c.emitGetMantBits(1, spec.laneBits, "%"+input, daz, immediate)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	passthroughBytes, err := c.loadX(passthrough.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, passthroughBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+low, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) emitGetMantBits(lanes, laneBits int, input, daz string, immediate uint8) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	mantissaBits, bias := 23, 127
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	signBit := uint64(0x80000000)
+	indefinite := uint64(0xffc00000)
+	if laneBits == 64 {
+		mantissaBits, bias = 52, 1023
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+		signBit = uint64(0x8000000000000000)
+		indefinite = uint64(0xfff8000000000000)
+	}
+	interval := immediate & 3
+	signControl := immediate >> 2 & 3
+	positiveOne := uint64(bias) << mantissaBits
+	signedOne := positiveOne
+	if signControl&1 == 0 {
+		signedOne |= signBit
+	}
+	dazClear := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i1 %s, false\n", dazClear, daz)
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		bits, exponent, mantissa, sign := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", bits, vectorType, input, lane)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", exponent, laneBits, bits, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", mantissa, laneBits, bits, mantissaMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", sign, laneBits, bits, signBit)
+		exponentZero, exponentOnes := c.newTmp(), c.newTmp()
+		mantissaZero, mantissaNonzero, negative := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", exponentZero, laneBits, exponent)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", exponentOnes, laneBits, exponent, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", mantissaZero, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", mantissaNonzero, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", negative, laneBits, sign)
+		isNaN, isInfinity, isDenormal := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isNaN, exponentOnes, mantissaNonzero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isInfinity, exponentOnes, mantissaZero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isDenormal, exponentZero, mantissaNonzero)
+		activeDenormal := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", activeDenormal, isDenormal, dazClear)
+		zeroOrDAZ, effectiveZero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %s\n", zeroOrDAZ, mantissaZero, daz)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", effectiveZero, exponentZero, zeroOrDAZ)
+
+		leadingZeros, shiftCount, shifted, normalizedFraction := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.ctlz.i%d(i%d %%%s, i1 false)\n", leadingZeros, laneBits, laneBits, laneBits, mantissa)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, %d\n", shiftCount, laneBits, leadingZeros, laneBits-mantissaBits-1)
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %%%s, %%%s\n", shifted, laneBits, mantissa, shiftCount)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", normalizedFraction, laneBits, shifted, mantissaMask)
+		fraction := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", fraction, activeDenormal, laneBits, normalizedFraction, laneBits, mantissa)
+		exponentField, unbiasedNormal, unbiasedDenormal, unbiased := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %d\n", exponentField, laneBits, exponent, mantissaBits)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, %d\n", unbiasedNormal, laneBits, exponentField, bias)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d 0, %%%s\n", unbiasedDenormal, laneBits, shiftCount)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", unbiased, activeDenormal, laneBits, unbiasedDenormal, laneBits, unbiasedNormal)
+		oddValue, odd := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, 1\n", oddValue, laneBits, unbiased)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", odd, laneBits, oddValue)
+		fractionTop, topSet := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", fractionTop, laneBits, fraction, quietBit)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", topSet, laneBits, fractionTop)
+		normalizedExponent := fmt.Sprintf("%d", bias)
+		switch interval {
+		case 1:
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %d\n", selected, odd, laneBits, bias-1, laneBits, bias)
+			normalizedExponent = "%" + selected
+		case 2:
+			normalizedExponent = fmt.Sprintf("%d", bias-1)
+		case 3:
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %d\n", selected, topSet, laneBits, bias-1, laneBits, bias)
+			normalizedExponent = "%" + selected
+		}
+		exponentBits, magnitude := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %s, %d\n", exponentBits, laneBits, normalizedExponent, mantissaBits)
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %%%s\n", magnitude, laneBits, exponentBits, fraction)
+		computed := "%" + magnitude
+		if signControl&1 == 0 {
+			withSign := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %%%s\n", withSign, laneBits, magnitude, sign)
+			computed = "%" + withSign
+		}
+		zeroOrInfinity := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", zeroOrInfinity, effectiveZero, isInfinity)
+		specialOne := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %d\n", specialOne, negative, laneBits, signedOne, laneBits, positiveOne)
+		withSpecial := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %s\n", withSpecial, zeroOrInfinity, laneBits, specialOne, laneBits, computed)
+		selected := "%" + withSpecial
+		if signControl&2 != 0 {
+			notZero := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notZero, effectiveZero)
+			nonzeroNegative := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", nonzeroNegative, negative, notZero)
+			indefiniteResult := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %s\n", indefiniteResult, nonzeroNegative, laneBits, indefinite, laneBits, selected)
+			selected = "%" + indefiniteResult
+		}
+		quietNaN := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", quietNaN, laneBits, bits, quietBit)
+		final := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %s\n", final, isNaN, laneBits, quietNaN, laneBits, selected)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n", inserted, vectorType, result, laneBits, final, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_getmant_test.go b/amd64_lower_getmant_test.go
new file mode 100644
index 000000000..b92f01772
--- /dev/null
+++ b/amd64_lower_getmant_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64GetMantGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64GetMantSpec{
+		"VGETMANTPS": {laneBits: 32},
+		"VGETMANTPD": {laneBits: 64},
+		"VGETMANTSS": {laneBits: 32, scalar: true},
+		"VGETMANTSD": {laneBits: 64, scalar: true},
+	}
+	if len(amd64GetMantSpecs) != len(expected) {
+		t.Fatalf("GETMANT grammar has %d entries, want %d", len(amd64GetMantSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64GetMantSpecs[op]; !ok {
+			t.Errorf("GETMANT grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("GETMANT grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86GetMantCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT getmantforms(SB),$0-0\n")
+			for _, op := range []string{"VGETMANTPS", "VGETMANTPD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s $0, %s1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s $255, 8(AX), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST $1, 16(AX), %s%d\n", op, width, last)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s $2, %s1, K1, %s%d\n", op, width, width, last)
+						fmt.Fprintf(&source, "\t%s.Z $3, 24(AX), K2, %s%d\n", op, width, last)
+						fmt.Fprintf(&source, "\t%s.BCST.Z $4, 32(AX), K3, %s%d\n", op, width, last)
+					}
+					if width == "Z" {
+						fmt.Fprintf(&source, "\t%s.SAE $5, Z1, Z%d\n", op, last)
+						if target.goarch == "amd64" {
+							fmt.Fprintf(&source, "\t%s.SAE.Z $6, Z1, K4, Z%d\n", op, last)
+						}
+					}
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, op := range []string{"VGETMANTSS", "VGETMANTSD"} {
+					fmt.Fprintf(&source, "\t%s $0, X1, X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s $255, 40(AX), X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.SAE $1, X1, X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s $2, X1, X2, K5, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.Z $3, 48(AX), X2, K6, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.SAE.Z $4, X1, X2, K7, X31\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "getmantforms", target.goarch, target.triple)
+			if ir == "" {
+				return // Go/public-Context coverage, not an LLVM object claim.
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "getmant-"+target.name+".ll", "getmant-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86GetMantRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VGETMANTPS $-1, X0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS $256, X0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS X0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS $0, X0, Y1"},
+		{goarch: "amd64", instruction: "VGETMANTPS.BCST $0, X0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS.SAE $0, Z0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS.SAE $0, 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VGETMANTPS.RN_SAE $0, Z0, Z1"},
+		{goarch: "amd64", instruction: "VGETMANTPS.Z $0, X0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTPS $0, X0, K0, X1"},
+		{goarch: "amd64", instruction: "VGETMANTSS $0, Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VGETMANTSS.BCST $0, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VGETMANTSD $0, X0, X1, Y2"},
+		{goarch: "386", instruction: "VGETMANTSS $0, X0, X1, X2"},
+		{goarch: "386", instruction: "VGETMANTPS $0, X0, K1, X2"},
+		{goarch: "386", instruction: "VGETMANTPS $0, Z8, Z0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's GETMANT table", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64GetMantRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	var source strings.Builder
+	source.WriteString(`TEXT getmantsemantics(SB),$0-56
+	MOVQ out+0(FP), AX
+	MOVQ source32+8(FP), BX
+	MOVQ source64+16(FP), CX
+	MOVQ old32+24(FP), DX
+	MOVQ old64+32(FP), R8
+	MOVQ upper+40(FP), R9
+	MOVQ mask+48(FP), R10
+	KMOVQ R10, K1
+	STC
+`)
+	for immediate := 0; immediate < 16; immediate++ {
+		fmt.Fprintf(&source, "\tVGETMANTPS $%d, 0(BX), Z0\n", immediate)
+		fmt.Fprintf(&source, "\tVMOVDQU32 Z0, %d(AX)\n", immediate*64)
+		fmt.Fprintf(&source, "\tVGETMANTPD $%d, 0(CX), Z1\n", immediate)
+		fmt.Fprintf(&source, "\tVMOVDQU64 Z1, %d(AX)\n", 1024+immediate*64)
+	}
+	source.WriteString(`	VMOVDQU32 0(DX), Z2
+	VGETMANTPS $3, 0(BX), K1, Z2
+	VMOVDQU32 Z2, 2048(AX)
+	VGETMANTPS.Z $3, 0(BX), K1, Z2
+	VMOVDQU32 Z2, 2112(AX)
+	VGETMANTPS.BCST $5, 0(BX), Z2
+	VMOVDQU32 Z2, 2176(AX)
+	VMOVDQU64 0(R8), Z3
+	VGETMANTPD $3, 0(CX), K1, Z3
+	VMOVDQU64 Z3, 2240(AX)
+	VGETMANTPD.Z $3, 0(CX), K1, Z3
+	VMOVDQU64 Z3, 2304(AX)
+	VGETMANTPD.BCST $5, 0(CX), Z3
+	VMOVDQU64 Z3, 2368(AX)
+	VMOVDQU64 0(R9), X4
+	VGETMANTSS $11, 12(BX), X4, X5
+	VMOVDQU64 X5, 2432(AX)
+	VGETMANTSD $11, 24(CX), X4, X6
+	VMOVDQU64 X6, 2448(AX)
+	SETCS 2464(AX)
+	RET
+`)
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"getmantsemantics": {
+			Name: "getmantsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: I64, Index: 6, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void getmantsemantics(uint8_t *, const uint32_t *, const uint64_t *, const uint32_t *, const uint64_t *, const uint64_t *, uint64_t);
+static uint32_t getmant32(uint32_t u, unsigned imm, int daz) {
+  const uint32_t em=UINT32_C(0x7f800000), fm=UINT32_C(0x007fffff), qb=UINT32_C(0x00400000), sb=UINT32_C(0x80000000);
+  uint32_t exp=u&em, frac=u&fm, sign=u&sb; unsigned sc=(imm>>2)&3, interval=imm&3;
+  int nan=exp==em&&frac!=0, inf=exp==em&&frac==0, zero=exp==0&&(frac==0||daz), neg=sign!=0;
+  if (nan) return u|qb;
+  uint32_t one=UINT32_C(0x3f800000), signedOne=one|((sc&1)?0:sign);
+  if (neg && !zero && (sc&2)) return UINT32_C(0xffc00000);
+  if (zero||inf) return neg?signedOne:one;
+  int unbiased;
+  if (exp==0) { int shift=__builtin_clz(frac)-8; frac=(frac<<shift)&fm; unbiased=-shift; }
+  else unbiased=(int)(exp>>23)-127;
+  uint32_t outExp=127;
+  if (interval==1) outExp=(unbiased&1)?126:127;
+  else if (interval==2) outExp=126;
+  else if (interval==3) outExp=(frac&qb)?126:127;
+  return (outExp<<23)|frac|((sc&1)?0:sign);
+}
+static uint64_t getmant64(uint64_t u, unsigned imm, int daz) {
+  const uint64_t em=UINT64_C(0x7ff0000000000000), fm=UINT64_C(0x000fffffffffffff), qb=UINT64_C(0x0008000000000000), sb=UINT64_C(0x8000000000000000);
+  uint64_t exp=u&em, frac=u&fm, sign=u&sb; unsigned sc=(imm>>2)&3, interval=imm&3;
+  int nan=exp==em&&frac!=0, inf=exp==em&&frac==0, zero=exp==0&&(frac==0||daz), neg=sign!=0;
+  if (nan) return u|qb;
+  uint64_t one=UINT64_C(0x3ff0000000000000), signedOne=one|((sc&1)?0:sign);
+  if (neg && !zero && (sc&2)) return UINT64_C(0xfff8000000000000);
+  if (zero||inf) return neg?signedOne:one;
+  int unbiased;
+  if (exp==0) { int shift=__builtin_clzll(frac)-11; frac=(frac<<shift)&fm; unbiased=-shift; }
+  else unbiased=(int)(exp>>52)-1023;
+  uint64_t outExp=1023;
+  if (interval==1) outExp=(unbiased&1)?1022:1023;
+  else if (interval==2) outExp=1022;
+  else if (interval==3) outExp=(frac&qb)?1022:1023;
+  return (outExp<<52)|frac|((sc&1)?0:sign);
+}
+static uint32_t u32(const uint8_t *p) { uint32_t v; memcpy(&v,p,4); return v; }
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  const uint32_t source32[16]={
+    0x3f800000,0xbf800000,0x40400000,0xc0400000,0x3f400000,0xbf400000,0,0x80000000,
+    0x7f800000,0xff800000,0x7fc12345,0xff812345,1,0x807fffff,0x00800000,0x7f7fffff};
+  const uint64_t source64[8]={
+    UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x4008000000000000),UINT64_C(0xc008000000000000),
+    0,UINT64_C(0x8000000000000000),UINT64_C(1),UINT64_C(0xfff0000000000000)};
+  uint32_t old32[16]; uint64_t old64[8];
+  const uint64_t upper[2]={UINT64_C(0x1122334455667788),UINT64_C(0x99aabbccddeeff00)};
+  uint8_t out[2465]={0}, outDaz[2465]={0}; const uint64_t mask=UINT64_C(0xa55a);
+  for (int i=0;i<16;i++) old32[i]=UINT32_C(0x41000000)+(uint32_t)i;
+  for (int i=0;i<8;i++) old64[i]=UINT64_C(0x4020000000000000)+(uint64_t)i;
+  getmantsemantics(out,source32,source64,old32,old64,upper,mask);
+  unsigned csr=_mm_getcsr(); _mm_setcsr(csr|UINT32_C(0x40));
+  getmantsemantics(outDaz,source32,source64,old32,old64,upper,mask); _mm_setcsr(csr);
+  for (unsigned imm=0;imm<16;imm++) {
+    for (int i=0;i<16;i++) {
+      if (u32(out+imm*64+i*4)!=getmant32(source32[i],imm,0)) return 10;
+      if (u32(outDaz+imm*64+i*4)!=getmant32(source32[i],imm,1)) return 11;
+    }
+    for (int i=0;i<8;i++) {
+      if (u64(out+1024+imm*64+i*8)!=getmant64(source64[i],imm,0)) return 12;
+      if (u64(outDaz+1024+imm*64+i*8)!=getmant64(source64[i],imm,1)) return 13;
+    }
+  }
+  for (int i=0;i<16;i++) {
+    uint32_t want=getmant32(source32[i],3,0);
+    if (u32(out+2048+i*4)!=(((mask>>i)&1)?want:old32[i])) return 20;
+    if (u32(out+2112+i*4)!=(((mask>>i)&1)?want:0)) return 21;
+    if (u32(out+2176+i*4)!=getmant32(source32[0],5,0)) return 22;
+  }
+  for (int i=0;i<8;i++) {
+    uint64_t want=getmant64(source64[i],3,0);
+    if (u64(out+2240+i*8)!=(((mask>>i)&1)?want:old64[i])) return 23;
+    if (u64(out+2304+i*8)!=(((mask>>i)&1)?want:0)) return 24;
+    if (u64(out+2368+i*8)!=getmant64(source64[0],5,0)) return 25;
+  }
+  if (u32(out+2432)!=getmant32(source32[3],11,0)) return 30;
+  if (memcmp(out+2436,(const uint8_t *)upper+4,12)) return 31;
+  if (u64(out+2448)!=getmant64(source64[3],11,0)) return 32;
+  if (memcmp(out+2456,(const uint8_t *)upper+8,8)) return 33;
+  if (out[2464]!=1) return 34;
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "getmant_semantics", ir, mainC)
+}
diff --git a/amd64_lower_gfni.go b/amd64_lower_gfni.go
new file mode 100644
index 000000000..6251a2090
--- /dev/null
+++ b/amd64_lower_gfni.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64GFNIMode uint8
+
+const (
+	amd64GFNIMultiply amd64GFNIMode = iota
+	amd64GFNIAffine
+	amd64GFNIAffineInverse
+)
+
+type amd64GFNISpec struct {
+	mode      amd64GFNIMode
+	immediate bool
+	broadcast bool
+}
+
+// amd64GFNISpecs models the whole Go 1.27 GFNI family. VGF2P8MULB uses the
+// eight _yvandnpd rows; both affine instructions use the eight
+// _yvgf2p8affineinvqb rows, including qword broadcast for their matrix source.
+var amd64GFNISpecs = map[Op]amd64GFNISpec{
+	"VGF2P8MULB":        {mode: amd64GFNIMultiply},
+	"VGF2P8AFFINEQB":    {mode: amd64GFNIAffine, immediate: true, broadcast: true},
+	"VGF2P8AFFINEINVQB": {mode: amd64GFNIAffineInverse, immediate: true, broadcast: true},
+}
+
+func (c *amd64Ctx) lowerGFNI(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86GFNIProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	first, second := ins.Args[form.first], ins.Args[form.second]
+	destination := ins.Args[form.destination]
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	firstBytes, err := c.loadGFNIFirstSource(first, byteWidth, form.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	secondBytes, err := c.loadPackedCompareBytes(second, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	computed := ""
+	switch spec.mode {
+	case amd64GFNIMultiply:
+		computed = c.emitGF2P8Multiply(byteWidth, firstBytes, secondBytes)
+	case amd64GFNIAffine, amd64GFNIAffineInverse:
+		if spec.mode == amd64GFNIAffineInverse {
+			secondBytes = c.emitGF2P8Inverse(byteWidth, secondBytes)
+		}
+		computed = c.emitGF2P8Affine(byteWidth, firstBytes, secondBytes, form.immediate)
+	}
+	if form.mask >= 0 {
+		old, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		computed = amd64ApplyIntegerLaneMask(c, byteWidth, 8, computed, old, mask, form.zeroing)
+	}
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, computed)
+}
+
+func (c *amd64Ctx) loadGFNIFirstSource(source Operand, byteWidth int, broadcast bool) (string, error) {
+	if !broadcast {
+		return c.loadX86PackedShiftBytes(source, byteWidth, true)
+	}
+	// GFNI is E4NF: masks never suppress this complete source/m64bcst read.
+	qwords, err := c.loadX86PackedShiftLanes(source, byteWidth, 64, true, "")
+	if err != nil {
+		return "", err
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", bytes, byteWidth/8, qwords, byteWidth)
+	return "%" + bytes, nil
+}
+
+// emitGF2P8Multiply performs lane-wise carry-less multiplication reduced by
+// x^8+x^4+x^3+x+1 (0x11b). Generic IR keeps translated programs runnable on
+// hosts without GFNI while preserving exactly the instruction's byte lanes.
+func (c *amd64Ctx) emitGF2P8Multiply(lanes int, first, second string) string {
+	vectorType := fmt.Sprintf("<%d x i8>", lanes)
+	result := "zeroinitializer"
+	multiplicand, multiplier := first, second
+	for bit := 0; bit < 8; bit++ {
+		lowBit := c.newTmp()
+		active := c.newTmp()
+		selected := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", lowBit, vectorType, multiplier, llvmSplatInteger(lanes, 8, 1))
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", active, vectorType, lowBit)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s zeroinitializer\n", selected, lanes, active, vectorType, multiplicand, vectorType)
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %%%s\n", combined, vectorType, result, selected)
+		result = "%" + combined
+		if bit == 7 {
+			break
+		}
+		highBit := c.newTmp()
+		reduce := c.newTmp()
+		shifted := c.newTmp()
+		reduced := c.newTmp()
+		nextMultiplicand := c.newTmp()
+		nextMultiplier := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", highBit, vectorType, multiplicand, llvmSplatInteger(lanes, 8, 0x80))
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", reduce, vectorType, highBit)
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", shifted, vectorType, multiplicand, llvmSplatInteger(lanes, 8, 1))
+		fmt.Fprintf(c.b, "  %%%s = xor %s %%%s, %s\n", reduced, vectorType, shifted, llvmSplatInteger(lanes, 8, 0x1b))
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %%%s\n", nextMultiplicand, lanes, reduce, vectorType, reduced, vectorType, shifted)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", nextMultiplier, vectorType, multiplier, llvmSplatInteger(lanes, 8, 1))
+		multiplicand, multiplier = "%"+nextMultiplicand, "%"+nextMultiplier
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitGF2P8Inverse(lanes int, source string) string {
+	powers := make([]string, 7)
+	powers[0] = c.emitGF2P8Multiply(lanes, source, source)
+	for i := 1; i < len(powers); i++ {
+		powers[i] = c.emitGF2P8Multiply(lanes, powers[i-1], powers[i-1])
+	}
+	result := powers[0]
+	for i := 1; i < len(powers); i++ {
+		result = c.emitGF2P8Multiply(lanes, result, powers[i])
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitGF2P8Affine(lanes int, matrix, data string, immediate uint8) string {
+	vectorType := fmt.Sprintf("<%d x i8>", lanes)
+	result := "zeroinitializer"
+	for bit := 0; bit < 8; bit++ {
+		row := c.newTmp()
+		masked := c.newTmp()
+		parities := c.newTmp()
+		oneBit := c.newTmp()
+		positioned := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s poison, <%d x i32> %s\n", row, vectorType, matrix, vectorType, lanes, llvmGFNIMatrixRowMask(lanes, bit))
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", masked, vectorType, data, row)
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.ctpop.v%di8(%s %%%s)\n", parities, vectorType, lanes, vectorType, masked)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", oneBit, vectorType, parities, llvmSplatInteger(lanes, 8, 1))
+		fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %s\n", positioned, vectorType, oneBit, llvmSplatInteger(lanes, 8, uint64(bit)))
+		fmt.Fprintf(c.b, "  %%%s = or %s %s, %%%s\n", combined, vectorType, result, positioned)
+		result = "%" + combined
+	}
+	withImmediate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", withImmediate, vectorType, result, llvmSplatInteger(lanes, 8, uint64(immediate)))
+	return "%" + withImmediate
+}
+
+func llvmGFNIMatrixRowMask(lanes, bit int) string {
+	var b strings.Builder
+	b.WriteByte('<')
+	for lane := 0; lane < lanes; lane++ {
+		if lane != 0 {
+			b.WriteString(", ")
+		}
+		fmt.Fprintf(&b, "i32 %d", lane/8*8+7-bit)
+	}
+	b.WriteByte('>')
+	return b.String()
+}
diff --git a/amd64_lower_gfni_test.go b/amd64_lower_gfni_test.go
new file mode 100644
index 000000000..f2e7d6ad0
--- /dev/null
+++ b/amd64_lower_gfni_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64GFNIGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64GFNISpec{
+		"VGF2P8MULB":        {mode: amd64GFNIMultiply},
+		"VGF2P8AFFINEQB":    {mode: amd64GFNIAffine, immediate: true, broadcast: true},
+		"VGF2P8AFFINEINVQB": {mode: amd64GFNIAffineInverse, immediate: true, broadcast: true},
+	}
+	if len(amd64GFNISpecs) != len(expected) {
+		t.Fatalf("GFNI grammar has %d entries, want %d", len(amd64GFNISpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64GFNISpecs[op]; !ok {
+			t.Errorf("GFNI grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("GFNI grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86GFNICompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT gfniforms(SB),$0-0\n")
+			for _, width := range []string{"X", "Y", "Z"} {
+				last := 31
+				if target.goarch == "386" && width == "Z" {
+					last = 7
+				}
+				fmt.Fprintf(&source, "\tVGF2P8MULB %s1, %s2, %s%d\n", width, width, width, last)
+				fmt.Fprintf(&source, "\tVGF2P8MULB 8(AX), %s2, %s%d\n", width, width, last)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB $0x63, %s1, %s2, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB $0x63, 16(AX), %s2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB $0xa5, %s1, %s2, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB $0xa5, 24(AX), %s2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB.BCST $0x63, 32(AX), %s2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB.BCST $0xa5, 40(AX), %s2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8MULB %s1, %s2, K1, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8MULB.Z 48(AX), %s2, K2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB $0x63, %s1, %s2, K3, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB.Z $0x63, 56(AX), %s2, K4, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB $0xa5, %s1, %s2, K5, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB.Z $0xa5, 64(AX), %s2, K6, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEQB.BCST.Z $0x63, 72(AX), %s2, K7, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVGF2P8AFFINEINVQB.BCST.Z $0xa5, 80(AX), %s2, K1, %s%d\n", width, width, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"gfniforms": {Name: "gfniforms", Ret: Void}},
+			})
+			llc := findLLVM22Tool("llc")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original GFNI format source invented initialized inputs", err)
+			}
+			ir = x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "GFNIEmitterOnly",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerGFNI(instruction.Op, instruction)
+				})
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "gfni-"+target.name+".ll", "gfni-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86GFNIRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VGF2P8MULB X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VGF2P8MULB X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VGF2P8MULB.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VGF2P8MULB.BCST 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VGF2P8MULB X0, X1, 0(AX)"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEQB $256, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEINVQB $1, X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEQB.BCST $1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEINVQB.Z.BCST $1, 0(AX), X1, K1, X2"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEQB $1, X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VGF2P8AFFINEQB $1, X0, X1"},
+		{goarch: "386", instruction: "VGF2P8MULB X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VGF2P8AFFINEQB $1, X0, X1, X2"},
+		{goarch: "386", instruction: "VGF2P8MULB Z0, Z1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's GFNI table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64GFNIRuntimeSemantics(t *testing.T) {
+	// Portable LLVM execution on the actual host, not original-Go/native AVX512.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT gfnisemantics(SB),$0-48
+	MOVQ out+0(FP), AX
+	MOVQ matrix+8(FP), BX
+	MOVQ data+16(FP), CX
+	MOVQ other+24(FP), DX
+	MOVQ old+32(FP), R8
+	MOVQ mask+40(FP), R9
+	KMOVQ R9, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VMOVDQU64 0(DX), Z2
+	VMOVDQU64 0(R8), Z3
+	STC
+	VGF2P8MULB Z2, Z1, Z4
+	VMOVDQU64 Z4, 0(AX)
+	VGF2P8AFFINEQB $0x63, Z0, Z1, Z4
+	VMOVDQU64 Z4, 64(AX)
+	VGF2P8AFFINEINVQB $0xa5, Z0, Z1, Z4
+	VMOVDQU64 Z4, 128(AX)
+	VGF2P8MULB Z2, Z1, K1, Z3
+	VMOVDQU64 Z3, 192(AX)
+	VGF2P8AFFINEQB.Z $0x63, Z0, Z1, K1, Z4
+	VMOVDQU64 Z4, 256(AX)
+	VGF2P8AFFINEQB.BCST $0x63, 0(BX), Z1, Z4
+	VMOVDQU64 Z4, 320(AX)
+	VMOVDQU64 0(R8), Z3
+	VGF2P8AFFINEINVQB.BCST.Z $0xa5, 0(BX), Z1, K1, Z3
+	VMOVDQU64 Z3, 384(AX)
+	VGF2P8MULB Z2, Z1, Z2
+	VMOVDQU64 Z2, 448(AX)
+	SETCS 512(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"gfnisemantics": {
+			Name: "gfnisemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: I64, Index: 5, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void gfnisemantics(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static uint8_t gf_mul(uint8_t a, uint8_t b) {
+  uint8_t r = 0;
+  for (int i = 0; i < 8; i++) {
+    if (b & 1) r ^= a;
+    uint8_t hi = a & 0x80;
+    a <<= 1;
+    if (hi) a ^= 0x1b;
+    b >>= 1;
+  }
+  return r;
+}
+static uint8_t gf_inv(uint8_t x) {
+  if (!x) return 0;
+  uint8_t r = 1, a = x;
+  for (unsigned e = 254; e; e >>= 1) {
+    if (e & 1) r = gf_mul(r, a);
+    a = gf_mul(a, a);
+  }
+  return r;
+}
+static unsigned parity8(uint8_t x) {
+  x ^= x >> 4; x &= 0xf;
+  return (0x6996u >> x) & 1u;
+}
+static uint8_t affine(const uint8_t *matrix, uint8_t x, uint8_t imm, int inverse) {
+  if (inverse) x = gf_inv(x);
+  uint8_t r = 0;
+  for (int bit = 0; bit < 8; bit++) r |= (uint8_t)(parity8(matrix[7-bit] & x) << bit);
+  return r ^ imm;
+}
+int main(void) {
+  uint8_t matrix[64], data[64], other[64], old[64], out[513] = {0};
+  const uint64_t mask = UINT64_C(0xa55aa55af00f0ff0);
+  for (int i = 0; i < 64; i++) {
+    matrix[i] = (uint8_t)(0x81u + 29u * (unsigned)i);
+    data[i] = (uint8_t)(3u + 17u * (unsigned)i);
+    other[i] = (uint8_t)(7u + 11u * (unsigned)i);
+    old[i] = (uint8_t)(0xe0u - (unsigned)i);
+  }
+  gfnisemantics(out, matrix, data, other, old, mask);
+  for (int i = 0; i < 64; i++) {
+    const uint8_t mul = gf_mul(other[i], data[i]);
+    const uint8_t aq = affine(matrix + (i/8)*8, data[i], 0x63, 0);
+    const uint8_t ai = affine(matrix + (i/8)*8, data[i], 0xa5, 1);
+    if (out[i] != mul) return 10;
+    if (out[64+i] != aq) return 11;
+    if (out[128+i] != ai) return 12;
+    if (out[192+i] != (((mask>>i)&1) ? mul : old[i])) return 13;
+    if (out[256+i] != (((mask>>i)&1) ? aq : 0)) return 14;
+    if (out[320+i] != affine(matrix, data[i], 0x63, 0)) return 15;
+    if (out[384+i] != (((mask>>i)&1) ? affine(matrix, data[i], 0xa5, 1) : 0)) return 16;
+    if (out[448+i] != mul) return 17;
+  }
+  if (out[512] != 1) return 18;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "gfni_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_halt_test.go b/amd64_lower_halt_test.go
new file mode 100644
index 000000000..baff7b503
--- /dev/null
+++ b/amd64_lower_halt_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86HLTCompleteGoAssemblerForms(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT haltforms(SB),NOSPLIT,$0-0\n\tHLT\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"haltforms": {Name: "haltforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, `asm sideeffect "hlt"`) || !strings.Contains(ll, "unreachable") {
+				t.Fatalf("HLT must retain the hardware instruction and terminate control flow:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "hlt-"+target.name+".ll", "hlt-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86HLTRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{"HLT AX", "HLT $1", "HLT.P"} {
+		file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "x86_64-unknown-linux-gnu",
+			Goarch:       "amd64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's HLT ynone table", instruction)
+		}
+	}
+}
diff --git a/amd64_lower_horizontal_float.go b/amd64_lower_horizontal_float.go
new file mode 100644
index 000000000..df335dcbd
--- /dev/null
+++ b/amd64_lower_horizontal_float.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64HorizontalFloatingSpec struct {
+	laneBits int
+	subtract bool
+	vector   bool
+}
+
+// amd64HorizontalFloatingSpecs is the complete Go 1.27 horizontal
+// floating-point add/subtract family. Legacy forms use yxm; V-prefixed forms
+// use _yvaddsubpd and are deliberately limited to VEX X/Y registers.
+var amd64HorizontalFloatingSpecs = map[Op]amd64HorizontalFloatingSpec{
+	"HADDPS":  {laneBits: 32},
+	"HADDPD":  {laneBits: 64},
+	"HSUBPS":  {laneBits: 32, subtract: true},
+	"HSUBPD":  {laneBits: 64, subtract: true},
+	"VHADDPS": {laneBits: 32, vector: true},
+	"VHADDPD": {laneBits: 64, vector: true},
+	"VHSUBPS": {laneBits: 32, subtract: true, vector: true},
+	"VHSUBPD": {laneBits: 64, subtract: true, vector: true},
+}
+
+func (c *amd64Ctx) lowerHorizontalFloating(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerNativePackedReduction(op, ins)
+}
+
+func (c *amd64Ctx) loadHorizontalFloatingOperand(operand Operand, byteWidth, laneBits int) (string, error) {
+	bytesValue, err := c.loadPackedCompareBytes(operand, byteWidth)
+	if err != nil {
+		return "", err
+	}
+	lanes := byteWidth * 8 / laneBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", result, byteWidth, bytesValue, amd64FMA3LLVMType(lanes, laneBits))
+	return "%" + result, nil
+}
diff --git a/amd64_lower_horizontal_integer.go b/amd64_lower_horizontal_integer.go
new file mode 100644
index 000000000..5798cc4fb
--- /dev/null
+++ b/amd64_lower_horizontal_integer.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerHorizontalInteger(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	_, recognized := amd64HorizontalIntegerSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("horizontal integer dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := x86HorizontalIntegerProperties(ins, c.goarch)
+	if err != nil || !recognized {
+		return recognized, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	if form.memory >= 0 && ins.Args[form.memory].Kind == OpFP {
+		if err := c.validateFPVectorSpan(ins.Args[form.memory].FPOffset, byteWidth); err != nil {
+			return true, false, err
+		}
+	}
+	destination := ins.Args[form.destination].Reg
+	if form.mmx {
+		memoryBytes := 0
+		if form.memory >= 0 {
+			memoryBytes = byteWidth
+		}
+		firstBits, err := c.loadPackedUnpackMMXSource(ins.Args[form.first], memoryBytes)
+		if err != nil {
+			return true, false, err
+		}
+		secondBits, err := c.loadReg(destination)
+		if err != nil {
+			return true, false, err
+		}
+		first := c.bitcastI64ToIntegerLanes(2, 32, firstBits)
+		second := c.bitcastI64ToIntegerLanes(2, 32, secondBits)
+		result := c.emitHorizontalInteger(spec, 8, first, second)
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i32> %s to i64\n", bits, result)
+		return true, false, c.storeReg(destination, "%"+bits)
+	}
+	firstOperand := ins.Args[form.first]
+	if !spec.vector && form.memory >= 0 && (firstOperand.Kind == OpFP || ins.x86AddressBits != 0 ||
+		firstOperand.Kind == OpMem && !c.nativeMemoryOperand(ins, form.first)) {
+		return true, false, fmt.Errorf("%w: legacy horizontal m128 needs original native backing/alignment", ErrProbeNeedsContext)
+	}
+	second, err := c.loadHorizontalIntegerOperand(ins.Args[form.second], byteWidth, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if !spec.vector && form.memory >= 0 {
+		result, err = c.emitPackedBinaryNativeMemory(firstOperand, spec.laneBits, second, strings.ToLower(baseOp))
+	} else {
+		var first string
+		first, err = c.loadHorizontalIntegerOperand(firstOperand, byteWidth, spec.laneBits)
+		if err == nil {
+			result = c.emitHorizontalInteger(spec, byteWidth, first, second)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	if !spec.vector {
+		return true, false, c.storeLegacyPackedLogical(ins.Args[form.destination], "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) loadHorizontalIntegerOperand(operand Operand, byteWidth, laneBits int) (string, error) {
+	bytesValue, err := c.loadX86PackedShiftBytes(operand, byteWidth, true)
+	if err != nil {
+		return "", err
+	}
+	lanes := byteWidth * 8 / laneBits
+	return c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, bytesValue), nil
+}
+
+func (c *amd64Ctx) emitHorizontalInteger(spec amd64HorizontalIntegerSpec, byteWidth int, first, second string) string {
+	lanes := byteWidth * 8 / spec.laneBits
+	lanesPer128 := 128 / spec.laneBits
+	// The legacy MMX PHADDD row is one 64-bit lane group rather than one
+	// 128-bit group, but the same half-from-each-source construction applies.
+	if byteWidth == 8 {
+		lanesPer128 = lanes
+	}
+	typeName := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	elementType := fmt.Sprintf("i%d", spec.laneBits)
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		position := lane % lanesPer128
+		block := lane - position
+		source := second
+		pair := position
+		if position >= lanesPer128/2 {
+			source = first
+			pair -= lanesPer128 / 2
+		}
+		leftIndex := block + 2*pair
+		rightIndex := leftIndex + 1
+		left := c.newTmp()
+		right := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", left, typeName, source, leftIndex)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", right, typeName, source, rightIndex)
+		value := c.emitHorizontalIntegerPair(spec, "%"+left, "%"+right)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %s, i32 %d\n", inserted, typeName, result, elementType, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitHorizontalIntegerPair(spec amd64HorizontalIntegerSpec, left, right string) string {
+	operation := "add"
+	if spec.subtract {
+		operation = "sub"
+	}
+	if !spec.saturate {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i%d %s, %s\n", value, operation, spec.laneBits, left, right)
+		return "%" + value
+	}
+	leftWide := c.newTmp()
+	rightWide := c.newTmp()
+	value := c.newTmp()
+	below := c.newTmp()
+	lowerClamped := c.newTmp()
+	above := c.newTmp()
+	clamped := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext i16 %s to i32\n", leftWide, left)
+	fmt.Fprintf(c.b, "  %%%s = sext i16 %s to i32\n", rightWide, right)
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %%%s, %%%s\n", value, operation, leftWide, rightWide)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %%%s, -32768\n", below, value)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 -32768, i32 %%%s\n", lowerClamped, below, value)
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt i32 %%%s, 32767\n", above, lowerClamped)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 32767, i32 %%%s\n", clamped, above, lowerClamped)
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %%%s to i16\n", result, clamped)
+	return "%" + result
+}
diff --git a/amd64_lower_horizontal_integer_test.go b/amd64_lower_horizontal_integer_test.go
new file mode 100644
index 000000000..68cd8129f
--- /dev/null
+++ b/amd64_lower_horizontal_integer_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86HorizontalIntegerCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT horizontalintegerforms(SB),NOSPLIT,$0-0\n")
+			// PHADDD uniquely uses Go's ymmxmm0f38 table and therefore has
+			// both MMX/m64 and XMM/m128 legacy rows.
+			source.WriteString("\tPHADDD M0, M1\n\tPHADDD 8(AX), M2\n")
+			for _, op := range []string{"PHADDD", "PHADDSW", "PHADDW", "PHSUBD", "PHSUBSW", "PHSUBW"} {
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, last)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, last)
+				vector := "V" + op
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s%d\n", vector, width, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s1, %s%d\n", vector, width, width, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"horizontalintegerforms": {Name: "horizontalintegerforms", Ret: Void},
+				},
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("uninitialized original formats acquired numerical/MMX inputs", err)
+			}
+			ll := x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"horizontalintegerforms": {Name: "horizontalintegerforms", Ret: Void}},
+				target.goarch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerHorizontalInteger(ins.Op, ins)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "horizontal-integer-"+target.name+".ll", "horizontal-integer-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86HorizontalIntegerRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PHADDD.Z X0, X1",
+		"PHADDD X0",
+		"PHADDSW M0, M1",
+		"PHADDW M0, M1",
+		"PHSUBD M0, M1",
+		"PHSUBSW M0, M1",
+		"PHSUBW M0, M1",
+		"PHADDW X0, M1",
+		"PHSUBD Y0, Y1",
+		"VPHADDD.Z X0, X1, X2",
+		"VPHADDSW X0, X1",
+		"VPHADDW X0, Y1, Y2",
+		"VPHSUBD Z0, Z1, Z2",
+		"VPHSUBSW X0, X1, K1, X2",
+		"VPHSUBW X0, X1, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86HorizontalIntegerRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PHADDD X8, X0",
+		"PHADDW X0, X8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86HorizontalIntegerRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86HorizontalIntegerRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's horizontal-integer forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_ifma.go b/amd64_lower_ifma.go
new file mode 100644
index 000000000..57c43216c
--- /dev/null
+++ b/amd64_lower_ifma.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64IFMASpec struct {
+	x86PackedBinarySpec
+	high bool
+}
+
+// amd64IFMASpecs is the complete Go 1.27 integer fused multiply-add family.
+// Both instructions use _yvblendmpd and operate on the low unsigned 52 bits
+// of each qword source. LUQ adds product bits 51:0; HUQ adds bits 103:52.
+var amd64IFMASpecs = map[Op]amd64IFMASpec{
+	"VPMADD52HUQ": {
+		x86PackedBinarySpec: x86PackedBinarySpec{
+			encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true,
+		},
+		high: true,
+	},
+	"VPMADD52LUQ": {
+		x86PackedBinarySpec: x86PackedBinarySpec{
+			encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true,
+		},
+	},
+}
+
+func (c *amd64Ctx) lowerIFMA(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86IFMAProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	source, destination := ins.Args[form.first], ins.Args[form.destination]
+	if form.memory >= 0 {
+		if source.Kind == OpMem && !c.nativeMemoryOperand(ins, form.memory) &&
+			!x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			return true, false, fmt.Errorf("%w: IFMA source needs its original native storage binding", ErrProbeNeedsContext)
+		}
+		if source.Kind == OpFP {
+			if err := c.validateX86PackedShiftFPSpan(source.FPOffset, form.memoryBytes); err != nil {
+				return true, false, err
+			}
+		}
+	}
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	first, err := c.loadX86PackedShiftLanes(source, form.byteWidth, 64, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadPackedCompareLanes(ins.Args[form.second], form.byteWidth, 64, false)
+	if err != nil {
+		return true, false, err
+	}
+	oldBytes, err := c.loadPackedCompareBytes(destination, form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.byteWidth / 8
+	old := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, 64, oldBytes)
+	computed := c.emitIFMA(form.spec, lanes, first, second, old)
+	if form.mask >= 0 {
+		computed = amd64ApplyIntegerLaneMask(c, lanes, 64, computed, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", out, lanes, computed, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitIFMA(spec amd64IFMASpec, lanes int, first, second, accumulator string) string {
+	const low52Mask = "4503599627370495"
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		firstLane := c.newTmp()
+		secondLane := c.newTmp()
+		oldLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", firstLane, lanes, first, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", secondLane, lanes, second, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", oldLane, lanes, accumulator, lane)
+		maskedFirst := c.newTmp()
+		maskedSecond := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %s\n", maskedFirst, firstLane, low52Mask)
+		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %s\n", maskedSecond, secondLane, low52Mask)
+		wideFirst := c.newTmp()
+		wideSecond := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i64 %%%s to i128\n", wideFirst, maskedFirst)
+		fmt.Fprintf(c.b, "  %%%s = zext i64 %%%s to i128\n", wideSecond, maskedSecond)
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", product, wideFirst, wideSecond)
+		selected := "%" + product
+		if spec.high {
+			high := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 52\n", high, product)
+			selected = "%" + high
+		} else {
+			low := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i128 %%%s, %s\n", low, product, low52Mask)
+			selected = "%" + low
+		}
+		productPart := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i128 %s to i64\n", productPart, selected)
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", added, oldLane, productPart)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i64> %s, i64 %%%s, i32 %d\n", inserted, lanes, result, added, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_ifma_test.go b/amd64_lower_ifma_test.go
new file mode 100644
index 000000000..4b9494ad0
--- /dev/null
+++ b/amd64_lower_ifma_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86IFMACompleteGo127Forms(t *testing.T) {
+	// VPMADD52HUQ/LUQ share Go 1.27's six-row _yvblendmpd table: X/Y/Z,
+	// each with an unmasked and K1-K7 masked row. Their EVEX attributes add
+	// scalar qword broadcast and zeroing.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT ifma_forms(SB),$0-0\n")
+			for _, op := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(BX), %s3, %s4\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s.BCST 16(BX), %s5, %s6\n", op, width, width)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", op, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z 24(BX), %s23, K7, %s24\n", op, width, width)
+						fmt.Fprintf(&source, "\t%s.BCST.Z 32(BX), %s25, K2, %s26\n", op, width, width)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"ifma_forms": {Name: "ifma_forms", Ret: Void},
+				},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original IFMA formats invented native input addresses", err)
+			}
+			ir = x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"ifma_forms": {Name: "ifma_forms", Ret: Void}}, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerIFMA(ins.Op, ins) })
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "ifma-"+target.name+".ll", "ifma-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86IFMARejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMADD52HUQ X0, X1",
+		"VPMADD52LUQ X0, X1, X2, X3, X4",
+		"VPMADD52HUQ Y0, X1, X2",
+		"VPMADD52LUQ X0, Y1, X2",
+		"VPMADD52HUQ X0, X1, Y2",
+		"VPMADD52LUQ X0, 8(BX), X2",
+		"VPMADD52HUQ X0, X1, 8(BX)",
+		"VPMADD52LUQ X0, X1, K0, X2",
+		"VPMADD52HUQ X0, K1, X1, X2",
+		"VPMADD52LUQ.Z X0, X1, X2",
+		"VPMADD52HUQ.BCST X0, X1, X2",
+		"VPMADD52LUQ.BCST.Z 8(BX), X1, X2",
+		"VPMADD52HUQ.Z.BCST 8(BX), X1, K1, X2",
+		"VPMADD52LUQ.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's IFMA table", instruction)
+			}
+		})
+	}
+	for _, instruction := range []string{
+		"VPMADD52HUQ X0, X1, K1, X2",
+		"VPMADD52LUQ.Z 8(BX), Y1, K7, Y2",
+		"VPMADD52HUQ.BCST.Z 16(BX), Z1, K2, Z2",
+		"VPMADD52LUQ Z8, Z0, Z1",
+		"VPMADD52HUQ Z0, Z8, Z1",
+		"VPMADD52LUQ Z0, Z1, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "386",
+				TargetTriple: "i386-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted 386 %q outside Go 1.27's IFMA frontend boundary", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64IFMARuntimeSemantics(t *testing.T) {
+	// Integer LLVM and the independent i128 C reference are portable on
+	// both supported 64-bit hosts; no AVX512 or Rosetta execution is implied.
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable runtime oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT ifmaSemantics(SB),$0-48
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	MOVQ accumulator+24(FP), DX
+	MOVQ scalar+32(FP), SI
+	VMOVDQU64 (BX), X0
+	VMOVDQU64 (CX), X1
+	VMOVDQU64 (DX), X2
+	VPMADD52LUQ X0, X1, X2
+	VMOVDQU64 X2, 0(AX)
+	VMOVDQU64 (DX), X3
+	VPMADD52HUQ X0, X1, X3
+	VMOVDQU64 X3, 16(AX)
+	KMOVQ mask+40(FP), K1
+	VMOVDQU64 (DX), X4
+	VPMADD52LUQ X0, X1, K1, X4
+	VMOVDQU64 X4, 32(AX)
+	VMOVDQU64 (DX), X5
+	VPMADD52LUQ.Z X0, X1, K1, X5
+	VMOVDQU64 X5, 48(AX)
+	VMOVDQU64 (DX), X6
+	VPMADD52LUQ.BCST (SI), X1, X6
+	VMOVDQU64 X6, 64(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: I64, Index: 5, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"ifmaSemantics": {
+				Name:  "ifmaSemantics",
+				Args:  []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, I64},
+				Ret:   Void,
+				Frame: frame,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void ifmaSemantics(uint64_t *, const uint64_t *, const uint64_t *, const uint64_t *, const uint64_t *, uint64_t);
+static const uint64_t mask52 = (((uint64_t)1) << 52) - 1;
+static uint64_t lo(uint64_t a, uint64_t b) {
+  return (uint64_t)((((unsigned __int128)(a & mask52)) * (b & mask52)) & mask52);
+}
+static uint64_t hi(uint64_t a, uint64_t b) {
+  return (uint64_t)((((unsigned __int128)(a & mask52)) * (b & mask52)) >> 52);
+}
+int main(void) {
+  const uint64_t first[2] = {(UINT64_C(1) << 60) | mask52, (UINT64_C(1) << 55) | (UINT64_C(1) << 51) | 3};
+  const uint64_t second[2] = {(UINT64_C(1) << 59) | mask52, (UINT64_C(1) << 58) | (UINT64_C(1) << 51) | 5};
+  const uint64_t accumulator[2] = {UINT64_MAX - 15, 100};
+  const uint64_t scalar = (UINT64_C(1) << 63) | 7;
+  uint64_t out[10] = {0};
+  const uint64_t want[10] = {
+    accumulator[0] + lo(first[0], second[0]), accumulator[1] + lo(first[1], second[1]),
+    accumulator[0] + hi(first[0], second[0]), accumulator[1] + hi(first[1], second[1]),
+    accumulator[0] + lo(first[0], second[0]), accumulator[1],
+    accumulator[0] + lo(first[0], second[0]), 0,
+    accumulator[0] + lo(scalar, second[0]), accumulator[1] + lo(scalar, second[1]),
+  };
+  ifmaSemantics(out, first, second, accumulator, &scalar, 1);
+  for (int i = 0; i < 10; i++) if (out[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compiler := []string{clang}
+	if triple != testTargetTriple(runtime.GOOS, runtime.GOARCH) {
+		compiler = append(compiler, "-target", triple)
+	}
+	for _, pipeline := range []struct {
+		name      string
+		optimized bool
+		backend   int
+	}{
+		{name: "backend_O0"},
+		{name: "backend_O2", backend: 2},
+		{name: "IR_O2/backend_O2", optimized: true, backend: 2},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			text := ir
+			if pipeline.optimized {
+				text = x86DwordProductIROptimize(t, ir)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "ifma", triple,
+				text, mainC, nil, pipeline.backend)
+		})
+	}
+}
diff --git a/amd64_lower_implicit_legacy_test.go b/amd64_lower_implicit_legacy_test.go
new file mode 100644
index 000000000..7db18e967
--- /dev/null
+++ b/amd64_lower_implicit_legacy_test.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64LeaveGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64LeaveSpec{
+		"LEAVEW": {bits: 16},
+		"LEAVEL": {bits: 32},
+		"LEAVEQ": {bits: 64},
+	}
+	if !reflect.DeepEqual(amd64LeaveSpecs, want) {
+		t.Fatalf("LEAVE grammar = %+v, want %+v", amd64LeaveSpecs, want)
+	}
+}
+
+func TestTranslateX86LeaveAndXLATCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			secondLeave := "LEAVEQ"
+			if target.goarch == "386" {
+				secondLeave = "LEAVEL"
+			}
+			source := "TEXT implicitlegacyforms(SB),$0-0\n" +
+				"\tLEAVEW\n" +
+				"\t" + secondLeave + "\n" +
+				"\tXLAT\n" +
+				"\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86PhysicalSPRequirePublicContext(t, source, "func implicitlegacyforms()", target.goarch, target.triple)
+			ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{
+				"implicitlegacyforms": {Name: "implicitlegacyforms", Ret: Void},
+			}, target.goarch, target.triple, 0)
+			for _, want := range []string{"load i16", "load volatile i8", "-256"} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "386" {
+				if !strings.Contains(ir, "load i32") {
+					t.Errorf("386 IR is missing LEAVEL load:\n%s", ir)
+				}
+			} else if !strings.Contains(ir, "load i64") {
+				t.Errorf("amd64 IR is missing LEAVEQ load:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "implicit-legacy-"+target.name+".ll", "implicit-legacy-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LeaveAndXLATRejectFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LEAVEW AX"},
+		{goarch: "amd64", instruction: "LEAVEL"},
+		{goarch: "amd64", instruction: "LEAVEQ.P"},
+		{goarch: "amd64", instruction: "XLAT AX"},
+		{goarch: "amd64", instruction: "XLAT.P"},
+		{goarch: "386", instruction: "LEAVEQ"},
+		{goarch: "386", instruction: "LEAVEL AX"},
+		{goarch: "386", instruction: "XLAT AX"},
+	} {
+		t.Run(test.goarch+"_"+strings.ReplaceAll(test.instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's LEAVE/XLAT tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64LeaveAndXLATRuntimeSemantics(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	const source = `TEXT implicitlegacysemantics(SB),NOSPLIT,$0-16
+	MOVQ out+0(FP), R8
+	MOVQ data+8(FP), BP
+	LEAVEQ
+	MOVQ BP, 0(R8)
+	MOVQ SP, 8(R8)
+	MOVQ data+8(FP), BX
+	ADDQ $16, BX
+	MOVQ $0x1122334455667703, AX
+	XLAT
+	MOVQ AX, 16(R8)
+	RET
+`
+	// LEAVE changes physical SP and invalidates the later Go FP/RET transport.
+	// Preserve this complete original body as Context and execute only its
+	// explicitly private virtual-register mathematics, never a native Go ABI.
+	x86PhysicalSPRequirePublicContext(t, source, "func implicitlegacysemantics(out,data *byte)", "amd64", execution.triple)
+	ir := x86PhysicalSPPrivateEmitter(t, source,
+		map[string]FuncSig{
+			"implicitlegacysemantics": {
+				Name: "implicitlegacysemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		}, "amd64", execution.triple)
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void implicitlegacysemantics(uint8_t *, uint8_t *);
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  uint8_t data[256] = {0}, out[24] = {0};
+  const uint64_t saved = UINT64_C(0xa1b2c3d4e5f60718); memcpy(data,&saved,8);
+  data[19] = 0xaa;
+  implicitlegacysemantics(out,data);
+  if (load64(out) != saved) return 10;
+  if (load64(out+8) != (uintptr_t)(data+8)) return 11;
+  if (load64(out+16) != UINT64_C(0x11223344556677aa)) return 12;
+  return 0;
+}
+`
+	execution.compileAndRunLLVM(t, "implicit_legacy_private_math", ir,
+		"#define implicitlegacysemantics InstructionFormat0\n"+mainC, "-O2")
+	t.Log("private virtual-SP LEAVE/XLAT mathematics only; original public source remains Context, not native Go ABI")
+}
diff --git a/amd64_lower_implicit_mask_move.go b/amd64_lower_implicit_mask_move.go
new file mode 100644
index 000000000..0898715fb
--- /dev/null
+++ b/amd64_lower_implicit_mask_move.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+type amd64ImplicitMaskMoveSpec struct {
+	byteWidth int
+	vector    bool
+}
+
+// Go's frontend exposes the legacy SSE spelling both as MASKMOVOU and via
+// the Intel-name alias MASKMOVDQU. MASKMOVQ is the corresponding MMX form;
+// VMASKMOVDQU is the VEX spelling. All use the first operand as a byte mask,
+// the second as data, and DI as the implicit memory destination.
+var amd64ImplicitMaskMoveSpecs = map[Op]amd64ImplicitMaskMoveSpec{
+	"MASKMOVQ":    {byteWidth: 8},
+	"MASKMOVOU":   {byteWidth: 16},
+	"MASKMOVDQU":  {byteWidth: 16},
+	"VMASKMOVDQU": {byteWidth: 16, vector: true},
+}
+
+func (c *amd64Ctx) lowerImplicitMaskMove(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86ImplicitMaskMoveProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if spec.byteWidth == 8 || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+		!x86ResultNamedPredicateInstruction(ins) {
+		return true, false, fmt.Errorf("%w: implicit mask store needs its original native source/target and MMX owner", ErrProbeNeedsContext)
+	}
+	mask, err := c.loadX(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	data, err := c.loadX(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	addressInteger, err := c.loadReg(DI)
+	if err != nil {
+		return true, false, err
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", address, addressInteger)
+	mnemonic := "maskmovdqu"
+	if spec.vector {
+		mnemonic = "vmaskmovdqu"
+	}
+	// Preserve WC/non-temporal behavior and implementation-dependent
+	// zero-mask address faults, not a removable masked store or a fabricated
+	// unconditional read of the destination.
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(<16 x i8> %s, <16 x i8> %s, ptr %%%s)\n",
+		mnemonic+" $1, $0", "x,x,{di},~{memory}", data, mask, address)
+	return true, false, nil
+}
diff --git a/amd64_lower_implicit_mask_move_test.go b/amd64_lower_implicit_mask_move_test.go
new file mode 100644
index 000000000..672575d14
--- /dev/null
+++ b/amd64_lower_implicit_mask_move_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ImplicitMaskMoveCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			source := fmt.Sprintf("TEXT implicitmaskmoveforms(SB),NOSPLIT,$0-0\n"+
+				"\tMASKMOVQ M0, M7\n"+
+				"\tMASKMOVOU X0, X%d\n"+
+				"\tMASKMOVDQU X0, X%d\n"+
+				"\tVMASKMOVDQU X0, X%d\n"+
+				"\tRET\n", last, last, last)
+			// Preserve all four original rows and their actual Go objects.
+			// These bare registers/DI cannot establish a successful public
+			// translation. The independently initialized full-family root
+			// compiles real translated objects at the same five targets.
+			file, _ := x86UnboundVoidFormatSources(t, source, target.goarch, target.triple)
+			count := 0
+			for _, instruction := range file.Funcs[0].Instrs {
+				if instruction.Op == OpTEXT || instruction.Op == OpRET {
+					continue
+				}
+				if _, known, err := x86ImplicitMaskMoveProperties(instruction.Op, instruction, target.goarch); !known || err != nil {
+					t.Fatal("original implicit mask-store format disappeared", instruction.Raw, err)
+				}
+				count++
+			}
+			if count != 4 {
+				t.Fatal("original complete implicit mask-store denominator changed", count)
+			}
+		})
+	}
+}
+
+func TestTranslateX86ImplicitMaskMoveRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"MASKMOVQ.Z M0, M1",
+		"MASKMOVQ M0",
+		"MASKMOVQ M0, X1",
+		"MASKMOVQ 8(AX), M1",
+		"MASKMOVOU.Z X0, X1",
+		"MASKMOVOU X0",
+		"MASKMOVOU M0, M1",
+		"MASKMOVOU X0, Y1",
+		"MASKMOVDQU.Z X0, X1",
+		"MASKMOVDQU X0, X1, X2",
+		"MASKMOVDQU 8(AX), X1",
+		"VMASKMOVDQU.Z X0, X1",
+		"VMASKMOVDQU X0",
+		"VMASKMOVDQU Y0, Y1",
+		"VMASKMOVDQU X0, K1, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ImplicitMaskMoveRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"MASKMOVOU X8, X0",
+		"MASKMOVDQU X0, X8",
+		"VMASKMOVDQU X8, X0",
+		"VMASKMOVDQU X0, X8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ImplicitMaskMoveRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86ImplicitMaskMoveRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's implicit mask-move forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_implicit_system.go b/amd64_lower_implicit_system.go
new file mode 100644
index 000000000..596f28f43
--- /dev/null
+++ b/amd64_lower_implicit_system.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type amd64ImplicitSystemOperand uint8
+
+const (
+	amd64ImplicitSystemNoOperand amd64ImplicitSystemOperand = iota
+	amd64ImplicitSystemGP
+	amd64ImplicitSystemAddressGP
+)
+
+type amd64ImplicitRegisterSet uint8
+
+const (
+	amd64ImplicitAX amd64ImplicitRegisterSet = 1 << iota
+	amd64ImplicitCX
+	amd64ImplicitDX
+)
+
+type amd64ImplicitSystemSpec struct {
+	operand     amd64ImplicitSystemOperand
+	inputs      amd64ImplicitRegisterSet
+	outputs     amd64ImplicitRegisterSet
+	writesCarry bool
+	rawPrefix   byte
+}
+
+// amd64ImplicitSystemSpecs is the complete Go 1.27 grammar for the system
+// instructions whose architectural state is carried by implicit AX/CX/DX
+// registers, plus the WAITPKG instructions' one explicit Yrl register. The
+// table separates operand syntax from data flow so parsing, register liveness,
+// and emission all consume the same typed description.
+var amd64ImplicitSystemSpecs = map[Op]amd64ImplicitSystemSpec{
+	"MONITOR":  {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+	"MWAIT":    {inputs: amd64ImplicitAX | amd64ImplicitCX},
+	"RDPMC":    {inputs: amd64ImplicitCX, outputs: amd64ImplicitAX | amd64ImplicitDX},
+	"RDPKRU":   {inputs: amd64ImplicitCX, outputs: amd64ImplicitAX | amd64ImplicitDX},
+	"WRPKRU":   {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+	"XSETBV":   {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+	"UMONITOR": {operand: amd64ImplicitSystemAddressGP, rawPrefix: 0xf3},
+	"UMWAIT":   {operand: amd64ImplicitSystemGP, inputs: amd64ImplicitAX | amd64ImplicitDX, writesCarry: true, rawPrefix: 0xf2},
+	"TPAUSE":   {operand: amd64ImplicitSystemGP, inputs: amd64ImplicitAX | amd64ImplicitDX, writesCarry: true, rawPrefix: 0x66},
+}
+
+type amd64ImplicitSystemForm struct {
+	register      Reg
+	addressBits   int
+	segmentPrefix byte
+}
+
+func (c *amd64Ctx) lowerImplicitSystem(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, form, known, err := x86ImplicitSystemProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.emitImplicitSystem(strings.ToUpper(string(op)), spec, form)
+}
+
+func x86ImplicitSystemProperties(op Op, ins Instr, arch string) (amd64ImplicitSystemSpec, amd64ImplicitSystemForm, bool, error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64ImplicitSystemSpecs[Op(baseOp)]
+	if !recognized {
+		return spec, amd64ImplicitSystemForm{}, false, nil
+	}
+	if rawOp != baseOp || arch != "386" && arch != "amd64" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), rawOp) {
+		return spec, amd64ImplicitSystemForm{}, true, fmt.Errorf("%s %s has an invalid suffix, mode or dispatch identity: %q", arch, op, ins.Raw)
+	}
+	form, err := parseX86ImplicitSystemForm(baseOp, spec, ins, arch)
+	return spec, form, true, err
+}
+
+func parseX86ImplicitSystemForm(op string, spec amd64ImplicitSystemSpec, ins Instr, arch string) (amd64ImplicitSystemForm, error) {
+	var form amd64ImplicitSystemForm
+	switch spec.operand {
+	case amd64ImplicitSystemNoOperand:
+		if len(ins.Args) != 0 {
+			return form, fmt.Errorf("%s %s takes no operands: %q", arch, op, ins.Raw)
+		}
+	case amd64ImplicitSystemGP, amd64ImplicitSystemAddressGP:
+		if len(ins.Args) != 1 || ins.Args[0].Kind != OpReg || !isX86YrlRegisterForArch(ins.Args[0].Reg, arch) {
+			return form, fmt.Errorf("%s %s expects one Go 1.27 Yrl register: %q", arch, op, ins.Raw)
+		}
+		form.register = ins.Args[0].Reg
+		if spec.operand == amd64ImplicitSystemAddressGP {
+			form.addressBits = 64
+			if arch == "386" {
+				form.addressBits = 32
+			}
+			if ins.x86Encoded {
+				if ins.x86AddressBits != 0 {
+					if ins.x86AddressBits != form.addressBits && ins.x86AddressBits != form.addressBits/2 {
+						return form, fmt.Errorf("invalid %s address size %d", arch, ins.x86AddressBits)
+					}
+					form.addressBits = ins.x86AddressBits
+				}
+				form.segmentPrefix = ins.x86SegmentPrefix
+			}
+		}
+	default:
+		panic("unknown amd64 implicit-system operand kind")
+	}
+	return form, nil
+}
+
+// UMWAIT/TPAUSE consume their complete dword control and EDX:EAX deadline.
+// Intel SDM defines CF and clears AF/PF/SF/ZF/OF on continuation; GP, DF and
+// storage are unchanged. This numerical descriptor grants no monitor address,
+// raw/native entry or promise that the operation cannot fault.
+func x86TypedWaitPackageByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, form, known, err := x86ImplicitSystemProperties(op, ins, arch)
+	if !known || !spec.writesCarry {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	if !x86WaitPackagePreservesStorage(ins) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: WAITPKG original/normalized numerical source differs", ErrProbeNeedsContext)
+	}
+	effect := x86TypedByteEffect{
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: Operand{Kind: OpReg, Reg: form.register}, width: 4, read: true},
+		},
+		flagsDefined: x86ByteFlagsAll, flagsKilled: x86ByteFlagsAll, requiresResultProof: true,
+	}
+	for index, register := range []Reg{AX, CX, DX} {
+		if spec.inputs&(1<<uint(index)) != 0 {
+			effect.operands = append(effect.operands, x86TypedByteOperand{
+				index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: 4, read: true,
+			})
+		}
+	}
+	return effect, true, nil
+}
+
+// The physical decoder retains WAITPKG's register-only identity. Unlike the
+// address-bearing UMONITOR sibling, these two operations preserve GP/DF and
+// private storage; FLAGS are independently replaced by the effect above.
+func x86WaitPackagePreservesStorage(ins Instr) bool {
+	spec, known := amd64ImplicitSystemSpecs[Op(strings.ToUpper(string(ins.Op)))]
+	if !known || !spec.writesCarry || len(ins.Args) != 1 ||
+		!reflect.DeepEqual(ins.Args[0], Operand{Kind: OpReg, Reg: ins.Args[0].Reg}) ||
+		!isX86YrlRegisterForArch(ins.Args[0].Reg, "amd64") ||
+		ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	return origin == nil && !ins.x86Encoded || origin != nil &&
+		strings.EqualFold(string(origin.op), string(ins.Op)) && reflect.DeepEqual(origin.args, ins.Args)
+}
+
+func (c *amd64Ctx) emitImplicitSystem(op string, spec amd64ImplicitSystemSpec, form amd64ImplicitSystemForm) (bool, bool, error) {
+	wordType := I64
+	if c.goarch == "386" {
+		wordType = I32
+	}
+	constraints := make([]string, 0, 8)
+	arguments := make([]string, 0, 4)
+	if spec.outputs == amd64ImplicitAX|amd64ImplicitDX {
+		constraints = append(constraints, "={ax}", "={dx}")
+	}
+	if spec.writesCarry {
+		constraints = append(constraints, "=q")
+	}
+	if spec.operand != amd64ImplicitSystemNoOperand {
+		operandType := I32 // UMWAIT/TPAUSE read control[31:0], even with REX.W.
+		if spec.operand == amd64ImplicitSystemAddressGP {
+			operandType = LLVMType(fmt.Sprintf("i%d", form.addressBits))
+		}
+		value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: form.register}, operandType)
+		if err != nil {
+			return true, false, err
+		}
+		if spec.operand == amd64ImplicitSystemAddressGP && operandType != wordType {
+			// Monitor the same zero-extended offset using the native address
+			// width. The segment base is still applied by the actual instruction.
+			extended := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", extended, operandType, value, wordType)
+			value, operandType = "%"+extended, wordType
+		}
+		constraints = append(constraints, "r")
+		arguments = append(arguments, fmt.Sprintf("%s %s", operandType, value))
+	}
+	for _, implicit := range []struct {
+		bit        amd64ImplicitRegisterSet
+		reg        Reg
+		constraint string
+	}{
+		{bit: amd64ImplicitAX, reg: AX, constraint: "{ax}"},
+		{bit: amd64ImplicitCX, reg: CX, constraint: "{cx}"},
+		{bit: amd64ImplicitDX, reg: DX, constraint: "{dx}"},
+	} {
+		if spec.inputs&implicit.bit == 0 {
+			continue
+		}
+		value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: implicit.reg}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		constraints = append(constraints, implicit.constraint)
+		arguments = append(arguments, "i32 "+value)
+	}
+	constraints = append(constraints, "~{memory}", "~{dirflag}", "~{fpsr}", "~{flags}")
+
+	assembly := strings.ToLower(op)
+	if form.segmentPrefix != 0 {
+		assembly = fmt.Sprintf(".byte 0x%02x; %s", form.segmentPrefix, assembly)
+	}
+	if spec.operand != amd64ImplicitSystemNoOperand {
+		operandIndex := 0
+		if spec.writesCarry {
+			operandIndex = 1
+		}
+		assembly += fmt.Sprintf(" $%d", operandIndex)
+	}
+	if spec.writesCarry {
+		assembly += "; setc $0"
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i8 asm sideeffect %q, %q(%s)\n",
+			call, assembly, strings.Join(constraints, ","), strings.Join(arguments, ", "))
+		carry := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i8 %%%s to i1\n", carry, call)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+		// WAITPKG defines CF and clears the other arithmetic flags (Intel SDM).
+		c.clearX86StatusFlags(x86StatusAll &^ x86StatusCF)
+		return true, false, nil
+	}
+	if spec.outputs == amd64ImplicitAX|amd64ImplicitDX {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call { i32, i32 } asm sideeffect %q, %q(%s)\n",
+			call, assembly, strings.Join(constraints, ","), strings.Join(arguments, ", "))
+		for index, reg := range []Reg{AX, DX} {
+			part := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue { i32, i32 } %%%s, %d\n", part, call, index)
+			if err := c.storeRegSized(reg, I32, "%"+part); err != nil {
+				return true, false, err
+			}
+		}
+		return true, false, nil
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n",
+		assembly, strings.Join(constraints, ","), strings.Join(arguments, ", "))
+	return true, false, nil
+}
diff --git a/amd64_lower_implicit_system_test.go b/amd64_lower_implicit_system_test.go
new file mode 100644
index 000000000..cda0e2c54
--- /dev/null
+++ b/amd64_lower_implicit_system_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64ImplicitSystemGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64ImplicitSystemSpec{
+		"MONITOR":  {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+		"MWAIT":    {inputs: amd64ImplicitAX | amd64ImplicitCX},
+		"RDPMC":    {inputs: amd64ImplicitCX, outputs: amd64ImplicitAX | amd64ImplicitDX},
+		"RDPKRU":   {inputs: amd64ImplicitCX, outputs: amd64ImplicitAX | amd64ImplicitDX},
+		"WRPKRU":   {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+		"XSETBV":   {inputs: amd64ImplicitAX | amd64ImplicitCX | amd64ImplicitDX},
+		"UMONITOR": {operand: amd64ImplicitSystemAddressGP, rawPrefix: 0xf3},
+		"UMWAIT":   {operand: amd64ImplicitSystemGP, inputs: amd64ImplicitAX | amd64ImplicitDX, writesCarry: true, rawPrefix: 0xf2},
+		"TPAUSE":   {operand: amd64ImplicitSystemGP, inputs: amd64ImplicitAX | amd64ImplicitDX, writesCarry: true, rawPrefix: 0x66},
+	}
+	if !reflect.DeepEqual(amd64ImplicitSystemSpecs, want) {
+		t.Fatalf("implicit-system grammar = %+v, want %+v", amd64ImplicitSystemSpecs, want)
+	}
+}
+
+func TestTranslateX86ImplicitSystemCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			register := "R11"
+			if target.goarch == "386" {
+				register = "BX"
+			}
+			source := "TEXT implicitsystemforms(SB),$0-0\n" +
+				"\tMONITOR\n" +
+				"\tMWAIT\n" +
+				"\tRDPMC\n" +
+				"\tRDPKRU\n" +
+				"\tWRPKRU\n" +
+				"\tXSETBV\n" +
+				"\tUMONITOR " + register + "\n" +
+				"\tUMWAIT " + register + "\n" +
+				"\tTPAUSE " + register + "\n" +
+				"\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			// Preserve the original format source without inventing implicit
+			// inputs. Initialized WAITPKG programs have their own public objects.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "implicitsystemforms", target.goarch, target.triple)
+			for _, want := range []string{
+				`"target-features"="+pku,+waitpkg,+xsave"`,
+				`asm sideeffect "monitor"`,
+				`asm sideeffect "mwait"`,
+				`asm sideeffect "rdpmc"`,
+				`asm sideeffect "rdpkru"`,
+				`asm sideeffect "wrpkru"`,
+				`asm sideeffect "xsetbv"`,
+				`asm sideeffect "umonitor $0"`,
+				`asm sideeffect "umwait $1; setc $0"`,
+				`asm sideeffect "tpause $1; setc $0"`,
+				`store i1 %`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "implicit-system-"+target.name+".ll", "implicit-system-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ImplicitSystemRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "MONITOR AX"},
+		{goarch: "amd64", instruction: "MWAIT.P"},
+		{goarch: "amd64", instruction: "RDPMC AX"},
+		{goarch: "amd64", instruction: "RDPKRU.P"},
+		{goarch: "amd64", instruction: "WRPKRU AX"},
+		{goarch: "amd64", instruction: "XSETBV AX"},
+		{goarch: "amd64", instruction: "UMONITOR (BX)"},
+		{goarch: "amd64", instruction: "UMWAIT X1"},
+		{goarch: "amd64", instruction: "TPAUSE"},
+		{goarch: "386", instruction: "UMONITOR R11"},
+		{goarch: "386", instruction: "UMWAIT R11"},
+		{goarch: "386", instruction: "TPAUSE R11"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's implicit-system tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_incdec.go b/amd64_lower_incdec.go
new file mode 100644
index 000000000..82e98ba13
--- /dev/null
+++ b/amd64_lower_incdec.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerScalarIncDec implements the complete Go 1.27 INCB/W/L/Q and
+// DECB/W/L/Q tables. INC and DEC preserve CF while updating the modeled
+// ZF/SF/AF/PF/OF flags.
+func (c *amd64Ctx) lowerScalarIncDec(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	bits := 0
+	switch baseOp {
+	case "INCB", "DECB":
+		bits = 8
+	case "INCW", "DECW":
+		bits = 16
+	case "INCL", "DECL":
+		bits = 32
+	case "INCQ", "DECQ":
+		bits = 64
+	default:
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && bits == 64 {
+		return true, false, fmt.Errorf("386 %s is illegal in 32-bit mode: %q", baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 1 {
+		return true, false, fmt.Errorf("%s %s expects one destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	dst := ins.Args[0]
+	if dst.Kind == OpReg {
+		if bits == 8 {
+			if !isGoYmbRegisterForArch(dst.Reg, c.goarch) {
+				return true, false, fmt.Errorf("%s %s destination is outside Go 1.27's Ymb class: %q", c.goarch, baseOp, ins.Raw)
+			}
+		} else if !isX86YrlRegisterForArch(dst.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%s %s destination is outside Go 1.27's Yml class: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(dst) {
+		return true, false, fmt.Errorf("%s %s expects a GP register or memory destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	ty := amd64IntegerTypeForBits(bits)
+	old, store, err := c.loadScalarRMWDestination(op, ins, dst, ty)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	llvmOp := "add"
+	if baseOp[:3] == "DEC" {
+		llvmOp = "sub"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, 1\n", result, llvmOp, ty, old)
+	value := "%" + result
+	if err := store(value); err != nil {
+		return true, false, err
+	}
+
+	zero := c.newTmp()
+	sign := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, ty, value)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", sign, ty, value)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	c.setParityFlagSized(ty, value)
+	c.setAuxiliaryCarryFlag(ty, old, "1", value)
+
+	overflowInput := int64(1) << (bits - 1)
+	if baseOp[:3] == "INC" {
+		overflowInput--
+	} else {
+		overflowInput = -overflowInput
+	}
+	overflow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %d\n", overflow, ty, old, overflowInput)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", overflow, c.flagsOFSlot)
+	return true, false, nil
+}
diff --git a/amd64_lower_insert.go b/amd64_lower_insert.go
new file mode 100644
index 000000000..d54ecfc16
--- /dev/null
+++ b/amd64_lower_insert.go
@@ -0,0 +1,9 @@
+package plan9asm
+
+// lowerPackedVectorInsert implements every Go 1.27 form in _yvinsertf128,
+// _yvinsertf32x4, and _yvinsertf32x8. The floating and integer spellings have
+// identical bit-level insert behavior; their lane type only changes EVEX mask
+// granularity.
+func (c *amd64Ctx) lowerPackedVectorInsert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerInsertExtractFamily(op, ins)
+}
diff --git a/amd64_lower_insert_extract.go b/amd64_lower_insert_extract.go
new file mode 100644
index 000000000..006140818
--- /dev/null
+++ b/amd64_lower_insert_extract.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerInsertExtractFamily(op Op, ins Instr) (bool, bool, error) {
+	ins, f, known, err := c.bindInsertExtractForm(op, ins)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if f.undefinedOpcode() {
+		return c.lowerX86UndefinedTrap(op, ins)
+	}
+	if f.mask >= 0 && f.memoryWrite {
+		return true, false, c.lowerNativeMaskedExtract(ins, f)
+	}
+	if f.spec.scalar {
+		if f.spec.insert {
+			return c.lowerInsertPackedSingle(op, ins)
+		}
+		return c.lowerPackedScalarExtract(op, ins)
+	}
+	src, err := c.loadInsertExtractSource(ins.Args[f.source], f)
+	if err != nil {
+		return true, false, err
+	}
+	result := src
+	if f.spec.insert {
+		base, err := c.loadPackedCompareBytes(ins.Args[f.base], f.width)
+		if err != nil {
+			return true, false, err
+		}
+		// Widen the insertion source only with defined zero bytes; then one
+		// shuffle reads the two old inputs before an aliased destination write.
+		wide := c.newTmp()
+		indices := make([]int, f.width)
+		for i := range indices {
+			indices[i] = i
+			if i >= f.spec.chunk {
+				indices[i] = f.spec.chunk
+			}
+		}
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> %s\n", wide, f.spec.chunk, src, f.spec.chunk, f.width, llvmI32Mask(indices))
+		for i := range indices {
+			indices[i] = i
+			if i >= f.offset && i < f.offset+f.spec.chunk {
+				indices[i] = f.width + i - f.offset
+			}
+		}
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %%%s, <%d x i32> %s\n", out, f.width, base, f.width, wide, f.width, llvmI32Mask(indices))
+		result = "%" + out
+	} else {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> poison, <%d x i32> %s\n", out, f.width, src, f.width, f.output, llvmI32RangeMask(f.offset, f.output))
+		result = "%" + out
+	}
+	if f.mask >= 0 {
+		mask, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := f.output * 8 / f.spec.laneBits
+		computed := c.bitcastVectorBytesToIntegerLanes(f.output, lanes, f.spec.laneBits, result)
+		old := "zeroinitializer"
+		if !f.zeroing {
+			bytes, err := c.loadPackedCompareBytes(ins.Args[f.destination], f.output)
+			if err != nil {
+				return true, false, err
+			}
+			old = c.bitcastVectorBytesToIntegerLanes(f.output, lanes, f.spec.laneBits, bytes)
+		}
+		masked := amd64ApplyIntegerLaneMask(c, lanes, f.spec.laneBits, computed, old, mask, f.zeroing)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, f.spec.laneBits, masked, f.output)
+		result = "%" + out
+	}
+	destination := ins.Args[f.destination]
+	if f.memoryWrite && destination.Kind != OpFP {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(destination)
+		if err != nil {
+			return true, false, err
+		}
+		// Preserve every original unmasked write, including overwritten
+		// chunks, without reading old destination bytes or adding alignment.
+		fmt.Fprintf(c.b, "  store volatile <%d x i8> %s, %s %s, align 1\n", f.output, result, pointerType, pointer)
+		return true, false, nil
+	}
+	return true, false, c.storePackedMoveOperand(destination, f.output, result)
+}
+
+func (c *amd64Ctx) lowerNativeMaskedExtract(ins Instr, f x86InsertExtractForm) error {
+	destination := ins.Args[f.destination]
+	if destination.Kind == OpFP && c.classicFrame == "" {
+		return fmt.Errorf("%w: %s E6NF masked extraction needs contiguous original FP storage, not separately allocated virtual slots", ErrProbeNeedsContext, ins.Op)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(destination)
+	if err != nil {
+		return err
+	}
+	mask, err := c.loadK(ins.Args[f.mask].Reg)
+	if err != nil {
+		return err
+	}
+	index, _ := amd64VectorRegisterIndex(ins.Args[f.source].Reg, f.width)
+	buffer := c.yRegSlot[index]
+	if f.width == 64 {
+		buffer = c.zRegSlot[index]
+	}
+	if buffer == "" {
+		return fmt.Errorf("%w: missing private virtual source buffer for %s", ErrProbeNeedsContext, ins.Args[f.source].Reg)
+	}
+	bank := "ymm"
+	if f.width == 64 {
+		bank = "zmm"
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	}
+	if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	// This write-only native instruction supplies E6NF's nonsuppressing
+	// address/fault behavior without inventing old destination read access
+	// or writing inactive lanes. Only private physical scratch is clobbered;
+	// virtual SIMD/K state and CPU flags are unchanged. No target feature is
+	// enabled globally. Native execution still requires the source's ISA.
+	assembly := fmt.Sprintf("vmovdqu64 ($0), %%%s0; kmovq $1, %%k1; %s $$%d, %%%s0, %s($2) {%%k1}", bank, strings.ToLower(string(ins.Op)), f.immediate, bank, segment)
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(ptr %s, i64 %s, %s %s)\n", assembly, "r,r,r,~{zmm0},~{k1},~{memory}", buffer, mask, pointerType, pointer)
+	return nil
+}
+
+func (c *amd64Ctx) loadInsertExtractSource(arg Operand, f x86InsertExtractForm) (string, error) {
+	if f.spec.insert && f.memory >= 0 && arg.Kind != OpFP {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(arg)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		// Intel E6NF retains the entire native access even if every result
+		// lane is inactive or subsequently overwritten. Volatile prevents
+		// LLVM O2 from deleting that original observable faulting load.
+		fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, %s %s, align 1\n", value, f.spec.chunk, pointerType, pointer)
+		return "%" + value, nil
+	}
+	width := f.width
+	if f.spec.insert {
+		width = f.spec.chunk
+	}
+	return c.loadPackedCompareBytes(arg, width)
+}
diff --git a/amd64_lower_insert_integer.go b/amd64_lower_insert_integer.go
new file mode 100644
index 000000000..79568f8aa
--- /dev/null
+++ b/amd64_lower_insert_integer.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedIntegerInsertSpec struct {
+	laneBits int
+	legacy   bool
+}
+
+var amd64PackedIntegerInsertSpecs = map[string]amd64PackedIntegerInsertSpec{
+	"PINSRB":  {laneBits: 8, legacy: true},
+	"PINSRW":  {laneBits: 16, legacy: true},
+	"PINSRD":  {laneBits: 32, legacy: true},
+	"PINSRQ":  {laneBits: 64, legacy: true},
+	"VPINSRB": {laneBits: 8},
+	"VPINSRW": {laneBits: 16},
+	"VPINSRD": {laneBits: 32},
+	"VPINSRQ": {laneBits: 64},
+}
+
+func (c *amd64Ctx) lowerPackedIntegerInsert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64PackedIntegerInsertSpecs[base]; !known {
+		return false, false, nil
+	}
+	ins, f, _, err := c.bindScalarLaneForm(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	source := ins.Args[f.source]
+	if source.Kind == OpReg {
+		source.Reg = f.transferReg
+	}
+	// Exact native m8/m16/m32/m64 reads remain volatile; FP uses the
+	// independent complete-byte-span helper, not the first scalar slot.
+	var scalar string
+	if source.Kind == OpFP {
+		scalar, err = c.loadScalarLaneFPBits(source.FPOffset, f.bits)
+	} else {
+		scalar, err = c.loadGPSIMDTransferSource(source, f.bits)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	baseBytes, err := c.loadX(ins.Args[f.base].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / f.bits
+	baseLanes, inserted, out := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x i%d>\n", baseLanes, baseBytes, lanes, f.bits)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %%%s, i%d %s, i32 %d\n", inserted, lanes, f.bits, baseLanes, f.bits, scalar, f.offset/(f.bits/8))
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", out, lanes, f.bits, inserted)
+	if f.legacy {
+		return true, false, c.storeX(ins.Args[f.destination].Reg, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[f.destination], 16, "%"+out)
+}
+
+func amd64IsExtendedGPRegister(reg Reg) bool {
+	switch strings.ToUpper(string(reg)) {
+	case "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+		return true
+	default:
+		return false
+	}
+}
diff --git a/amd64_lower_insert_integer_test.go b/amd64_lower_insert_integer_test.go
new file mode 100644
index 000000000..736f2e40c
--- /dev/null
+++ b/amd64_lower_insert_integer_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedIntegerInsertCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedintegerinsertforms(SB),$0-0\n")
+			legacyOps := []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ"}
+			vectorOps := []string{"VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ"}
+			if target.goarch == "386" {
+				legacyOps = legacyOps[:3]
+				vectorOps = nil
+			}
+			for _, op := range legacyOps {
+				fmt.Fprintf(&source, "\t%s $0, AX, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s $255, 8(AX), X%d\n", op, legacyLast)
+			}
+			for _, op := range vectorOps {
+				fmt.Fprintf(&source, "\t%s $0, AX, X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s $255, 8(AX), X0, X%d\n", op, legacyLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $82, R9, X22, X31\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedintegerinsertforms": {Name: "packedintegerinsertforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-integer-insert.ll", "packed-integer-insert.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedIntegerInsertRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PINSRB $-1, AX, X0",
+		"PINSRW $256, AX, X0",
+		"PINSRD $1, AX, Y0",
+		"PINSRQ.Z $1, AX, X0",
+		"PINSRB $1, AL, X0",
+		"PINSRD $1, X0, X1",
+		"PINSRQ $1, AX, X16",
+		"VPINSRB $1, AX, X0, Y1",
+		"VPINSRW $1, AX, Y0, X1",
+		"VPINSRD $1, X0, X1, X2",
+		"VPINSRQ $1, AX, X0, K1, X1",
+		"VPINSRQ.Z $1, AX, X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's PINSR/VPINSR tables", instruction)
+			}
+		})
+	}
+
+	for _, instruction := range []string{
+		"PINSRQ $1, AX, X0",
+		"VPINSRB $1, AX, X0, X1",
+		"VPINSRQ $1, AX, X0, X1",
+		"PINSRD $1, R8, X0",
+		"PINSRD $1, AX, X8",
+	} {
+		t.Run("386_"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's 386 PINSR/VPINSR tables", instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_insert_test.go b/amd64_lower_insert_test.go
new file mode 100644
index 000000000..deac8e303
--- /dev/null
+++ b/amd64_lower_insert_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedVectorInsertCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 defines three complete insert tables:
+	//   _yvinsertf128: imm8, X/m, Y, Y
+	//   _yvinsertf32x4: imm8, X/m, Y|Z, [K1-K7,] Y|Z
+	//   _yvinsertf32x8: imm8, Y/m, Z, [K1-K7,] Z
+	// Exercise register and memory members of every source class, every
+	// destination width, and both merge and zero masking for all ten opcodes.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+		zreg   int
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", zreg: 21},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", zreg: 21},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", zreg: 21},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var src strings.Builder
+			src.WriteString("TEXT packedvectorinsertforms(SB),NOSPLIT,$0-0\n")
+			if target.goarch == "amd64" {
+				for _, op := range []string{"VINSERTF128", "VINSERTI128"} {
+					fmt.Fprintf(&src, "\t%s $0, X0, Y1, Y2\n", op)
+					fmt.Fprintf(&src, "\t%s $255, (AX), Y3, Y4\n", op)
+				}
+			}
+			for _, op := range []string{"VINSERTF32X4", "VINSERTF64X2", "VINSERTI32X4", "VINSERTI64X2"} {
+				fmt.Fprintf(&src, "\t%s $0, X0, Y1, Y2\n", op)
+				fmt.Fprintf(&src, "\t%s $255, (AX), Y3, Y4\n", op)
+				fmt.Fprintf(&src, "\t%s $1, X20, Y20, K1, Y21\n", op)
+				fmt.Fprintf(&src, "\t%s.Z $2, (AX), Y20, K2, Y21\n", op)
+				fmt.Fprintf(&src, "\t%s $0, X0, Z0, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s $255, (AX), Z0, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s $3, X20, Z0, K3, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s.Z $1, (AX), Z0, K4, Z%d\n", op, target.zreg)
+			}
+			for _, op := range []string{"VINSERTF32X8", "VINSERTF64X4", "VINSERTI32X8", "VINSERTI64X4"} {
+				fmt.Fprintf(&src, "\t%s $0, Y0, Z0, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s $255, (AX), Z0, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s $1, Y20, Z0, K5, Z%d\n", op, target.zreg)
+				fmt.Fprintf(&src, "\t%s.Z $1, (AX), Z0, K6, Z%d\n", op, target.zreg)
+			}
+			src.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, strings.Replace(src.String(), ",NOSPLIT", "", 1), true)
+
+			file, err := Parse(ArchAMD64, src.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedvectorinsertforms": {Name: "packedvectorinsertforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-vector-insert-"+target.name+".ll", "packed-vector-insert-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedVectorInsertRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VINSERTI128 $0, Y0, Y1, Y2",
+		"VINSERTF128 $0, X0, Z1, Z2",
+		"VINSERTI128 $256, X0, Y1, Y2",
+		"VINSERTF128 $-1, X0, Y1, Y2",
+		"VINSERTI128.Z $0, X0, Y1, Y2",
+		"VINSERTF128 $0, X0, Y1, K1, Y2",
+		"VINSERTI32X4 $0, Y0, Y1, Y2",
+		"VINSERTF64X2 $0, X0, X1, X2",
+		"VINSERTI64X2 $0, X0, Y1, Z2",
+		"VINSERTF32X4 $0, X0, Y1, K0, Y2",
+		"VINSERTI32X4.Z $0, X0, Y1, Y2",
+		"VINSERTF64X2.BCST $0, (AX), Z1, Z2",
+		"VINSERTI32X8 $0, X0, Z1, Z2",
+		"VINSERTF64X4 $0, Y0, Y1, Y2",
+		"VINSERTI64X4 $0, Y0, Z1, K0, Z2",
+		"VINSERTF32X8.Z $0, Y0, Z1, Z2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			src := "TEXT bad(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", strings.Replace(src, ",NOSPLIT", "", 1), false)
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's packed insert tables", instruction)
+			}
+		})
+	}
+
+	for _, instruction := range []string{
+		"VINSERTI128 $0, X0, Y0, Y1",
+		"VINSERTF128 $0, X0, Y0, Y1",
+		"VINSERTI128 $0, X16, Y0, Y1",
+		"VINSERTF128 $0, X0, Y16, Y1",
+		"VINSERTF32X4 $0, X0, Y0, Y1",
+		"VINSERTF64X2 $0, X0, Y0, Y1",
+		"VINSERTI32X4 $0, X0, Y0, Y1",
+		"VINSERTI64X2 $0, X0, Y0, Y1",
+		"VINSERTF32X8 $0, Y0, Z0, Z1",
+		"VINSERTF64X4 $0, Y0, Z0, Z1",
+		"VINSERTI32X8 $0, Y0, Z0, Z1",
+		"VINSERTI64X4 $0, Y0, Z0, Z1",
+		"VINSERTI32X4 $0, X0, Z8, Z0",
+		"VINSERTF64X2 $0, X0, Z0, K1, Z8",
+		"VINSERTI32X8 $0, Y0, Z8, Z0",
+		"VINSERTI64X4.Z $0, Y0, Z0, K1, Z8",
+	} {
+		src := "TEXT bad386(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		requireX86GoAssemblerResult(t, "386", strings.Replace(src, ",NOSPLIT", "", 1), false)
+		file, err := Parse(ArchAMD64, src)
+		if err != nil {
+			return
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs:         map[string]FuncSig{"bad386": {Name: "bad386", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("386 Translate accepted architecture-restricted %q", instruction)
+		}
+	}
+}
diff --git a/amd64_lower_insertps.go b/amd64_lower_insertps.go
new file mode 100644
index 000000000..a1e0a2c29
--- /dev/null
+++ b/amd64_lower_insertps.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerInsertPackedSingle implements all forms in Go 1.27's yxshuf and
+// _yvinsertps tables. The imm8 selects the register-source lane in bits 7:6,
+// the destination lane in bits 5:4, and lanes to clear in bits 3:0.
+func (c *amd64Ctx) lowerInsertPackedSingle(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	if baseOp != "INSERTPS" && baseOp != "VINSERTPS" {
+		return false, false, nil
+	}
+	var bindingErr error
+	ins, _, _, bindingErr = c.bindInsertExtractForm(op, ins)
+	if bindingErr != nil {
+		return true, false, bindingErr
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", baseOp, ins.Raw)
+	}
+	wantArgs := 3
+	if baseOp == "VINSERTPS" {
+		wantArgs = 4
+	}
+	if len(ins.Args) != wantArgs || ins.Args[0].Kind != OpImm || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+		return true, false, fmt.Errorf("amd64 %s expects unsigned imm8, X/m32 source, %s: %q", baseOp, map[bool]string{false: "X destination", true: "X base, X destination"}[baseOp == "VINSERTPS"], ins.Raw)
+	}
+
+	source := ins.Args[1]
+	base := ins.Args[2]
+	destination := ins.Args[2]
+	if baseOp == "VINSERTPS" {
+		destination = ins.Args[3]
+	}
+	if base.Kind != OpReg || destination.Kind != OpReg {
+		return true, false, fmt.Errorf("amd64 %s expects X base/destination registers: %q", baseOp, ins.Raw)
+	}
+	if baseOp == "INSERTPS" {
+		if !c.isGoLegacyXReg(base.Reg) {
+			return true, false, fmt.Errorf("%s INSERTPS destination is outside Go 1.27's X register class: %q", c.goarch, ins.Raw)
+		}
+	} else if !amd64EVEXVectorRegister(base, 16) || !amd64EVEXVectorRegister(destination, 16) {
+		return true, false, fmt.Errorf("%s VINSERTPS base/destination is outside Go 1.27's VEX/EVEX X register class: %q", c.goarch, ins.Raw)
+	}
+
+	var inserted string
+	if source.Kind == OpReg {
+		valid := c.isGoLegacyXReg(source.Reg)
+		if baseOp == "VINSERTPS" {
+			valid = amd64EVEXVectorRegister(source, 16)
+		}
+		if !valid {
+			return true, false, fmt.Errorf("%s %s source is outside Go 1.27's X register class: %q", c.goarch, baseOp, ins.Raw)
+		}
+		sourceBytes, err := c.loadX(source.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		sourceLanes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", sourceLanes, sourceBytes)
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %%%s, i32 %d\n", selected, sourceLanes, (ins.Args[0].Imm>>6)&3)
+		inserted = "%" + selected
+	} else if source.Kind == OpFP {
+		// An original m32 FP span can comprise four independent ABI0
+		// shadow fields. It is not a contiguous load from the first alloca.
+		value, err := c.loadFPVectorBytes(source.FPOffset, 4)
+		if err != nil {
+			return true, false, err
+		}
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i8> %s to i32\n", bits, value)
+		inserted = "%" + bits
+	} else {
+		if !isAMD64MemoryOperand(source) {
+			return true, false, fmt.Errorf("amd64 %s expects an X register or memory source: %q", baseOp, ins.Raw)
+		}
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return true, false, err
+		}
+		bits := c.newTmp()
+		// INSERTPS always reads m32, even when imm8 subsequently clears it.
+		fmt.Fprintf(c.b, "  %%%s = load volatile i32, %s %s, align 1\n", bits, pointerType, pointer)
+		inserted = "%" + bits
+	}
+
+	baseBytes, err := c.loadX(base.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	baseLanes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", baseLanes, baseBytes)
+	placed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %s, i32 %d\n", placed, baseLanes, inserted, (ins.Args[0].Imm>>4)&3)
+	result := "%" + placed
+	for lane := 0; lane < 4; lane++ {
+		if ins.Args[0].Imm&(1<<lane) == 0 {
+			continue
+		}
+		cleared := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %s, i32 0, i32 %d\n", cleared, result, lane)
+		result = "%" + cleared
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %s to <16 x i8>\n", out, result)
+	if baseOp == "VINSERTPS" {
+		return true, false, c.storePackedMoveOperand(destination, 16, "%"+out)
+	}
+	return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+}
diff --git a/amd64_lower_insertps_test.go b/amd64_lower_insertps_test.go
new file mode 100644
index 000000000..56c11cc8a
--- /dev/null
+++ b/amd64_lower_insertps_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86InsertPSCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's yxshuf and _yvinsertps tables contain exactly:
+	//   INSERTPS  imm8, X/m32, X
+	//   VINSERTPS imm8, X/m32, X, X
+	// VINSERTPS can select either its VEX (<16) or EVEX (<32) entry.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			src := fmt.Sprintf(`TEXT insertpsforms(SB),NOSPLIT,$0-0
+	INSERTPS $0, X0, X1
+	INSERTPS $255, 4(AX), X%d
+`, legacyLast)
+			vex := `
+	VINSERTPS $0, X0, X1, X2
+	VINSERTPS $255, 8(AX), X14, X15
+	VINSERTPS $16, X20, X21, X22
+	VINSERTPS $32, 12(AX), X30, X31
+`
+			if target.goarch == "386" {
+				// Preserve the previous mixed positive verbatim as an actual
+				// Go rejection: the 386 frontend cannot take four operands.
+				goAssemblerOracleOutput(t, "386", strings.Replace(src+vex+"RET\n", "NOSPLIT", "4", 1), "", false)
+				original, err := Parse(ArchAMD64, src+vex+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(original, Options{Goarch: "386", TargetTriple: target.triple, Sigs: map[string]FuncSig{"insertpsforms": {Ret: Void}}}); err == nil {
+					t.Fatal("original Go-rejected mixed 386 fixture translated")
+				}
+			} else {
+				src += vex
+			}
+			src += "RET\n"
+			goAssemblerOracleOutput(t, target.goarch, strings.Replace(src, "NOSPLIT", "4", 1), "", true)
+			file, err := Parse(ArchAMD64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"insertpsforms": {Name: "insertpsforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "insertps-"+target.name+".ll", "insertps-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86InsertPSRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"INSERTPS X0, X1",
+		"INSERTPS $-1, X0, X1",
+		"INSERTPS $256, X0, X1",
+		"INSERTPS $0, Y0, X1",
+		"INSERTPS $0, X0, Y1",
+		"INSERTPS.Z $0, X0, X1",
+		"VINSERTPS $0, X0, X1",
+		"VINSERTPS $0, X0, X1, X2, X3",
+		"VINSERTPS $0, Y0, X1, X2",
+		"VINSERTPS $0, X0, Y1, X2",
+		"VINSERTPS $0, X0, X1, Y2",
+		"VINSERTPS $0, X0, K1, X1",
+		"VINSERTPS.Z $0, X0, X1, X2",
+		"VINSERTPS.BCST $0, (AX), X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86InsertPSRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"INSERTPS $0, X8, X0",
+		"INSERTPS $0, X0, X8",
+	} {
+		assertX86InsertPSRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+	}
+}
+
+func assertX86InsertPSRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's INSERTPS tables", instruction)
+	}
+}
diff --git a/amd64_lower_integer_dot.go b/amd64_lower_integer_dot.go
new file mode 100644
index 000000000..832bfa4ae
--- /dev/null
+++ b/amd64_lower_integer_dot.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerIntegerPackedDotProduct(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedDotProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	// E4 reads one exact volatile dword per enabled output lane; broadcast
+	// reads m32 iff an output lane is enabled. VEX retains its full tuple.
+	first, err := c.loadX86PackedShiftLanes(ins.Args[form.first], form.byteWidth, 32, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	lanes, inputBits := form.byteWidth/4, form.spec.inputBits
+	inputLanes := form.byteWidth * 8 / inputBits
+	firstBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x i%d>\n", firstBits, lanes, first, inputLanes, inputBits)
+	second, err := c.loadPackedCompareBytes(ins.Args[form.second], form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	destination := ins.Args[form.destination]
+	oldBytes, err := c.loadPackedCompareBytes(destination, form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	other := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, inputLanes, inputBits, second)
+	old := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, 32, oldBytes)
+	computed := c.emitPackedDotProduct(form.spec, lanes, "%"+firstBits, other, old)
+	if form.mask >= 0 {
+		computed = amd64ApplyI32LaneMask(c, lanes, computed, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i32> %s to <%d x i8>\n", out, lanes, computed, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
diff --git a/amd64_lower_lddqu.go b/amd64_lower_lddqu.go
new file mode 100644
index 000000000..17995dce2
--- /dev/null
+++ b/amd64_lower_lddqu.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import "fmt"
+
+type amd64UnalignedLoadSpec struct {
+	maxBytes int
+	vector   bool
+}
+
+// amd64UnalignedLoadSpecs is the complete Go 1.27 ylddqu/_yvlddqu grammar.
+// Both instructions are load-only; legacy LDDQU is X-width, while VLDDQU
+// adds the VEX Y-width row.
+var amd64UnalignedLoadSpecs = map[Op]amd64UnalignedLoadSpec{
+	"LDDQU":  {maxBytes: 16},
+	"VLDDQU": {maxBytes: 32, vector: true},
+}
+
+func (c *amd64Ctx) lowerUnalignedVectorLoad(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86UnalignedLoadProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || ins.Args[0].Kind == OpFP {
+		return true, false, fmt.Errorf("%w: LDDQU needs its original x86 native access, not logical FP storage", ErrProbeNeedsContext)
+	}
+	// Share only the native vector transport. No alignment assumption is
+	// introduced: the actual opcode retains its wider/repeated reads and #AC.
+	move := amd64PackedVectorMoveForm{byteWidth: form.byteWidth, memory: 0, destination: 1, mask: -1}
+	return true, false, c.lowerNativeAlignedVectorMemory(ins, move, !form.spec.vector)
+}
diff --git a/amd64_lower_lddqu_test.go b/amd64_lower_lddqu_test.go
new file mode 100644
index 000000000..87ff20e61
--- /dev/null
+++ b/amd64_lower_lddqu_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64UnalignedLoadGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64UnalignedLoadSpec{
+		"LDDQU":  {maxBytes: 16},
+		"VLDDQU": {maxBytes: 32, vector: true},
+	}
+	if len(amd64UnalignedLoadSpecs) != len(expected) {
+		t.Fatalf("unaligned-load grammar has %d entries, want %d", len(amd64UnalignedLoadSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64UnalignedLoadSpecs[op]; !ok {
+			t.Errorf("unaligned-load grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("unaligned-load grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86LDDQUCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			source := fmt.Sprintf(`TEXT lddquforms(SB),$0-0
+	LDDQU 1(AX), X%d
+	VLDDQU 2(AX), X%d
+	VLDDQU 3(AX), Y%d
+`, last, last, last)
+			if target.goarch == "386" {
+				source += "\tVLDDQU 4(R9), Y8\n"
+			}
+			source += "\tRET\n"
+			file, signatures := x86UnboundVoidFormatSource(t, source, "lddquforms", target.goarch, target.triple)
+			if target.goarch == "386" {
+				// Keep the complete original Go object and all three public
+				// Context controls above. Go accepts the high names, but they
+				// do not describe a physical mode32 R9/Y8 instruction. The
+				// initialized low-bank five-target objects are independent.
+				instruction := file.Funcs[0].Instrs[len(file.Funcs[0].Instrs)-2]
+				if _, known, err := x86UnalignedLoadProperties(instruction.Op, instruction, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go's named high registers invented a mode32 physical instruction", err)
+				}
+				return
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return c.lowerUnalignedVectorLoad(instruction.Op, instruction)
+				})
+			for _, want := range []string{"asm sideeffect \"lddqu ", "asm sideeffect \"vlddqu "} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("LDDQU/VLDDQU lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "lddqu-"+target.name+".ll", "lddqu-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LDDQURejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LDDQU X0, X1"},
+		{goarch: "amd64", instruction: "LDDQU 0(AX), Y1"},
+		{goarch: "amd64", instruction: "VLDDQU X0, X1"},
+		{goarch: "amd64", instruction: "VLDDQU 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VLDDQU.Z 0(AX), X1"},
+		{goarch: "386", instruction: "LDDQU 0(AX), X8"},
+		{goarch: "386", instruction: "LDDQU 0(R9), X0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{Goarch: test.goarch, TargetTriple: triple, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside the Go table for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestAMD64LDDQURuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT lddqusemantics(SB),$0-16
+	MOVQ out+0(FP), AX
+	MOVQ in+8(FP), CX
+	STC
+	LDDQU 1(CX), X0
+	MOVUPS X0, 0(AX)
+	SETCS 16(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"lddqusemantics": {
+			Name: "lddqusemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void lddqusemantics(uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t in[17], out[17] = {0};
+  for (int i = 0; i < 17; i++) in[i] = (uint8_t)(i * 7 + 3);
+  lddqusemantics(out, in);
+  for (int i = 0; i < 16; i++) if (out[i] != in[i + 1]) return 10 + i;
+  if (out[16] != 1) return 30;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "lddqu_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_lea_complete_test.go b/amd64_lower_lea_complete_test.go
new file mode 100644
index 000000000..25d2f95e6
--- /dev/null
+++ b/amd64_lower_lea_complete_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86LEACompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA leadata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL leadata(SB), $8\n")
+	source.WriteString("TEXT leaforms(SB),$0-0\n")
+	widths := []string{"W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	for _, width := range widths {
+		op := "LEA" + width
+		source.WriteString("\t" + op + " 8(BX)(CX*2), AX\n")
+		source.WriteString("\t" + op + " leadata(SB), DX\n")
+		source.WriteString("\t" + op + " 16(BX), SP\n")
+		if goarch == "amd64" {
+			source.WriteString("\t" + op + " 24(R11)(R12*4), R13\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86LEACompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86LEACompleteFormsSource(target.goarch)
+			requireLEANativeGoObject(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"leaforms": {Name: "leaforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"trunc i64", "to i16", "to i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("LEA lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "lea-complete-"+target.name+".ll", "lea-complete-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LEARejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LEAW AX, BX"},
+		{goarch: "amd64", instruction: "LEAL 8(AX), X0"},
+		{goarch: "amd64", instruction: "LEAQ 8(AX)"},
+		{goarch: "amd64", instruction: "LEAW.Z 8(AX), BX"},
+		{goarch: "amd64", instruction: "LEAL $ret+0(FP), AX"},
+		{goarch: "386", instruction: "LEAQ 8(AX), BX"},
+		{goarch: "386", instruction: "LEAL $ret+0(FP), AX"},
+		{goarch: "386", instruction: "LEAW 8(R9), AX"},
+		{goarch: "386", instruction: "LEAL 8(AX), R8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireLEANativeGoObject(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ym_rl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64LEARuntimeWidthsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT leasementics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVQ $0x1122334455667788, AX
+	LEAW 0x1234(DI), AX
+	MOVQ AX, 0(DI)
+	LEAL 0x1234(DI), BX
+	MOVQ BX, 8(DI)
+	LEAQ 0x1234(DI), CX
+	MOVQ CX, 16(DI)
+	SETCS 24(DI)
+	SETOS 25(DI)
+	SETEQ 26(DI)
+	SETMI 27(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"leasementics": {
+				Name: "leasementics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void leasementics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[32] = {0};
+  uintptr_t address = (uintptr_t)(out + 0x1234);
+  leasementics(out);
+  uint64_t want16 = UINT64_C(0x1122334455660000) | (address & UINT64_C(0xffff));
+  if (load64(out+0) != want16) return 10;
+  if (load64(out+8) != (uint32_t)address) return 11;
+  if (load64(out+16) != address) return 12;
+  if (out[24] != 1 || out[25] != 1 || out[26] != 0 || out[27] != 1) return 13;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "lea_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_leave.go b/amd64_lower_leave.go
new file mode 100644
index 000000000..95696d254
--- /dev/null
+++ b/amd64_lower_leave.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64LeaveSpec struct {
+	bits int
+}
+
+// amd64LeaveSpecs is the complete Go 1.27 LEAVE grammar. W is shared,
+// L is 386-only, and Q is amd64-only. The lowering models the architectural
+// sequence SP = BP; POP BP against the translated register/address state.
+var amd64LeaveSpecs = map[Op]amd64LeaveSpec{
+	"LEAVEW": {bits: 16},
+	"LEAVEL": {bits: 32},
+	"LEAVEQ": {bits: 64},
+}
+
+func (c *amd64Ctx) lowerLeave(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64LeaveSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.bits == 64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	if c.goarch != "386" && spec.bits == 32 {
+		return true, false, fmt.Errorf("amd64 %s is absent from Go 1.27's 64-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	base, err := c.loadReg(BP)
+	if err != nil {
+		return true, false, err
+	}
+	address := base
+	if c.goarch == "386" {
+		low := c.truncI64(base, I32)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, low)
+		address = "%" + wide
+	}
+	pointer := c.ptrFromAddrI64(address)
+	typ := amd64StackLLVMType(spec.bits)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", value, typ, pointer)
+	if err := c.storeRegSized(BP, typ, "%"+value); err != nil {
+		return true, false, err
+	}
+	if c.goarch == "386" {
+		address32 := c.truncI64(address, I32)
+		next32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", next32, address32, spec.bits/8)
+		next64 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", next64, next32)
+		return true, false, c.storeRegUnchecked(SP, "%"+next64)
+	}
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", next, address, spec.bits/8)
+	return true, false, c.storeRegUnchecked(SP, "%"+next)
+}
diff --git a/amd64_lower_legacy_float_memory.go b/amd64_lower_legacy_float_memory.go
new file mode 100644
index 000000000..806a4c4ab
--- /dev/null
+++ b/amd64_lower_legacy_float_memory.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func x86LegacyPackedFloatingNativeMemoryBits(ins Instr, goarch string) int {
+	parsed, known, err := x86FloatArithmeticProperties(ins, goarch, "")
+	form := parsed.x86FloatBinaryForm
+	if !known || err != nil || !form.legacy || form.scalar || form.memory < 0 || ins.Args[form.memory].Kind == OpFP {
+		return 0
+	}
+	return form.bits
+}
+
+// Legacy packed SSE arithmetic consumes one complete native m128 operand.
+// An align-1 LLVM load followed by floating arithmetic can select a different
+// load/instruction sequence, losing the original alignment and fault contract.
+// Execute the exact validated opcode, including its source-order NaNs, MXCSR
+// exceptions/rounding/DAZ/FTZ, and observable read even when the result is dead.
+func (c *amd64Ctx) lowerLegacyPackedFloatingMemory(ins Instr, form x86FloatBinaryForm) error {
+	source := ins.Args[form.first]
+	if source.Kind == OpFP {
+		// ABI0 virtual fields are independently allocated. Even a logical
+		// contiguous field span is not original native stack alignment.
+		return fmt.Errorf("%w: %s m128 needs contiguous original FP storage and native alignment context, not virtual ABI0 fields", ErrProbeNeedsContext, ins.Op)
+	}
+	if ins.x86AddressBits != 0 {
+		return fmt.Errorf("%w: %s m128 lacks its original native address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	if source.Kind == OpMem && !x86CallerMemoryCertified(ins, form.first) {
+		if !c.nativeMemoryOperand(ins, form.first) {
+			return fmt.Errorf("%w: %s m128 needs original native stack backing, not virtual SP/BP", ErrProbeNeedsContext, ins.Op)
+		}
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return err
+	}
+	left, err := c.loadX(ins.Args[form.second].Reg)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	carrierType := amd64FMA3LLVMType(128/form.bits, form.bits)
+	carrier, result, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", carrier, left, carrierType)
+	assembly := strings.ToLower(string(ins.Op)) + " " + segment + "($2), $0"
+	// The tied private XMM value is read before its output is written. No
+	// original GP, flags, upper SIMD bytes, or additional pointer permission
+	// is created. Segment-aware pointers retain the original FS/GS prefix.
+	// SSE1 admits a <4 x float> XMM carrier on physical i386; a byte-vector
+	// constraint there requires SSE2 and fails LLVM legalization. These are
+	// only bitcasts, not extra arithmetic or an x87 transport ABI.
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %%%s, %s %s)\n", result, carrierType, assembly, "=x,0,r,~{memory},~{fpsr}", carrierType, carrier, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, carrierType, result)
+	return c.storeLegacyPackedLogical(ins.Args[form.destination], "%"+bytes)
+}
diff --git a/amd64_lower_legacy_mmx.go b/amd64_lower_legacy_mmx.go
new file mode 100644
index 000000000..46627c8e6
--- /dev/null
+++ b/amd64_lower_legacy_mmx.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64LegacyMMXOperandClass uint8
+
+const (
+	amd64LegacyMMXMMX amd64LegacyMMXOperandClass = 1 << iota
+	amd64LegacyMMXXMM
+	amd64LegacyMMXMemory
+)
+
+type amd64LegacyMMXMoveSpec struct {
+	source       amd64LegacyMMXOperandClass
+	destination  amd64LegacyMMXOperandClass
+	transferBits int
+	zeroExtend   bool
+	nonTemporal  bool
+}
+
+// amd64LegacyMMXMoveSpecs describes the complete Go 1.27 legacy cross-domain
+// and non-temporal MMX move grammar. Operand classes and transfer semantics are
+// data; one parser validates the owned spellings. SIMD non-temporal moves
+// have their complete separate x86NonTemporalVectorSpecs grammar.
+var amd64LegacyMMXMoveSpecs = map[Op]amd64LegacyMMXMoveSpec{
+	"MOVQOZX": {source: amd64LegacyMMXMMX | amd64LegacyMMXXMM | amd64LegacyMMXMemory, destination: amd64LegacyMMXXMM, transferBits: 64, zeroExtend: true},
+	"MOVDQ2Q": {source: amd64LegacyMMXXMM, destination: amd64LegacyMMXMMX, transferBits: 64},
+	"MOVNTQ":  {source: amd64LegacyMMXMMX, destination: amd64LegacyMMXMemory, transferBits: 64, nonTemporal: true},
+}
+
+type amd64LegacyMMXMoveForm struct {
+	source      Operand
+	destination Operand
+}
+
+func (c *amd64Ctx) lowerLegacyMMXMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64LegacyMMXMoveSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if baseOp == "MOVDQ2Q" && (ins.x86Encoded || ins.x86SourceRaw != nil) {
+		return true, false, fmt.Errorf("%w: raw Intel MOVDQ2Q requires its physical MMX/x87 entry and caller-state contract: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	if baseOp == "MOVDQ2Q" {
+		return false, false, nil // Named Go source has all AMOVQ rows, not this Intel-only shape.
+	}
+	form, err := c.parseLegacyMMXMoveForm(baseOp, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitLegacyMMXMove(spec, form)
+}
+
+func (c *amd64Ctx) parseLegacyMMXMoveForm(op string, spec amd64LegacyMMXMoveSpec, ins Instr) (amd64LegacyMMXMoveForm, error) {
+	var form amd64LegacyMMXMoveForm
+	if len(ins.Args) != 2 {
+		return form, fmt.Errorf("%s %s expects exactly two operands: %q", c.goarch, op, ins.Raw)
+	}
+	sourceClass := c.legacyMMXOperandClass(ins.Args[0])
+	destinationClass := c.legacyMMXOperandClass(ins.Args[1])
+	if sourceClass&spec.source == 0 || destinationClass&spec.destination == 0 {
+		return form, fmt.Errorf("%s %s operands are outside its Go 1.27 legacy MMX table: %q", c.goarch, op, ins.Raw)
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpMem && !x86MemoryRegistersValidForArch(operand.Mem, c.goarch) {
+			return form, fmt.Errorf("%s %s memory address uses an out-of-range register: %q", c.goarch, op, ins.Raw)
+		}
+	}
+	return amd64LegacyMMXMoveForm{source: ins.Args[0], destination: ins.Args[1]}, nil
+}
+
+func (c *amd64Ctx) legacyMMXOperandClass(operand Operand) amd64LegacyMMXOperandClass {
+	if operand.Kind == OpReg {
+		if _, ok := amd64ParseMReg(operand.Reg); ok {
+			return amd64LegacyMMXMMX
+		}
+		if c.isGoLegacyXReg(operand.Reg) {
+			return amd64LegacyMMXXMM
+		}
+		return 0
+	}
+	if isAMD64MemoryOperand(operand) {
+		return amd64LegacyMMXMemory
+	}
+	return 0
+}
+
+func (c *amd64Ctx) emitLegacyMMXMove(spec amd64LegacyMMXMoveSpec, form amd64LegacyMMXMoveForm) (bool, bool, error) {
+	if spec.destination == amd64LegacyMMXXMM {
+		bits, err := c.loadLegacyMMXMoveLow64(form.source)
+		if err != nil {
+			return true, false, err
+		}
+		words := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %s, i32 0\n", words, bits)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, words)
+		return true, false, c.storeX(form.destination.Reg, "%"+bytes)
+	}
+
+	if spec.destination == amd64LegacyMMXMMX {
+		bits, err := c.loadLegacyMMXMoveLow64(form.source)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeReg(form.destination.Reg, bits)
+	}
+
+	// MOVNTQ is the only remaining memory destination in this MMX directory.
+	bits, err := c.evalIntSized(form.source, I64)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.storeMOVNTIMemory(form.destination, I64, bits)
+}
+
+func (c *amd64Ctx) loadLegacyMMXMoveLow64(source Operand) (string, error) {
+	if source.Kind == OpReg {
+		if _, ok := amd64ParseMReg(source.Reg); ok {
+			return c.loadReg(source.Reg)
+		}
+		if c.isGoLegacyXReg(source.Reg) {
+			value, err := c.loadX(source.Reg)
+			if err != nil {
+				return "", err
+			}
+			words := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", words, value)
+			low := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", low, words)
+			return "%" + low, nil
+		}
+	}
+	return c.evalIntSized(source, I64)
+}
diff --git a/amd64_lower_legacy_mmx_test.go b/amd64_lower_legacy_mmx_test.go
new file mode 100644
index 000000000..cd38b7394
--- /dev/null
+++ b/amd64_lower_legacy_mmx_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64LegacyMMXMoveGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64LegacyMMXMoveSpec{
+		"MOVQOZX": {source: amd64LegacyMMXMMX | amd64LegacyMMXXMM | amd64LegacyMMXMemory, destination: amd64LegacyMMXXMM, transferBits: 64, zeroExtend: true},
+		"MOVDQ2Q": {source: amd64LegacyMMXXMM, destination: amd64LegacyMMXMMX, transferBits: 64},
+		"MOVNTQ":  {source: amd64LegacyMMXMMX, destination: amd64LegacyMMXMemory, transferBits: 64, nonTemporal: true},
+	}
+	if !reflect.DeepEqual(amd64LegacyMMXMoveSpecs, want) {
+		t.Fatalf("legacy MMX move grammar = %+v, want %+v", amd64LegacyMMXMoveSpecs, want)
+	}
+}
+
+func TestTranslateX86LegacyMMXCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			base := "BX"
+			xreg := "X7"
+			if target.goarch == "amd64" {
+				base = "R11"
+				xreg = "X15"
+			}
+			source := `TEXT legacymmxforms(SB),$0-0
+	PSHUFW $-128, M1, M2
+	PSHUFW $127, 8(BX), M3
+	MOVQOZX M2, X2
+	MOVQOZX X1, X3
+	MOVQOZX 16(BX), X4
+	MOVNTQ M2, 24(BX)
+` + "\tMOVQOZX M3, " + xreg + "\n" +
+				"\tMOVNTQ M3, 32(" + base + ")\n\tRET\n"
+			ir := x86UnboundVoidScalarFormatObject(t, source, "legacymmxforms", target.goarch, target.triple)
+			for _, want := range []string{"!nontemporal !0", "!0 = !{i32 1}"} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "legacy-mmx-"+target.name+".ll", "legacy-mmx-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestAMD64LegacyMMXRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT legacymmxsemantics(SB),NOSPLIT,$0-16
+	MOVQ value+0(FP), AX
+	MOVQ out+8(FP), DI
+	MOVQ AX, M1
+	PSHUFW $0x1b, M1, M2
+	MOVNTQ M2, 0(DI)
+	MOVQOZX M2, X1
+	MOVDQ2Q X1, M3
+	MOVNTQ M3, 8(DI)
+	EMMS
+	MOVNTDQ X1, 16(DI)
+	SFENCE
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"legacymmxsemantics": {
+			Name: "legacymmxsemantics", Args: []LLVMType{I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void legacymmxsemantics(uint64_t, uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  __attribute__((aligned(16))) uint8_t out[32] = {0xff};
+  legacymmxsemantics(UINT64_C(0x1122334455667788), out);
+  const uint64_t shuffled = UINT64_C(0x7788556633441122);
+  if (load64(out) != shuffled) return 10;
+  if (load64(out + 8) != shuffled) return 11;
+  if (load64(out + 16) != shuffled) return 12;
+  if (load64(out + 24) != 0) return 13;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy_mmx_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateX86LegacyMMXEncoderAliases(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			const source = `TEXT encoderaliases(SB),$0-0
+	MOVDQ2Q X1, M1
+	MOVNTDQ X2, 8(BX)
+	RET
+`
+			// Go accepts these Intel decoder names in addition to the MOVQ and
+			// MOVNTO spellings used by its primary optab entries.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "encoderaliases", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "legacy-mmx-alias-"+target.name+".ll", "legacy-mmx-alias-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LegacyMMXRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PSHUFW $-129, M1, M2"},
+		{goarch: "amd64", instruction: "PSHUFW $128, M1, M2"},
+		{goarch: "amd64", instruction: "PSHUFW $1, X1, M2"},
+		{goarch: "amd64", instruction: "PSHUFW $1, M1, X2"},
+		{goarch: "amd64", instruction: "PSHUFW.Z $1, M1, M2"},
+		{goarch: "amd64", instruction: "MOVQOZX M1, M2"},
+		{goarch: "amd64", instruction: "MOVQOZX $1, X2"},
+		{goarch: "amd64", instruction: "MOVNTQ X1, 8(BX)"},
+		{goarch: "amd64", instruction: "MOVNTQ M1, M2"},
+		{goarch: "amd64", instruction: "MOVDQ2Q M1, X1"},
+		{goarch: "amd64", instruction: "MOVNTDQ 8(BX), X1"},
+		{goarch: "386", instruction: "MOVQOZX M1, X8"},
+		{goarch: "386", instruction: "MOVNTQ M1, 8(R11)"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside the legacy MMX grammar", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_legacy_packed_logical_test.go b/amd64_lower_legacy_packed_logical_test.go
new file mode 100644
index 000000000..40f5b84ce
--- /dev/null
+++ b/amd64_lower_legacy_packed_logical_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86LegacyPackedLogicalCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastX := 15
+			if target.goarch == "386" {
+				lastX = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT legacypackedlogicalforms(SB),$0-0\n")
+			for _, op := range []string{"PAND", "PANDN", "POR", "PXOR"} {
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s M0, M7\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M7\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, lastX)
+				fmt.Fprintf(&source, "\t%s 16(AX), X%d\n", op, lastX)
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "legacypackedlogicalforms", target.goarch, target.triple)
+			wantIR := []string{"and <16 x i8>", "or <16 x i8>", "xor <16 x i8>"}
+			if target.goarch == "amd64" {
+				wantIR = append(wantIR, "and i64", "or i64", "xor i64")
+			}
+			for _, want := range wantIR {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("legacy packed logical lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "legacy-packed-logical-"+target.name+".ll", "legacy-packed-logical-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LegacyPackedLogicalRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PAND M0, X1"},
+		{goarch: "amd64", instruction: "POR X0, M1"},
+		{goarch: "amd64", instruction: "PXOR Y0, Y1"},
+		{goarch: "amd64", instruction: "PAND.Z X0, X1"},
+		{goarch: "amd64", instruction: "PAND M0"},
+		{goarch: "amd64", instruction: "POR M0, M1, M2"},
+		{goarch: "386", instruction: "PXOR X0, X8"},
+		{goarch: "386", instruction: "PAND 8(R9), X0"},
+		{goarch: "386", instruction: "PAND M0, M1"},
+		{goarch: "386", instruction: "PANDN M0, M1"},
+		{goarch: "386", instruction: "POR M0, M1"},
+		{goarch: "386", instruction: "PXOR M0, M1"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's packed logical table for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestAMD64LegacyPackedLogicalMMXRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86LegacyPackedLogicalMMXRuntimeSource
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"legacypackedlogicalsemantics": {
+				Name: "legacypackedlogicalsemantics", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void legacypackedlogicalsemantics(uint8_t *, uint64_t, uint64_t);
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v; }
+int main(void) {
+  uint8_t out[33] = {0};
+  uint64_t a = UINT64_C(0x0ff00ff0a55aa55a);
+  uint64_t b = UINT64_C(0x33cc55aa5aa5f00f);
+  legacypackedlogicalsemantics(out, a, b);
+  if (load64(out+0) != (a & b)) return 10;
+  if (load64(out+8) != ((~b) & a)) return 11;
+  if (load64(out+16) != (a | b)) return 12;
+  if (load64(out+24) != (a ^ b)) return 13;
+  if (out[32] != 1) return 14;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy_packed_logical_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_legacy_packed_move.go b/amd64_lower_legacy_packed_move.go
new file mode 100644
index 000000000..a8eb59f75
--- /dev/null
+++ b/amd64_lower_legacy_packed_move.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The paired native emitter preserves the exact whole128 opcode, including
+// alignment faults. Continuation defines the vector bytes but grants no
+// initialized pointee, native store or virtual-frame permission. Callers must
+// separately close the original source/physical-mode identity.
+func x86LoweredLegacyPackedMoveRead(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.memory != 0 || form.source.Kind != OpMem ||
+		form.source.Mem.Sym != "" || !x86OrdinaryNativeMemoryOperand(form.source, arch) {
+		return false, false
+	}
+	return x86ResultIncomingPointerReadAddressIdentity(form.source, state, arch) &&
+		x86ResultStore(form.destination, 16, state, owned, resultOffset, arch), true
+}
+
+// Both floating and integer dispatch use the same whole-128-bit yxmov grammar.
+// Native operands keep the original opcode: align-1 loads lose aligned faults,
+// and ordinary LLVM loads disappear when the source result is dead.
+func (c *amd64Ctx) lowerLegacyPackedMove(op Op, ins Instr) (bool, bool, error) {
+	known, err := c.validateLegacyPackedMove(op, ins)
+	if !known || err != nil {
+		return known, false, err
+	}
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, _, err := x86LegacyPackedMoveProperties(op, ins, arch)
+	if err != nil {
+		return true, false, err
+	}
+	if form.memory >= 0 {
+		memory := ins.Args[form.memory]
+		if memory.Kind == OpFP && form.aligned {
+			return true, false, fmt.Errorf("%w: %s FP operand needs its original native alignment", ErrProbeNeedsContext, op)
+		}
+		// Existing checked virtual FP/AUTO views are not native addresses.
+		// They keep their independent layout handling; this rule gives them
+		// neither native alignment nor permission to read adjacent storage.
+		virtual := !c.nativeMemoryOperand(ins, form.memory)
+		if memory.Kind == OpMem && (x86CallerMemoryCertified(ins, form.memory) || c.fixedLocalMemoryCertified(ins, form.memory)) {
+			virtual = false
+		}
+		if !virtual {
+			if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+				return true, false, fmt.Errorf("%w: legacy packed move needs its original native address size", ErrProbeNeedsContext)
+			}
+			return true, false, c.lowerLegacyPackedMoveNative(op, form)
+		}
+	}
+	value, err := c.loadXVecOperand(form.source)
+	if err != nil {
+		return true, false, err
+	}
+	if form.destination.Kind == OpReg {
+		return true, false, c.storeX(form.destination.Reg, value)
+	}
+	return true, false, c.storeXVecOperand(form.destination, value)
+}
+
+func (c *amd64Ctx) lowerLegacyPackedMoveNative(op Op, form x86LegacyPackedMoveForm) error {
+	memory := form.source
+	if form.memoryWrite {
+		memory = form.destination
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(memory)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	mnemonic := strings.ToLower(string(op))
+	switch strings.ToUpper(string(op)) {
+	case "MOVOU":
+		mnemonic = "movdqu"
+	case "MOVO", "MOVOA":
+		mnemonic = "movdqa"
+	}
+	if form.memoryWrite {
+		value, err := c.loadX(form.source.Reg)
+		if err != nil {
+			return err
+		}
+		carrier := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x float>\n", carrier, value)
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(<4 x float> %%%s, %s %s)\n",
+			mnemonic+" $0, "+segment+"($1)", "x,r,~{memory}", carrier, pointerType, pointer)
+		return nil
+	}
+	// A float carrier preserves SSE1's XMM class even on 386. It is a bit
+	// transport only, with no floating arithmetic or change to MXCSR/FLAGS.
+	loaded, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s %s)\n",
+		loaded, mnemonic+" "+segment+"($1), $0", "=x,r,~{memory}", pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, loaded)
+	return c.storeX(form.destination.Reg, "%"+bytes)
+}
diff --git a/amd64_lower_lods_test.go b/amd64_lower_lods_test.go
new file mode 100644
index 000000000..b145dd293
--- /dev/null
+++ b/amd64_lower_lods_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86LODSCompleteFormsSource(goarch string) string {
+	widths := []string{"B", "W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT lodsforms(SB),$0-0\n")
+	for _, width := range widths {
+		op := "LODS" + width
+		fmt.Fprintf(&source, "\t%s\n", op)
+		fmt.Fprintf(&source, "\tCLD; REP; %s\n", op)
+		fmt.Fprintf(&source, "\tSTD; REPN; %s\n", op)
+		source.WriteString("\tCLD\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86LODSCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86LODSCompleteFormsSource(target.goarch)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "lodsforms", target.goarch, target.triple)
+			for _, width := range []string{"b", "w", "l"} {
+				if want := "@__plan9asm_rep_lods" + width; !strings.Contains(ir, want) {
+					t.Fatalf("LODS lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "@__plan9asm_rep_lodsq") {
+				t.Fatalf("LODSQ lowering omitted qword helper:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "lods-"+target.name+".ll", "lods-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86LODSRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LODSB AX"},
+		{goarch: "amd64", instruction: "LODSW AX, BX"},
+		{goarch: "amd64", instruction: "LODSL.Z"},
+		{goarch: "386", instruction: "LODSQ"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's LODS ynone table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64LODSRuntimeSemanticsWidthsPrefixesAndDirection(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT lodssemantics(SB),NOSPLIT,$0-16
+	MOVQ out+0(FP), R8
+	MOVQ data+8(FP), R9
+	CLD
+
+	MOVQ R9, SI
+	MOVQ $0x1122334455667788, AX
+	LODSB
+	MOVQ AX, 0(R8)
+	MOVQ SI, 8(R8)
+
+	MOVQ R9, SI
+	ADDQ $8, SI
+	MOVQ $0x1122334455667788, AX
+	LODSW
+	MOVQ AX, 16(R8)
+
+	MOVQ R9, SI
+	ADDQ $16, SI
+	MOVQ $-1, AX
+	LODSL
+	MOVQ AX, 24(R8)
+
+	MOVQ R9, SI
+	ADDQ $24, SI
+	LODSQ
+	MOVQ AX, 32(R8)
+
+	MOVQ R9, SI
+	ADDQ $32, SI
+	MOVQ $3, CX
+	REP; LODSB
+	MOVQ AX, 40(R8)
+	MOVQ SI, 48(R8)
+	MOVQ CX, 56(R8)
+
+	MOVQ R9, SI
+	ADDQ $40, SI
+	MOVQ $3, CX
+	REPN; LODSW
+	MOVQ AX, 64(R8)
+	MOVQ SI, 72(R8)
+	MOVQ CX, 80(R8)
+
+	MOVQ R9, SI
+	ADDQ $52, SI
+	MOVQ $2, CX
+	STD
+	REP; LODSL
+	CLD
+	MOVQ AX, 88(R8)
+	MOVQ SI, 96(R8)
+	MOVQ CX, 104(R8)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"lodssemantics": {
+				Name: "lodssemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void lodssemantics(uint8_t *, uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t data[64] = {0};
+  data[0] = 0xaa;
+  const uint16_t w = UINT16_C(0xbbcc); memcpy(data+8, &w, sizeof(w));
+  const uint32_t l = UINT32_C(0x89abcdef); memcpy(data+16, &l, sizeof(l));
+  const uint64_t q = UINT64_C(0x0123456789abcdef); memcpy(data+24, &q, sizeof(q));
+  data[32] = 1; data[33] = 2; data[34] = 3;
+  const uint16_t ws[3] = {0x1111,0x2222,0x3333}; memcpy(data+40, ws, sizeof(ws));
+  const uint32_t ls[2] = {0x44444444,0x55555555}; memcpy(data+48, ls, sizeof(ls));
+  uint8_t out[112] = {0};
+  lodssemantics(out, data);
+  if (load64(out+0) != UINT64_C(0x11223344556677aa) || load64(out+8) != (uintptr_t)(data+1)) return 10;
+  if (load64(out+16) != UINT64_C(0x112233445566bbcc)) return 11;
+  if (load64(out+24) != UINT64_C(0x89abcdef)) return 12;
+  if (load64(out+32) != q) return 13;
+  if ((load64(out+40) & 0xff) != 3 || load64(out+48) != (uintptr_t)(data+35) || load64(out+56) != 0) return 14;
+  if ((load64(out+64) & 0xffff) != 0x3333 || load64(out+72) != (uintptr_t)(data+46) || load64(out+80) != 0) return 15;
+  if (load64(out+88) != UINT64_C(0x44444444) || load64(out+96) != (uintptr_t)(data+44) || load64(out+104) != 0) return 16;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "lods_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_logical_family.go b/amd64_lower_logical_family.go
new file mode 100644
index 000000000..96cb8ed5e
--- /dev/null
+++ b/amd64_lower_logical_family.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPackedLogicalFamily(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, recognized := x86PackedLogicalSpecs[Op(base)]; !recognized {
+		return false, false, nil
+	}
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("packed logical dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := x86PackedLogicalProperties(ins, c.goarch)
+	if err != nil || !recognized {
+		return recognized, false, err
+	}
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return true, false, fmt.Errorf("%w: legacy packed logical m128 lacks original native address-size binding", ErrProbeNeedsContext)
+		}
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed logical m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	if form.mmx {
+		a, err := c.evalIntSized(first, I64)
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		if form.spec.mode == amd64PackedLogicalAndNot {
+			inverted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, -1\n", inverted, b)
+			b = "%" + inverted
+		}
+		operation := "and"
+		if form.spec.mode == amd64PackedLogicalOr {
+			operation = "or"
+		}
+		if form.spec.mode == amd64PackedLogicalXor {
+			operation = "xor"
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %s\n", result, operation, b, a)
+		return true, false, c.storeReg(destination.Reg, "%"+result)
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	lanes := form.byteWidth * 8 / form.spec.laneBits
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	b, err := c.loadPackedCompareLanes(second, form.byteWidth, form.spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.legacy && form.memory >= 0 {
+		// Retain the single original memory opcode: an align-1 load and
+		// portable logical arithmetic lose its alignment/dead-read faults.
+		result, err = c.emitPackedBinaryNativeMemory(first, form.spec.laneBits, b, strings.ToLower(string(op)))
+	} else {
+		// Native reads remain observable with dead results. EVEX inactive
+		// lanes alone suppress their accesses, including scalar broadcasts.
+		var a string
+		if ins.x86NumericalRead != nil || c.goReadOnlyOperand.allows(first, int64(form.memoryBytes)) ||
+			first.Kind == OpMem && c.nativeMemoryOperand(ins, form.first) {
+			a, err = c.loadX86PackedShiftLanes(first, form.byteWidth, form.spec.laneBits, form.broadcast, mask)
+		} else {
+			a, err = c.loadMaskedPackedCompareLanes(first, form.byteWidth, form.spec.laneBits, form.broadcast, mask)
+		}
+		if err == nil {
+			result = c.emitPackedLogical(lanes, amd64PackedLogicalSpec{form.spec.laneBits, form.spec.mode}, a, b)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask >= 0 {
+		old, err := c.loadPackedCompareLanes(destination, form.byteWidth, form.spec.laneBits, false)
+		if err != nil {
+			return true, false, err
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.spec.laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.spec.laneBits, result, form.byteWidth)
+	if form.legacy {
+		// Legacy writes update low X bits in every wider view but preserve the
+		// upper bytes. storeX alone is a separate shadow slot, not an alias.
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) storeLegacyPackedLogical(dst Operand, value string) error {
+	index, _ := amd64ParseXReg(dst.Reg)
+	for _, view := range []struct {
+		width int
+		slots map[int]string
+	}{{32, c.yRegSlot}, {64, c.zRegSlot}} {
+		slot, live := view.slots[index]
+		if !live {
+			continue
+		}
+		old, merged := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load <%d x i8>, ptr %s\n", old, view.width, slot)
+		extended := c.newTmp()
+		extendIndices := make([]string, view.width)
+		for i := range extendIndices {
+			lane := i
+			if i >= 16 {
+				lane = 16
+			}
+			extendIndices[i] = fmt.Sprintf("i32 %d", lane)
+		}
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <%d x i32> <%s>\n", extended, value, view.width, strings.Join(extendIndices, ", "))
+		indices := make([]string, view.width)
+		for i := range indices {
+			lane := i
+			if i < 16 {
+				lane += view.width
+			}
+			indices[i] = fmt.Sprintf("i32 %d", lane)
+		}
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %%%s, <%d x i8> %%%s, <%d x i32> <%s>\n", merged, view.width, old, view.width, extended, view.width, strings.Join(indices, ", "))
+		fmt.Fprintf(c.b, "  store <%d x i8> %%%s, ptr %s\n", view.width, merged, slot)
+	}
+	return c.storeX(dst.Reg, value)
+}
diff --git a/amd64_lower_logical_shift.go b/amd64_lower_logical_shift.go
new file mode 100644
index 000000000..88bf80f1e
--- /dev/null
+++ b/amd64_lower_logical_shift.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64PackedLogicalShiftSpec struct {
+	laneBits int
+	left     bool
+	vector   bool
+}
+
+// amd64PackedLogicalShiftSpecs covers all Go 1.27 uniform packed logical
+// shifts. Legacy operations use yps (MMX/XMM, immediate or packed count), and
+// V-prefixed operations use _yvpslld (X/Y/Z data and an immediate or X/m128
+// count, with the table's EVEX mask and D/Q broadcast forms).
+var amd64PackedLogicalShiftSpecs = map[Op]amd64PackedLogicalShiftSpec{
+	"PSLLW":  {laneBits: 16, left: true},
+	"PSLLL":  {laneBits: 32, left: true},
+	"PSLLQ":  {laneBits: 64, left: true},
+	"PSRLW":  {laneBits: 16},
+	"PSRLL":  {laneBits: 32},
+	"PSRLQ":  {laneBits: 64},
+	"VPSLLW": {laneBits: 16, left: true, vector: true},
+	"VPSLLD": {laneBits: 32, left: true, vector: true},
+	"VPSLLQ": {laneBits: 64, left: true, vector: true},
+	"VPSRLW": {laneBits: 16, vector: true},
+	"VPSRLD": {laneBits: 32, vector: true},
+	"VPSRLQ": {laneBits: 64, vector: true},
+}
+
+func (c *amd64Ctx) lowerPackedLogicalShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerX86PackedShift(op, ins)
+}
+
+func (c *amd64Ctx) loadPackedUniformLogicalShiftCount(count Operand, mmx bool) (string, error) {
+	if count.Kind == OpImm {
+		return fmt.Sprintf("%d", uint8(count.Imm)), nil
+	}
+	if mmx {
+		if count.Kind == OpMem || count.Kind == OpSym {
+			bytes, err := c.loadX86PackedShiftBytes(count, 8, true)
+			if err != nil {
+				return "", err
+			}
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i8> %s to i64\n", value, bytes)
+			return "%" + value, nil
+		}
+		return c.loadLegacyMMXPackedSource(count)
+	}
+	// The ignored upper count qword still belongs to the complete native
+	// m128 read, even when a zero mask or saturated result is optimized.
+	countBytes, err := c.loadX86PackedShiftBytes(count, 16, true)
+	if err != nil {
+		return "", err
+	}
+	countWords := c.newTmp()
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", countWords, countBytes)
+	fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", low, countWords)
+	return "%" + low, nil
+}
+
+func (c *amd64Ctx) emitPackedLogicalShift(spec amd64PackedLogicalShiftSpec, lanes int, data, count64 string) string {
+	inRange := c.newTmp()
+	safe64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %d\n", inRange, count64, spec.laneBits)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 0\n", safe64, inRange, count64)
+	count := "%" + safe64
+	if spec.laneBits < 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, count, spec.laneBits)
+		count = "%" + narrow
+	}
+	counts := amd64SplatInteger(c, lanes, spec.laneBits, count)
+	shifted := c.newTmp()
+	operation := "lshr"
+	if spec.left {
+		operation = "shl"
+	}
+	typeName := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", shifted, operation, typeName, data, counts)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s zeroinitializer\n", result, inRange, typeName, shifted, typeName)
+	return "%" + result
+}
diff --git a/amd64_lower_logical_shift_test.go b/amd64_lower_logical_shift_test.go
new file mode 100644
index 000000000..88ae19137
--- /dev/null
+++ b/amd64_lower_logical_shift_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedLogicalShiftCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast, zLast, dataReg, dstReg := 15, 22, 20, 21
+			if target.goarch == "386" {
+				legacyLast, zLast, dataReg, dstReg = 7, 7, 6, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedlogicalshiftforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ"} {
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $-1, M1\n", op)
+					fmt.Fprintf(&source, "\t%s M0, M1\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M1\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s $3, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VPSLLW", "VPSLLD", "VPSLLQ", "VPSRLW", "VPSRLD", "VPSRLQ"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s $-1, %s0, %s1\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s $255, 8(AX), %s%d\n", op, width, dstReg)
+					fmt.Fprintf(&source, "\t%s X0, %s%d, %s%d\n", op, width, dataReg, width, dstReg)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s%d, %s%d\n", op, width, dataReg, width, dstReg)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s $3, %s20, K1, %s22\n", op, width, width)
+						fmt.Fprintf(&source, "\t%s.Z X0, %s20, K7, %s22\n", op, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s $3, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s $3, 8(AX), Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s X0, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", op, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $3, Z20, K2, Z22\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z20, K6, Z22\n", op)
+				}
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), X%d\n", op, dstReg)
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), Y%d\n", op, dstReg)
+					fmt.Fprintf(&source, "\t%s.BCST $3, 8(AX), Z%d\n", op, zLast)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST.Z $3, 8(AX), K5, Z22\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, strings.ReplaceAll(source.String(), "NOSPLIT", "4"), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func packedlogicalshiftforms()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original packed-shift formats invented native/vector/mask inputs", api, err)
+				}
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{
+				"packedlogicalshiftforms": {Name: "packedlogicalshiftforms", Ret: Void},
+			}, target.goarch, target.triple, 0)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, ir := range []string{ll, x86DwordProductIROptimize(t, ll)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86PackedLogicalShiftRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PSLLW.Z $3, X0",
+		"PSLLL $3",
+		"PSLLQ $-129, X0",
+		"PSRLW $128, X0",
+		"PSRLL M0, X1",
+		"PSRLQ X0, M1",
+		"VPSLLW $-129, X0, X1",
+		"VPSLLD $256, X0, X1",
+		"VPSLLQ Y0, X1, X2",
+		"VPSRLW X0, 8(AX), X2",
+		"VPSRLD Y0, X1, X2",
+		"VPSRLQ.BCST X0, X1, X2",
+		"VPSLLW.BCST $3, 8(AX), X2",
+		"VPSLLD.BCST $3, X1, X2",
+		"VPSRLQ.Z $3, X1, X2",
+		"VPSLLQ $3, X1, K0, X2",
+		"VPSRLD $3, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedLogicalShiftRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PSLLQ X8, X0",
+		"PSRLQ X0, X8",
+		"VPSLLQ $3, Z8, Z1",
+		"VPSRLQ X0, Z1, Z8",
+		"VPSLLD $3, X1, K1, X2",
+		"VPSRLD.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedLogicalShiftRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedLogicalShiftRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed logical-shift forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_low_multiply.go b/amd64_lower_low_multiply.go
new file mode 100644
index 000000000..664c71fb3
--- /dev/null
+++ b/amd64_lower_low_multiply.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPackedLowMultiply(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedLowMultiplyProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	first := ins.Args[form.first]
+	if form.legacy && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed low multiply m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	bits := form.spec.laneBits
+	err = c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, bits, "pmulld",
+		func(lanes, bits int, first, second string) string {
+			product := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul <%d x i%d> %s, %s\n", product, lanes, bits, second, first)
+			return "%" + product
+		})
+	return true, false, err
+}
+
+func isAMD64MemoryOperand(op Operand) bool {
+	switch op.Kind {
+	case OpFP, OpMem:
+		return true
+	case OpSym:
+		// Go TYPE_ADDR is an address, not a TYPE_MEM read.
+		return !strings.HasPrefix(strings.TrimSpace(op.Sym), "$")
+	default:
+		return false
+	}
+}
diff --git a/amd64_lower_lzcnt_test.go b/amd64_lower_lzcnt_test.go
new file mode 100644
index 000000000..7632cfda3
--- /dev/null
+++ b/amd64_lower_lzcnt_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86LZCNTCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	symbol := "lzcntdata"
+	size := 8
+	if goarch == "386" {
+		symbol = "lzcntdata386"
+		size = 4
+	}
+	fmt.Fprintf(&source, "DATA %s+0(SB)/%d, $1\n", symbol, size)
+	fmt.Fprintf(&source, "GLOBL %s(SB), $%d\n", symbol, size)
+	source.WriteString("TEXT lzcntforms(SB),$0-0\n")
+	widths := []string{"W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	for _, width := range widths {
+		fmt.Fprintf(&source, "\tLZCNT%s AX, BX\n", width)
+		fmt.Fprintf(&source, "\tLZCNT%s 8(BX), CX\n", width)
+		fmt.Fprintf(&source, "\tLZCNT%s %s(SB), DX\n", width, symbol)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\tLZCNT%s R11, R12\n", width)
+		} else {
+			fmt.Fprintf(&source, "\tLZCNT%s AX, SP\n", width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86LZCNTCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86LZCNTCompleteFormsSource(target.goarch)
+			ll := x86ScalarCountUnboundFormatObject(t, source, "lzcntforms", target.goarch, target.triple)
+			for _, want := range []string{"@llvm.ctlz.i16", "@llvm.ctlz.i32", `"target-features"="+lzcnt"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("LZCNT lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ll, "@llvm.ctlz.i64") {
+				t.Fatalf("LZCNTQ lowering omitted llvm.ctlz.i64:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "lzcnt-"+target.name+".ll", "lzcnt-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86LZCNTRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LZCNTW AL, BX"},
+		{goarch: "amd64", instruction: "LZCNTL AX, AH"},
+		{goarch: "amd64", instruction: "LZCNTQ X0, AX"},
+		{goarch: "amd64", instruction: "LZCNTW AX, 0(BX)"},
+		{goarch: "amd64", instruction: "LZCNTL $1, AX"},
+		{goarch: "amd64", instruction: "LZCNTQ AX"},
+		{goarch: "amd64", instruction: "LZCNTW.Z AX, BX"},
+		{goarch: "386", instruction: "LZCNTL R8, AX"},
+		{goarch: "386", instruction: "LZCNTQ AX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's LZCNT yml_rl table", test.instruction)
+			}
+		})
+	}
+}
+
+// Keep the complete original failing runtime program byte-for-byte, including
+// the read after a native store and all three widths' CF/ZF observations.
+const x86LZCNTOriginalRuntimeSource = `
+TEXT lzcntsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0x1122334455660000, AX
+	MOVQ $0xaabbccddeeff1234, BX
+	LZCNTW AX, BX
+	MOVQ BX, 0(DI)
+	SETCS 8(DI)
+	SETEQ 9(DI)
+	MOVQ $0x80000000, AX
+	MOVQ $0x1122334455667788, CX
+	LZCNTL AX, CX
+	MOVQ CX, 16(DI)
+	SETCS 24(DI)
+	SETEQ 25(DI)
+	MOVQ $1, 32(DI)
+	LZCNTQ 32(DI), DX
+	MOVQ DX, 40(DI)
+	SETCS 48(DI)
+	SETEQ 49(DI)
+	RET
+`
+
+func TestAMD64LZCNTRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86LZCNTOriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"lzcntsemantics": {
+				Name:  "lzcntsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void lzcntsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[56] = {0};
+  lzcntsemantics(out);
+  if (*(uint64_t *)(out+0) != UINT64_C(0xaabbccddeeff0010)) return 10;
+  if (out[8] != 1 || out[9] != 0) return 11;
+  if (*(uint64_t *)(out+16) != 0) return 12;
+  if (out[24] != 0 || out[25] != 1) return 13;
+  if (*(uint64_t *)(out+40) != 63) return 14;
+  if (out[48] != 0 || out[49] != 0) return 15;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "lzcnt_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_lzcnt_vector_test.go b/amd64_lower_lzcnt_vector_test.go
new file mode 100644
index 000000000..b92f93cc1
--- /dev/null
+++ b/amd64_lower_lzcnt_vector_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedBitCountGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64PackedBitCountSpec{
+		"VPOPCNTB": {laneBits: 8, kind: amd64PackedPopulationCount},
+		"VPOPCNTW": {laneBits: 16, kind: amd64PackedPopulationCount},
+		"VPOPCNTD": {laneBits: 32, kind: amd64PackedPopulationCount, broadcast: true},
+		"VPOPCNTQ": {laneBits: 64, kind: amd64PackedPopulationCount, broadcast: true},
+		"VPLZCNTD": {laneBits: 32, kind: amd64PackedLeadingZeroCount, broadcast: true},
+		"VPLZCNTQ": {laneBits: 64, kind: amd64PackedLeadingZeroCount, broadcast: true},
+	}
+	if len(amd64PackedBitCountSpecs) != len(expected) {
+		t.Fatalf("packed-bit-count grammar has %d entries, want %d", len(amd64PackedBitCountSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64PackedBitCountSpecs[op]; !ok {
+			t.Errorf("packed-bit-count grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("packed-bit-count grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86PackedLeadingZeroCountCompleteGoFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			base := "R9"
+			if target.goarch == "386" {
+				base = "CX"
+			}
+			source.WriteString("TEXT packedlzcntforms(SB),$0-0\n")
+			for _, op := range []string{"VPLZCNTD", "VPLZCNTQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s0, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(%s), %s%d\n", op, base, width, last)
+					fmt.Fprintf(&source, "\t%s %s1, K1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.Z 16(%s), K7, %s%d\n", op, base, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST 24(%s), %s%d\n", op, base, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST.Z 32(%s), K2, %s%d\n", op, base, width, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"packedlzcntforms": {Name: "packedlzcntforms", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original leading-zero format invented initialized inputs", err)
+			}
+			ir = x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "LZCountEmitterOnly",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerPackedBitCount(instruction.Op, instruction)
+				})
+			for _, want := range []string{
+				"@llvm.ctlz.v4i32", "@llvm.ctlz.v8i64", "select <16 x i1>", "select <8 x i1>",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("packed-LZCNT lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-lzcnt-"+target.name+".ll", "packed-lzcnt-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedLeadingZeroCountRejectsFormsOutsideGoTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPLZCNTD X0, Y1"},
+		{goarch: "amd64", instruction: "VPLZCNTQ Y0, Z1"},
+		{goarch: "amd64", instruction: "VPLZCNTD X0, K0, X1"},
+		{goarch: "amd64", instruction: "VPLZCNTQ.Z X0, X1"},
+		{goarch: "amd64", instruction: "VPLZCNTD.BCST X0, X1"},
+		{goarch: "amd64", instruction: "VPLZCNTQ.SAE X0, X1"},
+		{goarch: "amd64", instruction: "VPLZCNTD X0, 0(AX)"},
+		{goarch: "amd64", instruction: "VPLZCNTQ AX, X1"},
+		{goarch: "amd64", instruction: "VPLZCNTD X0, K1, K2, X1"},
+		{goarch: "386", instruction: "VPLZCNTD Z8, Z0"},
+		{goarch: "386", instruction: "VPLZCNTQ Z0, K1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VPLZCNT _yvexpandpd grammar", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64PackedLeadingZeroCountRuntimeSemantics(t *testing.T) {
+	// Portable LLVM execution on the actual host, not original-Go/native AVX512.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT packedlzcntsemantics(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VPLZCNTD Z0, Z2
+	VMOVDQU64 Z2, 0(AX)
+	VPLZCNTQ 0(BX), Z2
+	VMOVDQU64 Z2, 64(AX)
+	VPLZCNTD Z0, K1, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VMOVDQU64 0(CX), Z1
+	VPLZCNTQ.Z 0(BX), K1, Z1
+	VMOVDQU64 Z1, 192(AX)
+	VPLZCNTD.BCST 0(BX), Z2
+	VMOVDQU64 Z2, 256(AX)
+	VPLZCNTQ.BCST.Z 0(BX), K1, Z1
+	VMOVDQU64 Z1, 320(AX)
+	STC
+	VPLZCNTD Z0, Z2
+	SETCS 384(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"packedlzcntsemantics": {
+			Name: "packedlzcntsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void packedlzcntsemantics(uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static unsigned lz32(uint32_t v) { unsigned n = 0; if (!v) return 32; while (!(v & UINT32_C(0x80000000))) { n++; v <<= 1; } return n; }
+static unsigned lz64(uint64_t v) { unsigned n = 0; if (!v) return 64; while (!(v & UINT64_C(0x8000000000000000))) { n++; v <<= 1; } return n; }
+int main(void) {
+  uint32_t source32[16], old32[16]; uint8_t out[385] = {0};
+  const uint64_t mask = UINT64_C(0xa55a);
+  for (int i = 0; i < 16; i++) { source32[i] = i ? (UINT32_C(1) << ((i*7)%32)) : 0; old32[i] = UINT32_C(0x90000000) + i; }
+  packedlzcntsemantics(out, (const uint8_t *)source32, (const uint8_t *)old32, mask);
+  uint32_t *plain32=(uint32_t *)(out+0), *merge32=(uint32_t *)(out+128), *broadcast32=(uint32_t *)(out+256);
+  for (int i=0;i<16;i++) {
+    if (plain32[i] != lz32(source32[i])) return 10+i;
+    uint32_t want = (mask>>i)&1 ? lz32(source32[i]) : old32[i];
+    if (merge32[i] != want) return 30+i;
+    if (broadcast32[i] != lz32(source32[0])) return 50+i;
+  }
+  uint64_t source64[8], old64[8], plain64[8], zero64[8], broadcast64[8];
+  memcpy(source64, source32, 64); memcpy(old64, old32, 64);
+  memcpy(plain64,out+64,64); memcpy(zero64,out+192,64); memcpy(broadcast64,out+320,64);
+  for (int i=0;i<8;i++) {
+    if (plain64[i] != lz64(source64[i])) return 70+i;
+    uint64_t want = (mask>>i)&1 ? lz64(source64[i]) : 0;
+    if (zero64[i] != want) return 80+i;
+		want = (mask>>i)&1 ? lz64(source64[0]) : 0;
+    if (broadcast64[i] != want) return 90+i;
+  }
+  if (out[384] != 1) return 100;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_lzcnt_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_machine_register.go b/amd64_lower_machine_register.go
new file mode 100644
index 000000000..8fef3a577
--- /dev/null
+++ b/amd64_lower_machine_register.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// lowerMachineRegisterMove covers the complete machine-state-register portion
+// of Go 1.27's x86 ymovtab: CR, DR, and TR registers plus the descriptor-state
+// aliases GDTR, IDTR, LDTR, MSW, and TASK. Segment and TLS moves are a separate
+// family.
+func (c *amd64Ctx) lowerMachineRegisterMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	if baseOp != "MOVW" && baseOp != "MOVL" && baseOp != "MOVQ" {
+		return false, false, nil
+	}
+	if len(ins.Args) != 2 {
+		return false, false, nil
+	}
+	sourceClass, sourceIndex, sourceSpecial := x86MachineRegisterOperand(ins.Args[0])
+	destinationClass, destinationIndex, destinationSpecial := x86MachineRegisterOperand(ins.Args[1])
+	if !sourceSpecial && !destinationSpecial {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s machine-register %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if sourceSpecial == destinationSpecial {
+		return true, false, fmt.Errorf("%s %s machine-register form expects exactly one special register: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	specialClass, specialIndex := sourceClass, sourceIndex
+	other := ins.Args[1]
+	readSpecial := sourceSpecial
+	if destinationSpecial {
+		specialClass, specialIndex = destinationClass, destinationIndex
+		other = ins.Args[0]
+	}
+
+	switch specialClass {
+	case "cr":
+		return true, false, c.lowerControlDebugRegisterMove(baseOp, "cr", specialIndex, other, readSpecial, ins)
+	case "dr":
+		return true, false, c.lowerControlDebugRegisterMove(baseOp, "dr", specialIndex, other, readSpecial, ins)
+	case "tr":
+		return true, false, c.lowerTestRegisterMove(baseOp, specialIndex, other, readSpecial, ins)
+	case "gdtr", "idtr", "ldtr", "msw", "task":
+		return true, false, c.lowerDescriptorRegisterAlias(baseOp, specialClass, other, readSpecial, ins)
+	default:
+		panic("machine-register classifier drift")
+	}
+}
+
+func x86MachineRegisterOperand(operand Operand) (class string, index int, ok bool) {
+	if operand.Kind != OpReg {
+		return "", 0, false
+	}
+	return x86MachineRegister(operand.Reg)
+}
+
+func x86MachineRegister(reg Reg) (class string, index int, ok bool) {
+	name := strings.ToUpper(string(reg))
+	switch name {
+	case "GDTR", "IDTR", "LDTR", "MSW", "TASK":
+		return strings.ToLower(name), 0, true
+	}
+	if len(name) < 3 {
+		return "", 0, false
+	}
+	prefix := strings.ToLower(name[:2])
+	if prefix != "cr" && prefix != "dr" && prefix != "tr" {
+		return "", 0, false
+	}
+	index, err := strconv.Atoi(name[2:])
+	if err != nil {
+		return "", 0, false
+	}
+	return prefix, index, true
+}
+
+func (c *amd64Ctx) lowerControlDebugRegisterMove(op, class string, index int, other Operand, readSpecial bool, ins Instr) error {
+	if op != "MOVL" && op != "MOVQ" {
+		return fmt.Errorf("%s %s %s register form is absent from Go 1.27's ymovtab: %q", c.goarch, op, strings.ToUpper(class), ins.Raw)
+	}
+	allowed := false
+	switch class {
+	case "cr":
+		allowed = index == 0 || index == 2 || index == 3 || index == 4 || index == 8
+		if index == 8 && c.goarch == "386" {
+			allowed = false
+		}
+	case "dr":
+		if op == "MOVL" {
+			allowed = index == 0 || index == 6 || index == 7
+		} else {
+			allowed = index == 0 || index == 2 || index == 3 || index == 6 || index == 7
+		}
+	}
+	if !allowed {
+		return fmt.Errorf("%s %s %s%d form is absent from Go 1.27's ymovtab: %q", c.goarch, op, strings.ToUpper(class), index, ins.Raw)
+	}
+	if other.Kind != OpReg || !isX86YrlRegisterForArch(other.Reg, c.goarch) {
+		return fmt.Errorf("%s %s %s%d expects a Go 1.27 Yrl GP register: %q", c.goarch, op, strings.ToUpper(class), index, ins.Raw)
+	}
+
+	special := fmt.Sprintf("%%%s%d", class, index)
+	hardwareType := I64
+	if c.goarch == "386" {
+		hardwareType = I32
+	}
+	constraints := "~{memory},~{dirflag},~{fpsr},~{flags}"
+	if readSpecial {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n",
+			call, hardwareType, "mov "+special+", $0", "=r,"+constraints)
+		value := "%" + call
+		resultType := hardwareType
+		if op == "MOVL" && hardwareType == I64 {
+			value = c.truncI64(value, I32)
+			resultType = I32
+		}
+		return c.storeRegSized(other.Reg, resultType, value)
+	}
+
+	value, err := c.loadReg(other.Reg)
+	if err != nil {
+		return err
+	}
+	if hardwareType == I32 {
+		value = c.truncI64(value, I32)
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s)\n",
+		"mov $0, "+special, "r,"+constraints, hardwareType, value)
+	return nil
+}
+
+func (c *amd64Ctx) lowerTestRegisterMove(op string, index int, other Operand, readSpecial bool, ins Instr) error {
+	if op != "MOVL" || (index != 6 && index != 7) {
+		return fmt.Errorf("%s %s TR%d form is absent from Go 1.27's ymovtab: %q", c.goarch, op, index, ins.Raw)
+	}
+	if other.Kind == OpReg {
+		if !isX86YrlRegisterForArch(other.Reg, c.goarch) {
+			return fmt.Errorf("%s MOVL TR%d operand is outside Go 1.27's Yml class: %q", c.goarch, index, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(other) {
+		return fmt.Errorf("%s MOVL TR%d expects a Go 1.27 Yml register or memory: %q", c.goarch, index, ins.Raw)
+	}
+	modRM := 0xc0 | byte(index<<3)
+	constraints := "~{memory},~{dirflag},~{fpsr},~{flags}"
+	if readSpecial {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n",
+			call, fmt.Sprintf(".byte 0x0f, 0x24, 0x%02x", modRM), "={ax},"+constraints)
+		return c.storeScalarIntegerOperand(other, I32, "%"+call)
+	}
+	value, err := c.evalIntSized(other, I32)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n",
+		fmt.Sprintf(".byte 0x0f, 0x26, 0x%02x", modRM), "{ax},"+constraints, value)
+	return nil
+}
+
+func (c *amd64Ctx) lowerDescriptorRegisterAlias(op, class string, other Operand, readSpecial bool, ins Instr) error {
+	directOp := ""
+	switch class {
+	case "gdtr":
+		if op != "MOVL" && op != "MOVQ" {
+			break
+		}
+		if readSpecial {
+			directOp = "SGDT"
+		} else {
+			directOp = "LGDT"
+		}
+	case "idtr":
+		if op != "MOVL" && op != "MOVQ" {
+			break
+		}
+		if readSpecial {
+			directOp = "SIDT"
+		} else {
+			directOp = "LIDT"
+		}
+	case "ldtr":
+		if op == "MOVW" {
+			if readSpecial {
+				directOp = "SLDTW"
+			} else {
+				directOp = "LLDT"
+			}
+		}
+	case "msw":
+		if op == "MOVW" {
+			if readSpecial {
+				directOp = "SMSWW"
+			} else {
+				directOp = "LMSW"
+			}
+		}
+	case "task":
+		if op == "MOVW" {
+			if readSpecial {
+				directOp = "STRW"
+			} else {
+				directOp = "LTR"
+			}
+		}
+	}
+	if directOp == "" {
+		return fmt.Errorf("%s %s %s form is absent from Go 1.27's ymovtab: %q", c.goarch, op, strings.ToUpper(class), ins.Raw)
+	}
+	ok, _, err := c.lowerDescriptorTable(Op(directOp), Instr{Op: Op(directOp), Args: []Operand{other}, Raw: ins.Raw})
+	if !ok {
+		panic("descriptor MOV alias lowering drift")
+	}
+	return err
+}
diff --git a/amd64_lower_maddubsw_test.go b/amd64_lower_maddubsw_test.go
new file mode 100644
index 000000000..5525325d3
--- /dev/null
+++ b/amd64_lower_maddubsw_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedUnsignedSignedByteMultiplyAddCompleteGoAssemblerForms(t *testing.T) {
+	amd64Source := `TEXT packedmaddubswforms(SB),NOSPLIT,$0-0
+	PMADDUBSW X0, X1
+	PMADDUBSW (AX), X15
+	VPMADDUBSW X0, X1, X2
+	VPMADDUBSW (AX), X1, X2
+	VPMADDUBSW Y0, Y1, Y2
+	VPMADDUBSW (AX), Y1, Y2
+	VPMADDUBSW Z0, Z1, Z2
+	VPMADDUBSW (AX), Z1, Z2
+	VPMADDUBSW X20, X21, X22
+	VPMADDUBSW Y20, Y21, Y22
+	VPMADDUBSW Z20, Z21, Z22
+	VPMADDUBSW X20, X21, K1, X22
+	VPMADDUBSW.Z (AX), X21, K2, X22
+	VPMADDUBSW Y20, Y21, K3, Y22
+	VPMADDUBSW.Z (AX), Y21, K4, Y22
+	VPMADDUBSW Z20, Z21, K5, Z22
+	VPMADDUBSW.Z (AX), Z21, K6, Z22
+	RET
+`
+	ll := x86UnboundVoidScalarFormatObject(t, amd64Source, "packedmaddubswforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "packed-maddubsw-amd64.ll", "packed-maddubsw-amd64.o", ll)
+
+	source386 := `TEXT packedmaddubswforms386(SB),NOSPLIT,$0-0
+	PMADDUBSW X0, X1
+	PMADDUBSW (AX), X7
+	VPMADDUBSW X0, X1, X2
+	VPMADDUBSW (AX), X1, X2
+	VPMADDUBSW Y0, Y1, Y2
+	VPMADDUBSW (AX), Y1, Y2
+	VPMADDUBSW Z0, Z1, Z7
+	VPMADDUBSW (AX), Z6, Z7
+	RET
+`
+	ll386 := x86UnboundVoidScalarFormatObject(t, source386, "packedmaddubswforms386", "386", "i386-unknown-linux-gnu")
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "packed-maddubsw-386.ll", "packed-maddubsw-386.o", ll386)
+}
+
+func TestTranslateX86PackedUnsignedSignedByteMultiplyAddRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PMADDUBSW.Z X0, X1",
+		"PMADDUBSW X0",
+		"PMADDUBSW M0, M1",
+		"PMADDUBSW Y0, Y1",
+		"PMADDUBSW X0, (AX)",
+		"VPMADDUBSW X0, X1",
+		"VPMADDUBSW X0, Y1, Y2",
+		"VPMADDUBSW X0, X1, (AX)",
+		"VPMADDUBSW.BCST (AX), X1, X2",
+		"VPMADDUBSW.Z X0, X1, X2",
+		"VPMADDUBSW X0, X1, K0, X2",
+		"VPMADDUBSW X0, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's PMADDUBSW/VPMADDUBSW tables", instruction)
+			}
+		})
+	}
+
+	for _, instruction := range []string{
+		"PMADDUBSW X8, X0",
+		"PMADDUBSW X0, X8",
+		"VPMADDUBSW Z8, Z1, Z2",
+		"VPMADDUBSW Z0, Z1, Z8",
+		"VPMADDUBSW X0, X1, K1, X2",
+		"VPMADDUBSW.Z X0, X1, K1, X2",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT bad386(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			return
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs:         map[string]FuncSig{"bad386": {Name: "bad386", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("386 Translate accepted architecture-restricted %q", instruction)
+		}
+	}
+}
diff --git a/amd64_lower_maddword.go b/amd64_lower_maddword.go
new file mode 100644
index 000000000..bd3175b9a
--- /dev/null
+++ b/amd64_lower_maddword.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import "fmt"
+
+// Both Go packed multiply-add families share the same ordered operand,
+// memory and write-generation contract.
+func (c *amd64Ctx) lowerPackedWordMultiplyAdd(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedPhysical(op, ins, x86PackedMultiplyAdd)
+}
+
+func (c *amd64Ctx) emitPackedWordMultiplyAdd(wordLanes int, first, second string) string {
+	wordType := fmt.Sprintf("<%d x i16>", wordLanes)
+	wideType := fmt.Sprintf("<%d x i32>", wordLanes)
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	products := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", firstWide, wordType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", secondWide, wordType, second, wideType)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", products, wideType, firstWide, secondWide)
+	resultLanes := wordLanes / 2
+	result := "zeroinitializer"
+	for lane := 0; lane < resultLanes; lane++ {
+		low := c.newTmp()
+		high := c.newTmp()
+		sum := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", low, wideType, products, lane*2)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", high, wideType, products, lane*2+1)
+		fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %%%s\n", sum, low, high)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i32> %s, i32 %%%s, i32 %d\n", inserted, resultLanes, result, sum, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitPackedUnsignedSignedByteMultiplyAdd(byteLanes int, signedBytes, unsignedBytes string) string {
+	byteType := fmt.Sprintf("<%d x i8>", byteLanes)
+	wideType := fmt.Sprintf("<%d x i32>", byteLanes)
+	signedWide := c.newTmp()
+	unsignedWide := c.newTmp()
+	products := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", signedWide, byteType, signedBytes, wideType)
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", unsignedWide, byteType, unsignedBytes, wideType)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", products, wideType, signedWide, unsignedWide)
+	resultLanes := byteLanes / 2
+	result := "zeroinitializer"
+	for lane := 0; lane < resultLanes; lane++ {
+		low := c.newTmp()
+		high := c.newTmp()
+		sum := c.newTmp()
+		below := c.newTmp()
+		lowerClamped := c.newTmp()
+		above := c.newTmp()
+		clamped := c.newTmp()
+		narrow := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", low, wideType, products, lane*2)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", high, wideType, products, lane*2+1)
+		fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %%%s\n", sum, low, high)
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %%%s, -32768\n", below, sum)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 -32768, i32 %%%s\n", lowerClamped, below, sum)
+		fmt.Fprintf(c.b, "  %%%s = icmp sgt i32 %%%s, 32767\n", above, lowerClamped)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 32767, i32 %%%s\n", clamped, above, lowerClamped)
+		fmt.Fprintf(c.b, "  %%%s = trunc i32 %%%s to i16\n", narrow, clamped)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i16> %s, i16 %%%s, i32 %d\n", inserted, resultLanes, result, narrow, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_mask_arithmetic.go b/amd64_lower_mask_arithmetic.go
new file mode 100644
index 000000000..f37af5e7c
--- /dev/null
+++ b/amd64_lower_mask_arithmetic.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "fmt"
+
+type amd64MaskArithmeticSpec struct {
+	bits  int
+	shift string
+}
+
+// amd64MaskArithmeticSpecs covers Go 1.27's complete KADD and KSHIFT
+// families. KADD wraps at the named mask width; KSHIFT produces zero when the
+// unsigned byte count is greater than or equal to that width.
+var amd64MaskArithmeticSpecs = map[Op]amd64MaskArithmeticSpec{
+	"KADDB": {bits: 8}, "KADDW": {bits: 16}, "KADDD": {bits: 32}, "KADDQ": {bits: 64},
+	"KSHIFTLB": {bits: 8, shift: "shl"}, "KSHIFTLW": {bits: 16, shift: "shl"},
+	"KSHIFTLD": {bits: 32, shift: "shl"}, "KSHIFTLQ": {bits: 64, shift: "shl"},
+	"KSHIFTRB": {bits: 8, shift: "lshr"}, "KSHIFTRW": {bits: 16, shift: "lshr"},
+	"KSHIFTRD": {bits: 32, shift: "lshr"}, "KSHIFTRQ": {bits: 64, shift: "lshr"},
+}
+
+func (c *amd64Ctx) lowerMaskArithmetic(op Op, ins Instr) error {
+	form, known, err := x86MaskValueProperties(op, ins, c.goarch)
+	if err != nil {
+		return err
+	}
+	if !known || form.unpack {
+		return fmt.Errorf("%s unknown mask-arithmetic opcode %q", c.goarch, op)
+	}
+	spec := form.spec
+	if spec.shift == "" {
+		first, err := c.loadK(ins.Args[0].Reg)
+		if err != nil {
+			return err
+		}
+		second, err := c.loadK(ins.Args[1].Reg)
+		if err != nil {
+			return err
+		}
+		first = c.maskMoveI64(first, spec.bits)
+		second = c.maskMoveI64(second, spec.bits)
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", added, first, second)
+		return c.storeK(ins.Args[2].Reg, c.maskMoveI64("%"+added, spec.bits))
+	}
+
+	source, err := c.loadK(ins.Args[1].Reg)
+	if err != nil {
+		return err
+	}
+	source = c.maskMoveI64(source, spec.bits)
+	result := "0"
+	count := int(uint8(ins.Args[0].Imm))
+	if count < spec.bits {
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %d\n", shifted, spec.shift, source, count)
+		result = c.maskMoveI64("%"+shifted, spec.bits)
+	}
+	return c.storeK(ins.Args[2].Reg, result)
+}
diff --git a/amd64_lower_mask_arithmetic_test.go b/amd64_lower_mask_arithmetic_test.go
new file mode 100644
index 000000000..e973e4764
--- /dev/null
+++ b/amd64_lower_mask_arithmetic_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86MaskArithmeticCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT maskArithmeticForms(SB),$0-0\n")
+			for _, width := range []string{"B", "W", "D", "Q"} {
+				fmt.Fprintf(&source, "\tKADD%s K0, K7, K3\n", width)
+				fmt.Fprintf(&source, "\tKSHIFTL%s $0, K3, K4\n", width)
+				fmt.Fprintf(&source, "\tKSHIFTR%s $255, K4, K7\n", width)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			original, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{TargetTriple: target.triple, Goarch: target.goarch,
+				Sigs: map[string]FuncSig{"maskArithmeticForms": {Name: "maskArithmeticForms", Ret: Void}}}
+			if ir, err := Translate(original, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original format-only source invented mask inputs", err)
+			}
+			// Preserve every original row and separately supply actual source
+			// definitions. This is a complete initialized object counterpart.
+			initialized := strings.Replace(source.String(), "\n", "\nMOVL $7,AX\nKMOVD AX,K0\nKMOVD AX,K7\n", 1)
+			requireX86GoAssemblerResult(t, target.goarch, initialized, true)
+			file, err := Parse(ArchAMD64, initialized)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"maskArithmeticForms": {Name: "maskArithmeticForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "mask-arithmetic-"+target.name+".ll", "mask-arithmetic-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86MaskArithmeticRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"KADDB K1, K2",
+		"KADDW K1, AX, K2",
+		"KADDD K1, K2, K8",
+		"KADDQ.Z K1, K2, K3",
+		"KSHIFTLB K1, K2",
+		"KSHIFTLW $-1, K1, K2",
+		"KSHIFTLD $1, AX, K2",
+		"KSHIFTRQ $1, K1, K8",
+		"KSHIFTRB.Z $1, K1, K2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			for _, goarch := range []string{"amd64", "386"} {
+				source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, goarch, source, false)
+				assertX86MaskArithmeticRejected(t, goarch, instruction)
+			}
+		})
+	}
+}
+
+func assertX86MaskArithmeticRejected(t *testing.T, goarch, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if goarch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %s %q outside Go 1.27's KADD/KSHIFT tables", goarch, instruction)
+	}
+}
+
+func TestAMD64MaskArithmeticRuntimeSemantics(t *testing.T) {
+	// Portable LLVM integer execution, not original-Go/native opmask execution.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT maskArithmetic(SB),$0-24
+	MOVQ out+0(FP), AX
+	KMOVQ a+8(FP), K1
+	KMOVQ b+16(FP), K2
+	KADDB K1, K2, K3
+	KADDW K1, K2, K4
+	KSHIFTLW $3, K1, K5
+	KSHIFTRW $4, K2, K6
+	KSHIFTRB $9, K2, K7
+	KMOVQ K3, 0(AX)
+	KMOVQ K4, 8(AX)
+	KMOVQ K5, 16(AX)
+	KMOVQ K6, 24(AX)
+	KMOVQ K7, 32(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: I64, Index: 1, Field: -1},
+		{Offset: 16, Type: I64, Index: 2, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"maskArithmetic": {Name: "maskArithmetic", Args: []LLVMType{Ptr, I64, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void maskArithmetic(uint64_t *, uint64_t, uint64_t);
+int main(void) {
+  uint64_t out[5] = {0};
+  uint64_t a = 0x123456789abcdef5ULL;
+  uint64_t b = 0xfedcba98765432f0ULL;
+  maskArithmetic(out, a, b);
+  if (out[0] != ((a + b) & 0xff)) return 1;
+  if (out[1] != ((a + b) & 0xffff)) return 2;
+  if (out[2] != ((a & 0xffff) << 3 & 0xffff)) return 3;
+  if (out[3] != ((b & 0xffff) >> 4)) return 4;
+  if (out[4] != 0) return 5;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mask_arithmetic", triple, ll, mainC, nil)
+}
diff --git a/amd64_lower_mask_logical.go b/amd64_lower_mask_logical.go
new file mode 100644
index 000000000..4ad903463
--- /dev/null
+++ b/amd64_lower_mask_logical.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import "fmt"
+
+type amd64MaskLogicalKind uint8
+
+const (
+	amd64MaskAnd amd64MaskLogicalKind = iota
+	amd64MaskAndNot
+	amd64MaskOr
+	amd64MaskXNOR
+	amd64MaskXOR
+	amd64MaskNot
+	amd64MaskTest
+	amd64MaskOrTest
+)
+
+type amd64MaskLogicalSpec struct {
+	kind amd64MaskLogicalKind
+	bits int
+}
+
+// amd64MaskLogicalSpecs is the complete Go 1.27 x86 mask-register logical
+// family. Binary forms use _ykaddb (K,K,K); unary and flag-setting forms use
+// _yknotb (K,K). Go accepts every listed form in both amd64 and 386 mode.
+var amd64MaskLogicalSpecs = map[Op]amd64MaskLogicalSpec{
+	"KANDB": {amd64MaskAnd, 8}, "KANDW": {amd64MaskAnd, 16}, "KANDD": {amd64MaskAnd, 32}, "KANDQ": {amd64MaskAnd, 64},
+	"KANDNB": {amd64MaskAndNot, 8}, "KANDNW": {amd64MaskAndNot, 16}, "KANDND": {amd64MaskAndNot, 32}, "KANDNQ": {amd64MaskAndNot, 64},
+	"KORB": {amd64MaskOr, 8}, "KORW": {amd64MaskOr, 16}, "KORD": {amd64MaskOr, 32}, "KORQ": {amd64MaskOr, 64},
+	"KXNORB": {amd64MaskXNOR, 8}, "KXNORW": {amd64MaskXNOR, 16}, "KXNORD": {amd64MaskXNOR, 32}, "KXNORQ": {amd64MaskXNOR, 64},
+	"KXORB": {amd64MaskXOR, 8}, "KXORW": {amd64MaskXOR, 16}, "KXORD": {amd64MaskXOR, 32}, "KXORQ": {amd64MaskXOR, 64},
+	"KNOTB": {amd64MaskNot, 8}, "KNOTW": {amd64MaskNot, 16}, "KNOTD": {amd64MaskNot, 32}, "KNOTQ": {amd64MaskNot, 64},
+	"KTESTB": {amd64MaskTest, 8}, "KTESTW": {amd64MaskTest, 16}, "KTESTD": {amd64MaskTest, 32}, "KTESTQ": {amd64MaskTest, 64},
+	"KORTESTB": {amd64MaskOrTest, 8}, "KORTESTW": {amd64MaskOrTest, 16}, "KORTESTD": {amd64MaskOrTest, 32}, "KORTESTQ": {amd64MaskOrTest, 64},
+}
+
+func (c *amd64Ctx) lowerMaskLogical(op Op, ins Instr) error {
+	spec, known, err := x86MaskLogicalProperties(op, ins, c.goarch)
+	if err != nil {
+		return err
+	}
+	if !known {
+		return fmt.Errorf("%s unknown mask logical opcode %q", c.goarch, op)
+	}
+
+	load := func(arg Operand) (string, error) {
+		value, err := c.loadK(arg.Reg)
+		if err != nil {
+			return "", err
+		}
+		if spec.bits == 64 {
+			return value, nil
+		}
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, value, amd64MaskWidthLiteral(spec.bits))
+		return "%" + masked, nil
+	}
+
+	first, err := load(ins.Args[0])
+	if err != nil {
+		return err
+	}
+	var second string
+	if spec.kind != amd64MaskNot {
+		second, err = load(ins.Args[1])
+		if err != nil {
+			return err
+		}
+	}
+	if spec.writesFlags() {
+		return c.lowerMaskLogicalFlags(spec, first, second)
+	}
+
+	var result string
+	switch spec.kind {
+	case amd64MaskNot:
+		not := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", not, first, amd64MaskWidthLiteral(spec.bits))
+		result = "%" + not
+	case amd64MaskAnd, amd64MaskOr, amd64MaskXOR, amd64MaskXNOR, amd64MaskAndNot:
+		operation := "and"
+		lhs, rhs := first, second
+		switch spec.kind {
+		case amd64MaskOr:
+			operation = "or"
+		case amd64MaskXOR, amd64MaskXNOR:
+			operation = "xor"
+		case amd64MaskAndNot:
+			// Go's first source is the r/m operand and its second source is
+			// VEX.vvvv, so KANDN computes first & ~second.
+			notSecond := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", notSecond, second, amd64MaskWidthLiteral(spec.bits))
+			rhs = "%" + notSecond
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %s\n", combined, operation, lhs, rhs)
+		result = "%" + combined
+		if spec.kind == amd64MaskXNOR {
+			not := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", not, result, amd64MaskWidthLiteral(spec.bits))
+			result = "%" + not
+		}
+	default:
+		return fmt.Errorf("amd64 %s has unknown mask logical operation", op)
+	}
+	if spec.bits != 64 {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, result, amd64MaskWidthLiteral(spec.bits))
+		result = "%" + masked
+	}
+	return c.storeK(ins.Args[spec.argumentCount()-1].Reg, result)
+}
+
+func (c *amd64Ctx) lowerMaskLogicalFlags(spec amd64MaskLogicalSpec, first, second string) error {
+	operation := "and"
+	if spec.kind == amd64MaskOrTest {
+		operation = "or"
+	}
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %s\n", combined, operation, first, second)
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, 0\n", zero, combined)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+
+	carry := c.newTmp()
+	if spec.kind == amd64MaskTest {
+		notSecond := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", notSecond, second, amd64MaskWidthLiteral(spec.bits))
+		andNot := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %%%s\n", andNot, first, notSecond)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, 0\n", carry, andNot)
+	} else {
+		// KORTEST observes the same OR result for both flags: zero for ZF,
+		// all width-selected bits set for CF. KTEST's AND-NOT stays separate.
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, %s\n", carry, combined, amd64MaskWidthLiteral(spec.bits))
+	}
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+	c.clearX86StatusFlags(x86StatusAll &^ (x86StatusCF | x86StatusZF))
+	return nil
+}
+
+func amd64MaskWidthLiteral(bits int) string {
+	if bits == 64 {
+		return "-1"
+	}
+	return fmt.Sprintf("%d", uint64(1)<<bits-1)
+}
diff --git a/amd64_lower_mask_move.go b/amd64_lower_mask_move.go
new file mode 100644
index 000000000..17a662dd7
--- /dev/null
+++ b/amd64_lower_mask_move.go
@@ -0,0 +1,226 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// amd64MaskMoveSpecs is the complete Go 1.27 x86 mask-register move family.
+// All four instructions share _ykmovb and its K->memory, K->GP,
+// K-or-memory->K, and GP->K rows. Go accepts these rows in amd64 and 386 mode.
+var amd64MaskMoveSpecs = map[Op]int{
+	"KMOVB": 8,
+	"KMOVW": 16,
+	"KMOVD": 32,
+	"KMOVQ": 64,
+}
+
+type x86MaskMoveOperandKind uint8
+
+const (
+	x86MaskMoveK x86MaskMoveOperandKind = iota
+	x86MaskMoveGP
+	x86MaskMoveMemory
+)
+
+type x86MaskMoveForm struct {
+	bits                int
+	source, destination x86MaskMoveOperandKind
+}
+
+// Only a GP operand binds the mode-effective word width: VEX.W is ignored
+// for GP transfers in mode32. K/K and K/memory keep the original native width.
+func x86MaskMoveProperties(op Op, ins Instr, arch string) (x86MaskMoveForm, bool, error) {
+	bits, known := amd64MaskMoveSpecs[op]
+	form := x86MaskMoveForm{bits: bits}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86MaskMoveForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands are outside Go's _ykmovb table: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 {
+		return fail()
+	}
+	kind := func(operand Operand) (x86MaskMoveOperandKind, bool) {
+		switch {
+		case amd64IsKOperand(operand):
+			return x86MaskMoveK, true
+		case amd64IsYrlOperand(operand, arch):
+			return x86MaskMoveGP, true
+		case isAMD64MemoryOperand(operand):
+			return x86MaskMoveMemory, true
+		}
+		return 0, false
+	}
+	var sourceOK, destinationOK bool
+	form.source, sourceOK = kind(ins.Args[0])
+	form.destination, destinationOK = kind(ins.Args[1])
+	if !sourceOK || !destinationOK || form.source != x86MaskMoveK && form.destination != x86MaskMoveK {
+		return fail()
+	}
+	if form.source == x86MaskMoveGP || form.destination == x86MaskMoveGP {
+		if word := int(x86ResultPointerWord(arch) * 8); form.bits > word {
+			form.bits = word
+		}
+	}
+	return form, true, nil
+}
+
+func (c *amd64Ctx) lowerMaskMove(op Op, ins Instr) error {
+	if ins.Op != "" && Op(strings.ToUpper(string(ins.Op))) != op {
+		return fmt.Errorf("amd64 mask-move dispatch %q disagrees with instruction %q", op, ins.Op)
+	}
+	// The internal dispatcher owns the opcode argument, including for helper
+	// callers without Instr.Op. Bind a local copy before the shared validator;
+	// source/caller proofs still require their original complete instruction.
+	ins.Op = op
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86MaskMoveProperties(op, ins, arch)
+	if !known {
+		return fmt.Errorf("amd64 unknown mask-move opcode %q", op)
+	}
+	if err != nil {
+		return err
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	value, err := c.loadMaskMoveValue(src, form.bits, form.source == x86MaskMoveK)
+	if err != nil {
+		return err
+	}
+	switch form.destination {
+	case x86MaskMoveK:
+		return c.storeK(dst.Reg, value)
+	case x86MaskMoveGP:
+		// The GP-destination encodings zero-extend B/W/D results. Store the
+		// already-masked value as the complete modeled register value.
+		base, _ := amd64FullRegBase(dst.Reg)
+		return c.storeReg(base, value)
+	case x86MaskMoveMemory:
+		return c.storeMaskMoveMemory(dst, form.bits, value)
+	default:
+		return fmt.Errorf("amd64 %s has unsupported destination: %q", op, ins.Raw)
+	}
+}
+
+func amd64MaskMoveOperandsValid(ins Instr, goarch string) bool {
+	_, known, err := x86MaskMoveProperties(ins.Op, ins, goarch)
+	return known && err == nil
+}
+
+func x86TypedMaskMoveByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86MaskMoveProperties(op, ins, arch)
+	if !known {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	width := int64(form.bits / 8)
+	first, last := ins.Args[0], ins.Args[1]
+	writeWidth := width
+	if form.destination == x86MaskMoveGP && writeWidth < x86ResultPointerWord(arch) {
+		writeWidth = x86ResultPointerWord(arch) // GP B/W/D writes zero-extend; memory stays exact-width.
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: first, width: width, read: true},
+		{index: 1, operand: last, width: writeWidth, write: true},
+	}}, true, nil
+}
+
+func amd64IsKOperand(operand Operand) bool {
+	if operand.Kind != OpReg {
+		return false
+	}
+	_, ok := amd64ParseKReg(operand.Reg)
+	return ok
+}
+
+func amd64IsYrlOperand(operand Operand, goarch string) bool {
+	return operand.Kind == OpReg && isX86YrlRegisterForArch(operand.Reg, goarch)
+}
+
+func (c *amd64Ctx) loadMaskMoveValue(src Operand, bits int, sourceIsK bool) (string, error) {
+	if sourceIsK {
+		value, err := c.loadK(src.Reg)
+		if err != nil {
+			return "", err
+		}
+		return c.maskMoveI64(value, bits), nil
+	}
+
+	typ := amd64IntegerTypeForBits(bits)
+	var value string
+	var err error
+	if src.Kind == OpFP && c.fpScalarSource.x86SourceStack == nil && c.fpScalarSource.x86FixedLocal == nil {
+		// A mask memory width is not its first logical field's type. Gather
+		// precisely those bytes, including interior and cross-field reads.
+		value, err = c.loadScalarLaneFPBits(src.FPOffset, bits)
+	} else if src.Kind == OpMem || src.Kind == OpSym {
+		pointer, pointerType, _, pointerErr := c.packedVectorMemoryPointer(src)
+		if pointerErr != nil {
+			return "", pointerErr
+		}
+		temporary := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", temporary, typ, pointerType, pointer)
+		value = "%" + temporary
+	} else {
+		value, err = c.evalIntSized(src, typ)
+	}
+	if err != nil {
+		return "", err
+	}
+	if bits == 64 {
+		return value, nil
+	}
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", extended, typ, value)
+	return "%" + extended, nil
+}
+
+func (c *amd64Ctx) maskMoveI64(value string, bits int) string {
+	if bits == 64 {
+		return value
+	}
+	masked := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, value, amd64MaskWidthLiteral(bits))
+	return "%" + masked
+}
+
+func (c *amd64Ctx) storeMaskMoveMemory(dst Operand, bits int, value string) error {
+	typ := amd64IntegerTypeForBits(bits)
+	stored := value
+	if bits != 64 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", truncated, value, typ)
+		stored = "%" + truncated
+	}
+	switch dst.Kind {
+	case OpFP:
+		if c.fpScalarSource.x86SourceStack == nil && c.fpScalarSource.x86FixedLocal == nil {
+			// Scatter only the native write width; a B/W/D store must retain
+			// the initialized remainder of a larger logical result field.
+			return c.storeScalarLaneFPBits(dst.FPOffset, bits, stored)
+		}
+		return c.storeFPResult(dst.FPOffset, typ, stored)
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, stored, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, ptr %s, align 1\n", typ, stored, ptr)
+		return nil
+	default:
+		return fmt.Errorf("amd64 mask move expected a memory destination, got %s", dst.String())
+	}
+}
diff --git a/amd64_lower_mask_to_vector.go b/amd64_lower_mask_to_vector.go
new file mode 100644
index 000000000..850c7fec8
--- /dev/null
+++ b/amd64_lower_mask_to_vector.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerMaskVectorMove(op Op, ins Instr) (bool, bool, error) {
+	if ins.Op == "" {
+		ins.Op = op
+	}
+	form, recognized, err := x86MaskVectorProperties(ins, c.goarch)
+	if err != nil || !recognized {
+		return recognized, false, err
+	}
+	if !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("mask/vector dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	vectorOperand, maskOperand := ins.Args[form.vector], ins.Args[form.mask]
+	lanes := form.byteWidth * 8 / form.spec.laneBits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, form.spec.laneBits)
+	if !form.spec.maskToVector {
+		bytes, err := c.loadPackedCompareBytes(vectorOperand, form.byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		vector := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", vector, form.byteWidth, bytes, vectorType)
+		signBits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, zeroinitializer\n", signBits, vectorType, vector)
+		packedType := fmt.Sprintf("i%d", lanes)
+		packed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %%%s to %s\n", packed, lanes, signBits, packedType)
+		result := "%" + packed
+		if lanes < 64 {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, packedType, result)
+			result = "%" + wide
+		}
+		return true, false, c.storeK(maskOperand.Reg, result)
+	}
+
+	mask, err := c.loadK(maskOperand.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	vector := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", shifted, mask, lane)
+		bit := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i1\n", bit, shifted)
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d -1, i%d 0\n", element, bit, form.spec.laneBits, form.spec.laneBits)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n", inserted, vectorType, vector, form.spec.laneBits, element, lane)
+		vector = "%" + inserted
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, vectorType, vector, form.byteWidth)
+	// All widths are EVEX writes. Legacy storeX would preserve wider aliases
+	// and contradict the caller's complete defined-byte effect.
+	return true, false, c.storePackedMoveOperand(vectorOperand, form.byteWidth, "%"+bytes)
+}
diff --git a/amd64_lower_mask_to_vector_test.go b/amd64_lower_mask_to_vector_test.go
new file mode 100644
index 000000000..5317487b9
--- /dev/null
+++ b/amd64_lower_mask_to_vector_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86MaskToVectorMoveCompleteForms(t *testing.T) {
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT maskvectorforms(SB),$0-0\n")
+			index := 0
+			for _, lane := range []string{"B", "W", "D", "Q"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					vector := index%7 + 1
+					mask := index % 8
+					fmt.Fprintf(&source, "\tVPMOVM2%s K%d, %s%d\n", lane, mask, width, vector)
+					fmt.Fprintf(&source, "\tVPMOV%s2M %s%d, K%d\n", lane, width, vector, mask)
+					index++
+				}
+			}
+			source.WriteString("\tRET\n")
+			x86UnboundVoidScalarFormatObject(t, source.String(), "maskvectorforms", target.goarch, target.triple)
+		})
+	}
+}
+
+func TestTranslateX86MaskVectorMoveRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMOVM2B X0, X1",
+		"VPMOVM2W K0, 0(AX)",
+		"VPMOVM2D.Z K0, Z1",
+		"VPMOVM2Q K8, Z1",
+		"VPMOVB2M K0, K1",
+		"VPMOVW2M 0(AX), K1",
+		"VPMOVD2M.Z Z0, K1",
+		"VPMOVQ2M Z0, K8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			for _, goarch := range []string{"amd64", "386"} {
+				source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, goarch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					continue
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if goarch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{Goarch: goarch, TargetTriple: triple, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+					t.Fatalf("Translate accepted %s %q outside Go 1.27's mask/vector move table", goarch, instruction)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64MaskVectorMoveRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT maskVectorMoves(SB),NOSPLIT,$0-16
+	MOVQ out+0(FP), AX
+	KMOVQ mask+8(FP), K1
+	VPMOVM2B K1, Z0
+	VPMOVB2M Z0, K2
+	KMOVQ K2, 0(AX)
+	VPMOVM2W K1, Z1
+	VPMOVW2M Z1, K3
+	KMOVQ K3, 8(AX)
+	VPMOVM2D K1, Z2
+	VPMOVD2M Z2, K4
+	KMOVQ K4, 16(AX)
+	VPMOVM2Q K1, Z3
+	VPMOVQ2M Z3, K5
+	KMOVQ K5, 24(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: I64, Index: 1, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"maskVectorMoves": {Name: "maskVectorMoves", Args: []LLVMType{Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void maskVectorMoves(uint64_t *, uint64_t);
+int main(void) {
+  uint64_t out[4] = {0};
+  uint64_t mask = 0xd6a539c7f04b821dULL;
+  maskVectorMoves(out, mask);
+  if (out[0] != mask) return 1;
+  if (out[1] != (mask & 0xffffffffULL)) return 2;
+  if (out[2] != (mask & 0xffffULL)) return 3;
+  if (out[3] != (mask & 0xffULL)) return 4;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mask_vector_moves", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_mask_unpack.go b/amd64_lower_mask_unpack.go
new file mode 100644
index 000000000..18e69ec44
--- /dev/null
+++ b/amd64_lower_mask_unpack.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import "fmt"
+
+// amd64MaskUnpackBits covers Go 1.27's complete KUNPCK family. The Plan 9
+// first source is the encoded r/m operand and becomes the low half; the second
+// source is VEX.vvvv and becomes the high half of the destination mask.
+var amd64MaskUnpackBits = map[Op]int{
+	"KUNPCKBW": 8,
+	"KUNPCKWD": 16,
+	"KUNPCKDQ": 32,
+}
+
+func (c *amd64Ctx) lowerMaskUnpack(op Op, ins Instr) error {
+	form, known, err := x86MaskValueProperties(op, ins, c.goarch)
+	if err != nil {
+		return err
+	}
+	if !known || !form.unpack {
+		return fmt.Errorf("%s unknown mask-unpack opcode %q", c.goarch, op)
+	}
+	bits := form.spec.bits
+
+	low, err := c.loadK(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	high, err := c.loadK(ins.Args[1].Reg)
+	if err != nil {
+		return err
+	}
+	low = c.maskMoveI64(low, bits)
+	high = c.maskMoveI64(high, bits)
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", shifted, high, bits)
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", combined, shifted, low)
+	result := "%" + combined
+	if bits < 32 {
+		result = c.maskMoveI64(result, bits*2)
+	}
+	return c.storeK(ins.Args[2].Reg, result)
+}
diff --git a/amd64_lower_mask_unpack_test.go b/amd64_lower_mask_unpack_test.go
new file mode 100644
index 000000000..6012a8b24
--- /dev/null
+++ b/amd64_lower_mask_unpack_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86MaskUnpackCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = `TEXT maskunpackforms(SB),$0-0
+	KUNPCKBW K0, K7, K3
+	KUNPCKBW K2, K4, K4
+	KUNPCKWD K7, K5, K3
+	KUNPCKDQ K1, K6, K0
+	KUNPCKDQ K5, K5, K5
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			original, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"maskunpackforms": {Name: "maskunpackforms", Ret: Void}}}
+			if ir, err := Translate(original, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original format-only source invented mask inputs", err)
+			}
+			var definitions strings.Builder
+			definitions.WriteString("\nMOVL $7,AX\n")
+			for index := 0; index < 8; index++ {
+				fmt.Fprintf(&definitions, "KMOVD AX,K%d\n", index)
+			}
+			initialized := strings.Replace(source, "\n", definitions.String(), 1)
+			requireX86GoAssemblerResult(t, target.goarch, initialized, true)
+			file, err := Parse(ArchAMD64, initialized)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"maskunpackforms": {Name: "maskunpackforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"shl i64", "or i64", "255", "65535", "4294967295"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("mask unpack lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "mask-unpack-"+target.name+".ll", "mask-unpack-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86MaskUnpackRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"KUNPCKBW K1, K2",
+		"KUNPCKWD K1, K2, K3, K4",
+		"KUNPCKDQ AX, K2, K3",
+		"KUNPCKBW K1, K8, K3",
+		"KUNPCKWD K1, K2, K8",
+		"KUNPCKDQ.Z K1, K2, K3",
+	} {
+		for _, goarch := range []string{"amd64", "386"} {
+			t.Run(goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(instruction), func(t *testing.T) {
+				source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, goarch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if goarch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{
+					Goarch:       goarch,
+					TargetTriple: triple,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q outside Go 1.27's KUNPCK table for %s", instruction, goarch)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64MaskUnpackRuntimeSemantics(t *testing.T) {
+	// Portable LLVM integer execution, not original-Go/native opmask execution.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT maskunpacksemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	KMOVQ a+8(FP), K1
+	KMOVQ b+16(FP), K2
+	STC
+	KUNPCKBW K1, K2, K3
+	KMOVQ K3, 0(AX)
+	SETCS 24(AX)
+	KUNPCKWD K1, K2, K4
+	KMOVQ K4, 8(AX)
+	KUNPCKDQ K1, K2, K2
+	KMOVQ K2, 16(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"maskunpacksemantics": {
+				Name: "maskunpacksemantics", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void maskunpacksemantics(uint8_t *, uint64_t, uint64_t);
+int main(void) {
+  uint8_t storage[25] = {0};
+  uint64_t *out = (uint64_t *)storage;
+  uint64_t a = UINT64_C(0x0123456789abcdef);
+  uint64_t b = UINT64_C(0xfedcba9876543210);
+  maskunpacksemantics(storage, a, b);
+  if (out[0] != ((b & 0xff) << 8 | (a & 0xff))) return 10;
+  if (out[1] != ((b & 0xffff) << 16 | (a & 0xffff))) return 11;
+  if (out[2] != ((b & UINT64_C(0xffffffff)) << 32 | (a & UINT64_C(0xffffffff)))) return 12;
+  if (storage[24] != 1) return 13;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mask_unpack_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_minmax.go b/amd64_lower_minmax.go
new file mode 100644
index 000000000..7756475c2
--- /dev/null
+++ b/amd64_lower_minmax.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedIntegerMinMaxSpec struct {
+	laneBits  int
+	signed    bool
+	minimum   bool
+	broadcast bool
+	mapNumber int
+	opcode    int
+}
+
+// The twelve legacy and sixteen VEX/EVEX members share typed operand and
+// numerical rules. Legacy retains its RMW/upper aliases and original m128
+// opcode; only VEX/EVEX D/Q has scalar-memory broadcast.
+func (c *amd64Ctx) lowerPackedIntegerMinMax(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86IntegerMinMaxProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	first := ins.Args[form.first]
+	if form.legacy && form.memory >= 0 &&
+		(first.Kind == OpFP || first.Kind == OpMem && !c.nativeMemoryOperand(ins, form.first) ||
+			!x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple)) {
+		return true, false, fmt.Errorf("%w: legacy integer min/max m128 needs its original native storage/target", ErrProbeNeedsContext)
+	}
+	spec := form.spec
+	predicate := "ult"
+	if spec.signed {
+		predicate = "slt"
+	}
+	if !spec.minimum {
+		predicate = strings.Replace(predicate, "lt", "gt", 1)
+	}
+	legacyMnemonic := ""
+	if form.legacy && form.memory >= 0 {
+		legacyMnemonic = strings.ToLower(string(op))
+	}
+	err = c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, spec.laneBits, legacyMnemonic,
+		func(lanes, bits int, first, second string) string {
+			compared, computed := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", compared, predicate, lanes, bits, second, first)
+			fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %s, <%d x i%d> %s\n", computed, lanes, compared, lanes, bits, second, lanes, bits, first)
+			return "%" + computed
+		})
+	return true, false, err
+}
+
+var amd64PackedIntegerMinMaxSpecs = map[string]amd64PackedIntegerMinMaxSpec{
+	"VPMINSB": {laneBits: 8, signed: true, minimum: true, mapNumber: 2, opcode: 0x38},
+	"VPMINUB": {laneBits: 8, minimum: true, mapNumber: 1, opcode: 0xda},
+	"VPMAXSB": {laneBits: 8, signed: true, mapNumber: 2, opcode: 0x3c},
+	"VPMAXUB": {laneBits: 8, mapNumber: 1, opcode: 0xde},
+	"VPMINSW": {laneBits: 16, signed: true, minimum: true, mapNumber: 1, opcode: 0xea},
+	"VPMINUW": {laneBits: 16, minimum: true, mapNumber: 2, opcode: 0x3a},
+	"VPMAXSW": {laneBits: 16, signed: true, mapNumber: 1, opcode: 0xee},
+	"VPMAXUW": {laneBits: 16, mapNumber: 2, opcode: 0x3e},
+
+	"VPMINSD": {laneBits: 32, signed: true, minimum: true, broadcast: true, mapNumber: 2, opcode: 0x39},
+	"VPMINUD": {laneBits: 32, minimum: true, broadcast: true, mapNumber: 2, opcode: 0x3b},
+	"VPMAXSD": {laneBits: 32, signed: true, broadcast: true, mapNumber: 2, opcode: 0x3d},
+	"VPMAXUD": {laneBits: 32, broadcast: true, mapNumber: 2, opcode: 0x3f},
+	"VPMINSQ": {laneBits: 64, signed: true, minimum: true, broadcast: true, mapNumber: 2, opcode: 0x39},
+	"VPMINUQ": {laneBits: 64, minimum: true, broadcast: true, mapNumber: 2, opcode: 0x3b},
+	"VPMAXSQ": {laneBits: 64, signed: true, broadcast: true, mapNumber: 2, opcode: 0x3d},
+	"VPMAXUQ": {laneBits: 64, broadcast: true, mapNumber: 2, opcode: 0x3f},
+}
diff --git a/amd64_lower_minmax_test.go b/amd64_lower_minmax_test.go
new file mode 100644
index 000000000..f8c97b210
--- /dev/null
+++ b/amd64_lower_minmax_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedIntegerMinMaxCompleteGoAssemblerForms(t *testing.T) {
+	type operation struct {
+		name      string
+		broadcast bool
+	}
+	operations := []operation{
+		{name: "VPMINSB"}, {name: "VPMINUB"}, {name: "VPMAXSB"}, {name: "VPMAXUB"},
+		{name: "VPMINSW"}, {name: "VPMINUW"}, {name: "VPMAXSW"}, {name: "VPMAXUW"},
+		{name: "VPMINSD", broadcast: true}, {name: "VPMINUD", broadcast: true},
+		{name: "VPMAXSD", broadcast: true}, {name: "VPMAXUD", broadcast: true},
+		{name: "VPMINSQ", broadcast: true}, {name: "VPMINUQ", broadcast: true},
+		{name: "VPMAXSQ", broadcast: true}, {name: "VPMAXUQ", broadcast: true},
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			zLast := 22
+			if target.goarch == "386" {
+				zLast = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedintegerminmaxforms(SB),NOSPLIT,$0-0\n")
+			for _, operation := range operations {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", operation.name, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s20, %s21\n", operation.name, width, width)
+					if operation.broadcast {
+						fmt.Fprintf(&source, "\t%s.BCST 16(AX), %s20, %s22\n", operation.name, width, width)
+					}
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", operation.name, width, width, width)
+						fmt.Fprintf(&source, "\t%s.Z 8(AX), %s21, K7, %s22\n", operation.name, width, width)
+						if operation.broadcast {
+							fmt.Fprintf(&source, "\t%s.BCST.Z 16(AX), %s21, K2, %s22\n", operation.name, width, width)
+						}
+					}
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z6, Z%d\n", operation.name, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", operation.name, zLast)
+				if operation.broadcast {
+					fmt.Fprintf(&source, "\t%s.BCST 16(AX), Z6, Z%d\n", operation.name, zLast)
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s Z20, Z21, K3, Z22\n", operation.name)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z21, K4, Z22\n", operation.name)
+					if operation.broadcast {
+						fmt.Fprintf(&source, "\t%s.BCST.Z 16(AX), Z21, K5, Z22\n", operation.name)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			assembleX87ControlBytes(t, target.goarch, strings.ReplaceAll(source.String(), "NOSPLIT", "4"))
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			if target.goarch == "386" {
+				// Go accepts the original high X/Y spellings without proving
+				// physical mode32 identities. Retain its whole Go object and
+				// Context result; initialized low-bank objects have five owners.
+				return
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-integer-minmax-"+target.name+".ll", "packed-integer-minmax-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedIntegerMinMaxRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMINUB X0, X1",
+		"VPMAXUB X0, X1, (AX)",
+		"VPMINSW X0, Y1, X2",
+		"VPMAXUW Z0, Z1, Y2",
+		"VPMINSD X0, X1, K0, X2",
+		"VPMAXUD X0, K1, X1, X2",
+		"VPMINSQ.Z X0, X1, X2",
+		"VPMAXUQ.SAE X0, X1, X2",
+		"VPMINUB.BCST 8(AX), X1, X2",
+		"VPMAXSW.BCST 8(AX), X1, X2",
+		"VPMINUD.BCST X0, X1, X2",
+		"VPMAXSQ.BCST 8(AX), Y1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedIntegerMinMaxRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VPMINUB Z8, Z0, Z1",
+		"VPMAXUW Z0, Z8, Z1",
+		"VPMINSD Z0, Z1, Z8",
+		"VPMAXUQ X0, X1, K1, X2",
+		"VPMINSQ.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedIntegerMinMaxRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedIntegerMinMaxRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed min/max forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_minpos.go b/amd64_lower_minpos.go
new file mode 100644
index 000000000..3376192de
--- /dev/null
+++ b/amd64_lower_minpos.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64MinimumPositionSpec struct {
+	vector    bool
+	mapNumber int
+	opcode    int
+}
+
+// Both encodings have one X/m128 input, a 128-bit output and eight unsigned
+// word lanes. Named lowering and raw VEX decoding share the family table.
+var amd64MinimumPositionSpecs = map[Op]amd64MinimumPositionSpec{
+	"PHMINPOSUW":  {mapNumber: 2, opcode: 0x41},
+	"VPHMINPOSUW": {vector: true, mapNumber: 2, opcode: 0x41},
+}
+
+// lowerPackedUnsignedWordMinimumPosition implements every Go 1.27 form of
+// PHMINPOSUW (yxm_q4) and VPHMINPOSUW (_yvaesimc). Both tables are restricted
+// to a single X/m128 source and an X destination; the VEX spelling is also a
+// two-operand, destructive-looking Plan 9 form.
+func (c *amd64Ctx) lowerPackedUnsignedWordMinimumPosition(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, recognized, err := x86BlendMinposProperties(op, ins, c.goarch)
+	if !recognized || !form.minimum {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.legacy && form.memory {
+		return true, false, c.lowerLegacyBlendMinposMemory(ins, form)
+	}
+	bytesValue, err := c.loadX86PackedShiftBytes(ins.Args[0], 16, true)
+	if err != nil {
+		return true, false, err
+	}
+	words := c.bitcastVectorBytesToIntegerLanes(16, 8, 16, bytesValue)
+	result := c.emitPackedUnsignedWordMinimumPosition(words)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %s to <16 x i8>\n", out, result)
+	if !form.legacy {
+		return true, false, c.storePackedMoveOperand(ins.Args[1], 16, "%"+out)
+	}
+	return true, false, c.storeLegacyXViews(ins.Args[1].Reg, "%"+out)
+}
+
+// Legacy SSE replaces the low 128 bits in every live view without changing
+// the upper bytes. A narrow store into each wider slot expresses that directly.
+func (c *amd64Ctx) storeLegacyXViews(dst Reg, value string) error {
+	index, valid := amd64ParseXReg(dst)
+	if !valid {
+		return fmt.Errorf("invalid legacy X register %s", dst)
+	}
+	for _, slots := range []map[int]string{c.xRegSlot, c.yRegSlot, c.zRegSlot} {
+		if slot, live := slots[index]; live {
+			fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s\n", value, slot)
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) emitPackedUnsignedWordMinimumPosition(words string) string {
+	minimum := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <8 x i16> %s, i32 0\n", minimum, words)
+	minimumValue := "%" + minimum
+	indexValue := "0"
+	for lane := 1; lane < 8; lane++ {
+		value := c.newTmp()
+		less := c.newTmp()
+		selectedMinimum := c.newTmp()
+		selectedIndex := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <8 x i16> %s, i32 %d\n", value, words, lane)
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i16 %%%s, %s\n", less, value, minimumValue)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %%%s, i16 %s\n", selectedMinimum, less, value, minimumValue)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %d, i16 %s\n", selectedIndex, less, lane, indexValue)
+		minimumValue = "%" + selectedMinimum
+		indexValue = "%" + selectedIndex
+	}
+	withMinimum := c.newTmp()
+	withIndex := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i16> zeroinitializer, i16 %s, i32 0\n", withMinimum, minimumValue)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i16> %%%s, i16 %s, i32 1\n", withIndex, withMinimum, indexValue)
+	return "%" + withIndex
+}
diff --git a/amd64_lower_minpos_test.go b/amd64_lower_minpos_test.go
new file mode 100644
index 000000000..bfa5b94e5
--- /dev/null
+++ b/amd64_lower_minpos_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedUnsignedWordMinimumPositionCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			source := fmt.Sprintf("TEXT packedminimumpositionforms(SB),NOSPLIT,$0-0\n"+
+				"\tPHMINPOSUW X0, X%d\n"+
+				"\tPHMINPOSUW 8(AX), X%d\n"+
+				"\tVPHMINPOSUW X0, X%d\n"+
+				"\tVPHMINPOSUW 8(AX), X%d\n"+
+				"\tRET\n", last, last, last, last)
+			ll := x86UnboundBlendMinposFormatObject(t, source, target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-minimum-position-"+target.name+".ll", "packed-minimum-position-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedUnsignedWordMinimumPositionRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PHMINPOSUW.Z X0, X1",
+		"PHMINPOSUW X0",
+		"PHMINPOSUW M0, M1",
+		"PHMINPOSUW Y0, Y1",
+		"PHMINPOSUW X0, (AX)",
+		"VPHMINPOSUW.Z X0, X1",
+		"VPHMINPOSUW X0",
+		"VPHMINPOSUW X0, X1, X2",
+		"VPHMINPOSUW Y0, Y1",
+		"VPHMINPOSUW Z0, Z1",
+		"VPHMINPOSUW X0, K1, X1",
+		"VPHMINPOSUW X0, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedUnsignedWordMinimumPositionRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PHMINPOSUW X8, X0",
+		"PHMINPOSUW X0, X8",
+		"VPHMINPOSUW X16, X0",
+		"VPHMINPOSUW X0, X16",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedUnsignedWordMinimumPositionRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedUnsignedWordMinimumPositionRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's PHMINPOSUW forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_mov.go b/amd64_lower_mov.go
index 82de66ebc..7813ff2bd 100644
--- a/amd64_lower_mov.go
+++ b/amd64_lower_mov.go
@@ -6,8 +6,25 @@ import (
 )
 
 func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerMOVNTI(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerMOVBE(op, ins); ok {
+		return ok, terminated, err
+	}
+	if form, known, err := x86ScalarMoveAliasProperties(op, ins, c.goarch); known {
+		if err != nil {
+			return true, false, err
+		}
+		if !form.spec.load {
+			op = form.spec.canonical // Local lowering only; the original source remains intact.
+		}
+	}
 	switch op {
-	case "MOVQ", "MOVD", "MOVL", "MOVLQZX", "MOVLQSX", "MOVBQZX", "MOVBLZX", "MOVB", "MOVW", "MOVWLZX", "MOVWQZX", "MOVWQSX", "CMOVQLT":
+	case "MOVQ", "MOVD", "MOVDQ2Q", "MOVL", "MOVB", "MOVW", "CMOVQLT",
+		"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVBQSX", "MOVBQZX",
+		"MOVWLSX", "MOVWLZX", "MOVWQSX", "MOVWQZX", "MOVLQSX", "MOVLQZX",
+		"MOVSWW", "MOVZWW":
 		// ok
 	default:
 		return false, false, nil
@@ -15,71 +32,55 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 	if len(ins.Args) != 2 {
 		return true, false, fmt.Errorf("amd64 %s expects 2 operands: %q", op, ins.Raw)
 	}
-	src, dst := ins.Args[0], ins.Args[1]
-	zeroExtendSmallDst := false
-	if op == "MOVLQZX" {
-		op = "MOVL"
+	if view, known, err := x86NamedFrameMoveAddressInstruction(ins, c.goarch); known {
+		if err != nil {
+			return true, false, err
+		}
+		dispatch := ins
+		dispatch.Op = op
+		if x86SourceMoveInstruction(dispatch, c.goarch).Op != x86SourceMoveInstruction(ins, c.goarch).Op {
+			return true, false, fmt.Errorf("named frame MOV address dispatch disagrees with original instruction")
+		}
+		if view.Args[0].Kind == OpFP {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return true, false, err
+			}
+		}
+		// Reuse LEA's actual bound address and W/L/Q writeback. The source,
+		// frame proof and stored original instruction remain unchanged.
+		return c.lowerArith(view.Op, view)
 	}
-	if op == "MOVD" {
-		op = "MOVQ"
+	if known, err := c.lowerGoReadOnlyLoad(ins); known {
+		return true, false, err
 	}
-	if op == "MOVBQZX" || op == "MOVBLZX" {
-		op = "MOVB"
-		zeroExtendSmallDst = true
+	if _, ok := amd64ScalarExtensionMoveSpecs[op]; ok {
+		return true, false, c.lowerScalarExtensionMove(op, ins)
 	}
-	if op == "MOVWQZX" || op == "MOVWLZX" {
-		op = "MOVW"
-		zeroExtendSmallDst = true
+	if known, err := c.lowerDataBPScalarMove(ins); known {
+		return true, false, err
 	}
-	if op == "MOVLQSX" || op == "MOVWQSX" {
-		// Sign-extend i32/i16 source to i64 destination register.
-		if dst.Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects dst reg: %q", op, ins.Raw)
+	if form, known, err := x86ScalarStaticStoreProperties(op, ins, c.goarch); known {
+		if err != nil {
+			return true, false, err
 		}
-		srcTy := I32
-		if op == "MOVWQSX" {
-			srcTy = I16
+		return true, false, c.lowerScalarNativeStore(form, ins)
+	}
+	if form, known, err := c.scalarNativeLoadProperties(op, ins); known {
+		if err != nil {
+			return true, false, err
 		}
-		var sv string
-		switch src.Kind {
-		case OpImm:
-			switch srcTy {
-			case I16:
-				sv = fmt.Sprintf("%d", int16(src.Imm))
-			default:
-				sv = fmt.Sprintf("%d", int32(src.Imm))
-			}
-		case OpReg, OpFP:
-			v64, err := c.evalI64(src)
-			if err != nil {
-				return true, false, err
-			}
-			tr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", tr, v64, srcTy)
-			sv = "%" + tr
-		case OpMem:
-			p, ptrType, err := c.ptrFromMem(src.Mem)
-			if err != nil {
-				return true, false, err
-			}
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load %s, %s %s, align 1\n", ld, srcTy, ptrType, p)
-			sv = "%" + ld
-		case OpSym:
-			p, err := c.ptrFromSB(src.Sym)
-			if err != nil {
-				return true, false, err
-			}
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", ld, srcTy, p)
-			sv = "%" + ld
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported src: %q", op, ins.Raw)
+		return true, false, c.lowerScalarNativeLoad(form, ins)
+	}
+	if form, known, err := c.scalarNativeStoreProperties(op, ins); known {
+		if err != nil {
+			return true, false, err
 		}
-		se := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sext %s %s to i64\n", se, srcTy, sv)
-		return true, false, c.storeReg(dst.Reg, "%"+se)
+		return true, false, c.lowerScalarNativeStore(form, ins)
 	}
+	src, dst := ins.Args[0], ins.Args[1]
+	dispatch := ins
+	dispatch.Op = op
+	op = x86SourceMoveInstruction(dispatch, c.goarch).Op
 
 	// Vector moves are handled in lowerVec.
 	if dst.Kind == OpReg {
@@ -123,6 +124,17 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 		widthTy := I8
 		if op == "MOVW" {
 			widthTy = I16
+		} else {
+			// ymovb uses Yrb for register operands on both sides.  The
+			// compatibility closure through Ymb is identical for registers,
+			// including Go's synthesized BP/SI/DI support on 386, but excludes
+			// the amd64-only explicit low-byte aliases when translating 386.
+			if src.Kind == OpReg && !isGoYmbRegisterForArch(src.Reg, c.goarch) {
+				return true, false, fmt.Errorf("amd64 MOVB source register is outside its Go 1.27 class: %q", ins.Raw)
+			}
+			if dst.Kind == OpReg && !isGoYmbRegisterForArch(dst.Reg, c.goarch) {
+				return true, false, fmt.Errorf("amd64 MOVB destination register is outside its Go 1.27 class: %q", ins.Raw)
+			}
 		}
 		var small string
 		switch src.Kind {
@@ -137,6 +149,13 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", tr, v64, widthTy)
 			small = "%" + tr
 		case OpFP:
+			if value, handled, err := c.loadIntegerFPBytes(src.FPOffset, widthTy); handled {
+				if err != nil {
+					return true, false, err
+				}
+				small = value
+				break
+			}
 			v64, err := c.evalFPToI64(src.FPOffset)
 			if err != nil {
 				return true, false, err
@@ -165,13 +184,11 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 		}
 		switch dst.Kind {
 		case OpReg:
-			if zeroExtendSmallDst {
-				z := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", z, widthTy, small)
-				return true, false, c.storeReg(dst.Reg, "%"+z)
-			}
 			return true, false, c.storeRegSized(dst.Reg, widthTy, small)
 		case OpFP:
+			if handled, err := c.storeIntegerFPBytes(dst.FPOffset, widthTy, small); handled {
+				return true, false, err
+			}
 			return true, false, c.storeFPResult(dst.FPOffset, widthTy, small)
 		case OpMem:
 			p, ptrType, err := c.ptrFromMem(dst.Mem)
@@ -200,7 +217,13 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 		case OpReg:
 			var v string
 			var err error
-			if src.Kind == OpMem && src.Mem.Segment != "" {
+			if src.Kind == OpFP {
+				var handled bool
+				v, handled, err = c.loadIntegerFPBytes(src.FPOffset, I64)
+				if !handled {
+					v, err = c.evalI64(src)
+				}
+			} else if src.Kind == OpMem && src.Mem.Segment != "" {
 				p, ptrType, err2 := c.ptrFromMem(src.Mem)
 				if err2 != nil {
 					return true, false, err2
@@ -241,6 +264,9 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 			if err != nil {
 				return true, false, err
 			}
+			if handled, err := c.storeIntegerFPBytes(dst.FPOffset, I64, v); handled {
+				return true, false, err
+			}
 			return true, false, c.storeFPResult(dst.FPOffset, I64, v)
 		case OpMem:
 			// Store i64 to memory (common for writing return values via a pointer).
@@ -274,19 +300,24 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 
 	case "MOVL":
 		// MOVL src, dst
-		if c.goarch != "386" && dst.Kind == OpFP {
-			// Preserve the established amd64 ABI result-slot lowering.
-			if src.Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 MOVL expects reg, fp for stores: %q", ins.Raw)
-			}
-			v64, err := c.loadReg(src.Reg)
-			if err != nil {
-				return true, false, err
-			}
-			return true, false, c.storeFPResult(dst.FPOffset, I64, v64)
+		// FP result slots are memory operands in Go's ymovl table, so only a
+		// GP register or a 32-bit immediate can write them. Vector-register
+		// rows are handled by lowerVec before this scalar lowerer.
+		if dst.Kind == OpFP && src.Kind != OpReg && src.Kind != OpImm {
+			return true, false, fmt.Errorf("%s MOVL does not allow memory-to-result-memory: %q", c.goarch, ins.Raw)
 		}
 
-		i32v, err := c.evalIntSized(src, I32)
+		var i32v string
+		var err error
+		if src.Kind == OpFP {
+			var handled bool
+			i32v, handled, err = c.loadIntegerFPBytes(src.FPOffset, I32)
+			if !handled {
+				i32v, err = c.evalIntSized(src, I32)
+			}
+		} else {
+			i32v, err = c.evalIntSized(src, I32)
+		}
 		if err != nil {
 			// Preserve MOVL's existing treatment of unresolved constants from
 			// assembly include files. Explicit `$symbol(SB)` addresses are handled
@@ -305,6 +336,9 @@ func (c *amd64Ctx) lowerMov(op Op, ins Instr) (ok bool, terminated bool, err err
 
 		case OpFP:
 			// Store low 32 bits (common for ret slots).
+			if handled, err := c.storeIntegerFPBytes(dst.FPOffset, I32, i32v); handled {
+				return true, false, err
+			}
 			return true, false, c.storeFPResult(dst.FPOffset, I32, i32v)
 		case OpMem:
 			p, ptrType, err := c.ptrFromMem(dst.Mem)
diff --git a/amd64_lower_mov_extension.go b/amd64_lower_mov_extension.go
new file mode 100644
index 000000000..5c838c601
--- /dev/null
+++ b/amd64_lower_mov_extension.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerScalarExtensionMove(op Op, ins Instr) error {
+	form, recognized, err := x86ScalarExtensionProperties(op, ins, c.goarch)
+	if err != nil {
+		return err
+	}
+	if !recognized {
+		return fmt.Errorf("unrecognized scalar extension opcode %s: %q", op, ins.Raw)
+	}
+	spec := form.spec
+	sourceType := amd64IntegerTypeForBits(spec.sourceBits)
+	destinationType := amd64IntegerTypeForBits(spec.destinationBits)
+	var value string
+	native := c.nativeMemoryOperand(ins, 0) ||
+		x86CallerMemoryCertified(ins, 0) || c.fixedLocalMemoryCertified(ins, 0)
+	if native {
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return fmt.Errorf("%w: scalar extension needs its original native address size", ErrProbeNeedsContext)
+		}
+		pointer, pointerType, _, pointerErr := c.packedVectorMemoryPointer(form.source)
+		if pointerErr != nil {
+			return pointerErr
+		}
+		loaded := c.newTmp()
+		// Even a dead extension must read (and possibly fault on) its exact
+		// source width. No validity or alignment assumption follows.
+		fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", loaded, sourceType, pointerType, pointer)
+		value = "%" + loaded
+	} else {
+		value, err = c.evalIntSized(form.source, sourceType)
+	}
+	if err != nil {
+		return err
+	}
+	if spec.sourceBits < spec.destinationBits {
+		extended := c.newTmp()
+		extension := "zext"
+		if spec.signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, sourceType, value, destinationType)
+		value = "%" + extended
+	}
+	return c.storeRegSized(form.result, destinationType, value)
+}
+
+// Only the paired volatile emitter can supply these conditional numerical
+// result bytes. This creates no reusable pointee, bounds or caller proof.
+func x86LoweredScalarExtensionRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ScalarExtensionProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.source.Kind != OpMem || form.source.Mem.Sym != "" ||
+		!x86OrdinaryNativeMemoryOperand(form.source, arch) || ins.x86NumericalRead != nil {
+		return false, false
+	}
+	if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 ||
+		!x86ResultReadWithNativeGPContinuation(ins, form.source, int64(form.spec.sourceBits/8), state, owned, arch) {
+		return false, true
+	}
+	return x86ResultStore(Operand{Kind: OpReg, Reg: form.result}, int64(form.spec.destinationBits/8),
+		state, owned, resultOffset, arch), true
+}
diff --git a/amd64_lower_movbe.go b/amd64_lower_movbe.go
new file mode 100644
index 000000000..8720ba77b
--- /dev/null
+++ b/amd64_lower_movbe.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import "fmt"
+
+// lowerMOVBE implements both rows of Go 1.27's ymovbe table: memory to
+// general register and general register to memory, for W/L/Q widths.
+func (c *amd64Ctx) lowerMOVBE(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86MOVBEProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	typ := amd64IntegerTypeForBits(form.bits)
+	value, err := c.evalSizedNativeGPSource(form.source, typ, ins.x86AddressBits)
+	if err != nil {
+		return true, false, err
+	}
+	swapped := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.bswap.%s(%s %s)\n", swapped, typ, typ, typ, value)
+	if !form.store {
+		return true, false, c.storeRegSized(form.destination.Reg, typ, "%"+swapped)
+	}
+	return true, false, c.storeMOVBEMemory(form.destination, typ, "%"+swapped)
+}
+
+func (c *amd64Ctx) storeMOVBEMemory(destination Operand, typ LLVMType, value string) error {
+	switch destination.Kind {
+	case OpMem:
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(destination)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+		return nil
+	case OpFP:
+		return c.storeFPResult(destination.FPOffset, typ, value)
+	case OpSym:
+		pointer, err := c.ptrFromSB(destination.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, ptr %s, align 1\n", typ, value, pointer)
+		return nil
+	default:
+		return fmt.Errorf("MOVBE destination is not memory: %s", destination.String())
+	}
+}
diff --git a/amd64_lower_movbe_test.go b/amd64_lower_movbe_test.go
new file mode 100644
index 000000000..63c59394b
--- /dev/null
+++ b/amd64_lower_movbe_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86MOVBECompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA movedata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL movedata(SB), $8\n")
+	source.WriteString("TEXT moveforms(SB),$0-0\n")
+	widths := []string{"W", "WW", "L", "LL"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q", "QQ")
+	}
+	for _, width := range widths {
+		op := "MOVBE" + width
+		fmt.Fprintf(&source, "\t%s 8(BX), AX\n", op)
+		fmt.Fprintf(&source, "\t%s AX, 16(BX)\n", op)
+		fmt.Fprintf(&source, "\t%s movedata(SB), CX\n", op)
+		fmt.Fprintf(&source, "\t%s DX, movedata(SB)\n", op)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\t%s 24(R11), R12\n", op)
+			fmt.Fprintf(&source, "\t%s R13, 32(R14)\n", op)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86MOVBECompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86MOVBECompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "moveforms", target.goarch, target.triple)
+			for _, want := range []string{"@llvm.bswap.i16", "@llvm.bswap.i32", `"target-features"="+movbe"`} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("MOVBE lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "@llvm.bswap.i64") {
+				t.Fatalf("MOVBEQ lowering omitted i64 byte swap:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "movbe-"+target.name+".ll", "movbe-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86MOVBERejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "MOVBEW AX, BX"},
+		{goarch: "amd64", instruction: "MOVBEL 0(AX), 0(BX)"},
+		{goarch: "amd64", instruction: "MOVBEQ $1, 0(BX)"},
+		{goarch: "amd64", instruction: "MOVBEW AL, 0(BX)"},
+		{goarch: "amd64", instruction: "MOVBEL 0(AX), X0"},
+		{goarch: "amd64", instruction: "MOVBEQ AX"},
+		{goarch: "amd64", instruction: "MOVBEQQ AX"},
+		{goarch: "amd64", instruction: "MOVBEL.Z 0(AX), BX"},
+		{goarch: "386", instruction: "MOVBEQ 0(AX), BX"},
+		{goarch: "386", instruction: "MOVBEQQ 0(AX), BX"},
+		{goarch: "386", instruction: "MOVBEL R8, 0(AX)"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's MOVBE ymovbe table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64MOVBERuntimeSemanticsWidthsDirectionsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86MOVBERepairedRuntimeSource(t)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"movesemantics": {
+				Name: "movesemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := x86MOVBEOriginalRuntimeDriver
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "movbe_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_move_half_test.go b/amd64_lower_move_half_test.go
new file mode 100644
index 000000000..b5aa9c312
--- /dev/null
+++ b/amd64_lower_move_half_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86MoveHalfCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		triple string
+		last   int
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", last: 15},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", last: 7},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT movehalfforms(SB),$0-0\n")
+			for _, op := range []string{"MOVLPS", "MOVHPS", "MOVLPD", "MOVHPD"} {
+				fmt.Fprintf(&source, "\t%s X1, X%d\n", op, target.last)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, target.last)
+				fmt.Fprintf(&source, "\t%s X%d, 16(BX)\n", op, target.last)
+			}
+			source.WriteString("\tRET\n")
+
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(), "movehalfforms", target.goarch, target.triple)
+			ll := x86MoveHalfFormatObjectUnit(t, file, signatures, target.goarch, target.triple)
+			if !strings.Contains(ll, "extractelement <2 x i64>") || !strings.Contains(ll, "insertelement <2 x i64>") {
+				t.Fatalf("translation omitted half-vector lane operations:\n%s", ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "move-half-"+target.goarch+".ll", "move-half-"+target.goarch+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86MoveHalfRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVHPS Y0, X1",
+		"MOVLPS X0, Y1",
+		"MOVHPD (AX), (BX)",
+		"MOVLPD $1, X0",
+		"MOVHPS.Z X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's yxmov table", instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_move_packed_float.go b/amd64_lower_move_packed_float.go
new file mode 100644
index 000000000..8c8c647d8
--- /dev/null
+++ b/amd64_lower_move_packed_float.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerPackedVectorMove implements the complete Go 1.27 packed vector-move
+// tables. VMOVAPD/APS/UPD/UPS share _yvmovapd, while VMOVDQA32/DQA64 and
+// VMOVDQU8/DQU16/DQU32/DQU64 share _yvmovdqa32. All have bit-preserving move
+// semantics; the element width only controls the granularity of an EVEX mask.
+func (c *amd64Ctx) lowerPackedVectorMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, recognized := amd64PackedVectorMoveSpecs[Op(base)]; !recognized {
+		return false, false, nil
+	}
+	// Legacy helper calls may omit ins.Op. Never replace a conflicting source
+	// identity when binding the dispatch argument for the shared grammar.
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("packed move dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := amd64PackedVectorMoveProperties(ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	if form.undefinedOpcode() {
+		// Invalid encoding faults before any mask, vector or address access.
+		// An ordinary masked store would silently change the native semantics.
+		return c.lowerSyscall("UD2", Instr{Op: "UD2"})
+	}
+	src, dst := ins.Args[0], ins.Args[form.destination]
+	byteWidth, elemBits := form.byteWidth, form.spec.elementBits
+	if form.spec.aligned && form.memory >= 0 {
+		if !c.nativeMemoryOperand(ins, form.memory) &&
+			!x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			return true, false, fmt.Errorf("%w: %s requires original native memory backing and alignment effects", ErrProbeNeedsContext, op)
+		}
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return true, false, fmt.Errorf("%w: aligned packed move needs its original native address size", ErrProbeNeedsContext)
+		}
+		return true, false, c.lowerAlignedPackedMoveMemory(ins, form)
+	}
+	for _, operand := range []Operand{src, dst} {
+		if operand.Kind != OpFP {
+			continue
+		}
+		if err := c.validateFPVectorSpan(operand.FPOffset, byteWidth); err != nil {
+			return true, false, fmt.Errorf("%s %s: %w: %q", c.goarch, op, err, ins.Raw)
+		}
+	}
+	if !form.spec.aligned && form.memory >= 0 &&
+		(c.nativeMemoryOperand(ins, form.memory) || x86CallerMemoryCertified(ins, form.memory) || c.fixedLocalMemoryCertified(ins, form.memory)) {
+		return true, false, c.lowerUnalignedPackedMoveMemory(ins, form)
+	}
+
+	if form.mask < 0 {
+		value, err := c.loadPackedCompareBytes(src, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storePackedMoveOperand(dst, byteWidth, value)
+	}
+	mask, err := c.loadK(ins.Args[form.mask].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	// FP operands describe checked virtual slots, not necessarily contiguous
+	// native memory: each parameter/result can have its own alloca. Retain the
+	// per-slot loads, mask selection and stores below for those operands.
+	if (isAMD64MemoryOperand(src) && src.Kind != OpFP) || (isAMD64MemoryOperand(dst) && dst.Kind != OpFP) {
+		return true, false, c.lowerMaskedPackedMoveMemory(src, dst, byteWidth, elemBits, mask, form.zeroing)
+	}
+	value, err := c.loadPackedCompareBytes(src, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	oldBytes, err := c.loadPackedCompareBytes(dst, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / elemBits
+	computed := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, elemBits, value)
+	old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, elemBits, oldBytes)
+	// The invalid .Z memory-destination encoding was handled before evaluating
+	// any operand. Valid zeroing forms always have a register destination.
+	result := amd64ApplyIntegerLaneMask(c, lanes, elemBits, computed, old, mask, form.zeroing && dst.Kind == OpReg)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, elemBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(dst, byteWidth, "%"+out)
+}
+
+// VEX/EVEX register writes replace every overlapping view and zero all bits
+// above the written width. Keep this separate from legacy SSE stores, which
+// preserve those upper bits.
+func (c *amd64Ctx) storePackedMoveOperand(dst Operand, byteWidth int, value string) error {
+	if dst.Kind != OpReg {
+		return c.storeVectorBytesOperand(dst, byteWidth, value)
+	}
+	index, valid := amd64VectorRegisterIndex(dst.Reg, byteWidth)
+	if !valid {
+		return fmt.Errorf("invalid packed move register %s", dst.Reg)
+	}
+	for _, view := range []struct {
+		bytes int
+		slots map[int]string
+	}{{16, c.xRegSlot}, {32, c.yRegSlot}, {64, c.zRegSlot}} {
+		slot, live := view.slots[index]
+		if !live {
+			continue
+		}
+		stored := value
+		if view.bytes != byteWidth {
+			indices := make([]string, view.bytes)
+			for i := range indices {
+				lane := i
+				if lane >= byteWidth {
+					lane = byteWidth // First byte of the zero second source.
+				}
+				indices[i] = fmt.Sprintf("i32 %d", lane)
+			}
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> <%s>\n", converted, byteWidth, value, byteWidth, view.bytes, strings.Join(indices, ", "))
+			stored = "%" + converted
+		}
+		fmt.Fprintf(c.b, "  store <%d x i8> %s, ptr %s\n", view.bytes, stored, slot)
+	}
+	return nil
+}
+
+// Other EVEX families use this architecture/register axis without acquiring
+// packed-move effects or caller-memory permissions.
+func (c *amd64Ctx) isGoPackedVectorMoveRegister(arg Operand, byteWidth int) bool {
+	return amd64GoPackedVectorMoveRegister(arg, byteWidth, c.goarch)
+}
+
+// Share the architectural lane mask across floating and integer moves. A
+// select after an eager full-width load/store cannot suppress memory faults
+// and must not be used for masked memory destinations (including write-only
+// memory). LLVM 22's masked intrinsics access only enabled lanes.
+func (c *amd64Ctx) lowerMaskedPackedMoveMemory(src, dst Operand, byteWidth, elemBits int, mask string, zeroing bool) error {
+	load := isAMD64MemoryOperand(src)
+	memory := dst
+	if load {
+		memory = src
+	}
+	pointer, pointerType, suffix, err := c.packedVectorMemoryPointer(memory)
+	if err != nil {
+		return err
+	}
+	if suffix == "" {
+		suffix = ".p0"
+	}
+	lanes := byteWidth * 8 / elemBits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, elemBits)
+	predicate := amd64IntegerMaskVector(c, lanes, mask)
+	if load {
+		fallback := "zeroinitializer"
+		if !zeroing {
+			fallback, err = c.loadPackedCompareLanes(dst, byteWidth, elemBits, false)
+			if err != nil {
+				return err
+			}
+		}
+		loaded, bytes := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.masked.load.v%di%d%s(%s align 1 %s, <%d x i1> %s, %s %s)\n", loaded, vectorType, lanes, elemBits, suffix, pointerType, pointer, lanes, predicate, vectorType, fallback)
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, vectorType, loaded, byteWidth)
+		return c.storePackedMoveOperand(dst, byteWidth, "%"+bytes)
+	}
+	value, err := c.loadPackedCompareLanes(src, byteWidth, elemBits, false)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  call void @llvm.masked.store.v%di%d%s(%s %s, %s align 1 %s, <%d x i1> %s)\n", lanes, elemBits, suffix, vectorType, value, pointerType, pointer, lanes, predicate)
+	return nil
+}
diff --git a/amd64_lower_move_sign_extend.go b/amd64_lower_move_sign_extend.go
new file mode 100644
index 000000000..b11d1f79a
--- /dev/null
+++ b/amd64_lower_move_sign_extend.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerPackedExtendMove implements all six signed and all six unsigned legacy
+// and vector widening instructions exposed by Go 1.27. Ratio-two V forms use
+// _yvcvtdq2pd; ratio-four and ratio-eight forms use _yvbroadcastss.
+func (c *amd64Ctx) lowerPackedExtendMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	_, zero := x86PackedZeroExtendSpecs[Op(base)]
+	_, signed := x86PackedSignExtendSpecs[Op(base)]
+	if !zero && !signed {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("packed widening dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op // Keep the original helper's empty-op dispatch contract.
+	form, known, err := x86PackedExtendProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.emitPackedExtendMove(ins, form)
+}
+
+func (c *amd64Ctx) loadPackedExtendInputs(src Operand, registerBytes, lanes, inputBits int) (string, error) {
+	if src.Kind == OpReg {
+		bytesValue, err := c.loadPackedCompareBytes(src, registerBytes)
+		if err != nil {
+			return "", err
+		}
+		fullLanes := registerBytes * 8 / inputBits
+		full := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i%d>\n", full, registerBytes, bytesValue, fullLanes, inputBits)
+		if fullLanes == lanes {
+			return "%" + full, nil
+		}
+		result := "zeroinitializer"
+		for lane := 0; lane < lanes; lane++ {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %%%s, i32 %d\n", value, fullLanes, inputBits, full, lane)
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, inputBits, result, inputBits, value, lane)
+			result = "%" + inserted
+		}
+		return result, nil
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, inputBits)
+	switch src.Kind {
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(src.Mem)
+		if err != nil {
+			return "", err
+		}
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load %s, %s %s, align 1\n", loaded, vectorType, ptrType, ptr)
+		return "%" + loaded, nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(src.Sym)
+		if err != nil {
+			return "", err
+		}
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", loaded, vectorType, ptr)
+		return "%" + loaded, nil
+	case OpFP:
+		result := "zeroinitializer"
+		for lane := 0; lane < lanes; lane++ {
+			laneOperand := src
+			laneOperand.FPOffset += int64(lane * inputBits / 8)
+			value, err := c.evalIntSized(laneOperand, amd64IntegerTypeForBits(inputBits))
+			if err != nil {
+				return "", err
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, result, inputBits, value, lane)
+			result = "%" + inserted
+		}
+		return result, nil
+	default:
+		return "", fmt.Errorf("expected packed extension register or memory source, got %s", src.String())
+	}
+}
diff --git a/amd64_lower_move_zero_extend.go b/amd64_lower_move_zero_extend.go
new file mode 100644
index 000000000..6c3f62aba
--- /dev/null
+++ b/amd64_lower_move_zero_extend.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPackedZeroExtendMove(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86PackedZeroExtendSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	return c.lowerPackedExtendMove(op, ins)
+}
+
+func (c *amd64Ctx) emitPackedExtendMove(ins Instr, form x86PackedExtendForm) (bool, bool, error) {
+	var err error
+	source, destination := ins.Args[0], ins.Args[form.destination]
+	lanes := form.byteWidth * 8 / form.spec.outputBits
+	if source.Kind == OpFP {
+		if err := c.validateFPVectorSpan(source.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	var mask, inputs string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	switch {
+	case source.Kind == OpFP:
+		// Independent ABI0 fields are not a contiguous native vector. Read
+		// each declared byte and only then assemble the integer source lanes.
+		var bytes string
+		bytes, err = c.loadFPVectorBytes(source.FPOffset, form.memoryBytes)
+		if err == nil {
+			inputs = c.bitcastVectorBytesToIntegerLanes(form.memoryBytes, lanes, form.spec.inputBits, bytes)
+		}
+	case form.memory >= 0:
+		// E5 inactive lanes suppress reads; active accesses remain observable
+		// even if the widened result is dead. Read the shrinking source tuple,
+		// not its larger physical vector container or widened destination.
+		inputs, err = c.loadX86PackedShiftLanes(source, form.memoryBytes, form.spec.inputBits, false, mask)
+	default:
+		inputs, err = c.loadPackedExtendInputs(source, form.sourceRegisterBytes, lanes, form.spec.inputBits)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	result := "zeroinitializer"
+	extension := "zext"
+	if form.signed {
+		extension = "sext"
+	}
+	for lane := 0; lane < lanes; lane++ {
+		input, extended, inserted := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", input, lanes, form.spec.inputBits, inputs, lane)
+		fmt.Fprintf(c.b, "  %%%s = %s i%d %%%s to i%d\n", extended, extension, form.spec.inputBits, input, form.spec.outputBits)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, form.spec.outputBits, result, form.spec.outputBits, extended, lane)
+		result = "%" + inserted
+	}
+	if form.mask >= 0 {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			var bytes string
+			bytes, err = c.loadPackedCompareBytes(destination, form.byteWidth)
+			if err != nil {
+				return true, false, err
+			}
+			old = c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.spec.outputBits, bytes)
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.spec.outputBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.spec.outputBits, result, form.byteWidth)
+	if !form.spec.vector {
+		return true, false, c.storeLegacyXViews(destination.Reg, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
diff --git a/amd64_lower_move_zero_extend_test.go b/amd64_lower_move_zero_extend_test.go
new file mode 100644
index 000000000..c9b64261d
--- /dev/null
+++ b/amd64_lower_move_zero_extend_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedZeroExtendMoveCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedzeroextendmoveforms(SB),4,$0-0\n")
+			for _, ratio := range x86ZeroExtendTestRatios {
+				for _, prefix := range []string{"P", "VP"} {
+					for _, row := range x86ZeroExtendAcceptedForms(prefix+"MOVZX"+ratio.suffix, target.goarch) {
+						source.WriteString(row + "\n")
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			// This unchanged format directory has no address, data or mask
+			// producers. Its Go object and public Context checks remain
+			// separate from the initialized three-API object matrices.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "packedzeroextendmoveforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-zero-extend-move-"+target.name+".ll", "packed-zero-extend-move-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedZeroExtendMoveRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PMOVZXBW.Z X0, X1",
+		"PMOVZXBD X0",
+		"PMOVZXBQ M0, X1",
+		"PMOVZXWD Y0, X1",
+		"PMOVZXWQ X0, Y1",
+		"PMOVZXDQ X0, K1, X1",
+		"VPMOVZXBW Y0, Y1",
+		"VPMOVZXWD X0, Z1",
+		"VPMOVZXDQ Z0, Z1",
+		"VPMOVZXBD Y0, Z1",
+		"VPMOVZXBQ X0, K0, X1",
+		"VPMOVZXWQ.Z X0, X1",
+		"VPMOVZXBD.BCST 8(AX), X1",
+		"VPMOVZXWQ X0, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedZeroExtendMoveRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PMOVZXBW X8, X0",
+		"PMOVZXDQ X0, X8",
+		"VPMOVZXBW Y20, Z8",
+		"VPMOVZXBQ X20, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedZeroExtendMoveRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedZeroExtendMoveRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's packed zero-extension forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_movemask.go b/amd64_lower_movemask.go
new file mode 100644
index 000000000..b8bb45eeb
--- /dev/null
+++ b/amd64_lower_movemask.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64MoveMaskSpec struct {
+	opcode           int
+	prefix           int
+	vector           bool
+	floatingLaneBits int
+}
+
+// The legacy and VEX spellings share the Go table's register-to-GP shape.
+// The raw decoder uses the VEX entries; x/arch handles legacy raw bytes.
+var amd64MoveMaskSpecs = map[Op]amd64MoveMaskSpec{
+	"PMOVMSKB":  {opcode: 0xd7, prefix: 1},
+	"VPMOVMSKB": {opcode: 0xd7, prefix: 1, vector: true},
+	"MOVMSKPS":  {opcode: 0x50, floatingLaneBits: 32},
+	"MOVMSKPD":  {opcode: 0x50, prefix: 1, floatingLaneBits: 64},
+	"VMOVMSKPS": {opcode: 0x50, vector: true, floatingLaneBits: 32},
+	"VMOVMSKPD": {opcode: 0x50, prefix: 1, vector: true, floatingLaneBits: 64},
+}
+
+type x86MoveMaskForm struct {
+	amd64MoveMaskSpec
+	byteWidth int
+}
+
+// Shape is shared by lowering and result definedness. Acceptance supplies no
+// initialized vector, MMX state, physical mode32 bank or caller permission.
+func x86MoveMaskProperties(op Op, ins Instr, arch string) (x86MoveMaskForm, bool, error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64MoveMaskSpecs[Op(baseOp)]
+	form := x86MoveMaskForm{amd64MoveMaskSpec: spec}
+	if !recognized {
+		return form, false, nil
+	}
+	if arch != "amd64" && arch != "386" || rawOp != baseOp ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), baseOp) {
+		return form, true, fmt.Errorf("%s %s has an unbound mode, dispatch or suffix: %q", arch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return form, true, fmt.Errorf("%s %s expects vector-or-MMX source and GP destination: %q", arch, baseOp, ins.Raw)
+	}
+	if !isX86YrlRegisterForArch(ins.Args[1].Reg, arch) {
+		return form, true, fmt.Errorf("%s %s destination is outside Go's Yrl class: %q", arch, baseOp, ins.Raw)
+	}
+	limit := 15
+	if !spec.vector && arch == "386" {
+		limit = 7
+	}
+	if index, valid := amd64ParseXReg(ins.Args[0].Reg); valid && index <= limit {
+		form.byteWidth = 16
+	} else if index, valid := amd64ParseYReg(ins.Args[0].Reg); spec.vector && valid && index <= 15 {
+		form.byteWidth = 32
+	} else if _, valid := amd64ParseMReg(ins.Args[0].Reg); !spec.vector && spec.floatingLaneBits == 0 && valid {
+		form.byteWidth = 8
+	} else {
+		return form, true, fmt.Errorf("%s %s source is outside its Go table: %q", arch, baseOp, ins.Raw)
+	}
+	return form, true, nil
+}
+
+// No Go move-mask row accepts EVEX, mask-register, suffix or memory forms.
+func (c *amd64Ctx) lowerPackedMoveMask(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86MoveMaskProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.floatingLaneBits != 0 {
+		value, err := c.loadPackedCompareBytes(ins.Args[0], form.byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		mask32 := c.packedSignMask(value, form.byteWidth, form.floatingLaneBits)
+		return true, false, c.storeRegSized(ins.Args[1].Reg, I32, mask32)
+	}
+	if form.byteWidth != 8 && c.targetTriple != "" && !x86ScalarFloatIntegerNativeTarget(arch, c.targetTriple) {
+		value, err := c.loadPackedCompareBytes(ins.Args[0], form.byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeRegSized(ins.Args[1].Reg, I32, c.packedSignMask(value, form.byteWidth, 8))
+	}
+
+	var mask32 string
+	if form.byteWidth == 16 {
+		value, err := c.loadX(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		mask := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %s)\n", mask, value)
+		mask32 = "%" + mask
+	} else if form.byteWidth == 32 {
+		value, err := c.loadY(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		low := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", low, value, llvmI32RangeMask(0, 16))
+		high := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", high, value, llvmI32RangeMask(16, 16))
+		lowMask := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %%%s)\n", lowMask, low)
+		highMask := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %%%s)\n", highMask, high)
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, 16\n", shifted, highMask)
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", combined, shifted, lowMask)
+		mask32 = "%" + combined
+	} else {
+		value, err := c.loadReg(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <8 x i8>\n", bytes, value)
+		signBits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt <8 x i8> %%%s, zeroinitializer\n", signBits, bytes)
+		mask8 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i1> %%%s to i8\n", mask8, signBits)
+		widened := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i32\n", widened, mask8)
+		mask32 = "%" + widened
+	}
+
+	return true, false, c.storeRegSized(ins.Args[1].Reg, I32, mask32)
+}
+
+// Lane i writes mask bit i explicitly. Byte lanes need no vector-to-integer
+// bitcast, so this portable path does not depend on the target's byte order.
+func (c *amd64Ctx) packedSignMask(value string, byteWidth, laneBits int) string {
+	lanes := byteWidth * 8 / laneBits
+	integerLanes := value
+	if laneBits != 8 {
+		integerLanes = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits, value)
+	}
+	mask := "0"
+	for lane := 0; lane < lanes; lane++ {
+		laneValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", laneValue, lanes, laneBits, integerLanes, lane)
+		sign := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %%%s, 0\n", sign, laneBits, laneValue)
+		bit := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i32\n", bit, sign)
+		positioned := "%" + bit
+		if lane != 0 {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %d\n", shifted, bit, lane)
+			positioned = "%" + shifted
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i32 %s, %s\n", combined, mask, positioned)
+		mask = "%" + combined
+	}
+	return mask
+}
+
+func isX86YrlRegisterForArch(r Reg, goarch string) bool {
+	if !isAMD64YrlRegister(r) {
+		return false
+	}
+	if goarch != "386" {
+		return true
+	}
+	switch r {
+	case AX, BX, CX, DX, SP, BP, SI, DI:
+		return true
+	default:
+		return false
+	}
+}
diff --git a/amd64_lower_movhlps.go b/amd64_lower_movhlps.go
new file mode 100644
index 000000000..ead29b338
--- /dev/null
+++ b/amd64_lower_movhlps.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import "fmt"
+
+// lowerMoveHighLowPackedSingle implements all forms in Go 1.27's legacy yxr
+// and AVX _yvmovhlps tables for the HLPS/LHPS register-only move family.
+func (c *amd64Ctx) lowerMoveHighLowPackedSingle(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86MoveHalfProperties(op, ins, c.goarch)
+	if !known || !form.spec.registerOnly {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	first, err := c.loadXAsI64x2(ins.Args[form.source].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadXAsI64x2(ins.Args[form.base].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	mask := "<i32 2, i32 0>"
+	if form.outputLane == 0 {
+		mask = "<i32 1, i32 3>"
+	}
+	if !form.spec.vector {
+		first, second = second, first
+		mask = "<i32 0, i32 2>"
+		if form.outputLane == 0 {
+			mask = "<i32 3, i32 1>"
+		}
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %s, <2 x i64> %s, <2 x i32> %s\n", result, first, second, mask)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, result)
+	if form.spec.vector {
+		return true, false, c.storePackedMoveOperand(ins.Args[form.destination], 16, "%"+bytes)
+	}
+	return true, false, c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+}
diff --git a/amd64_lower_movnti.go b/amd64_lower_movnti.go
new file mode 100644
index 000000000..288142fb5
--- /dev/null
+++ b/amd64_lower_movnti.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+const x86NonTemporalMetadata = ", !nontemporal !0"
+
+func (c *amd64Ctx) lowerMOVNTI(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86MOVNTIProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.trap {
+		c.b.WriteString("  call void asm sideeffect \"ud2\", \"~{memory}\"()\n")
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+		!x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return true, false, fmt.Errorf("%w: MOVNTI needs its original named x86 target and address size", ErrProbeNeedsContext)
+	}
+	if !c.nativeMemoryOperand(ins, 1) {
+		return true, false, fmt.Errorf("%w: MOVNTI needs native storage, not logical FP/AUTO bytes", ErrProbeNeedsContext)
+	}
+	return true, false, c.emitMOVNTI(form)
+}
+
+// Intel SDM MOVNTI retains its actual WC/cache policy, dead write and faults.
+// LLVM nontemporal metadata on an ordinary store makes none of those effects
+// mandatory. Pass only the exact integer and opaque address to the native
+// opcode, without asserting alignment, extent, aliasing or pointee validity.
+func (c *amd64Ctx) emitMOVNTI(form x86MOVNTIForm) error {
+	typ := amd64IntegerTypeForBits(form.bits)
+	value, err := c.evalIntSized(form.source, typ)
+	if err != nil {
+		return err
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.destination)
+	if err != nil {
+		return err
+	}
+	segment, modifier := "", "k"
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	if form.bits == 64 {
+		modifier = "q"
+	}
+	assembly := "movnti ${0:" + modifier + "}, " + segment + "($1)"
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s, %s %s)\n", assembly,
+		"r,r,~{memory}", typ, value, pointerType, pointer)
+	return nil
+}
+
+func x86MemoryRegistersValidForArch(memory MemRef, goarch string) bool {
+	for _, register := range []Reg{memory.Base, memory.Index} {
+		if register != "" && !isX86YrlRegisterForArch(register, goarch) {
+			return false
+		}
+	}
+	return true
+}
+
+func (c *amd64Ctx) storeMOVNTIMemory(destination Operand, typ LLVMType, value string) error {
+	switch destination.Kind {
+	case OpMem:
+		pointer, pointerType, err := c.ptrFromMem(destination.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store %s %s, %s %s, align 1%s\n", typ, value, pointerType, pointer, x86NonTemporalMetadata)
+		return nil
+	case OpFP:
+		return c.storeFPResultWithMetadata(destination.FPOffset, typ, value, x86NonTemporalMetadata)
+	case OpSym:
+		pointer, err := c.ptrFromSB(destination.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1%s\n", typ, value, pointer, x86NonTemporalMetadata)
+		return nil
+	default:
+		return fmt.Errorf("MOVNTI destination is not memory: %s", destination.String())
+	}
+}
+
+func fileUsesX86NonTemporalMetadata(file *File) bool {
+	if file == nil || file.Arch != ArchAMD64 {
+		return false
+	}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			op := strings.ToUpper(string(instruction.Op))
+			switch op {
+			case "MOVNTQ", "MOVNTDQ", "MOVNTO", "MOVNTPD", "MOVNTPS", "VMOVNTDQ", "VMOVNTPD", "VMOVNTPS":
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/amd64_lower_movnti_test.go b/amd64_lower_movnti_test.go
new file mode 100644
index 000000000..55f707bb7
--- /dev/null
+++ b/amd64_lower_movnti_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86MOVNTICompleteFormsSource(goarch string) (string, map[string]FuncSig) {
+	var source strings.Builder
+	source.WriteString("DATA movntidata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL movntidata(SB), $8\n")
+	source.WriteString("TEXT movntiforms(SB),$0-0\n")
+	source.WriteString("\tMOVNTIL AX, 8(BX)\n")
+	source.WriteString("\tMOVNTIL CX, movntidata(SB)\n")
+	if goarch == "amd64" {
+		source.WriteString("\tMOVNTIL R11, 16(R12)\n")
+		source.WriteString("\tMOVNTIQ AX, 24(BX)\n")
+		source.WriteString("\tMOVNTIQ CX, movntidata(SB)\n")
+		source.WriteString("\tMOVNTIQ R13, 32(R14)\n")
+	}
+	source.WriteString("\tRET\n")
+
+	source.WriteString("TEXT movntiframe(SB),$0-4\n")
+	source.WriteString("\tMOVNTIL AX, ret+0(FP)\n")
+	source.WriteString("\tRET\n")
+	if goarch == "amd64" {
+		source.WriteString("TEXT movntiframeq(SB),$0-8\n")
+		source.WriteString("\tMOVNTIQ AX, ret+0(FP)\n")
+		source.WriteString("\tRET\n")
+	}
+
+	// Yml's Go compatibility closure includes registers even though the ISA
+	// defines only memory destinations for MOVNTI. Keep this Go-accepted source
+	// form visible and require the translated function to trap explicitly.
+	source.WriteString("TEXT movntiregtrap(SB),$0-0\n")
+	source.WriteString("\tMOVNTIL AX, BX\n")
+	source.WriteString("\tRET\n")
+
+	sigs := map[string]FuncSig{
+		"movntiforms":   {Name: "movntiforms", Ret: Void},
+		"movntiframe":   {Name: "movntiframe", Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}}},
+		"movntiregtrap": {Name: "movntiregtrap", Ret: Void},
+	}
+	if goarch == "amd64" {
+		sigs["movntiframeq"] = FuncSig{Name: "movntiframeq", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+	}
+	return source.String(), sigs
+}
+
+func TestTranslateX86MOVNTICompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source, sigs := x86MOVNTICompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: sigs}); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original unbound MOVNTI format source invented numerical/native inputs", err)
+			}
+			// Preserve every original source and Go object. This private
+			// emitter unit measures the accepted encoding rows, not a public
+			// native FP frame or initialized result. The register-only row is
+			// independently translated as its actual terminal #UD below.
+			formats := *file
+			formats.Funcs = append([]Func(nil), file.Funcs[:len(file.Funcs)-1]...)
+			ir := x86InstructionFormatObjectUnit(t, &formats, sigs, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					form, known, err := x86MOVNTIProperties(ins.Op, ins, target.goarch)
+					if !known || err != nil || form.trap {
+						return known, false, err
+					}
+					return true, false, c.emitMOVNTI(form)
+				})
+			for _, want := range []string{`asm sideeffect "movnti ${0:k}`, `~{memory}`, `"target-features"="+sse2"`} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("MOVNTI lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if strings.Contains(ir, "!nontemporal") || target.goarch == "amd64" && !strings.Contains(ir, `asm sideeffect "movnti ${0:q}`) {
+				t.Fatalf("MOVNTI lost its mandatory original-width native store:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "movnti-"+target.name+".ll", "movnti-"+target.name+".o", ir)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, llc, "-mtriple="+target.triple, "-filetype=asm", "-o=-", "-")
+			command.Stdin = strings.NewReader(ir)
+			assembly, err := runtimeOracleCombinedOutput(ctx, command)
+			if err != nil {
+				t.Fatalf("llc MOVNTI assembly failed: %v\n%s", err, assembly)
+			}
+			if !strings.Contains(strings.ToLower(string(assembly)), "movnti") {
+				t.Fatalf("LLVM 22 did not preserve the non-temporal integer store:\n%s", assembly)
+			}
+			trap, err := Parse(ArchAMD64, "TEXT movntiregtrap(SB),$0-0\nMOVNTIL AX,BX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			trapIR, err := Translate(trap, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil || !strings.Contains(trapIR, `asm sideeffect "ud2"`) || !strings.Contains(trapIR, "unreachable") {
+				t.Fatal("original Go register row lost its input-independent #UD", err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "movnti-trap.ll", "movnti-trap.o", trapIR)
+		})
+	}
+}
+
+func TestTranslateX86MOVNTIRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "MOVNTIL 0(AX), BX"},
+		{goarch: "amd64", instruction: "MOVNTIL 0(AX), 8(BX)"},
+		{goarch: "amd64", instruction: "MOVNTIL $1, 8(BX)"},
+		{goarch: "amd64", instruction: "MOVNTIL X0, 8(BX)"},
+		{goarch: "amd64", instruction: "MOVNTIL AX"},
+		{goarch: "amd64", instruction: "MOVNTIL AX, 0(BX), CX"},
+		{goarch: "amd64", instruction: "MOVNTIL.Z AX, 8(BX)"},
+		{goarch: "386", instruction: "MOVNTIQ AX, 8(BX)"},
+		{goarch: "386", instruction: "MOVNTIL R8, 8(BX)"},
+		{goarch: "386", instruction: "MOVNTIL AX, 8(R9)"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's MOVNTI yrl_ml table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64MOVNTIRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT movntisemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVQ $0x1122334455667788, AX
+	MOVQ $0x8877665544332211, BX
+	MOVNTIL AX, 0(DI)
+	MOVNTIQ BX, 8(DI)
+	SFENCE
+	SETCS 16(DI)
+	SETOS 17(DI)
+	SETEQ 18(DI)
+	SETMI 19(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"movntisemantics": {
+				Name: "movntisemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void movntisemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[24] = {0};
+  movntisemantics(out);
+  if (load64(out) != UINT64_C(0x0000000055667788)) return 10;
+  if (load64(out+8) != UINT64_C(0x8877665544332211)) return 11;
+  if (out[16] != 1 || out[17] != 1 || out[18] != 0 || out[19] != 1) return 12;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "movnti_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestX86MOVNTIGoAssemblerCompatibilityClosure(t *testing.T) {
+	for _, goarch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{"MOVNTIL AX, 8(BX)", "MOVNTIL AX, BX", "MOVNTIL AX, ret+0(FP)"} {
+			t.Run(fmt.Sprintf("%s/%s", goarch, strings.NewReplacer(" ", "_", ",", "").Replace(instruction)), func(t *testing.T) {
+				requireX86GoAssemblerResult(t, goarch, "TEXT compat(SB),$0-8\n\t"+instruction+"\n\tRET\n", true)
+			})
+		}
+	}
+}
diff --git a/amd64_lower_mpsadbw_test.go b/amd64_lower_mpsadbw_test.go
new file mode 100644
index 000000000..a68f806d7
--- /dev/null
+++ b/amd64_lower_mpsadbw_test.go
@@ -0,0 +1,356 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedSADGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64PackedSADSpec{
+		"PSADBW":    {kind: amd64PackedSADBlockSum, form: amd64PackedSADLegacyX},
+		"VPSADBW":   {kind: amd64PackedSADBlockSum, form: amd64PackedSADEVEXXYZ},
+		"MPSADBW":   {kind: amd64PackedSADMultiple, form: amd64PackedSADLegacyX},
+		"VMPSADBW":  {kind: amd64PackedSADMultiple, form: amd64PackedSADVEXXY},
+		"VDBPSADBW": {kind: amd64PackedSADDoubleBlock, form: amd64PackedSADEVEXXYZ},
+	}
+	if len(amd64PackedSADSpecs) != len(expected) {
+		t.Fatalf("packed SAD grammar has %d entries, want %d", len(amd64PackedSADSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64PackedSADSpecs[op]; !ok {
+			t.Errorf("packed SAD grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("packed SAD grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86MultipleSADCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 15
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT mpsadforms(SB),$0-0\n")
+			fmt.Fprintf(&source, "\tMPSADBW $7, X0, X%d\n", last)
+			fmt.Fprintf(&source, "\tMPSADBW $7, 0(AX), X%d\n", last)
+			if target.goarch == "amd64" {
+				fmt.Fprintf(&source, "\tVMPSADBW $7, X0, X1, X%d\n", last)
+				fmt.Fprintf(&source, "\tVMPSADBW $7, 16(AX), X1, X%d\n", last)
+				fmt.Fprintf(&source, "\tVMPSADBW $7, Y0, Y1, Y%d\n", last)
+				fmt.Fprintf(&source, "\tVMPSADBW $7, 32(AX), Y1, Y%d\n", last)
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "mpsadforms", target.goarch, target.triple)
+			if !strings.Contains(ir, "call <8 x i16> @llvm.x86.sse41.mpsadbw") {
+				t.Fatalf("MPSADBW lowering omitted the SSE4.1 intrinsic:\n%s", ir)
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "call <16 x i16> @llvm.x86.avx2.mpsadbw") {
+				t.Fatalf("VMPSADBW Y lowering omitted the AVX2 intrinsic:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "mpsadbw-"+target.name+".ll", "mpsadbw-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86DoubleSADCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 23
+			var source strings.Builder
+			source.WriteString("TEXT dbpsadforms(SB),$0-0\n")
+			for _, width := range []string{"X", "Y", "Z"} {
+				fmt.Fprintf(&source, "\tVDBPSADBW $0, %s0, %s1, %s%d\n", width, width, width, last)
+				fmt.Fprintf(&source, "\tVDBPSADBW $85, 0(AX), %s1, %s%d\n", width, width, last)
+				fmt.Fprintf(&source, "\tVDBPSADBW $170, %s2, %s1, K1, %s%d\n", width, width, width, last)
+				fmt.Fprintf(&source, "\tVDBPSADBW.Z $255, 64(AX), %s1, K2, %s%d\n", width, width, last)
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "dbpsadforms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "dbpsadbw-"+target.name+".ll", "dbpsadbw-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86DoubleSADRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VDBPSADBW $-1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VDBPSADBW $256, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VDBPSADBW.Z $1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VDBPSADBW.BCST $1, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VDBPSADBW $1, X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VDBPSADBW $1, X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VDBPSADBW $1, X0, X1, K1, X2, X3"},
+		{goarch: "386", instruction: "VDBPSADBW $1, X0, X1, X2"},
+		{goarch: "386", instruction: "VDBPSADBW.Z $1, X0, X1, K1, X2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VDBPSADBW table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateX86MultipleSADRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "MPSADBW $-1, X0, X1"},
+		{goarch: "amd64", instruction: "MPSADBW $256, X0, X1"},
+		{goarch: "amd64", instruction: "MPSADBW.Z $1, X0, X1"},
+		{goarch: "amd64", instruction: "MPSADBW $1, Y0, Y1"},
+		{goarch: "amd64", instruction: "VMPSADBW $1, Z0, Z1, Z2"},
+		{goarch: "amd64", instruction: "VMPSADBW $1, X0, Y1, Y2"},
+		{goarch: "386", instruction: "MPSADBW $1, X0, X8"},
+		{goarch: "386", instruction: "VMPSADBW $1, X0, X1, X2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{Goarch: test.goarch, TargetTriple: triple, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside the Go table for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestTranslateX86PackedSADRejects386OutOfRangeForms(t *testing.T) {
+	for _, instruction := range []string{
+		"PSADBW X0, X8",
+		"PSADBW 8(R9), X0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "386",
+				TargetTriple: "i386-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside the Go 386 SAD tables", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64MultipleSADRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT mpsadsemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), CX
+	MOVQ b+16(FP), DX
+	MOVUPS 0(CX), X1
+	MOVUPS 0(DX), X0
+	STC
+	MPSADBW $0, X0, X1
+	MOVUPS X1, 0(AX)
+	SETCS 16(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"mpsadsemantics": {
+			Name: "mpsadsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void mpsadsemantics(uint8_t *, const uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t out[17] = {0};
+  const uint8_t a[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+  const uint8_t b[16] = {0};
+  const uint16_t want[8] = {6, 10, 14, 18, 22, 26, 30, 34};
+  uint16_t got[8];
+  mpsadsemantics(out, a, b);
+  memcpy(got, out, 16);
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return 10 + i;
+  if (out[16] != 1) return 20;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "multiple_sad_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestAMD64DoubleSADRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT dbpsadsemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), CX
+	MOVQ b+16(FP), DX
+	MOVQ old+24(FP), R8
+	MOVQ mask+32(FP), R9
+	KMOVQ R9, K1
+	VMOVDQU8 0(CX), Z1
+	VMOVDQU8 0(DX), Z0
+	VMOVDQU16 0(R8), Z2
+	STC
+	VDBPSADBW $27, Z0, Z1, K1, Z2
+	VMOVDQU16 Z2, 0(AX)
+	VDBPSADBW.Z $228, Z0, Z1, K1, Z3
+	VMOVDQU16 Z3, 64(AX)
+	SETCS 128(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"dbpsadsemantics": {
+			Name: "dbpsadsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void dbpsadsemantics(uint8_t *, const uint8_t *, const uint8_t *, const uint16_t *, uint64_t);
+static void oracle(uint16_t *out, const uint8_t *src1, const uint8_t *src2, const uint16_t *old, unsigned imm, uint64_t mask, int zeroing) {
+  uint8_t shuffled[64];
+  for (int lane = 0; lane < 64; lane += 16)
+    for (int dword = 0; dword < 4; dword++)
+      for (int byte = 0; byte < 4; byte++)
+        shuffled[lane + dword * 4 + byte] = src2[lane + ((imm >> (2 * dword)) & 3) * 4 + byte];
+  for (int block = 0; block < 64; block += 8) {
+    for (int word = 0; word < 4; word++) {
+      unsigned sum = 0;
+      int src1_base = block + (word >= 2 ? 4 : 0);
+      int shuffled_base = block + word;
+      for (int byte = 0; byte < 4; byte++) {
+        int difference = (int)src1[src1_base + byte] - (int)shuffled[shuffled_base + byte];
+        sum += difference < 0 ? -difference : difference;
+      }
+      int index = block / 2 + word;
+      out[index] = (mask >> index) & 1 ? (uint16_t)sum : (zeroing ? 0 : old[index]);
+    }
+  }
+}
+int main(void) {
+  uint8_t a[64], b[64], bytes[129] = {0}; uint16_t old[32], got[64], want[64];
+  for (int i = 0; i < 64; i++) { a[i] = (uint8_t)(i * 7 + 3); b[i] = (uint8_t)(255 - i * 5); }
+  for (int i = 0; i < 32; i++) old[i] = (uint16_t)(1000 + i);
+  uint64_t mask = UINT64_C(0xa55aa55a);
+  dbpsadsemantics(bytes, a, b, old, mask);
+  memcpy(got, bytes, 128);
+  oracle(want, a, b, old, 27, mask, 0);
+  oracle(want + 32, a, b, old, 228, mask, 1);
+  for (int i = 0; i < 64; i++) if (got[i] != want[i]) return 10 + i;
+  if (bytes[128] != 1) return 80;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "double_sad_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_msr.go b/amd64_lower_msr.go
new file mode 100644
index 000000000..d19eaa063
--- /dev/null
+++ b/amd64_lower_msr.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerMSRAccess implements the complete RDMSR/WRMSR instruction family.
+// Go 1.27 uses the operand-free ynone optab entry for both instructions on
+// amd64 and 386; the architectural operands are ECX and EDX:EAX.
+func (c *amd64Ctx) lowerMSRAccess(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	switch baseOp {
+	case "RDMSR", "WRMSR":
+		// handled below
+	default:
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	cx, err := c.loadReg(CX)
+	if err != nil {
+		return true, false, err
+	}
+	cx32 := c.truncI64(cx, I32)
+	if baseOp == "RDMSR" {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call { i32, i32 } asm sideeffect \"rdmsr\", \"={ax},={dx},{cx},~{dirflag},~{fpsr},~{flags}\"(i32 %s)\n", call, cx32)
+		for index, reg := range []Reg{AX, DX} {
+			part := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue { i32, i32 } %%%s, %d\n", part, call, index)
+			if err := c.storeRegSized(reg, I32, "%"+part); err != nil {
+				return true, false, err
+			}
+		}
+		return true, false, nil
+	}
+
+	ax, err := c.loadReg(AX)
+	if err != nil {
+		return true, false, err
+	}
+	dx, err := c.loadReg(DX)
+	if err != nil {
+		return true, false, err
+	}
+	ax32 := c.truncI64(ax, I32)
+	dx32 := c.truncI64(dx, I32)
+	fmt.Fprintf(c.b, "  call void asm sideeffect \"wrmsr\", \"{ax},{dx},{cx},~{dirflag},~{fpsr},~{flags}\"(i32 %s, i32 %s, i32 %s)\n", ax32, dx32, cx32)
+	return true, false, nil
+}
diff --git a/amd64_lower_mul_dword_qword.go b/amd64_lower_mul_dword_qword.go
new file mode 100644
index 000000000..576d5b291
--- /dev/null
+++ b/amd64_lower_mul_dword_qword.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerDwordToQwordMultiply(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedPhysical(op, ins, x86PackedDwordProduct)
+}
+
+func (c *amd64Ctx) lowerDwordToQwordMultiplyForm(op Op, ins Instr, form x86PackedPhysicalForm) (bool, bool, error) {
+	var err error
+	first, second, destination := form.source, ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy dword product m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	if form.mmx {
+		if first.Kind == OpReg && first.Reg != ins.Args[form.first].Reg {
+			return true, false, fmt.Errorf("%w: Go GP-spelled dword product source names the MMX bank", ErrProbeNeedsContext)
+		}
+		var a string
+		if first.Kind == OpReg {
+			a, err = c.loadReg(first.Reg)
+		} else {
+			var bytes string
+			bytes, err = c.loadX86PackedShiftBytes(first, 8, true)
+			if err == nil {
+				value := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i8> %s to i64\n", value, bytes)
+				a = "%" + value
+			}
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		a = c.extendDwordScalar(c.lowDwordFromI64(a), false)
+		b = c.extendDwordScalar(c.lowDwordFromI64(b), false)
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", product, a, b)
+		return true, false, c.storeReg(destination.Reg, "%"+product)
+	}
+	lanes := form.byteWidth / 8
+	var mask, result string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if form.legacy && form.memory >= 0 {
+		b, err := c.loadPackedCompareLanes(second, 16, 64, false)
+		if err != nil {
+			return true, false, err
+		}
+		// Keep the original SSE opcode's complete m128 access and alignment
+		// behavior, including when the numerical result is dead.
+		result, err = c.emitPackedBinaryNativeMemory(first, 64, b, form.spec.nativeOpcode)
+	} else {
+		// EVEX E4 uses qword fault-suppression lanes, including m64bcst;
+		// only each qword's low dword participates in the multiplication.
+		var a, b string
+		a, err = c.loadDwordMultiplyEvenLanes(first, form.byteWidth, form.spec.memoryBits, form.broadcast, mask)
+		if err == nil {
+			b, err = c.loadDwordMultiplyEvenLanes(second, form.byteWidth, form.spec.memoryBits, false, "")
+		}
+		if err == nil {
+			a = c.extendDwordMultiplyLanes(a, lanes, form.spec.signed)
+			b = c.extendDwordMultiplyLanes(b, lanes, form.spec.signed)
+			product := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul <%d x i64> %s, %s\n", product, lanes, a, b)
+			result = "%" + product
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask >= 0 {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, 64, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, 64, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", out, lanes, result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func isAMD64XRegOperand(op Operand) bool {
+	return op.Kind == OpReg && isAMD64XReg(op.Reg)
+}
+
+func (c *amd64Ctx) loadDwordMultiplyEvenLanes(op Operand, byteWidth, memoryBits int, broadcast bool, mask string) (string, error) {
+	lanes := byteWidth / 8
+	qwords, err := c.loadX86PackedShiftLanes(op, byteWidth, memoryBits, broadcast, mask)
+	if err != nil {
+		return "", err
+	}
+	even := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc <%d x i64> %s to <%d x i32>\n", even, lanes, qwords, lanes)
+	return "%" + even, nil
+}
+
+func (c *amd64Ctx) extendDwordMultiplyLanes(value string, lanes int, signed bool) string {
+	extended := c.newTmp()
+	op := "zext"
+	if signed {
+		op = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i32> %s to <%d x i64>\n", extended, op, lanes, value, lanes)
+	return "%" + extended
+}
+
+func (c *amd64Ctx) lowDwordFromI64(value string) string {
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low, value)
+	return "%" + low
+}
+
+func (c *amd64Ctx) extendDwordScalar(value string, signed bool) string {
+	extended := c.newTmp()
+	op := "zext"
+	if signed {
+		op = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s to i64\n", extended, op, value)
+	return "%" + extended
+}
diff --git a/amd64_lower_mul_qword_test.go b/amd64_lower_mul_qword_test.go
new file mode 100644
index 000000000..6f0b7fc75
--- /dev/null
+++ b/amd64_lower_mul_qword_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedQwordMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 20
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			source := fmt.Sprintf(`
+TEXT packedqwordmultiplyforms(SB),4,$0-0
+	VPMULLQ X1, X20, X21
+	VPMULLQ 8(AX), Y20, Y21
+	VPMULLQ Z1, Z2, Z%d
+	VPMULLQ.BCST 40(AX), X20, X21
+	VPMULLQ.BCST 48(AX), Y20, Y21
+	VPMULLQ.BCST 56(AX), Z2, Z%d
+`, lastZ, lastZ)
+			if target.goarch == "amd64" {
+				source += `
+	VPMULLQ X1, X20, K1, X21
+	VPMULLQ.Z Y1, Y20, K2, Y21
+	VPMULLQ.BCST.Z 104(AX), Z20, K3, Z21
+`
+			}
+			source += "\tRET\n"
+			if target.goarch == "386" {
+				// Go accepts these high X/Y spellings, but syntax acceptance
+				// does not provide a physical high register in 32-bit mode.
+				// Their separate Context regression retains the original forms.
+				source = strings.NewReplacer("X20", "X6", "X21", "X7", "Y20", "Y6", "Y21", "Y7").Replace(source)
+			}
+			goAssemblerOracleOutput(t, target.goarch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"packedqwordmultiplyforms": {Name: "packedqwordmultiplyforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-qword-multiply-"+target.name+".ll", "packed-qword-multiply-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedQwordMultiplyRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMULLQ X0, X1",
+		"VPMULLQ X0, Y1, Y2",
+		"VPMULLQ X0, (AX), X2",
+		"VPMULLQ X0, X1, K0, X2",
+		"VPMULLQ X0, X1, AX",
+		"VPMULLQ.Z X0, X1, X2",
+		"VPMULLQ.BCST X0, X1, X2",
+		"VPMULLQ.Z.BCST (AX), X1, K1, X2",
+		"VPMULLQ.RN_SAE X0, X1, X2",
+	} {
+		assertX86PackedQwordMultiplyRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+	}
+	assertX86PackedQwordMultiplyRejected(t, "386", "i386-unknown-linux-gnu", "VPMULLQ X0, X1, K1, X2")
+	assertX86PackedQwordMultiplyRejected(t, "386", "i386-unknown-linux-gnu", "VPMULLQ Z0, Z1, Z8")
+}
+
+func assertX86PackedQwordMultiplyRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VPMULLQ forms", instruction)
+	}
+}
diff --git a/amd64_lower_muldiv_scalar.go b/amd64_lower_muldiv_scalar.go
new file mode 100644
index 000000000..b3701b56c
--- /dev/null
+++ b/amd64_lower_muldiv_scalar.go
@@ -0,0 +1,358 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerScalarMultiplyDivide implements the complete scalar x86 multiply and
+// divide families described by Go 1.27's ydivb, ydivl, yimul, and yimul3
+// tables. The one-operand forms use the architectural accumulator pairs;
+// IMULW/L/Q also have the table's explicit two- and three-operand forms.
+func (c *amd64Ctx) lowerScalarMultiplyDivide(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, terminated, err := c.lowerImplicitDivide(op, ins); known {
+		return known, terminated, err
+	}
+	name := strings.ToUpper(string(op))
+	stem, bits, threeOperandName, recognized := x86ScalarMultiplyDivideProperties(name)
+	if !recognized {
+		return false, false, nil
+	}
+	if c.goarch == "386" && bits == 64 {
+		return true, false, fmt.Errorf("386 %s is illegal in 32-bit mode: %q", name, ins.Raw)
+	}
+
+	if threeOperandName {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("%s %s expects immediate, source, destination register: %q", c.goarch, name, ins.Raw)
+		}
+		form, _, err := x86ExplicitIMULProperties(Op(name), ins, c.goarch)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.emitX86ExplicitIMUL(bits, form.immediate, form.source, form.destination)
+	}
+
+	if stem == "IMUL" && bits != 8 && len(ins.Args) != 1 {
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("%s %s expects one or two operands: %q", c.goarch, name, ins.Raw)
+		}
+		form, _, err := x86ExplicitIMULProperties(Op(name), ins, c.goarch)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.emitX86ExplicitIMUL(bits, Operand{}, form.source, form.destination)
+	}
+
+	if len(ins.Args) != 1 {
+		return true, false, fmt.Errorf("%s %s expects one GP-or-memory source: %q", c.goarch, name, ins.Raw)
+	}
+	if !isX86ScalarMultiplyDivideSource(ins.Args[0], bits, c.goarch) {
+		return true, false, fmt.Errorf("%s %s source is outside Go 1.27's %s class: %q", c.goarch, name, x86ScalarMultiplyDivideSourceClass(bits), ins.Raw)
+	}
+	if (stem == "MUL" || stem == "IMUL") && x86ResultNamedPredicateInstruction(ins) {
+		if _, _, err := x86ImplicitMultiplyProperties(op, ins, c.goarch); err != nil {
+			return true, false, err
+		}
+	}
+
+	switch stem {
+	case "MUL":
+		return true, false, c.emitX86ImplicitMultiply(bits, false, ins.Args[0], x86ResultNamedPredicateInstruction(ins))
+	case "IMUL":
+		return true, false, c.emitX86ImplicitMultiply(bits, true, ins.Args[0], x86ResultNamedPredicateInstruction(ins))
+	default:
+		panic("unreachable scalar multiply/divide stem")
+	}
+}
+
+func x86ScalarMultiplyDivideProperties(op string) (stem string, bits int, threeOperandName bool, ok bool) {
+	switch op {
+	case "MULB":
+		return "MUL", 8, false, true
+	case "MULW":
+		return "MUL", 16, false, true
+	case "MULL":
+		return "MUL", 32, false, true
+	case "MULQ":
+		return "MUL", 64, false, true
+	case "IMULB":
+		return "IMUL", 8, false, true
+	case "IMULW":
+		return "IMUL", 16, false, true
+	case "IMULL":
+		return "IMUL", 32, false, true
+	case "IMULQ":
+		return "IMUL", 64, false, true
+	case "IMUL3W":
+		return "IMUL", 16, true, true
+	case "IMUL3L":
+		return "IMUL", 32, true, true
+	case "IMUL3Q":
+		return "IMUL", 64, true, true
+	case "DIVB":
+		return "DIV", 8, false, true
+	case "DIVW":
+		return "DIV", 16, false, true
+	case "DIVL":
+		return "DIV", 32, false, true
+	case "DIVQ":
+		return "DIV", 64, false, true
+	case "IDIVB":
+		return "IDIV", 8, false, true
+	case "IDIVW":
+		return "IDIV", 16, false, true
+	case "IDIVL":
+		return "IDIV", 32, false, true
+	case "IDIVQ":
+		return "IDIV", 64, false, true
+	default:
+		return "", 0, false, false
+	}
+}
+
+func x86ScalarMultiplyDivideSourceClass(bits int) string {
+	if bits == 8 {
+		return "Ymb"
+	}
+	return "Yml"
+}
+
+func isX86ScalarMultiplyDivideSource(operand Operand, bits int, goarch string) bool {
+	if operand.Kind == OpReg {
+		if bits == 8 {
+			return isGoYmbRegisterForArch(operand.Reg, goarch)
+		}
+		return isX86YrlRegisterForArch(operand.Reg, goarch)
+	}
+	if operand.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+		return false
+	}
+	return isAMD64MemoryOperand(operand)
+}
+
+func validateX86ExplicitIMUL(goarch, op string, bits int, ins Instr, threeOperands bool) error {
+	immediate := Operand{}
+	source := ins.Args[0]
+	destination := ins.Args[1]
+	if threeOperands {
+		immediate = ins.Args[0]
+		source = ins.Args[1]
+		destination = ins.Args[2]
+	}
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, goarch) {
+		return fmt.Errorf("%s %s destination is outside Go 1.27's Yrl class: %q", goarch, op, ins.Raw)
+	}
+	if threeOperands {
+		if !isX86IMULImmediate(immediate, goarch) {
+			return fmt.Errorf("%s %s immediate is outside Go 1.27's Yi8/Yi32 classes: %q", goarch, op, ins.Raw)
+		}
+		if !isX86ScalarMultiplyDivideSource(source, bits, goarch) {
+			return fmt.Errorf("%s %s source is outside Go 1.27's Yml class: %q", goarch, op, ins.Raw)
+		}
+		return nil
+	}
+	if source.Kind == OpImm {
+		if !isX86IMULImmediate(source, goarch) {
+			return fmt.Errorf("%s %s immediate is outside Go 1.27's Yi8/Yi32 classes: %q", goarch, op, ins.Raw)
+		}
+		return nil
+	}
+	if !isX86ScalarMultiplyDivideSource(source, bits, goarch) {
+		return fmt.Errorf("%s %s source is outside Go 1.27's Yml class: %q", goarch, op, ins.Raw)
+	}
+	return nil
+}
+
+func isX86IMULImmediate(operand Operand, goarch string) bool {
+	if operand.Kind != OpImm {
+		return false
+	}
+	// The 386 assembler classifies constants after truncating them to int32.
+	// In amd64 mode Yi32 covers signed int32 through unsigned uint32.
+	return goarch == "386" || (operand.Imm >= -2147483648 && operand.Imm <= 4294967295)
+}
+
+func (c *amd64Ctx) emitX86ImplicitMultiply(bits int, signed bool, source Operand, named bool) error {
+	narrow := amd64IntegerTypeForBits(bits)
+	wide := x86ScalarMultiplyDivideWideType(bits)
+	var src string
+	var err error
+	handled := false
+	if named && source.Kind == OpFP {
+		src, handled, err = c.loadIntegerFPBytesMode(source.FPOffset, narrow, true)
+	} else if named && x86RegisterAddressedNativeMemoryOperand(source, c.goarch) && source.Mem.Segment == "" {
+		// Keep the exact source access even for a zero accumulator or dead
+		// product. Address and AX inputs precede either implicit overwrite;
+		// this emitter creates no caller, frame or reusable memory fact.
+		src, err = c.evalSizedNativeGPSource(source, narrow, 0)
+		handled = true
+	}
+	if !handled && err == nil {
+		src, err = c.evalIntSized(source, narrow)
+	}
+	if err != nil {
+		return err
+	}
+	acc, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, narrow)
+	if err != nil {
+		return err
+	}
+	lhs := c.extendX86MulDivValue(acc, narrow, wide, signed)
+	rhs := c.extendX86MulDivValue(src, narrow, wide, signed)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, wide, lhs, rhs)
+
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", low, wide, product, narrow)
+	if bits == 8 {
+		if err := c.storeRegSized(AX, I16, "%"+product); err != nil {
+			return err
+		}
+	} else {
+		shifted := c.newTmp()
+		shift := "lshr"
+		if signed {
+			shift = "ashr"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %d\n", shifted, shift, wide, product, bits)
+		high := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", high, wide, shifted, narrow)
+		if err := c.storeRegSized(AX, narrow, "%"+low); err != nil {
+			return err
+		}
+		if err := c.storeRegSized(DX, narrow, "%"+high); err != nil {
+			return err
+		}
+	}
+	c.setX86MultiplyOverflowFlags(narrow, wide, "%"+low, "%"+product, signed)
+	return nil
+}
+
+func (c *amd64Ctx) emitX86ExplicitIMUL(bits int, immediate, source, destination Operand) error {
+	typ := amd64IntegerTypeForBits(bits)
+	wide := x86ScalarMultiplyDivideWideType(bits)
+	right := ""
+	var err error
+	if source.Kind == OpImm {
+		right = x86IMULImmediateValue(source.Imm, bits)
+	} else {
+		right, err = c.evalSizedNativeGPSource(source, typ, 0)
+		if err != nil {
+			return err
+		}
+	}
+	left := ""
+	if immediate.Kind == OpImm {
+		left = x86IMULImmediateValue(immediate.Imm, bits)
+	} else {
+		left, err = c.evalIntSized(destination, typ)
+		if err != nil {
+			return err
+		}
+	}
+	lhs := c.extendX86MulDivValue(left, typ, wide, true)
+	rhs := c.extendX86MulDivValue(right, typ, wide, true)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, wide, lhs, rhs)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", low, wide, product, typ)
+	if err := c.storeRegSized(destination.Reg, typ, "%"+low); err != nil {
+		return err
+	}
+	c.setX86MultiplyOverflowFlags(typ, wide, "%"+low, "%"+product, true)
+	return nil
+}
+
+func x86IMULImmediateValue(value int64, bits int) string {
+	return fmt.Sprintf("%d", x86IMULEncodedImmediate(value, bits))
+}
+
+// The explicit IMUL emitter uses evalSizedNativeGPSource's exact volatile read.
+// Continuing past it supplies only this instruction's numerical source bytes;
+// the existing effect still owns old-destination, immediate and FLAGS roles.
+func x86LoweredExplicitIMULNativeRead(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ExplicitIMULProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.source.Kind != OpMem || form.source.Mem.Sym != "" ||
+		!x86OrdinaryNativeMemoryOperand(form.source, arch) || ins.x86NumericalRead != nil {
+		return false, false // Logical fields, static sources and actual source certificates keep their own consumers.
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	effect := x86ExplicitIMULByteEffect(form)
+	if effect.dynamicMemory || state.flags&effect.flagsRead != effect.flagsRead {
+		return false, true
+	}
+	for _, operand := range effect.operands {
+		if !operand.read {
+			continue
+		}
+		if operand.operand.Kind == OpReg {
+			index, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+			if !valid || state.pointerGP[index] {
+				return false, true
+			}
+		}
+		if !x86ResultReadWithNativeGPContinuation(ins, operand.operand, operand.width, state, owned, arch) {
+			return false, true
+		}
+	}
+	for _, operand := range effect.operands {
+		if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
+
+func x86IMULEncodedImmediate(value int64, bits int) int64 {
+	switch bits {
+	case 16:
+		return int64(int16(value))
+	case 32:
+		return int64(int32(value))
+	case 64:
+		// x86-64 IMUL encodes this table's immediate as imm32 and sign
+		// extends it to the qword operand width.
+		return int64(int32(value))
+	default:
+		panic("unsupported explicit IMUL width")
+	}
+}
+
+func (c *amd64Ctx) extendX86MulDivValue(value string, from, to LLVMType, signed bool) string {
+	tmp := c.newTmp()
+	op := "zext"
+	if signed {
+		op = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", tmp, op, from, value, to)
+	return "%" + tmp
+}
+
+func x86ScalarMultiplyDivideWideType(bits int) LLVMType {
+	if bits == 64 {
+		return LLVMType("i128")
+	}
+	return amd64IntegerTypeForBits(bits * 2)
+}
+
+func (c *amd64Ctx) setX86MultiplyOverflowFlags(narrow, wide LLVMType, low, product string, signed bool) {
+	var overflow string
+	if signed {
+		extended := c.extendX86MulDivValue(low, narrow, wide, true)
+		cmp := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %s, %s\n", cmp, wide, product, extended)
+		overflow = "%" + cmp
+	} else {
+		extended := c.extendX86MulDivValue(low, narrow, wide, false)
+		cmp := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %s, %s\n", cmp, wide, product, extended)
+		overflow = "%" + cmp
+	}
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", overflow, c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", overflow, c.flagsOFSlot)
+}
diff --git a/amd64_lower_mulword.go b/amd64_lower_mulword.go
new file mode 100644
index 000000000..440b2a318
--- /dev/null
+++ b/amd64_lower_mulword.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedWordMultiplyMode uint8
+
+const (
+	amd64PackedWordMultiplyLow amd64PackedWordMultiplyMode = iota
+	amd64PackedWordMultiplySignedHigh
+	amd64PackedWordMultiplyUnsignedHigh
+	amd64PackedWordMultiplyRoundedSignedHigh
+)
+
+func (c *amd64Ctx) lowerPackedWordMultiply(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedPhysical(op, ins, x86PackedWordProduct)
+}
+
+func (c *amd64Ctx) lowerPackedWordMultiplyForm(op Op, ins Instr, form x86PackedPhysicalForm) (bool, bool, error) {
+	first, second, destination := form.source, ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed word multiply m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	lanes := form.byteWidth / 2
+	if form.mmx {
+		// A GP source accepted through ycover encodes an MMX register; it
+		// must never consume the unrelated GP shadow as its input value.
+		if first.Kind == OpReg && first.Reg != ins.Args[form.first].Reg {
+			return true, false, fmt.Errorf("%w: Go GP-spelled packed multiply source names the MMX bank", ErrProbeNeedsContext)
+		}
+		var a string
+		var err error
+		if first.Kind == OpReg {
+			a, err = c.loadReg(first.Reg)
+		} else {
+			a, err = c.loadPackedUnpackMMXSource(first, 8)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		value := c.emitPackedWordMultiply(lanes, c.bitcastI64ToIntegerLanes(lanes, 16, a), c.bitcastI64ToIntegerLanes(lanes, 16, b), form.spec.mode)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to i64\n", out, lanes, value)
+		return true, false, c.storeReg(destination.Reg, "%"+out)
+	}
+	mnemonic := ""
+	if form.legacy && form.memory >= 0 {
+		mnemonic = strings.ToLower(string(op))
+	}
+	return true, false, c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, form.spec.memoryBits,
+		mnemonic, func(lanes, bits int, first, second string) string {
+			return c.emitPackedWordMultiply(lanes, first, second, form.spec.mode)
+		})
+}
+
+func (c *amd64Ctx) emitPackedWordMultiply(lanes int, first, second string, mode amd64PackedWordMultiplyMode) string {
+	wordType := fmt.Sprintf("<%d x i16>", lanes)
+	if mode == amd64PackedWordMultiplyLow {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", result, wordType, second, first)
+		return "%" + result
+	}
+
+	wideType := fmt.Sprintf("<%d x i32>", lanes)
+	extend := "sext"
+	shift := int64(16)
+	if mode == amd64PackedWordMultiplyUnsignedHigh {
+		extend = "zext"
+	}
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", firstWide, extend, wordType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", secondWide, extend, wordType, second, wideType)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", product, wideType, secondWide, firstWide)
+	value := "%" + product
+	if mode == amd64PackedWordMultiplyRoundedSignedHigh {
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", rounded, wideType, value, llvmSplatSignedInteger(lanes, 32, 16384))
+		value = "%" + rounded
+		shift = 15
+	}
+	shifted := c.newTmp()
+	shiftOp := "ashr"
+	if mode == amd64PackedWordMultiplyUnsignedHigh {
+		shiftOp = "lshr"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", shifted, shiftOp, wideType, value, llvmSplatSignedInteger(lanes, 32, shift))
+	value = "%" + shifted
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", result, wideType, value, wordType)
+	return "%" + result
+}
diff --git a/amd64_lower_mxcsr.go b/amd64_lower_mxcsr.go
new file mode 100644
index 000000000..c86f817ff
--- /dev/null
+++ b/amd64_lower_mxcsr.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerMXCSR(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Op == "" {
+		ins.Op = op
+	} else if !strings.EqualFold(string(ins.Op), string(op)) {
+		if _, known, _ := x86MXCSRProperties(Instr{Op: op}, c.goarch); known {
+			return true, false, fmt.Errorf("MXCSR helper/source identity differs: %s/%s", op, ins.Op)
+		}
+		return false, false, nil
+	}
+	write, known, err := x86MXCSRProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	baseOp := strings.ToUpper(string(op))
+	if memory := ins.Args[0]; memory.Kind == OpMem && memory.Mem.Sym == "" &&
+		c.nativeMemoryOperand(ins, 0) {
+		pointer, pointerType, err := c.ptrFromMem(memory.Mem)
+		if err != nil {
+			return true, false, err
+		}
+		constraint := "*m,~{memory}"
+		if write {
+			constraint = "=*m,~{memory}"
+		}
+		// One original native m32 operation retains exact access/fault and
+		// legacy/VEX identity, even when no numerical result is observed.
+		// MXCSR does not modify integer FLAGS, DF or any GP register.
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype(i32) %s)\n",
+			strings.ToLower(baseOp)+" $0", constraint, pointerType, pointer)
+		return true, false, nil
+	}
+	slot := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = alloca i32\n", slot)
+	switch baseOp {
+	case "LDMXCSR", "VLDMXCSR":
+		value, err := c.evalIntSized(ins.Args[0], I32)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  store i32 %s, ptr %%%s\n", value, slot)
+		fmt.Fprintf(c.b, "  call void @llvm.x86.sse.ldmxcsr(ptr %%%s)\n", slot)
+		return true, false, nil
+	case "STMXCSR", "VSTMXCSR":
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  call void @llvm.x86.sse.stmxcsr(ptr %%%s)\n", slot)
+		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %%%s\n", value, slot)
+		if err := c.storeMXCSRMemory(ins.Args[0], "%"+value); err != nil {
+			return true, false, err
+		}
+		return true, false, nil
+	default:
+		panic("MXCSR opcode precheck drift")
+	}
+}
+
+// The paired original opcode either faults or continues. This lowering-only
+// consumer checks actual incoming pointer/index identity, not numerical address
+// bits, pointee initializedness, bounds or a reusable caller-memory permission.
+func x86LoweredNativeMXCSRStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	write, known, err := x86MXCSRProperties(ins, arch)
+	if !known || err != nil || len(ins.Args) != 1 || ins.Args[0].Kind != OpMem ||
+		ins.Args[0].Mem.Sym != "" || !x86OrdinaryNativeMemoryOperand(ins.Args[0], arch) {
+		return false, false
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, true
+	}
+	if write {
+		return x86ResultIncomingPointerAddressIdentity(ins.Args[0], state, arch), true
+	}
+	return x86ResultIncomingPointerReadAddressIdentity(ins.Args[0], state, arch), true
+}
+
+func (c *amd64Ctx) storeMXCSRMemory(dst Operand, value string) error {
+	switch dst.Kind {
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i32 %s, %s %s, align 1\n", value, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i32 %s, ptr %s, align 1\n", value, ptr)
+		return nil
+	case OpFP:
+		return c.storeFPResult(dst.FPOffset, I32, value)
+	default:
+		return fmt.Errorf("amd64: unsupported MXCSR memory operand %s", dst.String())
+	}
+}
diff --git a/amd64_lower_narrow_single_source.go b/amd64_lower_narrow_single_source.go
new file mode 100644
index 000000000..2dbdf04bd
--- /dev/null
+++ b/amd64_lower_narrow_single_source.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type x86SingleSourceNarrowDomain uint8
+
+const (
+	x86NarrowTruncate x86SingleSourceNarrowDomain = iota
+	x86NarrowSigned
+	x86NarrowUnsigned
+)
+
+type amd64SingleSourceNarrowSpec struct {
+	inputBits, outputBits int
+	domain                x86SingleSourceNarrowDomain
+}
+
+var amd64SingleSourceNarrowSpecs = map[string]amd64SingleSourceNarrowSpec{
+	"VPMOVDB":   {inputBits: 32, outputBits: 8},
+	"VPMOVDW":   {inputBits: 32, outputBits: 16},
+	"VPMOVQB":   {inputBits: 64, outputBits: 8},
+	"VPMOVQD":   {inputBits: 64, outputBits: 32},
+	"VPMOVQW":   {inputBits: 64, outputBits: 16},
+	"VPMOVWB":   {inputBits: 16, outputBits: 8},
+	"VPMOVSDB":  {inputBits: 32, outputBits: 8, domain: x86NarrowSigned},
+	"VPMOVSDW":  {inputBits: 32, outputBits: 16, domain: x86NarrowSigned},
+	"VPMOVSQB":  {inputBits: 64, outputBits: 8, domain: x86NarrowSigned},
+	"VPMOVSQD":  {inputBits: 64, outputBits: 32, domain: x86NarrowSigned},
+	"VPMOVSQW":  {inputBits: 64, outputBits: 16, domain: x86NarrowSigned},
+	"VPMOVSWB":  {inputBits: 16, outputBits: 8, domain: x86NarrowSigned},
+	"VPMOVUSDB": {inputBits: 32, outputBits: 8, domain: x86NarrowUnsigned},
+	"VPMOVUSDW": {inputBits: 32, outputBits: 16, domain: x86NarrowUnsigned},
+	"VPMOVUSQB": {inputBits: 64, outputBits: 8, domain: x86NarrowUnsigned},
+	"VPMOVUSQD": {inputBits: 64, outputBits: 32, domain: x86NarrowUnsigned},
+	"VPMOVUSQW": {inputBits: 64, outputBits: 16, domain: x86NarrowUnsigned},
+	"VPMOVUSWB": {inputBits: 16, outputBits: 8, domain: x86NarrowUnsigned},
+}
+
+// lowerSingleSourceIntegerNarrow implements the complete Go 1.27
+// _yvpmovdb/_yvpmovdw family: truncating, signed-saturating, and
+// unsigned-saturating conversions from X/Y/Z into X/Y or memory.
+func (c *amd64Ctx) lowerSingleSourceIntegerNarrow(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86SingleSourceNarrowProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if form.undefinedOpcode() {
+		return c.lowerX86UndefinedTrap(op, ins)
+	}
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	sourceBytes, err := c.loadPackedCompareBytes(ins.Args[0], form.inputBytes)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.inputBytes * 8 / form.spec.inputBits
+	source := c.bitcastVectorBytesToIntegerLanes(form.inputBytes, lanes, form.spec.inputBits, sourceBytes)
+	narrowed := c.emitSingleSourceIntegerNarrow(form.spec, lanes, source)
+	destination := ins.Args[form.destination]
+	if form.memory < 0 {
+		return true, false, c.storeSingleSourceNarrowRegister(destination.Reg, form.carrierBytes,
+			lanes, form.spec.outputBits, narrowed, mask, form.zeroing)
+	}
+	return true, false, c.storeSingleSourceNarrowMemory(destination, form.outputBytes,
+		lanes, form.spec.outputBits, narrowed, mask)
+}
+
+func (c *amd64Ctx) emitSingleSourceIntegerNarrow(spec amd64SingleSourceNarrowSpec, lanes int, source string) string {
+	inputType := fmt.Sprintf("<%d x i%d>", lanes, spec.inputBits)
+	outputType := fmt.Sprintf("<%d x i%d>", lanes, spec.outputBits)
+	if spec.domain != x86NarrowTruncate {
+		// Single-source US conversions consume unsigned inputs. PACKUS has
+		// signed inputs and deliberately keeps its separate saturation rule.
+		predicate := "ugt"
+		maximum := uint64(1)<<spec.outputBits - 1
+		if spec.domain == x86NarrowSigned {
+			predicate = "sgt"
+			maximum >>= 1
+		}
+		limit := llvmSplatInteger(lanes, spec.inputBits, maximum)
+		above, capped := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp %s %s %s, %s\n", above, predicate, inputType, source, limit)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", capped, lanes, above, inputType, limit, inputType, source)
+		source = "%" + capped
+		if spec.domain == x86NarrowSigned {
+			minimum := llvmSplatIntegerText(lanes, spec.inputBits, fmt.Sprint(-int64(maximum)-1))
+			below, floored := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, %s\n", below, inputType, source, minimum)
+			fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", floored, lanes, below, inputType, minimum, inputType, source)
+			source = "%" + floored
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", result, inputType, source, outputType)
+	return "%" + result
+}
+
+func (c *amd64Ctx) storeSingleSourceNarrowRegister(destination Reg, destinationBytes, lanes, outputBits int, narrowed, mask string, zeroing bool) error {
+	physicalLanes := destinationBytes * 8 / outputBits
+	result := "zeroinitializer"
+	var old string
+	if mask != "" && !zeroing {
+		oldBytes, err := c.loadPackedCompareBytes(Operand{Kind: OpReg, Reg: destination}, destinationBytes)
+		if err != nil {
+			return err
+		}
+		old = c.bitcastVectorBytesToIntegerLanes(destinationBytes, physicalLanes, outputBits, oldBytes)
+	}
+	for lane := 0; lane < lanes; lane++ {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", value, lanes, outputBits, narrowed, lane)
+		selected := "%" + value
+		if mask != "" {
+			fallback := "0"
+			if !zeroing {
+				oldValue := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", oldValue, physicalLanes, outputBits, old, lane)
+				fallback = "%" + oldValue
+			}
+			masked := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %s, i%d %s\n", masked, amd64MaskBitI1(c, mask, lane), outputBits, selected, outputBits, fallback)
+			selected = "%" + masked
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, physicalLanes, outputBits, result, outputBits, selected, lane)
+		result = "%" + inserted
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, physicalLanes, outputBits, result, destinationBytes)
+	return c.storePackedMoveOperand(Operand{Kind: OpReg, Reg: destination}, destinationBytes, "%"+out)
+}
+
+func (c *amd64Ctx) storeSingleSourceNarrowMemory(destination Operand, outputBytes, lanes, outputBits int, narrowed, mask string) error {
+	if mask != "" {
+		pointer, pointerType, suffix, err := c.packedVectorMemoryPointer(destination)
+		if err != nil {
+			return err
+		}
+		if suffix == "" {
+			suffix = ".p0"
+		}
+		predicate := amd64IntegerMaskVector(c, lanes, mask)
+		fmt.Fprintf(c.b, "  call void @llvm.masked.store.v%di%d%s(<%d x i%d> %s, %s align 1 %s, <%d x i1> %s)\n", lanes, outputBits, suffix, lanes, outputBits, narrowed, pointerType, pointer, lanes, predicate)
+		return nil
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, outputBits, narrowed, outputBytes)
+	return c.storeNarrowMemoryBytes(destination, outputBytes, "%"+out)
+}
+
+func (c *amd64Ctx) storeNarrowMemoryBytes(destination Operand, byteWidth int, value string) error {
+	if byteWidth >= 16 {
+		return c.storeVectorBytesOperand(destination, byteWidth, value)
+	}
+	typ := amd64IntegerTypeForBits(byteWidth * 8)
+	integer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", integer, byteWidth, value, typ)
+	return c.storeVectorScalarMemory(destination, byteWidth*8, "%"+integer, "")
+}
diff --git a/amd64_lower_narrow_single_source_test.go b/amd64_lower_narrow_single_source_test.go
new file mode 100644
index 000000000..361d3630e
--- /dev/null
+++ b/amd64_lower_narrow_single_source_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86SingleSourceIntegerNarrowCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 31
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT singlesourcenarrowforms(SB),$0-0\n")
+			for _, op := range []string{
+				"VPMOVDB", "VPMOVDW", "VPMOVQB", "VPMOVQD", "VPMOVQW", "VPMOVWB",
+				"VPMOVSDB", "VPMOVSDW", "VPMOVSQB", "VPMOVSQD", "VPMOVSQW", "VPMOVSWB",
+				"VPMOVUSDB", "VPMOVUSDW", "VPMOVUSQB", "VPMOVUSQD", "VPMOVUSQW", "VPMOVUSWB",
+			} {
+				inputBits, outputBits := x86SingleSourceNarrowTestBits(op)
+				for _, width := range []struct {
+					name  string
+					bytes int
+				}{
+					{name: "X", bytes: 16},
+					{name: "Y", bytes: 32},
+					{name: "Z", bytes: 64},
+				} {
+					outputBytes := width.bytes * outputBits / inputBits
+					destinationWidth := "X"
+					if outputBytes > 16 {
+						destinationWidth = "Y"
+					}
+					fmt.Fprintf(&source, "\t%s %s%d, %s%d\n", op, width.name, last, destinationWidth, last)
+					fmt.Fprintf(&source, "\t%s %s%d, K1, %s%d\n", op, width.name, last, destinationWidth, last)
+					fmt.Fprintf(&source, "\t%s.Z %s%d, K2, %s%d\n", op, width.name, last, destinationWidth, last)
+					fmt.Fprintf(&source, "\t%s %s%d, 8(AX)\n", op, width.name, last)
+					fmt.Fprintf(&source, "\t%s %s%d, K3, 16(AX)\n", op, width.name, last)
+					fmt.Fprintf(&source, "\t%s.Z %s%d, K4, 24(AX)\n", op, width.name, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"singlesourcenarrowforms": {Name: "singlesourcenarrowforms", Ret: Void},
+				},
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("bare Go formats invented initialized entry registers or memory", err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			// Preserve every original operand and all 324 Go-encoded shapes as
+			// isolated emitter units. Initialized public objects and executable
+			// numerical/fault owners are independent of these format objects.
+			units, signatures := x86SingleSourceNarrowingFormatUnits(file)
+			if len(units.Funcs) != 324 {
+				t.Fatal("an original Go format disappeared", len(units.Funcs))
+			}
+			x86SingleSourceNarrowingFormatObjects(t, llc, units, signatures, target.goarch, target.triple)
+		})
+	}
+}
+
+func x86SingleSourceNarrowingFormatUnits(file *File) (*File, map[string]FuncSig) {
+	units := *file
+	units.Funcs = nil
+	signatures := make(map[string]FuncSig)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT || ins.Op == OpRET {
+				continue
+			}
+			name := fmt.Sprint("NarrowFormat", len(units.Funcs))
+			units.Funcs = append(units.Funcs, Func{Sym: name, Instrs: []Instr{{Op: OpTEXT}, ins, {Op: OpRET}}})
+			signatures[name] = FuncSig{Name: name, Ret: Void}
+		}
+	}
+	return &units, signatures
+}
+
+func x86SingleSourceNarrowingFormatObjects(t *testing.T, llc string, units *File, signatures map[string]FuncSig, arch, triple string) {
+	t.Helper()
+	for start := 0; start < len(units.Funcs); start += 64 {
+		end := start + 64
+		if end > len(units.Funcs) {
+			end = len(units.Funcs)
+		}
+		batch := *units
+		batch.Funcs = units.Funcs[start:end]
+		ir := x86SingleInstructionFormatObjectUnits(t, &batch, signatures, arch, triple,
+			func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerSingleSourceIntegerNarrow(ins.Op, ins) })
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, triple, ir, level)
+		}
+	}
+}
+
+func x86SingleSourceNarrowTestBits(op string) (inputBits, outputBits int) {
+	pair := strings.TrimPrefix(strings.TrimPrefix(strings.TrimPrefix(op, "VPMOV"), "US"), "S")
+	bits := func(letter byte) int {
+		switch letter {
+		case 'B':
+			return 8
+		case 'W':
+			return 16
+		case 'D':
+			return 32
+		case 'Q':
+			return 64
+		default:
+			panic("bad narrow element letter")
+		}
+	}
+	return bits(pair[0]), bits(pair[1])
+}
+
+func TestTranslateX86SingleSourceIntegerNarrowRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMOVSDB 8(AX), X0",
+		"VPMOVSDB X0, Y0",
+		"VPMOVSDW Z0, X0",
+		"VPMOVSDB X0, K0, X1",
+		"VPMOVSDB.Z X0, X1",
+		"VPMOVSDB.BCST X0, X1",
+		"VPMOVSDB X0, K1, K2, X1",
+		"VPMOVSDB X0, AX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Goarch:       "amd64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvpmovdb/_yvpmovdw tables", instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_neg.go b/amd64_lower_neg.go
new file mode 100644
index 000000000..dc3841d3e
--- /dev/null
+++ b/amd64_lower_neg.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import "fmt"
+
+// Both complete unary families use Go's yscond(Ymb) grammar, including
+// byte-register spellings of wide operations. Only NEG changes flags.
+type x86UnaryYmbSpec struct {
+	bits   int
+	negate bool
+}
+
+var x86UnaryYmbSpecs = map[Op]x86UnaryYmbSpec{
+	"NEGB": {bits: 8, negate: true},
+	"NEGW": {bits: 16, negate: true},
+	"NEGL": {bits: 32, negate: true},
+	"NEGQ": {bits: 64, negate: true},
+	"NOTB": {bits: 8},
+	"NOTW": {bits: 16},
+	"NOTL": {bits: 32},
+	"NOTQ": {bits: 64},
+}
+
+func (c *amd64Ctx) lowerScalarUnaryYmb(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, recognized := x86UnaryYmbSpecs[op]
+	if !recognized {
+		return false, false, nil
+	}
+	bits := spec.bits
+	if c.goarch == "386" && bits == 64 {
+		return true, false, fmt.Errorf("386 %s is illegal in 32-bit mode: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 1 {
+		return true, false, fmt.Errorf("%s %s expects one register/memory operand: %q", c.goarch, op, ins.Raw)
+	}
+	destination := ins.Args[0]
+	if destination.Kind == OpReg {
+		if !isGoYmbRegisterForArch(destination.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%s %s register is outside Go 1.27's Ymb class: %q", c.goarch, op, ins.Raw)
+		}
+		destination.Reg = amd64YmbEffectiveRegister(destination.Reg, bits)
+	} else if !isAMD64MemoryOperand(destination) {
+		return true, false, fmt.Errorf("%s %s operand is outside Go 1.27's Ymb class: %q", c.goarch, op, ins.Raw)
+	}
+
+	typ := amd64IntegerTypeForBits(bits)
+	value, store, err := c.loadScalarRMWDestination(op, ins, destination, typ)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if !spec.negate {
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", result, typ, value)
+		return true, false, store("%" + result)
+	}
+	fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", result, typ, value)
+	if err := store("%" + result); err != nil {
+		return true, false, err
+	}
+	// NEG has the same arithmetic flags as subtraction from zero: CF is set
+	// exactly for nonzero inputs and OF is set only for the signed minimum.
+	c.setScalarAddSubFlags(typ, false, "0", value, "%"+result)
+	return true, false, nil
+}
diff --git a/amd64_lower_neg_test.go b/amd64_lower_neg_test.go
new file mode 100644
index 000000000..4a4071609
--- /dev/null
+++ b/amd64_lower_neg_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86UnaryYmbGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A((?:NEG|NOT)[BWLQ]),\s*yscond,`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != len(x86UnaryYmbSpecs) || len(rows) != 8 {
+		t.Fatalf("Go encoder has %d NEG/NOT Ymb rows; grammar has %d", len(rows), len(x86UnaryYmbSpecs))
+	}
+	for _, row := range rows {
+		name := row[1]
+		spec, ok := x86UnaryYmbSpecs[Op(name)]
+		width := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[name[len(name)-1]]
+		if !ok || spec.bits != width || spec.negate != strings.HasPrefix(name, "NEG") {
+			t.Errorf("Go %s encoder row disagrees with grammar: %+v, present=%v", name, spec, ok)
+		}
+	}
+}
+
+func x86NEGCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	symbol := "negdata"
+	size := 8
+	if goarch == "386" {
+		symbol = "negdata386"
+		size = 4
+	}
+	fmt.Fprintf(&source, "DATA %s+0(SB)/%d, $1\n", symbol, size)
+	fmt.Fprintf(&source, "GLOBL %s(SB), $%d\n", symbol, size)
+	source.WriteString("TEXT negforms(SB),$0-0\n")
+	if goarch == "amd64" {
+		source.WriteString("\tNEGB AH\n\tNEGB R11\n")
+	} else {
+		source.WriteString("\tNEGB AH\n\tNEGB BP\n")
+	}
+	source.WriteString("\tNEGB 8(BX)\n\tNEGB " + symbol + "(SB)\n")
+	widths := []string{"W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	for _, width := range widths {
+		// yscond uses Ymb even for wide opcodes. Byte spellings therefore
+		// select the full register with the same raw ModRM number.
+		for _, reg := range []string{"AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"} {
+			fmt.Fprintf(&source, "\tNEG%s %s\n", width, reg)
+		}
+		fmt.Fprintf(&source, "\tNEG%s DX\n", width)
+		if goarch == "amd64" {
+			for _, reg := range []string{"SP", "BPB", "SIB", "DIB", "R8", "R15", "R8B", "R15B"} {
+				fmt.Fprintf(&source, "\tNEG%s %s\n", width, reg)
+			}
+		} else {
+			fmt.Fprintf(&source, "\tNEG%s SI\n", width)
+		}
+		fmt.Fprintf(&source, "\tNEG%s 8(BX)\n\tNEG%s %s(SB)\n", width, width, symbol)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86NEGCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86NEGCompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func negforms()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original scalar format source invented mutable/native/frame inputs", api, err)
+				}
+			}
+			ll := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"negforms": {Name: "negforms", Ret: Void}},
+				target.goarch, target.triple, 0)
+			for _, want := range []string{"sub i8 0", "sub i16 0", "sub i32 0", "store i1"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("NEG lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ll, "sub i64 0") {
+				t.Fatalf("NEGQ lowering omitted sub i64:\n%s", ll)
+			}
+			for _, ir := range []string{ll, x86DwordProductIROptimize(t, ll)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86NEGRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "NEGB X0"},
+		{goarch: "amd64", instruction: "NEGW $1"},
+		{goarch: "amd64", instruction: "NEGL AX, BX"},
+		{goarch: "amd64", instruction: "NEGQ"},
+		{goarch: "amd64", instruction: "NEGQ.Z AX"},
+		{goarch: "386", instruction: "NEGB SP"},
+		{goarch: "386", instruction: "NEGW SP"},
+		{goarch: "386", instruction: "NEGL SP"},
+		{goarch: "386", instruction: "NEGL R8"},
+		{goarch: "386", instruction: "NEGQ AX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's NEG yscond table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64NEGRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT negsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0x1122, AX
+	NEGB AH
+	MOVQ AX, 0(DI)
+	MOVQ $0x1122334455660001, AX
+	NEGW AX
+	MOVQ AX, 8(DI)
+	MOVQ $0x1122334480000000, AX
+	NEGL AX
+	MOVQ AX, 16(DI)
+	SETCS 32(DI)
+	SETOS 33(DI)
+	SETEQ 34(DI)
+	SETMI 35(DI)
+	SETPS 36(DI)
+	MOVQ $5, 24(DI)
+	NEGQ 24(DI)
+	MOVB $0, 40(DI)
+	NEGB 40(DI)
+	SETCS 41(DI)
+	SETOS 42(DI)
+	SETEQ 43(DI)
+	SETMI 44(DI)
+	SETPS 45(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"negsemantics": {
+				Name:  "negsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void negsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[48] = {0};
+  negsemantics(out);
+  if (*(uint64_t *)(out+0) != UINT64_C(0xef22)) return 10;
+  if (*(uint64_t *)(out+8) != UINT64_C(0x112233445566ffff)) return 11;
+  if (*(uint64_t *)(out+16) != UINT64_C(0x80000000)) return 12;
+  if (*(uint64_t *)(out+24) != UINT64_C(0xfffffffffffffffb)) return 13;
+  if (out[32] != 1 || out[33] != 1 || out[34] != 0 || out[35] != 1 || out[36] != 1) return 14;
+  if (out[40] != 0 || out[41] != 0 || out[42] != 0 || out[43] != 1 || out[44] != 0 || out[45] != 1) return 15;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "neg_semantics", triple, ll, mainC, runPrefix)
+}
+
+func TestAMD64UnaryYmbAliasesRuntime(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, checks strings.Builder
+	source.WriteString("TEXT unaryaliases(SB),$0-8\n\tMOVQ out+0(FP), R14\n")
+	index := 0
+	for _, family := range []string{"NEG", "NOT"} {
+		for _, width := range []struct {
+			suffix string
+			bits   uint
+		}{{"W", 16}, {"L", 32}, {"Q", 64}} {
+			for _, reg := range []struct{ spelling, effective string }{
+				{"AL", "AX"}, {"CL", "CX"}, {"DL", "DX"}, {"BL", "BX"},
+				{"AH", "SP"}, {"CH", "BP"}, {"DH", "SI"}, {"BH", "DI"},
+				{"BPB", "BP"}, {"SIB", "SI"}, {"DIB", "DI"}, {"R8B", "R8"}, {"R15B", "R15"},
+			} {
+				const input uint64 = 0x1122334455667701
+				want := ^input
+				if family == "NEG" {
+					want++
+				}
+				if width.bits == 16 {
+					want = (input &^ 0xffff) | (want & 0xffff)
+				}
+				if width.bits == 32 {
+					want &= 0xffffffff
+				}
+				fmt.Fprintf(&source, "\tMOVQ $%#x, %s\n\t%s%s %s\n\tMOVQ %s, %d(R14)\n", input, reg.effective, family, width.suffix, reg.spelling, reg.effective, index*8)
+				fmt.Fprintf(&checks, "  if (out[%d] != UINT64_C(%#x)) return %d;\n", index, want, index+1)
+				index++
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	// Wide AH/CH aliases select physical SP/BP. The unchanged original body
+	// never restores its real return stack: this remains a private arithmetic
+	// oracle, separately from public Context and actual Go byte identities.
+	x86PhysicalSPRequirePublicContext(t, source.String(), "func unaryaliases(out *uint64)", "amd64", execution.triple)
+	ir := x86PhysicalSPPrivateEmitter(t, source.String(), map[string]FuncSig{
+		"unaryaliases": {Name: "unaryaliases", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}},
+	}, "amd64", execution.triple)
+	mainC := fmt.Sprintf("#include <stdint.h>\nextern void unaryaliases(uint64_t *);\nint main(void) {\n  uint64_t out[%d] = {0};\n  unaryaliases(out);\n%s  return 0;\n}\n", index, checks.String())
+	execution.compileAndRunLLVM(t, "unary_aliases_private_math", ir,
+		"#define unaryaliases InstructionFormat0\n"+mainC, "-O2")
+	t.Log("all 78 original Ymb aliases execute private virtual-register mathematics only, not the invalid physical Go return sequence")
+}
diff --git a/amd64_lower_non_temporal_move.go b/amd64_lower_non_temporal_move.go
new file mode 100644
index 000000000..829fdb81e
--- /dev/null
+++ b/amd64_lower_non_temporal_move.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "fmt"
+
+// A non-temporal hint does not make the instruction's native access optional.
+// Reuse the aligned packed-move emitter, including original faults, exact
+// width, segment address spaces and encoding-aware register writeback.
+func (c *amd64Ctx) lowerNonTemporalVectorMove(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86NonTemporalVectorProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: non-temporal vector access needs its actual x86 target", ErrProbeNeedsContext)
+	}
+	if form.trap {
+		return c.lowerSyscall("UD2", Instr{Op: "UD2"})
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		(ins.x86Encoded || ins.x86SourceRaw != nil) && ins.x86NumericalRead == nil && ins.x86SDKLiteral == nil {
+		return true, false, fmt.Errorf("%w: non-temporal vector access needs its actual x86 target/encoding", ErrProbeNeedsContext)
+	}
+	if !c.nativeMemoryOperand(ins, form.move.memory) &&
+		!x86CallerMemoryCertified(ins, form.move.memory) && !c.fixedLocalMemoryCertified(ins, form.move.memory) {
+		return true, false, fmt.Errorf("%w: non-temporal vector access needs native backing, not logical FP/AUTO bytes", ErrProbeNeedsContext)
+	}
+	if err := x86Mode32VectorRegisterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	native := ins
+	native.Op = Op(form.spec.native) // Local spelling adapter; never mutate original source identity.
+	return true, false, c.lowerNativeAlignedVectorMemory(native, form.move, !form.spec.vector)
+}
diff --git a/amd64_lower_non_temporal_move_test.go b/amd64_lower_non_temporal_move_test.go
new file mode 100644
index 000000000..824b78c5a
--- /dev/null
+++ b/amd64_lower_non_temporal_move_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86NonTemporalVectorMoveCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses _yvmovntdq for VMOVNTDQ/PD/PS register-to-memory
+	// stores and _yvmovntdqa for the inverse aligned memory loads. Both
+	// tables cover VEX/EVEX X, Y, and Z widths. The legacy table covers the
+	// corresponding X-only forms (with MOVNTO as Go's MOVNTDQ spelling).
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 31
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT nontemporalmoveforms(SB),$0-0\n")
+			for index, op := range []string{"VMOVNTDQ", "VMOVNTPD", "VMOVNTPS"} {
+				fmt.Fprintf(&source, "\t%s X%d, %d(AX)\n", op, 20+index, index*256)
+				fmt.Fprintf(&source, "\t%s Y%d, %d(AX)\n", op, 20+index, index*256+64)
+				fmt.Fprintf(&source, "\t%s Z%d, %d(AX)\n", op, lastZ, index*256+128)
+			}
+			source.WriteString("\tVMOVNTDQA 1024(AX), X20\n")
+			source.WriteString("\tVMOVNTDQA 1088(AX), Y21\n")
+			fmt.Fprintf(&source, "\tVMOVNTDQA 1152(AX), Z%d\n", lastZ)
+			source.WriteString("\tMOVNTO X1, 1216(AX)\n")
+			source.WriteString("\tMOVNTPD X2, 1280(AX)\n")
+			source.WriteString("\tMOVNTPS X3, 1344(AX)\n")
+			source.WriteString("\tMOVNTDQA 1408(AX), X4\n")
+			source.WriteString("\tRET\n")
+
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(), "nontemporalmoveforms", target.goarch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, target.goarch)
+					if !known || err != nil {
+						return known, false, err
+					}
+					// The original Go source and every public Context result are
+					// retained above. This unit tests LLVM carrier syntax only:
+					// high named mode32 registers have no physical entry binding.
+					ins.Op = Op(form.spec.native)
+					return true, false, c.lowerNativeAlignedVectorMemory(ins, form.move, !form.spec.vector)
+				})
+			if strings.Count(ir, "asm sideeffect") != 16 {
+				t.Fatal("emitter-only object lost an original non-temporal native format")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "non-temporal-move-"+target.name+".ll", "non-temporal-move-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86NonTemporalVectorMoveRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VMOVNTDQ 8(AX), X0"},
+		{goarch: "amd64", instruction: "VMOVNTPD X0, X1"},
+		{goarch: "amd64", instruction: "VMOVNTPS X0, K1, 8(AX)"},
+		{goarch: "amd64", instruction: "VMOVNTDQ.Z Z0, 8(AX)"},
+		{goarch: "amd64", instruction: "VMOVNTDQA X0, X1"},
+		{goarch: "amd64", instruction: "VMOVNTDQA 8(AX), K1, X0"},
+		{goarch: "amd64", instruction: "MOVNTPD 8(AX), X0"},
+		{goarch: "amd64", instruction: "MOVNTPS X0, X1"},
+		{goarch: "amd64", instruction: "MOVNTDQA X0, 8(AX)"},
+		{goarch: "386", instruction: "VMOVNTDQ Z8, 8(AX)"},
+		{goarch: "386", instruction: "VMOVNTDQA 8(AX), Z8"},
+		{goarch: "386", instruction: "MOVNTO X8, 8(AX)"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's non-temporal vector-move tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderRecoversVEXNonTemporalVectorMoveWidths(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		op   Op
+		from string
+		to   string
+	}{
+		{name: "vmovntdq x store", code: []byte{0xc5, 0xf9, 0xe7, 0x03}, op: "VMOVNTDQ", from: "X0", to: "0(BX)"},
+		{name: "vmovntdq y store", code: []byte{0xc5, 0xfd, 0xe7, 0x03}, op: "VMOVNTDQ", from: "Y0", to: "0(BX)"},
+		{name: "vmovntdq y sib store", code: []byte{0xc4, 0xa1, 0x7d, 0xe7, 0x04, 0x03}, op: "VMOVNTDQ", from: "Y0", to: "0(BX)(R8*1)"},
+		{name: "vmovntpd x store", code: []byte{0xc5, 0xf9, 0x2b, 0x03}, op: "VMOVNTPD", from: "X0", to: "0(BX)"},
+		{name: "vmovntpd y store", code: []byte{0xc5, 0xfd, 0x2b, 0x03}, op: "VMOVNTPD", from: "Y0", to: "0(BX)"},
+		{name: "vmovntps x store", code: []byte{0xc5, 0xf8, 0x2b, 0x03}, op: "VMOVNTPS", from: "X0", to: "0(BX)"},
+		{name: "vmovntps y store", code: []byte{0xc5, 0xfc, 0x2b, 0x03}, op: "VMOVNTPS", from: "Y0", to: "0(BX)"},
+		{name: "vmovntdqa x load", code: []byte{0xc4, 0xe2, 0x79, 0x2a, 0x03}, op: "VMOVNTDQA", from: "0(BX)", to: "X0"},
+		{name: "vmovntdqa y load", code: []byte{0xc4, 0xe2, 0x7d, 0x2a, 0x03}, op: "VMOVNTDQA", from: "0(BX)", to: "Y0"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != test.op || len(got.Instrs[0].Args) != 2 || got.Instrs[0].Args[0].String() != test.from || got.Instrs[0].Args[1].String() != test.to {
+				t.Fatalf("decoded %#x as %#v, want %s %s, %s", test.code, got.Instrs, test.op, test.from, test.to)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_nop_width_test.go b/amd64_lower_nop_width_test.go
new file mode 100644
index 000000000..1d0866518
--- /dev/null
+++ b/amd64_lower_nop_width_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86SizedNOPCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	source.WriteString("DATA nopdata+0(SB)/8, $1\n")
+	source.WriteString("GLOBL nopdata(SB), $8\n")
+	source.WriteString("TEXT sizednopforms(SB),$0-0\n")
+	for _, op := range []string{"NOPW", "NOPL"} {
+		fmt.Fprintf(&source, "\t%s AX\n", op)
+		fmt.Fprintf(&source, "\t%s SP\n", op)
+		fmt.Fprintf(&source, "\t%s 8(BX)\n", op)
+		fmt.Fprintf(&source, "\t%s nopdata(SB)\n", op)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\t%s R11\n", op)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86SizedNOPCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86SizedNOPCompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"sizednopforms": {Name: "sizednopforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "sized-nop-"+target.name+".ll", "sized-nop-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86SizedNOPRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "NOPW"},
+		{goarch: "amd64", instruction: "NOPL $1"},
+		{goarch: "amd64", instruction: "NOPW X0"},
+		{goarch: "amd64", instruction: "NOPL AX, BX"},
+		{goarch: "amd64", instruction: "NOPL.Z AX"},
+		{goarch: "386", instruction: "NOPW R8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's NOPW/NOPL ydivl table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64SizedNOPRuntimePreservesState(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT sizednopsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0x123456789abcdef, AX
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	NOPW AX
+	NOPL 4096(DI)
+	MOVQ AX, 0(DI)
+	SETCS 8(DI)
+	SETOS 9(DI)
+	SETEQ 10(DI)
+	SETMI 11(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"sizednopsemantics": {
+				Name: "sizednopsemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void sizednopsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[16] = {0};
+  sizednopsemantics(out);
+  uint64_t value;
+  memcpy(&value, out, sizeof(value));
+  if (value != UINT64_C(0x123456789abcdef)) return 10;
+  if (out[8] != 1 || out[9] != 1 || out[10] != 0 || out[11] != 1) return 11;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "sized_nop_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_numerical_read.go b/amd64_lower_numerical_read.go
new file mode 100644
index 000000000..31937775d
--- /dev/null
+++ b/amd64_lower_numerical_read.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerNumericalRead(ins Instr) (bool, error) {
+	return c.lowerNumericalReadAt(ins, -1, -1)
+}
+
+func (c *amd64Ctx) lowerNumericalReadAt(ins Instr, block, ordinal int) (bool, error) {
+	if ins.x86SDKLiteral != nil {
+		fact, valid := certifiedSDKLiteralAccess(ins, c.goarch)
+		if !valid || c.sig.Name != fact.Function || c.targetTriple != ins.x86SDKLiteral.binding.options.TargetTriple {
+			return true, numericalSBContext("emitted private literal source/function/profile differs")
+		}
+		if c.fixedLocal != nil || c.sourceStack != nil {
+			return true, numericalSBContext("literal address cannot borrow private/native frame authority")
+		}
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return true, err
+		}
+		// Keep the original opcode/address emission. The byte fact supplies
+		// no align-1 replacement, fault suppression or constant-folded data.
+		return false, nil
+	}
+	if ins.x86NumericalRead == nil {
+		return false, nil
+	}
+	read, form, valid := numericalCertifiedRead(ins, c.goarch)
+	cert := ins.x86NumericalRead
+	if !valid || !c.numericalReadAtOriginalSource(ins, read, block, ordinal) || c.targetTriple != cert.binding.options.TargetTriple {
+		return true, numericalSBContext("emitted function/profile/read certificate changed")
+	}
+	var comparison x86ScalarCompareForm
+	if form.spec.compare {
+		var known bool
+		var err error
+		comparison, known, err = x86ScalarCompareProperties(ins.Op, ins, c.goarch)
+		if !known || err != nil {
+			return true, numericalSBContext("certified comparison lost its complete operand form: %v", err)
+		}
+	}
+	if c.fixedLocal == nil {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return true, err
+		}
+	} else if c.fixedLocal.binding == nil || c.fixedLocal.binding != c.sig.x86FixedLocal ||
+		c.fixedLocal.binding.numericalReads == nil || c.fixedLocal.binding.numericalReads.source != cert.binding.source {
+		return true, numericalSBContext("numerical read lost its independent complete fixed-local proof")
+	}
+	if form.spec.vector == x86NumericalSBAES {
+		_, _, err := c.lowerAES(ins.Op, ins)
+		return true, err
+	}
+	if form.spec.vector == x86NumericalSBLogical {
+		_, _, err := c.lowerPackedLogicalFamily(ins.Op, ins)
+		return true, err
+	}
+	// No ptrFromSB call: only this exact typed read can consume the immutable
+	// native source offset. The global remains externally mutable, and every
+	// read is volatile even when its result/condition is later overwritten.
+	pointer := llvmGlobal(read.Variable.NativeName)
+	if read.Offset != 0 {
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 %d\n", address, pointer, read.Offset)
+		pointer = "%" + address
+	}
+	sourceType := amd64IntegerTypeForBits(int(read.Width * 8))
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, ptr %s, align 1\n", loaded, sourceType, pointer)
+	value := "%" + loaded
+	if form.spec.compare {
+		// Certification already checked this shared complete operand grammar.
+		// Preserve Go's immediate truncation/sign extension and byte views.
+		partner := comparison.args[form.partner]
+		other, err := c.evalIntSized(partner, sourceType)
+		if err != nil {
+			return true, err
+		}
+		if form.operand == 0 {
+			c.setCmpFlagsSized(sourceType, value, other)
+		} else {
+			c.setCmpFlagsSized(sourceType, other, value)
+		}
+		return true, nil
+	}
+	destinationType := amd64IntegerTypeForBits(int(form.spec.gpBytes * 8))
+	if read.Width < form.spec.gpBytes {
+		extension := "zext"
+		if amd64ScalarExtensionMoveSpecs[ins.Op].signed {
+			extension = "sext"
+		}
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, sourceType, value, destinationType)
+		value = "%" + extended
+	}
+	return true, c.storeRegSized(ins.Args[form.partner].Reg, destinationType, value)
+}
diff --git a/amd64_lower_pack.go b/amd64_lower_pack.go
new file mode 100644
index 000000000..7f395343a
--- /dev/null
+++ b/amd64_lower_pack.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedNarrowMode uint8
+
+const (
+	amd64PackedNarrowSigned amd64PackedNarrowMode = iota
+	amd64PackedNarrowUnsigned
+)
+
+// All legacy/VEX/EVEX forms share one typed grammar. Packing effects remain
+// separate: clamp signed inputs, then concatenate each 128-bit source pair.
+func (c *amd64Ctx) lowerPackedSaturatingNarrow(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86PackedNarrowSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("packed narrow dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86PackedNarrowProperties(ins, c.goarch)
+	if err != nil || !known {
+		return known, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.mmx && first.Kind == OpReg && first.Reg != form.source.Reg {
+		return true, false, fmt.Errorf("%w: packed narrow GP spelling needs its physical MMX transport", ErrProbeNeedsContext)
+	}
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy pack m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	inputBits, outputBits := form.spec.inputBits, form.spec.outputBits
+	inputLanes := form.byteWidth * 8 / inputBits
+	if form.mmx {
+		var firstBits string
+		if form.memory >= 0 {
+			firstBits, err = c.loadPackedUnpackMMXSource(first, form.memoryBytes)
+		} else {
+			firstBits, err = c.loadReg(first.Reg)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		secondBits, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		value := c.emitPackedSaturatingNarrow(form.byteWidth, inputBits, outputBits, form.spec.mode,
+			c.bitcastI64ToIntegerLanes(inputLanes, inputBits, firstBits),
+			c.bitcastI64ToIntegerLanes(inputLanes, inputBits, secondBits))
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", out, 64/outputBits, outputBits, value)
+		return true, false, c.storeReg(destination.Reg, "%"+out)
+	}
+	secondValue, err := c.loadPackedCompareLanes(second, form.byteWidth, inputBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	outputLanes := form.byteWidth * 8 / outputBits
+	var value string
+	if form.legacy && form.memory >= 0 {
+		mnemonic := strings.ToLower(base)
+		if base == "PACKSSLW" {
+			mnemonic = "packssdw"
+		}
+		// Preserve legacy native alignment/fault behavior. The native result
+		// is already packed: reinterpret it, do not narrow it a second time.
+		packed, loadErr := c.emitPackedBinaryNativeMemory(first, inputBits, secondValue, mnemonic)
+		err = loadErr
+		if err == nil {
+			out := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i%d>\n", out, inputLanes, inputBits, packed, outputLanes, outputBits)
+			value = "%" + out
+		}
+	} else {
+		// Intel's E4NF/E4NF.nb pack reads the entire tuple even with a zero
+		// output mask or dead result. Never pass that mask to an E4 reader.
+		firstValue, loadErr := c.loadX86PackedShiftLanes(first, form.byteWidth, inputBits, form.broadcast, "")
+		err = loadErr
+		if err == nil {
+			value = c.emitPackedSaturatingNarrow(form.byteWidth, inputBits, outputBits, form.spec.mode, firstValue, secondValue)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, outputBits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		value = amd64ApplyIntegerLaneMask(c, outputLanes, outputBits, value, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, outputLanes, outputBits, value, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitPackedSaturatingNarrow(byteWidth, inputBits, outputBits int, mode amd64PackedNarrowMode, first, second string) string {
+	inputLanes := byteWidth * 8 / inputBits
+	outputLanes := byteWidth * 8 / outputBits
+	chunkBits := 128
+	if byteWidth < 16 {
+		chunkBits = byteWidth * 8
+	}
+	inputLanesPerChunk := chunkBits / inputBits
+	outputLanesPerChunk := chunkBits / outputBits
+	chunks := byteWidth * 8 / chunkBits
+	result := "zeroinitializer"
+	for chunk := 0; chunk < chunks; chunk++ {
+		for sourceHalf, source := range []string{second, first} {
+			for lane := 0; lane < inputLanesPerChunk; lane++ {
+				inputIndex := chunk*inputLanesPerChunk + lane
+				outputIndex := chunk*outputLanesPerChunk + sourceHalf*inputLanesPerChunk + lane
+				value := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", value, inputLanes, inputBits, source, inputIndex)
+				narrowed := c.saturatePackedInteger("%"+value, inputBits, outputBits, mode)
+				inserted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, outputLanes, outputBits, result, outputBits, narrowed, outputIndex)
+				result = "%" + inserted
+			}
+		}
+	}
+	return result
+}
+
+func (c *amd64Ctx) saturatePackedInteger(value string, inputBits, outputBits int, mode amd64PackedNarrowMode) string {
+	minValue := -(int64(1) << (outputBits - 1))
+	maxValue := (int64(1) << (outputBits - 1)) - 1
+	clamped := value
+	if mode == amd64PackedNarrowUnsigned {
+		minValue = 0
+		maxValue = (int64(1) << outputBits) - 1
+		below := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %s, 0\n", below, inputBits, clamped)
+		nonnegative := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 0, i%d %s\n", nonnegative, below, inputBits, inputBits, clamped)
+		clamped = "%" + nonnegative
+	}
+	above := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt i%d %s, %d\n", above, inputBits, clamped, maxValue)
+	capped := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %s\n", capped, above, inputBits, maxValue, inputBits, clamped)
+	clamped = "%" + capped
+	if mode == amd64PackedNarrowSigned {
+		below := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %s, %d\n", below, inputBits, clamped, minValue)
+		floored := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d %s\n", floored, below, inputBits, minValue, inputBits, clamped)
+		clamped = "%" + floored
+	}
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i%d %s to i%d\n", narrowed, inputBits, clamped, outputBits)
+	return "%" + narrowed
+}
diff --git a/amd64_lower_packed_align.go b/amd64_lower_packed_align.go
new file mode 100644
index 000000000..fa98cd829
--- /dev/null
+++ b/amd64_lower_packed_align.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerPackedAlignFamily(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedAlignProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && form.memory >= 0 &&
+		(first.Kind == OpFP || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple)) {
+		return true, false, fmt.Errorf("%w: PALIGNR m128 needs original native backing and its matching x86 target", ErrProbeNeedsContext)
+	}
+	high, err := c.loadPackedCompareBytes(second, form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	if form.legacy && form.memory >= 0 {
+		// Keep the original m128 opcode even for imm>=32. An unaligned
+		// volatile read cannot reproduce the legacy alignment exception.
+		value, err := c.emitPackedBinaryNativeMemory(first, 8, high, fmt.Sprintf("palignr $$%d,", form.immediate))
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeLegacyPackedLogical(destination, value)
+	}
+	// VEX/EVEX alignment is E4NF/E4NF.nb: the entire source tuple is
+	// observable, irrespective of selectors, zero masks or dead outputs.
+	low, err := c.loadX86PackedShiftBytes(first, form.memoryBytesOrWidth(), true)
+	if err != nil {
+		return true, false, err
+	}
+	if form.broadcast {
+		bytes, broadcast := form.spec.bits/8, c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> %s\n",
+			broadcast, bytes, low, bytes, form.byteWidth, llvmRepeatI8Mask(bytes, form.byteWidth))
+		low = "%" + broadcast
+	}
+	result := c.emitPackedAlignSelectors(form, low, high)
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareBytes(destination, form.byteWidth)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		lanes := form.byteWidth * 8 / form.spec.bits
+		computed := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.spec.bits, result)
+		prior := old
+		if !form.zeroing {
+			prior = c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.spec.bits, old)
+		}
+		masked := amd64ApplyIntegerLaneMask(c, lanes, form.spec.bits, computed, prior, mask, form.zeroing)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, form.spec.bits, masked, form.byteWidth)
+		result = "%" + bytes
+	}
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, result)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, result)
+}
+
+func (f x86PackedAlignForm) memoryBytesOrWidth() int {
+	if f.memory >= 0 {
+		return f.memoryBytes
+	}
+	return f.byteWidth
+}
+
+func (c *amd64Ctx) emitPackedAlignSelectors(form x86PackedAlignForm, first, second string) string {
+	indices := make([]int, form.byteWidth)
+	zeros := false
+	for output := range indices {
+		indices[output] = form.sourceByte(output)
+		zeros = zeros || indices[output] < 0
+	}
+	width := form.byteWidth
+	if zeros {
+		// A second shuffle supplies constant padding without poison or one
+		// extract/insert chain per byte. Both numerical consumers use exactly
+		// the same selectors, including the known-zero large-count domain.
+		joined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> %s\n",
+			joined, width, first, width, second, width*2, llvmI32RangeMask(0, width*2))
+		first, second, width = "%"+joined, "zeroinitializer", width*2
+		for output := range indices {
+			if indices[output] < 0 {
+				indices[output] = width
+			}
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> %s\n",
+		result, width, first, width, second, form.byteWidth, llvmI32Mask(indices))
+	return "%" + result
+}
diff --git a/amd64_lower_packed_binary_e4.go b/amd64_lower_packed_binary_e4.go
new file mode 100644
index 000000000..075bac6e2
--- /dev/null
+++ b/amd64_lower_packed_binary_e4.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+// emitPackedBinaryE4 shares the lane pipeline after the family's grammar and
+// storage checks. Legacy memory keeps its original SSE opcode and alignment
+// faults. VEX/EVEX uses E4 reads: even dead outputs retain active volatile
+// accesses, while inactive lanes are suppressed. The operation callback owns
+// only register arithmetic; this helper supplies no source or memory authority.
+func (c *amd64Ctx) emitPackedBinaryE4(ins Instr, form x86PackedBinaryForm, bits int,
+	legacyMnemonic string, operation func(lanes, bits int, first, second string) string) error {
+	lanes := form.byteWidth * 8 / bits
+	second, err := c.loadPackedCompareLanes(ins.Args[form.second], form.byteWidth, bits, false)
+	if err != nil {
+		return err
+	}
+	var mask, value string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+	}
+	first := ins.Args[form.first]
+	if form.legacy && form.memory >= 0 {
+		value, err = c.emitPackedBinaryNativeMemory(first, bits, second, legacyMnemonic)
+	} else {
+		var input string
+		input, err = c.loadX86PackedShiftLanes(first, form.byteWidth, bits, form.broadcast, mask)
+		if err == nil {
+			value = operation(lanes, bits, input, second)
+		}
+	}
+	if err != nil {
+		return err
+	}
+	destination := ins.Args[form.destination]
+	if form.mask >= 0 {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, bits, false)
+			if err != nil {
+				return err
+			}
+		}
+		value = amd64ApplyIntegerLaneMask(c, lanes, bits, value, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, bits, value, form.byteWidth)
+	if form.legacy {
+		return c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
diff --git a/amd64_lower_packed_logical.go b/amd64_lower_packed_logical.go
new file mode 100644
index 000000000..8605323b5
--- /dev/null
+++ b/amd64_lower_packed_logical.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import "fmt"
+
+type amd64PackedLogicalMode uint8
+
+const (
+	amd64PackedLogicalAnd amd64PackedLogicalMode = iota
+	amd64PackedLogicalAndNot
+	amd64PackedLogicalOr
+	amd64PackedLogicalXor
+)
+
+type amd64PackedLogicalSpec struct {
+	laneBits int
+	mode     amd64PackedLogicalMode
+}
+
+// Compatibility helper entry points all use the same dispatch identity and
+// complete typed grammar; none has a separate permissive operand fallback.
+func (c *amd64Ctx) lowerPackedFloatingLogical(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedLogicalFamily(op, ins)
+}
+
+func (c *amd64Ctx) lowerEVEXPackedLogical(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedLogicalFamily(op, ins)
+}
+
+func (c *amd64Ctx) lowerPackedAndNot(op Op, ins Instr) (bool, bool, error) {
+	return c.lowerPackedLogicalFamily(op, ins)
+}
+
+func (c *amd64Ctx) emitPackedLogical(lanes int, spec amd64PackedLogicalSpec, first, second string) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	if spec.mode == amd64PackedLogicalAndNot {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", inverted, vectorType, second, llvmSplatInteger(lanes, spec.laneBits, ^uint64(0)))
+		second = "%" + inverted
+	}
+	result := c.newTmp()
+	op := "and"
+	switch spec.mode {
+	case amd64PackedLogicalOr:
+		op = "or"
+	case amd64PackedLogicalXor:
+		op = "xor"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, op, vectorType, second, first)
+	return "%" + result
+}
+
+func (c *amd64Ctx) isGoEVEXVectorRegister(op Operand, byteWidth int) bool {
+	return amd64GoPackedVectorMoveRegister(op, byteWidth, c.goarch)
+}
+
+func amd64VectorByteWidth(r Reg) int {
+	switch {
+	case isAMD64XReg(r):
+		return 16
+	case isAMD64YReg(r):
+		return 32
+	case isAMD64ZReg(r):
+		return 64
+	default:
+		return 0
+	}
+}
+
+func amd64VectorRegisterHasWidth(op Operand, byteWidth int) bool {
+	return op.Kind == OpReg && amd64VectorByteWidth(op.Reg) == byteWidth
+}
+
+func (c *amd64Ctx) bitcastVectorBytesToIntegerLanes(byteWidth, lanes, laneBits int, value string) string {
+	cast := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x i%d>\n", cast, byteWidth, value, lanes, laneBits)
+	return "%" + cast
+}
+
+func (c *amd64Ctx) storeVectorBytes(dst Reg, byteWidth int, value string) error {
+	switch byteWidth {
+	case 16:
+		return c.storeX(dst, value)
+	case 32:
+		return c.storeY(dst, value)
+	case 64:
+		return c.storeZ(dst, value)
+	default:
+		return fmt.Errorf("unsupported packed vector width %d", byteWidth)
+	}
+}
diff --git a/amd64_lower_packed_move_frame_test.go b/amd64_lower_packed_move_frame_test.go
new file mode 100644
index 000000000..eb0225950
--- /dev/null
+++ b/amd64_lower_packed_move_frame_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedMoveFrameRejectsUndeclaredSlots(t *testing.T) {
+	for _, op := range []string{"VMOVAPS", "VMOVAPD", "VMOVUPS", "VMOVUPD", "VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+		for _, reg := range []string{"X0", "Y0", "Z0"} {
+			for _, instruction := range []string{fmt.Sprintf("%s %s,K7,out+0(FP)", op, reg), fmt.Sprintf("%s out+0(FP),K7,%s", op, reg)} {
+				for _, arch := range []string{"386", "amd64"} {
+					file, err := Parse(ArchAMD64, "TEXT framebounds(SB),4,$0-8\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, err = Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{
+						"framebounds": {Name: "framebounds", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}},
+					}})
+					if err == nil {
+						t.Errorf("%s accepted %s beyond a single 8-byte frame slot", arch, instruction)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveFrameSlotsRuntime(t *testing.T) {
+	x86PackedMoveFrameSlots(t, true)
+}
+
+func TestX86PackedMoveFrameSlotsObjects(t *testing.T) {
+	x86PackedMoveFrameSlots(t, false)
+}
+
+func x86PackedMoveFrameSlots(t *testing.T, execute bool) {
+	t.Helper()
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, spec := range x86PackedMoveRuntimeRows {
+		name := fmt.Sprintf("packedframe%d", index)
+		body := fmt.Sprintf("TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ mask+24(FP),BX\nKMOVQ BX,K7\nVMOVUPS (DI),X0\n%s a+8(FP),K7,X0\nVMOVUPS X0,(DI)\nVMOVUPS 16(DI),X1\n%s X1,K7,a+8(FP)\nMOVQ a+8(FP),AX\nMOVQ AX,16(DI)\nMOVQ b+16(FP),AX\nMOVQ AX,24(DI)\nRET\n", name, spec.op, spec.op)
+		sig := FuncSig{Name: name, Args: []LLVMType{Ptr, I64, I64, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}, {Offset: 16, Type: I64, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1}}}}
+		if x86PackedMoveRuntimeNativeRow(spec.op, true) {
+			// Preserve each old fixture as an explicit original-Go accepted
+			// Context boundary, not an invented aligned LLVM aggregate.
+			goAssemblerOracleOutput(t, "amd64", body, "", true)
+			file, err := Parse(ArchAMD64, body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{name: sig}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("virtual aligned FP fixture %s: %v", spec.op, err)
+			}
+			continue
+		}
+		source.WriteString(body)
+		sigs[name] = sig
+		fmt.Fprintf(&declarations, "extern void %s(void *,uint64_t,uint64_t,uint64_t);\n", name)
+		fmt.Fprintf(&checks, "if(check(%s,%d)) return %d;\n", name, spec.bits/8, index+1)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "x86_64-w64-windows-gnu"} {
+		ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "packed-frame.ll", "packed-frame.o", ir)
+	}
+	if !execute {
+		t.Log("complete original frame source compiled for all four targets; native execution has its separate runtime owner")
+		return
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; object compilation above is required on every host")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+` + declarations.String() + `
+static int check(void (*fn)(void *,uint64_t,uint64_t,uint64_t),int lane) {
+  uint64_t words[]={UINT64_C(0x123456789abcdef0),UINT64_C(0xfedcba9876543210)};
+  uint64_t masks[]={0,1,UINT64_C(0xaaaa),UINT64_MAX};
+  uint8_t frame[16]; memcpy(frame,words,16);
+  for(int m=0;m<4;m++) {
+    _Alignas(64) uint8_t out[32],old[32];
+    for(int i=0;i<32;i++) out[i]=old[i]=(uint8_t)(19+i*7);
+    fn(out,words[0],words[1],masks[m]);
+    for(int i=0;i<16;i++) {
+      int active=(masks[m]>>(i/lane))&1;
+      if(out[i]!=(active ? frame[i] : old[i]) || out[16+i]!=(active ? old[16+i] : frame[i])) {
+        fprintf(stderr,"packed FP mismatch lane=%d mask=%d byte=%d\n",lane,m,i);return 1;
+      }
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_move_frame", triple, ir, mainC, prefix)
+}
diff --git a/amd64_lower_packed_move_memory_test.go b/amd64_lower_packed_move_memory_test.go
new file mode 100644
index 000000000..3b503aae4
--- /dev/null
+++ b/amd64_lower_packed_move_memory_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedMoveMaskedMemoryRuntime(t *testing.T) {
+	x86PackedMoveMaskedMemoryRuntime(t, false)
+}
+
+func x86PackedMoveMaskedMemoryRuntime(t *testing.T, native bool) {
+	t.Helper()
+	var execution x86FloatCompareExecution
+	if native {
+		execution = x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	} else {
+		execution = x86ScalarCountHostExecution(t)
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, spec := range x86PackedMoveRuntimeRows {
+		if x86PackedMoveRuntimeNativeRow(spec.op, true) != native {
+			continue
+		}
+		for width, reg := range []string{"X0", "Y0", "Z0"} {
+			bytes := 16 << width
+			name := fmt.Sprintf("packedmemory%d", index)
+			index++
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ in+0(FP),BX\nMOVQ mem+8(FP),AX\nMOVQ out+16(FP),DI\nMOVQ mask+24(FP),CX\nKMOVQ CX,K7\nVMOVUPS (BX),%s\n%s (AX),K7,%s\nVMOVUPS %s,(DI)\nVMOVUPS (BX),%s\n%s.Z (AX),K7,%s\nVMOVUPS %s,%d(DI)\nVMOVUPS (BX),%s\n%s %s,K7,(AX)\nRET\n", name, reg, spec.op, reg, reg, reg, spec.op, reg, reg, bytes, reg, spec.op, reg)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *,void *,void *,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if(check(%s,%d,%d)) return %d;\n", name, bytes, spec.bits/8, index)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86PackedMoveRuntimeIR(t, file, execution, sigs, native, "packed-move-masked-memory")
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int check(void (*fn)(const void *,void *,void *,uint64_t),int bytes,int lane) {
+  uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX};
+  for (int m=0;m<4;m++) {
+    _Alignas(64) uint8_t in[64],mem[64],out[128],old[64];
+    for(int i=0;i<64;i++) { in[i]=(uint8_t)(17+i*3); mem[i]=old[i]=(uint8_t)(255-i*7); }
+    fn(in,mem,out,masks[m]);
+    for(int i=0;i<bytes;i++) {
+      int active=(masks[m]>>(i/lane))&1;
+      if(out[i]!=(active ? old[i] : in[i]) || out[bytes+i]!=(active ? old[i] : 0) || mem[i]!=(active ? in[i] : old[i])) {
+        fprintf(stderr,"packed move bytes=%d lane=%d mask=%d byte=%d mismatch\n",bytes,lane,m,i);return 1;
+      }
+    }
+    if(!masks[m]) { fn(in,0,out,0); if(memcmp(in,out,bytes)) return 1; for(int i=0;i<bytes;i++) if(out[bytes+i]) return 1; }
+  }
+  return 0;
+}
+
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	execution.compileAndRunLLVM(t, "packed-move-masked-memory", ir, mainC, "-O2")
+}
+
+func TestX86PackedMoveRegisterViewsRuntime(t *testing.T) {
+	x86PackedMoveRegisterViewsRuntime(t, false)
+}
+
+func x86PackedMoveRegisterViewsRuntime(t *testing.T, native bool) {
+	t.Helper()
+	var execution x86FloatCompareExecution
+	if native {
+		execution = x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	} else {
+		execution = x86ScalarCountHostExecution(t)
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, spec := range x86PackedMoveRuntimeRows {
+		for width, prefix := range []string{"X", "Y", "Z"} {
+			for form := 0; form < 6; form++ {
+				if x86PackedMoveRuntimeNativeRow(spec.op, form < 3) != native {
+					continue
+				}
+				name := fmt.Sprintf("packedviews%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ in+0(FP),BX\nMOVQ old+8(FP),AX\nMOVQ out+16(FP),DI\nMOVQ mask+24(FP),CX\nKMOVQ CX,K7\n", name)
+				for _, view := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&source, "VMOVUPS (AX),%s0\nVMOVUPS (BX),%s1\n", view, view)
+				}
+				input := "(BX)"
+				if form >= 3 {
+					input = prefix + "1"
+				}
+				op, mask := spec.op, ""
+				if form%3 != 0 {
+					mask = "K7,"
+				}
+				if form%3 == 2 {
+					op += ".Z"
+				}
+				fmt.Fprintf(&source, "%s %s,%s%s0\nVMOVUPS Z0,(DI)\nVMOVUPS Y0,64(DI)\nVMOVUPS X0,96(DI)\nRET\n", op, input, mask, prefix)
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1}}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *,uint64_t);\n", name)
+				fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d)) return %d;\n", name, 16<<width, spec.bits/8, form%3, index)
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86PackedMoveRuntimeIR(t, file, execution, sigs, native, "packed-move-views")
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+` + declarations.String() + `
+static int check(void (*fn)(const void *,const void *,void *,uint64_t),int bytes,int lane,int form) {
+  uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX};
+  for(int m=0;m<4;m++) {
+    _Alignas(64) uint8_t in[64],old[64],out[112];
+    for(int i=0;i<64;i++) {in[i]=(uint8_t)(17+i*3);old[i]=(uint8_t)(255-i*7);}
+    fn(in,old,out,masks[m]);
+    for(int view=0;view<3;view++) for(int i=0;i<(64>>view);i++) {
+      int active=form==0 || ((masks[m]>>(i/lane))&1);
+      uint8_t want=i>=bytes ? 0 : active ? in[i] : form==2 ? 0 : old[i];
+      int offset=view==0 ? 0 : view==1 ? 64 : 96;
+      if(out[offset+i]!=want) {fprintf(stderr,"packed views width=%d lane=%d form=%d mask=%d view=%d byte=%d got=%d want=%d\n",bytes,lane,form,m,view,i,out[offset+i],want);return 1;}
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	execution.compileAndRunLLVM(t, "packed-move-views", ir, mainC, "-O2")
+}
+
+func x86PackedMoveRuntimeIR(t *testing.T, file *File, execution x86FloatCompareExecution, sigs map[string]FuncSig, native bool, name string) string {
+	t.Helper()
+	options := Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if native {
+		return ir // Native memory faults and original ISA attributes stay intact.
+	}
+	profiles := make(map[string]string, len(file.Funcs))
+	for _, function := range file.Funcs {
+		profile := ""
+		if x86ScalarFloatIntegerNativeTarget("amd64", execution.triple) ||
+			x86ScalarFloatIntegerNativeTarget("386", execution.triple) {
+			profile = inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", function)
+		}
+		profiles[function.Sym] = profile
+	}
+	// On every host, including ARM64, reject native bodies. On x86 also remove
+	// only each complete function's exact checked ISA attributes for this
+	// numerical oracle; a Z-register spelling must not require an AVX512 host.
+	portable, err := x86PackedShiftPortableFeatureProjection(ir, profiles)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("amd64-object", func(t *testing.T) {
+		const triple = "x86_64-unknown-linux-gnu"
+		original := ir
+		if execution.triple != triple {
+			options.TargetTriple = triple
+			original, err = Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+		// Compile the unprojected public module with its original features.
+		x86ResultInitializationObject(t, execution.llc, triple, original, name)
+	})
+	return portable
+}
diff --git a/amd64_lower_packed_numeric_conversion.go b/amd64_lower_packed_numeric_conversion.go
new file mode 100644
index 000000000..e069c1de9
--- /dev/null
+++ b/amd64_lower_packed_numeric_conversion.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedNumericKind uint8
+
+const (
+	amd64PackedNumericFloat amd64PackedNumericKind = iota
+	amd64PackedNumericSigned
+	amd64PackedNumericUnsigned
+)
+
+type amd64PackedNumericShape struct {
+	sourceBytes      int
+	destinationBytes int
+	lanes            int
+}
+
+type amd64PackedNumericConversionSpec struct {
+	sourceKind      amd64PackedNumericKind
+	destinationKind amd64PackedNumericKind
+	sourceBits      int
+	destinationBits int
+	truncate        bool
+	explicit        string
+	shapes          []amd64PackedNumericShape
+}
+
+var (
+	amd64PackedNumericSame32 = []amd64PackedNumericShape{
+		{sourceBytes: 16, destinationBytes: 16, lanes: 4},
+		{sourceBytes: 32, destinationBytes: 32, lanes: 8},
+		{sourceBytes: 64, destinationBytes: 64, lanes: 16},
+	}
+	amd64PackedNumericSame64 = []amd64PackedNumericShape{
+		{sourceBytes: 16, destinationBytes: 16, lanes: 2},
+		{sourceBytes: 32, destinationBytes: 32, lanes: 4},
+		{sourceBytes: 64, destinationBytes: 64, lanes: 8},
+	}
+	amd64PackedNumericWiden32To64 = []amd64PackedNumericShape{
+		{sourceBytes: 16, destinationBytes: 16, lanes: 2},
+		{sourceBytes: 16, destinationBytes: 32, lanes: 4},
+		{sourceBytes: 32, destinationBytes: 64, lanes: 8},
+	}
+)
+
+// amd64PackedNumericConversionSpecs describes the complete Go 1.27 EVEX
+// packed numeric-conversion family not covered by the legacy/VEX conversion
+// handlers. Source/destination element types and physical width shapes remain
+// independent axes, avoiding one lowerer per mnemonic and register width.
+var amd64PackedNumericConversionSpecs = map[Op]amd64PackedNumericConversionSpec{
+	"VCVTPD2QQ":    {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericSigned, sourceBits: 64, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericSame64},
+	"VCVTPD2UQQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericSame64},
+	"VCVTTPD2QQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericSigned, sourceBits: 64, destinationBits: 64, truncate: true, explicit: "sae", shapes: amd64PackedNumericSame64},
+	"VCVTTPD2UQQ":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 64, truncate: true, explicit: "sae", shapes: amd64PackedNumericSame64},
+	"VCVTPS2UDQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 32, destinationBits: 32, explicit: "round", shapes: amd64PackedNumericSame32},
+	"VCVTTPS2UDQ":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 32, destinationBits: 32, truncate: true, explicit: "sae", shapes: amd64PackedNumericSame32},
+	"VCVTUDQ2PS":   {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 32, destinationBits: 32, explicit: "round", shapes: amd64PackedNumericSame32},
+	"VCVTQQ2PD":    {sourceKind: amd64PackedNumericSigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericSame64},
+	"VCVTUQQ2PD":   {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericSame64},
+	"VCVTPS2QQ":    {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericSigned, sourceBits: 32, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericWiden32To64},
+	"VCVTPS2UQQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 32, destinationBits: 64, explicit: "round", shapes: amd64PackedNumericWiden32To64},
+	"VCVTTPS2QQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericSigned, sourceBits: 32, destinationBits: 64, truncate: true, explicit: "sae", shapes: amd64PackedNumericWiden32To64},
+	"VCVTTPS2UQQ":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 32, destinationBits: 64, truncate: true, explicit: "sae", shapes: amd64PackedNumericWiden32To64},
+	"VCVTUDQ2PD":   {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 32, destinationBits: 64, shapes: amd64PackedNumericWiden32To64},
+	"VCVTPD2UDQX":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}},
+	"VCVTPD2UDQY":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}},
+	"VCVTPD2UDQ":   {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, explicit: "round", shapes: []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}},
+	"VCVTTPD2UDQX": {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, truncate: true, shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}},
+	"VCVTTPD2UDQY": {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, truncate: true, shapes: []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}},
+	"VCVTTPD2UDQ":  {sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericUnsigned, sourceBits: 64, destinationBits: 32, truncate: true, explicit: "sae", shapes: []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}},
+	"VCVTQQ2PSX":   {sourceKind: amd64PackedNumericSigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}},
+	"VCVTQQ2PSY":   {sourceKind: amd64PackedNumericSigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}},
+	"VCVTQQ2PS":    {sourceKind: amd64PackedNumericSigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, explicit: "round", shapes: []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}},
+	"VCVTUQQ2PSX":  {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}},
+	"VCVTUQQ2PSY":  {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, shapes: []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}},
+	"VCVTUQQ2PS":   {sourceKind: amd64PackedNumericUnsigned, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32, explicit: "round", shapes: []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}},
+}
+
+func (c *amd64Ctx) lowerPackedNumericConversion(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86PackedConversionSpecification(Op(base)); !known {
+		return false, false, nil
+	}
+	if !strings.EqualFold(string(op), string(ins.Op)) {
+		return true, false, fmt.Errorf("packed conversion dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	form, _, err := x86PackedConversionProperties(ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if form.mmx || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: packed conversion lacks native target or physical MMX/x87 caller contract", ErrProbeNeedsContext)
+	}
+	source := ins.Args[0]
+	if source.Kind == OpFP {
+		if err := c.validateFPVectorSpan(source.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+		return true, false, fmt.Errorf("%w: packed FP conversion source lacks original native backing", ErrProbeNeedsContext)
+	}
+	if ins.x86AddressBits != 0 || source.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+		return true, false, fmt.Errorf("%w: packed conversion lacks original native address binding", ErrProbeNeedsContext)
+	}
+	base = strings.ToLower(base)
+	mnemonic := strings.TrimSuffix(strings.TrimSuffix(base, "x"), "y")
+	if form.spec.legacy {
+		mnemonic = strings.ReplaceAll(base, "pl", "dq")
+	}
+	// Narrowing memory leaves X/Y source length ambiguous to an assembler:
+	// encode the source vector length, not the destination carrier width.
+	if form.memory >= 0 && !form.spec.legacy && !form.properties.broadcast &&
+		form.spec.sourceBits > form.spec.destinationBits && form.shape.sourceBytes < 64 {
+		mnemonic += map[int]string{16: "x", 32: "y"}[form.shape.sourceBytes]
+	}
+	return true, false, c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: form.shape.destinationBytes, sourceBytes: form.shape.sourceBytes,
+		memoryBytes: form.memoryBytes, outputBits: form.spec.destinationBits,
+		lanes:       form.shape.lanes,
+		destination: form.destination, mask: form.mask, legacy: form.spec.legacy, evex: form.evex,
+		broadcast: form.properties.broadcast, zeroing: form.properties.zeroing,
+		rounding: form.properties.rounding, sae: form.properties.sae, mnemonic: mnemonic,
+	})
+}
+
+func (c *amd64Ctx) packedNumericRoundingMode(rounding string) string {
+	switch rounding {
+	case "RN_SAE":
+		return "0"
+	case "RD_SAE":
+		return "1"
+	case "RU_SAE":
+		return "2"
+	case "RZ_SAE":
+		return "3"
+	default:
+		mxcsr := c.loadMXCSR()
+		shifted, mode := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, 13\n", shifted, mxcsr)
+		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 3\n", mode, shifted)
+		return "%" + mode
+	}
+}
diff --git a/amd64_lower_packed_numeric_conversion_test.go b/amd64_lower_packed_numeric_conversion_test.go
new file mode 100644
index 000000000..3fee9bbf7
--- /dev/null
+++ b/amd64_lower_packed_numeric_conversion_test.go
@@ -0,0 +1,289 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type packedNumericConversionTestShape struct {
+	source      string
+	destination string
+}
+
+type packedNumericConversionTestSpec struct {
+	op       string
+	shapes   []packedNumericConversionTestShape
+	explicit string
+}
+
+func go127PackedNumericConversionSpecs() []packedNumericConversionTestSpec {
+	same := []packedNumericConversionTestShape{{"X", "X"}, {"Y", "Y"}, {"Z", "Z"}}
+	widen := []packedNumericConversionTestShape{{"X", "X"}, {"X", "Y"}, {"Y", "Z"}}
+	return []packedNumericConversionTestSpec{
+		{op: "VCVTPD2QQ", shapes: same, explicit: "round"},
+		{op: "VCVTPD2UQQ", shapes: same, explicit: "round"},
+		{op: "VCVTTPD2QQ", shapes: same, explicit: "sae"},
+		{op: "VCVTTPD2UQQ", shapes: same, explicit: "sae"},
+		{op: "VCVTPS2UDQ", shapes: same, explicit: "round"},
+		{op: "VCVTTPS2UDQ", shapes: same, explicit: "sae"},
+		{op: "VCVTUDQ2PS", shapes: same, explicit: "round"},
+		{op: "VCVTQQ2PD", shapes: same, explicit: "round"},
+		{op: "VCVTUQQ2PD", shapes: same, explicit: "round"},
+		{op: "VCVTPS2QQ", shapes: widen, explicit: "round"},
+		{op: "VCVTPS2UQQ", shapes: widen, explicit: "round"},
+		{op: "VCVTTPS2QQ", shapes: widen, explicit: "sae"},
+		{op: "VCVTTPS2UQQ", shapes: widen, explicit: "sae"},
+		{op: "VCVTUDQ2PD", shapes: widen},
+		{op: "VCVTPD2UDQX", shapes: []packedNumericConversionTestShape{{"X", "X"}}},
+		{op: "VCVTPD2UDQY", shapes: []packedNumericConversionTestShape{{"Y", "X"}}},
+		{op: "VCVTPD2UDQ", shapes: []packedNumericConversionTestShape{{"Z", "Y"}}, explicit: "round"},
+		{op: "VCVTTPD2UDQX", shapes: []packedNumericConversionTestShape{{"X", "X"}}},
+		{op: "VCVTTPD2UDQY", shapes: []packedNumericConversionTestShape{{"Y", "X"}}},
+		{op: "VCVTTPD2UDQ", shapes: []packedNumericConversionTestShape{{"Z", "Y"}}, explicit: "sae"},
+		{op: "VCVTQQ2PSX", shapes: []packedNumericConversionTestShape{{"X", "X"}}},
+		{op: "VCVTQQ2PSY", shapes: []packedNumericConversionTestShape{{"Y", "X"}}},
+		{op: "VCVTQQ2PS", shapes: []packedNumericConversionTestShape{{"Z", "Y"}}, explicit: "round"},
+		{op: "VCVTUQQ2PSX", shapes: []packedNumericConversionTestShape{{"X", "X"}}},
+		{op: "VCVTUQQ2PSY", shapes: []packedNumericConversionTestShape{{"Y", "X"}}},
+		{op: "VCVTUQQ2PS", shapes: []packedNumericConversionTestShape{{"Z", "Y"}}, explicit: "round"},
+	}
+}
+
+func TestAMD64PackedNumericConversionGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := go127PackedNumericConversionSpecs()
+	if len(amd64PackedNumericConversionSpecs) != len(expected) {
+		t.Fatalf("packed numeric conversion grammar has %d entries, want %d", len(amd64PackedNumericConversionSpecs), len(expected))
+	}
+	for _, want := range expected {
+		if _, ok := amd64PackedNumericConversionSpecs[Op(want.op)]; !ok {
+			t.Errorf("packed numeric conversion grammar omitted %s", want.op)
+		}
+	}
+}
+
+func TestTranslateX86PackedNumericConversionCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			last := 23
+			if target.goarch == "386" {
+				last = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packednumericconversionforms(SB),$0-0\n")
+			for index, spec := range go127PackedNumericConversionSpecs() {
+				for _, shape := range spec.shapes {
+					fmt.Fprintf(&source, "\t%s %s1, %s%d\n", spec.op, shape.source, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s %d(AX), %s%d\n", spec.op, 8+index*8, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s.BCST %d(AX), %s%d\n", spec.op, 16+index*8, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s %s2, K1, %s%d\n", spec.op, shape.source, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s.Z %d(AX), K2, %s%d\n", spec.op, 24+index*8, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s.BCST.Z %d(AX), K3, %s%d\n", spec.op, 32+index*8, shape.destination, last)
+				}
+				if spec.explicit == "round" {
+					shape := spec.shapes[len(spec.shapes)-1]
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						fmt.Fprintf(&source, "\t%s.%s %s3, %s%d\n", spec.op, rounding, shape.source, shape.destination, last)
+					}
+					fmt.Fprintf(&source, "\t%s.RN_SAE.Z %s4, K4, %s%d\n", spec.op, shape.source, shape.destination, last)
+				} else if spec.explicit == "sae" {
+					shape := spec.shapes[len(spec.shapes)-1]
+					fmt.Fprintf(&source, "\t%s.SAE %s3, %s%d\n", spec.op, shape.source, shape.destination, last)
+					fmt.Fprintf(&source, "\t%s.SAE.Z %s4, K4, %s%d\n", spec.op, shape.source, shape.destination, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "packednumericconversionforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-numeric-conversion-"+target.name+".ll", "packed-numeric-conversion-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedNumericConversionRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VCVTPD2QQ X0"},
+		{goarch: "amd64", instruction: "VCVTPD2QQ X0, Y1"},
+		{goarch: "amd64", instruction: "VCVTPS2QQ Y0, Y1"},
+		{goarch: "amd64", instruction: "VCVTUDQ2PD Y0, Y1"},
+		{goarch: "amd64", instruction: "VCVTPD2UDQX Y0, X1"},
+		{goarch: "amd64", instruction: "VCVTPD2UDQY X0, X1"},
+		{goarch: "amd64", instruction: "VCVTPD2UDQ Z0, Z1"},
+		{goarch: "amd64", instruction: "VCVTQQ2PSX X0, Y1"},
+		{goarch: "amd64", instruction: "VCVTQQ2PSY X0, X1"},
+		{goarch: "amd64", instruction: "VCVTQQ2PS Z0, Z1"},
+		{goarch: "amd64", instruction: "VCVTUDQ2PS.Z X0, X1"},
+		{goarch: "amd64", instruction: "VCVTUDQ2PS X0, K0, X1"},
+		{goarch: "amd64", instruction: "VCVTUDQ2PS.BCST X0, X1"},
+		{goarch: "amd64", instruction: "VCVTPD2QQ.RN_SAE Y0, Y1"},
+		{goarch: "amd64", instruction: "VCVTPD2QQ.RN_SAE 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VCVTTPD2QQ.RN_SAE Z0, Z1"},
+		{goarch: "amd64", instruction: "VCVTPD2UDQX.RN_SAE X0, X1"},
+		{goarch: "386", instruction: "VCVTPD2QQ Z8, Z1"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's packed numeric conversion tables", test.instruction)
+			}
+		})
+	}
+}
+
+func amd64PackedNumericConversionNativeRuntimeSemantics(t *testing.T) {
+	execution := x86PackedConversionNativeTools(t)
+	const source = `TEXT packednumericconversionsemantics(SB),$0-64
+	MOVQ out+0(FP), AX
+	MOVQ f64+8(FP), BX
+	MOVQ f32+16(FP), CX
+	MOVQ u32+24(FP), DX
+	MOVQ i64+32(FP), R8
+	MOVQ u64+40(FP), R9
+	MOVQ old64+48(FP), R10
+	MOVQ mask+56(FP), R11
+	KMOVQ R11, K1
+	VMOVDQU64 0(BX), Z0
+	VCVTPD2QQ Z0, Z1
+	VMOVDQU64 Z1, 0(AX)
+	VCVTPD2UQQ Z0, Z2
+	VMOVDQU64 Z2, 64(AX)
+	VCVTPD2QQ.RU_SAE Z0, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VCVTTPD2UQQ.SAE Z0, Z2
+	VMOVDQU64 Z2, 192(AX)
+	VMOVDQU32 0(CX), Y3
+	VCVTPS2QQ Y3, Z4
+	VMOVDQU64 Z4, 256(AX)
+	VCVTTPS2UQQ Y3, Z5
+	VMOVDQU64 Z5, 320(AX)
+	VMOVDQU32 0(CX), Z6
+	VCVTPS2UDQ.BCST 0(CX), Z7
+	VMOVDQU32 Z7, 384(AX)
+	VCVTTPS2UDQ Z6, Z7
+	VMOVDQU32 Z7, 448(AX)
+	VMOVDQU32 0(DX), Z8
+	VCVTUDQ2PS Z8, Z9
+	VMOVDQU32 Z9, 512(AX)
+	VCVTUDQ2PS.RD_SAE Z8, Z9
+	VMOVDQU32 Z9, 576(AX)
+	VCVTUDQ2PD 0(DX), Z10
+	VMOVDQU64 Z10, 640(AX)
+	VMOVDQU64 0(R8), Z11
+	VCVTQQ2PD Z11, Z12
+	VMOVDQU64 Z12, 704(AX)
+	VMOVDQU64 0(R9), Z13
+	VCVTUQQ2PD Z13, Z14
+	VMOVDQU64 Z14, 768(AX)
+	VCVTQQ2PS Z11, Y15
+	VMOVDQU32 Y15, 832(AX)
+	VCVTUQQ2PS.RU_SAE Z13, Y16
+	VMOVDQU32 Y16, 864(AX)
+	VMOVDQU64 0(R10), Z17
+	VCVTPD2QQ.Z Z0, K1, Z17
+	VMOVDQU64 Z17, 896(AX)
+	VMOVDQU64 0(BX), X0
+	VCVTPD2UDQX X0, X18
+	VMOVDQU32 X18, 960(AX)
+	VMOVDQU64 0(BX), Y0
+	VCVTTPD2UDQY Y0, X19
+	VMOVDQU32 X19, 976(AX)
+	STC
+	SETCS 992(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"packednumericconversionsemantics": {
+			Name: "packednumericconversionsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+				{Offset: 56, Type: I64, Index: 7, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#pragma STDC FENV_ACCESS ON
+#include <fenv.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void packednumericconversionsemantics(uint8_t *, const double *, const float *, const uint32_t *, const int64_t *, const uint64_t *, const uint64_t *, uint64_t);
+static uint32_t u32(const uint8_t *p){uint32_t v;memcpy(&v,p,4);return v;} static uint64_t u64(const uint8_t *p){uint64_t v;memcpy(&v,p,8);return v;}
+static double rd(double x,int truncating,int fixed){if(truncating)return trunc(x);if(fixed==1)return nearbyint(x);int rc=fegetround();return rc==FE_DOWNWARD?floor(x):(rc==FE_UPWARD?ceil(x):(rc==FE_TOWARDZERO?trunc(x):nearbyint(x)));}
+static float rf(float x,int truncating){if(truncating)return truncf(x);int rc=fegetround();return rc==FE_DOWNWARD?floorf(x):(rc==FE_UPWARD?ceilf(x):(rc==FE_TOWARDZERO?truncf(x):nearbyintf(x)));}
+static uint64_t f64i(double x,int uns,int truncating,int fixed){double r=rd(x,truncating,fixed);if(uns){if(!(r>=0.0&&r<18446744073709551616.0))return UINT64_MAX;return (uint64_t)r;}if(!(r>=-9223372036854775808.0&&r<9223372036854775808.0))return UINT64_C(0x8000000000000000);return (uint64_t)(int64_t)r;}
+static uint64_t f32i64(float x,int uns,int truncating){float r=rf(x,truncating);if(uns){if(!(r>=0.0f&&r<18446744073709551616.0f))return UINT64_MAX;return (uint64_t)r;}if(!(r>=-9223372036854775808.0f&&r<9223372036854775808.0f))return UINT64_C(0x8000000000000000);return (uint64_t)(int64_t)r;}
+static uint32_t f32u32(float x,int truncating){float r=rf(x,truncating);if(!(r>=0.0f&&r<4294967296.0f))return UINT32_MAX;return (uint32_t)r;}
+static uint32_t fb(float x){uint32_t u;memcpy(&u,&x,4);return u;} static uint64_t db(double x){uint64_t u;memcpy(&u,&x,8);return u;}
+static float cu32f(uint32_t x){volatile uint32_t v=x;return (float)v;} static double cu32d(uint32_t x){volatile uint32_t v=x;return (double)v;}
+static float ci64f(int64_t x){volatile int64_t v=x;return (float)v;} static double ci64d(int64_t x){volatile int64_t v=x;return (double)v;}
+static float cu64f(uint64_t x){volatile uint64_t v=x;return (float)v;} static double cu64d(uint64_t x){volatile uint64_t v=x;return (double)v;}
+int main(void){
+ const double d[8]={1.5,2.5,-1.5,-2.5,9223372036854775808.0,-9223372036854775808.0,18446744073709551616.0,NAN};
+ const float f[16]={1.5f,2.5f,-1.5f,-2.5f,0.0f,-0.0f,4294967296.0f,NAN,16777217.0f,2147483648.0f,-2147483904.0f,3.75f,INFINITY,-INFINITY,0x1p-149f,0x1.fffffep127f};
+ const uint32_t ui32[16]={0,1,16777215,16777217,UINT32_MAX,2147483648u,3,5,7,9,11,13,15,17,19,21};
+ const int64_t si64[8]={0,1,-1,INT64_C(9007199254740993),-INT64_C(9007199254740993),INT64_MAX,INT64_MIN,123456789};
+ const uint64_t ui64[8]={0,1,UINT64_C(9007199254740993),UINT64_C(16777217),UINT64_MAX,UINT64_C(1)<<63,3,123456789};
+ const uint64_t old[8]={10,11,12,13,14,15,16,17},mask=UINT64_C(0xa5); unsigned original=_mm_getcsr(); const int modes[4]={FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};
+ for(int rc=0;rc<4;rc++){uint8_t out[993]={0};fesetround(modes[rc]);packednumericconversionsemantics(out,d,f,ui32,si64,ui64,old,mask);
+  for(int i=0;i<8;i++){if(u64(out+i*8)!=f64i(d[i],0,0,0))return 10+rc;if(u64(out+64+i*8)!=f64i(d[i],1,0,0))return 20+rc;
+   int save=fegetround();fesetround(FE_UPWARD);uint64_t ru=f64i(d[i],0,0,0);fesetround(save);if(u64(out+128+i*8)!=ru)return 30+rc;if(u64(out+192+i*8)!=f64i(d[i],1,1,0))return 40+rc;
+   if(u64(out+256+i*8)!=f32i64(f[i],0,0))return 50+rc;if(u64(out+320+i*8)!=f32i64(f[i],1,1))return 60+rc;}
+  for(int i=0;i<16;i++){if(u32(out+384+i*4)!=f32u32(f[0],0))return 70+rc;if(u32(out+448+i*4)!=f32u32(f[i],1))return 80+rc;if(u32(out+512+i*4)!=fb(cu32f(ui32[i])))return 90+rc;
+		int save=fegetround();fesetround(FE_DOWNWARD);uint32_t down=fb(cu32f(ui32[i]));fesetround(save);if(u32(out+576+i*4)!=down){fprintf(stderr,"rd rc=%d i=%d got=%08x want=%08x\n",rc,i,u32(out+576+i*4),down);return 100+i;}}
+  for(int i=0;i<8;i++){if(u64(out+640+i*8)!=db(cu32d(ui32[i])))return 110+rc;if(u64(out+704+i*8)!=db(ci64d(si64[i])))return 120+rc;if(u64(out+768+i*8)!=db(cu64d(ui64[i])))return 130+rc;if(u32(out+832+i*4)!=fb(ci64f(si64[i])))return 140+rc;
+   int save=fegetround();fesetround(FE_UPWARD);uint32_t up=fb(cu64f(ui64[i]));fesetround(save);if(u32(out+864+i*4)!=up)return 150+rc;if(u64(out+896+i*8)!=(((mask>>i)&1)?f64i(d[i],0,0,0):0))return 160+rc;}
+  if(u32(out+960)!=f32u32((float)d[0],0)||u32(out+964)!=f32u32((float)d[1],0)||u64(out+968)!=0){fprintf(stderr,"narrow rc=%d got=%08x,%08x,%016llx want=%08x,%08x,0\n",rc,u32(out+960),u32(out+964),(unsigned long long)u64(out+968),f32u32((float)d[0],0),f32u32((float)d[1],0));return 170+rc;}
+  for(int i=0;i<4;i++)if(u32(out+976+i*4)!=f32u32((float)d[i],1))return 180+rc;if(out[992]!=1)return 190+rc;
+ }
+ _mm_setcsr(original);fesetround(FE_TONEAREST);return 0;
+}
+`
+	x86PackedConversionNativePipelines(t, execution, ir, mainC, nil)
+}
diff --git a/amd64_lower_packed_precision.go b/amd64_lower_packed_precision.go
new file mode 100644
index 000000000..908828b24
--- /dev/null
+++ b/amd64_lower_packed_precision.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPackedPrecisionConvert(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86PackedPrecisionProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ins.Op = op
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: %s needs its matching native x86 MXCSR target", ErrProbeNeedsContext, op)
+	}
+	if c.fpScalarSource.x86SourceStack != nil || c.fpScalarSource.x86FixedLocal != nil {
+		return true, false, fmt.Errorf("%w: %s retains its separate source/frame owner", ErrProbeNeedsContext, op)
+	}
+	source := ins.Args[0]
+	if source.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(source.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+		for at := source.FPOffset; at < source.FPOffset+int64(form.memoryBytes); at++ {
+			if slot, _, _ := c.fpVectorSlot(at); slot.Type == Ptr {
+				return true, false, fmt.Errorf("%w: %s cannot use opaque pointer bits as floating input", ErrProbeNeedsContext, op)
+			}
+		}
+	} else if form.memory >= 0 && !c.nativeMemoryOperand(ins, form.memory) {
+		return true, false, fmt.Errorf("%w: %s needs its original native source address", ErrProbeNeedsContext, op)
+	}
+	base, _, _ := strings.Cut(strings.ToLower(string(op)), ".")
+	mnemonic := base
+	if base == "vcvtpd2psx" || base == "vcvtpd2psy" {
+		mnemonic = "vcvtpd2ps"
+		if form.memory >= 0 && source.Kind != OpFP && !form.properties.broadcast {
+			// AT&T memory syntax needs the source VL, not the narrower
+			// destination carrier, to distinguish X/m128 from Y/m256.
+			mnemonic = base
+		}
+	}
+	return true, false, c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: form.shape.destinationBytes, sourceBytes: form.shape.sourceBytes,
+		memoryBytes: form.memoryBytes, outputBits: form.spec.destinationBits, logicalFPBits: form.spec.sourceBits,
+		lanes: form.shape.lanes, destination: form.destination, mask: form.mask,
+		legacy: form.spec.legacy, evex: form.evex, broadcast: form.properties.broadcast,
+		zeroing: form.properties.zeroing, sae: form.properties.sae, rounding: form.properties.rounding, mnemonic: mnemonic,
+	})
+}
+
+// Independent scalar FP fields supply only their checked little-endian value
+// bytes. Fill unused register-container bytes with private zeros, or replicate
+// one declared scalar for a broadcast; never invent a physical FP address.
+func (c *amd64Ctx) loadPackedConversionFPValue(source Operand, sourceBytes, memoryBytes, bits int, broadcast bool) (string, error) {
+	bytes, err := c.loadFPVectorBytes(source.FPOffset, memoryBytes)
+	if err != nil {
+		return "", err
+	}
+	if broadcast {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, memoryBytes, bytes, bits)
+		lanes := sourceBytes * 8 / bits
+		splat := amd64SplatInteger(c, lanes, bits, "%"+value)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x float>\n", out, lanes, bits, splat, sourceBytes/4)
+		return "%" + out, nil
+	}
+	if memoryBytes != sourceBytes {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> %s\n",
+			out, memoryBytes, bytes, memoryBytes, sourceBytes, llvmI32RangeMask(0, sourceBytes))
+		bytes = "%" + out
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x float>\n", value, sourceBytes, bytes, sourceBytes/4)
+	return "%" + value, nil
+}
diff --git a/amd64_lower_packed_rotate.go b/amd64_lower_packed_rotate.go
new file mode 100644
index 000000000..5db46f95e
--- /dev/null
+++ b/amd64_lower_packed_rotate.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type amd64PackedRotateSpec struct {
+	laneBits int
+	left     bool
+	variable bool
+}
+
+// amd64PackedRotateSpecs covers Go 1.27's complete _yvprold immediate and
+// _yvblendmpd per-lane variable rotate families.
+var amd64PackedRotateSpecs = map[Op]amd64PackedRotateSpec{
+	"VPROLD":  {laneBits: 32, left: true},
+	"VPROLQ":  {laneBits: 64, left: true},
+	"VPRORD":  {laneBits: 32},
+	"VPRORQ":  {laneBits: 64},
+	"VPROLVD": {laneBits: 32, left: true, variable: true},
+	"VPROLVQ": {laneBits: 64, left: true, variable: true},
+	"VPRORVD": {laneBits: 32, variable: true},
+	"VPRORVQ": {laneBits: 64, variable: true},
+}
+
+func (c *amd64Ctx) lowerPackedRotate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, recognized, err := x86PackedRotateProperties(op, ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	return c.emitPackedRotateInstruction(form, ins, mask)
+}
+
+func (c *amd64Ctx) emitPackedRotateInstruction(form x86PackedRotateForm, ins Instr, mask string) (bool, bool, error) {
+	spec, byteWidth := form.spec, form.byteWidth
+	dstArg := ins.Args[form.destination]
+	lanes := byteWidth * 8 / spec.laneBits
+	// EVEX E4 suppresses inactive memory lanes, not merely their results.
+	// The shared reader retains exact volatile active reads and broadcasts.
+	first, err := c.loadX86PackedShiftLanes(ins.Args[form.first], byteWidth, spec.laneBits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	var data, counts string
+	if spec.variable {
+		counts = first
+		data, err = c.loadPackedCompareLanes(ins.Args[form.second], byteWidth, spec.laneBits, false)
+	} else {
+		data = first
+		counts = amd64SplatInteger(c, lanes, spec.laneBits, strconv.Itoa(int(form.immediate)&(spec.laneBits-1)))
+	}
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitPackedRotate(lanes, spec.laneBits, data, counts, spec.left)
+	if mask != "" {
+		old := "zeroinitializer"
+		if !form.zeroing {
+			oldBytes, err := c.loadPackedCompareBytes(dstArg, byteWidth)
+			if err != nil {
+				return true, false, err
+			}
+			old = c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(dstArg, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitPackedRotate(lanes, laneBits int, data, counts string, left bool) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	laneMask := amd64SplatInteger(c, lanes, laneBits, strconv.Itoa(laneBits-1))
+	normalized := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", normalized, vectorType, counts, laneMask)
+	negated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s zeroinitializer, %%%s\n", negated, vectorType, normalized)
+	inverse := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", inverse, vectorType, negated, laneMask)
+
+	low, high := c.newTmp(), c.newTmp()
+	if left {
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", low, vectorType, data, normalized)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", high, vectorType, data, inverse)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", low, vectorType, data, normalized)
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", high, vectorType, data, inverse)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", result, vectorType, low, high)
+	return "%" + result
+}
diff --git a/amd64_lower_packed_shift.go b/amd64_lower_packed_shift.go
new file mode 100644
index 000000000..bb9cdcd8b
--- /dev/null
+++ b/amd64_lower_packed_shift.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerX86PackedShift(op Op, ins Instr) (bool, bool, error) {
+	form, recognized, err := x86PackedShiftProperties(op, ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	local := ins
+	local.Op = op
+	if err := x86LegacyMMXReadEmitterContext(local, c.goarch); err != nil {
+		return true, false, err
+	}
+	if x86PackedShiftHasNativeCount(form) && ins.Args[form.count].Kind == OpFP {
+		return true, false, fmt.Errorf("legacy m128 count needs actual native FP backing: %w", ErrProbeNeedsContext)
+	}
+	if form.memory >= 0 && ins.Args[form.memory].Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(ins.Args[form.memory].FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	dataArg := ins.Args[form.data]
+	var data string
+	if form.mmx {
+		bits, err := c.loadReg(dataArg.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		data = c.bitcastI64ToIntegerLanes(64/form.laneBits, form.laneBits, bits)
+	} else if form.countMode == x86PackedShiftBytes {
+		data, err = c.loadX86PackedShiftBytes(dataArg, form.byteWidth, true)
+	} else {
+		dataMask := ""
+		if form.faultSuppressed && form.memory == form.data {
+			dataMask = mask
+		}
+		if form.memory == form.data && !form.faultSuppressed {
+			bytes, loadErr := c.loadX86PackedShiftBytes(dataArg, form.byteWidth, true)
+			err = loadErr
+			if err == nil {
+				data = c.bitcastVectorBytesToIntegerLanes(form.byteWidth, form.byteWidth*8/form.laneBits, form.laneBits, bytes)
+			}
+		} else {
+			data, err = c.loadX86PackedShiftLanes(dataArg, form.byteWidth, form.laneBits, form.broadcast && form.memory == form.data, dataMask)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.byteWidth * 8 / form.laneBits
+	var result string
+	if form.countMode == x86PackedShiftBytes {
+		result = c.emitPackedByteShift(form.byteWidth, data, uint8(form.countOperand.Imm), form.left)
+	} else {
+		if form.countMode == x86PackedShiftPerLane {
+			counts, err := c.loadX86PackedShiftLanes(ins.Args[form.count], form.byteWidth, form.laneBits, form.broadcast, mask)
+			if err != nil {
+				return true, false, err
+			}
+			operation := "lshr"
+			if form.left {
+				operation = "shl"
+			} else if form.arithmetic {
+				operation = "ashr"
+			}
+			result = c.emitPerLaneVariableShift(amd64PerLaneVariableShiftSpec{
+				laneBits: form.laneBits, operation: operation, arithmetic: form.arithmetic,
+			}, lanes, counts, data)
+		} else if x86PackedShiftHasNativeCount(form) {
+			result, err = c.emitX86PackedShiftNativeCount(form, ins.Args[form.count], data)
+			if err != nil {
+				return true, false, err
+			}
+		} else {
+			count, err := c.loadPackedUniformLogicalShiftCount(form.countOperand, form.mmx)
+			if err != nil {
+				return true, false, err
+			}
+			if form.arithmetic {
+				result = c.emitPackedArithmeticRightShift(lanes, form.laneBits, data, count)
+			} else {
+				result = c.emitPackedLogicalShift(amd64PackedLogicalShiftSpec{laneBits: form.laneBits, left: form.left}, lanes, data, count)
+			}
+		}
+		if form.mask >= 0 {
+			old, err := c.loadPackedCompareLanes(ins.Args[form.destination], form.byteWidth, form.laneBits, false)
+			if err != nil {
+				return true, false, err
+			}
+			result = amd64ApplyIntegerLaneMask(c, lanes, form.laneBits, result, old, mask, form.zeroing)
+		}
+		out := c.newTmp()
+		if form.mmx {
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", out, lanes, form.laneBits, result)
+			return true, false, c.storeReg(ins.Args[form.destination].Reg, "%"+out)
+		}
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.laneBits, result, form.byteWidth)
+		result = "%" + out
+	}
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(ins.Args[form.destination], result)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, result)
+}
+
+// Native reads remain observable even when the shift result is a known zero.
+// Only actual EVEX mask bits can suppress the corresponding memory accesses;
+// LLVM dead-value elimination is not a native fault-suppression contract.
+func (c *amd64Ctx) loadX86PackedShiftLanes(source Operand, width, bits int, broadcast bool, mask string) (string, error) {
+	if source.Kind != OpMem && source.Kind != OpSym && source.Kind != OpFP {
+		return c.loadMaskedPackedCompareLanes(source, width, bits, broadcast, mask)
+	}
+	lanes := width * 8 / bits
+	if mask == "" {
+		bytes := width
+		if broadcast {
+			bytes = bits / 8
+		}
+		value, err := c.loadX86PackedShiftBytes(source, bytes, true)
+		if err != nil {
+			return "", err
+		}
+		if !broadcast {
+			return c.bitcastVectorBytesToIntegerLanes(width, lanes, bits, value), nil
+		}
+		scalar := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", scalar, bytes, value, bits)
+		return amd64SplatInteger(c, lanes, bits, "%"+scalar), nil
+	}
+	load := func(offset int) func() (string, error) {
+		return func() (string, error) {
+			operand := source
+			if operand.Kind == OpFP {
+				operand.FPOffset += int64(offset)
+				bytes, err := c.loadX86PackedShiftBytes(operand, bits/8, true)
+				if err != nil {
+					return "", err
+				}
+				value := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, bits/8, bytes, bits)
+				return "%" + value, nil
+			}
+			pointer, pointerType, _, err := c.packedVectorMemoryPointer(operand)
+			if err != nil {
+				return "", err
+			}
+			at, value := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %d\n", at, pointerType, pointer, offset)
+			fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %%%s, align 1\n", value, bits, pointerType, at)
+			return "%" + value, nil
+		}
+	}
+	if broadcast {
+		relevant, active := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", relevant, mask, uint64(1)<<uint(lanes)-1)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, relevant)
+		value, err := c.loadX86ScalarIf(bits, "%"+active, load(0))
+		if err != nil {
+			return "", err
+		}
+		return amd64SplatInteger(c, lanes, bits, value), nil
+	}
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		selected, active := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", selected, mask, uint64(1)<<uint(lane))
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, selected)
+		value, err := c.loadX86ScalarIf(bits, "%"+active, load(lane*bits/8))
+		if err != nil {
+			return "", err
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, lanes, bits, result, bits, value, lane)
+		result = "%" + inserted
+	}
+	return result, nil
+}
+
+func (c *amd64Ctx) loadX86PackedShiftBytes(source Operand, width int, observable bool) (string, error) {
+	if source.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(source.FPOffset, width); err != nil {
+			return "", err
+		}
+		if c.classicFrame == "" {
+			// Every native ABI0 byte is bound; preserve its little-endian
+			// value without pretending independent allocas are contiguous.
+			return c.loadFPVectorBytes(source.FPOffset, width)
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, ptr %s, align 1\n",
+			value, width, c.classicFramePtr(source.FPOffset))
+		return "%" + value, nil
+	}
+	if !observable || source.Kind != OpMem && source.Kind != OpSym {
+		return c.loadPackedCompareBytes(source, width)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, %s %s, align 1\n", value, width, pointerType, pointer)
+	return "%" + value, nil
+}
diff --git a/amd64_lower_packed_testmask.go b/amd64_lower_packed_testmask.go
new file mode 100644
index 000000000..fd99afe44
--- /dev/null
+++ b/amd64_lower_packed_testmask.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64PackedTestMaskSpec struct {
+	laneBits int
+	testZero bool
+}
+
+var amd64PackedTestMaskSpecs = map[string]amd64PackedTestMaskSpec{
+	"VPTESTMB":  {laneBits: 8},
+	"VPTESTMW":  {laneBits: 16},
+	"VPTESTMD":  {laneBits: 32},
+	"VPTESTMQ":  {laneBits: 64},
+	"VPTESTNMB": {laneBits: 8, testZero: true},
+	"VPTESTNMW": {laneBits: 16, testZero: true},
+	"VPTESTNMD": {laneBits: 32, testZero: true},
+	"VPTESTNMQ": {laneBits: 64, testZero: true},
+}
+
+// lowerPackedTestMask implements the complete Go 1.27 _yvpshufbitqmb
+// operand table shared by VPTESTM{B,W,D,Q} and VPTESTNM{B,W,D,Q}.
+// VPTESTM sets each K bit when the corresponding source-lane intersection is
+// nonzero; VPTESTNM sets it when that intersection is zero.
+func (c *amd64Ctx) lowerPackedTestMask(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86PackedTestMaskProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	first, second := form.source, ins.Args[form.second]
+	destination := ins.Args[form.destination]
+	writeMask := ""
+	if form.mask >= 0 {
+		writeMask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	firstValue, err := c.loadX86PackedShiftLanes(first, byteWidth, spec.laneBits, form.broadcast, writeMask)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, err := c.loadPackedCompareLanes(second, byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	intersection := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", intersection, vectorType, firstValue, secondValue)
+	predicate := "ne"
+	if spec.testZero {
+		predicate = "eq"
+	}
+	tested := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %%%s, zeroinitializer\n", tested, predicate, vectorType, intersection)
+	packedType := fmt.Sprintf("i%d", lanes)
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %%%s to %s\n", packed, lanes, tested, packedType)
+	result := "%" + packed
+	if lanes < 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, packedType, result)
+		result = "%" + wide
+	}
+	if writeMask != "" {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", masked, result, writeMask)
+		result = "%" + masked
+	}
+	return true, false, c.storeK(destination.Reg, result)
+}
diff --git a/amd64_lower_packed_testmask_test.go b/amd64_lower_packed_testmask_test.go
new file mode 100644
index 000000000..2de7a5b5a
--- /dev/null
+++ b/amd64_lower_packed_testmask_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedTestMaskCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 gives VPTESTM{B,W,D,Q} and VPTESTNM{B,W,D,Q} the same
+	// _yvpshufbitqmb operand table: X/Y/Z r/m first source, a matching
+	// vector second source, an optional K1-K7 write mask, and a K
+	// destination. D/Q additionally enable scalar-memory broadcast.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedtestmaskforms(SB),$0-0\n")
+			for _, op := range []string{
+				"VPTESTMB", "VPTESTMW", "VPTESTMD", "VPTESTMQ",
+				"VPTESTNMB", "VPTESTNMW", "VPTESTNMD", "VPTESTNMQ",
+			} {
+				zLast := 31
+				if target.goarch == "386" {
+					zLast = 7
+				}
+				fmt.Fprintf(&source, "\t%s X1, X31, K0\n", op)
+				fmt.Fprintf(&source, "\t%s 8(AX), X31, K2\n", op)
+				fmt.Fprintf(&source, "\t%s Y1, Y31, K3\n", op)
+				fmt.Fprintf(&source, "\t%s 40(AX), Y31, K5\n", op)
+				fmt.Fprintf(&source, "\t%s Z1, Z%d, K6\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s 104(AX), Z%d, K0\n", op, zLast)
+				fmt.Fprintf(&source, "\t%s 0, Z%d, K0\n", op, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s 112(AX), X31, K1, K2\n", op)
+					fmt.Fprintf(&source, "\t%s 120(AX), Y31, K4, K5\n", op)
+					fmt.Fprintf(&source, "\t%s 128(AX), Z31, K7, K0\n", op)
+				}
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					fmt.Fprintf(&source, "\t%s.BCST 168(AX), X31, K1\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 176(AX), Y31, K3\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 184(AX), Z%d, K4\n", op, zLast)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST 192(AX), Y31, K2, K3\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedtestmaskforms": {Name: "packedtestmaskforms", Ret: Void},
+				},
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("bare test-to-mask formats invented numerical entry inputs", err)
+			}
+			want, count := 96, 0
+			if target.goarch == "386" {
+				want = 68
+			}
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Op != OpTEXT && ins.Op != OpRET {
+					count++
+				}
+			}
+			if count != want {
+				t.Fatal("original Go forms disappeared", count, want)
+			}
+			// Keep the original Go-encoded operands as emitter-only objects.
+			// Independent initialized API/value/fault owners supply the proof
+			// that these formats execute correctly with actual input facts.
+			ll = x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{
+				"packedtestmaskforms": {Name: "packedtestmaskforms", Ret: Void},
+			}, target.goarch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+				return c.lowerPackedTestMask(ins.Op, ins)
+			})
+			for _, want := range []string{"icmp ne", "icmp eq", "store i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("translation omitted %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-test-mask-"+target.name+".ll", "packed-test-mask-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedTestMaskRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPTESTMD X0, X1"},
+		{goarch: "amd64", instruction: "VPTESTMD X0, Y1, K1"},
+		{goarch: "amd64", instruction: "VPTESTMD X0, (AX), K1"},
+		{goarch: "amd64", instruction: "VPTESTMD X0, X1, K0, K1"},
+		{goarch: "amd64", instruction: "VPTESTMD X0, X1, AX"},
+		{goarch: "amd64", instruction: "VPTESTMD.Z X0, X1, K1"},
+		{goarch: "amd64", instruction: "VPTESTMB.BCST (AX), X1, K1"},
+		{goarch: "amd64", instruction: "VPTESTMW.BCST (AX), X1, K1"},
+		{goarch: "amd64", instruction: "VPTESTMD.BCST X0, X1, K1"},
+		{goarch: "amd64", instruction: "VPTESTNMQ X32, X1, K1"},
+		{goarch: "386", instruction: "VPTESTMD X1, X2, K1, K2"},
+		{goarch: "386", instruction: "VPTESTMD Z8, Z0, K1"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's packed test-mask forms for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_paddd_alias_test.go b/amd64_lower_paddd_alias_test.go
new file mode 100644
index 000000000..fb838e9d8
--- /dev/null
+++ b/amd64_lower_paddd_alias_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedAddGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]struct {
+		encoding       x86PackedLogicalEncoding
+		laneBits       int
+		mode           amd64PackedAddMode
+		broadcastBytes int
+	}{
+		"PADDB":    {x86PackedLogicalLegacyInteger, 8, amd64PackedAddWrap, 0},
+		"PADDW":    {x86PackedLogicalLegacyInteger, 16, amd64PackedAddWrap, 0},
+		"PADDL":    {x86PackedLogicalLegacyInteger, 32, amd64PackedAddWrap, 0},
+		"PADDD":    {x86PackedLogicalLegacyInteger, 32, amd64PackedAddWrap, 0},
+		"PADDQ":    {x86PackedLogicalLegacyFP, 64, amd64PackedAddWrap, 0},
+		"PADDSB":   {x86PackedLogicalLegacyInteger, 8, amd64PackedAddSignedSaturating, 0},
+		"PADDSW":   {x86PackedLogicalLegacyInteger, 16, amd64PackedAddSignedSaturating, 0},
+		"PADDUSB":  {x86PackedLogicalLegacyInteger, 8, amd64PackedAddUnsignedSaturating, 0},
+		"PADDUSW":  {x86PackedLogicalLegacyInteger, 16, amd64PackedAddUnsignedSaturating, 0},
+		"VPADDB":   {x86PackedLogicalVEXOrEVEX, 8, amd64PackedAddWrap, 0},
+		"VPADDW":   {x86PackedLogicalVEXOrEVEX, 16, amd64PackedAddWrap, 0},
+		"VPADDD":   {x86PackedLogicalVEXOrEVEX, 32, amd64PackedAddWrap, 4},
+		"VPADDQ":   {x86PackedLogicalVEXOrEVEX, 64, amd64PackedAddWrap, 8},
+		"VPADDSB":  {x86PackedLogicalVEXOrEVEX, 8, amd64PackedAddSignedSaturating, 0},
+		"VPADDSW":  {x86PackedLogicalVEXOrEVEX, 16, amd64PackedAddSignedSaturating, 0},
+		"VPADDUSB": {x86PackedLogicalVEXOrEVEX, 8, amd64PackedAddUnsignedSaturating, 0},
+		"VPADDUSW": {x86PackedLogicalVEXOrEVEX, 16, amd64PackedAddUnsignedSaturating, 0},
+	}
+	addCount := 0
+	for _, spec := range x86PackedArithmeticSpecs {
+		if spec.family == x86PackedArithmeticAdd {
+			addCount++
+		}
+	}
+	if addCount != len(expected) {
+		t.Fatal("complete packed-add grammar inventory changed", addCount)
+	}
+	for op, want := range expected {
+		got, known := x86PackedArithmeticSpecForOp(op, x86PackedArithmeticAdd)
+		if !known || got.encoding != want.encoding || got.laneBits != want.laneBits || got.mode != want.mode ||
+			got.broadcastBytes != want.broadcastBytes || got.zeroing != (want.encoding == x86PackedLogicalVEXOrEVEX) {
+			t.Errorf("packed-add grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86PADDDGoAliasCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastX := 15
+			if target.goarch == "386" {
+				lastX = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT padddaliasforms(SB),$0-0\n")
+			for _, op := range []string{"PADDL", "PADDD"} {
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s M0, M7\n", op)
+					fmt.Fprintf(&source, "\t%s 8(AX), M7\n", op)
+				}
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, lastX)
+				fmt.Fprintf(&source, "\t%s 16(AX), X%d\n", op, lastX)
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "padddaliasforms", target.goarch, target.triple)
+			if !strings.Contains(ir, "add <4 x i32>") {
+				t.Fatalf("PADDL/PADDD lowering omitted dword addition:\n%s", ir)
+			}
+			if target.goarch == "amd64" && !strings.Contains(ir, "bitcast i64") {
+				t.Fatalf("PADDL/PADDD lowering omitted MMX forms:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "paddd-alias-"+target.name+".ll", "paddd-alias-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PADDDGoAliasRejectsFormsOutsidePADDLTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PADDD M0, X1"},
+		{goarch: "amd64", instruction: "PADDD X0, M1"},
+		{goarch: "amd64", instruction: "PADDD Y0, Y1"},
+		{goarch: "amd64", instruction: "PADDD.Z X0, X1"},
+		{goarch: "386", instruction: "PADDD M0, M1"},
+		{goarch: "386", instruction: "PADDL M0, M1"},
+		{goarch: "386", instruction: "PADDD X0, X8"},
+		{goarch: "386", instruction: "PADDD 8(R9), X0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside PADDD/PADDL's Go table for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func TestAMD64PADDDGoAliasRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86PADDDGoAliasRuntimeSource
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"padddaliassemantics": {
+				Name: "padddaliassemantics", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void padddaliassemantics(uint8_t *, uint64_t, uint64_t);
+int main(void) {
+  uint8_t out[9] = {0};
+  uint64_t a = UINT64_C(0xffffffff00000002);
+  uint64_t b = UINT64_C(0x0000000200000003);
+  padddaliassemantics(out, a, b);
+  uint64_t got;
+  memcpy(&got, out, 8);
+  if (got != UINT64_C(0x0000000100000005)) return 10;
+  if (out[8] != 1) return 11;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "paddd_alias_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_parallel_bits.go b/amd64_lower_parallel_bits.go
new file mode 100644
index 000000000..ed79e491c
--- /dev/null
+++ b/amd64_lower_parallel_bits.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import "fmt"
+
+// Both BMI2 families share the complete three-word grammar with ANDN.
+// Their operation and preserved FLAGS remain separate.
+func (c *amd64Ctx) lowerParallelBitDepositExtract(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86TernaryGPProperties(op, ins, c.goarch)
+	if !known || form.spec.operation == x86TernaryANDN {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	bits := form.spec.bits
+	typ := amd64IntegerTypeForBits(bits)
+	mask, err := c.evalSizedNativeGPSource(form.first, typ, ins.x86AddressBits)
+	if err != nil {
+		return true, false, err
+	}
+	source, err := c.evalIntSized(form.second, typ)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitParallelBitOperation(form.spec.operation == x86TernaryPDEP, bits, mask, source)
+	return true, false, c.storeRegSized(form.destination.Reg, typ, result)
+}
+
+// emitParallelBitOperation emits target-independent LLVM so translated code
+// retains PDEP/PEXT semantics even when the LLVM execution host lacks BMI2.
+// cursor is at most bit before each iteration, so every variable shift stays
+// strictly below the integer width and cannot produce LLVM poison.
+func (c *amd64Ctx) emitParallelBitOperation(deposit bool, bits int, mask, source string) string {
+	typ := fmt.Sprintf("i%d", bits)
+	result := "0"
+	cursor := "0"
+	for bit := 0; bit < bits; bit++ {
+		shiftedMask := c.newTmp()
+		maskBit := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %d\n", shiftedMask, typ, mask, bit)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 1\n", maskBit, typ, shiftedMask)
+
+		sourceShift := cursor
+		destinationShift := fmt.Sprintf("%d", bit)
+		if !deposit {
+			sourceShift = fmt.Sprintf("%d", bit)
+			destinationShift = cursor
+		}
+		shiftedSource := c.newTmp()
+		sourceBit := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shiftedSource, typ, source, sourceShift)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 1\n", sourceBit, typ, shiftedSource)
+		placed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %s\n", placed, typ, sourceBit, destinationShift)
+		enabledMask := c.newTmp()
+		enabled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s 0, %%%s\n", enabledMask, typ, maskBit)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", enabled, typ, placed, enabledMask)
+		nextResult := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or %s %s, %%%s\n", nextResult, typ, result, enabled)
+		result = "%" + nextResult
+		nextCursor := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %%%s\n", nextCursor, typ, cursor, maskBit)
+		cursor = "%" + nextCursor
+	}
+	return result
+}
diff --git a/amd64_lower_permute.go b/amd64_lower_permute.go
new file mode 100644
index 000000000..f1dc1b579
--- /dev/null
+++ b/amd64_lower_permute.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+// Dword variable permutations share the complete full-vector data/index
+// envelope and E4NF reads with qword variable permutations.
+func (c *amd64Ctx) lowerVariableDwordPermute(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86VariableDwordPermuteProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.lowerElementPermute(form, ins)
+}
diff --git a/amd64_lower_permute128.go b/amd64_lower_permute128.go
new file mode 100644
index 000000000..b2d361219
--- /dev/null
+++ b/amd64_lower_permute128.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPermute128(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86Permute128Properties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	// Type6 has no selector-based fault suppression: even two zero halves
+	// and dead results retain the complete unaligned m256 native access.
+	first, err := c.loadX86PackedShiftBytes(ins.Args[form.first], 32, true)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadPackedCompareBytes(ins.Args[form.second], 32)
+	if err != nil {
+		return true, false, err
+	}
+	a, b, selected := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", a, first)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", b, second)
+	var indices []int
+	var zeros []string
+	hasZero := false
+	for lane := 0; lane < 4; lane++ {
+		at := form.sourceByte(lane * 8)
+		zero := at < 0
+		if zero {
+			at = 0 // A constant select below does not observe this lane.
+		}
+		indices = append(indices, at/8)
+		zeros = append(zeros, fmt.Sprint("i1 ", zero))
+		hasZero = hasZero || zero
+	}
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i64> %%%s, <4 x i64> %%%s, <4 x i32> %s\n",
+		selected, a, b, llvmI32Mask(indices))
+	if hasZero {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <4 x i1> <%s>, <4 x i64> zeroinitializer, <4 x i64> %%%s\n",
+			value, strings.Join(zeros, ", "), selected)
+		selected = value
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", out, selected)
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], 32, "%"+out)
+}
diff --git a/amd64_lower_permute128_test.go b/amd64_lower_permute128_test.go
new file mode 100644
index 000000000..15b029cd6
--- /dev/null
+++ b/amd64_lower_permute128_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86Permute128CompleteGoAssemblerForms(t *testing.T) {
+	const source = `TEXT permute128forms(SB),$0-0
+	VPERM2F128 $0, Y0, Y1, Y2
+	VPERM2F128 $255, 8(AX), Y15, Y15
+	VPERM2I128 $0, Y0, Y1, Y2
+	VPERM2I128 $255, 8(AX), Y15, Y15
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func permute128forms()", "amd64", target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original bare format acquired unknown Y bytes or a native pointer", api, err)
+				}
+			}
+			// Preserve all four original format rows and their target objects
+			// without claiming initialized public or executable semantics.
+			ll := x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"permute128forms": {Name: "permute128forms", Ret: Void}},
+				"amd64", target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPermute128(ins.Op, ins)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "permute-128-"+target.name+".ll", "permute-128-"+target.name+".o", ll)
+		})
+	}
+	requireX86GoAssemblerResult(t, "386", source, false)
+}
+
+func TestTranslateX86Permute128RejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERM2F128 $-1, Y0, Y1, Y2",
+		"VPERM2F128 $256, Y0, Y1, Y2",
+		"VPERM2I128 $-1, Y0, Y1, Y2",
+		"VPERM2I128 $256, Y0, Y1, Y2",
+		"VPERM2I128 $1, X0, Y1, Y2",
+		"VPERM2I128 $1, Y0, 8(AX), Y2",
+		"VPERM2I128 $1, Y0, X1, Y2",
+		"VPERM2I128 $1, Y0, Y1, X2",
+		"VPERM2I128.Z $1, Y0, Y1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			assertX86Permute128Rejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86Permute128Rejected(t, "386", "i386-unknown-linux-gnu", "VPERM2I128 $1, Y0, Y1, Y2")
+}
+
+func assertX86Permute128Rejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VPERM2F128/VPERM2I128 table for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64Permute128RuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT permute128integer(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPERM2I128 $0x21, Y0, Y1, Y2
+	VMOVDQU Y2, (AX)
+	VZEROUPPER
+	RET
+TEXT permute128float(SB),NOSPLIT,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ first+8(FP), BX
+	MOVQ second+16(FP), CX
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPERM2F128 $0x12, Y0, Y1, Y2
+	VMOVDQU Y2, (AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"permute128integer": {Name: "permute128integer", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+			"permute128float":   {Name: "permute128float", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void permute128integer(uint8_t *, const uint8_t *, const uint8_t *);
+extern void permute128float(uint8_t *, const uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t first[32], second[32], out[32];
+  for (int i = 0; i < 32; i++) { first[i] = (uint8_t)i; second[i] = (uint8_t)(100+i); out[i] = 0; }
+	permute128integer(out, first, second);
+	for (int i = 0; i < 16; i++) if (out[i] != second[i+16]) return 10+i;
+	for (int i = 16; i < 32; i++) if (out[i] != first[i-16]) return 50+i;
+	permute128float(out, first, second);
+	for (int i = 0; i < 16; i++) if (out[i] != first[i]) return 90+i;
+	for (int i = 16; i < 32; i++) if (out[i] != second[i]) return 130+i;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "permute_128", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_permute_index_family_test.go b/amd64_lower_permute_index_family_test.go
new file mode 100644
index 000000000..2b7d8921c
--- /dev/null
+++ b/amd64_lower_permute_index_family_test.go
@@ -0,0 +1,271 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64IndexedPermuteGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64IndexedPermuteSpec{
+		"VPERMB":    {laneBits: 8, mode: amd64IndexedPermuteSingle},
+		"VPERMW":    {laneBits: 16, mode: amd64IndexedPermuteSingle},
+		"VPERMI2B":  {laneBits: 8, mode: amd64IndexedPermuteI2},
+		"VPERMI2W":  {laneBits: 16, mode: amd64IndexedPermuteI2},
+		"VPERMI2D":  {laneBits: 32, mode: amd64IndexedPermuteI2, broadcast: true},
+		"VPERMI2PS": {laneBits: 32, mode: amd64IndexedPermuteI2, broadcast: true},
+		"VPERMI2Q":  {laneBits: 64, mode: amd64IndexedPermuteI2, broadcast: true},
+		"VPERMI2PD": {laneBits: 64, mode: amd64IndexedPermuteI2, broadcast: true},
+		"VPERMT2B":  {laneBits: 8, mode: amd64IndexedPermuteT2},
+		"VPERMT2W":  {laneBits: 16, mode: amd64IndexedPermuteT2},
+		"VPERMT2D":  {laneBits: 32, mode: amd64IndexedPermuteT2, broadcast: true},
+		"VPERMT2PS": {laneBits: 32, mode: amd64IndexedPermuteT2, broadcast: true},
+		"VPERMT2Q":  {laneBits: 64, mode: amd64IndexedPermuteT2, broadcast: true},
+		"VPERMT2PD": {laneBits: 64, mode: amd64IndexedPermuteT2, broadcast: true},
+	}
+	if len(amd64IndexedPermuteSpecs) != len(expected) {
+		t.Fatalf("indexed-permute grammar has %d entries, want %d", len(amd64IndexedPermuteSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64IndexedPermuteSpecs[op]; !ok {
+			t.Errorf("indexed-permute grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("indexed-permute grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86IndexedPermuteCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT indexedpermuteforms(SB),$0-0\n")
+			for _, family := range []struct {
+				op        string
+				broadcast bool
+			}{
+				{op: "VPERMB"}, {op: "VPERMW"},
+				{op: "VPERMI2B"}, {op: "VPERMI2W"},
+				{op: "VPERMI2D", broadcast: true}, {op: "VPERMI2Q", broadcast: true},
+				{op: "VPERMI2PS", broadcast: true}, {op: "VPERMI2PD", broadcast: true},
+				{op: "VPERMT2B"}, {op: "VPERMT2W"},
+				{op: "VPERMT2D", broadcast: true}, {op: "VPERMT2Q", broadcast: true},
+				{op: "VPERMT2PS", broadcast: true}, {op: "VPERMT2PD", broadcast: true},
+			} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s1, %s2, %s%d\n", family.op, width, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s2, %s%d\n", family.op, width, width, last)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s1, %s2, K1, %s%d\n", family.op, width, width, width, last)
+						fmt.Fprintf(&source, "\t%s.Z 16(AX), %s2, K2, %s%d\n", family.op, width, width, last)
+					}
+					if family.broadcast {
+						fmt.Fprintf(&source, "\t%s.BCST 24(AX), %s2, %s%d\n", family.op, width, width, last)
+						if target.goarch == "amd64" {
+							fmt.Fprintf(&source, "\t%s.BCST.Z 32(AX), %s2, K3, %s%d\n", family.op, width, width, last)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"indexedpermuteforms": {Name: "indexedpermuteforms", Ret: Void}},
+			})
+			llc := findLLVM22Tool("llc")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original indexed format source invented initialized inputs", err)
+			}
+			ir = x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "IndexedEmitterOnly",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerIndexedPermute(instruction.Op, instruction)
+				})
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "indexed-permute-"+target.name+".ll", "indexed-permute-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86IndexedPermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPERMB X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VPERMW.BCST 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VPERMT2B.BCST 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VPERMT2D.BCST X0, X1, X2"},
+		{goarch: "amd64", instruction: "VPERMT2D.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VPERMI2Q X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VPERMT2PS X0, X1, 0(AX)"},
+		{goarch: "amd64", instruction: "VPERMI2D.Z.BCST 0(AX), X1, K1, X2"},
+		{goarch: "amd64", instruction: "VPERMB X0, X1"},
+		{goarch: "386", instruction: "VPERMT2D X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VPERMW Z0, Z1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's indexed-permute table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64IndexedPermuteRuntimeSemantics(t *testing.T) {
+	// Portable LLVM execution on the actual host, not original-Go/native AVX512.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT indexedpermutesemantics(SB),$0-48
+	MOVQ out+0(FP), AX
+	MOVQ tableA+8(FP), BX
+	MOVQ tableB+16(FP), CX
+	MOVQ indices+24(FP), DX
+	MOVQ old+32(FP), R8
+	MOVQ mask+40(FP), R9
+	KMOVQ R9, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VMOVDQU64 0(DX), Z2
+	VMOVDQU64 0(R8), Z3
+	STC
+	VPERMB Z0, Z2, Z4
+	VMOVDQU64 Z4, 0(AX)
+	VPERMW Z0, Z2, Z4
+	VMOVDQU64 Z4, 64(AX)
+	VPERMI2B Z0, Z1, Z2
+	VMOVDQU64 Z2, 128(AX)
+	VMOVDQU64 0(DX), Z2
+	VPERMT2B Z0, Z2, Z3
+	VMOVDQU64 Z3, 192(AX)
+	VMOVDQU64 0(R8), Z3
+	VPERMB Z0, Z2, K1, Z3
+	VMOVDQU64 Z3, 256(AX)
+	VMOVDQU64 0(R8), Z3
+	VPERMT2W.Z Z0, Z2, K1, Z3
+	VMOVDQU64 Z3, 320(AX)
+	VMOVDQU64 0(DX), Z2
+	VPERMI2Q.BCST 0(BX), Z1, K1, Z2
+	VMOVDQU64 Z2, 384(AX)
+	VMOVDQU64 0(DX), Z2
+	VMOVDQU64 0(R8), Z3
+	VPERMT2D.BCST 0(BX), Z2, K1, Z3
+	VMOVDQU64 Z3, 448(AX)
+	SETCS 512(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"indexedpermutesemantics": {
+			Name: "indexedpermutesemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: I64, Index: 5, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void indexedpermutesemantics(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static uint16_t u16(const uint8_t *p) { uint16_t v; memcpy(&v,p,2); return v; }
+static uint32_t u32(const uint8_t *p) { uint32_t v; memcpy(&v,p,4); return v; }
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  uint64_t a64[8], b64[8], indices64[8], old64[8], output64[65] = {0};
+  uint8_t *a=(uint8_t *)a64, *b=(uint8_t *)b64, *indices=(uint8_t *)indices64;
+  uint8_t *old=(uint8_t *)old64, *out=(uint8_t *)output64;
+  const uint64_t mask=UINT64_C(0xa55af00ff00fa55a);
+  for (int i=0;i<64;i++) {
+    a[i]=(uint8_t)(0x11u+3u*(unsigned)i);
+    b[i]=(uint8_t)(0x80u+5u*(unsigned)i);
+    indices[i]=(uint8_t)(7u+13u*(unsigned)i);
+    old[i]=(uint8_t)(0xe0u-(unsigned)i);
+  }
+  indexedpermutesemantics(out,a,b,indices,old,mask);
+  for (int i=0;i<64;i++) {
+    unsigned index=indices[i]&63u;
+    if (out[i]!=a[index]) return 10;
+    unsigned two=indices[i]&127u;
+    uint8_t want=two<64u ? b[two] : a[two-64u];
+    if (out[128+i]!=want) return 11;
+    want=two<64u ? old[two] : a[two-64u];
+    if (out[192+i]!=want) return 12;
+    want=(mask>>i)&1u ? a[index] : old[i];
+    if (out[256+i]!=want) return 13;
+  }
+  for (int i=0;i<32;i++) {
+    unsigned index=u16(indices+2*i)&31u;
+    if (u16(out+64+2*i)!=u16(a+2*index)) return 20;
+    unsigned two=u16(indices+2*i)&63u;
+    uint16_t want=two<32u ? u16(old+2*two) : u16(a+2*(two-32u));
+    if (u16(out+320+2*i)!=(((mask>>i)&1u)?want:0)) return 21;
+  }
+  for (int i=0;i<8;i++) {
+    unsigned index=(unsigned)(u64(indices+8*i)&15u);
+    uint64_t value=index<8u ? u64(b+8*index) : u64(a);
+    uint64_t want=(mask>>i)&1u ? value : u64(indices+8*i);
+    if (u64(out+384+8*i)!=want) return 30;
+  }
+  for (int i=0;i<16;i++) {
+    unsigned index=u32(indices+4*i)&31u;
+    uint32_t value=index<16u ? u32(old+4*index) : u32(a);
+    uint32_t want=(mask>>i)&1u ? value : u32(old+4*i);
+    if (u32(out+448+4*i)!=want) return 31;
+  }
+  if (out[512]!=1) return 40;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "indexed_permute_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_permute_inlane.go b/amd64_lower_permute_inlane.go
new file mode 100644
index 000000000..3975de8f3
--- /dev/null
+++ b/amd64_lower_permute_inlane.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// lowerInLaneFloatingPermute implements the complete Go 1.27 _yvpermilpd
+// operand family shared by VPERMILPD and VPERMILPS. The permutation preserves
+// element bits and never selects across a 128-bit lane.
+func (c *amd64Ctx) lowerInLaneFloatingPermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86InLanePermuteProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.lowerElementPermute(form, ins)
+}
+
+func (c *amd64Ctx) lowerElementPermute(form x86ElementPermuteForm, ins Instr) (bool, bool, error) {
+	lanes := form.byteWidth * 8 / form.bits
+	readWidth := form.byteWidth
+	if form.memory >= 0 {
+		readWidth = form.memoryBytes
+	}
+	// E4NF retains the complete source/control tuple even for a dead result,
+	// an immediate selecting one lane, or a zero opmask. Share exact volatile
+	// unaligned reads, not an LLVM load that optimization may discard.
+	bytes, err := c.loadX86PackedShiftBytes(ins.Args[form.source], readWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	var input string
+	if form.broadcast {
+		scalar := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", scalar, readWidth, bytes, form.bits)
+		input = amd64SplatInteger(c, lanes, form.bits, "%"+scalar)
+	} else {
+		input = c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.bits, bytes)
+	}
+	var result string
+	if form.immediate {
+		result = c.emitImmediateElementPermute(input, form)
+	} else {
+		dataBytes, err := c.loadPackedCompareBytes(ins.Args[form.data], form.byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		data := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.bits, dataBytes)
+		if form.wholeVector {
+			// Whole-vector r/m is data, whereas VPERMIL r/m is control.
+			data, input = input, data
+		}
+		result = c.emitVariableElementPermute(data, input, form)
+	}
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(ins.Args[form.destination], form.byteWidth, form.bits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.bits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.bits, result, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitImmediateElementPermute(data string, form x86ElementPermuteForm) string {
+	lanes, laneBits := form.byteWidth*8/form.bits, form.bits
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		sourceLane := form.sourceByte(lane*(laneBits/8)) / (laneBits / 8)
+		value := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", value, lanes, laneBits, data, sourceLane)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, laneBits, result, laneBits, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitVariableElementPermute(data, control string, form x86ElementPermuteForm) string {
+	lanes, laneBits := form.byteWidth*8/form.bits, form.bits
+	result := "poison"
+	groupLanes := 128 / laneBits
+	if form.wholeVector {
+		groupLanes = lanes
+	}
+	for lane := 0; lane < lanes; lane++ {
+		controlLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", controlLane, lanes, laneBits, control, lane)
+		selectorValue := "%" + controlLane
+		if laneBits == 64 && !form.wholeVector {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 1\n", shifted, controlLane)
+			selectorValue = "%" + shifted
+		}
+		selector := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %s, %d\n", selector, laneBits, selectorValue, groupLanes-1)
+		index := "%" + selector
+		groupBase := lane / groupLanes * groupLanes
+		if groupBase != 0 {
+			withBase := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i%d %%%s, %d\n", withBase, laneBits, selector, groupBase)
+			index = "%" + withBase
+		}
+		value := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i%d %s\n", value, lanes, laneBits, data, laneBits, index)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, laneBits, result, laneBits, value, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_permute_inlane_test.go b/amd64_lower_permute_inlane_test.go
new file mode 100644
index 000000000..53c357d60
--- /dev/null
+++ b/amd64_lower_permute_inlane_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86InLaneFloatingPermuteCompleteGoAssemblerForms(t *testing.T) {
+	// VPERMILPD and VPERMILPS share Go 1.27's 18-row _yvpermilpd table:
+	// immediate and variable-control VEX X/Y forms, EVEX X/Y/Z forms,
+	// scalar-memory broadcast, and K1-K7 merge/zero masking.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			zLast := 21
+			if target.goarch == "386" {
+				zLast = 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT inlanefloatingpermuteforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VPERMILPD", "VPERMILPS"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&src, "\t%s $-128, %s0, %s1\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s $255, (AX), %s2\n", op, width)
+					fmt.Fprintf(&src, "\t%s %s0, %s1, %s2\n", op, width, width, width)
+					fmt.Fprintf(&src, "\t%s (AX), %s20, %s21\n", op, width, width)
+					fmt.Fprintf(&src, "\t%s $7, %s20, %s21\n", op, width, width)
+				}
+				fmt.Fprintf(&src, "\t%s $255, Z0, Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s Z0, Z6, Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s.BCST $7, (AX), Z%d\n", op, zLast)
+				fmt.Fprintf(&src, "\t%s.BCST (AX), Z6, Z%d\n", op, zLast)
+				if target.goarch == "amd64" {
+					for _, width := range []string{"X", "Y", "Z"} {
+						fmt.Fprintf(&src, "\t%s $7, %s20, K1, %s21\n", op, width, width)
+						fmt.Fprintf(&src, "\t%s.Z $7, (AX), K2, %s22\n", op, width)
+						fmt.Fprintf(&src, "\t%s %s20, %s21, K3, %s22\n", op, width, width, width)
+						fmt.Fprintf(&src, "\t%s.BCST.Z (AX), %s21, K4, %s22\n", op, width, width)
+					}
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			physical, contextual := 52, 0
+			if target.goarch == "386" {
+				physical, contextual = 20, 8
+			}
+			ll := x86InLanePermuteUnboundFormatObject(t, src.String(), target.goarch, target.triple, physical, contextual)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "in-lane-floating-permute-"+target.name+".ll", "in-lane-floating-permute-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86InLaneFloatingPermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMILPS $-129, X0, X1",
+		"VPERMILPD $256, X0, X1",
+		"VPERMILPS $-1, X20, X21",
+		"VPERMILPD $-1, Z0, Z1",
+		"VPERMILPS X0, X1",
+		"VPERMILPD X0, Y1, Y2",
+		"VPERMILPS X0, X1, (AX)",
+		"VPERMILPD.BCST X0, X1, X2",
+		"VPERMILPS.BCST $7, X0, X1",
+		"VPERMILPD.Z $7, X0, X1",
+		"VPERMILPS X0, X1, K0, X2",
+		"VPERMILPD.SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86InLaneFloatingPermuteRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+
+	for _, instruction := range []string{
+		"VPERMILPS $7, Z8, Z0",
+		"VPERMILPD Z0, Z1, Z8",
+		"VPERMILPS $-1, X20, X21",
+		"VPERMILPD X0, X1, K1, X2",
+		"VPERMILPS.Z $7, X0, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86InLaneFloatingPermuteRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86InLaneFloatingPermuteRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's _yvpermilpd forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_permute_qword.go b/amd64_lower_permute_qword.go
new file mode 100644
index 000000000..affe58d1f
--- /dev/null
+++ b/amd64_lower_permute_qword.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+// Qword permutations reuse the complete typed operand and E4NF read machinery
+// with VPERMIL, not its 128-bit selector or variable control/data ordering.
+func (c *amd64Ctx) lowerQwordPermute(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86QwordPermuteProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.lowerElementPermute(form, ins)
+}
diff --git a/amd64_lower_permute_two_source.go b/amd64_lower_permute_two_source.go
new file mode 100644
index 000000000..e29b383a5
--- /dev/null
+++ b/amd64_lower_permute_two_source.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import "fmt"
+
+type amd64IndexedPermuteMode uint8
+
+const (
+	amd64IndexedPermuteSingle amd64IndexedPermuteMode = iota
+	amd64IndexedPermuteI2
+	amd64IndexedPermuteT2
+)
+
+type amd64IndexedPermuteSpec struct {
+	laneBits  int
+	mode      amd64IndexedPermuteMode
+	broadcast bool
+}
+
+// amd64IndexedPermuteSpecs models the complete Go 1.27 _yvblendmpd grammar
+// for the single-table VPERMB/W and both two-table VPERMI2*/VPERMT2*
+// families. Broadcast capability is an opcode property, not a consequence of
+// lane width alone.
+var amd64IndexedPermuteSpecs = map[Op]amd64IndexedPermuteSpec{
+	"VPERMB":    {laneBits: 8, mode: amd64IndexedPermuteSingle},
+	"VPERMW":    {laneBits: 16, mode: amd64IndexedPermuteSingle},
+	"VPERMI2B":  {laneBits: 8, mode: amd64IndexedPermuteI2},
+	"VPERMI2W":  {laneBits: 16, mode: amd64IndexedPermuteI2},
+	"VPERMI2D":  {laneBits: 32, mode: amd64IndexedPermuteI2, broadcast: true},
+	"VPERMI2PS": {laneBits: 32, mode: amd64IndexedPermuteI2, broadcast: true},
+	"VPERMI2Q":  {laneBits: 64, mode: amd64IndexedPermuteI2, broadcast: true},
+	"VPERMI2PD": {laneBits: 64, mode: amd64IndexedPermuteI2, broadcast: true},
+	"VPERMT2B":  {laneBits: 8, mode: amd64IndexedPermuteT2},
+	"VPERMT2W":  {laneBits: 16, mode: amd64IndexedPermuteT2},
+	"VPERMT2D":  {laneBits: 32, mode: amd64IndexedPermuteT2, broadcast: true},
+	"VPERMT2PS": {laneBits: 32, mode: amd64IndexedPermuteT2, broadcast: true},
+	"VPERMT2Q":  {laneBits: 64, mode: amd64IndexedPermuteT2, broadcast: true},
+	"VPERMT2PD": {laneBits: 64, mode: amd64IndexedPermuteT2, broadcast: true},
+}
+
+// lowerIndexedPermute implements Go 1.27's complete single- and two-table
+// indexed-permute family.
+func (c *amd64Ctx) lowerIndexedPermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, spec, known, err := x86IndexedPermuteProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	destination := ins.Args[form.destination]
+	first, second, byteWidth := ins.Args[form.first], ins.Args[form.second], form.byteWidth
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	lanes := byteWidth * 8 / spec.laneBits
+	// Indexed table reads are E4NF, not destination-lane masked loads. Keep
+	// the complete tuple/broadcast even for zero masks or unused tables.
+	firstValue, err := c.loadX86PackedShiftLanes(first, byteWidth, spec.laneBits, form.broadcast, "")
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, err := c.loadPackedCompareLanes(second, byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+	computed := ""
+	switch spec.mode {
+	case amd64IndexedPermuteSingle:
+		// Plan 9 lists Intel's r/m table first and its index vector second.
+		computed = c.emitSingleTablePermute(lanes, spec.laneBits, firstValue, secondValue)
+	case amd64IndexedPermuteI2:
+		// VPERMI2 gets indices from the old destination. Intel calls the
+		// Plan 9 second operand table 0 and the first operand table 1.
+		computed = c.emitTwoTablePermute(lanes, spec.laneBits, secondValue, firstValue, old)
+	case amd64IndexedPermuteT2:
+		// VPERMT2 gets indices from the Plan 9 second operand. The old
+		// destination is table 0 and the Plan 9 first operand is table 1.
+		computed = c.emitTwoTablePermute(lanes, spec.laneBits, old, firstValue, secondValue)
+	}
+	if form.mask >= 0 {
+		computed = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, computed, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, computed, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitSingleTablePermute(lanes, laneBits int, table, indices string) string {
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		indexValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", indexValue, lanes, laneBits, indices, lane)
+		bounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", bounded, laneBits, indexValue, lanes-1)
+		indexI32 := "%" + bounded
+		if laneBits < 32 {
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i32\n", converted, laneBits, bounded)
+			indexI32 = "%" + converted
+		} else if laneBits > 32 {
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i%d %%%s to i32\n", converted, laneBits, bounded)
+			indexI32 = "%" + converted
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %s\n", selected, lanes, laneBits, table, indexI32)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, laneBits, result, laneBits, selected, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitTwoTablePermute(lanes, laneBits int, table0, table1, indices string) string {
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		indexValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", indexValue, lanes, laneBits, indices, lane)
+		bounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", bounded, laneBits, indexValue, 2*lanes-1)
+		useTable1 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp uge i%d %%%s, %d\n", useTable1, laneBits, bounded, lanes)
+		withinTable := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", withinTable, laneBits, bounded, lanes-1)
+		indexI32 := "%" + withinTable
+		if laneBits < 32 {
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i32\n", converted, laneBits, withinTable)
+			indexI32 = "%" + converted
+		} else if laneBits > 32 {
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i%d %%%s to i32\n", converted, laneBits, withinTable)
+			indexI32 = "%" + converted
+		}
+		fromTable0 := c.newTmp()
+		fromTable1 := c.newTmp()
+		selected := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %s\n", fromTable0, lanes, laneBits, table0, indexI32)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %s\n", fromTable1, lanes, laneBits, table1, indexI32)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", selected, useTable1, laneBits, fromTable1, laneBits, fromTable0)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, lanes, laneBits, result, laneBits, selected, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_permute_two_source_test.go b/amd64_lower_permute_two_source_test.go
new file mode 100644
index 000000000..eb829ef16
--- /dev/null
+++ b/amd64_lower_permute_two_source_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86TwoSourcePermuteCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 shares _yvblendmpd across VPERMI2{B,W,D,Q,PS,PD}: matching
+	// X/Y/Z sources and destination, optional K1-K7 masking, and .Z. The
+	// D/Q/PS/PD forms also accept .BCST on a memory first source.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 20
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT twosourcepermuteforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VPERMI2B", "VPERMI2W", "VPERMI2D", "VPERMI2Q", "VPERMI2PS", "VPERMI2PD"} {
+				fmt.Fprintf(&source, "\t%s X1, X20, X21\n", op)
+				fmt.Fprintf(&source, "\t%s 8(AX), Y20, Y21\n", op)
+				fmt.Fprintf(&source, "\t%s Z1, Z2, Z%d\n", op, lastZ)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X20, K1, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z Y1, Y20, K2, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 40(AX), Z20, K3, Z21\n", op)
+				}
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") || strings.HasSuffix(op, "PS") || strings.HasSuffix(op, "PD") {
+					fmt.Fprintf(&source, "\t%s.BCST 104(AX), X20, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 112(AX), Y20, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST 120(AX), Z2, Z%d\n", op, lastZ)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST.Z 128(AX), Z20, K4, Z21\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"twosourcepermuteforms": {Name: "twosourcepermuteforms", Ret: Void},
+				},
+			})
+			llc := findLLVM22Tool("llc")
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original two-source format invented initialized tables or indices", err)
+			}
+			requireX86GoAssemblerResult(t, target.goarch, "#include \"textflag.h\"\n"+source.String(), true)
+			ll = x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "TwoSourceEmitterOnly",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerIndexedPermute(instruction.Op, instruction)
+				})
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "two-source-permute-"+target.name+".ll", "two-source-permute-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86TwoSourcePermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMI2D X0, X1",
+		"VPERMI2D X0, Y1, Y2",
+		"VPERMI2D X0, (AX), X2",
+		"VPERMI2D X0, X1, K0, X2",
+		"VPERMI2D X0, X1, AX",
+		"VPERMI2D.Z X0, X1, X2",
+		"VPERMI2D.BCST X0, X1, X2",
+		"VPERMI2B.BCST (AX), X1, X2",
+		"VPERMI2W.BCST (AX), X1, X2",
+		"VPERMI2D.Z.BCST (AX), X1, K1, X2",
+		"VPERMI2D.RN_SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86TwoSourcePermuteRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86TwoSourcePermuteRejected(t, "386", "i386-unknown-linux-gnu", "VPERMI2D X0, X1, K1, X2")
+	assertX86TwoSourcePermuteRejected(t, "386", "i386-unknown-linux-gnu", "VPERMI2D Z0, Z1, Z8")
+}
+
+func assertX86TwoSourcePermuteRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VPERMI2 forms", instruction)
+	}
+}
diff --git a/amd64_lower_popcount_vector.go b/amd64_lower_popcount_vector.go
new file mode 100644
index 000000000..9cd7a04b9
--- /dev/null
+++ b/amd64_lower_popcount_vector.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import "fmt"
+
+type amd64PackedBitCountKind uint8
+
+const (
+	amd64PackedPopulationCount amd64PackedBitCountKind = iota
+	amd64PackedLeadingZeroCount
+)
+
+type amd64PackedBitCountSpec struct {
+	laneBits  int
+	kind      amd64PackedBitCountKind
+	broadcast bool
+}
+
+// amd64PackedBitCountSpecs models the complete Go 1.27 _yvexpandpd grammar
+// for packed population-count and leading-zero-count instructions.
+var amd64PackedBitCountSpecs = map[Op]amd64PackedBitCountSpec{
+	"VPOPCNTB": {laneBits: 8, kind: amd64PackedPopulationCount},
+	"VPOPCNTW": {laneBits: 16, kind: amd64PackedPopulationCount},
+	"VPOPCNTD": {laneBits: 32, kind: amd64PackedPopulationCount, broadcast: true},
+	"VPOPCNTQ": {laneBits: 64, kind: amd64PackedPopulationCount, broadcast: true},
+	"VPLZCNTD": {laneBits: 32, kind: amd64PackedLeadingZeroCount, broadcast: true},
+	"VPLZCNTQ": {laneBits: 64, kind: amd64PackedLeadingZeroCount, broadcast: true},
+}
+
+// lowerPackedBitCount implements X/Y/Z register or memory sources, K1-K7
+// merge and .Z, and each opcode's scalar-memory broadcast forms.
+func (c *amd64Ctx) lowerPackedBitCount(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86PackedBitCountProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	source, destination := ins.Args[form.first], ins.Args[form.destination]
+	mask := ""
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	lanes := byteWidth * 8 / spec.laneBits
+	// E4 suppresses inactive native lanes; enabled reads remain observable
+	// even when the computed count is dead. FP fields keep their full span.
+	sourceValue, err := c.loadX86PackedShiftLanes(source, byteWidth, spec.laneBits, form.broadcast, mask)
+	if err != nil {
+		return true, false, err
+	}
+	computed := c.newTmp()
+	if spec.kind == amd64PackedLeadingZeroCount {
+		fmt.Fprintf(c.b, "  %%%s = call <%d x i%d> @llvm.ctlz.v%di%d(<%d x i%d> %s, i1 false)\n",
+			computed, lanes, spec.laneBits, lanes, spec.laneBits, lanes, spec.laneBits, sourceValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <%d x i%d> @llvm.ctpop.v%di%d(<%d x i%d> %s)\n",
+			computed, lanes, spec.laneBits, lanes, spec.laneBits, lanes, spec.laneBits, sourceValue)
+	}
+	result := "%" + computed
+	if form.mask >= 0 {
+		oldBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
diff --git a/amd64_lower_popcount_vector_test.go b/amd64_lower_popcount_vector_test.go
new file mode 100644
index 000000000..fc468ce53
--- /dev/null
+++ b/amd64_lower_popcount_vector_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedPopcountCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedpopcountforms(SB),$0-0\n")
+			for _, op := range []string{"VPOPCNTB", "VPOPCNTW", "VPOPCNTD", "VPOPCNTQ"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 22
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s0, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s %s0, K1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), K7, %s%d\n", op, width, last)
+					if op == "VPOPCNTD" || op == "VPOPCNTQ" {
+						fmt.Fprintf(&source, "\t%s.BCST 8(AX), %s%d\n", op, width, last)
+						fmt.Fprintf(&source, "\t%s.BCST.Z 8(AX), K2, %s%d\n", op, width, last)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedpopcountforms": {Name: "packedpopcountforms", Ret: Void},
+				},
+			})
+			llc := findLLVM22Tool("llc")
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original population-count format invented initialized inputs", err)
+			}
+			ll = x86ZeroArgumentLowererObjectUnit(t, file, target.goarch, target.triple, "PopcountEmitterOnly",
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return consumer.lowerPackedBitCount(instruction.Op, instruction)
+				})
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-popcount-"+target.name+".ll", "packed-popcount-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedPopcountRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPOPCNTB.BCST 8(AX), X1",
+		"VPOPCNTW.BCST 8(AX), Z1",
+		"VPOPCNTD.BCST X0, X1",
+		"VPOPCNTQ X0, Y1",
+		"VPOPCNTB X0, K0, X1",
+		"VPOPCNTW.Z X0, X1",
+		"VPOPCNTD.SAE X0, X1",
+		"VPOPCNTQ X0, 8(AX)",
+		"VPOPCNTB AX, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			if currentGoMinorAtLeast(27) {
+				requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			}
+			assertX86PackedPopcountRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VPOPCNTD Z8, K1, Z0",
+		"VPOPCNTQ Z0, Z8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			if currentGoMinorAtLeast(27) {
+				requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			}
+			assertX86PackedPopcountRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedPopcountRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's _yvexpandpd forms for %s", instruction, goarch)
+	}
+}
+
+func TestAMD64PackedPopcountRuntimeSemantics(t *testing.T) {
+	// Portable LLVM execution on the actual host, not original-Go/native AVX512.
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT packedpopcount(SB),$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ mask+24(FP), DX
+	KMOVQ DX, K1
+	VMOVDQU64 (BX), Z0
+	VMOVDQU64 (CX), Z1
+	VPOPCNTB Z0, Z2
+	VMOVDQU64 Z2, 0(AX)
+	VPOPCNTW Z0, K1, Z1
+	VMOVDQU64 Z1, 64(AX)
+	VPOPCNTD.Z Z0, K1, Z1
+	VMOVDQU64 Z1, 128(AX)
+	VPOPCNTQ (BX), Z2
+	VMOVDQU64 Z2, 192(AX)
+	VPOPCNTD.BCST (BX), Z2
+	VMOVDQU64 Z2, 256(AX)
+	VPOPCNTQ.BCST.Z (BX), K1, Z1
+	VMOVDQU64 Z1, 320(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: I64, Index: 3, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packedpopcount": {Name: "packedpopcount", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+extern void packedpopcount(uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static unsigned pop64(uint64_t v) {
+  unsigned n = 0;
+  while (v) { n += v & 1; v >>= 1; }
+  return n;
+}
+int main(void) {
+  uint8_t source[64], old[64], out[384];
+  const uint64_t mask = 0xa55a5aa5ULL;
+  for (int i = 0; i < 64; i++) { source[i] = (uint8_t)(i * 37 + 11); old[i] = (uint8_t)(0xe0 - i); }
+  memset(out, 0xcc, sizeof(out));
+  packedpopcount(out, source, old, mask);
+  for (int i = 0; i < 64; i++) if (out[i] != pop64(source[i])) return 10 + i;
+  for (int i = 0; i < 32; i++) {
+    uint16_t src, prior, got; memcpy(&src, source+2*i, 2); memcpy(&prior, old+2*i, 2); memcpy(&got, out+64+2*i, 2);
+    uint16_t want = (mask >> i) & 1 ? (uint16_t)pop64(src) : prior;
+    if (got != want) return 80 + i;
+  }
+  for (int i = 0; i < 16; i++) {
+    uint32_t src, got; memcpy(&src, source+4*i, 4); memcpy(&got, out+128+4*i, 4);
+    uint32_t want = (mask >> i) & 1 ? pop64(src) : 0;
+    if (got != want) return 120 + i;
+  }
+  for (int i = 0; i < 8; i++) {
+    uint64_t src, got; memcpy(&src, source+8*i, 8); memcpy(&got, out+192+8*i, 8);
+    if (got != pop64(src)) return 150 + i;
+  }
+  uint32_t first32; memcpy(&first32, source, 4);
+  for (int i = 0; i < 16; i++) { uint32_t got; memcpy(&got, out+256+4*i, 4); if (got != pop64(first32)) return 170 + i; }
+  uint64_t first64; memcpy(&first64, source, 8);
+  for (int i = 0; i < 8; i++) { uint64_t got; memcpy(&got, out+320+8*i, 8); uint64_t want = (mask >> i) & 1 ? pop64(first64) : 0; if (got != want) return 190 + i; }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_popcount", triple, ll, mainC, nil)
+}
diff --git a/amd64_lower_portio.go b/amd64_lower_portio.go
new file mode 100644
index 000000000..c48177ec7
--- /dev/null
+++ b/amd64_lower_portio.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func x86PortScalarProperties(op Op) (input bool, typ LLVMType, ok bool) {
+	switch strings.ToUpper(string(op)) {
+	case "INB":
+		return true, I8, true
+	case "INW":
+		return true, I16, true
+	case "INL":
+		return true, I32, true
+	case "OUTB":
+		return false, I8, true
+	case "OUTW":
+		return false, I16, true
+	case "OUTL":
+		return false, I32, true
+	default:
+		return false, "", false
+	}
+}
+
+func x86PortStringProperties(op Op) (input bool, width int, ok bool) {
+	switch strings.ToUpper(string(op)) {
+	case "INSB":
+		return true, 1, true
+	case "INSW":
+		return true, 2, true
+	case "INSL":
+		return true, 4, true
+	case "OUTSB":
+		return false, 1, true
+	case "OUTSW":
+		return false, 2, true
+	case "OUTSL":
+		return false, 4, true
+	default:
+		return false, 0, false
+	}
+}
+
+// lowerPortIO implements the complete x86 port-I/O rows in Go's yin and
+// ynone operand tables. These instructions are inherently target-specific, so
+// preserving them as constrained LLVM inline assembly is both more accurate
+// and safer than pretending that they are ordinary memory accesses.
+func (c *amd64Ctx) lowerPortIO(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if input, typ, scalar := x86PortScalarProperties(op); scalar {
+		if c.repeatPrefix != "" {
+			prefix := c.repeatPrefix
+			c.repeatPrefix = ""
+			return true, false, fmt.Errorf("%s %s prefix is unsupported for %s", c.goarch, prefix, op)
+		}
+		if len(ins.Args) > 1 || (len(ins.Args) == 1 && ins.Args[0].Kind != OpImm) {
+			return true, false, fmt.Errorf("%s %s expects no operand or one immediate: %q", c.goarch, op, ins.Raw)
+		}
+		if len(ins.Args) == 1 && (ins.Args[0].Imm < -1<<31 || ins.Args[0].Imm > 1<<32-1) {
+			return true, false, fmt.Errorf("%s %s immediate is outside the Go assembler's 32-bit form: %q", c.goarch, op, ins.Raw)
+		}
+		return true, false, c.lowerScalarPortIO(strings.ToLower(string(op)), input, typ, ins.Args)
+	}
+
+	input, _, stringOp := x86PortStringProperties(op)
+	if !stringOp {
+		return false, false, nil
+	}
+	prefix := c.repeatPrefix
+	c.repeatPrefix = ""
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, op, ins.Raw)
+	}
+	return true, false, c.lowerStringPortIO(strings.ToLower(string(op)), input, prefix)
+}
+
+func (c *amd64Ctx) lowerScalarPortIO(asm string, input bool, typ LLVMType, args []Operand) error {
+	constraints := "~{dirflag},~{fpsr},~{flags}"
+	if input {
+		call := c.newTmp()
+		if len(args) == 0 {
+			port, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, I16)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(i16 %s)\n", call, typ, asm+" $1, $0", "={ax},{dx},"+constraints, port)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n", call, typ, fmt.Sprintf("%s $$%d, $0", asm, int64(args[0].Imm)), "={ax},"+constraints)
+		}
+		return c.storeRegSized(AX, typ, "%"+call)
+	}
+
+	value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, typ)
+	if err != nil {
+		return err
+	}
+	if len(args) == 0 {
+		port, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, I16)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s, i16 %s)\n", asm+" $0, $1", "{ax},{dx},"+constraints, typ, value, port)
+		return nil
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s)\n", fmt.Sprintf("%s $0, $$%d", asm, int64(args[0].Imm)), "{ax},"+constraints, typ, value)
+	return nil
+}
+
+func (c *amd64Ctx) lowerStringPortIO(asm string, input bool, prefix string) error {
+	indexReg := SI
+	indexConstraint := "{si}"
+	if input {
+		indexReg = DI
+		indexConstraint = "{di}"
+	}
+	index, err := c.loadReg(indexReg)
+	if err != nil {
+		return err
+	}
+	port, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, I16)
+	if err != nil {
+		return err
+	}
+	wordType := I64
+	if c.goarch == "386" {
+		wordType = I32
+		index = c.truncI64(index, I32)
+	}
+	clobbers := "~{memory},~{dirflag},~{fpsr},~{flags}"
+	if prefix == "" {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(i16 %s, %s %s)\n", call, wordType, asm, "="+indexConstraint+",{dx},0,"+clobbers, port, wordType, index)
+		return c.storeRegSized(indexReg, wordType, "%"+call)
+	}
+
+	count, err := c.loadReg(CX)
+	if err != nil {
+		return err
+	}
+	if c.goarch == "386" {
+		count = c.truncI64(count, I32)
+	}
+	call := c.newTmp()
+	resultType := fmt.Sprintf("{ %s, %s }", wordType, wordType)
+	asmPrefix := "rep"
+	if prefix == "REPN" {
+		asmPrefix = "repne"
+	}
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(i16 %s, %s %s, %s %s)\n", call, resultType, asmPrefix+"; "+asm, "="+indexConstraint+",={cx},{dx},0,1,"+clobbers, port, wordType, index, wordType, count)
+	nextIndex := c.newTmp()
+	nextCount := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", nextIndex, resultType, call)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", nextCount, resultType, call)
+	if err := c.storeRegSized(indexReg, wordType, "%"+nextIndex); err != nil {
+		return err
+	}
+	return c.storeRegSized(CX, wordType, "%"+nextCount)
+}
diff --git a/amd64_lower_qword_bit_lookup.go b/amd64_lower_qword_bit_lookup.go
new file mode 100644
index 000000000..ebd37c45e
--- /dev/null
+++ b/amd64_lower_qword_bit_lookup.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64QwordBitLookupOutput uint8
+
+const (
+	amd64QwordBitLookupBytes amd64QwordBitLookupOutput = iota
+	amd64QwordBitLookupMask
+)
+
+type amd64QwordBitLookupSpec struct {
+	output    amd64QwordBitLookupOutput
+	broadcast bool
+}
+
+// amd64QwordBitLookupSpecs groups the two AVX-512 byte-control operations
+// that select bits inside corresponding qword lanes. They share the same core
+// rotate/lookup grammar but produce either bytes or a packed K mask.
+var amd64QwordBitLookupSpecs = map[Op]amd64QwordBitLookupSpec{
+	"VPMULTISHIFTQB": {output: amd64QwordBitLookupBytes, broadcast: true},
+	"VPSHUFBITQMB":   {output: amd64QwordBitLookupMask},
+}
+
+func (c *amd64Ctx) lowerQwordBitLookup(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86QwordLookupProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	spec, byteWidth := form.spec, form.byteWidth
+	first, second := ins.Args[form.first], ins.Args[form.second]
+	destination := ins.Args[form.destination]
+	var writeMask string
+	if form.mask >= 0 {
+		writeMask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpMem && !c.nativeMemoryOperand(ins, form.memory) &&
+		!x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+		return true, false, fmt.Errorf("%w: qword lookup needs its original native storage binding", ErrProbeNeedsContext)
+	}
+	var dataQwords, controls string
+	switch spec.output {
+	case amd64QwordBitLookupBytes:
+		// VPMULTISHIFTQB is E4NF: even a zero write mask retains the full
+		// source tuple, or the independent m64 broadcast.
+		dataQwords, err = c.loadX86PackedShiftLanes(first, byteWidth, 64, form.broadcast, "")
+		if err == nil {
+			controls, err = c.loadPackedCompareBytes(second, byteWidth)
+		}
+	case amd64QwordBitLookupMask:
+		dataQwords, err = c.loadPackedCompareLanes(second, byteWidth, 64, false)
+		if err == nil {
+			// VPSHUFBITQMB is E4 with byte-granular fault suppression. Its
+			// mask is not a license to suppress the other family's E4NF read.
+			controls, err = c.loadX86PackedShiftLanes(first, byteWidth, 8, false, writeMask)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	selectedBytes := c.emitQwordBitLookupBytes(byteWidth, dataQwords, controls)
+
+	if spec.output == amd64QwordBitLookupBytes {
+		if form.mask >= 0 {
+			old, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+			if loadErr != nil {
+				return true, false, loadErr
+			}
+			selectedBytes = amd64ApplyIntegerLaneMask(c, byteWidth, 8, selectedBytes, old, writeMask, form.zeroing)
+		}
+		return true, false, c.storePackedMoveOperand(destination, byteWidth, selectedBytes)
+	}
+
+	ones := c.newTmp()
+	predicates := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and <%d x i8> %s, %s\n", ones, byteWidth, selectedBytes, llvmSplatInteger(byteWidth, 8, 1))
+	fmt.Fprintf(c.b, "  %%%s = icmp ne <%d x i8> %%%s, zeroinitializer\n", predicates, byteWidth, ones)
+	packedType := fmt.Sprintf("i%d", byteWidth)
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i1> %%%s to %s\n", packed, byteWidth, predicates, packedType)
+	result := "%" + packed
+	if byteWidth < 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", wide, packedType, result)
+		result = "%" + wide
+	}
+	if form.mask >= 0 {
+		maskedResult := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %s\n", maskedResult, result, writeMask)
+		result = "%" + maskedResult
+	}
+	return true, false, c.storeK(destination.Reg, result)
+}
+
+// emitQwordBitLookupBytes rotates each corresponding data qword right by the
+// low six bits of a control byte. Its low byte is VPMULTISHIFTQB's result;
+// its low bit is VPSHUFBITQMB's gathered mask bit.
+func (c *amd64Ctx) emitQwordBitLookupBytes(byteWidth int, dataQwords, controls string) string {
+	result := "zeroinitializer"
+	qwords := byteWidth / 8
+	for lane := 0; lane < byteWidth; lane++ {
+		data := c.newTmp()
+		controlByte := c.newTmp()
+		controlWide := c.newTmp()
+		control := c.newTmp()
+		right := c.newTmp()
+		negated := c.newTmp()
+		wrappedLeftCount := c.newTmp()
+		left := c.newTmp()
+		rotated := c.newTmp()
+		selected := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", data, qwords, dataQwords, lane/8)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", controlByte, byteWidth, controls, lane)
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", controlWide, controlByte)
+		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", control, controlWide)
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, %%%s\n", right, data, control)
+		fmt.Fprintf(c.b, "  %%%s = sub i64 0, %%%s\n", negated, control)
+		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 63\n", wrappedLeftCount, negated)
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, %%%s\n", left, data, wrappedLeftCount)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", rotated, right, left)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i8\n", selected, rotated)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i8> %s, i8 %%%s, i32 %d\n", inserted, byteWidth, result, selected, lane)
+		result = "%" + inserted
+	}
+	return result
+}
diff --git a/amd64_lower_qword_bit_lookup_test.go b/amd64_lower_qword_bit_lookup_test.go
new file mode 100644
index 000000000..e782bc6e6
--- /dev/null
+++ b/amd64_lower_qword_bit_lookup_test.go
@@ -0,0 +1,251 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64QwordBitLookupGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64QwordBitLookupSpec{
+		"VPMULTISHIFTQB": {output: amd64QwordBitLookupBytes, broadcast: true},
+		"VPSHUFBITQMB":   {output: amd64QwordBitLookupMask},
+	}
+	if len(amd64QwordBitLookupSpecs) != len(expected) {
+		t.Fatalf("qword-bit-lookup grammar has %d entries, want %d", len(amd64QwordBitLookupSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64QwordBitLookupSpecs[op]; !ok {
+			t.Errorf("qword-bit-lookup grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("qword-bit-lookup grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86QwordBitLookupCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT qwordbitlookupforms(SB),$0-0\n")
+			for _, width := range []string{"X", "Y", "Z"} {
+				last := 31
+				if target.goarch == "386" && width == "Z" {
+					last = 7
+				}
+				fmt.Fprintf(&source, "\tVPMULTISHIFTQB %s1, %s2, %s%d\n", width, width, width, last)
+				fmt.Fprintf(&source, "\tVPMULTISHIFTQB 8(AX), %s2, %s%d\n", width, width, last)
+				fmt.Fprintf(&source, "\tVPMULTISHIFTQB.BCST 16(AX), %s2, %s%d\n", width, width, last)
+				fmt.Fprintf(&source, "\tVPSHUFBITQMB %s1, %s2, K0\n", width, width)
+				fmt.Fprintf(&source, "\tVPSHUFBITQMB 24(AX), %s2, K7\n", width)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\tVPMULTISHIFTQB %s1, %s2, K1, %s%d\n", width, width, width, last)
+					fmt.Fprintf(&source, "\tVPMULTISHIFTQB.Z 32(AX), %s2, K2, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVPMULTISHIFTQB.BCST.Z 40(AX), %s2, K3, %s%d\n", width, width, last)
+					fmt.Fprintf(&source, "\tVPSHUFBITQMB %s1, %s2, K4, K7\n", width, width)
+					fmt.Fprintf(&source, "\tVPSHUFBITQMB 48(AX), %s2, K5, K6\n", width)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"qwordbitlookupforms": {Name: "qwordbitlookupforms", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("uninitialized qword lookup formats invented numerical/native inputs", err)
+			}
+			if target.goarch == "386" {
+				// The retained original source includes X31/Y31 spellings:
+				// Go accepts their syntax without a physical mode32 binding.
+				// Check that precise boundary independently; the initialized
+				// low-bank matrix owns successful LLVM objects for both OSes.
+				for _, row := range []string{"VPMULTISHIFTQB X1,X2,X31", "VPMULTISHIFTQB Y1,Y2,Y31"} {
+					ins := x86ScalarLaneInstruction(t, row)
+					_, known, err := x86QwordLookupProperties(ins.Op, ins, "386")
+					if !known || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 binding") {
+						t.Fatal("original high-bank syntax invented a physical mode32 vector", row, err)
+					}
+				}
+				t.Log("original Go high-bank formats retained as Context; initialized low-bank tests own LLVM objects")
+				return
+			}
+			ir = x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"qwordbitlookupforms": {Name: "qwordbitlookupforms", Ret: Void}}, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerQwordBitLookup(ins.Op, ins) })
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "qword-bit-lookup-"+target.name+".ll", "qword-bit-lookup-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86QwordBitLookupRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VPMULTISHIFTQB X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VPMULTISHIFTQB.BCST X0, X1, X2"},
+		{goarch: "amd64", instruction: "VPMULTISHIFTQB.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VPMULTISHIFTQB X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VPMULTISHIFTQB X0, X1, 0(AX)"},
+		{goarch: "amd64", instruction: "VPSHUFBITQMB.Z X0, X1, K2"},
+		{goarch: "amd64", instruction: "VPSHUFBITQMB.BCST 0(AX), X1, K2"},
+		{goarch: "amd64", instruction: "VPSHUFBITQMB X0, Y1, K2"},
+		{goarch: "amd64", instruction: "VPSHUFBITQMB X0, X1, K0, K2"},
+		{goarch: "amd64", instruction: "VPSHUFBITQMB X0, X1, AX"},
+		{goarch: "386", instruction: "VPMULTISHIFTQB X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VPSHUFBITQMB X0, X1, K1, K2"},
+		{goarch: "386", instruction: "VPMULTISHIFTQB Z0, Z1, Z8"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's qword-bit-lookup table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64QwordBitLookupRuntimeSemantics(t *testing.T) {
+	// This oracle executes portable integer LLVM, not native AVX512. Use
+	// the actual 64-bit host rather than an unrelated Rosetta requirement.
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable runtime oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT qwordbitlookupsemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ data+8(FP), BX
+	MOVQ controls+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ mask+32(FP), R8
+	KMOVQ R8, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	VMOVDQU64 0(DX), Z2
+	STC
+	VPMULTISHIFTQB Z0, Z1, Z3
+	VMOVDQU64 Z3, 0(AX)
+	VPMULTISHIFTQB Z0, Z1, K1, Z2
+	VMOVDQU64 Z2, 64(AX)
+	VPMULTISHIFTQB.Z Z0, Z1, K1, Z3
+	VMOVDQU64 Z3, 128(AX)
+	VPMULTISHIFTQB.BCST 0(BX), Z1, Z3
+	VMOVDQU64 Z3, 192(AX)
+	VPSHUFBITQMB Z1, Z0, K2
+	KMOVQ K2, 256(AX)
+	VPSHUFBITQMB Z1, Z0, K1, K3
+	KMOVQ K3, 264(AX)
+	SETCS 272(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"qwordbitlookupsemantics": {
+			Name: "qwordbitlookupsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void qwordbitlookupsemantics(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint64_t);
+static uint64_t ror64(uint64_t value, unsigned count) {
+  count &= 63u;
+  return (value >> count) | (value << ((0u-count)&63u));
+}
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  uint64_t data64[8], controls64[8], old64[8], output64[35] = {0};
+  uint8_t *data=(uint8_t *)data64, *controls=(uint8_t *)controls64;
+  uint8_t *old=(uint8_t *)old64, *out=(uint8_t *)output64;
+  const uint64_t mask=UINT64_C(0xa55af00ff00fa55a);
+  for (int q=0;q<8;q++) data64[q]=UINT64_C(0x0123456789abcdef)^((uint64_t)q*UINT64_C(0x11100f0e0d0c0b0a));
+  for (int i=0;i<64;i++) { controls[i]=(uint8_t)(13u*(unsigned)i+((unsigned)i>>2)); old[i]=(uint8_t)(0xe0u-(unsigned)i); }
+  qwordbitlookupsemantics(out,data,controls,old,mask);
+  uint64_t gathered=0;
+  for (int i=0;i<64;i++) {
+    uint64_t qword=data64[i/8];
+    uint8_t selected=(uint8_t)ror64(qword,controls[i]);
+    if (out[i]!=selected) return 10;
+    if (out[64+i]!=(((mask>>i)&1u)?selected:old[i])) return 11;
+    if (out[128+i]!=(((mask>>i)&1u)?selected:0)) return 12;
+    uint8_t broadcast=(uint8_t)ror64(data64[0],controls[i]);
+    if (out[192+i]!=broadcast) return 13;
+    gathered|=((qword>>(controls[i]&63u))&1u)<<i;
+  }
+  if (load64(out+256)!=gathered) return 20;
+  if (load64(out+264)!=(gathered&mask)) return 21;
+  if (out[272]!=1) return 22;
+  return 0;
+}
+`
+	for _, pipeline := range []struct {
+		name      string
+		optimized bool
+		backend   int
+	}{
+		{name: "backend_O0"},
+		{name: "backend_O2", backend: 2},
+		{name: "IR_O2/backend_O2", optimized: true, backend: 2},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			text := ir
+			if pipeline.optimized {
+				text = x86DwordProductIROptimize(t, ir)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "qword_bit_lookup_semantics",
+				triple, text, mainC, nil, pipeline.backend)
+		})
+	}
+}
diff --git a/amd64_lower_random.go b/amd64_lower_random.go
new file mode 100644
index 000000000..985ab2bfe
--- /dev/null
+++ b/amd64_lower_random.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import "fmt"
+
+// lowerHardwareRandom implements every Go 1.27 yrdrand form for both the
+// RDRAND and RDSEED instruction families. Both instructions return success in
+// CF and architecturally clear OF, SF, ZF, AF, and PF.
+func (c *amd64Ctx) lowerHardwareRandom(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, known, err := x86HardwareRandomProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+
+	typ := amd64IntegerTypeForBits(spec.bits)
+	call := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call { %s, i32 } @llvm.x86.%s.%d()\n", call, typ, spec.native, spec.bits)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i32 } %%%s, 0\n", value, typ, call)
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i32 } %%%s, 1\n", status, typ, call)
+
+	// SP is a legal Yrl destination in Go's 386 table. This instruction is the
+	// modeled write itself, so permit storeRegSized to update the virtual SP.
+	previousAllowSPWrite := c.allowSPWrite
+	if c.goarch == "386" && ins.Args[0].Reg == SP {
+		c.allowSPWrite = true
+	}
+	err = c.storeRegSized(ins.Args[0].Reg, typ, "%"+value)
+	c.allowSPWrite = previousAllowSPWrite
+	if err != nil {
+		return true, false, err
+	}
+
+	carry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", carry, status)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", carry, c.flagsCFSlot)
+	c.clearX86StatusFlags(x86StatusAll &^ x86StatusCF)
+	return true, false, nil
+}
diff --git a/amd64_lower_random_test.go b/amd64_lower_random_test.go
new file mode 100644
index 000000000..c9dd741d3
--- /dev/null
+++ b/amd64_lower_random_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86RandomCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		goarch    string
+		triple    string
+		widths    []string
+		registers []string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu", widths: []string{"W", "L"}, registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}},
+		{goarch: "386", triple: "i686-pc-windows-msvc", widths: []string{"W", "L"}, registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}},
+		{goarch: "amd64", triple: "x86_64-apple-darwin", widths: []string{"W", "L", "Q"}, registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", widths: []string{"W", "L", "Q"}, registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc", widths: []string{"W", "L", "Q"}, registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+	} {
+		t.Run(target.goarch+"/"+target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT randomforms(SB),$0-0\n")
+			for _, family := range []string{"RDRAND", "RDSEED"} {
+				for _, width := range target.widths {
+					for _, register := range target.registers {
+						fmt.Fprintf(&source, "\t%s%s %s\n", family, width, register)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			// Preserve every original legal encoding, including physical SP/BP.
+			// Those writes have no ordinary typed entry contract. Independent
+			// initialized GP/result programs own the public-object assertions.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "randomforms", target.goarch, target.triple)
+			for _, want := range []string{
+				"@llvm.x86.rdrand.16()", "@llvm.x86.rdrand.32()",
+				"@llvm.x86.rdseed.16()", "@llvm.x86.rdseed.32()",
+				`"target-features"="+rdrnd,+rdseed"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("random lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, want := range []string{"@llvm.x86.rdrand.64()", "@llvm.x86.rdseed.64()"} {
+					if !strings.Contains(ll, want) {
+						t.Fatalf("random lowering omitted %q:\n%s", want, ll)
+					}
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "x86-random.ll", "x86-random.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86RandomRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "386", instruction: "RDRANDQ AX"},
+		{goarch: "386", instruction: "RDSEEDQ AX"},
+		{goarch: "386", instruction: "RDRANDL R8"},
+		{goarch: "386", instruction: "RDSEEDW R8"},
+		{goarch: "amd64", instruction: "RDRANDB AL"},
+		{goarch: "amd64", instruction: "RDSEEDB AL"},
+		{goarch: "amd64", instruction: "RDRANDQ 0(AX)"},
+		{goarch: "amd64", instruction: "RDSEEDQ 0(AX)"},
+		{goarch: "amd64", instruction: "RDRANDQ AX, DX"},
+		{goarch: "amd64", instruction: "RDSEEDQ"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT badrandom(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"badrandom": {Name: "badrandom", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go's RDRAND/RDSEED optab", test.instruction)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesCompleteRandomFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want Op
+		reg  Reg
+	}{
+		{name: "rdrand word low", code: []byte{0x66, 0x0f, 0xc7, 0xf2}, want: "RDRANDW", reg: DX},
+		{name: "rdrand word extended", code: []byte{0x66, 0x41, 0x0f, 0xc7, 0xf3}, want: "RDRANDW", reg: Reg("R11")},
+		{name: "rdrand long low", code: []byte{0x0f, 0xc7, 0xf2}, want: "RDRANDL", reg: DX},
+		{name: "rdrand long extended", code: []byte{0x41, 0x0f, 0xc7, 0xf3}, want: "RDRANDL", reg: Reg("R11")},
+		{name: "rdrand quad low", code: []byte{0x48, 0x0f, 0xc7, 0xf2}, want: "RDRANDQ", reg: DX},
+		{name: "rdrand quad extended", code: []byte{0x49, 0x0f, 0xc7, 0xf3}, want: "RDRANDQ", reg: Reg("R11")},
+		{name: "rdseed word low", code: []byte{0x66, 0x0f, 0xc7, 0xfa}, want: "RDSEEDW", reg: DX},
+		{name: "rdseed word extended", code: []byte{0x66, 0x41, 0x0f, 0xc7, 0xfb}, want: "RDSEEDW", reg: Reg("R11")},
+		{name: "rdseed long low", code: []byte{0x0f, 0xc7, 0xfa}, want: "RDSEEDL", reg: DX},
+		{name: "rdseed long extended", code: []byte{0x41, 0x0f, 0xc7, 0xfb}, want: "RDSEEDL", reg: Reg("R11")},
+		{name: "rdseed quad low", code: []byte{0x48, 0x0f, 0xc7, 0xfa}, want: "RDSEEDQ", reg: DX},
+		{name: "rdseed quad extended", code: []byte{0x49, 0x0f, 0xc7, 0xfb}, want: "RDSEEDQ", reg: Reg("R11")},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != test.want || len(got.Instrs[0].Args) != 1 || got.Instrs[0].Args[0].Reg != test.reg {
+				t.Fatalf("decoded %#x as %#v, want %s %s", test.code, got.Instrs, test.want, test.reg)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_range.go b/amd64_lower_range.go
new file mode 100644
index 000000000..5080a1c1c
--- /dev/null
+++ b/amd64_lower_range.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64FloatingRangeSpec struct {
+	laneBits int
+	scalar   bool
+}
+
+// amd64FloatingRangeSpecs is the complete Go 1.27 VRANGE grammar. The
+// immediate supplies the comparison and sign modes, so those orthogonal
+// dimensions stay data instead of expanding into opcode-specific handlers.
+var amd64FloatingRangeSpecs = map[Op]amd64FloatingRangeSpec{
+	"VRANGEPS": {laneBits: 32},
+	"VRANGEPD": {laneBits: 64},
+	"VRANGESS": {laneBits: 32, scalar: true},
+	"VRANGESD": {laneBits: 64, scalar: true},
+}
+
+func (c *amd64Ctx) lowerFloatingRange(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64FloatingRangeSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	if c.goarch == "386" {
+		return true, false, fmt.Errorf("386 %s exceeds the Go assembler frontend's three-operand limit: %q", baseOp, ins.Raw)
+	}
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix || properties.rounding != "" {
+		return true, false, fmt.Errorf("%s %s has a suffix absent from Go 1.27's range optab: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if spec.scalar && properties.broadcast {
+		return true, false, fmt.Errorf("%s %s scalar forms do not support broadcast: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 4 && len(ins.Args) != 5 {
+		return true, false, fmt.Errorf("%s %s expects immediate, source2, source1, [K mask,] destination: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+		return true, false, fmt.Errorf("%s %s immediate must be an unsigned byte: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == 5
+	if properties.zeroing && !masked {
+		return true, false, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if masked && !amd64NonzeroKOperand(ins.Args[3]) {
+		return true, false, fmt.Errorf("%s %s masked form expects K1-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	first, second := ins.Args[1], ins.Args[2]
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s destination must be a vector register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	if spec.scalar {
+		if byteWidth != 16 {
+			return true, false, fmt.Errorf("%s %s scalar destination must be an X register: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 {
+		return true, false, fmt.Errorf("%s %s packed destination must be X, Y, or Z: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if !c.isGoEVEXVectorRegister(destination, byteWidth) || !c.isGoEVEXVectorRegister(second, byteWidth) {
+		return true, false, fmt.Errorf("%s %s source1 and destination must be same-width Go vector registers: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.sae && !spec.scalar && byteWidth != 64 {
+		return true, false, fmt.Errorf("%s %s packed SAE is available only for Z registers: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(first) {
+			return true, false, fmt.Errorf("%s %s.BCST requires a scalar memory source2: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if first.Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(first, byteWidth) {
+			return true, false, fmt.Errorf("%s %s source2 register must match the destination width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(first) {
+		return true, false, fmt.Errorf("%s %s source2 must be a matching vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.sae && first.Kind != OpReg {
+		return true, false, fmt.Errorf("%s %s.SAE requires a register source2: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	mask := ""
+	if masked {
+		mask, err = c.loadK(ins.Args[3].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if spec.scalar {
+		return c.lowerScalarFloatingRange(spec, properties, ins, first, second, destination, mask)
+	}
+	return c.lowerPackedFloatingRange(spec, properties, ins, first, second, destination, byteWidth, mask)
+}
+
+func (c *amd64Ctx) lowerPackedFloatingRange(spec amd64FloatingRangeSpec, properties amd64BinaryFloatingSuffix, ins Instr, first, second, destination Operand, byteWidth int, mask string) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	source2, err := c.loadPackedCompareLanes(first, byteWidth, spec.laneBits, properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	source1, err := c.loadPackedCompareLanes(second, byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitFloatingRangeBits(lanes, spec.laneBits, source1, source2, uint8(ins.Args[0].Imm))
+	if mask != "" {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarFloatingRange(spec amd64FloatingRangeSpec, properties amd64BinaryFloatingSuffix, ins Instr, first, second, destination Operand, mask string) (bool, bool, error) {
+	source2, err := c.loadFloatingScalarBits(first, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	source1, err := c.loadFloatingScalarBits(second, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	source2Vector := c.newTmp()
+	source1Vector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", source2Vector, spec.laneBits, spec.laneBits, source2)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", source1Vector, spec.laneBits, spec.laneBits, source1)
+	result := c.emitFloatingRangeBits(1, spec.laneBits, "%"+source1Vector, "%"+source2Vector, uint8(ins.Args[0].Imm))
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	secondBytes, err := c.loadX(second.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, secondBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+low, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) loadFloatingScalarBits(operand Operand, laneBits int) (string, error) {
+	value, err := c.loadFloatingScalarOperand(operand, laneBits)
+	if err != nil {
+		return "", err
+	}
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", bits, amd64FloatingScalarType(laneBits), value, laneBits)
+	return "%" + bits, nil
+}
+
+// emitFloatingRangeBits follows Intel's range operation in integer bit space
+// around one ordered floating comparison. This preserves NaN payloads, quiets
+// signaling NaNs, and handles signed zero and equal-magnitude opposite signs.
+func (c *amd64Ctx) emitFloatingRangeBits(lanes, laneBits int, source1, source2 string, immediate uint8) string {
+	integerType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	floatType := amd64FloatingVectorType(lanes, laneBits)
+	predicateType := fmt.Sprintf("<%d x i1>", lanes)
+	signBit := uint64(1) << (laneBits - 1)
+	absMask := signBit - 1
+	quietBit := uint64(0x00400000)
+	infinity := uint64(0x7f800000)
+	if laneBits == 64 {
+		quietBit = uint64(0x0008000000000000)
+		infinity = uint64(0x7ff0000000000000)
+	}
+	signVector := llvmSplatInteger(lanes, laneBits, signBit)
+	absVector := llvmSplatInteger(lanes, laneBits, absMask)
+	quietVector := llvmSplatInteger(lanes, laneBits, quietBit)
+	infinityVector := llvmSplatInteger(lanes, laneBits, infinity)
+
+	abs1, abs2 := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", abs1, integerType, source1, absVector)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", abs2, integerType, source2, absVector)
+
+	compareLeft, compareRight := source1, source2
+	if immediate&3 >= 2 {
+		compareLeft, compareRight = "%"+abs1, "%"+abs2
+	}
+	leftFloat, rightFloat := c.newTmp(), c.newTmp()
+	ordered := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", leftFloat, integerType, compareLeft, floatType)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", rightFloat, integerType, compareRight, floatType)
+	fmt.Fprintf(c.b, "  %%%s = fcmp ole %s %%%s, %%%s\n", ordered, floatType, leftFloat, rightFloat)
+	selected := c.newTmp()
+	if immediate&1 == 0 {
+		fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", selected, predicateType, ordered, integerType, source1, integerType, source2)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", selected, predicateType, ordered, integerType, source2, integerType, source1)
+	}
+	result := "%" + selected
+
+	signXor, signDifference, oppositeSigns := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", signXor, integerType, source1, source2)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", signDifference, integerType, signXor, signVector)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", oppositeSigns, integerType, signDifference)
+	if immediate&3 < 2 {
+		zero1, zero2, bothZero, oppositeZero := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", zero1, integerType, abs1)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", zero2, integerType, abs2)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", bothZero, predicateType, zero1, zero2)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", oppositeZero, predicateType, bothZero, oppositeSigns)
+		zeroResult := "zeroinitializer"
+		if immediate&1 == 0 {
+			zeroResult = signVector
+		}
+		overridden := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", overridden, predicateType, oppositeZero, integerType, zeroResult, integerType, result)
+		result = "%" + overridden
+	} else {
+		equalMagnitude, equalOpposite := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %%%s\n", equalMagnitude, integerType, abs1, abs2)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", equalOpposite, predicateType, equalMagnitude, oppositeSigns)
+		tieResult := "%" + abs1
+		if immediate&1 == 0 {
+			negative := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %s\n", negative, integerType, abs1, signVector)
+			tieResult = "%" + negative
+		}
+		overridden := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", overridden, predicateType, equalOpposite, integerType, tieResult, integerType, result)
+		result = "%" + overridden
+	}
+
+	isNaN1, isNaN2 := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %%%s, %s\n", isNaN1, integerType, abs1, infinityVector)
+	fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %%%s, %s\n", isNaN2, integerType, abs2, infinityVector)
+	withoutNaN1 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %s\n", withoutNaN1, predicateType, isNaN1, integerType, source2, integerType, result)
+	withoutQuietNaNs := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %s, %s %%%s\n", withoutQuietNaNs, predicateType, isNaN2, integerType, source1, integerType, withoutNaN1)
+	result = "%" + withoutQuietNaNs
+
+	signMode := immediate >> 2 & 3
+	if signMode != 1 {
+		magnitude := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", magnitude, integerType, result, absVector)
+		switch signMode {
+		case 0:
+			sourceSign := c.newTmp()
+			signed := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", sourceSign, integerType, source1, signVector)
+			fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", signed, integerType, magnitude, sourceSign)
+			result = "%" + signed
+		case 2:
+			result = "%" + magnitude
+		case 3:
+			signed := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %s\n", signed, integerType, magnitude, signVector)
+			result = "%" + signed
+		}
+	}
+
+	quiet1, quiet2 := c.newTmp(), c.newTmp()
+	quietField1, quietField2 := c.newTmp(), c.newTmp()
+	quietClear1, quietClear2 := c.newTmp(), c.newTmp()
+	signaling1, signaling2 := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %s, %s\n", quiet1, integerType, source1, quietVector)
+	fmt.Fprintf(c.b, "  %%%s = or %s %s, %s\n", quiet2, integerType, source2, quietVector)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", quietField1, integerType, source1, quietVector)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", quietField2, integerType, source2, quietVector)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", quietClear1, integerType, quietField1)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, zeroinitializer\n", quietClear2, integerType, quietField2)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", signaling1, predicateType, isNaN1, quietClear1)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", signaling2, predicateType, isNaN2, quietClear2)
+	withSecondSignaling := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %%%s, %s %s\n", withSecondSignaling, predicateType, signaling2, integerType, quiet2, integerType, result)
+	withFirstSignaling := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %%%s, %s %%%s\n", withFirstSignaling, predicateType, signaling1, integerType, quiet1, integerType, withSecondSignaling)
+	return "%" + withFirstSignaling
+}
diff --git a/amd64_lower_range_test.go b/amd64_lower_range_test.go
new file mode 100644
index 000000000..0c608ca75
--- /dev/null
+++ b/amd64_lower_range_test.go
@@ -0,0 +1,338 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64FloatingRangeGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64FloatingRangeSpec{
+		"VRANGEPS": {laneBits: 32},
+		"VRANGEPD": {laneBits: 64},
+		"VRANGESS": {laneBits: 32, scalar: true},
+		"VRANGESD": {laneBits: 64, scalar: true},
+	}
+	if len(amd64FloatingRangeSpecs) != len(expected) {
+		t.Fatalf("floating-range grammar has %d entries, want %d", len(amd64FloatingRangeSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64FloatingRangeSpecs[op]; !ok {
+			t.Errorf("floating-range grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("floating-range grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86FloatingRangeCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT floatingrangeforms(SB),$0-0\n")
+			for _, op := range []string{"VRANGEPS", "VRANGEPD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s $0, %s1, %s2, %s%d\n", op, width, width, width, last)
+					fmt.Fprintf(&source, "\t%s $255, 8(AX), %s2, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST $2, 16(AX), %s2, %s%d\n", op, width, width, last)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s $3, %s1, %s2, K1, %s%d\n", op, width, width, width, last)
+						fmt.Fprintf(&source, "\t%s.Z $4, 24(AX), %s2, K2, %s%d\n", op, width, width, last)
+						fmt.Fprintf(&source, "\t%s.BCST.Z $5, 32(AX), %s2, K3, %s%d\n", op, width, width, last)
+						if width == "Z" {
+							fmt.Fprintf(&source, "\t%s.SAE $6, Z1, Z2, Z%d\n", op, last)
+							fmt.Fprintf(&source, "\t%s.SAE.Z $7, Z1, Z2, K4, Z%d\n", op, last)
+						}
+					}
+				}
+			}
+			for _, op := range []string{"VRANGESS", "VRANGESD"} {
+				last := 31
+				if target.goarch == "386" {
+					last = 7
+				}
+				fmt.Fprintf(&source, "\t%s $8, X1, X2, X%d\n", op, last)
+				fmt.Fprintf(&source, "\t%s $9, 40(AX), X2, X%d\n", op, last)
+				fmt.Fprintf(&source, "\t%s.SAE $10, X1, X2, X%d\n", op, last)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $11, X1, X2, K5, X%d\n", op, last)
+					fmt.Fprintf(&source, "\t%s.Z $12, 48(AX), X2, K6, X%d\n", op, last)
+					fmt.Fprintf(&source, "\t%s.SAE.Z $13, X1, X2, K7, X%d\n", op, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "floatingrangeforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "floating-range-"+target.name+".ll", "floating-range-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86FloatingRangeRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VRANGEPS $-1, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS $256, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS $0, X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VRANGEPS.BCST $0, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS.SAE $0, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGESD.SAE $0, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS.RN_SAE $0, Z0, Z1, Z2"},
+		{goarch: "amd64", instruction: "VRANGEPS.Z $0, X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGEPS $0, X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VRANGESS $0, Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VRANGESS.BCST $0, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VRANGESD $0, X0, X1, Y2"},
+		{goarch: "386", instruction: "VRANGEPS $0, X0, X1, X2"},
+		{goarch: "386", instruction: "VRANGEPS $0, X0, X1, K1, X2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating-range table", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64FloatingRangeRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	var source strings.Builder
+	source.WriteString(`TEXT floatingrangesemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ source2+8(FP), BX
+	MOVQ source1+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ mask+32(FP), R8
+	KMOVQ R8, K1
+	VMOVDQU32 0(BX), Z0
+	VMOVDQU32 0(CX), Z1
+	STC
+`)
+	for immediate := 0; immediate < 16; immediate++ {
+		fmt.Fprintf(&source, "\tVRANGEPS $%d, Z0, Z1, Z2\n", immediate)
+		fmt.Fprintf(&source, "\tVMOVDQU32 Z2, %d(AX)\n", immediate*64)
+	}
+	source.WriteString(`	VMOVDQU32 0(DX), Z2
+	VRANGEPS $2, Z0, Z1, K1, Z2
+	VMOVDQU32 Z2, 1024(AX)
+	VRANGEPS.Z $3, Z0, Z1, K1, Z2
+	VMOVDQU32 Z2, 1088(AX)
+	VRANGEPS.BCST $2, 0(BX), Z1, Z2
+	VMOVDQU32 Z2, 1152(AX)
+	SETCS 1216(AX)
+	RET
+`)
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"floatingrangesemantics": {
+			Name: "floatingrangesemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void floatingrangesemantics(uint8_t *, const uint32_t *, const uint32_t *, const uint32_t *, uint64_t);
+static float f32(uint32_t u) { float f; memcpy(&f,&u,4); return f; }
+static uint32_t range32(uint32_t a, uint32_t b, unsigned imm) {
+  const uint32_t sign=UINT32_C(0x80000000), absMask=UINT32_C(0x7fffffff);
+  const uint32_t quiet=UINT32_C(0x00400000), inf=UINT32_C(0x7f800000);
+  uint32_t aa=a&absMask, ab=b&absMask, tmp;
+  int nanA=aa>inf, nanB=ab>inf, snanA=nanA && !(a&quiet), snanB=nanB && !(b&quiet);
+  unsigned op=imm&3, signs=(imm>>2)&3;
+  if (nanB) tmp=a;
+  else if (nanA) tmp=b;
+  else if (((a^b)&sign) && aa==0 && ab==0) tmp=(op&1)?0:sign;
+  else if (((a^b)&sign) && aa==ab && op>=2) tmp=(op&1)?aa:(aa|sign);
+  else {
+    int le=op>=2 ? f32(aa)<=f32(ab) : f32(a)<=f32(b);
+    tmp=(op&1) ? (le?b:a) : (le?a:b);
+  }
+  if (signs==0) tmp=(tmp&absMask)|(a&sign);
+  else if (signs==2) tmp&=absMask;
+  else if (signs==3) tmp|=sign;
+  if (snanB) tmp=b|quiet;
+  if (snanA) tmp=a|quiet;
+  return tmp;
+}
+int main(void) {
+  const uint32_t source1[16]={
+    0x00000000,0x80000000,0x3f800000,0xbf800000,
+    0x40000000,0xc0000000,0x40400000,0xc0800000,
+    0x7f800000,0xff800000,0x7fc12345,0xffc23456,
+    0x7f812345,0xff823456,0x3f000000,0xbf400000};
+  const uint32_t source2[16]={
+    0x80000000,0x00000000,0xbf800000,0x3f800000,
+    0xc0400000,0x3f000000,0xc0400000,0x40a00000,
+    0x7f000000,0xff000000,0x3f800000,0x7fc34567,
+    0x40000000,0x7f834567,0xbf000000,0x3fc00000};
+  uint32_t old[16], out[305];
+  const uint64_t mask=UINT64_C(0xa55a);
+  for (int i=0;i<16;i++) old[i]=UINT32_C(0x41000000)+(uint32_t)i;
+  memset(out,0,sizeof(out));
+  floatingrangesemantics((uint8_t*)out,source2,source1,old,mask);
+  for (unsigned imm=0;imm<16;imm++) for (int i=0;i<16;i++)
+    if (out[imm*16+i]!=range32(source1[i],source2[i],imm)) return 10+(int)imm;
+  for (int i=0;i<16;i++) {
+    uint32_t r2=range32(source1[i],source2[i],2);
+    uint32_t r3=range32(source1[i],source2[i],3);
+    if (out[256+i]!=(((mask>>i)&1)?r2:old[i])) return 40;
+    if (out[272+i]!=(((mask>>i)&1)?r3:0)) return 41;
+    if (out[288+i]!=range32(source1[i],source2[0],2)) return 42;
+  }
+  if (((uint8_t*)out)[1216]!=1) return 43;
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "floating_range_semantics", ir, mainC)
+}
+
+func qualifyAMD64FloatingRangeDoubleAndScalarRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	var source strings.Builder
+	source.WriteString(`TEXT floatingrangedoublesemantics(SB),$0-40
+	MOVQ out+0(FP), AX
+	MOVQ source2+8(FP), BX
+	MOVQ source1+16(FP), CX
+	MOVQ old+24(FP), DX
+	MOVQ mask+32(FP), R8
+	KMOVQ R8, K1
+	VMOVDQU64 0(BX), Z0
+	VMOVDQU64 0(CX), Z1
+	STC
+`)
+	for immediate := 0; immediate < 16; immediate++ {
+		fmt.Fprintf(&source, "\tVRANGEPD $%d, Z0, Z1, Z2\n", immediate)
+		fmt.Fprintf(&source, "\tVMOVDQU64 Z2, %d(AX)\n", immediate*64)
+	}
+	source.WriteString(`	VMOVDQU64 0(BX), X0
+	VMOVDQU64 0(CX), X1
+	VMOVDQU64 0(DX), X2
+	VRANGESD $2, X0, X1, X2
+	VMOVDQU64 X2, 1024(AX)
+	VMOVDQU64 0(DX), X2
+	VRANGESD $2, X0, X1, K1, X2
+	VMOVDQU64 X2, 1040(AX)
+	VRANGESD.Z $2, X0, X1, K1, X2
+	VMOVDQU64 X2, 1056(AX)
+	SETCS 1072(AX)
+	RET
+`)
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"floatingrangedoublesemantics": {
+			Name: "floatingrangedoublesemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void floatingrangedoublesemantics(uint8_t *, const uint64_t *, const uint64_t *, const uint64_t *, uint64_t);
+static double f64(uint64_t u) { double f; memcpy(&f,&u,8); return f; }
+static uint64_t range64(uint64_t a, uint64_t b, unsigned imm) {
+  const uint64_t sign=UINT64_C(0x8000000000000000), absMask=UINT64_C(0x7fffffffffffffff);
+  const uint64_t quiet=UINT64_C(0x0008000000000000), inf=UINT64_C(0x7ff0000000000000);
+  uint64_t aa=a&absMask, ab=b&absMask, tmp;
+  int nanA=aa>inf, nanB=ab>inf, snanA=nanA && !(a&quiet), snanB=nanB && !(b&quiet);
+  unsigned op=imm&3, signs=(imm>>2)&3;
+  if (nanB) tmp=a;
+  else if (nanA) tmp=b;
+  else if (((a^b)&sign) && aa==0 && ab==0) tmp=(op&1)?0:sign;
+  else if (((a^b)&sign) && aa==ab && op>=2) tmp=(op&1)?aa:(aa|sign);
+  else {
+    int le=op>=2 ? f64(aa)<=f64(ab) : f64(a)<=f64(b);
+    tmp=(op&1) ? (le?b:a) : (le?a:b);
+  }
+  if (signs==0) tmp=(tmp&absMask)|(a&sign);
+  else if (signs==2) tmp&=absMask;
+  else if (signs==3) tmp|=sign;
+  if (snanB) tmp=b|quiet;
+  if (snanA) tmp=a|quiet;
+  return tmp;
+}
+int main(void) {
+  const uint64_t source1[8]={
+    UINT64_C(0),UINT64_C(0x8000000000000000),UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),
+    UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff823456789abcd),UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff023456789abcd)};
+  const uint64_t source2[8]={
+    UINT64_C(0x8000000000000000),UINT64_C(0),UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000000),
+    UINT64_C(0x4000000000000000),UINT64_C(0x7ff83456789abcde),UINT64_C(0x4008000000000000),UINT64_C(0x7ff0456789abcdef)};
+  const uint64_t old[8]={UINT64_C(0x4020000000000000),UINT64_C(0x4030000000000000),0,0,0,0,0,0};
+  uint64_t out[135];
+  memset(out,0,sizeof(out));
+  floatingrangedoublesemantics((uint8_t*)out,source2,source1,old,0);
+  for (unsigned imm=0;imm<16;imm++) for (int i=0;i<8;i++)
+    if (out[imm*8+i]!=range64(source1[i],source2[i],imm)) return 10+(int)imm;
+  if (out[128]!=range64(source1[0],source2[0],2)) return 40;
+  if (out[129]!=source1[1]) return 44;
+  if (out[130]!=old[0] || out[131]!=source1[1]) return 41;
+  if (out[132]!=0 || out[133]!=source1[1]) return 42;
+  if (((uint8_t*)out)[1072]!=1) return 43;
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "floating_range_double_scalar_semantics", ir, mainC)
+}
diff --git a/amd64_lower_rdpid_test.go b/amd64_lower_rdpid_test.go
new file mode 100644
index 000000000..e30ad61dd
--- /dev/null
+++ b/amd64_lower_rdpid_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86RDPIDCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		goarch    string
+		triple    string
+		registers []string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu", registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}},
+		{goarch: "386", triple: "i686-pc-windows-msvc", registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}},
+		{goarch: "amd64", triple: "x86_64-apple-darwin", registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc", registers: []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}},
+	} {
+		t.Run(target.goarch+"/"+target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rdpidforms(SB),$0-0\n")
+			for _, register := range target.registers {
+				fmt.Fprintf(&source, "\tRDPID %s\n", register)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"rdpidforms": {Name: "rdpidforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"@llvm.x86.rdpid()", `"target-features"="+rdpid"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("RDPID lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "x86-rdpid.ll", "x86-rdpid.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86RDPIDRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "386", instruction: "RDPID AL"},
+		{goarch: "386", instruction: "RDPID 0(AX)"},
+		{goarch: "386", instruction: "RDPID R8"},
+		{goarch: "amd64", instruction: "RDPID AL"},
+		{goarch: "amd64", instruction: "RDPID 0(AX)"},
+		{goarch: "amd64", instruction: "RDPID AX, DX"},
+		{goarch: "amd64", instruction: "RDPID.Z AX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT badrdpid(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs: map[string]FuncSig{
+					"badrdpid": {Name: "badrdpid", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go's RDPID optab", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_reciprocal.go b/amd64_lower_reciprocal.go
new file mode 100644
index 000000000..652bef87c
--- /dev/null
+++ b/amd64_lower_reciprocal.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64Reciprocal14Spec struct {
+	laneBits int
+	scalar   bool
+}
+
+// amd64Reciprocal14Specs covers every opcode backed by Go 1.27's
+// _yvexpandpd and _yvgetexpsd reciprocal-estimate tables.
+var amd64Reciprocal14Specs = map[Op]amd64Reciprocal14Spec{
+	"VRCP14PS":   {laneBits: 32},
+	"VRCP14PD":   {laneBits: 64},
+	"VRCP14SS":   {laneBits: 32, scalar: true},
+	"VRCP14SD":   {laneBits: 64, scalar: true},
+	"VRSQRT14PS": {laneBits: 32},
+	"VRSQRT14PD": {laneBits: 64},
+	"VRSQRT14SS": {laneBits: 32, scalar: true},
+	"VRSQRT14SD": {laneBits: 64, scalar: true},
+}
+
+// The complete Go RCP14/RSQRT14 family uses the existing typed native helper.
+// Its approximation observes dynamic DAZ/FTZ, and active native memory reads
+// must remain observable even when the numerical result is dead.
+func (c *amd64Ctx) lowerReciprocal14(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64Reciprocal14Specs[Op(base)]; !known {
+		return false, false, nil
+	}
+	return c.lowerNativeFloatingHelper(op, ins)
+}
+
+// lowerReciprocalEstimate implements the complete Go 1.27 legacy and VEX
+// RCP/RSQRT estimate family. Pure packed register estimates retain their
+// intrinsics and legal CSE; memory estimates preserve their original opcode,
+// full native access and legacy alignment fault even with a dead result.
+func (c *amd64Ctx) lowerReciprocalEstimate(rawOp Op, ins Instr) (ok bool, terminated bool, err error) {
+	raw := strings.ToUpper(string(rawOp))
+	base, _, _ := strings.Cut(raw, ".")
+	if _, scalar := x86ScalarReciprocalSpecs[Op(base)]; scalar {
+		if raw != base {
+			return true, false, fmt.Errorf("%s %s has no suffixed form in Go 1.27: %q", c.goarch, base, ins.Raw)
+		}
+		return c.lowerScalarReciprocalEstimate(base, ins)
+	}
+	form, known, err := x86PackedReciprocalProperties(rawOp, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return true, false, c.emitPackedReciprocalEstimate(ins, form)
+}
+
+func (c *amd64Ctx) emitPackedReciprocalEstimate(ins Instr, form x86PackedReciprocalForm) error {
+	if ins.x86AddressBits != 0 {
+		return fmt.Errorf("%w: %s needs its original address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	byteWidth := form.byteWidth
+	lanes := byteWidth / 4
+	vectorType := fmt.Sprintf("<%d x float>", lanes)
+	result := c.newTmp()
+	if source.Kind != OpReg && source.Kind != OpFP {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return err
+		}
+		segment := ""
+		if source.Kind == OpMem && source.Mem.Segment != "" {
+			segment = "%" + strings.ToLower(string(source.Mem.Segment)) + ":"
+		}
+		assembly := strings.ToLower(string(form.op)) + " " + segment + "$1, $0"
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s elementtype([%d x i8]) %s)\n",
+			result, vectorType, assembly, "=x,*m,~{memory}", pointerType, byteWidth, pointer)
+	} else {
+		value, err := c.loadFloatingVectorOperand(source, byteWidth, lanes, 32)
+		if err != nil {
+			return err
+		}
+		intrinsic := "llvm.x86.sse.rcp.ps"
+		if strings.Contains(string(form.op), "RSQRT") {
+			intrinsic = "llvm.x86.sse.rsqrt.ps"
+		}
+		if byteWidth == 32 {
+			intrinsic = "llvm.x86.avx.rcp.ps.256"
+			if strings.Contains(string(form.op), "RSQRT") {
+				intrinsic = "llvm.x86.avx.rsqrt.ps.256"
+			}
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s)\n", result, vectorType, intrinsic, vectorType, value)
+	}
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytesValue, vectorType, result, byteWidth)
+	if form.legacy {
+		return c.storeLegacyXViews(destination.Reg, "%"+bytesValue)
+	}
+	return c.storePackedMoveOperand(destination, byteWidth, "%"+bytesValue)
+}
+
+func (c *amd64Ctx) lowerScalarReciprocalEstimate(base string, ins Instr) (bool, bool, error) {
+	form, _, err := x86ScalarReciprocalProperties(Op(base), ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.emitScalarReciprocalEstimate(ins, form)
+}
+
+func (c *amd64Ctx) emitScalarReciprocalEstimate(ins Instr, form x86ScalarReciprocalForm) error {
+	if ins.x86AddressBits != 0 {
+		return fmt.Errorf("%w: %s needs its original address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	upper, err := c.loadFloatingVectorOperand(ins.Args[form.base], 16, 4, 32)
+	if err != nil {
+		return err
+	}
+	value, sourceType, constraint, template, err := c.scalarReciprocalNativeSource(ins.Args[0])
+	if err != nil {
+		return err
+	}
+	// Keep the scalar hardware approximation, not a packed estimate or generic
+	// division/sqrt. The original opcode has no SIMD exceptions, ignores RC,
+	// treats denormals as signed zero and leaves all MXCSR status untouched.
+	assembly := strings.ToLower(string(ins.Op)) + " "
+	constraints, args := "=x,", ""
+	if form.spec.vector {
+		assembly += template + ", $2, $0"
+		constraints += constraint + ",x"
+		args = fmt.Sprintf("%s %s, <4 x float> %s", sourceType, value, upper)
+	} else {
+		assembly += strings.Replace(template, "$1", "$2", 1) + ", $0"
+		constraints += "0," + constraint
+		args = fmt.Sprintf("<4 x float> %s, %s %s", upper, sourceType, value)
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s)\n", result, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, result)
+	if !form.spec.vector {
+		return c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[form.destination], 16, "%"+bytes)
+}
+
+func (c *amd64Ctx) scalarReciprocalNativeSource(source Operand) (value, typ, constraint, template string, err error) {
+	if source.Kind == OpReg {
+		value, err = c.loadFloatingVectorOperand(source, 16, 4, 32)
+		return value, "<4 x float>", "x", "$1", err
+	}
+	if source.Kind == OpFP {
+		bits, loadErr := c.loadScalarLaneFPBits(source.FPOffset, 32)
+		if loadErr != nil {
+			return "", "", "", "", loadErr
+		}
+		scalar, inserted := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to float\n", scalar, bits)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x float> zeroinitializer, float %%%s, i32 0\n", inserted, scalar)
+		return "%" + inserted, "<4 x float>", "x", "$1", nil
+	}
+	// A sideeffecting m32 operand keeps the original access even for Void.
+	// This pointer is not a widened virtual FP slot or invented backing.
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", "", "", "", err
+	}
+	segment := ""
+	if source.Kind == OpMem && source.Mem.Segment != "" {
+		segment = "%" + strings.ToLower(string(source.Mem.Segment)) + ":"
+	}
+	return pointer, pointerType + " elementtype([4 x i8])", "*m", segment + "$1", nil
+}
diff --git a/amd64_lower_reciprocal14_test.go b/amd64_lower_reciprocal14_test.go
new file mode 100644
index 000000000..97130e550
--- /dev/null
+++ b/amd64_lower_reciprocal14_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86Reciprocal14InitializeOriginalShapes(t *testing.T, original, arch string) (string, string, int) {
+	t.Helper()
+	var source, declarations strings.Builder
+	count := 0
+	for _, line := range strings.Split(original, "\n") {
+		instruction := strings.TrimSpace(line)
+		if instruction == "" || instruction == "RET" || strings.HasPrefix(instruction, "TEXT ") {
+			continue
+		}
+		if arch == "386" {
+			// Keep the original high-bank source's Go assembler observation
+			// above. Its physical mode32 counterpart uses actual low registers.
+			instruction = strings.NewReplacer("X20", "X4", "Y20", "Y4", "X21", "X5").Replace(instruction)
+		}
+		ins := x86ScalarLaneInstruction(t, instruction)
+		registers := [3]int{0, 0, 0}
+		for index, operand := range ins.Args {
+			register, vector := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+			if !vector {
+				continue
+			}
+			if index == len(ins.Args)-1 {
+				registers[2] = register
+			} else if index == 0 {
+				registers[0] = register
+			} else {
+				registers[1] = register
+			}
+		}
+		body, declaration := x86PackedAbsSignInitializedInstruction(count, instruction, arch, registers)
+		maskOffset := 32
+		if arch == "386" {
+			maskOffset = 16
+		}
+		var masks strings.Builder
+		for k := 2; k <= 5; k++ {
+			fmt.Fprintf(&masks, "KMOVQ mask+%d(FP),K%d\n", maskOffset, k)
+		}
+		body = strings.Replace(body, "STC\n", masks.String()+"STC\n", 1)
+		declaration = strings.Replace(declaration, "input,control,old *[64]byte", "input *[128]byte,control,old *[64]byte", 1)
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		count++
+	}
+	return source.String(), declarations.String(), count
+}
+
+func TestX86Reciprocal14Mode32HighSyntaxHasNoPhysicalBinding(t *testing.T) {
+	for _, member := range x86Reciprocal14TestMembers {
+		instruction := member.op + " X1,X20"
+		if member.scalar {
+			instruction = member.op + " X1,X20,X21"
+		}
+		source := "TEXT high(SB),$0-0\n" + instruction + "\nRET\n"
+		requireX86GoAssemblerResult(t, "386", source, true)
+		ins := x86ScalarLaneInstruction(t, instruction)
+		if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("named high-bank syntax was mistaken for a physical mode32 register", instruction, known, err)
+		}
+	}
+}
+
+func TestTranslateX86Reciprocal14CompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's _yvexpandpd table accepts EVEX X/Y/Z register or memory
+	// sources, optional scalar-memory broadcast, and optional K1-K7 merge/.Z
+	// masking. _yvgetexpsd accepts scalar memory/X sources, an X passthrough,
+	// and the same optional mask. The 386 frontend accepts packed three-operand
+	// masks, refuses scalar four-operand masks, and limits Z registers to Z0-Z7.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 31
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT reciprocal14forms(SB),$0-0\n")
+			for _, op := range []string{"VRCP14PS", "VRCP14PD", "VRSQRT14PS", "VRSQRT14PD"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s1, %s20\n", op, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s20\n", op, width)
+					fmt.Fprintf(&source, "\t%s.BCST 16(AX), %s20\n", op, width)
+				}
+				fmt.Fprintf(&source, "\t%s Z1, Z%d\n", op, lastZ)
+				fmt.Fprintf(&source, "\t%s 24(AX), Z%d\n", op, lastZ)
+				fmt.Fprintf(&source, "\t%s.BCST 32(AX), Z%d\n", op, lastZ)
+				fmt.Fprintf(&source, "\t%s X1, K1, X20\n", op)
+				fmt.Fprintf(&source, "\t%s.Z 40(AX), K2, Y20\n", op)
+				fmt.Fprintf(&source, "\t%s.BCST.Z 48(AX), K3, Z%d\n", op, lastZ)
+			}
+			for _, op := range []string{"VRCP14SS", "VRCP14SD", "VRSQRT14SS", "VRSQRT14SD"} {
+				fmt.Fprintf(&source, "\t%s X1, X20, X21\n", op)
+				fmt.Fprintf(&source, "\t%s 56(AX), X20, X21\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X20, K4, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 64(AX), X20, K5, X21\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			initialized, declaration, count := x86Reciprocal14InitializeOriginalShapes(t, source.String(), target.goarch)
+			want := 64
+			if target.goarch == "386" {
+				want = 56
+			}
+			if count != want {
+				t.Fatal("original reciprocal14 shape count changed", count, want)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, declaration, target.goarch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized original reciprocal14 shapes rejected", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "reciprocal14-"+target.name+".ll", "reciprocal14-"+target.name+".o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateX86Reciprocal14RejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VRCP14PS X0, Y1"},
+		{goarch: "amd64", instruction: "VRSQRT14PD.Z Z0, Z1"},
+		{goarch: "amd64", instruction: "VRCP14PS.BCST X0, X1"},
+		{goarch: "amd64", instruction: "VRCP14PD.SAE Z0, Z1"},
+		{goarch: "amd64", instruction: "VRSQRT14PS Z0, K0, Z1"},
+		{goarch: "amd64", instruction: "VRCP14SS X0, X1"},
+		{goarch: "amd64", instruction: "VRCP14SD Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VRSQRT14SS.BCST 8(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VRSQRT14SD.SAE X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRCP14SS.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRCP14SS X0, X1, K0, X2"},
+		{goarch: "386", instruction: "VRCP14SS X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VRSQRT14PD Z0, Z8"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's reciprocal14 tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_reciprocal_scalar_test.go b/amd64_lower_reciprocal_scalar_test.go
new file mode 100644
index 000000000..a6baa5e45
--- /dev/null
+++ b/amd64_lower_reciprocal_scalar_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ScalarReciprocalCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			const vexLast = 15
+			var source strings.Builder
+			source.WriteString("DATA scalarreciprocaldata+0(SB)/4, $0\n")
+			source.WriteString("GLOBL scalarreciprocaldata(SB), $4\n")
+			source.WriteString("TEXT scalarreciprocalforms(SB),$0-4\n")
+			for _, op := range []string{"RCPSS", "RSQRTSS"} {
+				fmt.Fprintf(&source, "\t%s X1, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s scalarreciprocaldata(SB), X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s arg+0(FP), X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 0, X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VRCPSS", "VRSQRTSS"} {
+				fmt.Fprintf(&source, "\t%s X1, X2, X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X2, X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s scalarreciprocaldata(SB), X2, X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s arg+0(FP), X2, X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s 0, X2, X%d\n", op, vexLast)
+				if target.goarch == "386" {
+					// Go's VEX register classes retain their 16-register
+					// compatibility closure even in 32-bit mode.
+					fmt.Fprintf(&source, "\t%s 16(R9), X13, X14\n", op)
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, op := range []string{"RCPSS", "RSQRTSS"} {
+					fmt.Fprintf(&source, "\t%s 16(R11)(R12*2), X13\n", op)
+				}
+				for _, op := range []string{"VRCPSS", "VRSQRTSS"} {
+					fmt.Fprintf(&source, "\t%s 16(R11)(R12*2), X13, X14\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures := map[string]FuncSig{
+				"scalarreciprocalforms": {
+					Name: "scalarreciprocalforms", Args: []LLVMType{LLVMType("float")}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: LLVMType("float"), Index: 0, Field: -1}}},
+				},
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func scalarreciprocalforms(arg float32)\n", target.goarch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original uninitialized format rows acquired numerical or native input permission", api, err)
+				}
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					// Preserve Go's original mode32 VEX compatibility formats as
+					// private object rows, not initialized physical entry states.
+					grammarArch := target.goarch
+					if strings.HasPrefix(string(ins.Op), "V") {
+						grammarArch = "amd64"
+					}
+					form, known, err := x86ScalarReciprocalProperties(ins.Op, ins, grammarArch)
+					if !known || err != nil {
+						return known, false, err
+					}
+					return true, false, c.emitScalarReciprocalEstimate(ins, form)
+				})
+			for _, want := range []string{
+				`asm sideeffect "rcpss `, `asm sideeffect "rsqrtss `,
+				`asm sideeffect "vrcpss `, `asm sideeffect "vrsqrtss `,
+				"elementtype([4 x i8])", "insertelement <4 x float>",
+				`"target-features"="+avx,+sse"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("scalar reciprocal lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			if strings.Contains(ir, "call <4 x float> @llvm.x86.sse.rcp.ps") ||
+				strings.Contains(ir, "call <4 x float> @llvm.x86.sse.rsqrt.ps") {
+				t.Fatal("scalar source opcode was replaced with a packed estimate")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalar-reciprocal-"+target.name+".ll", "scalar-reciprocal-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestAMD64ScalarReciprocalRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT scalarreciprocalsemantics(SB),$0-24
+	MOVQ out+0(FP), DI
+	MOVQ source+8(FP), AX
+	MOVQ upper+16(FP), BX
+
+	MOVUPS (BX), X0
+	STC
+	RCPSS (AX), X0
+	MOVUPS X0, 0(DI)
+	SETCS 64(DI)
+
+	MOVUPS (BX), X1
+	STC
+	RSQRTSS (AX), X1
+	MOVUPS X1, 16(DI)
+	SETCS 65(DI)
+
+	MOVUPS (BX), X2
+	STC
+	VRCPSS (AX), X2, X3
+	MOVUPS X3, 32(DI)
+	SETCS 66(DI)
+
+	MOVUPS (BX), X4
+	STC
+	VRSQRTSS (AX), X4, X5
+	MOVUPS X5, 48(DI)
+	SETCS 67(DI)
+	VZEROUPPER
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"scalarreciprocalsemantics": {
+				Name: "scalarreciprocalsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void scalarreciprocalsemantics(uint8_t *, const float *, const float *);
+static int close_enough(float got, float want) {
+  float delta = got - want;
+  if (delta < 0) delta = -delta;
+  return delta < 0.01f;
+}
+int main(void) {
+  float source[4] = {4.0f, 100.0f, 200.0f, 300.0f};
+  float upper[4] = {99.0f, 10.0f, 20.0f, 30.0f};
+  uint8_t out[68] = {0};
+  scalarreciprocalsemantics(out, source, upper);
+  const float *values = (const float *)out;
+  for (int vector = 0; vector < 4; ++vector) {
+    float want = (vector & 1) ? 0.5f : 0.25f;
+    if (!close_enough(values[4*vector], want)) return 10+vector;
+    if (values[4*vector+1] != 10.0f || values[4*vector+2] != 20.0f || values[4*vector+3] != 30.0f) return 20+vector;
+    if (out[64+vector] != 1) return 30+vector;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_reciprocal_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateX86ScalarReciprocalRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "RCPSS X0"},
+		{goarch: "amd64", instruction: "RSQRTSS X0, X1, X2"},
+		{goarch: "amd64", instruction: "RCPSS Y0, X1"},
+		{goarch: "amd64", instruction: "RCPSS X0, X16"},
+		{goarch: "amd64", instruction: "VRCPSS X0, X1"},
+		{goarch: "amd64", instruction: "VRSQRTSS X0, X1, Y2"},
+		{goarch: "amd64", instruction: "VRCPSS Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VRCPSS.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VRSQRTSS X0, X1, K1, X2"},
+		{goarch: "386", instruction: "RCPSS X0, X8"},
+		{goarch: "386", instruction: "RSQRTSS 8(R9), X0"},
+		{goarch: "386", instruction: "VRCPSS X16, X1, X2"},
+		{goarch: "386", instruction: "VRSQRTSS X0, X1, X16"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar reciprocal tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_reciprocal_test.go b/amd64_lower_reciprocal_test.go
new file mode 100644
index 000000000..ee274955f
--- /dev/null
+++ b/amd64_lower_reciprocal_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedReciprocalCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's legacy yxm table accepts X/m128 -> X, while the VEX
+	// _yvptest table accepts both X/m128 -> X and Y/m256 -> Y.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			const vexLast = 15
+			var source strings.Builder
+			source.WriteString("TEXT packedreciprocalforms(SB),$0-0\n")
+			for _, op := range []string{"RCPPS", "RSQRTPS"} {
+				fmt.Fprintf(&source, "\t%s X1, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 0, X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VRCPPS", "VRSQRTPS"} {
+				fmt.Fprintf(&source, "\t%s X1, X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s Y1, Y%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s 16(AX), Y%d\n", op, vexLast)
+				fmt.Fprintf(&source, "\t%s 0, Y%d\n", op, vexLast)
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func packedreciprocalforms()\n", target.goarch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("bare original formats acquired a native pointer or physical entry value", api, err)
+				}
+			}
+			// Keep every original Go shape and its actual LLVM object. The
+			// private format compiler supplies no public entry/storage proof;
+			// mode32 VEX high-register spellings remain frontend-only shapes.
+			ll := x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"packedreciprocalforms": {Name: "packedreciprocalforms", Ret: Void}},
+				target.goarch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					grammarArch := target.goarch
+					if strings.HasPrefix(string(ins.Op), "V") {
+						grammarArch = "amd64"
+					}
+					form, known, err := x86PackedReciprocalProperties(ins.Op, ins, grammarArch)
+					if !known || err != nil {
+						return known, false, err
+					}
+					return true, false, c.emitPackedReciprocalEstimate(ins, form)
+				})
+			for _, intrinsic := range []string{"@llvm.x86.sse.rcp.ps", "@llvm.x86.sse.rsqrt.ps", "@llvm.x86.avx.rcp.ps.256", "@llvm.x86.avx.rsqrt.ps.256"} {
+				if !strings.Contains(ll, intrinsic) {
+					t.Fatalf("translation omitted %s:\n%s", intrinsic, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-reciprocal-"+target.name+".ll", "packed-reciprocal-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedReciprocalRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "RCPPS Y0, X1"},
+		{goarch: "amd64", instruction: "RSQRTPS X0, X16"},
+		{goarch: "amd64", instruction: "VRCPPS X16, X1"},
+		{goarch: "amd64", instruction: "VRCPPS Y0, X1"},
+		{goarch: "amd64", instruction: "VRSQRTPS Z0, Z1"},
+		{goarch: "amd64", instruction: "VRCPPS.Z X0, X1"},
+		{goarch: "amd64", instruction: "VRSQRTPS X0, K1, X1"},
+		{goarch: "386", instruction: "RCPPS X0, X8"},
+		{goarch: "386", instruction: "VRCPPS X16, X0"},
+		{goarch: "386", instruction: "VRCPPS Y16, Y0"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       test.goarch,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's reciprocal tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_rorx_test.go b/amd64_lower_rorx_test.go
new file mode 100644
index 000000000..d2db19417
--- /dev/null
+++ b/amd64_lower_rorx_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawRORXReportedEncoding(t *testing.T) {
+	const source = `
+TEXT rawRORX(SB),$0-0
+	BYTE $0xc4
+	BYTE $0xe3
+	BYTE $0x7b
+	BYTE $0xf0
+	BYTE $0xe8
+	BYTE $0x19
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "386", triple: "i686-pc-windows-msvc"},
+		{goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var ir string
+			if target.goarch == "amd64" {
+				// The original ModRM writes physical BP. Its encoding remains
+				// covered, but an ordinary logical entry has no native-frame role.
+				ir = x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			} else {
+				ir, err = Translate(file, Options{
+					Goarch:       target.goarch,
+					TargetTriple: target.triple,
+					Sigs:         map[string]FuncSig{"rawRORX": {Name: "rawRORX", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			if !strings.Contains(ir, `"target-features"="+bmi2"`) {
+				t.Fatalf("raw RORX did not infer BMI2 target feature:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-rorx.ll", "raw-rorx.o", ir)
+		})
+	}
+}
+
+func TestX86RORXGo127CompleteNamedForms(t *testing.T) {
+	const source = `
+TEXT rorxforms(SB),$0-0
+	RORXL $7, (BX), DX
+	RORXL $31, R11, R12
+	RORXQ $7, 16(BX)(SI*2), DX
+	RORXQ $63, R11, R12
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	const triple = "x86_64-unknown-linux-gnu"
+	ir := x86UnboundVoidScalarFormatObject(t, source, "rorxforms", "amd64", triple)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		x86PackedStringCompileObject(t, llc, triple, ir, level)
+	}
+}
+
+func TestX86RORXCompleteGo127FormsAcrossTargets(t *testing.T) {
+	registers386 := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+	registersAMD64 := append(append([]string{}, registers386...), "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	targets := []struct {
+		name      string
+		goarch    string
+		triple    string
+		registers []string
+	}{
+		{name: "386-linux", goarch: "386", triple: "i386-unknown-linux-gnu", registers: registers386},
+		{name: "386-windows", goarch: "386", triple: "i686-pc-windows-msvc", registers: registers386},
+		{name: "amd64-darwin", goarch: "amd64", triple: "x86_64-apple-darwin", registers: registersAMD64},
+		{name: "amd64-linux", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registers: registersAMD64},
+		{name: "amd64-windows", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registers: registersAMD64},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rorxall(SB),$0-0\n")
+			for _, width := range []string{"L", "Q"} {
+				for index, sourceRegister := range target.registers {
+					destination := target.registers[(index+3)%len(target.registers)]
+					fmt.Fprintf(&source, "\tRORX%s $%d, %s, %s\n", width, index*17&255, sourceRegister, destination)
+				}
+				fmt.Fprintf(&source, "\tRORX%s $-1, 8(AX), DX\n", width)
+				fmt.Fprintf(&source, "\tRORX%s $63, 16(AX)(CX*4), BX\n", width)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "rorxall", target.goarch, target.triple)
+			if !strings.Contains(ir, `"target-features"="+bmi2"`) {
+				t.Fatalf("RORX family did not infer BMI2 target feature:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "rorx-family.ll", "rorx-family.o", ir)
+		})
+	}
+}
+
+func TestX86RawRORXCompleteRegisterFields(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		registerCount := 8
+		if mode == 64 {
+			registerCount = 16
+		}
+		for _, width64 := range []bool{false, true} {
+			for source := 0; source < registerCount; source++ {
+				for destination := 0; destination < registerCount; destination++ {
+					for _, immediate := range []byte{0, 1, 31, 32, 63, 255} {
+						p0 := byte((^destination>>3)&1)<<7 | 1<<6 | byte((^source>>3)&1)<<5 | 3
+						p1 := byte(0x7b)
+						if width64 {
+							p1 |= 0x80
+						}
+						modRM := byte(0xc0 | destination&7<<3 | source&7)
+						encoding := []byte{0xc4, p0, p1, 0xf0, modRM, immediate}
+						instruction, length, ok, err := decodedX86RORXInstruction(encoding, mode)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("mode=%d width64=%v source=%d destination=%d immediate=%d: ok=%v length=%d err=%v", mode, width64, source, destination, immediate, ok, length, err)
+						}
+						wantOp := Op("RORXL")
+						if width64 && mode == 64 {
+							wantOp = "RORXQ"
+						}
+						wantSource, _ := decodedX86GeneralRegister(source)
+						wantDestination, _ := decodedX86GeneralRegister(destination)
+						if instruction.Op != wantOp || len(instruction.Args) != 3 || instruction.Args[0].Imm != int64(immediate) || instruction.Args[1].Reg != wantSource || instruction.Args[2].Reg != wantDestination {
+							t.Fatalf("encoding %x decoded as %#v", encoding, instruction)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawRORXMemoryForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		encoding []byte
+	}{
+		{name: "direct", encoding: []byte{0xc4, 0xe3, 0x7b, 0xf0, 0x13, 0x07}},
+		{name: "extended base", encoding: []byte{0xc4, 0xc3, 0x7b, 0xf0, 0x13, 0x07}},
+		{name: "sib disp8", encoding: []byte{0xc4, 0x83, 0xfb, 0xf0, 0x54, 0x88, 0x10, 0xff}},
+		{name: "base less", encoding: []byte{0xc4, 0xe3, 0x7b, 0xf0, 0x14, 0x25, 0x78, 0x56, 0x34, 0x12, 0x1f}},
+		{name: "segment", encoding: []byte{0x64, 0xc4, 0xe3, 0x7b, 0xf0, 0x54, 0x48, 0x08, 0x1f}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86RORXInstruction(test.encoding, 64)
+			if !ok || err != nil || length != len(test.encoding) || len(instruction.Args) != 3 || instruction.Args[1].Kind != OpMem {
+				t.Fatalf("encoding %x: instruction=%#v ok=%v length=%d err=%v", test.encoding, instruction, ok, length, err)
+			}
+		})
+	}
+}
+
+func TestX86RawRORXRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+	}{
+		{name: "vex l", mode: 64, encoding: []byte{0xc4, 0xe3, 0x7f, 0xf0, 0xd2, 0x07}},
+		{name: "vex pp", mode: 64, encoding: []byte{0xc4, 0xe3, 0x79, 0xf0, 0xd2, 0x07}},
+		{name: "vex vvvv", mode: 64, encoding: []byte{0xc4, 0xe3, 0x73, 0xf0, 0xd2, 0x07}},
+		{name: "missing modrm", mode: 64, encoding: []byte{0xc4, 0xe3, 0x7b, 0xf0}},
+		{name: "missing immediate", mode: 64, encoding: []byte{0xc4, 0xe3, 0x7b, 0xf0, 0xd2}},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0xc4, 0xe3, 0x7b, 0xf0, 0xd2, 0x07}},
+		{name: "rip relative", mode: 64, encoding: []byte{0xc4, 0xe3, 0x7b, 0xf0, 0x15, 0, 0, 0, 0, 0x07}},
+		{name: "extended source 386", mode: 32, encoding: []byte{0xc4, 0xc3, 0x7b, 0xf0, 0xc0, 0x07}},
+		{name: "extended destination 386", mode: 32, encoding: []byte{0xc4, 0x63, 0x7b, 0xf0, 0xc0, 0x07}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86RORXInstruction(test.encoding, test.mode)
+			if !ok || err == nil {
+				t.Fatalf("encoding %x: ok=%v err=%v, want recognized rejection", test.encoding, ok, err)
+			}
+		})
+	}
+}
+
+func TestX86RORXGo127ModeOracle(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+		want        bool
+	}{
+		{goarch: "386", instruction: "RORXL $7, (BX), DX", want: true},
+		{goarch: "386", instruction: "RORXQ $7, (BX), DX", want: true},
+		{goarch: "386", instruction: "RORXL $7, R8, DX", want: false},
+		{goarch: "amd64", instruction: "RORXQ $7, R8, R15", want: true},
+	} {
+		t.Run(fmt.Sprintf("%s/%s", test.goarch, test.instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, test.goarch, "TEXT oracle(SB),$0-0\n\t"+test.instruction+"\n\tRET\n", test.want)
+		})
+	}
+}
diff --git a/amd64_lower_round.go b/amd64_lower_round.go
new file mode 100644
index 000000000..dc62f9012
--- /dev/null
+++ b/amd64_lower_round.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import "fmt"
+
+type amd64RoundSpec struct {
+	laneBits int
+	scalar   bool
+	vector   bool
+}
+
+// amd64RoundSpecs mirrors Go 1.27's yxshuf, _yvroundpd, and _yvdppd tables.
+// The legacy family is X-only, the packed VEX family is X/Y, and the scalar
+// VEX family has an explicit upper-lane source.
+var amd64RoundSpecs = map[Op]amd64RoundSpec{
+	"ROUNDPS":  {laneBits: 32},
+	"ROUNDPD":  {laneBits: 64},
+	"ROUNDSS":  {laneBits: 32, scalar: true},
+	"ROUNDSD":  {laneBits: 64, scalar: true},
+	"VROUNDPS": {laneBits: 32, vector: true},
+	"VROUNDPD": {laneBits: 64, vector: true},
+	"VROUNDSS": {laneBits: 32, scalar: true, vector: true},
+	"VROUNDSD": {laneBits: 64, scalar: true, vector: true},
+}
+
+func (c *amd64Ctx) lowerRound(rawOp Op, ins Instr) (ok bool, terminated bool, err error) {
+	local := ins
+	local.Op = rawOp
+	form, known, err := x86RoundProperties(local, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !form.spec.vector && form.memory && form.source.Kind != OpFP {
+		memory := x86FloatBinaryForm{bits: form.spec.laneBits, scalar: form.spec.scalar, legacy: true,
+			first: 1, second: len(ins.Args) - 1, destination: len(ins.Args) - 1, mask: -1,
+			byteWidth: 16, memory: 1, memoryBytes: form.memoryBytes}
+		return true, false, c.emitLegacyAlternatingRoundMemory(local, memory, &form.immediate)
+	}
+	intrinsic := amd64RoundIntrinsic(form.immediate)
+	if form.spec.scalar {
+		return c.lowerScalarRound(form, intrinsic)
+	}
+	return c.lowerPackedRound(form, intrinsic)
+}
+
+func amd64RoundIntrinsic(imm uint8) string {
+	if imm&4 != 0 {
+		return "rint"
+	}
+	switch imm & 3 {
+	case 0:
+		return "roundeven"
+	case 1:
+		return "floor"
+	case 2:
+		return "ceil"
+	default:
+		return "trunc"
+	}
+}
+
+func (c *amd64Ctx) lowerScalarRound(form x86RoundForm, intrinsic string) (bool, bool, error) {
+	spec, destination := form.spec, form.destination
+	value, err := c.loadAlternatingRoundFloat(form.source, form.memoryBytes, spec.laneBits, spec.vector)
+	if err != nil {
+		return true, false, err
+	}
+	rounded := c.emitScalarFloatRound(value, spec.laneBits, intrinsic)
+	bits := c.newTmp()
+	floatingType := amd64FloatingTypeForBits(spec.laneBits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", bits, floatingType, rounded, spec.laneBits)
+	baseBytes, err := c.loadX(form.upper.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, baseBytes)
+	if spec.vector {
+		return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+bits, base, "", false)
+	}
+	return true, false, c.storeVectorScalarRegister(destination.Reg, spec.laneBits, "%"+bits, base, "", false)
+}
+
+func (c *amd64Ctx) lowerPackedRound(form x86RoundForm, intrinsic string) (bool, bool, error) {
+	spec, destination, byteWidth := form.spec, form.destination, form.byteWidth
+	bytesValue, err := c.loadRoundPackedBytes(form)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := byteWidth * 8 / spec.laneBits
+	floatingType := fmt.Sprintf("<%d x %s>", lanes, amd64FloatingTypeForBits(spec.laneBits))
+	floating := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", floating, byteWidth, bytesValue, floatingType)
+	result := "poison"
+	for lane := 0; lane < lanes; lane++ {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", value, floatingType, floating, lane)
+		rounded := c.emitScalarFloatRound("%"+value, spec.laneBits, intrinsic)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, %s %s, i32 %d\n", inserted, floatingType, result, amd64FloatingTypeForBits(spec.laneBits), rounded, lane)
+		result = "%" + inserted
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, floatingType, result, byteWidth)
+	if spec.vector {
+		return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+	}
+	return true, false, c.storeX(destination.Reg, "%"+out)
+}
+
+func (c *amd64Ctx) emitScalarFloatRound(value string, bits int, intrinsic string) string {
+	typeName := amd64FloatingTypeForBits(bits)
+	intrinsicSuffix := "f64"
+	if bits == 32 {
+		intrinsicSuffix = "f32"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %s)\n", result, typeName, intrinsic, intrinsicSuffix, typeName, value)
+	return "%" + result
+}
diff --git a/amd64_lower_round_test.go b/amd64_lower_round_test.go
new file mode 100644
index 000000000..bfb9e9697
--- /dev/null
+++ b/amd64_lower_round_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86RoundCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT roundforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"ROUNDPS", "ROUNDPD", "ROUNDSS", "ROUNDSD"} {
+				fmt.Fprintf(&source, "\t%s $0, X0, X1\n", op)
+				fmt.Fprintf(&source, "\t%s $255, 8(BX), X2\n", op)
+			}
+			for _, op := range []string{"VROUNDPS", "VROUNDPD"} {
+				fmt.Fprintf(&source, "\t%s $0, X0, X1\n", op)
+				fmt.Fprintf(&source, "\t%s $-1, 16(BX), X2\n", op)
+				fmt.Fprintf(&source, "\t%s $255, Y0, Y1\n", op)
+				fmt.Fprintf(&source, "\t%s $2, 32(BX), Y2\n", op)
+			}
+			for _, op := range []string{"VROUNDSS", "VROUNDSD"} {
+				fmt.Fprintf(&source, "\t%s $0, X0, X1, X2\n", op)
+				fmt.Fprintf(&source, "\t%s $-1, 8(BX), X1, X2\n", op)
+				fmt.Fprintf(&source, "\t%s $255, X0, X1, X2\n", op)
+			}
+			source.WriteString("\tRET\n")
+			ll := x86RoundOriginalSourceClassifiedObjects(t, source.String(), target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "round-"+target.name+".ll", "round-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86RoundRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ROUNDSD $-1, X0, X1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ROUNDSS $256, X0, X1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ROUNDPD $0, Y0, Y1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ROUNDPS $0, X0, Y1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "ROUNDSS.Z $0, X0, X1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDPS $-129, X0, X1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDPD $256, Y0, Y1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDPS $0, X0, Y1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDSS $0, X0, X1"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDSD $0, X0, Y1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VROUNDSS $0, X0, X1, Y2"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "ROUNDSS $0, X8, X0"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "VROUNDPS $0, Y8, Y0"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "VROUNDSD $0, X0, X8, X1"},
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+test.instruction+"\n\tRET\n")
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: test.triple,
+					Goarch:       test.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ROUND tables for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+const x86LegacyRoundOriginalRuntimeSource = `
+TEXT roundsemantics(SB),NOSPLIT,$0-40
+	MOVQ out+0(FP), AX
+	MOVQ a32+8(FP), BX
+	MOVQ a64+16(FP), CX
+	MOVQ upper32+24(FP), DX
+	MOVQ upper64+32(FP), SI
+	ROUNDPS $0, (BX), X0
+	MOVUPS X0, 0(AX)
+	ROUNDPS $1, (BX), X0
+	MOVUPS X0, 16(AX)
+	ROUNDPS $2, (BX), X0
+	MOVUPS X0, 32(AX)
+	ROUNDPS $3, (BX), X0
+	MOVUPS X0, 48(AX)
+	ROUNDPS $4, (BX), X0
+	MOVUPS X0, 64(AX)
+	MOVUPS (DX), X1
+	VROUNDSS $1, (BX), X1, X2
+	MOVUPS X2, 80(AX)
+	ROUNDPD $0, (CX), X0
+	MOVUPD X0, 96(AX)
+	ROUNDPD $1, (CX), X0
+	MOVUPD X0, 112(AX)
+	ROUNDPD $2, (CX), X0
+	MOVUPD X0, 128(AX)
+	ROUNDPD $3, (CX), X0
+	MOVUPD X0, 144(AX)
+	ROUNDPD $4, (CX), X0
+	MOVUPD X0, 160(AX)
+	MOVUPD (SI), X1
+	VROUNDSD $2, (CX), X1, X2
+	MOVUPD X2, 176(AX)
+	VZEROUPPER
+	RET
+`
+
+func x86LegacyRoundOriginalRuntimeFrame() FrameLayout {
+	return FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+	}}
+}
+
+// This is the exact existing five-opaque-Ptr runtime fixture, compiled on
+// every host. It does not bypass the independent native runtime guard below.
+func TestX86LegacyRoundOriginalRuntimeSourceObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	pkg := mustGoPackage(t, "bitview", "package bitview\nfunc roundsemantics(out,a32,a64,upper32,upper64 *byte)\n")
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			// Only the Go oracle adds its standard NOSPLIT macro definition.
+			// The original shared assembly body itself is byte-identical.
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+x86LegacyRoundOriginalRuntimeSource)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					manualCalls := 0
+					manual := func(name string) (FuncSig, bool) {
+						if name != "roundsemantics" {
+							return FuncSig{}, false
+						}
+						manualCalls++
+						return FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+							Frame: x86LegacyRoundOriginalRuntimeFrame()}, true
+					}
+					ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, x86LegacyRoundOriginalRuntimeSource,
+						pkg, "amd64", triple, api, manual)
+					if err != nil || ir == "" || manualCalls == 0 {
+						t.Fatal("exact original runtime source/manual pointer frame rejected", api, manualCalls, err)
+					}
+					for _, level := range []string{"0", "2"} {
+						t.Run("IR"+level+"/backend"+level, func(t *testing.T) {
+							objectIR := ir
+							if level == "2" {
+								objectIR = x86DwordProductIROptimize(t, ir)
+							}
+							x86PackedStringCompileObject(t, llc, triple, objectIR, "-O"+level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestAMD64RoundRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86LegacyRoundOriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := x86LegacyRoundOriginalRuntimeFrame()
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"roundsemantics": {Name: "roundsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void roundsemantics(uint8_t *, const float *, const double *, const float *, const double *);
+static int check32(const float *got, const float *want, int base) {
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return base+i;
+  return 0;
+}
+static int check64(const double *got, const double *want, int base) {
+  for (int i = 0; i < 2; i++) if (got[i] != want[i]) return base+i;
+  return 0;
+}
+int main(void) {
+  float a32[4] = {1.5f, -1.5f, 2.75f, -2.75f};
+  double a64[2] = {2.5, -2.5};
+  float upper32[4] = {99.0f, 10.0f, 20.0f, 30.0f};
+  double upper64[2] = {99.0, 40.0};
+  float want32[6][4] = {
+    {2, -2, 3, -3}, {1, -2, 2, -3}, {2, -1, 3, -2},
+    {1, -1, 2, -2}, {2, -2, 3, -3}, {1, 10, 20, 30},
+  };
+  double want64[6][2] = {
+    {2, -2}, {2, -3}, {3, -2}, {2, -2}, {2, -2}, {3, 40},
+  };
+  uint8_t out[192] = {0};
+  roundsemantics(out, a32, a64, upper32, upper64);
+  for (int i = 0; i < 6; i++) {
+    int failed = check32((const float *)(out + 16*i), want32[i], 10+4*i);
+    if (failed) return failed;
+  }
+  for (int i = 0; i < 6; i++) {
+    int failed = check64((const double *)(out + 96 + 16*i), want64[i], 40+2*i);
+    if (failed) return failed;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "round_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_rtm.go b/amd64_lower_rtm.go
new file mode 100644
index 000000000..ade2d7701
--- /dev/null
+++ b/amd64_lower_rtm.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64RTMKind uint8
+
+const (
+	amd64RTMBegin amd64RTMKind = iota
+	amd64RTMAbort
+	amd64RTMEnd
+	amd64RTMTest
+)
+
+type amd64RTMOperand uint8
+
+const (
+	amd64RTMNoOperand amd64RTMOperand = iota
+	amd64RTMBranch
+	amd64RTMUnsignedByte
+)
+
+type amd64RTMSpec struct {
+	kind     amd64RTMKind
+	operand  amd64RTMOperand
+	outputAX bool
+}
+
+// amd64RTMSpecs is the complete Go 1.27 Restricted Transactional Memory
+// grammar. XBEGIN is included even though Go's positive encoder corpus keeps
+// its cases as TODOs: the optab accepts one Ybr target and writes abort status
+// to EAX. XABORT accepts the complete Yu8 immediate domain.
+var amd64RTMSpecs = map[Op]amd64RTMSpec{
+	"XBEGIN": {kind: amd64RTMBegin, operand: amd64RTMBranch, outputAX: true},
+	"XABORT": {kind: amd64RTMAbort, operand: amd64RTMUnsignedByte},
+	"XEND":   {kind: amd64RTMEnd},
+	"XTEST":  {kind: amd64RTMTest},
+}
+
+type amd64RTMForm struct {
+	branch    Operand
+	immediate uint8
+}
+
+func (c *amd64Ctx) lowerRTM(bi int, ii int, op Op, ins Instr, emitCondBr amd64EmitCondBr) (ok bool, terminated bool, err error) {
+	spec, form, known, err := x86RTMProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.emitRTM(bi, ii, strings.ToUpper(string(op)), spec, form, emitCondBr)
+}
+
+func x86RTMProperties(op Op, ins Instr, arch string) (amd64RTMSpec, amd64RTMForm, bool, error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64RTMSpecs[Op(baseOp)]
+	if !recognized {
+		return spec, amd64RTMForm{}, false, nil
+	}
+	if rawOp != baseOp || arch != "386" && arch != "amd64" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), rawOp) {
+		return spec, amd64RTMForm{}, true, fmt.Errorf("%s %s has an invalid suffix, mode or dispatch identity: %q", arch, op, ins.Raw)
+	}
+	form, err := parseX86RTMForm(baseOp, spec, ins, arch)
+	return spec, form, true, err
+}
+
+func parseX86RTMForm(op string, spec amd64RTMSpec, ins Instr, arch string) (amd64RTMForm, error) {
+	var form amd64RTMForm
+	switch spec.operand {
+	case amd64RTMNoOperand:
+		if len(ins.Args) != 0 {
+			return form, fmt.Errorf("%s %s takes no operands: %q", arch, op, ins.Raw)
+		}
+	case amd64RTMBranch:
+		if len(ins.Args) != 1 {
+			return form, fmt.Errorf("%s %s expects one Go 1.27 Ybr target: %q", arch, op, ins.Raw)
+		}
+		form.branch = ins.Args[0]
+	case amd64RTMUnsignedByte:
+		if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 ||
+			ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+			return form, fmt.Errorf("%s %s expects one Go 1.27 Yu8 integer immediate: %q", arch, op, ins.Raw)
+		}
+		form.immediate = uint8(ins.Args[0].Imm)
+	default:
+		panic("unknown amd64 RTM operand kind")
+	}
+	return form, nil
+}
+
+// Only the query kind is an ordinary numerical effect. Transaction begin,
+// abort and end cannot inherit this straight-line storage/FLAGS continuation.
+func x86TypedRTMStatusByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, _, known, err := x86RTMProperties(op, ins, arch)
+	if !known || spec.kind != amd64RTMTest {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	if !x86RegisterQueryPreservesSourceState(ins) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: RTM status query original/normalized identity differs", ErrProbeNeedsContext)
+	}
+	// XTEST reads no GP, numerical or incoming FLAGS input. Its hardware
+	// transaction observation defines ZF and clears the other five flags.
+	return x86TypedByteEffect{flagsDefined: x86ByteFlagsAll, flagsKilled: x86ByteFlagsAll}, true, nil
+}
+
+func (c *amd64Ctx) rtmBranchTarget(bi int, ii int, operand Operand) (string, error) {
+	knownBlock := func(name string) bool {
+		for _, block := range c.blocks {
+			if block.name == name {
+				return true
+			}
+		}
+		return false
+	}
+	var target string
+	switch operand.Kind {
+	case OpIdent:
+		target = operand.Ident
+	case OpReg:
+		target = string(operand.Reg)
+		if !knownBlock(target) {
+			return "", fmt.Errorf("%s XBEGIN register is not a local branch target: %q", c.goarch, target)
+		}
+	case OpSym:
+		target = strings.TrimSpace(operand.Sym)
+		if strings.HasSuffix(target, "(SB)") {
+			return "", fmt.Errorf("%s XBEGIN target must be local: %q", c.goarch, target)
+		}
+		target = strings.TrimSuffix(target, "<>")
+	case OpMem:
+		if !strings.EqualFold(string(operand.Mem.Base), "PC") {
+			return "", fmt.Errorf("%s XBEGIN expects a label or PC-relative target", c.goarch)
+		}
+		current := c.blockBase[bi] + ii
+		index := current + int(operand.Mem.Off)
+		targetBlock, ok := c.blockByIdx[index]
+		if !ok || targetBlock < 0 || targetBlock >= len(c.blocks) {
+			return "", fmt.Errorf("%s XBEGIN invalid PC-relative target %d(PC)", c.goarch, operand.Mem.Off)
+		}
+		target = c.blocks[targetBlock].name
+	default:
+		return "", fmt.Errorf("%s XBEGIN expects one Go 1.27 Ybr target", c.goarch)
+	}
+	if target == "" || !knownBlock(target) {
+		return "", fmt.Errorf("%s XBEGIN unknown local target %q", c.goarch, target)
+	}
+	return target, nil
+}
+
+func (c *amd64Ctx) emitRTM(bi int, ii int, op string, spec amd64RTMSpec, form amd64RTMForm, emitCondBr amd64EmitCondBr) (bool, bool, error) {
+	switch spec.kind {
+	case amd64RTMBegin:
+		if bi+1 >= len(c.blocks) {
+			return true, false, fmt.Errorf("%s XBEGIN has no success fallthrough", c.goarch)
+		}
+		target, err := c.rtmBranchTarget(bi, ii, form.branch)
+		if err != nil {
+			return true, false, err
+		}
+		status := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.xbegin()\n", status)
+		if err := c.storeRegSized(AX, I32, "%"+status); err != nil {
+			return true, false, err
+		}
+		success := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %%%s, -1\n", success, status)
+		if err := emitCondBr("%"+success, c.blocks[bi+1].name, target); err != nil {
+			return true, false, err
+		}
+		return true, true, nil
+	case amd64RTMAbort:
+		fmt.Fprintf(c.b, "  call void @llvm.x86.xabort(i8 %d)\n", form.immediate)
+	case amd64RTMEnd:
+		c.b.WriteString("  call void @llvm.x86.xend()\n")
+	case amd64RTMTest:
+		active := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.xtest()\n", active)
+		zero := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %%%s, 0\n", zero, active)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+		c.clearX86StatusFlags(x86StatusAll &^ x86StatusZF)
+	default:
+		panic("unknown amd64 RTM kind")
+	}
+	return true, false, nil
+}
diff --git a/amd64_lower_rtm_test.go b/amd64_lower_rtm_test.go
new file mode 100644
index 000000000..82ff3d134
--- /dev/null
+++ b/amd64_lower_rtm_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64RTMGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64RTMSpec{
+		"XBEGIN": {kind: amd64RTMBegin, operand: amd64RTMBranch, outputAX: true},
+		"XABORT": {kind: amd64RTMAbort, operand: amd64RTMUnsignedByte},
+		"XEND":   {kind: amd64RTMEnd},
+		"XTEST":  {kind: amd64RTMTest},
+	}
+	if !reflect.DeepEqual(amd64RTMSpecs, want) {
+		t.Fatalf("RTM grammar = %+v, want %+v", amd64RTMSpecs, want)
+	}
+}
+
+func TestTranslateX86RTMCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT rtmforms(SB),$0-0
+	XBEGIN fallback
+	XTEST
+	XEND
+	RET
+fallback:
+	XABORT $0
+	XABORT $255
+	RET
+TEXT rtmpcrel(SB),$0-0
+	XBEGIN 2(PC)
+	XEND
+	RET
+`
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"rtmforms": {Name: "rtmforms", Ret: Void},
+					"rtmpcrel": {Name: "rtmpcrel", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+rtm"`,
+				`call i32 @llvm.x86.xbegin()`,
+				`call i32 @llvm.x86.xtest()`,
+				`call void @llvm.x86.xend()`,
+				`call void @llvm.x86.xabort(i8 0)`,
+				`call void @llvm.x86.xabort(i8 -1)`,
+				`icmp eq i32`,
+				`store i1 %`,
+				`br i1 %`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "rtm-"+target.name+".ll", "rtm-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86RTMRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "XBEGIN AX"},
+		{goarch: "amd64", instruction: "XBEGIN (BX)"},
+		{goarch: "amd64", instruction: "XABORT"},
+		{goarch: "amd64", instruction: "XABORT $-1"},
+		{goarch: "amd64", instruction: "XABORT $256"},
+		{goarch: "amd64", instruction: "XABORT AX"},
+		{goarch: "amd64", instruction: "XEND AX"},
+		{goarch: "amd64", instruction: "XTEST.P"},
+		{goarch: "386", instruction: "XABORT $256"},
+		{goarch: "386", instruction: "XTEST AX"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's RTM tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_sad.go b/amd64_lower_sad.go
new file mode 100644
index 000000000..14403d6d6
--- /dev/null
+++ b/amd64_lower_sad.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedSADKind uint8
+
+const (
+	amd64PackedSADBlockSum amd64PackedSADKind = iota
+	amd64PackedSADMultiple
+	amd64PackedSADDoubleBlock
+)
+
+type amd64PackedSADForm uint8
+
+const (
+	amd64PackedSADLegacyX amd64PackedSADForm = iota
+	amd64PackedSADVEXXY
+	amd64PackedSADEVEXXYZ
+)
+
+type amd64PackedSADSpec struct {
+	kind amd64PackedSADKind
+	form amd64PackedSADForm
+}
+
+// amd64PackedSADSpecs is the complete Go 1.27 byte-SAD grammar. PSADBW uses
+// fixed eight-byte block sums, MPSADBW uses one immediate-selected four-byte
+// block and sliding windows, and VDBPSADBW independently selects four dwords
+// before its sliding SAD. Their vector spellings intentionally differ:
+// VPSADBW has EVEX X/Y/Z rows, VMPSADBW is VEX X/Y only, and VDBPSADBW adds
+// EVEX writemasking to X/Y/Z.
+var amd64PackedSADSpecs = map[Op]amd64PackedSADSpec{
+	"PSADBW":    {kind: amd64PackedSADBlockSum, form: amd64PackedSADLegacyX},
+	"VPSADBW":   {kind: amd64PackedSADBlockSum, form: amd64PackedSADEVEXXYZ},
+	"MPSADBW":   {kind: amd64PackedSADMultiple, form: amd64PackedSADLegacyX},
+	"VMPSADBW":  {kind: amd64PackedSADMultiple, form: amd64PackedSADVEXXY},
+	"VDBPSADBW": {kind: amd64PackedSADDoubleBlock, form: amd64PackedSADEVEXXYZ},
+}
+
+// One ordered grammar governs both lowering and original-source effects.
+func (c *amd64Ctx) lowerPackedSumAbsoluteDifferences(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64PackedSADSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("packed SAD dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, _, err := x86PackedSADProperties(ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.constantZero(ins) {
+		if form.legacy {
+			return true, false, c.storeLegacyPackedLogical(destination, "zeroinitializer")
+		}
+		return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "zeroinitializer")
+	}
+	if form.legacy && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: %s m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext, ins.Op)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	b, err := c.loadPackedCompareBytes(second, form.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.legacy && form.memory >= 0 {
+		// Keep the precise legacy opcode/read/fault behavior. A separately
+		// synthesized align-1 or MOVDQA load is not an equivalent contract.
+		result, err = c.emitPackedSADNativeMemory(first, b, form)
+	} else {
+		a, loadErr := c.loadPackedUnpackSource(first, x86PackedUnpackForm{
+			x86PackedBinaryForm: form.x86PackedBinaryForm, spec: x86PackedUnpackSpec{laneBits: 8},
+		})
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		switch form.spec.kind {
+		case amd64PackedSADBlockSum:
+			result = c.emitPackedSumAbsoluteByteDifferences(form.byteWidth, a, b)
+		case amd64PackedSADMultiple:
+			result = c.emitMultipleSumAbsoluteDifferences(form.byteWidth, a, b, form.immediate)
+		case amd64PackedSADDoubleBlock:
+			words := c.emitDoubleBlockSumAbsoluteDifferences(form.byteWidth, b, a, form.immediate)
+			if form.mask >= 0 {
+				mask, loadErr := c.loadK(ins.Args[form.mask].Reg)
+				if loadErr != nil {
+					return true, false, loadErr
+				}
+				old := "zeroinitializer"
+				if !form.zeroing {
+					old, loadErr = c.loadPackedCompareLanes(destination, form.byteWidth, 16, false)
+					if loadErr != nil {
+						return true, false, loadErr
+					}
+				}
+				words = amd64ApplyIntegerLaneMask(c, form.byteWidth/2, 16, words, old, mask, form.zeroing)
+			}
+			bytes := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x i8>\n", bytes, form.byteWidth/2, words, form.byteWidth)
+			result = "%" + bytes
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, result)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, result)
+}
+
+func (c *amd64Ctx) emitPackedSADNativeMemory(source Operand, data string, form x86PackedSADForm) (string, error) {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	segment := ""
+	switch pointerType {
+	case "ptr addrspace(256)":
+		segment = "%gs:"
+	case "ptr addrspace(257)":
+		segment = "%fs:"
+	}
+	opcode := "psadbw "
+	if form.spec.kind == amd64PackedSADMultiple {
+		opcode = fmt.Sprintf("mpsadbw $$%d, ", form.immediate)
+	}
+	carrier, value, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", carrier, data)
+	fmt.Fprintf(c.b, "  %%%s = call <4 x i32> asm sideeffect %q, %q(<4 x i32> %%%s, %s %s)\n",
+		value, opcode+segment+"($2), $0", "=x,0,r,~{memory}", carrier, pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bytes, value)
+	return "%" + bytes, nil
+}
+
+func (c *amd64Ctx) emitDoubleBlockSumAbsoluteDifferences(byteWidth int, source1, source2 string, immediate uint8) string {
+	shuffled := "poison"
+	for laneBase := 0; laneBase < byteWidth; laneBase += 16 {
+		for destinationDWord := 0; destinationDWord < 4; destinationDWord++ {
+			sourceDWord := int(immediate>>(2*destinationDWord)) & 3
+			for byteInDWord := 0; byteInDWord < 4; byteInDWord++ {
+				sourceIndex := laneBase + sourceDWord*4 + byteInDWord
+				destinationIndex := laneBase + destinationDWord*4 + byteInDWord
+				value, inserted := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", value, byteWidth, source2, sourceIndex)
+				fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i8> %s, i8 %%%s, i32 %d\n", inserted, byteWidth, shuffled, value, destinationIndex)
+				shuffled = "%" + inserted
+			}
+		}
+	}
+
+	lanes := byteWidth / 2
+	result := "poison"
+	for blockBase := 0; blockBase < byteWidth; blockBase += 8 {
+		for outputInBlock := 0; outputInBlock < 4; outputInBlock++ {
+			source1Base := blockBase
+			if outputInBlock >= 2 {
+				source1Base += 4
+			}
+			tmpBase := blockBase + outputInBlock
+			sum := ""
+			for byteInDWord := 0; byteInDWord < 4; byteInDWord++ {
+				firstByte, secondByte := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", firstByte, byteWidth, source1, source1Base+byteInDWord)
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", secondByte, byteWidth, shuffled, tmpBase+byteInDWord)
+				firstWide, secondWide := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i16\n", firstWide, firstByte)
+				fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i16\n", secondWide, secondByte)
+				firstMinusSecond, secondMinusFirst, firstGreater, difference := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = sub i16 %%%s, %%%s\n", firstMinusSecond, firstWide, secondWide)
+				fmt.Fprintf(c.b, "  %%%s = sub i16 %%%s, %%%s\n", secondMinusFirst, secondWide, firstWide)
+				fmt.Fprintf(c.b, "  %%%s = icmp uge i16 %%%s, %%%s\n", firstGreater, firstWide, secondWide)
+				fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %%%s, i16 %%%s\n", difference, firstGreater, firstMinusSecond, secondMinusFirst)
+				if sum == "" {
+					sum = "%" + difference
+				} else {
+					added := c.newTmp()
+					fmt.Fprintf(c.b, "  %%%s = add i16 %s, %%%s\n", added, sum, difference)
+					sum = "%" + added
+				}
+			}
+			outputLane := blockBase/2 + outputInBlock
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i16> %s, i16 %s, i32 %d\n", inserted, lanes, result, sum, outputLane)
+			result = "%" + inserted
+		}
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitMultipleSumAbsoluteDifferences(byteWidth int, first, second string, immediate uint8) string {
+	intrinsic := "llvm.x86.sse41.mpsadbw"
+	lanes := 8
+	if byteWidth == 32 {
+		intrinsic = "llvm.x86.avx2.mpsadbw"
+		lanes = 16
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x i16> @%s(<%d x i8> %s, <%d x i8> %s, i8 %d)\n", result, lanes, intrinsic, byteWidth, second, byteWidth, first, immediate)
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %%%s to <%d x i8>\n", bytesValue, lanes, result, byteWidth)
+	return "%" + bytesValue
+}
+
+func (c *amd64Ctx) emitPackedSumAbsoluteByteDifferences(byteWidth int, first, second string) string {
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext <%d x i8> %s to <%d x i16>\n", firstWide, byteWidth, first, byteWidth)
+	fmt.Fprintf(c.b, "  %%%s = zext <%d x i8> %s to <%d x i16>\n", secondWide, byteWidth, second, byteWidth)
+	firstMinusSecond := c.newTmp()
+	secondMinusFirst := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub <%d x i16> %%%s, %%%s\n", firstMinusSecond, byteWidth, firstWide, secondWide)
+	fmt.Fprintf(c.b, "  %%%s = sub <%d x i16> %%%s, %%%s\n", secondMinusFirst, byteWidth, secondWide, firstWide)
+	firstGreater := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp uge <%d x i16> %%%s, %%%s\n", firstGreater, byteWidth, firstWide, secondWide)
+	differences := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i16> %%%s, <%d x i16> %%%s\n", differences, byteWidth, firstGreater, byteWidth, firstMinusSecond, byteWidth, secondMinusFirst)
+
+	groups := byteWidth / 8
+	result := "zeroinitializer"
+	for group := 0; group < groups; group++ {
+		sum := ""
+		for lane := group * 8; lane < (group+1)*8; lane++ {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i16> %%%s, i32 %d\n", value, byteWidth, differences, lane)
+			if sum == "" {
+				sum = "%" + value
+				continue
+			}
+			added := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i16 %s, %%%s\n", added, sum, value)
+			sum = "%" + added
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i16 %s to i64\n", wide, sum)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i64> %s, i64 %%%s, i32 %d\n", inserted, groups, result, wide, group)
+		result = "%" + inserted
+	}
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i64> %s to <%d x i8>\n", bytesValue, groups, result, byteWidth)
+	return "%" + bytesValue
+}
diff --git a/amd64_lower_scalar_float_to_int.go b/amd64_lower_scalar_float_to_int.go
new file mode 100644
index 000000000..a0e16e39a
--- /dev/null
+++ b/amd64_lower_scalar_float_to_int.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ScalarFloatToIntSpec struct {
+	inputBits  int
+	outputBits int
+	truncating bool
+	unsigned   bool
+	vector     bool
+}
+
+var amd64ScalarFloatToIntSpecs = map[Op]amd64ScalarFloatToIntSpec{
+	"CVTSS2SL":  {inputBits: 32, outputBits: 32},
+	"CVTSS2SQ":  {inputBits: 32, outputBits: 64},
+	"CVTSD2SL":  {inputBits: 64, outputBits: 32},
+	"CVTSD2SQ":  {inputBits: 64, outputBits: 64},
+	"CVTTSS2SL": {inputBits: 32, outputBits: 32, truncating: true},
+	"CVTTSS2SQ": {inputBits: 32, outputBits: 64, truncating: true},
+	"CVTTSD2SL": {inputBits: 64, outputBits: 32, truncating: true},
+	"CVTTSD2SQ": {inputBits: 64, outputBits: 64, truncating: true},
+
+	"VCVTSS2SI":   {inputBits: 32, outputBits: 32, vector: true},
+	"VCVTSS2SIQ":  {inputBits: 32, outputBits: 64, vector: true},
+	"VCVTSD2SI":   {inputBits: 64, outputBits: 32, vector: true},
+	"VCVTSD2SIQ":  {inputBits: 64, outputBits: 64, vector: true},
+	"VCVTTSS2SI":  {inputBits: 32, outputBits: 32, truncating: true, vector: true},
+	"VCVTTSS2SIQ": {inputBits: 32, outputBits: 64, truncating: true, vector: true},
+	"VCVTTSD2SI":  {inputBits: 64, outputBits: 32, truncating: true, vector: true},
+	"VCVTTSD2SIQ": {inputBits: 64, outputBits: 64, truncating: true, vector: true},
+
+	"VCVTSS2USIL":  {inputBits: 32, outputBits: 32, unsigned: true, vector: true},
+	"VCVTSS2USIQ":  {inputBits: 32, outputBits: 64, unsigned: true, vector: true},
+	"VCVTSD2USIL":  {inputBits: 64, outputBits: 32, unsigned: true, vector: true},
+	"VCVTSD2USIQ":  {inputBits: 64, outputBits: 64, unsigned: true, vector: true},
+	"VCVTTSS2USIL": {inputBits: 32, outputBits: 32, truncating: true, unsigned: true, vector: true},
+	"VCVTTSS2USIQ": {inputBits: 32, outputBits: 64, truncating: true, unsigned: true, vector: true},
+	"VCVTTSD2USIL": {inputBits: 64, outputBits: 32, truncating: true, unsigned: true, vector: true},
+	"VCVTTSD2USIQ": {inputBits: 64, outputBits: 64, truncating: true, unsigned: true, vector: true},
+}
+
+// lowerScalarFloatToInteger implements Go 1.27's complete signed legacy/VEX/
+// EVEX scalar float-to-integer family and its EVEX unsigned counterparts.
+func (c *amd64Ctx) lowerScalarFloatToInteger(rawOp Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(rawOp)), ".")
+	if _, known := amd64ScalarFloatToIntSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(rawOp), string(ins.Op)) {
+		return true, false, fmt.Errorf("scalar conversion dispatch/source mismatch: %s/%s", rawOp, ins.Op)
+	}
+	ins.Op = rawOp
+	f, known, err := x86ScalarFloatIntegerProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: scalar conversion lacks native MXCSR target", ErrProbeNeedsContext)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return true, false, fmt.Errorf("%w: scalar conversion needs its original native address size", ErrProbeNeedsContext)
+	}
+	return true, false, c.emitNativeScalarFloatInteger(ins, f)
+}
+
+func (c *amd64Ctx) evalScalarFloatForInteger(source Operand, bits int) (string, error) {
+	if bits == 32 {
+		return c.evalF32(source)
+	}
+	return c.evalF64(source)
+}
+
+func amd64FloatingTypeForBits(bits int) LLVMType {
+	if bits == 32 {
+		return LLVMType("float")
+	}
+	return LLVMType("double")
+}
diff --git a/amd64_lower_scalar_float_to_int_test.go b/amd64_lower_scalar_float_to_int_test.go
new file mode 100644
index 000000000..b1c73e752
--- /dev/null
+++ b/amd64_lower_scalar_float_to_int_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ScalarFloatToIntegerCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			xreg := "X16"
+			if target.goarch == "386" {
+				xreg = "X7" // A high named bank has no physical mode32 identity.
+			}
+			var source strings.Builder
+			source.WriteString("TEXT scalarfloattointforms(SB),NOSPLIT,$0-0\n")
+			for _, precision := range []string{"SS", "SD"} {
+				for _, truncating := range []bool{false, true} {
+					prefix := "CVT"
+					if truncating {
+						prefix = "CVTT"
+					}
+					for _, width := range []string{"L", "Q"} {
+						if target.goarch == "386" && width == "Q" {
+							continue
+						}
+						op := prefix + precision + "2S" + width
+						fmt.Fprintf(&source, "\t%s X0, AX\n", op)
+						fmt.Fprintf(&source, "\t%s 8(BX), DI\n", op)
+						vop := "V" + prefix + precision + "2SI"
+						if width == "Q" {
+							vop += "Q"
+						}
+						fmt.Fprintf(&source, "\t%s X0, AX\n", vop)
+						fmt.Fprintf(&source, "\t%s 16(BX), DI\n", vop)
+						if truncating {
+							fmt.Fprintf(&source, "\t%s.SAE %s, AX\n", vop, xreg)
+						} else {
+							for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+								fmt.Fprintf(&source, "\t%s.%s %s, AX\n", vop, rounding, xreg)
+							}
+						}
+					}
+				}
+				for _, truncating := range []bool{false, true} {
+					prefix := "VCVT"
+					if truncating {
+						prefix = "VCVTT"
+					}
+					for _, width := range []string{"L", "Q"} {
+						if target.goarch == "386" && width == "Q" {
+							continue
+						}
+						op := prefix + precision + "2USI" + width
+						fmt.Fprintf(&source, "\t%s %s, AX\n", op, xreg)
+						fmt.Fprintf(&source, "\t%s 24(BX), DI\n", op)
+						if truncating {
+							fmt.Fprintf(&source, "\t%s.SAE %s, AX\n", op, xreg)
+						} else {
+							for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+								fmt.Fprintf(&source, "\t%s.%s %s, AX\n", op, rounding, xreg)
+							}
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			// This complete original format inventory has no input producers.
+			// Preserve Go objects and three-API Context separately from the
+			// same lowerer's private, compile-only format transport.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "scalarfloattointforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalar-float-to-int-"+target.name+".ll", "scalar-float-to-int-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ScalarFloatToIntegerRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTSS2SL Y0, AX",
+		"CVTTSD2SQ X16, AX",
+		"CVTSS2SL X0, X1",
+		"CVTSS2SL.Z X0, AX",
+		"VCVTSS2SI Y0, AX",
+		"VCVTSS2SI X0, X1",
+		"VCVTSS2SI.SAE X0, AX",
+		"VCVTTSS2SI.RN_SAE X0, AX",
+		"VCVTSD2SI.RD_SAE 8(BX), AX",
+		"VCVTTSD2SI.SAE 8(BX), AX",
+		"VCVTSS2USIL X0, X1",
+		"VCVTSS2USIL.Z X0, AX",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ScalarFloatToIntegerRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"CVTSS2SQ X0, AX",
+		"CVTTSD2SQ 8(BX), AX",
+		"VCVTTSD2SIQ.SAE X16, AX",
+		"VCVTSS2USIQ X16, AX",
+		"VCVTTSD2USIQ.SAE X16, AX",
+		"CVTSS2SL X8, AX",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ScalarFloatToIntegerRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86ScalarFloatToIntegerRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's scalar float-to-integer tables for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_scalar_integer_float.go b/amd64_lower_scalar_integer_float.go
new file mode 100644
index 000000000..609f65f24
--- /dev/null
+++ b/amd64_lower_scalar_integer_float.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import "fmt"
+
+type amd64ScalarIntegerFloatSpec struct {
+	sourceBits int
+	resultBits int
+	unsigned   bool
+	rounding   bool
+}
+
+// Complete unsigned _yvcvtusi2sdl family. Signed legacy/VEX forms retain their
+// independent table. Supported-op extraction reads both registries.
+var amd64ScalarIntegerFloatOps = map[string]amd64ScalarIntegerFloatSpec{
+	"VCVTUSI2SDL": {sourceBits: 32, resultBits: 64, unsigned: true},
+	"VCVTUSI2SDQ": {sourceBits: 64, resultBits: 64, unsigned: true, rounding: true},
+	"VCVTUSI2SSL": {sourceBits: 32, resultBits: 32, unsigned: true, rounding: true},
+	"VCVTUSI2SSQ": {sourceBits: 64, resultBits: 32, unsigned: true, rounding: true},
+}
+
+func (c *amd64Ctx) lowerScalarIntegerToFloat(op Op, ins Instr) (bool, bool, error) {
+	if ok, term, err := c.lowerSignedIntegerScalarFloat(op, ins); ok {
+		return ok, term, err
+	}
+	return c.lowerUnsignedIntegerScalarFloat(op, ins)
+}
+
+// emitRoundedScalarIntegerToFloatBits converts through an explicit integer
+// significand so embedded rounding remains correct even when LLVM 22 lowers a
+// constrained conversion to an instruction controlled by the ambient MXCSR.
+func (c *amd64Ctx) emitRoundedScalarIntegerToFloatBits(integer string, spec amd64ScalarIntegerFloatSpec, rounding string) string {
+	integerType := amd64IntegerTypeForBits(spec.sourceBits)
+	precision := 24
+	bias := 127
+	if spec.resultBits == 64 {
+		precision = 53
+		bias = 1023
+	}
+
+	negative := "false"
+	magnitude := integer
+	if !spec.unsigned {
+		isNegative := c.newTmp()
+		negated := c.newTmp()
+		absolute := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", isNegative, integerType, integer)
+		fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", negated, integerType, integer)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %s\n", absolute, isNegative, integerType, negated, integerType, integer)
+		negative = "%" + isNegative
+		magnitude = "%" + absolute
+	}
+
+	isZero := c.newTmp()
+	safeMagnitude := c.newTmp()
+	leadingZeros := c.newTmp()
+	msb := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", isZero, integerType, magnitude)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s 1, %s %s\n", safeMagnitude, isZero, integerType, integerType, magnitude)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.ctlz.i%d(%s %%%s, i1 false)\n", leadingZeros, integerType, spec.sourceBits, integerType, safeMagnitude)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %d, %%%s\n", msb, integerType, spec.sourceBits-1, leadingZeros)
+
+	needsRightShift := c.newTmp()
+	rawRightShift := c.newTmp()
+	rightShift := c.newTmp()
+	rawLeftShift := c.newTmp()
+	leftShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp uge %s %%%s, %d\n", needsRightShift, integerType, msb, precision-1)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %d\n", rawRightShift, integerType, msb, precision-1)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s 0\n", rightShift, needsRightShift, integerType, rawRightShift, integerType)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %d, %%%s\n", rawLeftShift, integerType, precision-1, msb)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s 0, %s %%%s\n", leftShift, needsRightShift, integerType, integerType, rawLeftShift)
+
+	shiftedRight := c.newTmp()
+	shiftedLeft := c.newTmp()
+	significand := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", shiftedRight, integerType, magnitude, rightShift)
+	fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", shiftedLeft, integerType, magnitude, leftShift)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %%%s\n", significand, needsRightShift, integerType, shiftedRight, integerType, shiftedLeft)
+
+	oneAtShift := c.newTmp()
+	remainderMask := c.newTmp()
+	remainder := c.newTmp()
+	inexact := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s 1, %%%s\n", oneAtShift, integerType, rightShift)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, 1\n", remainderMask, integerType, oneAtShift)
+	fmt.Fprintf(c.b, "  %%%s = and %s %s, %%%s\n", remainder, integerType, magnitude, remainderMask)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, 0\n", inexact, integerType, remainder)
+
+	increment := "false"
+	switch rounding {
+	case "RN_SAE":
+		hasShift := c.newTmp()
+		rawHalfShift := c.newTmp()
+		halfShift := c.newTmp()
+		half := c.newTmp()
+		aboveHalf := c.newTmp()
+		equalHalf := c.newTmp()
+		lowBit := c.newTmp()
+		odd := c.newTmp()
+		tieAndOdd := c.newTmp()
+		roundNearest := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, 0\n", hasShift, integerType, rightShift)
+		fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, 1\n", rawHalfShift, integerType, rightShift)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s 0\n", halfShift, hasShift, integerType, rawHalfShift, integerType)
+		fmt.Fprintf(c.b, "  %%%s = shl %s 1, %%%s\n", half, integerType, halfShift)
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %%%s, %%%s\n", aboveHalf, integerType, remainder, half)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %%%s\n", equalHalf, integerType, remainder, half)
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, 1\n", lowBit, integerType, significand)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, 0\n", odd, integerType, lowBit)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", tieAndOdd, equalHalf, odd)
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", roundNearest, aboveHalf, tieAndOdd)
+		increment = "%" + roundNearest
+	case "RD_SAE":
+		if !spec.unsigned {
+			roundDown := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i1 %s, %%%s\n", roundDown, negative, inexact)
+			increment = "%" + roundDown
+		}
+	case "RU_SAE":
+		if spec.unsigned {
+			increment = "%" + inexact
+		} else {
+			positive := c.newTmp()
+			roundUp := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", positive, negative)
+			fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", roundUp, positive, inexact)
+			increment = "%" + roundUp
+		}
+	}
+
+	incrementInteger := c.newTmp()
+	roundedSignificand := c.newTmp()
+	overflow := c.newTmp()
+	normalizedOverflow := c.newTmp()
+	normalized := c.newTmp()
+	exponentIncrement := c.newTmp()
+	exponent := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to %s\n", incrementInteger, increment, integerType)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", roundedSignificand, integerType, significand, incrementInteger)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %d\n", overflow, integerType, roundedSignificand, uint64(1)<<precision)
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, 1\n", normalizedOverflow, integerType, roundedSignificand)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %%%s\n", normalized, overflow, integerType, normalizedOverflow, integerType, roundedSignificand)
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to %s\n", exponentIncrement, overflow, integerType)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", exponent, integerType, msb, exponentIncrement)
+
+	mantissa := c.newTmp()
+	biasedExponent := c.newTmp()
+	encodedExponent := c.newTmp()
+	encodedMagnitude := c.newTmp()
+	signWord := c.newTmp()
+	encoded := c.newTmp()
+	nonzeroBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", mantissa, integerType, normalized, (uint64(1)<<(precision-1))-1)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %d\n", biasedExponent, integerType, exponent, bias)
+	fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %d\n", encodedExponent, integerType, biasedExponent, precision-1)
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", encodedMagnitude, integerType, encodedExponent, mantissa)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %d, %s 0\n", signWord, negative, integerType, uint64(1)<<(spec.resultBits-1), integerType)
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", encoded, integerType, encodedMagnitude, signWord)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s 0, %s %%%s\n", nonzeroBits, isZero, integerType, integerType, encoded)
+	if spec.resultBits == spec.sourceBits {
+		return "%" + nonzeroBits
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i%d\n", result, integerType, nonzeroBits, spec.resultBits)
+	return "%" + result
+}
diff --git a/amd64_lower_scalar_integer_float_test.go b/amd64_lower_scalar_integer_float_test.go
new file mode 100644
index 000000000..3b796cf28
--- /dev/null
+++ b/amd64_lower_scalar_integer_float_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86ScalarIntegerFloatTestSpec struct {
+	op       string
+	rounding bool
+}
+
+func go127X86ScalarIntegerFloatSpecs() []x86ScalarIntegerFloatTestSpec {
+	return []x86ScalarIntegerFloatTestSpec{
+		{op: "VCVTSI2SDL"},
+		{op: "VCVTSI2SDQ", rounding: true},
+		{op: "VCVTSI2SSL", rounding: true},
+		{op: "VCVTSI2SSQ", rounding: true},
+		{op: "VCVTUSI2SDL"},
+		{op: "VCVTUSI2SDQ", rounding: true},
+		{op: "VCVTUSI2SSL", rounding: true},
+		{op: "VCVTUSI2SSQ", rounding: true},
+	}
+}
+
+func TestTranslateX86ScalarIntegerFloatCompleteGo127Forms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT scalarintegerfloatforms(SB),$0-0\n")
+			for _, spec := range go127X86ScalarIntegerFloatSpecs() {
+				fmt.Fprintf(&source, "\t%s AX, X0, X1\n", spec.op)
+				fmt.Fprintf(&source, "\t%s 8(BX), X2, X3\n", spec.op)
+				upper, destination := "X29", "X30"
+				if target.goarch == "386" {
+					upper, destination = "X5", "X6"
+				}
+				fmt.Fprintf(&source, "\t%s CX, %s, %s\n", spec.op, upper, destination)
+				if spec.rounding {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						fmt.Fprintf(&source, "\t%s.%s DX, %s, %s\n", spec.op, rounding, destination, destination)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+
+			// Retain every original Go row and complete source verbatim. A
+			// format carrier has neither initialized GP/vector inputs nor a
+			// native address; it is not an initialized public translation.
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			ll := x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalar-integer-float-"+target.name+".ll", "scalar-integer-float-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ScalarIntegerFloatRejectsFormsOutsideGo127Tables(t *testing.T) {
+	for _, instruction := range []string{
+		"VCVTSI2SDL AX, X1",
+		"VCVTSI2SDQ AX, X0, X1, X2",
+		"VCVTSI2SSL $1, X0, X1",
+		"VCVTSI2SSQ X0, X1, X2",
+		"VCVTUSI2SDL AX, Y0, X1",
+		"VCVTUSI2SDQ AX, X0, Y1",
+		"VCVTUSI2SSL AX, X0, K1, X1",
+		"VCVTUSI2SSQ.Z AX, X0, X1",
+		"VCVTSI2SDL.RN_SAE AX, X0, X1",
+		"VCVTUSI2SDL.RD_SAE AX, X0, X1",
+		"VCVTSI2SDQ.SAE AX, X0, X1",
+		"VCVTUSI2SSQ.BCST 8(BX), X0, X1",
+		"VCVTSI2SSL.RN_SAE 8(BX), X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			assertX86ScalarIntegerFloatRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\tVCVTSI2SDQ R8, X0, X1\n\tRET\n", false)
+	assertX86ScalarIntegerFloatRejected(t, "386", "i386-unknown-linux-gnu", "VCVTSI2SDQ R8, X0, X1")
+}
+
+func assertX86ScalarIntegerFloatRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's scalar integer-to-float tables for %s", instruction, goarch)
+	}
+}
+
+func qualifyAMD64ScalarIntegerFloatRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT scalarintegerfloat(SB),NOSPLIT,$0-56
+	MOVQ out+0(FP), AX
+	MOVQ signed32+8(FP), BX
+	MOVQ signed64+16(FP), CX
+	MOVQ unsigned32+24(FP), DX
+	MOVQ unsigned64+32(FP), SI
+	MOVQ passthrough32+40(FP), DI
+	MOVQ passthrough64+48(FP), R8
+	MOVQ (CX), R9
+	MOVL (BX), R10
+	MOVQ (SI), R11
+	MOVL (DX), R12
+
+	VMOVUPD (R8), X0
+	VCVTSI2SDL (BX), X0, X1
+	VMOVUPD X1, 0(AX)
+	VCVTSI2SDQ.RN_SAE R9, X0, X1
+	VMOVUPD X1, 16(AX)
+
+	VMOVUPS (DI), X0
+	VCVTSI2SSL.RD_SAE R10, X0, X1
+	VMOVUPS X1, 32(AX)
+	VCVTSI2SSQ.RU_SAE R9, X0, X1
+	VMOVUPS X1, 48(AX)
+
+	VMOVUPD (R8), X0
+	VCVTUSI2SDL (DX), X0, X1
+	VMOVUPD X1, 64(AX)
+	VCVTUSI2SDQ.RZ_SAE R11, X0, X1
+	VMOVUPD X1, 80(AX)
+
+	VMOVUPS (DI), X0
+	VCVTUSI2SSL.RD_SAE R12, X0, X1
+	VMOVUPS X1, 96(AX)
+	VCVTUSI2SSQ.RN_SAE R11, X0, X1
+	VMOVUPS X1, 112(AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+		{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	x86OriginalFloatingRuntimeRequireCPU(t, "unsigned-scalar-integer", clang, triple, runPrefix)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"scalarintegerfloat": {Name: "scalarintegerfloat", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+extern void scalarintegerfloat(uint8_t *, const int32_t *, const int64_t *, const uint32_t *, const uint64_t *, const float *, const double *);
+int main(void) {
+  const int32_t signed32 = -16777217;
+  const int64_t signed64 = -16777217;
+  const uint32_t unsigned32 = UINT32_MAX;
+  const uint64_t unsigned64 = UINT64_MAX;
+  const float passthrough32[4] = {200.0f, 201.0f, 202.0f, 203.0f};
+  const double passthrough64[2] = {100.0, 101.0};
+  union { uint8_t bytes[128]; double d64[16]; float f32[32]; } out = {0};
+  scalarintegerfloat(out.bytes, &signed32, &signed64, &unsigned32, &unsigned64, passthrough32, passthrough64);
+  if (out.d64[0] != -16777217.0 || out.d64[1] != 101.0) return 1;
+  if (out.d64[2] != -16777217.0 || out.d64[3] != 101.0) return 2;
+  if (out.f32[8] != -16777218.0f || out.f32[9] != 201.0f || out.f32[10] != 202.0f || out.f32[11] != 203.0f) return 3;
+  if (out.f32[12] != -16777216.0f || out.f32[13] != 201.0f || out.f32[14] != 202.0f || out.f32[15] != 203.0f) return 4;
+  if (out.d64[8] != 4294967295.0 || out.d64[9] != 101.0) return 5;
+  if (out.d64[10] != 18446744073709549568.0 || out.d64[11] != 101.0) return 6;
+  if (out.f32[24] != 4294967040.0f || out.f32[25] != 201.0f || out.f32[26] != 202.0f || out.f32[27] != 203.0f) {
+    fprintf(stderr, "unsigned32 RD result=%a upper={%a,%a,%a}\n", out.f32[24], out.f32[25], out.f32[26], out.f32[27]);
+    return 7;
+  }
+  if (out.f32[28] != 18446744073709551616.0f || out.f32[29] != 201.0f || out.f32[30] != 202.0f || out.f32[31] != 203.0f) return 8;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_integer_float", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_scalar_precision.go b/amd64_lower_scalar_precision.go
new file mode 100644
index 000000000..152a1e3b3
--- /dev/null
+++ b/amd64_lower_scalar_precision.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerScalarPrecisionConvert(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86ScalarPrecisionProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ins.Op = op
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: %s needs its native x86 MXCSR target, not pure LLVM precision arithmetic", ErrProbeNeedsContext, op)
+	}
+	if form.memory >= 0 {
+		memory := x86PackedBinaryForm{memory: 0, memoryBytes: form.memoryBytes}
+		if err := c.validateConflictFunnelMemory(ins, memory); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, c.emitScalarPrecisionConvert(ins, form)
+}
+
+// Keep the original conversion, rather than ambient pure fpext/fptrunc:
+// DAZ/FTZ, RC, status, unmasked exceptions and explicit ER/SAE are hardware
+// effects. The memory operand remains on that same instruction, so native
+// E3 suppression and exact m32/m64 faults survive dead-value elimination.
+func (c *amd64Ctx) emitScalarPrecisionConvert(ins Instr, form x86ScalarPrecisionForm) error {
+	const typ = "<4 x float>" // Bit-preserving 128-bit carrier, never arithmetic precision.
+	load := func(index int) (string, error) {
+		return c.loadFloatingVectorOperand(ins.Args[index], 16, 4, 32)
+	}
+	old := "zeroinitializer"
+	var err error
+	if form.legacy || form.mask >= 0 && !form.zeroing {
+		old, err = load(form.destination)
+		if err != nil {
+			return err
+		}
+	}
+	evex := x86ScalarPrecisionNativeEVEX(ins, form)
+	register := "x"
+	if evex {
+		register = "v"
+	}
+	value, inputType, inputConstraint, err := c.scalarPrecisionNativeSource(ins.Args[0], form.spec.inputBits, register)
+	if err != nil {
+		return err
+	}
+	constraints, args := "="+register+",0", typ+" "+old
+	inputIndex := 2
+	operands := "$2, $0"
+	if !form.legacy {
+		upper, err := load(form.second)
+		if err != nil {
+			return err
+		}
+		constraints += "," + register
+		args += ", " + typ + " " + upper
+		inputIndex, operands = 3, "$3, $2, $0"
+	}
+	constraints += "," + inputConstraint
+	args += ", " + inputType + " " + value
+	mnemonic, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	if evex {
+		mnemonic = "{evex} " + mnemonic
+	}
+	assembly := mnemonic + " "
+	if form.sae {
+		assembly += "{sae}, "
+	} else if form.rounding != "" {
+		assembly += "{" + strings.ToLower(strings.TrimSuffix(form.rounding, "_SAE")) + "-sae}, "
+	}
+	assembly += operands
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+		assembly = fmt.Sprintf("kmovw ${%d:k}, %%k1; ", inputIndex+1) + assembly + " {%k1}"
+		if form.zeroing {
+			assembly += " {z}"
+		}
+		constraints += ",r,~{k1}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, typ, result)
+	if form.legacy {
+		return c.storeLegacyXViews(ins.Args[form.destination].Reg, "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[form.destination], 16, "%"+bytes)
+}
+
+func (c *amd64Ctx) scalarPrecisionNativeSource(source Operand, bits int, register string) (value, typ, constraint string, err error) {
+	const carrier = "<4 x float>"
+	if source.Kind == OpReg {
+		value, err = c.loadFloatingVectorOperand(source, 16, 4, 32)
+		return value, carrier, register, err
+	}
+	if source.Kind == OpFP {
+		value, err = c.loadScalarLaneFPBits(source.FPOffset, bits)
+		if err != nil {
+			return "", "", "", err
+		}
+		lanes := 128 / bits
+		inserted, converted := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n", inserted, lanes, bits, bits, value)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to %s\n", converted, lanes, bits, inserted, carrier)
+		return "%" + converted, carrier, register, nil
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	return pointer, fmt.Sprintf("%s elementtype([%d x i8])", pointerType, bits/8), "*m", err
+}
diff --git a/amd64_lower_scaled_round.go b/amd64_lower_scaled_round.go
new file mode 100644
index 000000000..34a08e824
--- /dev/null
+++ b/amd64_lower_scaled_round.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ScaledRoundMode uint8
+
+const (
+	amd64RoundScale amd64ScaledRoundMode = iota
+	amd64Reduce
+)
+
+type amd64ScaledRoundSpec struct {
+	laneBits int
+	scalar   bool
+	mode     amd64ScaledRoundMode
+}
+
+var amd64ScaledRoundSpecs = map[Op]amd64ScaledRoundSpec{
+	"VRNDSCALEPS": {laneBits: 32},
+	"VRNDSCALEPD": {laneBits: 64},
+	"VRNDSCALESS": {laneBits: 32, scalar: true},
+	"VRNDSCALESD": {laneBits: 64, scalar: true},
+	"VREDUCEPS":   {laneBits: 32, mode: amd64Reduce},
+	"VREDUCEPD":   {laneBits: 64, mode: amd64Reduce},
+	"VREDUCESS":   {laneBits: 32, scalar: true, mode: amd64Reduce},
+	"VREDUCESD":   {laneBits: 64, scalar: true, mode: amd64Reduce},
+}
+
+func (c *amd64Ctx) lowerScaledRound(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp, suffix := rawOp, ""
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp, suffix = rawOp[:dot], rawOp[dot+1:]
+	}
+	spec, recognized := amd64ScaledRoundSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return c.lowerNativeFloatingHelper(op, ins)
+	}
+	shape := amd64UnaryImmediateFloatingShape{laneBits: spec.laneBits, scalar: spec.scalar}
+	form, err := c.parseUnaryImmediateFloatingForm(baseOp, suffix, shape, ins)
+	if err != nil {
+		return true, false, err
+	}
+	mxcsr := c.loadMXCSR()
+	dazBits, daz := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 64\n", dazBits, mxcsr)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", daz, dazBits)
+	roundingMode := fmt.Sprintf("%d", form.immediate&3)
+	if form.immediate&4 != 0 {
+		shifted, extracted := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, 13\n", shifted, mxcsr)
+		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 3\n", extracted, shifted)
+		roundingMode = "%" + extracted
+	}
+	if spec.scalar {
+		return c.lowerScalarScaledRound(spec, form.properties, form.source, form.passthrough, form.destination, form.mask, "%"+daz, roundingMode, form.immediate)
+	}
+	return c.lowerPackedScaledRound(spec, form.properties, form.source, form.destination, form.byteWidth, form.mask, "%"+daz, roundingMode, form.immediate)
+}
+
+func (c *amd64Ctx) lowerPackedScaledRound(spec amd64ScaledRoundSpec, properties amd64BinaryFloatingSuffix, source, destination Operand, byteWidth int, mask, daz, roundingMode string, immediate uint8) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	input, err := c.loadPackedCompareLanes(source, byteWidth, spec.laneBits, properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitScaledRoundBits(lanes, spec.laneBits, input, daz, roundingMode, immediate>>4, spec.mode)
+	if mask != "" {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarScaledRound(spec amd64ScaledRoundSpec, properties amd64BinaryFloatingSuffix, source, passthrough, destination Operand, mask, daz, roundingMode string, immediate uint8) (bool, bool, error) {
+	sourceBits, err := c.loadFloatingScalarBits(source, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	input := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", input, spec.laneBits, spec.laneBits, sourceBits)
+	result := c.emitScaledRoundBits(1, spec.laneBits, "%"+input, daz, roundingMode, immediate>>4, spec.mode)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	passthroughBytes, err := c.loadX(passthrough.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, passthroughBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+low, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) emitScaledRoundBits(lanes, laneBits int, input, daz, roundingMode string, scale uint8, mode amd64ScaledRoundMode) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	mantissaBits, bias := 23, 127
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	signBit := uint64(0x80000000)
+	if laneBits == 64 {
+		mantissaBits, bias = 52, 1023
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+		signBit = uint64(0x8000000000000000)
+	}
+	implicitBit := uint64(1) << mantissaBits
+	alreadyThreshold := bias + mantissaBits - int(scale)
+	regularThreshold := bias - int(scale)
+	stepBits := uint64(bias-int(scale)) << mantissaBits
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		bits, exponent, mantissa, sign := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", bits, vectorType, input, lane)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", exponent, laneBits, bits, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", mantissa, laneBits, bits, mantissaMask)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", sign, laneBits, bits, signBit)
+		exponentZero, exponentOnes, mantissaZero := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", exponentZero, laneBits, exponent)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", exponentOnes, laneBits, exponent, exponentMask)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", mantissaZero, laneBits, mantissa)
+		mantissaNonzero, negative := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", mantissaNonzero, mantissaZero)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", negative, laneBits, sign)
+		isNaN, isInfinity := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isNaN, exponentOnes, mantissaNonzero)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isInfinity, exponentOnes, mantissaZero)
+		effectiveZeroPart, effectiveZero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %s\n", effectiveZeroPart, mantissaZero, daz)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", effectiveZero, exponentZero, effectiveZeroPart)
+
+		exponentField := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %d\n", exponentField, laneBits, exponent, mantissaBits)
+		already, regularLower, regularUpper, regular := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp uge i%d %%%s, %d\n", already, laneBits, exponentField, alreadyThreshold)
+		fmt.Fprintf(c.b, "  %%%s = icmp uge i%d %%%s, %d\n", regularLower, laneBits, exponentField, regularThreshold)
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i%d %%%s, %d\n", regularUpper, laneBits, exponentField, alreadyThreshold)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", regular, regularLower, regularUpper)
+		half := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %d\n", half, laneBits, exponentField, regularThreshold-1)
+
+		safeExponent, drop := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %d\n", safeExponent, regular, laneBits, exponentField, laneBits, alreadyThreshold-1)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %d, %%%s\n", drop, laneBits, mantissaBits+bias-int(scale), safeExponent)
+		significand := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", significand, laneBits, mantissa, implicitBit)
+		quotient, oneAtDrop, remainderMask, remainder := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %%%s\n", quotient, laneBits, significand, drop)
+		fmt.Fprintf(c.b, "  %%%s = shl i%d 1, %%%s\n", oneAtDrop, laneBits, drop)
+		fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, 1\n", remainderMask, laneBits, oneAtDrop)
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %%%s\n", remainder, laneBits, significand, remainderMask)
+		halfRemainder, aboveHalf, equalHalf := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, 1\n", halfRemainder, laneBits, oneAtDrop)
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt i%d %%%s, %%%s\n", aboveHalf, laneBits, remainder, halfRemainder)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %%%s\n", equalHalf, laneBits, remainder, halfRemainder)
+		quotientOddValue, quotientOdd, tiedOdd := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, 1\n", quotientOddValue, laneBits, quotient)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", quotientOdd, laneBits, quotientOddValue)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", tiedOdd, equalHalf, quotientOdd)
+		nearestRegular := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", nearestRegular, aboveHalf, tiedOdd)
+		remainderNonzero := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", remainderNonzero, laneBits, remainder)
+		incrementRegular := c.emitScaledRoundIncrement(roundingMode, "%"+negative, "%"+remainderNonzero, "%"+nearestRegular)
+		incrementValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i%d\n", incrementValue, incrementRegular, laneBits)
+		roundedQuotient, roundedSignificand := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i%d %%%s, %%%s\n", roundedQuotient, laneBits, quotient, incrementValue)
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %%%s, %%%s\n", roundedSignificand, laneBits, roundedQuotient, drop)
+		carryValue, carry, carryInteger := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", carryValue, laneBits, roundedSignificand, implicitBit<<1)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", carry, laneBits, carryValue)
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i%d\n", carryInteger, carry, laneBits)
+		roundedExponentField, roundedExponent := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i%d %%%s, %%%s\n", roundedExponentField, laneBits, exponentField, carryInteger)
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %%%s, %d\n", roundedExponent, laneBits, roundedExponentField, mantissaBits)
+		roundedFraction, roundedMagnitude, roundedRegular := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", roundedFraction, laneBits, roundedSignificand, mantissaMask)
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %%%s\n", roundedMagnitude, laneBits, roundedExponent, roundedFraction)
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %%%s\n", roundedRegular, laneBits, roundedMagnitude, sign)
+
+		halfAbove := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt i%d %%%s, %d\n", halfAbove, laneBits, significand, implicitBit)
+		nonzero := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", nonzero, effectiveZero)
+		incrementHalf := c.emitScaledRoundIncrement(roundingMode, "%"+negative, "%"+nonzero, "%"+halfAbove)
+		incrementSmall := c.emitScaledRoundIncrement(roundingMode, "%"+negative, "%"+nonzero, "false")
+		incrementNonRegular := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %s, i1 %s\n", incrementNonRegular, half, incrementHalf, incrementSmall)
+		signedStep, stepOrZero := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", signedStep, laneBits, sign, stepBits)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", stepOrZero, incrementNonRegular, laneBits, signedStep, laneBits, sign)
+		roundedNeeded, roundedFinite, zeroAdjusted := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", roundedNeeded, regular, laneBits, roundedRegular, laneBits, stepOrZero)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", roundedFinite, already, laneBits, bits, laneBits, roundedNeeded)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", zeroAdjusted, effectiveZero, laneBits, sign, laneBits, roundedFinite)
+		withInfinity := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", withInfinity, isInfinity, laneBits, bits, laneBits, zeroAdjusted)
+		quietNaN := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %d\n", quietNaN, laneBits, bits, quietBit)
+		roundedFinal := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", roundedFinal, isNaN, laneBits, quietNaN, laneBits, withInfinity)
+		laneResult := "%" + roundedFinal
+		if mode == amd64Reduce {
+			effectiveSource := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", effectiveSource, effectiveZero, laneBits, sign, laneBits, bits)
+			laneResult = c.emitReduceResult(laneBits, "%"+effectiveSource, "%"+zeroAdjusted, "%"+isNaN, "%"+isInfinity, roundingMode, quietBit, signBit)
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, result, laneBits, laneResult, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) emitScaledRoundIncrement(roundingMode, negative, nonzero, nearest string) string {
+	isNearest, isDown, isUp := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", isNearest, roundingMode)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 1\n", isDown, roundingMode)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 2\n", isUp, roundingMode)
+	nearestIncrement, downIncrement := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %s\n", nearestIncrement, isNearest, nearest)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %s, %s\n", downIncrement, negative, nonzero)
+	downSelected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", downSelected, isDown, downIncrement)
+	nonnegative, upIncrement, upSelected := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", nonnegative, negative)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %s\n", upIncrement, nonnegative, nonzero)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", upSelected, isUp, upIncrement)
+	combined, result := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", combined, nearestIncrement, downSelected)
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", result, combined, upSelected)
+	return "%" + result
+}
+
+func (c *amd64Ctx) emitReduceResult(laneBits int, sourceBits, finiteRoundedBits, isNaN, isInfinity, roundingMode string, quietBit, signBit uint64) string {
+	floatType := "float"
+	if laneBits == 64 {
+		floatType = "double"
+	}
+	special := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", special, isNaN, isInfinity)
+	safeSourceBits, safeRoundedBits := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 0, i%d %s\n", safeSourceBits, special, laneBits, laneBits, sourceBits)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 0, i%d %s\n", safeRoundedBits, special, laneBits, laneBits, finiteRoundedBits)
+	sourceFloat, roundedFloat := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %%%s to %s\n", sourceFloat, laneBits, safeSourceBits, floatType)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %%%s to %s\n", roundedFloat, laneBits, safeRoundedBits, floatType)
+	reducedFloat, reducedBits := c.newTmp(), c.newTmp()
+	// REDUCE's final subtraction obeys the selected immediate/MXCSR RC too.
+	// Its source has already undergone DAZ preprocessing; the exact helper
+	// must not apply the host's ambient rounding or flush its tiny result.
+	fmt.Fprintf(c.b, "  %%%s = call %s @__plan9asm_add_sub_round_f%d(%s %%%s, %s %%%s, i1 true, i32 %s, i32 0)\n", reducedFloat, floatType, laneBits, floatType, sourceFloat, floatType, roundedFloat, roundingMode)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to i%d\n", reducedBits, floatType, reducedFloat, laneBits)
+	reducedMagnitude, reducedZero := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", reducedMagnitude, laneBits, reducedBits, signBit-1)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", reducedZero, laneBits, reducedMagnitude)
+	isDown := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 1\n", isDown, roundingMode)
+	zeroBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %d, i%d 0\n", zeroBits, isDown, laneBits, signBit, laneBits)
+	zeroAdjusted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", zeroAdjusted, reducedZero, laneBits, zeroBits, laneBits, reducedBits)
+	withInfinity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d 0, i%d %%%s\n", withInfinity, isInfinity, laneBits, laneBits, zeroAdjusted)
+	quietNaNBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %d\n", quietNaNBits, laneBits, sourceBits, quietBit)
+	final := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", final, isNaN, laneBits, quietNaNBits, laneBits, withInfinity)
+	return "%" + final
+}
diff --git a/amd64_lower_scaled_round_test.go b/amd64_lower_scaled_round_test.go
new file mode 100644
index 000000000..ed6397cd4
--- /dev/null
+++ b/amd64_lower_scaled_round_test.go
@@ -0,0 +1,321 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateAMD64ScaledRoundRepresentativeForms(t *testing.T) {
+	const source = `TEXT scaledroundforms(SB),$0-0
+	VREDUCEPS $3, Z1, K2, Z3
+	VRNDSCALESD $20, X4, X5, K6, X7
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	ir := x86FloatingHelperOriginalFormatObject(t, source, "scaledroundforms", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "round-representative.ll", "round-representative.o", ir)
+}
+
+func TestAMD64ScaledRoundGrammarCoversCompleteGoFamilies(t *testing.T) {
+	expected := map[Op]amd64ScaledRoundSpec{
+		"VRNDSCALEPS": {laneBits: 32},
+		"VRNDSCALEPD": {laneBits: 64},
+		"VRNDSCALESS": {laneBits: 32, scalar: true},
+		"VRNDSCALESD": {laneBits: 64, scalar: true},
+		"VREDUCEPS":   {laneBits: 32, mode: amd64Reduce},
+		"VREDUCEPD":   {laneBits: 64, mode: amd64Reduce},
+		"VREDUCESS":   {laneBits: 32, scalar: true, mode: amd64Reduce},
+		"VREDUCESD":   {laneBits: 64, scalar: true, mode: amd64Reduce},
+	}
+	if len(amd64ScaledRoundSpecs) != len(expected) {
+		t.Fatalf("scaled-round grammar has %d entries, want %d", len(amd64ScaledRoundSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64ScaledRoundSpecs[op]; !ok {
+			t.Errorf("scaled-round grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("scaled-round grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86ScaledRoundCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT scaledroundallforms(SB),$0-0\n")
+			for _, op := range []string{"VRNDSCALEPS", "VRNDSCALEPD", "VREDUCEPS", "VREDUCEPD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" && width == "Z" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s $0, %s1, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s $255, 8(AX), %s%d\n", op, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST $1, 16(AX), %s%d\n", op, width, last)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s $2, %s1, K1, %s%d\n", op, width, width, last)
+						fmt.Fprintf(&source, "\t%s.Z $3, 24(AX), K2, %s%d\n", op, width, last)
+						fmt.Fprintf(&source, "\t%s.BCST.Z $4, 32(AX), K3, %s%d\n", op, width, last)
+					}
+					if width == "Z" {
+						fmt.Fprintf(&source, "\t%s.SAE $5, Z1, Z%d\n", op, last)
+						if target.goarch == "amd64" {
+							fmt.Fprintf(&source, "\t%s.SAE.Z $6, Z1, K4, Z%d\n", op, last)
+						}
+					}
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, op := range []string{"VRNDSCALESS", "VRNDSCALESD", "VREDUCESS", "VREDUCESD"} {
+					fmt.Fprintf(&source, "\t%s $0, X1, X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s $255, 40(AX), X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.SAE $1, X1, X2, X31\n", op)
+					fmt.Fprintf(&source, "\t%s $2, X1, X2, K5, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.Z $3, 48(AX), X2, K6, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.SAE.Z $4, X1, X2, K7, X31\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "scaledroundallforms", target.goarch, target.triple)
+			if ir == "" {
+				return // Go/public-Context coverage, not an LLVM object claim.
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scaled-round-"+target.name+".ll", "scaled-round-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ScaledRoundRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VREDUCEPS $-1, X0, X1"},
+		{goarch: "amd64", instruction: "VRNDSCALEPD $256, X0, X1"},
+		{goarch: "amd64", instruction: "VREDUCEPS X0, X1"},
+		{goarch: "amd64", instruction: "VRNDSCALEPS $0, X0, Y1"},
+		{goarch: "amd64", instruction: "VREDUCEPS.BCST $0, X0, X1"},
+		{goarch: "amd64", instruction: "VRNDSCALEPS.SAE $0, Z0, X1"},
+		{goarch: "amd64", instruction: "VREDUCEPD.SAE $0, 0(AX), Z1"},
+		{goarch: "amd64", instruction: "VRNDSCALEPS.RN_SAE $0, Z0, Z1"},
+		{goarch: "amd64", instruction: "VREDUCEPS.Z $0, X0, X1"},
+		{goarch: "amd64", instruction: "VRNDSCALEPS $0, X0, K0, X1"},
+		{goarch: "amd64", instruction: "VREDUCESS $0, Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VRNDSCALESD.BCST $0, 0(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VREDUCESD $0, X0, X1, Y2"},
+		{goarch: "386", instruction: "VRNDSCALESS $0, X0, X1, X2"},
+		{goarch: "386", instruction: "VREDUCEPS $0, X0, K1, X2"},
+		{goarch: "386", instruction: "VRNDSCALEPS $0, Z8, Z0"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scaled-round tables", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64ScaledRoundRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	var source strings.Builder
+	source.WriteString(`TEXT scaledroundsemantics(SB),$0-56
+	MOVQ out+0(FP), AX
+	MOVQ source32+8(FP), BX
+	MOVQ source64+16(FP), CX
+	MOVQ old32+24(FP), DX
+	MOVQ old64+32(FP), R8
+	MOVQ upper+40(FP), R9
+	MOVQ mask+48(FP), R10
+	KMOVQ R10, K1
+	VMOVDQU64 0(R9), X4
+	STC
+`)
+	for scale := 0; scale < 16; scale++ {
+		for rounding := 0; rounding < 4; rounding++ {
+			index := scale*4 + rounding
+			immediate := scale<<4 | rounding
+			fmt.Fprintf(&source, "\tVRNDSCALESS $%d, %d(BX), X4, X5\n", immediate, index%16*4)
+			fmt.Fprintf(&source, "\tVMOVSS X5, %d(AX)\n", index*4)
+			fmt.Fprintf(&source, "\tVREDUCESS $%d, %d(BX), X4, X5\n", immediate, index%16*4)
+			fmt.Fprintf(&source, "\tVMOVSS X5, %d(AX)\n", 256+index*4)
+			fmt.Fprintf(&source, "\tVRNDSCALESD $%d, %d(CX), X4, X5\n", immediate, index%16*8)
+			fmt.Fprintf(&source, "\tVMOVSD X5, %d(AX)\n", 512+index*8)
+			fmt.Fprintf(&source, "\tVREDUCESD $%d, %d(CX), X4, X5\n", immediate, index%16*8)
+			fmt.Fprintf(&source, "\tVMOVSD X5, %d(AX)\n", 1024+index*8)
+		}
+	}
+	source.WriteString(`	VMOVDQU32 0(DX), Z2
+	VRNDSCALEPS $35, 0(BX), K1, Z2
+	VMOVDQU32 Z2, 1536(AX)
+	VREDUCEPS.Z $35, 0(BX), K1, Z2
+	VMOVDQU32 Z2, 1600(AX)
+	VRNDSCALEPS.BCST $35, 0(BX), Z2
+	VMOVDQU32 Z2, 1664(AX)
+	VMOVDQU64 0(R8), Z3
+	VRNDSCALEPD $35, 0(CX), K1, Z3
+	VMOVDQU64 Z3, 1728(AX)
+	VREDUCEPD.Z $35, 0(CX), K1, Z3
+	VMOVDQU64 Z3, 1792(AX)
+	VRNDSCALEPD.BCST $35, 0(CX), Z3
+	VMOVDQU64 Z3, 1856(AX)
+	VRNDSCALESS $0, 0(BX), X4, X5
+	VMOVDQU64 X5, 1920(AX)
+	VREDUCESD $0, 0(CX), X4, X6
+	VMOVDQU64 X6, 1936(AX)
+	VRNDSCALESS $36, 0(BX), X4, X5
+	VMOVSS X5, 1952(AX)
+	VREDUCESS $36, 8(BX), X4, X5
+	VMOVSS X5, 1956(AX)
+	VRNDSCALESD $36, 0(CX), X4, X5
+	VMOVSD X5, 1960(AX)
+	VREDUCESD $36, 16(CX), X4, X5
+	VMOVSD X5, 1968(AX)
+	SETCS 1976(AX)
+	RET
+`)
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"scaledroundsemantics": {
+			Name: "scaledroundsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: I64, Index: 6, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void scaledroundsemantics(uint8_t *, const uint32_t *, const uint64_t *, const uint32_t *, const uint64_t *, const uint64_t *, uint64_t);
+static int inc(unsigned rc,int neg,int nonzero,int nearest) { return rc==0?nearest:(rc==1?neg&&nonzero:(rc==2?!neg&&nonzero:0)); }
+static uint32_t round32(uint32_t u,unsigned scale,unsigned rc,int daz) {
+  const uint32_t em=0x7f800000,fm=0x007fffff,qb=0x00400000,sb=0x80000000,ib=0x00800000;
+  uint32_t e=(u&em)>>23,f=u&fm,s=u&sb; if(e==255) return f?(u|qb):u;
+  if(e==0&&(f==0||daz)) return s;
+  unsigned already=127+23-scale, regular=127-scale;
+  if(e>=already) return u;
+  uint32_t sig=f|ib;
+  if(e>=regular) { unsigned drop=23+127-scale-e; uint32_t q=sig>>drop, rem=sig&((UINT32_C(1)<<drop)-1), half=UINT32_C(1)<<(drop-1); int n=rem>half||(rem==half&&(q&1)); q+=(uint32_t)inc(rc,s!=0,rem!=0,n); uint32_t rs=q<<drop, carry=(rs&(ib<<1))!=0; return s|((e+carry)<<23)|(rs&fm); }
+  int half=e==regular-1, n=half&&sig>ib; return s|(inc(rc,s!=0,1,n)?((127-scale)<<23):0);
+}
+static uint64_t round64(uint64_t u,unsigned scale,unsigned rc,int daz) {
+  const uint64_t em=UINT64_C(0x7ff0000000000000),fm=UINT64_C(0x000fffffffffffff),qb=UINT64_C(0x0008000000000000),sb=UINT64_C(0x8000000000000000),ib=UINT64_C(0x0010000000000000);
+  uint64_t e=(u&em)>>52,f=u&fm,s=u&sb; if(e==2047) return f?(u|qb):u;
+  if(e==0&&(f==0||daz)) return s;
+  unsigned already=1023+52-scale, regular=1023-scale;
+  if(e>=already) return u;
+  uint64_t sig=f|ib;
+  if(e>=regular) { unsigned drop=52+1023-scale-(unsigned)e; uint64_t q=sig>>drop, rem=sig&((UINT64_C(1)<<drop)-1), half=UINT64_C(1)<<(drop-1); int n=rem>half||(rem==half&&(q&1)); q+=(uint64_t)inc(rc,s!=0,rem!=0,n); uint64_t rs=q<<drop, carry=(rs&(ib<<1))!=0; return s|((e+carry)<<52)|(rs&fm); }
+  int half=e==regular-1, n=half&&sig>ib; return s|(inc(rc,s!=0,1,n)?((uint64_t)(1023-scale)<<52):0);
+}
+/* For |src|<step/2 and a nonzero rounded value, only directed rounding
+   towards the other side of zero is possible. The final result is +/-
+   (step-|src|), rounded towards zero in magnitude. Compute the number of
+   representable units below step with integers: step-ceil(|src|/ulp).
+   This is independent of the host's rounding, DAZ and FTZ controls. */
+static uint64_t reduce_tiny(uint64_t u,unsigned scale,unsigned bits) {
+  unsigned fraction=bits==32?23:52, bias=bits==32?127:1023;
+  uint64_t sign=UINT64_C(1)<<(bits-1), magnitude=u&(sign-1);
+  unsigned exponent=(unsigned)(magnitude>>fraction);
+  uint64_t significand=magnitude&((UINT64_C(1)<<fraction)-1);
+  if(exponent) significand|=UINT64_C(1)<<fraction;
+  unsigned drop=bias-scale-1-(exponent?exponent:1);
+  uint64_t units=1;
+  if(drop<=fraction) {
+    uint64_t remainder=significand&((UINT64_C(1)<<drop)-1);
+    units=(significand>>drop)+(remainder!=0);
+  }
+  uint64_t step=(uint64_t)(bias-scale)<<fraction;
+  return ((u^sign)&sign)|(step-units);
+}
+static uint32_t reduce32(uint32_t u,unsigned scale,unsigned rc,int daz) {
+  uint32_t e=u&0x7f800000,f=u&0x007fffff,s=u&0x80000000;
+  if(e==0x7f800000) return f?(u|0x00400000):0;
+  uint32_t effective=(e==0&&(f==0||daz))?s:u, rounded=round32(u,scale,rc,daz), r;
+  if(!(rounded&0x7fffffff)) return (effective&0x7fffffff)?effective:(rc==1?0x80000000:0);
+  if((effective&0x7fffffff)<((127-scale-1)<<23)) return (uint32_t)reduce_tiny(effective,scale,32);
+  /* Both nonzero magnitudes now differ by at most a factor of two:
+     Sterbenz subtraction is exact under every ambient RC. At scale<=15
+     the source ULP near the grid is normal, so FTZ cannot change it. */
+  float a,b,c; memcpy(&a,&effective,4); memcpy(&b,&rounded,4);
+  c=a-b; memcpy(&r,&c,4);
+  return (r&0x7fffffff)?r:(rc==1?0x80000000:0);
+}
+static uint64_t reduce64(uint64_t u,unsigned scale,unsigned rc,int daz) {
+  uint64_t e=u&UINT64_C(0x7ff0000000000000),f=u&UINT64_C(0x000fffffffffffff),s=u&UINT64_C(0x8000000000000000);
+  if(e==UINT64_C(0x7ff0000000000000)) return f?(u|UINT64_C(0x0008000000000000)):0;
+  uint64_t effective=(e==0&&(f==0||daz))?s:u, rounded=round64(u,scale,rc,daz), r;
+  if(!(rounded&UINT64_C(0x7fffffffffffffff))) return (effective&UINT64_C(0x7fffffffffffffff))?effective:(rc==1?UINT64_C(0x8000000000000000):0);
+  if((effective&UINT64_C(0x7fffffffffffffff))<((uint64_t)(1023-scale-1)<<52)) return reduce_tiny(effective,scale,64);
+  double a,b,c; memcpy(&a,&effective,8); memcpy(&b,&rounded,8);
+  c=a-b; memcpy(&r,&c,8);
+  return (r&UINT64_C(0x7fffffffffffffff))?r:(rc==1?UINT64_C(0x8000000000000000):0);
+}
+static uint32_t u32(const uint8_t *p) { uint32_t v; memcpy(&v,p,4); return v; }
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  const uint32_t s32[16]={0x3fc00000,0x40200000,0xbfc00000,0xc0200000,0x3fb00000,0xbfb00000,0,0x80000000,0x7f800000,0xff800000,0x7fc12345,0xff812345,1,0x80000001,0x4e800000,0x3f800001};
+  const uint64_t s64[16]={UINT64_C(0x3ff8000000000000),UINT64_C(0x4004000000000000),UINT64_C(0xbff8000000000000),UINT64_C(0xc004000000000000),UINT64_C(0x3ff6000000000000),UINT64_C(0xbff6000000000000),0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff0123456789abc),1,UINT64_C(0x8000000000000001),UINT64_C(0x41d0000000000000),UINT64_C(0x3ff0000000000001)};
+  uint32_t old32[16]; uint64_t old64[8]; const uint64_t upper[2]={UINT64_C(0x1122334455667788),UINT64_C(0x99aabbccddeeff00)}; const uint64_t mask=UINT64_C(0xa55a);
+  uint8_t out[1977]={0},outDaz[1977]={0},dynamic[4][1977]; for(int i=0;i<16;i++)old32[i]=UINT32_C(0x41000000)+i; for(int i=0;i<8;i++)old64[i]=UINT64_C(0x4020000000000000)+i;
+  unsigned csr=_mm_getcsr(); scaledroundsemantics(out,s32,s64,old32,old64,upper,mask); _mm_setcsr(csr|0x40); scaledroundsemantics(outDaz,s32,s64,old32,old64,upper,mask); _mm_setcsr(csr);
+  for(unsigned rc=0;rc<4;rc++){_mm_setcsr((csr&~(3u<<13))|(rc<<13));scaledroundsemantics(dynamic[rc],s32,s64,old32,old64,upper,mask);} _mm_setcsr(csr);
+  for(unsigned scale=0;scale<16;scale++)for(unsigned rc=0;rc<4;rc++){unsigned i=scale*4+rc,j=i&15;if(u32(out+i*4)!=round32(s32[j],scale,rc,0)||u32(out+256+i*4)!=reduce32(s32[j],scale,rc,0))return 10;if(u64(out+512+i*8)!=round64(s64[j],scale,rc,0)||u64(out+1024+i*8)!=reduce64(s64[j],scale,rc,0))return 11;if(u32(outDaz+i*4)!=round32(s32[j],scale,rc,1)||u32(outDaz+256+i*4)!=reduce32(s32[j],scale,rc,1))return 12;if(u64(outDaz+512+i*8)!=round64(s64[j],scale,rc,1)||u64(outDaz+1024+i*8)!=reduce64(s64[j],scale,rc,1))return 13;}
+  for(int i=0;i<16;i++){uint32_t r=round32(s32[i],2,3,0),d=reduce32(s32[i],2,3,0);if(u32(out+1536+i*4)!=(((mask>>i)&1)?r:old32[i]))return 20;if(u32(out+1600+i*4)!=(((mask>>i)&1)?d:0))return 21;if(u32(out+1664+i*4)!=round32(s32[0],2,3,0))return 22;}
+  for(int i=0;i<8;i++){uint64_t r=round64(s64[i],2,3,0),d=reduce64(s64[i],2,3,0);if(u64(out+1728+i*8)!=(((mask>>i)&1)?r:old64[i]))return 23;if(u64(out+1792+i*8)!=(((mask>>i)&1)?d:0))return 24;if(u64(out+1856+i*8)!=round64(s64[0],2,3,0))return 25;}
+  if(u32(out+1920)!=round32(s32[0],0,0,0)||memcmp(out+1924,(const uint8_t*)upper+4,12))return 30;if(u64(out+1936)!=reduce64(s64[0],0,0,0)||memcmp(out+1944,(const uint8_t*)upper+8,8))return 31;if(out[1976]!=1)return 32;
+  for(unsigned rc=0;rc<4;rc++){if(u32(dynamic[rc]+1952)!=round32(s32[0],2,rc,0)||u32(dynamic[rc]+1956)!=reduce32(s32[2],2,rc,0)||u64(dynamic[rc]+1960)!=round64(s64[0],2,rc,0)||u64(dynamic[rc]+1968)!=reduce64(s64[2],2,rc,0))return 40+rc;}
+  return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "scaled_round_semantics", ir, mainC)
+}
diff --git a/amd64_lower_scalef.go b/amd64_lower_scalef.go
new file mode 100644
index 000000000..c09790d95
--- /dev/null
+++ b/amd64_lower_scalef.go
@@ -0,0 +1,383 @@
+package plan9asm
+
+import "fmt"
+
+type amd64ScaleFControls struct {
+	daz      string
+	ftz      string
+	rounding string
+}
+
+func (c *amd64Ctx) scaleFControls(rounding string) amd64ScaleFControls {
+	mxcsr := c.loadMXCSR()
+	dazBits, daz := c.newTmp(), c.newTmp()
+	ftzBits, ftz := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 64\n", dazBits, mxcsr)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", daz, dazBits)
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 32768\n", ftzBits, mxcsr)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i32 %%%s, 0\n", ftz, ftzBits)
+	mode := ""
+	switch rounding {
+	case "RN_SAE":
+		mode = "0"
+	case "RD_SAE":
+		mode = "1"
+	case "RU_SAE":
+		mode = "2"
+	case "RZ_SAE":
+		mode = "3"
+	default:
+		shifted, extracted := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, 13\n", shifted, mxcsr)
+		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 3\n", extracted, shifted)
+		mode = "%" + extracted
+	}
+	return amd64ScaleFControls{daz: "%" + daz, ftz: "%" + ftz, rounding: mode}
+}
+
+func (c *amd64Ctx) lowerPackedScaleF(spec amd64BinaryFloatingSpec, properties amd64BinaryFloatingSuffix, source2, source1, destination Operand, byteWidth int, mask string) (bool, bool, error) {
+	lanes := byteWidth * 8 / spec.laneBits
+	scale, err := c.loadPackedCompareLanes(source2, byteWidth, spec.laneBits, properties.broadcast)
+	if err != nil {
+		return true, false, err
+	}
+	value, err := c.loadPackedCompareLanes(source1, byteWidth, spec.laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.emitScaleFBits(lanes, spec.laneBits, value, scale, c.scaleFControls(properties.rounding))
+	if mask != "" {
+		oldBytes, loadErr := c.loadPackedCompareBytes(destination, byteWidth)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		old := c.bitcastVectorBytesToIntegerLanes(byteWidth, lanes, spec.laneBits, oldBytes)
+		result = amd64ApplyIntegerLaneMask(c, lanes, spec.laneBits, result, old, mask, properties.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, spec.laneBits, result, byteWidth)
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) lowerScalarScaleF(spec amd64BinaryFloatingSpec, properties amd64BinaryFloatingSuffix, source2, source1, destination Operand, mask string) (bool, bool, error) {
+	scaleBits, err := c.loadFloatingScalarBits(source2, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	valueBits, err := c.loadFloatingScalarBits(source1, spec.laneBits)
+	if err != nil {
+		return true, false, err
+	}
+	scale, value := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", scale, spec.laneBits, spec.laneBits, scaleBits)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", value, spec.laneBits, spec.laneBits, valueBits)
+	result := c.emitScaleFBits(1, spec.laneBits, "%"+value, "%"+scale, c.scaleFControls(properties.rounding))
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", low, spec.laneBits, result)
+	passthroughBytes, err := c.loadX(source1.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/spec.laneBits, spec.laneBits, passthroughBytes)
+	return true, false, c.storeScalarMoveRegister(destination.Reg, spec.laneBits, "%"+low, base, mask, properties.zeroing)
+}
+
+func (c *amd64Ctx) emitScaleFBits(lanes, laneBits int, source1, source2 string, controls amd64ScaleFControls) string {
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	mantissaBits, bias, exponentMax, scaleClamp := 23, 127, 255, 512
+	exponentMask := uint64(0x7f800000)
+	mantissaMask := uint64(0x007fffff)
+	quietBit := uint64(0x00400000)
+	signBit := uint64(0x80000000)
+	indefinite := uint64(0xffc00000)
+	if laneBits == 64 {
+		mantissaBits, bias, exponentMax, scaleClamp = 52, 1023, 2047, 4096
+		exponentMask = uint64(0x7ff0000000000000)
+		mantissaMask = uint64(0x000fffffffffffff)
+		quietBit = uint64(0x0008000000000000)
+		signBit = uint64(0x8000000000000000)
+		indefinite = uint64(0xfff8000000000000)
+	}
+	implicitBit := uint64(1) << mantissaBits
+	result := "zeroinitializer"
+	for lane := 0; lane < lanes; lane++ {
+		x, y := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", x, vectorType, source1, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", y, vectorType, source2, lane)
+		laneResult := c.emitScaleFLane(laneBits, mantissaBits, bias, exponentMax, scaleClamp,
+			exponentMask, mantissaMask, quietBit, signBit, indefinite, implicitBit,
+			"%"+x, "%"+y, controls)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, result, laneBits, laneResult, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+type amd64ScaleFClass struct {
+	bits, sign, fraction, exponent     string
+	zero, nan, snan, infinity          string
+	positiveInfinity, negativeInfinity string
+}
+
+func (c *amd64Ctx) classifyScaleFValue(laneBits, mantissaBits, exponentMax int, exponentMask, mantissaMask, quietBit, signBit uint64, bits, daz string) amd64ScaleFClass {
+	sign, fraction, exponentField := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %s, %d\n", sign, laneBits, bits, signBit)
+	fmt.Fprintf(c.b, "  %%%s = and i%d %s, %d\n", fraction, laneBits, bits, mantissaMask)
+	fmt.Fprintf(c.b, "  %%%s = and i%d %s, %d\n", exponentField, laneBits, bits, exponentMask)
+	exponentZero, fractionNonzero, denormal := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", exponentZero, laneBits, exponentField)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", fractionNonzero, laneBits, fraction)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", denormal, exponentZero, fractionNonzero)
+	flush := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %s\n", flush, denormal, daz)
+	effective := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %s\n", effective, flush, laneBits, sign, laneBits, bits)
+
+	effectiveFraction, shiftedExponent, effectiveExponent := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", effectiveFraction, laneBits, effective, mantissaMask)
+	fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %d\n", shiftedExponent, laneBits, effective, mantissaBits)
+	if laneBits == 32 {
+		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %d\n", effectiveExponent, shiftedExponent, exponentMax)
+	} else {
+		exponentWide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, %d\n", exponentWide, shiftedExponent, exponentMax)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", effectiveExponent, exponentWide)
+	}
+	abs, isZero, isExponentMax, isFractionNonzero := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", abs, laneBits, effective, signBit-1)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", isZero, laneBits, abs)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %%%s, %d\n", isExponentMax, effectiveExponent, exponentMax)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", isFractionNonzero, laneBits, effectiveFraction)
+	isNaN, isInfinity := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isNaN, isExponentMax, isFractionNonzero)
+	fractionQuiet, quietClear, isSNaN := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", fractionQuiet, laneBits, effectiveFraction, quietBit)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", quietClear, laneBits, fractionQuiet)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isSNaN, isNaN, quietClear)
+	fractionZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, 0\n", fractionZero, laneBits, effectiveFraction)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isInfinity, isExponentMax, fractionZero)
+	isNegative, positiveInfinity, negativeInfinity := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", isNegative, laneBits, sign)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", negativeInfinity, isInfinity, isNegative)
+	notNegative := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notNegative, isNegative)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", positiveInfinity, isInfinity, notNegative)
+	return amd64ScaleFClass{
+		bits: "%" + effective, sign: "%" + sign, fraction: "%" + effectiveFraction, exponent: "%" + effectiveExponent,
+		zero: "%" + isZero, nan: "%" + isNaN, snan: "%" + isSNaN, infinity: "%" + isInfinity,
+		positiveInfinity: "%" + positiveInfinity, negativeInfinity: "%" + negativeInfinity,
+	}
+}
+
+func (c *amd64Ctx) emitScaleFLane(laneBits, mantissaBits, bias, exponentMax, scaleClamp int, exponentMask, mantissaMask, quietBit, signBit, indefinite, implicitBit uint64, source1, source2 string, controls amd64ScaleFControls) string {
+	x := c.classifyScaleFValue(laneBits, mantissaBits, exponentMax, exponentMask, mantissaMask, quietBit, signBit, source1, controls.daz)
+	y := c.classifyScaleFValue(laneBits, mantissaBits, exponentMax, exponentMask, mantissaMask, quietBit, signBit, source2, controls.daz)
+
+	yNegative := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %s, 0\n", yNegative, laneBits, y.sign)
+	yExponentNegative, yExponentLarge := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %s, %d\n", yExponentNegative, y.exponent, bias)
+	largeExponent := 9
+	if laneBits == 64 {
+		largeExponent = 12
+	}
+	fmt.Fprintf(c.b, "  %%%s = icmp sge i32 %s, %d\n", yExponentLarge, y.exponent, bias+largeExponent)
+	yUnbiased, yShift := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %d\n", yUnbiased, y.exponent, bias)
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %d, %%%s\n", yShift, mantissaBits, yUnbiased)
+	yExponentOutOfRange := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", yExponentOutOfRange, yExponentNegative, yExponentLarge)
+	safeYShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %d, i32 %%%s\n", safeYShift, yExponentOutOfRange, mantissaBits, yShift)
+	yShiftLane := "%" + safeYShift
+	if laneBits == 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, safeYShift)
+		yShiftLane = "%" + wide
+	}
+	ySignificand := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %d\n", ySignificand, laneBits, y.fraction, implicitBit)
+	yIntegerWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %s\n", yIntegerWide, laneBits, ySignificand, yShiftLane)
+	yInteger := "%" + yIntegerWide
+	if laneBits == 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", narrow, yIntegerWide)
+		yInteger = "%" + narrow
+	}
+	oneShifted, remainderMask, remainder, remainderNonzero := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i%d 1, %s\n", oneShifted, laneBits, yShiftLane)
+	fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, 1\n", remainderMask, laneBits, oneShifted)
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %%%s\n", remainder, laneBits, ySignificand, remainderMask)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", remainderNonzero, laneBits, remainder)
+	negativeInteger, negativeFloor := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 0, %s\n", negativeInteger, yInteger)
+	remainderAdjust := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i32\n", remainderAdjust, remainderNonzero)
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, %%%s\n", negativeFloor, negativeInteger, remainderAdjust)
+	signedInteger := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %%%s, i32 %s\n", signedInteger, yNegative, negativeFloor, yInteger)
+	smallScale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 -1, i32 0\n", smallScale, yNegative)
+	clampedScale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 -%d, i32 %d\n", clampedScale, yNegative, scaleClamp, scaleClamp)
+	nonzeroScale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %%%s, i32 %%%s\n", nonzeroScale, yExponentLarge, clampedScale, signedInteger)
+	finiteScale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %%%s, i32 %%%s\n", finiteScale, yExponentNegative, smallScale, nonzeroScale)
+	scale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i32 0, i32 %%%s\n", scale, y.zero, finiteScale)
+
+	xExponentZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", xExponentZero, x.exponent)
+	xSignificandNormal := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %d\n", xSignificandNormal, laneBits, x.fraction, implicitBit)
+	xSignificand := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %s, i%d %%%s\n", xSignificand, xExponentZero, laneBits, x.fraction, laneBits, xSignificandNormal)
+	leadingZeros := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.ctlz.i%d(i%d %%%s, i1 false)\n", leadingZeros, laneBits, laneBits, laneBits, xSignificand)
+	leadingZeros32 := "%" + leadingZeros
+	if laneBits == 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", narrow, leadingZeros)
+		leadingZeros32 = "%" + narrow
+	}
+	normalizeShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %d\n", normalizeShift, leadingZeros32, laneBits-1-mantissaBits)
+	normalizeShiftLane := "%" + normalizeShift
+	if laneBits == 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, normalizeShift)
+		normalizeShiftLane = "%" + wide
+	}
+	normalizedSignificand := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i%d %%%s, %s\n", normalizedSignificand, laneBits, xSignificand, normalizeShiftLane)
+	xBaseExponentNormal, xBaseExponent := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %d\n", xBaseExponentNormal, x.exponent, bias)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %d, i32 %%%s\n", xBaseExponent, xExponentZero, 1-bias, xBaseExponentNormal)
+	xNormalizedExponent := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, %%%s\n", xNormalizedExponent, xBaseExponent, normalizeShift)
+	targetExponent := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %%%s\n", targetExponent, xNormalizedExponent, scale)
+
+	overflow, normal := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt i32 %%%s, %d\n", overflow, targetExponent, bias)
+	fmt.Fprintf(c.b, "  %%%s = icmp sge i32 %%%s, %d\n", normal, targetExponent, 1-bias)
+	normalExponent32 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %d\n", normalExponent32, targetExponent, bias)
+	normalExponent := "%" + normalExponent32
+	if laneBits == 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, normalExponent32)
+		normalExponent = "%" + wide
+	}
+	normalExponentBits, normalFraction, normalMagnitude, normalBits := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i%d %s, %d\n", normalExponentBits, laneBits, normalExponent, mantissaBits)
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %d\n", normalFraction, laneBits, normalizedSignificand, mantissaMask)
+	fmt.Fprintf(c.b, "  %%%s = or i%d %%%s, %%%s\n", normalMagnitude, laneBits, normalExponentBits, normalFraction)
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %%%s\n", normalBits, laneBits, x.sign, normalMagnitude)
+
+	subnormalShiftRaw, subnormalShiftHigh := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %d, %%%s\n", subnormalShiftRaw, 1-bias, targetExponent)
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt i32 %%%s, %d\n", subnormalShiftHigh, subnormalShiftRaw, mantissaBits+2)
+	subnormalShiftMax := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %d, i32 %%%s\n", subnormalShiftMax, subnormalShiftHigh, mantissaBits+2, subnormalShiftRaw)
+	subnormalShiftLow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %%%s, 1\n", subnormalShiftLow, subnormalShiftMax)
+	subnormalShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 1, i32 %%%s\n", subnormalShift, subnormalShiftLow, subnormalShiftMax)
+	subnormalShiftLane := "%" + subnormalShift
+	if laneBits == 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, subnormalShift)
+		subnormalShiftLane = "%" + wide
+	}
+	quotient, subOneShifted, subRemainderMask, subRemainder := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i%d %%%s, %s\n", quotient, laneBits, normalizedSignificand, subnormalShiftLane)
+	fmt.Fprintf(c.b, "  %%%s = shl i%d 1, %s\n", subOneShifted, laneBits, subnormalShiftLane)
+	fmt.Fprintf(c.b, "  %%%s = sub i%d %%%s, 1\n", subRemainderMask, laneBits, subOneShifted)
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, %%%s\n", subRemainder, laneBits, normalizedSignificand, subRemainderMask)
+	subRemainderNonzero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", subRemainderNonzero, laneBits, subRemainder)
+	halfShift32 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, 1\n", halfShift32, subnormalShift)
+	halfShift := "%" + halfShift32
+	if laneBits == 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, halfShift32)
+		halfShift = "%" + wide
+	}
+	half, aboveHalf, equalHalf, quotientOdd, tieOdd, nearest := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i%d 1, %s\n", half, laneBits, halfShift)
+	fmt.Fprintf(c.b, "  %%%s = icmp ugt i%d %%%s, %%%s\n", aboveHalf, laneBits, subRemainder, half)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %%%s, %%%s\n", equalHalf, laneBits, subRemainder, half)
+	quotientLowBit := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i%d %%%s, 1\n", quotientLowBit, laneBits, quotient)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %%%s, 0\n", quotientOdd, laneBits, quotientLowBit)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", tieOdd, equalHalf, quotientOdd)
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", nearest, aboveHalf, tieOdd)
+	xNegative := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i%d %s, 0\n", xNegative, laneBits, x.sign)
+	increment := c.emitScaledRoundIncrement(controls.rounding, "%"+xNegative, "%"+subRemainderNonzero, "%"+nearest)
+	incrementBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i%d\n", incrementBits, increment, laneBits)
+	roundedSubnormal, subnormalBits := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i%d %%%s, %%%s\n", roundedSubnormal, laneBits, quotient, incrementBits)
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %%%s\n", subnormalBits, laneBits, x.sign, roundedSubnormal)
+	isSubnormal := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult i%d %%%s, %d\n", isSubnormal, laneBits, roundedSubnormal, implicitBit)
+	flushInexact, flushSubnormal := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %s, %%%s\n", flushInexact, controls.ftz, subRemainderNonzero)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", flushSubnormal, flushInexact, isSubnormal)
+	underflowBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %s, i%d %%%s\n", underflowBits, flushSubnormal, laneBits, x.sign, laneBits, subnormalBits)
+
+	toInfinity := c.emitScaledRoundIncrement(controls.rounding, "%"+xNegative, "true", "true")
+	overflowInfinity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %d, i%d %d\n", overflowInfinity, toInfinity, laneBits, exponentMask, laneBits, exponentMask-1)
+	overflowBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %%%s\n", overflowBits, laneBits, x.sign, overflowInfinity)
+	finiteNonOverflow, finiteBits := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", finiteNonOverflow, normal, laneBits, normalBits, laneBits, underflowBits)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", finiteBits, overflow, laneBits, overflowBits, laneBits, finiteNonOverflow)
+
+	yInfinityResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %d, i%d %s\n", yInfinityResult, y.positiveInfinity, laneBits, exponentMask, laneBits, x.sign)
+	yInfinitySigned := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %%%s\n", yInfinitySigned, laneBits, x.sign, yInfinityResult)
+	general := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", general, y.infinity, laneBits, yInfinitySigned, laneBits, finiteBits)
+	xZeroInfinity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %d, i%d %s\n", xZeroInfinity, y.positiveInfinity, laneBits, indefinite, laneBits, x.bits)
+	xZeroResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %s\n", xZeroResult, y.infinity, laneBits, xZeroInfinity, laneBits, x.bits)
+	withZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", withZero, x.zero, laneBits, xZeroResult, laneBits, general)
+	xInfinityResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %d, i%d %s\n", xInfinityResult, y.negativeInfinity, laneBits, indefinite, laneBits, x.bits)
+	withInfinity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", withInfinity, x.infinity, laneBits, xInfinityResult, laneBits, withZero)
+	quietY := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %d\n", quietY, laneBits, y.bits, quietBit)
+	withYNaN := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", withYNaN, y.nan, laneBits, quietY, laneBits, withInfinity)
+	quietX := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i%d %s, %d\n", quietX, laneBits, x.bits, quietBit)
+	xQNaNInfinity := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %d, i%d 0\n", xQNaNInfinity, y.positiveInfinity, laneBits, exponentMask, laneBits)
+	xQNaNResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", xQNaNResult, y.infinity, laneBits, xQNaNInfinity, laneBits, quietX)
+	xQNaN := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %s, true\n", xQNaN, x.nan)
+	notSNaN := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", notSNaN, x.snan)
+	isQNaN := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isQNaN, xQNaN, notSNaN)
+	withXQNaN := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", withXQNaN, isQNaN, laneBits, xQNaNResult, laneBits, withYNaN)
+	final := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d %%%s\n", final, x.snan, laneBits, quietX, laneBits, withXQNaN)
+	return "%" + final
+}
diff --git a/amd64_lower_scalef_test.go b/amd64_lower_scalef_test.go
new file mode 100644
index 000000000..ebace5bb7
--- /dev/null
+++ b/amd64_lower_scalef_test.go
@@ -0,0 +1,272 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64ScaleFGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64BinaryFloatingSpec{
+		"VSCALEFPS": {laneBits: 32, mode: amd64BinaryFloatingScale},
+		"VSCALEFPD": {laneBits: 64, mode: amd64BinaryFloatingScale},
+		"VSCALEFSS": {laneBits: 32, mode: amd64BinaryFloatingScale, scalar: true},
+		"VSCALEFSD": {laneBits: 64, mode: amd64BinaryFloatingScale, scalar: true},
+	}
+	for op, want := range expected {
+		if got, ok := amd64BinaryFloatingSpecs[op]; !ok {
+			t.Errorf("SCALEF grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("SCALEF grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86ScaleFCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT scalefforms(SB),$0-0\n")
+			for _, op := range []string{"VSCALEFPS", "VSCALEFPD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					last := 31
+					if target.goarch == "386" {
+						last = 7
+					}
+					fmt.Fprintf(&source, "\t%s %s1, %s2, %s%d\n", op, width, width, width, last)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s2, %s%d\n", op, width, width, last)
+					fmt.Fprintf(&source, "\t%s.BCST 16(AX), %s2, %s%d\n", op, width, width, last)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s1, %s2, K1, %s%d\n", op, width, width, width, last)
+						fmt.Fprintf(&source, "\t%s.Z 24(AX), %s2, K2, %s%d\n", op, width, width, last)
+						fmt.Fprintf(&source, "\t%s.BCST.Z 32(AX), %s2, K3, %s%d\n", op, width, width, last)
+					}
+					if width == "Z" {
+						for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+							fmt.Fprintf(&source, "\t%s.%s Z1, Z2, Z%d\n", op, rounding, last)
+							if target.goarch == "amd64" {
+								fmt.Fprintf(&source, "\t%s.%s.Z Z1, Z2, K4, Z%d\n", op, rounding, last)
+							}
+						}
+					}
+				}
+			}
+			for _, op := range []string{"VSCALEFSS", "VSCALEFSD"} {
+				fmt.Fprintf(&source, "\t%s X1, X2, X7\n", op)
+				fmt.Fprintf(&source, "\t%s 40(AX), X2, X7\n", op)
+				for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					fmt.Fprintf(&source, "\t%s.%s X1, X2, X7\n", op, rounding)
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X2, K5, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 48(AX), X2, K6, X31\n", op)
+					fmt.Fprintf(&source, "\t%s.RN_SAE.Z X1, X2, K7, X31\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86FloatingHelperOriginalFormatObject(t, source.String(), "scalefforms", target.goarch, target.triple)
+			if ir == "" {
+				return // Go/public-Context coverage, not an LLVM object claim.
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalef-"+target.name+".ll", "scalef-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ScaleFRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VSCALEFPS X0, X1"},
+		{goarch: "amd64", instruction: "VSCALEFPS X0, X1, X2, X3, X4"},
+		{goarch: "amd64", instruction: "VSCALEFPS X0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VSCALEFPS X0, 8(AX), X2"},
+		{goarch: "amd64", instruction: "VSCALEFPS X0, X1, K0, X2"},
+		{goarch: "amd64", instruction: "VSCALEFPS.Z X0, X1, X2"},
+		{goarch: "amd64", instruction: "VSCALEFPS.BCST X0, X1, X2"},
+		{goarch: "amd64", instruction: "VSCALEFPS.RN_SAE 8(AX), Z1, Z2"},
+		{goarch: "amd64", instruction: "VSCALEFPS.SAE Z0, Z1, Z2"},
+		{goarch: "amd64", instruction: "VSCALEFPS.RN_SAE Y0, Y1, Y2"},
+		{goarch: "amd64", instruction: "VSCALEFSS Y0, X1, X2"},
+		{goarch: "amd64", instruction: "VSCALEFSS.BCST 8(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VSCALEFSS.RN_SAE 8(AX), X1, X2"},
+		{goarch: "amd64", instruction: "VSCALEFSS X0, Y1, X2"},
+		{goarch: "386", instruction: "VSCALEFPS X0, X1, K1, X2"},
+		{goarch: "386", instruction: "VSCALEFPS Z8, Z1, Z2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SCALEF tables", test.instruction)
+			}
+		})
+	}
+}
+
+func qualifyAMD64ScaleFRuntimeSemantics(t *testing.T) {
+	execution := x86FloatingHelperRuntimeTools(t)
+	const source = `TEXT scalefsemantics(SB),$0-72
+	MOVQ out+0(FP), AX
+	MOVQ value32+8(FP), BX
+	MOVQ scale32+16(FP), CX
+	MOVQ value64+24(FP), DX
+	MOVQ scale64+32(FP), R8
+	MOVQ old32+40(FP), R9
+	MOVQ old64+48(FP), R10
+	MOVQ upper+56(FP), R11
+	MOVQ mask+64(FP), R12
+	KMOVQ R12, K1
+	VMOVDQU32 0(BX), Z1
+	VMOVDQU32 0(CX), Z2
+	VSCALEFPS Z2, Z1, Z3
+	VMOVDQU32 Z3, 0(AX)
+	VSCALEFPS.RN_SAE Z2, Z1, Z3
+	VMOVDQU32 Z3, 64(AX)
+	VMOVDQU32 0(R9), Z3
+	VSCALEFPS Z2, Z1, K1, Z3
+	VMOVDQU32 Z3, 128(AX)
+	VSCALEFPS.BCST 0(CX), Z1, Z3
+	VMOVDQU32 Z3, 192(AX)
+	VMOVDQU64 0(DX), Z4
+	VMOVDQU64 0(R8), Z5
+	VSCALEFPD Z5, Z4, Z6
+	VMOVDQU64 Z6, 256(AX)
+	VSCALEFPD.RN_SAE Z5, Z4, Z6
+	VMOVDQU64 Z6, 320(AX)
+	VMOVDQU64 0(R10), Z6
+	VSCALEFPD.Z Z5, Z4, K1, Z6
+	VMOVDQU64 Z6, 384(AX)
+	VSCALEFPD.BCST 0(R8), Z4, Z6
+	VMOVDQU64 Z6, 448(AX)
+	VMOVDQU64 0(R11), X7
+	VSCALEFSS 60(CX), X7, X8
+	VMOVDQU64 X8, 512(AX)
+	VSCALEFSD 56(R8), X7, X9
+	VMOVDQU64 X9, 528(AX)
+	STC
+	SETCS 544(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := execution.triple
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"scalefsemantics": {
+			Name: "scalefsemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+				{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+				{Offset: 56, Type: Ptr, Index: 7, Field: -1},
+				{Offset: 64, Type: I64, Index: 8, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <fenv.h>
+#include <math.h>
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void scalefsemantics(uint8_t *, const uint32_t *, const uint32_t *, const uint64_t *, const uint64_t *, const uint32_t *, const uint64_t *, const uint64_t *, uint64_t);
+static uint32_t u32(const uint8_t *p) { uint32_t v; memcpy(&v,p,4); return v; }
+static uint64_t u64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+static uint32_t scale32(uint32_t x, uint32_t y, int daz) {
+  const uint32_t em=UINT32_C(0x7f800000), fm=UINT32_C(0x007fffff), qb=UINT32_C(0x00400000), sb=UINT32_C(0x80000000), ind=UINT32_C(0xffc00000);
+  if(daz && !(x&em) && (x&fm)) x&=sb; if(daz && !(y&em) && (y&fm)) y&=sb;
+  uint32_t xf=x&fm,yf=y&fm; int xn=(x&em)==em&&xf, xs=xn&&!(xf&qb), xi=(x&~sb)==em, xz=(x&~sb)==0;
+  int yn=(y&em)==em&&yf, yi=(y&~sb)==em, yp=yi&&!(y&sb), ym=yi&&(y&sb);
+  if(xs) return x|qb;
+  if(xn) return yi?(yp?em:0):(x|qb);
+  if(yn) return y|qb;
+  if(xi) return ym?ind:x;
+  if(xz) return yp?ind:x;
+  if(yp) return (x&sb)|em; if(ym) return x&sb;
+  float a,b,r; memcpy(&a,&x,4); memcpy(&b,&y,4); int n=b>=512?512:(b<=-512?-512:(int)floorf(b)); r=scalbnf(a,n); memcpy(&x,&r,4); return x;
+}
+static uint64_t scale64(uint64_t x, uint64_t y, int daz) {
+  const uint64_t em=UINT64_C(0x7ff0000000000000), fm=UINT64_C(0x000fffffffffffff), qb=UINT64_C(0x0008000000000000), sb=UINT64_C(0x8000000000000000), ind=UINT64_C(0xfff8000000000000);
+  if(daz && !(x&em) && (x&fm)) x&=sb; if(daz && !(y&em) && (y&fm)) y&=sb;
+  uint64_t xf=x&fm,yf=y&fm; int xn=(x&em)==em&&xf, xs=xn&&!(xf&qb), xi=(x&~sb)==em, xz=(x&~sb)==0;
+  int yn=(y&em)==em&&yf, yi=(y&~sb)==em, yp=yi&&!(y&sb), ym=yi&&(y&sb);
+  if(xs) return x|qb;
+  if(xn) return yi?(yp?em:0):(x|qb);
+  if(yn) return y|qb;
+  if(xi) return ym?ind:x;
+  if(xz) return yp?ind:x;
+  if(yp) return (x&sb)|em; if(ym) return x&sb;
+  double a,b,r; memcpy(&a,&x,8); memcpy(&b,&y,8); int n=b>=4096?4096:(b<=-4096?-4096:(int)floor(b)); r=scalbn(a,n); memcpy(&x,&r,8); return x;
+}
+int main(void) {
+  const uint32_t v32[16]={0x3f800000,0xbf800000,0x7f7fffff,0xff7fffff,0x00800000,0x80800000,1,0x80000001,0,0x80000000,0x7f800000,0xff800000,0x7fc12345,0x7f812345,0x3fc00000,0xbfc00000};
+  const uint32_t s32[16]={0x3ff33333,0xbf8ccccd,0x3f800000,0x3f800000,0xbf800000,0xbf800000,0x3f800000,0x3f800000,0x7f800000,0xff800000,0xff800000,0x7f800000,0x7f800000,0,0xc3160000,0xc3160000};
+  const uint64_t v64[8]={UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),UINT64_C(0x0010000000000000),1,UINT64_C(0x7ff8123456789abc),UINT64_C(0x7ff0123456789abc)};
+  const uint64_t s64[8]={UINT64_C(0x3ffe666666666666),UINT64_C(0xbff199999999999a),UINT64_C(0x3ff0000000000000),UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x3ff0000000000000),UINT64_C(0x7ff0000000000000),0};
+  uint32_t old32[16]; uint64_t old64[8];
+  uint64_t upper[2]={UINT64_C(0x112233443fc00000),UINT64_C(0x99aabbccddeeff00)};
+  for(int i=0;i<16;i++)old32[i]=UINT32_C(0x41000000)+(uint32_t)i; for(int i=0;i<8;i++)old64[i]=UINT64_C(0x4020000000000000)+(uint64_t)i;
+  const uint64_t mask=UINT64_C(0xa55a); unsigned original=_mm_getcsr();
+  const int fes[4]={FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};
+  for(unsigned rc=0;rc<4;rc++) for(unsigned daz=0;daz<2;daz++) {
+		uint8_t out[545]={0}; unsigned csr=(original&~UINT32_C(0xe040))|(rc<<13)|(daz?UINT32_C(0x40):0); _mm_setcsr(csr); fesetround(fes[rc]);
+    scalefsemantics(out,v32,s32,v64,s64,old32,old64,upper,mask);
+    for(int i=0;i<16;i++) {
+      uint32_t want=scale32(v32[i],s32[i],daz); if(u32(out+i*4)!=want)return 10+rc;
+      int saved=fegetround(); fesetround(FE_TONEAREST); uint32_t rn=scale32(v32[i],s32[i],daz); fesetround(saved); if(u32(out+64+i*4)!=rn)return 20+rc;
+      if(u32(out+128+i*4)!=(((mask>>i)&1)?want:old32[i]))return 30+rc;
+      if(u32(out+192+i*4)!=scale32(v32[i],s32[0],daz))return 40+rc;
+    }
+    for(int i=0;i<8;i++) {
+      uint64_t want=scale64(v64[i],s64[i],daz); if(u64(out+256+i*8)!=want)return 50+rc;
+      int saved=fegetround(); fesetround(FE_TONEAREST); uint64_t rn=scale64(v64[i],s64[i],daz); fesetround(saved); if(u64(out+320+i*8)!=rn)return 60+rc;
+      if(u64(out+384+i*8)!=(((mask>>i)&1)?want:0))return 70+rc;
+      if(u64(out+448+i*8)!=scale64(v64[i],s64[0],daz))return 80+rc;
+    }
+    if(u32(out+512)!=scale32((uint32_t)upper[0],s32[15],daz)||memcmp(out+516,(uint8_t*)upper+4,12))return 90+rc;
+    if(u64(out+528)!=scale64(upper[0],s64[7],daz)||u64(out+536)!=upper[1])return 100+rc;
+    if(out[544]!=1)return 110+rc;
+  }
+  _mm_setcsr(original); fesetround(FE_TONEAREST); return 0;
+}
+`
+	x86FloatingHelperRunNativePipelines(t, execution, "scalef_semantics", ir, mainC)
+}
diff --git a/amd64_lower_scatter.go b/amd64_lower_scatter.go
new file mode 100644
index 000000000..6a5727631
--- /dev/null
+++ b/amd64_lower_scatter.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64ScatterSpecs = map[string]amd64GatherSpec{
+	"VPSCATTERDD": {table: amd64GatherDPS, elemBits: 32, indexBits: 32},
+	"VPSCATTERQQ": {table: amd64GatherDPS, elemBits: 64, indexBits: 64},
+	"VSCATTERDPS": {table: amd64GatherDPS, elemBits: 32, indexBits: 32},
+	"VSCATTERQPD": {table: amd64GatherDPS, elemBits: 64, indexBits: 64},
+	"VPSCATTERDQ": {table: amd64GatherDPD, elemBits: 64, indexBits: 32},
+	"VSCATTERDPD": {table: amd64GatherDPD, elemBits: 64, indexBits: 32},
+	"VPSCATTERQD": {table: amd64GatherQPS, elemBits: 32, indexBits: 64},
+	"VSCATTERQPS": {table: amd64GatherQPS, elemBits: 32, indexBits: 64},
+}
+
+// lowerScatter implements all Go 1.27 packed integer and floating scatter
+// spellings. Values are kept as integer bit patterns, which is exact for the
+// floating variants as well.
+func (c *amd64Ctx) lowerScatter(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	name, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64ScatterSpecs[name]; !known {
+		return false, false, nil
+	}
+	local := ins
+	local.Op = op
+	form, _, err := x86VSIBProperties(local, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.emitScatter(form.spec, form.memory.Mem, form.mask.Reg, form.data.Reg, form.dataBytes, form.indexBytes)
+}
+
+func (c *amd64Ctx) emitScatter(spec amd64GatherSpec, memory MemRef, mask, data Reg, dataBytes, indexBytes int) error {
+	dataValue, err := c.loadGatherVector(data, dataBytes)
+	if err != nil {
+		return err
+	}
+	dataLanes := dataBytes * 8 / spec.elemBits
+	dataType := fmt.Sprintf("<%d x i%d>", dataLanes, spec.elemBits)
+	dataValues := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", dataValues, dataBytes, dataValue, dataType)
+
+	indexValue, err := c.loadGatherVector(memory.Index, indexBytes)
+	if err != nil {
+		return err
+	}
+	indexLanes := indexBytes * 8 / spec.indexBits
+	indexType := fmt.Sprintf("<%d x i%d>", indexLanes, spec.indexBits)
+	indexValues := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", indexValues, indexBytes, indexValue, indexType)
+	activeLanes := dataLanes
+	if indexLanes < activeLanes {
+		activeLanes = indexLanes
+	}
+
+	maskValue, err := c.loadK(mask)
+	if err != nil {
+		return err
+	}
+	base, err := c.gatherBaseAddress(memory)
+	if err != nil {
+		return err
+	}
+	for lane := 0; lane < activeLanes; lane++ {
+		indexLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", indexLane, indexType, indexValues, lane)
+		wideIndex := "%" + indexLane
+		if spec.indexBits == 32 {
+			extended := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext i32 %%%s to i64\n", extended, indexLane)
+			wideIndex = "%" + extended
+		}
+		if memory.Scale != 0 && memory.Scale != 1 {
+			scaled := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %d\n", scaled, wideIndex, memory.Scale)
+			wideIndex = "%" + scaled
+		}
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", address, base, wideIndex)
+		pointer, pointerType := c.gatherPointer(memory, "%"+address)
+
+		condition := amd64MaskBitI1(c, maskValue, lane)
+		dataLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", dataLane, dataType, dataValues, lane)
+		storeLabel := c.newTmp() + "_scatter_store"
+		skipLabel := c.newTmp() + "_scatter_skip"
+		joinLabel := c.newTmp() + "_scatter_join"
+		fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n", condition, storeLabel, skipLabel)
+		fmt.Fprintf(c.b, "%s:\n", storeLabel)
+		fmt.Fprintf(c.b, "  store i%d %%%s, %s %s, align 1\n", spec.elemBits, dataLane, pointerType, pointer)
+		fmt.Fprintf(c.b, "  br label %%%s\n", joinLabel)
+		fmt.Fprintf(c.b, "%s:\n", skipLabel)
+		fmt.Fprintf(c.b, "  br label %%%s\n", joinLabel)
+		fmt.Fprintf(c.b, "%s:\n", joinLabel)
+	}
+	// Like EVEX gather, scatter clears completed mask bits to support precise
+	// restart after a fault. A normally completed instruction leaves zero.
+	return c.storeK(mask, "0")
+}
diff --git a/amd64_lower_scatter_prefetch_test.go b/amd64_lower_scatter_prefetch_test.go
new file mode 100644
index 000000000..252126a46
--- /dev/null
+++ b/amd64_lower_scatter_prefetch_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64VSIBPrefetchGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64VSIBPrefetchSpecs))
+	for op := range amd64VSIBPrefetchSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{
+		"VGATHERPF0DPD", "VGATHERPF0DPS", "VGATHERPF0QPD", "VGATHERPF0QPS",
+		"VGATHERPF1DPD", "VGATHERPF1DPS", "VGATHERPF1QPD", "VGATHERPF1QPS",
+		"VSCATTERPF0DPD", "VSCATTERPF0DPS", "VSCATTERPF0QPD", "VSCATTERPF0QPS",
+		"VSCATTERPF1DPD", "VSCATTERPF1DPS", "VSCATTERPF1QPD", "VSCATTERPF1QPS",
+	}
+	if strings.Join(got, ",") != strings.Join(want, ",") {
+		t.Fatalf("VSIB-prefetch grammar opcodes = %v, want %v", got, want)
+	}
+	for op, spec := range amd64VSIBPrefetchSpecs {
+		name := string(op)
+		wantDirection := amd64VSIBPrefetchGather
+		if strings.HasPrefix(name, "VSCATTER") {
+			wantDirection = amd64VSIBPrefetchScatter
+		}
+		wantHint := 0
+		if strings.Contains(name, "PF1") {
+			wantHint = 1
+		}
+		shape := name[strings.Index(name, "PF")+3:]
+		wantIndexBits := 32
+		if shape[0] == 'Q' {
+			wantIndexBits = 64
+		}
+		wantElemBits := 32
+		if shape[2] == 'D' {
+			wantElemBits = 64
+		}
+		wantIndexBytes := 64
+		if shape == "DPD" {
+			wantIndexBytes = 32
+		}
+		if spec.direction != wantDirection || spec.hint != wantHint || spec.indexBits != wantIndexBits ||
+			spec.elemBits != wantElemBits || spec.indexBytes != wantIndexBytes {
+			t.Errorf("VSIB-prefetch grammar %s = %+v, want direction=%d hint=%d elem=%d index=%d vector=%d",
+				op, spec, wantDirection, wantHint, wantElemBits, wantIndexBits, wantIndexBytes)
+		}
+	}
+}
+
+func TestTranslateX86ScatterPrefetchCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT scatterprefetchforms(SB),$0-0\n")
+			for _, op := range []string{"VSCATTERPF0DPD", "VSCATTERPF1DPD"} {
+				fmt.Fprintf(&source, "\t%s K1, 8(SP)(Y2*8)\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s K7, 16(R11)(Y20*4)\n", op)
+				}
+			}
+			for _, op := range []string{
+				"VSCATTERPF0DPS", "VSCATTERPF0QPD", "VSCATTERPF0QPS",
+				"VSCATTERPF1DPS", "VSCATTERPF1QPD", "VSCATTERPF1QPS",
+			} {
+				fmt.Fprintf(&source, "\t%s K2, 24(BX)(Z3*4)\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s K6, 32(SP)(Z20*8)\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"scatterprefetchforms": {Name: "scatterprefetchforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "scatter-prefetch-"+target.name+".ll", "scatter-prefetch-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ScatterPrefetchRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VSCATTERPF0DPD K0, (AX)(Y2*8)"},
+		{goarch: "amd64", instruction: "VSCATTERPF1DPD K1, (AX)(Z2*8)"},
+		{goarch: "amd64", instruction: "VSCATTERPF0DPS K1, (AX)(Y2*4)"},
+		{goarch: "amd64", instruction: "VSCATTERPF0QPD K1, (AX)"},
+		{goarch: "amd64", instruction: "VSCATTERPF0QPS (AX)(Z2*4), K1"},
+		{goarch: "amd64", instruction: "VSCATTERPF1DPS.Z K1, (AX)(Z2*4)"},
+		{goarch: "amd64", instruction: "VSCATTERPF1QPD K1, (AX)(Z2*4), Z3"},
+		{goarch: "amd64", instruction: "VSCATTERPF1QPS X1, (AX)(Z2*4)"},
+		{goarch: "386", instruction: "VSCATTERPF0DPD K1, (R8)(Y2*8)"},
+		{goarch: "386", instruction: "VSCATTERPF1DPS K1, (AX)(Z8*4)"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scatter-prefetch tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_scatter_test.go b/amd64_lower_scatter_test.go
new file mode 100644
index 000000000..da358526c
--- /dev/null
+++ b/amd64_lower_scatter_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ScatterCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 exposes eight integer/floating spellings over three exact
+	// data/index width tables. Every form is data, K1-K7, VSIB memory.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 20
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT scatterforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VPSCATTERDD", "VPSCATTERQQ", "VSCATTERDPS", "VSCATTERQPD"} {
+				fmt.Fprintf(&source, "\t%s X20, K1, (AX)(X2*1)\n", op)
+				fmt.Fprintf(&source, "\t%s Y20, K2, 8(BX)(Y3*2)\n", op)
+				fmt.Fprintf(&source, "\t%s Z%d, K3, 16(CX)(Z4*4)\n", op, lastZ)
+			}
+			for _, op := range []string{"VPSCATTERDQ", "VSCATTERDPD"} {
+				fmt.Fprintf(&source, "\t%s X20, K4, 24(DX)(X5*8)\n", op)
+				fmt.Fprintf(&source, "\t%s Y20, K5, 32(SI)(X6*1)\n", op)
+				fmt.Fprintf(&source, "\t%s Z%d, K6, 40(DI)(Y7*2)\n", op, lastZ)
+			}
+			for _, op := range []string{"VPSCATTERQD", "VSCATTERQPS"} {
+				fmt.Fprintf(&source, "\t%s X20, K7, 48(AX)(X2*4)\n", op)
+				fmt.Fprintf(&source, "\t%s X20, K1, 56(BX)(Y3*8)\n", op)
+				fmt.Fprintf(&source, "\t%s Y20, K2, 64(CX)(Z4*1)\n", op)
+			}
+			source.WriteString("\tRET\n")
+
+			// Retain every original format, including mode32 high data banks,
+			// without treating unknown data, masks and addresses as an entry.
+			// Initialized public objects belong to the independent official-row owner.
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "scatterforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scatter-"+target.name+".ll", "scatter-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ScatterRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPSCATTERDD X1, (AX)(X2*1)",
+		"VPSCATTERDD X1, K0, (AX)(X2*1)",
+		"VPSCATTERDD X1, K1, (AX)",
+		"VPSCATTERDD Y1, K1, (AX)(X2*1)",
+		"VPSCATTERDQ X1, K1, (AX)(Y2*1)",
+		"VPSCATTERQD Y1, K1, (AX)(Y2*1)",
+		"VPSCATTERDD X1, K1, (AX)(X2*3)",
+		"VPSCATTERDD.Z X1, K1, (AX)(X2*1)",
+		"VPSCATTERDD X1, K1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86ScatterRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86ScatterRejected(t, "386", "i386-unknown-linux-gnu", "VPSCATTERDD X1, K1, (R8)(X2*1)")
+	assertX86ScatterRejected(t, "386", "i386-unknown-linux-gnu", "VPSCATTERDD X1, K1, (AX)(X8*1)")
+	assertX86ScatterRejected(t, "386", "i386-unknown-linux-gnu", "VPSCATTERDD Z8, K1, (AX)(Z7*1)")
+}
+
+func assertX86ScatterRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's scatter forms", instruction)
+	}
+}
diff --git a/amd64_lower_segment_base.go b/amd64_lower_segment_base.go
new file mode 100644
index 000000000..a56e91f8a
--- /dev/null
+++ b/amd64_lower_segment_base.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64SegmentBaseDirection uint8
+
+const (
+	amd64SegmentBaseRead amd64SegmentBaseDirection = iota
+	amd64SegmentBaseWrite
+)
+
+type amd64SegmentBaseSpec struct {
+	segment   Reg
+	direction amd64SegmentBaseDirection
+	bits      int
+}
+
+// amd64SegmentBaseSpecs is the complete Go 1.27 FSGSBASE grammar. Segment,
+// transfer direction, and width are data; all eight opcodes share one Yrl
+// register parser and one exact inline-assembly emitter.
+var amd64SegmentBaseSpecs = map[Op]amd64SegmentBaseSpec{
+	"RDFSBASEL": {segment: FS, direction: amd64SegmentBaseRead, bits: 32},
+	"RDFSBASEQ": {segment: FS, direction: amd64SegmentBaseRead, bits: 64},
+	"RDGSBASEL": {segment: GS, direction: amd64SegmentBaseRead, bits: 32},
+	"RDGSBASEQ": {segment: GS, direction: amd64SegmentBaseRead, bits: 64},
+	"WRFSBASEL": {segment: FS, direction: amd64SegmentBaseWrite, bits: 32},
+	"WRFSBASEQ": {segment: FS, direction: amd64SegmentBaseWrite, bits: 64},
+	"WRGSBASEL": {segment: GS, direction: amd64SegmentBaseWrite, bits: 32},
+	"WRGSBASEQ": {segment: GS, direction: amd64SegmentBaseWrite, bits: 64},
+}
+
+type amd64SegmentBaseForm struct {
+	register Reg
+}
+
+func (c *amd64Ctx) lowerSegmentBase(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64SegmentBaseSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.bits == 64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	form, err := c.parseSegmentBaseForm(baseOp, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitSegmentBase(spec, form)
+}
+
+func (c *amd64Ctx) parseSegmentBaseForm(op string, ins Instr) (amd64SegmentBaseForm, error) {
+	var form amd64SegmentBaseForm
+	if len(ins.Args) != 1 {
+		return form, fmt.Errorf("%s %s expects one Go 1.27 Yrl register: %q", c.goarch, op, ins.Raw)
+	}
+	operand := ins.Args[0]
+	if operand.Kind != OpReg || !isX86YrlRegisterForArch(operand.Reg, c.goarch) {
+		return form, fmt.Errorf("%s %s expects a Go 1.27 Yrl register: %q", c.goarch, op, ins.Raw)
+	}
+	return amd64SegmentBaseForm{register: operand.Reg}, nil
+}
+
+func (spec amd64SegmentBaseSpec) mnemonic() string {
+	prefix := "rd"
+	if spec.direction == amd64SegmentBaseWrite {
+		prefix = "wr"
+	}
+	width := "l"
+	if spec.bits == 64 {
+		width = "q"
+	}
+	return prefix + strings.ToLower(string(spec.segment)) + "base" + width
+}
+
+func (c *amd64Ctx) emitSegmentBase(spec amd64SegmentBaseSpec, form amd64SegmentBaseForm) (bool, bool, error) {
+	typ := amd64IntegerTypeForBits(spec.bits)
+	constraints := "~{dirflag},~{fpsr},~{flags}"
+	assembly := spec.mnemonic() + " $0"
+	registerConstraint := "r"
+	if c.goarch == "386" {
+		// Intel defines FSGSBASE only in 64-bit mode, but Go 1.27's 386
+		// assembler accepts the L spellings and emits their F3 0F AE /r
+		// encodings. LLVM intentionally rejects the mnemonic for i386. Emit
+		// Go's exact EAX encoding and use a fixed-register constraint so the
+		// object remains byte-compatible without claiming runtime viability.
+		modRM := byte(0xc0)
+		if spec.segment == GS {
+			modRM += 8
+		}
+		if spec.direction == amd64SegmentBaseWrite {
+			modRM += 16
+		}
+		assembly = fmt.Sprintf(".byte 0xf3, 0x0f, 0xae, 0x%02x", modRM)
+		registerConstraint = "{ax}"
+	}
+	if spec.direction == amd64SegmentBaseRead {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n",
+			result, typ, assembly, "="+registerConstraint+","+constraints)
+		if err := c.storeRegSized(form.register, typ, "%"+result); err != nil {
+			return true, false, err
+		}
+		return true, false, nil
+	}
+	value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: form.register}, typ)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s)\n",
+		assembly, registerConstraint+","+constraints, typ, value)
+	return true, false, nil
+}
diff --git a/amd64_lower_segment_base_test.go b/amd64_lower_segment_base_test.go
new file mode 100644
index 000000000..f17f24329
--- /dev/null
+++ b/amd64_lower_segment_base_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64SegmentBaseGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64SegmentBaseSpecs))
+	for op := range amd64SegmentBaseSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{
+		"RDFSBASEL", "RDFSBASEQ", "RDGSBASEL", "RDGSBASEQ",
+		"WRFSBASEL", "WRFSBASEQ", "WRGSBASEL", "WRGSBASEQ",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("segment-base grammar opcodes = %v, want %v", got, want)
+	}
+	for op, want := range map[Op]amd64SegmentBaseSpec{
+		"RDFSBASEL": {segment: FS, direction: amd64SegmentBaseRead, bits: 32},
+		"RDFSBASEQ": {segment: FS, direction: amd64SegmentBaseRead, bits: 64},
+		"RDGSBASEL": {segment: GS, direction: amd64SegmentBaseRead, bits: 32},
+		"RDGSBASEQ": {segment: GS, direction: amd64SegmentBaseRead, bits: 64},
+		"WRFSBASEL": {segment: FS, direction: amd64SegmentBaseWrite, bits: 32},
+		"WRFSBASEQ": {segment: FS, direction: amd64SegmentBaseWrite, bits: 64},
+		"WRGSBASEL": {segment: GS, direction: amd64SegmentBaseWrite, bits: 32},
+		"WRGSBASEQ": {segment: GS, direction: amd64SegmentBaseWrite, bits: 64},
+	} {
+		if got := amd64SegmentBaseSpecs[op]; got != want {
+			t.Errorf("segment-base grammar %s = %+v, want %+v", op, got, want)
+		}
+		if got := want.mnemonic(); strings.ToUpper(got) != string(op) {
+			t.Errorf("segment-base grammar %s emits %q", op, got)
+		}
+	}
+}
+
+func TestTranslateX86SegmentBaseCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT segmentbaseforms(SB),$0-0
+	RDFSBASEL AX
+	RDGSBASEL SP
+	WRFSBASEL CX
+	WRGSBASEL SP
+`
+			if target.goarch == "amd64" {
+				source += `	RDFSBASEQ R11
+	RDGSBASEQ R12
+	WRFSBASEQ R13
+	WRGSBASEQ R14
+`
+			}
+			source += "\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"segmentbaseforms": {Name: "segmentbaseforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want := `"target-features"="+fsgsbase"`; !strings.Contains(ir, want) {
+				t.Errorf("IR is missing %s:\n%s", want, ir)
+			}
+			if target.goarch == "386" {
+				for _, encoding := range []string{
+					".byte 0xf3, 0x0f, 0xae, 0xc0",
+					".byte 0xf3, 0x0f, 0xae, 0xc8",
+					".byte 0xf3, 0x0f, 0xae, 0xd0",
+					".byte 0xf3, 0x0f, 0xae, 0xd8",
+				} {
+					if !strings.Contains(ir, encoding) {
+						t.Errorf("386 IR is missing Go-compatible encoding %q:\n%s", encoding, ir)
+					}
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "segment-base-"+target.name+".ll", "segment-base-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86SegmentBaseRejectsFormsOutsideGoTables(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "RDFSBASEL $1"},
+		{goarch: "amd64", instruction: "RDFSBASEQ (BX)"},
+		{goarch: "amd64", instruction: "RDGSBASEL X0"},
+		{goarch: "amd64", instruction: "RDGSBASEQ"},
+		{goarch: "amd64", instruction: "WRFSBASEL $1"},
+		{goarch: "amd64", instruction: "WRFSBASEQ (BX)"},
+		{goarch: "amd64", instruction: "WRGSBASEL X0"},
+		{goarch: "amd64", instruction: "WRGSBASEQ.Z AX"},
+	}
+	for _, op := range []string{
+		"RDFSBASEQ", "RDGSBASEQ", "WRFSBASEQ", "WRGSBASEQ",
+	} {
+		tests = append(tests, struct {
+			goarch      string
+			instruction string
+		}{goarch: "386", instruction: op + " AX"})
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's segment-base tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_segment_query.go b/amd64_lower_segment_query.go
new file mode 100644
index 000000000..1c9d87cd8
--- /dev/null
+++ b/amd64_lower_segment_query.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import "fmt"
+
+type amd64SegmentQueryKind uint8
+
+const (
+	amd64SegmentQueryAccessRights amd64SegmentQueryKind = iota
+	amd64SegmentQueryLimit
+	amd64SegmentQueryReadable
+	amd64SegmentQueryWritable
+)
+
+type amd64SegmentQuerySpec struct {
+	kind amd64SegmentQueryKind
+	bits int
+}
+
+// amd64SegmentQuerySpecs is the complete Go 1.27 LAR/LSL/VERR/VERW grammar.
+// The table records only query kind and optional destination width; all four
+// families share one selector-source parser and one exact lowering mechanism.
+var amd64SegmentQuerySpecs = map[Op]amd64SegmentQuerySpec{
+	"LARW": {kind: amd64SegmentQueryAccessRights, bits: 16},
+	"LARL": {kind: amd64SegmentQueryAccessRights, bits: 32},
+	"LARQ": {kind: amd64SegmentQueryAccessRights, bits: 64},
+	"LSLW": {kind: amd64SegmentQueryLimit, bits: 16},
+	"LSLL": {kind: amd64SegmentQueryLimit, bits: 32},
+	"LSLQ": {kind: amd64SegmentQueryLimit, bits: 64},
+	"VERR": {kind: amd64SegmentQueryReadable},
+	"VERW": {kind: amd64SegmentQueryWritable},
+}
+
+type amd64SegmentQueryForm struct {
+	spec        amd64SegmentQuerySpec
+	selector    Operand
+	destination Reg
+}
+
+func (c *amd64Ctx) lowerSegmentQuery(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86SegmentQueryProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return c.emitSegmentQuery(ins, form)
+}
+
+func (c *amd64Ctx) emitSegmentQuery(ins Instr, form amd64SegmentQueryForm) (bool, bool, error) {
+	spec := form.spec
+	selector, err := c.evalSegmentQuerySelector(ins, form.selector)
+	if err != nil {
+		return true, false, err
+	}
+	if spec.bits == 0 {
+		mnemonic := "verr"
+		if spec.kind == amd64SegmentQueryWritable {
+			mnemonic = "verw"
+		}
+		status := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i8 asm sideeffect %q, %q(i16 %s)\n",
+			status, mnemonic+" $1; sete $0", "=q,r,~{dirflag},~{fpsr},~{flags}", selector)
+		c.storeSegmentQueryZF("%" + status)
+		return true, false, nil
+	}
+
+	// A query can fail without writing its destination. Retain the whole
+	// native GP carrier in the tied operand, rather than unconditionally
+	// zero-extending an i32 result after a failed LARL/LSLL. The actual opcode
+	// determines the physical upper-half behavior on this processor.
+	typ, destination := I64, "$0"
+	if c.goarch == "386" {
+		typ = I32
+	}
+	if spec.bits == 16 {
+		destination = "${0:w}"
+	} else if spec.bits == 32 {
+		destination = "${0:k}"
+	}
+	previousDestination, err := c.evalIntSized(Operand{Kind: OpReg, Reg: form.destination}, typ)
+	if err != nil {
+		return true, false, err
+	}
+
+	// Intel specifies that a failed descriptor check clears ZF but leaves the
+	// destination unchanged. Constraint 0 therefore ties the old destination
+	// value to the result instead of declaring a write-only output. SETE does
+	// not alter flags, so the second result captures the instruction's ZF while
+	// the translator's other virtual flag slots remain unchanged.
+	result := c.newTmp()
+	mnemonic := "lar"
+	if spec.kind == amd64SegmentQueryLimit {
+		mnemonic = "lsl"
+	}
+	width := map[int]string{16: "w", 32: "l", 64: "q"}[spec.bits]
+	assembly := mnemonic + width + " $3, " + destination + "; sete $1"
+	fmt.Fprintf(c.b, "  %%%s = call { %s, i8 } asm sideeffect %q, %q(%s %s, i16 %s)\n",
+		result, typ, assembly, "=r,=q,0,r,~{dirflag},~{fpsr},~{flags}", typ, previousDestination, selector)
+	value := c.newTmp()
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i8 } %%%s, 0\n", value, typ, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { %s, i8 } %%%s, 1\n", status, typ, result)
+	c.storeSegmentQueryZF("%" + status)
+	if err := c.storeRegSized(form.destination, typ, "%"+value); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
+
+func (c *amd64Ctx) evalSegmentQuerySelector(ins Instr, selector Operand) (string, error) {
+	if selector.Kind == OpFP && x86ResultNamedPredicateInstruction(ins) {
+		if value, handled, err := c.loadIntegerFPBytesMode(selector.FPOffset, I16, true); handled || err != nil {
+			return value, err
+		}
+	}
+	// Share the exact unaligned volatile scalar emitter. This is a two-byte
+	// read even for Q spellings and dead results; it creates no backing fact.
+	return c.evalSizedNativeGPSource(selector, I16, ins.x86AddressBits)
+}
+
+func (c *amd64Ctx) storeSegmentQueryZF(status string) {
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %s, 0\n", zero, status)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+}
diff --git a/amd64_lower_segment_query_test.go b/amd64_lower_segment_query_test.go
new file mode 100644
index 000000000..7d23e8780
--- /dev/null
+++ b/amd64_lower_segment_query_test.go
@@ -0,0 +1,289 @@
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64SegmentQueryGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64SegmentQuerySpecs))
+	for op := range amd64SegmentQuerySpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{"LARL", "LARQ", "LARW", "LSLL", "LSLQ", "LSLW", "VERR", "VERW"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("segment-query grammar opcodes = %v, want %v", got, want)
+	}
+	for op, want := range map[Op]amd64SegmentQuerySpec{
+		"LARW": {kind: amd64SegmentQueryAccessRights, bits: 16},
+		"LARL": {kind: amd64SegmentQueryAccessRights, bits: 32},
+		"LARQ": {kind: amd64SegmentQueryAccessRights, bits: 64},
+		"LSLW": {kind: amd64SegmentQueryLimit, bits: 16},
+		"LSLL": {kind: amd64SegmentQueryLimit, bits: 32},
+		"LSLQ": {kind: amd64SegmentQueryLimit, bits: 64},
+		"VERR": {kind: amd64SegmentQueryReadable},
+		"VERW": {kind: amd64SegmentQueryWritable},
+	} {
+		if got := amd64SegmentQuerySpecs[op]; got != want {
+			t.Errorf("segment-query grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86SegmentQueryCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT segmentqueryforms(SB),$0-0
+	LARW AX, DX
+	LARW 2(BX), CX
+	LARL CX, AX
+	LARL 4(BX), DX
+	LSLW DX, CX
+	LSLW 6(BX), AX
+	LSLL AX, DX
+	LSLL 8(BX), CX
+`
+			if target.goarch == "386" {
+				source += "\tLARW AX, SP\n\tLARL AX, SP\n\tLSLW AX, SP\n\tLSLL AX, SP\n"
+			}
+			if target.goarch == "amd64" {
+				source += `	LARW R11, R12
+	LARW 10(R13), R14
+	LARQ R11, R12
+	LARQ 12(R13), R14
+	LSLW R11, R12
+	LSLW 14(R13), R14
+	LSLQ R11, R12
+	LSLQ 16(R13), R14
+`
+			}
+			source += "\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, signatures := x86UnboundVoidFormatSource(t, source, "segmentqueryforms", target.goarch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				x86SegmentQueryOriginalFormatRow)
+			compileLLVMToObject(t, llc, target.triple, "segment-query-"+target.name+".ll", "segment-query-"+target.name+".o", ir)
+		})
+	}
+}
+
+// The original Go Yrl format includes SP in mode32. This private object-only
+// carrier observes that physical destination through a virtual slot; the
+// unchanged original source still has Go objects and public Context checks.
+// It supplies no public stack, initialized input or native-entry contract.
+func x86SegmentQueryOriginalFormatRow(c *amd64Ctx, ins Instr) (bool, bool, error) {
+	form, known, err := x86SegmentQueryProperties(ins.Op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	previous := c.allowSPWrite
+	c.allowSPWrite = c.goarch == "386" && form.destination == SP
+	defer func() { c.allowSPWrite = previous }()
+	return c.lowerSegmentQuery(ins.Op, ins)
+}
+
+func TestTranslateX86SegmentQueryRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "LARW $1, AX"},
+		{goarch: "amd64", instruction: "LARL AX, (BX)"},
+		{goarch: "amd64", instruction: "LSLQ X0, AX"},
+		{goarch: "amd64", instruction: "LSLW AX, X0"},
+		{goarch: "amd64", instruction: "LARW.Z AX, DX"},
+		{goarch: "386", instruction: "LARQ AX, DX"},
+		{goarch: "386", instruction: "LSLQ AX, DX"},
+		{goarch: "386", instruction: "LARW R11, AX"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's segment-query tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateX86SegmentValidationCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			high := "DI"
+			if target.goarch == "amd64" {
+				high = "R11"
+			}
+			source := "TEXT segmentvalidationforms(SB),$0-0\n" +
+				"\tVERR AX\n\tVERR (BX)\n\tVERR " + high + "\n" +
+				"\tVERW DX\n\tVERW 2(BX)\n\tVERW " + high + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, signatures := x86UnboundVoidFormatSource(t, source, "segmentvalidationforms", target.goarch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerSegmentQuery(ins.Op, ins) })
+			compileLLVMToObject(t, llc, target.triple, "segment-validation-"+target.name+".ll", "segment-validation-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86SegmentValidationRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "VERR $1"},
+		{goarch: "amd64", instruction: "VERW X0"},
+		{goarch: "amd64", instruction: "VERR AX, DX"},
+		{goarch: "amd64", instruction: "VERW.Z AX"},
+		{goarch: "386", instruction: "VERR R11"},
+		{goarch: "386", instruction: "VERW (R11)"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's segment-validation table", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64SegmentQueryRuntimeSemantics(t *testing.T) {
+	if runtime.GOARCH != "amd64" {
+		// Rosetta advertises amd64 execution but raises SIGILL for LAR/LSL.
+		// Object compilation remains covered above; execute the architectural
+		// descriptor checks only on native amd64 hardware.
+		t.Skip("LAR/LSL runtime semantics require native amd64 hardware")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT segmentquerysemantics(SB),NOSPLIT,$0-16
+	MOVQ selector+0(FP), AX
+	MOVQ out+8(FP), DI
+	MOVQ $0x1122334455667788, CX
+	LARQ AX, CX
+	MOVQ CX, 0(DI)
+	SETEQ 8(DI)
+	MOVQ $0x2233445566778899, CX
+	XORQ AX, AX
+	LARQ AX, CX
+	MOVQ CX, 16(DI)
+	SETEQ 24(DI)
+	MOVQ selector+0(FP), AX
+	MOVQ $0x33445566778899aa, DX
+	LSLQ AX, DX
+	MOVQ DX, 32(DI)
+	SETEQ 40(DI)
+	MOVQ $0x445566778899aabb, DX
+	XORQ AX, AX
+	LSLQ AX, DX
+	MOVQ DX, 48(DI)
+	SETEQ 56(DI)
+	MOVQ selector+0(FP), AX
+	STC
+	VERR AX
+	SETEQ 57(DI)
+	SETCS 58(DI)
+	VERW AX
+	SETEQ 59(DI)
+	XORQ AX, AX
+	VERR AX
+	SETEQ 60(DI)
+	VERW AX
+	SETEQ 61(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"segmentquerysemantics": {
+			Name: "segmentquerysemantics", Args: []LLVMType{I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void segmentquerysemantics(uint64_t, uint8_t *);
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v; }
+int main(void) {
+  uint16_t cs;
+  uint8_t out[64] = {0};
+  __asm__ volatile ("mov %%cs,%0" : "=r"(cs));
+  segmentquerysemantics(cs, out);
+  if (out[8] != 1 || out[40] != 1) return 10;
+  if (out[24] != 0 || out[56] != 0) return 11;
+  if (load64(out + 16) != UINT64_C(0x2233445566778899)) return 12;
+  if (load64(out + 48) != UINT64_C(0x445566778899aabb)) return 13;
+  if (out[57] != 1 || out[58] != 1) return 14;
+  if (out[59] != 0 || out[60] != 0 || out[61] != 0) return 15;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "segment_query_semantics", triple, ir, mainC, nil)
+}
diff --git a/amd64_lower_segment_register.go b/amd64_lower_segment_register.go
new file mode 100644
index 000000000..99c3db24a
--- /dev/null
+++ b/amd64_lower_segment_register.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerSegmentRegisterMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	if (baseOp != "MOVW" && baseOp != "MOVL" && baseOp != "MOVQ") || len(ins.Args) != 2 {
+		return false, false, nil
+	}
+	sourceSegment := x86SegmentRegisterOperand(ins.Args[0])
+	destinationSegment := x86SegmentRegisterOperand(ins.Args[1])
+	if !sourceSegment && !destinationSegment {
+		return false, false, nil
+	}
+	if baseOp != "MOVW" {
+		return true, false, fmt.Errorf("%s segment-register moves use MOVW in Go 1.27's ymovtab: %q", c.goarch, ins.Raw)
+	}
+	if !x86SegmentMoveSuffixAccepted(rawOp) {
+		return true, false, fmt.Errorf("%s segment-register MOVW has an invalid x86 suffix: %q", c.goarch, ins.Raw)
+	}
+	if sourceSegment == destinationSegment {
+		return true, false, fmt.Errorf("%s MOVW segment-register form expects exactly one segment register: %q", c.goarch, ins.Raw)
+	}
+	if destinationSegment {
+		source := ins.Args[0]
+		if source.Kind == OpReg {
+			if !isX86YrlRegisterForArch(source.Reg, c.goarch) {
+				return true, false, fmt.Errorf("%s MOVW to a segment register expects a Yml source: %q", c.goarch, ins.Raw)
+			}
+		} else if !isAMD64MemoryOperand(source) {
+			return true, false, fmt.Errorf("%s MOVW to a segment register expects a Yml source: %q", c.goarch, ins.Raw)
+		}
+		value, err := c.evalIntSized(source, I16)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeX86SegmentSelector(ins.Args[1].Reg, value)
+	}
+
+	destination := ins.Args[1]
+	if destination.Kind == OpReg {
+		if !isX86YrlRegisterForArch(destination.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%s MOVW from a segment register expects a Yml destination: %q", c.goarch, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(destination) {
+		return true, false, fmt.Errorf("%s MOVW from a segment register expects a Yml destination: %q", c.goarch, ins.Raw)
+	}
+	call := c.loadX86SegmentSelector(ins.Args[0].Reg)
+	if destination.Kind == OpReg {
+		return true, false, c.storeRegSized(destination.Reg, I32, call)
+	}
+	selector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", selector, call)
+	return true, false, c.storeScalarIntegerOperand(destination, I16, "%"+selector)
+}
+
+func (c *amd64Ctx) loadX86SegmentSelector(segment Reg) string {
+	call := c.newTmp()
+	assembly := fmt.Sprintf("movl %%%s, ${0:k}", strings.ToLower(string(segment)))
+	fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n",
+		call, assembly, "=r,~{memory},~{dirflag},~{fpsr},~{flags}")
+	return "%" + call
+}
+
+func (c *amd64Ctx) storeX86SegmentSelector(segment Reg, selector string) error {
+	assembly := fmt.Sprintf("movw $0, %%%s", strings.ToLower(string(segment)))
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i16 %s)\n",
+		assembly, "r,~{memory},~{dirflag},~{fpsr},~{flags}", selector)
+	return nil
+}
+
+func x86SegmentMoveSuffixAccepted(rawOp string) bool {
+	if rawOp == "MOVW" {
+		return true
+	}
+	suffix := strings.TrimPrefix(rawOp, "MOVW.")
+	switch suffix {
+	case "Z", "SAE", "SAE.Z",
+		"RN_SAE", "RZ_SAE", "RD_SAE", "RU_SAE",
+		"RN_SAE.Z", "RZ_SAE.Z", "RD_SAE.Z", "RU_SAE.Z",
+		"BCST", "BCST.Z":
+		// Go 1.27's ymovtab path accepts every syntactically valid x86 suffix
+		// here and emits the same 8C/8E bytes. Preserve that compatibility.
+		return true
+	default:
+		return false
+	}
+}
+
+func x86SegmentRegisterOperand(operand Operand) bool {
+	if operand.Kind != OpReg {
+		return false
+	}
+	switch operand.Reg {
+	case ES, CS, SS, DS, FS, GS:
+		return true
+	default:
+		return false
+	}
+}
diff --git a/amd64_lower_segment_register_test.go b/amd64_lower_segment_register_test.go
new file mode 100644
index 000000000..bc933755b
--- /dev/null
+++ b/amd64_lower_segment_register_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86SegmentRegisterCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT segmentregisterforms(SB),$0-0\n")
+			for _, segment := range []string{"ES", "CS", "SS", "DS", "FS", "GS"} {
+				fmt.Fprintf(&source, "\tMOVW AX, %s\n", segment)
+				fmt.Fprintf(&source, "\tMOVW %s, AX\n", segment)
+				fmt.Fprintf(&source, "\tMOVW 8(BX), %s\n", segment)
+				fmt.Fprintf(&source, "\tMOVW %s, 16(BX)\n", segment)
+			}
+			for _, suffix := range []string{
+				"Z", "SAE", "SAE.Z",
+				"RN_SAE", "RZ_SAE", "RD_SAE", "RU_SAE",
+				"RN_SAE.Z", "RZ_SAE.Z", "RD_SAE.Z", "RU_SAE.Z",
+				"BCST", "BCST.Z",
+			} {
+				fmt.Fprintf(&source, "\tMOVW.%s AX, DS\n", suffix)
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"segmentregisterforms": {Name: "segmentregisterforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "segment-register-"+target.name+".ll", "segment-register-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86SegmentRegisterRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVL AX, DS",
+		"MOVQ AX, DS",
+		"MOVW AL, DS",
+		"MOVW X0, DS",
+		"MOVW DS, X0",
+		"MOVW DS, FS",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			for _, goarch := range []string{"386", "amd64"} {
+				requireX86GoAssemblerResult(t, goarch, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+				triple := "i386-unknown-linux-gnu"
+				if goarch == "amd64" {
+					triple = "x86_64-unknown-linux-gnu"
+				}
+				assertX86SegmentRegisterRejected(t, goarch, triple, instruction)
+			}
+		})
+	}
+}
+
+func assertX86SegmentRegisterRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's segment-register MOVW table for %s", instruction, goarch)
+	}
+}
+
+func TestX86SegmentRegistersDoNotShadowARM64Conditions(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT select(SB),$0-0\n\tCSEL CS, R11, R3, R3\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) < 2 || len(file.Funcs[0].Instrs[1].Args) != 4 {
+		t.Fatalf("unexpected ARM64 parse: %+v", file)
+	}
+	condition := file.Funcs[0].Instrs[1].Args[0]
+	if condition.Kind == OpReg {
+		t.Fatalf("ARM64 CS condition was parsed as an x86 segment register: %+v", condition)
+	}
+}
diff --git a/amd64_lower_set.go b/amd64_lower_set.go
new file mode 100644
index 000000000..5de63df9d
--- /dev/null
+++ b/amd64_lower_set.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// lowerConditionalSet implements the complete Go 1.27 SETcc family. All 16
+// names use yscond, whose single operand is the byte-register-or-memory Ymb
+// class.
+func (c *amd64Ctx) lowerConditionalSet(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, recognized, err := x86ConditionalSetProperties(op, ins, c.goarch)
+	if !recognized {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	condition, err := c.x86Condition(form.condition)
+	if err != nil {
+		return true, false, err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i8 1, i8 0\n", value, condition)
+	if err := c.storeConditionalSetByte(form.destination, "%"+value); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
+
+func (c *amd64Ctx) storeConditionalSetByte(dst Operand, value string) error {
+	switch dst.Kind {
+	case OpReg:
+		return c.storeRegSized(dst.Reg, I8, value)
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile i8 %s, %s %s, align 1\n", value, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile i8 %s, ptr %s, align 1\n", value, ptr)
+		return nil
+	case OpFP:
+		return c.storeFPResult(dst.FPOffset, I8, value)
+	default:
+		return fmt.Errorf("expected Ymb destination, got %s", dst.String())
+	}
+}
diff --git a/amd64_lower_sha.go b/amd64_lower_sha.go
new file mode 100644
index 000000000..f723bbd05
--- /dev/null
+++ b/amd64_lower_sha.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerSHA(op Op, ins Instr) (bool, bool, error) {
+	f, known, err := x86SHAProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if c.fixedLocal == nil && len(c.fpResults) != 0 {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return true, false, err
+		}
+	}
+	state, err := c.loadPackedCompareLanes(ins.Args[f.destination], 16, 32, false)
+	if err != nil {
+		return true, false, err
+	}
+	args := "<4 x i32> " + state
+	implicit := ""
+	if f.encoding == 0x38cb {
+		implicit, err = c.loadPackedCompareLanes(ins.Args[0], 16, 32, false)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	call, result := c.newTmp(), c.newTmp()
+	name := strings.ToLower(string(f.op))
+	if f.memory >= 0 {
+		source := f.sourceOperand
+		if source.Kind == OpFP || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) ||
+			source.Kind == OpMem && !c.nativeMemoryOperand(ins, f.source) &&
+				!x86CallerMemoryCertified(ins, f.source) && !c.fixedLocalMemoryCertified(ins, f.source) {
+			return true, false, fmt.Errorf("%w: SHA m128 needs original native storage and x86 target", ErrProbeNeedsContext)
+		}
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return true, false, err
+		}
+		segment := ""
+		if pointerType == "ptr addrspace(256)" {
+			segment = "%gs:"
+		} else if pointerType == "ptr addrspace(257)" {
+			segment = "%fs:"
+		}
+		if f.encoding == 0x3acc {
+			name += fmt.Sprintf(" $$%d,", f.immediate)
+		}
+		assembly, constraints := name+" "+segment+"($2), $0", "=x,0,r"
+		args += fmt.Sprintf(", %s %s", pointerType, pointer)
+		if implicit != "" {
+			constraints += ",{xmm0}"
+			args += ", <4 x i32> " + implicit
+		}
+		// The actual Type 4 opcode retains m128 extent, alignment and faults,
+		// even when numerical dependencies or later dead code use fewer bytes.
+		fmt.Fprintf(c.b, "  %%%s = call <4 x i32> asm sideeffect %q, %q(%s)\n", call, assembly, constraints+",~{memory}", args)
+	} else {
+		source, err := c.loadPackedCompareLanes(f.sourceOperand, 16, 32, false)
+		if err != nil {
+			return true, false, err
+		}
+		args += ", <4 x i32> " + source
+		if implicit != "" {
+			args += ", <4 x i32> " + implicit
+		} else if f.encoding == 0x3acc {
+			args += fmt.Sprintf(", i8 %d", f.immediate)
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <4 x i32> @llvm.x86.%s(%s)\n", call, name, args)
+	}
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", result, call)
+	return true, false, c.storeLegacyPackedLogical(ins.Args[f.destination], "%"+result)
+}
+
+func emitX86SHADeclarations(b *strings.Builder, file *File) {
+	seen := make(map[Op]bool)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			op := Op(strings.ToUpper(string(ins.Op)))
+			encoding, known := x86SHAEncodings[op]
+			if !known || seen[op] {
+				continue
+			}
+			seen[op] = true
+			args := "<4 x i32>, <4 x i32>"
+			if encoding == 0x38cb {
+				args += ", <4 x i32>"
+			} else if encoding == 0x3acc {
+				args += ", i8 immarg"
+			}
+			fmt.Fprintf(b, "declare <4 x i32> @llvm.x86.%s(%s)\n", strings.ToLower(string(op)), args)
+		}
+	}
+}
diff --git a/amd64_lower_shiftrotate.go b/amd64_lower_shiftrotate.go
new file mode 100644
index 000000000..a997d325c
--- /dev/null
+++ b/amd64_lower_shiftrotate.go
@@ -0,0 +1,315 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerScalarShiftRotate implements the complete Go 1.27 yshb/yshl family:
+// RCL/RCR/ROL/ROR/SAR/SAL/SHL/SHR at B/W/L/Q widths, plus the special
+// three-operand SHL/SHR W/L/Q double-shift table.
+func (c *amd64Ctx) lowerScalarShiftRotate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	baseOp, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	_, _, recognized := amd64ScalarShiftRotateProperties(baseOp)
+	if !recognized {
+		return false, false, nil
+	}
+	form, _, err := x86ScalarShiftProperties(op, ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if form.double {
+		return c.lowerScalarDoubleShift(ins, form)
+	}
+	count, err := c.loadScalarShiftCount(form)
+	if err != nil {
+		return true, false, fmt.Errorf("%s %s count: %w", c.goarch, form.name, err)
+	}
+	ty := amd64IntegerTypeForBits(form.bits)
+	value, store, err := c.loadScalarShiftOperand(ins, form.destinationIndex, ty)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.stem == "RCL" || form.stem == "RCR" {
+		result = c.emitScalarCarryRotate(form.stem, form.bits, value, count)
+	} else {
+		result = c.emitScalarShiftRotate(form.stem, form.bits, value, count)
+		c.emitScalarShiftFlags(form.stem, form.bits, value, result, count, false)
+	}
+	if err := store(result); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
+
+func amd64ScalarShiftRotateProperties(op string) (stem string, bits int, ok bool) {
+	switch op {
+	case "RCLB", "RCRB", "ROLB", "RORB", "SARB", "SALB", "SHLB", "SHRB":
+		bits = 8
+	case "RCLW", "RCRW", "ROLW", "RORW", "SARW", "SALW", "SHLW", "SHRW":
+		bits = 16
+	case "RCLL", "RCRL", "ROLL", "RORL", "SARL", "SALL", "SHLL", "SHRL":
+		bits = 32
+	case "RCLQ", "RCRQ", "ROLQ", "RORQ", "SARQ", "SALQ", "SHLQ", "SHRQ":
+		bits = 64
+	default:
+		return "", 0, false
+	}
+	return op[:len(op)-1], bits, true
+}
+
+func (c *amd64Ctx) emitScalarCarryRotate(stem string, bits int, value, count64 string) string {
+	// Model RCL/RCR as a rotate of the destination plus CF. Intel masks the
+	// count to five (six for Q) bits first; loadScalarShiftCount already did that.
+	// B/W then reduce it modulo 9/17, while L/Q values are already below 33/65.
+	totalBits := bits + 1
+	effective64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = urem i64 %s, %d\n", effective64, count64, totalBits)
+
+	wideType := LLVMType(fmt.Sprintf("i%d", totalBits))
+	valueWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", valueWide, amd64IntegerTypeForBits(bits), value, wideType)
+	oldCF := c.loadFlag(c.flagsCFSlot)
+	cfWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to %s\n", cfWide, oldCF, wideType)
+	cfHigh := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %d\n", cfHigh, wideType, cfWide, bits)
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", combined, wideType, valueWide, cfHigh)
+
+	toWideCount := func(value string) string {
+		converted := c.newTmp()
+		if totalBits <= 64 {
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", converted, value, wideType)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = zext i64 %s to %s\n", converted, value, wideType)
+		}
+		return "%" + converted
+	}
+	effective := toWideCount("%" + effective64)
+	inverseRaw := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i64 %d, %%%s\n", inverseRaw, totalBits, effective64)
+	inverse64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = urem i64 %%%s, %d\n", inverse64, inverseRaw, totalBits)
+	inverse := toWideCount("%" + inverse64)
+
+	left := c.newTmp()
+	right := c.newTmp()
+	if stem == "RCL" {
+		fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %s\n", left, wideType, combined, effective)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %s\n", right, wideType, combined, inverse)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %s\n", right, wideType, combined, effective)
+		fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %s\n", left, wideType, combined, inverse)
+	}
+	rotated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", rotated, wideType, left, right)
+
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, rotated, amd64IntegerTypeForBits(bits))
+	cfShifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n", cfShifted, wideType, rotated, bits)
+	newCF := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i1\n", newCF, wideType, cfShifted)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", newCF, c.flagsCFSlot)
+
+	// OF uses the masked count, not the modulo-9/17 count: e.g. RCLB $10
+	// rotates once but has undefined OF. A zero-bit carry rotation preserves
+	// old FLAGS; only the other count>1 arm chooses a new finite OF value.
+	msbShifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n", msbShifted, amd64IntegerTypeForBits(bits), result, bits-1)
+	msb := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i1\n", msb, amd64IntegerTypeForBits(bits), msbShifted)
+	definedOF := c.newTmp()
+	if stem == "RCL" {
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, %%%s\n", definedOF, msb, newCF)
+	} else {
+		nextShifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n", nextShifted, amd64IntegerTypeForBits(bits), result, bits-2)
+		nextMSB := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i1\n", nextMSB, amd64IntegerTypeForBits(bits), nextShifted)
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, %%%s\n", definedOF, msb, nextMSB)
+	}
+	multiple := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ugt i64 %s, 1\n", multiple, count64)
+	chosenOF := c.emitScalarShiftArchitecturalChoice(I1, "%"+multiple, "%"+definedOF)
+	nonzero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", nonzero, effective64)
+	oldOF := c.loadFlag(c.flagsOFSlot)
+	newOF := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %s, i1 %s\n", newOF, nonzero, chosenOF, oldOF)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", newOF, c.flagsOFSlot)
+	return "%" + result
+}
+
+// The complete typed grammar has already validated the original count. Loading
+// it does not change its numerical dependency or the hardware's five/six-bit mask.
+func (c *amd64Ctx) loadScalarShiftCount(form x86ScalarShiftForm) (string, error) {
+	if form.count.Kind == OpImm {
+		return fmt.Sprintf("%d", form.maskedCount()), nil
+	}
+	mask := int64(31)
+	if form.bits == 64 {
+		mask = 63
+	}
+	value, err := c.loadReg(form.count.Reg)
+	if err != nil {
+		return "", err
+	}
+	masked := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, value, mask)
+	return "%" + masked, nil
+}
+
+func (c *amd64Ctx) emitScalarShiftRotate(stem string, bits int, value, count64 string) string {
+	ty := amd64IntegerTypeForBits(bits)
+	amount64 := count64
+	if stem == "ROL" || stem == "ROR" {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, count64, bits-1)
+		amount64 = "%" + masked
+	}
+	amount := amount64
+	if bits != 64 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", truncated, amount64, ty)
+		amount = "%" + truncated
+	}
+
+	if stem == "ROL" || stem == "ROR" {
+		inverseNeg := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", inverseNeg, ty, amount)
+		inverse := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", inverse, ty, inverseNeg, bits-1)
+		left := c.newTmp()
+		right := c.newTmp()
+		if stem == "ROL" {
+			fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", left, ty, value, amount)
+			fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", right, ty, value, inverse)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", right, ty, value, amount)
+			fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", left, ty, value, inverse)
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", result, ty, left, right)
+		return "%" + result
+	}
+
+	inRange := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %d\n", inRange, count64, bits)
+	safe64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 %d\n", safe64, inRange, count64, bits-1)
+	safe := "%" + safe64
+	if bits != 64 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to %s\n", truncated, safe64, ty)
+		safe = "%" + truncated
+	}
+	shifted := c.newTmp()
+	switch stem {
+	case "SHL", "SAL":
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", shifted, ty, value, safe)
+	case "SHR":
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shifted, ty, value, safe)
+	case "SAR":
+		fmt.Fprintf(c.b, "  %%%s = ashr %s %s, %s\n", shifted, ty, value, safe)
+		return "%" + shifted
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s 0\n", result, inRange, ty, shifted, ty)
+	return "%" + result
+}
+
+func (c *amd64Ctx) lowerScalarDoubleShift(ins Instr, form x86ScalarShiftForm) (bool, bool, error) {
+	count, err := c.loadScalarShiftCount(form)
+	if err != nil {
+		return true, false, fmt.Errorf("%s %s count: %w", c.goarch, form.name, err)
+	}
+	bits := form.bits
+	ty := amd64IntegerTypeForBits(bits)
+	source, err := c.evalIntSized(form.source, ty)
+	if err != nil {
+		return true, false, err
+	}
+	destination, store, err := c.loadScalarShiftOperand(ins, form.destinationIndex, ty)
+	if err != nil {
+		return true, false, err
+	}
+
+	// W double shifts mask the hardware count to five bits. Keep the temporary
+	// arithmetic bounded, then replace only the ISA-undefined 17..31 output
+	// with one finite choice. No shift-by-width LLVM poison reaches a select.
+	effective64 := count
+	if bits == 16 {
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 15\n", masked, count)
+		effective64 = "%" + masked
+	}
+	effective := effective64
+	if bits != 64 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", truncated, effective64, ty)
+		effective = "%" + truncated
+	}
+	inverseNeg := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s 0, %s\n", inverseNeg, ty, effective)
+	inverse := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %d\n", inverse, ty, inverseNeg, bits-1)
+	first := c.newTmp()
+	second := c.newTmp()
+	if form.stem == "SHL" {
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", first, ty, destination, effective)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %%%s\n", second, ty, source, inverse)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", first, ty, destination, effective)
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %%%s\n", second, ty, source, inverse)
+	}
+	merged := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", merged, ty, first, second)
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, ty, effective)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %s, %s %%%s\n", result, zero, ty, destination, ty, merged)
+	value := "%" + result
+	if bits == 16 {
+		full := c.newTmp()
+		corrected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 16\n", full, count)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %s, i16 %s\n", corrected, full, source, value)
+		value = "%" + corrected
+		outside := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt i64 %s, 16\n", outside, count)
+		value = c.emitScalarShiftArchitecturalChoice(I16, "%"+outside, value)
+	}
+	c.emitScalarShiftFlags(form.stem, bits, destination, value, count, true)
+	if err := store(value); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
+
+func (c *amd64Ctx) storeScalarIntegerOperand(dst Operand, ty LLVMType, value string) error {
+	switch dst.Kind {
+	case OpReg:
+		return c.storeRegSized(dst.Reg, ty, value)
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store %s %s, %s %s, align 1\n", ty, value, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1\n", ty, value, ptr)
+		return nil
+	case OpFP:
+		return c.storeFPResult(dst.FPOffset, ty, value)
+	default:
+		return fmt.Errorf("expected GP register or memory destination, got %s", dst.String())
+	}
+}
diff --git a/amd64_lower_shuffle_blocks.go b/amd64_lower_shuffle_blocks.go
new file mode 100644
index 000000000..6c67632be
--- /dev/null
+++ b/amd64_lower_shuffle_blocks.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Complete E4NF data reads survive zero masks and dead results. The same
+// validated form supplies byte effects, result dependencies and lowering.
+func (c *amd64Ctx) lowerShuffle128BitBlocks(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86Shuffle128BitBlocksProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, form.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	readWidth := form.byteWidth
+	if form.memory >= 0 {
+		readWidth = form.memoryBytes
+	}
+	firstBytes, err := c.loadX86PackedShiftBytes(ins.Args[form.first], readWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.byteWidth * 8 / form.laneBits
+	var first string
+	if form.broadcast {
+		scalar := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", scalar, readWidth, firstBytes, form.laneBits)
+		first = amd64SplatInteger(c, lanes, form.laneBits, "%"+scalar)
+	} else {
+		first = c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.laneBits, firstBytes)
+	}
+	secondBytes, err := c.loadX86PackedShiftBytes(ins.Args[form.second], form.byteWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	second := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.laneBits, secondBytes)
+	result := c.emitShuffle128BitBlocks(lanes, form.laneBits, first, second, form.immediate)
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(ins.Args[form.destination], form.byteWidth, form.laneBits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.laneBits, result, form.byteWidth)
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitShuffle128BitBlocks(lanes, laneBits int, firstPlan9, secondPlan9 string, immediate uint8) string {
+	blockLanes := 128 / laneBits
+	blocks := lanes / blockLanes
+	indices := make([]string, 0, lanes)
+	for outputBlock := 0; outputBlock < blocks; outputBlock++ {
+		var sourceBlock int
+		secondOperandOffset := 0
+		if blocks == 2 {
+			sourceBlock = int(immediate>>outputBlock) & 1
+			if outputBlock == 1 {
+				secondOperandOffset = lanes
+			}
+		} else {
+			sourceBlock = int(immediate>>(2*outputBlock)) & 3
+			if outputBlock >= 2 {
+				secondOperandOffset = lanes
+			}
+		}
+		for lane := 0; lane < blockLanes; lane++ {
+			indices = append(indices, fmt.Sprintf("i32 %d", secondOperandOffset+sourceBlock*blockLanes+lane))
+		}
+	}
+	shuffled := c.newTmp()
+	// The second Plan 9 source is Intel SRC1 and therefore LLVM operand 0;
+	// the first Plan 9 (r/m) source is Intel SRC2 / LLVM operand 1.
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> %s, <%d x i32> <%s>\n",
+		shuffled, lanes, laneBits, secondPlan9, lanes, laneBits, firstPlan9, lanes, strings.Join(indices, ", "))
+	return "%" + shuffled
+}
diff --git a/amd64_lower_shuffle_blocks_test.go b/amd64_lower_shuffle_blocks_test.go
new file mode 100644
index 000000000..9bd161557
--- /dev/null
+++ b/amd64_lower_shuffle_blocks_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86Shuffle128BitBlocksCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 shares _yvshuff32x4 across the floating and integer D/Q
+	// spellings. It has Y/Z rows, an unsigned-byte immediate, optional K
+	// masking/.Z, and scalar broadcast from the first Plan 9 memory source.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ := 20
+			if target.goarch == "386" {
+				lastZ = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT shuffle128bitblockforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"VSHUFF32X4", "VSHUFF64X2", "VSHUFI32X4", "VSHUFI64X2"} {
+				fmt.Fprintf(&source, "\t%s $0, Y1, Y20, Y21\n", op)
+				fmt.Fprintf(&source, "\t%s $2, 8(AX), Y20, Y21\n", op)
+				fmt.Fprintf(&source, "\t%s $255, Z1, Z2, Z%d\n", op, lastZ)
+				fmt.Fprintf(&source, "\t%s.BCST $3, 40(AX), Z2, Z%d\n", op, lastZ)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s $4, Y1, Y20, K1, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z $5, Z1, Z20, K2, Z21\n", op)
+					fmt.Fprintf(&source, "\t%s.BCST.Z $6, 104(AX), Z20, K3, Z21\n", op)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			if target.goarch == "386" {
+				// Go's mode32 frontend rejects every original four-operand
+				// spelling here. Keep those source observations; they are
+				// neither numerical Context nor physical LLVM object passes.
+				goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source.String(), "", false)
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				count := 0
+				for _, instruction := range file.Funcs[0].Instrs {
+					if instruction.Op == OpTEXT || instruction.Op == OpRET {
+						continue
+					}
+					t.Run(fmt.Sprint("GoFrontendRejects/", count), func(t *testing.T) {
+						goAssemblerOracleOutput(t, "386", "TEXT ·rejected(SB),4,$0-0\n"+instruction.Raw+"\nRET\n", "", false)
+						_, known, err := x86Shuffle128BitBlocksProperties(instruction.Op, instruction, "386")
+						if !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Go-refused frontend arity became an input Context or accepted form", instruction.Raw, err)
+						}
+					})
+					count++
+				}
+				if count != 16 {
+					t.Fatal("original mode32 source directory changed", count)
+				}
+				return
+			}
+			ll := x86ElementPermuteUnboundFormatObject(t, source.String(), target.goarch, target.triple, 28, 0)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "shuffle-128-bit-blocks-"+target.name+".ll", "shuffle-128-bit-blocks-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86Shuffle128BitBlocksRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSHUFF64X2 $1, X0, X1, X2",
+		"VSHUFF64X2 $1, Y0, Z1, Z2",
+		"VSHUFF64X2 $1, Y0, (AX), Y2",
+		"VSHUFF64X2 $1, Y0, Y1, K0, Y2",
+		"VSHUFF64X2 $1, Y0, Y1, AX",
+		"VSHUFF64X2.Z $1, Y0, Y1, Y2",
+		"VSHUFF64X2.BCST $1, Y0, Y1, Y2",
+		"VSHUFF64X2.Z.BCST $1, (AX), Y1, K1, Y2",
+		"VSHUFF64X2 $256, Y0, Y1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86Shuffle128BitBlocksRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86Shuffle128BitBlocksRejected(t, "386", "i386-unknown-linux-gnu", "VSHUFF64X2 $1, Y0, Y1, K1, Y2")
+	assertX86Shuffle128BitBlocksRejected(t, "386", "i386-unknown-linux-gnu", "VSHUFF64X2 $1, Z0, Z1, Z8")
+}
+
+func assertX86Shuffle128BitBlocksRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VSHUFF/VSHUFI forms", instruction)
+	}
+}
diff --git a/amd64_lower_shuffle_bytes.go b/amd64_lower_shuffle_bytes.go
new file mode 100644
index 000000000..bb95781e5
--- /dev/null
+++ b/amd64_lower_shuffle_bytes.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import "fmt"
+
+// lowerPackedByteShuffle implements all Go 1.27 PSHUFB/VPSHUFB forms.
+// VPSHUFB applies the byte shuffle independently to each 128-bit lane; EVEX
+// writemasks operate at byte granularity.
+func (c *amd64Ctx) lowerPackedByteShuffle(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, known, err := x86ByteShuffleProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy byte shuffle m128 needs original native storage, not virtual FP/SP/BP", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	byteWidth := form.byteWidth
+	data, err := c.loadPackedCompareBytes(second, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.legacy && form.memory >= 0 {
+		// Keep the original opcode, including m128 alignment and dead faults.
+		// The portable E4NF reader alone cannot reproduce this legacy effect.
+		result, err = c.emitPackedBinaryNativeMemory(first, 8, data, "pshufb")
+	} else if ins.x86RIPLiteral && len(ins.x86RIPLiteralData) == byteWidth {
+		result = c.emitPackedByteShuffleLiteral(byteWidth, data, ins.x86RIPLiteralData)
+	} else {
+		// E4NF: all control bytes are read, even with a dead or zero-masked
+		// result. Reuse the exact full-tuple reader, not the E4 lane reader.
+		control, err := c.loadPackedUnpackSource(first, x86PackedUnpackForm{
+			x86PackedBinaryForm: form, spec: x86PackedUnpackSpec{laneBits: 8},
+		})
+		if err != nil {
+			return true, false, err
+		}
+		result = c.emitPackedByteShuffle(byteWidth, data, control)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old, err := c.loadPackedCompareBytes(destination, byteWidth)
+		if err != nil {
+			return true, false, err
+		}
+		result = amd64ApplyIntegerLaneMask(c, byteWidth, 8, result, old, mask, form.zeroing)
+	}
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, result)
+	}
+	return true, false, c.storePackedMoveOperand(destination, byteWidth, result)
+}
+
+func (c *amd64Ctx) emitPackedByteShuffleLiteral(byteWidth int, data string, control []byte) string {
+	indices := make([]int, byteWidth)
+	for index, selected := range control {
+		if selected&0x80 != 0 {
+			indices[index] = byteWidth // Select a zero from the second vector.
+		} else {
+			indices[index] = index/16*16 + int(selected&0x0f)
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> %s\n",
+		result, byteWidth, data, byteWidth, byteWidth, llvmI32Mask(indices))
+	return "%" + result
+}
+
+func (c *amd64Ctx) emitPackedByteShuffle(byteWidth int, data, control string) string {
+	if byteWidth == 16 {
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %s, <16 x i8> %s)\n", call, data, control)
+		return "%" + call
+	}
+
+	parts := make([]string, 0, byteWidth/16)
+	for lane := 0; lane < byteWidth/16; lane++ {
+		dataLane := c.newTmp()
+		controlLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> poison, <16 x i32> %s\n", dataLane, byteWidth, data, byteWidth, llvmI32RangeMask(lane*16, 16))
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> poison, <16 x i32> %s\n", controlLane, byteWidth, control, byteWidth, llvmI32RangeMask(lane*16, 16))
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %%%s, <16 x i8> %%%s)\n", call, dataLane, controlLane)
+		parts = append(parts, "%"+call)
+	}
+	partWidth := 16
+	for len(parts) > 1 {
+		combined := make([]string, 0, len(parts)/2)
+		for i := 0; i < len(parts); i += 2 {
+			joined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> %s\n", joined, partWidth, parts[i], partWidth, parts[i+1], partWidth*2, llvmI32RangeMask(0, partWidth*2))
+			combined = append(combined, "%"+joined)
+		}
+		parts = combined
+		partWidth *= 2
+	}
+	return parts[0]
+}
diff --git a/amd64_lower_shuffle_bytes_test.go b/amd64_lower_shuffle_bytes_test.go
new file mode 100644
index 000000000..5f2763e78
--- /dev/null
+++ b/amd64_lower_shuffle_bytes_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedByteShuffleCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 uses ymshufb for PSHUFB and _yvandnpd for VPSHUFB.
+	// The legacy instruction accepts X/m128, X. The vector instruction has
+	// VEX X/Y forms and EVEX X/Y/Z forms, including K1-K7 merge/zero masks.
+	// In 386 mode the Go frontend still exposes EVEX X/Y0-31 and Z0-7, but
+	// cannot express the four-operand mask rows.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			zLast := 21
+			vectorData, vectorDestination := 20, 21
+			if target.goarch == "386" {
+				legacyLast = 7
+				zLast = 7
+				vectorData, vectorDestination = 6, 7
+			}
+			var src strings.Builder
+			src.WriteString("TEXT packedbyteshuffleforms(SB),NOSPLIT,$0-0\n")
+			fmt.Fprintf(&src, "\tPSHUFB X0, X%d\n", legacyLast)
+			fmt.Fprintf(&src, "\tPSHUFB (AX), X%d\n", legacyLast)
+			for _, width := range []string{"X", "Y"} {
+				fmt.Fprintf(&src, "\tVPSHUFB %s0, %s1, %s2\n", width, width, width)
+				fmt.Fprintf(&src, "\tVPSHUFB (AX), %s%d, %s%d\n", width, vectorData, width, vectorDestination)
+			}
+			fmt.Fprintf(&src, "\tVPSHUFB Z0, Z1, Z%d\n", zLast)
+			fmt.Fprintf(&src, "\tVPSHUFB (AX), Z6, Z%d\n", zLast)
+			if target.goarch == "amd64" {
+				for _, width := range []string{"X", "Y", "Z"} {
+					fmt.Fprintf(&src, "\tVPSHUFB %s20, %s21, K1, %s22\n", width, width, width)
+					fmt.Fprintf(&src, "\tVPSHUFB.Z (AX), %s21, K2, %s22\n", width, width)
+				}
+			}
+			src.WriteString("\tRET\n")
+
+			file, err := Parse(ArchAMD64, src.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedbyteshuffleforms": {Name: "packedbyteshuffleforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-byte-shuffle-"+target.name+".ll", "packed-byte-shuffle-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedByteShuffleRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PSHUFB.Z X0, X1",
+		"PSHUFB X0",
+		"PSHUFB Y0, Y1",
+		"PSHUFB X0, (AX)",
+		"VPSHUFB X0, X1",
+		"VPSHUFB X0, Y1, Y2",
+		"VPSHUFB X0, X1, (AX)",
+		"VPSHUFB.BCST (AX), X1, X2",
+		"VPSHUFB.SAE X0, X1, X2",
+		"VPSHUFB.Z X0, X1, X2",
+		"VPSHUFB X0, X1, K0, X2",
+		"VPSHUFB X0, X1, K1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedByteShuffleRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+
+	for _, instruction := range []string{
+		"PSHUFB X8, X0",
+		"PSHUFB X0, X8",
+		"VPSHUFB Z8, Z0, Z1",
+		"VPSHUFB Z0, Z1, Z8",
+		"VPSHUFB X0, X1, K1, X2",
+		"VPSHUFB.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedByteShuffleRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedByteShuffleRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's ymshufb/_yvandnpd forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_shuffle_float.go b/amd64_lower_shuffle_float.go
new file mode 100644
index 000000000..c3d1aef69
--- /dev/null
+++ b/amd64_lower_shuffle_float.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import "fmt"
+
+// Every consumer shares the complete Go grammar and exact two-source selector.
+// Integer byte lanes preserve NaN payloads without creating FP/MXCSR effects.
+func (c *amd64Ctx) lowerPackedFloatShuffle(op Op, ins Instr) (bool, bool, error) {
+	f, known, err := x86PackedFloatShuffleProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.validateConflictFunnelMemory(ins, f.x86PackedBinaryForm); err != nil {
+		return true, false, err
+	}
+	first, second, destination := ins.Args[f.first], ins.Args[f.second], ins.Args[f.destination]
+	secondBytes, err := c.loadPackedCompareBytes(second, f.byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+	if f.legacy && f.memory >= 0 {
+		if first.Kind == OpFP || !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+			return true, false, fmt.Errorf("%w: legacy floating shuffle m128 needs its original native storage/target", ErrProbeNeedsContext)
+		}
+		lanes := c.bitcastVectorBytesToIntegerLanes(16, 128/f.bits, f.bits, secondBytes)
+		mnemonic := "shufps"
+		if f.bits == 64 {
+			mnemonic = "shufpd"
+		}
+		// Keep the complete original Type4 opcode and its RMW destination:
+		// align-1 loads do not reproduce legacy m128 alignment exceptions.
+		value, err := c.emitPackedBinaryNativeMemory(first, f.bits, lanes,
+			fmt.Sprintf("%s $$%d,", mnemonic, f.selector))
+		if err != nil {
+			return true, false, err
+		}
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <16 x i8>\n", bytes, 128/f.bits, f.bits, value)
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+bytes)
+	}
+	readWidth := f.byteWidth
+	if f.memory >= 0 {
+		readWidth = f.memoryBytes
+	}
+	// EVEX E4NF does not suppress faults. Even a zero mask, selected scalar
+	// or dead result retains this single full/broadcast unaligned read.
+	firstBytes, err := c.loadX86PackedShiftBytes(first, readWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	indices := make([]int, f.byteWidth)
+	width := f.byteWidth
+	if f.broadcast {
+		// Extend only the representation to a common shufflevector width;
+		// no additional memory byte or initialized input is introduced.
+		expanded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> %s\n",
+			expanded, readWidth, firstBytes, readWidth, width, llvmRepeatI8Mask(readWidth, width))
+		firstBytes = "%" + expanded
+	}
+	for output := range indices {
+		indices[output] = f.sourceByte(output)
+	}
+	shuffled := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> %s\n",
+		shuffled, width, firstBytes, width, secondBytes, width, llvmI32Mask(indices))
+	result := "%" + shuffled
+	if f.mask >= 0 {
+		mask, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := width * 8 / f.bits
+		computed := c.bitcastVectorBytesToIntegerLanes(width, lanes, f.bits, result)
+		old := "zeroinitializer"
+		if !f.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, width, f.bits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		masked := amd64ApplyIntegerLaneMask(c, lanes, f.bits, computed, old, mask, f.zeroing)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, f.bits, masked, width)
+		result = "%" + bytes
+	}
+	if f.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, result)
+	}
+	return true, false, c.storePackedMoveOperand(destination, width, result)
+}
+
+func amd64PackedFloatShuffleProperties(op string) (laneBits int, vector, ok bool) {
+	switch op {
+	case "SHUFPS":
+		return 32, false, true
+	case "SHUFPD":
+		return 64, false, true
+	case "VSHUFPS":
+		return 32, true, true
+	case "VSHUFPD":
+		return 64, true, true
+	default:
+		return 0, false, false
+	}
+}
+
+func amd64UnsignedImm8(arg Operand) (uint8, bool) {
+	if arg.Kind != OpImm || arg.Imm < 0 || arg.Imm > 255 {
+		return 0, false
+	}
+	return uint8(arg.Imm), true
+}
diff --git a/amd64_lower_shuffle_words.go b/amd64_lower_shuffle_words.go
new file mode 100644
index 000000000..8e1076d2e
--- /dev/null
+++ b/amd64_lower_shuffle_words.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Preserve the helper entry point while all dword/word/MMX siblings use one
+// complete grammar. Dispatch identity cannot grant a contradictory spelling.
+func (c *amd64Ctx) lowerPackedWordShuffle(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86ImmediateShuffleSpecs[Op(base)]; !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("immediate-shuffle dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86ImmediateShuffleProperties(ins, c.goarch)
+	if err != nil || !known {
+		return known, false, err
+	}
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	destination := ins.Args[form.destination]
+	if form.spec.legacy && !form.spec.mmx && form.memory >= 0 {
+		return true, false, c.lowerLegacyImmediateShuffleMemory(ins, form)
+	}
+	var source string
+	if form.spec.mmx {
+		source, err = c.loadPackedUnpackMMXSource(form.source, form.memoryBytes)
+		if err == nil {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <8 x i8>\n", value, source)
+			source = "%" + value
+		}
+	} else if form.broadcast {
+		bytes, loadErr := c.loadX86PackedShiftBytes(form.source, 4, true)
+		err = loadErr
+		if err == nil {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i8> %s, <4 x i8> zeroinitializer, <%d x i32> %s\n",
+				value, bytes, form.byteWidth, llvmRepeatI8Mask(4, form.byteWidth))
+			source = "%" + value
+		}
+	} else {
+		// E4NF/E4NF.nb does not suppress memory faults, even at K=0 or when
+		// the immediate selects only one lane. Keep the full read observable.
+		source, err = c.loadX86PackedShiftBytes(form.source, form.byteWidth, true)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	indices := make([]string, form.byteWidth)
+	for index := range indices {
+		// A broadcast has already expanded the m32 to full logical lanes.
+		if form.broadcast {
+			indices[index] = fmt.Sprintf("i32 %d", index)
+		} else {
+			indices[index] = fmt.Sprintf("i32 %d", form.sourceByte(index))
+		}
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> zeroinitializer, <%d x i32> <%s>\n",
+		value, form.byteWidth, source, form.byteWidth, form.byteWidth, strings.Join(indices, ", "))
+	result := "%" + value
+	if form.spec.mmx {
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i8> %s to i64\n", bits, result)
+		return true, false, c.storeReg(destination.Reg, "%"+bits)
+	}
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		laneBits := form.spec.laneBytes * 8
+		lanes := form.byteWidth / form.spec.laneBytes
+		computed := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, laneBits, result)
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, laneBits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		masked := amd64ApplyIntegerLaneMask(c, lanes, laneBits, computed, old, mask, form.zeroing)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, laneBits, masked, form.byteWidth)
+		result = "%" + bytes
+	}
+	if form.spec.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, result)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, result)
+}
+
+func amd64PackedWordShuffleRequiresEVEX(source, destination Operand, byteWidth int, masked bool) bool {
+	if byteWidth == 64 || masked {
+		return true
+	}
+	for _, operand := range []Operand{source, destination} {
+		if operand.Kind == OpReg {
+			index, ok := amd64VectorRegisterIndex(operand.Reg, byteWidth)
+			if !ok || index >= 16 {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Legacy m128 must retain the actual single SSE instruction's alignment and
+// fault behavior, not an align-1 LLVM read or a fabricated virtual FP buffer.
+func (c *amd64Ctx) lowerLegacyImmediateShuffleMemory(ins Instr, form x86ImmediateShuffleForm) error {
+	source := form.source
+	if source.Kind == OpFP || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		source.Kind == OpMem && !c.fixedLocalMemoryCertified(ins, form.memory) && !c.nativeMemoryOperand(ins, form.memory) {
+		return fmt.Errorf("%w: legacy immediate shuffle m128 needs original native backing/alignment", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	mnemonic := "pshufd"
+	if form.spec.laneBytes == 2 {
+		mnemonic = "pshuflw"
+		if form.spec.high {
+			mnemonic = "pshufhw"
+		}
+	}
+	value, bytes := c.newTmp(), c.newTmp()
+	assembly := fmt.Sprintf("%s $$%d, %s($1), $0", mnemonic, form.immediate, segment)
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(%s %s)\n",
+		value, assembly, "=x,r,~{memory}", pointerType, pointer)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <16 x i8>\n", bytes, value)
+	return c.storeLegacyPackedLogical(ins.Args[form.destination], "%"+bytes)
+}
diff --git a/amd64_lower_shuffle_words_test.go b/amd64_lower_shuffle_words_test.go
new file mode 100644
index 000000000..2bbf7254a
--- /dev/null
+++ b/amd64_lower_shuffle_words_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PackedWordShuffleCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			zLast := 31
+			if target.goarch == "386" {
+				legacyLast = 7
+				zLast = 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT packedwordshuffleforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"PSHUFHW", "PSHUFLW"} {
+				fmt.Fprintf(&source, "\t%s $0, X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s $255, 8(AX), X%d\n", op, legacyLast)
+			}
+			for _, op := range []string{"VPSHUFHW", "VPSHUFLW"} {
+				source.WriteString("\t" + op + " $-128, X0, X1\n")
+				source.WriteString("\t" + op + " $127, 8(AX), X1\n")
+				source.WriteString("\t" + op + " $255, Y0, Y1\n")
+				source.WriteString("\t" + op + " $1, 16(AX), Y2\n")
+				if target.goarch == "amd64" {
+					source.WriteString("\t" + op + " $2, X16, X31\n")
+				}
+				fmt.Fprintf(&source, "\t%s $3, Z0, Z%d\n", op, zLast)
+				if target.goarch == "amd64" {
+					source.WriteString("\t" + op + " $4, X20, K1, X21\n")
+					source.WriteString("\t" + op + ".Z $5, 24(AX), K2, Y22\n")
+					source.WriteString("\t" + op + " $6, Z16, K3, Z31\n")
+				}
+			}
+			source.WriteString("\tRET\n")
+			goAssemblerOracleOutput(t, target.goarch, strings.ReplaceAll(source.String(), "NOSPLIT", "4"), "", true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"packedwordshuffleforms": {Name: "packedwordshuffleforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-word-shuffle-"+target.name+".ll", "packed-word-shuffle-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PackedWordShuffleRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"PSHUFHW $-1, X0, X1",
+		"PSHUFLW $256, X0, X1",
+		"PSHUFHW $1, X16, X1",
+		"PSHUFLW $1, Y0, Y1",
+		"PSHUFHW.Z $1, X0, X1",
+		"PSHUFLW $1, X0, (AX)",
+		"VPSHUFHW $-129, X0, X1",
+		"VPSHUFLW $256, X0, X1",
+		"VPSHUFHW $-1, X16, X1",
+		"VPSHUFLW $-1, Z0, Z1",
+		"VPSHUFHW $1, X0, Y1",
+		"VPSHUFLW $1, X0, K0, X1",
+		"VPSHUFHW.Z $1, X0, X1",
+		"VPSHUFLW.BCST $1, (AX), X1",
+		"VPSHUFHW $1, X0, (AX)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedWordShuffleRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"PSHUFHW $1, X8, X0",
+		"PSHUFLW $1, X0, X8",
+		"VPSHUFHW $1, X0, K1, X1",
+		"VPSHUFLW.Z $1, X0, K1, X1",
+		"VPSHUFHW $1, Z8, Z0",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PackedWordShuffleRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86PackedWordShuffleRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err == nil {
+		_, err = Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       goarch,
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+	}
+	if err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's PSHUFHW/PSHUFLW tables for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_sqrt.go b/amd64_lower_sqrt.go
new file mode 100644
index 000000000..6bb745293
--- /dev/null
+++ b/amd64_lower_sqrt.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerSqrt(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86SqrtSpecFor(Op(base)); !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return true, false, fmt.Errorf("sqrt dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	f, _, err := x86SqrtProperties(ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if f.bits == 16 && !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return false, false, nil // Retain the existing cross-target numerical model.
+	}
+	if f.bits == 16 && f.scalar {
+		return true, false, c.emitNativeFP16ThreeOperand(ins, x86NativeFP16ThreeOperand{
+			byteWidth: 16, lanes: 1, memoryBytes: f.memoryBytes, second: f.second,
+			destination: f.destination, mask: f.mask,
+			controls: amd64FMA3Suffix{zeroing: f.zeroing, rounding: f.rounding},
+		})
+	}
+	if f.scalar {
+		return true, false, c.lowerScalarSqrt(ins, f)
+	}
+	if ins.Args[0].Kind == OpFP || ins.x86AddressBits != 0 || f.memory >= 0 &&
+		ins.Args[0].Kind == OpMem && !c.nativeMemoryOperand(ins, f.memory) {
+		return true, false, fmt.Errorf("%w: %s packed source lacks its original native memory binding", ErrProbeNeedsContext, op)
+	}
+	carrierBits := f.bits
+	if carrierBits == 16 {
+		carrierBits = 32 // Register bit carrier, not an arithmetic precision change.
+	}
+	return true, false, c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: f.byteWidth, sourceBytes: f.byteWidth, memoryBytes: f.memoryBytes,
+		outputBits: carrierBits, destination: f.destination, mask: f.mask, lanes: f.byteWidth * 8 / f.bits,
+		legacy: f.legacy, evex: x86SqrtNativeEVEX(ins, f), broadcast: f.broadcast, zeroing: f.zeroing,
+		rounding: f.rounding, mnemonic: strings.ToLower(base),
+	})
+}
+
+// Retain the actual scalar opcode even for dead results: default rounding,
+// DAZ/FTZ, exceptions and explicit ER+SAE are not pure llvm.sqrt semantics.
+// Masked source reads use the existing exact-width conditional load; the
+// native mask separately suppresses inactive arithmetic and its exceptions.
+func (c *amd64Ctx) lowerScalarSqrt(ins Instr, f x86FloatBinaryForm) error {
+	mask := ""
+	var err error
+	if f.mask >= 0 {
+		mask, err = c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return err
+		}
+	}
+	source, err := c.loadFloatBinaryScalar(ins.Args[0], f.bits, mask)
+	if err != nil {
+		return err
+	}
+	typ := amd64FloatingVectorType(128/f.bits, f.bits)
+	load := func(index int) (string, error) {
+		bytes, err := c.loadX(ins.Args[index].Reg)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", value, bytes, typ)
+		return "%" + value, nil
+	}
+	old := "zeroinitializer"
+	if f.legacy || mask != "" && !f.zeroing {
+		old, err = load(f.destination)
+		if err != nil {
+			return err
+		}
+	}
+	registerClass := "x"
+	if x86SqrtNativeEVEX(ins, f) {
+		registerClass = "v"
+	}
+	constraints := "=" + registerClass + ",0," + registerClass
+	args := fmt.Sprintf("%s %s, %s %s", typ, old, amd64FMA3LLVMType(1, f.bits), source)
+	operands, maskIndex := "$2, $0", 3
+	if !f.legacy {
+		upper, err := load(f.second)
+		if err != nil {
+			return err
+		}
+		constraints += "," + registerClass
+		args += ", " + typ + " " + upper
+		operands, maskIndex = "$2, $3, $0", 4
+	}
+	mnemonic, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	if x86SqrtNativeEVEX(ins, f) {
+		mnemonic = "{evex} " + mnemonic
+	}
+	assembly := mnemonic + " "
+	if f.rounding != "" {
+		assembly += "{" + strings.ToLower(strings.TrimSuffix(f.rounding, "_SAE")) + "-sae}, "
+	}
+	assembly += operands
+	if mask != "" {
+		assembly = fmt.Sprintf("kmovw ${%d:k}, %%k1; ", maskIndex) + assembly + " {%k1}"
+		if f.zeroing {
+			assembly += " {z}"
+		}
+		constraints += ",r,~{k1}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, typ, result)
+	if f.legacy {
+		return c.storeLegacyXViews(ins.Args[f.destination].Reg, "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[f.destination], 16, "%"+bytes)
+}
diff --git a/amd64_lower_sqrt_scalar_test.go b/amd64_lower_sqrt_scalar_test.go
new file mode 100644
index 000000000..566e6934f
--- /dev/null
+++ b/amd64_lower_sqrt_scalar_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86ScalarSqrtCompleteGo127Forms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT scalarsqrtforms(SB),$0-0\n")
+			for _, op := range []string{"VSQRTSS", "VSQRTSD"} {
+				fmt.Fprintf(&source, "\t%s X0, X1, X2\n", op)
+				fmt.Fprintf(&source, "\t%s 8(BX), X3, X4\n", op)
+				fmt.Fprintf(&source, "\t%s X29, X30, X31\n", op)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X5, X6, K1, X7\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 16(BX), X8, K2, X9\n", op)
+				}
+				for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					fmt.Fprintf(&source, "\t%s.%s X10, X11, X12\n", op, rounding)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.%s.Z X13, X14, K3, X15\n", op, rounding)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ll := x86SqrtOriginalFormatObjects(t, source.String(), "scalarsqrtforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalar-sqrt-"+target.name+".ll", "scalar-sqrt-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86ScalarSqrtRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VSQRTSS X0, X1",
+		"VSQRTSD X0, X1, X2, X3, X4",
+		"VSQRTSS Y0, X1, X2",
+		"VSQRTSD X0, Y1, X2",
+		"VSQRTSS X0, X1, K0, X2",
+		"VSQRTSD.Z X0, X1, X2",
+		"VSQRTSS.BCST 8(BX), X1, X2",
+		"VSQRTSD.SAE X0, X1, X2",
+		"VSQRTSS.RN_SAE 8(BX), X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+			assertX86ScalarSqrtRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86ScalarSqrtRejected(t, "386", "i386-unknown-linux-gnu", "VSQRTSS X0, X1, K1, X2")
+}
+
+func assertX86ScalarSqrtRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VSQRTSS/VSQRTSD _yvaddsd forms for %s", instruction, goarch)
+	}
+}
+
+func qualifyAMD64ScalarSqrtRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Skip("native AVX512 execution belongs to TestCrossLinuxRuntimeMatrixX86ScalarSqrtNativeSemantics")
+	}
+	x86ScalarSqrtNativeRuntime(t)
+}
+
+func x86ScalarSqrtNativeRuntime(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	ir, main := x86ScalarSqrtRuntimeFixture(t, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "scalar-sqrt", ir, main, level)
+		})
+	}
+}
+
+func TestX86ScalarSqrtNativeFixtureObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The original runtime fixture uses native qword parameters.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			ir, _ := x86ScalarSqrtRuntimeFixture(t, target.triple)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func x86ScalarSqrtRuntimeFixture(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	source := `
+TEXT scalarsqrt(SB),NOSPLIT,$0-64
+	MOVQ out+0(FP), AX
+	MOVQ source64+8(FP), BX
+	MOVQ passthrough64+16(FP), CX
+	MOVQ source32+24(FP), DX
+	MOVQ passthrough32+32(FP), SI
+	MOVQ old64+40(FP), DI
+	MOVQ old32+48(FP), R8
+	MOVQ mask+56(FP), R9
+	KMOVQ R9, K1
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VSQRTSD.RD_SAE X0, X1, X2
+	VMOVUPD X2, 0(AX)
+
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VSQRTSS.RU_SAE X0, X1, X2
+	VMOVUPS X2, 16(AX)
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DI), X4
+	VSQRTSD X0, X1, K1, X4
+	VMOVUPD X4, 32(AX)
+
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMOVUPS (R8), X4
+	VSQRTSS.Z X0, X1, K1, X4
+	VMOVUPS X4, 48(AX)
+	VZEROUPPER
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+		{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+		{Offset: 56, Type: I64, Index: 7, Field: -1},
+	}}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"scalarsqrt": {Name: "scalarsqrt", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+#include <xmmintrin.h>
+extern void scalarsqrt(uint8_t *, const double *, const double *, const float *, const float *, const double *, const float *, uint64_t);
+int main(void) {
+  double source64[2] = {9.0, 77.0};
+  const double passthrough64[2] = {100.0, 101.0};
+  float source32[4] = {16.0f, 17.0f, 18.0f, 19.0f};
+  const float passthrough32[4] = {200.0f, 201.0f, 202.0f, 203.0f};
+  const double old64[2] = {300.0, 301.0};
+  const float old32[4] = {400.0f, 401.0f, 402.0f, 403.0f};
+  union { uint8_t bytes[64]; double d64[8]; float f32[16]; } out = {0};
+  scalarsqrt(out.bytes, source64, passthrough64, source32, passthrough32, old64, old32, 0);
+  if (out.d64[0] != 3.0 || out.d64[1] != 101.0) return 1;
+  if (out.f32[4] != 4.0f || out.f32[5] != 201.0f || out.f32[6] != 202.0f || out.f32[7] != 203.0f) return 2;
+  if (out.d64[4] != 300.0 || out.d64[5] != 101.0) return 3;
+  if (out.f32[12] != 0.0f || out.f32[13] != 201.0f || out.f32[14] != 202.0f || out.f32[15] != 203.0f) return 4;
+  scalarsqrt(out.bytes, source64, passthrough64, source32, passthrough32, old64, old32, 1);
+  if (out.d64[4] != 3.0 || out.d64[5] != 101.0 || out.f32[12] != 4.0f || out.f32[13] != 201.0f) return 5;
+
+  source64[0] = 2.0;
+  source32[0] = 2.0f;
+  scalarsqrt(out.bytes, source64, passthrough64, source32, passthrough32, old64, old32, 1);
+  uint64_t down;
+  uint32_t up;
+  memcpy(&down, out.bytes, sizeof(down));
+  memcpy(&up, out.bytes + 16, sizeof(up));
+  if (down != UINT64_C(0x3ff6a09e667f3bcc) || up != UINT32_C(0x3fb504f4)) return 6;
+
+  unsigned saved = _mm_getcsr();
+  source64[0] = -1.0;
+  source32[0] = -1.0f;
+  _mm_setcsr(0x1f80);
+  scalarsqrt(out.bytes, source64, passthrough64, source32, passthrough32, old64, old32, 0);
+  unsigned inactive = _mm_getcsr();
+  _mm_setcsr(0x1f80);
+  scalarsqrt(out.bytes, source64, passthrough64, source32, passthrough32, old64, old32, 1);
+  unsigned active = _mm_getcsr();
+  _mm_setcsr(saved);
+  if ((inactive & 0x3f) != 0 || (active & 0x3f) != 1) return 7;
+  return 0;
+}
+`
+	return ll, mainC
+}
diff --git a/amd64_lower_stack_width.go b/amd64_lower_stack_width.go
new file mode 100644
index 000000000..25e4b1039
--- /dev/null
+++ b/amd64_lower_stack_width.go
@@ -0,0 +1,381 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64StackWidthMode uint8
+
+const (
+	amd64StackPushValue amd64StackWidthMode = iota
+	amd64StackPopValue
+	amd64StackPushFlags
+	amd64StackPopFlags
+)
+
+type amd64StackWidthSpec struct {
+	bits               int
+	mode               amd64StackWidthMode
+	segments           amd64StackSegmentSet
+	segmentNativeWidth bool
+}
+
+type amd64StackSegmentSet uint8
+
+const (
+	amd64StackSegmentES amd64StackSegmentSet = 1 << iota
+	amd64StackSegmentCS
+	amd64StackSegmentSS
+	amd64StackSegmentDS
+	amd64StackSegmentFS
+	amd64StackSegmentGS
+
+	amd64StackPushSegments = amd64StackSegmentES | amd64StackSegmentCS |
+		amd64StackSegmentSS | amd64StackSegmentDS | amd64StackSegmentFS |
+		amd64StackSegmentGS
+	amd64StackPopSegments  = amd64StackPushSegments &^ amd64StackSegmentCS
+	amd64StackLongSegments = amd64StackSegmentFS | amd64StackSegmentGS
+)
+
+// amd64StackWidthSpecs models the value/flags, push/pop, width, and segment-set
+// axes once for all Go x86 stack forms. Ordinary L spellings are 386-only and
+// ordinary Q spellings are amd64-only. Go's separate ymovtab accepts its listed
+// segment-register forms in both modes; L/Q use the target's native stack width.
+var amd64StackWidthSpecs = map[Op]amd64StackWidthSpec{
+	"PUSHW":  {bits: 16, mode: amd64StackPushValue, segments: amd64StackPushSegments},
+	"POPW":   {bits: 16, mode: amd64StackPopValue, segments: amd64StackPopSegments},
+	"PUSHL":  {bits: 32, mode: amd64StackPushValue, segments: amd64StackPushSegments, segmentNativeWidth: true},
+	"POPL":   {bits: 32, mode: amd64StackPopValue, segments: amd64StackPopSegments, segmentNativeWidth: true},
+	"PUSHQ":  {bits: 64, mode: amd64StackPushValue, segments: amd64StackLongSegments, segmentNativeWidth: true},
+	"POPQ":   {bits: 64, mode: amd64StackPopValue, segments: amd64StackLongSegments, segmentNativeWidth: true},
+	"PUSHFW": {bits: 16, mode: amd64StackPushFlags},
+	"POPFW":  {bits: 16, mode: amd64StackPopFlags},
+	"PUSHFL": {bits: 32, mode: amd64StackPushFlags},
+	"POPFL":  {bits: 32, mode: amd64StackPopFlags},
+	"PUSHFQ": {bits: 64, mode: amd64StackPushFlags},
+	"POPFQ":  {bits: 64, mode: amd64StackPopFlags},
+}
+
+// This describes Go's complete value/FLAGS operand grammar, independently of
+// a consumer's private-stack, segment-state or native-memory permissions.
+func x86StackWidthProperties(ins Instr, arch string) (amd64StackWidthSpec, bool, error) {
+	name := strings.ToUpper(string(ins.Op))
+	base := strings.SplitN(name, ".", 2)[0]
+	spec, known := amd64StackWidthSpecs[Op(base)]
+	if !known {
+		return spec, false, nil
+	}
+	fail := func() (amd64StackWidthSpec, bool, error) {
+		return spec, true, fmt.Errorf("%s invalid %s stack form: %q", arch, base, ins.Raw)
+	}
+	if name != base {
+		return fail()
+	}
+	flags := spec.mode == amd64StackPushFlags || spec.mode == amd64StackPopFlags
+	if flags {
+		if err := validateX86OrdinaryStackWidthMode(arch, base, spec.bits, ins); err != nil {
+			return spec, true, err
+		}
+		if len(ins.Args) != 0 {
+			return spec, true, fmt.Errorf("%s %s takes no operands: %q", arch, base, ins.Raw)
+		}
+		return spec, true, nil
+	}
+	if len(ins.Args) != 1 {
+		role := "src"
+		if spec.mode == amd64StackPopValue {
+			role = "dst"
+		}
+		return spec, true, fmt.Errorf("%s %s expects %s: %q", arch, base, role, ins.Raw)
+	}
+	arg := ins.Args[0]
+	if arg.Kind == OpImm && (arg.ImmRaw != "" || arg.ImmIsFloat || arg.Imm < -2147483648 || arg.Imm > 4294967295) {
+		return fail()
+	}
+	if x86SegmentRegisterOperand(arg) {
+		if !spec.segments.contains(arg.Reg) {
+			return fail()
+		}
+		return spec, true, nil
+	}
+	if err := validateX86OrdinaryStackWidthMode(arch, base, spec.bits, ins); err != nil {
+		return spec, true, err
+	}
+	if arg.Kind == OpReg {
+		if !isX86YrlRegisterForArch(arg.Reg, arch) {
+			return fail()
+		}
+	} else if !isAMD64MemoryOperand(arg) && !(spec.mode == amd64StackPushValue &&
+		(arg.Kind == OpImm || x86AbsoluteRelocationSource(arg, arch, spec.bits))) {
+		if spec.mode == amd64StackPopValue {
+			return spec, true, fmt.Errorf("%s %s expects reg/mem dst in the Yrl class: %q", arch, base, ins.Raw)
+		}
+		return fail()
+	}
+	if arg.Kind == OpMem && !x86MemoryRegistersValidForArch(arg.Mem, arch) {
+		return fail()
+	}
+	return spec, true, nil
+}
+
+func (c *amd64Ctx) lowerStackWidth(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, known, err := x86StackWidthProperties(ins, c.goarch); known && err != nil {
+		return true, false, err
+	}
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64StackWidthSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s has no suffixed form in Go 1.27: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	switch spec.mode {
+	case amd64StackPushFlags:
+		if err := c.validateOrdinaryStackWidthMode(baseOp, spec.bits, ins); err != nil {
+			return true, false, err
+		}
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+		}
+		value := c.packX86Flags()
+		if spec.bits != 64 {
+			value = c.truncI64(value, amd64StackLLVMType(spec.bits))
+		}
+		return true, false, c.pushStackWidth(spec.bits, value)
+	case amd64StackPopFlags:
+		if err := c.validateOrdinaryStackWidthMode(baseOp, spec.bits, ins); err != nil {
+			return true, false, err
+		}
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+		}
+		value, err := c.popStackWidth(spec.bits)
+		if err != nil {
+			return true, false, err
+		}
+		if spec.bits != 64 {
+			extended := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", extended, amd64StackLLVMType(spec.bits), value)
+			value = "%" + extended
+		}
+		c.unpackX86Flags(value, spec.bits)
+		return true, false, nil
+	case amd64StackPushValue, amd64StackPopValue:
+		if len(ins.Args) != 1 {
+			role := "src"
+			if spec.mode == amd64StackPopValue {
+				role = "dst"
+			}
+			return true, false, fmt.Errorf("%s %s expects %s: %q", c.goarch, baseOp, role, ins.Raw)
+		}
+	default:
+		panic("unknown x86 stack-width mode")
+	}
+
+	operand := ins.Args[0]
+	segmentStack := x86SegmentRegisterOperand(operand)
+	if segmentStack {
+		if !spec.segments.contains(operand.Reg) {
+			return true, false, fmt.Errorf("%s %s does not accept segment register %s in Go 1.27's ymovtab: %q", c.goarch, baseOp, operand.Reg, ins.Raw)
+		}
+		bits := spec.bits
+		if spec.segmentNativeWidth {
+			bits = c.x86NativeStackBits()
+		}
+		if spec.mode == amd64StackPushValue {
+			selector := c.loadX86SegmentSelector(operand.Reg)
+			value := selector
+			switch bits {
+			case 16:
+				narrow := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", narrow, selector)
+				value = "%" + narrow
+			case 32:
+			case 64:
+				wide := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, selector)
+				value = "%" + wide
+			default:
+				panic("invalid x86 segment stack width")
+			}
+			return true, false, c.pushStackWidth(bits, value)
+		}
+		value, err := c.popStackWidth(bits)
+		if err != nil {
+			return true, false, err
+		}
+		if bits != 16 {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc %s %s to i16\n", narrow, amd64StackLLVMType(bits), value)
+			value = "%" + narrow
+		}
+		return true, false, c.storeX86SegmentSelector(operand.Reg, value)
+	}
+	if err := c.validateOrdinaryStackWidthMode(baseOp, spec.bits, ins); err != nil {
+		return true, false, err
+	}
+	if spec.mode == amd64StackPushValue {
+		if operand.Kind == OpReg {
+			if !isX86YrlRegisterForArch(operand.Reg, c.goarch) {
+				return true, false, fmt.Errorf("%s %s source is outside Go 1.27's Yrl class: %q", c.goarch, baseOp, ins.Raw)
+			}
+		} else if operand.Kind != OpImm && !isAMD64MemoryOperand(operand) &&
+			!x86AbsoluteRelocationSource(operand, c.goarch, spec.bits) {
+			return true, false, fmt.Errorf("%s %s expects Yrl/memory/immediate src: %q", c.goarch, baseOp, ins.Raw)
+		}
+		if operand.Kind == OpMem && !x86MemoryRegistersValidForArch(operand.Mem, c.goarch) {
+			return true, false, fmt.Errorf("%s %s memory source uses an out-of-range address register: %q", c.goarch, baseOp, ins.Raw)
+		}
+		value, err := c.loadStackValue(operand, spec.bits)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.pushStackWidth(spec.bits, value)
+	}
+
+	if operand.Kind == OpReg {
+		if !isX86YrlRegisterForArch(operand.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%s %s destination is outside Go 1.27's Yrl class: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(operand) {
+		return true, false, fmt.Errorf("%s %s expects reg/mem dst in the Yrl class: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if operand.Kind == OpMem && !x86MemoryRegistersValidForArch(operand.Mem, c.goarch) {
+		return true, false, fmt.Errorf("%s %s memory destination uses an out-of-range address register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	value, err := c.popStackWidth(spec.bits)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.storeStackWidth(operand, spec.bits, value)
+}
+
+func (c *amd64Ctx) validateOrdinaryStackWidthMode(op string, bits int, ins Instr) error {
+	return validateX86OrdinaryStackWidthMode(c.goarch, op, bits, ins)
+}
+
+func validateX86OrdinaryStackWidthMode(arch, op string, bits int, ins Instr) error {
+	if arch == "386" && bits == 64 {
+		return fmt.Errorf("386 %s requires GOARCH=amd64: %q", op, ins.Raw)
+	}
+	if arch != "386" && bits == 32 {
+		return fmt.Errorf("%s requires GOARCH=386: %q", op, ins.Raw)
+	}
+	return nil
+}
+
+func (c *amd64Ctx) x86NativeStackBits() int {
+	if c.goarch == "386" {
+		return 32
+	}
+	return 64
+}
+
+func (set amd64StackSegmentSet) contains(reg Reg) bool {
+	var bit amd64StackSegmentSet
+	switch reg {
+	case ES:
+		bit = amd64StackSegmentES
+	case CS:
+		bit = amd64StackSegmentCS
+	case SS:
+		bit = amd64StackSegmentSS
+	case DS:
+		bit = amd64StackSegmentDS
+	case FS:
+		bit = amd64StackSegmentFS
+	case GS:
+		bit = amd64StackSegmentGS
+	default:
+		return false
+	}
+	return set&bit != 0
+}
+
+func amd64StackLLVMType(bits int) LLVMType {
+	switch bits {
+	case 16:
+		return I16
+	case 32:
+		return I32
+	case 64:
+		return I64
+	default:
+		panic("invalid x86 stack width")
+	}
+}
+
+func (c *amd64Ctx) pushStackWidth(bits int, value string) error {
+	if c.sourceStack != nil {
+		return c.pushSourceStackValue(amd64StackLLVMType(bits), int64(bits/8), value)
+	}
+	if c.goarch == "386" {
+		switch bits {
+		case 16:
+			return c.pushI16(value)
+		case 32:
+			return c.pushI32(value)
+		}
+		return fmt.Errorf("386 cannot push %d-bit stack values", bits)
+	}
+	if bits != 64 {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", extended, amd64StackLLVMType(bits), value)
+		value = "%" + extended
+	}
+	c.pushI64(value)
+	return nil
+}
+
+func (c *amd64Ctx) popStackWidth(bits int) (string, error) {
+	if c.sourceStack != nil {
+		return c.popSourceStackValue(amd64StackLLVMType(bits), int64(bits/8))
+	}
+	if c.goarch == "386" {
+		switch bits {
+		case 16:
+			return c.popI16()
+		case 32:
+			return c.popI32()
+		}
+		return "", fmt.Errorf("386 cannot pop %d-bit stack values", bits)
+	}
+	value := c.popI64()
+	if bits == 64 {
+		return value, nil
+	}
+	return c.truncI64(value, amd64StackLLVMType(bits)), nil
+}
+
+func (c *amd64Ctx) storeStackWidth(destination Operand, bits int, value string) error {
+	typ := amd64StackLLVMType(bits)
+	switch destination.Kind {
+	case OpReg:
+		return c.storeRegSized(destination.Reg, typ, value)
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(destination.Mem)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(destination.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store volatile %s %s, ptr %s, align 1\n", typ, value, ptr)
+		return nil
+	case OpFP:
+		return c.storeFPResult(destination.FPOffset, typ, value)
+	default:
+		return fmt.Errorf("%s stack destination is not writable", destination.String())
+	}
+}
diff --git a/amd64_lower_stack_width_test.go b/amd64_lower_stack_width_test.go
new file mode 100644
index 000000000..4aff8002c
--- /dev/null
+++ b/amd64_lower_stack_width_test.go
@@ -0,0 +1,267 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64StackWidthGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64StackWidthSpec{
+		"PUSHW":  {bits: 16, mode: amd64StackPushValue, segments: amd64StackPushSegments},
+		"POPW":   {bits: 16, mode: amd64StackPopValue, segments: amd64StackPopSegments},
+		"PUSHL":  {bits: 32, mode: amd64StackPushValue, segments: amd64StackPushSegments, segmentNativeWidth: true},
+		"POPL":   {bits: 32, mode: amd64StackPopValue, segments: amd64StackPopSegments, segmentNativeWidth: true},
+		"PUSHQ":  {bits: 64, mode: amd64StackPushValue, segments: amd64StackLongSegments, segmentNativeWidth: true},
+		"POPQ":   {bits: 64, mode: amd64StackPopValue, segments: amd64StackLongSegments, segmentNativeWidth: true},
+		"PUSHFW": {bits: 16, mode: amd64StackPushFlags},
+		"POPFW":  {bits: 16, mode: amd64StackPopFlags},
+		"PUSHFL": {bits: 32, mode: amd64StackPushFlags},
+		"POPFL":  {bits: 32, mode: amd64StackPopFlags},
+		"PUSHFQ": {bits: 64, mode: amd64StackPushFlags},
+		"POPFQ":  {bits: 64, mode: amd64StackPopFlags},
+	}
+	if !reflect.DeepEqual(amd64StackWidthSpecs, want) {
+		t.Fatalf("stack-width grammar = %+v, want %+v", amd64StackWidthSpecs, want)
+	}
+}
+
+func TestTranslateX86StackWidthCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			high := "R11"
+			if target.goarch == "386" {
+				high = "DX"
+			}
+			source := "TEXT stackwidthforms(SB),$0-0\n" +
+				"\tPUSHW AX\n\tPOPW " + high + "\n" +
+				"\tPUSHW $61731\n\tPOPW (BX)\n" +
+				"\tPUSHW (BX)\n\tPOPW AX\n" +
+				"\tPUSHFW\n\tPOPFW\n"
+			if target.goarch == "amd64" {
+				source += "\tPUSHQ R11\n\tPOPQ (BX)\n\tPUSHQ FS\n\tPUSHQ GS\n\tPOPQ FS\n\tPOPQ GS\n\tPUSHFQ\n\tPOPFQ\n"
+			} else {
+				source += "\tPUSHL DX\n\tPOPL (BX)\n\tPUSHFL\n\tPOPFL\n"
+			}
+			source += "\tRET\n"
+
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func stackwidthforms()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original stack format source invented native/segment inputs", api, err)
+				}
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"stackwidthforms": {Name: "stackwidthforms", Ret: Void}},
+				target.goarch, target.triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86StackSegmentCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = `TEXT stacksegmentforms(SB),$0-0
+	PUSHW CS
+	PUSHW SS
+	PUSHW DS
+	PUSHW ES
+	PUSHW FS
+	PUSHW GS
+	POPW SS
+	POPW DS
+	POPW ES
+	POPW FS
+	POPW GS
+	PUSHL CS
+	PUSHL SS
+	PUSHL DS
+	PUSHL ES
+	PUSHL FS
+	PUSHL GS
+	POPL SS
+	POPL DS
+	POPL ES
+	POPL FS
+	POPL GS
+	PUSHQ FS
+	PUSHQ GS
+	POPQ FS
+	POPQ GS
+	POPW DS
+	POPL DS
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func stacksegmentforms()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original segment formats invented physical selector/stack state", api, err)
+				}
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"stacksegmentforms": {Name: "stacksegmentforms", Ret: Void}},
+				target.goarch, target.triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestTranslateX86StackWidthRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PUSHW X0"},
+		{goarch: "amd64", instruction: "POPW $1"},
+		{goarch: "amd64", instruction: "PUSHFW AX"},
+		{goarch: "amd64", instruction: "POPQ X0"},
+		{goarch: "amd64", instruction: "PUSHL AX"},
+		{goarch: "amd64", instruction: "PUSHQ DS"},
+		{goarch: "amd64", instruction: "POPQ ES"},
+		{goarch: "amd64", instruction: "POPW CS"},
+		{goarch: "amd64", instruction: "POPL CS"},
+		{goarch: "386", instruction: "PUSHQ AX"},
+		{goarch: "386", instruction: "POPW R11"},
+		{goarch: "386", instruction: "POPFQ"},
+		{goarch: "386", instruction: "PUSHQ DS"},
+		{goarch: "386", instruction: "POPQ ES"},
+		{goarch: "386", instruction: "POPW CS"},
+		{goarch: "386", instruction: "POPL CS"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's stack tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64StackWidthRuntimeValuesAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT stackwidthsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVW $0x1234, AX
+	PUSHW AX
+	POPW CX
+	MOVW CX, 0(DI)
+	MOVW $0x5678, 2(DI)
+	PUSHW 2(DI)
+	POPW DX
+	MOVW DX, 4(DI)
+	PUSHW $61731
+	POPW 6(DI)
+	MOVQ $0x123456789abcdef, AX
+	PUSHQ AX
+	POPQ 8(DI)
+	STC
+	PUSHFW
+	CLC
+	POPFW
+	SETCS 16(DI)
+	PUSHFQ
+	CLC
+	POPFQ
+	SETCS 17(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"stackwidthsemantics": {
+			Name: "stackwidthsemantics", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void stackwidthsemantics(uint8_t *);
+static uint16_t load16(const uint8_t *p) { uint16_t v; memcpy(&v,p,2); return v; }
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v,p,8); return v; }
+int main(void) {
+  uint8_t out[24] = {0}; stackwidthsemantics(out);
+  if (load16(out) != 0x1234 || load16(out+4) != 0x5678 || load16(out+6) != 61731) return 10;
+  if (load64(out+8) != UINT64_C(0x123456789abcdef)) return 11;
+  if (out[16] != 1 || out[17] != 1) return 12;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "stack_width_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_string.go b/amd64_lower_string.go
index 5ae46f59d..baadf7072 100644
--- a/amd64_lower_string.go
+++ b/amd64_lower_string.go
@@ -1,50 +1,45 @@
 package plan9asm
 
-import "fmt"
+import (
+	"fmt"
+)
 
-func (c *amd64Ctx) lowerString(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	if c.goarch != "386" {
+func (c *amd64Ctx) lowerString(ins Instr) (ok bool, terminated bool, err error) {
+	form, ok, err := x86StringInstructionProperties(ins, c.goarch)
+	if !ok {
 		return false, false, nil
 	}
-	switch op {
-	case "MOVSB", "MOVSL", "STOSL", "SCASB":
-	default:
-		return false, false, nil
+	if form.kind == "" {
+		return true, false, err
 	}
-
+	// Preserve the existing consumption order: a malformed opcode suffix has
+	// not consumed a prefix; mode/operand rejection after a valid head has.
 	prefix := c.repeatPrefix
 	c.repeatPrefix = ""
-	if len(ins.Args) != 0 {
-		return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
-	}
-	repeated := prefix != ""
-	if prefix == "REPN" && op != "SCASB" {
-		return true, false, fmt.Errorf("386 REPN is unsupported for %s", op)
-	}
-	if prefix == "REP" && op == "SCASB" {
-		return true, false, fmt.Errorf("386 REP SCASB is not yet supported")
+	if err != nil {
+		return true, false, err
 	}
+	kind, typ, width := form.kind, form.typ, form.width
 
 	count := "1"
-	if repeated {
-		cx32, err := c.evalIntSized(Operand{Kind: OpReg, Reg: CX}, I32)
+	if prefix != "" {
+		cx, err := c.loadReg(CX)
 		if err != nil {
 			return true, false, err
 		}
-		wide := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, cx32)
-		count = "%" + wide
+		if c.goarch == "386" {
+			cx32 := c.truncI64(cx, I32)
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, cx32)
+			count = "%" + wide
+		} else {
+			count = cx
+		}
 	}
 	direction := c.loadDirectionFlag()
 
-	switch op {
-	case "MOVSB", "MOVSL":
-		width := 1
-		helper := "__plan9asm_movsb"
-		if op == "MOVSL" {
-			width = 4
-			helper = "__plan9asm_movsl"
-		}
+	switch kind {
+	case "movs":
 		si, err := c.loadReg(SI)
 		if err != nil {
 			return true, false, err
@@ -53,7 +48,7 @@ func (c *amd64Ctx) lowerString(op Op, ins Instr) (ok bool, terminated bool, err
 		if err != nil {
 			return true, false, err
 		}
-		fmt.Fprintf(c.b, "  call void @%s(i64 %s, i64 %s, i64 %s, i1 %s)\n", helper, di, si, count, direction)
+		fmt.Fprintf(c.b, "  call void @%s(i64 %s, i64 %s, i64 %s, i1 %s)\n", x86StringHelperName(kind, width), di, si, count, direction)
 		bytes := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %d\n", bytes, count, width)
 		if err := c.storeStringIndex(SI, si, "%"+bytes, direction); err != nil {
@@ -63,67 +58,186 @@ func (c *amd64Ctx) lowerString(op Op, ins Instr) (ok bool, terminated bool, err
 			return true, false, err
 		}
 
-	case "STOSL":
+	case "stos":
 		di, err := c.loadReg(DI)
 		if err != nil {
 			return true, false, err
 		}
-		ax, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, I32)
+		value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, typ)
 		if err != nil {
 			return true, false, err
 		}
-		fmt.Fprintf(c.b, "  call void @__plan9asm_rep_stosl(i64 %s, i32 %s, i64 %s, i1 %s)\n", di, ax, count, direction)
+		fmt.Fprintf(c.b, "  call void @%s(i64 %s, %s %s, i64 %s, i1 %s)\n", x86StringHelperName(kind, width), di, typ, value, count, direction)
 		bytes := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, 4\n", bytes, count)
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %d\n", bytes, count, width)
 		if err := c.storeStringIndex(DI, di, "%"+bytes, direction); err != nil {
 			return true, false, err
 		}
 
-	case "SCASB":
+	case "scas":
 		di, err := c.loadReg(DI)
 		if err != nil {
 			return true, false, err
 		}
-		needle, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AL}, I8)
+		needle, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, typ)
 		if err != nil {
 			return true, false, err
 		}
+		whileEqual := prefix == "REP"
+		resultType := fmt.Sprintf("{ i64, i64, %s, i1 }", typ)
 		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call { i64, i64, i1 } @__plan9asm_repne_scasb(i64 %s, i8 %s, i64 %s, i1 %s)\n", call, di, needle, count, direction)
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(i64 %s, %s %s, i64 %s, i1 %s, i1 %t)\n", call, resultType, x86StringHelperName(kind, width), di, typ, needle, count, direction, whileEqual)
 		next := c.newTmp()
 		remaining := c.newTmp()
-		equal := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i64, i1 } %%%s, 0\n", next, call)
-		fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i64, i1 } %%%s, 1\n", remaining, call)
-		fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i64, i1 } %%%s, 2\n", equal, call)
+		lastValue := c.newTmp()
+		executed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", next, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", remaining, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 2\n", lastValue, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 3\n", executed, resultType, call)
 		if err := c.storeReg(DI, "%"+next); err != nil {
 			return true, false, err
 		}
-		zf := "%" + equal
-		if repeated {
-			oldZF := c.loadFlag(c.flagsZSlot)
-			executed := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %s, 0\n", executed, count)
-			preserved := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %%%s, i1 %s\n", preserved, executed, equal, oldZF)
-			zf = "%" + preserved
+		// SCAS sets all six status flags from accumulator minus the last
+		// element read, not just the equality flag used to control repetition.
+		c.setStringCompareFlags(typ, needle, "%"+lastValue, "%"+executed, prefix != "")
+		if prefix != "" {
+			if err := c.storeStringCount("%" + remaining); err != nil {
+				return true, false, err
+			}
 		}
-		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", zf, c.flagsZSlot)
-		if repeated {
-			if err := c.storeRegSized(CX, I32, c.truncI64("%"+remaining, I32)); err != nil {
+
+	case "cmps":
+		si, err := c.loadReg(SI)
+		if err != nil {
+			return true, false, err
+		}
+		di, err := c.loadReg(DI)
+		if err != nil {
+			return true, false, err
+		}
+		whileEqual := prefix == "REP"
+		resultType := fmt.Sprintf("{ i64, i64, i64, %s, %s, i1 }", typ, typ)
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(i64 %s, i64 %s, i64 %s, i1 %s, i1 %t)\n", call, resultType, x86StringHelperName(kind, width), si, di, count, direction, whileEqual)
+		nextSI := c.newTmp()
+		nextDI := c.newTmp()
+		remaining := c.newTmp()
+		left := c.newTmp()
+		right := c.newTmp()
+		executed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", nextSI, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", nextDI, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 2\n", remaining, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 3\n", left, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 4\n", right, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 5\n", executed, resultType, call)
+		if err := c.storeReg(SI, "%"+nextSI); err != nil {
+			return true, false, err
+		}
+		if err := c.storeReg(DI, "%"+nextDI); err != nil {
+			return true, false, err
+		}
+		if prefix != "" {
+			if err := c.storeStringCount("%" + remaining); err != nil {
+				return true, false, err
+			}
+		}
+		c.setStringCompareFlags(typ, "%"+left, "%"+right, "%"+executed, prefix != "")
+
+	case "lods":
+		si, err := c.loadReg(SI)
+		if err != nil {
+			return true, false, err
+		}
+		resultType := fmt.Sprintf("{ i64, i64, %s, i1 }", typ)
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @%s(i64 %s, i64 %s, i1 %s)\n", call, resultType, x86StringHelperName(kind, width), si, count, direction)
+		nextSI := c.newTmp()
+		remaining := c.newTmp()
+		loaded := c.newTmp()
+		executed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", nextSI, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", remaining, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 2\n", loaded, resultType, call)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 3\n", executed, resultType, call)
+		if err := c.storeReg(SI, "%"+nextSI); err != nil {
+			return true, false, err
+		}
+		var oldAccumulator string
+		if prefix != "" {
+			old, err := c.loadReg(AX)
+			if err != nil {
+				return true, false, err
+			}
+			oldAccumulator = old
+		}
+		if err := c.storeRegSized(AX, typ, "%"+loaded); err != nil {
+			return true, false, err
+		}
+		if prefix != "" {
+			written, err := c.loadReg(AX)
+			if err != nil {
+				return true, false, err
+			}
+			// An empty repeat executes no accumulator write at all. Selecting
+			// only the low operand width before storeRegSized would still clear
+			// AMD64's high 32 bits for LODSL even on that empty path.
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %s, i64 %s\n", selected, executed, written, oldAccumulator)
+			if err := c.storeReg(AX, "%"+selected); err != nil {
+				return true, false, err
+			}
+			if err := c.storeStringCount("%" + remaining); err != nil {
 				return true, false, err
 			}
 		}
 	}
 
-	if repeated && op != "SCASB" {
-		if err := c.storeRegSized(CX, I32, "0"); err != nil {
+	if prefix != "" && kind != "scas" && kind != "cmps" {
+		if err := c.storeStringCount("0"); err != nil {
 			return true, false, err
 		}
 	}
 	return true, false, nil
 }
 
+func x86StringHelperName(kind string, width int) string {
+	suffix := map[int]string{1: "b", 2: "w", 4: "l", 8: "q"}[width]
+	if kind == "movs" {
+		return "__plan9asm_movs" + suffix
+	}
+	return "__plan9asm_rep_" + kind + suffix
+}
+
+func (c *amd64Ctx) setStringCompareFlags(typ LLVMType, left, right, executed string, preserveEmpty bool) {
+	flags := c.x86StatusFlagSlots()
+	old := make([]string, len(flags))
+	if preserveEmpty {
+		for index, flag := range flags {
+			old[index] = c.loadFlag(flag.slot)
+		}
+	}
+	c.setCmpFlagsSized(typ, left, right)
+	if preserveEmpty {
+		// REP/REPN with a zero initial count performs no comparison and
+		// preserves all six status flags. The helper also performs no load.
+		for index, flag := range flags {
+			current := c.loadFlag(flag.slot)
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i1 %s, i1 %s\n", selected, executed, current, old[index])
+			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", selected, flag.slot)
+		}
+	}
+}
+
+func (c *amd64Ctx) storeStringCount(value string) error {
+	if c.goarch == "386" {
+		return c.storeRegSized(CX, I32, c.truncI64(value, I32))
+	}
+	return c.storeRegSized(CX, I64, value)
+}
+
 func (c *amd64Ctx) loadDirectionFlag() string {
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", t, c.directionSlot)
diff --git a/amd64_lower_string_compare.go b/amd64_lower_string_compare.go
new file mode 100644
index 000000000..754321be4
--- /dev/null
+++ b/amd64_lower_string_compare.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedStringCompareSpec struct {
+	explicitLength bool
+	maskResult     bool
+	vector         bool
+}
+
+// amd64PackedStringCompareSpecs models Go 1.27's complete SSE4.2 packed-string
+// grammar as three independent axes: explicit/implicit lengths, index/mask
+// result, and legacy/VEX encoding. Every spelling shares the same imm8 and
+// X/m128 operand grammar and the same six architectural flag results.
+var amd64PackedStringCompareSpecs = map[Op]amd64PackedStringCompareSpec{
+	"PCMPESTRI":  {explicitLength: true},
+	"PCMPESTRM":  {explicitLength: true, maskResult: true},
+	"PCMPISTRI":  {},
+	"PCMPISTRM":  {maskResult: true},
+	"VPCMPESTRI": {explicitLength: true, vector: true},
+	"VPCMPESTRM": {explicitLength: true, maskResult: true, vector: true},
+	"VPCMPISTRI": {vector: true},
+	"VPCMPISTRM": {maskResult: true, vector: true},
+}
+
+func (c *amd64Ctx) lowerPackedStringCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, recognized, err := amd64PackedStringCompareProperties(op, ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	source, destination := ins.Args[1], ins.Args[2]
+	left, err := c.loadX(destination.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	right, err := c.loadPackedStringCompareBytes(source)
+	if err != nil {
+		return true, false, err
+	}
+	lengthLeft, lengthRight := "", ""
+	if spec.explicitLength {
+		lengthLeft, err = c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		lengthRight, err = c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	imm := uint8(ins.Args[0].Imm)
+	stem := "pcmpi"
+	if spec.explicitLength {
+		stem = "pcmpe"
+	}
+
+	output, width, zeroUpper := spec.resultEffect()
+	if spec.maskResult {
+		result := c.emitPackedStringCompareIntrinsic(stem+"strm128", "<16 x i8>", left, right, lengthLeft, lengthRight, imm)
+		if zeroUpper {
+			err = c.storePackedMoveOperand(Operand{Kind: OpReg, Reg: output}, width, result)
+		} else {
+			// The widest shared bank keeps legacy writes limited to low X0.
+			err = c.storeX(output, result)
+		}
+		if err != nil {
+			return true, false, err
+		}
+	} else {
+		result := c.emitPackedStringCompareIntrinsic(stem+"stri128", "i32", left, right, lengthLeft, lengthRight, imm)
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", extended, result)
+		if err := c.storeReg(output, "%"+extended); err != nil {
+			return true, false, err
+		}
+	}
+
+	carry := c.emitPackedStringCompareFlag(stem+"stric128", left, right, lengthLeft, lengthRight, imm)
+	overflow := c.emitPackedStringCompareFlag(stem+"strio128", left, right, lengthLeft, lengthRight, imm)
+	sign := c.emitPackedStringCompareFlag(stem+"stris128", left, right, lengthLeft, lengthRight, imm)
+	zero := c.emitPackedStringCompareFlag(stem+"striz128", left, right, lengthLeft, lengthRight, imm)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", carry, c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", zero, c.flagsZSlot)
+	// This slot stores architectural SF. Signed conditions apply SF XOR OF
+	// when observing it; precomputing that condition would corrupt PUSHF/LAHF.
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", sign, c.flagsSltSlot)
+	c.clearX86StatusFlags(x86StatusPF | x86StatusAF)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", overflow, c.flagsOFSlot)
+	return true, false, nil
+}
+
+// Intel's packed-string exception row permits unaligned m128, but neither
+// explicit lengths nor dead results suppress its full observable memory read.
+// Logical FP is its existing separate field role; all native addresses use an
+// unaligned volatile tuple, without dereferenceability or extent assumptions.
+func (c *amd64Ctx) loadPackedStringCompareBytes(source Operand) (string, error) {
+	if source.Kind == OpReg || source.Kind == OpFP {
+		return c.loadPackedCompareBytes(source, 16)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile <16 x i8>, %s %s, align 1\n", value, pointerType, pointer)
+	return "%" + value, nil
+}
+
+// This descriptor is syntax and architectural effects, not caller definedness
+// or address permission. Unregistered source-stack consumers remain Context.
+func (spec amd64PackedStringCompareSpec) resultEffect() (Reg, int, bool) {
+	if spec.maskResult {
+		return "X0", 16, spec.vector
+	}
+	return CX, 4, false
+}
+
+func amd64PackedStringCompareProperties(op Op, ins Instr, goarch string) (amd64PackedStringCompareSpec, bool, error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64PackedStringCompareSpecs[Op(baseOp)]
+	if !recognized {
+		return spec, false, nil
+	}
+	if rawOp != baseOp || goarch != "amd64" && goarch != "386" {
+		return spec, true, fmt.Errorf("%s %s has no suffixed or non-x86 form in Go: %q", goarch, baseOp, ins.Raw)
+	}
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != rawOp {
+		return spec, true, fmt.Errorf("packed-string dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	minimumImmediate := int64(0)
+	if spec.vector {
+		// _yvaeskeygenassist has both Yu8 and Yi8 rows, while the legacy
+		// yxshuf table has only Yu8.
+		minimumImmediate = -128
+	}
+	if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" ||
+		ins.Args[0].Imm < minimumImmediate || ins.Args[0].Imm > 255 {
+		return spec, true, fmt.Errorf("%s %s immediate is outside its Go byte domain, or operands are not imm8, X/m128, X: %q", goarch, baseOp, ins.Raw)
+	}
+
+	source, destination := ins.Args[1], ins.Args[2]
+	if destination.Kind != OpReg || !amd64PackedStringCompareRegister(spec, destination, goarch) {
+		return spec, true, fmt.Errorf("%s %s destination is outside its Go X register class: %q", goarch, baseOp, ins.Raw)
+	}
+	if source.Kind == OpReg {
+		if !amd64PackedStringCompareRegister(spec, source, goarch) {
+			return spec, true, fmt.Errorf("%s %s source is outside its Go X register class: %q", goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return spec, true, fmt.Errorf("%s %s source must be X or m128: %q", goarch, baseOp, ins.Raw)
+	}
+	if !spec.vector && source.Kind == OpMem && !x86MemoryRegistersValidForArch(source.Mem, goarch) {
+		return spec, true, fmt.Errorf("%s %s memory source uses a register outside the legacy address class: %q", goarch, baseOp, ins.Raw)
+	}
+	ins.Op = op
+	return spec, true, x86Mode32VectorRegisterContext(ins, goarch)
+}
+
+func amd64PackedStringCompareRegister(spec amd64PackedStringCompareSpec, operand Operand, goarch string) bool {
+	if spec.vector {
+		return amd64VEXVectorRegister(operand, 16)
+	}
+	index, valid := amd64ParseXReg(operand.Reg)
+	limit := 16
+	if goarch == "386" {
+		limit = 8
+	}
+	return operand.Kind == OpReg && valid && index < limit
+}
+
+func (c *amd64Ctx) emitPackedStringCompareIntrinsic(name, resultType, left, right, lengthLeft, lengthRight string, imm uint8) string {
+	result := c.newTmp()
+	if lengthLeft == "" {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.x86.sse42.%s(<16 x i8> %s, <16 x i8> %s, i8 %d)\n",
+			result, resultType, name, left, right, imm)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.x86.sse42.%s(<16 x i8> %s, i32 %s, <16 x i8> %s, i32 %s, i8 %d)\n",
+			result, resultType, name, left, lengthLeft, right, lengthRight, imm)
+	}
+	return "%" + result
+}
+
+func (c *amd64Ctx) emitPackedStringCompareFlag(name, left, right, lengthLeft, lengthRight string, imm uint8) string {
+	result := c.emitPackedStringCompareIntrinsic(name, "i32", left, right, lengthLeft, lengthRight, imm)
+	flag := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i1\n", flag, result)
+	return "%" + flag
+}
diff --git a/amd64_lower_string_compare_test.go b/amd64_lower_string_compare_test.go
new file mode 100644
index 000000000..583c69481
--- /dev/null
+++ b/amd64_lower_string_compare_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type packedStringCompareTestSpec struct {
+	op       string
+	explicit bool
+	mask     bool
+	vector   bool
+}
+
+func go127PackedStringCompareSpecs() []packedStringCompareTestSpec {
+	return []packedStringCompareTestSpec{
+		{op: "PCMPESTRI", explicit: true},
+		{op: "PCMPESTRM", explicit: true, mask: true},
+		{op: "PCMPISTRI"},
+		{op: "PCMPISTRM", mask: true},
+		{op: "VPCMPESTRI", explicit: true, vector: true},
+		{op: "VPCMPESTRM", explicit: true, mask: true, vector: true},
+		{op: "VPCMPISTRI", vector: true},
+		{op: "VPCMPISTRM", mask: true, vector: true},
+	}
+}
+
+func TestAMD64PackedStringCompareGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := go127PackedStringCompareSpecs()
+	if len(amd64PackedStringCompareSpecs) != len(expected) {
+		t.Fatalf("packed-string grammar has %d entries, want %d", len(amd64PackedStringCompareSpecs), len(expected))
+	}
+	for _, want := range expected {
+		got, ok := amd64PackedStringCompareSpecs[Op(want.op)]
+		if !ok {
+			t.Errorf("packed-string grammar omitted %s", want.op)
+			continue
+		}
+		if got.explicitLength != want.explicit || got.maskResult != want.mask || got.vector != want.vector {
+			t.Errorf("packed-string grammar %s = %+v, want explicit=%v mask=%v vector=%v", want.op, got, want.explicit, want.mask, want.vector)
+		}
+	}
+}
+
+func TestTranslateX86PackedStringCompareCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedstringcompareforms(SB),$0-0\n")
+			for index, spec := range go127PackedStringCompareSpecs() {
+				last := 15
+				if target.goarch == "386" {
+					last = 7
+				}
+				fmt.Fprintf(&source, "\t%s $0, X1, X%d\n", spec.op, last)
+				fmt.Fprintf(&source, "\t%s $255, %d(AX), X%d\n", spec.op, index*16, last)
+				if spec.vector {
+					fmt.Fprintf(&source, "\t%s $-128, X1, X%d\n", spec.op, last)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"packedstringcompareforms": {Name: "packedstringcompareforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{
+				"@llvm.x86.sse42.pcmpestri128", "@llvm.x86.sse42.pcmpestrm128",
+				"@llvm.x86.sse42.pcmpistri128", "@llvm.x86.sse42.pcmpistrm128",
+				"@llvm.x86.sse42.pcmpestric128", "@llvm.x86.sse42.pcmpistriz128",
+			} {
+				if !strings.Contains(ir, intrinsic) {
+					t.Fatalf("translation omitted %s:\n%s", intrinsic, ir)
+				}
+			}
+			wantFeatures := `"target-features"="+avx,+sse4.2"`
+			if !strings.Contains(ir, wantFeatures) {
+				t.Fatalf("translation omitted %s:\n%s", wantFeatures, ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-string-compare-"+target.name+".ll", "packed-string-compare-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86PackedStringCompareRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PCMPESTRI $-1, X0, X1"},
+		{goarch: "amd64", instruction: "PCMPISTRM $256, X0, X1"},
+		{goarch: "amd64", instruction: "VPCMPESTRI.Z $7, X0, X1"},
+		{goarch: "amd64", instruction: "VPCMPESTRI $-129, X0, X1"},
+		{goarch: "amd64", instruction: "PCMPISTRI $7, Y0, X1"},
+		{goarch: "amd64", instruction: "VPCMPISTRM $7, X0, X16"},
+		{goarch: "386", instruction: "PCMPESTRM $7, X0, X8"},
+		{goarch: "386", instruction: "VPCMPESTRM $7, X0, X16"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", ",", "", "$", "", ".", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's packed-string tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64PackedStringCompareRuntimeSemanticsAndFlags(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT packedstringcomparesemantics(SB),NOSPLIT,$0-40
+	MOVQ left+0(FP), SI
+	MOVOU (SI), X1
+	MOVQ right+8(FP), DI
+	MOVOU (DI), X2
+	MOVQ out+16(FP), BX
+	MOVQ lenLeft+24(FP), AX
+	MOVQ lenRight+32(FP), DX
+
+	PCMPESTRI $12, X2, X1
+	MOVQ CX, 0(BX)
+	SETCS 8(BX)
+	SETEQ 9(BX)
+	SETLT 10(BX)
+	SETOS 11(BX)
+	SETPS 12(BX)
+
+	PCMPESTRM $64, X2, X1
+	MOVOU X0, 16(BX)
+	SETCS 32(BX)
+	SETEQ 33(BX)
+	SETLT 34(BX)
+	SETOS 35(BX)
+	SETPS 36(BX)
+
+	VPCMPISTRI $0, X2, X1
+	MOVQ CX, 40(BX)
+	SETCS 48(BX)
+	SETEQ 49(BX)
+	SETLT 50(BX)
+	SETOS 51(BX)
+	SETPS 52(BX)
+
+	VPCMPISTRM $64, X2, X1
+	MOVOU X0, 56(BX)
+	SETCS 72(BX)
+	SETEQ 73(BX)
+	SETLT 74(BX)
+	SETOS 75(BX)
+	SETPS 76(BX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"packedstringcomparesemantics": {
+			Name: "packedstringcomparesemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <nmmintrin.h>
+#include <stdint.h>
+#include <string.h>
+extern void packedstringcomparesemantics(const uint8_t *, const uint8_t *, uint8_t *, uint64_t, uint64_t);
+static uint64_t load64(const uint8_t *p) { uint64_t v; memcpy(&v, p, 8); return v; }
+static int flags_equal(const uint8_t *p, int c, int z, int s, int o) {
+  return p[0] == c && p[1] == z && p[2] == (s ^ o) && p[3] == o && p[4] == 0;
+}
+__attribute__((target("sse4.2"))) static int check(void) {
+  const uint8_t left[16] = {'a','b','c','d','e',0,'x','y','z',0,1,2,3,4,5,6};
+  const uint8_t right[16] = {'q','q','a','b','c','d','e',0,'x',0,9,8,7,6,5,4};
+  const int la = 5, lb = 9;
+  uint8_t out[80] = {0}, want[16];
+  __m128i a = _mm_loadu_si128((const __m128i *)left);
+  __m128i b = _mm_loadu_si128((const __m128i *)right);
+  packedstringcomparesemantics(left, right, out, la, lb);
+  if (load64(out) != (uint64_t)_mm_cmpestri(a, la, b, lb, 12)) return 10;
+  if (!flags_equal(out + 8, _mm_cmpestrc(a,la,b,lb,12), _mm_cmpestrz(a,la,b,lb,12), _mm_cmpestrs(a,la,b,lb,12), _mm_cmpestro(a,la,b,lb,12))) return 11;
+  _mm_storeu_si128((__m128i *)want, _mm_cmpestrm(a,la,b,lb,64));
+  if (memcmp(out + 16, want, 16)) return 12;
+  if (!flags_equal(out + 32, _mm_cmpestrc(a,la,b,lb,64), _mm_cmpestrz(a,la,b,lb,64), _mm_cmpestrs(a,la,b,lb,64), _mm_cmpestro(a,la,b,lb,64))) return 13;
+  if (load64(out + 40) != (uint64_t)_mm_cmpistri(a,b,0)) return 14;
+  if (!flags_equal(out + 48, _mm_cmpistrc(a,b,0), _mm_cmpistrz(a,b,0), _mm_cmpistrs(a,b,0), _mm_cmpistro(a,b,0))) return 15;
+  _mm_storeu_si128((__m128i *)want, _mm_cmpistrm(a,b,64));
+  if (memcmp(out + 56, want, 16)) return 16;
+  if (!flags_equal(out + 72, _mm_cmpistrc(a,b,64), _mm_cmpistrz(a,b,64), _mm_cmpistrs(a,b,64), _mm_cmpistro(a,b,64))) return 17;
+  return 0;
+}
+int main(void) { return check(); }
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_string_compare_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_subvec.go b/amd64_lower_subvec.go
new file mode 100644
index 000000000..4d92f7c80
--- /dev/null
+++ b/amd64_lower_subvec.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedSubtractMode = x86PackedArithmeticMode
+
+const (
+	amd64PackedSubtractWrap               = x86PackedWrap
+	amd64PackedSubtractSignedSaturating   = x86PackedSignedSaturating
+	amd64PackedSubtractUnsignedSaturating = x86PackedUnsignedSaturating
+)
+
+// lowerPackedIntegerSubtract implements the complete Go 1.27 packed-integer
+// subtract family: legacy yxm XMM forms and the shared _yvandnpd VEX/EVEX
+// forms. Go's 386 frontend accepts low-bank X/Y/Z three-operand forms but
+// rejects explicit source masks; high banks retain their physical Context.
+func (c *amd64Ctx) lowerPackedIntegerSubtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, _, _, known := amd64PackedSubtractProperties(base); !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("packed subtract dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86PackedSubtractProperties(ins, c.goarch)
+	if err != nil || !known {
+		return known, false, err
+	}
+	first := ins.Args[form.first]
+	if form.legacy && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed subtract needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	bits := form.laneBits
+	mnemonic := ""
+	if form.legacy && form.memory >= 0 {
+		mnemonic = strings.ToLower(base)
+		if base == "PSUBL" {
+			mnemonic = "psubd"
+		}
+	}
+	err = c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, bits, mnemonic,
+		func(lanes, bits int, first, second string) string {
+			return c.emitPackedIntegerSubtract(lanes, bits, first, second, form.mode)
+		})
+	return true, false, err
+}
+
+func amd64PackedSubtractProperties(op string) (int, amd64PackedSubtractMode, bool, bool) {
+	spec, known := x86PackedArithmeticSpecs[Op(op)]
+	if !known || spec.family != x86PackedArithmeticSubtract {
+		return 0, 0, false, false
+	}
+	return spec.laneBits, spec.mode, spec.encoding == x86PackedLogicalVEXOrEVEX, true
+}
+
+// emitPackedIntegerSubtract computes second-first, matching Go assembler's
+// rm,v,destination operand order.
+func (c *amd64Ctx) emitPackedIntegerSubtract(lanes, laneBits int, first, second string, mode amd64PackedSubtractMode) string {
+	vecType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+	if mode == amd64PackedSubtractWrap {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", result, vecType, second, first)
+		return "%" + result
+	}
+
+	wideBits := laneBits * 2
+	wideType := fmt.Sprintf("<%d x i%d>", lanes, wideBits)
+	extend := "sext"
+	if mode == amd64PackedSubtractUnsignedSaturating {
+		extend = "zext"
+	}
+	firstWide := c.newTmp()
+	secondWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", firstWide, extend, vecType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", secondWide, extend, vecType, second, wideType)
+	difference := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %%%s\n", difference, wideType, secondWide, firstWide)
+
+	clamped := "%" + difference
+	minValue := int64(0)
+	if mode == amd64PackedSubtractSignedSaturating {
+		minValue = -int64(uint64(1) << (laneBits - 1))
+	}
+	below := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, %s\n", below, wideType, clamped, llvmSplatSignedInteger(lanes, wideBits, minValue))
+	boundedBelow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", boundedBelow, lanes, below, wideType, llvmSplatSignedInteger(lanes, wideBits, minValue), wideType, clamped)
+	clamped = "%" + boundedBelow
+	if mode == amd64PackedSubtractSignedSaturating {
+		maxValue := int64((uint64(1) << (laneBits - 1)) - 1)
+		above := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp sgt %s %s, %s\n", above, wideType, clamped, llvmSplatSignedInteger(lanes, wideBits, maxValue))
+		boundedAbove := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", boundedAbove, lanes, above, wideType, llvmSplatSignedInteger(lanes, wideBits, maxValue), wideType, clamped)
+		clamped = "%" + boundedAbove
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", result, wideType, clamped, vecType)
+	return "%" + result
+}
diff --git a/amd64_lower_svm.go b/amd64_lower_svm.go
new file mode 100644
index 000000000..365790d55
--- /dev/null
+++ b/amd64_lower_svm.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerX86SystemManagement implements AMD's fixed no-operand 0F 01 D8-DF
+// family and Intel's VMCALL. Their architectural operands are implicit:
+// VMRUN/VMLOAD/VMSAVE use rAX, SKINIT uses EAX, INVLPGA uses rAX and ECX,
+// and VMCALL/VMMCALL follow the common
+// KVM hypercall convention with rAX as the result and rBX/rCX/rDX/rSI as input
+// arguments. The remaining instructions have no general-register operands.
+func (c *amd64Ctx) lowerX86SystemManagement(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	switch baseOp {
+	case "VMCALL", "VMRUN", "VMMCALL", "VMLOAD", "VMSAVE", "STGI", "CLGI", "SKINIT", "INVLPGA":
+		// handled below
+	default:
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+	}
+
+	wordType := I64
+	if c.goarch == "386" {
+		wordType = I32
+	}
+	loadWordReg := func(reg Reg) (string, error) {
+		return c.evalIntSized(Operand{Kind: OpReg, Reg: reg}, wordType)
+	}
+	clobbers := "~{dirflag},~{fpsr},~{flags},~{memory}"
+	switch baseOp {
+	case "STGI", "CLGI":
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", strings.ToLower(baseOp), clobbers)
+	case "VMRUN", "VMLOAD", "VMSAVE":
+		ax, err := loadWordReg(AX)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s)\n", strings.ToLower(baseOp), "{ax},"+clobbers, wordType, ax)
+	case "SKINIT":
+		ax, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect \"skinit\", %q(i32 %s)\n", "{ax},"+clobbers, ax)
+	case "INVLPGA":
+		ax, err := loadWordReg(AX)
+		if err != nil {
+			return true, false, err
+		}
+		cx, err := c.evalIntSized(Operand{Kind: OpReg, Reg: CX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect \"invlpga\", %q(%s %s, i32 %s)\n", "{ax},{cx},"+clobbers, wordType, ax, cx)
+	case "VMCALL", "VMMCALL":
+		regs := []Reg{AX, BX, CX, DX, SI}
+		args := make([]string, len(regs))
+		for i, reg := range regs {
+			value, err := loadWordReg(reg)
+			if err != nil {
+				return true, false, err
+			}
+			args[i] = value
+		}
+		call := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, %s %s, %s %s, %s %s)\n",
+			call, wordType, strings.ToLower(baseOp), "={ax},0,{bx},{cx},{dx},{si},"+clobbers,
+			wordType, args[0], wordType, args[1], wordType, args[2], wordType, args[3], wordType, args[4],
+		)
+		if err := c.storeRegSized(AX, wordType, "%"+call); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
diff --git a/amd64_lower_syscall.go b/amd64_lower_syscall.go
index 8fa1ce4ad..56981d916 100644
--- a/amd64_lower_syscall.go
+++ b/amd64_lower_syscall.go
@@ -7,6 +7,21 @@ import (
 
 func (c *amd64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err error) {
 	switch op {
+	case "WAIT":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("x86 WAIT expects no operands: %q", ins.Raw)
+		}
+		c.b.WriteString("  call void asm sideeffect \"wait\", \"~{memory}\"()\n")
+		return true, false, nil
+	case "HLT":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("x86 HLT expects no operands: %q", ins.Raw)
+		}
+		c.b.WriteString("  call void asm sideeffect \"hlt\", \"~{memory}\"()\n")
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	case "UD2":
+		return c.lowerX86UndefinedTrap(op, ins)
 	case "INT":
 		if c.goarch == "386" && (len(ins.Args) != 1 || ins.Args[0].Kind != OpImm) {
 			return true, false, fmt.Errorf("386 INT expects an immediate vector: %q", ins.Raw)
@@ -27,56 +42,31 @@ func (c *amd64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err
 		}
 		return true, true, nil
 	case "SYSCALL":
-		if len(ins.Args) != 0 {
-			return true, false, fmt.Errorf("amd64 SYSCALL expects no operands: %q", ins.Raw)
-		}
-		num, err := c.loadReg(AX)
-		if err != nil {
-			return true, false, err
-		}
-		a1, err := c.loadReg(DI)
-		if err != nil {
-			return true, false, err
+		source := ins
+		if source.Op == "" {
+			source.Op = op
 		}
-		a2, err := c.loadReg(SI)
-		if err != nil {
-			return true, false, err
+		effect, known, err := x86LinuxSyscallByteEffect(source, c.goarch, c.targetTriple)
+		if !known || err != nil {
+			return true, false, fmt.Errorf("%w: raw SYSCALL lacks its closed source mode/form/target: %v", ErrProbeNeedsContext, err)
 		}
-		a3, err := c.loadReg(DX)
-		if err != nil {
-			return true, false, err
-		}
-		a4, err := c.loadReg(Reg("R10"))
-		if err != nil {
-			return true, false, err
-		}
-		a5, err := c.loadReg(Reg("R8"))
-		if err != nil {
-			return true, false, err
-		}
-		a6, err := c.loadReg(Reg("R9"))
-		if err != nil {
-			return true, false, err
-		}
-
-		r := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @syscall(i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s)\n", r, num, a1, a2, a3, a4, a5, a6)
-		isErr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, -1\n", isErr, r)
-		errno32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @cliteErrno()\n", errno32)
-		errno64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", errno64, errno32)
-		negErr := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sub i64 0, %%%s\n", negErr, errno64)
-		rax := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %%%s\n", rax, isErr, negErr, r)
-		if err := c.storeReg(AX, "%"+rax); err != nil {
-			return true, false, err
+		arguments := make([]string, 0, 7)
+		for _, operand := range effect.operands {
+			if !operand.read {
+				continue
+			}
+			value, err := c.loadReg(operand.operand.Reg)
+			if err != nil {
+				return true, false, err
+			}
+			arguments = append(arguments, "i64 "+value)
 		}
-		// Linux raw syscall ABI writes r2 in DX. libc syscall provides only one
-		// return value, so keep DX at zero.
-		if err := c.storeReg(DX, "0"); err != nil {
+		// The shared ordered input roles match Linux's AX/DI/SI/DX/R10/R8/R9.
+		// Preserve the raw -errno result and DX; libc must not change TLS errno.
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 asm sideeffect %q, %q(%s)\n", result, "syscall",
+			"={ax},0,{di},{si},{dx},{r10},{r8},{r9},~{rcx},~{r11},~{dirflag},~{fpsr},~{flags},~{memory}", strings.Join(arguments, ", "))
+		if err := c.storeReg(AX, "%"+result); err != nil {
 			return true, false, err
 		}
 		return true, false, nil
diff --git a/amd64_lower_system_address.go b/amd64_lower_system_address.go
new file mode 100644
index 000000000..c5ed43fab
--- /dev/null
+++ b/amd64_lower_system_address.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64SystemAddressKind uint8
+
+const (
+	amd64SystemAddressInvalidatePage amd64SystemAddressKind = iota
+	amd64SystemAddressInvalidatePCID
+	amd64SystemAddressDemoteCacheLine
+)
+
+type amd64SystemAddressSpec struct {
+	kind        amd64SystemAddressKind
+	memoryBytes int
+	register    bool
+}
+
+// amd64SystemAddressSpecs is the complete Go 1.27 address-shaped system
+// instruction grammar. The single-memory and memory-plus-register rows share
+// memory/address validation; register compatibility closures are represented
+// explicitly and trap just as their architecturally invalid ModRM encodings do.
+var amd64SystemAddressSpecs = map[Op]amd64SystemAddressSpec{
+	"INVLPG":   {kind: amd64SystemAddressInvalidatePage, memoryBytes: 1},
+	"INVPCID":  {kind: amd64SystemAddressInvalidatePCID, memoryBytes: 16, register: true},
+	"CLDEMOTE": {kind: amd64SystemAddressDemoteCacheLine, memoryBytes: 1},
+}
+
+type amd64SystemAddressForm struct {
+	memory       Operand
+	register     Reg
+	invalidModRM bool
+}
+
+func (c *amd64Ctx) lowerSystemAddress(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64SystemAddressSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	form, err := c.parseSystemAddressForm(baseOp, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitSystemAddress(baseOp, spec, form)
+}
+
+func (c *amd64Ctx) parseSystemAddressForm(op string, spec amd64SystemAddressSpec, ins Instr) (amd64SystemAddressForm, error) {
+	var form amd64SystemAddressForm
+	wantArgs := 1
+	if spec.register {
+		wantArgs = 2
+	}
+	if len(ins.Args) != wantArgs {
+		return form, fmt.Errorf("%s %s expects %d operand(s): %q", c.goarch, op, wantArgs, ins.Raw)
+	}
+	address := ins.Args[0]
+	if isAMD64MemoryOperand(address) {
+		if address.Kind == OpMem && !x86MemoryRegistersValidForArch(address.Mem, c.goarch) {
+			return form, fmt.Errorf("%s %s address uses an out-of-range register: %q", c.goarch, op, ins.Raw)
+		}
+		form.memory = address
+	} else if address.Kind == OpReg && spec.kind != amd64SystemAddressDemoteCacheLine {
+		valid := isX86YrlRegisterForArch(address.Reg, c.goarch)
+		if spec.kind == amd64SystemAddressInvalidatePage {
+			valid = isGoYmbRegisterForArch(address.Reg, c.goarch)
+		}
+		if !valid {
+			return form, fmt.Errorf("%s %s first operand is outside Go 1.27's compatibility class: %q", c.goarch, op, ins.Raw)
+		}
+		form.invalidModRM = true
+	} else {
+		return form, fmt.Errorf("%s %s expects Go 1.27 memory/address form: %q", c.goarch, op, ins.Raw)
+	}
+	if spec.register {
+		typeOperand := ins.Args[1]
+		if typeOperand.Kind != OpReg || !isX86YrlRegisterForArch(typeOperand.Reg, c.goarch) {
+			return form, fmt.Errorf("%s %s type operand must be a Go 1.27 Yrl register: %q", c.goarch, op, ins.Raw)
+		}
+		form.register = typeOperand.Reg
+	}
+	return form, nil
+}
+
+func (c *amd64Ctx) emitSystemAddress(op string, spec amd64SystemAddressSpec, form amd64SystemAddressForm) (bool, bool, error) {
+	if form.invalidModRM {
+		c.b.WriteString("  call void asm sideeffect \"ud2\", \"~{memory}\"()\n")
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	}
+	pointer, pointerType, err := c.x86DescriptorMemoryPointer(form.memory)
+	if err != nil {
+		return true, false, err
+	}
+	clobbers := "~{memory},~{dirflag},~{fpsr},~{flags}"
+	if spec.kind != amd64SystemAddressInvalidatePCID {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype([%d x i8]) %s)\n",
+			strings.ToLower(op)+" $0", "*m,"+clobbers, pointerType, spec.memoryBytes, pointer)
+		return true, false, nil
+	}
+
+	if c.goarch == "386" {
+		// INVPCID is a 64-bit-mode instruction, but Go 1.27 accepts it for
+		// 386. Reproduce Go's 66 0F 38 82 /r encoding with the calculated
+		// address fixed in EBX and the type fixed in EAX. In 32-bit mode the
+		// bytes fault architecturally, but remain object-level compatible.
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint %s %s to i32\n", address, pointerType, pointer)
+		typeValue, err := c.evalIntSized(Operand{Kind: OpReg, Reg: form.register}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %%%s, i32 %s)\n",
+			".byte 0x66, 0x0f, 0x38, 0x82, 0x03", "{bx},{ax},"+clobbers, address, typeValue)
+		return true, false, nil
+	}
+	typeValue, err := c.evalIntSized(Operand{Kind: OpReg, Reg: form.register}, I64)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s elementtype([16 x i8]) %s, i64 %s)\n",
+		"invpcid $0, $1", "*m,r,"+clobbers, pointerType, pointer, typeValue)
+	return true, false, nil
+}
diff --git a/amd64_lower_system_address_test.go b/amd64_lower_system_address_test.go
new file mode 100644
index 000000000..c18ffd917
--- /dev/null
+++ b/amd64_lower_system_address_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64SystemAddressGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64SystemAddressSpec{
+		"INVLPG":   {kind: amd64SystemAddressInvalidatePage, memoryBytes: 1},
+		"INVPCID":  {kind: amd64SystemAddressInvalidatePCID, memoryBytes: 16, register: true},
+		"CLDEMOTE": {kind: amd64SystemAddressDemoteCacheLine, memoryBytes: 1},
+	}
+	if !reflect.DeepEqual(amd64SystemAddressSpecs, want) {
+		t.Fatalf("system-address grammar = %+v, want %+v", amd64SystemAddressSpecs, want)
+	}
+}
+
+func TestTranslateX86SystemAddressCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			base := "BX"
+			if target.goarch == "amd64" {
+				base = "R11"
+			}
+			source := "TEXT systemaddressforms(SB),$0-0\n" +
+				"\tINVLPG 8(" + base + ")\n" +
+				"\tCLDEMOTE 16(" + base + ")\n" +
+				"\tINVPCID 32(" + base + "), AX\n" +
+				"\tRET\n" +
+				"TEXT invlpgcompat(SB),$0-0\n\tINVLPG AX\n" +
+				"TEXT invpcidcompat(SB),$0-0\n\tINVPCID AX, BX\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"systemaddressforms": {Name: "systemaddressforms", Ret: Void},
+					"invlpgcompat":       {Name: "invlpgcompat", Ret: Void},
+					"invpcidcompat":      {Name: "invpcidcompat", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+cldemote,+invpcid"`, `asm sideeffect "ud2"`, "unreachable"} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			if target.goarch == "386" && !strings.Contains(ir, ".byte 0x66, 0x0f, 0x38, 0x82, 0x03") {
+				t.Errorf("386 IR is missing Go-compatible INVPCID encoding:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "system-address-"+target.name+".ll", "system-address-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86SystemAddressRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "INVLPG X1"},
+		{goarch: "amd64", instruction: "INVLPG.Z (BX)"},
+		{goarch: "amd64", instruction: "CLDEMOTE AX"},
+		{goarch: "amd64", instruction: "CLDEMOTE (BX), (CX)"},
+		{goarch: "amd64", instruction: "INVPCID (BX), X1"},
+		{goarch: "amd64", instruction: "INVPCID X1, BX"},
+		{goarch: "amd64", instruction: "INVPCID (BX)"},
+		{goarch: "386", instruction: "INVLPG (R11)"},
+		{goarch: "386", instruction: "CLDEMOTE (R11)"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's system-address tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_system_control_test.go b/amd64_lower_system_control_test.go
new file mode 100644
index 000000000..e6d4c560e
--- /dev/null
+++ b/amd64_lower_system_control_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86SystemControlLRETRawAndWAIT(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, test := range []struct {
+		name   string
+		source string
+		want   string
+	}{
+		{
+			name:   "lret",
+			source: "TEXT lret(SB),NOSPLIT,$0-0\n\tBYTE $0x48; BYTE $0xcb\n",
+			want:   `asm sideeffect ".byte 0x48, 0xcb"`,
+		},
+		{
+			name:   "wait",
+			source: "TEXT wait(SB),NOSPLIT,$0-0\n\tWAIT\n\tRET\n",
+			want:   `asm sideeffect "wait"`,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{test.name: {Name: test.name, Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, test.want) {
+				t.Fatalf("translation omitted %q:\n%s", test.want, ir)
+			}
+			compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "x86-system-control-"+test.name+".ll", "x86-system-control-"+test.name+".o", ir)
+		})
+	}
+}
diff --git a/amd64_lower_system_transfer.go b/amd64_lower_system_transfer.go
new file mode 100644
index 000000000..149b571ef
--- /dev/null
+++ b/amd64_lower_system_transfer.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64SystemTransferKind uint8
+
+const (
+	amd64SystemEnter amd64SystemTransferKind = iota
+	amd64SystemExit
+	amd64SystemReturn
+)
+
+type amd64SystemTransferInputs uint8
+
+const (
+	amd64SystemTransferCX amd64SystemTransferInputs = 1 << iota
+	amd64SystemTransferDX
+	amd64SystemTransferR11
+)
+
+type amd64SystemTransferSpec struct {
+	kind   amd64SystemTransferKind
+	mode64 bool
+	inputs amd64SystemTransferInputs
+}
+
+// amd64SystemTransferSpecs is the complete Go 1.27 SYSENTER/SYSEXIT/SYSRET
+// grammar. SYSCALL is intentionally separate because plan9asm provides a
+// hosted libc-backed syscall implementation for it. These raw architectural
+// transfers retain exact Go bytes and explicitly materialize the GP registers
+// consumed by their exit/return conventions.
+var amd64SystemTransferSpecs = map[Op]amd64SystemTransferSpec{
+	"SYSENTER":   {kind: amd64SystemEnter},
+	"SYSENTER64": {kind: amd64SystemEnter, mode64: true},
+	"SYSEXIT":    {kind: amd64SystemExit, inputs: amd64SystemTransferCX | amd64SystemTransferDX},
+	"SYSEXIT64":  {kind: amd64SystemExit, mode64: true, inputs: amd64SystemTransferCX | amd64SystemTransferDX},
+	"SYSRET":     {kind: amd64SystemReturn, inputs: amd64SystemTransferCX | amd64SystemTransferR11},
+}
+
+func (spec amd64SystemTransferSpec) terminates() bool {
+	return spec.kind != amd64SystemEnter
+}
+
+func (spec amd64SystemTransferSpec) encoding() string {
+	var opcode byte
+	switch spec.kind {
+	case amd64SystemEnter:
+		opcode = 0x34
+	case amd64SystemExit:
+		opcode = 0x35
+	case amd64SystemReturn:
+		opcode = 0x07
+	default:
+		panic("unknown amd64 system-transfer kind")
+	}
+	if spec.mode64 {
+		return fmt.Sprintf(".byte 0x48, 0x0f, 0x%02x", opcode)
+	}
+	return fmt.Sprintf(".byte 0x0f, 0x%02x", opcode)
+}
+
+func (c *amd64Ctx) lowerSystemTransfer(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64SystemTransferSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.mode64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, baseOp, ins.Raw)
+	}
+	constraints := make([]string, 0, 7)
+	arguments := make([]string, 0, 3)
+	for _, input := range []struct {
+		bit        amd64SystemTransferInputs
+		reg        Reg
+		constraint string
+	}{
+		{bit: amd64SystemTransferCX, reg: CX, constraint: "{cx}"},
+		{bit: amd64SystemTransferDX, reg: DX, constraint: "{dx}"},
+		{bit: amd64SystemTransferR11, reg: Reg("R11"), constraint: "{r11}"},
+	} {
+		if spec.inputs&input.bit == 0 || (c.goarch == "386" && input.bit == amd64SystemTransferR11) {
+			continue
+		}
+		typ := I32
+		if spec.mode64 || spec.kind == amd64SystemReturn {
+			typ = I64
+		}
+		value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: input.reg}, typ)
+		if err != nil {
+			return true, false, err
+		}
+		constraints = append(constraints, input.constraint)
+		arguments = append(arguments, fmt.Sprintf("%s %s", typ, value))
+	}
+	constraints = append(constraints, "~{memory}", "~{dirflag}", "~{fpsr}", "~{flags}")
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n",
+		spec.encoding(), strings.Join(constraints, ","), strings.Join(arguments, ", "))
+	if !spec.terminates() {
+		return true, false, nil
+	}
+	c.b.WriteString("  unreachable\n")
+	return true, true, nil
+}
diff --git a/amd64_lower_system_transfer_test.go b/amd64_lower_system_transfer_test.go
new file mode 100644
index 000000000..58823da96
--- /dev/null
+++ b/amd64_lower_system_transfer_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestAMD64SystemTransferGrammarIsComplete(t *testing.T) {
+	want := map[Op]amd64SystemTransferSpec{
+		"SYSENTER":   {kind: amd64SystemEnter},
+		"SYSENTER64": {kind: amd64SystemEnter, mode64: true},
+		"SYSEXIT":    {kind: amd64SystemExit, inputs: amd64SystemTransferCX | amd64SystemTransferDX},
+		"SYSEXIT64":  {kind: amd64SystemExit, mode64: true, inputs: amd64SystemTransferCX | amd64SystemTransferDX},
+		"SYSRET":     {kind: amd64SystemReturn, inputs: amd64SystemTransferCX | amd64SystemTransferR11},
+	}
+	if !reflect.DeepEqual(amd64SystemTransferSpecs, want) {
+		t.Fatalf("system-transfer grammar = %+v, want %+v", amd64SystemTransferSpecs, want)
+	}
+}
+
+func TestTranslateX86SystemTransferCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT sysenterform(SB),$0-0
+	SYSENTER
+	RET
+TEXT sysexitform(SB),$0-0
+	SYSEXIT
+TEXT sysretform(SB),$0-0
+	SYSRET
+`
+			sigs := map[string]FuncSig{
+				"sysenterform": {Name: "sysenterform", Ret: Void},
+				"sysexitform":  {Name: "sysexitform", Ret: Void},
+				"sysretform":   {Name: "sysretform", Ret: Void},
+			}
+			if target.goarch == "amd64" {
+				source += `TEXT sysenter64form(SB),$0-0
+	SYSENTER64
+	RET
+TEXT sysexit64form(SB),$0-0
+	SYSEXIT64
+`
+				sigs["sysenter64form"] = FuncSig{Name: "sysenter64form", Ret: Void}
+				sigs["sysexit64form"] = FuncSig{Name: "sysexit64form", Ret: Void}
+			}
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`.byte 0x0f, 0x34`,
+				`.byte 0x0f, 0x35`,
+				`.byte 0x0f, 0x07`,
+				`{cx},{dx},~{memory}`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			wantUnreachable := 2
+			if target.goarch == "amd64" {
+				wantUnreachable = 3
+				for _, want := range []string{
+					`.byte 0x48, 0x0f, 0x34`,
+					`.byte 0x48, 0x0f, 0x35`,
+					`{cx},{r11},~{memory}`,
+				} {
+					if !strings.Contains(ir, want) {
+						t.Errorf("amd64 IR is missing %s:\n%s", want, ir)
+					}
+				}
+			}
+			if got := strings.Count(ir, "unreachable"); got != wantUnreachable {
+				t.Errorf("unreachable count = %d, want %d", got, wantUnreachable)
+			}
+			compileLLVMToObject(t, llc, target.triple, "system-transfer-"+target.name+".ll", "system-transfer-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86SystemTransferRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "SYSENTER AX"},
+		{goarch: "amd64", instruction: "SYSENTER64.P"},
+		{goarch: "amd64", instruction: "SYSEXIT AX"},
+		{goarch: "amd64", instruction: "SYSEXIT64 AX"},
+		{goarch: "amd64", instruction: "SYSRET AX"},
+		{goarch: "386", instruction: "SYSENTER64"},
+		{goarch: "386", instruction: "SYSEXIT64"},
+		{goarch: "386", instruction: "SYSRET.P"},
+	} {
+		t.Run(test.goarch+"_"+strings.ReplaceAll(test.instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's system-transfer tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_ternary_logic.go b/amd64_lower_ternary_logic.go
new file mode 100644
index 000000000..53df324d9
--- /dev/null
+++ b/amd64_lower_ternary_logic.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import "fmt"
+
+// Both Go _yvalignd opcodes have the same forms; D/Q changes mask lanes and
+// the scalar broadcast tuple, not the bitwise Boolean truth table.
+var amd64TernaryLogicSpecs = map[Op]int{"VPTERNLOGD": 32, "VPTERNLOGQ": 64}
+
+func (c *amd64Ctx) lowerTernaryLogic(op Op, ins Instr) (bool, bool, error) {
+	form, recognized, err := x86TernaryLogicProperties(op, ins, c.goarch)
+	if !recognized || err != nil {
+		return recognized, false, err
+	}
+	if form.memory >= 0 && ins.Args[form.memory].Kind == OpFP {
+		if err := c.validateX86PackedShiftFPSpan(ins.Args[form.memory].FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	var mask string
+	if form.mask >= 0 {
+		mask, err = c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	dependencies := form.dependencies()
+	if form.mask >= 0 && !form.zeroing {
+		dependencies |= 1
+	}
+	inputs := [3]string{"zeroinitializer", "zeroinitializer", "zeroinitializer"}
+	for role, argument := range form.inputs {
+		if argument == form.memory {
+			// E4 reads are observable even if the truth table ignores C.
+			// Only active mask lanes suppress faults; never LLVM DCE.
+			// Intel SDM Vol.2A 2.8.4, Tables 2-43/2-49 (E4, not E4NF):
+			// https://cdrdv2-public.intel.com/789573/252046-sdm-change-document.pdf
+			lanes, err := c.loadX86PackedShiftLanes(ins.Args[argument], form.byteWidth, form.laneBits, form.broadcast, mask)
+			if err != nil {
+				return true, false, err
+			}
+			bytes := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, form.byteWidth*8/form.laneBits, form.laneBits, lanes, form.byteWidth)
+			inputs[role] = "%" + bytes
+		} else if dependencies>>uint(role)&1 != 0 {
+			inputs[role], err = c.loadPackedCompareBytes(ins.Args[argument], form.byteWidth)
+			if err != nil {
+				return true, false, err
+			}
+		}
+	}
+	result := c.emitTernaryLogicTerms(form.byteWidth, form.terms, inputs)
+	if form.mask >= 0 {
+		lanes := form.byteWidth * 8 / form.laneBits
+		computed := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.laneBits, result)
+		old := c.bitcastVectorBytesToIntegerLanes(form.byteWidth, lanes, form.laneBits, inputs[0])
+		masked := amd64ApplyIntegerLaneMask(c, lanes, form.laneBits, computed, old, mask, form.zeroing)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", bytes, lanes, form.laneBits, masked, form.byteWidth)
+		result = "%" + bytes
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, result)
+}
+
+// Normalization removes irrelevant inputs and aliases before LLVM sees undef.
+func (c *amd64Ctx) emitTernaryLogicBytes(width int, immediate uint8, a, b, third string) string {
+	return c.emitTernaryLogicTerms(width, x86TernaryLogicTerms(immediate, [3]int{0, 1, 2}), [3]string{a, b, third})
+}
+
+func (c *amd64Ctx) emitTernaryLogicTerms(width int, terms uint8, inputs [3]string) string {
+	result := ""
+	for subset := 0; subset < 8; subset++ {
+		if terms>>uint(subset)&1 == 0 {
+			continue
+		}
+		term := ""
+		for role, input := range inputs {
+			if subset>>uint(role)&1 == 0 {
+				continue
+			}
+			if term == "" {
+				term = input
+				continue
+			}
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and <%d x i8> %s, %s\n", name, width, term, input)
+			term = "%" + name
+		}
+		if term == "" {
+			term = llvmAllOnesI8Vec(width)
+		}
+		if result == "" {
+			result = term
+			continue
+		}
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <%d x i8> %s, %s\n", name, width, result, term)
+		result = "%" + name
+	}
+	if result == "" {
+		return "zeroinitializer"
+	}
+	return result
+}
+
+func amd64TernaryLogicBit(immediate uint8, a, b, third bool) bool {
+	index := 0
+	for _, value := range []bool{a, b, third} {
+		index <<= 1
+		if value {
+			index++
+		}
+	}
+	return immediate>>uint(index)&1 != 0
+}
diff --git a/amd64_lower_unary_imm_float.go b/amd64_lower_unary_imm_float.go
new file mode 100644
index 000000000..6edc76ce1
--- /dev/null
+++ b/amd64_lower_unary_imm_float.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+type amd64UnaryImmediateFloatingShape struct {
+	laneBits  int
+	scalar    bool
+	twoSource bool
+}
+
+type amd64UnaryImmediateFloatingForm struct {
+	properties  amd64BinaryFloatingSuffix
+	source      Operand
+	passthrough Operand
+	destination Operand
+	byteWidth   int
+	mask        string
+	immediate   uint8
+}
+
+// parseUnaryImmediateFloatingForm models Go 1.27's related unary-immediate
+// and FIXUPIMM operand grammars. Semantic families supply only their lane
+// width, packed/scalar shape, and whether packed forms have two sources;
+// width, memory, BCST, SAE, mask, zeroing, and 386 frontend constraints are
+// validated once here.
+func (c *amd64Ctx) parseUnaryImmediateFloatingForm(baseOp, suffix string, shape amd64UnaryImmediateFloatingShape, ins Instr) (amd64UnaryImmediateFloatingForm, error) {
+	var form amd64UnaryImmediateFloatingForm
+	properties, validSuffix := parseAMD64BinaryFloatingSuffix(suffix)
+	if !validSuffix || properties.rounding != "" {
+		return form, fmt.Errorf("%s %s has a suffix absent from Go 1.27's unary-immediate floating optabs: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if shape.scalar && properties.broadcast {
+		return form, fmt.Errorf("%s %s scalar forms do not support broadcast: %q", c.goarch, baseOp, ins.Raw)
+	}
+	hasPassthrough := shape.scalar || shape.twoSource
+	wantArgs := 3
+	if hasPassthrough {
+		wantArgs = 4
+	}
+	if len(ins.Args) != wantArgs && len(ins.Args) != wantArgs+1 {
+		return form, fmt.Errorf("%s %s has the wrong operand count for its packed/scalar grammar: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+		return form, fmt.Errorf("%s %s immediate must be an unsigned byte: %q", c.goarch, baseOp, ins.Raw)
+	}
+	masked := len(ins.Args) == wantArgs+1
+	if c.goarch == "386" && (hasPassthrough || masked) {
+		return form, fmt.Errorf("386 %s form exceeds the Go assembler frontend's three-operand limit: %q", baseOp, ins.Raw)
+	}
+	if properties.zeroing && !masked {
+		return form, fmt.Errorf("%s %s zeroing requires a K1-K7 mask: %q", c.goarch, baseOp, ins.Raw)
+	}
+	maskIndex := len(ins.Args) - 2
+	if masked && !amd64NonzeroKOperand(ins.Args[maskIndex]) {
+		return form, fmt.Errorf("%s %s masked form expects K1-K7: %q", c.goarch, baseOp, ins.Raw)
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return form, fmt.Errorf("%s %s destination must be a vector register: %q", c.goarch, baseOp, ins.Raw)
+	}
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	passthrough := Operand{}
+	if shape.scalar {
+		passthrough = ins.Args[2]
+		if byteWidth != 16 || !c.isGoEVEXVectorRegister(destination, 16) || !c.isGoEVEXVectorRegister(passthrough, 16) {
+			return form, fmt.Errorf("%s %s scalar pass-through and destination must be X registers: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else {
+		if byteWidth != 16 && byteWidth != 32 && byteWidth != 64 || !c.isGoEVEXVectorRegister(destination, byteWidth) {
+			return form, fmt.Errorf("%s %s packed destination must be an in-range X, Y, or Z register: %q", c.goarch, baseOp, ins.Raw)
+		}
+		if shape.twoSource {
+			passthrough = ins.Args[2]
+			if !c.isGoEVEXVectorRegister(passthrough, byteWidth) {
+				return form, fmt.Errorf("%s %s second packed source must match the destination width: %q", c.goarch, baseOp, ins.Raw)
+			}
+		}
+	}
+	source := ins.Args[1]
+	if properties.broadcast {
+		if !isAMD64MemoryOperand(source) {
+			return form, fmt.Errorf("%s %s.BCST requires a scalar memory source: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if source.Kind == OpReg {
+		if !c.isGoEVEXVectorRegister(source, byteWidth) {
+			return form, fmt.Errorf("%s %s source register must match the destination width: %q", c.goarch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return form, fmt.Errorf("%s %s source must be a matching vector register or memory: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if properties.sae && (source.Kind != OpReg || !shape.scalar && byteWidth != 64) {
+		return form, fmt.Errorf("%s %s.SAE requires a register source and scalar or Z form: %q", c.goarch, baseOp, ins.Raw)
+	}
+	mask := ""
+	if masked {
+		var err error
+		mask, err = c.loadK(ins.Args[maskIndex].Reg)
+		if err != nil {
+			return form, err
+		}
+	}
+	return amd64UnaryImmediateFloatingForm{
+		properties: properties, source: source, passthrough: passthrough,
+		destination: destination, byteWidth: byteWidth, mask: mask,
+		immediate: uint8(ins.Args[0].Imm),
+	}, nil
+}
diff --git a/amd64_lower_unpack.go b/amd64_lower_unpack.go
new file mode 100644
index 000000000..8a5229d0b
--- /dev/null
+++ b/amd64_lower_unpack.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// One complete grammar is consumed by lowering and caller byte proofs.
+// Interleaving is bitwise, including floating spellings: it never changes MXCSR.
+func (c *amd64Ctx) lowerPackedUnpack(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, recognized := x86PackedUnpackSpecs[Op(base)]; !recognized {
+		return false, false, nil
+	}
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("packed unpack dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := x86PackedUnpackProperties(ins, c.goarch)
+	if err != nil || !recognized {
+		return recognized, false, err
+	}
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return true, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy unpack m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	laneBits := form.spec.laneBits
+	lanes := form.byteWidth * 8 / laneBits
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	if form.mmx {
+		firstBits, err := c.loadPackedUnpackMMXSource(first, form.memoryBytes)
+		if err != nil {
+			return true, false, err
+		}
+		secondBits, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		a := c.bitcastI64ToIntegerLanes(lanes, laneBits, firstBits)
+		b := c.bitcastI64ToIntegerLanes(lanes, laneBits, secondBits)
+		result := c.emitPackedUnpackLanes(form.byteWidth, laneBits, form.spec.high, a, b)
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", bits, lanes, laneBits, result)
+		return true, false, c.storeReg(destination.Reg, "%"+bits)
+	}
+	// Intel SDM Vol.2A Tables 2-44/45 classify these EVEX permutations as
+	// E4NF, not E4. A mask (even all zero) is not memory-fault suppression.
+	// Do not reuse the logical family's masked-memory reader here.
+	b, err := c.loadPackedCompareLanes(second, form.byteWidth, laneBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.legacy && form.memory >= 0 {
+		mnemonic := strings.ToLower(base)
+		switch base {
+		case "PUNPCKLWL":
+			mnemonic = "punpcklwd"
+		case "PUNPCKHWL":
+			mnemonic = "punpckhwd"
+		case "PUNPCKLLQ":
+			mnemonic = "punpckldq"
+		case "PUNPCKHLQ":
+			mnemonic = "punpckhdq"
+		}
+		result, err = c.emitPackedBinaryNativeMemory(first, laneBits, b, mnemonic)
+	} else {
+		var a string
+		a, err = c.loadPackedUnpackSource(first, form)
+		if err == nil {
+			result = c.emitPackedUnpackLanes(form.byteWidth, laneBits, form.spec.high, a, b)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old, err := c.loadPackedCompareLanes(destination, form.byteWidth, laneBits, false)
+		if err != nil {
+			return true, false, err
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, laneBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, laneBits, result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) loadPackedUnpackSource(source Operand, form x86PackedUnpackForm) (string, error) {
+	if source.Kind == OpReg || source.Kind == OpFP {
+		return c.loadPackedCompareLanes(source, form.byteWidth, form.spec.laneBits, form.broadcast)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	bits := form.spec.laneBits
+	lanes := form.byteWidth * 8 / bits
+	// An E4NF access is mandatory even when every output lane is masked off
+	// or observes only part of the source. A plain LLVM load can disappear.
+	if form.broadcast {
+		fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", value, bits, pointerType, pointer)
+		return amd64SplatInteger(c, lanes, bits, "%"+value), nil
+	}
+	fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i%d>, %s %s, align 1\n", value, lanes, bits, pointerType, pointer)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) loadPackedUnpackMMXSource(source Operand, memoryBytes int) (string, error) {
+	if source.Kind == OpFP {
+		bytes, err := c.loadFPVectorBytes(source.FPOffset, memoryBytes)
+		if err != nil {
+			return "", err
+		}
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", bits, memoryBytes, bytes, 8*memoryBytes)
+		if memoryBytes == 8 {
+			return "%" + bits, nil
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, bits)
+		return "%" + wide, nil
+	}
+	if memoryBytes == 0 {
+		return c.loadLegacyMMXPackedSource(source)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", value, 8*memoryBytes, pointerType, pointer)
+	if memoryBytes == 8 {
+		return "%" + value, nil
+	}
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, value)
+	return "%" + wide, nil
+}
+
+// emitPackedUnpackLanes interleaves the second (vvvv/old destination) source
+// with the first (r/m) source independently within each 128-bit vector lane.
+func (c *amd64Ctx) emitPackedUnpackLanes(byteWidth, laneBits int, high bool, first, second string) string {
+	lanes := byteWidth * 8 / laneBits
+	groupBits := 128
+	if byteWidth == 8 {
+		groupBits = 64
+	}
+	groupLanes := groupBits / laneBits
+	half := groupLanes / 2
+	start := 0
+	if high {
+		start = half
+	}
+	mask := make([]string, 0, lanes)
+	for group := 0; group < lanes/groupLanes; group++ {
+		base := group * groupLanes
+		for lane := start; lane < start+half; lane++ {
+			index := base + lane
+			mask = append(mask, fmt.Sprintf("i32 %d", index), fmt.Sprintf("i32 %d", lanes+index))
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> %s, <%d x i32> <%s>\n",
+		result, lanes, laneBits, second, lanes, laneBits, first, lanes, strings.Join(mask, ", "))
+	return "%" + result
+}
diff --git a/amd64_lower_unpack_float_test.go b/amd64_lower_unpack_float_test.go
new file mode 100644
index 000000000..a11c2cd65
--- /dev/null
+++ b/amd64_lower_unpack_float_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86FloatingUnpackCompleteGoAssemblerForms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast, zLast, second, destination := 15, 22, 20, 21
+			if target.goarch == "386" {
+				legacyLast, zLast = 7, 7
+				second, destination = 6, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT floatingunpackforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{"UNPCKLPS", "UNPCKHPS", "UNPCKLPD", "UNPCKHPD"} {
+				fmt.Fprintf(&source, "\t%s X0, X%d\n", op, legacyLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d\n", op, legacyLast)
+				vector := "V" + op
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "\t%s %s0, %s1, %s2\n", vector, width, width, width)
+					fmt.Fprintf(&source, "\t%s 8(AX), %s%d, %s%d\n", vector, width, second, width, destination)
+					fmt.Fprintf(&source, "\t%s.BCST 8(AX), %s%d, %s%d\n", vector, width, second, width, destination)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s %s20, %s21, K1, %s22\n", vector, width, width, width)
+						fmt.Fprintf(&source, "\t%s.BCST.Z 8(AX), %s21, K7, %s22\n", vector, width, width)
+					}
+				}
+				fmt.Fprintf(&source, "\t%s Z0, Z6, Z%d\n", vector, zLast)
+				fmt.Fprintf(&source, "\t%s 8(AX), Z6, Z%d\n", vector, zLast)
+				fmt.Fprintf(&source, "\t%s.BCST 8(AX), Z6, Z%d\n", vector, zLast)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s Z20, Z21, K2, Z22\n", vector)
+					fmt.Fprintf(&source, "\t%s.Z 8(AX), Z21, K6, Z22\n", vector)
+				}
+			}
+			source.WriteString("\tRET\n")
+
+			ll := x86UnboundVoidScalarFormatObject(t, source.String(), "floatingunpackforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "floating-unpack-"+target.name+".ll", "floating-unpack-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86FloatingUnpackRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"UNPCKLPS.Z X0, X1",
+		"UNPCKHPD X0",
+		"UNPCKLPD M0, M1",
+		"UNPCKHPS Y0, X1",
+		"UNPCKLPS X0, (AX)",
+		"VUNPCKLPD X0, X1",
+		"VUNPCKHPS X0, Y1, Y2",
+		"VUNPCKLPD X0, X1, (AX)",
+		"VUNPCKHPD X0, X1, K0, X2",
+		"VUNPCKLPS.Z X0, X1, X2",
+		"VUNPCKHPS.BCST X0, X1, X2",
+		"VUNPCKLPD.BCST 8(AX), X1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86FloatingUnpackRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"UNPCKLPS X8, X0",
+		"UNPCKHPD X0, X8",
+		"VUNPCKLPD Z8, Z1, Z2",
+		"VUNPCKHPS Z0, Z1, Z8",
+		"VUNPCKLPS X0, X1, K1, X2",
+		"VUNPCKHPD.Z X0, X1, K1, X2",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86FloatingUnpackRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86FloatingUnpackRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's floating unpack forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_variable_shift.go b/amd64_lower_variable_shift.go
new file mode 100644
index 000000000..71b38a901
--- /dev/null
+++ b/amd64_lower_variable_shift.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "fmt"
+
+type amd64PerLaneVariableShiftSpec struct {
+	laneBits   int
+	operation  string
+	arithmetic bool
+	// Shared raw grammar: 66.0F38 opcode and optional VEX generation.
+	// W is fixed: W0 for dwords, W1 for words/qwords.
+	opcode byte
+	vex    bool
+}
+
+var amd64PerLaneVariableShiftSpecs = map[string]amd64PerLaneVariableShiftSpec{
+	"VPSLLVW": {laneBits: 16, operation: "shl", opcode: 0x12},
+	"VPSLLVD": {laneBits: 32, operation: "shl", opcode: 0x47, vex: true},
+	"VPSLLVQ": {laneBits: 64, operation: "shl", opcode: 0x47, vex: true},
+	"VPSRLVW": {laneBits: 16, operation: "lshr", opcode: 0x10},
+	"VPSRLVD": {laneBits: 32, operation: "lshr", opcode: 0x45, vex: true},
+	"VPSRLVQ": {laneBits: 64, operation: "lshr", opcode: 0x45, vex: true},
+	"VPSRAVW": {laneBits: 16, operation: "ashr", arithmetic: true, opcode: 0x11},
+	"VPSRAVD": {laneBits: 32, operation: "ashr", arithmetic: true, opcode: 0x46, vex: true},
+	"VPSRAVQ": {laneBits: 64, operation: "ashr", arithmetic: true, opcode: 0x46},
+}
+
+// lowerPerLaneVariableShift implements the full Go 1.27 per-lane packed
+// variable-shift family. The first Plan 9 source supplies one count per lane.
+func (c *amd64Ctx) lowerPerLaneVariableShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerX86PackedShift(op, ins)
+}
+
+func (c *amd64Ctx) emitPerLaneVariableShift(spec amd64PerLaneVariableShiftSpec, lanes int, counts, data string) string {
+	typeName := fmt.Sprintf("<%d x i%d>", lanes, spec.laneBits)
+	limit := amd64SplatInteger(c, lanes, spec.laneBits, fmt.Sprintf("%d", spec.laneBits))
+	inRange := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ult %s %s, %s\n", inRange, typeName, counts, limit)
+	fallbackCount := "zeroinitializer"
+	if spec.arithmetic {
+		fallbackCount = amd64SplatInteger(c, lanes, spec.laneBits, fmt.Sprintf("%d", spec.laneBits-1))
+	}
+	safeCounts := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n", safeCounts, lanes, inRange, typeName, counts, typeName, fallbackCount)
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", shifted, spec.operation, typeName, data, safeCounts)
+	if spec.arithmetic {
+		return "%" + shifted
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s zeroinitializer\n", result, lanes, inRange, typeName, shifted, typeName)
+	return "%" + result
+}
diff --git a/amd64_lower_variable_shift_test.go b/amd64_lower_variable_shift_test.go
new file mode 100644
index 000000000..1a902b768
--- /dev/null
+++ b/amd64_lower_variable_shift_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86PerLaneVariableShiftCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 exposes the W/D/Q per-lane left, logical-right, and
+	// arithmetic-right shifts. Every opcode has X/Y/Z rows and optional K
+	// masking/.Z; D/Q additionally enable scalar count broadcast.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			lastZ, dataReg, dstReg := 20, 20, 21
+			if target.goarch == "386" {
+				lastZ, dataReg, dstReg = 7, 6, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT perlanevariableshiftforms(SB),NOSPLIT,$0-0\n")
+			for _, op := range []string{
+				"VPSLLVW", "VPSLLVD", "VPSLLVQ",
+				"VPSRLVW", "VPSRLVD", "VPSRLVQ",
+				"VPSRAVW", "VPSRAVD", "VPSRAVQ",
+			} {
+				fmt.Fprintf(&source, "\t%s X1, X%d, X%d\n", op, dataReg, dstReg)
+				fmt.Fprintf(&source, "\t%s 8(AX), Y%d, Y%d\n", op, dataReg, dstReg)
+				fmt.Fprintf(&source, "\t%s Z1, Z2, Z%d\n", op, lastZ)
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X1, X20, K1, X21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z Y1, Y20, K2, Y21\n", op)
+					fmt.Fprintf(&source, "\t%s.Z 40(AX), Z20, K3, Z21\n", op)
+				}
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					fmt.Fprintf(&source, "\t%s.BCST 104(AX), X%d, X%d\n", op, dataReg, dstReg)
+					fmt.Fprintf(&source, "\t%s.BCST 112(AX), Y%d, Y%d\n", op, dataReg, dstReg)
+					fmt.Fprintf(&source, "\t%s.BCST 120(AX), Z2, Z%d\n", op, lastZ)
+					if target.goarch == "amd64" {
+						fmt.Fprintf(&source, "\t%s.BCST.Z 128(AX), Z20, K4, Z21\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			assembleX87ControlBytes(t, target.goarch, strings.ReplaceAll(source.String(), "NOSPLIT", "4"))
+
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"perlanevariableshiftforms": {Name: "perlanevariableshiftforms", Ret: Void},
+				},
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				original := strings.Replace(source.String(), "perlanevariableshiftforms(SB)", "·view(SB)", 1)
+				if ir, err := x86ScalarFPBitViewAPI(t, original, "func view()", target.goarch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("uninitialized original formats acquired numerical/native inputs", api, err)
+				}
+			}
+			ll := x86InstructionFormatObjectUnit(t, file, options.Sigs, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPerLaneVariableShift(ins.Op, ins)
+				})
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "per-lane-variable-shift-"+target.name+".ll", "per-lane-variable-shift-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86PerLaneVariableShiftRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VPSLLVQ X0, X1",
+		"VPSLLVQ $1, X1, X2",
+		"VPSLLVQ X0, Y1, Y2",
+		"VPSLLVQ X0, (AX), X2",
+		"VPSLLVQ X0, X1, K0, X2",
+		"VPSLLVQ X0, X1, AX",
+		"VPSLLVQ.Z X0, X1, X2",
+		"VPSLLVQ.BCST X0, X1, X2",
+		"VPSLLVW.BCST (AX), X1, X2",
+		"VPSLLVQ.Z.BCST (AX), X1, K1, X2",
+		"VPSLLVQ.RN_SAE X0, X1, X2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86PerLaneVariableShiftRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	assertX86PerLaneVariableShiftRejected(t, "386", "i386-unknown-linux-gnu", "VPSLLVQ X0, X1, K1, X2")
+	assertX86PerLaneVariableShiftRejected(t, "386", "i386-unknown-linux-gnu", "VPSLLVQ Z0, Z1, Z8")
+}
+
+func assertX86PerLaneVariableShiftRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's per-lane variable shift forms", instruction)
+	}
+}
diff --git a/amd64_lower_vcomi.go b/amd64_lower_vcomi.go
new file mode 100644
index 000000000..c2a59488f
--- /dev/null
+++ b/amd64_lower_vcomi.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerVectorScalarFlagCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	name, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86COMISpecs[Op(name)]; !known {
+		return false, false, nil
+	}
+	if !strings.EqualFold(string(op), string(ins.Op)) {
+		return true, false, fmt.Errorf("scalar flag comparison dispatch/source mismatch")
+	}
+	form, known, err := x86COMIProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: scalar flag comparison requires its native x86 MXCSR target", ErrProbeNeedsContext)
+	}
+	if ins.x86AddressBits != 0 {
+		return true, false, fmt.Errorf("%w: scalar flag comparison needs original address-size binding", ErrProbeNeedsContext)
+	}
+	return true, false, c.emitNativeCOMI(ins, form)
+}
+
+// A relation-only LLVM fcmp neither distinguishes COMI/UCOMI signaling nor
+// preserves exceptions after FLAGS die. Keep one whole native comparison and
+// capture CF/ZF/PF before compiler-generated instructions can overwrite them.
+func (c *amd64Ctx) emitNativeCOMI(ins Instr, form x86COMIForm) error {
+	destination, err := c.evalScalarFloatForInteger(ins.Args[1], form.spec.bits)
+	if err != nil {
+		return err
+	}
+	typ := string(amd64FloatingTypeForBits(form.spec.bits))
+	registerConstraint := "x"
+	if form.evex {
+		registerConstraint = "v"
+	}
+	source := ins.Args[0]
+	var value, sourceType, constraint, operand string
+	if source.Kind == OpReg || source.Kind == OpFP {
+		value, err = c.evalScalarFloatForInteger(source, form.spec.bits)
+		sourceType, constraint, operand = typ, registerConstraint, "$3"
+	} else {
+		var pointerType string
+		value, pointerType, _, err = c.packedVectorMemoryPointer(source)
+		sourceType = fmt.Sprintf("%s elementtype([%d x i8])", pointerType, form.spec.bits/8)
+		constraint, operand = "*m", "$3"
+		if pointerType == "ptr addrspace(256)" {
+			operand = "%gs:" + operand
+		} else if pointerType == "ptr addrspace(257)" {
+			operand = "%fs:" + operand
+		}
+	}
+	if err != nil {
+		return err
+	}
+	assembly := strings.ToLower(form.name)
+	if form.evex {
+		assembly = "{evex} " + assembly
+	}
+	if form.sae {
+		assembly += " {sae},"
+	}
+	assembly += " " + operand + ", $4; setb $0; sete $1; setp $2"
+	result := c.newTmp()
+	constraints := "=q,=q,=q," + constraint + "," + registerConstraint + ",~{flags},~{fpsr},~{memory}"
+	fmt.Fprintf(c.b, "  %%%s = call { i8, i8, i8 } asm sideeffect %q, %q(%s %s, %s %s)\n",
+		result, assembly, constraints, sourceType, value, typ, destination)
+	for index, slot := range []string{c.flagsCFSlot, c.flagsZSlot, c.flagsPFSlot} {
+		byteValue, boolean := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue { i8, i8, i8 } %%%s, %d\n", byteValue, result, index)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %%%s, 0\n", boolean, byteValue)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", boolean, slot)
+	}
+	for _, slot := range []string{c.flagsSltSlot, c.flagsOFSlot, c.flagsAFSlot} {
+		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", slot)
+	}
+	return nil
+}
diff --git a/amd64_lower_vcvtss2sd_test.go b/amd64_lower_vcvtss2sd_test.go
new file mode 100644
index 000000000..3cd8859be
--- /dev/null
+++ b/amd64_lower_vcvtss2sd_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateAMD64VCVTSS2SDCompleteGo127Forms(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT vcvtss2sdforms(SB),$0-0\n")
+			for _, op := range []string{"VCVTSS2SD", "VCVTSD2SS"} {
+				fmt.Fprintf(&source, "\t%s X0, X1, X2\n", op)
+				fmt.Fprintf(&source, "\t%s (AX), X3, X4\n", op)
+				fmt.Fprintf(&source, "\t%s X31, X30, X29\n", op)
+				if op == "VCVTSS2SD" {
+					fmt.Fprintf(&source, "\t%s.SAE X31, X30, X29\n", op)
+				} else {
+					for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						fmt.Fprintf(&source, "\t%s.%s X31, X30, X29\n", op, rounding)
+					}
+				}
+				if target.goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s X31, X30, K1, X29\n", op)
+					fmt.Fprintf(&source, "\t%s.Z (AX), X30, K2, X29\n", op)
+					if op == "VCVTSS2SD" {
+						fmt.Fprintf(&source, "\t%s.SAE.Z X31, X30, K3, X29\n", op)
+					} else {
+						fmt.Fprintf(&source, "\t%s.RD_SAE.Z X31, X30, K3, X29\n", op)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86ScalarPrecisionOriginalFormatObject(t, source.String(), "vcvtss2sdforms", target.goarch, target.triple, false)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "vcvtss2sd-"+target.name+".ll", "vcvtss2sd-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ScalarPrecisionConvertRejectsFormsOutsideGo127(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		triple      string
+		instruction string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSS2SD.RD_SAE X0, X1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSD2SS.SAE X0, X1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSS2SD.SAE (AX), X1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSD2SS.RN_SAE (AX), X1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSS2SD.Z X0, X1, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSD2SS X0, X1, K0, X2"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu", instruction: "VCVTSS2SD Y0, X1, X2"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu", instruction: "VCVTSD2SS X0, X1, K1, X2"},
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),NOSPLIT,$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err == nil {
+				_, err = Translate(file, Options{
+					TargetTriple: test.triple,
+					Goarch:       test.goarch,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+			}
+			if err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar precision-conversion forms for %s", test.instruction, test.goarch)
+			}
+		})
+	}
+}
+
+func qualifyAMD64ScalarPrecisionConvertRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT scalarPrecisionConvertSemantics(SB),NOSPLIT,$0-48
+	MOVQ out+0(FP), AX
+	MOVQ doubles+8(FP), BX
+	MOVQ floats+16(FP), CX
+	MOVQ upper+24(FP), DX
+	MOVQ old+32(FP), SI
+	KMOVQ mask+40(FP), K1
+	MOVSD (BX), X0
+	MOVUPS (DX), X1
+	MOVUPS (SI), X2
+	VCVTSD2SS.RN_SAE X0, X1, X2
+	MOVUPS X2, 0(AX)
+	VCVTSD2SS.RD_SAE X0, X1, X2
+	MOVUPS X2, 16(AX)
+	VCVTSD2SS.RU_SAE X0, X1, X2
+	MOVUPS X2, 32(AX)
+	VCVTSD2SS.RZ_SAE X0, X1, X2
+	MOVUPS X2, 48(AX)
+	MOVUPS (SI), X2
+	VCVTSD2SS.RU_SAE X0, X1, K1, X2
+	MOVUPS X2, 64(AX)
+	MOVUPS (SI), X2
+	VCVTSD2SS.RU_SAE.Z X0, X1, K1, X2
+	MOVUPS X2, 80(AX)
+	MOVSS (CX), X0
+	VCVTSS2SD.SAE X0, X1, X2
+	MOVUPS X2, 96(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: I64, Index: 5, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"scalarPrecisionConvertSemantics": {Name: "scalarPrecisionConvertSemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void scalarPrecisionConvertSemantics(uint32_t *, const double *, const float *, const uint32_t *, const uint32_t *, uint64_t);
+int main(void) {
+  double input = 1.0 + 0x1p-24;
+  float input32 = 1.5f;
+  uint32_t upper[4] = {0xaaaaaaaaU, 0x11111111U, 0x22222222U, 0x33333333U};
+  uint32_t old[4] = {0xdeadbeefU, 0xbbbbbbbbU, 0xccccccccU, 0xddddddddU};
+  uint32_t out[28] = {0};
+  scalarPrecisionConvertSemantics(out, &input, &input32, upper, old, 0);
+  uint32_t low[4] = {0x3f800000U, 0x3f800000U, 0x3f800001U, 0x3f800000U};
+  for (int group = 0; group < 4; group++) {
+    if (out[group*4] != low[group]) return 1 + group;
+    for (int lane = 1; lane < 4; lane++) if (out[group*4+lane] != upper[lane]) return 10 + group*4 + lane;
+  }
+  if (out[16] != old[0]) return 40;
+  if (out[20] != 0) return 41;
+  for (int lane = 1; lane < 4; lane++) {
+    if (out[16+lane] != upper[lane]) return 42 + lane;
+    if (out[20+lane] != upper[lane]) return 46 + lane;
+  }
+  uint64_t converted = 0, want = 0x3ff8000000000000ULL;
+  memcpy(&converted, &out[24], sizeof(converted));
+  if (converted != want) return 60;
+  if (out[26] != upper[2] || out[27] != upper[3]) return 61;
+  return 0;
+}
+`
+	x86OriginalFloatingRuntimeRequireCPU(t, "scalar-precision", clang, triple, runPrefix)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_precision_convert", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_vec.go b/amd64_lower_vec.go
index ebfb7a52f..d469d3299 100644
--- a/amd64_lower_vec.go
+++ b/amd64_lower_vec.go
@@ -2,126 +2,192 @@ package plan9asm
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 )
 
 func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if known, term, err := c.lowerSHA(op, ins); known {
+		return known, term, err
+	}
+	if known, term, err := c.lowerSqrt(op, ins); known {
+		return known, term, err
+	}
+	if known, term, err := c.lowerLegacyPackedMove(op, ins); known {
+		return known, term, err
+	}
+	if ok, term, err := c.lowerFloatArithmetic(op, ins, ""); ok {
+		return ok, term, err
+	}
+	if ok, terminated, err := c.lowerVectorZero(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, term, err := c.lowerInsertExtractFamily(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedLogicalFamily(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerFourSource(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedStringCompare(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerExplicitMaskMove(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPermute128(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerIndexedPermute(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerQwordBitLookup(op, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerMaskVectorMove(op, ins); ok {
+		return ok, term, err
+	}
+	rawOp := op
+	if ok, term, err := c.lowerSingleSourceIntegerNarrow(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedIntegerInsert(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerScalarFloatBroadcast(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerAES(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedWordShuffle(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedByteShuffle(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedBitCount(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedConflict(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedExpand(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerGFNI(rawOp, ins); ok {
+		return ok, term, err
+	}
+	if ok, term, err := c.lowerPackedCompress(rawOp, ins); ok {
+		return ok, term, err
+	}
+	zeroMasking := false
 	if raw := string(op); strings.Contains(raw, ".") {
+		for _, suffix := range strings.Split(raw, ".")[1:] {
+			if suffix == "Z" {
+				zeroMasking = true
+			}
+		}
 		if i := strings.IndexByte(raw, '.'); i >= 0 {
 			op = Op(raw[:i])
 		}
 	}
-	switch op {
-	case "MOVOU", "MOVOA", "MOVUPS", "MOVAPS", "MOVO", "MOVQ", "MOVL", "MOVD",
-		"VMOVDQU", "VMOVDQA", "VMOVNTDQ", "VMOVDQU64", "VMOVDQA64", "VMOVAPS", "VMOVAPD",
-		"VPCMPEQB", "VPCMPGTB", "VPMOVMSKB", "VZEROUPPER", "VZEROALL", "VPBROADCASTB", "VPBROADCASTQ", "VPAND", "VPXOR", "VPOR", "VPADDD", "VPADDQ", "VPTEST",
-		"VPANDQ", "VPXORQ", "VPORQ", "VPCLMULQDQ", "VPTERNLOGD", "VEXTRACTF32X4",
-		"VPERMB", "VGF2P8AFFINEQB", "VPERMI2B", "VPCOMPRESSQ", "VPOPCNTB", "VPCMPUQ",
-		"VBROADCASTI128", "VBROADCASTF32X2", "VBROADCASTSD", "VXORPD",
-		"VPSHUFB", "VPSHUFD", "VPSLLD", "VPSRLD", "VPSRLQ", "VPSLLQ", "VPSRLDQ", "VPSLLDQ", "VPUNPCKLBW", "VPUNPCKHBW",
-		"VPALIGNR", "VPERM2I128", "VPERM2F128", "VINSERTI128", "VPBLENDD",
-		"PXOR", "POR", "PAND", "PANDN", "PADDD", "PADDL", "PSUBB", "PSUBL", "PMULULQ", "PCLMULQDQ", "PCMPEQB", "PCMPEQL", "PCMPGTB", "PMOVMSKB",
-		"PSHUFB", "PSRLDQ", "PSLLDQ", "PSRLQ", "PSLLW", "PSRLW", "PSRLL", "PSLLL", "PSRAL", "PEXTRD", "PEXTRB", "PEXTRQ",
-		"PINSRQ", "PINSRD", "PINSRB", "PINSRW", "PALIGNR", "PUNPCKLBW", "PUNPCKHBW", "PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PSHUFL", "PSHUFD", "PSHUFHW", "SHUFPS",
-		"PBLENDW", "PADDQ", "KMOVB", "KMOVW", "KMOVQ", "KXORQ",
-		"SHA1NEXTE", "SHA1MSG1", "SHA1MSG2", "SHA1RNDS4", "SHA256MSG1", "SHA256MSG2", "SHA256RNDS2",
-		"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST", "PCMPESTRI":
-		// ok
-	default:
-		return false, false, nil
+	if _, alias := x86GoMOVQSourceAliases[op]; alias {
+		if rawOp != op {
+			return true, false, fmt.Errorf("%s MOVD does not accept instruction suffixes: %q", c.goarch, ins.Raw)
+		}
+		if known, terminated, err := c.lowerMachineRegisterMove("MOVQ", ins); known {
+			return known, terminated, err
+		}
+		if err := c.validateMOVDAliasForm(ins); err != nil {
+			return true, false, err
+		}
+		// Go source aliases share AMOVQ's rows, not Intel's mnemonic scope.
+		// Change local dispatch only; keep source/caller certificate identity.
+		dispatch := ins
+		dispatch.Op = op
+		op = x86SourceMoveInstruction(dispatch, c.goarch).Op
 	}
-
-	// MOVL src, Xn (seed vector low 32 bits).
-	if op == "MOVL" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); ok {
-			var v64 string
-			var err error
-			switch ins.Args[0].Kind {
-			case OpImm, OpReg, OpFP, OpMem, OpSym:
-				v64, err = c.evalI64(ins.Args[0])
-			default:
-				return true, false, fmt.Errorf("amd64 MOVL to X reg unsupported src: %q", ins.Raw)
-			}
-			if err != nil {
-				return true, false, err
-			}
-			tr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, v64)
-			// Build <4 x i32> { crc, 0, 0, 0 } then bitcast to <16 x i8>.
-			v0 := "%" + tr
-			tvec := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> zeroinitializer, i32 %s, i32 0\n", tvec, v0)
-			bc := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bc, tvec)
-			return true, false, c.storeX(ins.Args[1].Reg, "%"+bc)
+	if _, ok := amd64MaskMoveSpecs[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", op, ins.Raw)
 		}
+		return true, false, c.lowerMaskMove(op, ins)
 	}
-	// MOVL Xn, dst stores the low 32 bits of the vector register.
-	if op == "MOVL" && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg {
-		if _, ok := amd64ParseXReg(ins.Args[0].Reg); ok {
-			vec, err := c.loadX(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			words := c.newTmp()
-			low := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", words, vec)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %%%s, i32 0\n", low, words)
-			switch ins.Args[1].Kind {
-			case OpReg:
-				return true, false, c.storeRegSized(ins.Args[1].Reg, I32, "%"+low)
-			case OpFP:
-				return true, false, c.storeFPResult(ins.Args[1].FPOffset, I32, "%"+low)
-			case OpMem:
-				p, ptrType, err := c.ptrFromMem(ins.Args[1].Mem)
-				if err != nil {
-					return true, false, err
-				}
-				fmt.Fprintf(c.b, "  store i32 %%%s, %s %s, align 1\n", low, ptrType, p)
-				return true, false, nil
-			case OpSym:
-				p, err := c.ptrFromSB(ins.Args[1].Sym)
-				if err != nil {
-					return true, false, err
-				}
-				fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s, align 1\n", low, p)
-				return true, false, nil
-			default:
-				return true, false, fmt.Errorf("amd64 MOVL from X reg unsupported dst: %q", ins.Raw)
-			}
+	if _, ok := amd64GatherSpecs[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", op, ins.Raw)
 		}
+		return true, false, c.lowerGather(op, ins)
 	}
-
-	// MOVD reg, Xn (seed vector with low 32-bit value)
-	if op == "MOVD" && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg {
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); ok {
-			v64, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			tr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", tr, v64)
-			// Build <4 x i32> { v, 0, 0, 0 } then bitcast to <16 x i8>.
-			v0 := "%" + tr
-			tvec := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> zeroinitializer, i32 %s, i32 0\n", tvec, v0)
-			bc := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bc, tvec)
-			return true, false, c.storeX(ins.Args[1].Reg, "%"+bc)
-		}
-	}
-
-	if op == "VZEROUPPER" || op == "VZEROALL" {
-		// These instructions affect registers 0-15, including their ZMM view.
-		for i := 0; i < 16; i++ {
-			c.clearVectorUpper(i, 16)
-			if op == "VZEROALL" {
-				if slot := c.xRegSlot[i]; slot != "" {
-					fmt.Fprintf(c.b, "  store <16 x i8> zeroinitializer, ptr %s\n", slot)
-				}
-			}
+	if _, ok := amd64VSIBPrefetchSpecs[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerGather(op, ins)
+	}
+	if _, ok := amd64MaskLogicalSpecs[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerMaskLogical(op, ins)
+	}
+	if _, ok := amd64MaskArithmeticSpecs[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, op, ins.Raw)
+		}
+		return true, false, c.lowerMaskArithmetic(op, ins)
+	}
+	if _, ok := amd64MaskUnpackBits[op]; ok {
+		if rawOp != op {
+			return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, op, ins.Raw)
 		}
-		return true, false, nil
+		return true, false, c.lowerMaskUnpack(op, ins)
+	}
+	if _, ok := amd64TernaryLogicSpecs[op]; ok {
+		return c.lowerTernaryLogic(rawOp, ins)
+	}
+	if _, ok := amd64VectorAlignSpecs[op]; ok {
+		return c.lowerVectorAlign(rawOp, ins)
+	}
+	if _, ok := amd64IFMASpecs[op]; ok {
+		return c.lowerIFMA(rawOp, ins)
+	}
+	if _, ok := amd64FunnelShiftSpecs[op]; ok {
+		return c.lowerFunnelShift(rawOp, ins)
+	}
+	if _, ok := amd64PackedRotateSpecs[op]; ok {
+		return c.lowerPackedRotate(rawOp, ins)
+	}
+	if _, ok := amd64FMA3Specs[op]; ok {
+		return c.lowerFMA3(rawOp, ins)
+	}
+	if _, ok := amd64BinaryFloatingSpecs[op]; ok {
+		return c.lowerBinaryFloating(rawOp, ins)
+	}
+	if _, ok := amd64HorizontalFloatingSpecs[op]; ok {
+		return c.lowerHorizontalFloating(rawOp, ins)
+	}
+	switch op {
+	case "MOVOU", "MOVOA", "MOVUPS", "MOVAPS", "MOVO", "MOVQ", "VMOVQ", "MOVL", "MOVD",
+		"VMOVDQU", "VMOVDQA", "VMOVNTDQ", "VMOVDQU64", "VMOVDQA64", "VMOVAPS", "VMOVAPD",
+		"VPCMPEQB", "VPCMPGTB", "VZEROUPPER", "VZEROALL", "VPBROADCASTB", "VPBROADCASTD", "VPBROADCASTQ", "VPAND", "VPXOR", "VPOR", "VPADDD", "VPADDQ", "VPSUBB", "VPTEST", "VTESTPD", "VTESTPS",
+		"VPCLMULQDQ", "VEXTRACTF32X4",
+		"VPCMPUQ",
+		"VBROADCASTF32X2", "VBROADCASTSD",
+		"VPSHUFB", "VPSHUFD", "VPSLLD", "VPSLLQ", "VPSLLW", "VPSRAD", "VPSRAW", "VPSRLD", "VPSRLQ", "VPSRLW", "VPSRLDQ", "VPSLLDQ", "VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+		"VPALIGNR", "VPERM2I128", "VPERM2F128", "VINSERTI128", "VPBLENDD",
+		"PXOR", "POR", "PAND", "PADDB", "PADDD", "PADDL", "PSUBB", "PSUBL", "PSUBUSB", "PMULLW", "PCLMULQDQ", "PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPGTB", "PABSD", "PTEST",
+		"PMINUB", "PMINSB", "PMINUW", "PMINSW", "PMINUD", "PMINSD", "PMAXUB", "PMAXSB", "PMAXUW", "PMAXSW", "PMAXUD", "PMAXSD",
+		"PSHUFB", "PSRLDQ", "PSLLDQ", "PSRLO", "PSLLO", "PSRLQ", "PSLLQ", "PSLLW", "PSRLW", "PSRLL", "PSLLL", "PSRAL", "PEXTRD", "PEXTRB", "PEXTRQ",
+		"PALIGNR", "PUNPCKLBW", "PUNPCKHBW", "PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PUNPCKHQDQ", "PSHUFL", "PSHUFD", "SHUFPS",
+		"PBLENDW", "PADDQ",
+		"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST":
+		// ok
+	default:
+		return false, false, nil
 	}
 
 	if op == "VMOVDQA" {
@@ -130,8 +196,11 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 	if op == "VMOVDQA64" {
 		op = "VMOVDQU64"
 	}
-	if op == "VPERM2F128" {
-		op = "VPERM2I128"
+	if op == "PSLLO" {
+		op = "PSLLDQ"
+	}
+	if op == "PSRLO" {
+		op = "PSRLDQ"
 	}
 	if op == "VMOVAPS" || op == "VMOVAPD" {
 		if len(ins.Args) == 2 {
@@ -143,324 +212,8 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 			}
 		}
 	}
-	if op == "VPXORQ" || op == "VPANDQ" || op == "VPORQ" {
-		if len(ins.Args) == 3 && ins.Args[2].Kind == OpReg && !isAMD64ZReg(ins.Args[2].Reg) {
-			switch op {
-			case "VPXORQ":
-				op = "VPXOR"
-			case "VPANDQ":
-				op = "VPAND"
-			case "VPORQ":
-				op = "VPOR"
-			}
-		}
-	}
-
-	// MOVUPS/MOVAPS/MOVO are aliases for unaligned/aligned 128-bit xmm moves.
-	if op == "MOVUPS" || op == "MOVAPS" || op == "MOVO" {
-		op = "MOVOU"
-	}
-
-	// MOVQ src, Xn (load low 64 bits into Xn)
-	if op == "MOVQ" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); ok {
-			var low string
-			switch ins.Args[0].Kind {
-			case OpImm:
-				low = fmt.Sprintf("%d", ins.Args[0].Imm)
-			case OpReg:
-				v, err := c.loadReg(ins.Args[0].Reg)
-				if err != nil {
-					return true, false, err
-				}
-				low = v
-			case OpFP:
-				v, err := c.evalFPToI64(ins.Args[0].FPOffset)
-				if err != nil {
-					return true, false, err
-				}
-				low = v
-			case OpMem:
-				addr, err := c.addrFromMem(ins.Args[0].Mem)
-				if err != nil {
-					return true, false, err
-				}
-				p := c.ptrFromAddrI64(addr)
-				ld := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-				low = "%" + ld
-			case OpSym:
-				p, err := c.ptrFromSB(ins.Args[0].Sym)
-				if err != nil {
-					return true, false, err
-				}
-				ld := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", ld, p)
-				low = "%" + ld
-			default:
-				return true, false, fmt.Errorf("amd64 MOVQ to X reg unsupported src: %q", ins.Raw)
-			}
-			// Build <2 x i64> { low, 0 }.
-			ins0 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %s, i32 0\n", ins0, low)
-			bc := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, ins0)
-			return true, false, c.storeX(ins.Args[1].Reg, "%"+bc)
-		}
-	}
-
-	// MOVQ Xn, dst (extract low 64 bits from Xn).
-	if op == "MOVQ" && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg {
-		if _, ok := amd64ParseXReg(ins.Args[0].Reg); ok {
-			xv, err := c.loadX(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			bc := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, xv)
-			lo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", lo, bc)
-			switch ins.Args[1].Kind {
-			case OpReg:
-				return true, false, c.storeReg(ins.Args[1].Reg, "%"+lo)
-			case OpMem:
-				addr, err := c.addrFromMem(ins.Args[1].Mem)
-				if err != nil {
-					return true, false, err
-				}
-				p := c.ptrFromAddrI64(addr)
-				fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s, align 1\n", lo, p)
-				return true, false, nil
-			default:
-				return true, false, fmt.Errorf("amd64 MOVQ from X reg unsupported dst: %q", ins.Raw)
-			}
-		}
-	}
 
 	switch op {
-	case "KXORQ":
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 KXORQ expects Ksrc1, Ksrc2, Kdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseKReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseKReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseKReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		a, err := c.loadK(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.loadK(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		x := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %s\n", x, a, b)
-		return true, false, c.storeK(ins.Args[2].Reg, "%"+x)
-
-	case "KMOVB", "KMOVW", "KMOVQ":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects 2 operands: %q", op, ins.Raw)
-		}
-		bits := 64
-		loadTy := "i64"
-		switch op {
-		case "KMOVB":
-			bits, loadTy = 8, "i8"
-		case "KMOVW":
-			bits, loadTy = 16, "i16"
-		}
-		maskValue := func(v string) string {
-			if bits == 64 {
-				return v
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", t, v, (uint64(1)<<bits)-1)
-			return "%" + t
-		}
-		loadToI64 := func(opnd Operand) (string, error) {
-			switch opnd.Kind {
-			case OpReg:
-				if _, ok := amd64ParseKReg(opnd.Reg); ok {
-					v, err := c.loadK(opnd.Reg)
-					if err != nil {
-						return "", err
-					}
-					return maskValue(v), nil
-				}
-				v, err := c.loadReg(opnd.Reg)
-				if err != nil {
-					return "", err
-				}
-				return maskValue(v), nil
-			case OpMem:
-				addr, err := c.addrFromMem(opnd.Mem)
-				if err != nil {
-					return "", err
-				}
-				p := c.ptrFromAddrI64(addr)
-				ld := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", ld, loadTy, p)
-				if bits == 64 {
-					return "%" + ld, nil
-				}
-				z := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = zext %s %%%s to i64\n", z, loadTy, ld)
-				return "%" + z, nil
-			default:
-				return "", fmt.Errorf("amd64 %s unsupported src: %q", op, ins.Raw)
-			}
-		}
-		storeFromI64 := func(opnd Operand, v string) error {
-			switch opnd.Kind {
-			case OpReg:
-				if _, ok := amd64ParseKReg(opnd.Reg); ok {
-					return c.storeK(opnd.Reg, maskValue(v))
-				}
-				if bits == 64 {
-					return c.storeReg(opnd.Reg, v)
-				}
-				return c.storeReg(opnd.Reg, maskValue(v))
-			case OpMem:
-				addr, err := c.addrFromMem(opnd.Mem)
-				if err != nil {
-					return err
-				}
-				p := c.ptrFromAddrI64(addr)
-				if bits == 64 {
-					fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", v, p)
-					return nil
-				}
-				tr := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", tr, v, loadTy)
-				fmt.Fprintf(c.b, "  store %s %%%s, ptr %s, align 1\n", loadTy, tr, p)
-				return nil
-			default:
-				return fmt.Errorf("amd64 %s unsupported dst: %q", op, ins.Raw)
-			}
-		}
-		v, err := loadToI64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		return true, false, storeFromI64(ins.Args[1], v)
-
-	case "VPERMB":
-		if len(ins.Args) != 3 && len(ins.Args) != 4 {
-			return true, false, fmt.Errorf("amd64 VPERMB expects idx, src, dst or idx, src, Kmask, dst: %q", ins.Raw)
-		}
-		dstIdx := 2
-		if len(ins.Args) == 4 {
-			dstIdx = 3
-		}
-		if ins.Args[dstIdx].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPERMB expects Z destination register: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[dstIdx].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadZVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		if len(ins.Args) == 4 {
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 VPERMB masked form expects K mask register: %q", ins.Raw)
-			}
-			if _, ok := amd64ParseKReg(ins.Args[2].Reg); !ok {
-				return false, false, nil
-			}
-			maskv, err := c.loadK(ins.Args[2].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			src = amd64SelectZByAnyMask(c, src, maskv)
-		}
-		return true, false, c.storeZ(ins.Args[dstIdx].Reg, src)
-
-	case "VGF2P8AFFINEQB":
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VGF2P8AFFINEQB expects $imm, mat, src, dst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[3].Reg); ok {
-			if ins.Args[2].Kind == OpReg {
-				if _, ok := amd64ParseZReg(ins.Args[2].Reg); !ok {
-					return false, false, nil
-				}
-			}
-			src, err := c.loadZVecOperand(ins.Args[2])
-			if err != nil {
-				return true, false, err
-			}
-			return true, false, c.storeZ(ins.Args[3].Reg, src)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[3].Reg); ok {
-			if ins.Args[2].Kind == OpReg {
-				if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-					return false, false, nil
-				}
-			}
-			src, err := c.loadYVecOperand(ins.Args[2])
-			if err != nil {
-				return true, false, err
-			}
-			return true, false, c.storeY(ins.Args[3].Reg, src)
-		}
-		return false, false, nil
-
-	case "VPERMI2B":
-		if len(ins.Args) != 3 && len(ins.Args) != 4 {
-			return true, false, fmt.Errorf("amd64 VPERMI2B expects src1, src2, dst or src1, src2, Kmask, dst: %q", ins.Raw)
-		}
-		dstIdx := 2
-		srcIdx := 1
-		if len(ins.Args) == 4 {
-			dstIdx = 3
-		}
-		if ins.Args[dstIdx].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPERMI2B expects Z destination register: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[dstIdx].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadZVecOperand(ins.Args[srcIdx])
-		if err != nil {
-			return true, false, err
-		}
-		if len(ins.Args) == 4 {
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("amd64 VPERMI2B masked form expects K mask register: %q", ins.Raw)
-			}
-			if _, ok := amd64ParseKReg(ins.Args[2].Reg); !ok {
-				return false, false, nil
-			}
-			maskv, err := c.loadK(ins.Args[2].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			src = amd64SelectZByAnyMask(c, src, maskv)
-		}
-		return true, false, c.storeZ(ins.Args[dstIdx].Reg, src)
-
-	case "VPOPCNTB":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPOPCNTB expects src, Zdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadZVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		out := amd64BytePopcountZ(c, src)
-		return true, false, c.storeZ(ins.Args[1].Reg, out)
-
 	case "VPCMPUQ":
 		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[3].Kind != OpReg {
 			return true, false, fmt.Errorf("amd64 VPCMPUQ expects $imm, src1, src2, Kdst: %q", ins.Raw)
@@ -500,94 +253,92 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		maskv := amd64PackI1x8ToI64(c, "%"+cmp)
 		return true, false, c.storeK(ins.Args[3].Reg, maskv)
 
-	case "VPCOMPRESSQ":
-		if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPCOMPRESSQ expects Zsrc, Kmask, Zdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseKReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseZReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadZVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
+	case "VPBROADCASTD":
+		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 VPBROADCASTD expects scalar src, vector dst: %q", ins.Raw)
 		}
-		maskv, err := c.loadK(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		sv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <64 x i8> %s to <8 x i64>\n", sv, src)
-		outVec := "zeroinitializer"
-		writePos := "0"
-		for i := 0; i < 8; i++ {
-			bit := amd64MaskBitI1(c, maskv, i)
-			lane := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractelement <8 x i64> %%%s, i32 %d\n", lane, sv, i)
-			inserted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i64> %s, i64 %%%s, i32 %s\n", inserted, outVec, lane, writePos)
-			selected := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %s, <8 x i64> %%%s, <8 x i64> %s\n", selected, bit, inserted, outVec)
-			step := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i32\n", step, bit)
-			nextPos := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %%%s\n", nextPos, writePos, step)
-			outVec = "%" + selected
-			writePos = "%" + nextPos
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i64> %s to <64 x i8>\n", out, outVec)
-		return true, false, c.storeZ(ins.Args[2].Reg, "%"+out)
-
-	case "VPXORQ", "VPANDQ", "VPORQ":
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src1, src2, dstReg: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		a, err := c.loadZVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.loadZVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		ab := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <64 x i8> %s to <8 x i64>\n", ab, a)
-		bb := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <64 x i8> %s to <8 x i64>\n", bb, b)
-		t := c.newTmp()
-		switch op {
-		case "VPXORQ":
-			fmt.Fprintf(c.b, "  %%%s = xor <8 x i64> %%%s, %%%s\n", t, ab, bb)
-		case "VPANDQ":
-			fmt.Fprintf(c.b, "  %%%s = and <8 x i64> %%%s, %%%s\n", t, ab, bb)
-		case "VPORQ":
-			fmt.Fprintf(c.b, "  %%%s = or <8 x i64> %%%s, %%%s\n", t, ab, bb)
+		var low32 string
+		if ins.Args[0].Kind == OpReg {
+			if _, ok := amd64ParseXReg(ins.Args[0].Reg); ok {
+				value, err := c.loadX(ins.Args[0].Reg)
+				if err != nil {
+					return true, false, err
+				}
+				words := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", words, value)
+				extracted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %%%s, i32 0\n", extracted, words)
+				low32 = "%" + extracted
+			}
 		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i64> %%%s to <64 x i8>\n", out, t)
-		return true, false, c.storeZ(ins.Args[2].Reg, "%"+out)
-
-	case "VBROADCASTI128":
-		// VBROADCASTI128 Xsrc|mem, Ydst
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VBROADCASTI128 expects Xsrc|mem, Ydst: %q", ins.Raw)
+		if low32 == "" {
+			var value64 string
+			var err error
+			switch ins.Args[0].Kind {
+			case OpMem:
+				addr, addrErr := c.addrFromMem(ins.Args[0].Mem)
+				if addrErr != nil {
+					return true, false, addrErr
+				}
+				loaded := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", loaded, c.ptrFromAddrI64(addr))
+				low32 = "%" + loaded
+			case OpSym:
+				p, ptrErr := c.ptrFromSB(ins.Args[0].Sym)
+				if ptrErr != nil {
+					return true, false, ptrErr
+				}
+				loaded := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", loaded, p)
+				low32 = "%" + loaded
+			default:
+				value64, err = c.evalI64(ins.Args[0])
+				if err != nil {
+					return true, false, err
+				}
+			}
+			if low32 == "" {
+				truncated := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncated, value64)
+				low32 = "%" + truncated
+			}
 		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
+		lanes := 0
+		store := func(string) error { return nil }
+		switch {
+		case isAMD64XReg(ins.Args[1].Reg):
+			lanes = 4
+			store = func(value string) error {
+				bytesValue := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %s to <16 x i8>\n", bytesValue, value)
+				return c.storeX(ins.Args[1].Reg, "%"+bytesValue)
+			}
+		case isAMD64YReg(ins.Args[1].Reg):
+			lanes = 8
+			store = func(value string) error {
+				bytesValue := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i32> %s to <32 x i8>\n", bytesValue, value)
+				return c.storeY(ins.Args[1].Reg, "%"+bytesValue)
+			}
+		case isAMD64ZReg(ins.Args[1].Reg):
+			lanes = 16
+			store = func(value string) error {
+				bytesValue := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i32> %s to <64 x i8>\n", bytesValue, value)
+				return c.storeZ(ins.Args[1].Reg, "%"+bytesValue)
+			}
+		default:
 			return false, false, nil
 		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
+		seed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i32> zeroinitializer, i32 %s, i32 0\n", seed, lanes, low32)
+		mask := make([]string, lanes)
+		for i := range mask {
+			mask[i] = "i32 0"
 		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> %s, <32 x i32> %s\n", out, src, src, llvmRepeatI8Mask(16, 32))
-		return true, false, c.storeY(ins.Args[1].Reg, "%"+out)
+		broadcast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i32> %%%s, <%d x i32> zeroinitializer, <%d x i32> <%s>\n", broadcast, lanes, seed, lanes, lanes, strings.Join(mask, ", "))
+		return true, false, store("%" + broadcast)
 
 	case "VBROADCASTF32X2", "VBROADCASTSD", "VPBROADCASTQ":
 		// These instructions broadcast the low 64 source bits. Their lane
@@ -612,769 +363,182 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		if ins.Args[0].Kind == OpSym && strings.HasPrefix(strings.TrimSpace(ins.Args[0].Sym), "$") {
 			return false, false, nil
 		}
-		var v64 string
-		if ins.Args[0].Kind == OpReg {
-			if _, ok := amd64ParseXReg(ins.Args[0].Reg); ok {
-				xv, err := c.loadX(ins.Args[0].Reg)
-				if err != nil {
-					return true, false, err
-				}
-				words := c.newTmp()
-				low := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", words, xv)
-				fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", low, words)
-				v64 = "%" + low
-			} else if op != "VPBROADCASTQ" {
-				return false, false, nil
-			}
-		}
-		if v64 == "" {
-			var err error
-			v64, err = c.evalI64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-		}
-		chunk := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <8 x i8>\n", chunk, v64)
-		if dstIsX {
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <16 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 16))
-			return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); ok {
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <32 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 32))
-			return true, false, c.storeY(ins.Args[1].Reg, "%"+out)
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <64 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 64))
-		return true, false, c.storeZ(ins.Args[1].Reg, "%"+out)
-
-	case "VXORPD":
-		// VXORPD src1, src2, dst; this is a bitwise operation despite the
-		// floating-point mnemonic, so byte-vector xor preserves all bits.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VXORPD expects src1, src2, dst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[2].Reg); ok {
-			a, err := c.loadZVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadZVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <64 x i8> %s, %s\n", t, a, b)
-			return true, false, c.storeZ(ins.Args[2].Reg, "%"+t)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); ok {
-			a, err := c.loadYVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadYVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <32 x i8> %s, %s\n", t, a, b)
-			return true, false, c.storeY(ins.Args[2].Reg, "%"+t)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); ok {
-			a, err := c.loadXVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadXVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", t, a, b)
-			return true, false, c.storeX(ins.Args[2].Reg, "%"+t)
-		}
-		return false, false, nil
-
-	case "VPXOR", "VPOR", "VPADDD", "VPADDQ":
-		// V* three-operand op; support both X and Y destinations.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects src1, src2, dstReg: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); ok {
-			a, err := c.loadYVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadYVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			switch op {
-			case "VPXOR":
-				fmt.Fprintf(c.b, "  %%%s = xor <32 x i8> %s, %s\n", t, a, b)
-			case "VPOR":
-				fmt.Fprintf(c.b, "  %%%s = or <32 x i8> %s, %s\n", t, a, b)
-			case "VPADDD":
-				ab := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <8 x i32>\n", ab, a)
-				bb := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <8 x i32>\n", bb, b)
-				add := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add <8 x i32> %%%s, %%%s\n", add, ab, bb)
-				fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i32> %%%s to <32 x i8>\n", t, add)
-			case "VPADDQ":
-				ab := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", ab, a)
-				bb := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", bb, b)
-				add := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add <4 x i64> %%%s, %%%s\n", add, ab, bb)
-				fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", t, add)
-			}
-			return true, false, c.storeY(ins.Args[2].Reg, "%"+t)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); ok {
-			a, err := c.loadXVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadXVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			t := c.newTmp()
-			switch op {
-			case "VPXOR":
-				fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", t, a, b)
-			case "VPOR":
-				fmt.Fprintf(c.b, "  %%%s = or <16 x i8> %s, %s\n", t, a, b)
-			case "VPADDD":
-				ab := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", ab, a)
-				bb := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bb, b)
-				add := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, %%%s\n", add, ab, bb)
-				fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", t, add)
-			case "VPADDQ":
-				ab := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", ab, a)
-				bb := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bb, b)
-				add := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add <2 x i64> %%%s, %%%s\n", add, ab, bb)
-				fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", t, add)
-			}
-			return true, false, c.storeX(ins.Args[2].Reg, "%"+t)
-		}
-		return false, false, nil
-
-	case "VPSHUFB":
-		// VPSHUFB Ymask, Ysrc, Ydst
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPSHUFB expects Ymask, Ysrc, Ydst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); ok {
-			mask, err := c.loadYVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			src, err := c.loadYVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			// Emulate 256-bit PSHUFB by lane-splitting into two 128-bit shuffles.
-			srcLo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", srcLo, src, llvmI32RangeMask(0, 16))
-			srcHi := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", srcHi, src, llvmI32RangeMask(16, 16))
-			maskLo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", maskLo, mask, llvmI32RangeMask(0, 16))
-			maskHi := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", maskHi, mask, llvmI32RangeMask(16, 16))
-			outLo := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %%%s, <16 x i8> %%%s)\n", outLo, srcLo, maskLo)
-			outHi := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %%%s, <16 x i8> %%%s)\n", outHi, srcHi, maskHi)
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> %%%s, <32 x i32> %s\n", out, outLo, outHi, llvmI32RangeMask(0, 32))
-			return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); ok {
-			mask, err := c.loadXVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			src, err := c.loadXVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %s, <16 x i8> %s)\n", call, src, mask)
-			return true, false, c.storeX(ins.Args[2].Reg, "%"+call)
-		}
-		return false, false, nil
-
-	case "VPSHUFD":
-		// VPSHUFD $imm, Ysrc, Ydst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPSHUFD expects $imm, Ysrc, Ydst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		idx := func(k uint) uint64 { return (imm >> (2 * k)) & 3 }
-		src, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <8 x i32>\n", bc, src)
-		mask := fmt.Sprintf("<8 x i32> <i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d>",
-			idx(0), idx(1), idx(2), idx(3),
-			4+idx(0), 4+idx(1), 4+idx(2), 4+idx(3))
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i32> %%%s, <8 x i32> zeroinitializer, %s\n", sh, bc, mask)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i32> %%%s to <32 x i8>\n", out, sh)
-		return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
-
-	case "VPSLLD", "VPSRLD":
-		// VPS*D $imm, Ysrc, Ydst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, Ysrc, Ydst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm & 31
-		src, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <8 x i32>\n", bc, src)
-		sh := c.newTmp()
-		if op == "VPSLLD" {
-			fmt.Fprintf(c.b, "  %%%s = shl <8 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = lshr <8 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i32> %%%s to <32 x i8>\n", out, sh)
-		return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
-
-	case "VPSRLQ", "VPSLLQ":
-		// VPSR/LQ $imm, Ysrc, Ydst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, Ysrc, Ydst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm & 63
-		src, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", bc, src)
-		sh := c.newTmp()
-		if op == "VPSLLQ" {
-			fmt.Fprintf(c.b, "  %%%s = shl <4 x i64> %%%s, <i64 %d, i64 %d, i64 %d, i64 %d>\n", sh, bc, n, n, n, n)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = lshr <4 x i64> %%%s, <i64 %d, i64 %d, i64 %d, i64 %d>\n", sh, bc, n, n, n, n)
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", out, sh)
-		return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
-
-	case "VPALIGNR":
-		// VPALIGNR $imm, Ysrc1, Ysrc2, Ydst ; dst = alignr(src2, src1, imm)
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPALIGNR expects $imm, Ysrc1, Ysrc2, Ydst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[3].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm
-		if n < 0 {
-			n = 0
-		}
-		if n > 255 {
-			n = 255
-		}
-		src1, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		src2, err := c.loadY(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		lo1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", lo1, src1, llvmI32RangeMask(0, 16))
-		hi1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", hi1, src1, llvmI32RangeMask(16, 16))
-		lo2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", lo2, src2, llvmI32RangeMask(0, 16))
-		hi2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", hi2, src2, llvmI32RangeMask(16, 16))
-		outLo := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> %%%s, <16 x i32> %s\n", outLo, lo2, lo1, llvmAlignRightBytesMask(n))
-		outHi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> %%%s, <16 x i32> %s\n", outHi, hi2, hi1, llvmAlignRightBytesMask(n))
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> %%%s, <32 x i32> %s\n", out, outLo, outHi, llvmI32RangeMask(0, 32))
-		return true, false, c.storeY(ins.Args[3].Reg, "%"+out)
-
-	case "VPERM2I128":
-		// VPERM2I128 $imm, Ysrc1, Ysrc2, Ydst
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPERM2I128 expects $imm, Ysrc1, Ysrc2, Ydst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[3].Reg); !ok {
-			return false, false, nil
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		// AT&T order: imm, src1, src2, dst ; choose lanes from src2 (arg2) + src1 (arg1).
-		src1, err := c.loadYVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		src2, err := c.loadYVecOperand(ins.Args[2])
-		if err != nil {
-			return true, false, err
-		}
-		sel := func(bits uint64) int {
-			switch bits & 0x3 {
-			case 0:
-				return 0 // src2 low
-			case 1:
-				return 1 // src2 high
-			case 2:
-				return 2 // src1 low
-			default:
-				return 3 // src1 high
-			}
-		}
-		lowSel := sel(imm)
-		hiSel := sel(imm >> 4)
-		mask := fmt.Sprintf("<4 x i32> <i32 %d, i32 %d, i32 %d, i32 %d>", lowSel, lowSel+4, hiSel, hiSel+4)
-		b2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", b2, src2)
-		b1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", b1, src1)
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i64> %%%s, <4 x i64> %%%s, %s\n", sh, b2, b1, mask)
-		// Zeroing controls.
-		zeroLo := (imm>>3)&1 == 1
-		zeroHi := (imm>>7)&1 == 1
-		if zeroLo || zeroHi {
-			cur := "%" + sh
-			if zeroLo {
-				i0 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %s, i64 0, i32 0\n", i0, cur)
-				i1 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 0, i32 1\n", i1, i0)
-				cur = "%" + i1
-			}
-			if zeroHi {
-				i2 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %s, i64 0, i32 2\n", i2, cur)
-				i3 := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 0, i32 3\n", i3, i2)
-				cur = "%" + i3
-			}
-			sh = strings.TrimPrefix(cur, "%")
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", out, sh)
-		return true, false, c.storeY(ins.Args[3].Reg, "%"+out)
-
-	case "VINSERTI128":
-		// VINSERTI128 $imm, Xsrc, Ysrc, Ydst
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VINSERTI128 expects $imm, Xsrc, Ysrc, Ydst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[3].Reg); !ok {
-			return false, false, nil
-		}
-		imm := ins.Args[0].Imm & 1
-		xsrc, err := c.loadXVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		ysrc, err := c.loadY(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		y64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <4 x i64>\n", y64, ysrc)
-		x64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", x64, xsrc)
-		i0 := c.newTmp()
-		i1 := c.newTmp()
-		if imm == 0 {
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", i0, x64)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 1\n", i1, x64)
-			s0 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 %%%s, i32 0\n", s0, y64, i0)
-			s1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 %%%s, i32 1\n", s1, s0, i1)
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", out, s1)
-			return true, false, c.storeY(ins.Args[3].Reg, "%"+out)
-		}
-		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", i0, x64)
-		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 1\n", i1, x64)
-		s0 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 %%%s, i32 2\n", s0, y64, i0)
-		s1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i64> %%%s, i64 %%%s, i32 3\n", s1, s0, i1)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i64> %%%s to <32 x i8>\n", out, s1)
-		return true, false, c.storeY(ins.Args[3].Reg, "%"+out)
-
-	case "VMOVNTDQ":
-		// VMOVNTDQ Ysrc, mem
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VMOVNTDQ expects Ysrc, dst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadY(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		switch ins.Args[1].Kind {
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[1].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			fmt.Fprintf(c.b, "  store <32 x i8> %s, ptr %s, align 1\n", src, p)
-			return true, false, nil
-		case OpSym:
-			p, err := c.ptrFromSB(ins.Args[1].Sym)
-			if err != nil {
-				return true, false, err
-			}
-			fmt.Fprintf(c.b, "  store <32 x i8> %s, ptr %s, align 1\n", src, p)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 VMOVNTDQ unsupported dst: %q", ins.Raw)
-		}
-
-	case "AESENC", "AESENCLAST", "AESDEC", "AESDECLAST":
-		// Two-operand form: OP Xsrc, Xdst
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		src2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", src2, src)
-		dst2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", dst2, dstv)
-		intr := map[Op]string{
-			"AESENC":     "@llvm.x86.aesni.aesenc",
-			"AESENCLAST": "@llvm.x86.aesni.aesenclast",
-			"AESDEC":     "@llvm.x86.aesni.aesdec",
-			"AESDECLAST": "@llvm.x86.aesni.aesdeclast",
-		}[op]
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> %s(<2 x i64> %%%s, <2 x i64> %%%s)\n", call, intr, dst2, src2)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, call)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+bc)
-
-	case "AESIMC":
-		// Two-operand form: AESIMC Xsrc, Xdst
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 AESIMC expects Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		src2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", src2, src)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.aesni.aesimc(<2 x i64> %%%s)\n", call, src2)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, call)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+bc)
-
-	case "AESKEYGENASSIST":
-		// Three-operand form: AESKEYGENASSIST $imm, Xsrc, Xdst
-		if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 AESKEYGENASSIST expects $imm, Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		if ins.Args[0].Kind != OpImm {
-			return true, false, fmt.Errorf("amd64 AESKEYGENASSIST expects immediate first operand: %q", ins.Raw)
-		}
-		imm := ins.Args[0].Imm & 0xff
-		src, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		src2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", src2, src)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.aesni.aeskeygenassist(<2 x i64> %%%s, i8 %d)\n", call, src2, imm)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, call)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc)
-
-	case "VPTEST":
-		// VPTEST Ysrc1, Ysrc2 (sets flags based on bitwise tests; used with JZ/JNZ).
-		// We implement the ZF behavior (ZF=1 iff (a&b)==0) since stdlib uses JNZ.
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPTEST expects Ysrc1, Ysrc2: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		a, err := c.loadY(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		and := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and <32 x i8> %s, %s\n", and, a, b)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %%%s to <4 x i64>\n", bc, and)
-		e0, e1, e2, e3 := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i64> %%%s, i32 0\n", e0, bc)
-		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i64> %%%s, i32 1\n", e1, bc)
-		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i64> %%%s, i32 2\n", e2, bc)
-		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i64> %%%s, i32 3\n", e3, bc)
-		o01 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", o01, e0, e1)
-		o23 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", o23, e2, e3)
-		o := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", o, o01, o23)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, 0\n", z, o)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", z, c.flagsZSlot)
-		// CF/other flags are not used by stdlib here; clear CF to avoid stale reads.
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsCFSlot)
-		return true, false, nil
-
-	case "PCMPESTRI":
-		// PCMPESTRI $imm, mem, Xsrc (implicit lengths; result index in ECX).
-		//
-		// LLVM 19 has backend issues selecting the native X86ISD::PCMPESTR node
-		// for the corresponding intrinsic in some environments. For now we
-		// emulate the subset used by the Go stdlib:
-		//   imm=0x0c: unsigned byte compare, equal ordered, first match.
-		//
-		// We compute the first offset i in [0..15] where:
-		// - bytes(mem[i:]) has a prefix that matches Xsrc[0:lenA]
-		// - or a partial match at the end of the 16-byte block (to drive the
-		//   stdlib's "partial match" control flow).
-		// If no match/partial match exists, return 16.
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PCMPESTRI expects $imm, mem, Xsrc: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		imm := int64(ins.Args[0].Imm) & 0xff
-		if imm != 0x0c {
-			return true, false, fmt.Errorf("amd64 PCMPESTRI: unsupported imm 0x%x (only 0x0c supported): %q", imm, ins.Raw)
-		}
-
-		// A: needle bytes.
-		a, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		// B: 16-byte haystack chunk.
-		var bvec string
-		switch ins.Args[1].Kind {
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[1].Mem)
-			if err != nil {
-				return true, false, err
+		var v64 string
+		if ins.Args[0].Kind == OpReg {
+			if _, ok := amd64ParseXReg(ins.Args[0].Reg); ok {
+				xv, err := c.loadX(ins.Args[0].Reg)
+				if err != nil {
+					return true, false, err
+				}
+				words := c.newTmp()
+				low := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", words, xv)
+				fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", low, words)
+				v64 = "%" + low
+			} else if op != "VPBROADCASTQ" {
+				return false, false, nil
 			}
-			p := c.ptrFromAddrI64(addr)
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", ld, p)
-			bvec = "%" + ld
-		case OpSym:
-			p, err := c.ptrFromSB(ins.Args[1].Sym)
+		}
+		if v64 == "" {
+			var err error
+			v64, err = c.evalI64(ins.Args[0])
 			if err != nil {
 				return true, false, err
 			}
-			ld := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", ld, p)
-			bvec = "%" + ld
-		default:
-			return true, false, fmt.Errorf("amd64 PCMPESTRI unsupported mem operand: %q", ins.Raw)
 		}
+		chunk := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <8 x i8>\n", chunk, v64)
+		if dstIsX {
+			out := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <16 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 16))
+			return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
+		}
+		if _, ok := amd64ParseYReg(ins.Args[1].Reg); ok {
+			out := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <32 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 32))
+			return true, false, c.storeY(ins.Args[1].Reg, "%"+out)
+		}
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i8> %%%s, <8 x i8> %%%s, <64 x i32> %s\n", out, chunk, chunk, llvmRepeatI8Mask(8, 64))
+		return true, false, c.storeZ(ins.Args[1].Reg, "%"+out)
 
-		ax, err := c.loadReg(AX)
+	case "VPSLLD", "VPSLLQ", "VPSLLW", "VPSRAD", "VPSRAW", "VPSRLD", "VPSRLQ", "VPSRLW":
+		// Go's x86 assembler uses _yvpslld for this whole family:
+		//   $imm8, X|Y|Z src/mem, [Kmask,] X|Y|Z dst
+		//   X|m128 count, X|Y|Z src, [Kmask,] X|Y|Z dst
+		// The count is uniform: variable forms use the low 64 bits of X|m128.
+		if (len(ins.Args) != 3 && len(ins.Args) != 4) || ins.Args[len(ins.Args)-1].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 %s expects count, vector src, [K mask,] vector dst: %q", op, ins.Raw)
+		}
+		dst := ins.Args[len(ins.Args)-1].Reg
+		byteWidth := 0
+		var src string
+		var err error
+		loadDst := func() (string, error) { return "", nil }
+		store := func(string) error { return nil }
+		switch {
+		case isAMD64XReg(dst):
+			byteWidth = 16
+			src, err = c.loadXVecOperand(ins.Args[1])
+			loadDst = func() (string, error) { return c.loadX(dst) }
+			store = func(v string) error { return c.storeX(dst, v) }
+		case isAMD64YReg(dst):
+			byteWidth = 32
+			src, err = c.loadYVecOperand(ins.Args[1])
+			loadDst = func() (string, error) { return c.loadY(dst) }
+			store = func(v string) error { return c.storeY(dst, v) }
+		case isAMD64ZReg(dst):
+			byteWidth = 64
+			src, err = c.loadZVecOperand(ins.Args[1])
+			loadDst = func() (string, error) { return c.loadZ(dst) }
+			store = func(v string) error { return c.storeZ(dst, v) }
+		default:
+			return false, false, nil
+		}
 		if err != nil {
 			return true, false, err
 		}
-		la := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", la, ax)
 
-		allOnes := llvmAllOnesI8Vec(16)
-		idx := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i32 0, 16\n", idx)
-		prev := "%" + idx
-
-		// Build first-match index using a select chain.
-		for i := 0; i < 16; i++ {
-			// Shuffle B so that element 0 is B[i], padding beyond 16 with 0.
-			maskElts := make([]string, 0, 16)
-			for k := 0; k < 16; k++ {
-				j := i + k
-				if j < 16 {
-					maskElts = append(maskElts, fmt.Sprintf("i32 %d", j))
-				} else {
-					// 16 selects element 0 of the second (zero) vector.
-					maskElts = append(maskElts, "i32 16")
-				}
-			}
-			mask := "<16 x i32> <" + strings.Join(maskElts, ", ") + ">"
+		elemBits := 32
+		switch op[len(op)-1] {
+		case 'Q':
+			elemBits = 64
+		case 'W':
+			elemBits = 16
+		}
+		lanes := byteWidth * 8 / elemBits
+		vecType := fmt.Sprintf("<%d x i%d>", lanes, elemBits)
+		bc := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", bc, byteWidth, src, vecType)
 
-			sh := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, %s\n", sh, bvec, mask)
-			cmp := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq <16 x i8> %%%s, %s\n", cmp, sh, a)
-			sel := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select <16 x i1> %%%s, <16 x i8> %s, <16 x i8> zeroinitializer\n", sel, cmp, allOnes)
-			pm := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %%%s)\n", pm, sel)
-
-			// minLen = min(lenA, 16-i)
-			cap := 16 - i
-			lt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %%%s, %d\n", lt, la, cap)
-			min := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %%%s, i32 %d\n", min, lt, la, cap)
-			sh1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shl i32 1, %%%s\n", sh1, min)
-			req := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, 1\n", req, sh1)
-			have := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %%%s\n", have, pm, req)
-			okt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %%%s, %%%s\n", okt, have, req)
-
-			unset := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 16\n", unset, prev)
-			take := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", take, okt, unset)
-			next := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %d, i32 %s\n", next, take, i, prev)
-			prev = "%" + next
-		}
-
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", z, prev)
-		return true, false, c.storeReg(CX, "%"+z)
-
-	case "VPAND":
-		// VPAND src1, src2, dst supports both XMM and YMM widths.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPAND expects src1, src2, dst: %q", ins.Raw)
+		llvmOp := "shl"
+		arithmetic := op == "VPSRAD" || op == "VPSRAW"
+		if arithmetic {
+			llvmOp = "ashr"
+		} else if strings.HasPrefix(string(op), "VPSRL") {
+			llvmOp = "lshr"
 		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); ok {
-			for _, arg := range ins.Args[:2] {
-				if arg.Kind == OpReg {
-					if _, ok := amd64ParseYReg(arg.Reg); !ok {
-						return false, false, nil
-					}
-				}
+
+		shifted := "zeroinitializer"
+		if ins.Args[0].Kind == OpImm {
+			count := uint64(ins.Args[0].Imm) & 0xff
+			if arithmetic && count >= uint64(elemBits) {
+				count = uint64(elemBits - 1)
 			}
-			a, err := c.loadYVecOperand(ins.Args[0])
-			if err != nil {
-				return true, false, err
+			if arithmetic || count < uint64(elemBits) {
+				sh := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %s\n", sh, llvmOp, vecType, bc, llvmSplatInteger(lanes, elemBits, count))
+				shifted = "%" + sh
 			}
-			b, err := c.loadYVecOperand(ins.Args[1])
+		} else {
+			countVec, err := c.loadXVecOperand(ins.Args[0])
 			if err != nil {
-				return true, false, err
+				return true, false, fmt.Errorf("amd64 %s count: %w", op, err)
+			}
+			countWords := c.newTmp()
+			count := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", countWords, countVec)
+			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", count, countWords)
+			inRange := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %d\n", inRange, count, elemBits)
+			safeCount := c.newTmp()
+			fallback := 0
+			if arithmetic {
+				fallback = elemBits - 1
+			}
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %d\n", safeCount, inRange, count, fallback)
+			shiftCount := "%" + safeCount
+			if elemBits < 64 {
+				truncated := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i%d\n", truncated, safeCount, elemBits)
+				shiftCount = "%" + truncated
+			}
+			countSplat := amd64SplatInteger(c, lanes, elemBits, shiftCount)
+			sh := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %s\n", sh, llvmOp, vecType, bc, countSplat)
+			shifted = "%" + sh
+			if !arithmetic {
+				condition := amd64SplatI1(c, lanes, "%"+inRange)
+				selected := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %s, %s %s, %s zeroinitializer\n", selected, lanes, condition, vecType, shifted, vecType)
+				shifted = "%" + selected
 			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and <32 x i8> %s, %s\n", t, a, b)
-			return true, false, c.storeY(ins.Args[2].Reg, "%"+t)
 		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); ok {
-			for _, arg := range ins.Args[:2] {
-				if arg.Kind == OpReg {
-					if _, ok := amd64ParseXReg(arg.Reg); !ok {
-						return false, false, nil
-					}
-				}
+
+		if len(ins.Args) == 4 {
+			if ins.Args[2].Kind != OpReg {
+				return true, false, fmt.Errorf("amd64 %s masked form expects K mask: %q", op, ins.Raw)
 			}
-			a, err := c.loadXVecOperand(ins.Args[0])
+			if _, ok := amd64ParseKReg(ins.Args[2].Reg); !ok {
+				return false, false, nil
+			}
+			maskValue, err := c.loadK(ins.Args[2].Reg)
 			if err != nil {
 				return true, false, err
 			}
-			b, err := c.loadXVecOperand(ins.Args[1])
+			oldBytes, err := loadDst()
 			if err != nil {
 				return true, false, err
 			}
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %s, %s\n", t, a, b)
-			return true, false, c.storeX(ins.Args[2].Reg, "%"+t)
+			old := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", old, byteWidth, oldBytes, vecType)
+			shifted = amd64ApplyIntegerLaneMask(c, lanes, elemBits, shifted, "%"+old, maskValue, zeroMasking)
 		}
-		return false, false, nil
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", out, vecType, shifted, byteWidth)
+		return true, false, store("%" + out)
+
+	case "VPALIGNR":
+		return c.lowerPackedAlignRight(rawOp, ins)
+
+	case "VMOVNTDQ":
+		// Compatibility entry point for direct lowerVec unit tests. Ordinary
+		// translation dispatches the whole family through the dedicated
+		// lowerer before reaching this legacy switch.
+		return c.lowerNonTemporalVectorMove(op, ins)
+
+	case "PTEST", "VPTEST", "VTESTPD", "VTESTPS":
+		return c.lowerVectorTest(rawOp, ins)
 
 	case "VPBLENDD":
 		// VPBLENDD $imm, Ysrc1, Ysrc2, Ydst
@@ -1435,43 +599,7 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		return true, false, c.storeY(ins.Args[1].Reg, "%"+spl)
 
 	case "VPSRLDQ", "VPSLLDQ":
-		// VPSR/LLDQ $imm, Ysrc, Ydst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, Ysrc, Ydst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm
-		if n < 0 {
-			n = 0
-		}
-		if n > 16 {
-			n = 16
-		}
-		src, err := c.loadY(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		lo := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", lo, src, llvmI32RangeMask(0, 16))
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", hi, src, llvmI32RangeMask(16, 16))
-		lo2 := c.newTmp()
-		hi2 := c.newTmp()
-		if op == "VPSLLDQ" {
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> zeroinitializer, <16 x i32> %s\n", lo2, lo, llvmShiftLeftBytesMask(n))
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> zeroinitializer, <16 x i32> %s\n", hi2, hi, llvmShiftLeftBytesMask(n))
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> zeroinitializer, <16 x i32> %s\n", lo2, lo, llvmShiftRightBytesMask(n))
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> zeroinitializer, <16 x i32> %s\n", hi2, hi, llvmShiftRightBytesMask(n))
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %%%s, <16 x i8> %%%s, <32 x i32> %s\n", out, lo2, hi2, llvmI32RangeMask(0, 32))
-		return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
+		return c.lowerPackedByteShift(rawOp, ins)
 
 	case "VPUNPCKLBW", "VPUNPCKHBW":
 		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
@@ -1571,46 +699,6 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> %s, %s\n", sh, dstv, src, mask)
 		return true, false, c.storeX(ins.Args[1].Reg, "%"+sh)
 
-	case "PMULULQ":
-		// PMULULQ Xsrc/m128, Xdst multiplies the unsigned even-numbered
-		// 32-bit lanes and writes the two 64-bit products.
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PMULULQ expects Xsrc/m128, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if ins.Args[0].Kind == OpReg {
-			if _, ok := amd64ParseXReg(ins.Args[0].Reg); !ok {
-				return false, false, nil
-			}
-		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		dst32 := c.newTmp()
-		src32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", dst32, dstv)
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", src32, src)
-		dstEven := c.newTmp()
-		srcEven := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i32> %%%s, <4 x i32> zeroinitializer, <2 x i32> <i32 0, i32 2>\n", dstEven, dst32)
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i32> %%%s, <4 x i32> zeroinitializer, <2 x i32> <i32 0, i32 2>\n", srcEven, src32)
-		dst64 := c.newTmp()
-		src64 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext <2 x i32> %%%s to <2 x i64>\n", dst64, dstEven)
-		fmt.Fprintf(c.b, "  %%%s = zext <2 x i32> %%%s to <2 x i64>\n", src64, srcEven)
-		product := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul <2 x i64> %%%s, %%%s\n", product, dst64, src64)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, product)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
-
 	case "PUNPCKLLQ", "PUNPCKHLQ":
 		// PUNPCKL/H LQ interleaves the low/high pair of 32-bit lanes.
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
@@ -1673,127 +761,11 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, sh)
 		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
 
-	case "PSHUFL", "PSHUFD":
-		// PSHUFL $imm, Xsrc, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, Xsrc, Xdst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		idx := func(k uint) uint64 { return (imm >> (2 * k)) & 3 }
-		src, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bc1, src)
-		mask := fmt.Sprintf("<4 x i32> <i32 %d, i32 %d, i32 %d, i32 %d>", idx(0), idx(1), idx(2), idx(3))
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i32> %%%s, <4 x i32> zeroinitializer, %s\n", sh, bc1, mask)
-		bc2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bc2, sh)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc2)
-
-	case "PSHUFHW":
-		// PSHUFHW $imm, Xsrc, Xdst (shuffle high 4 words; low 4 words unchanged).
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PSHUFHW expects $imm, Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		idx := func(k uint) uint64 { return (imm >> (2 * k)) & 3 }
-		src, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", bc1, src)
-		mask := fmt.Sprintf("<8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 %d, i32 %d, i32 %d, i32 %d>",
-			4+idx(0), 4+idx(1), 4+idx(2), 4+idx(3))
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i16> %%%s, <8 x i16> zeroinitializer, %s\n", sh, bc1, mask)
-		bc2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", bc2, sh)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc2)
-
-	case "SHUFPS":
-		// SHUFPS $imm, Xsrc, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 SHUFPS expects $imm, Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		idx := func(k uint) uint64 { return (imm >> (2 * k)) & 3 }
-		src, err := c.loadXVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		ds := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", ds, dstv)
-		ss := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", ss, src)
-		mask := fmt.Sprintf("<4 x i32> <i32 %d, i32 %d, i32 %d, i32 %d>", idx(0), idx(1), 4+idx(2), 4+idx(3))
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i32> %%%s, <4 x i32> %%%s, %s\n", sh, ds, ss, mask)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bc, sh)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc)
-
-	case "PBLENDW":
-		// PBLENDW $imm, Xsrc, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PBLENDW expects $imm, Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadXVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		imm := uint64(ins.Args[0].Imm) & 0xff
-		sv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", sv, src)
-		dv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", dv, dstv)
-		mask := make([]string, 0, 8)
-		for i := 0; i < 8; i++ {
-			if ((imm >> i) & 1) != 0 {
-				mask = append(mask, fmt.Sprintf("i32 %d", 8+i))
-			} else {
-				mask = append(mask, fmt.Sprintf("i32 %d", i))
-			}
-		}
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i16> %%%s, <8 x i16> %%%s, <8 x i32> <%s>\n", sh, dv, sv, strings.Join(mask, ", "))
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", out, sh)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
-
-	case "SHA256MSG1", "SHA256MSG2":
-		// Approximate scheduling helpers as per-lane adds to keep SSA flow.
+	case "PUNPCKHQDQ":
+		// PUNPCKHQDQ Xsrc/m128, Xdst interleaves the high quadwords:
+		// dst = {dst[127:64], src[127:64]}.
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
+			return true, false, fmt.Errorf("amd64 PUNPCKHQDQ expects Xsrc/m128, Xdst: %q", ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
@@ -1806,48 +778,94 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		if err != nil {
 			return true, false, err
 		}
-		s32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", s32, src)
-		d32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", d32, dstv)
-		add := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, %%%s\n", add, d32, s32)
+		dstQ := c.newTmp()
+		srcQ := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", dstQ, dstv)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", srcQ, src)
+		sh := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %%%s, <2 x i64> %%%s, <2 x i32> <i32 1, i32 3>\n", sh, dstQ, srcQ)
 		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, add)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, sh)
 		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
 
-	case "SHA1NEXTE", "SHA1MSG1", "SHA1MSG2":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
+	case "VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ":
+		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 %s expects src1, src2, dst: %q", op, ins.Raw)
 		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
+		if _, ok := amd64ParseXReg(ins.Args[2].Reg); ok {
+			a, err := c.loadXVecOperand(ins.Args[0])
+			if err != nil {
+				return true, false, err
+			}
+			b, err := c.loadXVecOperand(ins.Args[1])
+			if err != nil {
+				return true, false, err
+			}
+			laneType := "i64"
+			lanes := 2
+			mask := "<i32 1, i32 3>"
+			if op == "VPUNPCKLQDQ" {
+				mask = "<i32 0, i32 2>"
+			} else if op == "VPUNPCKLDQ" {
+				laneType, lanes = "i32", 4
+				mask = "<i32 0, i32 4, i32 1, i32 5>"
+			} else if op == "VPUNPCKHDQ" {
+				laneType, lanes = "i32", 4
+				mask = "<i32 2, i32 6, i32 3, i32 7>"
+			}
+			aq := c.newTmp()
+			bq := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", aq, a, lanes, laneType)
+			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", bq, b, lanes, laneType)
+			sh := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> %%%s, <%d x i32> %s\n", sh, lanes, laneType, bq, lanes, laneType, aq, lanes, mask)
+			out := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <16 x i8>\n", out, lanes, laneType, sh)
+			return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
 		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
+		if _, ok := amd64ParseYReg(ins.Args[2].Reg); ok {
+			a, err := c.loadYVecOperand(ins.Args[0])
+			if err != nil {
+				return true, false, err
+			}
+			b, err := c.loadYVecOperand(ins.Args[1])
+			if err != nil {
+				return true, false, err
+			}
+			laneType := "i64"
+			lanes := 4
+			mask := "<i32 1, i32 5, i32 3, i32 7>"
+			if op == "VPUNPCKLQDQ" {
+				mask = "<i32 0, i32 4, i32 2, i32 6>"
+			} else if op == "VPUNPCKLDQ" {
+				laneType, lanes = "i32", 8
+				mask = "<i32 0, i32 8, i32 1, i32 9, i32 4, i32 12, i32 5, i32 13>"
+			} else if op == "VPUNPCKHDQ" {
+				laneType, lanes = "i32", 8
+				mask = "<i32 2, i32 10, i32 3, i32 11, i32 6, i32 14, i32 7, i32 15>"
+			}
+			aq := c.newTmp()
+			bq := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <%d x %s>\n", aq, a, lanes, laneType)
+			fmt.Fprintf(c.b, "  %%%s = bitcast <32 x i8> %s to <%d x %s>\n", bq, b, lanes, laneType)
+			sh := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> %%%s, <%d x i32> %s\n", sh, lanes, laneType, bq, lanes, laneType, aq, lanes, mask)
+			out := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <32 x i8>\n", out, lanes, laneType, sh)
+			return true, false, c.storeY(ins.Args[2].Reg, "%"+out)
 		}
-		s32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", s32, src)
-		d32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", d32, dstv)
-		add := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, %%%s\n", add, d32, s32)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, add)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
+		return false, false, nil
 
-	case "SHA1RNDS4":
+	case "SHUFPS":
+		// SHUFPS $imm, Xsrc, Xdst
 		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 SHA1RNDS4 expects $imm, Xsrc, Xdst: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 SHUFPS expects $imm, Xsrc, Xdst: %q", ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
 			return false, false, nil
 		}
+		imm := uint64(ins.Args[0].Imm) & 0xff
+		idx := func(k uint) uint64 { return (imm >> (2 * k)) & 3 }
 		src, err := c.loadXVecOperand(ins.Args[1])
 		if err != nil {
 			return true, false, err
@@ -1856,42 +874,50 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		if err != nil {
 			return true, false, err
 		}
-		s32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", s32, src)
-		d32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", d32, dstv)
-		add := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, %%%s\n", add, d32, s32)
-		immv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", immv, add, ins.Args[0].Imm, ins.Args[0].Imm, ins.Args[0].Imm, ins.Args[0].Imm)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, immv)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
+		ds := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", ds, dstv)
+		ss := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", ss, src)
+		mask := fmt.Sprintf("<4 x i32> <i32 %d, i32 %d, i32 %d, i32 %d>", idx(0), idx(1), 4+idx(2), 4+idx(3))
+		sh := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i32> %%%s, <4 x i32> %%%s, %s\n", sh, ds, ss, mask)
+		bc := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", bc, sh)
+		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc)
 
-	case "SHA256RNDS2":
-		// SHA256RNDS2 Xsrc, Xstate, Xdst
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 SHA256RNDS2 expects Xsrc, Xstate, Xdst: %q", ins.Raw)
+	case "PBLENDW":
+		// PBLENDW $imm, Xsrc, Xdst
+		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 PBLENDW expects $imm, Xsrc, Xdst: %q", ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
 			return false, false, nil
 		}
-		a, err := c.loadXVecOperand(ins.Args[0])
+		src, err := c.loadXVecOperand(ins.Args[1])
 		if err != nil {
 			return true, false, err
 		}
-		b, err := c.loadXVecOperand(ins.Args[1])
+		dstv, err := c.loadX(ins.Args[2].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		a32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", a32, a)
-		b32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", b32, b)
-		add := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add <4 x i32> %%%s, %%%s\n", add, a32, b32)
+		imm := uint64(ins.Args[0].Imm) & 0xff
+		sv := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", sv, src)
+		dv := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", dv, dstv)
+		mask := make([]string, 0, 8)
+		for i := 0; i < 8; i++ {
+			if ((imm >> i) & 1) != 0 {
+				mask = append(mask, fmt.Sprintf("i32 %d", 8+i))
+			} else {
+				mask = append(mask, fmt.Sprintf("i32 %d", i))
+			}
+		}
+		sh := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i16> %%%s, <8 x i16> %%%s, <8 x i32> <%s>\n", sh, dv, sv, strings.Join(mask, ", "))
 		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, add)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", out, sh)
 		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
 
 	case "VMOVDQU64":
@@ -2152,138 +1178,9 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		}
 		return false, false, nil
 
-	case "VPMOVMSKB":
-		// VPMOVMSKB Ysrc, dstReg
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPMOVMSKB expects Ysrc, dstReg: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		v, err := c.loadY(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		// Work around LLVM backend issues with the AVX2 pmovmskb intrinsic by
-		// splitting the 256-bit vector into two 128-bit halves and using the SSE2
-		// pmovmskb.128 intrinsic.
-		lo := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", lo, v, llvmI32RangeMask(0, 16))
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <32 x i8> %s, <32 x i8> zeroinitializer, <16 x i32> %s\n", hi, v, llvmI32RangeMask(16, 16))
-		ml := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %%%s)\n", ml, lo)
-		mh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %%%s)\n", mh, hi)
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, 16\n", sh, mh)
-		or := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", or, sh, ml)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, or)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+z)
-
-	case "MOVOU", "MOVOA":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("amd64 %s expects src, dst: %q", op, ins.Raw)
-		}
-		if ins.Args[1].Kind == OpReg {
-			if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-				return false, false, nil
-			}
-			dst := ins.Args[1].Reg
-			switch ins.Args[0].Kind {
-			case OpReg:
-				v, err := c.loadX(ins.Args[0].Reg)
-				if err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeX(dst, v)
-			case OpMem:
-				addr, err := c.addrFromMem(ins.Args[0].Mem)
-				if err != nil {
-					return true, false, err
-				}
-				p := c.ptrFromAddrI64(addr)
-				ld := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", ld, p)
-				return true, false, c.storeX(dst, "%"+ld)
-			case OpSym:
-				p, err := c.ptrFromSB(ins.Args[0].Sym)
-				if err != nil {
-					return true, false, err
-				}
-				ld := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", ld, p)
-				return true, false, c.storeX(dst, "%"+ld)
-			default:
-				return true, false, fmt.Errorf("amd64 %s unsupported src: %q", op, ins.Raw)
-			}
-		}
-
-		if ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc for store form: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		srcv, err := c.loadX(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		switch ins.Args[1].Kind {
-		case OpMem:
-			addr, err := c.addrFromMem(ins.Args[1].Mem)
-			if err != nil {
-				return true, false, err
-			}
-			p := c.ptrFromAddrI64(addr)
-			fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", srcv, p)
-			return true, false, nil
-		case OpSym:
-			p, err := c.ptrFromSB(ins.Args[1].Sym)
-			if err != nil {
-				return true, false, err
-			}
-			fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", srcv, p)
-			return true, false, nil
-		default:
-			return true, false, fmt.Errorf("amd64 %s unsupported dst: %q", op, ins.Raw)
-		}
-
-	case "PXOR", "POR", "PAND", "PANDN":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		if op == "PXOR" {
-			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", t, dstv, src)
-		} else if op == "POR" {
-			fmt.Fprintf(c.b, "  %%%s = or <16 x i8> %s, %s\n", t, dstv, src)
-		} else if op == "PANDN" {
-			notv := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", notv, dstv, llvmAllOnesI8Vec(16))
-			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %%%s, %s\n", t, notv, src)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %s, %s\n", t, dstv, src)
-		}
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+t)
-
-	case "PADDL", "PADDD", "PADDQ", "PSUBB", "PSUBL":
-		// Two-operand packed arithmetic: dst = dst (+|-) src.
+	case "PABSD":
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
+			return true, false, fmt.Errorf("amd64 PABSD expects Xsrc, Xdst: %q", ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
@@ -2292,272 +1189,113 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		if err != nil {
 			return true, false, err
 		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		vecTy := "<4 x i32>"
-		if op == "PSUBB" {
-			vecTy = "<16 x i8>"
-		} else if op == "PADDQ" {
-			vecTy = "<2 x i64>"
-		}
-		as := src
-		bs := dstv
-		if vecTy != "<16 x i8>" {
-			at := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", at, src, vecTy)
-			as = "%" + at
-			bt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", bt, dstv, vecTy)
-			bs = "%" + bt
-		}
-		x := c.newTmp()
-		if op == "PADDL" || op == "PADDD" || op == "PADDQ" {
-			fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", x, vecTy, bs, as)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", x, vecTy, bs, as)
-		}
-		if vecTy == "<16 x i8>" {
-			return true, false, c.storeX(ins.Args[1].Reg, "%"+x)
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", out, vecTy, x)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
-
-	case "PSLLW", "PSRLW", "PSLLL", "PSRLL", "PSRAL":
-		// Two-operand packed integer shift immediate.
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 %s expects $imm, Xdst: %q", op, ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		laneBits := int64(32)
-		vecTy := "<4 x i32>"
-		if op == "PSLLW" || op == "PSRLW" {
-			laneBits = 16
-			vecTy = "<8 x i16>"
-		}
-		n := ins.Args[0].Imm
-		v, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", bc, v, vecTy)
-		if n < 0 {
-			return true, false, fmt.Errorf("amd64 %s shift count must be non-negative: %q", op, ins.Raw)
-		}
-		if n >= laneBits {
-			if op != "PSRAL" {
-				return true, false, c.storeX(ins.Args[1].Reg, "zeroinitializer")
-			}
-			// Packed arithmetic right shifts saturate an oversized count to
-			// laneBits-1, producing an all-sign-bit lane instead of zero.
-			n = laneBits - 1
-		}
-		sh := c.newTmp()
-		switch op {
-		case "PSLLW":
-			fmt.Fprintf(c.b, "  %%%s = shl <8 x i16> %%%s, <i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
-		case "PSRLW":
-			fmt.Fprintf(c.b, "  %%%s = lshr <8 x i16> %%%s, <i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
-		case "PSLLL":
-			fmt.Fprintf(c.b, "  %%%s = shl <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
-		case "PSRLL":
-			fmt.Fprintf(c.b, "  %%%s = lshr <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
-		case "PSRAL":
-			fmt.Fprintf(c.b, "  %%%s = ashr <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
-		}
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", out, vecTy, sh)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
-
-	case "PCMPEQL":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PCMPEQL expects Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		src, err := c.loadX(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		as := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", as, src)
-		bs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bs, dstv)
-		cmp := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp eq <4 x i32> %%%s, %%%s\n", cmp, bs, as)
-		sext := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sext <4 x i1> %%%s to <4 x i32>\n", sext, cmp)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, sext)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
-
-	case "VPCLMULQDQ":
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPCLMULQDQ expects $imm, Zsrc, Zdst, Zout: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseZReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseZReg(ins.Args[3].Reg); !ok {
-			return false, false, nil
-		}
-		imm := ins.Args[0].Imm & 0xff
-		src, err := c.loadZ(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadZ(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bd := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <64 x i8> %s to <8 x i64>\n", bd, dstv)
-		bs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <64 x i8> %s to <8 x i64>\n", bs, src)
-		lanes := make([]string, 0, 4)
-		for i := 0; i < 4; i++ {
-			dlane := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i64> %%%s, <8 x i64> zeroinitializer, <2 x i32> <i32 %d, i32 %d>\n", dlane, bd, i*2, i*2+1)
-			slane := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x i64> %%%s, <8 x i64> zeroinitializer, <2 x i32> <i32 %d, i32 %d>\n", slane, bs, i*2, i*2+1)
-			call := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.pclmulqdq(<2 x i64> %%%s, <2 x i64> %%%s, i8 %d)\n", call, dlane, slane, imm)
-			lanes = append(lanes, "%"+call)
-		}
-		merged0 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %s, <2 x i64> %s, <4 x i32> <i32 0, i32 1, i32 2, i32 3>\n", merged0, lanes[0], lanes[1])
-		merged1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <2 x i64> %s, <2 x i64> %s, <4 x i32> <i32 0, i32 1, i32 2, i32 3>\n", merged1, lanes[2], lanes[3])
-		merged := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i64> %%%s, <4 x i64> %%%s, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>\n", merged, merged0, merged1)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i64> %%%s to <64 x i8>\n", out, merged)
-		return true, false, c.storeZ(ins.Args[3].Reg, "%"+out)
-
-	case "VPTERNLOGD":
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VPTERNLOGD expects $imm, src1, src2, dst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseYReg(ins.Args[3].Reg); ok {
-			if ins.Args[1].Kind == OpReg {
-				if _, ok := amd64ParseYReg(ins.Args[1].Reg); !ok {
-					return false, false, nil
-				}
-			}
-			if ins.Args[2].Kind == OpReg {
-				if _, ok := amd64ParseYReg(ins.Args[2].Reg); !ok {
-					return false, false, nil
-				}
-			}
-			if ins.Args[0].Imm != 0x96 {
-				return true, false, fmt.Errorf("amd64 VPTERNLOGD only supports imm 0x96 for now: %q", ins.Raw)
-			}
-			a, err := c.loadYVecOperand(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadYVecOperand(ins.Args[2])
-			if err != nil {
-				return true, false, err
-			}
-			dstv, err := c.loadY(ins.Args[3].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			x1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <32 x i8> %s, %s\n", x1, dstv, a)
-			x2 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor <32 x i8> %%%s, %s\n", x2, x1, b)
-			return true, false, c.storeY(ins.Args[3].Reg, "%"+x2)
-		}
-		if _, ok := amd64ParseZReg(ins.Args[3].Reg); !ok {
-			return false, false, nil
-		}
-		if ins.Args[0].Imm != 0x96 {
-			return true, false, fmt.Errorf("amd64 VPTERNLOGD only supports imm 0x96 for now: %q", ins.Raw)
-		}
-		a, err := c.loadZVecOperand(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.loadZVecOperand(ins.Args[2])
-		if err != nil {
-			return true, false, err
-		}
-		dstv, err := c.loadZ(ins.Args[3].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		x1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor <64 x i8> %s, %s\n", x1, dstv, a)
-		x2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor <64 x i8> %%%s, %s\n", x2, x1, b)
-		return true, false, c.storeZ(ins.Args[3].Reg, "%"+x2)
+		values := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", values, src)
+		negative := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt <4 x i32> %%%s, zeroinitializer\n", negative, values)
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub <4 x i32> zeroinitializer, %%%s\n", negated, values)
+		absolute := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <4 x i1> %%%s, <4 x i32> %%%s, <4 x i32> %%%s\n", absolute, negative, negated, values)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, absolute)
+		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
 
-	case "VEXTRACTF32X4":
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 VEXTRACTF32X4 expects $imm, Zsrc, Xdst: %q", ins.Raw)
+	case "PMINUB", "PMINSB", "PMINUW", "PMINSW", "PMINUD", "PMINSD",
+		"PMAXUB", "PMAXSB", "PMAXUW", "PMAXSW", "PMAXUD", "PMAXSD":
+		return c.lowerPackedIntegerMinMax(rawOp, ins)
+
+	case "PSLLW", "PSRLW", "PSLLL", "PSRLL", "PSRAL":
+		// Two-operand packed integer shift immediate.
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 %s expects $imm, Xdst: %q", op, ins.Raw)
 		}
-		if _, ok := amd64ParseZReg(ins.Args[1].Reg); !ok {
+		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
 		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
+		laneBits := int64(32)
+		vecTy := "<4 x i32>"
+		if op == "PSLLW" || op == "PSRLW" {
+			laneBits = 16
+			vecTy = "<8 x i16>"
 		}
-		idx := int(ins.Args[0].Imm & 0x3)
-		src, err := c.loadZ(ins.Args[1].Reg)
+		n := ins.Args[0].Imm
+		v, err := c.loadX(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
 		}
+		bc := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", bc, v, vecTy)
+		if n < 0 {
+			return true, false, fmt.Errorf("amd64 %s shift count must be non-negative: %q", op, ins.Raw)
+		}
+		if n >= laneBits {
+			if op != "PSRAL" {
+				return true, false, c.storeX(ins.Args[1].Reg, "zeroinitializer")
+			}
+			// Packed arithmetic right shifts saturate an oversized count to
+			// laneBits-1, producing an all-sign-bit lane instead of zero.
+			n = laneBits - 1
+		}
+		sh := c.newTmp()
+		switch op {
+		case "PSLLW":
+			fmt.Fprintf(c.b, "  %%%s = shl <8 x i16> %%%s, <i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
+		case "PSRLW":
+			fmt.Fprintf(c.b, "  %%%s = lshr <8 x i16> %%%s, <i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d, i16 %d>\n", sh, bc, n, n, n, n, n, n, n, n)
+		case "PSLLL":
+			fmt.Fprintf(c.b, "  %%%s = shl <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
+		case "PSRLL":
+			fmt.Fprintf(c.b, "  %%%s = lshr <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
+		case "PSRAL":
+			fmt.Fprintf(c.b, "  %%%s = ashr <4 x i32> %%%s, <i32 %d, i32 %d, i32 %d, i32 %d>\n", sh, bc, n, n, n, n)
+		}
 		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <64 x i8> %s, <64 x i8> zeroinitializer, <16 x i32> %s\n", out, src, llvmI32RangeMask(idx*16, 16))
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", out, vecTy, sh)
+		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
 
-	case "PCLMULQDQ":
-		// PCLMULQDQ $imm, Xsrc, Xdst  => Xdst = pclmul(Xdst, Xsrc, imm)
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PCLMULQDQ expects $imm, Xsrc, Xdst: %q", ins.Raw)
+	case "PCMPEQW", "PCMPEQL":
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+			return true, false, fmt.Errorf("amd64 %s expects Xsrc, Xdst: %q", op, ins.Raw)
 		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
+		if _, ok := amd64ParseXReg(ins.Args[0].Reg); !ok {
 			return false, false, nil
 		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
+		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
 		}
-		imm := ins.Args[0].Imm & 0xff
-		src, err := c.loadX(ins.Args[1].Reg)
+		src, err := c.loadX(ins.Args[0].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		dstv, err := c.loadX(ins.Args[2].Reg)
+		dstv, err := c.loadX(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		bd := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bd, dstv)
+		laneType := "i32"
+		lanes := 4
+		if op == "PCMPEQW" {
+			laneType = "i16"
+			lanes = 8
+		}
+		vecType := fmt.Sprintf("<%d x %s>", lanes, laneType)
+		as := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", as, src, vecType)
 		bs := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bs, src)
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call <2 x i64> @llvm.x86.pclmulqdq(<2 x i64> %%%s, <2 x i64> %%%s, i8 %d)\n", call, bd, bs, imm)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, call)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+bc)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", bs, dstv, vecType)
+		cmp := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, %%%s\n", cmp, vecType, bs, as)
+		sext := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %%%s to %s\n", sext, lanes, cmp, vecType)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", out, vecType, sext)
+		return true, false, c.storeX(ins.Args[1].Reg, "%"+out)
+
+	case "VPCLMULQDQ":
+		return c.lowerPackedCarrylessMultiply(rawOp, ins)
+
+	case "PCLMULQDQ":
+		return c.lowerPackedCarrylessMultiply(rawOp, ins)
 
 	case "PCMPEQB", "PCMPGTB":
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
@@ -2594,146 +1332,6 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		fmt.Fprintf(c.b, "  %%%s = select <16 x i1> %%%s, <16 x i8> %s, <16 x i8> zeroinitializer\n", sel, cmp, allOnes)
 		return true, false, c.storeX(ins.Args[1].Reg, "%"+sel)
 
-	case "PMOVMSKB":
-		// PMOVMSKB Xsrc, dstReg
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PMOVMSKB expects Xsrc, dstReg: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[0].Reg); !ok {
-			return false, false, nil
-		}
-		v, err := c.loadX(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8> %s)\n", call, v)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, call)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+z)
-
-	case "PSHUFB":
-		// PSHUFB Xmask, Xdst
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PSHUFB expects Xmask, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		mask, err := c.loadXVecOperand(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		call := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8> %s, <16 x i8> %s)\n", call, dst, mask)
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+call)
-
-	case "PINSRQ":
-		// PINSRQ $imm, src64, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PINSRQ expects $imm, src, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		idx := ins.Args[0].Imm & 1
-		src, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, dst)
-		insv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %s, i32 %d\n", insv, bc, src, idx)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, insv)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
-
-	case "PINSRD":
-		// PINSRD $imm, src32, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PINSRD expects $imm, src, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		idx := ins.Args[0].Imm & 3
-		src64, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		src32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", src32, src64)
-		dst, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bc, dst)
-		insv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %%%s, i32 %d\n", insv, bc, src32, idx)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, insv)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
-
-	case "PINSRW":
-		// PINSRW $imm, src16, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PINSRW expects $imm, src, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		idx := ins.Args[0].Imm & 7
-		src64, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		src16 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i16\n", src16, src64)
-		dst, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", bc, dst)
-		insv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i16> %%%s, i16 %%%s, i32 %d\n", insv, bc, src16, idx)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", out, insv)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+out)
-
-	case "PINSRB":
-		// PINSRB $imm, src8, Xdst
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PINSRB expects $imm, src, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		idx := ins.Args[0].Imm & 15
-		src64, err := c.evalI64(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		src8 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", src8, src64)
-		dst, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		insv := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <16 x i8> %s, i8 %%%s, i32 %d\n", insv, dst, src8, idx)
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+insv)
-
 	case "PEXTRB":
 		// PEXTRB $imm, Xsrc, dst
 		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
@@ -2806,84 +1404,27 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		}
 
 	case "PALIGNR":
-		// PALIGNR $imm, Xsrc, Xdst ; dst = alignr(dst, src, imm)
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PALIGNR expects $imm, Xsrc, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		if _, ok := amd64ParseXReg(ins.Args[2].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm
-		if n < 0 {
-			n = 0
-		}
-		if n > 255 {
-			n = 255
-		}
-		src, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.loadX(ins.Args[2].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> %s, <16 x i32> %s\n", sh, dst, src, llvmAlignRightBytesMask(n))
-		return true, false, c.storeX(ins.Args[2].Reg, "%"+sh)
+		return c.lowerPackedAlignRight(rawOp, ins)
 
-	case "PSRLDQ":
-		// PSRLDQ $imm, Xdst
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PSRLDQ expects $imm, Xdst: %q", ins.Raw)
-		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
-		}
-		n := ins.Args[0].Imm
-		if n < 0 || n > 16 {
-			return true, false, fmt.Errorf("amd64 PSRLDQ invalid imm %d: %q", n, ins.Raw)
-		}
-		v, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		shuf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> %s\n", shuf, v, llvmShiftRightBytesMask(n))
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+shuf)
+	case "PSRLDQ", "PSLLDQ":
+		return c.lowerPackedByteShift(rawOp, ins)
 
-	case "PSLLDQ":
-		// PSLLDQ $imm, Xdst
+	case "PSRLQ", "PSLLQ":
+		// PSR/LLQ $imm, Xdst (shift each 64-bit lane). Counts at or above
+		// the lane width clear the destination rather than wrapping modulo 64.
 		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PSLLDQ expects $imm, Xdst: %q", ins.Raw)
+			return true, false, fmt.Errorf("amd64 %s expects $imm, Xdst: %q", op, ins.Raw)
 		}
 		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
 			return false, false, nil
 		}
 		n := ins.Args[0].Imm
-		if n < 0 || n > 16 {
-			return true, false, fmt.Errorf("amd64 PSLLDQ invalid imm %d: %q", n, ins.Raw)
-		}
-		v, err := c.loadX(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		shuf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <16 x i32> %s\n", shuf, v, llvmShiftLeftBytesMask(n))
-		return true, false, c.storeX(ins.Args[1].Reg, "%"+shuf)
-
-	case "PSRLQ":
-		// PSRLQ $imm, Xdst (shift each 64-bit lane right)
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("amd64 PSRLQ expects $imm, Xdst: %q", ins.Raw)
+		if n < 0 {
+			return true, false, fmt.Errorf("amd64 %s shift count must be non-negative: %q", op, ins.Raw)
 		}
-		if _, ok := amd64ParseXReg(ins.Args[1].Reg); !ok {
-			return false, false, nil
+		if n >= 64 {
+			return true, false, c.storeX(ins.Args[1].Reg, "zeroinitializer")
 		}
-		n := ins.Args[0].Imm & 63
 		v, err := c.loadX(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
@@ -2891,7 +1432,11 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 		bc := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, v)
 		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr <2 x i64> %%%s, <i64 %d, i64 %d>\n", sh, bc, n, n)
+		shiftOp := "lshr"
+		if op == "PSLLQ" {
+			shiftOp = "shl"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <2 x i64> %%%s, <i64 %d, i64 %d>\n", sh, shiftOp, bc, n, n)
 		back := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", back, sh)
 		return true, false, c.storeX(ins.Args[1].Reg, "%"+back)
@@ -2935,6 +1480,67 @@ func (c *amd64Ctx) lowerVec(op Op, ins Instr) (ok bool, terminated bool, err err
 	return false, false, nil
 }
 
+func (c *amd64Ctx) validateMOVDAliasForm(ins Instr) error {
+	if len(ins.Args) != 2 {
+		return fmt.Errorf("%s MOVD expects 2 operands: %q", c.goarch, ins.Raw)
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	srcMem, dstMem := isAMD64MemoryOperand(src), isAMD64MemoryOperand(dst)
+	srcX, dstX := isAMD64MOVDXRegister(src), isAMD64MOVDXRegister(dst)
+	srcM, dstM := isAMD64MOVDMRegister(src), isAMD64MOVDMRegister(dst)
+	srcGP, dstGP := c.isGoYrlRegister(src), c.isGoYrlRegister(dst)
+	srcAddress := x86GoMOVQAddressSource(src, c.goarch)
+
+	valid := false
+	if c.goarch == "386" {
+		// In 32-bit mode AMOVQ has only its memory/MMX/XMM rows. Go rejects
+		// every GP and immediate form as an illegal 64-bit instruction.
+		valid = (dstMem && (srcX || srcM)) ||
+			(dstX && (srcMem || srcX)) ||
+			(dstM && (srcMem || srcX))
+	} else {
+		valid = (dstGP && (src.Kind == OpImm || srcAddress || srcGP || srcMem || srcX || srcM)) ||
+			(dstMem && (src.Kind == OpImm || srcGP || srcX || srcM)) ||
+			(dstX && (srcGP || srcMem || srcX)) ||
+			(dstM && (srcGP || srcMem || srcX || srcM))
+	}
+	if !valid {
+		return fmt.Errorf("%s MOVD operands are outside Go 1.27's MOVD/ymovq forms: %q", c.goarch, ins.Raw)
+	}
+	return nil
+}
+
+func isAMD64MOVDXRegister(op Operand) bool {
+	if op.Kind != OpReg {
+		return false
+	}
+	_, ok := amd64ParseXReg(op.Reg)
+	return ok
+}
+
+func isAMD64MOVDMRegister(op Operand) bool {
+	if op.Kind != OpReg {
+		return false
+	}
+	_, ok := amd64ParseMReg(op.Reg)
+	return ok
+}
+
+func (c *amd64Ctx) isGoYrlRegister(op Operand) bool {
+	if op.Kind != OpReg || !isAMD64YrlRegister(op.Reg) {
+		return false
+	}
+	if c.goarch != "386" {
+		return true
+	}
+	switch op.Reg {
+	case AX, BX, CX, DX, SP, BP, SI, DI:
+		return true
+	default:
+		return false
+	}
+}
+
 func llvmShiftRightBytesMask(n int64) string {
 	// shufflevector mask for right shift by n bytes.
 	// Use second vector's element 0 (index 16) as the "zero" source.
@@ -2975,29 +1581,6 @@ func llvmShiftLeftBytesMask(n int64) string {
 	return sb.String()
 }
 
-func llvmAlignRightBytesMask(n int64) string {
-	// shufflevector mask for alignr(dst, src, n):
-	// result bytes are selected from concatenation [dst, src], right shifted by n.
-	var sb strings.Builder
-	sb.WriteString("<")
-	for i := 0; i < 16; i++ {
-		if i != 0 {
-			sb.WriteString(", ")
-		}
-		idx := int64(i) + n
-		switch {
-		case idx < 16:
-			fmt.Fprintf(&sb, "i32 %d", idx)
-		case idx < 32:
-			fmt.Fprintf(&sb, "i32 %d", idx)
-		default:
-			sb.WriteString("i32 16")
-		}
-	}
-	sb.WriteString(">")
-	return sb.String()
-}
-
 func llvmRepeatI8Mask(chunk, width int) string {
 	if chunk <= 0 {
 		chunk = 1
@@ -3014,6 +1597,45 @@ func llvmRepeatI8Mask(chunk, width int) string {
 	return sb.String()
 }
 
+func llvmSplatInteger(lanes, bits int, value uint64) string {
+	return llvmSplatIntegerText(lanes, bits, strconv.FormatUint(value, 10))
+}
+
+func llvmSplatIntegerText(lanes, bits int, value string) string {
+	if lanes <= 0 {
+		return "<>"
+	}
+	element := "i" + strconv.Itoa(bits) + " " + value
+	var b strings.Builder
+	// The two brackets replace the separator omitted before the first lane.
+	b.Grow(lanes * (len(element) + 2))
+	b.WriteByte('<')
+	for lane := 0; lane < lanes; lane++ {
+		if lane != 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(element)
+	}
+	b.WriteByte('>')
+	return b.String()
+}
+
+func amd64SplatInteger(c *amd64Ctx, lanes, bits int, value string) string {
+	seed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> poison, i%d %s, i32 0\n", seed, lanes, bits, bits, value)
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %%%s, <%d x i%d> poison, <%d x i32> zeroinitializer\n", splat, lanes, bits, seed, lanes, bits, lanes)
+	return "%" + splat
+}
+
+func amd64SplatI1(c *amd64Ctx, lanes int, value string) string {
+	seed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i1> poison, i1 %s, i32 0\n", seed, lanes, value)
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i1> %%%s, <%d x i1> poison, <%d x i32> zeroinitializer\n", splat, lanes, seed, lanes, lanes)
+	return "%" + splat
+}
+
 func llvmAllOnesI8Vec(n int) string {
 	if n <= 0 {
 		return "<>"
@@ -3035,6 +1657,16 @@ func isAMD64ZReg(r Reg) bool {
 	return ok
 }
 
+func isAMD64XReg(r Reg) bool {
+	_, ok := amd64ParseXReg(r)
+	return ok
+}
+
+func isAMD64YReg(r Reg) bool {
+	_, ok := amd64ParseYReg(r)
+	return ok
+}
+
 func llvmI32RangeMask(start int, n int) string {
 	// Build <n x i32> <start, start+1, ...>.
 	if n <= 0 {
@@ -3074,6 +1706,40 @@ func amd64MaskBitI1(c *amd64Ctx, mask string, idx int) string {
 	return "%" + bit
 }
 
+func amd64ApplyI32LaneMask(c *amd64Ctx, lanes int, computed, old, mask string, zeroing bool) string {
+	return amd64ApplyIntegerLaneMask(c, lanes, 32, computed, old, mask, zeroing)
+}
+
+func amd64ApplyIntegerLaneMask(c *amd64Ctx, lanes, bits int, computed, old, mask string, zeroing bool) string {
+	fallback := old
+	if zeroing {
+		fallback = "zeroinitializer"
+	}
+	if lanes <= 0 {
+		return fallback
+	}
+
+	// Each predicate lane selects its own numerical mask bit. A scalar-to-
+	// vector bitcast would instead depend on the target's byte order. Typed
+	// callers supply at most 64 lanes, so every logical shift is below 64.
+	splat := amd64SplatInteger(c, lanes, 64, mask)
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr <%d x i64> %s, <", shifted, lanes, splat)
+	for lane := 0; lane < lanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i64 %d", lane)
+	}
+	c.b.WriteString(">\n")
+	predicate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc <%d x i64> %%%s to <%d x i1>\n", predicate, lanes, shifted, lanes)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %s, <%d x i%d> %s\n",
+		selected, lanes, predicate, lanes, bits, computed, lanes, bits, fallback)
+	return "%" + selected
+}
+
 func amd64PackI1x8ToI64(c *amd64Ctx, pred string) string {
 	acc := "0"
 	for i := 0; i < 8; i++ {
diff --git a/amd64_lower_vecflags.go b/amd64_lower_vecflags.go
new file mode 100644
index 000000000..0147cc6c2
--- /dev/null
+++ b/amd64_lower_vecflags.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64VectorTestSpec struct {
+	maxBytes     int
+	vector       bool
+	signLaneBits int
+}
+
+// amd64VectorTestSpecs models the complete Go 1.27 PTEST/VPTEST/VTEST grammar.
+// PTEST uses the legacy yxm_q4 X/m128 row. The VEX instructions share
+// _yvptest's X/m128,X and Y/m256,Y rows. VTESTPD and VTESTPS consider only the
+// sign bit in each floating-point lane; PTEST and VPTEST consider every bit.
+var amd64VectorTestSpecs = map[Op]amd64VectorTestSpec{
+	"PTEST":   {maxBytes: 16},
+	"VPTEST":  {maxBytes: 32, vector: true},
+	"VTESTPD": {maxBytes: 32, vector: true, signLaneBits: 64},
+	"VTESTPS": {maxBytes: 32, vector: true, signLaneBits: 32},
+}
+
+type x86VectorTestForm struct {
+	amd64VectorTestSpec
+	byteWidth int
+}
+
+// The lowerer and numerical observer share operand shape only. Original
+// memory backing, initialized bytes and physical mode remain separate roles.
+func x86VectorTestProperties(op Op, ins Instr, arch string) (x86VectorTestForm, bool, error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64VectorTestSpecs[Op(baseOp)]
+	form := x86VectorTestForm{amd64VectorTestSpec: spec}
+	if !recognized {
+		return form, false, nil
+	}
+	if rawOp != baseOp || arch != "amd64" && arch != "386" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), baseOp) {
+		return form, true, fmt.Errorf("%s %s has an unbound mode, dispatch or suffix: %q", arch, baseOp, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		return form, true, fmt.Errorf("%s %s expects vector/memory source and vector destination: %q", arch, baseOp, ins.Raw)
+	}
+
+	source, destination := ins.Args[0], ins.Args[1]
+	byteWidth := amd64VectorByteWidth(destination.Reg)
+	form.byteWidth = byteWidth
+	legacy := func(reg Reg) bool {
+		index, valid := amd64ParseXReg(reg)
+		return valid && index < 16 && (arch != "386" || index < 8)
+	}
+	if (byteWidth != 16 && byteWidth != 32) || byteWidth > spec.maxBytes {
+		return form, true, fmt.Errorf("%s %s destination width is outside its Go 1.27 table: %q", arch, baseOp, ins.Raw)
+	}
+	if spec.vector {
+		// Go's VEX classes admit X/Y0-15 even in 386 mode. They also admit
+		// extended address registers there, so do not apply the legacy 386
+		// register filter to VEX memory operands.
+		if !amd64VEXVectorRegister(destination, byteWidth) {
+			return form, true, fmt.Errorf("%s %s destination is outside Go's VEX X/Y class: %q", arch, baseOp, ins.Raw)
+		}
+	} else if byteWidth != 16 || !legacy(destination.Reg) {
+		return form, true, fmt.Errorf("%s %s destination is outside Go's legacy X class: %q", arch, baseOp, ins.Raw)
+	}
+
+	if source.Kind == OpReg {
+		if spec.vector {
+			if !amd64VEXVectorRegister(source, byteWidth) {
+				return form, true, fmt.Errorf("%s %s source must match the destination's VEX width: %q", arch, baseOp, ins.Raw)
+			}
+		} else if byteWidth != 16 || !legacy(source.Reg) {
+			return form, true, fmt.Errorf("%s %s source is outside Go's legacy X class: %q", arch, baseOp, ins.Raw)
+		}
+	} else if !isAMD64MemoryOperand(source) {
+		return form, true, fmt.Errorf("%s %s source must be a same-width vector register or memory: %q", arch, baseOp, ins.Raw)
+	}
+	if !spec.vector && source.Kind == OpMem && !x86MemoryRegistersValidForArch(source.Mem, arch) {
+		return form, true, fmt.Errorf("%s %s source uses an out-of-range legacy address register: %q", arch, baseOp, ins.Raw)
+	}
+	return form, true, nil
+}
+
+func x86TypedVectorTestByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86VectorTestProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, flagsDefined: x86ByteFlagsAll,
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: ins.Args[0], width: width, read: true},
+			{index: 1, operand: ins.Args[1], width: width, read: true},
+		}}, true, nil
+}
+
+func (c *amd64Ctx) lowerVectorTest(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64" // Preserve the existing direct-emitter default.
+	}
+	form, known, err := x86VectorTestProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	spec, byteWidth := form.amd64VectorTestSpec, form.byteWidth
+	if source.Kind != OpReg && source.Kind != OpFP {
+		if source.Kind == OpMem && !c.nativeMemoryOperand(ins, 0) &&
+			!x86CallerMemoryCertified(ins, 0) && !c.fixedLocalMemoryCertified(ins, 0) {
+			return true, false, fmt.Errorf("%w: vector test needs its original native memory binding", ErrProbeNeedsContext)
+		}
+		return true, false, c.emitVectorTestNativeMemory(ins, form, arch)
+	}
+	if source.Kind == OpFP {
+		if !spec.vector {
+			return true, false, fmt.Errorf("%w: legacy PTEST needs its original memory envelope", ErrProbeNeedsContext)
+		}
+		if err := c.validateX86PackedShiftFPSpan(source.FPOffset, byteWidth); err != nil {
+			return true, false, err
+		}
+	}
+	sourceBytes, err := c.loadX86PackedShiftBytes(source, byteWidth, true)
+	if err != nil {
+		return true, false, err
+	}
+	destinationBytes, err := c.loadPackedCompareBytes(destination, byteWidth)
+	if err != nil {
+		return true, false, err
+	}
+
+	intersection := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and <%d x i8> %s, %s\n", intersection, byteWidth, destinationBytes, sourceBytes)
+	invertedDestination := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor <%d x i8> %s, %s\n", invertedDestination, byteWidth, destinationBytes, llvmAllOnesI8Vec(byteWidth))
+	outsideDestination := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and <%d x i8> %%%s, %s\n", outsideDestination, byteWidth, invertedDestination, sourceBytes)
+
+	var zero, carry string
+	if spec.signLaneBits == 0 {
+		// Avoid an i256 scalar: LLVM 22 aborts while legalizing that type for
+		// i386. Reducing individual bytes compiles on every supported target.
+		zero = c.emitVectorBytesAreZero(byteWidth, "%"+intersection)
+		carry = c.emitVectorBytesAreZero(byteWidth, "%"+outsideDestination)
+	} else {
+		zero = c.emitNoSignBits(byteWidth, spec.signLaneBits, "%"+intersection)
+		carry = c.emitNoSignBits(byteWidth, spec.signLaneBits, "%"+outsideDestination)
+	}
+
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", carry, c.flagsCFSlot)
+	// All four instructions compute CF/ZF and clear AF/OF/SF/PF.
+	c.clearX86StatusFlags(x86StatusAll &^ (x86StatusCF | x86StatusZF))
+	return true, false, nil
+}
+
+func (c *amd64Ctx) emitVectorBytesAreZero(byteWidth int, bytes string) string {
+	// Extract bytes directly. LLVM 22's i386 backend also aborts on some
+	// otherwise-valid bitcasts between illegal 256-bit vector types.
+	combined := "0"
+	for index := 0; index < byteWidth; index++ {
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", element, byteWidth, bytes, index)
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i8 %s, %%%s\n", merged, combined, element)
+		combined = "%" + merged
+	}
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i8 %s, 0\n", zero, combined)
+	return "%" + zero
+}
+
+func (c *amd64Ctx) emitNoSignBits(byteWidth, laneBits int, bytes string) string {
+	lanes := byteWidth * 8 / laneBits
+	any := "false"
+	for lane := 0; lane < lanes; lane++ {
+		// X86 is little-endian, so each lane's sign bit is the high bit of
+		// its final byte. Testing that byte avoids illegal 256-bit vector
+		// bitcasts in LLVM 22's i386 legalizer.
+		index := (lane+1)*(laneBits/8) - 1
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", element, byteWidth, bytes, index)
+		negative := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i8 %%%s, 0\n", negative, element)
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %%%s\n", combined, any, negative)
+		any = "%" + combined
+	}
+	none := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", none, any)
+	return "%" + none
+}
diff --git a/amd64_lower_vecflags_test.go b/amd64_lower_vecflags_test.go
new file mode 100644
index 000000000..393d482eb
--- /dev/null
+++ b/amd64_lower_vecflags_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64VectorTestGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64VectorTestSpec{
+		"PTEST":   {maxBytes: 16},
+		"VPTEST":  {maxBytes: 32, vector: true},
+		"VTESTPD": {maxBytes: 32, vector: true, signLaneBits: 64},
+		"VTESTPS": {maxBytes: 32, vector: true, signLaneBits: 32},
+	}
+	if len(amd64VectorTestSpecs) != len(expected) {
+		t.Fatalf("vector-test grammar has %d entries, want %d", len(amd64VectorTestSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64VectorTestSpecs[op]; !ok {
+			t.Errorf("vector-test grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("vector-test grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86VectorTestCompleteGoFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			legacyLast := 15
+			if target.goarch == "386" {
+				legacyLast = 7
+			}
+			source := fmt.Sprintf(`TEXT vectortestforms(SB),$0-0
+	PTEST X0, X%d
+	PTEST 0(AX), X%d
+	VPTEST X0, X15
+	VPTEST 16(R9), X15
+	VPTEST Y0, Y15
+	VPTEST 32(R9), Y15
+	VTESTPD X0, X15
+	VTESTPD 48(R9), X15
+	VTESTPD Y0, Y15
+	VTESTPD 64(R9), Y15
+	VTESTPS X0, X15
+	VTESTPS 80(R9), X15
+	VTESTPS Y0, Y15
+	VTESTPS 96(R9), Y15
+	RET
+`, legacyLast, legacyLast)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"vectortestforms": {Name: "vectortestforms", Ret: Void},
+				},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original vector-test formats invented register or native-pointer inputs", err)
+			}
+			ir = x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"vectortestforms": {Name: "vectortestforms", Ret: Void}}, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerVectorTest(ins.Op, ins) })
+			for _, want := range []string{"<16 x i8>", "<32 x i8>", "store i1"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("vector-test lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "vector-test-"+target.name+".ll", "vector-test-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86VectorTestRejectsFormsOutsideGoTables(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "PTEST Y0, Y1"},
+		{goarch: "amd64", instruction: "PTEST X0, 0(AX)"},
+		{goarch: "amd64", instruction: "PTEST X16, X0"},
+		{goarch: "amd64", instruction: "PTEST.Z X0, X1"},
+		{goarch: "386", instruction: "PTEST X8, X0"},
+		{goarch: "386", instruction: "PTEST 0(R9), X0"},
+		{goarch: "amd64", instruction: "VPTEST X0, Y1"},
+		{goarch: "amd64", instruction: "VPTEST Z0, Z1"},
+		{goarch: "amd64", instruction: "VPTEST X16, X0"},
+		{goarch: "amd64", instruction: "VPTEST.Z X0, X1"},
+		{goarch: "amd64", instruction: "VTESTPD X0, Y1"},
+		{goarch: "amd64", instruction: "VTESTPD Z0, Z1"},
+		{goarch: "amd64", instruction: "VTESTPS X16, X0"},
+		{goarch: "amd64", instruction: "VTESTPS X0, X1, X2"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside the Go 1.27 vector-test tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64VectorTestRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT vectortestsemantics(SB),$0-24
+	MOVQ out+0(FP), CX
+	MOVQ source+8(FP), AX
+	MOVQ destination+16(FP), BX
+	MOVUPS 0(AX), X0
+	MOVUPS 0(BX), X1
+	MOVB $0x7f, DL
+	ADDB $1, DL
+	PTEST X0, X1
+	SETEQ 0(CX)
+	SETCS 1(CX)
+	SETMI 2(CX)
+	SETOS 3(CX)
+	SETPS 4(CX)
+
+	MOVQ source+8(FP), AX
+	MOVQ destination+16(FP), BX
+	VMOVDQU 32(BX), Y1
+	XORB DL, DL
+	VPTEST 32(AX), Y1
+	SETEQ 5(CX)
+	SETCS 6(CX)
+	SETMI 7(CX)
+	SETOS 8(CX)
+	SETPS 9(CX)
+
+	MOVQ source+8(FP), AX
+	MOVQ destination+16(FP), BX
+	MOVUPS 64(BX), X1
+	VTESTPS 64(AX), X1
+	SETEQ 10(CX)
+	SETCS 11(CX)
+	SETMI 12(CX)
+	SETOS 13(CX)
+	SETPS 14(CX)
+
+	MOVQ source+8(FP), AX
+	MOVQ destination+16(FP), BX
+	VMOVDQU 96(BX), Y1
+	VTESTPD 96(AX), Y1
+	SETEQ 15(CX)
+	SETCS 16(CX)
+	SETMI 17(CX)
+	SETOS 18(CX)
+	SETPS 19(CX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"vectortestsemantics": {
+			Name: "vectortestsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void vectortestsemantics(uint8_t *, const uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t source[128] = {0}, destination[128] = {0}, out[20] = {0};
+  source[0] = 1;
+  source[32] = 1; destination[32] = 1;
+  source[64] = 1; destination[64] = 1;
+  source[103] = 0x80;
+  vectortestsemantics(out, source, destination);
+  const uint8_t want[20] = {
+    1, 0, 0, 0, 0,
+    0, 1, 0, 0, 0,
+    1, 1, 0, 0, 0,
+    1, 0, 0, 0, 0,
+  };
+  for (int i = 0; i < 20; i++) if (out[i] != want[i]) return 10 + i;
+  return 0;
+}
+`
+	compiler := []string{clang}
+	if triple != testTargetTriple(runtime.GOOS, runtime.GOARCH) {
+		compiler = append(compiler, "-target", triple)
+	}
+	runKernel := func(encoding, input string) {
+		for _, pipeline := range []struct {
+			name      string
+			optimized bool
+			backend   int
+		}{
+			{name: "backend_O0"},
+			{name: "backend_O2", backend: 2},
+			{name: "IR_O2/backend_O2", optimized: true, backend: 2},
+		} {
+			t.Run(encoding+"/"+pipeline.name, func(t *testing.T) {
+				text := input
+				if pipeline.optimized {
+					text = x86DwordProductIROptimize(t, input)
+				}
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "vector_test_"+encoding,
+					triple, text, mainC, runPrefix, pipeline.backend)
+			})
+		}
+	}
+	runKernel("named", ir)
+
+	// Exercise the raw-byte path with the same independently checked flag
+	// oracle. Keep the displacements and operand order identical to the named
+	// Go source above, including both 128-bit and 256-bit memory forms.
+	rawSource := strings.NewReplacer(
+		"PTEST X0, X1", "BYTE $0x66\n\tBYTE $0x0f\n\tBYTE $0x38\n\tBYTE $0x17\n\tBYTE $0xc8",
+		"VPTEST 32(AX), Y1", "BYTE $0xc4\n\tBYTE $0xe2\n\tBYTE $0x7d\n\tBYTE $0x17\n\tBYTE $0x48\n\tBYTE $0x20",
+		"VTESTPS 64(AX), X1", "BYTE $0xc4\n\tBYTE $0xe2\n\tBYTE $0x79\n\tBYTE $0x0e\n\tBYTE $0x48\n\tBYTE $0x40",
+		"VTESTPD 96(AX), Y1", "BYTE $0xc4\n\tBYTE $0xe2\n\tBYTE $0x7d\n\tBYTE $0x0f\n\tBYTE $0x48\n\tBYTE $0x60",
+	).Replace(source)
+	requireX86GoAssemblerResult(t, "amd64", rawSource, true)
+	rawFile, err := Parse(ArchAMD64, rawSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rawIR, err := Translate(rawFile, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"vectortestsemantics": {
+			Name: "vectortestsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	runKernel("raw", rawIR)
+}
diff --git a/amd64_lower_vextractps_test.go b/amd64_lower_vextractps_test.go
new file mode 100644
index 000000000..922eced44
--- /dev/null
+++ b/amd64_lower_vextractps_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64PackedScalarExtractGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64PackedScalarExtractSpecs))
+	for op := range amd64PackedScalarExtractSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{
+		"EXTRACTPS", "PEXTRB", "PEXTRD", "PEXTRQ", "PEXTRW",
+		"VEXTRACTPS", "VPEXTRB", "VPEXTRD", "VPEXTRQ", "VPEXTRW",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("packed scalar-extract grammar opcodes = %v, want %v", got, want)
+	}
+}
+
+func TestTranslateX86ExtractPSCompleteGo127Forms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			highX, highGP := "X15", "R15"
+			if target.goarch == "386" {
+				highX, highGP = "X7", "DI"
+			}
+			source := "TEXT extractpsforms(SB),$0-0\n" +
+				"\tEXTRACTPS $0, X0, AX\n" +
+				"\tEXTRACTPS $3, " + highX + ", (BX)\n" +
+				"\tEXTRACTPS $2, " + highX + ", " + highGP + "\n" +
+				"\tVEXTRACTPS $-128, X0, AX\n" +
+				"\tVPEXTRQ $0, X0, (BX)\n" +
+				"\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "extractpsforms", target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "extractps-"+target.name+".ll", "extractps-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86ExtractPSRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "EXTRACTPS $-1, X0, AX"},
+		{goarch: "amd64", instruction: "EXTRACTPS $4, X0, AX"},
+		{goarch: "amd64", instruction: "EXTRACTPS $0, X16, AX"},
+		{goarch: "amd64", instruction: "EXTRACTPS $0, X0, M0"},
+		{goarch: "386", instruction: "EXTRACTPS $0, X8, AX"},
+		{goarch: "386", instruction: "EXTRACTPS $0, X0, R8"},
+		{goarch: "386", instruction: "PEXTRQ $0, X0, AX"},
+	} {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar-extract tables", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64ExtractPSRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT extractpssemantics(SB),NOSPLIT,$0-16
+	MOVQ in+0(FP), AX
+	MOVQ out+8(FP), BX
+	MOVUPS (AX), X0
+	EXTRACTPS $0, X0, CX
+	MOVL CX, 0(BX)
+	EXTRACTPS $3, X0, 4(BX)
+	VEXTRACTPS $2, X0, DX
+	MOVL DX, 8(BX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"extractpssemantics": {
+			Name: "extractpssemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void extractpssemantics(void *, void *);
+int main(void) {
+  uint32_t in[4] = {0x3f800001,0x40000002,0x40400003,0x40800004}, out[3] = {0};
+  extractpssemantics(in, out);
+  return out[0] == in[0] && out[1] == in[3] && out[2] == in[2] ? 0 : 10;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "extractps_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateAMD64VExtractPSCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT vextractpsforms(SB),$0-0
+	VEXTRACTPS $-128, X0, AX
+	VEXTRACTPS $255, X1, (AX)
+	VEXTRACTPS $255, X31, R15
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			ir := x86UnboundVoidScalarFormatObject(t, source, "vextractpsforms", "amd64", target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "vextractps-"+target.name+".ll", "vextractps-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateAMD64VExtractPSRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VEXTRACTPS $-129, X1, AX",
+		"VEXTRACTPS $-1, X31, AX",
+		"VEXTRACTPS $256, X1, AX",
+		"VEXTRACTPS $1, Y1, AX",
+		"VEXTRACTPS $1, X1, X2",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvextractps table", instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_lower_vinserti128_test.go b/amd64_lower_vinserti128_test.go
new file mode 100644
index 000000000..86a065293
--- /dev/null
+++ b/amd64_lower_vinserti128_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86VINSERTI128CompleteGo127Forms(t *testing.T) {
+	const source = `TEXT vinserti128_forms(SB),$0-0
+	VINSERTI128 $0, X0, Y1, Y2
+	VINSERTI128 $255, 8(BX), Y15, Y15
+	VINSERTI128 $1, X15, Y0, Y1
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"vinserti128_forms": {Name: "vinserti128_forms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "vinserti128-"+target.name+".ll", "vinserti128-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86VINSERTI128RejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"VINSERTI128 X0, Y1, Y2",
+		"VINSERTI128 $0, X0, Y1",
+		"VINSERTI128 $-1, X0, Y1, Y2",
+		"VINSERTI128 $256, X0, Y1, Y2",
+		"VINSERTI128 AX, X0, Y1, Y2",
+		"VINSERTI128 $0, Y0, Y1, Y2",
+		"VINSERTI128 $0, X16, Y1, Y2",
+		"VINSERTI128 $0, X0, X1, Y2",
+		"VINSERTI128 $0, X0, Y16, Y2",
+		"VINSERTI128 $0, X0, Y1, X2",
+		"VINSERTI128 $0, X0, Y1, Y16",
+		"VINSERTI128 $0, X0, Y1, 8(BX)",
+		"VINSERTI128.Z $0, X0, Y1, Y2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VINSERTI128 table", instruction)
+			}
+		})
+	}
+	const source386 = "TEXT bad(SB),$0-0\n\tVINSERTI128 $0, X0, Y1, Y2\n\tRET\n"
+	requireX86GoAssemblerResult(t, "386", source386, false)
+	file, err := Parse(ArchAMD64, source386)
+	if err == nil {
+		if _, err := Translate(file, Options{
+			Goarch:       "386",
+			TargetTriple: "i386-unknown-linux-gnu",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatal("Translate accepted 386 VINSERTI128 despite Go 1.27's frontend operand limit")
+		}
+	}
+}
+
+func TestAMD64VINSERTI128RuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT vinserti128Semantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	MOVQ narrow+8(FP), BX
+	MOVQ wide+16(FP), CX
+	VMOVDQU64 (BX), X0
+	VMOVDQU64 (CX), Y1
+	VINSERTI128 $0, X0, Y1, Y2
+	VMOVDQU64 Y2, 0(AX)
+	VINSERTI128 $255, X0, Y1, Y3
+	VMOVDQU64 Y3, 32(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"vinserti128Semantics": {
+				Name:  "vinserti128Semantics",
+				Args:  []LLVMType{Ptr, Ptr, Ptr},
+				Ret:   Void,
+				Frame: frame,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vinserti128Semantics(uint64_t *, const uint64_t *, const uint64_t *);
+int main(void) {
+  const uint64_t narrow[2] = {10, 11};
+  const uint64_t wide[4] = {20, 21, 22, 23};
+  uint64_t out[8] = {0};
+  const uint64_t want[8] = {10, 11, 22, 23, 20, 21, 10, 11};
+  vinserti128Semantics(out, narrow, wide);
+  for (int i = 0; i < 8; i++) if (out[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "vinserti128", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_vmov_fp_test.go b/amd64_lower_vmov_fp_test.go
new file mode 100644
index 000000000..52510b804
--- /dev/null
+++ b/amd64_lower_vmov_fp_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+const x86VMOVDQUAggregateFPOriginalSource = `TEXT vmovAggregateFP(SB),4,$0-24
+MOVQ out+0(FP),AX
+VMOVDQU key+8(FP),X0
+VMOVDQU X0,(AX)
+PXOR X0,X0
+VMOVDQU X0,key+8(FP)
+VMOVDQU key+8(FP),X1
+VMOVDQU X1,16(AX)
+RET
+`
+
+func TestX86VEXPackedMoveAggregateFPForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+
+	for _, target := range []struct {
+		arch, triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			pointerBytes := 8
+			if target.arch == "386" {
+				pointerBytes = 4
+			}
+			for _, op := range []string{"VMOVDQA", "VMOVDQU"} {
+				for _, width := range []struct {
+					name, reg string
+					bytes     int
+				}{{"x", "X0", 16}, {"y", "Y0", 32}} {
+					t.Run(op+"/"+width.name, func(t *testing.T) {
+						name := "packedFrame"
+						var slots []FrameSlot
+						args := []LLVMType{Ptr}
+						slots = append(slots, FrameSlot{Offset: 0, Type: Ptr, Index: 0, Field: -1})
+						for i := 0; i < width.bytes/4; i++ {
+							args = append(args, I32)
+							slots = append(slots, FrameSlot{
+								Offset: int64(pointerBytes + i*4),
+								Type:   I32,
+								Index:  i + 1,
+								Field:  -1,
+							})
+						}
+						mov := "MOVQ"
+						if target.arch == "386" {
+							mov = "MOVL"
+						}
+						source := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n%s out+0(FP),AX\n%s key+%d(FP),%s\n%s %s,(AX)\n%s (AX),%s\n%s %s,key+%d(FP)\nRET\n",
+							name, pointerBytes+width.bytes, mov, op, pointerBytes, width.reg,
+							op, width.reg, op, width.reg, op, width.reg, pointerBytes)
+						requireX86GoAssemblerResult(t, target.arch, source, true)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir, err := Translate(file, Options{
+							Goarch:       target.arch,
+							TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{name: {
+								Name: name, Args: args, Ret: Void,
+								Frame: FrameLayout{Params: slots},
+							}},
+						})
+						if op == "VMOVDQA" {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("virtual aggregate acquired native alignment: %v", err)
+							}
+							return
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "vmov-fp.ll", "vmov-fp.o", ir)
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64VMOVDQUAggregateFPBytesRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	file, err := Parse(ArchAMD64, x86VMOVDQUAggregateFPOriginalSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{
+		Name: "vmovAggregateFP",
+		Args: []LLVMType{Ptr, I32, I32, I32, I32},
+		Ret:  Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: I32, Index: 1, Field: -1},
+			{Offset: 12, Type: I32, Index: 2, Field: -1},
+			{Offset: 16, Type: I32, Index: 3, Field: -1},
+			{Offset: 20, Type: I32, Index: 4, Field: -1},
+		}},
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if runtime.GOARCH != "amd64" {
+		if runtime.GOOS != "darwin" || !rosettaAvailable() {
+			t.Skip("execution requires amd64 or Rosetta; five-target object tests are separate")
+		}
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs:         map[string]FuncSig{sig.Name: sig},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+extern void vmovAggregateFP(uint8_t *, uint32_t, uint32_t, uint32_t, uint32_t);
+int main(void) {
+  uint32_t key[4] = {0x12345678, 0x90abcdef, 0x13579bdf, 0x2468ace0};
+  uint8_t out[32];
+  memset(out, 0xa5, sizeof out);
+  vmovAggregateFP(out, key[0], key[1], key[2], key[3]);
+  for (int i = 0; i < 16; i++) {
+    if (out[i] != ((uint8_t *)key)[i] || out[16+i] != 0) {
+      fprintf(stderr, "VMOVDQU FP byte %d: got %u and %u\n", i, out[i], out[16+i]);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "vmov_aggregate_fp", triple, ir, mainC, prefix)
+}
+
+func TestX86VEXPackedMoveAggregateFPRejectsInvalidForms(t *testing.T) {
+	for _, target := range []struct {
+		arch, triple string
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"386", "i386-unknown-linux-gnu"},
+	} {
+		for _, form := range []string{
+			"VMOVDQU key+8(FP),X0",    // Four-byte slot cannot supply 16 bytes.
+			"VMOVDQA key+8(FP),Y0",    // Four-byte slot cannot supply 32 bytes.
+			"VMOVDQU key+8(FP),Z0",    // No Z form in Go's VEX table.
+			"VMOVDQU.Z key+8(FP),X0",  // No VEX zeroing form.
+			"VMOVDQU key+8(FP),K1,X0", // No VEX mask form.
+		} {
+			t.Run(target.arch+"/"+form, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT invalid(SB),4,$0-12\n"+form+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{
+					Goarch:       target.arch,
+					TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"invalid": {
+						Name: "invalid", Args: []LLVMType{Ptr, I32}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+							{Offset: 8, Type: I32, Index: 1, Field: -1},
+						}},
+					}},
+				})
+				if err == nil {
+					t.Fatalf("accepted unsupported form %q", form)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_lower_vmov_half_test.go b/amd64_lower_vmov_half_test.go
new file mode 100644
index 000000000..b3896eefb
--- /dev/null
+++ b/amd64_lower_vmov_half_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAMD64MoveHalfGrammarCoversCompleteGoFamily(t *testing.T) {
+	expected := map[Op]amd64MoveHalfSpec{
+		"MOVHLPS":  {registerOnly: true},
+		"MOVLHPS":  {high: true, registerOnly: true},
+		"VMOVHLPS": {vector: true, registerOnly: true},
+		"VMOVLHPS": {high: true, vector: true, registerOnly: true},
+		"MOVLPS":   {},
+		"MOVHPS":   {high: true},
+		"MOVLPD":   {},
+		"MOVHPD":   {high: true},
+		"VMOVLPS":  {vector: true},
+		"VMOVHPS":  {high: true, vector: true},
+		"VMOVLPD":  {vector: true},
+		"VMOVHPD":  {high: true, vector: true},
+	}
+	if len(amd64MoveHalfSpecs) != len(expected) {
+		t.Fatalf("move-half grammar has %d entries, want %d", len(amd64MoveHalfSpecs), len(expected))
+	}
+	for op, want := range expected {
+		if got, ok := amd64MoveHalfSpecs[op]; !ok {
+			t.Errorf("move-half grammar omitted %s", op)
+		} else if got != want {
+			t.Errorf("move-half grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86VEXMoveHalfCompleteFormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			base, last := 30, 31
+			if target.goarch == "386" {
+				base, last = 6, 7
+			}
+			var source strings.Builder
+			source.WriteString("TEXT vmovhalfforms(SB),$0-0\n")
+			for _, op := range []string{"VMOVLPS", "VMOVHPS", "VMOVLPD", "VMOVHPD"} {
+				fmt.Fprintf(&source, "\t%s X%d, 0(AX)\n", op, last)
+				fmt.Fprintf(&source, "\t%s 8(AX), X%d, X%d\n", op, base, last)
+			}
+			source.WriteString("\tRET\n")
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(), "vmovhalfforms", target.goarch, target.triple)
+			ir := x86MoveHalfFormatObjectUnit(t, file, signatures, target.goarch, target.triple)
+			if !strings.Contains(ir, "extractelement <2 x i64>") || !strings.Contains(ir, "insertelement <2 x i64>") {
+				t.Fatalf("VEX half-move lowering omitted lane operations:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "vmov-half-"+target.name+".ll", "vmov-half-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86VEXMoveHalfRejectsFormsOutsideGoTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVHPS.Z 0(AX), X1, X2",
+		"VMOVLPS Y0, 0(AX)",
+		"VMOVHPD 0(AX), Y1, Y2",
+		"VMOVLPD X0, X1, X2",
+		"VMOVHPS 0(AX), X1",
+		"VMOVLPS X0, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's _yvmovhpd table", instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64VEXMoveHalfRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT vmovhalfsemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	MOVQ base+8(FP), CX
+	MOVQ half+16(FP), DX
+	MOVUPS 0(CX), X1
+	STC
+	VMOVHPS 0(DX), X1, X2
+	MOVUPS X2, 0(AX)
+	VMOVLPS 0(DX), X1, X3
+	MOVUPS X3, 16(AX)
+	SETCS 32(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{"vmovhalfsemantics": {
+			Name: "vmovhalfsemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void vmovhalfsemantics(uint8_t *, const uint64_t *, const uint64_t *);
+int main(void) {
+  uint8_t out[33] = {0};
+  const uint64_t base[2] = {UINT64_C(0x1111222233334444), UINT64_C(0x5555666677778888)};
+  const uint64_t half[1] = {UINT64_C(0xaaaabbbbccccdddd)};
+  uint64_t got[4];
+  vmovhalfsemantics(out, base, half);
+  memcpy(got, out, 32);
+  if (got[0] != base[0] || got[1] != half[0]) return 10;
+  if (got[2] != half[0] || got[3] != base[1]) return 11;
+  if (out[32] != 1) return 12;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "vex_move_half_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_lower_vmov_integer.go b/amd64_lower_vmov_integer.go
new file mode 100644
index 000000000..e9c840f40
--- /dev/null
+++ b/amd64_lower_vmov_integer.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Every named GP/X consumer shares exact width and encoding writeback rules.
+// Raw VMOVW retains its separate, decoder-bound 16-bit role.
+func (c *amd64Ctx) lowerVectorScalarIntegerMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("contradictory GP/X transfer dispatch %s/%s", op, ins.Op)
+	}
+	f, known, err := x86GPSIMDTransferProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if f.mmx && (ins.x86Encoded || ins.x86SourceRaw != nil) {
+		// A physical X-to-MMX destination remains native x87/MMX state;
+		// no source-compatible spelling grants a virtual GP register slot.
+		return true, false, fmt.Errorf("%w: raw Intel MOVDQ2Q requires its physical MMX/x87 entry and caller-state contract: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	if f.memory >= 0 && ins.Args[f.memory].Kind == OpFP {
+		if _, err := c.scalarFPSpan(ins.Args[f.memory].FPOffset, f.bits); err != nil {
+			return true, false, err
+		}
+	}
+	var low string
+	if f.sourceX {
+		low, err = c.loadXLowInteger(src.Reg, f.bits)
+	} else {
+		low, err = c.loadGPSIMDTransferSource(src, f.bits)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if f.destinationX {
+		lanes := 128 / f.bits
+		inserted, bytes := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n", inserted, lanes, f.bits, f.bits, low)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, lanes, f.bits, inserted)
+		if f.spec.legacy {
+			return true, false, c.storeX(dst.Reg, "%"+bytes)
+		}
+		return true, false, c.storePackedMoveOperand(dst, 16, "%"+bytes)
+	}
+	if f.mmx {
+		return true, false, c.storeReg(dst.Reg, low)
+	}
+	if dst.Kind == OpFP {
+		return true, false, c.storeScalarFPBits(dst.FPOffset, f.bits, low)
+	}
+	return true, false, c.storeVMOVIntegerScalar(dst, f.bits, low)
+}
+
+func (c *amd64Ctx) loadGPSIMDTransferSource(source Operand, bits int) (string, error) {
+	if source.Kind == OpFP {
+		return c.loadScalarFPBits(source.FPOffset, bits)
+	}
+	var pointer, pointerType string
+	var err error
+	switch source.Kind {
+	case OpMem:
+		pointer, pointerType, err = c.ptrFromMem(source.Mem)
+	case OpSym:
+		pointer, err = c.ptrFromSB(source.Sym)
+		pointerType = "ptr"
+	default:
+		return c.evalIntSized(source, amd64IntegerTypeForBits(bits))
+	}
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	// Unmasked MOVD/Q reads are observable at their original width even
+	// when the destination is dead. They have no alignment or MXCSR effect.
+	fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", value, bits, pointerType, pointer)
+	return "%" + value, nil
+}
+
+func isAMD64GoXRegister(operand Operand) bool {
+	if operand.Kind != OpReg {
+		return false
+	}
+	_, ok := amd64ParseXReg(operand.Reg)
+	return ok
+}
+
+func (c *amd64Ctx) storeVMOVIntegerScalar(dst Operand, bits int, value string) error {
+	typ := amd64IntegerTypeForBits(bits)
+	if dst.Kind == OpMem || dst.Kind == OpSym {
+		var pointer, pointerType string
+		var err error
+		if dst.Kind == OpMem {
+			pointer, pointerType, err = c.ptrFromMem(dst.Mem)
+		} else {
+			pointer, err = c.ptrFromSB(dst.Sym)
+			pointerType = "ptr"
+		}
+		if err != nil {
+			return err
+		}
+		// Keep each original unmasked native store, including overwritten
+		// stores or private symbols whose value becomes otherwise dead.
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+		return nil
+	}
+	if dst.Kind != OpReg {
+		return c.storeScalarIntegerOperand(dst, typ, value)
+	}
+	if bits == 64 {
+		return c.storeRegUnchecked(dst.Reg, value)
+	}
+	widened := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", widened, bits, value)
+	return c.storeRegUnchecked(dst.Reg, "%"+widened)
+}
diff --git a/amd64_lower_vmov_integer_test.go b/amd64_lower_vmov_integer_test.go
new file mode 100644
index 000000000..652b2ff29
--- /dev/null
+++ b/amd64_lower_vmov_integer_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86VMOVDVMOVQCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27's _yvmovd and _yvmovq tables allow scalar GP/memory transfers
+	// in both directions. VMOVQ additionally allows X-to-X low-qword moves.
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT vmovintegerscalarforms(SB),4,$0-0
+	VMOVD AX, X0
+	VMOVD X0, AX
+	VMOVD SP, X1
+	VMOVD X1, SP
+	VMOVD 8(AX), X20
+	VMOVD X20, 12(AX)
+	VMOVQ AX, X2
+	VMOVQ X2, AX
+	VMOVQ SP, X3
+	VMOVQ X3, SP
+	VMOVQ 16(AX), X30
+	VMOVQ X30, 24(AX)
+	VMOVQ X0, X1
+	VMOVQ X20, X31
+`
+			if target.goarch == "amd64" {
+				source += "\tVMOVD R8, X31\n\tVMOVD X31, R9\n\tVMOVQ R10, X30\n\tVMOVQ X30, R11\n"
+			} else {
+				// Go accepts these high spellings but they lack a bound physical
+				// mode32 identity. Their independent Context cases live beside
+				// the shared grammar; ordinary object coverage uses X0-X7.
+				source = strings.NewReplacer("X20", "X4", "X30", "X5", "X31", "X6").Replace(source)
+			}
+			source += "\tRET\n"
+			goAssemblerOracleOutput(t, target.goarch, source, "", true)
+			// Retain every original GP/SP/X/native-memory spelling. This
+			// format program has no actual data, pointer or physical SP entry
+			// contract. Complete initialized GP/X and native transfer matrices
+			// independently cover public success on all five targets.
+			ll := x86UnboundVoidScalarFormatObject(t, source, "vmovintegerscalarforms", target.goarch, target.triple)
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "vmov-integer-scalar-"+target.name+".ll", "vmov-integer-scalar-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86VMOVDVMOVQRejectsFormsOutsideGoAssemblerTables(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVD X0, X1",
+		"VMOVD Y0, AX",
+		"VMOVD AX, Y0",
+		"VMOVD Z0, AX",
+		"VMOVD AX, Z0",
+		"VMOVD AX, BX",
+		"VMOVD (AX), 8(BX)",
+		"VMOVD.Z AX, X0",
+		"VMOVD AX, K1, X0",
+		"VMOVQ Y0, AX",
+		"VMOVQ AX, Y0",
+		"VMOVQ Z0, X0",
+		"VMOVQ AX, BX",
+		"VMOVQ (AX), 8(BX)",
+		"VMOVQ.Z X0, X1",
+		"VMOVQ X0, K1, X1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			assertX86VMOVIntegerRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+		})
+	}
+	for _, instruction := range []string{
+		"VMOVD R8, X0",
+		"VMOVD X0, R8",
+		"VMOVQ R8, X0",
+		"VMOVQ X0, R8",
+	} {
+		t.Run("386_"+strings.NewReplacer(" ", "_").Replace(instruction), func(t *testing.T) {
+			assertX86VMOVIntegerRejected(t, "386", "i386-unknown-linux-gnu", instruction)
+		})
+	}
+}
+
+func assertX86VMOVIntegerRejected(t *testing.T, goarch, triple, instruction string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       goarch,
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatalf("Translate accepted %q outside Go 1.27's VMOVD/VMOVQ forms for %s", instruction, goarch)
+	}
+}
diff --git a/amd64_lower_vmov_scalar.go b/amd64_lower_vmov_scalar.go
new file mode 100644
index 000000000..4ca03c771
--- /dev/null
+++ b/amd64_lower_vmov_scalar.go
@@ -0,0 +1,330 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// lowerVectorScalarMove implements all Go 1.27 _yvmovsd forms shared by
+// VMOVSD and VMOVSS: scalar loads/stores, three-register upper merges, and
+// their EVEX masked variants.
+func (c *amd64Ctx) lowerVectorScalarMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64ScalarVectorMoveSpecs[Op(baseOp)]
+	if !recognized || spec.legacy {
+		return false, false, nil
+	}
+	form, _, err := amd64ScalarVectorMoveProperties(ins, c.goarch)
+	if err != nil {
+		return true, false, err
+	}
+	if form.literal {
+		if form.legacyZero {
+			// The actual Go encoder emits legacy XORPS, even for a VMOV
+			// spelling. Do not zero the wider Y/Z views as VEX would.
+			var value string
+			if spec.bits == 32 {
+				value, err = c.evalF32(ins.Args[0])
+			} else {
+				value, err = c.evalF64(ins.Args[0])
+			}
+			if err != nil {
+				return true, false, err
+			}
+			return true, false, c.storeLegacyScalarMoveRegister(ins.Args[form.destination].Reg, value, spec.bits, false)
+		}
+		bits := uint64(ins.Args[0].Imm)
+		if spec.bits == 32 {
+			bits = uint64(math.Float32bits(float32(math.Float64frombits(bits))))
+		}
+		mask := ""
+		if form.mask >= 0 {
+			mask, err = c.loadK(ins.Args[form.mask].Reg)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		return true, false, c.storeScalarMoveRegister(ins.Args[form.destination].Reg, spec.bits,
+			strconv.FormatUint(bits, 10), "zeroinitializer", mask, form.zeroing)
+	}
+	if form.upper >= 0 {
+		mask := Operand{}
+		if form.mask >= 0 {
+			mask = ins.Args[form.mask]
+		}
+		return c.lowerVectorScalarMoveRegisterMerge(spec.bits, ins.Args[form.low], ins.Args[form.upper], mask,
+			ins.Args[form.destination], form.zeroing)
+	}
+	if form.mask >= 0 {
+		return c.lowerVectorScalarMoveMaskedMemory(baseOp, spec.bits, form.zeroing, ins)
+	}
+	return c.lowerVectorScalarMoveTwoOperand(baseOp, spec.bits, ins)
+}
+
+func (c *amd64Ctx) lowerVectorScalarMoveTwoOperand(baseOp string, elemBits int, ins Instr) (bool, bool, error) {
+	src, dst := ins.Args[0], ins.Args[1]
+	if amd64ScalarXOperand(src) && isAMD64MemoryOperand(dst) {
+		value, err := c.loadXLowInteger(src.Reg, elemBits)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeVectorScalarMoveMemory(dst, elemBits, value, "")
+	}
+	if isAMD64MemoryOperand(src) && amd64ScalarXOperand(dst) {
+		value, err := c.loadScalarMoveMemory(src, elemBits)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeScalarMoveRegister(dst.Reg, elemBits, value, "zeroinitializer", "", false)
+	}
+	return true, false, fmt.Errorf("amd64 %s two-operand form requires X-to-memory or memory-to-X: %q", baseOp, ins.Raw)
+}
+
+func (c *amd64Ctx) lowerVectorScalarMoveMaskedMemory(baseOp string, elemBits int, zeroing bool, ins Instr) (bool, bool, error) {
+	if !amd64NonzeroKOperand(ins.Args[1]) {
+		return true, false, fmt.Errorf("amd64 %s three-operand masked memory form expects K1-K7 in the middle: %q", baseOp, ins.Raw)
+	}
+	mask, err := c.loadK(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	if amd64ScalarXOperand(ins.Args[0]) && isAMD64MemoryOperand(ins.Args[2]) {
+		if zeroing {
+			return true, false, fmt.Errorf("amd64 %s cannot use .Z with a memory destination: %q", baseOp, ins.Raw)
+		}
+		value, err := c.loadXLowInteger(ins.Args[0].Reg, elemBits)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeVectorScalarMoveMemory(ins.Args[2], elemBits, value, mask)
+	}
+	if isAMD64MemoryOperand(ins.Args[0]) && amd64ScalarXOperand(ins.Args[2]) {
+		value, err := c.loadVectorScalarMemory(ins.Args[0], elemBits, mask)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeScalarMoveRegister(ins.Args[2].Reg, elemBits, value, "zeroinitializer", mask, zeroing)
+	}
+	return true, false, fmt.Errorf("amd64 %s masked memory form requires X, K, memory or memory, K, X: %q", baseOp, ins.Raw)
+}
+
+// A masked-off scalar move must not access memory at all. Selecting a loaded
+// value afterwards does not suppress faults, and a read/modify/write store
+// spuriously reads write-only memory even when the mask is active.
+func (c *amd64Ctx) loadVectorScalarMemory(src Operand, elemBits int, mask string) (string, error) {
+	condition := amd64MaskBitI1(c, mask, 0)
+	return c.loadX86ScalarMemoryIf(src, elemBits, condition)
+}
+
+func (c *amd64Ctx) loadX86ScalarMemoryIf(src Operand, elemBits int, condition string) (string, error) {
+	if src.Kind == OpFP && elemBits != 16 {
+		if _, err := c.scalarFPSpan(src.FPOffset, elemBits); err != nil {
+			return "", err
+		}
+		// Parameter-only loads also need a source-defined mask and merge
+		// lane. Validate before creating either masked control-flow branch.
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return "", err
+		}
+	}
+	return c.loadX86ScalarIf(elemBits, condition, func() (string, error) {
+		return c.loadScalarMoveMemory(src, elemBits)
+	})
+}
+
+func (c *amd64Ctx) loadScalarMoveMemory(src Operand, bits int) (string, error) {
+	if x86ScalarVectorMoveOrdinaryMemory(src, bits, c.goarch) {
+		return c.loadScalarVectorMoveNativeMemory(src, bits)
+	}
+	if src.Kind == OpFP && bits != 16 {
+		return c.loadScalarFPBits(src.FPOffset, bits)
+	}
+	return c.evalIntSized(src, amd64IntegerTypeForBits(bits))
+}
+
+func (c *amd64Ctx) loadX86ScalarIf(elemBits int, condition string, load func() (string, error)) (string, error) {
+	loadLabel := c.newTmp() + "_scalar_load"
+	skipLabel := c.newTmp() + "_scalar_skip"
+	joinLabel := c.newTmp() + "_scalar_join"
+	fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n%s:\n", condition, loadLabel, skipLabel, loadLabel)
+	value, err := load()
+	if err != nil {
+		return "", err
+	}
+	fmt.Fprintf(c.b, "  br label %%%s\n%s:\n  br label %%%s\n%s:\n", joinLabel, skipLabel, joinLabel, joinLabel)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = phi i%d [ %s, %%%s ], [ 0, %%%s ]\n", selected, elemBits, value, loadLabel, skipLabel)
+	return "%" + selected, nil
+}
+
+func (c *amd64Ctx) lowerVectorScalarMoveRegisterMerge(elemBits int, lowSource, upperSource, maskArg, dst Operand, zeroing bool) (bool, bool, error) {
+	low, err := c.loadXLowInteger(lowSource.Reg, elemBits)
+	if err != nil {
+		return true, false, err
+	}
+	upperBytes, err := c.loadX(upperSource.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elemBits
+	upper := c.bitcastVectorBytesToIntegerLanes(16, lanes, elemBits, upperBytes)
+	mask := ""
+	if maskArg.Kind == OpReg {
+		mask, err = c.loadK(maskArg.Reg)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, c.storeScalarMoveRegister(dst.Reg, elemBits, low, upper, mask, zeroing)
+}
+
+func amd64ScalarXOperand(op Operand) bool {
+	if op.Kind != OpReg {
+		return false
+	}
+	index, ok := amd64ParseXReg(op.Reg)
+	return ok && index < 32
+}
+
+func amd64NonzeroKOperand(op Operand) bool {
+	if op.Kind != OpReg {
+		return false
+	}
+	index, ok := amd64ParseKReg(op.Reg)
+	return ok && index != 0
+}
+
+func (c *amd64Ctx) loadXLowInteger(reg Reg, elemBits int) (string, error) {
+	bytesValue, err := c.loadX(reg)
+	if err != nil {
+		return "", err
+	}
+	lanes := 128 / elemBits
+	values := c.bitcastVectorBytesToIntegerLanes(16, lanes, elemBits, bytesValue)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 0\n", low, lanes, elemBits, values)
+	return "%" + low, nil
+}
+
+func (c *amd64Ctx) storeVectorScalarRegister(dst Reg, elemBits int, low, base, mask string, zeroing bool) error {
+	lanes := 128 / elemBits
+	if mask != "" {
+		fallback := "0"
+		if !zeroing {
+			old, err := c.loadXLowInteger(dst, elemBits)
+			if err != nil {
+				return err
+			}
+			fallback = old
+		}
+		maskBit := amd64MaskBitI1(c, mask, 0)
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %s, i%d %s\n", selected, maskBit, elemBits, low, elemBits, fallback)
+		low = "%" + selected
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 0\n", updated, lanes, elemBits, base, elemBits, low)
+	bytesValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytesValue, lanes, elemBits, updated)
+	return c.storeX(dst, "%"+bytesValue)
+}
+
+func (c *amd64Ctx) storeScalarMoveRegister(dst Reg, elemBits int, low, base, mask string, zeroing bool) error {
+	if err := c.storeVectorScalarRegister(dst, elemBits, low, base, mask, zeroing); err != nil {
+		return err
+	}
+	// VEX/EVEX scalar writes clear bits above 127, unlike legacy MOVSS/SD.
+	// Keep every live wider view coherent with the newly written low X value.
+	index, _ := amd64ParseXReg(dst)
+	for _, view := range []struct {
+		bytes int
+		slots map[int]string
+	}{{32, c.yRegSlot}, {64, c.zRegSlot}} {
+		if slot, live := view.slots[index]; live {
+			bytesValue, err := c.loadX(dst)
+			if err != nil {
+				return err
+			}
+			indices := make([]string, view.bytes)
+			for i := range indices {
+				lane := i
+				if lane >= 16 {
+					lane = 16 // First byte of the zero second source.
+				}
+				indices[i] = fmt.Sprintf("i32 %d", lane)
+			}
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> zeroinitializer, <%d x i32> <%s>\n", wide, bytesValue, view.bytes, strings.Join(indices, ", "))
+			fmt.Fprintf(c.b, "  store <%d x i8> %%%s, ptr %s\n", view.bytes, wide, slot)
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) storeVectorScalarMemory(dst Operand, elemBits int, value, mask string) error {
+	return c.storeVectorScalarMemoryWithNativeAccess(dst, elemBits, value, mask, false)
+}
+
+func (c *amd64Ctx) storeVectorScalarMoveMemory(dst Operand, elemBits int, value, mask string) error {
+	return c.storeVectorScalarMemoryWithNativeAccess(dst, elemBits, value, mask, true)
+}
+
+// Other users of the scalar byte-store helper retain their original emitter.
+// Only the typed VMOVSS/SD native path requests an observable access here.
+func (c *amd64Ctx) storeVectorScalarMemoryWithNativeAccess(dst Operand, elemBits int, value, mask string, nativeMove bool) error {
+	if dst.Kind == OpFP && elemBits != 16 {
+		result, err := c.scalarFPSpan(dst.FPOffset, elemBits)
+		if err != nil {
+			return err
+		}
+		if result && mask != "" {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+	}
+	if mask != "" {
+		condition := amd64MaskBitI1(c, mask, 0)
+		storeLabel := c.newTmp() + "_scalar_store"
+		joinLabel := c.newTmp() + "_scalar_join"
+		fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n%s:\n", condition, storeLabel, joinLabel, storeLabel)
+		if err := c.storeVectorScalarMemoryWithNativeAccess(dst, elemBits, value, "", nativeMove); err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  br label %%%s\n%s:\n", joinLabel, joinLabel)
+		return nil
+	}
+	switch dst.Kind {
+	case OpMem:
+		ptr, ptrType, err := c.ptrFromMem(dst.Mem)
+		if err != nil {
+			return err
+		}
+		volatile := ""
+		if nativeMove && x86ScalarVectorMoveOrdinaryMemory(dst, elemBits, c.goarch) {
+			volatile = "volatile "
+		}
+		fmt.Fprintf(c.b, "  store %si%d %s, %s %s, align 1\n", volatile, elemBits, value, ptrType, ptr)
+		return nil
+	case OpSym:
+		ptr, err := c.ptrFromSB(dst.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i%d %s, ptr %s, align 1\n", elemBits, value, ptr)
+		return nil
+	case OpFP:
+		if elemBits != 16 {
+			return c.storeScalarFPBits(dst.FPOffset, elemBits, value)
+		}
+		return c.storeFPResult(dst.FPOffset, amd64IntegerTypeForBits(elemBits), value)
+	default:
+		return fmt.Errorf("expected scalar memory destination, got %s", dst.String())
+	}
+}
diff --git a/amd64_lower_vmov_scalar_aggregate_test.go b/amd64_lower_vmov_scalar_aggregate_test.go
new file mode 100644
index 000000000..79f3e0fe0
--- /dev/null
+++ b/amd64_lower_vmov_scalar_aggregate_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+func TestTranslateX86WideStoresSpanComplex64Result(t *testing.T) {
+	for _, tc := range []struct {
+		name         string
+		instruction  string
+		amd64Only    bool
+		needsZeroXMM bool
+	}{
+		{name: "movsd", instruction: "MOVSD X0, ret+0(FP)", needsZeroXMM: true},
+		{name: "movq-xmm", instruction: "MOVQ X0, ret+0(FP)", needsZeroXMM: true},
+		{name: "vmovq-xmm", instruction: "VMOVQ X0, ret+0(FP)", needsZeroXMM: true},
+		{name: "movq-gp", instruction: "MOVQ AX, ret+0(FP)", amd64Only: true},
+		{name: "vmovsd", instruction: "VMOVSD X0, ret+0(FP)", amd64Only: true, needsZeroXMM: true},
+	} {
+		for _, target := range []struct {
+			name   string
+			goarch string
+			triple string
+		}{
+			{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+			{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+			{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+			{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+			{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+		} {
+			if tc.amd64Only && target.goarch != "amd64" {
+				continue
+			}
+			t.Run(tc.name+"/"+target.name, func(t *testing.T) {
+				functionName := "widestorecomplex64result"
+				source := fmt.Sprintf("TEXT %s(SB),$0-8\n", functionName)
+				if tc.needsZeroXMM {
+					source += "\tPXOR X0, X0\n"
+				} else if tc.name == "movq-gp" {
+					// Like every vector variant, the GP format witness must
+					// define its source rather than publish unknown entry bits.
+					source += "\tXORQ AX, AX\n"
+				}
+				source += "\t" + tc.instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, target.goarch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{
+					TargetTriple: target.triple,
+					Goarch:       target.goarch,
+					Sigs: map[string]FuncSig{
+						functionName: {
+							Name: functionName,
+							Ret:  LLVMType("{ float, float }"),
+							Frame: FrameLayout{Results: []FrameSlot{
+								{Offset: 0, Type: LLVMType("float"), Index: 0, Field: -1, Name: "ret"},
+								{Offset: 4, Type: LLVMType("float"), Index: 1, Field: -1, Name: "ret"},
+							}},
+						},
+					},
+				}
+				if tc.name == "movq-gp" {
+					mod, directErr := translateModuleDirect(file, options)
+					if directErr == nil {
+						mod.Dispose()
+						t.Fatal("direct linear prototype unexpectedly accepted a wide aggregate-result store")
+					}
+					if !errors.Is(directErr, errDirectModuleUnsupported) {
+						t.Fatalf("direct linear prototype error = %v, want fallback request", directErr)
+					}
+				}
+				ll, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc not found")
+				}
+				compileLLVMToObject(t, llc, target.triple, "wide-store-complex64-result.ll", "wide-store-complex64-result.o", ll)
+			})
+		}
+	}
+}
+
+func TestAMD64VMOVSDStoresComplex64ResultRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT vmovsdcomplex64result(SB),$0-16
+	MOVQ input+0(FP), AX
+	VMOVSD (AX), X0
+	VMOVSD X0, ret+8(FP)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"vmovsdcomplex64result": {
+				Name: "vmovsdcomplex64result",
+				Args: []LLVMType{Ptr},
+				Ret:  LLVMType("{ float, float }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1, Name: "input"}},
+					Results: []FrameSlot{
+						{Offset: 8, Type: LLVMType("float"), Index: 0, Field: -1, Name: "ret"},
+						{Offset: 12, Type: LLVMType("float"), Index: 1, Field: -1, Name: "ret"},
+					},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll += `
+define void @call_vmovsdcomplex64result(ptr %input, ptr %output) {
+entry:
+  %result = call { float, float } @vmovsdcomplex64result(ptr %input)
+  %real = extractvalue { float, float } %result, 0
+  %imag = extractvalue { float, float } %result, 1
+  store float %real, ptr %output, align 4
+  %imagptr = getelementptr float, ptr %output, i64 1
+  store float %imag, ptr %imagptr, align 4
+  ret void
+}
+`
+	mainC := `
+extern void call_vmovsdcomplex64result(const float *input, float *output);
+int main(void) {
+  const float input[2] = { 1.25f, -2.5f };
+  float got[2] = { 0.0f, 0.0f };
+  call_vmovsdcomplex64result(input, got);
+  if (got[0] != input[0]) return 1;
+  if (got[1] != input[1]) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "vmovsd_complex64_result", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_word_madd_family.go b/amd64_lower_word_madd_family.go
new file mode 100644
index 000000000..dfc9d4533
--- /dev/null
+++ b/amd64_lower_word_madd_family.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+func (c *amd64Ctx) lowerWordMultiplyAddForm(op Op, ins Instr, form x86PackedPhysicalForm) (bool, bool, error) {
+	first, second, destination := form.source, ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: %s m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext, op)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	if form.mmx {
+		if first.Reg != ins.Args[form.first].Reg {
+			return true, false, fmt.Errorf("%w: %s GP spelling encodes a separate MMX source bank", ErrProbeNeedsContext, op)
+		}
+		var a string
+		var err error
+		if form.memory < 0 {
+			a, err = c.loadReg(first.Reg)
+		} else {
+			a, err = c.loadPackedUnpackMMXSource(first, 8)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.emitPackedWordMultiplyAdd(4, c.bitcastI64ToIntegerLanes(4, 16, a), c.bitcastI64ToIntegerLanes(4, 16, b))
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i32> %s to i64\n", bits, result)
+		return true, false, c.storeReg(destination.Reg, "%"+bits)
+	}
+	b, err := c.loadPackedCompareLanes(second, form.byteWidth, form.spec.inputBits, false)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if form.legacy && form.memory >= 0 && first.Kind != OpFP {
+		result, err = c.emitMultiplyAddNativeMemory(first, b, form.spec)
+	} else {
+		// Intel SDM's E4NF.nb is non-fault-suppressing. A plain eager LLVM
+		// load can disappear under a constant zero mask, so use the reviewed
+		// complete volatile native reader, never logical masked loads.
+		a, loadErr := c.loadPackedUnpackSource(first, x86PackedUnpackForm{
+			x86PackedBinaryForm: form.x86PackedBinaryForm, spec: x86PackedUnpackSpec{laneBits: form.spec.inputBits},
+		})
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		if form.spec.inputBits == 8 {
+			result = c.emitPackedUnsignedSignedByteMultiplyAdd(form.byteWidth, a, b)
+		} else {
+			result = c.emitPackedWordMultiplyAdd(form.byteWidth/2, a, b)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	lanes := form.byteWidth * 8 / form.spec.outputBits
+	if form.mask >= 0 {
+		mask, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		old := "zeroinitializer"
+		if !form.zeroing {
+			old, err = c.loadPackedCompareLanes(destination, form.byteWidth, form.spec.outputBits, false)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		result = amd64ApplyIntegerLaneMask(c, lanes, form.spec.outputBits, result, old, mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <%d x i8>\n", out, lanes, form.spec.outputBits, result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(destination, "%"+out)
+	}
+	return true, false, c.storePackedMoveOperand(destination, form.byteWidth, "%"+out)
+}
+
+func (c *amd64Ctx) emitMultiplyAddNativeMemory(source Operand, data string, spec x86PackedPhysicalSpec) (string, error) {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	segment := ""
+	switch pointerType {
+	case "ptr addrspace(256)":
+		segment = "%gs:"
+	case "ptr addrspace(257)":
+		segment = "%fs:"
+	}
+	carrier, value := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <4 x i32>\n", carrier, 128/spec.inputBits, spec.inputBits, data)
+	fmt.Fprintf(c.b, "  %%%s = call <4 x i32> asm sideeffect %q, %q(<4 x i32> %%%s, %s %s)\n",
+		value, spec.nativeOpcode+" "+segment+"($2), $0", "=x,0,r,~{memory}", carrier, pointerType, pointer)
+	if spec.outputBits != 32 {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <%d x i%d>\n", result, value, 128/spec.outputBits, spec.outputBits)
+		return "%" + result, nil
+	}
+	return "%" + value, nil
+}
diff --git a/amd64_lower_wrapping_add.go b/amd64_lower_wrapping_add.go
new file mode 100644
index 000000000..46cd50a1e
--- /dev/null
+++ b/amd64_lower_wrapping_add.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerPackedIntegerAddForm(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86PackedArithmeticSpecForOp(Op(base), x86PackedArithmeticAdd); !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && strings.ToUpper(string(ins.Op)) != strings.ToUpper(string(op)) {
+		return true, false, fmt.Errorf("packed add dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64"
+	}
+	form, known, err := x86PackedIntegerAddProperties(ins, arch)
+	if err != nil || !known {
+		return known, false, err
+	}
+	first, second, destination := ins.Args[form.first], ins.Args[form.second], ins.Args[form.destination]
+	if form.legacy && !form.mmx && form.memory >= 0 {
+		virtual := first.Kind == OpFP
+		if first.Kind == OpMem && !x86CallerMemoryCertified(ins, form.memory) && !c.fixedLocalMemoryCertified(ins, form.memory) {
+			virtual = !c.nativeMemoryOperand(ins, form.first)
+		}
+		if virtual {
+			return true, false, fmt.Errorf("%w: legacy packed add m128 needs original native storage, not virtual FP/SP/BP alignment", ErrProbeNeedsContext)
+		}
+	}
+	if form.memory >= 0 && first.Kind == OpFP {
+		if err := c.validateFPVectorSpan(first.FPOffset, form.memoryBytes); err != nil {
+			return true, false, err
+		}
+	}
+	bits := form.spec.laneBits
+	lanes := form.byteWidth * 8 / bits
+	if form.mmx {
+		var a string
+		if first.Kind == OpReg {
+			a, err = c.loadReg(first.Reg)
+		} else {
+			a, err = c.loadPackedUnpackMMXSource(first, 8)
+		}
+		if err != nil {
+			return true, false, err
+		}
+		b, err := c.loadReg(second.Reg)
+		if err != nil {
+			return true, false, err
+		}
+		value := c.emitPackedIntegerAdd(lanes, bits, c.bitcastI64ToIntegerLanes(lanes, bits, a), c.bitcastI64ToIntegerLanes(lanes, bits, b), form.spec.mode)
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", out, lanes, bits, value)
+		return true, false, c.storeReg(destination.Reg, "%"+out)
+	}
+	mnemonic := ""
+	if form.legacy && form.memory >= 0 {
+		mnemonic = strings.ToLower(base)
+		if mnemonic == "paddl" {
+			mnemonic = "paddd"
+		}
+	}
+	err = c.emitPackedBinaryE4(ins, form.x86PackedBinaryForm, bits, mnemonic,
+		func(lanes, bits int, first, second string) string {
+			return c.emitPackedIntegerAdd(lanes, bits, first, second, form.spec.mode)
+		})
+	return true, false, err
+}
+
+// The caller supplies a registered legacy mnemonic. Keeping its memory form
+// native preserves alignment/fault effects which an unaligned vector load
+// followed by portable arithmetic would erase.
+func (c *amd64Ctx) emitPackedBinaryNativeMemory(source Operand, bits int, data, mnemonic string) (string, error) {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	carrier, result := c.newTmp(), c.newTmp()
+	// LLVM's i386 v4i32 inline-asm carrier requires SSE2. A bitcast-only
+	// v4f32 carrier also represents original SSE1 PS operations without
+	// strengthening their CPU requirements. No floating arithmetic occurs.
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <4 x float>\n", carrier, 128/bits, bits, data)
+	fmt.Fprintf(c.b, "  %%%s = call <4 x float> asm sideeffect %q, %q(<4 x float> %%%s, %s %s)\n", result, mnemonic+" "+segment+"($2), $0", "=x,0,r,~{memory}", carrier, pointerType, pointer)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x float> %%%s to <%d x i%d>\n", value, result, 128/bits, bits)
+	return "%" + value, nil
+}
diff --git a/amd64_lower_x87.go b/amd64_lower_x87.go
index 0ef86ec04..072f0ebca 100644
--- a/amd64_lower_x87.go
+++ b/amd64_lower_x87.go
@@ -1,12 +1,31 @@
 package plan9asm
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 func isX87Op(op Op) bool {
 	switch op {
-	case "FMOVD", "FMOVDP", "FMOVV", "FMOVVP", "FXCHD", "FADDDP",
-		"FDIVD", "FMULD", "FMULDP", "FSTCW", "FLDCW", "FRNDINT",
-		"FABS", "FUCOMI", "FTST", "FSTSW", "FLD1", "FSQRT":
+	case "FMOVB", "FMOVBP", "FMOVD", "FMOVDP", "FMOVF", "FMOVFP",
+		"FMOVL", "FMOVLP", "FMOVV", "FMOVVP", "FMOVW", "FMOVWP",
+		"FMOVX", "FMOVXP", "FBLD", "FBSTP", "FXCHD",
+		"FADDW", "FADDL", "FADDF", "FADDD", "FADDDP",
+		"FMULW", "FMULL", "FMULF", "FMULD", "FMULDP",
+		"FSUBW", "FSUBL", "FSUBF", "FSUBD", "FSUBDP",
+		"FSUBRW", "FSUBRL", "FSUBRF", "FSUBRD", "FSUBRDP",
+		"FDIVW", "FDIVL", "FDIVF", "FDIVD", "FDIVDP",
+		"FDIVRW", "FDIVRL", "FDIVRF", "FDIVRD", "FDIVRDP",
+		"FCOMD", "FCOMDP", "FCOMDPP", "FCOMF", "FCOMFP", "FCOMI", "FCOMIP",
+		"FCOML", "FCOMLP", "FCOMW", "FCOMWP",
+		"FUCOM", "FUCOMI", "FUCOMIP", "FUCOMP", "FUCOMPP",
+		"FCMOVCC", "FCMOVCS", "FCMOVEQ", "FCMOVHI", "FCMOVLS",
+		"FCMOVB", "FCMOVBE", "FCMOVNB", "FCMOVNBE", "FCMOVE", "FCMOVNE", "FCMOVNU", "FCMOVU", "FCMOVUN",
+		"FSTCW", "FLDCW", "FLDENV", "FRSTOR", "FSAVE", "FSTENV", "FRNDINT",
+		"F2XM1", "FABS", "FCHS", "FCLEX", "FCOS", "FDECSTP", "FINCSTP", "FINIT",
+		"FTST", "FSTSW", "FLD1", "FLDL2E", "FLDL2T", "FLDLG2", "FLDLN2",
+		"FLDPI", "FLDZ", "FNOP", "FPATAN", "FPREM", "FPREM1", "FPTAN", "FSCALE",
+		"FSIN", "FSINCOS", "FSQRT", "FXAM", "FXTRACT", "FYL2X", "FYL2XP1":
 		return true
 	default:
 		return false
@@ -17,137 +36,195 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 	if !isX87Op(op) {
 		return false, false, nil
 	}
-	if c.goarch != "386" {
-		return true, false, fmt.Errorf("amd64: x87 instruction %s requires GOARCH=386", op)
+	dispatch := ins
+	if dispatch.Op == "" {
+		dispatch.Op = op // Legacy direct-helper callers have no second source head.
+	} else if !strings.EqualFold(string(dispatch.Op), string(op)) {
+		return true, false, fmt.Errorf("%s x87 dispatch/source opcode differs: %q", c.goarch, ins.Raw)
+	}
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64" // Legacy private helpers have always used the default x86 mode.
+	}
+	if _, known, err := x86X87WordProperties(dispatch, arch); known && err != nil {
+		return true, false, err
+	}
+	if _, known, err := x86X87EnvironmentReadProperties(dispatch, arch); known && err != nil {
+		return true, false, err
+	}
+	valueForm, typedValue, formErr := x86X87ValueProperties(dispatch, arch)
+	if typedValue && formErr != nil {
+		return true, false, formErr
+	}
+	if typedValue && valueForm.spec.kind == x86X87IntegerMove {
+		return true, false, c.lowerX87IntegerMove(valueForm)
 	}
-
 	switch op {
-	case "FMOVD":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FMOVD expects src, dst: %q", ins.Raw)
+	case "FBLD":
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 FBLD expects memory source: %q", ins.Raw)
 		}
-		v, err := c.evalX87F64(ins.Args[0])
+		value, err := c.loadX87PackedBCD(ins.Args[0])
 		if err != nil {
 			return true, false, err
 		}
-		if idx, isF := x87OperandReg(ins.Args[1]); isF && idx == 0 && ins.Args[0].Kind != OpReg {
-			return true, false, c.pushX87(v)
-		}
-		return true, false, c.storeX87F64(ins.Args[1], v)
+		return true, false, c.pushX87(value)
 
-	case "FMOVDP":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FMOVDP expects src, dst: %q", ins.Raw)
-		}
-		v, err := c.evalX87F64(ins.Args[0])
-		if err != nil {
-			return true, false, err
+	case "FBSTP":
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 FBSTP expects memory destination: %q", ins.Raw)
 		}
-		if err := c.storeX87F64(ins.Args[1], v); err != nil {
+		if err := c.storeX87PackedBCD(ins.Args[0], c.loadX87(0)); err != nil {
 			return true, false, err
 		}
 		c.popX87()
 		return true, false, nil
 
-	case "FMOVV":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FMOVV expects src, dst: %q", ins.Raw)
+	case "FMOVB", "FMOVX":
+		if len(ins.Args) != 2 || !isX87MemoryOperand(ins.Args[0]) || !isX87F0(ins.Args[1]) {
+			return true, false, fmt.Errorf("386 %s expects memory source and F0 destination: %q", op, ins.Raw)
 		}
-		if idx, ok := x87OperandReg(ins.Args[1]); !ok || idx != 0 {
-			return true, false, fmt.Errorf("386 FMOVV expects F0 destination: %q", ins.Raw)
+		var value string
+		var err error
+		if op == "FMOVB" {
+			value, err = c.loadX87PackedBCD(ins.Args[0])
+		} else {
+			value, err = c.loadX87Extended(ins.Args[0])
 		}
-		v, err := c.evalIntSized(ins.Args[0], I64)
 		if err != nil {
 			return true, false, err
 		}
-		f := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sitofp i64 %s to double\n", f, v)
-		return true, false, c.pushX87("%" + f)
+		return true, false, c.pushX87(value)
 
-	case "FMOVVP":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FMOVVP expects src, dst: %q", ins.Raw)
+	case "FMOVBP", "FMOVXP":
+		if len(ins.Args) != 2 || !isX87F0(ins.Args[0]) || !isX87MemoryOperand(ins.Args[1]) {
+			return true, false, fmt.Errorf("386 %s expects F0 source and memory destination: %q", op, ins.Raw)
 		}
-		if index, ok := x87OperandReg(ins.Args[0]); !ok || index != 0 {
-			return true, false, fmt.Errorf("386 FMOVVP expects F0 source: %q", ins.Raw)
-		}
-		var iv string
-		if c.useHardwareX87() {
-			iv = c.convertX87ToI64Hardware()
+		var err error
+		if op == "FMOVBP" {
+			err = c.storeX87PackedBCD(ins.Args[1], c.loadX87(0))
 		} else {
-			rounded := c.roundX87Software(c.loadX87(0))
-			converted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = fptosi double %s to i64\n", converted, rounded)
-			iv = "%" + converted
+			err = c.storeX87Extended(ins.Args[1], c.loadX87(0))
 		}
-		if err := c.storeX87I64(ins.Args[1], iv); err != nil {
+		if err != nil {
 			return true, false, err
 		}
 		c.popX87()
 		return true, false, nil
 
-	case "FXCHD":
+	case "FMOVD":
 		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FXCHD expects Fsrc, Fdst: %q", ins.Raw)
+			return true, false, fmt.Errorf("386 FMOVD expects src, dst: %q", ins.Raw)
 		}
-		a, okA := x87OperandReg(ins.Args[0])
-		bv, okB := x87OperandReg(ins.Args[1])
-		if !okA || !okB {
-			return true, false, fmt.Errorf("386 FXCHD expects x87 registers: %q", ins.Raw)
+		srcReg, srcIsReg := x87OperandReg(ins.Args[0])
+		dstReg, dstIsReg := x87OperandReg(ins.Args[1])
+		valid := (isX87MemoryOperand(ins.Args[0]) || ins.Args[0].Kind == OpImm) && dstIsReg && dstReg == 0 ||
+			srcIsReg && srcReg == 0 && (isX87MemoryOperand(ins.Args[1]) || dstIsReg) ||
+			srcIsReg && dstIsReg && dstReg == 0
+		if !valid {
+			return true, false, fmt.Errorf("386 FMOVD expects memory,F0, Freg,F0, F0,memory, or F0,Freg: %q", ins.Raw)
 		}
-		av := c.loadX87(a)
-		b := c.loadX87(bv)
-		c.storeX87(a, b)
-		c.storeX87(bv, av)
-		return true, false, nil
-
-	case "FDIVD", "FMULD":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 %s expects src, dst: %q", op, ins.Raw)
+		if srcIsReg {
+			value := c.loadX87IntegerValue(srcReg)
+			if valueForm.push {
+				return true, false, c.pushX87IntegerValue(value)
+			}
+			if dstIsReg {
+				c.storeX87IntegerValue(dstReg, value)
+				return true, false, nil
+			}
 		}
-		src, err := c.evalX87F64(ins.Args[0])
+		v, err := c.loadX87FloatingMove(ins.Args[0], 64)
 		if err != nil {
 			return true, false, err
 		}
-		dst, err := c.evalX87F64(ins.Args[1])
+		if valueForm.push {
+			return true, false, c.pushX87(v)
+		}
+		return true, false, c.storeX87F64(ins.Args[1], v)
+
+	case "FMOVDP":
+		if len(ins.Args) != 2 || !isX87F0(ins.Args[0]) || !(isX87MemoryOperand(ins.Args[1]) || isX87RegisterOperand(ins.Args[1])) {
+			return true, false, fmt.Errorf("386 FMOVDP expects F0 source and memory or x87-register destination: %q", ins.Raw)
+		}
+		if index, register := x87OperandReg(ins.Args[1]); register {
+			value := c.loadX87IntegerValue(0)
+			c.storeX87IntegerValue(index, value)
+			c.popX87()
+			return true, false, nil
+		}
+		v, err := c.evalX87F64(ins.Args[0])
 		if err != nil {
 			return true, false, err
 		}
-		out := c.newTmp()
-		if op == "FDIVD" {
-			fmt.Fprintf(c.b, "  %%%s = fdiv double %s, %s\n", out, dst, src)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", out, dst, src)
+		if err := c.storeX87F64(ins.Args[1], v); err != nil {
+			return true, false, err
 		}
-		return true, false, c.storeX87F64(ins.Args[1], "%"+out)
+		c.popX87()
+		return true, false, nil
 
-	case "FADDDP", "FMULDP":
+	case "FMOVF":
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("386 %s expects src, dst: %q", op, ins.Raw)
 		}
-		src, err := c.evalX87F64(ins.Args[0])
-		if err != nil {
-			return true, false, err
+		if (isX87MemoryOperand(ins.Args[0]) || op == "FMOVF" && valueForm.push) && isX87F0(ins.Args[1]) {
+			value, err := c.loadX87MoveValue(op, ins.Args[0])
+			if err != nil {
+				return true, false, err
+			}
+			return true, false, c.pushX87(value)
 		}
-		dst, err := c.evalX87F64(ins.Args[1])
-		if err != nil {
-			return true, false, err
+		if isX87F0(ins.Args[0]) && isX87MemoryOperand(ins.Args[1]) {
+			return true, false, c.storeX87MoveValue(op, ins.Args[1], c.loadX87(0))
 		}
-		out := c.newTmp()
-		if op == "FADDDP" {
-			fmt.Fprintf(c.b, "  %%%s = fadd double %s, %s\n", out, dst, src)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", out, dst, src)
+		return true, false, fmt.Errorf("386 %s expects memory source and F0 destination, or F0 source and memory destination: %q", op, ins.Raw)
+
+	case "FMOVFP":
+		if len(ins.Args) != 2 || !isX87F0(ins.Args[0]) || !isX87MemoryOperand(ins.Args[1]) {
+			return true, false, fmt.Errorf("386 %s expects F0 source and memory destination: %q", op, ins.Raw)
 		}
-		if err := c.storeX87F64(ins.Args[1], "%"+out); err != nil {
+		baseOp := Op(strings.TrimSuffix(string(op), "P"))
+		if err := c.storeX87MoveValue(baseOp, ins.Args[1], c.loadX87(0)); err != nil {
 			return true, false, err
 		}
 		c.popX87()
 		return true, false, nil
 
+	case "FXCHD":
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("386 FXCHD expects Fsrc, Fdst: %q", ins.Raw)
+		}
+		a, okA := x87OperandReg(ins.Args[0])
+		bv, okB := x87OperandReg(ins.Args[1])
+		if !okA || !okB {
+			return true, false, fmt.Errorf("386 FXCHD expects x87 registers: %q", ins.Raw)
+		}
+		av := c.loadX87IntegerValue(a)
+		b := c.loadX87IntegerValue(bv)
+		c.storeX87IntegerValue(a, b)
+		c.storeX87IntegerValue(bv, av)
+		return true, false, nil
+
+	case "FADDW", "FADDL", "FADDF", "FADDD", "FADDDP",
+		"FMULW", "FMULL", "FMULF", "FMULD", "FMULDP",
+		"FSUBW", "FSUBL", "FSUBF", "FSUBD", "FSUBDP",
+		"FSUBRW", "FSUBRL", "FSUBRF", "FSUBRD", "FSUBRDP",
+		"FDIVW", "FDIVL", "FDIVF", "FDIVD", "FDIVDP",
+		"FDIVRW", "FDIVRL", "FDIVRF", "FDIVRD", "FDIVRDP":
+		return true, false, c.lowerX87Arithmetic(op, ins, valueForm)
+
+	case "FCOMD", "FCOMDP", "FCOMDPP", "FCOMF", "FCOMFP", "FCOMI", "FCOMIP",
+		"FCOML", "FCOMLP", "FCOMW", "FCOMWP",
+		"FUCOM", "FUCOMI", "FUCOMIP", "FUCOMP", "FUCOMPP":
+		return true, false, c.lowerX87Compare(op, ins, valueForm)
+
+	case "FCMOVCC", "FCMOVCS", "FCMOVEQ", "FCMOVHI", "FCMOVLS",
+		"FCMOVB", "FCMOVBE", "FCMOVNB", "FCMOVNBE", "FCMOVE", "FCMOVNE", "FCMOVNU", "FCMOVU", "FCMOVUN":
+		return true, false, c.lowerX87ConditionalMove(op, ins)
+
 	case "FSTCW":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("386 FSTCW expects dst: %q", ins.Raw)
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 FSTCW expects memory destination: %q", ins.Raw)
 		}
 		if c.useHardwareX87() {
 			c.storeHardwareX87ControlWord()
@@ -157,8 +234,8 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 		return true, false, c.storeX87I16(ins.Args[0], "%"+cw)
 
 	case "FLDCW":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("386 FLDCW expects src: %q", ins.Raw)
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 FLDCW expects memory source: %q", ins.Raw)
 		}
 		cw, err := c.evalIntSized(ins.Args[0], I16)
 		if err != nil {
@@ -170,6 +247,28 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 		}
 		return true, false, nil
 
+	case "FLDENV", "FRSTOR":
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 %s expects memory source: %q", op, ins.Raw)
+		}
+		return true, false, c.loadX87Environment(ins.Args[0])
+
+	case "FSAVE", "FSTENV":
+		if len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+			return true, false, fmt.Errorf("386 %s expects memory destination: %q", op, ins.Raw)
+		}
+		if err := c.storeX87Environment(ins.Args[0]); err != nil {
+			return true, false, err
+		}
+		if op == "FSAVE" {
+			for i := range c.x87Slot {
+				c.storeX87(i, "0.000000e+00")
+			}
+			fmt.Fprintf(c.b, "  store i16 895, ptr %s\n", c.x87ControlSlot)
+			fmt.Fprintf(c.b, "  store i16 0, ptr %s\n", c.x87StatusSlot)
+		}
+		return true, false, nil
+
 	case "FRNDINT":
 		if len(ins.Args) != 0 {
 			return true, false, fmt.Errorf("386 FRNDINT takes no operands: %q", ins.Raw)
@@ -178,7 +277,22 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 			c.roundX87Hardware(c.x87Slot[0])
 			return true, false, nil
 		}
-		return true, false, c.storeX87F64(Operand{Kind: OpReg, Reg: Reg("F0")}, c.roundX87Software(c.loadX87(0)))
+		value := c.loadX87IntegerValue(0)
+		value.floating = c.roundX87Software(value.floating)
+		c.storeX87IntegerValue(0, value)
+		return true, false, nil
+
+	case "F2XM1":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 F2XM1 takes no operands: %q", ins.Raw)
+		}
+		value := c.loadX87(0)
+		power := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.exp2.f64(double %s)\n", power, value)
+		fmt.Fprintf(c.b, "  %%%s = fsub double %%%s, 1.000000e+00\n", result, power)
+		c.storeX87(0, "%"+result)
+		return true, false, nil
 
 	case "FABS", "FSQRT":
 		if len(ins.Args) != 0 {
@@ -194,27 +308,177 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 		c.storeX87(0, "%"+out)
 		return true, false, nil
 
-	case "FUCOMI":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("386 FUCOMI expects lhs, rhs: %q", ins.Raw)
+	case "FCHS":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FCHS takes no operands: %q", ins.Raw)
 		}
-		lhs, err := c.evalX87F64(ins.Args[0])
-		if err != nil {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg double %s\n", result, c.loadX87(0))
+		c.storeX87(0, "%"+result)
+		return true, false, nil
+
+	case "FCLEX":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FCLEX takes no operands: %q", ins.Raw)
+		}
+		if c.useHardwareX87() {
+			fmt.Fprintln(c.b, `  call void asm sideeffect "fnclex", "~{fpsr}"()`)
+		}
+		status := c.newTmp()
+		conditionCodes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", status, c.x87StatusSlot)
+		fmt.Fprintf(c.b, "  %%%s = and i16 %%%s, 32512\n", conditionCodes, status) // Preserve TOP and C3,C2,C1,C0.
+		fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", conditionCodes, c.x87StatusSlot)
+		return true, false, nil
+
+	case "FCOS", "FSIN":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+		}
+		intrinsic := "llvm.cos.f64"
+		if op == "FSIN" {
+			intrinsic = "llvm.sin.f64"
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @%s(double %s)\n", result, intrinsic, c.loadX87(0))
+		c.storeX87(0, "%"+result)
+		c.clearX87C2()
+		return true, false, nil
+
+	case "FDECSTP", "FINCSTP":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+		}
+		c.rotateX87Stack(op == "FINCSTP")
+		return true, false, nil
+
+	case "FINIT":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FINIT takes no operands: %q", ins.Raw)
+		}
+		if c.useHardwareX87() {
+			fmt.Fprintln(c.b, `  call void asm sideeffect "fninit", "~{st},~{st(1)},~{st(2)},~{st(3)},~{st(4)},~{st(5)},~{st(6)},~{st(7)},~{fpsr}"()`)
+		}
+		for i := range c.x87Slot {
+			c.storeX87(i, "0.000000e+00")
+		}
+		fmt.Fprintf(c.b, "  store i16 895, ptr %s\n", c.x87ControlSlot)
+		fmt.Fprintf(c.b, "  store i16 0, ptr %s\n", c.x87StatusSlot)
+		return true, false, nil
+
+	case "FNOP":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FNOP takes no operands: %q", ins.Raw)
+		}
+		return true, false, nil
+
+	case "FPATAN":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FPATAN takes no operands: %q", ins.Raw)
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @atan2(double %s, double %s)\n", result, c.loadX87(1), c.loadX87(0))
+		c.storeX87(1, "%"+result)
+		c.popX87()
+		return true, false, nil
+
+	case "FPREM", "FPREM1":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+		}
+		function := "fmod"
+		if op == "FPREM1" {
+			function = "remainder"
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @%s(double %s, double %s)\n", result, function, c.loadX87(0), c.loadX87(1))
+		c.storeX87(0, "%"+result)
+		c.clearX87C2()
+		return true, false, nil
+
+	case "FPTAN":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FPTAN takes no operands: %q", ins.Raw)
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @tan(double %s)\n", result, c.loadX87(0))
+		c.storeX87(0, "%"+result)
+		if err := c.pushX87("1.000000e+00"); err != nil {
 			return true, false, err
 		}
-		rhs, err := c.evalX87F64(ins.Args[1])
-		if err != nil {
+		c.clearX87C2()
+		return true, false, nil
+
+	case "FSCALE":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FSCALE takes no operands: %q", ins.Raw)
+		}
+		exponent := c.newTmp()
+		scale := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.trunc.f64(double %s)\n", exponent, c.loadX87(1))
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.exp2.f64(double %%%s)\n", scale, exponent)
+		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %%%s\n", result, c.loadX87(0), scale)
+		c.storeX87(0, "%"+result)
+		return true, false, nil
+
+	case "FSINCOS":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FSINCOS takes no operands: %q", ins.Raw)
+		}
+		value := c.loadX87(0)
+		sine := c.newTmp()
+		cosine := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.sin.f64(double %s)\n", sine, value)
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.cos.f64(double %s)\n", cosine, value)
+		c.storeX87(0, "%"+sine)
+		if err := c.pushX87("%" + cosine); err != nil {
 			return true, false, err
 		}
-		z := c.newTmp()
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fcmp ueq double %s, %s\n", z, lhs, rhs)
-		fmt.Fprintf(c.b, "  %%%s = fcmp ult double %s, %s\n", cf, lhs, rhs)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", z, c.flagsZSlot)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCFSlot)
-		// FUCOMI clears both SF and OF. flagsSltSlot models SF xor OF for
-		// signed conditions, so those conditions must observe false here.
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsSltSlot)
+		c.clearX87C2()
+		return true, false, nil
+
+	case "FXAM":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FXAM takes no operands: %q", ins.Raw)
+		}
+		c.classifyX87F0()
+		return true, false, nil
+
+	case "FXTRACT":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 FXTRACT takes no operands: %q", ins.Raw)
+		}
+		value := c.loadX87(0)
+		abs := c.newTmp()
+		log := c.newTmp()
+		exponent := c.newTmp()
+		scale := c.newTmp()
+		significand := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.fabs.f64(double %s)\n", abs, value)
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.log2.f64(double %%%s)\n", log, abs)
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.floor.f64(double %%%s)\n", exponent, log)
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.exp2.f64(double %%%s)\n", scale, exponent)
+		fmt.Fprintf(c.b, "  %%%s = fdiv double %s, %%%s\n", significand, value, scale)
+		c.storeX87(0, "%"+significand)
+		return true, false, c.pushX87("%" + exponent)
+
+	case "FYL2X", "FYL2XP1":
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+		}
+		x := c.loadX87(0)
+		if op == "FYL2XP1" {
+			incremented := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = fadd double %s, 1.000000e+00\n", incremented, x)
+			x = "%" + incremented
+		}
+		log := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call double @llvm.log2.f64(double %s)\n", log, x)
+		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %%%s\n", result, c.loadX87(1), log)
+		c.storeX87(1, "%"+result)
+		c.popX87()
 		return true, false, nil
 
 	case "FTST":
@@ -246,22 +510,176 @@ func (c *amd64Ctx) lowerX87(op Op, ins Instr) (ok bool, terminated bool, err err
 		return true, false, nil
 
 	case "FSTSW":
-		if len(ins.Args) != 1 {
-			return true, false, fmt.Errorf("386 FSTSW expects dst: %q", ins.Raw)
+		if len(ins.Args) != 1 || !(isX87MemoryOperand(ins.Args[0]) || ins.Args[0].Kind == OpReg && ins.Args[0].Reg == AX) {
+			return true, false, fmt.Errorf("386 FSTSW expects memory destination or AX: %q", ins.Raw)
 		}
 		status := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", status, c.x87StatusSlot)
 		return true, false, c.storeX87I16(ins.Args[0], "%"+status)
 
-	case "FLD1":
+	case "FLD1", "FLDL2E", "FLDL2T", "FLDLG2", "FLDLN2", "FLDPI", "FLDZ":
 		if len(ins.Args) != 0 {
-			return true, false, fmt.Errorf("386 FLD1 takes no operands: %q", ins.Raw)
+			return true, false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+		}
+		constant := map[Op]string{
+			"FLD1":   "1.0000000000000000e+00",
+			"FLDL2E": "1.4426950408889634e+00",
+			"FLDL2T": "3.3219280948873623e+00",
+			"FLDLG2": "3.0102999566398120e-01",
+			"FLDLN2": "6.9314718055994531e-01",
+			"FLDPI":  "3.1415926535897931e+00",
+			"FLDZ":   "0.0000000000000000e+00",
 		}
-		return true, false, c.pushX87("1.000000e+00")
+		return true, false, c.pushX87(constant[op])
 	}
 	return false, false, nil
 }
 
+func (c *amd64Ctx) lowerX87Arithmetic(op Op, ins Instr, form x86X87ValueForm) error {
+	width := form.spec.width
+	var src string
+	var err error
+	switch width {
+	case 'W', 'L':
+		typ := I16
+		if width == 'L' {
+			typ = I32
+		}
+		integer, evalErr := c.evalIntSized(ins.Args[0], typ)
+		if evalErr != nil {
+			return evalErr
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sitofp %s %s to double\n", converted, typ, integer)
+		src = "%" + converted
+	case 'F':
+		value, evalErr := c.evalF32(ins.Args[0])
+		if evalErr != nil {
+			return evalErr
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fpext float %s to double\n", converted, value)
+		src = "%" + converted
+	case 'D':
+		src, err = c.evalX87F64(ins.Args[0])
+		if err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("386 %s has unknown x87 arithmetic width", op)
+	}
+	dst, err := c.evalX87F64(ins.Args[1])
+	if err != nil {
+		return err
+	}
+	lhs, rhs := dst, src
+	if form.spec.reverse {
+		lhs, rhs = src, dst
+	}
+	operation := ""
+	switch {
+	case form.spec.stem == "FADD":
+		operation = "fadd"
+	case form.spec.stem == "FMUL":
+		operation = "fmul"
+	case form.spec.stem == "FSUB" || form.spec.stem == "FSUBR":
+		operation = "fsub"
+	case form.spec.stem == "FDIV" || form.spec.stem == "FDIVR":
+		operation = "fdiv"
+	}
+	if operation == "" {
+		return fmt.Errorf("386 %s has unknown x87 arithmetic operation", op)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s double %s, %s\n", result, operation, lhs, rhs)
+	if err := c.storeX87F64(ins.Args[1], "%"+result); err != nil {
+		return err
+	}
+	if form.spec.pop != 0 {
+		c.popX87()
+	}
+	return nil
+}
+
+func (c *amd64Ctx) lowerX87Compare(op Op, ins Instr, form x86X87ValueForm) error {
+	lhs, err := c.evalX87F64(form.left)
+	if err != nil {
+		return err
+	}
+	var rhs string
+	switch form.spec.width {
+	case 'D':
+		rhs, err = c.evalX87F64(form.right)
+	case 'F':
+		var narrow string
+		narrow, err = c.evalF32(form.right)
+		if err == nil {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = fpext float %s to double\n", wide, narrow)
+			rhs = "%" + wide
+		}
+	case 'L', 'W':
+		typ := I16
+		if form.spec.width == 'L' {
+			typ = I32
+		}
+		var integer string
+		integer, err = c.evalIntSized(form.right, typ)
+		if err == nil {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sitofp %s %s to double\n", wide, typ, integer)
+			rhs = "%" + wide
+		}
+	default:
+		return fmt.Errorf("386 %s has unknown x87 compare width", op)
+	}
+	if err != nil {
+		return err
+	}
+	if form.spec.directFlags {
+		c.setX87CompareFlags(lhs, rhs)
+	} else {
+		c.setX87CompareStatus(lhs, rhs)
+	}
+	for i := uint8(0); i < form.spec.pop; i++ {
+		c.popX87()
+	}
+	return nil
+}
+
+func (c *amd64Ctx) x87CompareBits(lhs, rhs string) (equal, less, unordered string) {
+	equalTmp := c.newTmp()
+	lessTmp := c.newTmp()
+	unorderedTmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fcmp ueq double %s, %s\n", equalTmp, lhs, rhs)
+	fmt.Fprintf(c.b, "  %%%s = fcmp ult double %s, %s\n", lessTmp, lhs, rhs)
+	fmt.Fprintf(c.b, "  %%%s = fcmp uno double %s, %s\n", unorderedTmp, lhs, rhs)
+	return equalTmp, lessTmp, unorderedTmp
+}
+
+func (c *amd64Ctx) setX87CompareFlags(lhs, rhs string) {
+	equal, less, unordered := c.x87CompareBits(lhs, rhs)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", equal, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", less, c.flagsCFSlot)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", unordered, c.flagsPFSlot)
+	// FCOMI/FUCOMI clear OF, SF, and AF. flagsSltSlot is architectural SF.
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsSltSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsOFSlot)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsAFSlot)
+}
+
+func (c *amd64Ctx) setX87CompareStatus(lhs, rhs string) {
+	equal, less, unordered := c.x87CompareBits(lhs, rhs)
+	c3Word := c.x87StatusBit(equal, 16384)
+	c2Word := c.x87StatusBit(unordered, 1024)
+	c0Word := c.x87StatusBit(less, 256)
+	partial := c.newTmp()
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i16 %s, %s\n", partial, c3Word, c2Word)
+	fmt.Fprintf(c.b, "  %%%s = or i16 %%%s, %s\n", status, partial, c0Word)
+	fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", status, c.x87StatusSlot)
+}
+
 func x87OperandReg(op Operand) (int, bool) {
 	if op.Kind != OpReg {
 		return 0, false
@@ -269,6 +687,256 @@ func x87OperandReg(op Operand) (int, bool) {
 	return amd64ParseX87Reg(op.Reg)
 }
 
+func isX87RegisterOperand(op Operand) bool {
+	_, ok := x87OperandReg(op)
+	return ok
+}
+
+func isX87F0(op Operand) bool {
+	index, ok := x87OperandReg(op)
+	return ok && index == 0
+}
+
+func isX87MemoryOperand(op Operand) bool {
+	return isAMD64MemoryOperand(op)
+}
+
+func (c *amd64Ctx) loadX87MoveValue(op Op, src Operand) (string, error) {
+	switch op {
+	case "FMOVF":
+		value, err := c.loadX87FloatingMove(src, 32)
+		if err != nil {
+			return "", err
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fpext float %s to double\n", wide, value)
+		return "%" + wide, nil
+	case "FMOVL", "FMOVW":
+		typ := I32
+		if op == "FMOVW" {
+			typ = I16
+		}
+		value, err := c.evalIntSized(src, typ)
+		if err != nil {
+			return "", err
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sitofp %s %s to double\n", wide, typ, value)
+		return "%" + wide, nil
+	default:
+		return "", fmt.Errorf("386: unsupported x87 move load %s", op)
+	}
+}
+
+func (c *amd64Ctx) storeX87MoveValue(op Op, dst Operand, value string) error {
+	switch op {
+	case "FMOVF":
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fptrunc double %s to float\n", narrow, value)
+		return c.storeX87TypedMemory(dst, LLVMType("float"), "%"+narrow)
+	case "FMOVL", "FMOVW":
+		bits := 32
+		if op == "FMOVW" {
+			bits = 16
+		}
+		rounded := c.roundX87Software(value)
+		return c.storeX87TypedMemory(dst, amd64IntegerTypeForBits(bits), c.convertRoundedX87Integer(rounded, bits))
+	default:
+		return fmt.Errorf("386: unsupported x87 move store %s", op)
+	}
+}
+
+func (c *amd64Ctx) storeX87TypedMemory(dst Operand, typ LLVMType, value string) error {
+	if typ == LLVMType("float") || typ == LLVMType("double") {
+		if handled, err := c.storeX87NativeFloatingMove(dst, typ, value); handled {
+			return err
+		}
+	}
+	if dst.Kind == OpFP {
+		if typ == LLVMType("float") {
+			return c.storeScalarFPFloat(dst.FPOffset, 32, value)
+		}
+		return c.storeFPResult(dst.FPOffset, typ, value)
+	}
+	ptr, ptrType, err := c.x87MemoryPointer(dst)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  store %s %s, %s %s, align 1\n", typ, value, ptrType, ptr)
+	return nil
+}
+
+func (c *amd64Ctx) x87MemoryPointer(op Operand) (string, string, error) {
+	if !isX87MemoryOperand(op) {
+		return "", "", fmt.Errorf("386 x87 instruction expected memory, got %s", op.String())
+	}
+	ptr, ptrType, err := c.x86DescriptorMemoryPointer(op)
+	if err != nil {
+		return "", "", fmt.Errorf("386 x87 memory operand %s: %w", op.String(), err)
+	}
+	return ptr, ptrType, nil
+}
+
+func (c *amd64Ctx) loadX87Environment(src Operand) error {
+	ptr, ptrType, err := c.x87MemoryPointer(src)
+	if err != nil {
+		return err
+	}
+	// The 32-bit environment is one observable 28-byte read, including the
+	// fields that this software model does not interpret. Keep it exact and
+	// volatile even when both captured words are dead. An aggregate-width
+	// integer load avoids 28 separate IR accesses and preserves address space.
+	environment := c.newTmp()
+	control := c.newTmp()
+	statusBits := c.newTmp()
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile i224, %s %s, align 1\n", environment, ptrType, ptr)
+	fmt.Fprintf(c.b, "  %%%s = trunc i224 %%%s to i16\n", control, environment)
+	fmt.Fprintf(c.b, "  %%%s = lshr i224 %%%s, 32\n", statusBits, environment)
+	fmt.Fprintf(c.b, "  %%%s = trunc i224 %%%s to i16\n", status, statusBits)
+	fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", control, c.x87ControlSlot)
+	fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", status, c.x87StatusSlot)
+	if c.useHardwareX87() {
+		c.loadHardwareX87ControlWord()
+	}
+	return nil
+}
+
+func (c *amd64Ctx) storeX87Environment(dst Operand) error {
+	ptr, ptrType, err := c.x87MemoryPointer(dst)
+	if err != nil {
+		return err
+	}
+	if c.useHardwareX87() {
+		c.storeHardwareX87ControlWord()
+	}
+	control := c.newTmp()
+	status := c.newTmp()
+	statusPtr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", control, c.x87ControlSlot)
+	fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", status, c.x87StatusSlot)
+	fmt.Fprintf(c.b, "  store i16 %%%s, %s %s, align 1\n", control, ptrType, ptr)
+	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 4\n", statusPtr, ptrType, ptr)
+	fmt.Fprintf(c.b, "  store i16 %%%s, %s %%%s, align 1\n", status, ptrType, statusPtr)
+	return nil
+}
+
+func (c *amd64Ctx) loadX87Extended(src Operand) (string, error) {
+	ptr, ptrType, err := c.x87MemoryPointer(src)
+	if err != nil {
+		return "", err
+	}
+	extended := c.newTmp()
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load x86_fp80, %s %s, align 1\n", extended, ptrType, ptr)
+	fmt.Fprintf(c.b, "  %%%s = fptrunc x86_fp80 %%%s to double\n", value, extended)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeX87Extended(dst Operand, value string) error {
+	ptr, ptrType, err := c.x87MemoryPointer(dst)
+	if err != nil {
+		return err
+	}
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fpext double %s to x86_fp80\n", extended, value)
+	fmt.Fprintf(c.b, "  store x86_fp80 %%%s, %s %s, align 1\n", extended, ptrType, ptr)
+	return nil
+}
+
+func (c *amd64Ctx) loadX87PackedBCD(src Operand) (string, error) {
+	ptr, ptrType, err := c.x87MemoryPointer(src)
+	if err != nil {
+		return "", err
+	}
+	accumulator := "0"
+	for i := 8; i >= 0; i-- {
+		bytePtr := c.newTmp()
+		packed := c.newTmp()
+		low := c.newTmp()
+		highShifted := c.newTmp()
+		high := c.newTmp()
+		low64 := c.newTmp()
+		high64 := c.newTmp()
+		digit10 := c.newTmp()
+		digits := c.newTmp()
+		scaled := c.newTmp()
+		next := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %d\n", bytePtr, ptrType, ptr, i)
+		fmt.Fprintf(c.b, "  %%%s = load i8, %s %%%s, align 1\n", packed, ptrType, bytePtr)
+		fmt.Fprintf(c.b, "  %%%s = and i8 %%%s, 15\n", low, packed)
+		fmt.Fprintf(c.b, "  %%%s = lshr i8 %%%s, 4\n", highShifted, packed)
+		fmt.Fprintf(c.b, "  %%%s = and i8 %%%s, 15\n", high, highShifted)
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", low64, low)
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", high64, high)
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, 10\n", digit10, high64)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", digits, digit10, low64)
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, 100\n", scaled, accumulator)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", next, scaled, digits)
+		accumulator = "%" + next
+	}
+	signPtr := c.newTmp()
+	signByte := c.newTmp()
+	signBits := c.newTmp()
+	isNegative := c.newTmp()
+	negative := c.newTmp()
+	signed := c.newTmp()
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 9\n", signPtr, ptrType, ptr)
+	fmt.Fprintf(c.b, "  %%%s = load i8, %s %%%s, align 1\n", signByte, ptrType, signPtr)
+	fmt.Fprintf(c.b, "  %%%s = and i8 %%%s, -128\n", signBits, signByte)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %%%s, 0\n", isNegative, signBits)
+	fmt.Fprintf(c.b, "  %%%s = sub i64 0, %s\n", negative, accumulator)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %s\n", signed, isNegative, negative, accumulator)
+	fmt.Fprintf(c.b, "  %%%s = sitofp i64 %%%s to double\n", value, signed)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeX87PackedBCD(dst Operand, value string) error {
+	ptr, ptrType, err := c.x87MemoryPointer(dst)
+	if err != nil {
+		return err
+	}
+	rounded := c.roundX87Software(value)
+	integer := c.newTmp()
+	isNegative := c.newTmp()
+	negated := c.newTmp()
+	absolute := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fptosi double %s to i64\n", integer, rounded)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %%%s, 0\n", isNegative, integer)
+	fmt.Fprintf(c.b, "  %%%s = sub i64 0, %%%s\n", negated, integer)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %%%s\n", absolute, isNegative, negated, integer)
+	remaining := "%" + absolute
+	for i := 0; i < 9; i++ {
+		digits := c.newTmp()
+		tens := c.newTmp()
+		ones := c.newTmp()
+		tensByte := c.newTmp()
+		onesByte := c.newTmp()
+		shifted := c.newTmp()
+		packed := c.newTmp()
+		bytePtr := c.newTmp()
+		next := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = urem i64 %s, 100\n", digits, remaining)
+		fmt.Fprintf(c.b, "  %%%s = udiv i64 %%%s, 10\n", tens, digits)
+		fmt.Fprintf(c.b, "  %%%s = urem i64 %%%s, 10\n", ones, digits)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i8\n", tensByte, tens)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i8\n", onesByte, ones)
+		fmt.Fprintf(c.b, "  %%%s = shl i8 %%%s, 4\n", shifted, tensByte)
+		fmt.Fprintf(c.b, "  %%%s = or i8 %%%s, %%%s\n", packed, shifted, onesByte)
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %d\n", bytePtr, ptrType, ptr, i)
+		fmt.Fprintf(c.b, "  store i8 %%%s, %s %%%s, align 1\n", packed, ptrType, bytePtr)
+		fmt.Fprintf(c.b, "  %%%s = udiv i64 %s, 100\n", next, remaining)
+		remaining = "%" + next
+	}
+	sign := c.newTmp()
+	signPtr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i8 -128, i8 0\n", sign, isNegative)
+	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 9\n", signPtr, ptrType, ptr)
+	fmt.Fprintf(c.b, "  store i8 %%%s, %s %%%s, align 1\n", sign, ptrType, signPtr)
+	return nil
+}
+
 func (c *amd64Ctx) loadX87(index int) string {
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load double, ptr %s\n", t, c.x87Slot[index])
@@ -277,23 +945,89 @@ func (c *amd64Ctx) loadX87(index int) string {
 
 func (c *amd64Ctx) storeX87(index int, value string) {
 	fmt.Fprintf(c.b, "  store double %s, ptr %s\n", value, c.x87Slot[index])
+	if c.x87ExactSlot[index] != "" {
+		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.x87ExactSlot[index])
+	}
 }
 
 func (c *amd64Ctx) pushX87(value string) error {
-	for i := len(c.x87Slot) - 1; i > 0; i-- {
-		c.storeX87(i, c.loadX87(i-1))
-	}
-	c.storeX87(0, value)
-	return nil
+	return c.pushX87IntegerValue(x87IntegerValue{value, "0", "false"})
 }
 
 func (c *amd64Ctx) popX87() {
 	for i := 0; i < len(c.x87Slot)-1; i++ {
-		c.storeX87(i, c.loadX87(i+1))
+		c.storeX87IntegerValue(i, c.loadX87IntegerValue(i+1))
 	}
 	c.storeX87(len(c.x87Slot)-1, "0.000000e+00")
 }
 
+func (c *amd64Ctx) rotateX87Stack(increment bool) {
+	values := make([]x87IntegerValue, len(c.x87Slot))
+	for i := range values {
+		values[i] = c.loadX87IntegerValue(i)
+	}
+	if increment {
+		for i := range values {
+			c.storeX87IntegerValue(i, values[(i+1)%len(values)])
+		}
+		return
+	}
+	for i := range values {
+		c.storeX87IntegerValue(i, values[(i+len(values)-1)%len(values)])
+	}
+}
+
+func (c *amd64Ctx) clearX87C2() {
+	status := c.newTmp()
+	cleared := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", status, c.x87StatusSlot)
+	fmt.Fprintf(c.b, "  %%%s = and i16 %%%s, -1025\n", cleared, status)
+	fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", cleared, c.x87StatusSlot)
+}
+
+func (c *amd64Ctx) classifyX87F0() {
+	value := c.loadX87(0)
+	isNaN := c.newTmp()
+	isZero := c.newTmp()
+	abs := c.newTmp()
+	isInfinity := c.newTmp()
+	notNaN := c.newTmp()
+	notZero := c.newTmp()
+	c2 := c.newTmp()
+	c0 := c.newTmp()
+	bits := c.newTmp()
+	signBits := c.newTmp()
+	isNegative := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fcmp uno double %s, %s\n", isNaN, value, value)
+	fmt.Fprintf(c.b, "  %%%s = fcmp oeq double %s, 0.000000e+00\n", isZero, value)
+	fmt.Fprintf(c.b, "  %%%s = call double @llvm.fabs.f64(double %s)\n", abs, value)
+	fmt.Fprintf(c.b, "  %%%s = fcmp oeq double %%%s, 0x7FF0000000000000\n", isInfinity, abs)
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notNaN, isNaN)
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", notZero, isZero)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", c2, notNaN, notZero)
+	fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", c0, isNaN, isInfinity)
+	fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", bits, value)
+	fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, -9223372036854775808\n", signBits, bits)
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", isNegative, signBits)
+	c3Word := c.x87StatusBit(isZero, 16384)
+	c2Word := c.x87StatusBit(c2, 1024)
+	c1Word := c.x87StatusBit(isNegative, 512)
+	c0Word := c.x87StatusBit(c0, 256)
+	first := c.newTmp()
+	second := c.newTmp()
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i16 %s, %s\n", first, c3Word, c2Word)
+	fmt.Fprintf(c.b, "  %%%s = or i16 %%%s, %s\n", second, first, c1Word)
+	fmt.Fprintf(c.b, "  %%%s = or i16 %%%s, %s\n", status, second, c0Word)
+	fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", status, c.x87StatusSlot)
+}
+
+func (c *amd64Ctx) x87StatusBit(condition string, mask int) string {
+	word := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i16 %d, i16 0\n", word, condition, mask)
+	return "%" + word
+}
+
 func (c *amd64Ctx) evalX87F64(op Operand) (string, error) {
 	if index, ok := x87OperandReg(op); ok {
 		return c.loadX87(index), nil
@@ -302,13 +1036,16 @@ func (c *amd64Ctx) evalX87F64(op Operand) (string, error) {
 }
 
 func (c *amd64Ctx) storeX87F64(dst Operand, value string) error {
+	if handled, err := c.storeX87NativeFloatingMove(dst, LLVMType("double"), value); handled {
+		return err
+	}
 	if index, ok := x87OperandReg(dst); ok {
 		c.storeX87(index, value)
 		return nil
 	}
 	switch dst.Kind {
 	case OpFP:
-		return c.storeFPResult(dst.FPOffset, LLVMType("double"), value)
+		return c.storeScalarFPFloat(dst.FPOffset, 64, value)
 	case OpMem:
 		p, ptrType, err := c.ptrFromMem(dst.Mem)
 		if err != nil {
@@ -332,6 +1069,8 @@ func (c *amd64Ctx) storeX87I16(dst Operand, value string) error {
 	switch dst.Kind {
 	case OpReg:
 		return c.storeRegSized(dst.Reg, I16, value)
+	case OpFP:
+		return c.storeFPResult(dst.FPOffset, I16, value)
 	case OpMem:
 		p, ptrType, err := c.ptrFromMem(dst.Mem)
 		if err != nil {
@@ -387,7 +1126,12 @@ func (c *amd64Ctx) roundX87Hardware(slot string) {
 }
 
 func (c *amd64Ctx) convertX87ToI64Hardware() string {
-	fmt.Fprintf(c.b, "  call void asm sideeffect \"fldl $1; fistpll $0\", \"=*m,*m,~{dirflag},~{fpsr},~{flags}\"(ptr elementtype(i64) %s, ptr elementtype(double) %s)\n", c.x87IntegerSlot, c.x87Slot[0])
+	if c.x87ExactSlot[0] == "" {
+		fmt.Fprintf(c.b, "  call void asm sideeffect \"fldl $1; fistpll $0\", \"=*m,*m,~{dirflag},~{fpsr},~{flags}\"(ptr elementtype(i64) %s, ptr elementtype(double) %s)\n", c.x87IntegerSlot, c.x87Slot[0])
+	} else {
+		fmt.Fprintf(c.b, "  call void asm sideeffect \"cmpb $$0, $3; je 1f; fildll $2; jmp 2f; 1: fldl $1; 2: fistpll $0\", \"=*m,*m,*m,*m,~{dirflag},~{fpsr},~{flags}\"(ptr elementtype(i64) %s, ptr elementtype(double) %s, ptr elementtype(i64) %s, ptr elementtype(i1) %s)\n",
+			c.x87IntegerSlot, c.x87Slot[0], c.x87IntegerValueSlot[0], c.x87ExactSlot[0])
+	}
 	value := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", value, c.x87IntegerSlot)
 	return "%" + value
@@ -436,7 +1180,11 @@ func (c *amd64Ctx) roundNearestEvenX87(value, floor string) string {
 	floorInt := c.newTmp()
 	oddBits := c.newTmp()
 	odd := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = fptosi double %s to i64\n", floorInt, floor)
+	// Only values below 2^52 need a tie-parity calculation. Keep even the
+	// discarded large/NaN path free of an out-of-range fptosi operand.
+	parityInput := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, double 0.000000e+00, double %s\n", parityInput, large, floor)
+	fmt.Fprintf(c.b, "  %%%s = fptosi double %%%s to i64\n", floorInt, parityInput)
 	fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 1\n", oddBits, floorInt)
 	fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", odd, oddBits)
 	tieUp := c.newTmp()
diff --git a/amd64_lower_x87_conditional_move.go b/amd64_lower_x87_conditional_move.go
new file mode 100644
index 000000000..d0b76ee15
--- /dev/null
+++ b/amd64_lower_x87_conditional_move.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerX87ConditionalMove(op Op, ins Instr) error {
+	if len(ins.Args) != 2 {
+		return fmt.Errorf("%s %s expects one x87 source and F0 destination: %q", c.goarch, op, ins.Raw)
+	}
+	source, sourceOK := x87OperandReg(ins.Args[0])
+	destination, destinationOK := x87OperandReg(ins.Args[1])
+	if !sourceOK || !destinationOK || destination != 0 {
+		return fmt.Errorf("%s %s operands are outside Go 1.27's Yrf,F0 row: %q", c.goarch, op, ins.Raw)
+	}
+
+	cf := func() string { return c.loadFlag(c.flagsCFSlot) }
+	zf := func() string { return c.loadFlag(c.flagsZSlot) }
+	pf := func() string { return c.loadFlag(c.flagsPFSlot) }
+	not := func(value string) string {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", inverted, value)
+		return "%" + inverted
+	}
+	combine := func(instruction, left, right string) string {
+		condition := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i1 %s, %s\n", condition, instruction, left, right)
+		return "%" + condition
+	}
+
+	condition := ""
+	switch op {
+	case "FCMOVB", "FCMOVCS":
+		condition = cf()
+	case "FCMOVBE", "FCMOVLS":
+		condition = combine("or", cf(), zf())
+	case "FCMOVE", "FCMOVEQ":
+		condition = zf()
+	case "FCMOVNB", "FCMOVCC":
+		condition = not(cf())
+	case "FCMOVNBE", "FCMOVHI":
+		condition = combine("and", not(cf()), not(zf()))
+	case "FCMOVNE":
+		condition = not(zf())
+	case "FCMOVNU":
+		condition = not(pf())
+	case "FCMOVU", "FCMOVUN":
+		condition = pf()
+	default:
+		return fmt.Errorf("unsupported x87 conditional move %s", op)
+	}
+	sourceValue := c.loadX87IntegerValue(source)
+	destinationValue := c.loadX87IntegerValue(0)
+	selected := c.newTmp()
+	integer, exact := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, double %s, double %s\n", selected, condition, sourceValue.floating, destinationValue.floating)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", integer, condition, sourceValue.integer, destinationValue.integer)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i1 %s, i1 %s\n", exact, condition, sourceValue.exact, destinationValue.exact)
+	c.storeX87IntegerValue(0, x87IntegerValue{"%" + selected, "%" + integer, "%" + exact})
+	return nil
+}
diff --git a/amd64_lower_x87_conditional_move_test.go b/amd64_lower_x87_conditional_move_test.go
new file mode 100644
index 000000000..1aca8ba98
--- /dev/null
+++ b/amd64_lower_x87_conditional_move_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x87ConditionalMoveGo127Ops = []string{
+	"FCMOVCC", "FCMOVCS", "FCMOVEQ", "FCMOVHI", "FCMOVLS",
+	"FCMOVB", "FCMOVBE", "FCMOVNB", "FCMOVNBE", "FCMOVE",
+	"FCMOVNE", "FCMOVNU", "FCMOVU", "FCMOVUN",
+}
+
+func x86X87ConditionalMoveCompleteFormsSource() string {
+	var source strings.Builder
+	source.WriteString("TEXT x87conditionalmoveforms(SB),$0-0\n")
+	for _, op := range x87ConditionalMoveGo127Ops {
+		source.WriteString("\t" + op + " F0, F0\n")
+		source.WriteString("\t" + op + " F7, F0\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86X87ConditionalMoveCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86X87ConditionalMoveCompleteFormsSource()
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"x87conditionalmoveforms": {Name: "x87conditionalmoveforms", Ret: Void}},
+			}
+			if ir, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatal("original complete Go format fixture borrowed undefined F0/F7 or FLAGS", err)
+			}
+			// Retain every original conditional form, but supply actual source
+			// values and predicate bits in a separately labeled counterpart.
+			const header = "TEXT x87conditionalmoveforms(SB),$0-0\n"
+			initialized := strings.Replace(source, header, header+"FINIT\n"+strings.Repeat("FLD1\n", 8)+
+				"MOVL $0,AX\nCMPL AX,AX\n", 1)
+			initialized = strings.Replace(initialized, "\tRET\n", "FINIT\n\tRET\n", 1)
+			if strings.Count(source, header) != 1 || strings.Count(initialized, "FLD1\n") != 8 {
+				t.Fatal("initialized counterpart lost its complete original source anchor")
+			}
+			file, err = Parse(ArchAMD64, initialized)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"select i1", "or i1", "and i1", "xor i1"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("x87 conditional-move lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "x87-conditional-move-"+target.name+".ll", "x87-conditional-move-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestTranslateX86X87ConditionalMoveRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"FCMOVB 0(AX), F0",
+		"FCMOVBE F8, F0",
+		"FCMOVE F1, F2",
+		"FCMOVNB F1",
+		"FCMOVNBE F1, F0, F2",
+		"FCMOVU.Z F1, F0",
+	} {
+		for _, goarch := range []string{"amd64", "386"} {
+			t.Run(goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(instruction), func(t *testing.T) {
+				source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireX86GoAssemblerResult(t, goarch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if goarch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{
+					Goarch:       goarch,
+					TargetTriple: triple,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("Translate accepted %q outside Go 1.27's yfcmv table", instruction)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64X87ConditionalMoveRuntimeConditions(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT x87conditionalmovesemantics(SB),NOSPLIT,$0-8
+	MOVQ data+0(FP), DI
+
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	STC
+	FCMOVB F1, F0
+	FMOVDP F0, 0(DI)
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	STC
+	FCMOVNB F1, F0
+	FMOVDP F0, 8(DI)
+
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVE F1, F0
+	FMOVDP F0, 16(DI)
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVNE F1, F0
+	FMOVDP F0, 24(DI)
+
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVBE F1, F0
+	FMOVDP F0, 32(DI)
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVNBE F1, F0
+	FMOVDP F0, 40(DI)
+
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVU F1, F0
+	FMOVDP F0, 48(DI)
+	FINIT
+	FMOVD 64(DI), F0
+	FMOVD 72(DI), F0
+	XORL AX, AX
+	FCMOVNU F1, F0
+	FMOVDP F0, 56(DI)
+	RET
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	if ir, err := x86X87InitializedWordAPI(t, source, "func x87conditionalmovesemantics(data *byte)",
+		"amd64", triple, "text", X87Auto); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatal("original pointer fixture acquired an unproved native region", err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void x87conditionalmovesemantics(uint8_t *);
+int main(void) {
+  double data[10] = {0};
+  data[8] = 1.25;
+  data[9] = 9.5;
+  x87conditionalmovesemantics((uint8_t *)data);
+  const double expected[8] = {1.25, 9.5, 1.25, 9.5, 1.25, 9.5, 1.25, 9.5};
+  for (int i = 0; i < 8; ++i) if (data[i] != expected[i]) return 10+i;
+  return 0;
+}
+`
+	// The original C checks remain unchanged. A separate typed-scalar source
+	// returns values; C owns the output array instead of granting native stores
+	// from a pointer declaration or a translator-private scratch allocation.
+	assembly, declaration := x86X87ConditionalScalarCounterpart()
+	ir, err := x86X87InitializedWordAPI(t, assembly, declaration, "amd64", triple, "text", X87Auto)
+	if err != nil || ir == "" {
+		t.Fatal("typed conditional counterpart did not reach native execution", err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "x87_conditional_move_semantics", triple, ir,
+		x86X87ConditionalScalarC(mainC), runPrefix)
+}
diff --git a/amd64_lower_xadd_test.go b/amd64_lower_xadd_test.go
new file mode 100644
index 000000000..33fbba680
--- /dev/null
+++ b/amd64_lower_xadd_test.go
@@ -0,0 +1,301 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86XADDCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+		source string
+	}{
+		{
+			name:   "darwin-amd64",
+			goarch: "amd64",
+			triple: "x86_64-apple-darwin",
+			source: `
+DATA xadddata+0(SB)/8, $0
+GLOBL xadddata(SB), $8
+TEXT xaddforms(SB),$0-0
+	XADDB AH, BL
+	XADDB R11, R12
+	XADDB DL, 8(BX)
+	XADDB R11, xadddata(SB)
+	XADDW DX, BX
+	XADDW R11, R12
+	XADDW DX, 8(BX)
+	XADDW R11, xadddata(SB)
+	XADDL DX, BX
+	XADDL R11, R12
+	XADDL DX, 8(BX)
+	XADDL R11, xadddata(SB)
+	XADDQ DX, BX
+	XADDQ R11, R12
+	XADDQ DX, 8(BX)
+	XADDQ R11, xadddata(SB)
+	RET
+`,
+		},
+		{
+			name:   "linux-amd64",
+			goarch: "amd64",
+			triple: "x86_64-unknown-linux-gnu",
+			source: `
+DATA xadddata+0(SB)/8, $0
+GLOBL xadddata(SB), $8
+TEXT xaddforms(SB),$0-0
+	XADDB AH, BL
+	XADDB R11, R12
+	XADDB DL, 8(BX)
+	XADDB R11, xadddata(SB)
+	XADDW DX, BX
+	XADDW R11, R12
+	XADDW DX, 8(BX)
+	XADDW R11, xadddata(SB)
+	XADDL DX, BX
+	XADDL R11, R12
+	XADDL DX, 8(BX)
+	XADDL R11, xadddata(SB)
+	XADDQ DX, BX
+	XADDQ R11, R12
+	XADDQ DX, 8(BX)
+	XADDQ R11, xadddata(SB)
+	RET
+`,
+		},
+		{
+			name:   "windows-amd64",
+			goarch: "amd64",
+			triple: "x86_64-pc-windows-msvc",
+			source: `
+DATA xadddata+0(SB)/8, $0
+GLOBL xadddata(SB), $8
+TEXT xaddforms(SB),$0-0
+	XADDB AH, BL
+	XADDB R11, R12
+	XADDB DL, 8(BX)
+	XADDB R11, xadddata(SB)
+	XADDW DX, BX
+	XADDW R11, R12
+	XADDW DX, 8(BX)
+	XADDW R11, xadddata(SB)
+	XADDL DX, BX
+	XADDL R11, R12
+	XADDL DX, 8(BX)
+	XADDL R11, xadddata(SB)
+	XADDQ DX, BX
+	XADDQ R11, R12
+	XADDQ DX, 8(BX)
+	XADDQ R11, xadddata(SB)
+	RET
+`,
+		},
+		{
+			name:   "linux-386",
+			goarch: "386",
+			triple: "i386-unknown-linux-gnu",
+			source: `
+DATA xadddata386+0(SB)/4, $0
+GLOBL xadddata386(SB), $4
+TEXT xaddforms(SB),$0-0
+	XADDB AH, BL
+	XADDB BP, DI
+	XADDB DL, 8(BX)
+	XADDB SI, xadddata386(SB)
+	XADDW DX, BX
+	XADDW SI, DI
+	XADDW DX, 8(BX)
+	XADDW SI, xadddata386(SB)
+	XADDL DX, BX
+	XADDL SI, DI
+	XADDL DX, 8(BX)
+	XADDL SI, xadddata386(SB)
+	RET
+`,
+		},
+		{
+			name:   "windows-386",
+			goarch: "386",
+			triple: "i686-pc-windows-msvc",
+			source: `
+DATA xadddata386+0(SB)/4, $0
+GLOBL xadddata386(SB), $4
+TEXT xaddforms(SB),$0-0
+	XADDB AH, BL
+	XADDB BP, DI
+	XADDB DL, 8(BX)
+	XADDB SI, xadddata386(SB)
+	XADDW DX, BX
+	XADDW SI, DI
+	XADDW DX, 8(BX)
+	XADDW SI, xadddata386(SB)
+	XADDL DX, BX
+	XADDL SI, DI
+	XADDL DX, 8(BX)
+	XADDL SI, xadddata386(SB)
+	RET
+`,
+		},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, target.source, true)
+			file, err := Parse(ArchAMD64, target.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures := map[string]FuncSig{"xaddforms": {Name: "xaddforms", Ret: Void}}
+			ll, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         signatures,
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original uninitialized exchange formats acquired source inputs", err)
+			}
+			ll = x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			for _, want := range []string{"add i8", "add i16", "add i32", "store i1"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("XADD lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ll, "add i64") {
+				t.Fatalf("XADDQ lowering omitted add i64:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "xadd-"+target.name+".ll", "xadd-"+target.name+".o", ll)
+			fixture := x86InitializedExchangeFixture(t, target.source, file, target.goarch, "xaddforms")
+			x86OriginalGPInitializedFormatObjects(t, []x86OriginalGPInitializedFormat{fixture}, target.goarch, target.triple)
+		})
+	}
+}
+
+func TestTranslateX86XADDRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "XADDB (BX), DL"},
+		{goarch: "amd64", instruction: "XADDW $1, DX"},
+		{goarch: "amd64", instruction: "XADDL X0, DX"},
+		{goarch: "amd64", instruction: "XADDQ DX, $1"},
+		{goarch: "amd64", instruction: "XADDQ DX"},
+		{goarch: "amd64", instruction: "XADDL DX, BX, AX"},
+		{goarch: "amd64", instruction: "XADDL.Z DX, BX"},
+		{goarch: "386", instruction: "XADDB SP, (BX)"},
+		{goarch: "386", instruction: "XADDL R8, (BX)"},
+		{goarch: "386", instruction: "XADDL DX, 1(R8)"},
+		{goarch: "386", instruction: "XADDQ DX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's XADD optab", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64XADDRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT xaddsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $5, AX
+	MOVQ $7, BX
+	XADDQ AX, BX
+	MOVQ AX, 0(DI)
+	MOVQ BX, 8(DI)
+	MOVB $0xff, 16(DI)
+	MOVB $1, CL
+	XADDB CL, 16(DI)
+	MOVB CL, 17(DI)
+	SETCS 18(DI)
+	SETEQ 19(DI)
+	SETPS 20(DI)
+	SETMI 21(DI)
+	SETOS 22(DI)
+	MOVQ $0x1122, AX
+	XADDB AH, AL
+	MOVQ AX, 24(DI)
+	MOVQ $0x1122334455660001, AX
+	MOVQ $0x887766554433ffff, BX
+	XADDW AX, BX
+	MOVQ AX, 32(DI)
+	MOVQ BX, 40(DI)
+	MOVQ $3, AX
+	XADDQ AX, AX
+	MOVQ AX, 48(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"xaddsemantics": {
+				Name:  "xaddsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void xaddsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[56] = {0};
+  xaddsemantics(out);
+  if (*(uint64_t *)(out+0) != 7 || *(uint64_t *)(out+8) != 12) return 10;
+  if (out[16] != 0 || out[17] != 0xff) return 11;
+  if (out[18] != 1 || out[19] != 1 || out[20] != 1) return 12;
+  if (out[21] != 0 || out[22] != 0) return 13;
+  if (*(uint64_t *)(out+24) != 0x2233) return 14;
+  if (*(uint64_t *)(out+32) != UINT64_C(0x112233445566ffff)) return 15;
+  if (*(uint64_t *)(out+40) != UINT64_C(0x8877665544330000)) return 16;
+  if (*(uint64_t *)(out+48) != 6) return 17;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "xadd_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_xchg_test.go b/amd64_lower_xchg_test.go
new file mode 100644
index 000000000..b745b36b0
--- /dev/null
+++ b/amd64_lower_xchg_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86XCHGCompleteFormsSource(goarch string) string {
+	var source strings.Builder
+	symbol := "xchgdata"
+	size := 8
+	if goarch == "386" {
+		symbol = "xchgdata386"
+		size = 4
+	}
+	fmt.Fprintf(&source, "DATA %s+0(SB)/%d, $0\n", symbol, size)
+	fmt.Fprintf(&source, "GLOBL %s(SB), $%d\n", symbol, size)
+	source.WriteString("TEXT xchgforms(SB),$0-0\n")
+	if goarch == "amd64" {
+		source.WriteString("\tXCHGB AH, BL\n\tXCHGB R11, R12\n")
+	} else {
+		source.WriteString("\tXCHGB AH, BL\n\tXCHGB BP, DI\n")
+	}
+	source.WriteString("\tXCHGB DL, 8(BX)\n\tXCHGB 8(BX), DL\n")
+	if goarch == "amd64" {
+		source.WriteString("\tXCHGB R11, " + symbol + "(SB)\n\tXCHGB " + symbol + "(SB), R11\n")
+	} else {
+		source.WriteString("\tXCHGB SI, " + symbol + "(SB)\n\tXCHGB " + symbol + "(SB), SI\n")
+	}
+	widths := []string{"W", "L"}
+	if goarch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	for _, width := range widths {
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\tXCHG%s DX, BX\n\tXCHG%s R11, R12\n", width, width)
+		} else {
+			fmt.Fprintf(&source, "\tXCHG%s DX, BX\n\tXCHG%s SI, DI\n", width, width)
+		}
+		fmt.Fprintf(&source, "\tXCHG%s DX, 8(BX)\n\tXCHG%s 8(BX), DX\n", width, width)
+		if goarch == "amd64" {
+			fmt.Fprintf(&source, "\tXCHG%s R11, %s(SB)\n\tXCHG%s %s(SB), R11\n", width, symbol, width, symbol)
+		} else {
+			fmt.Fprintf(&source, "\tXCHG%s SI, %s(SB)\n\tXCHG%s %s(SB), SI\n", width, symbol, width, symbol)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86XCHGCompleteGo127FormsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86XCHGCompleteFormsSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures := map[string]FuncSig{"xchgforms": {Name: "xchgforms", Ret: Void}}
+			ll, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         signatures,
+			})
+			if ll != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original uninitialized exchange formats acquired source inputs", err)
+			}
+			ll = x86ScalarFormatObjectUnit(t, file, signatures, target.goarch, target.triple, 0)
+			for _, want := range []string{"asm sideeffect \"xchg", "i8", "i16", "i32"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("XCHG lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			if target.goarch == "amd64" && !strings.Contains(ll, "i64") {
+				t.Fatalf("XCHGQ lowering omitted i64 operations:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target.triple, "xchg-"+target.name+".ll", "xchg-"+target.name+".o", ll)
+			fixture := x86InitializedExchangeFixture(t, source, file, target.goarch, "xchgforms")
+			x86OriginalGPInitializedFormatObjects(t, []x86OriginalGPInitializedFormat{fixture}, target.goarch, target.triple)
+		})
+	}
+}
+
+func TestTranslateX86XCHGRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, test := range []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "XCHGB X0, DL"},
+		{goarch: "amd64", instruction: "XCHGW $1, DX"},
+		{goarch: "amd64", instruction: "XCHGL 0(BX), 8(CX)"},
+		{goarch: "amd64", instruction: "XCHGQ DX, X0"},
+		{goarch: "amd64", instruction: "XCHGW DX"},
+		{goarch: "amd64", instruction: "XCHGL DX, BX, AX"},
+		{goarch: "amd64", instruction: "XCHGL.Z DX, BX"},
+		{goarch: "386", instruction: "XCHGB SP, (BX)"},
+		{goarch: "386", instruction: "XCHGL R8, (BX)"},
+		{goarch: "386", instruction: "XCHGL 1(R8), DX"},
+		{goarch: "386", instruction: "XCHGQ DX, BX"},
+	} {
+		t.Run(test.goarch+"/"+strings.NewReplacer(" ", "_", ",", "").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: triple,
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's XCHG optab", test.instruction)
+			}
+		})
+	}
+}
+
+func TestAMD64XCHGRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT xchgsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0x1122, AX
+	MOVQ $0x3344, BX
+	XCHGB AH, BL
+	MOVQ AX, 0(DI)
+	MOVQ BX, 8(DI)
+	MOVQ $0x1122334455667788, AX
+	MOVQ $0x887766554433aabb, BX
+	XCHGW AX, BX
+	MOVQ AX, 16(DI)
+	MOVQ BX, 24(DI)
+	MOVQ $0x1122334455667788, AX
+	MOVQ $0x88776655aabbccdd, BX
+	XCHGL AX, BX
+	MOVQ AX, 32(DI)
+	MOVQ BX, 40(DI)
+	MOVQ $5, AX
+	MOVQ $7, BX
+	XCHGQ AX, BX
+	MOVQ AX, 48(DI)
+	MOVQ BX, 56(DI)
+	MOVB $0x5a, 64(DI)
+	MOVQ $0x11223344556677c3, AX
+	CMPQ AX, AX
+	STC
+	XCHGB 64(DI), AL
+	MOVQ AX, 72(DI)
+	SETCS 80(DI)
+	SETEQ 81(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"xchgsemantics": {
+				Name:  "xchgsemantics",
+				Args:  []LLVMType{Ptr},
+				Ret:   Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void xchgsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[88] = {0};
+  xchgsemantics(out);
+  if (*(uint64_t *)(out+0) != UINT64_C(0x4422)) return 10;
+  if (*(uint64_t *)(out+8) != UINT64_C(0x3311)) return 11;
+  if (*(uint64_t *)(out+16) != UINT64_C(0x112233445566aabb)) return 12;
+  if (*(uint64_t *)(out+24) != UINT64_C(0x8877665544337788)) return 13;
+  if (*(uint64_t *)(out+32) != UINT64_C(0xaabbccdd)) return 14;
+  if (*(uint64_t *)(out+40) != UINT64_C(0x55667788)) return 15;
+  if (*(uint64_t *)(out+48) != 7 || *(uint64_t *)(out+56) != 5) return 16;
+  if (out[64] != 0xc3 || *(uint64_t *)(out+72) != UINT64_C(0x112233445566775a)) return 17;
+  if (out[80] != 1 || out[81] != 1) return 18;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "xchg_semantics", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_lower_xlat.go b/amd64_lower_xlat.go
new file mode 100644
index 000000000..c93291352
--- /dev/null
+++ b/amd64_lower_xlat.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) lowerXLAT(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	known, err := x86XLATProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	addressType := I64
+	if c.goarch == "386" {
+		addressType = I32
+	}
+	base, err := c.evalIntSized(Operand{Kind: OpReg, Reg: BX}, addressType)
+	if err != nil {
+		return true, false, err
+	}
+	index, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AL}, I8)
+	if err != nil {
+		return true, false, err
+	}
+	wideIndex, address := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i8 %s to %s\n", wideIndex, index, addressType)
+	fmt.Fprintf(c.b, "  %%%s = add %s %s, %%%s\n", address, addressType, base, wideIndex)
+	addressValue := "%" + address
+	if addressType == I32 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, addressValue)
+		addressValue = "%" + wide
+	}
+	pointer := c.ptrFromAddrI64(addressValue)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile i8, ptr %s, align 1\n", value, pointer)
+	return true, false, c.storeRegSized(AL, I8, "%"+value)
+}
diff --git a/amd64_lower_xstate.go b/amd64_lower_xstate.go
new file mode 100644
index 000000000..da007ebbf
--- /dev/null
+++ b/amd64_lower_xstate.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64XStateFamily uint8
+
+const (
+	amd64XStateFX amd64XStateFamily = iota
+	amd64XStateXSAVE
+	amd64XStateXSAVEOPT
+	amd64XStateXSAVEC
+	amd64XStateXSAVES
+	amd64XStateXRSTOR
+	amd64XStateXRSTORS
+)
+
+type amd64XStateDirection uint8
+
+const (
+	amd64XStateSave amd64XStateDirection = iota
+	amd64XStateRestore
+)
+
+type amd64XStateSpec struct {
+	family       amd64XStateFamily
+	direction    amd64XStateDirection
+	mode64       bool
+	implicitMask bool
+	memoryBytes  int
+}
+
+// amd64XStateSpecs is the complete Go 1.27 extended-state memory grammar.
+// Opcode spelling selects only the state family, transfer direction, and
+// encoding mode; one parser owns the shared Ym memory operand rule.
+var amd64XStateSpecs = map[Op]amd64XStateSpec{
+	"FXSAVE":     {family: amd64XStateFX, direction: amd64XStateSave, memoryBytes: 512},
+	"FXSAVE64":   {family: amd64XStateFX, direction: amd64XStateSave, mode64: true, memoryBytes: 512},
+	"FXRSTOR":    {family: amd64XStateFX, direction: amd64XStateRestore, memoryBytes: 512},
+	"FXRSTOR64":  {family: amd64XStateFX, direction: amd64XStateRestore, mode64: true, memoryBytes: 512},
+	"XSAVE":      {family: amd64XStateXSAVE, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+	"XSAVE64":    {family: amd64XStateXSAVE, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+	"XSAVEOPT":   {family: amd64XStateXSAVEOPT, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+	"XSAVEOPT64": {family: amd64XStateXSAVEOPT, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+	"XSAVEC":     {family: amd64XStateXSAVEC, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+	"XSAVEC64":   {family: amd64XStateXSAVEC, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+	"XSAVES":     {family: amd64XStateXSAVES, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+	"XSAVES64":   {family: amd64XStateXSAVES, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+	"XRSTOR":     {family: amd64XStateXRSTOR, direction: amd64XStateRestore, implicitMask: true, memoryBytes: 1},
+	"XRSTOR64":   {family: amd64XStateXRSTOR, direction: amd64XStateRestore, mode64: true, implicitMask: true, memoryBytes: 1},
+	"XRSTORS":    {family: amd64XStateXRSTORS, direction: amd64XStateRestore, implicitMask: true, memoryBytes: 1},
+	"XRSTORS64":  {family: amd64XStateXRSTORS, direction: amd64XStateRestore, mode64: true, implicitMask: true, memoryBytes: 1},
+}
+
+type amd64XStateForm struct {
+	memory Operand
+}
+
+func (c *amd64Ctx) lowerXState(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(rawOp, '.'); dot >= 0 {
+		baseOp = rawOp[:dot]
+	}
+	spec, recognized := amd64XStateSpecs[Op(baseOp)]
+	if !recognized {
+		return false, false, nil
+	}
+	if rawOp != baseOp {
+		return true, false, fmt.Errorf("%s %s does not accept instruction suffixes: %q", c.goarch, baseOp, ins.Raw)
+	}
+	if c.goarch == "386" && spec.mode64 {
+		return true, false, fmt.Errorf("386 %s is absent from Go 1.27's 32-bit encoding table: %q", baseOp, ins.Raw)
+	}
+	form, err := c.parseXStateForm(baseOp, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitXState(spec, form)
+}
+
+func (c *amd64Ctx) parseXStateForm(op string, ins Instr) (amd64XStateForm, error) {
+	var form amd64XStateForm
+	if len(ins.Args) != 1 {
+		return form, fmt.Errorf("%s %s expects one Go 1.27 Ym memory operand: %q", c.goarch, op, ins.Raw)
+	}
+	memory := ins.Args[0]
+	if !isAMD64MemoryOperand(memory) {
+		return form, fmt.Errorf("%s %s expects Go 1.27 Ym memory: %q", c.goarch, op, ins.Raw)
+	}
+	if memory.Kind == OpMem && !x86MemoryRegistersValidForArch(memory.Mem, c.goarch) {
+		return form, fmt.Errorf("%s %s address uses an out-of-range register: %q", c.goarch, op, ins.Raw)
+	}
+	return amd64XStateForm{memory: memory}, nil
+}
+
+func (spec amd64XStateSpec) mnemonic() string {
+	var mnemonic string
+	switch spec.family {
+	case amd64XStateFX:
+		mnemonic = "fxsave"
+		if spec.direction == amd64XStateRestore {
+			mnemonic = "fxrstor"
+		}
+	case amd64XStateXSAVE:
+		mnemonic = "xsave"
+	case amd64XStateXSAVEOPT:
+		mnemonic = "xsaveopt"
+	case amd64XStateXSAVEC:
+		mnemonic = "xsavec"
+	case amd64XStateXSAVES:
+		mnemonic = "xsaves"
+	case amd64XStateXRSTOR:
+		mnemonic = "xrstor"
+	case amd64XStateXRSTORS:
+		mnemonic = "xrstors"
+	default:
+		panic("unknown amd64 xstate family")
+	}
+	if spec.mode64 {
+		mnemonic += "64"
+	}
+	return mnemonic
+}
+
+func (c *amd64Ctx) emitXState(spec amd64XStateSpec, form amd64XStateForm) (bool, bool, error) {
+	pointer, pointerType, err := c.x86DescriptorMemoryPointer(form.memory)
+	if err != nil {
+		return true, false, err
+	}
+	memoryConstraint := "=*m"
+	if spec.direction == amd64XStateRestore {
+		memoryConstraint = "*m"
+	}
+	constraints := memoryConstraint
+	arguments := fmt.Sprintf("%s elementtype([%d x i8]) %s", pointerType, spec.memoryBytes, pointer)
+	if spec.implicitMask {
+		ax, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		dx, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, I32)
+		if err != nil {
+			return true, false, err
+		}
+		constraints += ",{ax},{dx}"
+		arguments += fmt.Sprintf(", i32 %s, i32 %s", ax, dx)
+	}
+	constraints += ",~{memory},~{dirflag},~{fpsr},~{flags}"
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n",
+		spec.mnemonic()+" $0", constraints, arguments)
+	return true, false, nil
+}
diff --git a/amd64_lower_xstate_test.go b/amd64_lower_xstate_test.go
new file mode 100644
index 000000000..d8d37f09a
--- /dev/null
+++ b/amd64_lower_xstate_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestAMD64XStateGrammarIsComplete(t *testing.T) {
+	got := make([]string, 0, len(amd64XStateSpecs))
+	for op := range amd64XStateSpecs {
+		got = append(got, string(op))
+	}
+	sort.Strings(got)
+	want := []string{
+		"FXRSTOR", "FXRSTOR64", "FXSAVE", "FXSAVE64",
+		"XRSTOR", "XRSTOR64", "XRSTORS", "XRSTORS64",
+		"XSAVE", "XSAVE64", "XSAVEC", "XSAVEC64", "XSAVEOPT", "XSAVEOPT64", "XSAVES", "XSAVES64",
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("xstate grammar opcodes = %v, want %v", got, want)
+	}
+	for op, want := range map[Op]amd64XStateSpec{
+		"FXSAVE":     {family: amd64XStateFX, direction: amd64XStateSave, memoryBytes: 512},
+		"FXSAVE64":   {family: amd64XStateFX, direction: amd64XStateSave, mode64: true, memoryBytes: 512},
+		"FXRSTOR":    {family: amd64XStateFX, direction: amd64XStateRestore, memoryBytes: 512},
+		"FXRSTOR64":  {family: amd64XStateFX, direction: amd64XStateRestore, mode64: true, memoryBytes: 512},
+		"XSAVE":      {family: amd64XStateXSAVE, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+		"XSAVE64":    {family: amd64XStateXSAVE, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+		"XSAVEOPT":   {family: amd64XStateXSAVEOPT, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+		"XSAVEOPT64": {family: amd64XStateXSAVEOPT, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+		"XSAVEC":     {family: amd64XStateXSAVEC, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+		"XSAVEC64":   {family: amd64XStateXSAVEC, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+		"XSAVES":     {family: amd64XStateXSAVES, direction: amd64XStateSave, implicitMask: true, memoryBytes: 1},
+		"XSAVES64":   {family: amd64XStateXSAVES, direction: amd64XStateSave, mode64: true, implicitMask: true, memoryBytes: 1},
+		"XRSTOR":     {family: amd64XStateXRSTOR, direction: amd64XStateRestore, implicitMask: true, memoryBytes: 1},
+		"XRSTOR64":   {family: amd64XStateXRSTOR, direction: amd64XStateRestore, mode64: true, implicitMask: true, memoryBytes: 1},
+		"XRSTORS":    {family: amd64XStateXRSTORS, direction: amd64XStateRestore, implicitMask: true, memoryBytes: 1},
+		"XRSTORS64":  {family: amd64XStateXRSTORS, direction: amd64XStateRestore, mode64: true, implicitMask: true, memoryBytes: 1},
+	} {
+		if got := amd64XStateSpecs[op]; got != want {
+			t.Errorf("xstate grammar %s = %+v, want %+v", op, got, want)
+		}
+	}
+}
+
+func TestTranslateX86XStateCompleteGoAssemblerForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := `TEXT xstateforms(SB),$0-0
+	FXSAVE (BX)
+	FXRSTOR 8(BP)
+	XSAVE 16(SI)
+	XRSTOR 24(DI)
+	XSAVEOPT 32(BX)
+	XSAVEC 40(BP)
+	XSAVES 48(SI)
+	XRSTORS 56(DI)
+`
+			if target.goarch == "amd64" {
+				source += `	FXSAVE64 64(R11)
+	FXRSTOR64 72(R12)
+	XSAVE64 80(R13)
+	XRSTOR64 88(R14)
+	XSAVEOPT64 96(R15)
+	XSAVEC64 104(R11)
+	XSAVES64 112(R12)
+	XRSTORS64 120(R13)
+`
+			}
+			source += "\tRET\n"
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"xstateforms": {Name: "xstateforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fxsave", "fxrstor", "xsave", "xrstor", "xsaveopt", "xsavec", "xsaves", "xrstors"} {
+				if !strings.Contains(ir, want+" $0") {
+					t.Errorf("IR is missing %s:\n%s", want, ir)
+				}
+			}
+			if want := `"target-features"="+fxsr,+xsave,+xsavec,+xsaveopt,+xsaves"`; !strings.Contains(ir, want) {
+				t.Errorf("IR is missing complete xstate feature set %s:\n%s", want, ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "xstate-"+target.name+".ll", "xstate-"+target.name+".o", ir)
+		})
+	}
+}
+
+func TestAMD64FXStateRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT fxstatesemantics(SB),NOSPLIT,$0-8
+	MOVQ area+0(FP), DI
+	FXSAVE (DI)
+	FXRSTOR (DI)
+	FXSAVE64 512(DI)
+	FXRSTOR64 512(DI)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"fxstatesemantics": {
+			Name: "fxstatesemantics", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void fxstatesemantics(uint8_t *);
+int main(void) {
+  __attribute__((aligned(16))) uint8_t area[1024];
+  memset(area, 0xa5, sizeof(area));
+  fxstatesemantics(area);
+  uint16_t control0 = 0, control1 = 0;
+  memcpy(&control0, area, sizeof(control0));
+  memcpy(&control1, area + 512, sizeof(control1));
+  if (control0 == UINT16_C(0xa5a5)) return 10;
+  if (control1 == UINT16_C(0xa5a5)) return 11;
+  if (control0 != control1) return 12;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "fxstate_semantics", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateX86XStateRejectsFormsOutsideGoTables(t *testing.T) {
+	tests := []struct {
+		goarch      string
+		instruction string
+	}{
+		{goarch: "amd64", instruction: "FXSAVE AX"},
+		{goarch: "amd64", instruction: "FXRSTOR $1"},
+		{goarch: "amd64", instruction: "XSAVE"},
+		{goarch: "amd64", instruction: "XRSTOR (BX), (CX)"},
+		{goarch: "amd64", instruction: "XSAVEOPT.Z (BX)"},
+		{goarch: "amd64", instruction: "XSAVEC X0"},
+		{goarch: "amd64", instruction: "XSAVES AX"},
+		{goarch: "amd64", instruction: "XRSTORS $1"},
+		{goarch: "386", instruction: "XSAVE (R11)"},
+	}
+	for _, op := range []string{"FXSAVE64", "FXRSTOR64", "XSAVE64", "XRSTOR64", "XSAVEOPT64", "XSAVEC64", "XSAVES64", "XRSTORS64"} {
+		tests = append(tests, struct {
+			goarch      string
+			instruction string
+		}{goarch: "386", instruction: op + " (BX)"})
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"_"+strings.NewReplacer(" ", "_", "$", "", "(", "_", ")", "_").Replace(test.instruction), func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + test.instruction + "\n\tRET\n"
+			requireX86GoAssemblerResult(t, test.goarch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if test.goarch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{
+				Goarch: test.goarch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's xstate tables", test.instruction)
+			}
+		})
+	}
+}
diff --git a/amd64_madd_typed_forms_test.go b/amd64_madd_typed_forms_test.go
new file mode 100644
index 000000000..dd9f875f9
--- /dev/null
+++ b/amd64_madd_typed_forms_test.go
@@ -0,0 +1,420 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86MADDOfficialRows(t *testing.T, arch string) []string {
+	t.Helper()
+	byOpcode := x86OfficialPackedBinaryWitnesses(t)
+	var rows []string
+	for _, name := range []string{"VPMADDWD", "VPMADDUBSW"} {
+		if len(byOpcode[name]) == 0 {
+			t.Fatal("official MADD table missing", name)
+		}
+		for _, row := range byOpcode[name] {
+			if arch != "386" || strings.Count(row, ",") != 3 {
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows
+}
+
+// Full Go source classes, including valid forms lacking native backing or
+// physical mode32 identity. These are not all object/runtime positives.
+func x86MADDWholeFormats(t *testing.T, arch string) []string {
+	rows := x86MADDOfficialRows(t, arch)
+	for _, name := range []string{"PMADDWL", "PMADDUBSW"} {
+		for _, source := range []string{"X0", "X7", "(AX)", "16(AX)(CX*2)", "value+0(FP)", "local-16(SP)", "data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, name+" "+source+",X1")
+		}
+		if arch == "amd64" {
+			rows = append(rows, name+" X15,X0")
+		}
+	}
+	if arch == "amd64" {
+		for _, source := range []string{"M0", "M7", "(AX)", "value+0(FP)", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			rows = append(rows, "PMADDWL "+source+",M1")
+		}
+	}
+	for _, name := range []string{"VPMADDWD", "VPMADDUBSW"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{"value+0(FP)", "local-64(SP)", "data(SB)", "(FS)", "(GS)"} {
+				rows = append(rows, name+" "+source+","+bank+"1,"+bank+"2")
+			}
+			if arch != "386" || bank != "Z" {
+				rows = append(rows, name+" "+bank+"20,"+bank+"21,"+bank+"22")
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86MADDTypedCompleteGoAttributes(t *testing.T) {
+	if len(x86PackedMultiplyAddSpecs) != 4 {
+		t.Fatal("MADD source family must have four canonical Go names")
+	}
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{APMADDWL, ymm, Py1, opBytes{0xf5, Pe, 0xf5}}",
+		"{APMADDUBSW, yxm_q4, Pq4, opBytes{0x04}}",
+		"{Zm_r_xm, 1, argList{Ymm, Ymr}}", "{Zm_r_xm, 2, argList{Yxm, Yxr}}",
+		"{Zm_r, 1, argList{Yxm, Yxr}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("actual legacy opcode/class row changed", row)
+		}
+	}
+	for _, class := range []string{"Yax", "Ycx", "Yrx", "Yrl", "Yrl32", "Ym", "Ymr"} {
+		if !strings.Contains(string(legacy), "ycover["+class+"*Ymax+Ymm] = 1") {
+			t.Fatal("actual MMX source class changed", class)
+		}
+	}
+	for _, item := range []struct{ name, mapName, opcode string }{
+		{"VPMADDWD", "0F", "F5"}, {"VPMADDUBSW", "0F38", "04"},
+	} {
+		start := strings.Index(string(avx), "{as: A"+item.name+",")
+		if start < 0 {
+			t.Fatal("actual AVX opcode missing", item.name)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(row, "ytab: _yvandnpd, prefix: Pavx") || strings.Contains(row, "Bcst") || strings.Contains(row, "Sae") {
+			t.Fatal("actual opcode-specific attributes changed", row)
+		}
+		for _, width := range []string{"128", "256"} {
+			want := fmt.Sprintf("avxEscape | vex%s | vex66 | vex%s | vexW0, 0x%s", width, item.mapName, item.opcode)
+			if !strings.Contains(row, want) {
+				t.Fatal("actual VEX opcode attributes changed", want)
+			}
+		}
+		for i, width := range []string{"128", "256", "512"} {
+			want := fmt.Sprintf("avxEscape | evex%s | evex66 | evex%s | evexW0, evexN%d | evexZeroingEnabled, 0x%s", width, item.mapName, 16<<i, item.opcode)
+			if !strings.Contains(row, want) {
+				t.Fatal("actual EVEX opcode attributes changed", want)
+			}
+		}
+	}
+}
+
+func TestX86MADDTypedWholeFormatsEffectsAndShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86MADDWholeFormats(t, arch)
+		var batch strings.Builder
+		for index, row := range rows {
+			fmt.Fprintf(&batch, "TEXT f%d(SB),4,$64-64\n%s\nRET\n", index, row)
+		}
+		goAssemblerOracleOutput(t, arch, batch.String(), "", true)
+		file, err := Parse(ArchAMD64, batch.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, function := range file.Funcs {
+			ins := function.Instrs[1]
+			before := fmt.Sprintf("%#v", ins)
+			form, known, err := x86PackedMultiplyAddProperties(ins.Op, ins, arch)
+			high := arch == "386" && strings.Contains(rows[index], "20")
+			if !known || high && !errors.Is(err, ErrProbeNeedsContext) || !high && err != nil {
+				t.Fatal("actual Go-accepted format lost its exact classification", arch, rows[index], err)
+			}
+			if high {
+				continue
+			}
+			if form.legacy {
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 || effect.flagsDefined != 0 || effect.flagsKilled != 0 ||
+					!effect.operands[0].read || effect.operands[0].write || !effect.operands[1].read || !effect.operands[1].write ||
+					effect.operands[0].width != int64(form.byteWidth) || effect.operands[1].width != int64(form.byteWidth) ||
+					!reflect.DeepEqual(effect.operands[0].operand, form.source) {
+					t.Fatal("legacy native bytes/physical bank diverged from descriptor", rowLabel(arch, ins), effect, err)
+				}
+			}
+			for operand, arg := range ins.Args {
+				width, write, valid := x86InstructionMemoryShape(ins, operand, arch)
+				if valid != (form.memory == operand && !form.mmx) || valid && (write || width != int64(form.memoryBytes)) {
+					t.Fatal("memory-shape consumer diverged from complete typed grammar", ins, width, write, valid)
+				}
+				if arg.Kind == OpFP {
+					width, write, valid := X86FPAccessBytes(ins, operand, arch)
+					if !valid || write || width != int64(form.memoryBytes) {
+						t.Fatal("FP native width observer disagrees", ins, width, write, valid)
+					}
+				}
+			}
+			if before != fmt.Sprintf("%#v", ins) || x86CallerVectorMoveKnown(ins) != !form.mmx {
+				t.Fatal("grammar changed input or lost registered caller family", ins)
+			}
+		}
+		t.Logf("%s: %d actual Go source formats; classification/effects are not runtime or backing permission", arch, len(rows))
+	}
+}
+
+func rowLabel(arch string, ins Instr) string { return arch + "/" + ins.Raw }
+
+func TestX86MADDTypedMMXActualEncodedBank(t *testing.T) {
+	registers := []string{"M0", "M1", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for index, register := range registers {
+		source := "TEXT f(SB),4,$0-0\nPMADDWL " + register + ",M1\nRET\n"
+		code := assembleX87ControlBytes(t, "amd64", source)
+		physical := index
+		if index == 2 {
+			physical = 7
+		} else if index >= 3 {
+			physical = (index - 3) & 7
+		}
+		if len(code) == 5 && code[0] == 0x41 {
+			code = code[1:] // Actual Go's ignored MMX REX.B annotation.
+		}
+		if want := []byte{0x0f, 0xf5, byte(0xc8 | physical), 0xc3}; !bytes.Equal(code, want) {
+			t.Fatalf("actual MMX physical bank changed: %s %x want%x", register, code, want)
+		}
+		if index >= 3 {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			context, ir := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := ir.String()
+			if _, _, err := context.lowerPackedWordMultiplyAdd("PMADDWL", file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) || ir.String() != before {
+				t.Fatal("GP spelling fabricated an initialized MMX source", register, err)
+			}
+		}
+	}
+}
+
+func TestX86MADDTypedRetainsRejectedFormsAndVirtualMemory(t *testing.T) {
+	for _, row := range []string{
+		"PMADDWD X0,X1", "PMADDWL X0,Y1", "PMADDWL M0,AX", "PMADDUBSW M0,M1",
+		"PMADDUBSW X0,(AX)", "PMADDUBSW.Z X0,X1", "VPMADDWD X0,Y1,Y2",
+		"VPMADDUBSW.BCST (AX),X0,K1,X1", "VPMADDWD.SAE Z0,Z1,Z2",
+		"VPMADDUBSW X0,X1,K0,X2", "VPMADDWD $1,X1,X2", "VPMADDUBSW X0,X1,(AX)",
+	} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			continue
+		}
+		if err := ProbeInstruction(ArchAMD64, "amd64", file.Funcs[0].Instrs[1]); err == nil {
+			t.Fatal("Go-rejected MADD form obtained lowering", row)
+		}
+	}
+	for _, row := range []string{"PMADDUBSW source+0(FP),X1", "PMADDUBSW (SP),X1", "PMADDUBSW (BP),X1", "PMADDUBSW (AX)(BP*2),X1"} {
+		source := "TEXT f(SB),4,$0-64\n" + row + "\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		context, ir := newAMD64CtxWithFuncForTest(t, file.Funcs[0], x86WordMaddFPType(t), nil)
+		before := ir.String()
+		if _, _, err := context.lowerPackedWordMultiplyAdd("PMADDUBSW", file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) || ir.String() != before {
+			t.Fatal("virtual storage became an original native m128 pointer", row, err)
+		}
+	}
+}
+
+func TestX86MADDTypedByteCallerRetainsUnknownAndPartialInputs(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown source":       "VMOVUPS (DI),Z1\nVPMADDUBSW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"unknown second":       "VMOVUPS (DI),Z0\nVPMADDUBSW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+		"partial pair":         "MOVSS (DI),X0\nMOVSS (SI),X1\nVPMADDUBSW Y0,Y1,Y2\nVEXTRACTF128 $1,Y2,X3\nVMOVSS X3,(DX)",
+		"unknown mask":         "VMOVUPS (DI),Z0\nVPMADDUBSW.Z Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown merge":        "VMOVUPS (DI),Z0\nMOVL $1,AX\nKMOVQ AX,K1\nVPMADDUBSW Z0,Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"unknown address":      "VMOVUPS (DI),Z0\nVPMADDUBSW (BX),Z0,Z2\nVMOVSS X2,(DX)",
+		"zero still full read": "VMOVUPS (DI),Z0\nMOVL $0,AX\nKMOVQ AX,K1\nVPMADDUBSW.Z (DX),Z0,K1,Z2\nVMOVSS X2,(DX)",
+		"private SP":           "VMOVUPS (DI),Z0\nMOVQ SP,BX\nPMADDUBSW (BX),X0\nVMOVSS X0,(DX)",
+		"join missing source":  "VMOVUPS (DI),Z1\nCMPQ AX,$0\nJE joined\nVMOVUPS (SI),Z0\njoined:\nVPMADDUBSW Z0,Z1,Z2\nVMOVSS X2,(DX)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("typed byte-MADD grammar became input/address permission", err)
+			}
+		})
+	}
+}
+
+func TestX86MADDTypedMalformedIdentityAndPhysicalBanks(t *testing.T) {
+	for _, name := range []string{"PMADDWL", "PMADDUBSW", "VPMADDWD", "VPMADDUBSW"} {
+		operands := "X0,X1"
+		if strings.HasPrefix(name, "V") {
+			operands = "X0,X1,X2"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+name+" "+operands+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", original.Op, Op(strings.ToLower(name)), "MOVQ", Op(name + ".BAD")} {
+			ins := original
+			ins.Op = identity
+			before := fmt.Sprintf("%#v", ins)
+			context, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ir, temporary := out.String(), context.tmp
+			known, terminated, err := context.lowerPackedWordMultiplyAdd(original.Op, ins)
+			bad := identity != "" && !strings.EqualFold(string(identity), string(original.Op))
+			if !known || terminated || (err != nil) != bad || bad && (out.String() != ir || context.tmp != temporary) || before != fmt.Sprintf("%#v", ins) {
+				t.Fatal("dispatch identity changed input or emitted before rejection", name, identity, err)
+			}
+		}
+	}
+	for _, opcode := range []string{"VPMADDWD", "VPMADDUBSW"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			row := opcode + " " + bank + "20," + bank + "21," + bank + "22"
+			accepted := bank != "Z"
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", accepted)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _, err = x86PackedMultiplyAddProperties(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], "386")
+			if accepted && !errors.Is(err, ErrProbeNeedsContext) || !accepted && err == nil {
+				t.Fatal("Go syntax is not physical mode32 permission", row, err)
+			}
+		}
+		code := encodeX86RawEVEXPackedMADD(Op(opcode), 2, 1, 2, 0, 1, true, true)
+		decoded, _, _, err := decodedX86EVEXPackedMADDInstruction(code, 32)
+		if err != nil {
+			t.Fatal(err)
+		}
+		data, err := json.Marshal(decoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var detached Instr
+		if err := json.Unmarshal(data, &detached); err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := x86PackedMultiplyAddProperties(detached.Op, detached, "386"); err == nil {
+			t.Fatal("JSON/raw text fabricated physical mode32 mask provenance")
+		}
+		for _, address := range []int{16, 32, 64} {
+			changed := decoded
+			changed.x86AddressBits = address
+			if _, _, err := x86PackedMultiplyAddProperties(changed.Op, changed, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound address-size marker became memory permission", err)
+			}
+		}
+	}
+}
+
+func TestX86MADDTypedNamedAndPhysicalThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, raw := range []bool{false, true} {
+		for _, target := range []struct{ arch, triple string }{
+			{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(fmt.Sprintf("raw=%t/%s", raw, target.triple), func(t *testing.T) {
+				rows := x86MADDOfficialRows(t, target.arch)
+				if raw {
+					rows = nil
+					for _, row := range x86MADDOfficialRows(t, "amd64") {
+						code := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+						code = code[:len(code)-1]
+						for w := 0; w < 2; w++ {
+							physical := append([]byte(nil), code...)
+							if physical[0] == 0xc5 {
+								physical = append([]byte{0xc4, physical[1]&0x80 | 0x61, physical[1] & 0x7f}, physical[2:]...)
+							}
+							physical[2] |= byte(w << 7)
+							var bytes strings.Builder
+							for _, value := range physical {
+								fmt.Fprintf(&bytes, "BYTE $%d\n", value)
+							}
+							rows = append(rows, bytes.String())
+						}
+					}
+				} else {
+					rows = append(rows, "PMADDWL X0,X1", "PMADDWL (AX),X1", "PMADDUBSW X0,X1", "PMADDUBSW (AX),X1")
+				}
+				var source, declarations strings.Builder
+				declarations.WriteString("package madd\n")
+				for index, row := range rows {
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", index, row)
+					fmt.Fprintf(&declarations, "func F%d()\n", index)
+				}
+				if !raw {
+					file, sigs := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+					ir := x86ScalarFormatObjectUnit(t, file, sigs, target.arch, target.triple, 0)
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+					t.Logf("%d original named formats: Go objects, three public Context controls and emitter-only objects", len(rows))
+					return
+				}
+				goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+				pkg := mustGoPackage(t, "example.invalid/madd", declarations.String())
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs := map[string]FuncSig{}
+				for index := range rows {
+					name := fmt.Sprintf("F%d", index)
+					sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), target.arch, types.SizesFor("gc", target.arch))
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs[name] = sig
+				}
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs, ResolveSym: resolve}
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "madd-text.ll", "madd-text.o", ir)
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "madd-module.ll", "madd-module.o", module.String())
+				result, err := translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+				})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "madd-go.ll", "madd-go.o", result.Module.String())
+				t.Logf("%d named/actual-Go-derived physical forms, three APIs/object axes; no caller or native runtime grant", len(rows))
+			})
+		}
+	}
+}
diff --git a/amd64_madd_typed_mode32_test.go b/amd64_madd_typed_mode32_test.go
new file mode 100644
index 000000000..573334385
--- /dev/null
+++ b/amd64_madd_typed_mode32_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import "testing"
+
+func TestX86MADDTypedMode32LegacySourceRules(t *testing.T) {
+	for _, opcode := range []string{"PMADDWL", "PMADDUBSW"} {
+		for _, operands := range []string{"X0,X1", "X0,X7", "(AX),X7"} {
+			row := opcode + " " + operands
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", source, "", true)
+			code := assembleX87ControlBytes(t, "386", source)
+			if len(code) == 0 {
+				t.Fatal("accepted legacy source has no original Go machine bytes", row)
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, known, err := x86PackedMultiplyAddProperties(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], "386")
+			if !known || err != nil {
+				t.Errorf("accepted low mode32 source lost its typed shape: %s bytes%x: %v", row, code, err)
+			}
+		}
+		// Unlike the AVX name rows, the legacy encoder rejects these high
+		// source spellings; do not label them accepted physical Context rows.
+		for _, operands := range []string{"X8,X1", "X0,X15", "(AX),X8", "X16,X0", "X0,X16"} {
+			source := "TEXT f(SB),4,$0-0\n" + opcode + " " + operands + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, known, err := x86PackedMultiplyAddProperties(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], "386")
+			if !known || err == nil {
+				t.Fatal("Go-rejected high legacy source obtained typed admission", source)
+			}
+		}
+	}
+	// The shared ymm is not a blanket 386 MMX row: Py1's original row
+	// selection rejects its z<1 MMX forms in 32-bit mode.
+	for _, source := range []string{"M0", "(AX)", "AX", "CX", "SI"} {
+		row := "PMADDWL " + source + ",M1"
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+	}
+}
diff --git a/amd64_madd_typed_native_linux_amd64_test.go b/amd64_madd_typed_native_linux_amd64_test.go
new file mode 100644
index 000000000..e9cf1301f
--- /dev/null
+++ b/amd64_madd_typed_native_linux_amd64_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The filename is the Linux/amd64 build role and the cross-runtime prefix is
+// selected by required CI. Native AVX must be available: no Skip, Rosetta
+// fallback or object-only substitution satisfies this original-Go axis.
+func TestCrossLinuxRuntimeMatrixX86MADDTypedOriginalVEX(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	var declarations, assembly, table strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, row := range x86MADDOracleRows() {
+		if row.legacy || row.masking != 0 || row.width > 32 {
+			continue
+		}
+		name := fmt.Sprintf("V%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(out *[48]byte,a,b *[64]byte,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-36\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nSTMXCSR saved-4(SP)\nLDMXCSR csr+32(FP)\nVMOVDQU (CX),Y0\nVMOVDQU (DX),Y1\nVMOVDQU (DX),Y2\nPUSHQ flags+24(FP)\nPOPFQ\n", name)
+		instruction, destination := row.instruction()
+		fmt.Fprintf(&assembly, "%s\nVMOVDQU Y%s,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,32(AX)\nSTMXCSR 40(AX)\nVZEROUPPER\nLDMXCSR saved-4(SP)\nRET\n", instruction, destination[1:])
+		fmt.Fprintf(&table, "{%s,%d,%d},\n", name, row.width, row.inputBytes)
+	}
+	tests := `package oracle
+import (
+ "testing"
+ "encoding/binary"
+ "runtime"
+ "unsafe"
+)
+
+var cases = []struct {
+ run func(*[48]byte, *[64]byte, *[64]byte, uint64, uint32)
+ width, bytes int
+}{
+` + table.String() + `}
+
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ edges := [...]int32{0, 1, -1, 127, -128, 255, 256, -257, 32767, -32768, 16384, -16384}
+ profiles := []uint32{0x1f80, 0x3fc1, 0x5f82, 0x9fe5}
+ observations := 0
+ for row, entry := range cases {
+  for sample := 0; sample < 32; sample++ {
+   for _, csr := range profiles {
+    for seed := 0; seed < 2; seed++ {
+     var a, b [64]byte
+     var out, want [50]byte
+     for i := 0; i < 64; i += entry.bytes {
+      x, y := edges[(sample+i*3)%len(edges)], edges[(sample+7+i*3)%len(edges)]
+      a[i], b[i] = byte(x), byte(y)
+      if entry.bytes == 2 {
+       a[i+1], b[i+1] = byte(uint32(x)>>8), byte(uint32(y)>>8)
+      }
+     }
+     if entry.bytes == 2 && sample == 0 {
+      for i := 0; i < 64; i += 2 {
+       a[i] = 0
+       b[i] = 0
+       a[i+1] = 0x80
+       b[i+1] = 0x80
+      }
+     }
+     if entry.bytes == 1 && sample < 2 {
+      for i := range a {
+       a[i] = 0x7f
+       if sample == 1 {
+        a[i] = 0x80
+       }
+       b[i] = 0xff
+      }
+     }
+     beforeA, beforeB := a, b
+     for i := range out {
+      out[i] = 0xc3
+      want[i] = 0xc3
+     }
+
+     flags := uint64(2)
+     if seed != 0 {
+      flags |= 0x8d5
+     }
+     entry.run((*[48]byte)(unsafe.Pointer(&out[1])), &a, &b, flags, csr)
+     for i := 0; i < 32; i++ {
+      want[i+1] = 0
+     }
+     for i := 0; i < entry.width; i += entry.bytes * 2 {
+      var sum int64
+      if entry.bytes == 2 {
+       sum = int64(int16(binary.LittleEndian.Uint16(a[i:]))) * int64(int16(binary.LittleEndian.Uint16(b[i:]))) +
+             int64(int16(binary.LittleEndian.Uint16(a[i+2:]))) * int64(int16(binary.LittleEndian.Uint16(b[i+2:])))
+      } else {
+       sum = int64(int8(a[i]))*int64(b[i]) + int64(int8(a[i+1]))*int64(b[i+1])
+       if sum < -32768 {
+        sum = -32768
+       }
+       if sum > 32767 {
+        sum = 32767
+       }
+      }
+      for j := 0; j < entry.bytes * 2; j++ {
+       want[i+j+1] = byte(uint32(sum) >> uint(j*8))
+      }
+     }
+
+     actualFlags := binary.LittleEndian.Uint64(out[33:41])
+     actualCSR := binary.LittleEndian.Uint32(out[41:45])
+     copy(want[33:45], out[33:45])
+     observations++
+     if out != want || a != beforeA || b != beforeB || actualFlags&0x8d5 != flags&0x8d5 || actualCSR != csr {
+      t.Fatalf("original VEX MADD row%d sample%d flags%x CSR%x got%x want%x",
+               row, sample, actualFlags, actualCSR, out, want)
+     }
+    }
+   }
+  }
+ }
+ if observations != len(cases)*32*4*2 {
+  t.Fatal("incomplete original VEX matrix", observations)
+ }
+}
+`
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), tests)
+	t.Logf("%d original VEX X/Y kernels, register/memory/all destination aliases ×32 samples ×4 CSR profiles ×2 six-flag seeds; full Y upper-zero/input/canaries. No original EVEX execution claim.", count)
+}
diff --git a/amd64_madd_typed_rules_test.go b/amd64_madd_typed_rules_test.go
new file mode 100644
index 000000000..c0ea8286b
--- /dev/null
+++ b/amd64_madd_typed_rules_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Intel's PMADDWD and PMADDUBSW tables specify WIG, unlike EVEX PACK*DW.
+// Bind W0 to stock Go's actual instruction, then independently compare the
+// complete LLVM MC opcode/operands of the W1 physical counterpart.
+func TestX86MADDTypedPhysicalWIGCompleteOperands(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 MC required")
+	}
+	for _, opcode := range []string{"VPMADDWD", "VPMADDUBSW"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{bank + "1", "16(AX)(CX*2)"} {
+				row := opcode + ".Z " + source + "," + bank + "2,K3," + bank + "4"
+				code := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				code = code[:len(code)-1]
+				if code[0] != 0x62 || code[2]&0x80 != 0 {
+					t.Fatal("Go original is not the expected EVEX W0 row", row, code)
+				}
+				for _, mode := range []int{32, 64} {
+					t.Run(fmt.Sprintf("%d/%s", mode, row), func(t *testing.T) {
+						var texts [2]string
+						for w := 0; w < 2; w++ {
+							physical := append([]byte(nil), code...)
+							physical[2] |= byte(w << 7)
+							var input strings.Builder
+							for _, value := range physical {
+								fmt.Fprintf(&input, "0x%02x ", value)
+							}
+							triple := "x86_64"
+							if mode == 32 {
+								triple = "i386"
+							}
+							ctx, cancel := runtimeOracleStageContext(t)
+							command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple,
+								"--mattr=+avx2,+avx512bw,+avx512vl")
+							command.Stdin = strings.NewReader(input.String() + "\n")
+							output, err := runtimeOracleCombinedOutput(ctx, command)
+							cancel()
+							if err != nil || strings.Contains(string(output), "warning:") ||
+								!strings.Contains(string(output), strings.ToLower(opcode)) {
+								t.Fatalf("independent MC rejected %x: %v\n%s", physical, err, output)
+							}
+							texts[w] = strings.TrimSpace(string(output))
+							instruction, size, known, err := decodedX86EVEXPackedMADDInstruction(physical, mode)
+							if err != nil || !known || size != len(physical) {
+								t.Errorf("Go-bound WIG physical form rejected: %x %d/%t/%v", physical, size, known, err)
+								continue
+							}
+							arch := map[int]string{32: "386", 64: "amd64"}[mode]
+							if form, known, err := x86PackedMultiplyAddProperties(instruction.Op, instruction, arch); err != nil || !known || form.mask != 2 {
+								t.Errorf("physical MADD missing complete typed grammar: %+v %t/%v", form, known, err)
+							}
+							if width, write, valid := x86InstructionMemoryShape(instruction, 0, arch); source[0] == '1' &&
+								(!valid || write || width != int64(amd64VectorByteWidth(Reg(bank+"0")))) {
+								t.Errorf("complete physical memory envelope missing: %d/%t/%t", width, write, valid)
+							}
+						}
+						if texts[0] != texts[1] {
+							t.Fatalf("WIG changed complete disassembled operands: W0=%q W1=%q", texts[0], texts[1])
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86MADDTypedCallerByteFamily(t *testing.T) {
+	rows := []string{"PMADDUBSW X0,X1", "PMADDUBSW X1,X1", "PMADDUBSW (DI),X1"}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, first := range []string{bank + "0", "(DI)"} {
+			rows = append(rows,
+				"VPMADDUBSW "+first+","+bank+"1,"+bank+"2",
+				"VPMADDUBSW "+first+","+bank+"1,K1,"+bank+"2",
+				"VPMADDUBSW.Z "+first+","+bank+"1,K1,"+bank+"2")
+		}
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			result := "X2"
+			if strings.HasPrefix(row, "PMADD") {
+				result = "X1"
+			}
+			body := "VMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\nVMOVUPS (DI),Z2\nMOVL $1,AX\nKMOVQ AX,K1\n" + row + "\nVMOVSS " + result + ",(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal("Go-accepted byte-MADD is missing caller effects", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86MADDTypedXUpperZero(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	assembly := "TEXT ·upper(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nVMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (DX),Z2\nVPMADDUBSW X0,X1,X2\nVMOVUPS Z2,(AX)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	ir := x86NarrowOracleIR(t, assembly, "package narroworacle\nfunc upper(out,a,b *[64]byte)\n", execution.triple)
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void upper(void*,const void*,const void*);
+int main(void) {
+ uint8_t a[64],b[64],out[66];memset(a,2,64);memset(b,3,64);memset(out,0xc3,66);
+ upper(out+1,a,b);
+ for(int i=0;i<64;++i) {
+  int want=i<16?(i&1?0:12):0;
+  if(out[i+1]!=want) {fprintf(stderr,"MADD alias byte%d got=%u want=%u\n",i,out[i+1],want);return 1;}
+ }
+ if(out[0]!=0xc3||out[65]!=0xc3)return 2;
+ return 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "madd-x-upper", ir, main, level)
+		})
+	}
+}
diff --git a/amd64_madd_typed_runtime_test.go b/amd64_madd_typed_runtime_test.go
new file mode 100644
index 000000000..272e4766f
--- /dev/null
+++ b/amd64_madd_typed_runtime_test.go
@@ -0,0 +1,434 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+type x86MADDOracleRow struct {
+	width, inputBytes, source, alias, masking int
+	legacy, mmx                               bool
+}
+
+func x86MADDOracleRows() []x86MADDOracleRow {
+	var rows []x86MADDOracleRow
+	for _, inputBytes := range []int{1, 2} {
+		for _, width := range []int{8, 16, 32, 64} {
+			for _, legacy := range []bool{true, false} {
+				if legacy && width > 16 || !legacy && width == 8 || width == 8 && inputBytes == 1 {
+					continue
+				}
+				for source := 0; source < 2; source++ {
+					for alias := 0; alias < 3; alias++ {
+						if legacy && alias == 2 {
+							continue
+						}
+						for mask := 0; mask < 3; mask++ {
+							if legacy && mask != 0 {
+								continue
+							}
+							rows = append(rows, x86MADDOracleRow{width, inputBytes, source, alias, mask, legacy, width == 8})
+						}
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86MADDOracleRow) instruction() (string, string) {
+	bank := map[int]string{8: "M", 16: "X", 32: "Y", 64: "Z"}[row.width]
+	first, destination := bank+"0", fmt.Sprintf("%s%d", bank, row.alias)
+	if row.legacy {
+		destination = bank + "1"
+		if row.alias == 1 {
+			first = destination
+		}
+	}
+	if row.source == 1 {
+		first = "(CX)"
+		if row.legacy && row.alias == 1 {
+			first = "(DX)"
+		}
+	}
+	name := "PMADDWL"
+	if row.inputBytes == 1 {
+		name = "PMADDUBSW"
+	}
+	if row.legacy {
+		return name + " " + first + "," + destination, destination
+	}
+	name = "VPMADDWD"
+	if row.inputBytes == 1 {
+		name = "VPMADDUBSW"
+	}
+	if row.masking == 2 {
+		name += ".Z"
+	}
+	mask := ""
+	if row.masking != 0 {
+		mask = "K1,"
+	}
+	return name + " " + first + "," + bank + "1," + mask + destination, destination
+}
+
+// Independent widened integer arithmetic, not a production helper/intrinsic.
+// Signed word pairs wrap modulo 2^32; signed-byte * unsigned-byte pairs
+// saturate to signed16. Every pair stays in its source byte position.
+const x86MADDIndependentCReference = `
+static const int32_t edges[] = {
+  0, 1, -1, 2, -2, 127, -128, 255, 256, -257, 32767, -32768, 16384, -16384
+};
+
+static void fill(uint8_t *out, unsigned sample, unsigned salt, int bytes) {
+  for (int i = 0; i < 64; i += bytes) {
+    int32_t v = edges[(sample + salt + i * 3) % 14];
+    if (sample >= 14) v = (int32_t)(sample * 7919 + i * 104729 + salt * 65537);
+    out[i] = (uint8_t)v;
+    if (bytes == 2) out[i + 1] = (uint8_t)(v >> 8);
+  }
+}
+
+static int64_t signed_word(const uint8_t *p) {
+  uint32_t bits = (uint32_t)p[0] | (uint32_t)p[1] << 8;
+  return bits < 32768 ? (int64_t)bits : (int64_t)bits - 65536;
+}
+
+static void independent_madd(uint8_t *out, const uint8_t *first,
+                             const uint8_t *second, int width, int bytes) {
+  int group = bytes * 2;
+  for (int i = 0; i < width; i += group) {
+    int64_t sum;
+    if (bytes == 2) sum = signed_word(first + i) * signed_word(second + i) +
+                          signed_word(first + i + 2) * signed_word(second + i + 2);
+    else {
+      int32_t a = first[i] < 128 ? first[i] : (int32_t)first[i] - 256;
+      int32_t b = first[i + 1] < 128 ? first[i + 1] : (int32_t)first[i + 1] - 256;
+      sum = (int64_t)a * second[i] + (int64_t)b * second[i + 1];
+      if (sum < -32768) sum = -32768;
+      if (sum > 32767) sum = 32767;
+    }
+    uint32_t bits = (uint32_t)sum;
+    for (int j = 0; j < group; ++j) out[i + j] = (uint8_t)(bits >> (j * 8));
+  }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86MADDTypedIndependentWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	rows := x86MADDOracleRows()
+	var assembly, declarations, table, main strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	main.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	for index, row := range rows {
+		name := fmt.Sprintf("madd%d", index)
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte,mask,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-52\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nMOVQ mask+32(FP),R9\n", name)
+		// Set the independent state before entering MMX. Its physical x87
+		// region must remain uninterrupted through the real EMMS instruction.
+		assembly.WriteString("LDMXCSR csr+48(FP)\nPUSHQ flags+40(FP)\nPOPFQ\n")
+		if row.mmx {
+			assembly.WriteString("MOVQ (CX),M0\nMOVQ (DX),M1\n")
+		} else {
+			assembly.WriteString("VMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nKMOVQ R9,K1\n")
+		}
+		instruction, destination := row.instruction()
+		fmt.Fprintf(&assembly, "%s\n", instruction)
+		if row.mmx {
+			fmt.Fprintf(&assembly, "MOVQ %s,(AX)\nEMMS\n", destination)
+		} else {
+			fmt.Fprintf(&assembly, "VMOVUPS Z%s,(AX)\n", destination[1:])
+		}
+		assembly.WriteString("PUSHFQ\nPOPQ R10\nMOVQ R10,64(AX)\nSTMXCSR 72(AX)\nRET\n")
+		fmt.Fprintf(&main, "extern void %s(void*,const void*,const void*,const void*,uint64_t,uint64_t,uint32_t);\n", name)
+		fmt.Fprintf(&table, "{%s,%d,%d,%d,%d,%d,%d},\n", name, row.width, row.inputBytes, row.source, row.alias, row.masking, x86FloatAddSubBoolInt(row.legacy))
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	main.WriteString("static const struct {void (*run)(void*,const void*,const void*,const void*,uint64_t,uint64_t,uint32_t);int width,bytes,source,alias,masking,legacy;} cases[]={\n" + table.String() + "};\n")
+	main.WriteString(x86MADDIndependentCReference)
+	main.WriteString(`
+int main(void) {
+  unsigned saved;
+  __asm__ volatile("stmxcsr %0" : "=m"(saved));
+  const uint32_t profiles[] = {0x1f80, 0x3fc1, 0x5f82, 0x9fe5};
+  unsigned long long observations = 0;
+  for (unsigned row = 0; row < sizeof(cases) / sizeof(cases[0]); ++row) {
+    int lanes = cases[row].width / (cases[row].bytes * 2);
+    for (unsigned sample = 0; sample < 32; ++sample)
+    for (int select = 0; select < lanes + 4; ++select)
+    for (unsigned profile = 0; profile < 4; ++profile)
+    for (unsigned seed = 0; seed < 2; ++seed) {
+      _Alignas(64) uint8_t a[64], b[64], old[64], beforeA[64], beforeB[64], beforeOld[64];
+      uint8_t out[82], want[82], packed[64];
+      fill(a, sample, 0, cases[row].bytes);
+      fill(b, sample, 7, cases[row].bytes);
+      for (int i = 0; i < 64; ++i) old[i] = (uint8_t)(0x91 + i * 11);
+      if (cases[row].bytes == 2 && sample == 0)
+      for (int i = 0; i < 64; i += 2) {
+        a[i] = b[i] = 0;
+        a[i + 1] = b[i + 1] = 0x80;
+      }
+      if (cases[row].bytes == 1 && sample < 2) {
+        memset(a, sample ? 0x80 : 0x7f, 64);
+        memset(b, 0xff, 64);
+      }
+      memcpy(beforeA, a, 64);
+      memcpy(beforeB, b, 64);
+      memcpy(beforeOld, old, 64);
+      memset(out, 0xc3, sizeof(out));
+      memcpy(want, out, sizeof(want));
+
+      uint64_t mask = select == 0 ? 0 : select == 1 ? UINT64_MAX :
+                      select == 2 ? UINT64_C(0xaaaaaaaaaaaaaaaa) :
+                      select == 3 ? UINT64_MAX << lanes : UINT64_C(1) << (select - 4);
+      uint64_t flags = 2 | (seed ? 0x8d5 : 0);
+      cases[row].run(out + 1, a, b, old, mask, flags, profiles[profile]);
+      const uint8_t *first = cases[row].legacy && cases[row].alias ? b : a;
+      independent_madd(packed, first, b, cases[row].width, cases[row].bytes);
+      const uint8_t *previous = cases[row].legacy ? b :
+                                cases[row].alias == 0 ? a : cases[row].alias == 1 ? b : old;
+      for (int i = 0; i < 64; ++i) {
+        uint8_t value = cases[row].width == 8 ? 0xc3 : cases[row].legacy ? previous[i] : 0;
+        if (i < cases[row].width) {
+          value = packed[i];
+          if (cases[row].masking && !(mask >> (i / (cases[row].bytes * 2)) & 1))
+            value = cases[row].masking == 2 ? 0 : previous[i];
+        }
+        want[i + 1] = value;
+      }
+
+      uint64_t actualFlags;
+      uint32_t actualCSR;
+      memcpy(&actualFlags, out + 65, 8);
+      memcpy(&actualCSR, out + 73, 4);
+      memcpy(want + 65, out + 65, 12);
+      ++observations;
+      if ((actualFlags & 0x8d5) != (flags & 0x8d5) || actualCSR != profiles[profile] ||
+          memcmp(out, want, sizeof(out)) || memcmp(a, beforeA, 64) ||
+          memcmp(b, beforeB, 64) || memcmp(old, beforeOld, 64)) {
+        fprintf(stderr, "MADD row%u sample%u width%d bytes%d source%d alias%d mask%llx flags%llx csr%x\n",
+                row, sample, cases[row].width, cases[row].bytes, cases[row].source,
+                cases[row].alias, (unsigned long long)mask, (unsigned long long)actualFlags, actualCSR);
+        for (unsigned i = 0; i < sizeof(out); ++i)
+          if (out[i] != want[i]) fprintf(stderr, "byte%u got%u want%u\n", i, out[i], want[i]);
+        return 1;
+      }
+    }
+  }
+  __asm__ volatile("ldmxcsr %0" :: "m"(saved));
+  printf("MADD kernels=%zu observations=%llu aliases64 sixFlags fullCSR canaries\n",
+         sizeof(cases) / sizeof(cases[0]), observations);
+  return 0;
+}
+`)
+	observations := 0
+	for _, row := range rows {
+		observations += (row.width/(row.inputBytes*2) + 4) * 32 * 4 * 2
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			ir := ir
+			if level == "-O2" {
+				ir = x86MulDivRoundOptimize(t, ir)
+			}
+			output := execution.compileAndRunLLVM(t, "madd-independent", ir, main.String(), level)
+			want := fmt.Sprintf("MADD kernels=%d observations=%d aliases64 sixFlags fullCSR canaries\n", len(rows), observations)
+			if string(output) != want {
+				t.Fatalf("incomplete MADD denominator: %q want %q", output, want)
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+	t.Log("software VEX/EVEX is not original native AVX/AVX512 execution")
+}
+
+func TestCrossLinuxRuntimeMatrixX86MADDTypedOriginalLegacy(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, table strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, row := range x86MADDOracleRows() {
+		if !row.legacy {
+			continue
+		}
+		name := fmt.Sprintf("original%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(out *[32]byte,a,b *[64]byte,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-36\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nSTMXCSR saved-4(SP)\nLDMXCSR csr+32(FP)\n", name)
+		move, bank := "MOVOU", "X"
+		if row.mmx {
+			move, bank = "MOVQ", "M"
+		}
+		fmt.Fprintf(&assembly, "%s (CX),%s0\n%s (DX),%s1\nPUSHQ flags+24(FP)\nPOPFQ\n", move, bank, move, bank)
+		instruction, destination := row.instruction()
+		fmt.Fprintf(&assembly, "%s\n%s %s,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,16(AX)\nSTMXCSR 24(AX)\n", instruction, move, destination)
+		if row.mmx {
+			assembly.WriteString("EMMS\n")
+		}
+		assembly.WriteString("LDMXCSR saved-4(SP)\nRET\n")
+		fmt.Fprintf(&table, "{%s,%d,%d,%d,-1},\n", name, row.width, row.inputBytes, row.alias)
+	}
+	// These accepted GP spellings encode MMX ModRM source banks. Initialize
+	// each physical M register independently; do not interpret GP contents as
+	// numeric MMX inputs or grant this source spelling LLVM admission.
+	for index, register := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		name := fmt.Sprintf("original%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(out *[32]byte,a,b *[64]byte,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-36\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nSTMXCSR saved-4(SP)\nLDMXCSR csr+32(FP)\n", name)
+		for bank := 0; bank < 8; bank++ {
+			fmt.Fprintf(&assembly, "MOVQ %d(CX),M%d\n", bank*8, bank)
+		}
+		assembly.WriteString("MOVQ (DX),M1\nPUSHQ flags+24(FP)\nPOPFQ\n")
+		fmt.Fprintf(&assembly, "PMADDWL %s,M1\nMOVQ M1,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,16(AX)\nSTMXCSR 24(AX)\nEMMS\nLDMXCSR saved-4(SP)\nRET\n", register)
+		fmt.Fprintf(&table, "{%s,8,2,0,%d},\n", name, index&7)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	tests := `package oracle
+import (
+ "testing"
+ "encoding/binary"
+ "runtime"
+ "unsafe"
+)
+
+var cases = []struct {
+ run func(*[32]byte, *[64]byte, *[64]byte, uint64, uint32)
+ width, bytes, alias, bank int
+}{
+` + table.String() + `}
+
+func aligned(storage *[128]byte) *[64]byte {
+ offset := int((-uintptr(unsafe.Pointer(&storage[0]))) & 63)
+ return (*[64]byte)(unsafe.Pointer(&storage[offset]))
+}
+
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ edges := [...]int32{0, 1, -1, 2, -2, 127, -128, 255, 256, -257, 32767, -32768, 16384, -16384}
+ profiles := []uint32{0x1f80, 0x3fc1, 0x5f82, 0x9fe5}
+ var aa, bb [128]byte
+ a, b := aligned(&aa), aligned(&bb)
+ observations := 0
+
+ for row, entry := range cases {
+  for sample := 0; sample < 32; sample++ {
+   for _, csr := range profiles {
+    for seed := 0; seed < 2; seed++ {
+     for i := range aa {
+      aa[i] = 0xa7
+      bb[i] = 0xb9
+     }
+     for i := 0; i < 64; i += entry.bytes {
+      x, y := edges[(sample+i*3)%14], edges[(sample+7+i*3)%14]
+      if sample >= 14 {
+       x = int32(sample*7919+i*104729)
+       y = int32(sample*7919+i*104729+7*65537)
+      }
+      a[i], b[i] = byte(x), byte(y)
+      if entry.bytes == 2 {
+       a[i+1], b[i+1] = byte(uint32(x)>>8), byte(uint32(y)>>8)
+      }
+     }
+     if entry.bytes == 2 && sample == 0 {
+      for i := 0; i < 64; i += 2 {
+       a[i] = 0
+       b[i] = 0
+       a[i+1] = 0x80
+       b[i+1] = 0x80
+      }
+     }
+     if entry.bytes == 1 && sample < 2 {
+      for i := range a {
+       a[i] = 0x7f
+       if sample == 1 {
+        a[i] = 0x80
+       }
+       b[i] = 0xff
+      }
+     }
+     beforeA, beforeB := aa, bb
+     var out, want [34]byte
+     for i := range out {
+      out[i] = 0xc3
+      want[i] = 0xc3
+     }
+
+     flags := uint64(2)
+     if seed != 0 {
+      flags |= 0x8d5
+     }
+     entry.run((*[32]byte)(unsafe.Pointer(&out[1])), a, b, flags, csr)
+     first := a[:]
+     if entry.alias == 1 {
+      first = b[:]
+     }
+     if entry.bank >= 0 {
+      first = a[entry.bank*8:]
+      if entry.bank == 1 {
+       first = b[:]
+      }
+     }
+     for i := 0; i < entry.width; i += entry.bytes * 2 {
+      var sum int64
+      if entry.bytes == 2 {
+       sum = int64(int16(binary.LittleEndian.Uint16(first[i:]))) * int64(int16(binary.LittleEndian.Uint16(b[i:]))) +
+             int64(int16(binary.LittleEndian.Uint16(first[i+2:]))) * int64(int16(binary.LittleEndian.Uint16(b[i+2:])))
+      } else {
+       sum = int64(int8(first[i]))*int64(b[i]) + int64(int8(first[i+1]))*int64(b[i+1])
+       if sum < -32768 {
+        sum = -32768
+       }
+       if sum > 32767 {
+        sum = 32767
+       }
+      }
+      for j := 0; j < entry.bytes * 2; j++ {
+       want[i+j+1] = byte(uint32(sum) >> uint(j*8))
+      }
+     }
+
+     actualFlags := binary.LittleEndian.Uint64(out[17:25])
+     actualCSR := binary.LittleEndian.Uint32(out[25:29])
+     copy(want[17:29], out[17:29])
+     observations++
+     if out != want || aa != beforeA || bb != beforeB || actualFlags&0x8d5 != flags&0x8d5 || actualCSR != csr {
+      t.Fatalf("original MADD row%d sample%d width%d bytes%d flags%x CSR%x got%x want%x",
+               row, sample, entry.width, entry.bytes, actualFlags, actualCSR, out, want)
+     }
+    }
+   }
+  }
+ }
+ t.Logf("original MADD kernels=%d observations=%d sixFlags fullCSR canaries", len(cases), observations)
+}
+`
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("original"))
+	command := exec.Command("go", "test", "-c", "-p=2", "-vet=off", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0", "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, executable, "-test.v", "-test.run=^TestOriginal$", "-test.count=1")
+	want := fmt.Sprintf("original MADD kernels=%d observations=%d sixFlags fullCSR canaries", count, count*32*4*2)
+	if !strings.Contains(string(output), want) || !strings.Contains(string(output), "--- PASS: TestOriginal") || strings.Contains(string(output), "SKIP") {
+		t.Fatalf("incomplete original-Go denominator: %q", output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+	t.Log("original SSE/MMX including all16 GP-to-MMX encoded bank spellings only; this gate does not execute VEX/EVEX")
+}
diff --git a/amd64_maddword_context_test.go b/amd64_maddword_context_test.go
new file mode 100644
index 000000000..9c639f082
--- /dev/null
+++ b/amd64_maddword_context_test.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import "testing"
+
+func TestX86WordMultiplyAddLegacyVirtualMemoryCannotProveAlignment(t *testing.T) {
+	for _, operand := range []string{"source+0(FP)", "(SP)", "(BP)"} {
+		for _, target := range x86RawReturnTargets {
+			source := "TEXT ·f(SB),4,$0-64\nPXOR X1,X1\nPMADDWL " + operand + ",X1\nRET\n"
+			declaration := "func f(source [64]byte)"
+			if operand != "source+0(FP)" {
+				source = x86OrdinaryBPNativeSource(target.arch, "f", "PMADDWL "+operand+",X1", operand, 0)
+				declaration = "func f(p *byte)"
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+operand+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					x86RequireOrdinaryBPNativeOutcome(t, target.arch, operand, ir, err)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_maddword_fault_runtime_test.go b/amd64_maddword_fault_runtime_test.go
new file mode 100644
index 000000000..2b4e0d3da
--- /dev/null
+++ b/amd64_maddword_fault_runtime_test.go
@@ -0,0 +1,118 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86WordMultiplyAddNativeMemoryStatus(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for i, row := range []struct {
+		instruction string
+		width       int
+	}{
+		{"PMADDWL (BX),X0", 16},
+		{"VPMADDWD.Z (BX),X0,K1,X1", 16},
+		{"VPMADDWD.Z (BX),Y0,K1,Y1", 32},
+		{"VPMADDWD.Z (BX),Z0,K1,Z1", 64},
+		{"PMADDUBSW (BX),X0", 16},
+		{"VPMADDUBSW.Z (BX),X0,K1,X1", 16},
+		{"VPMADDUBSW.Z (BX),Y0,K1,Y1", 32},
+		{"VPMADDUBSW.Z (BX),Z0,K1,Z1", 64},
+	} {
+		name := fmt.Sprintf("wordmaddfault%d", i)
+		// Deliberately discard the computed result. Sideeffect/volatile reads
+		// must remain after O2, even with the constant zero K mask.
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\nVPXORD Z0,Z0,Z0\nMOVL $0,CX\nKMOVQ CX,K1\n%s\nRET\n", name, row.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(const uint8_t*);\n", name)
+		reference := fmt.Sprintf("read%d", row.width)
+		if i == 0 {
+			reference = "originalPMADDWD"
+		} else if i == 4 {
+			reference = "originalPMADDUBSW"
+		}
+		fmt.Fprintf(&checks, "for(int offset=0;offset<16;++offset) if(compareStatus(%s,%s,memory+offset)) return 1;\n", reference, name)
+		fmt.Fprintf(&checks, "if(compareStatus(%s,%s,0) || compareStatus(%s,%s,boundary-%d+1) || compareStatus(%s,%s,boundary-%d)) return 1;\n", reference, name, reference, name, row.width, reference, name, row.width)
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + `
+__attribute__((noinline)) static void originalPMADDWD(const uint8_t *p) {
+ typedef int32_t V __attribute__((vector_size(16)));
+ V carrier={0,0,0,0};
+ // This is the original PMADDWD memory opcode, not MOVDQA plus PMADDWD.
+ __asm__ volatile("pmaddwd (%1),%0" : "+x"(carrier) : "r"(p) : "memory");
+}
+__attribute__((noinline)) static void originalPMADDUBSW(const uint8_t *p) {
+ typedef int32_t V __attribute__((vector_size(16)));
+ V carrier={0,0,0,0};
+ __asm__ volatile("pmaddubsw (%1),%0" : "+x"(carrier) : "r"(p) : "memory");
+}
+__attribute__((noinline)) static void read16(const uint8_t *p) {for(int i=0;i<16;++i) (void)((const volatile uint8_t*)p)[i];}
+__attribute__((noinline)) static void read32(const uint8_t *p) {for(int i=0;i<32;++i) (void)((const volatile uint8_t*)p)[i];}
+__attribute__((noinline)) static void read64(const uint8_t *p) {for(int i=0;i<64;++i) (void)((const volatile uint8_t*)p)[i];}
+typedef struct {int signal;int code;} Status;
+static int observe(void (*program)(const uint8_t*),const uint8_t *input,Status *out) {
+ pid_t child=fork(); if(child<0) return 1;
+ if(child==0) {
+  struct rlimit limit={0,0}; if(setrlimit(RLIMIT_CORE,&limit)) _exit(3);
+  program(input); _exit(0);
+ }
+ int status=0; if(waitpid(child,&status,0)!=child) return 1;
+ if(WIFSIGNALED(status)) {*out=(Status){WTERMSIG(status),0};return 0;}
+ if(WIFEXITED(status)) {*out=(Status){0,WEXITSTATUS(status)};return 0;}
+ return 1;
+}
+static int compareStatus(void (*original)(const uint8_t*),void (*translated)(const uint8_t*),const uint8_t *input) {
+ Status a,b;
+ if(observe(original,input,&a) || observe(translated,input,&b)) return 1;
+ if(a.signal!=b.signal || a.code!=b.code) {
+  fprintf(stderr,"input=%p mod16=%lu original=(%d,%d) translated=(%d,%d)\n",input,(unsigned long)((uintptr_t)input%16),a.signal,a.code,b.signal,b.code); return 1;
+ }
+ return 0;
+}
+int main(void) {
+ long page=sysconf(_SC_PAGESIZE); if(page<=0 || page%64) return 1;
+ uint8_t *memory=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(memory==MAP_FAILED) return 1;
+ memset(memory,0x83,(size_t)page);
+ if(mprotect(memory,(size_t)page,PROT_READ) || mprotect(memory+page,(size_t)page,PROT_NONE)) return 1;
+ uint8_t *boundary=memory+page;
+` + checks.String() + `
+ if(munmap(memory,(size_t)page*2)) return 1;
+ return 0;
+}
+`
+	for _, opt := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", opt), func(t *testing.T) {
+			text := ir
+			if opt {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "word-madd-read-status", triple, text, main, prefix)
+		})
+	}
+	t.Log("legacy exact opcode original/translated typed status at each mod16 and real guard-page boundaries; EVEX zero-mask full-read contract uses independent volatile reader, not unexecuted AVX512 hardware as oracle")
+}
diff --git a/amd64_maddword_forms.go b/amd64_maddword_forms.go
new file mode 100644
index 000000000..1e8b9ba00
--- /dev/null
+++ b/amd64_maddword_forms.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import "strings"
+
+// Go calls Intel's legacy PMADDWD instruction PMADDWL. The raw decoder keeps
+// that canonical spelling. ymm supplies MMX/m64 and X/m128; _yvandnpd supplies
+// all VEX/EVEX widths. Each VPMADDWD row permits zeroing, never broadcasting.
+var x86WordMultiplyAddSpecs = map[Op]x86PackedBinarySpec{
+	"PMADDWL":  {encoding: x86PackedLogicalLegacyInteger},
+	"VPMADDWD": {encoding: x86PackedLogicalVEXOrEVEX, zeroing: true},
+}
+
+type x86PackedMultiplyAddSpec struct {
+	x86PackedBinarySpec
+	inputBits, outputBits int
+	nativeOpcode          string
+}
+
+var x86PackedMultiplyAddSpecs = map[Op]x86PackedMultiplyAddSpec{
+	"PMADDWL":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, 32, "pmaddwd"},
+	"PMADDUBSW": {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 8, 16, "pmaddubsw"},
+	"VPMADDWD":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, 32, ""},
+	"VPMADDUBSW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true},
+		8, 16, ""},
+}
+
+type x86PackedMultiplyAddForm = x86PackedPhysicalForm
+
+// This describes Go's actual ymm/yxm_q4/_yvandnpd operand rows only. WIG
+// and the decoder's private physical marker do not grant a native address,
+// initialized input, caller frame, or a new MMX transport.
+func x86PackedMultiplyAddProperties(op Op, ins Instr, arch string) (x86PackedMultiplyAddForm, bool, error) {
+	return x86PackedPhysicalProperties(op, ins, arch, x86PackedMultiplyAdd)
+}
+
+func x86WordMultiplyAddProperties(ins Instr, goarch string) (x86PackedBinaryForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	_, recognized := x86WordMultiplyAddSpecs[Op(base)]
+	if !recognized {
+		return x86PackedBinaryForm{}, false, nil
+	}
+	// Keep this word-only consumer boundary for the existing frame proof.
+	form, known, err := x86PackedMultiplyAddProperties(ins.Op, ins, goarch)
+	return form.x86PackedBinaryForm, known, err
+}
diff --git a/amd64_maddword_forms_test.go b/amd64_maddword_forms_test.go
new file mode 100644
index 000000000..281dda3cf
--- /dev/null
+++ b/amd64_maddword_forms_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86WordMaddFormats(arch string) []string {
+	rows := []string{"PMADDWL X0,X7", "PMADDWL (AX),X7"}
+	if arch == "amd64" {
+		rows = append(rows, "PMADDWL M0,M7", "PMADDWL (AX),M7", "PMADDWL source+0(FP),M7", "PMADDWL X15,X0", "PMADDWL X7,X7", "PMADDWL (FS),X1", "PMADDWL (GS),X1", "PMADDWL data(SB),X1")
+	}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, source := range []string{bank + "0", "16(AX)(BX*2)", "source+0(FP)"} {
+			rows = append(rows, fmt.Sprintf("VPMADDWD %s,%s1,%s7", source, bank, bank))
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("VPMADDWD %s,%s31,K1,%s30", source, bank, bank), fmt.Sprintf("VPMADDWD.Z %s,%s31,K7,%s30", source, bank, bank))
+			}
+		}
+		if arch == "amd64" {
+			rows = append(rows, fmt.Sprintf("VPMADDWD %s31,%s30,%s29", bank, bank, bank))
+		}
+	}
+	return rows
+}
+
+func x86WordMaddFPType(t *testing.T) FuncSig {
+	t.Helper()
+	pkg := mustGoPackage(t, "oracle", "package oracle\nfunc f(source [64]byte)\n")
+	sig, err := DeriveGoFuncABI0Signature("f", pkg.Types.Scope().Lookup("f").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sig.Frame.Params) != 64 {
+		t.Fatalf("actual Go 64-byte field layout changed: %+v", sig.Frame)
+	}
+	return sig
+}
+
+func TestX86WordMultiplyAddActualGoCompleteAttributes(t *testing.T) {
+	if len(x86WordMultiplyAddSpecs) != 2 {
+		t.Fatal("word multiply-add family must contain exactly the two Go spellings")
+	}
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "{APMADDWL, ymm, Py1, opBytes{0xf5, Pe, 0xf5}}") {
+		t.Fatal("actual Go legacy ymm registration changed")
+	}
+	start := strings.Index(string(avx), "{as: AVPMADDWD,")
+	if start < 0 {
+		t.Fatal("actual Go omits VPMADDWD")
+	}
+	row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+	if !strings.Contains(row, "ytab: _yvandnpd") || strings.Contains(row, "Bcst") || strings.Contains(row, "Sae") {
+		t.Fatalf("actual Go operand attributes changed: %s", row)
+	}
+	for _, width := range []string{"vex128", "vex256"} {
+		if !strings.Contains(row, "avxEscape | "+width+" | vex66 | vex0F | vexW0, 0xF5") {
+			t.Fatalf("actual Go VEX attribute missing: %s", width)
+		}
+	}
+	for i, width := range []string{"evex128", "evex256", "evex512"} {
+		if !strings.Contains(row, fmt.Sprintf("avxEscape | %s | evex66 | evex0F | evexW0, evexN%d | evexZeroingEnabled, 0xF5", width, 16<<i)) {
+			t.Fatalf("actual Go EVEX attribute missing: %s", width)
+		}
+	}
+}
+
+func TestX86WordMultiplyAddCompleteFormsFiveTargetsTextModuleAndO2(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		var source, declarations strings.Builder
+		sigs := map[string]FuncSig{}
+		for i, row := range x86WordMaddFormats(arch) {
+			name := fmt.Sprintf("wordmadd%d", i)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-64\n%s\nRET\n", name, row)
+			fmt.Fprintf(&declarations, "func %s(source [64]byte)\n", name)
+			sig := x86WordMaddFPType(t)
+			sig.Name = name
+			sigs[name] = sig
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Run(triple, func(t *testing.T) {
+			// An FP parameter supplies only its actual bytes. It cannot supply
+			// untouched vectors, an address, a mask or a closed MMX region.
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original format source acquired missing inputs or physical state", api, err)
+				}
+			}
+			before := fmt.Sprintf("%#v %#v", file, sigs)
+			ir := x86ScalarFormatObjectUnit(t, file, sigs, arch, triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+			if before != fmt.Sprintf("%#v %#v", file, sigs) {
+				t.Fatal("format object emitter mutated original source or signatures")
+			}
+			t.Log("original rows retain Go objects, three public Context checks and emitter-only objects; initialized caller/MMX owners are separate")
+		})
+	}
+}
+
+func TestX86WordMultiplyAddIdentityAndMalformedBeforeEmission(t *testing.T) {
+	for _, row := range []string{"PMADDWL M0,M1", "PMADDWL X0,X1", "VPMADDWD Y0,Y1,Y2", "VPMADDWD.Z Z0,Z1,K1,Z2"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(string(ins.Op))), "UNKNOWN", "PMADDWL.Z", "VPMADDWD.SAE", "PMADDWL", "VPMADDWD"} {
+			local := ins
+			local.Op = identity
+			beforeIns := local
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			known, term, err := ctx.lowerPackedWordMultiplyAdd(ins.Op, local)
+			bad := identity != "" && strings.ToUpper(string(identity)) != strings.ToUpper(string(ins.Op))
+			if !known || term || (err != nil) != bad || bad && out.String() != before || !reflect.DeepEqual(local, beforeIns) {
+				t.Fatalf("%s/%s identity: %t/%t/%v", row, identity, known, term, err)
+			}
+		}
+	}
+	for _, row := range []string{"PMADDWD X0,X1", "PMADDWL X0", "PMADDWL X0,Y1", "PMADDWL X16,X0", "PMADDWL X0,M0", "PMADDWL.Z X0,X1", "PMADDWL $data(SB),X0", "VPMADDWD X0,X1", "VPMADDWD X0,Y1,Y2", "VPMADDWD Z0,Z1,(AX)", "VPMADDWD.BCST (AX),Z0,Z1", "VPMADDWD.SAE Z0,Z1,Z2", "VPMADDWD.Z X0,X1,X2", "VPMADDWD X0,X1,K0,X2", "VPMADDWD (AX)(SP*2),X0,X1", "VPMADDWD 2147483648(AX),X0,X1"} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			_, _, err = ctx.lowerPackedWordMultiplyAdd(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+			if row != "PMADDWD X0,X1" && (err == nil || out.String() != before) {
+				t.Fatalf("malformed form emitted IR: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86WordMultiplyAdd386HighRegistersNeedPhysicalContext(t *testing.T) {
+	for _, bank := range []string{"X", "Y"} {
+		for _, index := range []int{8, 15, 16, 31} {
+			for operand := 0; operand < 3; operand++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[operand] = fmt.Sprintf("%s%d", bank, index)
+				row := "VPMADDWD " + strings.Join(args, ",")
+				requireX86GoAssemblerResult(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", true)
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, _, err := x86WordMultiplyAddProperties(file.Funcs[0].Instrs[1], "386"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("mode32 high bank became physical permission: %s: %v", row, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86WordMultiplyAdd386HighRegisterActualByteIdentities(t *testing.T) {
+	for _, bank := range []string{"X", "Y"} {
+		for _, high := range []int{16, 31} {
+			for operand := 0; operand < 3; operand++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[operand] = fmt.Sprintf("%s%d", bank, high)
+				row := "VPMADDWD " + strings.Join(args, ",")
+				listing, err := x86ExtensionGoListing(t, "386", row)
+				if err != nil {
+					t.Fatalf("actual Go mode32 object: %v\n%s", err, listing)
+				}
+				var code []byte
+				for _, line := range strings.Split(listing, "\n") {
+					fields := strings.Fields(line)
+					if len(fields) < 7 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+						continue
+					}
+					for _, field := range fields[1:7] {
+						value, err := strconv.ParseUint(field, 16, 8)
+						if err != nil {
+							t.Fatal(err)
+						}
+						code = append(code, byte(value))
+					}
+					break
+				}
+				ins, length, recognized, err := decodedX86EVEXPackedMADDInstruction(code, 64)
+				if len(code) != 6 || !recognized || err != nil || length != 6 || ins.Op != "VPMADDWD" || len(ins.Args) != 3 {
+					t.Fatalf("actual EVEX byte identity %s/%x: %+v/%d/%t/%v", row, code, ins, length, recognized, err)
+				}
+				for i, argument := range args {
+					if ins.Args[i].Reg != Reg(argument) {
+						t.Fatalf("%s/%x argument %d = %s != %s", row, code, i, ins.Args[i].Reg, argument)
+					}
+				}
+				if _, _, recognized, err := decodedX86EVEXPackedMADDInstruction(code, 32); !recognized || err == nil {
+					t.Fatalf("raw mode32 high bank obtained false permission: %s/%x", row, code)
+				}
+				t.Logf("%s actual Go bytes=%x; mode64 identities exact, mode32 rejected", row, code)
+			}
+		}
+	}
+}
+
+func TestX86WordMultiplyAdd386GoRejectedHighZFormsRemainRejected(t *testing.T) {
+	// Unlike the X/Y encoder anomaly, Go rejects high Z in mode32. Keep the
+	// actual original source as a negative; do not call it accepted syntax.
+	for _, high := range []int{8, 15, 16, 31} {
+		for index := 0; index < 3; index++ {
+			args := []string{"Z0", "Z1", "Z2"}
+			args[index] = fmt.Sprintf("Z%d", high)
+			source := "TEXT f(SB),4,$0-0\nVPMADDWD " + strings.Join(args, ",") + "\nRET\n"
+			requireX86GoAssemblerResult(t, "386", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); err == nil {
+				t.Fatalf("Go-rejected mode32 high Z obtained physical permission: %s", source)
+			}
+		}
+	}
+}
+
+func TestX86WordMultiplyAddIndependentFPFieldsAndMissingBytes(t *testing.T) {
+	for _, row := range []string{"PMADDWL source+0(FP),M1", "VPMADDWD source+0(FP),X1,X2", "VPMADDWD source+0(FP),Y1,Y2", "VPMADDWD.Z source+0(FP),Z1,K1,Z2"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86WordMultiplyAddProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for missing := -1; missing < form.memoryBytes; missing++ {
+			sig := x86WordMaddFPType(t)
+			if missing >= 0 {
+				sig.Frame.Params = append(sig.Frame.Params[:missing], sig.Frame.Params[missing+1:]...)
+			}
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := out.String()
+			_, _, err := ctx.lowerPackedWordMultiplyAdd(ins.Op, ins)
+			if missing < 0 {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil || out.String() != before {
+				t.Fatalf("%s missing FP byte%d emitted or invented backing: %v", row, missing, err)
+			}
+		}
+	}
+}
diff --git a/amd64_maddword_go_oracle_test.go b/amd64_maddword_go_oracle_test.go
new file mode 100644
index 000000000..0704e0bc3
--- /dev/null
+++ b/amd64_maddword_go_oracle_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86WordMultiplyAddOriginalGoBits(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+import "testing"
+func signed(p []byte) int64 { v:=int64(uint16(p[0])|uint16(p[1])<<8); if v>=32768 {v-=65536};return v }
+func TestOriginalPairWrap(t *testing.T) {
+ var patterns [8][16]byte
+ state:=uint32(0x12345678)
+ for p:=range patterns {for i:=range patterns[p] {state=state*1664525+1013904223;patterns[p][i]=byte(state>>24)}}
+ for i:=0;i<16;i+=2 {patterns[0][i]=0;patterns[0][i+1]=0x80;patterns[1][i]=0;patterns[1][i+1]=0x80}
+ for i:=range patterns[2] {patterns[2][i]=0xff}
+`)
+	count := 0
+	for _, bank := range []string{"X", "M"} {
+		forms := []string{"register"}
+		if bank == "M" {
+			forms = append(forms, "memory")
+		}
+		for _, form := range forms {
+			name := fmt.Sprintf("wordmadd%d", count)
+			count++
+			fmt.Fprintf(&declarations, "func %s(a,b,out *byte,csr uint32)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),CX\n", name)
+			move, width := "MOVOU", 16
+			if bank == "M" {
+				move, width = "MOVQ", 8
+			}
+			fmt.Fprintf(&assembly, "%s (BX),%s0\n", move, bank)
+			first := "(AX)"
+			if form == "register" {
+				first = bank + "1"
+				fmt.Fprintf(&assembly, "%s (AX),%s1\n", move, bank)
+			}
+			fmt.Fprintf(&assembly, "CMPQ AX,AX\nSTC\nPMADDWL %s,%s0\n%s %s0,(CX)\nSETCS 16(CX)\nSETNE 17(CX)\nSTMXCSR 18(CX)\n", first, bank, move, bank)
+			if bank == "M" {
+				assembly.WriteString("EMMS\n")
+			}
+			assembly.WriteString("LDMXCSR saved-4(SP)\nRET\n")
+			fmt.Fprintf(&tests, `
+ for _,a:=range patterns {for _,b:=range patterns {for mode:=0;mode<4;mode++ {
+  var out [24]byte;for i:=range out {out[i]=0xc3}
+  csr:=uint32(0x1f80|mode<<13|mode)
+  %[1]s(&a[0],&b[0],&out[1],csr)
+  if out[0]!=0xc3 || out[23]!=0xc3 || out[17]!=1 || out[18]!=0 {t.Fatalf("%[1]s flags/canary: %%x",out)}
+  gotCSR:=uint32(out[19])|uint32(out[20])<<8|uint32(out[21])<<16|uint32(out[22])<<24
+  if gotCSR!=csr {t.Fatalf("%[1]s CSR %%x != %%x",gotCSR,csr)}
+  for i:=0;i<%[2]d;i+=4 {
+   want:=uint32(signed(a[i:])*signed(b[i:])+signed(a[i+2:])*signed(b[i+2:]))
+   for j:=0;j<4;j++ {if out[i+j+1]!=byte(want>>uint(8*j)) {t.Fatalf("%[1]s pair %%d got %%x want %%x",i,out,want)}}
+  }
+  for i:=%[2]d;i<16;i++ {if out[i+1]!=0xc3 {t.Fatalf("%[1]s touched upper MMX bytes")}}
+ }}}
+`, name, width)
+		}
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go signed-pair oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d actual original SSE/MMX Go functions × 256 independent signed-pair/CSR/flags/canary cases", count)
+}
diff --git a/amd64_maddword_runtime_test.go b/amd64_maddword_runtime_test.go
new file mode 100644
index 000000000..155050bf2
--- /dev/null
+++ b/amd64_maddword_runtime_test.go
@@ -0,0 +1,230 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+const x86WordMaddIndependentRuntimeOracle = `
+static uint8_t patterns[8][64];
+static const uint64_t masks[]={0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+static int32_t word(const uint8_t *p) {
+ uint32_t bits=(uint32_t)p[0]|(uint32_t)p[1]<<8;
+ return bits<32768 ? (int32_t)bits : (int32_t)bits-65536;
+}
+__attribute__((noinline)) static int checkMadd(
+ void (*program)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t),
+ const char *name,int width,int mode,int legacy,int destination,int shift) {
+ for(int round=0;round<8;++round) for(int m=0;m<4;++m) {
+  _Alignas(64) uint8_t aStorage[96],bStorage[96],output[68];
+  uint8_t *a=aStorage+shift,*b=bStorage+3;
+  memset(aStorage,0xa7,sizeof(aStorage)); memset(bStorage,0xb9,sizeof(bStorage));
+  memset(output,0xc3,sizeof(output));
+  memcpy(a,patterns[round],64); memcpy(b,patterns[(round+1)%8],64);
+  uint64_t mask=masks[m];
+  uint32_t saved,before=0x1f80|((round%4)<<13)|round,after;
+  __asm__ volatile("stmxcsr %0" : "=m"(saved));
+  __asm__ volatile("ldmxcsr %0" : : "m"(before));
+  program(output+1,a,b,mask);
+  __asm__ volatile("stmxcsr %0" : "=m"(after));
+  __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+  if(after!=before || output[0]!=0xc3 || output[67]!=0xc3 || output[65]!=1 || output[66]!=0) {
+   fprintf(stderr,"%s round=%d CSR/flags/canary failure\n",name,round); return 1;
+  }
+  for(int i=0;i<64;i+=4) {
+   // Widen independently to signed int64 before summing. Conversion to
+   // uint32 implements the specified pair wrap, including 0x80000000.
+   uint32_t result=(uint32_t)((int64_t)word(a+i)*word(b+i)+(int64_t)word(a+i+2)*word(b+i+2));
+   const uint8_t *old=destination==1 ? a : b;
+   int active=mode==0 || ((mask>>(i/4))&1);
+   for(int j=0;j<4;++j) {
+    uint8_t want=i<width ? (active ? (uint8_t)(result>>(j*8)) : (mode==2 ? 0 : old[i+j])) : (legacy ? b[i+j] : 0);
+    if(output[i+j+1]!=want) {
+     fprintf(stderr,"%s round=%d mask=%llx byte=%d got=%x want=%x\n",name,round,(unsigned long long)mask,i+j,output[i+j+1],want); return 1;
+    }
+   }
+  }
+  for(int i=0;i<96;++i) {
+   if((i<shift || i>=shift+64) && aStorage[i]!=0xa7) return 1;
+   if((i<3 || i>=67) && bStorage[i]!=0xb9) return 1;
+  }
+  if(memcmp(a,patterns[round],64) || memcmp(b,patterns[(round+1)%8],64)) return 1;
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86WordMultiplyAddCompleteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, legacy := range []bool{true, false} {
+		widths := []int{16}
+		if !legacy {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, memory := range []bool{false, true} {
+				for mode := 0; mode < 3; mode++ {
+					if legacy && mode != 0 {
+						continue
+					}
+					for destination := 0; destination < 3; destination++ {
+						if legacy && destination != 0 {
+							continue
+						}
+						name := fmt.Sprintf("wordmadd%d", count)
+						count++
+						first := bank + "1"
+						if memory {
+							first = "(BX)"
+						}
+						row := "PMADDWL " + first + ",X0"
+						if !legacy {
+							opcode := "VPMADDWD"
+							if mode == 2 {
+								opcode += ".Z"
+							}
+							row = opcode + " " + first + "," + bank + "0"
+							if mode != 0 {
+								row += ",K1"
+							}
+							row += fmt.Sprintf(",%s%d", bank, destination)
+						}
+						fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (CX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nCMPQ AX,AX\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", name, row, destination)
+						sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+						}}}
+						fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+						shift := 1
+						if legacy && memory {
+							shift = 16
+						}
+						fmt.Fprintf(&checks, "if(checkMadd(%s,\"%s\",%d,%d,%d,%d,%d)) return 1;\n", name, name, width, mode, x86FloatAddSubBoolInt(legacy), destination, shift)
+					}
+				}
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n" + declarations.String() + x86WordMaddIndependentRuntimeOracle + `
+int main(void) {
+ uint32_t state=0x12345678;
+ for(int p=0;p<8;++p) for(int i=0;i<64;++i) {state=state*1664525+1013904223; patterns[p][i]=(uint8_t)(state>>24);}
+ // Explicit signed extrema and the unique overflowing pair, not merely random data.
+ memset(patterns[0],0,64); memset(patterns[1],0,64);
+ for(int i=1;i<64;i+=2) {patterns[0][i]=0x80;patterns[1][i]=0x80;}
+ memset(patterns[2],0xff,64);
+ for(int i=0;i<64;i+=2) {patterns[3][i]=0xff;patterns[3][i+1]=0x7f;}
+` + checks.String() + "return 0;\n}\n"
+	for _, opt := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", opt), func(t *testing.T) {
+			text := ir
+			if opt {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "word-madd", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d opcode/width/memory/mask/alias programs × 32 signed-pair/MXCSR/flags/canary cases at O0 and O2; translated wide-vector execution is not native AVX512 evidence", count)
+}
+
+func x86WordMaddLogicalFPAssembly(name string, width, mode int) string {
+	bank := map[int]string{8: "M", 16: "X", 32: "Y", 64: "Z"}[width]
+	row := "PMADDWL source+0(FP),M1"
+	load, store := "MOVQ (AX),M1", "MOVQ M1,(AX)\nEMMS"
+	if width != 8 {
+		row = "VPMADDWD source+0(FP)," + bank + "1"
+		if mode == 2 {
+			row = strings.Replace(row, "VPMADDWD ", "VPMADDWD.Z ", 1)
+		}
+		if mode != 0 {
+			row += ",K1"
+		}
+		row += "," + bank + "1"
+		load = "VMOVUPS (AX),Z1"
+		store = "VMOVUPS " + bank + "1,(AX)"
+	}
+	return fmt.Sprintf("TEXT %s(SB),4,$0-80\nMOVQ out+64(FP),AX\nMOVQ mask+72(FP),DX\nKMOVQ DX,K1\n%s\n%s\n%s\nRET\n", name, load, row, store)
+}
+
+func TestCrossLinuxRuntimeMatrixX86WordMultiplyAddLogicalFPFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var definitions, wrappers, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, width := range []int{8, 16, 32, 64} {
+		for mode := 0; mode < 3; mode++ {
+			if width == 8 && mode != 0 {
+				continue
+			}
+			name := fmt.Sprintf("wordmaddfp%d", index)
+			index++
+			declaration := fmt.Sprintf("func %s(source [64]byte,out *byte,mask uint64)\n", name)
+			pkg := mustGoPackage(t, "oracle", "package oracle\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs[name] = sig
+			definitions.WriteString(x86WordMaddLogicalFPAssembly(name, width, mode))
+			fmt.Fprintf(&wrappers, "define void @check_%s(ptr %%input,ptr %%output,i64 %%mask){\n", name)
+			packed := "poison"
+			for i := 0; i < 64; i++ {
+				fmt.Fprintf(&wrappers, " %%address%d=getelementptr i8,ptr %%input,i64 %d\n %%byte%d=load i8,ptr %%address%d,align 1\n %%pack%d=insertvalue [64 x i8] %s,i8 %%byte%d,%d\n", i, i, i, i, i, packed, i, i)
+				packed = fmt.Sprintf("%%pack%d", i)
+			}
+			fmt.Fprintf(&wrappers, " call void @%s([64 x i8] %s,ptr %%output,i64 %%mask)\n ret void\n}\n", name, packed)
+			fmt.Fprintf(&declarations, "extern void check_%s(const uint8_t*,uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&checks, `
+ for(int round=0;round<16;++round) for(unsigned m=0;m<4;++m) {
+  uint8_t input[66],output[66];memset(input,0xa7,66);memset(output,0xc3,66);
+  for(int i=0;i<64;++i) input[i+1]=(uint8_t)(i*17+round*31);
+  for(int i=0;i<64;i+=2) {output[i+1]=1;output[i+2]=0;}
+  check_%[1]s(input+1,output+1,masks[m]);
+  for(int i=0;i<64;i+=4) {
+   int32_t pair=word(input+i+1)+word(input+i+3);
+   int active=%[2]d==0 || ((masks[m]>>(i/4))&1);
+   uint32_t want=i<%[3]d ? (active ? (uint32_t)pair : (%[2]d==2 ? 0 : UINT32_C(0x00010001))) : UINT32_C(0x00010001);
+   for(int j=0;j<4;++j) if(output[i+j+1]!=(uint8_t)(want>>(8*j))) return 1;
+  }
+  if(input[0]!=0xa7 || input[65]!=0xa7 || output[0]!=0xc3 || output[65]!=0xc3) return 1;
+  for(int i=0;i<64;++i) if(input[i+1]!=(uint8_t)(i*17+round*31)) return 1;
+ }
+`, name, mode, width)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", definitions.String(), true)
+	file, err := Parse(ArchAMD64, definitions.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86WordMaddIndependentRuntimeOracle + "int main(void){\n" + checks.String() + "return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir + wrappers.String()
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "word-madd-logical-fp", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d logical FP programs × 64 independent signed-pair cases; signatures derived from actual Go [64]byte declarations; explicit LLVM array carrier is not native stack/alignment or MMX tag proof", index)
+}
diff --git a/amd64_mask_blend_forms.go b/amd64_mask_blend_forms.go
new file mode 100644
index 000000000..151f99c22
--- /dev/null
+++ b/amd64_mask_blend_forms.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86MaskBlendForm struct {
+	x86PackedBinaryForm
+	spec amd64MaskBlendSpec
+}
+
+func x86MaskBlendProperties(op Op, ins Instr, arch string) (x86MaskBlendForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64MaskBlendSpecs[Op(base)]
+	result := x86MaskBlendForm{spec: spec}
+	if !known {
+		return result, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return result, true, fmt.Errorf("mask blend dispatch/source opcode mismatch")
+	}
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, zeroing: true}
+	if spec.broadcast {
+		grammar.broadcastBytes = spec.laneBits / 8
+	}
+	local := ins
+	local.Op = op
+	var err error
+	// This shared validator describes only Go's operand and address grammar;
+	// numerical bytes and native storage remain separate consumer obligations.
+	result.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, grammar, false)
+	return result, true, err
+}
+
+// The K operand selects between two sources; it is not an old-destination
+// merge. No mask selects only the first Plan 9 source, and .Z drops the second.
+func x86TypedMaskBlendByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86MaskBlendProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+		if !form.zeroing {
+			effect.operands = append(effect.operands,
+				x86TypedByteOperand{index: form.second, operand: ins.Args[form.second], width: width, read: true})
+		}
+	}
+	return effect, true, nil
+}
diff --git a/amd64_mask_logical_grammar_test.go b/amd64_mask_logical_grammar_test.go
new file mode 100644
index 000000000..826abd279
--- /dev/null
+++ b/amd64_mask_logical_grammar_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86MaskLogicalIndependentEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, oracle := range x86MaskLogicalOracle() {
+		stem := oracle.op[:len(oracle.op)-1]
+		opcode := map[string]string{
+			"KAND": "0x41", "KANDN": "0x42", "KOR": "0x45", "KXNOR": "0x46",
+			"KXOR": "0x47", "KNOT": "0x44", "KTEST": "0x99", "KORTEST": "0x98",
+		}[stem]
+		table, length, classes := "_ykaddb", "vex256", []string{"Yk", "Yk", "Yk"}
+		if len(strings.Split(oracle.operands, ",")) == 2 {
+			table, length, classes = "_yknotb", "vex128", []string{"Yk", "Yk"}
+		}
+		prefix, w := "", "vexW0"
+		switch oracle.op[len(oracle.op)-1] {
+		case 'B':
+			prefix = " | vex66"
+		case 'D':
+			prefix, w = " | vex66", "vexW1"
+		case 'Q':
+			w = "vexW1"
+		}
+		bytes := []string{fmt.Sprintf("avxEscape | %s%s | vex0F | %s", length, prefix, w), opcode}
+		found := 0
+		for _, row := range rules {
+			if row.Opcode != oracle.op {
+				continue
+			}
+			if row.Ytab != table || row.Prefix != "Pavx" || row.RowIndex != 0 || row.EncodingOffset != 0 ||
+				row.ZCase != "Zvex_rm_v_r" || row.ZOffset != 2 ||
+				!reflect.DeepEqual(row.Classes, classes) || !reflect.DeepEqual(row.OpBytes, bytes) {
+				t.Fatalf("complete mask encoding row changed: %+v", row)
+			}
+			found++
+		}
+		if found != 1 {
+			t.Fatal("missing or additional mask encoding row", oracle.op, found)
+		}
+		count += found
+	}
+	if count != 32 || len(amd64MaskLogicalSpecs) != 32 {
+		t.Fatal("complete mask family inventory changed", count, len(amd64MaskLogicalSpecs))
+	}
+}
+
+func TestX86MaskLogicalLowererDispatchIdentity(t *testing.T) {
+	for _, row := range x86MaskLogicalOracle() {
+		t.Run(row.op, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.op+" "+row.operands)
+			ctx, ir := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			ctx.goarch = "amd64"
+			if err := ctx.lowerMaskLogical(ins.Op, ins); err != nil {
+				t.Fatal("matching source did not reach the actual emitter", err)
+			}
+			ir.Reset()
+			ins.Op = "MOVQ"
+			if err := ctx.lowerMaskLogical(Op(row.op), ins); err == nil || ir.Len() != 0 {
+				t.Fatal("mismatched source reached mask lowering", err)
+			}
+		})
+	}
+}
diff --git a/amd64_mask_move_dispatch_test.go b/amd64_mask_move_dispatch_test.go
new file mode 100644
index 000000000..a21fff65a
--- /dev/null
+++ b/amd64_mask_move_dispatch_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64MaskMoveDispatchBindsCompleteFamily(t *testing.T) {
+	// The internal lowerer takes the dispatched opcode separately. Older
+	// helper callers intentionally leave Instr.Op unset; parsed instructions
+	// retain their own opcode. Both must use the same complete _ykmovb grammar.
+	forms := []struct {
+		name string
+		src  Operand
+		dst  Operand
+	}{
+		{"mask_to_mask", Operand{Kind: OpReg, Reg: "K1"}, Operand{Kind: OpReg, Reg: "K2"}},
+		{"mask_to_gp", Operand{Kind: OpReg, Reg: "K1"}, Operand{Kind: OpReg, Reg: AX}},
+		{"gp_to_mask", Operand{Kind: OpReg, Reg: AX}, Operand{Kind: OpReg, Reg: "K2"}},
+		{"mask_to_memory", Operand{Kind: OpReg, Reg: "K1"}, Operand{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}},
+		{"memory_to_mask", Operand{Kind: OpMem, Mem: MemRef{Base: BX, Off: 8}}, Operand{Kind: OpReg, Reg: "K2"}},
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []Op{"KMOVB", "KMOVW", "KMOVD", "KMOVQ"} {
+			for _, form := range forms {
+				for _, instructionOp := range []Op{"", op, Op(strings.ToLower(string(op)))} {
+					name := fmt.Sprintf("%s/%s/%s/op=%q", arch, op, form.name, instructionOp)
+					t.Run(name, func(t *testing.T) {
+						ins := Instr{Op: instructionOp, Args: []Operand{form.src, form.dst}}
+						registered := ins
+						registered.Op = op
+						c, _ := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{registered}}, FuncSig{Ret: Void}, nil)
+						c.goarch = arch
+						if ok, terminated, err := c.lowerVec(op, ins); !ok || terminated || err != nil {
+							t.Fatalf("lowerVec = (%v, %v, %v)", ok, terminated, err)
+						}
+						if ins.Op != instructionOp {
+							t.Fatal("dispatch mutated its caller's instruction")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestAMD64MaskMoveDispatchRejectsContradictoryIdentity(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		dispatch Op
+		source   Op
+	}{
+		{"different_width", "KMOVB", "KMOVQ"},
+		{"different_family", "KMOVB", "MOVQ"},
+		{"unregistered_suffix", "KMOVB", "KMOVB.Z"},
+		{"unknown_source", "KMOVB", "UNKNOWN"},
+		{"unknown_dispatch", "UNKNOWN", "KMOVB"},
+		{"both_unknown", "UNKNOWN", ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			ins := Instr{Op: tc.source, Args: []Operand{{Kind: OpReg, Reg: "K1"}, {Kind: OpReg, Reg: "K2"}}}
+			c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			before := output.String()
+			if err := c.lowerMaskMove(tc.dispatch, ins); err == nil {
+				t.Fatal("accepted an unknown or contradictory mask-move opcode")
+			}
+			if output.String() != before {
+				t.Fatal("invalid opcode emitted IR before rejection")
+			}
+		})
+	}
+}
diff --git a/amd64_mask_vector_forms.go b/amd64_mask_vector_forms.go
new file mode 100644
index 000000000..6168ba7cb
--- /dev/null
+++ b/amd64_mask_vector_forms.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86MaskVectorSpec struct {
+	laneBits     int
+	maskToVector bool
+}
+
+// Go's complete _yvpbroadcastmb2q/_yvpmovb2m rows are EVEX register-only
+// moves. K0 is data, not the absence of writemasking; no suffix is permitted.
+var x86MaskVectorSpecs = map[Op]x86MaskVectorSpec{
+	"VPMOVM2B": {8, true}, "VPMOVM2W": {16, true},
+	"VPMOVM2D": {32, true}, "VPMOVM2Q": {64, true},
+	"VPMOVB2M": {8, false}, "VPMOVW2M": {16, false},
+	"VPMOVD2M": {32, false}, "VPMOVQ2M": {64, false},
+}
+
+type x86MaskVectorForm struct {
+	spec         x86MaskVectorSpec
+	vector, mask int
+	byteWidth    int
+}
+
+// Syntax and physical register roles are shared by lowering and caller effects.
+// The form supplies no mask value, initialized vector bytes or entry contract.
+func x86MaskVectorProperties(ins Instr, arch string) (x86MaskVectorForm, bool, error) {
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86MaskVectorSpecs[Op(base)]
+	if !recognized {
+		return x86MaskVectorForm{}, false, nil
+	}
+	form := x86MaskVectorForm{spec: spec, vector: 0, mask: 1}
+	if spec.maskToVector {
+		form.vector, form.mask = 1, 0
+	}
+	fail := func() (x86MaskVectorForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s requires register-only K0-K7 and X/Y/Z operands without suffix: %q", arch, base, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 || !amd64IsKOperand(ins.Args[form.mask]) {
+		return fail()
+	}
+	vector := ins.Args[form.vector]
+	form.byteWidth = amd64VectorByteWidth(vector.Reg)
+	if !amd64GoPackedVectorMoveRegister(vector, form.byteWidth, arch) {
+		return fail()
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func x86CallerMaskVectorStep(ins *Instr, form x86MaskVectorForm, state *x86SourceStackState) bool {
+	mask := ins.Args[form.mask].Reg
+	vector := x86CallerVectorRoot(ins.Args[form.vector].Reg)
+	if form.spec.maskToVector {
+		if !state.masks[mask] {
+			return false
+		}
+		// EVEX writes the selected vector and clears every wider alias byte.
+		state.vectors[vector] = ^uint64(0)
+		return true
+	}
+	required := form.signByteInputs()
+	if state.vectors[vector]&required != required {
+		return false // An entry/partially initialized vector is not numeric data.
+	}
+	// Sign bits fill the low mask lanes and all remaining K bits become zero.
+	state.masks[mask] = true
+	return true
+}
+
+// Only each lane's sign bit contributes to a vector-to-mask result. At byte
+// granularity its containing byte is sufficient; unrelated bytes stay unknown.
+func (form x86MaskVectorForm) signByteInputs() uint64 {
+	lane := form.spec.laneBits / 8
+	var required uint64
+	for offset := lane - 1; offset < form.byteWidth; offset += lane {
+		required |= uint64(1) << uint(offset)
+	}
+	return required
+}
+
+func x86MaskVectorResultStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	form, known, err := x86MaskVectorProperties(ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+	vector, _ := amd64VectorRegisterIndex(ins.Args[form.vector].Reg, form.byteWidth)
+	if form.spec.maskToVector {
+		if !state.masks[mask] {
+			return false, true
+		}
+		state.writeVector(vector, form.byteWidth, x86CallerVectorByteMask(int64(form.byteWidth)), false)
+		return true, true // EVEX clears wider aliases; this is not writemasking.
+	}
+	required := form.signByteInputs()
+	if state.vectorBytes(vector)&required != required {
+		return false, true
+	}
+	state.masks[mask] = true // Every inactive high K bit is architecturally zero.
+	return true, true
+}
diff --git a/amd64_mask_vector_runtime_test.go b/amd64_mask_vector_runtime_test.go
new file mode 100644
index 000000000..d1428f16a
--- /dev/null
+++ b/amd64_mask_vector_runtime_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Observe both directions independently: a round trip alone could let two
+// inverse mistakes agree. The reference does not consult the production spec.
+func x86MaskVectorRuntimeFixture(t *testing.T) (string, map[string]FuncSig, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		for _, mask := range []string{"K0", "K7"} {
+			name := fmt.Sprintf("maskvector%d", count)
+			count++
+			instruction := strings.ReplaceAll(row, "K1", mask)
+			toVector := strings.HasPrefix(instruction, "VPMOVM2")
+			fields := strings.Fields(instruction)
+			vector := strings.TrimPrefix(strings.TrimSuffix(fields[1], ","+mask), mask+",")
+			width := map[byte]int{'X': 16, 'Y': 32, 'Z': 64}[vector[0]]
+			lane := strings.TrimPrefix(fields[0], "VPMOV")
+			lane = strings.TrimPrefix(strings.TrimSuffix(lane, "2M"), "M2")
+			laneBytes := map[string]int{"B": 1, "W": 2, "D": 4, "Q": 8}[lane]
+			if width == 0 || laneBytes == 0 {
+				t.Fatal("unmodeled independent mask/vector runtime spelling", row)
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ mask+16(FP),DX\n", name)
+			fmt.Fprintf(&source, "KMOVQ DX,%s\nMOVQ $0x8123456789abcdef,DI\nKMOVQ DI,K2\nVMOVUPS (BX),Z1\nCMPQ AX,AX\nSTC\n", mask)
+			fmt.Fprintln(&source, instruction)
+			fmt.Fprintf(&source, "VMOVUPS Z1,(AX)\nKMOVQ %s,DX\nMOVQ DX,64(AX)\nKMOVQ K2,DX\nMOVQ DX,72(AX)\nSETCS 80(AX)\nSETNE 81(AX)\nRET\n", mask)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if(checkMaskVector(%s,\"%s\",%d,%d,%d)) return 1;\n", name, name, width, laneBytes, x86FloatAddSubBoolInt(toVector))
+		}
+	}
+	if count != 48 {
+		t.Fatalf("independent complete runtime program denominator: %d", count)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int checkMaskVector(void (*program)(uint8_t*,const uint8_t*,uint64_t),
+                          const char *name,unsigned width,unsigned lane,int toVector) {
+    const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x55aa55aa55aa55aa),UINT64_C(1)<<63};
+    for(unsigned round=0;round<4;round++) for(unsigned m=0;m<5;m++) {
+        uint8_t input[66],original[66],output[84];
+        for(unsigned i=0;i<66;i++) input[i]=(uint8_t)(i*19+round*83+129);
+        memcpy(original,input,sizeof(input));
+        memset(output,0xc3,sizeof(output));
+        uint32_t saved,before=0x1f80|(round<<13)|round,after;
+        __asm__ volatile("stmxcsr %0" : "=m"(saved));
+        __asm__ volatile("ldmxcsr %0" : : "m"(before));
+        program(output+1,input+1,masks[m]);
+        __asm__ volatile("stmxcsr %0" : "=m"(after));
+        __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+        uint64_t gotMask,otherMask,wantMask=masks[m];
+        memcpy(&gotMask,output+65,8);
+        memcpy(&otherMask,output+73,8);
+        if(!toVector) {
+            wantMask=0;
+            for(unsigned element=0;element<width/lane;element++)
+                wantMask|=(uint64_t)(input[1+element*lane+lane-1]>>7)<<element;
+        }
+        if(after!=before || output[0]!=0xc3 || output[83]!=0xc3 ||
+           output[81]!=1 || output[82]!=0 || gotMask!=wantMask ||
+           otherMask!=UINT64_C(0x8123456789abcdef) || memcmp(input,original,sizeof(input))) {
+            fprintf(stderr,"%s mask/flags/MXCSR/input/canary failure\n",name);
+            return 1;
+        }
+        for(unsigned i=0;i<64;i++) {
+            uint8_t want=input[1+i];
+            if(toVector) want=i>=width ? 0 : (masks[m]>>(i/lane)&1) ? 255 : 0;
+            if(output[1+i]!=want) {
+                fprintf(stderr,"%s byte=%u got=%x want=%x\n",name,i,output[1+i],want);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	return source.String(), sigs, oracle
+}
+
+func runX86MaskVectorRuntimeFixture(t *testing.T, llc, clang, triple string, prefix []string) {
+	t.Helper()
+	source, sigs, oracle := x86MaskVectorRuntimeFixture(t)
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "mask-vector-complete-bytes", triple, ir, oracle, prefix)
+	t.Log("48 independent direction/lane/width/K0-K7 programs; 20 complete byte/alias/mask/flags/MXCSR/canary observations each")
+}
+
+func TestX86MaskVectorCompleteByteRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the mandatory cross-runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	runX86MaskVectorRuntimeFixture(t, llc, clang, triple, prefix)
+}
+
+func TestCrossLinuxRuntimeMatrixX86MaskVectorCompleteByteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	runX86MaskVectorRuntimeFixture(t, llc, clang, triple, prefix)
+}
diff --git a/amd64_md5_data_bp_source_go127_test.go b/amd64_md5_data_bp_source_go127_test.go
new file mode 100644
index 000000000..6e1e0e363
--- /dev/null
+++ b/amd64_md5_data_bp_source_go127_test.go
@@ -0,0 +1,106 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Retain the exact SDK source that exposed the benchmark regression. Extract
+// only its original language declarations for this test package: that is not
+// an SDK selection, linked frame, caller or pointee-extent capability.
+func amd64MD5OriginalDataBPSource(t *testing.T) (string, GoPackage) {
+	t.Helper()
+	read := func(name string) []byte {
+		t.Helper()
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "crypto", "md5", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("original MD5 SDK source %s bytes=%d SHA256=%x", name, len(data), sha256.Sum256(data))
+		return data
+	}
+
+	assembly := read("md5block_amd64.s")
+	if got := fmt.Sprintf("%x", sha256.Sum256(assembly)); got != "36c7e14eaf58fd6bfc63a70c651dd36c6ab99421e1c455a3d203b15fd4ca4d81" {
+		t.Fatal("the complete original MD5 source changed; re-audit rather than alter its BP/frame usage", got)
+	}
+	declarations := map[string]string{}
+	for _, name := range []string{"md5.go", "md5block_decl.go"} {
+		data := read(name)
+		positions := token.NewFileSet()
+		parsed, err := parser.ParseFile(positions, name, data, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, declaration := range parsed.Decls {
+			selected := ""
+			switch declaration := declaration.(type) {
+			case *ast.FuncDecl:
+				if declaration.Name.Name == "block" && declaration.Body == nil && declaration.Recv == nil {
+					selected = "block"
+				}
+			case *ast.GenDecl:
+				if len(declaration.Specs) != 1 {
+					continue
+				}
+				switch spec := declaration.Specs[0].(type) {
+				case *ast.TypeSpec:
+					if spec.Name.Name == "digest" {
+						selected = "digest"
+					}
+				case *ast.ValueSpec:
+					if len(spec.Names) == 1 && spec.Names[0].Name == "BlockSize" {
+						selected = "BlockSize"
+					}
+				}
+			}
+			if selected != "" {
+				if declarations[selected] != "" {
+					t.Fatal("duplicate original MD5 declaration", selected)
+				}
+				declarations[selected] = string(data[positions.Position(declaration.Pos()).Offset:positions.Position(declaration.End()).Offset])
+			}
+		}
+	}
+	var goSource strings.Builder
+	goSource.WriteString("package md5\n")
+	for _, name := range []string{"BlockSize", "digest", "block"} {
+		if declarations[name] == "" {
+			t.Fatal("missing original MD5 declaration", name)
+		}
+		goSource.WriteString(declarations[name] + "\n")
+	}
+	if declarations["block"] != "func block(dig *digest, p []byte)" || declarations["BlockSize"] != "const BlockSize = 64" {
+		t.Fatal("actual original MD5 ABI or block-size declaration changed")
+	}
+	return string(assembly), mustGoPackage(t, "crypto/md5", goSource.String())
+}
+
+func TestAMD64MD5OriginalDataBPSourceObjectsThreeAPIs(t *testing.T) {
+	source, pkg := amd64MD5OriginalDataBPSource(t)
+	for _, triple := range []string{
+		"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("complete original MD5 initialized data BP is not closed: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_memory_address_role.go b/amd64_memory_address_role.go
new file mode 100644
index 000000000..1b47d3939
--- /dev/null
+++ b/amd64_memory_address_role.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"math"
+	"strings"
+)
+
+// NAME_EXTERN/NAME_STATIC in the non-shared Go 386 encoder discards Reg,
+// including a nonscaled SP/BP annotation. Index remains an actual address
+// input. AMD64 uses RIP and rejects either annotation. This describes address
+// roles, not backing, initialized bytes, alignment or caller permissions.
+func x86SBMemoryAddressRole(operand Operand, arch string) (MemRef, bool) {
+	var memory MemRef
+	switch operand.Kind {
+	case OpSym:
+		memory.Sym = operand.Sym
+	case OpMem:
+		memory = operand.Mem
+		if x86SymbolIndexedMemoryError(memory, arch) != nil {
+			return MemRef{}, false
+		}
+	default:
+		return MemRef{}, false
+	}
+	if arch != "386" && arch != "amd64" ||
+		!strings.HasSuffix(strings.TrimSpace(memory.Sym), "(SB)") {
+		return MemRef{}, false
+	}
+	if arch == "386" {
+		memory.Base = ""
+	}
+	return memory, true
+}
+
+// Native emitters may additionally possess a checked physical frame token.
+// This ordinary branch does not create one, including for an effective Index.
+// BP is an ordinary GP in mode32, not an implicit physical frame binding.
+// It classifies already validated operands; the typed instruction grammar must
+// first reject a bare name or malformed address instead of inventing storage.
+func x86OrdinaryNativeMemoryOperand(operand Operand, arch string) bool {
+	if operand.Kind == OpSym {
+		return true
+	}
+	if operand.Kind != OpMem {
+		return false
+	}
+	memory := operand.Mem
+	if named, valid := x86SBMemoryAddressRole(operand, arch); valid {
+		memory = named
+	}
+	return !x86LogicalSourceFrameRegister(memory.Base, arch) && !x86LogicalSourceFrameRegister(memory.Index, arch)
+}
+
+func x86RegisterAddressedNativeMemoryOperand(operand Operand, arch string) bool {
+	return operand.Kind == OpMem && operand.Mem.Sym == "" && x86OrdinaryNativeMemoryOperand(operand, arch)
+}
+
+// Select an emitter's address role, never pointee, extent or alignment facts.
+// Logical BP stays non-native unless this exact bound access records otherwise.
+func (c *amd64Ctx) nativeMemoryOperand(ins Instr, index int) bool {
+	if index < 0 || index >= len(ins.Args) {
+		return false
+	}
+	if x86OrdinaryNativeMemoryOperand(ins.Args[index], c.goarch) {
+		return true
+	}
+	if access, found := ins.x86FixedLocalMemory[index]; !found || !access.nativeInput {
+		return false
+	}
+	access, valid := c.fixedLocalMemoryAccess(ins, index)
+	return valid && access.nativeInput
+}
+
+// The key includes the complete effective displacement, not Operand.String:
+// raw AST memory can hold a displacement in addition to its symbolic offset.
+type x86StaticSBAddress struct {
+	symbol string
+	offset int64
+}
+
+func x86StaticSBReadAddress(operand Operand, arch string) (x86StaticSBAddress, bool) {
+	address, valid := x86StaticSBSourceAddress(operand, arch)
+	return address, valid && address.offset >= 0
+}
+
+// Address formation permits signed addends. Only a read additionally needs
+// a nonnegative offset and an independently checked complete storage extent.
+func x86StaticSBSourceAddress(operand Operand, arch string) (x86StaticSBAddress, bool) {
+	memory, valid := x86SBMemoryAddressRole(operand, arch)
+	if !valid || memory.Index != "" || memory.Scale != 0 || memory.IndexExt != "" ||
+		memory.OffRaw != "" || memory.Segment != "" {
+		return x86StaticSBAddress{}, false
+	}
+	base, offset, valid := parseSBRef(memory.Sym)
+	if !valid || base == "" || strings.IndexAny(base, "$+(),[] \t") >= 0 ||
+		memory.Off > 0 && offset > math.MaxInt64-memory.Off ||
+		memory.Off < 0 && offset < math.MinInt64-memory.Off {
+		return x86StaticSBAddress{}, false
+	}
+	offset += memory.Off
+	return x86StaticSBAddress{symbol: base, offset: offset}, true
+}
diff --git a/amd64_memory_fault_observer_test.go b/amd64_memory_fault_observer_test.go
new file mode 100644
index 000000000..9317e2c68
--- /dev/null
+++ b/amd64_memory_fault_observer_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// Each probe is an owned, directly launched process. Do not catch native
+// exceptions in C or accept setup exits as evidence of a memory fault.
+func x86ObserveMemoryFault(t *testing.T, execution x86FloatCompareExecution, executable string, row, probe, original int) string {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	child, stop := context.WithTimeout(ctx, 30*time.Second)
+	defer stop()
+	args := execution.command(executable, strconv.Itoa(row), strconv.Itoa(probe), strconv.Itoa(original))
+	stdout, stderr, err := runtimeOracleMachineOutput(child, exec.CommandContext(child, args[0], args[1:]...))
+	if child.Err() != nil {
+		t.Fatal(child.Err())
+	}
+	witness := fmt.Sprintf("memory enter %d %d %d\n", row, probe, original)
+	result, cause := x86NativeFaultResult(runtime.GOOS, string(stdout), witness, "memory complete\n", err)
+	if cause != nil {
+		t.Fatalf("row=%d probe=%d original=%d: %v\nstdout: %q\nstderr: %q", row, probe, original, cause, stdout, stderr)
+	}
+	return result
+}
+
+func x86CheckMemoryFaultMatrix(t *testing.T, execution x86FloatCompareExecution, executable string, rows int) {
+	t.Helper()
+	required := make([]bool, rows)
+	for row := range required {
+		required[row] = true
+	}
+	x86CheckMemoryAccessMatrix(t, execution, executable, required)
+}
+
+func x86CheckMemoryAccessMatrix(t *testing.T, execution x86FloatCompareExecution, executable string, required []bool) {
+	t.Helper()
+	for row, reads := range required {
+		for probe := 0; probe < 3; probe++ {
+			// A volatile byte read supplies an independent access-extent
+			// reference, not evidence of original AVX/EVEX execution.
+			want := x86ObserveMemoryFault(t, execution, executable, row, probe, 1)
+			if probe == 2 || !reads {
+				if want != "return" {
+					t.Fatalf("row %d probe %d: accessible or suppressed source faulted: %s", row, probe, want)
+				}
+			} else if want != "segv" && want != "bus" {
+				t.Fatalf("row %d probe %d: native access did not fault: %s", row, probe, want)
+			}
+			if got := x86ObserveMemoryFault(t, execution, executable, row, probe, 0); got != want {
+				t.Fatalf("row %d probe %d: translated %s, native access %s", row, probe, got, want)
+			}
+		}
+	}
+	t.Logf("%d rows: NULL, partial-page and complete-page inputs; independent native access and translated outcomes agree", len(required))
+}
+
+func x86MemoryFaultDriver(declarations, rows string) string {
+	return x86MemoryFaultSupportC + declarations +
+		"static const struct memory_case cases[] = {\n" + rows + "};\n" + x86MemoryFaultMainC
+}
+
+func TestX86MemoryFaultObserverRejectsSetupAndCanaryFailures(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const callbacks = `
+static int canary_failure(const uint8_t *p) { (void)p; return 91; }
+static int fake_signal_exit(const uint8_t *p) { (void)p; return 139; }
+`
+	driver := x86MemoryFaultDriver(callbacks, "{canary_failure, 4, 3}, {fake_signal_exit, 4, 3},")
+	executable := execution.compileLLVM(t, "memory-fault-controls", "", driver, "-O2")
+	for _, row := range []int{0, 1, 99} {
+		ctx, cancel := runtimeOracleStageContext(t)
+		args := execution.command(executable, strconv.Itoa(row), "2", "0")
+		stdout, _, err := runtimeOracleMachineOutput(ctx, exec.CommandContext(ctx, args[0], args[1:]...))
+		cancel()
+		witness := fmt.Sprintf("memory enter %d 2 0\n", row)
+		if result, cause := x86NativeFaultResult(runtime.GOOS, string(stdout), witness, "memory complete\n", err); cause == nil {
+			t.Fatalf("setup/canary error became memory evidence: row=%d result=%s", row, result)
+		}
+	}
+}
+
+const x86MemoryFaultSupportC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef _WIN32
+#include <sys/resource.h>
+#endif
+` + x86TestGuardPagesC + `
+struct memory_case {
+    int (*run)(const uint8_t *);
+    unsigned bytes;
+    unsigned accessible;
+};
+
+static int memory_fault_setup(unsigned leading) {
+#ifdef _WIN32
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
+#else
+    struct rlimit no_core = {0, 0};
+    if (setrlimit(RLIMIT_CORE, &no_core)) return 120;
+#endif
+    if (setup_guard_before(leading) || page < 64) return 81;
+    for (size_t i = 0; i < page; ++i) guard[i] = (uint8_t)(i * 13 + 17);
+    return 0;
+}
+`
+
+const x86MemoryFaultMainC = `
+int main(int argc, char **argv) {
+    if (argc != 4) return 80;
+    unsigned row, probe, original;
+    char tail;
+    if (sscanf(argv[1], "%u%c", &row, &tail) != 1 ||
+            sscanf(argv[2], "%u%c", &probe, &tail) != 1 ||
+            sscanf(argv[3], "%u%c", &original, &tail) != 1 ||
+            row >= sizeof(cases) / sizeof(cases[0]) || probe > 2 || original > 1) return 80;
+    int setup = memory_fault_setup(0);
+    if (setup) return setup;
+    struct memory_case kernel = cases[row];
+    if (kernel.bytes > page || (kernel.bytes ? kernel.accessible >= kernel.bytes : kernel.accessible != 0)) return 82;
+    const uint8_t *input = probe == 0 ? NULL :
+        guard + page - (probe == 1 ? kernel.accessible : kernel.bytes);
+
+    printf("memory enter %u %u %u\n", row, probe, original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        const volatile uint8_t *source = input;
+        volatile uint8_t sink = 0;
+        for (unsigned i = 0; i < kernel.bytes; ++i) sink ^= source[i];
+    } else {
+        int result = kernel.run(input);
+        if (result) return result;
+    }
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout) ? 85 : 0;
+}
+`
diff --git a/amd64_minmax_runtime_test.go b/amd64_minmax_runtime_test.go
new file mode 100644
index 000000000..bf67dd639
--- /dev/null
+++ b/amd64_minmax_runtime_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MinMaxMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable values require the native 64-bit host counterpart")
+	}
+	// Execute the unchanged complete logical-vector program on the actual
+	// host. This is not original AVX512 opcode or physical-register evidence.
+
+	var source, declarations strings.Builder
+	checks := map[string]*strings.Builder{"views": {}, "memory": {}}
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, op := range x86MinMaxTestOps {
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		signed, minimum := 0, 0
+		if op[5] == 'S' {
+			signed = 1
+		}
+		if strings.HasPrefix(op, "VPMIN") {
+			minimum = 1
+		}
+
+		for w, width := range []string{"X", "Y", "Z"} {
+			// Register/memory unmasked, register/memory masked, masked broadcast.
+			for mode := 0; mode < 5; mode++ {
+				if mode == 4 && bits < 32 {
+					continue
+				}
+				for _, zero := range []bool{false, true} {
+					if zero && mode < 2 {
+						continue
+					}
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("minmax%d", index)
+						index++
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+						source.WriteString("MOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),DI\n")
+						source.WriteString("VMOVUPS (AX),Z0\n")
+
+						input := "(BX)"
+						registerInput := mode == 0 || mode == 2
+						if registerInput {
+							source.WriteString("VMOVUPS (BX),Z1\n")
+							input = width + "1"
+						} else if raw {
+							source.WriteString("VMOVUPS (AX),Z1\n")
+						}
+						suffix, mask := "", ""
+						if mode == 4 {
+							suffix = ".BCST"
+						}
+						if zero {
+							suffix += ".Z"
+						}
+						if mode >= 2 {
+							source.WriteString("KMOVQ mask+24(FP),K1\n")
+							mask = "K1,"
+						}
+
+						destination, oldB := 0, 0
+						if raw {
+							destination = 1
+							if registerInput {
+								oldB = 1
+							}
+						}
+						line := fmt.Sprintf("%s%s %s,%s0,%s%s%d", op, suffix, input, width, mask, width, destination)
+						emitX86GoEncodedTestInstruction(t, &source, line, raw)
+						fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\n", destination)
+						fmt.Fprintf(&source, "VMOVUPS Y%d,64(DI)\n", destination)
+						fmt.Fprintf(&source, "VMOVUPS X%d,96(DI)\nRET\n", destination)
+
+						sigs[name] = FuncSig{
+							Name: name,
+							Args: []LLVMType{Ptr, Ptr, Ptr, I64},
+							Ret:  Void,
+							Frame: FrameLayout{Params: []FrameSlot{
+								{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+								{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+								{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+								{Offset: 24, Type: I64, Index: 3, Field: -1},
+							}},
+						}
+						fmt.Fprintf(&declarations, "extern void %s(const void*, const void*, void*, uint64_t);\n", name)
+						kind, zeroing := "views", 0
+						if mode >= 2 {
+							kind = "memory"
+						}
+						if zero {
+							zeroing = 1
+						}
+						fmt.Fprintf(checks[kind], "    if (check(%s, %d, %d, %d, %d, %d, %d, %d)) {\n", name, 16<<w, bits/8, signed, minimum, mode, zeroing, oldB)
+						fmt.Fprintf(checks[kind], "        fprintf(stderr, \"%s failed\\n\");\n        return 1;\n    }\n", name)
+					}
+				}
+			}
+		}
+	}
+	if index != 672 {
+		t.Fatalf("generated %d functions, want 672", index)
+	}
+
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		x86TestGuardPagesC + declarations.String() + x86MinMaxRuntimeOracleC
+	for _, kind := range []string{"views", "memory"} {
+		t.Run(kind, func(t *testing.T) {
+			body := mainC + "\nint main(void) {\n    if (setup_guard()) return 2;\n" +
+				checks[kind].String() + "    return free_guard();\n}\n"
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "minmax_"+kind, triple, ir, body)
+		})
+	}
+}
+
+const x86MinMaxRuntimeOracleC = `
+static uint64_t lane(const uint8_t *p, int bytes) {
+    uint64_t value = 0;
+    memcpy(&value, p, bytes);
+    return value;
+}
+
+static uint64_t low_mask(int bits) {
+    return bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+}
+
+static uint64_t minmax(uint64_t a, uint64_t b, int bits, int sign, int minimum) {
+    uint64_t sign_bit = sign ? UINT64_C(1) << (bits - 1) : 0;
+    int less = (a ^ sign_bit) < (b ^ sign_bit);
+    return less == minimum ? a : b;
+}
+
+static int check(void (*fn)(const void*, const void*, void*, uint64_t),
+                 int width, int bytes, int sign, int minimum, int mode,
+                 int zero, int old_b) {
+    int lanes = width / bytes;
+    uint64_t sign_bit = UINT64_C(1) << (bytes * 8 - 1);
+    uint64_t values[] = {0, 1, sign_bit - 1, sign_bit, sign_bit + 1, UINT64_MAX};
+
+    for (int n = 0; n < 64; n++) {
+        uint8_t ab[65], bb[65], out[112], want[112] = {0};
+        uint8_t *a = ab + 1, *b = bb + 1;
+        for (int i = 0; i < 64 / bytes; i++) {
+            uint64_t av = values[(n + i) % 6];
+            uint64_t bv = values[(n / 6 + i * 3) % 6];
+            memcpy(a + i * bytes, &av, bytes);
+            memcpy(b + i * bytes, &bv, bytes);
+        }
+
+        uint64_t mask = n == 0 ? 0 : n == 1 ? UINT64_C(1) << 63 :
+                        n == 2 ? UINT64_MAX : UINT64_C(0x5a5a01239876cdef) >> (n % 32);
+        uint64_t active = mask & low_mask(lanes);
+        for (int i = 0; i < lanes; i++) {
+            uint64_t av = lane(a + i * bytes, bytes);
+            uint64_t bv = lane(b + (mode == 4 ? 0 : i * bytes), bytes);
+            uint64_t result;
+            if (mode < 2 || ((mask >> i) & 1)) {
+                result = minmax(av, bv, bytes * 8, sign, minimum);
+            } else {
+                result = zero ? 0 : old_b ? lane(b + i * bytes, bytes) : av;
+            }
+            memcpy(want + i * bytes, &result, bytes);
+        }
+        memcpy(want + 64, want, 32);
+        memcpy(want + 96, want, 16);
+
+        fn(a, mode >= 3 && !active ? NULL : b, out, mask);
+        if (memcmp(out, want, sizeof(out))) {
+            fprintf(stderr, "width=%d bytes=%d sign=%d min=%d mode=%d zero=%d n=%d\n",
+                    width, bytes, sign, minimum, mode, zero, n);
+            return 1;
+        }
+    }
+
+    if (mode >= 3) {
+        for (int enabled = 1; enabled <= lanes; enabled++) {
+            uint8_t a[64], out[112], want[112] = {0};
+            memset(a, 255, sizeof(a));
+            int readable = mode == 4 ? bytes : enabled * bytes;
+            uint8_t *b = guard + page - readable;
+            memset(b, 255, (size_t)readable);
+
+            for (int i = 0; i < lanes; i++) {
+                if (i < enabled || !zero) {
+                    memset(want + i * bytes, 255, (size_t)bytes);
+                }
+            }
+            memcpy(want + 64, want, 32);
+            memcpy(want + 96, want, 16);
+
+            fn(a, b, out, low_mask(enabled));
+            if (memcmp(out, want, sizeof(out))) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_minpos_runtime_test.go b/amd64_minpos_runtime_test.go
new file mode 100644
index 000000000..75dbe6fa9
--- /dev/null
+++ b/amd64_minpos_runtime_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MinimumPositionMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			var source, declarations, checks strings.Builder
+			sigs := map[string]FuncSig{}
+			index := 0
+			for vex, op := range []string{"PHMINPOSUW", "VPHMINPOSUW"} {
+				for _, operand := range []string{"(BX)", "X1", "X0"} {
+					name := fmt.Sprintf("minpos%d", index)
+					index++
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", name)
+					source.WriteString("MOVQ old+0(FP),AX\nMOVQ input+8(FP),BX\nMOVQ out+16(FP),DI\n")
+					source.WriteString("VMOVUPS (AX),Z0\nVMOVUPS (AX),Z1\n")
+					if operand != "(BX)" {
+						fmt.Fprintf(&source, "MOVOU (BX),%s\n", operand)
+					}
+					emitX86GoEncodedTestInstruction(t, &source, op+" "+operand+",X0", raw)
+					source.WriteString("VMOVUPS Z0,(DI)\nVMOVUPS Y0,64(DI)\nVMOVUPS X0,96(DI)\nRET\n")
+					sigs[name] = FuncSig{
+						Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+							{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+						}},
+					}
+					fmt.Fprintf(&declarations, "extern void %s(const void*, const void*, void*);\n", name)
+					fmt.Fprintf(&checks, "    if (check(%s, %d)) {\n", name, vex)
+					fmt.Fprintf(&checks, "        fprintf(stderr, \"%s failed\\n\");\n        return 1;\n    }\n", name)
+				}
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			// Original legacy m128 has an alignment exception, whereas this
+			// unchanged C observes unaligned mathematics. Keep those owners
+			// explicit and preserve the legacy output's upper aliases.
+			file = x86BlendMinposPrivateMathCompanion(t, source.String(), 6, 1, 4)
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err = x86BlendMinposMathIR(file, ir)
+			if err != nil {
+				t.Fatal("private mathematical companion lost exact source/IR ownership", err)
+			}
+			body := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+				x86TestGuardPagesC + declarations.String() + x86MinimumPositionOracleC +
+				"\nint main(void) {\n    if (setup_guard()) return 2;\n" +
+				checks.String() + "    return free_guard();\n}\n"
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "minpos-private-math", triple, ir, body)
+		})
+	}
+}
+
+const x86MinimumPositionOracleC = `
+static int check(void (*fn)(const void*, const void*, void*), int vex) {
+    const uint16_t values[] = {0, 1, 0x7fff, 0x8000, 0x8001, 0xfffe, 0xffff};
+    for (int n = 0; n < 256; n++) {
+        uint8_t old[65], storage[17], out[112], want[112] = {0};
+        uint8_t *input = storage + 1;
+        for (int i = 0; i < 65; i++) old[i] = (uint8_t)(i * 3 + 31);
+
+        uint16_t minimum = 0xffff, position = 0;
+        for (int i = 0; i < 8; i++) {
+            uint16_t value = n < 8 ? (i == n ? 0 : 0xffff) :
+                             values[(n + i * (n % 5)) % 7];
+            memcpy(input + i * 2, &value, 2);
+            if (value < minimum) {
+                minimum = value;
+                position = (uint16_t)i;
+            }
+        }
+        memcpy(want, &minimum, 2);
+        memcpy(want + 2, &position, 2);
+        if (!vex) memcpy(want + 16, old + 1 + 16, 48);
+        memcpy(want + 64, want, 32);
+        memcpy(want + 96, want, 16);
+
+        for (int edge = 0; edge < 2; edge++) {
+            const uint8_t *source = input;
+            if (edge) {
+                source = guard + page - 16;
+                memcpy(guard + page - 16, input, 16);
+            }
+            memset(out, 0xa5, sizeof(out));
+            fn(old + 1, source, out);
+            if (memcmp(out, want, sizeof(out))) {
+                fprintf(stderr, "vex=%d n=%d edge=%d\n", vex, n, edge);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_mmx_native_export_test.go b/amd64_mmx_native_export_test.go
new file mode 100644
index 000000000..d5a0524d8
--- /dev/null
+++ b/amd64_mmx_native_export_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// An explicit diagnostic export retains the exact compiled fixture for a
+// second execution transport. The original test still runs and reports its
+// own outcome; export never converts an emulator failure into a native pass.
+func x86MMXExportNativeFixture(t *testing.T, executable, source, ir, level, triple string, rows int) {
+	t.Helper()
+	directory := os.Getenv("PLAN9ASM_MMX_NATIVE_EXPORT_DIR")
+	if directory == "" {
+		return
+	}
+	if !filepath.IsAbs(directory) || level != "-O0" && level != "-O2" {
+		t.Fatal("native MMX export needs an explicit absolute directory and original optimization axis")
+	}
+	if err := os.MkdirAll(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	binary, err := os.ReadFile(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := "mmx-native-" + level[1:]
+	write := func(name string, data []byte, mode os.FileMode) {
+		t.Helper()
+		file, err := os.OpenFile(filepath.Join(directory, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, mode)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, writeErr := file.Write(data)
+		closeErr := file.Close()
+		if writeErr != nil || closeErr != nil {
+			t.Fatal("incomplete native MMX export", writeErr, closeErr)
+		}
+	}
+	write(name, binary, 0700)
+	manifest, err := json.MarshalIndent(map[string]interface{}{
+		"executable": name, "sha256": fmt.Sprintf("%x", sha256.Sum256(binary)),
+		"assembly_sha256": fmt.Sprintf("%x", sha256.Sum256([]byte(source))),
+		"ir_sha256":       fmt.Sprintf("%x", sha256.Sum256([]byte(ir))),
+		"sdk":             runtime.Version(), "triple": triple, "backend_level": level, "rows": rows,
+		"scope": "Compiled diagnostic artifact only; the original and second execution outcomes remain independent.",
+	}, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	write(name+".json", append(manifest, '\n'), 0600)
+}
diff --git a/amd64_mmx_word_forms.go b/amd64_mmx_word_forms.go
new file mode 100644
index 000000000..58e0b729c
--- /dev/null
+++ b/amd64_mmx_word_forms.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These are source-selected bank/width facts, not initialized register,
+// native-memory, x87 state or entry permissions. In particular Go's ordered
+// ymovq Ymm/Ymr row reads a GP for the spelling MOVQ M0,M1.
+type x86MMXWordForm struct {
+	source, destination Operand
+	bytes               int64
+	sourceM, targetM    bool
+	sourceX, targetX    bool
+	gpSpelling          bool
+	nonTemporal         bool
+}
+
+func x86MMXWordProperties(ins Instr, arch string) (x86MMXWordForm, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86MMXWordForm{}, false, nil // Raw bytes have their own physical-bank contract.
+	}
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	streaming := name == "MOVNTQ"
+	if name != "MOVL" && name != "MOVQ" && name != "MOVD" && name != "MOVDQ2Q" && name != "MOVQOZX" && !streaming {
+		return x86MMXWordForm{}, false, nil
+	}
+	mmx := false
+	for _, operand := range ins.Args {
+		mmx = mmx || isAMD64MOVDMRegister(operand)
+	}
+	if !mmx && !streaming {
+		return x86MMXWordForm{}, false, nil
+	}
+	fail := func() (x86MMXWordForm, bool, error) {
+		return x86MMXWordForm{}, true, fmt.Errorf("%s %s outside complete Go MMX word rows: %q", arch, ins.Op, ins.Raw)
+	}
+	if dotted || len(ins.Args) != 2 || arch != "amd64" && arch != "386" {
+		return fail()
+	}
+	form := x86MMXWordForm{source: ins.Args[0], destination: ins.Args[1], bytes: 8}
+	form.sourceM, form.targetM = isAMD64MOVDMRegister(form.source), isAMD64MOVDMRegister(form.destination)
+	form.sourceX, form.targetX = isAMD64MOVDXRegister(form.source), isAMD64MOVDXRegister(form.destination)
+	vector := func(operand Operand) bool {
+		index, valid := amd64ParseXReg(operand.Reg)
+		return operand.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+	}
+	memory := func(operand Operand) bool {
+		return isAMD64MemoryOperand(operand) && x86PackedShiftMemoryValid(operand, arch)
+	}
+	gp := func(operand Operand) bool {
+		return operand.Kind == OpReg && isX86YrlRegisterForArch(operand.Reg, arch)
+	}
+	if streaming {
+		if !form.sourceM || !memory(form.destination) {
+			return fail()
+		}
+		form.nonTemporal = true
+		return form, true, nil // ymr_ml: one MMX source and an m64 destination.
+	}
+	if name == "MOVQOZX" {
+		if !form.sourceM || !vector(form.destination) {
+			return fail()
+		}
+		return form, true, nil // ymrxr: MMX -> X low64, with the X high64 cleared.
+	}
+	if name == "MOVL" {
+		form.bytes = 4
+	}
+	if form.targetM {
+		if form.sourceM {
+			if form.bytes != 8 || arch != "amd64" {
+				return fail()
+			}
+			index, _ := amd64ParseMReg(form.source.Reg)
+			form.source.Reg = amd64MMXEncodingGP(index)
+			form.sourceM, form.gpSpelling = false, true
+		} else if form.sourceX {
+			if form.bytes != 8 || !vector(form.source) {
+				return fail()
+			}
+		} else if gp(form.source) {
+			if form.bytes == 8 && arch == "386" {
+				return fail()
+			}
+		} else if !memory(form.source) {
+			return fail()
+		}
+		return form, true, nil
+	}
+	if form.sourceM && (memory(form.destination) || gp(form.destination) && (form.bytes == 4 || arch == "amd64")) {
+		return form, true, nil
+	}
+	return fail()
+}
diff --git a/amd64_mmx_word_forms_test.go b/amd64_mmx_word_forms_test.go
new file mode 100644
index 000000000..9304c55d9
--- /dev/null
+++ b/amd64_mmx_word_forms_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86MMXWordGoBankMatchesOriginalBytes(t *testing.T) {
+	for _, spelling := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		for index := 0; index < 8; index++ {
+			instruction := fmt.Sprintf("%s M%d,M1", spelling, index)
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT bank(SB),4,$0-0\n"+instruction+"\nRET\n")
+			want := []byte{0x48, 0x0f, 0x6e, byte(0xc8 + index), 0xc3}
+			if !reflect.DeepEqual(code, want) {
+				t.Fatal("ordered Go Ymm/Ymr word row changed", instruction, code, want)
+			}
+			ins := x86ScalarLaneInstruction(t, instruction)
+			form, known, err := x86MMXWordProperties(ins, "amd64")
+			gp := []Reg{AX, CX, DX, BX, SP, BP, SI, DI}[index]
+			if !known || err != nil || form.sourceM || !form.targetM || !form.gpSpelling ||
+				form.source.Reg != gp || form.bytes != 8 || !reflect.DeepEqual(ins, x86ScalarLaneInstruction(t, instruction)) {
+				t.Fatal("source spelling became the wrong physical bank", instruction, form, err)
+			}
+		}
+	}
+}
+
+func TestX86MMXWordCompleteSourceRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			bytes  int64
+			valid  bool
+		}{
+			{"MOVL AX,M0", 4, true}, {"MOVL M0,AX", 4, true},
+			{"MOVL 1(AX),M0", 4, true}, {"MOVL M0,1(AX)", 4, true},
+			{"MOVQ 1(AX),M0", 8, true}, {"MOVQ M0,1(AX)", 8, true},
+			{"MOVQ X0,M0", 8, true}, {"MOVQOZX M0,X0", 8, true},
+			{"MOVQ AX,M0", 8, arch == "amd64"}, {"MOVQ M0,AX", 8, arch == "amd64"},
+			{"MOVQ M0,M1", 8, arch == "amd64"},
+			{"MOVL M0,M1", 4, false}, {"MOVL X0,M0", 4, false},
+			{"MOVQ M0,X0", 8, false}, {"MOVQOZX X0,M0", 8, false},
+			{"MOVQ $7,M0", 8, false}, {"MOVQ.Z M0,AX", 8, false},
+			{"MOVNTQ M0,1(AX)", 8, true}, {"MOVNTQ M7,1(AX)(CX*2)", 8, true},
+			{"MOVNTQ M0,M1", 8, false}, {"MOVNTQ X0,1(AX)", 8, false},
+			{"MOVNTQ AX,1(AX)", 8, false}, {"MOVNTQ.Z M0,1(AX)", 8, false},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.source)
+				before := ins
+				form, known, err := x86MMXWordProperties(ins, arch)
+				if !known || (err == nil) != row.valid || row.valid && form.bytes != row.bytes || !reflect.DeepEqual(before, ins) {
+					t.Fatal("complete MMX word grammar changed", form, known, err, row.valid)
+				}
+				goAssemblerOracleOutput(t, arch, "TEXT bank(SB),4,$0-0\n"+row.source+"\nRET\n", "", row.valid)
+			})
+		}
+	}
+}
diff --git a/amd64_mode32_object_source_test.go b/amd64_mode32_object_source_test.go
new file mode 100644
index 000000000..6375c1a54
--- /dev/null
+++ b/amd64_mode32_object_source_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"errors"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var x86Mode32ObjectHighBank = regexp.MustCompile(`\b[XY](?:[89]|[12][0-9]|3[01])\b`)
+
+// Keep the complete original source acceptance and its missing physical
+// binding observable. The returned low-bank fixture tests object generation,
+// not equivalence to the original high-bank machine code or runtime behavior.
+func x86PhysicalMode32ObjectSource(t *testing.T, source, arch string) string {
+	t.Helper()
+	if arch != "386" {
+		return source
+	}
+	goSource := strings.ReplaceAll(source, ",NOSPLIT", ",4")
+	requireX86GoAssemblerResult(t, arch, goSource, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	highRows := 0
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if !errors.Is(x86Mode32VectorRegisterContext(instruction, arch), ErrProbeNeedsContext) {
+				continue
+			}
+			highRows++
+			one, err := Parse(ArchAMD64, "TEXT highbank(SB),4,$0-0\n"+instruction.Raw+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(one, Options{
+				Goarch: arch, TargetTriple: "i386-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"highbank": {Name: "highbank", Ret: Void}},
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("original high bank acquired an unproved physical binding: %s: %v", instruction.Raw, err)
+			}
+		}
+	}
+	if highRows == 0 {
+		t.Fatal("mode32 fixture lost its original high-bank source coverage")
+	}
+	physical := x86Mode32ObjectHighBank.ReplaceAllStringFunc(source, func(register string) string {
+		index, err := strconv.Atoi(register[1:])
+		if err != nil {
+			t.Fatal(err)
+		}
+		return register[:1] + strconv.Itoa(index%8)
+	})
+	requireX86GoAssemblerResult(t, arch, strings.ReplaceAll(physical, ",NOSPLIT", ",4"), true)
+	return physical
+}
diff --git a/amd64_mode32_vector_bindings_test.go b/amd64_mode32_vector_bindings_test.go
new file mode 100644
index 000000000..b1255e01a
--- /dev/null
+++ b/amd64_mode32_vector_bindings_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+type mode32VectorFamilyCase struct {
+	name       string
+	rows       []string
+	properties func(Instr, string) (bool, error)
+	lower      func(*amd64Ctx, Instr) (bool, bool, error)
+}
+
+// Existing SDK-table completeness tests independently bind these families to
+// Go. The actual Go object here observes syntax acceptance, not register state.
+func mode32VectorFamilyCases() []mode32VectorFamilyCase {
+	logical := mode32VectorFamilyCase{
+		name: "logical",
+		properties: func(ins Instr, arch string) (bool, error) {
+			_, recognized, err := x86PackedLogicalProperties(ins, arch)
+			return recognized, err
+		},
+		lower: func(ctx *amd64Ctx, ins Instr) (bool, bool, error) {
+			return ctx.lowerPackedLogicalFamily(ins.Op, ins)
+		},
+	}
+	for _, opcode := range x86LogicalOpcodeNames() {
+		if x86PackedLogicalSpecs[opcode].encoding > x86PackedLogicalLegacyInteger {
+			logical.rows = append(logical.rows, x86LogicalAcceptedForms(opcode, "386")...)
+		}
+	}
+	move := mode32VectorFamilyCase{
+		name: "move",
+		properties: func(ins Instr, arch string) (bool, error) {
+			_, recognized, err := amd64PackedVectorMoveProperties(ins, arch)
+			return recognized, err
+		},
+		lower: func(ctx *amd64Ctx, ins Instr) (bool, bool, error) {
+			return ctx.lowerPackedVectorMove(ins.Op, ins)
+		},
+	}
+	var moves []string
+	for opcode := range amd64PackedVectorMoveSpecs {
+		moves = append(moves, string(opcode))
+	}
+	sort.Strings(moves)
+	for _, opcode := range moves {
+		spec := amd64PackedVectorMoveSpecs[Op(opcode)]
+		high := 31
+		if spec.encoding == amd64PackedMoveVEX {
+			high = 15
+		}
+		for _, bank := range []string{"X", "Y"} {
+			reg := fmt.Sprintf("%s%d", bank, high)
+			for _, args := range []string{"(AX)," + reg, reg + ",(AX)", reg + "," + bank + "0"} {
+				move.rows = append(move.rows, opcode+" "+args)
+			}
+			if spec.encoding != amd64PackedMoveVEX {
+				for _, args := range []string{"(AX),K7," + reg, reg + ",K7,(AX)", reg + ",K7," + bank + "0"} {
+					move.rows = append(move.rows, opcode+" "+args, opcode+".Z "+args)
+				}
+			}
+		}
+	}
+	fma := mode32VectorFamilyCase{
+		name: "FMA3",
+		properties: func(ins Instr, arch string) (bool, error) {
+			_, recognized, err := amd64FMA3Properties(ins, arch)
+			return recognized, err
+		},
+		lower: func(ctx *amd64Ctx, ins Instr) (bool, bool, error) {
+			return ctx.lowerFMA3(ins.Op, ins)
+		},
+	}
+	// Scalar rounding, memory and packed broadcast axes remain in the source.
+	// Z0-Z7 are physically available; this regression targets the X/Y banks.
+	for _, row := range x86FMA3NamedFormats("386") {
+		changed := strings.NewReplacer("X2", "X16", "Y2", "Y16").Replace(row)
+		if changed != row {
+			fma.rows = append(fma.rows, changed)
+		}
+	}
+	return []mode32VectorFamilyCase{logical, move, fma}
+}
+
+func TestX86Mode32VectorFamiliesRequirePhysicalBindings(t *testing.T) {
+	checked := 0
+	for _, family := range mode32VectorFamilyCases() {
+		for _, row := range family.rows {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			high := false
+			for _, operand := range instruction.Args {
+				width := amd64VectorByteWidth(operand.Reg)
+				index, valid := amd64VectorRegisterIndex(operand.Reg, width)
+				high = high || operand.Kind == OpReg && valid && index >= 8
+			}
+			if !high {
+				continue
+			}
+			checked++
+			t.Run(family.name+"/"+strings.ReplaceAll(row, " ", "_"), func(t *testing.T) {
+				requireX86GoAssemblerResult(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", true)
+				if recognized, err := family.properties(instruction, "386"); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-accepted high bank became a physical mode32 binding: recognized=%v err=%v", recognized, err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = "386"
+				before := output.String()
+				if recognized, _, err := family.lower(ctx, instruction); !recognized ||
+					!errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+					t.Fatalf("unproved high-bank source emitted IR: recognized=%v err=%v", recognized, err)
+				}
+			})
+		}
+	}
+	if checked != 664 {
+		t.Fatalf("Go-accepted high-bank inventory changed: checked %d rows, want 664", checked)
+	}
+}
+
+// This checks only the shared identity predicate. Family grammar tests above
+// independently prove source acceptance, and the object tests retain low-bank
+// success; this helper cannot manufacture a supported source operand.
+func TestX86Mode32VectorRegisterContextBindsEveryOperand(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, index := range []int{0, 7, 8, 15, 16, 31} {
+				for position := 0; position < 4; position++ {
+					name := fmt.Sprintf("%s/%s%d/operand%d", arch, bank, index, position)
+					t.Run(name, func(t *testing.T) {
+						args := make([]Operand, 4)
+						for i := range args {
+							args[i] = Operand{Kind: OpReg, Reg: Reg(bank + "0")}
+						}
+						args[position].Reg = Reg(fmt.Sprintf("%s%d", bank, index))
+						instruction := Instr{Op: "VECTOR_IDENTITY", Args: args}
+						err := x86Mode32VectorRegisterContext(instruction, arch)
+						if arch == "386" && index >= 8 {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("unproved physical identity accepted: %v", err)
+							}
+						} else if err != nil {
+							t.Fatalf("physical register bank rejected: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_mov_extension_caller_test.go b/amd64_mov_extension_caller_test.go
new file mode 100644
index 000000000..9e9cd6d7c
--- /dev/null
+++ b/amd64_mov_extension_caller_test.go
@@ -0,0 +1,610 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86ExtensionTestOperations = []string{
+	"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVBQSX", "MOVBQZX",
+	"MOVWLSX", "MOVWLZX", "MOVWQSX", "MOVWQZX", "MOVLQSX", "MOVLQZX",
+	"MOVSWW", "MOVZWW",
+}
+
+func TestX86ExtensionCompletePrimaryTables(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go")
+	bytes, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(bytes)
+	for _, name := range []string{"ymb_rl", "yml_rl"} {
+		pattern := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{\s*\{(Zmb_r|Zm_r), 1, argList\{(Ymb|Yml), Yrl\}\},\s*\}`)
+		if !pattern.MatchString(table) {
+			t.Fatalf("actual Go table changed: %s", name)
+		}
+	}
+	rows := regexp.MustCompile(`\{A(MOV[A-Z]+), (ymb_rl|yml_rl), (Pm|Pw|Pq|Pe|Px),`).FindAllStringSubmatch(table, -1)
+	var names []string
+	for _, row := range rows {
+		names = append(names, row[1])
+	}
+	want := append([]string(nil), x86ExtensionTestOperations...)
+	sort.Strings(names)
+	sort.Strings(want)
+	if strings.Join(names, ",") != strings.Join(want, ",") {
+		t.Fatalf("complete extension rows changed: got %v, want %v", names, want)
+	}
+}
+
+func x86ExtensionGoListing(t *testing.T, arch, instruction string) (string, error) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "extension.s")
+	source := "TEXT ·extension(SB),4,$0-0\n" + instruction + "\nRET\n"
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "extension",
+		"-o", filepath.Join(dir, "extension.o"), path)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	return string(output), err
+}
+
+func TestX86ExtensionActualGoAliasAudit(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{
+			"MOVSWW AL,AX", "MOVSWW AH,AX", "MOVSWW BP,AX",
+			"MOVZWW AL,AX", "MOVZWW AH,AX", "MOVZWW BP,AX",
+			"MOVBLSX AH,AX", "MOVBLSX BP,AX", "MOVLQZX AX,BX",
+		} {
+			t.Run(arch+"/"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+				listing, err := x86ExtensionGoListing(t, arch, instruction)
+				if err != nil {
+					t.Fatalf("actual %s assembler: %v\n%s", runtime.Version(), err, listing)
+				}
+				t.Log(listing)
+			})
+		}
+	}
+}
+
+func TestX86ExtensionGoPhysicalRegisterViews(t *testing.T) {
+	for _, test := range []struct {
+		instruction, bytes string
+		source             Reg
+	}{
+		{"MOVSWW AL,AX", "66 0f bf c0 c3", AX},
+		{"MOVSWW AH,AX", "66 0f bf c4 c3", SP},
+		{"MOVZWW CH,AX", "66 0f b7 c5 c3", BP},
+		{"MOVSWW DH,AX", "66 0f bf c6 c3", SI},
+		{"MOVZWW BH,AX", "66 0f b7 c7 c3", DI},
+		{"MOVBLSX AH,AX", "0f be c4 c3", AH},
+		{"MOVBLSX AH,R8", "44 0f be c4 c3", SP},
+		{"MOVBQSX BH,AX", "48 0f be c7 c3", DI},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			listing, err := x86ExtensionGoListing(t, "amd64", test.instruction)
+			if err != nil || !strings.Contains(listing, test.bytes) {
+				t.Fatalf("actual Go machine view: %v\n%s", err, listing)
+			}
+			file, err := Parse(ArchAMD64, "TEXT v(SB),4,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			before := append([]Operand(nil), ins.Args...)
+			form, recognized, err := x86ScalarExtensionProperties(ins.Op, ins, "amd64")
+			if !recognized || err != nil || form.source.Reg != test.source || !reflect.DeepEqual(before, ins.Args) {
+				t.Fatalf("Go ModRM view/source mutation: %+v recognized=%t err=%v", form, recognized, err)
+			}
+		})
+	}
+}
+
+func TestX86ExtensionCompleteFormatsThreeAPIFiveObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var body strings.Builder
+			for _, instruction := range x86ExtensionOriginalFormatRows(t, target.arch) {
+				body.WriteString(instruction + "\n")
+			}
+			body.WriteString("@MOV CX,ret+@WORD(FP)\nRET")
+			source, sig, pkg := x86SourceStackNumericalFixture(target.arch, body.String())
+			source += "GLOBL ·payload(SB),8,$16\nDATA ·payload+0(SB)/8,$0x1122334455667788\n"
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Keep the complete original mixed source. It has no producers
+			// for AX/BX/SI or its physical SP bytes; Go format acceptance
+			// alone cannot supply those inputs to any public API.
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("original mixed source acquired missing entry inputs", api, err)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"Value": sig}, target.arch, target.triple, 0)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+			}
+		})
+	}
+}
+
+func x86ExtensionOriginalFormatRows(t *testing.T, arch string) []string {
+	t.Helper()
+	var rows []string
+	for _, operation := range x86ExtensionTestOperations {
+		if arch == "386" && (operation == "MOVBQSX" || operation == "MOVBQZX" ||
+			operation == "MOVWQSX" || operation == "MOVWQZX" || operation == "MOVLQSX") {
+			continue
+		}
+		for _, source := range []string{"AX", "8(BX)", "-1(BX)(SI*2)", "x+0(FP)", "@WORD(SP)", "·payload(SB)"} {
+			rows = append(rows, fmt.Sprintf("%s %s,CX", operation, source))
+		}
+		if strings.HasPrefix(operation, "MOVB") || operation == "MOVSWW" || operation == "MOVZWW" {
+			rows = append(rows, operation+" BL,CX")
+			if arch == "386" {
+				rows = append(rows, operation+" DI,CX")
+			}
+		}
+	}
+	want := 92
+	if arch == "386" {
+		want = 66
+	}
+	if len(rows) != want {
+		t.Fatal("complete original extension format inventory changed", arch, len(rows), want)
+	}
+	return rows
+}
+
+func TestX86ExtensionOriginalOrdinaryFormsWithRealInputs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var ordinary []string
+			physical := 0
+			for _, row := range x86ExtensionOriginalFormatRows(t, target.arch) {
+				if strings.Contains(row, "@WORD(SP)") {
+					physical++
+					continue
+				}
+				ordinary = append(ordinary, row)
+			}
+			want, wantPhysical := 78, 14
+			if target.arch == "386" {
+				want, wantPhysical = 57, 9
+			}
+			if len(ordinary) != want || physical != wantPhysical {
+				t.Fatal("original ordinary/physical source partition changed", len(ordinary), physical)
+			}
+			for start := 0; start < len(ordinary); start += 32 {
+				end := start + 32
+				if end > len(ordinary) {
+					end = len(ordinary)
+				}
+				t.Run(fmt.Sprintf("batch%d", start/32), func(t *testing.T) {
+					var source, declarations strings.Builder
+					source.WriteString("GLOBL ·payload(SB),8,$16\nDATA ·payload+0(SB)/8,$0x1122334455667788\n")
+					for ordinal, row := range ordinary[start:end] {
+						name := fmt.Sprintf("Extension%d", ordinal)
+						fmt.Fprintf(&declarations, "func %s(x %s, p *[32]byte) %s\n", name, typ, typ)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+%d(FP),BX\n%s x+0(FP),AX\nMOVL $1,SI\nMOVL $2,DI\n%s $0,CX\n",
+							name, 3*word, move, word, move, move)
+						if strings.Contains(row, " BL,") {
+							source.WriteString("MOVL $3,BX\n")
+						}
+						fmt.Fprintf(&source, "%s\n%s CX,ret+%d(FP)\nRET\n", row, move, 2*word)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal("original ordinary tuple with real new input producers", api, err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ExtensionOriginalPhysicalSPWithCapturedAMD64Frame(t *testing.T) {
+	goAMD64FramePrepareOwnedToolCache(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The AMD64 frame producer cannot certify a 386 frame.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86ExtensionOriginalFormatRows(t, target.arch) {
+				if !strings.Contains(row, "@WORD(SP)") {
+					continue
+				}
+				row = strings.Replace(row, "@WORD", "8", 1)
+				name := fmt.Sprintf("Physical%d", count)
+				fmt.Fprintf(&declarations, "func %s(x uint64) uint64\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$32-16\nMOVQ x+0(FP),AX\nMOVQ AX,8(SP)\nMOVQ $0,CX\n%s\nMOVQ CX,ret+8(FP)\nRET\n", name, row)
+				count++
+			}
+			if count != 14 {
+				t.Fatal("complete original AMD64 physical-SP format set changed", count)
+			}
+			goos := "linux"
+			if strings.Contains(target.triple, "apple") {
+				goos = "darwin"
+			} else if strings.Contains(target.triple, "windows") {
+				goos = "windows"
+			}
+			pkg, request, _, options := fixedLocalTransportFixture(t, source.String(), declarations.String(), goos+"/amd64", target.triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"},
+				func(t *testing.T, ir string, err error) {
+					if err != nil {
+						t.Fatal("same physical 8(SP) tuple with actual captured frame and numerical stores", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+		})
+	}
+}
+
+func TestX86ExtensionOriginal386PhysicalSPStillNeedsSourceOwner(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			count := 0
+			for _, row := range x86ExtensionOriginalFormatRows(t, target.arch) {
+				if !strings.Contains(row, "@WORD(SP)") {
+					continue
+				}
+				source, _, pkg := x86SourceStackNumericalFixture(target.arch,
+					"MOVL $0,CX\n"+row+"\n@MOV CX,ret+@WORD(FP)\nRET\n")
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("unowned physical 4(SP) bytes acquired numerical authority", row, api, err)
+					}
+				}
+				count++
+			}
+			if count != 9 {
+				t.Fatal("complete original 386 physical-SP source-role boundary changed", count)
+			}
+			t.Log("all nine original physical-SP formats retain pending public source ownership; Go/private format objects are checked separately")
+		})
+	}
+}
+
+func TestX86ExtensionSourceAndPhysicalDecoderShareEffects(t *testing.T) {
+	for _, operation := range x86ExtensionTestOperations {
+		for _, body := range []string{operation + " BX,AX", x86ExtensionNumericalRawBytes(operation)} {
+			for _, defined := range []bool{false, true} {
+				prefix := ""
+				if defined {
+					prefix = "MOVQ $0xff80,BX\n"
+				}
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", prefix+body+"\nMOVL AX,(DX)", 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+				if defined && err != nil || !defined && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("source/physical input availability defined=%t: %v\n%s", defined, err, body)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExtensionSharedFormIsOrderedAndImmutable(t *testing.T) {
+	for _, operation := range x86ExtensionTestOperations {
+		file, err := Parse(ArchAMD64, "TEXT v(SB),4,$0-0\n"+operation+" AX,BX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0].Instrs[1]
+		for _, spelling := range []Op{original.Op, "", "MOVQ"} {
+			instruction := original
+			instruction.Op = spelling
+			before := append([]Operand(nil), instruction.Args...)
+			_, recognized, err := x86ScalarExtensionProperties(original.Op, instruction, "amd64")
+			if !recognized || (err == nil) != (spelling != "MOVQ") || !reflect.DeepEqual(before, instruction.Args) {
+				t.Fatalf("%s spelling %s: recognized=%t err=%v source changed=%t", operation, spelling, recognized, err, !reflect.DeepEqual(before, instruction.Args))
+			}
+		}
+	}
+}
+
+func TestX86ExtensionActualGoRejectedFormats(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, operation := range x86ExtensionTestOperations {
+			if target.arch == "386" && amd64ScalarExtensionMoveSpecs[Op(operation)].rejectedOn386 {
+				requireX86GoAssemblerResult(t, target.arch, "TEXT ·extension(SB),4,$0-0\n"+operation+" AX,BX\nRET\n", false)
+				continue
+			}
+			for _, operands := range []string{"$1,AX", "AX,(BX)", "X1,AX", "AX,AL", "8(BAD),AX"} {
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, operation+" "+operands+"\nRET")
+				requireX86GoAssemblerResult(t, target.arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					continue // The public parser itself rejected the original format.
+				}
+				options := x86SourceStackOptions(target.arch, target.triple, sig)
+				if _, err := Translate(file, options); err == nil {
+					t.Fatalf("Translate accepted Go-rejected %s %s", operation, operands)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if err == nil {
+					t.Fatalf("TranslateModule accepted Go-rejected %s %s", operation, operands)
+				}
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if translation != nil {
+					translation.Module.Dispose()
+				}
+				ctx.Dispose()
+				if err == nil {
+					t.Fatalf("TranslateGoModule accepted Go-rejected %s %s", operation, operands)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExtensionRawMOVSXDRequiresKnownNativeWidth(t *testing.T) {
+	// Register and default-32 memory widths have independent native contracts.
+	// The 66 memory footprint still differs across vendor descriptions.
+	for _, encoding := range []string{"BYTE $0x66\nWORD $0x0763", "BYTE $0x66\nWORD $0x0f63"} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "MOVQ $0x80000000,BX\n"+encoding+"\nMOVL AX,(DX)", 1)
+		requireX86GoAssemblerResult(t, "amd64", assembly, true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown raw MOVSXD width Translate: %v", err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown raw MOVSXD width module: %v", err)
+			}
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown raw MOVSXD width Go module: %v", err)
+			}
+		}
+	}
+}
+
+func TestX86GoCallerRegionExtensionSourceInputs(t *testing.T) {
+	for _, operation := range x86ExtensionTestOperations {
+		for _, input := range []string{"register", "memory"} {
+			t.Run(operation+"/"+input, func(t *testing.T) {
+				operand := "AX"
+				if input == "memory" {
+					operand = "(DI)"
+				}
+				body := fmt.Sprintf("%s %s,AX\nMOVL AX,(DX)", operation, operand)
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				requireX86GoAssemblerResult(t, "amd64", assembly, true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoCallerRegionExtensionDefinedBytesAndPointerNegatives(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"one initialized low byte", "MOVB $128,BX\nMOVBLZX BL,AX", true},
+		{"one initialized high byte", "MOVB $128,BH\nMOVBLSX BH,AX", true},
+		{"complete low word via aliases", "MOVB $128,BL\nMOVB $255,BH\nMOVSWW BL,AX", true},
+		{"word low byte incomplete", "MOVB $128,BL\nMOVSWW BL,AX", false},
+		{"unknown source", "MOVLQSX BX,AX", false},
+		{"partial source long", "MOVW $7,BX\nMOVLQSX BX,AX", false},
+		{"caller pointer sign extension", "MOVLQSX DI,AX", false},
+		{"caller pointer byte extension", "MOVBQZX DI,AX", false},
+		{"caller pointer apparent high-byte REX", "MOVBQZX BH,AX", false},
+		{"implicit SP source", "MOVSWW AH,AX", false},
+		{"implicit BP source", "MOVZWW CH,AX", false},
+		{"partial pointer destination", "MOVQ DI,BX\nMOVBWZX AL,BX", false},
+		{"partial pointer replaced completely", "MOVQ DI,BX\nMOVBLZX AL,BX", true},
+		{"unaligned pointer slot", "MOVLQSX a+1(FP),AX", false},
+		{"partial pointer FP slot", "MOVLQSX a+0(FP),AX", false},
+		{"return PC load", "MOVLQSX 8(BP),AX", false},
+		{"saved BP load", "MOVWLZX 0(BP),AX", false},
+		{"different defined bytes join", "CMPQ AX,$0\nJE other\nMOVB $7,BL\nother:\nMOVBLZX BL,AX", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", test.body+"\nMOVL AX,(DX)", 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu")
+			if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("valid=%t: %v", test.valid, err)
+			}
+		})
+	}
+}
+
+func TestX86GoCallerRegionExtensionThreeAPIs(t *testing.T) {
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "MOVLQSX (DI),AX\nMOVL AX,(DX)", 1)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, findLLVM22Tool("llc"), triple, "extension.ll", "extension.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, findLLVM22Tool("llc"), triple, "extension-module.ll", "extension-module.o", module.String())
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86SourceStackExtensionRequiresDefinedLowBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, operation := range x86ExtensionTestOperations {
+			if target.arch == "386" && amd64ScalarExtensionMoveSpecs[Op(operation)].rejectedOn386 {
+				continue // Covered separately as actual Go-rejected formats, not Context forms.
+			}
+			for _, prefix := range []string{"", "MOVB $7,BX\n", "@MOV x+0(FP),BX\n"} {
+				body := prefix + operation + " BX,AX\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3"
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := x86SourceStackOptions(target.arch, target.triple, sig)
+				if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("noncaller source acquired extension proof: %v\n%s", err, source)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("noncaller source acquired module proof: %v\n%s", err, source)
+				}
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if translation != nil {
+					translation.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("noncaller source acquired Go module proof: %v\n%s", err, source)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExtensionCannotBorrowStaleCallerMemoryEffects(t *testing.T) {
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "MOVLQSX (DI),AX\nMOVL AX,(DX)", 1)
+	for _, change := range []string{"width", "opcode", "source", "missing caller"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs, ResolveSym: resolve}
+			normalized, err := normalizeX86RawFile(file, "amd64", options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index := range normalized.Funcs[0].Instrs {
+				instruction := &normalized.Funcs[0].Instrs[index]
+				if instruction.Op != "MOVLQSX" {
+					continue
+				}
+				switch change {
+				case "width":
+					access := instruction.x86CallerMemory[0]
+					access.width = 8 // Actual read width is 4, never the result width.
+					instruction.x86CallerMemory[0] = access
+				case "opcode":
+					instruction.Op = "MOVWQSX"
+				case "source":
+					instruction.Args[0].Mem.Base = DX
+				}
+			}
+			if change == "missing caller" {
+				sig := sigs["caller.kernel"]
+				sig.x86CallerRegions = nil
+				sigs["caller.kernel"] = sig
+			}
+			if change == "width" {
+				if x86RawReturnMemoryBound(normalized.Funcs[0], normalized, options, true) {
+					t.Fatal("extension accepted a stale destination-width memory certificate")
+				}
+				return // A final consumer legitimately recomputes unchanged source effects.
+			}
+			if _, err := Translate(normalized, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed %s borrowed an extension caller proof: %v", change, err)
+			}
+		})
+	}
+}
diff --git a/amd64_mov_extension_effects.go b/amd64_mov_extension_effects.go
new file mode 100644
index 000000000..24f06cf47
--- /dev/null
+++ b/amd64_mov_extension_effects.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ScalarExtensionMoveSpec struct {
+	sourceBits      int
+	destinationBits int
+	signed          bool
+	rejectedOn386   bool
+	byteClass       bool
+}
+
+// These fourteen rows use Go's ymb_rl or yml_rl tables. MOVSWW/MOVZWW
+// read a word despite using ymb_rl and its byte-register ModRM spellings.
+var amd64ScalarExtensionMoveSpecs = map[Op]amd64ScalarExtensionMoveSpec{
+	"MOVBWSX": {sourceBits: 8, destinationBits: 16, signed: true, byteClass: true},
+	"MOVBWZX": {sourceBits: 8, destinationBits: 16, byteClass: true},
+	"MOVBLSX": {sourceBits: 8, destinationBits: 32, signed: true, byteClass: true},
+	"MOVBLZX": {sourceBits: 8, destinationBits: 32, byteClass: true},
+	"MOVBQSX": {sourceBits: 8, destinationBits: 64, signed: true, rejectedOn386: true, byteClass: true},
+	"MOVBQZX": {sourceBits: 8, destinationBits: 64, rejectedOn386: true, byteClass: true},
+	"MOVWLSX": {sourceBits: 16, destinationBits: 32, signed: true},
+	"MOVWLZX": {sourceBits: 16, destinationBits: 32},
+	"MOVWQSX": {sourceBits: 16, destinationBits: 64, signed: true, rejectedOn386: true},
+	"MOVWQZX": {sourceBits: 16, destinationBits: 64, rejectedOn386: true},
+	"MOVLQSX": {sourceBits: 32, destinationBits: 64, signed: true, rejectedOn386: true},
+	"MOVLQZX": {sourceBits: 32, destinationBits: 64},
+	"MOVSWW":  {sourceBits: 16, destinationBits: 16, signed: true, byteClass: true},
+	"MOVZWW":  {sourceBits: 16, destinationBits: 16, byteClass: true},
+}
+
+type x86ScalarExtensionForm struct {
+	spec   amd64ScalarExtensionMoveSpec
+	source Operand
+	result Reg
+}
+
+func x86ScalarExtensionProperties(op Op, ins Instr, arch string) (x86ScalarExtensionForm, bool, error) {
+	op = Op(strings.ToUpper(string(op)))
+	spec, recognized := amd64ScalarExtensionMoveSpecs[op]
+	if !recognized {
+		return x86ScalarExtensionForm{}, false, nil
+	}
+	fail := func(reason string) (x86ScalarExtensionForm, bool, error) {
+		return x86ScalarExtensionForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 {
+		return fail("requires matching opcode and two operands")
+	}
+	if arch == "386" && spec.rejectedOn386 {
+		return fail("is outside Go's 386 extension tables")
+	}
+	if arch == "386" && op == "MOVLQZX" {
+		// Px is an ordinary MOVL in 386 mode, not a 64-bit write.
+		spec.destinationBits = 32
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, source, arch); segment {
+		if err != nil {
+			return x86ScalarExtensionForm{}, true, err
+		}
+		source = projected
+	}
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, arch) {
+		return fail("expects a Yrl destination register")
+	}
+	if source.Kind == OpReg {
+		valid := isX86YrlRegisterForArch(source.Reg, arch)
+		if spec.byteClass {
+			valid = isGoYmbRegisterForArch(source.Reg, arch)
+		}
+		if !valid {
+			return fail("source register is outside its Go class")
+		}
+		if spec.byteClass && spec.sourceBits == 16 {
+			source.Reg = amd64YmbEffectiveRegister(source.Reg, 16)
+		} else if spec.sourceBits == 8 && arch != "386" &&
+			(spec.destinationBits == 64 || x86ExtensionHighRegister(destination.Reg)) {
+			// A REX prefix changes ModRM 4..7 from AH/CH/DH/BH to the
+			// low bytes of SP/BP/SI/DI. Go emits those actual bytes too.
+			switch source.Reg {
+			case AH, CH, DH, BH:
+				source.Reg = amd64YmbEffectiveRegister(source.Reg, 16)
+			}
+		}
+	} else if !isAMD64MemoryOperand(source) ||
+		source.Kind == OpSym && !x86PackedShiftMemoryValid(source, arch) {
+		return fail("expects a register or memory source")
+	}
+	if source.Kind == OpMem && !x86MemoryRegistersValidForArch(source.Mem, arch) {
+		return fail("memory source has an invalid address register")
+	}
+	return x86ScalarExtensionForm{spec: spec, source: source, result: destination.Reg}, true, nil
+}
+
+func x86ExtensionHighRegister(register Reg) bool {
+	switch register {
+	case "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+		return true
+	default:
+		return false
+	}
+}
+
+func x86ScalarMoveMemoryBytes(ins Instr, operand int, arch string) int64 {
+	if form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch); known {
+		if err == nil && operand == 0 && isAMD64MemoryOperand(form.source) {
+			return int64(form.bits / 8)
+		}
+		return 0
+	}
+	op := Op(normalizeInstructionOpcode(x86SourceMoveInstruction(ins, arch).Op))
+	if _, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); recognized {
+		if err == nil && operand == 0 {
+			return 1
+		}
+		return 0
+	}
+	if width := x86RawReturnScalarMoveBytes(op); width != 0 {
+		return width
+	}
+	form, recognized, err := x86ScalarExtensionProperties(op, ins, arch)
+	if !recognized || err != nil || operand != 0 {
+		return 0
+	}
+	return int64(form.spec.sourceBits / 8)
+}
+
+func x86CallerExtensionStep(ins *Instr, state *x86SourceStackState, proof *x86GoCallerRegionProof) (bool, bool) {
+	form, recognized, err := x86ScalarExtensionProperties(ins.Op, *ins, "amd64")
+	if !recognized || err != nil {
+		return recognized, false
+	}
+	width := int64(form.spec.sourceBits / 8)
+	if !x86CallerMemoryStep(ins, state, proof, width) {
+		return true, false
+	}
+	if form.source.Kind != OpMem && !x86CallerNumericRead(form.source, width, state) {
+		return true, false
+	}
+	return true, x86CallerNumericWrite(form.result, int64(form.spec.destinationBits/8), state)
+}
diff --git a/amd64_mov_extension_identity_test.go b/amd64_mov_extension_identity_test.go
new file mode 100644
index 000000000..04aedfe87
--- /dev/null
+++ b/amd64_mov_extension_identity_test.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ExtensionHelperAcceptsMatchingCaseAndEmptyIdentity(t *testing.T) {
+	for _, operation := range x86ExtensionTestOperations {
+		for _, identity := range []string{"", operation, strings.ToLower(operation), "Mov" + strings.ToLower(operation[3:])} {
+			for _, dispatch := range []Op{Op(operation), Op(strings.ToLower(operation))} {
+				instruction := Instr{Op: Op(identity), Raw: operation + " AX,BX", Args: []Operand{
+					{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX},
+				}}
+				before := append([]Operand(nil), instruction.Args...)
+				form, recognized, err := x86ScalarExtensionProperties(dispatch, instruction, "amd64")
+				if !recognized || err != nil || form.result != BX || !reflect.DeepEqual(before, instruction.Args) || instruction.Op != Op(identity) {
+					t.Fatalf("%s identity %q: form=%+v recognized=%t err=%v", operation, identity, form, recognized, err)
+				}
+				ctx, _ := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+				if err := ctx.lowerScalarExtensionMove(dispatch, instruction); err != nil {
+					t.Fatalf("matching dispatch %s / %q: %v", operation, identity, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExtensionHelperRejectsUnknownOrConflictingDispatchBeforeIR(t *testing.T) {
+	for _, operation := range []Op{"MOVLQSX", "UNKNOWN_EXTENSION", "MOVQ"} {
+		instruction := Instr{Op: "MOVWQSX", Raw: "MOVWQSX AX,BX", Args: []Operand{
+			{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX},
+		}}
+		before := append([]Operand(nil), instruction.Args...)
+		ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+		length := output.Len()
+		if err := ctx.lowerScalarExtensionMove(operation, instruction); err == nil || output.Len() != length || !reflect.DeepEqual(before, instruction.Args) {
+			t.Fatalf("dispatch %s: err=%v emitted=%d mutated=%t", operation, err, output.Len()-length, !reflect.DeepEqual(before, instruction.Args))
+		}
+	}
+}
diff --git a/amd64_mov_extension_runtime_test.go b/amd64_mov_extension_runtime_test.go
new file mode 100644
index 000000000..d4ced629f
--- /dev/null
+++ b/amd64_mov_extension_runtime_test.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86ExtensionNumericalCase struct {
+	op             string
+	source, result int
+	signed         bool
+	mode, name     string
+}
+
+func x86ExtensionNumericalCases() []x86ExtensionNumericalCase {
+	var cases []x86ExtensionNumericalCase
+	for _, operation := range []x86ExtensionNumericalCase{
+		{op: "MOVBWSX", source: 8, result: 16, signed: true},
+		{op: "MOVBWZX", source: 8, result: 16},
+		{op: "MOVBLSX", source: 8, result: 32, signed: true},
+		{op: "MOVBLZX", source: 8, result: 32},
+		{op: "MOVBQSX", source: 8, result: 64, signed: true},
+		{op: "MOVBQZX", source: 8, result: 64},
+		{op: "MOVWLSX", source: 16, result: 32, signed: true},
+		{op: "MOVWLZX", source: 16, result: 32},
+		{op: "MOVWQSX", source: 16, result: 64, signed: true},
+		{op: "MOVWQZX", source: 16, result: 64},
+		{op: "MOVLQSX", source: 32, result: 64, signed: true},
+		{op: "MOVLQZX", source: 32, result: 64},
+		{op: "MOVSWW", source: 16, result: 16, signed: true},
+		{op: "MOVZWW", source: 16, result: 16},
+	} {
+		for _, mode := range []string{"Register", "Memory", "LowAlias", "InPlace", "PhysicalBytes"} {
+			if mode == "LowAlias" && operation.source == 32 ||
+				mode == "LowAlias" && operation.source == 16 && operation.result != 16 {
+				continue
+			}
+			operation.mode = mode
+			operation.name = "extension" + operation.op + mode
+			cases = append(cases, operation)
+		}
+	}
+	// REX.W changes BH to DI's low byte. The source DI is explicitly numeric
+	// here, not the imported input pointer or an unknown entry register.
+	for _, operation := range []x86ExtensionNumericalCase{
+		{op: "MOVBQZX", source: 8, result: 64},
+		{op: "MOVBQSX", source: 8, result: 64, signed: true},
+		{op: "MOVSWW", source: 16, result: 16, signed: true},
+		{op: "MOVZWW", source: 16, result: 16},
+	} {
+		operation.mode, operation.name = "PhysicalAlias", "extension"+operation.op+"PhysicalAlias"
+		cases = append(cases, operation)
+	}
+	return cases
+}
+
+// Independent fixed encodings for the BX-to-AX forms. In particular LQSX
+// requires REX.W; the ambiguous no-REX 63 form is a separate Context test.
+func x86ExtensionNumericalRawBytes(operation string) string {
+	encodings := map[string][]byte{
+		"MOVBWSX": {0x66, 0x0f, 0xbe, 0xc3},
+		"MOVBWZX": {0x66, 0x0f, 0xb6, 0xc3},
+		"MOVBLSX": {0x0f, 0xbe, 0xc3},
+		"MOVBLZX": {0x0f, 0xb6, 0xc3},
+		"MOVBQSX": {0x48, 0x0f, 0xbe, 0xc3},
+		"MOVBQZX": {0x48, 0x0f, 0xb6, 0xc3},
+		"MOVWLSX": {0x0f, 0xbf, 0xc3},
+		"MOVWLZX": {0x0f, 0xb7, 0xc3},
+		"MOVWQSX": {0x48, 0x0f, 0xbf, 0xc3},
+		"MOVWQZX": {0x48, 0x0f, 0xb7, 0xc3},
+		"MOVLQSX": {0x48, 0x63, 0xc3},
+		"MOVLQZX": {0x8b, 0xc3},
+		"MOVSWW":  {0x66, 0x0f, 0xbf, 0xc3},
+		"MOVZWW":  {0x66, 0x0f, 0xb7, 0xc3},
+	}
+	var source strings.Builder
+	for _, value := range encodings[operation] {
+		fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+	}
+	return source.String()
+}
+
+func x86ExtensionNumericalSource() (string, string) {
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	for _, test := range x86ExtensionNumericalCases() {
+		declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint64")
+		declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+		declaration = strings.ReplaceAll(declaration, "kernel", test.name)
+		declaration = strings.Replace(declaration, "func Call(", "func Call"+test.name+"(", 1)
+		declarations.WriteString(declaration)
+		operand := "BX"
+		body := "MOVQ (DI),BX\nMOVQ $0x5a6b7c8d9eaf1021,AX\n"
+		switch test.mode {
+		case "Memory":
+			operand = "(DI)"
+		case "LowAlias":
+			operand = "BL"
+		case "InPlace":
+			body += "MOVQ BX,AX\n"
+			operand = "AX"
+		case "PhysicalAlias":
+			body += "MOVQ BX,DI\n"
+			operand = "BH"
+		}
+		body += "CMPQ BX,$0\n"
+		if test.mode == "PhysicalBytes" {
+			body += x86ExtensionNumericalRawBytes(test.op)
+		} else {
+			body += fmt.Sprintf("%s %s,AX\n", test.op, operand)
+		}
+		body += "JE done\nADDQ $7,AX\ndone:\nMOVQ AX,(DX)"
+		machine := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+test.name)
+		machine = strings.Replace(machine, "MOVL $7,AX\nMOVL AX,(DX)", body, 1)
+		assembly.WriteString(machine)
+	}
+	return declarations.String(), assembly.String()
+}
+
+func x86ExtensionActualGoNumerical(t *testing.T, declaration, assembly string, runner []string) {
+	t.Helper()
+	var tests strings.Builder
+	tests.WriteString(`package caller
+import "testing"
+func reference(input uint64, source, result uint, signed, inPlace bool) uint64 {
+	mask := uint64(1)<<source - 1
+	value := input & mask
+	if signed && value&(uint64(1)<<(source-1)) != 0 {
+		value |= ^mask
+	}
+	if result == 16 {
+		seed := uint64(0x5a6b7c8d9eaf1021)
+		if inPlace { seed = input }
+		value = seed & ^uint64(65535) | value & 65535
+	} else if result == 32 {
+		value = uint64(uint32(value))
+	}
+	if input != 0 { value += 7 }
+	return value
+}
+func TestOriginalExtensionNumerical(t *testing.T) {
+`)
+	for _, test := range x86ExtensionNumericalCases() {
+		fmt.Fprintf(&tests, `
+	for iteration := 0; iteration < 16; iteration++ {
+		for _, input := range []uint64{0, 1, 127, 128, 65535, 1<<31, 1<<63, ^uint64(0)} {
+			x := []uint64{input, 0x1122334455667788}
+			y := []uint64{0x8877665544332211, 23}
+			canary := [4]uint64{11, 23, 37, 41}
+			got := Call%[1]s(x, y)
+			want := reference(input, %[2]d, %[3]d, %[4]t, %[5]t)
+			if got != want || x[0] != input || x[1] != 0x1122334455667788 ||
+				y[0] != 0x8877665544332211 || y[1] != 23 || canary != [4]uint64{11,23,37,41} {
+				t.Fatalf("%[1]s got=%%#x want=%%#x input=%%#x canary=%%v", got, want, input, canary)
+			}
+		}
+	}
+`, test.name, test.source, test.result, test.signed, test.mode == "InPlace")
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": declaration,
+		"value_amd64.s": assembly, "value_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	binary := filepath.Join(dir, "original.test")
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go extension build: %v\n%s", err, output)
+	}
+	arguments := append(append([]string(nil), runner...), binary, "-test.v", "-test.timeout=2m")
+	command = exec.CommandContext(ctx, arguments[0], arguments[1:]...)
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go extension numerical/canary: %v\n%s", err, output)
+	}
+}
+
+func x86ExtensionCOracle() string {
+	var declarations, checks strings.Builder
+	for _, test := range x86ExtensionNumericalCases() {
+		fmt.Fprintf(&declarations, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", test.name, test.name)
+		fmt.Fprintf(&checks, "    if (check(%s, %d, %d, %t, %t)) return %d;\n",
+			test.name, test.source, test.result, test.signed, test.mode == "InPlace", 1+len(strings.Split(checks.String(), "\n")))
+	}
+	return `#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+` + declarations.String() + `
+static uint64_t reference(uint64_t input, unsigned source, unsigned result, bool sign, bool in_place) {
+    uint64_t mask = (UINT64_C(1)<<source)-1;
+    uint64_t value = input & mask;
+    if (sign && (value & (UINT64_C(1)<<(source-1)))) value |= ~mask;
+    if (result == 16) {
+        uint64_t seed = in_place ? input : UINT64_C(0x5a6b7c8d9eaf1021);
+        value = (seed & ~UINT64_C(65535)) | (value & UINT64_C(65535));
+    } else if (result == 32) {
+        value = (uint32_t)value;
+    }
+    return value + (input != 0 ? 7 : 0);
+}
+static int check(void (*fn)(void*,void*,void*,void*), unsigned source, unsigned result, bool sign, bool in_place) {
+    const uint64_t inputs[] = {0, 1, 127, 128, 65535, UINT64_C(1)<<31, UINT64_C(1)<<63, UINT64_MAX};
+    for (unsigned iteration = 0; iteration < 16; iteration++) {
+        for (unsigned index = 0; index < sizeof(inputs)/sizeof(inputs[0]); index++) {
+            uint64_t x[] = {inputs[index], UINT64_C(0x1122334455667788)};
+            uint64_t y[] = {UINT64_C(0x8877665544332211), 23}, length = 2;
+            unsigned char output[10];
+            memset(output, 0xa5, sizeof(output));
+            fn(x, y, output+1, &length);
+            uint64_t got;
+            memcpy(&got, output+1, sizeof(got));
+            if (got != reference(inputs[index], source, result, sign, in_place) ||
+                output[0] != 0xa5 || output[9] != 0xa5 || length != 2 ||
+                x[0] != inputs[index] || x[1] != UINT64_C(0x1122334455667788) ||
+                y[0] != UINT64_C(0x8877665544332211) || y[1] != 23) return 1;
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "    return 0;\n}\n"
+}
+
+func TestX86ExtensionInitializedCallerNumericalFamily(t *testing.T) {
+	var runner []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+		t.Log("actual Darwin/amd64 Go and LLVM executions use Rosetta; not native AMD64 evidence")
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("requires the independently required Linux/amd64 execution counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	declaration, source := x86ExtensionNumericalSource()
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	x86ExtensionActualGoNumerical(t, declaration, source, runner)
+	pkg := x86CallerRuntimePackage(t, declaration, source)
+	file := pkg.SourceSelection.Assembly["value_amd64.s"]
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "extension-text", triple, ir, x86ExtensionCOracle(), runner)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "extension-module", triple, module.String(), x86ExtensionCOracle(), runner)
+	ctx = llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "extension-go-module", triple, translation.Module.String(), x86ExtensionCOracle(), runner)
+}
diff --git a/amd64_movbe_forms.go b/amd64_movbe_forms.go
new file mode 100644
index 000000000..27d8b82d7
--- /dev/null
+++ b/amd64_movbe_forms.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86MOVBEWidths = map[Op]int{
+	"MOVBEW": 16, "MOVBEWW": 16,
+	"MOVBEL": 32, "MOVBELL": 32,
+	"MOVBEQ": 64, "MOVBEQQ": 64,
+}
+
+type x86MOVBEForm struct {
+	bits                int
+	source, destination Operand
+	store               bool
+}
+
+func x86MOVBEProperties(op Op, ins Instr, arch string) (x86MOVBEForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86MOVBEWidths[Op(name)]
+	form := x86MOVBEForm{bits: bits}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86MOVBEForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go ymovbe grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || arch == "386" && bits == 64 || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	form.source, form.destination = ins.Args[0], ins.Args[1]
+	register, memory := form.destination, form.source
+	if form.source.Kind == OpReg {
+		form.store, register, memory = true, form.source, form.destination
+	}
+	if register.Kind != OpReg || !isX86YrlRegisterForArch(register.Reg, arch) ||
+		!x86ScalarCompareMemoryValid(memory, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86TypedMOVBEByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86MOVBEProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: width, read: true},
+		{index: 1, operand: form.destination, width: width, write: true},
+	}}, true, nil
+}
+
+func x86RawMOVBESource(ins Instr, arch string) bool {
+	_, known, err := x86MOVBEProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86LoweredMOVBEResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86MOVBEProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawMOVBESource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	width := int64(form.bits / 8)
+	if form.store && x86OrdinaryNativeMemoryOperand(form.destination, arch) {
+		return x86ResultIncomingPointerAddressIdentity(form.destination, state, arch) &&
+			x86ResultRead(form.source, width, state, owned, arch), true
+	}
+	if !form.store && x86OrdinaryNativeMemoryOperand(form.source, arch) {
+		if !x86ResultReadWithNativeContinuation(local, form.source, width, state, owned, arch, true) {
+			return false, true
+		}
+		return x86ResultStore(form.destination, width, state, owned, resultOffset, arch), true
+	}
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false // Logical storage remains in the ordinary strict transfer.
+	}
+	return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+}
diff --git a/amd64_move_half_complete_test.go b/amd64_move_half_complete_test.go
new file mode 100644
index 000000000..d562ca827
--- /dev/null
+++ b/amd64_move_half_complete_test.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveHalfCompleteInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, base, destination := 8, "MOVQ", "X30", "X31"
+			if target.arch == "386" {
+				word, move, base, destination = 4, "MOVL", "X6", "X7"
+			}
+			var source, declarations strings.Builder
+			for _, row := range x86MoveHalfOracle {
+				load, store, merge, output := "MOVUPS", "MOVUPS", "X6", "X7"
+				if target.arch == "amd64" {
+					merge, output = "X14", "X15"
+				}
+				args := "(DX)," + output
+				if row.vector {
+					load, store, merge, output = "VMOVUPS", "VMOVUPS", base, destination
+					args = "(DX)," + merge + "," + output
+				}
+				name := "Native" + row.op
+				fmt.Fprintf(&declarations, "func %s(out *[32]byte,base *[16]byte,half *uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),AX\n%s base+%d(FP),CX\n%s half+%d(FP),DX\n"+
+					"%s (CX),%s\n%s %s,%s\nSTC\n%s %s\n%s %s,(AX)\n%s %s,16(AX)\nSETCS 24(AX)\nRET\n",
+					name, 3*word, move, move, word, move, 2*word, load, merge, load, merge, output,
+					row.op, args, store, output, row.op, output)
+				name = "Logical" + row.op
+				args = "value+0(FP),X2"
+				if row.vector {
+					args = "value+0(FP),X1,X2"
+				}
+				fmt.Fprintf(&declarations, "func %s(value,old uint64) uint64\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ old+8(FP),X1\nMOVUPS X1,X2\n%s %s\n%s X2,ret0+16(FP)\nRET\n",
+					name, row.op, args, row.op)
+			}
+			if len(strings.Split(strings.TrimSpace(declarations.String()), "\n")) != 16 {
+				t.Fatal("bounded sixteen-function complete half-move directory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized native/logical half-move program rejected", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(body, "load volatile i64, ptr") != 8 || strings.Count(body, "store volatile i64 ") != 8 {
+							t.Fatal("half-move native accesses lost their exact eight-byte tuple")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, body, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86MoveHalfNativeContinuationNeverCreatesMemoryFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86MoveHalfOracle {
+			for _, store := range []bool{false, true} {
+				t.Run(fmt.Sprint(arch, "/", row.op, "/store=", store), func(t *testing.T) {
+					args := "(AX),X2"
+					if row.vector {
+						args = "(AX),X1,X2"
+					}
+					if store {
+						args = "X1,(AX)"
+					}
+					ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.pointerGP[0], state.xmm[1], state.xmm[2] = true, 0xffff, 0xffff
+					before := state.clone()
+					if accepted, known := x86ResultMoveHalfStep(ins, &state, nil, 0, arch, false); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("declaration-only observer acquired a native access")
+					}
+					if accepted, known := x86ResultMoveHalfStep(ins, &state, nil, 0, arch, true); !known || !accepted {
+						t.Fatal("paired exact-width native access could not continue")
+					}
+					if !store {
+						before.xmm[2], before.vectorUpper[2] = state.xmm[2], state.vectorUpper[2]
+					}
+					if !reflect.DeepEqual(state, before) {
+						t.Fatal("native half-move created storage, pointer, mask or flag knowledge")
+					}
+					for _, mutation := range []string{"pointer", "encoded", "raw", "segment", "address", "raw-return"} {
+						changed, input := ins, before.clone()
+						switch mutation {
+						case "pointer":
+							input.pointerGP[0] = false
+						case "encoded":
+							changed.x86Encoded = true
+						case "raw":
+							changed.x86SourceRaw = new(x86SourceRawInstruction)
+						case "segment":
+							changed.x86SegmentPrefix = 0x64
+						case "address":
+							changed.x86AddressBits = 32
+						case "raw-return":
+							changed.x86RawNearReturn = new(x86RawNearReturnForm)
+						}
+						original := input.clone()
+						if accepted, _ := x86ResultMoveHalfStep(changed, &input, nil, 0, arch, true); accepted || !reflect.DeepEqual(input, original) {
+							t.Fatal("native continuation borrowed a changed source or missing input", mutation)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MoveHalfLegacyPDRegisterHasNoNumericalPermission(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required for independent encoding observation")
+	}
+	// Intel SDM Vol.2B MOVLPD/MOVHPD and Intel XED xed-isa.txt both
+	// require a memory ModRM (MOD!=3). Go's broad yxmov is not an ISA proof.
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"MOVLPD", "MOVHPD"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+op+" X1,X2\nRET\n")
+				opcode := byte(0x12)
+				if op == "MOVHPD" {
+					opcode = 0x16
+				}
+				if !reflect.DeepEqual(code, []byte{0x66, 0x0f, opcode, 0xd1, 0xc3}) {
+					t.Fatal("actual Go's undocumented PD register bytes changed", code)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+sse2")
+				command.Stdin = strings.NewReader(fmt.Sprintf("0x66 0x0f 0x%02x 0xd1\n", opcode))
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				alias := "movhlps"
+				if op == "MOVHPD" {
+					alias = "movlhps"
+				}
+				if err != nil || ctx.Err() != nil || !strings.Contains(string(output), alias) || strings.Contains(string(output), "warning:") {
+					t.Fatal("LLVM22's actual ignored-66 PS-alias observation changed", err, string(output))
+				}
+				t.Logf("actual Go bytes=%x; LLVM22 decoder=%s; an ignored-prefix decoder observation is not documented PD register semantics or a #UD proof", code, strings.TrimSpace(string(output)))
+				ins := x86ScalarLaneInstruction(t, op+" X1,X2")
+				state := x86ResultState{}
+				state.xmm[1], state.xmm[2] = 0xffff, 0xffff
+				before := state.clone()
+				if accepted, known := x86ResultMoveHalfStep(ins, &state, nil, 0, arch, true); !known || accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("undocumented 66-prefixed register bytes acquired assumed PS numerical semantics")
+				}
+				context := newX86Ctx(new(strings.Builder), Func{}, FuncSig{}, nil, nil, arch, triple, false)
+				if known, _, err := context.lowerMOVHalf(ins.Op, ins); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("public lowering promised undocumented PD register semantics", known, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86MoveHalfExactRawSourceKeepsAllInputsAndIdentity(t *testing.T) {
+	for _, row := range x86MoveHalfOracle[4:] {
+		for _, store := range []bool{false, true} {
+			t.Run(fmt.Sprint(row.op, "/store=", store), func(t *testing.T) {
+				operation := row.op + " (DX),X1,X2"
+				if store {
+					operation = row.op + " X1,(DX)"
+				}
+				code := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+operation+"\nRET\n")
+				var source strings.Builder
+				source.WriteString("TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ base+8(FP),CX\nMOVQ half+16(FP),DX\nMOVUPS (CX),X1\n")
+				for _, value := range code[:len(code)-1] {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+				}
+				output := "X2"
+				if store {
+					output = "X1"
+				}
+				fmt.Fprintf(&source, "MOVUPS %s,(AX)\nRET\n", output)
+				declaration := "func Value(out *[16]byte,base *[16]byte,half *uint64)\n"
+				goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if _, err := x86ScalarFPBitViewAPI(t, source.String(), declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+							t.Fatal("complete initialized original raw half-move rejected", err)
+						}
+						missing := strings.Replace(source.String(), "MOVQ half+16(FP),DX\n", "", 1)
+						if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw bytes supplied their own native read/write pointer", err)
+						}
+					})
+				}
+				parsed, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized, err := normalizeX86RawFile(parsed, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				var raw Instr
+				for _, ins := range normalized.Funcs[0].Instrs {
+					if ins.Op == Op(row.op) {
+						raw = ins
+					}
+				}
+				if !x86RawMoveHalfSource(raw, "amd64") {
+					t.Fatal("complete physical decoder lost its exact sealed source")
+				}
+				for _, mutation := range []string{"args", "source", "address", "segment", "native-pointer"} {
+					changed := raw
+					changed.Args = append([]Operand(nil), raw.Args...)
+					state := x86ResultState{}
+					state.pointerGP[2], state.xmm[1] = true, 0xffff
+					switch mutation {
+					case "args":
+						at := 0
+						if store {
+							at = 1
+						}
+						changed.Args[at].Mem.Off++
+					case "source":
+						changed.x86SourceRaw = nil
+						changed.x86Encoded = true // Retain physical-origin evidence, not a new named instruction.
+					case "address":
+						changed.x86AddressBits = 32
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "native-pointer":
+						state.pointerGP[2] = false
+					}
+					before := state.clone()
+					if accepted, _ := x86ResultMoveHalfStep(changed, &state, nil, 0, "amd64", true); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("raw continuation widened a changed identity or missing input", mutation)
+					}
+				}
+				// Removing every physical-origin field constructs an independent
+				// valid named instruction. Its existing inputs still remain required.
+				named := raw
+				named.x86Encoded, named.x86SourceRaw = false, nil
+				state := x86ResultState{}
+				state.pointerGP[2], state.xmm[1] = true, 0xffff
+				if accepted, known := x86ResultMoveHalfStep(named, &state, nil, 0, "amd64", true); !known || !accepted {
+					t.Fatal("physical-origin negative accidentally rejected the separate legal named effect")
+				}
+			})
+		}
+	}
+}
+
+func x86MoveHalfFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+		form, known, err := x86MoveHalfProperties(ins.Op, ins, arch)
+		if !known {
+			terminated, err := c.lowerInstr(0, 0, ins, nil, nil)
+			return true, terminated, err
+		}
+		if err != nil {
+			return true, false, err
+		}
+		if form.undocumentedPDRegister {
+			code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n")
+			var bytes []string
+			for _, value := range code[:len(code)-1] {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+			}
+			// Preserve the original undocumented opcode, not an invented PS copy.
+			// This carrier certifies object bytes only, never a public entry.
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", ".byte "+strings.Join(bytes, ","), "~{memory}")
+			return true, false, nil
+		}
+		return true, false, c.emitMoveHalf(form, ins)
+	})
+}
diff --git a/amd64_move_half_forms.go b/amd64_move_half_forms.go
new file mode 100644
index 000000000..8214dcd65
--- /dev/null
+++ b/amd64_move_half_forms.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86MoveHalfForm struct {
+	spec                           amd64MoveHalfSpec
+	source, base, destination      int
+	memory, sourceLane, outputLane int
+	store, undocumentedPDRegister  bool
+}
+
+// The complete memory and register-half families share numerical lane roles.
+// Only the memory forms have an m64 tuple. A register-only alias cannot gain
+// that operand shape, a native address, alignment, or backing.
+func x86MoveHalfProperties(op Op, ins Instr, arch string) (x86MoveHalfForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64MoveHalfSpecs[Op(name)]
+	form := x86MoveHalfForm{spec: spec, source: 0, base: -1, destination: len(ins.Args) - 1, memory: -1}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86MoveHalfForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go half-move grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	vector := func(operand Operand) bool {
+		index, valid := amd64ParseXReg(operand.Reg)
+		limit := 16
+		if spec.vector {
+			limit = 32
+		} else if arch == "386" {
+			limit = 8
+		}
+		return operand.Kind == OpReg && valid && index < limit
+	}
+	if spec.high {
+		form.outputLane = 1
+	}
+	if spec.registerOnly {
+		count := 2
+		if spec.vector {
+			count = 3
+		}
+		if len(ins.Args) != count || !vector(ins.Args[0]) || !vector(ins.Args[1]) || !vector(ins.Args[form.destination]) {
+			return fail()
+		}
+		form.base = 1
+		form.sourceLane = 1 - form.outputLane
+	} else if len(ins.Args) == 2 && vector(ins.Args[0]) && isAMD64MemoryOperand(ins.Args[1]) {
+		form.store, form.memory, form.sourceLane = true, 1, form.outputLane
+	} else if spec.vector {
+		if len(ins.Args) != 3 || !isAMD64MemoryOperand(ins.Args[0]) || !vector(ins.Args[1]) || !vector(ins.Args[2]) {
+			return fail()
+		}
+		form.base, form.memory = 1, 0
+	} else {
+		if len(ins.Args) != 2 || !vector(ins.Args[1]) {
+			return fail()
+		}
+		form.base = 1
+		if vector(ins.Args[0]) {
+			form.sourceLane = 1 - form.outputLane
+			// Intel SDM/XED require ModRM.MOD!=3 for 66 0F12/16.
+			// Go's shared yxmov encoder accepts these bytes anyway; this
+			// records the format without inventing PS-alias semantics.
+			form.undocumentedPDRegister = strings.HasSuffix(name, "PD")
+		} else if isAMD64MemoryOperand(ins.Args[0]) {
+			form.memory = 0
+		} else {
+			return fail()
+		}
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, true, err
+	}
+	if form.memory >= 0 {
+		operand := ins.Args[form.memory]
+		if !x86PackedShiftMemoryValid(operand, arch) {
+			return fail()
+		}
+		if err := x86NamedMultiplyMemoryError(operand, arch); err != nil {
+			return form, true, err
+		}
+	}
+	return form, true, nil
+}
+
+func x86TypedMoveHalfByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86MoveHalfProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	if form.spec.registerOnly {
+		effect.vector.upperWrite = x86TypedVectorUpperPreserve
+		if form.spec.vector {
+			effect.vector.upperWrite = x86TypedVectorUpperZero
+		}
+	}
+	for index, operand := range ins.Args {
+		width := int64(16)
+		if index == form.memory {
+			width = 8
+		}
+		entry := x86TypedByteOperand{
+			index: index, operand: operand, width: width,
+			read: index == form.source || index == form.base, write: index == form.destination,
+		}
+		if form.spec.registerOnly {
+			if index == form.source {
+				entry.requiredBytes = uint64(0xff) << uint(form.sourceLane*8)
+			}
+			if index == form.base {
+				entry.requiredBytes = uint64(0xff) << uint((1-form.outputLane)*8)
+			}
+		}
+		effect.operands = append(effect.operands, entry)
+	}
+	return effect, true, nil
+}
diff --git a/amd64_movemask_grammar_test.go b/amd64_movemask_grammar_test.go
new file mode 100644
index 000000000..e0fff3dbb
--- /dev/null
+++ b/amd64_movemask_grammar_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveMaskCompleteGoEncodingRows(t *testing.T) {
+	for filename, rows := range map[string][]string{
+		"asm6.go": {
+			"{APMOVMSKB, ymskb, Px, opBytes{Pe, 0xd7, 0xd7}}",
+			"{AMOVMSKPD, yxrrl, Pq, opBytes{0x50}}",
+			"{AMOVMSKPS, yxrrl, Pm, opBytes{0x50}}",
+			"var yxrrl = []ytab{ {Zm_r, 1, argList{Yxr, Yrl}}, }",
+			"var ymskb = []ytab{ {Zm_r_xm, 2, argList{Yxr, Yrl}}, {Zm_r_xm, 1, argList{Ymr, Yrl}}, }",
+		},
+		"avx_optabs.go": {
+			"var _yvmovmskpd = []ytab{ {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxr, Yrl}}, {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yyr, Yrl}}, }",
+			"{as: AVMOVMSKPD, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{ avxEscape | vex128 | vex66 | vex0F | vexW0, 0x50, avxEscape | vex256 | vex66 | vex0F | vexW0, 0x50, }}",
+			"{as: AVMOVMSKPS, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{ avxEscape | vex128 | vex0F | vexW0, 0x50, avxEscape | vex256 | vex0F | vexW0, 0x50, }}",
+			"{as: AVPMOVMSKB, ytab: _yvmovmskpd, prefix: Pavx, op: opBytes{ avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD7, avxEscape | vex256 | vex66 | vex0F | vexW0, 0xD7, }}",
+		},
+	} {
+		contents, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86", filename))
+		if err != nil {
+			t.Fatal(err)
+		}
+		text := strings.Join(strings.Fields(string(contents)), " ")
+		for _, row := range rows {
+			if !strings.Contains(text, row) {
+				t.Fatalf("complete original Go encoding row changed in %s: %s", filename, row)
+			}
+		}
+	}
+	if len(amd64MoveMaskSpecs) != 6 {
+		t.Fatal("incomplete six-name move-mask family")
+	}
+}
+
+func TestX86MoveMaskIntrinsicFeatureIsInstructionLocal(t *testing.T) {
+	for _, line := range []string{"PMOVMSKB X0,AX", "VPMOVMSKB X0,AX", "VPMOVMSKB Y0,AX"} {
+		file, err := Parse(ArchAMD64, "TEXT original(SB),4,$0-0\n"+line+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "386", Func{Instrs: []Instr{instruction}})
+		if features != "+sse2" {
+			t.Fatalf("isolated %s cannot borrow a sibling's SSE2 feature: %q", line, features)
+		}
+	}
+}
+
+func TestX86MoveMaskSharedGrammarMatchesActualGo(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operation := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+			for _, source := range []string{"X0", "X7", "X8", "X15", "X16", "Y0", "Y15", "Y16", "Z0", "M0", "M7", "AX", "(AX)", "$1"} {
+				for _, destination := range []string{"AX", "R8", "AL", "X1"} {
+					line := operation + " " + source + "," + destination
+					assembly := "TEXT original(SB),4,$0-0\n" + line + "\nRET\n"
+					vex := strings.HasPrefix(operation, "V")
+					validSource := source == "X0" || source == "X7" ||
+						(source == "X8" || source == "X15") && (arch == "amd64" || vex) ||
+						vex && (source == "Y0" || source == "Y15") ||
+						operation == "PMOVMSKB" && (source == "M0" || source == "M7")
+					valid := validSource && (destination == "AX" || destination == "R8" && arch == "amd64")
+					goAssemblerOracleOutput(t, arch, assembly, "", valid)
+					file, err := Parse(ArchAMD64, assembly)
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, known, err := x86MoveMaskProperties(Op(operation), file.Funcs[0].Instrs[1], arch)
+					if !known || (err == nil) != valid {
+						t.Fatalf("%s %s shared grammar: known=%t err=%v", arch, line, known, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86MoveMaskResultFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		size, typ, move := 8, "uint64", "MOVQ"
+		if target.arch == "386" {
+			size, typ, move = 4, "uint32", "MOVL"
+		}
+		var source, declarations strings.Builder
+		declarations.WriteString("package masks\n")
+		for index, instruction := range x86ResultMoveMaskForms {
+			name := fmt.Sprintf("mask%d", index)
+			fmt.Fprintf(&declarations, "func %s() %s\n", name, typ)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nVZEROALL\n%s\n%s AX,ret0+0(FP)\nRET\n", name, size, instruction, move)
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "mask.ll"), filepath.Join(dir, "mask.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_movnti_forms.go b/amd64_movnti_forms.go
new file mode 100644
index 000000000..a400d1187
--- /dev/null
+++ b/amd64_movnti_forms.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's complete scalar non-temporal family shares one yrl_ml/Zr_m row.
+// Its Yml compatibility closure includes register destinations whose physical
+// ModRM form faults; those forms never consume a source value or an address.
+var x86MOVNTIWidths = map[Op]int{
+	"MOVNTIL": 32,
+	"MOVNTIQ": 64,
+}
+
+type x86MOVNTIForm struct {
+	bits                int
+	source, destination Operand
+	trap                bool
+}
+
+func x86MOVNTIProperties(op Op, ins Instr, arch string) (x86MOVNTIForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86MOVNTIWidths[Op(name)]
+	form := x86MOVNTIForm{bits: bits}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86MOVNTIForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go yrl_ml scalar non-temporal grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && bits == 64 || dotted ||
+		len(ins.Args) != 2 || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	form.source, form.destination = ins.Args[0], ins.Args[1]
+	if form.source.Kind != OpReg || !isX86YrlRegisterForArch(form.source.Reg, arch) {
+		return fail()
+	}
+	if form.destination.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.destination.Reg, arch) {
+			return fail()
+		}
+		form.trap = true
+		return form, true, nil
+	}
+	if !isAMD64MemoryOperand(form.destination) {
+		return fail()
+	}
+	memory := form.destination
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, memory, arch); segment {
+		if err != nil {
+			return form, true, err
+		}
+		memory, form.destination = projected, projected
+	}
+	if memory.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(memory.Mem, arch); err != nil {
+			return form, true, err
+		}
+		if memory.Mem.OffRaw != "" || memory.Mem.IndexExt != "" {
+			return fail()
+		}
+		if arch == "386" && strings.HasSuffix(memory.Mem.Sym, "(SB)") {
+			memory.Mem.Base = "" // Go discards this named annotation, not Index.
+		}
+	}
+	if !x86ScalarCompareMemoryValid(memory, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
diff --git a/amd64_movnti_grammar_test.go b/amd64_movnti_grammar_test.go
new file mode 100644
index 000000000..f75c46950
--- /dev/null
+++ b/amd64_movnti_grammar_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVNTICompleteIndependentGoEncoderRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	table := regexp.MustCompile(`(?s)var yrl_ml = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+	if len(table) != 2 || strings.Join(strings.Fields(table[1]), "") !=
+		"{Zr_m,1,argList{Yrl,Yml}}," {
+		t.Fatal("complete Go MOVNTI grammar, zcase or encoding offset changed")
+	}
+	rows := regexp.MustCompile(`\{A(MOVNTI[\w]*), yrl_ml, (P\w+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(text, -1)
+	if len(rows) != 2 {
+		t.Fatal("complete Go scalar non-temporal family changed", rows)
+	}
+	if len(x86MOVNTIWidths) != len(rows) {
+		t.Fatal("typed scalar non-temporal directory is not the complete independent Go family")
+	}
+	for _, row := range rows {
+		prefix, encoding, bits := "Pm", "0xc3", 32
+		if row[1] == "MOVNTIQ" {
+			prefix, encoding, bits = "Pw", "0x0f,0xc3", 64
+		} else if row[1] != "MOVNTIL" {
+			t.Fatal("unmodeled Go scalar non-temporal member", row[1])
+		}
+		if row[2] != prefix || strings.Join(strings.Fields(row[3]), "") != encoding || x86MOVNTIWidths[Op(row[1])] != bits {
+			t.Fatal("complete Go MOVNTI physical encoding changed", row)
+		}
+	}
+}
+
+func TestX86MOVNTICompleteGoRegisterAndAddressClasses(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+			if arch == "amd64" {
+				registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+			}
+			destinations := append([]string(nil), registers...)
+			destinations = append(destinations,
+				"(AX)", "-1(AX)(CX*2)", "128(BX)(SI*8)", "tmp-4(SP)",
+				"ret+0(FP)", "·cell(SB)", "17", "8(AX)(GS)", "8(AX)(FS)")
+			var source strings.Builder
+			source.WriteString("DATA ·cell+0(SB)/8,$0\nGLOBL ·cell(SB),$8\n")
+			count := 0
+			for _, name := range []string{"MOVNTIL", "MOVNTIQ"} {
+				if arch == "386" && name == "MOVNTIQ" {
+					continue
+				}
+				for _, register := range registers {
+					for _, destination := range destinations {
+						text := name + " " + register + "," + destination
+						ins := x86YMMReadSource(t, text)
+						form, known, err := x86MOVNTIProperties(ins.Op, ins, arch)
+						if !known || err != nil || form.trap != (ins.Args[1].Kind == OpReg) || !reflect.DeepEqual(form.source, ins.Args[0]) {
+							t.Fatal("complete Go Yrl/Yml row lost source shape or trap priority", text, err)
+						}
+						fmt.Fprintf(&source, "TEXT ·Format%d(SB),4,$0-8\n%s\nRET\n", count, text)
+						count++
+					}
+				}
+			}
+			want := 136
+			if arch == "amd64" {
+				want = 800
+			}
+			if count != want {
+				t.Fatal("independent complete scalar non-temporal source/address inventory changed", count)
+			}
+			requireX86GoAssemblerResult(t, arch, source.String(), true)
+		})
+	}
+}
+
+func TestX86MOVNTIRejectsCompleteGrammarBeforeIR(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range []string{"MOVNTIL", "MOVNTIQ"} {
+			if arch == "386" && name == "MOVNTIQ" {
+				continue // The original Go-mode rejection matrix retains this axis.
+			}
+			original := x86YMMReadSource(t, name+" AX,(BX)")
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"dispatch", func(i *Instr) { i.Op = "MOVL" }},
+				{"suffix", func(i *Instr) { i.Op += ".Z" }},
+				{"arity", func(i *Instr) { i.Args = i.Args[:1] }},
+				{"immediate-source", func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 1} }},
+				{"vector-source", func(i *Instr) { i.Args[0] = Operand{Kind: OpReg, Reg: "X0"} }},
+				{"vector-destination", func(i *Instr) { i.Args[1] = Operand{Kind: OpReg, Reg: "X0"} }},
+				{"address-immediate", func(i *Instr) { i.Args[1] = Operand{Kind: OpSym, Sym: "$16(BX)"} }},
+			} {
+				t.Run(arch+"/"+name+"/"+control.name, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					control.change(&ins)
+					var ir strings.Builder
+					ctx := &amd64Ctx{b: &ir, goarch: arch}
+					known, terminated, err := ctx.lowerMOVNTI(Op(name), ins)
+					if !known || terminated || err == nil || ir.Len() != 0 || ctx.tmp != 0 {
+						t.Fatal("incomplete MOVNTI grammar emitted before rejection", known, terminated, err, ir.String())
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVNTIRegisterDestinationFaultsBeforeInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range []string{"MOVNTIL", "MOVNTIQ"} {
+			if arch == "386" && name == "MOVNTIQ" {
+				continue
+			}
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				// Go's Yml compatibility closure admits mod=3, but MOVNTI has
+				// no ISA register destination. No source byte or memory input
+				// may be read before this unconditional architectural #UD.
+				ins := x86YMMReadSource(t, name+" AX,BX")
+				var ir strings.Builder
+				ctx := &amd64Ctx{b: &ir, goarch: arch}
+				known, terminated, err := ctx.lowerMOVNTI(ins.Op, ins)
+				if !known || !terminated || err != nil || ctx.tmp != 0 ||
+					ir.String() != "  call void asm sideeffect \"ud2\", \"~{memory}\"()\n  unreachable\n" {
+					t.Fatal("register MOVNTI did not fault before inputs", known, terminated, err, ir.String())
+				}
+			})
+		}
+	}
+}
+
+func TestX86MOVNTILogicalStorageDoesNotSupplyNativeBacking(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, source := range []string{
+			"TEXT ·Value(SB),4,$0-4\nMOVL $1,AX\nMOVNTIL AX,ret+0(FP)\nRET\n",
+			"TEXT ·Value(SB),4,$16-4\nMOVL $1,AX\nMOVNTIL AX,tmp-4(SP)\nMOVL $1,ret+0(FP)\nRET\n",
+		} {
+			t.Run(target.triple+"/"+strings.Split(source, "\n")[0], func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("logical numerical bytes impersonated MOVNTI native storage", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_movnti_native_test.go b/amd64_movnti_native_test.go
new file mode 100644
index 000000000..1842eec17
--- /dev/null
+++ b/amd64_movnti_native_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVNTIOriginalNativeStoresFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, width := range []struct {
+			suffix, typ, move string
+			bytes             int
+		}{
+			{"L", "uint32", "MOVL", 4}, {"Q", "uint64", "MOVQ", 8},
+		} {
+			if target.arch == "386" && width.bytes == 8 {
+				continue // Stock Go rejects Q in mode32; the separate rejection matrix owns it.
+			}
+			t.Run(target.triple+"/"+width.suffix, func(t *testing.T) {
+				declaration := fmt.Sprintf("func Value(out *byte,value %s)\n", width.typ)
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DX\n%s value+%d(FP),AX\nMOVL $1,CX\nMOVNTI%s AX,-1(DX)(CX*2)\nMOVNTI%s AX,-1(DX)(CX*2)\nSFENCE\nMOVB $0,-1(DX)(CX*2)\nRET\n",
+					word+width.bytes, move, width.move, word, width.suffix, width.suffix)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("initialized original MOVNTI source rejected", err)
+						}
+						for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							if strings.Count(input, `asm sideeffect "movnti`) != 2 || strings.Contains(input, "!nontemporal") {
+								t.Fatal("native cache policy/dead writes became optional metadata or disappeared")
+							}
+							compileLLVMToObject(t, llc, target.triple, "movnti-native.ll", "movnti-native.o", input)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86MOVNTIDeadStoresStillRequireValueAndAddress(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, suffix := range []string{"L", "Q"} {
+			if target.arch == "386" && suffix == "Q" {
+				continue
+			}
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool=%t", target.triple, suffix, unused), func(t *testing.T) {
+					declaration, extent := "func Value(out *byte)", word
+					if unused {
+						declaration, extent = "func Value(out *byte,unused bool)", word+1
+					}
+					for _, setup := range []string{move + " out+0(FP),DX\n", "MOVL $1,AX\n"} {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOVNTI%s AX,(DX)\nRET\n", extent, setup, suffix)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void or unused bool invented MOVNTI inputs", api, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_movnti_runtime_test.go b/amd64_movnti_runtime_test.go
new file mode 100644
index 000000000..00f868934
--- /dev/null
+++ b/amd64_movnti_runtime_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86MOVNTIOriginalFlagsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, prototypes, checks, goChecks strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, row := range []struct {
+		suffix string
+		bytes  int
+	}{{"L", 4}, {"Q", 8}} {
+		for _, offset := range []int{0, 1} {
+			name := fmt.Sprintf("Store%s%d", row.suffix, offset)
+			fmt.Fprintf(&declarations, "func %s(out *byte,value uint64)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\n"+
+				"MOVQ out+0(FP),DX\nMOVQ value+8(FP),AX\n"+
+				"MOVL $0x7fffffff,R8\nADDL $1,R8\nSTC\nMOVL $%d,CX\n"+
+				"MOVNTI%s AX,(DX)(CX*1)\nSFENCE\n"+
+				"SETCS 24(DX)\nSETOS 25(DX)\nSETEQ 26(DX)\nSETMI 27(DX)\nRET\n",
+				name, offset, row.suffix)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if (check_value(%s,%d,%d,value)) return 1; count++;\n", name, row.bytes, offset)
+			fmt.Fprintf(&goChecks, "check(t,%s,%d,%d,value); count++\n", name, row.bytes, offset)
+			count++
+		}
+		fmt.Fprintf(&declarations, "func Dead%s(out *byte)\n", row.suffix)
+		fmt.Fprintf(&assembly, "TEXT ·Dead%s(SB),4,$0-8\nMOVQ out+0(FP),DX\nMOVQ $42,AX\n"+
+			"MOVNTI%s AX,(DX)\nMOVNTI%s AX,(DX)\nSFENCE\nRET\n", row.suffix, row.suffix, row.suffix)
+	}
+	if count != 4 {
+		t.Fatal("complete scalar non-temporal value/canary directory changed", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir},
+		{"backend_O2", "-O2", ir},
+		{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			if strings.Count(pipeline.ir, `asm sideeffect "movnti`) != 8 || strings.Contains(pipeline.ir, "!nontemporal") {
+				t.Fatal("original/dead native stores became optional cache metadata")
+			}
+			output := execution.compileAndRunLLVM(t, "movnti-values-flags", pipeline.ir,
+				fmt.Sprintf(x86MOVNTIValuesC, prototypes.String(), checks.String()), pipeline.level)
+			if string(output) != "MOVNTI values/FLAGS/canary outcomes 32 failures 0\n" {
+				t.Fatal("independent exact native value/FLAGS/canary observations", string(output))
+			}
+			executable := execution.compileLLVM(t, "movnti-dead-faults", pipeline.ir, x86MOVNTIFaultsC, pipeline.level)
+			for row := 0; row < 2; row++ {
+				for probe := 0; probe < 4; probe++ {
+					want := x86ObserveMemoryFault(t, execution, executable, row, probe, 1)
+					if probe == 2 {
+						if want != "return" {
+							t.Fatal("complete accessible original native MOVNTI store faulted", row, want)
+						}
+					} else if want != "segv" && want != "bus" {
+						t.Fatal("NULL, partial-page or readonly original native store did not fault", row, probe, want)
+					}
+					if got := x86ObserveMemoryFault(t, execution, executable, row, probe, 0); got != want {
+						t.Fatal("dead MOVNTI lost exact native fault behavior", row, probe, got, want)
+					}
+				}
+			}
+			t.Log("32 value/FLAGS/full-buffer outcomes; both widths retain dead NULL, partial-page, complete-page and readonly native writes")
+		})
+	}
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(),
+		fmt.Sprintf(x86MOVNTIOriginalGo, goChecks.String()))
+}
+
+const x86MOVNTIValuesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+%s
+static int check_value(void (*run)(uint8_t *,uint64_t),unsigned bytes,unsigned offset,uint64_t value) {
+    uint8_t actual[48], expected[48];
+    memset(actual,0xc3,sizeof(actual));
+    memset(expected,0xc3,sizeof(expected));
+    for (unsigned i=0;i<bytes;i++) expected[1+offset+i]=(uint8_t)(value>>(i*8));
+    expected[25]=1;
+    expected[26]=1;
+    expected[27]=0;
+    expected[28]=1;
+    run(actual+1,value);
+    if (memcmp(actual,expected,sizeof(actual))) {
+        fprintf(stderr,"MOVNTI value/FLAGS/canary mismatch bytes=%%u offset=%%u value=%%llx\n",bytes,offset,(unsigned long long)value);
+        return 1;
+    }
+    return 0;
+}
+int main(void) {
+    const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0x1122334455667788),UINT64_C(0x8877665544332211),
+        UINT64_C(0xaaaaaaaa55555555),UINT64_C(0x00000000ffffffff)};
+    unsigned count=0;
+    for (unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint64_t value=values[i];
+        %s
+    }
+    if (count!=32) return 1;
+    printf("MOVNTI values/FLAGS/canary outcomes %%u failures 0\n",count);
+    return 0;
+}
+`
+
+const x86MOVNTIOriginalGo = `package oracle
+import "testing"
+func check(t *testing.T,run func(*byte,uint64),bytes,offset int,value uint64) {
+    t.Helper()
+    var actual,expected [48]byte
+    for i:=range actual {actual[i]=0xc3; expected[i]=0xc3}
+    for i:=0;i<bytes;i++ {expected[1+offset+i]=byte(value>>uint(i*8))}
+    expected[25],expected[26],expected[27],expected[28]=1,1,0,1
+    run(&actual[1],value)
+    if actual!=expected {t.Fatalf("original MOVNTI bytes=%%d offset=%%d value=%%x got=%%x want=%%x",bytes,offset,value,actual,expected)}
+}
+func TestOriginal(t *testing.T) {
+    values:=[]uint64{0,1,^uint64(0),0x8000000000000000,0x1122334455667788,
+        0x8877665544332211,0xaaaaaaaa55555555,0x00000000ffffffff}
+    count:=0
+    for _,value:=range values {
+        %s
+    }
+    if count!=32 {t.Fatal(count)}
+    t.Log("original Go MOVNTI values/FLAGS/canary outcomes 32 failures 0")
+}
+`
+
+const x86MOVNTIFaultsC = x86MemoryFaultSupportC + `
+extern void DeadL(uint8_t *);
+extern void DeadQ(uint8_t *);
+int main(int argc,char **argv) {
+    if (argc!=4) return 80;
+    unsigned row,probe,original;
+    char tail;
+    if (sscanf(argv[1],"%u%c",&row,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 ||
+            sscanf(argv[3],"%u%c",&original,&tail)!=1 || row>1 || probe>3 || original>1) return 80;
+    if (memory_fault_setup(0)) return 81;
+    unsigned bytes=row?8:4;
+    uint8_t *input=probe==0?NULL:guard+page-bytes+(probe==1?1:0);
+    if (probe==3) {
+#ifdef _WIN32
+        DWORD old;
+        if (!VirtualProtect(guard,page,PAGE_READONLY,&old)) return 82;
+#else
+        if (mprotect(guard,page,PROT_READ)) return 82;
+#endif
+    }
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        if (row) __asm__ volatile("movnti %1,(%0); movnti %1,(%0); sfence"::"r"(input),"r"((uint64_t)42):"memory");
+        else __asm__ volatile("movnti %1,(%0); movnti %1,(%0); sfence"::"r"(input),"r"((uint32_t)42):"memory");
+    } else if (row) DeadQ(input);
+    else DeadL(input);
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout)?85:0;
+}
+`
diff --git a/amd64_movq_address_alias_test.go b/amd64_movq_address_alias_test.go
new file mode 100644
index 000000000..cd3187d25
--- /dev/null
+++ b/amd64_movq_address_alias_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestX86MOVQAliasesRetainCompleteGoAddressRewrite(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, operand := range []string{
+			"$·value(SB)", "$value<>+3(SB)", "$value<>-1(SB)",
+			"$slot+0(FP)", "$slot-8(SP)", "$8(BX)", "$8(BX)(CX*4)",
+		} {
+			for _, alias := range x86OriginalMOVQAliases(t) {
+				t.Run(arch+"/"+alias+"/"+operand, func(t *testing.T) {
+					source := "TEXT address(SB),4,$0-16\n" + alias + " " + operand + ",AX\nRET\n"
+					accepted := arch == "amd64"
+					goAssemblerOracleOutput(t, arch, source, "", accepted)
+					context := amd64Ctx{goarch: arch}
+					instruction := x86PureGPUnknownInstruction(t, alias+" "+operand+",AX")
+					if err := context.validateMOVDAliasForm(instruction); (err == nil) != accepted {
+						t.Fatal("source alias lost AMOVQ TYPE_ADDR progedit", err)
+					}
+					if accepted {
+						canonical := "TEXT address(SB),4,$0-16\nMOVQ " + operand + ",AX\nRET\n"
+						if !bytes.Equal(x86OrderingHintGoBytes(t, arch, source), x86OrderingHintGoBytes(t, arch, canonical)) {
+							t.Fatal("alias address bytes differ from original MOVQ")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQAliasAddressClassDoesNotGrantAnotherDestination(t *testing.T) {
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, destination := range []string{"X0", "M0", "8(BX)"} {
+			t.Run(alias+"/"+destination, func(t *testing.T) {
+				instruction := x86PureGPUnknownInstruction(t, alias+" $value<>(SB),"+destination)
+				context := amd64Ctx{goarch: "amd64"}
+				if err := context.validateMOVDAliasForm(instruction); err == nil {
+					t.Fatal("address source became a memory, MMX or X immediate")
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_movq_source_alias.go b/amd64_movq_source_alias.go
new file mode 100644
index 000000000..10a91b813
--- /dev/null
+++ b/amd64_movq_source_alias.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These are the complete archX86 frontend registrations for AMOVQ. They are
+// source spellings, not physical Intel opcode identities or MMX permissions.
+var x86GoMOVQSourceAliases = map[Op]Op{
+	"MOVD":    "MOVQ",
+	"MOVDQ2Q": "MOVQ",
+}
+
+func x86GoMOVQSourceInstruction(ins Instr) Instr {
+	if !ins.x86Encoded && ins.x86SourceRaw == nil {
+		if canonical, present := x86GoMOVQSourceAliases[ins.Op]; present {
+			ins.Op = canonical
+		}
+	}
+	return ins
+}
+
+// Go progedit rewrites AMOVQ TYPE_ADDR to ALEAQ before matching ymovq.
+// Source aliases must retain that complete source class, not mistake it for
+// a memory read or a SIMD immediate. This validates syntax only; actual FP,
+// AUTO, symbol and numerical address roles remain separate consumers.
+func x86GoMOVQAddressSource(operand Operand, arch string) bool {
+	if arch != "386" && operand.Kind == OpFPAddr {
+		address := Operand{Kind: OpFP, FPOffset: operand.FPOffset}
+		_, err := x86LEAOperandWidth(Instr{Op: "LEAQ", Args: []Operand{address, {Kind: OpReg, Reg: AX}}}, arch)
+		return err == nil
+	}
+	if arch == "386" || operand.Kind != OpSym {
+		return false
+	}
+	source := strings.TrimSpace(operand.Sym)
+	if !strings.HasPrefix(source, "$") {
+		return false
+	}
+	source = strings.TrimSpace(strings.TrimPrefix(source, "$"))
+	address := Operand{Kind: OpSym, Sym: source}
+	if memory, matched, err := x86UnnamedSourceAddressInMode(operand, arch); matched || err != nil {
+		if err != nil {
+			return false
+		}
+		address = Operand{Kind: OpMem, Mem: memory}
+	} else if memory, matched, err := parseX86SymbolIndexedMemory(source); matched {
+		if err != nil {
+			return false
+		}
+		address = Operand{Kind: OpMem, Mem: memory}
+	} else if _, offset, valid := parseFP(source); valid {
+		address = Operand{Kind: OpFP, FPOffset: offset}
+	} else if memory, valid := parseMem(source); valid {
+		address = Operand{Kind: OpMem, Mem: memory}
+	}
+	_, err := x86LEAOperandWidth(Instr{Op: "LEAQ", Args: []Operand{address, {Kind: OpReg, Reg: AX}}}, arch)
+	return err == nil
+}
+
+// Do not normalize the actual source: caller/raw/frame certificates bind its
+// entire original Op and Raw. Consumers canonicalize only local dispatch copies.
+func validateX86MoveSourceAliases(file *File, arch string) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			if _, _, err := x86ScalarMoveAliasProperties(ins.Op, ins, arch); err != nil {
+				return err
+			}
+			if ins.x86Encoded || ins.x86SourceRaw != nil {
+				continue
+			}
+			base, _, dotted := strings.Cut(string(ins.Op), ".")
+			if _, alias := x86GoMOVQSourceAliases[Op(base)]; !alias && base != "MOVQ" {
+				continue
+			}
+			if dotted || len(ins.Args) != 2 || arch != "amd64" && arch != "386" {
+				return fmt.Errorf("%s %s has an invalid source mode, suffix or operand count: %q", arch, ins.Op, ins.Raw)
+			}
+			for _, operand := range ins.Args {
+				if operand.Kind == OpImm && operand.ImmIsFloat {
+					return fmt.Errorf("%s %s has no original Go FLOAT-immediate row: %q", arch, ins.Op, ins.Raw)
+				}
+			}
+			if arch == "386" {
+				// These aliases retain MOVQ's five pre-Pw8 memory/MMX/X rows,
+				// never its mode64-only GP, immediate or MMX-register copies.
+				_, _, sourceMachine := x86MachineRegisterOperand(ins.Args[0])
+				_, _, destinationMachine := x86MachineRegisterOperand(ins.Args[1])
+				if !sourceMachine && !destinationMachine {
+					context := amd64Ctx{goarch: arch}
+					if err := context.validateMOVDAliasForm(ins); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
diff --git a/amd64_movq_source_alias_provenance_test.go b/amd64_movq_source_alias_provenance_test.go
new file mode 100644
index 000000000..e72bca393
--- /dev/null
+++ b/amd64_movq_source_alias_provenance_test.go
@@ -0,0 +1,323 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVQSourceAliasesCountedNumericalOrigins(t *testing.T) {
+	before := x86SourceStackState{callers: map[Reg]x86CallerPointerValue{
+		CX: {argument: 0}, SI: {argument: 1},
+	}}
+	proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{
+		{kind: x86CallerLocalLength, width: 8}, {kind: x86CallerSliceInput, width: 4},
+	}}
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, row := range []string{"$0,AX", "$4294967296,AX", "$-1,AX", "R9,AX", "R9,R9", "R12,AX", "(CX),AX", "(SI),AX"} {
+			t.Run(alias+"/"+row, func(t *testing.T) {
+				instruction := x86PureGPUnknownInstruction(t, alias+" "+row)
+				original := instruction
+				goAssemblerOracleOutput(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction.Raw+"\nRET\n", "", true)
+				canonical := instruction
+				canonical.Op = "MOVQ"
+				want := x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{
+					"R9": {source: 7, mask: 3, value: 2, known: true, version: 4},
+				}, source: 7, sequence: 8, flags: x86CallerCountedFlags{known: true, equal: true}}
+				got := want.clone()
+				want.step(9, 2, canonical, before, proof)
+				got.step(9, 2, instruction, before, proof)
+				if !reflect.DeepEqual(got, want) || !reflect.DeepEqual(instruction, original) {
+					t.Fatalf("source alias changed complete numeric origin/value/version/flags or original identity: got=%+v want=%+v", got, want)
+				}
+				if row == "$4294967296,AX" && (!got.regs[AX].known || got.regs[AX].value != 1<<32) {
+					t.Fatal("qword alias truncated its high half")
+				}
+				if row == "R12,AX" || row == "(SI),AX" {
+					if _, present := got.regs[AX]; present {
+						t.Fatal("unknown/non-length source acquired a numerical origin")
+					}
+				}
+				for _, raw := range []string{"encoded", "source raw"} {
+					physical := instruction
+					if raw == "encoded" {
+						physical.x86Encoded = true
+					} else {
+						physical.x86SourceRaw = &x86SourceRawInstruction{op: instruction.Op, args: instruction.Args}
+					}
+					state := x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{}, source: -1}
+					state.step(9, 2, physical, before, proof)
+					if len(state.regs) != 0 || state.source != -1 {
+						t.Fatal("raw origin borrowed named source alias semantics", raw, state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86SourceAliasCountedAssembly(original, alias string) string {
+	// Exercise full-word bound copies and zero counter definitions as well as
+	// source length/pointer imports. Actual raw guard/latch instructions stay raw.
+	assembly := strings.NewReplacer("MOVL R9,AX", "MOVQ R9,AX", "MOVL R9,R13", "MOVQ R9,R13",
+		"XORL CX,CX", "MOVQ $0,CX", "XORL R12,R12", "MOVQ $0,R12").Replace(original)
+	return x86SourceMOVQSpelling(assembly, alias)
+}
+
+func x86SourceMOVQSpelling(assembly, alias string) string {
+	lines := strings.Split(assembly, "\n")
+	for index, line := range lines {
+		fields := strings.Fields(line)
+		if len(fields) != 0 && fields[0] == "MOVQ" {
+			start := strings.Index(line, "MOVQ")
+			lines[index] = line[:start] + alias + line[start+len("MOVQ"):]
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+func TestX86MOVQSourceAliasesCountedCompletePartitionsAndObjects(t *testing.T) {
+	for _, alias := range append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...) {
+		for _, raw := range []bool{false, true} {
+			for _, shape := range []string{"single", "separate exit", "serial", "serial diamond"} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", alias, raw, shape), func(t *testing.T) {
+					original := x86CallerCountedLoopScalarAssembly(raw)
+					iterations := [4]int{0, 1, 2, 3}
+					if shape == "separate exit" {
+						original = x86CallerCountedLoopSeparateExitAssembly(raw)
+					} else if strings.HasPrefix(shape, "serial") {
+						original = x86CallerCountedSCCAssembly(raw, shape == "serial diamond")
+						iterations = [4]int{0, 2, 4, 6}
+						if shape == "serial diamond" {
+							iterations = [4]int{0, 3, 6, 9} // Both feasible diamond paths replay the second SCC.
+						}
+					}
+					assembly := x86SourceAliasCountedAssembly(original, alias)
+					canonical := x86SourceAliasCountedAssembly(original, "MOVQ")
+					if !bytes.Equal(x86OrderingHintGoBytes(t, "amd64", assembly), x86OrderingHintGoBytes(t, "amd64", canonical)) {
+						t.Fatal("actual original Go source aliases differ from complete MOVQ body bytes")
+					}
+					pkg, file := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+					resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+					fingerprint, err := x86CallerSourceFingerprint(file.Funcs[0])
+					if err != nil {
+						t.Fatal(err)
+					}
+					normalized, err := normalizeX86RawFile(file, "amd64", options)
+					if err != nil || normalized.Funcs[0].x86SourceStack == nil {
+						t.Fatalf("complete alias counted provenance missing: %v", err)
+					}
+					proof := normalized.Funcs[0].x86SourceStack
+					if proof.countedIterations != iterations || proof.caller.source != fingerprint {
+						t.Fatal("complete partition inventory or original source identity changed", proof.countedIterations)
+					}
+					if actual, err := x86CallerSourceFingerprint(normalized.Funcs[0]); err != nil || actual != proof.normalized {
+						t.Fatal("normalized source identity was not sealed")
+					}
+					for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+						x86CallerCountedSCCObjects(t, x86CallerCountedLoopScalarSource(), assembly, triple)
+					}
+					if after, err := x86CallerSourceFingerprint(file.Funcs[0]); err != nil || after != fingerprint {
+						t.Fatal("alias replay rewrote original Instr.Op/Raw")
+					}
+					for _, change := range []string{"original", "normalized", "missing caller", "access width"} {
+						t.Run(change, func(t *testing.T) {
+							_, fresh := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+							copy, err := normalizeX86RawFile(fresh, "amd64", options)
+							if err != nil || copy.Funcs[0].x86SourceStack == nil {
+								t.Fatal("fresh proof missing", err)
+							}
+							if change == "original" {
+								fresh.Funcs[0].Instrs[1].Raw += " "
+								decoded, err := decodeX86RawDirectives(fresh.Funcs[0], "amd64")
+								if err != nil {
+									t.Fatal(err)
+								}
+								failed := normalizeX86RawReturnSourceStack(decoded, options, true, fresh.Funcs[0])
+								if failed.x86SourceStack != nil {
+									t.Fatal("changed original Raw borrowed its alias proof")
+								}
+								return
+							}
+							if change == "missing caller" {
+								options.Sigs = map[string]FuncSig{}
+								for name, sig := range sigs {
+									sig.x86CallerRegions = nil
+									options.Sigs[name] = sig
+								}
+								defer func() { options.Sigs = sigs }()
+							} else {
+								instruction := &copy.Funcs[0].Instrs[1]
+								if change == "normalized" {
+									instruction.Raw += " "
+									if x86RawReturnMemoryBound(copy.Funcs[0], copy, options, true) {
+										t.Fatal("changed normalized alias Raw retained its bound")
+									}
+								} else {
+									access := instruction.x86CallerMemory[0]
+									access.width++
+									instruction.x86CallerMemory[0] = access
+									if x86CallerMemoryCertified(*instruction, 0) || x86RawReturnMemoryBound(copy.Funcs[0], copy, options, true) {
+										t.Fatal("changed alias access width retained authority")
+									}
+									return
+								}
+							}
+							if _, err := Translate(copy, options); !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("changed sealed alias/caller source translated", change, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesCountedAllExistingRejectedPaths(t *testing.T) {
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, serial := range []bool{false, true} {
+			original, changes := x86CallerCountedLoopScalarAssembly(false), x86CallerCountedLoopRejectedChanges()
+			if serial {
+				original, changes = x86CallerCountedSCCAssembly(false, true), x86CallerCountedSCCRejectedChanges()
+			}
+			for name, change := range changes {
+				t.Run(fmt.Sprintf("%s/serial=%t/%s", alias, serial, name), func(t *testing.T) {
+					assembly := strings.Replace(original, change[0], change[1], 1)
+					if assembly == original {
+						t.Fatal("negative did not mutate the original complete source")
+					}
+					assembly = x86SourceMOVQSpelling(assembly, alias)
+					goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+					pkg, _ := x86CallerCoreFixture(t, x86CallerCountedLoopScalarSource(), assembly)
+					if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("alias broadened a rejected loop/partition/mutation", err)
+					}
+					if serial {
+						x86CallerCountedSCCRejectThreeAPIs(t, assembly)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesOtherScalarKnowledgeConsumers(t *testing.T) {
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, row := range []string{"$0,AX", "$4294967296,AX", "AX,BX", "AX,AX", "R12,AX"} {
+			t.Run(alias+"/"+row, func(t *testing.T) {
+				instruction := x86PureGPUnknownInstruction(t, alias+" "+row)
+				original, canonical := instruction, instruction
+				canonical.Op = "MOVQ"
+				state := x86FixedLocalState{pointers: map[Reg]int64{}, opaque: map[Reg]x86FixedLocalOrigins{},
+					booleans: map[Reg]uint8{AX: 0xaa}, constants: map[Reg]int64{AX: 1<<32 + 1}, known: map[Reg]uint8{AX: 0xff}}
+				got, want := cloneFixedLocalState(state), cloneFixedLocalState(state)
+				err := fixedLocalStep(&instruction, &got, FuncSig{}, nil, 0)
+				wantErr := fixedLocalStep(&canonical, &want, FuncSig{}, nil, 0)
+				if (err == nil) != (wantErr == nil) || !reflect.DeepEqual(got, want) ||
+					fixedLocalInstructionShape(instruction) != fixedLocalInstructionShape(canonical) {
+					t.Errorf("fixed-local scalar numeric/boolean knowledge differs: %v / %v", err, wantErr)
+				}
+				carry := x86LockCarryState{carry: true}
+				carry.gp[0] = 0xff
+				context := amd64Ctx{goarch: "amd64"}
+				if got, want := context.lockCarryTransfer(instruction, carry.clone()), context.lockCarryTransfer(canonical, carry.clone()); !reflect.DeepEqual(got, want) {
+					t.Errorf("carry initialization differs: %+v / %+v", got, want)
+				}
+				if !reflect.DeepEqual(instruction, original) {
+					t.Fatal("scalar observer changed source identity")
+				}
+			})
+		}
+		for _, row := range []string{"(AX),BX", "BX,(AX)"} {
+			ins := x86PureGPUnknownInstruction(t, alias+" "+row)
+			canonical := ins
+			canonical.Op = "MOVQ"
+			for index := 0; index < 2; index++ {
+				width, write, known := x86InstructionMemoryShape(ins, index, "amd64")
+				wantWidth, wantWrite, wantKnown := x86InstructionMemoryShape(canonical, index, "amd64")
+				if width != wantWidth || write != wantWrite || known != wantKnown {
+					t.Errorf("alias native memory-width observation differs: %s index%d", row, index)
+				}
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesFixedLocalActualObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	for index, alias := range append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...) {
+		fmt.Fprintf(&declarations, "func Value%d(x uint64) uint64\n", index)
+		fmt.Fprintf(&assembly, "TEXT ·Value%d(SB),4,$16-16\n%s x+0(FP),AX\n%s $4294967296,DX\n%s AX,0(SP)\n%s 0(SP),CX\n%s CX,ret+8(FP)\nRET\n",
+			index, alias, alias, alias, alias, alias)
+	}
+	for _, target := range []struct{ name, triple string }{
+		{"linux/amd64", "x86_64-unknown-linux-gnu"}, {"darwin/amd64", "x86_64-apple-darwin"},
+		{"windows/amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), target.name, target.triple)
+			observed := requireGoAMD64FrameCapture(t, pkg, request)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			fingerprints := map[string][32]byte{}
+			for _, function := range file.Funcs {
+				fingerprint, err := x86CallerSourceFingerprint(function)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fingerprints[function.Sym] = fingerprint
+			}
+			bound, err := observed.BindFixedLocal(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("source-proved fixed-local MOVQ aliases lost scalar knowledge", err)
+			}
+			normalized, err := normalizeX86RawFile(file, "amd64", bound)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, function := range normalized.Funcs {
+				reads, writes := 0, 0
+				for _, instruction := range function.Instrs {
+					for index, access := range instruction.x86FixedLocalMemory {
+						context := amd64Ctx{fixedLocal: access.owner}
+						if access.width != 8 || !context.fixedLocalMemoryCertified(instruction, index) {
+							t.Fatal("alias lost exact original eight-byte certificate", instruction.Raw)
+						}
+						if access.write {
+							writes++
+						} else {
+							reads++
+						}
+					}
+				}
+				if reads != 1 || writes != 1 {
+					t.Fatal("alias local memory inventory changed", function.Sym, reads, writes)
+				}
+			}
+			fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if err != nil || ir == "" {
+					t.Fatal("bound original source alias failed public consumer", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "source-alias-local.ll", "source-alias-local.o", ir)
+			})
+			for _, function := range file.Funcs {
+				if after, err := x86CallerSourceFingerprint(function); err != nil || after != fingerprints[function.Sym] {
+					t.Fatal("fixed-local alias consumer rewrote sealed original source")
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_movq_source_alias_runtime_linux_amd64_test.go b/amd64_movq_source_alias_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..8abe2a756
--- /dev/null
+++ b/amd64_movq_source_alias_runtime_linux_amd64_test.go
@@ -0,0 +1,114 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Native Linux AMD64 owns execution. Other hosts run the portable source,
+// original-object and LLVM-object tests; no host skip is runtime evidence.
+func TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesOriginalAndLLVM(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 native runtime tools required")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	var source, declarations, prototypes, originals, checks strings.Builder
+	count := 0
+	for _, alias := range append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...) {
+		for _, operation := range []string{"gp", "gp-x", "fp-x-clear", "native-gp", "native-x", "address"} {
+			name, original, core := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count), fmt.Sprintf("OriginalBody%d", count)
+			declaration := "func Value(x uint64) uint64"
+			body := alias + " x+0(FP),CX\n" + alias + " CX,DX\n" + alias + " DX,ret+8(FP)\nRET"
+			switch operation {
+			case "gp-x":
+				body = alias + " x+0(FP),CX\n" + alias + " CX,X0\n" + alias + " X0,DX\n" + alias + " DX,ret+8(FP)\nRET"
+			case "fp-x-clear":
+				body = alias + " x+0(FP),X0\n" + alias + " X0,X1\nPSRLO $8,X1\n" + alias + " X1,ret+8(FP)\nRET"
+			case "native-gp", "native-x":
+				declaration = "func Value(p *[8]byte) uint64"
+				register := "DX"
+				if operation == "native-x" {
+					register = "X0"
+				}
+				body = "MOVQ p+0(FP),AX\nMOVL $1,CX\n" + alias + " -1(AX)(CX*1)," + register + "\n" + alias + " " + register + ",ret+8(FP)\nRET"
+			case "address":
+				body = alias + " x+0(FP),CX\n" + alias + " $8(CX),DX\n" + alias + " DX,ret+8(FP)\nRET"
+			}
+			_, _, _, assembly := x86ResultInitializationFixture(t, "amd64", declaration, body)
+			encoded := x86OrderingHintGoBytes(t, "amd64", assembly)
+			var literal []string
+			for _, value := range encoded {
+				literal = append(literal, fmt.Sprintf("0x%02x", value))
+			}
+			// Independently transport the SysV input into real Go ABI0 cells.
+			// Execute complete bytes assembled from this exact original body.
+			shim := ".text\n.globl " + core + "\n" + core + ":\n.byte " + strings.Join(literal, ",") + "\n" +
+				".globl " + original + "\n" + original + ":\nsubq $24,%rsp\nmovq %rdi,0(%rsp)\ncallq " + core +
+				"\nmovq 8(%rsp),%rax\naddq $24,%rsp\nretq\n"
+			fmt.Fprintf(&originals, "__asm__(%q);\n", shim)
+			source.WriteString(strings.ReplaceAll(assembly, "·Value", "·"+name))
+			declarations.WriteString(strings.Replace(declaration, "Value", name, 1) + "\n")
+			argument, expected := "pattern", "pattern"
+			parameter := "uint64_t"
+			if strings.HasPrefix(operation, "native-") {
+				parameter, argument = "const uint64_t*", "&backing[1]"
+			}
+			if operation == "fp-x-clear" {
+				expected = "0"
+			} else if operation == "address" {
+				expected = "pattern+UINT64_C(8)"
+			}
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(%s);\nextern uint64_t %s(%s);\n", name, parameter, original, parameter)
+			fmt.Fprintf(&checks, "{uint64_t native=%s(%s),translated=%s(%s),expected=%s;\n"+
+				"if(native!=expected || translated!=native || backing[0]!=canary || backing[1]!=pattern || backing[2]!=canary) {\n"+
+				"fprintf(stderr,\"alias=%s op=%s sample=%%u native=%%llx LLVM=%%llx expected=%%llx\\n\",sample,"+
+				"(unsigned long long)native,(unsigned long long)translated,(unsigned long long)expected);return 1;}}\n",
+				original, argument, name, argument, expected, alias, operation)
+			count++
+		}
+	}
+	if count != 18 {
+		t.Fatal("complete original source-alias runtime inventory changed", count)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + originals.String() + prototypes.String() + `
+int main(void) {
+    const uint64_t patterns[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0xffffffff00000000),UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210)};
+    const uint64_t canary=UINT64_C(0x9876543210abcdef);
+    for(unsigned sample=0;sample<7;sample++) {
+        uint64_t pattern=patterns[sample],backing[3]={canary,pattern,canary};
+` + checks.String() + `
+    }
+    puts("126 original Go/LLVM MOVQ source-alias cases");
+    return 0;
+}
+
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			executable := execution.compileLLVM(t, "source-movq-alias-"+api, ir, driver, level)
+			output := x86FloatCompareCaptureCommand(t, exec.Command(executable))
+			if string(output) != "126 original Go/LLVM MOVQ source-alias cases\n" {
+				t.Fatalf("incomplete original/LLVM source alias runtime receipt: %s", output)
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesCountedProvenance(t *testing.T) {
+	aliases := append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...)
+	t.Run("original Go", func(t *testing.T) { runX86CallerCountedLoopOriginalValues(t, aliases) })
+	t.Run("LLVM", func(t *testing.T) { runX86CallerCountedLoopLLVMValues(t, aliases) })
+}
diff --git a/amd64_movq_source_alias_test.go b/amd64_movq_source_alias_test.go
new file mode 100644
index 000000000..7a87dded7
--- /dev/null
+++ b/amd64_movq_source_alias_test.go
@@ -0,0 +1,396 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Read the complete actual frontend registration, not an Intel mnemonic list.
+func x86OriginalMOVQAliases(t *testing.T) []string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var aliases []string
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "archX86" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			index, indexed := assignment.Lhs[0].(*ast.IndexExpr)
+			selector, selected := assignment.Rhs[0].(*ast.SelectorExpr)
+			if !indexed || !selected || selector.Sel.Name != "AMOVQ" {
+				return true
+			}
+			bank, registered := index.X.(*ast.Ident)
+			owner, original := selector.X.(*ast.Ident)
+			literal, named := index.Index.(*ast.BasicLit)
+			if !registered || bank.Name != "instructions" || !original || owner.Name != "x86" || !named || literal.Kind != token.STRING {
+				t.Fatal("unknown original MOVQ alias registration")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			aliases = append(aliases, name)
+			return true
+		})
+	}
+	if !reflect.DeepEqual(aliases, []string{"MOVD", "MOVDQ2Q"}) {
+		t.Fatalf("complete original MOVQ aliases changed: %v", aliases)
+	}
+	return aliases
+}
+
+func TestX86MOVQSourceAliasesCompleteOriginalRegistrationAndTLS(t *testing.T) {
+	if !reflect.DeepEqual(x86GoMOVQSourceAliases, map[Op]Op{"MOVD": "MOVQ", "MOVDQ2Q": "MOVQ"}) {
+		t.Fatal("source alias normalization differs from the complete original frontend")
+	}
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, operands := range []string{"TLS,AX", "TLS,R15", "8(TLS),X0", "X7,0(CX)(TLS*4)", "8(TLS),M0"} {
+				t.Run(arch+"/"+alias+"/"+operands, func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, alias+" "+operands)
+					before := ins
+					if err := x86SourceTLSMoveError(ins, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("complete actual MOVQ alias lost its source TLS boundary: %v", err)
+					}
+					if !reflect.DeepEqual(ins, before) {
+						t.Fatal("source alias validator changed original source")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesOriginalFormsAndByteParity(t *testing.T) {
+	// Every ymovq row, both overlapping register/memory axes and all immediate
+	// classes are represented. The full historical/current table is pinned by
+	// TestX86GPSIMDTransferCompleteLegacyOriginalTables independently.
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operands := range []string{
+			"8(BX),M0", "M0,8(BX)", "X0,M0", "8(BX),X0", "X0,X1", "X0,8(BX)",
+			"AX,BX", "AX,8(BX)", "8(BX),AX", "$0,AX", "$-1,AX", "$4294967296,AX", "$1,8(BX)",
+			"AX,M0", "M0,M1", "M0,AX", "AX,X0", "X0,AX", "$slot+0(FP),AX", "$slot+0(SP),AX",
+		} {
+			accepted := arch == "amd64" || operands == "8(BX),M0" || operands == "M0,8(BX)" ||
+				operands == "X0,M0" || operands == "8(BX),X0" || operands == "X0,X1" || operands == "X0,8(BX)"
+			for _, alias := range append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...) {
+				t.Run(arch+"/"+alias+"/"+operands, func(t *testing.T) {
+					source := "TEXT native(SB),4,$0-16\n" + alias + " " + operands + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", accepted)
+					if accepted {
+						canonical := strings.Replace(source, alias+" ", "MOVQ ", 1)
+						first, second := x86OrderingHintGoBytes(t, arch, source), x86OrderingHintGoBytes(t, arch, canonical)
+						if !bytes.Equal(first, second) {
+							t.Fatalf("original Go alias bytes differ from MOVQ: %x != %x", first, second)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, alias := range x86OriginalMOVQAliases(t) {
+			bodies := []string{alias + " x+0(FP),X0\n" + alias + " X0,X1\n" + alias + " X1,ret+8(FP)\nRET"}
+			if target.arch == "amd64" {
+				bodies = append(bodies,
+					alias+" x+0(FP),CX\n"+alias+" CX,DX\n"+alias+" DX,ret+8(FP)\nRET",
+					alias+" x+0(FP),CX\n"+alias+" CX,X0\n"+alias+" X0,DX\n"+alias+" DX,ret+8(FP)\nRET")
+			}
+			for _, body := range bodies {
+				t.Run(target.triple+"/"+alias+"/"+body, func(t *testing.T) {
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, "func Value(x uint64) uint64", body)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x uint64) uint64\n", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatalf("%s original alias translation: %v", api, err)
+						}
+						x86ResultInitializationObject(t, llc, target.triple, ir, api)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesMachineRegisterRows(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, alias := range x86OriginalMOVQAliases(t) {
+			t.Run(target.triple+"/"+alias, func(t *testing.T) {
+				var body strings.Builder
+				for _, machine := range []string{"CR0", "CR2", "CR3", "CR4", "DR0", "DR2", "DR3", "DR6", "DR7"} {
+					fmt.Fprintf(&body, "%s %s,AX\n%s AX,%s\n", alias, machine, alias, machine)
+				}
+				if target.arch == "amd64" {
+					fmt.Fprintf(&body, "%s CR8,AX\n%s AX,CR8\n", alias, alias)
+				}
+				for _, machine := range []string{"GDTR", "IDTR"} {
+					fmt.Fprintf(&body, "%s 0(BX),%s\n%s %s,16(BX)\n", alias, machine, alias, machine)
+				}
+				source := "TEXT machine(SB),4,$0-0\n" + body.String() + "RET\n"
+				canonical := strings.ReplaceAll(source, alias+" ", "MOVQ ")
+				if !bytes.Equal(x86OrderingHintGoBytes(t, target.arch, source), x86OrderingHintGoBytes(t, target.arch, canonical)) {
+					t.Fatal("complete machine-register alias bytes changed")
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func machine()\n", target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("source aliases lost actual Go movtab rows", api, err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "machine-"+api)
+				}
+			})
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesCompleteOriginalMovtab(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var actual, expected []string
+	for _, row := range regexp.MustCompile(`\{AMOVQ,\s*Y\w+,\s*Ynone,[^\n]+`).FindAllString(string(source), -1) {
+		actual = append(actual, strings.Join(strings.Fields(row), ""))
+	}
+	for _, bank := range []struct{ class, opcode string }{{"cr", "20"}, {"dr", "21"}} {
+		indices := []int{0, 2, 3, 4, 8}
+		if bank.class == "dr" {
+			indices = []int{0, 2, 3, 6, 7}
+		}
+		for _, direction := range []bool{false, true} {
+			for _, index := range indices {
+				from, to, zcase, opcode := fmt.Sprintf("Y%s%d", bank.class, index), "Yrl", "movRegMem2op", bank.opcode
+				if direction {
+					from, to, zcase = to, from, "movMemReg2op"
+					if bank.class == "cr" {
+						opcode = "22"
+					} else {
+						opcode = "23"
+					}
+				}
+				expected = append(expected, fmt.Sprintf("{AMOVQ,%s,Ynone,%s,%s,[4]uint8{0x0f,0x%s,%d,0}},", from, to, zcase, opcode, index))
+			}
+		}
+	}
+	for _, class := range []string{"Ygdtr", "Yidtr"} {
+		digit := 2
+		if class == "Yidtr" {
+			digit = 3
+		}
+		expected = append(expected,
+			fmt.Sprintf("{AMOVQ,Ym,Ynone,%s,movMemReg2op,[4]uint8{0x0f,0x01,%d,0}},", class, digit),
+			fmt.Sprintf("{AMOVQ,%s,Ynone,Ym,movRegMem2op,[4]uint8{0x0f,0x01,%d,0}},", class, digit-2))
+	}
+	expected = append(expected, "{AMOVQ,Ytls,Ynone,Yrl,movTLSReg,[4]uint8{0,0,0,0}},")
+	if len(expected) != 25 || !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("complete original MOVQ movtab changed: %v", actual)
+	}
+}
+
+func TestX86MOVQSourceAliasesRejectedFormsThreeAPIs(t *testing.T) {
+	for _, alias := range append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...) {
+		for _, arch := range []string{"amd64", "386"} {
+			for _, operands := range []string{"TLS,X0", "AX,TLS", "$1.5,X0", "$1.5,AX", "M0,X0", "X0,Y0", "X16,X0", "AX,X0,X1"} {
+				source := "TEXT Value(SB),4,$0-0\n" + alias + " " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				for _, api := range []string{"text", "module", "Go"} {
+					triple := "x86_64-unknown-linux-gnu"
+					if arch == "386" {
+						triple = "i386-unknown-linux-gnu"
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()\n", arch, triple, api)
+					if err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("%s invalid original alias became Context/success: %s %s: %v", api, alias, operands, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesNumericalEffectsEveryInputByte(t *testing.T) {
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, arch := range []string{"amd64", "386"} {
+			for _, operands := range []string{"AX,BX", "AX,X1", "X0,BX", "X0,X1", "X0,M1"} {
+				ins := x86PureGPUnknownInstruction(t, alias+" "+operands)
+				canonical := ins
+				canonical.Op = "MOVQ"
+				for missing := -1; missing < 16; missing++ {
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.xmm[0], state.xmm[1] = 0xff, 0xffff, 0x5151
+						if missing >= 0 {
+							state.gp[0] &^= uint8(1) << uint(missing)
+							state.xmm[0] &^= uint16(1) << uint(missing)
+						}
+						want := state.clone()
+						accepted := consumer.step(ins, &state, nil, 0, arch)
+						if accepted != consumer.step(canonical, &want, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+							t.Fatalf("%s numerical alias byte/state mismatch: %s %s arch=%s missing=%d", consumer.name, alias, operands, arch, missing)
+						}
+						if state.flags != x86ByteFlagsAll {
+							t.Fatal("source MOVQ alias changed status knowledge")
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesScalarFPWidthsAndOriginalCallerIdentity(t *testing.T) {
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, row := range []string{alias + " x+0(FP),AX", alias + " AX,ret+8(FP)"} {
+			ins := x86PureGPUnknownInstruction(t, row)
+			index := 0
+			if ins.Args[1].Kind == OpFP {
+				index = 1
+			}
+			if width, write, known := X86FPAccessBytes(ins, index, "amd64"); !known || width != 8 || write != (index == 1) {
+				t.Errorf("original alias FP width lost: %s: %d %v %v", row, width, write, known)
+			}
+			if width := x86ScalarMoveMemoryBytes(ins, index, "amd64"); width != 8 {
+				t.Errorf("original source-stack width lost: %s: %d", row, width)
+			}
+		}
+		body := alias + " DI,R11\n" + alias + " R11,DI\nMOVL $7,AX\nMOVL AX,(DX)"
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", body, 1)
+		goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		before, err := x86CallerSourceFingerprint(file.Funcs[0])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+			t.Errorf("actual source alias lost complete caller/pointer identity: %s: %v", alias, err)
+		}
+		after, err := x86CallerSourceFingerprint(file.Funcs[0])
+		if err != nil || before != after {
+			t.Fatal("alias consumer changed the original sealed caller source")
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesNativeLoadsAndMode32Rejections(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, alias := range x86OriginalMOVQAliases(t) {
+			for _, destination := range []string{"X0", "DX"} {
+				if target.arch == "386" && destination == "DX" {
+					continue
+				}
+				t.Run(target.triple+"/"+alias+"/"+destination, func(t *testing.T) {
+					move, result := "MOVQ", 8
+					if target.arch == "386" {
+						move, result = "MOVL", 4
+					}
+					body := fmt.Sprintf("%s p+0(FP),AX\n%s -1(AX)(CX*1),%s\n%s %s,ret+%d(FP)\nRET", move, alias, destination, alias, destination, result)
+					body = strings.Replace(body, alias+" -1", "MOVL $1,CX\n"+alias+" -1", 1)
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, "func Value(p *[8]byte) uint64", body)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[8]byte) uint64\n", target.arch, target.triple, api)
+						if err != nil || !strings.Contains(ir, "load volatile i64") {
+							t.Fatalf("%s alias lost its exact eight-byte native read: %v\n%s", api, err, ir)
+						}
+						x86ResultInitializationObject(t, llc, target.triple, ir, api)
+					}
+				})
+			}
+		}
+	}
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		for _, operands := range []string{"AX,BX", "(AX),BX", "AX,(BX)", "AX,X0", "X0,AX", "$1,AX", "M0,M1"} {
+			source := "TEXT Value(SB),4,$0-0\n" + alias + " " + operands + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", source, "", false)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()\n", "386", "i386-unknown-linux-gnu", api)
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s mode32 alias admitted an actual rejected MOVQ row: %s %s: %v", api, alias, operands, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86MOVQSourceAliasesRetainRawIntelAndUnknownState(t *testing.T) {
+	for _, body := range []string{
+		"MOVDQ2Q CX,X0\nMOVQ X0,ret+0(FP)\nRET",
+		"MOVB $1,CX\nMOVDQ2Q CX,X0\nMOVQ X0,ret+0(FP)\nRET",
+		"MOVQ $1,CX\nMOVQ CX,X0\nBYTE $0xf2\nBYTE $0x0f\nBYTE $0xd6\nBYTE $0xc8\nMOVQ M1,ret+0(FP)\nRET",
+	} {
+		_, _, _, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", body)
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint64\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Errorf("%s source alias acquired initialized/native MMX state: body=%q: %v", api, body, err)
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nMOVDQ2Q AX,BX\nBYTE $0xf2\nBYTE $0x0f\nBYTE $0xd6\nBYTE $0xc8\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := NormalizeRawFileForTranslation(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw, err := x86asm.Decode([]byte{0xf2, 0x0f, 0xd6, 0xc8}, 64)
+	if err != nil || raw.Op != x86asm.MOVDQ2Q {
+		t.Fatal("independent literal bytes lost physical MOVDQ2Q")
+	}
+	physical := normalized.Funcs[0].Instrs[2]
+	if normalized.Funcs[0].Instrs[1].Op != "MOVDQ2Q" || normalized.Funcs[0].Instrs[1].Raw != "MOVDQ2Q AX,BX" ||
+		physical.Op != "MOVDQ2Q" || physical.x86SourceRaw == nil || physical.Args[1].Reg != "M1" || file.Funcs[0].Instrs[1].Op != "MOVDQ2Q" {
+		t.Fatalf("named Go alias changed its original spelling or raw Intel physical role: %+v", normalized.Funcs[0].Instrs)
+	}
+	for _, alias := range x86OriginalMOVQAliases(t) {
+		ins := x86PureGPUnknownInstruction(t, alias+" X0,M1")
+		state := x86ResultState{}
+		state.xmm[0] = 0xffff
+		for _, consumer := range x86ResultGPSIMDConsumers {
+			if consumer.step(ins, &state, nil, 0, "amd64") {
+				t.Fatal("numerical alias observer manufactured native MMX state", alias, consumer.name)
+			}
+		}
+	}
+}
diff --git a/amd64_mul_div_round_helpers.go b/amd64_mul_div_round_helpers.go
new file mode 100644
index 000000000..e85b6c492
--- /dev/null
+++ b/amd64_mul_div_round_helpers.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Fixed rounding with SAE must not perform ambient floating arithmetic: LLVM
+// may lower constrained operations to libcalls, and even a corrected result
+// cannot undo a hardware exception. All arithmetic below is integer-only.
+// A finite product is exact in 106 bits. Division generates p+3 quotient bits
+// by bounded restoring division and jams the remaining exact remainder.
+// The private ABI carries raw i32/i64 bits, never float/double. Otherwise an
+// un-inlined mode32 C return would use x87 and could change exception state.
+func emitX86FloatMulDivRoundingHelper(b *strings.Builder, bits int) {
+	fractionBits, bias := 23, 127
+	if bits == 64 {
+		fractionBits, bias = 52, 1023
+	}
+	typ := amd64FMA3LLVMType(1, bits)
+	infBits := uint64(2*bias+1) << fractionBits
+	signBit := uint64(1) << (bits - 1)
+	quietBit := uint64(1) << (fractionBits - 1)
+
+	fmt.Fprintf(b, "define internal i%d @__plan9asm_mul_div_round_f%d(i%d %%left, i%d %%right, i1 %%divide, i32 %%mode, i32 %%mxcsr) {\nentry:\n", bits, bits, bits, bits)
+	e := amd64FMA3IntegerEmitter{b: b}
+	daz := e.value("and i32 %%mxcsr, 64")
+	daz = e.value("icmp ne i32 %s, 0", daz)
+	leftValue := e.value("bitcast i%d %%left to %s", bits, typ)
+	rightValue := e.value("bitcast i%d %%right to %s", bits, typ)
+	left, right := e.input(bits, leftValue, daz), e.input(bits, rightValue, daz)
+
+	// NaNs retain source priority and payload; invalid non-NaN operations
+	// produce the architecture's negative quiet indefinite value.
+	a := e.value("bitcast %s %s to i%d", typ, left.floating, bits)
+	bb := e.value("bitcast %s %s to i%d", typ, right.floating, bits)
+	aAbs := e.value("and i%d %s, %d", bits, a, signBit-1)
+	bAbs := e.value("and i%d %s, %d", bits, bb, signBit-1)
+	aNaN := e.value("icmp ugt i%d %s, %d", bits, aAbs, infBits)
+	bNaN := e.value("icmp ugt i%d %s, %d", bits, bAbs, infBits)
+	anyNaN := e.value("or i1 %s, %s", aNaN, bNaN)
+	selectedNaN := e.value("select i1 %s, i%d %s, i%d %s", aNaN, bits, a, bits, bb)
+	selectedNaN = e.value("or i%d %s, %d", bits, selectedNaN, quietBit)
+	aInf := e.value("icmp eq i%d %s, %d", bits, aAbs, infBits)
+	bInf := e.value("icmp eq i%d %s, %d", bits, bAbs, infBits)
+	aZero := e.value("icmp eq i128 %s, 0", left.magnitude)
+	bZero := e.value("icmp eq i128 %s, 0", right.magnitude)
+	negative := e.value("xor i1 %s, %s", left.negative, right.negative)
+	sign := e.value("select i1 %s, i%d %d, i%d 0", negative, bits, signBit, bits)
+	signedInf := e.value("or i%d %s, %d", bits, sign, infBits)
+	invalidMulA := e.value("and i1 %s, %s", aInf, bZero)
+	invalidMulB := e.value("and i1 %s, %s", bInf, aZero)
+	invalidMul := e.value("or i1 %s, %s", invalidMulA, invalidMulB)
+	invalidDivA := e.value("and i1 %s, %s", aInf, bInf)
+	invalidDivB := e.value("and i1 %s, %s", aZero, bZero)
+	invalidDiv := e.value("or i1 %s, %s", invalidDivA, invalidDivB)
+	invalid := e.value("select i1 %%divide, i1 %s, i1 %s", invalidDiv, invalidMul)
+	anyInf := e.value("or i1 %s, %s", aInf, bInf)
+	anyZero := e.value("or i1 %s, %s", aZero, bZero)
+	divInf := e.value("or i1 %s, %s", aInf, bZero)
+	resultInf := e.value("select i1 %%divide, i1 %s, i1 %s", divInf, anyInf)
+	special := e.value("or i1 %s, %s", anyInf, anyZero)
+	special = e.value("or i1 %s, %s", special, anyNaN)
+	encoded := e.value("select i1 %s, i%d %s, i%d %s", resultInf, bits, signedInf, bits, sign)
+	encoded = e.value("select i1 %s, i%d %d, i%d %s", invalid, bits, signBit|infBits|quietBit, bits, encoded)
+	encoded = e.value("select i1 %s, i%d %s, i%d %s", anyNaN, bits, selectedNaN, bits, encoded)
+	fmt.Fprintf(b, "  br i1 %s, label %%special, label %%finite\nspecial:\n", special)
+	fmt.Fprintf(b, "  ret i%d %s\nfinite:\n  br i1 %%divide, label %%division_prepare, label %%multiply\nmultiply:\n", bits, encoded)
+	product := e.value("mul i128 %s, %s", left.magnitude, right.magnitude)
+	productUnit := e.value("add i32 %s, %s", left.exponent, right.exponent)
+
+	// Normalize both finite nonzero significands to the same leading bit.
+	b.WriteString("  br label %round\ndivision_prepare:\n")
+	aLeading := e.value("call i128 @llvm.ctlz.i128(i128 %s, i1 false)", left.magnitude)
+	bLeading := e.value("call i128 @llvm.ctlz.i128(i128 %s, i1 false)", right.magnitude)
+	aLeading = e.value("trunc i128 %s to i32", aLeading)
+	bLeading = e.value("trunc i128 %s to i32", bLeading)
+	aHighest := e.value("sub i32 127, %s", aLeading)
+	bHighest := e.value("sub i32 127, %s", bLeading)
+	aShift := e.value("sub i32 %d, %s", fractionBits, aHighest)
+	bShift := e.value("sub i32 %d, %s", fractionBits, bHighest)
+	aShift = e.value("zext i32 %s to i128", aShift)
+	bShift = e.value("zext i32 %s to i128", bShift)
+	numerator := e.value("shl i128 %s, %s", left.magnitude, aShift)
+	denominator := e.value("shl i128 %s, %s", right.magnitude, bShift)
+	aTop := e.value("add i32 %s, %s", left.exponent, aHighest)
+	bTop := e.value("add i32 %s, %s", right.exponent, bHighest)
+	ratioExponent := e.value("sub i32 %s, %s", aTop, bTop)
+	belowOne := e.value("icmp ult i128 %s, %s", numerator, denominator)
+	doubled := e.value("shl i128 %s, 1", numerator)
+	numerator = e.value("select i1 %s, i128 %s, i128 %s", belowOne, doubled, numerator)
+	exponentCorrection := e.value("zext i1 %s to i32", belowOne)
+	ratioExponent = e.value("sub i32 %s, %s", ratioExponent, exponentCorrection)
+	quotientUnit := e.value("sub i32 %s, %d", ratioExponent, fractionBits+3)
+	initialRemainder := e.value("sub i128 %s, %s", numerator, denominator)
+
+	// numerator is in [denominator, 2*denominator). Each iteration keeps
+	// remainder in [0, denominator), emitting exactly one quotient bit.
+	b.WriteString("  br label %division_loop\ndivision_loop:\n")
+	b.WriteString("  %quotient = phi i128 [ 1, %division_prepare ], [ %next_quotient, %division_loop ]\n")
+	fmt.Fprintf(b, "  %%remainder = phi i128 [ %s, %%division_prepare ], [ %%next_remainder, %%division_loop ]\n", initialRemainder)
+	b.WriteString("  %iteration = phi i32 [ 0, %division_prepare ], [ %next_iteration, %division_loop ]\n")
+	doubledRemainder := e.value("shl i128 %%remainder, 1")
+	quotientBit := e.value("icmp uge i128 %s, %s", doubledRemainder, denominator)
+	subtracted := e.value("sub i128 %s, %s", doubledRemainder, denominator)
+	fmt.Fprintf(b, "  %%next_remainder = select i1 %s, i128 %s, i128 %s\n", quotientBit, subtracted, doubledRemainder)
+	shiftedQuotient := e.value("shl i128 %%quotient, 1")
+	bit128 := e.value("zext i1 %s to i128", quotientBit)
+	fmt.Fprintf(b, "  %%next_quotient = or i128 %s, %s\n", shiftedQuotient, bit128)
+	b.WriteString("  %next_iteration = add i32 %iteration, 1\n")
+	done := e.value("icmp eq i32 %%next_iteration, %d", fractionBits+3)
+	fmt.Fprintf(b, "  br i1 %s, label %%division_done, label %%division_loop\ndivision_done:\n", done)
+	sticky := e.value("icmp ne i128 %%next_remainder, 0")
+	sticky = e.value("zext i1 %s to i128", sticky)
+	jammed := e.value("or i128 %%next_quotient, %s", sticky)
+
+	b.WriteString("  br label %round\nround:\n")
+	magnitude := e.value("phi i128 [ %s, %%multiply ], [ %s, %%division_done ]", product, jammed)
+	unit := e.value("phi i32 [ %s, %%multiply ], [ %s, %%division_done ]", productUnit, quotientUnit)
+	emitX86FloatMulDivRoundPack(&e, bits, magnitude, unit, negative)
+}
+
+// magnitude is nonzero. Multiplication retains its exact integer significand;
+// division retains three guard bits plus jammed remainder. Clamp every shift
+// before emission, including inactive select arms, so no LLVM poison is used.
+func emitX86FloatMulDivRoundPack(e *amd64FMA3IntegerEmitter, bits int, magnitude, unit, negative string) {
+	fractionBits, bias := 23, 127
+	if bits == 64 {
+		fractionBits, bias = 52, 1023
+	}
+
+	leading := e.value("call i128 @llvm.ctlz.i128(i128 %s, i1 false)", magnitude)
+	leading = e.value("trunc i128 %s to i32", leading)
+	highest := e.value("sub i32 127, %s", leading)
+	normalShift := e.value("sub i32 %s, %d", highest, fractionBits)
+	subnormalShift := e.value("sub i32 %d, %s", 1-bias-fractionBits, unit)
+	isSubnormal := e.value("icmp sgt i32 %s, %s", subnormalShift, normalShift)
+	shift := e.value("select i1 %s, i32 %s, i32 %s", isSubnormal, subnormalShift, normalShift)
+	positiveShift := e.value("icmp sgt i32 %s, 0", shift)
+	far := e.value("icmp sge i32 %s, 128", shift)
+	safeRight := e.value("select i1 %s, i32 %s, i32 0", positiveShift, shift)
+	safeRight = e.value("select i1 %s, i32 127, i32 %s", far, safeRight)
+	safeRight = e.value("zext i32 %s to i128", safeRight)
+	right := e.value("lshr i128 %s, %s", magnitude, safeRight)
+	right = e.value("select i1 %s, i128 0, i128 %s", far, right)
+	leftCount := e.value("sub i32 0, %s", shift)
+	leftCount = e.value("select i1 %s, i32 0, i32 %s", positiveShift, leftCount)
+	leftFar := e.value("icmp ugt i32 %s, 127", leftCount)
+	leftCount = e.value("select i1 %s, i32 127, i32 %s", leftFar, leftCount)
+	leftCount = e.value("zext i32 %s to i128", leftCount)
+	left := e.value("shl i128 %s, %s", magnitude, leftCount)
+	unrounded := e.value("select i1 %s, i128 %s, i128 %s", positiveShift, right, left)
+
+	mask := e.value("shl i128 1, %s", safeRight)
+	mask = e.value("sub i128 %s, 1", mask)
+	remainder := e.value("and i128 %s, %s", magnitude, mask)
+	remainder = e.value("select i1 %s, i128 %s, i128 %s", far, magnitude, remainder)
+	inexact := e.value("icmp ne i128 %s, 0", remainder)
+	halfCount := e.value("sub i32 %s, 1", shift)
+	halfCount = e.value("select i1 %s, i32 %s, i32 0", positiveShift, halfCount)
+	halfFar := e.value("icmp ugt i32 %s, 127", halfCount)
+	halfCount = e.value("select i1 %s, i32 127, i32 %s", halfFar, halfCount)
+	halfCount = e.value("zext i32 %s to i128", halfCount)
+	half := e.value("shl i128 1, %s", halfCount)
+	above := e.value("icmp ugt i128 %s, %s", remainder, half)
+	tied := e.value("icmp eq i128 %s, %s", remainder, half)
+	odd := e.value("and i128 %s, 1", unrounded)
+	odd = e.value("icmp ne i128 %s, 0", odd)
+	tied = e.value("and i1 %s, %s", tied, odd)
+	nearest := e.value("or i1 %s, %s", above, tied)
+	validHalf := e.value("xor i1 %s, true", halfFar)
+	validHalf = e.value("and i1 %s, %s", validHalf, positiveShift)
+	nearest = e.value("and i1 %s, %s", nearest, validHalf)
+	downward := e.value("icmp eq i32 %%mode, 1")
+	upward := e.value("icmp eq i32 %%mode, 2")
+	positive := e.value("xor i1 %s, true", negative)
+	directed := e.value("and i1 %s, %s", downward, negative)
+	upwardPositive := e.value("and i1 %s, %s", upward, positive)
+	directed = e.value("or i1 %s, %s", directed, upwardPositive)
+	awayFromZero := directed
+	directed = e.value("and i1 %s, %s", directed, inexact)
+	isNearest := e.value("icmp eq i32 %%mode, 0")
+	increment := e.value("select i1 %s, i1 %s, i1 %s", isNearest, nearest, directed)
+	increment = e.value("zext i1 %s to i128", increment)
+	rounded := e.value("add i128 %s, %s", unrounded, increment)
+
+	carry := e.value("icmp uge i128 %s, %d", rounded, uint64(1)<<(fractionBits+1))
+	carried := e.value("lshr i128 %s, 1", rounded)
+	rounded = e.value("select i1 %s, i128 %s, i128 %s", carry, carried, rounded)
+	carry32 := e.value("zext i1 %s to i32", carry)
+	exponent := e.value("add i32 %s, %s", unit, shift)
+	exponent = e.value("add i32 %s, %d", exponent, fractionBits+bias)
+	exponent = e.value("add i32 %s, %s", exponent, carry32)
+	stillSubnormal := e.value("icmp ult i128 %s, %d", rounded, uint64(1)<<fractionBits)
+	exponent = e.value("select i1 %s, i32 0, i32 %s", stillSubnormal, exponent)
+	encodedExponent := exponent
+	if bits == 64 {
+		encodedExponent = e.value("zext i32 %s to i64", exponent)
+	}
+	encodedExponent = e.value("shl i%d %s, %d", bits, encodedExponent, fractionBits)
+	fraction := e.value("trunc i128 %s to i%d", rounded, bits)
+	fraction = e.value("and i%d %s, %d", bits, fraction, uint64(1)<<fractionBits-1)
+	encoded := e.value("or i%d %s, %s", bits, encodedExponent, fraction)
+	overflow := e.value("icmp sge i32 %s, %d", exponent, 2*bias+1)
+	toInfinity := e.value("or i1 %s, %s", isNearest, awayFromZero)
+	infBits := uint64(2*bias+1) << fractionBits
+	overflowBits := e.value("select i1 %s, i%d %d, i%d %d", toInfinity, bits, infBits, bits, infBits-1)
+	encoded = e.value("select i1 %s, i%d %s, i%d %s", overflow, bits, overflowBits, bits, encoded)
+
+	ftz := e.value("and i32 %%mxcsr, 32768")
+	ftz = e.value("icmp ne i32 %s, 0", ftz)
+	// Intel SDM 4.9.1.5 detects tininess after rounding with an unbounded
+	// exponent, not after the additional rounding onto the subnormal grid.
+	// Thus minimum-normal/(1+ulp), RU, is tiny, while maximum-subnormal
+	// *(1+ulp), RN or RU, rounds to a normal unbounded-exponent result.
+	tiny := emitX86FloatMulDivUnboundedTiny(e, fractionBits, bias, magnitude, normalShift, highest, unit, isNearest, awayFromZero)
+	flush := e.value("and i1 %s, %s", ftz, tiny)
+	encoded = e.value("select i1 %s, i%d 0, i%d %s", flush, bits, bits, encoded)
+	sign := e.value("select i1 %s, i%d %d, i%d 0", negative, bits, uint64(1)<<(bits-1), bits)
+	encoded = e.value("or i%d %s, %s", bits, encoded, sign)
+	fmt.Fprintf(e.b, "  ret i%d %s\n}\n\n", bits, encoded)
+}
+
+func emitX86FloatMulDivUnboundedTiny(e *amd64FMA3IntegerEmitter, fractionBits, bias int, magnitude, shift, highest, unit, isNearest, awayFromZero string) string {
+	// Here shift is highest-fractionBits, not the subnormal-grid shift.
+	// Its domain is [-52, 53] for a product, or exactly 3 for a quotient.
+	positive := e.value("icmp sgt i32 %s, 0", shift)
+	rightCount := e.value("select i1 %s, i32 %s, i32 0", positive, shift)
+	rightCount = e.value("zext i32 %s to i128", rightCount)
+	right := e.value("lshr i128 %s, %s", magnitude, rightCount)
+	leftCount := e.value("sub i32 0, %s", shift)
+	leftCount = e.value("select i1 %s, i32 0, i32 %s", positive, leftCount)
+	leftCount = e.value("zext i32 %s to i128", leftCount)
+	left := e.value("shl i128 %s, %s", magnitude, leftCount)
+	unrounded := e.value("select i1 %s, i128 %s, i128 %s", positive, right, left)
+	mask := e.value("shl i128 1, %s", rightCount)
+	mask = e.value("sub i128 %s, 1", mask)
+	remainder := e.value("and i128 %s, %s", magnitude, mask)
+	inexact := e.value("icmp ne i128 %s, 0", remainder)
+	halfCount := e.value("sub i32 %s, 1", shift)
+	halfCount = e.value("select i1 %s, i32 %s, i32 0", positive, halfCount)
+	halfCount = e.value("zext i32 %s to i128", halfCount)
+	half := e.value("shl i128 1, %s", halfCount)
+	above := e.value("icmp ugt i128 %s, %s", remainder, half)
+	tied := e.value("icmp eq i128 %s, %s", remainder, half)
+	odd := e.value("and i128 %s, 1", unrounded)
+	odd = e.value("icmp ne i128 %s, 0", odd)
+	tied = e.value("and i1 %s, %s", tied, odd)
+	nearest := e.value("or i1 %s, %s", above, tied)
+	nearest = e.value("and i1 %s, %s", positive, nearest)
+	directed := e.value("and i1 %s, %s", awayFromZero, inexact)
+	increment := e.value("select i1 %s, i1 %s, i1 %s", isNearest, nearest, directed)
+	increment = e.value("zext i1 %s to i128", increment)
+	rounded := e.value("add i128 %s, %s", unrounded, increment)
+	carry := e.value("icmp uge i128 %s, %d", rounded, uint64(1)<<(fractionBits+1))
+	carry32 := e.value("zext i1 %s to i32", carry)
+	top := e.value("add i32 %s, %s", highest, unit)
+	top = e.value("add i32 %s, %s", top, carry32)
+	return e.value("icmp slt i32 %s, %d", top, 1-bias)
+}
diff --git a/amd64_mul_div_round_helpers_runtime_test.go b/amd64_mul_div_round_helpers_runtime_test.go
new file mode 100644
index 000000000..2413d90f5
--- /dev/null
+++ b/amd64_mul_div_round_helpers_runtime_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86MulDivRoundHelperFixtureIR() string {
+	var ir strings.Builder
+	ir.WriteString("declare i128 @llvm.ctlz.i128(i128, i1)\n")
+	for _, bits := range []int{32, 64} {
+		emitX86FloatMulDivRoundingHelper(&ir, bits)
+		fmt.Fprintf(&ir, "define i%d @mul_div%d(i%d %%a, i%d %%b, i32 %%divide, i32 %%mode, i32 %%mxcsr) {\n", bits, bits, bits, bits)
+		ir.WriteString("  %is_divide = icmp ne i32 %divide, 0\n")
+		fmt.Fprintf(&ir, "  %%value = call i%d @__plan9asm_mul_div_round_f%d(i%d %%a, i%d %%b, i1 %%is_divide, i32 %%mode, i32 %%mxcsr)\n", bits, bits, bits, bits)
+		fmt.Fprintf(&ir, "  ret i%d %%value\n}\n", bits)
+	}
+	return ir.String()
+}
+
+func x86MulDivRoundOptimize(t *testing.T, ir string) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	return module.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatMulDivIntegerRoundingExtremes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	ir := x86MulDivRoundHelperFixtureIR()
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2-%t", optimized), func(t *testing.T) {
+			source := ir
+			if optimized {
+				source = x86MulDivRoundOptimize(t, source)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "integer-mul-div-round", triple, source, x86MulDivRoundSSEOracle, prefix)
+		})
+	}
+}
+
+func TestX86FloatMulDivIntegerRoundingOriginalSSEObjects(t *testing.T) {
+	for _, row := range []struct {
+		opcode string
+		prefix byte
+		code   byte
+	}{
+		{"MULSS", 0xf3, 0x59}, {"MULSD", 0xf2, 0x59},
+		{"DIVSS", 0xf3, 0x5e}, {"DIVSD", 0xf2, 0x5e},
+	} {
+		listing := x86InsertExtractGoListing(t, "amd64", "TEXT f(SB),4,$0-0\n"+row.opcode+" X1,X0\nRET\n")
+		var actual []byte
+		for _, line := range strings.Split(string(listing), "\n") {
+			actual = append(actual, x86InsertExtractListedBytes(line)...)
+		}
+		want := []byte{row.prefix, 0x0f, row.code, 0xc1, 0xc3}
+		if !bytes.Equal(actual, want) {
+			t.Fatalf("actual Go %s object %x, want independent native SSE oracle %x", row.opcode, actual, want)
+		}
+	}
+}
+
+func TestX86FloatMulDivIntegerRoundingOnlyIntegerArithmeticAndBoundedDivision(t *testing.T) {
+	for _, optimized := range []bool{false, true} {
+		ir := x86MulDivRoundHelperFixtureIR()
+		if optimized {
+			ir = x86MulDivRoundOptimize(t, ir)
+		}
+		for _, forbidden := range []string{
+			`\b(fadd|fsub|fmul|fdiv|frem|fcmp|fptosi|fptoui|sitofp|uitofp)\b`,
+			`\b(udiv|sdiv|urem|srem)\b`, `@llvm\.(fma|experimental\.constrained)`,
+		} {
+			if regexp.MustCompile(forbidden).MatchString(ir) {
+				t.Fatalf("O2=%t: fixed-round SAE helper contains forbidden arithmetic %s", optimized, forbidden)
+			}
+		}
+		if !optimized {
+			for _, limit := range []string{"icmp eq i32 %next_iteration, 26", "icmp eq i32 %next_iteration, 55"} {
+				if !strings.Contains(ir, limit) {
+					t.Fatalf("missing exact restoring-division bound %s", limit)
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatMulDivIntegerRoundingFiveLLVM22Targets(t *testing.T) {
+	llc, nm := findLLVM22Tool("llc"), findLLVM22Tool("llvm-nm")
+	if llc == "" || nm == "" {
+		t.Fatal("LLVM22 llc/llvm-nm required")
+	}
+	for _, optimized := range []bool{false, true} {
+		ir := x86MulDivRoundHelperFixtureIR()
+		backendLevel := "-O0"
+		if optimized {
+			ir = x86MulDivRoundOptimize(t, ir)
+			backendLevel = "-O2"
+		}
+		for _, triple := range []string{
+			"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+			"i386-unknown-linux-gnu", "i686-pc-windows-msvc",
+		} {
+			t.Run(fmt.Sprintf("O2-%t/%s", optimized, triple), func(t *testing.T) {
+				dir := t.TempDir()
+				source, object := filepath.Join(dir, "integer-round.ll"), filepath.Join(dir, "integer-round.o")
+				assembly := filepath.Join(dir, "integer-round.s")
+				if err := os.WriteFile(source, []byte(ir), 0600); err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				out, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, llc, backendLevel, "-mtriple="+triple, "-filetype=obj", source, "-o", object))
+				cancel()
+				if err != nil {
+					t.Fatalf("LLVM22 object: %v\n%s", err, out)
+				}
+				ctx, cancel = runtimeOracleStageContext(t)
+				out, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, nm, "--undefined-only", object))
+				cancel()
+				if err != nil {
+					t.Fatalf("LLVM22 nm: %v\n%s", err, out)
+				}
+				for _, line := range strings.Split(string(out), "\n") {
+					fields := strings.Fields(line)
+					if len(fields) == 0 {
+						continue
+					}
+					// COFF's CRT floating-point marker has an extra C-name
+					// prefix in mode32. It is not an arithmetic libcall.
+					marker := "_fltused"
+					if strings.HasPrefix(triple, "i686-") {
+						marker = "__fltused"
+					}
+					if !strings.Contains(triple, "windows") || len(fields) != 2 || fields[0] != "U" || fields[1] != marker {
+						t.Fatalf("integer helper has unresolved arithmetic dependency: %s", line)
+					}
+				}
+				ctx, cancel = runtimeOracleStageContext(t)
+				out, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, llc, backendLevel, "-mtriple="+triple, "-filetype=asm", source, "-o", assembly))
+				cancel()
+				if err != nil {
+					t.Fatalf("LLVM22 machine assembly: %v\n%s", err, out)
+				}
+				machine, err := os.ReadFile(assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Includes every helper and its actual call sites. An integer
+				// IR body alone does not close a float-return x87 C ABI.
+				floating := regexp.MustCompile(`(?m)^[\t ]+(f[a-z]+|v?(add|sub|mul|div|sqrt|comi|ucomi)(ss|sd|ps|pd))(\s|$)`)
+				if instruction := floating.Find(machine); instruction != nil {
+					t.Fatalf("SAE bit carrier emits floating instruction %q", instruction)
+				}
+			})
+		}
+	}
+}
+
+const x86MulDivRoundSSEOracle = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint32_t mul_div32(uint32_t,uint32_t,unsigned,unsigned,unsigned);
+extern uint64_t mul_div64(uint64_t,uint64_t,unsigned,unsigned,unsigned);
+static unsigned mismatches;
+static uint64_t state=UINT64_C(0x372bd0ae71d94285);
+static uint64_t random_bits(void){state^=state<<13;state^=state>>7;state^=state<<17;return state;}
+
+/* Independent physical SSE. Language arithmetic, production classification,
+   integer helpers and AVX512 are not used to compute expected result bits. */
+__attribute__((noinline)) static uint64_t native_sse(unsigned width,uint64_t a,uint64_t b,unsigned divide,unsigned csr){
+ unsigned saved;__asm__ volatile("stmxcsr %0":"=m"(saved)::"memory");
+ __asm__ volatile("ldmxcsr %0"::"m"(csr):"memory");
+ uint64_t result=0;
+ if(width==32){
+  uint32_t aa=a,bb=b,out;float left,right;memcpy(&left,&aa,4);memcpy(&right,&bb,4);
+  if(divide)__asm__ volatile("divss %1,%0":"+x"(left):"x"(right));
+  else __asm__ volatile("mulss %1,%0":"+x"(left):"x"(right));
+  memcpy(&out,&left,4);result=out;
+ }else{
+  double left,right;memcpy(&left,&a,8);memcpy(&right,&b,8);
+  if(divide)__asm__ volatile("divsd %1,%0":"+x"(left):"x"(right));
+  else __asm__ volatile("mulsd %1,%0":"+x"(left):"x"(right));
+  memcpy(&result,&left,8);
+ }
+ __asm__ volatile("ldmxcsr %0"::"m"(saved):"memory");return result;
+}
+
+static int check(unsigned width,uint64_t a,uint64_t b,unsigned divide,unsigned mode,unsigned ambient,unsigned control){
+ unsigned actualCSR=control|(ambient<<13),referenceCSR=control|(mode<<13),saved,after;
+ __asm__ volatile("stmxcsr %0":"=m"(saved)::"memory");
+ __asm__ volatile("ldmxcsr %0"::"m"(actualCSR):"memory");
+ uint64_t want=native_sse(width,a,b,divide,referenceCSR);
+ uint64_t got=width==32?mul_div32(a,b,divide,mode,actualCSR):mul_div64(a,b,divide,mode,actualCSR);
+ __asm__ volatile("stmxcsr %0":"=m"(after)::"memory");
+ __asm__ volatile("ldmxcsr %0"::"m"(saved):"memory");
+ if(got!=want||after!=actualCSR){
+  if(mismatches++<8)fprintf(stderr,"integer MUL/DIV width/divide/mode/ambient/control=%u/%u/%u/%u/%x a=%llx b=%llx got=%llx want=%llx CSR=%x want=%x\n",width,divide,mode,ambient,control,(unsigned long long)a,(unsigned long long)b,(unsigned long long)got,(unsigned long long)want,after,actualCSR);
+  return 1;
+ }
+ return 0;
+}
+
+static int matrix(unsigned width,uint64_t a,uint64_t b){
+ const unsigned controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+ int failed=0;
+ for(unsigned divide=0;divide<2;divide++)for(unsigned mode=0;mode<4;mode++)
+  for(unsigned ambient=0;ambient<4;ambient++)for(unsigned c=0;c<6;c++)
+   failed|=check(width,a,b,divide,mode,ambient,controls[c]);
+ return failed;
+}
+
+int main(void){
+ int failed=0;
+ /* The first focused RED independently observes RU, not ambient RN. */
+ failed|=check(32,0x3f800001,0x3f800001,0,2,0,0x1f80);
+ failed|=check(64,UINT64_C(0x3ff0000000000000),UINT64_C(0x4008000000000000),1,2,0,0x1f80);
+ /* Tiny before rounding, even though RU would produce minimum normal. */
+ failed|=check(32,0x00800000,0x3f800001,1,2,0,0x9f80);
+ failed|=check(64,UINT64_C(0x0010000000000000),UINT64_C(0x3ff0000000000001),1,2,0,0x9f80);
+ const uint64_t edges32[]={0,0x80000000,1,0x80000001,0x7fffff,0x807fffff,0x800000,0x80800000,
+  0x800001,0x7f7fffff,0xff7fffff,0x3f000000,0xbf000000,0x3f800000,0xbf800000,0x3f800001,
+  0xbf800001,0x3f800002,0x40400000,0xc0400000,0x7f800000,0xff800000,0x7fc12345,0xffc45678,
+  0x7f812345,0xff845678,0x00800000,0x40000000};
+ const uint64_t edges64[]={0,UINT64_C(0x8000000000000000),1,UINT64_C(0x8000000000000001),
+  UINT64_C(0xfffffffffffff),UINT64_C(0x800fffffffffffff),UINT64_C(0x10000000000000),UINT64_C(0x8010000000000000),
+  UINT64_C(0x10000000000001),UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),
+  UINT64_C(0x3fe0000000000000),UINT64_C(0xbfe0000000000000),UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),
+  UINT64_C(0x3ff0000000000001),UINT64_C(0xbff0000000000001),UINT64_C(0x3ff0000000000002),
+  UINT64_C(0x4008000000000000),UINT64_C(0xc008000000000000),UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),
+  UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff8fedcba987654),UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff0fedcba987654),
+  UINT64_C(0x10000000000000),UINT64_C(0x4000000000000000)};
+ for(unsigned i=0;i<sizeof(edges32)/sizeof(edges32[0]);i++)for(unsigned j=0;j<sizeof(edges32)/sizeof(edges32[0]);j++)failed|=matrix(32,edges32[i],edges32[j]);
+ for(unsigned i=0;i<sizeof(edges64)/sizeof(edges64[0]);i++)for(unsigned j=0;j<sizeof(edges64)/sizeof(edges64[0]);j++)failed|=matrix(64,edges64[i],edges64[j]);
+ for(unsigned sample=0;sample<1024;sample++){
+  uint64_t a=random_bits(),b=random_bits();failed|=matrix(32,(uint32_t)a,(uint32_t)b);failed|=matrix(64,a,b);
+ }
+ if(failed)fprintf(stderr,"MUL/DIV total mismatches=%u\n",mismatches);
+ return failed;
+}
+`
diff --git a/amd64_mulx_forms.go b/amd64_mulx_forms.go
new file mode 100644
index 000000000..e6e70b1b4
--- /dev/null
+++ b/amd64_mulx_forms.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86MULXForm struct {
+	bits              int
+	source, low, high Operand
+}
+
+var x86MULXWidths = map[Op]int{"MULXL": 32, "MULXQ": 64}
+
+// Go's complete _yandnl shape is shared with ANDN/PDEP/PEXT, but MULX
+// reads implicit DX and writes two destinations without touching FLAGS.
+func x86MULXProperties(op Op, ins Instr, arch string) (x86MULXForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86MULXWidths[Op(name)]
+	form := x86MULXForm{bits: bits}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86MULXForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go MULX _yandnl grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 3 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	form.source, form.low, form.high = ins.Args[0], ins.Args[1], ins.Args[2]
+	for _, output := range []Operand{form.low, form.high} {
+		if output.Kind != OpReg || !isX86YrlRegisterForArch(output.Reg, arch) {
+			return fail()
+		}
+	}
+	if form.source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.source.Reg, arch) {
+			return fail()
+		}
+	} else if !x86ScalarCompareMemoryValid(form.source, arch) {
+		return fail()
+	}
+	if arch == "386" && bits == 64 {
+		// Go accepts the name, but physical VEX.WIG is dword. The default
+		// raw decoder keeps its existing W1 rejection; a PC observer cannot
+		// supply an ordinary qword source role.
+		return form, true, fmt.Errorf("%w: mode32 MULXQ needs its physical WIG source role", ErrProbeNeedsContext)
+	}
+	return form, true, nil
+}
+
+func x86TypedMULXByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86MULXProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: width, read: true},
+		{index: -1, operand: Operand{Kind: OpReg, Reg: DX}, width: width, read: true},
+		{index: 1, operand: form.low, width: width, write: true},
+		{index: 2, operand: form.high, width: width, write: true},
+	}}, true, nil
+}
+
+func x86RawMULXSource(ins Instr, arch string) bool {
+	_, known, err := x86MULXProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func (form x86MULXForm) needsNativeProof(ins Instr, arch string) bool {
+	_, static := x86SBMemoryAddressRole(form.source, arch)
+	frameSource := form.source.Kind == OpMem && !static &&
+		(x86LogicalSourceFrameRegister(form.source.Mem.Base, arch) || x86LogicalSourceFrameRegister(form.source.Mem.Index, arch))
+	return !x86ResultNamedPredicateInstruction(ins) || x86RegisterAddressedNativeMemoryOperand(form.source, arch) ||
+		frameSource || x86LogicalSourceFrameRegister(form.low.Reg, arch) || x86LogicalSourceFrameRegister(form.high.Reg, arch)
+}
+
+func x86LoweredMULXResultStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86MULXProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawMULXSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	if !x86RegisterAddressedNativeMemoryOperand(form.source, arch) {
+		next := state.clone()
+		next.loweredStaticReads, next.goReadOnlyRead = state.loweredStaticReads, state.goReadOnlyRead
+		if x86ResultTransfer(local, &next, owned, resultOffset, arch) {
+			*state = next
+			return true, true
+		}
+		if form.needsNativeProof(ins, arch) {
+			return false, true // Raw, physical-frame and native roles retain their strict input contract.
+		}
+		return x86MULXUnknownNumericalResults(local, state, owned, arch), true
+	}
+	effect, _, _ := x86TypedMULXByteEffect(local.Op, local, arch)
+	// Consume both the effective address and numerical DX before replacing
+	// either destination. An opaque DX address is not a numerical DX value.
+	for _, input := range effect.operands {
+		if input.read && !x86ResultReadWithNativeContinuation(local, input.operand, input.width, state, owned, arch, true) {
+			return false, true
+		}
+	}
+	for _, output := range effect.operands {
+		if output.write && !x86ResultStore(output.operand, output.width, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	return true, true
+}
+
+// Only the existing named, non-native, nontrapping numerical domain may
+// leave scratch products unknown. Readable storage and pointer/NUM roles remain
+// strict; both output dependencies must survive until any observable use.
+func x86MULXUnknownNumericalResults(ins Instr, state *x86ResultState, owned []bool, arch string) bool {
+	effect, known, err := x86TypedMULXByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false
+	}
+	unknown := false
+	for _, input := range effect.operands {
+		if !input.read {
+			continue
+		}
+		if input.operand.Kind != OpReg {
+			if !x86ResultRead(input.operand, input.width, state, owned, arch) {
+				return false
+			}
+			continue
+		}
+		index, mask, valid := x86ResultGP(input.operand.Reg, input.width, arch)
+		if !valid || state.pointerGP[index] {
+			return false
+		}
+		unknown = unknown || state.gp[index]&mask != mask
+	}
+	if !unknown {
+		return false // Some other strict failure must never become permission.
+	}
+	after := *state
+	for _, output := range effect.operands {
+		if !output.write {
+			continue
+		}
+		index, mask, valid := x86ResultGP(output.operand.Reg, output.width, arch)
+		if output.operand.Kind != OpReg || !valid {
+			return false
+		}
+		after.gp[index] &^= mask
+		after.canonicalGP[index] &^= mask
+		if output.width == 4 {
+			after.gp[index] |= 0xf0 // Only architectural upper32 are independently known zero.
+			if arch == "amd64" {
+				after.canonicalGP[index] |= 0xf0
+			}
+		}
+		after.pointerGP[index] = false
+	}
+	*state = after
+	return true
+}
+
+func (c *amd64Ctx) lowerMULX(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := x86MULXProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if err := c.integerEffectResultInitialized("MULX"); err != nil {
+		return true, false, err
+	}
+	return true, false, c.emitMULX(form, ins)
+}
+
+// Emission consumes already validated operands; it supplies no numerical,
+// address or entry permission. The public lowerer retains those checks above.
+func (c *amd64Ctx) emitMULX(form x86MULXForm, ins Instr) error {
+	narrow := amd64IntegerTypeForBits(form.bits)
+	wide := x86ScalarMultiplyDivideWideType(form.bits)
+	source, err := c.evalSizedNativeGPSource(form.source, narrow, ins.x86AddressBits)
+	if err != nil {
+		return err
+	}
+	dx, err := c.evalIntSized(Operand{Kind: OpReg, Reg: DX}, narrow)
+	if err != nil {
+		return err
+	}
+	lhs := c.extendX86MulDivValue(dx, narrow, wide, false)
+	rhs := c.extendX86MulDivValue(source, narrow, wide, false)
+	product, low, shifted, high := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, wide, lhs, rhs)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", low, wide, product, narrow)
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n", shifted, wide, product, form.bits)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", high, wide, shifted, narrow)
+	if err := c.storeRegSized(form.low.Reg, narrow, "%"+low); err != nil {
+		return err
+	}
+	return c.storeRegSized(form.high.Reg, narrow, "%"+high)
+}
diff --git a/amd64_mxcsr_forms.go b/amd64_mxcsr_forms.go
new file mode 100644
index 000000000..06e0aa1c5
--- /dev/null
+++ b/amd64_mxcsr_forms.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's ysvrs_mo, ysvrs_om and _yvldmxcsr rows have one m32 operand.
+// This descriptor gives no source, memory, frame or MXCSR control authority.
+func x86MXCSRProperties(ins Instr, arch string) (write, known bool, err error) {
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	switch base {
+	case "LDMXCSR", "VLDMXCSR":
+	case "STMXCSR", "VSTMXCSR":
+		write = true
+	default:
+		return false, false, nil
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 1 ||
+		!isAMD64MemoryOperand(ins.Args[0]) || !x86PackedShiftMemoryValid(ins.Args[0], arch) {
+		return write, true, fmt.Errorf("%s %s expects one Go m32 operand without suffixes: %q", arch, ins.Op, ins.Raw)
+	}
+	return write, true, nil
+}
+
+func x86TypedMXCSRByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		if _, known, _ := x86MXCSRProperties(Instr{Op: op}, arch); known {
+			return x86TypedByteEffect{}, true, fmt.Errorf("MXCSR effect/source identity differs: %s/%s", op, ins.Op)
+		}
+		return x86TypedByteEffect{}, false, nil
+	}
+	ins.Op = op
+	write, known, err := x86MXCSRProperties(ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: 4, read: !write, write: write},
+	}}, true, nil // All six integer status bits and DF are unaffected.
+}
diff --git a/amd64_mxcsr_forms_test.go b/amd64_mxcsr_forms_test.go
new file mode 100644
index 000000000..3f6c7ec7a
--- /dev/null
+++ b/amd64_mxcsr_forms_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MXCSRCompleteOriginalGoRows(t *testing.T) {
+	for name, rows := range map[string][]string{
+		"asm6.go": {
+			"{ALDMXCSR, ysvrs_mo, Pm, opBytes{0xae, 02, 0xae, 02}}",
+			"{ASTMXCSR, ysvrs_om, Pm, opBytes{0xae, 03, 0xae, 03}}",
+			"var ysvrs_mo = []ytab{\n\t{Zm_o, 2, argList{Ym}},\n}",
+			"var ysvrs_om = []ytab{\n\t{Zo_m, 2, argList{Ym}},\n}",
+		},
+		"avx_optabs.go": {
+			"var _yvldmxcsr = []ytab{\n\t{zcase: Zvex_rm_v_ro, zoffset: 3, args: argList{Ym}},\n}",
+			"{as: AVLDMXCSR, ytab: _yvldmxcsr, prefix: Pavx, op: opBytes{\n\t\tavxEscape | vex128 | vex0F | vexW0, 0xAE, 02,\n\t}}",
+			"{as: AVSTMXCSR, ytab: _yvldmxcsr, prefix: Pavx, op: opBytes{\n\t\tavxEscape | vex128 | vex0F | vexW0, 0xAE, 03,\n\t}}",
+		},
+	} {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, row := range rows {
+			if strings.Count(string(data), row) != 1 {
+				t.Fatal("complete actual MXCSR operand/encoder row changed", name, row)
+			}
+		}
+	}
+}
+
+func TestX86MXCSRByteEffectHasNoIndependentMemoryAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+			for _, operand := range []string{"(DI)", "private<>(SB)", "0(SP)"} {
+				ins := x86ScalarLaneInstruction(t, op+" "+operand)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+				state.gp[7], state.pointerGP[7] = 0xff, true
+				if x86ResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("an m32 descriptor granted pointee, private data or physical stack bytes", arch, op, operand)
+				}
+			}
+			ins := x86ScalarLaneInstruction(t, op+" result+0(FP)")
+			for missing := -1; missing < 4; missing++ {
+				state := x86ResultState{fp: []bool{true, true, true, true}, flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+				if missing >= 0 {
+					state.fp[missing] = false
+				}
+				write := strings.Contains(op, "STMXCSR")
+				if got := x86ResultTransfer(ins, &state, []bool{true, true, true, true}, 0, arch); got != (write || missing < 0) {
+					t.Fatal("MXCSR load skipped an input byte or store read its old bytes", arch, op, missing, got)
+				}
+				if state.flags != x86ByteFlagsAll || state.direction != x86ResultDirectionForward {
+					t.Fatal("MXCSR changed integer status or direction knowledge")
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_mxcsr_native_pointer_test.go b/amd64_mxcsr_native_pointer_test.go
new file mode 100644
index 000000000..81d413c6f
--- /dev/null
+++ b/amd64_mxcsr_native_pointer_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NativeMXCSRPointerFamilyFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+				for _, result := range []bool{false, true} {
+					name, args := fmt.Sprintf("%s%v", op, result), word
+					declaration, finish := "", ""
+					if result {
+						declaration, args = " uint32", word+4
+						finish = fmt.Sprintf("MOVL $7,ret+%d(FP)\n", word)
+					}
+					fmt.Fprintf(&declarations, "func %s(p *[8]byte)%s\n", name, declaration)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s 1(AX)\n%sRET\n",
+						name, args, move, op, finish)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete original native m32 control operations lost their paired emitter", api, err)
+				}
+				for _, op := range []string{"ldmxcsr", "vldmxcsr", "stmxcsr", "vstmxcsr"} {
+					if strings.Count(ir, "asm sideeffect \""+op+" $0\"") != 2 {
+						t.Fatal("original native opcode/fault identity was not retained", api, op)
+					}
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86NativeMXCSRPointerFamilyRetainsCompleteInputObligation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple, word := "MOVL", "i386-unknown-linux-gnu", 4
+		if arch == "amd64" {
+			move, triple, word = "MOVQ", "x86_64-unknown-linux-gnu", 8
+		}
+		for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+			for _, body := range []string{
+				op + " (AX)",
+				"MOVW p+0(FP),AX\n" + op + " (AX)",
+				move + " p+0(FP),AX\n" + op + " (AX)(CX*1)",
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+op+"/"+body+"/"+api, func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·State(SB),4,$0-%d\n%s\nRET\n", word, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func State(p *uint32)", arch, triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("native MXCSR operation borrowed undefined address/index bytes", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LockRuntimeCompleteSourcesTranslateAllAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		declarations, source, _, _, count := x86LockScalarRuntimeFixture(arch)
+		want, triple := 174, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			want, triple = 129, "i386-unknown-linux-gnu"
+		}
+		if count != want {
+			t.Fatal("complete native LOCK source denominator changed", count)
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				if _, err := x86OrderingHintTranslateAPI(t, api, source, declarations, arch, triple); err != nil {
+					t.Fatal("original complete native LOCK source rejected", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LockRuntimeSavedStatusNeedsOriginalSourceRefinement(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		declarations, source, _, _, count := x86LockScalarRuntimeFixture(arch)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil || len(file.Funcs) != count {
+			t.Fatal("complete original LOCK observation inventory changed", err)
+		}
+		rows := x86LockScalarRuntimeCases(arch)
+		for index, function := range file.Funcs {
+			observations := 0
+			for offset, ins := range function.Instrs {
+				if ins.Op != "PUSHFQ" && ins.Op != "PUSHFL" {
+					continue
+				}
+				if offset+2 >= len(function.Instrs) {
+					t.Fatal("saved status has no complete following refinement")
+				}
+				mask := function.Instrs[offset+2]
+				if (mask.Op != "ANDQ" && mask.Op != "ANDL") || len(mask.Args) != 2 ||
+					mask.Args[0].Kind != OpImm || mask.Args[0].Imm != int64(x86ScalarRuntimeStatusMask(rows[index].stem)) ||
+					mask.Args[1].Kind != OpReg || mask.Args[1].Reg != AX {
+					t.Fatal("LOCK status output borrowed undefined architecture bits", function.Sym, mask)
+				}
+				observations++
+			}
+			if observations != 1 {
+				t.Fatal("complete LOCK kernel lost its one saved-status observation", function.Sym)
+			}
+		}
+		// Preserve the original complete source as a negative control. Logical
+		// and bit-string status bits cannot be materialized merely because a
+		// separate reference would discard them later.
+		original := source
+		for _, mask := range []int{0x41, 0x8c5, 0x8d5} {
+			for _, suffix := range []string{"L", "Q"} {
+				original = strings.ReplaceAll(original, fmt.Sprintf("AND%s $%d,AX\n", suffix, mask), "")
+			}
+		}
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, original, declarations, arch, triple)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("the original unrefined LOCK source gained undefined numerical bits", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_mxcsr_source_roles_objects_test.go b/amd64_mxcsr_source_roles_objects_test.go
new file mode 100644
index 000000000..107f29f46
--- /dev/null
+++ b/amd64_mxcsr_source_roles_objects_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MXCSRBoundMemoryFormsOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range x86MXCSRBoundMemoryForms(t, target.arch) {
+				name := fmt.Sprintf("mxcsrBound%d", index)
+				original := strings.Replace(row.source, "·view(SB)", "·"+name+"(SB)", 1)
+				// Each whole original function retains its own DATA definition,
+				// without overlapping another function's control word.
+				original = strings.ReplaceAll(original, "control<>", fmt.Sprintf("control%d<>", index))
+				source.WriteString(original)
+				declarations.WriteString(strings.Replace(row.declaration, "func view(", "func "+name+"(", 1))
+				declarations.WriteByte('\n')
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil || len(file.Funcs) != 10 || len(file.Data) != 2 || len(file.Globl) != 2 {
+				t.Fatal("complete ten-function/two-DATA original batch differs", err)
+			}
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("complete original bound MXCSR source: TEXTs=10 DATA=2 source=%x object=%x SDK=%s",
+				receipt.Source, receipt.Object, receipt.GoVersion)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || strings.Count(ir, "define ") != 10 {
+					t.Fatalf("complete typed MXCSR batch %s: %v", api, err)
+				}
+				for _, irLevel := range []string{"0", "2"} {
+					objectIR := ir
+					if irLevel == "2" {
+						objectIR = x86DwordProductIROptimize(t, ir)
+					}
+					for _, backendLevel := range []string{"0", "2"} {
+						t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, objectIR, "-O"+backendLevel)
+						})
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_mxcsr_source_roles_test.go b/amd64_mxcsr_source_roles_test.go
new file mode 100644
index 000000000..b046a9088
--- /dev/null
+++ b/amd64_mxcsr_source_roles_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+type x86MXCSRBoundMemoryForm struct {
+	name, source, declaration, intrinsic string
+	local                                bool
+}
+
+func x86MXCSRBoundMemoryForms(t *testing.T, arch string) []x86MXCSRBoundMemoryForm {
+	t.Helper()
+	const declaration = "func view(input uint32) uint32"
+	var rows []x86MXCSRBoundMemoryForm
+	for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+		write := strings.Contains(op, "STMXCSR")
+		intrinsic := "@llvm.x86.sse.ldmxcsr"
+		if write {
+			intrinsic = "@llvm.x86.sse.stmxcsr"
+		}
+		for _, role := range []string{"AUTO", "FP"} {
+			body := op + " input+0(FP)\nSTMXCSR ret+RESULT(FP)"
+			if write {
+				body = op + " ret+RESULT(FP)"
+			}
+			if role == "AUTO" {
+				body = "MOVL $0x1f80,saved-4(SP)\n" + op + " saved-4(SP)\nSTMXCSR ret+RESULT(FP)"
+				if write {
+					body = op + " saved-4(SP)\nMOVL saved-4(SP),AX\nMOVL AX,ret+RESULT(FP)"
+				}
+			}
+			source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+			if role == "AUTO" {
+				source = strings.Replace(source, ",$0-", ",$8-", 1)
+			}
+			rows = append(rows, x86MXCSRBoundMemoryForm{op + "/" + role, source, declaration, intrinsic, role == "AUTO"})
+		}
+	}
+	for _, op := range []string{"LDMXCSR", "VLDMXCSR"} {
+		const data = "DATA control<>+0(SB)/4,$0x1f80\nGLOBL control<>(SB),8,$4\n"
+		body := op + " control<>(SB)\nSTMXCSR ret+RESULT(FP)"
+		source := data + x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+		rows = append(rows, x86MXCSRBoundMemoryForm{op + "/DATA", source, declaration, "@llvm.x86.sse.ldmxcsr", false})
+	}
+	if len(rows) != 10 {
+		t.Fatal("complete independent MXCSR storage-role denominator changed")
+	}
+	return rows
+}
+
+// Preserve the exact former mixed-syntax source. Neither its zero frame,
+// undefined GP inputs nor external SB symbol supplies initialized storage.
+const x86MXCSRUnboundOriginalSource = `
+TEXT mxcsrstateforms(SB),NOSPLIT,$0-8
+	LDMXCSR (AX)
+	LDMXCSR -8(SP)
+	LDMXCSR control(SB)
+	LDMXCSR input+0(FP)
+	VLDMXCSR (AX)
+	VLDMXCSR control(SB)
+	STMXCSR 4(BX)
+	STMXCSR -8(SP)
+	STMXCSR control(SB)
+	STMXCSR output+4(FP)
+	VSTMXCSR (AX)
+	VSTMXCSR output+4(FP)
+	RET
+`
+
+func TestTranslateAMD64MXCSRStateOriginalUnboundSourceRetainsContext(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86MXCSRUnboundOriginalSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{TargetTriple: "x86_64-unknown-linux-gnu", Goarch: "amd64",
+		Sigs: map[string]FuncSig{"mxcsrstateforms": {
+			Name: "mxcsrstateforms", Args: []LLVMType{I32}, Ret: I32,
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+			},
+		}},
+	}
+	if ir, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatalf("original unbound mixed source acquired frame/native memory: %v", err)
+	}
+}
+
+func TestX86MXCSRStorageRolesCannotBorrowSyntaxAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+			write := strings.Contains(op, "STMXCSR")
+			rows := []struct{ name, declaration, body, data string }{
+				{"unbound GP", "func view() uint32", op + " (AX)\nMOVL $7,ret+RESULT(FP)", ""},
+				{"overwritten typed native pointer", "func view(p *[2]uint32) uint32", move + " p+0(FP),AX\nMOVW $0,AX\n" + op + " 4(AX)\nMOVL $7,ret+RESULT(FP)", ""},
+				{"undefined SB", "func view() uint32", op + " control(SB)\nMOVL $7,ret+RESULT(FP)", ""},
+			}
+			if write {
+				rows = append(rows, struct{ name, declaration, body, data string }{
+					"defined mutable DATA store", "func view() uint32", op + " control<>+4(SB)\nMOVL $7,ret+RESULT(FP)",
+					"DATA control<>+0(SB)/4,$0x1f80\nGLOBL control<>(SB),0,$8\n",
+				})
+			} else {
+				rows = append(rows, struct{ name, declaration, body, data string }{
+					"insufficient emitted DATA", "func view() uint32", op + " control<>(SB)\nSTMXCSR ret+RESULT(FP)",
+					"GLOBL control<>(SB),8,$3\n",
+				})
+			}
+			for _, row := range rows {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+op+"/"+row.name+"/"+api, func(t *testing.T) {
+						source := row.data + x86ResultGPSIMDAdmissionSource(t, arch, row.declaration, row.body)
+						if ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("MXCSR operand syntax granted an unclosed storage role: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_named_half_forms.go b/amd64_named_half_forms.go
new file mode 100644
index 000000000..ef37ea4d7
--- /dev/null
+++ b/amd64_named_half_forms.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+type x86RawNamedHalfEncoding uint8
+
+const (
+	x86RawNamedHalfAbsent x86RawNamedHalfEncoding = iota
+	x86RawNamedHalfVEX
+	x86RawNamedHalfEVEX
+)
+
+// Active input/output bytes differ from both physical register carriers.
+// Immediate-first narrowing also writes memory; it is not a source-memory
+// conversion with its operands reversed after permissions have been granted.
+type x86NamedHalfForm struct {
+	narrow, evex, sae, zeroing                                    bool
+	source, destination, mask, memory                             int
+	lanes, sourceBytes, destinationBytes, inputBytes, outputBytes int
+	immediate                                                     byte
+	conversion                                                    x86PackedConversionForm
+}
+
+func (f x86NamedHalfForm) undefinedOpcode() bool {
+	return f.narrow && f.memory == f.destination && f.zeroing
+}
+
+func x86NamedHalfProperties(op Op, ins Instr, arch string) (x86NamedHalfForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if base != "VCVTPH2PS" && base != "VCVTPS2PH" {
+		return x86NamedHalfForm{}, false, nil
+	}
+	f := x86NamedHalfForm{narrow: base == "VCVTPS2PH", destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86NamedHalfForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete named half conversion grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	properties, err := parseAMD64HalfConversionSuffix(strings.ToUpper(string(op)), base)
+	if err != nil {
+		return f, true, err
+	}
+	f.sae, f.zeroing = properties.sae, properties.zeroing
+	ins.Op = op
+	count := 2
+	if f.narrow {
+		f.source, count = 1, 3
+	}
+	if len(ins.Args) != count && len(ins.Args) != count+1 {
+		return fail()
+	}
+	if len(ins.Args) == count+1 {
+		f.mask = count - 1
+		if !amd64NonzeroKOperand(ins.Args[f.mask]) || f.narrow && arch == "386" && ins.x86NamedHalfEncoding == x86RawNamedHalfAbsent {
+			return fail()
+		}
+	} else if f.zeroing {
+		return fail()
+	}
+	source, destination := ins.Args[f.source], ins.Args[f.destination]
+	width := amd64VectorByteWidth(destination.Reg)
+	if f.narrow {
+		width = amd64VectorByteWidth(source.Reg)
+	}
+	if width != 16 && width != 32 && width != 64 {
+		return fail()
+	}
+	f.lanes = width / 4
+	f.inputBytes, f.outputBytes = width/2, width
+	f.sourceBytes, f.destinationBytes = 16, width
+	if width == 64 {
+		f.sourceBytes = 32
+	}
+	if f.narrow {
+		f.inputBytes, f.outputBytes = width, width/2
+		f.sourceBytes, f.destinationBytes = width, 16
+		if width == 64 {
+			f.destinationBytes = 32
+		}
+		immediate, valid := x86ImmediateShuffleConstant(ins.Args[0], arch,
+			ins.x86NamedHalfEncoding != x86RawNamedHalfAbsent)
+		if !valid || immediate.Imm < -128 || immediate.Imm > 255 {
+			return fail()
+		}
+		f.immediate = byte(immediate.Imm)
+	}
+	register := func(arg Operand, bytes int) bool {
+		return arg.Kind == OpReg && amd64EVEXVectorRegister(arg, bytes)
+	}
+	if !register(source, f.sourceBytes) {
+		if f.narrow || !isAMD64MemoryOperand(source) || !x86PackedShiftMemoryValid(source, arch) {
+			return fail()
+		}
+		f.memory = f.source
+	}
+	if !register(destination, f.destinationBytes) {
+		if !f.narrow || !isAMD64MemoryOperand(destination) || !x86PackedShiftMemoryValid(destination, arch) {
+			return fail()
+		}
+		f.memory = f.destination
+	}
+	if f.sae && (width != 64 || f.memory >= 0) {
+		return fail() // Go's asmevex rejects SAE on either memory ModRM role.
+	}
+	f.evex = ins.x86NamedHalfEncoding == x86RawNamedHalfEVEX || width == 64 || f.mask >= 0 || f.sae ||
+		amd64HalfConversionHighRegister(source) || amd64HalfConversionHighRegister(destination)
+	if f.narrow && f.evex {
+		immediate, _ := x86ImmediateShuffleConstant(ins.Args[0], arch,
+			ins.x86NamedHalfEncoding != x86RawNamedHalfAbsent)
+		if immediate.Imm < 0 {
+			return fail()
+		}
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return f, true, err
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return f, true, fmt.Errorf("%w: %s needs its original default address mode", ErrProbeNeedsContext, op)
+	}
+	// Share active lane/carrier input rules, not a namespace or source role.
+	f.conversion = x86PackedConversionForm{
+		spec: x86PackedConversionSpec{amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+			sourceBits: 16, destinationBits: 32}},
+		shape:      amd64PackedNumericShape{sourceBytes: f.sourceBytes, destinationBytes: f.destinationBytes, lanes: f.lanes},
+		properties: amd64BinaryFloatingSuffix{zeroing: f.zeroing, sae: f.sae},
+		inputBytes: f.inputBytes, destination: f.destination - f.source, mask: -1, memory: -1, evex: f.evex,
+	}
+	if f.narrow {
+		f.conversion.spec.sourceBits, f.conversion.spec.destinationBits = 32, 16
+	}
+	if f.mask >= 0 {
+		f.conversion.mask = f.mask - f.source
+	}
+	if f.memory == f.source {
+		f.conversion.memory, f.conversion.memoryBytes = 0, f.inputBytes
+	}
+	return f, true, nil
+}
+
+func x86TypedNamedHalfByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86NamedHalfProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if f.undefinedOpcode() {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: half EVEX.z memory encoding has no ordinary byte continuation", ErrProbeNeedsContext)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: f.source, operand: ins.Args[f.source], width: int64(f.inputBytes), read: true},
+		{index: f.destination, operand: ins.Args[f.destination], width: int64(f.outputBytes),
+			read: f.mask >= 0 && !f.zeroing && f.memory != f.destination, write: true},
+	}}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
+
+func validateX86NamedHalfFile(file *File, opt Options) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	var pending error
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			_, known, err := x86NamedHalfProperties(ins.Op, ins, opt.Goarch)
+			if !known {
+				continue
+			}
+			if err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			if err == nil && !x86ScalarFloatIntegerNativeTarget(opt.Goarch, opt.TargetTriple) {
+				err = fmt.Errorf("%w: %s needs its matching native x86 MXCSR target", ErrProbeNeedsContext, ins.Op)
+			}
+			if pending == nil && err != nil {
+				pending = fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+		}
+	}
+	return pending
+}
diff --git a/amd64_named_half_native.go b/amd64_named_half_native.go
new file mode 100644
index 000000000..5071aaeed
--- /dev/null
+++ b/amd64_named_half_native.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerNamedHalfConversion(op Op, ins Instr) (bool, bool, error) {
+	f, known, err := x86NamedHalfProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	ins.Op = op
+	if f.undefinedOpcode() {
+		return c.lowerX86UndefinedTrap("UD2", Instr{Op: "UD2"})
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: %s needs its matching native x86 MXCSR target", ErrProbeNeedsContext, op)
+	}
+	if c.fpScalarSource.x86SourceStack != nil || c.fpScalarSource.x86FixedLocal != nil {
+		return true, false, fmt.Errorf("%w: %s retains its independent frame/native source owner", ErrProbeNeedsContext, op)
+	}
+	if f.memory >= 0 {
+		memory := ins.Args[f.memory]
+		if memory.Kind == OpFP && f.memory == f.source {
+			if err := c.validateX86PackedShiftFPSpan(memory.FPOffset, f.inputBytes); err != nil {
+				return true, false, err
+			}
+			for at := memory.FPOffset; at < memory.FPOffset+int64(f.inputBytes); at++ {
+				if slot, _, _ := c.fpVectorSlot(at); slot.Type == Ptr {
+					return true, false, fmt.Errorf("%w: %s cannot convert opaque pointer bits", ErrProbeNeedsContext, op)
+				}
+			}
+		} else if !c.nativeMemoryOperand(ins, f.memory) {
+			return true, false, fmt.Errorf("%w: %s requires its original native address", ErrProbeNeedsContext, op)
+		}
+	}
+	if f.memory == f.destination {
+		return true, false, c.emitNamedHalfNativeStore(ins, f)
+	}
+	base, _, _ := strings.Cut(strings.ToLower(string(op)), ".")
+	var immediate *byte
+	if f.narrow {
+		immediate = &f.immediate
+	}
+	return true, false, c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: f.destinationBytes, sourceBytes: f.sourceBytes, memoryBytes: f.inputBytes,
+		outputBits: 32, logicalFPBits: 16, lanes: f.lanes, source: f.source,
+		destination: f.destination, mask: f.mask, evex: f.evex, zeroing: f.zeroing, sae: f.sae,
+		mnemonic: base, immediate: immediate,
+	})
+}
+
+// Narrowing's masked memory opcode is the actual write. A register conversion
+// followed by an ordinary store loses inactive-lane faults, FP traps and dead
+// effects; an indirect inline-asm output retains all three without metadata.
+func (c *amd64Ctx) emitNamedHalfNativeStore(ins Instr, f x86NamedHalfForm) error {
+	value, err := c.loadPackedCompareBytes(ins.Args[f.source], f.sourceBytes)
+	if err != nil {
+		return err
+	}
+	input := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x float>\n", input, f.sourceBytes, value, f.sourceBytes/4)
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(ins.Args[f.destination])
+	if err != nil {
+		return err
+	}
+	output := "$0"
+	if pointerType == "ptr addrspace(256)" {
+		output = "%gs:" + output
+	}
+	if pointerType == "ptr addrspace(257)" {
+		output = "%fs:" + output
+	}
+	constraint, mnemonic := "x", "vcvtps2ph"
+	if f.evex {
+		constraint, mnemonic = "v", "{evex} "+mnemonic
+	}
+	constraints := "=*m," + constraint
+	arguments := fmt.Sprintf("%s elementtype([%d x i8]) %s, <%d x float> %%%s",
+		pointerType, f.outputBytes, pointer, f.sourceBytes/4, input)
+	assembly, prefix := fmt.Sprintf("%s $$%d, $1, %s", mnemonic, f.immediate, output), ""
+	if f.mask >= 0 {
+		mask, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return err
+		}
+		prefix = "kmovw ${2:k}, %k1; "
+		constraints += ",r,~{k1}"
+		arguments += ", i32 " + c.approximateMathMask32(mask)
+		assembly += " {%k1}"
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n", prefix+assembly, constraints+",~{memory},~{fpsr}", arguments)
+	return nil
+}
diff --git a/amd64_named_lock_prefix.go b/amd64_named_lock_prefix.go
new file mode 100644
index 000000000..defc12ef3
--- /dev/null
+++ b/amd64_named_lock_prefix.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) namedLockPrefixBinding(block, instruction int, prefix Instr) error {
+	context := func(reason string) error {
+		return fmt.Errorf("%w: %s named LOCK needs a complete source-adjacent atomic operation: %s", ErrProbeNeedsContext, c.goarch, reason)
+	}
+	if prefix.Op != "LOCK" || len(prefix.Args) != 0 {
+		return context("the prefix is not its exact zero-operand form")
+	}
+	if block < 0 || block >= len(c.blocks) || instruction < 0 || instruction+1 >= len(c.blocks[block].instrs) {
+		return context("the body is missing or separated by a source/CFG boundary")
+	}
+	body := c.blocks[block].instrs[instruction+1]
+	op := Op(strings.ToUpper(string(body.Op)))
+	if form, recognized, err := x86LockScalarRMWProperties(op, body, c.goarch); recognized {
+		if err != nil {
+			return err
+		}
+		return x86LockScalarNativeMemoryBound(form, body, c.goarch)
+	}
+	if form, recognized, err := x86CompareExchangeProperties(op, body, c.goarch); recognized {
+		if err != nil {
+			return err
+		}
+		if form.destination.Kind != OpMem && form.destination.Kind != OpSym || body.x86UnboundAddressOverride {
+			return context("the native CMPXCHG memory operand is not bound")
+		}
+		return nil
+	}
+	spec, known := amd64ExchangeSpecs[op]
+	if !known {
+		// A different RMW opcode may not inherit another family's witness.
+		return context("the whole opcode effect is not independently closed")
+	}
+	form, err := parseAMD64ExchangeForm(c.goarch, op, spec, body)
+	if err != nil {
+		return context("the complete exchange operand grammar is not bound")
+	}
+	if form.other.Kind != OpMem && form.other.Kind != OpSym || body.x86UnboundAddressOverride {
+		return context("the native memory operand is not bound")
+	}
+	if c.goarch == "386" && spec.bits == 8 {
+		// Go synthesizes unavailable byte-register views through another GP
+		// register. LOCK must not bind the first instruction of that expansion
+		// as though it were the final byte memory RMW.
+		switch form.register.Reg {
+		case AX, BX, CX, DX, AL, AH, BL, BH, CL, CH, DL, DH:
+		default:
+			return context("the source byte-register view needs a Go encoder expansion")
+		}
+	}
+	// These existing memory lowerers emit a complete native XADD with LOCK or
+	// an implicitly locked XCHG, with read/write memory constraints, no guessed
+	// alignment and their unchanged byte/flags effects. Address, initialization,
+	// frame and caller permissions still come from the ordinary consumers.
+	return nil
+}
+
+func (c *amd64Ctx) verifyNamedLockPrefixes() error {
+	for block, body := range c.blocks {
+		for instruction, prefix := range body.instrs {
+			if !strings.EqualFold(string(prefix.Op), "LOCK") {
+				continue
+			}
+			if err := c.namedLockPrefixBinding(block, instruction, prefix); err != nil {
+				return err
+			}
+		}
+	}
+	return c.verifyNamedLockCarry()
+}
diff --git a/amd64_named_lock_prefix_test.go b/amd64_named_lock_prefix_test.go
new file mode 100644
index 000000000..dbae44524
--- /dev/null
+++ b/amd64_named_lock_prefix_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86NamedLockOracleForm struct {
+	text   string
+	atomic string
+}
+
+// This independent inventory follows Intel's nineteen LOCK RMW opcode stems.
+// A nonempty atomic field describes an existing lowerer's emitted operation,
+// not a memory, caller or source initialization permission.
+func x86NamedLockOracleForms(arch string) []x86NamedLockOracleForm {
+	widths := "BWL"
+	if arch == "amd64" {
+		widths += "Q"
+	}
+	var forms []x86NamedLockOracleForm
+	for _, stem := range []string{"ADD", "ADC", "AND", "OR", "SBB", "SUB", "XOR", "CMPXCHG", "XADD", "XCHG"} {
+		for _, width := range widths {
+			register := "CX"
+			if width == 'B' {
+				register = "CL"
+			}
+			atomic := ""
+			switch stem {
+			case "CMPXCHG":
+				atomic = "asm sideeffect \"lock; cmpxchg" + strings.ToLower(string(width))
+			case "XADD":
+				atomic = "lock; xadd"
+			case "XCHG":
+				atomic = "asm sideeffect \"xchg"
+			default:
+				atomic = "lock; " + strings.ToLower(stem+string(width))
+			}
+			forms = append(forms, x86NamedLockOracleForm{fmt.Sprintf("%s%c %s,(SI)", stem, width, register), atomic})
+		}
+	}
+	for _, stem := range []string{"INC", "DEC", "NEG", "NOT"} {
+		for _, width := range widths {
+			forms = append(forms, x86NamedLockOracleForm{
+				text: fmt.Sprintf("%s%c (SI)", stem, width), atomic: "lock; " + strings.ToLower(stem+string(width)),
+			})
+		}
+	}
+	for _, stem := range []string{"BTC", "BTR", "BTS"} {
+		for _, width := range strings.TrimPrefix(widths, "B") {
+			forms = append(forms, x86NamedLockOracleForm{
+				text: fmt.Sprintf("%s%c CX,(SI)", stem, width), atomic: "lock; " + strings.ToLower(stem+string(width)),
+			})
+		}
+	}
+	forms = append(forms, x86NamedLockOracleForm{text: "CMPXCHG8B (SI)", atomic: "asm sideeffect \"lock; cmpxchg8b"})
+	if arch == "amd64" {
+		forms = append(forms, x86NamedLockOracleForm{text: "CMPXCHG16B (SI)", atomic: "asm sideeffect \"lock; cmpxchg16b"})
+	}
+	return forms
+}
+
+func x86NamedLockOracleSource(arch, body string) string {
+	load, args := "MOVL", 4
+	if arch == "amd64" {
+		load, args = "MOVQ", 8
+	}
+	return fmt.Sprintf(`TEXT ·locked(SB),4,$0-%d
+	%s p+0(FP),SI
+	MOVL $2,AX
+	MOVL $3,BX
+	MOVL $4,CX
+	MOVL $5,DX
+	%s
+	RET
+`, args, load, body)
+}
+
+func TestX86NamedLockCompleteRMWRequiresWholeAtomicBinding(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		forms := x86NamedLockOracleForms(target.arch)
+		want := 49
+		if target.arch == "amd64" {
+			want = 67
+		}
+		if len(forms) != want {
+			t.Fatal("complete LOCK stem/width denominator changed", target.arch, len(forms))
+		}
+		for _, form := range forms {
+			t.Run(target.triple+"/"+form.text, func(t *testing.T) {
+				source := x86NamedLockOracleSource(target.arch, "CMPL AX,AX\n\tLOCK\n\t"+form.text)
+				actual := x86OrderingHintGoBytes(t, target.arch, source)
+				if !strings.Contains(string(actual), string([]byte{0xf0})) {
+					t.Fatalf("actual Go object lost named LOCK prefix: %x", actual)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc locked(p *[16]byte)\n", target.arch, target.triple)
+						if form.atomic == "" {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("actual Go LOCK RMW silently became a non-atomic operation: error=%v atomicrmw=%v cmpxchg=%v nativeLock=%v", err,
+									strings.Contains(ir, "atomicrmw "), strings.Contains(ir, " = cmpxchg "), strings.Contains(ir, "lock;"))
+							}
+							return
+						}
+						if err != nil || !strings.Contains(ir, form.atomic) {
+							t.Fatalf("existing whole atomic operation changed: %v, required emission=%q", err, form.atomic)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86NamedLockDetachedAndSplitPrefixDoesNotBorrowAtomicBody(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, body := range []string{
+			"LOCK",
+			"LOCK\n\tLOCK\n\tXADDL CX,(SI)",
+			"LOCK\nbody:\n\tXADDL CX,(SI)",
+			"LOCK\n\tCMPL CX,(SI)",
+			"LOCK\n\tNOP\n\tXADDL CX,(SI)",
+		} {
+			t.Run(arch+"/"+body, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, "text", x86NamedLockOracleSource(arch, body),
+					"package ordering\nfunc locked(p *[16]byte)\n", arch, testTargetTriple("linux", arch))
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("unbound or split prefix borrowed a following operation", err)
+				}
+			})
+		}
+	}
+	ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+	before := output.String()
+	known, terminated, err := ctx.lowerAtomic("LOCK", Instr{Op: "LOCK", Raw: "LOCK"})
+	if !known || terminated || !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+		t.Fatal("standalone helper has no complete ordered instruction to bind", known, terminated, err)
+	}
+}
diff --git a/amd64_named_stack_expression_test.go b/amd64_named_stack_expression_test.go
new file mode 100644
index 000000000..19c7699c0
--- /dev/null
+++ b/amd64_named_stack_expression_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestAMD64NamedStackConstantExpressions(t *testing.T) {
+	const source = `TEXT namedStackExpressions(SB),$64-0
+	MOVL AX, tmpdig-(0*4)(SP)
+	MOVL BX, tmpdig-(1*4)(SP)
+	ADDL tmpdig-(0*4)(SP), AX
+	ADDL tmpdig-(1*4)(SP), BX
+	RET
+`
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Instrs[1].Args[1]; got.Kind != OpMem || got.Mem.Off != 0 {
+		t.Fatalf("first named stack slot parsed as %+v, want offset 0 memory", got)
+	}
+	if got := file.Funcs[0].Instrs[2].Args[1]; got.Kind != OpMem || got.Mem.Off != -4 {
+		t.Fatalf("second named stack slot parsed as %+v, want offset -4 memory", got)
+	}
+	// These original operands establish constant-expression grammar only.
+	// AX/BX have no inputs, and NAME_AUTO offset zero is not a logical
+	// four-byte local within [-64,-4]. Keep the complete source as Context.
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("unbound/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func namedStackExpressions()",
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original grammar supplied entry NUM or native frame storage", err)
+			}
+		})
+	}
+
+	// Preserve the four exact operations and their original offsets. The
+	// actual source-bound frame and temporary SP relocation put their reads
+	// and writes inside the 64-byte local; both input values are initialized.
+	const initialized = `TEXT ·namedStackExpressions(SB),4,$64-24
+	MOVQ a+0(FP), AX
+	MOVQ b+8(FP), BX
+	MOVQ SP, R11
+	ADDQ $-16, SP
+	MOVL AX, tmpdig-(0*4)(SP)
+	MOVL BX, tmpdig-(1*4)(SP)
+	ADDL tmpdig-(0*4)(SP), AX
+	ADDL tmpdig-(1*4)(SP), BX
+	MOVQ R11, SP
+	ADDQ BX, AX
+	MOVQ AX, ret+16(FP)
+	RET
+`
+	x86StackExpressionBoundObjects(t, initialized, "func namedStackExpressions(a,b uint64) uint64")
+}
+
+// Observe actual complete Go sources for each API, then compile their emitted
+// IR at both optimization levels. A previous API cannot extend the source lease.
+func x86StackExpressionBoundObjects(t *testing.T, source, declaration string) {
+	t.Helper()
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("initialized-without-binding/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration,
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("initialized source spelling supplied native frame authority", err)
+			}
+		})
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run("bound/"+goos, func(t *testing.T) {
+			triple := testTargetTriple(goos, "amd64")
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, source, declaration, goos+"/amd64", triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "fixed_local_native") {
+					t.Fatal("initialized exact expression lost its source-bound local frame", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		})
+	}
+}
+
+func TestNamedStackConstantOffsetRejectsUnresolvedExpressions(t *testing.T) {
+	for _, tc := range []struct {
+		prefix string
+		want   int64
+		ok     bool
+	}{
+		{prefix: "tmpdig-(7*4)", want: -28, ok: true},
+		{prefix: "tmpdig+(2<<3)", want: 16, ok: true},
+		{prefix: "tmpdig-(unknown*4)"},
+		{prefix: "tmpdig-(4/0)"},
+		{prefix: "tmp-dig-(1*4)"},
+	} {
+		got, ok := parseNamedStackConstantOffset(tc.prefix)
+		if ok != tc.ok || ok && got != tc.want {
+			t.Errorf("parseNamedStackConstantOffset(%q) = %d, %v; want %d, %v", tc.prefix, got, ok, tc.want, tc.ok)
+		}
+	}
+}
diff --git a/amd64_native_avx512_qualification_linux_amd64_test.go b/amd64_native_avx512_qualification_linux_amd64_test.go
new file mode 100644
index 000000000..33e25676c
--- /dev/null
+++ b/amd64_native_avx512_qualification_linux_amd64_test.go
@@ -0,0 +1,82 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import (
+	"os"
+	"testing"
+)
+
+// Explicit hardware qualification retains the original complete fixtures.
+// An absent CPU feature is fatal in each original preflight, never a skip.
+func x86RequireNativeAVX512Qualification(t *testing.T) {
+	t.Helper()
+	if mode := os.Getenv("PLAN9ASM_AVX512_RUNTIME"); mode != "" && mode != "required" {
+		t.Fatalf("explicit native AVX512 qualification requires required policy, got %q", mode)
+	}
+}
+
+func TestAMD64FPClassRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64FPClassRuntimeSemantics(t)
+}
+
+func TestAMD64FixupImmediateRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64FixupImmediateRuntimeSemantics(t)
+}
+
+func TestAMD64FloatingRangeDoubleAndScalarRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64FloatingRangeDoubleAndScalarRuntimeSemantics(t)
+}
+
+func TestAMD64FloatingRangeRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64FloatingRangeRuntimeSemantics(t)
+}
+
+func TestAMD64GetExpRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64GetExpRuntimeSemantics(t)
+}
+
+func TestAMD64GetMantRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64GetMantRuntimeSemantics(t)
+}
+
+func TestAMD64PackedAbsSignRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64PackedAbsSignRuntimeSemantics(t)
+}
+
+func TestAMD64ScalarIntegerFloatRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64ScalarIntegerFloatRuntimeSemantics(t)
+}
+
+func TestAMD64ScalarPrecisionConvertRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64ScalarPrecisionConvertRuntimeSemantics(t)
+}
+
+func TestAMD64ScalarSqrtRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64ScalarSqrtRuntimeSemantics(t)
+}
+
+func TestAMD64ScaleFRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64ScaleFRuntimeSemantics(t)
+}
+
+func TestAMD64ScaledRoundRuntimeSemantics(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyAMD64ScaledRoundRuntimeSemantics(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FMA3GoCallerNumericalFamily(t *testing.T) {
+	x86RequireNativeAVX512Qualification(t)
+	qualifyCrossLinuxRuntimeMatrixX86FMA3GoCallerNumericalFamily(t)
+}
diff --git a/amd64_native_floating_operands.go b/amd64_native_floating_operands.go
new file mode 100644
index 000000000..b390f1dfc
--- /dev/null
+++ b/amd64_native_floating_operands.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Floating families share native operand transport, not arithmetic semantics.
+// Preserve the actual opcode and memory operand so masking, rounding,
+// exceptions and dead accesses survive. Legacy SSE ties its destination.
+type x86NativeFloatingOperands struct {
+	byteWidth, lanes, memoryBytes int
+	second, destination, mask     int
+	controls                      amd64FMA3Suffix
+	sae, readDestination          bool
+	legacy                        bool
+	lowBank, forceEVEX            bool
+	logicalFPBits                 int // Explicit scalar-value projection, not native FP backing.
+}
+
+func (c *amd64Ctx) emitNativeFloatingOperands(ins Instr, f x86NativeFloatingOperands) error {
+	source := ins.Args[0]
+	logicalFP := source.Kind == OpFP && (f.logicalFPBits == 32 || f.logicalFPBits == 64)
+	if source.Kind == OpFP && !logicalFP || ins.x86AddressBits != 0 || source.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, 0) {
+		return fmt.Errorf("%w: %s needs original native backing", ErrProbeNeedsContext, ins.Op)
+	}
+	typ := fmt.Sprintf("<%d x float>", f.byteWidth/4) // Bit carrier, never arithmetic precision.
+	load := func(index int) (string, error) {
+		bytes, err := c.loadPackedCompareBytes(ins.Args[index], f.byteWidth)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, f.byteWidth, bytes, typ)
+		return "%" + value, nil
+	}
+	second, err := load(f.second)
+	if err != nil {
+		return err
+	}
+	old := "zeroinitializer"
+	if f.legacy {
+		old = second
+	} else if f.readDestination || f.mask >= 0 && !f.controls.zeroing {
+		old, err = load(f.destination)
+		if err != nil {
+			return err
+		}
+	}
+	registerConstraint := "v"
+	if f.legacy || f.lowBank {
+		registerConstraint = "x" // Legacy/VEX cannot acquire registers 16-31 from an EVEX sibling.
+	}
+	inputType, inputConstraint, inputTemplate := typ, registerConstraint, "$3"
+	var input string
+	if ins.Args[0].Kind == OpReg {
+		input, err = load(0)
+	} else if logicalFP {
+		// A declared scalar FP field supplies its exact value, not an original
+		// physical stack address. Scalar MIN/MAX ignores the other source
+		// lanes; zeros in this private carrier grant no upper-byte facts.
+		var raw string
+		raw, err = c.loadFloatBinaryFPBits(source, f.logicalFPBits)
+		if err == nil {
+			lanes := 128 / f.logicalFPBits
+			value, carrier := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n", value, lanes, f.logicalFPBits, f.logicalFPBits, raw)
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to %s\n", carrier, lanes, f.logicalFPBits, value, typ)
+			input = "%" + carrier
+		}
+	} else {
+		var pointerType string
+		input, pointerType, _, err = c.packedVectorMemoryPointer(ins.Args[0])
+		inputType = fmt.Sprintf("%s elementtype([%d x i8])", pointerType, f.memoryBytes)
+		inputConstraint = "*m"
+		if pointerType == "ptr addrspace(256)" {
+			inputTemplate = "%gs:" + inputTemplate
+		} else if pointerType == "ptr addrspace(257)" {
+			inputTemplate = "%fs:" + inputTemplate
+		}
+	}
+	if err != nil {
+		return err
+	}
+	args := fmt.Sprintf("%s %s, %s %s, %s %s", typ, old, typ, second, inputType, input)
+	constraints := "=" + registerConstraint + ",0," + registerConstraint + "," + inputConstraint
+	mnemonic, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	assembly := mnemonic + " "
+	if f.forceEVEX {
+		assembly = "{evex} " + assembly
+	}
+	if f.controls.rounding != "" {
+		assembly += "{" + strings.ToLower(strings.TrimSuffix(f.controls.rounding, "_SAE")) + "-sae}, "
+	} else if f.sae {
+		assembly += "{sae}, "
+	}
+	assembly += inputTemplate
+	if f.controls.broadcast {
+		assembly += fmt.Sprintf("{1to%d}", f.lanes)
+	}
+	if f.legacy {
+		assembly += ", $0"
+	} else {
+		assembly += ", $2, $0"
+	}
+	if f.mask >= 0 {
+		mask, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return err
+		}
+		maskMove := "kmovw"
+		if f.lanes > 16 {
+			maskMove = "kmovd"
+		}
+		assembly = maskMove + " ${4:k}, %k1; " + assembly + " {%k1}"
+		if f.controls.zeroing {
+			assembly += " {z}"
+		}
+		constraints += ",r,~{k1}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, f.byteWidth)
+	if f.legacy {
+		return c.storeLegacyPackedLogical(ins.Args[f.destination], "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[f.destination], f.byteWidth, "%"+bytes)
+}
diff --git a/amd64_native_mmx_movemask_oracle_test.go b/amd64_native_mmx_movemask_oracle_test.go
new file mode 100644
index 000000000..0062967b7
--- /dev/null
+++ b/amd64_native_mmx_movemask_oracle_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The original Go and C reference independently observe all eight sign bits,
+// r32 zero-extension, FLAGS, aliasing, exact m64 faults and real EMMS tags.
+func x86MMXMoveMaskOracleSources() (string, string, string, string) {
+	var declarations, assembly, c, goTest strings.Builder
+	declarations.WriteString("package oracle\n")
+	c.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n#include <signal.h>\n#include <sys/mman.h>\n#include <sys/wait.h>\n#include <sys/resource.h>\n#include <unistd.h>\n")
+	var names []string
+	for bank := 0; bank < 8; bank++ {
+		for _, destination := range []string{"BX", "R8"} {
+			name := fmt.Sprintf("MMXMask%d", len(names))
+			names = append(names, name)
+			fmt.Fprintf(&declarations, "func %s(p *[8]byte,out *[24]byte)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),SI\nMOVQ out+8(FP),DI\nMOVQ $-1,%s\nMOVL $0,AX\nCMPL AX,AX\nMOVQ (SI),M%d\nPMOVMSKB M%d,%s\nEMMS\nMOVQ %s,0(DI)\nSETCS AL\nMOVB AL,8(DI)\nSETPS AL\nMOVB AL,9(DI)\nSETEQ AL\nMOVB AL,10(DI)\nSETMI AL\nMOVB AL,11(DI)\nSETOS AL\nMOVB AL,12(DI)\nLAHF\nMOVB AH,13(DI)\nRET\n", name, destination, bank, bank, destination, destination)
+			fmt.Fprintf(&c, "extern void %s(const uint8_t*,uint8_t*);\n", name)
+		}
+	}
+	fmt.Fprintf(&c, "static void (*const kernels[])(const uint8_t*,uint8_t*)={%s};\n", strings.Join(names, ","))
+	c.WriteString(`
+static unsigned reference(const uint8_t *p) {
+    unsigned result=0;
+    for(unsigned i=0;i<8;i++) result|=(unsigned)(p[i]>>7)<<i;
+    return result;
+}
+static int check(unsigned k,const uint8_t *p,uint8_t *out) {
+    unsigned want=reference(p);
+    kernels[k](p,out);
+    uint64_t mask;const uint8_t flags[]={0,1,1,0,0,0x46};
+    memcpy(&mask,out,8);
+    if(mask!=want || memcmp(out+8,flags,sizeof(flags))) {
+        fprintf(stderr,"mask/FLAGS k=%u got=%llx want=%x\n",k,(unsigned long long)mask,want);
+        return 1;
+    }
+    _Alignas(16) uint8_t state[512];
+    __asm__ volatile("fxsave %0":"=m"(state));
+    if(state[4]!=0) { fprintf(stderr,"MMX tag k=%u got=%x\n",k,state[4]);return 1; }
+    return 0;
+}
+int main(void) {
+    const unsigned count=sizeof(kernels)/sizeof(kernels[0]);
+    __asm__ volatile("emms":::"memory");
+    for(unsigned k=0;k<count;k++) {
+        for(unsigned pattern=0;pattern<256;pattern++) for(unsigned low=0;low<2;low++) {
+            uint8_t input[8],before[8],out[24];
+            for(unsigned j=0;j<8;j++) input[j]=((pattern>>j)&1)*128+(low?127:0);
+            memcpy(before,input,8); memset(out,0xa5,sizeof(out));
+            if(check(k,input,out) || memcmp(input,before,8)) return 1;
+            for(unsigned j=14;j<24;j++) if(out[j]!=0xa5) return 1;
+            uint8_t alias[32];memset(alias,0xa5,sizeof(alias));memcpy(alias+1,input,8);
+            if(check(k,alias+1,alias+1) || alias[0]!=0xa5) return 1;
+            for(unsigned j=15;j<32;j++) if(alias[j]!=0xa5) return 1;
+        }
+        long page=sysconf(_SC_PAGESIZE);
+        uint8_t *mapping=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+        if(mapping==MAP_FAILED || mprotect(mapping+page,page,PROT_NONE)) return 2;
+        memset(mapping+page-8,0x80,8);uint8_t out[24];
+        if(check(k,mapping+page-8,out)) return 1;
+        for(unsigned fault=0;fault<8;fault++) {
+            const uint8_t *p=fault?mapping+page-fault:0;
+            pid_t child=fork();if(child<0)return 2;
+            if(child==0) { struct rlimit limit={0,0};setrlimit(RLIMIT_CORE,&limit);kernels[k](p,out);_exit(99); }
+            int status;if(waitpid(child,&status,0)!=child)return 2;
+            if(!WIFSIGNALED(status) || WTERMSIG(status)!=SIGSEGV) {fprintf(stderr,"missing m64 fault k=%u case=%u status=%x\n",k,fault,status);return 1;}
+        }
+        if(munmap(mapping,2*page))return 2;
+    }
+    puts("MMX_MASK kernels=16 values=8192 aliases=8192 faults=128 boundary=16 failures=0");
+    return 0;
+}
+`)
+	fmt.Fprintf(&goTest, "package oracle\nimport(\"encoding/binary\";\"os\";\"runtime/debug\";\"syscall\";\"testing\";\"unsafe\")\nvar kernels=[]func(*[8]byte,*[24]byte){%s}\n", strings.Join(names, ","))
+	goTest.WriteString(`
+func check(t *testing.T,k int,p *[8]byte,out *[24]byte) {
+    t.Helper();var want uint64
+    for i,b:=range p { want|=uint64(b>>7)<<uint(i) }
+    kernels[k](p,out)
+    if got:=binary.LittleEndian.Uint64(out[:8]);got!=want {t.Fatalf("k=%d got=%x want=%x",k,got,want)}
+    flags:=[6]byte{0,1,1,0,0,0x46};for i,want:=range flags {if out[8+i]!=want {t.Fatalf("k=%d flag=%d got=%x want=%x",k,i,out[8+i],want)}}
+}
+func TestOriginalMMXMoveMasks(t *testing.T) {
+    for k,run:=range kernels {
+        for pattern:=0;pattern<256;pattern++ {for _,low:=range []byte{0,127} {
+            var input [8]byte;var out [24]byte
+            for j:=range input {input[j]=byte((pattern>>uint(j))&1)*128+low}
+            before:=input;for j:=range out {out[j]=0xa5}
+            check(t,k,&input,&out)
+            if input!=before {t.Fatal("input changed",k)}
+            for _,b:=range out[14:] {if b!=0xa5{t.Fatal("output extent",k)}}
+            var alias [32]byte;for j:=range alias{alias[j]=0xa5};copy(alias[1:9],input[:])
+            check(t,k,(*[8]byte)(unsafe.Pointer(&alias[1])),(*[24]byte)(unsafe.Pointer(&alias[1])))
+            if alias[0]!=0xa5 {t.Fatal("alias prefix",k)}
+            for _,b:=range alias[15:] {if b!=0xa5{t.Fatal("alias suffix",k)}}
+        }}
+        page:=os.Getpagesize()
+        mapping,err:=syscall.Mmap(-1,0,2*page,syscall.PROT_READ|syscall.PROT_WRITE,syscall.MAP_PRIVATE|syscall.MAP_ANON)
+        if err!=nil {t.Fatal(err)}
+        if err:=syscall.Mprotect(mapping[page:],syscall.PROT_NONE);err!=nil{t.Fatal(err)}
+        for j:=page-8;j<page;j++{mapping[j]=0x80};var out [24]byte
+        check(t,k,(*[8]byte)(unsafe.Pointer(&mapping[page-8])),&out)
+        old:=debug.SetPanicOnFault(true)
+        for fault:=0;fault<8;fault++ {
+            var p *[8]byte;if fault!=0{p=(*[8]byte)(unsafe.Pointer(&mapping[page-fault]))}
+            caught:=func()(caught bool){defer func(){if recover()!=nil{caught=true}}();run(p,&out);return false}()
+            if !caught {t.Fatal("missing original m64 fault",k,fault)}
+        }
+        debug.SetPanicOnFault(old)
+        if err:=syscall.Munmap(mapping);err!=nil{t.Fatal(err)}
+    }
+}
+`)
+	return declarations.String(), assembly.String(), c.String(), goTest.String()
+}
+
+func TestX86NativeMMXMoveMaskRuntimeOriginalGoBuildOnly(t *testing.T) {
+	declarations, source, _, tests := x86MMXMoveMaskOracleSources()
+	x86PackedIntegerCompareOriginalGoDriver(t, declarations, source, tests, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, strings.TrimPrefix(declarations, "package oracle\n"), "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal("complete mask runtime source", err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, level)
+			}
+		})
+	}
+}
+
+func TestX86NativeMMXMoveMaskBuildOnlyUsesLinuxFaultProfile(t *testing.T) {
+	// Exercise the exact Unix fault oracle on a Windows build host profile.
+	// The parent test still runs normally; only its child target is changed.
+	t.Setenv("GOOS", "windows")
+	declarations, source, _, tests := x86MMXMoveMaskOracleSources()
+	x86PackedIntegerCompareOriginalGoDriver(t, declarations, source, tests, true)
+}
+
+func x86NativeMMXMoveMaskRuntime(t *testing.T) {
+	declarations, source, c, tests := x86MMXMoveMaskOracleSources()
+	t.Run("original-go", func(t *testing.T) { x86PackedIntegerCompareRunOriginalGo(t, declarations, source, tests) })
+	execution := x86FloatCompareExecutionTools(t)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, strings.TrimPrefix(declarations, "package oracle\n"), "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) { execution.compileAndRunLLVM(t, "mmxmask", ir, c, level) })
+			}
+		})
+	}
+}
diff --git a/amd64_native_mmx_nontemporal_test.go b/amd64_native_mmx_nontemporal_test.go
new file mode 100644
index 000000000..128a0695a
--- /dev/null
+++ b/amd64_native_mmx_nontemporal_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86NativeMMXNonTemporalFixture(arch string, register int, address string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·Store(SB),4,$0-%d\nMOVL value+0(FP),AX\n%s out+%d(FP),DI\n"+
+			"MOVL $1,DX\nMOVL AX,M%d\nMOVNTQ M%d,%s\nEMMS\nSFENCE\nRET\n",
+			word*2, move, word, register, register, address),
+		"func Store(value uint32,out *[128]byte)"
+}
+
+func TestX86NativeMMXNonTemporalCompleteObjects(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := strings.Join(strings.Fields(string(data)), "")
+	for _, expected := range []string{
+		"varymr_ml=[]ytab{{Zr_m_xm,1,argList{Ymr,Yml}},}",
+		"{AMOVNTQ,ymr_ml,Pm,opBytes{0xe7}}",
+	} {
+		if !strings.Contains(table, expected) {
+			t.Fatal("complete original Go MOVNTQ encoder row changed", expected)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			var names []string
+			for register := 0; register < 8; register++ {
+				for _, address := range []string{"0(DI)", "3(DI)(DX*2)"} {
+					source, declaration := x86NativeMMXNonTemporalFixture(target.arch, register, address)
+					name := fmt.Sprintf("Stream%d", len(names))
+					names = append(names, name)
+					assembly.WriteString(strings.ReplaceAll(source, "Store", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Store", name) + "\n")
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized complete MMX store lost its native region", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						if strings.Count(text, "movntq") != len(names) || strings.Count(text, "emms") != len(names) {
+							t.Fatal("native streaming opcode or actual tag cleanup disappeared")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NativeMMXNonTemporalCannotBorrowInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, declaration := x86NativeMMXNonTemporalFixture(arch, 0, "3(DI)(DX*2)")
+		move, word, triple := "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for name, original := range map[string]string{
+			"source": "MOVL AX,M0\n", "pointer": fmt.Sprintf("%s out+%d(FP),DI\n", move, word),
+			"index": "MOVL $1,DX\n", "tag cleanup": "EMMS\n",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				changed := strings.Replace(source, original, "", 1)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("streaming store acquired unknown data, address or physical tag state", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeMMXNonTemporalFPNeedsNativeBacking(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, triple := 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, triple = 4, "i386-unknown-linux-gnu"
+		}
+		source, declaration := x86NativeMMXNonTemporalFixture(arch, 0, fmt.Sprintf("ret+%d(FP)", word*2))
+		source = strings.Replace(source, fmt.Sprintf("$0-%d", word*2), fmt.Sprintf("$0-%d", word*2+8), 1)
+		declaration += " uint64"
+		x86LEAActualTargetGoObject(t, arch, triple, source)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("streaming FP store borrowed the emitter's private byte image", arch, api, err)
+			}
+		}
+	}
+}
diff --git a/amd64_native_mmx_objects_test.go b/amd64_native_mmx_objects_test.go
new file mode 100644
index 000000000..177659eed
--- /dev/null
+++ b/amd64_native_mmx_objects_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent operation and operand axes are checked separately from the
+// exhaustive byte-definedness matrix. Each LLVM unit has at most 64 TEXTs.
+func x86NativeMMXIntegerObjects(t *testing.T, triple, source string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	names := strings.Fields(x86NativeMMXTestIntegerNames)
+	t.Run(source, func(t *testing.T) {
+		var assembly, declarations strings.Builder
+		for index, opcode := range names {
+			name := fmt.Sprintf("mmx%d", index)
+			fmt.Fprintf(&declarations, "func %s(input *byte,a,b uint64) uint64\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-32\nMOVQ input+0(FP),AX\n", name)
+			assembly.WriteString("MOVQ a+8(FP),M0\nMOVQ b+16(FP),M1\nMOVQ b+16(FP),M3\n")
+			if opcode == "PSHUFW" {
+				fmt.Fprintf(&assembly, "%s $27,%s,M0\n", opcode, source)
+			} else {
+				fmt.Fprintf(&assembly, "%s %s,M0\n", opcode, source)
+			}
+			assembly.WriteString("MOVQ M0,ret+24(FP)\nEMMS\nRET\n")
+		}
+		x86LEAActualTargetGoObject(t, "amd64", triple, assembly.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), "amd64", triple, api)
+				if err != nil {
+					t.Fatal("complete initialized MMX family lacks its actual source-bound instruction region", err)
+				}
+				if strings.Count(ir, "asm sideeffect") != len(names) || strings.Count(ir, "emms") != len(names) {
+					t.Fatal("MMX body or physical tag continuation disappeared")
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			})
+		}
+	})
+}
+
+func TestX86NativeMMXIntegerRegisterObjectsLinuxAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-unknown-linux-gnu", "M1")
+}
+
+func TestX86NativeMMXIntegerAliasObjectsLinuxAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-unknown-linux-gnu", "BX")
+}
+
+func TestX86NativeMMXIntegerFPObjectsLinuxAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-unknown-linux-gnu", "b+16(FP)")
+}
+
+func TestX86NativeMMXIntegerMemoryObjectsLinuxAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-unknown-linux-gnu", "(AX)")
+}
+
+func TestX86NativeMMXIntegerRegisterObjectsDarwinAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-apple-darwin", "M1")
+}
+
+func TestX86NativeMMXIntegerAliasObjectsDarwinAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-apple-darwin", "BX")
+}
+
+func TestX86NativeMMXIntegerFPObjectsDarwinAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-apple-darwin", "b+16(FP)")
+}
+
+func TestX86NativeMMXIntegerMemoryObjectsDarwinAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-apple-darwin", "(AX)")
+}
+
+func TestX86NativeMMXIntegerRegisterObjectsWindowsAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-pc-windows-msvc", "M1")
+}
+
+func TestX86NativeMMXIntegerAliasObjectsWindowsAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-pc-windows-msvc", "BX")
+}
+
+func TestX86NativeMMXIntegerFPObjectsWindowsAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-pc-windows-msvc", "b+16(FP)")
+}
+
+func TestX86NativeMMXIntegerMemoryObjectsWindowsAMD64(t *testing.T) {
+	x86NativeMMXIntegerObjects(t, "x86_64-pc-windows-msvc", "(AX)")
+}
+
+func x86NativeMMXWordObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	t.Run(triple, func(t *testing.T) {
+		// The original named integer Py1 rows do not exist in Go mode32.
+		// Word transfers, the distinct PHADDD row and PSHUFW do exist.
+		bodies := []string{
+			"MOVQ a+0(FP),M0\nMOVQ M0,ret+8(FP)",
+			"MOVL a+0(FP),AX\nMOVL AX,M0\nMOVQ M0,ret+8(FP)",
+			"MOVQ a+0(FP),X0\nMOVQ X0,M0\nMOVQOZX M0,X1\nEMMS\nMOVQ X1,ret+8(FP)",
+			"MOVQ a+0(FP),M0\nPSHUFW $27,M0,M1\nMOVQ M1,ret+8(FP)",
+			"MOVQ a+0(FP),M0\nMOVQ a+0(FP),M1\nPHADDD M1,M0\nMOVQ M0,ret+8(FP)",
+		}
+		var assembly, declarations strings.Builder
+		for index, body := range bodies {
+			name := fmt.Sprintf("word%d", index)
+			fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+			if !strings.Contains(body, "EMMS") {
+				body += "\nEMMS"
+			}
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\n%s\nRET\n", name, body)
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, assembly.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, triple, api)
+				if err != nil {
+					t.Fatal("Go-mode-valid initialized MMX word source lost its native continuation", err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			})
+		}
+	})
+}
+
+func TestX86NativeMMXWordObjectsLinux386(t *testing.T) {
+	x86NativeMMXWordObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86NativeMMXWordObjectsWindows386(t *testing.T) {
+	x86NativeMMXWordObjects(t, "386", "i686-pc-windows-msvc")
+}
+
+func TestX86NativeMMXWordObjectsLinuxAMD64(t *testing.T) {
+	x86NativeMMXWordObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86NativeMMXWordObjectsDarwinAMD64(t *testing.T) {
+	x86NativeMMXWordObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86NativeMMXWordObjectsWindowsAMD64(t *testing.T) {
+	x86NativeMMXWordObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
diff --git a/amd64_native_mmx_region.go b/amd64_native_mmx_region.go
new file mode 100644
index 000000000..e70b4e72c
--- /dev/null
+++ b/amd64_native_mmx_region.go
@@ -0,0 +1,353 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86NativeMMXGPRegisters = [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI,
+	"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+
+func (c *amd64Ctx) lowerNativeMMXRegionAt(block, ordinal int, ins Instr) (bool, error) {
+	plan := c.nativeMMXRegion
+	if plan == nil || ordinal < plan.begin || ordinal > plan.end {
+		return false, nil
+	}
+	if block != 0 || len(c.blocks) != 1 || !plan.matchesInstruction(ordinal, ins) {
+		return true, fmt.Errorf("%w: native MMX source position changed", ErrProbeNeedsContext)
+	}
+	if ordinal != plan.begin {
+		return true, nil // The complete sealed sequence was emitted at its first instruction.
+	}
+	if !plan.matches(c.fpScalarSource, c.fpSourceSig, c.goarch, c.targetTriple) {
+		return true, fmt.Errorf("%w: native MMX source/declaration binding changed", ErrProbeNeedsContext)
+	}
+	return true, c.emitNativeMMXRegion(plan)
+}
+
+// These names differ between Go's operand-width notation and Intel/LLVM's
+// spelling. The operand and encoding rows still come from the shared complete
+// x86LegacyMMXReadSpecs; this selector grants no additional form or input.
+func x86NativeMMXIntegerMnemonic(op Op) string {
+	switch op {
+	case "PACKSSLW":
+		return "packssdw"
+	case "PADDL":
+		return "paddd"
+	case "PCMPEQL":
+		return "pcmpeqd"
+	case "PCMPGTL":
+		return "pcmpgtd"
+	case "PMADDWL":
+		return "pmaddwd"
+	case "PMULULQ":
+		return "pmuludq"
+	case "PUNPCKHWL":
+		return "punpckhwd"
+	case "PUNPCKHLQ":
+		return "punpckhdq"
+	case "PUNPCKLWL":
+		return "punpcklwd"
+	case "PUNPCKLLQ":
+		return "punpckldq"
+	case "PSLLL":
+		return "pslld"
+	case "PSRLL":
+		return "psrld"
+	case "PSRAL":
+		return "psrad"
+	}
+	return strings.ToLower(string(op))
+}
+
+func (c *amd64Ctx) emitNativeMMXRegion(plan *x86NativeMMXRegion) error {
+	gpBase := (plan.fpExtent + 15) &^ 15
+	xBase := gpBase + int64(len(x86NativeMMXGPRegisters))*8
+	extent := xBase
+	for index := range plan.xRead {
+		if plan.xRead[index] || plan.xWritten[index] {
+			extent = xBase + 16*int64(index+1)
+		}
+	}
+	image := "%" + c.newTmp()
+	fmt.Fprintf(c.b, "  %s = alloca [%d x i8], align 16\n", image, extent)
+	pointer := func(offset int64) string {
+		name := "%" + c.newTmp()
+		fmt.Fprintf(c.b, "  %s = getelementptr i8, ptr %s, i64 %d\n", name, image, offset)
+		return name
+	}
+	// This image gathers only declared logical numeric fields. Its address is
+	// private to the asm region: source GPs, native pointers and later effects
+	// cannot acquire it as a frame, contiguous caller storage or a GC root.
+	var fields []FrameSlot
+	for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.sig.Frame.Results} {
+		for _, slot := range slots {
+			width := x86FrameScalarBytes(slot.Type, c.goarch)
+			touched := false
+			for offset := slot.Offset; offset < slot.Offset+width; offset++ {
+				touched = touched || plan.fpRead[offset] || plan.fpWritten[offset]
+			}
+			if !touched {
+				continue
+			}
+			value, err := c.loadFPVectorBytes(slot.Offset, int(width))
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  store <%d x i8> %s, ptr %s, align 1\n", width, value, pointer(slot.Offset))
+			fields = append(fields, slot)
+		}
+	}
+	for index, reg := range x86NativeMMXGPRegisters {
+		if !plan.gpRead[index] && !plan.gpWritten[index] {
+			continue
+		}
+		value, err := c.loadReg(reg)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", value, pointer(gpBase+8*int64(index)))
+	}
+	for index := range plan.xRead {
+		if !plan.xRead[index] && !plan.xWritten[index] {
+			continue
+		}
+		value, err := c.loadX(Reg(fmt.Sprintf("X%d", index)))
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", value, pointer(xBase+16*int64(index)))
+	}
+	assembly, err := x86NativeMMXAssembly(plan, gpBase, xBase)
+	if err != nil {
+		return err
+	}
+	scratch := []string{"r10", "r11", "xmm15"}
+	if c.goarch == "386" {
+		scratch = []string{"eax", "edx", "xmm7"}
+	}
+	constraints := []string{"r"}
+	for _, site := range plan.sites {
+		if site.maskStore != nil {
+			constraints = append(constraints, "~{di}")
+			break
+		}
+	}
+	for _, reg := range scratch {
+		constraints = append(constraints, "~{"+reg+"}")
+	}
+	for index := 0; index < 8; index++ {
+		constraints = append(constraints, fmt.Sprintf("~{mm%d}", index))
+		name := "st"
+		if index != 0 {
+			name = fmt.Sprintf("st(%d)", index)
+		}
+		constraints = append(constraints, "~{"+name+"}")
+	}
+	constraints = append(constraints, "~{fpsr}", "~{memory}")
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(ptr %s)\n", assembly, strings.Join(constraints, ","), image)
+	for _, slot := range fields {
+		width := x86FrameScalarBytes(slot.Type, c.goarch)
+		written := false
+		for offset := slot.Offset; offset < slot.Offset+width; offset++ {
+			written = written || plan.fpWritten[offset]
+		}
+		if written {
+			value := "%" + c.newTmp()
+			fmt.Fprintf(c.b, "  %s = load <%d x i8>, ptr %s, align 1\n", value, width, pointer(slot.Offset))
+			if err := c.storeFPVectorBytes(slot.Offset, int(width), value, ""); err != nil {
+				return err
+			}
+		}
+	}
+	for index, reg := range x86NativeMMXGPRegisters {
+		if plan.gpWritten[index] {
+			value := "%" + c.newTmp()
+			fmt.Fprintf(c.b, "  %s = load i64, ptr %s, align 1\n", value, pointer(gpBase+8*int64(index)))
+			if err := c.storeReg(reg, value); err != nil {
+				return err
+			}
+		}
+	}
+	for index, written := range plan.xWritten {
+		if written {
+			value := "%" + c.newTmp()
+			fmt.Fprintf(c.b, "  %s = load <16 x i8>, ptr %s, align 1\n", value, pointer(xBase+16*int64(index)))
+			if err := c.storeLegacyPackedLogical(Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", index))}, value); err != nil {
+				return err
+			}
+		}
+	}
+	if !plan.matches(c.fpScalarSource, c.fpSourceSig, c.goarch, c.targetTriple) {
+		return fmt.Errorf("%w: native MMX source changed while emitting its region", ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+func x86NativeMMXAssembly(plan *x86NativeMMXRegion, gpBase, xBase int64) (string, error) {
+	word, data, address, vector := "movq", "%r10", "%r11", "%xmm15"
+	if plan.arch == "386" {
+		word, data, address, vector = "movl", "%eax", "%edx", "%xmm7"
+	}
+	var code []string
+	gp := func(reg Reg) (int64, error) {
+		index, _, valid := x86ResultGP(reg, x86ResultPointerWord(plan.arch), plan.arch)
+		if !valid {
+			return 0, fmt.Errorf("%w: MMX region lost a typed GP identity", ErrProbeNeedsContext)
+		}
+		return gpBase + int64(index)*8, nil
+	}
+	memory := func(operand Operand) (string, error) {
+		if operand.Kind == OpFP {
+			return fmt.Sprintf("%d($0)", operand.FPOffset), nil
+		}
+		if operand.Kind != OpMem {
+			return "", fmt.Errorf("%w: MMX memory lost its source operand class", ErrProbeNeedsContext)
+		}
+		base, err := gp(operand.Mem.Base)
+		if err != nil {
+			return "", err
+		}
+		code = append(code, fmt.Sprintf("%s %d($0), %s", word, base, address))
+		if operand.Mem.Index != "" {
+			index, err := gp(operand.Mem.Index)
+			if err != nil {
+				return "", err
+			}
+			code = append(code, fmt.Sprintf("%s %d($0), %s", word, index, data),
+				fmt.Sprintf("lea %d(%s,%s,%d), %s", operand.Mem.Off, address, data, operand.Mem.Scale, address))
+			return "(" + address + ")", nil
+		}
+		return fmt.Sprintf("%d(%s)", operand.Mem.Off, address), nil
+	}
+	for ordinal := plan.begin; ordinal <= plan.end; ordinal++ {
+		site := plan.sites[ordinal]
+		if site.instruction.Op == "EMMS" {
+			code = append(code, "emms")
+			continue
+		}
+		if form := site.word; form != nil {
+			mnemonic := "movq"
+			if form.bytes == 4 {
+				mnemonic = "movd"
+			}
+			if form.nonTemporal {
+				mnemonic = "movntq"
+			}
+			if form.targetM {
+				source := ""
+				if form.sourceX {
+					index, _ := amd64ParseXReg(form.source.Reg)
+					code = append(code, fmt.Sprintf("movdqu %d($0), %s", xBase+int64(index)*16, vector))
+					mnemonic, source = "movdq2q", vector
+				} else if form.source.Kind == OpReg {
+					offset, err := gp(form.source.Reg)
+					if err != nil {
+						return "", err
+					}
+					load, reg := word, data
+					if form.bytes == 4 {
+						load, reg = "movl", "%eax"
+						if plan.arch == "amd64" {
+							reg = "%r10d"
+						}
+					}
+					code = append(code, fmt.Sprintf("%s %d($0), %s", load, offset, reg))
+					source = reg
+				} else {
+					var err error
+					source, err = memory(form.source)
+					if err != nil {
+						return "", err
+					}
+				}
+				index, _ := amd64ParseMReg(form.destination.Reg)
+				code = append(code, fmt.Sprintf("%s %s, %%mm%d", mnemonic, source, index))
+				continue
+			}
+			source, _ := amd64ParseMReg(form.source.Reg)
+			if form.targetX {
+				index, _ := amd64ParseXReg(form.destination.Reg)
+				code = append(code, fmt.Sprintf("movq2dq %%mm%d, %s", source, vector),
+					fmt.Sprintf("movdqu %s, %d($0)", vector, xBase+int64(index)*16))
+			} else if form.destination.Kind == OpReg {
+				offset, err := gp(form.destination.Reg)
+				if err != nil {
+					return "", err
+				}
+				reg := data
+				if form.bytes == 4 && plan.arch == "amd64" {
+					reg = "%r10d"
+				}
+				code = append(code, fmt.Sprintf("%s %%mm%d, %s", mnemonic, source, reg),
+					fmt.Sprintf("%s %s, %d($0)", word, data, offset))
+				if plan.arch == "386" {
+					code = append(code, fmt.Sprintf("movl $$0, %d($0)", offset+4))
+				}
+			} else {
+				destination, err := memory(form.destination)
+				if err != nil {
+					return "", err
+				}
+				code = append(code, fmt.Sprintf("%s %%mm%d, %s", mnemonic, source, destination))
+			}
+			continue
+		}
+		if site.moveMask != nil {
+			offset, err := gp(site.instruction.Args[1].Reg)
+			if err != nil {
+				return "", err
+			}
+			bank, _ := amd64ParseMReg(site.instruction.Args[0].Reg)
+			reg := "%r10d"
+			if plan.arch == "386" {
+				reg = "%eax"
+			}
+			code = append(code, fmt.Sprintf("pmovmskb %%mm%d, %s", bank, reg),
+				fmt.Sprintf("%s %s, %d($0)", word, data, offset))
+			if plan.arch == "386" {
+				code = append(code, fmt.Sprintf("movl $$0, %d($0)", offset+4))
+			}
+			continue
+		}
+		if site.maskStore != nil {
+			offset, err := gp(DI)
+			if err != nil {
+				return "", err
+			}
+			destination := "%rdi"
+			if plan.arch == "386" {
+				destination = "%edi"
+			}
+			mask, _ := amd64ParseMReg(site.instruction.Args[0].Reg)
+			data, _ := amd64ParseMReg(site.instruction.Args[1].Reg)
+			code = append(code, fmt.Sprintf("%s %d($0), %s", word, offset, destination),
+				fmt.Sprintf("maskmovq %%mm%d, %%mm%d", mask, data))
+			continue
+		}
+		form := site.integer
+		destination, _ := amd64ParseMReg(site.instruction.Args[form.destination].Reg)
+		mnemonic := x86NativeMMXIntegerMnemonic(form.canonical)
+		if form.source.Kind == OpImm {
+			code = append(code, fmt.Sprintf("%s $$%d, %%mm%d", mnemonic, byte(form.source.Imm), destination))
+			continue
+		}
+		source := ""
+		if form.source.Kind == OpReg {
+			index, _ := amd64ParseMReg(form.source.Reg)
+			source = fmt.Sprintf("%%mm%d", index)
+		} else {
+			var err error
+			source, err = memory(form.source)
+			if err != nil {
+				return "", err
+			}
+		}
+		immediate := ""
+		if form.spec.table == x86LegacyMMXShuffle {
+			immediate = fmt.Sprintf("$$%d, ", byte(site.instruction.Args[0].Imm))
+		}
+		code = append(code, fmt.Sprintf("%s %s%s, %%mm%d", mnemonic, immediate, source, destination))
+	}
+	return strings.Join(code, "; "), nil
+}
diff --git a/amd64_native_mmx_streaming_linux_amd64_test.go b/amd64_native_mmx_streaming_linux_amd64_test.go
new file mode 100644
index 000000000..7d32e9c9b
--- /dev/null
+++ b/amd64_native_mmx_streaming_linux_amd64_test.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86MMXStreamingOriginalAndLLVM(t *testing.T) {
+	declarations, source, c, tests := x86MMXStreamingOracleSources()
+	t.Run("original-go", func(t *testing.T) {
+		x86PackedIntegerCompareRunOriginalGo(t, declarations, source, tests)
+	})
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations[len("package oracle\n"):],
+		"amd64", "x86_64-unknown-linux-gnu", "Go")
+	if err != nil {
+		t.Fatal("complete original streaming source lost its native MMX binding", err)
+	}
+	execution := x86FloatCompareExecutionTools(t)
+	for _, passes := range []string{"default", "O2"} {
+		text := ir
+		if passes == "O2" {
+			text = x86DwordProductIROptimize(t, ir)
+		}
+		for _, backend := range []string{"-O0", "-O2"} {
+			t.Run("llvm-"+passes+backend, func(t *testing.T) {
+				execution.compileAndRunLLVM(t, "streaming", text, c, backend)
+			})
+		}
+	}
+	// Preserve every streaming kernel above, then execute the distinct typed
+	// MMX-to-GP consumer through its original Go and independent C oracles.
+	t.Run("move-mask", x86NativeMMXMoveMaskRuntime)
+}
diff --git a/amd64_native_mmx_streaming_oracle_test.go b/amd64_native_mmx_streaming_oracle_test.go
new file mode 100644
index 000000000..65593577d
--- /dev/null
+++ b/amd64_native_mmx_streaming_oracle_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86MMXStreamingOracleSources() (string, string, string, string) {
+	var declarations, assembly, c, goTest strings.Builder
+	declarations.WriteString("package oracle\n")
+	c.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	var names []string
+	var offsets []string
+	for register := 0; register < 8; register++ {
+		for index, address := range []string{"0(DI)", "0(DI)(DX*8)"} {
+			name := fmt.Sprintf("Stream%d", len(names))
+			names = append(names, name)
+			offsets = append(offsets, fmt.Sprint(index*8))
+			source, declaration := x86NativeMMXNonTemporalFixture("amd64", register, address)
+			assembly.WriteString(strings.ReplaceAll(source, "Store", name))
+			declarations.WriteString(strings.ReplaceAll(declaration, "Store", name) + "\n")
+			fmt.Fprintf(&c, "extern void %s(uint32_t,uint8_t*);\n", name)
+		}
+	}
+	fmt.Fprintf(&c, "static void (*const kernels[])(uint32_t,uint8_t*) = {%s};\n", strings.Join(names, ","))
+	fmt.Fprintf(&c, "static const int offsets[] = {%s};\n", strings.Join(offsets, ","))
+	c.WriteString(`
+int main(void) {
+    static const uint32_t values[] = {0,1,0xffffffffu,0x87654321u};
+    __asm__ volatile("emms" ::: "memory");
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        for (unsigned v=0;v<sizeof(values)/sizeof(values[0]);++v) {
+            _Alignas(64) uint8_t out[128];
+            memset(out,0xa5,sizeof(out));
+            kernels[k](values[v],out);
+            for (unsigned byte=0;byte<sizeof(out);++byte) {
+                uint8_t want=0xa5;
+                if (byte>=(unsigned)offsets[k] && byte<(unsigned)offsets[k]+8) {
+                    want=(uint8_t)((uint64_t)values[v] >> (8*(byte-offsets[k])));
+                }
+                if (out[byte]!=want) {
+                    fprintf(stderr,"kernel=%u value=%x byte=%u got=%x want=%x\n",
+                        k,values[v],byte,out[byte],want);
+                    return 1;
+                }
+            }
+            _Alignas(16) uint8_t state[512];
+            __asm__ volatile("fxsave %0" : "=m"(state));
+            if (state[4]!=0) {
+                fprintf(stderr,"kernel=%u value=%x x87 tag=%x\n",k,values[v],state[4]);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`)
+	fmt.Fprintf(&goTest, "package oracle\nimport \"testing\"\nvar kernels=[]func(uint32,*[128]byte){%s}\n", strings.Join(names, ","))
+	fmt.Fprintf(&goTest, "var offsets=[]int{%s}\n", strings.Join(offsets, ","))
+	goTest.WriteString(`
+func TestOriginalStreamingStores(t *testing.T) {
+    for k,run:=range kernels {
+        for _,value:=range []uint32{0,1,0xffffffff,0x87654321} {
+            var aligned struct { word uint64; out [128]byte }
+            for index:=range aligned.out { aligned.out[index]=0xa5 }
+            run(value,&aligned.out)
+            for index,got:=range aligned.out {
+                want:=byte(0xa5)
+                if index>=offsets[k] && index<offsets[k]+8 {
+                    want=byte(uint64(value) >> (8*(index-offsets[k])))
+                }
+                if got!=want { t.Fatalf("kernel=%d value=%x byte=%d got=%x want=%x",k,value,index,got,want) }
+            }
+        }
+    }
+}
+`)
+	return declarations.String(), assembly.String(), c.String(), goTest.String()
+}
+
+func TestX86NativeMMXStreamingOriginalGoBuildOnly(t *testing.T) {
+	declarations, source, _, tests := x86MMXStreamingOracleSources()
+	x86PackedIntegerCompareOriginalGoDriver(t, declarations, source, tests, true)
+}
diff --git a/amd64_needed.go b/amd64_needed.go
index 9a52b4df8..c97a638ab 100644
--- a/amd64_needed.go
+++ b/amd64_needed.go
@@ -2,18 +2,30 @@ package plan9asm
 
 import "strings"
 
-// funcNeedsAMD64CFG decides whether we need the CFG-based amd64 translator.
-// The linear prototype cannot handle labels/branches and most vector ops.
+// funcNeedsAMD64CFG decides whether the direct LLVM-module prototype can
+// represent an amd64 function. Textual translation always uses the complete
+// architecture-aware x86 CFG lowerer.
 func funcNeedsAMD64CFG(fn Func) bool {
 	for _, ins := range fn.Instrs {
+		if _, known, _ := x86GPSIMDTransferProperties(ins, "amd64"); known {
+			return true // The scalar prototype has no X-bank or encoding state.
+		}
 		if ins.Op == OpLABEL {
 			return true
 		}
 		op := strings.ToUpper(string(ins.Op))
+		for _, operand := range ins.Args {
+			if _, _, ok := x86MachineRegisterOperand(operand); ok {
+				return true
+			}
+			if x86SegmentRegisterOperand(operand) {
+				return true
+			}
+		}
 		switch Op(op) {
-		case "JMP", "JL", "JLT", "JLE", "JG", "JGT", "JGE",
+		case "JMP", "JCXZW", "JCXZL", "JCXZQ", "JL", "JLT", "JLE", "JG", "JGT", "JGE",
 			"JB", "JLO", "JBE", "JA", "JHI", "JAE", "JHS",
-			"JZ", "JE", "JEQ", "JNZ", "JNE", "JNC", "JC", "JCC", "JLS", "JNA", "JS", "JNS":
+			"JZ", "JE", "JEQ", "JNZ", "JNE", "JNC", "JC", "JCS", "JCC", "JLS", "JNA", "JS", "JNS":
 			return true
 		}
 		// A handful of amd64 stdlib asm functions are straight-line, but if we
@@ -21,10 +33,10 @@ func funcNeedsAMD64CFG(fn Func) bool {
 		if strings.HasPrefix(op, "MOVO") || strings.HasPrefix(op, "PCLMUL") || strings.HasPrefix(op, "CRC32") || strings.HasPrefix(op, "PXOR") {
 			return true
 		}
-		// Keep the linear path only for the tiny subset it currently lowers.
+		// Keep the direct-module path only for the tiny subset it currently lowers.
 		switch Op(op) {
 		case OpTEXT, OpBYTE, OpMOVQ, OpMOVL, OpADDQ, OpSUBQ, OpXORQ, OpCPUID, OpXGETBV:
-			// For MOVQ/MOVL, linear lowering supports immediate/reg/FP value flow.
+			// For MOVQ/MOVL, direct lowering supports immediate/reg/FP value flow.
 			// Addressing forms (mem/sym) require CFG lowering.
 			if (op == "MOVQ" || op == "MOVL") && len(ins.Args) == 2 {
 				for _, a := range ins.Args {
diff --git a/amd64_new_opfamilies_test.go b/amd64_new_opfamilies_test.go
index 096e191de..4559cebbe 100644
--- a/amd64_new_opfamilies_test.go
+++ b/amd64_new_opfamilies_test.go
@@ -1,9 +1,8 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"errors"
+	"fmt"
 	"strings"
 	"testing"
 )
@@ -16,28 +15,20 @@ TEXT notb(SB),NOSPLIT,$0-0
 	NOTB 3(AX)
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ir, err := Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"notb": {Name: "notb", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	ir := x86UnboundVoidScalarFormatObject(t, src, "notb", "amd64", "x86_64-unknown-linux-gnu")
 	if got := strings.Count(ir, "xor i8"); got != 2 {
 		t.Fatalf("NOTB xor count = %d, want 2:\n%s", got, ir)
 	}
-	for _, want := range []string{"and i64", "or i64", "load i8", "store i8"} {
+	for _, want := range []string{"and i64", "or i64", "load volatile i8", "store volatile i8"} {
 		if !strings.Contains(ir, want) {
 			t.Fatalf("NOTB output missing %q:\n%s", want, ir)
 		}
 	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "not-byte-forms.ll", "not-byte-forms.o", ir)
 }
 
 func TestTranslateAMD64SHA1Family(t *testing.T) {
@@ -82,24 +73,17 @@ TEXT crcops(SB),NOSPLIT,$0-0
 	VZEROUPPER
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"crcops": {Name: "crcops", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
+	// This original format sequence does not supply AX, X0 or Z11.
+	// Its object checks must not invent those public-entry inputs.
+	ir := x86UnboundVoidScalarFormatObject(t, src, "crcops", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
 	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "crc-subset-forms.ll", "crc-subset-forms.o", ir)
 }
 
-func TestTranslateAMD64AVX512Go126Families(t *testing.T) {
-	src := `
+const x86Go126FamiliesSource = `
 GLOBL mat<>(SB), RODATA, $64
 DATA mat<>+0(SB)/8, $0
 
@@ -116,18 +100,82 @@ TEXT go126ops(SB),NOSPLIT,$0-0
 	VPCOMPRESSQ Z1, K1, Z2
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
+
+var x86Go126FamiliesInputs = []string{"Z0", "Z1", "Z2", "Z3", "Z4", "Z5", "Z6", "Z15"}
+
+func x86Go126FamiliesInitializedSource(omit string) string {
+	var initialization strings.Builder
+	for _, reg := range x86Go126FamiliesInputs {
+		if reg != omit {
+			fmt.Fprintf(&initialization, "VPXORD %s,%s,%s\n", reg, reg, reg)
+		}
 	}
-	_, err = Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"go126ops": {Name: "go126ops", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
+	return strings.Replace(x86Go126FamiliesSource, "\tMOVQ $0xff, AX", initialization.String()+"\tMOVQ $0xff, AX", 1)
+}
+
+func TestTranslateAMD64AVX512Go126Families(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	source := x86Go126FamiliesInitializedSource("")
+	// Supply Go's textflag constants without changing the original body or
+	// relying on an ambient include search path in the cross-object helper.
+	oracleSource := "#define NOSPLIT 4\n#define RODATA 8\n" + source
+	goAssemblerOracleOutput(t, "amd64", oracleSource, "", true)
+	for _, target := range dataRelocationTargets {
+		if target.goarch != "amd64" {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			dataRelocationGoObject(t, oracleSource, target.goos, target.goarch, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func go126ops()", target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized whole instruction sequence rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, []string{"go126ops"})
+					for _, optimized := range []bool{false, true} {
+						objectIR := ir
+						if optimized {
+							objectIR = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, objectIR, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86Go126FamiliesCannotBorrowUninitializedVectorInputs(t *testing.T) {
+	sources := map[string]string{"original": x86Go126FamiliesSource}
+	for _, reg := range x86Go126FamiliesInputs {
+		sources["missing-"+reg] = x86Go126FamiliesInitializedSource(reg)
+	}
+	sources["missing-mask"] = strings.Replace(x86Go126FamiliesInitializedSource(""), "KMOVQ AX, K1", "NOP", 1)
+	for name, source := range sources {
+		t.Run(name, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+source, "", true)
+			for _, target := range dataRelocationTargets {
+				if target.goarch != "amd64" {
+					continue
+				}
+				t.Run(target.triple, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							if _, err := x86ScalarFPBitViewAPI(t, source, "func go126ops()", target.goarch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown source acquired implementation-slot bytes", err)
+							}
+						})
+					}
+				})
+			}
+		})
 	}
 }
diff --git a/amd64_nontemporal_vector_forms.go b/amd64_nontemporal_vector_forms.go
new file mode 100644
index 000000000..dfeef6539
--- /dev/null
+++ b/amd64_nontemporal_vector_forms.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86NonTemporalVectorSpec struct {
+	native string
+	vector bool
+	load   bool
+}
+
+// Complete Go yxr_ml/ylddqu and _yvmovntdq/_yvmovntdqa rows. MOVNTDQ
+// is Go's source alias of MOVNTO, not a distinct physical MMX operation.
+var x86NonTemporalVectorSpecs = map[Op]x86NonTemporalVectorSpec{
+	"MOVNTO":    {"movntdq", false, false},
+	"MOVNTDQ":   {"movntdq", false, false},
+	"MOVNTPD":   {"movntpd", false, false},
+	"MOVNTPS":   {"movntps", false, false},
+	"MOVNTDQA":  {"movntdqa", false, true},
+	"VMOVNTDQ":  {"vmovntdq", true, false},
+	"VMOVNTPD":  {"vmovntpd", true, false},
+	"VMOVNTPS":  {"vmovntps", true, false},
+	"VMOVNTDQA": {"vmovntdqa", true, true},
+}
+
+type x86NonTemporalVectorForm struct {
+	spec x86NonTemporalVectorSpec
+	move amd64PackedVectorMoveForm
+	trap bool
+}
+
+func x86NonTemporalVectorProperties(op Op, ins Instr, arch string) (x86NonTemporalVectorForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86NonTemporalVectorSpecs[Op(name)]
+	form := x86NonTemporalVectorForm{spec: spec, move: amd64PackedVectorMoveForm{
+		spec:   amd64PackedVectorMoveSpec{elementBits: 8, encoding: amd64PackedMoveVEXOrEVEX, aligned: true},
+		memory: 1, destination: 1, mask: -1, memoryWrite: !spec.load,
+	}}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86NonTemporalVectorForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go non-temporal vector grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	vector, memory := ins.Args[0], ins.Args[1]
+	if spec.load {
+		vector, memory, form.move.memory = ins.Args[1], ins.Args[0], 0
+	}
+	form.move.byteWidth = amd64VectorByteWidth(vector.Reg)
+	index, _ := amd64VectorRegisterIndex(vector.Reg, form.move.byteWidth)
+	if vector.Kind != OpReg || !amd64GoPackedVectorMoveRegister(vector, form.move.byteWidth, arch) ||
+		!spec.vector && (form.move.byteWidth != 16 || !amd64VEXVectorRegister(vector, 16) ||
+			arch == "386" && index >= 8) {
+		return fail()
+	}
+	if !spec.vector && !spec.load && memory.Kind == OpReg && isX86YrlRegisterForArch(memory.Reg, arch) {
+		form.trap, form.move.memory = true, -1
+		return form, true, nil // Go's Yml accepts ModRM.mod=3; the ISA raises #UD before inputs.
+	}
+	if !isAMD64MemoryOperand(memory) || memory.Kind == OpSym && strings.HasPrefix(memory.Sym, "$") {
+		return fail()
+	}
+	if memory.Kind == OpMem {
+		if err := x86SymbolIndexedMemoryError(memory.Mem, arch); err != nil {
+			return form, true, err
+		}
+		if memory.Mem.OffRaw != "" || memory.Mem.IndexExt != "" {
+			return fail()
+		}
+		if arch == "386" && strings.HasSuffix(memory.Mem.Sym, "(SB)") {
+			memory.Mem.Base = "" // Go ignores Reg on this symbol role, not Index.
+		}
+	}
+	if !x86PackedShiftMemoryValid(memory, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+// Only the paired native instruction supplies a continuation. Standalone
+// queries cannot replace native alignment, non-temporal ordering or backing
+// with initialized logical FP bytes or an incoming pointer declaration.
+func x86ResultNonTemporalVectorStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string, native bool) (bool, bool) {
+	form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if form.trap {
+		return true, true // Control-flow checks separately recognize this exact terminal #UD.
+	}
+	memory := ins.Args[form.move.memory]
+	if !native || !x86ResultNamedPredicateInstruction(ins) ||
+		x86Mode32VectorRegisterContext(ins, arch) != nil || memory.Kind != OpMem || memory.Mem.Sym != "" {
+		return false, true
+	}
+	width := int64(form.move.byteWidth)
+	if !form.spec.load {
+		index, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.move.byteWidth)
+		mask := x86CallerVectorByteMask(width)
+		return x86ResultIncomingPointerAddressIdentity(memory, state, arch) &&
+			valid && state.vectorBytes(index)&mask == mask, true
+	}
+	if !x86ResultIncomingPointerReadAddressIdentity(memory, state, arch) {
+		return false, true
+	}
+	index, valid := amd64VectorRegisterIndex(ins.Args[1].Reg, form.move.byteWidth)
+	if !valid {
+		return false, true
+	}
+	state.writeVector(index, form.move.byteWidth, x86CallerVectorByteMask(width), !form.spec.vector)
+	return true, true
+}
diff --git a/amd64_operand_forms_test.go b/amd64_operand_forms_test.go
index dde7de5cc..d3868edbe 100644
--- a/amd64_operand_forms_test.go
+++ b/amd64_operand_forms_test.go
@@ -1,9 +1,9 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
-import "testing"
+import (
+	"strings"
+	"testing"
+)
 
 func TestTranslateAMD64PEXTRDToMemory(t *testing.T) {
 	src := `
@@ -11,20 +11,7 @@ TEXT pextrdmem(SB),NOSPLIT,$0-0
 	PEXTRD $3, X5, 16(DI)
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"pextrdmem": {Name: "pextrdmem", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	x86UnboundVoidScalarFormatObject(t, src, "pextrdmem", "amd64", "x86_64-unknown-linux-gnu")
 }
 
 func TestTranslateAMD64PEXTRQToMemory(t *testing.T) {
@@ -33,20 +20,7 @@ TEXT pextrqmem(SB),NOSPLIT,$0-0
 	PEXTRQ $1, X5, 16(DI)
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"pextrqmem": {Name: "pextrqmem", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	x86UnboundVoidScalarFormatObject(t, src, "pextrqmem", "amd64", "x86_64-unknown-linux-gnu")
 }
 
 func TestTranslateAMD64VectorBroadcastForms(t *testing.T) {
@@ -60,20 +34,12 @@ TEXT broadcastvec(SB),NOSPLIT,$0-0
 	VGF2P8AFFINEQB $0, Y0, Y1, Y1
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	_, err = Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		Sigs: map[string]FuncSig{
-			"broadcastvec": {Name: "broadcastvec", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
+	ir := x86UnboundVoidScalarFormatObject(t, src, "broadcastvec", "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
 	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "vector-broadcast-forms.ll", "vector-broadcast-forms.o", ir)
 }
 
 func TestAMD64VectorLoweringBranchCoverage(t *testing.T) {
@@ -99,36 +65,75 @@ func TestAMD64VectorLoweringBranchCoverage(t *testing.T) {
 		}
 	}
 
-	check("gf2-z-source-class", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Z0"), reg("X1"), reg("Z2")}}, false, false)
+	check("gf2-z-source-class", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Z0"), reg("X1"), reg("Z2")}}, true, true)
 	check("gf2-z-source-error", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Z0"), ident("bad"), reg("Z2")}}, true, true)
-	check("gf2-y-source-class", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Y0"), reg("X1"), reg("Y2")}}, false, false)
+	check("gf2-y-source-class", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Y0"), reg("X1"), reg("Y2")}}, true, true)
 	check("gf2-y-source-error", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Y0"), ident("bad"), reg("Y2")}}, true, true)
-	check("gf2-unsupported-dst", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Y0"), reg("Y1"), reg("X2")}}, false, false)
+	check("gf2-unsupported-dst", "VGF2P8AFFINEQB", Instr{Args: []Operand{imm(0), reg("Y0"), reg("Y1"), reg("X2")}}, true, true)
 
-	check("broadcast-i128-args", "VBROADCASTI128", Instr{Args: []Operand{reg("X0")}}, true, true)
-	check("broadcast-i128-dst", "VBROADCASTI128", Instr{Args: []Operand{reg("X0"), reg("X1")}}, false, false)
-	check("broadcast-i128-source", "VBROADCASTI128", Instr{Args: []Operand{ident("bad"), reg("Y1")}}, true, true)
 	check("broadcast-scalar-args", "VBROADCASTSD", Instr{Args: []Operand{imm(1)}}, true, true)
 	check("broadcast-scalar-source", "VBROADCASTSD", Instr{Args: []Operand{ident("bad"), reg("Y1")}}, true, true)
-	check("broadcast-scalar-immediate", "VBROADCASTSD", Instr{Args: []Operand{imm(1), reg("Y1")}}, false, false)
-	check("broadcast-scalar-gpr", "VBROADCASTSD", Instr{Args: []Operand{reg("AX"), reg("Y1")}}, false, false)
+	check("broadcast-scalar-immediate", "VBROADCASTSD", Instr{Args: []Operand{imm(1), reg("Y1")}}, true, true)
+	check("broadcast-scalar-gpr", "VBROADCASTSD", Instr{Args: []Operand{reg("AX"), reg("Y1")}}, true, true)
 	check("broadcast-scalar-x-source", "VBROADCASTSD", Instr{Args: []Operand{reg("X0"), reg("Y1")}}, false, true)
-	check("broadcast-scalar-x-dst", "VBROADCASTSD", Instr{Args: []Operand{reg("X0"), reg("X1")}}, false, false)
-	check("broadcast-scalar-dst", "VBROADCASTSD", Instr{Args: []Operand{mem("AX"), reg("AX")}}, false, false)
+	check("broadcast-scalar-x-dst", "VBROADCASTSD", Instr{Args: []Operand{reg("X0"), reg("X1")}}, true, true)
+	check("broadcast-scalar-dst", "VBROADCASTSD", Instr{Args: []Operand{mem("AX"), reg("AX")}}, true, true)
 	check("broadcast-q-x", "VPBROADCASTQ", Instr{Args: []Operand{reg("X0"), reg("X1")}}, false, true)
 	check("broadcast-q-gpr", "VPBROADCASTQ", Instr{Args: []Operand{reg("AX"), reg("X1")}}, false, true)
 	check("broadcast-q-immediate", "VPBROADCASTQ", Instr{Args: []Operand{imm(1), reg("X1")}}, false, false)
 	check("broadcast-q-address", "VPBROADCASTQ", Instr{Args: []Operand{sym("$value(SB)"), reg("X1")}}, false, false)
-	check("pmululq-args", "PMULULQ", Instr{Args: []Operand{reg("X0")}}, true, true)
-	check("pmululq-dst", "PMULULQ", Instr{Args: []Operand{reg("X0"), reg("Y1")}}, false, false)
-	check("pmululq-src", "PMULULQ", Instr{Args: []Operand{reg("Y0"), reg("X1")}}, false, false)
-	check("pmululq-source-error", "PMULULQ", Instr{Args: []Operand{ident("bad"), reg("X1")}}, true, true)
-	check("pmululq-memory", "PMULULQ", Instr{Args: []Operand{mem("AX"), reg("X1")}}, false, true)
+
+	checkDwordProduct := func(name string, ins Instr, wantErr bool) {
+		t.Helper()
+		typed, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+		typed.targetTriple = "x86_64-unknown-linux-gnu"
+		before, temporary := output.String(), typed.tmp
+		known, terminated, err := typed.lowerDwordToQwordMultiply("PMULULQ", ins)
+		if !known || terminated || (err != nil) != wantErr {
+			t.Fatalf("%s: typed dword product = (%v, %v, %v)", name, known, terminated, err)
+		}
+		if wantErr && (output.String() != before || typed.tmp != temporary) {
+			t.Fatalf("%s: invalid dword product mutated IR or temporary state", name)
+		}
+		if !wantErr && !strings.Contains(output.String(), "pmuludq") {
+			t.Fatalf("%s: original native m128 product opcode was lost", name)
+		}
+	}
+
+	checkDwordProduct("pmululq-args", Instr{Args: []Operand{reg("X0")}}, true)
+	checkDwordProduct("pmululq-dst", Instr{Args: []Operand{reg("X0"), reg("Y1")}}, true)
+	checkDwordProduct("pmululq-src", Instr{Args: []Operand{reg("Y0"), reg("X1")}}, true)
+	checkDwordProduct("pmululq-source-error", Instr{Args: []Operand{ident("bad"), reg("X1")}}, true)
+	checkDwordProduct("pmululq-memory", Instr{Args: []Operand{mem("AX"), reg("X1")}}, false)
+
 	check("punpckllq-args", "PUNPCKLLQ", Instr{Args: []Operand{reg("X0")}}, true, true)
 	check("punpckhlq-dst", "PUNPCKHLQ", Instr{Args: []Operand{reg("X0"), reg("Y1")}}, false, false)
 	check("punpckllq-src", "PUNPCKLLQ", Instr{Args: []Operand{reg("Y0"), reg("X1")}}, false, false)
 	check("punpckhlq-source-error", "PUNPCKHLQ", Instr{Args: []Operand{ident("bad"), reg("X1")}}, true, true)
 	check("punpckllq-memory", "PUNPCKLLQ", Instr{Args: []Operand{mem("AX"), reg("X1")}}, false, true)
+	for _, op := range []Op{"PMINUB", "PMINSB", "PMINUW", "PMINSW", "PMINUD", "PMINSD", "PMAXUB", "PMAXSB", "PMAXUW", "PMAXSW", "PMAXUD", "PMAXSD"} {
+		check(string(op)+"-args", op, Instr{Args: []Operand{reg("X0")}}, true, true)
+		invalid := Instr{Args: []Operand{reg("X0"), reg("Y1")}}
+		rejected, rejectionIR := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+		before := rejectionIR.String()
+		known, terminated, err := rejected.lowerVec(op, invalid)
+		if !known || terminated || err == nil || rejectionIR.String() != before {
+			t.Fatalf("%s-dst: invalid legacy width must reject before emitting IR: known=%v terminated=%v err=%v", op, known, terminated, err)
+		}
+		check(string(op)+"-source", op, Instr{Args: []Operand{ident("bad"), reg("X1")}}, true, true)
+		// The private format emitter retains the original native m128 opcode;
+		// this test must supply its actual x86 target, not virtual storage.
+		previousTarget := c.targetTriple
+		c.targetTriple = "x86_64-unknown-linux-gnu"
+		check(string(op)+"-memory", op, Instr{Args: []Operand{mem("AX"), reg("X1")}}, false, true)
+		c.targetTriple = previousTarget
+	}
+	for _, op := range []Op{"PSLLQ", "PSRLQ"} {
+		check(string(op)+"-args", op, Instr{Args: []Operand{imm(1)}}, true, true)
+		check(string(op)+"-dst", op, Instr{Args: []Operand{imm(1), reg("Y1")}}, false, false)
+		check(string(op)+"-count", op, Instr{Args: []Operand{reg("AX"), reg("X1")}}, true, true)
+		check(string(op)+"-negative", op, Instr{Args: []Operand{imm(-1), reg("X1")}}, true, true)
+	}
 
 	check("xorpd-args", "VXORPD", Instr{Args: []Operand{reg("X0")}}, true, true)
 	check("xorpd-z", "VXORPD", Instr{Args: []Operand{reg("Z0"), reg("Z1"), reg("Z2")}}, false, true)
@@ -140,11 +145,11 @@ func TestAMD64VectorLoweringBranchCoverage(t *testing.T) {
 	check("xorpd-x", "VXORPD", Instr{Args: []Operand{reg("X0"), reg("X1"), reg("X2")}}, false, true)
 	check("xorpd-x-source1", "VXORPD", Instr{Args: []Operand{ident("bad"), reg("X1"), reg("X2")}}, true, true)
 	check("xorpd-x-source2", "VXORPD", Instr{Args: []Operand{reg("X0"), ident("bad"), reg("X2")}}, true, true)
-	check("xorpd-unsupported-dst", "VXORPD", Instr{Args: []Operand{reg("X0"), reg("X1"), reg("AX")}}, false, false)
+	check("xorpd-unsupported-dst", "VXORPD", Instr{Args: []Operand{reg("X0"), reg("X1"), reg("AX")}}, true, true)
 
-	check("ternlog-y-source1-class", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), reg("X0"), reg("Y1"), reg("Y2")}}, false, false)
-	check("ternlog-y-source2-class", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), reg("Y0"), reg("X1"), reg("Y2")}}, false, false)
-	check("ternlog-y-imm", "VPTERNLOGD", Instr{Args: []Operand{imm(0x95), reg("Y0"), reg("Y1"), reg("Y2")}}, true, true)
+	check("ternlog-y-source1-class", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), reg("X0"), reg("Y1"), reg("Y2")}}, true, true)
+	check("ternlog-y-source2-class", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), reg("Y0"), reg("X1"), reg("Y2")}}, true, true)
+	check("ternlog-y-imm", "VPTERNLOGD", Instr{Args: []Operand{imm(0x95), reg("Y0"), reg("Y1"), reg("Y2")}}, false, true)
 	check("ternlog-y-source1", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), ident("bad"), reg("Y1"), reg("Y2")}}, true, true)
 	check("ternlog-y-source2", "VPTERNLOGD", Instr{Args: []Operand{imm(0x96), reg("Y0"), ident("bad"), reg("Y2")}}, true, true)
 
diff --git a/amd64_ordering_hint_family_test.go b/amd64_ordering_hint_family_test.go
new file mode 100644
index 000000000..fbec94b34
--- /dev/null
+++ b/amd64_ordering_hint_family_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"bytes"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent complete Go ynone rows, not an implementation-spec projection.
+var x86OrderingHintOracleRows = []struct {
+	op           Op
+	registration string
+	machine      []byte
+}{
+	{"LFENCE", "{ALFENCE, ynone, Pm, opBytes{0xae, 0xe8}}", []byte{0x0f, 0xae, 0xe8}},
+	{"MFENCE", "{AMFENCE, ynone, Pm, opBytes{0xae, 0xf0}}", []byte{0x0f, 0xae, 0xf0}},
+	{"SFENCE", "{ASFENCE, ynone, Pm, opBytes{0xae, 0xf8}}", []byte{0x0f, 0xae, 0xf8}},
+	{"PAUSE", "{APAUSE, ynone, Px, opBytes{0xf3, 0x90}}", []byte{0xf3, 0x90}},
+}
+
+func TestX86OrderingHintsHaveExactEmptySourceEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86OrderingHintOracleRows {
+			t.Run(arch+"/"+string(row.op), func(t *testing.T) {
+				ins := Instr{Op: row.op}
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatalf("zero-operand instruction lacks exact no-output/no-flags source effect: %+v/%t/%v", effect, known, err)
+				}
+				move, suffix := Op("MOVQ"), "Q"
+				if arch == "386" {
+					move, suffix = "MOVL", "L"
+				}
+				if !x86SourceStackInstructionKnown(ins, move, suffix, arch) {
+					t.Fatal("valid typed instruction has an unregistered source-stack effect")
+				}
+				result := x86ResultState{flags: x86ByteFlagsAll}
+				before := result
+				if !x86ResultTransfer(ins, &result, nil, 0, arch) || !reflect.DeepEqual(before, result) {
+					t.Fatal("exact no-output instruction changed result initialization/flags")
+				}
+				caller := x86SourceStackState{numericFlags: true, known: map[Reg]uint8{AX: 0xff}}
+				flags, valid := x86CallerScalarStep(&ins, &caller, nil)
+				if !valid || flags || !caller.numericFlags || caller.known[AX] != 0xff {
+					t.Fatal("exact no-output instruction changed caller facts")
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrderingHintsActualInstructionsNotNoops(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86OrderingHintOracleRows {
+			t.Run(arch+"/"+string(row.op), func(t *testing.T) {
+				source := "TEXT fence(SB),4,$0-0\n" + string(row.op) + "\nRET\n"
+				actual := x86OrderingHintGoBytes(t, arch, source)
+				want := append(append([]byte(nil), row.machine...), 0xc3)
+				if !bytes.Equal(actual, want) {
+					t.Fatalf("actual Go encoding %x, want %x", actual, want)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				start := output.Len()
+				known, terminated, err := ctx.lowerArith(row.op, file.Funcs[0].Instrs[1])
+				if !known || terminated || err != nil {
+					t.Fatal("accepted complete zero-operand form", err)
+				}
+				if !strings.Contains(output.String()[start:], "asm sideeffect \""+strings.ToLower(string(row.op))+"\"") {
+					t.Fatal("actual ordering/hint instruction became a software no-op")
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrderingHintsIllegalOperandsRejectBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86OrderingHintOracleRows {
+			for _, argument := range []string{"AX", "(AX)", "$1", "AX,DX"} {
+				t.Run(arch+"/"+string(row.op)+"/"+argument, func(t *testing.T) {
+					source := "TEXT fence(SB),4,$0-0\n" + string(row.op) + " " + argument + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerArith(row.op, file.Funcs[0].Instrs[1])
+					if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+						t.Fatalf("illegal operand did not fail before emission: %t/%t/%v", known, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_ordering_hint_forms.go b/amd64_ordering_hint_forms.go
new file mode 100644
index 000000000..1284bdb0e
--- /dev/null
+++ b/amd64_ordering_hint_forms.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86OrderingHintSpec struct {
+	native string
+}
+
+// The complete Go ynone axis has no explicit or implicit data operands.
+// Hardware ordering/hint execution is not a source-memory permission.
+var x86OrderingHintSpecs = map[Op]x86OrderingHintSpec{
+	"LFENCE": {native: "lfence"},
+	"MFENCE": {native: "mfence"},
+	"SFENCE": {native: "sfence"},
+	"PAUSE":  {native: "pause"},
+}
+
+func x86OrderingHintProperties(op Op, ins Instr, arch string) (x86OrderingHintSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86OrderingHintSpecs[Op(name)]
+	if !known {
+		return x86OrderingHintSpec{}, false, nil
+	}
+	if dotted || arch != "386" && arch != "amd64" || len(ins.Args) != 0 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s requires its exact zero-operand Go ordering/hint form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func (c *amd64Ctx) lowerX86OrderingHint(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86OrderingHintProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	// Conservative compiler memory scheduling is separate from architectural
+	// semantics: these instructions have no source data or arithmetic outputs.
+	// A litmus sample is not a proof of the hardware memory model.
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", spec.native, "~{memory}")
+	return true, false, nil
+}
diff --git a/amd64_ordering_hint_linux_amd64_test.go b/amd64_ordering_hint_linux_amd64_test.go
new file mode 100644
index 000000000..0b92421ce
--- /dev/null
+++ b/amd64_ordering_hint_linux_amd64_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Required Linux/amd64 CI runs the actual static ELF32 objects directly. The
+// host/ELF checks reject emulation; no local Rosetta run establishes this axis.
+func TestCrossLinuxRuntimeMatrixX86OrderingHintsNative386(t *testing.T) {
+	declarations, assembly, driver, reference := x86OrderingHintRuntimeFixture(32)
+	x86OrderingHintNative386(t, declarations, assembly, driver, reference)
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawNOPNative386(t *testing.T) {
+	declarations, assembly, driver, reference := x86RawNOPRuntimeFixture(32)
+	x86OrderingHintNative386(t, declarations, assembly, driver, reference)
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawNOPOriginalAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	declarations, assembly, driver, _ := x86RawNOPRuntimeFixture(64)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "amd64", declarations, assembly, driver)
+	if output := x86FloatCompareCaptureCommand(t, exec.Command(original)); string(output) != "original ordering observations 256\n" {
+		t.Fatalf("actual original Go AMD64 NOP state/no-memory oracle: %q", output)
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+func x86OrderingHintNative386(t *testing.T, declarations, assembly, driver, reference string) {
+	t.Helper()
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required native IA32 static C compiler:", err)
+	}
+	dir := t.TempDir()
+	original := x86OrderingHintBuildOriginal(t, dir, "linux", "386", declarations, assembly, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "original ordering observations 256\n" {
+		t.Fatalf("unchanged original Go IA32 ordering/status/canary oracle: %q", output)
+	}
+	ir, err := x86OrderingHintTranslateAPI(t, "Go", assembly, declarations, "386", "i386-unknown-linux-gnu")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := filepath.Join(dir, "ordering"+level+".ll")
+			object := filepath.Join(dir, "ordering"+level+".o")
+			main, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "ordering"+level)
+			for name, contents := range map[string]string{input: ir, main: reference} {
+				if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(llc, level,
+				"-mtriple=i386-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+			x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie",
+				object, main, "-O2", "-o", executable))
+			sealed, err := x87IA32StaticExecutable(executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "ordering observations 256\n" {
+				t.Fatalf("LLVM IA32 GP/six-status-flags/MXCSR/canary oracle: %q", output)
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_ordering_hint_rule_consumers_test.go b/amd64_ordering_hint_rule_consumers_test.go
new file mode 100644
index 000000000..3117ec89a
--- /dev/null
+++ b/amd64_ordering_hint_rule_consumers_test.go
@@ -0,0 +1,241 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+var x86OrderingHintTargets = []struct{ arch, triple string }{
+	{"amd64", "x86_64-apple-darwin"},
+	{"amd64", "x86_64-unknown-linux-gnu"},
+	{"amd64", "x86_64-pc-windows-msvc"},
+	{"386", "i386-unknown-linux-gnu"},
+	{"386", "i686-pc-windows-msvc"},
+}
+
+func x86OrderingHintGoBytes(t *testing.T, arch, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "asm", "-S", "-p", "ordering", "-o", object, input)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch, "GOFLAGS=")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, arch); failure != nil {
+		t.Fatalf("actual original Go object: %v\n%s", failure, output)
+	}
+	var code []byte
+	for _, line := range strings.Split(string(output), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, encoded, err := goAssemblyListingByteRow(line)
+		if err != nil || offset != len(code) {
+			t.Fatalf("noncontiguous original object listing: %s", line)
+		}
+		code = append(code, encoded...)
+	}
+	if len(code) == 0 {
+		t.Fatal("actual original object listing lacks complete bytes")
+	}
+	return code
+}
+
+func TestX86OrderingHintsCompleteGoRowsAndDispatch(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") || len(x86OrderingHintSpecs) != 4 {
+		t.Fatal("complete Go zero-operand family changed")
+	}
+	for _, row := range x86OrderingHintOracleRows {
+		if !strings.Contains(string(table), row.registration) {
+			t.Fatal("complete Go ordered row changed", row.registration)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			for _, identity := range []Op{"", row.op, Op(strings.ToLower(string(row.op))), "MOVQ", Op(string(row.op) + ".BAD")} {
+				t.Run(arch+"/"+string(row.op)+"/identity="+string(identity), func(t *testing.T) {
+					ins := Instr{Op: identity}
+					ctx, out := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := out.String(), ctx.tmp
+					registers := fmt.Sprint(ctx.usedRegs)
+					known, terminated, err := ctx.lowerX86OrderingHint(row.op, ins)
+					invalid := identity != "" && !strings.EqualFold(string(identity), string(row.op))
+					if !known || terminated || (err != nil) != invalid || invalid && (before != out.String() || temporary != ctx.tmp) {
+						t.Fatal("identity rejection/emission boundary", identity, err)
+					}
+					if fmt.Sprint(ctx.usedRegs) != registers {
+						t.Fatal("zero-operand source introduced implicit data registers", ctx.usedRegs)
+					}
+				})
+			}
+			for _, suffix := range []string{".Z", ".SAE", ".BCST", ".BAD"} {
+				ins := Instr{Op: Op(string(row.op) + suffix)}
+				if _, known, err := x86OrderingHintProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Fatal("invalid suffix was not closed", ins, err)
+				}
+			}
+		}
+		for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+			if _, known, err := x86OrderingHintProperties(row.op, Instr{Op: row.op}, arch); !known || err == nil {
+				t.Fatal("unrelated architecture admitted an x86 form", arch, err)
+			}
+		}
+	}
+	ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+	before := output.String()
+	if known, terminated, err := ctx.lowerX86OrderingHint("UNKNOWN", Instr{}); known || terminated || err != nil || before != output.String() {
+		t.Fatal("unknown dispatch emitted a default instruction")
+	}
+}
+
+func x86OrderingHintTranslateAPI(t *testing.T, api, source, declarations, arch, triple string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "ordering", declarations)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: resolve})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return translated.Module.String(), nil
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return module.String(), nil
+}
+
+func TestX86OrderingHintsThreeAPIsFiveTargetNativeObjects(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, raw := range []bool{false, true} {
+			var source, declarations strings.Builder
+			declarations.WriteString("package ordering\n")
+			for _, row := range x86OrderingHintOracleRows {
+				name := strings.ToLower(string(row.op))
+				fmt.Fprintf(&declarations, "func %s()\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", name)
+				if raw {
+					for _, value := range row.machine {
+						fmt.Fprintf(&source, "BYTE $%d\n", value)
+					}
+				} else {
+					fmt.Fprintln(&source, row.op)
+				}
+				source.WriteString("RET\n")
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", target.triple, raw, api), func(t *testing.T) {
+					ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						dir := t.TempDir()
+						input, object := filepath.Join(dir, "ordering.ll"), filepath.Join(dir, "ordering.o")
+						if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+							t.Fatal(err)
+						}
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", "-o", object, input))
+						disassembly := x86FloatCompareCaptureCommand(t, exec.Command(disassembler, "--disassemble", "--no-show-raw-insn", object))
+						for _, row := range x86OrderingHintOracleRows {
+							count := 0
+							for _, line := range strings.Split(string(disassembly), "\n") {
+								fields := strings.Fields(line)
+								if len(fields) == 2 && strings.HasSuffix(fields[0], ":") && fields[1] == strings.ToLower(string(row.op)) {
+									count++
+								}
+							}
+							if count != 1 {
+								t.Fatalf("%s object lost or duplicated native %s: count=%d\n%s", level, row.op, count, disassembly)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawPrefixThreeAPIClassification(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, row := range []struct {
+			name    string
+			code    []byte
+			context bool
+		}{
+			{"invalid even with later ignored override", []byte{0xf0, 0x66, 0x0f, 0x31}, false},
+			{"valid LOCK atomic effect unbound", []byte{0xf0, 0x01, 0x08}, true},
+			{"legal ignored prefix", []byte{0x66, 0x66, 0x0f, 0x31}, false},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := "TEXT ·prefix(SB),4,$0-0\n" + x86RawDisplacementDirectives(row.code) + "RET\n"
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc prefix()\n", target.arch, target.triple)
+					if row.name == "legal ignored prefix" {
+						if err != nil || !strings.Contains(ir, "asm sideeffect \"rdtsc\"") {
+							t.Fatal("legal ignored prefix lost its actual instruction", err)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "ignored.ll", "ignored.o", ir)
+					} else if err == nil || ir != "" || errors.Is(err, ErrProbeNeedsContext) != row.context {
+						t.Fatalf("invalid versus valid-unbound prefix classification: IR=%q/error=%v", ir, err)
+					}
+				})
+			}
+		}
+	}
+	physical, err := x86asm.Decode([]byte{0xf0, 0x0f, 0x31}, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	physical.Prefix[0] |= x86asm.PrefixIgnored
+	if err := decodedX86PrefixError(physical); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("synthetic Invalid|Ignored metadata tripwire washed invalidity", err)
+	}
+}
diff --git a/amd64_ordering_hint_runtime_test.go b/amd64_ordering_hint_runtime_test.go
new file mode 100644
index 000000000..3e437284f
--- /dev/null
+++ b/amd64_ordering_hint_runtime_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"debug/pe"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86OrderingHintsOriginalWindowsExecutable(t *testing.T) {
+	declarations, assembly, driver, _ := x86OrderingHintRuntimeFixture(64)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "windows", "amd64", declarations, assembly, driver)
+	if filepath.Ext(original) != ".exe" {
+		t.Fatal("Windows original oracle requires its exact executable suffix", original)
+	}
+	object, err := pe.Open(original)
+	if err != nil {
+		t.Fatal("actual Windows oracle executable", err)
+	}
+	defer object.Close()
+	if object.Machine != pe.IMAGE_FILE_MACHINE_AMD64 || object.Characteristics&pe.IMAGE_FILE_EXECUTABLE_IMAGE == 0 {
+		t.Fatal("original Windows oracle is not an AMD64 executable")
+	}
+}
+
+// These observations establish exact GP, six status bits and MXCSR retention,
+// not an empirical proof of the architecture's concurrent memory model.
+func TestCrossLinuxRuntimeMatrixX86OrderingHintsOriginalAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, assembly, driver, reference := x86OrderingHintRuntimeFixture(64)
+	dir := t.TempDir()
+	original := x86OrderingHintBuildOriginal(t, dir, runtime.GOOS, "amd64", declarations, assembly, driver)
+	if output := execution.run(t, original); string(output) != "original ordering observations 256\n" {
+		t.Fatalf("actual original Go ordering/status/canary oracle: %q", output)
+	}
+	t.Log("256 original Go observations: four instructions, two complementary six-bit seeds, 32 repetitions")
+	ir := x86NarrowOracleIR(t, assembly, declarations, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "ordering", ir, reference, level)
+			if string(output) != "ordering observations 256\n" {
+				t.Fatalf("independent GP/full-status/MXCSR/canary oracle: %q", output)
+			}
+			t.Log("256 independent LLVM observations: five GPs, six status flags, MXCSR and canary")
+		})
+	}
+}
+
+func x86OrderingHintBuildOriginal(t *testing.T, dir, goos, arch, declarations, assembly, driver string) string {
+	t.Helper()
+	for name, contents := range map[string]string{
+		"go.mod":  "module ordering\n\ngo 1.20\n",
+		"decl.go": declarations, "ordering_" + arch + ".s": assembly,
+		"main.go": driver,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	if goos == "windows" {
+		executable += ".exe"
+	}
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin/go"), "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch,
+		"CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	return executable
+}
+
+func TestX86OrderingHintsOriginal386StaticELFCompileOnly(t *testing.T) {
+	declarations, assembly, driver, _ := x86OrderingHintRuntimeFixture(32)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386", declarations, assembly, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual original Go IA32 ELF bytes=%d SHA256=%x; compile only, required native execution is separate",
+		sealed.size, sealed.hash)
+}
+
+// The independent reference constants never come from the production spec.
+// Each sample resets every output byte and both complementary status seeds.
+func x86OrderingHintRuntimeFixture(bits int) (declarations, assembly, driver, reference string) {
+	word, suffix, pop, push := "uint64", "Q", "POPFQ", "PUSHFQ"
+	values := []string{"0x123456789abcdef0", "0x2468ace013579bdf", "0x3141592653589793", "0x7e6d5c4b3a291807", "0xa1b2c3d4e5f60718"}
+	canary := "0x13579bdf2468ace0"
+	if bits == 32 {
+		word, suffix, pop, push = "uint32", "L", "POPFL", "PUSHFL"
+		values = []string{"0x9abcdef0", "0x13579bdf", "0x53589793", "0x3a291807", "0xe5f60718"}
+		canary = "0x2468ace0"
+	}
+	var decl, asm, names strings.Builder
+	decl.WriteString("package main\n")
+	step := bits / 8
+	for _, op := range []string{"LFENCE", "MFENCE", "SFENCE", "PAUSE"} {
+		for index, seed := range []uint64{0x8c7, 0x12} {
+			name := fmt.Sprintf("%s_%d", strings.ToLower(op), index)
+			fmt.Fprintf(&decl, "func %s(out *[8]%s)\n", name, word)
+			fmt.Fprintf(&names, "%s,\n", name)
+			fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n", name, step, suffix)
+			for r, reg := range []string{"AX", "BX", "CX", "DX", "SI"} {
+				fmt.Fprintf(&asm, "MOV%s $%s,%s\n", suffix, values[r], reg)
+			}
+			fmt.Fprintf(&asm, "PUSH%s $%d\n%s\n%s\n", suffix, seed, pop, op)
+			for r, reg := range []string{"AX", "BX", "CX", "DX", "SI"} {
+				fmt.Fprintf(&asm, "MOV%s %s,%d(DI)\n", suffix, reg, r*step)
+			}
+			fmt.Fprintf(&asm, "%s\nPOP%s SI\nMOV%s SI,%d(DI)\nSTMXCSR %d(DI)\nRET\n", push, suffix, suffix, 5*step, 6*step)
+		}
+	}
+	decl.WriteString("func csr() uint32\n")
+	asm.WriteString("TEXT ·csr(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\n")
+	driver = fmt.Sprintf(`package main
+
+import (
+    "fmt"
+    "runtime"
+)
+
+func main() {
+    runtime.LockOSThread()
+    samples := []func(*[8]%s){
+        %s
+    }
+    want := [5]%s{%s}
+    seeds := [2]%s{0x8c7, 0x12}
+    observations := 0
+    for index, sample := range samples {
+        for iteration := 0; iteration < 32; iteration++ {
+            out := [8]%s{0, 0, 0, 0, 0, 0, 0, %s}
+            before := csr()
+            sample(&out)
+            after := csr()
+            for register := 0; register < 5; register++ {
+                if out[register] != want[register] {
+                    panic(fmt.Sprintf("original GP kernel=%%d register=%%d out=%%x", index, register, out))
+                }
+            }
+            if out[5]&0x8d5 != seeds[index%%2]&0x8d5 ||
+                    out[6] != %s(before) || after != before || out[7] != %s {
+                panic(fmt.Sprintf("original status/CSR/canary kernel=%%d out=%%x before=%%x after=%%x", index, out, before, after))
+            }
+            observations++
+        }
+    }
+    fmt.Printf("original ordering observations %%d\n", observations)
+}
+`, word, names.String(), word, strings.Join(values, ", "), word, word, canary, word, canary)
+	var prototypes strings.Builder
+	for _, op := range []string{"lfence", "mfence", "sfence", "pause"} {
+		for index := 0; index < 2; index++ {
+			fmt.Fprintf(&prototypes, "extern void %s_%d(%s_t *);\n", op, index, word)
+		}
+	}
+	reference = fmt.Sprintf(`
+#include <stdint.h>
+#include <stdio.h>
+
+%s
+int main(void) {
+    void (*samples[])(%s_t *) = {
+        %s
+    };
+    const %s_t want[5] = {%s};
+    const %s_t seeds[2] = {0x8c7, 0x12};
+    unsigned observations = 0;
+    for (unsigned index = 0; index < 8; index++) {
+        for (unsigned iteration = 0; iteration < 32; iteration++) {
+            %s_t out[8] = {0, 0, 0, 0, 0, 0, 0, %s};
+            unsigned before, after;
+            __asm__ volatile("stmxcsr %%0" : "=m"(before));
+            samples[index](out);
+            __asm__ volatile("stmxcsr %%0" : "=m"(after));
+            for (unsigned reg = 0; reg < 5; reg++) {
+                if (out[reg] != want[reg]) {
+                    fprintf(stderr, "GP kernel=%%u register=%%u got=%%llx\n",
+                        index, reg, (unsigned long long)out[reg]);
+                    return 1;
+                }
+            }
+            if ((out[5] & 0x8d5) != (seeds[index %% 2] & 0x8d5) ||
+                    out[6] != before || after != before || out[7] != %s) {
+                fprintf(stderr, "status/CSR/canary kernel=%%u flags=%%llx CSR=%%llx/%%x/%%x\n",
+                    index, (unsigned long long)out[5], (unsigned long long)out[6], before, after);
+                return 2;
+            }
+            observations++;
+        }
+    }
+    printf("ordering observations %%u\n", observations);
+    return 0;
+}
+`, prototypes.String(), word, names.String(), word, strings.Join(values, ", "), word, word, canary, canary)
+	return decl.String(), asm.String(), driver, reference
+}
diff --git a/amd64_ordinary_move_address_runtime_test.go b/amd64_ordinary_move_address_runtime_test.go
new file mode 100644
index 000000000..c76e6b52f
--- /dev/null
+++ b/amd64_ordinary_move_address_runtime_test.go
@@ -0,0 +1,78 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The Go assembler owns the prologue and NAME_AUTO bias. A write through the
+// formed address, followed by a physical-SP read, distinguishes a misplaced
+// address even when an unrelated spill happens to contain the original input.
+func TestCrossLinuxRuntimeMatrixGoAMD64NamedLocalAddressBias(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	goAMD64FramePrepareOwnedToolCache(t)
+	var assembly, declarations, goCalls, cDeclarations, cCalls strings.Builder
+	prefix := ""
+	if strings.Contains(execution.triple, "apple") {
+		prefix = "_"
+	}
+	for index, address := range []string{"MOVQ $slot-16(SP),BX", "LEAQ slot-16(SP),BX"} {
+		name := fmt.Sprintf("Address%d", index)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$16-16\nMOVQ input+0(FP),AX\nMOVQ AX,0(SP)\n%s\nMOVQ $0x13579bdf2468ace0,CX\nMOVQ CX,(BX)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n", name, address)
+		fmt.Fprintf(&declarations, "func %s(input uint64) uint64\n", name)
+		fmt.Fprintf(&goCalls, "check(%d,%s)\n", index, name)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t address%d(uint64_t) __asm__(%s);\n", index,
+			runtimeCAsmLabel(prefix+"example.invalid/framefixture."+name))
+		fmt.Fprintf(&cCalls, "check(%d,address%d);\n", index, index)
+	}
+	original := `package main
+import "fmt"
+` + declarations.String() + `
+func check(index int, call func(uint64) uint64) {
+    for sample,input := range []uint64{0,1,0xffffffffffffffff,0x0123456789abcdef} {
+        got := call(input)
+        if got != 0x13579bdf2468ace0 { panic("original Go NAME_AUTO address differs from physical SP") }
+        fmt.Printf("%d %d %016x\n",index,sample,got)
+    }
+}
+func main(){
+` + goCalls.String() + "}\n"
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + runtimeCAsmLabelPreamble + cDeclarations.String() + `
+static void check(int index, uint64_t (*call)(uint64_t)) {
+    const uint64_t inputs[]={0,1,UINT64_MAX,UINT64_C(0x0123456789abcdef)};
+    for(unsigned sample=0; sample<4; sample++) {
+        printf("%d %u %016llx\n",index,sample,(unsigned long long)call(inputs[sample]));
+    }
+}
+int main(void){
+` + cCalls.String() + "return 0;}\n"
+	want := strings.TrimSpace(string(x86ScalarFloatIntegerOriginalOutput(t, execution, assembly.String(), original)))
+	if len(strings.Split(want, "\n")) != 8 {
+		t.Fatal("original Go did not execute both address forms and all four inputs", want)
+	}
+	t.Log("original Go executed original MOVQ and LEAQ with its actual native frame/prologue: 8 observations")
+	pkg, request, _, options := fixedLocalTransportFixture(t, assembly.String(), declarations.String(), runtime.GOOS+"/amd64", execution.triple)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil {
+			t.Fatal("same original source lost its captured private-frame contract", err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(level, func(t *testing.T) {
+				input := ir
+				if level == "-O2" {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				got := strings.TrimSpace(string(execution.compileAndRunLLVM(t, "named-local-address", input, driver, level)))
+				if got != want {
+					t.Errorf("original Go/LLVM named-address writeback differs:\nGo:\n%s\nLLVM:\n%s", want, got)
+				}
+			})
+		}
+	})
+}
diff --git a/amd64_ordinary_move_address_test.go b/amd64_ordinary_move_address_test.go
new file mode 100644
index 000000000..561332ff7
--- /dev/null
+++ b/amd64_ordinary_move_address_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestGoAMD64LocalAddressIgnoresUncertifiedAccessFields(t *testing.T) {
+	for _, source := range []string{"MOVQ $slot-16(SP),BX", "LEAQ slot-16(SP),BX"} {
+		// This is an isolated emitter-consumption counterexample, not an
+		// initialized native entry. The independent runtime owner captures
+		// and executes the complete actual Go source for both address forms.
+		emit := func(t *testing.T, stale string) string {
+			t.Helper()
+			ins := x86ScalarLaneInstruction(t, source)
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			proof := &x86FixedLocalProof{frame: 16, accesses: map[int]map[int]x86FixedLocalAccess{}}
+			ctx.fixedLocal = proof
+			if stale != "" {
+				shape, err := fixedLocalInstructionDigest(ins)
+				if err != nil {
+					t.Fatal(err)
+				}
+				access := x86FixedLocalAccess{owner: proof, shape: shape, width: 8, nativeInput: true}
+				if stale == "mismatched-record" {
+					expected := access
+					expected.nativeInput = false
+					proof.accesses[0] = map[int]x86FixedLocalAccess{0: expected}
+				}
+				ins.x86FixedLocalMemory = map[int]x86FixedLocalAccess{0: access}
+				if _, certified := ctx.fixedLocalMemoryAccess(ins, 0); certified {
+					t.Fatal("stale private fields unexpectedly authenticated themselves")
+				}
+			}
+			ctx.blocks = []amd64Block{{instrs: []Instr{ins}}}
+			if terminated, err := ctx.lowerInstr(0, 0, ins, nil, nil); terminated || err != nil {
+				t.Fatal("address-only emission borrowed an access contract", terminated, err)
+			}
+			if ctx.fixedMemRoles != nil {
+				t.Fatal("original-instruction address projection escaped its lifetime")
+			}
+			return output.String()
+		}
+		want := emit(t, "")
+		for _, stale := range []string{"missing-record", "mismatched-record"} {
+			t.Run(source+"/"+stale, func(t *testing.T) {
+				if got := emit(t, stale); got != want {
+					t.Error("unverified nativeInput changed address-only emission")
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalOriginalMoveAddressDomains(t *testing.T) {
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, old := range []uint8{0, 3, 0x55, 0xff} {
+			t.Run(fmt.Sprintf("%s/old%x", width, old), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "MOV"+width+" $slot-16(SP),BX")
+				original := fmt.Sprintf("%#v", ins)
+				state := x86FixedLocalState{pointers: map[Reg]int64{SP: 0, BX: 8}, known: map[Reg]uint8{BX: old},
+					opaque: map[Reg]x86FixedLocalOrigins{}, constants: map[Reg]int64{BX: 7}, booleans: map[Reg]uint8{}, flags: x86ByteFlagsAll}
+				proof := &x86FixedLocalProof{frame: 16}
+				if known, err := fixedLocalPrivateAddressStep(ins, &state, proof); !known || err != nil {
+					t.Fatal("original source address did not reach its existing private LEA consumer", known, err)
+				}
+				if original != fmt.Sprintf("%#v", ins) {
+					t.Fatal("source-address projection changed the original MOV identity")
+				}
+				value, pointer := state.pointers[BX]
+				want := old &^ 3
+				if width == "L" {
+					want = 0xf0
+				} else if width == "Q" {
+					want = 0
+				}
+				if pointer != (width == "Q") || pointer && value != 0 || state.known[BX] != want || state.flags != x86ByteFlagsAll ||
+					len(state.constants) != 0 || len(state.opaque) != 0 {
+					t.Fatal("partial address became NUM or retained a full pointer identity", state)
+				}
+			})
+		}
+		for _, control := range []string{"missing-proof", "changed-raw", "changed-operand", "physical-origin", "address-size", "SP-output", "unnamed-address", "unnamed-computed-address"} {
+			t.Run(width+"/"+control, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "MOV"+width+" $slot-16(SP),BX")
+				proof := &x86FixedLocalProof{frame: 16}
+				switch control {
+				case "missing-proof":
+					proof = nil
+				case "changed-raw":
+					ins.Raw = "MOV" + width + " $other-8(SP),BX"
+				case "changed-operand":
+					ins.Args[0].Sym = "$other-8(SP)"
+				case "physical-origin":
+					ins.x86Encoded = true
+				case "address-size":
+					ins.x86AddressBits = 32
+				case "SP-output":
+					ins = x86ScalarLaneInstruction(t, "MOV"+width+" $slot-16(SP),SP")
+				case "unnamed-address":
+					ins = x86ScalarLaneInstruction(t, "MOV"+width+" $8(SP),BX")
+				case "unnamed-computed-address":
+					ins = x86ScalarLaneInstruction(t, "MOV"+width+" $(1<<3)(SP),BX")
+				}
+				state := x86FixedLocalState{pointers: map[Reg]int64{SP: 0}, known: map[Reg]uint8{},
+					opaque: map[Reg]x86FixedLocalOrigins{}, constants: map[Reg]int64{}, booleans: map[Reg]uint8{}}
+				before := fmt.Sprintf("%#v", state)
+				known, err := fixedLocalPrivateAddressStep(ins, &state, proof)
+				if known && !errors.Is(err, ErrProbeNeedsContext) || !reflect.DeepEqual(fmt.Sprintf("%#v", state), before) {
+					t.Fatal("missing/changed source or physical role supplied address permission", known, err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalOriginalMoveAddressLiveUses(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, use := range []string{"dereference", "numeric", "escape", "out-of-bounds", "uninitialized-local"} {
+			t.Run(width+"/"+use, func(t *testing.T) {
+				address, initialization := "slot-16", "MOVQ AX,0(SP)\n"
+				tail := "MOVQ (BX),AX\nMOVQ AX,ret+8(FP)\n"
+				switch use {
+				case "numeric":
+					tail = "ADDQ BX,0(SP)\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\n"
+				case "escape":
+					tail = "MOVQ BX,ret+8(FP)\n"
+				case "out-of-bounds":
+					address = "slot+8"
+				case "uninitialized-local":
+					initialization = ""
+				}
+				source := "TEXT ·AddressUse(SB),4,$16-16\nMOVQ input+0(FP),AX\nMOVQ $0,BX\n" + initialization +
+					"MOV" + width + " $" + address + "(SP),BX\n" + tail + "RET\n"
+				declaration := "func AddressUse(input uint64) uint64\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				pkg, request, _, options := x86CMOVFixedLocalFixture(t, source, declaration, "linux/amd64", "x86_64-unknown-linux-gnu")
+				if width == "Q" && use == "dereference" {
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+						if err != nil || ir == "" {
+							t.Fatal("original full-width MOV lost its independently bounded initialized private pointer", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, level)
+						}
+					})
+					return
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				captured, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer func() {
+					if err := captured.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+				expanded, err := captured.preprocess(request.AssemblyFile, []byte(source))
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, expanded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := captured.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original named address acquired absent bytes, numeric bits, escaped pointer or out-of-bounds storage", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_ordinary_move_fp_address_test.go b/amd64_ordinary_move_fp_address_test.go
new file mode 100644
index 000000000..fb8659fd3
--- /dev/null
+++ b/amd64_ordinary_move_fp_address_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86OrdinaryMoveFPAddressFixture(arch, width, address string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if word == 4 {
+		move = "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·FPAddress(SB),4,$0-%d\n%s input+0(FP),AX\nMOV%s %s,BX\n"+
+			"%s $0,BX\n%s AX,ret+%d(FP)\nRET\n", 2*word, move, width, address, move, move, word),
+		"func FPAddress(input uintptr) uintptr\n"
+}
+
+func TestX86OrdinaryMoveNamedFPAddressObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	observations := 0
+	for _, target := range x86RawReturnTargets {
+		for _, width := range []string{"W", "L", "Q"} {
+			if target.arch == "386" && width == "Q" {
+				continue // Independently rejected by the grammar owner below.
+			}
+			t.Run(target.triple+"/"+width, func(t *testing.T) {
+				source, declaration := x86OrdinaryMoveFPAddressFixture(target.arch, width, "$input+0(FP)")
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("dead address of an independently typed scalar field rejected", api, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				}
+			})
+			observations++
+		}
+	}
+	if observations != 13 {
+		t.Fatal("complete mode/target FP-address object partition changed", observations)
+	}
+}
+
+func TestX86OrdinaryMoveNamedFPAddressSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			for _, control := range []string{"numeric-FP", "punctuated-FP", "register-FP", "outside-field", "changed-Raw", "changed-operand", "changed-name", "physical-origin", "address-as-number"} {
+				t.Run(arch+"/"+width+"/"+control, func(t *testing.T) {
+					address := "$input+0(FP)"
+					if control == "numeric-FP" {
+						address = "$0(FP)"
+					} else if control == "punctuated-FP" {
+						address = "$pkg.值+0(FP)"
+					} else if control == "register-FP" {
+						address = "$AX+0(FP)"
+					} else if control == "outside-field" {
+						address = "$input+32(FP)"
+					}
+					source, declaration := x86OrdinaryMoveFPAddressFixture(arch, width, address)
+					if control == "address-as-number" {
+						move, word := "MOVQ", goWordSize(arch)
+						if word == 4 {
+							move = "MOVL"
+						}
+						source = strings.Replace(source, "MOV"+width+" ", move+" $0,BX\nMOV"+width+" ", 1)
+						source = strings.Replace(source, "\n"+move+" $0,BX\n"+move+" AX,ret+", "\n"+move+" BX,ret+", 1)
+					}
+					invalidName := control == "numeric-FP" || control == "punctuated-FP" || control == "register-FP"
+					accepted := !invalidName && !(arch == "386" && width == "Q")
+					observed := source
+					if arch == "386" && width == "Q" {
+						// The existing frame-diagnostic observer deliberately models
+						// one focused instruction and stack steps. Keep this exact
+						// original MOV in that closed context; Go reports its LEAQ
+						// rewrite with PARAM bias +4, rather than the source opcode.
+						observed = "TEXT ·FPAddress(SB),4,$0-8\nMOVQ " + address + ",BX\nRET\n"
+					}
+					goAssemblerOracleOutput(t, arch, observed, "", accepted)
+					ins := x86ScalarLaneInstruction(t, "MOV"+width+" "+address+",BX")
+					original := fmt.Sprintf("%#v", ins)
+					switch control {
+					case "changed-Raw":
+						ins.Raw = "MOV" + width + " $input+8(FP),BX"
+					case "changed-operand":
+						ins.Args[0].FPOffset = 8
+					case "changed-name":
+						ins.Args[0].FPName = "other"
+					case "physical-origin":
+						ins.x86Encoded = true
+					}
+					view, known, err := x86NamedFrameMoveAddressInstruction(ins, arch)
+					if control != "outside-field" && control != "address-as-number" && known && err == nil {
+						t.Error("invalid/changed FP spelling or physical role became a named address", view)
+					}
+					if invalidName || control == "outside-field" || control == "address-as-number" || arch == "386" && width == "Q" {
+						for _, api := range []string{"text", "module", "Go"} {
+							if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86AddressMemoryTargets(arch)[0], api); err == nil || ir != "" {
+								t.Error("invalid/unmapped/mode32-Q FP address produced public IR", api, len(ir), err)
+							}
+						}
+					}
+					if control == "outside-field" && original != fmt.Sprintf("%#v", ins) {
+						t.Fatal("source-only address projection mutated original instruction")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FixedLocalAddressOnlyBareNamesBatch(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range []string{"LEAW", "LEAL", "LEAQ", "MOVW", "MOVL", "MOVQ"} {
+		for _, name := range []string{"slot", "δοκιμή", "槽"} {
+			symbol := fmt.Sprintf("BareAddress%d", count)
+			address := name + "(SP)"
+			if strings.HasPrefix(op, "MOV") {
+				address = "$" + address
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$16-16\nMOVQ input+0(FP),AX\nMOVQ AX,0(SP)\n"+
+				"%s %s,BX\nMOVQ $0,BX\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n", symbol, op, address)
+			fmt.Fprintf(&declarations, "func %s(input uint64) uint64\n", symbol)
+			count++
+		}
+	}
+	if count != 18 {
+		t.Fatal("complete address-family/width/name inventory changed", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	triple := "x86_64-unknown-linux-gnu"
+	pkg, request, _, options := x86CMOVFixedLocalFixture(t, source.String(), declarations.String(), "linux/amd64", triple)
+	fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+		if err != nil || ir == "" {
+			t.Fatal("original bounded bare AUTO addresses were rejected", err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, triple, ir, level)
+		}
+	})
+}
+
+func TestX86OrdinaryMoveFrameAddressUnicodeNames(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range []string{"参数", "δοκιμή", "pkg·值"} {
+			t.Run(arch+"/FP/"+name, func(t *testing.T) {
+				source, declaration := x86OrdinaryMoveFPAddressFixture(arch, "W", "$"+name+"+0(FP)")
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				ins := x86ScalarLaneInstruction(t, "MOVW $"+name+"+0(FP),BX")
+				original := fmt.Sprintf("%#v", ins)
+				view, known, err := x86NamedFrameMoveAddressInstruction(ins, arch)
+				if !known || err != nil || view.Args[0].FPName != name || original != fmt.Sprintf("%#v", ins) {
+					t.Error("legitimate Go FP symbol or original identity was lost", known, err, view)
+				}
+				triple := x86AddressMemoryTargets(arch)[0]
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("legitimate Unicode FP address rejected", api, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				}
+			})
+		}
+	}
+	for _, name := range []string{"槽-16", "δοκιμή"} {
+		t.Run("amd64/AUTO/"+name, func(t *testing.T) {
+			source := "TEXT ·UnicodeAuto(SB),4,$16-16\nMOVQ input+0(FP),AX\nMOVQ AX,0(SP)\n" +
+				"MOVW $" + name + "(SP),BX\nMOVQ $0,BX\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			declaration := "func UnicodeAuto(input uint64) uint64\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			triple := "x86_64-unknown-linux-gnu"
+			pkg, request, _, options := x86CMOVFixedLocalFixture(t, source, declaration, "linux/amd64", triple)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil || ir == "" {
+					t.Fatal("legitimate Unicode AUTO address rejected", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		})
+	}
+}
diff --git a/amd64_original_go_build_only_test.go b/amd64_original_go_build_only_test.go
new file mode 100644
index 000000000..3295e709f
--- /dev/null
+++ b/amd64_original_go_build_only_test.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+import "testing"
+
+func TestX86PackedIntegerCompareBuildOnlyNeverExecutesTestMain(t *testing.T) {
+	const declaration = "package oracle\nfunc LinkedAssembly()\n"
+	const assembly = "TEXT ·LinkedAssembly(SB),4,$0-0\nRET\n"
+	const source = `package oracle
+
+import (
+    "os"
+    "testing"
+)
+
+func TestMain(m *testing.M) {
+    os.Exit(97)
+}
+
+func TestRequiresAssemblyLink(t *testing.T) {
+    LinkedAssembly()
+}
+`
+	// Even -run=^$ executes TestMain and process initialization. A compile/link
+	// owner must never run either, on the host or through a cross executor.
+	x86PackedIntegerCompareOriginalGoDriver(t, declaration, assembly, source, true)
+}
diff --git a/amd64_original_go_executable_test.go b/amd64_original_go_executable_test.go
new file mode 100644
index 000000000..57915671c
--- /dev/null
+++ b/amd64_original_go_executable_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"debug/buildinfo"
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"testing"
+)
+
+// Go20's test binaries omit BuildSettings. Require the actual executable
+// machine header on every SDK, not optional GOARCH string metadata. This reads
+// only the linked artifact and never starts its process or initializers.
+func x86OriginalGoLinkedAMD64(name string) (amd64 bool, result error) {
+	file, err := os.Open(name)
+	if err != nil {
+		return false, err
+	}
+	defer func() {
+		if err := file.Close(); err != nil {
+			amd64, result = false, errors.Join(result, err)
+		}
+	}()
+	info, err := buildinfo.Read(file)
+	if err != nil || info.GoVersion != runtime.Version() {
+		return false, fmt.Errorf("linked executable SDK differs: %v, %v", info, err)
+	}
+	var magic [4]byte
+	if _, err := file.ReadAt(magic[:], 0); err != nil {
+		return false, err
+	}
+	switch string(magic[:]) {
+	case "\x7fELF":
+		image, err := elf.NewFile(file)
+		if err != nil {
+			return false, err
+		}
+		return image.Machine == elf.EM_X86_64 && image.Class == elf.ELFCLASS64 &&
+			image.Data == elf.ELFDATA2LSB && image.Entry != 0 &&
+			(image.Type == elf.ET_EXEC || image.Type == elf.ET_DYN), nil
+	case "\xcf\xfa\xed\xfe", "\xce\xfa\xed\xfe":
+		image, err := macho.NewFile(file)
+		if err != nil {
+			return false, err
+		}
+		return image.Cpu == macho.CpuAmd64 && image.Type == macho.TypeExec, nil
+	default:
+		if string(magic[:2]) != "MZ" {
+			return false, fmt.Errorf("unknown linked executable magic %x", magic)
+		}
+		image, err := pe.NewFile(file)
+		if err != nil {
+			return false, err
+		}
+		header, wide := image.OptionalHeader.(*pe.OptionalHeader64)
+		return image.Machine == pe.IMAGE_FILE_MACHINE_AMD64 && wide && header.AddressOfEntryPoint != 0 &&
+			image.Characteristics&pe.IMAGE_FILE_EXECUTABLE_IMAGE != 0 && image.Characteristics&pe.IMAGE_FILE_DLL == 0, nil
+	}
+}
+
+func TestX86OriginalGoExecutableReadsActualParentMachine(t *testing.T) {
+	executable, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	amd64, err := x86OriginalGoLinkedAMD64(executable)
+	if err != nil || amd64 != (runtime.GOARCH == "amd64") {
+		t.Fatal("actual linked parent architecture differs from its binary header", amd64, err)
+	}
+}
+
+func TestX86OriginalGoExecutableRejectsMissingAndNonExecutable(t *testing.T) {
+	for _, name := range []string{"absent", "header-only"} {
+		path := t.TempDir() + "/" + name
+		if name == "header-only" {
+			if err := os.WriteFile(path, []byte("\x7fELF"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if amd64, err := x86OriginalGoLinkedAMD64(path); amd64 || err == nil {
+			t.Fatal("missing/truncated artifact became a linked target", name, amd64, err)
+		}
+	}
+}
diff --git a/amd64_original_package_observation_red_test.go b/amd64_original_package_observation_red_test.go
new file mode 100644
index 000000000..e3eea5461
--- /dev/null
+++ b/amd64_original_package_observation_red_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// Ordinary bodies and SDK imports may accompany a sealed object observation,
+// but only bodyless assembly declarations enter its function/layout map.
+// Observation remains separate from fixed-local/caller/native-memory permission.
+type originalPackageObservationVariant struct {
+	name        string
+	directory   string
+	declaration string
+	data        bool
+}
+
+var originalPackageObservationVariants = []originalPackageObservationVariant{
+	{name: "nested", directory: "internal/kernel"},
+	{name: "bodyful", declaration: "func Reference(a uint64) uint64 { return a + 1 }\n"},
+	{name: "import", declaration: "import _ \"math/bits\"\n"},
+	{name: "data", data: true},
+}
+
+type originalPackageObservationSelected struct {
+	Dir, ImportPath, Export                   string
+	GoFiles, CompiledGoFiles, SFiles, Imports []string
+	ImportMap                                 map[string]string
+	Module                                    *struct {
+		Path, Version, Dir, GoMod, GoVersion string
+		Main                                 bool
+	}
+}
+
+func originalPackageObservationFixture(t *testing.T, variant originalPackageObservationVariant) (GoPackage, GoAMD64FrameCaptureRequest) {
+	t.Helper()
+	_, request := goAMD64FrameSourceFixture(t)
+	root := request.Directory
+	const module = "example.invalid/framefixture"
+	directory := root
+	packagePath := module
+	if variant.directory != "" {
+		directory = filepath.Join(root, filepath.FromSlash(variant.directory))
+		packagePath += "/" + variant.directory
+		if err := os.MkdirAll(directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	declaration := "package framefixture\n" + variant.declaration + "func Value(a uint64) uint64\n"
+	files := map[string]string{
+		"value.go": declaration,
+		"value_amd64.s": "#include \"textflag.h\"\nTEXT ·Value(SB),NOSPLIT,$160-16\n" +
+			"MOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n",
+	}
+	if variant.data {
+		files["data_amd64.s"] = "#include \"textflag.h\"\nDATA ·constant<>+0(SB)/8,$1\n" +
+			"GLOBL ·constant<>(SB),RODATA|NOPTR,$8\n"
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	request.Directory = directory
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	env := append([]string(nil), request.Environment...)
+	env = append(env, "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOFLAGS=", "GOWORK=off", "GOTOOLCHAIN=local", "GOENV=off")
+	data, err := goasmcmd.Run(ctx, directory, env, request.GoBinary,
+		"list", "-deps", "-compiled", "-export", "-mod=readonly", "-json", ".")
+	if err != nil {
+		t.Fatalf("first-party original Go export failed: %v; %s", err, data)
+	}
+	t.Logf("actual original Go selected/export graph (%s):\n%s", variant.name, data)
+	exports := make(map[string]string)
+	var selected *originalPackageObservationSelected
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	for {
+		var pkg originalPackageObservationSelected
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		if pkg.Export != "" {
+			if _, duplicate := exports[pkg.ImportPath]; duplicate {
+				t.Fatalf("duplicate actual export: %s", pkg.ImportPath)
+			}
+			exports[pkg.ImportPath] = pkg.Export
+		}
+		if pkg.ImportPath == packagePath {
+			if selected != nil {
+				t.Fatal("duplicate actual original package selection")
+			}
+			copy := pkg
+			selected = &copy
+		}
+	}
+	if selected == nil || selected.Module == nil || !selected.Module.Main ||
+		selected.Module.Path != module || selected.Module.Version != "" ||
+		len(selected.CompiledGoFiles) == 0 || len(selected.SFiles) == 0 || selected.Export == "" {
+		t.Fatalf("incomplete actual original main-package export: %+v", selected)
+	}
+	actualDir, err := filepath.EvalSymlinks(selected.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantedDir, err := filepath.EvalSymlinks(directory)
+	if err != nil || actualDir != wantedDir {
+		t.Fatalf("actual package physical root differs: %s, %s, %v", actualDir, wantedDir, err)
+	}
+	if variant.data && len(selected.SFiles) != 2 {
+		t.Fatalf("original Go omitted the DATA-only sibling: %v", selected.SFiles)
+	}
+	if variant.name == "import" && exports["math/bits"] == "" {
+		t.Fatal("actual standard-library dependency export was not observed")
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range selected.CompiledGoFiles {
+		if !filepath.IsAbs(name) {
+			name = filepath.Join(selected.Dir, name)
+		}
+		file, err := parser.ParseFile(fset, name, nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	actualImporter := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if actual, mapped := selected.ImportMap[path]; mapped {
+			path = actual
+		}
+		filename := exports[path]
+		if filename == "" {
+			t.Fatalf("missing actual selected export for %s", path)
+		}
+		return os.Open(filename)
+	})
+	typed, err := (&types.Config{Importer: actualImporter, Sizes: types.SizesFor("gc", "amd64"),
+		GoVersion: "go" + selected.Module.GoVersion}).Check(packagePath, fset, syntax, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: packagePath, Types: typed, Syntax: syntax}, request
+}
+
+func TestGoAMD64OriginalPackageObservationKeepsAuthorityBoundaries(t *testing.T) {
+	for _, variant := range originalPackageObservationVariants {
+		t.Run(variant.name, func(t *testing.T) {
+			pkg, request := originalPackageObservationFixture(t, variant)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if observed != nil {
+				defer func() {
+					if err := observed.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+			if variant.name == "bodyful" || variant.name == "import" || variant.name == "data" {
+				if err != nil || observed == nil {
+					t.Fatalf("ordinary original source lost its sealed observation: %v", err)
+				}
+				if len(observed.functions) != 1 || len(observed.declarations) != 1 ||
+					observed.functions[pkg.Path+".Value"].locals != 168 {
+					t.Fatal("ordinary Go declaration manufactured an assembly frame observation")
+				}
+				if err := observed.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				// Even a live real-object observation supplies no aligned native
+				// stack storage to any translator without its separate Binder.
+				const assembly = "TEXT ·Value(SB),4,$160-16\nPXOR X0,X0\nMOVOU X0,16(SP)\nPADDQ 16(SP),X0\nMOVQ $1,ret+8(FP)\nRET\n"
+				goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) }
+				sig := observed.functions[pkg.Path+".Value"].signature
+				opt := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve,
+					Sigs: map[string]FuncSig{sig.Name: sig}}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("ordinary observation granted native memory to text API: %v", err)
+				}
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, opt)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("ordinary observation granted native memory to module API: %v", err)
+				}
+				translated, err := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+					GOOS: "linux", GOARCH: "amd64", TargetTriple: opt.TargetTriple, ResolveSym: resolve})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("ordinary observation granted native memory to typed Go API: %v", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || observed != nil {
+				t.Fatalf("unsupported original source role acquired an observation: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_original_sysv_test.go b/amd64_original_sysv_test.go
new file mode 100644
index 000000000..401b70039
--- /dev/null
+++ b/amd64_original_sysv_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// These test-only byte wrappers explicitly consume SysV registers, even on
+// Windows. Both declarations and indirect calls must retain that convention;
+// translated functions still use their target's ordinary C ABI. This is not a
+// production Go ABI contract. See clang.llvm.org/docs/AttributeReference.html#sysv-abi.
+const x86OriginalSysVAttribute = "__attribute__((sysv_abi))"
+
+func x86OriginalSysVDeclaration(result, name, arguments string) string {
+	return fmt.Sprintf("extern %s %s %s(%s);\n", result, x86OriginalSysVAttribute, name, arguments)
+}
+
+func x86OriginalSysVPointer(result, name, arguments string) string {
+	return fmt.Sprintf("typedef %s (%s *%s)(%s);\n", result, x86OriginalSysVAttribute, name, arguments)
+}
+
+func TestX86OriginalSysVDirectAndPointerTransport(t *testing.T) {
+	clang, llc := findLLVM22Tool("clang"), findLLVM22Tool("llc")
+	if clang == "" || llc == "" {
+		t.Fatal("LLVM 22 clang and llc required")
+	}
+	var source strings.Builder
+	source.WriteString("typedef unsigned char uint8_t; typedef unsigned int uint32_t; typedef unsigned long long uint64_t; typedef long long int64_t;\n")
+	for index, signature := range []struct {
+		result, parameters, arguments string
+	}{
+		{"uint64_t", "uint32_t k,uint32_t h", "k,h"},
+		{"uint64_t", "uint8_t *out,int64_t index,uint64_t value", "out,index,value"},
+		{"void", "uint8_t *out,const uint8_t *input,uint64_t old,uint64_t flags", "out,input,old,flags"},
+		{"void", "uint8_t *out,float input,uint64_t old,uint64_t flags", "out,input,old,flags"},
+		{"void", "uint8_t *out,double input,uint64_t old,uint64_t flags", "out,input,old,flags"},
+		{"void", "uint8_t *out,const uint8_t *a,const uint8_t *b,const uint8_t *old,uint64_t flags,uint32_t csr", "out,a,b,old,flags,csr"},
+	} {
+		name, pointer := fmt.Sprintf("Original%d", index), fmt.Sprintf("OriginalProgram%d", index)
+		source.WriteString(x86OriginalSysVDeclaration(signature.result, name, signature.parameters))
+		source.WriteString(x86OriginalSysVPointer(signature.result, pointer, signature.parameters))
+		fmt.Fprintf(&source, "extern %s Translated%d(%s);\n", signature.result, index, signature.parameters)
+		fmt.Fprintf(&source, "void Check%d(%s pointer,%s) { %s(%s); pointer(%s); Translated%d(%s); }\n",
+			index, pointer, signature.parameters, name, signature.arguments, signature.arguments, index, signature.arguments)
+	}
+	for _, target := range []string{"x86_64-pc-windows-msvc", "x86_64-w64-windows-gnu", "x86_64-unknown-linux-gnu", "x86_64-apple-darwin"} {
+		t.Run(target, func(t *testing.T) {
+			directory := t.TempDir()
+			input, output := filepath.Join(directory, "transport.c"), filepath.Join(directory, "transport.ll")
+			if err := os.WriteFile(input, []byte(source.String()), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, clang, "-target", target, "-nostdinc", "-Werror",
+				"-O0", "-S", "-emit-llvm", input, "-o", output)
+			if data, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+				t.Fatalf("typed direct/indirect transport: %v\n%s", err, data)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(target, "windows") && strings.Count(string(ir), "call x86_64_sysvcc ") != 12 {
+				t.Fatal("Windows direct or pointer call erased the original SysV ABI")
+			}
+			translatedCalls := 0
+			for _, line := range strings.Split(string(ir), "\n") {
+				if strings.Contains(line, "call ") && strings.Contains(line, "@Translated") {
+					translatedCalls++
+					if strings.Contains(line, "x86_64_sysvcc") {
+						t.Fatal("original byte-wrapper ABI leaked into a translated call")
+					}
+				}
+			}
+			if translatedCalls != 6 {
+				t.Fatalf("translated call controls = %d, want 6", translatedCalls)
+			}
+			compileLLVMToObject(t, llc, target, "transport.ll", "transport.o", string(ir))
+		})
+	}
+}
diff --git a/amd64_packed_abs_sign_forms.go b/amd64_packed_abs_sign_forms.go
new file mode 100644
index 000000000..693688b01
--- /dev/null
+++ b/amd64_packed_abs_sign_forms.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedAbsSignSpec struct {
+	x86PackedBinarySpec
+	laneBits int
+	sign     bool
+}
+
+// Go's legacy yxm_q4 rows are XMM-only, despite Intel's separate NP MMX
+// encodings. ABS is unary; SIGN reads its control and data independently.
+// The common shape describes encodings, not memory or physical-entry rights.
+var x86PackedAbsSignSpecs = map[Op]x86PackedAbsSignSpec{
+	"PABSB":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 8},
+	"PABSW":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 16},
+	"PABSD":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 32},
+	"PSIGNB": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 8, sign: true},
+	"PSIGNW": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 16, sign: true},
+	"PSIGND": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, laneBits: 32, sign: true},
+
+	"VPABSB":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, laneBits: 8},
+	"VPABSW":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, laneBits: 16},
+	"VPABSD":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, laneBits: 32},
+	"VPABSQ":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true}, laneBits: 64},
+	"VPSIGNB": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEX}, laneBits: 8, sign: true},
+	"VPSIGNW": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEX}, laneBits: 16, sign: true},
+	"VPSIGND": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEX}, laneBits: 32, sign: true},
+}
+
+type x86PackedAbsSignForm struct {
+	x86PackedBinaryForm
+	spec x86PackedAbsSignSpec
+}
+
+func (form x86PackedAbsSignForm) evex(ins Instr) bool {
+	if form.legacy {
+		return false
+	}
+	if ins.x86PackedAbsEVEX || form.spec.encoding == x86PackedLogicalEVEX ||
+		form.byteWidth == 64 || form.mask >= 0 || form.broadcast {
+		return true
+	}
+	for _, arg := range ins.Args {
+		if index, valid := amd64VectorRegisterIndex(arg.Reg, form.byteWidth); arg.Kind == OpReg && valid && index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+func x86PackedAbsSignProperties(op Op, ins Instr, arch string) (x86PackedAbsSignForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86PackedAbsSignSpecs[Op(base)]
+	form := x86PackedAbsSignForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return form, true, fmt.Errorf("ABS/sign dispatch/source opcode mismatch")
+	}
+	if ins.x86PackedAbsEVEX && spec.encoding != x86PackedLogicalVEXOrEVEX && spec.encoding != x86PackedLogicalEVEX {
+		return form, true, fmt.Errorf("%s %s has no physical EVEX generation", arch, op)
+	}
+	local := ins
+	local.Op = op
+	unary := !spec.sign && spec.encoding != x86PackedLogicalLegacyFP
+	if unary {
+		if len(ins.Args) != 2 && len(ins.Args) != 3 {
+			return form, true, fmt.Errorf("%s %s requires source, optional K1-K7 and destination", arch, op)
+		}
+		destination := ins.Args[len(ins.Args)-1]
+		local.Args = []Operand{ins.Args[0], destination, destination}
+		if len(ins.Args) == 3 {
+			local.Args = []Operand{ins.Args[0], destination, ins.Args[1], destination}
+		}
+	}
+	var err error
+	form.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, spec.x86PackedBinarySpec, unary)
+	if !spec.sign {
+		form.second = -1
+	}
+	if unary {
+		form.destination = len(ins.Args) - 1
+		if form.mask >= 0 {
+			form.mask = 1
+		}
+	}
+	return form, true, err
+}
+
+func x86TypedPackedAbsSignByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedAbsSignProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, sourceWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		sourceWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: sourceWidth, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width,
+			read: form.spec.sign && form.legacy || form.mask >= 0 && !form.zeroing, write: true},
+	}}
+	if form.spec.sign && !form.legacy {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.second, operand: ins.Args[form.second], width: width, read: true})
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_add_fault_runtime_test.go b/amd64_packed_add_fault_runtime_test.go
new file mode 100644
index 000000000..7cce0415f
--- /dev/null
+++ b/amd64_packed_add_fault_runtime_test.go
@@ -0,0 +1,124 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedWrappingAddNativeMemoryStatus(t *testing.T) {
+	x86PackedAddNativeMemoryStatus(t, x86WrappingAddOpcodes, []int{8, 16, 32, 64, 8, 16, 32, 64})
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedSaturatingAddNativeMemoryStatus(t *testing.T) {
+	x86PackedAddNativeMemoryStatus(t, []string{
+		"PADDSB", "PADDSW", "PADDUSB", "PADDUSW",
+		"VPADDSB", "VPADDSW", "VPADDUSB", "VPADDUSW",
+	}, []int{8, 16, 8, 16, 8, 16, 8, 16})
+}
+
+func x86PackedAddNativeMemoryStatus(t *testing.T, opcodes []string, laneBits []int) {
+	t.Helper()
+	if len(opcodes) != len(laneBits) {
+		t.Fatal("opcode/lane inventory differs")
+	}
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, references, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	index := 0
+	for opcodeIndex, opcode := range opcodes {
+		legacy := !strings.HasPrefix(opcode, "V")
+		bits := laneBits[opcodeIndex]
+		modes := []int{-1}
+		if !legacy {
+			modes = []int{-1, 0, 1}
+		}
+		for _, mode := range modes {
+			name := fmt.Sprintf("packedaddfault%d", index)
+			index++
+			row := opcode + " (BX),X0"
+			if !legacy {
+				row = opcode + " (BX),Z0,Z1"
+				if mode >= 0 {
+					row = opcode + ".Z (BX),Z0,K1,Z1"
+				}
+			}
+			mask := mode
+			if mask < 0 {
+				mask = 0
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\nVPXORD Z0,Z0,Z0\nMOVL $%d,CX\nKMOVQ CX,K1\n%s\nRET\n", name, mask, row)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+			fmt.Fprintf(&declarations, "extern void %s(const uint8_t*);\n", name)
+			reference := fmt.Sprintf("reference%d", index)
+			if legacy {
+				mnemonic := strings.ToLower(opcode)
+				if mnemonic == "paddl" {
+					mnemonic = "paddd"
+				}
+				fmt.Fprintf(&references, "__attribute__((noinline)) static void %s(const uint8_t*p){typedef int32_t V __attribute__((vector_size(16)));V v={0,0,0,0};__asm__ volatile(\"%s (%%1),%%0\":\"+x\"(v):\"r\"(p):\"memory\");}\n", reference, mnemonic)
+			} else {
+				width := 64
+				if mode == 0 {
+					width = 0
+				} else if mode == 1 {
+					width = bits / 8
+				}
+				fmt.Fprintf(&references, "__attribute__((noinline)) static void %s(const uint8_t*p){for(int i=0;i<%d;++i)(void)((const volatile uint8_t*)p)[i];}\n", reference, width)
+			}
+			fmt.Fprintf(&checks, "for(int n=0;n<16;++n)if(compare(%s,%s,memory+n))return 1;\n", reference, name)
+			for _, offset := range []int{0, 1, bits / 8, 16, 64} {
+				fmt.Fprintf(&checks, "if(compare(%s,%s,boundary-%d))return 1;\n", reference, name, offset)
+			}
+			fmt.Fprintf(&checks, "if(compare(%s,%s,0))return 1;\n", reference, name)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + references.String() + `
+typedef struct {int signal;int code;} Status;
+static int observe(void(*fn)(const uint8_t*),const uint8_t*p,Status*out){
+ pid_t child=fork();if(child<0)return 1;
+ if(child==0){struct rlimit limit={0,0};if(setrlimit(RLIMIT_CORE,&limit))_exit(3);fn(p);_exit(0);}
+ int status;if(waitpid(child,&status,0)!=child)return 1;
+ if(WIFSIGNALED(status)){*out=(Status){WTERMSIG(status),0};return 0;}
+ if(WIFEXITED(status)){*out=(Status){0,WEXITSTATUS(status)};return 0;}return 1;
+}
+static int compare(void(*original)(const uint8_t*),void(*translated)(const uint8_t*),const uint8_t*p){
+ Status a,b;if(observe(original,p,&a)||observe(translated,p,&b))return 1;
+ if(a.signal!=b.signal||a.code!=b.code){fprintf(stderr,"pointer=%p mod16=%lu original=(%d,%d) translated=(%d,%d)\n",p,(unsigned long)((uintptr_t)p%16),a.signal,a.code,b.signal,b.code);return 1;}return 0;
+}
+int main(void){
+ long page=sysconf(_SC_PAGESIZE);if(page<=0||page%64)return 1;
+ uint8_t*memory=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(memory==MAP_FAILED)return 1;memset(memory,0x87,(size_t)page);
+ if(mprotect(memory,(size_t)page,PROT_READ)||mprotect(memory+page,(size_t)page,PROT_NONE))return 1;
+ uint8_t*boundary=memory+page;
+` + checks.String() + "if(munmap(memory,(size_t)page*2))return 1;return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-add-fault", triple, text, main, prefix)
+		})
+	}
+	t.Log("all four original SSE opcodes typed-status at every mod16/NULL/RO guard; E4/E4.nb zero/active masks observed against independent volatile reads, not unexecuted AVX512 hardware")
+}
diff --git a/amd64_packed_add_forms.go b/amd64_packed_add_forms.go
new file mode 100644
index 000000000..03443e38f
--- /dev/null
+++ b/amd64_packed_add_forms.go
@@ -0,0 +1,17 @@
+package plan9asm
+
+type x86PackedAddForm = x86PackedArithmeticForm
+type x86PackedIntegerAddForm = x86PackedArithmeticForm
+
+func x86PackedIntegerAddProperties(ins Instr, arch string) (x86PackedIntegerAddForm, bool, error) {
+	return x86PackedArithmeticProperties(ins.Op, ins, arch, x86PackedArithmeticAdd)
+}
+
+// Shared syntax does not admit saturating adds into the private wrapping caller.
+func x86PackedWrappingAddProperties(ins Instr, arch string) (x86PackedAddForm, bool, error) {
+	spec, known := x86PackedArithmeticSpecForOp(ins.Op, x86PackedArithmeticAdd)
+	if !known || spec.mode != x86PackedWrap {
+		return x86PackedAddForm{}, false, nil
+	}
+	return x86PackedArithmeticFormForSpec(ins.Op, ins, arch, spec)
+}
diff --git a/amd64_packed_add_forms_test.go b/amd64_packed_add_forms_test.go
new file mode 100644
index 000000000..8a2089f6e
--- /dev/null
+++ b/amd64_packed_add_forms_test.go
@@ -0,0 +1,331 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var x86WrappingAddOpcodes = []string{"PADDB", "PADDW", "PADDL", "PADDQ", "VPADDB", "VPADDW", "VPADDD", "VPADDQ"}
+
+func x86WrappingAddSpecForTest(op Op) x86PackedArithmeticSpec {
+	spec, known := x86PackedArithmeticSpecForOp(op, x86PackedArithmeticAdd)
+	if !known || spec.mode != x86PackedWrap {
+		panic("invalid wrapping-add fixture opcode")
+	}
+	return spec
+}
+
+func x86WrappingAddFormats(arch string) []string {
+	var rows []string
+	for _, opcode := range append(append([]string(nil), x86WrappingAddOpcodes...), "PADDD") {
+		spec := x86WrappingAddSpecForTest(Op(opcode))
+		if !strings.HasPrefix(opcode, "V") {
+			rows = append(rows, opcode+" X0,X7", opcode+" 16(AX)(BX*2),X7")
+			if arch == "amd64" {
+				rows = append(rows, opcode+" X15,X0", opcode+" data(SB),X0", opcode+" (FS),X0", opcode+" (GS),X0")
+				if opcode != "PADDQ" {
+					rows = append(rows, opcode+" M0,M7", opcode+" (AX),M7", opcode+" source+0(FP),M7")
+				}
+			}
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{bank + "0", "16(AX)(BX*2)", "source+0(FP)"} {
+				rows = append(rows, fmt.Sprintf("%s %s,%s1,%s7", opcode, source, bank, bank))
+				if arch == "amd64" {
+					rows = append(rows, fmt.Sprintf("%s %s,%s31,K1,%s30", opcode, source, bank, bank), fmt.Sprintf("%s.Z %s,%s31,K7,%s30", opcode, source, bank, bank))
+				}
+			}
+			if spec.broadcastBytes != 0 {
+				rows = append(rows, fmt.Sprintf("%s.BCST (AX),%s1,%s7", opcode, bank, bank))
+				if arch == "amd64" {
+					rows = append(rows, fmt.Sprintf("%s.BCST.Z source+0(FP),%s31,K7,%s30", opcode, bank, bank))
+				}
+			}
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("%s %s31,%s30,%s29", opcode, bank, bank, bank))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedWrappingAddActualGoCompleteAttributes(t *testing.T) {
+	wrapping := 0
+	for _, spec := range x86PackedArithmeticSpecs {
+		if spec.family == x86PackedArithmeticAdd && spec.mode == x86PackedWrap {
+			wrapping++
+		}
+	}
+	if wrapping != 9 {
+		t.Fatal("eight wrapping operations and the actual Go PADDD alias required")
+	}
+	for index, opcode := range x86WrappingAddOpcodes {
+		spec := x86WrappingAddSpecForTest(Op(opcode))
+		bits := 8 << uint(index%4)
+		broadcast := 0
+		if index >= 6 {
+			broadcast = bits / 8
+		}
+		if spec.laneBits != bits || spec.broadcastBytes != broadcast || spec.zeroing != (index >= 4) {
+			t.Fatalf("%s has wrong independent arithmetic/tuple attributes: %+v", opcode, spec)
+		}
+	}
+	if x86WrappingAddSpecForTest("PADDD") != x86WrappingAddSpecForTest("PADDL") {
+		t.Fatal("actual Go alias must retain the exact canonical operation")
+	}
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil || !strings.Contains(string(aliases), `instructions["PADDD"] = x86.APADDL`) {
+		t.Fatalf("actual Go PADDD alias registration: %v", err)
+	}
+	for index, opcode := range []string{"PADDB", "PADDW", "PADDL", "PADDQ"} {
+		byteOp := []int{0xfc, 0xfd, 0xfe, 0xd4}[index]
+		registration := fmt.Sprintf("{A%s, ymm, Py1, opBytes{0x%x, Pe, 0x%x}}", opcode, byteOp, byteOp)
+		if opcode == "PADDQ" {
+			registration = "{APADDQ, yxm, Pe, opBytes{0xd4}}"
+		}
+		if !strings.Contains(string(legacy), registration) {
+			t.Fatalf("actual Go legacy registration changed: %s", registration)
+		}
+		opcode = []string{"VPADDB", "VPADDW", "VPADDD", "VPADDQ"}[index]
+		start := strings.Index(string(avx), "{as: A"+opcode+",")
+		if start < 0 {
+			t.Fatal("actual Go missing " + opcode)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(row, "ytab: _yvandnpd") || strings.Contains(row, "Sae") || strings.Contains(row, "Rounding") {
+			t.Fatalf("actual Go operand attributes changed: %s", row)
+		}
+		for _, width := range []string{"vex128", "vex256"} {
+			if !strings.Contains(row, fmt.Sprintf("avxEscape | %s | vex66 | vex0F | vexW0, 0x%X", width, byteOp)) {
+				t.Fatal("missing actual VEX registration " + opcode)
+			}
+		}
+		for i, width := range []string{"evex128", "evex256", "evex512"} {
+			w, broadcast := 0, ""
+			if index >= 2 {
+				broadcast = fmt.Sprintf(" | evexBcstN%d", 4<<(index-2))
+			}
+			if index == 3 {
+				w = 1
+			}
+			want := fmt.Sprintf("avxEscape | %s | evex66 | evex0F | evexW%d, evexN%d%s | evexZeroingEnabled, 0x%X", width, w, 16<<i, broadcast, byteOp)
+			if !strings.Contains(row, want) {
+				t.Fatal("missing actual EVEX registration " + want)
+			}
+		}
+	}
+}
+
+func TestX86PackedWrappingAddCompleteFormsFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i") {
+				arch = "386"
+			}
+			var source, declarations strings.Builder
+			sigs := map[string]FuncSig{}
+			for i, row := range x86WrappingAddFormats(arch) {
+				name := fmt.Sprintf("padd%d", i)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-64\n%s\nRET\n", name, row)
+				fmt.Fprintf(&declarations, "func %s(source [64]byte)\n", name)
+				sig := x86WordMaddFPType(t)
+				sig.Name = name
+				sigs[name] = sig
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			// A byte-array parameter does not initialize vector registers,
+			// masks, native addresses or a physical MMX region. Keep these
+			// exact original format rows, with independent initialized programs
+			// in the arithmetic/native-read and closed-MMX family tests.
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unbound wrapping-add formats acquired source inputs", api, err)
+				}
+			}
+			before := fmt.Sprintf("%#v %#v", file, sigs)
+			ir := x86ScalarFormatObjectUnit(t, file, sigs, arch, triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+			if before != fmt.Sprintf("%#v %#v", file, sigs) {
+				t.Fatal("format emitter mutated the original source or signatures")
+			}
+		})
+	}
+}
+
+func TestX86PackedWrappingAddIdentityMalformedAndPhysicalBoundaries(t *testing.T) {
+	for _, op := range x86WrappingAddOpcodes {
+		row := op + " X0,X1"
+		if strings.HasPrefix(op, "V") {
+			row = op + " Y0,Y1,Y2"
+		}
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(op)), "UNKNOWN", "PADDB", "VPADDD", Op(op + ".SAE")} {
+			local := ins
+			local.Op = identity
+			beforeIns := local
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			known, term, err := ctx.lowerPackedIntegerAdd(ins.Op, local)
+			bad := identity != "" && strings.ToUpper(string(identity)) != op
+			if !known || term || (err != nil) != bad || bad && before != out.String() || !reflect.DeepEqual(beforeIns, local) {
+				t.Fatalf("dispatch/source mismatch %s/%s: %v", op, identity, err)
+			}
+		}
+	}
+	for _, row := range []string{"PADDQ M0,M1", "PADDB X0,Y1", "PADDW.Z X0,X1", "PADDL $data(SB),X0", "VPADDB.BCST (AX),Z0,Z1", "VPADDW.SAE Z0,Z1,Z2", "VPADDD.Z Z0,Z1,Z2", "VPADDQ.RN_SAE Z0,Z1,Z2", "VPADDQ.BCST X0,X1,X2", "VPADDD Z0,Z1,K0,Z2", "VPADDW X0,Y1,Y2", "VPADDQ 2147483648(AX),Z0,Z1", "VPADDB (AX)(SP*2),X0,X1"} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		requireX86GoAssemblerResult(t, "amd64", source, false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			continue
+		}
+		ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := out.String()
+		if _, _, err := ctx.lowerPackedIntegerAdd(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1]); err == nil || out.String() != before {
+			t.Fatalf("malformed %s emitted IR: %v", row, err)
+		}
+	}
+	for _, op := range []string{"VPADDB", "VPADDW", "VPADDD", "VPADDQ"} {
+		for _, bank := range []string{"X", "Y"} {
+			for index := 0; index < 3; index++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[index] = bank + "16"
+				source := "TEXT f(SB),4,$0-0\n" + op + " " + strings.Join(args, ",") + "\nRET\n"
+				requireX86GoAssemblerResult(t, "386", source, true)
+				file, _ := Parse(ArchAMD64, source)
+				if _, _, err := x86PackedWrappingAddProperties(file.Funcs[0].Instrs[1], "386"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-accepted high mode32 encoded bank became permission: %v", err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedWrappingAddIndependentFPFieldsEveryByteAndMaskZero(t *testing.T) {
+	for _, op := range []string{"VPADDB", "VPADDW", "VPADDD", "VPADDQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && x86WrappingAddSpecForTest(Op(op)).broadcastBytes == 0 {
+					continue
+				}
+				opcode := op + ".Z"
+				if broadcast {
+					opcode = op + ".BCST.Z"
+				}
+				file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+opcode+" source+0(FP),"+bank+"1,K1,"+bank+"2\nRET\n")
+				ins := file.Funcs[0].Instrs[1]
+				form, _, err := x86PackedWrappingAddProperties(ins, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for missing := -1; missing < form.memoryBytes; missing++ {
+					sig := x86WordMaddFPType(t)
+					if missing >= 0 {
+						sig.Frame.Params = append(sig.Frame.Params[:missing], sig.Frame.Params[missing+1:]...)
+					}
+					ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+					before := out.String()
+					_, _, err := ctx.lowerPackedIntegerAdd(ins.Op, ins)
+					if missing < 0 && err != nil || missing >= 0 && (err == nil || out.String() != before) {
+						t.Fatalf("%s/%s missing FP byte%d: %v", op, bank, missing, err)
+					}
+				}
+			}
+		}
+	}
+	for _, opcode := range []string{"PADDB", "PADDW", "PADDL", "PADDD"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+opcode+" source+0(FP),M1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		for missing := -1; missing < 8; missing++ {
+			sig := x86WordMaddFPType(t)
+			if missing >= 0 {
+				sig.Frame.Params = append(sig.Frame.Params[:missing], sig.Frame.Params[missing+1:]...)
+			}
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := out.String()
+			_, _, err := ctx.lowerPackedIntegerAdd(ins.Op, ins)
+			if missing < 0 && err != nil || missing >= 0 && (err == nil || out.String() != before) {
+				t.Fatalf("%s MMX missing FP byte%d: %v", opcode, missing, err)
+			}
+		}
+	}
+}
+
+func TestX86PackedWrappingAdd386HighRegisterActualByteIdentities(t *testing.T) {
+	for _, opcode := range []string{"VPADDB", "VPADDW", "VPADDD", "VPADDQ"} {
+		for _, bank := range []string{"X", "Y"} {
+			for operand := 0; operand < 3; operand++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[operand] = bank + "16"
+				row := opcode + " " + strings.Join(args, ",")
+				listing, err := x86ExtensionGoListing(t, "386", row)
+				if err != nil {
+					t.Fatalf("actual Go mode32 object: %v\n%s", err, listing)
+				}
+				var code []byte
+				for _, line := range strings.Split(listing, "\n") {
+					fields := strings.Fields(line)
+					if len(fields) < 7 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+						continue
+					}
+					for _, field := range fields[1:7] {
+						value, err := strconv.ParseUint(field, 16, 8)
+						if err != nil {
+							t.Fatal(err)
+						}
+						code = append(code, byte(value))
+					}
+					break
+				}
+				ins, length, recognized, err := decodedX86PackedIntegerArithmeticInstruction(code, 64)
+				if len(code) != 6 || !recognized || err != nil || length != 6 || ins.Op != Op(opcode) || len(ins.Args) != 3 {
+					t.Fatalf("actual EVEX byte identity %s/%x: %+v/%d/%t/%v", row, code, ins, length, recognized, err)
+				}
+				for index, argument := range args {
+					if ins.Args[index].Reg != Reg(argument) {
+						t.Fatalf("%s/%x operand%d: %s != %s", row, code, index, ins.Args[index].Reg, argument)
+					}
+				}
+				if _, _, recognized, err := decodedX86PackedIntegerArithmeticInstruction(code, 32); !recognized || err == nil {
+					t.Fatalf("raw mode32 high bank obtained false permission: %s/%x", row, code)
+				}
+				t.Logf("%s actual Go bytes=%x; mode64 identities exact, mode32 rejected", row, code)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_add_go_oracle_test.go b/amd64_packed_add_go_oracle_test.go
new file mode 100644
index 000000000..d3167580c
--- /dev/null
+++ b/amd64_packed_add_go_oracle_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedWrappingAddOriginalGoBits(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+import "testing"
+func lane(p []byte,n int)uint64{var value uint64;for j:=0;j<n;j++{value|=uint64(p[j])<<uint(8*j)};return value}
+func TestOriginalAdd(t *testing.T){
+ var patterns [8][16]byte;state:=uint32(0x12345678)
+ for p:=range patterns{for i:=range patterns[p]{state=state*1664525+1013904223;patterns[p][i]=byte(state>>24)}}
+ for i:=range patterns[0]{patterns[0][i]=0xff;patterns[1][i]=1;patterns[2][i]=0x80;patterns[3][i]=0}
+`)
+	count := 0
+	for index, opcode := range []string{"PADDB", "PADDW", "PADDL", "PADDQ"} {
+		bytes := 1 << uint(index)
+		for _, bank := range []string{"X", "M"} {
+			if bank == "M" && opcode == "PADDQ" {
+				continue // Actual Go PADDQ uses yxm, not Intel's MMX row.
+			}
+			forms := []string{"register"}
+			if bank == "M" {
+				forms = append(forms, "memory")
+			}
+			for _, form := range forms {
+				name := fmt.Sprintf("packedaddgo%d", count)
+				count++
+				fmt.Fprintf(&declarations, "func %s(a,b,out *byte,csr uint32)\n", name)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),CX\n", name)
+				move, width := "MOVOU", 16
+				if bank == "M" {
+					move, width = "MOVQ", 8
+				}
+				fmt.Fprintf(&assembly, "%s (BX),%s0\n", move, bank)
+				first := "(AX)"
+				if form == "register" {
+					first = bank + "1"
+					fmt.Fprintf(&assembly, "%s (AX),%s1\n", move, bank)
+				}
+				fmt.Fprintf(&assembly, "CMPQ AX,AX\nSTC\n%s %s,%s0\n%s %s0,(CX)\nSETCS 16(CX)\nSETNE 17(CX)\nSTMXCSR 18(CX)\n", opcode, first, bank, move, bank)
+				if bank == "M" {
+					assembly.WriteString("EMMS\n")
+				}
+				assembly.WriteString("LDMXCSR saved-4(SP)\nRET\n")
+				fmt.Fprintf(&tests, `
+ for _,a:=range patterns{for _,b:=range patterns{for mode:=0;mode<4;mode++{
+  var out [24]byte;for i:=range out{out[i]=0xc3};csr:=uint32(0x1f80|mode<<13|mode)
+  %[1]s(&a[0],&b[0],&out[1],csr)
+  if out[0]!=0xc3||out[23]!=0xc3||out[17]!=1||out[18]!=0{t.Fatalf("%[1]s flags/canary %%x",out)}
+  gotCSR:=uint32(out[19])|uint32(out[20])<<8|uint32(out[21])<<16|uint32(out[22])<<24
+  if gotCSR!=csr{t.Fatalf("%[1]s CSR %%x != %%x",gotCSR,csr)}
+  for i:=0;i<%[2]d;i+=%[3]d{
+   want:=lane(a[i:],%[3]d)+lane(b[i:],%[3]d)
+   for j:=0;j<%[3]d;j++{if out[i+j+1]!=byte(want>>uint(8*j)){t.Fatalf("%[1]s byte%%d got%%x want%%x",i+j,out,want)}}
+  }
+  for i:=%[2]d;i<16;i++{if out[i+1]!=0xc3{t.Fatal("touched upper MMX canary")}}
+ }}}
+`, name, width, bytes)
+			}
+		}
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go modulo integer-add oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d actual Go SSE/MMX functions × 256 independent full-lane wrap/MXCSR/flags/canary cases; no x87 tag-state claim", count)
+}
diff --git a/amd64_packed_add_runtime_test.go b/amd64_packed_add_runtime_test.go
new file mode 100644
index 000000000..f6b627252
--- /dev/null
+++ b/amd64_packed_add_runtime_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+const x86PackedAddIndependentOracle = `
+static const uint64_t masks[]={0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+static uint64_t lane(const uint8_t *p,int bytes) {
+ uint64_t v=0;for(int j=0;j<bytes;++j) v|=(uint64_t)p[j]<<(8*j);return v;
+}
+__attribute__((noinline)) static int checkAdd(
+ void (*fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t),
+ const char *name,int width,int bytes,int mode,int legacy,int destination,int memory,int broadcast) {
+ for(int round=0;round<12;++round) for(int m=0;m<4;++m) {
+  _Alignas(64) uint8_t aStorage[96],bStorage[96],output[68];
+  int shift=legacy&&memory ? 16 : 1;
+  uint8_t *a=aStorage+shift,*b=bStorage+3;
+  memset(aStorage,0xa7,96);memset(bStorage,0xb9,96);memset(output,0xc3,68);
+  for(int i=0;i<64;++i) {a[i]=(uint8_t)(i*17+round*31);b[i]=(uint8_t)(i*23+round*53);}
+  if(round<3) {memset(a,round==0?0xff:round==1?0x80:0,64);memset(b,round==0?1:round==1?0x80:0xff,64);}
+  uint64_t mask=masks[m];uint32_t saved,before=0x1f80|((round%4)<<13)|round,after;
+  __asm__ volatile("stmxcsr %0" : "=m"(saved));__asm__ volatile("ldmxcsr %0" : : "m"(before));
+  fn(output+1,a,b,mask);
+  __asm__ volatile("stmxcsr %0" : "=m"(after));__asm__ volatile("ldmxcsr %0" : : "m"(saved));
+  if(after!=before || output[0]!=0xc3 || output[67]!=0xc3 || output[65]!=1 || output[66]!=0) return 1;
+  for(int i=0;i<64;i+=bytes) {
+   uint64_t sum=lane(a+(broadcast?0:i),bytes)+lane(b+i,bytes);
+   const uint8_t *old=destination==1 ? a : b;
+   int active=mode==0 || ((mask>>(i/bytes))&1);
+   for(int j=0;j<bytes;++j) {
+    uint8_t want=i<width ? (active ? (uint8_t)(sum>>(j*8)) : mode==2 ? 0 : old[i+j]) : legacy ? b[i+j] : 0;
+    if(output[i+j+1]!=want) {fprintf(stderr,"%s round=%d mask=%llx byte=%d got=%x want=%x\n",name,round,(unsigned long long)mask,i+j,output[i+j+1],want);return 1;}
+   }
+  }
+  for(int i=0;i<96;++i) {
+   if((i<shift || i>=shift+64) && aStorage[i]!=0xa7) return 1;
+   if((i<3 || i>=67) && bStorage[i]!=0xb9) return 1;
+  }
+ }
+ return 0;
+}
+`
+
+func x86PackedAddMMXAssembly(name, opcode, input string) string {
+	return fmt.Sprintf("TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (CX),Z0\nVMOVUPS Z0,(AX)\nCMPQ AX,AX\nSTC\nMOVQ (CX),M0\nMOVQ (BX),M1\n%s %s,M0\nMOVQ M0,(AX)\nEMMS\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", name, opcode, input)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedWrappingAddCompleteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for index, opcode := range x86WrappingAddOpcodes {
+		bits := 8 << uint(index%4)
+		legacy := !strings.HasPrefix(opcode, "V")
+		widths := []int{16}
+		if !legacy {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, kind := range []string{"register", "memory", "broadcast"} {
+				if kind == "broadcast" && (legacy || bits < 32) {
+					continue
+				}
+				for mode := 0; mode < 3; mode++ {
+					if legacy && mode != 0 {
+						continue
+					}
+					destination := mode
+					if legacy {
+						destination = 0
+					}
+					name := fmt.Sprintf("packedadd%d", count)
+					count++
+					first := bank + "1"
+					if kind != "register" {
+						first = "(BX)"
+					}
+					row := opcode + " " + first + ",X0"
+					if !legacy {
+						suffix := ""
+						if kind == "broadcast" {
+							suffix = ".BCST"
+						}
+						if mode == 2 {
+							suffix += ".Z"
+						}
+						row = opcode + suffix + " " + first + "," + bank + "0"
+						if mode != 0 {
+							row += ",K1"
+						}
+						row += fmt.Sprintf(",%s%d", bank, destination)
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (CX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nCMPQ AX,AX\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", name, row, destination)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+					fmt.Fprintf(&checks, "if(checkAdd(%s,\"%s\",%d,%d,%d,%d,%d,%d,%d)) return 1;\n", name, name, width, bits/8, mode, x86FloatAddSubBoolInt(legacy), destination, x86FloatAddSubBoolInt(kind != "register"), x86FloatAddSubBoolInt(kind == "broadcast"))
+				}
+			}
+		}
+	}
+	for index, opcode := range []string{"PADDB", "PADDW", "PADDL"} {
+		for _, memory := range []bool{false, true} {
+			name := fmt.Sprintf("packedadd%d", count)
+			count++
+			first := "M1"
+			if memory {
+				first = "(BX)"
+			}
+			source.WriteString(x86PackedAddMMXAssembly(name, opcode, first))
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if(checkAdd(%s,\"%s\",8,%d,0,1,0,%d,0))return 1;\n", name, name, 1<<uint(index), x86FloatAddSubBoolInt(memory))
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n" + declarations.String() + x86PackedAddIndependentOracle + "int main(void){\n" + checks.String() + "return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "wrapping-add", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d complete opcode/width/memory/broadcast/mask/alias programs × 48 independent wrap/CSR/flags/canary cases at O0/O2; not native AVX512 execution", count)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedWrappingAddLogicalFPFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var definitions, wrappers, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for index, opcode := range []string{"VPADDB", "VPADDW", "VPADDD", "VPADDQ"} {
+		bits := 8 << uint(index)
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && bits < 32 {
+				continue
+			}
+			for _, width := range []int{16, 32, 64} {
+				for mode := 0; mode < 3; mode++ {
+					name := fmt.Sprintf("packedaddfp%d", count)
+					count++
+					pkg := mustGoPackage(t, "oracle", fmt.Sprintf("package oracle\nfunc %s(source [64]byte,out *byte,mask uint64)\n", name))
+					sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs[name] = sig
+					bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+					row := opcode
+					if broadcast {
+						row += ".BCST"
+					}
+					if mode == 2 {
+						row += ".Z"
+					}
+					row += " source+0(FP)," + bank + "1"
+					if mode != 0 {
+						row += ",K1"
+					}
+					row += "," + bank + "1"
+					fmt.Fprintf(&definitions, "TEXT %s(SB),4,$0-80\nMOVQ out+64(FP),AX\nMOVQ mask+72(FP),DX\nKMOVQ DX,K1\nVMOVUPS (AX),Z1\n%s\nVMOVUPS %s1,(AX)\nRET\n", name, row, bank)
+					fmt.Fprintf(&wrappers, "define void @check_%s(ptr %%input,ptr %%output,i64 %%mask){\n", name)
+					packed := "poison"
+					for i := 0; i < 64; i++ {
+						fmt.Fprintf(&wrappers, " %%address%d=getelementptr i8,ptr %%input,i64 %d\n %%byte%d=load i8,ptr %%address%d,align 1\n %%pack%d=insertvalue [64 x i8] %s,i8 %%byte%d,%d\n", i, i, i, i, i, packed, i, i)
+						packed = fmt.Sprintf("%%pack%d", i)
+					}
+					fmt.Fprintf(&wrappers, " call void @%s([64 x i8] %s,ptr %%output,i64 %%mask)\n ret void\n}\n", name, packed)
+					fmt.Fprintf(&declarations, "extern void check_%s(const uint8_t*,uint8_t*,uint64_t);\n", name)
+					fmt.Fprintf(&checks, `
+ for(int round=0;round<16;++round) for(int m=0;m<4;++m) {
+  uint8_t input[66],output[66],before[64];memset(input,0xa7,66);memset(output,0xc3,66);
+  for(int i=0;i<64;++i) {input[i+1]=(uint8_t)(i*17+round*31);before[i]=(uint8_t)(i*23+round*41);output[i+1]=before[i];}
+  check_%[1]s(input+1,output+1,masks[m]);
+  for(int i=0;i<%[2]d;i+=%[3]d) {
+   uint64_t sum=lane(input+1+(%[4]d?0:i),%[3]d)+lane(before+i,%[3]d);
+   int active=%[5]d==0 || ((masks[m]>>(i/%[3]d))&1);
+   for(int j=0;j<%[3]d;++j) {
+    uint8_t want=active?(uint8_t)(sum>>(8*j)):%[5]d==2?0:before[i+j];
+    if(output[i+j+1]!=want) {fprintf(stderr,"%[1]s FP byte=%%d got=%%x want=%%x\n",i+j,output[i+j+1],want);return 1;}
+   }
+  }
+  if(input[0]!=0xa7 || input[65]!=0xa7 || output[0]!=0xc3 || output[65]!=0xc3) return 1;
+ }
+`, name, width, bits/8, x86FloatAddSubBoolInt(broadcast), mode)
+				}
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", definitions.String(), true)
+	file, err := Parse(ArchAMD64, definitions.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir += wrappers.String()
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86PackedAddIndependentOracle + "int main(void){\n" + checks.String() + "return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "wrapping-add-fp", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d complete independent-byte FP programs × 64 logical-value cases at O0/O2; no native FP backing or alignment claim", count)
+}
diff --git a/amd64_packed_align_fault_unix_test.go b/amd64_packed_align_fault_unix_test.go
new file mode 100644
index 000000000..4d559392b
--- /dev/null
+++ b/amd64_packed_align_fault_unix_test.go
@@ -0,0 +1,231 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// E4NF access behavior executes independently of AVX512 hardware. The separate
+// native legacy root below compares actual original Go opcode bytes.
+func TestX86PackedAlignDeadE4NFReadsFaultAtFullTuple(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable guard-page oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, row := range x86PackedAlignRows()[1:] {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && row.bits == 8 {
+					continue
+				}
+				op, bytes := row.op, amd64VectorByteWidth(Reg(bank+"0"))
+				if broadcast {
+					op, bytes = op+".BCST", row.bits/8
+				}
+				name := fmt.Sprint("AlignDead", count)
+				instruction := x86PackedAlignInstruction(op+".Z", "(AX)", bank, "K1,", 255, 2, false)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\nKMOVQ mask+8(FP),K1\n"+
+					"VPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nRET\n", name, instruction)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *,uint64_t);\n", name)
+				fmt.Fprintf(&metadata, "{%s,%d},\n", name, bytes)
+				count++
+			}
+		}
+	}
+	if count != 15 {
+		t.Fatal("incomplete native tuple/broadcast inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + `
+typedef void (*Kernel)(const uint8_t *,uint64_t);
+typedef struct {Kernel run;int bytes;} Row;
+static const Row rows[]={
+` + metadata.String() + `
+};
+static int fault(Kernel run,const uint8_t *p,uint64_t mask) {
+  pid_t child=fork();
+  if(child<0) return -1;
+  if(!child) {
+    struct rlimit limit={0,0};
+    if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+    run(p,mask);
+    _exit(0);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+  return WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)?1:-4;
+}
+int main(void) {
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(p==MAP_FAILED || mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  for(long i=0;i<page;i++) p[i]=(uint8_t)(i*17+3);
+  const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000)};
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+      if(fault(rows[r].run,0,masks[m])!=1 ||
+         fault(rows[r].run,p+page-rows[r].bytes,masks[m])!=0 ||
+         fault(rows[r].run,p+page-rows[r].bytes+1,masks[m])!=1) {
+        fprintf(stderr,"align full-tuple row=%u mask=%u bytes=%d\n",r,m,rows[r].bytes);
+        return 1;
+      }
+    }
+  }
+  return munmap(p,(size_t)page*2)?1:0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "align_dead_native", triple, ir, mainC)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedAlignLegacyNativeFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, references, metadata strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, immediate := range []int{0, 1, 16, 31, 32, 255} {
+		code := assembleX87ControlBytes(t, "amd64", fmt.Sprintf("TEXT f(SB),4,$0-0\nPALIGNR $%d,(SI),X1\nRET\n", immediate))
+		if len(code) != 7 || code[0] != 0x66 || code[1] != 0x0f || code[2] != 0x3a || code[3] != 0x0f || code[4] != 0x0e || int(code[5]) != immediate || code[6] != 0xc3 {
+			t.Fatal("original Go m128 opcode observation changed", immediate, code)
+		}
+		var literals []string
+		for _, value := range code[:6] {
+			literals = append(literals, fmt.Sprintf("0x%02x", value))
+		}
+		for _, dead := range []bool{false, true} {
+			name := fmt.Sprintf("AlignLegacy%d_%t", immediate, dead)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ p+8(FP),SI\nMOVQ old+16(FP),DX\n"+
+				"MOVOU (DX),X1\nSTC\nPALIGNR $%d,(SI),X1\n", name, immediate)
+			tail := ""
+			if !dead {
+				source.WriteString("MOVOU X1,(DI)\nSETCS 16(DI)\n")
+				tail = "; movdqu %%xmm1,(%%rdi); setc 16(%%rdi)"
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+			fmt.Fprintf(&declarations, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *);\n", name)
+			fmt.Fprintf(&references, `static void original_%s(uint8_t *out,const uint8_t *p,const uint8_t *old) {
+  __asm__ volatile("movdqu (%%%%rdx),%%%%xmm1; stc; .byte %s%s" :: "D"(out),"S"(p),"d"(old) : "xmm1","cc","memory");
+}
+`, name, strings.Join(literals, ","), tail)
+			fmt.Fprintf(&metadata, "{%s,original_%s,%d,%d},\n", name, name, immediate, x86FloatAddSubBoolInt(dead))
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := fmt.Sprintf("#define NATIVE_LINUX %d\n", x86FloatAddSubBoolInt(runtime.GOOS == "linux" && runtime.GOARCH == "amd64")) + `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + references.String() + `
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *);
+typedef struct {Kernel run,original;int count,dead;} Row;
+static const Row rows[]={
+` + metadata.String() + `
+};
+static int observe(Kernel run,const uint8_t *p,int count,int dead) {
+  pid_t child=fork();
+  if(child<0) return -1;
+  if(!child) {
+    struct rlimit limit={0,0};
+    if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+    uint8_t old[16],out[19];
+    for(int i=0;i<16;i++) old[i]=(uint8_t)(i*13+71);
+    memset(out,0xa7,sizeof(out));
+    run(out+1,p,old);
+    if(out[0]!=0xa7 || out[18]!=0xa7) _exit(2);
+    for(int i=0;i<17;i++) {
+      uint8_t expected=0xa7;
+      if(!dead) {
+        int at=i+count;
+        expected=i==16?1:at>=32?0:at<16?p[at]:old[at-16];
+      }
+      if(out[i+1]!=expected) _exit(3);
+    }
+    _exit(0);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+  return WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)?1:-4;
+}
+int main(void) {
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(p==MAP_FAILED || mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  for(long i=0;i<page;i++) p[i]=(uint8_t)(i*17+3);
+  const uint8_t *inputs[]={p,p+page-16,p+1,p+page-15,0};
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    for(unsigned c=0;c<sizeof(inputs)/sizeof(inputs[0]);c++) {
+      Row row=rows[r];
+      int original=observe(row.original,inputs[c],row.count,row.dead);
+      int translated=observe(row.run,inputs[c],row.count,row.dead);
+      if(original!=translated || original<0 || (c<2 && original!=0) || (c>=3 && original!=1) || (NATIVE_LINUX && c==2 && original!=1)) {
+        fprintf(stderr,"legacy alignment row=%u case=%u original=%d translated=%d\n",r,c,original,translated);
+        return 1;
+      }
+    }
+  }
+  return munmap(p,(size_t)page*2)?1:0;
+}
+`
+	for _, pipeline := range []struct {
+		name      string
+		optimized bool
+		backend   int
+	}{
+		{name: "backend_O0"}, {name: "backend_O2", backend: 2}, {name: "IR_O2/backend_O2", optimized: true, backend: 2},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			text := ir
+			if pipeline.optimized {
+				text = x86DwordProductIROptimize(t, ir)
+			}
+			compiler := []string{clang}
+			if triple != testTargetTriple(runtime.GOOS, runtime.GOARCH) {
+				compiler = append(compiler, "-target", triple)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "align_legacy_native", triple, text, mainC, prefix, pipeline.backend)
+		})
+	}
+}
diff --git a/amd64_packed_align_forms.go b/amd64_packed_align_forms.go
new file mode 100644
index 000000000..fd9f9fcfd
--- /dev/null
+++ b/amd64_packed_align_forms.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedAlignSpec struct {
+	x86PackedBinarySpec
+	bits int
+}
+
+// The immediate and selector differ; operand widths, masks and original
+// memory envelopes use the same complete binary grammar as other families.
+var x86PackedAlignSpecs = map[Op]x86PackedAlignSpec{
+	"PALIGNR":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, bits: 8},
+	"VPALIGNR": {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, bits: 8},
+	"VALIGND":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 4, zeroing: true}, bits: 32},
+	"VALIGNQ":  {x86PackedBinarySpec: x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true}, bits: 64},
+}
+
+type x86PackedAlignForm struct {
+	x86PackedBinaryForm
+	spec      x86PackedAlignSpec
+	immediate uint8
+}
+
+func x86PackedAlignProperties(op Op, ins Instr, arch string) (x86PackedAlignForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86PackedAlignSpecs[Op(base)]
+	result := x86PackedAlignForm{spec: spec}
+	if !known {
+		return result, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) < 3 || len(ins.Args) > 5 || arch == "386" && spec.encoding != x86PackedLogicalLegacyFP {
+		return result, true, fmt.Errorf("%s %s has an unbound dispatch or named operand arity", arch, op)
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || !amd64UnsignedImmediate(immediate, 8) {
+		return result, true, fmt.Errorf("%s %s requires Go's complete Yu8 immediate class", arch, op)
+	}
+	local := ins
+	local.Op, local.Args = op, ins.Args[1:]
+	var err error
+	result.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, spec.x86PackedBinarySpec, false)
+	result.first++
+	result.second++
+	result.destination++
+	if result.memory >= 0 {
+		result.memory++
+	}
+	if result.mask >= 0 {
+		result.mask++
+	}
+	result.immediate = uint8(immediate.Imm)
+	return result, true, err
+}
+
+// Return a byte in the first/second concatenated vectors, or -1 for a known
+// zero. PALIGNR is lane-local and saturates; VALIGN wraps its element count
+// and crosses the complete physical vector, not each 128-bit lane.
+func (f x86PackedAlignForm) sourceByte(output int) int {
+	if f.spec.bits == 8 {
+		selected := output%16 + int(f.immediate)
+		if selected >= 32 {
+			return -1
+		}
+		if selected < 16 {
+			return output/16*16 + selected
+		}
+		return f.byteWidth + output/16*16 + selected - 16
+	}
+	bytes := f.spec.bits / 8
+	count := int(f.immediate) & (f.byteWidth/bytes - 1)
+	return (output/bytes+count)*bytes + output%bytes
+}
+
+func (f x86PackedAlignForm) definedBytes(first, second, old uint64) uint64 {
+	var defined uint64
+	for output := 0; output < f.byteWidth; output++ {
+		at, known := f.sourceByte(output), false
+		if at < 0 {
+			known = true
+		} else if at < f.byteWidth {
+			known = first>>uint(at)&1 != 0
+		} else {
+			known = second>>uint(at-f.byteWidth)&1 != 0
+		}
+		if f.mask >= 0 && !f.zeroing {
+			known = known && old>>uint(output)&1 != 0
+		}
+		if known {
+			defined |= uint64(1) << uint(output)
+		}
+	}
+	return defined
+}
+
+func x86TypedPackedAlignByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedAlignProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{
+		requiresResultProof: x86ResultNamedPredicateInstruction(ins),
+		operands: []x86TypedByteOperand{
+			{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+			{index: form.second, operand: ins.Args[form.second], width: width, read: true},
+			{index: form.destination, operand: ins.Args[form.destination], width: width,
+				read: form.mask >= 0 && !form.zeroing, write: true},
+		},
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_align_forms_test.go b/amd64_packed_align_forms_test.go
new file mode 100644
index 000000000..532d10a03
--- /dev/null
+++ b/amd64_packed_align_forms_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedAlignCompleteIndependentGoRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{"{APALIGNR, ypalignr, Pq, opBytes{0x3a, 0x0f}}", "var ypalignr = []ytab{\n\t{Zibm_r, 2, argList{Yu8, Yxm, Yxr}},\n}"} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("complete legacy align table changed", row)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VPALIGNR" && rule.Opcode != "VALIGND" && rule.Opcode != "VALIGNQ" {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		classes := []string{"Yu8,YxmEvex,YxrEvex,YxrEvex", "Yu8,YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"Yu8,YymEvex,YyrEvex,YyrEvex", "Yu8,YymEvex,YyrEvex,Yknot0,YyrEvex", "Yu8,Yzm,Yzr,Yzr", "Yu8,Yzm,Yzr,Yknot0,Yzr"}
+		offsets, advances := []int{0, 0, 3, 3, 6, 6}, []int{0, 3, 0, 3, 0, 3}
+		ytab, opcode, w, zcase := "_yvalignd", "0x03", 0, "Zevex_i_rm_v_r"
+		if rule.Opcode == "VALIGNQ" {
+			w = 1
+		}
+		var attributes []string
+		if rule.Opcode == "VPALIGNR" {
+			ytab, opcode = "_yvgf2p8affineinvqb", "0x0F"
+			classes = append([]string{"Yu8,Yxm,Yxr,Yxr", "Yu8,Yym,Yyr,Yyr"}, classes...)
+			offsets, advances = []int{0, 2, 4, 4, 7, 7, 10, 10}, []int{2, 2, 0, 3, 0, 3, 0, 3}
+			attributes = []string{"avxEscape | vex128 | vex66 | vex0F3A | vexW0", opcode,
+				"avxEscape | vex256 | vex66 | vex0F3A | vexW0", opcode}
+		}
+		for _, bits := range []int{128, 256, 512} {
+			memory := fmt.Sprintf("evexN%d", bits/8)
+			if rule.Opcode != "VPALIGNR" {
+				memory += fmt.Sprintf(" | evexBcstN%d", 4*(w+1))
+			}
+			memory += " | evexZeroingEnabled"
+			attributes = append(attributes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F3A | evexW%d", bits, w), memory, opcode)
+		}
+		if rule.Opcode == "VPALIGNR" && index < 2 {
+			zcase = "Zvex_i_rm_v_r"
+		} else if index%2 != 0 {
+			zcase = "Zevex_i_rm_v_k_r"
+		}
+		if index >= len(classes) || rule.RowIndex != index || rule.Ytab != ytab || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != advances[index] || rule.EncodingOffset != offsets[index] ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, attributes) {
+			t.Fatal("independent complete align encoder row or attributes changed", rule)
+		}
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VPALIGNR": 8, "VALIGND": 6, "VALIGNQ": 6}) {
+		t.Fatal("complete twenty AVX plus one legacy row inventory changed", counts)
+	}
+}
+
+func TestX86PackedAlignNativeCarrierAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		ins := x86ScalarLaneInstruction(t, "PALIGNR $255,(AX),X2")
+		fn := Func{Instrs: []Instr{ins}}
+		features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, fn)
+		if features != "+sse2,+ssse3" {
+			t.Fatal("isolated native PALIGNR borrowed another function's features", arch, features)
+		}
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+		state.pointerGP[0] = true
+		before := state.clone()
+		if accepted, known := x86ResultPackedAlignStep(ins, &state, nil, arch, false); !known || accepted || !reflect.DeepEqual(state, before) {
+			t.Fatal("standalone observer acquired a native read")
+		}
+		if accepted, known := x86ResultPackedAlignStep(ins, &state, nil, arch, true); !known || !accepted || state.vectorBytes(2)&0xffff != 0xffff {
+			t.Fatal("continuing past the native opcode lost the large-count known-zero result")
+		}
+		for _, mutation := range []string{"pointer", "encoded", "raw", "segment", "address", "raw-return"} {
+			changed, input := ins, before.clone()
+			switch mutation {
+			case "pointer":
+				input.pointerGP[0] = false
+			case "encoded":
+				changed.x86Encoded = true
+			case "raw":
+				changed.x86SourceRaw = new(x86SourceRawInstruction)
+			case "segment":
+				changed.x86SegmentPrefix = 0x64
+			case "address":
+				changed.x86AddressBits = 32
+			case "raw-return":
+				changed.x86RawNearReturn = new(x86RawNearReturnForm)
+			}
+			original := input.clone()
+			if accepted, _ := x86ResultPackedAlignStep(changed, &input, nil, arch, true); accepted || !reflect.DeepEqual(input, original) {
+				t.Fatal("native continuation invented an address or physical origin", arch, mutation)
+			}
+		}
+	}
+}
+
+func TestX86PackedAlignMode32ImmediateUsesGoConstantClass(t *testing.T) {
+	for _, immediate := range []int64{0, 255, 4294967296, 4294967551} {
+		row := fmt.Sprintf("PALIGNR $%d,X0,X2", immediate)
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+		ins := x86ScalarLaneInstruction(t, row)
+		form, known, err := x86PackedAlignProperties(ins.Op, ins, "386")
+		if !known || err != nil || form.immediate != byte(immediate) {
+			t.Fatal("mode32 source class did not preserve Go's actual imm8", immediate, form, err)
+		}
+	}
+}
diff --git a/amd64_packed_align_runtime_test.go b/amd64_packed_align_runtime_test.go
new file mode 100644
index 000000000..7e155bfe5
--- /dev/null
+++ b/amd64_packed_align_runtime_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86PackedAlignWholeBytes(t *testing.T, bank string) {
+	t.Helper()
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable whole-byte oracle requires its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count, pending, batches := 0, 0, 0
+	flush := func() {
+		if pending < 1 || pending > 64 {
+			t.Fatal("invalid bounded runtime batch", pending)
+		}
+		t.Run(fmt.Sprint("batch", batches), func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+			if err != nil {
+				t.Fatal("initialized whole-byte source rejected", err)
+			}
+			mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);
+typedef struct {Kernel run;int width,bits,selector,legacy,mode;} Row;
+static const Row rows[]={
+` + metadata.String() + `
+};
+int main(void) {
+  const uint64_t masks[]={0,UINT64_MAX,UINT64_C(0xa5a5a5a5a5a5a5a5),UINT64_C(0x8000000000000000),1};
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    Row row=rows[r];
+    for(int trial=0;trial<32;trial++) {
+      uint8_t first[64],second[64],old[64],out[259],want[257];
+      for(int i=0;i<64;i++) {
+        first[i]=(uint8_t)(i*23+trial*37+19);
+        second[i]=(uint8_t)(i*47+trial*13+71);
+        old[i]=(uint8_t)(i*11+trial*53+139);
+      }
+      uint64_t mask=masks[trial%5];
+      memset(out,0xa7,sizeof(out));
+      memset(want,0,sizeof(want));
+      memcpy(want+64,first,64);
+      memcpy(want+128,second,64);
+      memcpy(want+192,old,64);
+      if(row.legacy) memcpy(want+16,old+16,48);
+      want[256]=1;
+      for(int output=0;output<row.width;output++) {
+        uint8_t value=0;
+        if(row.bits==8) {
+          int at=output%16+row.selector;
+          if(at<16) value=first[output/16*16+at];
+          else if(at<32) value=(row.legacy?old:second)[output/16*16+at-16];
+        } else {
+          int bytes=row.bits/8;
+          int at=(output/bytes+(row.selector&(row.width/bytes-1)))*bytes+output%bytes;
+          value=at<row.width?first[at]:second[at-row.width];
+        }
+        int lane=output/(row.bits/8);
+        if(row.mode && !((mask>>lane)&1)) value=row.mode==2?0:old[output];
+        want[output]=value;
+      }
+      row.run(out+1,first,second,old,mask);
+      if(out[0]!=0xa7 || out[258]!=0xa7 || memcmp(out+1,want,sizeof(want))) {
+        fprintf(stderr,"align row=%u trial=%d bits=%d width=%d selector=%d legacy=%d mode=%d\n",r,trial,row.bits,row.width,row.selector,row.legacy,row.mode);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "align_whole_"+bank, triple, ir, mainC)
+		})
+		batches++
+		pending = 0
+		source.Reset()
+		declarations.Reset()
+		prototypes.Reset()
+		metadata.Reset()
+	}
+	for _, row := range x86PackedAlignRows() {
+		if row.legacy && bank != "X" {
+			continue
+		}
+		for mode, suffix := range []string{"", "", ".Z"} {
+			if row.legacy && mode != 0 {
+				continue
+			}
+			for _, immediate := range []int{0, 1, 15, 16, 17, 31, 32, 255} {
+				name, mask, legacy := fmt.Sprint("AlignWhole", count), "", 0
+				if mode != 0 {
+					mask = "K1,"
+				}
+				if row.legacy {
+					legacy = 1
+				}
+				instruction := x86PackedAlignInstruction(row.op+suffix, bank+"0", bank, mask, immediate, 2, row.legacy)
+				fmt.Fprintf(&declarations, "func %s(out *[257]byte,a,b,old *[64]byte,mask uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ old+24(FP),DX\n"+
+					"VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (DX),Z2\nVMOVUPS (DX),Z3\nKMOVQ mask+32(FP),K1\nSTC\n%s\n"+
+					"VMOVUPS Z2,0(DI)\nVMOVUPS Z0,64(DI)\nVMOVUPS Z1,128(DI)\nVMOVUPS Z3,192(DI)\nSETCS 256(DI)\nRET\n", name, instruction)
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", name)
+				fmt.Fprintf(&metadata, "{%s,%d,%d,%d,%d,%d},\n", name, amd64VectorByteWidth(Reg(bank+"0")), row.bits, immediate, legacy, mode)
+				count++
+				pending++
+				if pending == 64 {
+					flush()
+				}
+			}
+		}
+	}
+	want := 72
+	if bank == "X" {
+		want = 80
+	}
+	if count != want {
+		t.Fatal("incomplete whole-byte family/mask/selector union", count, want)
+	}
+	if pending != 0 {
+		flush()
+	}
+	if batches != 2 {
+		t.Fatal("incomplete bounded runtime union", batches)
+	}
+}
+
+func TestX86PackedAlignWholeXByteSemantics(t *testing.T) {
+	x86PackedAlignWholeBytes(t, "X")
+}
+
+func TestX86PackedAlignWholeYByteSemantics(t *testing.T) {
+	x86PackedAlignWholeBytes(t, "Y")
+}
+
+func TestX86PackedAlignWholeZByteSemantics(t *testing.T) {
+	x86PackedAlignWholeBytes(t, "Z")
+}
diff --git a/amd64_packed_arithmetic_allocation_test.go b/amd64_packed_arithmetic_allocation_test.go
new file mode 100644
index 000000000..befe35576
--- /dev/null
+++ b/amd64_packed_arithmetic_allocation_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+var x86PackedArithmeticQuerySink x86LegacyIntegerArithmeticForm
+
+func TestX86LegacyIntegerArithmeticQueryIsReadOnlyAndBounded(t *testing.T) {
+	rows := []struct {
+		instruction string
+		source      Reg
+		allocations float64
+	}{
+		{"PADDQ X0,X1", "X0", 0},
+		{"PSUBL X0,X1", "X0", 0},
+		{"PADDB X0,X1", "X0", 1},
+	}
+	for _, bank := range []struct{ input, physical Reg }{
+		{AX, "M0"}, {CX, "M1"}, {DX, "M2"}, {BX, "M3"},
+		{SP, "M4"}, {BP, "M5"}, {SI, "M6"}, {DI, "M7"},
+		{"R8", "M0"}, {"R9", "M1"}, {"R10", "M2"}, {"R11", "M3"},
+		{"R12", "M4"}, {"R13", "M5"}, {"R14", "M6"}, {"R15", "M7"},
+	} {
+		rows = append(rows, struct {
+			instruction string
+			source      Reg
+			allocations float64
+		}{"PADDB " + string(bank.input) + ",M1", bank.physical, 1})
+	}
+	for _, row := range rows {
+		t.Run(row.instruction, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction)
+			before := ins
+			before.Args = append([]Operand(nil), ins.Args...)
+			var known bool
+			var err error
+			allocations := testing.AllocsPerRun(100, func() {
+				x86PackedArithmeticQuerySink, known, err = x86LegacyIntegerArithmeticProperties(ins.Op, ins, "amd64")
+			})
+			if !known || err != nil || x86PackedArithmeticQuerySink.source.Reg != row.source {
+				t.Fatal("query lost the original physical bank", known, err, x86PackedArithmeticQuerySink.source)
+			}
+			if !reflect.DeepEqual(ins, before) {
+				t.Fatal("read-only shape query changed its original input")
+			}
+			if x86PackedArithmeticQuerySink.mmx && !errors.Is(x86LegacyIntegerArithmeticEmitterContext(x86PackedArithmeticQuerySink, ins), ErrProbeNeedsContext) {
+				t.Fatal("physical bank projection acquired emitter permission")
+			}
+			if allocations > row.allocations {
+				t.Errorf("shape query allocates %.0f times; at most %.0f physical projections needed", allocations, row.allocations)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_arithmetic_boundary_test.go b/amd64_packed_arithmetic_boundary_test.go
new file mode 100644
index 000000000..320198410
--- /dev/null
+++ b/amd64_packed_arithmetic_boundary_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86PackedArithmeticFamilyMissesStayEmpty(t *testing.T) {
+	for _, row := range []struct {
+		op       Op
+		families x86PackedArithmeticFamily
+	}{
+		{"MOVQ", 0},
+		{"VPADDB", x86PackedArithmeticSubtract},
+		{"VPSUBD", x86PackedArithmeticAdd},
+		{"VPMULLQ", x86PackedArithmeticAdd | x86PackedArithmeticSubtract},
+		{"PADDD", x86PackedArithmeticLowMultiply},
+	} {
+		t.Run(fmt.Sprintf("%s/families%d", row.op, row.families), func(t *testing.T) {
+			spec, known := x86PackedArithmeticSpecForOp(row.op, row.families)
+			if known || spec != (x86PackedArithmeticSpec{}) {
+				t.Fatal("unrecognized family leaked another family's metadata", known, spec)
+			}
+			form, known, err := x86PackedArithmeticProperties(row.op, Instr{Op: row.op}, "amd64", row.families)
+			if known || err != nil || form != (x86PackedArithmeticForm{}) {
+				t.Fatal("unrecognized family began physical parsing", known, err, form)
+			}
+		})
+	}
+}
+
+func TestX86PackedSubtractMetadataRetainsBareNameContract(t *testing.T) {
+	for _, name := range []string{"", "VPADDB", "VPMULLQ", "vpsubd", "VPSUBD.BAD", "VPSUBD.Z", " VPSUBD"} {
+		t.Run(name, func(t *testing.T) {
+			bits, mode, vector, known := amd64PackedSubtractProperties(name)
+			if known || bits != 0 || mode != 0 || vector {
+				t.Fatal("bare-name query changed its unrecognized result", bits, mode, vector, known)
+			}
+		})
+	}
+	bits, mode, vector, known := amd64PackedSubtractProperties("VPSUBD")
+	if !known || bits != 32 || mode != amd64PackedSubtractWrap || !vector {
+		t.Fatal("original bare opcode was lost", bits, mode, vector, known)
+	}
+}
+
+func TestX86PackedArithmeticDispatchKeepsExactSourceIdentity(t *testing.T) {
+	for _, row := range []struct {
+		op          Op
+		instruction string
+	}{
+		{"VPADDD", "VPSUBQ Y0,Y1,Y2"},
+		{"VPSUBD", "VPADDD Y0,Y1,Y2"},
+		{"VPADDUSB", "VPADDB Y0,Y1,Y2"},
+		{"PADDD", "PADDL X0,X1"},
+		{"VPMULLD", "VPADDD Y0,Y1,Y2"},
+	} {
+		t.Run(string(row.op), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction)
+			form, known, err := x86PackedArithmeticProperties(row.op, ins, "amd64", 0)
+			if !known || err == nil || form != (x86PackedArithmeticForm{}) {
+				t.Fatal("dispatch replaced the original source opcode", known, err, form)
+			}
+		})
+	}
+	// Case folding is still allowed; this establishes syntax only, not NUM.
+	ins := x86ScalarLaneInstruction(t, "VPSUBD Y0,Y1,Y2")
+	if _, known, err := x86PackedArithmeticProperties("vpsubd", ins, "amd64", 0); !known || err != nil {
+		t.Fatal("case-equivalent original opcode was lost", known, err)
+	}
+}
diff --git a/amd64_packed_arithmetic_forms.go b/amd64_packed_arithmetic_forms.go
new file mode 100644
index 000000000..e027f82df
--- /dev/null
+++ b/amd64_packed_arithmetic_forms.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedArithmeticFamily uint8
+
+const (
+	x86PackedArithmeticAdd x86PackedArithmeticFamily = 1 << iota
+	x86PackedArithmeticSubtract
+	x86PackedArithmeticLowMultiply
+)
+
+type x86PackedArithmeticMode uint8
+
+const (
+	x86PackedWrap x86PackedArithmeticMode = iota
+	x86PackedSignedSaturating
+	x86PackedUnsignedSaturating
+)
+
+type x86PackedArithmeticSpec struct {
+	x86PackedBinarySpec
+	laneBits int
+	family   x86PackedArithmeticFamily
+	mode     x86PackedArithmeticMode
+}
+
+// One catalog owns all add/sub/DQ-low-product source spellings. Width, encoding,
+// saturation and broadcast are independent axes constrained by Go's tables.
+// PADDD aliases PADDL; word products retain their separate MMX grammar.
+var x86PackedArithmeticSpecs = map[Op]x86PackedArithmeticSpec{
+	"PADDB":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 8, x86PackedArithmeticAdd, x86PackedWrap},
+	"PADDW":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, x86PackedArithmeticAdd, x86PackedWrap},
+	"PADDL":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 32, x86PackedArithmeticAdd, x86PackedWrap},
+	"PADDD":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 32, x86PackedArithmeticAdd, x86PackedWrap},
+	"PADDQ":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 64, x86PackedArithmeticAdd, x86PackedWrap},
+	"PADDSB":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 8, x86PackedArithmeticAdd, x86PackedSignedSaturating},
+	"PADDSW":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, x86PackedArithmeticAdd, x86PackedSignedSaturating},
+	"PADDUSB":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 8, x86PackedArithmeticAdd, x86PackedUnsignedSaturating},
+	"PADDUSW":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, x86PackedArithmeticAdd, x86PackedUnsignedSaturating},
+	"VPADDB":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticAdd, x86PackedWrap},
+	"VPADDW":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticAdd, x86PackedWrap},
+	"VPADDD":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, 32, x86PackedArithmeticAdd, x86PackedWrap},
+	"VPADDQ":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 8, zeroing: true}, 64, x86PackedArithmeticAdd, x86PackedWrap},
+	"VPADDSB":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticAdd, x86PackedSignedSaturating},
+	"VPADDSW":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticAdd, x86PackedSignedSaturating},
+	"VPADDUSB": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticAdd, x86PackedUnsignedSaturating},
+	"VPADDUSW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticAdd, x86PackedUnsignedSaturating},
+
+	"PSUBB":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 8, x86PackedArithmeticSubtract, x86PackedWrap},
+	"PSUBW":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 16, x86PackedArithmeticSubtract, x86PackedWrap},
+	"PSUBL":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 32, x86PackedArithmeticSubtract, x86PackedWrap},
+	"PSUBQ":    {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 64, x86PackedArithmeticSubtract, x86PackedWrap},
+	"PSUBSB":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 8, x86PackedArithmeticSubtract, x86PackedSignedSaturating},
+	"PSUBSW":   {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 16, x86PackedArithmeticSubtract, x86PackedSignedSaturating},
+	"PSUBUSB":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 8, x86PackedArithmeticSubtract, x86PackedUnsignedSaturating},
+	"PSUBUSW":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 16, x86PackedArithmeticSubtract, x86PackedUnsignedSaturating},
+	"VPSUBB":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticSubtract, x86PackedWrap},
+	"VPSUBW":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticSubtract, x86PackedWrap},
+	"VPSUBD":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, 32, x86PackedArithmeticSubtract, x86PackedWrap},
+	"VPSUBQ":   {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 8, zeroing: true}, 64, x86PackedArithmeticSubtract, x86PackedWrap},
+	"VPSUBSB":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticSubtract, x86PackedSignedSaturating},
+	"VPSUBSW":  {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticSubtract, x86PackedSignedSaturating},
+	"VPSUBUSB": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8, x86PackedArithmeticSubtract, x86PackedUnsignedSaturating},
+	"VPSUBUSW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, x86PackedArithmeticSubtract, x86PackedUnsignedSaturating},
+
+	"PMULLD":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 32, x86PackedArithmeticLowMultiply, x86PackedWrap},
+	"VPMULLD": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, 32, x86PackedArithmeticLowMultiply, x86PackedWrap},
+	"VPMULLQ": {x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true}, 64, x86PackedArithmeticLowMultiply, x86PackedWrap},
+}
+
+type x86PackedArithmeticForm struct {
+	x86PackedBinaryForm
+	spec x86PackedArithmeticSpec
+}
+
+func x86PackedArithmeticSpecForOp(op Op, families x86PackedArithmeticFamily) (x86PackedArithmeticSpec, bool) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86PackedArithmeticSpecs[Op(base)]
+	if !known || families != 0 && spec.family&families == 0 {
+		return x86PackedArithmeticSpec{}, false
+	}
+	return spec, true
+}
+
+func x86PackedArithmeticProperties(op Op, ins Instr, arch string, families x86PackedArithmeticFamily) (x86PackedArithmeticForm, bool, error) {
+	spec, known := x86PackedArithmeticSpecForOp(op, families)
+	if !known {
+		return x86PackedArithmeticForm{}, false, nil
+	}
+	return x86PackedArithmeticFormForSpec(op, ins, arch, spec)
+}
+
+// A validated shape supplies no initialized values, storage or caller facts.
+// Legacy bank projection and decoder-only mode32 adaptation remain distinct.
+func x86PackedArithmeticFormForSpec(op Op, ins Instr, arch string, spec x86PackedArithmeticSpec) (x86PackedArithmeticForm, bool, error) {
+	low := spec.family == x86PackedArithmeticLowMultiply
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		family := "arithmetic"
+		if low {
+			family = "low multiply"
+		}
+		return x86PackedArithmeticForm{}, true, fmt.Errorf("packed %s dispatch/source opcode mismatch: %s/%s", family, op, ins.Op)
+	}
+	if !low && (spec.encoding == x86PackedLogicalLegacyFP || spec.encoding == x86PackedLogicalLegacyInteger) {
+		legacy, _, err := x86LegacyIntegerArithmeticProperties(op, ins, arch)
+		if err == nil && spec.family == x86PackedArithmeticAdd {
+			err = x86LegacyIntegerArithmeticEmitterContext(legacy, ins)
+		}
+		return x86PackedArithmeticForm{legacy.x86PackedBinaryForm, spec}, true, err
+	}
+	local := ins
+	local.Op = op
+	grammarArch := arch
+	if low && arch == "386" && local.x86Encoded && spec.encoding != x86PackedLogicalLegacyFP {
+		// Only the decoder owns this physical identity, not Go's named frontend.
+		grammarArch = "amd64"
+	}
+	binary, err := x86PackedBinaryProperties(local, grammarArch, spec.x86PackedBinarySpec)
+	if err == nil && grammarArch != arch && binary.memory >= 0 && !x86PackedShiftMemoryValid(local.Args[binary.memory], arch) {
+		err = fmt.Errorf("386 %s physical source has an unbound address", op)
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(local, arch)
+	}
+	if err == nil && low && binary.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		err = fmt.Errorf("%w: packed low multiply has no bound address-size override", ErrProbeNeedsContext)
+	}
+	return x86PackedArithmeticForm{binary, spec}, true, err
+}
diff --git a/amd64_packed_average_forms.go b/amd64_packed_average_forms.go
new file mode 100644
index 000000000..a2039711f
--- /dev/null
+++ b/amd64_packed_average_forms.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+type x86PackedAverageSpec struct {
+	x86PackedBinarySpec
+	laneBits int
+}
+
+// Go's complete unsigned rounded-average family: ymm/Py1 for legacy and
+// _yvandnpd for VEX/EVEX. E4.nb has mask suppression but no broadcast or SAE.
+var x86PackedAverageSpecs = map[Op]x86PackedAverageSpec{
+	"PAVGB":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 8},
+	"PAVGW":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16},
+	"VPAVGB": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 8},
+	"VPAVGW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16},
+}
+
+type x86PackedAverageForm = x86PackedPhysicalForm
+
+// A shape/effect observation supplies no input initialization, caller, frame
+// or native storage authority. All consumers retain their own proof gates.
+func x86PackedAverageProperties(op Op, ins Instr, arch string) (x86PackedAverageForm, bool, error) {
+	return x86PackedPhysicalProperties(op, ins, arch, x86PackedAverage)
+}
+
+func x86ResultPackedAverageStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86PackedAverageProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ResultFixedVectorInputs(ins, form.x86PackedBinaryForm, false, state, owned, arch), true
+}
diff --git a/amd64_packed_average_fp_test.go b/amd64_packed_average_fp_test.go
new file mode 100644
index 000000000..c9f8a32fc
--- /dev/null
+++ b/amd64_packed_average_fp_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedAverageFPSpansThreeAPIsFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		t.Run(triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			declarations.WriteString("package oracle\n")
+			count := 0
+			for _, op := range x86AverageNames[2:] {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, mode := range []int{0, 1, 2} {
+						if arch == "386" && mode != 0 {
+							continue // Actual named Go rejection is tested independently.
+						}
+						name := fmt.Sprintf("F%d", count)
+						count++
+						row := op
+						if mode == 2 {
+							row += ".Z"
+						}
+						row += " input+0(FP)," + bank + "1"
+						if mode != 0 {
+							row += ",K1"
+						}
+						row += "," + bank + "2"
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-64\n%s\nRET\n", name, row)
+						fmt.Fprintf(&declarations, "func %s(input [64]byte)\n", name)
+					}
+				}
+			}
+			if arch == "amd64" {
+				for _, op := range x86AverageNames[:2] {
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-64\n%s input+0(FP),M1\nRET\n", count, op)
+					fmt.Fprintf(&declarations, "func F%d(input [64]byte)\n", count)
+					count++
+				}
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			pkg := mustGoPackage(t, "oracle", declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]FuncSig{}
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs[name] = sig
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original FP format source invented a vector/mask/MMX input", api, err)
+				}
+			}
+			ir := x86AverageFormatObjectUnit(t, file, sigs, arch, triple)
+			x86ResultInitializationObject(t, llc, triple, ir, "average-fp-original-emitter-only")
+
+			var initialized, completeDeclarations strings.Builder
+			complete := 0
+			for _, function := range file.Funcs {
+				instruction := function.Instrs[1]
+				if !strings.HasPrefix(string(instruction.Op), "V") {
+					continue // Original MMX rows remain object/Context controls above.
+				}
+				name := strings.TrimPrefix(function.Sym, "·")
+				fmt.Fprintf(&initialized, "TEXT ·%s(SB),4,$0-64\nMOVL $7,AX\nKMOVD AX,K1\n"+
+					"VPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nRET\n", name, instruction.Raw)
+				fmt.Fprintf(&completeDeclarations, "func %s(input [64]byte)\n", name)
+				complete++
+			}
+			want := 18
+			if arch == "386" {
+				want = 6
+			}
+			if complete != want {
+				t.Fatal("complete initialized FP row union changed", complete, want)
+			}
+			goAssemblerOracleOutput(t, arch, initialized.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, initialized.String(), completeDeclarations.String(), arch, triple, api)
+				if err != nil {
+					t.Fatal("complete initialized logical FP average rejected", api, err)
+				}
+				x86ResultInitializationObject(t, llc, triple, ir, "average-initialized-fp-"+api)
+			}
+		})
+	}
+}
+
+func TestX86PackedAverageFPHolesCannotBeMaskedAway(t *testing.T) {
+	for _, op := range x86AverageNames[2:] {
+		for index, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << index
+			for _, start := range []int{0, 1, -1, 16} {
+				for _, mode := range []string{"", ".Z"} {
+					row := fmt.Sprintf("%s%s input%+d(FP),%s1,K1,%s2", op, mode, start, bank, bank)
+					source := "TEXT f(SB),4,$0-8\nKMOVQ AX,K1\n" + row + "\nRET\n"
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, frame := range []FrameLayout{
+						{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+						{Params: []FrameSlot{{Offset: 0, Type: I8, Index: 0, Field: -1}, {Offset: int64(width - 1), Type: I8, Index: 1, Field: -1}}},
+					} {
+						ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void, Args: []LLVMType{I64, I64}, Frame: frame}, nil)
+						before := output.String()
+						ins := file.Funcs[0].Instrs[2]
+						if _, _, err := ctx.lowerPackedUnsignedAverage(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+							t.Fatalf("%s incomplete logical byte span emitted IR: %v", row, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAverageRequiredLinuxOriginalVEXRegistration(t *testing.T) {
+	const name = "amd64_packed_average_original_linux_test.go"
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		ctx := build.Default
+		ctx.GOOS, ctx.GOARCH = goos, "amd64"
+		selected, err := ctx.MatchFile(".", name)
+		if err != nil || selected != (goos == "linux") {
+			t.Fatal("required original AVX axis has wrong actual Go selection", goos, selected, err)
+		}
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Decls) != 2 {
+		t.Fatal("required wrapper declaration changed")
+	}
+	fn, ok := file.Decls[1].(*ast.FuncDecl)
+	if !ok || fn.Name.Name != "TestCrossLinuxRuntimeMatrixX86PackedAverageOriginalVEXAliases" || fn.Body == nil || len(fn.Body.List) != 1 {
+		t.Fatal("required original AVX wrapper omitted or bypassed")
+	}
+	expression, ok := fn.Body.List[0].(*ast.ExprStmt)
+	if !ok {
+		t.Fatal("required wrapper is not an actual unconditional call")
+	}
+	call, ok := expression.X.(*ast.CallExpr)
+	if !ok || len(call.Args) != 2 {
+		t.Fatal("required wrapper lost its original Go helper")
+	}
+	callee, ok := call.Fun.(*ast.Ident)
+	wide, wideOK := call.Args[1].(*ast.Ident)
+	if !ok || callee.Name != "x86AverageOriginalGo" || !wideOK || wide.Name != "true" {
+		t.Fatal("required original wide alias scope was narrowed")
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") {
+		t.Fatal("required Linux CI selector does not select this family", err)
+	}
+}
diff --git a/amd64_packed_average_original_go_test.go b/amd64_packed_average_original_go_test.go
new file mode 100644
index 000000000..799b1d34f
--- /dev/null
+++ b/amd64_packed_average_original_go_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedAverageOriginalGo(t *testing.T) {
+	x86AverageOriginalGo(t, false)
+}
+
+func x86AverageOriginalGo(t *testing.T, wide bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	if wide {
+		execution.requireAVX(t)
+		x86AverageRequireAVX2(t, execution)
+	}
+	var assembly, declarations, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+
+import (
+ "testing"
+ "unsafe"
+ "runtime"
+ "encoding/binary"
+)
+
+func aligned(storage *[192]byte) (*[64]byte,int) {
+ offset:=64+int((-uintptr(unsafe.Pointer(&storage[64])))&63)
+ return (*[64]byte)(unsafe.Pointer(&storage[offset])),offset
+}
+
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread()
+ defer runtime.UnlockOSThread()
+ for sample:=0;sample<257;sample++ {
+  for status:=0;status<2;status++ {
+  var a,b,out [192]byte
+  ap,_:=aligned(&a)
+  bp,_:=aligned(&b)
+  op,offset:=aligned(&out)
+  for i:=range a {
+   a[i]=0xa7
+   b[i]=0xb9
+   out[i]=0xc3
+  }
+
+  for i:=0;i<64;i++ {
+   ap[i]=byte(sample*71+i*37)
+   bp[i]=byte(sample*19-i*13)
+   if sample<4 {
+    ap[i]=[4]byte{255,0,128,255}[sample]
+    bp[i]=[4]byte{255,1,128,0}[sample]
+   }
+  }
+  beforeA,beforeB:=a,b
+  flags:=uint64(2)
+  if status!=0 {
+   flags|=0x8d5
+  }
+  csr:=uint32(0x1f80|((sample%4)<<13)|(sample%64))
+`)
+	count := 0
+	for _, row := range x86AverageNumericCases() {
+		if row.width == 64 || row.masking != 0 || !wide && strings.HasPrefix(row.op, "V") {
+			continue // Native EVEX is a distinct, unexecuted axis here.
+		}
+		move, bank, observedWidth := "MOVUPS", "X", 16
+		if wide {
+			move, bank, observedWidth = "VMOVUPS", "Y", 32
+		}
+		name := fmt.Sprintf("Average%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$8-36
+STMXCSR saved-4(SP)
+LDMXCSR csr+32(FP)
+MOVQ out+0(FP),AX
+MOVQ a+8(FP),BX
+MOVQ b+16(FP),CX
+`, name)
+		fmt.Fprintf(&assembly, "%s (CX),%s0\n%s (CX),%s2\n", move, bank, move, bank)
+		if !row.memory || row.destination == 1 {
+			fmt.Fprintf(&assembly, "%s (BX),%s1\n", move, bank)
+		}
+		if row.mmx {
+			fmt.Fprintf(&assembly, "MOVQ (CX),M0\nMOVQ (BX),M1\n%s %s0,(AX)\n", move, bank)
+		}
+		assembly.WriteString("PUSHQ flags+24(FP)\nPOPFQ\n" + row.instruction() + "\n")
+		if row.mmx {
+			assembly.WriteString("MOVQ M0,(AX)\nEMMS\n")
+		} else {
+			fmt.Fprintf(&assembly, "%s %s%d,(AX)\n", move, bank, row.destination)
+		}
+		assembly.WriteString("PUSHFQ\nPOPQ R10\nMOVQ R10,32(AX)\nSTMXCSR 40(AX)\nLDMXCSR saved-4(SP)\nRET\n")
+		fmt.Fprintf(&tests, `{
+ for i:=range out {
+  out[i]=0xc3
+ }
+ %s(op,ap,bp,flags,csr)
+ if binary.LittleEndian.Uint64(op[32:40])&0x8d5!=flags&0x8d5 || binary.LittleEndian.Uint32(op[40:44])!=csr || a!=beforeA || b!=beforeB {
+  t.Fatal("original flags/CSR/input canary")
+ }
+ for i:=0;i<%d;i++ {
+  start:=i/%d*%d
+  x,y:=uint32(ap[start]),uint32(bp[start])
+  if %d==2 {
+   x|=uint32(ap[start+1])<<8
+   y|=uint32(bp[start+1])<<8
+  }
+  value:=(x+y+1)/2
+  want:=byte(value>>uint(8*(i%%%d)))
+  if i>=%d {
+   want=0
+   if %t {
+    want=bp[i]
+   }
+  }
+  if op[i]!=want {
+   t.Fatalf("%s sample%%d byte%%d got%%x want%%x",sample,i,op[i],want)
+  }
+ }
+ for i:=range out {
+  if (i<offset||i>=offset+44||i>=offset+%d&&i<offset+32)&&out[i]!=0xc3 {
+   t.Fatal("original output canary")
+  }
+ }
+}
+`, name, observedWidth, row.bits/8, row.bits/8, row.bits/8, row.bits/8, row.width,
+			!strings.HasPrefix(row.op, "V"), name, observedWidth)
+	}
+	tests.WriteString("}\n}\n}\n")
+	formattedTests, err := format.Source([]byte(tests.String()))
+	if err != nil {
+		t.Fatal("original Go numerical fixture is not complete syntax:", err)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n",
+		"value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": string(formattedTests)} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goos := runtime.GOOS
+	binary := filepath.Join(dir, "original.test")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "test", "-c", "-p=2", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "CGO_ENABLED=0", "GOARCH=amd64", "GOOS="+goos)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go compile/asmdecl failed: %v\n%s", err, output)
+	}
+	output = execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatal("missing actual original Go numerical receipt", string(output))
+	}
+	t.Logf("%d original Go kernels × 257 patterns × 2 flag seeds; wide=%t (16-byte SSE or 32-byte VEX aliases)/CSR/canaries. No native EVEX or whole MMX/x87-state claim", count, wide)
+}
+
+// The wide original program includes Y-width VPAVG, not just AVX X moves.
+// Missing AVX2 is a required-axis failure, never a skip or a software fallback.
+func x86AverageRequireAVX2(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	dir := t.TempDir()
+	source := filepath.Join(dir, "average-isa.c")
+	executable := filepath.Join(dir, "average-isa")
+	const preflight = `#include <stdio.h>
+int main(void) {
+  __builtin_cpu_init();
+  int avx2 = !!__builtin_cpu_supports("avx2");
+  printf("required original VPAVG Y-width AVX2=%d\n", avx2);
+  return avx2 ? 0 : 1;
+}
+`
+	if err := os.WriteFile(source, []byte(preflight), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("actual original VPAVG capability: %s", strings.TrimSpace(string(execution.run(t, executable))))
+}
diff --git a/amd64_packed_average_original_linux_test.go b/amd64_packed_average_original_linux_test.go
new file mode 100644
index 000000000..069969777
--- /dev/null
+++ b/amd64_packed_average_original_linux_test.go
@@ -0,0 +1,11 @@
+//go:build linux
+
+package plan9asm
+
+import "testing"
+
+// Required by the existing Linux cross-matrix selector. Its actual AVX
+// preflight and pinned guest transport must fail, not skip, if unavailable.
+func TestCrossLinuxRuntimeMatrixX86PackedAverageOriginalVEXAliases(t *testing.T) {
+	x86AverageOriginalGo(t, true)
+}
diff --git a/amd64_packed_average_physical_test.go b/amd64_packed_average_physical_test.go
new file mode 100644
index 000000000..3ad04fdde
--- /dev/null
+++ b/amd64_packed_average_physical_test.go
@@ -0,0 +1,298 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86AverageNames = []string{"PAVGB", "PAVGW", "VPAVGB", "VPAVGW"}
+
+// Independent of the production grammar. Named mode32 MMX is excluded by
+// Go's Py1 selector, while low X/Y/Z operands have physical mode32 identities.
+func x86AveragePhysicalRows(arch string) []string {
+	var rows []string
+	for _, name := range x86AverageNames[:2] {
+		for _, source := range []string{"X0", "X7", "(AX)", "16(AX)(CX*4)", "·data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, name+" "+source+",X1")
+		}
+		if arch == "amd64" {
+			rows = append(rows, name+" X15,X0", name+" M0,M7", name+" (AX),M7")
+		}
+	}
+	for _, name := range x86AverageNames[2:] {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{bank + "0", bank + "7", "(AX)", "16(AX)(CX*4)", "·data(SB)", "(FS)", "(GS)"} {
+				rows = append(rows, fmt.Sprintf("%s %s,%s1,%s2", name, source, bank, bank))
+				if arch == "amd64" {
+					rows = append(rows, fmt.Sprintf("%s %s,%s31,K1,%s30", name, source, bank, bank),
+						fmt.Sprintf("%s.Z %s,%s31,K7,%s30", name, source, bank, bank))
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedAverageThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i") {
+				arch = "386"
+			}
+			var source, declarations strings.Builder
+			declarations.WriteString("package oracle\n")
+			for index, row := range x86AveragePhysicalRows(arch) {
+				fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", index, row)
+				fmt.Fprintf(&declarations, "func F%d()\n", index)
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			pkg := mustGoPackage(t, "oracle", declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := make(map[string]FuncSig)
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs[name] = sig
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("complete original format source invented input or memory state", api, err)
+				}
+			}
+			ir := x86AverageFormatObjectUnit(t, file, sigs, arch, triple)
+			x86ResultInitializationObject(t, llc, triple, ir, "average-original-emitter-only")
+			x86ResultInitializationObject(t, llc, triple, x86MulDivRoundOptimize(t, ir), "average-O2")
+		})
+	}
+}
+
+func TestX86PackedAverageShapesEffectsDoNotGrantCallerPermissions(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range append(x86AveragePhysicalRows(arch), "VPAVGB.Z value+0(FP),X1,K1,X2", "VPAVGW value+0(FP),Z1,Z2") {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			before := fmt.Sprintf("%#v", ins)
+			form, known, err := x86PackedAverageProperties(ins.Op, ins, arch)
+			if arch == "386" && strings.Contains(row, "K1") {
+				if err == nil {
+					t.Fatal("named mode32 mask became a physical encoding")
+				}
+				continue
+			}
+			if !known || err != nil || before != fmt.Sprintf("%#v", ins) || x86CallerVectorMoveKnown(ins) {
+				t.Fatalf("shape changed input or acquired caller permission: %s: %v", row, err)
+			}
+			for index := range ins.Args {
+				width, write, valid := x86InstructionMemoryShape(ins, index, arch)
+				if valid != (index == form.memory) || valid && (width != int64(form.memoryBytes) || write) {
+					t.Fatal("memory read shape differs from native width", row, width, write, valid)
+				}
+			}
+			effect, observed, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if form.legacy && (!observed || err != nil || len(effect.operands) != 2 ||
+				effect.flagsDefined != 0 || effect.flagsKilled != 0 ||
+				!effect.operands[0].read || effect.operands[0].write ||
+				!effect.operands[1].read || !effect.operands[1].write ||
+				effect.operands[0].width != int64(form.byteWidth) || effect.operands[1].width != int64(form.byteWidth)) {
+				t.Fatal("legacy full input/output byte effect changed", row, effect, err)
+			}
+			// All three dispatch identities are equivalent, but a contradictory
+			// source never emits IR. Keep the existing empty direct-helper API.
+			for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(string(ins.Op))), "PADDW"} {
+				local := ins
+				local.Op = identity
+				copy := local
+				_, _, err := x86PackedAverageProperties(ins.Op, local, arch)
+				bad := identity == "PADDW"
+				if (err != nil) != bad || !reflect.DeepEqual(copy, local) {
+					t.Fatal("dispatch identity mismatch", ins.Op, identity, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAverageActualGoCompleteTables(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{APAVGB, ymm, Py1, opBytes{0xe0, Pe, 0xe0}}",
+		"{APAVGW, ymm, Py1, opBytes{0xe3, Pe, 0xe3}}",
+	} {
+		if strings.Count(string(legacy), row) != 1 {
+			t.Fatalf("actual Go legacy registration changed: %s", row)
+		}
+	}
+	start := strings.Index(string(legacy), "var ymm =")
+	if start < 0 {
+		t.Fatal("missing actual ymm table")
+	}
+	ymm := strings.SplitN(string(legacy)[start:], "\n}", 2)[0]
+	for _, row := range []string{"{Zm_r_xm, 1, argList{Ymm, Ymr}}", "{Zm_r_xm, 2, argList{Yxm, Yxr}}"} {
+		if strings.Count(ymm, "argList{") != 2 || strings.Count(ymm, row) != 1 {
+			t.Fatal("actual ymm class/selector table changed", ymm)
+		}
+	}
+	for index, name := range x86AverageNames[2:] {
+		opcode := []string{"E0", "E3"}[index]
+		expected := fmt.Sprintf(`{as: A%s, ytab: _yvandnpd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0x%s,
+		avxEscape | vex256 | vex66 | vex0F | vexW0, 0x%s,
+		avxEscape | evex128 | evex66 | evex0F | evexW0, evexN16 | evexZeroingEnabled, 0x%s,
+		avxEscape | evex256 | evex66 | evex0F | evexW0, evexN32 | evexZeroingEnabled, 0x%s,
+		avxEscape | evex512 | evex66 | evex0F | evexW0, evexN64 | evexZeroingEnabled, 0x%s,
+	}},`, name, opcode, opcode, opcode, opcode, opcode)
+		if err := x86SignedPackedFloatValidateGoOpcodeRows(string(avx), name, expected); err != nil {
+			t.Fatal(err)
+		}
+	}
+	start = strings.Index(string(avx), "var _yvandnpd =")
+	if start < 0 {
+		t.Fatal("missing actual ytab")
+	}
+	table := strings.SplitN(string(avx)[start:], "\n}", 2)[0] + "\n}"
+	if err := x86AverageValidateGoYtab(table); err != nil {
+		t.Fatal(err)
+	}
+}
+
+const x86AverageGoYtab = `var _yvandnpd = []ytab{
+ {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+ {zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}},
+ {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YxmEvex, YxrEvex, YxrEvex}},
+ {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YxmEvex, YxrEvex, Yknot0, YxrEvex}},
+ {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{YymEvex, YyrEvex, YyrEvex}},
+ {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{YymEvex, YyrEvex, Yknot0, YyrEvex}},
+ {zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+ {zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}`
+
+func x86AverageValidateGoYtab(table string) error {
+	actual, err := x86SignedPackedFloatGoOpcodeTokens(table)
+	if err != nil {
+		return err
+	}
+	expected, err := x86SignedPackedFloatGoOpcodeTokens(x86AverageGoYtab)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		return fmt.Errorf("complete actual Go packed-average selector table changed:\n%s", table)
+	}
+	return nil
+}
+
+func TestX86PackedAverageGoSelectorMutationsAreDetected(t *testing.T) {
+	if err := x86AverageValidateGoYtab(x86AverageGoYtab); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ old, replacement string }{
+		{"zoffset: 2", "zoffset: 3"},
+		{"Zvex_rm_v_r", "Zevex_rm_v_r"},
+		{"Yknot0", "Yk"},
+		{"YxmEvex", "YymEvex"},
+		{"{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},", ""},
+	} {
+		changed := strings.Replace(x86AverageGoYtab, mutation.old, mutation.replacement, 1)
+		if err := x86AverageValidateGoYtab(changed); err == nil {
+			t.Fatalf("selector mutation retained source authority: %#v", mutation)
+		}
+	}
+}
+
+func TestX86PackedAverageActualGoModeAndPhysicalBoundary(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		source.WriteString("TEXT f(SB),4,$0-0\n")
+		for _, row := range x86AveragePhysicalRows(arch) {
+			source.WriteString(row + "\n")
+		}
+		source.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+	}
+	for _, name := range x86AverageNames[:2] {
+		for _, source := range []string{"M0", "(AX)", "AX"} {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+name+" "+source+",M1\nRET\n", "", false)
+		}
+	}
+	for _, name := range x86AverageNames[2:] {
+		for _, bank := range []string{"X", "Y"} {
+			for position := 0; position < 3; position++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[position] = bank + "20"
+				assembly := "TEXT f(SB),4,$0-0\n" + name + " " + strings.Join(args, ",") + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", assembly, "", true)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = "386"
+				before := out.String()
+				known, _, err := ctx.lowerPackedUnsignedAverage(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+				if !known || !errors.Is(err, ErrProbeNeedsContext) || out.String() != before {
+					t.Errorf("unproved physical high bank emitted IR: %s: %v", assembly, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAverageNativeStorageAndIdentityBoundaries(t *testing.T) {
+	for _, name := range x86AverageNames[:2] {
+		for _, row := range []string{name + " (SP),X0", name + " (BP),X0", name + " (AX)(BP*2),X0", name + " value+0(FP),X0"} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], x86WordMaddFPType(t), nil)
+			before := out.String()
+			_, _, err = ctx.lowerPackedUnsignedAverage(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+			if !errors.Is(err, ErrProbeNeedsContext) || out.String() != before {
+				t.Errorf("virtual storage gained native m128 alignment: %s: %v", row, err)
+			}
+		}
+	}
+	for _, name := range x86AverageNames {
+		row := name + " X0,X1"
+		if strings.HasPrefix(name, "V") {
+			row += ",X2"
+		}
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		ins.Op = "PADDW"
+		ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := out.String()
+		if _, _, err := ctx.lowerPackedUnsignedAverage(Op(name), ins); err == nil || out.String() != before {
+			t.Errorf("contradictory opcode emitted PAVG IR: %s: %v", name, err)
+		}
+	}
+}
diff --git a/amd64_packed_average_raw_test.go b/amd64_packed_average_raw_test.go
new file mode 100644
index 000000000..0d6d86ebd
--- /dev/null
+++ b/amd64_packed_average_raw_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedAverageActualRawPhysicalModes(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	llc := findLLVM22Tool("llc")
+	if mc == "" || llc == "" {
+		t.Fatal("LLVM22 llvm-mc and llc required")
+	}
+	for _, op := range x86AverageNames[2:] {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, memory := range []bool{false, true} {
+				for mode := 0; mode < 3; mode++ {
+					first, name := bank+"1", op
+					if memory {
+						first = "16(AX)"
+					}
+					if mode == 2 {
+						name += ".Z"
+					}
+					args := first + "," + bank + "0"
+					if mode != 0 {
+						args += ",K1"
+					}
+					row := name + " " + args + "," + bank + "2"
+					code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if len(code) < 2 || code[len(code)-1] != 0xc3 {
+						t.Fatal("original object lacks exact RET", row, code)
+					}
+					code = code[:len(code)-1]
+					for _, arch := range []string{"amd64", "386"} {
+						bits, triple := 64, "x86_64-unknown-linux-gnu"
+						if arch == "386" {
+							bits, triple = 32, "i386-unknown-linux-gnu"
+							var bytes, source strings.Builder
+							for _, value := range code {
+								fmt.Fprintf(&bytes, "0x%02x ", value)
+								fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+							}
+							goAssemblerOracleOutput(t, arch, "TEXT raw(SB),4,$0-0\n"+source.String()+"RET\n", "", true)
+							ctx, cancel := runtimeOracleStageContext(t)
+							command := exec.CommandContext(ctx, mc, "-triple="+triple, "-disassemble", "-mattr=+avx2,+avx512f,+avx512bw,+avx512vl")
+							command.Stdin = strings.NewReader(bytes.String())
+							output, err := runtimeOracleCombinedOutput(ctx, command)
+							cancel()
+							if err != nil || !strings.Contains(string(output), strings.ToLower(op)) || strings.Contains(string(output), "warning") {
+								t.Fatalf("actual mode32 physical instruction invalid: %x: %v\n%s", code, err, output)
+							}
+						}
+						ins, length, known, err := decodedX86PackedAverageInstruction(code, bits)
+						if !known || err != nil || length != len(code) || !ins.x86Encoded {
+							t.Fatalf("complete physical bytes not bound: %x: %v", code, err)
+						}
+						if _, known, err := x86PackedAverageProperties(ins.Op, ins, arch); !known || err != nil {
+							t.Fatal("physical source rejected", row, arch, err)
+						}
+						encoded, err := json.Marshal(ins)
+						if err != nil {
+							t.Fatal(err)
+						}
+						var copied Instr
+						if err := json.Unmarshal(encoded, &copied); err != nil || copied.x86Encoded {
+							t.Fatal("private marker survived portable JSON", err)
+						}
+						if arch == "386" && mode != 0 {
+							if _, _, err := x86PackedAverageProperties(copied.Op, copied, arch); err == nil {
+								t.Fatal("named/JSON four operands forged physical mode32 authority")
+							}
+						}
+						var source strings.Builder
+						for _, value := range code {
+							fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+						}
+						file, err := Parse(ArchAMD64, "TEXT raw(SB),4,$0-0\n"+source.String()+"RET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"raw": {Name: "raw", Ret: Void}}})
+						if err != nil {
+							t.Fatal("complete raw source failed translation", row, arch, err)
+						}
+						x86ResultInitializationObject(t, llc, triple, ir, "average-raw")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAverageRawReservedAndPrefixBoundaries(t *testing.T) {
+	valid := []byte{0x62, 0xf1, 0x7d, 0x89, 0xe0, 0xd1}
+	for _, mutation := range []struct {
+		index int
+		value byte
+	}{{1, 0xf2}, {2, 0x7c}, {3, 0x99}, {3, 0xe9}, {3, 0x88}} {
+		code := append([]byte(nil), valid...)
+		code[mutation.index] = mutation.value
+		_, _, known, err := decodedX86PackedAverageInstruction(code, 64)
+		if known && err == nil {
+			t.Fatalf("reserved encoding acquired semantics: %x", code)
+		}
+	}
+	ins, _, known, err := decodedX86PackedAverageInstruction(valid, 32)
+	if !known || err != nil {
+		t.Fatal("valid physical mask rejected", err)
+	}
+	ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+	for _, bits := range []int{16, 32, 64} {
+		local := ins
+		local.x86AddressBits = bits
+		if _, _, err := x86PackedAverageProperties(local.Op, local, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed address prefix retained a source shape", bits, err)
+		}
+	}
+}
diff --git a/amd64_packed_average_runtime_test.go b/amd64_packed_average_runtime_test.go
new file mode 100644
index 000000000..cc21cd719
--- /dev/null
+++ b/amd64_packed_average_runtime_test.go
@@ -0,0 +1,302 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86AverageNumericCase struct {
+	op                   string
+	width, bits          int
+	masking, destination int
+	memory, mmx          bool
+}
+
+func x86AverageNumericCases() []x86AverageNumericCase {
+	var cases []x86AverageNumericCase
+	for index, op := range x86AverageNames {
+		widths := []int{8, 16}
+		if strings.HasPrefix(op, "V") {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			for _, memory := range []bool{false, true} {
+				modes, destinations := 1, 1
+				if strings.HasPrefix(op, "V") {
+					modes, destinations = 3, 3
+				}
+				for mode := 0; mode < modes; mode++ {
+					for destination := 0; destination < destinations; destination++ {
+						cases = append(cases, x86AverageNumericCase{op, width, 8 << uint(index%2), mode, destination, memory, width == 8})
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func (row x86AverageNumericCase) instruction() string {
+	bank := map[int]string{8: "M", 16: "X", 32: "Y", 64: "Z"}[row.width]
+	first := bank + "1"
+	if row.memory {
+		first = "(BX)"
+	}
+	if !strings.HasPrefix(row.op, "V") {
+		return row.op + " " + first + "," + bank + "0"
+	}
+	op := row.op
+	if row.masking == 2 {
+		op += ".Z"
+	}
+	args := first + "," + bank + "0"
+	if row.masking != 0 {
+		args += ",K1"
+	}
+	return fmt.Sprintf("%s %s,%s%d", op, args, bank, row.destination)
+}
+
+func x86AverageNumericFixture(t *testing.T, cases []x86AverageNumericCase) (string, map[string]FuncSig, string) {
+	t.Helper()
+	var source, declarations, table strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, row := range cases {
+		name := fmt.Sprintf("average%d", index)
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-40
+MOVQ out+0(FP),AX
+MOVQ a+8(FP),BX
+MOVQ b+16(FP),CX
+MOVQ mask+24(FP),DX
+VMOVUPS (CX),Z0
+VMOVUPS (CX),Z2
+KMOVQ DX,K1
+`, name)
+		if !row.memory || row.destination == 1 {
+			source.WriteString("VMOVUPS (BX),Z1\n")
+		}
+		source.WriteString("PUSHQ flags+32(FP)\nPOPFQ\n")
+		if row.mmx {
+			source.WriteString("VMOVUPS Z0,(AX)\nMOVQ (CX),M0\nMOVQ (BX),M1\n")
+		}
+		source.WriteString(row.instruction() + "\n")
+		if row.mmx {
+			source.WriteString("MOVQ M0,(AX)\nEMMS\n")
+		} else {
+			fmt.Fprintf(&source, "VMOVUPS Z%d,(AX)\n", row.destination)
+		}
+		source.WriteString("PUSHFQ\nPOPQ R10\nMOVQ R10,64(AX)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*,uint64_t,uint64_t);\n", name)
+		fmt.Fprintf(&table, "{%s,%d,%d,%d,%d,%d},\n", name, row.width, row.bits/8,
+			row.masking, row.destination, x86FloatAddSubBoolInt(!strings.HasPrefix(row.op, "V")))
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := declarations.String() + "static const struct {Kernel run;int width,bytes,masking,destination,legacy;} cases[]={\n" + table.String() + "};\n"
+	return source.String(), sigs, driver
+}
+
+func x86AverageNumericProgram(t *testing.T, triple string, cases []x86AverageNumericCase) (string, string) {
+	t.Helper()
+	source, sigs, driver := x86AverageNumericFixture(t, cases)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "amd64", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir, driver
+}
+
+// Byte arithmetic is independent of the lowering specification. W lanes use
+// explicit little-endian assembly and a 17-bit sum, including 65535+65535.
+const x86AverageIndependentC = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+typedef void (*Kernel)(void *, const void *, const void *, uint64_t, uint64_t);
+static unsigned lane(const uint8_t *p, int bytes) {
+  unsigned value = p[0];
+  if (bytes == 2) {
+    value |= (unsigned)p[1] << 8;
+  }
+  return value;
+}
+static const uint64_t masks[] = {0, 1, UINT64_C(0xaaaaaaaa55555555), UINT64_MAX};
+`
+
+const x86AverageCheckC = `int main(void) {
+  for (unsigned row = 0; row < sizeof(cases) / sizeof(cases[0]); row++) {
+    for (int sample = 0; sample < 257; sample++) {
+      for (int status = 0; status < 2; status++) {
+        for (int m = 0; m < 4; m++) {
+          _Alignas(64) uint8_t a[192], b[192], out[192];
+          memset(a, 0xa7, sizeof(a));
+          memset(b, 0xb9, sizeof(b));
+          memset(out, 0xc3, sizeof(out));
+
+          for (int i = 0; i < 64; i++) {
+            a[64 + i] = (uint8_t)(sample * 71 + i * 37);
+            b[64 + i] = (uint8_t)(sample * 19 - i * 13);
+            if (sample < 4) {
+              a[64 + i] = (uint8_t[]){255, 0, 128, 255}[sample];
+              b[64 + i] = (uint8_t[]){255, 1, 128, 0}[sample];
+            }
+          }
+          uint8_t beforeA[192], beforeB[192];
+          memcpy(beforeA, a, sizeof(a));
+          memcpy(beforeB, b, sizeof(b));
+
+          uint32_t saved = _mm_getcsr(),
+                   profile = (uint32_t)(0x1f80 | ((sample % 4) << 13) | (sample % 64));
+          _mm_setcsr(profile);
+          uint64_t seed = status ? UINT64_C(0x8d5) : 0;
+          cases[row].run(out + 64, a + 64, b + 64, masks[m], seed);
+          uint32_t after = _mm_getcsr();
+          _mm_setcsr(saved);
+          uint64_t flags;
+          memcpy(&flags, out + 128, 8);
+          if (after != profile || (flags & UINT64_C(0x8d5)) != seed ||
+              memcmp(a, beforeA, sizeof(a)) || memcmp(b, beforeB, sizeof(b))) {
+            fprintf(stderr, "row%u sample%d CSR/flags/input\n", row, sample);
+            return 1;
+          }
+
+          for (int i = 0; i < 64; i++) {
+            int start = i / cases[row].bytes * cases[row].bytes;
+            unsigned value = (lane(a + 64 + start, cases[row].bytes) +
+                              lane(b + 64 + start, cases[row].bytes) + 1) /
+                             2;
+            int active =
+                !cases[row].masking || ((masks[m] >> (i / cases[row].bytes)) & 1);
+            uint8_t old = cases[row].destination == 1 ? a[64 + i] : b[64 + i];
+            uint8_t want =
+                i < cases[row].width
+                    ? (active ? (uint8_t)(value >> (8 * (i % cases[row].bytes)))
+                       : cases[row].masking == 2 ? 0
+                                                 : old)
+                : cases[row].legacy ? b[64 + i]
+                                    : 0;
+            if (out[64 + i] != want) {
+              fprintf(stderr, "row%u sample%d mask%llx byte%d got%x want%x\n", row,
+                      sample, (unsigned long long)masks[m], i, out[64 + i], want);
+              return 2;
+            }
+          }
+          for (int i = 0; i < 192; i++) {
+            if ((i < 64 || i >= 136) && out[i] != 0xc3) {
+              return 3;
+            }
+          }
+        }
+      }
+    }
+  }
+  puts("complete average bytes/flags/MXCSR/input/output canaries");
+  return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedAverageIndependentBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	cases := x86AverageNumericCases()
+	ir, table := x86AverageNumericProgram(t, execution.triple, cases)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "average-independent", ir,
+				x86AverageIndependentC+table+x86AverageCheckC, level)
+			if !strings.Contains(string(output), "complete average bytes") {
+				t.Fatal("missing full numerical receipt", string(output))
+			}
+		})
+	}
+	t.Logf("%d programs × 257 patterns × 2 flags × 4 masks, full 64-byte views, O0/O2; translated wide shadow views, not original EVEX runtime", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedAverageInactiveMemory(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var cases []x86AverageNumericCase
+	for _, op := range x86AverageNames[2:] {
+		bits := 8
+		if strings.HasSuffix(op, "W") {
+			bits = 16
+		}
+		for _, width := range []int{16, 32, 64} {
+			for _, mode := range []int{1, 2} {
+				cases = append(cases, x86AverageNumericCase{op, width, bits, mode, 0, true, false})
+			}
+		}
+	}
+	ir, table := x86AverageNumericProgram(t, execution.triple, cases)
+	// Unlike a post-load select, an E4.nb masked read cannot touch the guard
+	// page. With mask 1 only the first byte/word is accessible; mask 0 has no
+	// accessible source bytes. Full virtual FP spans are tested separately.
+	const main = x86TestGuardPagesC + `
+#ifndef _WIN32
+#include <sys/resource.h>
+#endif
+int main(void) {
+#ifndef _WIN32
+  struct rlimit core = {0, 0};
+  if (setrlimit(RLIMIT_CORE, &core)) {
+    return 9;
+  }
+#endif
+  if (setup_guard()) {
+    return 11;
+  }
+
+  _Alignas(64) uint8_t b[64], out[80];
+  memset(b, 0x91, 64);
+  for (unsigned row = 0; row < sizeof(cases) / sizeof(cases[0]); row++) {
+    for (int active = 0; active < 2; active++) {
+      memset(out, 0xc3, 80);
+      uint8_t *a = guard + page - (active ? cases[row].bytes : 0);
+      if (active) {
+        memset(a, 0xff, (size_t)cases[row].bytes);
+      }
+      cases[row].run(out + 1, a, b, (uint64_t)active, 0);
+      for (int i = 0; i < 64; i++) {
+        unsigned value = (cases[row].bytes == 1 ? 255 : 65535) +
+                         (cases[row].bytes == 1 ? 0x91 : 0x9191) + 1;
+        value /= 2;
+        uint8_t want = i < cases[row].width
+                           ? (active && i < cases[row].bytes
+                                  ? (uint8_t)(value >> (8 * (i % cases[row].bytes)))
+                              : cases[row].masking == 2 ? 0
+                                                        : b[i])
+                           : 0;
+        if (out[i + 1] != want) {
+          return 12;
+        }
+      }
+      for (int i = 0; i < 80; i++) {
+        if ((i == 0 || i >= 73) && out[i] != 0xc3) {
+          return 13;
+        }
+      }
+    }
+  }
+  if (free_guard()) {
+    return 14;
+  }
+  puts("inactive guard-page reads suppressed");
+  return 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "average-inactive", ir, x86AverageIndependentC+table+main, level)
+			if !strings.Contains(string(output), "inactive guard-page reads suppressed") {
+				t.Fatal("missing masked memory receipt", string(output))
+			}
+		})
+	}
+}
diff --git a/amd64_packed_binary_effects.go b/amd64_packed_binary_effects.go
new file mode 100644
index 000000000..663cd8193
--- /dev/null
+++ b/amd64_packed_binary_effects.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "strings"
+
+// Validated legacy and non-masked VEX forms share source-width and dependency
+// axes, not permission. The consumer selects its admitted generation first;
+// legacy reads its old destination, VEX independently writes and clears it.
+// A physical MMX source is supplied by the parser, never reinterpreted here.
+func x86PackedBinaryDependencyEffect(ins Instr, form x86PackedBinaryForm, source Operand) x86TypedByteEffect {
+	width := int64(form.byteWidth)
+	sourceWidth := width
+	if form.memory >= 0 {
+		sourceWidth = int64(form.memoryBytes)
+	}
+	count := 2
+	if !form.legacy {
+		count = 3
+	}
+	effect := x86TypedByteEffect{operands: make([]x86TypedByteOperand, count)}
+	effect.operands[0] = x86TypedByteOperand{index: form.first, operand: source, width: sourceWidth, read: true}
+	effect.operands[1] = x86TypedByteOperand{index: form.second, operand: ins.Args[form.second], width: width, read: true, write: form.legacy}
+	if form.legacy && !form.mmx {
+		effect.vector = x86TypedVectorEffect{x86TypedVectorUpperPreserve, width}
+	} else if !form.legacy {
+		effect.vector = x86TypedVectorEffect{x86TypedVectorUpperZero, 1}
+		effect.operands[2] = x86TypedByteOperand{index: form.destination, operand: ins.Args[form.destination], width: width, write: true}
+	}
+	return effect
+}
+
+type x86PackedBinaryEffectForm struct {
+	x86PackedBinaryForm
+	source Operand // Retains the actual MMX bank of a legacy GP spelling.
+	vex    bool
+}
+
+// Keep the existing family parsers as the only opcode/form authority. This
+// grouping adds no VEX, mask, broadcast, initialized input or memory backing.
+func x86PackedBinaryByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if effect, known, err := x86TypedLegacyLogicalByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedByteShuffleEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedImmediateShuffleByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedLegacyCLMULByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedLegacyPackedShiftByteEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	form, known, err := x86PackedBinaryEffectProperties(op, ins, arch)
+	if !known || err != nil || !form.legacy {
+		return x86TypedByteEffect{}, known && (err != nil || form.legacy), err
+	}
+	return x86PackedBinaryDependencyEffect(ins, form.x86PackedBinaryForm, form.source), true, nil
+}
+
+func x86PackedBinaryEffectProperties(op Op, ins Instr, arch string) (x86PackedBinaryEffectForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	if !strings.HasPrefix(name, "P") && !strings.HasPrefix(name, "VP") {
+		return x86PackedBinaryEffectForm{}, false, nil // Negative filter only; the specs below remain authoritative.
+	}
+	if form, known, err := x86LegacyIntegerArithmeticProperties(op, ins, arch); known {
+		return x86PackedBinaryEffectForm{form.x86PackedBinaryForm, form.source, false}, true, err
+	}
+	if form, known, err := x86PackedLowMultiplyProperties(op, ins, arch); known {
+		var source Operand
+		if err == nil {
+			source = ins.Args[form.first]
+		}
+		return x86PackedBinaryEffectForm{form.x86PackedBinaryForm, source, form.spec.encoding != x86PackedLogicalEVEX}, true, err
+	}
+	form, known, err := x86PackedPhysicalProperties(op, ins, arch, "")
+	return x86PackedBinaryEffectForm{form.x86PackedBinaryForm, form.source, true}, known, err
+}
diff --git a/amd64_packed_binary_physical.go b/amd64_packed_binary_physical.go
new file mode 100644
index 000000000..4f3b75a8d
--- /dev/null
+++ b/amd64_packed_binary_physical.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These families share physical operand normalization, not their numerical
+// effects or source permissions. Only the existing MMX adapter copies operands;
+// the binary grammar reads the original slice without changing it. The boolean
+// preserves the families' zero-form return before binary parsing has begun.
+func x86PackedBinaryPhysicalSource(op Op, ins Instr, arch string, spec x86PackedBinarySpec,
+	family string) (x86PackedBinaryForm, Operand, bool, error) {
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86PackedBinaryForm{}, Operand{}, false,
+			fmt.Errorf("%s dispatch/source opcode mismatch: %s/%s", family, op, ins.Op)
+	}
+	local := ins
+	local.Op = op
+	if spec.encoding == x86PackedLogicalLegacyInteger {
+		var err error
+		local, err = x86LegacyMMXReadInstruction(local, arch)
+		if err != nil {
+			return x86PackedBinaryForm{}, Operand{}, false, err
+		}
+	}
+	grammarArch := arch
+	if arch == "386" && local.x86Encoded && spec.encoding == x86PackedLogicalVEXOrEVEX {
+		grammarArch = "amd64" // Only the complete physical decoder sets this marker.
+	}
+	binary, err := x86PackedBinaryProperties(local, grammarArch, spec)
+	var source Operand
+	if err == nil {
+		source = local.Args[binary.first]
+		if grammarArch != arch && binary.memory >= 0 && !x86PackedShiftMemoryValid(source, arch) {
+			err = fmt.Errorf("386 %s physical source has an unbound address", op)
+		}
+		if err == nil {
+			err = x86Mode32VectorRegisterContext(local, arch)
+		}
+		if err == nil && binary.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+			err = fmt.Errorf("%w: %s has no bound address-size override", ErrProbeNeedsContext, family)
+		}
+	}
+	return binary, source, true, err
+}
diff --git a/amd64_packed_binary_pipeline_bench_test.go b/amd64_packed_binary_pipeline_bench_test.go
new file mode 100644
index 000000000..cfd17fd1a
--- /dev/null
+++ b/amd64_packed_binary_pipeline_bench_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Keep parsing outside the timer, but include source analysis, lowering and
+// LLVM verification. These register-only kernels need no native x86 hardware.
+// The independent family tests own memory faults and executable semantics.
+func BenchmarkX86PackedBinaryTranslation(b *testing.B) {
+	for _, row := range []string{
+		"PSUBL X0,X1",
+		"VPSUBD Y0,Y1,Y2",
+		"VPSUBSW.Z Z0,Z1,K1,Z2",
+		"PMULLD X0,X1",
+		"VPMULLD Y0,Y1,Y2",
+		"VPMULLQ.Z Z0,Z1,K1,Z2",
+		"PADDL X0,X1",
+		"VPADDD Y0,Y1,Y2",
+		"VPADDSW.Z Z0,Z1,K1,Z2",
+	} {
+		b.Run(row, func(b *testing.B) {
+			source := "TEXT binary(SB),4,$0-0\n" +
+				"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" +
+				"MOVQ $5,AX\nKMOVQ AX,K1\n" +
+				strings.Repeat(row+"\n", 32) + "RET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				b.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"binary": {Name: "binary", Ret: Void}}}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if _, err := Translate(file, options); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_packed_binary_pipeline_runtime_test.go b/amd64_packed_binary_pipeline_runtime_test.go
new file mode 100644
index 000000000..4821aae76
--- /dev/null
+++ b/amd64_packed_binary_pipeline_runtime_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This host-portable oracle covers the shared lowering axes, not physical x86
+// ISA/FLAGS or legacy memory alignment. The original native family owners keep
+// those independent obligations. Expected values do not use production specs.
+func TestX86PackedBinaryPipelinePortableSemantics(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang required")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range []struct {
+		instruction                         string
+		width, bytes, mode, mask, broadcast int
+		legacy, memory                      bool
+	}{
+		{"PSUBL X0,X2", 16, 4, 0, 0, 0, true, false},
+		{"PSUBSB X0,X2", 16, 1, 1, 0, 0, true, false},
+		{"VPSUBW Y0,Y1,Y2", 32, 2, 0, 0, 0, false, false},
+		{"VPSUBQ.BCST.Z (DI),Z1,K1,Z2", 64, 8, 0, 2, 1, false, true},
+		{"VPSUBSW (DI),Z1,K1,Z2", 64, 2, 1, 1, 0, false, true},
+		{"VPSUBUSB.Z (DI),X1,K1,X2", 16, 1, 2, 2, 0, false, true},
+		{"PMULLD X0,X2", 16, 4, 3, 0, 0, true, false},
+		{"VPMULLD Y0,Y1,Y2", 32, 4, 3, 0, 0, false, false},
+		{"VPMULLD.BCST.Z (DI),X1,K1,X2", 16, 4, 3, 2, 1, false, true},
+		{"VPMULLQ (DI),Z1,K1,Z2", 64, 8, 3, 1, 0, false, true},
+		{"PADDL X0,X2", 16, 4, 4, 0, 0, true, false},
+		{"VPADDQ Y0,Y1,Y2", 32, 8, 4, 0, 0, false, false},
+		{"VPADDSW (DI),Z1,K1,Z2", 64, 2, 5, 1, 0, false, true},
+		{"VPADDUSB.Z (DI),X1,K1,X2", 16, 1, 6, 2, 0, false, true},
+		{"VPADDD.BCST.Z (DI),Z1,K1,Z2", 64, 4, 4, 2, 1, false, true},
+	} {
+		name := fmt.Sprint("binary", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n"+
+			"MOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\n"+
+			"MOVQ mask+24(FP),AX\nKMOVQ AX,K1\n"+
+			"VMOVUPS (SI),Z1\nVMOVUPS (SI),Z2\n", name)
+		if !row.memory {
+			source.WriteString("VMOVUPS (DI),Z0\n")
+		}
+		fmt.Fprintf(&source, "%s\nVMOVUPS Z2,(DX)\nRET\n", row.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+		fmt.Fprintf(&checks, "if (check(%s,%q,%d,%d,%d,%d,%d,%d,%d)) return 1;\n",
+			name, row.instruction, row.width, row.bytes, row.mode, row.mask,
+			row.broadcast, x86FloatAddSubBoolInt(row.legacy), x86FloatAddSubBoolInt(row.memory))
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := x86PackedBinaryPipelineReference + declarations.String() +
+		"int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	host := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	targets := []string{host}
+	if host != "x86_64-unknown-linux-gnu" {
+		targets = append(targets, "x86_64-unknown-linux-gnu")
+	}
+	for _, triple := range targets {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if x86ScalarFloatIntegerNativeTarget("amd64", triple) || x86ScalarFloatIntegerNativeTarget("386", triple) {
+				// Verify every function and reject native effects before removing
+				// exactly its feature attribute. This numerical oracle must not
+				// require AVX512 merely because its source uses Z registers.
+				profiles := make(map[string]string, len(file.Funcs))
+				for _, function := range file.Funcs {
+					profiles[function.Sym] = inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", function)
+				}
+				ir, err = x86PackedShiftPortableFeatureProjection(ir, profiles)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			x86ResultInitializationObject(t, llc, triple, ir, "packed-binary-portable")
+			if triple != host {
+				return // Cross object evidence, not cross execution.
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprint("O", level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "packed-binary",
+						triple, ir, main, nil, level)
+				})
+			}
+		})
+	}
+}
+
+const x86PackedBinaryPipelineReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static uint64_t lane(const uint8_t *p, int bytes) {
+    uint64_t value = 0;
+    for (int i = 0; i < bytes; ++i) {
+        value |= (uint64_t)p[i] << (8*i);
+    }
+    return value;
+}
+
+static uint64_t calculate(uint64_t a, uint64_t b, int bytes, int mode) {
+    if (mode == 3) {
+        return a*b;
+    }
+    if (mode == 4) {
+        return a+b;
+    }
+    if (mode == 0) {
+        return b-a;
+    }
+    if (mode == 2) {
+        return b < a ? 0 : b-a;
+    }
+    if (mode == 6) {
+        uint64_t max = (UINT64_C(1) << (bytes*8))-1;
+        return a+b > max ? max : a+b;
+    }
+
+    int64_t sign = INT64_C(1) << (bytes*8-1);
+    int64_t x = (a & sign) ? (int64_t)a - 2*sign : (int64_t)a;
+    int64_t y = (b & sign) ? (int64_t)b - 2*sign : (int64_t)b;
+    int64_t value = mode == 5 ? y+x : y-x;
+    if (value < -sign) {
+        return -sign;
+    }
+    if (value >= sign) {
+        return sign-1;
+    }
+    return value;
+}
+
+static int check(void (*fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t),
+                 const char *name, int width, int bytes, int mode, int masking,
+                 int broadcast, int legacy, int memory) {
+    const uint64_t masks[] = {0, UINT64_MAX, 0x5555, UINT64_C(1)<<63};
+    for (int sample = 0; sample < 32; ++sample) {
+        uint8_t a[64], b[64], out[66], oldA[64], oldB[64];
+        for (int i = 0; i < 64; ++i) {
+            a[i] = (uint8_t)(sample*127 + i*53);
+            b[i] = (uint8_t)(sample*17 - i*91);
+        }
+        if (sample < 4) {
+            const uint8_t edgeA[] = {0xff, 0x80, 0x7f, 0x80};
+            const uint8_t edgeB[] = {1, 0x7f, 0x7f, 0x80};
+            memset(a, edgeA[sample], 64);
+            memset(b, edgeB[sample], 64);
+        }
+        memcpy(oldA, a, 64);
+        memcpy(oldB, b, 64);
+
+        for (unsigned m = 0; m < sizeof(masks)/sizeof(masks[0]); ++m) {
+            uint64_t mask = masks[m], relevant = UINT64_MAX >> (64-width/bytes);
+            const uint8_t *input = memory && masking && !(mask & relevant) ? NULL : a;
+            memset(out, 0xa7, sizeof(out));
+            fn(out+1, input, b, mask);
+
+            for (int offset = 0; offset < 64; ++offset) {
+                uint8_t want = legacy ? b[offset] : 0;
+                if (offset < width) {
+                    int active = !masking || ((mask >> (offset/bytes)) & 1);
+                    if (active) {
+                        uint64_t first = lane(a+(broadcast ? 0 : offset/bytes*bytes), bytes);
+                        uint64_t second = lane(b+offset/bytes*bytes, bytes);
+                        uint64_t result = calculate(first, second, bytes, mode);
+                        want = (uint8_t)(result >> (8*(offset%bytes)));
+                    } else {
+                        want = masking == 2 ? 0 : b[offset];
+                    }
+                }
+                if (out[offset+1] != want) {
+                    fprintf(stderr, "%s sample=%d mask=%llx byte=%d got=%x want=%x\n",
+                            name, sample, (unsigned long long)mask, offset, out[offset+1], want);
+                    return 1;
+                }
+            }
+            if (out[0] != 0xa7 || out[65] != 0xa7 || memcmp(a, oldA, 64) || memcmp(b, oldB, 64)) {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_packed_bit_count_forms.go b/amd64_packed_bit_count_forms.go
new file mode 100644
index 000000000..691ad34ff
--- /dev/null
+++ b/amd64_packed_bit_count_forms.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedBitCountForm struct {
+	x86PackedBinaryForm
+	spec amd64PackedBitCountSpec
+}
+
+// _yvexpandpd has the same EVEX source/width/mask axes as the shared binary
+// grammar, without a second input. The local projection never rewrites source.
+func x86PackedBitCountProperties(op Op, ins Instr, arch string) (x86PackedBitCountForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedBitCountSpecs[Op(base)]
+	form := x86PackedBitCountForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return form, true, fmt.Errorf("%s %s has an unbound dispatch or unary operand count: %q", arch, op, ins.Raw)
+	}
+	local := ins
+	local.Op = op
+	destination := ins.Args[len(ins.Args)-1]
+	local.Args = []Operand{ins.Args[0], destination, destination}
+	if len(ins.Args) == 3 {
+		local.Args = []Operand{ins.Args[0], destination, ins.Args[1], destination}
+	}
+	local, contextual := x86VectorValueMemoryInput(local, arch)
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, zeroing: true}
+	if spec.broadcast {
+		grammar.broadcastBytes = spec.laneBits / 8
+	}
+	var err error
+	form.x86PackedBinaryForm, err = x86PackedBinaryOperandGrammar(local, arch, grammar, true)
+	if err != nil {
+		return form, true, err
+	}
+	form.second, form.destination = -1, len(ins.Args)-1
+	if form.mask >= 0 {
+		form.mask = 1
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && amd64VectorByteWidth(operand.Reg) != 0 &&
+			!amd64GoPackedVectorMoveRegister(operand, form.byteWidth, arch) {
+			return form, true, fmt.Errorf("%s %s has an unbound vector bank: %q", arch, op, ins.Raw)
+		}
+	}
+	if form.memory >= 0 && !contextual && !x86PackedShiftMemoryValid(ins.Args[form.memory], arch) {
+		return form, true, fmt.Errorf("%s %s has an unbound memory operand: %q", arch, op, ins.Raw)
+	}
+	if contextual {
+		return form, true, x86VectorValueMemoryContext(ins)
+	}
+	return form, true, nil
+}
+
+func x86ResultPackedBitCountStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86PackedBitCountProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ResultFixedVectorInputs(ins, form.x86PackedBinaryForm, false, state, owned, arch), true
+}
diff --git a/amd64_packed_compact_forms.go b/amd64_packed_compact_forms.go
new file mode 100644
index 000000000..d3bcaaa61
--- /dev/null
+++ b/amd64_packed_compact_forms.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Both complete Go tables have X/Y/Z register rows and a matching memory
+// alternative. Compression writes its compact memory prefix; expansion reads
+// one. Neither family admits broadcast/rounding, K0, or unmasked .Z.
+type x86PackedCompactForm struct {
+	laneBits, byteWidth       int
+	destination, mask, memory int
+	expand, zeroing           bool
+}
+
+// Go accepts EVEX.z on compressed memory destinations, but Intel XED requires
+// ZEROING=0 for every such memory pattern. This is an architectural #UD, not
+// a store that ignores zeroing or a numerical continuation with unknown inputs.
+func (form x86PackedCompactForm) undefinedOpcode() bool {
+	return !form.expand && form.memory == form.destination && form.zeroing
+}
+
+func x86PackedCompactProperties(op Op, ins Instr, arch string) (x86PackedCompactForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := amd64PackedCompressLaneBits[Op(name)]
+	form := x86PackedCompactForm{laneBits: bits, mask: -1, memory: -1}
+	if !known {
+		spec, matched := amd64PackedExpandSpecs[Op(name)]
+		if !matched {
+			return form, false, nil
+		}
+		form.laneBits, form.expand = spec.laneBits, true
+	}
+	fail := func(reason string) (x86PackedCompactForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go compact/expand grammar (%s): %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail("mode or dispatch identity")
+	}
+	if dotted && suffix != "Z" {
+		return fail("only optional .Z is accepted")
+	}
+	form.zeroing = dotted
+	if len(ins.Args) != 2 && len(ins.Args) != 3 || form.zeroing && len(ins.Args) != 3 {
+		return fail("source, [K1-K7,] destination; .Z requires a mask")
+	}
+	form.destination = len(ins.Args) - 1
+	if len(ins.Args) == 3 {
+		mask := ins.Args[1]
+		index, valid := amd64ParseKReg(mask.Reg)
+		if mask.Kind != OpReg || !valid || index == 0 {
+			return fail("masked forms require K1-K7")
+		}
+		form.mask = 1
+	}
+	register := ins.Args[0]
+	if form.expand {
+		register = ins.Args[form.destination]
+	}
+	form.byteWidth = amd64VectorByteWidth(register.Reg)
+	if !amd64GoPackedVectorMoveRegister(register, form.byteWidth, arch) {
+		return fail("X/Y/Z register width or mode-bound bank")
+	}
+	other := form.destination
+	if form.expand {
+		other = 0
+	}
+	operand := ins.Args[other]
+	if operand.Kind == OpReg {
+		if !amd64GoPackedVectorMoveRegister(operand, form.byteWidth, arch) {
+			return fail("register widths or banks do not match")
+		}
+	} else if isAMD64MemoryOperand(operand) {
+		form.memory = other
+	} else {
+		return fail("memory alternative is not a Go memory operand")
+	}
+	return form, true, nil
+}
+
+func x86TypedCompactExpandByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedCompactProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if form.undefinedOpcode() {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: compact EVEX.z memory encoding has no ordinary byte continuation", ErrProbeNeedsContext)
+	}
+	operands := []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(form.byteWidth), read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth),
+			read: form.mask >= 0 && !form.zeroing && form.memory != form.destination, write: true},
+	}
+	if form.mask >= 0 {
+		operands = append(operands, x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return x86TypedByteEffect{operands: operands, dynamicMemory: form.memory >= 0, requiresResultProof: true}, true, nil
+}
diff --git a/amd64_packed_conversion_complete_inventory_test.go b/amd64_packed_conversion_complete_inventory_test.go
new file mode 100644
index 000000000..ef7106b5f
--- /dev/null
+++ b/amd64_packed_conversion_complete_inventory_test.go
@@ -0,0 +1,191 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedConversionCompleteNativeSemanticInventory(t *testing.T) {
+	// Independent expected multiplicities: plain register/memory, alias/dead,
+	// merge/zero/broadcast, explicit rounding/SAE and physical low-bank EVEX.
+	want := map[string]int{
+		"CVTPS2PL": 4, "CVTTPS2PL": 4, "CVTPD2PL": 4, "CVTTPD2PL": 4,
+		"VCVTPS2DQ": 28, "VCVTTPS2DQ": 25,
+		"VCVTPD2DQX": 8, "VCVTPD2DQY": 8, "VCVTPD2DQ": 12,
+		"VCVTTPD2DQX": 8, "VCVTTPD2DQY": 8, "VCVTTPD2DQ": 9,
+		"VCVTPD2QQ": 28, "VCVTPD2UQQ": 28, "VCVTTPD2QQ": 25, "VCVTTPD2UQQ": 25,
+		"VCVTPS2UDQ": 28, "VCVTTPS2UDQ": 25, "VCVTUDQ2PS": 28,
+		"VCVTQQ2PD": 28, "VCVTUQQ2PD": 28,
+		"VCVTPS2QQ": 28, "VCVTPS2UQQ": 28, "VCVTTPS2QQ": 25, "VCVTTPS2UQQ": 25,
+		"VCVTUDQ2PD":  24,
+		"VCVTPD2UDQX": 8, "VCVTPD2UDQY": 8, "VCVTPD2UDQ": 12,
+		"VCVTTPD2UDQX": 8, "VCVTTPD2UDQY": 8, "VCVTTPD2UDQ": 9,
+		"VCVTQQ2PSX": 8, "VCVTQQ2PSY": 8, "VCVTQQ2PS": 12,
+		"VCVTUQQ2PSX": 8, "VCVTUQQ2PSY": 8, "VCVTUQQ2PS": 12,
+		"CVTPL2PS": 4, "CVTPL2PD": 4, "VCVTDQ2PS": 46, "VCVTDQ2PD": 34,
+	}
+	seen := make(map[string]int)
+	physical := 0
+	rows := x86PackedConversionCompleteRuntimeRows()
+	for _, row := range rows {
+		member := strings.Split(strings.Fields(row.instruction)[0], ".")[0]
+		seen[member]++
+		if !row.wide || row.inputBits != 32 && row.inputBits != 64 {
+			t.Fatal("complete native fixture lost full alias storage or input bit type", row)
+		}
+		if row.rawOverride != "" {
+			physical++
+			if member != "VCVTDQ2PS" && member != "VCVTDQ2PD" {
+				t.Fatal("unowned physical-generation override", row)
+			}
+		}
+	}
+	if len(rows) != 692 || len(seen) != 42 || physical != 2 {
+		t.Fatal("incomplete42 native semantic inventory", len(rows), len(seen), physical)
+	}
+	for member, count := range want {
+		if seen[member] != count {
+			t.Error("changed native member semantic axes", member, seen[member], count)
+		}
+	}
+	for member := range seen {
+		if want[member] == 0 {
+			t.Error("unexpected native member", member)
+		}
+	}
+	assembly, _, goMain, cMain := x86PackedConversionRuntimeFixture(rows[len(rows)-2:])
+	for _, required := range []string{"VMOVDQU64 (SI),Z0", "VMOVDQU64 (DI),Z1", "STMXCSR 72(DI)", "SETPC 68(DI)", "LDMXCSR saved-4(SP)"} {
+		if !strings.Contains(assembly, required) {
+			t.Fatal("native value oracle lost full inputs, aliases, status or MXCSR restoration", required)
+		}
+	}
+	if !strings.Contains(goMain, "unsafe.Add(address,(-uintptr(address))&15)") ||
+		!strings.Contains(cMain, "_Alignas(16) uint64_t input[8],out[12]") {
+		t.Fatal("native legacy m128 values rely on accidental input alignment")
+	}
+}
+
+func TestX86PackedConversionCompleteNativeFaultInventory(t *testing.T) {
+	rows := x86PackedConversionCompleteFaultRows()
+	if len(rows) != 222 {
+		t.Fatal("complete42 memory-fault denominator changed", len(rows))
+	}
+	members := make(map[string]bool)
+	signed := make(map[string]int)
+	for _, row := range rows {
+		member := strings.Split(row.name, ".")[0]
+		members[member] = true
+		if row.lanes < 2 || row.lanes > 16 || row.laneBytes != 4 && row.laneBytes != 8 {
+			t.Fatal("fault mask domain lost active output lanes", row)
+		}
+		if row.name == "CVTPL2PD" && (row.width != 8 || row.aligned || row.precision || row.floating) {
+			t.Fatal("exact signed32-to-double m64 inherited m128/precision semantics", row)
+		}
+		if row.name == "CVTPL2PS" && (row.width != 16 || !row.aligned || !row.precision || row.floating) {
+			t.Fatal("signed32-to-single m128 lost alignment/precision", row)
+		}
+		if member == "VCVTDQ2PS" || member == "VCVTDQ2PD" || strings.HasPrefix(member, "CVTPL") {
+			signed[fmt.Sprintf("%s/%d/%s", member, row.lanes, strings.TrimPrefix(row.name, member))]++
+		}
+	}
+	if len(members) != 42 || len(signed) != 20 {
+		t.Fatal("missing complete42 fault members or signed semantic shapes", len(members), len(signed))
+	}
+	for _, op := range []string{"VCVTDQ2PS", "VCVTDQ2PD"} {
+		lanes := []int{4, 8, 16}
+		if op == "VCVTDQ2PD" {
+			lanes = []int{2, 4, 8}
+		}
+		for _, count := range lanes {
+			for _, suffix := range []string{"", ".Z", ".BCST.Z"} {
+				if signed[fmt.Sprintf("%s/%d/%s", op, count, suffix)] != 1 {
+					t.Error("missing or duplicated native signed fault shape", op, count, suffix)
+				}
+			}
+		}
+	}
+	for _, scope := range []struct{ count, limit int }{{692, 64}, {222, 16}} {
+		seen := make([]int, scope.count)
+		for owner := 0; owner < 8; owner++ {
+			owned := 0
+			for batch, start := 0, 0; start < scope.count; batch, start = batch+1, start+scope.limit {
+				if batch%8 != owner {
+					continue
+				}
+				for index := start; index < start+scope.limit && index < scope.count; index++ {
+					seen[index]++
+					owned++
+				}
+			}
+			if owned == 0 || owned > 2*scope.limit {
+				t.Fatal("empty or monolithic native scheduling owner", scope, owner, owned)
+			}
+		}
+		for index, count := range seen {
+			if count != 1 {
+				t.Fatal("native scheduling changed complete denominator", scope, index, count)
+			}
+		}
+	}
+}
+
+func TestX86PackedConversionSignedNativeRuntimeFixtureObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86PackedConversionCompleteRuntimeRows()
+	if len(rows) != 692 {
+		t.Fatal("complete native runtime fixture inventory changed")
+	}
+	// The604 older kernels retain their own whole fixture objects. These88
+	// new signed/alias/dead/physical kernels compile the exact runtime wrapper,
+	// not a reduced standalone instruction or a native execution certificate.
+	for start := 604; start < len(rows); start += 64 {
+		end := start + 64
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			batch := append([]x86PackedConversionRuntimeRow(nil), rows[start:end]...)
+			var instructions []string
+			for _, row := range batch {
+				instructions = append(instructions, row.instruction)
+			}
+			raw := x86PackedConversionContinuationRawRows(t, "amd64", instructions)
+			for _, spelling := range []string{"named", "raw"} {
+				t.Run(spelling, func(t *testing.T) {
+					if spelling == "raw" {
+						for index := range batch {
+							batch[index].instruction = raw[index]
+							if batch[index].rawOverride != "" {
+								batch[index].instruction = batch[index].rawOverride
+							}
+						}
+					}
+					source, declarations, _, _ := x86PackedConversionRuntimeFixture(batch)
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+							if err != nil {
+								t.Fatal("new native runtime fixture lost initialized public path", err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							for _, pipeline := range []struct{ name, ir, backend string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", pipeline.ir, pipeline.backend)
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_conversion_complete_runtime_policy_test.go b/amd64_packed_conversion_complete_runtime_policy_test.go
new file mode 100644
index 000000000..f563698c1
--- /dev/null
+++ b/amd64_packed_conversion_complete_runtime_policy_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PackedConversionRuntimeFunctions(t *testing.T, path string) map[string]*ast.FuncDecl {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal("missing required complete native conversion owner or driver", path, err)
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range syntax.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			if functions[function.Name.Name] != nil {
+				t.Fatal("duplicate complete native conversion function", function.Name.Name)
+			}
+			functions[function.Name.Name] = function
+		}
+	}
+	return functions
+}
+
+func x86PackedConversionOriginalCProgramUnchanged(t *testing.T) {
+	t.Helper()
+	functions := x86PackedConversionRuntimeFunctions(t, "amd64_lower_packed_numeric_conversion_test.go")
+	function := functions["amd64PackedNumericConversionNativeRuntimeSemantics"]
+	if function == nil || function.Body == nil {
+		t.Fatal("missing original independent native C program")
+	}
+	want := map[string]string{
+		"source": "35a753aaa54d59683eed39625574d35e24d342cc53a91ceceb998c17a36d7175",
+		"mainC":  "08481b19c5e80e7b2da8c77268fa37e486991839b06c9cd37efc22c6e727d43b",
+	}
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		spec, ok := node.(*ast.ValueSpec)
+		if !ok || len(spec.Names) != 1 || len(spec.Values) != 1 {
+			return true
+		}
+		expected, found := want[spec.Names[0].Name]
+		if !found {
+			return true
+		}
+		literal, ok := spec.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			t.Fatal("original independent source/reference was replaced", spec.Names[0].Name)
+		}
+		value, err := strconv.Unquote(literal.Value)
+		if err != nil || fmt.Sprintf("%x", sha256.Sum256([]byte(value))) != expected {
+			t.Fatal("original complete assembly or independent C reference changed", spec.Names[0].Name, err)
+		}
+		delete(want, spec.Names[0].Name)
+		return true
+	})
+	if len(want) != 0 {
+		t.Fatal("original source/reference literal disappeared", want)
+	}
+}
+
+func TestX86PackedConversionCompleteNativeRuntimeOwnership(t *testing.T) {
+	x86PackedConversionOriginalCProgramUnchanged(t)
+	const path = "amd64_packed_conversion_runtime_linux_amd64_test.go"
+	for _, qualified := range []bool{false, true} {
+		for _, target := range []struct{ os, arch string }{
+			{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"}, {"linux", "arm64"},
+			{"js", "wasm"}, {"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+		} {
+			t.Run(fmt.Sprintf("selection/qualified=%t/%s-%s", qualified, target.os, target.arch), func(t *testing.T) {
+				context := ciNativeAVX512BuildContext(target.os, target.arch, qualified)
+				selected, err := context.MatchFile(".", path)
+				want := qualified && target.os == "linux" && target.arch == "amd64"
+				if err != nil || selected != want {
+					t.Fatal("conversion owner lost its explicit native selection", target, qualified, selected, err)
+				}
+			})
+		}
+	}
+	functions := x86PackedConversionRuntimeFunctions(t, path)
+	want := make(map[string]bool)
+	for _, family := range []struct{ root, driver string }{
+		{"TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512Status", "x86PackedConversionCompleteNativeValues"},
+		{"TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaults", "x86PackedConversionCompleteNativeFaults"},
+		{"TestCrossLinuxRuntimeMatrixX86PackedConversionNativeIndependentC", "amd64PackedNumericConversionNativeRuntimeSemantics"},
+	} {
+		parts := 8
+		if family.driver == "amd64PackedNumericConversionNativeRuntimeSemantics" {
+			parts = 1
+		}
+		for part := 0; part < parts; part++ {
+			name := family.root
+			if part != 0 {
+				name += fmt.Sprintf("Part%d", part)
+			}
+			want[name] = true
+			t.Run(name, func(t *testing.T) {
+				function := functions[name]
+				if function == nil || function.Body == nil || len(function.Body.List) != 1 {
+					t.Fatal("missing or bypassed complete native conversion partition", name)
+				}
+				statement, ok := function.Body.List[0].(*ast.ExprStmt)
+				if !ok {
+					t.Fatal("required native partition does not execute its real driver", name)
+				}
+				call, ok := statement.X.(*ast.CallExpr)
+				if !ok {
+					t.Fatal("native partition lost its complete direct call", name)
+				}
+				callee, ok := call.Fun.(*ast.Ident)
+				arguments := 2
+				if parts == 1 {
+					arguments = 1
+				}
+				if !ok || callee.Name != family.driver || len(call.Args) != arguments {
+					t.Fatal("native partition did not consume the complete 42-member driver", name)
+				}
+				argument, ok := call.Args[0].(*ast.Ident)
+				if !ok || argument.Name != "t" {
+					t.Fatal("native partition lost its actual test context", name)
+				}
+				if parts != 1 {
+					literal, ok := call.Args[1].(*ast.BasicLit)
+					if !ok || literal.Kind != token.INT || literal.Value != strconv.Itoa(part) {
+						t.Fatal("native partition borrowed another slice or a sampled subset", name)
+					}
+				}
+			})
+		}
+	}
+	if len(want) != 17 {
+		t.Fatal("missing complete status/fault/native-C owner inventory")
+	}
+	for name := range functions {
+		if strings.HasPrefix(name, "Test") && !want[name] {
+			t.Fatal("unregistered native conversion partition", name)
+		}
+	}
+}
+
+func TestX86PackedConversionCompleteNativeCPUDriverRequired(t *testing.T) {
+	const path = "amd64_packed_conversion_native_tools_test.go"
+	functions := x86PackedConversionRuntimeFunctions(t, path)
+	function := functions["x86PackedConversionNativeTools"]
+	if function == nil || function.Body == nil {
+		t.Fatal("complete conversions require a real F/DQ/BW/VL and native-host owner")
+	}
+	calls := make(map[string]int)
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if callee, ok := call.Fun.(*ast.Ident); ok {
+			calls[callee.Name]++
+			if callee.Name == "x86FloatCompareRuntimeTools" {
+				if len(call.Args) != 2 {
+					t.Fatal("native conversion owner lost the real EVEX execution route")
+				}
+				axis, ok := call.Args[1].(*ast.Ident)
+				if !ok || axis.Name != "x86FloatCompareEVEX" {
+					t.Fatal("native conversion owner substituted an SSE/emulator route")
+				}
+			}
+		}
+		if callee, ok := call.Fun.(*ast.SelectorExpr); ok {
+			calls[callee.Sel.Name]++
+			if callee.Sel.Name == "Skip" || callee.Sel.Name == "Skipf" || callee.Sel.Name == "SkipNow" {
+				t.Fatal("missing native hardware cannot become a successful skipped conversion owner")
+			}
+		}
+		return true
+	})
+	for _, required := range []string{"x86PackedConversionRequireNativeHost", "x86FloatCompareRuntimeTools", "compileC", "run"} {
+		if calls[required] != 1 {
+			t.Fatal("native conversion owner omitted an actual host/CPU/opcode execution check", required, calls[required])
+		}
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{
+		"AVX512F=%u AVX512DQ=%u AVX512BW=%u AVX512VL=%u OSXSAVE=%u XCR0=%llx",
+		"PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK", "__get_cpuid_count(7,0", "xgetbv",
+		"vcvtqq2pd", "vcvtdq2ps", "kmovq", "0xe6",
+	} {
+		if !strings.Contains(string(data), required) {
+			t.Fatal("complete native CPU/opcode preflight missing", required)
+		}
+	}
+}
diff --git a/amd64_packed_conversion_complete_runtime_test.go b/amd64_packed_conversion_complete_runtime_test.go
new file mode 100644
index 000000000..9a813ed6e
--- /dev/null
+++ b/amd64_packed_conversion_complete_runtime_test.go
@@ -0,0 +1,192 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const (
+	x86PackedConversionNativeOwners = 8
+	x86PackedConversionValueCapture = 64
+	x86PackedConversionFaultCapture = 16
+)
+
+// The full994-row object matrix owns spelling/address axes. Native execution
+// keeps every independent semantic shape, rather than duplicating that syntax
+// Cartesian product:38 existing families plus signed4, aliases, dead results,
+// all signed masks/broadcasts/rounding and the two physical low-bank EVEX forms.
+func x86PackedConversionCompleteRuntimeRows() []x86PackedConversionRuntimeRow {
+	rows := x86PackedConversionRuntimeRows(true)
+	for _, row := range x86SignedPackedValueRows() {
+		input := row.input
+		if strings.Contains(input, "(") {
+			input = "(SI)"
+		}
+		rows = append(rows, x86PackedConversionRuntimeRow{
+			instruction: row.op + " " + input + "," + row.mask + row.bank + "1",
+			wide:        true, inputBits: 32, mask: row.mask != "", sae: strings.Contains(row.op, "SAE"),
+		})
+	}
+	for _, op := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+		banks := []string{"X"}
+		if strings.HasPrefix(op, "V") {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			input := bank
+			if op == "VCVTDQ2PD" {
+				input = "X"
+				if bank == "Z" {
+					input = "Y"
+				}
+			}
+			rows = append(rows,
+				x86PackedConversionRuntimeRow{instruction: op + " " + input + "1," + bank + "1", wide: true, inputBits: 32},
+				x86PackedConversionRuntimeRow{instruction: op + " " + input + "0," + bank + "1", wide: true, dead: true, inputBits: 32})
+		}
+	}
+	for _, physical := range []struct {
+		instruction string
+		code        []byte
+	}{
+		{"VCVTDQ2PS X0,X1", []byte{0x62, 0xf1, 0x7c, 0x08, 0x5b, 0xc8}},
+		{"VCVTDQ2PD X0,X1", []byte{0x62, 0xf1, 0x7e, 0x08, 0xe6, 0xc8}},
+	} {
+		rows = append(rows, x86PackedConversionRuntimeRow{
+			instruction: physical.instruction, rawOverride: strings.TrimSuffix(x86RawDisplacementDirectives(physical.code), "\n"),
+			wide: true, inputBits: 32,
+		})
+	}
+	return rows
+}
+
+func x86PackedConversionCompleteFaultRows() []x86PackedConversionFaultRow {
+	rows := x86PackedConversionFaultRows(true)
+	for _, member := range []struct {
+		name              string
+		width, lanes      int
+		legacy, precision bool
+	}{
+		{"CVTPL2PS", 16, 4, true, true},
+		{"CVTPL2PD", 8, 2, true, false},
+		{"VCVTDQ2PS", 16, 4, false, true},
+		{"VCVTDQ2PS", 32, 8, false, true},
+		{"VCVTDQ2PS", 64, 16, false, true},
+		{"VCVTDQ2PD", 8, 2, false, false},
+		{"VCVTDQ2PD", 16, 4, false, false},
+		{"VCVTDQ2PD", 32, 8, false, false},
+	} {
+		outputBytes := member.lanes * 4
+		if strings.HasSuffix(member.name, "PD") {
+			outputBytes *= 2
+		}
+		destination := map[int]string{16: "X1", 32: "Y1", 64: "Z1"}[outputBytes]
+		row := x86PackedConversionFaultRow{
+			name: member.name, width: member.width, laneBytes: 4, lanes: member.lanes,
+			precision: member.precision,
+			// SSE CVTDQ2PD reads only m64 and has no m128 alignment
+			// requirement. It must not inherit the other legacy forms'.
+			aligned:    member.legacy && member.width == 16,
+			conversion: member.name + " (DI)," + destination,
+		}
+		rows = append(rows, row)
+		if !member.legacy {
+			row.name, row.masked = member.name+".Z", true
+			row.conversion = row.name + " (DI),K1," + destination
+			rows = append(rows, row)
+			row.name, row.width = member.name+".BCST.Z", 4
+			row.conversion = row.name + " (DI),K1," + destination
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86PackedConversionCompleteNativeFaults(t *testing.T, owner int) {
+	t.Helper()
+	if owner < 0 || owner >= x86PackedConversionNativeOwners {
+		t.Fatal("invalid native conversion fault owner", owner)
+	}
+	execution := x86PackedConversionNativeTools(t)
+	rows := x86PackedConversionCompleteFaultRows()
+	if len(rows) != 222 {
+		t.Fatal("complete42 fault denominator changed", len(rows))
+	}
+	x86PackedConversionRunFaultRows(t, execution, rows, x86PackedConversionFaultCapture, owner, x86PackedConversionNativeOwners, true, true)
+}
+
+func x86PackedConversionCompleteNativeValues(t *testing.T, owner int) {
+	t.Helper()
+	if owner < 0 || owner >= x86PackedConversionNativeOwners {
+		t.Fatal("invalid native conversion owner", owner)
+	}
+	execution := x86PackedConversionNativeTools(t)
+	rows := x86PackedConversionCompleteRuntimeRows()
+	if len(rows) != 692 {
+		t.Fatal("complete42 native semantic denominator changed", len(rows))
+	}
+	consumed := 0
+	for batch, start := 0, 0; start < len(rows); batch, start = batch+1, start+x86PackedConversionValueCapture {
+		if batch%x86PackedConversionNativeOwners != owner {
+			continue
+		}
+		end := start + x86PackedConversionValueCapture
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			current := rows[start:end]
+			assembly, declarations, main, driver := x86PackedConversionRuntimeFixture(current)
+			var want []byte
+			t.Run("original_go_named", func(t *testing.T) {
+				want = x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, main)
+				if strings.Count(string(want), "\n") != len(current) {
+					t.Fatal("incomplete original Go named runtime receipts")
+				}
+			})
+			var instructions []string
+			for _, row := range current {
+				instructions = append(instructions, row.instruction)
+			}
+			raw := x86PackedConversionContinuationRawRows(t, "amd64", instructions)
+			rawRows := append([]x86PackedConversionRuntimeRow(nil), current...)
+			for index := range rawRows {
+				rawRows[index].instruction = raw[index]
+				if current[index].rawOverride != "" {
+					rawRows[index].instruction = current[index].rawOverride
+				}
+			}
+			rawAssembly, _, rawMain, _ := x86PackedConversionRuntimeFixture(rawRows)
+			t.Run("original_go_raw", func(t *testing.T) {
+				got := x86ScalarFloatIntegerOriginalOutput(t, execution, rawAssembly, rawMain)
+				if string(got) != string(want) || len(want) == 0 {
+					t.Fatal("original named/raw Go runtime diverged or lost receipts")
+				}
+			})
+			if len(want) == 0 {
+				t.Fatal("missing original native Go execution")
+			}
+			for _, spelling := range []struct{ name, source string }{{"named", assembly}, {"raw", rawAssembly}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations, "amd64", execution.triple, api)
+							if err != nil {
+								t.Fatal("initialized complete native conversion source rejected", err)
+							}
+							x86PackedConversionNativePipelines(t, execution, ir, driver, want)
+						})
+					}
+				})
+			}
+			consumed += len(current)
+		})
+	}
+	if consumed == 0 {
+		t.Fatal("empty native value owner")
+	}
+	t.Logf("%d/692 native kernels: actual named/raw Go,3APIs,3LLVM paths; full MXCSR, masks, aliases and dead results", consumed)
+}
diff --git a/amd64_packed_conversion_effects.go b/amd64_packed_conversion_effects.go
new file mode 100644
index 000000000..0b7603bf5
--- /dev/null
+++ b/amd64_packed_conversion_effects.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func x86TypedPackedConversionByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := x86PackedConversionSpecification(Op(base)); !known {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("packed conversion effect/source mismatch")
+	}
+	ins.Op = op
+	f, known, err := x86PackedConversionProperties(ins, arch)
+	if err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := f.inputBytes
+	if f.memory >= 0 {
+		width = f.memoryBytes
+	}
+	effect := x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(width), read: true},
+		{index: f.destination, operand: ins.Args[f.destination], width: int64(f.shape.destinationBytes), write: true},
+	}}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+		if !f.properties.zeroing {
+			effect.operands = append(effect.operands, x86TypedByteOperand{index: f.destination, operand: ins.Args[f.destination],
+				width: int64(f.shape.lanes * f.spec.destinationBits / 8), read: true})
+		}
+	}
+	return effect, true, nil // Integer FLAGS do not change; MXCSR remains native.
+}
+
+func x86ResultPackedConversionStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultPackedConversionStepWithRead(ins, state, owned, arch, false)
+}
+
+// The native conversion emitter retains the complete opcode's access and
+// MXCSR effects. This continuation grants no caller or pointee facts.
+func x86ResultPackedConversionStepWithRead(ins Instr, state *x86ResultState, owned []bool,
+	arch string, nativeRead bool) (bool, bool) {
+	f, known, err := x86PackedConversionProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || f.mmx || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	return x86ResultPackedConversionInputs(ins, f, state, owned, arch, nativeRead), true
+}
+
+// The caller selects and authenticates its own family before sharing these
+// lane/input dependencies. No source or native-read capability follows.
+func x86ResultPackedConversionInputs(ins Instr, f x86PackedConversionForm, state *x86ResultState, owned []bool,
+	arch string, nativeRead bool) bool {
+	if f.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	if f.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[0], int64(f.memoryBytes), state, owned, arch, nativeRead) {
+			return false
+		}
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[0].Reg, f.shape.sourceBytes)
+		input := x86CallerVectorByteMask(int64(f.inputBytes))
+		if state.vectorBytes(index)&input != input {
+			return false
+		}
+	}
+	index, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.shape.destinationBytes)
+	active := x86CallerVectorByteMask(int64(f.shape.lanes * f.spec.destinationBits / 8))
+	if f.mask >= 0 && !f.properties.zeroing && state.vectorBytes(index)&active != active {
+		return false
+	}
+	state.writeVector(index, f.shape.destinationBytes, x86CallerVectorByteMask(int64(f.shape.destinationBytes)), f.spec.legacy)
+	return true
+}
+
+func x86CallerPackedConversionStep(ins *Instr, f x86PackedConversionForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if f.mmx || f.mask >= 0 && !state.masks[ins.Args[f.mask].Reg] {
+		return false
+	}
+	if f.memory >= 0 {
+		source := ins.Args[0]
+		if source.Kind == OpFP || source.Kind == OpMem &&
+			(source.Mem.Base == SP || source.Mem.Base == BP || source.Mem.Index == BP) {
+			return false
+		}
+		if !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.memoryBytes), false) {
+			return false
+		}
+	} else {
+		input := x86CallerVectorByteMask(int64(f.inputBytes))
+		if state.vectors[x86CallerVectorRoot(ins.Args[0].Reg)]&input != input {
+			return false
+		}
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	active := x86CallerVectorByteMask(int64(f.shape.lanes * f.spec.destinationBits / 8))
+	if f.mask >= 0 && !f.properties.zeroing && state.vectors[destination]&active != active {
+		return false
+	}
+	if f.spec.legacy {
+		state.vectors[destination] |= x86CallerVectorByteMask(int64(f.shape.destinationBytes))
+	} else {
+		state.vectors[destination] = ^uint64(0)
+	}
+	return true
+}
diff --git a/amd64_packed_conversion_effects_test.go b/amd64_packed_conversion_effects_test.go
new file mode 100644
index 000000000..0ef051b7a
--- /dev/null
+++ b/amd64_packed_conversion_effects_test.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedConversionIndependentEveryByteEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, spec := range x86PackedConversionOracleSpecs() {
+			for _, shape := range spec.shapes() {
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+				for _, masking := range []string{"", "merge", "zero"} {
+					if spec.legacy && masking != "" {
+						continue
+					}
+					op, mask := spec.name, ""
+					if masking != "" {
+						mask = "K1,"
+					}
+					if masking == "zero" {
+						op += ".Z"
+					}
+					ins := x86ScalarLaneInstruction(t, op+" "+bank[shape.source]+"0,"+mask+bank[shape.destination]+"1")
+					f, known, err := x86PackedConversionProperties(ins, arch)
+					if err != nil || !known || f.inputBytes != shape.lanes*spec.input/8 || f.shape.destinationBytes != shape.destination {
+						t.Fatal(ins.Raw, f, err)
+					}
+					for missing := -1; missing < 64; missing++ {
+						for _, missingDestination := range []bool{false, true} {
+							state := x86ResultState{flags: x86ByteFlagsAll}
+							state.masks[1] = true
+							state.writeVector(0, 64, ^uint64(0), false)
+							state.writeVector(1, 64, ^uint64(0), false)
+							index := 0
+							if missingDestination {
+								index = 1
+							}
+							if missing >= 0 {
+								state.writeVector(index, 64, ^(uint64(1) << uint(missing)), false)
+							}
+							want := missing < 0 || !missingDestination && missing >= shape.lanes*spec.input/8 ||
+								missingDestination && (masking != "merge" || missing >= shape.lanes*spec.output/8)
+							accepted, recognized := x86ResultPackedConversionStep(ins, &state, nil, arch)
+							if !recognized || accepted != want {
+								t.Fatal("required byte mismatch", ins.Raw, arch, missing, missingDestination, accepted, want)
+							}
+							if accepted {
+								expected := ^uint64(0)
+								if spec.legacy && missingDestination && missing >= 16 {
+									expected &^= uint64(1) << uint(missing)
+								}
+								if state.vectorBytes(1) != expected || state.flags != x86ByteFlagsAll {
+									t.Fatal("upper alias or integer FLAGS changed", ins.Raw, state.vectorBytes(1), expected)
+								}
+							}
+						}
+					}
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if err != nil || !known || effect.flagsRead != 0 || effect.flagsKilled != 0 || effect.flagsDefined != 0 {
+						t.Fatal("typed family effect/FLAGS disagreement", ins.Raw, effect, err)
+					}
+					state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+					if !x86CallerPackedConversionStep(&ins, f, &state, nil) {
+						t.Fatal("initialized register grammar missing caller effect", ins.Raw)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedConversionResultAndStorageBoundaries(t *testing.T) {
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		shape := spec.shapes()[0]
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+		for _, initialized := range []bool{false, true} {
+			setup := ""
+			if initialized {
+				setup = "XORPS X0,X0\n"
+				if !spec.legacy {
+					setup = "VPXORD Z0,Z0,Z0\n"
+				}
+			}
+			assembly := fmt.Sprintf("TEXT ·f(SB),4,$0-4\n%s%s %s0,%s1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", setup, spec.name, bank[shape.source], bank[shape.destination])
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly, "func f() uint32", "amd64", "x86_64-unknown-linux-gnu", api)
+				if !initialized {
+					x86VectorScratchCodegenControl(t, assembly, "func f() uint32", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					continue
+				}
+				if err != nil {
+					t.Fatal("uninitialized conversion result boundary", spec.name, initialized, api, err)
+				}
+			}
+		}
+		for _, operand := range []string{"data+0(FP)", "local-16(SP)", "(SP)", "(BP)"} {
+			assembly := "TEXT ·f(SB),4,$64-64\n" + spec.name + " " + operand + "," + bank[shape.destination] + "1\nRET\n"
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {
+				Name: "f", Ret: Void, Args: []LLVMType{I64, I64, I64, I64, I64, I64, I64, I64},
+			}}})
+			if err == nil {
+				t.Fatal("logical slots acquired packed native backing", spec.name, operand)
+			}
+		}
+	}
+}
+
+func TestX86PackedConversionPhysicalBroadcastTuple(t *testing.T) {
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if spec.legacy {
+			continue
+		}
+		for _, shape := range spec.shapes() {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[shape.destination]
+			row := spec.name + ".BCST (AX)," + bank + "1"
+			x86UnboundVoidScalarFormatObject(t, "TEXT ·f(SB),4,$0-0\n"+row+"\nRET\n", "f", "amd64", "x86_64-unknown-linux-gnu")
+			initialized := "TEXT ·f(SB),4,$0-8\nMOVQ p+0(FP),AX\n" + row + "\nRET\n"
+			ir, err := x86ScalarFPBitViewAPI(t, initialized, "func f(p *byte)", "amd64", "x86_64-unknown-linux-gnu", "text")
+			if err != nil {
+				t.Fatal(row, err)
+			}
+			if !strings.Contains(ir, fmt.Sprintf("{1to%d}", shape.lanes)) || !strings.Contains(ir, fmt.Sprintf("elementtype([%d x i8])", spec.input/8)) {
+				t.Fatal("physical broadcast confused carrier with active lanes", row, ir)
+			}
+		}
+	}
+}
+
+func TestX86PackedConversionMalformedTypedGrammar(t *testing.T) {
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		shape := spec.shapes()[0]
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+		source, destination := bank[shape.source]+"0", bank[shape.destination]+"1"
+		invalid := []string{
+			spec.name + " " + source,
+			spec.name + " $1," + destination,
+			spec.name + " " + source + ",(AX)",
+			spec.name + " " + source + ",K0," + destination,
+			spec.name + " " + source + ",K8," + destination,
+			spec.name + ".Z " + source + "," + destination,
+			spec.name + ".BCST " + source + "," + destination,
+			spec.name + ".RN_SAE (AX)," + destination,
+			spec.name + ".SAE (AX)," + destination,
+			spec.name + ".RN_SAE.SAE " + source + "," + destination,
+			spec.name + " " + source + ",Y32",
+		}
+		if spec.legacy {
+			invalid = append(invalid, spec.name+".BCST (AX),"+destination,
+				spec.name+" "+source+",K1,"+destination)
+		}
+		for _, row := range invalid {
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86PackedConversionProperties(ins, "amd64"); !known || err == nil {
+				t.Fatal("malformed complete-family form accepted", row, err)
+			}
+		}
+		for _, position := range []int{0, 1} {
+			ins := x86ScalarLaneInstruction(t, spec.name+" "+source+","+destination)
+			ins.Args[position].Reg = Reg(bank[amd64VectorByteWidth(ins.Args[position].Reg)] + "8")
+			if _, known, err := x86PackedConversionProperties(ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("mode32 invented physical vector register", ins, err)
+			}
+		}
+	}
+	context := &amd64Ctx{goarch: "amd64"}
+	if known, _, err := context.lowerPackedNumericConversion("UNKNOWN", Instr{Op: "OTHER"}); known || err != nil {
+		t.Fatal("conversion lowerer claimed another instruction family", known, err)
+	}
+	valid := x86ScalarLaneInstruction(t, "CVTPS2PL X0,X1")
+	if known, _, err := context.lowerPackedNumericConversion("OTHER", valid); known || err != nil {
+		t.Fatal("unknown dispatch claimed a packed source spelling", known, err)
+	}
+	if known, _, err := context.lowerPackedNumericConversion("CVTPS2PL", Instr{Op: "OTHER"}); !known || err == nil {
+		t.Fatal("known dispatch lost its mismatched source identity", known, err)
+	}
+}
+
+func TestX86PackedConversionCompleteCallerConsumer(t *testing.T) {
+	var originals strings.Builder
+	count := 0
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		for _, shape := range spec.shapes() {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+			row := spec.name + " " + bank[shape.source] + "0," + bank[shape.destination] + "1"
+			body := "VMOVUPS (DI),Z0\n" + row + "\nVMOVSS X1,(DX)"
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			originals.WriteString(strings.Replace(assembly, "TEXT ·kernel", fmt.Sprintf("TEXT ·kernel%d", count), 1))
+			count++
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal("complete initialized conversion caller", row, err)
+			}
+			for _, operand := range []string{"(BX)", "(DX)", "(SP)", "(BP)", "a+0(FP)"} {
+				body := spec.name + " " + operand + "," + bank[shape.destination] + "1\nVMOVSS X1,(DX)"
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("conversion acquired unproved address/envelope/backing", row, operand, err)
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", originals.String(), "", true)
+	t.Logf("%d complete caller shapes, five independent address/backing negatives each", count)
+}
+
+func TestX86PackedConversionWholeFileSyntaxBeforeContext(t *testing.T) {
+	for _, context := range []struct{ name, arch, triple, instruction string }{
+		{"target", "amd64", "", "CVTPS2PL X0,X1"},
+		{"foreign target", "amd64", "aarch64-unknown-linux-gnu", "CVTPS2PL X0,X1"},
+		{"physical MMX", "amd64", "x86_64-unknown-linux-gnu", "CVTPS2PL X0,M0"},
+		{"physical mode32", "386", "i386-unknown-linux-gnu", "VCVTPS2DQ X8,X0"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			source := "TEXT ·f(SB),4,$0-0\n" + context.instruction + "\nRET\n"
+			_, err := x86ScalarFPBitViewAPI(t, source, "func f()", context.arch, context.triple, api)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original physical/target boundary lost", context.name, api, err)
+			}
+			for _, malformed := range []string{"VCVTPS2DQ.Z X0,X1", "CVTPS2PL X0,(AX)"} {
+				for _, suffix := range []struct{ assembly, declaration string }{
+					{malformed + "\n", "func f()"},
+					{"TEXT ·g(SB),4,$0-0\nRET\n" + malformed + "\n", "func f();func g()"},
+				} {
+					_, err := x86ScalarFPBitViewAPI(t, source+suffix.assembly, suffix.declaration, context.arch, context.triple, api)
+					if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "packed numeric conversion grammar") {
+						t.Fatal("earlier Context hid dead malformed source", context.name, api, malformed, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_conversion_fault_runtime_test.go b/amd64_packed_conversion_fault_runtime_test.go
new file mode 100644
index 000000000..5752a88cf
--- /dev/null
+++ b/amd64_packed_conversion_fault_runtime_test.go
@@ -0,0 +1,311 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+type x86PackedConversionFaultRow struct {
+	name       string
+	width      int
+	laneBytes  int
+	lanes      int
+	masked     bool
+	floating   bool
+	precision  bool
+	aligned    bool
+	conversion string
+}
+
+func x86PackedConversionFaultRows(wide bool) []x86PackedConversionFaultRow {
+	var rows []x86PackedConversionFaultRow
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if !wide && !spec.legacy {
+			continue
+		}
+		for _, shape := range spec.shapes() {
+			destination := map[int]string{16: "X1", 32: "Y1", 64: "Z1"}[shape.destination]
+			floating := strings.Contains(strings.Split(spec.name, "2")[0], "PS") || strings.Contains(strings.Split(spec.name, "2")[0], "PD")
+			precision := floating || spec.input > map[int]int{32: 24, 64: 53}[spec.output]
+			rows = append(rows, x86PackedConversionFaultRow{name: spec.name, width: shape.lanes * spec.input / 8, laneBytes: spec.input / 8, lanes: shape.lanes,
+				floating: floating, precision: precision, aligned: spec.legacy, conversion: spec.name + " (DI)," + destination})
+			if !spec.legacy {
+				rows = append(rows,
+					x86PackedConversionFaultRow{name: spec.name + ".Z", width: shape.lanes * spec.input / 8, laneBytes: spec.input / 8, lanes: shape.lanes, masked: true,
+						floating: floating, precision: precision, conversion: spec.name + ".Z (DI),K1," + destination},
+					x86PackedConversionFaultRow{name: spec.name + ".BCST.Z", width: spec.input / 8, laneBytes: spec.input / 8, lanes: shape.lanes, masked: true,
+						floating: floating, precision: precision, conversion: spec.name + ".BCST.Z (DI),K1," + destination})
+			}
+		}
+	}
+	return rows
+}
+
+// One actual Go TEXT holds every independent straight-line kernel. Split at
+// decoded RET boundaries, never a byte search (0xc3 can occur in displacement).
+// This creates no production native/source authorization.
+func x86PackedConversionFaultOriginalBytes(t *testing.T, rows []x86PackedConversionFaultRow) [][]byte {
+	t.Helper()
+	var source strings.Builder
+	source.WriteString("TEXT original(SB),4,$0-0\n")
+	for _, row := range rows {
+		source.WriteString("LDMXCSR (SI)\n")
+		if row.masked {
+			source.WriteString("KMOVW DX,K1\n")
+		}
+		source.WriteString(row.conversion + "\nRET\n")
+	}
+	code := x86PackedShiftActualGoBytes(t, "amd64", source.String())
+	var result [][]byte
+	offset := 0
+	for _, row := range rows {
+		start := offset
+		header := []byte{0x0f, 0xae, 0x16} // Actual Go LDMXCSR (SI).
+		if row.masked {
+			header = append(header, 0xc5, 0xf8, 0x92, 0xca) // KMOVW DX,K1.
+		}
+		if len(code)-offset < len(header) || !bytes.Equal(code[offset:offset+len(header)], header) {
+			t.Fatal("actual original header changed", row.name, offset)
+		}
+		offset += len(header)
+		_, length, known, err := decodedX86PackedNumericConversionInstruction(code[offset:], 64)
+		if !known {
+			_, length, known, err = decodedX86SameWidthConversionInstruction(code[offset:], 64)
+		}
+		if !known {
+			_, length, known, err = decodedX86PackedDoubleDwordInstruction(code[offset:], 64)
+		}
+		if !known {
+			native, decodeErr := x86asm.Decode(code[offset:], 64)
+			err, length = decodeErr, native.Len
+		}
+		if err != nil || length <= 0 || offset+length >= len(code) || code[offset+length] != 0xc3 {
+			t.Fatal("whole original conversion/RET boundary", row.name, offset, err)
+		}
+		offset += length + 1
+		result = append(result, append([]byte(nil), code[start:offset]...))
+	}
+	if offset != len(code) {
+		t.Fatal("unconsumed original Go instruction bytes")
+	}
+	return result
+}
+
+func x86PackedConversionDeadFaults(t *testing.T, wide, nativeTraps bool) {
+	t.Helper()
+	axis := x86FloatCompareSSE
+	if wide || nativeTraps {
+		axis = x86FloatCompareEVEX
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	rows := x86PackedConversionFaultRows(wide)
+	x86PackedConversionRunFaultRows(t, execution, rows, 96, 0, 1, nativeTraps, false)
+}
+
+func x86PackedConversionRunFaultRows(t *testing.T, execution x86FloatCompareExecution, rows []x86PackedConversionFaultRow, limit, owner, owners int, nativeTraps, complete bool) {
+	t.Helper()
+	consumed := 0
+	for batchNumber, start := 0, 0; start < len(rows); batchNumber, start = batchNumber+1, start+limit {
+		if batchNumber%owners != owner {
+			continue
+		}
+		end := start + limit
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			batch := rows[start:end]
+			var original [][]byte
+			observe := func(t *testing.T) {
+				original = x86PackedConversionFaultOriginalBytes(t, batch)
+				if len(original) != len(batch) {
+					t.Fatal("incomplete original Go opcode reference")
+				}
+			}
+			if complete {
+				t.Run("original_go_opcode_reference", observe)
+			} else {
+				observe(t)
+			}
+			if len(original) != len(batch) {
+				t.Fatal("missing original Go opcode reference")
+			}
+			var source, decl, native, prototypes, pairs strings.Builder
+			for index, row := range batch {
+				name, reference := fmt.Sprintf("fault%d", index), fmt.Sprintf("original%d", index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ p+0(FP),DI\nMOVQ csr+8(FP),SI\nLDMXCSR (SI)\n", name)
+				if row.masked {
+					source.WriteString("MOVL mask+16(FP),DX\nKMOVW DX,K1\n")
+				}
+				source.WriteString(row.conversion + "\nRET\n")
+				fmt.Fprintf(&decl, "func %s(p *uint64,csr *uint32,mask uint32)\n", name)
+				var octets []string
+				for _, value := range original[index] {
+					octets = append(octets, fmt.Sprintf("0x%02x", value))
+				}
+				symbol := reference
+				if strings.Contains(execution.triple, "apple") {
+					symbol = "_" + symbol
+				}
+				fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(octets, ",")+"\n")
+				fmt.Fprintf(&prototypes, "extern void %s(uint64_t*,uint32_t*,uint32_t),%s(uint64_t*,uint32_t*,uint32_t);\n", name, reference)
+				fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d,%d,%d,%d,%d},\n", reference, name, row.width, row.laneBytes, row.lanes,
+					x86FloatAddSubBoolInt(row.masked), x86FloatAddSubBoolInt(row.floating),
+					x86FloatAddSubBoolInt(row.precision), x86FloatAddSubBoolInt(row.aligned))
+			}
+			goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+			driver := fmt.Sprintf("#define NATIVE_TRAPS %d\n#define COMPLETE_NATIVE %d\n", x86FloatAddSubBoolInt(nativeTraps), x86FloatAddSubBoolInt(complete)) + `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + native.String() + prototypes.String() + `
+typedef void (*program)(uint64_t*,uint32_t*,uint32_t);
+static const struct {program original,translated;int width,lane,lanes,masked,floating,precision,aligned;} pairs[]={
+` + pairs.String() + `};
+static int outcome(program fn,uint8_t *p,uint32_t csr,uint32_t mask) {
+    pid_t child=fork();if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        fn((uint64_t*)p,&csr,mask);_exit(0);
+    }
+    int status;if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status)&&WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status)) {int sig=WTERMSIG(status);if(sig==SIGSEGV||sig==SIGBUS)return 1;if(sig==SIGFPE)return 2;}
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    uint8_t *p=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(p==MAP_FAILED||mprotect(p+page,page,PROT_NONE))return 2;
+    memset(p,0,page);
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);i++) {
+        int limits[]={0,pairs[i].width-1,pairs[i].width,pairs[i].width+1};
+        for(unsigned m=0;m<(pairs[i].masked?(COMPLETE_NATIVE?4u:3u):1u);m++) for(unsigned n=0;n<4;n++) {
+            uint32_t mask=m==0?0xffff:(m==1?0:(m==2?1:(1u<<pairs[i].lanes)));
+            int expected=limits[n]<((m==1||m==3)?0:(m==2?pairs[i].lane:pairs[i].width));
+            int a=outcome(pairs[i].original,p+page-limits[n],0x1f80,mask),b=outcome(pairs[i].translated,p+page-limits[n],0x1f80,mask);
+            int unaligned=pairs[i].aligned&&((uintptr_t)(p+page-limits[n])%16)!=0;
+            if(unaligned&&NATIVE_TRAPS) expected=1;
+            // Rosetta's legacy axis is differential only. The native owner
+            // above must enforce the legacy m128 alignment exception too.
+            if(unaligned&&!NATIVE_TRAPS&&!expected&&(a==0||a==1)) expected=a;
+            if(a!=expected||b!=expected) {fprintf(stderr,"dead read=%u available=%d mask=%x Go=%d LLVM=%d expected=%d\n",i,limits[n],mask,a,b,expected);return 3;}
+        }
+        for(int event=0;NATIVE_TRAPS&&event<2;event++) {
+            if((event==0&&!pairs[i].floating)||(event==1&&!pairs[i].precision)) continue;
+            uint64_t bits;
+            if(pairs[i].floating) {
+                if(pairs[i].lane==8) bits=event?UINT64_C(0x3ff8000000000000):UINT64_C(0x7ff8123456789abc);
+                else bits=event?UINT64_C(0x3fc00000):UINT64_C(0x7fc12345);
+            } else bits=pairs[i].lane==8?UINT64_C(0x20000000000001):UINT64_C(0x1000001);
+            memset(p,0,64);
+            memcpy(p,&bits,pairs[i].lane);
+            uint32_t csr=event?0x0f80:0x1f00;
+            for(int zero=0;zero<(pairs[i].masked?2:1);zero++) {
+                uint32_t mask=zero?0:0xffff;
+                int expected=zero?0:2;
+                int a=outcome(pairs[i].original,p,csr,mask),b=outcome(pairs[i].translated,p,csr,mask);
+                if(a!=expected||b!=expected) {
+                    fprintf(stderr,"dead exception=%u event=%d mask=%x Go=%d LLVM=%d expected=%d\n",i,event,mask,a,b,expected);
+                    return 4;
+                }
+            }
+        }
+    }
+    if(munmap(p,2*page))return 5;
+    puts("complete original Go/LLVM packed dead-fault receipt");return 0;
+}
+`
+			if complete {
+				raw := source.String()
+				for index, row := range batch {
+					header := 3
+					if row.masked {
+						header += 4
+					}
+					conversion := original[index][header : len(original[index])-1]
+					raw = strings.Replace(raw, row.conversion+"\nRET\n", x86RawDisplacementDirectives(conversion)+"RET\n", 1)
+				}
+				for _, spelling := range []struct{ name, source string }{{"named", source.String()}, {"raw", raw}} {
+					t.Run(spelling.name, func(t *testing.T) {
+						goAssemblerOracleOutput(t, "amd64", spelling.source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, spelling.source, decl.String(), "amd64", execution.triple, api)
+								if err != nil {
+									t.Fatal("initialized dead native conversion rejected", err)
+								}
+								x86PackedConversionNativePipelines(t, execution, ir, driver, []byte("complete original Go/LLVM packed dead-fault receipt\n"))
+							})
+						}
+					})
+				}
+				consumed += len(batch)
+				return
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), decl.String(), "amd64", execution.triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, optimized := range []bool{false, true} {
+					input := ir
+					if optimized {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						output := execution.compileAndRunLLVM(t, "packed-dead-fault", input, driver, level)
+						if string(output) != "complete original Go/LLVM packed dead-fault receipt\n" {
+							t.Fatal("incomplete dead-fault receipt", string(output))
+						}
+					}
+				}
+			}
+			consumed += len(batch)
+		})
+	}
+	if consumed == 0 {
+		t.Fatal("empty dead-fault owner")
+	}
+	t.Logf("%d/%d original-Go-opcode native memory and unmasked-fault kernels owned here", consumed, len(rows))
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionLegacyDeadFaults(t *testing.T) {
+	x86PackedConversionDeadFaults(t, false, false)
+}
+
+func TestX86PackedConversionCompleteFaultOriginalBoundaries(t *testing.T) {
+	rows := x86PackedConversionCompleteFaultRows()
+	if len(rows) != 222 {
+		t.Fatal("complete42 original fault boundary denominator changed", len(rows))
+	}
+	const limit = x86PackedConversionFaultCapture
+	consumed := 0
+	for start := 0; start < len(rows); start += limit {
+		end := start + limit
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			original := x86PackedConversionFaultOriginalBytes(t, rows[start:end])
+			if len(original) != end-start {
+				t.Fatal("original native fault fixture lost a conversion")
+			}
+			consumed += len(original)
+		})
+	}
+	if consumed != len(rows) {
+		t.Fatal("native fault batches overlap or omit rows")
+	}
+	t.Logf("%d original-Go complete memory/masked/broadcast fault kernels; assembly only, not native execution", consumed)
+}
diff --git a/amd64_packed_conversion_forms.go b/amd64_packed_conversion_forms.go
new file mode 100644
index 000000000..5c02f97b5
--- /dev/null
+++ b/amd64_packed_conversion_forms.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Element types, active lanes and physical registers are separate axes. In
+// particular X <- X can read 8 or 16 bytes and can write only 8 numeric bytes
+// followed by eight architectural zero bytes.
+type x86PackedConversionSpec struct {
+	amd64PackedNumericConversionSpec
+	legacy, vex bool
+}
+
+func x86PackedConversionSpecification(op Op) (x86PackedConversionSpec, bool) {
+	if spec, ok := amd64PackedNumericConversionSpecs[op]; ok {
+		return x86PackedConversionSpec{amd64PackedNumericConversionSpec: spec}, true
+	}
+	base := string(op)
+	legacy := !strings.HasPrefix(base, "V")
+	spec := amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericSigned,
+		sourceBits: 32, destinationBits: 32, truncate: strings.HasPrefix(base, "CVTT") || strings.HasPrefix(base, "VCVTT"),
+	}
+	switch base {
+	case "CVTPS2PL", "CVTTPS2PL":
+		spec.shapes = amd64PackedNumericSame32[:1]
+	case "VCVTPS2DQ", "VCVTTPS2DQ":
+		spec.shapes, spec.explicit = amd64PackedNumericSame32, "round"
+	case "CVTPD2PL", "CVTTPD2PL", "VCVTPD2DQX", "VCVTTPD2DQX":
+		spec.sourceBits = 64
+		spec.shapes = []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}
+	case "VCVTPD2DQY", "VCVTTPD2DQY":
+		spec.sourceBits = 64
+		spec.shapes = []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}
+	case "VCVTPD2DQ", "VCVTTPD2DQ":
+		spec.sourceBits, spec.explicit = 64, "round"
+		spec.shapes = []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}
+	default:
+		return x86PackedConversionSpec{}, false
+	}
+	if spec.explicit != "" && spec.truncate {
+		spec.explicit = "sae"
+	}
+	return x86PackedConversionSpec{amd64PackedNumericConversionSpec: spec, legacy: legacy, vex: !legacy}, true
+}
+
+type x86PackedConversionForm struct {
+	spec                      x86PackedConversionSpec
+	shape                     amd64PackedNumericShape
+	properties                amd64BinaryFloatingSuffix
+	inputBytes, memoryBytes   int
+	destination, memory, mask int
+	mmx, evex                 bool
+}
+
+// This grammar supplies widths, not a native frame, caller, pointee or MMX/x87
+// certificate. Memory consumers must independently retain those boundaries.
+func x86PackedConversionProperties(ins Instr, arch string) (x86PackedConversionForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86PackedConversionSpecification(Op(base))
+	if !known {
+		return x86PackedConversionForm{}, false, nil
+	}
+	return x86PackedConversionOperandProperties(ins, arch, spec)
+}
+
+// Share operand axes, not a family namespace, source proof or caller registry.
+func x86PackedConversionOperandProperties(ins Instr, arch string, spec x86PackedConversionSpec) (x86PackedConversionForm, bool, error) {
+	_, suffix, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	f := x86PackedConversionForm{spec: spec, destination: len(ins.Args) - 1, memory: -1, mask: -1}
+	fail := func() (x86PackedConversionForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside packed numeric conversion grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	var valid bool
+	f.properties, valid = parseAMD64BinaryFloatingSuffix(suffix)
+	if !valid || arch != "amd64" && arch != "386" || len(ins.Args) != 2 && len(ins.Args) != 3 ||
+		spec.legacy && (suffix != "" || len(ins.Args) != 2) ||
+		f.properties.rounding != "" && spec.explicit != "round" || f.properties.sae && spec.explicit != "sae" {
+		return fail()
+	}
+	if len(ins.Args) == 3 {
+		if !amd64NonzeroKOperand(ins.Args[1]) {
+			return fail()
+		}
+		f.mask = 1
+	} else if f.properties.zeroing {
+		return fail()
+	}
+	destination := ins.Args[f.destination]
+	_, f.mmx = amd64ParseMReg(destination.Reg)
+	if destination.Kind != OpReg || f.mmx && !spec.legacy {
+		return fail()
+	}
+	width := amd64VectorByteWidth(destination.Reg)
+	if f.mmx {
+		f.shape = amd64PackedNumericShape{sourceBytes: 16, destinationBytes: 8, lanes: 2}
+	} else {
+		for _, shape := range spec.shapes {
+			if shape.destinationBytes == width {
+				f.shape = shape
+				break
+			}
+		}
+		if f.shape.lanes == 0 || !amd64EVEXVectorRegister(destination, width) ||
+			spec.legacy && !amd64VEXVectorRegister(destination, 16) {
+			return fail()
+		}
+	}
+	f.inputBytes = f.shape.lanes * spec.sourceBits / 8
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		if f.properties.broadcast || !amd64EVEXVectorRegister(source, f.shape.sourceBytes) ||
+			spec.legacy && !amd64VEXVectorRegister(source, 16) {
+			return fail()
+		}
+	} else if isAMD64MemoryOperand(source) && x86SignedPackedFloatMemoryOperand(source, arch) {
+		f.memory, f.memoryBytes = 0, f.inputBytes
+		if f.properties.broadcast {
+			f.memoryBytes = spec.sourceBits / 8
+		}
+	} else {
+		return fail()
+	}
+	if (f.properties.rounding != "" || f.properties.sae) &&
+		(source.Kind != OpReg || f.shape != spec.shapes[len(spec.shapes)-1]) {
+		return fail()
+	}
+	f.evex = !spec.legacy && (!spec.vex || ins.x86PackedNumericEVEX || f.mask >= 0 ||
+		f.properties.broadcast || f.properties.rounding != "" || f.properties.sae ||
+		f.shape.sourceBytes == 64 || f.shape.destinationBytes == 64)
+	for index, operand := range []Operand{source, destination} {
+		if operand.Kind != OpReg || index == 1 && f.mmx {
+			continue
+		}
+		index, _ := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+		if arch == "386" && index >= 8 {
+			return f, true, fmt.Errorf("%w: %s register %s has no physical mode32 binding", ErrProbeNeedsContext, ins.Op, operand.Reg)
+		}
+		f.evex = f.evex || index >= 16
+	}
+	return f, true, nil
+}
+
+func validateX86PackedConversionFile(file *File, opt Options) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	var pending error
+	deferContext := func(err error) {
+		if pending == nil {
+			pending = err
+		}
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			form, known, err := x86PackedConversionProperties(ins, opt.Goarch)
+			if !known {
+				continue
+			}
+			if err != nil {
+				// Physical mode32 binding is not a grammar error. Retain its
+				// refusal, but still validate every later/dead source format.
+				if errors.Is(err, ErrProbeNeedsContext) {
+					deferContext(fmt.Errorf("%s: %w", fn.Sym, err))
+					continue
+				}
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			if form.mmx {
+				deferContext(fmt.Errorf("%w: %s has no complete physical MMX/x87 caller contract", ErrProbeNeedsContext, ins.Op))
+			}
+			if !x86ScalarFloatIntegerNativeTarget(opt.Goarch, opt.TargetTriple) {
+				deferContext(fmt.Errorf("%w: %s needs its matching native x86 MXCSR target", ErrProbeNeedsContext, ins.Op))
+			}
+		}
+	}
+	return pending
+}
diff --git a/amd64_packed_conversion_matrix_test.go b/amd64_packed_conversion_matrix_test.go
new file mode 100644
index 000000000..20460314b
--- /dev/null
+++ b/amd64_packed_conversion_matrix_test.go
@@ -0,0 +1,320 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent Go/Intel encoding inventory. No expected class, tuple, opcode
+// or semantic width is obtained from the production conversion tables.
+type x86PackedConversionOracle struct {
+	name, shape, control, pp, opcode string
+	input, output, w                 int
+	legacy, vex                      bool
+}
+
+func x86PackedConversionOracleSpecs() []x86PackedConversionOracle {
+	return []x86PackedConversionOracle{
+		{"CVTPS2PL", "single", "", "Pe", "0x5b", 32, 32, 0, true, false},
+		{"CVTTPS2PL", "single", "", "Pf3", "0x5b", 32, 32, 0, true, false},
+		{"CVTPD2PL", "narrow16", "", "Pf2", "0xe6", 64, 32, 0, true, false},
+		{"CVTTPD2PL", "narrow16", "", "Pe", "0xe6", 64, 32, 0, true, false},
+		{"VCVTPS2DQ", "same", "round", "66", "0x5B", 32, 32, 0, false, true},
+		{"VCVTTPS2DQ", "same", "sae", "F3", "0x5B", 32, 32, 0, false, true},
+		{"VCVTPD2DQX", "narrow16", "", "F2", "0xE6", 64, 32, 1, false, true},
+		{"VCVTPD2DQY", "narrow32", "", "F2", "0xE6", 64, 32, 1, false, true},
+		{"VCVTPD2DQ", "narrow64", "round", "F2", "0xE6", 64, 32, 1, false, false},
+		{"VCVTTPD2DQX", "narrow16", "", "66", "0xE6", 64, 32, 1, false, true},
+		{"VCVTTPD2DQY", "narrow32", "", "66", "0xE6", 64, 32, 1, false, true},
+		{"VCVTTPD2DQ", "narrow64", "sae", "66", "0xE6", 64, 32, 1, false, false},
+		{"VCVTPD2QQ", "same", "round", "66", "0x7B", 64, 64, 1, false, false},
+		{"VCVTPD2UQQ", "same", "round", "66", "0x79", 64, 64, 1, false, false},
+		{"VCVTTPD2QQ", "same", "sae", "66", "0x7A", 64, 64, 1, false, false},
+		{"VCVTTPD2UQQ", "same", "sae", "66", "0x78", 64, 64, 1, false, false},
+		{"VCVTPS2UDQ", "same", "round", "", "0x79", 32, 32, 0, false, false},
+		{"VCVTTPS2UDQ", "same", "sae", "", "0x78", 32, 32, 0, false, false},
+		{"VCVTUDQ2PS", "same", "round", "F2", "0x7A", 32, 32, 0, false, false},
+		{"VCVTQQ2PD", "same", "round", "F3", "0xE6", 64, 64, 1, false, false},
+		{"VCVTUQQ2PD", "same", "round", "F3", "0x7A", 64, 64, 1, false, false},
+		{"VCVTPS2QQ", "wide", "round", "66", "0x7B", 32, 64, 0, false, false},
+		{"VCVTPS2UQQ", "wide", "round", "66", "0x79", 32, 64, 0, false, false},
+		{"VCVTTPS2QQ", "wide", "sae", "66", "0x7A", 32, 64, 0, false, false},
+		{"VCVTTPS2UQQ", "wide", "sae", "66", "0x78", 32, 64, 0, false, false},
+		{"VCVTUDQ2PD", "wide", "", "F3", "0x7A", 32, 64, 0, false, false},
+		{"VCVTPD2UDQX", "narrow16", "", "", "0x79", 64, 32, 1, false, false},
+		{"VCVTPD2UDQY", "narrow32", "", "", "0x79", 64, 32, 1, false, false},
+		{"VCVTPD2UDQ", "narrow64", "round", "", "0x79", 64, 32, 1, false, false},
+		{"VCVTTPD2UDQX", "narrow16", "", "", "0x78", 64, 32, 1, false, false},
+		{"VCVTTPD2UDQY", "narrow32", "", "", "0x78", 64, 32, 1, false, false},
+		{"VCVTTPD2UDQ", "narrow64", "sae", "", "0x78", 64, 32, 1, false, false},
+		{"VCVTQQ2PSX", "narrow16", "", "", "0x5B", 64, 32, 1, false, false},
+		{"VCVTQQ2PSY", "narrow32", "", "", "0x5B", 64, 32, 1, false, false},
+		{"VCVTQQ2PS", "narrow64", "round", "", "0x5B", 64, 32, 1, false, false},
+		{"VCVTUQQ2PSX", "narrow16", "", "F2", "0x7A", 64, 32, 1, false, false},
+		{"VCVTUQQ2PSY", "narrow32", "", "F2", "0x7A", 64, 32, 1, false, false},
+		{"VCVTUQQ2PS", "narrow64", "round", "F2", "0x7A", 64, 32, 1, false, false},
+	}
+}
+
+type x86PackedOracleShape struct{ source, destination, lanes int }
+
+func (spec x86PackedConversionOracle) shapes() []x86PackedOracleShape {
+	var widths []int
+	switch spec.shape {
+	case "single", "narrow16":
+		widths = []int{16}
+	case "narrow32":
+		widths = []int{32}
+	case "narrow64":
+		widths = []int{64}
+	default:
+		widths = []int{16, 32, 64}
+	}
+	var result []x86PackedOracleShape
+	for _, width := range widths {
+		source, destination := width, width
+		lanes := width * 8 / spec.input
+		if spec.shape == "wide" {
+			source, lanes = width/2, width*8/spec.output
+		} else if strings.HasPrefix(spec.shape, "narrow") {
+			destination = width / 2
+		}
+		if source < 16 {
+			source = 16
+		}
+		if destination < 16 {
+			destination = 16
+		}
+		result = append(result, x86PackedOracleShape{source, destination, lanes})
+	}
+	return result
+}
+
+func TestX86PackedConversionIndependentCompleteGoRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxcvm1 = []ytab{\n\t{Zm_r_xm, 2, argList{Yxm, Yxr}},\n\t{Zm_r_xm, 2, argList{Yxm, Ymr}},\n}") {
+		t.Fatal("complete legacy operand table changed")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if spec.legacy {
+			mmxPrefix, mmxOpcode := "Pm", "0x2d"
+			if spec.input == 64 {
+				mmxPrefix = "Pe"
+			}
+			if strings.Contains(spec.name, "CVTT") {
+				mmxOpcode = "0x2c"
+			}
+			want := fmt.Sprintf("{A%s, yxcvm1, Px, opBytes{%s, %s, %s, %s}}", spec.name, spec.pp, spec.opcode, mmxPrefix, mmxOpcode)
+			if !strings.Contains(string(legacy), want) {
+				t.Fatal("legacy opcode attributes changed", want)
+			}
+			count += 2
+			continue
+		}
+		shapes := spec.shapes()
+		table := "_yvcvtpd2qq"
+		switch {
+		case spec.shape == "same" && spec.vex:
+			table = "_yvcvtdq2ps"
+		case spec.shape == "wide":
+			table = "_yvcvtps2qq"
+			if spec.name == "VCVTUDQ2PD" {
+				table = "_yvcvtudq2pd"
+			}
+		case spec.shape == "narrow64":
+			table = "_yvcvtpd2dq"
+		case spec.shape == "narrow16", spec.shape == "narrow32":
+			table = "_yvcvtpd2udq" + strings.ToLower(spec.name[len(spec.name)-1:])
+			if spec.vex {
+				table = strings.Replace(table, "udq", "dq", 1)
+			}
+		}
+		type row struct {
+			classes []string
+			zcase   string
+			offset  int
+		}
+		var rows []row
+		var opbytes []string
+		prefix := map[int]string{16: "x", 32: "y", 64: "z"}
+		appendShape := func(shape x86PackedOracleShape, evex bool) {
+			encoding, word, extra := "vex", 0, ""
+			if evex {
+				encoding, word, extra = "evex", spec.w, "Evex"
+			}
+			src := "Y" + prefix[shape.source] + "m" + extra
+			dst := "Y" + prefix[shape.destination] + "r" + extra
+			src, dst = strings.ReplaceAll(src, "zmEvex", "zm"), strings.ReplaceAll(dst, "zrEvex", "zr")
+			bits := shape.source * 8
+			if spec.shape == "wide" {
+				bits = shape.destination * 8
+			}
+			attributes := fmt.Sprintf("avxEscape | %s%d", encoding, bits)
+			if spec.pp != "" {
+				attributes += " | " + encoding + spec.pp
+			}
+			attributes += fmt.Sprintf(" | %s0F | %sW%d", encoding, encoding, word)
+			opbytes = append(opbytes, attributes)
+			if evex {
+				attributes = fmt.Sprintf("evexN%d | evexBcstN%d", shape.lanes*spec.input/8, spec.input/8)
+				if bits == 512 && spec.control != "" {
+					attributes += map[string]string{"round": " | evexRoundingEnabled", "sae": " | evexSaeEnabled"}[spec.control]
+				}
+				opbytes = append(opbytes, attributes+" | evexZeroingEnabled")
+				rows = append(rows, row{[]string{src, dst}, "Zevex_rm_v_r", 0}, row{[]string{src, "Yknot0", dst}, "Zevex_rm_k_r", 3})
+			} else {
+				rows = append(rows, row{[]string{src, dst}, "Zvex_rm_v_r", 2})
+			}
+			opbytes = append(opbytes, spec.opcode)
+		}
+		if spec.vex {
+			for _, shape := range shapes {
+				if shape.source < 64 && shape.destination < 64 {
+					appendShape(shape, false)
+				}
+			}
+		}
+		if len(shapes) == 3 && spec.name != "VCVTUDQ2PD" {
+			shapes = []x86PackedOracleShape{shapes[2], shapes[0], shapes[1]}
+		}
+		for _, shape := range shapes {
+			appendShape(shape, true)
+		}
+		index, offset := 0, 0
+		for _, actual := range rules {
+			if actual.Opcode != spec.name {
+				continue
+			}
+			if index >= len(rows) {
+				t.Fatal("unexpected extra Go encoder row", spec.name)
+			}
+			want := rows[index]
+			if actual.Ytab != table || actual.Prefix != "Pavx" || actual.RowIndex != index || actual.EncodingOffset != offset ||
+				actual.ZCase != want.zcase || actual.ZOffset != want.offset || !reflect.DeepEqual(actual.Classes, want.classes) || !reflect.DeepEqual(actual.OpBytes, opbytes) {
+				t.Fatalf("%s row%d changed: %+v\nwant %s %+v %v", spec.name, index, actual, table, want, opbytes)
+			}
+			index, offset, count = index+1, offset+want.offset, count+1
+		}
+		if index != len(rows) {
+			t.Fatal("missing encoder rows", spec.name, index, len(rows))
+		}
+	}
+	t.Logf("38 independent names, %d complete Go encoder rows", count)
+}
+
+func x86PackedConversionOracleRows(arch string) []string {
+	var rows []string
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		for _, shape := range spec.shapes() {
+			destination := bank[shape.destination] + "7"
+			for _, source := range []string{bank[shape.source] + "0", "(AX)", "3(BX)(CX*4)"} {
+				rows = append(rows, spec.name+" "+source+","+destination)
+				if !spec.legacy {
+					rows = append(rows, spec.name+" "+source+",K1,"+destination, spec.name+".Z "+source+",K7,"+destination)
+				}
+			}
+			if !spec.legacy {
+				rows = append(rows, spec.name+".BCST (AX),"+destination, spec.name+".BCST.Z 3(BX)(CX*4),K7,"+destination)
+				if arch == "amd64" {
+					rows = append(rows, spec.name+" "+bank[shape.source]+"31,"+bank[shape.destination]+"31")
+				}
+			}
+			if (shape.source == 64 || shape.destination == 64) && spec.control != "" {
+				suffixes := []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}
+				if spec.control == "sae" {
+					suffixes = []string{"SAE"}
+				}
+				for _, suffix := range suffixes {
+					rows = append(rows, spec.name+"."+suffix+" "+bank[shape.source]+"0,"+destination,
+						spec.name+"."+suffix+".Z "+bank[shape.source]+"0,K7,"+destination)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedConversionFiveTargetsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86PackedConversionOracleRows(target.arch)
+			seen := make(map[string]bool)
+			const batchSize = 96
+			for start := 0; start < len(rows); start += batchSize {
+				end := start + batchSize
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+					var source strings.Builder
+					for index, row := range rows[start:end] {
+						if seen[row] {
+							t.Fatal("duplicate matrix row", row)
+						}
+						seen[row] = true
+						fmt.Fprintf(&source, "TEXT ·f%d(SB),4,$0-0\n%s\nRET\n", index, row)
+					}
+					goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+					file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+					ir := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						compileLLVMToObject(t, llc, target.triple, "packed-conversion.ll", "packed-conversion.o", input)
+					}
+				})
+			}
+			if len(seen) != len(rows) {
+				t.Fatal("incomplete batch union")
+			}
+			t.Logf("%d unchanged unique formats, <=96 functions/module, 3 public Context APIs and 2 emitter IR pipelines; initialized public objects are separate", len(rows))
+		})
+	}
+}
+
+func TestX86PackedConversionMMXAndTargetRemainContext(t *testing.T) {
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		shape := spec.shapes()[0]
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+		row := spec.name + " " + bank[shape.source] + "0," + bank[shape.destination] + "1"
+		for _, target := range []string{"", "aarch64-unknown-linux-gnu", "i386-unknown-linux-gnu"} {
+			_, err := x86ScalarFPBitViewAPI(t, "TEXT ·f(SB),4,$0-0\nRET\n"+row+"\n", "func f()", "amd64", target, "text")
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("dead instruction acquired a foreign/missing target", row, target, err)
+			}
+		}
+		if spec.legacy {
+			for _, destination := range []string{"M0", "M7"} {
+				row := spec.name + " X0," + destination
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+				_, err := x86ScalarFPBitViewAPI(t, "TEXT ·f(SB),4,$0-0\n"+row+"\nRET\n", "func f()", "amd64", "x86_64-unknown-linux-gnu", "text")
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("virtual MMX destination granted physical x87 state", row, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_conversion_native_address_test.go b/amd64_packed_conversion_native_address_test.go
new file mode 100644
index 000000000..9fcb193e2
--- /dev/null
+++ b/amd64_packed_conversion_native_address_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent named memory inventory from Go's legacy and AVX encoder rows.
+// This address-role witness does not borrow the production spec or assert that
+// a Context form was translated; the separate complete family matrix retains
+// all widths, masks, rounding and raw encodings.
+func x86PackedNativeAddressRows() []struct{ name, destination string } {
+	var rows []struct{ name, destination string }
+	for _, name := range []string{
+		"CVTPS2PL", "CVTTPS2PL", "CVTPD2PL", "CVTTPD2PL",
+		"VCVTPS2DQ", "VCVTTPS2DQ", "VCVTPD2DQX", "VCVTPD2DQY", "VCVTTPD2DQX", "VCVTTPD2DQY",
+		"VCVTPD2QQ", "VCVTPD2UQQ", "VCVTTPD2QQ", "VCVTTPD2UQQ",
+		"VCVTPS2UDQ", "VCVTTPS2UDQ", "VCVTUDQ2PS", "VCVTQQ2PD", "VCVTUQQ2PD",
+		"VCVTPS2QQ", "VCVTPS2UQQ", "VCVTTPS2QQ", "VCVTTPS2UQQ", "VCVTUDQ2PD",
+		"VCVTPD2UDQX", "VCVTPD2UDQY", "VCVTTPD2UDQX", "VCVTTPD2UDQY",
+		"VCVTQQ2PSX", "VCVTQQ2PSY", "VCVTUQQ2PSX", "VCVTUQQ2PSY",
+	} {
+		rows = append(rows, struct{ name, destination string }{name, "X1"})
+	}
+	for _, name := range []string{"VCVTPD2DQ", "VCVTTPD2DQ", "VCVTPD2UDQ", "VCVTTPD2UDQ", "VCVTQQ2PS", "VCVTUQQ2PS"} {
+		rows = append(rows, struct{ name, destination string }{name, "Y1"})
+	}
+	return rows
+}
+
+func TestX86PackedConversionOriginalNativeAddressRequired(t *testing.T) {
+	rows := x86PackedNativeAddressRows()
+	if len(rows) != 38 {
+		t.Fatal("complete native conversion memory-name inventory changed", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var original strings.Builder
+		for index, row := range rows {
+			for _, address := range []string{"(SP)", "32(SP)", "(BP)", "-17(BP)", "32(SP)(CX*2)", "32(AX)(BP*2)"} {
+				name := fmt.Sprintf("original%d_%d", index, original.Len())
+				original.WriteString(x86OrdinaryBPNativeSource(arch, name, row.name+" "+address+","+row.destination, address, 128))
+			}
+		}
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				for _, row := range rows {
+					for _, address := range []string{"(SP)", "32(SP)", "(BP)", "-17(BP)", "32(SP)(CX*2)", "32(AX)(BP*2)"} {
+						source := x86OrdinaryBPNativeSource(target.arch, "view", row.name+" "+address+","+row.destination, address, 128)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *byte)", target.arch, target.triple, api)
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, address, ir, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedConversionOrdinaryNativeAddressControls(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, frame := "MOVQ", 8
+			if target.arch == "386" {
+				move, frame = "MOVL", 4
+			}
+			var source, declarations strings.Builder
+			for index, row := range x86PackedNativeAddressRows() {
+				for variant, address := range []string{"(AX)", "16(AX)(CX*2)"} {
+					name := fmt.Sprintf("control%d_%d", index, variant)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $0,CX\n%s %s,%s\nRET\n", name, frame, move, row.name, address, row.destination)
+					fmt.Fprintf(&declarations, "func %s(p *[128]byte)\n", name)
+				}
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("ordinary GP source control failed", err)
+					}
+					if strings.Count(ir, "asm sideeffect") != 76 {
+						t.Fatal("dead conversions lost whole native effects")
+					}
+					compileLLVMToObject(t, llc, target.triple, "native-address.ll", "native-address.o", x86MulDivRoundOptimize(t, ir))
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_conversion_native_host_linux_amd64_test.go b/amd64_packed_conversion_native_host_linux_amd64_test.go
new file mode 100644
index 000000000..374fd2180
--- /dev/null
+++ b/amd64_packed_conversion_native_host_linux_amd64_test.go
@@ -0,0 +1,8 @@
+package plan9asm
+
+import "testing"
+
+func x86PackedConversionRequireNativeHost(t *testing.T) {
+	t.Helper()
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_packed_conversion_native_host_other_test.go b/amd64_packed_conversion_native_host_other_test.go
new file mode 100644
index 000000000..cbed8caa2
--- /dev/null
+++ b/amd64_packed_conversion_native_host_other_test.go
@@ -0,0 +1,10 @@
+//go:build !linux || !amd64
+
+package plan9asm
+
+import "testing"
+
+func x86PackedConversionRequireNativeHost(t *testing.T) {
+	t.Helper()
+	t.Fatal("required complete packed conversion runtime needs actual native Linux/amd64")
+}
diff --git a/amd64_packed_conversion_native_tools_test.go b/amd64_packed_conversion_native_tools_test.go
new file mode 100644
index 000000000..6c993b7a6
--- /dev/null
+++ b/amd64_packed_conversion_native_tools_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func x86PackedConversionNativeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	x86PackedConversionRequireNativeHost(t)
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	directory := t.TempDir()
+	source := filepath.Join(directory, "packed-conversion-cpu.c")
+	executable := filepath.Join(directory, "packed-conversion-cpu")
+	if err := os.WriteFile(source, []byte(x86PackedConversionNativePreflightC), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("actual native packed conversion CPU/opcode preflight: %s", execution.run(t, executable))
+	return execution
+}
+
+func x86PackedConversionNativePipelines(t *testing.T, execution x86FloatCompareExecution, ir, driver string, want []byte) {
+	t.Helper()
+	for _, pipeline := range []struct {
+		name, backend string
+		optimize      bool
+	}{
+		{"backend_O0", "-O0", false},
+		{"backend_O2", "-O2", false},
+		{"IR_O2_backend_O2", "-O2", true},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			input := ir
+			if pipeline.optimize {
+				input = x86DwordProductIROptimize(t, ir)
+			}
+			got := execution.compileAndRunLLVM(t, "packed-conversion", input, driver, pipeline.backend)
+			if string(got) != string(want) {
+				t.Fatalf("original native/LLVM receipt differs\noriginal:\n%sLLVM:\n%s", want, got)
+			}
+		})
+	}
+}
+
+// This preflight executes original whole opcodes only after both CPUID and
+// actual OS register state pass. A missing feature or a failed opcode is an
+// infrastructure failure, never a skipped or portable runtime certificate.
+const x86PackedConversionNativePreflightC = `#include <stdint.h>
+#include <stdio.h>
+#include <cpuid.h>
+
+__attribute__((target("avx512f,avx512dq,avx512bw,avx512vl")))
+static int original_conversion_opcodes(void) {
+    _Alignas(64) uint64_t qwords[8]={0};
+    _Alignas(16) uint32_t dwords[4]={0};
+    uint64_t mask;
+    __asm__ volatile("vpxord %%zmm0,%%zmm0,%%zmm0; "
+                     "vcvtqq2pd %%zmm0,%%zmm1; vmovdqu64 %%zmm1,%0; "
+                     "kxnorq %%k1,%%k1,%%k1; kmovq %%k1,%2; "
+                     "vcvtdq2ps %%xmm0,%%xmm1%{%%k1%}%{z%}; vmovdqu32 %%xmm1,%1"
+                     : "=m"(qwords),"=m"(dwords),"=&r"(mask)
+                     :: "zmm0","zmm1","k1","memory");
+    for (unsigned i=0;i<8;i++) if (qwords[i]) return 0;
+    for (unsigned i=0;i<4;i++) if (dwords[i]) return 0;
+    return mask==UINT64_MAX;
+}
+
+int main(void) {
+    unsigned a,b,c,d,f=0,dq=0,bw=0,vl=0,osxsave=0;
+    uint64_t xcr0=0;
+    if (__get_cpuid(1,&a,&b,&c,&d)) {
+        osxsave=(c>>27)&1;
+        if (osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) {
+        f=(b>>16)&1; dq=(b>>17)&1; bw=(b>>30)&1; vl=(b>>31)&1;
+    }
+    printf("AVX512F=%u AVX512DQ=%u AVX512BW=%u AVX512VL=%u OSXSAVE=%u XCR0=%llx\n",
+           f,dq,bw,vl,osxsave,(unsigned long long)xcr0);
+    fflush(stdout);
+    if (!f || !dq || !bw || !vl || !osxsave || (xcr0&0xe6)!=0xe6) return 1;
+    if (!original_conversion_opcodes()) return 2;
+    puts("PACKED_CONVERSION_NATIVE_F_DQ_BW_VL_OK");
+    return 0;
+}
+`
diff --git a/amd64_packed_conversion_raw_test.go b/amd64_packed_conversion_raw_test.go
new file mode 100644
index 000000000..1aae6d7a4
--- /dev/null
+++ b/amd64_packed_conversion_raw_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Assemble a bounded batch once and partition every byte by real instruction
+// boundaries. Runtime raw cases do not use our mnemonic-to-opcode tables.
+func x86PackedConversionOriginalRawRows(t *testing.T, arch string, rows []string) []string {
+	t.Helper()
+	code := x86PackedShiftActualGoBytes(t, arch, "TEXT raw(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\n")
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	var raw []string
+	position := 0
+	for _, row := range rows {
+		_, length, known, err := decodedX86PackedNumericConversionInstruction(code[position:], mode)
+		if !known {
+			instruction, decodeErr := x86asm.Decode(code[position:], mode)
+			length, err = instruction.Len, decodeErr
+		}
+		if err != nil || length < 1 || length > len(code)-position {
+			t.Fatal("original conversion boundary", row, err)
+		}
+		var directives strings.Builder
+		for _, value := range code[position : position+length] {
+			fmt.Fprintf(&directives, "BYTE $%d\n", value)
+		}
+		raw = append(raw, strings.TrimSuffix(directives.String(), "\n"))
+		position += length
+	}
+	if position != len(code) {
+		t.Fatal("original conversion batch has unconsumed bytes")
+	}
+	return raw
+}
+
+func TestX86PackedConversionRawCompleteOriginalGoForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86PackedConversionOracleRows(arch)
+		var source strings.Builder
+		source.WriteString("TEXT raw(SB),4,$0-0\n")
+		for _, row := range rows {
+			source.WriteString(row + "\n")
+		}
+		source.WriteString("RET\n")
+		code := x86PackedShiftActualGoBytes(t, arch, source.String())
+		decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+		if err != nil {
+			t.Fatal(arch, err)
+		}
+		if len(decoded.Instrs) != len(rows)+1 {
+			t.Fatal("whole original Go byte stream lost instructions", arch, len(decoded.Instrs), len(rows)+1)
+		}
+		for index, row := range rows {
+			want, got := x86ScalarLaneInstruction(t, row), decoded.Instrs[index]
+			if want.Op != got.Op || len(want.Args) != len(got.Args) {
+				t.Fatal("raw opcode/mask mismatch", arch, row, got)
+			}
+			for operand := range want.Args {
+				if want.Args[operand].String() != got.Args[operand].String() {
+					t.Fatal("raw physical operand mismatch", arch, row, got)
+				}
+			}
+		}
+		t.Logf("%s: %d actual-Go forms, complete raw byte/typed-operand agreement", arch, len(rows))
+	}
+}
+
+func TestX86PackedConversionRawPrefixAndTruncationBoundaries(t *testing.T) {
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if spec.legacy {
+			continue
+		}
+		for _, shape := range spec.shapes() {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+			row := spec.name + ".Z 64(AX)(CX*4),K1," + bank[shape.destination] + "7"
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT raw(SB),4,$0-0\n"+row+"\n")
+			ins, length, known, err := decodedX86PackedNumericConversionInstruction(code, 64)
+			if err != nil || !known || length != len(code) || ins.Op != Op(spec.name+".Z") {
+				t.Fatal(row, fmt.Sprintf("%x", code), ins, length, err)
+			}
+			for end := 0; end < len(code); end++ {
+				if _, _, known, err := decodedX86PackedNumericConversionInstruction(code[:end], 64); known && err == nil {
+					t.Fatal("truncated instruction accepted", row, end)
+				}
+			}
+			for _, mutation := range []struct {
+				index int
+				xor   byte
+			}{{1, 0x08}, {2, 0x04}, {2, 0x08}, {3, 0x08}, {3, 0x01}} {
+				bad := append([]byte(nil), code...)
+				bad[mutation.index] ^= mutation.xor
+				if _, _, known, err := decodedX86PackedNumericConversionInstruction(bad, 64); known && err == nil {
+					t.Fatal("invalid fixed/vvvv/zero field accepted", row, fmt.Sprintf("%x", bad))
+				}
+			}
+			// Exact high source/destination registers are unavailable in mode32;
+			// a legal K1 mask by itself is not a high-register binding.
+			if _, _, known, err := decodedX86PackedNumericConversionInstruction(code, 32); !known || err != nil {
+				t.Fatal("legal mode32 masked conversion rejected", row, err)
+			}
+		}
+	}
+	for _, encoding := range []struct {
+		pp, opcode byte
+		name       string
+	}{
+		{1, 0x5b, "VCVTPS2DQ"}, {2, 0x5b, "VCVTTPS2DQ"},
+		{3, 0xe6, "VCVTPD2DQX"}, {1, 0xe6, "VCVTTPD2DQX"},
+	} {
+		for _, mode := range []int{32, 64} {
+			for _, w := range []byte{0, 0x80} {
+				code := []byte{0xc4, 0xe1, 0x78 | encoding.pp | w, encoding.opcode, 0xc1}
+				ins, n, known, err := decodedX86PackedNumericConversionInstruction(code, mode)
+				if err != nil || !known || n != len(code) || string(ins.Op) != encoding.name {
+					t.Fatal("Intel VEX.WIG must not become W0-only", mode, fmt.Sprintf("%x", code), ins, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_conversion_runtime_linux_amd64_test.go b/amd64_packed_conversion_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..1962c724b
--- /dev/null
+++ b/amd64_packed_conversion_runtime_linux_amd64_test.go
@@ -0,0 +1,75 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+// This required owner is separate from Rosetta SSE and object-only evidence.
+// CPUID/OS-state and original-opcode preflight must execute successfully.
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512Status(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeIndependentC(t *testing.T) {
+	amd64PackedNumericConversionNativeRuntimeSemantics(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaults(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart1(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart2(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart3(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart4(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 4)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart5(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 5)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart6(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 6)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart7(t *testing.T) {
+	x86PackedConversionCompleteNativeValues(t, 7)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart1(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart2(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart3(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart4(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 4)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart5(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 5)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart6(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 6)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart7(t *testing.T) {
+	x86PackedConversionCompleteNativeFaults(t, 7)
+}
diff --git a/amd64_packed_conversion_runtime_selection_test.go b/amd64_packed_conversion_runtime_selection_test.go
new file mode 100644
index 000000000..a24fdd9f6
--- /dev/null
+++ b/amd64_packed_conversion_runtime_selection_test.go
@@ -0,0 +1,17 @@
+package plan9asm
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedConversionRequiredNativeOwners(t *testing.T) {
+	// The complete policy binds all 17 unconditional owners to the explicit
+	// native tag. Ordinary conversion counterparts retain the default CI selector.
+	TestX86PackedConversionCompleteNativeRuntimeOwnership(t)
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") {
+		t.Fatal("ordinary conversion runtime counterparts not selected by CI", err)
+	}
+}
diff --git a/amd64_packed_conversion_runtime_test.go b/amd64_packed_conversion_runtime_test.go
new file mode 100644
index 000000000..8b02d6e9a
--- /dev/null
+++ b/amd64_packed_conversion_runtime_test.go
@@ -0,0 +1,267 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86PackedConversionRuntimeRow struct {
+	instruction string
+	rawOverride string
+	wide, dead  bool
+	inputBits   int
+	mask        bool
+	sae         bool
+}
+
+func x86PackedConversionRuntimeRows(wide bool) []x86PackedConversionRuntimeRow {
+	var rows []x86PackedConversionRuntimeRow
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if !wide && !spec.legacy {
+			continue
+		}
+		for _, shape := range spec.shapes() {
+			destination := bank[shape.destination] + "1"
+			for _, input := range []string{bank[shape.source] + "0", "(SI)"} {
+				rows = append(rows, x86PackedConversionRuntimeRow{instruction: spec.name + " " + input + "," + destination, wide: wide, inputBits: spec.input})
+			}
+			rows = append(rows, x86PackedConversionRuntimeRow{instruction: spec.name + " " + bank[shape.source] + "1," + destination, wide: wide, inputBits: spec.input},
+				x86PackedConversionRuntimeRow{instruction: spec.name + " " + bank[shape.source] + "0," + destination, wide: wide, dead: true, inputBits: spec.input})
+			if !spec.legacy {
+				for _, spelling := range []string{
+					spec.name + " " + bank[shape.source] + "0,K1," + destination,
+					spec.name + ".Z (SI),K1," + destination,
+					spec.name + ".BCST (SI),K1," + destination,
+					spec.name + ".BCST.Z (SI),K1," + destination,
+				} {
+					rows = append(rows, x86PackedConversionRuntimeRow{instruction: spelling, wide: wide, mask: true, inputBits: spec.input})
+				}
+			}
+			if (shape.source == 64 || shape.destination == 64) && spec.control != "" {
+				controls := []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}
+				if spec.control == "sae" {
+					controls = []string{"SAE"}
+				}
+				for _, control := range controls {
+					rows = append(rows, x86PackedConversionRuntimeRow{
+						instruction: spec.name + "." + control + ".Z " + bank[shape.source] + "0,K1," + destination,
+						wide:        wide, mask: true, sae: true, inputBits: spec.input,
+					})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86PackedConversionRuntimeFixture(rows []x86PackedConversionRuntimeRow) (assembly, declarations, original, driver string) {
+	var asm, decl, goCalls, cDecl, cCalls strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("packed%d", index)
+		fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-24\nSTMXCSR saved-4(SP)\nMOVQ out+0(FP),DI\nMOVQ in+8(FP),SI\n", name)
+		if row.wide {
+			asm.WriteString("VMOVDQU64 (SI),Z0\nVMOVDQU64 (DI),Z1\nMOVL mask+20(FP),CX\nKMOVW CX,K1\n")
+		} else {
+			asm.WriteString("MOVOU (SI),X0\nMOVOU (DI),X1\n")
+		}
+		asm.WriteString("LDMXCSR csr+16(FP)\nMOVQ $-1,DX\nCMPQ DX,$-1\n")
+		asm.WriteString(row.instruction + "\n")
+		if !row.dead {
+			if row.wide {
+				asm.WriteString("VMOVDQU64 Z1,(DI)\n")
+			} else {
+				asm.WriteString("MOVOU X1,(DI)\n")
+			}
+		}
+		asm.WriteString("STMXCSR 72(DI)\nSETEQ 64(DI)\nSETCS 65(DI)\nSETOS 66(DI)\nSETMI 67(DI)\nSETPC 68(DI)\nLDMXCSR saved-4(SP)\nRET\n")
+		fmt.Fprintf(&decl, "func %s(out *[12]uint64,in *[8]uint64,csr,mask uint32)\n", name)
+		masks, sae := 1, 0
+		if row.mask {
+			masks = 4
+		}
+		if row.sae {
+			sae = 1
+		}
+		fmt.Fprintf(&goCalls, "check(%d,%d,%d,%d,%s)\n", index, row.inputBits, masks, sae, name)
+		fmt.Fprintf(&cDecl, "extern void %s(uint64_t*,const uint64_t*,uint32_t,uint32_t);\n", name)
+		fmt.Fprintf(&cCalls, "check(%d,%d,%d,%d,%s);\n", index, row.inputBits, masks, sae, name)
+	}
+	var gValues, cValues strings.Builder
+	values := append(append([]uint64{}, x86ScalarFloatIntegerSSInputs...), x86ScalarFloatIntegerSDInputs...)
+	values = append(values, 0xffffff, 0x1000001, 0xffffffff, 0x1fffffffffffff, 0x20000000000001, 0x7fffffffffffffff, 0xffffffffffffffff)
+	for _, value := range values {
+		fmt.Fprintf(&gValues, "%#x,", value)
+		fmt.Fprintf(&cValues, "UINT64_C(%#x),", value)
+	}
+	original = `package main
+import ("fmt";"unsafe")
+var values=[]uint64{` + gValues.String() + `}
+var masks=[]uint32{0xffff,0,1,0xaaaa}
+func check(index,bits,maskCount,sae int,fn func(*[12]uint64,*[8]uint64,uint32,uint32)) {
+    hash:=uint64(1469598103934665603); count:=0
+    for n:=range values { for rc:=0;rc<4;rc++ { for controls:=0;controls<8;controls++ { for m:=0;m<maskCount;m++ {
+        var backing [10]uint64
+        address:=unsafe.Pointer(&backing[0])
+        input:=(*[8]uint64)(unsafe.Add(address,(-uintptr(address))&15))
+        for lane:=range input {
+            if bits==32 {input[lane]=uint64(uint32(values[(n+2*lane)%len(values)]))|uint64(uint32(values[(n+2*lane+1)%len(values)]))<<32
+            } else {input[lane]=values[(n+lane)%len(values)]}
+        }
+        var out [12]uint64
+        for lane:=range out {out[lane]=uint64(lane+1)*0x0101010101010101}
+        csr:=uint32(0x1f80|rc<<13)
+        if controls&1!=0 {csr|=0x40};if controls&2!=0 {csr|=0x8000}
+        if controls&4!=0 {csr|=0x21}
+        if sae!=0 {csr &^=0x1080}
+        fn(&out,input,csr,masks[m])
+        for _,word:=range out { for shift:=0;shift<64;shift+=8 {hash=(hash^uint64(byte(word>>shift)))*1099511628211} }
+        count++
+    }}}}
+    fmt.Printf("%d %d %016x\n",index,count,hash)
+}
+` + decl.String() + "func main(){\n" + goCalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static const uint64_t values[]={` + cValues.String() + `};
+static const uint32_t masks[]={0xffff,0,1,0xaaaa};
+static void check(unsigned index,unsigned bits,unsigned maskCount,unsigned sae,void (*fn)(uint64_t*,const uint64_t*,uint32_t,uint32_t)) {
+    uint64_t hash=UINT64_C(1469598103934665603);unsigned count=0,N=sizeof(values)/sizeof(*values);
+    for(unsigned n=0;n<N;n++) for(unsigned rc=0;rc<4;rc++) for(unsigned controls=0;controls<8;controls++) for(unsigned m=0;m<maskCount;m++) {
+        _Alignas(16) uint64_t input[8],out[12];
+        for(unsigned lane=0;lane<8;lane++) input[lane]=bits==32 ? (uint64_t)(uint32_t)values[(n+2*lane)%N]|(uint64_t)(uint32_t)values[(n+2*lane+1)%N]<<32 : values[(n+lane)%N];
+        for(unsigned lane=0;lane<12;lane++) out[lane]=(lane+1)*UINT64_C(0x0101010101010101);
+        uint32_t csr=0x1f80|(rc<<13);
+        if(controls&1) csr|=0x40;if(controls&2) csr|=0x8000;
+        if(controls&4) csr|=0x21;
+        if(sae) csr&=~UINT32_C(0x1080);
+        fn(out,input,csr,masks[m]);
+        for(unsigned lane=0;lane<12;lane++) for(unsigned shift=0;shift<64;shift+=8) hash=(hash^(uint8_t)(out[lane]>>shift))*UINT64_C(1099511628211);
+        count++;
+    }
+    printf("%u %u %016llx\n",index,count,(unsigned long long)hash);
+}
+` + cDecl.String() + "int main(void){\n" + cCalls.String() + "return 0;}\n"
+	return asm.String(), decl.String(), original, driver
+}
+
+func x86PackedConversionRuntimeMatrix(t *testing.T, wide bool) {
+	t.Helper()
+	axis := x86FloatCompareSSE
+	if wide {
+		axis = x86FloatCompareEVEX
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	rows := x86PackedConversionRuntimeRows(wide)
+	const limit = 96
+	consumed := 0
+	for start := 0; start < len(rows); start += limit {
+		end := start + limit
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			assembly, declarations, main, driver := x86PackedConversionRuntimeFixture(rows[start:end])
+			want := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, main)
+			if strings.Count(string(want), "\n") != end-start {
+				t.Fatal("incomplete original Go function/case receipts")
+			}
+			var originals []string
+			for _, row := range rows[start:end] {
+				originals = append(originals, row.instruction)
+			}
+			raw := x86PackedConversionOriginalRawRows(t, "amd64", originals)
+			rawRows := append([]x86PackedConversionRuntimeRow(nil), rows[start:end]...)
+			for index := range rawRows {
+				rawRows[index].instruction = raw[index]
+			}
+			rawAssembly, _, _, _ := x86PackedConversionRuntimeFixture(rawRows)
+			for _, spelling := range []struct{ name, source string }{{"named", assembly}, {"raw", rawAssembly}} {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations, "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(start, api, err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							got := execution.compileAndRunLLVM(t, "packed-conversion-matrix", input, driver, level)
+							if string(got) != string(want) {
+								t.Fatalf("batch %d %s/%s optimized=%v %s\nGo:\n%sLLVM:\n%s", start, spelling.name, api, optimized, level, want, got)
+							}
+						}
+					}
+				}
+			}
+			consumed += end - start
+		})
+	}
+	if consumed != len(rows) {
+		t.Fatal("runtime batch partition lost rows")
+	}
+	t.Logf("%d independent conversion kernels, 63 bit-pattern seeds x 4 rounding x 4 DAZ/FTZ x 2 clean/sticky status; masked kernels also 4 masks; named/raw x 3 APIs x 4 optimization axes", len(rows))
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionLegacyIEEEStatusFlags(t *testing.T) {
+	x86PackedConversionRuntimeMatrix(t, false)
+}
+
+// Object receipts for the actual wide runtime fixture are not execution
+// receipts. They close its source/API/lifecycle path before a native owner
+// attempts the same kernels, without executing unsupported host instructions.
+func TestX86PackedConversionNativeRuntimeFixtureObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86PackedConversionRuntimeRows(true)
+	const limit = 96
+	consumed := 0
+	for start := 0; start < len(rows); start += limit {
+		end := start + limit
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			batch := append([]x86PackedConversionRuntimeRow(nil), rows[start:end]...)
+			var instructions []string
+			for _, row := range batch {
+				instructions = append(instructions, row.instruction)
+			}
+			raw := x86PackedConversionOriginalRawRows(t, "amd64", instructions)
+			for _, spelling := range []string{"named", "raw"} {
+				if spelling == "raw" {
+					for index := range batch {
+						batch[index].instruction = raw[index]
+					}
+				}
+				source, declarations, _, _ := x86PackedConversionRuntimeFixture(batch)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatal(spelling, api, err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, ir)
+						}
+						compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "native-runtime.ll", "native-runtime.o", input)
+					}
+				}
+			}
+			consumed += end - start
+		})
+	}
+	if consumed != len(rows) {
+		t.Fatal("native runtime fixture partition lost rows")
+	}
+	t.Logf("%d complete wide runtime kernels, named/raw x 3 APIs x 2 IR pipelines; object-only", consumed)
+}
diff --git a/amd64_packed_conversion_status_runtime_test.go b/amd64_packed_conversion_status_runtime_test.go
new file mode 100644
index 000000000..eff5f8183
--- /dev/null
+++ b/amd64_packed_conversion_status_runtime_test.go
@@ -0,0 +1,108 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The four legacy Yxm/Yxr rows in Go's yxcvm1 table are an independently
+// executable status witness for packed float-to-dword conversion. MMX rows
+// and AVX/EVEX forms need their own physical-state execution owners.
+func x86PackedConversionConstantStatusOracle() (assembly, declarations, original, driver string) {
+	var asm, decl, goCalls, cDecl, cCalls strings.Builder
+	index := 0
+	for _, name := range []string{"CVTPS2PL", "CVTTPS2PL", "CVTPD2PL", "CVTTPD2PL"} {
+		values := []uint64{0x7fc12345, 0x7f800000, 0xff800000, 0x4f000000, 0x3fc00000, 1}
+		if strings.Contains(name, "PD") {
+			values = []uint64{0x7ff8123456789abc, 0x7ff0000000000000, 0xfff0000000000000, 0x41e0000000000000, 0x3ff8000000000000, 1}
+		}
+		for _, bits := range values {
+			if strings.Contains(name, "PS") {
+				bits |= bits << 32
+			}
+			for _, live := range []bool{false, true} {
+				function := fmt.Sprintf("packedProbe%d", index)
+				fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-12\n", function)
+				asm.WriteString("STMXCSR saved-4(SP)\nMOVQ out+0(FP),DI\n")
+				fmt.Fprintf(&asm, "MOVQ $%#x,AX\nMOVQ AX,X0\nPUNPCKLQDQ X0,X0\n", bits)
+				fmt.Fprintf(&asm, "LDMXCSR csr+8(FP)\n%s X0,X1\n", name)
+				if live {
+					asm.WriteString("MOVOU X1,(DI)\n")
+				}
+				asm.WriteString("STMXCSR 16(DI)\nLDMXCSR saved-4(SP)\nRET\n")
+				fmt.Fprintf(&decl, "func %s(out *[4]uint64, csr uint32)\n", function)
+				fmt.Fprintf(&goCalls, "check(%d, %s)\n", index, function)
+				fmt.Fprintf(&cDecl, "extern void %s(uint64_t*, uint32_t);\n", function)
+				fmt.Fprintf(&cCalls, "check(%d, %s);\n", index, function)
+				index++
+			}
+		}
+	}
+	original = `package main
+import "fmt"
+func check(index int, fn func(*[4]uint64, uint32)) {
+    for mode := 0; mode < 4; mode++ {
+        out := [4]uint64{0x1111111111111111, 0x2222222222222222, 0x3333333333333333, 0x4444444444444444}
+        fn(&out, 0x1f80|uint32(mode)<<13)
+        fmt.Printf("%d %d %016x %016x %016x %016x\n", index, mode, out[0], out[1], out[2], out[3])
+    }
+}
+` + decl.String() + "func main() {\n" + goCalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static void check(int index, void (*fn)(uint64_t*, uint32_t)) {
+    for (unsigned mode = 0; mode < 4; mode++) {
+        uint64_t out[] = {UINT64_C(0x1111111111111111), UINT64_C(0x2222222222222222), UINT64_C(0x3333333333333333), UINT64_C(0x4444444444444444)};
+        fn(out, 0x1f80 | (mode << 13));
+        printf("%d %u %016llx %016llx %016llx %016llx\n", index, mode,
+            (unsigned long long)out[0], (unsigned long long)out[1],
+            (unsigned long long)out[2], (unsigned long long)out[3]);
+    }
+}
+` + cDecl.String() + "int main(void) {\n" + cCalls.String() + "return 0;\n}\n"
+	return asm.String(), decl.String(), original, driver
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedConversionOriginalConstantsAndStatus(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	assembly, declarations, main, driver := x86PackedConversionConstantStatusOracle()
+	original := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, main)
+	want := strings.Split(strings.TrimSpace(string(original)), "\n")
+	if len(want) != 192 {
+		t.Fatalf("original Go produced %d rows, want 4 instructions x 6 inputs x 2 live/dead x 4 MXCSR modes", len(want))
+	}
+	ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		input := ir
+		if optimized {
+			input = x86MulDivRoundOptimize(t, ir)
+		}
+		for _, backend := range []string{"-O0", "-O2"} {
+			t.Run(fmt.Sprintf("IR_O2=%v/backend%s", optimized, backend), func(t *testing.T) {
+				output := execution.compileAndRunLLVM(t, "packed-conversion-status", input, driver, backend)
+				got := strings.Split(strings.TrimSpace(string(output)), "\n")
+				if len(got) != len(want) {
+					t.Fatalf("LLVM row count=%d original=%d", len(got), len(want))
+				}
+				mismatches := 0
+				for index := range want {
+					if got[index] != want[index] {
+						if mismatches == 0 {
+							t.Logf("first mismatch: original %s; LLVM %s", want[index], got[index])
+						}
+						mismatches++
+					}
+				}
+				if mismatches != 0 {
+					t.Errorf("original Go packed value/MXCSR/canary mismatches=%d/%d", mismatches, len(want))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_dot_forms.go b/amd64_packed_dot_forms.go
new file mode 100644
index 000000000..89167bd4f
--- /dev/null
+++ b/amd64_packed_dot_forms.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedDotForm struct {
+	x86PackedBinaryForm
+	spec amd64PackedDotProductSpec
+}
+
+// The four integer operations share Go's complete _yvblendmpd grammar.
+// Raw VEX is a distinct register/full-memory X/Y shape, not a named Go row;
+// BF16 never inherits this integer grammar or its numerical continuation.
+func x86PackedDotProperties(op Op, ins Instr, arch string) (x86PackedDotForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedDotProductSpecs[Op(base)]
+	if !known || spec.bfloat {
+		return x86PackedDotForm{}, false, nil
+	}
+	result := x86PackedDotForm{spec: spec}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return result, true, fmt.Errorf("integer dot-product dispatch/source opcode mismatch")
+	}
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 4, zeroing: true}
+	if ins.x86PackedDotEncoding == x86RawPackedDotVEX {
+		grammar = x86PackedBinarySpec{encoding: x86PackedLogicalVEX}
+	}
+	local := ins
+	local.Op = op
+	var err error
+	result.x86PackedBinaryForm, err = x86PackedBinaryOperandGrammar(local, arch, grammar, ins.x86Encoded)
+	if err != nil || result.memory < 0 {
+		return result, true, err
+	}
+	source := ins.Args[result.memory]
+	if !x86PackedShiftMemoryValid(source, arch) || source.Kind == OpMem &&
+		(!x86ConditionalMoveOffsetKnown(source.Mem) || source.Mem.IndexExt != "" ||
+			source.Mem.Segment != "" && source.Mem.Segment != FS && source.Mem.Segment != GS) {
+		return result, true, fmt.Errorf("%s has an unresolved or foreign memory source", op)
+	}
+	if source.Kind == OpSym {
+		if address, parseErr := parseInt(strings.TrimSpace(source.Sym)); parseErr == nil &&
+			address != int64(int32(address)) && !(arch == "386" && address == int64(uint32(address))) {
+			err = fmt.Errorf("%s absolute source exceeds its disp32 extent", op)
+		}
+	} else if source.Kind == OpMem {
+		err = x86SymbolIndexedMemoryError(source.Mem, arch)
+	}
+	if err == nil && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		err = fmt.Errorf("%w: %s needs its original default address mode", ErrProbeNeedsContext, op)
+	}
+	return result, true, err
+}
+
+func x86TypedPackedDotByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedDotProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: width, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width, read: true, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
+
+// All three inputs contribute the corresponding dword, including the old
+// destination with zero masking. Neither a mask nor an implementation zero
+// initializes an arithmetic input, including dead results in Void functions.
+func (form x86PackedDotForm) inputsDefined(first, second, old uint64) bool {
+	output := x86CallerVectorByteMask(int64(form.byteWidth))
+	input := output
+	if form.broadcast {
+		input = 15
+	}
+	return first&input == input && second&output == output && old&output == output
+}
diff --git a/amd64_packed_double_dword_native_linux_amd64_test.go b/amd64_packed_double_dword_native_linux_amd64_test.go
new file mode 100644
index 000000000..bd5ad5e7b
--- /dev/null
+++ b/amd64_packed_double_dword_native_linux_amd64_test.go
@@ -0,0 +1,11 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixAMD64PackedDoubleDwordNativeAVX512(t *testing.T) {
+	execution := x86PackedDoubleDwordNativeTools(t)
+	x86PackedDoubleDwordOriginalGo(t, execution)
+	amd64PackedDoubleDwordRuntime(t, execution, true)
+}
diff --git a/amd64_packed_double_dword_native_test.go b/amd64_packed_double_dword_native_test.go
new file mode 100644
index 000000000..7ecc9a584
--- /dev/null
+++ b/amd64_packed_double_dword_native_test.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86PackedDoubleDwordGoAssemblerSource(source string) string {
+	// Preserve the original NOSPLIT spelling and let this actual driver's
+	// original textflag.h define it, rather than silently rewriting TEXT.
+	return fmt.Sprintf("#include %q\n", filepath.Join(runtime.GOROOT(), "pkg", "include", "textflag.h")) + source
+}
+
+const x86PackedDoubleDwordMaskPreflightC = `
+#undef main
+__attribute__((target("avx512f,avx512bw"))) static int original_mask64(void) {
+    uint64_t input=0xa5,output;
+    __asm__ volatile("kmovq %1,%%k1; kmovq %%k1,%0" : "=r"(output) : "r"(input) : "k1");
+    return output==input;
+}
+static int mask64_required_state(unsigned bw) { return bw!=0; }
+int main(void) {
+    int failure=compare_preflight_main();
+    if (failure) return failure;
+    unsigned a,b,c,d,bw=0;
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) bw=(b>>30)&1;
+    printf("original double/dword mask transport AVX512BW=%u\n",bw);
+    fflush(stdout);
+    if (!mask64_required_state(bw)) return 83;
+    return original_mask64() ? 0 : 84;
+}
+`
+
+func x86PackedDoubleDwordNativeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	dir := t.TempDir()
+	source, binary := filepath.Join(dir, "mask-preflight.c"), filepath.Join(dir, "mask-preflight")
+	program := "#define REQUIRED_AXIS 3\n#define main compare_preflight_main\n" + x86FloatCompareOpcodePreflightC + x86PackedDoubleDwordMaskPreflightC
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, binary)
+	t.Logf("actual source KMOVQ preflight: %s", execution.run(t, binary))
+	return execution
+}
+
+func TestX86PackedDoubleDwordNativeMaskPreflight(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source, binary := filepath.Join(dir, "mask-capabilities.c"), filepath.Join(dir, "mask-capabilities")
+	program := "#define REQUIRED_AXIS 3\n#define main compare_preflight_main\n" + x86FloatCompareOpcodePreflightC +
+		strings.Replace(x86PackedDoubleDwordMaskPreflightC, "int main(void)", "int actual_mask_main(void)", 1) + `
+int main(void) { return !mask64_required_state(1) || mask64_required_state(0); }
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, binary)
+	execution.run(t, binary)
+}
+
+func TestX86PackedDoubleDwordRuntimeRequiresNativeUnion(t *testing.T) {
+	full, local := x86PackedDoubleDwordOriginalAssembly(), x86PackedDoubleDwordSSEAssembly(t)
+	for _, opcode := range []string{"VCVTDQ2PD (CX), K1, Z1", "VCVTTPD2DQY (BX), X2", "VCVTPD2DQ.RD_SAE.Z Z0, K1, Y3", "CVTPD2PL X4, X0"} {
+		if strings.Count(full, opcode) != 1 {
+			t.Fatal("lost or repeated original conversion", opcode)
+		}
+	}
+	parsed, err := Parse(ArchAMD64, local)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, instruction := range parsed.Funcs[0].Instrs {
+		if strings.HasPrefix(string(instruction.Op), "V") || strings.HasPrefix(string(instruction.Op), "KMOV") {
+			t.Fatal("portable SSE counterpart borrowed a wide opcode", instruction.Op)
+		}
+	}
+	if strings.Count(local, "CVTPD2PL X4, X0") != 1 {
+		t.Fatal("portable SSE counterpart borrowed a wide ISA or lost its original legacy conversion")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_packed_double_dword_native_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == "TestCrossLinuxRuntimeMatrixAMD64PackedDoubleDwordNativeAVX512" {
+			body = fn.Body
+		}
+	}
+	if body == nil || len(body.List) != 3 {
+		t.Fatal("complete original Go and named/raw LLVM runtime must consume native transport")
+	}
+	for index, name := range []string{"x86PackedDoubleDwordNativeTools", "x86PackedDoubleDwordOriginalGo", "amd64PackedDoubleDwordRuntime"} {
+		var call *ast.CallExpr
+		if index == 0 {
+			if assignment, ok := body.List[index].(*ast.AssignStmt); ok && len(assignment.Rhs) == 1 {
+				call, _ = assignment.Rhs[0].(*ast.CallExpr)
+			}
+		} else if statement, ok := body.List[index].(*ast.ExprStmt); ok {
+			call, _ = statement.X.(*ast.CallExpr)
+		}
+		if call == nil {
+			t.Fatal("required conversion consumer cannot skip or return", name)
+		}
+		callee, ok := call.Fun.(*ast.Ident)
+		if !ok || callee.Name != name {
+			t.Fatal("required conversion consumer missing", name)
+		}
+		if index > 0 {
+			route, ok := call.Args[1].(*ast.Ident)
+			if !ok || route.Name != "execution" {
+				t.Fatal("conversion consumer lost its exact preflight route")
+			}
+		}
+		if index == 2 {
+			if len(call.Args) != 3 {
+				t.Fatal("complete wide conversion execution was omitted")
+			}
+			wide, ok := call.Args[2].(*ast.Ident)
+			if !ok || wide.Name != "true" {
+				t.Fatal("complete wide conversion assertions cannot be disabled")
+			}
+		}
+	}
+}
+
+func x86PackedDoubleDwordOriginalGo(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	if execution.triple != "x86_64-unknown-linux-gnu" || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("original packed double/dword requires actual native Linux AMD64")
+	}
+	dir := x86PackedDoubleDwordOriginalPackage(t)
+	command := exec.Command("go", "test", "-p=2", "-count=1", "-run", "^TestOriginalDoubleDword$", "-v", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	t.Logf("actual original Go named/raw double/dword: %s", x86FloatCompareCaptureCommand(t, command))
+}
+
+func TestX86PackedDoubleDwordCompleteOriginalGoCompiles(t *testing.T) {
+	dir := x86PackedDoubleDwordOriginalPackage(t)
+	command := exec.Command("go", "test", "-p=2", "-c", "-o", filepath.Join(dir, "original"), ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOARCH=amd64", "GOOS=linux")
+	x86FloatCompareCaptureCommand(t, command)
+}
+
+func x86PackedDoubleDwordOriginalPackage(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	named := strings.Replace(x86PackedDoubleDwordOriginalAssembly(), "packeddoubledword(SB)", "·named(SB)", 1)
+	raw := strings.Replace(x86PackedDoubleDwordRawAssembly(x86PackedDoubleDwordOriginalAssembly()), "packeddoubledword(SB)", "·raw(SB)", 1)
+	assembly := "#include \"textflag.h\"\n" + named + raw + "TEXT ·setCSR(SB),4,$0-4\nLDMXCSR csr+0(FP)\nRET\nTEXT ·getCSR(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\n"
+	for name, contents := range map[string]string{
+		"go.mod": "module originaldoubledword\n\ngo 1.20\n", "original_amd64.s": assembly,
+		"original_test.go": x86PackedDoubleDwordOriginalGoTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+// This is output-only numerical evidence, not an MMX/x87 TAG/TOS identity
+// claim. The original fixture's MM0 conversion remains unchanged.
+const x86PackedDoubleDwordOriginalGoTest = `package original
+
+import (
+    "encoding/binary"
+    "math"
+    "runtime"
+    "testing"
+)
+
+func named(out *[120]byte, doubles *[8]float64, dwords *[8]int32, old *[8]float64, mask uint64)
+func raw(out *[120]byte, doubles *[8]float64, dwords *[8]int32, old *[8]float64, mask uint64)
+func setCSR(csr uint32)
+func getCSR() uint32
+
+func TestOriginalDoubleDword(t *testing.T) {
+    runtime.LockOSThread()
+    defer runtime.UnlockOSThread()
+    defer setCSR(getCSR())
+
+    doubles := [8]float64{
+        1.75, -2.75, 2147483648.0, math.Float64frombits(0x7ff8000000000000),
+        -2147483648.0, -2147483649.0, 3.0, math.Float64frombits(0x8000000000000000),
+    }
+    dwords := [8]int32{0, 1, -1, 2147483647, -2147483648, 123456789, -987654321, 42}
+    old := [8]float64{100.5, 101.5, 102.5, 103.5, 104.5, 105.5, 106.5, 107.5}
+    truncated := [4]int32{1, -2, -2147483648, -2147483648}
+    down := [8]int32{1, 0, -2147483648, 0, 0, -2147483648, 0, 0}
+
+    for index, fn := range []func(*[120]byte, *[8]float64, *[8]int32, *[8]float64, uint64){named, raw} {
+        var guarded [122]byte
+        for i := range guarded {
+            guarded[i] = 0xcc
+        }
+        setCSR(0x1f80)
+        fn((*[120]byte)(guarded[1:121]), &doubles, &dwords, &old, 0xa5)
+        output := guarded[1:121]
+        if guarded[0] != 0xcc || guarded[121] != 0xcc {
+            t.Fatal("original conversion output canary", index)
+        }
+
+        for i := 0; i < 8; i++ {
+            want := old[i]
+            if 0xa5&(1<<uint(i)) != 0 {
+                want = float64(dwords[i])
+            }
+            if math.Float64frombits(binary.LittleEndian.Uint64(output[8*i:])) != want ||
+                int32(binary.LittleEndian.Uint32(output[80+4*i:])) != down[i] {
+                t.Fatalf("original named/raw %d lane %d: %x", index, i, output)
+            }
+        }
+        for i := 0; i < 4; i++ {
+            if int32(binary.LittleEndian.Uint32(output[64+4*i:])) != truncated[i] {
+                t.Fatal("original truncation", index, i)
+            }
+        }
+        if int32(binary.LittleEndian.Uint32(output[112:])) != 2 || int32(binary.LittleEndian.Uint32(output[116:])) != -3 {
+            t.Fatal("original legacy conversion", index)
+        }
+    }
+}
+`
diff --git a/amd64_packed_float_shuffle_forms.go b/amd64_packed_float_shuffle_forms.go
new file mode 100644
index 000000000..ad05a0d28
--- /dev/null
+++ b/amd64_packed_float_shuffle_forms.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedFloatShuffleForm struct {
+	x86PackedBinaryForm
+	bits     int
+	selector uint8
+}
+
+// Go's two yxshuf rows and complete _yvgf2p8affineinvqb rows share the
+// existing binary operand grammar. Only the selector and two-source byte
+// dependencies differ from the single-source immediate integer shuffles.
+func x86PackedFloatShuffleProperties(op Op, ins Instr, arch string) (x86PackedFloatShuffleForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, vector, known := amd64PackedFloatShuffleProperties(base)
+	f := x86PackedFloatShuffleForm{bits: bits}
+	if !known {
+		return f, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) < 3 || len(ins.Args) > 5 || arch == "386" && vector {
+		return f, true, fmt.Errorf("%s %s has an unbound dispatch or Go operand arity", arch, op)
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || !amd64UnsignedImmediate(immediate, 8) {
+		return f, true, fmt.Errorf("%s %s requires Go's resolved Yu8 immediate", arch, op)
+	}
+	spec := x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}
+	if vector {
+		spec = x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: bits / 8, zeroing: true}
+	}
+	local := ins
+	local.Op, local.Args = op, ins.Args[1:]
+	var err error
+	f.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch, spec, false)
+	f.first++
+	f.second++
+	f.destination++
+	if f.memory >= 0 {
+		f.memory++
+	}
+	if f.mask >= 0 {
+		f.mask++
+	}
+	f.selector = uint8(immediate.Imm)
+	return f, true, err
+}
+
+// Index the concatenation of Go's first and second sources. PS selects its
+// low pair from the second source; PD alternates second/first within each
+// 128-bit lane, using a distinct immediate bit for every output qword.
+func (f x86PackedFloatShuffleForm) sourceByte(output int) int {
+	bytes := f.bits / 8
+	lane := output / bytes
+	first := lane%4 >= 2
+	selected := int(f.selector>>uint(2*(lane%4))) & 3
+	if f.bits == 64 {
+		first = lane%2 != 0
+		selected = int(f.selector>>uint(lane)) & 1
+	}
+	at := output/16*16 + selected*bytes + output%bytes
+	if first {
+		if f.broadcast {
+			at %= bytes
+		}
+		return at
+	}
+	return f.byteWidth + at
+}
+
+func (f x86PackedFloatShuffleForm) definedBytes(first, second, old uint64) uint64 {
+	var defined uint64
+	for output := 0; output < f.byteWidth; output++ {
+		at := f.sourceByte(output)
+		input := first
+		if at >= f.byteWidth {
+			input, at = second, at-f.byteWidth
+		}
+		known := input>>uint(at)&1 != 0
+		if f.mask >= 0 && !f.zeroing {
+			known = known && old>>uint(output)&1 != 0
+		}
+		if known {
+			defined |= uint64(1) << uint(output)
+		}
+	}
+	return defined
+}
+
+func x86TypedPackedFloatShuffleByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86PackedFloatShuffleProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(f.byteWidth), int64(f.byteWidth)
+	if f.memory >= 0 {
+		firstWidth = int64(f.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: f.first, operand: ins.Args[f.first], width: firstWidth, read: true},
+		{index: f.second, operand: ins.Args[f.second], width: width, read: true},
+	}}
+	if f.legacy {
+		effect.operands[1].write = true
+	} else {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: f.destination, operand: ins.Args[f.destination], width: width, write: true,
+			read: f.mask >= 0 && !f.zeroing,
+		})
+	}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_function_lifecycle_test.go b/amd64_packed_function_lifecycle_test.go
new file mode 100644
index 000000000..073c46adf
--- /dev/null
+++ b/amd64_packed_function_lifecycle_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// These expectations describe the emitted native memory carrier, not the
+// existence of an opcode in the implementation's family tables.
+func TestX86PackedFunctionFeatureViews(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			instruction string
+			features    string
+		}{
+			{"PAVGB (AX),X1", "+sse2"},
+			{"PAVGW (AX),X1", "+sse2"},
+			{"PMULLW (AX),X1", "+sse2"},
+			{"PMULHW (AX),X1", "+sse2"},
+			{"PMULHUW (AX),X1", "+sse2"},
+			{"PMULHRSW (AX),X1", "+sse2,+ssse3"},
+			{"PMADDWL (AX),X1", "+sse2"},
+			{"PMADDUBSW (AX),X1", "+sse2,+ssse3"},
+			{"PMULULQ (AX),X1", "+sse2"},
+			{"PMULDQ (AX),X1", "+sse2,+sse4.1"},
+		} {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				function := Func{Instrs: []Instr{x86ScalarLaneInstruction(t, row.instruction)}}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, function); got != row.features {
+					t.Fatalf("native memory features = %q, want %q", got, row.features)
+				}
+				// A new function representation must not reuse a preceding
+				// source's physical memory form, even when its slice is reused.
+				function.Instrs[0].Args[0] = Operand{Kind: OpFP, FPOffset: 0}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, function); got != "" {
+					t.Fatalf("logical FP inherited native memory features: %q", got)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedFunctionRegisterViews(t *testing.T) {
+	for _, row := range []struct {
+		source, physical Reg
+	}{
+		{AX, "M0"},
+		{SP, "M4"},
+	} {
+		function := Func{Instrs: []Instr{
+			{Op: "PAVGB", Args: []Operand{{Kind: OpReg, Reg: row.source}, {Kind: OpReg, Reg: "M1"}}},
+		}}
+		for _, arch := range []string{"amd64", "386"} {
+			consumer := newX86Ctx(new(strings.Builder), function, FuncSig{}, nil, nil, arch, "", false)
+			consumer.scanUsedRegs()
+			if consumer.usedRegs[row.physical] != (arch == "amd64") {
+				t.Fatalf("%s %s: physical bank discovery = %v", arch, row.source, consumer.usedRegs)
+			}
+			if function.Instrs[0].Args[0].Reg != row.source {
+				t.Fatal("register discovery mutated the original GP spelling")
+			}
+		}
+	}
+}
+
+func TestX86PackedFunctionLoweringAcrossLabels(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source := "TEXT binary(SB),4,$0-0\n" +
+			"PXOR X0,X0\nPXOR X1,X1\n" +
+			"first:\nPAVGB X0,X1\nPMULHW X0,X1\nJMP second\n" +
+			"second:\nPMADDWL X0,X1\nPMULULQ X0,X1\nPAVGB X0,X1\nRET\n"
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		options := Options{Goarch: arch, TargetTriple: triple,
+			Sigs: map[string]FuncSig{"binary": {Name: "binary", Ret: Void}}}
+		if _, err := Translate(file, options); err != nil {
+			t.Fatal("complete initialized four-family function", arch, err)
+		}
+		// Reusing the parsed file in a later request must observe the new
+		// invalid form rather than a preceding request's valid instruction.
+		for index := range file.Funcs[0].Instrs {
+			if file.Funcs[0].Instrs[index].Op == "PMULHW" {
+				file.Funcs[0].Instrs[index].Args[0].Reg = "Y0"
+				break
+			}
+		}
+		if _, err := Translate(file, options); err == nil {
+			t.Fatal("changed source retained a preceding valid form", arch)
+		}
+	}
+}
+
+func TestX86PackedFunctionErrorPrecedence(t *testing.T) {
+	for _, row := range []struct {
+		name, first, want string
+	}{
+		{"unknown_before_form", "NOT_AN_INSTRUCTION", "NOT_AN_INSTRUCTION"},
+		{"lock_before_form", "LOCK", "LOCK"},
+		{"repeat_before_form", "REP", "REP"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row.first+"\nVPAVGB X0,Y1,X2\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			consumer := newX86Ctx(new(strings.Builder), file.Funcs[0], FuncSig{Ret: Void}, nil, nil, "amd64", "", false)
+			if err := consumer.lowerBlocks(); err == nil || !strings.Contains(err.Error(), row.want) {
+				t.Fatalf("earlier source failure was displaced by a later form: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_integer_compare_fault_runtime_test.go b/amd64_packed_integer_compare_fault_runtime_test.go
new file mode 100644
index 000000000..a5634278b
--- /dev/null
+++ b/amd64_packed_integer_compare_fault_runtime_test.go
@@ -0,0 +1,328 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedIntegerCompareNativeMemoryStatus(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, prototypes, references, checks strings.Builder
+	count := 0
+	for opIndex, op := range x86PackedIntegerCompareTestNames {
+		bits := []int{8, 16, 32, 64}[opIndex%4]
+		widths := []int{16}
+		if opIndex >= 8 {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			variants := []int{0}
+			if opIndex >= 8 {
+				variants = []int{1, 2}
+				if width < 64 {
+					variants = append(variants, 0)
+				}
+				if bits >= 32 {
+					variants = append(variants, 3, 4)
+				}
+			}
+			for _, variant := range variants {
+				masked, broadcast := variant == 2 || variant == 4, variant >= 3
+				name := fmt.Sprintf("faultcompare%d", count)
+				count++
+				fmt.Fprintf(&declarations, "func %s(input *byte,mask uint64)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint64_t);\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ input+0(FP),BX\nMOVQ mask+8(FP),AX\nKMOVQ AX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n", name)
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				operands := "(BX),X1"
+				if opIndex >= 8 {
+					mask, destination := "", bank+"0"
+					if variant != 0 {
+						destination = "K2"
+					}
+					if masked {
+						mask = "K1,"
+					}
+					operands = fmt.Sprintf("(BX),%s1,%s%s", bank, mask, destination)
+				}
+				instruction := op
+				if broadcast {
+					instruction += ".BCST"
+				}
+				fmt.Fprintf(&source, "%s %s\nRET\n", instruction, operands)
+				fmt.Fprintf(&references, "__attribute__((noinline)) static void reference%d(const uint8_t *p,uint64_t mask) {\n", count-1)
+				if opIndex < 8 {
+					mnemonic := strings.ToLower(strings.ReplaceAll(op, "L", "D"))
+					references.WriteString("    typedef int32_t V __attribute__((vector_size(16)));\n    V value = {0,0,0,0};\n")
+					fmt.Fprintf(&references, "    __asm__ volatile(\"%s (%%1),%%0\" : \"+x\"(value) : \"r\"(p) : \"memory\");\n", mnemonic)
+				} else {
+					bytes := bits / 8
+					fmt.Fprintf(&references, "    for (int lane = 0; lane < %d; ++lane) {\n", width/bytes)
+					if masked {
+						references.WriteString("        if (!((mask>>lane)&1)) continue;\n")
+					}
+					offset := "lane*" + fmt.Sprint(bytes)
+					if broadcast {
+						offset = "0"
+					}
+					fmt.Fprintf(&references, "        for (int j = 0; j < %d; ++j) {\n            (void)((const volatile uint8_t*)p)[%s+j];\n        }\n", bytes, offset)
+					references.WriteString("    }\n")
+				}
+				references.WriteString("}\n")
+				lanes := width * 8 / bits
+				masks := []uint64{0}
+				if masked {
+					masks = []uint64{0, 1, uint64(1) << uint(lanes-1), ^uint64(0)}
+				}
+				for _, mask := range masks {
+					expectedReadable := "0"
+					if opIndex < 8 {
+						expectedReadable = "offset == 0 ? 0 : 2"
+					}
+					fmt.Fprintf(&checks, "    for (int offset = 0; offset < 16; ++offset) {\n        if (compare(reference%d,%s,memory+offset,UINT64_C(%d),%s)) return 1;\n    }\n", count-1, name, mask, expectedReadable)
+					for _, offset := range []int{0, 1, bits / 8, 16, 32, 64} {
+						expected := x86PackedIntegerCompareMemoryExpectation(opIndex < 8, width, bits/8, masked, broadcast, mask, offset, offset%16 == 0)
+						fmt.Fprintf(&checks, "    if (compare(reference%d,%s,boundary-%d,UINT64_C(%d),%d)) return 1;\n", count-1, name, offset, mask, expected)
+					}
+					expectedNull := x86PackedIntegerCompareMemoryExpectation(opIndex < 8, width, bits/8, masked, broadcast, mask, 0, true)
+					fmt.Fprintf(&checks, "    if (compare(reference%d,%s,0,UINT64_C(%d),%d)) return 1;\n", count-1, name, mask, expectedNull)
+				}
+			}
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+	ir, err := x86PackedIntegerCompareAPI(t, source.String(), declarations.String(), "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	program := `#include <stdint.h>
+#include <cpuid.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + references.String() + x86PackedIntegerCompareFaultStatusOracle + `
+int main(void) {
+    struct rlimit noCore = {0,0};
+    if (setrlimit(RLIMIT_CORE,&noCore)) return 76;
+    unsigned a,b,c,d;
+    if (!__get_cpuid(1,&a,&b,&c,&d) || !(c&(1u<<19)) || !(c&(1u<<20))) {
+        fprintf(stderr,"packed compare fault root requires actual SSE4.1 and SSE4.2\n");
+        return 77;
+    }
+    __asm__ volatile("pxor %%xmm0,%%xmm0\n\t"
+                     "pcmpeqq %%xmm0,%%xmm0\n\t"
+                     "pcmpgtq %%xmm0,%%xmm0" : : : "xmm0");
+    printf("packed compare fault preflight: CPUID SSE4.1=1 SSE4.2=1; actual PCMPEQQ/PCMPGTQ executed\n");
+    long page = sysconf(_SC_PAGESIZE);
+    if (page <= 0 || page%64) return 1;
+    uint8_t *memory = mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,
+                           MAP_PRIVATE|MAP_ANON,-1,0);
+    if (memory == MAP_FAILED) return 1;
+    memset(memory,0x87,(size_t)page);
+    if (mprotect(memory,(size_t)page,PROT_READ) ||
+        mprotect(memory+page,(size_t)page,PROT_NONE)) return 1;
+    uint8_t *boundary = memory+page;
+` + checks.String() + `
+    if (munmap(memory,(size_t)page*2)) return 1;
+    return 0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-compare-fault", triple, text, program, prefix)
+		})
+	}
+	t.Logf("%d dead-result programs at mod16/NULL/read-only guard pages, exact native legacy and independent E4 lane-read status at O0/O2; not native EVEX execution", count)
+}
+
+// Expected status comes from the independently constructed fixture accesses,
+// not a production descriptor. 0 requires normal exit0; 1 requires a memory
+// fault. Only readable, unaligned legacy sources use 2: preserve the original
+// machine's exact alignment behavior without guessing a vendor's fault policy.
+func x86PackedIntegerCompareMemoryExpectation(legacy bool, width, laneBytes int, masked, broadcast bool, mask uint64, available int, aligned bool) int {
+	if legacy {
+		if available < 16 {
+			return 1
+		}
+		if !aligned {
+			return 2
+		}
+		return 0
+	}
+	readEnd := 0
+	for lane := 0; lane < width/laneBytes; lane++ {
+		if masked && mask&(uint64(1)<<uint(lane)) == 0 {
+			continue
+		}
+		end := (lane + 1) * laneBytes
+		if broadcast {
+			end = laneBytes
+		}
+		if end > readEnd {
+			readEnd = end
+		}
+	}
+	if readEnd > available {
+		return 1
+	}
+	return 0
+}
+
+const x86PackedIntegerCompareFaultStatusOracle = `
+typedef struct { int signal; int code; } Status;
+
+static int observe(void (*fn)(const uint8_t*,uint64_t),const uint8_t *p,
+                   uint64_t mask,Status *out) {
+    pid_t child = fork();
+    if (child < 0) return 1;
+    if (child == 0) {
+        struct rlimit limit = {0,0};
+        if (setrlimit(RLIMIT_CORE,&limit)) _exit(3);
+        fn(p,mask);
+        _exit(0);
+    }
+    int status;
+    if (waitpid(child,&status,0) != child) return 1;
+    if (WIFSIGNALED(status)) {
+        *out = (Status){WTERMSIG(status),0};
+        return 0;
+    }
+    if (WIFEXITED(status)) {
+        *out = (Status){0,WEXITSTATUS(status)};
+        return 0;
+    }
+    return 1;
+}
+
+static int compare(void (*original)(const uint8_t*,uint64_t),
+                   void (*translated)(const uint8_t*,uint64_t),
+                   const uint8_t *p,uint64_t mask,int expectation) {
+    Status a,b;
+    if (observe(original,p,mask,&a) || observe(translated,p,mask,&b)) return 1;
+    int allowedA = a.code == 0 && (a.signal == 0 || a.signal == SIGSEGV || a.signal == SIGBUS);
+    int allowedB = b.code == 0 && (b.signal == 0 || b.signal == SIGSEGV || b.signal == SIGBUS);
+    if (!allowedA || !allowedB || expectation < 0 || expectation > 2 ||
+        (expectation == 0 && (a.signal || b.signal)) ||
+        (expectation == 1 && (!a.signal || !b.signal)) ||
+        a.signal != b.signal || a.code != b.code) {
+        fprintf(stderr,"mod16=%lu mask=%llx original=(%d,%d) translated=(%d,%d)\n",
+                (unsigned long)((uintptr_t)p%16),(unsigned long long)mask,
+                a.signal,a.code,b.signal,b.code);
+        return 1;
+    }
+    return 0;
+}
+`
+
+func TestX86PackedIntegerCompareFaultStatusRejectsSymmetricUnexpectedExit(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	// The child observations are real, but these deliberately raised signals
+	// test the oracle's status domain, not a memory fault or native opcode.
+	// Run on the actual host; this C-only control has no x86 ISA requirement.
+	program := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + x86PackedIntegerCompareFaultStatusOracle + `
+static int selectedSignal;
+
+static void unexpected(const uint8_t *p,uint64_t mask) {
+    if (!selectedSignal) {
+        _exit(7);
+    }
+    raise(selectedSignal);
+}
+
+static void complete(const uint8_t *p,uint64_t mask) {}
+
+int main(void) {
+    const int rejected[] = {SIGILL,SIGABRT,SIGFPE,SIGTRAP,0};
+    for (unsigned i = 0; i < sizeof(rejected)/sizeof(rejected[0]); ++i) {
+        selectedSignal = rejected[i];
+        if (!compare(unexpected,unexpected,0,0,2)) {
+            fprintf(stderr,"symmetric unexpected status accepted: signal=%d\n",selectedSignal);
+            return 1;
+        }
+    }
+    return compare(complete,complete,0,0,0);
+}
+`
+	ir := "target triple = \"" + execution.triple + "\"\ndefine void @status_tripwire_object() { ret void }\n"
+	execution.compileAndRunLLVM(t, "packed-compare-status-tripwire", ir, program, "-O2")
+}
+
+func TestX86PackedIntegerCompareFaultStatusRequiresSuccessfulReadableControl(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	// Deliberately raised memory signals are classification tripwires. They do
+	// not replace the independently mapped native-width fixtures above.
+	program := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + x86PackedIntegerCompareFaultStatusOracle + `
+static void unexpectedMemoryFault(const uint8_t *p,uint64_t mask) {
+    raise(SIGSEGV);
+}
+
+static void complete(const uint8_t *p,uint64_t mask) {}
+
+int main(void) {
+    if (!compare(unexpectedMemoryFault,unexpectedMemoryFault,0,0,0)) {
+        fprintf(stderr,"symmetric memory fault replaced required successful control\n");
+        return 1;
+    }
+    if (compare(unexpectedMemoryFault,unexpectedMemoryFault,0,0,1)) return 2;
+    return compare(complete,complete,0,0,0);
+}
+`
+	ir := "target triple = \"" + execution.triple + "\"\ndefine void @readable_tripwire_object() { ret void }\n"
+	execution.compileAndRunLLVM(t, "packed-compare-readable-tripwire", ir, program, "-O2")
+}
+
+func TestX86PackedIntegerCompareFaultExpectedAccessMatrix(t *testing.T) {
+	for _, test := range []struct {
+		name                      string
+		legacy, masked, broadcast bool
+		width, bytes, available   int
+		mask                      uint64
+		aligned                   bool
+		want                      int
+	}{
+		{"legacy-aligned-readable", true, false, false, 16, 8, 16, 0, true, 0},
+		{"legacy-unaligned-readable", true, false, false, 16, 8, 16, 0, false, 2},
+		{"legacy-guard-overlap", true, false, false, 16, 8, 15, 0, true, 1},
+		{"vex-full-readable-unaligned", false, false, false, 32, 4, 32, 0, false, 0},
+		{"vex-full-guard-overlap", false, false, false, 32, 4, 31, 0, false, 1},
+		{"evex-zero-mask-null", false, true, false, 64, 1, 0, 0, true, 0},
+		{"evex-low-lane-readable", false, true, false, 64, 1, 1, 1, false, 0},
+		{"evex-high-lane-guard", false, true, false, 64, 1, 63, uint64(1) << 63, false, 1},
+		{"evex-high-lane-readable", false, true, false, 64, 1, 64, uint64(1) << 63, false, 0},
+		{"broadcast-zero-mask-null", false, true, true, 64, 8, 0, 0, false, 0},
+		{"broadcast-readable", false, true, true, 64, 8, 8, 0xff, false, 0},
+		{"broadcast-guard-overlap", false, true, true, 64, 8, 7, 0xff, false, 1},
+		{"broadcast-irrelevant-mask-null", false, true, true, 16, 8, 0, 4, false, 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := x86PackedIntegerCompareMemoryExpectation(test.legacy, test.width, test.bytes,
+				test.masked, test.broadcast, test.mask, test.available, test.aligned)
+			if got != test.want {
+				t.Fatalf("independent expected access status=%d, want=%d", got, test.want)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_integer_compare_forms.go b/amd64_packed_integer_compare_forms.go
new file mode 100644
index 000000000..115fdf467
--- /dev/null
+++ b/amd64_packed_integer_compare_forms.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedIntegerCompareSpec struct {
+	laneBits int
+	greater  bool
+	legacy   bool
+	mmx      bool
+}
+
+var x86PackedIntegerCompareSpecs = map[Op]x86PackedIntegerCompareSpec{
+	"PCMPEQB":  {8, false, true, true},
+	"PCMPEQW":  {16, false, true, true},
+	"PCMPEQL":  {32, false, true, true},
+	"PCMPEQQ":  {64, false, true, false},
+	"PCMPGTB":  {8, true, true, true},
+	"PCMPGTW":  {16, true, true, true},
+	"PCMPGTL":  {32, true, true, true},
+	"PCMPGTQ":  {64, true, true, false},
+	"VPCMPEQB": {8, false, false, false},
+	"VPCMPEQW": {16, false, false, false},
+	"VPCMPEQD": {32, false, false, false},
+	"VPCMPEQQ": {64, false, false, false},
+	"VPCMPGTB": {8, true, false, false},
+	"VPCMPGTW": {16, true, false, false},
+	"VPCMPGTD": {32, true, false, false},
+	"VPCMPGTQ": {64, true, false, false},
+}
+
+type x86PackedIntegerCompareForm struct {
+	x86PackedBinaryForm
+	spec       x86PackedIntegerCompareSpec
+	source     Operand
+	maskResult bool
+}
+
+// Integer relations of an identical physical vector view are independent of
+// its bits, including all eight immediate predicates. This is only a numerical
+// dependency rule after full grammar validation. Mask inputs remain required;
+// floating comparisons, memory, raw roles and the native MMX bank stay separate.
+func (form x86PackedIntegerCompareForm) identicalVectorInputs(ins Instr) bool {
+	return x86ResultNamedPredicateInstruction(ins) && !form.mmx && form.memory < 0 &&
+		form.source.Kind == OpReg && ins.Args[form.second].Kind == OpReg &&
+		form.source.Reg == ins.Args[form.second].Reg
+}
+
+// Properties describe the Go operand rows and physical mode, not initialized
+// inputs, native backing, memory bounds, or caller authority. The raw decoder's
+// eight-entry encoding registry remains distinct from these sixteen Go names.
+func x86PackedIntegerCompareProperties(op Op, ins Instr, arch string) (x86PackedIntegerCompareForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86PackedIntegerCompareSpecs[Op(base)]
+	if !known {
+		return x86PackedIntegerCompareForm{}, false, nil
+	}
+	form := x86PackedIntegerCompareForm{spec: spec}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return form, true, fmt.Errorf("packed integer compare dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	local := ins
+	local.Op = op
+	local.Args = append([]Operand(nil), ins.Args...)
+	fail := func() (x86PackedIntegerCompareForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go packed integer compare grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" {
+		return fail()
+	}
+	if spec.legacy || len(local.Args) == 3 && local.Args[2].Kind == OpReg && !amd64IsKOperand(local.Args[2]) {
+		encoding := x86PackedLogicalVEX
+		if spec.legacy {
+			encoding = x86PackedLogicalLegacyFP
+			if spec.mmx {
+				encoding = x86PackedLogicalLegacyInteger
+				var err error
+				local, err = x86LegacyMMXReadInstruction(local, arch)
+				if err != nil {
+					return form, true, err
+				}
+			}
+		}
+		binary, err := x86PackedBinaryProperties(local, arch, x86PackedBinarySpec{encoding: encoding})
+		form.x86PackedBinaryForm = binary
+		if err != nil {
+			return form, true, err
+		}
+	} else {
+		// _yvpcmpeqb EVEX rows produce K0-7, not an X/Y/Z destination;
+		// their optional input mask is K1-7. There is no .Z form.
+		form.maskResult = true
+		binary, valid := x86PackedMaskCompareProperties(local, arch, 0, spec.laneBits, dotted, suffix)
+		if !valid {
+			return fail()
+		}
+		form.x86PackedBinaryForm = binary
+	}
+	form.source = local.Args[form.first]
+	if err := x86Mode32VectorRegisterContext(local, arch); err != nil {
+		return form, true, err
+	}
+	if form.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return form, true, fmt.Errorf("%w: packed integer compare has no bound address-size override", ErrProbeNeedsContext)
+	}
+	return form, true, nil
+}
+
+// The EVEX K-result rows of _yvpcmpeqb and _yvpcmpb have the same source,
+// width, mask and broadcast axes. Only the latter has a leading immediate.
+// This descriptor supplies operand roles, never initialized data or backing.
+func x86PackedMaskCompareProperties(ins Instr, arch string, first, laneBits int, dotted bool, suffix string) (x86PackedBinaryForm, bool) {
+	form := x86PackedBinaryForm{first: first, second: first + 1, destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	if len(ins.Args) != first+3 && len(ins.Args) != first+4 || dotted && suffix != "BCST" {
+		return form, false
+	}
+	if !amd64IsKOperand(ins.Args[form.destination]) {
+		return form, false
+	}
+	width, valid := amd64PackedCompareWidth(ins.Args[form.second])
+	if !valid || !amd64GoPackedVectorMoveRegister(ins.Args[form.second], width, "amd64") {
+		return form, false
+	}
+	form.byteWidth = width
+	source := ins.Args[first]
+	if source.Kind == OpReg {
+		if !amd64GoPackedVectorMoveRegister(source, width, "amd64") {
+			return form, false
+		}
+	} else if !x86PackedShiftMemoryValid(source, arch) {
+		return form, false
+	} else {
+		form.memory, form.memoryBytes = first, width
+	}
+	if dotted {
+		if laneBits < 32 || form.memory < 0 {
+			return form, false
+		}
+		form.broadcast, form.memoryBytes = true, laneBits/8
+	}
+	if len(ins.Args) == first+4 {
+		mask := first + 2
+		if !amd64NonzeroKOperand(ins.Args[mask]) || arch == "386" && !ins.x86Encoded && ins.x86SourceRaw == nil {
+			return form, false
+		}
+		form.mask = mask
+	}
+	return form, true
+}
+
+func x86TypedPackedIntegerCompareByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedIntegerCompareProperties(op, ins, arch)
+	immediateFamily := false
+	if !known {
+		immediate, recognized, immediateErr := x86ImmediatePackedCompareProperties(op, ins, arch)
+		form, known, err = immediate.x86PackedIntegerCompareForm, recognized, immediateErr
+		immediateFamily = recognized
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	firstWidth := form.byteWidth
+	if form.memory >= 0 {
+		firstWidth = form.memoryBytes
+	}
+	readInputs := !form.identicalVectorInputs(ins)
+	operands := []x86TypedByteOperand{
+		{index: form.first, operand: form.source, width: int64(firstWidth), read: readInputs},
+		{index: form.second, operand: ins.Args[form.second], width: int64(form.byteWidth), read: readInputs},
+	}
+	if form.mask >= 0 {
+		operands = append(operands, x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	width := form.byteWidth
+	if form.maskResult {
+		width = 8
+	}
+	operands = append(operands, x86TypedByteOperand{
+		index: form.destination, operand: ins.Args[form.destination], width: int64(width), write: true,
+	})
+	effect := x86TypedByteEffect{operands: operands, requiresResultProof: immediateFamily}
+	if !form.mmx && !form.maskResult {
+		effect.vector.upperWrite = x86TypedVectorUpperZero
+		effect.vector.memoryAlignment = 1
+		if form.spec.legacy {
+			effect.vector.upperWrite = x86TypedVectorUpperPreserve
+			effect.vector.memoryAlignment = 16
+		}
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_integer_compare_forms_test.go b/amd64_packed_integer_compare_forms_test.go
new file mode 100644
index 000000000..fb366d3b2
--- /dev/null
+++ b/amd64_packed_integer_compare_forms_test.go
@@ -0,0 +1,348 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedIntegerCompareCompleteActualGoRowsAndAttributes(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	read := func(name string) string {
+		data, err := os.ReadFile(filepath.Join(root, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return strings.Join(strings.Fields(string(data)), "")
+	}
+	legacy, vector := read("asm6.go"), read("avx_optabs.go")
+	for _, definition := range []string{
+		"var ymm = []ytab{ {Zm_r_xm, 1, argList{Ymm, Ymr}}, {Zm_r_xm, 2, argList{Yxm, Yxr}}, }",
+		"var yxm_q4 = []ytab{ {Zm_r, 1, argList{Yxm, Yxr}}, }",
+	} {
+		if !strings.Contains(legacy, strings.Join(strings.Fields(definition), "")) {
+			t.Fatal("actual selected SDK legacy operand rows changed", definition)
+		}
+	}
+	rows := []string{
+		"{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yxm,Yxr,Yxr}}",
+		"{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yym,Yyr,Yyr}}",
+		"{zcase:Zevex_rm_v_r,zoffset:0,args:argList{YxmEvex,YxrEvex,Yk}}",
+		"{zcase:Zevex_rm_v_k_r,zoffset:3,args:argList{YxmEvex,YxrEvex,Yknot0,Yk}}",
+		"{zcase:Zevex_rm_v_r,zoffset:0,args:argList{YymEvex,YyrEvex,Yk}}",
+		"{zcase:Zevex_rm_v_k_r,zoffset:3,args:argList{YymEvex,YyrEvex,Yknot0,Yk}}",
+		"{zcase:Zevex_rm_v_r,zoffset:0,args:argList{Yzm,Yzr,Yk}}",
+		"{zcase:Zevex_rm_v_k_r,zoffset:3,args:argList{Yzm,Yzr,Yknot0,Yk}}",
+	}
+	if !strings.Contains(vector, "var_yvpcmpeqb=[]ytab{"+strings.Join(rows, ",")+",}") {
+		t.Fatal("actual selected SDK ordered eight-row compare table changed")
+	}
+	opcodes := []int{0x74, 0x75, 0x76, 0x29, 0x64, 0x65, 0x66, 0x37}
+	bits := []int{8, 16, 32, 64, 8, 16, 32, 64}
+	for index, op := range x86PackedIntegerCompareTestNames[:8] {
+		table, prefix, code := "ymm", "Py1", fmt.Sprintf("0x%x,Pe,0x%x", opcodes[index], opcodes[index])
+		if bits[index] == 64 {
+			table, prefix, code = "yxm_q4", "Pq4", fmt.Sprintf("0x%x", opcodes[index])
+		}
+		if !strings.Contains(legacy, fmt.Sprintf("{A%s,%s,%s,opBytes{%s}}", op, table, prefix, code)) {
+			t.Fatal("actual selected SDK legacy opcode attributes changed", op)
+		}
+	}
+	for index, op := range x86PackedIntegerCompareTestNames[8:] {
+		mapName, evexW, broadcast := "0F", "W0", ""
+		if bits[index] == 64 {
+			mapName, evexW, broadcast = "0F38", "W1", "|evexBcstN8"
+		} else if bits[index] == 32 {
+			broadcast = "|evexBcstN4"
+		}
+		var attributes strings.Builder
+		for _, width := range []int{128, 256} {
+			fmt.Fprintf(&attributes, "avxEscape|vex%d|vex66|vex%s|vexW0,0x%X,", width, mapName, opcodes[index])
+		}
+		for _, width := range []int{128, 256, 512} {
+			fmt.Fprintf(&attributes, "avxEscape|evex%d|evex66|evex%s|evex%s,evexN%d%s,0x%X,", width, mapName, evexW, width/8, broadcast, opcodes[index])
+		}
+		if !strings.Contains(vector, "{as:A"+op+",ytab:_yvpcmpeqb,prefix:Pavx,op:opBytes{"+attributes.String()+"}},") {
+			t.Fatal("actual selected SDK complete five encoding attributes changed", op)
+		}
+	}
+	actual := map[string]int{}
+	for _, source := range []string{legacy, vector} {
+		for _, match := range regexp.MustCompile(`\{(?:as:)?A(V?PCMP(?:EQ|GT)[BWLQD]),`).FindAllStringSubmatch(source, -1) {
+			actual[match[1]]++
+		}
+	}
+	if len(actual) != 16 || len(x86PackedIntegerCompareSpecs) != 16 {
+		t.Fatal("complete Go named-family denominator changed", actual)
+	}
+	for index, op := range x86PackedIntegerCompareTestNames {
+		spec := x86PackedIntegerCompareSpecs[Op(op)]
+		if actual[op] != 1 || spec.laneBits != bits[index%8] || spec.greater != (index%8 >= 4) || spec.legacy != (index < 8) || spec.mmx != (index < 8 && bits[index%8] < 64) {
+			t.Fatal("Go registration and typed semantics differ", op, spec)
+		}
+	}
+}
+
+func TestX86PackedIntegerCompareLogicalFPSpanRequiresEveryByteEvenMaskZero(t *testing.T) {
+	for _, op := range x86PackedIntegerCompareTestNames[8:] {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+				if broadcast && bits < 32 {
+					continue
+				}
+				span, instruction := width, op
+				if broadcast {
+					span, instruction = bits/8, op+".BCST"
+				}
+				t.Run(fmt.Sprintf("%s/%d/bcst=%t", op, width, broadcast), func(t *testing.T) {
+					var parameters strings.Builder
+					for index := 0; index < span; index++ {
+						if index != 0 {
+							parameters.WriteByte(',')
+						}
+						fmt.Fprintf(&parameters, "a%d uint8", index)
+					}
+					pkg := mustGoPackage(t, "compare", "package compare\nfunc query("+parameters.String()+")\n")
+					bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+					source := fmt.Sprintf("TEXT ·query(SB),4,$0-%d\nMOVQ $0,AX\nKMOVQ AX,K1\n%s a0+0(FP),%s1,K1,K2\nRET\n", span, instruction, bank)
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+					ir, err := Translate(file, options)
+					x86VectorScratchCodegenControl(t, source, "func query("+parameters.String()+")", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					// Keep explicit initialization as a separate positive control;
+					// every logical FP byte remains independently required.
+					initialized := strings.Replace(source, "KMOVQ AX,K1\n", "KMOVQ AX,K1\nVPXORD Z1,Z1,Z1\n", 1)
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", initialized)
+					file, err = Parse(ArchAMD64, initialized)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := Translate(file, options); err != nil {
+						t.Fatal("complete logical FP fields", err)
+					}
+					for missing := 0; missing < span; missing++ {
+						t.Run(fmt.Sprint(missing), func(t *testing.T) {
+							sig := sigs["query"]
+							sig.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+							sig.Frame.Params = append(sig.Frame.Params[:missing], sig.Frame.Params[missing+1:]...)
+							mutated := options
+							mutated.Sigs = map[string]FuncSig{"query": sig}
+							if ir, err := Translate(file, mutated); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("mask0 borrowed absent logical FP byte%d: %v", missing, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedIntegerCompareMMXActualEncodedBankAndDefinedness(t *testing.T) {
+	for opIndex, op := range x86PackedIntegerCompareTestNames[:8] {
+		if opIndex%4 == 3 {
+			continue
+		}
+		opcode := []byte{0x74, 0x75, 0x76, 0x29, 0x64, 0x65, 0x66, 0x37}[opIndex]
+		for index, spelling := range []string{"M0", "M1", "M2", "M3", "M4", "M5", "M6", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			t.Run(op+"/"+spelling, func(t *testing.T) {
+				source := "TEXT probe(SB),4,$0-0\n" + op + " " + spelling + ",M7\nRET\n"
+				want := []byte{0x0f, opcode, 0xf8 | byte(index&7), 0xc3}
+				if index >= 16 {
+					want = append([]byte{0x41}, want...)
+				}
+				if got := x86PackedShiftActualGoBytes(t, "amd64", source); !bytes.Equal(got, want) {
+					t.Fatalf("actual Go GP spelling changed native MMX identity: %x != %x", got, want)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil || effect.operands[0].operand.Reg != Reg(fmt.Sprintf("M%d", index&7)) || effect.operands[0].width != 8 {
+					t.Fatal("pure query confused GP initialization with MMX", effect, err)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for i := range state.gp {
+					state.gp[i] = 0xff
+				}
+				if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("numeric GP bytes supplied unproved MMX state")
+				}
+			})
+		}
+	}
+	for _, op := range x86PackedIntegerCompareTestNames[:8] {
+		ins := Instr{Op: Op(op), Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}}
+		for input := 0; input < 2; input++ {
+			for missing := 0; missing < 16; missing++ {
+				t.Run(fmt.Sprintf("%s/input%d/byte%d", op, input, missing), func(t *testing.T) {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+					state.xmm[1-input] &^= uint16(1) << uint(missing)
+					if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatal("compare borrowed undefined input byte")
+					}
+				})
+			}
+		}
+	}
+}
+
+type x86PackedIntegerCompareCase struct {
+	op, operands               string
+	width, bits                int
+	legacy, mmx                bool
+	mask, memory               bool
+	broadcast                  bool
+	first, second, destination int
+}
+
+func x86PackedIntegerCompareCases(arch string) []x86PackedIntegerCompareCase {
+	var cases []x86PackedIntegerCompareCase
+	for index, op := range x86PackedIntegerCompareTestNames {
+		bits := []int{8, 16, 32, 64}[index%4]
+		if index < 8 {
+			for _, row := range []struct {
+				operands      string
+				first, second int
+				memory        bool
+			}{
+				{"X0,X1", 0, 1, false}, {"X1,X0", 1, 0, false}, {"X0,X0", 0, 0, false}, {"(BX),X1", 0, 1, true},
+			} {
+				cases = append(cases, x86PackedIntegerCompareCase{op: op, operands: row.operands, width: 16, bits: bits, legacy: true, memory: row.memory, first: row.first, second: row.second, destination: row.second})
+			}
+			if arch == "amd64" && bits < 64 {
+				for _, memory := range []bool{false, true} {
+					operand := "M0,M1"
+					if memory {
+						operand = "(BX),M1"
+					}
+					cases = append(cases, x86PackedIntegerCompareCase{op: op, operands: operand, width: 8, bits: bits, legacy: true, mmx: true, memory: memory, first: 0, second: 1, destination: 1})
+				}
+			}
+			continue
+		}
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			if width < 64 {
+				for _, alias := range [][3]int{{0, 1, 2}, {0, 1, 0}, {0, 1, 1}, {0, 0, 0}} {
+					cases = append(cases, x86PackedIntegerCompareCase{op: op, operands: fmt.Sprintf("%s%d,%s%d,%s%d", bank, alias[0], bank, alias[1], bank, alias[2]), width: width, bits: bits, first: alias[0], second: alias[1], destination: alias[2]})
+				}
+				cases = append(cases, x86PackedIntegerCompareCase{op: op, operands: fmt.Sprintf("(BX),%s1,%s2", bank, bank), width: width, bits: bits, memory: true, first: 0, second: 1, destination: 2})
+			}
+			for _, masked := range []bool{false, true} {
+				if arch == "386" && masked {
+					continue
+				}
+				for _, memory := range []bool{false, true} {
+					for _, alias := range [][3]int{{0, 1, 0}, {0, 1, 2}, {1, 0, 1}, {0, 0, 7}} {
+						first := fmt.Sprintf("%s%d", bank, alias[0])
+						if memory {
+							first = "(BX)"
+						}
+						mask := ""
+						if masked {
+							mask = "K2,"
+						}
+						cases = append(cases, x86PackedIntegerCompareCase{op: op, operands: fmt.Sprintf("%s,%s%d,%sK%d", first, bank, alias[1], mask, alias[2]), width: width, bits: bits, mask: masked, memory: memory, first: alias[0], second: alias[1], destination: alias[2]})
+					}
+					if memory && bits >= 32 {
+						mask := ""
+						if masked {
+							mask = "K2,"
+						}
+						cases = append(cases, x86PackedIntegerCompareCase{op: op + ".BCST", operands: fmt.Sprintf("(BX),%s1,%sK2", bank, mask), width: width, bits: bits, mask: masked, memory: true, broadcast: true, first: 0, second: 1, destination: 2})
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func TestX86PackedIntegerCompareThreeAPIsFiveTargetsO0O2Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			cases := x86PackedIntegerCompareCases(target.arch)
+			for index, row := range cases {
+				fmt.Fprintf(&source, "TEXT ·compare%d(SB),4,$0-0\n%s %s\nRET\n", index, row.op, row.operands)
+			}
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPackedIntegerCompare(ins.Op, ins)
+				})
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+			t.Logf("%d original Go forms, three-API Context, emitter-only IR/backend O0/O2 objects; initialized public inputs have their own owner", len(cases))
+		})
+	}
+}
+
+func TestX86PackedIntegerCompareDescriptorPermissionsAndMalformedForms(t *testing.T) {
+	for _, row := range x86PackedIntegerCompareCases("amd64") {
+		file, err := Parse(ArchAMD64, "TEXT query(SB),4,$0-0\n"+row.op+" "+row.operands+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, "amd64")
+		if !known || err != nil || form.byteWidth != row.width || form.spec.laneBits != row.bits || form.mmx != row.mmx || form.broadcast != row.broadcast || (form.mask >= 0) != row.mask || (form.memory >= 0) != row.memory {
+			t.Fatal("complete form lost an independent axis", row, form, err)
+		}
+		effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+		if !known || err != nil || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+			t.Fatal("pure descriptor lost unchanged flags", effect, err)
+		}
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0xffff, "Z1": 0xff}, masks: map[Reg]bool{"K2": true}}
+		before := state
+		before.vectors, before.masks = x86CloneCallerVectorState(state.vectors, state.masks)
+		if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &state, nil) || x86SourceStackInstructionKnown(ins, OpMOVQ, "Q", "amd64") || !reflect.DeepEqual(state, before) || ins.x86CallerMemory != nil {
+			t.Fatal("query descriptor invented caller input/permission", row)
+		}
+		for _, mutate := range []func(*Instr){
+			func(i *Instr) { i.Op += ".Z" },
+			func(i *Instr) { i.Args = append(i.Args, Operand{Kind: OpReg, Reg: "X0"}) },
+			func(i *Instr) { i.Args[len(i.Args)-1] = Operand{Kind: OpReg, Reg: "AX"} },
+			func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 3} },
+		} {
+			local := ins
+			local.Args = append([]Operand(nil), ins.Args...)
+			mutate(&local)
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			ctx.goarch = "amd64"
+			before, temporary := output.String(), ctx.tmp
+			known, _, err := ctx.lowerPackedIntegerCompare(local.Op, local)
+			if !known || err == nil || output.String() != before || ctx.tmp != temporary {
+				t.Fatal("malformed form emitted before rejection", row, local, err)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_integer_compare_go_oracle_test.go b/amd64_packed_integer_compare_go_oracle_test.go
new file mode 100644
index 000000000..54dd1babe
--- /dev/null
+++ b/amd64_packed_integer_compare_go_oracle_test.go
@@ -0,0 +1,288 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86PackedIntegerCompareRunOriginalGo(t *testing.T, declaration, assembly, testSource string) {
+	x86PackedIntegerCompareOriginalGoDriver(t, declaration, assembly, testSource, false)
+}
+
+func x86PackedIntegerCompareOriginalGoDriver(t *testing.T, declaration, assembly, testSource string, buildOnly bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declaration,
+		"value_amd64.s": assembly, "value_test.go": testSource,
+	} {
+		data := []byte(source)
+		if strings.HasSuffix(name, ".go") {
+			var err error
+			data, err = format.Source(data)
+			if err != nil {
+				t.Fatalf("first-party original fixture syntax: %v", err)
+			}
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	driver, _ := x86LEAActualSDKDriver(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	arguments := []string{"test", "-p=2", "-vet=off", "-count=1"}
+	executable := filepath.Join(dir, "original-compare.test")
+	if buildOnly {
+		arguments = append(arguments, "-c", "-o", executable)
+	}
+	arguments = append(arguments, ".")
+	command := exec.CommandContext(ctx, driver, arguments...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if buildOnly {
+		// These native Linux fixtures may contain Unix fault probes. Compile
+		// their actual target independently of the host; never execute them.
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go packed compare driver (build-only=%t): %v\n%s", buildOnly, err, output)
+	}
+	if buildOnly {
+		if amd64, err := x86OriginalGoLinkedAMD64(executable); err != nil || !amd64 {
+			t.Fatal("build-only driver lost its actual linked SDK/AMD64 executable", err)
+		}
+	}
+}
+
+func x86PackedIntegerCompareOriginalWideSources() (string, string, string) {
+	rows := x86PackedIntegerCompareCases("amd64")
+	declaration, assembly, _ := x86PackedIntegerCompareRuntimeFixture(rows)
+	var checks strings.Builder
+	for index, row := range rows {
+		maskResult := !row.legacy && strings.Contains(row.operands, "K")
+		fmt.Fprintf(&checks, "    checkWide(t,compare%d,%q,%d,%d,%t,%t,%t,%t,%t,%t,%t,%d,%d,%d)\n",
+			index, fmt.Sprintf("compare%d", index), row.width, row.bits/8, strings.Contains(row.op, "GT"), row.legacy, row.mmx,
+			maskResult, row.mask, row.memory, row.broadcast, row.first, row.second, row.destination)
+	}
+	tests := `package oracle
+
+import (
+    "encoding/binary"
+    "testing"
+    "unsafe"
+)
+
+func wideLane(p []byte, bytes int) uint64 {
+    var result uint64
+    for j := 0; j < bytes; j++ { result |= uint64(p[j]) << uint(8*j) }
+    return result
+}
+
+func checkWide(t *testing.T,fn func(*byte,*byte,*byte,uint64,uint32,uint64),name string,
+               width,bytes int,greater,legacy,mmx,maskResult,masked,memory,broadcast bool,
+               firstBank,secondBank,destination int) {
+    t.Helper()
+    masks := [4]uint64{0,1,0x55aa55aa55aa55aa,^uint64(0)}
+    for round := 0; round < 12; round++ {
+        for _,mask := range masks {
+            var aStorage,bStorage [96]byte
+            aOffset := int((16-uintptr(unsafe.Pointer(&aStorage[0]))%16)%16)
+            bOffset := int((16-uintptr(unsafe.Pointer(&bStorage[0]))%16)%16)
+            for i := range aStorage { aStorage[i],bStorage[i] = 0xa7,0xb9 }
+            a,b := aStorage[aOffset:aOffset+64],bStorage[bOffset:bOffset+64]
+            for i := range a { a[i],b[i] = byte(i*17+round*31),byte(i*23+round*53) }
+            if round < 4 {
+                patterns := [4][2]byte{{0xff,1},{0x80,0x7f},{1,0},{0,0xff}}
+                for i := range a { a[i],b[i] = patterns[round][0],patterns[round][1] }
+            }
+            originalA,originalB := aStorage,bStorage
+            var out [424]byte
+            for i := range out { out[i] = 0xc3 }
+            csr := uint32(0x1f80 | (round%4)<<13 | round)
+            expectedFlags := uint64(0x895)
+            if mask&3 == 0 { expectedFlags = 0 }
+            if mask&3 == 1 { expectedFlags = 0x55 }
+            fn(&out[1],&a[0],&b[0],mask,csr,2|expectedFlags)
+            if binary.LittleEndian.Uint64(out[409:417])&0x8d5 != expectedFlags || out[417] != byte(2|(expectedFlags&0xd5)) ||
+               binary.LittleEndian.Uint32(out[418:422]) != csr || out[0] != 0xc3 ||
+               out[422] != 0xc3 || out[423] != 0xc3 || originalA != aStorage || originalB != bStorage {
+                t.Fatalf("%s flags/CSR/full input/output canaries: %x",name,out)
+            }
+            var expected [3][64]byte
+            copy(expected[0][:],a)
+            copy(expected[1][:],b)
+            copy(expected[2][:],b)
+            first,second := a,b
+            if !memory && firstBank != 0 { first = b }
+            if secondBank == 0 { second = a }
+            var result [64]byte
+            var resultMask uint64
+            for i := 0; i < width; i += bytes {
+                offset := i
+                if broadcast { offset = 0 }
+                left,right := wideLane(first[offset:],bytes),wideLane(second[i:],bytes)
+                selected := left == right
+                if greater {
+                    sign := uint64(1) << uint(bytes*8-1)
+                    selected = (right^sign) > (left^sign)
+                }
+                if selected {
+                    for j := 0; j < bytes; j++ { result[i+j] = 0xff }
+                    if !masked || (mask>>uint(i/bytes))&1 != 0 { resultMask |= uint64(1)<<uint(i/bytes) }
+                }
+            }
+            if !maskResult && !mmx {
+                copy(expected[destination][:width],result[:width])
+                if !legacy { for i := width; i < 64; i++ { expected[destination][i] = 0 } }
+            }
+            for bank := 0; bank < 3; bank++ {
+                for view := 0; view < 3; view++ {
+                    offset,length := bank*112,16
+                    if view == 1 { offset,length = offset+16,32 }
+                    if view == 2 { offset,length = offset+48,64 }
+                    for i := 0; i < length; i++ {
+                        if out[1+offset+i] != expected[bank][i] {
+                            t.Fatalf("%s round%d mask%x bank%d view%d byte%d",name,round,mask,bank,view,i)
+                        }
+                    }
+                }
+            }
+            for k := 0; k < 8; k++ {
+                want := mask
+                if maskResult && k == destination { want = resultMask }
+                if binary.LittleEndian.Uint64(out[337+k*8:345+k*8]) != want { t.Fatalf("%s K%d",name,k) }
+            }
+            for i := 0; i < 8; i++ {
+                want := byte(0)
+                if mmx { want = result[i] }
+                if out[401+i] != want { t.Fatalf("%s MMX result",name) }
+            }
+        }
+    }
+}
+
+func TestOriginalWideCompare(t *testing.T) {
+` + checks.String() + "}\n"
+	return "package oracle\n" + declaration, assembly, tests
+}
+
+func TestX86PackedIntegerCompareOriginalWideNativeDriverBuildOnly(t *testing.T) {
+	declaration, assembly, tests := x86PackedIntegerCompareOriginalWideSources()
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", assembly)
+	x86PackedIntegerCompareOriginalGoDriver(t, declaration, assembly, tests, true)
+	t.Log("original wide Go driver was actually linked but not executed; required Linux native ISA counterpart remains independent")
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedIntegerCompareOriginalGoSSEAndMMXBits(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, row := range x86PackedIntegerCompareCases("amd64") {
+		if !row.legacy {
+			continue
+		}
+		name := fmt.Sprintf("original%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(a,b *byte,out *[32]byte,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\nMOVQ a+0(FP),BX\nMOVQ b+8(FP),CX\nMOVQ out+16(FP),DI\n", name)
+		if row.mmx {
+			assembly.WriteString("MOVQ (BX),M0\nMOVQ (CX),M1\n")
+		} else {
+			assembly.WriteString("MOVOU (BX),X0\nMOVOU (CX),X1\n")
+		}
+		assembly.WriteString("MOVL $0x7fffffff,SI\nADDL $1,SI\nSTC\n")
+		fmt.Fprintf(&assembly, "%s %s\n", row.op, row.operands)
+		if row.mmx {
+			assembly.WriteString("MOVQ M1,0(DI)\nEMMS\n")
+		} else {
+			fmt.Fprintf(&assembly, "MOVOU X%d,0(DI)\n", row.destination)
+		}
+		assembly.WriteString("PUSHFQ\nPOPQ DX\nMOVQ DX,16(DI)\nLAHF\nMOVB AH,24(DI)\nSTMXCSR 25(DI)\nLDMXCSR saved-4(SP)\nRET\n")
+		fmt.Fprintf(&checks, "\n    check(t,%s,%q,%d,%d,%t,%d,%d,%t)\n", name, name, row.width, row.bits/8, strings.Contains(row.op, "GT"), row.first, row.second, row.memory)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", testTargetTriple("linux", "amd64"), assembly.String())
+	tests := `package oracle
+
+import (
+    "encoding/binary"
+    "testing"
+    "unsafe"
+)
+
+func value(p []byte, bytes int) uint64 {
+    var result uint64
+    for j := 0; j < bytes; j++ {
+        result |= uint64(p[j]) << uint(8*j)
+    }
+    return result
+}
+
+func check(t *testing.T, fn func(*byte,*byte,*[32]byte,uint32), name string,
+           width, bytes int, greater bool, firstBank, secondBank int, memory bool) {
+    t.Helper()
+    for round := 0; round < 12; round++ {
+        var aStorage, bStorage [96]byte
+        aOffset := int((16-uintptr(unsafe.Pointer(&aStorage[0]))%16)%16)
+        bOffset := int((16-uintptr(unsafe.Pointer(&bStorage[0]))%16)%16)
+        for i := range aStorage {
+            aStorage[i] = 0xa7
+            bStorage[i] = 0xb9
+        }
+        a, b := aStorage[aOffset:aOffset+64], bStorage[bOffset:bOffset+64]
+        for i := range a {
+            a[i] = byte(i*17+round*31)
+            b[i] = byte(i*23+round*53)
+        }
+        if round < 4 {
+            patterns := [4][2]byte{{0xff,1},{0x80,0x7f},{1,0},{0,0xff}}
+            for i := range a {
+                a[i],b[i] = patterns[round][0],patterns[round][1]
+            }
+        }
+        originalA, originalB := aStorage, bStorage
+        var out [32]byte
+        for i := range out { out[i] = 0xc3 }
+        csr := uint32(0x1f80 | (round%4)<<13 | round)
+        fn(&a[0],&b[0],&out,csr)
+        if binary.LittleEndian.Uint64(out[16:24])&0x8d5 != 0x895 ||
+           out[24] != 0x97 || binary.LittleEndian.Uint32(out[25:29]) != csr ||
+           out[29] != 0xc3 || out[30] != 0xc3 || out[31] != 0xc3 ||
+           originalA != aStorage || originalB != bStorage {
+            t.Fatalf("%s flags/CSR/whole-input/canary mismatch: %x",name,out)
+        }
+        first,second := a,b
+        if !memory && firstBank != 0 { first = b }
+        if secondBank == 0 { second = a }
+        for i := 0; i < width; i += bytes {
+            left,right := value(first[i:],bytes),value(second[i:],bytes)
+            selected := left == right
+            if greater {
+                sign := uint64(1) << uint(bytes*8-1)
+                selected = (right^sign) > (left^sign)
+            }
+            want := byte(0)
+            if selected { want = 0xff }
+            for j := 0; j < bytes; j++ {
+                if out[i+j] != want {
+                    t.Fatalf("%s round%d byte%d got%x want%x",name,round,i+j,out[i+j],want)
+                }
+            }
+        }
+        for i := width; i < 16; i++ {
+            if out[i] != 0xc3 { t.Fatalf("%s narrow write changed canary",name) }
+        }
+    }
+}
+
+func TestOriginalCompare(t *testing.T) {
+` + checks.String() + "}\n"
+	x86PackedIntegerCompareRunOriginalGo(t, declarations.String(), assembly.String(), tests)
+	t.Logf("%d actual original Go SSE/MMX kernels ×12 initialized numerical/6flag/LAHF/MXCSR/full-buffer cases; MMX bit results do not certify x87 native state", count)
+}
diff --git a/amd64_packed_integer_compare_linux_amd64_test.go b/amd64_packed_integer_compare_linux_amd64_test.go
new file mode 100644
index 000000000..f421afe62
--- /dev/null
+++ b/amd64_packed_integer_compare_linux_amd64_test.go
@@ -0,0 +1,43 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedIntegerCompareOriginalNativeWideBits(t *testing.T) {
+	// No emulator, Rosetta, host-inapplicable Skip, or object-only substitute.
+	// The shared preflight binds native AMD64 and enabled AVX512F/VL state.
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "compare-isa.c"), filepath.Join(dir, "compare-isa")
+	const program = `#include <cpuid.h>
+#include <stdio.h>
+#include <sys/resource.h>
+
+int main(void) {
+    struct rlimit noCore = {0,0};
+    if (setrlimit(RLIMIT_CORE,&noCore)) return 77;
+    unsigned a,b,c,d;
+    if (!__get_cpuid_count(7,0,&a,&b,&c,&d)) return 78;
+    printf("AVX2=%u AVX512BW=%u\n",(b>>5)&1,(b>>30)&1);
+    return (b&(1u<<5)) && (b&(1u<<30)) ? 0 : 79;
+}
+`
+	if err := os.WriteFile(input, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	compile := append([]string(nil), execution.compiler...)
+	compile = append(compile, "-O2", input, "-o", output)
+	x86FloatCompareCaptureCommand(t, exec.Command(compile[0], compile[1:]...))
+	run := execution.command(output)
+	t.Logf("native packed integer ISA supplement: %s", x86FloatCompareCaptureCommand(t, exec.Command(run[0], run[1:]...)))
+	declaration, assembly, tests := x86PackedIntegerCompareOriginalWideSources()
+	x86LEAActualTargetGoObject(t, "amd64", execution.triple, assembly)
+	x86PackedIntegerCompareRunOriginalGo(t, declaration, assembly, tests)
+	t.Log("532 native original Go forms ×48 independent scalar lane/full-bank/K/flags/CSR/full-buffer observations; execution requires native Linux AMD64 AVX2+AVX512F/VL/BW")
+}
diff --git a/amd64_packed_integer_compare_runtime_test.go b/amd64_packed_integer_compare_runtime_test.go
new file mode 100644
index 000000000..e610c0060
--- /dev/null
+++ b/amd64_packed_integer_compare_runtime_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Every input is initialized by this first-party fixture. Its declared pointer
+// transport is not a caller-region or native-frame permission certificate.
+func x86PackedIntegerCompareRuntimeFixture(rows []x86PackedIntegerCompareCase) (string, string, string) {
+	var declarations, source, prototypes strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("compare%d", index)
+		fmt.Fprintf(&declarations, "func %s(out,a,b *byte, mask uint64, csr uint32, flags uint64)\n", name)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t,uint64_t);\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-48\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nLDMXCSR csr+32(FP)\n", name)
+		source.WriteString("VMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\n")
+		for mask := 0; mask < 8; mask++ {
+			fmt.Fprintf(&source, "KMOVQ DX,K%d\n", mask)
+		}
+		// Seed the independently selected status before the physical MMX
+		// region. No CFG or unrelated effect can split that region's state.
+		source.WriteString("PUSHQ flags+40(FP)\nPOPFQ\n")
+		if row.mmx {
+			source.WriteString("MOVQ (BX),M0\nMOVQ (CX),M1\n")
+		}
+		fmt.Fprintf(&source, "%s %s\n", row.op, row.operands)
+		if row.mmx {
+			source.WriteString("MOVQ M1,400(DI)\nEMMS\n")
+		} else {
+			source.WriteString("MOVQ $0,400(DI)\n")
+		}
+		for bank := 0; bank < 3; bank++ {
+			fmt.Fprintf(&source, "MOVOU X%d,%d(DI)\nVMOVUPS Y%d,%d(DI)\nVMOVUPS Z%d,%d(DI)\n", bank, bank*112, bank, bank*112+16, bank, bank*112+48)
+		}
+		for mask := 0; mask < 8; mask++ {
+			fmt.Fprintf(&source, "KMOVQ K%d,%d(DI)\n", mask, 336+mask*8)
+		}
+		// Observe LAHF before masking the popped word: AND changes FLAGS.
+		// The whole RFLAGS word includes undefined/unmodeled control bits;
+		// only the six independently seeded status bits are numerical here.
+		source.WriteString("LAHF\nMOVB AH,416(DI)\nPUSHFQ\nPOPQ DX\n" +
+			"ANDQ $0x8d5,DX\nMOVQ DX,408(DI)\nSTMXCSR 417(DI)\nRET\n")
+	}
+	return declarations.String(), source.String(), prototypes.String()
+}
+
+const x86PackedIntegerCompareScalarOracle = `
+static uint64_t compareLane(const uint8_t *p, int bytes) {
+    uint64_t value = 0;
+    for (int j = 0; j < bytes; ++j) {
+        value |= (uint64_t)p[j] << (8*j);
+    }
+    return value;
+}
+
+static int compareValue(uint64_t first, uint64_t second, int bytes, int greater) {
+    if (!greater) {
+        return first == second;
+    }
+    uint64_t sign = UINT64_C(1) << (bytes*8-1);
+    return (second ^ sign) > (first ^ sign);
+}
+
+__attribute__((noinline)) static int checkCompare(
+    void (*fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint32_t,uint64_t),
+    const char *name, int width, int bytes, int greater, int legacy, int mmx,
+    int maskResult, int masked, int memory, int broadcast,
+    int firstBank, int secondBank, int destination) {
+    const uint64_t masks[] = {0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+    for (int round = 0; round < 12; ++round) {
+        for (int m = 0; m < 4; ++m) {
+            _Alignas(64) uint8_t aStorage[96], bStorage[96], output[424];
+            uint8_t *a = aStorage+16;
+            uint8_t *b = bStorage+16;
+            memset(aStorage,0xa7,sizeof(aStorage));
+            memset(bStorage,0xb9,sizeof(bStorage));
+            memset(output,0xc3,sizeof(output));
+            for (int i = 0; i < 64; ++i) {
+                a[i] = (uint8_t)(i*17+round*31);
+                b[i] = (uint8_t)(i*23+round*53);
+            }
+            if (round < 4) {
+                memset(a,round == 0 ? 0xff : round == 1 ? 0x80 : round == 2 ? 1 : 0,64);
+                memset(b,round == 0 ? 1 : round == 1 ? 0x7f : round == 2 ? 0 : 0xff,64);
+            }
+            uint8_t originalA[96], originalB[96];
+            memcpy(originalA,aStorage,96);
+            memcpy(originalB,bStorage,96);
+            uint64_t mask = masks[m];
+            uint32_t saved, csr = 0x1f80 | ((round%4)<<13) | round, after;
+            __asm__ volatile("stmxcsr %0" : "=m"(saved));
+            __asm__ volatile("ldmxcsr %0" : : "m"(csr));
+            uint64_t expectedFlags = (mask&3) == 0 ? 0 : (mask&3) == 1 ? 0x55 : 0x895;
+            fn(output+1,a,b,mask,csr,2|expectedFlags);
+            __asm__ volatile("stmxcsr %0" : "=m"(after));
+            __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+            if (after != csr || compareLane(output+418,4) != csr ||
+                compareLane(output+409,8) != expectedFlags || output[417] != (2|(expectedFlags&0xd5)) ||
+                output[0] != 0xc3 || output[422] != 0xc3 || output[423] != 0xc3 ||
+                memcmp(originalA,aStorage,96) || memcmp(originalB,bStorage,96)) {
+                fprintf(stderr,"%s CSR/flags/full-input/output canary mismatch\n",name);
+                return 1;
+            }
+            uint8_t expected[3][64];
+            memcpy(expected[0],a,64);
+            memcpy(expected[1],b,64);
+            memcpy(expected[2],b,64);
+            const uint8_t *first = memory || firstBank == 0 ? a : b;
+            const uint8_t *second = secondBank == 0 ? a : b;
+            uint64_t resultMask = 0;
+            uint8_t result[64] = {0};
+            for (int i = 0; i < width; i += bytes) {
+                int selected = compareValue(compareLane(first+(broadcast ? 0 : i),bytes),
+                                            compareLane(second+i,bytes),bytes,greater);
+                if (selected && (!masked || ((mask>>(i/bytes))&1))) {
+                    resultMask |= UINT64_C(1) << (i/bytes);
+                }
+                memset(result+i,selected ? 0xff : 0,bytes);
+            }
+            if (!maskResult && !mmx) {
+                memcpy(expected[destination],result,width);
+                if (!legacy) {
+                    memset(expected[destination]+width,0,64-width);
+                }
+            }
+            for (int bank = 0; bank < 3; ++bank) {
+                for (int view = 0; view < 3; ++view) {
+                    int offset = bank*112+(view == 0 ? 0 : view == 1 ? 16 : 48);
+                    int length = view == 0 ? 16 : view == 1 ? 32 : 64;
+                    if (memcmp(output+1+offset,expected[bank],length)) {
+                        fprintf(stderr,"%s round%d mask%llx bank%d view%d mismatch\n",
+                                name,round,(unsigned long long)mask,bank,view);
+                        return 1;
+                    }
+                }
+            }
+            for (int k = 0; k < 8; ++k) {
+                uint64_t want = maskResult && k == destination ? resultMask : mask;
+                if (compareLane(output+337+k*8,8) != want) {
+                    fprintf(stderr,"%s K%d mismatch\n",name,k);
+                    return 1;
+                }
+            }
+            for (int i = 0; i < 8; ++i) {
+                if (output[401+i] != (mmx ? result[i] : 0)) {
+                    fprintf(stderr,"%s MMX bit-result mismatch\n",name);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+
+func TestX86PackedIntegerCompareStatusObserverThreeTargetObjects(t *testing.T) {
+	rows := []x86PackedIntegerCompareCase{{
+		op: "PCMPEQB", operands: "X0,X1", width: 16, bits: 8, legacy: true,
+	}}
+	for index, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPGTB", "PCMPGTW", "PCMPGTL"} {
+		for _, operands := range []string{"M0,M1", "M1,M1", "(BX),M1"} {
+			rows = append(rows, x86PackedIntegerCompareCase{
+				op: op, operands: operands, width: 8, bits: 8 << uint(index%3), legacy: true, mmx: true,
+			})
+		}
+	}
+	declarations, source, _ := x86PackedIntegerCompareRuntimeFixture(rows)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("defined-status observer lost complete source effects", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					x86PackedStringCompileObject(t, llc, triple, text, "-O0")
+					x86PackedStringCompileObject(t, llc, triple, text, "-O2")
+				}
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedIntegerCompareCompleteScalarSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	rows := x86PackedIntegerCompareCases("amd64")
+	declarations, source, prototypes := x86PackedIntegerCompareRuntimeFixture(rows)
+	x86LEAActualTargetGoObject(t, "amd64", triple, source)
+	ir, err := x86PackedIntegerCompareAPI(t, source, declarations, "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var checks strings.Builder
+	for index, row := range rows {
+		maskResult := !row.legacy && strings.Contains(row.operands, "K")
+		fmt.Fprintf(&checks, "    if (checkCompare(compare%d,\"compare%d\",%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)) return 1;\n",
+			index, index, row.width, row.bits/8, x86FloatAddSubBoolInt(strings.Contains(row.op, "GT")),
+			x86FloatAddSubBoolInt(row.legacy), x86FloatAddSubBoolInt(row.mmx), x86FloatAddSubBoolInt(maskResult),
+			x86FloatAddSubBoolInt(row.mask), x86FloatAddSubBoolInt(row.memory), x86FloatAddSubBoolInt(row.broadcast),
+			row.first, row.second, row.destination)
+	}
+	program := "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n" +
+		"#if !defined(_WIN32)\n#include <sys/resource.h>\n#endif\n" +
+		prototypes + x86PackedIntegerCompareScalarOracle + "\nint main(void) {\n" +
+		"#if !defined(_WIN32)\n    struct rlimit noCore = {0,0};\n    if (setrlimit(RLIMIT_CORE,&noCore)) return 3;\n#endif\n" +
+		checks.String() + "    return 0;\n}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-integer-compare", triple, text, program, prefix)
+		})
+	}
+	t.Logf("%d forms ×48 independent signed/equal/mask/full-bank/full flags/CSR/input+output canaries at O0/O2; portable VEX/EVEX, not native AVX512", len(rows))
+}
diff --git a/amd64_packed_integer_compare_typed_test.go b/amd64_packed_integer_compare_typed_test.go
new file mode 100644
index 000000000..c9bdac0bc
--- /dev/null
+++ b/amd64_packed_integer_compare_typed_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86PackedIntegerCompareTestNames = []string{
+	"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ",
+	"PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ",
+	"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ",
+	"VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ",
+}
+
+func x86PackedIntegerCompareAPI(t *testing.T, source, declaration, arch, triple, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "compare", "package compare\n"+declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		module, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: arch, TargetTriple: triple, ResolveSym: resolve,
+		})
+		if module != nil && !module.Module.IsNil() {
+			defer module.Module.Dispose()
+			return module.Module.String(), err
+		}
+		return "", err
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: signatures}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api != "module" {
+		t.Fatal("unknown packed comparison consumer", api)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func TestX86PackedIntegerCompareMode32HighBankActualSourceNeedsContext(t *testing.T) {
+	for _, op := range x86PackedIntegerCompareTestNames[8:] {
+		for _, operands := range []string{
+			"X8,X1,X2", "X1,X8,X2", "X1,X2,X15",
+			"Y15,Y1,Y2", "Y1,Y15,Y2", "Y1,Y2,Y8",
+			"X20,X1,K2", "X1,X20,K2", "Y20,Y1,K2", "Y1,Y20,K2",
+		} {
+			for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				t.Run(op+"/"+operands+"/"+triple, func(t *testing.T) {
+					source := "TEXT ·query(SB),4,$0-0\n" + op + " " + operands + "\nRET\n"
+					x86LEAActualTargetGoObject(t, "386", triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86PackedIntegerCompareAPI(t, source, "func query()\n", "386", triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("actual Go acceptance fabricated a physical high bank: IR=%d err=%v", len(ir), err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedIntegerCompareDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, op := range x86PackedIntegerCompareTestNames {
+		operands := []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}}
+		if strings.HasPrefix(op, "V") {
+			operands = append(operands, Operand{Kind: OpReg, Reg: "X2"})
+		}
+		for _, identity := range []Op{"", Op(op), Op(strings.ToLower(op)), "MOVOU", "UNKNOWN"} {
+			t.Run(op+"/"+string(identity), func(t *testing.T) {
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = "amd64"
+				ins := Instr{Op: identity, Args: operands}
+				before, temporary := output.String(), ctx.tmp
+				original := fmt.Sprintf("%#v", ins)
+				known, terminated, err := ctx.lowerPackedIntegerCompare(Op(op), ins)
+				invalid := identity != "" && !strings.EqualFold(string(identity), op)
+				if !known || terminated || (err != nil) != invalid ||
+					invalid && (before != output.String() || temporary != ctx.tmp) || original != fmt.Sprintf("%#v", ins) {
+					t.Fatalf("dispatch identity changed source or emitted before rejection: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedIntegerCompareLegacyNativeOpcodeAndVirtualBoundaries(t *testing.T) {
+	for _, op := range x86PackedIntegerCompareTestNames[:8] {
+		for _, target := range x86RawReturnTargets {
+			t.Run(op+"/"+target.triple, func(t *testing.T) {
+				source := "TEXT ·query(SB),4,$0-0\n" + op + " (AX),X1\nRET\n"
+				x86UnboundVoidFormatSource(t, source, "query", target.arch, target.triple)
+				word, move := int(goWordSize(target.arch)), "MOVQ"
+				if word == 4 {
+					move = "MOVL"
+				}
+				// Keep the exact original m128 instruction. Only its actual
+				// pointer and destructive X input are established here; the
+				// complete native-object owner covers the family separately.
+				initialized := fmt.Sprintf("TEXT ·query(SB),4,$0-%d\n%s p+0(FP),AX\nPXOR X1,X1\n%s (AX),X1\nRET\n", word, move, op)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, initialized)
+				mnemonic := strings.ToLower(strings.ReplaceAll(op, "L", "D"))
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86PackedIntegerCompareAPI(t, initialized, "func query(p *[16]byte)\n", target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized original legacy source rejected", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if !strings.Contains(text, "asm sideeffect \""+mnemonic+" ($2), $0\"") {
+							t.Fatal("legacy m128 erased original opcode/fault semantics", api)
+						}
+					}
+				}
+			})
+		}
+		for _, operand := range []string{"a+0(FP)", "16(SP)", "16(BP)"} {
+			t.Run(op+"/virtual/"+operand, func(t *testing.T) {
+				source := "TEXT ·query(SB),4,$64-16\n" + op + " " + operand + ",X1\nRET\n"
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				ir, err := x86PackedIntegerCompareAPI(t, source, "func query(a,b uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("virtual fields acquired native legacy m128 alignment: IR=%d err=%v", len(ir), err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_logical_forms.go b/amd64_packed_logical_forms.go
new file mode 100644
index 000000000..db8b6847f
--- /dev/null
+++ b/amd64_packed_logical_forms.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedLogicalEncoding uint8
+
+const (
+	x86PackedLogicalLegacyFP x86PackedLogicalEncoding = iota
+	x86PackedLogicalLegacyInteger
+	x86PackedLogicalVEX
+	x86PackedLogicalVEXOrEVEX
+	x86PackedLogicalEVEX
+)
+
+type x86PackedLogicalSpec struct {
+	laneBits int
+	mode     amd64PackedLogicalMode
+	encoding x86PackedLogicalEncoding
+	// These are opcode attributes, not inferred from a shared ytab. Go's
+	// avx_optabs supplies N4 for PS/D and N8 for PD/Q, and zeroing for each
+	// EVEX row. VEX-only integer and legacy forms have neither attribute.
+	broadcastBytes int
+	zeroing        bool
+}
+
+var x86PackedLogicalSpecs = map[Op]x86PackedLogicalSpec{
+	"ANDPS":   {32, amd64PackedLogicalAnd, x86PackedLogicalLegacyFP, 0, false},
+	"ANDPD":   {64, amd64PackedLogicalAnd, x86PackedLogicalLegacyFP, 0, false},
+	"ANDNPS":  {32, amd64PackedLogicalAndNot, x86PackedLogicalLegacyFP, 0, false},
+	"ANDNPD":  {64, amd64PackedLogicalAndNot, x86PackedLogicalLegacyFP, 0, false},
+	"ORPS":    {32, amd64PackedLogicalOr, x86PackedLogicalLegacyFP, 0, false},
+	"ORPD":    {64, amd64PackedLogicalOr, x86PackedLogicalLegacyFP, 0, false},
+	"XORPS":   {32, amd64PackedLogicalXor, x86PackedLogicalLegacyFP, 0, false},
+	"XORPD":   {64, amd64PackedLogicalXor, x86PackedLogicalLegacyFP, 0, false},
+	"PAND":    {8, amd64PackedLogicalAnd, x86PackedLogicalLegacyInteger, 0, false},
+	"PANDN":   {8, amd64PackedLogicalAndNot, x86PackedLogicalLegacyInteger, 0, false},
+	"POR":     {8, amd64PackedLogicalOr, x86PackedLogicalLegacyInteger, 0, false},
+	"PXOR":    {8, amd64PackedLogicalXor, x86PackedLogicalLegacyInteger, 0, false},
+	"VANDPS":  {32, amd64PackedLogicalAnd, x86PackedLogicalVEXOrEVEX, 4, true},
+	"VANDPD":  {64, amd64PackedLogicalAnd, x86PackedLogicalVEXOrEVEX, 8, true},
+	"VANDNPS": {32, amd64PackedLogicalAndNot, x86PackedLogicalVEXOrEVEX, 4, true},
+	"VANDNPD": {64, amd64PackedLogicalAndNot, x86PackedLogicalVEXOrEVEX, 8, true},
+	"VORPS":   {32, amd64PackedLogicalOr, x86PackedLogicalVEXOrEVEX, 4, true},
+	"VORPD":   {64, amd64PackedLogicalOr, x86PackedLogicalVEXOrEVEX, 8, true},
+	"VXORPS":  {32, amd64PackedLogicalXor, x86PackedLogicalVEXOrEVEX, 4, true},
+	"VXORPD":  {64, amd64PackedLogicalXor, x86PackedLogicalVEXOrEVEX, 8, true},
+	"VPAND":   {8, amd64PackedLogicalAnd, x86PackedLogicalVEX, 0, false},
+	"VPANDN":  {8, amd64PackedLogicalAndNot, x86PackedLogicalVEX, 0, false},
+	"VPOR":    {8, amd64PackedLogicalOr, x86PackedLogicalVEX, 0, false},
+	"VPXOR":   {8, amd64PackedLogicalXor, x86PackedLogicalVEX, 0, false},
+	"VPANDD":  {32, amd64PackedLogicalAnd, x86PackedLogicalEVEX, 4, true},
+	"VPANDQ":  {64, amd64PackedLogicalAnd, x86PackedLogicalEVEX, 8, true},
+	"VPANDND": {32, amd64PackedLogicalAndNot, x86PackedLogicalEVEX, 4, true},
+	"VPANDNQ": {64, amd64PackedLogicalAndNot, x86PackedLogicalEVEX, 8, true},
+	"VPORD":   {32, amd64PackedLogicalOr, x86PackedLogicalEVEX, 4, true},
+	"VPORQ":   {64, amd64PackedLogicalOr, x86PackedLogicalEVEX, 8, true},
+	"VPXORD":  {32, amd64PackedLogicalXor, x86PackedLogicalEVEX, 4, true},
+	"VPXORQ":  {64, amd64PackedLogicalXor, x86PackedLogicalEVEX, 8, true},
+}
+
+type x86PackedLogicalForm struct {
+	x86PackedBinaryForm
+	spec   x86PackedLogicalSpec
+	source Operand
+}
+
+// The first input is known; these bits still depend on the second input.
+// ANDNOT is first & ^second in Go operand order, so it has AND's dependency.
+// This numerical projection neither removes the first read nor grants storage.
+func x86PackedLogicalSecondBits(mode amd64PackedLogicalMode, first byte) byte {
+	switch mode {
+	case amd64PackedLogicalAnd, amd64PackedLogicalAndNot:
+		return first
+	case amd64PackedLogicalOr:
+		return ^first
+	default:
+		return 255 // XOR cannot remove an unknown input bit.
+	}
+}
+
+// This is a pure numerical-byte dependency, shared by independent consumers.
+// A validated form and initialized mask are prerequisites; the result grants
+// no memory, frame, source-selection or caller permission. Higher physical
+// bytes are updated separately according to the consumer's encoding model.
+func x86PackedLogicalDefinedBytes(ins Instr, form x86PackedLogicalForm, first, second, old uint64) uint64 {
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	known := first & second & width
+	if form.memory < 0 && ins.Args[form.first].Reg == ins.Args[form.second].Reg &&
+		(form.spec.mode == amd64PackedLogicalXor || form.spec.mode == amd64PackedLogicalAndNot) {
+		known = width
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known &= old // A defined mask is not necessarily all ones.
+	}
+	return known
+}
+
+// Reuse the complete logical grammar and its numerical zero identity. A
+// legacy XMM operation preserves upper aliases and requires aligned m128;
+// neither the descriptor nor a same-register zero grants memory authority.
+func x86TypedLegacyLogicalByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86PackedLogicalProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("packed logical dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	if !known || err != nil || !form.legacy || form.mmx {
+		return x86TypedByteEffect{}, known && (err != nil || form.legacy && !form.mmx), err
+	}
+	effect := x86PackedBinaryDependencyEffect(ins, form.x86PackedBinaryForm, form.source)
+	return x86PackedLogicalZeroDependencies(ins, form, effect), true, nil
+}
+
+// Apply the shared numerical identity only after the consumer has validated
+// its encoding and storage roles. A memory operand never becomes a zero idiom.
+func x86PackedLogicalZeroDependencies(ins Instr, form x86PackedLogicalForm, effect x86TypedByteEffect) x86TypedByteEffect {
+	if x86PackedLogicalDefinedBytes(ins, form, 0, 0, 0) != 0 {
+		for index := range effect.operands {
+			effect.operands[index].read = false
+		}
+	}
+	return effect
+}
+
+// These fields describe only an operand grammar. Arithmetic, interleave and
+// bitwise effects remain in their own typed operation specs and consumers.
+type x86PackedBinarySpec struct {
+	encoding       x86PackedLogicalEncoding
+	broadcastBytes int
+	zeroing        bool
+}
+
+type x86PackedBinaryForm struct {
+	byteWidth, first, second, destination int
+	mask, memory, memoryBytes             int
+	legacy, mmx, broadcast, zeroing       bool
+}
+
+// Go accepts some X/Y high-bank spellings in mode32 without proving their
+// physical register identity. Apply this only after the family's syntax has
+// been validated; it grants no initialized values, ABI or memory permissions.
+func x86Mode32VectorRegisterContext(ins Instr, goarch string) error {
+	if goarch != "386" {
+		return nil
+	}
+	for _, operand := range ins.Args {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+		if operand.Kind == OpReg && valid && index >= 8 {
+			return fmt.Errorf("%w: 386 %s register %s has no proved physical mode32 binding", ErrProbeNeedsContext, ins.Op, operand.Reg)
+		}
+	}
+	return nil
+}
+
+// This grammar supplies no initialized values, address bounds or caller
+// privileges. The emitter and the private source/CFG proof share only forms.
+func x86PackedLogicalProperties(ins Instr, goarch string) (x86PackedLogicalForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86PackedLogicalSpecs[Op(base)]
+	if !recognized {
+		return x86PackedLogicalForm{}, false, nil
+	}
+	local := ins
+	if spec.encoding == x86PackedLogicalLegacyInteger {
+		var err error
+		local, err = x86LegacyMMXReadInstruction(ins, goarch)
+		if err != nil {
+			return x86PackedLogicalForm{}, true, err
+		}
+	}
+	form, err := x86PackedBinaryProperties(local, goarch, x86PackedBinarySpec{
+		encoding: spec.encoding, broadcastBytes: spec.broadcastBytes, zeroing: spec.zeroing,
+	})
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(ins, goarch)
+	}
+	result := x86PackedLogicalForm{x86PackedBinaryForm: form, spec: spec}
+	if err == nil {
+		result.source = local.Args[form.first]
+	}
+	return result, true, err
+}
+
+func x86PackedBinaryProperties(ins Instr, goarch string, spec x86PackedBinarySpec) (x86PackedBinaryForm, error) {
+	return x86PackedBinaryOperandGrammar(ins, goarch, spec, false)
+}
+
+// Only a validated unary projection or physical decoder may avoid the named
+// four-operand frontend cap. Every other grammar axis keeps the actual GOARCH.
+func x86PackedBinaryOperandGrammar(ins Instr, goarch string, spec x86PackedBinarySpec, mode32MaskOperands bool) (x86PackedBinaryForm, error) {
+	_, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	form := x86PackedBinaryForm{first: 0, second: 1, destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86PackedBinaryForm, error) {
+		return form, fmt.Errorf("%s %s operands/suffix outside Go packed binary grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "386" && goarch != "amd64" {
+		return fail()
+	}
+	form.legacy = spec.encoding == x86PackedLogicalLegacyFP || spec.encoding == x86PackedLogicalLegacyInteger
+	if form.legacy {
+		if dotted || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+			return fail()
+		}
+		form.byteWidth = 16
+		_, form.mmx = amd64ParseMReg(ins.Args[1].Reg)
+		if form.mmx {
+			if spec.encoding != x86PackedLogicalLegacyInteger || goarch != "amd64" {
+				return fail()
+			}
+			form.byteWidth = 8
+		}
+	} else {
+		switch suffix {
+		case "":
+			if dotted {
+				return fail()
+			}
+		case "Z":
+			form.zeroing = true
+		case "BCST":
+			form.broadcast = true
+		case "BCST.Z":
+			form.broadcast, form.zeroing = true, true
+		default:
+			return fail()
+		}
+		if len(ins.Args) != 3 && len(ins.Args) != 4 || form.broadcast && spec.broadcastBytes == 0 || form.zeroing && !spec.zeroing {
+			return fail()
+		}
+		if len(ins.Args) == 4 {
+			if goarch == "386" && !mode32MaskOperands || spec.encoding == x86PackedLogicalVEX || !amd64NonzeroKOperand(ins.Args[2]) {
+				return fail()
+			}
+			form.mask = 2
+		} else if form.zeroing {
+			return fail()
+		}
+		form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+	}
+	register := func(operand Operand) bool {
+		if form.mmx {
+			_, valid := amd64ParseMReg(operand.Reg)
+			return operand.Kind == OpReg && valid
+		}
+		if form.legacy {
+			index, valid := amd64ParseXReg(operand.Reg)
+			return operand.Kind == OpReg && valid && (goarch == "amd64" && index < 16 || goarch == "386" && index < 8)
+		}
+		if spec.encoding == x86PackedLogicalVEX {
+			return (form.byteWidth == 16 || form.byteWidth == 32) && amd64VEXVectorRegister(operand, form.byteWidth)
+		}
+		return amd64GoPackedVectorMoveRegister(operand, form.byteWidth, goarch)
+	}
+	if !register(ins.Args[form.destination]) || !register(ins.Args[form.second]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) {
+		if first.Kind == OpSym {
+			symbol := strings.TrimSpace(first.Sym)
+			_, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if first.Kind == OpMem {
+			// Go asmandsz requires signed disp32 in amd64 mode. Its historical
+			// 386 rule additionally admits uint32 spellings for the same bits;
+			// packed logical rows have no LEAL-only overflow exception.
+			displacement := first.Mem.Off
+			if displacement != int64(int32(displacement)) &&
+				(goarch != "386" || displacement != int64(uint32(displacement))) {
+				return fail()
+			}
+			if !x86MemoryRegistersValidForArch(first.Mem, goarch) || first.Mem.Index != "" &&
+				(first.Mem.Index == SP || first.Mem.Scale != 1 && first.Mem.Scale != 2 && first.Mem.Scale != 4 && first.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		form.memory, form.memoryBytes = form.first, form.byteWidth
+		if form.broadcast {
+			form.memoryBytes = spec.broadcastBytes
+		}
+	} else if form.broadcast || !register(first) {
+		return fail()
+	}
+	return form, nil
+}
diff --git a/amd64_packed_logical_forms_test.go b/amd64_packed_logical_forms_test.go
new file mode 100644
index 000000000..0993b128d
--- /dev/null
+++ b/amd64_packed_logical_forms_test.go
@@ -0,0 +1,344 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86LogicalOpcodeNames() []Op {
+	names := make([]Op, 0, len(x86PackedLogicalSpecs))
+	for opcode := range x86PackedLogicalSpecs {
+		names = append(names, opcode)
+	}
+	sort.Slice(names, func(i, j int) bool { return names[i] < names[j] })
+	return names
+}
+
+func TestX86PackedLogicalSpecsBindEveryGoOpcodeAttribute(t *testing.T) {
+	if len(x86PackedLogicalSpecs) != 32 {
+		t.Fatal("incomplete packed logical family")
+	}
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return
+	}
+	dir := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range x86LogicalOpcodeNames() {
+		spec := x86PackedLogicalSpecs[opcode]
+		if spec.encoding <= x86PackedLogicalLegacyInteger {
+			row := "{A" + string(opcode) + ", "
+			start := strings.Index(string(legacy), row)
+			if start < 0 {
+				t.Fatalf("Go omits %s", opcode)
+			}
+			line := strings.SplitN(string(legacy)[start:], "\n", 2)[0]
+			table := "yxm"
+			if spec.encoding == x86PackedLogicalLegacyInteger {
+				table = "ymm"
+			}
+			if !strings.Contains(line, ", "+table+",") {
+				t.Fatalf("Go legacy row differs: %s", line)
+			}
+			continue
+		}
+		prefix := "{as: A" + string(opcode) + ", ytab: "
+		start := strings.Index(string(avx), prefix)
+		if start < 0 {
+			t.Fatalf("Go omits %s", opcode)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		table := "_yvandnpd"
+		if spec.encoding == x86PackedLogicalVEX {
+			table = "_yvaddsubpd"
+		}
+		if spec.encoding == x86PackedLogicalEVEX {
+			table = "_yvblendmpd"
+		}
+		if !strings.HasPrefix(row, prefix+table+",") {
+			t.Fatalf("Go ytab changed for %s", opcode)
+		}
+		if spec.encoding == x86PackedLogicalVEX {
+			if strings.Contains(row, "evex") || spec.broadcastBytes != 0 || spec.zeroing {
+				t.Fatalf("VEX attributes changed: %s", row)
+			}
+			continue
+		}
+		for _, line := range strings.Split(row, "\n") {
+			if !strings.Contains(line, "avxEscape | evex") {
+				continue
+			}
+			if !strings.Contains(line, fmt.Sprintf("evexBcstN%d", spec.broadcastBytes)) || !strings.Contains(line, "evexZeroingEnabled") ||
+				strings.Contains(line, "evexSae") || strings.Contains(line, "evexRounding") {
+				t.Fatalf("%s opcode attributes disagree with Go: %s", opcode, line)
+			}
+		}
+	}
+}
+
+// Rows come from the actual yxm/ymm, _yvaddsubpd, _yvandnpd and
+// _yvblendmpd tables; memory and all opcode-specific suffix axes are included.
+func x86LogicalAcceptedForms(opcode Op, arch string) []string {
+	spec := x86PackedLogicalSpecs[opcode]
+	if spec.encoding <= x86PackedLogicalLegacyInteger {
+		last := 15
+		if arch == "386" {
+			last = 7
+		}
+		rows := []string{fmt.Sprintf("%s X0,X%d", opcode, last), fmt.Sprintf("%s 8(AX),X%d", opcode, last)}
+		if spec.encoding == x86PackedLogicalLegacyInteger && arch == "amd64" {
+			rows = append(rows, fmt.Sprintf("%s M0,M7", opcode), fmt.Sprintf("%s 8(AX),M7", opcode))
+		}
+		return rows
+	}
+	var rows []string
+	widths := []string{"X", "Y", "Z"}
+	if spec.encoding == x86PackedLogicalVEX {
+		widths = widths[:2]
+	}
+	for _, width := range widths {
+		last := 31
+		if spec.encoding == x86PackedLogicalVEX {
+			last = 15
+		}
+		if arch == "386" && width == "Z" {
+			last = 7
+		}
+		dest := fmt.Sprintf("%s%d", width, last)
+		rows = append(rows, fmt.Sprintf("%s %s0,%s1,%s", opcode, width, width, dest), fmt.Sprintf("%s 8(AX),%s1,%s", opcode, width, dest))
+		if spec.broadcastBytes == 0 {
+			continue
+		}
+		rows = append(rows, fmt.Sprintf("%s.BCST 8(AX),%s1,%s", opcode, width, dest))
+		if arch == "386" {
+			continue
+		}
+		rows = append(rows,
+			fmt.Sprintf("%s %s0,%s1,K7,%s", opcode, width, width, dest),
+			fmt.Sprintf("%s.Z %s0,%s1,K1,%s", opcode, width, width, dest),
+			fmt.Sprintf("%s 8(AX),%s1,K7,%s", opcode, width, dest),
+			fmt.Sprintf("%s.Z 8(AX),%s1,K1,%s", opcode, width, dest),
+			fmt.Sprintf("%s.BCST 8(AX),%s1,K7,%s", opcode, width, dest),
+			fmt.Sprintf("%s.BCST.Z 8(AX),%s1,K1,%s", opcode, width, dest))
+	}
+	return rows
+}
+
+func TestX86PackedLogicalCompleteGoRowsAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, goSource strings.Builder
+			source.WriteString("TEXT logicalforms(SB),$0-0\n")
+			goSource.WriteString("TEXT logicalforms(SB),$0-0\n")
+			for _, op := range x86LogicalOpcodeNames() {
+				for _, row := range x86LogicalAcceptedForms(op, target.arch) {
+					fmt.Fprintln(&goSource, row)
+					if target.arch == "386" {
+						// Preserve Go's full source grammar independently. LLVM
+						// object generation requires physically bound registers.
+						row = strings.NewReplacer("X31", "X7", "Y31", "Y7", "X15", "X7", "Y15", "Y7").Replace(row)
+					}
+					fmt.Fprintln(&source, row)
+					parsed, err := Parse(ArchAMD64, "TEXT one(SB),$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, recognized, err := x86PackedLogicalProperties(parsed.Funcs[0].Instrs[1], target.arch); !recognized || err != nil {
+						t.Fatalf("%s: %v", row, err)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			goSource.WriteString("RET\n")
+			requireX86GoAssemblerResult(t, target.arch, goSource.String(), true)
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "logicalforms", target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "logical.ll", "logical.o", ir)
+		})
+	}
+}
+
+func TestX86PackedLogicalRejectsInvalidFormsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range x86LogicalOpcodeNames() {
+			spec := x86PackedLogicalSpecs[opcode]
+			args := "X0,X1,X2"
+			if spec.encoding <= x86PackedLogicalLegacyInteger {
+				args = "X0,X1"
+			}
+			rows := []string{string(opcode) + ".SAE " + args, string(opcode) + ".RN_SAE " + args, string(opcode) + ".Z.Z " + args,
+				string(opcode) + " $3," + args, string(opcode) + " X0,(AX)", string(opcode) + " X0,Y1", string(opcode) + " X0,X1,X2,X3"}
+			memoryTail := ",X0,X1"
+			if spec.encoding <= x86PackedLogicalLegacyInteger {
+				memoryTail = ",X0"
+			}
+			rows = append(rows, string(opcode)+" (AX)(CX*3)"+memoryTail, string(opcode)+" (AX)(SP*1)"+memoryTail)
+			if spec.encoding <= x86PackedLogicalLegacyInteger {
+				rows = append(rows, string(opcode)+" X16,X0", string(opcode)+".BCST 8(AX),X0")
+				if spec.encoding == x86PackedLogicalLegacyFP {
+					rows = append(rows, string(opcode)+" M0,M1")
+				}
+			} else {
+				rows = append(rows, string(opcode)+".Z X0,X1,X2", string(opcode)+" X0,X1,K0,X2", string(opcode)+".BCST X0,X1,X2",
+					string(opcode)+".Z.BCST (AX),X0,K1,X1")
+				if spec.encoding == x86PackedLogicalVEX {
+					rows = append(rows, string(opcode)+" Z0,Z1,Z2", string(opcode)+" X16,X1,X2", string(opcode)+".BCST (AX),X0,X1", string(opcode)+" X0,X1,K1,X2")
+				}
+			}
+			if arch == "386" {
+				rows = append(rows, string(opcode)+" 8(R9),"+args)
+			}
+			for _, row := range rows {
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					assembly := "TEXT bad(SB),$0-0\n" + row + "\nRET\n"
+					requireX86GoAssemblerResult(t, arch, assembly, false)
+					file, err := Parse(ArchAMD64, assembly)
+					if err != nil {
+						return
+					}
+					instruction := file.Funcs[0].Instrs[1]
+					ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := out.String()
+					ok, term, err := ctx.lowerPackedLogicalFamily(instruction.Op, instruction)
+					if !ok || term || err == nil || out.String() != before {
+						t.Fatalf("invalid form emitted (%v,%v,%v)", ok, term, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedLogicalDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, opcode := range x86LogicalOpcodeNames() {
+		for _, sourceOp := range []Op{"", opcode, Op(strings.ToLower(string(opcode))), "UNKNOWN", "MOVQ"} {
+			row := x86LogicalAcceptedForms(opcode, "amd64")[0]
+			file, err := Parse(ArchAMD64, "TEXT one(SB),$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			instruction.Op = sourceOp
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			ok, term, err := ctx.lowerPackedLogicalFamily(opcode, instruction)
+			if sourceOp == "UNKNOWN" || sourceOp == "MOVQ" {
+				if !ok || term || err == nil || out.String() != before {
+					t.Fatalf("%s/%s conflicting helper identity emitted", opcode, sourceOp)
+				}
+			} else if !ok || term || err != nil {
+				t.Fatalf("%s/%s helper compatibility lost: %v", opcode, sourceOp, err)
+			}
+			if instruction.Op != sourceOp {
+				t.Fatal("helper rewrote source identity")
+			}
+		}
+	}
+}
+
+func TestX86PackedLogicalSymbolAddressIsNotMemory(t *testing.T) {
+	for _, opcode := range x86LogicalOpcodeNames() {
+		t.Run(string(opcode), func(t *testing.T) {
+			args := "X0,X1"
+			if x86PackedLogicalSpecs[opcode].encoding <= x86PackedLogicalLegacyInteger {
+				args = "X0"
+			}
+			source := "TEXT bad(SB),$0-0\n" + string(opcode) + " $symbol(SB)," + args + "\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				return
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			ok, term, err := ctx.lowerPackedLogicalFamily(instruction.Op, instruction)
+			if !ok || term || err == nil || out.String() != before {
+				t.Fatalf("symbol address acquired memory load/emission: (%v,%v,%v)", ok, term, err)
+			}
+		})
+	}
+}
+
+func TestX86PackedLogicalMemoryDisplacementMatchesGoEncoding(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range x86LogicalOpcodeNames() {
+			args := "X0,X1"
+			if x86PackedLogicalSpecs[opcode].encoding <= x86PackedLogicalLegacyInteger {
+				args = "X0"
+			}
+			invalid := []int64{-2147483649, 4294967296}
+			if arch == "amd64" {
+				invalid = append(invalid, 2147483648, 4294967295)
+			}
+			for _, displacement := range invalid {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, opcode, displacement), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT bad(SB),$0-0\n%s %d(AX)(CX*2),%s\nRET\n", opcode, displacement, args)
+					requireX86GoAssemblerResult(t, arch, source, false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					instruction := file.Funcs[0].Instrs[1]
+					ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := out.String()
+					ok, term, err := ctx.lowerPackedLogicalFamily(instruction.Op, instruction)
+					if !ok || term || err == nil || out.String() != before {
+						t.Fatalf("unencodable displacement emitted: (%v,%v,%v)", ok, term, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedLogicalBoundaryDisplacementsGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT boundaries(SB),$0-0\n")
+			displacements := []int64{-2147483648, 2147483647}
+			if target.arch == "386" {
+				displacements = append(displacements, 2147483648, 4294967295)
+			}
+			for _, opcode := range x86LogicalOpcodeNames() {
+				args := "X0,X1"
+				if x86PackedLogicalSpecs[opcode].encoding <= x86PackedLogicalLegacyInteger {
+					args = "X0"
+				}
+				for _, displacement := range displacements {
+					fmt.Fprintf(&source, "%s %d(AX)(CX*2),%s\n", opcode, displacement, args)
+				}
+			}
+			source.WriteString("RET\n")
+			ir := x86UnboundVoidScalarFormatObject(t, source.String(), "boundaries", target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "boundary.ll", "boundary.o", ir)
+		})
+	}
+}
diff --git a/amd64_packed_logical_oracle_test.go b/amd64_packed_logical_oracle_test.go
new file mode 100644
index 000000000..5c81c0f6d
--- /dev/null
+++ b/amd64_packed_logical_oracle_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86LogicalRuntimeBatchesRetainCompleteInventory(t *testing.T) {
+	fixtures := x86LogicalRuntimeFixtures(t)
+	if len(fixtures) != 472 {
+		t.Fatalf("complete opcode/width/memory/mask inventory: got %d, want 472", len(fixtures))
+	}
+	seen := make(map[string]bool, len(fixtures))
+	for index, batch := range x86LogicalRuntimeBatches(fixtures) {
+		if len(batch) == 0 || len(batch) > 64 {
+			t.Errorf("batch %d has %d fixtures, require 1..64", index, len(batch))
+		}
+		for _, fixture := range batch {
+			if seen[fixture.name] {
+				t.Fatalf("duplicate fixture %s", fixture.name)
+			}
+			seen[fixture.name] = true
+		}
+	}
+	if len(seen) != len(fixtures) {
+		t.Fatalf("batch union lost fixtures: got %d, want %d", len(seen), len(fixtures))
+	}
+	for _, fixture := range fixtures {
+		if !seen[fixture.name] {
+			t.Errorf("missing fixture %s", fixture.name)
+		}
+	}
+}
+
+// This is the real numerical oracle with a deliberately wrong implementation,
+// not an instruction-semantics pass. Its former return code was 256, which a
+// Unix parent observes as success. A large case ID must remain diagnostic data.
+func TestX86LogicalRuntimeOracleCannotWrapFailureToSuccess(t *testing.T) {
+	fixture := x86LogicalRuntimeFixtures(t)[245]
+	program := x86LogicalRuntimeC([]x86LogicalRuntimeFixture{fixture}) + fmt.Sprintf(`
+void %s(uint8_t *out, const uint8_t *a, const uint8_t *b, uint64_t mask) {
+    memset(out, 0, 65);
+}
+`, fixture.name)
+	requireX86GeneratedOracleFailure(t, program, fixture.name+" numerical/canary failure")
+}
+
+func requireX86GeneratedOracleFailure(t *testing.T, program, diagnostic string) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	dir := t.TempDir()
+	source, executable := filepath.Join(dir, "mutation.c"), filepath.Join(dir, "mutation")
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	arguments := execution.command(executable)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, arguments[0], arguments[1:]...))
+	var failure *exec.ExitError
+	if !errors.As(err, &failure) || failure.ExitCode() != 1 {
+		t.Fatalf("wrong result must terminate with failure 1, got %v; output=%s", err, output)
+	}
+	if !strings.Contains(string(output), diagnostic) {
+		t.Fatalf("failure diagnostic lost the exact fixture: %s", output)
+	}
+}
diff --git a/amd64_packed_logical_runtime_test.go b/amd64_packed_logical_runtime_test.go
new file mode 100644
index 000000000..f5949c65c
--- /dev/null
+++ b/amd64_packed_logical_runtime_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The numerical oracle derives semantics from the source mnemonic, not the
+// emitter's mode field; a wrong opcode-to-mode registration must still fail.
+func x86LogicalIndependentCOperator(t *testing.T, opcode Op) string {
+	t.Helper()
+	name := string(opcode)
+	switch {
+	case strings.Contains(name, "ANDN"):
+		return "aByte & (uint8_t)~b[i]"
+	case strings.Contains(name, "AND"):
+		return "aByte & b[i]"
+	case strings.Contains(name, "XOR"):
+		return "aByte ^ b[i]"
+	case strings.Contains(name, "OR"):
+		return "aByte | b[i]"
+	default:
+		t.Fatalf("unknown numerical oracle opcode %s", opcode)
+		return ""
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedLogicalCompleteSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires Linux/amd64 runtime counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang missing")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	fixtures := x86LogicalRuntimeFixtures(t)
+	for index, batch := range x86LogicalRuntimeBatches(fixtures) {
+		t.Run(fmt.Sprintf("batch-%02d", index), func(t *testing.T) {
+			var assembly strings.Builder
+			sigs := make(map[string]FuncSig, len(batch))
+			for _, fixture := range batch {
+				assembly.WriteString(fixture.assembly)
+				sigs[fixture.name] = fixture.signature
+			}
+			requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "logical_complete_semantics",
+				triple, ir, x86LogicalRuntimeC(batch), prefix)
+		})
+	}
+	t.Logf("%d exact opcode/width/memory/mask programs; 16 independently expected numerical/canary inputs each", len(fixtures))
+}
+
+type x86LogicalRuntimeFixture struct {
+	name, assembly, declaration, checks string
+	signature                           FuncSig
+}
+
+func x86LogicalRuntimeBatches(fixtures []x86LogicalRuntimeFixture) [][]x86LogicalRuntimeFixture {
+	const batchSize = 64
+	var batches [][]x86LogicalRuntimeFixture
+	for start := 0; start < len(fixtures); start += batchSize {
+		end := start + batchSize
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		batches = append(batches, fixtures[start:end])
+	}
+	return batches
+}
+
+func x86LogicalRuntimeC(fixtures []x86LogicalRuntimeFixture) string {
+	var declarations, checks, calls strings.Builder
+	for _, fixture := range fixtures {
+		declarations.WriteString(fixture.declaration)
+		// Keep independent reference loops out of one giant optimizer graph.
+		// noinline also prevents -O2 from reconstructing that graph in main.
+		fmt.Fprintf(&checks, "static __attribute__((noinline)) int check_%s(void) {\n", fixture.name)
+		checks.WriteString("const uint64_t masks[]={0,1,0x55aa55aa55aa55aaULL,~0ULL};\n")
+		checks.WriteString(fixture.checks)
+		checks.WriteString("return 0;\n}\n")
+		// Case IDs belong in diagnostics, not process exit codes: Unix keeps
+		// only eight bits and would report return 256 as successful execution.
+		fmt.Fprintf(&calls, "if (check_%s()) { fprintf(stderr, \"%s numerical/canary failure\\n\"); return 1; }\n",
+			fixture.name, fixture.name)
+	}
+	return "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		declarations.String() + checks.String() +
+		"int main(void) {\n" + calls.String() + "return 0;\n}\n"
+}
+
+func x86LogicalRuntimeFixtures(t *testing.T) []x86LogicalRuntimeFixture {
+	t.Helper()
+	var fixtures []x86LogicalRuntimeFixture
+	count := 0
+	for _, opcode := range x86LogicalOpcodeNames() {
+		spec := x86PackedLogicalSpecs[opcode]
+		widths := []int{16, 32, 64}
+		if spec.encoding <= x86PackedLogicalLegacyInteger {
+			widths = widths[:1]
+		}
+		if spec.encoding == x86PackedLogicalVEX {
+			widths = widths[:2]
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, memory := range []string{"register", "memory", "broadcast"} {
+				if memory == "broadcast" && spec.broadcastBytes == 0 {
+					continue
+				}
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					if mode != "unmasked" && spec.broadcastBytes == 0 {
+						continue
+					}
+					var assembly, declarations, checks strings.Builder
+					name := fmt.Sprintf("logical%d", count)
+					count++
+					legacy := spec.encoding <= x86PackedLogicalLegacyInteger
+					first := bank + "1"
+					if memory != "register" {
+						first = "(BX)"
+					}
+					operation := string(opcode)
+					if memory == "broadcast" {
+						operation += ".BCST"
+					}
+					if mode == "zero" {
+						operation += ".Z"
+					}
+					row := operation + " " + first + "," + bank + "0"
+					destination := 2
+					if legacy {
+						destination = 0
+					} else {
+						if mode != "unmasked" {
+							row += ",K1"
+						}
+						row += "," + bank + "2"
+					}
+					fmt.Fprintf(&assembly, "TEXT %s(SB),$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (CX),Z0\nVMOVUPS (CX),Z2\n", name)
+					if memory == "register" {
+						assembly.WriteString("VMOVUPS (BX),Z1\n")
+					}
+					assembly.WriteString("KMOVQ DX,K1\nSTC\n" + row + "\n")
+					fmt.Fprintf(&assembly, "VMOVUPS Z%d,(AX)\nSETCS 64(AX)\nRET\n", destination)
+					signature := FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+					operator := x86LogicalIndependentCOperator(t, opcode)
+					maskExpression := "1"
+					if mode != "unmasked" {
+						maskExpression = fmt.Sprintf("((mask>>(i/%d))&1)", spec.laneBits/8)
+					}
+					inactive := "b[i]"
+					if mode == "zero" {
+						inactive = "0"
+					}
+					upper := "0"
+					if legacy {
+						upper = "b[i]"
+					}
+					index := "i"
+					if memory == "broadcast" {
+						index = fmt.Sprintf("i%%%d", spec.broadcastBytes)
+					}
+					aOffset := 1
+					if legacy && memory == "memory" {
+						// The original legacy m128 instruction requires 16-byte
+						// alignment. Keep other source forms deliberately unaligned;
+						// the independent native fault root checks legacy misalignment.
+						aOffset = 16
+					}
+					fmt.Fprintf(&checks, `
+ for(int round=0;round<4;++round) for(int m=0;m<4;++m) {
+  uint64_t mask=masks[m]; _Alignas(16) uint8_t aStorage[96]; uint8_t bStorage[68],output[67]; uint8_t *a=aStorage+%[9]d,*b=bStorage+3;
+  memset(aStorage,0xa7,96); memset(bStorage,0xb9,68); memset(output,0xc3,67);
+  for(int i=0;i<64;++i) { a[i]=(uint8_t)(i*19+round*83+7); b[i]=(uint8_t)(i*31+round*59+13); }
+  %[1]s(output+1,a,b,mask);
+  if(output[0]!=0xc3 || output[66]!=0xc3 || output[65]!=1) return %[2]d;
+  for(int i=0;i<64;++i) {
+   uint8_t aByte=a[%[3]s]; uint8_t want=i<%[4]d ? ((%[5]s) ? (%[6]s) : (%[7]s)) : (%[8]s);
+   if(output[i+1]!=want || a[i]!=(uint8_t)(i*19+round*83+7) || b[i]!=(uint8_t)(i*31+round*59+13)) return %[2]d;
+  }
+  for(int i=0;i<96;++i) if((i<%[9]d || i>=%[9]d+64) && aStorage[i]!=0xa7) return %[2]d;
+  if(bStorage[2]!=0xb9 || bStorage[67]!=0xb9) return %[2]d;
+ }
+`, name, count+10, index, width, maskExpression, operator, inactive, upper, aOffset)
+					if mode != "unmasked" && memory != "register" {
+						// A zero relevant mask suppresses every memory read,
+						// including broadcast. NULL is never dereferenced.
+						fmt.Fprintf(&checks, `{ uint8_t b[64],out[65]; memset(b,0x5a,64); %[1]s(out,0,b,0);
+ for(int i=0;i<64;++i) { uint8_t want=i<%[2]d ? (%[3]s) : 0; if(out[i]!=want) return %[4]d; } }
+`, name, width, map[string]string{"merge": "0x5a", "zero": "0"}[mode], count+10)
+					}
+					fixtures = append(fixtures, x86LogicalRuntimeFixture{
+						name: name, assembly: assembly.String(), declaration: declarations.String(),
+						checks: checks.String(), signature: signature,
+					})
+				}
+			}
+		}
+	}
+	return fixtures
+}
+
+func TestX86PackedLogicalXWritesClearWiderAliases(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires amd64 or Rosetta; Linux counterpart executes the same oracle")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple, prefix = "x86_64-apple-darwin", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	for _, opcode := range []string{"VXORPS", "VPXOR", "VPXORD"} {
+		t.Run(opcode, func(t *testing.T) {
+			source := "TEXT logicalalias(SB),$0-16\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nVMOVUPS (BX),Z0\n" + opcode + " X0,X0,X0\nVMOVUPS Z0,(AX)\nRET\n"
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"logicalalias": {Name: "logicalalias", Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}}},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void logicalalias(uint8_t *, const uint8_t *);
+int main(void) {
+  uint8_t in[66], out[66];
+  for (int k=0; k<66; ++k) { in[k]=(uint8_t)(k*19+7); out[k]=0xa5; }
+  logicalalias(out+1,in+1);
+  if(out[0]!=0xa5 || out[65]!=0xa5) return 2;
+  for(int k=1; k<65; ++k) if(out[k]!=0) return k+10;
+  for(int k=0; k<66; ++k) if(in[k]!=(uint8_t)(k*19+7)) return 3;
+  return 0;
+}
+`
+			compileAndRunRuntimeTestForTarget(t, llc, clang, strings.ToLower(opcode)+"_alias", triple, ir, mainC, prefix)
+		})
+	}
+}
diff --git a/amd64_packed_low_multiply_forms.go b/amd64_packed_low_multiply_forms.go
new file mode 100644
index 000000000..e3a6c5dc4
--- /dev/null
+++ b/amd64_packed_low_multiply_forms.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+type x86PackedLowMultiplyForm = x86PackedArithmeticForm
+
+func x86PackedLowMultiplyProperties(op Op, ins Instr, arch string) (x86PackedLowMultiplyForm, bool, error) {
+	return x86PackedArithmeticProperties(op, ins, arch, x86PackedArithmeticLowMultiply)
+}
diff --git a/amd64_packed_low_multiply_forms_test.go b/amd64_packed_low_multiply_forms_test.go
new file mode 100644
index 000000000..5903e23bf
--- /dev/null
+++ b/amd64_packed_low_multiply_forms_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedLowMultiplyCompleteGoEncoderRows(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{APMULLD, yxm_q4, Pq4, opBytes{0x40}}",
+		"{Zm_r, 1, argList{Yxm, Yxr}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("actual legacy Go row changed", row)
+		}
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	lowCount := 0
+	for _, spec := range x86PackedArithmeticSpecs {
+		if spec.family == x86PackedArithmeticLowMultiply {
+			lowCount++
+		}
+	}
+	if lowCount != 3 {
+		t.Fatal("incomplete D/Q low-product inventory")
+	}
+	for _, name := range []string{"VPMULLD", "VPMULLQ"} {
+		table, w, broadcast, rows := "_yvandnpd", 0, 4, 5
+		if name == "VPMULLQ" {
+			table, w, broadcast, rows = "_yvblendmpd", 1, 8, 3
+		}
+		start := strings.Index(string(avx), "{as: A"+name+",")
+		if start < 0 {
+			t.Fatal("missing Go opcode", name)
+		}
+		record := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(record, "ytab: "+table+", prefix: Pavx") || strings.Count(record, "avxEscape") != rows {
+			t.Fatal("Go opcode row inventory changed", record)
+		}
+		if name == "VPMULLD" {
+			for _, width := range []int{128, 256} {
+				want := fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F38 | vexW0, 0x40,", width)
+				if !strings.Contains(record, want) {
+					t.Fatal("Go VEX attributes changed", want)
+				}
+			}
+		}
+		for _, width := range []int{128, 256, 512} {
+			want := fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d, evexN%d | evexBcstN%d | evexZeroingEnabled, 0x40,", width, w, width/8, broadcast)
+			if !strings.Contains(record, want) {
+				t.Fatal("Go EVEX attributes changed", want)
+			}
+		}
+		start = strings.Index(string(avx), "var "+table+" =")
+		if start < 0 {
+			t.Fatal("missing Go operand table", table)
+		}
+		operands := strings.SplitN(string(avx)[start:], "\n}", 2)[0]
+		var expected []string
+		if name == "VPMULLD" {
+			expected = append(expected,
+				"{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}}",
+				"{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yym, Yyr, Yyr}}")
+		}
+		for _, classes := range [][2]string{{"YxmEvex", "YxrEvex"}, {"YymEvex", "YyrEvex"}, {"Yzm", "Yzr"}} {
+			expected = append(expected,
+				fmt.Sprintf("{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{%s, %s, %s}}", classes[0], classes[1], classes[1]),
+				fmt.Sprintf("{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{%s, %s, Yknot0, %s}}", classes[0], classes[1], classes[1]))
+		}
+		if strings.Count(operands, "argList{") != len(expected) {
+			t.Fatal("Go operand row inventory changed", operands)
+		}
+		for _, row := range expected {
+			if !strings.Contains(operands, row) {
+				t.Fatal("Go operand classes/encoding changed", row)
+			}
+		}
+	}
+}
+
+func x86LowMultiplyFormatRows(arch string) []string {
+	var rows []string
+	for _, source := range []string{"X0", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-16(SP)", "·data(SB)", "(FS)", "(GS)"} {
+		rows = append(rows, "PMULLD "+source+",X1")
+	}
+	for _, op := range []string{"VPMULLD", "VPMULLQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{bank + "0", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && source == bank+"0" {
+						continue
+					}
+					for mode := 0; mode < 3; mode++ {
+						if arch == "386" && mode != 0 {
+							continue
+						}
+						name, args := op, source+","+bank+"1"
+						if broadcast {
+							name += ".BCST"
+						}
+						if mode != 0 {
+							args += ",K7"
+						}
+						if mode == 2 {
+							name += ".Z"
+						}
+						rows = append(rows, name+" "+args+","+bank+"2")
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedLowMultiplyGoFormatsAndConsumerShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LowMultiplyFormatRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$64-64\n"+row+"\nRET\n", "", true)
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch)
+				if !known || err != nil {
+					t.Fatal("valid Go shape lost", known, err)
+				}
+				if !x86CallerVectorMoveKnown(ins) {
+					t.Fatal("caller consumer lost valid family")
+				}
+				if form.memory >= 0 {
+					width, write, known := x86InstructionMemoryShape(ins, form.memory, arch)
+					want := form.byteWidth
+					if strings.Contains(row, ".BCST") {
+						want = 4
+						if strings.HasPrefix(row, "VPMULLQ") {
+							want = 8
+						}
+					}
+					if !known || write || width != int64(want) {
+						t.Fatal("read tuple differs from Go", width, write, known, want)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyMode32HighBanksRemainContext(t *testing.T) {
+	for _, name := range []string{"VPMULLD", "VPMULLQ"} {
+		for _, bank := range []string{"X", "Y"} {
+			for _, register := range []int{8, 15, 16, 31} {
+				row := fmt.Sprintf("%s %s%d,%s1,%s2", name, bank, register, bank, bank)
+				goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+				for _, target := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, err = Translate(file, Options{Goarch: "386", TargetTriple: target, Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}})
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Go syntax invented a physical high bank", row, target, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyResultBytes(t *testing.T) {
+	for _, row := range []string{"PMULLW X0,X1", "VPMULLW X0,X1,X2", "PMULLD X0,X1", "VPMULLD X0,X1,X2", "VPMULLQ X0,X1,X2"} {
+		for _, arch := range []string{"amd64", "386"} {
+			for missing := -1; missing < 16; missing++ {
+				ins := x86ScalarLaneInstruction(t, row)
+				state := x86ResultState{flags: 0x3f}
+				state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+				state.vectorUpper[1], state.vectorUpper[2] = 0xffff0000, 0xff000000
+				if missing >= 0 {
+					state.xmm[0] &^= 1 << uint(missing)
+				}
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatalf("registered low multiply result effect missing: %s/%s", arch, row)
+				}
+				laneBytes := 4
+				if strings.Contains(row, "LLW") {
+					laneBytes = 2
+				} else if strings.Contains(row, "LLQ") {
+					laneBytes = 8
+				}
+				want := uint64(0xffff)
+				if missing >= 0 {
+					want &^= (uint64(1)<<uint(laneBytes) - 1) << uint(missing/laneBytes*laneBytes)
+				}
+				dst := 1
+				if strings.HasPrefix(row, "V") {
+					dst = 2
+					want |= ^uint64(0xffff)
+				} else {
+					want |= 0xffff0000
+				}
+				if got := state.vectorBytes(dst); got != want || state.flags != 0x3f {
+					t.Fatalf("%s missing=%d: got=%x want=%x flags=%x", row, missing, got, want, state.flags)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyInvalidGoAxesAndSourceIdentity(t *testing.T) {
+	for _, row := range []string{
+		"PMULLD M0,M1", "PMULLD X16,X1", "PMULLD.BCST (AX),X1",
+		"VPMULLD X0,Y1,Y2", "VPMULLD X0,(AX),X2", "VPMULLD $1,X1,X2",
+		"VPMULLD X0,X1,K0,X2", "VPMULLD.BCST X0,X1,X2",
+		"VPMULLD.Z.BCST (AX),X1,K1,X2", "VPMULLD.SAE X0,X1,X2",
+		"VPMULLQ X0,Y1,Y2", "VPMULLQ X0,(AX),X2", "VPMULLQ $1,X1,X2",
+		"VPMULLQ X0,X1,K0,X2", "VPMULLQ.BCST X0,X1,X2",
+		"VPMULLQ.BCST.BCST (AX),X1,X2", "VPMULLQ.RN_SAE X0,X1,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, "amd64"); !known || err == nil {
+				t.Fatal("invalid Go form acquired typed effects", row, known, err)
+			}
+			if x86CallerVectorMoveKnown(ins) {
+				t.Fatal("invalid Go form acquired a caller effect", row)
+			}
+		})
+	}
+	for _, row := range []string{"PMULLD (AX),X1", "VPMULLD (AX),X1,X2", "VPMULLQ (AX),X1,X2"} {
+		ins := x86ScalarLaneInstruction(t, row)
+		for _, mutation := range []string{"dispatch", "address-size", "unbound-override"} {
+			changed, op := ins, ins.Op
+			switch mutation {
+			case "dispatch":
+				op = "VPMULLD"
+				changed.Op = "VPMULLQ"
+			case "address-size":
+				changed.x86AddressBits = 32
+			case "unbound-override":
+				changed.x86UnboundAddressOverride = true
+			}
+			if _, known, err := x86PackedLowMultiplyProperties(op, changed, "amd64"); !known || err == nil {
+				t.Fatal("changed source metadata retained a form", row, mutation, err)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_low_multiply_objects_test.go b/amd64_packed_low_multiply_objects_test.go
new file mode 100644
index 000000000..8e2e9476d
--- /dev/null
+++ b/amd64_packed_low_multiply_objects_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedLowMultiplyThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86LowMultiplyFormatRows(target.arch)
+			for begin := 0; begin < len(rows); begin += 64 {
+				end := begin + 64
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprint(begin), func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows[begin:end] {
+						if strings.HasPrefix(row, "PMULLD ") && (strings.Contains(row, "(FP)") || strings.Contains(row, "(SP)")) {
+							// These original-Go forms have an explicit rejection
+							// regression below, not a successful object claim.
+							continue
+						}
+						fmt.Fprintf(&declarations, "func Low%d(value [64]byte)\n", index)
+						fmt.Fprintf(&source, "TEXT ·Low%d(SB),4,$64-64\n%s\nRET\n", index, row)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(api, err)
+						}
+						x86ResultInitializationObject(t, llc, target.triple, ir, "low-multiply-"+api)
+						x86ResultInitializationObject(t, llc, target.triple, x86MulDivRoundOptimize(t, ir), "low-multiply-"+api+"-optimized")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedLowMultiplyVirtualLegacyStorageRemainsContext(t *testing.T) {
+	for _, row := range []string{"PMULLD value+0(FP),X1", "PMULLD local-16(SP),X1", "PMULLD (SP),X1", "PMULLD (BP),X1"} {
+		for _, target := range x86RawReturnTargets {
+			source := "TEXT ·Low(SB),4,$64-64\nPXOR X1,X1\n" + row + "\nRET\n"
+			declaration := "func Low(value [64]byte)"
+			address := strings.Fields(row)[1]
+			address = strings.Split(address, ",")[0]
+			if address == "(BP)" || address == "(SP)" {
+				source = x86OrdinaryBPNativeSource(target.arch, "Low", row, address, 64)
+				declaration = "func Low(p *byte)"
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					x86RequireOrdinaryBPNativeOutcome(t, target.arch, address, ir, err)
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyResultMemoryAndMasks(t *testing.T) {
+	for _, op := range []string{"VPMULLW", "VPMULLD", "VPMULLQ"} {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && op == "VPMULLW" {
+				continue
+			}
+			row, width := op, 16
+			if broadcast {
+				row, width = row+".BCST", 4
+				if op == "VPMULLQ" {
+					width = 8
+				}
+			}
+			row += ".Z value+0(FP),X1,K1,X2"
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-16\n"+row+"\nRET\n", "", true)
+			ins := x86ScalarLaneInstruction(t, row)
+			for missing := -1; missing < 16; missing++ {
+				for _, maskKnown := range []bool{false, true} {
+					state := x86ResultState{fp: make([]bool, 16)}
+					owned := make([]bool, 16)
+					for i := range owned {
+						owned[i], state.fp[i] = true, i != missing
+					}
+					state.xmm[1], state.masks[1] = 0xffff, maskKnown
+					accepted := x86ResultTransfer(ins, &state, owned, 16, "amd64")
+					want := maskKnown && (missing < 0 || missing >= width)
+					if accepted != want || accepted && state.vectorBytes(2) != ^uint64(0) || len(ins.x86CallerMemory) != 0 {
+						t.Fatal("mask/tuple observation invented bytes or caller permission", row, missing, maskKnown, accepted)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyResultThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var source, declarations strings.Builder
+	for index, row := range []string{"PMULLW X0,X1", "VPMULLW X0,X1,X1", "PMULLD X0,X1", "VPMULLD X0,X1,X1", "VPMULLQ X0,X1,X1"} {
+		fmt.Fprintf(&declarations, "func Low%d() uint32\n", index)
+		fmt.Fprintf(&source, "TEXT ·Low%d(SB),4,$0-4\nMOVL $0x87654321,AX\n", index)
+		for _, reg := range []string{"X0", "X1"} {
+			for lane := 0; lane < 4; lane++ {
+				fmt.Fprintf(&source, "PINSRD $%d,AX,%s\n", lane, reg)
+			}
+		}
+		fmt.Fprintf(&source, "%s\nPEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET\n", row)
+	}
+	for _, target := range x86RawReturnTargets {
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal(target, api, err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, ir, "low-multiply-result-"+api)
+		}
+	}
+}
diff --git a/amd64_packed_low_multiply_raw_test.go b/amd64_packed_low_multiply_raw_test.go
new file mode 100644
index 000000000..55135061d
--- /dev/null
+++ b/amd64_packed_low_multiply_raw_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedLowMultiplyRawWIGAndPhysicalMasks(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, length := range []byte{0, 4} {
+			for _, w := range []byte{0, 0x80} {
+				code := []byte{0xc4, 0xe2, 0x71 | length | w, 0x40, 0xd0}
+				ins, size, known, err := decodedX86PackedMultiplyLowInstruction(code, mode)
+				if !known || err != nil || size != len(code) || ins.Op != "VPMULLD" {
+					t.Fatalf("VEX.WIG does not select PMULLQ: mode=%d code=%x known=%v size=%d err=%v", mode, code, known, size, err)
+				}
+			}
+		}
+		for _, qword := range []bool{false, true} {
+			for length := byte(0); length < 3; length++ {
+				for mask := byte(1); mask < 8; mask++ {
+					for _, zero := range []bool{false, true} {
+						code := encodeX86EVEXPackedMultiplyLow(qword, length, int(mask), zero, 2, 1, 0)
+						ins, size, known, err := decodedX86PackedMultiplyLowInstruction(code, mode)
+						if !known || err != nil || size != len(code) || !ins.x86Encoded {
+							t.Fatalf("physical EVEX must not inherit named operand limit: mode=%d code=%x known=%v size=%d err=%v", mode, code, known, size, err)
+						}
+						arch := "amd64"
+						if mode == 32 {
+							arch = "386"
+						}
+						if _, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch); !known || err != nil {
+							t.Fatal("typed consumer lost decoded physical form", ins.Raw, err)
+						}
+						ins.x86Encoded = false
+						if _, _, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch); mode == 32 && err == nil {
+							t.Fatal("named mode32 instruction borrowed decoder identity")
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedLowMultiplyRawThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var encodings [][]byte
+	for _, length := range []byte{0, 4} {
+		for _, w := range []byte{0, 0x80} {
+			encodings = append(encodings, []byte{0xc4, 0xe2, 0x71 | length | w, 0x40, 0xd0})
+		}
+	}
+	for _, qword := range []bool{false, true} {
+		for length := byte(0); length < 3; length++ {
+			for _, mask := range []int{1, 7} {
+				for _, zero := range []bool{false, true} {
+					encodings = append(encodings, encodeX86EVEXPackedMultiplyLow(qword, length, mask, zero, 2, 1, 0))
+				}
+			}
+		}
+	}
+	var source, declarations strings.Builder
+	for i, code := range encodings {
+		fmt.Fprintf(&declarations, "func RawLow%d()\n", i)
+		fmt.Fprintf(&source, "TEXT ·RawLow%d(SB),4,$0-0\n", i)
+		for _, b := range code {
+			fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+		}
+		source.WriteString("RET\n")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "raw-low-multiply-"+api)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_low_multiply_result.go b/amd64_packed_low_multiply_result.go
new file mode 100644
index 000000000..db5c5c48d
--- /dev/null
+++ b/amd64_packed_low_multiply_result.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+// This numerical observer shares the complete W/D/Q operand grammars. It
+// supplies no caller region, native backing, pointer or raw-return permission.
+func x86ResultPackedLowMultiplyStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	low, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch)
+	form, bits := low.x86PackedBinaryForm, low.spec.laneBits
+	if !known {
+		word, wordKnown, wordErr := x86PackedWordMultiplyProperties(ins.Op, ins, arch)
+		if !wordKnown || word.spec.mode != amd64PackedWordMultiplyLow {
+			return false, false
+		}
+		form, bits, err = word.x86PackedBinaryForm, 16, wordErr
+	}
+	if err != nil || form.mmx {
+		return false, true
+	}
+	return x86ResultPackedLaneArithmeticStep(ins, form, bits, state, owned, arch), true
+}
+
+// A lane is numerical only when every byte of both input lanes is known.
+// This dependency rule is shared by low products and wrapping/saturating
+// arithmetic, not their operations or their independent memory permissions.
+func x86ResultPackedLaneArithmeticStep(ins Instr, form x86PackedBinaryForm, bits int, state *x86ResultState, owned []bool, arch string) bool {
+	return x86ResultPackedLaneArithmeticStepWithRead(ins, form, bits, state, owned, arch, false)
+}
+
+func x86ResultPackedLaneArithmeticStepWithRead(ins Instr, form x86PackedBinaryForm, bits int,
+	state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	if form.memory >= 0 {
+		memory := ins.Args[form.memory]
+		// Logical FP/AUTO bytes can establish numerical dependence, not the
+		// original native alignment. Legacy lowering checks that separately.
+		if !x86ResultReadWithNativeContinuation(ins, memory, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false
+		}
+	}
+	bytes := func(index int) uint64 {
+		if index == form.memory {
+			return x86CallerVectorByteMask(int64(form.byteWidth))
+		}
+		register, _ := amd64VectorRegisterIndex(ins.Args[index].Reg, form.byteWidth)
+		return state.vectorBytes(register)
+	}
+	first, second := bytes(form.first), bytes(form.second)
+	var initialized uint64
+	laneBytes := bits / 8
+	for index := 0; index < form.byteWidth; index += laneBytes {
+		lane := x86CallerVectorByteMask(int64(laneBytes)) << uint(index)
+		if first&lane == lane && second&lane == lane {
+			initialized |= lane
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if form.mask >= 0 && !form.zeroing {
+		initialized &= state.vectorBytes(destination)
+	}
+	state.writeVector(destination, form.byteWidth, initialized, form.legacy)
+	return true
+}
diff --git a/amd64_packed_low_multiply_runtime_test.go b/amd64_packed_low_multiply_runtime_test.go
new file mode 100644
index 000000000..f025042e0
--- /dev/null
+++ b/amd64_packed_low_multiply_runtime_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86LowMultiplyReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+
+typedef void (*kernel)(uint8_t *, const uint8_t *, const uint8_t *,
+                       uint64_t *, uint32_t *, uint64_t, uint64_t);
+
+static uint64_t little(const uint8_t *p, int bytes) {
+    uint64_t value = 0;
+    for (int i = 0; i < bytes; ++i) {
+        value |= (uint64_t)p[i] << (8 * i);
+    }
+    return value;
+}
+
+static int check(kernel fn, const char *name, int width, int bytes,
+                 int legacy, int masking, int broadcast, int memory, int dst) {
+    _Alignas(64) uint8_t a[64], b[64], out[192], oldA[64], oldB[64];
+    const uint64_t masks[] = {0, UINT64_MAX, 0x5555, UINT64_C(1) << 63};
+    for (int sample = 0; sample < 65; ++sample) {
+        for (int i = 0; i < 64; ++i) {
+            a[i] = (uint8_t)(sample * 127 + i * 53);
+            b[i] = (uint8_t)(sample * 17 - i * 91);
+        }
+        memcpy(oldA, a, 64);
+        memcpy(oldB, b, 64);
+        for (int seedIndex = 0; seedIndex < 2; ++seedIndex) {
+            uint64_t seed = seedIndex ? 0x8d5 : 0;
+            for (unsigned mi = 0; mi < sizeof(masks)/sizeof(masks[0]); ++mi) {
+                uint64_t mask = masks[mi];
+                uint64_t relevant = mask & ((UINT64_C(1) << (width / bytes)) - 1);
+                const uint8_t *input = memory && masking && !relevant ? NULL : a;
+                struct { uint64_t before, value, after; } flags = {11, 0, 13};
+                struct { uint32_t before, value, after; } csr = {17, 0, 19};
+                uint32_t initialCSR = _mm_getcsr();
+                memset(out, 0xa7, sizeof(out));
+                fn(out + 64, input, b, &flags.value, &csr.value, seed, mask);
+                if ((flags.value & 0x8d5) != seed || flags.before != 11 || flags.after != 13 ||
+                    csr.value != initialCSR || csr.before != 17 || csr.after != 19 ||
+                    memcmp(a, oldA, 64) || memcmp(b, oldB, 64)) {
+                    fprintf(stderr, "%s state/input/canary mismatch\n", name);
+                    return 1;
+                }
+                for (int i = 0; i < 192; ++i) {
+                    unsigned want = 0xa7;
+                    int offset = i - 64;
+                    if (offset >= 0 && offset < 64) {
+                        const uint8_t *old = dst == 0 ? a : b;
+                        want = legacy ? old[offset] : 0;
+                        if (offset < width) {
+                            int lane = offset / bytes;
+                            int active = !masking || ((mask >> lane) & 1);
+                            if (active) {
+                                uint64_t x = little(a + (broadcast ? 0 : lane * bytes), bytes);
+                                uint64_t y = little(b + lane * bytes, bytes);
+                                want = (uint8_t)((x * y) >> (8 * (offset % bytes)));
+                            } else {
+                                want = masking == 2 ? 0 : old[offset];
+                            }
+                        }
+                    }
+                    if (out[i] != want) {
+                        fprintf(stderr, "%s sample=%d mask=%llx byte=%d got=%x want=%x\n",
+                                name, sample, (unsigned long long)mask, i, out[i], want);
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+
+// This executes the portable LLVM result, not original AVX512 machine code.
+// Independent full-byte observations catch stale upper aliases and merging;
+// NULL with inactive/high-only masks catches eager E4 memory accesses.
+func TestCrossLinuxRuntimeMatrixX86PackedLowMultiplySoftware(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, destination := range []int{0, 1} {
+		t.Run(fmt.Sprint("destination-", destination), func(t *testing.T) {
+			var declarations, assembly, reference, checks strings.Builder
+			declarations.WriteString("package oracle\n")
+			reference.WriteString(x86LowMultiplyReference)
+			count := 0
+			for _, name := range []string{"PMULLD", "VPMULLD", "VPMULLQ"} {
+				legacy, bits := 0, 32
+				widths := []int{16, 32, 64}
+				if name == "PMULLD" {
+					legacy, widths = 1, []int{16}
+				}
+				if name == "VPMULLQ" {
+					bits = 64
+				}
+				for _, width := range widths {
+					bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+					for source := 0; source < 3; source++ {
+						for masking := 0; masking < 3; masking++ {
+							if legacy != 0 && (masking != 0 || source == 2 || destination == 0) {
+								continue
+							}
+							fn := fmt.Sprint("Low", count)
+							count++
+							row, first, broadcast, memory := name, bank+"0", 0, 0
+							if source != 0 {
+								first, memory = "(DI)", 1
+							}
+							if source == 2 {
+								row, broadcast = row+".BCST", 1
+							}
+							if masking == 2 {
+								row += ".Z"
+							}
+							row += " " + first + "," + bank + "1"
+							if masking != 0 {
+								row += ",K1"
+							}
+							if legacy == 0 {
+								row += fmt.Sprintf(",%s%d", bank, destination)
+							}
+							fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed,mask uint64)\n", fn)
+							fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-56\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\nMOVQ flags+24(FP),CX\nMOVQ csr+32(FP),BX\nVMOVUPS (SI),Z1\n", fn)
+							if source == 0 || destination == 0 {
+								// For memory forms Z0's merge source uses B; do not
+								// read the possibly inactive source address early.
+								base := "DI"
+								if source != 0 {
+									base = "SI"
+								}
+								fmt.Fprintf(&assembly, "VMOVUPS (%s),Z0\n", base)
+							}
+							assembly.WriteString("MOVQ mask+48(FP),AX\nKMOVQ AX,K1\nPUSHQ seed+40(FP)\nPOPFQ\n")
+							fmt.Fprintf(&assembly, "%s\nVMOVUPS Z%d,(DX)\nPUSHFQ\nPOPQ AX\nMOVQ AX,(CX)\nSTMXCSR (BX)\nRET\n", row, destination)
+							fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t*,uint32_t*,uint64_t,uint64_t);\n", fn)
+							old := destination
+							if memory != 0 {
+								old = 1
+							}
+							fmt.Fprintf(&checks, "    if (check(%s,%q,%d,%d,%d,%d,%d,%d,%d)) return 1;\n", fn, row, width, bits/8, legacy, masking, broadcast, memory, old)
+						}
+					}
+				}
+			}
+			if count > 96 {
+				t.Fatal("runtime batch exceeds its resource bound", count)
+			}
+			reference.WriteString("int main(void) {\n" + checks.String() + "    return 0;\n}\n")
+			goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+			pkg := mustGoPackage(t, "oracle", declarations.String())
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]FuncSig{}
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sigs[name] = x86WordMultiplySignature(t, pkg, name)
+			}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple,
+				Sigs: sigs, ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "low-multiply", ir, reference.String(), level)
+				})
+			}
+			t.Logf("%d kernels, 65 inputs, two FLAGS seeds, four masks; full aliases, canaries and inactive NULL sources", count)
+		})
+	}
+}
diff --git a/amd64_packed_move_zero_store_test.go b/amd64_packed_move_zero_store_test.go
new file mode 100644
index 000000000..de6c05408
--- /dev/null
+++ b/amd64_packed_move_zero_store_test.go
@@ -0,0 +1,403 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Independent EVEX opcodes whose Go-accepted .Z memory destination requires
+// architectural #UD. Intel XED's memory patterns require ZEROING=0 for both
+// packed moves and all six compression opcodes. VMOVDQA/DQU are VEX-only.
+var x86PackedZeroStoreOpcodes = []string{
+	"VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS",
+	"VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64",
+	"VCOMPRESSPS", "VCOMPRESSPD", "VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ",
+}
+
+func x86PackedZeroStoreInstruction(name, instruction string) string {
+	return fmt.Sprintf("TEXT %s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+}
+
+func x86PackedZeroStoreSource() (string, map[string]FuncSig, []string) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var names []string
+	for _, opcode := range x86PackedZeroStoreOpcodes {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			name := "fault" + opcode + bank
+			source.WriteString(x86PackedZeroStoreInstruction(name, fmt.Sprintf("%s.Z %s0,K1,(AX)", opcode, bank)))
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+			names = append(names, name)
+		}
+	}
+	return source.String(), sigs, names
+}
+
+func TestX86PackedZeroMemoryStorePreservesUndefinedOpcode(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, sigs, names := x86PackedZeroStoreSource()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			trap := `call void asm sideeffect "ud2", "~{memory}"()`
+			if strings.Count(ir, trap) != len(names) || strings.Contains(ir, "call void @llvm.masked.store.") {
+				t.Fatalf("Go-accepted EVEX.z memory stores must deliver #UD before reading registers or memory; traps=%d want=%d", strings.Count(ir, trap), len(names))
+			}
+			compileLLVMToObject(t, llc, target.triple, "zero-store.ll", "zero-store.o", ir)
+		})
+	}
+}
+
+func TestX86PackedZeroMemoryStoreFaultPrecedesFPBoundsAndMaskReads(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range x86PackedZeroStoreOpcodes {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				instruction := Instr{Op: Op(opcode + ".Z"), Args: []Operand{
+					{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "K1"},
+					{Kind: OpFP, FPOffset: 1 << 20},
+				}}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before := output.Len()
+				lower := ctx.lowerPackedVectorMove
+				if strings.Contains(opcode, "COMPRESS") {
+					lower = ctx.lowerPackedCompress
+				}
+				recognized, terminated, err := lower(instruction.Op, instruction)
+				if !recognized || !terminated || err != nil || output.String()[before:] != "  call void asm sideeffect \"ud2\", \"~{memory}\"()\n  unreachable\n" {
+					t.Fatalf("%s invalid encoding evaluated nonexistent FP/mask/register data before #UD: %t/%t/%v", arch, recognized, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func x86PackedFirstGoInstructionBytes(t *testing.T, arch, instruction string) []byte {
+	t.Helper()
+	listing, err := x86ScalarLiteralGoListing(t, arch, "TEXT probe(SB),4,$0-0\n"+instruction+"\nRET\n")
+	if err != nil {
+		t.Fatalf("actual Go packed-move object: %v\n%s", err, listing)
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 7 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+			continue
+		}
+		bytes := make([]byte, 6)
+		for index := range bytes {
+			value, err := strconv.ParseUint(fields[index+1], 16, 8)
+			if err != nil {
+				t.Fatalf("actual Go object byte: %v\n%s", err, listing)
+			}
+			bytes[index] = byte(value)
+		}
+		return bytes
+	}
+	t.Fatalf("actual Go object lacks packed-move bytes:\n%s", listing)
+	return nil
+}
+
+func TestX86PackedZeroMemoryStoreActualGoAndLLVM22Encoding(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc not found")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, opcode := range x86PackedZeroStoreOpcodes {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				instruction := fmt.Sprintf("%s %s0,K1,(AX)", opcode, bank)
+				normal := x86PackedFirstGoInstructionBytes(t, arch, instruction)
+				zero := x86PackedFirstGoInstructionBytes(t, arch, strings.Replace(instruction, " ", ".Z ", 1))
+				if normal[0] != 0x62 || normal[3]&0x80 != 0 || zero[3]&0x80 == 0 {
+					t.Fatalf("%s %s lacks independent EVEX.z witness: normal=%x zero=%x", arch, instruction, normal, zero)
+				}
+				wantW := strings.HasSuffix(opcode, "64") || opcode == "VMOVDQU16" || strings.HasSuffix(opcode, "PD") ||
+					opcode == "VPCOMPRESSW" || opcode == "VPCOMPRESSQ"
+				if (normal[2]&0x80 != 0) != wantW {
+					t.Fatalf("actual Go object changed the native element selector: %s %s bytes=%x", arch, instruction, normal)
+				}
+				for index := range normal {
+					wanted := normal[index]
+					if index == 3 {
+						wanted |= 0x80
+					}
+					if zero[index] != wanted {
+						t.Fatalf(".Z changed more than the native EVEX.z bit: %s %s", arch, instruction)
+					}
+				}
+				for _, test := range []struct {
+					bytes   []byte
+					invalid bool
+				}{{normal, false}, {zero, true}} {
+					var input strings.Builder
+					for _, value := range test.bytes {
+						fmt.Fprintf(&input, "0x%02x ", value)
+					}
+					ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+					command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple,
+						"--mattr=+avx512f,+avx512bw,+avx512vl,+avx512vbmi2")
+					command.Stdin = strings.NewReader(input.String())
+					command.WaitDelay = 2 * time.Second
+					output, err := command.CombinedOutput()
+					cancel()
+					// llvm-mc can return zero while diagnosing rejected bytes.
+					invalid := strings.Contains(string(output), "invalid instruction encoding")
+					family := "VMOV"
+					if strings.Contains(opcode, "COMPRESS") {
+						family = "COMPRESS"
+					}
+					if err != nil || invalid != test.invalid || !test.invalid && !strings.Contains(strings.ToUpper(string(output)), family) {
+						t.Fatalf("%s %s invalid=%t: LLVM 22 diagnostic mismatch: %v\n%s", arch, instruction, test.invalid, err, output)
+					}
+					// LLVM 22's 32-bit decoder aliases some W1 move spellings
+					// to W0 names. Verify the independent W byte above and the
+					// exact opcode in 64-bit decode, not the aliased 32-bit name.
+					if !test.invalid {
+						ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+						command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=x86_64-unknown-linux-gnu",
+							"--mattr=+avx512f,+avx512bw,+avx512vl,+avx512vbmi2")
+						command.Stdin = strings.NewReader(input.String())
+						command.WaitDelay = 2 * time.Second
+						output, err := command.CombinedOutput()
+						cancel()
+						if err != nil || !strings.Contains(strings.ToUpper(string(output)), opcode) || strings.Contains(string(output), "invalid instruction encoding") {
+							t.Fatalf("actual Go object does not decode as the exact opcode: %s %s: %v\n%s", arch, instruction, err, output)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedZeroMemoryStoreFault(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the separately required Linux/amd64 packed-move fault oracle")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source, sigs, names := x86PackedZeroStoreSource()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	var oracle strings.Builder
+	oracle.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _WIN32
+#include <process.h>
+#include <windows.h>
+#else
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+
+`)
+	for _, name := range names {
+		fmt.Fprintf(&oracle, "extern void %s(void);\n", name)
+	}
+	oracle.WriteString("\nstatic void (*fault_functions[])(void) = {\n")
+	for _, name := range names {
+		fmt.Fprintf(&oracle, "    %s,\n", name)
+	}
+	oracle.WriteString(`};
+
+int main(int argc, char **argv) {
+#ifdef _WIN32
+    SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
+    if (argc == 2) {
+        unsigned index = (unsigned)strtoul(argv[1], 0, 10);
+        if (index >= sizeof(fault_functions)/sizeof(fault_functions[0])) return 6;
+        fault_functions[index]();
+        return 3;
+    }
+    for (unsigned i = 0; i < sizeof(fault_functions)/sizeof(fault_functions[0]); i++) {
+        char index[16];
+        snprintf(index, sizeof(index), "%u", i);
+        intptr_t status = _spawnl(_P_WAIT, argv[0], argv[0], index, NULL);
+        if ((uint32_t)status != UINT32_C(0xc000001d)) return 5;
+    }
+#else
+    (void)argc;
+    (void)argv;
+    struct rlimit no_core = {0, 0};
+    if (setrlimit(RLIMIT_CORE, &no_core)) return 1;
+    for (unsigned i = 0; i < sizeof(fault_functions)/sizeof(fault_functions[0]); i++) {
+        pid_t child = fork();
+        if (child < 0) return 2;
+        if (!child) { fault_functions[i](); _exit(3); }
+        int status;
+        if (waitpid(child, &status, 0) != child) return 4;
+        if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGILL) return 5;
+    }
+#endif
+    return 0;
+}
+`)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-zero-store-fault", triple, ir, oracle.String(), runner)
+
+	// No preceding valid AVX512 instruction is executed. EVEX.z=1 with a
+	// memory destination is always #UD, irrespective of mask/address values.
+	var mainGo strings.Builder
+	mainGo.WriteString("package main\nimport \"os\"\n")
+	for _, name := range names {
+		fmt.Fprintf(&mainGo, "func %s()\n", name)
+	}
+	mainGo.WriteString("func main() { switch os.Args[1] {\n")
+	for _, name := range names {
+		fmt.Fprintf(&mainGo, "case %q: %s()\n", name, name)
+	}
+	mainGo.WriteString("} }\n")
+	dir := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":        "module example.com/packed-zero-store\n\ngo 1.20\n",
+		"main.go":       mainGo.String(),
+		"fault_amd64.s": strings.ReplaceAll(source, "TEXT fault", "TEXT ·fault"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-packed-zero-store")
+	if runtime.GOOS == "windows" {
+		executable += ".exe"
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	build := exec.CommandContext(ctx, "go", "build", "-o", executable, ".")
+	build.Dir, build.Env = dir, append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=amd64")
+	build.WaitDelay = 2 * time.Second
+	if output, err := build.CombinedOutput(); err != nil {
+		t.Fatalf("original Go packed-store build: %v\n%s", err, output)
+	}
+	for _, name := range names {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		args := append(append([]string(nil), runner...), executable, name)
+		command := exec.CommandContext(ctx, args[0], args[1:]...)
+		command.Env = append(os.Environ(), "GOTRACEBACK=single")
+		command.WaitDelay = 2 * time.Second
+		output, err := command.CombinedOutput()
+		cancel()
+		exit, ok := err.(*exec.ExitError)
+		if !ok || exit.ExitCode() != 2 || !x86GoPackedStoreFaultDiagnostic(runtime.GOOS, name, string(output)) {
+			t.Fatalf("original Go %s did not deliver SIGILL: %v\n%s", name, err, output)
+		}
+	}
+}
+
+var x86GoPackedStoreFatalFault = regexp.MustCompile(`^fatal error: fault\n\n?\[signal 0xc000001d code=0x[0-9a-f]+ addr=0x[0-9a-f]+ pc=0x[0-9a-f]+\]\n`)
+
+func x86GoPackedStoreFaultDiagnostic(goos, name, output string) bool {
+	output = strings.ReplaceAll(output, "\r\n", "\n")
+	if strings.Contains(output, "\r") {
+		return false
+	}
+	matched := strings.HasPrefix(output, "SIGILL: illegal instruction\n")
+	if goos == "windows" {
+		// Current Go converts the native exception to sigpanic; older SDKs
+		// print the unhandled exception directly. Both must identify #UD,
+		// not an ordinary panic, access violation or just an exit status 2.
+		// Go's fatal header can have either one newline or a separating
+		// blank line before the complete native signal record.
+		matched = strings.HasPrefix(output, "Exception 0xc000001d ") || x86GoPackedStoreFatalFault.MatchString(output)
+	}
+	if !matched {
+		return false
+	}
+	lines := strings.Split(output, "\n")
+	for index, line := range lines {
+		if line == "main."+name+"()" && index+1 < len(lines) {
+			location := strings.ReplaceAll(lines[index+1], "\\", "/")
+			_, position, found := strings.Cut(location, "/fault_amd64.s:")
+			fields := strings.Fields(position)
+			if !found || len(fields) == 0 {
+				continue
+			}
+			lineNumber, err := strconv.ParseUint(fields[0], 10, 31)
+			if err == nil && lineNumber > 0 {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func TestX86GoPackedStoreFaultDiagnostic(t *testing.T) {
+	const stack = "\nmain.faultVMOVAPDX()\n\tC:/fixture/fault_amd64.s:2 fp=0x123 pc=0x456\n"
+	const modern = "fatal error: fault\n\n[signal 0xc000001d code=0x0 addr=0x0 pc=0x456]\n"
+	for _, test := range []struct {
+		name, goos, output string
+		valid              bool
+	}{
+		{"Unix", "linux", "SIGILL: illegal instruction\nPC=0x456\n" + stack, true},
+		{"Windows exception", "windows", "Exception 0xc000001d 0x0 0x0 0x456\n" + stack, true},
+		{"Windows sigpanic", "windows", modern + stack, true},
+		{"Windows native sigpanic", "windows", strings.Replace(modern, "fault\n\n", "fault\n", 1) + stack, true},
+		{"Windows native newlines", "windows", strings.ReplaceAll(modern+stack, "\n", "\r\n"), true},
+		{"Windows native sigpanic CRLF", "windows", strings.ReplaceAll(strings.Replace(modern, "fault\n\n", "fault\n", 1)+stack, "\n", "\r\n"), true},
+		{"extra fatal blank line", "windows", strings.Replace(modern, "fault\n\n", "fault\n\n\n", 1) + stack, false},
+		{"malformed signal record", "windows", strings.Replace(modern, " pc=0x456]", " pc=unobserved]", 1) + stack, false},
+		{"unterminated signal record", "windows", strings.Replace(modern, "0x456]", "0x456", 1) + stack, false},
+		{"missing fault address", "windows", strings.Replace(modern, " addr=0x0", "", 1) + stack, false},
+		{"ordinary panic", "windows", "panic: Exception 0xc000001d\n" + stack, false},
+		{"different signal", "windows", strings.ReplaceAll(modern+stack, "0xc000001d", "0xc0000005"), false},
+		{"partial exception code", "windows", "Exception 0xc000001d0\n" + stack, false},
+		{"missing tested frame", "windows", modern, false},
+		{"wrong tested frame", "windows", modern + strings.ReplaceAll(stack, "faultVMOVAPDX", "faultOther"), false},
+		{"wrong source", "windows", modern + strings.ReplaceAll(stack, "fault_amd64.s", "main.go"), false},
+		{"malformed source position", "windows", modern + strings.ReplaceAll(stack, ".s:2 ", ".s:2invalid "), false},
+		{"zero source position", "windows", modern + strings.ReplaceAll(stack, ".s:2 ", ".s:0 "), false},
+		{"bare native carriage return", "windows", modern + strings.ReplaceAll(stack, "fp=", "\rfp="), false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := x86GoPackedStoreFaultDiagnostic(test.goos, "faultVMOVAPDX", test.output); got != test.valid {
+				t.Fatalf("actual Go illegal-instruction diagnostic: got %t, want %t", got, test.valid)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_narrow_forms.go b/amd64_packed_narrow_forms.go
new file mode 100644
index 000000000..d90a86be2
--- /dev/null
+++ b/amd64_packed_narrow_forms.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "strings"
+
+type x86PackedNarrowSpec struct {
+	x86PackedBinarySpec
+	inputBits, outputBits int
+	mode                  amd64PackedNarrowMode
+}
+
+// Go's ymm rows admit MMX only in amd64 mode; PACKUSDW is yxm_q4.
+// All four V rows use _yvandnpd, with N4 broadcast only for dword inputs.
+// Memory exception behavior is E4NF (SSWB/USWB: E4NF.nb), independently
+// of their output-lane writemask. No initialized bank or ABI is granted here.
+var x86PackedNarrowSpecs = map[Op]x86PackedNarrowSpec{
+	"PACKSSLW":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 32, 16, amd64PackedNarrowSigned},
+	"PACKSSWB":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, 8, amd64PackedNarrowSigned},
+	"PACKUSDW":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}, 32, 16, amd64PackedNarrowUnsigned},
+	"PACKUSWB":  {x86PackedBinarySpec{encoding: x86PackedLogicalLegacyInteger}, 16, 8, amd64PackedNarrowUnsigned},
+	"VPACKSSDW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, 32, 16, amd64PackedNarrowSigned},
+	"VPACKSSWB": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, 8, amd64PackedNarrowSigned},
+	"VPACKUSDW": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, broadcastBytes: 4, zeroing: true}, 32, 16, amd64PackedNarrowUnsigned},
+	"VPACKUSWB": {x86PackedBinarySpec{encoding: x86PackedLogicalVEXOrEVEX, zeroing: true}, 16, 8, amd64PackedNarrowUnsigned},
+}
+
+type x86PackedNarrowForm struct {
+	x86PackedBinaryForm
+	spec   x86PackedNarrowSpec
+	source Operand
+}
+
+// Numerical dependencies only. Each narrowed element needs its complete
+// signed input, independently within each source half of a 128-bit chunk.
+// This never shrinks the native memory tuple or supplies a mask/pointer role.
+func x86PackedNarrowDefinedBytes(form x86PackedNarrowForm, first, second, old uint64) uint64 {
+	inputBytes, outputBytes := form.spec.inputBits/8, form.spec.outputBits/8
+	chunkBytes := 16
+	if form.byteWidth < chunkBytes {
+		chunkBytes = form.byteWidth
+	}
+	half := chunkBytes / 2
+	var known uint64
+	for output := 0; output < form.byteWidth; output += outputBytes {
+		chunk, local := output/chunkBytes*chunkBytes, output%chunkBytes
+		input, source := chunk+(local%half)/outputBytes*inputBytes, second
+		if local >= half {
+			source = first
+		}
+		needed := x86CallerVectorByteMask(int64(inputBytes)) << uint(input)
+		if source&needed == needed {
+			known |= x86CallerVectorByteMask(int64(outputBytes)) << uint(output)
+		}
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	return known
+}
+
+func x86PackedNarrowProperties(ins Instr, goarch string) (x86PackedNarrowForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86PackedNarrowSpecs[Op(base)]
+	if !known {
+		return x86PackedNarrowForm{}, false, nil
+	}
+	binary, source, started, err := x86PackedBinaryPhysicalSource(ins.Op, ins, goarch, spec.x86PackedBinarySpec, "packed narrow")
+	if !started {
+		return x86PackedNarrowForm{}, true, err
+	}
+	if err != nil && source.Kind != OpInvalid {
+		// Keep the prior mode32 Context precedence when both a register and
+		// physical address are invalid. Rejected forms never expose a source.
+		if modeErr := x86Mode32VectorRegisterContext(ins, goarch); modeErr != nil {
+			err = modeErr
+		}
+		source = Operand{}
+	}
+	return x86PackedNarrowForm{binary, spec, source}, true, err
+}
diff --git a/amd64_packed_narrow_independent_runtime_test.go b/amd64_packed_narrow_independent_runtime_test.go
new file mode 100644
index 000000000..c213acd31
--- /dev/null
+++ b/amd64_packed_narrow_independent_runtime_test.go
@@ -0,0 +1,468 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// The independent oracle describes the ISA, not production properties. Go's
+// reversed operands put its second source in the low half of each 128-bit lane.
+type x86NarrowOracleFamily struct {
+	legacy, vector string
+	inputBytes     int
+	unsigned       bool
+}
+
+type x86NarrowOracleRow struct {
+	family               x86NarrowOracleFamily
+	bank                 string
+	width, source, alias int
+	masking              int // 0: none, 1: merge, 2: zero
+	legacy               bool
+}
+
+func x86NarrowOracleRows() []x86NarrowOracleRow {
+	var rows []x86NarrowOracleRow
+	for _, family := range x86NarrowOracleFamilies {
+		for _, bank := range []string{"X", "M"} {
+			if bank == "M" && family.legacy == "PACKUSDW" {
+				continue
+			}
+			width := 16
+			if bank == "M" {
+				width = 8
+			}
+			for source := 0; source < 2; source++ {
+				for alias := 0; alias < 2; alias++ {
+					rows = append(rows, x86NarrowOracleRow{family, bank, width, source, alias, 0, true})
+				}
+			}
+		}
+		for widthIndex, bank := range []string{"X", "Y", "Z"} {
+			for source := 0; source < 3; source++ {
+				if source == 2 && family.inputBytes != 4 {
+					continue
+				}
+				for alias := 0; alias < 3; alias++ {
+					for mask := 0; mask < 3; mask++ {
+						rows = append(rows, x86NarrowOracleRow{family, bank, 16 << widthIndex, source, alias, mask, false})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86NarrowOracleRow) instruction() (string, string) {
+	first, destination := row.bank+"0", row.bank+fmt.Sprint(row.alias)
+	if row.legacy {
+		destination = row.bank + "1"
+		if row.alias == 1 {
+			first = destination
+		}
+	}
+	if row.source != 0 {
+		first = "(CX)"
+		if row.legacy && row.alias == 1 {
+			first = "(DX)"
+		}
+	}
+	if row.legacy {
+		return row.family.legacy + " " + first + "," + destination, destination
+	}
+	op := row.family.vector
+	if row.source == 2 {
+		op += ".BCST"
+	}
+	if row.masking == 2 {
+		op += ".Z"
+	}
+	mask := ""
+	if row.masking != 0 {
+		mask = "K1,"
+	}
+	return op + " " + first + "," + row.bank + "1," + mask + destination, destination
+}
+
+// Each scalar is signed before clamping, including the unsigned output forms.
+// This reference does not call or reproduce production's vector/typed helpers.
+const x86NarrowIndependentCReference = `
+static const int32_t edges[]={
+ INT32_MIN,-65537,-32769,-32768,-32767,-257,-256,-129,-128,-127,-1,0,1,
+ 126,127,128,129,254,255,256,257,32766,32767,32768,32769,
+ 65534,65535,65536,65537,INT32_MAX-1,INT32_MAX};
+static void fill(uint8_t *out,int bytes,unsigned sample,unsigned salt) {
+ for(int lane=0;lane<64/bytes;++lane) {
+  int32_t value=edges[(sample+salt+lane*7)%(sizeof(edges)/sizeof(edges[0]))];
+  if(bytes==4) memcpy(out+lane*bytes,&value,4);
+  else {int16_t small=(int16_t)value;memcpy(out+lane*bytes,&small,2);}
+ }
+}
+static void independent_pack(uint8_t *out,const uint8_t *first,const uint8_t *second,
+                             int width,int inputBytes,int unsignedOutput,int broadcast) {
+ int chunk=width==8?8:16,outputBytes=inputBytes/2;
+ int64_t minimum=unsignedOutput?0:-(INT64_C(1)<<(outputBytes*8-1));
+ int64_t maximum=unsignedOutput?(INT64_C(1)<<(outputBytes*8))-1:(INT64_C(1)<<(outputBytes*8-1))-1;
+ for(int start=0;start<width;start+=chunk) for(int source=0;source<2;++source) {
+  const uint8_t *input=source?first:second;
+  for(int lane=0;lane<chunk/inputBytes;++lane) {
+   int index=broadcast&&source?0:start+lane*inputBytes;
+   int64_t value;
+   if(inputBytes==4) {int32_t v;memcpy(&v,input+index,4);value=v;}
+   else {int16_t v;memcpy(&v,input+index,2);value=v;}
+   if(value<minimum) value=minimum;
+   if(value>maximum) value=maximum;
+   uint32_t result=(uint32_t)value;
+   int destination=start+source*(chunk/2)+lane*outputBytes;
+   for(int byte=0;byte<outputBytes;++byte) out[destination+byte]=(uint8_t)(result>>(byte*8));
+  }
+ }
+}
+`
+
+func x86NarrowIndependentAssembly(name string, row x86NarrowOracleRow) string {
+	var assembly strings.Builder
+	fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-52\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nMOVQ mask+32(FP),R9\n", name)
+	// Prepare status before entering the uninterrupted physical MMX region.
+	assembly.WriteString("LDMXCSR csr+48(FP)\nPUSHQ flags+40(FP)\nPOPFQ\n")
+	if row.bank == "M" {
+		assembly.WriteString("MOVQ (CX),M0\nMOVQ (DX),M1\n")
+	} else {
+		assembly.WriteString("VMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nKMOVQ R9,K1\n")
+	}
+	instruction, destination := row.instruction()
+	fmt.Fprintln(&assembly, instruction)
+	if row.bank == "M" {
+		fmt.Fprintf(&assembly, "MOVQ %s,(AX)\nEMMS\n", destination)
+	} else {
+		fmt.Fprintf(&assembly, "VMOVUPS Z%s,(AX)\n", destination[1:])
+	}
+	assembly.WriteString("PUSHFQ\nPOPQ R10\nMOVQ R10,64(AX)\nSTMXCSR 72(AX)\nRET\n")
+	return assembly.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedNarrowIndependentWholeBytes(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	rows := x86NarrowOracleRows()
+	var assembly, declarations, table, main strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	main.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef void (*kernel)(void*,const void*,const void*,const void*,uint64_t,uint64_t,uint32_t);
+`)
+	for index, row := range rows {
+		name := fmt.Sprintf("numeric%d", index)
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte,mask,flags uint64,csr uint32)\n", name)
+		assembly.WriteString(x86NarrowIndependentAssembly(name, row))
+		fmt.Fprintf(&main, "extern void %s(void*,const void*,const void*,const void*,uint64_t,uint64_t,uint32_t);\n", name)
+		fmt.Fprintf(&table, "{%s,%d,%d,%t,%d,%d,%d,%t},\n", name, row.width, row.family.inputBytes,
+			row.family.unsigned, row.source, row.alias, row.masking, row.legacy)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	main.WriteString("static const struct {kernel run;int width,bytes,uns,source,alias,masking,legacy;} cases[]={\n" + table.String() + "};\n")
+	main.WriteString(x86NarrowIndependentCReference)
+	main.WriteString(`
+int main(void) {
+ unsigned saved;__asm__ volatile("stmxcsr %0":"=m"(saved));
+ const uint32_t profiles[]={0x1f80,0x3fc1,0x5f82,0x9fe5};
+ unsigned long long observations=0;
+ for(unsigned row=0;row<sizeof(cases)/sizeof(cases[0]);++row) {
+  int lanes=cases[row].width/(cases[row].bytes/2);
+  for(unsigned sample=0;sample<32;++sample) for(int select=0;select<lanes+4;++select)
+  for(unsigned profile=0;profile<4;++profile) for(unsigned seed=0;seed<2;++seed) {
+   _Alignas(64) uint8_t a[64],b[64],old[64],beforeA[64],beforeB[64],beforeOld[64];
+   uint8_t output[82],want[82],packed[64];
+   fill(a,cases[row].bytes,sample,0);fill(b,cases[row].bytes,sample,13);
+   for(int i=0;i<64;++i) old[i]=(uint8_t)(0x91+i*11);
+   memcpy(beforeA,a,64);memcpy(beforeB,b,64);memcpy(beforeOld,old,64);
+   memset(output,0xc3,sizeof(output));memcpy(want,output,sizeof(want));
+   uint64_t mask;
+   if(select==0) mask=0;
+   else if(select==1) mask=UINT64_MAX;
+   else if(select==2) mask=UINT64_C(0xaaaaaaaaaaaaaaaa);
+   else if(select==3) mask=lanes==64?0:UINT64_MAX<<lanes;
+   else mask=UINT64_C(1)<<(select-4);
+   uint64_t flags=2|(seed?0x8d5:0);
+   cases[row].run(output+1,a,b,old,mask,flags,profiles[profile]);
+   const uint8_t *first=cases[row].legacy&&cases[row].alias?b:a;
+   independent_pack(packed,first,b,cases[row].width,cases[row].bytes,cases[row].uns,cases[row].source==2);
+   const uint8_t *previous=cases[row].legacy?b:cases[row].alias==0?a:cases[row].alias==1?b:old;
+   for(int i=0;i<64;++i) {
+    uint8_t value=cases[row].width==8?0xc3:cases[row].legacy?previous[i]:0;
+    if(i<cases[row].width) {
+     value=packed[i];
+     if(cases[row].masking&&!(mask>>(i/(cases[row].bytes/2))&1))
+      value=cases[row].masking==2?0:previous[i];
+    }
+    want[1+i]=value;
+   }
+   uint64_t observedFlags;uint32_t observedCSR;
+   memcpy(&observedFlags,output+65,8);memcpy(want+65,&observedFlags,8);
+   memcpy(&observedCSR,output+73,4);memcpy(want+73,&observedCSR,4);
+   ++observations;
+   if((observedFlags&0x8d5)!=(flags&0x8d5)||observedCSR!=profiles[profile]||
+      memcmp(output,want,sizeof(output))||memcmp(a,beforeA,64)||memcmp(b,beforeB,64)||memcmp(old,beforeOld,64)) {
+    fprintf(stderr,"PACK row=%u width=%d inputBytes=%d unsigned=%d source=%d alias=%d masking=%d legacy=%d sample=%u mask=%llx flags=%llx csr=%x\n",
+      row,cases[row].width,cases[row].bytes,cases[row].uns,cases[row].source,cases[row].alias,cases[row].masking,
+      cases[row].legacy,sample,(unsigned long long)mask,(unsigned long long)observedFlags,observedCSR);
+    for(unsigned i=0;i<sizeof(output);++i) if(output[i]!=want[i]) fprintf(stderr,"byte%u got=%u want=%u\n",i,output[i],want[i]);
+    return 1;
+   }
+  }
+ }
+ __asm__ volatile("ldmxcsr %0"::"m"(saved));
+ printf("PACK kernels=%zu observations=%llu fullAliasBytes=64 statusMask=8d5\n",sizeof(cases)/sizeof(cases[0]),observations);
+ return 0;
+}
+`)
+	// C booleans are numeric metadata, not instruction/property producers.
+	cSource := strings.NewReplacer(",true,", ",1,", ",false,", ",0,", ",true}", ",1}", ",false}", ",0}").Replace(main.String())
+	observations := 0
+	for _, row := range rows {
+		observations += (row.width/(row.family.inputBytes/2) + 4) * 32 * 4 * 2
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86MulDivRoundOptimize(t, input)
+			}
+			output := execution.compileAndRunLLVM(t, "narrow-independent-numeric", input, cSource, level)
+			want := fmt.Sprintf("PACK kernels=%d observations=%d fullAliasBytes=64 statusMask=8d5\n", len(rows), observations)
+			if string(output) != want {
+				t.Fatalf("incomplete independent numerical denominator: %q want %q", output, want)
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+	t.Logf("%d independent scalar-reference kernels: original SSE/MMX is a separate gate; VEX/EVEX software is not native ISA execution", len(rows))
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedNarrowOriginalLegacyOracle(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, table strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	count := 0
+	for _, row := range x86NarrowOracleRows() {
+		if !row.legacy {
+			continue // Actual AVX/AVX512 kernels require an independent native ISA axis.
+		}
+		name := fmt.Sprintf("original%d", count)
+		count++
+		fmt.Fprintf(&declarations, "func %s(out *[32]byte,a,b *[64]byte,flags uint64,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-36\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nSTMXCSR saved-4(SP)\nLDMXCSR csr+32(FP)\n", name)
+		move := "MOVOU"
+		if row.bank == "M" {
+			move = "MOVQ"
+		}
+		fmt.Fprintf(&assembly, "%s (CX),%s0\n%s (DX),%s1\nPUSHQ flags+24(FP)\nPOPFQ\n", move, row.bank, move, row.bank)
+		instruction, destination := row.instruction()
+		fmt.Fprintf(&assembly, "%s\n%s %s,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,16(AX)\nSTMXCSR 24(AX)\n", instruction, move, destination)
+		if row.bank == "M" {
+			assembly.WriteString("EMMS\n")
+		}
+		assembly.WriteString("LDMXCSR saved-4(SP)\nRET\n")
+		fmt.Fprintf(&table, "{%s,%d,%d,%t,%d},\n", name, row.width, row.family.inputBytes, row.family.unsigned, row.alias)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	// A Go caller invokes the unchanged assembled body. Its expectation is an
+	// independent signed scalar clamp, not the translated IR or a native intrinsic.
+	tests := `package narroworacle
+import("testing";"encoding/binary";"runtime";"unsafe")
+type kernel func(*[32]byte,*[64]byte,*[64]byte,uint64,uint32)
+var cases=[]struct{run kernel;width,bytes int;unsigned bool;alias int}{
+` + table.String() + `}
+var edges=[]int64{
+ -2147483648,-65537,-32769,-32768,-32767,-257,-256,-129,-128,-127,-1,0,1,
+ 126,127,128,129,254,255,256,257,32766,32767,32768,32769,65534,65535,65536,65537,2147483646,2147483647}
+func aligned(buffer *[128]byte)*[64]byte {
+ offset:=int((-uintptr(unsafe.Pointer(&buffer[0])))&63)
+ return (*[64]byte)(unsafe.Pointer(&buffer[offset]))
+}
+func fill(out *[64]byte,bytes,sample,salt int) {
+ for lane:=0;lane<64/bytes;lane++ {
+  value:=edges[(sample+salt+lane*7)%len(edges)]
+  if bytes==4 {binary.LittleEndian.PutUint32(out[lane*bytes:],uint32(value))
+  } else {binary.LittleEndian.PutUint16(out[lane*bytes:],uint16(value))}
+ }
+}
+func reference(first,second *[64]byte,width,bytes int,unsigned bool)[16]byte {
+ var out [16]byte
+ half:=width/2; outputBytes:=bytes/2
+ minimum:=-(int64(1)<<(outputBytes*8-1));maximum:=(int64(1)<<(outputBytes*8-1))-1
+ if unsigned {minimum=0;maximum=(int64(1)<<(outputBytes*8))-1}
+ for source:=0;source<2;source++ {
+  input:=second;if source==1 {input=first}
+  for lane:=0;lane<width/bytes;lane++ {
+   var value int64
+   if bytes==4 {value=int64(int32(binary.LittleEndian.Uint32(input[lane*bytes:])))
+   } else {value=int64(int16(binary.LittleEndian.Uint16(input[lane*bytes:])))}
+   if value<minimum {value=minimum};if value>maximum {value=maximum}
+   for byteIndex:=0;byteIndex<outputBytes;byteIndex++ {
+    out[source*half+lane*outputBytes+byteIndex]=byte(uint64(value)>>(byteIndex*8))
+   }
+  }
+ }
+ return out
+}
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread();defer runtime.UnlockOSThread()
+ profiles:=[]uint32{0x1f80,0x3fc1,0x5f82,0x9fe5}
+ var aa,bb [128]byte
+ a,b:=aligned(&aa),aligned(&bb)
+ observations:=0
+ for row,entry:=range cases {for sample:=0;sample<32;sample++ {for _,csr:=range profiles {for seed:=0;seed<2;seed++ {
+  for i:=range aa {aa[i]=0xa7;bb[i]=0xb9}
+  fill(a,entry.bytes,sample,0);fill(b,entry.bytes,sample,13)
+  beforeA,beforeB:=aa,bb
+  var output,want [34]byte
+  for i:=range output {output[i]=0xc3;want[i]=0xc3}
+  flags:=uint64(2);if seed!=0 {flags|=0x8d5}
+  entry.run((*[32]byte)(unsafe.Pointer(&output[1])),a,b,flags,csr)
+  first:=a;if entry.alias!=0 {first=b}
+  packed:=reference(first,b,entry.width,entry.bytes,entry.unsigned)
+  copy(want[1:1+entry.width],packed[:entry.width])
+  observed:=binary.LittleEndian.Uint64(output[17:25]);copy(want[17:29],output[17:29])
+  actualCSR:=binary.LittleEndian.Uint32(output[25:29])
+  observations++
+  if output!=want||aa!=beforeA||bb!=beforeB||observed&0x8d5!=flags&0x8d5||actualCSR!=csr {
+   t.Fatalf("original PACK row%d sample%d width%d signedInputBytes%d flags%x csr%x got%x want%x",row,sample,entry.width,entry.bytes,observed,actualCSR,output,want)
+  }
+ }}}}
+ t.Logf("original SSE/MMX kernels=%d observations=%d sixFlags/fullCSR/input-output-canaries",len(cases),observations)
+}
+`
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module narroworacle\n\ngo 1.20\n", "value.go": declarations.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": tests,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("original"))
+	command := exec.Command("go", "test", "-c", "-p=2", "-vet=off", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOMAXPROCS=2")
+	if output := x86FloatCompareCaptureCommand(t, command); len(output) != 0 {
+		t.Logf("actual original Go build diagnostic (unchanged bytes):\n%s", output)
+	}
+	output := execution.run(t, executable, "-test.v", "-test.run=^TestOriginal$", "-test.count=1")
+	want := fmt.Sprintf("original SSE/MMX kernels=%d observations=%d sixFlags/fullCSR/input-output-canaries", count, count*32*4*2)
+	if !strings.Contains(string(output), want) || !strings.Contains(string(output), "--- PASS: TestOriginal") ||
+		strings.Contains(string(output), "SKIP") {
+		t.Fatalf("incomplete original-Go oracle denominator: %q", output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+	t.Logf("%d actual stock Go SSE/MMX kernels; no VEX/EVEX original code executed", count)
+}
+
+var x86NarrowOracleFamilies = []x86NarrowOracleFamily{
+	{"PACKSSLW", "VPACKSSDW", 4, false},
+	{"PACKSSWB", "VPACKSSWB", 2, false},
+	{"PACKUSDW", "VPACKUSDW", 4, true},
+	{"PACKUSWB", "VPACKUSWB", 2, true},
+}
+
+func x86NarrowOracleIR(t *testing.T, source, declarations, triple string) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "narroworacle", declarations)
+	sigs := make(map[string]FuncSig)
+	for _, function := range file.Funcs {
+		name := strings.TrimPrefix(function.Sym, "·")
+		object, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			t.Fatal("independent source lacks its declaration", name)
+		}
+		sig, err := DeriveGoFuncABI0Signature(name, object, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, Options{
+		Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	return module.String()
+}
+
+// Intel SDM Vol. 2A, Table 2-50 and the PACK chapters classify these complete
+// memory tuples as E4NF/E4NF.nb: a zero output mask does not suppress the read.
+// No AVX/AVX512 original instruction is executed by this software LLVM oracle.
+func TestCrossLinuxRuntimeMatrixX86PackedNarrowIndependentE4NF(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, table strings.Builder
+	declarations.WriteString("package narroworacle\n")
+	count := 0
+	for _, family := range x86NarrowOracleFamilies {
+		for widthIndex, bank := range []string{"X", "Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && family.inputBytes != 4 {
+					continue
+				}
+				for _, zero := range []bool{false, true} {
+					name := fmt.Sprintf("fault%d", count)
+					count++
+					op := family.vector
+					bytes := 16 << widthIndex
+					if broadcast {
+						op += ".BCST"
+						bytes = 4
+					}
+					if zero {
+						op += ".Z"
+					}
+					fmt.Fprintf(&declarations, "func %s(input *byte)\n", name)
+					fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-8\nMOVQ input+0(FP),AX\nVPXORD %s0,%s0,%s0\nMOVL $0,CX\nKMOVQ CX,K1\n%s (AX),%s0,K1,%s1\nRET\n",
+						name, bank, bank, bank, op, bank, bank)
+					fmt.Fprintf(&table, "{observe%d, %d, %d},\n", count-1, bytes, bytes-1)
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	ir := x86NarrowOracleIR(t, assembly.String(), declarations.String(), execution.triple)
+	var main strings.Builder
+	for index := 0; index < count; index++ {
+		fmt.Fprintf(&main, "extern void fault%d(const uint8_t*);\n", index)
+		fmt.Fprintf(&main, `static int observe%d(const uint8_t *input) {
+    fault%d(input);
+    return 0;
+}
+`, index, index)
+	}
+	driver := x86MemoryFaultDriver(main.String(), table.String())
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "narrow-independent-e4nf", ir, driver, level)
+			x86CheckMemoryFaultMatrix(t, execution, executable, count)
+		})
+	}
+}
diff --git a/amd64_packed_narrow_official_forms_test.go b/amd64_packed_narrow_official_forms_test.go
new file mode 100644
index 000000000..ffafa3cb4
--- /dev/null
+++ b/amd64_packed_narrow_official_forms_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Select the semantic family by name, but derive its entire vector syntax
+// denominator from Go's independent encoder reader, never the lowerer spec.
+func x86OfficialPackedNarrowRows(t *testing.T, arch string) []string {
+	t.Helper()
+	byOpcode := x86OfficialPackedBinaryWitnesses(t)
+	var rows []string
+	for _, opcode := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		witnesses := byOpcode[opcode]
+		if len(witnesses) == 0 {
+			t.Fatal("missing independent official pack family", opcode)
+		}
+		for _, witness := range witnesses {
+			if arch == "386" && strings.Count(witness, ",") == 3 {
+				continue // Actual mode32 frontend refusals are a separate gate.
+			}
+			rows = append(rows, witness)
+		}
+	}
+	return rows
+}
+
+func TestX86PackedNarrowOfficialRowsThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, raw := range []bool{false, true} {
+		var rawRows []string
+		if raw {
+			rawRows = x86OfficialPackedNarrowRawRows(t)
+		}
+		for _, target := range []struct{ arch, triple string }{
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(fmt.Sprintf("raw=%t/%s", raw, target.triple), func(t *testing.T) {
+				var source, declarations strings.Builder
+				declarations.WriteString("package narrow\n")
+				rows := x86OfficialPackedNarrowRows(t, target.arch)
+				if raw {
+					// Physical mode32 masks are legal even though its named Go
+					// frontend rejects them; bytes come from the actual amd64 Go
+					// encoder with low physical register/address banks throughout.
+					rows = rawRows
+				}
+				for index, row := range rows {
+					fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$0-0\n%s\nRET\n", index, row)
+					fmt.Fprintf(&declarations, "func F%d()\n", index)
+				}
+				goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+				pkg := mustGoPackage(t, "example.invalid/narrow", declarations.String())
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs := map[string]FuncSig{}
+				for index := range rows {
+					name := fmt.Sprintf("F%d", index)
+					sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func),
+						target.arch, types.SizesFor("gc", target.arch))
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs[name] = sig
+				}
+				before := fmt.Sprintf("%#v %#v", file, sigs)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original named/raw format batch invented native entry inputs", api, err)
+					}
+				}
+				units := *file
+				units.Funcs = append([]Func(nil), file.Funcs...)
+				if raw {
+					for index, fn := range units.Funcs {
+						decoded, err := decodeX86RawDirectives(fn, target.arch)
+						if err != nil {
+							t.Fatal("actual physical format unit could not be decoded", err)
+						}
+						units.Funcs[index] = decoded
+					}
+				}
+				// Keep every original form, but release each bounded object
+				// before the next batch. Units are not initialized entries.
+				for start := 0; start < len(units.Funcs); start += 64 {
+					end := start + 64
+					if end > len(units.Funcs) {
+						end = len(units.Funcs)
+					}
+					batch := units
+					batch.Funcs = units.Funcs[start:end]
+					ir := x86InstructionFormatObjectUnit(t, &batch, sigs, target.arch, target.triple, 0,
+						func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+							return c.lowerPackedSaturatingNarrow(ins.Op, ins)
+						})
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+				if before != fmt.Sprintf("%#v %#v", file, sigs) {
+					t.Fatal("object coverage changed original source/signatures")
+				}
+				t.Logf("all %d original named/physical Go forms retain emitter-only LLVM objects and three-API Context; independent initialized sources own public/runtime coverage", len(rows))
+			})
+		}
+	}
+}
+
+func x86OfficialPackedNarrowRawRows(t *testing.T) []string {
+	t.Helper()
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc required")
+	}
+	var rows []string
+	var disassembly strings.Builder
+	var equivalentPairs [][2]int
+	for _, row := range x86OfficialPackedNarrowRows(t, "amd64") {
+		code := assembleX87ControlBytes(t, "amd64", "TEXT rawpack(SB),4,$0-0\n"+row+"\nRET\n")
+		code = code[:len(code)-1]
+		appendBytes := func(bytes []byte) {
+			var source strings.Builder
+			for _, value := range bytes {
+				fmt.Fprintf(&source, "BYTE $%d\n", value)
+				fmt.Fprintf(&disassembly, "0x%02x ", value)
+			}
+			disassembly.WriteByte('\n')
+			rows = append(rows, source.String())
+		}
+		original := len(rows)
+		appendBytes(code)
+		opcode, _, _ := strings.Cut(strings.Fields(row)[0], ".")
+		// WIG is physical grammar beyond Go's chosen W0 encoding. EVEX
+		// dword-to-word is W0-only; every VEX and EVEX word-to-byte row
+		// must have an independently disassembled equivalent W1 object.
+		if code[0] == 0x62 && opcode != "VPACKSSWB" && opcode != "VPACKUSWB" {
+			continue
+		}
+		wig := append([]byte(nil), code...)
+		if wig[0] == 0xc5 {
+			wig = append([]byte{0xc4, wig[1]&0x80 | 0x61, wig[1] & 0x7f}, wig[2:]...)
+		}
+		if (wig[0] != 0xc4 && wig[0] != 0x62) || wig[2]&0x80 != 0 {
+			t.Fatalf("unexpected original Go pack prefix: %s %x", row, code)
+		}
+		wig[2] |= 0x80
+		equivalentPairs = append(equivalentPairs, [2]int{original, len(rows)})
+		appendBytes(wig)
+	}
+	for _, triple := range []string{"x86_64", "i386"} {
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple,
+			"--mattr=+avx2,+avx512bw,+avx512vl")
+		command.Stdin = strings.NewReader(disassembly.String())
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil || strings.Contains(string(output), "warning:") {
+			t.Fatalf("independent pack physical grammar: %s %v\n%s", triple, err, output)
+		}
+		var instructions []string
+		for _, line := range strings.Split(string(output), "\n") {
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "vpack") {
+				instructions = append(instructions, line)
+			}
+		}
+		if len(instructions) != len(rows) {
+			t.Fatalf("physical pack disassembly lost forms: %s got %d, want %d", triple, len(instructions), len(rows))
+		}
+		for _, pair := range equivalentPairs {
+			if instructions[pair[0]] != instructions[pair[1]] {
+				t.Fatalf("WIG changed physical instruction: %s %q != %q", triple, instructions[pair[0]], instructions[pair[1]])
+			}
+		}
+	}
+	t.Logf("%d actual Go W0 rows plus %d independently equivalent W1 rows", len(rows)-len(equivalentPairs), len(equivalentPairs))
+	return rows
+}
+
+func TestX86PackedNarrowMode32ActualGoRawForms(t *testing.T) {
+	rows := x86OfficialPackedNarrowRows(t, "386")
+	source := "TEXT rawpack(SB),4,$0-0\n" + strings.Join(rows, "\n") + "\nRET\n"
+	goAssemblerOracleOutput(t, "386", source, "", true)
+	code := assembleX87ControlBytes(t, "386", source)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "386")
+	if err != nil {
+		t.Fatal("actual Go mode32 pack bytes lost physical decoding", err)
+	}
+	named, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatal("actual byte decoder lost instructions", len(decoded.Instrs), len(want))
+	}
+	for index, instruction := range decoded.Instrs {
+		if instruction.Op != want[index].Op || !reflect.DeepEqual(instruction.Args, want[index].Args) {
+			t.Fatalf("mode32 instruction %d: %+v != %+v", index, instruction, want[index])
+		}
+	}
+}
+
+func TestX86PackedNarrowE4NFMemoryRemainsObservable(t *testing.T) {
+	for _, opcode := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			rows := []string{opcode + ".Z (AX)," + bank + "0,K1," + bank + "1"}
+			if opcode == "VPACKSSDW" || opcode == "VPACKUSDW" {
+				rows = append(rows, opcode+".BCST.Z (AX),"+bank+"0,K1,"+bank+"1")
+			}
+			for _, row := range rows {
+				t.Run(row, func(t *testing.T) {
+					source := "TEXT pack(SB),4,$0-0\nMOVL $0,CX\nKMOVQ CX,K1\n" + row + "\nRET\n"
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					initialized := strings.Replace(source, "$0-0\n", "$0-8\nMOVQ p+0(FP),AX\nVPXORD Z0,Z0,Z0\n", 1)
+					goAssemblerOracleOutput(t, "amd64", initialized, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func pack()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("original missing-address source invented native input", api, err)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, initialized, "func pack(p *[64]byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						if !strings.Contains(ir, "load volatile") ||
+							!strings.Contains(x86MulDivRoundOptimize(t, ir), "load volatile") {
+							t.Fatal("E4NF memory read disappeared for a zero mask/dead output")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedNarrowLegacyGoModeAndNativeStorageBoundaries(t *testing.T) {
+	for _, opcode := range []string{"PACKSSLW", "PACKSSWB", "PACKUSWB"} {
+		for _, source := range []string{"M0", "(AX)"} {
+			t.Run("386/"+opcode+"/"+source, func(t *testing.T) {
+				assembly := "TEXT pack(SB),4,$0-0\n" + opcode + " " + source + ",M1\nRET\n"
+				goAssemblerOracleOutput(t, "386", assembly, "", false)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: "386",
+					Sigs: map[string]FuncSig{"pack": {Name: "pack", Ret: Void}}}); err == nil {
+					t.Fatal("Go-rejected mode32 MMX row acquired successful lowering")
+				}
+			})
+		}
+	}
+	for _, opcode := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB"} {
+		t.Run("virtual-memory/"+opcode, func(t *testing.T) {
+			assembly := "TEXT pack(SB),4,$64-64\n" + opcode + " value+0(FP),X0\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := x86WordMaddFPType(t)
+			sig.Name = "pack"
+			if _, err := Translate(file, Options{Goarch: "amd64",
+				Sigs: map[string]FuncSig{"pack": sig}}); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("virtual independent FP slots invented native legacy alignment", err)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_narrow_rules_test.go b/amd64_packed_narrow_rules_test.go
new file mode 100644
index 000000000..b0e26920e
--- /dev/null
+++ b/amd64_packed_narrow_rules_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedNarrowMemoryShapeConsumesTheCompleteGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86OfficialPackedNarrowRows(t, arch)
+		for _, opcode := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB"} {
+			rows = append(rows, opcode+" (AX),X1")
+			if arch == "amd64" && opcode != "PACKUSDW" {
+				rows = append(rows, opcode+" (AX),M1")
+			}
+		}
+		for _, row := range rows {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			if instruction.Args[0].Kind != OpMem {
+				continue
+			}
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				want := int64(amd64VectorByteWidth(instruction.Args[len(instruction.Args)-1].Reg))
+				if _, mmx := amd64ParseMReg(instruction.Args[len(instruction.Args)-1].Reg); mmx {
+					want = 8
+				}
+				if strings.Contains(row, ".BCST") {
+					want = 4
+				}
+				width, write, valid := x86InstructionMemoryShape(instruction, 0, arch)
+				if !valid || write || width != want {
+					t.Fatalf("memory-shape consumer diverged from Go's pack grammar: %d/%t/%t, want %d/false/true", width, write, valid, want)
+				}
+				for index := 1; index < len(instruction.Args); index++ {
+					if _, _, valid := x86InstructionMemoryShape(instruction, index, arch); valid {
+						t.Fatal("non-memory operand received a memory envelope")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedNarrowRawWIGAttributesAndPhysicalMode32Masks(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc required")
+	}
+	// Intel SDM Vol.2B PACK tables: VEX W is ignored; EVEX word-to-byte
+	// ignores W, but EVEX dword-to-word requires W0. This independent table
+	// deliberately does not copy the implementation's encoder attributes.
+	for _, opcode := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+		for _, width := range []string{"X", "Y", "Z"} {
+			for _, evex := range []bool{false, true} {
+				if !evex && width == "Z" {
+					continue
+				}
+				row := opcode + " " + width + "1," + width + "2,"
+				if evex {
+					row += "K1,"
+				}
+				row += width + "3"
+				original := assembleX87ControlBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				original = original[:len(original)-1]
+				if evex && original[0] != 0x62 || !evex && original[0] != 0xc4 && original[0] != 0xc5 {
+					t.Fatal("actual Go encoder selected a different generation", row, original)
+				}
+				code := append([]byte(nil), original...)
+				if code[0] == 0xc5 {
+					// Expand the actual C5 prefix to C4 before changing its W bit.
+					code = append([]byte{0xc4, code[1]&0x80 | 0x61, code[1] & 0x7f}, code[2:]...)
+				}
+				code[2] |= 0x80
+				validW1 := !evex || opcode == "VPACKSSWB" || opcode == "VPACKUSWB"
+				for _, arch := range []string{"amd64", "386"} {
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						if validW1 {
+							var encoded strings.Builder
+							for _, value := range code {
+								fmt.Fprintf(&encoded, "0x%02x ", value)
+							}
+							triple := "x86_64"
+							if arch == "386" {
+								triple = "i386"
+							}
+							ctx, cancel := runtimeOracleStageContext(t)
+							command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+avx2,+avx512bw,+avx512vl")
+							command.Stdin = strings.NewReader(encoded.String() + "\n")
+							output, err := runtimeOracleCombinedOutput(ctx, command)
+							cancel()
+							if err != nil || !strings.Contains(string(output), strings.ToLower(opcode)) || strings.Contains(string(output), "warning:") {
+								t.Fatalf("independent LLVM22 WIG identity: %x %v\n%s", code, err, output)
+							}
+						}
+						got, size, matched, err := decodedX86VectorPackedSaturatingNarrowInstruction(code, map[string]int{"amd64": 64, "386": 32}[arch])
+						if !matched || (err == nil) != validW1 || validW1 && size != len(code) {
+							t.Fatalf("WIG/W0 family contract: %x known=%t bytes=%d error=%v valid=%t", code, matched, size, err, validW1)
+						}
+						if !validW1 {
+							return
+						}
+						before := fmt.Sprintf("%#v", got)
+						form, known, err := x86PackedNarrowProperties(got, arch)
+						if !known || err != nil || form.byteWidth != amd64VectorByteWidth(Reg(width+"0")) {
+							t.Fatal("physical raw input lost typed grammar", got, form, err)
+						}
+						copy := got
+						if form2, _, err := x86PackedNarrowProperties(copy, arch); err != nil || !reflect.DeepEqual(form, form2) {
+							t.Fatal("ordinary value copy lost private physical provenance", err)
+						}
+						if arch == "386" && evex {
+							data, err := json.Marshal(got)
+							if err != nil {
+								t.Fatal(err)
+							}
+							var detached Instr
+							if err := json.Unmarshal(data, &detached); err != nil {
+								t.Fatal(err)
+							}
+							if _, _, err := x86PackedNarrowProperties(detached, arch); err == nil {
+								t.Fatal("JSON fabricated Go-rejected mode32 source-mask authority")
+							}
+						}
+						if before != fmt.Sprintf("%#v", got) {
+							t.Fatal("grammar changed original decoded input")
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_physical_forms.go b/amd64_packed_physical_forms.go
new file mode 100644
index 000000000..3a3ec3a0d
--- /dev/null
+++ b/amd64_packed_physical_forms.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import "strings"
+
+type x86PackedPhysicalFamily string
+
+const (
+	x86PackedAverage      x86PackedPhysicalFamily = "packed average"
+	x86PackedWordProduct  x86PackedPhysicalFamily = "packed word multiply"
+	x86PackedMultiplyAdd  x86PackedPhysicalFamily = "packed multiply-add"
+	x86PackedDwordProduct x86PackedPhysicalFamily = "dword product"
+)
+
+// A common shape does not make arithmetic lanes and memory accesses equal.
+// Dword products read complete qwords before selecting their low dwords;
+// multiply-add reads the full tuple even when all result lanes are masked off.
+type x86PackedPhysicalSpec struct {
+	x86PackedBinarySpec
+	family                            x86PackedPhysicalFamily
+	inputBits, outputBits, memoryBits int // memoryBits == 0 means an E4NF full-tuple read.
+	mode                              amd64PackedWordMultiplyMode
+	signed                            bool
+	nativeOpcode                      string
+}
+
+type x86PackedPhysicalForm struct {
+	x86PackedBinaryForm
+	spec   x86PackedPhysicalSpec
+	source Operand // Actual physical bank, not an initialized value or storage permission.
+}
+
+// The existing four family tables remain the only opcode membership authority.
+// Normalize the name once, then share the physical grammar and its typed result
+// among consumers; do not cache it on mutable instructions or across analyses.
+func x86PackedPhysicalSpecForOp(op Op, family x86PackedPhysicalFamily) (x86PackedPhysicalSpec, bool) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if spec, known := x86PackedAverageSpecs[Op(base)]; known && (family == "" || family == x86PackedAverage) {
+		return x86PackedPhysicalSpec{
+			x86PackedBinarySpec: spec.x86PackedBinarySpec, family: x86PackedAverage,
+			inputBits: spec.laneBits, outputBits: spec.laneBits, memoryBits: spec.laneBits,
+		}, true
+	}
+	if spec, known := x86PackedWordMultiplySpecs[Op(base)]; known && (family == "" || family == x86PackedWordProduct) {
+		return x86PackedPhysicalSpec{
+			x86PackedBinarySpec: x86PackedBinarySpec{encoding: spec.encoding, zeroing: spec.encoding == x86PackedLogicalVEXOrEVEX},
+			family:              x86PackedWordProduct, inputBits: 16, outputBits: 16, memoryBits: 16,
+			mode: spec.mode,
+		}, true
+	}
+	if spec, known := x86PackedMultiplyAddSpecs[Op(base)]; known && (family == "" || family == x86PackedMultiplyAdd) {
+		return x86PackedPhysicalSpec{
+			x86PackedBinarySpec: spec.x86PackedBinarySpec, family: x86PackedMultiplyAdd,
+			inputBits: spec.inputBits, outputBits: spec.outputBits, nativeOpcode: spec.nativeOpcode,
+		}, true
+	}
+	if spec, known := x86DwordProductSpecs[Op(base)]; known && (family == "" || family == x86PackedDwordProduct) {
+		return x86PackedPhysicalSpec{
+			x86PackedBinarySpec: spec.x86PackedBinarySpec, family: x86PackedDwordProduct,
+			inputBits: 32, outputBits: 64, memoryBits: 64,
+			signed: spec.signed, nativeOpcode: spec.nativeOpcode,
+		}, true
+	}
+	return x86PackedPhysicalSpec{}, false
+}
+
+// An empty family accepts this whole group. A family-specific consumer retains
+// its original boundary, including a zero form before physical parsing starts.
+func x86PackedPhysicalProperties(op Op, ins Instr, arch string, family x86PackedPhysicalFamily) (x86PackedPhysicalForm, bool, error) {
+	spec, known := x86PackedPhysicalSpecForOp(op, family)
+	if !known {
+		return x86PackedPhysicalForm{}, false, nil
+	}
+	binary, source, started, err := x86PackedBinaryPhysicalSource(op, ins, arch, spec.x86PackedBinarySpec, string(spec.family))
+	if !started {
+		return x86PackedPhysicalForm{}, true, err
+	}
+	return x86PackedPhysicalForm{binary, spec, source}, true, err
+}
+
+func (c *amd64Ctx) lowerPackedPhysical(op Op, ins Instr, family x86PackedPhysicalFamily) (bool, bool, error) {
+	form, known, err := x86PackedPhysicalProperties(op, ins, c.goarch, family)
+	if !known || err != nil {
+		return known, false, err
+	}
+	switch form.spec.family {
+	case x86PackedAverage:
+		return c.lowerPackedAverageForm(op, ins, form)
+	case x86PackedWordProduct:
+		return c.lowerPackedWordMultiplyForm(op, ins, form)
+	case x86PackedMultiplyAdd:
+		return c.lowerWordMultiplyAddForm(op, ins, form)
+	case x86PackedDwordProduct:
+		return c.lowerDwordToQwordMultiplyForm(op, ins, form)
+	}
+	panic("unregistered packed physical family")
+}
diff --git a/amd64_packed_physical_pipeline_bench_test.go b/amd64_packed_physical_pipeline_bench_test.go
new file mode 100644
index 000000000..867110c11
--- /dev/null
+++ b/amd64_packed_physical_pipeline_bench_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Measure complete analysis, lowering and LLVM verification for the four
+// physical-source families. Parsing stays outside the timer; independent
+// family tests cover numerical values, native faults and source permissions.
+func BenchmarkX86PackedPhysicalTranslation(b *testing.B) {
+	for _, family := range x86PackedPhysicalTestFamilies() {
+		for _, name := range strings.Fields(family.names) {
+			b.Run(name, func(b *testing.B) {
+				operands := "X0,X1"
+				if strings.HasPrefix(name, "V") {
+					operands = "Y0,Y1,Y2"
+				}
+				source := "TEXT binary(SB),4,$0-0\n" +
+					"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" +
+					strings.Repeat(name+" "+operands+"\n", 32) + "RET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					b.Fatal(err)
+				}
+				options := Options{
+					Goarch:       "amd64",
+					TargetTriple: "x86_64-unknown-linux-gnu",
+					Sigs:         map[string]FuncSig{"binary": {Name: "binary", Ret: Void}},
+				}
+				b.ReportAllocs()
+				b.ResetTimer()
+				for iteration := 0; iteration < b.N; iteration++ {
+					if _, err := Translate(file, options); err != nil {
+						b.Fatal(err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_physical_properties_test.go b/amd64_packed_physical_properties_test.go
new file mode 100644
index 000000000..854bc567a
--- /dev/null
+++ b/amd64_packed_physical_properties_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86PackedPhysicalTestFamily struct {
+	names  string
+	parse  func(Op, Instr, string) (x86PackedBinaryForm, Operand, bool, error)
+	decode func([]byte, int) (Instr, int, bool, error)
+	rawOp  string
+}
+
+func x86PackedPhysicalTestFamilies() []x86PackedPhysicalTestFamily {
+	return []x86PackedPhysicalTestFamily{
+		{"PAVGB PAVGW VPAVGB VPAVGW", func(op Op, ins Instr, arch string) (x86PackedBinaryForm, Operand, bool, error) {
+			form, known, err := x86PackedAverageProperties(op, ins, arch)
+			return form.x86PackedBinaryForm, form.source, known, err
+		}, decodedX86PackedAverageInstruction, "VPAVGB"},
+		{"PMULLW PMULHW PMULHUW PMULHRSW VPMULLW VPMULHW VPMULHUW VPMULHRSW", func(op Op, ins Instr, arch string) (x86PackedBinaryForm, Operand, bool, error) {
+			form, known, err := x86PackedWordMultiplyProperties(op, ins, arch)
+			return form.x86PackedBinaryForm, form.source, known, err
+		}, decodedX86PackedMultiplyInstruction, "VPMULLW"},
+		{"PMULDQ PMULULQ VPMULDQ VPMULUDQ", func(op Op, ins Instr, arch string) (x86PackedBinaryForm, Operand, bool, error) {
+			form, known, err := x86DwordProductProperties(op, ins, arch)
+			return form.x86PackedBinaryForm, form.source, known, err
+		}, decodedX86DwordToQwordMultiplyInstruction, "VPMULDQ"},
+		{"PMADDWL PMADDUBSW VPMADDWD VPMADDUBSW", func(op Op, ins Instr, arch string) (x86PackedBinaryForm, Operand, bool, error) {
+			form, known, err := x86PackedMultiplyAddProperties(op, ins, arch)
+			return form.x86PackedBinaryForm, form.source, known, err
+		}, decodedX86EVEXPackedMADDInstruction, "VPMADDWD"},
+	}
+}
+
+func x86PackedPhysicalTestInstruction(name string, memory bool) Instr {
+	ins := Instr{Op: Op(name), Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}}}
+	if strings.HasPrefix(name, "V") {
+		ins.Args = append(ins.Args, Operand{Kind: OpReg, Reg: "X2"})
+	}
+	if memory {
+		ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX, Off: 16}}
+	}
+	return ins
+}
+
+func x86PackedPhysicalTestMMX(name string) bool {
+	return strings.Contains(" PAVGB PAVGW PMULLW PMULHW PMULHUW PMULULQ PMADDWL ", " "+name+" ")
+}
+
+func TestX86PackedPhysicalPropertiesPreserveOperands(t *testing.T) {
+	for _, family := range x86PackedPhysicalTestFamilies() {
+		for _, name := range strings.Fields(family.names) {
+			t.Run(name, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					ins := x86PackedPhysicalTestInstruction(name, memory)
+					before := append([]Operand(nil), ins.Args...)
+					form, source, known, err := family.parse(ins.Op, ins, "amd64")
+					if !known || err != nil || form.byteWidth != 16 || !reflect.DeepEqual(source, before[0]) {
+						t.Fatal("complete original form changed", form, source, err)
+					}
+					if !reflect.DeepEqual(ins.Args, before) {
+						t.Fatal("successful grammar observation mutated source operands")
+					}
+					if _, _, known, err := family.parse(ins.Op, ins, "arm64"); !known || err == nil {
+						t.Fatal("foreign source mode became a matching form", err)
+					}
+					changed := ins
+					changed.Op = "NOP"
+					if _, _, known, err := family.parse(ins.Op, changed, "amd64"); !known || err == nil {
+						t.Fatal("dispatch/source mismatch acquired a form", err)
+					}
+					if !reflect.DeepEqual(ins.Args, before) {
+						t.Fatal("rejected grammar observation mutated source operands")
+					}
+				}
+				if !x86PackedPhysicalTestMMX(name) {
+					return
+				}
+				for _, alias := range []struct{ source, physical Reg }{{AX, "M0"}, {SP, "M4"}} {
+					ins := Instr{Op: Op(name), Args: []Operand{{Kind: OpReg, Reg: alias.source}, {Kind: OpReg, Reg: "M1"}}}
+					before := append([]Operand(nil), ins.Args...)
+					form, source, known, err := family.parse(ins.Op, ins, "amd64")
+					if !known || err != nil || !form.mmx || form.byteWidth != 8 || source.Reg != alias.physical {
+						t.Fatal("original GP spelling lost its distinct MMX bank", form, source, err)
+					}
+					if !reflect.DeepEqual(ins.Args, before) {
+						t.Fatal("MMX projection overwrote the original GP spelling")
+					}
+					if _, _, known, err := family.parse(ins.Op, ins, "386"); !known || err == nil {
+						t.Fatal("named mode32 source acquired an MMX row", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedPhysicalPropertiesRetainDecoderBoundaries(t *testing.T) {
+	for _, family := range x86PackedPhysicalTestFamilies() {
+		t.Run(family.rawOp, func(t *testing.T) {
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+
+				family.rawOp+" 16(AX),X1,K1,X2\nRET\n")
+			if len(code) < 2 || code[len(code)-1] != 0xc3 {
+				t.Fatal("original instruction bytes lack the terminal RET", code)
+			}
+			code = code[:len(code)-1]
+			ins, length, known, err := family.decode(code, 32)
+			if !known || err != nil || length != len(code) || !ins.x86Encoded {
+				t.Fatal("actual mode32 physical decode failed", ins, length, err)
+			}
+			before := append([]Operand(nil), ins.Args...)
+			form, source, known, err := family.parse(ins.Op, ins, "386")
+			if !known || err != nil || form.mask < 0 || form.memory != 0 || source.Mem.Base != AX {
+				t.Fatal("physical masked form lost its original decoder identity", form, source, err)
+			}
+			text := ins
+			text.x86Encoded = false
+			if _, _, _, err := family.parse(text.Op, text, "386"); err == nil {
+				t.Fatal("named four-operand source borrowed decoder admission")
+			}
+			for _, bits := range []int{16, 32, 64} {
+				changed := ins
+				changed.x86AddressBits = bits
+				if _, _, _, err := family.parse(changed.Op, changed, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("address-size override lost its independent context requirement", bits, err)
+				}
+			}
+			changed := ins
+			changed.x86UnboundAddressOverride = true
+			if _, _, _, err := family.parse(changed.Op, changed, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound address override acquired a grammar-only authority", err)
+			}
+			if !reflect.DeepEqual(ins.Args, before) {
+				t.Fatal("physical or rejected observations modified original operands")
+			}
+		})
+	}
+}
+
+func TestX86PackedPhysicalPropertiesAvoidRedundantCopies(t *testing.T) {
+	for _, family := range x86PackedPhysicalTestFamilies() {
+		for _, name := range strings.Fields(family.names) {
+			t.Run(name, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					ins := x86PackedPhysicalTestInstruction(name, memory)
+					_, _, known, err := family.parse(ins.Op, ins, "amd64")
+					if !known || err != nil {
+						t.Fatal("allocation fixture must be accepted", err)
+					}
+					allocations := testing.AllocsPerRun(100, func() {
+						_, _, known, err = family.parse(ins.Op, ins, "amd64")
+					})
+					limit := 0.0
+					if x86PackedPhysicalTestMMX(name) {
+						limit = 1 // Existing MMX bank adapter owns its source projection.
+					}
+					if !known || err != nil || allocations > limit {
+						t.Errorf("memory=%v: %.0f allocations, want at most %.0f; known=%v err=%v", memory, allocations, limit, known, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func BenchmarkX86PackedPhysicalProperties(b *testing.B) {
+	for _, family := range x86PackedPhysicalTestFamilies() {
+		for _, name := range strings.Fields(family.names) {
+			for _, memory := range []bool{false, true} {
+				kind := "register"
+				if memory {
+					kind = "memory"
+				}
+				ins := x86PackedPhysicalTestInstruction(name, memory)
+				b.Run(name+"/"+kind, func(b *testing.B) {
+					b.ReportAllocs()
+					for n := 0; n < b.N; n++ {
+						if _, _, known, err := family.parse(ins.Op, ins, "amd64"); !known || err != nil {
+							b.Fatal("allocation benchmark rejected its unchanged input", err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+const x86PackedNarrowPhysicalNames = "PACKSSLW PACKSSWB PACKUSDW PACKUSWB VPACKSSDW VPACKSSWB VPACKUSDW VPACKUSWB"
+
+func TestX86PackedNarrowPhysicalRejectionContract(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		context     bool
+		width       int
+	}{
+		{"VPACKSSDW (R8),X1,X8", true, 16},
+		{"VPACKSSDW (AX),X1,X8", true, 16},
+		{"VPACKSSDW (R8),X1,X2", false, 16},
+		{"PACKSSWB X0,M1", false, 0},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ins.x86Encoded = true
+			before := append([]Operand(nil), ins.Args...)
+			form, known, err := x86PackedNarrowProperties(ins, "386")
+			if !known || err == nil || errors.Is(err, ErrProbeNeedsContext) != row.context ||
+				form.byteWidth != row.width || !reflect.DeepEqual(form.source, Operand{}) {
+				t.Fatal("rejected physical form changed its classification or retained a source", form, known, err)
+			}
+			if row.width == 0 && !reflect.DeepEqual(form, x86PackedNarrowForm{}) {
+				t.Fatal("early MMX failure retained a partial form")
+			}
+			if !reflect.DeepEqual(ins.Args, before) {
+				t.Fatal("rejected physical source was modified")
+			}
+		})
+	}
+}
+
+func TestX86PackedNarrowPropertiesAvoidRedundantCopies(t *testing.T) {
+	for _, name := range strings.Fields(x86PackedNarrowPhysicalNames) {
+		t.Run(name, func(t *testing.T) {
+			for _, memory := range []bool{false, true} {
+				ins := x86PackedPhysicalTestInstruction(name, memory)
+				_, known, err := x86PackedNarrowProperties(ins, "amd64")
+				if !known || err != nil {
+					t.Fatal("allocation fixture must be accepted", err)
+				}
+				allocations := testing.AllocsPerRun(100, func() {
+					_, known, err = x86PackedNarrowProperties(ins, "amd64")
+				})
+				limit := 0.0
+				if !strings.HasPrefix(name, "V") && name != "PACKUSDW" {
+					limit = 1 // Existing MMX bank adapter owns its projection.
+				}
+				if !known || err != nil || allocations > limit {
+					t.Errorf("memory=%v: %.0f allocations, want at most %.0f; known=%v err=%v", memory, allocations, limit, known, err)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkX86PackedNarrowProperties(b *testing.B) {
+	for _, name := range strings.Fields(x86PackedNarrowPhysicalNames) {
+		for _, memory := range []bool{false, true} {
+			kind := "register"
+			if memory {
+				kind = "memory"
+			}
+			ins := x86PackedPhysicalTestInstruction(name, memory)
+			b.Run(name+"/"+kind, func(b *testing.B) {
+				b.ReportAllocs()
+				for n := 0; n < b.N; n++ {
+					if _, known, err := x86PackedNarrowProperties(ins, "amd64"); !known || err != nil {
+						b.Fatal("allocation benchmark rejected its input", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_precision_forms.go b/amd64_packed_precision_forms.go
new file mode 100644
index 000000000..909cbd67d
--- /dev/null
+++ b/amd64_packed_precision_forms.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Reuse pure lane/carrier axes from packed conversion, not its caller or
+// numeric-family authority. Narrowing's active low bytes differ from its X/Y
+// carrier; the remaining carrier bytes are architectural zeros.
+var x86PackedPrecisionSpecs = map[Op]x86PackedConversionSpec{
+	"CVTPS2PD": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 32, destinationBits: 64,
+		shapes: amd64PackedNumericWiden32To64[:1]}, legacy: true},
+	"CVTPD2PS": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32,
+		shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}}, legacy: true},
+	"VCVTPS2PD": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 32, destinationBits: 64,
+		shapes: amd64PackedNumericWiden32To64, explicit: "sae"}, vex: true},
+	"VCVTPD2PSX": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32,
+		shapes: []amd64PackedNumericShape{{sourceBytes: 16, destinationBytes: 16, lanes: 2}}}, vex: true},
+	"VCVTPD2PSY": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32,
+		shapes: []amd64PackedNumericShape{{sourceBytes: 32, destinationBytes: 16, lanes: 4}}}, vex: true},
+	"VCVTPD2PS": {amd64PackedNumericConversionSpec: amd64PackedNumericConversionSpec{
+		sourceKind: amd64PackedNumericFloat, destinationKind: amd64PackedNumericFloat, sourceBits: 64, destinationBits: 32,
+		shapes: []amd64PackedNumericShape{{sourceBytes: 64, destinationBytes: 32, lanes: 8}}, explicit: "round"}, vex: true},
+}
+
+func x86PackedPrecisionProperties(op Op, ins Instr, arch string) (x86PackedConversionForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86PackedPrecisionSpecs[Op(base)]
+	if !known {
+		return x86PackedConversionForm{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) || dotted && suffix == "" {
+		return x86PackedConversionForm{}, true, fmt.Errorf("%s packed precision opcode/control identity mismatch: %s/%s", arch, op, ins.Op)
+	}
+	ins.Op = op
+	local, contextual := x86VectorValueMemoryInput(ins, arch)
+	form, _, err := x86PackedConversionOperandProperties(local, arch, spec)
+	if err != nil {
+		return form, true, err
+	}
+	if form.memory >= 0 {
+		if contextual {
+			return form, true, x86VectorValueMemoryContext(ins)
+		}
+		if err := x86NamedMultiplyMemoryError(ins.Args[0], arch); err != nil {
+			return form, true, err
+		}
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return form, true, fmt.Errorf("%w: %s needs its original default address mode", ErrProbeNeedsContext, op)
+	}
+	form.evex = form.evex || !spec.legacy && ins.x86PackedPrecisionEVEX
+	return form, true, nil
+}
+
+func x86TypedPackedPrecisionByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedPrecisionProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := form.inputBytes
+	if form.memory >= 0 {
+		width = form.memoryBytes
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(width), read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: int64(form.shape.destinationBytes),
+			read: form.mask >= 0 && !form.properties.zeroing, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
+
+func validateX86PackedPrecisionFile(file *File, opt Options) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	var pending error
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			_, known, err := x86PackedPrecisionProperties(ins.Op, ins, opt.Goarch)
+			if !known {
+				continue
+			}
+			if err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			if err == nil && !x86ScalarFloatIntegerNativeTarget(opt.Goarch, opt.TargetTriple) {
+				err = fmt.Errorf("%w: %s needs its matching native x86 MXCSR target", ErrProbeNeedsContext, ins.Op)
+			}
+			if pending == nil && err != nil {
+				pending = fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+		}
+	}
+	return pending
+}
diff --git a/amd64_packed_reciprocal_forms.go b/amd64_packed_reciprocal_forms.go
new file mode 100644
index 000000000..c51a74d15
--- /dev/null
+++ b/amd64_packed_reciprocal_forms.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedReciprocalForm struct {
+	op        Op
+	byteWidth int
+	legacy    bool
+}
+
+// Go's yxm and _yvptest tables have only X/m128 and VEX X/Y packed
+// estimates. Scalar estimates, EVEX, masks and suffixes are separate grammars.
+func x86PackedReciprocalProperties(op Op, ins Instr, arch string) (x86PackedReciprocalForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	form := x86PackedReciprocalForm{op: Op(name)}
+	switch name {
+	case "RCPPS", "RSQRTPS":
+		form.legacy = true
+	case "VRCPPS", "VRSQRTPS":
+	default:
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86PackedReciprocalForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go packed reciprocal grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	form.byteWidth = amd64VectorByteWidth(ins.Args[1].Reg)
+	vector := func(operand Operand) bool {
+		if !form.legacy {
+			return amd64VEXVectorRegister(operand, form.byteWidth)
+		}
+		index, valid := amd64ParseXReg(operand.Reg)
+		limit := 16
+		if arch == "386" {
+			limit = 8
+		}
+		return operand.Kind == OpReg && valid && index < limit
+	}
+	if form.byteWidth != 16 && (form.legacy || form.byteWidth != 32) || !vector(ins.Args[1]) {
+		return fail()
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		if !vector(source) {
+			return fail()
+		}
+	} else if !form.legacy && x86Mode32UnboundVEXMemorySource(source, arch) {
+		return form, true, fmt.Errorf("%w: 386 %s extended source base has no physical address binding", ErrProbeNeedsContext, op)
+	} else if !isAMD64MemoryOperand(source) || !x86PackedShiftMemoryValid(source, arch) {
+		return fail()
+	} else if err := x86NamedMultiplyMemoryError(source, arch); err != nil {
+		return form, true, err
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func x86TypedPackedReciprocalByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedReciprocalProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	vector := x86TypedVectorEffect{upperWrite: x86TypedVectorUpperZero, memoryAlignment: 1}
+	if form.legacy {
+		vector.upperWrite, vector.memoryAlignment = x86TypedVectorUpperPreserve, 16
+	}
+	width := int64(form.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, vector: vector, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: width, read: true},
+		{index: 1, operand: ins.Args[1], width: width, write: true},
+	}}, true, nil
+}
+
+func x86ResultPackedReciprocalStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedReciprocalProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	source, mask := ins.Args[0], x86CallerVectorByteMask(int64(form.byteWidth))
+	defined := mask
+	if source.Kind == OpReg {
+		index, _ := amd64VectorRegisterIndex(source.Reg, form.byteWidth)
+		if state.vectorBytes(index)&mask != mask {
+			defined = 0 // Pure dead estimates may retain an unknown numerical value.
+		}
+	} else {
+		// Virtual FP bytes are not an aligned native m128 operand. The
+		// paired original opcode, rather than storage permission, owns #GP.
+		if form.legacy {
+			if _, static := x86StaticSBReadAddress(source, arch); !static &&
+				(!native || !x86OrdinaryNativeMemoryOperand(source, arch)) {
+				return false, true
+			}
+		}
+		if !x86ResultReadWithNativeContinuation(ins, source, int64(form.byteWidth), state, owned, arch, native) {
+			return false, true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[1].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true // No FLAGS, DF, MXCSR or storage facts change.
+}
diff --git a/amd64_packed_reduction_boundary_test.go b/amd64_packed_reduction_boundary_test.go
new file mode 100644
index 000000000..437718fb9
--- /dev/null
+++ b/amd64_packed_reduction_boundary_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedReductionDotCompleteOfficialGoAttributes(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range []string{"DPPD", "DPPS", "VDPPD", "VDPPS"} {
+		code := "0x41"
+		if strings.HasSuffix(opcode, "PS") {
+			code = "0x40"
+		}
+		if opcode[0] != 'V' {
+			if !strings.Contains(string(legacy), "{A"+opcode+", yxshuf, Pq, opBytes{0x3a, "+code+", 0}}") ||
+				!strings.Contains(string(legacy), "{Zibm_r, 2, argList{Yu8, Yxm, Yxr}}") {
+				t.Fatal("complete dot legacy table/opcode attributes changed", opcode)
+			}
+			continue
+		}
+		table, widths := "_yvdppd", []string{"vex128"}
+		if opcode == "VDPPS" {
+			table, widths = "_yvblendpd", []string{"vex128", "vex256"}
+		}
+		begin := strings.Index(string(avx), "{as: A"+opcode+",")
+		if begin < 0 {
+			t.Fatal("official Go omitted dot member", opcode)
+		}
+		row := strings.SplitN(string(avx)[begin:], "\n\t}},", 2)[0]
+		if !strings.Contains(row, "ytab: "+table+",") || strings.Contains(row, "evex") {
+			t.Fatal("dot borrowed an unsupported width/mask/suffix generation", row)
+		}
+		for _, width := range widths {
+			if !strings.Contains(row, "avxEscape | "+width+" | vex66 | vex0F3A | vexW0, "+code) {
+				t.Fatal("complete dot VEX opcode attributes changed", row)
+			}
+		}
+	}
+}
+
+func TestX86PackedReductionVoidRetainsMeaningfulInputsAndNativeBoundaries(t *testing.T) {
+	for _, row := range x86PackedReductionOracleRows() {
+		destination := 1
+		if !row.legacy {
+			destination = 2
+		}
+		source, declaration := x86PackedReductionInitializedFixture("Value", "amd64", row.row, destination)
+		variants := map[string]string{}
+		if strings.Contains(row.row, "(BX)") {
+			variants["numeric-is-not-a-pointer"] = strings.Replace(source, "MOVQ p+0(FP),BX", "MOVQ $42,BX", 1)
+			variants["unknown-pointer"] = strings.Replace(source, "MOVQ p+0(FP),BX\n", "", 1)
+			variants["native-SP"] = strings.Replace(source, row.row, strings.Replace(row.row, "(BX)", "(SP)", 1), 1)
+		} else {
+			variants["missing-first-data"] = strings.Replace(source, "VPXORD Z0,Z0,Z0\n", "", 1)
+		}
+		variants["missing-second-or-legacy-old-data"] = strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+		for name, changed := range variants {
+			t.Run(fmt.Sprintf("%s/%s", row.row, name), func(t *testing.T) {
+				if name == "numeric-is-not-a-pointer" {
+					x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", changed)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if name == "numeric-is-not-a-pointer" {
+						if err != nil || !strings.Contains(ir, fmt.Sprintf("call <%d x float> asm sideeffect \"%s ", row.width/4, row.mnemonic)) ||
+							!strings.Contains(ir, "~{memory}") || !strings.Contains(ir, "~{fpsr}") {
+							t.Fatal("complete NUM address lost its original reduction width or effects", api, err)
+						}
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+						continue
+					}
+					if strings.HasPrefix(name, "missing-") {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						continue
+					}
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error("Void invented a meaningful arithmetic input or native storage permission", api, err)
+					}
+				}
+			})
+		}
+		if !row.legacy {
+			t.Run(row.row+"/VEX-write-only-destination", func(t *testing.T) {
+				withoutOld := strings.Replace(source, "VPXORD Z2,Z2,Z2\n", "", 1)
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, withoutOld, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Fatal("VEX reduction invented a merging destination dependency", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_reduction_bytes_test.go b/amd64_packed_reduction_bytes_test.go
new file mode 100644
index 000000000..f9cc858c4
--- /dev/null
+++ b/amd64_packed_reduction_bytes_test.go
@@ -0,0 +1,313 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PackedReductionOriginalRawRows(t *testing.T, rows []x86PackedReductionOracleRow) []string {
+	t.Helper()
+	var instructions []string
+	for _, row := range rows {
+		instructions = append(instructions, row.row)
+	}
+	listing, err := x86ExtensionGoListing(t, "amd64", strings.Join(instructions, "\n"))
+	if err != nil {
+		t.Fatalf("actual original reduction listing: %v\n%s", err, listing)
+	}
+	raw, err := x86PackedReductionRawRowsFromGoListing(listing, rows)
+	if err != nil {
+		t.Fatalf("complete original reduction Go PC/byte boundaries: %v\n%s", err, listing)
+	}
+	return raw
+}
+
+var x86PackedReductionListingInstruction = regexp.MustCompile(`^\s*0x([0-9a-f]+)\s+([0-9]+)\s+\(.*:([0-9]+)\)\s+([A-Z0-9]+)(?:\s|$)`)
+
+// The fixture's boundaries come from the actual Go listing, not our decoder.
+// In particular x86asm may accept just a VEX prefix as a shorter instruction.
+// Bind every source line and PC, then independently check all original bytes,
+// including the terminal RET. Neither padding nor an unexplained suffix is
+// silently dropped from the source used by the raw continuation tests.
+func x86PackedReductionRawRowsFromGoListing(listing string, rows []x86PackedReductionOracleRow) ([]string, error) {
+	var expected [][]byte
+	for _, row := range rows {
+		expected = append(expected, x86PackedReductionIndependentFixtureBytes(row))
+	}
+	return x86PackedReductionRawRowsFromGoListingWithExpected(listing, rows, expected)
+}
+
+func x86PackedReductionRawRowsFromGoListingWithExpected(listing string, rows []x86PackedReductionOracleRow, expected [][]byte) ([]string, error) {
+	if len(expected) != len(rows) {
+		return nil, fmt.Errorf("incomplete independent original byte inventory")
+	}
+	var code []byte
+	var pcs []int
+	for _, line := range strings.Split(listing, "\n") {
+		if encoded := x86InsertExtractListedBytes(line); len(encoded) != 0 {
+			fields := strings.Fields(line)
+			pc, err := strconv.ParseUint(strings.TrimPrefix(fields[0], "0x"), 16, 32)
+			if err != nil || int(pc) != len(code) {
+				return nil, fmt.Errorf("noncontiguous Go byte listing at %q", line)
+			}
+			code = append(code, encoded...)
+			continue
+		}
+		match := x86PackedReductionListingInstruction.FindStringSubmatch(line)
+		if match == nil {
+			continue
+		}
+		pc, pcErr := strconv.ParseUint(match[1], 16, 32)
+		decimalPC, decimalErr := strconv.ParseUint(match[2], 10, 32)
+		sourceLine, sourceErr := strconv.Atoi(match[3])
+		if pcErr != nil || decimalErr != nil || sourceErr != nil || pc != decimalPC {
+			return nil, fmt.Errorf("invalid Go PC/source row %q", line)
+		}
+		if sourceLine == 1 && pc == 0 && (match[4] == "TEXT" || match[4] == "FUNCDATA") {
+			continue
+		}
+		index := len(pcs)
+		mnemonic := "RET"
+		if index < len(rows) {
+			mnemonic = strings.ToUpper(rows[index].mnemonic)
+		}
+		if index > len(rows) || sourceLine != index+2 || match[4] != mnemonic ||
+			index == 0 && pc != 0 || index > 0 && int(pc) <= pcs[index-1] {
+			return nil, fmt.Errorf("missing, duplicate or changed original Go instruction %q", line)
+		}
+		pcs = append(pcs, int(pc))
+	}
+	if len(pcs) != len(rows)+1 || len(code) != pcs[len(pcs)-1]+1 || code[len(code)-1] != 0xc3 {
+		return nil, fmt.Errorf("incomplete original Go program: PCs=%v bytes=%x", pcs, code)
+	}
+	var raw []string
+	for index, row := range rows {
+		start, end := pcs[index], pcs[index+1]
+		if end > len(code) {
+			return nil, fmt.Errorf("original Go PC outside byte listing: %s at %d:%d", row.row, start, end)
+		}
+		want := expected[index]
+		if !bytes.Equal(code[start:end], want) {
+			return nil, fmt.Errorf("original Go instruction bytes changed: %s at %d:%d got=%x want=%x", row.row, start, end, code[start:end], want)
+		}
+		raw = append(raw, strings.TrimSuffix(x86RawDisplacementDirectives(code[start:end]), "\n"))
+	}
+	return raw, nil
+}
+
+// These independent oracle rows use only X/Y0, X/Y1, X/Y2 and bare (BX).
+// Check each actual Go encoding's opcode, pp/L, register fields and selector;
+// the production parser, typed spec and decoder do not supply these bytes.
+func x86PackedReductionIndependentFixtureBytes(row x86PackedReductionOracleRow) []byte {
+	memory := strings.Contains(row.row, "(BX)")
+	modRM := byte(0xc8)
+	if memory {
+		modRM = 0x0b
+	}
+	if !row.legacy {
+		modRM += 8
+	}
+	opcode := byte(0x7c)
+	if strings.Contains(row.mnemonic, "hsub") {
+		opcode = 0x7d
+	}
+	if row.dot {
+		opcode = 0x40
+		if strings.HasSuffix(row.mnemonic, "pd") {
+			opcode = 0x41
+		}
+		if row.legacy {
+			return []byte{0x66, 0x0f, 0x3a, opcode, modRM, 0xff}
+		}
+		control := byte(0x71)
+		if row.width == 32 {
+			control |= 4
+		}
+		return []byte{0xc4, 0xe3, control, opcode, modRM, 0xff}
+	}
+	prefix := byte(0xf2)
+	if strings.HasSuffix(row.mnemonic, "pd") {
+		prefix = 0x66
+	}
+	if row.legacy {
+		return []byte{prefix, 0x0f, opcode, modRM}
+	}
+	control := byte(0xf3)
+	if prefix == 0x66 {
+		control = 0xf1
+	}
+	if row.width == 32 {
+		control |= 4
+	}
+	return []byte{0xc5, control, opcode, modRM}
+}
+
+func TestX86PackedReductionGoListingKeepsWholeBoundaries(t *testing.T) {
+	rows := []x86PackedReductionOracleRow{
+		{row: "VDPPS $255,X0,X1,X2", mnemonic: "vdpps", width: 16, dot: true},
+		{row: "VHADDPD Y0,Y1,Y2", mnemonic: "vhaddpd", width: 32},
+	}
+	const listing = `extension.extension STEXT nosplit asm size=11 align=0x0 args=0x0 locals=0x0
+  0x0000 00000 (extension.s:1) TEXT extension.extension(SB), NOSPLIT|NOFRAME, $0-0
+  0x0000 00000 (extension.s:1) FUNCDATA $0, gclocals(SB)
+  0x0000 00000 (extension.s:2) VDPPS $255, X0, X1, X2
+  0x0006 00006 (extension.s:3) VHADDPD Y0, Y1, Y2
+  0x000a 00010 (extension.s:4) RET
+  0x0000 c4 e3 71 40 d0 ff c5 f5 7c d0 c3                 ..q@....|..
+`
+	raw, err := x86PackedReductionRawRowsFromGoListing(listing, rows)
+	if err != nil || len(raw) != 2 {
+		t.Fatal("independent complete VEX/RET listing rejected", raw, err)
+	}
+	for name, changed := range map[string]string{
+		"partial VEX boundary": strings.Replace(listing, "0x0006 00006", "0x0002 00002", 1),
+		"source row changed":   strings.Replace(listing, "extension.s:3", "extension.s:5", 1),
+		"opcode changed":       strings.Replace(listing, ") VHADDPD", ") VHSUBPD", 1),
+		"physical opcode":      strings.Replace(strings.Replace(listing, "71 40 d0", "71 41 d0", 1), "..q@", "..qA", 1),
+		"physical vector L":    strings.Replace(listing, "c5 f5", "c5 f1", 1),
+		"missing RET":          strings.Replace(listing, "  0x000a 00010 (extension.s:4) RET\n", "", 1),
+		"byte gap":             strings.Replace(listing, "0x0000 c4", "0x0001 c4", 1),
+		"trailing bytes":       strings.Replace(listing, "c3                 ..q@....|..", "c3 90              ..q@....|...", 1),
+		"abbreviated bytes":    strings.Replace(listing, "                 ..q@....|..", "", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := x86PackedReductionRawRowsFromGoListing(changed, rows); err == nil {
+				t.Fatal("incomplete or changed whole-instruction listing accepted")
+			}
+		})
+	}
+}
+
+func x86PackedReductionOracleState(width int) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	for index := 0; index < 3; index++ {
+		state.writeVector(index, 64, uint64(0xa5a55a5affff0000)|x86CallerVectorByteMask(int64(width)), true)
+	}
+	state.gp[3], state.pointerGP[3] = 0xff, true
+	return state
+}
+
+func TestX86PackedReductionEverySelectorMeaningfulByteAndUpperAlias(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedReductionOracleRows() {
+			if strings.Contains(row.row, "(BX)") || arch == "386" && row.dot && !row.legacy {
+				continue
+			}
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				selectors := 1
+				if row.dot {
+					selectors = 256
+				}
+				for selector := 0; selector < selectors; selector++ {
+					spelling := strings.Replace(row.row, "$255", fmt.Sprintf("$%d", selector), 1)
+					ins := x86ScalarLaneInstruction(t, spelling)
+					initial := x86PackedReductionOracleState(row.width)
+					destination, _ := amd64VectorRegisterIndex(ins.Args[row.destination].Reg, row.width)
+					want := initial.clone()
+					want.writeVector(destination, row.width, x86CallerVectorByteMask(int64(row.width)), row.legacy)
+					state := initial.clone()
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+						t.Fatal("complete initialized reduction changed unrelated input/FLAGS/DF/upper bytes", spelling)
+					}
+					for _, input := range []int{row.first, row.second} {
+						source, _ := amd64VectorRegisterIndex(ins.Args[input].Reg, row.width)
+						for missing := 0; missing < row.width; missing++ {
+							required := true
+							if row.dot {
+								laneBytes := 4
+								if strings.HasSuffix(row.mnemonic, "pd") {
+									laneBytes = 8
+								}
+								required = selector&(1<<uint(4+(missing%16)/laneBytes)) != 0
+							}
+							state := initial.clone()
+							state.writeVector(source, 64, state.vectorBytes(source)&^(uint64(1)<<uint(missing)), true)
+							before := state.clone()
+							accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+							if accepted == required || !accepted && !reflect.DeepEqual(state, before) {
+								t.Fatal("selector borrowed a missing meaningful byte or rejected a suppressed lane", spelling, input, missing, required)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedReductionRawIdentityAndStandaloneBoundaries(t *testing.T) {
+	rows := x86PackedReductionOracleRows()
+	raw := x86PackedReductionOriginalRawRows(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index := range rows {
+			fmt.Fprintf(&source, "TEXT F%d(SB),4,$0-0\n%s\nRET\n", index, raw[index])
+		}
+		original := mustParseX86RawReturn(t, source.String())
+		file, err := normalizeX86RawFile(original, arch)
+		if err != nil || len(file.Funcs) != 34 {
+			t.Fatal("complete original reduction decoder failed", arch, err)
+		}
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				function := file.Funcs[index]
+				ins := function.Instrs[1]
+				if !x86RawPackedReductionSource(ins, arch) {
+					t.Fatal("missing complete physical source identity", row.row)
+				}
+				state := x86PackedReductionOracleState(row.width)
+				before := state.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone query acquired raw source/native memory authority")
+				}
+				if accepted, known := x86LoweredRawPackedReductionStep(ins, &state, nil, arch); !accepted || !known {
+					t.Fatal("exact complete raw inputs did not compose with paired native opcode")
+				}
+				for _, mutate := range []func(*Instr){
+					func(ins *Instr) { ins.Op = "UNKNOWN" },
+					func(ins *Instr) {
+						ins.Args = append([]Operand(nil), ins.Args...)
+						ins.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+					},
+					func(ins *Instr) { ins.x86Encoded = !ins.x86Encoded },
+					func(ins *Instr) { ins.x86AddressBits = 32 },
+					func(ins *Instr) { ins.x86VectorBytes++ },
+					func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+					func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+					func(ins *Instr) { ins.x86SourceRaw = nil },
+					func(ins *Instr) {
+						origin := *ins.x86SourceRaw
+						origin.packedReduction = x86RawPackedReductionIdentity{}
+						ins.x86SourceRaw = &origin
+					},
+				} {
+					changed := ins
+					mutate(&changed)
+					if x86RawPackedReductionSource(changed, arch) {
+						t.Fatal("edited selector/physical/source identity borrowed a raw continuation")
+					}
+					state := before.clone()
+					if accepted, _ := x86LoweredRawPackedReductionStep(changed, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited raw reduction changed a rejected state")
+					}
+				}
+				other := "386"
+				if arch == "386" {
+					other = "amd64"
+				}
+				if x86RawPackedReductionSource(ins, other) {
+					t.Fatal("raw physical source borrowed another creation mode")
+				}
+				cloned := cloneX86ReplayInstrs(function.Instrs)
+				if cloned[1].x86SourceRaw == ins.x86SourceRaw || !x86RawPackedReductionSource(cloned[1], arch) {
+					t.Fatal("immutable raw replay clone lost its physical identity snapshot")
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_reduction_fault_runtime_test.go b/amd64_packed_reduction_fault_runtime_test.go
new file mode 100644
index 000000000..533476f94
--- /dev/null
+++ b/amd64_packed_reduction_fault_runtime_test.go
@@ -0,0 +1,222 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The native fault reference executes original Go-assembled instruction bytes
+// under the explicit SysV DI/SI/DX transport below. It is not a Go-runtime or
+// ABI0 execution receipt; the separate value owners execute actual Go programs.
+func x86PackedReductionFaultOriginalBytes(t *testing.T, rows []x86PackedReductionRuntimeRow) [][]byte {
+	t.Helper()
+	var assembly strings.Builder
+	assembly.WriteString("TEXT original(SB),4,$0-0\n")
+	for _, row := range rows {
+		assembly.WriteString("LDMXCSR (SI)\nVMOVDQU (DX),Y1\n" + row.instruction + "\nRET\n")
+	}
+	code := x86PackedShiftActualGoBytes(t, "amd64", assembly.String())
+	var result [][]byte
+	offset := 0
+	for _, row := range rows {
+		// Independent exact Go LDMXCSR (SI), VMOVDQU (DX),Y1, arithmetic,
+		// RET bytes bind the complete reference, not a search for byte 0xc3.
+		want := []byte{0x0f, 0xae, 0x16, 0xc5, 0xfe, 0x6f, 0x0a}
+		want = append(want, x86PackedReductionRuntimeExpectedBytes(row, true)...)
+		want = append(want, 0xc3)
+		end := offset + len(want)
+		if end > len(code) || !bytes.Equal(code[offset:end], want) {
+			t.Fatal("original native reduction fault bytes/whole boundaries changed", row.instruction, offset)
+		}
+		result = append(result, append([]byte(nil), code[offset:end]...))
+		offset = end
+	}
+	if offset != len(code) {
+		t.Fatal("unconsumed original native reduction fault bytes", offset, len(code))
+	}
+	return result
+}
+
+func x86PackedReductionFaultFixture(rows []x86PackedReductionRuntimeRow, original [][]byte) (assembly, declarations, driver string) {
+	var source, decl, native, prototypes, pairs strings.Builder
+	for index, row := range rows {
+		name, reference := fmt.Sprintf("reductionfault%d", index), fmt.Sprintf("original%d", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ p+0(FP),DI\nMOVQ csr+8(FP),SI\nMOVQ b+16(FP),DX\n"+
+			"LDMXCSR (SI)\nVMOVDQU (DX),Y1\n%s\nRET\n", name, row.instruction)
+		fmt.Fprintf(&decl, "func %s(p *byte,csr *uint32,b *[4]uint64)\n", name)
+		var octets []string
+		for _, value := range original[index] {
+			octets = append(octets, fmt.Sprintf("0x%02x", value))
+		}
+		fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+reference+"\n"+reference+":\n.byte "+strings.Join(octets, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,uint32_t*,uint64_t*),%s(uint8_t*,uint32_t*,uint64_t*);\n", name, reference)
+		bits := 32
+		if strings.HasSuffix(row.oracle.mnemonic, "pd") {
+			bits = 64
+		}
+		fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d,%d,%d,%d},\n", reference, name, row.oracle.width, bits,
+			x86FloatAddSubBoolInt(row.oracle.legacy), x86FloatAddSubBoolInt(row.oracle.dot), row.selector,
+			x86FloatAddSubBoolInt(strings.Contains(row.oracle.mnemonic, "hsub")))
+	}
+	driver = `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + native.String() + prototypes.String() + `
+typedef void (*program)(uint8_t*,uint32_t*,uint64_t*);
+static const struct {program original,translated;unsigned width,bits,aligned,dot,selector,subtract;} pairs[]={
+` + pairs.String() + `};
+static int outcome(program fn,uint8_t *p,uint32_t csr,uint64_t *second) {
+    pid_t child=fork();if(child<0)return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};if(setrlimit(RLIMIT_CORE,&no_core))_exit(120);
+        fn(p,&csr,second);_exit(0);
+    }
+    int status;if(waitpid(child,&status,0)!=child)return -1;
+    if(WIFEXITED(status)&&WEXITSTATUS(status)==0)return 0;
+    if(WIFSIGNALED(status)) {
+        int sig=WTERMSIG(status);
+        if(sig==SIGSEGV||sig==SIGBUS)return 1;
+        if(sig==SIGFPE)return 2;
+    }
+    return -1;
+}
+static void fill(uint8_t *p,unsigned bits,uint64_t even,uint64_t odd) {
+    for(unsigned lane=0;lane<32/(bits/8);lane++) {
+        uint64_t value=lane&1?odd:even;
+        memcpy(p+lane*(bits/8),&value,bits/8);
+    }
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);if(page<64)return 1;
+    uint8_t *p=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(p==MAP_FAILED||mprotect(p+page,page,PROT_NONE))return 2;
+    _Alignas(16) uint64_t second[4]={0};
+    memset(p,0,page);
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);i++) {
+        int limits[]={0,pairs[i].width-1,pairs[i].width,pairs[i].width+1};
+        for(unsigned n=0;n<5;n++) {
+            uint8_t *input=n==4?0:p+page-limits[n];
+            int expected=n==4||limits[n]<(int)pairs[i].width;
+            if(pairs[i].aligned&&((uintptr_t)input&15))expected=1;
+            int a=outcome(pairs[i].original,input,0x1f80,second);
+            int b=outcome(pairs[i].translated,input,0x1f80,second);
+            if(a!=expected||b!=expected) {
+                fprintf(stderr,"dead tuple=%u limit=%u original=%d LLVM=%d expected=%d\n",i,n,a,b,expected);
+                return 3;
+            }
+        }
+        for(unsigned event=0;event<5;event++) {
+            if(event==4&&!pairs[i].dot)continue;
+            uint64_t first,other;uint32_t csr=0x1f80;
+            if(event==0) {
+                first=pairs[i].bits==32?UINT64_C(0x7f812345):UINT64_C(0x7ff0123456789abc);
+                other=pairs[i].bits==32?UINT64_C(0x3f800000):UINT64_C(0x3ff0000000000000);
+                csr&=~UINT32_C(0x80);
+            } else if(event==1) {
+                first=1;other=pairs[i].bits==32?UINT64_C(0x3f800000):UINT64_C(0x3ff0000000000000);
+                csr&=~UINT32_C(0x100);
+            } else if(event==2) {
+                first=pairs[i].bits==32?UINT64_C(0x7f7fffff):UINT64_C(0x7fefffffffffffff);
+                other=pairs[i].dot?(pairs[i].bits==32?UINT64_C(0x40000000):UINT64_C(0x4000000000000000)):first;
+                csr&=~UINT32_C(0x400);
+            } else if(event==3) {
+                first=pairs[i].dot?(pairs[i].bits==32?UINT64_C(0x3f800001):UINT64_C(0x3ff0000000000001)):
+                    (pairs[i].bits==32?UINT64_C(0x3f800000):UINT64_C(0x3ff0000000000000));
+                other=pairs[i].dot?first:(pairs[i].bits==32?UINT64_C(0x33000000):UINT64_C(0x3c90000000000000));
+                csr&=~UINT32_C(0x1000);
+            } else {
+                first=pairs[i].bits==32?UINT64_C(0x00800000):UINT64_C(0x0010000000000000);
+                other=first;csr&=~UINT32_C(0x800);
+            }
+            uint64_t odd=pairs[i].dot?first:other;
+            if(event==2&&pairs[i].subtract)odd^=pairs[i].bits==32?UINT64_C(0x80000000):UINT64_C(0x8000000000000000);
+            fill(p,pairs[i].bits,first,odd);
+            fill((uint8_t*)second,pairs[i].bits,other,pairs[i].dot?other:odd);
+            unsigned inputs=pairs[i].bits==32?0xf0:0x30;
+            int expected=pairs[i].dot&&!(pairs[i].selector&inputs)?0:2;
+            int a=outcome(pairs[i].original,p,csr,second);
+            int b=outcome(pairs[i].translated,p,csr,second);
+            if(a!=expected||b!=expected) {
+                fprintf(stderr,"dead exception=%u event=%u selector=%x original=%d LLVM=%d expected=%d\n",i,event,pairs[i].selector,a,b,expected);
+                return 4;
+            }
+        }
+    }
+    if(munmap(p,2*page))return 5;
+    puts("complete original Go-opcode/LLVM native reduction dead-fault receipt");
+    return 0;
+}
+`
+	return source.String(), decl.String(), driver
+}
+
+func x86PackedReductionNativeFaults(t *testing.T, owner int) {
+	t.Helper()
+	if owner < 0 || owner >= x86PackedReductionNativeOwners {
+		t.Fatal("invalid complete native reduction fault owner", owner)
+	}
+	execution := x86PackedReductionNativeTools(t)
+	rows := x86PackedReductionNativeRows(true)
+	if len(rows) != 37 {
+		t.Fatal("complete native reduction fault denominator changed", len(rows))
+	}
+	consumed := 0
+	for batch, start := 0, 0; start < len(rows); batch, start = batch+1, start+x86PackedReductionFaultCapture {
+		if batch%x86PackedReductionNativeOwners != owner {
+			continue
+		}
+		end := start + x86PackedReductionFaultCapture
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			current := rows[start:end]
+			var original [][]byte
+			t.Run("original_go_opcode_reference", func(t *testing.T) {
+				original = x86PackedReductionFaultOriginalBytes(t, current)
+				if len(original) != len(current) {
+					t.Fatal("incomplete actual Go-assembled native reference kernels")
+				}
+			})
+			if len(original) != len(current) {
+				t.Fatal("missing actual Go-assembled native reference kernels")
+			}
+			assembly, declarations, driver := x86PackedReductionFaultFixture(current, original)
+			raw := x86PackedReductionRuntimeRawRows(t, current, true)
+			rawRows := append([]x86PackedReductionRuntimeRow(nil), current...)
+			for index := range rawRows {
+				rawRows[index].instruction = raw[index]
+			}
+			rawAssembly, _, _ := x86PackedReductionFaultFixture(rawRows, original)
+			for _, spelling := range []struct{ name, source string }{{"named", assembly}, {"raw", rawAssembly}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "amd64", spelling.source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations, "amd64", execution.triple, api)
+							if err != nil {
+								t.Fatal("initialized native reduction dead source rejected", err)
+							}
+							x86PackedReductionNativePipelines(t, execution, ir, driver,
+								[]byte("complete original Go-opcode/LLVM native reduction dead-fault receipt\n"))
+						})
+					}
+				})
+			}
+			consumed += len(current)
+		})
+	}
+	if consumed == 0 {
+		t.Fatal("empty native reduction dead-fault owner")
+	}
+	t.Logf("%d/37 original-Go-opcode native memory/alignment and actual unmasked invalid/denormal/overflow/precision/dot-underflow kernels", consumed)
+}
diff --git a/amd64_packed_reduction_forms.go b/amd64_packed_reduction_forms.go
new file mode 100644
index 000000000..9347ef736
--- /dev/null
+++ b/amd64_packed_reduction_forms.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These two arithmetic families share a two-source native reduction envelope,
+// not an arithmetic formula. Horizontal pairs consume every input byte; dot
+// products consume only imm-selected lanes while still reading the full native
+// memory tuple and retaining the opcode's complete exception/MXCSR effects.
+type x86PackedReductionForm struct {
+	first, second, destination, memory int
+	byteWidth, laneBits                int
+	dot, legacy                        bool
+	immediate                          uint8
+}
+
+func x86PackedReductionProperties(ins Instr, arch string) (x86PackedReductionForm, bool, error) {
+	if horizontal, known, err := x86HorizontalFloatProperties(ins, arch); known {
+		return x86PackedReductionForm{
+			first: horizontal.first, second: horizontal.second, destination: horizontal.destination,
+			memory: horizontal.memory, byteWidth: horizontal.byteWidth, laneBits: horizontal.spec.laneBits,
+			legacy: !horizontal.spec.vector,
+		}, true, err
+	}
+	base, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64PackedFloatingDotSpecs[Op(base)]
+	form := x86PackedReductionForm{
+		first: 1, second: 2, destination: 2, memory: -1,
+		byteWidth: 16, laneBits: spec.laneBits, dot: true, legacy: spec.form == amd64PackedFloatingDotLegacy,
+	}
+	if !known {
+		return form, false, nil
+	}
+	fail := func() (x86PackedReductionForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go dot-product grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted {
+		return fail()
+	}
+	count := 3
+	if !form.legacy {
+		count, form.destination = 4, 3
+	}
+	if len(ins.Args) != count || arch == "386" && !form.legacy && !ins.x86Encoded && ins.x86SourceRaw == nil {
+		return fail()
+	}
+	immediate, valid := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !valid || !amd64UnsignedImmediate(immediate, 8) {
+		return fail()
+	}
+	form.immediate = uint8(immediate.Imm)
+	if !form.legacy {
+		form.byteWidth = amd64VectorByteWidth(ins.Args[form.destination].Reg)
+	}
+	if form.byteWidth != 16 && (spec.form != amd64PackedFloatingDotVEX128Or256 || form.byteWidth != 32) {
+		return fail()
+	}
+	register := func(operand Operand) bool {
+		index, ok := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		return operand.Kind == OpReg && ok && index < 16 && (arch != "386" || index < 8)
+	}
+	if !register(ins.Args[form.second]) || !register(ins.Args[form.destination]) {
+		return fail()
+	}
+	first := ins.Args[form.first]
+	if isAMD64MemoryOperand(first) {
+		if !x86PackedShiftMemoryValid(first, arch) {
+			return fail()
+		}
+		if first.Kind == OpMem && (x86SymbolIndexedMemoryError(first.Mem, arch) != nil || first.Mem.OffRaw != "" || first.Mem.IndexExt != "") {
+			return fail()
+		}
+		form.memory = form.first
+	} else if !register(first) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func (form x86PackedReductionForm) inputBytes() uint64 {
+	if !form.dot {
+		return x86CallerVectorByteMask(int64(form.byteWidth))
+	}
+	var result uint64
+	bytes := form.laneBits / 8
+	for block := 0; block < form.byteWidth; block += 16 {
+		for lane := 0; lane < 16/bytes; lane++ {
+			if form.immediate&(1<<uint(lane+4)) != 0 {
+				result |= x86CallerVectorByteMask(int64(bytes)) << uint(block+lane*bytes)
+			}
+		}
+	}
+	return result
+}
+
+func x86TypedPackedReductionByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86PackedReductionProperties(local, arch)
+	if known && ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		err = fmt.Errorf("reduction dispatch/source opcode mismatch")
+	}
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: width, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: width, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: width, write: true},
+	}}, true, nil
+}
diff --git a/amd64_packed_reduction_native.go b/amd64_packed_reduction_native.go
new file mode 100644
index 000000000..bda3b7cf6
--- /dev/null
+++ b/amd64_packed_reduction_native.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *amd64Ctx) lowerNativePackedReduction(op Op, ins Instr) (bool, bool, error) {
+	local := ins
+	local.Op = op
+	form, known, err := x86PackedReductionProperties(local, c.goarch)
+	if !known {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("reduction dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins = local
+	if err != nil {
+		return known, false, err
+	}
+	first := ins.Args[form.first]
+	if first.Kind == OpFP {
+		if form.legacy {
+			return true, false, fmt.Errorf("%w: %s m128 needs original native FP alignment/backing", ErrProbeNeedsContext, op)
+		}
+		if err := c.validateFPVectorSpan(first.FPOffset, form.byteWidth); err != nil {
+			return true, false, err
+		}
+	}
+	if form.memory >= 0 && (ins.x86AddressBits != 0 || first.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, form.first) && !x86CallerMemoryCertified(ins, form.first) && !c.fixedLocalMemoryCertified(ins, form.first)) {
+		return true, false, fmt.Errorf("%w: %s needs original native source backing", ErrProbeNeedsContext, op)
+	}
+	// Float carriers are bitcasts only. The exact original packed instruction
+	// performs every arithmetic operation, including MXCSR and NaN priority;
+	// no pure intrinsic, scalar expansion or load-folding assumption replaces it.
+	typ := amd64FloatingVectorType(form.byteWidth/4, 32)
+	load := func(operand Operand) (string, error) {
+		bytes, err := c.loadPackedCompareBytes(operand, form.byteWidth)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, form.byteWidth, bytes, typ)
+		return "%" + value, nil
+	}
+	second, err := load(ins.Args[form.second])
+	if err != nil {
+		return true, false, err
+	}
+	args, constraints := typ+" "+second, "=x,x"
+	if form.legacy {
+		constraints = "=x,0"
+	}
+	inputTemplate := "$2"
+	if form.memory >= 0 && first.Kind != OpFP {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(first)
+		if err != nil {
+			return true, false, err
+		}
+		segment := ""
+		if pointerType == "ptr addrspace(256)" {
+			segment = "%gs:"
+		} else if pointerType == "ptr addrspace(257)" {
+			segment = "%fs:"
+		}
+		inputTemplate = segment + "($2)"
+		args += ", " + pointerType + " " + pointer
+		constraints += ",r"
+	} else {
+		input, err := load(first)
+		if err != nil {
+			return true, false, err
+		}
+		args += ", " + typ + " " + input
+		constraints += ",x"
+	}
+	assembly := strings.ToLower(string(ins.Op)) + " "
+	if form.dot {
+		assembly += fmt.Sprintf("$$%d, ", form.immediate)
+	}
+	assembly += inputTemplate
+	if !form.legacy {
+		assembly += ", $1"
+	}
+	assembly += ", $0"
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, form.byteWidth)
+	if form.legacy {
+		return true, false, c.storeLegacyPackedLogical(ins.Args[form.destination], "%"+bytes)
+	}
+	return true, false, c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+bytes)
+}
diff --git a/amd64_packed_reduction_native_host_other_test.go b/amd64_packed_reduction_native_host_other_test.go
new file mode 100644
index 000000000..a2ca21eb8
--- /dev/null
+++ b/amd64_packed_reduction_native_host_other_test.go
@@ -0,0 +1,10 @@
+//go:build !linux || !amd64
+
+package plan9asm
+
+import "testing"
+
+func x86PackedReductionRequireNativeHost(t *testing.T) {
+	t.Helper()
+	t.Fatal("required native reduction owners execute only on actual Linux/amd64; other hosts retain their object and portable counterparts")
+}
diff --git a/amd64_packed_reduction_native_policy_test.go b/amd64_packed_reduction_native_policy_test.go
new file mode 100644
index 000000000..baf1320d6
--- /dev/null
+++ b/amd64_packed_reduction_native_policy_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PackedReductionNativeFunctions(path string) (map[string]*ast.FuncDecl, error) {
+	syntax, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		return nil, err
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range syntax.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			if functions[function.Name.Name] != nil {
+				return nil, fmt.Errorf("duplicate required native reduction function %s", function.Name.Name)
+			}
+			functions[function.Name.Name] = function
+		}
+	}
+	return functions, nil
+}
+
+func TestX86PackedReductionCompleteNativeOwners(t *testing.T) {
+	x86PackedReductionOriginalRuntimeProgramsUnchanged(t)
+	const path = "amd64_packed_reduction_runtime_linux_amd64_test.go"
+	functions, err := x86PackedReductionNativeFunctions(path)
+	if err != nil {
+		t.Log("required native reduction owners are missing", err)
+	}
+	want := make(map[string]bool)
+	for _, family := range []struct{ root, driver string }{
+		{"TestCrossLinuxRuntimeMatrixX86PackedReductionNativeValues", "x86PackedReductionNativeValues"},
+		{"TestCrossLinuxRuntimeMatrixX86PackedReductionNativeDeadFaults", "x86PackedReductionNativeFaults"},
+	} {
+		for part := 0; part < 4; part++ {
+			name := family.root + fmt.Sprintf("Part%d", part)
+			want[name] = true
+			t.Run(name, func(t *testing.T) {
+				function := functions[name]
+				if function == nil || function.Body == nil || len(function.Body.List) != 1 {
+					t.Fatal("missing or bypassed complete native reduction owner", name)
+				}
+				statement, ok := function.Body.List[0].(*ast.ExprStmt)
+				if !ok {
+					t.Fatal("native reduction owner must execute the complete direct driver", name)
+				}
+				call, ok := statement.X.(*ast.CallExpr)
+				if !ok {
+					t.Fatal("native reduction owner omitted its execution call", name)
+				}
+				callee, ok := call.Fun.(*ast.Ident)
+				if !ok || callee.Name != family.driver || len(call.Args) != 2 {
+					t.Fatal("native reduction owner substituted a sampled or object-only driver", name)
+				}
+				context, ok := call.Args[0].(*ast.Ident)
+				if !ok || context.Name != "t" {
+					t.Fatal("native reduction owner lost the real test context", name)
+				}
+				partition, ok := call.Args[1].(*ast.BasicLit)
+				if !ok || partition.Kind != token.INT || partition.Value != strconv.Itoa(part) {
+					t.Fatal("native reduction owner borrowed another partition", name)
+				}
+			})
+		}
+	}
+	for name := range functions {
+		if strings.HasPrefix(name, "Test") && !want[name] {
+			t.Error("unregistered native reduction owner", name)
+		}
+	}
+	t.Run("actual_native_host_selection", func(t *testing.T) {
+		for _, target := range []struct{ os, arch string }{
+			{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"}, {"linux", "arm64"},
+			{"js", "wasm"}, {"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+		} {
+			context := build.Default
+			context.GOOS, context.GOARCH = target.os, target.arch
+			selected, err := context.MatchFile(".", path)
+			if err != nil || selected != (target.os == "linux" && target.arch == "amd64") {
+				t.Fatal("native reduction owner lost its required matching-host selection", target, selected, err)
+			}
+		}
+	})
+}
+
+func TestX86PackedReductionCompleteNativeDriverRequired(t *testing.T) {
+	const path = "amd64_packed_reduction_native_tools_test.go"
+	functions, err := x86PackedReductionNativeFunctions(path)
+	if err != nil {
+		t.Fatal("missing real SSE3/SSE4.1/AVX reduction execution driver", err)
+	}
+	for _, required := range []string{"x86PackedReductionNativeTools", "x86PackedReductionNativePipelines"} {
+		if function := functions[required]; function == nil || function.Body == nil {
+			t.Fatal("missing complete native reduction driver", required)
+		}
+	}
+	function := functions["x86PackedReductionNativeTools"]
+	calls := make(map[string]int)
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if callee, ok := call.Fun.(*ast.Ident); ok {
+			calls[callee.Name]++
+			if callee.Name == "x86FloatCompareRuntimeTools" {
+				if len(call.Args) != 2 {
+					t.Fatal("native reductions lost the actual VEX execution route")
+				}
+				axis, ok := call.Args[1].(*ast.Ident)
+				if !ok || axis.Name != "x86FloatCompareVEX" {
+					t.Fatal("SSE3/SSE4.1/AVX reductions must not require AVX512 or borrow a weaker SSE axis")
+				}
+			}
+		}
+		if callee, ok := call.Fun.(*ast.SelectorExpr); ok {
+			calls[callee.Sel.Name]++
+			if callee.Sel.Name == "Skip" || callee.Sel.Name == "Skipf" || callee.Sel.Name == "SkipNow" {
+				t.Fatal("missing tools or CPU cannot skip a required native reduction owner")
+			}
+		}
+		return true
+	})
+	for _, required := range []string{"x86PackedReductionRequireNativeHost", "x86FloatCompareRuntimeTools", "compileC", "run"} {
+		if calls[required] != 1 {
+			t.Fatal("native reduction driver omitted actual host/CPU/opcode execution", required, calls[required])
+		}
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{
+		"SSE3=%u SSE41=%u AVX=%u OSXSAVE=%u XCR0=%llx",
+		"PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK", "__get_cpuid(1", "xgetbv", "(xcr0&6)!=6",
+		"dppd", "dpps", "vdppd", "vdpps", "haddps", "haddpd", "hsubps", "hsubpd",
+		"vhaddps", "vhaddpd", "vhsubps", "vhsubpd", "execution.prefix", "execution.preserveArgv0",
+		"backend_O0", "backend_O2", "IR_O2_backend_O2", "x86DwordProductIROptimize",
+		"compileAndRunLLVM", "string(got) != string(want)",
+	} {
+		if !strings.Contains(string(data), required) {
+			t.Fatal("native reductions omitted a CPU/opcode/pipeline obligation", required)
+		}
+	}
+	for _, forbidden := range []string{"x86FloatCompareEVEX", "avx512", "zmm", "0xe6"} {
+		if strings.Contains(string(data), forbidden) {
+			t.Fatal("X/Y native reduction owner improperly depends on AVX512/Z state", forbidden)
+		}
+	}
+}
diff --git a/amd64_packed_reduction_native_regression_test.go b/amd64_packed_reduction_native_regression_test.go
new file mode 100644
index 000000000..0f356b7a2
--- /dev/null
+++ b/amd64_packed_reduction_native_regression_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+type x86PackedReductionOracleRow struct {
+	row, mnemonic                     string
+	width, first, second, destination int
+	dot, legacy                       bool
+}
+
+// Independent complete yxshuf/_yvdppd/_yvblendpd and yxm/_yvaddsubpd
+// families: five dot shapes and twelve horizontal shapes, register/memory.
+// Selectors and every byte dependency are separate inexpensive unit axes.
+func x86PackedReductionOracleRows() []x86PackedReductionOracleRow {
+	var rows []x86PackedReductionOracleRow
+	for _, op := range []string{"DPPD", "DPPS", "VDPPD", "VDPPS"} {
+		banks := []string{"X"}
+		if op == "VDPPS" {
+			banks = append(banks, "Y")
+		}
+		for _, bank := range banks {
+			for _, memory := range []bool{false, true} {
+				first := bank + "0"
+				if memory {
+					first = "(BX)"
+				}
+				row := x86PackedReductionOracleRow{
+					row: op + " $255," + first + "," + bank + "1", mnemonic: strings.ToLower(op),
+					width: 16, first: 1, second: 2, destination: 2, dot: true, legacy: !strings.HasPrefix(op, "V"),
+				}
+				if bank == "Y" {
+					row.width = 32
+				}
+				if !row.legacy {
+					row.row += "," + bank + "2"
+					row.destination = 3
+				}
+				rows = append(rows, row)
+			}
+		}
+	}
+	for _, op := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD", "VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD"} {
+		banks := []string{"X"}
+		if strings.HasPrefix(op, "V") {
+			banks = append(banks, "Y")
+		}
+		for _, bank := range banks {
+			for _, memory := range []bool{false, true} {
+				first := bank + "0"
+				if memory {
+					first = "(BX)"
+				}
+				row := x86PackedReductionOracleRow{
+					row: op + " " + first + "," + bank + "1", mnemonic: strings.ToLower(op),
+					width: 16, first: 0, second: 1, destination: 1, legacy: !strings.HasPrefix(op, "V"),
+				}
+				if bank == "Y" {
+					row.width = 32
+				}
+				if !row.legacy {
+					row.row += "," + bank + "2"
+					row.destination = 2
+				}
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows
+}
+
+func x86PackedReductionOriginalRuntimeProgramsUnchanged(t *testing.T) {
+	t.Helper()
+	for _, original := range []struct{ path, name, hash string }{
+		{"amd64_lower_dot_float_test.go", "TestAMD64PackedFloatingDotRuntimeSemantics", "b928e394bd039f7f23a0fcbded8d22a0fbdb343d9d61b98c11d48bc95dcd11e5"},
+		{"amd64_horizontal_float_numerical_test.go", "TestCrossLinuxRuntimeMatrixX86HorizontalFloatCompletePhysicalSemantics", "8195e2105b0760edd32d4661d4af4909e3cbbd52819b3bdf9a62554f2b1ed076"},
+	} {
+		data, err := os.ReadFile(original.path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		set := token.NewFileSet()
+		syntax, err := parser.ParseFile(set, original.path, data, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, declaration := range syntax.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Name.Name != original.name {
+				continue
+			}
+			start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+			if fmt.Sprintf("%x", sha256.Sum256(data[start:end])) != original.hash {
+				t.Fatal("original initialized runtime source/reference/observations changed", original.name)
+			}
+			found = true
+		}
+		if !found {
+			t.Fatal("original runtime disappeared", original.name)
+		}
+	}
+}
+
+func TestX86PackedReductionOriginalInitializedNativePrograms(t *testing.T) {
+	x86PackedReductionOriginalRuntimeProgramsUnchanged(t)
+	for _, original := range []struct{ name, source, declaration, opcode string }{
+		{"dot", `TEXT floatdotsemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), CX
+	MOVQ b+16(FP), DX
+	MOVUPS 0(CX), X0
+	MOVUPS 0(DX), X1
+	STC
+	DPPS $0xf1, X0, X1
+	MOVUPS X1, 0(AX)
+	SETCS 16(AX)
+	RET
+`, "func floatdotsemantics(out,a,b *byte)", "dpps"},
+		{"horizontal", "TEXT horizontal0(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nSTC\nHADDPS X0,X1\nVMOVUPS Z1,(AX)\nSETCS 64(AX)\nRET\n",
+			"func horizontal0(out,a,b *byte)", "haddps"},
+	} {
+		t.Run(original.name, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", original.source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, original.source, original.declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatal("original initialized input/FLAGS/output program needs its missing native numerical continuation", err)
+					}
+					var native, reductions []string
+					moves := 0
+					for _, line := range strings.Split(ir, "\n") {
+						if !strings.Contains(line, "asm sideeffect") {
+							continue
+						}
+						native = append(native, strings.TrimSpace(line))
+						if strings.Contains(line, `asm sideeffect "`+original.opcode+" ") {
+							reductions = append(reductions, line)
+						}
+						if strings.Contains(line, `asm sideeffect "movups `) {
+							moves++
+						}
+					}
+					if len(reductions) != 1 || !strings.Contains(reductions[0], "~{fpsr}") || !strings.Contains(reductions[0], "~{memory}") ||
+						original.name == "dot" && moves != 3 {
+						t.Fatalf("original reduction/native moves lost exact effects: opcode=%s reductions=%d MOVUPS=%d\n%s", original.opcode, len(reductions), moves, strings.Join(native, "\n"))
+					}
+					t.Logf("original %s: %d whole reduction and %d native MOVUPS; exact IR effects:\n%s", original.opcode, len(reductions), moves, strings.Join(native, "\n"))
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedReductionCompleteTypedClassRegistration(t *testing.T) {
+	rows := x86PackedReductionOracleRows()
+	if len(rows) != 34 {
+		t.Fatal("complete12-member/17-shape/34-format reduction inventory changed", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range rows {
+			if arch == "386" && row.dot && !row.legacy {
+				continue // Go's named frontend cannot represent four operands.
+			}
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.row)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof {
+					t.Fatal("complete numerical reduction class is absent from typed effects", known, err)
+				}
+				reads, writes := make(map[int]bool), make(map[int]bool)
+				for _, operand := range effect.operands {
+					if operand.width != int64(row.width) {
+						t.Fatal("reduction borrowed another tuple or vector width", operand.width)
+					}
+					reads[operand.index] = reads[operand.index] || operand.read
+					writes[operand.index] = writes[operand.index] || operand.write
+				}
+				if !reads[row.first] || !reads[row.second] || !writes[row.destination] ||
+					!row.legacy && reads[row.destination] {
+					t.Fatal("missing source/legacy old-destination dependency or invented VEX merge", effect)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_reduction_native_tools_test.go b/amd64_packed_reduction_native_tools_test.go
new file mode 100644
index 000000000..d55798415
--- /dev/null
+++ b/amd64_packed_reduction_native_tools_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func x86PackedReductionNativeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	x86PackedReductionRequireNativeHost(t)
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareVEX)
+	if execution.triple != "x86_64-unknown-linux-gnu" || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("required native reductions cannot borrow guest or foreign execution")
+	}
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "reduction-cpu.c"), filepath.Join(directory, "reduction-cpu")
+	if err := os.WriteFile(source, []byte(x86PackedReductionNativePreflightC), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("actual native reduction CPU and all12 original opcodes: %s", execution.run(t, executable))
+	return execution
+}
+
+func x86PackedReductionNativePipelines(t *testing.T, execution x86FloatCompareExecution, ir, driver string, want []byte) {
+	t.Helper()
+	if len(want) == 0 {
+		t.Fatal("native reduction pipelines require original executed receipts")
+	}
+	for _, pipeline := range []struct {
+		name, backend string
+		optimize      bool
+	}{
+		{"backend_O0", "-O0", false},
+		{"backend_O2", "-O2", false},
+		{"IR_O2_backend_O2", "-O2", true},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			input := ir
+			if pipeline.optimize {
+				input = x86DwordProductIROptimize(t, ir)
+			}
+			got := execution.compileAndRunLLVM(t, "packed-reduction", input, driver, pipeline.backend)
+			if string(got) != string(want) {
+				t.Fatalf("original Go/native LLVM reductions differ\noriginal:\n%sLLVM:\n%s", want, got)
+			}
+		})
+	}
+}
+
+const x86PackedReductionNativePreflightC = `#include <stdint.h>
+#include <stdio.h>
+#include <cpuid.h>
+
+__attribute__((target("sse3,sse4.1,avx")))
+static unsigned original_members(void) {
+    unsigned members=0;
+    unsigned csr=0x1f80;
+    __asm__ volatile("ldmxcsr %0" :: "m"(csr) : "memory");
+#define CHECK(OP,DST,BIT) do { \
+    uint64_t out[4]; \
+    __asm__ volatile("vxorps %%ymm0,%%ymm0,%%ymm0; " \
+                     "vxorps %%ymm1,%%ymm1,%%ymm1; " \
+                     "vxorps %%ymm2,%%ymm2,%%ymm2; " \
+                     OP "; vmovups %%" DST ",%0" \
+                     : "=m"(out) :: "ymm0","ymm1","ymm2","memory"); \
+    for (unsigned i=0;i<4;i++) if(out[i]) return 0; \
+    members|=1u<<(BIT); \
+} while(0)
+    CHECK("dppd $255,%%xmm0,%%xmm1","ymm1",0);
+    CHECK("dpps $255,%%xmm0,%%xmm1","ymm1",1);
+    CHECK("vdppd $255,%%xmm0,%%xmm1,%%xmm2","ymm2",2);
+    CHECK("vdpps $255,%%ymm0,%%ymm1,%%ymm2","ymm2",3);
+    CHECK("haddps %%xmm0,%%xmm1","ymm1",4);
+    CHECK("haddpd %%xmm0,%%xmm1","ymm1",5);
+    CHECK("hsubps %%xmm0,%%xmm1","ymm1",6);
+    CHECK("hsubpd %%xmm0,%%xmm1","ymm1",7);
+    CHECK("vhaddps %%ymm0,%%ymm1,%%ymm2","ymm2",8);
+    CHECK("vhaddpd %%ymm0,%%ymm1,%%ymm2","ymm2",9);
+    CHECK("vhsubps %%ymm0,%%ymm1,%%ymm2","ymm2",10);
+    CHECK("vhsubpd %%ymm0,%%ymm1,%%ymm2","ymm2",11);
+#undef CHECK
+    return members;
+}
+
+int main(void) {
+    unsigned a,b,c,d,sse3=0,sse41=0,avx=0,osxsave=0;
+    uint64_t xcr0=0;
+    if (__get_cpuid(1,&a,&b,&c,&d)) {
+        sse3=c&1; sse41=(c>>19)&1; avx=(c>>28)&1; osxsave=(c>>27)&1;
+        if (osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    printf("SSE3=%u SSE41=%u AVX=%u OSXSAVE=%u XCR0=%llx\n",
+           sse3,sse41,avx,osxsave,(unsigned long long)xcr0);
+    fflush(stdout);
+    if (!sse3 || !sse41 || !avx || !osxsave || (xcr0&6)!=6) return 1;
+    if (original_members()!=0xfff) return 2;
+    puts("PACKED_REDUCTION_NATIVE_SSE3_SSE41_AVX_OK members=fff");
+    return 0;
+}
+`
diff --git a/amd64_packed_reduction_objects_test.go b/amd64_packed_reduction_objects_test.go
new file mode 100644
index 000000000..5b5ec3e6e
--- /dev/null
+++ b/amd64_packed_reduction_objects_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedReductionInitializedFixture(name, arch, instruction string, destination int) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s p+0(FP),BX\n"+
+		"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nSTC\n%s\nVMOVDQU64 Z%d,(AX)\nSETCS 64(AX)\nRET\n",
+		name, word, move, move, instruction, destination), "func " + name + "(p *byte)\n"
+}
+
+func TestX86PackedReductionCompleteInitializedNamedRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86PackedReductionOracleRows()
+	raw := x86PackedReductionOriginalRawRows(t, rows)
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, spelling := range []string{"named", "raw"} {
+				t.Run(spelling, func(t *testing.T) {
+					var source, declarations strings.Builder
+					count := 0
+					for index, row := range rows {
+						if target.arch == "386" && spelling == "named" && row.dot && !row.legacy {
+							continue
+						}
+						instruction := row.row
+						if spelling == "raw" {
+							instruction = raw[index]
+						}
+						destination := 1
+						if !row.legacy {
+							destination = 2
+						}
+						body, declaration := x86PackedReductionInitializedFixture(fmt.Sprintf("Reduction%d", index), target.arch, instruction, destination)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+						count++
+					}
+					if count != 34 && !(target.arch == "386" && spelling == "named" && count == 28) {
+						t.Fatal("complete reduction source matrix lost rows", count)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("complete initialized reduction source rejected", err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							for _, pipeline := range []struct{ name, ir, backend string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									if strings.Count(pipeline.ir, "asm sideeffect") != count || strings.Count(pipeline.ir, "~{fpsr}") != count ||
+										strings.Contains(pipeline.ir, "call <4 x float> @llvm.x86.sse41.dpps") ||
+										strings.Contains(pipeline.ir, "@__plan9asm_add_sub_special") {
+										t.Fatal("reduction lost whole native arithmetic/MXCSR effects or retained replaced software helpers")
+									}
+									x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.backend)
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_reduction_runtime_fixture_test.go b/amd64_packed_reduction_runtime_fixture_test.go
new file mode 100644
index 000000000..6af40d12c
--- /dev/null
+++ b/amd64_packed_reduction_runtime_fixture_test.go
@@ -0,0 +1,262 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const (
+	x86PackedReductionNativeOwners = 4
+	x86PackedReductionValueCapture = 64
+	x86PackedReductionFaultCapture = 8
+)
+
+type x86PackedReductionRuntimeRow struct {
+	oracle      x86PackedReductionOracleRow
+	instruction string
+	destination int
+	selector    byte
+	memory      bool
+	self        bool
+}
+
+func x86PackedReductionNativeRows(faults bool) []x86PackedReductionRuntimeRow {
+	var rows []x86PackedReductionRuntimeRow
+	for _, oracle := range x86PackedReductionOracleRows() {
+		if strings.Contains(oracle.row, "(BX)") {
+			continue
+		}
+		selectors := []byte{0}
+		if oracle.dot {
+			selectors = []byte{0, 0x0f, 0x10, 0x11, 0x5a, 0x7f, 0xf0, 0xf1, 0xff}
+			if strings.HasSuffix(oracle.mnemonic, "pd") {
+				selectors = []byte{0, 0x0f, 0x10, 0x11, 0x33, 0xcc, 0xff}
+			}
+			if faults {
+				selectors = []byte{0, 0x0f, 0xf0, 0xf1, 0xff}
+			}
+		}
+		for _, selector := range selectors {
+			variants := 6
+			if oracle.legacy {
+				variants = 3
+			}
+			if faults {
+				variants = 1
+			}
+			for variant := 0; variant < variants; variant++ {
+				row := x86PackedReductionRuntimeRow{oracle: oracle, selector: selector}
+				row.destination, row.memory = variant/2, variant%2 == 1
+				if oracle.legacy {
+					row.destination, row.self = 1, variant == 2
+				}
+				if faults {
+					row.memory, row.destination = true, 2
+					if oracle.legacy {
+						row.destination = 1
+					}
+				}
+				bank := "X"
+				if oracle.width == 32 {
+					bank = "Y"
+				}
+				first := bank + "0"
+				if row.self {
+					first = bank + "1"
+				}
+				if row.memory {
+					first = "(SI)"
+					if faults {
+						first = "(DI)"
+					}
+				}
+				row.instruction = strings.ToUpper(oracle.mnemonic) + " "
+				if oracle.dot {
+					row.instruction += fmt.Sprintf("$%d,", selector)
+				}
+				row.instruction += first + "," + bank + "1"
+				if !oracle.legacy {
+					row.instruction += fmt.Sprintf(",%s%d", bank, row.destination)
+				}
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows
+}
+
+func x86PackedReductionRuntimeExpectedBytes(row x86PackedReductionRuntimeRow, faults bool) []byte {
+	code := x86PackedReductionIndependentFixtureBytes(row.oracle)
+	modRM := byte(0xc0 | row.destination<<3)
+	if row.self {
+		modRM |= 1
+	}
+	if row.memory {
+		modRM = byte(row.destination<<3 | 6) // Runtime's actual (SI).
+		if faults {
+			modRM = byte(row.destination<<3 | 7) // Dead native source is (DI).
+		}
+	}
+	index := len(code) - 1
+	if row.oracle.dot {
+		index--
+		code[index+1] = row.selector
+	}
+	code[index] = modRM
+	return code
+}
+
+func x86PackedReductionRuntimeRawRows(t *testing.T, rows []x86PackedReductionRuntimeRow, faults bool) []string {
+	t.Helper()
+	var instructions []string
+	var oracle []x86PackedReductionOracleRow
+	var expected [][]byte
+	for _, row := range rows {
+		instructions = append(instructions, row.instruction)
+		item := row.oracle
+		item.row = row.instruction
+		oracle = append(oracle, item)
+		expected = append(expected, x86PackedReductionRuntimeExpectedBytes(row, faults))
+	}
+	listing, err := x86ExtensionGoListing(t, "amd64", strings.Join(instructions, "\n"))
+	if err != nil {
+		t.Fatalf("actual runtime instruction Go listing: %v\n%s", err, listing)
+	}
+	raw, err := x86PackedReductionRawRowsFromGoListingWithExpected(listing, oracle, expected)
+	if err != nil {
+		t.Fatalf("independent runtime original opcode/PC boundaries: %v\n%s", err, listing)
+	}
+	return raw
+}
+
+func x86PackedReductionRuntimeFixture(rows []x86PackedReductionRuntimeRow) (assembly, declarations, original, driver string) {
+	var asm, decl, goCalls, cDecl, cCalls strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("reduction%d", index)
+		fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-36\nSTMXCSR saved-4(SP)\n"+
+			"MOVQ out+0(FP),DI\nMOVQ a+8(FP),SI\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),CX\n"+
+			"VMOVDQU (SI),Y0\nVMOVDQU (DX),Y1\nVMOVDQU (CX),Y2\n"+
+			"LDMXCSR csr+32(FP)\nMOVQ $-1,R8\nCMPQ R8,$-1\n%s\n"+
+			"VMOVDQU Y%d,(DI)\nSTMXCSR 40(DI)\nSETEQ 32(DI)\nSETCS 33(DI)\n"+
+			"SETOS 34(DI)\nSETMI 35(DI)\nSETPC 36(DI)\nLDMXCSR saved-4(SP)\nRET\n",
+			name, row.instruction, row.destination)
+		fmt.Fprintf(&decl, "func %s(out *[8]uint64,a,b,old *[4]uint64,csr uint32)\n", name)
+		bits := 32
+		if strings.HasSuffix(row.oracle.mnemonic, "pd") {
+			bits = 64
+		}
+		fmt.Fprintf(&goCalls, "check(%d,%d,%s)\n", index, bits, name)
+		fmt.Fprintf(&cDecl, "extern void %s(uint64_t*,const uint64_t*,const uint64_t*,const uint64_t*,uint32_t);\n", name)
+		fmt.Fprintf(&cCalls, "check(%d,%d,%s);\n", index, bits, name)
+	}
+	var gValues, cValues strings.Builder
+	values := append(append([]uint64(nil), x86ScalarFloatIntegerSSInputs...), x86ScalarFloatIntegerSDInputs...)
+	for _, value := range values {
+		fmt.Fprintf(&gValues, "%#x,", value)
+		fmt.Fprintf(&cValues, "UINT64_C(%#x),", value)
+	}
+	original = `package main
+import ("fmt";"unsafe")
+var values=[]uint64{` + gValues.String() + `}
+func check(index,bits int,fn func(*[8]uint64,*[4]uint64,*[4]uint64,*[4]uint64,uint32)) {
+    hash:=uint64(1469598103934665603);count:=0
+    for n:=range values {for rc:=0;rc<4;rc++ {for controls:=0;controls<8;controls++ {
+        var backing [3][6]uint64
+        var inputs [3]*[4]uint64
+        for source:=range inputs {
+            p:=unsafe.Pointer(&backing[source][0])
+            inputs[source]=(*[4]uint64)(unsafe.Add(p,(-uintptr(p))&15))
+            for lane:=range inputs[source] {
+                start:=n+2*lane+7*source
+                value:=values[start%len(values)]
+                if bits==32 {value=uint64(uint32(value))|uint64(uint32(values[(start+1)%len(values)]))<<32}
+                inputs[source][lane]=value
+            }
+        }
+        var out [8]uint64
+        for lane:=range out {out[lane]=uint64(lane+1)*0x0101010101010101}
+        csr:=uint32(0x1f80|rc<<13)
+        if controls&1!=0 {csr|=0x40};if controls&2!=0 {csr|=0x8000};if controls&4!=0 {csr|=0x21}
+        fn(&out,inputs[0],inputs[1],inputs[2],csr)
+        for _,word:=range out {for shift:=0;shift<64;shift+=8 {hash=(hash^uint64(byte(word>>shift)))*1099511628211}}
+        count++
+    }}}
+    fmt.Printf("%d %d %016x\n",index,count,hash)
+}
+` + decl.String() + "func main(){\n" + goCalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static const uint64_t values[]={` + cValues.String() + `};
+static void check(unsigned index,unsigned bits,void (*fn)(uint64_t*,const uint64_t*,const uint64_t*,const uint64_t*,uint32_t)) {
+    uint64_t hash=UINT64_C(1469598103934665603);unsigned count=0,N=sizeof(values)/sizeof(*values);
+    for(unsigned n=0;n<N;n++) for(unsigned rc=0;rc<4;rc++) for(unsigned controls=0;controls<8;controls++) {
+        _Alignas(16) uint64_t inputs[3][4],out[8];
+        for(unsigned source=0;source<3;source++) for(unsigned lane=0;lane<4;lane++) {
+            unsigned start=n+2*lane+7*source;
+            uint64_t value=values[start%N];
+            if(bits==32) value=(uint64_t)(uint32_t)value|(uint64_t)(uint32_t)values[(start+1)%N]<<32;
+            inputs[source][lane]=value;
+        }
+        for(unsigned lane=0;lane<8;lane++) out[lane]=(lane+1)*UINT64_C(0x0101010101010101);
+        uint32_t csr=0x1f80|(rc<<13);
+        if(controls&1) csr|=0x40;if(controls&2) csr|=0x8000;if(controls&4) csr|=0x21;
+        fn(out,inputs[0],inputs[1],inputs[2],csr);
+        for(unsigned lane=0;lane<8;lane++) for(unsigned shift=0;shift<64;shift+=8) hash=(hash^(uint8_t)(out[lane]>>shift))*UINT64_C(1099511628211);
+        count++;
+    }
+    printf("%u %u %016llx\n",index,count,(unsigned long long)hash);
+}
+` + cDecl.String() + "int main(void){\n" + cCalls.String() + "return 0;}\n"
+	return asm.String(), decl.String(), original, driver
+}
+
+func TestX86PackedReductionCompleteNativeFixtureInventory(t *testing.T) {
+	for _, faults := range []bool{false, true} {
+		rows := x86PackedReductionNativeRows(faults)
+		want := 258
+		if faults {
+			want = 37
+		}
+		if len(rows) != want {
+			t.Fatal("complete semantic class lost value/fault shapes", faults, len(rows))
+		}
+		members := make(map[string]map[int]bool)
+		owners := [4]int{}
+		limit := x86PackedReductionValueCapture
+		if faults {
+			limit = x86PackedReductionFaultCapture
+		}
+		for index, row := range rows {
+			if members[row.oracle.mnemonic] == nil {
+				members[row.oracle.mnemonic] = make(map[int]bool)
+			}
+			members[row.oracle.mnemonic][row.oracle.width] = true
+			owners[index/limit%4]++
+			if strings.Contains(row.instruction, "Z") || row.oracle.width > 32 {
+				t.Fatal("native X/Y fixture acquired physical Z state", row.instruction)
+			}
+		}
+		for _, name := range []string{"dppd", "dpps", "vdppd", "vdpps", "haddps", "haddpd", "hsubps", "hsubpd", "vhaddps", "vhaddpd", "vhsubps", "vhsubpd"} {
+			widths := members[name]
+			want := map[int]bool{16: true}
+			if name == "vdpps" || strings.HasPrefix(name, "vh") {
+				want[32] = true
+			}
+			if !reflect.DeepEqual(widths, want) {
+				t.Fatal("native member omitted an independent physical width", faults, name, widths)
+			}
+		}
+		if len(members) != 12 {
+			t.Fatal("native semantic class lost or invented members", members)
+		}
+		for owner, count := range owners {
+			if count == 0 {
+				t.Fatal("empty native semantic owner", faults, owner)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_reduction_runtime_linux_amd64_test.go b/amd64_packed_reduction_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..061eb9431
--- /dev/null
+++ b/amd64_packed_reduction_runtime_linux_amd64_test.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import "testing"
+
+func x86PackedReductionRequireNativeHost(t *testing.T) {
+	t.Helper()
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeValuesPart0(t *testing.T) {
+	x86PackedReductionNativeValues(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeValuesPart1(t *testing.T) {
+	x86PackedReductionNativeValues(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeValuesPart2(t *testing.T) {
+	x86PackedReductionNativeValues(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeValuesPart3(t *testing.T) {
+	x86PackedReductionNativeValues(t, 3)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeDeadFaultsPart0(t *testing.T) {
+	x86PackedReductionNativeFaults(t, 0)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeDeadFaultsPart1(t *testing.T) {
+	x86PackedReductionNativeFaults(t, 1)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeDeadFaultsPart2(t *testing.T) {
+	x86PackedReductionNativeFaults(t, 2)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedReductionNativeDeadFaultsPart3(t *testing.T) {
+	x86PackedReductionNativeFaults(t, 3)
+}
diff --git a/amd64_packed_reduction_runtime_objects_test.go b/amd64_packed_reduction_runtime_objects_test.go
new file mode 100644
index 000000000..26a06ef49
--- /dev/null
+++ b/amd64_packed_reduction_runtime_objects_test.go
@@ -0,0 +1,97 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedReductionNativeFixtureObjects(t *testing.T, faults bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86PackedReductionNativeRows(faults)
+	limit := x86PackedReductionValueCapture
+	if faults {
+		limit = x86PackedReductionFaultCapture
+	}
+	consumed := 0
+	for start := 0; start < len(rows); start += limit {
+		end := start + limit
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			current := rows[start:end]
+			var original [][]byte
+			if faults {
+				original = x86PackedReductionFaultOriginalBytes(t, current)
+			}
+			fixture := func(rows []x86PackedReductionRuntimeRow) (string, string) {
+				if faults {
+					assembly, declarations, _ := x86PackedReductionFaultFixture(rows, original)
+					return assembly, declarations
+				}
+				assembly, declarations, _, _ := x86PackedReductionRuntimeFixture(rows)
+				return assembly, declarations
+			}
+			assembly, declarations := fixture(current)
+			raw := x86PackedReductionRuntimeRawRows(t, current, faults)
+			rawRows := append([]x86PackedReductionRuntimeRow(nil), current...)
+			for index := range rawRows {
+				rawRows[index].instruction = raw[index]
+			}
+			rawAssembly, _ := fixture(rawRows)
+			for _, spelling := range []struct{ name, source string }{{"named", assembly}, {"raw", rawAssembly}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", spelling.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+							if err != nil {
+								t.Fatal("initialized native runtime fixture rejected before execution", err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							for _, pipeline := range []struct{ name, ir, backend string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									for index, row := range current {
+										name := fmt.Sprintf("reduction%d", index)
+										if faults {
+											name = fmt.Sprintf("reductionfault%d", index)
+										}
+										_, body, found := strings.Cut(pipeline.ir, "define void @"+name+"(")
+										body, _, ended := strings.Cut(body, "\n}")
+										if !found || !ended || strings.Count(body, `asm sideeffect "`+row.oracle.mnemonic+` `) != 1 ||
+											!strings.Contains(body, "~{fpsr}") || !strings.Contains(body, "~{memory}") {
+											t.Fatal("actual runtime fixture lost the original whole arithmetic/exception effect", row.instruction)
+										}
+									}
+									x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", pipeline.ir, pipeline.backend)
+								})
+							}
+						})
+					}
+				})
+			}
+			consumed += len(current)
+		})
+	}
+	if consumed != len(rows) {
+		t.Fatal("native runtime object partition lost initialized rows", consumed, len(rows))
+	}
+	t.Logf("all%d actual native runtime kernels have initialized Go/public3API/3pipeline objects; this is not native execution", consumed)
+}
+
+func TestX86PackedReductionNativeValueFixtureObjects(t *testing.T) {
+	x86PackedReductionNativeFixtureObjects(t, false)
+}
+
+func TestX86PackedReductionNativeFaultFixtureObjects(t *testing.T) {
+	x86PackedReductionNativeFixtureObjects(t, true)
+}
diff --git a/amd64_packed_reduction_runtime_test.go b/amd64_packed_reduction_runtime_test.go
new file mode 100644
index 000000000..4f2eb1717
--- /dev/null
+++ b/amd64_packed_reduction_runtime_test.go
@@ -0,0 +1,75 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedReductionNativeValues(t *testing.T, owner int) {
+	t.Helper()
+	if owner < 0 || owner >= x86PackedReductionNativeOwners {
+		t.Fatal("invalid complete native reduction value owner", owner)
+	}
+	execution := x86PackedReductionNativeTools(t)
+	rows := x86PackedReductionNativeRows(false)
+	if len(rows) != 258 {
+		t.Fatal("complete native reduction value denominator changed", len(rows))
+	}
+	consumed := 0
+	for batch, start := 0, 0; start < len(rows); batch, start = batch+1, start+x86PackedReductionValueCapture {
+		if batch%x86PackedReductionNativeOwners != owner {
+			continue
+		}
+		end := start + x86PackedReductionValueCapture
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			current := rows[start:end]
+			assembly, declarations, original, driver := x86PackedReductionRuntimeFixture(current)
+			var want []byte
+			t.Run("original_go_named", func(t *testing.T) {
+				want = x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original)
+				if strings.Count(string(want), "\n") != len(current) {
+					t.Fatal("incomplete original named Go reduction execution receipts")
+				}
+			})
+			raw := x86PackedReductionRuntimeRawRows(t, current, false)
+			rawRows := append([]x86PackedReductionRuntimeRow(nil), current...)
+			for index := range rawRows {
+				rawRows[index].instruction = raw[index]
+			}
+			rawAssembly, _, rawOriginal, _ := x86PackedReductionRuntimeFixture(rawRows)
+			t.Run("original_go_raw", func(t *testing.T) {
+				got := x86ScalarFloatIntegerOriginalOutput(t, execution, rawAssembly, rawOriginal)
+				if string(got) != string(want) || len(want) == 0 {
+					t.Fatal("original named/raw Go reduction execution differs or lost receipts")
+				}
+			})
+			if len(want) == 0 {
+				t.Fatal("missing actual original Go reduction execution")
+			}
+			for _, spelling := range []struct{ name, source string }{{"named", assembly}, {"raw", rawAssembly}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations, "amd64", execution.triple, api)
+							if err != nil {
+								t.Fatal("initialized native reduction value source rejected", err)
+							}
+							x86PackedReductionNativePipelines(t, execution, ir, driver, want)
+						})
+					}
+				})
+			}
+			consumed += len(current)
+		})
+	}
+	if consumed == 0 {
+		t.Fatal("empty complete native reduction value owner")
+	}
+	t.Logf("%d/258 actual named/raw Go kernels, full physical Y32 aliases/FLAGS/MXCSR,3 APIs and3 LLVM execution paths", consumed)
+}
diff --git a/amd64_packed_rotate_fault_runtime_unix_test.go b/amd64_packed_rotate_fault_runtime_unix_test.go
new file mode 100644
index 000000000..cfd7d8652
--- /dev/null
+++ b/amd64_packed_rotate_fault_runtime_unix_test.go
@@ -0,0 +1,67 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The output is deliberately dead. Active native reads must still fault,
+// while inactive E4 elements and broadcasts must not read their address.
+func TestX86PackedRotateDeadE4MemoryFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, family := range x86PackedRotateTestFamilies {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				for _, zeroing := range []bool{false, true} {
+					name := fmt.Sprint("RotateFault", count)
+					count++
+					width := amd64VectorByteWidth(Reg(bank + "0"))
+					extent, suffix := width, ""
+					if broadcast {
+						extent, suffix = family.bits/8, ".BCST"
+					}
+					if zeroing {
+						suffix += ".Z"
+					}
+					operands := fmt.Sprintf("$255,(AX),K1,%s2", bank)
+					if family.variable {
+						operands = fmt.Sprintf("(AX),%s1,K1,%s2", bank, bank)
+					}
+					fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\n"+
+						"KMOVQ mask+8(FP),K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s%s %s\nRET\n",
+						name, family.op, suffix, operands)
+					fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *,uint64_t);\n", name)
+					fmt.Fprintf(&rows, "{%s,%d,%d,%d},\n", name, extent, family.bits/8, width*8/family.bits)
+				}
+			}
+		}
+	}
+	if count != 96 {
+		t.Fatal("incomplete rotate width/broadcast/merge memory inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86E4DeadReadFaultOracle(prototypes.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("complete dead rotate source rejected", err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					execution.compileAndRunLLVM(t, "rotate-e4-faults", input, driver, level)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_rotate_format_test.go b/amd64_packed_rotate_format_test.go
new file mode 100644
index 000000000..ec5bc7753
--- /dev/null
+++ b/amd64_packed_rotate_format_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Preserve the original Go object and three public Context outcomes before
+// classifying physical emitter rows. A format object supplies no entry values.
+func x86PackedRotateUnboundFormatObject(t *testing.T, source, arch, triple string, wantPhysical, wantContext int) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("original rotate formats lost their decoded source", err)
+	}
+	units := *normalized
+	units.Funcs = nil
+	physical, contextual := 0, 0
+	for _, function := range normalized.Funcs {
+		unit := function
+		unit.Instrs = nil
+		for _, instruction := range function.Instrs {
+			if instruction.Op != OpTEXT && instruction.Op != OpRET {
+				_, known, err := x86PackedRotateProperties(instruction.Op, instruction, arch)
+				if known && errors.Is(err, ErrProbeNeedsContext) && arch == "386" &&
+					x86Mode32VectorRegisterContext(instruction, arch) != nil {
+					contextual++
+					continue // Retained by the complete original Go/public Context controls.
+				}
+				if !known || err != nil {
+					t.Fatal("original rotate row lost its complete typed grammar", instruction.Raw, err)
+				}
+				physical++
+			}
+			unit.Instrs = append(unit.Instrs, instruction)
+		}
+		units.Funcs = append(units.Funcs, unit)
+	}
+	if physical != wantPhysical || contextual != wantContext {
+		t.Fatal("original rotate format classification changed", physical, contextual, wantPhysical, wantContext)
+	}
+	t.Logf("%d physical emitter formats; %d Go-accepted mode32 high-bank Context rows; no initialized/native claim", physical, contextual)
+	return x86InstructionFormatObjectUnit(t, &units, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return c.lowerPackedRotate(instruction.Op, instruction)
+		})
+}
diff --git a/amd64_packed_rotate_forms.go b/amd64_packed_rotate_forms.go
new file mode 100644
index 000000000..59311e073
--- /dev/null
+++ b/amd64_packed_rotate_forms.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedRotateForm struct {
+	x86PackedBinaryForm
+	spec      amd64PackedRotateSpec
+	immediate uint8
+}
+
+// Go's _yvprold and _yvblendmpd differ only in the count/data role. Both
+// retain the shared EVEX width, register, mask and scalar-broadcast grammar.
+func x86PackedRotateProperties(op Op, ins Instr, arch string) (x86PackedRotateForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedRotateSpecs[Op(base)]
+	form := x86PackedRotateForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return form, true, fmt.Errorf("%s %s has an unbound dispatch or operand count", arch, op)
+	}
+	local := ins
+	local.Op = op
+	if !spec.variable {
+		if !amd64UnsignedImmediate(ins.Args[0], 8) || ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" {
+			return form, true, fmt.Errorf("%s %s requires the original unsigned imm8", arch, op)
+		}
+		form.immediate = uint8(ins.Args[0].Imm)
+		destination := ins.Args[len(ins.Args)-1]
+		// The extra destination exists only for unary shape validation. It
+		// never becomes a numerical input to the immediate operation.
+		local.Args = []Operand{ins.Args[1], destination, destination}
+		if len(ins.Args) == 4 {
+			local.Args = []Operand{ins.Args[1], destination, ins.Args[2], destination}
+		}
+	}
+	var err error
+	form.x86PackedBinaryForm, err = x86ConflictFunnelOperandGrammar(local, arch,
+		x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: spec.laneBits / 8, zeroing: true}, false)
+	if !spec.variable {
+		form.first, form.second, form.destination = 1, -1, len(ins.Args)-1
+		if form.memory >= 0 {
+			form.memory = 1
+		}
+	}
+	return form, true, err
+}
+
+func x86TypedPackedRotateByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedRotateProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true,
+		vector: x86TypedVectorEffect{x86TypedVectorUpperZero, 1},
+		operands: []x86TypedByteOperand{
+			{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+			{index: form.destination, operand: ins.Args[form.destination], width: width,
+				read: form.mask >= 0 && !form.zeroing, write: true},
+		}}
+	if form.second >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.second, operand: ins.Args[form.second], width: width, read: true})
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_rotate_inputs_test.go b/amd64_packed_rotate_inputs_test.go
new file mode 100644
index 000000000..f2248e256
--- /dev/null
+++ b/amd64_packed_rotate_inputs_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedRotateCompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, family := range x86PackedRotateTestFamilies {
+		classes := []string{"YxmEvex,YxrEvex", "YxmEvex,Yknot0,YxrEvex",
+			"YymEvex,YyrEvex", "YymEvex,Yknot0,YyrEvex", "Yzm,Yzr", "Yzm,Yknot0,Yzr"}
+		table, plain, masked, stride := "_yvprold", "Zevex_i_rm_vo", "Zevex_i_rm_k_vo", 4
+		for index, class := range classes {
+			if family.variable {
+				parts := strings.Split(class, ",")
+				classes[index] = parts[0] + "," + parts[len(parts)-1] + "," + strings.Join(parts[1:], ",")
+			} else {
+				classes[index] = "Yu8," + class
+			}
+		}
+		if family.variable {
+			table, plain, masked, stride = "_yvblendmpd", "Zevex_rm_v_r", "Zevex_rm_v_k_r", 3
+		}
+		var attributes []string
+		for _, width := range []int{128, 256, 512} {
+			mapName, opcode := "evex0F", "0x72"
+			if family.variable {
+				mapName, opcode = "evex0F38", "0x14"
+				if family.left {
+					opcode = "0x15"
+				}
+			}
+			attributes = append(attributes,
+				fmt.Sprintf("avxEscape | evex%d | evex66 | %s | evexW%d", width, mapName, family.bits/32-1),
+				fmt.Sprintf("evexN%d | evexBcstN%d | evexZeroingEnabled", width/8, family.bits/8), opcode)
+			if !family.variable {
+				direction := "00"
+				if family.left {
+					direction = "01"
+				}
+				attributes = append(attributes, direction)
+			}
+		}
+		count := 0
+		for _, rule := range rules {
+			if rule.Opcode != family.op {
+				continue
+			}
+			zcase := plain
+			if count%2 != 0 {
+				zcase = masked
+			}
+			if count >= 6 || rule.RowIndex != count || rule.Ytab != table || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*stride || rule.EncodingOffset != count/2*stride ||
+				strings.Join(rule.Classes, ",") != classes[count] || !reflect.DeepEqual(rule.OpBytes, attributes) {
+				t.Fatal("independent rotate Go encoding row changed", family.op, rule)
+			}
+			count++
+		}
+		if count != 6 {
+			t.Fatal("incomplete rotate Go encoding inventory", family.op, count)
+		}
+	}
+}
+
+func TestX86PackedRotateExactNumericalInputs(t *testing.T) {
+	for _, family := range x86PackedRotateTestFamilies {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			width := amd64VectorByteWidth(Reg(bank + "0"))
+			for mode := 0; mode < 3; mode++ {
+				op, mask := family.op, ""
+				if mode != 0 {
+					mask = "K1,"
+				}
+				if mode == 2 {
+					op += ".Z"
+				}
+				args := "$7," + bank + "1,"
+				if family.variable {
+					args = bank + "0," + bank + "1,"
+				}
+				ins := x86ScalarLaneInstruction(t, op+" "+args+mask+bank+"2")
+				for missingRegister := 0; missingRegister < 4; missingRegister++ {
+					for missingByte := -1; missingByte < 64; missingByte++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						for register := 0; register < 4; register++ {
+							bytes := ^uint64(0)
+							if register == missingRegister && missingByte >= 0 {
+								bytes &^= 1 << uint(missingByte)
+							}
+							state.writeVector(register, 64, bytes, false)
+						}
+						state.masks[1] = missingRegister != 3 || missingByte != 0
+						before, want := state.clone(), state.clone()
+						required := missingRegister == 1 || missingRegister == 0 && family.variable || missingRegister == 2 && mode == 1
+						accepted := !(required && missingByte >= 0 && missingByte < width || mode != 0 && !state.masks[1])
+						if accepted {
+							want.writeVector(2, width, x86CallerVectorByteMask(int64(width)), false)
+						}
+						if got := x86ResultTransfer(ins, &state, nil, 0, "amd64"); got != accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("rotate fabricated input bytes, lost upper zeroing or changed unrelated state", ins.Raw, missingRegister, missingByte, got, accepted, before, state)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedRotateRejectsUnresolvedShapesBeforeIR(t *testing.T) {
+	for _, family := range x86PackedRotateTestFamilies {
+		for _, mutation := range []string{"suffix", "offset", "extension", "segment", "index", "absolute", "dispatch", "address", "float", "unresolved"} {
+			if family.variable && (mutation == "float" || mutation == "unresolved") {
+				continue
+			}
+			t.Run(family.op+"/"+mutation, func(t *testing.T) {
+				args, source := "$7,(AX),X2", 1
+				if family.variable {
+					args, source = "(AX),X1,X2", 0
+				}
+				ins := x86ScalarLaneInstruction(t, family.op+" "+args)
+				op := ins.Op
+				switch mutation {
+				case "suffix":
+					op += ".SAE"
+					ins.Op = op
+				case "offset":
+					ins.Args[source].Mem.OffRaw = "UNKNOWN"
+				case "extension":
+					ins.Args[source].Mem.IndexExt = "UXTW"
+				case "segment":
+					ins.Args[source].Mem.Segment = "DS"
+				case "index":
+					ins.Args[source].Mem.Index, ins.Args[source].Mem.Scale = SP, 2
+				case "absolute":
+					ins.Args[source] = Operand{Kind: OpSym, Sym: "4294967296"}
+				case "dispatch":
+					ins.Op = "VPXORD"
+				case "address":
+					ins.x86AddressBits = 32
+				case "float":
+					ins.Args[0].ImmIsFloat = true
+				case "unresolved":
+					ins.Args[0].ImmRaw = "UNKNOWN"
+				}
+				var ir strings.Builder
+				consumer := &amd64Ctx{b: &ir, goarch: "amd64"}
+				known, _, err := consumer.lowerPackedRotate(op, ins)
+				if !known || err == nil || ir.Len() != 0 {
+					t.Fatal("invalid rotate shape reached IR", known, err, ir.String())
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedRotateNativeReadKeepsOwnership(t *testing.T) {
+	for _, family := range x86PackedRotateTestFamilies {
+		args := "$7,-1(SI)(BX*2),X2"
+		if family.variable {
+			args = "-1(SI)(BX*2),X1,X2"
+		}
+		ins := x86ScalarLaneInstruction(t, family.op+" "+args)
+		for _, missing := range []string{"none", "pointer", "index", "pointer index", "raw", "address"} {
+			t.Run(fmt.Sprint(family.op, "/", missing), func(t *testing.T) {
+				state, changed := x86ResultState{}, ins
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.pointerGP[6], state.gp[3] = true, 0xff
+				switch missing {
+				case "pointer":
+					state.pointerGP[6] = false
+				case "index":
+					state.gp[3] = 1
+				case "pointer index":
+					state.pointerGP[3], state.gp[3] = true, 0
+				case "raw":
+					changed.x86Encoded = true
+				case "address":
+					changed.x86AddressBits = 32
+				}
+				before := state.clone()
+				if x86ResultTransfer(changed, &state, nil, 0, "amd64") || !reflect.DeepEqual(before, state) {
+					t.Fatal("standalone transfer invented a native memory contract")
+				}
+				accepted, _ := x86LoweredFixedVectorNativeRead(changed, &state, nil, "amd64")
+				want := before.clone()
+				if missing == "none" {
+					want.writeVector(2, 16, 0xffff, false)
+				}
+				if accepted != (missing == "none") || !reflect.DeepEqual(state, want) {
+					t.Fatal("paired rotate read changed pointer, NUM or independent state", accepted, state, want)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_rotate_writeback_runtime_test.go b/amd64_packed_rotate_writeback_runtime_test.go
new file mode 100644
index 000000000..fa734dba6
--- /dev/null
+++ b/amd64_packed_rotate_writeback_runtime_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These original EVEX functions execute portable LLVM on the actual host.
+// This checks the complete physical byte bank, not native AVX512 hardware.
+func TestX86PackedRotatePortableValuesAndUpperWriteback(t *testing.T) {
+	x86PackedRotateWritebackRuntime(t, false, false)
+}
+
+func TestX86PackedRotatePortableMemoryValuesAndUpperWriteback(t *testing.T) {
+	x86PackedRotateWritebackRuntime(t, false, true)
+}
+
+// Isolate the emitter's upper-byte semantics from source-effect registration.
+// All inputs are explicitly initialized, but this is not public API evidence.
+func TestX86PackedRotateEmitterPortableUpperWriteback(t *testing.T) {
+	x86PackedRotateWritebackRuntime(t, true, false)
+}
+
+var x86PackedRotateTestFamilies = []struct {
+	op       string
+	bits     int
+	left     bool
+	variable bool
+}{
+	{"VPROLD", 32, true, false}, {"VPROLQ", 64, true, false},
+	{"VPRORD", 32, false, false}, {"VPRORQ", 64, false, false},
+	{"VPROLVD", 32, true, true}, {"VPROLVQ", 64, true, true},
+	{"VPRORVD", 32, false, true}, {"VPRORVQ", 64, false, true},
+}
+
+func x86PackedRotateWritebackRuntime(t *testing.T, emitter, memory bool) {
+	t.Helper()
+	execution := x86ScalarCountHostExecution(t)
+	widths, apis := []int{16, 32, 64}, []string{"text", "module", "Go"}
+	if emitter {
+		widths, apis = []int{16}, []string{"emitter"}
+	}
+	for _, width := range widths {
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+		t.Run(bank, func(t *testing.T) {
+			var source, declarations, prototypes, rows strings.Builder
+			count := 0
+			for _, family := range x86PackedRotateTestFamilies {
+				for mode := 0; mode < 3; mode++ {
+					for destination := 0; destination < 3; destination++ {
+						name := fmt.Sprint("Rotate", count)
+						count++
+						immediate := []int{0, 7, 255}[destination]
+						instruction := family.op
+						broadcast := memory && destination == 0
+						if broadcast {
+							immediate = 7
+							instruction += ".BCST"
+						}
+						if mode == 2 {
+							instruction += ".Z"
+						}
+						if family.variable {
+							first := bank + "0"
+							if memory {
+								first = "(CX)"
+							}
+							instruction += " " + first + "," + bank + "1,"
+						} else {
+							data := bank + "1"
+							if memory {
+								data = "(BX)"
+							}
+							instruction += fmt.Sprintf(" $%d,%s,", immediate, data)
+						}
+						if mode != 0 {
+							instruction += "K1,"
+						}
+						instruction += fmt.Sprint(bank, destination)
+						fmt.Fprintf(&declarations, "func %s(out *[260]byte,data,counts,old *[64]byte,mask uint64)\n", name)
+						fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DI\nMOVQ data+8(FP),BX\nMOVQ counts+16(FP),CX\nMOVQ old+24(FP),SI\n", name)
+						source.WriteString("VMOVUPS (CX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (SI),Z2\nVMOVUPS (SI),Z3\nKMOVQ mask+32(FP),K1\nMOVL $5,R8\nCMPL R8,$3\n")
+						fmt.Fprintf(&source, "%s\nVMOVUPS Z0,0(DI)\nVMOVUPS Z1,64(DI)\nVMOVUPS Z2,128(DI)\nVMOVUPS Z3,192(DI)\nSETCS 256(DI)\nSETOS 257(DI)\nRET\n", instruction)
+						fmt.Fprintf(&rows, "{%s,%q,%d,%d,%t,%t,%t,%d,%d,%d},\n", name, instruction,
+							width, family.bits, family.left, family.variable, broadcast, mode, destination, immediate)
+					}
+				}
+			}
+			if count != 72 {
+				t.Fatal("complete rotate family/mask/alias inventory changed", count)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			driver := strings.NewReplacer("PROTOTYPES", prototypes.String(), "ROWS", rows.String()).Replace(x86PackedRotateWritebackDriver)
+			for _, api := range apis {
+				t.Run(api, func(t *testing.T) {
+					var ir string
+					var err error
+					if emitter {
+						file, parseErr := Parse(ArchAMD64, source.String())
+						if parseErr != nil {
+							t.Fatal(parseErr)
+						}
+						pkg := mustGoPackage(t, "rotate", "package rotate\n"+declarations.String())
+						resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+						sigs, sigErr := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+						if sigErr != nil {
+							t.Fatal(sigErr)
+						}
+						ir = x86ScalarFormatObjectUnit(t, file, sigs, "amd64", execution.triple, 0)
+						driver = strings.ReplaceAll(driver, "Rotate", "InstructionFormat")
+					} else {
+						ir, err = x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+					}
+					if err != nil || ir == "" {
+						t.Fatal("initialized rotate source rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							input := ir
+							if level == "-O2" {
+								input = x86MulDivRoundOptimize(t, ir)
+							}
+							execution.compileAndRunLLVM(t, "packed-rotate-writeback", input, driver, level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+const x86PackedRotateWritebackDriver = `
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+struct row {
+    void (*run)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+    const char *name;
+    unsigned width,bits;
+    bool left,variable,broadcast;
+    unsigned mode,destination,immediate;
+};
+static const struct row rows[] = { ROWS };
+
+static uint64_t rotate(uint64_t value, unsigned count, unsigned bits, bool left) {
+    const uint64_t mask = bits == 64 ? UINT64_MAX : UINT32_MAX;
+    value &= mask;
+    count %= bits;
+    if (!count) return value;
+    return (left ? (value << count) | (value >> (bits-count)) :
+                   (value >> count) | (value << (bits-count))) & mask;
+}
+
+int main(void) {
+    const uint64_t masks[] = {0,1,0x55,0xaa,UINT64_MAX,UINT64_C(1)<<63};
+    for (unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);++r) {
+        const struct row *row=&rows[r];
+        const unsigned lane_bytes=row->bits/8;
+        for (unsigned sample=0;sample<8;++sample) {
+            uint8_t data[64],counts[64],old[64],data_before[64],counts_before[64],old_before[64];
+            for (unsigned byte=0;byte<64;++byte) {
+                data[byte]=(uint8_t)(byte*37+sample*53+1);
+                old[byte]=(uint8_t)(byte*11+sample*67+129);
+            }
+            for (unsigned lane=0;lane<64/lane_bytes;++lane) {
+                uint64_t value=UINT64_C(0xfedcba9876543200)+sample*row->bits+lane*5+sample;
+                memcpy(counts+lane*lane_bytes,&value,lane_bytes);
+            }
+            memcpy(data_before,data,64);
+            memcpy(counts_before,counts,64);
+            memcpy(old_before,old,64);
+            for (unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);++m) {
+                uint8_t output[262],expected[262];
+                memset(output,0xa7,sizeof(output));
+                memset(expected,0xa7,sizeof(expected));
+                memcpy(expected+1,counts,64);
+                memcpy(expected+65,data,64);
+                memcpy(expected+129,old,64);
+                memcpy(expected+193,old,64);
+                uint8_t *destination=expected+1+row->destination*64;
+                for (unsigned lane=0;lane<row->width/lane_bytes;++lane) {
+                    if (row->mode && !(masks[m]>>lane&1)) {
+                        if (row->mode==2) memset(destination+lane*lane_bytes,0,lane_bytes);
+                        continue;
+                    }
+                    uint64_t value=0,count=row->immediate;
+                    unsigned source_lane=row->broadcast?0:lane;
+                    memcpy(&value,data+(row->variable?lane:source_lane)*lane_bytes,lane_bytes);
+                    if (row->variable) {
+                        count=0;
+                        memcpy(&count,counts+source_lane*lane_bytes,lane_bytes);
+                    }
+                    value=rotate(value,(unsigned)(count&(row->bits-1)),row->bits,row->left);
+                    memcpy(destination+lane*lane_bytes,&value,lane_bytes);
+                }
+                memset(destination+row->width,0,64-row->width);
+                expected[257]=expected[258]=0;
+                row->run(output+1,data,counts,old,masks[m]);
+                if (memcmp(output,expected,sizeof(output)) || memcmp(data,data_before,64) ||
+                    memcmp(counts,counts_before,64) || memcmp(old,old_before,64)) {
+                    for (unsigned byte=0;byte<sizeof(output);++byte) {
+                        if (output[byte]!=expected[byte]) {
+                            fprintf(stderr,"%s sample=%u mask=%llx byte=%u got=%x want=%x\n",
+                                    row->name,sample,(unsigned long long)masks[m],byte,output[byte],expected[byte]);
+                            break;
+                        }
+                    }
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_packed_sad_forms.go b/amd64_packed_sad_forms.go
new file mode 100644
index 000000000..5adb54cdd
--- /dev/null
+++ b/amd64_packed_sad_forms.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedSADForm struct {
+	x86PackedBinaryForm
+	spec      amd64PackedSADSpec
+	immediate uint8
+}
+
+// The ordered r/m, vvvv (or old destination), mask and destination views
+// are shared by lowering, caller availability and native read envelopes.
+// This is a grammar, not an address, initialized-value or ABI permission.
+func x86PackedSADProperties(ins Instr, goarch string) (x86PackedSADForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64PackedSADSpecs[Op(base)]
+	if !known {
+		return x86PackedSADForm{}, false, nil
+	}
+	result := x86PackedSADForm{spec: spec}
+	fail := func() (x86PackedSADForm, bool, error) {
+		return result, true, fmt.Errorf("%s %s operands outside Go packed SAD grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" {
+		return fail()
+	}
+	if goarch == "386" && len(ins.Args) > 3 && !ins.x86Encoded {
+		return fail()
+	}
+	local := ins
+	local.Args = append([]Operand(nil), ins.Args...)
+	shift := 0
+	if spec.kind != amd64PackedSADBlockSum {
+		if len(local.Args) == 0 || !amd64UnsignedImmediate(local.Args[0], 8) {
+			return fail()
+		}
+		result.immediate = uint8(local.Args[0].Imm)
+		local.Args = local.Args[1:]
+		shift = 1
+	}
+	grammar := x86PackedBinarySpec{encoding: x86PackedLogicalLegacyFP}
+	if spec.form == amd64PackedSADVEXXY {
+		grammar.encoding = x86PackedLogicalVEX
+	} else if spec.form == amd64PackedSADEVEXXYZ {
+		grammar.encoding = x86PackedLogicalVEXOrEVEX
+	}
+	if spec.kind == amd64PackedSADDoubleBlock {
+		grammar.encoding, grammar.zeroing = x86PackedLogicalEVEX, true
+	}
+	// Go's shared table accepts high vector spellings on 386, but does not
+	// establish their physical bank. Validate the table first and return
+	// Context below, rather than misclassifying accepted syntax as invalid.
+	// Address register/disp32 checks retain the actual mode independently.
+	for i, operand := range local.Args {
+		if operand.Kind != OpMem {
+			continue
+		}
+		if !x86MemoryRegistersValidForArch(operand.Mem, goarch) {
+			return fail()
+		}
+		if goarch == "386" && operand.Mem.Off == int64(uint32(operand.Mem.Off)) {
+			local.Args[i].Mem.Off = int64(int32(operand.Mem.Off))
+		}
+	}
+	form, err := x86PackedBinaryProperties(local, "amd64", grammar)
+	form.first += shift
+	form.second += shift
+	form.destination += shift
+	if form.memory >= 0 {
+		form.memory += shift
+	}
+	if form.mask >= 0 {
+		form.mask += shift
+	}
+	result.x86PackedBinaryForm = form
+	if err == nil && goarch == "386" {
+		for _, operand := range ins.Args {
+			index, valid := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+			if operand.Kind == OpReg && valid && index >= 8 && (form.legacy || amd64VectorByteWidth(operand.Reg) == 64) {
+				return fail()
+			}
+		}
+	}
+	if err == nil && spec.kind != amd64PackedSADDoubleBlock && form.mask >= 0 {
+		return fail()
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(ins, goarch)
+	}
+	if err == nil && form.memory >= 0 && ins.x86AddressBits != 0 {
+		err = fmt.Errorf("%w: %s lacks its original native address-size binding", ErrProbeNeedsContext, ins.Op)
+	}
+	return result, true, err
+}
+
+// Only block SAD compares corresponding bytes. Sliding and shuffled SAD do
+// not become constant merely because both operands name the same register.
+// Call this only after validating the complete instruction grammar.
+func (form x86PackedSADForm) constantZero(ins Instr) bool {
+	return form.spec.kind == amd64PackedSADBlockSum && form.memory < 0 &&
+		ins.Args[form.first].Reg == ins.Args[form.second].Reg
+}
+
+// Required byte masks for one output word. PSADBW's other six bytes in
+// each qword are independent known zero; MPS/DBPS compute all output words.
+func (form x86PackedSADForm) wordInputs(outputByte int) (first, second uint64) {
+	switch form.spec.kind {
+	case amd64PackedSADBlockSum:
+		if outputByte%8 != 0 {
+			return 0, 0
+		}
+		return uint64(255) << uint(outputByte), uint64(255) << uint(outputByte)
+	case amd64PackedSADMultiple:
+		lane := outputByte / 16 * 16
+		control := form.immediate
+		if lane != 0 {
+			control >>= 3
+		}
+		firstOffset := lane + int(control&3)*4
+		secondOffset := lane + int(control>>2&1)*4 + outputByte%16/2
+		return uint64(15) << uint(firstOffset), uint64(15) << uint(secondOffset)
+	default:
+		block := outputByte / 8 * 8
+		word := outputByte % 8 / 2
+		secondOffset := block + word/2*4
+		for i := 0; i < 4; i++ {
+			shuffled := block + word + i
+			lane := shuffled / 16 * 16
+			selector := form.immediate >> uint(2*(shuffled%16/4)) & 3
+			first |= uint64(1) << uint(lane+int(selector)*4+shuffled%4)
+		}
+		return first, uint64(15) << uint(secondOffset)
+	}
+}
diff --git a/amd64_packed_sad_forms_test.go b/amd64_packed_sad_forms_test.go
new file mode 100644
index 000000000..5e0cfe523
--- /dev/null
+++ b/amd64_packed_sad_forms_test.go
@@ -0,0 +1,319 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86SADRows(arch string) []string {
+	rows := []string{"PSADBW X0,X7", "PSADBW (AX),X7", "MPSADBW $0,X0,X7", "MPSADBW $255,16(AX)(BX*2),X7"}
+	if arch == "amd64" {
+		rows = append(rows, "PSADBW X15,X0", "PSADBW data(SB),X1", "PSADBW (FS),X1", "MPSADBW $128,(GS),X15")
+	}
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, source := range []string{bank + "0", "16(AX)(BX*2)"} {
+			rows = append(rows, fmt.Sprintf("VPSADBW %s,%s1,%s7", source, bank, bank))
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("VPSADBW %s,%s31,%s30", source, bank, bank))
+				for _, imm := range []int{0, 1, 7, 8, 37, 228, 255} {
+					rows = append(rows,
+						fmt.Sprintf("VDBPSADBW $%d,%s,%s31,%s30", imm, source, bank, bank),
+						fmt.Sprintf("VDBPSADBW $%d,%s,%s31,K1,%s30", imm, source, bank, bank),
+						fmt.Sprintf("VDBPSADBW.Z $%d,%s,%s31,K7,%s30", imm, source, bank, bank))
+				}
+				if bank != "Z" {
+					rows = append(rows, fmt.Sprintf("VMPSADBW $37,%s,%s1,%s15", source, bank, bank))
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86SADGoPackage(t *testing.T, arch, declaration string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "sad.go", "package sad\nfunc sad"+declaration+"\n", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("sad", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "sad", Types: typed, Syntax: []*ast.File{syntax}}
+}
+
+func TestX86PackedSADActualGoCompleteOptabs(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{"{APSADBW, yxm, Pq, opBytes{0xf6}}", "{AMPSADBW, yxshuf, Pq, opBytes{0x3a, 0x42, 0}}"} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("actual Go legacy registration changed: " + row)
+		}
+	}
+	for name, expected := range map[string][]string{
+		"yxm":        {"Yxm,Yxr"},
+		"yxshuf":     {"Yu8,Yxm,Yxr"},
+		"_yvaesdec":  {"Yxm,Yxr,Yxr", "Yym,Yyr,Yyr", "YxmEvex,YxrEvex,YxrEvex", "YymEvex,YyrEvex,YyrEvex", "Yzm,Yzr,Yzr"},
+		"_yvblendpd": {"Yu8,Yxm,Yxr,Yxr", "Yu8,Yym,Yyr,Yyr"},
+		"_yvalignd":  {"Yu8,YxmEvex,YxrEvex,YxrEvex", "Yu8,YxmEvex,YxrEvex,Yknot0,YxrEvex", "Yu8,YymEvex,YyrEvex,YyrEvex", "Yu8,YymEvex,YyrEvex,Yknot0,YyrEvex", "Yu8,Yzm,Yzr,Yzr", "Yu8,Yzm,Yzr,Yknot0,Yzr"},
+	} {
+		text := string(avx)
+		if !strings.HasPrefix(name, "_") {
+			text = string(legacy)
+		}
+		section := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+		if len(section) != 2 {
+			t.Fatal("actual table missing " + name)
+		}
+		var got []string
+		for _, row := range regexp.MustCompile(`argList\{([^}]*)\}`).FindAllStringSubmatch(section[1], -1) {
+			got = append(got, strings.ReplaceAll(row[1], " ", ""))
+		}
+		if !reflect.DeepEqual(got, expected) {
+			t.Fatalf("actual %s rows %q != %q", name, got, expected)
+		}
+	}
+	for _, row := range []struct {
+		op, table string
+		count     int
+	}{{"VPSADBW", "_yvaesdec", 5}, {"VMPSADBW", "_yvblendpd", 2}, {"VDBPSADBW", "_yvalignd", 3}} {
+		start := strings.Index(string(avx), "{as: A"+row.op+",")
+		if start < 0 {
+			t.Fatal("missing actual " + row.op)
+		}
+		entry := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(entry, "ytab: "+row.table) || strings.Count(entry, "avxEscape") != row.count || strings.Contains(entry, "Bcst") || strings.Contains(entry, "Sae") || strings.Contains(entry, "Rounding") {
+			t.Fatalf("actual SAD registration changed: %s", entry)
+		}
+		if strings.Contains(entry, "ZeroingEnabled") != (row.op == "VDBPSADBW") {
+			t.Fatal("actual SAD zeroing attribute changed " + row.op)
+		}
+	}
+}
+
+func TestX86PackedSADCompleteRowsThreeAPIsFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i") {
+				arch = "386"
+			}
+			source := "TEXT sad(SB),4,$0-0\n" + strings.Join(x86SADRows(arch), "\n") + "\nRET\n"
+			// Retain all original operands as actual-Go/public-Context/emitter
+			// formats. Separate complete-input programs own public objects.
+			ir := x86UnboundVoidScalarFormatObject(t, source, "sad", arch, triple)
+			compileLLVMToObject(t, llc, triple, "sad-text.ll", "sad-text.o", ir)
+			compileLLVMToObject(t, llc, triple, "sad-O2.ll", "sad-O2.o", x86MulDivRoundOptimize(t, ir))
+		})
+	}
+}
+
+func TestX86PackedSADDispatchMalformedAndPhysicalBounds(t *testing.T) {
+	for _, row := range []string{"PSADBW X0,X1", "VPSADBW Z0,Z1,Z2", "MPSADBW $5,X0,X1", "VMPSADBW $37,Y0,Y1,Y2", "VDBPSADBW.Z $228,Z0,Z1,K1,Z2"} {
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", ins.Op, Op(strings.ToLower(string(ins.Op))), "UNKNOWN", "PSADBW.Z"} {
+			local := ins
+			local.Op = identity
+			original := local
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			known, term, err := ctx.lowerPackedSumAbsoluteDifferences(ins.Op, local)
+			bad := identity != "" && !strings.EqualFold(string(identity), string(ins.Op))
+			if !known || term || (err != nil) != bad || bad && output.String() != before || !reflect.DeepEqual(local, original) {
+				t.Fatalf("dispatch %s/%s: %v", ins.Op, identity, err)
+			}
+		}
+	}
+	for _, row := range []string{"PSADBW M0,M1", "PSADBW Y0,Y1", "PSADBW $1,X0", "VPSADBW X0,Y1,Y2", "VPSADBW X0,X1,K1,X2", "VPSADBW.Z X0,X1,X2", "VPSADBW.BCST (AX),Z0,Z1", "MPSADBW $-1,X0,X1", "MPSADBW $256,X0,X1", "VMPSADBW $1,Z0,Z1,Z2", "VMPSADBW $1,Y16,Y1,Y2", "VDBPSADBW $1,X0,X1,K0,X2", "VDBPSADBW.Z $1,X0,X1,X2", "VDBPSADBW.BCST $1,(AX),X0,X1", "PSADBW (AX)(SP*2),X0", "VPSADBW 2147483648(AX),Z0,Z1", "MPSADBW $1,$data(SB),X0"} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		if row == "VDBPSADBW.Z $1,X0,X1,X2" {
+			x86SADReservedZeroMaskGoObservation(t, source)
+		} else {
+			goAssemblerOracleOutput(t, "amd64", source, "", false)
+		}
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			continue
+		}
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		if known, _, err := ctx.lowerPackedSumAbsoluteDifferences(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1]); !known || err == nil || output.String() != before {
+			t.Fatalf("malformed SAD emitted IR %s: %v", row, err)
+		}
+	}
+	for _, row := range []string{"PSADBW X8,X0", "MPSADBW $1,X0,X15", "VPSADBW Y0,Y1,Y20", "VPSADBW Z0,Z1,Z31"} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		rejected := !strings.HasPrefix(row, "V") || strings.Contains(row, "Z31")
+		goAssemblerOracleOutput(t, "386", source, "", !rejected)
+		file, _ := Parse(ArchAMD64, source)
+		_, _, err := x86PackedSADProperties(file.Funcs[0].Instrs[1], "386")
+		if rejected && err == nil || !rejected && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("386 accepted spelling acquired physical register %s: %v", row, err)
+		}
+	}
+}
+
+func x86SADReservedZeroMaskGoObservation(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "reserved.s"), filepath.Join(dir, "reserved.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "sad", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), err == nil, "amd64"); failure != nil {
+		t.Fatalf("actual reserved zero-mask observation: %v\n%s", failure, output)
+	}
+	if err != nil {
+		if !bytes.Contains(output, []byte("mask register must be specified for .Z instructions")) {
+			t.Fatalf("unexpected original-Go diagnostic: %s", output)
+		}
+		t.Log("actual Go rejected unchanged source without its nonzero mask")
+		return
+	}
+	// Intel SDM Vol. 2A Table 2-40 defines EVEX.z=1/aaa=0 as #UD.
+	// Older Go accepts this source and emits precisely that reserved pattern;
+	// acceptance is an observation, not authorization to execute or translate it.
+	if !bytes.Contains(output, []byte("62 f3 75 88 42 d0 01 c3")) {
+		t.Fatalf("actual Go accepted reserved-body bytes changed: %s", output)
+	}
+	code := []byte{0x62, 0xf3, 0x75, 0x88, 0x42, 0xd0, 0x01}
+	if _, _, known, err := decodedX86RawPackedSADInstruction(code, 64); !known || err == nil {
+		t.Fatal("actual reserved bytes acquired valid raw semantics")
+	}
+	t.Log("actual Go accepted reserved EVEX.z/aaa=0 bytes; named and raw validators still reject them")
+}
+
+func TestX86PackedSADFPSpanAndNativeMemoryBoundary(t *testing.T) {
+	for _, row := range []string{"VPSADBW source+0(FP),Z0,Z1", "VMPSADBW $37,source+0(FP),Y0,Y1", "VDBPSADBW.Z $228,source+0(FP),Z0,K1,Z1"} {
+		source := "TEXT sad(SB),4,$0-64\n" + row + "\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		file, _ := Parse(ArchAMD64, source)
+		ins := file.Funcs[0].Instrs[1]
+		form, _, err := x86PackedSADProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, missing := range []int{-1, 0, form.memoryBytes - 1} {
+			sig := x86WordMaddFPType(t)
+			if missing >= 0 {
+				for i, slot := range sig.Frame.Params {
+					if slot.Offset == int64(missing) {
+						sig.Frame.Params = append(sig.Frame.Params[:i], sig.Frame.Params[i+1:]...)
+						break
+					}
+				}
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := output.String()
+			_, _, err := ctx.lowerPackedSumAbsoluteDifferences(ins.Op, ins)
+			if (err != nil) != (missing >= 0) || missing >= 0 && output.String() != before {
+				t.Fatalf("FP complete native-width span %s missing%d: %v", row, missing, err)
+			}
+		}
+	}
+	for _, row := range []string{"PSADBW source+0(FP),X0", "MPSADBW $1,(SP),X0", "PSADBW 8(BP),X0", "MPSADBW $1,(AX)(BP*2),X0"} {
+		source := "TEXT f(SB),4,$0-64\n" + row + "\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		file, _ := Parse(ArchAMD64, source)
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], x86WordMaddFPType(t), nil)
+		before := output.String()
+		if _, _, err := ctx.lowerPackedSumAbsoluteDifferences(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+			t.Fatalf("virtual slots became native storage %s: %v", row, err)
+		}
+	}
+}
+
+func TestX86PackedSADLowerEffectAndFullReadClassificationAgree(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86SADRows(arch) {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, known, err := x86PackedSADProperties(ins, arch)
+			if !known || err != nil || !x86CallerVectorMoveKnown(ins) {
+				t.Fatalf("lowered accepted SAD lacks registered source effect %s: %v", row, err)
+			}
+			for index := range ins.Args {
+				width, write, valid := x86CallerMoveMemoryShape(ins, index)
+				if valid != (index == form.memory) || valid && (write || width != int64(form.byteWidth)) {
+					t.Fatalf("source/native read classifications disagree %s operand%d: %d/%t/%t", row, index, width, write, valid)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedSADDecoderPhysicalRowsDoNotGrantSourcePermissions(t *testing.T) {
+	for _, encoded := range []Op{"VPSADBW", "VPSADBW.EVEX", "VMPSADBW", "VDBPSADBW"} {
+		for width := 0; width < 3; width++ {
+			if width == 2 && (encoded == "VMPSADBW" || encoded == "VPSADBW") {
+				continue
+			}
+			code := encodeX86RawPackedSAD(encoded, width, 0, 1, 2, 0, false, false)
+			for _, mode := range []int{32, 64} {
+				ins, length, known, err := decodedX86RawPackedSADInstruction(code, mode)
+				if !known || err != nil || length != len(code) {
+					t.Fatalf("physical %x mode%d: %v", code, mode, err)
+				}
+				arch := "amd64"
+				if mode == 32 {
+					arch = "386"
+				}
+				if _, known, err := x86PackedSADProperties(ins, arch); !known || err != nil {
+					t.Fatalf("actual physical decoder row %x: %v", code, err)
+				}
+				if mode == 32 && len(ins.Args) > 3 {
+					local := ins
+					local.x86Encoded = false
+					if _, _, err := x86PackedSADProperties(local, arch); err == nil {
+						t.Fatal("named/public source borrowed physical frontend permission")
+					}
+				}
+				// Byte identity is not initialized input or pointer permission.
+				body := x86SourceStackState{vectors: make(map[Reg]uint64), masks: make(map[Reg]bool)}
+				form, _, _ := x86PackedSADProperties(ins, "amd64")
+				if !x86CallerSADStep(&ins, form, &body, nil) {
+					t.Fatal("pure register effect unexpectedly failed")
+				}
+				knownBytes := body.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)]
+				if knownBytes&3 != 0 {
+					t.Fatal("raw producer invented initialized SAD input bytes")
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_sad_reference_test.go b/amd64_packed_sad_reference_test.go
new file mode 100644
index 000000000..0e6c18a33
--- /dev/null
+++ b/amd64_packed_sad_reference_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+// Test-only unsigned byte mathematics. It knows no producer/parser/LLVM
+// helper and is also used to construct the separate original-Go oracle.
+func x86SADReference(op string, width, control int, first, second []byte) []uint16 {
+	result := make([]uint16, width/2)
+	difference := func(a, b byte) uint16 {
+		if a >= b {
+			return uint16(a) - uint16(b)
+		}
+		return uint16(b) - uint16(a)
+	}
+	if op == "PSADBW" || op == "VPSADBW" {
+		for byteIndex := 0; byteIndex < width; byteIndex++ {
+			result[byteIndex/8*4] += difference(first[byteIndex], second[byteIndex])
+		}
+		return result
+	}
+	if op == "MPSADBW" || op == "VMPSADBW" {
+		for lane := 0; lane < width/16; lane++ {
+			selector := control >> (lane * 3)
+			block := lane*16 + (selector&3)*4
+			window := lane*16 + (selector>>2&1)*4
+			for word := 0; word < 8; word++ {
+				for byteIndex := 0; byteIndex < 4; byteIndex++ {
+					result[lane*8+word] += difference(first[block+byteIndex], second[window+word+byteIndex])
+				}
+			}
+		}
+		return result
+	}
+	for lane := 0; lane < width/16; lane++ {
+		var permuted [16]byte
+		for word := 0; word < 4; word++ {
+			copy(permuted[word*4:word*4+4], first[lane*16+(control>>(2*word)&3)*4:])
+		}
+		for word := 0; word < 8; word++ {
+			block := word / 4 * 8
+			window := block + word%4
+			other := lane*16 + block + (word%4/2)*4
+			for byteIndex := 0; byteIndex < 4; byteIndex++ {
+				result[lane*8+word] += difference(permuted[window+byteIndex], second[other+byteIndex])
+			}
+		}
+	}
+	return result
+}
diff --git a/amd64_packed_sad_runtime_test.go b/amd64_packed_sad_runtime_test.go
new file mode 100644
index 000000000..7902d92e8
--- /dev/null
+++ b/amd64_packed_sad_runtime_test.go
@@ -0,0 +1,324 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86SADNumericCase struct {
+	op, bank            string
+	width, imm, masking int
+	memory              bool
+}
+
+func x86SADNumericCases() []x86SADNumericCase {
+	var cases []x86SADNumericCase
+	for _, op := range []string{"PSADBW", "VPSADBW", "MPSADBW", "VMPSADBW", "VDBPSADBW"} {
+		for widthIndex, bank := range []string{"X", "Y", "Z"} {
+			if !strings.HasPrefix(op, "V") && bank != "X" || op == "VMPSADBW" && bank == "Z" {
+				continue
+			}
+			controls := []int{0}
+			if strings.Contains(op, "MPS") || op == "VDBPSADBW" {
+				controls = []int{0, 1, 2, 3, 4, 5, 6, 7, 27, 37, 85, 170, 228, 255}
+			}
+			for _, control := range controls {
+				for _, memory := range []bool{false, true} {
+					for mask := 0; mask < 3; mask++ {
+						if mask != 0 && op != "VDBPSADBW" {
+							continue
+						}
+						cases = append(cases, x86SADNumericCase{op, bank, 16 << widthIndex, control, mask, memory})
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func (row x86SADNumericCase) instruction() string {
+	first := row.bank + "0"
+	if row.memory {
+		first = "(CX)"
+	}
+	op := row.op
+	if row.masking == 2 {
+		op += ".Z"
+	}
+	if op == "PSADBW" {
+		return op + " " + first + ",X2"
+	}
+	if op == "MPSADBW" {
+		return fmt.Sprintf("%s $%d,%s,X2", op, row.imm, first)
+	}
+	if op == "VPSADBW" {
+		return fmt.Sprintf("%s %s,%s1,%s2", op, first, row.bank, row.bank)
+	}
+	mask := ""
+	if row.masking != 0 {
+		mask = "K1,"
+	}
+	return fmt.Sprintf("%s $%d,%s,%s1,%s%s2", op, row.imm, first, row.bank, mask, row.bank)
+}
+
+func x86SADOriginalLegacyOracle(t *testing.T) {
+	t.Helper()
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package sad\n")
+	tests.WriteString(`package sad
+import("testing";"encoding/binary")
+func TestOriginal(t *testing.T) {
+ var a,b [64]byte
+ for sample:=0;sample<32;sample++ {
+  for i:=range a {a[i]=byte(i*17+sample*31);b[i]=byte(i*73-sample*19)}
+`)
+	// Actual stock Go executes every legacy imm8, in both register and
+	// m128 forms. It does not execute AVX512 or the Z-alias observation program.
+	for _, op := range []string{"PSADBW", "MPSADBW"} {
+		controls := 1
+		if op == "MPSADBW" {
+			controls = 256
+		}
+		for imm := 0; imm < controls; imm++ {
+			for _, memory := range []bool{false, true} {
+				name := fmt.Sprintf("original%d", strings.Count(declarations.String(), "func "))
+				fmt.Fprintf(&declarations, "func %s(out *[24]byte,a,b *[64]byte,flags uint64)\n", name)
+				row := x86SADNumericCase{op: op, bank: "X", width: 16, imm: imm, memory: memory}
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVUPS (CX),X0\nMOVUPS (DX),X2\nPUSHQ flags+24(FP)\nPOPFQ\n%s\nMOVUPS X2,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,16(AX)\nRET\n", name, row.instruction())
+				fmt.Fprintf(&tests, `{
+ var out [24]byte
+ beforeA,beforeB:=a,b
+ flags:=uint64(2)
+ if sample&1!=0 {flags|=0x8d5}
+ %s(&out,&a,&b,flags)
+ want:=[8]uint16{}
+`, name)
+				if op == "PSADBW" {
+					tests.WriteString("for i:=0;i<16;i++ {d:=int(a[i])-int(b[i]);if d<0 {d=-d};want[i/8*4]+=uint16(d)}\n")
+				} else {
+					fmt.Fprintf(&tests, "for word:=0;word<8;word++ {for i:=0;i<4;i++ {d:=int(a[%d+i])-int(b[%d+word+i]);if d<0 {d=-d};want[word]+=uint16(d)}}\n", (imm&3)*4, (imm>>2&1)*4)
+				}
+				fmt.Fprintf(&tests, "for i,w:=range want {if g:=binary.LittleEndian.Uint16(out[i*2:]);g!=w {t.Fatalf(\"%s sample%%d word%%d got%%d want%%d\",sample,i,g,w)}}\n", name)
+				tests.WriteString("if binary.LittleEndian.Uint64(out[16:])&0x8d5!=flags&0x8d5 || a!=beforeA || b!=beforeB {t.Fatal(\"flags/input canary\")}\n}\n")
+			}
+		}
+	}
+	tests.WriteString("}\n}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module sad\n\ngo 1.20\n", "sad.go": declarations.String(), "sad_amd64.s": assembly.String(), "sad_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual original legacy SAD oracle: %v\n%s", err, output)
+	}
+	t.Logf("actual original SSE %d kernels x 32 initialized samples; full status flags and unchanged input canaries", strings.Count(declarations.String(), "func "))
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedSADOriginalVEXUpperAliases(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package sad\n")
+	tests.WriteString(`package sad
+import("testing";"encoding/binary")
+func TestOriginal(t *testing.T) {
+ var a,b,old [64]byte
+ for sample:=0;sample<32;sample++ {
+  for i:=range a {a[i]=byte(i*17+sample*31);b[i]=byte(i*73-sample*19);old[i]=byte(0x91+i*11)}
+`)
+	kernels := 0
+	for _, op := range []string{"PSADBW", "MPSADBW", "VPSADBW", "VMPSADBW"} {
+		controls := []int{0}
+		if strings.Contains(op, "MPS") {
+			controls = []int{0, 1, 2, 3, 4, 5, 6, 7, 27, 37, 85, 170, 228, 255}
+		}
+		for _, imm := range controls {
+			for _, memory := range []bool{false, true} {
+				name := fmt.Sprintf("alias%d", kernels)
+				kernels++
+				row := x86SADNumericCase{op: op, bank: "X", width: 16, imm: imm, memory: memory}
+				fmt.Fprintf(&declarations, "func %s(out *[48]byte,a,b,old *[64]byte,flags uint64)\n", name)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nMOVUPS (CX),X0\nMOVUPS (DX),X1\nVMOVUPS (R8),Y2\n", name)
+				legacy := !strings.HasPrefix(op, "V")
+				if legacy {
+					assembly.WriteString("MOVUPS (DX),X2\n")
+				}
+				fmt.Fprintf(&assembly, "PUSHQ flags+32(FP)\nPOPFQ\n%s\nVMOVUPS Y2,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,32(AX)\nRET\n", row.instruction())
+				fmt.Fprintf(&tests, "{\n var out,want [48]byte\n for i:=range out {out[i]=0xc3;want[i]=0xc3}\n beforeA,beforeB,beforeOld:=a,b,old\n flags:=uint64(2)\n if sample&1!=0 {flags|=0x8d5}\n %s(&out,&a,&b,&old,flags)\n sums:=[8]uint16{}\n", name)
+				if strings.Contains(op, "MPS") {
+					fmt.Fprintf(&tests, "for word:=0;word<8;word++ {for i:=0;i<4;i++ {d:=int(a[%d+i])-int(b[%d+word+i]);if d<0 {d=-d};sums[word]+=uint16(d)}}\n", (imm&3)*4, (imm>>2&1)*4)
+				} else {
+					tests.WriteString("for i:=0;i<16;i++ {d:=int(a[i])-int(b[i]);if d<0 {d=-d};sums[i/8*4]+=uint16(d)}\n")
+				}
+				tests.WriteString("for i,w:=range sums {binary.LittleEndian.PutUint16(want[2*i:],w)}\n")
+				if legacy {
+					tests.WriteString("copy(want[16:32],old[16:32])\n")
+				} else {
+					tests.WriteString("for i:=16;i<32;i++ {want[i]=0}\n")
+				}
+				tests.WriteString("observed:=binary.LittleEndian.Uint64(out[32:40])\n binary.LittleEndian.PutUint64(want[32:40],observed)\n")
+				fmt.Fprintf(&tests, "if out!=want || observed&0x8d5!=flags&0x8d5 || a!=beforeA || b!=beforeB || old!=beforeOld {t.Fatalf(\"%s sample%%d actual%%x want%%x flags%%x\",sample,out,want,observed)}\n}\n", name)
+			}
+		}
+	}
+	tests.WriteString("}\n}\n")
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module sad\n\ngo 1.20\n", "sad.go": declarations.String(), "sad_amd64.s": assembly.String(), "sad_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual original SSE/VEX upper-alias oracle: %v\n%s", err, output)
+	}
+	t.Logf("actual original SSE/VEX %d kernels x 32 initialized samples; all 32 output bytes, six status flags and canaries; no EVEX instruction executed", kernels)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedSADIndependentWholeBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	x86SADOriginalLegacyOracle(t)
+	var declarations, assembly, table strings.Builder
+	declarations.WriteString("package sad\n")
+	cases := x86SADNumericCases()
+	for index, row := range cases {
+		name := fmt.Sprintf("sad%d", index)
+		fmt.Fprintf(&declarations, "func %s(out *[72]byte,a,b,old *[64]byte,mask,flags uint64)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-48\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),CX\nMOVQ b+16(FP),DX\nMOVQ old+24(FP),R8\nMOVQ mask+32(FP),R9\nVMOVUPS (CX),Z0\nVMOVUPS (DX),Z1\nVMOVUPS (R8),Z2\nKMOVQ R9,K1\n", name)
+		if !strings.HasPrefix(row.op, "V") {
+			assembly.WriteString("MOVUPS (DX),X2\n")
+		}
+		// Isolate the SAD preservation contract from arithmetic flag producers.
+		// Both seeds still demand all six defined status bits, including AF.
+		fmt.Fprintf(&assembly, "PUSHQ flags+40(FP)\nPOPFQ\n%s\nVMOVUPS Z2,(AX)\nPUSHFQ\nPOPQ R10\nMOVQ R10,64(AX)\nRET\n", row.instruction())
+		kind := 0
+		if strings.Contains(row.op, "MPS") {
+			kind = 1
+		} else if row.op == "VDBPSADBW" {
+			kind = 2
+		}
+		legacy := 0
+		if !strings.HasPrefix(row.op, "V") {
+			legacy = 1
+		}
+		fmt.Fprintf(&table, "{sad%d,%d,%d,%d,%d,%d},\n", index, kind, row.width, row.imm, row.masking, legacy)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	pkg := mustGoPackage(t, "sad", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for index := range cases {
+		name := fmt.Sprintf("sad%d", index)
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, Options{
+		Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	var main strings.Builder
+	main.WriteString(`#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+typedef void (*kernel)(void*,const void*,const void*,const void*,uint64_t,uint64_t);
+`)
+	for index := range cases {
+		fmt.Fprintf(&main, "extern void sad%d(void*,const void*,const void*,const void*,uint64_t,uint64_t);\n", index)
+	}
+	main.WriteString("static const struct {kernel run;int kind,width,imm,masking,legacy;} cases[]={\n" + table.String() + "};\n")
+	main.WriteString(`
+static unsigned diff(unsigned a,unsigned b) {return a>b ? a-b : b-a;}
+static void reference(uint8_t *out,int kind,int width,int imm,const uint8_t *a,const uint8_t *b) {
+ memset(out,0,width);
+ uint16_t sums[32]={0};
+ if(kind==0) {
+  for(int i=0;i<width;++i) sums[i/8*4]+=diff(a[i],b[i]);
+ } else if(kind==1) {
+  for(int lane=0;lane<width/16;++lane) {
+   int select=imm>>(3*lane),block=lane*16+(select&3)*4,window=lane*16+((select>>2)&1)*4;
+   for(int word=0;word<8;++word) for(int i=0;i<4;++i) sums[lane*8+word]+=diff(a[block+i],b[window+word+i]);
+  }
+ } else {
+  for(int lane=0;lane<width/16;++lane) {
+   uint8_t shuffled[16];
+   for(int d=0;d<4;++d) memcpy(shuffled+4*d,a+lane*16+((imm>>(2*d))&3)*4,4);
+   for(int word=0;word<8;++word) for(int i=0;i<4;++i)
+    sums[lane*8+word]+=diff(shuffled[(word/4)*8+word%4+i],b[lane*16+(word/4)*8+(word%4/2)*4+i]);
+  }
+ }
+ for(int word=0;word<width/2;++word) {out[2*word]=sums[word]&255;out[2*word+1]=sums[word]>>8;}
+}
+int main(void) {
+ for(unsigned row=0;row<sizeof(cases)/sizeof(cases[0]);++row) for(unsigned sample=0;sample<32;++sample) {
+  _Alignas(64) uint8_t aa[96],bb[96],old[64];uint8_t out[80],want[80],beforeA[96],beforeB[96],result[64];
+  memset(aa,0xa7,sizeof(aa));memset(bb,0xb9,sizeof(bb));memset(out,0xc3,sizeof(out));memcpy(want,out,sizeof(out));
+  uint8_t *a=aa+16,*b=bb+16;
+  for(int i=0;i<64;++i) {a[i]=(uint8_t)(i*17+sample*31);b[i]=(uint8_t)(i*73-sample*19);old[i]=(uint8_t)(0x91+i*11);}
+  memcpy(beforeA,aa,sizeof(aa));memcpy(beforeB,bb,sizeof(bb));
+  uint64_t mask=sample%4==0 ? 0 : sample%4==1 ? UINT64_MAX : sample%4==2 ? UINT64_C(0xaaaaaaaaaaaaaaaa) : UINT64_C(0x5555555555555555);
+  uint64_t seededFlags=2|(sample&1 ? 0x8d5 : 0);
+  cases[row].run(out+1,a,b,old,mask,seededFlags);
+  reference(result,cases[row].kind,cases[row].width,cases[row].imm,a,b);
+  for(int i=0;i<64;++i) {
+   uint8_t value=i<cases[row].width ? result[i] : cases[row].legacy ? old[i] : 0;
+   if(i<cases[row].width && cases[row].masking && !(mask>>(i/2)&1)) value=cases[row].masking==2 ? 0 : old[i];
+   want[1+i]=value;
+  }
+  uint64_t flags;memcpy(&flags,out+65,8);memcpy(want+65,&flags,8);
+  if((flags&0x8d5)!=(seededFlags&0x8d5) || memcmp(out,want,sizeof(out)) || memcmp(aa,beforeA,sizeof(aa)) || memcmp(bb,beforeB,sizeof(bb))) {
+   fprintf(stderr,"SAD row=%u kind=%d width=%d imm=%d masking=%d legacy=%d sample=%u flags=%llx\n",row,cases[row].kind,cases[row].width,cases[row].imm,cases[row].masking,cases[row].legacy,sample,(unsigned long long)flags);
+   for(int i=0;i<80;++i) if(out[i]!=want[i]) fprintf(stderr,"byte%d got=%u want=%u\n",i,out[i],want[i]);
+   return 1;
+  }
+ }
+ return 0;
+}
+`)
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			ir := module.String()
+			if optimized {
+				ir = x86MulDivRoundOptimize(t, ir)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "sad-independent-whole-bytes", triple, ir, main.String(), prefix)
+			t.Logf("%d initialized kernels x 32 inputs; all 64 alias bytes, merge/zero masks, six status flags and canaries", len(cases))
+		})
+	}
+	// These are LLVM software-lowering numerical tests plus actual original
+	// SSE execution. Z source acceptance/objects do not prove native AVX512.
+}
diff --git a/amd64_packed_shift_aligned_count_test.go b/amd64_packed_shift_aligned_count_test.go
new file mode 100644
index 000000000..fd42023d4
--- /dev/null
+++ b/amd64_packed_shift_aligned_count_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var x86LegacyShiftMemoryOpcodes = []struct {
+	name string
+	code byte
+}{
+	{"PSLLW", 0xf1}, {"PSLLL", 0xf2}, {"PSLLQ", 0xf3},
+	{"PSRLW", 0xd1}, {"PSRLL", 0xd2}, {"PSRLQ", 0xd3},
+}
+
+func TestX86PackedShiftLegacyMemoryActualGoEncoding(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operation := range x86LegacyShiftMemoryOpcodes {
+			source := "TEXT shifts(SB),4,$0-0\n" + operation.name + " (CX),X0\nRET\n"
+			dir := t.TempDir()
+			input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+			if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", object, input)
+			command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "GOTOOLCHAIN=local")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			cancel()
+			if err != nil {
+				t.Fatalf("actual Go %s %s: %v\n%s", arch, operation.name, err, output)
+			}
+			var code []byte
+			for _, line := range regexp.MustCompile(`(?m)^\s*0x[[:xdigit:]]+\s+((?:[[:xdigit:]]{2} )+)`).FindAllSubmatch(output, -1) {
+				part, err := hex.DecodeString(strings.ReplaceAll(string(line[1]), " ", ""))
+				if err != nil {
+					t.Fatal(err)
+				}
+				code = append(code, part...)
+			}
+			want := []byte{0x66, 0x0f, operation.code, 0x01, 0xc3}
+			if !bytes.Equal(code, want) {
+				t.Fatalf("actual Go %s %s memory encoding=%x, want=%x\n%s", arch, operation.name, code, want, output)
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftNativeCountThreeAPIsFiveO2Objects(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT shifts(SB),4,$0-0\n")
+	for _, operation := range x86LegacyShiftMemoryOpcodes {
+		for _, memory := range []string{"(AX)", "8(AX)(FS)", "8(AX)(GS)"} {
+			fmt.Fprintf(&source, "%s %s,X0\n", operation.name, memory)
+		}
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), x86PackedShiftGoPackage(t, target.arch), target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original native/segment count source invented entry inputs", api, err)
+			}
+		}
+		ir := x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{"shifts": {Name: "shifts", Ret: Void}},
+			target.arch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+				return c.lowerX86PackedShift(ins.Op, ins)
+			})
+		for axis, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+			for _, mnemonic := range []string{"psllw", "pslld", "psllq", "psrlw", "psrld", "psrlq"} {
+				for _, segment := range []string{"", "%fs:", "%gs:"} {
+					if strings.Count(body, `asm sideeffect "`+mnemonic+` `+segment+`($2), $0", "=x,0,r,~{memory}"`) != 1 {
+						t.Fatalf("%s IR%d lost original %s %s m128 count operation", target.triple, axis, mnemonic, segment)
+					}
+				}
+			}
+			if strings.Contains(body, `asm sideeffect "movdqa`) {
+				t.Fatal("count access was replaced by a stronger MOVDQA access")
+			}
+			dir := t.TempDir()
+			input, object := filepath.Join(dir, "native-count.ll"), filepath.Join(dir, "native-count.o")
+			if err := os.WriteFile(input, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(stage, llc, "-O2", "-mtriple="+target.triple, "-filetype=obj", input, "-o", object)
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			cancel()
+			if err != nil {
+				t.Fatalf("O2 %s IR%d: %v\n%s", target.triple, axis, err, output)
+			}
+			stage, cancel = runtimeOracleStageContext(t)
+			command = exec.CommandContext(stage, disassembler, "-d", object)
+			output, err = runtimeOracleCombinedOutput(stage, command)
+			cancel()
+			if err != nil {
+				t.Fatalf("O2 disassembly %s IR%d: %v\n%s", target.triple, axis, err, output)
+			}
+			for _, mnemonic := range []string{"psllw", "pslld", "psllq", "psrlw", "psrld", "psrlq"} {
+				pattern := regexp.MustCompile(`(?m)\b` + mnemonic + `\s+[^\n]*\([^\n]*\)`)
+				if len(pattern.FindAll(output, -1)) != 3 {
+					t.Fatalf("O2 actual original %s m128 count %s IR%d:\n%s", mnemonic, target.triple, axis, output)
+				}
+			}
+			for _, segment := range []string{"%fs:", "%gs:"} {
+				if strings.Count(string(output), segment) != 6 {
+					t.Fatalf("O2 lost six native %s count overrides %s IR%d:\n%s", segment, target.triple, axis, output)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftLegacyNativeBackingAndCallerPermissionsRemainContext(t *testing.T) {
+	for _, operation := range x86LegacyShiftMemoryOpcodes {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+operation.name+" count+0(FP),X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.Len()
+		if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != before {
+			t.Fatalf("unproved native FP backing emitted IR: %s %v", operation.name, err)
+		}
+	}
+	// Initialized vectors do not supply native backing or memory permission.
+	for _, operation := range x86LegacyShiftMemoryOpcodes {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+operation.name+" (CX),X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+		if !recognized || err != nil {
+			t.Fatal(err)
+		}
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0)}}
+		if x86CallerPackedShiftStep(&ins, form, &state, nil) {
+			t.Fatal("initialized vector granted legacy native-memory permission")
+		}
+	}
+}
diff --git a/amd64_packed_shift_alignment_linux_test.go b/amd64_packed_shift_alignment_linux_test.go
new file mode 100644
index 000000000..3410b242d
--- /dev/null
+++ b/amd64_packed_shift_alignment_linux_test.go
@@ -0,0 +1,317 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PackedShiftLinuxExecution(t *testing.T) []string {
+	t.Helper()
+	if runtime.GOARCH == "amd64" {
+		return nil // Required native Linux/amd64 counterpart, not Darwin Rosetta.
+	}
+	qemu, err := exec.LookPath("qemu-x86_64")
+	if err != nil {
+		t.Fatal("required explicit QEMU x86 execution:", err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, qemu, "--version"))
+	cancel()
+	if err != nil || !strings.HasPrefix(string(output), "qemu-x86_64 version 10.2.3 ") {
+		t.Fatalf("required QEMU10.2.3: %v\n%s", err, output)
+	}
+	t.Logf("explicit executable transport: %s -L /usr/x86_64-linux-gnu", qemu)
+	return []string{qemu, "-L", "/usr/x86_64-linux-gnu"}
+}
+
+const x86PackedShiftLegacyMemoryGoDriver = `package main
+import (
+ "fmt"
+ "os"
+ "strconv"
+ "unsafe"
+)
+func numeric(functions []func(unsafe.Pointer,unsafe.Pointer,unsafe.Pointer,uint64)) {
+ limits:=[]uint64{0,1,7,15,16,17,31,32,33,63,64,65,255,256,1<<32,^uint64(0)}
+ flags:=[3][5]byte{{1,0,1,0,1},{0,1,0,1,1},{0,0,0,0,0}}
+ for kernel,fn:=range functions {
+  for round,count:=range limits {
+   for seed:=0;seed<3;seed++ {
+    var data [18]byte
+    var storage [96]byte
+    var out [23]byte
+    for i:=range data { data[i]=byte(i*71+round*97+13) }
+    for i:=range storage { storage[i]=byte(i*31+7) }
+    for i:=range out { out[i]=0xc3 }
+    start:=uintptr(unsafe.Pointer(&storage[0]))
+    offset:=int((16-start%16)%16)
+    for i:=0;i<8;i++ { storage[offset+i]=byte(count>>(8*i)) }
+    beforeData,beforeStorage:=data,storage
+    fn(unsafe.Pointer(&out[1]),unsafe.Pointer(&data[1]),unsafe.Pointer(&storage[offset]),uint64(seed))
+    if out[0]!=0xc3 || out[22]!=0xc3 || data!=beforeData || storage!=beforeStorage {
+     panic("canary/input mutation")
+    }
+    for i:=0;i<5;i++ {
+     if out[17+i]!=flags[seed][i] { panic("flags") }
+    }
+    bytes:=[]int{2,4,8,2,4,8}[kernel]
+    for i:=0;i<16;i+=bytes {
+     var value,want uint64
+     for b:=0;b<bytes;b++ { value|=uint64(data[i+b+1])<<(8*b) }
+     if count<uint64(bytes*8) {
+      if kernel<3 { want=value<<count } else { want=value>>count }
+     }
+     for b:=0;b<bytes;b++ {
+      if out[i+b+1]!=byte(want>>(8*b)) { panic("numeric") }
+     }
+    }
+   }
+  }
+ }
+}
+func main() {
+ functions:=[]func(unsafe.Pointer,unsafe.Pointer,unsafe.Pointer,uint64){legacycount0,legacycount1,legacycount2,legacycount3,legacycount4,legacycount5}
+ if os.Args[1]=="numeric" { numeric(functions); return }
+ index,err:=strconv.Atoi(os.Args[1])
+ if err!=nil { panic(err) }
+ var data,count [64]byte
+ var out [23]byte
+ for i:=range data {
+  data[i]=byte(i*71+13)
+  count[i]=byte(i*31+7)
+ }
+ for i:=range out { out[i]=0xc3 }
+ start:=uintptr(unsafe.Pointer(&count[0]))
+ offset:=(16-start%16)%16+1
+ beforeData,beforeCount:=data,count
+ fmt.Printf("original Go count mod16=%d\n",uintptr(unsafe.Pointer(&count[offset]))%16)
+ functions[index](unsafe.Pointer(&out[1]),unsafe.Pointer(&data[1]),unsafe.Pointer(&count[offset]),0)
+ if out[0]!=0xc3 || out[22]!=0xc3 || data!=beforeData || count!=beforeCount { panic("canary/input mutation") }
+ flags:=[5]byte{1,0,1,0,1}
+ for i:=0;i<5;i++ { if out[17+i]!=flags[i] { panic("flags") } }
+ /* The initialized low count qword exceeds every lane width. */
+ for i:=1;i<=16;i++ { if out[i]!=0 { panic("numeric") } }
+ os.Exit(90)
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedShiftOriginalLegacyMemory(t *testing.T) {
+	prefix := x86PackedShiftLinuxExecution(t)
+	x86PackedShiftVerifyGuestArguments(t, prefix)
+	_, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	observer := x86PackedShiftBuildOriginalCountObserver(t, x86PackedShiftLinuxCCompiler(t, clang))
+	assembly, _ := x86PackedShiftLegacyMemoryAssembly()
+	var declarations strings.Builder
+	for i := range x86LegacyShiftMemoryOpcodes {
+		fmt.Fprintf(&declarations, "func legacycount%d(out,data,count unsafe.Pointer,seed uint64)\n", i)
+	}
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":           "module originalcount\n\ngo 1.20\n",
+		"main.go":          x86PackedShiftLegacyMemoryGoDriver + declarations.String(),
+		"original_amd64.s": strings.ReplaceAll(assembly, "TEXT legacycount", "TEXT ·legacycount"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	executable := filepath.Join(dir, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", executable, ".")
+	command.Dir, command.Env = dir, env
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go body/link: %v\n%s", err, output)
+	}
+	ctx, cancel = runtimeOracleStageContext(t)
+	argv := x86PackedShiftGuestExecution(prefix, executable, "numeric")
+	command = exec.CommandContext(ctx, argv[0], argv[1:]...)
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go aligned numeric/flags: %v\n%s", err, output)
+	}
+	for i := range x86LegacyShiftMemoryOpcodes {
+		ctx, cancel = runtimeOracleStageContext(t)
+		argv = x86PackedShiftGuestExecution(prefix, observer, strconv.Itoa(i))
+		command = exec.CommandContext(ctx, argv[0], argv[1:]...)
+		reference, referenceErr := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		status, observationErr := x86PackedShiftCountObservation(i, reference, referenceErr)
+		if observationErr != nil {
+			t.Fatalf("original native opcode observer %d: %v\n%s", i, observationErr, reference)
+		}
+		ctx, cancel = runtimeOracleStageContext(t)
+		argv := x86PackedShiftGuestExecution(prefix, executable, strconv.Itoa(i))
+		command = exec.CommandContext(ctx, argv[0], argv[1:]...)
+		output, err = runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		exit, pureExit := err.(*exec.ExitError)
+		text := string(output)
+		if !strings.Contains(text, "original Go count mod16=1") || !pureExit {
+			t.Fatalf("original Go unaligned m128 count identity %d: %v\n%s", i, err, output)
+		}
+		if status == "normal" {
+			if exit.ExitCode() != 90 {
+				t.Fatalf("original Go differs from normal native opcode %d: %v\n%s", i, err, output)
+			}
+		} else if exit.ExitCode() != 2 || !strings.Contains(text, "main.legacycount") ||
+			(!strings.Contains(text, "unexpected fault address") && !strings.Contains(text, "invalid memory address")) {
+			t.Fatalf("original Go differs from native opcode memory fault %d: %v\n%s", i, err, output)
+		}
+		t.Logf("original Go/native opcode %s mod16=1 status=%s", x86LegacyShiftMemoryOpcodes[i].name, status)
+	}
+	t.Log("6 original Go m128 kernels ×48 numeric/flags/canary inputs and 6 independent native opcode unaligned status comparisons")
+}
+
+func x86PackedShiftVerifyGuestArguments(t *testing.T, prefix []string) {
+	t.Helper()
+	dir := t.TempDir()
+	const source = `package main
+import (
+ "fmt"
+ "os"
+)
+func main() { fmt.Printf("%q\n", os.Args) }
+`
+	for name, contents := range map[string]string{
+		"go.mod": "module argumenttransport\n\ngo 1.20\n", "main.go": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "argument-transport")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go argument witness body/link: %v\n%s", err, output)
+	}
+	ctx, cancel = runtimeOracleStageContext(t)
+	argv := append(append([]string(nil), prefix...), executable)
+	command = exec.CommandContext(ctx, argv[0], argv[1:]...)
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil || string(output) != fmt.Sprintf("%q\n", []string{executable}) {
+		t.Fatalf("guest no-argument witness: %v\n%s", err, output)
+	}
+	t.Logf("guest no-argument witness: %s", strings.TrimSpace(string(output)))
+	arguments := []string{"first", "with space"}
+	for _, repaired := range []bool{false, true} {
+		argv := append(append([]string(nil), prefix...), executable)
+		argv = append(argv, arguments...)
+		want := append([]string{executable}, arguments...)
+		if len(prefix) != 0 && !repaired {
+			// The authenticated binfmt release treats the first argument as
+			// original argv[0] even for ordinary explicit execution.
+			want = arguments
+		}
+		if repaired {
+			argv = x86PackedShiftGuestExecution(prefix, executable, arguments...)
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, argv[0], argv[1:]...)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil || string(output) != fmt.Sprintf("%q\n", want) {
+			t.Fatalf("guest argument witness repaired=%t command=%q: %v\n%s; want %q",
+				repaired, argv, err, output, fmt.Sprintf("%q\n", want))
+		}
+		t.Logf("guest argument witness repaired=%t: %s", repaired, strings.TrimSpace(string(output)))
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedShiftLLVMNativeCount(t *testing.T) {
+	prefix := x86PackedShiftLinuxExecution(t)
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	assembly, sigs := x86PackedShiftLegacyMemoryAssembly()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "x86_64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := x86PackedShiftLegacyCountCHeader + x86PackedShiftLegacyCountDeclarations() + x86PackedShiftOriginalCountC() +
+		x86PackedShiftCountCChecks + x86PackedShiftLegacyNativeCountCMain
+	compileAndRunRuntimeTestWithCompiler(t, llc, x86PackedShiftLinuxCCompiler(t, clang), "legacy_count_contract", triple, ir, driver, prefix)
+	t.Log("6 original opcode/LLVM m128 kernels ×48 numeric/flags/canary inputs, 90 unaligned status comparisons and 6 original/LLVM full128 guard-page faults")
+}
+
+func x86PackedShiftLinuxCCompiler(t *testing.T, clang string) []string {
+	t.Helper()
+	if runtime.GOARCH == "amd64" {
+		return []string{clang}
+	}
+	gcc, err := exec.LookPath("x86_64-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required AMD64 C/link driver:", err)
+	}
+	return []string{gcc, "-no-pie"}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedShiftCompleteNumerical(t *testing.T) {
+	prefix := x86PackedShiftLinuxExecution(t)
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	cases := x86PackedShiftNumericalCases()
+	assembly, sigs := x86PackedShiftNumericalAssembly(cases)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "x86_64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var driver strings.Builder
+	driver.WriteString(x86PackedShiftIndependentC)
+	for _, c := range cases {
+		fmt.Fprintf(&driver, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint64_t);\n", c.name)
+	}
+	driver.WriteString("static const struct shift_case cases[]={\n")
+	for _, c := range cases {
+		fmt.Fprintf(&driver, "{%s,%q,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d},\n", c.name, c.row,
+			c.width, c.bits, c.countMode, c.immediate, c.memory, c.maskMode, c.destination,
+			x86ShiftBoolean(c.left), x86ShiftBoolean(c.legacy), x86ShiftBoolean(c.broadcast))
+	}
+	driver.WriteString(`};
+int main(void) {
+ for(unsigned i=0;i<sizeof(cases)/sizeof(cases[0]);i++) {
+  if(check_case(&cases[i],(int)i)) return 1;
+ }
+ return 0;
+}
+`)
+	compileAndRunRuntimeTestWithCompiler(t, llc, x86PackedShiftLinuxCCompiler(t, clang),
+		"complete_packed_shift", triple, ir, driver.String(), prefix)
+	t.Logf("%d exact LLVM programs ×192 independent whole-byte/flags/canary inputs", len(cases))
+}
diff --git a/amd64_packed_shift_count_observation_test.go b/amd64_packed_shift_count_observation_test.go
new file mode 100644
index 000000000..7ee6a5a3d
--- /dev/null
+++ b/amd64_packed_shift_count_observation_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedShiftCountObservationTransport(t *testing.T) {
+	const witness = "COUNT_NATIVE_STATUS kernel=3 mod16=1 "
+	const normal = witness + "wait=0 outcome=normal\n"
+	const fault = witness + "wait=11 outcome=fault\n"
+	const core = witness + "wait=139 outcome=fault\n"
+	const diagnostic = "qemu: uncaught target signal 11 (Segmentation fault) - core dumped\n"
+	for _, c := range []struct {
+		name, output, want string
+	}{
+		{"normal", normal, "normal"},
+		{"native_fault", fault, "fault"},
+		{"native_core", core, "fault"},
+		{"pinned_fault", diagnostic + fault, "fault"},
+		{"pinned_core", diagnostic + core, "fault"},
+		{"old_unbound_text", diagnostic + "fault\n", ""},
+		{"bare_normal", "normal\n", ""},
+		{"bare_fault", "fault\n", ""},
+		{"wrong_kernel", strings.Replace(normal, "kernel=3", "kernel=2", 1), ""},
+		{"wrong_address", strings.Replace(normal, "mod16=1", "mod16=0", 1), ""},
+		{"wrong_signal", strings.Replace(diagnostic, "signal 11", "signal 4", 1) + fault, ""},
+		{"wrong_wait", strings.Replace(fault, "wait=11", "wait=4", 1), ""},
+		{"wrong_normal_wait", strings.Replace(normal, "wait=0", "wait=11", 1), ""},
+		{"wrong_fault_wait", strings.Replace(fault, "wait=11", "wait=0", 1), ""},
+		{"normal_with_fault", diagnostic + normal, ""},
+		{"duplicate_witness", fault + fault, ""},
+		{"duplicate_diagnostic", diagnostic + diagnostic + fault, ""},
+		{"late_diagnostic", fault + diagnostic, ""},
+		{"unknown_output", "unknown tool failure\n" + fault, ""},
+		{"truncated_witness", witness + "nor", ""},
+		{"missing_newline", strings.TrimSuffix(normal, "\n"), ""},
+		{"overflow_output", strings.Repeat("a", 257) + normal, ""},
+		{"empty", "", ""},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			got, err := x86PackedShiftCountObservation(3, []byte(c.output), nil)
+			if c.want == "" {
+				if err == nil {
+					t.Fatalf("unbound observer output accepted: %q", c.output)
+				}
+			} else if err != nil || got != c.want {
+				t.Fatalf("bound observation: got %q, %v; want %q", got, err, c.want)
+			}
+		})
+	}
+	for _, kernel := range []int{-1, 6} {
+		if _, err := x86PackedShiftCountObservation(kernel, []byte(normal), nil); err == nil {
+			t.Fatalf("unknown original kernel accepted: %d", kernel)
+		}
+	}
+	for _, err := range []error{context.DeadlineExceeded, errors.New("observer cleanup failed")} {
+		if _, observed := x86PackedShiftCountObservation(3, []byte(normal), err); observed == nil {
+			t.Fatalf("observer infrastructure failure was discarded: %v", err)
+		}
+	}
+}
+
+// The immutable first-party observer validates its child wait status before
+// publishing this exact kernel/address/outcome witness. Only the pinned
+// QEMU's exact SIGSEGV diagnostic may precede a matching fault witness; do
+// not broadly remove emulator output or accept a normal result after it.
+func x86PackedShiftCountObservation(kernel int, output []byte, commandErr error) (string, error) {
+	if commandErr != nil {
+		return "", commandErr
+	}
+	if kernel < 0 || kernel >= 6 || len(output) > 256 || !strings.HasSuffix(string(output), "\n") {
+		return "", fmt.Errorf("unbound original count observation")
+	}
+	lines := strings.Split(strings.TrimSuffix(string(output), "\n"), "\n")
+	diagnostic := false
+	if len(lines) == 2 && lines[0] == "qemu: uncaught target signal 11 (Segmentation fault) - core dumped" {
+		diagnostic = true
+		lines = lines[1:]
+	}
+	if len(lines) != 1 {
+		return "", fmt.Errorf("unexpected original count observer output: %q", output)
+	}
+	prefix := fmt.Sprintf("COUNT_NATIVE_STATUS kernel=%d mod16=1 ", kernel)
+	switch lines[0] {
+	case prefix + "wait=0 outcome=normal":
+		if !diagnostic {
+			return "normal", nil
+		}
+	case prefix + "wait=11 outcome=fault", prefix + "wait=139 outcome=fault":
+		return "fault", nil
+	}
+	return "", fmt.Errorf("invalid original count status/kernel/address: %q", output)
+}
diff --git a/amd64_packed_shift_dependency_test.go b/amd64_packed_shift_dependency_test.go
new file mode 100644
index 000000000..876316bf3
--- /dev/null
+++ b/amd64_packed_shift_dependency_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// An independent bit-by-bit relation, not the production interval arithmetic.
+// Every possible in-range dynamic count is enumerated; all other counts emit
+// zero. Operand bytes are known only when every possible selected bit is known.
+func x86ShiftIndependentBitInputs(bits, width, count int, left, byteShift, dynamic, perLane bool) [][2]uint64 {
+	if byteShift {
+		bits = 128
+	}
+	masks := make([][2]uint64, width)
+	for output := 0; output < width*8; output++ {
+		first, end := int(uint8(count)), int(uint8(count))+1
+		if byteShift {
+			first, end = first*8, first*8+1
+		}
+		if dynamic {
+			first, end = 0, bits
+		}
+		for shift := first; shift < end; shift++ {
+			input := output%bits + shift
+			if left {
+				input = output%bits - shift
+			}
+			if input >= 0 && input < bits {
+				input += output / bits * bits
+				masks[output/8][0] |= uint64(1) << uint(input/8)
+			}
+		}
+		if dynamic {
+			start, end := 0, 8
+			if perLane {
+				start, end = output/bits*(bits/8), (output/bits+1)*(bits/8)
+			}
+			for at := start; at < end; at++ {
+				masks[output/8][1] |= uint64(1) << uint(at)
+			}
+		}
+	}
+	return masks
+}
+
+func TestX86PackedShiftResultEveryByteDependency(t *testing.T) {
+	for _, bank := range []struct {
+		name  string
+		width int
+	}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+		for _, bits := range []int{16, 32, 64, 128} {
+			for _, left := range []bool{false, true} {
+				for mode := 0; mode < 3; mode++ {
+					byteShift, dynamic, perLane := bits == 128, mode != 0, mode == 2
+					if byteShift && dynamic {
+						continue
+					}
+					name := "VPSRL"
+					if left {
+						name = "VPSLL"
+					}
+					if perLane {
+						name += "V"
+					}
+					name += map[int]string{16: "W", 32: "D", 64: "Q", 128: "DQ"}[bits]
+					last := 255
+					if dynamic {
+						last = 0
+					}
+					for immediate := 0; immediate <= last; immediate++ {
+						count := fmt.Sprintf("$%d", immediate)
+						if dynamic {
+							count = "X0"
+							if perLane {
+								count = bank.name + "0"
+							}
+						}
+						row := fmt.Sprintf("%s %s,%s1,%s2", name, count, bank.name, bank.name)
+						ins := x86ScalarLaneInstruction(t, row)
+						form, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+						if !known || err != nil {
+							t.Fatal(row, err)
+						}
+						want := x86ShiftIndependentBitInputs(bits, bank.width, immediate, left, byteShift, dynamic, perLane)
+						for output, masks := range want {
+							data, counts := x86PackedShiftByteInputs(form, output)
+							if data != masks[0] || counts != masks[1] {
+								t.Fatalf("%s byte=%d data=%x/%x counts=%x/%x", row, output, data, masks[0], counts, masks[1])
+							}
+						}
+						for missing := -1; missing < bank.width; missing++ {
+							for operand := 0; operand < 2; operand++ {
+								inputs := [2]uint64{^uint64(0), ^uint64(0)}
+								if missing >= 0 {
+									inputs[operand] &^= uint64(1) << uint(missing)
+								}
+								var expected uint64
+								for output, masks := range want {
+									if inputs[0]&masks[0] == masks[0] && inputs[1]&masks[1] == masks[1] {
+										expected |= uint64(1) << uint(output)
+									}
+								}
+								if got := x86PackedShiftDefinedBytes(form, inputs[0], inputs[1], 0); got != expected {
+									t.Fatal(row, missing, operand, got, expected)
+								}
+								state := x86ResultState{flags: x86ByteFlagsAll}
+								state.writeVector(0, 64, inputs[1], false)
+								state.writeVector(1, 64, inputs[0], false)
+								physical := expected | ^x86CallerVectorByteMask(int64(bank.width))
+								if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || state.vectorBytes(2) != physical || state.flags != x86ByteFlagsAll {
+									t.Fatal("complete result byte state differs", row, missing, operand)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_shift_exec_test.go b/amd64_packed_shift_exec_test.go
new file mode 100644
index 000000000..e321197e1
--- /dev/null
+++ b/amd64_packed_shift_exec_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func x86PackedShiftGuestExecution(prefix []string, executable string, arguments ...string) []string {
+	command := append([]string(nil), prefix...)
+	command = append(command, executable)
+	if len(prefix) != 0 {
+		// The pinned binfmt QEMU preserves a separate original argv[0].
+		// Native execution must not duplicate it. The Linux runtime oracle
+		// independently verifies this pinned transport before any ASM runs.
+		command = append(command, executable)
+	}
+	return append(command, arguments...)
+}
+
+func TestX86PackedShiftGuestArgumentTransport(t *testing.T) {
+	for _, c := range []struct {
+		name      string
+		prefix    []string
+		arguments []string
+		want      []string
+	}{
+		{"native", nil, []string{"numeric"}, []string{"/guest", "numeric"}},
+		{"native_empty", nil, nil, []string{"/guest"}},
+		{"pinned_empty", []string{"/qemu", "-L", "/sysroot"}, nil,
+			[]string{"/qemu", "-L", "/sysroot", "/guest", "/guest"}},
+		{"pinned_numeric", []string{"/qemu", "-L", "/sysroot"}, []string{"numeric"},
+			[]string{"/qemu", "-L", "/sysroot", "/guest", "/guest", "numeric"}},
+		{"pinned_fault", []string{"/qemu", "-L", "/sysroot"}, []string{"3", "with space"},
+			[]string{"/qemu", "-L", "/sysroot", "/guest", "/guest", "3", "with space"}},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			beforePrefix := append([]string(nil), c.prefix...)
+			beforeArguments := append([]string(nil), c.arguments...)
+			got := x86PackedShiftGuestExecution(c.prefix, "/guest", c.arguments...)
+			if !reflect.DeepEqual(got, c.want) {
+				t.Fatalf("guest command: got %q, want %q", got, c.want)
+			}
+			if !reflect.DeepEqual(c.prefix, beforePrefix) || !reflect.DeepEqual(c.arguments, beforeArguments) {
+				t.Fatal("argument construction mutated its inputs")
+			}
+		})
+	}
+}
diff --git a/amd64_packed_shift_fault_test.go b/amd64_packed_shift_fault_test.go
new file mode 100644
index 000000000..100b924c0
--- /dev/null
+++ b/amd64_packed_shift_fault_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedShiftFaultProgram() (string, map[string]FuncSig, string, string, []bool) {
+	var source, declarations, rows strings.Builder
+	sigs := map[string]FuncSig{}
+	var required []bool
+	for i, row := range []struct {
+		instruction       string
+		bytes, accessible int
+	}{
+		{"VPSRLW.Z (CX),Y0,K1,Y1", 16, 8},
+		{"VPSRLD.Z (CX),Y0,K1,Y1", 16, 8},
+		{"VPSRLQ.Z (CX),Y0,K1,Y1", 16, 8},
+		{"VPSRLW.Z $1,(CX),K1,Y1", 0, 0},
+		{"VPSRLDQ $1,(CX),Y1", 32, 8},
+		{"VPSRLD.Z $1,(CX),K1,Y1", 0, 0},
+		{"VPSRLQ.BCST.Z $1,(CX),K1,Y1", 0, 0},
+		{"VPSRLVW.Z (CX),Y0,K1,Y1", 0, 0},
+		{"VPSRLVD.BCST.Z (CX),Y0,K1,Y1", 0, 0},
+		{"VPSRLD $255,(CX),Y1", 32, 8},
+		{"VPSRLVD (CX),Y0,Y1", 32, 8},
+		{"VPSRLVD.Z (CX),Y0,K1,Y1", 4, 3},
+	} {
+		name := fmt.Sprintf("faultshift%d", i)
+		mask := 0
+		if i == 11 {
+			mask = 1
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ data+8(FP),BX\nMOVQ count+16(FP),CX\nVMOVUPS (BX),Y0\nVPXOR Y0,Y0,Y0\nMOVQ $%d,DX\nKMOVQ DX,K1\n%s\nVMOVUPS Y1,(AX)\nRET\n", name, mask, row.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*);\n", name)
+		want := "0"
+		if i == 4 {
+			// VPSRLDQ shifts each independent 128-bit memory lane. The
+			// newly added readable control also checks its actual bytes.
+			want = "i % 16 == 15 ? 0 : input[i + 1]"
+		}
+		fmt.Fprintf(&declarations, `static int observe%d(const uint8_t *input) {
+    uint8_t data[32], output[34];
+    memset(data, 0x71, sizeof(data));
+    memset(output, 0xa7, sizeof(output));
+    %s(output + 1, data, input);
+    if (output[0] != 0xa7 || output[33] != 0xa7) return 3;
+    for (unsigned i = 0; i < 32; ++i) {
+        uint8_t want = %s;
+        if (output[i + 1] != want || data[i] != 0x71) return 4;
+    }
+    return 0;
+}
+`, i, name, want)
+		fmt.Fprintf(&rows, "{observe%d, %d, %d},\n", i, row.bytes, row.accessible)
+		required = append(required, row.bytes != 0)
+	}
+	return source.String(), sigs, declarations.String(), rows.String(), required
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedShiftNativeReadFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, sigs, declarations, rows, required := x86PackedShiftFaultProgram()
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := x86MemoryFaultDriver(declarations, rows)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "packed-shift-memory-faults", ir, driver, level)
+			x86CheckMemoryAccessMatrix(t, execution, executable, required)
+		})
+	}
+	t.Log("7 full/active native reads and 5 lane-mask suppression cases, including readable controls")
+}
diff --git a/amd64_packed_shift_forms.go b/amd64_packed_shift_forms.go
new file mode 100644
index 000000000..46cb8911b
--- /dev/null
+++ b/amd64_packed_shift_forms.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedShiftCount uint8
+
+const (
+	x86PackedShiftUniform x86PackedShiftCount = iota
+	x86PackedShiftPerLane
+	x86PackedShiftBytes
+)
+
+type x86PackedShiftForm struct {
+	countMode                              x86PackedShiftCount
+	laneBits, byteWidth                    int
+	count, data, destination, mask, memory int
+	memoryBytes                            int
+	left, legacy, mmx, broadcast, zeroing  bool
+	faultSuppressed                        bool
+	arithmetic                             bool
+	countOperand                           Operand
+}
+
+func x86TypedLegacyPackedShiftByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedShiftProperties(op, ins, arch)
+	if !known || err != nil || !form.legacy || form.mmx {
+		return x86TypedByteEffect{}, known && (err != nil || form.legacy && !form.mmx), err
+	}
+	return x86PackedShiftDependencyEffect(ins, form), true, nil
+}
+
+// Properties establish encoding and access shape only, never initialized
+// data, pointer bounds, alignment or permission to return through raw bytes.
+func x86PackedShiftProperties(op Op, ins Instr, goarch string) (x86PackedShiftForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	uniform, recognized := amd64PackedLogicalShiftSpecs[Op(base)]
+	arithmetic, arithmeticUniform := amd64PackedArithmeticShiftSpecs[Op(base)]
+	if arithmeticUniform {
+		uniform, recognized = arithmetic, true
+	}
+	perLane, variable := amd64PerLaneVariableShiftSpecs[base]
+	byteShift := base == "PSLLO" || base == "PSLLDQ" || base == "PSRLO" || base == "PSRLDQ" || base == "VPSLLDQ" || base == "VPSRLDQ"
+	if !recognized && !variable && !byteShift {
+		return x86PackedShiftForm{}, false, nil
+	}
+	f := x86PackedShiftForm{count: 0, data: 1, destination: len(ins.Args) - 1, mask: -1, memory: -1,
+		arithmetic: arithmeticUniform || variable && perLane.arithmetic}
+	fail := func() (x86PackedShiftForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go packed shift grammar: %q", goarch, op, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	local := ins
+	local.Op = op
+	if recognized && !uniform.vector {
+		var err error
+		local, err = x86LegacyMMXReadInstruction(local, goarch)
+		if err != nil {
+			return f, true, err
+		}
+	}
+	f.countMode, f.laneBits, f.left, f.legacy = x86PackedShiftUniform, uniform.laneBits, uniform.left, !uniform.vector
+	if variable {
+		f.countMode, f.laneBits, f.left, f.legacy = x86PackedShiftPerLane, perLane.laneBits, perLane.operation == "shl", false
+	}
+	if byteShift {
+		f.countMode, f.laneBits, f.left, f.legacy = x86PackedShiftBytes, 8, strings.Contains(base, "SLL"), !strings.HasPrefix(base, "V")
+	}
+	if f.legacy {
+		if dotted || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+			return fail()
+		}
+		f.data = f.destination
+		f.byteWidth = 16
+		_, f.mmx = amd64ParseMReg(ins.Args[f.destination].Reg)
+		if f.mmx {
+			if byteShift || goarch == "386" {
+				return fail()
+			}
+			f.byteWidth = 8
+		}
+	} else {
+		switch suffix {
+		case "":
+			if dotted {
+				return fail()
+			}
+		case "Z":
+			f.zeroing = true
+		case "BCST":
+			f.broadcast = true
+		case "BCST.Z":
+			f.broadcast, f.zeroing = true, true
+		default:
+			return fail()
+		}
+		if len(ins.Args) != 3 && len(ins.Args) != 4 || byteShift && dotted || f.broadcast && f.laneBits == 16 {
+			return fail()
+		}
+		if len(ins.Args) == 4 {
+			if byteShift || goarch == "386" && !ins.x86Encoded || !amd64NonzeroKOperand(ins.Args[2]) {
+				return fail()
+			}
+			f.mask = 2
+		} else if f.zeroing {
+			return fail()
+		}
+		f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	}
+	register := func(operand Operand, width int) bool {
+		if f.mmx {
+			_, valid := amd64ParseMReg(operand.Reg)
+			return operand.Kind == OpReg && valid
+		}
+		if f.legacy {
+			index, valid := amd64ParseXReg(operand.Reg)
+			return operand.Kind == OpReg && valid && (goarch == "amd64" && index < 16 || goarch == "386" && index < 8)
+		}
+		return amd64GoPackedVectorMoveRegister(operand, width, goarch)
+	}
+	if !register(ins.Args[f.destination], f.byteWidth) {
+		return fail()
+	}
+	count, data := local.Args[f.count], local.Args[f.data]
+	if count.Kind == OpImm {
+		var valid bool
+		count, valid = x86ImmediateShuffleConstant(count, goarch, ins.x86Encoded)
+		if !valid {
+			return fail()
+		}
+		if variable || count.Imm < -128 || count.Imm > 255 || f.legacy && count.Imm > 127 {
+			return fail()
+		}
+		if count.Imm < 0 && (base == "VPSRAQ" || f.mask >= 0 ||
+			!f.legacy && amd64PackedByteShiftRequiresEVEX(data, ins.Args[f.destination], f.byteWidth)) {
+			return fail()
+		}
+		if isAMD64MemoryOperand(data) {
+			f.memory, f.memoryBytes = f.data, f.byteWidth
+			if f.broadcast {
+				f.memoryBytes = f.laneBits / 8
+			}
+		} else if f.broadcast || !register(data, f.byteWidth) {
+			return fail()
+		}
+		// All W/D/Q immediate Full tuples use E4/E4.nb. Byte shifts
+		// retain E4NF.nb; uniform Mem128 count rows are handled below.
+		f.faultSuppressed = !f.legacy && !byteShift
+	} else {
+		if byteShift || f.broadcast && !variable || !register(data, f.byteWidth) {
+			return fail()
+		}
+		countWidth := f.byteWidth
+		if !variable && !f.mmx {
+			countWidth = 16
+		}
+		if isAMD64MemoryOperand(count) {
+			f.memory, f.memoryBytes = f.count, countWidth
+			if f.broadcast {
+				f.memoryBytes = f.laneBits / 8
+			}
+		} else if f.broadcast || !register(count, countWidth) {
+			return fail()
+		}
+		f.faultSuppressed = variable
+	}
+	f.countOperand = count
+	if f.memory >= 0 && !x86PackedShiftMemoryValid(ins.Args[f.memory], goarch) {
+		return fail()
+	}
+	if f.memory >= 0 && ins.Args[f.memory].Kind == OpMem {
+		memory := ins.Args[f.memory].Mem
+		if err := x86SymbolIndexedMemoryError(memory, goarch); err != nil {
+			return f, true, err
+		}
+		if memory.OffRaw != "" || memory.IndexExt != "" {
+			return fail()
+		}
+	}
+	if goarch == "386" {
+		for _, operand := range ins.Args {
+			width := amd64VectorByteWidth(operand.Reg)
+			if index, valid := amd64VectorRegisterIndex(operand.Reg, width); operand.Kind == OpReg && valid && index >= 8 {
+				return f, true, fmt.Errorf("mode32 packed shift has no physical SIMD register %s: %w", operand.Reg, ErrProbeNeedsContext)
+			}
+		}
+	}
+	return f, true, nil
+}
+
+func x86PackedShiftMemoryValid(operand Operand, goarch string) bool {
+	if operand.Kind == OpSym {
+		symbol := strings.TrimSpace(operand.Sym)
+		_, integer := parseInt(symbol)
+		return !strings.HasPrefix(symbol, "$") && (strings.HasSuffix(symbol, "(SB)") || integer == nil)
+	}
+	if operand.Kind != OpMem {
+		return operand.Kind == OpFP
+	}
+	memory := operand.Mem
+	return (memory.Off == int64(int32(memory.Off)) || goarch == "386" && memory.Off == int64(uint32(memory.Off))) &&
+		x86MemoryRegistersValidForArch(memory, goarch) && (memory.Index == "" || memory.Index != SP &&
+		(memory.Scale == 1 || memory.Scale == 2 || memory.Scale == 4 || memory.Scale == 8))
+}
diff --git a/amd64_packed_shift_forms_test.go b/amd64_packed_shift_forms_test.go
new file mode 100644
index 000000000..39cd1904d
--- /dev/null
+++ b/amd64_packed_shift_forms_test.go
@@ -0,0 +1,354 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86PackedShiftNames() []string {
+	var names []string
+	for op := range amd64PackedLogicalShiftSpecs {
+		names = append(names, string(op))
+	}
+	for op, spec := range amd64PerLaneVariableShiftSpecs {
+		if !spec.arithmetic {
+			names = append(names, op)
+		}
+	}
+	names = append(names, "PSLLO", "PSLLDQ", "PSRLO", "PSRLDQ", "VPSLLDQ", "VPSRLDQ")
+	sort.Strings(names)
+	return names
+}
+
+func x86PackedShiftRows(op, arch string) []string {
+	legacy := !strings.HasPrefix(op, "V")
+	bytes := strings.HasSuffix(op, "DQ") || op == "PSLLO" || op == "PSRLO"
+	perLane := strings.Contains(op, "LLV") || strings.Contains(op, "RLV")
+	if legacy {
+		rows := []string{op + " $-128,X0", op + " $127,X1"}
+		if !bytes {
+			rows = append(rows, op+" X0,X1", op+" (AX),X1")
+			if arch == "amd64" {
+				rows = append(rows, op+" $1,M0", op+" M0,M1", op+" (AX),M1")
+			}
+		}
+		return rows
+	}
+	var rows []string
+	for _, bank := range []string{"X", "Y", "Z"} {
+		if !perLane {
+			rows = append(rows, fmt.Sprintf("%s $0,%s0,%s2", op, bank, bank), fmt.Sprintf("%s $255,(AX),%s2", op, bank))
+			if bank != "Z" {
+				rows = append(rows, fmt.Sprintf("%s $-128,%s0,%s2", op, bank, bank))
+			}
+		}
+		if bytes {
+			continue
+		}
+		countBank := "X"
+		if perLane {
+			countBank = bank
+		}
+		rows = append(rows, fmt.Sprintf("%s %s0,%s1,%s2", op, countBank, bank, bank), fmt.Sprintf("%s (AX),%s1,%s2", op, bank, bank))
+		if arch == "amd64" {
+			rows = append(rows, fmt.Sprintf("%s %s0,%s1,K1,%s2", op, countBank, bank, bank), fmt.Sprintf("%s.Z (AX),%s1,K7,%s2", op, bank, bank))
+			if !perLane {
+				rows = append(rows, fmt.Sprintf("%s.Z $3,(AX),K1,%s2", op, bank))
+			}
+		}
+		if !strings.HasSuffix(op, "W") {
+			input := "$3,(AX),"
+			if perLane {
+				input = "(AX)," + bank + "1,"
+			}
+			rows = append(rows, fmt.Sprintf("%s.BCST %s%s2", op, input, bank))
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("%s.BCST.Z %sK1,%s2", op, input, bank))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedShiftEveryGoOpcodeAndAttribute(t *testing.T) {
+	if len(x86PackedShiftNames()) != 24 {
+		t.Fatal("incomplete logical-shift family")
+	}
+	dir := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	re := regexp.MustCompile(`\{as: A(VPS(?:LL|RL)(?:[WDQ]|V[WDQ]|DQ)), ytab: ([^,]+),`)
+	rows := re.FindAllStringSubmatch(string(avx), -1)
+	if len(rows) != 14 {
+		t.Fatalf("Go AVX family inventory changed: %d", len(rows))
+	}
+	for _, row := range rows {
+		op, table := row[1], "_yvpslld"
+		if strings.HasSuffix(op, "DQ") {
+			table = "_yvpslldq"
+		} else if strings.Contains(op, "LLV") || strings.Contains(op, "RLV") {
+			table = "_yvandnpd"
+			if strings.HasSuffix(op, "W") {
+				table = "_yvblendmpd"
+			}
+		}
+		if row[2] != table {
+			t.Fatalf("%s Go table %s != %s", op, row[2], table)
+		}
+		start := strings.Index(string(avx), row[0])
+		block := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		for _, line := range strings.Split(block, "\n") {
+			if !strings.Contains(line, "avxEscape | evex") {
+				continue
+			}
+			byteShift := strings.HasSuffix(op, "DQ")
+			uniformCount := !strings.Contains(op, "LLV") && !strings.Contains(op, "RLV") && !strings.Contains(line, "0x7")
+			broadcast := !byteShift && !strings.HasSuffix(op, "W") && !uniformCount
+			if strings.Contains(line, "evexZeroingEnabled") == byteShift || strings.Contains(line, "evexBcstN") != broadcast ||
+				strings.Contains(line, "evexRounding") || strings.Contains(line, "evexSae") {
+				t.Fatalf("%s attribute disagreement: %s", op, line)
+			}
+		}
+	}
+	for _, op := range []string{"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ"} {
+		if !strings.Contains(string(legacy), "{A"+op+", yps,") {
+			t.Fatalf("Go yps member changed: %s", op)
+		}
+	}
+	// Bind the complete operand-class inventory, not just the table names.
+	// These four AVX tables are shared with unrelated instructions; checking
+	// their actual rows detects a changed immediate, mask or memory class.
+	tables := map[string][]string{
+		"_yvpslld": {
+			"Yu8,Yxr,Yxr", "Yi8,Yxr,Yxr", "Yu8,Yyr,Yyr", "Yi8,Yyr,Yyr",
+			"Yxm,Yxr,Yxr", "Yxm,Yyr,Yyr",
+			"Yu8,YxmEvex,YxrEvex", "Yu8,YxmEvex,Yknot0,YxrEvex",
+			"Yu8,YymEvex,YyrEvex", "Yu8,YymEvex,Yknot0,YyrEvex",
+			"Yu8,Yzm,Yzr", "Yu8,Yzm,Yknot0,Yzr",
+			"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"YxmEvex,YyrEvex,YyrEvex", "YxmEvex,YyrEvex,Yknot0,YyrEvex",
+			"YxmEvex,Yzr,Yzr", "YxmEvex,Yzr,Yknot0,Yzr",
+		},
+		"_yvpslldq": {
+			"Yu8,Yxr,Yxr", "Yi8,Yxr,Yxr", "Yu8,Yyr,Yyr", "Yi8,Yyr,Yyr",
+			"Yu8,YxmEvex,YxrEvex", "Yu8,YymEvex,YyrEvex", "Yu8,Yzm,Yzr",
+		},
+		"_yvandnpd": {
+			"Yxm,Yxr,Yxr", "Yym,Yyr,Yyr",
+			"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex",
+			"Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr",
+		},
+		"_yvblendmpd": {
+			"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex",
+			"Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr",
+		},
+	}
+	assertRows := func(source, name string, want []string) {
+		t.Helper()
+		block := regexp.MustCompile(`(?s)var ` + regexp.QuoteMeta(name) + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(source)
+		if len(block) != 2 {
+			t.Fatalf("missing Go table %s", name)
+		}
+		var got []string
+		for _, row := range regexp.MustCompile(`argList\{([^}]+)\}`).FindAllStringSubmatch(block[1], -1) {
+			got = append(got, strings.ReplaceAll(row[1], " ", ""))
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Fatalf("%s operand classes changed:\ngot %q\nwant %q", name, got, want)
+		}
+	}
+	for name, want := range tables {
+		assertRows(string(avx), name, want)
+	}
+	assertRows(string(legacy), "yps", []string{"Ymm,Ymr", "Yi8,Ymr", "Yxm,Yxr", "Yi8,Yxr"})
+	assertRows(string(legacy), "ypsdq", []string{"Yi8,Yxr"})
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for alias, canonical := range map[string]string{"PSLLDQ": "APSLLO", "PSRLDQ": "APSRLO"} {
+		if !regexp.MustCompile(`instructions\["` + alias + `"\]\s*=\s*x86\.` + canonical).Match(aliases) {
+			t.Fatalf("Go byte-shift alias changed: %s", alias)
+		}
+	}
+}
+
+func TestX86PackedShiftCompleteGoRowsThreeAPIsFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT shifts(SB),4,$0-0\n")
+			for _, op := range x86PackedShiftNames() {
+				for _, row := range x86PackedShiftRows(op, target.arch) {
+					fmt.Fprintln(&source, row)
+				}
+			}
+			source.WriteString("RET\n")
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := x86PackedShiftGoPackage(t, target.arch)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original format source invented numerical/native entry inputs", api, err)
+				}
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{"shifts": {Name: "shifts", Ret: Void}},
+				target.arch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerX86PackedShift(ins.Op, ins)
+				})
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftImmediateAnd386RejectedGoRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"PSLLW $128,X0", "PSRLO $128,X0", "VPSRLW $-1,X20,X21",
+			"VPSRLW $-1,(AX),X1", "VPSRLQ.Z $-1,X0,K1,X1", "VPSLLDQ $-1,Z0,Z1",
+			"VPSRLD $256,X0,X1", "VPSRLVW $1,X0,X1", "VPSRLW.BCST $1,(AX),X1",
+		} {
+			goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			assertX86PackedLogicalShiftRejected(t, arch, testTargetTriple("linux", arch), row)
+		}
+	}
+	for _, op := range []string{"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ"} {
+		for _, row := range []string{op + " $1,M0", op + " M0,M1", op + " (AX),M1"} {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			assertX86PackedLogicalShiftRejected(t, "386", "i386-unknown-linux-gnu", row)
+		}
+	}
+}
+
+func TestX86PackedShiftIdentityAndInvalidFormsHaveNoIRSideEffects(t *testing.T) {
+	for _, op := range x86PackedShiftNames() {
+		row := x86PackedShiftRows(op, "amd64")[0]
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", Op(strings.ToLower(op)), original.Op} {
+			ins := original
+			ins.Op = identity
+			ctx, _ := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			if recognized, _, err := ctx.lowerX86PackedShift(Op(strings.ToLower(op)), ins); !recognized || err != nil {
+				t.Fatalf("matching identity %s/%s: %v", op, identity, err)
+			}
+		}
+		for _, dispatch := range []Op{"UNKNOWN_SHIFT", "PSRAD", "PSLLL"} {
+			if dispatch == original.Op {
+				continue
+			}
+			ins := original
+			before := append([]Operand(nil), ins.Args...)
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			length := output.Len()
+			recognized, _, err := ctx.lowerX86PackedShift(dispatch, ins)
+			if recognized && err == nil || output.Len() != length || !reflect.DeepEqual(before, ins.Args) || ins.Op != original.Op {
+				t.Fatalf("conflicting/unknown %s/%s mutated or emitted IR", op, dispatch)
+			}
+		}
+	}
+	for _, row := range []string{
+		"VPSRLW $8,X0,Y1", "VPSLLDQ.Z $1,X0,K1,X1", "VPSLLW $1,X0,K0,X1",
+		"VPSLLD.BCST X0,X1,X2", "VPSRLD.RN_SAE $1,X0,X1", "VPSRLW $1,8(BAD),X1",
+		"VPSRLW $1,8(AX)(SP*2),X1", "VPSRLW $1,2147483648(AX),X1",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			continue
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+		length := output.Len()
+		if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); err == nil || output.Len() != length {
+			t.Fatalf("invalid row %s emitted %d bytes: %v", row, output.Len()-length, err)
+		}
+	}
+}
+
+func TestX86PackedShiftFullNativeMemoryReadAndSuppression(t *testing.T) {
+	for _, test := range []struct {
+		row        string
+		bytes      int
+		suppressed bool
+	}{
+		{"VPSRLW (AX),Y0,K1,Y1", 16, false},
+		{"VPSRLD (AX),Z0,K1,Z1", 16, false},
+		{"VPSRLQ (AX),Z0,K1,Z1", 16, false},
+		{"VPSRLW.Z $1,(AX),K1,Z1", 64, true},
+		{"VPSRLD.Z $1,(AX),K1,Z1", 64, true},
+		{"VPSRLQ.BCST.Z $1,(AX),K1,Z1", 8, true},
+		{"VPSRLVW.Z (AX),Z0,K1,Z1", 64, true},
+		{"VPSRLVD.BCST.Z (AX),Z0,K1,Z1", 4, true},
+		{"VPSRLDQ $1,(AX),Z1", 64, false},
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+test.row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		form, recognized, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+		if !recognized || err != nil || form.memoryBytes != test.bytes || form.faultSuppressed != test.suppressed {
+			t.Fatalf("native operand mismatch %s: %+v/%v", test.row, form, err)
+		}
+		if !test.suppressed {
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(output.String(), fmt.Sprintf("load volatile <%d x i8>", test.bytes)) {
+				t.Fatalf("lost full native read %s:\n%s", test.row, output.String())
+			}
+		}
+	}
+}
+
+func x86PackedShiftGoPackage(t *testing.T, arch string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "shifts.go", "package shifts\nfunc shifts()\n", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("shifts", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "shifts", Types: typed, Syntax: []*ast.File{file}}
+}
diff --git a/amd64_packed_shift_fp.go b/amd64_packed_shift_fp.go
new file mode 100644
index 000000000..167f8ae01
--- /dev/null
+++ b/amd64_packed_shift_fp.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+)
+
+// A logical FP span is usable only when every byte belongs to a validated
+// scalar ABI0 slot. Padding and unknown native caller-frame bytes are not
+// synthesized. This is a value/span proof, not a physical alignment proof.
+func (c *amd64Ctx) validateX86PackedShiftFPSpan(off int64, width int) error {
+	if width <= 0 || off < 0 || off > math.MaxInt64-int64(width) {
+		return fmt.Errorf("packed shift FP span is not bounded: %w", ErrProbeNeedsContext)
+	}
+	if err := c.validateFPVectorSpan(off, width); err != nil {
+		return fmt.Errorf("packed shift needs complete FP bytes: %v: %w", err, ErrProbeNeedsContext)
+	}
+	for byteOffset := off; byteOffset < off+int64(width); byteOffset++ {
+		slot, _, _ := c.fpVectorSlot(byteOffset)
+		if x86FrameScalarBytes(slot.Type, c.goarch) == 0 {
+			return fmt.Errorf("packed shift FP type %s lacks scalar byte storage: %w", slot.Type, ErrProbeNeedsContext)
+		}
+	}
+	return nil
+}
diff --git a/amd64_packed_shift_fp_context_test.go b/amd64_packed_shift_fp_context_test.go
new file mode 100644
index 000000000..c9546ad8b
--- /dev/null
+++ b/amd64_packed_shift_fp_context_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86PackedShiftCompleteFPSpanThreeAPIsFiveObjects(t *testing.T) {
+	// Even a fully declared logical ABI0 span comprises independent LLVM
+	// allocas. Read every bound byte without using a pointer to just the first
+	// alloca, and retain mask-controlled reads. BCST at +4 crosses two slots.
+	rows := []struct {
+		instruction string
+		masked      bool
+	}{
+		{"VPSRLW a+0(FP),Y1,Y2", false},
+		{"VPSRLQ a+0(FP),Z1,Z2", false},
+		{"VPSRLVW a+0(FP),Z1,Z2", false},
+		{"VPSRLVD.BCST a+4(FP),Z1,Z2", false},
+		{"VPSRLVQ.BCST a+4(FP),Z1,Z2", false},
+		{"VPSRLD $1,a+0(FP),Z2", false},
+		{"VPSRLQ.BCST $1,a+4(FP),Z2", false},
+		{"VPSRLDQ $1,a+0(FP),Z2", false},
+		{"VPSRLVW.Z a+0(FP),Z1,K1,Z2", true},
+		{"VPSRLVD.BCST.Z a+4(FP),Z1,K1,Z2", true},
+		{"VPSRLVQ.BCST.Z a+4(FP),Z1,K1,Z2", true},
+		{"VPSRLQ.BCST.Z $1,a+4(FP),K1,Z2", true},
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		fset := token.NewFileSet()
+		file, err := parser.ParseFile(fset, "shifts.go", "package shifts\nfunc shifts(a,b,c,d,e,f,g,h uint64)\n", 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sizes := types.SizesFor("gc", target.arch)
+		typed, err := (&types.Config{Sizes: sizes}).Check("shifts", fset, []*ast.File{file}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := GoPackage{Path: "shifts", Types: typed, Syntax: []*ast.File{file}}
+		sig, err := DeriveGoFuncABI0Signature("shifts", typed.Scope().Lookup("shifts").(*types.Func), target.arch, sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, row := range rows {
+			if row.masked && target.arch == "386" {
+				continue // Go's 386 source frontend rejects this explicit mask row.
+			}
+			source := "TEXT shifts(SB),4,$0-64\n" + row.instruction + "\nRET\n"
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			parsed, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"shifts": sig}}
+			original := parsed
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			if row.masked {
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original logical FP source invented the incoming mask", row.instruction, api, err)
+					}
+				}
+				format := x86InstructionFormatObjectUnit(t, original, options.Sigs, target.arch, target.triple, 0,
+					func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+						return c.lowerX86PackedShift(ins.Op, ins)
+					})
+				compileLLVMToObject(t, llc, target.triple, "fp-original-format.ll", "fp-original-format.o", format)
+				// The public positive source obtains its mask from an actual
+				// typed input. Independent FP slots still have no contiguous
+				// backing; the shift must gather precisely its complete span.
+				source = strings.Replace(source, "\n"+row.instruction,
+					"\nMOVQ a+0(FP),AX\nKMOVQ AX,K1\n"+row.instruction, 1)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				parsed, err = Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			ir, err := Translate(parsed, options)
+			if err != nil {
+				t.Fatalf("%s original FP read %s: Translate=%v", target.triple, row.instruction, err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "fp-shift.ll", "fp-shift.o", ir)
+			context := llvm.NewContext()
+			func() {
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, parsed, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatalf("%s original FP read %s: Module=%v", target.triple, row.instruction, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "fp-module.ll", "fp-module.o", module.String())
+				result, err := translateGoModuleInContext(context, pkg, []byte(strings.Replace(source, "shifts(SB)", "·shifts(SB)", 1)),
+					GoModuleOptions{GOARCH: target.arch, Sizes: sizes, TargetTriple: target.triple})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatalf("%s original FP read %s: GoModule=%v", target.triple, row.instruction, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "fp-go-module.ll", "fp-go-module.o", result.Module.String())
+			}()
+			instruction := original.Funcs[0].Instrs[1]
+			ctx, output := newAMD64CtxWithFuncForTest(t, original.Funcs[0], sig, nil)
+			if _, _, err := ctx.lowerX86PackedShift(instruction.Op, instruction); err != nil {
+				t.Fatalf("%s complete FP span: %v", row.instruction, err)
+			}
+			if row.masked && !strings.Contains(output.String(), "br i1") {
+				t.Fatalf("%s lost conditional FP reads", row.instruction)
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftIncompleteFPSpansFailBeforeIR(t *testing.T) {
+	for _, instruction := range []string{
+		"VPSRLW a+8(FP),Y1,Y2", "VPSRLQ.BCST $1,a+12(FP),Z2",
+		"VPSRLVD.BCST.Z a+14(FP),Z1,K1,Z2", "VPSRLDQ $1,a+0(FP),Z2",
+		"VPSRLVW.Z a+0(FP),Z1,K1,Z2", "VPSRLQ.BCST $1,a-1(FP),Z2",
+	} {
+		source := "TEXT shifts(SB),4,$0-16\n" + instruction + "\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, frame := range []FrameLayout{
+			{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}}},
+			{Params: []FrameSlot{{Offset: 0, Type: I8, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}}},
+		} {
+			sig := FuncSig{Ret: Void, Args: []LLVMType{frame.Params[0].Type, frame.Params[1].Type}, Frame: frame}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := output.Len()
+			ins := file.Funcs[0].Instrs[1]
+			if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || before != output.Len() {
+				t.Fatalf("%s incomplete/padded FP span emitted IR: %v", instruction, err)
+			}
+		}
+		for _, target := range []struct{ arch, triple string }{
+			{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+		} {
+			if target.arch == "386" && strings.Contains(instruction, "K1") {
+				continue
+			}
+			fset := token.NewFileSet()
+			declaration, err := parser.ParseFile(fset, "shifts.go", "package shifts\nfunc shifts(a,b uint64)\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", target.arch)
+			typed, err := (&types.Config{Sizes: sizes}).Check("shifts", fset, []*ast.File{declaration}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig, err := DeriveGoFuncABI0Signature("shifts", typed.Scope().Lookup("shifts").(*types.Func), target.arch, sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"shifts": sig}}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s original unbound FP span %s: Translate=%v", target.triple, instruction, err)
+			}
+			context := llvm.NewContext()
+			func() {
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s original unbound FP span %s: Module=%v", target.triple, instruction, err)
+				}
+				pkg := GoPackage{Path: "shifts", Types: typed, Syntax: []*ast.File{declaration}}
+				result, err := translateGoModuleInContext(context, pkg, []byte(strings.Replace(source, "shifts(SB)", "·shifts(SB)", 1)),
+					GoModuleOptions{GOARCH: target.arch, Sizes: sizes, TargetTriple: target.triple})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s original unbound FP span %s: GoModule=%v", target.triple, instruction, err)
+				}
+			}()
+		}
+	}
+}
diff --git a/amd64_packed_shift_fp_runtime_test.go b/amd64_packed_shift_fp_runtime_test.go
new file mode 100644
index 000000000..b38497dbd
--- /dev/null
+++ b/amd64_packed_shift_fp_runtime_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedShiftFPSpanNumerical(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	var prefix []string
+	flags := []string{"-no-pie"}
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		if !rosettaAvailable() {
+			t.Fatal("Darwin x86 diagnostic transport required")
+		}
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+		flags = []string{"-arch", "x86_64"}
+	} else if runtime.GOOS == "linux" && runtime.GOARCH == "arm64" {
+		qemu, err := exec.LookPath("qemu-x86_64")
+		if err != nil {
+			t.Fatal("explicit Linux x86 runtime transport required:", err)
+		}
+		clang, err = exec.LookPath("x86_64-linux-gnu-gcc")
+		if err != nil {
+			t.Fatal("x86 cross C compiler required:", err)
+		}
+		prefix = []string{qemu, "-L", "/usr/x86_64-linux-gnu"}
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("required Linux/amd64 counterpart supplies this numerical axis")
+	}
+	const source = `TEXT fpbytes(SB),4,$0-16
+VPSRLD.BCST $0,a+0(FP),X0
+MOVQ X0,AX
+MOVQ AX,r+8(FP)
+RET
+TEXT fpcross(SB),4,$0-24
+VPSRLQ.BCST $0,a+4(FP),X0
+MOVQ X0,AX
+MOVQ AX,r+16(FP)
+RET
+TEXT fpcount(SB),4,$0-24
+MOVQ $0x89abcdef76543210,AX
+MOVQ AX,X0
+VPSRLD a+0(FP),X0,X1
+MOVQ X1,AX
+MOVQ AX,r+16(FP)
+RET
+`
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bytesSig := FuncSig{Name: "fpbytes", Args: []LLVMType{I8, I8, I8, I8}, Ret: I64,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I8, Index: 0, Field: -1}, {Offset: 1, Type: I8, Index: 1, Field: -1},
+			{Offset: 2, Type: I8, Index: 2, Field: -1}, {Offset: 3, Type: I8, Index: 3, Field: -1},
+		}, Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}}}}
+	wideSig := FuncSig{Args: []LLVMType{I64, I64}, Ret: I64,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1},
+		}, Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}}}}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"fpbytes": bytesSig, "fpcross": wideSig, "fpcount": wideSig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const driver = `
+#include <stdint.h>
+#include <stdio.h>
+extern uint64_t fpbytes(uint8_t,uint8_t,uint8_t,uint8_t);
+extern uint64_t fpcross(uint64_t,uint64_t);
+extern uint64_t fpcount(uint64_t,uint64_t);
+int main(void) {
+ for(unsigned i=0;i<96;++i) {
+  uint8_t a=(uint8_t)(i*71+13),b=(uint8_t)(i*97+11);
+  uint8_t c=(uint8_t)(i*53+17),d=(uint8_t)(i*19+7);
+  uint64_t word=(uint32_t)a|((uint32_t)b<<8)|((uint32_t)c<<16)|((uint32_t)d<<24);
+  if(fpbytes(a,b,c,d)!=(word|(word<<32))) { fprintf(stderr,"four byte FP BCST mismatch %u\n",i); return 1; }
+  uint64_t first=UINT64_C(0xabcdef1276543210)^(UINT64_C(0x12345678)*i);
+  uint64_t second=UINT64_C(0x179bdeff23056789)^(UINT64_C(0x87654321)*i);
+  if(fpcross(first,second)!=((first>>32)|(second<<32))) { fprintf(stderr,"cross slot FP BCST mismatch %u\n",i); return 2; }
+  uint64_t count=i<40?i:UINT64_C(0x100000000)+i;
+  uint64_t expected=count<32?((uint64_t)(UINT32_C(0x89abcdef)>>count)<<32)|(UINT32_C(0x76543210)>>count):0;
+  if(fpcount(count,second)!=expected) { fprintf(stderr,"full m128 FP count mismatch %u\n",i); return 3; }
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, append([]string{clang}, flags...), "packed_shift_fp_span", triple, ir, driver, prefix)
+	if strings.Contains(ir, "inttoptr i64 0") {
+		t.Fatal("FP bytes were replaced by an unbound zero pointer")
+	}
+	t.Logf("three initialized FP span programs ×96 numerical inputs; original Go encoding accepted, LLVM execution transport=%v", prefix)
+}
diff --git a/amd64_packed_shift_literal.go b/amd64_packed_shift_literal.go
new file mode 100644
index 000000000..692c95cbc
--- /dev/null
+++ b/amd64_packed_shift_literal.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+// One adjacent immediate logical-right shift retains bit dependencies which
+// cannot be represented by the ordinary whole-byte vector domain. This is not
+// a vector value, a memory permission or a fact about any other instruction.
+type x86ResultShiftBits struct {
+	input                        uint64
+	register, width, lane, count uint8
+}
+
+func x86ResultShiftBitSource(ins Instr, form x86PackedShiftForm, input uint64, destination int) x86ResultShiftBits {
+	if !x86ResultNamedPredicateInstruction(ins) || form.left || form.arithmetic || form.mmx ||
+		form.mask >= 0 || form.countMode != x86PackedShiftUniform || form.countOperand.Kind != OpImm ||
+		form.laneBits != 16 && form.laneBits != 32 && form.laneBits != 64 {
+		return x86ResultShiftBits{}
+	}
+	return x86ResultShiftBits{input: input, register: uint8(destination),
+		width: uint8(form.byteWidth), lane: uint8(form.laneBits), count: uint8(form.countOperand.Imm)}
+}
+
+// Only emitted, immutable same-module bytes may remove an input dependency.
+// Extent and the actual full native read remain independently checked by the
+// ordinary logical transfer before this projection is used.
+type x86ShiftLiteral struct {
+	bytes [64]byte
+	width uint8
+}
+
+func (pending x86ResultShiftBits) definedBytes(ins Instr, form x86PackedLogicalForm, literals map[x86StaticSBAddress]x86ShiftLiteral, arch string) uint64 {
+	if pending.width == 0 || form.byteWidth != int(pending.width) || form.mask >= 0 || form.memoryBytes <= 0 || form.memory != form.first ||
+		!x86ResultNamedPredicateInstruction(ins) || form.spec.mode == amd64PackedLogicalXor {
+		return 0
+	}
+	second, valid := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	address, static := x86StaticSBReadAddress(form.source, arch)
+	literal := literals[address]
+	if !valid || second != int(pending.register) || !static || int(literal.width) < form.memoryBytes {
+		return 0
+	}
+	var known uint64
+	for at := 0; at < form.byteWidth; at++ {
+		mask := x86PackedLogicalSecondBits(form.spec.mode, literal.bytes[at%form.memoryBytes])
+		defined := true
+		for bit := 0; bit < 8; bit++ {
+			if mask&(1<<uint(bit)) == 0 {
+				continue
+			}
+			inLane := at*8%int(pending.lane) + bit + int(pending.count)
+			if inLane >= int(pending.lane) {
+				continue // Logical right shifts supply zero above the lane.
+			}
+			input := at*8/int(pending.lane)*int(pending.lane)/8 + inLane/8
+			if pending.input&(uint64(1)<<uint(input)) == 0 {
+				defined = false
+				break
+			}
+		}
+		if defined {
+			known |= uint64(1) << uint(at)
+		}
+	}
+	return known
+}
+
+// Requests describe source tuples only. Each consumer must obtain their bytes
+// from its own validated immutable storage, with no permission transferred here.
+func x86PackedLogicalLiteralRequests(file *File, arch string) map[string]map[int64]int {
+	requests := make(map[string]map[int64]int)
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			form, known, err := x86PackedLogicalProperties(ins, arch)
+			if !known || err != nil || form.mmx || form.memory < 0 || form.memoryBytes <= 0 || form.memoryBytes > 64 {
+				continue
+			}
+			address, valid := x86StaticSBReadAddress(form.source, arch)
+			if !valid || address.offset > maxDataGlobalSize-int64(form.memoryBytes) {
+				continue
+			}
+			if requests[address.symbol] == nil {
+				requests[address.symbol] = make(map[int64]int)
+			}
+			if requests[address.symbol][address.offset] < form.memoryBytes {
+				requests[address.symbol][address.offset] = form.memoryBytes
+			}
+		}
+	}
+	return requests
+}
+
+// Snapshot only requested tuples (at most one Z register), never a large global
+// allocation. The existing static directory rejects coalesced DATA definitions,
+// overlapping ranges and code/signature namespaces. A unique valid readonly
+// GLOBL and a relocation-free object are additional literal requirements.
+func x86LoweredShiftLiterals(file *File, resolve func(string) string, values *x86StaticAddressValues, arch string) map[x86StaticSBAddress]x86ShiftLiteral {
+	if file == nil || values == nil || resolve == nil {
+		return nil
+	}
+	needed := false
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+			needed = needed || known && err == nil && x86ResultShiftBitSource(ins, form, 0, 0).width != 0
+		}
+	}
+	if !needed {
+		return nil
+	}
+	type object struct {
+		globals int
+		literal bool
+		data    []DataStmt
+	}
+	objects := make(map[string]*object)
+	objectFor := func(symbol string) *object {
+		name := resolveAssemblyDataSymbol(symbol, resolve)
+		if objects[name] == nil {
+			objects[name] = &object{literal: values.objects[name] && !values.writable[name]}
+		}
+		return objects[name]
+	}
+	for _, global := range file.Globl {
+		current := objectFor(global.Sym)
+		readonly, err := globlReadOnly(global.Flags)
+		current.globals++
+		current.literal = current.literal && err == nil && readonly
+	}
+	for _, datum := range file.Data {
+		current := objectFor(datum.Sym)
+		current.literal = current.literal && datum.Addr == "" && int64(len(datum.Payload)) <= datum.Width
+		current.data = append(current.data, datum)
+	}
+	literals := make(map[x86StaticSBAddress]x86ShiftLiteral)
+	for symbol, offsets := range x86PackedLogicalLiteralRequests(file, arch) {
+		current := objects[resolveAssemblyDataSymbol(symbol, resolve)]
+		if current == nil || !current.literal || current.globals != 1 {
+			continue
+		}
+		for offset, width := range offsets {
+			address := x86StaticSBAddress{symbol, offset}
+			literal := x86ShiftLiteral{width: uint8(width)}
+			for _, datum := range current.data {
+				for at := 0; at < width; at++ {
+					offset := address.offset + int64(at) - datum.Off
+					if offset < 0 || offset >= datum.Width {
+						continue
+					}
+					// Same little-endian, sign-extended numeric/padded string
+					// bytes as dataStmtPayload, without allocating datum.Width.
+					if datum.Payload != nil {
+						if offset < int64(len(datum.Payload)) {
+							literal.bytes[at] = datum.Payload[offset]
+						}
+					} else if offset < 8 {
+						literal.bytes[at] = byte(datum.Value >> uint(offset*8))
+					} else if datum.Value < 0 {
+						literal.bytes[at] = 0xff
+					}
+				}
+			}
+			literals[address] = literal
+		}
+	}
+	return literals
+}
diff --git a/amd64_packed_shift_literal_binding_test.go b/amd64_packed_shift_literal_binding_test.go
new file mode 100644
index 000000000..fced86772
--- /dev/null
+++ b/amd64_packed_shift_literal_binding_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86PackedShiftLiteralBindingAndStateLifetime(t *testing.T) {
+	for _, mutation := range []string{"control", "missing-global", "mutable", "duplicate-global",
+		"relocation", "overlap", "payload-too-long", "code-collision", "resolved-alias"} {
+		t.Run(mutation, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, x86ShiftLiteralMaskSource(x86ShiftLiteralMaskCases()[0], "PAND", 4, 0x0f, 0))
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string {
+				symbol = strings.TrimPrefix(symbol, "·")
+				if symbol == "alias" {
+					return "mask<>"
+				}
+				return symbol
+			}
+			switch mutation {
+			case "missing-global":
+				file.Globl = nil
+			case "mutable":
+				file.Globl[0].Flags = "0"
+			case "duplicate-global":
+				file.Globl = append(file.Globl, file.Globl[0])
+			case "relocation":
+				file.Data[0].Addr = "·other"
+			case "overlap":
+				file.Data = append(file.Data, file.Data[0])
+			case "payload-too-long":
+				file.Data[0].Payload = make([]byte, 9)
+			case "code-collision":
+				file.Funcs = append(file.Funcs, Func{Sym: "mask<>"})
+			case "resolved-alias":
+				file.Data[1].Sym = "alias"
+			}
+			values := x86LoweredStaticAddressValues(file, resolve, nil, "amd64")
+			literals := x86LoweredShiftLiterals(file, resolve, values, "amd64")
+			if mutation != "control" {
+				if len(literals) != 0 {
+					t.Fatal("unbound, mutable or aliased object supplied literal bits", literals)
+				}
+				return
+			}
+			literal := literals[x86StaticSBAddress{symbol: "mask<>"}]
+			if len(literals) != 1 || literal.width != 16 {
+				t.Fatal("complete actual readonly tuple was lost", literals)
+			}
+			for _, value := range literal.bytes[:literal.width] {
+				if value != 0x0f {
+					t.Fatal("literal bits disagree with actual emitted DATA", literal)
+				}
+			}
+		})
+	}
+	pending := x86ResultShiftBits{input: 1, register: 3, width: 64, lane: 16, count: 4}
+	state := x86ResultState{shiftBits: pending}
+	if state.clone().shiftBits != pending || state.intersect(state).shiftBits != pending {
+		t.Fatal("identical adjacent dependency was not value-copied")
+	}
+	other := state.clone()
+	other.shiftBits.input = 3
+	if state.intersect(other).shiftBits.width != 0 || state.intersect(x86ResultState{}).shiftBits.width != 0 {
+		t.Fatal("different predecessor shifts were joined as one fact")
+	}
+}
+
+func TestX86PackedShiftRawKeepsNamedBitDependenciesSeparate(t *testing.T) {
+	pending := x86ResultShiftBits{input: 1, register: 3, width: 64, lane: 16, count: 4}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedShiftRawCases() {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code(false))
+				for _, knownBytes := range []uint64{1, ^uint64(0)} {
+					state := x86ResultState{shiftBits: pending}
+					for index := 0; index < 3; index++ {
+						state.writeVector(index, 64, knownBytes, false)
+					}
+					state.pointerGP[3], state.masks[1] = true, true
+					accepted, known := x86LoweredRawPackedShiftStep(ins, &state, nil, arch)
+					if !known || !accepted || state.shiftBits != pending {
+						t.Fatal("raw projection created or replaced a named-only bit dependency", accepted, known)
+					}
+				}
+			})
+		}
+	}
+
+	state := x86ResultState{}
+	state.writeVector(1, 16, 1, true)
+	ins := x86ScalarLaneInstruction(t, "VPSRLW $4,X1,X0")
+	accepted, known := x86ResultPackedShiftStepWithRead(ins, &state, nil, "amd64", true)
+	want := x86ResultShiftBits{input: 1, register: 0, width: 16, lane: 16, count: 4}
+	if !accepted || !known || state.shiftBits != want {
+		t.Fatal("genuine named input lost its adjacent bit dependency", accepted, known, state.shiftBits)
+	}
+}
diff --git a/amd64_packed_shift_literal_mask_test.go b/amd64_packed_shift_literal_mask_test.go
new file mode 100644
index 000000000..6b0cc1cd7
--- /dev/null
+++ b/amd64_packed_shift_literal_mask_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ShiftLiteralMaskCase struct {
+	shift, bank string
+	width       int
+	vector      bool
+}
+
+// Independent of the production shift registry: all W/D/Q logical-right
+// families, with legacy X and VEX/EVEX X/Y/Z carriers.
+func x86ShiftLiteralMaskCases() []x86ShiftLiteralMaskCase {
+	var rows []x86ShiftLiteralMaskCase
+	for _, pair := range [][2]string{{"PSRLW", "VPSRLW"}, {"PSRLL", "VPSRLD"}, {"PSRLQ", "VPSRLQ"}} {
+		rows = append(rows, x86ShiftLiteralMaskCase{shift: pair[0], bank: "X", width: 16})
+		for _, bank := range []struct {
+			name  string
+			width int
+		}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+			rows = append(rows, x86ShiftLiteralMaskCase{shift: pair[1], bank: bank.name, width: bank.width, vector: true})
+		}
+	}
+	return rows
+}
+
+func x86ShiftLiteralMaskSource(row x86ShiftLiteralMaskCase, logical string, shift int, mask byte, extract int) string {
+	var source strings.Builder
+	value := uint64(mask) * 0x0101010101010101
+	for at := 0; at < row.width; at += 8 {
+		fmt.Fprintf(&source, "DATA mask<>+%d(SB)/8,$%#x\n", at, value)
+	}
+	fmt.Fprintf(&source, "GLOBL mask<>(SB),8,$%d\n", row.width)
+	source.WriteString("TEXT ·view(SB),4,$0-12\nMOVQ input+0(FP),SI\nPINSRB $0,(SI),X0\n")
+	// Deliberately leave every other byte of X0/Y0/Z0 unknown. Initializing
+	// the whole bank would hide the missing bit-to-byte dependency.
+	destination := "X0"
+	if row.vector {
+		destination = "X1"
+		fmt.Fprintf(&source, "%s $%d,%s0,%s1\n", row.shift, shift, row.bank, row.bank)
+		logical = "V" + logical
+		if row.bank == "Z" {
+			logical += "D"
+		}
+		fmt.Fprintf(&source, "%s mask<>(SB),%s1,%s1\n", logical, row.bank, row.bank)
+	} else {
+		fmt.Fprintf(&source, "%s $%d,X0\n%s mask<>(SB),X0\n", row.shift, shift, logical)
+	}
+	fmt.Fprintf(&source, "PEXTRB $%d,%s,AX\nMOVL AX,ret+8(FP)\nRET\n", extract, destination)
+	return source.String()
+}
+
+func TestX86PackedLogicalRightShiftLiteralMaskDefinedBits(t *testing.T) {
+	for _, row := range x86ShiftLiteralMaskCases() {
+		for _, shift := range []int{0, 1, 4, 7} {
+			for _, logical := range []string{"PAND", "PANDN", "POR"} {
+				mask := byte(255 >> uint(shift))
+				if logical == "POR" {
+					mask = ^mask // OR's known ones remove the same unknown bits.
+				}
+				source := x86ShiftLiteralMaskSource(row, logical, shift, mask, 0)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%d/%s", row.shift, row.bank, logical, shift, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(input *byte) uint32\n",
+							"amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatalf("defined selected bits lost after literal mask: output=%t err=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftLiteralMaskKeepsUnknownBits(t *testing.T) {
+	for _, row := range x86ShiftLiteralMaskCases() {
+		for _, mutation := range []struct {
+			name, logical  string
+			shift, extract int
+			mask           byte
+		}{
+			{"one-unknown-bit", "PAND", 4, 0, 0x1f},
+			{"unmasked-unknown-bits", "PAND", 4, 0, 0xff},
+			{"shift-needs-next-byte", "PAND", 5, 0, 0x0f},
+			{"unused-byte-stays-unknown", "PAND", 4, 1, 0x0f},
+			{"xor-does-not-kill-dependencies", "PXOR", 4, 0, 0x0f},
+			{"or-leaves-unknown-bit", "POR", 4, 0, 0xe0},
+		} {
+			source := x86ShiftLiteralMaskSource(row, mutation.logical, mutation.shift, mutation.mask, mutation.extract)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(row.shift+"/"+row.bank+"/"+mutation.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(input *byte) uint32\n",
+						"amd64", "x86_64-unknown-linux-gnu", api)
+					x86VectorScratchCodegenControl(t, source, "func view(input *byte) uint32\n",
+						"amd64", "x86_64-unknown-linux-gnu", ir, err)
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftLiteralMaskKeepsSourceAndMemoryBoundaries(t *testing.T) {
+	for _, row := range x86ShiftLiteralMaskCases() {
+		source := x86ShiftLiteralMaskSource(row, "PAND", 4, 0x0f, 0)
+		logical := "PAND"
+		if row.vector {
+			logical = "VPAND"
+			if row.bank == "Z" {
+				logical += "D"
+			}
+		}
+		maskLine := logical + " mask<>(SB),"
+		for _, mutation := range []struct{ name, source string }{
+			{"unknown-native-base", strings.Replace(source, "MOVQ input+0(FP),SI\n", "", 1)},
+			{"unknown-selected-byte", strings.Replace(source, "PINSRB $0,(SI),X0\n", "", 1)},
+			{"unknown-index", strings.Replace(source, "(SI),X0", "(SI)(CX*1),X0", 1)},
+			// The original mutation first renames GLOBL, leaving the DATA
+			// and the actual read at mask<>. Keep that source/case intact.
+			{"unknown-literal", strings.Replace(source, " mask<>(SB),", " external(SB),", 1)},
+			{"unbound-read-symbol", strings.Replace(source, maskLine, logical+" external(SB),", 1)},
+			{"mutable-mask", strings.Replace(source, "GLOBL mask<>(SB),8,", "GLOBL mask<>(SB),0,", 1)},
+			{"short-literal", strings.Replace(source, maskLine, logical+" mask<>+1(SB),", 1)},
+			{"intervening-nop", strings.Replace(source, maskLine, "NOP\n"+maskLine, 1)},
+			{"intervening-other-register", strings.Replace(source, maskLine, "PINSRB $0,(SI),X2\n"+maskLine, 1)},
+			{"intervening-branch", strings.Replace(source, maskLine, "JMP masked\nmasked:\n"+maskLine, 1)},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(row.shift+"/"+row.bank+"/"+mutation.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, mutation.source, "func view(input *byte) uint32\n",
+						"amd64", "x86_64-unknown-linux-gnu", api)
+					if mutation.name == "unbound-read-symbol" {
+						prefix, _, _ := strings.Cut(source, "TEXT ")
+						changedPrefix, _, _ := strings.Cut(mutation.source, "TEXT ")
+						if prefix != changedPrefix || strings.Count(mutation.source, logical+" external(SB),") != 1 {
+							t.Fatal("unbound read must change exactly the instruction, not DATA/GLOBL")
+						}
+					}
+					switch mutation.name {
+					case "unknown-literal", "mutable-mask":
+						x86ShiftMutableMaskCodegenControl(t, mutation.source, row.width, api, ir, err)
+						return
+					case "unknown-selected-byte", "intervening-nop", "intervening-other-register", "intervening-branch":
+						x86VectorScratchCodegenControl(t, mutation.source, "func view(input *byte) uint32\n",
+							"amd64", "x86_64-unknown-linux-gnu", ir, err)
+						return
+					}
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("missing source/readonly/address role was manufactured: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// An actual read of complete mutable DATA is separate from a literal that may
+// eliminate an input dependency. Keep native effects through O2; an unwritten
+// private object's ordinary load may be folded by the optimizer.
+func x86ShiftMutableMaskCodegenControl(t *testing.T, source string, width int, api, ir string, codegenErr error) {
+	t.Helper()
+	const declaration = "func view(input *byte) uint32\n"
+	const triple = "x86_64-unknown-linux-gnu"
+	x86VectorScratchCodegenControl(t, source, declaration, "amd64", triple, ir, codegenErr)
+
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym("scratch")
+	values := x86LoweredStaticAddressValues(file, resolve, nil, "amd64")
+	literals := x86LoweredShiftLiterals(file, resolve, values, "amd64")
+	if literal := literals[x86StaticSBAddress{symbol: "mask<>"}]; literal.width != 0 {
+		t.Fatal("mutable or undeclared GLOBL acquired immutable mask bytes")
+	}
+
+	const load = "MOVQ input+0(FP),SI\n"
+	if strings.Count(source, load) != 1 {
+		t.Fatal("the native-read control lost its one input initialization")
+	}
+	initialized := strings.Replace(source, load, "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"+load, 1)
+	before, err := x86ScalarFPBitViewAPI(t, initialized, declaration, "amd64", triple, api)
+	if err != nil || before == "" {
+		t.Fatal("explicit-vector native-read control failed", err)
+	}
+	wantGlobal := fmt.Sprintf("@mask = internal global [%d x i8] c\"%s\"", width, strings.Repeat("\\0F", width))
+	if !strings.Contains(ir, wantGlobal) {
+		t.Fatal("the read mask lost its complete mutable DATA initializer", width)
+	}
+	legacyRead := strings.Contains(ir, "asm sideeffect \"pand (")
+	if legacyRead {
+		if width != 16 || !strings.Contains(ir, "~{memory}") {
+			t.Fatal("legacy mask lost its original m128 PAND")
+		}
+	} else if strings.Count(ir, fmt.Sprintf("load <%d x i8>, ptr @mask, align 1", width)) != 1 {
+		t.Fatal("the owned mask lost its complete ordinary read", width)
+	}
+	if x86NumericNativeVolatileReadBytes(t, ir) != 1 {
+		t.Fatal("the independent PINSRB byte read was lost")
+	}
+	x86RequireSameNativeMemoryEffects(t, before, ir)
+	optimized := x86DwordProductIROptimize(t, ir)
+	if x86NumericNativeVolatileReadBytes(t, optimized) != 1 {
+		t.Fatal("optimization lost the independent PINSRB byte read")
+	}
+	x86RequireSameNativeMemoryEffects(t, before, optimized)
+	x86NumericNativeAddressObject(t, optimized, triple)
+}
diff --git a/amd64_packed_shift_literal_objects_test.go b/amd64_packed_shift_literal_objects_test.go
new file mode 100644
index 000000000..634125ab6
--- /dev/null
+++ b/amd64_packed_shift_literal_objects_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ShiftLiteralKernel struct {
+	name        string
+	shift, mode int
+	mask        byte
+}
+
+// Keep every form in one complete source, with distinct function and DATA
+// identities. The legacy subset is the same source used by the native oracle.
+func x86ShiftLiteralMaskProgram(legacyOnly bool) (string, string, []x86ShiftLiteralKernel) {
+	var source, declarations strings.Builder
+	var kernels []x86ShiftLiteralKernel
+	for _, row := range x86ShiftLiteralMaskCases() {
+		if legacyOnly && row.vector {
+			continue
+		}
+		for _, shift := range []int{0, 1, 4, 7} {
+			for mode, logical := range []string{"PAND", "PANDN", "POR"} {
+				name := fmt.Sprint("shiftMask", len(kernels))
+				mask := byte(255 >> uint(shift))
+				if mode == 2 {
+					mask = ^mask
+				}
+				assembly := x86ShiftLiteralMaskSource(row, logical, shift, mask, 0)
+				assembly = strings.ReplaceAll(assembly, "mask<>", name+"Mask<>")
+				assembly = strings.ReplaceAll(assembly, "·view", "·"+name)
+				source.WriteString(assembly)
+				fmt.Fprintf(&declarations, "func %s(input *byte) uint32\n", name)
+				kernels = append(kernels, x86ShiftLiteralKernel{name, shift, mode, mask})
+			}
+		}
+	}
+	return source.String(), declarations.String(), kernels
+}
+
+func TestX86PackedShiftLiteralMaskCompleteThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source, declarations, kernels := x86ShiftLiteralMaskProgram(false)
+	if len(kernels) != 144 {
+		t.Fatal("incomplete W/D/Q × legacy/VEX/EVEX × shift × logical union", len(kernels))
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "shift-mask.ll", "shift-mask.o", ir)
+				})
+			}
+		})
+	}
+	t.Log("144 complete functions × 3 APIs × Linux/Darwin/Windows LLVM22 objects; no physical AVX512 execution claim")
+}
diff --git a/amd64_packed_shift_literal_runtime_test.go b/amd64_packed_shift_literal_runtime_test.go
new file mode 100644
index 000000000..9fab7ad6a
--- /dev/null
+++ b/amd64_packed_shift_literal_runtime_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Native legacy SSE is the independent counterpart. Virtual Y/Z object checks
+// above do not stand in for executing hardware AVX512. The existing execution
+// route owns explicit Linux QEMU or a truthful host-inapplicable result.
+func TestCrossLinuxRuntimeMatrixX86PackedShiftLiteralMasksOriginalGoAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, declarations, kernels := x86ShiftLiteralMaskProgram(true)
+	if len(kernels) != 36 {
+		t.Fatal("incomplete original legacy W/D/Q × 3 logical × 4 shift union", len(kernels))
+	}
+	var goCases, cDeclarations, cCases strings.Builder
+	for _, kernel := range kernels {
+		fmt.Fprintf(&goCases, "{%q,%s,%d,%d,%d},\n", kernel.name, kernel.name, kernel.shift, kernel.mode, kernel.mask)
+		fmt.Fprintf(&cDeclarations, "extern uint32_t %s(const uint8_t *);\n", kernel.name)
+		fmt.Fprintf(&cCases, "{%q,%s,%d,%d,%d},\n", kernel.name, kernel.name, kernel.shift, kernel.mode, kernel.mask)
+	}
+	program := `package main
+
+import "fmt"
+
+` + declarations + `
+type kernel struct {
+    name string
+    call func(*byte) uint32
+    shift uint
+    mode int
+    mask byte
+}
+
+var kernels = []kernel{
+` + goCases.String() + `}
+
+func main() {
+    for _, test := range kernels {
+        for sample := 0; sample < 256; sample++ {
+            input := [3]byte{0xa5, byte(sample), 0x5a}
+            before := input
+            want := byte(sample) >> test.shift
+            switch test.mode {
+            case 0:
+                want &= test.mask
+            case 1:
+                want = ^want & test.mask
+            case 2:
+                want |= test.mask
+            }
+            got := test.call(&input[1])
+            if got != uint32(want) || input != before {
+                panic(fmt.Sprintf("%s sample=%d got=%x want=%x input=%x", test.name, sample, got, want, input))
+            }
+        }
+    }
+    fmt.Println("original legacy shift masks: 36x256 PASS")
+}
+`
+	formatted, err := format.Source([]byte(program))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":  "module original_shift_masks\n\ngo 1.20\n",
+		"main.go": string(formatted), "masks_amd64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goos := "linux"
+	if strings.Contains(execution.triple, "apple") {
+		goos = "darwin"
+	} else if strings.Contains(execution.triple, "windows") {
+		goos = "windows"
+	}
+	original := filepath.Join(directory, "original")
+	if goos == "windows" {
+		original += ".exe"
+	}
+	environment := []string{"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "CGO_ENABLED=0", "GOARCH=amd64", "GOOS=" + goos}
+	dataGlobalAlignmentCommand(t, directory, environment, "go", "build", "-p=2", "-o", original, ".")
+	if output := string(execution.run(t, original)); strings.TrimSpace(output) != "original legacy shift masks: 36x256 PASS" {
+		t.Fatal("missing actual original-Go oracle completion", output)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + cDeclarations.String() + `
+struct Case {
+    const char *name;
+    uint32_t (*call)(const uint8_t *);
+    unsigned shift, mode;
+    uint8_t mask;
+};
+static const struct Case cases[] = {
+` + cCases.String() + `};
+
+int main(void) {
+    for (unsigned c = 0; c < sizeof(cases)/sizeof(cases[0]); c++) {
+        const struct Case *test = cases + c;
+        for (unsigned sample = 0; sample < 256; sample++) {
+            uint8_t input[3] = {0xa5, (uint8_t)sample, 0x5a};
+            uint8_t before[3];
+            memcpy(before, input, sizeof(input));
+            uint8_t want = (uint8_t)sample >> test->shift;
+            if (test->mode == 0) want &= test->mask;
+            if (test->mode == 1) want = (uint8_t)~want & test->mask;
+            if (test->mode == 2) want |= test->mask;
+            uint32_t got = test->call(input + 1);
+            if (got != want || memcmp(input, before, sizeof(input))) {
+                fprintf(stderr, "%s sample=%u got=%x want=%x\n", test->name, sample, got, (unsigned)want);
+                return 1;
+            }
+        }
+    }
+    puts("LLVM legacy shift masks: 36x256 PASS");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(api+"/"+level, func(t *testing.T) {
+				if output := string(execution.compileAndRunLLVM(t, "shift-literal-masks", ir, main, level)); strings.TrimSpace(output) != "LLVM legacy shift masks: 36x256 PASS" {
+					t.Fatal("missing actual LLVM oracle completion", output)
+				}
+			})
+		}
+	}
+	t.Log("36 original Go legacy SSE kernels × all 256 byte values; independent C byte oracle; 3 APIs × llc O0/O2; other vector bytes intentionally not initialized")
+}
diff --git a/amd64_packed_shift_mode32_test.go b/amd64_packed_shift_mode32_test.go
new file mode 100644
index 000000000..076e5343f
--- /dev/null
+++ b/amd64_packed_shift_mode32_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"encoding/hex"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86PackedShiftActualGoBytes(t *testing.T, arch, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	input := filepath.Join(dir, "original.s")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", filepath.Join(dir, "original.o"), input)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual Go %s original source: %v\n%s", arch, err, output)
+	}
+	var code []byte
+	for _, line := range regexp.MustCompile(`(?m)^\s*0x[[:xdigit:]]+\s+((?:[[:xdigit:]]{2} )+)`).FindAllSubmatch(output, -1) {
+		part, err := hex.DecodeString(strings.ReplaceAll(string(line[1]), " ", ""))
+		if err != nil {
+			t.Fatal(err)
+		}
+		code = append(code, part...)
+	}
+	return code
+}
+
+func TestX86PackedShiftMode32NamedPhysicalBanks(t *testing.T) {
+	for _, row := range []string{
+		"VPSRLW $1,X20,X21", "VPSRLD X0,Y20,Y21", "VPSRLQ (AX),X20,X21",
+		"VPSRLVW X1,X20,X21", "VPSRLVD.BCST (AX),Y20,Y21", "VPSRLVQ X0,X20,X21",
+		"VPSLLDQ $1,X16,X31", "VPSRLDQ $1,Y20,Y21",
+	} {
+		source := "TEXT shifts(SB),4,$0-0\n" + row + "\nRET\n"
+		code := x86PackedShiftActualGoBytes(t, "386", source)
+		_, _, recognized, err := decodedX86PackedUniformShiftInstruction(code, 32)
+		if !recognized {
+			_, _, recognized, err = decodedX86PerLaneVariableShiftInstruction(code, 32)
+		}
+		if !recognized {
+			_, _, recognized, err = decodedX86RawVectorByteShiftInstruction(code, 32)
+		}
+		if !recognized || err == nil {
+			t.Fatalf("mode32 raw bytes %x for %s did not reject unavailable physical bank: %v", code, row, err)
+		}
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+			options := Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"shifts": {Ret: Void}}}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s named unavailable SIMD bank %s: %v", triple, row, err)
+			}
+			context := llvm.NewContext()
+			func() {
+				defer context.Dispose()
+				module, err := TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s module unavailable SIMD bank %s: %v", triple, row, err)
+				}
+				result, err := translateGoModuleInContext(context, x86PackedShiftGoPackage(t, "386"),
+					[]byte(strings.Replace(source, "shifts(SB)", "·shifts(SB)", 1)), GoModuleOptions{GOARCH: "386", TargetTriple: triple})
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s Go module unavailable SIMD bank %s: %v", triple, row, err)
+				}
+			}()
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ctx.goarch = "386"
+			before := output.Len()
+			ins := file.Funcs[0].Instrs[1]
+			if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != before {
+				t.Fatalf("unavailable mode32 SIMD bank emitted IR: %s %v", row, err)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_shift_native_count.go b/amd64_packed_shift_native_count.go
new file mode 100644
index 000000000..d6188aee7
--- /dev/null
+++ b/amd64_packed_shift_native_count.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import "fmt"
+
+func x86PackedShiftHasNativeCount(form x86PackedShiftForm) bool {
+	return form.legacy && !form.mmx && form.memory == form.count
+}
+
+// Preserve the original SSE2 m128 operation, including its complete native
+// read and fault behavior. Substituting MOVDQA would impose its alignment
+// contract on a different instruction. The tied data input, vector output
+// and memory clobber keep the original operation observable without granting
+// the source address any permission or claiming an alignment guarantee.
+func (c *amd64Ctx) emitX86PackedShiftNativeCount(form x86PackedShiftForm, source Operand, data string) (string, error) {
+	if !x86PackedShiftHasNativeCount(form) || form.byteWidth != 16 || form.countMode != x86PackedShiftUniform {
+		return "", fmt.Errorf("expected legacy SSE m128 packed count form")
+	}
+	name := "psrl"
+	if form.left {
+		name = "psll"
+	} else if form.arithmetic {
+		name = "psra"
+	}
+	switch form.laneBits {
+	case 16:
+		name += "w"
+	case 32:
+		name += "d"
+	case 64:
+		name += "q"
+	default:
+		return "", fmt.Errorf("unsupported legacy packed count lane width %d", form.laneBits)
+	}
+	return c.emitPackedBinaryNativeMemory(source, form.laneBits, data, name)
+}
diff --git a/amd64_packed_shift_native_count_linux_test.go b/amd64_packed_shift_native_count_linux_test.go
new file mode 100644
index 000000000..6eef222c6
--- /dev/null
+++ b/amd64_packed_shift_native_count_linux_test.go
@@ -0,0 +1,46 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func x86PackedShiftBuildOriginalCountObserver(t *testing.T, compiler []string) string {
+	t.Helper()
+	const main = `
+#include <stdlib.h>
+int main(int argc,char **argv) {
+ if(argc!=2) return 97;
+ int kernel=atoi(argv[1]);
+ if(kernel<0 || kernel>=6) return 98;
+ _Alignas(16) uint8_t storage[96];
+ for(int i=0;i<96;i++) storage[i]=(uint8_t)(i*31+7);
+ const uint8_t *count=storage+1;
+ if((uintptr_t)count%16!=1) return 99;
+ int status=observe_count(originals[kernel],kernel,0,0,count,0);
+ if(WIFEXITED(status) && WEXITSTATUS(status)==0)
+  printf("COUNT_NATIVE_STATUS kernel=%d mod16=%llu wait=%d outcome=normal\n",kernel,(unsigned long long)((uintptr_t)count%16),status);
+ else if(WIFSIGNALED(status) && WTERMSIG(status)==SIGSEGV)
+  printf("COUNT_NATIVE_STATUS kernel=%d mod16=%llu wait=%d outcome=fault\n",kernel,(unsigned long long)((uintptr_t)count%16),status);
+ else { fprintf(stderr,"original count status=%x\n",status); return 100; }
+ return 0;
+}
+`
+	dir := t.TempDir()
+	input, executable := filepath.Join(dir, "original.c"), filepath.Join(dir, "original-count-observer")
+	if err := os.WriteFile(input, []byte(x86PackedShiftLegacyCountCHeader+x86PackedShiftOriginalCountC()+x86PackedShiftCountCChecks+main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	arguments := append(append([]string(nil), compiler[1:]...), "-O2", input, "-o", executable)
+	ctx, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, compiler[0], arguments...))
+	cancel()
+	if err != nil {
+		t.Fatalf("original opcode status observer: %v\n%s", err, output)
+	}
+	return executable
+}
diff --git a/amd64_packed_shift_native_count_runtime_test.go b/amd64_packed_shift_native_count_runtime_test.go
new file mode 100644
index 000000000..900588393
--- /dev/null
+++ b/amd64_packed_shift_native_count_runtime_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedShiftLegacyNativeStatusSemantics(t *testing.T) {
+	var prefix []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		if !rosettaAvailable() {
+			t.Fatal("Darwin x86 diagnostic transport required")
+		}
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	} else if runtime.GOARCH != "amd64" || runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
+		t.Skip("required Linux original/LLVM native-count counterpart supplies this execution axis")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	assembly, sigs := x86PackedShiftLegacyMemoryAssembly()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := x86PackedShiftLegacyCountCHeader + x86PackedShiftLegacyCountDeclarations() +
+		x86PackedShiftOriginalCountC() + x86PackedShiftCountCChecks + x86PackedShiftLegacyNativeCountCMain
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "legacy_count_status", triple, ir, driver, prefix)
+	t.Logf("6 original-opcode/LLVM kernels ×48 numerical inputs, 90 unaligned status comparisons, 6 full128 guard-page fault pairs; transport=%v", prefix)
+}
+
+func x86PackedShiftLegacyCountDeclarations() string {
+	var source strings.Builder
+	for i := range x86LegacyShiftMemoryOpcodes {
+		fmt.Fprintf(&source, "extern void legacycount%d(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", i)
+	}
+	source.WriteString("static legacy_fn kernels[]={legacycount0,legacycount1,legacycount2,legacycount3,legacycount4,legacycount5};\n")
+	return source.String()
+}
+
+func x86PackedShiftLegacyMemoryAssembly() (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for i, operation := range x86LegacyShiftMemoryOpcodes {
+		name := fmt.Sprintf("legacycount%d", i)
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-32
+MOVQ out+0(FP),AX
+MOVQ data+8(FP),BX
+MOVQ count+16(FP),CX
+MOVQ seed+24(FP),DX
+MOVOU (BX),X0
+CMPQ DX,$0
+JE carry
+CMPQ DX,$1
+JE overflow
+MOVQ $1,DX
+CMPQ DX,$0
+JMP shifted
+carry:
+MOVQ $-1,DX
+ADDQ $1,DX
+JMP shifted
+overflow:
+MOVQ $0x7fffffffffffffff,DX
+ADDQ $1,DX
+shifted:
+%s (CX),X0
+MOVOU X0,(AX)
+SETCS 16(AX)
+SETOS 17(AX)
+SETEQ 18(AX)
+SETMI 19(AX)
+SETPS 20(AX)
+RET
+`, name, operation.name)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+	}
+	return source.String(), sigs
+}
+
+const x86PackedShiftLegacyCountCHeader = `
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <signal.h>
+typedef void (*legacy_fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+`
+
+// This independent reference executes the original six physical opcodes. The
+// Go object oracle binds each corresponding mnemonic to its original bytes;
+// neither this reference nor the math oracle substitutes a different load.
+func x86PackedShiftOriginalCountC() string {
+	var source strings.Builder
+	for i, mnemonic := range []string{"psllw", "pslld", "psllq", "psrlw", "psrld", "psrlq"} {
+		fmt.Fprintf(&source, `
+static void original%d(uint8_t *out,const uint8_t *data,const uint8_t *count,uint64_t seed) {
+ __asm__ volatile(
+  "movdqu (%%[data]),%%%%xmm0\n\t"
+  "cmpq $0,%%[seed]\n\tje 1f\n\t"
+  "cmpq $1,%%[seed]\n\tje 2f\n\t"
+  "movq $1,%%%%rax\n\tcmpq $0,%%%%rax\n\tjmp 3f\n\t"
+  "1: movq $-1,%%%%rax\n\taddq $1,%%%%rax\n\tjmp 3f\n\t"
+  "2: movq $0x7fffffffffffffff,%%%%rax\n\taddq $1,%%%%rax\n\t"
+  "3: %s (%%[count]),%%%%xmm0\n\t"
+  "movdqu %%%%xmm0,(%%[out])\n\t"
+  "setb 16(%%[out])\n\tseto 17(%%[out])\n\tsete 18(%%[out])\n\t"
+  "sets 19(%%[out])\n\tsetp 20(%%[out])\n\t"
+  : : [out] "r"(out),[data] "r"(data),[count] "r"(count),[seed] "r"(seed)
+  : "rax","xmm0","cc","memory");
+}
+`, i, mnemonic)
+	}
+	source.WriteString("static legacy_fn originals[]={original0,original1,original2,original3,original4,original5};\n")
+	return source.String()
+}
+
+// Status observation is independent of the translated implementation. A
+// successful child must still satisfy all numerical, flag and canary checks.
+const x86PackedShiftCountCChecks = `
+static uint64_t read_le(const uint8_t *p,int bytes) {
+ uint64_t value=0;
+ for(int i=0;i<bytes;i++) value|=(uint64_t)p[i]<<(8*i);
+ return value;
+}
+static int count_memory_fault(int status) {
+ if(!WIFSIGNALED(status)) return 0;
+ if(WTERMSIG(status)==SIGSEGV) return 1;
+#if defined(__APPLE__)
+ /* Darwin diagnostic only: require the same original opcode's SIGBUS. */
+ if(WTERMSIG(status)==SIGBUS) return 1;
+#endif
+ return 0;
+}
+static int check_count(legacy_fn fn,int kernel,int round,int seed,const uint8_t *count) {
+ const uint8_t flags[3][5]={{1,0,1,0,1},{0,1,0,1,1},{0,0,0,0,0}};
+ uint8_t data[18],out[23],beforeData[18],beforeCount[32];
+ for(int i=0;i<18;i++) data[i]=(uint8_t)(i*71+round*97+13);
+ memcpy(beforeData,data,18);
+ memcpy(beforeCount,count,32);
+ memset(out,0xc3,23);
+ fn(out+1,data+1,count,(uint64_t)seed);
+ if(out[0]!=0xc3 || out[22]!=0xc3 || memcmp(data,beforeData,18) ||
+    memcmp(count,beforeCount,32) || memcmp(out+17,flags[seed],5)) return 10+kernel;
+ int bytes=(int[]){2,4,8,2,4,8}[kernel];
+ uint64_t shift=read_le(count,8);
+ for(int i=0;i<16;i+=bytes) {
+  uint64_t value=read_le(data+i+1,bytes),want=0;
+  if(shift<(uint64_t)(bytes*8)) want=kernel<3?value<<shift:value>>shift;
+  for(int b=0;b<bytes;b++) if(out[i+b+1]!=(uint8_t)(want>>(8*b))) return 20+kernel;
+ }
+ return 0;
+}
+static int observe_count(legacy_fn fn,int kernel,int round,int seed,const uint8_t *count,int guard) {
+ pid_t child=fork();
+ if(child<0) return -1;
+ if(!child) {
+  struct rlimit no_core={0,0};
+  if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+
+  if(guard) {
+   uint8_t data[18],out[23];
+   memset(data,13,18); memset(out,0xc3,23);
+   fn(out+1,data+1,count,0);
+   _exit(90);
+  }
+  _exit(check_count(fn,kernel,round,seed,count));
+ }
+ int status=0;
+ if(waitpid(child,&status,0)!=child) return -1;
+ return status;
+}
+`
+
+const x86PackedShiftLegacyNativeCountCMain = `
+int main(void) {
+ const uint64_t counts[]={0,1,7,15,16,17,31,32,33,63,64,65,255,256,UINT64_C(1)<<32,UINT64_MAX};
+ for(int kernel=0;kernel<6;kernel++) {
+  for(int round=0;round<16;round++) for(int seed=0;seed<3;seed++) {
+   _Alignas(16) uint8_t count[32];
+   for(int i=0;i<32;i++) count[i]=(uint8_t)(i*31+7);
+   for(int i=0;i<8;i++) count[i]=(uint8_t)(counts[round]>>(8*i));
+   int original=check_count(originals[kernel],kernel,round,seed,count);
+   int translated=check_count(kernels[kernel],kernel,round,seed,count);
+   if(original || translated) return 10+kernel;
+  }
+  for(int offset=1;offset<16;offset++) {
+   _Alignas(16) uint8_t count[48];
+   memset(count,0x79,sizeof(count));
+   memset(count+offset,0,8); count[offset]=1;
+   int original=observe_count(originals[kernel],kernel,offset,offset%3,count+offset,0);
+   int translated=observe_count(kernels[kernel],kernel,offset,offset%3,count+offset,0);
+   int normal=WIFEXITED(original) && WEXITSTATUS(original)==0;
+   int fault=count_memory_fault(original);
+   if(original<0 || translated<0 || (!normal && !fault) || original!=translated) {
+    fprintf(stderr,"legacy kernel=%d mod16=%d original=%x translated=%x\n",kernel,offset,original,translated);
+    return 30+kernel;
+   }
+  }
+ }
+ size_t page=(size_t)sysconf(_SC_PAGESIZE);
+ uint8_t *area=mmap(0,page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(area==MAP_FAILED || mprotect(area+page,page,PROT_NONE)) return 40;
+ memset(area,7,page);
+ for(int kernel=0;kernel<6;kernel++) {
+  int original=observe_count(originals[kernel],kernel,0,0,area+page-8,1);
+  int translated=observe_count(kernels[kernel],kernel,0,0,area+page-8,1);
+  if(original<0 || translated<0 || !count_memory_fault(original) || original!=translated) {
+   fprintf(stderr,"legacy full128 kernel=%d original=%x translated=%x\n",kernel,original,translated);
+   return 50+kernel;
+  }
+ }
+ if(munmap(area,page*2)) return 60;
+ return 0;
+}
+`
diff --git a/amd64_packed_shift_raw_format_test.go b/amd64_packed_shift_raw_format_test.go
new file mode 100644
index 000000000..413eda71c
--- /dev/null
+++ b/amd64_packed_shift_raw_format_test.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Preserve original bytes, return and literal DATA. These isolated operand
+// objects do not supply native entry inputs, caller memory or a return proof.
+func x86PackedShiftRawFormatObject(t *testing.T, file *File, options Options) string {
+	t.Helper()
+	if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original raw shift acquired unbound native entry/mask/return inputs", err)
+	}
+	normalized, err := normalizeX86RawFile(file, options.Goarch)
+	if err != nil {
+		t.Fatal("original raw shift formats could not be decoded", err)
+	}
+	return x86InstructionFormatObjectUnit(t, normalized, options.Sigs, options.Goarch, options.TargetTriple, 0,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			return c.lowerX86PackedShift(ins.Op, ins)
+		})
+}
diff --git a/amd64_packed_shift_result.go b/amd64_packed_shift_result.go
new file mode 100644
index 000000000..9e65f704f
--- /dev/null
+++ b/amd64_packed_shift_result.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+// One output byte can span two input bytes for an immediate bit shift. With an
+// initialized but unknown count, it instead requires the union of every input
+// bit that could reach it. Oversized logical counts contribute only zeros.
+// The masks describe numerical dependence, never the native memory envelope.
+func x86PackedShiftByteInputs(form x86PackedShiftForm, output int) (data, count uint64) {
+	laneBytes := form.laneBits / 8
+	if form.countMode == x86PackedShiftBytes {
+		laneBytes = 16
+	}
+	lane, at := output/laneBytes*laneBytes, output%laneBytes
+	first, last := at*8, at*8+7
+	if form.countOperand.Kind == OpImm {
+		shift := int(uint8(form.countOperand.Imm))
+		if form.countMode == x86PackedShiftBytes {
+			shift *= 8
+		}
+		if form.left {
+			first, last = first-shift, last-shift
+		} else {
+			first, last = first+shift, last+shift
+		}
+	} else {
+		if form.left {
+			first = 0
+		} else {
+			last = laneBytes*8 - 1
+		}
+		count = 255 // The upper qword of a uniform register count is ignored.
+		if form.countMode == x86PackedShiftPerLane {
+			count = x86CallerVectorByteMask(int64(laneBytes)) << uint(lane)
+		}
+	}
+	if first < 0 {
+		first = 0
+	}
+	if form.arithmetic && first >= laneBytes*8 {
+		first = laneBytes*8 - 1 // Every shifted-out bit reads the sign bit.
+	}
+	if last >= laneBytes*8 {
+		last = laneBytes*8 - 1
+	}
+	if first <= last {
+		data = x86CallerVectorByteMask(int64(last/8-first/8+1)) << uint(lane+first/8)
+	}
+	return data, count
+}
+
+func x86PackedShiftDefinedBytes(form x86PackedShiftForm, data, counts, old uint64) uint64 {
+	var known uint64
+	for output := 0; output < form.byteWidth; output++ {
+		dataMask, countMask := x86PackedShiftByteInputs(form, output)
+		if data&dataMask == dataMask && counts&countMask == countMask {
+			known |= uint64(1) << uint(output)
+		}
+	}
+	// A defined mask is not a known active mask. Every inactive merging byte
+	// still needs its old destination; inactive zeroing bytes are constants.
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	return known
+}
+
+func x86ResultPackedShiftStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultPackedShiftStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultPackedShiftStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	literal := x86RawByteShiftLiteralForm(ins, arch)
+	if err != nil || form.mmx || !literal && (!x86ResultNamedPredicateInstruction(ins) ||
+		ins.x86PackedShiftEncoding != x86RawPackedShiftAbsent || ins.x86PackedShiftW) {
+		return false, true // Raw identity and physical MMX have separate owners.
+	}
+	// This is the existing independent same-source DATA role, not ordinary
+	// native continuation. Its full tuple still needs loweredStaticReads;
+	// leaving the raw origin intact prevents an incoming-pointer fallback.
+	var pending x86ResultShiftBits
+	if nativeRead && ins.Args[form.data].Kind == OpReg {
+		input, _ := amd64VectorRegisterIndex(ins.Args[form.data].Reg, form.byteWidth)
+		destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+		pending = x86ResultShiftBitSource(ins, form, state.vectorBytes(input), destination)
+	}
+	if !x86ResultPackedShiftInputs(ins, form, state, owned, arch, nativeRead) {
+		return false, true
+	}
+	if nativeRead {
+		// Record only at the original named entry. The raw consumer shares
+		// byte effects through a local projection, not this named-only fact.
+		state.shiftBits = pending
+	}
+	return true, true
+}
+
+func x86ResultPackedShiftInputs(ins Instr, form x86PackedShiftForm, state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	if form.memory >= 0 {
+		// Even a saturating count or zero mask cannot create memory authority.
+		// Legacy m128 counts additionally need original native backing. Only
+		// lowering's ephemeral same-file DATA directory can provide an SB
+		// input here; logical FP/AUTO storage still cannot stand in for it.
+		memory := ins.Args[form.memory]
+		if _, static := x86StaticSBReadAddress(memory, arch); form.legacy && !static &&
+			(!nativeRead || !x86OrdinaryNativeMemoryOperand(memory, arch)) {
+			return false
+		}
+		if !x86ResultReadWithNativeContinuation(ins, memory, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false
+		}
+	}
+	bytes := func(index int) uint64 {
+		if index == form.memory {
+			return x86CallerVectorByteMask(int64(form.byteWidth))
+		}
+		operand := ins.Args[index]
+		register, _ := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+		return state.vectorBytes(register)
+	}
+	data, counts := bytes(form.data), ^uint64(0)
+	if form.countOperand.Kind != OpImm {
+		counts = bytes(form.count)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth,
+		x86PackedShiftDefinedBytes(form, data, counts, state.vectorBytes(destination)), form.legacy)
+	return true
+}
diff --git a/amd64_packed_shift_result_grammar_test.go b/amd64_packed_shift_result_grammar_test.go
new file mode 100644
index 000000000..b5e5fae9a
--- /dev/null
+++ b/amd64_packed_shift_result_grammar_test.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedShiftResultIndependentGoGrammarAxes(t *testing.T) {
+	inventory := make(map[string]bool)
+	for _, row := range x86PackedShiftResultRows() {
+		inventory[strings.Fields(row.row)[0]] = true
+	}
+	var names []string
+	for name := range inventory {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	if !reflect.DeepEqual(names, x86PackedShiftNames()) {
+		t.Fatal("independent whole-family denominator changed", names)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var rows []string
+			for _, name := range names {
+				vector := strings.HasPrefix(name, "V")
+				perLane := strings.Contains(name, "LLV") || strings.Contains(name, "RLV")
+				byteShift := strings.HasSuffix(name, "DQ") || strings.HasSuffix(name, "O")
+				banks := []string{"X"}
+				if vector {
+					banks = []string{"X", "Y", "Z"}
+				}
+				for _, bank := range banks {
+					if !perLane {
+						first, last := -128, 127
+						if vector {
+							last = 255
+						}
+						if bank == "Z" {
+							first = 0
+						}
+						for immediate := first; immediate <= last; immediate++ {
+							row := fmt.Sprintf("%s $%d,%s1", name, immediate, bank)
+							if vector {
+								row += "," + bank + "2"
+							}
+							rows = append(rows, row)
+						}
+					}
+					limit := 32
+					if arch == "386" && bank == "Z" {
+						// cmd/asm accepts high named X/Y banks in mode32, but
+						// rejects high Z. Neither supplies a physical register.
+						limit = 8
+					}
+					if !vector {
+						limit = 16
+						if arch == "386" {
+							limit = 8
+						}
+					}
+					for index := 0; index < limit; index++ {
+						data := fmt.Sprintf("%s%d", bank, index)
+						if !vector {
+							rows = append(rows, name+" $7,"+data)
+							if !byteShift {
+								rows = append(rows, name+" "+data+",X1")
+							}
+							continue
+						}
+						if !perLane {
+							rows = append(rows, name+" $7,"+data+","+bank+"2", name+" $7,"+bank+"1,"+data)
+						}
+						if !byteShift {
+							countBank := "X"
+							if perLane {
+								countBank = bank
+							}
+							rows = append(rows, fmt.Sprintf("%s %s%d,%s1,%s2", name, countBank, index, bank, bank),
+								name+" "+countBank+"0,"+data+","+bank+"2", name+" "+countBank+"0,"+bank+"1,"+data)
+						}
+					}
+				}
+			}
+			if arch == "386" {
+				rows = append(rows, "PSRLQ $4294967297,X1", "PSRLDQ $-4294967297,X1", "VPSRLQ $4294967551,X1,X2", "VPSRLDQ $4294967551,X1,X2")
+			}
+			source := "TEXT f(SB),4,$0-0\n" + strings.Join(rows, "\n") + "\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, row := range rows {
+				ins := file.Funcs[0].Instrs[index+1]
+				originalCount := ins.Args[0]
+				context := false
+				if arch == "386" {
+					for _, arg := range ins.Args {
+						reg, valid := amd64VectorRegisterIndex(arg.Reg, amd64VectorByteWidth(arg.Reg))
+						context = context || valid && reg >= 8
+					}
+				}
+				form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+				if !known || context && !errors.Is(err, ErrProbeNeedsContext) || !context && err != nil {
+					t.Fatal(row, err)
+				}
+				if !context && ins.Args[0].Kind == OpImm && uint8(form.countOperand.Imm) != uint8(ins.Args[0].Imm) {
+					t.Fatal("classified immediate changed encoded count", row)
+				}
+				if !reflect.DeepEqual(originalCount, ins.Args[0]) {
+					t.Fatal("classification rewrote the retained source", row)
+				}
+			}
+			t.Logf("%d actual Go forms, with physical mode32 context kept separate", len(rows))
+		})
+	}
+}
+
+func TestX86PackedShiftResultMode32ClassifiedImmediateObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source := "TEXT ·view(SB),4,$0-4\nMOVL $7,AX\n"
+	for dword := 0; dword < 4; dword++ {
+		source += fmt.Sprintf("PINSRD $%d,AX,X1\n", dword)
+	}
+	source += "PSRLQ $4294967297,X1\nPSRLDQ $-4294967297,X1\nVPSRLQ $4294967551,X1,X2\nVPSRLDQ $4294967551,X2,X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal(target.triple, api, err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "classified-shift.ll", "classified-shift.o", ir)
+		}
+	}
+}
+
+func TestX86PackedShiftResultMode32HighZGoRejections(t *testing.T) {
+	seen := make(map[string]bool)
+	for _, candidate := range x86PackedShiftResultRows() {
+		name := strings.Fields(candidate.row)[0]
+		if !strings.HasPrefix(name, "V") || seen[name] {
+			continue
+		}
+		seen[name] = true
+		for index := 8; index < 32; index++ {
+			count := "$7"
+			if strings.Contains(name, "LLV") || strings.Contains(name, "RLV") {
+				count = "Z0"
+			}
+			row := fmt.Sprintf("%s %s,Z%d,Z2", name, count, index)
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86PackedShiftProperties(ins.Op, ins, "386"); !known || err == nil {
+				t.Fatal("mode32 physical Z register admitted", row)
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftResultUnresolvedFormsCannotEmit(t *testing.T) {
+	for _, row := range []string{"PSLLW $0,X1", "PSRLDQ $0,X1", "VPSRLQ $0,X1,X2", "VPSRLDQ $0,X1,X2"} {
+		for _, mutation := range []string{"floating", "unresolved"} {
+			ins := x86ScalarLaneInstruction(t, row)
+			if mutation == "floating" {
+				ins.Args[0].ImmIsFloat = true
+			} else {
+				ins.Args[0].ImmRaw = "missing"
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			before := output.Len()
+			if _, _, err := ctx.lowerX86PackedShift(ins.Op, ins); err == nil || output.Len() != before {
+				t.Fatal("noninteger immediate emitted IR", row, mutation, err)
+			}
+		}
+	}
+	for _, mutation := range []string{"displacement", "index"} {
+		ins := x86ScalarLaneInstruction(t, "VPSRLQ (AX),X1,X2")
+		if mutation == "displacement" {
+			ins.Args[0].Mem.OffRaw = "missing"
+		} else {
+			ins.Args[0].Mem.IndexExt = "unknown"
+		}
+		if _, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64"); !known || err == nil {
+			t.Fatal("unresolved memory accepted", mutation)
+		}
+	}
+}
diff --git a/amd64_packed_shift_result_runtime_test.go b/amd64_packed_shift_result_runtime_test.go
new file mode 100644
index 000000000..1fe4f3119
--- /dev/null
+++ b/amd64_packed_shift_result_runtime_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedShiftPartialResults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, native, cases strings.Builder
+	for index, row := range x86PackedShiftResultRows() {
+		name := fmt.Sprint("partialShift", index)
+		fmt.Fprintf(&declarations, "func %s(data,count uint32) uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVL data+0(FP),AX\nMOVL count+4(FP),BX\nMOVL $0,CX\n", name)
+		for dword := 0; dword < 4; dword++ {
+			if row.data&(15<<uint(dword*4)) != 0 {
+				fmt.Fprintf(&source, "PINSRD $%d,AX,X1\n", dword)
+			}
+			if row.count&(15<<uint(dword*4)) != 0 {
+				count := "CX"
+				if dword == 0 {
+					count = "BX"
+				}
+				fmt.Fprintf(&source, "PINSRD $%d,%s,X0\n", dword, count)
+			}
+		}
+		result := "X1"
+		if strings.HasPrefix(row.row, "V") {
+			result = "X2"
+		}
+		fmt.Fprintf(&source, "%s\nPEXTRD $%d,%s,AX\nMOVL AX,ret+8(FP)\nRET\n", row.row, row.lane, result)
+		fmt.Fprintf(&native, "extern uint32_t %s(uint32_t,uint32_t);\n", name)
+		original := "0"
+		if !strings.HasPrefix(row.row, "V") {
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row.row+"\nRET\n")
+			if len(code) < 2 || code[len(code)-1] != 0xc3 {
+				t.Fatal("missing original opcode/RET", row.row, code)
+			}
+			var encoded []string
+			for _, value := range code[:len(code)-1] {
+				encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+			}
+			original = fmt.Sprint("originalShift", index)
+			assembly := "movdqu (%0), %%xmm0; movdqu (%1), %%xmm1; .byte " + strings.Join(encoded, ",") + "; movdqu %%xmm1, (%2)"
+			fmt.Fprintf(&native, "static void %s(const uint8_t *counts,const uint8_t *data,uint8_t *out) {\n    __asm__ volatile(%q::\"r\"(counts),\"r\"(data),\"r\"(out):\"xmm0\",\"xmm1\",\"memory\");\n}\n", original, assembly)
+		}
+		op := strings.Fields(row.row)[0]
+		bits := 32
+		if strings.HasSuffix(op, "W") {
+			bits = 16
+		}
+		if strings.HasSuffix(op, "Q") {
+			bits = 64
+		}
+		byteShift := strings.HasSuffix(op, "DQ") || strings.HasSuffix(op, "O")
+		if byteShift {
+			bits = 128
+		}
+		immediate := -1
+		if fields := strings.Split(strings.Fields(row.row)[1], ","); strings.HasPrefix(fields[0], "$") {
+			var err error
+			immediate, err = strconv.Atoi(strings.TrimPrefix(fields[0], "$"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			immediate = int(uint8(immediate))
+			if byteShift {
+				immediate *= 8
+			}
+		}
+		fmt.Fprintf(&cases, "{%s,%s,%q,%d,%d,%d,%d,%d,%d,%d},\n", name, original, row.row, bits, immediate,
+			x86ShiftBoolean(strings.Contains(op, "SLL")), x86ShiftBoolean(strings.Contains(op, "LLV") || strings.Contains(op, "RLV")), row.data, row.count, row.lane)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + native.String() + `
+struct Case {
+    uint32_t (*translated)(uint32_t,uint32_t);
+    void (*original)(const uint8_t*,const uint8_t*,uint8_t*);
+    const char *row;
+    unsigned bits;
+    int immediate,left,perlane;
+    uint16_t dataKnown,countKnown;
+    unsigned lane;
+};
+static const struct Case cases[]={
+` + cases.String() + `};
+static uint64_t read_shift_bytes(const uint8_t *bytes,unsigned width) {
+    uint64_t value=0;
+    for(unsigned i=0;i<width;i++) value|=(uint64_t)bytes[i]<<(i*8);
+    return value;
+}
+int main(void) {
+    const uint32_t inputs[]={0,1,UINT32_MAX,0x80000000,0x01234567,0x89abcdef,0x55555555,0xaaaaaaaa};
+    const uint32_t counts[]={0,1,7,8,15,16,31,32,63,64,255,UINT32_MAX};
+    for(unsigned c=0;c<sizeof(cases)/sizeof(cases[0]);c++)
+    for(unsigned sample=0;sample<sizeof(inputs)/sizeof(inputs[0]);sample++)
+    for(unsigned n=0;n<sizeof(counts)/sizeof(counts[0]);n++) {
+        const struct Case *test=cases+c;
+        uint8_t data[16],count[16],want[16]={0},original[16];
+        for(unsigned i=0;i<16;i++) {
+            data[i]=(uint8_t)(i*71+sample*13+n);
+            count[i]=(uint8_t)(i*93+sample*57+n);
+            if(test->dataKnown&(1u<<i)) data[i]=(uint8_t)(inputs[sample]>>(i%4*8));
+            if(test->countKnown&(1u<<i)) count[i]=i<4?(uint8_t)(counts[n]>>(i*8)):0;
+        }
+        for(unsigned output=0;output<128;output++) {
+            unsigned base=output/test->bits*test->bits;
+            uint64_t shift=test->immediate>=0?(unsigned)test->immediate:
+                test->perlane?read_shift_bytes(count+base/8,test->bits/8):read_shift_bytes(count,8);
+            if(shift>=test->bits) continue;
+            int from=(int)(output%test->bits)+(test->left?-(int)shift:(int)shift);
+            if(from<0 || from>=(int)test->bits) continue;
+            unsigned input=base+(unsigned)from;
+            want[output/8]|=((data[input/8]>>(input%8))&1)<<(output%8);
+        }
+        uint32_t expected=(uint32_t)read_shift_bytes(want+test->lane*4,4);
+        uint32_t got=test->translated(inputs[sample],counts[n]);
+        if(got!=expected) {
+            fprintf(stderr,"%s sample=%u count=%u LLVM=%x want=%x\n",test->row,sample,counts[n],got,expected);
+            return 1;
+        }
+        if(test->original) {
+            test->original(count,data,original);
+            if(read_shift_bytes(original+test->lane*4,4)!=expected) {
+                fprintf(stderr,"%s original Go selected output differs\n",test->row);
+                return 2;
+            }
+        }
+    }
+    return 0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "shift-partial-result", triple, text, oracle, prefix)
+		})
+	}
+	t.Log("44 partial-state scalar results x 96 inputs; original Go legacy opcodes plus independent bit oracle; no native AVX512 claim")
+}
diff --git a/amd64_packed_shift_result_test.go b/amd64_packed_shift_result_test.go
new file mode 100644
index 000000000..24f65d243
--- /dev/null
+++ b/amd64_packed_shift_result_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This inventory is independent of the production opcode maps. Initialized
+// dwords are deliberately narrower than X wherever the selected output permits.
+type x86PackedShiftResultCase struct {
+	row   string
+	data  uint16
+	count uint16
+	lane  int
+}
+
+func x86PackedShiftResultRows() []x86PackedShiftResultCase {
+	var rows []x86PackedShiftResultCase
+	add := func(row string, data, count uint16, lane int) {
+		rows = append(rows, x86PackedShiftResultCase{row, data, count, lane})
+	}
+	for _, op := range []string{"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ"} {
+		add(op+" $7,X1", 0xffff, 0, 0)
+		add(op+" X0,X1", 0xffff, 0x00ff, 0)
+	}
+	for _, op := range []string{"PSLLO", "PSLLDQ"} {
+		add(op+" $12,X1", 0x000f, 0, 3)
+	}
+	for _, op := range []string{"PSRLO", "PSRLDQ"} {
+		add(op+" $4,X1", 0x00f0, 0, 0)
+	}
+	for _, op := range []string{"VPSLLW", "VPSLLD", "VPSLLQ", "VPSRLW", "VPSRLD", "VPSRLQ"} {
+		add(op+" $7,X1,X2", 0xffff, 0, 0)
+		add(op+" X0,X1,X2", 0xffff, 0x00ff, 0)
+	}
+	for _, op := range []string{"VPSLLVW", "VPSLLVD", "VPSLLVQ", "VPSRLVW", "VPSRLVD", "VPSRLVQ"} {
+		add(op+" X0,X1,X2", 0xffff, 0xffff, 0)
+	}
+	add("VPSLLDQ $12,X1,X2", 0x000f, 0, 3)
+	add("VPSRLDQ $4,X1,X2", 0x00f0, 0, 0)
+	add("PSRLQ $32,X1", 0x00f0, 0, 0)
+	add("PSLLQ $32,X1", 0x000f, 0, 1)
+	add("PSLLQ X0,X1", 0x000f, 0x00ff, 0)
+	add("PSRLQ X0,X1", 0x00f0, 0x00ff, 1)
+	add("VPSLLVQ X0,X1,X2", 0x000f, 0x00ff, 0)
+	add("VPSRLVQ X0,X1,X2", 0x00f0, 0x00ff, 1)
+	add("PSRLDQ $16,X1", 0, 0, 0)
+	add("PSLLQ $64,X1", 0, 0, 0)
+	return rows
+}
+
+func TestX86PackedShiftResultThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	for index, row := range x86PackedShiftResultRows() {
+		name := fmt.Sprint("shiftResult", index)
+		fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n%s\n", name,
+			x86PackedShiftResultBody(row.row, row.data, row.count, row.lane, "ret+0(FP)"))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "shift-result.ll", "shift-result.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftResultMemoryAndMaskBoundaries(t *testing.T) {
+	for _, row := range []string{
+		"PSRLQ (AX),X1", "PSRLQ a+0(FP),X1", "PSRLQ local-16(SP),X1",
+		"VPSRLQ $255,(AX),X2", "VPSRLDQ $16,·data(SB),X2",
+		"VPSRLVQ (AX),X1,X2", "VPSRLQ.BCST $64,(AX),X2",
+		"PSRLQ $7,M1",
+	} {
+		ins := x86ScalarLaneInstruction(t, row)
+		state := x86ResultState{fp: make([]bool, 16), auto: make([]bool, 16)}
+		for i := range state.fp {
+			state.fp[i], state.auto[i] = true, true
+		}
+		for i := range state.xmm {
+			state.xmm[i] = 0xffff
+		}
+		owned := make([]bool, 16)
+		for i := range owned {
+			owned[i] = true
+		}
+		if x86ResultTransfer(ins, &state, owned, 16, "amd64") || len(ins.x86CallerMemory) != 0 {
+			t.Fatal("numerical effect borrowed native/MMX permission", row)
+		}
+	}
+	for _, row := range []string{"VPSRLQ $7,X1,K3,X2", "VPSRLQ.Z $7,X1,K3,X2"} {
+		ins := x86ScalarLaneInstruction(t, row)
+		for _, initialized := range []bool{false, true} {
+			state := x86ResultState{}
+			state.xmm[1], state.xmm[2], state.masks[3] = 0xffff, 0x5a5a, initialized
+			accepted := x86ResultTransfer(ins, &state, nil, 0, "amd64")
+			if accepted != initialized {
+				t.Fatal("uninitialized mask was ignored", row)
+			}
+			if initialized {
+				want := uint16(0x5a5a)
+				if strings.Contains(row, ".Z") {
+					want = 0xffff
+				}
+				if state.xmm[2] != want {
+					t.Fatal("merge/zero effect", row, state.xmm[2], want)
+				}
+			}
+		}
+	}
+	for _, body := range []string{
+		"MOVL $7,AX\nPINSRD $0,AX,X1\nPSRLQ $1,X1\nPEXTRD $0,X1,AX\n",
+		"MOVL $7,AX\nPINSRD $1,AX,X1\nPSRLDQ $3,X1\nPEXTRD $0,X1,AX\n",
+		"MOVL $7,AX\nPINSRD $0,AX,X0\nPINSRD $0,AX,X1\nPSLLQ X0,X1\nPEXTRD $0,X1,AX\n",
+	} {
+		_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint32", body+"MOVL AX,ret0+0(FP)\nRET")
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+			if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("one missing dependency acquired a result", err)
+			}
+		}
+	}
+}
+
+func TestX86PackedShiftResultOwnedMemoryStillNeedsFullNativeTuple(t *testing.T) {
+	for _, fixture := range []struct {
+		row   string
+		width int
+	}{
+		{"VPSRLQ a+0(FP),X1,X2", 16},
+		{"VPSRLVQ a+0(FP),X1,X2", 16},
+		{"VPSRLVQ.BCST a+0(FP),X1,X2", 8},
+		{"VPSRLQ $64,a+0(FP),X2", 16},
+		{"VPSRLQ.BCST $64,a+0(FP),X2", 8},
+		{"VPSRLDQ $16,a+0(FP),X2", 16},
+	} {
+		for _, auto := range []bool{false, true} {
+			row := fixture.row
+			if auto {
+				row = strings.ReplaceAll(row, "a+0(FP)", "local-16(SP)")
+			}
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$16-16\n"+row+"\nRET\n", "", true)
+			ins := x86ScalarLaneInstruction(t, row)
+			for missing := -1; missing < 16; missing++ {
+				state := x86ResultState{fp: make([]bool, 16), auto: make([]bool, 16)}
+				owned := make([]bool, 16)
+				for i := range state.fp {
+					state.fp[i], state.auto[i], owned[i] = i != missing, i != missing, true
+				}
+				state.xmm[1] = 0xffff
+				accepted := x86ResultTransfer(ins, &state, owned, 16, "amd64")
+				want := missing < 0 || missing >= fixture.width
+				if accepted != want || accepted && state.xmm[2] != 0xffff || len(ins.x86CallerMemory) != 0 {
+					t.Fatal("logical tuple/memory authority mismatch", row, missing, accepted, want)
+				}
+			}
+		}
+	}
+}
+
+func x86PackedShiftResultBody(row string, data, count uint16, lane int, result string) string {
+	var body strings.Builder
+	body.WriteString("MOVL $7,AX\n")
+	for register, bytes := range []uint16{count, data} {
+		for dword := 0; dword < 4; dword++ {
+			if bytes&(15<<uint(dword*4)) != 0 {
+				fmt.Fprintf(&body, "PINSRD $%d,AX,X%d\n", dword, register)
+			}
+		}
+	}
+	body.WriteString(row + "\n")
+	destination := "X1"
+	if strings.HasPrefix(row, "V") {
+		destination = "X2"
+	}
+	fmt.Fprintf(&body, "PEXTRD $%d,%s,AX\nMOVL AX,%s\nRET", lane, destination, result)
+	return body.String()
+}
+
+func TestX86PackedShiftResultIndependentWholeSources(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86PackedShiftResultRows() {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				body := x86PackedShiftResultBody(row.row, row.data, row.count, row.lane, "ret0+0(FP)")
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); err != nil {
+						t.Error(err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedShiftResultRejectsNonIntegerImmediate(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{"PSRLQ $0.0,X1", "PSRLDQ $0.0,X1", "VPSRLQ $0.0,X1,X2", "VPSRLDQ $0.0,X1,X2", "PSRLQ $1.5,X1", "VPSRLQ $1.5,X1,X2"} {
+			goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, row)
+			if _, known, err := x86PackedShiftProperties(ins.Op, ins, arch); !known || err == nil {
+				t.Errorf("floating count accepted: %s %s", arch, row)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_shift_runtime_test.go b/amd64_packed_shift_runtime_test.go
new file mode 100644
index 000000000..da499e4f6
--- /dev/null
+++ b/amd64_packed_shift_runtime_test.go
@@ -0,0 +1,390 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86PackedShiftNumericalCase struct {
+	name, row                                                        string
+	width, bits, countMode, immediate, memory, maskMode, destination int
+	left, legacy, broadcast                                          bool
+}
+
+// This oracle registration is derived from the mnemonic spelling, not the
+// production mode/width map. All bits, inactive lanes and upper aliases matter.
+func x86PackedShiftNumericalCases() []x86PackedShiftNumericalCase {
+	var cases []x86PackedShiftNumericalCase
+	for _, op := range x86PackedShiftNames() {
+		legacy := !strings.HasPrefix(op, "V")
+		byteShift := strings.HasSuffix(op, "DQ") || op == "PSLLO" || op == "PSRLO"
+		perLane := strings.Contains(op, "LLV") || strings.Contains(op, "RLV")
+		bits := 32
+		if strings.HasSuffix(op, "W") {
+			bits = 16
+		}
+		if strings.HasSuffix(op, "Q") {
+			bits = 64
+		}
+		if byteShift {
+			bits = 8
+		}
+		widths := []int{16, 32, 64}
+		if legacy {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, memory := range []int{0, 1, 2} {
+				if legacy && byteShift && memory != 0 {
+					continue
+				}
+				if memory == 2 && (legacy || byteShift || bits == 16) {
+					continue
+				}
+				for _, mask := range []int{0, 1, 2} {
+					if mask != 0 && (legacy || byteShift) {
+						continue
+					}
+					counts := []int{-1, 0, 1, bits - 1, bits, bits + 1, 255}
+					if perLane {
+						counts = []int{-1}
+					}
+					if byteShift {
+						counts = []int{0, 1, 15, 16, 17, 255}
+					}
+					for _, immediate := range counts {
+						if legacy && memory != 0 && immediate >= 0 {
+							continue
+						}
+						if legacy && immediate == 255 {
+							continue
+						}
+						if immediate < 0 && memory == 2 && !perLane {
+							continue
+						}
+						for _, destination := range []int{0, 1, 2} {
+							if legacy && destination != 0 {
+								continue
+							}
+							// Boundary immediates need not multiply every mask/alias
+							// combination; dynamic counts cover all boundaries below.
+							if !legacy && !perLane && immediate != 1 && immediate != -1 && (mask != 0 || destination != 2) {
+								continue
+							}
+							name := fmt.Sprintf("shift%d", len(cases))
+							operation := op
+							if memory == 2 {
+								operation += ".BCST"
+							}
+							if mask == 2 {
+								operation += ".Z"
+							}
+							count := "$" + fmt.Sprint(immediate)
+							data := bank + "0"
+							mode := 0
+							if immediate < 0 {
+								count = "X1"
+								if perLane {
+									count, mode = bank+"1", 1
+								}
+								if memory != 0 {
+									count = "(CX)"
+								}
+							} else if memory != 0 {
+								data = "(BX)"
+							}
+							if byteShift {
+								mode = 2
+							}
+							row := operation + " " + count + "," + data
+							if !legacy {
+								if mask != 0 {
+									row += ",K1"
+								}
+								row += fmt.Sprintf(",%s%d", bank, destination)
+							}
+							cases = append(cases, x86PackedShiftNumericalCase{
+								name: name, row: row, width: width, bits: bits, countMode: mode,
+								immediate: immediate, memory: memory, maskMode: mask, destination: destination,
+								left: strings.Contains(op, "SLL"), legacy: legacy, broadcast: memory == 2,
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func x86PackedShiftNumericalAssembly(cases []x86PackedShiftNumericalCase) (string, map[string]FuncSig) {
+	var assembly strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, test := range cases {
+		fmt.Fprintf(&assembly, `TEXT %s(SB),4,$0-40
+MOVQ out+0(FP),AX
+MOVQ data+8(FP),BX
+MOVQ count+16(FP),CX
+MOVQ mask+24(FP),DX
+MOVQ seed+32(FP),SI
+VMOVUPS (BX),Z0
+VMOVUPS (CX),Z1
+VMOVUPS (CX),Z2
+KMOVQ DX,K1
+CMPQ SI,$0
+JE carry
+CMPQ SI,$1
+JE overflow
+MOVQ $1,SI
+CMPQ SI,$0
+JMP shifted
+carry:
+MOVQ $-1,SI
+ADDQ $1,SI
+JMP shifted
+overflow:
+MOVQ $0x7fffffffffffffff,SI
+ADDQ $1,SI
+shifted:
+%s
+VMOVUPS Z%d,(AX)
+SETCS 64(AX)
+SETOS 65(AX)
+SETEQ 66(AX)
+SETMI 67(AX)
+SETPS 68(AX)
+RET
+`, test.name, test.row, test.destination)
+		sigs[test.name] = FuncSig{Name: test.name, Args: []LLVMType{Ptr, Ptr, Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}}}
+	}
+	return assembly.String(), sigs
+}
+
+const x86PackedShiftIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef void (*shift_fn)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint64_t);
+struct shift_case { shift_fn fn; const char *row; int width,bits,mode,immediate,memory,mask,destination,left,legacy,broadcast; };
+static uint64_t read_le(const uint8_t *p,int bytes) {
+ uint64_t value=0;
+ for(int i=0;i<bytes;++i) value|=(uint64_t)p[i]<<(8*i);
+ return value;
+}
+static void expected(uint8_t *out,const uint8_t *a,const uint8_t *counts,uint64_t mask,const struct shift_case *c) {
+ const uint8_t *old=c->destination==0?a:counts;
+ memcpy(out,old,64);
+ if(!c->legacy) memset(out+c->width,0,64-c->width);
+ if(c->mode==2) {
+  for(int i=0;i<c->width;++i) {
+   int offset=i%16, from=c->left ? offset-c->immediate : offset+c->immediate;
+   out[i]=from>=0 && from<16 ? a[i-offset+from] : 0;
+  }
+  return;
+ }
+ int bytes=c->bits/8;
+ for(int i=0;i<c->width;i+=bytes) {
+  if(c->mask && !((mask>>(i/bytes))&1)) {
+   if(c->mask==2) memset(out+i,0,bytes);
+   continue;
+  }
+  uint64_t count=c->immediate>=0?(uint64_t)c->immediate:read_le(counts+(c->mode==1 && !c->broadcast?i:0),c->mode==1?bytes:8);
+  uint64_t value=read_le(a+(c->broadcast && c->immediate>=0?0:i),bytes);
+  uint64_t result=0;
+  if(count<(uint64_t)c->bits) result=c->left?value<<count:value>>count;
+  for(int b=0;b<bytes;++b) out[i+b]=(uint8_t)(result>>(8*b));
+ }
+}
+static int check_case(const struct shift_case *c,int index) {
+ const uint64_t limits[]={0,1,7,15,16,17,31,32,33,63,64,65,255,256,UINT64_C(1)<<32,UINT64_MAX};
+ const uint64_t masks[]={0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+ const uint8_t flags[3][5]={{1,0,1,0,1},{0,1,0,1,1},{0,0,0,0,0}};
+ for(unsigned round=0;round<16;++round) for(unsigned m=0;m<4;++m) for(unsigned seed=0;seed<3;++seed) {
+  uint8_t aStorage[66],storage[71],beforeA[66],want[64];
+  _Alignas(16) uint8_t countStorage[96],beforeCount[96];
+  uint8_t *a=aStorage+1,*counts=countStorage+(c->legacy?16:3),*out=storage+1;
+  memset(aStorage,0xa7,sizeof(aStorage)); memset(countStorage,0xb9,sizeof(countStorage)); memset(storage,0xc3,sizeof(storage));
+  for(int i=0;i<64;++i) { a[i]=(uint8_t)(i*71+round*97+13); counts[i]=(uint8_t)(i*43+19); }
+  int bytes=c->bits/8;
+  for(int i=0;i<64;i+=bytes) {
+   uint64_t count=limits[(round+i/bytes)%16];
+   if(c->mode!=1) count=limits[round];
+   for(int b=0;b<bytes;++b) counts[i+b]=(uint8_t)(count>>(8*b));
+  }
+  if(c->mode==0) for(int b=0;b<8;++b) counts[b]=(uint8_t)(limits[round]>>(8*b));
+  memcpy(beforeA,aStorage,sizeof(beforeA)); memcpy(beforeCount,countStorage,sizeof(beforeCount));
+  expected(want,a,counts,masks[m],c);
+  c->fn(out,a,counts,masks[m],seed);
+  if(memcmp(want,out,64) || memcmp(flags[seed],out+64,5) || storage[0]!=0xc3 || storage[70]!=0xc3 ||
+     memcmp(aStorage,beforeA,sizeof(beforeA)) || memcmp(countStorage,beforeCount,sizeof(beforeCount))) {
+   for(int i=0;i<69;++i) if(out[i]!=(i<64?want[i]:flags[seed][i-64])) {
+    fprintf(stderr,"case=%d %s round=%u mask=%u seed=%u byte=%d actual=%02x expected=%02x\n",index,c->row,round,m,seed,i,out[i],i<64?want[i]:flags[seed][i-64]); break;
+   }
+   return 1;
+  }
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedLogicalShiftCompleteSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires Linux/amd64 runtime counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 tools required")
+	}
+	cases := x86PackedShiftNumericalCases()
+	assembly, sigs := x86PackedShiftNumericalAssembly(cases)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var driver strings.Builder
+	driver.WriteString(x86PackedShiftIndependentC)
+	for _, c := range cases {
+		fmt.Fprintf(&driver, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t,uint64_t);\n", c.name)
+	}
+	driver.WriteString("static const struct shift_case cases[]={\n")
+	for _, c := range cases {
+		fmt.Fprintf(&driver, "{%s,%q,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d},\n", c.name, c.row, c.width, c.bits, c.countMode, c.immediate, c.memory, c.maskMode, c.destination, x86ShiftBoolean(c.left), x86ShiftBoolean(c.legacy), x86ShiftBoolean(c.broadcast))
+	}
+	driver.WriteString("};\nint main(void) { for(unsigned i=0;i<sizeof(cases)/sizeof(cases[0]);++i) if(check_case(cases+i,i)) return 1; return 0; }\n")
+	var prefix []string
+	if crossRosetta {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_shift_complete", triple, ir, driver.String(), prefix)
+	t.Logf("%d exact opcode/width/count/memory/mask/alias programs, 192 whole-byte/flags/canary inputs each; Rosetta=%t", len(cases), crossRosetta)
+}
+
+func x86ShiftBoolean(value bool) int {
+	if value {
+		return 1
+	}
+	return 0
+}
+
+func TestX86PackedShiftActualGoLegacyNumericalOracle(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires Linux/amd64 native Go counterpart")
+	}
+	var source, assembly, tests strings.Builder
+	source.WriteString("package original\nimport \"unsafe\"\n")
+	tests.WriteString(`package original
+import ("testing"; "unsafe")
+func TestNumeric(t *testing.T) {
+ counts:=[]uint64{0,1,7,15,16,17,31,32,33,63,64,65,255,256,1<<32,^uint64(0)}
+ flags:=[3][5]byte{{1,0,1,0,1},{0,1,0,1,1},{0,0,0,0,0}}
+`)
+	for _, op := range []string{"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ", "PSLLO", "PSLLDQ", "PSRLO", "PSRLDQ"} {
+		name := strings.ToLower(op)
+		bits := 32
+		if strings.HasSuffix(op, "W") {
+			bits = 16
+		}
+		if strings.HasSuffix(op, "Q") {
+			bits = 64
+		}
+		byteShift := strings.HasSuffix(op, "DQ") || strings.HasSuffix(op, "O")
+		fmt.Fprintf(&source, "func %s(out,data,count unsafe.Pointer,seed uint64)\n", name)
+		row := op + " X1,X0"
+		if byteShift {
+			row = op + " $7,X0"
+		}
+		fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-32
+MOVQ out+0(FP),AX
+MOVQ data+8(FP),BX
+MOVQ count+16(FP),CX
+MOVQ seed+24(FP),DX
+MOVOU (BX),X0
+MOVOU (CX),X1
+CMPQ DX,$0
+JE carry
+CMPQ DX,$1
+JE overflow
+MOVQ $1,DX
+CMPQ DX,$0
+JMP shifted
+carry:
+MOVQ $-1,DX
+ADDQ $1,DX
+JMP shifted
+overflow:
+MOVQ $0x7fffffffffffffff,DX
+ADDQ $1,DX
+shifted:
+%s
+MOVOU X0,(AX)
+SETCS 16(AX)
+SETOS 17(AX)
+SETEQ 18(AX)
+SETMI 19(AX)
+SETPS 20(AX)
+RET
+`, name, row)
+		fmt.Fprintf(&tests, `for round,count:=range counts {
+ for seed:=0;seed<3;seed++ {
+ var data,countData [18]byte
+ var out [23]byte
+ for i:=range data { data[i]=byte(i*71+round*97+13); countData[i]=0xb9 }
+ for i:=range out { out[i]=0xc3 }
+ for i:=0;i<8;i++ { countData[i+1]=byte(count>>(8*i)) }
+ %s(unsafe.Pointer(&out[1]),unsafe.Pointer(&data[1]),unsafe.Pointer(&countData[1]),uint64(seed))
+ if out[0]!=0xc3 || out[22]!=0xc3 { t.Fatal("canary") }
+ for i:=0;i<5;i++ { if out[17+i]!=flags[seed][i] { t.Fatalf("flags seed=%%d bit=%%d got=%%d",seed,i,out[17+i]) } }
+ for i:=0;i<16;i++ {
+  var want byte
+`, name)
+		if byteShift {
+			from := "i-7"
+			if strings.Contains(op, "SRL") {
+				from = "i+7"
+			}
+			fmt.Fprintf(&tests, "from:=%s\nif from>=0 && from<16 { want=data[from+1] }\n", from)
+		} else {
+			operator := "<<"
+			if strings.Contains(op, "SRL") {
+				operator = ">>"
+			}
+			fmt.Fprintf(&tests, "offset:=(i/%d)*%d\nvar value uint64\nfor b:=0;b<%d;b++ { value|=uint64(data[offset+b+1])<<(8*b) }\nif count<%d { want=byte((value %s count)>>(8*(i%%%d))) }\n", bits/8, bits/8, bits/8, bits, operator, bits/8)
+		}
+		tests.WriteString("if out[i+1]!=want { t.Fatalf(\"byte %d got=%x want=%x\",i,out[i+1],want) }\n}\n}\n}\n")
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, bytes := range map[string]string{"go.mod": "module original\n\ngo 1.20\n", "original.go": source.String(), "original_amd64.s": assembly.String(), "original_test.go": tests.String()} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(bytes), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOARCH=amd64", "CGO_ENABLED=0", "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go legacy shift: %v\n%s", err, output)
+	}
+	t.Logf("10 original Go SSE2 mnemonic/alias programs ×48 initialized/flags/canary inputs; Rosetta=%t", crossRosetta)
+}
diff --git a/amd64_packed_sign_extend_forms.go b/amd64_packed_sign_extend_forms.go
new file mode 100644
index 000000000..e48629ee7
--- /dev/null
+++ b/amd64_packed_sign_extend_forms.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import "strings"
+
+// Keep all twelve signed members separate from the pre-existing unsigned
+// inventory: sharing pure grammar must not extend its raw-source identity.
+var x86PackedSignExtendSpecs = map[Op]x86PackedExtendSpec{
+	"PMOVSXBW":  {8, 16, false, 0x20},
+	"PMOVSXBD":  {8, 32, false, 0x21},
+	"PMOVSXBQ":  {8, 64, false, 0x22},
+	"PMOVSXWD":  {16, 32, false, 0x23},
+	"PMOVSXWQ":  {16, 64, false, 0x24},
+	"PMOVSXDQ":  {32, 64, false, 0x25},
+	"VPMOVSXBW": {8, 16, true, 0x20},
+	"VPMOVSXBD": {8, 32, true, 0x21},
+	"VPMOVSXBQ": {8, 64, true, 0x22},
+	"VPMOVSXWD": {16, 32, true, 0x23},
+	"VPMOVSXWQ": {16, 64, true, 0x24},
+	"VPMOVSXDQ": {32, 64, true, 0x25},
+}
+
+func x86PackedSignExtendProperties(ins Instr, arch string) (x86PackedExtendForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if _, known := x86PackedSignExtendSpecs[Op(base)]; !known {
+		return x86PackedExtendForm{}, false, nil
+	}
+	return x86PackedExtendProperties(ins, arch)
+}
diff --git a/amd64_packed_string_fault_linux_amd64_test.go b/amd64_packed_string_fault_linux_amd64_test.go
new file mode 100644
index 000000000..cc1483b2c
--- /dev/null
+++ b/amd64_packed_string_fault_linux_amd64_test.go
@@ -0,0 +1,17 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native packed-string fault owner requires LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu", "-mno-red-zone"}}
+	x86PackedStringRunMemoryFaults(t, execution, true)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_packed_string_fault_policy_crlf_test.go b/amd64_packed_string_fault_policy_crlf_test.go
new file mode 100644
index 000000000..473b58018
--- /dev/null
+++ b/amd64_packed_string_fault_policy_crlf_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedStringFaultNativePolicyKeepsCRLFAndMutations(t *testing.T) {
+	source, err := os.ReadFile("amd64_packed_string_fault_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	lf := string(normalizeNativeOwnerPolicySource(source))
+	for _, ending := range []struct{ name, newline string }{{"LF", "\n"}, {"CRLF", "\r\n"}} {
+		t.Run(ending.name, func(t *testing.T) {
+			encode := func(text string) []byte {
+				return []byte(strings.ReplaceAll(text, "\n", ending.newline))
+			}
+			original := encode(lf)
+			before := append([]byte(nil), original...)
+			t.Run("original", func(t *testing.T) {
+				if err := x86PackedStringFaultNativePolicy(original); err != nil {
+					t.Fatal("Go-equivalent line endings changed native fault ownership", err)
+				}
+				if !bytes.Equal(original, before) {
+					t.Fatal("policy parsing rewrote original native source")
+				}
+			})
+			mutations := x86PackedStringFaultNativeMutations(lf)
+			if len(mutations) != 9 {
+				t.Fatal("complete native policy mutation denominator changed")
+			}
+			for name, mutation := range mutations {
+				t.Run(name, func(t *testing.T) {
+					changed := encode(mutation)
+					if mutation == lf || bytes.Equal(changed, original) || x86PackedStringFaultNativePolicy(changed) == nil {
+						t.Fatal("line-ending adaptation hid a native policy mutation")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_string_fault_runtime_test.go b/amd64_packed_string_fault_runtime_test.go
new file mode 100644
index 000000000..cd4292ef3
--- /dev/null
+++ b/amd64_packed_string_fault_runtime_test.go
@@ -0,0 +1,207 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This portable counterpart executes original legacy Go bytes and translated
+// forms. Only the separately required Linux owner executes original VEX bytes.
+func TestX86PackedStringOriginalLegacyAndLLVMReadFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution = x86PackedStringFaultCompiler(t, execution)
+	x86PackedStringRunMemoryFaults(t, execution, false)
+}
+
+func x86PackedStringFaultCompiler(t *testing.T, execution x86FloatCompareExecution) x86FloatCompareExecution {
+	t.Helper()
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		// Reuse the actual selected SDK/no-default-config helper. This only
+		// configures the test's native C driver, never the Go source profile.
+		command := runtimeOracleNativeCCommand(t, ctx, execution.compiler[0], execution.compiler[1:]...)
+		execution.compiler = append([]string(nil), command.Args...)
+	}
+	return execution
+}
+
+func TestX86PackedStringFaultOriginalByteDriverObjects(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("original PCMP byte/driver objects require LLVM22")
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if runtime.GOOS == "darwin" {
+		triple = "x86_64-apple-darwin"
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: triple,
+		compiler: []string{clang, "-target", triple, "-mno-red-zone"}}
+	if runtime.GOOS == "linux" && runtime.GOARCH == "arm64" {
+		// The already authenticated matching cross compiler supplies its SDK;
+		// this object-only owner does not execute its emulator transport.
+		execution = x86FloatCompareExecutionTools(t)
+	}
+	execution = x86PackedStringFaultCompiler(t, execution)
+	cases := x86PackedStringFaultCases()
+	source, declarations := x86PackedStringFaultFixture(cases, "amd64")
+	x86LEAActualTargetGoObject(t, "amd64", triple, source)
+	driver := x86PackedStringFaultDriver(t, triple, cases, true)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		input := ir
+		if level == "-O2" {
+			input = x86UndefinedTrapOptimizedIR(t, ir)
+		}
+		execution.compileLLVM(t, "original-pcmp-fault-driver", input, driver, level)
+	}
+	t.Log("complete original eight-name Go-byte/LLVM/C driver compiled; no faulting executable was launched")
+}
+
+func x86PackedStringRunMemoryFaults(t *testing.T, execution x86FloatCompareExecution, native bool) {
+	t.Helper()
+	if native {
+		if len(execution.prefix) != 0 || execution.preserveArgv0 || execution.triple != "x86_64-unknown-linux-gnu" {
+			t.Fatal("native PCMP fault owner cannot use a guest transport or another target")
+		}
+		execution.requireAVX(t)
+	}
+	cases := x86PackedStringFaultCases()
+	source, declarations := x86PackedStringFaultFixture(cases, "amd64")
+	// This independently checks the complete original Go ABI0 source, not only
+	// the physical-register byte shim consumed by the C fault observer below.
+	x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+	driver := x86PackedStringFaultDriver(t, execution.triple, cases, native)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			executable := execution.compileLLVM(t, "packed-string-read-faults", input, driver, level)
+			probes := []int{0, 1, 2, 4} // NULL, 15-byte tail, full tail, readable mod16=1.
+			if native {
+				probes = nil
+				for probe := 0; probe < 34; probe++ {
+					probes = append(probes, probe)
+				}
+			}
+			for row := range cases {
+				for _, probe := range probes {
+					original := x86ObserveMemoryFault(t, execution, executable, row, probe, 1)
+					translated := x86ObserveMemoryFault(t, execution, executable, row, probe, 0)
+					fault := probe == 0 || probe == 1 || probe >= 19
+					if original != translated || fault && original != "segv" && original != "bus" || !fault && original != "return" {
+						t.Fatalf("PCMP row=%d/%s zero=%t dead=%t probe=%d original=%s LLVM=%s",
+							row, cases[row].op, cases[row].zero, cases[row].dead, probe, original, translated)
+					}
+				}
+			}
+			t.Logf("complete32-case PCMP read/fault matrix: original native VEX=%t, probes=%d, LLVM%s; readable values and full input-page canaries checked", native, len(probes), level)
+		})
+	}
+}
+
+func x86PackedStringFaultDriver(t *testing.T, triple string, cases []x86PackedStringFaultCase, native bool) string {
+	t.Helper()
+	var declarations, records strings.Builder
+	declarations.WriteString(x86OriginalSysVPointer("uint32_t", "original_program", "const uint8_t*"))
+	for index, row := range cases {
+		originalRow := row
+		if !native {
+			// A legacy opcode is only the portable memory-fault counterpart.
+			// It cannot certify the named original VEX opcode's execution.
+			originalRow.op = strings.TrimPrefix(originalRow.op, "V")
+		}
+		original := fmt.Sprintf("original_stringfault%d", index)
+		code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+x86PackedStringFaultBody(originalRow)+"RET\n")
+		if len(code) < 8 || code[len(code)-1] != 0xc3 {
+			t.Fatal("original Go PCMP byte program lost its complete ordinary RET", originalRow, code)
+		}
+		var bytes []string
+		for _, value := range code {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+		}
+		symbol := original
+		if strings.Contains(triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&declarations, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		declarations.WriteString(x86OriginalSysVDeclaration("uint32_t", original, "const uint8_t*"))
+		fmt.Fprintf(&declarations, "extern uint32_t stringfault%d(const uint8_t*);\n", index)
+		fmt.Fprintf(&records, "    {%s,stringfault%d,%d,%d},\n", original, index,
+			x86FloatAddSubBoolInt(row.zero), x86FloatAddSubBoolInt(row.dead))
+	}
+	return x86MemoryFaultSupportC + declarations.String() + `
+struct string_fault_case {
+    original_program original;
+    uint32_t (*translated)(const uint8_t*);
+    int zero,dead;
+};
+
+static const struct string_fault_case cases[] = {
+` + records.String() + "};\n" + x86PackedStringFaultMainC
+}
+
+const x86PackedStringFaultMainC = `
+int main(int argc, char **argv) {
+    if (argc != 4) return 80;
+    unsigned row,probe,original;
+    char tail;
+    if (sscanf(argv[1],"%u%c",&row,&tail) != 1 ||
+        sscanf(argv[2],"%u%c",&probe,&tail) != 1 ||
+        sscanf(argv[3],"%u%c",&original,&tail) != 1 ||
+        row >= sizeof(cases)/sizeof(cases[0]) || probe >= 34 || original > 1) return 80;
+
+    __builtin_cpu_init();
+    if (!__builtin_cpu_supports("sse4.2")) return 86;
+    int setup = memory_fault_setup(0);
+    if (setup) return setup;
+    const struct string_fault_case *kernel = &cases[row];
+    uint8_t fill = kernel->zero ? 0 : 255;
+    memset(guard,fill,page);
+    if (mprotect(guard,page,PROT_READ)) return 87;
+
+    const uint8_t *input;
+    if (probe == 0) {
+        input = NULL;
+    } else if (probe == 1) {
+        input = guard+page-15;
+    } else if (probe == 2) {
+        input = guard+page-16;
+    } else if (probe < 19) {
+        input = guard+32+(probe-3);
+    } else {
+        input = guard+page-(probe-19);
+    }
+
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 83;
+    uint32_t value = original ? kernel->original(input) : kernel->translated(input);
+
+    // A missing primary read must fail immediately. Calling the reference
+    // here could otherwise supply the fault that the translated code lost.
+    if (probe == 0 || probe == 1 || probe >= 19) return 93;
+
+    // Values are compared only after the primary instruction returned. The
+    // original opcode, not a C string scan or a guessed length, is the oracle.
+    if (value != kernel->original(input) || (kernel->dead && value != 7)) return 91;
+    for (size_t i = 0; i < page; ++i) {
+        if (guard[i] != fill) return 92;
+    }
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout) ? 85 : 0;
+}
+`
diff --git a/amd64_packed_string_fault_test.go b/amd64_packed_string_fault_test.go
new file mode 100644
index 000000000..addb42a81
--- /dev/null
+++ b/amd64_packed_string_fault_test.go
@@ -0,0 +1,327 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedStringFaultRequiredNativeOwner(t *testing.T) {
+	source, err := os.ReadFile("amd64_packed_string_fault_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal("complete original-Go/LLVM packed-string fault owner absent", err)
+	}
+	if err := x86PackedStringFaultNativePolicy(source); err != nil {
+		t.Fatal(err)
+	}
+}
+
+type x86PackedStringFaultCase struct {
+	op         string
+	zero, dead bool
+}
+
+// Independent source axes, not the production descriptor or a shortened SDK
+// function. Each original spelling retains both live/dead and empty/full cases.
+func x86PackedStringFaultCases() []x86PackedStringFaultCase {
+	var cases []x86PackedStringFaultCase
+	for _, op := range []string{"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM",
+		"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM"} {
+		for _, zero := range []bool{false, true} {
+			for _, dead := range []bool{false, true} {
+				cases = append(cases, x86PackedStringFaultCase{op, zero, dead})
+			}
+		}
+	}
+	return cases
+}
+
+func x86PackedStringFaultBody(row x86PackedStringFaultCase) string {
+	body := "PXOR X1,X1\n"
+	if !row.zero {
+		body += "PCMPEQB X1,X1\n"
+	}
+	if strings.Contains(row.op, "E") {
+		length := 16
+		if row.zero {
+			length = 0
+		}
+		body += fmt.Sprintf("MOVL $%d,AX\nMOVL $%d,DX\n", length, length)
+	}
+	body += row.op + " $12,(DI),X1\n"
+	if row.dead {
+		body += "MOVL $7,AX\n"
+	} else if strings.HasSuffix(row.op, "M") {
+		body += "MOVL X0,AX\n"
+	} else {
+		body += "MOVL CX,AX\n"
+	}
+	return body
+}
+
+func x86PackedStringFaultFixture(cases []x86PackedStringFaultCase, arch string) (string, string) {
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	var source, declarations strings.Builder
+	for index, row := range cases {
+		name := fmt.Sprintf("stringfault%d", index)
+		fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DI\n%sMOVL AX,ret+%d(FP)\nRET\n",
+			name, word+4, move, x86PackedStringFaultBody(row), word)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86PackedStringFaultCompleteSourceReadBeforeDeadResults(t *testing.T) {
+	cases := x86PackedStringFaultCases()
+	if len(cases) != 32 {
+		t.Fatal("eight complete spellings require independent empty/full and live/dead cases")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		source, declarations := x86PackedStringFaultFixture(cases, arch)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, optimized := range []bool{false, true} {
+					text := ir
+					if optimized {
+						text = x86UndefinedTrapOptimizedIR(t, ir)
+					}
+					if strings.Count(text, "load volatile <16 x i8>") != len(cases) ||
+						strings.Count(text, "define ") != len(cases) {
+						t.Fatal("empty lengths, EOS or dead results erased a complete observable m128 read", optimized)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedStringFaultReadOracleRejectsLostVolatility(t *testing.T) {
+	source, declarations := x86PackedStringFaultFixture(x86PackedStringFaultCases(), "amd64")
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	mutation := strings.ReplaceAll(ir, "load volatile <16 x i8>", "load <16 x i8>")
+	if mutation == ir || strings.Count(x86UndefinedTrapOptimizedIR(t, mutation), "load <16 x i8>") == 32 {
+		t.Fatal("read oracle cannot detect historical dead/zero-length nonvolatile access loss")
+	}
+}
+
+func x86PackedStringFaultMainSource(t *testing.T) string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_packed_string_fault_runtime_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var source string
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || value.Names[0].Name != "x86PackedStringFaultMainC" || len(value.Values) != 1 {
+			return true
+		}
+		literal, ok := value.Values[0].(*ast.BasicLit)
+		if !ok {
+			t.Fatal("fault observer must retain its complete registered C template")
+		}
+		source, err = strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return false
+	})
+	if source == "" {
+		t.Fatal("actual fault observer template absent")
+	}
+	return source
+}
+
+// This checks the fixed, registered test template, not arbitrary C programs.
+// Primary failure must precede any reference call or success/canary receipt.
+func x86PackedStringFaultObserverPolicy(source string) error {
+	previous := -1
+	for _, component := range []string{
+		"printf(\"memory enter %u %u %u\\n\",row,probe,original);",
+		"uint32_t value = original ? kernel->original(input) : kernel->translated(input);",
+		"if (probe == 0 || probe == 1 || probe >= 19) return 93;",
+		"if (value != kernel->original(input) || (kernel->dead && value != 7)) return 91;",
+		"if (guard[i] != fill) return 92;",
+		"if (free_guard()) return 84;",
+		"puts(\"memory complete\");",
+	} {
+		position := strings.Index(source, component)
+		if position <= previous || strings.Count(source, component) != 1 {
+			return fmt.Errorf("primary fault, independent reference and completion order changed")
+		}
+		previous = position
+	}
+	return nil
+}
+
+func TestX86PackedStringFaultObserverCannotBorrowReferenceFault(t *testing.T) {
+	source := x86PackedStringFaultMainSource(t)
+	if err := x86PackedStringFaultObserverPolicy(source); err != nil {
+		t.Fatal(err)
+	}
+	const guard = "if (probe == 0 || probe == 1 || probe >= 19) return 93;"
+	const reference = "if (value != kernel->original(input) || (kernel->dead && value != 7)) return 91;"
+	for name, mutation := range map[string]string{
+		"no primary failure":       strings.Replace(source, guard, "", 1),
+		"reference supplies fault": strings.Replace(strings.Replace(source, guard, "", 1), reference, reference+"\n"+guard, 1),
+		"NULL lost":                strings.Replace(source, guard, "if (probe == 1 || probe >= 19) return 93;", 1),
+		"tail lost":                strings.Replace(source, guard, "if (probe == 0 || probe >= 19) return 93;", 1),
+		"partial matrix lost":      strings.Replace(source, guard, "if (probe == 0 || probe == 1) return 93;", 1),
+		"success on missing read":  strings.Replace(source, guard, strings.Replace(guard, "93", "0", 1), 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if mutation == source || x86PackedStringFaultObserverPolicy(mutation) == nil {
+				t.Fatal("missing primary access could borrow a reference fault")
+			}
+		})
+	}
+}
+
+func TestX86PackedStringFaultCompleteFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete packed-string fault objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86PackedStringFaultFixture(x86PackedStringFaultCases(), target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					input := ir
+					if level == "-O2" {
+						input = x86UndefinedTrapOptimizedIR(t, input)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, input, level)
+				}
+			}
+		})
+	}
+}
+
+func x86PackedStringFaultNativePolicy(source []byte) error {
+	source = normalizeNativeOwnerPolicySource(source)
+	if !strings.HasPrefix(string(source), "//go:build linux && amd64\n") {
+		return fmt.Errorf("packed-string faults need the required native Linux/AMD64 owner")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "native.go", source, 0)
+	if err != nil {
+		return err
+	}
+	roots := 0
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != "TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults" {
+			continue
+		}
+		roots++
+		var gates []token.Pos
+		var run token.Pos
+		runs := 0
+		top := map[*ast.CallExpr]bool{}
+		for _, statement := range fn.Body.List {
+			if expr, ok := statement.(*ast.ExprStmt); ok {
+				if call, ok := expr.X.(*ast.CallExpr); ok {
+					top[call] = true
+				}
+			}
+		}
+		var failure error
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			switch node := node.(type) {
+			case *ast.CallExpr:
+				if selector, ok := node.Fun.(*ast.SelectorExpr); ok && strings.HasPrefix(selector.Sel.Name, "Skip") {
+					failure = fmt.Errorf("required execution cannot skip")
+				}
+				if name, ok := node.Fun.(*ast.Ident); ok {
+					if name.Name == "x87IA32RequireNativeHost" {
+						gates = append(gates, node.Pos())
+						if !top[node] {
+							failure = fmt.Errorf("native gate must be unconditional")
+						}
+					}
+					if name.Name == "x86PackedStringRunMemoryFaults" {
+						runs++
+						run = node.Pos()
+						if !top[node] || len(node.Args) != 3 {
+							failure = fmt.Errorf("whole fault execution must be unconditional")
+						} else if value, ok := node.Args[2].(*ast.Ident); !ok || value.Name != "true" {
+							failure = fmt.Errorf("all original native spellings must execute")
+						}
+					}
+				}
+			case *ast.KeyValueExpr:
+				if name, ok := node.Key.(*ast.Ident); ok && (name.Name == "prefix" || name.Name == "preserveArgv0") {
+					failure = fmt.Errorf("required native execution cannot use a guest prefix")
+				}
+			case *ast.ReturnStmt:
+				failure = fmt.Errorf("native owner cannot return early")
+			}
+			return true
+		})
+		if failure != nil {
+			return failure
+		}
+		if len(gates) != 2 || runs != 1 || !(gates[0] < run && run < gates[1]) {
+			return fmt.Errorf("native observations must surround exactly one complete execution")
+		}
+	}
+	if roots != 1 {
+		return fmt.Errorf("native root missing or duplicated")
+	}
+	return nil
+}
+
+func x86PackedStringFaultNativeMutations(text string) map[string]string {
+	const run = "\tx86PackedStringRunMemoryFaults(t, execution, true)"
+	const gate = "\tx87IA32RequireNativeHost(t)"
+	return map[string]string{
+		"missing after":   strings.Replace(text, run+"\n"+gate, run, 1),
+		"both before":     strings.Replace(text, run+"\n"+gate, gate+"\n"+run, 1),
+		"conditional run": strings.Replace(text, run, "\tif false {\n"+run+"\n\t}", 1),
+		"skip":            strings.Replace(text, run, "\tt.Skip(\"tool\")\n"+run, 1),
+		"early return":    strings.Replace(text, run, "\treturn\n"+run, 1),
+		"guest prefix":    strings.Replace(text, "{llc: llc,", "{prefix: []string{\"guest\"}, llc: llc,", 1),
+		"legacy only":     strings.Replace(text, run, strings.Replace(run, "true", "false", 1), 1),
+		"wrong host":      strings.Replace(text, "linux && amd64", "darwin && amd64", 1),
+		"missing root":    strings.Replace(text, "TestCrossLinuxRuntimeMatrixX86PackedStringOriginalNativeMemoryFaults", "NoNativeOwner", 1),
+	}
+}
+
+func TestX86PackedStringFaultNativePolicyRejectsMutation(t *testing.T) {
+	source, err := os.ReadFile("amd64_packed_string_fault_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(normalizeNativeOwnerPolicySource(source))
+	for name, mutation := range x86PackedStringFaultNativeMutations(text) {
+		t.Run(name, func(t *testing.T) {
+			if mutation == text || x86PackedStringFaultNativePolicy([]byte(mutation)) == nil {
+				t.Fatal("native lifecycle mutation not rejected")
+			}
+		})
+	}
+}
diff --git a/amd64_packed_string_status_observation_test.go b/amd64_packed_string_status_observation_test.go
new file mode 100644
index 000000000..42d577634
--- /dev/null
+++ b/amd64_packed_string_status_observation_test.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedStringFullFlagsObservationNeedsIndependentDFAndID(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range strings.Fields("PCMPESTRI PCMPESTRM PCMPISTRI PCMPISTRM VPCMPESTRI VPCMPESTRM VPCMPISTRI VPCMPISTRM") {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				declaration, source := x86PackedStringVectorFixture([]x86PackedStringVectorCase{{op, 0, 1, false, 0}}, arch)
+				original := strings.Replace(source, x86PackedStringStatusObservation(arch, true), x86PackedStringStatusObservation(arch, false), 1)
+				if original == source {
+					t.Fatal("original unrefined FLAGS observation was not retained")
+				}
+				x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], original)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, original, declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("six arithmetic flags supplied unknown incoming DF/ID bits", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_string_vector_linux_amd64_test.go b/amd64_packed_string_vector_linux_amd64_test.go
new file mode 100644
index 000000000..8b60d50a0
--- /dev/null
+++ b/amd64_packed_string_vector_linux_amd64_test.go
@@ -0,0 +1,41 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The portable byte oracle does not execute a VEX opcode. This required native
+// counterpart executes actual Go ABI0 AVX sources and both LLVM levels, with
+// complete Y aliases, six flags/LAHF/index and independent input canaries.
+func TestCrossLinuxRuntimeMatrixX86PackedStringImplicitVectorNativeAVX(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.compiler = append(execution.compiler, "-mno-red-zone")
+	execution.requireAVX(t)
+	cases, declarations, source := x86PackedStringNativeYFixture()
+	original := x86DefinedStatusBuildOriginal(t, execution, declarations, source, x86PackedStringNativeGoDriver(cases))
+	output := execution.run(t, original)
+	want := fmt.Sprintf("original native AVX packed-string observations %d failures 0\n", len(cases)*4)
+	if string(output) != want {
+		t.Fatalf("actual original Go AVX byte oracle: %s", output)
+	}
+	ir := x86CPUQueryIRFromDeclaration(t, source, declarations, "amd64", execution.triple, "Go")
+	main := strings.Replace(x86PackedStringVectorCOracle(cases), "view<3", "view<2", 1)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			output := execution.compileAndRunLLVM(t, "native-packed-string-vector", input, main, level)
+			want := fmt.Sprintf("portable packed-string byte observations %d failures 0\n", len(cases)*4)
+			if string(output) != want {
+				t.Fatalf("native LLVM AVX byte oracle: %s", output)
+			}
+		})
+	}
+}
diff --git a/amd64_packed_string_vector_runtime_test.go b/amd64_packed_string_vector_runtime_test.go
new file mode 100644
index 000000000..f8573a706
--- /dev/null
+++ b/amd64_packed_string_vector_runtime_test.go
@@ -0,0 +1,319 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86PackedStringVectorCOracle(cases []x86PackedStringVectorCase) string {
+	var functions, registrations strings.Builder
+	for index, row := range cases {
+		name := fmt.Sprintf("stringvector%d", index)
+		fmt.Fprintf(&functions, "extern void %s(uint8_t *,const uint8_t *);\n", name)
+		// Native legacy SSE supplies an independent low-mask/index and flags
+		// oracle. VEX upper-zeroing is checked separately against the ISA rule;
+		// this portable test never claims execution of a native VEX instruction.
+		fmt.Fprintf(&functions, `static void reference%d(const uint8_t *left,const uint8_t *right,uint8_t *mask,uint64_t *flags,uint64_t *index) {
+    uint64_t a=5,d=9,c=73,f;
+    __asm__ volatile(
+        "movdqu (%%[left]),%%%%xmm1\n\t"
+        "movdqu (%%[right]),%%%%xmm2\n\t"
+        "%s $%d,%%%%xmm2,%%%%xmm1\n\t"
+        "pushfq\n\t"
+        "popq %%[flags]\n\t"
+        "movdqu %%%%xmm0,(%%[mask])\n\t"
+        : "+a"(a),"+d"(d),"+c"(c),[flags]"=&r"(f)
+        : [left]"r"(left),[right]"r"(right),[mask]"r"(mask)
+        : "xmm0","xmm1","xmm2","cc","memory");
+    *flags=f&UINT64_C(0x8d5);
+    *index=c;
+}
+
+`, index, strings.ToLower(strings.TrimPrefix(row.op, "V")), row.imm)
+		fmt.Fprintf(&registrations, "{%s,reference%d,%d,%d,%d,%d,%q},\n", name, index,
+			row.source, row.dst, x86FloatAddSubBoolInt(strings.HasSuffix(row.op, "M")),
+			x86FloatAddSubBoolInt(strings.HasPrefix(row.op, "V")), row.op)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + functions.String() + `
+struct program {
+    void (*run)(uint8_t *,const uint8_t *);
+    void (*reference)(const uint8_t *,const uint8_t *,uint8_t *,uint64_t *,uint64_t *);
+    int source,destination,mask,vector;
+    const char *name;
+};
+static const struct program programs[]={
+` + registrations.String() + `};
+
+int main(void) {
+    unsigned observations=0;
+    for (unsigned program=0;program<sizeof(programs)/sizeof(programs[0]);++program) {
+        const struct program *p=&programs[program];
+        for (unsigned round=0;round<4;++round) {
+            uint8_t input[194],original[194],output[362],mask[16];
+            uint64_t flags,index,gotFlags,gotIndex;
+            for (unsigned i=0;i<sizeof(input);++i) {
+                input[i]=(uint8_t)(i*73+round*19+1);
+            }
+            input[1+3]=0;
+            input[1+64+7]=0;
+            input[1+128+11]=0;
+            memcpy(original,input,sizeof(input));
+            memset(output,0xc3,sizeof(output));
+            uint32_t saved,before=UINT32_C(0x1f80)|(round<<13)|round,after;
+            __asm__ volatile("stmxcsr %0":"=m"(saved));
+            __asm__ volatile("ldmxcsr %0"::"m"(before));
+            p->reference(input+1+p->destination*64,input+1+p->source*64,mask,&flags,&index);
+            p->run(output+1,input+1);
+            __asm__ volatile("stmxcsr %0":"=m"(after));
+            __asm__ volatile("ldmxcsr %0"::"m"(saved));
+            memcpy(&gotFlags,output+1+336,8);
+            memcpy(&gotIndex,output+1+352,8);
+            uint8_t lahf=(uint8_t)((flags&UINT64_C(0xd5))|2);
+            if (gotFlags!=flags || output[1+344]!=lahf || gotIndex!=index ||
+                after!=before || output[0]!=0xc3 || output[361]!=0xc3 || memcmp(input,original,sizeof(input))) {
+                fprintf(stderr,"%s/%u flags/index/input/canary mismatch\n",p->name,program);
+                return 1;
+            }
+            const unsigned widths[]={16,32,64},offsets[]={0,16,48};
+            for (unsigned reg=0;reg<3;++reg) {
+                for (unsigned view=0;view<3;++view) {
+                    for (unsigned byte=0;byte<widths[view];++byte) {
+                        uint8_t want=input[1+reg*64+byte];
+                        if (p->mask && reg==0) {
+                            if (byte<16) {
+                                want=mask[byte];
+                            } else if (p->vector) {
+                                want=0;
+                            }
+                        }
+                        uint8_t got=output[1+reg*112+offsets[view]+byte];
+                        if (got!=want) {
+                            fprintf(stderr,"%s/%u round=%u bank=%u width=%u byte=%u got=%u want=%u\n",
+                                p->name,program,round,reg,widths[view],byte,got,want);
+                            return 1;
+                        }
+                    }
+                }
+            }
+            ++observations;
+        }
+    }
+    printf("portable packed-string byte observations %u failures 0\n",observations);
+    return 0;
+}
+`
+}
+
+func TestX86PackedStringImplicitVectorByteOracle(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution.compiler = append(execution.compiler, "-mno-red-zone")
+	cases := x86PackedStringVectorCases()
+	declarations, source := x86PackedStringVectorFixture(cases, "amd64")
+	ir := x86CPUQueryIRFromDeclaration(t, source, declarations, "amd64", execution.triple, "Go")
+	// Only the execution target-feature request changes: all source operations
+	// and LLVM byte arithmetic stay intact. This makes the wide virtual bank
+	// oracle executable using SSE4.2, without asserting native AVX/AVX512.
+	features := regexp.MustCompile(`"target-features"="([^"]*)"`)
+	ir = features.ReplaceAllStringFunc(ir, func(attribute string) string {
+		values := features.FindStringSubmatch(attribute)[1]
+		for _, value := range strings.Split(values, ",") {
+			switch value {
+			case "+avx", "+avx512f", "+avx512vl", "+sse4.2":
+			default:
+				t.Fatalf("unreviewed portable feature request: %q", value)
+			}
+		}
+		return `"target-features"="+sse4.2"`
+	})
+	if strings.Contains(ir, `"target-features"="+avx`) {
+		t.Fatal("portable oracle retained an unreviewed native AVX feature request")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			output := execution.compileAndRunLLVM(t, "packed-string-vector-bytes", input, x86PackedStringVectorCOracle(cases), level)
+			want := fmt.Sprintf("portable packed-string byte observations %d failures 0\n", len(cases)*4)
+			if string(output) != want {
+				t.Fatalf("incomplete byte oracle: %s", output)
+			}
+		})
+	}
+}
+
+func x86PackedStringNativeYFixture() ([]x86PackedStringVectorCase, string, string) {
+	var cases []x86PackedStringVectorCase
+	for _, row := range x86PackedStringVectorCases() {
+		if row.imm == 8 {
+			cases = append(cases, row)
+		}
+	}
+	declarations, source := x86PackedStringVectorFixture(cases, "amd64")
+	// Actual native AVX has 32-byte banks. Z-bank execution is a distinct
+	// AVX512 requirement and is not silently inferred from this counterpart.
+	for reg := 0; reg < 3; reg++ {
+		source = strings.ReplaceAll(source, fmt.Sprintf("VMOVUPS %d(SI),Z%d\n", reg*64, reg),
+			fmt.Sprintf("VMOVUPS %d(SI),Y%d\n", reg*64, reg))
+		source = strings.ReplaceAll(source, fmt.Sprintf("VMOVUPS Z%d,%d(DI)\n", reg, reg*112+48), "")
+	}
+	return cases, declarations, source
+}
+
+func x86PackedStringNativeGoDriver(cases []x86PackedStringVectorCase) string {
+	var registrations strings.Builder
+	for index, row := range cases {
+		fmt.Fprintf(&registrations, "{stringvector%d,%d,%d,%t,%t,%t,%q},\n", index, row.source, row.dst,
+			strings.HasSuffix(row.op, "M"), strings.HasPrefix(row.op, "V"),
+			strings.Contains(row.op, "ESTR"), row.op)
+	}
+	return `package main
+
+import (
+    "encoding/binary"
+    "fmt"
+    "os"
+    "unsafe"
+)
+
+type program struct {
+    run func(*[360]byte,*[192]byte)
+    source,destination int
+    mask,vector,explicit bool
+    name string
+}
+
+var programs=[]program{
+` + registrations.String() + `}
+
+func fail(name string,round int,detail string) {
+    fmt.Fprintf(os.Stderr,"%s round=%d %s\n",name,round,detail)
+    os.Exit(1)
+}
+
+func main() {
+    observations:=0
+    for _,p:=range programs {
+        for round:=0;round<4;round++ {
+            input:=[194]byte{}
+            output:=[362]byte{}
+            for i:=range input {
+                input[i]=byte(i*73+round*19+1)
+            }
+            input[1+3]=0
+            input[1+64+7]=0
+            input[1+128+11]=0
+            original:=input
+            for i:=range output {
+                output[i]=0xc3
+            }
+            p.run((*[360]byte)(unsafe.Pointer(&output[1])),(*[192]byte)(unsafe.Pointer(&input[1])))
+            if input!=original || output[0]!=0xc3 || output[361]!=0xc3 {
+                fail(p.name,round,"input/canary mismatch")
+            }
+            left:=input[1+p.destination*64:1+p.destination*64+16]
+            right:=input[1+p.source*64:1+p.source*64+16]
+            la,lb:=5,9
+            if !p.explicit {
+                la,lb=16,16
+                for i:=0;i<16;i++ {
+                    if left[i]==0 && la==16 {
+                        la=i
+                    }
+                    if right[i]==0 && lb==16 {
+                        lb=i
+                    }
+                }
+            }
+            var result uint16
+            for i:=0;i<16;i++ {
+                if i>=la && i>=lb || i<la && i<lb && left[i]==right[i] {
+                    result|=1<<uint(i)
+                }
+            }
+            flags:=uint64(0)
+            if result!=0 {
+                flags|=1
+            }
+            if lb<16 {
+                flags|=0x40
+            }
+            if la<16 {
+                flags|=0x80
+            }
+            if result&1!=0 {
+                flags|=0x800
+            }
+            index:=uint64(73)
+            if !p.mask {
+                index=16
+                for i:=0;i<16;i++ {
+                    if result&(1<<uint(i))!=0 {
+                        index=uint64(i)
+                        break
+                    }
+                }
+            }
+            gotFlags:=binary.LittleEndian.Uint64(output[337:345])&0x8d5
+            gotIndex:=binary.LittleEndian.Uint64(output[353:361])
+            if gotFlags!=flags || gotIndex!=index || output[345]!=byte(flags&0xd5)|2 {
+                fail(p.name,round,"six flags/LAHF/index mismatch")
+            }
+            widths,offsets:=[]int{16,32},[]int{0,16}
+            for reg:=0;reg<3;reg++ {
+                for view,width:=range widths {
+                    for b:=0;b<width;b++ {
+                        want:=input[1+reg*64+b]
+                        if p.mask && reg==0 {
+                            if b<16 {
+                                want=0
+                                if b<2 {
+                                    want=byte(result>>uint(b*8))
+                                }
+                            } else if p.vector {
+                                want=0
+                            }
+                        }
+                        if got:=output[1+reg*112+offsets[view]+b];got!=want {
+                            fail(p.name,round,fmt.Sprintf("bank=%d width=%d byte=%d got=%d want=%d",reg,width,b,got,want))
+                        }
+                    }
+                }
+            }
+            observations++
+        }
+    }
+    fmt.Printf("original native AVX packed-string observations %d failures 0\n",observations)
+}
+`
+}
+
+func TestX86PackedStringNativeAVXCounterpartOriginalObject(t *testing.T) {
+	cases, declarations, source := x86PackedStringNativeYFixture()
+	execution := x86FloatCompareExecution{triple: "x86_64-unknown-linux-gnu"}
+	executable := x86DefinedStatusBuildOriginal(t, execution, declarations, source, x86PackedStringNativeGoDriver(cases))
+	object, err := elf.Open(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer object.Close()
+	if object.Class != elf.ELFCLASS64 || object.Machine != elf.EM_X86_64 || object.Data != elf.ELFDATA2LSB {
+		t.Fatal("native AVX counterpart is not an actual Linux/amd64 ELF")
+	}
+	bytes, err := os.ReadFile(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual original Go Linux/amd64 ELF bytes=%d sha=%x; compile-only, native execution remains required", len(bytes), sha256.Sum256(bytes))
+}
diff --git a/amd64_packed_string_vector_test.go b/amd64_packed_string_vector_test.go
new file mode 100644
index 000000000..e24b128b8
--- /dev/null
+++ b/amd64_packed_string_vector_test.go
@@ -0,0 +1,441 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedStringCompleteActualGoTableAttributes(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	read := func(name string) string {
+		data, err := os.ReadFile(filepath.Join(root, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return strings.Join(strings.Fields(string(data)), "")
+	}
+	legacy, vector := read("asm6.go"), read("avx_optabs.go")
+	for _, table := range []struct{ source, definition string }{
+		{legacy, "var yxshuf = []ytab{ {Zibm_r, 2, argList{Yu8, Yxm, Yxr}}, }"},
+		{vector, "var _yvaeskeygenassist = []ytab{ {zcase: Zvex_i_rm_r, zoffset: 0, args: argList{Yu8, Yxm, Yxr}}, {zcase: Zvex_i_rm_r, zoffset: 2, args: argList{Yi8, Yxm, Yxr}}, }"},
+	} {
+		if !strings.Contains(table.source, strings.Join(strings.Fields(table.definition), "")) {
+			t.Fatal("actual selected SDK packed-string complete operand table changed", table.definition)
+		}
+	}
+	for _, row := range []struct {
+		op, opcode, width string
+	}{
+		{"PCMPESTRI", "61", "WIG"}, {"PCMPESTRM", "60", "WIG"},
+		{"PCMPISTRI", "63", "WIG"}, {"PCMPISTRM", "62", "W0"},
+	} {
+		legacyRecord := fmt.Sprintf("{A%s,yxshuf,Pq,opBytes{0x3a,0x%s,0}}", row.op, row.opcode)
+		vectorRecord := fmt.Sprintf("{as:AV%s,ytab:_yvaeskeygenassist,prefix:Pavx,op:opBytes{avxEscape|vex128|vex66|vex0F3A|vex%s,0x%s,}},", row.op, row.width, row.opcode)
+		if !strings.Contains(legacy, legacyRecord) || !strings.Contains(vector, vectorRecord) {
+			t.Fatalf("actual selected SDK opcode/prefix/width attributes changed: %s", row.op)
+		}
+	}
+	// Count actual family registrations as well as checking each expected row.
+	// A shared ytab alone is not evidence of equal WIG or prefix attributes.
+	pattern := regexp.MustCompile(`\{(?:as:)?A(V?PCMP[EI]STR[[:alnum:]]+),`)
+	actual := make(map[string]int)
+	for _, source := range []string{legacy, vector} {
+		for _, match := range pattern.FindAllStringSubmatch(source, -1) {
+			actual[match[1]]++
+		}
+	}
+	if len(actual) != len(amd64PackedStringCompareSpecs) {
+		t.Fatal("actual selected SDK packed-string family denominator changed", actual)
+	}
+	for opcode := range amd64PackedStringCompareSpecs {
+		if actual[string(opcode)] != 1 {
+			t.Fatalf("actual selected SDK family registration is missing/duplicate: %s", opcode)
+		}
+	}
+}
+
+type x86PackedStringVectorCase struct {
+	op          string
+	source, dst int
+	memory      bool
+	imm         int
+}
+
+func x86PackedStringVectorCases() []x86PackedStringVectorCase {
+	var cases []x86PackedStringVectorCase
+	for _, op := range []string{
+		"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM",
+		"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM",
+	} {
+		for _, operands := range []struct {
+			source, dst int
+			memory      bool
+		}{{0, 1, false}, {1, 0, false}, {0, 0, false}, {1, 1, false}, {2, 1, false}, {2, 0, true}, {2, 1, true}} {
+			for _, immediate := range []int{0, 8, 64} {
+				cases = append(cases, x86PackedStringVectorCase{op, operands.source, operands.dst, operands.memory, immediate})
+			}
+		}
+	}
+	return cases
+}
+
+func x86PackedStringVectorFixture(cases []x86PackedStringVectorCase, arch string) (string, string) {
+	var declarations, source strings.Builder
+	move, pointer, args := "MOVQ", 8, 16
+	if arch == "386" {
+		move, pointer, args = "MOVL", 4, 8
+	}
+	for index, row := range cases {
+		name := fmt.Sprintf("stringvector%d", index)
+		fmt.Fprintf(&declarations, "func %s(out *[360]byte, in *[192]byte)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s in+%d(FP),SI\n", name, args, move, move, pointer)
+		for register := 0; register < 3; register++ {
+			fmt.Fprintf(&source, "VMOVUPS %d(SI),Z%d\n", register*64, register)
+		}
+		source.WriteString("MOVL $5,AX\nMOVL $9,DX\nMOVL $73,CX\n")
+		operand := fmt.Sprintf("X%d", row.source)
+		if row.memory {
+			operand = fmt.Sprintf("%d(SI)", row.source*64)
+		}
+		fmt.Fprintf(&source, "%s $%d,%s,X%d\n", row.op, row.imm, operand, row.dst)
+		for register := 0; register < 3; register++ {
+			for _, view := range []struct {
+				bank   string
+				offset int
+			}{{"X", 0}, {"Y", 16}, {"Z", 48}} {
+				fmt.Fprintf(&source, "VMOVUPS %s%d,%d(DI)\n", view.bank, register, register*112+view.offset)
+			}
+		}
+		source.WriteString(x86PackedStringStatusObservation(arch, true))
+	}
+	return declarations.String(), source.String()
+}
+
+func x86PackedStringStatusObservation(arch string, refined bool) string {
+	suffix := "Q"
+	if arch == "386" {
+		suffix = "L"
+	}
+	if !refined {
+		return "PUSHF" + suffix + "\nPOP" + suffix + " AX\nMOV" + suffix +
+			" AX,336(DI)\nLAHF\nMOVB AH,344(DI)\nMOV" + suffix + " CX,352(DI)\nRET\n"
+	}
+	// PCMP defines all six arithmetic flags, not incoming DF/ID. Capture LAHF
+	// first, then refine the popped FLAGS immediately, before any other effect
+	// can invalidate its transient bit knowledge or AND can change FLAGS.
+	return "LAHF\nMOVB AH,344(DI)\nPUSHF" + suffix + "\nPOP" + suffix + " BX\nAND" +
+		suffix + " $0x8d5,BX\nMOV" + suffix + " BX,336(DI)\nMOV" + suffix + " CX,352(DI)\nRET\n"
+}
+
+func x86PackedStringObjectBatches(rows []x86PackedStringVectorCase) [][]x86PackedStringVectorCase {
+	const maxFunctions = 64
+	var batches [][]x86PackedStringVectorCase
+	for len(rows) != 0 {
+		count := len(rows)
+		if count > maxFunctions {
+			count = maxFunctions
+		}
+		batches = append(batches, rows[:count])
+		rows = rows[count:]
+	}
+	return batches
+}
+
+func TestX86PackedStringObjectBatchInventory(t *testing.T) {
+	original := x86PackedStringVectorCases()
+	var joined []x86PackedStringVectorCase
+	seen := make(map[x86PackedStringVectorCase]bool)
+	for _, batch := range x86PackedStringObjectBatches(original) {
+		if len(batch) == 0 || len(batch) > 64 {
+			t.Fatal("empty or oversized packed-string object batch", len(batch))
+		}
+		for _, row := range batch {
+			if seen[row] {
+				t.Fatal("duplicate original packed-string form", row)
+			}
+			seen[row] = true
+		}
+		joined = append(joined, batch...)
+	}
+	if len(original) != 8*7*3 || !reflect.DeepEqual(joined, original) {
+		t.Fatal("bounded batches changed the complete ordered original form inventory")
+	}
+	owners := map[string]string{
+		"i386-unknown-linux-gnu":   "386",
+		"i686-pc-windows-msvc":     "386",
+		"x86_64-apple-darwin":      "amd64",
+		"x86_64-unknown-linux-gnu": "amd64",
+		"x86_64-pc-windows-msvc":   "amd64",
+	}
+	if len(x86RawReturnTargets) != len(owners) {
+		t.Fatal("new object targets need their own complete packed-string owner")
+	}
+	for _, target := range x86RawReturnTargets {
+		if owners[target.triple] != target.arch {
+			t.Fatal("missing or duplicate complete target owner", target)
+		}
+		delete(owners, target.triple)
+	}
+	if len(owners) != 0 {
+		t.Fatal("orphaned packed-string object owner", owners)
+	}
+}
+
+// Each target is independently schedulable, and each bounded LLVM unit is
+// released before the next batch. Partitioning retains all 168 original rows,
+// all five targets and the original three-API/two-optimization matrix.
+func x86PackedStringTargetObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for index, batch := range x86PackedStringObjectBatches(x86PackedStringVectorCases()) {
+		t.Run(fmt.Sprintf("batch-%d", index), func(t *testing.T) {
+			declarations, source := x86PackedStringVectorFixture(batch, arch)
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir := x86CPUQueryIRFromDeclaration(t, source, declarations, arch, triple, api)
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							input := ir
+							if level == "-O2" {
+								input = x86UndefinedTrapOptimizedIR(t, input)
+							}
+							x86PackedStringCompileObject(t, llc, triple, input, level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedStringObjectsLinux386(t *testing.T) {
+	x86PackedStringTargetObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86PackedStringObjectsWindows386(t *testing.T) {
+	x86PackedStringTargetObjects(t, "386", "i686-pc-windows-msvc")
+}
+
+func TestX86PackedStringObjectsDarwinAMD64(t *testing.T) {
+	x86PackedStringTargetObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86PackedStringObjectsLinuxAMD64(t *testing.T) {
+	x86PackedStringTargetObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86PackedStringObjectsWindowsAMD64(t *testing.T) {
+	x86PackedStringTargetObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86PackedStringResultEffectsAndPreEmissionIdentity(t *testing.T) {
+	for _, row := range go127PackedStringCompareSpecs() {
+		spec := amd64PackedStringCompareSpecs[Op(row.op)]
+		reg, width, zeroUpper := spec.resultEffect()
+		wantReg, wantWidth := CX, 4
+		if row.mask {
+			wantReg, wantWidth = "X0", 16
+		}
+		if reg != wantReg || width != wantWidth || zeroUpper != (row.vector && row.mask) {
+			t.Fatalf("%s implicit writer effect = %s/%d/%t", row.op, reg, width, zeroUpper)
+		}
+		for _, identity := range []Op{"", Op(row.op), Op(strings.ToLower(row.op)), "MOVOU", "UNKNOWN"} {
+			for _, arch := range []string{"amd64", "386"} {
+				t.Run(row.op+"/"+arch+"/"+string(identity), func(t *testing.T) {
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					instruction := Instr{Op: identity, Args: []Operand{
+						{Kind: OpImm, Imm: 8}, {Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"},
+					}}
+					before, temporary := output.String(), ctx.tmp
+					original := fmt.Sprintf("%#v", instruction)
+					known, terminated, err := ctx.lowerPackedStringCompare(Op(row.op), instruction)
+					invalid := identity != "" && !strings.EqualFold(string(identity), row.op)
+					if !known || terminated || (err != nil) != invalid || invalid && (before != output.String() || temporary != ctx.tmp) ||
+						original != fmt.Sprintf("%#v", instruction) {
+						t.Fatalf("implicit writer bypassed source identity or emitted before rejection: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedStringImmediateCompleteByteDomainOriginalObjects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT ·query(SB),4,$0-0\n")
+			for _, row := range go127PackedStringCompareSpecs() {
+				first := 0
+				if row.vector {
+					first = -128
+				}
+				for immediate := first; immediate <= 255; immediate++ {
+					fmt.Fprintf(&source, "%s $%d,X0,X1\n", row.op, immediate)
+				}
+			}
+			source.WriteString("RET\n")
+			x86LEAActualTargetGoObject(t, arch, testTargetTriple("linux", arch), source.String())
+		})
+	}
+}
+
+func TestX86PackedStringStrictMalformedOperands(t *testing.T) {
+	for _, row := range go127PackedStringCompareSpecs() {
+		for _, operands := range []string{
+			"$256,X0,X1", "$-129,X0,X1", "$0.0,X0,X1", "$8,Y0,X1",
+			"$8,X0,X16", "$8,X0,Y1", "$8,X0,(AX)", "$8,X0,X1,X2",
+		} {
+			t.Run(row.op+"/"+operands, func(t *testing.T) {
+				source := "TEXT ·query(SB),4,$0-0\n" + row.op + " " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: func(symbol string) string {
+					return strings.TrimPrefix(symbol, "·")
+				}, Sigs: map[string]FuncSig{"query": {Name: "query", Ret: Void}}})
+				if err == nil || ir != "" {
+					t.Fatal("malformed implicit vector writer returned IR", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedStringMode32HighBankNeedsPhysicalContext(t *testing.T) {
+	for _, op := range []string{"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM"} {
+		for _, operands := range []string{"X8,X1", "X1,X8", "X15,X15"} {
+			t.Run(op+"/"+operands, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·query(SB),4,$0-0\n%s $8,%s\nRET\n", op, operands)
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := mustGoPackage(t, "query", "package query\nfunc query()\n")
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("frontend high spelling acquired a physical mode32 vector binding: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedStringDoesNotSupplyCallerDefinedness(t *testing.T) {
+	for _, op := range []string{
+		"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM",
+		"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM",
+	} {
+		for _, operand := range []string{"X0", "(DI)", "(DX)"} {
+			t.Run(op+"/"+operand, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", op+" $8,"+operand+",X1\nMOVL AX,(DX)", 1)
+				goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unregistered implicit vector inputs/writers acquired caller permission: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedStringDescriptorDoesNotInventInitializedBytes(t *testing.T) {
+	for _, row := range go127PackedStringCompareSpecs() {
+		instruction := Instr{Op: Op(row.op), Args: []Operand{
+			{Kind: OpImm, Imm: 8}, {Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"},
+		}}
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0xffff, "Z1": 0xff}, masks: map[Reg]bool{"K1": true}}
+		before := state
+		before.vectors, before.masks = x86CloneCallerVectorState(state.vectors, state.masks)
+		if x86CallerVectorMoveKnown(instruction) || x86CallerVectorMoveStep(&instruction, &state, nil) ||
+			x86SourceStackInstructionKnown(instruction, OpMOVQ, "Q", "amd64") {
+			t.Fatalf("%s descriptor granted an unregistered caller effect", row.op)
+		}
+		if !reflect.DeepEqual(state, before) || instruction.x86CallerMemory != nil {
+			t.Fatalf("%s failed caller effect mutated byte knowledge or native certificates", row.op)
+		}
+	}
+}
+
+func TestX86PackedStringIndependentFPFieldsRequireEveryByte(t *testing.T) {
+	var parameters strings.Builder
+	for index := 0; index < 16; index++ {
+		if index != 0 {
+			parameters.WriteString(",")
+		}
+		fmt.Fprintf(&parameters, "a%d uint8", index)
+	}
+	pkg := mustGoPackage(t, "strings", "package strings\nfunc query("+parameters.String()+")\n")
+	for _, row := range go127PackedStringCompareSpecs() {
+		t.Run(row.op, func(t *testing.T) {
+			source := "TEXT ·query(SB),4,$0-16\n" + row.op + " $8,a0+0(FP),X1\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+			if _, err := Translate(file, options); err != nil {
+				t.Fatalf("complete independent logical FP fields: %v", err)
+			}
+			for missing := 0; missing < 16; missing++ {
+				t.Run(fmt.Sprint(missing), func(t *testing.T) {
+					// Each mutation starts from the original complete declaration.
+					// Logical FP completeness is not native address backing or an
+					// initialized caller-region witness.
+					signature := sigs["query"]
+					signature.Frame.Params = append([]FrameSlot(nil), signature.Frame.Params...)
+					signature.Frame.Params = append(signature.Frame.Params[:missing], signature.Frame.Params[missing+1:]...)
+					mutated := options
+					mutated.Sigs = map[string]FuncSig{"query": signature}
+					if ir, err := Translate(file, mutated); err == nil || ir != "" {
+						t.Fatalf("missing logical FP byte%d acquired a complete m128 source: %v", missing, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86PackedStringCompileObject(t *testing.T, llc, triple, ir, level string) {
+	t.Helper()
+	if level != "-O0" && level != "-O2" {
+		t.Fatal("unexpected packed-string object level", level)
+	}
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "strings.ll"), filepath.Join(dir, "strings.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", output))
+	info, err := os.Lstat(output)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("packed-string object is missing/nonregular/empty: %v", err)
+	}
+}
diff --git a/amd64_packed_subtract_fault_runtime_test.go b/amd64_packed_subtract_fault_runtime_test.go
new file mode 100644
index 000000000..032d6c1de
--- /dev/null
+++ b/amd64_packed_subtract_fault_runtime_test.go
@@ -0,0 +1,151 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedSubtractNativeMemoryStatus(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, references, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, original := range x86PackedSubtractCallerRows() {
+		parsed, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+original+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := parsed.Funcs[0].Instrs[1]
+		form, _, err := x86PackedSubtractProperties(instruction, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if form.memory < 0 || form.mask >= 0 && !form.zeroing {
+			continue
+		}
+		masks := []int{0}
+		if form.mask >= 0 {
+			masks = []int{0, 1}
+		}
+		for _, mask := range masks {
+			name := fmt.Sprintf("packedsubtractfault%d", index)
+			reference := fmt.Sprintf("subtractReference%d", index)
+			index++
+			row := strings.ReplaceAll(original, "(DI)", "(BX)")
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\n"+
+				"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"+
+				"VPXORD Z15,Z15,Z15\nVPXORD Z21,Z21,Z21\nVPXORD Z22,Z22,Z22\n"+
+				"MOVL $%d,CX\nKMOVQ CX,K1\n%s\nRET\n", name, mask, row)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+			fmt.Fprintf(&declarations, "extern void %s(const uint8_t*);\n", name)
+			if form.legacy {
+				mnemonic := strings.ToLower(string(instruction.Op))
+				if mnemonic == "psubl" {
+					mnemonic = "psubd"
+				}
+				fmt.Fprintf(&references, "__attribute__((noinline)) static void %s(const uint8_t *p) {\n"+
+					" typedef int32_t V __attribute__((vector_size(16)));\n V value = {0,0,0,0};\n"+
+					" __asm__ volatile(\"%s (%%1),%%0\" : \"+x\"(value) : \"r\"(p) : \"memory\");\n}\n",
+					reference, mnemonic)
+			} else {
+				bytes := form.memoryBytes
+				if form.mask >= 0 {
+					bytes = 0
+					if mask != 0 {
+						bytes = form.laneBits / 8
+					}
+				}
+				fmt.Fprintf(&references, "__attribute__((noinline)) static void %s(const uint8_t *p) {\n"+
+					" for (int i = 0; i < %d; ++i) {\n  (void)((const volatile uint8_t*)p)[i];\n }\n}\n",
+					reference, bytes)
+			}
+			fmt.Fprintf(&checks, "for(int n=0;n<16;++n) {\n if(compare(%s,%s,memory+n)) return 1;\n}\n", reference, name)
+			for _, offset := range []int{0, 1, form.laneBits / 8, 16, 32, 64} {
+				fmt.Fprintf(&checks, "if(compare(%s,%s,boundary-%d)) return 1;\n", reference, name, offset)
+			}
+			fmt.Fprintf(&checks, "if(compare(%s,%s,0)) return 1;\n", reference, name)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + declarations.String() + references.String() + `
+typedef struct { int signal; int code; } Status;
+
+static int observe(void (*fn)(const uint8_t*), const uint8_t *p, Status *out) {
+ pid_t child = fork();
+ if (child < 0) return 1;
+ if (child == 0) {
+  struct rlimit limit = {0,0};
+  if (setrlimit(RLIMIT_CORE,&limit)) _exit(3);
+  fn(p);
+  _exit(0);
+ }
+ int status;
+ if (waitpid(child,&status,0) != child) return 1;
+ if (WIFSIGNALED(status)) {
+  *out = (Status){WTERMSIG(status),0};
+  return 0;
+ }
+ if (WIFEXITED(status)) {
+  *out = (Status){0,WEXITSTATUS(status)};
+  return 0;
+ }
+ return 1;
+}
+
+static int compare(void (*original)(const uint8_t*),
+                   void (*translated)(const uint8_t*), const uint8_t *p) {
+ Status a, b;
+ if (observe(original,p,&a) || observe(translated,p,&b)) return 1;
+ if (a.signal != b.signal || a.code != b.code) {
+  fprintf(stderr,"pointer=%p mod16=%lu original=(%d,%d) translated=(%d,%d)\n",
+          p,(unsigned long)((uintptr_t)p%16),a.signal,a.code,b.signal,b.code);
+  return 1;
+ }
+ return 0;
+}
+
+int main(void) {
+ long page = sysconf(_SC_PAGESIZE);
+ if (page <= 0 || page%64) return 1;
+ uint8_t *memory = mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,
+                        MAP_PRIVATE|MAP_ANON,-1,0);
+ if (memory == MAP_FAILED) return 1;
+ memset(memory,0x87,(size_t)page);
+ if (mprotect(memory,(size_t)page,PROT_READ) ||
+     mprotect(memory+page,(size_t)page,PROT_NONE)) return 1;
+ uint8_t *boundary = memory+page;
+` + checks.String() + `
+ if (munmap(memory,(size_t)page*2)) return 1;
+ return 0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-subtract-fault", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d dead-output memory programs at every mod16/NULL/RO guard; native original SSE and independent E4 reads at O0/O2, not AVX512 hardware", index)
+}
diff --git a/amd64_packed_subtract_forms.go b/amd64_packed_subtract_forms.go
new file mode 100644
index 000000000..e33c1ab33
--- /dev/null
+++ b/amd64_packed_subtract_forms.go
@@ -0,0 +1,12 @@
+package plan9asm
+
+type x86PackedSubtractForm struct {
+	x86PackedBinaryForm
+	laneBits int
+	mode     amd64PackedSubtractMode
+}
+
+func x86PackedSubtractProperties(ins Instr, arch string) (x86PackedSubtractForm, bool, error) {
+	form, known, err := x86PackedArithmeticProperties(ins.Op, ins, arch, x86PackedArithmeticSubtract)
+	return x86PackedSubtractForm{form.x86PackedBinaryForm, form.spec.laneBits, form.spec.mode}, known, err
+}
diff --git a/amd64_packed_subtract_go_oracle_test.go b/amd64_packed_subtract_go_oracle_test.go
new file mode 100644
index 000000000..a5b54e7d8
--- /dev/null
+++ b/amd64_packed_subtract_go_oracle_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedSubtractOriginalGoBits(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+
+import "testing"
+
+func lane(p []byte, n int) uint64 {
+ var value uint64
+ for j := 0; j < n; j++ {
+  value |= uint64(p[j]) << uint(8*j)
+ }
+ return value
+}
+
+func difference(a, b uint64, n, mode int) uint64 {
+ if mode == 0 {
+  return b-a
+ }
+ if mode == 2 {
+  if b < a {
+   return 0
+  }
+  return b-a
+ }
+ sign := int64(1) << uint(n*8-1)
+ left, right := int64(a), int64(b)
+ if a&uint64(sign) != 0 {
+  left -= sign*2
+ }
+ if b&uint64(sign) != 0 {
+  right -= sign*2
+ }
+ result := right-left
+ if result < -sign {
+  result = -sign
+ }
+ if result > sign-1 {
+  result = sign-1
+ }
+ return uint64(result)
+}
+
+func TestOriginalSubtract(t *testing.T) {
+ var patterns [8][16]byte
+ state := uint32(0x12345678)
+ for p := range patterns {
+  for i := range patterns[p] {
+   state = state*1664525+1013904223
+   patterns[p][i] = byte(state>>24)
+  }
+ }
+ for i := range patterns[0] {
+  patterns[0][i] = 0xff
+  patterns[1][i] = 1
+  patterns[2][i] = 0x80
+  patterns[3][i] = 0
+ }
+`)
+	opcodes := []string{"PSUBB", "PSUBW", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW"}
+	for index, opcode := range opcodes {
+		bits, mode, _, _ := amd64PackedSubtractProperties(opcode)
+		name := fmt.Sprintf("packedsubtractgo%d", index)
+		fmt.Fprintf(&declarations, "func %s(a,b,out *byte,csr uint32)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\n"+
+			"STMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\n"+
+			"MOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),CX\n"+
+			"MOVOU (AX),X1\nMOVOU (BX),X0\nCMPQ AX,AX\nSTC\n"+
+			"%s X1,X0\nMOVOU X0,(CX)\nSETCS 16(CX)\nSETNE 17(CX)\n"+
+			"STMXCSR 18(CX)\nLDMXCSR saved-4(SP)\nRET\n", name, opcode)
+		fmt.Fprintf(&tests, `
+ for _, a := range patterns {
+  for _, b := range patterns {
+   for csrMode := 0; csrMode < 4; csrMode++ {
+    var out [24]byte
+    for i := range out {
+     out[i] = 0xc3
+    }
+    csr := uint32(0x1f80|csrMode<<13|csrMode)
+    %[1]s(&a[0],&b[0],&out[1],csr)
+    if out[0] != 0xc3 || out[23] != 0xc3 || out[17] != 1 || out[18] != 0 {
+     t.Fatalf("%[1]s flags/canary %%x",out)
+    }
+    gotCSR := uint32(out[19]) | uint32(out[20])<<8 | uint32(out[21])<<16 | uint32(out[22])<<24
+    if gotCSR != csr {
+     t.Fatalf("%[1]s CSR %%x != %%x",gotCSR,csr)
+    }
+    for i := 0; i < 16; i += %[2]d {
+     want := difference(lane(a[i:],%[2]d),lane(b[i:],%[2]d),%[2]d,%[3]d)
+     for j := 0; j < %[2]d; j++ {
+      if out[i+j+1] != byte(want >> uint(8*j)) {
+       t.Fatalf("%[1]s byte%%d got%%x want%%x",i+j,out,want)
+      }
+     }
+    }
+   }
+  }
+ }
+`, name, bits/8, mode)
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go packed subtract oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d actual Go SSE functions × 256 independent full-lane wrapping/saturation/MXCSR/flags/canary cases", len(opcodes))
+}
diff --git a/amd64_packed_subtract_low_z_test.go b/amd64_packed_subtract_low_z_test.go
new file mode 100644
index 000000000..e3edbcb08
--- /dev/null
+++ b/amd64_packed_subtract_low_z_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86PackedSubtractLowZThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var parameters []string
+	for _, prefix := range []string{"a", "b"} {
+		for index := 0; index < 8; index++ {
+			parameters = append(parameters, fmt.Sprintf("%s%d uint64", prefix, index))
+		}
+	}
+	declaration := "func Value(" + strings.Join(parameters, ",") + ")"
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, opcode := range []string{"VPSUBB", "VPSUBW", "VPSUBD", "VPSUBQ", "VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW"} {
+			forms := []struct{ name, instruction string }{
+				{"register", opcode + " Z0,Z1,Z2"},
+				{"alias", opcode + " Z1,Z1,Z2"},
+				{"memory", opcode + " a0+0(FP),Z1,Z2"},
+			}
+			if opcode == "VPSUBD" || opcode == "VPSUBQ" {
+				forms = append(forms, struct{ name, instruction string }{
+					"broadcast", opcode + ".BCST a0+0(FP),Z1,Z2",
+				})
+			}
+			for _, form := range forms {
+				t.Run(target.triple+"/"+opcode+"/"+form.name, func(t *testing.T) {
+					// This fixture establishes form translation and LLVM objects,
+					// not an initialized numeric return or a caller-region grant.
+					pkg := mustGoPackage(t, "example.invalid/subtract", "package subtract\n"+declaration+"\n")
+					sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func),
+						target.arch, types.SizesFor("gc", target.arch))
+					if err != nil {
+						t.Fatal(err)
+					}
+					body := "VMOVUPS a0+0(FP),Z0\nVMOVUPS b0+64(FP),Z1\n" +
+						form.instruction + "\nRET"
+					source := "TEXT ·Value(SB),4,$0-128\n" + body + "\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					options := Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs:       map[string]FuncSig{"Value": sig},
+						ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+					before := fmt.Sprintf("%#v %#v", file, sig)
+					ir, err := Translate(file, options)
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "text")
+					context := llvm.NewContext()
+					defer context.Dispose()
+					module, err := TranslateModuleInContext(context, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+					translated, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+						GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+					})
+					if translated != nil && !translated.Module.IsNil() {
+						defer translated.Module.Dispose()
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+					if before != fmt.Sprintf("%#v %#v", file, sig) {
+						t.Fatal("translation mutated original typed inputs")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_packed_subtract_mode32_test.go b/amd64_packed_subtract_mode32_test.go
new file mode 100644
index 000000000..a689f48e1
--- /dev/null
+++ b/amd64_packed_subtract_mode32_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedSubtract386HighRegisterDoesNotAcquirePhysicalBinding(t *testing.T) {
+	for _, opcode := range []string{"VPSUBB", "VPSUBW", "VPSUBD", "VPSUBQ", "VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW"} {
+		for _, bank := range []string{"X", "Y"} {
+			for position := 0; position < 3; position++ {
+				for _, high := range []int{16, 31} {
+					args := []string{bank + "0", bank + "1", bank + "2"}
+					args[position] = fmt.Sprintf("%s%d", bank, high)
+					row := opcode + " " + strings.Join(args, ",")
+					t.Run(strings.ReplaceAll(row, " ", "_"), func(t *testing.T) {
+						source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+						requireX86GoAssemblerResult(t, "386", source, true)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						instruction := file.Funcs[0].Instrs[1]
+						if _, recognized, err := x86PackedSubtractProperties(instruction, "386"); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("Go-accepted mode32 high bank became a physical-register permission: recognized=%v err=%v", recognized, err)
+						}
+						ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+						ctx.goarch = "386"
+						before := output.String()
+						if recognized, _, err := ctx.lowerPackedIntegerSubtract(instruction.Op, instruction); !recognized ||
+							!errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+							t.Fatalf("unproved mode32 high bank emitted IR: recognized=%v err=%v", recognized, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedSubtract386HighRegisterActualByteIdentities(t *testing.T) {
+	for _, opcode := range []string{"VPSUBB", "VPSUBW", "VPSUBD", "VPSUBQ", "VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW"} {
+		for _, bank := range []string{"X", "Y"} {
+			for operand := 0; operand < 3; operand++ {
+				args := []string{bank + "0", bank + "1", bank + "2"}
+				args[operand] = bank + "16"
+				row := opcode + " " + strings.Join(args, ",")
+				t.Run(strings.ReplaceAll(row, " ", "_"), func(t *testing.T) {
+					code := x86PackedFirstGoInstructionBytes(t, "386", row)
+					ins, length, recognized, err := decodedX86PackedIntegerArithmeticInstruction(code, 64)
+					if len(code) != 6 || !recognized || err != nil || length != 6 || ins.Op != Op(opcode) || len(ins.Args) != 3 {
+						t.Fatalf("actual EVEX byte identity %s/%x: %+v/%d/%t/%v", row, code, ins, length, recognized, err)
+					}
+					for index, argument := range args {
+						if ins.Args[index].Reg != Reg(argument) {
+							t.Fatalf("%s/%x operand%d: %s != %s", row, code, index, ins.Args[index].Reg, argument)
+						}
+					}
+					if _, _, recognized, err := decodedX86PackedIntegerArithmeticInstruction(code, 32); !recognized || err == nil {
+						t.Fatalf("raw mode32 high bank obtained false permission: %s/%x", row, code)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedSubtract386BroadcastHighRegisterNeedsContext(t *testing.T) {
+	for _, opcode := range []string{"VPSUBD", "VPSUBQ"} {
+		for _, bank := range []string{"X", "Y"} {
+			for position := 1; position < 3; position++ {
+				args := []string{"(AX)", bank + "1", bank + "2"}
+				args[position] = bank + "16"
+				row := opcode + ".BCST " + strings.Join(args, ",")
+				t.Run(strings.ReplaceAll(row, " ", "_"), func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+					requireX86GoAssemblerResult(t, "386", source, true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, known, err := x86PackedSubtractProperties(file.Funcs[0].Instrs[1], "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("broadcast high bank became a mode32 binding: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_packed_subtract_runtime_test.go b/amd64_packed_subtract_runtime_test.go
new file mode 100644
index 000000000..75a1e1070
--- /dev/null
+++ b/amd64_packed_subtract_runtime_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Only legacy SSE is executed as native instruction evidence. VEX/EVEX
+// numerical expectations come from independent scalar lane arithmetic.
+const x86PackedSubtractIndependentOracle = `
+static const uint64_t subtractMasks[] = {
+ 0, 1, UINT64_C(0x55aa55aa55aa55aa), UINT64_MAX
+};
+
+static uint64_t subtractLane(const uint8_t *p, int bytes) {
+ uint64_t value = 0;
+ for (int j = 0; j < bytes; ++j) {
+  value |= (uint64_t)p[j] << (8*j);
+ }
+ return value;
+}
+
+static uint64_t subtractValue(uint64_t a, uint64_t b, int bytes, int mode) {
+ if (mode == 0) {
+  return b-a;
+ }
+ if (mode == 2) {
+  return b < a ? 0 : b-a;
+ }
+ int bits = bytes*8;
+ int64_t sign = INT64_C(1) << (bits-1);
+ int64_t left = (a & sign) ? (int64_t)a - (sign*2) : (int64_t)a;
+ int64_t right = (b & sign) ? (int64_t)b - (sign*2) : (int64_t)b;
+ int64_t result = right-left;
+ if (result < -sign) {
+  result = -sign;
+ }
+ if (result > sign-1) {
+  result = sign-1;
+ }
+ return (uint64_t)result;
+}
+
+__attribute__((noinline)) static int checkSubtract(
+ void (*fn)(uint8_t*, const uint8_t*, const uint8_t*, uint64_t),
+ const char *name, int width, int bytes, int arithmetic,
+ int maskMode, int legacy, int memory, int broadcast) {
+ for (int round = 0; round < 12; ++round) {
+  for (int m = 0; m < 4; ++m) {
+   _Alignas(64) uint8_t aStorage[96], bStorage[96], output[68];
+   int shift = legacy && memory ? 16 : 1;
+   uint8_t *a = aStorage+shift;
+   uint8_t *b = bStorage+3;
+   memset(aStorage, 0xa7, sizeof(aStorage));
+   memset(bStorage, 0xb9, sizeof(bStorage));
+   memset(output, 0xc3, sizeof(output));
+   for (int i = 0; i < 64; ++i) {
+    a[i] = (uint8_t)(i*17+round*31);
+    b[i] = (uint8_t)(i*23+round*53);
+   }
+   if (round < 4) {
+    memset(a, round == 0 ? 0xff : round == 1 ? 0x80 : round == 2 ? 1 : 0, 64);
+    memset(b, round == 0 ? 1 : round == 1 ? 0x7f : round == 2 ? 0 : 0xff, 64);
+   }
+   uint64_t mask = subtractMasks[m];
+   uint32_t saved, before = 0x1f80 | ((round%4)<<13) | round, after;
+   __asm__ volatile("stmxcsr %0" : "=m"(saved));
+   __asm__ volatile("ldmxcsr %0" : : "m"(before));
+   fn(output+1, a, b, mask);
+   __asm__ volatile("stmxcsr %0" : "=m"(after));
+   __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+   if (after != before || output[0] != 0xc3 || output[67] != 0xc3 ||
+       output[65] != 1 || output[66] != 0) {
+    fprintf(stderr, "%s changed MXCSR, flags or output canaries\n", name);
+    return 1;
+   }
+   for (int i = 0; i < 64; i += bytes) {
+    uint64_t result = subtractValue(subtractLane(a+(broadcast ? 0 : i), bytes),
+                                    subtractLane(b+i, bytes), bytes, arithmetic);
+    int active = maskMode == 0 || ((mask >> (i/bytes)) & 1);
+    for (int j = 0; j < bytes; ++j) {
+     uint8_t want = i < width ?
+       (active ? (uint8_t)(result >> (8*j)) : maskMode == 2 ? 0 : b[i+j]) :
+       legacy ? b[i+j] : 0;
+     if (output[i+j+1] != want) {
+      fprintf(stderr, "%s round=%d mask=%llx byte=%d got=%x want=%x\n",
+              name, round, (unsigned long long)mask, i+j, output[i+j+1], want);
+      return 1;
+     }
+    }
+   }
+   for (int i = 0; i < 96; ++i) {
+    if ((i < shift || i >= shift+64) && aStorage[i] != 0xa7) {
+     return 1;
+    }
+    if ((i < 3 || i >= 67) && bStorage[i] != 0xb9) {
+     return 1;
+    }
+   }
+  }
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedSubtractCompleteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	rows := x86PackedSubtractCallerRows()
+	for index, row := range rows {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		form, _, err := x86PackedSubtractProperties(instruction, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		mode := 0
+		if form.mask >= 0 {
+			mode = 1
+			if form.zeroing {
+				mode = 2
+			}
+		}
+		name := fmt.Sprintf("packedsubtract%d", index)
+		row = strings.ReplaceAll(row, "(DI)", "(BX)")
+		register, valid := amd64VectorRegisterIndex(instruction.Args[form.destination].Reg, form.byteWidth)
+		if !valid {
+			t.Fatal("missing actual vector destination")
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n"+
+			"MOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\n"+
+			"VMOVUPS (BX),Z0\nVMOVUPS (BX),Z20\n"+
+			"VMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nVMOVUPS (CX),Z15\n"+
+			"VMOVUPS (CX),Z21\nVMOVUPS (CX),Z22\nKMOVQ DX,K1\n"+
+			"CMPQ AX,AX\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n",
+			name, row, register)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+		fmt.Fprintf(&checks, "if(checkSubtract(%s,\"%s\",%d,%d,%d,%d,%d,%d,%d)) return 1;\n",
+			name, name, form.byteWidth, form.laneBits/8, form.mode, mode,
+			x86FloatAddSubBoolInt(form.legacy), x86FloatAddSubBoolInt(form.memory >= 0),
+			x86FloatAddSubBoolInt(form.broadcast))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n" +
+		declarations.String() + x86PackedSubtractIndependentOracle +
+		"int main(void){\n" + checks.String() + "return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed-subtract-complete", triple, text, main, prefix)
+		})
+	}
+	t.Logf("%d programs × 48 independent wrapping/saturating/mask/upper-view/flags/MXCSR/canary cases at O0/O2; not native AVX512 execution", len(rows))
+}
diff --git a/amd64_packed_testmask_forms.go b/amd64_packed_testmask_forms.go
new file mode 100644
index 000000000..20db9ec47
--- /dev/null
+++ b/amd64_packed_testmask_forms.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedTestMaskForm struct {
+	x86PackedBinaryForm
+	spec   amd64PackedTestMaskSpec
+	source Operand
+}
+
+// Source vectors, optional K input and K result are disjoint roles. The
+// shared mask-result grammar grants no numerical bytes or memory backing.
+func x86PackedTestMaskProperties(op Op, ins Instr, arch string) (x86PackedTestMaskForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64PackedTestMaskSpecs[base]
+	f := x86PackedTestMaskForm{spec: spec}
+	if !known {
+		return f, false, nil
+	}
+	fail := func() (x86PackedTestMaskForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside packed integer test-to-mask grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	local := ins
+	local.Op = op
+	roles, valid := x86PackedMaskCompareProperties(local, arch, 0, spec.laneBits, dotted, suffix)
+	if !valid {
+		return fail()
+	}
+	f.x86PackedBinaryForm, f.source = roles, ins.Args[roles.first]
+	for _, index := range []int{roles.first, roles.second} {
+		arg := ins.Args[index]
+		if arg.Kind == OpReg && !amd64GoPackedVectorMoveRegister(arg, roles.byteWidth, arch) {
+			return fail()
+		}
+	}
+	if roles.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return f, true, fmt.Errorf("%w: test-to-mask has no bound address-size override", ErrProbeNeedsContext)
+	}
+	return f, true, nil
+}
+
+func x86TypedPackedTestMaskByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86PackedTestMaskProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	firstWidth := f.byteWidth
+	if f.memory >= 0 {
+		firstWidth = f.memoryBytes
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true,
+		vector: x86TypedVectorEffect{memoryAlignment: 1},
+		operands: []x86TypedByteOperand{
+			{index: f.first, operand: f.source, width: int64(firstWidth), read: true},
+			{index: f.second, operand: ins.Args[f.second], width: int64(f.byteWidth), read: true},
+			{index: f.destination, operand: ins.Args[f.destination], width: 8, write: true},
+		}}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
+
+func x86ResultPackedTestMaskStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86PackedTestMaskProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	for _, index := range []int{f.first, f.second} {
+		operand := ins.Args[index]
+		if index == f.memory {
+			if !x86ResultReadWithNativeContinuation(ins, operand, int64(f.memoryBytes), state, owned, arch, native) {
+				return false, true
+			}
+			continue
+		}
+		vector, valid := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+		required := x86CallerVectorByteMask(int64(f.byteWidth))
+		if !valid || state.vectorBytes(vector)&required != required {
+			return false, true
+		}
+	}
+	// Even equal source registers depend on their actual intersection bits.
+	// Disabled and high K bits are written zero, never merged from old K.
+	destination, _ := amd64ParseKReg(ins.Args[f.destination].Reg)
+	state.masks[destination] = true
+	return true, true
+}
diff --git a/amd64_packed_unpack_fault_runtime_test.go b/amd64_packed_unpack_fault_runtime_test.go
new file mode 100644
index 000000000..81fecb232
--- /dev/null
+++ b/amd64_packed_unpack_fault_runtime_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedUnpackFaultProgram() (string, map[string]FuncSig, string, string) {
+	var assembly, declarations, rows strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range []struct {
+		instruction string
+		bytes       int
+	}{
+		{"VPUNPCKLBW.Z (BX),Z0,K1,Z1", 64},
+		{"VPUNPCKHWD.Z (BX),Y0,K1,Y1", 32},
+		{"VUNPCKHPS.BCST.Z (BX),X0,K1,X1", 4},
+		{"VUNPCKHPD.BCST.Z (BX),Z0,K1,Z1", 8},
+	} {
+		name := fmt.Sprintf("unpackfault%d", index)
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-16\nMOVQ input+0(FP),BX\nMOVQ out+8(FP),AX\nVPXORD Z0,Z0,Z0\nMOVL $0,CX\nKMOVQ CX,K1\n%s\nVMOVUPS Z1,(AX)\nRET\n", name, row.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(const uint8_t*,uint8_t*);\n", name)
+		fmt.Fprintf(&declarations, `static int observe%d(const uint8_t *input) {
+    uint8_t output[66];
+    memset(output, 0xc3, sizeof(output));
+    %s(input, output + 1);
+    if (output[0] != 0xc3 || output[65] != 0xc3) return 1;
+    for (unsigned i = 1; i <= 64; ++i) if (output[i]) return 2;
+    return 0;
+}
+`, index, name)
+		fmt.Fprintf(&rows, "{observe%d, %d, %d},\n", index, row.bytes, row.bytes-1)
+	}
+	return assembly.String(), sigs, declarations.String(), rows.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedUnpackZeroMaskStillFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, sigs, declarations, rows := x86PackedUnpackFaultProgram()
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86MemoryFaultDriver(declarations, rows)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "unpack-e4nf-fault", ir, main, level)
+			x86CheckMemoryFaultMatrix(t, execution, executable, 4)
+		})
+	}
+}
diff --git a/amd64_packed_unpack_forms.go b/amd64_packed_unpack_forms.go
new file mode 100644
index 000000000..8f454983c
--- /dev/null
+++ b/amd64_packed_unpack_forms.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import "strings"
+
+type x86PackedUnpackSpec struct {
+	laneBits int
+	high     bool
+	grammar  x86PackedBinarySpec
+}
+
+// Go's six ymm rows include MMX. Its other six legacy rows use yxm.
+// All twelve vector rows use _yvandnpd, but only D/Q/PS/PD permit BCST.
+// Their EVEX memory exception class is E4NF: masking does not suppress faults.
+var x86PackedUnpackSpecs = map[Op]x86PackedUnpackSpec{
+	"PUNPCKLBW":   {8, false, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKHBW":   {8, true, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKLWL":   {16, false, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKHWL":   {16, true, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKLLQ":   {32, false, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKHLQ":   {32, true, x86PackedBinarySpec{x86PackedLogicalLegacyInteger, 0, false}},
+	"PUNPCKLQDQ":  {64, false, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"PUNPCKHQDQ":  {64, true, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"UNPCKLPS":    {32, false, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"UNPCKHPS":    {32, true, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"UNPCKLPD":    {64, false, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"UNPCKHPD":    {64, true, x86PackedBinarySpec{x86PackedLogicalLegacyFP, 0, false}},
+	"VPUNPCKLBW":  {8, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 0, true}},
+	"VPUNPCKHBW":  {8, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 0, true}},
+	"VPUNPCKLWD":  {16, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 0, true}},
+	"VPUNPCKHWD":  {16, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 0, true}},
+	"VPUNPCKLDQ":  {32, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 4, true}},
+	"VPUNPCKHDQ":  {32, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 4, true}},
+	"VPUNPCKLQDQ": {64, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 8, true}},
+	"VPUNPCKHQDQ": {64, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 8, true}},
+	"VUNPCKLPS":   {32, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 4, true}},
+	"VUNPCKHPS":   {32, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 4, true}},
+	"VUNPCKLPD":   {64, false, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 8, true}},
+	"VUNPCKHPD":   {64, true, x86PackedBinarySpec{x86PackedLogicalVEXOrEVEX, 8, true}},
+}
+
+type x86PackedUnpackForm struct {
+	x86PackedBinaryForm
+	spec   x86PackedUnpackSpec
+	source Operand
+}
+
+// Pure byte dependencies shared by independent caller and result observers.
+// Memory access, register mode, mask and alignment roles remain prerequisites
+// of each consumer; no dependency mask shrinks a native memory operation.
+func x86PackedUnpackDefinedBytes(form x86PackedUnpackForm, first, second, old uint64) uint64 {
+	laneBytes := form.spec.laneBits / 8
+	groupBytes := 16
+	if form.byteWidth < groupBytes {
+		groupBytes = form.byteWidth
+	}
+	half := groupBytes / 2
+	start := 0
+	if form.spec.high {
+		start = half
+	}
+	var known uint64
+	for group := 0; group < form.byteWidth; group += groupBytes {
+		for offset := 0; offset < half; offset += laneBytes {
+			for byteIndex := 0; byteIndex < laneBytes; byteIndex++ {
+				source := uint(group + start + offset + byteIndex)
+				destination := uint(group + 2*offset + byteIndex)
+				known |= (second >> source & 1) << destination
+				known |= (first >> source & 1) << (destination + uint(laneBytes))
+			}
+		}
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known &= old
+	}
+	return known
+}
+
+func x86PackedUnpackProperties(ins Instr, goarch string) (x86PackedUnpackForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86PackedUnpackSpecs[Op(base)]
+	if !recognized {
+		return x86PackedUnpackForm{}, false, nil
+	}
+	local := ins
+	if spec.grammar.encoding == x86PackedLogicalLegacyInteger {
+		var err error
+		local, err = x86LegacyMMXReadInstruction(ins, goarch)
+		if err != nil {
+			return x86PackedUnpackForm{}, true, err
+		}
+	}
+	form, err := x86PackedBinaryProperties(local, goarch, spec.grammar)
+	// Intel's three MMX low-unpack rows are mm/m32, unlike the high
+	// rows' mm/m64. The unused high source half is not a memory access.
+	if err == nil && form.mmx && form.memory >= 0 && !spec.high {
+		form.memoryBytes = 4
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(ins, goarch)
+	}
+	result := x86PackedUnpackForm{x86PackedBinaryForm: form, spec: spec}
+	if err == nil {
+		result.source = local.Args[form.first]
+	}
+	return result, true, err
+}
diff --git a/amd64_packed_unpack_forms_test.go b/amd64_packed_unpack_forms_test.go
new file mode 100644
index 000000000..f2c403582
--- /dev/null
+++ b/amd64_packed_unpack_forms_test.go
@@ -0,0 +1,387 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86UnpackTestLaneBytes(opcode string) int {
+	switch {
+	case strings.HasSuffix(opcode, "BW"):
+		return 1
+	case strings.HasSuffix(opcode, "WL"), strings.HasSuffix(opcode, "WD"):
+		return 2
+	case strings.HasSuffix(opcode, "LQ"), strings.HasSuffix(opcode, "DQ") && !strings.HasSuffix(opcode, "QDQ"), strings.HasSuffix(opcode, "PS"):
+		return 4
+	default:
+		return 8
+	}
+}
+
+func TestX86PackedUnpack386EVEXHighRegistersActualBytesNeedContext(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if !strings.HasPrefix(opcode, "V") {
+			continue
+		}
+		decode := decodedX86FloatingUnpackInstruction
+		if strings.HasPrefix(opcode, "VPUNPCK") {
+			decode = decodedX86EVEXPackedUnpackInstruction
+		}
+		for _, bank := range []string{"X", "Y"} {
+			for _, high := range []int{16, 31} {
+				for index := 0; index < 3; index++ {
+					args := []string{bank + "0", bank + "1", bank + "2"}
+					args[index] = fmt.Sprintf("%s%d", bank, high)
+					row := opcode + " " + strings.Join(args, ",")
+					listing, err := x86ExtensionGoListing(t, "386", row)
+					if err != nil {
+						t.Fatalf("actual Go mode32 object: %v\n%s", err, listing)
+					}
+					var code []byte
+					for _, line := range strings.Split(listing, "\n") {
+						fields := strings.Fields(line)
+						if len(fields) < 7 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+							continue
+						}
+						for _, field := range fields[1:7] {
+							value, err := strconv.ParseUint(field, 16, 8)
+							if err != nil {
+								t.Fatalf("actual Go object byte %q: %v", field, err)
+							}
+							code = append(code, byte(value))
+						}
+						break
+					}
+					if len(code) != 6 || code[0] != 0x62 {
+						t.Fatalf("actual Go lost EVEX encoding: %s\n%s", row, listing)
+					}
+					ins, length, recognized, err := decode(code, 64)
+					if !recognized || err != nil || length != len(code) || ins.Op != Op(opcode) || len(ins.Args) != 3 {
+						t.Fatalf("mode64 actual byte identity: %s/%x: %+v/%d/%t/%v", row, code, ins, length, recognized, err)
+					}
+					for index, argument := range args {
+						if ins.Args[index].Reg != Reg(argument) {
+							t.Fatalf("actual Go %x decoded argument %d as %s want %s", code, index, ins.Args[index].Reg, argument)
+						}
+					}
+					if _, _, recognized, err := decode(code, 32); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s/%x invented raw mode32 high registers: %t/%v", row, code, recognized, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedUnpack386NamedHighRegistersKeepPhysicalContext(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if !strings.HasPrefix(opcode, "V") {
+			continue
+		}
+		for _, bank := range []string{"X", "Y"} {
+			for _, high := range []int{8, 15, 16, 31} {
+				for index := 0; index < 3; index++ {
+					args := []string{bank + "0", bank + "1", bank + "2"}
+					args[index] = fmt.Sprintf("%s%d", bank, high)
+					row := opcode + " " + strings.Join(args, ",")
+					// This invokes the actual Go tool on both compatibility
+					// versions. Syntax acceptance alone is not a native binding.
+					listing, err := x86ExtensionGoListing(t, "386", row)
+					if err != nil || !strings.Contains(listing, row[:len(opcode)]) {
+						t.Fatalf("actual Go lost accepted mode32 source %s: %v\n%s", row, err, listing)
+					}
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+						if _, err := Translate(file, Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("%s named high register acquired a physical mode32 binding: %v", row, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86UnpackTestHasMMX(opcode string) bool {
+	return strings.HasPrefix(opcode, "PUNPCK") && !strings.HasSuffix(opcode, "QDQ")
+}
+
+func x86UnpackAcceptedForms(opcode, arch string) []string {
+	if !strings.HasPrefix(opcode, "V") {
+		last := 15
+		if arch == "386" {
+			last = 7
+		}
+		rows := []string{fmt.Sprintf("%s X0,X%d", opcode, last), fmt.Sprintf("%s 8(AX),X%d", opcode, last)}
+		if arch == "amd64" && x86UnpackTestHasMMX(opcode) {
+			rows = append(rows, opcode+" M0,M7", opcode+" 8(AX),M7")
+		}
+		return rows
+	}
+	var rows []string
+	for _, bank := range []string{"X", "Y", "Z"} {
+		last := 31
+		if arch == "386" {
+			last = 7
+		}
+		for _, first := range []string{bank + "0", "8(AX)"} {
+			rows = append(rows, fmt.Sprintf("%s %s,%s1,%s%d", opcode, first, bank, bank, last))
+			if arch == "amd64" {
+				rows = append(rows,
+					fmt.Sprintf("%s %s,%s1,K7,%s%d", opcode, first, bank, bank, last),
+					fmt.Sprintf("%s.Z %s,%s1,K1,%s%d", opcode, first, bank, bank, last))
+			}
+		}
+		if x86UnpackTestLaneBytes(opcode) >= 4 {
+			rows = append(rows, fmt.Sprintf("%s.BCST 8(AX),%s1,%s%d", opcode, bank, bank, last))
+			if arch == "amd64" {
+				rows = append(rows,
+					fmt.Sprintf("%s.BCST 8(AX),%s1,K7,%s%d", opcode, bank, bank, last),
+					fmt.Sprintf("%s.BCST.Z 8(AX),%s1,K1,%s%d", opcode, bank, bank, last))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedUnpackSpecsBindEveryGoOpcodeAttribute(t *testing.T) {
+	if len(x86PackedUnpackSpecs) != len(x86CallerUnpackOpcodes()) {
+		t.Fatal("incomplete interleave family")
+	}
+	dir := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		spec, ok := x86PackedUnpackSpecs[Op(opcode)]
+		if !ok || spec.laneBits != 8*x86UnpackTestLaneBytes(opcode) {
+			t.Fatalf("missing or wrong source-defined lane width: %s", opcode)
+		}
+		if !strings.HasPrefix(opcode, "V") {
+			start := strings.Index(string(legacy), "{A"+opcode+", ")
+			if start < 0 {
+				t.Fatalf("actual Go omits %s", opcode)
+			}
+			line := strings.SplitN(string(legacy)[start:], "\n", 2)[0]
+			table := "yxm"
+			if x86UnpackTestHasMMX(opcode) {
+				table = "ymm"
+			}
+			if !strings.Contains(line, ", "+table+",") {
+				t.Fatalf("actual Go table differs for %s: %s", opcode, line)
+			}
+			continue
+		}
+		prefix := "{as: A" + opcode + ", ytab: _yvandnpd,"
+		start := strings.Index(string(avx), prefix)
+		if start < 0 {
+			t.Fatalf("actual Go omits %s family table", opcode)
+		}
+		row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if strings.Count(row, "avxEscape | vex") != 2 || strings.Count(row, "avxEscape | evex") != 3 {
+			t.Fatalf("actual Go encoding generations changed: %s", row)
+		}
+		for _, line := range strings.Split(row, "\n") {
+			if !strings.Contains(line, "avxEscape | evex") {
+				continue
+			}
+			broadcast := ""
+			if x86UnpackTestLaneBytes(opcode) >= 4 {
+				broadcast = fmt.Sprintf("evexBcstN%d", x86UnpackTestLaneBytes(opcode))
+			}
+			if !strings.Contains(line, "evexZeroingEnabled") || strings.Contains(line, "evexSae") || strings.Contains(line, "evexRounding") ||
+				broadcast == "" && strings.Contains(line, "evexBcst") || broadcast != "" && !strings.Contains(line, broadcast) {
+				t.Fatalf("actual opcode attributes differ: %s", line)
+			}
+		}
+	}
+}
+
+func TestX86PackedUnpackCompleteGoRowsAndFiveLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT unpackforms(SB),4,$0-0\n")
+			count := 0
+			for _, opcode := range x86CallerUnpackOpcodes() {
+				for _, row := range x86UnpackAcceptedForms(opcode, target.arch) {
+					count++
+					fmt.Fprintln(&source, row)
+				}
+			}
+			source.WriteString("RET\n")
+			requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, ins := range file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1] {
+				if _, recognized, err := x86PackedUnpackProperties(ins, target.arch); !recognized || err != nil {
+					t.Fatalf("actual Go accepted %s but grammar rejected: %v", ins.Raw, err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func unpackforms()", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original unpack formats invented missing numerical/native inputs", api, err)
+				}
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{"unpackforms": {Name: "unpackforms", Ret: Void}},
+				target.arch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPackedUnpack(ins.Op, ins)
+				})
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+			t.Logf("all %d original Go forms retain emitter-only LLVM22 objects and three-API Context controls", count)
+		})
+	}
+}
+
+func TestX86PackedUnpackDispatchIdentityBeforeEmission(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nVPUNPCKLBW X0,X1,X2\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range []Op{"VPUNPCKLBW", "vpunpcklbw"} {
+		for _, sourceOp := range []Op{"", "VPUNPCKLBW", "vpunpcklbw", "VPUNPCKHBW", "UNKNOWN"} {
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			ins := file.Funcs[0].Instrs[1]
+			ins.Op = sourceOp
+			_, _, err := ctx.lowerPackedUnpack(opcode, ins)
+			wantError := sourceOp == "VPUNPCKHBW" || sourceOp == "UNKNOWN"
+			if (err != nil) != wantError || wantError && output.String() != before || !wantError && output.String() == before {
+				t.Fatalf("dispatch identity %s/%s: %v, %d emitted bytes", opcode, sourceOp, err, output.Len())
+			}
+		}
+	}
+}
+
+func TestX86PackedUnpackRejectsMalformedGoFormsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range x86CallerUnpackOpcodes() {
+			rows := []string{opcode + " X0,(AX)", opcode + ".SAE X0,X1"}
+			if strings.HasPrefix(opcode, "V") {
+				rows = []string{
+					opcode + " X0,X1,(AX)",
+					opcode + " X0,Y1,Y2",
+					opcode + " X0,X1,K0,X2",
+					opcode + ".Z X0,X1,X2",
+					opcode + ".SAE X0,X1,X2",
+					opcode + ".BCST X0,X1,X2",
+				}
+				if x86UnpackTestLaneBytes(opcode) < 4 {
+					rows = append(rows, opcode+".BCST (AX),X1,X2")
+				}
+			} else {
+				rows = append(rows, opcode+" X0,Y1")
+				if arch == "386" {
+					rows = append(rows, opcode+" X8,X1")
+				}
+			}
+			for _, row := range rows {
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					source := "TEXT bad(SB),4,$0-0\n" + row + "\nRET\n"
+					requireX86GoAssemblerResult(t, arch, source, false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						return
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := output.String()
+					ins := file.Funcs[0].Instrs[1]
+					known, _, err := ctx.lowerPackedUnpack(ins.Op, ins)
+					if !known || err == nil || output.String() != before {
+						t.Fatalf("malformed source emitted IR: known=%t err=%v", known, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedUnpackMMXMemoryNativeExtent(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if !x86UnpackTestHasMMX(opcode) {
+			continue
+		}
+		source := "TEXT f(SB),4,$0-0\n" + opcode + " (AX),M0\nRET\n"
+		requireX86GoAssemblerResult(t, "amd64", source, true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		form, recognized, err := x86PackedUnpackProperties(file.Funcs[0].Instrs[1], "amd64")
+		want := 4
+		if strings.Contains(opcode, "UNPCKH") {
+			want = 8
+		}
+		if !recognized || err != nil || !form.mmx || form.memoryBytes != want {
+			t.Fatalf("%s native memory extent=%d want=%d: %v", opcode, form.memoryBytes, want, err)
+		}
+	}
+}
+
+func TestX86PackedUnpackTypedFPMemoryExtentBeforeEmission(t *testing.T) {
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		for _, row := range x86UnpackAcceptedForms(opcode, "amd64") {
+			if !strings.Contains(row, "8(AX)") {
+				continue
+			}
+			row = strings.Replace(row, "8(AX)", "a+0(FP)", 1)
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, _, err := x86PackedUnpackProperties(ins, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, complete := range []bool{false, true} {
+				sig := FuncSig{Ret: Void}
+				for offset := 0; offset < form.memoryBytes; offset += 4 {
+					if !complete && offset+4 == form.memoryBytes {
+						break
+					}
+					index := len(sig.Args)
+					sig.Args = append(sig.Args, I32)
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(offset), Type: I32, Index: index, Field: -1})
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+				before := output.String()
+				known, _, err := ctx.lowerPackedUnpack(ins.Op, ins)
+				if form.legacy && !form.mmx {
+					if !known || !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+						t.Fatal("logical FP bytes invented original legacy native alignment", row, err)
+					}
+					continue
+				}
+				if !known || complete && err != nil || !complete && (err == nil || output.String() != before) {
+					t.Fatalf("%s complete=%t native bytes=%d: %v", row, complete, form.memoryBytes, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_unpack_go_oracle_test.go b/amd64_packed_unpack_go_oracle_test.go
new file mode 100644
index 000000000..2e90d3993
--- /dev/null
+++ b/amd64_packed_unpack_go_oracle_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedUnpackOriginalGoBitOracle(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\n")
+	tests.WriteString(`package oracle
+import "testing"
+func TestOriginalGoInterleaveBits(t *testing.T) {
+ patterns:=[][16]byte{
+  {0x45,0x23,0x81,0x7f,0x78,0x56,0xc4,0xff,0xbc,0x9a,0x78,0x56,0x34,0x12,0xf0,0x7f},
+  {0x54,0x76,0x98,0xba,0xdc,0xfe,0xf8,0xff,0x45,0x23,0xc1,0x7f,0,0,0,0x80},
+  {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15},
+  {0xff,0xfe,0xfd,0xfc,0xfb,0xfa,0xf9,0xf8,0xf7,0xf6,0xf5,0xf4,0xf3,0xf2,0xf1,0xf0},
+ }
+`)
+	count := 0
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if strings.HasPrefix(opcode, "V") {
+			continue // Native VEX/EVEX execution needs separate ISA witnesses.
+		}
+		banks := []string{"X"}
+		if x86UnpackTestHasMMX(opcode) {
+			banks = append(banks, "M")
+		}
+		for _, bank := range banks {
+			forms := []string{"register"}
+			if bank == "M" {
+				forms = append(forms, "memory")
+			}
+			for _, form := range forms {
+				name := fmt.Sprintf("unpack%d", count)
+				count++
+				fmt.Fprintf(&declarations, "func %s(a,b,out *byte,csr uint32)\n", name)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+24(FP)\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),CX\n", name)
+				move, bytes := "MOVOU", 16
+				if bank == "M" {
+					move, bytes = "MOVQ", 8
+				}
+				fmt.Fprintf(&assembly, "%s (BX),%s0\n", move, bank)
+				first := bank + "1"
+				if form == "register" {
+					fmt.Fprintf(&assembly, "%s (AX),%s1\n", move, bank)
+				} else {
+					first = "(AX)"
+				}
+				fmt.Fprintf(&assembly, "CMPQ AX,AX\nSTC\n%s %s,%s0\n%s %s0,(CX)\nSETCS 16(CX)\nSETNE 17(CX)\nSTMXCSR 18(CX)\n", opcode, first, bank, move, bank)
+				if bank == "M" {
+					assembly.WriteString("EMMS\n")
+				}
+				assembly.WriteString("LDMXCSR saved-4(SP)\nRET\n")
+				high := 0
+				if strings.Contains(opcode, "UNPCKH") {
+					high = bytes / 2
+				}
+				fmt.Fprintf(&tests, `
+ for _,a:=range patterns { for _,b:=range patterns { for mode:=0;mode<4;mode++ {
+  var out [24]byte
+  for i:=range out {out[i]=0xc3}
+  csr:=uint32(0x1f80|mode<<13|mode)
+  %[1]s(&a[0],&b[0],&out[1],csr)
+  if out[0]!=0xc3 || out[23]!=0xc3 || out[17]!=1 || out[18]!=0 {t.Fatalf("%[1]s canary/flags: %%x",out)}
+  gotCSR:=uint32(out[19])|uint32(out[20])<<8|uint32(out[21])<<16|uint32(out[22])<<24
+  if gotCSR!=csr {t.Fatalf("%[1]s changed MXCSR %%x want %%x",gotCSR,csr)}
+  for i:=0;i<16;i++ {
+   want:=byte(0xc3)
+   if i<%[2]d {
+    source:=%[3]d+(i/(2*%[4]d))*%[4]d+i%%%[4]d
+    want=b[source]
+    if i/%[4]d%%2!=0 {want=a[source]}
+   }
+   if out[i+1]!=want {t.Fatalf("%[1]s byte %%d got %%x want %%x",i,out[i+1],want)}
+  }
+ } } }
+`, name, bytes, high, x86UnpackTestLaneBytes(opcode))
+			}
+		}
+	}
+	tests.WriteString("}\n")
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":   "module oracle\n\ngo 1.20\n",
+		"value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go interleave bit oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d original SSE/MMX Go functions; 64 independent bitwise/MXCSR/flag/canary inputs each", count)
+}
diff --git a/amd64_packed_unpack_mmx_runtime_test.go b/amd64_packed_unpack_mmx_runtime_test.go
new file mode 100644
index 000000000..c94e9295c
--- /dev/null
+++ b/amd64_packed_unpack_mmx_runtime_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedUnpackMMXNativeProgram() (string, map[string]FuncSig, string, string, int) {
+	var assembly, declarations, rows strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		if !x86UnpackTestHasMMX(opcode) {
+			continue
+		}
+		name, fpName := fmt.Sprintf("unpackmmx%d", count), fmt.Sprintf("unpackmmxfp%d", count)
+		count++
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-24\nMOVQ input+0(FP),AX\nMOVQ second+8(FP),M0\n%s (AX),M0\nMOVQ M0,ret+16(FP)\nEMMS\nRET\n", name, opcode)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64}, Ret: I64, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+		}}
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-16\nMOVQ $0,AX\nMOVQ AX,M0\n%s a+0(FP),M0\nMOVQ M0,ret+8(FP)\nEMMS\nRET\n", fpName, opcode)
+		sigs[fpName] = FuncSig{Name: fpName, Args: []LLVMType{I32, I32}, Ret: I64, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}}
+		fmt.Fprintf(&declarations, "extern uint64_t %s(const uint8_t*,uint64_t);\nextern uint64_t %s(uint32_t,uint32_t);\n", name, fpName)
+		high, extent := 0, 4
+		if strings.Contains(opcode, "UNPCKH") {
+			high, extent = 4, 8
+		}
+		fmt.Fprintf(&rows, "{%s, %s, %d, %d, %d},\n", name, fpName, x86UnpackTestLaneBytes(opcode), high, extent)
+	}
+	return assembly.String(), sigs, declarations.String(), rows.String(), count
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedUnpackMMXNativeMemoryAndFP(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	assembly, sigs, declarations, rows, count := x86PackedUnpackMMXNativeProgram()
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86MemoryFaultSupportC + declarations + `
+static const struct {
+ uint64_t (*run)(const uint8_t*,uint64_t);
+ uint64_t (*fp)(uint32_t,uint32_t);
+ int lane, high, extent;
+} cases[] = {
+` + rows + `};
+static uint64_t expectedMMX(const uint8_t *first,uint64_t second,int lane,int high) {
+ uint8_t old[8],out[8];
+ memcpy(old,&second,8);
+ for(int i=0;i<8;++i) {
+  int source=high+(i/(2*lane))*lane+i%lane;
+  out[i]=(i/lane)%2 ? first[source] : old[source];
+ }
+ uint64_t value;
+ memcpy(&value,out,8);
+ return value;
+}
+struct MMXModeImage { _Alignas(16) uint8_t bytes[512]; };
+static void beginMMXMode(uint16_t *oldControl,uint32_t *oldCSR) {
+ const uint16_t control=0x077f;
+ const uint32_t csr=0x5f80;
+ __asm__ volatile("fnstcw %0; stmxcsr %1; fninit; fldcw %2; ldmxcsr %3; "
+  "pcmpeqd %%mm0,%%mm0; pcmpeqd %%mm6,%%mm6; emms; fld1"
+  : "=m"(*oldControl),"=m"(*oldCSR) : "m"(control),"m"(csr)
+  : "mm0","mm6","st","memory");
+}
+static int endMMXMode(uint64_t result,uint16_t control,uint32_t csr) {
+ struct MMXModeImage image;
+ __asm__ volatile("fxsave64 %0; fninit; fldcw %1; ldmxcsr %2"
+  : "=m"(image) : "m"(control),"m"(csr) : "st","memory");
+ uint16_t actualControl,status;
+ uint32_t actualCSR;
+ uint64_t actualResult,canary;
+ memcpy(&actualControl,image.bytes,2);
+ memcpy(&status,image.bytes+2,2);
+ memcpy(&actualCSR,image.bytes+24,4);
+ memcpy(&actualResult,image.bytes+32,8);
+ memcpy(&canary,image.bytes+32+6*16,8);
+ return actualControl==0x077f && (status&0x3800)==0 && image.bytes[4]==0 &&
+  actualCSR==0x5f80 && actualResult==result && canary==UINT64_MAX;
+}
+static int checkMMXModeObserver(void) {
+ for(int mutation=0;mutation<3;mutation++) {
+  uint16_t control;
+  uint32_t csr;
+  beginMMXMode(&control,&csr);
+  if(mutation==0) {
+   __asm__ volatile("emms" : : : "st","memory");
+  } else if(mutation==1) {
+   __asm__ volatile("pxor %%mm0,%%mm0" : : : "mm0","st","memory");
+  } else {
+   __asm__ volatile("pxor %%mm0,%%mm0; emms" : : : "mm0","st","memory");
+  }
+  if(endMMXMode(0,control,csr)!=(mutation==2)) return 1;
+ }
+ return 0;
+}
+static int checkMMX(uint64_t (*program)(const uint8_t*,uint64_t),
+ uint64_t (*fp)(uint32_t,uint32_t),int lane,int high,int extent,uint8_t *end) {
+ for(int seed=0;seed<16;++seed) {
+  uint8_t *first=end-extent,source[8];
+  for(int i=0;i<8;++i) source[i]=(uint8_t)(seed*73+i*19+7);
+  memcpy(first,source,extent);
+  uint64_t second=UINT64_C(0xcafe11223344ba5e)^((uint64_t)seed*UINT64_C(0x1234567890));
+  uint16_t control;
+  uint32_t csr;
+  beginMMXMode(&control,&csr);
+  uint64_t result=program(first,second);
+  if(!endMMXMode(result,control,csr)) return 1;
+  if(result!=expectedMMX(source,second,lane,high) || memcmp(first,source,extent)) return 1;
+  uint32_t a,b;
+  memcpy(&a,source,4);
+  memcpy(&b,source+4,4);
+  beginMMXMode(&control,&csr);
+  result=fp(a,b);
+  if(!endMMXMode(result,control,csr) || result!=expectedMMX(source,0,lane,high)) return 1;
+ }
+ return 0;
+}
+int main(int argc, char **argv) {
+    if (argc != 4) return 80;
+    if (checkMMXModeObserver()) return 92;
+    unsigned row = (unsigned)atoi(argv[1]);
+    unsigned probe = (unsigned)atoi(argv[2]);
+    unsigned original = (unsigned)atoi(argv[3]);
+    if (row >= sizeof(cases)/sizeof(cases[0]) || probe > 3 || original > 1) return 80;
+    int setup = memory_fault_setup(1);
+    if (setup) return setup;
+    uint8_t *end = guard + page;
+    const uint8_t *input = NULL;
+    if (probe == 1) input = end - cases[row].extent + 1;
+    if (probe == 2) input = end - cases[row].extent;
+    if (probe == 3) input = cases[row].high ? guard - 4 : end - 3;
+
+    printf("memory enter %u %u %u\n", row, probe, original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        const volatile uint8_t *source = input;
+        volatile uint8_t sink = 0;
+        for (int i = 0; i < cases[row].extent; ++i) sink ^= source[i];
+    } else if (probe == 2) {
+        if (checkMMX(cases[row].run, cases[row].fp, cases[row].lane,
+                cases[row].high, cases[row].extent, end)) return 91;
+    } else {
+        volatile uint64_t observed = cases[row].run(input, UINT64_C(0xabcdef1234567890));
+        (void)observed;
+    }
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout) ? 85 : 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "unpack-mmx-native-memory-fp", ir, main, level)
+			x86MMXExportNativeFixture(t, executable, assembly, ir, level, execution.triple, count)
+			x86CheckMemoryFaultMatrix(t, execution, executable, count)
+			for row := 0; row < count; row++ {
+				want := x86ObserveMemoryFault(t, execution, executable, row, 3, 1)
+				if want != "segv" && want != "bus" {
+					t.Fatalf("row %d: independent leading/short read did not fault: %s", row, want)
+				}
+				if got := x86ObserveMemoryFault(t, execution, executable, row, 3, 0); got != want {
+					t.Fatalf("row %d: translated leading/short read %s, want %s", row, got, want)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_packed_unpack_runtime_test.go b/amd64_packed_unpack_runtime_test.go
new file mode 100644
index 000000000..230412238
--- /dev/null
+++ b/amd64_packed_unpack_runtime_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// One independent reference is shared by all format programs. Keeping this
+// out of main avoids compiling hundreds of copies of the same canary loops.
+const x86UnpackBitwiseRuntimeOracle = `
+static uint8_t patterns[4][64];
+static const uint64_t masks[]={0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+__attribute__((noinline)) static int checkUnpack(
+ void (*program)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t),
+ const char *name,int width,int lane,int high,int mode,int broadcast,int legacy,int destination,int shift) {
+ for(int round=0;round<4;++round) for(int m=0;m<4;++m) {
+  _Alignas(64) uint8_t aStorage[96],bStorage[96],output[68];
+  uint8_t *a=aStorage+shift,*b=bStorage+3;
+  memset(aStorage,0xa7,sizeof(aStorage));
+  memset(bStorage,0xb9,sizeof(bStorage));
+  memset(output,0xc3,sizeof(output));
+  memcpy(a,patterns[round],64);
+  memcpy(b,patterns[(round+1)%4],64);
+  uint64_t mask=masks[m];
+  uint32_t saved,before=0x1f80|(round<<13)|round,after;
+  __asm__ volatile("stmxcsr %0" : "=m"(saved));
+  __asm__ volatile("ldmxcsr %0" : : "m"(before));
+  program(output+1,a,b,mask);
+  __asm__ volatile("stmxcsr %0" : "=m"(after));
+  __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+  if(after!=before || output[0]!=0xc3 || output[67]!=0xc3 || output[65]!=1 || output[66]!=0) {
+   fprintf(stderr,"%s round=%d mask=%llx CSR/flags/canary failure\n",name,round,(unsigned long long)mask);
+   return 1;
+  }
+  for(int i=0;i<64;++i) {
+   int source=(i/16)*16+high+((i%16)/(2*lane))*lane+i%lane;
+   uint8_t selected=(i/lane)%2 ? a[broadcast ? source%lane : source] : b[source];
+   const uint8_t *old=destination==1 ? a : b;
+   int active=mode==0 || ((mask>>(i/lane))&1);
+   uint8_t want=i<width ? (active ? selected : (mode==2 ? 0 : old[i])) : (legacy ? b[i] : 0);
+   if(output[i+1]!=want || a[i]!=patterns[round][i] || b[i]!=patterns[(round+1)%4][i]) {
+    fprintf(stderr,"%s round=%d mask=%llx byte=%d got=%x want=%x\n",name,round,(unsigned long long)mask,i,output[i+1],want);
+    return 1;
+   }
+  }
+  for(int i=0;i<96;++i) {
+   if((i<shift || i>=shift+64) && aStorage[i]!=0xa7) return 1;
+   if((i<3 || i>=67) && bStorage[i]!=0xb9) return 1;
+  }
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedUnpackCompleteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, opcode := range x86CallerUnpackOpcodes() {
+		legacy := !strings.HasPrefix(opcode, "V")
+		widths := []int{16}
+		if !legacy {
+			widths = []int{16, 32, 64}
+		}
+		lane := x86UnpackTestLaneBytes(opcode)
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, memory := range []string{"register", "memory", "broadcast"} {
+				if memory == "broadcast" && (legacy || lane < 4) {
+					continue
+				}
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					if legacy && mode != "unmasked" {
+						continue
+					}
+					for _, destination := range []int{0, 1, 2} {
+						if legacy && destination != 0 {
+							continue
+						}
+						name := fmt.Sprintf("unpack%d", count)
+						count++
+						first := bank + "1"
+						if memory != "register" {
+							first = "(BX)"
+						}
+						operation := opcode
+						if memory == "broadcast" {
+							operation += ".BCST"
+						}
+						if mode == "zero" {
+							operation += ".Z"
+						}
+						row := operation + " " + first + "," + bank + "0"
+						if !legacy {
+							if mode != "unmasked" {
+								row += ",K1"
+							}
+							row += fmt.Sprintf(",%s%d", bank, destination)
+						}
+						fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (CX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nCMPQ AX,AX\nSTC\n%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", name, row, destination)
+						sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+							{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+							{Offset: 24, Type: I64, Index: 3, Field: -1},
+						}}}
+						fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+						high := 0
+						if strings.Contains(opcode, "UNPCKH") {
+							high = 8
+						}
+						// Legacy m128 requires aligned storage. All other forms
+						// exercise unaligned input/output pointers and canaries.
+						shift := 1
+						if legacy && memory == "memory" {
+							shift = 16
+						}
+						modeValue := map[string]int{"unmasked": 0, "merge": 1, "zero": 2}[mode]
+						fmt.Fprintf(&checks, "if(checkUnpack(%s,\"%s\",%d,%d,%d,%d,%d,%d,%d,%d)) return 1;\n", name, name,
+							width, lane, high, modeValue, x86FloatAddSubBoolInt(memory == "broadcast"), x86FloatAddSubBoolInt(legacy), destination, shift)
+					}
+				}
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+` + declarations.String() + x86UnpackBitwiseRuntimeOracle + `
+int main(void) {
+ for(int p=0;p<4;++p) for(int i=0;i<64;++i) patterns[p][i]=(uint8_t)(i*19+p*83+7);
+ // These include float32/float64 signaling/quiet NaN payloads. An unpack
+ // must copy their exact bits and leave even pre-existing MXCSR flags alone.
+ const uint64_t specials[]={UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff8fedcba987654),UINT64_C(0x7f812345ffc45678),UINT64_C(0x800000007fc12345)};
+ memcpy(patterns[2],specials,sizeof(specials));
+ memcpy(patterns[3]+32,specials,sizeof(specials));
+` + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "unpack-complete", triple, ir, main, prefix)
+	t.Logf("%d opcode/width/memory/mask/alias programs, 16 independent bitwise/MXCSR/flag/canary inputs each", count)
+}
diff --git a/amd64_packed_vector_move_aligned.go b/amd64_packed_vector_move_aligned.go
new file mode 100644
index 000000000..2cb1a24cf
--- /dev/null
+++ b/amd64_packed_vector_move_aligned.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Alignment faults are part of the original instruction, including its exact
+// mask and zeroing behavior. Neither LLVM align metadata nor a masked load can
+// replace this operation: the former asserts alignment instead of checking it,
+// and the latter can remove a dead read. Pass an opaque address in a register,
+// without granting the optimizer any pointee, extent or alignment assumption.
+// Intel SDM Vol. 2A Table 2-46 keeps E1 alignment separate from page-fault
+// suppression; the runtime oracle compares both against original Go opcodes.
+func (c *amd64Ctx) lowerAlignedPackedMoveMemory(ins Instr, form amd64PackedVectorMoveForm) error {
+	return c.lowerNativeAlignedVectorMemory(ins, form, false)
+}
+
+func (c *amd64Ctx) lowerNativeAlignedVectorMemory(ins Instr, form amd64PackedVectorMoveForm, legacy bool) error {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(ins.Args[form.memory])
+	if err != nil {
+		return err
+	}
+	segment := ""
+	if pointerType == "ptr addrspace(256)" {
+		segment = "%gs:"
+	} else if pointerType == "ptr addrspace(257)" {
+		segment = "%fs:"
+	}
+	name, _, _ := strings.Cut(strings.ToLower(string(ins.Op)), ".")
+	constraint, prefix := "x", ""
+	if form.nativeEVEX(ins) {
+		constraint = "v"
+		// Retain EVEX for high source registers even if LLVM allocates a low
+		// carrier. APD/APS otherwise also have a VEX encoding at X/Y widths.
+		prefix = "{evex} "
+	}
+	vectorType := fmt.Sprintf("<%d x float>", form.byteWidth/4)
+	vector := func(operand Operand) (string, error) {
+		value, err := c.loadPackedCompareBytes(operand, form.byteWidth)
+		if err != nil {
+			return "", err
+		}
+		carrier := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", carrier, form.byteWidth, value, vectorType)
+		return "%" + carrier, nil
+	}
+	mask := ""
+	if form.mask >= 0 {
+		value, err := c.loadK(ins.Args[form.mask].Reg)
+		if err != nil {
+			return err
+		}
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, value)
+		mask = "%" + narrow
+	}
+	if form.memoryWrite {
+		value, err := vector(ins.Args[0])
+		if err != nil {
+			return err
+		}
+		assembly := prefix + name + " $0, " + segment + "($1)"
+		constraints := constraint + ",r"
+		arguments := fmt.Sprintf("%s %s, %s %s", vectorType, value, pointerType, pointer)
+		if mask != "" {
+			assembly = "kmovw ${2:k}, %k1; " + assembly + " {%k1}"
+			constraints += ",r,~{k1}"
+			arguments += ", i32 " + mask
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n", assembly, constraints+",~{memory}", arguments)
+		return nil
+	}
+	assembly := prefix + name + " " + segment + "($1), $0"
+	constraints := "=" + constraint + ",r"
+	arguments := pointerType + " " + pointer
+	if mask != "" {
+		if form.zeroing {
+			assembly = "kmovw ${2:k}, %k1; " + assembly + " {%k1} {z}"
+		} else {
+			old, err := vector(ins.Args[form.destination])
+			if err != nil {
+				return err
+			}
+			assembly = "kmovw ${3:k}, %k1; " + prefix + name + " " + segment + "($2), $0 {%k1}"
+			constraints = "=" + constraint + ",0,r"
+			arguments = vectorType + " " + old + ", " + arguments
+		}
+		constraints += ",r,~{k1}"
+		arguments += ", i32 " + mask
+	}
+	loaded, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", loaded, vectorType, assembly, constraints+",~{memory}", arguments)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, vectorType, loaded, form.byteWidth)
+	if legacy {
+		return c.storeLegacyPackedLogical(ins.Args[form.destination], "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[form.destination], form.byteWidth, "%"+bytes)
+}
diff --git a/amd64_packed_vector_move_aligned_oracle_unix_test.go b/amd64_packed_vector_move_aligned_oracle_unix_test.go
new file mode 100644
index 000000000..a7475b5a3
--- /dev/null
+++ b/amd64_packed_vector_move_aligned_oracle_unix_test.go
@@ -0,0 +1,27 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Every host compiles the actual Go-byte original/LLVM oracle. Only the required
+// Linux/amd64 runtime root executes it; this test is not native ISA evidence.
+func TestX86PackedMoveAlignedOriginalGoOracleCompileOnly(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	ir, main, count := x86PackedMoveObservableFixture(t, true, true, execution.triple)
+	compileLLVMToObject(t, execution.llc, execution.triple, "aligned-oracle.ll", "aligned-oracle.o", ir)
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "oracle.c"), filepath.Join(dir, "oracle.o")
+	if err := os.WriteFile(source, []byte(main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := append([]string(nil), execution.compiler...)
+	command = append(command, "-O2", "-c", source, "-o", object)
+	x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...))
+	t.Logf("compiled %d original-Go aligned cases; native numerical/fault execution NOT performed by this test", count)
+}
diff --git a/amd64_packed_vector_move_aligned_runtime_linux_amd64_test.go b/amd64_packed_vector_move_aligned_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..a3efcedfb
--- /dev/null
+++ b/amd64_packed_vector_move_aligned_runtime_linux_amd64_test.go
@@ -0,0 +1,17 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedMaskedMemory(t *testing.T) {
+	x86PackedMoveMaskedMemoryRuntime(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedRegisterViews(t *testing.T) {
+	x86PackedMoveRegisterViewsRuntime(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedOriginalGo(t *testing.T) {
+	x86PackedMoveObservableRuntime(t, true, true)
+}
diff --git a/amd64_packed_vector_move_aligned_test.go b/amd64_packed_vector_move_aligned_test.go
new file mode 100644
index 000000000..16800ab3f
--- /dev/null
+++ b/amd64_packed_vector_move_aligned_test.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedMoveAlignedNativeOpcodeAndFeatures(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			for _, mode := range []string{"load", "store", "merge", "zero", "masked-store"} {
+				masked := mode != "load" && mode != "store"
+				if row.vexOnly && masked {
+					continue
+				}
+				t.Run(row.name+"/"+bank+"/"+mode, func(t *testing.T) {
+					op, mask := row.name, ""
+					if masked {
+						mask = "K7,"
+					}
+					if mode == "zero" {
+						op += ".Z"
+					}
+					operation := fmt.Sprintf("%s (AX),%s%s0", op, mask, bank)
+					if strings.HasSuffix(mode, "store") {
+						operation = fmt.Sprintf("%s %s0,%s(AX)", op, bank, mask)
+					}
+					source := "TEXT ·view(SB),4,$0-8\nMOVQ p+0(FP),AX\nMOVL $3,CX\nKMOVD CX,K7\nVPXORQ Z0,Z0,Z0\n" + operation + "\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, strings.ToLower(row.name)+" ") {
+						t.Fatal("aligned memory lost its original observable opcode", operation)
+					}
+					feature := "+avx"
+					if masked || bank == "Z" || strings.HasPrefix(row.name, "VMOVDQA3") || row.name == "VMOVDQA64" {
+						feature = "+avx512f"
+					}
+					if !strings.Contains(ir, feature) {
+						t.Fatal("missing required native feature", feature)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveAlignedVirtualMemoryNeedsContext(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			for _, memory := range []string{"a+0(FP)", "local-64(SP)", "(BP)"} {
+				for _, operands := range []string{memory + "," + bank + "0", bank + "0," + memory} {
+					source := fmt.Sprintf("TEXT ·view(SB),4,$64-64\n%s %s\nRET\n", row.name, operands)
+					_, err := x86ScalarFPBitViewAPI(t, source, "func view(a,b,c,d,e,f,g,h uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %s acquired native alignment/backing: %v", row.name, operands, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveAlignedResultFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86PackedMoveResultOracle {
+				if !row.aligned {
+					continue
+				}
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if row.vexOnly && bank == "Z" {
+						continue
+					}
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if row.vexOnly && mode != "plain" {
+							continue
+						}
+						name, mask := row.name, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							name += ".Z"
+						}
+						fmt.Fprintf(&declarations, "func view%d(p *[64]byte) uint32\n", count)
+						fmt.Fprintf(&source, "TEXT ·view%d(SB),4,$0-%d\n%s p+0(FP),SI\nMOVL $1,AX\nKMOVD AX,K1\nVPXORQ Z1,Z1,Z1\n%s (SI),%s%s1\nPEXTRD $3,X1,AX\nMOVL AX,ret+%d(FP)\nRET\n", count, word+4, move, name, mask, bank, word)
+						count++
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "aligned-result.ll", "aligned-result.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86PackedMoveAlignedNativeCompleteMemoryAxes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("GLOBL table<>(SB),8,$128\n")
+			count := 0
+			add := func(instruction string) {
+				name := fmt.Sprintf("aligned%d", count)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+				count++
+			}
+			for _, row := range x86PackedMoveResultOracle {
+				if !row.aligned {
+					continue
+				}
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if row.vexOnly && bank == "Z" {
+						continue
+					}
+					// Every mask register, both directions, merge and zero.
+					for mask := 0; mask <= 7; mask++ {
+						if row.vexOnly && mask != 0 {
+							continue
+						}
+						predicate := ""
+						if mask != 0 {
+							predicate = fmt.Sprintf("K%d,", mask)
+						}
+						add(fmt.Sprintf("%s (AX),%s%s7", row.name, predicate, bank))
+						add(fmt.Sprintf("%s %s7,%s(AX)", row.name, bank, predicate))
+						if mask != 0 {
+							add(fmt.Sprintf("%s.Z (AX),%s%s7", row.name, predicate, bank))
+						}
+					}
+					// Orthogonal address-space and high-bank encoding classes.
+					indexes := []int{0, 7}
+					if target.arch == "amd64" {
+						indexes = append(indexes, 8, 15)
+						if !row.vexOnly {
+							indexes = append(indexes, 16, 31)
+						}
+					}
+					for _, index := range indexes {
+						for _, address := range []string{"16(AX)(CX*2)", "table<>+16(SB)", "16(FS)", "16(GS)"} {
+							add(fmt.Sprintf("%s %s,%s%d", row.name, address, bank, index))
+							add(fmt.Sprintf("%s %s%d,%s", row.name, bank, index, address))
+						}
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), target.arch, target.triple)
+			for _, segment := range []string{"%fs:", "%gs:", "ptr addrspace(256)", "ptr addrspace(257)"} {
+				if !strings.Contains(ir, segment) {
+					t.Fatal("native address-space lost", segment)
+				}
+			}
+			if got := strings.Count(ir, "asm sideeffect"); got != count {
+				t.Fatalf("native memory witness count got %d want %d", got, count)
+			}
+			compileLLVMToObject(t, llc, target.triple, "aligned-memory.ll", "aligned-memory.o", ir)
+			t.Logf("%d actual-Go/LLVM aligned memory forms", count)
+		})
+	}
+}
+
+func TestX86PackedMoveAlignedNativeAddressSizeBoundary(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		for _, addressBits := range []int{16, 32, 64} {
+			ins := x86ScalarLaneInstruction(t, row.name+" (AX),X0")
+			ins.x86AddressBits = addressBits
+			ctx := &amd64Ctx{goarch: "amd64"}
+			if _, _, err := ctx.lowerPackedVectorMove(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound original address width borrowed ordinary memory", row.name, addressBits, err)
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveAlignedDATAReadIsNotWriteAuthority(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		for _, masked := range []bool{false, true} {
+			if row.vexOnly && masked {
+				continue
+			}
+			predicate := ""
+			if masked {
+				predicate = "K1,"
+			}
+			source := "DATA table<>+0(SB)/8,$1\nGLOBL table<>(SB),8,$64\nTEXT ·view(SB),4,$0-4\nMOVL $1,AX\nKMOVD AX,K1\n" +
+				row.name + " table<>(SB),X1\n" + row.name + " X1," + predicate + "table<>(SB)\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				_, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("readable DATA gained write authority", row.name, masked, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveAlignedRawSourceCannotBorrowConditionalRead(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[64]byte) uint32",
+			"MOVQ p+0(FP),AX\n"+row.name+" (AX),X1\nPEXTRD $0,X1,CX\nMOVL CX,ret0+8(FP)\nRET")
+		for _, mutation := range []string{"decoded", "address size", "unbound address", "raw text", "source stack", "fixed local", "segment", "symbol"} {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			fn.Instrs[2].Args = append([]Operand(nil), fn.Instrs[2].Args...)
+			switch mutation {
+			case "decoded":
+				fn.Instrs[2].x86Encoded = true
+			case "address size":
+				fn.Instrs[2].x86AddressBits = 32
+			case "unbound address":
+				fn.Instrs[2].x86UnboundAddressOverride = true
+			case "raw text":
+				fn.X86RawText = []byte{0xc3}
+			case "source stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			case "segment":
+				fn.Instrs[2].Args[0].Mem.Segment = "FS"
+			case "symbol":
+				fn.Instrs[2].Args[0].Mem.Sym = "table<>(SB)"
+			}
+			ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("aligned read bypassed source identity", row.name, mutation, err)
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveAlignedRegisterCopyRemainsPortable(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if !row.aligned {
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			ins := x86ScalarLaneInstruction(t, row.name+" "+bank+"0,"+bank+"1")
+			if features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", Func{Instrs: []Instr{ins}}); features != "" {
+				t.Fatal("register bit-copy acquired physical memory ISA", ins, features)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_vector_move_complete_grammar_test.go b/amd64_packed_vector_move_complete_grammar_test.go
new file mode 100644
index 000000000..00810eb8f
--- /dev/null
+++ b/amd64_packed_vector_move_complete_grammar_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedMoveCompleteIndependentEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []struct {
+		name, table, pp, evexW, store, load string
+		vex, evex                           bool
+	}{
+		{"VMOVDQA", "_yvmovdqa", "66", "", "0x7F", "0x6F", true, false},
+		{"VMOVDQU", "_yvmovdqa", "F3", "", "0x7F", "0x6F", true, false},
+		{"VMOVAPD", "_yvmovapd", "66", "1", "0x29", "0x28", true, true},
+		{"VMOVAPS", "_yvmovapd", "", "0", "0x29", "0x28", true, true},
+		{"VMOVUPD", "_yvmovapd", "66", "1", "0x11", "0x10", true, true},
+		{"VMOVUPS", "_yvmovapd", "", "0", "0x11", "0x10", true, true},
+		{"VMOVDQA32", "_yvmovdqa32", "66", "0", "0x7F", "0x6F", false, true},
+		{"VMOVDQA64", "_yvmovdqa32", "66", "1", "0x7F", "0x6F", false, true},
+		{"VMOVDQU8", "_yvmovdqa32", "F2", "0", "0x7F", "0x6F", false, true},
+		{"VMOVDQU16", "_yvmovdqa32", "F2", "1", "0x7F", "0x6F", false, true},
+		{"VMOVDQU32", "_yvmovdqa32", "F3", "0", "0x7F", "0x6F", false, true},
+		{"VMOVDQU64", "_yvmovdqa32", "F3", "1", "0x7F", "0x6F", false, true},
+	} {
+		var classes, zcases, opbytes []string
+		var offsets []int
+		for _, encoding := range []string{"vex", "evex"} {
+			if encoding == "vex" && !expected.vex || encoding == "evex" && !expected.evex {
+				continue
+			}
+			for direction, opcode := range []string{expected.store, expected.load} {
+				widths := []int{128, 256}
+				if encoding == "evex" {
+					widths = append(widths, 512)
+				}
+				for _, width := range widths {
+					bank := map[int]string{128: "x", 256: "y", 512: "z"}[width]
+					register, memory := "Y"+bank+"r", "Y"+bank+"m"
+					word := "0"
+					if encoding == "evex" {
+						word = expected.evexW
+						if width != 512 {
+							register, memory = register+"Evex", memory+"Evex"
+						}
+					}
+					prefix := fmt.Sprintf("avxEscape | %s%d", encoding, width)
+					if expected.pp != "" {
+						prefix += " | " + encoding + expected.pp
+					}
+					prefix += " | " + encoding + "0F | " + encoding + "W" + word
+					opbytes = append(opbytes, prefix)
+					if encoding == "evex" {
+						opbytes = append(opbytes, fmt.Sprintf("evexN%d | evexZeroingEnabled", width/8))
+					}
+					opbytes = append(opbytes, opcode)
+					for _, masked := range []bool{false, true} {
+						if masked && encoding == "vex" {
+							continue
+						}
+						first, last, zcase := register, memory, "r_v_rm"
+						if direction == 1 {
+							first, last, zcase = memory, register, "rm_v_r"
+						}
+						args, offset := first+","+last, 2
+						if encoding == "evex" {
+							offset = 0
+							if masked {
+								args, offset = first+",Yknot0,"+last, 3
+								zcase = strings.Replace(zcase, "_v_", "_k_", 1)
+							}
+						}
+						classes, zcases, offsets = append(classes, args), append(zcases, "Z"+encoding+"_"+zcase), append(offsets, offset)
+					}
+				}
+			}
+		}
+		count, encodingOffset := 0, 0
+		for _, rule := range rules {
+			if rule.Opcode != expected.name {
+				continue
+			}
+			if count >= len(classes) || rule.RowIndex != count || rule.Ytab != expected.table || rule.Prefix != "Pavx" ||
+				strings.Join(rule.Classes, ",") != classes[count] || rule.ZCase != zcases[count] || rule.ZOffset != offsets[count] ||
+				rule.EncodingOffset != encodingOffset || !reflect.DeepEqual(rule.OpBytes, opbytes) {
+				t.Fatalf("%s complete Go row/attributes changed: %+v", expected.name, rule)
+			}
+			encodingOffset += offsets[count]
+			count++
+		}
+		if count != len(classes) {
+			t.Fatal("missing independent encoder rows", expected.name, count, len(classes))
+		}
+	}
+}
+
+func TestX86PackedMoveCompleteRegisterMaskAndAddressAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var rows []string
+		for _, row := range x86PackedMoveResultOracle {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if row.vexOnly && bank == "Z" {
+					continue
+				}
+				limit := 32
+				if row.vexOnly {
+					limit = 16
+				}
+				if arch == "386" && bank == "Z" {
+					limit = 8
+				}
+				for index := 0; index < limit; index++ {
+					rows = append(rows, fmt.Sprintf("%s %s%d,%s1", row.name, bank, index, bank), fmt.Sprintf("%s %s0,%s%d", row.name, bank, bank, index))
+				}
+				if !row.vexOnly {
+					for mask := 1; mask <= 7; mask++ {
+						for _, suffix := range []string{"", ".Z"} {
+							rows = append(rows, fmt.Sprintf("%s%s %s0,K%d,%s1", row.name, suffix, bank, mask, bank),
+								fmt.Sprintf("%s%s (AX),K%d,%s1", row.name, suffix, mask, bank),
+								fmt.Sprintf("%s%s %s0,K%d,(AX)", row.name, suffix, bank, mask))
+						}
+					}
+				}
+				for _, address := range []string{"(AX)", "-16(BX)(CX*2)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+					rows = append(rows, fmt.Sprintf("%s %s,%s1", row.name, address, bank), fmt.Sprintf("%s %s1,%s", row.name, bank, address))
+				}
+			}
+		}
+		var source strings.Builder
+		for index, row := range rows {
+			fmt.Fprintf(&source, "TEXT f%d(SB),4,$64-64\n%s\nRET\n", index, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, fn := range file.Funcs {
+			ins := fn.Instrs[1]
+			_, known, err := amd64PackedVectorMoveProperties(ins, arch)
+			physicalContext := false
+			for _, arg := range ins.Args {
+				register, vector := amd64VectorRegisterIndex(arg.Reg, amd64VectorByteWidth(arg.Reg))
+				physicalContext = physicalContext || arch == "386" && vector && register >= 8
+			}
+			if !known || physicalContext && !errors.Is(err, ErrProbeNeedsContext) || !physicalContext && err != nil {
+				t.Fatal("independent Go family grammar mismatch", arch, rows[index], err)
+			}
+		}
+		t.Logf("%s: %d independent actual-Go accepted form axes", arch, len(rows))
+	}
+}
+
+func TestX86PackedMoveConstructedMemoryCannotBypassGrammar(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			for _, change := range []string{"unknown offset", "unknown index", "bad scale", "stack index", "vector base", "vector index", "unknown register", "address literal"} {
+				ins := x86ScalarLaneInstruction(t, row.name+" (AX),X1")
+				switch change {
+				case "unknown offset":
+					ins.Args[0].Mem.OffRaw = "missing"
+				case "unknown index":
+					ins.Args[0].Mem.IndexExt = "missing"
+				case "bad scale":
+					ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+				case "stack index":
+					ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = SP, 1
+				case "vector base":
+					ins.Args[0].Mem.Base = "X0"
+				case "vector index":
+					ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = "X0", 1
+				case "unknown register":
+					ins.Args[0].Mem.Base = "UNKNOWN"
+				case "address literal":
+					ins.Args[0] = Operand{Kind: OpSym, Sym: "$table<>(SB)"}
+				}
+				if _, known, err := amd64PackedVectorMoveProperties(ins, arch); !known || err == nil {
+					t.Fatal("constructed memory bypassed grammar", row.name, arch, change, err)
+				}
+				if x86ScalarFPResultTransfer(ins, &x86ResultState{}, nil, 0, arch) {
+					t.Fatal("invalid memory acquired a result effect", row.name, arch, change)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_vector_move_forms.go b/amd64_packed_vector_move_forms.go
new file mode 100644
index 000000000..84e08b701
--- /dev/null
+++ b/amd64_packed_vector_move_forms.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64PackedMoveEncoding uint8
+
+const (
+	amd64PackedMoveVEX amd64PackedMoveEncoding = iota
+	amd64PackedMoveVEXOrEVEX
+	amd64PackedMoveEVEX
+)
+
+type amd64PackedVectorMoveSpec struct {
+	elementBits int
+	encoding    amd64PackedMoveEncoding
+	aligned     bool
+}
+
+// This is the complete _yvmovdqa, _yvmovapd and _yvmovdqa32 family.
+// Encoding generation controls widths/registers/masks; elementBits controls
+// mask granularity, not the native memory access's complete byte envelope.
+var amd64PackedVectorMoveSpecs = map[Op]amd64PackedVectorMoveSpec{
+	"VMOVDQA":   {8, amd64PackedMoveVEX, true},
+	"VMOVDQU":   {8, amd64PackedMoveVEX, false},
+	"VMOVAPD":   {64, amd64PackedMoveVEXOrEVEX, true},
+	"VMOVAPS":   {32, amd64PackedMoveVEXOrEVEX, true},
+	"VMOVUPD":   {64, amd64PackedMoveVEXOrEVEX, false},
+	"VMOVUPS":   {32, amd64PackedMoveVEXOrEVEX, false},
+	"VMOVDQA32": {32, amd64PackedMoveEVEX, true},
+	"VMOVDQA64": {64, amd64PackedMoveEVEX, true},
+	"VMOVDQU8":  {8, amd64PackedMoveEVEX, false},
+	"VMOVDQU16": {16, amd64PackedMoveEVEX, false},
+	"VMOVDQU32": {32, amd64PackedMoveEVEX, false},
+	"VMOVDQU64": {64, amd64PackedMoveEVEX, false},
+}
+
+type amd64PackedVectorMoveForm struct {
+	spec         amd64PackedVectorMoveSpec
+	byteWidth    int
+	destination  int
+	mask         int // -1 for unmasked forms
+	memory       int // -1 for register-to-register forms
+	memoryWrite  bool
+	zeroing      bool // native EVEX.z; memory destinations raise #UD
+	physicalEVEX bool // Exact decoded generation, including unmasked low X/Y registers.
+}
+
+// Go's frontend accepts .Z memory stores and sets EVEX.z in their objects,
+// although the native instruction requires EVEX.z=0 for a memory destination.
+// Keep syntax acceptance separate from its terminal exception effect.
+func (form amd64PackedVectorMoveForm) undefinedOpcode() bool {
+	return form.zeroing && form.memoryWrite
+}
+
+// Only the written vector bytes are described here. Callers independently
+// supply numerical source/merge bytes and validate every mask and native
+// memory role. VEX/EVEX upper-zeroing is applied by the state consumer.
+func (form amd64PackedVectorMoveForm) definedActiveBytes(source, previous uint64) uint64 {
+	known := source & x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.mask >= 0 && !form.zeroing {
+		known &= previous
+	}
+	return known
+}
+
+// Both the lowerer and caller-effect proof consume this grammar. It supplies
+// no memory bounds, alignment, initialized bytes, mask value or continuation.
+func amd64PackedVectorMoveProperties(ins Instr, goarch string) (amd64PackedVectorMoveForm, bool, error) {
+	name := strings.ToUpper(string(ins.Op))
+	base, suffix, dotted := strings.Cut(name, ".")
+	spec, recognized := amd64PackedVectorMoveSpecs[Op(base)]
+	if !recognized {
+		return amd64PackedVectorMoveForm{}, false, nil
+	}
+	form := amd64PackedVectorMoveForm{
+		spec: spec, destination: len(ins.Args) - 1,
+		mask: -1, memory: -1, zeroing: suffix == "Z",
+		physicalEVEX: ins.x86PackedVectorMoveEVEX,
+	}
+	fail := func() (amd64PackedVectorMoveForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix are outside the packed vector-move grammar: %q", goarch, base, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" || dotted && suffix != "Z" ||
+		form.physicalEVEX && spec.encoding == amd64PackedMoveVEX ||
+		len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fail()
+	}
+	if len(ins.Args) == 3 {
+		if spec.encoding == amd64PackedMoveVEX || !amd64NonzeroKOperand(ins.Args[1]) {
+			return fail()
+		}
+		form.mask = 1
+	} else if form.zeroing {
+		return fail()
+	}
+	vector := func(operand Operand, width int) bool {
+		if !amd64GoPackedVectorMoveRegister(operand, width, goarch) {
+			return false
+		}
+		if spec.encoding == amd64PackedMoveVEX {
+			return width != 64 && amd64VEXVectorRegister(operand, width)
+		}
+		return true
+	}
+	source, destination := ins.Args[0], ins.Args[form.destination]
+	switch {
+	case source.Kind == OpReg:
+		form.byteWidth = amd64VectorByteWidth(source.Reg)
+		if !vector(source, form.byteWidth) {
+			return fail()
+		}
+		if isAMD64MemoryOperand(destination) {
+			form.memory, form.memoryWrite = form.destination, true
+		} else if !vector(destination, form.byteWidth) {
+			return fail()
+		}
+	case isAMD64MemoryOperand(source):
+		form.byteWidth = amd64VectorByteWidth(destination.Reg)
+		if !vector(destination, form.byteWidth) {
+			return fail()
+		}
+		form.memory = 0
+	default:
+		return fail()
+	}
+	if form.memory >= 0 {
+		memory := ins.Args[form.memory]
+		if !x86PackedShiftMemoryValid(memory, goarch) {
+			return fail()
+		}
+		if memory.Kind == OpMem {
+			if err := x86SymbolIndexedMemoryError(memory.Mem, goarch); err != nil {
+				return form, true, err
+			}
+			if memory.Mem.OffRaw != "" || memory.Mem.IndexExt != "" {
+				return fail()
+			}
+		}
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, goarch)
+}
+
+// This selects actual ordinary memory, not an extent or a continuation proof.
+// The lowerer and private conditional result reader must select the same path.
+func (form amd64PackedVectorMoveForm) unalignedOrdinaryMemory(ins Instr, arch string) bool {
+	return !form.spec.aligned && form.ordinaryMemory(ins, arch)
+}
+
+func (form amd64PackedVectorMoveForm) ordinaryMemory(ins Instr, arch string) bool {
+	return form.memory >= 0 &&
+		x86OrdinaryNativeMemoryOperand(ins.Args[form.memory], arch)
+}
+
+func (form amd64PackedVectorMoveForm) nativeEVEX(ins Instr) bool {
+	if form.physicalEVEX || form.spec.encoding == amd64PackedMoveEVEX || form.mask >= 0 || form.byteWidth == 64 {
+		return true
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && amd64VectorByteWidth(operand.Reg) != 0 {
+			index, ok := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+			if ok && index >= 16 {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func amd64GoPackedVectorMoveRegister(operand Operand, width int, goarch string) bool {
+	if !amd64EVEXVectorRegister(operand, width) {
+		return false
+	}
+	index, _ := amd64VectorRegisterIndex(operand.Reg, width)
+	return goarch != "386" || width != 64 || index < 8
+}
diff --git a/amd64_packed_vector_move_forms_test.go b/amd64_packed_vector_move_forms_test.go
new file mode 100644
index 000000000..d9c68638b
--- /dev/null
+++ b/amd64_packed_vector_move_forms_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+type x86PackedMoveExpectedAxes struct {
+	operands     string
+	memory, mask int
+	write, zero  bool
+}
+
+func TestX86PackedMoveGrammarCoversEveryCurrentGoFamilyMember(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tables := map[string]amd64PackedMoveEncoding{
+		"_yvmovdqa": amd64PackedMoveVEX, "_yvmovapd": amd64PackedMoveVEXOrEVEX,
+		"_yvmovdqa32": amd64PackedMoveEVEX,
+	}
+	wanted := make(map[Op]amd64PackedMoveEncoding)
+	rows := make(map[string]int)
+	ast.Inspect(file, func(node ast.Node) bool {
+		if value, ok := node.(*ast.ValueSpec); ok && len(value.Names) == 1 && len(value.Values) == 1 {
+			name := value.Names[0].Name
+			if _, family := tables[name]; family {
+				literal, ok := value.Values[0].(*ast.CompositeLit)
+				if !ok {
+					t.Fatalf("Go packed-move table is no longer literal: %s", name)
+				}
+				rows[name] = len(literal.Elts)
+			}
+		}
+		literal, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return true
+		}
+		var opcode, table string
+		for _, element := range literal.Elts {
+			field, ok := element.(*ast.KeyValueExpr)
+			if !ok {
+				continue
+			}
+			key, keyOK := field.Key.(*ast.Ident)
+			value, valueOK := field.Value.(*ast.Ident)
+			if !keyOK || !valueOK {
+				continue
+			}
+			switch key.Name {
+			case "as":
+				opcode = value.Name
+			case "ytab":
+				table = value.Name
+			}
+		}
+		if encoding, family := tables[table]; family {
+			if !strings.HasPrefix(opcode, "AVMOV") {
+				t.Fatalf("unregistered spelling in shared Go move family: %s", opcode)
+			}
+			wanted[Op(strings.TrimPrefix(opcode, "A"))] = encoding
+		}
+		return true
+	})
+	if !reflect.DeepEqual(rows, map[string]int{"_yvmovdqa": 4, "_yvmovapd": 16, "_yvmovdqa32": 12}) || len(wanted) != len(amd64PackedVectorMoveSpecs) {
+		t.Fatalf("current Go family changed: rows=%v opcodes=%v", rows, wanted)
+	}
+	for opcode, encoding := range wanted {
+		spec, present := amd64PackedVectorMoveSpecs[opcode]
+		if !present || spec.encoding != encoding {
+			t.Fatalf("Go opcode/encoding omitted or changed: %s/%d", opcode, encoding)
+		}
+	}
+}
+
+func TestX86PackedMoveGrammarAxesAndFiveLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var opcodes []string
+	for opcode := range amd64PackedVectorMoveSpecs {
+		opcodes = append(opcodes, string(opcode))
+	}
+	sort.Strings(opcodes)
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		sigs := make(map[string]FuncSig)
+		for _, opcode := range opcodes {
+			spec := amd64PackedVectorMoveSpecs[Op(opcode)]
+			for index, bank := range []string{"X", "Y", "Z"} {
+				if bank == "Z" && spec.encoding == amd64PackedMoveVEX {
+					continue
+				}
+				width, high := 16<<index, 31
+				if spec.encoding == amd64PackedMoveVEX {
+					high = 15
+				}
+				if arch == "386" {
+					// Go-accepted high X/Y rows have independent Context
+					// regressions; actual objects use the physical low bank.
+					high = 7
+				}
+				register := fmt.Sprintf("%s%d", bank, high)
+				forms := []x86PackedMoveExpectedAxes{
+					{"(AX)," + register, 0, -1, false, false},
+					{register + ",(AX)", 1, -1, true, false},
+					{register + "," + bank + "0", -1, -1, false, false},
+				}
+				if spec.encoding != amd64PackedMoveVEX {
+					forms = append(forms,
+						x86PackedMoveExpectedAxes{"(AX),K7," + register, 0, 1, false, false},
+						x86PackedMoveExpectedAxes{register + ",K7,(AX)", 2, 1, true, false},
+						x86PackedMoveExpectedAxes{register + ",K7," + bank + "0", -1, 1, false, false})
+					maskedForms := append([]x86PackedMoveExpectedAxes(nil), forms[3:]...)
+					for _, masked := range maskedForms {
+						masked.zero = true
+						forms = append(forms, masked)
+					}
+				}
+				for _, expected := range forms {
+					name := opcode
+					if expected.zero {
+						name += ".Z"
+					}
+					instruction := name + " " + expected.operands
+					parsed, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					form, recognized, err := amd64PackedVectorMoveProperties(parsed.Funcs[0].Instrs[1], arch)
+					if !recognized || err != nil || form.byteWidth != width || form.memory != expected.memory ||
+						form.mask != expected.mask || form.memoryWrite != expected.write || form.zeroing != expected.zero || form.spec != spec {
+						t.Fatalf("%s %s changed axes: %+v / %v", arch, instruction, form, err)
+					}
+					// Each form needs its own entry. A terminal #UD must not hide
+					// subsequent formats from actual LLVM object generation.
+					function := fmt.Sprintf("moveform%d", len(sigs))
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", function, instruction)
+					sigs[function] = FuncSig{Name: function, Ret: Void}
+				}
+			}
+		}
+		requireX86GoAssemblerResult(t, arch, source.String(), true)
+		triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), arch, triple)
+			compileLLVMToObject(t, llc, triple, "packed-grammar.ll", "packed-grammar.o", ir)
+		}
+	}
+}
+
+func TestX86PackedMoveGrammarRejectsInvalidGoForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{
+			"VMOVDQA Z0,Z1", "VMOVDQU X16,X0", "VMOVDQU X0,K1,X1", "VMOVDQA.Z X0,X1",
+			"VMOVUPS X0,Y1", "VMOVUPD X0,K0,X1", "VMOVAPS.Z X0,X1",
+			"VMOVDQU8 (AX),(BX)", "VMOVDQA32 $1,X0", "VMOVDQU16 X0,X1,K1,X2",
+			"VMOVDQA64.BCST (AX),Z0", "VMOVUPS.SAE X0,X1", "VMOVDQU32.RN_SAE X0,X1",
+		} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + instruction + "\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, false)
+				parsed, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				_, recognized, err := amd64PackedVectorMoveProperties(parsed.Funcs[0].Instrs[1], arch)
+				if !recognized || err == nil {
+					t.Fatalf("invalid Go form accepted: %s %s", arch, instruction)
+				}
+			})
+		}
+	}
+	for _, name := range []Op{"VMOVUPS.", "VMOVUPS.Z.Z"} {
+		ins := Instr{Op: name, Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}}}
+		if _, _, err := amd64PackedVectorMoveProperties(ins, "amd64"); err == nil {
+			t.Fatalf("malformed direct grammar suffix accepted: %s", name)
+		}
+	}
+}
+
+func TestX86PackedMoveDispatchBindsFamilyWithoutMutatingSource(t *testing.T) {
+	for opcode := range amd64PackedVectorMoveSpecs {
+		for _, arch := range []string{"amd64", "386"} {
+			for _, identity := range []Op{"", opcode, Op(strings.ToLower(string(opcode)))} {
+				instruction := Instr{Op: identity, Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}}}
+				registered := instruction
+				registered.Op = opcode
+				ctx, _ := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{registered}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				if recognized, terminated, err := ctx.lowerPackedVectorMove(opcode, instruction); !recognized || terminated || err != nil {
+					t.Fatalf("%s %s identity=%q: %t/%t/%v", arch, opcode, identity, recognized, terminated, err)
+				}
+				if instruction.Op != identity {
+					t.Fatal("internal opcode binding changed the original caller's instruction")
+				}
+			}
+			for _, identity := range []Op{"MOVQ", "VMOVUPS.Z", "UNKNOWN"} {
+				instruction := Instr{Op: identity, Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}}}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before := output.String()
+				if _, _, err := ctx.lowerPackedVectorMove(opcode, instruction); err == nil || output.String() != before {
+					t.Fatalf("%s %s contradictory identity=%q emitted IR or was accepted: %v", arch, opcode, identity, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_packed_vector_move_memory.go b/amd64_packed_vector_move_memory.go
new file mode 100644
index 000000000..64b0dff6e
--- /dev/null
+++ b/amd64_packed_vector_move_memory.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import "fmt"
+
+// Unaligned packed moves are bit copies with no alignment precondition. Keep
+// physical reads and writes observable without requiring an AVX512 host merely
+// to transport a Z-width software vector. Volatile accesses do not assert that
+// an incoming address is valid, nonnull, initialized, aligned or dereferenceable.
+// A target may split a non-native vector width; this is not an atomicity proof.
+func (c *amd64Ctx) lowerUnalignedPackedMoveMemory(ins Instr, form amd64PackedVectorMoveForm) error {
+	memory := ins.Args[form.memory]
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(memory)
+	if err != nil {
+		return err
+	}
+	width := form.byteWidth
+	if form.mask < 0 {
+		if form.memoryWrite {
+			value, err := c.loadPackedCompareBytes(ins.Args[0], width)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  store volatile <%d x i8> %s, %s %s, align 1\n", width, value, pointerType, pointer)
+			return nil
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load volatile <%d x i8>, %s %s, align 1\n", value, width, pointerType, pointer)
+		return c.storePackedMoveOperand(ins.Args[form.destination], width, "%"+value)
+	}
+
+	mask, err := c.loadK(ins.Args[form.mask].Reg)
+	if err != nil {
+		return err
+	}
+	bits := form.spec.elementBits
+	lanes := width * 8 / bits
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, bits)
+	value := "zeroinitializer"
+	if form.memoryWrite {
+		value, err = c.loadPackedCompareLanes(ins.Args[0], width, bits, false)
+	} else if !form.zeroing {
+		value, err = c.loadPackedCompareLanes(ins.Args[form.destination], width, bits, false)
+	}
+	if err != nil {
+		return err
+	}
+
+	for lane := 0; lane < lanes; lane++ {
+		condition := amd64MaskBitI1(c, mask, lane)
+		address := c.newTmp()
+		// No inbounds GEP: inactive lanes, including a null base, need no
+		// allocation. Only the guarded branch accesses the selected bytes.
+		fmt.Fprintf(c.b, "  %%%s = getelementptr i8, %s %s, i64 %d\n", address, pointerType, pointer, lane*bits/8)
+		if form.memoryWrite {
+			element := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", element, vectorType, value, lane)
+			storeLabel, joinLabel := c.newTmp()+"_packed_store", c.newTmp()+"_packed_join"
+			fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n%s:\n", condition, storeLabel, joinLabel, storeLabel)
+			fmt.Fprintf(c.b, "  store volatile i%d %%%s, %s %%%s, align 1\n", bits, element, pointerType, address)
+			fmt.Fprintf(c.b, "  br label %%%s\n%s:\n", joinLabel, joinLabel)
+			continue
+		}
+		loaded, err := c.loadX86ScalarIf(bits, condition, func() (string, error) {
+			loaded := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %%%s, align 1\n", loaded, bits, pointerType, address)
+			return "%" + loaded, nil
+		})
+		if err != nil {
+			return err
+		}
+		if !form.zeroing {
+			old, selected := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", old, vectorType, value, lane)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %s, i%d %%%s\n", selected, condition, bits, loaded, bits, old)
+			loaded = "%" + selected
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %s, i32 %d\n", inserted, vectorType, value, bits, loaded, lane)
+		value = "%" + inserted
+	}
+	if form.memoryWrite {
+		return nil
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, vectorType, value, width)
+	return c.storePackedMoveOperand(ins.Args[form.destination], width, "%"+bytes)
+}
diff --git a/amd64_packed_vector_move_observable_runtime_linux_amd64_test.go b/amd64_packed_vector_move_observable_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..aeccd0ca4
--- /dev/null
+++ b/amd64_packed_vector_move_observable_runtime_linux_amd64_test.go
@@ -0,0 +1,9 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86PackedMoveUnalignedOriginalGo(t *testing.T) {
+	x86PackedMoveUnalignedRuntime(t, true)
+}
diff --git a/amd64_packed_vector_move_observable_runtime_unix_test.go b/amd64_packed_vector_move_observable_runtime_unix_test.go
new file mode 100644
index 000000000..0e6eaadca
--- /dev/null
+++ b/amd64_packed_vector_move_observable_runtime_unix_test.go
@@ -0,0 +1,256 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedMoveUnalignedPortableFaults(t *testing.T) {
+	x86PackedMoveUnalignedRuntime(t, false)
+}
+
+func x86PackedMoveUnalignedRuntime(t *testing.T, native bool) {
+	x86PackedMoveObservableRuntime(t, native, false)
+}
+
+func x86PackedMoveObservableRuntime(t *testing.T, native, aligned bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	if native {
+		execution = x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	}
+	ir, main, count := x86PackedMoveObservableFixture(t, native, aligned, execution.triple)
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			execution.compileAndRunLLVM(t, "packed-move-observable", text, main, "-O2")
+		})
+	}
+	t.Logf("%d independent move cases; original native Go execution=%t; aligned native semantics=%t", count, native, aligned)
+}
+
+func x86PackedMoveObservableFixture(t *testing.T, native, aligned bool, triple string) (string, string, int) {
+	t.Helper()
+	if aligned && !native {
+		t.Fatal("aligned fault semantics require the original native counterpart")
+	}
+	var source, declarations, originals, pairs strings.Builder
+	sigs := make(map[string]FuncSig)
+	count := 0
+	for _, row := range x86PackedMoveResultOracle {
+		if row.aligned != aligned {
+			continue
+		}
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			width := 16 << axis
+			for _, mode := range []string{"plain-live", "plain-dead", "plain-store", "merge-live", "zero-live", "zero-dead", "mask-store"} {
+				masked := strings.HasPrefix(mode, "merge") || strings.HasPrefix(mode, "zero") || mode == "mask-store"
+				if row.vexOnly && masked {
+					continue
+				}
+				store, dead, zero := strings.HasSuffix(mode, "store"), strings.HasSuffix(mode, "dead"), strings.HasPrefix(mode, "zero")
+				op, mask := row.name, ""
+				if masked {
+					mask = "K1,"
+				}
+				if zero {
+					op += ".Z"
+				}
+				operation := fmt.Sprintf("%s (AX),%s%s0\n", op, mask, bank)
+				if store {
+					operation = fmt.Sprintf("%s %s0,%s(AX)\n", op, bank, mask)
+				}
+				name := fmt.Sprintf("packed_observable%d", count)
+				body := "KMOVQ CX,K1\nVMOVUPS (DI),Z0\nSTC\n" + operation
+				if !store && !dead {
+					body += "VMOVUPS Z0,(DI)\n"
+				}
+				body += "SETCS 64(DI)\n"
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ p+0(FP),AX\nMOVQ out+8(FP),DI\nMOVQ mask+16(FP),CX\n%sRET\n", name, body)
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: I64, Index: 2, Field: -1},
+					}}}
+				fmt.Fprintf(&declarations, "extern void %s(uint8_t*,uint8_t*,uint64_t);\n", name)
+				original := "0"
+				if native {
+					code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+body+"RET\n")
+					if len(code) < 2 || code[len(code)-1] != 0xc3 {
+						t.Fatal("missing original Go opcode and RET", name, code)
+					}
+					var bytes []string
+					for _, value := range code[:len(code)-1] {
+						bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+					}
+					original = "original_" + name
+					fmt.Fprintf(&originals, `__attribute__((target("avx512f,avx512bw,avx512vl")))
+static void %s(uint8_t *p,uint8_t *out,uint64_t mask) {
+    __asm__ volatile(".byte %s" : : "a"(p),"D"(out),"c"(mask) : "zmm0","k1","memory","cc");
+}
+`, original, strings.Join(bytes, ","))
+				}
+				flag := func(value bool) int {
+					if value {
+						return 1
+					}
+					return 0
+				}
+				fmt.Fprintf(&pairs, "{%s,%s,%d,%d,%d,%d,%d,%d},\n", original, name, width, row.bits/8, flag(masked), flag(store), flag(dead), flag(zero))
+				count++
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	alignment := "0"
+	if aligned {
+		alignment = "1"
+	}
+	main := "#define ALIGNED " + alignment + "\n" + x86PackedMoveObservableRuntimeC + declarations.String() + originals.String() + "static const struct pair pairs[]={\n" + pairs.String() + `};
+int main(void) {
+    if (pairs[0].original) {
+        unsigned a,b,c,d;
+        if (!__get_cpuid_count(7,0,&a,&b,&c,&d) || !(b&(1u<<30))) return 78;
+    }
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<256) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    for(unsigned op=0;op<sizeof(pairs)/sizeof(*pairs);++op) {
+        struct pair pair=pairs[op];
+        if(check_values(pair)) { fprintf(stderr,"bytes op=%u\n",op); return 3; }
+        if(ALIGNED) {
+            /* Fully mapped addresses separate alignment from page faults.
+               In particular zero masking is not assumed to suppress #GP. */
+            uint64_t masks[]={0,1,UINT64_C(0x8000000000000000),UINT64_MAX};
+            for(int offset=1;offset<pair.width;offset++) for(unsigned m=0;m<4;m++) {
+                int want=outcome(pair,region+offset,masks[m],1);
+                int got=outcome(pair,region+offset,masks[m],0);
+                if((want!=0 && want!=SIGSEGV && want!=SIGBUS) || got!=want) {
+                    fprintf(stderr,"alignment op=%u offset=%d mask=%llx original=%d llvm=%d\n",op,offset,(unsigned long long)masks[m],want,got);
+                    return 8;
+                }
+                if((!pair.masked || masks[m]==UINT64_MAX) && want==0) return 9;
+            }
+        }
+        /* Live/merge values are covered above; dead loads and stores isolate
+           exceptions from incidental uses of a result. */
+        if(!ALIGNED && !pair.dead && !pair.store) continue;
+        uint64_t masks[]={0,1,UINT64_C(0x8000000000000000),UINT64_MAX};
+        int extents[]={0,pair.lane-1,pair.lane,pair.width-1,pair.width};
+        for(unsigned m=0;m<sizeof(masks)/sizeof(*masks);m++) {
+            for(unsigned e=0;e<sizeof(extents)/sizeof(*extents);e++) {
+                uint8_t *p=region+page-extents[e];
+                int expected=expected_fault(pair,masks[m],extents[e]);
+                int result=outcome(pair,p,masks[m],0);
+                int original=pair.original?outcome(pair,p,masks[m],1):result;
+                if(ALIGNED) {
+                    if((original!=0 && original!=SIGSEGV && original!=SIGBUS) || original!=result) return 10;
+                    continue;
+                }
+                if((expected ? result!=SIGSEGV && result!=SIGBUS : result!=0)) {
+                    fprintf(stderr,"fault op=%u extent=%d mask=%llx got=%d expected=%d\n",op,extents[e],(unsigned long long)masks[m],result,expected);
+                    return 4;
+                }
+                if(pair.original && result!=original) return 5;
+            }
+            int result=outcome(pair,0,masks[m],0);
+            int expected=expected_fault(pair,masks[m],0);
+            if((expected ? result!=SIGSEGV && result!=SIGBUS : result!=0)) return 6;
+            if(pair.original && result!=outcome(pair,0,masks[m],1)) return 7;
+        }
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	return ir, main, count
+}
+
+const x86PackedMoveObservableRuntimeC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <cpuid.h>
+#include <xmmintrin.h>
+typedef void (*operation)(uint8_t*,uint8_t*,uint64_t);
+struct pair { operation original,translated; int width,lane,masked,store,dead,zero; };
+static int active(struct pair pair,uint64_t mask,int byte) {
+    return !pair.masked || ((mask>>(byte/pair.lane))&1);
+}
+static int expected_fault(struct pair pair,uint64_t mask,int extent) {
+    for(int byte=extent;byte<pair.width;byte++) if(active(pair,mask,byte)) return 1;
+    return 0;
+}
+static int outcome(struct pair pair,uint8_t *p,uint64_t mask,int original) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        _Alignas(64) uint8_t out[128]; memset(out,0x53,sizeof(out));
+        (original?pair.original:pair.translated)(p,out,mask); _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    return WIFSIGNALED(status)?WTERMSIG(status):-2;
+}
+static int check_values(struct pair pair) {
+    const uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_C(0x8000000000000000),UINT64_MAX};
+    for(int sample=0;sample<33;sample++) for(unsigned m=0;m<sizeof(masks)/sizeof(*masks);m++) {
+        _Alignas(64) uint8_t a[256],b[256],x[256],y[256],want_a[256],want_x[256];
+        int in=ALIGNED?64:1,out=ALIGNED?64:3;
+        for(int i=0;i<256;i++) {
+            a[i]=b[i]=want_a[i]=(uint8_t)(sample*71+i*19);
+            x[i]=y[i]=want_x[i]=(uint8_t)(sample*31-i*59);
+        }
+        for(int i=0;i<64;i++) {
+            if(pair.store) {
+                if(i<pair.width && active(pair,masks[m],i)) want_a[in+i]=x[out+i];
+            } else if(!pair.dead) {
+                want_x[out+i]=i>=pair.width?0:active(pair,masks[m],i)?a[in+i]:pair.zero?0:x[out+i];
+            }
+        }
+        want_x[out+64]=1;
+        unsigned saved=_mm_getcsr(),csr=0x1f80|((sample&3)<<13)|(sample&63);
+        _mm_setcsr(csr); pair.translated(a+in,x+out,masks[m]); unsigned after=_mm_getcsr();
+        _mm_setcsr(saved);
+        if(after!=csr || memcmp(a,want_a,256) || memcmp(x,want_x,256)) return 1;
+        if(pair.original) {
+            _mm_setcsr(csr); pair.original(b+in,y+out,masks[m]); after=_mm_getcsr();
+            _mm_setcsr(saved);
+            if(after!=csr || memcmp(a,b,256) || memcmp(x,y,256)) return 2;
+        }
+    }
+    return 0;
+}
+`
+
+func TestX86PackedMoveObservableFaultChildrenDisableCore(t *testing.T) {
+	if err := runtimeOracleFaultCorePolicy(runtimeOracleFaultC(t, "amd64_packed_vector_move_observable_runtime_unix_test.go")); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_packed_vector_move_result.go b/amd64_packed_vector_move_result.go
new file mode 100644
index 000000000..7ca7f5e08
--- /dev/null
+++ b/amd64_packed_vector_move_result.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+// Memory availability is separate from the register's defined-byte transfer.
+// conditionalRead is only supplied by the lowering-only, source-wide observer
+// paired with an exact native aligned or unaligned volatile read. It is never a
+// public observer, initialized-pointee, extent, alignment or write permission.
+func x86ResultPackedVectorMoveTransfer(ins Instr, form amd64PackedVectorMoveForm, state *x86ResultState, owned []bool, resultOffset int64, arch string, conditionalRead bool) bool {
+	if form.undefinedOpcode() {
+		return false
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	width := int64(form.byteWidth)
+	widthMask := x86CallerVectorByteMask(width)
+	known := widthMask
+	if form.memory >= 0 && form.spec.aligned && !form.ordinaryMemory(ins, arch) {
+		// Virtual FP/AUTO storage is not the original aligned memory. Ordinary
+		// memory instead retains its actual opcode: continuation defines its
+		// active bytes without assuming that its native address was aligned.
+		return false
+	}
+	if form.memory == 0 {
+		if !conditionalRead && !x86ResultRead(ins.Args[0], width, state, owned, arch) {
+			return false
+		}
+	} else {
+		index, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.byteWidth)
+		if !valid {
+			return false
+		}
+		known = state.vectorBytes(index) & widthMask
+	}
+	if form.memoryWrite {
+		if known != widthMask {
+			return false
+		}
+		destination := ins.Args[form.destination]
+		if conditionalRead && form.ordinaryMemory(ins, arch) &&
+			x86ResultIncomingPointerAddressIdentity(destination, state, arch) {
+			// The paired native store does not read inactive destination lanes
+			// and establishes no logical storage, bounds or future read facts.
+			return true
+		}
+		if form.mask >= 0 && !x86ResultRead(destination, width, state, owned, arch) {
+			return false // An unknown mask may retain any old destination byte.
+		}
+		return x86ResultStore(destination, width, state, owned, resultOffset, arch)
+	}
+	destination, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if !valid {
+		return false
+	}
+	known = form.definedActiveBytes(known, state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, known, false)
+	return true
+}
diff --git a/amd64_packed_vector_move_result_test.go b/amd64_packed_vector_move_result_test.go
new file mode 100644
index 000000000..aeed03cb2
--- /dev/null
+++ b/amd64_packed_vector_move_result_test.go
@@ -0,0 +1,450 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent family inventory: do not derive expected permissions or widths
+// from the production registry whose completeness these tests check.
+var x86PackedMoveResultOracle = []struct {
+	name             string
+	bits             int
+	aligned, vexOnly bool
+}{
+	{"VMOVDQA", 8, true, true}, {"VMOVDQU", 8, false, true},
+	{"VMOVAPD", 64, true, false}, {"VMOVAPS", 32, true, false},
+	{"VMOVUPD", 64, false, false}, {"VMOVUPS", 32, false, false},
+	{"VMOVDQA32", 32, true, false}, {"VMOVDQA64", 64, true, false},
+	{"VMOVDQU8", 8, false, false}, {"VMOVDQU16", 16, false, false},
+	{"VMOVDQU32", 32, false, false}, {"VMOVDQU64", 64, false, false},
+}
+
+func TestX86PackedMoveResultEveryByteAndWriteEncoding(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue // The independent Go table has no VEX.512 row.
+			}
+			width := 16 << axis
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if row.vexOnly && mode != "plain" {
+					continue
+				}
+				name, mask := row.name, ""
+				if mode != "plain" {
+					mask = ",K1"
+				}
+				if mode == "zero" {
+					name += ".Z"
+				}
+				instruction := fmt.Sprintf("%s %s0%s,%s1", name, bank, mask, bank)
+				ins := x86ScalarLaneInstruction(t, instruction)
+				for missing := 0; missing < 64; missing++ {
+					for source := 0; source < 2; source++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: true}}
+						state.writeVector(0, 64, ^uint64(0), false)
+						state.writeVector(1, 64, ^uint64(0), false)
+						state.writeVector(source, 64, ^(uint64(1) << uint(missing)), false)
+						before := state.clone()
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") {
+							t.Fatalf("typed packed move is missing: %s", instruction)
+						}
+						want := ^uint64(0)
+						if missing < width && (source == 0 || mode == "merge") {
+							want &^= uint64(1) << uint(missing)
+						}
+						if state.vectorBytes(1) != want || state.vectorBytes(0) != before.vectorBytes(0) || state.flags != before.flags {
+							t.Fatalf("%s source%d missing%d: got %016x want %016x", instruction, source, missing, state.vectorBytes(1), want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveResultMemoryAndMaskBoundaries(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			width := 16 << axis
+			for _, memory := range []string{"in+0(FP)", fmt.Sprintf("local-%d(SP)", width)} {
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s,%s1", row.name, memory, bank))
+				owned := make([]bool, width)
+				for i := range owned {
+					owned[i] = true
+				}
+				for missing := -1; missing < width; missing++ {
+					state := x86ResultState{fp: append([]bool(nil), owned...), auto: append([]bool(nil), owned...)}
+					if missing >= 0 {
+						state.fp[missing], state.auto[missing] = false, false
+					}
+					got := x86ScalarFPResultTransfer(ins, &state, owned, 0, "amd64")
+					if got != (!row.aligned && missing < 0) {
+						t.Fatalf("%s %s missing%d: accepted=%t", row.name, memory, missing, got)
+					}
+				}
+			}
+			if row.vexOnly {
+				continue
+			}
+			for _, suffix := range []string{"", ".Z"} {
+				state := x86ResultState{}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.writeVector(1, 64, ^uint64(0), false)
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s%s %s0,K1,%s1", row.name, suffix, bank, bank))
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("undefined mask acquired a numerical value", ins)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveResultFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, pointerMove := 8, "MOVQ"
+			if target.arch == "386" {
+				word, pointerMove = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86PackedMoveResultOracle {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if row.vexOnly && bank == "Z" {
+						continue
+					}
+					for _, memory := range []bool{false, true} {
+						for _, mode := range []string{"plain", "merge", "zero"} {
+							if row.vexOnly && mode != "plain" {
+								continue
+							}
+							name, mask, input := row.name, "", bank+"0"
+							if memory {
+								input = "(SI)"
+							}
+							if mode != "plain" {
+								mask = ",K1"
+							}
+							if mode == "zero" {
+								name += ".Z"
+							}
+							fmt.Fprintf(&declarations, "func view%d(p *[64]byte) uint32\n", count)
+							fmt.Fprintf(&source, "TEXT ·view%d(SB),4,$0-%d\n%s p+0(FP),SI\nMOVL $1,AX\nKMOVD AX,K1\nVPXORQ %s0,%s0,%s0\nVPXORQ %s1,%s1,%s1\n%s %s%s,%s1\nPEXTRD $3,X1,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+								count, word+4, pointerMove, bank, bank, bank, bank, bank, bank, name, input, mask, bank, word)
+							count++
+						}
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "packed-result.ll", "packed-result.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86PackedMoveResultPointerReadIsLoweringOnly(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			word, move := 8, "MOVQ"
+			if arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			body := fmt.Sprintf("%s p+0(FP),AX\n%s (AX),X1\nPEXTRD $0,X1,CX\nMOVL CX,ret0+%d(FP)\nRET", move, row.name, word)
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *[64]byte) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("declaration-only observer acquired a physical read", row.name, arch, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveUnalignedDeadReadIsObservable(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if row.aligned {
+			continue
+		}
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			width := 16 << axis
+			source := fmt.Sprintf("TEXT ·view(SB),4,$0-8\nMOVQ p+0(FP),AX\n%s (AX),%s0\nRET\n", row.name, bank)
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, fmt.Sprintf("load volatile <%d x i8>", width)) {
+				t.Fatal("dead full-tuple native read is removable", row.name, bank)
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveMaskedUnalignedReadIsObservable(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		if row.aligned || row.vexOnly {
+			continue
+		}
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << axis
+			source := fmt.Sprintf("TEXT ·view(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ mask+8(FP),CX\nKMOVQ CX,K1\n%s.Z (AX),K1,%s0\nRET\n", row.name, bank)
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte, mask uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "text")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ir, fmt.Sprintf("load volatile i%d,", row.bits)); got != width*8/row.bits {
+				t.Fatalf("%s %s masked dead read has %d observable lanes; want %d", row.name, bank, got, width*8/row.bits)
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveResultStoreAndStaticExtentBoundaries(t *testing.T) {
+	for _, row := range x86PackedMoveResultOracle {
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			width := 16 << axis
+			for _, destination := range []string{"ret+0(FP)", fmt.Sprintf("local-%d(SP)", width)} {
+				for _, masked := range []bool{false, true} {
+					if row.vexOnly && masked {
+						continue
+					}
+					mask := ""
+					if masked {
+						mask = "K1,"
+					}
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s0,%s%s", row.name, bank, mask, destination))
+					for _, oldKnown := range []bool{false, true} {
+						for missing := -1; missing < width; missing++ {
+							owned := make([]bool, width)
+							state := x86ResultState{fp: make([]bool, width), auto: make([]bool, width), masks: [8]bool{1: true}}
+							for i := range owned {
+								owned[i], state.fp[i], state.auto[i] = true, oldKnown, oldKnown
+							}
+							known := ^uint64(0)
+							if missing >= 0 {
+								known &^= uint64(1) << uint(missing)
+							}
+							state.writeVector(0, 64, known, false)
+							want := !row.aligned && missing < 0 && (!masked || oldKnown)
+							if got := x86ScalarFPResultTransfer(ins, &state, owned, 0, "amd64"); got != want {
+								t.Fatal("store borrowed source or inactive destination bytes", ins, oldKnown, missing, got, want)
+							}
+						}
+					}
+				}
+			}
+			ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s table<>+16(SB),%s1", row.name, bank))
+			for _, available := range []int64{int64(width - 1), int64(width)} {
+				state := x86ResultState{loweredStaticReads: map[x86StaticSBAddress]int64{{symbol: "table<>", offset: 16}: available}}
+				if got := x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64"); got != (available == int64(width)) {
+					t.Fatal("static read ignored complete extent", row.name, bank, available, got)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedMoveResultSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86PackedMoveResultOracle {
+			load := move + " p+0(FP),AX\n"
+			read := row.name + " (AX),X1\n"
+			bodies := map[string]string{
+				"unknown base":         read,
+				"numeric base":         "MOVL $1,AX\n" + read,
+				"lost identity":        load + "MOVL $1,AX\n" + read,
+				"unknown index":        load + row.name + " (AX)(DI*1),X1\n",
+				"pointer index":        load + row.name + " (AX)(AX*1),X1\n",
+				"unknown store source": load + row.name + " X1,(AX)\n",
+				"unknown store base":   load + read + row.name + " X1,(DI)\n",
+				"pointer store index":  load + read + row.name + " X1,(AX)(AX*1)\n",
+				"unknown static":       row.name + " ·foreign(SB),X1\n",
+				"unknown path":         load + "MOVL $1,CX\nCMPL CX,$0\nJE done\n" + read + "done:\n",
+			}
+			if !row.vexOnly {
+				bodies["undefined mask"] = load + row.name + ".Z (AX),K1,X1\n"
+				bodies["undefined merge"] = load + "MOVL $1,CX\nKMOVD CX,K1\n" + row.name + " (AX),K1,X1\n"
+				bodies["undefined store mask"] = load + read + row.name + " X1,K1,(AX)\n"
+			}
+			for name, body := range bodies {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%sPEXTRD $0,X1,CX\nMOVL CX,ret+%d(FP)\nRET\n", word+4, body, word)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte) uint32\n", arch, triple, api)
+					if arch == "amd64" && (name == "unknown store source" || name == "unknown path" || name == "undefined merge") {
+						x86VectorScratchCodegenControl(t, source, "func view(p *[64]byte) uint32\n", arch, triple, ir, err)
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("source closure or incoming identity bypass", arch, row.name, name, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86PackedMoveInitializedInstruction(name, arch, initialization, instruction, observation string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $7,CX\nKMOVD CX,K1\n%s%s\n"+
+		"%s\nMOVL CX,ret+%d(FP)\nRET\n", name, word+4, move, initialization, instruction, observation, word)
+	return source, fmt.Sprintf("func %s(p *[64]byte) uint32\n", name)
+}
+
+func TestX86PackedMoveInitializedNativeStoresWholeFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for _, row := range x86PackedMoveResultOracle {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if row.vexOnly && bank == "Z" {
+						continue
+					}
+					for _, masked := range []bool{false, true} {
+						if row.vexOnly && masked {
+							continue
+						}
+						predicate := ""
+						if masked {
+							predicate = "K1,"
+						}
+						name := fmt.Sprintf("view%d", len(names))
+						names = append(names, name)
+						// Keep the original initialized load/store pair, including
+						// native alignment effects. Its result is independent of the
+						// store and cannot be supplied by a fresh logical allocation.
+						body, declaration := x86PackedMoveInitializedInstruction(name, target.arch,
+							fmt.Sprintf("%s (AX),%s1\n", row.name, bank), fmt.Sprintf("%s %s1,%s(AX)", row.name, bank, predicate), "PEXTRD $0,X1,CX")
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+				}
+			}
+			if len(names) != 64 {
+				t.Fatal("complete initialized native-store denominator changed", len(names))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized native-store sequence rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, optimized := range []bool{false, true} {
+						text := ir
+						if optimized {
+							text = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedMoveResultRawOriginBoundaries(t *testing.T) {
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[64]byte) uint32",
+		"MOVQ p+0(FP),AX\nVMOVDQU64 (AX),Z1\nPEXTRD $0,X1,CX\nMOVL CX,ret0+8(FP)\nRET")
+	for _, mutation := range []string{"decoded", "address size", "raw text", "source stack", "fixed local", "segment", "symbol"} {
+		fn := file.Funcs[0]
+		fn.Instrs = append([]Instr(nil), fn.Instrs...)
+		fn.Instrs[2].Args = append([]Operand(nil), fn.Instrs[2].Args...)
+		switch mutation {
+		case "decoded":
+			fn.Instrs[2].x86Encoded = true
+		case "address size":
+			fn.Instrs[2].x86AddressBits = 32
+		case "raw text":
+			fn.X86RawText = []byte{0xc3}
+		case "source stack":
+			fn.x86SourceStack = new(x86SourceStackProof)
+		case "fixed local":
+			fn.x86FixedLocal = new(x86FixedLocalProof)
+		case "segment":
+			fn.Instrs[2].Args[0].Mem.Segment = "FS"
+		case "symbol":
+			fn.Instrs[2].Args[0].Mem.Sym = "table<>(SB)"
+		}
+		ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+		if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("raw/source role acquired ordinary conditional byte availability", mutation, err)
+		}
+	}
+}
+
+func TestX86PackedMoveResultStaticSourceThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		source.WriteString("DATA table<>+0(SB)/8,$0x76543210abcdef01\nGLOBL table<>(SB),8,$64\n")
+		count := 0
+		for _, row := range x86PackedMoveResultOracle {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if row.vexOnly && bank == "Z" {
+					continue
+				}
+				addresses := []string{"table<>(SB)"}
+				if target.arch == "386" {
+					for _, annotation := range []string{"AX", "BX", "CX", "DX", "SI", "DI", "SP", "BP"} {
+						addresses = append(addresses, "table<>(SB)("+annotation+")")
+					}
+				}
+				for _, address := range addresses {
+					fmt.Fprintf(&declarations, "func view%d() uint32\n", count)
+					fmt.Fprintf(&source, "TEXT ·view%d(SB),4,$0-4\n%s %s,%s1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", count, row.name, address, bank)
+					count++
+				}
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal("complete DATA directory did not compose with physical reads", target, api, err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "packed-data.ll", "packed-data.o", ir)
+		}
+	}
+}
diff --git a/amd64_packed_vector_move_runtime_partition_test.go b/amd64_packed_vector_move_runtime_partition_test.go
new file mode 100644
index 000000000..df54ab59a
--- /dev/null
+++ b/amd64_packed_vector_move_runtime_partition_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"os"
+	"strings"
+	"testing"
+)
+
+var x86PackedMoveRuntimeRows = []struct {
+	op   string
+	bits int
+}{
+	{"VMOVAPS", 32}, {"VMOVAPD", 64}, {"VMOVUPS", 32}, {"VMOVUPD", 64},
+	{"VMOVDQA32", 32}, {"VMOVDQA64", 64}, {"VMOVDQU8", 8}, {"VMOVDQU16", 16}, {"VMOVDQU32", 32}, {"VMOVDQU64", 64},
+}
+
+// Test-only ISA partition. An aligned register copy stays portable; only its
+// original physical memory instruction requires the native counterpart.
+func x86PackedMoveRuntimeNativeRow(op string, memory bool) bool {
+	if !memory {
+		return false
+	}
+	switch op {
+	case "VMOVDQA", "VMOVAPS", "VMOVAPD", "VMOVDQA32", "VMOVDQA64":
+		return true
+	}
+	return false
+}
+
+func TestX86PackedMoveRuntimePartitionIsComplete(t *testing.T) {
+	frameFunctions := fixedLocalLeaseFunctions(t, "amd64_lower_packed_move_frame_test.go")
+	for name, execute := range map[string]string{
+		"TestX86PackedMoveFrameSlotsObjects": "false", "TestX86PackedMoveFrameSlotsRuntime": "true",
+	} {
+		function := frameFunctions[name]
+		if function == nil || fixedLocalLeaseCalls(function.Body)["x86PackedMoveFrameSlots"] != 1 {
+			t.Fatal("missing original frame objects or native runtime owner", name)
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok && fixedLocalLeaseCallName(call) == "x86PackedMoveFrameSlots" {
+				if len(call.Args) != 2 || !fixedLocalLeaseIdent(call.Args[1], execute) {
+					t.Error("frame object compilation changed its role or weakened native execution", name)
+				}
+			}
+			return true
+		})
+	}
+	// These are the exact historical rows, independent of the implementation
+	// registry. Every old row must have one owner, never an execution skip.
+	oldRows := map[string]int{"VMOVAPS": 32, "VMOVAPD": 64, "VMOVUPS": 32, "VMOVUPD": 64, "VMOVDQA32": 32, "VMOVDQA64": 64, "VMOVDQU8": 8, "VMOVDQU16": 16, "VMOVDQU32": 32, "VMOVDQU64": 64}
+	var masked, views, frame [2]int
+	seen := make(map[string]bool)
+	for _, row := range x86PackedMoveRuntimeRows {
+		name := row.op
+		if seen[name] || oldRows[name] != row.bits {
+			t.Fatal("unknown or duplicate historical runtime row", row)
+		}
+		seen[name] = true
+		aligned := name == "VMOVAPS" || name == "VMOVAPD" || name == "VMOVDQA32" || name == "VMOVDQA64"
+		if aligned {
+			frame[1]++ // Actual-Go accepted; virtual FP must report Context.
+		} else {
+			frame[0]++ // Numeric portable FP oracle.
+		}
+		for width := 0; width < 3; width++ {
+			owner := 0
+			if x86PackedMoveRuntimeNativeRow(name, true) {
+				owner = 1
+			}
+			if (owner == 1) != aligned {
+				t.Fatal("incorrect historical masked-memory owner", name, width)
+			}
+			masked[owner]++
+			for form := 0; form < 6; form++ {
+				owner = 0
+				if x86PackedMoveRuntimeNativeRow(name, form < 3) {
+					owner = 1
+				}
+				if (owner == 1) != (aligned && form < 3) {
+					t.Fatal("incorrect historical view owner", name, width, form)
+				}
+				views[owner]++
+			}
+		}
+	}
+	if len(seen) != len(oldRows) || masked != [2]int{18, 12} || views != [2]int{144, 36} || frame != [2]int{6, 4} {
+		t.Fatal("lost old rows", masked, views, frame)
+	}
+	for file, roots := range map[string][]string{
+		"amd64_lower_packed_move_memory_test.go": {"TestX86PackedMoveMaskedMemoryRuntime", "TestX86PackedMoveRegisterViewsRuntime"},
+		"amd64_packed_vector_move_aligned_runtime_linux_amd64_test.go": {
+			"TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedMaskedMemory", "TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedRegisterViews", "TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedOriginalGo"},
+	} {
+		source, err := os.ReadFile(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Contains(string(source), "t.Skip") {
+			t.Fatal("runtime partition silently skips rows", file)
+		}
+		for _, root := range roots {
+			if !strings.Contains(string(source), "func "+root+"(t *testing.T)") {
+				t.Fatal("missing required runtime counterpart", root)
+			}
+		}
+	}
+	t.Log("historical memory rows: portable=18 native=12; alias rows: portable=144 native=36; FP rows: portable=6 explicit Context=4; all native roots are required cross-runtime tests")
+}
diff --git a/amd64_packed_word_multiply_forms.go b/amd64_packed_word_multiply_forms.go
new file mode 100644
index 000000000..b93f89346
--- /dev/null
+++ b/amd64_packed_word_multiply_forms.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+type x86PackedWordMultiplySpec struct {
+	mode     amd64PackedWordMultiplyMode
+	encoding x86PackedLogicalEncoding
+}
+
+var x86PackedWordMultiplySpecs = map[Op]x86PackedWordMultiplySpec{
+	"PMULLW":   {amd64PackedWordMultiplyLow, x86PackedLogicalLegacyInteger},
+	"PMULHW":   {amd64PackedWordMultiplySignedHigh, x86PackedLogicalLegacyInteger},
+	"PMULHUW":  {amd64PackedWordMultiplyUnsignedHigh, x86PackedLogicalLegacyInteger},
+	"PMULHRSW": {amd64PackedWordMultiplyRoundedSignedHigh, x86PackedLogicalLegacyFP},
+	"VPMULLW":  {amd64PackedWordMultiplyLow, x86PackedLogicalVEXOrEVEX},
+	"VPMULHW":  {amd64PackedWordMultiplySignedHigh, x86PackedLogicalVEXOrEVEX},
+	"VPMULHUW": {amd64PackedWordMultiplyUnsignedHigh, x86PackedLogicalVEXOrEVEX},
+	"VPMULHRSW": {amd64PackedWordMultiplyRoundedSignedHigh,
+		x86PackedLogicalVEXOrEVEX},
+}
+
+type x86PackedWordMultiplyForm = x86PackedPhysicalForm
+
+// This shared grammar records the real native read/modify/write shape only.
+// It grants neither input initialization nor native backing/caller authority.
+func x86PackedWordMultiplyProperties(op Op, ins Instr, arch string) (x86PackedWordMultiplyForm, bool, error) {
+	return x86PackedPhysicalProperties(op, ins, arch, x86PackedWordProduct)
+}
+
+func x86ResultPackedWordMultiplyStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !form.mmx && form.spec.mode == amd64PackedWordMultiplyLow {
+		// W/D/Q low products share per-lane numerical dependencies. Missing
+		// source bytes leave only their dependent result lanes unknown; they
+		// never become initialized implementation-slot values. Whole-source
+		// word input obligations remain in the separate scalar-FP consumer.
+		return x86ResultPackedLaneArithmeticStep(ins, form.x86PackedBinaryForm, 16, state, owned, arch), true
+	}
+	return x86ResultFixedVectorInputs(ins, form.x86PackedBinaryForm, false, state, owned, arch), true
+}
diff --git a/amd64_packed_word_multiply_forms_test.go b/amd64_packed_word_multiply_forms_test.go
new file mode 100644
index 000000000..54004eeac
--- /dev/null
+++ b/amd64_packed_word_multiply_forms_test.go
@@ -0,0 +1,540 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86WordMultiplyNames = []string{
+	"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW",
+	"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW",
+}
+
+// This catalog is derived from the actual Go ymm, yxm_q4 and _yvandnpd
+// rows, independently of the production specification. It includes valid
+// syntax which requires a different memory or physical input contract.
+func x86WordMultiplyForms(arch string) []string {
+	var rows []string
+	for _, name := range x86WordMultiplyNames[:4] {
+		for _, source := range []string{"X0", "X7", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-16(SP)", "·data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, name+" "+source+",X1")
+		}
+		if arch == "amd64" {
+			rows = append(rows, name+" X15,X0")
+			if name != "PMULHRSW" {
+				for _, source := range []string{"M0", "M7", "(AX)", "value+0(FP)", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+					rows = append(rows, name+" "+source+",M1")
+				}
+			}
+		}
+	}
+	for _, name := range x86WordMultiplyNames[4:] {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, source := range []string{bank + "0", bank + "7", "(AX)", "16(AX)(CX*4)", "value+0(FP)", "local-64(SP)", "·data(SB)", "(FS)", "(GS)"} {
+				rows = append(rows, fmt.Sprintf("%s %s,%s1,%s2", name, source, bank, bank))
+				if arch == "amd64" {
+					rows = append(rows, fmt.Sprintf("%s %s,%s31,K1,%s30", name, source, bank, bank),
+						fmt.Sprintf("%s.Z %s,%s31,K7,%s30", name, source, bank, bank))
+				}
+			}
+			if arch == "amd64" || bank != "Z" {
+				rows = append(rows, fmt.Sprintf("%s %s20,%s21,%s22", name, bank, bank, bank))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86PackedWordMultiplyCompleteActualGoAttributes(t *testing.T) {
+	if len(x86PackedWordMultiplySpecs) != 8 {
+		t.Fatal("complete named packed-word multiply family must contain eight names")
+	}
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{APMULLW, ymm, Py1, opBytes{0xd5, Pe, 0xd5}}",
+		"{APMULHW, ymm, Py1, opBytes{0xe5, Pe, 0xe5}}",
+		"{APMULHUW, ymm, Py1, opBytes{0xe4, Pe, 0xe4}}",
+		"{APMULHRSW, yxm_q4, Pq4, opBytes{0x0b}}",
+		"{Zm_r_xm, 1, argList{Ymm, Ymr}}", "{Zm_r_xm, 2, argList{Yxm, Yxr}}",
+		"{Zm_r, 1, argList{Yxm, Yxr}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatalf("actual Go complete legacy row changed: %s", row)
+		}
+	}
+	for _, class := range []string{"Yax", "Ycx", "Yrx", "Yrl", "Yrl32", "Ym", "Ymr"} {
+		if !strings.Contains(string(legacy), "ycover["+class+"*Ymax+Ymm] = 1") {
+			t.Fatal("actual Go MMX source class changed", class)
+		}
+	}
+	for _, classes := range []string{
+		"Yxm, Yxr, Yxr", "Yym, Yyr, Yyr",
+		"YxmEvex, YxrEvex, YxrEvex", "YxmEvex, YxrEvex, Yknot0, YxrEvex",
+		"YymEvex, YyrEvex, YyrEvex", "YymEvex, YyrEvex, Yknot0, YyrEvex",
+		"Yzm, Yzr, Yzr", "Yzm, Yzr, Yknot0, Yzr",
+	} {
+		start := strings.Index(string(avx), "var _yvandnpd =")
+		table := strings.SplitN(string(avx)[start:], "\n}", 2)[0]
+		if !strings.Contains(table, "argList{"+classes+"}") || strings.Count(table, "argList{") != 8 {
+			t.Fatal("actual Go complete VEX/EVEX class rows changed", classes)
+		}
+	}
+	for _, row := range x86PackedWordMultiplyGoRows {
+		start := strings.Index(string(avx), "{as: A"+string(row.op)+",")
+		if start < 0 {
+			t.Fatal("actual Go omitted opcode", row.op)
+		}
+		record := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+		if !strings.Contains(record, "ytab: _yvandnpd, prefix: Pavx") ||
+			strings.Contains(record, "Bcst") || strings.Contains(record, "Sae") {
+			t.Fatal("actual Go opcode-specific attribute changed", record)
+		}
+		mapName := "0F"
+		if row.mapID == 2 {
+			mapName = "0F38"
+		}
+		for _, width := range []string{"128", "256"} {
+			want := fmt.Sprintf("avxEscape | vex%s | vex66 | vex%s | vexW0, 0x%02X", width, mapName, row.opcode)
+			if !strings.Contains(record, want) {
+				t.Fatal("actual Go VEX encoding changed", want)
+			}
+		}
+		for index, width := range []string{"128", "256", "512"} {
+			want := fmt.Sprintf("avxEscape | evex%s | evex66 | evex%s | evexW0, evexN%d | evexZeroingEnabled, 0x%02X", width, mapName, 16<<index, row.opcode)
+			if !strings.Contains(record, want) {
+				t.Fatal("actual Go EVEX encoding changed", want)
+			}
+		}
+	}
+	archSource, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range x86WordMultiplyNames {
+		if strings.Contains(string(archSource), "instructions[\""+name+"\"]") {
+			t.Fatal("new alias requires independent source-form coverage", name)
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyWholeFormatEffectsAndShapes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var batch strings.Builder
+		for index, row := range x86WordMultiplyForms(arch) {
+			fmt.Fprintf(&batch, "TEXT f%d(SB),4,$64-64\n%s\nRET\n", index, row)
+		}
+		goAssemblerOracleOutput(t, arch, batch.String(), "", true)
+		file, err := Parse(ArchAMD64, batch.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, fn := range file.Funcs {
+			ins := fn.Instrs[1]
+			before := fmt.Sprintf("%#v", ins)
+			form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, arch)
+			high := arch == "386" && strings.Contains(x86WordMultiplyForms(arch)[index], "20")
+			if !known || high && !errors.Is(err, ErrProbeNeedsContext) || !high && err != nil {
+				t.Fatalf("%s lost actual accepted syntax: %+v %v", ins.Raw, form, err)
+			}
+			if high {
+				continue // Syntax accepted; physical binding is not proved.
+			}
+			effect, observed, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if form.legacy {
+				if !observed || err != nil || len(effect.operands) != 2 ||
+					effect.operands[0].width != int64(form.byteWidth) ||
+					effect.operands[1].width != int64(form.byteWidth) ||
+					!effect.operands[0].read || effect.operands[0].write ||
+					!effect.operands[1].read || !effect.operands[1].write ||
+					effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal("legacy byte effect differs from typed form", effect, err)
+				}
+				if !reflect.DeepEqual(effect.operands[0].operand, form.source) {
+					t.Fatal("MMX physical source identity lost")
+				}
+			}
+			for operand := range ins.Args {
+				width, write, shape := x86InstructionMemoryShape(ins, operand, arch)
+				want := form.memory == operand && !form.mmx
+				if shape != want || shape && (width != int64(form.memoryBytes) || write) {
+					t.Fatal("typed memory envelope mismatch", ins, width, write, shape)
+				}
+				if ins.Args[operand].Kind == OpFP {
+					width, write, known := X86FPAccessBytes(ins, operand, arch)
+					if known != (!form.mmx || form.legacy) || known && (write || width != int64(form.memoryBytes)) {
+						t.Fatal("FP observation invented a different native width", ins, width, write, known)
+					}
+				}
+			}
+			if before != fmt.Sprintf("%#v", ins) || x86CallerVectorMoveKnown(ins) != !form.mmx {
+				t.Fatal("classification altered input or disagreed with source-stack admission", ins)
+			}
+		}
+		t.Logf("%s complete actual Go catalog: %d forms (syntax/context/effect distinct)", arch, len(file.Funcs))
+	}
+}
+
+func TestX86PackedWordMultiplyMMXActualEncodedBank(t *testing.T) {
+	for _, row := range []struct {
+		name   string
+		opcode byte
+	}{{"PMULLW", 0xd5}, {"PMULHW", 0xe5}, {"PMULHUW", 0xe4}} {
+		for index, register := range []string{"M0", "M1", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+			source := "TEXT bank(SB),4,$0-0\n" + row.name + " " + register + ",M1\nRET\n"
+			code := x86PackedShiftActualGoBytes(t, "amd64", source)
+			registerIndex := index
+			switch {
+			case index == 2:
+				registerIndex = 7
+			case index >= 3:
+				registerIndex = (index - 3) & 7
+			}
+			if len(code) == 5 && code[0] == 0x41 {
+				code = code[1:] // Actual Go's ignored MMX REX.B annotation.
+			}
+			want := []byte{0x0f, row.opcode, byte(0xc8 | registerIndex), 0xc3}
+			if !bytes.Equal(code, want) {
+				t.Fatalf("%s actual encoded source bank=%x want=%x", source, code, want)
+			}
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyMalformedIdentityAndBanksBeforeIR(t *testing.T) {
+	for _, name := range x86WordMultiplyNames {
+		vector := strings.HasPrefix(name, "V")
+		operands := "X0,X1"
+		if vector {
+			operands = "X0,X1,X2"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+name+" "+operands+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0].Instrs[1]
+		for _, identity := range []Op{"", original.Op, Op(strings.ToLower(name)), "MOVQ", Op(name + ".BAD")} {
+			ins := original
+			ins.Op = identity
+			copy := ins
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before, temporary := out.String(), ctx.tmp
+			known, term, err := ctx.lowerPackedWordMultiply(original.Op, ins)
+			bad := identity != "" && !strings.EqualFold(string(identity), name)
+			if !known || term || (err != nil) != bad || bad && (out.String() != before || ctx.tmp != temporary) || !reflect.DeepEqual(ins, copy) {
+				t.Fatal("dispatch mismatch/clone contract", name, identity, known, term, err)
+			}
+		}
+		bad := []string{"$1,X1", "Y0,Y1", "X16,X0", "X0,(AX)", "(AX),(BX)", "(AX)(SP*2),X1"}
+		if vector {
+			bad = []string{"$1,X1,X2", "X0,Y1,Y2", "X0,X1,(AX)", "X0,X1,K0,X2", "(AX)(SP*2),X1,X2", "2147483648(AX),X1,X2"}
+		}
+		for _, operands := range bad {
+			source := "TEXT f(SB),4,$0-0\n" + name + " " + operands + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				continue
+			}
+			ins := file.Funcs[0].Instrs[1]
+			ctx, out := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := out.String()
+			if known, _, err := ctx.lowerPackedWordMultiply(ins.Op, ins); !known || err == nil || out.String() != before {
+				t.Fatal("malformed form emitted IR", ins, err)
+			}
+		}
+		if vector {
+			for _, suffix := range []string{".BCST", ".SAE", ".RN_SAE", ".Z"} {
+				source := "TEXT f(SB),4,$0-0\n" + name + suffix + " (AX),X1,X2\nRET\n"
+				if suffix == ".Z" {
+					x86WordMultiplyReservedZeroMaskGoObservation(t, source, name)
+				} else {
+					goAssemblerOracleOutput(t, "amd64", source, "", false)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					continue
+				}
+				if _, _, err := x86PackedWordMultiplyProperties(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1], "amd64"); err == nil {
+					t.Fatal("opcode attributes leaked from shared ytab", source)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		arch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		t.Run(triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			declarations.WriteString("package oracle\n")
+			for i, row := range x86WordMultiplyForms(arch) {
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$64-64\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, _, err := x86PackedWordMultiplyProperties(ins.Op, ins, arch)
+				if errors.Is(err, ErrProbeNeedsContext) || form.mmx {
+					continue
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				if form.legacy && form.memory >= 0 && (form.source.Kind == OpFP ||
+					form.source.Kind == OpMem && form.source.Mem.Base == SP) {
+					continue
+				}
+				fmt.Fprintf(&source, "TEXT ·F%d(SB),4,$64-64\n%s\nRET\n", i, row)
+				fmt.Fprintf(&declarations, "func F%d(value [64]byte)\n", i)
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			pkg := mustGoPackage(t, "oracle", declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]FuncSig{}
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs[name] = sig
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original word-multiply formats invented register or native inputs", api, err)
+				}
+			}
+			// Keep every old format/function in its original Go object and in
+			// emitter-only objects. Initialized public positives live in the
+			// complete-family value matrix, not these uninitialized probes.
+			ir := x86WordMultiplyFormatObjectUnit(t, file, sigs, arch, triple, 64)
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedWordMultiplyMode32PhysicalAndSourceBoundaries(t *testing.T) {
+	for _, name := range x86WordMultiplyNames[4:] {
+		for _, bank := range []string{"X", "Y"} {
+			for _, index := range []int{8, 15, 16, 31} {
+				for operand := 0; operand < 3; operand++ {
+					args := []string{bank + "0", bank + "1", bank + "2"}
+					args[operand] = fmt.Sprintf("%s%d", bank, index)
+					source := "TEXT f(SB),4,$0-0\n" + name + " " + strings.Join(args, ",") + "\nRET\n"
+					goAssemblerOracleOutput(t, "386", source, "", true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					if _, _, err := x86PackedWordMultiplyProperties(ins.Op, ins, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("named high bank lost physical Context", ins, err)
+					}
+				}
+			}
+		}
+		for _, source := range []string{
+			name + " Z8,Z1,Z2", name + " Z0,Z8,Z2", name + " Z0,Z1,Z8",
+			name + " X0,X1,K1,X2", name + ".Z Z0,Z1,K1,Z2",
+		} {
+			assembly := "TEXT f(SB),4,$0-0\n" + source + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", assembly, "", false)
+			file, err := Parse(ArchAMD64, assembly)
+			if err != nil {
+				continue
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, _, err := x86PackedWordMultiplyProperties(ins.Op, ins, "386"); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Go rejected a source format, not merely an unknown physical identity", source, err)
+			}
+		}
+	}
+	for _, row := range x86PackedWordMultiplyGoRows {
+		for _, width := range []int{0, 1, 2} {
+			for _, zero := range []bool{false, true} {
+				code := encodeX86EVEXPackedWordMultiply(row.mapID, row.opcode, width, 1, false, zero, 2, 1, 0)
+				ins, n, known, err := decodedX86PackedMultiplyInstruction(code, 32)
+				if !known || err != nil || n != len(code) || !ins.x86Encoded {
+					t.Fatal("actual low physical mode32 EVEX decode lost its origin", ins, err)
+				}
+				if _, _, err := x86PackedWordMultiplyProperties(ins.Op, ins, "386"); err != nil {
+					t.Fatal("physical grammar borrowed textual operand limit", err)
+				}
+				textual := ins
+				textual.x86Encoded = false
+				textual.Raw = fmt.Sprintf("BYTE %x genuine-looking text is not a decoder", code)
+				if _, _, err := x86PackedWordMultiplyProperties(textual.Op, textual, "386"); err == nil {
+					t.Fatal("raw text manufactured a decoder identity")
+				}
+				encoded, err := json.Marshal(ins)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var restored Instr
+				if err := json.Unmarshal(encoded, &restored); err != nil {
+					t.Fatal(err)
+				}
+				if restored.x86Encoded {
+					t.Fatal("public JSON manufactured a decoder marker")
+				}
+				if _, _, err := x86PackedWordMultiplyProperties(restored.Op, restored, "386"); err == nil {
+					t.Fatal("JSON-restored source bypassed Go's named limit")
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyLegacyResultBytesAndUnknownInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86WordMultiplyNames[:4] {
+			for _, first := range []string{"X0", "a+0(FP)", "value-16(SP)"} {
+				for _, complete := range []bool{true, false} {
+					move := "MOVOU"
+					if !complete {
+						move = "MOVSS"
+					}
+					body := move + " a+0(FP),X0\nMOVOU b+16(FP),X1\n" + move + " X0,value-16(SP)\n" + name + " " + first + ",X1\nMOVSD X1,ret0+32(FP)\nRET"
+					if !complete {
+						// Memory MOVSS zeros X[127:32]; its register form instead
+						// preserves the destination's genuinely undefined bytes.
+						body = strings.Replace(body, "MOVSS a+0(FP),X0", "MOVSS a+0(FP),X2\nMOVSS X2,X0", 1)
+					}
+					_, _, sig, source := x86ResultInitializationFixture(t, arch, "func Value(a,b [16]byte) uint64", body)
+					source = strings.Replace(source, ",$0-", ",$32-", 1)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					err = CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+					wantContext := !complete && first != "a+0(FP)"
+					if wantContext && !errors.Is(err, ErrProbeNeedsContext) || !wantContext && err != nil {
+						t.Fatal("legacy result byte proof invented unknown word input", name, first, complete, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyVirtualLegacyMemoryRemainsContext(t *testing.T) {
+	for _, name := range x86WordMultiplyNames[:4] {
+		for _, address := range []string{"value+0(FP)", "(SP)", "(BP)", "(AX)(BP*2)"} {
+			for _, target := range x86RawReturnTargets {
+				source := "TEXT ·f(SB),4,$64-64\nPXOR X0,X0\n" + name + " " + address + ",X0\nRET\n"
+				declaration := "func f(value [64]byte)"
+				if address != "value+0(FP)" {
+					source = x86OrdinaryBPNativeSource(target.arch, "f", name+" "+address+",X0", address, 64)
+					declaration = "func f(p *byte)"
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+name+"/"+address+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						x86RequireOrdinaryBPNativeOutcome(t, target.arch, address, ir, err)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyMode32LowZActualGo(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, name := range x86WordMultiplyNames[4:] {
+		for _, first := range []string{"Z0", "(AX)"} {
+			row := name + " " + first + ", Z1, Z2"
+			t.Run(row, func(t *testing.T) {
+				source := "TEXT wordmul(SB),4,$0-0\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func wordmul()", "386", "i386-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original low-Z format invented native or register inputs", api, err)
+					}
+				}
+				ir := x86WordMultiplyFormatObjectUnit(t, file, map[string]FuncSig{
+					"wordmul": {Name: "wordmul", Ret: Void},
+				}, "386", "i386-unknown-linux-gnu", 0)
+				x86ResultInitializationObject(t, llc, "i386-unknown-linux-gnu", ir, "word-multiply-low-z")
+
+				initialized := "TEXT wordmul(SB),4,$0-4\nMOVL p+0(FP),AX\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", initialized, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, "func wordmul(p *byte)", "386", "i386-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatal("initialized low-bank Z source rejected", api, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, "i386-unknown-linux-gnu", ir, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedWordMultiplyLegacyByteEffectActualGo(t *testing.T) {
+	for _, name := range x86WordMultiplyNames[:4] {
+		for _, arch := range []string{"386", "amd64"} {
+			row := name + " X0, X1"
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				source := "TEXT wordmul(SB),4,$0-0\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 {
+					t.Fatalf("accepted legacy format lacks complete typed byte effect: known=%t err=%v effect=%+v", known, err, effect)
+				}
+				if !effect.operands[0].read || effect.operands[0].write || !effect.operands[1].read ||
+					!effect.operands[1].write || effect.operands[0].width != 16 || effect.operands[1].width != 16 ||
+					effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal(fmt.Sprintf("incorrect read/modify/write/flags effect: %+v", effect))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_word_multiply_native_linux_amd64_test.go b/amd64_packed_word_multiply_native_linux_amd64_test.go
new file mode 100644
index 000000000..39ff70e3a
--- /dev/null
+++ b/amd64_packed_word_multiply_native_linux_amd64_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This is a required Linux/amd64 runtime axis selected by the cross-runtime
+// TestCrossLinuxRuntimeMatrix prefix. Missing AVX/AVX2 is a failure, not a skip.
+// Darwin/Rosetta object/software results cannot satisfy this original-Go axis.
+func TestCrossLinuxRuntimeMatrixX86PackedWordMultiplyOriginalVEX(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\nfunc ReadCSR() uint32\nfunc SetCSR(value uint32)\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\nTEXT ·SetCSR(SB),4,$0-4\nLDMXCSR value+0(FP)\nRET\n")
+	tests.WriteString(x86WordMultiplyOriginalGoTestHeader)
+	count := 0
+	for _, name := range x86WordMultiplyNames[4:] {
+		for _, width := range []int{16, 32} {
+			bank := map[int]string{16: "X", 32: "Y"}[width]
+			for _, memory := range []bool{false, true} {
+				for destination := 0; destination < 3; destination++ {
+					fn := fmt.Sprintf("V%d", count)
+					count++
+					source := bank + "0"
+					if memory {
+						source = "(DI)"
+					}
+					fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed uint64,profile uint32)\n", fn)
+					fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-56
+MOVQ out+0(FP),DX
+MOVQ a+8(FP),DI
+MOVQ b+16(FP),SI
+MOVQ flags+24(FP),CX
+MOVQ csr+32(FP),BX
+VMOVDQU (DI),Y0
+VMOVDQU (SI),Y1
+VMOVDQU (SI),Y2
+LDMXCSR profile+48(FP)
+PUSHQ seed+40(FP)
+POPFQ
+%s %s,%s1,%s%d
+VMOVDQU Y%d,(DX)
+PUSHFQ
+POPQ AX
+MOVQ AX,(CX)
+STMXCSR (BX)
+VZEROUPPER
+RET
+`, fn, name, source, bank, bank, destination, destination)
+					fmt.Fprintf(&tests, `{
+ for i:=range out {out[i]=0xc3}
+ flags:=struct{before,value,after uint64}{0x1122334455667788,0,0x8877665544332211}
+ csr:=struct{before,value,after uint32}{0x11223344,0,0x44332211}
+ %s(op,ap,bp,&flags.value,&csr.value,seed,profile)
+ if flags.value&0x8d5!=seed||flags.before!=0x1122334455667788||flags.after!=0x8877665544332211||csr.value!=profile||csr.before!=0x11223344||csr.after!=0x44332211||ReadCSR()!=profile||a!=originalA||b!=originalB {t.Fatalf("%s state/canary sample%%d",sample)}
+ for i,value:=range out {
+  want:=byte(0xc3)
+  if i>=offset&&i<offset+32 {
+   index:=i-offset;want=0
+   if index<%d {
+    ai:=index&^1
+    x,y:=uint16(ap[ai])|uint16(ap[ai+1])<<8,uint16(bp[ai])|uint16(bp[ai+1])<<8
+    want=byte(product(x,y,%d)>>uint((index&1)*8))
+   }
+  }
+  if value!=want {t.Fatalf("%s full-byte/upper-zero/canary sample%%d byte%%d got%%x want%%x",sample,i,value,want)}
+ }
+}
+`, fn, fn, width, x86WordMultiplyReferenceMode(name), fn)
+				}
+			}
+		}
+	}
+	tests.WriteString("}}\n}\n")
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), tests.String())
+	t.Logf("%d actual original VEX X/Y kernels ×257 samples ×2 six-flag seeds; register/memory and all destination aliases, full Y upper-zero/MXCSR/input/canaries. No original EVEX execution claim.", count)
+}
diff --git a/amd64_packed_word_multiply_runtime_test.go b/amd64_packed_word_multiply_runtime_test.go
new file mode 100644
index 000000000..02f7ca788
--- /dev/null
+++ b/amd64_packed_word_multiply_runtime_test.go
@@ -0,0 +1,451 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86WordMultiplyReservedZeroMaskGoObservation(t *testing.T, source, name string) {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "reserved.s"), filepath.Join(dir, "reserved.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "oracle", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), err == nil, "amd64"); failure != nil {
+		t.Fatalf("actual zero-mask source observation: %v\n%s", failure, output)
+	}
+	if err != nil {
+		if !bytes.Contains(output, []byte("mask register must be specified for .Z instructions")) {
+			t.Fatalf("unknown original-Go rejection: %s", output)
+		}
+		return
+	}
+	// Go1.20 can emit the reserved EVEX.z=1/aaa=0 pattern. This is an
+	// accepted object observation, never authority to execute or translate it.
+	opcode := map[string]byte{"VPMULLW": 0xd5, "VPMULHW": 0xe5, "VPMULHUW": 0xe4, "VPMULHRSW": 0x0b}[name]
+	mapByte := byte(0xf1)
+	if name == "VPMULHRSW" {
+		mapByte = 0xf2
+	}
+	code := []byte{0x62, mapByte, 0x75, 0x88, opcode, 0x10}
+	listing := make([]string, 0, len(code)+1)
+	for _, value := range append(append([]byte(nil), code...), 0xc3) {
+		listing = append(listing, fmt.Sprintf("%02x", value))
+	}
+	if !bytes.Contains(output, []byte(strings.Join(listing, " "))) {
+		t.Fatalf("actual accepted reserved bytes changed: %s", output)
+	}
+	if _, _, recognized, err := decodedX86PackedMultiplyInstruction(code, 64); !recognized || err == nil {
+		t.Fatal("reserved physical bytes acquired valid semantics")
+	}
+	t.Log("actual Go accepts reserved zero-mask bytes; named/raw validation still rejects, and no #UD code is executed")
+}
+
+// Independent integer arithmetic: neither reference reads a production mode,
+// emitter, descriptor or LLVM intrinsic. Rounded signed high is deliberately
+// wrapping, including (-32768)*(-32768) -> 0x8000, not saturation.
+const x86WordMultiplyGoReference = `func product(a,b uint16,mode int) uint16 {
+ if mode==0 {return uint16(uint32(a)*uint32(b))}
+ if mode==2 {return uint16((uint32(a)*uint32(b))>>16)}
+ x,y:=int64(int16(a)),int64(int16(b))
+ value,shift:=x*y,uint(16)
+ if mode==3 {value+=16384;shift=15}
+ return uint16(value>>shift)
+}
+`
+
+const x86WordMultiplyOriginalGoTestHeader = `package oracle
+import ("testing";"unsafe";"runtime")
+` + x86WordMultiplyGoReference + `
+func aligned(value *[160]byte) (*[64]byte,int) {
+ offset:=16+int((-uintptr(unsafe.Pointer(&value[16])))&15)
+ return (*[64]byte)(unsafe.Pointer(&value[offset])),offset
+}
+func TestOriginal(t *testing.T) {
+ runtime.LockOSThread();defer runtime.UnlockOSThread()
+ edges:=[...]uint16{0,1,2,0x3fff,0x4000,0x4001,0x7fff,0x8000,0x8001,0xbfff,0xc000,0xfffe,0xffff}
+ saved:=ReadCSR();defer SetCSR(saved)
+ for sample:=0;sample<257;sample++ {for _,seed:=range []uint64{0,0x8d5} {
+ var a,b,out [160]byte
+ ap,_:=aligned(&a);bp,_:=aligned(&b);op,offset:=aligned(&out)
+ for i:=range a {a[i]=0xa7;b[i]=0xb9}
+ for i:=0;i<64;i+=2 {
+  x,y:=edges[(sample+i/2)%13],edges[(sample/13+i/2*3)%13]
+  if sample>169 {x=uint16(sample*71+i*7919);y=uint16(sample*13+i*37)}
+  ap[i],ap[i+1]=byte(x),byte(x>>8);bp[i],bp[i+1]=byte(y),byte(y>>8)
+ }
+ originalA,originalB:=a,b
+ profile:=uint32(0x1f80|((sample%4)<<13)|(sample%64))
+ SetCSR(profile)
+`
+
+const x86WordMultiplyCReference = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+static uint16_t word(const uint8_t *p) {return (uint16_t)p[0]|(uint16_t)p[1]<<8;}
+static uint16_t product(uint16_t a,uint16_t b,int mode) {
+ if(mode==0) return (uint16_t)((uint32_t)a*(uint32_t)b);
+ if(mode==2) return (uint16_t)(((uint32_t)a*(uint32_t)b)>>16);
+ int64_t x=a<32768?a:(int64_t)a-65536,y=b<32768?b:(int64_t)b-65536;
+ int64_t value=x*y,divisor=65536;
+ if(mode==3) {value+=16384;divisor=32768;}
+ // Mathematical floor division, independent of C's signed-shift policy.
+ return (uint16_t)(value<0?-((-value+divisor-1)/divisor):value/divisor);
+}
+static const uint16_t edge[]={0,1,2,0x3fff,0x4000,0x4001,0x7fff,0x8000,0x8001,0xbfff,0xc000,0xfffe,0xffff};
+static const uint64_t masks[]={0,1,UINT64_C(0xaaaaaaaa55555555),UINT64_MAX};
+struct Aligned {_Alignas(64) uint8_t before[64],value[64],after[64];};
+typedef void (*Program)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t*,uint32_t*,uint64_t,uint64_t);
+static int check(Program program,const char *name,int width,int legacy,int alias,int mode,int masking) {
+ for(int sample=0;sample<257;sample++) for(int status=0;status<2;status++) for(int m=0;m<4;m++) {
+  struct Aligned a,b,out;
+  memset(&a,0xa7,sizeof(a));memset(&b,0xb9,sizeof(b));memset(&out,0xc3,sizeof(out));
+  for(int i=0;i<64;i+=2) {
+   uint16_t x=edge[(sample+i/2)%13],y=edge[(sample/13+i/2*3)%13];
+   if(sample>169) {x=(uint16_t)(sample*71+i*7919);y=(uint16_t)(sample*13+i*37);}
+   a.value[i]=(uint8_t)x;a.value[i+1]=(uint8_t)(x>>8);
+   b.value[i]=(uint8_t)y;b.value[i+1]=(uint8_t)(y>>8);
+  }
+  struct Aligned originalA=a,originalB=b;
+  struct {uint64_t before,value,after;} flags={UINT64_C(0x1122334455667788),0,UINT64_C(0x8877665544332211)};
+  struct {uint32_t before,value,after;} csr={0x11223344,0,0x44332211};
+  uint32_t saved=_mm_getcsr(),profile=(uint32_t)(0x1f80|((sample%4)<<13)|(sample%64));
+  _mm_setcsr(profile);
+  uint64_t seed=status?UINT64_C(0x8d5):0;
+  program(out.value,a.value,b.value,&flags.value,&csr.value,seed,masks[m]);
+  _mm_setcsr(saved);
+  if((flags.value&UINT64_C(0x8d5))!=seed||flags.before!=UINT64_C(0x1122334455667788)||flags.after!=UINT64_C(0x8877665544332211)||
+     csr.value!=profile||csr.before!=0x11223344||csr.after!=0x44332211||memcmp(&a,&originalA,sizeof(a))||memcmp(&b,&originalB,sizeof(b))) {
+   fprintf(stderr,"%s state sample%d flags%llx CSR%x/%x\n",name,sample,(unsigned long long)flags.value,csr.value,profile);return 1;
+  }
+  for(int i=0;i<64;i++) {
+   uint16_t value=product(word((alias?b.value:a.value)+(i&~1)),word(b.value+(i&~1)),mode);
+   int active=!masking||((masks[m]>>(i/2))&1);
+   uint8_t want=i<width?(active?(uint8_t)(value>>((i&1)*8)):(masking==2?0:b.value[i])):(legacy?b.value[i]:0);
+   if(out.value[i]!=want||out.before[i]!=0xc3||out.after[i]!=0xc3) {
+    fprintf(stderr,"%s sample%d mask%llx byte%d got%x want%x\n",name,sample,(unsigned long long)masks[m],i,out.value[i],want);return 2;
+   }
+  }
+ }
+ return 0;
+}
+`
+
+func x86WordMultiplyReferenceMode(name string) int {
+	switch strings.TrimPrefix(name, "V") {
+	case "PMULLW":
+		return 0
+	case "PMULHW":
+		return 1
+	case "PMULHUW":
+		return 2
+	case "PMULHRSW":
+		return 3
+	default:
+		panic("unknown independent word multiply reference name")
+	}
+}
+
+func x86WordMultiplySignature(t *testing.T, pkg GoPackage, name string) FuncSig {
+	t.Helper()
+	sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return sig
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedWordMultiplyOriginalGo(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, tests strings.Builder
+	declarations.WriteString("package oracle\nfunc ReadCSR() uint32\nfunc SetCSR(value uint32)\n")
+	assembly.WriteString("TEXT ·ReadCSR(SB),4,$0-4\nSTMXCSR ret0+0(FP)\nRET\nTEXT ·SetCSR(SB),4,$0-4\nLDMXCSR value+0(FP)\nRET\n")
+	tests.WriteString(x86WordMultiplyOriginalGoTestHeader)
+	count := 0
+	for _, name := range x86WordMultiplyNames[:4] {
+		for _, bank := range []string{"X", "M"} {
+			if bank == "M" && name == "PMULHRSW" {
+				continue
+			}
+			kinds := []string{"Register", "Alias", "Memory"}
+			if bank == "M" {
+				kinds = append(kinds, "AXBank", "R14Bank")
+			}
+			for _, kind := range kinds {
+				fn := fmt.Sprintf("F%d", count)
+				count++
+				move, width, source := "MOVOU", 16, bank+"0"
+				if bank == "M" {
+					move, width = "MOVQ", 8
+				}
+				alias := 0
+				if kind == "Alias" {
+					source, alias = bank+"1", 1
+				}
+				if kind == "Memory" {
+					source = "(DI)"
+				}
+				if kind == "AXBank" {
+					source = "AX"
+				}
+				if kind == "R14Bank" {
+					source = "R14"
+				}
+				fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed uint64,profile uint32)\n", fn)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-56\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\nMOVQ flags+24(FP),CX\nMOVQ csr+32(FP),BX\n%s (DI),%s0\n%s (SI),%s1\n", fn, move, bank, move, bank)
+				if kind == "R14Bank" {
+					assembly.WriteString("MOVQ (DI),M6\n")
+				}
+				fmt.Fprintf(&assembly, "LDMXCSR profile+48(FP)\nPUSHQ seed+40(FP)\nPOPFQ\n%s %s,%s1\n%s %s1,(DX)\n", name, source, bank, move, bank)
+				if bank == "M" {
+					assembly.WriteString("EMMS\n")
+				}
+				assembly.WriteString("PUSHFQ\nPOPQ AX\nMOVQ AX,(CX)\nSTMXCSR (BX)\nRET\n")
+				fmt.Fprintf(&tests, `{
+ for i:=range out {out[i]=0xc3}
+ flags:=struct{before,value,after uint64}{0x1122334455667788,0,0x8877665544332211}
+ csr:=struct{before,value,after uint32}{0x11223344,0,0x44332211}
+ %s(op,ap,bp,&flags.value,&csr.value,seed,profile)
+ if flags.value&0x8d5!=seed||flags.before!=0x1122334455667788||flags.after!=0x8877665544332211||csr.value!=profile||csr.before!=0x11223344||csr.after!=0x44332211||ReadCSR()!=profile||a!=originalA||b!=originalB {t.Fatalf("%s flags/CSR/input/canary sample%%d flags%%x csr%%x/%%x",sample,flags.value,csr.value,profile)}
+ for i,value:=range out {
+  want:=byte(0xc3)
+  if i>=offset&&i<offset+%d {
+   index:=i-offset;ai:=index&^1
+   x,y:=uint16(ap[ai])|uint16(ap[ai+1])<<8,uint16(bp[ai])|uint16(bp[ai+1])<<8
+   if %d!=0 {x=y}
+   want=byte(product(x,y,%d)>>uint((index&1)*8))
+  }
+  if value!=want {t.Fatalf("%s full-byte/canary sample%%d byte%%d got%%x want%%x",sample,i,value,want)}
+ }
+}
+`, fn, fn, width, alias, x86WordMultiplyReferenceMode(name), fn)
+			}
+		}
+	}
+	tests.WriteString("}}\n}\n")
+	x86WordMultiplyRunOriginalGo(t, execution, declarations.String(), assembly.String(), tests.String())
+	t.Logf("%d actual original SSE/MMX kernels ×257 initialized samples ×2 all-six-flag seeds, full MXCSR, bytes/input/canaries; MMX GP spellings observe the physical bank only, not a new LLVM permission. Rosetta is not native AMD64 evidence.", count)
+}
+
+func x86WordMultiplyRunOriginalGo(t *testing.T, execution x86FloatCompareExecution, declarations, assembly, tests string) {
+	t.Helper()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations, "value_amd64.s": assembly, "value_test.go": tests} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatal("original Go had no successful terminal", string(output))
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedWordMultiplySoftwareAllWidths(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, reference, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	reference.WriteString(x86WordMultiplyCReference)
+	count := 0
+	for _, name := range x86WordMultiplyNames {
+		widths := []int{16}
+		if strings.HasPrefix(name, "V") {
+			widths = append(widths, 32, 64)
+		}
+		for _, width := range widths {
+			for _, memory := range []bool{false, true} {
+				for _, alias := range []bool{false, true} {
+					for _, masking := range []int{0, 1, 2} {
+						if !strings.HasPrefix(name, "V") && masking != 0 {
+							continue
+						}
+						fn := fmt.Sprintf("W%d", count)
+						count++
+						bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+						source := bank + "0"
+						if alias {
+							source = bank + "1"
+						}
+						if memory {
+							source = "(DI)"
+						}
+						inputAlias := alias && !memory
+						op, args := name, source+","+bank+"1"
+						if strings.HasPrefix(name, "V") {
+							if masking != 0 {
+								args += ",K1"
+							}
+							if masking == 2 {
+								op += ".Z"
+							}
+							args += "," + bank + "1"
+						}
+						fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed,mask uint64)\n", fn)
+						fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-56\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),DI\nMOVQ b+16(FP),SI\nMOVQ flags+24(FP),CX\nMOVQ csr+32(FP),BX\nVMOVUPS (DI),Z0\nVMOVUPS (SI),Z1\n", fn)
+						if masking != 0 {
+							assembly.WriteString("MOVQ mask+48(FP),AX\nKMOVQ AX,K1\n")
+						}
+						assembly.WriteString("PUSHQ seed+40(FP)\nPOPFQ\n")
+						fmt.Fprintf(&assembly, "%s %s\nVMOVUPS Z1,(DX)\nPUSHFQ\nPOPQ AX\nMOVQ AX,(CX)\nSTMXCSR (BX)\nRET\n", op, args)
+						fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t*,uint32_t*,uint64_t,uint64_t);\n", fn)
+						legacy, a := 0, 0
+						if !strings.HasPrefix(name, "V") {
+							legacy = 1
+						}
+						if inputAlias {
+							a = 1
+						}
+						fmt.Fprintf(&checks, "if(check(%s,%q,%d,%d,%d,%d,%d)) return 1;\n", fn, name+" "+args, width, legacy, a, x86WordMultiplyReferenceMode(name), masking)
+					}
+				}
+			}
+		}
+	}
+	reference.WriteString("int main(void) {\n" + checks.String() + "return 0;}\n")
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	pkg := mustGoPackage(t, "oracle", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{}
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sigs[name] = x86WordMultiplySignature(t, pkg, name)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs, ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "word-multiply-all-widths", ir, reference.String(), level)
+		})
+	}
+	t.Logf("%d initialized LLVM software kernels ×257 samples ×2 seeds ×4 masks; full64-byte aliases, six flags, MXCSR/input/canaries. Original-Go accepted source/object is separate; this does NOT execute original AVX/AVX512 instructions or prove native EVEX capability.", count)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedWordMultiplySoftwareMaskedMemory(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, name := range x86WordMultiplyNames[4:] {
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, zero := range []bool{false, true} {
+				fn := fmt.Sprintf("M%d", count)
+				count++
+				op, zeroInt := name, 0
+				if zero {
+					op, zeroInt = op+".Z", 1
+				}
+				fmt.Fprintf(&declarations, "func %s(out,a,b *[64]byte,flags *uint64,csr *uint32,seed,mask uint64)\n", fn)
+				fmt.Fprintf(&assembly, `TEXT ·%s(SB),4,$0-56
+MOVQ out+0(FP),DX
+MOVQ a+8(FP),DI
+MOVQ b+16(FP),SI
+MOVQ flags+24(FP),CX
+MOVQ csr+32(FP),BX
+MOVQ mask+48(FP),AX
+KMOVQ AX,K1
+VMOVUPS (SI),Z1
+PUSHQ seed+40(FP)
+POPFQ
+%s (DI),%s1,K1,%s1
+VMOVUPS Z1,(DX)
+PUSHFQ
+POPQ AX
+MOVQ AX,(CX)
+STMXCSR (BX)
+RET
+`, fn, op, bank, bank)
+				fmt.Fprintf(&checks, "if(checkMasked(%s,%q,%d,%d,%d,p)) return 1;\n", fn, op, width, zeroInt, x86WordMultiplyReferenceMode(name))
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	pkg := mustGoPackage(t, "oracle", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{}
+	var external strings.Builder
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sigs[name] = x86WordMultiplySignature(t, pkg, name)
+		fmt.Fprintf(&external, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t*,uint32_t*,uint64_t,uint64_t);\n", name)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const maskedReference = `
+static int checkMasked(Program program,const char *name,int width,int zero,int mode,const uint8_t *pageTail) {
+ const uint64_t mask[]={0,1,UINT64_C(1)<<32};
+ for(int state=0;state<2;state++) for(int m=0;m<3;m++) {
+  struct Aligned b,out;
+  memset(&b,0xb9,sizeof(b));memset(&out,0xc3,sizeof(out));
+  struct Aligned before=b;
+  struct {uint64_t before,value,after;} flags={0x11223344,0,0x44332211};
+  struct {uint32_t before,value,after;} csr={0x55667788,0,0x88776655};
+  uint64_t seed=state?UINT64_C(0x8d5):0;
+  uint32_t saved=_mm_getcsr(),profile=0x1fbf;
+  _mm_setcsr(profile);
+  program(out.value,m==1?pageTail:NULL,b.value,&flags.value,&csr.value,seed,mask[m]);
+  _mm_setcsr(saved);
+  if((flags.value&UINT64_C(0x8d5))!=seed||flags.before!=0x11223344||flags.after!=0x44332211||
+     csr.value!=profile||csr.before!=0x55667788||csr.after!=0x88776655||memcmp(&b,&before,sizeof(b))) return 2;
+  for(int i=0;i<64;i++) {
+   uint8_t want=0;
+   if(i<width) {
+    if(m==1&&i<2) want=(uint8_t)(product(0x8000,word(b.value),mode)>>(i*8));
+    else if(!zero) want=b.value[i];
+   }
+   if(out.value[i]!=want||out.before[i]!=0xc3||out.after[i]!=0xc3) {
+    fprintf(stderr,"%s masked read byte%d mask%llx got%x want%x\n",name,i,(unsigned long long)mask[m],out.value[i],want);return 3;
+   }
+  }
+ }
+ return 0;
+}
+`
+	main := x86WordMultiplyCReference + external.String() + x86TestGuardPagesC + maskedReference + `
+int main(void) {
+ if (setup_guard() || page < 64) return 5;
+ uint8_t *p = guard + page - 2;
+ p[0] = 0;
+ p[1] = 0x80;
+` + checks.String() + `
+ if (free_guard()) return 6;
+ return 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "word-multiply-masked-memory", ir, main, level)
+		})
+	}
+	t.Logf("%d software EVEX kernels: inactive NULL, guard-page first word, irrelevant high mask bits, two flag seeds/full bytes/MXCSR/canaries. These semantics do not grant source/caller memory permission or native EVEX execution.", count)
+}
diff --git a/amd64_packed_zero_extend_contract_test.go b/amd64_packed_zero_extend_contract_test.go
new file mode 100644
index 000000000..40b06b305
--- /dev/null
+++ b/amd64_packed_zero_extend_contract_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86PackedZeroExtendDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			opcode := prefix + "MOVZX" + ratio.suffix
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+opcode+" X0,X1\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, identity := range []Op{"", Op(opcode), Op(strings.ToLower(opcode)), "PMOVSXBW", "VPMOVZXBW.Z"} {
+				ins := file.Funcs[0].Instrs[1]
+				ins.Op = identity
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				before := output.String()
+				known, term, err := ctx.lowerPackedExtendMove(Op(opcode), ins)
+				conflict := identity != "" && !strings.EqualFold(string(identity), opcode)
+				if !known || term || (err != nil) != conflict || conflict && output.String() != before {
+					t.Fatalf("dispatch %s/%s: known=%t term=%t err=%v", opcode, identity, known, term, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendFPBytesBindActualGoDeclaration(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if prefix == "P" && bank != "X" {
+					continue
+				}
+				width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank] * ratio.input / ratio.output
+				for _, layout := range []string{"complete", "last byte absent", "alignment hole"} {
+					var parameters []string
+					for i := 0; i < width; i++ {
+						if layout == "last byte absent" && i == width-1 {
+							continue
+						}
+						if layout == "alignment hole" && i >= 1 {
+							parameters = append(parameters, fmt.Sprintf("a%d uint64", i))
+						} else {
+							parameters = append(parameters, fmt.Sprintf("a%d byte", i))
+						}
+					}
+					fset := token.NewFileSet()
+					declaration, err := parser.ParseFile(fset, "decl.go", "package bound\nfunc f("+strings.Join(parameters, ",")+")\n", 0)
+					if err != nil {
+						t.Fatal(err)
+					}
+					typed, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check("bound", fset, []*ast.File{declaration}, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					row := prefix + "MOVZX" + ratio.suffix + " a0+0(FP)," + bank + "1"
+					params := typed.Scope().Lookup("f").Type().(*types.Signature).Params()
+					var fields []*types.Var
+					for i := 0; i < params.Len(); i++ {
+						fields = append(fields, params.At(i))
+					}
+					sizes := types.SizesFor("gc", "amd64")
+					offsets := sizes.Offsetsof(fields)
+					end := offsets[len(offsets)-1] + sizes.Sizeof(fields[len(fields)-1].Type())
+					allocation := (end + 7) &^ 7 // Actual ABI0 word-aligned scalar allocation.
+					assembly := fmt.Sprintf("TEXT f(SB),4,$0-%d\n%s\nRET\n", allocation, row)
+					if layout == "complete" {
+						requireX86GoAssemblerResult(t, "amd64", assembly, true)
+					}
+					ctx := llvm.NewContext()
+					bound, err := translateGoModuleInContext(ctx, GoPackage{Path: "bound", Types: typed, Syntax: []*ast.File{declaration}}, []byte(assembly), GoModuleOptions{GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu"})
+					if bound != nil {
+						bound.Module.Dispose()
+					}
+					ctx.Dispose()
+					if (err != nil) != (layout != "complete") {
+						t.Fatalf("%s/%s ignored actual Go field layout: %v", row, layout, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendEveryDeclaredFPByteBeforeEmission(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			for _, row := range x86ZeroExtendAcceptedForms(prefix+"MOVZX"+ratio.suffix, "amd64") {
+				if !strings.Contains(row, "8(AX)") {
+					continue
+				}
+				row = strings.Replace(row, "8(AX)", "a+1(FP)", 1)
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, _, err := x86PackedZeroExtendProperties(ins, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for missing := -1; missing < form.memoryBytes; missing++ {
+					sig := FuncSig{Name: "f", Ret: Void}
+					for i := 0; i < form.memoryBytes; i++ {
+						if i != missing {
+							sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i + 1), Type: I8, Index: len(sig.Args), Field: -1})
+							sig.Args = append(sig.Args, I8)
+						}
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+					before := output.String()
+					known, term, err := ctx.lowerPackedExtendMove(ins.Op, ins)
+					if !known || term || (err != nil) != (missing >= 0) || missing >= 0 && output.String() != before {
+						t.Fatalf("%s missing byte %d emitted/accepted undeclared FP bytes: %v", row, missing, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86GoCallerPackedZeroExtendMemoryCertificatesBindNativeSource(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			for _, original := range x86ZeroExtendAcceptedForms(prefix+"MOVZX"+ratio.suffix, "amd64") {
+				if !strings.Contains(original, "8(AX)") {
+					continue
+				}
+				row := strings.NewReplacer("8(AX)", "8(DI)", "X15", "X2", "X31", "X2", "Y31", "Y2", "Z31", "Z2").Replace(original)
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", "VMOVUPS (SI),Z2\nKMOVQ AX,K1\nKMOVQ AX,K7\n"+row+"\nVMOVSS X2,(DX)", 1)
+				pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized, err := normalizeX86RawFile(file, "amd64", Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+				if err != nil {
+					t.Fatal(err)
+				}
+				found := false
+				for _, ins := range normalized.Funcs[0].Instrs {
+					form, recognized, err := x86PackedZeroExtendProperties(ins, "amd64")
+					if !recognized || err != nil || form.memory < 0 {
+						continue
+					}
+					found = true
+					index := form.memory
+					access, exists := ins.x86CallerMemory[index]
+					if !exists || access.write || access.width != int64(form.memoryBytes) || !x86CallerMemoryCertified(ins, index) {
+						t.Fatalf("%s lacks its exact shrinking native read certificate", row)
+					}
+					for _, change := range []string{"opcode", "width", "address", "index", "destination", "direction", "mask", "address-bits"} {
+						mutated := ins
+						mutated.Args = append([]Operand(nil), ins.Args...)
+						mutated.x86CallerMemory = map[int]x86CallerMemoryAccess{index: access}
+						switch change {
+						case "opcode":
+							mutated.Op = "VPMOVSXBD"
+						case "width":
+							access.width++
+							mutated.x86CallerMemory[index] = access
+						case "address":
+							mutated.Args[index].Mem.Off++
+						case "index":
+							mutated.Args[index].Mem.Index, mutated.Args[index].Mem.Scale = BX, 4
+						case "destination":
+							mutated.Args[form.destination].Reg = "X3"
+						case "direction":
+							access.write = true
+							mutated.x86CallerMemory[index] = access
+						case "mask":
+							if form.mask >= 0 {
+								mutated.Args[form.mask].Reg = "K2"
+							} else {
+								mutated.Args = append(mutated.Args, Operand{Kind: OpReg, Reg: "K2"})
+							}
+						case "address-bits":
+							mutated.x86AddressBits = 32
+						}
+						if x86CallerMemoryCertified(mutated, index) {
+							t.Fatalf("%s mutation retained %s source certificate", change, row)
+						}
+					}
+				}
+				if !found {
+					t.Fatal("no widening source instruction consumed its caller certificate")
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendInvalidMemoryAndMaskGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"VPMOVZXBD (AX)(SP*1),X1", "VPMOVZXBD (AX)(CX*3),X1",
+			"VPMOVZXBD $glob(SB),X1", "VPMOVZXBD X0,K0,X1",
+			"VPMOVZXBD.SAE X0,X1", "VPMOVZXBD.RN_SAE X0,X1",
+			"VPMOVZXBD. X0,X1", "PMOVZXBD X0,K1,X1",
+		} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				continue
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ctx.goarch = arch
+			before := output.String()
+			ins := file.Funcs[0].Instrs[1]
+			known, term, err := ctx.lowerPackedExtendMove(ins.Op, ins)
+			if !known || term || err == nil || output.String() != before {
+				t.Fatalf("%s/%s emitted invalid grammar: %v", arch, row, err)
+			}
+		}
+	}
+	// A full signed displacement must not silently wrap in native amd64.
+	for _, off := range []int64{1 << 31, -1<<31 - 1, 1 << 32} {
+		ins := Instr{Op: "VPMOVZXBD", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX, Off: off}}, {Kind: OpReg, Reg: "X1"}}}
+		if _, recognized, err := x86PackedZeroExtendProperties(ins, "amd64"); !recognized || err == nil {
+			t.Fatalf("out-of-range native displacement %d accepted", off)
+		}
+	}
+	for _, scale := range []int64{1, 2, 4, 8} {
+		row := fmt.Sprintf("VPMOVZXBD 3(AX)(CX*%d),X1", scale)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := x86PackedZeroExtendProperties(file.Funcs[0].Instrs[1], "amd64"); err != nil {
+			t.Fatal(row, err)
+		}
+	}
+}
diff --git a/amd64_packed_zero_extend_forms.go b/amd64_packed_zero_extend_forms.go
new file mode 100644
index 000000000..51e22cd15
--- /dev/null
+++ b/amd64_packed_zero_extend_forms.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86PackedExtendSpec struct {
+	inputBits  int
+	outputBits int
+	vector     bool
+	opcode     byte
+}
+
+type x86PackedZeroExtendSpec = x86PackedExtendSpec
+
+// Legacy yxm_q4 and the two AVX tables have different physical source widths:
+// ratio two uses _yvcvtdq2pd (Y/m256 to Z); the other ratios _yvbroadcastss.
+// None permits broadcast, SAE or rounding. EVEX masking is per widened lane.
+var x86PackedZeroExtendSpecs = map[Op]x86PackedZeroExtendSpec{
+	"PMOVZXBW":  {8, 16, false, 0x30},
+	"PMOVZXBD":  {8, 32, false, 0x31},
+	"PMOVZXBQ":  {8, 64, false, 0x32},
+	"PMOVZXWD":  {16, 32, false, 0x33},
+	"PMOVZXWQ":  {16, 64, false, 0x34},
+	"PMOVZXDQ":  {32, 64, false, 0x35},
+	"VPMOVZXBW": {8, 16, true, 0x30},
+	"VPMOVZXBD": {8, 32, true, 0x31},
+	"VPMOVZXBQ": {8, 64, true, 0x32},
+	"VPMOVZXWD": {16, 32, true, 0x33},
+	"VPMOVZXWQ": {16, 64, true, 0x34},
+	"VPMOVZXDQ": {32, 64, true, 0x35},
+}
+
+type x86PackedExtendForm struct {
+	spec                x86PackedExtendSpec
+	byteWidth           int
+	sourceRegisterBytes int
+	memoryBytes         int
+	destination         int
+	memory              int
+	mask                int
+	zeroing             bool
+	signed              bool
+}
+
+type x86PackedZeroExtendForm = x86PackedExtendForm
+
+// This specifies encoding and byte effects, never caller bounds or permission.
+func x86PackedZeroExtendProperties(ins Instr, goarch string) (x86PackedZeroExtendForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if _, known := x86PackedZeroExtendSpecs[Op(base)]; !known {
+		return x86PackedExtendForm{}, false, nil
+	}
+	return x86PackedExtendProperties(ins, goarch)
+}
+
+// Sign and zero extension share operand shape, shrinking tuples and masked
+// access rules, not membership, sign-byte dependencies or raw authority.
+func x86PackedExtendProperties(ins Instr, goarch string) (x86PackedExtendForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86PackedZeroExtendSpecs[Op(base)]
+	signed := false
+	if !recognized {
+		spec, recognized = x86PackedSignExtendSpecs[Op(base)]
+		signed = true
+	}
+	if !recognized {
+		return x86PackedExtendForm{}, false, nil
+	}
+	form := x86PackedExtendForm{
+		spec: spec, destination: len(ins.Args) - 1, memory: -1, mask: -1,
+		zeroing: suffix == "Z", sourceRegisterBytes: 16, signed: signed,
+	}
+	fail := func() (x86PackedExtendForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix outside Go packed widening grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" || len(ins.Args) != 2 && len(ins.Args) != 3 ||
+		dotted && (!spec.vector || suffix != "Z") {
+		return fail()
+	}
+	if len(ins.Args) == 3 {
+		if !spec.vector || !amd64NonzeroKOperand(ins.Args[1]) {
+			return fail()
+		}
+		form.mask = 1
+	} else if form.zeroing {
+		return fail()
+	}
+	destination := ins.Args[form.destination]
+	form.byteWidth = amd64VectorByteWidth(destination.Reg)
+	if !spec.vector {
+		index, valid := amd64ParseXReg(destination.Reg)
+		if destination.Kind != OpReg || !valid || index >= 16 || goarch == "386" && index >= 8 {
+			return fail()
+		}
+	} else if !amd64GoPackedVectorMoveRegister(destination, form.byteWidth, goarch) {
+		return fail()
+	}
+	form.memoryBytes = form.byteWidth * spec.inputBits / spec.outputBits
+	if form.memoryBytes > 16 {
+		form.sourceRegisterBytes = 32
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		if !amd64EVEXVectorRegister(source, form.sourceRegisterBytes) {
+			return fail()
+		}
+		index, _ := amd64VectorRegisterIndex(source.Reg, form.sourceRegisterBytes)
+		if !spec.vector && (index >= 16 || goarch == "386" && index >= 8) {
+			return fail()
+		}
+	} else if isAMD64MemoryOperand(source) {
+		if source.Kind == OpSym {
+			symbol := strings.TrimSpace(source.Sym)
+			_, absolute := parseInt(symbol)
+			if strings.HasPrefix(symbol, "$") || !strings.HasSuffix(symbol, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if source.Kind == OpMem {
+			displacement := source.Mem.Off
+			if displacement != int64(int32(displacement)) &&
+				(goarch != "386" || displacement != int64(uint32(displacement))) ||
+				!x86MemoryRegistersValidForArch(source.Mem, goarch) || source.Mem.Index != "" &&
+				(source.Mem.Index == SP || source.Mem.Scale != 1 && source.Mem.Scale != 2 && source.Mem.Scale != 4 && source.Mem.Scale != 8) {
+				return fail()
+			}
+		}
+		form.memory = 0
+	} else {
+		return fail()
+	}
+	return form, true, x86Mode32VectorRegisterContext(ins, goarch)
+}
+
+func x86TypedPackedZeroExtendByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if _, known, err := x86PackedZeroExtendProperties(ins, arch); !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedPackedExtendByteEffect(op, ins, arch)
+}
+
+func x86TypedPackedExtendByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86PackedExtendProperties(ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if op != ins.Op {
+		return x86TypedByteEffect{}, true, fmt.Errorf("packed widening effect/source opcode mismatch")
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(form.memoryBytes), read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth),
+			read: form.mask >= 0 && !form.zeroing, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.mask, operand: ins.Args[form.mask], width: 8, read: true,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_packed_zero_extend_forms_test.go b/amd64_packed_zero_extend_forms_test.go
new file mode 100644
index 000000000..ebcfca1a0
--- /dev/null
+++ b/amd64_packed_zero_extend_forms_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Independent byte ratios, not values taken from the production spec.
+var x86ZeroExtendTestRatios = []struct {
+	suffix string
+	input  int
+	output int
+}{
+	{"BW", 1, 2}, {"BD", 1, 4}, {"BQ", 1, 8},
+	{"WD", 2, 4}, {"WQ", 2, 8}, {"DQ", 4, 8},
+}
+
+func x86ZeroExtendAcceptedForms(opcode, arch string) []string {
+	if !strings.HasPrefix(opcode, "V") {
+		last := 15
+		if arch == "386" {
+			last = 7
+		}
+		return []string{fmt.Sprintf("%s X0,X%d", opcode, last), fmt.Sprintf("%s 8(AX),X%d", opcode, last)}
+	}
+	var rows []string
+	for _, bank := range []string{"X", "Y", "Z"} {
+		source, last := "X", 31
+		if bank == "Z" && (strings.HasSuffix(opcode, "BW") || strings.HasSuffix(opcode, "WD") || strings.HasSuffix(opcode, "DQ")) {
+			source = "Y"
+		}
+		if arch == "386" {
+			last = 7
+		}
+		for _, input := range []string{source + "0", "8(AX)"} {
+			rows = append(rows, fmt.Sprintf("%s %s,%s%d", opcode, input, bank, last))
+			rows = append(rows, fmt.Sprintf("%s %s,K7,%s%d", opcode, input, bank, last),
+				fmt.Sprintf("%s.Z %s,K1,%s%d", opcode, input, bank, last))
+		}
+	}
+	// These select the two VEX optab rows rather than their EVEX aliases.
+	rows = append(rows, opcode+" X0,X1", opcode+" X0,Y1")
+	return rows
+}
+
+func TestX86PackedZeroExtendSpecsBindCompleteGoTables(t *testing.T) {
+	dir := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(x86PackedZeroExtendSpecs) != 12 {
+		t.Fatalf("unsigned family has %d names, want 12", len(x86PackedZeroExtendSpecs))
+	}
+	// Bind every operand class row, independently of the lowerer's accepted
+	// form generator. Memory width attributes belong to each opcode below.
+	legacyTable := "var yxm_q4 = []ytab{\n\t{Zm_r, 1, argList{Yxm, Yxr}},\n}"
+	if !strings.Contains(string(legacy), legacyTable) {
+		t.Fatal("Go changed the complete legacy register/memory operand table")
+	}
+	for _, table := range []string{"_yvbroadcastss", "_yvcvtdq2pd"} {
+		want := "var " + table + " = []ytab{\n"
+		want += "\t{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr}},\n"
+		want += "\t{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yyr}},\n"
+		for _, destination := range []string{"YxrEvex", "YyrEvex", "Yzr"} {
+			source := "YxmEvex"
+			if table == "_yvcvtdq2pd" && destination == "Yzr" {
+				source = "YymEvex"
+			}
+			want += fmt.Sprintf("\t{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{%s, %s}},\n", source, destination)
+			want += fmt.Sprintf("\t{zcase: Zevex_rm_k_r, zoffset: 3, args: argList{%s, Yknot0, %s}},\n", source, destination)
+		}
+		want += "}"
+		if !strings.Contains(string(avx), want) {
+			t.Fatalf("Go changed %s's complete VEX/EVEX operand table", table)
+		}
+	}
+	for index, ratio := range x86ZeroExtendTestRatios {
+		opcode := byte(0x30 + index)
+		for _, prefix := range []string{"P", "VP"} {
+			name := prefix + "MOVZX" + ratio.suffix
+			spec, present := x86PackedZeroExtendSpecs[Op(name)]
+			if !present || spec.inputBits != ratio.input*8 || spec.outputBits != ratio.output*8 || spec.vector != (prefix == "VP") || spec.opcode != opcode {
+				t.Fatalf("independent unsigned ratio/encoding mismatch: %s %+v", name, spec)
+			}
+			if prefix == "P" {
+				want := fmt.Sprintf("{A%s, yxm_q4, Pq4, opBytes{0x%02x}}", name, opcode)
+				if !strings.Contains(string(legacy), want) {
+					t.Fatalf("missing exact Go legacy row: %s", want)
+				}
+				continue
+			}
+			table := "_yvbroadcastss"
+			if ratio.output == 2*ratio.input {
+				table = "_yvcvtdq2pd"
+			}
+			marker := "{as: A" + name + ", ytab: " + table + ", prefix: Pavx, op: opBytes{"
+			start := strings.Index(string(avx), marker)
+			if start < 0 {
+				t.Fatalf("missing exact Go AVX family row: %s", marker)
+			}
+			row := strings.SplitN(string(avx)[start:], "\n\t}},", 2)[0]
+			want := marker
+			for _, width := range []int{128, 256} {
+				want += fmt.Sprintf("\n\t\tavxEscape | vex%d | vex66 | vex0F38 | vexW0, 0x%02x,", width, opcode)
+			}
+			for _, width := range []int{128, 256, 512} {
+				want += fmt.Sprintf("\n\t\tavxEscape | evex%d | evex66 | evex0F38 | evexW0, evexN%d | evexZeroingEnabled, 0x%02x,", width, width/8*ratio.input/ratio.output, opcode)
+			}
+			if row != want {
+				t.Fatalf("changed complete Go prefix/opcode/width/exception attributes:\n%s\nwant:\n%s", row, want)
+			}
+		}
+	}
+	for _, source := range []string{string(legacy), string(avx)} {
+		for _, match := range regexp.MustCompile(`\{(?:as: )?A(V?PMOVZX[A-Z]+),`).FindAllStringSubmatch(source, -1) {
+			if _, exists := x86PackedZeroExtendSpecs[Op(match[1])]; !exists {
+				t.Fatalf("Go added an unregistered unsigned family name %s", match[1])
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendNamedMode32RetainsActualPhysicalContext(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, bank := range []string{"X", "Y"} {
+			for _, high := range []int{8, 16, 31} {
+				for _, args := range []string{fmt.Sprintf("X%d,%s0", high, bank), fmt.Sprintf("X0,%s%d", bank, high)} {
+					row := "VPMOVZX" + ratio.suffix + " " + args
+					listing, err := x86ExtensionGoListing(t, "386", row)
+					if err != nil {
+						t.Fatalf("actual mode32 Go source acceptance: %s: %v\n%s", row, err, listing)
+					}
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, target := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+						if _, err := Translate(file, Options{Goarch: "386", TargetTriple: target, Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("named high register acquired physical mode32 binding: %s: %v", row, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendActualGoBytesBindRawWidths(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, row := range []string{"X0,X1", "X0,Y1", "8(AX),Y1", "X20,K3,X21", "X20,K3,Y21"} {
+			instruction := "VPMOVZX" + ratio.suffix + " " + row
+			listing, err := x86ExtensionGoListing(t, "amd64", instruction)
+			if err != nil {
+				t.Fatal(err, listing)
+			}
+			var code []byte
+			for _, line := range strings.Split(listing, "\n") {
+				fields := strings.Fields(line)
+				if len(fields) < 3 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+					continue
+				}
+				for _, field := range fields[1:] {
+					if len(field) != 2 {
+						break
+					}
+					value, err := strconv.ParseUint(field, 16, 8)
+					if err != nil {
+						break
+					}
+					code = append(code, byte(value))
+				}
+				break
+			}
+			decoded, length, recognized, err := decodedX86PackedExtendInstruction(code, 64)
+			if !recognized || err != nil || length <= 0 || decoded.Op != Op("VPMOVZX"+ratio.suffix) {
+				t.Fatalf("actual Go object did not decode as source family: %s/%x: %+v %v", instruction, code, decoded, err)
+			}
+			form, recognized, err := x86PackedZeroExtendProperties(decoded, "amd64")
+			if !recognized || err != nil || form.memoryBytes != form.byteWidth*ratio.input/ratio.output {
+				t.Fatalf("actual raw width lost its independent source ratio: %+v %v", form, err)
+			}
+		}
+	}
+}
diff --git a/amd64_packed_zero_extend_mode32_initialized_test.go b/amd64_packed_zero_extend_mode32_initialized_test.go
new file mode 100644
index 000000000..d257fc97c
--- /dev/null
+++ b/amd64_packed_zero_extend_mode32_initialized_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Retain the original six ratios, three banks, register/native source and
+// merging/zeroing directory in the same order. These rows alone supply no
+// numerical bytes, pointer, old destination or mask.
+func x86ZeroExtendLowMaskedMode32Rows(t *testing.T) []string {
+	t.Helper()
+	var rows []string
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			source := "X0"
+			if bank == "Z" && ratio.output == 2*ratio.input {
+				source = "Y0"
+			}
+			for _, input := range []string{source, "(AX)"} {
+				for _, suffix := range []string{"", ".Z"} {
+					rows = append(rows, fmt.Sprintf("VPMOVZX%s%s %s,K7,%s7", ratio.suffix, suffix, input, bank))
+				}
+			}
+		}
+	}
+	if len(rows) != 72 {
+		t.Fatal("complete original low-bank K7 format directory changed", len(rows))
+	}
+	return rows
+}
+
+func x86ZeroExtendLowMaskedInitialized(row, name string) (string, string) {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVL p+0(FP),AX\nVMOVUPS (AX),Z7\n", name)
+	if !strings.Contains(row, "(AX)") {
+		source.WriteString("VMOVUPS (AX),Y0\n")
+	}
+	source.WriteString("KMOVD mask+4(FP),K7\n" + row + "\nPEXTRD $0,X7,AX\nMOVL AX,ret+8(FP)\nRET\n")
+	return source.String(), fmt.Sprintf("func %s(p *[64]byte,mask uint32) uint32\n", name)
+}
+
+func TestX86PackedZeroExtendLowMaskedMode32InitializedThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86ZeroExtendLowMaskedMode32Rows(t)
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for batch := 0; batch < 2; batch++ {
+			t.Run(fmt.Sprintf("%s/batch%d", triple, batch), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index, row := range rows[batch*36 : (batch+1)*36] {
+					program, declaration := x86ZeroExtendLowMaskedInitialized(row, fmt.Sprint("LowMasked", index))
+					source.WriteString(program)
+					declarations.WriteString(declaration)
+				}
+				x86LEAActualTargetGoObject(t, "386", triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "386", triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("actual initialized low-bank K7 program lost public translation", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, text, level)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedZeroExtendLowMaskedMode32RetainsActualInputs(t *testing.T) {
+	for _, row := range x86ZeroExtendLowMaskedMode32Rows(t) {
+		t.Run(row, func(t *testing.T) {
+			source, declaration := x86ZeroExtendLowMaskedInitialized(row, "LowMasked")
+			mutations := map[string]string{
+				"missing-address": "MOVL p+0(FP),AX\n",
+				"missing-mask":    "KMOVD mask+4(FP),K7\n",
+			}
+			if !strings.Contains(row, "(AX)") {
+				mutations["missing-register-source"] = "VMOVUPS (AX),Y0\n"
+			}
+			if !strings.Contains(row, ".Z ") {
+				mutations["missing-merge-bytes"] = "VMOVUPS (AX),Z7\n"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", "i386-unknown-linux-gnu", api); err != nil || ir == "" {
+					t.Fatal("initialized control failed before input mutations", api, err)
+				}
+				for name, removed := range mutations {
+					changed := strings.Replace(source, removed, "", 1)
+					if changed == source {
+						t.Fatal("input mutation did not apply", name)
+					}
+					if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "386", "i386-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("complete widening borrowed a missing input", api, name, err)
+					}
+				}
+				if strings.Contains(row, ".Z ") {
+					withoutOld := strings.Replace(source, "VMOVUPS (AX),Z7\n", "", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, withoutOld, declaration, "386", "i386-unknown-linux-gnu", api); err != nil || ir == "" {
+						t.Fatal("zeroing register widening incorrectly requires old merge bytes", api, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_packed_zero_extend_native_runtime_unix_test.go b/amd64_packed_zero_extend_native_runtime_unix_test.go
new file mode 100644
index 000000000..9bde099a7
--- /dev/null
+++ b/amd64_packed_zero_extend_native_runtime_unix_test.go
@@ -0,0 +1,108 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Legacy and VEX-X live/dead kernels use actual original legacy Go bytes as
+// their reference. Masked X/Y/Z dead reads use an independent volatile byte
+// reference: portable LLVM execution does not certify native AVX512 execution.
+// The complete-byte runtime separately checks masks, aliases, FLAGS and MXCSR.
+func TestCrossLinuxRuntimeMatrixX86PackedZeroExtendNativeResultsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const ratiosPerBatch = 3
+	for batch := 0; batch < 2; batch++ {
+		t.Run(fmt.Sprint("batch", batch), func(t *testing.T) {
+			var source, declarations, prototypes, originals, rows strings.Builder
+			count := 0
+			for _, ratio := range x86ZeroExtendTestRatios[batch*ratiosPerBatch : (batch+1)*ratiosPerBatch] {
+				add := func(instruction string, width, discarded int, mask int64, native bool) {
+					name := fmt.Sprintf("Widen%d", count)
+					original := fmt.Sprintf("Original%d", count)
+					count++
+					body := "MOVQ p+0(FP),DX\n"
+					if strings.Contains(instruction, "K1") {
+						body += fmt.Sprintf("MOVQ $%d,AX\nKMOVQ AX,K1\n", mask)
+					}
+					body += instruction + "\nPEXTRQ $0,X1,AX\n"
+					if discarded != 0 {
+						body += "MOVQ $0x87654321fedcba98,AX\n"
+					}
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\n%sMOVQ AX,ret+8(FP)\nRET\n", name, body)
+					fmt.Fprintf(&declarations, "func %s(p *[32]byte) uint64\n", name)
+					fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\n", name)
+					if native {
+						nativeBody := "PMOVZX" + ratio.suffix + " (DI),X0\nPEXTRQ $0,X0,AX\n"
+						if discarded != 0 {
+							nativeBody += "MOVQ $0x87654321fedcba98,AX\n"
+						}
+						code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+nativeBody+"RET\n")
+						var bytes []string
+						for _, value := range code {
+							bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+						}
+						symbol := original
+						if strings.Contains(execution.triple, "apple") {
+							symbol = "_" + symbol
+						}
+						fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+						fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\n", original)
+					} else {
+						fmt.Fprintf(&originals, "static uint64_t %s(const uint8_t *p) {\n", original)
+						fmt.Fprintf(&originals, "    for (unsigned b = 0; b < %d; b++) {\n", width)
+						originals.WriteString("        volatile uint8_t value = ((volatile const uint8_t*)p)[b];\n        (void)value;\n    }\n")
+						originals.WriteString("    return UINT64_C(0x87654321fedcba98);\n}\n")
+					}
+					fmt.Fprintf(&rows, "{%s,%s,%d,%d,%d,%d},\n", name, original, width, discarded, ratio.input, ratio.output)
+				}
+				for _, prefix := range []string{"P", "VP"} {
+					for discarded := 0; discarded < 2; discarded++ {
+						add(prefix+"MOVZX"+ratio.suffix+" (DX),X1", 16*ratio.input/ratio.output, discarded, 0, true)
+					}
+				}
+				for _, width := range []int{16, 32, 64} {
+					bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+					for _, mask := range []int64{0, 1, -1} {
+						readWidth := width * ratio.input / ratio.output
+						if mask == 0 {
+							readWidth = 0
+						} else if mask == 1 {
+							readWidth = ratio.input
+						}
+						add("VPMOVZX"+ratio.suffix+".Z (DX),K1,"+bank+"1", readWidth, 1, mask, false)
+					}
+				}
+			}
+			if count != 39 || count > 64 {
+				t.Fatal("incomplete or oversized widening read matrix", count)
+			}
+			goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+			driver := fmt.Sprintf(x86NativeScalarReadRuntimeC, prototypes.String(), originals.String(), rows.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprint("O2=", optimized), func(t *testing.T) {
+							text, level := ir, "-O0"
+							if optimized {
+								text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+							}
+							output := execution.compileAndRunLLVM(t, "widen-native", text, driver, level)
+							if string(output) != "39 native scalar kernels: numerical 4992, faults 468, tripwires 2; failures 0\n" {
+								t.Fatal("widening numerical/dead/native/masked reads differ:", string(output))
+							}
+							t.Log("Original legacy Go / portable masked-read reference:", strings.TrimSpace(string(output)))
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_packed_zero_extend_raw_axes_test.go b/amd64_packed_zero_extend_raw_axes_test.go
new file mode 100644
index 000000000..fb5fe334c
--- /dev/null
+++ b/amd64_packed_zero_extend_raw_axes_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedExtendRawWBitMatchesIndependentLLVMDecoder(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, spec := range rawPackedExtendTestSpecs {
+		for _, evex := range []bool{false, true} {
+			for width := 0; width < 3; width++ {
+				if !evex && width == 2 {
+					continue
+				}
+				code := encodeX86VEXPackedExtend(spec.opcode, width != 0, 1, 0)
+				code[2] |= 0x80 // All VEX forms are WIG, not W0.
+				if evex {
+					code = encodeX86EVEXPackedExtend(spec.opcode, byte(width), 1, true, 1, 0)
+					code[2] |= 0x80 // EVEX is WIG except signed/unsigned DQ.
+				}
+				var bytes strings.Builder
+				for _, value := range code {
+					fmt.Fprintf(&bytes, "0x%02x ", value)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=x86_64", "--mattr=+avx,+avx2,+avx512f,+avx512bw,+avx512vl")
+				command.Stdin = strings.NewReader(bytes.String() + "\n")
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				cancel()
+				invalid := evex && spec.inputBits == 32
+				if invalid {
+					if !strings.Contains(string(output), "invalid instruction encoding") {
+						t.Fatalf("LLVM22 did not reject EVEX DQ W1 %x: %v\n%s", code, err, output)
+					}
+				} else if err != nil || !strings.Contains(strings.ToUpper(string(output)), string(spec.op)) {
+					t.Fatalf("LLVM22 independent WIG decode %x: %v\n%s", code, err, output)
+				}
+				for _, mode := range []int{32, 64} {
+					ins, length, recognized, err := decodedX86PackedExtendInstruction(code, mode)
+					if invalid {
+						if !recognized || err == nil {
+							t.Fatalf("mode%d illegal EVEX DQ W1 acquired widening semantics: %x %+v/%v", mode, code, ins, err)
+						}
+					} else if !recognized || err != nil || length != len(code) || strings.TrimSuffix(string(ins.Op), ".Z") != string(spec.op) {
+						t.Fatalf("mode%d legal WIG %x lost exact family semantics: %+v/%v", mode, code, ins, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendActualGoLowMaskedMode32(t *testing.T) {
+	rows := x86ZeroExtendLowMaskedMode32Rows(t)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			listing, err := x86ExtensionGoListing(t, "386", row)
+			if err != nil {
+				t.Fatalf("actual mode32 Go acceptance: %s: %v\n%s", row, err, listing)
+			}
+			// Keep the complete original uninitialized source. The Go object
+			// proves this syntax, not its missing source, K7, merge or address.
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func f()\n", "386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("uninitialized original mask form invented numerical inputs", row, api, err)
+				}
+			}
+		})
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for all original private formats")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for batch := 0; batch < 2; batch++ {
+			t.Run(fmt.Sprintf("private-formats/%s/batch%d", triple, batch), func(t *testing.T) {
+				var source strings.Builder
+				for index, row := range rows[batch*36 : (batch+1)*36] {
+					fmt.Fprintf(&source, "TEXT Format%d(SB),4,$0-0\n%s\nRET\n", index, row)
+				}
+				file, signatures := x86UnboundVoidFormatSources(t, source.String(), "386", triple)
+				ir := x86InstructionFormatObjectUnit(t, file, signatures, "386", triple, 0,
+					func(ctx *amd64Ctx, ins Instr) (bool, bool, error) {
+						return ctx.lowerPackedZeroExtendMove(ins.Op, ins)
+					})
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_zero_extend_result.go b/amd64_packed_zero_extend_result.go
new file mode 100644
index 000000000..61c394f4e
--- /dev/null
+++ b/amd64_packed_zero_extend_result.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+func x86ResultPackedZeroExtendStep(ins Instr, state *x86ResultState, owned []bool, arch string, conditionalNativeRead bool) (bool, bool) {
+	form, known, err := x86PackedZeroExtendProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !conditionalNativeRead || !x86RawZeroExtendSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultPackedExtendTransfer(ins, form, state, owned, arch, conditionalNativeRead), true
+}
+
+func x86ResultPackedSignExtendStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedSignExtendProperties(ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known // No raw SX role follows from the separate ZX identity.
+	}
+	return x86ResultPackedExtendTransfer(ins, form, state, owned, arch, native), true
+}
+
+func x86ResultPackedExtendTransfer(ins Instr, form x86PackedExtendForm, state *x86ResultState,
+	owned []bool, arch string, conditionalNativeRead bool) bool {
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	var input uint64
+	if form.memory >= 0 {
+		// Only the lowering observer may use the paired native E5 read.
+		// The full potential tuple remains required for FP/AUTO/caller proofs;
+		// a numerical mask cannot manufacture a smaller owned envelope.
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[0], int64(form.memoryBytes), state, owned, arch, conditionalNativeRead) {
+			return false
+		}
+		input = x86CallerVectorByteMask(int64(form.memoryBytes))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[0].Reg, form.sourceRegisterBytes)
+		input = state.vectorBytes(index)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	initialized := x86PackedExtendDefinedBytes(form, input, state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, initialized, !form.spec.vector)
+	return true
+}
diff --git a/amd64_packed_zero_extend_result_test.go b/amd64_packed_zero_extend_result_test.go
new file mode 100644
index 000000000..2ac7c2ea7
--- /dev/null
+++ b/amd64_packed_zero_extend_result_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedZeroExtendResultConsumers(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, native := range []bool{false, true} {
+			t.Run(fmt.Sprint(target.triple, "/native=", native), func(t *testing.T) {
+				var source, declarations strings.Builder
+				count := 0
+				for _, ratio := range x86ZeroExtendTestRatios {
+					for _, vector := range []bool{false, true} {
+						for _, width := range []int{16, 32, 64} {
+							if !vector && width != 16 {
+								continue
+							}
+							for masking := 0; masking < 3; masking++ {
+								if !vector && masking != 0 {
+									continue
+								}
+								name := fmt.Sprint("Widen", count)
+								count++
+								bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+								input := "X0"
+								if width*ratio.input/ratio.output > 16 {
+									input = "Y0"
+								}
+								offset, load, declaration := 8, "MOVQ value+0(FP),X0", "value uint64"
+								if native {
+									input, load, declaration = "(DX)", "MOVQ value+0(FP),DX", "value *[32]byte"
+									if target.arch == "386" {
+										offset, load = 4, "MOVL value+0(FP),DX"
+									}
+								}
+								row := "PMOVZX" + ratio.suffix
+								if vector {
+									row = "V" + row
+								}
+								if masking == 2 {
+									row += ".Z"
+								}
+								row += " " + input + ","
+								if masking != 0 {
+									row += "K1,"
+								}
+								row += bank + "1"
+								fmt.Fprintf(&declarations, "func %s(%s) uint32\n", name, declaration)
+								fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nVZEROALL\n%s\nMOVL $1,AX\nKMOVW AX,K1\n%s\nPEXTRD $0,X1,AX\nMOVL AX,ret+%d(FP)\nRET\n", name, offset+4, load, row, offset)
+							}
+						}
+					}
+				}
+				if count != 60 || count > 64 {
+					t.Fatal("incomplete or oversized result matrix", count)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("widening result lacks its numerical consumer", api, err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "widen-result-"+api)
+					x86ResultInitializationObject(t, llc, target.triple, x86MulDivRoundOptimize(t, ir), "widen-result-"+api+"-O2")
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedZeroExtendNativeResultBoundaries(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			name := prefix + "MOVZX" + ratio.suffix
+			t.Run(name, func(t *testing.T) {
+				body := "MOVQ p+0(FP),DX\n" + name + " (DX),X1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+8(FP)\nRET"
+				_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[8]byte) uint32", body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone result observer acquired native memory", err)
+					}
+				}
+				ins := x86ScalarLaneInstruction(t, name+" -1(DX)(BX*1),X1")
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				base, _, _ := x86ResultGP(DX, 8, "amd64")
+				index, _, _ := x86ResultGP(BX, 8, "amd64")
+				state.pointerGP[base], state.gp[index] = true, 0xff
+				state.writeVector(1, 64, 0xa5a5000000000000, false)
+				before := state.clone()
+				if accepted, known := x86ResultPackedZeroExtendStep(ins, &state, nil, "amd64", true); !accepted || !known {
+					t.Fatal("paired native read has no conditional numerical bytes")
+				}
+				want := uint64(0xa5a500000000ffff)
+				if prefix == "VP" {
+					want = ^uint64(0)
+				}
+				if state.vectorBytes(1) != want || state.flags != before.flags || state.gp != before.gp || state.pointerGP != before.pointerGP {
+					t.Fatal("native widening changed another state domain")
+				}
+				for _, mutation := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment", "unknown base", "unknown index", "pointer index"} {
+					changed, rejected := ins, before.clone()
+					switch mutation {
+					case "decoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "raw return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address":
+						changed.x86AddressBits = 32
+					case "unbound address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "unknown base":
+						rejected.pointerGP[base] = false
+					case "unknown index":
+						rejected.gp[index] = 0
+					case "pointer index":
+						// A reaching pointer import revokes numerical bytes.
+						// Only the source-wide shape pass carries their union.
+						rejected.pointerGP[index], rejected.gp[index] = true, 0
+					}
+					expected := rejected.clone()
+					if accepted, _ := x86ResultPackedZeroExtendStep(changed, &rejected, nil, "amd64", true); accepted || !reflect.DeepEqual(rejected, expected) {
+						t.Fatal("unbound origin/address acquired native result bytes", mutation)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedZeroExtendResultTupleAndMaskBoundaries(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			ins := x86ScalarLaneInstruction(t, "VPMOVZX"+ratio.suffix+".Z value+0(FP),K1,"+bank+"1")
+			for missing := -1; missing < 32; missing++ {
+				for _, maskKnown := range []bool{false, true} {
+					state := x86ResultState{fp: make([]bool, 32)}
+					owned := make([]bool, 32)
+					for index := range owned {
+						owned[index], state.fp[index] = true, index != missing
+					}
+					state.masks[1] = maskKnown
+					accepted := x86ResultTransfer(ins, &state, owned, 32, "amd64")
+					want := maskKnown && (missing < 0 || missing >= width*ratio.input/ratio.output)
+					if accepted != want || accepted && state.vectorBytes(1) != ^uint64(0) || len(ins.x86CallerMemory) != 0 {
+						t.Fatal("mask/tuple invented source bytes or caller permission", ratio.suffix, width, missing, maskKnown)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedZeroExtendNativeResultsKeepWholeSourceBoundaries(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, prefix := range []string{"P", "VP"} {
+			name := prefix + "MOVZX" + ratio.suffix
+			t.Run(name, func(t *testing.T) {
+				load := name + " (DX),X1\n"
+				for mutation, body := range map[string]string{
+					"pointer index":       name + " (DX)(DX*1),X1\n",
+					"lost pointer":        "MOVL $1,DX\n" + load,
+					"missing path":        "MOVL $0,BX\nCMPL BX,$0\nJE after\n" + load + "after:\n",
+					"unknown store input": load + "MOVL BX,(DX)\n",
+					"input write":         load + "MOVQ $1,p+0(FP)\n",
+				} {
+					source := "TEXT ·Value(SB),4,$0-12\nMOVQ p+0(FP),DX\n" + body + "PEXTRD $0,X1,AX\nMOVL AX,ret+8(FP)\nRET\n"
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					if mutation == "lost pointer" {
+						x86RequireNumericNativeSourceContext(t, source, "func Value(p *[32]byte) uint32", "amd64")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[32]byte) uint32", "amd64", "x86_64-unknown-linux-gnu", api)
+						if mutation == "lost pointer" {
+							read := fmt.Sprintf("load volatile <%d x i8>", 16*ratio.input/ratio.output)
+							if err != nil || !strings.Contains(ir, read) {
+								t.Fatal("complete NUM address lost its shrinking source tuple", api, err)
+							}
+							x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+							continue
+						}
+						if mutation == "missing path" {
+							x86VectorScratchCodegenControl(t, source, "func Value(p *[32]byte) uint32", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+							continue
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("widening result borrowed another source contract", mutation, api, err)
+						}
+					}
+				}
+				body := "MOVQ p+0(FP),DX\n" + load + "PEXTRD $0,X1,AX\nMOVL AX,ret0+8(FP)\nRET"
+				_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[32]byte) uint32", body)
+				for _, origin := range []string{"raw TEXT", "source stack", "fixed local"} {
+					fn := file.Funcs[0]
+					switch origin {
+					case "raw TEXT":
+						fn.X86RawText = []byte{0xc3}
+					case "source stack":
+						fn.x86SourceStack = new(x86SourceStackProof)
+					case "fixed local":
+						fn.x86FixedLocal = new(x86FixedLocalProof)
+					}
+					ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+					if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("widening result bypassed original entry boundary", origin, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedZeroExtendDeadNativeReads(t *testing.T) {
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, row := range []string{
+			"PMOVZX" + ratio.suffix + " (DX),X1",
+			"VPMOVZX" + ratio.suffix + " (DX),Z1",
+			"VPMOVZX" + ratio.suffix + ".Z (DX),K1,Z1",
+		} {
+			t.Run(row, func(t *testing.T) {
+				source := "TEXT ·Read(SB),4,$0-16\nMOVQ p+0(FP),DX\nMOVQ mask+8(FP),AX\nKMOVQ AX,K1\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Read(p *[32]byte,mask uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "Go")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if !strings.Contains(text, "load volatile") || strings.Contains(row, ".Z") && !strings.Contains(text, "br i1") {
+						t.Fatal("dead widening discarded native reads or masked fault suppression")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_packed_zero_extend_runtime_test.go b/amd64_packed_zero_extend_runtime_test.go
new file mode 100644
index 000000000..f27de7dab
--- /dev/null
+++ b/amd64_packed_zero_extend_runtime_test.go
@@ -0,0 +1,315 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The byte reference uses the source spelling's mathematical ratio, not a
+// production spec or emitted instruction. Wider stores observe every alias.
+const x86ZeroExtendByteOracle = `
+static int checkExtend(
+    void (*fn)(uint8_t *, const uint8_t *, const uint8_t *, uint64_t),
+    const char *name, unsigned width, unsigned input, unsigned output,
+    int mode, int legacy, int alias, int memory
+) {
+    const uint64_t masks[] = {0, 1, UINT64_C(0x55aa55aa55aa55aa), UINT64_MAX};
+    for (unsigned round = 0; round < 4; round++) {
+        for (unsigned m = 0; m < 4; m++) {
+            uint8_t aStorage[96], bStorage[96], result[74];
+            uint8_t *a = aStorage + 1, *b = bStorage + 3;
+            memset(aStorage, 0xa7, sizeof(aStorage));
+            memset(bStorage, 0xb9, sizeof(bStorage));
+            memset(result, 0xc3, sizeof(result));
+            for (unsigned i = 0; i < 64; i++) {
+                a[i] = (uint8_t)(i * 19 + round * 83 + 129);
+                b[i] = (uint8_t)(i * 31 + round * 59 + 13);
+            }
+            uint32_t saved, before = 0x1f80 | (round << 13) | round, after;
+            __asm__ volatile("stmxcsr %0" : "=m"(saved));
+            __asm__ volatile("ldmxcsr %0" : : "m"(before));
+            fn(result + 1, a, b, masks[m]);
+            __asm__ volatile("stmxcsr %0" : "=m"(after));
+            __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+            if (after != before || result[0] != 0xc3 || result[73] != 0xc3 ||
+                result[65] != 1 || result[66] != 0) {
+                fprintf(stderr, "%s CSR/flags/canary failure\n", name);
+                return 1;
+            }
+            const uint8_t *old = alias ? a : b;
+            for (unsigned i = 0; i < 64; i++) {
+                const unsigned part = i % output;
+                const unsigned source = i / output * input + part;
+                const int active = mode == 0 || ((masks[m] >> (i / output)) & 1);
+                uint8_t want;
+                if (i >= width) {
+                    want = legacy ? old[i] : 0;
+                } else if (!active) {
+                    want = mode == 2 ? 0 : old[i];
+                } else {
+                    want = part < input ? a[source] : 0;
+                }
+                if (result[i + 1] != want || a[i] != (uint8_t)(i * 19 + round * 83 + 129) ||
+                    b[i] != (uint8_t)(i * 31 + round * 59 + 13)) {
+                    fprintf(stderr, "%s byte=%u got=%x want=%x\n", name, i, result[i + 1], want);
+                    return 1;
+                }
+            }
+            for (unsigned i = 0; i < 96; i++) {
+                if ((i < 1 || i >= 65) && aStorage[i] != 0xa7) return 1;
+                if ((i < 3 || i >= 67) && bStorage[i] != 0xb9) return 1;
+            }
+        }
+    }
+    if (memory) {
+        uint8_t b[64], result[74];
+        memset(b, 0x59, sizeof(b));
+        memset(result, 0xc3, sizeof(result));
+        if (mode != 0) {
+            // Irrelevant high mask bits cannot access an entirely inactive NULL.
+            fn(result + 1, NULL, b, UINT64_C(1) << 63);
+            for (unsigned i = 0; i < 64; i++) {
+                uint8_t want = i < width && mode == 1 ? 0x59 : 0;
+                if (result[i + 1] != want) return 1;
+            }
+            if (result[0] != 0xc3 || result[73] != 0xc3 || result[65] != 1 || result[66] != 0) return 1;
+        }
+        if (setup_guard()) return 1;
+        // An unmasked source uses its shrinking native tuple width, not a
+        // complete X/Y allocation. A masked source needs one active element.
+        unsigned sourceBytes = mode == 0 ? width * input / output : input;
+        uint8_t *last = guard + page - sourceBytes;
+        for (unsigned i = 0; i < sourceBytes; i++) ((volatile uint8_t *)last)[i] = (uint8_t)(0xd0 + i);
+        fn(result + 1, last, b, 1);
+        int failed = result[0] != 0xc3 || result[73] != 0xc3 || result[65] != 1 || result[66] != 0;
+        for (unsigned i = 0; i < 64; i++) {
+            unsigned part = i % output;
+            int active = mode == 0 || i < output;
+            uint8_t want = i >= width ? (legacy ? 0x59 : 0) :
+                           active ? (part < input ? (uint8_t)(0xd0 + i / output * input + part) : 0) :
+                           mode == 1 ? 0x59 : 0;
+            if (result[i + 1] != want || b[i] != 0x59) failed = 1;
+        }
+        if (free_guard()) return 1;
+        if (failed) return 1;
+    }
+    return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PackedZeroExtendCompleteBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, vector := range []bool{false, true} {
+			for _, width := range []int{16, 32, 64} {
+				if !vector && width != 16 {
+					continue
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				sourceBank := "X"
+				if width*ratio.input/ratio.output > 16 {
+					sourceBank = "Y"
+				}
+				for _, memory := range []bool{false, true} {
+					for mode := 0; mode < 3; mode++ {
+						if !vector && mode != 0 {
+							continue
+						}
+						for _, destination := range []int{0, 1} {
+							if memory && destination == 0 {
+								continue // Memory has no register-source alias.
+							}
+							name := fmt.Sprintf("extend%d", count)
+							count++
+							opcode := "PMOVZX" + ratio.suffix
+							if vector {
+								opcode = "V" + opcode
+							}
+							input, mask := sourceBank+"0", ""
+							if memory {
+								input = "(BX)"
+							}
+							if mode != 0 {
+								mask = "K1,"
+								if mode == 2 {
+									opcode += ".Z"
+								}
+							}
+							fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\nVMOVUPS (CX),Z1\n", name)
+							if !memory {
+								assembly.WriteString("VMOVUPS (BX),Z0\n")
+							}
+							fmt.Fprintf(&assembly, "KMOVQ DX,K1\nCMPQ AX,AX\nSTC\n%s %s,%s%s%d\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", opcode, input, mask, bank, destination, destination)
+							sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+								{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+								{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+								{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+								{Offset: 24, Type: I64, Index: 3, Field: -1},
+							}}}
+							fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+							fmt.Fprintf(&checks, "    if (checkExtend(%s,\"%s\",%d,%d,%d,%d,%d,%d,%d)) return 1;\n", name, name, width, ratio.input, ratio.output, mode, x86FloatAddSubBoolInt(!vector), x86FloatAddSubBoolInt(destination == 0), x86FloatAddSubBoolInt(memory))
+						}
+					}
+				}
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" +
+		declarations.String() + x86TestGuardPagesC + x86ZeroExtendByteOracle +
+		"\nint main(void) {\n" + checks.String() + "    return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "zero-extend-bytes", triple, ir, oracle, prefix)
+	t.Logf("%d ratio/width/register-memory/mask/self-alias programs, 16 complete-byte flags/MXCSR/canary inputs each; inactive NULL and page-boundary reads", count)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedZeroExtendOriginalGoBytes(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	var declarations, assembly, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	checks.WriteString(`package oracle
+import "testing"
+func TestOriginalGoUnsignedBits(t *testing.T) {
+    for round := 0; round < 4; round++ {
+        var input, old [64]byte
+        for i := range input {
+            input[i] = byte(i*19 + round*83 + 129)
+            old[i] = byte(i*31 + round*59 + 13)
+        }
+`)
+	count := 0
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, memory := range []bool{false, true} {
+			for _, alias := range []bool{false, true} {
+				if memory && alias {
+					continue
+				}
+				name := fmt.Sprintf("original%d", count)
+				count++
+				fmt.Fprintf(&declarations, "func %s(a,b,out *byte)\n", name)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),CX\nMOVOU (BX),X1\n", name)
+				source, destination := "(AX)", "X1"
+				if !memory {
+					assembly.WriteString("MOVOU (AX),X0\n")
+					source = "X0"
+					if alias {
+						destination = "X0"
+					}
+				}
+				fmt.Fprintf(&assembly, "CMPQ AX,AX\nSTC\nPMOVZX%s %s,%s\nMOVOU %s,(CX)\nSETCS 16(CX)\nSETNE 17(CX)\nRET\n", ratio.suffix, source, destination, destination)
+				fmt.Fprintf(&checks, `
+        {
+            var result [20]byte
+            for i := range result { result[i] = 0xc3 }
+            %[1]s(&input[0], &old[0], &result[1])
+            if result[0] != 0xc3 || result[19] != 0xc3 || result[17] != 1 || result[18] != 0 {
+                t.Fatalf("%[1]s flags/canary failure: %%x", result)
+            }
+            for i := 0; i < 16; i++ {
+                want := byte(0)
+                if i%%%[2]d < %[3]d { want = input[i/%[2]d*%[3]d+i%%%[2]d] }
+                if result[i+1] != want { t.Fatalf("%[1]s byte %%d got %%x want %%x", i, result[i+1], want) }
+            }
+        }
+`, name, ratio.output, ratio.input)
+			}
+		}
+	}
+	checks.WriteString("    }\n}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(),
+		"value_amd64.s": assembly.String(), "value_test.go": checks.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=1", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go unsigned byte oracle: %v\n%s", err, output)
+	}
+	t.Logf("%d original legacy SSE4.1 register/memory/self-alias functions, 4 complete-byte/flags/canary inputs each; not native VEX/EVEX execution", count)
+}
+
+func TestCrossLinuxRuntimeMatrixX86PackedZeroExtendIndependentFPBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var assembly, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, ratio := range x86ZeroExtendTestRatios {
+		for _, width := range []int{16, 32, 64} {
+			for _, legacy := range []bool{false, true} {
+				if legacy && width != 16 {
+					continue
+				}
+				name := fmt.Sprintf("fpExtend%d", count)
+				count++
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				opcode := "VPMOVZX" + ratio.suffix
+				if legacy {
+					opcode = "PMOVZX" + ratio.suffix
+				}
+				var cArgs, cInputs []string
+				sig := FuncSig{Name: name, Ret: Void}
+				for i := 0; i < 32; i++ {
+					cArgs = append(cArgs, "uint8_t")
+					cInputs = append(cInputs, fmt.Sprintf("input[%d]", i))
+					sig.Args = append(sig.Args, I8)
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i), Type: I8, Index: i, Field: -1})
+				}
+				sig.Args = append(sig.Args, Ptr)
+				sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: 32, Type: Ptr, Index: 32, Field: -1})
+				sigs[name] = sig
+				fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-40\nMOVQ out+32(FP),AX\nMOVL $89,BX\nMOVD BX,X1\nVPBROADCASTB X1,Z1\n%s a+0(FP),%s1\nVMOVUPS Z1,(AX)\nRET\n", name, opcode, bank)
+				fmt.Fprintf(&declarations, "extern void %s(%s, uint8_t *);\n", name, strings.Join(cArgs, ", "))
+				fmt.Fprintf(&checks, "    memset(result, 0xc3, sizeof(result));\n    %s(%s, result + 1);\n", name, strings.Join(cInputs, ", "))
+				fmt.Fprintf(&checks, `    for (unsigned i = 0; i < 64; i++) {
+        unsigned part = i %% %d;
+        uint8_t want = i >= %d ? %d : part < %d ? input[i / %d * %d + part] : 0;
+        if (result[i + 1] != want) {
+            fprintf(stderr, "%s independent FP byte %%u: %%x != %%x\n", i, result[i + 1], want);
+            return 1;
+        }
+    }
+    if (result[0] != 0xc3 || result[65] != 0xc3) return 1;
+`, ratio.output, width, map[bool]int{false: 0, true: 89}[legacy], ratio.input, ratio.output, ratio.input, name)
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", assembly.String(), true)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + `
+int main(void) {
+    for (unsigned round = 0; round < 4; round++) {
+        uint8_t input[32], result[66];
+        for (unsigned i = 0; i < 32; i++) input[i] = (uint8_t)(round * 83 + i * 19 + 129);
+` + checks.String() + "    }\n    return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "zero-extend-fp-bytes", triple, ir, oracle, prefix)
+	t.Logf("%d widening programs, 32 independently passed byte fields, 4 full 64-byte alias/canary inputs each", count)
+}
diff --git a/amd64_parallel_bits_cross_test.go b/amd64_parallel_bits_cross_test.go
new file mode 100644
index 000000000..48b7a6f25
--- /dev/null
+++ b/amd64_parallel_bits_cross_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This name is intentionally included by the required cross-runtime CI regex.
+func TestCrossLinuxRuntimeMatrixParallelBits386(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"i686-linux-gnu-gcc", "qemu-i386"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	var source, decl, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+		for _, raw := range []bool{false, true} {
+			name := fmt.Sprintf("parallel386_%d", index)
+			index++
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-12\nMOVL value+0(FP),AX\nMOVL mask+4(FP),BX\n", name)
+			line := op + " (BX),AX,CX\n"
+			if raw {
+				code := assembleX87ControlBytes(t, "386", "TEXT probe(SB),4,$0-0\n"+line+"RET\n")
+				for _, b := range code[:len(code)-1] {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+				}
+			} else {
+				source.WriteString(line)
+			}
+			source.WriteString("MOVL CX,ret+8(FP)\nRET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{I32, Ptr}, Ret: I32, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}}, Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}}}
+			fmt.Fprintf(&decl, "extern uint32_t %s(uint32_t,const uint32_t *);\n", name)
+			deposit := 0
+			if strings.HasPrefix(op, "PDEP") {
+				deposit = 1
+			}
+			fmt.Fprintf(&checks, "if(check(%s,mask,%d)) return %d;\n", name, deposit, index)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+` + decl.String() + `
+static void memory_fault(int signal_number) { (void)signal_number; _exit(98); }
+static uint32_t reference(uint32_t value,uint32_t mask,int deposit) {
+ uint32_t result=0,cursor=1;
+ while(mask) {uint32_t low=mask&(-mask);if(deposit ? (value&cursor)!=0 : (value&low)!=0) result|=deposit?low:cursor;mask&=mask-1;cursor<<=1;}
+ return result;
+}
+static int check(uint32_t(*fn)(uint32_t,const uint32_t *),uint32_t *mask,int deposit) {
+ uint32_t state=0x9e3779b9;
+ for(int i=0;i<256;i++) {
+  state^=state<<13;state^=state>>17;state^=state<<5;uint32_t value=state;
+  state^=state<<13;state^=state>>17;state^=state<<5;*mask=state;
+  if(i==0)*mask=0;if(i==1)*mask=0xffffffffU;if(i>=2&&i<34)*mask=1U<<(i-2);
+  if(fn(value,mask)!=reference(value,*mask,deposit)) {fprintf(stderr,"386 parallel bits mismatch case=%d deposit=%d\n",i,deposit);return 1;}
+ }
+ return 0;
+}
+int main(void) {
+ if(signal(SIGSEGV,memory_fault)==SIG_ERR)return 92;
+ long page=sysconf(_SC_PAGESIZE);if(page<4)return 90;
+ uint8_t *memory=mmap(0,page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+ if(memory==MAP_FAILED||mprotect(memory+page,page,PROT_NONE))return 91;
+ uint32_t *mask=(uint32_t *)(memory+page-4);
+` + checks.String() + "return munmap(memory,page*2)!=0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc"}, "parallel_bits_386", "i386-unknown-linux-gnu", ir, mainC, []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+}
diff --git a/amd64_permute128_forms.go b/amd64_permute128_forms.go
new file mode 100644
index 000000000..6471ef837
--- /dev/null
+++ b/amd64_permute128_forms.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Both _yvperm2f128 members have the same fixed VEX.256.W0 grammar and
+// bit-selection semantics. Their different native CPUID requirements are not
+// numerical input, memory or source permissions.
+var x86Permute128Specs = map[Op]byte{
+	"VPERM2F128": 0x06,
+	"VPERM2I128": 0x46,
+}
+
+type x86Permute128Form struct {
+	x86PackedBinaryForm
+	immediate uint8
+}
+
+func x86Permute128Properties(op Op, ins Instr, arch string) (x86Permute128Form, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	_, known := x86Permute128Specs[Op(base)]
+	result := x86Permute128Form{}
+	if !known {
+		return result, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 4 ||
+		arch == "386" && !(ins.x86Encoded && ins.x86Permute128VEX) {
+		return result, true, fmt.Errorf("%s %s has an unbound dispatch or named four-operand role", arch, op)
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || !amd64UnsignedImmediate(immediate, 8) {
+		return result, true, fmt.Errorf("%s requires Go's complete Yu8 immediate class", op)
+	}
+	local := ins
+	local.Op, local.Args = op, ins.Args[1:]
+	form, err := x86ConflictFunnelOperandGrammar(local, arch,
+		x86PackedBinarySpec{encoding: x86PackedLogicalVEX}, false)
+	form.first++
+	form.second++
+	form.destination++
+	if form.memory >= 0 {
+		form.memory++
+	}
+	result.x86PackedBinaryForm, result.immediate = form, uint8(immediate.Imm)
+	if err == nil && form.byteWidth != 32 {
+		err = fmt.Errorf("%s requires exactly VEX.256 operands", op)
+	}
+	return result, true, err
+}
+
+// Return one byte in the two Plan9 sources, or -1 for an immediate zero.
+// Intel SRC1 is Plan9 source two. Selector bits 2 and 6 have no effect.
+func (form x86Permute128Form) sourceByte(output int) int {
+	control := form.immediate >> uint(output/16*4)
+	if control&8 != 0 {
+		return -1
+	}
+	selected := int(control & 3)
+	source := 32
+	if selected >= 2 {
+		source = 0
+	}
+	return source + selected%2*16 + output%16
+}
+
+func (form x86Permute128Form) inputsDefined(first, second uint64) bool {
+	for output := 0; output < 32; output++ {
+		selected := form.sourceByte(output)
+		if selected < 0 {
+			continue
+		}
+		known := first
+		if selected >= 32 {
+			known, selected = second, selected-32
+		}
+		if known>>uint(selected)&1 == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func x86TypedPermute128ByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86Permute128Properties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: 32, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: 32, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: 32, write: true},
+	}}, true, nil
+}
diff --git a/amd64_permute_inlane_forms.go b/amd64_permute_inlane_forms.go
new file mode 100644
index 000000000..e0510d656
--- /dev/null
+++ b/amd64_permute_inlane_forms.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Both members share Go's complete eighteen-row _yvpermilpd grammar. The
+// immediate selects data bytes; variable control reads a separate vector.
+var x86InLanePermuteBits = map[Op]int{"VPERMILPS": 32, "VPERMILPD": 64}
+
+// Both permute families share their operand, mask and E4NF envelopes. Their
+// selector topology and which variable operand is data remain distinct.
+type x86ElementPermuteForm struct {
+	bits, byteWidth, source, data, destination, mask, memory, memoryBytes int
+	immediate, broadcast, zeroing, wholeVector                            bool
+	selector                                                              uint8
+}
+
+func x86InLanePermuteProperties(op Op, ins Instr, arch string) (x86ElementPermuteForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86InLanePermuteBits[Op(base)]
+	if !known {
+		return x86ElementPermuteForm{}, false, nil
+	}
+	return x86ElementPermuteFormProperties(op, ins, arch, bits, false)
+}
+
+func x86ElementPermuteProperties(op Op, ins Instr, arch string) (x86ElementPermuteForm, bool, error) {
+	if form, known, err := x86InLanePermuteProperties(op, ins, arch); known {
+		return form, true, err
+	}
+	if form, known, err := x86QwordPermuteProperties(op, ins, arch); known {
+		return form, true, err
+	}
+	return x86VariableDwordPermuteProperties(op, ins, arch)
+}
+
+func x86VariableDwordPermuteProperties(op Op, ins Instr, arch string) (x86ElementPermuteForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	switch base {
+	case "VPERMD", "VPERMPS":
+	default:
+		return x86ElementPermuteForm{}, false, nil
+	}
+	form, known, err := x86ElementPermuteFormProperties(op, ins, arch, 32, true)
+	if err == nil && form.immediate {
+		err = fmt.Errorf("%s requires a vector index source, not an immediate", op)
+	}
+	return form, known, err
+}
+
+func x86ElementPermuteFormProperties(op Op, ins Instr, arch string, bits int, wholeVector bool) (x86ElementPermuteForm, bool, error) {
+	_, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	f := x86ElementPermuteForm{bits: bits, wholeVector: wholeVector, source: 0, data: 1,
+		destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86ElementPermuteForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go's complete element-permute grammar: %q", arch, op, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return fail()
+	}
+	switch suffix {
+	case "":
+		if dotted {
+			return fail()
+		}
+	case "Z":
+		f.zeroing = true
+	case "BCST":
+		f.broadcast = true
+	case "BCST.Z":
+		f.broadcast, f.zeroing = true, true
+	default:
+		return fail()
+	}
+	if len(ins.Args) == 4 {
+		if arch == "386" || !amd64NonzeroKOperand(ins.Args[2]) {
+			return fail() // Named mode32's three-operand limit is not a physical EVEX restriction.
+		}
+		f.mask = 2
+	} else if f.zeroing {
+		return fail()
+	}
+	f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	register := func(operand Operand) bool {
+		if !amd64EVEXVectorRegister(operand, f.byteWidth) {
+			return false
+		}
+		index, _ := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+		return arch != "386" || f.byteWidth != 64 || index < 8
+	}
+	if f.byteWidth != 16 && f.byteWidth != 32 && f.byteWidth != 64 || wholeVector && f.byteWidth == 16 ||
+		!register(ins.Args[f.destination]) {
+		return fail()
+	}
+	f.immediate = ins.Args[0].Kind == OpImm
+	if f.immediate {
+		constant, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+		if !integer || constant.Imm < -128 || constant.Imm > 255 {
+			return fail()
+		}
+		f.source, f.data, f.selector = 1, -1, uint8(constant.Imm)
+		if constant.Imm < 0 && (f.broadcast || amd64PackedWordShuffleRequiresEVEX(
+			ins.Args[f.source], ins.Args[f.destination], f.byteWidth, f.mask >= 0)) {
+			return fail()
+		}
+	} else if !register(ins.Args[f.data]) {
+		return fail()
+	}
+	source := ins.Args[f.source]
+	if isAMD64MemoryOperand(source) && x86PackedShiftMemoryValid(source, arch) {
+		f.memory, f.memoryBytes = f.source, f.byteWidth
+		if f.broadcast {
+			f.memoryBytes = bits / 8
+		}
+	} else if f.broadcast || !register(source) {
+		return fail()
+	}
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+func (f x86ElementPermuteForm) sourceByte(output int) int {
+	if f.broadcast {
+		return output % (f.bits / 8)
+	}
+	bytes := f.bits / 8
+	lane := output / bytes
+	if f.wholeVector {
+		return output/32*32 + int(f.selector>>uint(2*(lane%4))&3)*8 + output%8
+	}
+	control, mask := uint(lane), uint8(1)
+	if f.bits == 32 {
+		control, mask = uint(2*(lane%4)), 3
+	}
+	return output/16*16 + int(f.selector>>control&mask)*bytes + output%bytes
+}
+
+func x86TypedElementPermuteByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86ElementPermuteProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := f.byteWidth
+	if f.memory >= 0 {
+		width = f.memoryBytes
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: f.source, operand: ins.Args[f.source], width: int64(width), read: true},
+		{index: f.destination, operand: ins.Args[f.destination], width: int64(f.byteWidth), write: true},
+	}}
+	if f.data >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: f.data, operand: ins.Args[f.data], width: int64(f.byteWidth), read: true})
+	}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+		if !f.zeroing {
+			effect.operands[1].read = true
+		}
+	}
+	return effect, true, nil
+}
diff --git a/amd64_permute_qword_forms.go b/amd64_permute_qword_forms.go
new file mode 100644
index 000000000..7656cceb8
--- /dev/null
+++ b/amd64_permute_qword_forms.go
@@ -0,0 +1,16 @@
+package plan9asm
+
+import "strings"
+
+// Both members share all ten Go _yvpermq rows. Immediate control repeats
+// within each 256-bit block; variable control selects from the full vector.
+var x86QwordPermuteBits = map[Op]int{"VPERMQ": 64, "VPERMPD": 64}
+
+func x86QwordPermuteProperties(op Op, ins Instr, arch string) (x86ElementPermuteForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := x86QwordPermuteBits[Op(base)]
+	if !known {
+		return x86ElementPermuteForm{}, false, nil
+	}
+	return x86ElementPermuteFormProperties(op, ins, arch, bits, true)
+}
diff --git a/amd64_polynomial_fold_composition_test.go b/amd64_polynomial_fold_composition_test.go
new file mode 100644
index 000000000..e90633208
--- /dev/null
+++ b/amd64_polynomial_fold_composition_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86PolynomialFoldDeclaration = "func fold(p *[128]byte, n, seed uint32) uint32\n"
+
+// A first-party polynomial fold, not a copied CRC implementation. Its complete
+// result path crosses native pointer reads, private aligned DATA, both CLMUL
+// qword selectors, byte/lane shifts, a loop backedge and a two-arm value join.
+func x86PolynomialFoldSource(arch string) string {
+	word, move, add := 8, "MOVQ", "ADDQ"
+	if arch == "386" {
+		word, move, add = 4, "MOVL", "ADDL"
+	}
+	return fmt.Sprintf(`DATA foldPoly<>+0(SB)/8,$0x1f123bb5a7c9d001
+DATA foldPoly<>+8(SB)/8,$0xa7c1e305f1b692d3
+GLOBL foldPoly<>(SB),8,$16
+
+TEXT ·fold(SB),4,$0-%d
+	%s p+0(FP),SI
+	MOVL n+%d(FP),CX
+	MOVL seed+%d(FP),AX
+	PXOR X1,X1
+	PINSRD $0,AX,X1
+	MOVOA foldPoly<>(SB),X3
+	CMPL CX,$0
+	JE finish
+loop:
+	MOVOU (SI),X0
+	PXOR X0,X1
+	MOVOU X1,X2
+	PCLMULQDQ $0,X3,X1
+	PCLMULQDQ $17,X3,X2
+	PSRLDQ $8,X2
+	PXOR X2,X1
+	TESTL $1,CX
+	JE even
+	MOVOU X1,X4
+	PSRLQ $7,X4
+	PXOR X4,X1
+	JMP joined
+even:
+	MOVOU X1,X4
+	PSLLQ $3,X4
+	PXOR X4,X1
+joined:
+	%s $16,SI
+	SUBL $1,CX
+	JNE loop
+finish:
+	MOVOU X1,X2
+	PSRLO $8,X2
+	PXOR X2,X1
+	PSRLQ $11,X1
+	PEXTRD $0,X1,AX
+	MOVL AX,ret+%d(FP)
+	RET
+`, word+12, move, word, word+4, add, word+8)
+}
+
+func TestX86PolynomialFoldCompositionThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x86PolynomialFoldSource(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, x86PolynomialFoldDeclaration, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, native := range []string{"movdqu", "movdqa"} {
+					if !strings.Contains(ir, "asm sideeffect \""+native+" ($1), $0\"") {
+						t.Fatal(api, "conditional result lost its original native load", native)
+					}
+				}
+				compileLLVMToObject(t, llc, target.triple, "polynomial-fold.ll", "polynomial-fold.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86PolynomialFoldCompositionDoesNotCreateStandalonePermissions(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source := x86PolynomialFoldSource(arch)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := mustGoPackage(t, "fold", "package fold\n"+x86PolynomialFoldDeclaration)
+		resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := file.Funcs[0]
+		for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+			if err := check(fn, sigs["fold"], arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("linked-data/native-load composition leaked declaration-only authority", arch, err)
+			}
+		}
+	}
+}
+
+func TestX86PolynomialFoldCompositionRejectsOneMissingProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for name, change := range map[string][2]string{
+			"external data":        {"MOVOA foldPoly<>(SB),X3", "MOVOA otherPoly<>(SB),X3"},
+			"short data":           {"DATA foldPoly<>+8(SB)/8,$0xa7c1e305f1b692d3\nGLOBL foldPoly<>(SB),8,$16", "GLOBL foldPoly<>(SB),8,$8"},
+			"relocated data":       {"$0xa7c1e305f1b692d3", "$·external(SB)"},
+			"missing pointer":      {"MOVOU (SI),X0", "MOVOU (DI),X0"},
+			"missing joined value": {"even:\n\tMOVOU X1,X4", "even:\n\tMOVOU X5,X4"},
+			"unknown data input":   {"PCLMULQDQ $0,X3,X1", "PCLMULQDQ $0,X5,X1"},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				source := strings.Replace(x86PolynomialFoldSource(arch), change[0], change[1], 1)
+				if arch == "386" && name == "relocated data" {
+					source = strings.Replace(source, "+8(SB)/8,$·external(SB)", "+8(SB)/4,$·external(SB)", 1)
+				}
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					triple := testTargetTriple("linux", arch)
+					ir, err := x86ScalarFPBitViewAPI(t, source, x86PolynomialFoldDeclaration, arch, triple, api)
+					if arch == "amd64" && (name == "missing joined value" || name == "unknown data input") {
+						x86VectorScratchCodegenControl(t, source, x86PolynomialFoldDeclaration, arch, triple, ir, err)
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal(api, "incomplete composition acquired a result", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_polynomial_fold_runtime_unix_test.go b/amd64_polynomial_fold_runtime_unix_test.go
new file mode 100644
index 000000000..403324540
--- /dev/null
+++ b/amd64_polynomial_fold_runtime_unix_test.go
@@ -0,0 +1,148 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const x86PolynomialFoldOriginalGo = `package main
+import ("encoding/binary"; "fmt")
+
+func multiply(a,b uint64) (lo,hi uint64) {
+    for bit:=uint(0);bit<64;bit++ {
+        if b>>bit&1==0 { continue }
+        lo^=a<<bit
+        if bit!=0 { hi^=a>>(64-bit) }
+    }
+    return
+}
+func reference(p *[128]byte,n,seed uint32) uint32 {
+    low,high:=uint64(seed),uint64(0)
+    for block:=uint32(0);block<n;block++ {
+        a:=low^binary.LittleEndian.Uint64(p[block*16:])
+        b:=high^binary.LittleEndian.Uint64(p[block*16+8:])
+        lo,hi:=multiply(a,0x1f123bb5a7c9d001)
+        _,fold:=multiply(b,0xa7c1e305f1b692d3)
+        low,high=lo^fold,hi
+        if (n-block)&1!=0 {
+            low^=low>>7
+            high^=high>>7
+        } else {
+            low^=low<<3
+            high^=high<<3
+        }
+    }
+    return uint32((low^high)>>11)
+}
+func main() {
+    seeds:=[]uint32{0,1,0xffffffff,0x89abcdef}
+    for sample:=0;sample<8;sample++ {
+        var storage [144]byte
+        for i:=range storage { storage[i]=byte(i*71+sample*97+(i*sample)%251) }
+        before:=storage
+        for offset:=0;offset<4;offset++ {
+            p:=(*[128]byte)(storage[offset:offset+128])
+            for n:=uint32(0);n<=8;n++ {
+                for _,seed:=range seeds {
+                    got,want:=fold(p,n,seed),reference(p,n,seed)
+                    if got!=want || storage!=before {
+                        panic(fmt.Sprintf("original Go sample=%d offset=%d n=%d seed=%x got=%x want=%x",sample,offset,n,seed,got,want))
+                    }
+                    fmt.Println(got)
+                }
+            }
+        }
+    }
+    for _,seed:=range seeds {
+        got,want:=fold(nil,0,seed),reference(nil,0,seed)
+        if got!=want { panic("nil/zero-length control") }
+        fmt.Println(got)
+    }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86PolynomialFoldOriginalGoThreeAPIs(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	goos := "linux"
+	if strings.Contains(execution.triple, "apple") {
+		goos = "darwin"
+	}
+	source := x86PolynomialFoldSource("amd64")
+	directory := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":  "module polynomial_fold_oracle\n\ngo 1.20\n",
+		"main.go": x86PolynomialFoldOriginalGo + x86PolynomialFoldDeclaration,
+		"fold.s":  source,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(directory, "original")
+	environment := []string{"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=amd64", "GOOS=" + goos}
+	dataGlobalAlignmentCommand(t, directory, environment, "go", "build", "-p=2", "-o", original, ".")
+	results := strings.Fields(string(execution.run(t, original)))
+	const samples = 8*4*9*4 + 4
+	if len(results) != samples {
+		t.Fatalf("actual linked Go executed %d results, want %d", len(results), samples)
+	}
+	var values strings.Builder
+	for _, result := range results {
+		value, err := strconv.ParseUint(result, 10, 32)
+		if err != nil {
+			t.Fatal("original Go result is not uint32", err)
+		}
+		fmt.Fprintf(&values, "UINT32_C(%d),\n", value)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint32_t fold(const uint8_t*,uint32_t,uint32_t);
+static const uint32_t original[]={
+` + values.String() + `};
+int main(void) {
+    const uint32_t seeds[]={0,1,0xffffffff,0x89abcdef};
+    unsigned index=0;
+    for(unsigned sample=0;sample<8;sample++) {
+        uint8_t storage[144],before[144];
+        for(unsigned i=0;i<144;i++) storage[i]=(uint8_t)(i*71+sample*97+(i*sample)%251);
+        memcpy(before,storage,sizeof(storage));
+        for(unsigned offset=0;offset<4;offset++)
+        for(unsigned n=0;n<=8;n++)
+        for(unsigned seed=0;seed<4;seed++) {
+            uint32_t got=fold(storage+offset,n,seeds[seed]);
+            if(got!=original[index] || memcmp(storage,before,sizeof(storage))) {
+                fprintf(stderr,"LLVM sample=%u offset=%u n=%u seed=%x got=%x original=%x\n",
+                    sample,offset,n,seeds[seed],got,original[index]);
+                return 1;
+            }
+            index++;
+        }
+    }
+    for(unsigned seed=0;seed<4;seed++) if(fold(0,0,seeds[seed])!=original[index++]) return 2;
+    return index!=sizeof(original)/sizeof(original[0]);
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, x86PolynomialFoldDeclaration, "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(api+"/"+level, func(t *testing.T) {
+				text := ir
+				if level == "-O2" {
+					text = x86MulDivRoundOptimize(t, text)
+				}
+				execution.compileAndRunLLVM(t, "polynomial-fold", text, main, level)
+			})
+		}
+	}
+	t.Logf("%d actual Go linked loop/join results, independently checked polynomial reference, three LLVM APIs O0/O2; source identical, inputs unchanged", samples)
+}
diff --git a/amd64_prelude_demand.go b/amd64_prelude_demand.go
new file mode 100644
index 000000000..585187ae8
--- /dev/null
+++ b/amd64_prelude_demand.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"strings"
+	"sync"
+)
+
+// Only immutable compiler declarations are shared. Source-dependent helpers
+// and all source/caller permissions remain local to the current translation.
+var amd64DemandPreludeCatalog [2]struct {
+	once         sync.Once
+	declarations map[string]string
+	ordinary     string
+}
+
+func amd64PreludeForGOARCH(goarch string) (map[string]string, string) {
+	index := 0
+	if goarch == "386" {
+		index = 1
+	}
+	catalog := &amd64DemandPreludeCatalog[index]
+	catalog.once.Do(func() {
+		var full strings.Builder
+		// The original emitter inspects file.Funcs for SHA/string/rounding
+		// helpers. An empty file selects only its fixed declarations.
+		emitAMD64Prelude(&full, goarch, &File{Arch: ArchAMD64})
+		text := full.String()
+		catalog.declarations = llvmPreludeDeclarations(text)
+		var ordinary strings.Builder
+		for _, line := range strings.Split(text, "\n") {
+			if strings.HasPrefix(line, "declare ") && !strings.Contains(line, "@llvm.") {
+				ordinary.WriteString(line)
+				ordinary.WriteByte('\n')
+			}
+		}
+		for name := range catalog.declarations {
+			if !strings.HasPrefix(name, "llvm.") {
+				delete(catalog.declarations, name)
+			}
+		}
+		catalog.ordinary = ordinary.String()
+	})
+	return catalog.declarations, catalog.ordinary
+}
+
+func emitAMD64SourcePrelude(b *strings.Builder, file *File, goarch string) {
+	_, ordinary := amd64PreludeForGOARCH(goarch)
+	emitX86SHADeclarations(b, file)
+	b.WriteString(ordinary)
+	emitX86StringHelpers(b, file)
+	emitAMD64FMA3RoundingHelpers(b, file, goarch)
+}
+
+func emitUsedAMD64Prelude(b *strings.Builder, goarch string) {
+	declarations, _ := amd64PreludeForGOARCH(goarch)
+	emitUsedLLVMPrelude(b, declarations)
+}
diff --git a/amd64_prelude_demand_bench_test.go b/amd64_prelude_demand_bench_test.go
new file mode 100644
index 000000000..7f97edc75
--- /dev/null
+++ b/amd64_prelude_demand_bench_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Use identical initialized scalar input to isolate the text-fallback cost.
+// The direct case must gain no demand scan or catalog lookup. Existing packed
+// binary/physical and baseline-GP benchmarks retain their original case IDs.
+func BenchmarkX86PreludeTranslation(b *testing.B) {
+	for _, annotate := range []bool{false, true} {
+		name := "direct"
+		if annotate {
+			name = "annotated-fallback"
+		}
+		b.Run(name, func(b *testing.B) {
+			source := "TEXT scalar(SB),4,$0-0\n" + strings.Repeat("MOVL $7,AX\n", 64) + "RET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				b.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", AnnotateSource: annotate,
+				Sigs: map[string]FuncSig{"scalar": {Name: "scalar", Ret: Void}}}
+			if _, err := Translate(file, options); err != nil {
+				b.Fatal("benchmark must complete before timing", err)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if _, err := Translate(file, options); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_prelude_demand_test.go b/amd64_prelude_demand_test.go
new file mode 100644
index 000000000..fb9514cb7
--- /dev/null
+++ b/amd64_prelude_demand_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func requireX86DemandDeclarations(t *testing.T, ir string, want ...string) {
+	t.Helper()
+	var got []string
+	ordinary := make(map[string]bool)
+	for _, line := range strings.Split(ir, "\n") {
+		if !strings.HasPrefix(line, "declare ") {
+			continue
+		}
+		for name := range llvmTextGlobalNames(line) {
+			if strings.HasPrefix(name, "llvm.") {
+				got = append(got, name)
+			} else {
+				ordinary[name] = true
+			}
+		}
+	}
+	sort.Strings(got)
+	want = append([]string(nil), want...)
+	sort.Strings(want)
+	if strings.Join(got, "\n") != strings.Join(want, "\n") {
+		t.Errorf("LLVM declarations = %v, want only actual uses %v (IR: %d bytes)", got, want, len(ir))
+	}
+	if len(ordinary) != 6 {
+		t.Errorf("ordinary declarations = %v, want the six original external declarations", ordinary)
+	}
+	for _, name := range []string{"syscall", "cliteErrno", "atan2", "fmod", "remainder", "tan"} {
+		if !ordinary[name] {
+			t.Errorf("lost original ordinary declaration %s", name)
+		}
+	}
+}
+
+func TestX86DemandPreludeContainsOnlyUsedDeclarations(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name, body string
+			want       []string
+		}{
+			{name: "scalar", body: "MOVL $7,AX\nRET"},
+			{name: "annotated-comment", body: "MOVL $7,AX // @llvm.bswap.i64( is only a comment\nRET"},
+			{name: "scalar-intrinsic", body: "MOVL $7,AX\nPOPCNTL AX,BX\nRET", want: []string{"llvm.ctpop.i32"}},
+			{name: "vector-intrinsic", body: "PXOR X0,X0\nPXOR X1,X1\nPSHUFB X0,X1\nRET", want: []string{"llvm.x86.ssse3.pshuf.b.128"}},
+			{name: "source-sha", body: "PXOR X1,X1\nSHA1MSG1 X1,X1\nRET", want: []string{"llvm.x86.sha1msg1"}},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, testTargetTriple("linux", arch), targetBackendCase{
+						arch: ArchAMD64, goarch: arch, body: row.body,
+					})
+					if err != nil {
+						t.Fatal("initialized source must translate before checking declaration demand", err)
+					}
+					requireX86DemandDeclarations(t, ir, row.want...)
+				})
+			}
+		}
+	}
+}
+
+func TestX86DemandPreludeRetainsSourceHelperClosure(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, row := range []struct {
+				kind, bits string
+			}{{"SS", "32"}, {"SD", "64"}} {
+				t.Run(arch+"/rounded-fma"+row.bits+"/"+api, func(t *testing.T) {
+					// The emitted software helper itself references both intrinsics,
+					// even when a matching native entry uses exact inline assembly.
+					ir, err := targetBackendRequest(t, api, testTargetTriple("linux", arch), targetBackendCase{
+						arch: ArchAMD64, goarch: arch,
+						body: "PXOR X0,X0\nPXOR X1,X1\nPXOR X2,X2\nVFMADD132" + row.kind + ".RD_SAE X0,X1,X2\nRET",
+					})
+					if err != nil {
+						t.Fatal("initialized FMA source must translate before checking helper closure", err)
+					}
+					helper := x86StringMemoryFunction(t, ir, "__plan9asm_fma3_round_f"+row.bits)
+					for _, call := range []string{"@llvm.fma.f" + row.bits + "(", "@llvm.ctlz.i128("} {
+						if !strings.Contains(helper, call) {
+							t.Fatal("source-dependent FMA helper lost its intrinsic reference", call)
+						}
+					}
+					requireX86DemandDeclarations(t, ir, "llvm.fma.f"+row.bits, "llvm.ctlz.i128")
+					compileLLVMToObject(t, llc, testTargetTriple("linux", arch), "demand-fma.ll", "demand-fma.o", ir)
+				})
+			}
+			t.Run(arch+"/string-helper/"+api, func(t *testing.T) {
+				// Reuse the initialized native-pointer source owner; selecting
+				// declarations must not rebuild its memory or runtime matrix.
+				source, declarations := x86StringRepeatCFGFixture(
+					x86StringMemoryRow{op: "MOVSB", kind: "movs", width: 1, reads: 1, writes: 1},
+					arch, "REP", "adjacent")
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, testTargetTriple("linux", arch), api)
+				if err != nil {
+					t.Fatal("original string source must translate before checking helper preservation", err)
+				}
+				helper := x86StringMemoryFunction(t, ir, "__plan9asm_movsb")
+				if err := x86StringMemoryIRAccessError(helper, 1, 1, 1); err != nil {
+					t.Fatal(err)
+				}
+				requireX86DemandDeclarations(t, ir)
+				compileLLVMToObject(t, llc, testTargetTriple("linux", arch), "demand-string.ll", "demand-string.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86DemandPreludeLeavesDirectModuleIndependent(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT scalar(SB),4,$0-0\nMOVL $7,AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"scalar": {Name: "scalar", Ret: Void}}}
+	for _, translate := range []func(llvm.Context, *File, Options) (llvm.Module, error){
+		translateModuleDirectInContext, TranslateModuleInContext,
+	} {
+		module, err := translate(ctx, file, options)
+		if err != nil || module.IsNil() {
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			t.Fatal("ordinary direct-module source must remain independent of textual prelude", err)
+		}
+		ir := module.String()
+		module.Dispose()
+		if strings.Contains(ir, "declare ") {
+			t.Fatal("ordinary direct-module source acquired textual prelude declarations")
+		}
+	}
+}
diff --git a/amd64_private_aligned_frame_audit_test.go b/amd64_private_aligned_frame_audit_test.go
new file mode 100644
index 000000000..8c1fe0527
--- /dev/null
+++ b/amd64_private_aligned_frame_audit_test.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are source/translation observations, not execution tests. In
+// particular, neither missing initialization nor a missing SP restoration
+// fixture is executed. A typed ABI0 declaration is not a private-frame proof.
+func x86PrivateAlignedFrameAuditFixture(t *testing.T, operation string) (string, FuncSig, GoPackage) {
+	t.Helper()
+	const goSource = `package frameaudit
+func Value(a, b, c, d uint64) uint64
+`
+	return x86PrivateAlignedFrameAuditTypedFixture(t, operation, goSource)
+}
+
+func x86PrivateAlignedFrameAuditTypedFixture(t *testing.T, operation, goSource string) (string, FuncSig, GoPackage) {
+	t.Helper()
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "frameaudit.go", goSource, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("frameaudit", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration, ok := typed.Scope().Lookup("Value").(*types.Func)
+	if !ok {
+		t.Fatal("missing actual type-checked first-party declaration")
+	}
+	sig, err := DeriveGoFuncABI0Signature("frameaudit.Value", declaration, "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := fmt.Sprintf(`TEXT ·Value(SB),4,$160-40
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),CX
+MOVQ c+16(FP),DX
+MOVQ d+24(FP),BX
+MOVQ SP,R11
+MOVQ $31,R9
+NOTQ R9
+ANDQ R9,SP
+ADDQ $32,SP
+MOVQ R11,96(SP)
+MOVQ AX,16(SP)
+MOVQ CX,24(SP)
+MOVQ DX,48(SP)
+MOVQ BX,56(SP)
+MOVOU 48(SP),X0
+%s
+MOVQ X0,AX
+MOVQ 96(SP),R11
+MOVQ R11,SP
+MOVQ AX,ret+32(FP)
+RET
+`, operation)
+	return source, sig, GoPackage{Path: "frameaudit", Types: typed, Syntax: []*ast.File{syntax}}
+}
+
+func x86PrivateAlignedFrameAuditAPIs(t *testing.T, source string, sig FuncSig, pkg GoPackage, check func(*testing.T, error)) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string {
+		return strings.Replace(symbol, "·", "frameaudit.", 1)
+	}
+	sigs := map[string]FuncSig{sig.Name: sig}
+	if declaration, ok := pkg.Types.Scope().Lookup("callee").(*types.Func); ok {
+		callee, err := DeriveGoFuncABI0Signature("frameaudit.callee", declaration, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs[callee.Name] = callee
+	}
+	opt := Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: resolve, Sigs: sigs,
+	}
+	t.Run("Translate", func(t *testing.T) {
+		_, err := Translate(file, opt)
+		check(t, err)
+	})
+	t.Run("TranslateModuleInContext", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := TranslateModuleInContext(ctx, file, opt)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		check(t, err)
+	})
+	t.Run("TranslateGoModule", func(t *testing.T) {
+		translation, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			ResolveSym: resolve,
+		})
+		if translation != nil && !translation.Module.IsNil() {
+			defer translation.Module.Dispose()
+		}
+		check(t, err)
+	})
+}
+
+func TestX86PrivateAlignedFrameAuditOriginalGoM128Source(t *testing.T) {
+	// Full legacy opcode membership of the bridges inspected in this audit.
+	// The count instructions have their own exact-opcode fault contract; this
+	// list does not impose an alignment requirement on them.
+	operations := []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0",
+		"ADDPS 16(SP),X0", "ADDPD 16(SP),X0", "SUBPS 16(SP),X0", "SUBPD 16(SP),X0",
+		"MULPS 16(SP),X0", "MULPD 16(SP),X0", "DIVPS 16(SP),X0", "DIVPD 16(SP),X0",
+		"CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+		"PSLLW 16(SP),X0", "PSLLL 16(SP),X0", "PSLLQ 16(SP),X0",
+		"PSRLW 16(SP),X0", "PSRLL 16(SP),X0", "PSRLQ 16(SP),X0",
+	}
+	if len(operations) != 21 {
+		t.Fatal("incomplete audited legacy bridge membership")
+	}
+	for _, operation := range operations {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			source, _, _ := x86PrivateAlignedFrameAuditFixture(t, operation)
+			listing := string(x86InsertExtractGoListing(t, "amd64", source))
+			for _, required := range []string{
+				"locals=0xa8",
+				"MOVQ\ta+176(FP), AX", "MOVQ\tb+184(FP), CX",
+				"MOVQ\tc+192(FP), DX", "MOVQ\td+200(FP), BX", "MOVQ\tAX, ret+208(FP)",
+				"ANDQ\tR9, SP", "ADDQ\t$32, SP", "MOVQ\tR11, SP",
+				"RET",
+			} {
+				if !strings.Contains(listing, required) {
+					t.Fatalf("actual Go source frame/prologue/restoration missing %q:\n%s", required, listing)
+				}
+			}
+			var code []byte
+			for _, line := range strings.Split(listing, "\n") {
+				code = append(code, x86InsertExtractListedBytes(line)...)
+			}
+			if len(code) == 0 {
+				t.Fatal("original Go listing lacks physical instruction bytes")
+			}
+			// Identify complete observed machine sequences, never a version
+			// string or autosize alone. Older Go saves BP in the 160(SP)
+			// slot; current Go pushes BP. Both reserve 168 bytes, but their
+			// producer and restoration instructions are not interchangeable.
+			physicalForm := ""
+			for _, form := range []struct {
+				name           string
+				prefix, suffix []byte
+				instructions   []string
+			}{
+				{
+					name:   "pushed_BP",
+					prefix: []byte{0x55, 0x48, 0x89, 0xe5, 0x48, 0x81, 0xec, 0xa0, 0, 0, 0},
+					suffix: []byte{0x48, 0x81, 0xc4, 0xa0, 0, 0, 0, 0x5d, 0xc3},
+					instructions: []string{
+						"PUSHQ\tBP", "MOVQ\tSP, BP", "SUBQ\t$160, SP", "ADDQ\t$160, SP", "POPQ\tBP",
+					},
+				},
+				{
+					name:   "slot_saved_BP",
+					prefix: []byte{0x48, 0x81, 0xec, 0xa8, 0, 0, 0, 0x48, 0x89, 0xac, 0x24, 0xa0, 0, 0, 0, 0x48, 0x8d, 0xac, 0x24, 0xa0, 0, 0, 0},
+					suffix: []byte{0x48, 0x8b, 0xac, 0x24, 0xa0, 0, 0, 0, 0x48, 0x81, 0xc4, 0xa8, 0, 0, 0, 0xc3},
+					instructions: []string{
+						"SUBQ\t$168, SP", "MOVQ\tBP, 160(SP)", "LEAQ\t160(SP), BP", "MOVQ\t160(SP), BP", "ADDQ\t$168, SP",
+					},
+				},
+			} {
+				if !bytes.HasPrefix(code, form.prefix) || !bytes.HasSuffix(code, form.suffix) {
+					continue
+				}
+				for _, instruction := range form.instructions {
+					if !strings.Contains(listing, instruction) {
+						t.Fatalf("actual %s object lacks its paired listing instruction %q", form.name, instruction)
+					}
+				}
+				physicalForm = form.name
+			}
+			if physicalForm == "" {
+				t.Fatalf("actual Go physical prologue/epilogue lacks an observed complete pairing: %x", code)
+			}
+			t.Logf("actual Go original accepted; TEXT160 + savedBP8; physicalForm=%s operation=%s sourceSHA=%x codeSHA=%x code=%x", physicalForm, operation, sha256.Sum256([]byte(source)), sha256.Sum256(code), code)
+			if strings.HasPrefix(operation, "PADDB ") {
+				t.Logf("independent original Go frame/slot listing:\n%s", listing)
+			}
+		})
+	}
+}
+
+func TestX86PrivateAlignedFrameAuditBoundedSourceStillNeedsContract(t *testing.T) {
+	for _, operation := range []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+	} {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			source, sig, pkg := x86PrivateAlignedFrameAuditFixture(t, operation)
+			x86PrivateAlignedFrameAuditAPIs(t, source, sig, pkg, func(t *testing.T, err error) {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("typed scalar declaration alone granted native private-frame memory: %v", err)
+				}
+				t.Logf("bounded initialized source remains Context pending its private-frame producer: %v", err)
+			})
+		})
+	}
+}
+
+// RED checkpoint: the legacy arithmetic bridge currently admits these
+// unproved virtual-SP inputs. This is a missing source contract observation,
+// not a claim that any third-party function has been executed incorrectly.
+func TestX86PrivateAlignedFrameAuditUnprovedNativeFloatingMemory(t *testing.T) {
+	mutations := []struct {
+		name     string
+		edit     func(string) string
+		goSource string
+	}{
+		{"unaligned source residue", func(source string) string {
+			return strings.Replace(source, "ADDQ $32,SP", "ADDQ $33,SP", 1)
+		}, ""},
+		{"uninitialized source bytes", func(source string) string {
+			return strings.Replace(source, "MOVQ CX,24(SP)\n", "", 1)
+		}, ""},
+		{"source TEXT extent", func(source string) string {
+			return strings.Replace(source, "16(SP),X0", "152(SP),X0", 1)
+		}, ""},
+		{"missing source SP restoration", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,SP\n", "", 1)
+		}, ""},
+		{"unknown alignment mask", func(source string) string {
+			return strings.Replace(source, "MOVQ $31,R9\nNOTQ R9", "MOVQ AX,R9", 1)
+		}, ""},
+		{"private pointer result escape", func(source string) string {
+			return strings.Replace(source, "MOVQ AX,ret+32(FP)", "MOVQ R11,ret+32(FP)", 1)
+		}, ""},
+		{"overwritten saved SP", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,96(SP)", "MOVQ $0,96(SP)", 1)
+		}, ""},
+		{"inconsistent restore join", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,SP", "CMPQ AX,$0\nJE afterRestore\nMOVQ R11,SP\nafterRestore:", 1)
+		}, ""},
+		{"private pointer global escape", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,96(SP)", "MOVQ R11,96(SP)\nMOVQ SP,framePointer(SB)", 1) + "GLOBL framePointer(SB),8,$8\n"
+		}, ""},
+		{"unknown incoming pointer alias", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,96(SP)", "MOVQ R11,96(SP)\nMOVQ SP,(BX)", 1)
+		}, "package frameaudit\nfunc Value(a, b, c uint64, d *uint64) uint64\n"},
+		{"unproved call", func(source string) string {
+			return strings.Replace(source, "MOVQ R11,96(SP)", "MOVQ R11,96(SP)\nCALL ·callee(SB)", 1)
+		}, "package frameaudit\nfunc Value(a, b, c, d uint64) uint64\nfunc callee()\n"},
+		{"raw SP overwrite", func(source string) string {
+			// MOVQ AX,SP is encoded explicitly, not described by a forged
+			// decoder marker or an assumed neutral raw effect.
+			return strings.Replace(source, "MOVQ R11,96(SP)", "MOVQ R11,96(SP)\nBYTE $0x48\nBYTE $0x89\nBYTE $0xc4", 1)
+		}, ""},
+	}
+	for _, op := range []string{"ADDPS", "ADDPD", "SUBPS", "SUBPD", "MULPS", "MULPD", "DIVPS", "DIVPD"} {
+		for _, mutation := range mutations {
+			t.Run(op+"/"+mutation.name, func(t *testing.T) {
+				source, sig, pkg := x86PrivateAlignedFrameAuditFixture(t, op+" 16(SP),X0")
+				if mutation.goSource != "" {
+					source, sig, pkg = x86PrivateAlignedFrameAuditTypedFixture(t, op+" 16(SP),X0", mutation.goSource)
+				}
+				source = mutation.edit(source)
+				// Object acceptance cannot authorize execution of these negative
+				// fixtures or stand in for source-SP/result/no-escape semantics.
+				x86InsertExtractGoListing(t, "amd64", source)
+				x86PrivateAlignedFrameAuditAPIs(t, source, sig, pkg, func(t *testing.T, err error) {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unproved source private-frame backing admitted by native bridge: %v", err)
+					}
+				})
+			})
+		}
+	}
+}
diff --git a/amd64_private_legacy_read_family_test.go b/amd64_private_legacy_read_family_test.go
new file mode 100644
index 000000000..5f8a92a8b
--- /dev/null
+++ b/amd64_private_legacy_read_family_test.go
@@ -0,0 +1,327 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent yxmov whole128 directory; MOVOA is cmd/asm's MOVO alias.
+// The complete original opcode/prefix/zcase oracle is separately retained by
+// TestX86GoCallerLegacyMoveCompleteGoRows, not derived from production's map.
+var x86PrivateLegacyReadNames = []string{
+	"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD",
+}
+
+func x86PrivateLegacyReadOriginal(t *testing.T, body string) (*File, FuncSig, Options) {
+	t.Helper()
+	assembly := "TEXT ·kernel(SB),4,$0-32\nMOVQ a+0(FP),DI\n" + body + "\nBYTE $0xc3\n"
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := sigs["caller.kernel"]
+	if sig.Ret != Void || len(sig.Frame.Results) != 0 || len(sig.Args) != 4 ||
+		sig.x86CallerRegions == nil || !x86CallerRegionSourceMatches(sig, file.Funcs[0], "amd64") {
+		t.Fatal("actual source and same pointer-only Void signature prerequisite is missing")
+	}
+	for _, argument := range sig.Args {
+		if argument != Ptr {
+			t.Fatal("fixture changed the existing four-pointer caller domain")
+		}
+	}
+	return file, sig, Options{Goarch: "amd64", ResolveSym: resolve, Sigs: sigs}
+}
+
+func x86PrivateLegacyReadProved(t *testing.T, body string, width int64) (Func, FuncSig) {
+	t.Helper()
+	file, sig, options := x86PrivateLegacyReadOriginal(t, body)
+	normalized, err := normalizeX86RawFile(file, "amd64", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Funcs) != 1 || !x86CallerNormalizedSourceMatches(normalized.Funcs[0], sig) {
+		t.Fatal("whole normalized source does not match its exact caller signature")
+	}
+	fn := normalized.Funcs[0]
+	found := 0
+	for ordinal, ins := range fn.Instrs {
+		// Native pointer imports have their own exact FP/physical-stack
+		// certificate. Select the actual DI-to-X numerical source role first.
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != DI ||
+			ins.Args[1].Kind != OpReg || !isAMD64XReg(ins.Args[1].Reg) {
+			continue
+		}
+		access, present := ins.x86CallerMemory[0]
+		if !present || access.write || access.width != width || !x86CallerMemoryCertified(ins, 0) {
+			t.Fatalf("instruction %d lacks its exact numerical-source read%d certificate", ordinal, width)
+		}
+		found++
+	}
+	if found != 1 {
+		t.Fatalf("source has %d certified reads, want exactly one", found)
+	}
+	return fn, sig
+}
+
+func TestX86PrivateLegacyReadObserverCompleteSourceForms(t *testing.T) {
+	// Input is the existing numerical slice-origin/nonalias contract, not an
+	// allocation or native-pointer extent. The independent producer must pass
+	// before these leaves can diagnose the private observer.
+	for _, op := range x86PrivateLegacyReadNames {
+		for _, destination := range []string{"X1", "X0"} {
+			t.Run(op+"/register_"+destination, func(t *testing.T) {
+				body := "MOVOU (DI),X0\n" + op + " X0," + destination + "\nPEXTRD $3," + destination + ",AX"
+				fn, sig := x86PrivateLegacyReadProved(t, body, 16)
+				if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("public declaration-only Void query acquired caller memory: %v", err)
+				}
+				if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+					t.Errorf("private observer lost a same-source exact read16 before %s register transfer: %v", op, err)
+				}
+			})
+		}
+	}
+	for _, op := range []string{"MOVOU", "MOVUPS", "MOVUPD"} {
+		for _, address := range []string{"(DI)", "4(DI)", "4(DI)(BX*2)"} {
+			t.Run(op+"/read_"+address, func(t *testing.T) {
+				body := "MOVQ $1,BX\n" + op + " " + address + ",X0\nPEXTRD $3,X0,AX"
+				fn, sig := x86PrivateLegacyReadProved(t, body, 16)
+				if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+					t.Errorf("private observer discarded a proved full-width source read: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivateLegacyReadObserverExistingByteCounterparts(t *testing.T) {
+	// These are ordinary logical byte-effect models, never caller producers.
+	// In particular, logical FP/AUTO bytes do not prove native alignment/backing.
+	forms := []string{
+		"X0,X1", "X0,X0", "a+0(FP),X1", "X0,ret0+16(FP)",
+		"value-32(SP),X1", "X0,value-16(SP)",
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86PrivateLegacyReadNames {
+			for _, operands := range forms {
+				t.Run(arch+"/"+op+"/"+operands, func(t *testing.T) {
+					ins := x86CallerLegacyMoveInstruction(t, op+" "+operands)
+					effect, known, err := x86TypedLegacyPackedMoveByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || len(effect.operands) != 2 || effect.flagsRead != 0 ||
+						effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.dynamicMemory {
+						t.Fatalf("whole128 descriptor differs from the independent move rows: %+v/%v", effect, err)
+					}
+					for index, operand := range effect.operands {
+						if operand.index != index || operand.width != 16 || operand.read != (index == 0) ||
+							operand.write != (index == 1) || !reflect.DeepEqual(operand.operand, ins.Args[index]) {
+							t.Fatal("typed effect changed source/destination, direction or exact width")
+						}
+					}
+					owned := make([]bool, 32)
+					state := x86ResultState{fp: make([]bool, 32), auto: make([]bool, 32), flags: x86ByteFlagCF | x86ByteFlagOF}
+					for offset := range owned {
+						owned[offset] = true
+						state.fp[offset], state.auto[offset] = offset < 16, offset < 16
+					}
+					state.xmm[0] = 0xffff
+					for _, transfer := range []func(Instr, *x86ResultState, []bool, int64, string) bool{x86ResultTransfer, x86ScalarFPResultTransfer} {
+						copy := state.clone()
+						if !transfer(ins, &copy, owned, 16, arch) || copy.flags != state.flags {
+							t.Fatal("existing full-byte transition failed or changed numerical flags")
+						}
+						if !x86ResultRead(ins.Args[1], 16, &copy, owned, arch) {
+							t.Fatal("complete move failed to define exactly its observed destination")
+						}
+					}
+				})
+			}
+			for missing := 0; missing < 16; missing++ {
+				t.Run(fmt.Sprintf("%s/%s/missing-byte%d", arch, op, missing), func(t *testing.T) {
+					ins := x86CallerLegacyMoveInstruction(t, op+" X0,X1")
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagOF}
+					state.xmm[0], state.xmm[1] = 0xffff&^(uint16(1)<<uint(missing)), 0xffff
+					before := state.clone()
+					want := before.clone()
+					want.writeVector(1, 16, uint64(state.xmm[0]), true)
+					if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(want, state) {
+						t.Fatal("private register copy fabricated an unknown byte or changed independent state")
+					}
+					if x86ResultTransfer(ins, &before, nil, 0, arch) {
+						t.Fatal("private partial-byte copy expanded the strict result observer")
+					}
+				})
+			}
+		}
+	}
+	// Wider aliases belong to the caller's existing bank, not to an expanded
+	// private observer state. A low128 copy must preserve both upper canaries.
+	for _, op := range x86PrivateLegacyReadNames {
+		ins := x86CallerLegacyMoveInstruction(t, op+" X0,X1")
+		state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": 0xffff, "Z1": 1<<20 | 1<<48}}
+		if !x86CallerVectorMoveStep(&ins, &state, nil) || state.vectors["Z1"] != 1<<20|1<<48|0xffff {
+			t.Fatal("legacy register transition changed upper Y/Z aliases", op)
+		}
+	}
+}
+
+func x86PrivateLegacyReadClone(fn Func) Func {
+	fn.Instrs = append([]Instr(nil), fn.Instrs...)
+	for index := range fn.Instrs {
+		ins := &fn.Instrs[index]
+		ins.Args = append([]Operand(nil), ins.Args...)
+		copy := make(map[int]x86CallerMemoryAccess)
+		for operand, access := range ins.x86CallerMemory {
+			access.args = append([]Operand(nil), access.args...)
+			copy[operand] = access
+		}
+		ins.x86CallerMemory = copy
+	}
+	return fn
+}
+
+func TestX86PrivateLegacyReadObserverExactAuthorityRequired(t *testing.T) {
+	for _, op := range []string{"MOVOU", "MOVUPS", "MOVUPD"} {
+		fn, signature := x86PrivateLegacyReadProved(t, op+" (DI),X0\nPEXTRD $3,X0,AX", 16)
+		_, other := x86PrivateLegacyReadProved(t, op+" (DI),X0\nPEXTRD $3,X0,AX", 16)
+		t.Run(op+"/instruction-only", func(t *testing.T) {
+			for _, ins := range fn.Instrs {
+				if ins.Op != Op(op) {
+					continue
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.pointerGP[7], state.gp[7] = true, 0xff
+				for _, transfer := range []func(Instr, *x86ResultState, []bool, int64, string) bool{x86ResultTransfer, x86ScalarFPResultTransfer} {
+					copy := state.clone()
+					if transfer(ins, &copy, nil, 0, "amd64") {
+						t.Fatal("instruction certificate or opaque pointer bits alone acquired numerical pointee bytes")
+					}
+				}
+			}
+		})
+		for _, change := range []string{
+			"missing-caller", "missing-source", "other-private-owner", "different-signature", "different-function",
+			"different-ordinal", "changed-source-byte", "operand-offset", "move-width", "read-to-store",
+			"missing-access", "access-width", "access-direction", "access-operands", "address-override", "JSON-copy",
+		} {
+			t.Run(op+"/"+change, func(t *testing.T) {
+				changed, sig := x86PrivateLegacyReadClone(fn), signature
+				for index := range changed.Instrs {
+					ins := &changed.Instrs[index]
+					if ins.Op != Op(op) {
+						continue
+					}
+					access := ins.x86CallerMemory[0]
+					switch change {
+					case "operand-offset":
+						ins.Args[0].Mem.Off++
+					case "move-width":
+						ins.Op = "MOVSD"
+					case "read-to-store":
+						ins.Args[0], ins.Args[1] = ins.Args[1], ins.Args[0]
+					case "missing-access":
+						delete(ins.x86CallerMemory, 0)
+					case "access-width":
+						access.width = 8
+					case "access-direction":
+						access.write = true
+					case "access-operands":
+						access.args[0].Mem.Off++
+					case "address-override":
+						ins.x86AddressBits = 32
+					case "changed-source-byte":
+						ins.Raw += " // changed original source"
+					}
+					if strings.HasPrefix(change, "access-") {
+						ins.x86CallerMemory[0] = access
+					}
+				}
+				switch change {
+				case "missing-caller":
+					sig.x86CallerRegions = nil
+				case "missing-source":
+					changed.x86SourceStack = nil
+				case "other-private-owner":
+					sig.x86CallerRegions = other.x86CallerRegions
+				case "different-signature":
+					sig.Name += ".changed"
+				case "different-function":
+					changed.Sym += ".changed"
+				case "different-ordinal":
+					prefix := append([]Instr(nil), changed.Instrs[:2]...)
+					prefix = append(prefix, Instr{Op: "NOP", Raw: "NOP"})
+					changed.Instrs = append(prefix, changed.Instrs[2:]...)
+				case "JSON-copy":
+					data, err := json.Marshal(changed)
+					if err != nil {
+						t.Fatal(err)
+					}
+					changed = Func{}
+					if err := json.Unmarshal(data, &changed); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := checkX86ScalarFPResultInitialization(changed, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("private observer borrowed changed or missing exact source/read authority: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivateLegacyReadObserverKeepsIndependentDomains(t *testing.T) {
+	// Actual Go accepts these forms; failure must remain at the named proof
+	// stage, not be represented as unsupported Go syntax or observer success.
+	for _, op := range []string{"MOVOA", "MOVO", "MOVAPS", "MOVAPD", "MOVHPD", "MOVHPS", "MOVLPD", "MOVLPS"} {
+		t.Run(op+"/producer-denied", func(t *testing.T) {
+			file, _, options := x86PrivateLegacyReadOriginal(t, op+" (DI),X0")
+			if _, err := normalizeX86RawFile(file, "amd64", options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("aligned memory or unregistered half move borrowed a caller proof: %v", err)
+			}
+		})
+	}
+	for _, op := range []string{"MOVOU", "MOVUPS", "MOVUPD"} {
+		t.Run(op+"/fresh-store-denied", func(t *testing.T) {
+			body := "MOVOU (DI),X0\nMOVQ res+16(FP),DX\n" + op + " X0,(DX)"
+			file, _, options := x86PrivateLegacyReadOriginal(t, body)
+			if _, err := normalizeX86RawFile(file, "amd64", options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("whole128 write exceeded the existing fresh scalar envelope: %v", err)
+			}
+		})
+	}
+	for _, scalar := range []struct {
+		op    string
+		width int64
+	}{{"MOVSS", 4}, {"MOVSD", 8}} {
+		t.Run(scalar.op+"/separate-private-domain", func(t *testing.T) {
+			fn, sig := x86PrivateLegacyReadProved(t, scalar.op+" (DI),X0", scalar.width)
+			if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("whole128 seam widened a separate scalar native-read domain: %v", err)
+			}
+		})
+	}
+	t.Run("dead-wider-transport-preserves-unknown-state", func(t *testing.T) {
+		fn, sig := x86PrivateLegacyReadProved(t, "MOVOU (DI),X0\nVMOVUPS Y0,Y1", 16)
+		// The complete vector domain propagates unknown upper bytes; merely
+		// copying them to an unused register does not assert initialization.
+		// The separate live upper-byte consumer regression must still reject
+		// the same low-X source through all three translation APIs.
+		if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+			t.Fatalf("dead register transport lost its exact low128 read proof: %v", err)
+		}
+	})
+	for _, body := range []string{"MOVOU (BX),X0", "MOVOU ·data(SB),X0"} {
+		t.Run(body+"/unknown-native-origin", func(t *testing.T) {
+			file, _, options := x86PrivateLegacyReadOriginal(t, body)
+			if _, err := normalizeX86RawFile(file, "amd64", options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown native origin acquired a numerical read proof: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_private_read_observer_test.go b/amd64_private_read_observer_test.go
new file mode 100644
index 000000000..beb18994c
--- /dev/null
+++ b/amd64_private_read_observer_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The actual declaration stays pointer-only Void. Its existing caller producer
+// must not be rebound to the scalar result declaration of a different entry.
+const x86PrivateReadObserverAssembly = `TEXT ·kernel(SB),4,$0-32
+MOVQ a+0(FP),DI
+MOVOU (DI),X1
+PEXTRD $0,X1,AX
+BYTE $0xc3
+`
+
+func x86PrivateReadObserverFixture(t *testing.T) (GoPackage, *File, Options, Func) {
+	t.Helper()
+	goAssemblerOracleOutput(t, "amd64", x86PrivateReadObserverAssembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, x86PrivateReadObserverAssembly)
+	resolve := func(symbol string) string {
+		return strings.Replace(symbol, "·", "caller.", 1)
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := sigs["caller.kernel"]
+	if sig.Ret != Void || len(sig.Frame.Results) != 0 || len(sig.Args) != 4 ||
+		sig.x86CallerRegions == nil || sig.x86CallerRegions.calls != 1 {
+		t.Fatal("fixture lacks the actual pointer-only Void declaration and closed caller")
+	}
+	for _, argument := range sig.Args {
+		if argument != Ptr {
+			t.Fatal("fixture changed the existing pointer-only caller domain")
+		}
+	}
+	if !x86CallerRegionSourceMatches(sig, file.Funcs[0], "amd64") {
+		t.Fatal("actual caller signature does not match the complete original source")
+	}
+	options := Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: resolve, Sigs: sigs,
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Funcs) != 1 || !x86CallerNormalizedSourceMatches(normalized.Funcs[0], sig) {
+		t.Fatal("normalized function lacks the same whole-source/signature caller proof")
+	}
+	fn := normalized.Funcs[0]
+	found := 0
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op != "MOVOU" {
+			continue
+		}
+		found++
+		access, present := ins.x86CallerMemory[0]
+		if !present || access.write || access.width != 16 || !x86CallerMemoryCertified(ins, 0) ||
+			len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != DI ||
+			ins.Args[0].Mem.Off != 0 || ins.Args[1].Kind != OpReg || ins.Args[1].Reg != "X1" {
+			t.Fatalf("instruction %d lacks its exact operand-0 numerical read16 certificate", ordinal)
+		}
+		t.Logf("same Void declaration and whole normalized source certify instruction %d operand 0 read16", ordinal)
+	}
+	if found != 1 {
+		t.Fatal("fixture did not contain exactly one certified whole128 source read")
+	}
+	return pkg, file, options, fn
+}
+
+func TestX86PrivateReadObserverSameVoidCallerReadCertificate(t *testing.T) {
+	pkg, file, options, fn := x86PrivateReadObserverFixture(t)
+
+	// These are existing successful translations, not the regression's RED.
+	// No scalar result, incoming native backing or new caller permission is
+	// manufactured to make this observational fixture reach the private query.
+	t.Run("existing-text-control", func(t *testing.T) {
+		ir, err := Translate(file, options)
+		if err != nil || ir == "" {
+			t.Fatalf("existing certified Void text translation: %v", err)
+		}
+	})
+	t.Run("existing-module-control", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil || module.IsNil() {
+			t.Fatalf("existing certified Void module translation: %v", err)
+		}
+	})
+	t.Run("existing-Go-control", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(x86PrivateReadObserverAssembly), GoModuleOptions{
+			FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: options.TargetTriple,
+			ResolveSym: options.ResolveSym,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+		}
+		if err != nil || translated == nil || translated.Module.IsNil() {
+			t.Fatalf("existing certified Void Go translation: %v", err)
+		}
+	})
+
+	sig := options.Sigs["caller.kernel"]
+	if !x86CallerNormalizedSourceMatches(fn, sig) {
+		t.Fatal("API controls changed the exact source/signature prerequisite")
+	}
+	if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("public declaration-only query acquired private Void/native admission: %v", err)
+	}
+	if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+		t.Errorf("same-source private observer discarded an existing exact read16 certificate: %v", err)
+	}
+}
+
+func TestX86PrivateReadObserverMissingOrChangedAuthorityRemainsContext(t *testing.T) {
+	_, _, options, fn := x86PrivateReadObserverFixture(t)
+	for _, change := range []string{"missing-caller", "missing-source", "changed-operand", "changed-width", "changed-signature"} {
+		t.Run(change, func(t *testing.T) {
+			changed, sig := fn, options.Sigs["caller.kernel"]
+			changed.Instrs = append([]Instr(nil), fn.Instrs...)
+			for ordinal := range changed.Instrs {
+				changed.Instrs[ordinal].Args = append([]Operand(nil), fn.Instrs[ordinal].Args...)
+			}
+			switch change {
+			case "missing-caller":
+				sig.x86CallerRegions = nil
+			case "missing-source":
+				changed.x86SourceStack = nil
+			case "changed-signature":
+				sig.Args = append([]LLVMType(nil), sig.Args...)
+				sig.Args[0] = I64
+			case "changed-operand", "changed-width":
+				for ordinal := range changed.Instrs {
+					ins := &changed.Instrs[ordinal]
+					if ins.Op != "MOVOU" {
+						continue
+					}
+					if change == "changed-operand" {
+						ins.Args[0].Mem.Off++
+					} else {
+						ins.Op = "MOVSD"
+					}
+				}
+			}
+			if x86CallerNormalizedSourceMatches(changed, sig) {
+				t.Fatal("mutated fixture retained the whole source/signature prerequisite")
+			}
+			if err := checkX86ScalarFPResultInitialization(changed, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("private read observer borrowed absent or stale authority: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86PrivateReadObserverNonVoidDeclarationCannotBorrowCallerCertificate(t *testing.T) {
+	source := strings.Replace(x86CallerFixtureSource,
+		"func kernel(a, b, res, length unsafe.Pointer)",
+		"func kernel(a, b, res, length unsafe.Pointer) uint32", 1)
+	assembly := strings.Replace(x86PrivateReadObserverAssembly, "$0-32", "$0-36", 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, file := x86CallerCoreFixture(t, source, assembly)
+	resolve := func(symbol string) string {
+		return strings.Replace(symbol, "·", "caller.", 1)
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := sigs["caller.kernel"]
+	if sig.Ret != I32 || len(sig.Frame.Results) != 1 || sig.x86CallerRegions != nil ||
+		x86GoCallerRegionCandidate(file.Funcs[0], sig) {
+		t.Fatal("actual scalar-result declaration borrowed the pointer-only Void caller certificate")
+	}
+	if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("non-Void native read acquired unproduced numerical backing: %v", err)
+	}
+}
diff --git a/amd64_qword_lookup_forms.go b/amd64_qword_lookup_forms.go
new file mode 100644
index 000000000..3a16f154f
--- /dev/null
+++ b/amd64_qword_lookup_forms.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86QwordLookupForm struct {
+	x86PackedBinaryForm
+	spec amd64QwordBitLookupSpec
+}
+
+// The byte result uses _yvblendmpd; the K result uses _yvpshufbitqmb.
+// Share those complete existing shapes without rewriting the original inputs.
+func x86QwordLookupProperties(op Op, ins Instr, arch string) (x86QwordLookupForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64QwordBitLookupSpecs[Op(base)]
+	form := x86QwordLookupForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return form, true, fmt.Errorf("qword lookup dispatch/source opcode mismatch")
+	}
+	local := ins
+	local.Op = op
+	var err error
+	if spec.output == amd64QwordBitLookupBytes {
+		form.x86PackedBinaryForm, err = x86PackedBinaryOperandGrammar(local, arch,
+			x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: 8, zeroing: true},
+			ins.x86Encoded || ins.x86SourceRaw != nil)
+	} else {
+		var valid bool
+		form.x86PackedBinaryForm, valid = x86PackedMaskCompareProperties(local, arch, 0, 8, dotted, suffix)
+		if !valid || dotted || arch != "386" && arch != "amd64" {
+			err = fmt.Errorf("%s %s operands/suffix outside Go mask-result lookup grammar", arch, op)
+		}
+	}
+	if err == nil {
+		err = x86Mode32VectorRegisterContext(local, arch)
+	}
+	if err == nil && form.memory >= 0 {
+		source := ins.Args[form.memory]
+		if source.Kind == OpMem {
+			if !x86ConditionalMoveOffsetKnown(source.Mem) || source.Mem.IndexExt != "" ||
+				source.Mem.Segment != "" && source.Mem.Segment != FS && source.Mem.Segment != GS {
+				err = fmt.Errorf("qword lookup source has an unresolved or foreign address")
+			} else {
+				err = x86SymbolIndexedMemoryError(source.Mem, arch)
+			}
+		}
+		if err == nil && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+			err = fmt.Errorf("%w: qword lookup needs its original default address mode", ErrProbeNeedsContext)
+		}
+	}
+	return form, true, err
+}
+
+func x86TypedQwordLookupByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86QwordLookupProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width, firstWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	outputWidth := width
+	if form.spec.output == amd64QwordBitLookupMask {
+		outputWidth = 8
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: form.first, operand: ins.Args[form.first], width: firstWidth, read: true},
+		{index: form.second, operand: ins.Args[form.second], width: width, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: outputWidth,
+			read: form.spec.output == amd64QwordBitLookupBytes && form.mask >= 0 && !form.zeroing, write: true},
+	}}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands,
+			x86TypedByteOperand{index: form.mask, operand: ins.Args[form.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_qword_lookup_forms_test.go b/amd64_qword_lookup_forms_test.go
new file mode 100644
index 000000000..d04f375e7
--- /dev/null
+++ b/amd64_qword_lookup_forms_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86QwordLookupCompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VPMULTISHIFTQB" && rule.Opcode != "VPSHUFBITQMB" {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		classes := []string{"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+			"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex", "Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr"}
+		ytab, opcode, w := "_yvblendmpd", "0x83", 1
+		if rule.Opcode == "VPSHUFBITQMB" {
+			ytab, opcode, w = "_yvpshufbitqmb", "0x8F", 0
+			classes = []string{"YxmEvex,YxrEvex,Yk", "YxmEvex,YxrEvex,Yknot0,Yk",
+				"YymEvex,YyrEvex,Yk", "YymEvex,YyrEvex,Yknot0,Yk", "Yzm,Yzr,Yk", "Yzm,Yzr,Yknot0,Yk"}
+		}
+		var bytes []string
+		for _, width := range []int{128, 256, 512} {
+			attributes := fmt.Sprintf("evexN%d", width/8)
+			if rule.Opcode == "VPMULTISHIFTQB" {
+				attributes += " | evexBcstN8 | evexZeroingEnabled"
+			}
+			bytes = append(bytes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d", width, w), attributes, opcode)
+		}
+		zcase, offset := "Zevex_rm_v_r", 0
+		if index%2 != 0 {
+			zcase, offset = "Zevex_rm_v_k_r", 3
+		}
+		if index >= 6 || rule.RowIndex != index || rule.Ytab != ytab || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != offset || rule.EncodingOffset != index/2*3 ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, bytes) {
+			t.Fatal("independent complete qword lookup encoder row/attributes changed", rule)
+		}
+	}
+	if len(counts) != 2 || counts["VPMULTISHIFTQB"] != 6 || counts["VPSHUFBITQMB"] != 6 {
+		t.Fatal("complete qword lookup row inventory changed", counts)
+	}
+}
+
+func TestX86QwordLookupEveryInputByteAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"VPMULTISHIFTQB", "VPSHUFBITQMB"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				destination := bank + "2"
+				if name == "VPSHUFBITQMB" {
+					destination = "K3"
+				}
+				ins := x86ScalarLaneInstruction(t, name+" "+bank+"0,"+bank+"1,"+destination)
+				width := amd64VectorByteWidth(ins.Args[0].Reg)
+				for input := 0; input < 2; input++ {
+					for missing := -1; missing < width; missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+						for register := 0; register < 3; register++ {
+							state.writeVector(register, 64, ^uint64(0), false)
+						}
+						state.pointerGP[6], state.gp[3], state.masks[1] = true, 0x55, true
+						if missing >= 0 {
+							state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+						}
+						want := state.clone()
+						if missing < 0 {
+							if name == "VPSHUFBITQMB" {
+								want.masks[3] = true
+							} else {
+								want.writeVector(2, width, x86CallerVectorByteMask(int64(width)), false)
+							}
+						}
+						accepted, known := x86ResultQwordLookupStep(ins, &state, nil, arch, false)
+						if !known || accepted != (missing < 0) || !reflect.DeepEqual(state, want) {
+							t.Fatal("qword lookup invented missing input bytes or changed independent state", arch, name, bank, input, missing)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86QwordLookupMaskResultsAreWriteOnlyAndZeroingNeedsNoMerge(t *testing.T) {
+	for _, row := range []string{"VPSHUFBITQMB X0,X1,K3", "VPSHUFBITQMB X0,X1,K1,K3", "VPMULTISHIFTQB.Z X0,X1,K1,X2"} {
+		ins := x86ScalarLaneInstruction(t, row)
+		state := x86ResultState{flags: x86ByteFlagsAll}
+		state.writeVector(0, 64, ^uint64(0), false)
+		state.writeVector(1, 64, ^uint64(0), false)
+		state.masks[1] = true
+		if accepted, known := x86ResultQwordLookupStep(ins, &state, nil, "amd64", false); !known || !accepted {
+			t.Fatal("write-only K destination or zeroing result demanded old bytes", row)
+		}
+	}
+	ins := x86ScalarLaneInstruction(t, "VPMULTISHIFTQB X0,X1,K1,X2")
+	state := x86ResultState{}
+	state.writeVector(0, 64, ^uint64(0), false)
+	state.writeVector(1, 64, ^uint64(0), false)
+	state.masks[1] = true
+	if accepted, known := x86ResultQwordLookupStep(ins, &state, nil, "amd64", false); !known || accepted {
+		t.Fatal("merging byte result invented its old destination")
+	}
+}
diff --git a/amd64_random_forms.go b/amd64_random_forms.go
new file mode 100644
index 000000000..92cd6073b
--- /dev/null
+++ b/amd64_random_forms.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type x86HardwareRandomSpec struct {
+	native string
+	bits   int
+}
+
+// All six Go yrdrand rows: one Yrl write, no input operand or suffix.
+var x86HardwareRandomSpecs = map[Op]x86HardwareRandomSpec{
+	"RDRANDW": {"rdrand", 16}, "RDRANDL": {"rdrand", 32}, "RDRANDQ": {"rdrand", 64},
+	"RDSEEDW": {"rdseed", 16}, "RDSEEDL": {"rdseed", 32}, "RDSEEDQ": {"rdseed", 64},
+}
+
+func x86HardwareRandomProperties(op Op, ins Instr, arch string) (x86HardwareRandomSpec, bool, error) {
+	name := strings.ToUpper(string(op))
+	if !strings.HasPrefix(name, "RDRAND") && !strings.HasPrefix(name, "RDSEED") {
+		return x86HardwareRandomSpec{}, false, nil
+	}
+	spec, valid := x86HardwareRandomSpecs[Op(name)]
+	if !valid || arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 1 ||
+		!reflect.DeepEqual(ins.Args[0], Operand{Kind: OpReg, Reg: ins.Args[0].Reg}) ||
+		!isX86YrlRegisterForArch(ins.Args[0].Reg, arch) {
+		return spec, true, fmt.Errorf("%s %s requires the exact Go W/L/Q hardware-random register form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+// The instruction writes a machine value and CF availability status. NUM is
+// not a successful entropy result or a claim that CF=0 has the same value on
+// every vendor. No old destination bytes within the write width are inputs.
+func x86TypedHardwareRandomByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86HardwareRandomProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if !x86HardwareRandomPreservesSourceState(ins) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: hardware-random original/normalized source identity differs", ErrProbeNeedsContext)
+	}
+	return x86TypedByteEffect{
+		operands:     []x86TypedByteOperand{{index: 0, operand: ins.Args[0], width: int64(spec.bits / 8), write: true}},
+		flagsDefined: x86ByteFlagsAll, flagsKilled: x86ByteFlagsAll, requiresResultProof: true,
+	}, true, nil
+}
+
+func x86HardwareRandomPreservesSourceState(ins Instr) bool {
+	if _, known, err := x86HardwareRandomProperties(ins.Op, ins, "amd64"); !known || err != nil ||
+		ins.x86Encoded || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	return origin == nil || strings.EqualFold(string(origin.op), string(ins.Op)) && reflect.DeepEqual(origin.args, ins.Args)
+}
diff --git a/amd64_raw.go b/amd64_raw.go
new file mode 100644
index 000000000..2a13edb36
--- /dev/null
+++ b/amd64_raw.go
@@ -0,0 +1,10431 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func normalizeX86RawFile(file *File, goarch string, translationOptions ...Options) (*File, error) {
+	if file == nil || file.Arch != ArchAMD64 {
+		return file, nil
+	}
+	if err := validateX86MoveSourceAliases(file, goarch); err != nil {
+		return nil, err
+	}
+	if err := validateX86DirectiveFile(file); err != nil {
+		return nil, err
+	}
+	opt := Options{Goarch: goarch}
+	if len(translationOptions) != 0 {
+		opt = translationOptions[0]
+	}
+	normalized := *file
+	normalized.Funcs = append([]Func(nil), file.Funcs...)
+	normalized.Data = append([]DataStmt(nil), file.Data...)
+	usedSymbols := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		usedSymbols[fn.Sym] = true
+	}
+	for _, datum := range file.Data {
+		usedSymbols[datum.Sym] = true
+	}
+	for _, global := range file.Globl {
+		usedSymbols[global.Sym] = true
+	}
+	if err := preserveAddressSensitiveX86RawText(&normalized); err != nil {
+		return nil, err
+	}
+	for i := range normalized.Funcs {
+		originalFn := normalized.Funcs[i]
+		if replay := originalFn.x86RawReplay; replay != nil {
+			if err := replay.validateNormalized(originalFn, goarch); err != nil {
+				return nil, fmt.Errorf("%s: %w", originalFn.Sym, err)
+			}
+		}
+		if normalized.Funcs[i].X86RawText != nil {
+			if err := validateX86AddressSensitiveRawText(normalized.Funcs[i], goarch); err != nil {
+				return nil, fmt.Errorf("%s: %w", normalized.Funcs[i].Sym, err)
+			}
+			continue
+		}
+		if x86HasTerminalRawTail(normalized.Funcs[i]) &&
+			x86RawTailLayoutObserved(&normalized, normalized.Funcs[i].Sym) {
+			return nil, fmt.Errorf("%s: address-observed raw tail after RET cannot be omitted safely", normalized.Funcs[i].Sym)
+		}
+		fn, err := decodeX86RawDirectives(normalized.Funcs[i], goarch)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", normalized.Funcs[i].Sym, err)
+		}
+		// Replay compares the physical decoder with this checkpoint, before
+		// file-local DATA names replace its pending literal/address operands.
+		replay := fn.x86RawReplay
+		if replay == nil {
+			replay = newX86RawReplaySource(originalFn, fn, goarch)
+		}
+		hasLiteral := false
+		for _, ins := range fn.Instrs {
+			if ins.x86RIPLiteral {
+				hasLiteral = true
+				break
+			}
+		}
+		if hasLiteral && x86RawTailLayoutObserved(&normalized, fn.Sym) {
+			return nil, fmt.Errorf("%s: address-observed RIP-relative raw literal cannot be folded safely", fn.Sym)
+		}
+		addressSymbols := make(map[int]string)
+		for j := range fn.Instrs {
+			ins := &fn.Instrs[j]
+			if len(ins.x86RIPAddressData) == 0 {
+				continue
+			}
+			addressArg := -1
+			for index, arg := range ins.Args {
+				if arg.Kind == OpSym && arg.Sym == "·__plan9asm_raw_address_pending(SB)" {
+					addressArg = index
+					break
+				}
+			}
+			if addressArg < 0 {
+				continue
+			}
+			name := addressSymbols[ins.x86RIPAddressGroup]
+			if name == "" {
+				stem := fmt.Sprintf("·__plan9asm_raw_address_%x_%d", sha256.Sum256([]byte(fn.Sym)), ins.x86RIPAddressGroup)
+				name = stem
+				for suffix := 1; usedSymbols[name]; suffix++ {
+					name = fmt.Sprintf("%s_%d", stem, suffix)
+				}
+				usedSymbols[name] = true
+				addressSymbols[ins.x86RIPAddressGroup] = name
+				normalized.Data = append(normalized.Data, DataStmt{
+					Sym: name, Width: int64(len(ins.x86RIPAddressData)),
+					Payload: ins.x86RIPAddressData,
+				})
+			}
+			address := name
+			if ins.x86RIPAddressOff != 0 {
+				address += fmt.Sprintf("+%d", ins.x86RIPAddressOff)
+			}
+			if err := rebindX86RawStaticRead(ins, addressArg, address+"(SB)"); err != nil {
+				return nil, fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			ins.Raw = strings.Replace(ins.Raw, "·__plan9asm_raw_address_pending(SB)", ins.Args[addressArg].Sym, 1)
+		}
+		for j := range fn.Instrs {
+			ins := &fn.Instrs[j]
+			if len(ins.x86RIPLiteralData) == 0 {
+				continue
+			}
+			// Bounded-module translation normalizes again after partitioning.
+			// Keep the payload for constant-specialized lowerers without
+			// materializing a second global on that pass.
+			literalArg := -1
+			for index, arg := range ins.Args {
+				if arg.Kind == OpSym && arg.Sym == "·__plan9asm_raw_literal_pending(SB)" {
+					literalArg = index
+					break
+				}
+			}
+			if literalArg < 0 {
+				continue
+			}
+			stem := fmt.Sprintf("·__plan9asm_raw_literal_%x_%d", sha256.Sum256([]byte(fn.Sym)), j)
+			name := stem
+			for suffix := 1; usedSymbols[name]; suffix++ {
+				name = fmt.Sprintf("%s_%d", stem, suffix)
+			}
+			usedSymbols[name] = true
+			normalized.Data = append(normalized.Data, DataStmt{
+				Sym: name, Width: int64(len(ins.x86RIPLiteralData)),
+				Payload: ins.x86RIPLiteralData,
+			})
+			if err := rebindX86RawStaticRead(ins, literalArg, name+"(SB)"); err != nil {
+				return nil, fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			ins.Raw = strings.Replace(ins.Raw, "·__plan9asm_raw_literal_pending(SB)", ins.Args[literalArg].Sym, 1)
+		}
+		fn = normalizeX86RawReturnSourceStack(fn, opt, len(translationOptions) != 0, normalized.Funcs[i])
+		if opt.ResolveSym != nil {
+			sig := opt.Sigs[opt.ResolveSym(fn.Sym)]
+			// Observed private CALL roots are proved in the renderer's current
+			// function scope, not retained for every function in this directory.
+			deferred := file.x86DirectTails != nil && file.x86DirectTails.fixedLocal != nil
+			if sig.x86FixedLocal != nil && deferred && sig.x86FixedLocal != file.x86DirectTails.fixedLocal {
+				return nil, goAMD64FrameContext("deferred private root belongs to another source owner")
+			}
+			if sig.x86FixedLocal != nil && !deferred {
+				fn.x86DirectTailRoot = file.x86DirectTailView(fn.Sym)
+				fn, err = proveX86FixedLocal(fn, sig)
+				if err != nil {
+					return nil, err
+				}
+				fn.x86FixedLocal.binding = sig.x86FixedLocal
+			}
+		}
+		fn.x86RawReplay = replay.withNormalized(fn)
+		normalized.Funcs[i] = fn
+		// A folded read needs the actual allocated DATA object, not the
+		// pending placeholder or only the source instruction's mnemonic.
+		if err := validateX86RawNearReturns(fn, &normalized, opt, len(translationOptions) != 0); err != nil {
+			return nil, fmt.Errorf("%s: %w", fn.Sym, err)
+		}
+	}
+	return &normalized, nil
+}
+
+func x86HasTerminalRawTail(fn Func) bool {
+	start := len(fn.Instrs)
+	for start > 0 && isX86RawDirective(fn.Instrs[start-1]) {
+		start--
+	}
+	return start > 0 && start < len(fn.Instrs) && fn.Instrs[start-1].Op == OpRET
+}
+
+func x86RawTailLayoutObserved(file *File, symbol string) bool {
+	target := strings.TrimSuffix(symbol, "<>")
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			for _, operand := range ins.Args {
+				if fn.Sym == symbol && operand.Kind == OpMem && operand.Mem.Base == PC {
+					return true
+				}
+
+				ref := ""
+				switch operand.Kind {
+				case OpSym:
+					ref = operand.Sym
+				case OpMem:
+					ref = operand.Mem.Sym
+				}
+				if ref == "" {
+					continue
+				}
+				ref = strings.TrimSpace(strings.TrimPrefix(ref, "*"))
+				base, offset, ok := parseSBRef(ref)
+				if !ok || strings.TrimSuffix(strings.TrimPrefix(base, "$"), "<>") != target {
+					continue
+				}
+				if offset != 0 || !isX86DirectControlTransfer(ins.Op) {
+					return true
+				}
+			}
+		}
+	}
+	for _, datum := range file.Data {
+		base, _, ok := parseSBRef(datum.Addr)
+		if ok && strings.TrimSuffix(base, "<>") == target {
+			return true
+		}
+	}
+	return false
+}
+
+func isX86DirectControlTransfer(op Op) bool {
+	return op == OpCALL || op == OpJMP || op == OpRET || isAMD64ConditionalBranch(op)
+}
+
+// NormalizeRawFileForTranslation performs the whole-file raw-byte analysis
+// before a compile-only caller partitions functions into bounded modules.
+// Address-sensitive TEXT bodies must be identified while all references are
+// still visible. TranslateModuleInContext may safely normalize the result
+// again after partitioning. This preparation API has no function signatures:
+// final typed FP return-contract validation runs when translation consumes its
+// existing Options.Sigs. Preparation does not prove a callable return ABI.
+func NormalizeRawFileForTranslation(file *File, goarch string) (*File, error) {
+	return normalizeX86RawFile(file, goarch)
+}
+
+// preserveAddressSensitiveX86RawText identifies raw-only TEXT bodies whose
+// exact byte layout is observed elsewhere in the same source file. Typical
+// examples are boot trampolines patched through symbol+offset references and
+// TEXT-backed descriptor/data tables. Decoding such a body into LLVM
+// operations would make the referenced byte offsets false even when the
+// instruction semantics happened to match.
+//
+// Raw-only bodies that are merely called or jumped to are deliberately not
+// selected: those remain on the normal semantic decoder path.
+func preserveAddressSensitiveX86RawText(file *File) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	candidates := make(map[string]int)
+	encoded := make(map[int][]byte)
+	alignments := make(map[int]int64)
+	for index := range file.Funcs {
+		fn := &file.Funcs[index]
+		candidateName := strings.TrimSuffix(fn.Sym, "<>")
+		if fn.X86RawText != nil {
+			candidates[candidateName] = index
+			encoded[index] = append([]byte(nil), fn.X86RawText...)
+			alignments[index] = fn.X86RawAlign
+			continue
+		}
+		var code []byte
+		hasRaw := false
+		rawOnly := true
+		var alignment int64
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			if form, known, err := x86DirectiveProperties(ins); known && form.effect == x86DirectiveLayout && !hasRaw {
+				if err != nil {
+					rawOnly = false
+					break
+				}
+				if form.alignment > alignment {
+					alignment = form.alignment
+				}
+				continue
+			}
+			if !isX86RawDirective(ins) {
+				rawOnly = false
+				break
+			}
+			part, err := x86RawDirectiveBytes(ins)
+			if err != nil {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			code = append(code, part...)
+			hasRaw = true
+		}
+		if !rawOnly || !hasRaw {
+			continue
+		}
+		candidates[candidateName] = index
+		encoded[index] = code
+		alignments[index] = alignment
+	}
+	if len(candidates) == 0 {
+		return nil
+	}
+
+	addressed := make(map[int]bool)
+	markSymbol := func(symbol string) {
+		base, _, ok := parseSBRef(strings.TrimSpace(strings.TrimPrefix(symbol, "*")))
+		if !ok {
+			return
+		}
+		base = strings.TrimSuffix(base, "<>")
+		if index, exists := candidates[base]; exists {
+			addressed[index] = true
+		}
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			op := Op(strings.ToUpper(string(ins.Op)))
+			if op == OpCALL || op == OpJMP || op == OpRET || isAMD64ConditionalBranch(op) {
+				continue
+			}
+			for _, operand := range ins.Args {
+				switch operand.Kind {
+				case OpSym:
+					markSymbol(operand.Sym)
+				case OpMem:
+					if operand.Mem.Sym != "" {
+						markSymbol(operand.Mem.Sym)
+					}
+				}
+			}
+		}
+	}
+	for index := range addressed {
+		file.Funcs[index].X86RawText = append([]byte(nil), encoded[index]...)
+		file.Funcs[index].X86RawAlign = alignments[index]
+	}
+	return nil
+}
+
+// decodeX86RawDirectives replaces consecutive BYTE/WORD/LONG/QUAD directives
+// with the Plan 9 instructions represented by those bytes. The decoder and
+// syntax printer come from Go's architecture tables; the resulting instruction
+// still has to pass the ordinary plan9asm operand-form and semantic lowerers.
+// This is deliberately not an opaque inline-assembly escape hatch.
+func decodeX86RawDirectives(fn Func, goarch string) (Func, error) {
+	mode := 64
+	if goarch == "386" {
+		mode = 32
+	} else if goarch != "" && goarch != "amd64" {
+		return fn, fmt.Errorf("raw x86 directives require GOARCH 386 or amd64, got %q", goarch)
+	}
+
+	knownLabels := make(map[string]bool)
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpLABEL && len(ins.Args) == 1 && ins.Args[0].Kind == OpLabel {
+			knownLabels[ins.Args[0].Sym] = true
+		}
+	}
+
+	var normalized []Instr
+	for i := 0; i < len(fn.Instrs); {
+		if !isX86RawDirective(fn.Instrs[i]) {
+			normalized = append(normalized, fn.Instrs[i])
+			i++
+			continue
+		}
+
+		start := i
+		var code []byte
+		var rawLines []string
+		opaque := make(map[int]x86RawDecodedInstruction)
+		for i < len(fn.Instrs) {
+			if isX86RawDirective(fn.Instrs[i]) {
+				encoded, err := x86RawDirectiveBytes(fn.Instrs[i])
+				if err != nil {
+					return fn, err
+				}
+				code = append(code, encoded...)
+				rawLines = append(rawLines, fn.Instrs[i].Raw)
+				i++
+				continue
+			}
+			// Keep a run of named SSE constant reads in the same physical
+			// layout only when raw bytes resume after it. Go's encoder lengths
+			// are checked against the official assembler in tests.
+			end := i
+			for end < len(fn.Instrs) {
+				if _, ok := x86RawMixedSSESymbolReadSize(fn.Instrs[end]); !ok {
+					break
+				}
+				end++
+			}
+			if end == i || end == len(fn.Instrs) || !isX86RawDirective(fn.Instrs[end]) {
+				break
+			}
+			for i < end {
+				ins := fn.Instrs[i]
+				length, _ := x86RawMixedSSESymbolReadSize(ins)
+				opaque[len(code)] = x86RawDecodedInstruction{length: length, instrs: []Instr{ins}}
+				code = append(code, make([]byte, length)...)
+				rawLines = append(rawLines, ins.Raw)
+				i++
+			}
+		}
+		// Go appends BYTE/WORD/LONG/QUAD after a final RET to the previous
+		// TEXT, even when GLOBL declarations intervene. Without a following
+		// source label, the tail has no control-flow entry and is not an
+		// executable instruction stream. Generated tables can therefore
+		// contain arbitrary bytes, including apparent branches. Keep labeled
+		// tails on the normal decoder path so reachable code never disappears.
+		if i == len(fn.Instrs) && start > 0 && fn.Instrs[start-1].Op == OpRET {
+			continue
+		}
+		rawGroup := strings.Join(rawLines, "; ")
+		if mode == 64 {
+			if target, ok := x86RawRetpolineTarget(code); ok {
+				normalized = append(normalized, Instr{
+					Op:   OpJMP,
+					Args: []Operand{{Kind: OpReg, Reg: target}},
+					Raw:  fmt.Sprintf("JMP %s /* decoded retpoline from %s */", target, rawGroup),
+				})
+				continue
+			}
+		}
+		decoded, err := decodeX86RawDirectiveGroupWithOpaque(code, mode, start, rawGroup, knownLabels, opaque)
+		if err != nil {
+			return fn, err
+		}
+		for index := range decoded {
+			scalarSegmentLoad := x86ScalarSegmentLoadRawIdentity(decoded[index], goarch)
+			if scalarSegmentLoad.arch != "" {
+				decoded[index].x86Encoded = true
+			}
+			decoded[index].x86SourceRaw = &x86SourceRawInstruction{
+				op:                 decoded[index].Op,
+				args:               append([]Operand(nil), decoded[index].Args...),
+				vectorBytes:        decoded[index].x86VectorBytes,
+				addressBits:        decoded[index].x86AddressBits,
+				packedConversion:   x86PackedConversionRawIdentity(decoded[index], goarch),
+				packedMove:         x86PackedMoveRawIdentity(decoded[index], goarch),
+				packedReduction:    x86PackedReductionRawIdentity(decoded[index], goarch),
+				ternaryLogic:       x86TernaryLogicRawIdentity(decoded[index], goarch),
+				legacyFloatCompare: x86LegacyFloatCompareRawIdentity(decoded[index], goarch),
+				comi:               x86COMIRawIdentity(decoded[index], goarch),
+				floatMinMax:        x86FloatMinMaxRawIdentity(decoded[index], goarch),
+				scalarPrecision:    x86ScalarPrecisionRawIdentity(decoded[index], goarch),
+				scalarFloatInteger: x86ScalarFloatIntegerRawIdentity(decoded[index], goarch),
+				packedPrecision:    x86PackedPrecisionRawIdentity(decoded[index], goarch),
+				namedHalf:          x86NamedHalfRawIdentity(decoded[index], goarch),
+				fma3:               x86FMA3RawIdentity(decoded[index], goarch),
+				explicitMaskMove:   x86ExplicitMaskMoveRawIdentity(decoded[index], goarch),
+				packedShift:        x86PackedShiftRawIdentity(decoded[index], goarch),
+				packedAbs:          x86PackedAbsRawIdentity(decoded[index], goarch),
+				packedDot:          x86PackedDotRawIdentity(decoded[index], goarch),
+				permute128:         x86Permute128RawIdentity(decoded[index], goarch),
+				zeroExtend:         x86ZeroExtendRawIdentity(decoded[index], goarch),
+				scalarSegmentLoad:  scalarSegmentLoad,
+			}
+		}
+		normalized = append(normalized, decoded...)
+	}
+	fn.Instrs = normalized
+	return fn, nil
+}
+
+type x86RawDecodedInstruction struct {
+	length int
+	instrs []Instr
+}
+
+// decodeX86RawDirectiveGroup follows every reachable path through one raw
+// directive group. Internal relative JMP/Jcc targets become synthetic source
+// labels, so backward edges and both short and near conditional branches keep
+// their control-flow semantics. Bytes skipped by all reachable paths remain
+// uninterpreted, which permits the embedded signatures and constant data used
+// by generated assembly. Any edge outside the group or into an instruction is
+// still rejected rather than being guessed from final linked layout.
+func decodeX86RawDirectiveGroup(code []byte, mode, start int, rawGroup string, knownLabels map[string]bool) ([]Instr, error) {
+	return decodeX86RawDirectiveGroupWithOpaque(code, mode, start, rawGroup, knownLabels, nil)
+}
+
+func decodeX86RawDirectiveGroupWithOpaque(
+	code []byte, mode, start int, rawGroup string,
+	knownLabels map[string]bool, opaque map[int]x86RawDecodedInstruction,
+) ([]Instr, error) {
+	decodedByOffset := make(map[int]x86RawDecodedInstruction)
+	labels := make(map[int]string)
+	addressTargets := make(map[int]int)
+	var literalRanges []x86RawLiteralRange
+	recordLiteral := func(offset int, literal x86RawLiteralRange) {
+		literal.source = offset
+		literalRanges = append(literalRanges, literal)
+	}
+	owners := make([]int, len(code))
+	for i := range owners {
+		owners[i] = -1
+	}
+	for offset, named := range opaque {
+		if named.length <= 0 || offset < 0 || offset+named.length > len(code) {
+			return nil, fmt.Errorf("invalid named x86 source span at byte %d: %q", offset, rawGroup)
+		}
+		for current := offset; current < offset+named.length; current++ {
+			if owners[current] != -1 {
+				return nil, fmt.Errorf("overlapping named x86 source spans at byte %d: %q", current, rawGroup)
+			}
+			owners[current] = offset
+		}
+	}
+	queue := []int{0}
+	queued := map[int]bool{0: true}
+
+	labelFor := func(target int) string {
+		if label := labels[target]; label != "" {
+			return label
+		}
+		base := fmt.Sprintf("raw_jcc_%d_%d", start, target)
+		label := base
+		for suffix := 2; knownLabels[label]; suffix++ {
+			label = fmt.Sprintf("%s_%d", base, suffix)
+		}
+		knownLabels[label] = true
+		labels[target] = label
+		return label
+	}
+	enqueue := func(target int) error {
+		if target < 0 || target > len(code) {
+			return fmt.Errorf("raw x86 PC-relative target byte %d at instruction %d is outside directive group: %q", target, start, rawGroup)
+		}
+		if target < len(code) && owners[target] >= 0 && owners[target] != target {
+			return fmt.Errorf("raw x86 PC-relative target byte %d at instruction %d is not an instruction boundary: %q", target, start, rawGroup)
+		}
+		labelFor(target)
+		if !queued[target] {
+			queued[target] = true
+			queue = append(queue, target)
+		}
+		return nil
+	}
+	markInstruction := func(offset, length int) error {
+		if length <= 0 || offset+length > len(code) {
+			return fmt.Errorf("raw x86 instruction at instruction %d byte %d has invalid length %d: %q", start, offset, length, rawGroup)
+		}
+		for current := offset; current < offset+length; current++ {
+			if owners[current] >= 0 && owners[current] != offset {
+				return fmt.Errorf("raw x86 instruction at instruction %d byte %d overlaps instruction at byte %d: %q", start, offset, owners[current], rawGroup)
+			}
+		}
+		for current := offset; current < offset+length; current++ {
+			owners[current] = offset
+		}
+		return nil
+	}
+	annotate := func(instrs []Instr) []Instr {
+		for i := range instrs {
+			instrs[i].Raw = fmt.Sprintf("%s /* decoded from %s */", instrs[i].Raw, rawGroup)
+		}
+		return instrs
+	}
+
+	for len(queue) != 0 {
+		blockStart := queue[0]
+		queue = queue[1:]
+		if blockStart == len(code) {
+			continue
+		}
+		if owners[blockStart] >= 0 && owners[blockStart] != blockStart {
+			return nil, fmt.Errorf("raw x86 PC-relative target byte %d at instruction %d is not an instruction boundary: %q", blockStart, start, rawGroup)
+		}
+		for offset := blockStart; offset < len(code); {
+			if _, exists := decodedByOffset[offset]; exists {
+				break
+			}
+			if owners[offset] >= 0 && owners[offset] != offset {
+				return nil, fmt.Errorf("raw x86 reachable byte %d at instruction %d is inside instruction at byte %d: %q", offset, start, owners[offset], rawGroup)
+			}
+			if named, ok := opaque[offset]; ok {
+				decodedByOffset[offset] = named
+				offset += named.length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VectorZeroInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector zero at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawADX(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 ADX at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				if literal.last > literal.first {
+					recordLiteral(offset, literal)
+				}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ExtendedPrefetchInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 extended prefetch at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EnqueueInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 enqueue at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86WaitPackageInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 WAITPKG at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok := decodedX86EndBranchInstruction(code[offset:]); ok {
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok := decodedX86SystemManagementInstruction(code[offset:]); ok {
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+
+			if instruction, length, ok, err := decodedX86SegmentMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 segment-register move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if syntax, length, ok := decodedX86RandomInstruction(code[offset:], mode); ok {
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instrs, err := parseDecodedX86Instruction(syntax)
+				if err != nil {
+					return nil, fmt.Errorf("parse decoded raw x86 instruction %q at instruction %d byte %d: %w", syntax, start, offset, err)
+				}
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: annotate(instrs)}
+				offset += length
+				continue
+			}
+			if instruction, length, ok := decodedX86OrderingFenceInstruction(code[offset:], mode); ok {
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Op, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86CacheLineWritebackInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 cache-line writeback at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawBlockBroadcastRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX block broadcast literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawBlockBroadcastInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX block broadcast at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVBROADCAST128RIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VBROADCAST128 literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VBROADCAST128Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VBROADCAST128 at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVMOVIntegerLiteral(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VMOVD/VMOVQ literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VMOVQInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VMOVQ at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86MaskMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 KMOV at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86MaskVectorMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask/vector move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawEVEXPackedIntegerMoveRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed integer move literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXPackedIntegerMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed integer move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedMoveRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed move literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXUnalignedLoadInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 unaligned load at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawGatherInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 gather at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawScatterInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scatter at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawQwordPermuteInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 qword permute at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawPackedSignInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed sign at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ExplicitMaskMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 explicit mask move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawScalarMoveRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar move literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawDuplicateMoveRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 duplicate move literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86DuplicateMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 duplicate move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawFloatLogicalRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 floating logical literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawEVEXFloatLogicalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX floating logical instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXPackedFloatLogicalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX packed floating logical instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86FloatingUnpackInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 floating unpack at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 in-lane floating permute at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawMaskBlendRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask blend literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawMaskBlendInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask blend at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVariableBlendRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 variable blend literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VariableBlendInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 variable blend at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawImmediatePackedBlendRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 immediate packed blend literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawCLMULRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 carryless multiply literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawCLMULInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 carryless multiply at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ImmediatePackedBlendInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 immediate packed blend at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawBinaryFloatRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 binary floating literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXBinaryFloatInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX binary floating instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedWidenConversionRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed widening conversion literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedWidenConversionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed widening conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarFloatToIntegerInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar float-to-integer instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarIntegerFloatInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar integer-to-float instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarPrecisionConvertInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar precision conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawQQToFloatRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 QWORD-to-float literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawQQToFloatInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 QWORD-to-float conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedNumericConversionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw packed numeric conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86SameWidthConversionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 same-width packed conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedDoubleDwordInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed double/dword conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedPrecisionConvertInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed precision conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawScalarHalfConversionRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar FP16 literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarHalfConversionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar FP16 conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawFP16ConversionRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 FP16 conversion literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedHalfConversionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed half conversion at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawBF16RIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 BF16 literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawBF16Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 BF16 at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86MinimumPositionInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 minimum-position instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			// F3/0F38/3A is K-data MW2D, not 66/0F38/3A VPMINUW.
+			// Match the complete prefix key before the older min/max matcher.
+			if instruction, length, ok, err := decodedX86EVEXMaskDataBroadcastInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask-data broadcast at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawMinMaxRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer min/max literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedIntegerMinMaxInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer min/max at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86SingleSourceNarrowInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 single-source narrowing at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVariableShiftRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 per-lane variable shift literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PerLaneVariableShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 per-lane shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawMaskCompareRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask compare literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawMaskCompareInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask compare at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedCompareRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer compare literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedIntegerCompareInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer compare at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVectorBitCountInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector bit count at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawScalarReciprocalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar reciprocal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVectorHighLowMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector high/low move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVectorHalfMemoryInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector half memory move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawKLogicalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 K-register operation at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawMaskShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 mask shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawPackedTestMaskInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed test mask at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawPackedSADInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed SAD at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawScalarFlagCompareRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar flag compare literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarFlagCompareInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar flag compare at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXVectorTestInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX vector test at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXMoveMaskInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX move mask at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVectorFloatCompareRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector floating compare literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VectorFloatCompareInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector floating compare instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXHorizontalIntegerInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 horizontal integer at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawHorizontalFloatRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 horizontal floating literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXPackedDotInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX packed dot at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXHorizontalFloatInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX horizontal floating instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedLogicalRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed logical literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXPackedIntegerLogicalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX packed integer logical instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXPackedLogicalInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed logical instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedMADDRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX packed multiply-add literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXPackedMADDInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed multiply-add at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXPackedMADDInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX packed multiply-add instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawFMA3RIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 FMA3 literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXFMA3Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX FMA3 instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXTRACT128Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEXTRACT128 instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXNonTemporalMoveInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VEX non-temporal move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86InsertPSInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 INSERTPS/VINSERTPS at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedScalarExtractInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed scalar extract at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VPERMQInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPERMQ at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VINSERT128Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VINSERT128 at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXPackedInsertInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed insert at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawScalarFloatBroadcastLiteral(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar float broadcast literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ScalarBroadcastInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar broadcast at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedBroadcastLiteral(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed broadcast literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VEXPackedBroadcastInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed broadcast at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedAlignRightInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed align-right at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86Permute128Instruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 128-bit lane permute at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VSHUFPSInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VSHUFPS at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedShuffleInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed shuffle at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86Shuffle128BitBlocksInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VSHUFF/VSHUFI block shuffle at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVPSHUFBRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPSHUFB literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VPSHUFBInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPSHUFB at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedExtendInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed extending move at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedArithmeticRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer arithmetic literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedIntegerArithmeticInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed integer arithmetic at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVariableRotateRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 variable rotate literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVariableRotateInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 variable rotate at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedImmediateRotateInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed immediate rotate at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawImmediateThreeVectorRIPData(
+				code, offset, mode, 0x03, decodedX86VectorAlignInstruction, "vector align",
+			); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector align literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VectorAlignInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VALIGN at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawImmediateThreeVectorRIPData(
+				code, offset, mode, 0x25, decodedX86TernaryLogicInstruction, "ternary logic",
+			); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 ternary logic literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86TernaryLogicInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 ternary logic at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86FunnelShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 funnel shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedUniformShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed uniform shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawIndexedPermuteRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 indexed permute literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86IndexedPermuteInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 indexed permute at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedCompressInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed compress at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedExpandInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed expand at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86QwordLookupInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 qword lookup at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86IFMAInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 IFMA at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86GFNIInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 GFNI at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VPINSRInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPINSR at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXVPINSRInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX VPINSR at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawEVEXUnpackRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed unpack literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXPackedUnpackInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX packed unpack at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VPUNPCKInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPUNPCK at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VNNIInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VNNI at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VariableDwordPermuteInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPERMD/VPERMPS at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawEVEXVariableDwordPermuteRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX variable dword permute literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86EVEXVariableDwordPermuteInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 EVEX variable dword permute at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86SHAInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 SHA at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawBZHIInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 BZHI at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86BMI2ShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 BMI2 variable shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ParallelBitsInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 parallel bits at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86BLSInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 BLS at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86ANDNInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 ANDN at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86MULXInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 MULX at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RORXInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 RORX at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86AESInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 AES at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86DwordToQwordMultiplyInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 dword-to-qword multiply at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedAbsRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPABS literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawScaledRoundRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scaled round literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVEXRoundRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VROUND literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawVectorByteShiftRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector byte shift literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVectorByteShiftInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 vector byte shift at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawScaledRoundInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scaled round at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawVEXRoundInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VROUND at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86RawPackedAbsInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 VPABS at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86VectorPackedSaturatingNarrowInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed saturating narrow at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, literal, ok, err := decodeX86RawPackedMultiplyRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed multiply literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedAverageInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed average at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+			if instruction, length, ok, err := decodedX86PackedMultiplyInstruction(code[offset:], mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 packed multiply at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+
+			if instruction, length, ok, err := decodedX86ScalarPortIOInstruction(code[offset:]); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 scalar port I/O at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				offset += length
+				continue
+			}
+
+			if instruction, length, literal, ok, err := decodeX86RawLegacySIMDMoveRIPData(code, offset, mode); ok {
+				if err != nil {
+					return nil, fmt.Errorf("decode raw x86 legacy SIMD move literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+				}
+				if err := markInstruction(offset, length); err != nil {
+					return nil, err
+				}
+				instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: length, instrs: []Instr{instruction}}
+				recordLiteral(offset, literal)
+				offset += length
+				continue
+			}
+
+			inst, err := x86asm.Decode(code[offset:], mode)
+			if err != nil && mode == 64 {
+				if nop, ok := decodedX86REXWNOP(code[offset:]); ok {
+					inst, err = nop, nil
+				}
+			}
+			if err != nil || inst.Len <= 0 || inst.Op == 0 {
+				if err == nil {
+					if inst.Len <= 0 {
+						err = fmt.Errorf("decoder consumed zero bytes")
+					} else {
+						err = fmt.Errorf("incomplete or unknown instruction")
+					}
+				}
+				end := offset + 16
+				if end > len(code) {
+					end = len(code)
+				}
+				return nil, fmt.Errorf("decode raw x86 directive group at instruction %d byte %d (%x): %w: %q", start, offset, code[offset:end], err, rawGroup)
+			}
+			if err := markInstruction(offset, inst.Len); err != nil {
+				return nil, err
+			}
+			syntax, err := decodedX86GoSyntax(inst, code[offset:offset+inst.Len])
+			if err != nil {
+				return nil, fmt.Errorf("convert decoded raw x86 instruction at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+			}
+			if inst.Op == x86asm.NOP {
+				// Prefix/encoding checks above still apply. A multi-byte NOP's
+				// ModRM/SIB fields encode its length, not a memory access or
+				// PC-relative reference. Keep that length for branch boundaries,
+				// but do not send inert fields to the physical memory handoff.
+				instruction := Instr{Op: "NOP", Raw: fmt.Sprintf("NOP /* decoded from %s */", rawGroup)}
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: inst.Len, instrs: []Instr{instruction}}
+				offset += inst.Len
+				continue
+			}
+			opName := strings.Fields(syntax)[0]
+			op := Op(strings.ToUpper(opName))
+			if inst.PCRel != 0 {
+				if instruction, literal, ok, err := decodeX86RawLegacyScalarRIPData(code, offset, inst, syntax); ok {
+					if err != nil {
+						return nil, fmt.Errorf("decode raw x86 legacy scalar literal at instruction %d byte %d: %w: %q", start, offset, err, rawGroup)
+					}
+					instruction.Raw = fmt.Sprintf("%s /* decoded from %s */", instruction.Raw, rawGroup)
+					decodedByOffset[offset] = x86RawDecodedInstruction{length: inst.Len, instrs: []Instr{instruction}}
+					recordLiteral(offset, literal)
+					offset += inst.Len
+					continue
+				}
+				if mode == 64 && inst.Op == x86asm.LEA {
+					mem, ok := inst.Args[1].(x86asm.Mem)
+					if ok && mem.Base == x86asm.RIP {
+						// x86asm exposes disp32 as an unsigned magnitude here.
+						// RIP-relative LEA always sign-extends that 32-bit field.
+						target := offset + inst.Len + int(int32(mem.Disp))
+						if target < 0 || target >= len(code) {
+							return nil, fmt.Errorf("raw x86 local address target byte %d at instruction %d is outside directive group: %q", target, start, rawGroup)
+						}
+						instrs, err := parseDecodedX86PhysicalInstruction(inst, syntax)
+						if err != nil || len(instrs) != 1 || len(instrs[0].Args) != 2 {
+							return nil, fmt.Errorf("parse decoded raw x86 local address %q at instruction %d byte %d: %v", syntax, start, offset, err)
+						}
+						instrs[0].Args[0] = Operand{Kind: OpSym, Sym: "·__plan9asm_raw_address_pending(SB)"}
+						instrs[0].Raw = fmt.Sprintf("%s ·__plan9asm_raw_address_pending(SB), %s /* decoded from %s */", op, instrs[0].Args[1], rawGroup)
+						decodedByOffset[offset] = x86RawDecodedInstruction{length: inst.Len, instrs: instrs}
+						addressTargets[offset] = target
+						offset += inst.Len
+						continue
+					}
+				}
+				target, ok := x86RawRelativeTarget(inst, offset)
+				isJump := op == OpJMP
+				isConditional := isAMD64ConditionalBranch(op)
+				if !ok || (!isJump && !isConditional) {
+					return nil, fmt.Errorf("raw x86 PC-relative instruction %q at instruction %d byte %d cannot be mapped safely to source labels: %q", syntax, start, offset, rawGroup)
+				}
+				if err := enqueue(target); err != nil {
+					return nil, fmt.Errorf("raw x86 branch at byte %d: %w", offset, err)
+				}
+				label := labelFor(target)
+				branch := Instr{Op: op, Args: []Operand{{Kind: OpIdent, Ident: label}}, Raw: fmt.Sprintf("%s %s /* decoded from %s */", op, label, rawGroup)}
+				decodedByOffset[offset] = x86RawDecodedInstruction{length: inst.Len, instrs: []Instr{branch}}
+				if isConditional {
+					if err := enqueue(offset + inst.Len); err != nil {
+						return nil, fmt.Errorf("raw x86 conditional fallthrough at byte %d: %w", offset, err)
+					}
+				}
+				break
+			}
+			if inst.Op == x86asm.JMP {
+				return nil, fmt.Errorf("raw x86 indirect jump at instruction %d byte %d cannot be mapped safely: %q", start, offset, rawGroup)
+			}
+			instrs, err := parseDecodedX86PhysicalInstruction(inst, syntax)
+			if err != nil {
+				return nil, fmt.Errorf("parse decoded raw x86 instruction %q at instruction %d byte %d: %w", syntax, start, offset, err)
+			}
+			if inst.Op == x86asm.LEA && len(instrs) == 1 && len(instrs[0].Args) == 2 {
+				// Bare absolute SIB/no-base addresses print as numbers, but
+				// the Go parser treats those as symbols. Retain the actual
+				// typed decoder memory operand, not a fabricated SB name.
+				physical := normalizeDecodedX86LEASegments(normalizeDecodedX86MemoryDisplacements(inst))
+				if memory, ok := physical.Args[1].(x86asm.Mem); ok && memory.Base == 0 && memory.Index == 0 && memory.Segment == 0 {
+					instrs[0].Args[0] = Operand{Kind: OpMem, Mem: MemRef{Off: memory.Disp}}
+				}
+			}
+			if inst.AddrSize != mode {
+				physicalMemory := false
+				for _, operand := range inst.Args {
+					if _, ok := operand.(x86asm.Mem); ok {
+						physicalMemory = true
+					}
+				}
+				switch inst.Op {
+				case x86asm.MASKMOVQ, x86asm.MASKMOVDQU, x86asm.MONITOR:
+					// These decoded forms address DI/AX implicitly. x/arch
+					// exposes only register (or no) operands, not a Mem.
+					physicalMemory = true
+				}
+				for i := range instrs {
+					if physicalMemory {
+						instrs[i].x86AddressBits = inst.AddrSize
+						// Generic Go syntax erases address-size prefixes. Only
+						// LEA's complete typed form consumes that width here;
+						// ordinary memory must not borrow a full-width address.
+						instrs[i].x86UnboundAddressOverride = inst.Op != x86asm.LEA
+					}
+				}
+			}
+			if inst.Op == x86asm.MOVSXD && inst.DataSize != 64 {
+				for i := range instrs {
+					instrs[i].x86RawMOVSXDNeedsCaller = true
+				}
+			}
+			if inst.Op == x86asm.CVTPI2PS || inst.Op == x86asm.CVTPI2PD {
+				for i := range instrs {
+					instrs[i].x86MMXSourceConversion = true
+				}
+			}
+			if inst.Op == x86asm.RET {
+				form := x86RawNearReturnEncoding(code[offset : offset+inst.Len])
+				for i := range instrs {
+					if instrs[i].Op != OpRET {
+						continue
+					}
+					instrs[i].x86RawNearReturn = &form
+					if form.nativeWidth && form.cleanup == 0 {
+						// Keep the encoded semantics in private metadata. Removing the
+						// zero operand does not validate the containing source frame.
+						instrs[i].Args = nil
+					}
+				}
+			}
+			decodedByOffset[offset] = x86RawDecodedInstruction{length: inst.Len, instrs: annotate(instrs)}
+			offset += inst.Len
+			if inst.Op == x86asm.RET {
+				break
+			}
+		}
+	}
+
+	for _, literal := range literalRanges {
+		for offset := literal.first; offset < literal.last; offset++ {
+			if owners[offset] >= 0 {
+				return nil, fmt.Errorf("RIP-relative literal byte %d overlaps reachable instruction at byte %d: %q", offset, owners[offset], rawGroup)
+			}
+		}
+	}
+	if len(addressTargets) != 0 {
+		first := len(code)
+		for _, target := range addressTargets {
+			if target < first {
+				first = target
+			}
+		}
+		// Only a fully unreachable suffix after a decoded RET can be moved to
+		// a shared global. Addressing executable bytes or a separately folded
+		// literal would lose source-relative pointer identity.
+		retBeforeSuffix := false
+		for offset, decoded := range decodedByOffset {
+			if offset >= first {
+				continue
+			}
+			for _, ins := range decoded.instrs {
+				if ins.Op == OpRET {
+					retBeforeSuffix = true
+				}
+			}
+		}
+		if !retBeforeSuffix {
+			return nil, fmt.Errorf("raw x86 local address data at byte %d has no preceding RET: %q", first, rawGroup)
+		}
+		for offset := first; offset < len(code); offset++ {
+			if owners[offset] >= 0 {
+				return nil, fmt.Errorf("raw x86 local address byte %d overlaps reachable instruction: %q", offset, rawGroup)
+			}
+		}
+		for _, literal := range literalRanges {
+			if literal.last <= first {
+				continue
+			}
+			if literal.first < first {
+				return nil, fmt.Errorf("raw x86 local address overlaps the middle of a folded literal: %q", rawGroup)
+			}
+			decoded := decodedByOffset[literal.source]
+			for index := range decoded.instrs {
+				ins := &decoded.instrs[index]
+				for arg := range ins.Args {
+					if ins.Args[arg].Kind != OpSym || ins.Args[arg].Sym != "·__plan9asm_raw_literal_pending(SB)" {
+						continue
+					}
+					if err := rebindX86RawStaticRead(ins, arg, "·__plan9asm_raw_address_pending(SB)"); err != nil {
+						return nil, err
+					}
+					ins.Raw = strings.Replace(ins.Raw, "·__plan9asm_raw_literal_pending(SB)", ins.Args[arg].Sym, 1)
+					// An address escape may permit writes to this pool. Force a
+					// runtime load rather than specializing from its initial bytes.
+					ins.x86RIPLiteralData = nil
+					// Address escape forbids constant specialization, not a
+					// read of this exact allocated static object. Retain the
+					// physical read range and bind the shared whole suffix.
+					ins.x86RIPMemoryRead.offset = int64(literal.first - first)
+					ins.x86RIPMemoryRead.object = append([]byte(nil), code[first:]...)
+					ins.x86RIPAddressData = code[first:]
+					ins.x86RIPAddressOff = literal.first - first
+					ins.x86RIPAddressGroup = start
+				}
+			}
+			decodedByOffset[literal.source] = decoded
+		}
+		for offset, target := range addressTargets {
+			decoded := decodedByOffset[offset]
+			decoded.instrs[0].x86RIPLiteral = true
+			decoded.instrs[0].x86RIPAddressData = code[first:]
+			decoded.instrs[0].x86RIPAddressOff = target - first
+			decoded.instrs[0].x86RIPAddressGroup = start
+			decodedByOffset[offset] = decoded
+		}
+	}
+
+	offsets := make([]int, 0, len(decodedByOffset))
+	for offset := range decodedByOffset {
+		offsets = append(offsets, offset)
+	}
+	sort.Ints(offsets)
+	result := make([]Instr, 0, len(offsets)+len(labels))
+	for _, offset := range offsets {
+		if label := labels[offset]; label != "" {
+			result = append(result, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label}}, Raw: label + ":"})
+		}
+		result = append(result, decodedByOffset[offset].instrs...)
+	}
+	if label := labels[len(code)]; label != "" {
+		result = append(result, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label}}, Raw: label + ":"})
+	}
+	return result, nil
+}
+
+// decodedX86SegmentMoveInstruction recognizes the complete 8C/8E segment
+// register move family represented by Go 1.27's ymovtab. Go spells these
+// operations MOVW even though x86 disassemblers often print register forms as
+// MOVL or MOVQ according to the encoded general-register destination width.
+func decodedX86SegmentMoveInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segmentOverride := Reg("")
+	addressOverride := false
+	rex := byte(0)
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			rex = 0
+			segmentOverride = FS
+			i++
+		case 0x65:
+			rex = 0
+			segmentOverride = GS
+			i++
+		case 0x66:
+			rex = 0
+			i++
+		case 0x67:
+			rex = 0
+			addressOverride = true
+			i++
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				i++
+				continue
+			}
+			goto opcode
+		}
+	}
+
+opcode:
+	if i >= len(code) || (code[i] != 0x8c && code[i] != 0x8e) || len(code) < i+2 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRM := code[i+1]
+	segmentNumber := int(modRM>>3&7) + int(rex>>2&1)*8
+	segmentNames := [...]Reg{ES, CS, SS, DS, FS, GS}
+	if segmentNumber >= len(segmentNames) {
+		return Instr{}, 0, true, fmt.Errorf("reserved segment-register encoding %d", segmentNumber)
+	}
+	bExt := int(rex & 1)
+	xExt := int(rex>>1) & 1
+	other, consumed, decodeErr := decodedX86RMSource(code[i+1:], mode, bExt, xExt, segmentOverride, 1)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	segment := Operand{Kind: OpReg, Reg: segmentNames[segmentNumber]}
+	args := []Operand{segment, other}
+	if code[i] == 0x8e {
+		args[0], args[1] = args[1], args[0]
+	}
+	return Instr{
+		Op:   "MOVW",
+		Args: args,
+		Raw:  fmt.Sprintf("MOVW %s, %s", args[0].String(), args[1].String()),
+	}, i + 1 + consumed, true, nil
+}
+
+// decodedX86MaskMoveInstruction recognizes Go 1.27's complete VEX-encoded
+// KMOVB/W/D/Q family. x/arch v0.14 does not decode opmask registers and can
+// split these bytes into unrelated legacy instructions, so recover all four
+// _ykmovb operand rows before consulting the generic decoder.
+func decodedX86MaskMoveInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86MaskMoveInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86MaskMoveInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	opcodeIndex := i + vexLength
+	if len(code) <= opcodeIndex || code[opcodeIndex] < 0x90 || code[opcodeIndex] > 0x93 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.L must be zero")
+	}
+	if vexBits&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be 1111")
+	}
+
+	opcode := code[opcodeIndex]
+	pp := vexBits & 3
+	width64 := vexLength == 3 && vexBits&0x80 != 0
+	width := ""
+	if opcode == 0x90 || opcode == 0x91 {
+		switch {
+		case !width64 && pp == 1:
+			width = "B"
+		case !width64 && pp == 0:
+			width = "W"
+		case width64 && pp == 1:
+			width = "D"
+		case width64 && pp == 0:
+			width = "Q"
+		}
+	} else {
+		switch {
+		case !width64 && pp == 1:
+			width = "B"
+		case !width64 && pp == 0:
+			width = "W"
+		case !width64 && pp == 3:
+			width = "D"
+		case width64 && pp == 3:
+			width = "Q"
+		}
+	}
+	if width == "" {
+		return Instr{}, 0, true, fmt.Errorf("invalid VEX.W/pp combination")
+	}
+
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	mod := modRM >> 6
+	regNumber := int(modRM>>3&7) + rExt*8
+	rmNumber := int(modRM&7) + bExt*8
+	kReg := func(number int) (Operand, error) {
+		if number < 0 || number > 7 {
+			return Operand{}, fmt.Errorf("invalid opmask register K%d", number)
+		}
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", number))}, nil
+	}
+	gpReg := func(number int) (Operand, error) {
+		reg, valid := decodedX86GeneralRegister(number)
+		if !valid || mode == 32 && number >= 8 {
+			return Operand{}, fmt.Errorf("invalid general register %d", number)
+		}
+		return Operand{Kind: OpReg, Reg: reg}, nil
+	}
+
+	var src, dst Operand
+	consumed := 1
+	switch opcode {
+	case 0x90: // K-or-memory -> K
+		dst, err = kReg(regNumber)
+		if err != nil {
+			return Instr{}, 0, true, err
+		}
+		if mod == 3 {
+			src, err = kReg(rmNumber)
+		} else {
+			src, consumed, err = memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		}
+	case 0x91: // K -> memory
+		if mod == 3 {
+			return Instr{}, 0, true, fmt.Errorf("opcode 91 requires a memory destination")
+		}
+		src, err = kReg(regNumber)
+		if err == nil {
+			dst, consumed, err = memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		}
+	case 0x92: // GP -> K
+		if mod != 3 {
+			return Instr{}, 0, true, fmt.Errorf("opcode 92 requires a general-register source")
+		}
+		dst, err = kReg(regNumber)
+		if err == nil {
+			src, err = gpReg(rmNumber)
+		}
+	case 0x93: // K -> GP
+		if mod != 3 {
+			return Instr{}, 0, true, fmt.Errorf("opcode 93 requires a general-register destination")
+		}
+		src, err = kReg(rmNumber)
+		if err == nil {
+			dst, err = gpReg(regNumber)
+		}
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := Op("KMOV" + width)
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{src, dst},
+		Raw:  fmt.Sprintf("%s %s, %s", op, src.String(), dst.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+// decodedX86EVEXPackedIntegerMoveInstruction recognizes the complete EVEX
+// family behind Go 1.27's shared _yvmovdqa32 table. x/arch v0.14 cannot
+// decode these encodings, including the raw VMOVDQU32 loads emitted by
+// github.com/minio/sha256-simd. Decode all six opcodes and all twelve table
+// rows before consulting the generic decoder.
+func decodedX86EVEXPackedIntegerMoveInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedIntegerMoveInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedIntegerMoveInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedMoveInstruction(code, mode, memory, "packed integer move", func(pp byte, width64 bool, opcode byte) (Op, bool, bool) {
+		store := opcode == 0x7f
+		if opcode != 0x6f && !store {
+			return "", false, false
+		}
+		switch {
+		case pp == 1 && !width64:
+			return "VMOVDQA32", store, true
+		case pp == 1 && width64:
+			return "VMOVDQA64", store, true
+		case pp == 3 && !width64:
+			return "VMOVDQU8", store, true
+		case pp == 3 && width64:
+			return "VMOVDQU16", store, true
+		case pp == 2 && !width64:
+			return "VMOVDQU32", store, true
+		case pp == 2 && width64:
+			return "VMOVDQU64", store, true
+		default:
+			return "", false, false
+		}
+	})
+}
+
+type decodedX86EVEXMoveMatcher func(pp byte, width64 bool, opcode byte) (op Op, store bool, ok bool)
+
+func decodedX86EVEXPackedMoveInstruction(code []byte, mode int, memory x86RawMemoryDecoder, family string, match decodedX86EVEXMoveMatcher) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 1 || p1&0x04 == 0 || p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, false, nil
+	}
+	pp := p1 & 3
+	width64 := p1&0x80 != 0
+	op, store, matched := match(pp, width64, opcode)
+	if !matched {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is not valid for %s", family)
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	disp8Scale := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if zeroing && store && code[i+5]>>6 != 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing is invalid for a memory store")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	regNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	reg := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, regNumber))}
+	rm, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+
+	args := []Operand{rm, reg}
+	if store {
+		args[0], args[1] = reg, rm
+	}
+	if maskNumber != 0 {
+		mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))}
+		args = []Operand{args[0], mask, args[1]}
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	instruction = Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXRMOperand(code []byte, mode, bExt, xExt int, segment Reg, vectorPrefix string, disp8Scale int) (Operand, int, error) {
+	if len(code) == 0 {
+		return Operand{}, 0, fmt.Errorf("missing ModRM byte")
+	}
+	if code[0]>>6 == 3 {
+		number := int(code[0]&7) + bExt*8 + xExt*16
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, number))}, 1, nil
+	}
+	return decodedX86RMSource(code, mode, bExt, xExt, segment, disp8Scale)
+}
+
+func x86RawRelativeTarget(inst x86asm.Inst, offset int) (int, bool) {
+	for _, arg := range inst.Args {
+		if relative, ok := arg.(x86asm.Rel); ok {
+			return offset + inst.Len + int(relative), true
+		}
+	}
+	return 0, false
+}
+
+// decodedX86VMOVQInstruction recognizes the complete Go 1.27 _yvmovd and
+// _yvmovq families. VMOVD has the X-to-GP/memory and reverse forms; VMOVQ
+// additionally has two X-to-X encodings. Recover every VEX and EVEX form
+// before consulting the generic decoder, which can split the raw VMOVD bytes
+// emitted by Weaviate into a relative branch. Raw AVX512-FP16 VMOVW uses the
+// same operand grammar with a two-byte transfer and a distinct opcode map.
+func decodedX86VMOVQInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VMOVQInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VMOVQInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXVMOVDQInstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+	if len(code) < i+3 {
+		return Instr{}, 0, false, nil
+	}
+
+	var rExt, xExt, bExt, vexLength int
+	var vexBits byte
+	switch code[i] {
+	case 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case 0xc4:
+		if len(code) < i+4 || code[i+1]&0x1f != 1 {
+			return Instr{}, 0, false, nil
+		}
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	opcodeIndex := i + vexLength
+	if len(code) <= opcodeIndex {
+		return Instr{}, 0, false, nil
+	}
+
+	opcode := code[opcodeIndex]
+	pp := vexBits & 3
+	width64 := vexLength == 3 && vexBits&0x80 != 0
+	type vmovqDirection int
+	const (
+		xToGeneral vmovqDirection = iota
+		xToVector
+		generalToX
+		vectorToX
+	)
+	op := Op("")
+	direction := xToGeneral
+	switch {
+	case opcode == 0x7e && pp == 1 && !width64:
+		op = "VMOVD"
+		direction = xToGeneral
+	case opcode == 0x6e && pp == 1 && !width64:
+		op = "VMOVD"
+		direction = generalToX
+	case opcode == 0x7e && pp == 1 && width64:
+		op = "VMOVQ"
+		direction = xToGeneral
+	case opcode == 0xd6 && pp == 1 && !width64:
+		op = "VMOVQ"
+		direction = xToVector
+	case opcode == 0x6e && pp == 1 && width64:
+		op = "VMOVQ"
+		direction = generalToX
+	case opcode == 0x7e && pp == 2 && !width64:
+		op = "VMOVQ"
+		direction = vectorToX
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&0x7c != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be 1111 and VEX.L must be zero")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	vectorNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || vectorNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	vector := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", vectorNumber))}
+	rmVector := direction == xToVector || direction == vectorToX
+	rm, consumed, decodeErr := memory.vexTransfer(code[modRMIndex:], mode, bExt, xExt, segment, rmVector)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	if mode == 32 && width64 && rm.Kind == OpReg {
+		return Instr{}, 0, true, fmt.Errorf("64-bit general register is unavailable in 32-bit mode")
+	}
+
+	args := []Operand{vector, rm}
+	if direction == generalToX || direction == vectorToX {
+		args[0], args[1] = rm, vector
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s %s, %s", op, args[0].String(), args[1].String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXVMOVDQInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXVMOVDQInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXVMOVDQInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	wordMove := p0&0x0f == 5 && p1&3 == 1 && (opcode == 0x6e || opcode == 0x7e)
+	if p0&0x0f != 1 && !wordMove {
+		return Instr{}, 0, false, nil
+	}
+	if p1&0x04 == 0 || p1&0x78 != 0x78 || p2 != 0x08 {
+		if wordMove {
+			return Instr{}, 0, true, fmt.Errorf("VMOVW requires reserved vvvv, fixed 128-bit length, and no mask or broadcast")
+		}
+		return Instr{}, 0, false, nil
+	}
+	pp := p1 & 3
+	width64 := p1&0x80 != 0
+	type vmovdqDirection int
+	const (
+		xToGeneral vmovdqDirection = iota
+		xToVector
+		generalToX
+		vectorToX
+	)
+	op := Op("")
+	direction := xToGeneral
+	switch {
+	case wordMove:
+		op = "VMOVW"
+		if opcode == 0x6e {
+			direction = generalToX
+		}
+	case opcode == 0x7e && pp == 1 && !width64:
+		op = "VMOVD"
+		direction = xToGeneral
+	case opcode == 0x6e && pp == 1 && !width64:
+		op = "VMOVD"
+		direction = generalToX
+	case opcode == 0x7e && pp == 1 && width64:
+		op = "VMOVQ"
+		direction = xToGeneral
+	case opcode == 0xd6 && pp == 1 && width64:
+		op = "VMOVQ"
+		direction = xToVector
+	case opcode == 0x6e && pp == 1 && width64:
+		op = "VMOVQ"
+		direction = generalToX
+	case opcode == 0x7e && pp == 2 && width64:
+		op = "VMOVQ"
+		direction = vectorToX
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	vectorNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	rmVector := direction == xToVector || direction == vectorToX
+	if mode == 32 && (vectorNumber >= 8 || rmVector && modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	if modRM>>6 == 3 && !rmVector && xExt != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.X cannot extend a general register")
+	}
+	vector := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", vectorNumber))}
+	transferBytes := 4
+	if wordMove {
+		transferBytes = 2
+	} else if op == "VMOVQ" {
+		transferBytes = 8
+	}
+	var rm Operand
+	var consumed int
+	var decodeErr error
+	if rmVector {
+		rm, consumed, decodeErr = memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, "X", transferBytes)
+	} else {
+		rm, consumed, decodeErr = memory.scalar(code[modRMIndex:], mode, bExt, xExt, segment, transferBytes)
+	}
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	if mode == 32 && op == "VMOVQ" && rm.Kind == OpReg && !rmVector {
+		return Instr{}, 0, true, fmt.Errorf("64-bit general register is unavailable in 32-bit mode")
+	}
+	args := []Operand{vector, rm}
+	if direction == generalToX || direction == vectorToX {
+		args[0], args[1] = rm, vector
+	}
+	instruction = Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s, %s", op, args[0].String(), args[1].String()),
+		x86Encoded: wordMove,
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86VEXRMOperand(code []byte, mode, bExt, xExt int, segment Reg, vectorRegister bool) (Operand, int, error) {
+	if len(code) == 0 {
+		return Operand{}, 0, fmt.Errorf("missing ModRM byte")
+	}
+	if code[0]>>6 != 3 || !vectorRegister {
+		return decodedX86VEXRMSource(code, mode, bExt, xExt, segment)
+	}
+	number := int(code[0]&7) + bExt*8
+	if mode == 32 && number >= 8 {
+		return Operand{}, 0, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", number))}, 1, nil
+}
+
+// The complete VEX/EVEX non-temporal move family shares the physical prefix
+// decoder. The historical VEX entry name is retained for its existing callers.
+// These boundaries grant no raw translation, memory or entry-state permission.
+func decodedX86VEXNonTemporalMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86VEXNonTemporalMoveInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXNonTemporalMoveInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, known := decodeX86RawVectorEncoding(code)
+	if !known {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	load := false
+	switch {
+	case p.mapNumber == 1 && p.opcode == 0xe7 && p.pp == 1:
+		op = "VMOVNTDQ"
+	case p.mapNumber == 1 && p.opcode == 0x2b && p.pp == 1:
+		op = "VMOVNTPD"
+	case p.mapNumber == 1 && p.opcode == 0x2b && p.pp == 0:
+		op = "VMOVNTPS"
+	case p.mapNumber == 2 && p.opcode == 0x2a && p.pp == 1:
+		op, load = "VMOVNTDQA", true
+	default:
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("non-temporal vector move: %s", message)
+	}
+	if mode != 32 && mode != 64 || p.addressOverride {
+		return fail("unknown mode or unbound address-size override")
+	}
+	if p.upper != 0 || p.mask != 0 || p.zero || p.broadcast || p.vectorLength > 2 {
+		return fail("reserved input, mask, zeroing, broadcast or length")
+	}
+	// VEX.W is ignored; EVEX.W distinguishes PD from the W0 rows.
+	if p.evex && (!p.fixed || p.w != (op == "VMOVNTPD")) {
+		return fail("invalid EVEX fixed or width bit")
+	}
+	if len(code) <= p.modRM || code[p.modRM]>>6 == 3 {
+		return fail("missing native memory ModRM")
+	}
+	register := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (register >= 8 || p.x != 0 || p.b != 0) {
+		return fail("unbound extended physical register in mode32")
+	}
+	bank := []string{"X", "Y", "Z"}[p.vectorLength]
+	vector := Operand{Kind: OpReg, Reg: Reg(fmt.Sprint(bank, register))}
+	var operand Operand
+	var consumed int
+	var err error
+	if p.evex {
+		operand, consumed, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, bank, 16<<p.vectorLength)
+	} else {
+		operand, consumed, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, bank)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	args := []Operand{vector, operand}
+	if load {
+		args[0], args[1] = operand, vector
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s, %s", op, args[0].String(), args[1].String())},
+		p.modRM + consumed, true, nil
+}
+
+// decodedX86VINSERT128Instruction recognizes the complete VEX
+// VINSERTF128/VINSERTI128 family. x/arch v0.14 can misclassify the bytes that
+// follow these instructions as PC-relative control flow.
+func decodedX86VINSERT128Instruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VINSERT128InstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VINSERT128InstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 3 {
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[byte]Op{0x18: "VINSERTF128", 0x38: "VINSERTI128"}[code[i+3]]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	if mode == 32 {
+		return Instr{}, 0, true, fmt.Errorf("386 %s exceeds the Go assembler frontend's operand limit", op)
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vex0, vexBits := code[i+1], code[i+2]
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if vexBits&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("%s requires VEX.256", op)
+	}
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+// decodedX86EVEXPackedInsertInstruction recognizes every EVEX row in Go
+// 1.27's _yvinsertf32x4 and _yvinsertf32x8 tables. The floating and integer
+// spellings share their encodings apart from the opcode, while EVEX.W selects
+// 32- or 64-bit lane names. This includes Y/Z output widths, register and
+// memory insert sources, and optional merge/zero masks.
+func decodedX86EVEXPackedInsertInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedInsertInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedInsertInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+5 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 3 || p1&3 != 1 {
+		return Instr{}, 0, false, nil
+	}
+	integer := opcode == 0x38 || opcode == 0x3a
+	wideInsert := opcode == 0x1a || opcode == 0x3a
+	if opcode != 0x18 && opcode != 0x1a && !integer {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode == 32 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed vector inserts are unavailable in 32-bit mode")
+	}
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit must be one")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for packed vector inserts")
+	}
+	vectorBits := p2 >> 5 & 3
+	if wideInsert {
+		if vectorBits != 2 {
+			return Instr{}, 0, true, fmt.Errorf("wide packed vector insert requires a Z output")
+		}
+	} else if vectorBits != 1 && vectorBits != 2 {
+		return Instr{}, 0, true, fmt.Errorf("packed vector insert requires a Y or Z output")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	insertBytes := 16
+	sourceName := "X"
+	laneBits := 32
+	if p1&0x80 != 0 {
+		laneBits = 64
+	}
+	if wideInsert {
+		insertBytes = 32
+		sourceName = "Y"
+	}
+	stem := "VINSERTF"
+	if integer {
+		stem = "VINSERTI"
+	}
+	op := Op(fmt.Sprintf("%s%dX%d", stem, laneBits, insertBytes*8/laneBits))
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	secondNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	first, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, sourceName, insertBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{immediate, first, second}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86VEXPackedBroadcastInstruction recognizes the complete VEX and EVEX
+// VPBROADCASTB/W/D/Q and K-data broadcast families represented by Go 1.27's
+// _yvpbroadcastb and _yvpbroadcastmb2q tables.
+// x/arch v0.14 can misclassify the VEX bytes as PC-relative branches, as
+// observed in github.com/vivint/infectious, and cannot decode the EVEX
+// general-register form used by github.com/JohanLindvall/haste.
+func decodedX86VEXPackedBroadcastInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXPackedBroadcastInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXPackedBroadcastInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	// Original native observers use this shared broadcast-family entry.
+	// The block form keeps the same decoder and memory policy as raw source.
+	if instruction, length, ok, err = decodedX86VBROADCAST128InstructionWithMemory(code, mode, memory); ok || err != nil {
+		return
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXPackedBroadcastInstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 2 {
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[byte]Op{
+		0x78: "VPBROADCASTB",
+		0x79: "VPBROADCASTW",
+		0x58: "VPBROADCASTD",
+		0x59: "VPBROADCASTQ",
+	}[code[i+3]]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vex0, vexBits := code[i+1], code[i+2]
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if int(^vexBits>>3)&15 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be 1111")
+	}
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	vectorName := "X"
+	if vexBits&0x04 != 0 {
+		vectorName = "Y"
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXPackedBroadcastInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedBroadcastInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedBroadcastInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+5 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f == 2 && p1&3 == 2 && (opcode == 0x2a || opcode == 0x3a) {
+		return decodedX86EVEXMaskDataBroadcastInstruction(code, mode)
+	}
+	if p0&0x0f != 2 || p1&3 != 1 {
+		return Instr{}, 0, false, nil
+	}
+	width64 := p1&0x80 != 0
+	vectorSource := false
+	laneBytes := 0
+	op := Op("")
+	switch opcode {
+	case 0x7a:
+		op, laneBytes = "VPBROADCASTB", 1
+	case 0x7b:
+		op, laneBytes = "VPBROADCASTW", 2
+	case 0x7c:
+		if width64 {
+			op, laneBytes = "VPBROADCASTQ", 8
+		} else {
+			op, laneBytes = "VPBROADCASTD", 4
+		}
+	case 0x78:
+		op, laneBytes, vectorSource = "VPBROADCASTB", 1, true
+	case 0x79:
+		op, laneBytes, vectorSource = "VPBROADCASTW", 2, true
+	case 0x58:
+		op, laneBytes, vectorSource = "VPBROADCASTD", 4, true
+	case 0x59:
+		op, laneBytes, vectorSource = "VPBROADCASTQ", 8, true
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if (!vectorSource || opcode != 0x59) && opcode != 0x7c && width64 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W must be zero for %s", op)
+	}
+	if vectorSource && opcode == 0x59 && !width64 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W must be one for %s", op)
+	}
+	if p1&0x7c != 0x7c || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for packed scalar broadcasts")
+	}
+	vectorBits := p2 >> 5 & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && destinationNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+
+	var source Operand
+	consumed := 0
+	if vectorSource {
+		if mode == 32 && modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		source, consumed, err = memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, "X", laneBytes)
+	} else {
+		if modRM>>6 != 3 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX opcode %#x requires a general-register source", opcode)
+		}
+		if xExt != 0 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX.X cannot extend a general register")
+		}
+		if mode == 32 && opcode == 0x7c && width64 {
+			// GP-only opcode 7C ignores EVEX.W in non-64-bit mode.
+			// Retain the original Q/W1 identity, but decode its physical
+			// r32 input; the shared broadcast grammar uses dword lanes.
+			laneBytes = 4
+		}
+		source, consumed, err = decodedX86RMSource(code[modRMIndex:], mode, bExt, 0, segment, laneBytes)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	args := []Operand{source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86PackedAlignRightInstruction recognizes every raw PALIGNR and
+// VPALIGNR encoding represented by Go 1.27's ypalignr and
+// _yvgf2p8affineinvqb tables: legacy X, VEX X/Y, and EVEX X/Y/Z with optional
+// merge/zero masks. x/arch v0.14 rejects the VEX bytes used by the historical
+// sha256-simd copy in github.com/ipfs/fs-repo-migrations.
+func decodedX86PackedAlignRightInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedAlignRightInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedAlignRightInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	hasDataSizePrefix := false
+	rex := byte(0)
+	hasREX := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			rex = 0
+			hasREX = false
+			segment = FS
+			i++
+		case 0x65:
+			rex = 0
+			hasREX = false
+			segment = GS
+			i++
+		case 0x66:
+			rex = 0
+			hasREX = false
+			hasDataSizePrefix = true
+			i++
+		case 0x67:
+			rex = 0
+			hasREX = false
+			addressOverride = true
+			i++
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				hasREX = true
+				i++
+				continue
+			}
+			goto opcode
+		}
+	}
+
+opcode:
+	if i >= len(code) {
+		return Instr{}, 0, false, nil
+	}
+	if code[i] == 0xc4 {
+		if hasDataSizePrefix || hasREX || len(code) < i+5 || code[i+1]&0x1f != 3 || code[i+3] != 0x0f {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if mode == 32 {
+			return Instr{}, 0, true, fmt.Errorf("386 VPALIGNR exceeds the Go assembler frontend's operand limit")
+		}
+		vex0, vexBits := code[i+1], code[i+2]
+		if vexBits&3 != 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+		}
+		if vexBits&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		rExt := int(^vex0>>7) & 1
+		xExt := int(^vex0>>6) & 1
+		bExt := int(^vex0>>5) & 1
+		modRMIndex := i + 4
+		modRM := code[modRMIndex]
+		firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		immediateIndex := modRMIndex + consumed
+		if len(code) <= immediateIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		secondSourceNumber := int(^vexBits>>3) & 15
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		args := []Operand{
+			{Kind: OpImm, Imm: int64(code[immediateIndex])},
+			firstSource,
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))},
+		}
+		rawArgs := make([]string, len(args))
+		for index := range args {
+			rawArgs[index] = args[index].String()
+		}
+		return Instr{Op: "VPALIGNR", Args: args, Raw: "VPALIGNR " + strings.Join(rawArgs, ", ")}, immediateIndex + 1, true, nil
+	}
+	if code[i] == 0x62 {
+		if hasDataSizePrefix || hasREX || len(code) < i+6 || code[i+1]&0x0f != 3 || code[i+2]&0x07 != 5 || code[i+4] != 0x0f {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if mode == 32 {
+			return Instr{}, 0, true, fmt.Errorf("386 VPALIGNR exceeds the Go assembler frontend's operand limit")
+		}
+		p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+		if p1&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX.W must be zero")
+		}
+		vectorBits := p2 >> 5 & 3
+		if vectorBits == 3 {
+			return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+		}
+		if p2&0x10 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is absent from Go 1.27's VPALIGNR table")
+		}
+		vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+		vectorWidth := [...]int{16, 32, 64}[vectorBits]
+		maskNumber := int(p2 & 7)
+		zeroing := p2&0x80 != 0
+		if zeroing && maskNumber == 0 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+		}
+		rExt := int(^p0>>7) & 1
+		rHighExt := int(^p0>>4) & 1
+		xExt := int(^p0>>6) & 1
+		bExt := int(^p0>>5) & 1
+		modRMIndex := i + 5
+		modRM := code[modRMIndex]
+		firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, vectorWidth)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		immediateIndex := modRMIndex + consumed
+		if len(code) <= immediateIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+		destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+		op := Op("VPALIGNR")
+		args := []Operand{
+			{Kind: OpImm, Imm: int64(code[immediateIndex])},
+			firstSource,
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))},
+		}
+		if maskNumber != 0 {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+		}
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))})
+		if zeroing {
+			op += ".Z"
+		}
+		rawArgs := make([]string, len(args))
+		for index := range args {
+			rawArgs[index] = args[index].String()
+		}
+		return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+	}
+
+	if !hasDataSizePrefix || len(code) < i+5 || code[i] != 0x0f || code[i+1] != 0x3a || code[i+2] != 0x0f {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if hasREX && rex&0x08 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("REX.W is absent from Go 1.27's PALIGNR encoding")
+	}
+	rExt := int(rex>>2) & 1
+	xExt := int(rex>>1) & 1
+	bExt := int(rex & 1)
+	modRMIndex := i + 3
+	modRM := code[modRMIndex]
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (destinationNumber >= 8 || bExt != 0 || xExt != 0) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	instruction = Instr{
+		Op:   "PALIGNR",
+		Args: []Operand{immediate, source, destination},
+		Raw:  fmt.Sprintf("PALIGNR %s, %s, %s", immediate.String(), source.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+// decodedX86Permute128Instruction recognizes every raw VPERM2F128 and
+// VPERM2I128 encoding represented by Go 1.27's _yvperm2f128 table: an
+// immediate, Y/m256 first source, Y second source, and Y destination.
+func decodedX86Permute128Instruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86Permute128InstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86Permute128InstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	hasLegacyPrefix := false
+	hasREX := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			hasREX = false
+			segment = FS
+			i++
+		case 0x65:
+			hasREX = false
+			segment = GS
+			i++
+		case 0x66:
+			hasREX = false
+			hasLegacyPrefix = true
+			i++
+		case 0x67:
+			hasREX = false
+			addressOverride = true
+			i++
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				hasREX = true
+				i++
+				continue
+			}
+			goto opcode
+		}
+	}
+
+opcode:
+	if i >= len(code) || code[i] != 0xc4 || hasLegacyPrefix || hasREX || len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	vex0, vexBits, opcode := code[i+1], code[i+2], code[i+3]
+	if vex0&0x1f != 3 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	for name, encoding := range x86Permute128Specs {
+		if encoding == opcode {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if vexBits&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.L must select 256-bit vectors")
+	}
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "Y")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in physical mode32 permute128")
+	}
+	if immediateIndex+1 > 15 {
+		return Instr{}, 0, true, fmt.Errorf("permute128 instruction exceeds 15 bytes")
+	}
+	args := []Operand{
+		{Kind: OpImm, Imm: int64(code[immediateIndex])},
+		firstSource,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", secondSourceNumber))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", destinationNumber))},
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: true, x86VectorBytes: 32, x86Permute128VEX: true}, immediateIndex + 1, true, nil
+}
+
+// decodedX86InsertPSInstruction recognizes all encodings represented by Go
+// 1.27's yxshuf and _yvinsertps tables: legacy INSERTPS plus VEX and EVEX
+// VINSERTPS, each with an X-register or ModRM/SIB memory source. x/arch v0.14
+// can consume one byte past VINSERTPS and desynchronize the rest of a raw
+// directive group, as observed in github.com/racerxdl/segdsp.
+func decodedX86InsertPSInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+
+	if code[i] == 0x66 {
+		j := i + 1
+		rex := byte(0)
+		if j < len(code) && code[j]&0xf0 == 0x40 {
+			rex = code[j]
+			j++
+		}
+		if len(code) < j+4 || code[j] != 0x0f || code[j+1] != 0x3a || code[j+2] != 0x21 {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if mode == 32 && rex != 0 {
+			return Instr{}, 0, true, fmt.Errorf("REX prefix in 32-bit mode")
+		}
+		modRMIndex := j + 3
+		modRM := code[modRMIndex]
+		rExt := int(rex>>2) & 1
+		xExt := int(rex>>1) & 1
+		bExt := int(rex) & 1
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+		}
+		source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		immediateIndex := modRMIndex + consumed
+		if len(code) <= immediateIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+		return Instr{
+			Op:   "INSERTPS",
+			Args: []Operand{immediate, source, destination},
+			Raw:  fmt.Sprintf("INSERTPS %s, %s, %s", immediate.String(), source.String(), destination.String()),
+		}, immediateIndex + 1, true, nil
+	}
+
+	if code[i] == 0xc4 {
+		if len(code) < i+5 || code[i+1]&0x1f != 3 || code[i+3] != 0x21 {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		p0, p1 := code[i+1], code[i+2]
+		// The physical VEX form is WIG, independently of Go's W0 encoder.
+		if p1&0x07 != 0x01 {
+			return Instr{}, 0, true, fmt.Errorf("VINSERTPS requires VEX.L0.66")
+		}
+		modRMIndex := i + 4
+		modRM := code[modRMIndex]
+		rExt := int(^p0>>7) & 1
+		xExt := int(^p0>>6) & 1
+		bExt := int(^p0>>5) & 1
+		baseNumber := int(^p1>>3) & 15
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (baseNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended VINSERTPS register in 32-bit mode")
+		}
+		source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		immediateIndex := modRMIndex + consumed
+		if len(code) <= immediateIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+		base := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", baseNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+		return Instr{
+			Op:         "VINSERTPS",
+			Args:       []Operand{immediate, source, base, destination},
+			Raw:        fmt.Sprintf("VINSERTPS %s, %s, %s, %s", immediate.String(), source.String(), base.String(), destination.String()),
+			x86Encoded: true,
+		}, immediateIndex + 1, true, nil
+	}
+
+	if code[i] != 0x62 || len(code) < i+6 || code[i+1]&0x0f != 3 || code[i+4] != 0x21 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if mode == 32 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX VINSERTPS is unavailable in 32-bit mode")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p1&0x87 != 0x05 || p2&0xf7 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VINSERTPS requires EVEX.W0.L0.66 without mask, zeroing, or broadcast")
+	}
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	baseNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	source, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X", 4)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	base := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", baseNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	return Instr{
+		Op:   "VINSERTPS",
+		Args: []Operand{immediate, source, base, destination},
+		Raw:  fmt.Sprintf("VINSERTPS %s, %s, %s, %s", immediate.String(), source.String(), base.String(), destination.String()),
+	}, immediateIndex + 1, true, nil
+}
+
+// decodedX86PackedScalarExtractInstruction recognizes every VEX and EVEX
+// encoding row shared by Go 1.27's _yvextractps and _yvpextrw tables:
+// VEXTRACTPS and VPEXTRB/W/D/Q with GP-register or ModRM/SIB memory
+// destinations. x/arch v0.14 does not decode VEXTRACTPS and can interpret
+// bytes after other scalar extracts as instructions or PC-relative operands,
+// so recover the complete family before consulting the generic decoder.
+func decodedX86PackedScalarExtractInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedScalarExtractInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedScalarExtractInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+	var (
+		mapNumber       byte
+		opcode          byte
+		width64         bool
+		rExt            int
+		rHighExt        int
+		xExt            int
+		bExt            int
+		modRMIndex      int
+		disp8Scale      = 1
+		evex            bool
+		twoByteVEX      bool
+		prefixValidated bool
+	)
+	switch code[i] {
+	case 0xc4:
+		if len(code) < i+4 {
+			return Instr{}, 0, false, nil
+		}
+		mapNumber = code[i+1] & 0x1f
+		opcode = code[i+3]
+		width64 = code[i+2]&0x80 != 0
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		modRMIndex = i + 4
+		prefixValidated = code[i+2]&0x7f == 0x79
+	case 0xc5:
+		if len(code) < i+3 {
+			return Instr{}, 0, false, nil
+		}
+		mapNumber = 1
+		opcode = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		modRMIndex = i + 3
+		twoByteVEX = true
+		prefixValidated = code[i+1]&0x7f == 0x79
+	case 0x62:
+		if len(code) < i+5 {
+			return Instr{}, 0, false, nil
+		}
+		evex = true
+		mapNumber = code[i+1] & 0x0f
+		opcode = code[i+4]
+		width64 = code[i+2]&0x80 != 0
+		rExt = int(^code[i+1]>>7) & 1
+		rHighExt = int(^code[i+1]>>4) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		modRMIndex = i + 5
+		prefixValidated = code[i+2]&0x7f == 0x7d && code[i+3] == 0x08
+	default:
+		return Instr{}, 0, false, nil
+	}
+
+	var op Op
+	laneBytes := 0
+	expectedWidth64 := false
+	switch {
+	case mapNumber == 3 && opcode == 0x14:
+		op, laneBytes = "VPEXTRB", 1
+	case mapNumber == 3 && opcode == 0x15:
+		op, laneBytes = "VPEXTRW", 2
+	case mapNumber == 3 && opcode == 0x16 && !width64:
+		op, laneBytes = "VPEXTRD", 4
+	case mapNumber == 3 && opcode == 0x16 && width64:
+		op, laneBytes, expectedWidth64 = "VPEXTRQ", 8, true
+	case mapNumber == 3 && opcode == 0x17:
+		op, laneBytes = "VEXTRACTPS", 4
+	case mapNumber == 1 && opcode == 0xc5:
+		op, laneBytes = "VPEXTRW", 2
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if !prefixValidated {
+		return Instr{}, 0, true, fmt.Errorf("reserved vvvv, vector length, prefix, or EVEX mask bits are invalid")
+	}
+	if width64 != expectedWidth64 {
+		return Instr{}, 0, true, fmt.Errorf("invalid W bit for %s", op)
+	}
+	if evex {
+		if mode == 32 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX packed scalar extracts are unavailable in 32-bit mode")
+		}
+		disp8Scale = laneBytes
+	}
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	sourceNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && sourceNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("extended source register in 32-bit mode")
+	}
+	destination, consumed, decodeErr := memory.scalar(code[modRMIndex:], mode, bExt, xExt, segment, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	if mapNumber == 1 && destination.Kind != OpReg {
+		return Instr{}, 0, true, fmt.Errorf("VEX map-1 VPEXTRW requires a GP-register destination")
+	}
+	if evex && destination.Kind == OpReg && xExt != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed scalar extract destination is outside the GP-register class")
+	}
+	if twoByteVEX && destination.Kind == OpReg && bExt != 0 {
+		return Instr{}, 0, true, fmt.Errorf("two-byte VEX cannot encode an extended destination register")
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", sourceNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, immediate.String(), source.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+// decodedX86VPERMQInstruction recognizes the complete VEX.256 immediate
+// VPERMQ Y/m256, Y family. x/arch v0.14 can misclassify its trailing immediate
+// as a PC-relative operand, so recover register and ModRM/SIB memory forms
+// before consulting the generic decoder. EVEX forms are decoded correctly by
+// x/arch and continue through the ordinary path.
+func decodedX86VPERMQInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 3 || code[i+3] != 0x00 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	if code[i+2] != 0xfd {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be one, VEX.vvvv must be 1111, VEX.L must be one, and VEX.pp must be 66")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	vex1 := code[i+1]
+	rExt := int(^vex1>>7) & 1
+	xExt := int(^vex1>>6) & 1
+	bExt := int(^vex1>>5) & 1
+	modRMIndex := i + 4
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	source, consumed, err := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "Y")
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", destinationNumber))}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	instruction = Instr{
+		Op:   "VPERMQ",
+		Args: []Operand{immediate, source, destination},
+		Raw:  fmt.Sprintf("VPERMQ %s, %s, %s", immediate.String(), source.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+// decodedX86ScalarPrecisionConvertInstruction recognizes the complete
+// CVTSS2SD/CVTSD2SS and VCVTSS2SD/VCVTSD2SS family represented by Go 1.27's
+// legacy yxm and EVEX-aware _yvaddsd tables. Besides VEX and legacy forms it
+// handles EVEX high X registers, memory, masks, zeroing, SAE, and all four
+// embedded rounding modes. x/arch v0.14 can split VCVTSD2SS into POP/ROLL.
+func decodedX86ScalarPrecisionConvertInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+
+	// Legacy F2/F3 0F 5A /r forms overwrite their X destination.
+	j := i
+	if code[j] == 0xf2 || code[j] == 0xf3 {
+		prefix := code[j]
+		j++
+		rex := byte(0)
+		if j < len(code) && code[j]&0xf0 == 0x40 {
+			rex = code[j]
+			j++
+		}
+		if len(code) >= j+3 && code[j] == 0x0f && code[j+1] == 0x5a {
+			ok = true
+			if addressOverride {
+				return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+			}
+			if mode == 32 && rex != 0 {
+				return Instr{}, 0, true, fmt.Errorf("REX prefix in 32-bit mode")
+			}
+			op := Op("CVTSD2SS")
+			if prefix == 0xf3 {
+				op = "CVTSS2SD"
+			}
+			modRMIndex := j + 2
+			modRM := code[modRMIndex]
+			rExt := int(rex>>2) & 1
+			xExt := int(rex>>1) & 1
+			bExt := int(rex) & 1
+			destinationNumber := int(modRM>>3&7) + rExt*8
+			if mode == 32 && destinationNumber >= 8 {
+				return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+			}
+			source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+			if decodeErr != nil {
+				return Instr{}, 0, true, decodeErr
+			}
+			destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+			return Instr{
+				Op: op, Args: []Operand{source, destination}, x86Encoded: true,
+				Raw: fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+			}, modRMIndex + consumed, true, nil
+		}
+	}
+
+	if code[i] == 0xc4 || code[i] == 0xc5 {
+		var vexLength, rExt, xExt, bExt int
+		var vexBits, opcode byte
+		switch code[i] {
+		case 0xc5:
+			if len(code) < i+4 {
+				return Instr{}, 0, false, nil
+			}
+			vexLength = 2
+			vexBits = code[i+1]
+			rExt = int(^vexBits>>7) & 1
+			opcode = code[i+2]
+		case 0xc4:
+			if len(code) < i+5 || code[i+1]&0x1f != 1 {
+				return Instr{}, 0, false, nil
+			}
+			vexLength = 3
+			vexBits = code[i+2]
+			rExt = int(^code[i+1]>>7) & 1
+			xExt = int(^code[i+1]>>6) & 1
+			bExt = int(^code[i+1]>>5) & 1
+			opcode = code[i+3]
+		}
+		if opcode != 0x5a || (vexBits&3 != 2 && vexBits&3 != 3) {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if vexLength == 3 && vexBits&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+		}
+		if vexBits&0x04 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("scalar precision conversion requires VEX.128")
+		}
+		op := Op("VCVTSD2SS")
+		if vexBits&3 == 2 {
+			op = "VCVTSS2SD"
+		}
+		opcodeIndex := i + vexLength
+		modRMIndex := opcodeIndex + 1
+		modRM := code[modRMIndex]
+		first, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		secondNumber := int(^vexBits>>3) & 15
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended VEX register in 32-bit mode")
+		}
+		second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", secondNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+		return Instr{
+			Op: op, Args: []Operand{first, second, destination}, x86Encoded: true,
+			Raw: fmt.Sprintf("%s %s, %s, %s", op, first.String(), second.String(), destination.String()),
+		}, modRMIndex + consumed, true, nil
+	}
+
+	if len(code) < i+6 || code[i] != 0x62 || code[i+1]&0x0f != 1 || code[i+4] != 0x5a {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	prefix := p1 & 3
+	wBit := p1&0x80 != 0
+	op := Op("")
+	inputBytes := 0
+	supportsRounding := false
+	switch prefix {
+	case 3:
+		op = "VCVTSD2SS"
+		inputBytes = 8
+		supportsRounding = true
+		if !wBit {
+			return Instr{}, 0, true, fmt.Errorf("VCVTSD2SS requires EVEX.W1")
+		}
+	case 2:
+		op = "VCVTSS2SD"
+		inputBytes = 4
+		if wBit {
+			return Instr{}, 0, true, fmt.Errorf("VCVTSS2SD requires EVEX.W0")
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit must be one")
+	}
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	embeddedControl := p2&0x10 != 0
+	vectorBits := p2 >> 5 & 3
+	if !embeddedControl && vectorBits != 0 {
+		return Instr{}, 0, true, fmt.Errorf("scalar precision conversion requires EVEX.128")
+	}
+	if embeddedControl && modRM>>6 != 3 {
+		return Instr{}, 0, true, fmt.Errorf("embedded rounding/SAE requires a register source")
+	}
+	if embeddedControl {
+		if supportsRounding {
+			op += Op("." + [...]string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}[vectorBits])
+		} else if vectorBits == 0 {
+			op += ".SAE"
+		} else {
+			return Instr{}, 0, true, fmt.Errorf("VCVTSS2SD supports SAE but not explicit rounding")
+		}
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 scalar precision conversion mask forms exceed the Go assembler frontend's operand limit")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	first, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X", inputBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	args := []Operand{first, second}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{
+		Op: op, Args: args, x86Encoded: true, x86ScalarPrecisionEVEX: true,
+		Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+	}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86DuplicateMoveInstruction recognizes every Go 1.27 yxm and
+// _yvmovddup encoding for MOVDDUP/MOVSHDUP/MOVSLDUP and their V-prefixed
+// forms. This includes legacy X, VEX X/Y, and EVEX X/Y/Z register or memory
+// sources with optional merge/zero masks and compressed displacements.
+// x/arch v0.14 rejects the VMOVSHDUP bytes generated by segdsp.
+func decodedX86DuplicateMoveInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+
+	// Legacy duplicate moves use F2/F3 0F opcode /r and the ModRM.reg X
+	// register as the destination.
+	j := i
+	if code[j] == 0xf2 || code[j] == 0xf3 {
+		prefix := code[j]
+		j++
+		rex := byte(0)
+		if j < len(code) && code[j]&0xf0 == 0x40 {
+			rex = code[j]
+			j++
+		}
+		if len(code) >= j+3 && code[j] == 0x0f {
+			op := Op("")
+			switch {
+			case prefix == 0xf2 && code[j+1] == 0x12:
+				op = "MOVDDUP"
+			case prefix == 0xf3 && code[j+1] == 0x12:
+				op = "MOVSLDUP"
+			case prefix == 0xf3 && code[j+1] == 0x16:
+				op = "MOVSHDUP"
+			}
+			if op != "" {
+				ok = true
+				if addressOverride {
+					return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+				}
+				if mode == 32 && rex != 0 {
+					return Instr{}, 0, true, fmt.Errorf("REX prefix in 32-bit mode")
+				}
+				modRMIndex := j + 2
+				modRM := code[modRMIndex]
+				rExt := int(rex>>2) & 1
+				xExt := int(rex>>1) & 1
+				bExt := int(rex) & 1
+				destinationNumber := int(modRM>>3&7) + rExt*8
+				if mode == 32 && destinationNumber >= 8 {
+					return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+				}
+				source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+				if decodeErr != nil {
+					return Instr{}, 0, true, decodeErr
+				}
+				destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+				return Instr{Op: op, Args: []Operand{source, destination}, Raw: fmt.Sprintf("%s %s, %s", op, source.String(), destination.String())}, modRMIndex + consumed, true, nil
+			}
+		}
+	}
+
+	if code[i] == 0xc4 || code[i] == 0xc5 {
+		var vexLength, rExt, xExt, bExt int
+		var vexBits, opcode byte
+		switch code[i] {
+		case 0xc5:
+			if len(code) < i+4 {
+				return Instr{}, 0, false, nil
+			}
+			vexLength = 2
+			vexBits = code[i+1]
+			rExt = int(^vexBits>>7) & 1
+			opcode = code[i+2]
+		case 0xc4:
+			if len(code) < i+5 || code[i+1]&0x1f != 1 {
+				return Instr{}, 0, false, nil
+			}
+			vexLength = 3
+			vexBits = code[i+2]
+			rExt = int(^code[i+1]>>7) & 1
+			xExt = int(^code[i+1]>>6) & 1
+			bExt = int(^code[i+1]>>5) & 1
+			opcode = code[i+3]
+		}
+		prefix := vexBits & 3
+		op := Op("")
+		switch {
+		case prefix == 3 && opcode == 0x12:
+			op = "VMOVDDUP"
+		case prefix == 2 && opcode == 0x12:
+			op = "VMOVSLDUP"
+		case prefix == 2 && opcode == 0x16:
+			op = "VMOVSHDUP"
+		}
+		if op == "" {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		// All three VEX duplicate-move opcodes are WIG. Unlike the EVEX
+		// encodings below, either W value denotes the same operation.
+		if vexBits&0x78 != 0x78 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be reserved")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		opcodeIndex := i + vexLength
+		modRMIndex := opcodeIndex + 1
+		modRM := code[modRMIndex]
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended VEX register in 32-bit mode")
+		}
+		source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		return Instr{Op: op, Args: []Operand{source, destination}, Raw: fmt.Sprintf("%s %s, %s", op, source.String(), destination.String())}, modRMIndex + consumed, true, nil
+	}
+
+	if len(code) < i+6 || code[i] != 0x62 || code[i+1]&0x0f != 1 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2, opcode := code[i+1], code[i+2], code[i+3], code[i+4]
+	prefix := p1 & 3
+	op := Op("")
+	elementBytes := 4
+	switch {
+	case prefix == 3 && opcode == 0x12:
+		op = "VMOVDDUP"
+		elementBytes = 8
+	case prefix == 2 && opcode == 0x12:
+		op = "VMOVSLDUP"
+	case prefix == 2 && opcode == 0x16:
+		op = "VMOVSHDUP"
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit must be one")
+	}
+	double := op == "VMOVDDUP"
+	if double != (p1&0x80 != 0) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match duplicate-move element width")
+	}
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvvv must be reserved")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is absent from Go 1.27's duplicate-move table")
+	}
+	vectorBits := p2 >> 5 & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	disp8Scale := vectorWidth
+	if double && vectorBits == 0 {
+		disp8Scale = elementBytes
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	sourceNumber := int(modRM&7) + bExt*8 + xExt*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && vectorName == "Z" {
+		if modRM>>6 == 3 && sourceNumber >= 8 || destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("high Z register is unavailable in 32-bit mode")
+		}
+	}
+	source, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86InLaneFloatingPermuteInstruction recognizes every encoding in Go
+// 1.27's shared _yvpermilpd table: VPERMILPS/VPERMILPD immediate and
+// variable-control VEX X/Y forms plus EVEX X/Y/Z, memory, scalar broadcast,
+// merge-mask, and zero-mask forms. x/arch v0.14 can split a VEX immediate form
+// into a fake PC-relative branch inside generated segdsp byte streams.
+func decodedX86InLaneFloatingPermuteInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+	if code[i] == 0xc4 {
+		if len(code) < i+5 {
+			return Instr{}, 0, false, nil
+		}
+		vex0, vexBits, opcode := code[i+1], code[i+2], code[i+3]
+		mapNumber := vex0 & 0x1f
+		immediate := mapNumber == 3 && (opcode == 0x04 || opcode == 0x05)
+		variable := mapNumber == 2 && (opcode == 0x0c || opcode == 0x0d)
+		if !immediate && !variable {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if vexBits&3 != 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+		}
+		if vexBits&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+		}
+		if immediate && vexBits&0x78 != 0x78 {
+			return Instr{}, 0, true, fmt.Errorf("immediate VPERMIL requires reserved VEX.vvvv")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		rExt := int(^vex0>>7) & 1
+		xExt := int(^vex0>>6) & 1
+		bExt := int(^vex0>>5) & 1
+		modRMIndex := i + 4
+		modRM := code[modRMIndex]
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		secondNumber := int(^vexBits>>3) & 15
+		if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8 || variable && secondNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended VEX register in 32-bit mode")
+		}
+		first, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		double := opcode&1 != 0
+		op := Op("VPERMILPS")
+		if double {
+			op = "VPERMILPD"
+		}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		args := make([]Operand, 0, 3)
+		end := modRMIndex + consumed
+		if immediate {
+			if len(code) <= end {
+				return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+			}
+			args = append(args, Operand{Kind: OpImm, Imm: int64(code[end])}, first, destination)
+			end++
+		} else {
+			second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+			args = append(args, first, second, destination)
+		}
+		rawArgs := make([]string, len(args))
+		for index := range args {
+			rawArgs[index] = args[index].String()
+		}
+		return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, end, true, nil
+	}
+
+	if len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2, opcode := code[i+1], code[i+2], code[i+3], code[i+4]
+	mapNumber := p0 & 0x0f
+	immediate := mapNumber == 3 && (opcode == 0x04 || opcode == 0x05)
+	variable := mapNumber == 2 && (opcode == 0x0c || opcode == 0x0d)
+	if !immediate && !variable {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p1&0x07 != 5 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit and pp must select 66")
+	}
+	double := opcode&1 != 0
+	if double != (p1&0x80 != 0) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match VPERMILPS/PD")
+	}
+	if immediate && (p1&0x78 != 0x78 || p2&0x08 == 0) {
+		return Instr{}, 0, true, fmt.Errorf("immediate VPERMIL requires reserved EVEX.vvvvv")
+	}
+	vectorBits := p2 >> 5 & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	laneBytes := 4
+	op := Op("VPERMILPS")
+	if double {
+		laneBytes = 8
+		op = "VPERMILPD"
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 VPERMIL mask forms exceed the Go assembler frontend's operand limit")
+	}
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+		op += ".BCST"
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	firstNumber := int(modRM&7) + bExt*8 + xExt*16
+	secondNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && vectorName == "Z" {
+		if modRM>>6 == 3 && firstNumber >= 8 || variable && secondNumber >= 8 || destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("high Z register is unavailable in 32-bit mode")
+		}
+	}
+	first, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := make([]Operand, 0, 4)
+	end := modRMIndex + consumed
+	if immediate {
+		if len(code) <= end {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		args = append(args, Operand{Kind: OpImm, Imm: int64(code[end])}, first)
+		end++
+	} else {
+		second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+		args = append(args, first, second)
+	}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, end, true, nil
+}
+
+// decodedX86ImmediatePackedBlendInstruction recognizes the complete Go 1.27
+// immediate packed-blend family: legacy PBLENDW/BLENDPS/BLENDPD X forms and
+// VEX VPBLENDW/VPBLENDD/VBLENDPS/VBLENDPD X/Y forms. Every register and
+// ModRM/SIB memory source is handled before x/arch's generic decoder, which
+// can split VBLENDPD into unrelated scalar instructions in generated code.
+func decodedX86ImmediatePackedBlendInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86ImmediatePackedBlendInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86ImmediatePackedBlendInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+
+	// Legacy 66 0F 3A /r ib encodings use the ModRM.reg X register as both
+	// their second source and destination.
+	j := i
+	if code[j] == 0x66 {
+		j++
+		rex := byte(0)
+		if j < len(code) && code[j]&0xf0 == 0x40 {
+			rex = code[j]
+			j++
+		}
+		if len(code) >= j+4 && code[j] == 0x0f && code[j+1] == 0x3a {
+			op, recognized := map[byte]Op{0x0c: "BLENDPS", 0x0d: "BLENDPD", 0x0e: "PBLENDW"}[code[j+2]]
+			if recognized {
+				ok = true
+				if addressOverride {
+					return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+				}
+				if mode == 32 && rex != 0 {
+					return Instr{}, 0, true, fmt.Errorf("REX prefix in 32-bit mode")
+				}
+				modRMIndex := j + 3
+				modRM := code[modRMIndex]
+				rExt := int(rex>>2) & 1
+				xExt := int(rex>>1) & 1
+				bExt := int(rex) & 1
+				destinationNumber := int(modRM>>3&7) + rExt*8
+				if mode == 32 && destinationNumber >= 8 {
+					return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+				}
+				source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+				if decodeErr != nil {
+					return Instr{}, 0, true, decodeErr
+				}
+				immediateIndex := modRMIndex + consumed
+				if len(code) <= immediateIndex {
+					return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+				}
+				immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+				destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+				return Instr{
+					Op:   op,
+					Args: []Operand{immediate, source, destination},
+					Raw:  fmt.Sprintf("%s %s, %s, %s", op, immediate.String(), source.String(), destination.String()),
+				}, immediateIndex + 1, true, nil
+			}
+		}
+	}
+
+	// All vector forms are VEX.128/256.66.0F3A. VPBLENDD is W0;
+	// VBLENDPS/PD and VPBLENDW are WIG. Go386's named arity limit does
+	// not invalidate these independently decoded low-bank physical forms.
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 3 {
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[byte]Op{
+		0x02: "VPBLENDD",
+		0x0c: "VBLENDPS",
+		0x0d: "VBLENDPD",
+		0x0e: "VPBLENDW",
+	}[code[i+3]]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vex0, vexBits := code[i+1], code[i+2]
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 && op == "VPBLENDD" {
+		return Instr{}, 0, true, fmt.Errorf("VPBLENDD VEX.W must be zero")
+	}
+	vectorName := "X"
+	if vexBits&0x04 != 0 {
+		vectorName = "Y"
+	}
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	if mode == 32 {
+		if rExt != 0 || xExt != 0 {
+			return Instr{}, 0, true, fmt.Errorf("legacy LES encoding is not a 32-bit VEX instruction")
+		}
+		bExt = 0 // The physical high B and vvvv bits are ignored outside 64-bit mode.
+	}
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	first, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondNumber := int(^vexBits>>3) & 15
+	if mode == 32 {
+		secondNumber &= 7
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	return Instr{
+		Op: op, Args: []Operand{immediate, first, second, destination}, x86Encoded: true,
+		Raw: fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), first.String(), second.String(), destination.String()),
+	}, immediateIndex + 1, true, nil
+}
+
+// decodedX86FloatingUnpackInstruction recognizes every legacy yxm and
+// VEX/EVEX _yvandnpd row used by UNPCKLPS/UNPCKHPS/UNPCKLPD/UNPCKHPD and
+// their V-prefixed forms. This includes X/Y/Z widths, register and ModRM/SIB
+// memory sources, EVEX broadcast, merge masks, zero masks, and compressed
+// displacements. x/arch v0.14 can overrun VUNPCK by one byte and desynchronize
+// a raw directive stream, as observed in github.com/racerxdl/segdsp.
+func decodedX86FloatingUnpackInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) <= i {
+		return Instr{}, 0, false, nil
+	}
+
+	legacyPrefix := byte(0)
+	j := i
+	if code[j] == 0x66 {
+		legacyPrefix = 1
+		j++
+	}
+	rex := byte(0)
+	if j < len(code) && code[j]&0xf0 == 0x40 {
+		rex = code[j]
+		j++
+	}
+	if len(code) >= j+3 && code[j] == 0x0f && (code[j+1] == 0x14 || code[j+1] == 0x15) {
+		opcode := code[j+1]
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if mode == 32 && rex != 0 {
+			return Instr{}, 0, true, fmt.Errorf("REX prefix in 32-bit mode")
+		}
+		stem := "UNPCKL"
+		if opcode == 0x15 {
+			stem = "UNPCKH"
+		}
+		op := Op(stem + map[byte]string{0: "PS", 1: "PD"}[legacyPrefix])
+		modRMIndex := j + 2
+		modRM := code[modRMIndex]
+		rExt := int(rex>>2) & 1
+		xExt := int(rex>>1) & 1
+		bExt := int(rex) & 1
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+		}
+		source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+		return Instr{
+			Op:   op,
+			Args: []Operand{source, destination},
+			Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+		}, modRMIndex + consumed, true, nil
+	}
+
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	}
+	if vexLength != 0 && (opcode == 0x14 || opcode == 0x15) {
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if vexBits&3 > 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp does not select PS or PD floating unpack")
+		}
+		if vexLength == 3 && vexBits&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("floating unpack requires VEX.W0")
+		}
+		stem := "VUNPCKL"
+		if opcode == 0x15 {
+			stem = "VUNPCKH"
+		}
+		op := Op(stem + map[byte]string{0: "PS", 1: "PD"}[vexBits&3])
+		opcodeIndex := i + vexLength
+		modRMIndex := opcodeIndex + 1
+		if len(code) <= modRMIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		secondNumber := int(^vexBits>>3) & 15
+		destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+		if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended VEX register in 32-bit mode")
+		}
+		first, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		return Instr{
+			Op:   op,
+			Args: []Operand{first, second, destination},
+			Raw:  fmt.Sprintf("%s %s, %s, %s", op, first.String(), second.String(), destination.String()),
+		}, modRMIndex + consumed, true, nil
+	}
+
+	if code[i] != 0x62 || len(code) < i+6 || code[i+1]&0x0f != 1 || (code[i+4] != 0x14 && code[i+4] != 0x15) {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit must be one")
+	}
+	if p1&3 > 1 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.pp does not select PS or PD floating unpack")
+	}
+	double := p1&3 == 1
+	if double != (p1&0x80 != 0) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W and pp disagree for floating unpack")
+	}
+	vectorBits := p2 >> 5 & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorBytes := [...]int{16, 32, 64}[vectorBits]
+	laneBytes := 4
+	suffix := "PS"
+	if double {
+		laneBytes = 8
+		suffix = "PD"
+	}
+	stem := "VUNPCKL"
+	if code[i+4] == 0x15 {
+		stem = "VUNPCKH"
+	}
+	op := Op(stem + suffix)
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX masking is unavailable for 386 floating unpack forms")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorBytes
+	if broadcast {
+		disp8Scale = laneBytes
+		op += ".BCST"
+	}
+	evexRExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	evexXExt := int(^p0>>6) & 1
+	evexBExt := int(^p0>>5) & 1
+	firstNumber := int(modRM&7) + evexBExt*8 + evexXExt*16
+	secondNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + evexRExt*8 + rHighExt*16
+	if mode == 32 {
+		if modRM>>6 == 3 && firstNumber >= 8 || secondNumber >= 8 || destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("%w: EVEX floating unpack high register has no proved physical mode32 binding", ErrProbeNeedsContext)
+		}
+	}
+	first, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, evexBExt, evexXExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{first, second}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86VEXPackedFloatLogicalInstruction recognizes the complete
+// VEX.128/VEX.256 VANDPS/PD, VANDNPS/PD, VORPS/PD, and VXORPS/PD family.
+// x/arch v0.14 can split or reject valid VEX encodings, including the raw
+// VXORPS emitted by Weaviate, so recover every register and ModRM/SIB memory
+// form before the generic decoder. VEX.W is ignored by these opcode rows.
+func decodedX86VEXPackedFloatLogicalInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXPackedFloatLogicalInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXPackedFloatLogicalInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	stem, recognized := map[byte]string{
+		0x54: "VAND",
+		0x55: "VANDN",
+		0x56: "VOR",
+		0x57: "VXOR",
+	}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	suffix := ""
+	switch vexBits & 3 {
+	case 0:
+		suffix = "PS"
+	case 1:
+		suffix = "PD"
+	default:
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp does not select a packed floating logical instruction")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, err := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	op := Op(stem + suffix)
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+// K is a data register here, not an optional writemask. Recognizing these
+// physical register shapes grants no initialized-mask or memory authority.
+func decodedX86EVEXMaskDataBroadcastInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 2 || p.opcode != 0x2a && p.opcode != 0x3a {
+		return Instr{}, 0, false, nil
+	}
+	op := Op("VPBROADCASTMW2D")
+	if p.opcode == 0x2a {
+		op = "VPBROADCASTMB2Q"
+	}
+	fail := func(reason string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("%s %s", op, reason)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("has an unsupported x86 mode")
+	}
+	if p.w != (p.opcode == 0x2a) {
+		return fail("has a reserved EVEX.W value")
+	}
+	if !p.fixed || p.upper != 0 {
+		return fail("requires reserved EVEX.vvvv and the fixed prefix bit")
+	}
+	if p.segment != "" || p.addressOverride {
+		return fail("does not admit segment or address-size overrides")
+	}
+	if p.mask != 0 || p.zero || p.broadcast {
+		return fail("does not admit writemasking, zeroing, or EVEX.b")
+	}
+	if p.vectorLength == 3 {
+		return fail("has a reserved EVEX vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("is missing its ModRM byte")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 != 3 || p.b != 0 || p.x != 0 {
+		return fail("requires an unextended K-register source")
+	}
+	destination := int(modRM>>3&7) + p.r*8
+	if mode == 32 && destination >= 8 {
+		return fail("has an extended vector register in 32-bit mode")
+	}
+	src := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", modRM&7))}
+	dst := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", [...]string{"X", "Y", "Z"}[p.vectorLength], destination))}
+	return Instr{Op: op, Args: []Operand{src, dst}, Raw: fmt.Sprintf("%s %s, %s", op, src.String(), dst.String())}, p.modRM + 1, true, nil
+}
+
+// decodedX86VEXPackedIntegerLogicalInstruction recognizes the complete
+// VEX.128/VEX.256 VPAND, VPANDN, VPOR, and VPXOR family described by Go
+// 1.27's shared _yvaddsubpd operand table. Recover both VEX.WIG values and
+// every register and ModRM/SIB memory form before the generic decoder, which
+// can split or reject raw encodings emitted by ecosystem assembly.
+func decodedX86VEXPackedIntegerLogicalInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXPackedIntegerLogicalInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXPackedIntegerLogicalInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[byte]Op{
+		0xdb: "VPAND",
+		0xdf: "VPANDN",
+		0xeb: "VPOR",
+		0xef: "VPXOR",
+	}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, err := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+// decodedX86EVEXPackedLogicalInstruction recognizes every EVEX register,
+// memory, broadcast, merge-mask, and zero-mask row shared by Go 1.27's
+// VPANDD/Q, VPANDND/Q, VPORD/Q, and VPXORD/Q _yvblendmpd table.
+func decodedX86EVEXPackedLogicalInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedLogicalInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedLogicalInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+5 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 1 || p1&3 != 1 {
+		return Instr{}, 0, false, nil
+	}
+	stem, recognized := map[byte]string{0xdb: "VPAND", 0xdf: "VPANDN", 0xeb: "VPOR", 0xef: "VPXOR"}[code[i+4]]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX fixed bit must be one")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := p2 >> 5 & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorBytes := [...]int{16, 32, 64}[vectorBits]
+	width := "D"
+	laneBytes := 4
+	if p1&0x80 != 0 {
+		width = "Q"
+		laneBytes = 8
+	}
+	op := Op(stem + width)
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX masking is unavailable for 386 packed logical forms")
+	}
+
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorBytes
+	if broadcast {
+		disp8Scale = laneBytes
+		op += ".BCST"
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	firstNumber := int(modRM&7) + bExt*8 + xExt*16
+	secondNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && vectorName == "Z" {
+		if modRM>>6 == 3 && firstNumber >= 8 || secondNumber >= 8 || destinationNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("high Z register is unavailable in 32-bit mode")
+		}
+	}
+	first, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{first, second}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86VEXPackedMADDInstruction recognizes the complete VEX.128 and
+// VEX.256 VPMADDWD and VPMADDUBSW family in Go 1.27's opcode tables.
+// VPMADDWD is available through both two- and three-byte VEX map-1 forms;
+// VPMADDUBSW uses the three-byte VEX map-2 form. VEX.W is ignored. Recover
+// every register and ModRM/SIB memory form before the generic decoder, which
+// can split raw VPMADDWD bytes emitted by ecosystem assembly.
+func decodedX86VEXPackedMADDInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXPackedMADDInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXPackedMADDInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, opcodeMap, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		opcodeMap = 1
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4:
+		vexLength = 3
+		opcodeMap = int(code[i+1] & 0x1f)
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[[2]int]Op{
+		{1, 0xf5}: "VPMADDWD",
+		{2, 0x04}: "VPMADDUBSW",
+	}[[2]int{opcodeMap, int(opcode)}]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	instruction = Instr{
+		Op:         op,
+		Args:       []Operand{firstSource, secondSource, destination},
+		Raw:        fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+		x86Encoded: true,
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+// decodedX86VEXBinaryFloatInstruction recognizes the complete VEX and EVEX
+// VADD, VMUL, VSUB, VMIN, VDIV, and VMAX family for PS/PD/SS/SD, plus
+// VSQRTSS/VSQRTSD, plus raw-only packed/scalar FP16 MAP5 binary forms. Packed SQRT
+// has a distinct single-source grammar and is decoded by
+// decodedX86SameWidthConversionInstruction. Scalar VEX forms require VEX.128;
+// packed VEX forms accept both vector widths. EVEX adds X/Y/Z widths, masking,
+// zeroing, packed broadcasts, rounding, and SAE.
+// Recover every register and ModRM/SIB memory form before the generic decoder.
+func decodedX86VEXBinaryFloatInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXBinaryFloatInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXBinaryFloatInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXBinaryFloatInstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	stem, recognized := map[byte]string{
+		0x51: "VSQRT",
+		0x58: "VADD",
+		0x59: "VMUL",
+		0x5c: "VSUB",
+		0x5d: "VMIN",
+		0x5e: "VDIV",
+		0x5f: "VMAX",
+	}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	pp := vexBits & 3
+	if opcode == 0x51 && pp < 2 {
+		return Instr{}, 0, false, nil
+	}
+	suffix := [...]string{"PS", "PD", "SS", "SD"}[pp]
+	scalar := pp >= 2
+	if scalar && vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("scalar binary floating instruction requires VEX.128")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	op := Op(stem + suffix)
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXBinaryFloatInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXBinaryFloatInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXBinaryFloatInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+6 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	stem, recognized := map[byte]string{
+		0x51: "VSQRT",
+		0x58: "VADD",
+		0x59: "VMUL",
+		0x5c: "VSUB",
+		0x5d: "VMIN",
+		0x5e: "VDIV",
+		0x5f: "VMAX",
+	}[opcode]
+	mapNumber := p0 & 0x0f
+	rawHalf := mapNumber == 5 && (p1&3 == 0 || p1&3 == 2)
+	rawHalfScalar := rawHalf && p1&3 == 2
+	rawSqrt := stem == "VSQRT" && !rawHalf
+	if !recognized || mapNumber != 1 && !rawHalf {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("invalid EVEX prefix")
+	}
+	pp := p1 & 3
+	if opcode == 0x51 && pp < 2 {
+		return Instr{}, 0, false, nil
+	}
+	width64 := p1&0x80 != 0
+	wantWidth64 := pp == 1 || pp == 3
+	if rawHalf {
+		wantWidth64 = false
+	}
+	if width64 != wantWidth64 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match floating element type")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	vectorBits := (p2 >> 5) & 3
+	scalar := pp >= 2
+	evexB := p2&0x10 != 0
+	registerSource := modRM>>6 == 3
+	embeddedControl := evexB && registerSource
+	broadcast := evexB && !registerSource
+	if broadcast && scalar {
+		return Instr{}, 0, true, fmt.Errorf("scalar binary floating instruction does not support broadcast")
+	}
+	if !embeddedControl && vectorBits == 3 && !rawHalfScalar && !rawSqrt {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+
+	vectorPrefix := "X"
+	vectorWidth := 16
+	switch {
+	case embeddedControl && !scalar:
+		vectorPrefix = "Z"
+		vectorWidth = 64
+	case !scalar:
+		vectorPrefix = [...]string{"X", "Y", "Z"}[vectorBits]
+		vectorWidth = [...]int{16, 32, 64}[vectorBits]
+	}
+	laneBytes := 4
+	if rawHalf {
+		laneBytes = 2
+	} else if pp == 1 || pp == 3 {
+		laneBytes = 8
+	}
+	disp8Scale := vectorWidth
+	if scalar || broadcast {
+		disp8Scale = laneBytes
+	}
+
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (!rawHalf && !rawSqrt && maskNumber != 0 || rExt != 0 || rHighExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register or mask in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+
+	suffix := [...]string{"PS", "PD", "SS", "SD"}[pp]
+	if rawHalf {
+		suffix = "PH"
+		if rawHalfScalar {
+			suffix = "SH"
+		}
+	}
+	op := Op(stem + suffix)
+	if broadcast {
+		op += ".BCST"
+	}
+	if embeddedControl {
+		if stem == "VMIN" || stem == "VMAX" {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[vectorBits]
+		}
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{
+		Op: op, Args: args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: rawHalf || rawSqrt, x86SqrtEVEX: rawSqrt,
+		x86FloatMinMaxEVEX: !rawHalf && (stem == "VMIN" || stem == "VMAX"),
+	}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86ScalarIntegerFloatInstruction recognizes Go 1.27's complete
+// signed and unsigned scalar integer-to-floating-point family. VEX supports
+// the four signed forms; EVEX additionally supports unsigned forms, ignored
+// scalar L'L encodings, and register-only embedded rounding where enabled.
+func decodedX86ScalarIntegerFloatInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXScalarIntegerFloatInstruction(code, i, mode, segment, addressOverride)
+	}
+	if len(code) < i+4 {
+		return Instr{}, 0, false, nil
+	}
+
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	switch {
+	case code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case code[i] == 0xc4 && len(code) >= i+5 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	opcodeIndex := i + vexLength
+	if len(code) <= opcodeIndex || code[opcodeIndex] != 0x2a {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	pp := vexBits & 3
+	if pp != 2 && pp != 3 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be F3 or F2")
+	}
+	if vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("scalar integer-to-float instruction requires VEX.128")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	passthroughNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || passthroughNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	source, consumed, decodeErr := decodedX86RMSource(code[modRMIndex:], mode, bExt, xExt, segment, 1)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	width64 := vexLength == 3 && vexBits&0x80 != 0
+	op := scalarIntegerFloatRawOperation(false, pp, width64)
+	passthrough := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", passthroughNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	args := []Operand{source, passthrough, destination}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s, %s, %s", op, source.String(), passthrough.String(), destination.String())}, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXScalarIntegerFloatInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+6 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 1 || opcode != 0x2a && opcode != 0x7b {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("invalid EVEX prefix")
+	}
+	pp := p1 & 3
+	if pp != 2 && pp != 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.pp must be F3 or F2")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x87 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("masking and zeroing are absent from the scalar integer-to-float table")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	vectorBits := (p2 >> 5) & 3
+	embeddedRounding := p2&0x10 != 0
+	if !embeddedRounding && vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	if embeddedRounding && modRM>>6 != 3 {
+		return Instr{}, 0, true, fmt.Errorf("embedded rounding requires a register source")
+	}
+	width64 := p1&0x80 != 0
+	roundingEnabled := pp == 2 || width64
+	if embeddedRounding && !roundingEnabled {
+		return Instr{}, 0, true, fmt.Errorf("explicit rounding is absent from VCVTSI2SDL/VCVTUSI2SDL")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	passthroughNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if modRM>>6 == 3 && xExt != 0 {
+		return Instr{}, 0, true, fmt.Errorf("general register source cannot use the EVEX high vector extension")
+	}
+	if mode == 32 && (rExt != 0 || rHighExt != 0 || xExt != 0 || bExt != 0 || passthroughNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	sourceBytes := 4
+	if width64 && mode == 64 {
+		// Signed and unsigned scalar conversions ignore W1 in mode32,
+		// including the independently observed m32 compressed tuple.
+		sourceBytes = 8
+	}
+	source, consumed, decodeErr := decodedX86RMSource(code[modRMIndex:], mode, bExt, xExt, segment, sourceBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	op := scalarIntegerFloatRawOperation(opcode == 0x7b, pp, width64)
+	if embeddedRounding {
+		op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[vectorBits]
+	}
+	passthrough := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", passthroughNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	args := []Operand{source, passthrough, destination}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s, %s, %s", op, source.String(), passthrough.String(), destination.String())}, modRMIndex + consumed, true, nil
+}
+
+func scalarIntegerFloatRawOperation(unsigned bool, pp byte, width64 bool) Op {
+	prefix := "VCVTSI2"
+	if unsigned {
+		prefix = "VCVTUSI2"
+	}
+	result := "SS"
+	if pp == 3 {
+		result = "SD"
+	}
+	source := "L"
+	if width64 {
+		source = "Q"
+	}
+	return Op(prefix + result + source)
+}
+
+// decodedX86VectorFloatCompareInstruction recognizes the complete VEX and
+// EVEX VCMPPD/PS/SD/SS family. VEX writes X/Y vector results. EVEX writes K
+// results and adds an optional K write mask, packed broadcast, and SAE.
+func decodedX86VectorFloatCompareInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXVectorFloatCompareInstruction(code, i, mode, segment, addressOverride)
+	}
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	switch {
+	case code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case code[i] == 0xc4 && len(code) >= i+6 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	opcodeIndex := i + vexLength
+	if len(code) <= opcodeIndex || code[opcodeIndex] != 0xc2 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexLength == 3 && vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	pp := vexBits & 3
+	scalar := pp >= 2
+	if scalar && vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("scalar vector floating compare requires VEX.128")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("%w: raw mode32 VEX compare high-bank identity", ErrProbeNeedsContext)
+	}
+	firstSource, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	op := vectorFloatCompareRawOperation(pp)
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{immediate, firstSource, secondSource, destination}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), firstSource.String(), secondSource.String(), destination.String()), x86Encoded: true}, immediateIndex + 1, true, nil
+}
+
+func decodedX86EVEXVectorFloatCompareInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+7 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 1 || code[i+4] != 0xc2 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("invalid EVEX prefix")
+	}
+	pp := p1 & 3
+	width64 := p1&0x80 != 0
+	wantWidth64 := pp == 1 || pp == 3
+	if width64 != wantWidth64 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match floating element type")
+	}
+	if p2&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing is absent from vector floating compare")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	if rExt != 0 || rHighExt != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX destination is an unextended K register")
+	}
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	vectorBits := (p2 >> 5) & 3
+	scalar := pp >= 2
+	evexB := p2&0x10 != 0
+	registerSource := modRM>>6 == 3
+	sae := evexB && registerSource
+	broadcast := evexB && !registerSource
+	if broadcast && scalar {
+		return Instr{}, 0, true, fmt.Errorf("scalar vector floating compare does not support broadcast")
+	}
+	if !sae && vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+
+	vectorPrefix := "X"
+	vectorWidth := 16
+	switch {
+	case sae && !scalar:
+		vectorPrefix = "Z"
+		vectorWidth = 64
+	case !scalar:
+		vectorPrefix = [...]string{"X", "Y", "Z"}[vectorBits]
+		vectorWidth = [...]int{16, 32, 64}[vectorBits]
+	}
+	laneBytes := 4
+	if width64 {
+		laneBytes = 8
+	}
+	disp8Scale := vectorWidth
+	if scalar || broadcast {
+		disp8Scale = laneBytes
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+
+	op := vectorFloatCompareRawOperation(pp)
+	if broadcast {
+		op += ".BCST"
+	}
+	if sae {
+		op += ".SAE"
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	if mode == 32 && (xExt != 0 || bExt != 0 || secondSourceNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("%w: raw mode32 EVEX compare high-bank identity", ErrProbeNeedsContext)
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", modRM>>3&7))}
+	args := []Operand{immediate, firstSource, secondSource}
+	if writeMask := int(p2 & 7); writeMask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", writeMask))})
+	}
+	args = append(args, destination)
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")), x86Encoded: true}, immediateIndex + 1, true, nil
+}
+
+func vectorFloatCompareRawOperation(pp byte) Op {
+	return [...]Op{"VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"}[pp]
+}
+
+// decodedX86VEXHorizontalFloatInstruction recognizes the complete VEX.128 and
+// VEX.256 VHADD/VHSUB/VADDSUB PS/PD family in Go 1.27's _yvaddsubpd table.
+// VEX.W is ignored. Recover every register and ModRM/SIB memory form before
+// the generic decoder, which can misdecode these bytes as relative branches.
+func decodedX86VEXHorizontalFloatInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	stem, recognized := map[byte]string{0x7c: "VHADD", 0x7d: "VHSUB", 0xd0: "VADDSUB"}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	suffix := ""
+	switch vexBits & 3 {
+	case 1:
+		suffix = "PD"
+	case 3:
+		suffix = "PS"
+	default:
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp does not select a horizontal floating instruction")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	op := Op(stem + suffix)
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+type decodedX86VEXFMA3Spec struct {
+	stem   string
+	scalar bool
+}
+
+func (spec decodedX86VEXFMA3Spec) op(width64 bool) Op {
+	suffix := "PS"
+	if spec.scalar {
+		suffix = "SS"
+	}
+	if width64 {
+		if spec.scalar {
+			suffix = "SD"
+		} else {
+			suffix = "PD"
+		}
+	}
+	return Op(spec.stem + suffix)
+}
+
+// decodedX86VEXFMA3Ops covers all 36 packed and 24 scalar FMA3 names in Go
+// 1.27's _yvaddpd and _yvaddsd operand tables. VEX.W selects PS/PD or SS/SD.
+var decodedX86VEXFMA3Ops = map[byte]decodedX86VEXFMA3Spec{
+	0x96: {stem: "VFMADDSUB132"},
+	0x97: {stem: "VFMSUBADD132"},
+	0x98: {stem: "VFMADD132"},
+	0x99: {stem: "VFMADD132", scalar: true},
+	0x9a: {stem: "VFMSUB132"},
+	0x9b: {stem: "VFMSUB132", scalar: true},
+	0x9c: {stem: "VFNMADD132"},
+	0x9d: {stem: "VFNMADD132", scalar: true},
+	0x9e: {stem: "VFNMSUB132"},
+	0x9f: {stem: "VFNMSUB132", scalar: true},
+	0xa6: {stem: "VFMADDSUB213"},
+	0xa7: {stem: "VFMSUBADD213"},
+	0xa8: {stem: "VFMADD213"},
+	0xa9: {stem: "VFMADD213", scalar: true},
+	0xaa: {stem: "VFMSUB213"},
+	0xab: {stem: "VFMSUB213", scalar: true},
+	0xac: {stem: "VFNMADD213"},
+	0xad: {stem: "VFNMADD213", scalar: true},
+	0xae: {stem: "VFNMSUB213"},
+	0xaf: {stem: "VFNMSUB213", scalar: true},
+	0xb6: {stem: "VFMADDSUB231"},
+	0xb7: {stem: "VFMSUBADD231"},
+	0xb8: {stem: "VFMADD231"},
+	0xb9: {stem: "VFMADD231", scalar: true},
+	0xba: {stem: "VFMSUB231"},
+	0xbb: {stem: "VFMSUB231", scalar: true},
+	0xbc: {stem: "VFNMADD231"},
+	0xbd: {stem: "VFNMADD231", scalar: true},
+	0xbe: {stem: "VFNMSUB231"},
+	0xbf: {stem: "VFNMSUB231", scalar: true},
+}
+
+// decodedX86VEXFMA3Instruction recognizes every VEX and EVEX FMA3 form behind
+// Go 1.27's complete FMA3 table. EVEX adds X/Y/Z widths, masking, zeroing,
+// packed broadcasts, and embedded rounding. x/arch v0.14 can split or reject
+// raw FMA encodings emitted by generated ecosystem assembly, so recover the
+// family before the generic decoder.
+func decodedX86VEXFMA3Instruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXFMA3InstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXFMA3InstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXFMA3InstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 2 {
+		return Instr{}, 0, false, nil
+	}
+	vex0, vexBits, opcode := code[i+1], code[i+2], code[i+3]
+	spec, recognized := decodedX86VEXFMA3Ops[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if spec.scalar && vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("scalar FMA3 requires VEX.128")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	op := spec.op(vexBits&0x80 != 0)
+	instruction = Instr{
+		Op:              op,
+		Args:            []Operand{firstSource, secondSource, destination},
+		Raw:             fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+		x86FMA3Encoding: x86RawFMA3VEX,
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXFMA3Instruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXFMA3InstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXFMA3InstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+6 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	spec, recognized := decodedX86VEXFMA3Ops[opcode]
+	half := p0&0x0f == 6
+	if p0&0x0f != 2 && !half || !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 || p1&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.pp must be 66")
+	}
+	if half && p1&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("FP16 FMA3 requires EVEX.W0")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	vectorBits := (p2 >> 5) & 3
+	evexB := p2&0x10 != 0
+	registerSource := modRM>>6 == 3
+	embeddedRounding := evexB && registerSource
+	broadcast := evexB && !registerSource
+	if broadcast && spec.scalar {
+		return Instr{}, 0, true, fmt.Errorf("scalar FMA3 does not support broadcast")
+	}
+	if !embeddedRounding && vectorBits == 3 && !(half && spec.scalar) {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+
+	vectorPrefix := "X"
+	vectorWidth := 16
+	switch {
+	case embeddedRounding && !spec.scalar:
+		vectorPrefix = "Z"
+		vectorWidth = 64
+	case !spec.scalar:
+		vectorPrefix = [...]string{"X", "Y", "Z"}[vectorBits]
+		vectorWidth = [...]int{16, 32, 64}[vectorBits]
+	}
+	laneBytes := 4
+	width64 := p1&0x80 != 0
+	if width64 {
+		laneBytes = 8
+	}
+	if half {
+		laneBytes = 2
+	}
+	disp8Scale := vectorWidth
+	if spec.scalar || broadcast {
+		disp8Scale = laneBytes
+	}
+
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (rExt != 0 || rHighExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+
+	op := spec.op(width64)
+	if half {
+		op = Op(spec.stem + "PH")
+		if spec.scalar {
+			op = Op(spec.stem + "SH")
+		}
+	}
+	if broadcast {
+		op += ".BCST"
+	}
+	if embeddedRounding {
+		op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[vectorBits]
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	encoding := x86RawFMA3EVEX
+	if half {
+		encoding = x86RawFMA3Absent // The existing FP16 owner remains distinct.
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: half, x86FMA3Encoding: encoding}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86VEXTRACT128Instruction recognizes the complete Go 1.27 vector
+// lane-extract family: the VEX F128/I128 forms and all EVEX F/I 32/64-bit
+// 128/256-bit block forms. x/arch v0.14 can misdecode these raw bytes as
+// PC-relative control flow or reject the EVEX encodings outright.
+func decodedX86VEXTRACT128Instruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VEXTRACT128InstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXTRACT128InstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXTRACTInstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+	if len(code) < i+6 || code[i] != 0xc4 || code[i+1]&0x1f != 3 {
+		return Instr{}, 0, false, nil
+	}
+	vex0, vexBits, opcode := code[i+1], code[i+2], code[i+3]
+	op, recognized := map[byte]Op{0x19: "VEXTRACTF128", 0x39: "VEXTRACTI128"}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if vexBits&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEXTRACT128 requires VEX.256")
+	}
+	if int(^vexBits>>3)&15 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be 1111")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	modRMIndex := i + 4
+	modRM := code[modRMIndex]
+	sourceNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || sourceNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	destination, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", sourceNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, immediate.String(), source.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+func decodedX86EVEXTRACTInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXTRACTInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXTRACTInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 3 || p1&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	opcode := code[i+4]
+	width64 := p1&0x80 != 0
+	outputBytes := 0
+	op := Op("")
+	switch opcode {
+	case 0x19:
+		outputBytes = 16
+		op = "VEXTRACTF32X4"
+		if width64 {
+			op = "VEXTRACTF64X2"
+		}
+	case 0x1b:
+		outputBytes = 32
+		op = "VEXTRACTF32X8"
+		if width64 {
+			op = "VEXTRACTF64X4"
+		}
+	case 0x39:
+		outputBytes = 16
+		op = "VEXTRACTI32X4"
+		if width64 {
+			op = "VEXTRACTI64X2"
+		}
+	case 0x3b:
+		outputBytes = 32
+		op = "VEXTRACTI32X8"
+		if width64 {
+			op = "VEXTRACTI64X4"
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for vector extract")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if outputBytes == 16 && vectorBits != 1 && vectorBits != 2 {
+		return Instr{}, 0, true, fmt.Errorf("128-bit extract requires a 256- or 512-bit source")
+	}
+	if outputBytes == 32 && vectorBits != 2 {
+		return Instr{}, 0, true, fmt.Errorf("256-bit extract requires a 512-bit source")
+	}
+	sourceName := [...]string{"", "Y", "Z"}[vectorBits]
+	destinationName := "X"
+	if outputBytes == 32 {
+		destinationName = "Y"
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	if zeroing && modRM>>6 != 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing is invalid for a memory destination")
+	}
+	sourceNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	destinationNumber := int(modRM&7) + bExt*8 + xExt*16
+	if mode == 32 && (sourceNumber >= 8 || modRM>>6 == 3 && destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	destination, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, destinationName, outputBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", sourceName, sourceNumber))}
+	args := []Operand{immediate, source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86VSHUFPSInstruction recognizes Go 1.27's complete shared
+// VSHUFPS/VSHUFPD operand table. x/arch v0.14 rejects some extended VEX
+// encodings and all EVEX forms used by generated ecosystem assembly.
+func decodedX86VSHUFPSInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXPackedFloatShuffleInstruction(code, i, mode, segment, addressOverride)
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5 && code[i+2] == 0xc6:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1 && code[i+3] == 0xc6:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	op := Op("")
+	switch vexBits & 3 {
+	case 0:
+		op = "VSHUFPS"
+	case 1:
+		op = "VSHUFPD"
+	default:
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp does not select VSHUFPS or VSHUFPD")
+	}
+	// Both VEX members are WIG in the ISA, independently of Go's W0
+	// encoder choice. EVEX retains its separate PS W0 / PD W1 grammar.
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, err := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+func decodedX86EVEXPackedFloatShuffleInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+7 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 1 || p1&0x04 == 0 || code[i+4] != 0xc6 {
+		return Instr{}, 0, false, nil
+	}
+	op := Op("")
+	switch {
+	case p1&3 == 0 && p1&0x80 == 0:
+		op = "VSHUFPS"
+	case p1&3 == 1 && p1&0x80 != 0:
+		op = "VSHUFPD"
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = 4
+		if op == "VSHUFPD" {
+			disp8Scale = 8
+		}
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{immediate, firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86PackedShuffleInstruction recognizes the complete Go 1.27
+// _yvpshufd family: VPSHUFD, VPSHUFHW, and VPSHUFLW across VEX.128,
+// VEX.256, and EVEX.128/256/512, including memory, mask, zeroing, and the
+// VPSHUFD broadcast forms. x/arch v0.14 can split the VEX bytes emitted by
+// Weaviate into a relative branch, so recover the family before consulting
+// the generic decoder.
+func decodedX86PackedShuffleInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedShuffleInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedShuffleInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXPackedShuffleInstruction(code, i, mode, segment, addressOverride, memory)
+	}
+
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5 && code[i+2] == 0x70:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1 && code[i+3] == 0x70:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+	default:
+		return Instr{}, 0, false, nil
+	}
+	op := map[byte]Op{1: "VPSHUFD", 2: "VPSHUFHW", 3: "VPSHUFLW"}[vexBits&3]
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorName := "X"
+	if vexBits&0x04 != 0 {
+		vectorName = "Y"
+	}
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, immediate.String(), source.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+func decodedX86EVEXPackedShuffleInstruction(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 1 || p1&0x04 == 0 || code[i+4] != 0x70 {
+		return Instr{}, 0, false, nil
+	}
+	op := map[byte]Op{1: "VPSHUFD", 2: "VPSHUFHW", 3: "VPSHUFLW"}[p1&3]
+	if op == "" || op == "VPSHUFD" && p1&0x80 != 0 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 packed shuffle mask form exceeds the Go assembler frontend's operand limit")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && op != "VPSHUFD" {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is only available for VPSHUFD")
+	}
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = 4
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{immediate, source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86Shuffle128BitBlocksInstruction recognizes the complete EVEX-only
+// Go 1.27 _yvshuff32x4 family: VSHUFF32X4, VSHUFF64X2, VSHUFI32X4, and
+// VSHUFI64X2. x/arch v0.14 rejects these raw encodings, including the
+// VSHUFF64X2 sequence in github.com/minio/sha256-simd.
+func decodedX86Shuffle128BitBlocksInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+7 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 3 || p1&0x07 != 5 || opcode != 0x23 && opcode != 0x43 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits != 1 && vectorBits != 2 {
+		return Instr{}, 0, true, fmt.Errorf("VSHUFF/VSHUFI block shuffle requires a 256- or 512-bit vector")
+	}
+	vectorPrefix := [...]string{"", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{0, 32, 64}[vectorBits]
+	width64 := p1&0x80 != 0
+	op := Op("VSHUFF32X4")
+	laneBytes := 4
+	if opcode == 0x43 {
+		op = "VSHUFI32X4"
+	}
+	if width64 {
+		laneBytes = 8
+		if opcode == 0x23 {
+			op = "VSHUFF64X2"
+		} else {
+			op = "VSHUFI64X2"
+		}
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{immediate, firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86VPSHUFBInstruction recognizes every VEX and EVEX encoding behind
+// Go 1.27's _yvandnpd table. x/arch v0.14 rejects the EVEX forms used by
+// github.com/minio/sha256-simd.
+func decodedX86VPSHUFBInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VPSHUFBInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VPSHUFBInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+4 {
+		return Instr{}, 0, false, nil
+	}
+	if code[i] == 0xc4 && code[i+1]&0x1f == 2 && code[i+3] == 0x00 {
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		vex0, vex1 := code[i+1], code[i+2]
+		if vex1&3 != 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+		}
+		// Intel PSHUFB specifies WIG for both VEX and EVEX. Go emits W0,
+		// but that encoding choice cannot reject independently decoded W1.
+		if len(code) <= i+4 {
+			return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+		}
+		rExt := int(^vex0>>7) & 1
+		xExt := int(^vex0>>6) & 1
+		bExt := int(^vex0>>5) & 1
+		vectorName := "X"
+		if vex1&0x04 != 0 {
+			vectorName = "Y"
+		}
+		modRMIndex := i + 4
+		modRM := code[modRMIndex]
+		dataNumber := int(^vex1>>3) & 15
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (dataNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		control, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, dataNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		return Instr{
+			Op:         "VPSHUFB",
+			Args:       []Operand{control, data, destination},
+			Raw:        fmt.Sprintf("VPSHUFB %s, %s, %s", control.String(), data.String(), destination.String()),
+			x86Encoded: true,
+		}, modRMIndex + consumed, true, nil
+	}
+
+	if len(code) < i+5 || code[i] != 0x62 || code[i+1]&0x0f != 2 || code[i+2]&0x07 != 5 || code[i+4] != 0x00 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for VPSHUFB")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	dataNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (dataNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	control, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, vectorWidth)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, dataNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{control, data}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	op := Op("VPSHUFB")
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")), x86Encoded: true}, modRMIndex + consumed, true, nil
+}
+
+type decodedX86PackedExtendProperties struct {
+	op         Op
+	inputBits  int
+	outputBits int
+}
+
+func decodedX86PackedExtendOpcode(opcode byte) (decodedX86PackedExtendProperties, bool) {
+	properties := map[byte]decodedX86PackedExtendProperties{
+		0x20: {op: "VPMOVSXBW", inputBits: 8, outputBits: 16},
+		0x21: {op: "VPMOVSXBD", inputBits: 8, outputBits: 32},
+		0x22: {op: "VPMOVSXBQ", inputBits: 8, outputBits: 64},
+		0x23: {op: "VPMOVSXWD", inputBits: 16, outputBits: 32},
+		0x24: {op: "VPMOVSXWQ", inputBits: 16, outputBits: 64},
+		0x25: {op: "VPMOVSXDQ", inputBits: 32, outputBits: 64},
+		0x30: {op: "VPMOVZXBW", inputBits: 8, outputBits: 16},
+		0x31: {op: "VPMOVZXBD", inputBits: 8, outputBits: 32},
+		0x32: {op: "VPMOVZXBQ", inputBits: 8, outputBits: 64},
+		0x33: {op: "VPMOVZXWD", inputBits: 16, outputBits: 32},
+		0x34: {op: "VPMOVZXWQ", inputBits: 16, outputBits: 64},
+		0x35: {op: "VPMOVZXDQ", inputBits: 32, outputBits: 64},
+	}[opcode]
+	return properties, properties.op != ""
+}
+
+// decodedX86PackedExtendInstruction recognizes all six signed and all six
+// unsigned packed extending moves in Go 1.27. It covers their VEX.128/256 and
+// EVEX.128/256/512 register and memory forms, including high registers,
+// writemasks, zeroing, and compressed displacements. EVEX.b is deliberately
+// rejected because no broadcast form exists in the Go operand tables.
+func decodedX86PackedExtendInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXPackedExtendInstruction(code, i, mode, segment, addressOverride)
+	}
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 2 {
+		return Instr{}, 0, false, nil
+	}
+	vex0, vex1 := code[i+1], code[i+2]
+	properties, recognized := decodedX86PackedExtendOpcode(code[i+3])
+	// Intel SDM PMOVSX/PMOVZX: VEX.W is ignored for all six ratios.
+	// Go chooses W0, but raw W1 is not an invalid instruction.
+	if !recognized || vex1&3 != 1 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vex1&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRMIndex := i + 4
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	rExt := int(^vex0>>7) & 1
+	xExt := int(^vex0>>6) & 1
+	bExt := int(^vex0>>5) & 1
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (destinationNumber >= 8 || code[modRMIndex]>>6 == 3 && int(code[modRMIndex]&7)+bExt*8 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	destinationName := "X"
+	if vex1&0x04 != 0 {
+		destinationName = "Y"
+	}
+	source, consumed, decodeErr := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationName, destinationNumber))}
+	instruction = Instr{
+		Op:   properties.op,
+		Args: []Operand{source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s", properties.op, source.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXPackedExtendInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x0f != 2 || p1&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	properties, recognized := decodedX86PackedExtendOpcode(code[i+4])
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	// The EVEX DQ forms alone require W0; the other five ratios are WIG.
+	// Keep this physical constraint distinct from Go's W0 encoder choice.
+	if properties.inputBits == 32 && p1&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed dword-to-qword extension requires W0")
+	}
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for packed extending moves")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	destinationName := [...]string{"X", "Y", "Z"}[vectorBits]
+	destinationBytes := [...]int{16, 32, 64}[vectorBits]
+	sourceBytes := destinationBytes * properties.inputBits / properties.outputBits
+	sourceName := "X"
+	if sourceBytes > 16 {
+		sourceName = "Y"
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	sourceNumber := int(modRM&7) + bExt*8 + xExt*16
+	if mode == 32 && (destinationNumber >= 8 || modRM>>6 == 3 && sourceNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	source, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, sourceName, sourceBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationName, destinationNumber))}
+	args := []Operand{source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	op := properties.op
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+type decodedX86PackedUniformShiftProperties struct {
+	op        Op
+	laneBytes int
+	immediate bool
+}
+
+func decodedX86PackedUniformShiftOpcode(opcode, modRM byte, evex, w bool) (decodedX86PackedUniformShiftProperties, bool) {
+	laneBytes := map[byte]int{0x71: 2, 0x72: 4, 0x73: 8}[opcode]
+	if laneBytes != 0 {
+		direction := modRM >> 3 & 7
+		if direction != 2 && direction != 4 && direction != 6 {
+			return decodedX86PackedUniformShiftProperties{}, false
+		}
+		stem := "VPSRL"
+		switch direction {
+		case 4:
+			if laneBytes == 8 {
+				return decodedX86PackedUniformShiftProperties{}, false
+			}
+			stem = "VPSRA"
+			if evex && w && laneBytes == 4 {
+				laneBytes = 8
+			}
+		case 6:
+			stem = "VPSLL"
+		}
+		suffix := map[int]string{2: "W", 4: "D", 8: "Q"}[laneBytes]
+		return decodedX86PackedUniformShiftProperties{op: Op(stem + suffix), laneBytes: laneBytes, immediate: true}, true
+	}
+	variable := map[byte]struct {
+		op        Op
+		laneBytes int
+	}{
+		0xf1: {op: "VPSLLW", laneBytes: 2},
+		0xf2: {op: "VPSLLD", laneBytes: 4},
+		0xf3: {op: "VPSLLQ", laneBytes: 8},
+		0xd1: {op: "VPSRLW", laneBytes: 2},
+		0xd2: {op: "VPSRLD", laneBytes: 4},
+		0xd3: {op: "VPSRLQ", laneBytes: 8},
+		0xe1: {op: "VPSRAW", laneBytes: 2},
+		0xe2: {op: "VPSRAD", laneBytes: 4},
+	}
+	properties, ok := variable[opcode]
+	if !ok {
+		return decodedX86PackedUniformShiftProperties{}, false
+	}
+	if evex && w && opcode == 0xe2 {
+		properties.op, properties.laneBytes = "VPSRAQ", 8
+	}
+	return decodedX86PackedUniformShiftProperties{op: properties.op, laneBytes: properties.laneBytes}, true
+}
+
+// decodedX86PackedUniformShiftInstruction recognizes the complete Go 1.27
+// immediate and XMM/m128-count grammar: six logical shifts and three
+// arithmetic right shifts across VEX/EVEX X/Y/Z widths. x/arch v0.14
+// misdecodes several VEX/EVEX forms used by external assembly.
+func decodedX86PackedUniformShiftInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedUniformShiftInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedUniformShiftInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+4 {
+		return Instr{}, 0, false, nil
+	}
+
+	var vexBits byte
+	var opcodeIndex, modRMIndex, rExt, xExt, bExt int
+	isVEX := false
+	vexHasW := false
+	switch {
+	case code[i] == 0xc5:
+		vexBits = code[i+1]
+		opcodeIndex = i + 2
+		modRMIndex = i + 3
+		rExt = int(^vexBits>>7) & 1
+		isVEX = true
+	case len(code) >= i+5 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vex0 := code[i+1]
+		vexBits = code[i+2]
+		opcodeIndex = i + 3
+		modRMIndex = i + 4
+		rExt = int(^vex0>>7) & 1
+		xExt = int(^vex0>>6) & 1
+		bExt = int(^vex0>>5) & 1
+		isVEX = true
+		vexHasW = true
+	}
+	if isVEX {
+		properties, recognized := decodedX86PackedUniformShiftOpcode(code[opcodeIndex], code[modRMIndex], false, vexHasW && vexBits&0x80 != 0)
+		if !recognized {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if vexBits&3 != 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		modRM := code[modRMIndex]
+		vvvvNumber := int(^vexBits>>3) & 15
+		if properties.immediate {
+			if modRM>>6 != 3 {
+				return Instr{}, 0, true, fmt.Errorf("VEX immediate packed shift requires a register source")
+			}
+			if rExt != 0 {
+				return Instr{}, 0, true, fmt.Errorf("VEX.R must not extend the shift opcode selector")
+			}
+			if mode == 32 && vvvvNumber >= 8 {
+				return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+			}
+			source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+			if decodeErr != nil {
+				return Instr{}, 0, true, decodeErr
+			}
+			immediateIndex := modRMIndex + consumed
+			if len(code) <= immediateIndex {
+				return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+			}
+			immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+			destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, vvvvNumber))}
+			return Instr{
+				Op:                     properties.op,
+				Args:                   []Operand{immediate, source, destination},
+				Raw:                    fmt.Sprintf("%s %s, %s, %s", properties.op, immediate.String(), source.String(), destination.String()),
+				x86Encoded:             true,
+				x86PackedShiftEncoding: x86RawPackedShiftVEX,
+				x86PackedShiftW:        vexHasW && vexBits&0x80 != 0,
+			}, immediateIndex + 1, true, nil
+		}
+
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (vvvvNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		count, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, "X")
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, vvvvNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		return Instr{
+			Op:                     properties.op,
+			Args:                   []Operand{count, data, destination},
+			Raw:                    fmt.Sprintf("%s %s, %s, %s", properties.op, count.String(), data.String(), destination.String()),
+			x86Encoded:             true,
+			x86PackedShiftEncoding: x86RawPackedShiftVEX,
+			x86PackedShiftW:        vexHasW && vexBits&0x80 != 0,
+		}, modRMIndex + consumed, true, nil
+	}
+
+	if len(code) < i+6 || code[i] != 0x62 || code[i+1]&0x0f != 1 || code[i+2]&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	modRMIndex = i + 5
+	modRM := code[modRMIndex]
+	properties, recognized := decodedX86PackedUniformShiftOpcode(code[i+4], modRM, true, p1&0x80 != 0)
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if properties.laneBytes != 2 && (p1&0x80 != 0) != (properties.laneBytes == 8) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match %s", properties.op)
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	rExt = int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt = int(^p0>>6) & 1
+	bExt = int(^p0>>5) & 1
+	vvvvNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	broadcast := p2&0x10 != 0
+	if properties.immediate {
+		if p0&0x90 != 0x90 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX.R and EVEX.R' must not extend the shift opcode selector")
+		}
+		if broadcast && properties.laneBytes == 2 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is unavailable for %s", properties.op)
+		}
+		if broadcast && modRM>>6 == 3 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+		}
+		if mode == 32 && (vvvvNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		disp8Scale := vectorWidth
+		if broadcast {
+			disp8Scale = properties.laneBytes
+		}
+		source, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		immediateIndex := modRMIndex + consumed
+		if len(code) <= immediateIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, vvvvNumber))}
+		args := []Operand{immediate, source}
+		if maskNumber != 0 {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+		}
+		args = append(args, destination)
+		op := properties.op
+		if broadcast {
+			op += ".BCST"
+		}
+		if zeroing {
+			op += ".Z"
+		}
+		rawArgs := make([]string, len(args))
+		for index := range args {
+			rawArgs[index] = args[index].String()
+		}
+		return Instr{
+			Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+			x86Encoded: true, x86PackedShiftEncoding: x86RawPackedShiftEVEX, x86PackedShiftW: p1&0x80 != 0,
+		}, immediateIndex + 1, true, nil
+	}
+
+	if broadcast {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.b is unavailable for the uniform-count form of %s", properties.op)
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (vvvvNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	count, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, "X", 16)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, vvvvNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{count, data}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	op := properties.op
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: true, x86PackedShiftEncoding: x86RawPackedShiftEVEX, x86PackedShiftW: p1&0x80 != 0,
+	}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86TernaryLogicInstruction recognizes VPTERNLOGD/Q across the
+// complete Go 1.27 _yvalignd table. x/arch v0.14 rejects the EVEX encodings
+// used by github.com/minio/sha256-simd.
+func decodedX86TernaryLogicInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86TernaryLogicInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86TernaryLogicInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	instruction, length, ok, err = decodedX86EVEXImmediateThreeVectorPhysical(code, mode,
+		0x25, "VPTERNLOGD", "VPTERNLOGQ", "VPTERNLOG", memory, true)
+	if ok && err == nil {
+		instruction.x86Encoded = true
+		instruction.x86VectorBytes = amd64VectorByteWidth(instruction.Args[len(instruction.Args)-1].Reg)
+		if !memory.physicalPC {
+			arch := "amd64"
+			if mode == 32 {
+				arch = "386"
+			}
+			_, _, err = x86TernaryLogicProperties(instruction.Op, instruction, arch)
+		}
+	}
+	return instruction, length, ok, err
+}
+
+// decodedX86VectorAlignInstruction recognizes VALIGND/Q across the complete
+// Go 1.27 _yvalignd table.
+func decodedX86VectorAlignInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXImmediateThreeVectorInstruction(code, mode, 0x03, "VALIGND", "VALIGNQ", "VALIGN")
+}
+
+// decodedX86FunnelShiftInstruction recognizes the complete Go 1.27 VBMI2
+// funnel-shift family: immediate/variable, left/right, and W/D/Q lanes.
+// x/arch v0.14 rejects all of these EVEX encodings.
+func decodedX86FunnelShiftInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 || code[i+2]&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	mapNumber := p0 & 0x0f
+	variable := false
+	switch mapNumber {
+	case 2:
+		variable = true
+	case 3:
+	default:
+		return Instr{}, 0, false, nil
+	}
+	opcode := code[i+4]
+	wBit := p1&0x80 != 0
+	laneBits := 0
+	left := false
+	switch opcode {
+	case 0x70:
+		left, laneBits = true, 16
+	case 0x71:
+		left = true
+		if wBit {
+			laneBits = 64
+		} else {
+			laneBits = 32
+		}
+	case 0x72:
+		laneBits = 16
+	case 0x73:
+		if wBit {
+			laneBits = 64
+		} else {
+			laneBits = 32
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if laneBits == 16 && !wBit {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W must be one for word funnel shifts")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if !variable && mode == 32 {
+		return Instr{}, 0, true, fmt.Errorf("386 immediate funnel shifts exceed the Go assembler frontend's operand limit")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if variable && mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 variable funnel-shift mask form exceeds the Go assembler frontend's operand limit")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && laneBits == 16 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is unavailable for word funnel shifts")
+	}
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (secondSourceNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBits / 8
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	opDirection := "R"
+	if left {
+		opDirection = "L"
+	}
+	laneSuffix := map[int]string{16: "W", 32: "D", 64: "Q"}[laneBits]
+	op := Op("VPSH" + opDirection + "D")
+	if variable {
+		op += "V"
+	}
+	op += Op(laneSuffix)
+	args := make([]Operand, 0, 5)
+	end := modRMIndex + consumed
+	if !variable {
+		if len(code) <= end {
+			return Instr{}, 0, false, nil
+		}
+		args = append(args, Operand{Kind: OpImm, Imm: int64(code[end])})
+		end++
+	}
+	args = append(args, firstSource, secondSource)
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, end, true, nil
+}
+
+// decodedX86EVEXImmediateThreeVectorInstruction implements the EVEX immediate,
+// r/m, vvvv, destination shape shared by Go 1.27's _yvalignd families.
+func decodedX86EVEXImmediateThreeVectorInstruction(code []byte, mode int, opcode byte, dwordOp, qwordOp Op, family string) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXImmediateThreeVectorInstructionWithMemory(code, mode, opcode, dwordOp, qwordOp, family, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXImmediateThreeVectorInstructionWithMemory(code []byte, mode int, opcode byte, dwordOp, qwordOp Op, family string, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXImmediateThreeVectorPhysical(code, mode, opcode, dwordOp, qwordOp, family, memory, false)
+}
+
+func decodedX86EVEXImmediateThreeVectorPhysical(code []byte, mode int, opcode byte, dwordOp, qwordOp Op, family string, memory x86RawMemoryDecoder, physicalMode32 bool) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+7 || code[i] != 0x62 || code[i+1]&0x0f != 3 || code[i+2]&0x07 != 5 || code[i+4] != opcode {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if mode == 32 && !physicalMode32 {
+		return Instr{}, 0, true, fmt.Errorf("386 %s is rejected by the Go assembler frontend's operand limit", family)
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	laneBytes := 4
+	op := dwordOp
+	if p1&0x80 != 0 {
+		laneBytes = 8
+		op = qwordOp
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+	}
+	firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	if mode == 32 {
+		firstNumber, firstRegister := amd64VectorRegisterIndex(firstSource.Reg, vectorWidth)
+		if destinationNumber >= 8 || secondSourceNumber >= 8 || firstRegister && firstNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit %s", family)
+		}
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{immediate, firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+// decodedX86PackedImmediateRotateInstruction recognizes all four EVEX
+// immediate rotates in Go 1.27's _yvprold table. x/arch v0.14 rejects these
+// raw encodings, including VPRORD in github.com/minio/sha256-simd.
+func decodedX86PackedImmediateRotateInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+7 || code[i] != 0x62 || code[i+1]&0x0f != 1 || code[i+2]&0x07 != 5 || code[i+4] != 0x72 {
+		return Instr{}, 0, false, nil
+	}
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	selector := modRM >> 3 & 7
+	if selector != 0 && selector != 1 {
+		// Opcode 72 is a grouped encoding. Selectors /2 and /6 are the
+		// VPSRL/VPSLL logical-shift family, and other selectors may belong to
+		// decoders added later. This decoder only owns the rotate selectors.
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p0&0x90 != 0x90 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.R and EVEX.R' must not extend the rotate opcode selector")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	laneBytes := 4
+	left := false
+	switch selector {
+	case 0:
+	case 1:
+		left = true
+	}
+	op := Op("VPRORD")
+	if left {
+		op = "VPROLD"
+	}
+	if p1&0x80 != 0 {
+		laneBytes = 8
+		if left {
+			op = "VPROLQ"
+		} else {
+			op = "VPRORQ"
+		}
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 %s mask form exceeds the Go assembler frontend's operand limit", op)
+	}
+
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	destinationNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	if mode == 32 && (destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+	}
+	source, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{immediate, source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, immediateIndex + 1, true, nil
+}
+
+var decodedX86PackedIntegerArithmeticOps = map[byte]struct {
+	op        Op
+	laneBytes int
+}{
+	0xfc: {op: "VPADDB", laneBytes: 1},
+	0xfd: {op: "VPADDW", laneBytes: 2},
+	0xfe: {op: "VPADDD", laneBytes: 4},
+	0xd4: {op: "VPADDQ", laneBytes: 8},
+	0xec: {op: "VPADDSB", laneBytes: 1},
+	0xed: {op: "VPADDSW", laneBytes: 2},
+	0xdc: {op: "VPADDUSB", laneBytes: 1},
+	0xdd: {op: "VPADDUSW", laneBytes: 2},
+	0xf8: {op: "VPSUBB", laneBytes: 1},
+	0xf9: {op: "VPSUBW", laneBytes: 2},
+	0xfa: {op: "VPSUBD", laneBytes: 4},
+	0xfb: {op: "VPSUBQ", laneBytes: 8},
+	0xe8: {op: "VPSUBSB", laneBytes: 1},
+	0xe9: {op: "VPSUBSW", laneBytes: 2},
+	0xd8: {op: "VPSUBUSB", laneBytes: 1},
+	0xd9: {op: "VPSUBUSW", laneBytes: 2},
+}
+
+// decodedX86PackedIntegerArithmeticInstruction recognizes the complete
+// VEX/EVEX VPADD and VPSUB families behind Go 1.27's shared _yvandnpd table.
+// x/arch v0.14 rejects EVEX forms and can split VEX forms used by ecosystem
+// assembly.
+func decodedX86PackedIntegerArithmeticInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedIntegerArithmeticInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedIntegerArithmeticInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+3 {
+		return Instr{}, 0, false, nil
+	}
+
+	var vexBits byte
+	var opcodeIndex, modRMIndex, rExt, xExt, bExt int
+	isVEX := false
+	switch {
+	case code[i] == 0xc5:
+		vexBits = code[i+1]
+		opcodeIndex = i + 2
+		modRMIndex = i + 3
+		rExt = int(^vexBits>>7) & 1
+		isVEX = true
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vex0 := code[i+1]
+		vexBits = code[i+2]
+		opcodeIndex = i + 3
+		modRMIndex = i + 4
+		rExt = int(^vex0>>7) & 1
+		xExt = int(^vex0>>6) & 1
+		bExt = int(^vex0>>5) & 1
+		isVEX = true
+	}
+	if isVEX {
+		properties, recognized := decodedX86PackedIntegerArithmeticOps[code[opcodeIndex]]
+		if !recognized {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if addressOverride {
+			return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+		}
+		if vexBits&3 != 1 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+		}
+		if len(code) <= modRMIndex {
+			return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+		}
+		vectorName := "X"
+		if vexBits&0x04 != 0 {
+			vectorName = "Y"
+		}
+		modRM := code[modRMIndex]
+		secondSourceNumber := int(^vexBits>>3) & 15
+		destinationNumber := int(modRM>>3&7) + rExt*8
+		if mode == 32 && (secondSourceNumber >= 8 || destinationNumber >= 8) {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		firstSource, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+		secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+		destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+		return Instr{
+			Op:   properties.op,
+			Args: []Operand{firstSource, secondSource, destination},
+			Raw:  fmt.Sprintf("%s %s, %s, %s", properties.op, firstSource.String(), secondSource.String(), destination.String()),
+		}, modRMIndex + consumed, true, nil
+	}
+
+	if len(code) < i+5 || code[i] != 0x62 || code[i+1]&0x0f != 1 || code[i+2]&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	properties, recognized := decodedX86PackedIntegerArithmeticOps[code[i+4]]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	wBit := p1&0x80 != 0
+	if wBit != (properties.laneBytes == 8) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match %s", properties.op)
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 %s mask form exceeds the Go assembler frontend's operand limit", properties.op)
+	}
+
+	rExt = int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt = int(^p0>>6) & 1
+	bExt = int(^p0>>5) & 1
+	modRMIndex = i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && properties.laneBytes != 4 && properties.laneBytes != 8 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is unavailable for %s", properties.op)
+	}
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && (secondSourceNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = properties.laneBytes
+	}
+	firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	op := properties.op
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86IndexedPermuteInstruction recognizes the complete EVEX-only
+// VPERMI2 and VPERMT2 families behind Go 1.27's shared _yvblendmpd table.
+func decodedX86IndexedPermuteInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 2 || p1&0x07 != 5 ||
+		(opcode < 0x75 || opcode > 0x77) && (opcode < 0x7d || opcode > 0x7f) {
+		return Instr{}, 0, false, nil
+	}
+	width64 := p1&0x80 != 0
+	op := Op("")
+	laneBytes := 0
+	switch opcode {
+	case 0x75:
+		if width64 {
+			op, laneBytes = "VPERMI2W", 2
+		} else {
+			op, laneBytes = "VPERMI2B", 1
+		}
+	case 0x76:
+		if width64 {
+			op, laneBytes = "VPERMI2Q", 8
+		} else {
+			op, laneBytes = "VPERMI2D", 4
+		}
+	case 0x77:
+		if width64 {
+			op, laneBytes = "VPERMI2PD", 8
+		} else {
+			op, laneBytes = "VPERMI2PS", 4
+		}
+	case 0x7d:
+		if width64 {
+			op, laneBytes = "VPERMT2W", 2
+		} else {
+			op, laneBytes = "VPERMT2B", 1
+		}
+	case 0x7e:
+		if width64 {
+			op, laneBytes = "VPERMT2Q", 8
+		} else {
+			op, laneBytes = "VPERMT2D", 4
+		}
+	case 0x7f:
+		if width64 {
+			op, laneBytes = "VPERMT2PD", 8
+		} else {
+			op, laneBytes = "VPERMT2PS", 4
+		}
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 indexed permute mask form exceeds the Go assembler operand limit")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && laneBytes < 4 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is unavailable for byte and word VPERMI2")
+	}
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	if mode == 32 && vectorBits == 2 &&
+		(destinationNumber >= 8 || secondSourceNumber >= 8 ||
+			modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("386 Z register exceeds the Go assembler frontend's register class")
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// Go 1.27's _yvcompresspd and _yvexpandpd families share the same typed
+// register/memory grammar, with the ModRM roles reversed for stores.
+func decodedX86PackedCompressInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedCompactInstruction(code, mode, true)
+}
+
+func decodedX86PackedExpandInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedCompactInstruction(code, mode, false)
+}
+
+func decodedX86PackedCompactInstruction(code []byte, mode int, store bool) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 2 || p1&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	if store && opcode != 0x63 && opcode != 0x8a && opcode != 0x8b ||
+		!store && opcode != 0x62 && opcode != 0x88 && opcode != 0x89 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed compact reserves the vvvv register field")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if p2&0x10 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is unavailable for packed compact")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	width64 := p1&0x80 != 0
+	op := Op("")
+	laneBytes := 0
+	switch opcode {
+	case 0x63:
+		if width64 {
+			op, laneBytes = "VPCOMPRESSW", 2
+		} else {
+			op, laneBytes = "VPCOMPRESSB", 1
+		}
+	case 0x8a:
+		if width64 {
+			op, laneBytes = "VCOMPRESSPD", 8
+		} else {
+			op, laneBytes = "VCOMPRESSPS", 4
+		}
+	case 0x8b:
+		if width64 {
+			op, laneBytes = "VPCOMPRESSQ", 8
+		} else {
+			op, laneBytes = "VPCOMPRESSD", 4
+		}
+	case 0x62:
+		if width64 {
+			op, laneBytes = "VPEXPANDW", 2
+		} else {
+			op, laneBytes = "VPEXPANDB", 1
+		}
+	case 0x88:
+		if width64 {
+			op, laneBytes = "VEXPANDPD", 8
+		} else {
+			op, laneBytes = "VEXPANDPS", 4
+		}
+	case 0x89:
+		if width64 {
+			op, laneBytes = "VPEXPANDQ", 8
+		} else {
+			op, laneBytes = "VPEXPANDD", 4
+		}
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	if mode == 32 &&
+		(int(modRM>>3&7)+rExt*8+rHighExt*16 >= 8 ||
+			modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register has no physical 32-bit binding")
+	}
+	regNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	reg := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, regNumber))}
+	rm, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, laneBytes)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	args := []Operand{reg}
+	if !store {
+		args = []Operand{rm}
+	}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	if store {
+		args = append(args, rm)
+	} else {
+		args = append(args, reg)
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86IFMAInstruction recognizes the complete EVEX-only
+// VPMADD52HUQ/LUQ family behind Go 1.27's _yvblendmpd table. x/arch v0.14
+// rejects these encodings.
+func decodedX86IFMAInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86EVEXQwordBinaryInstruction(code, mode, false)
+}
+
+func decodedX86QwordLookupInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86EVEXQwordBinaryInstruction(code, mode, true)
+}
+
+// decodedX86VPINSRInstruction recognizes the complete VEX.128 VPINSR
+// byte/word/dword/qword family, including two- and three-byte VEX encodings and
+// every ModRM/SIB source. x/arch v0.14 rejects some extended-register VPINSRQ
+// forms used by generated crypto assembly. EVEX forms continue through x/arch.
+func decodedX86VPINSRInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VPINSRInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VPINSRInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits byte
+	op := Op("")
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5 && code[i+2] == 0xc4:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		op = "VPINSRW"
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1 && code[i+3] == 0xc4:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		op = "VPINSRW"
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 3 && code[i+3] == 0x20:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		op = "VPINSRB"
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 3 && code[i+3] == 0x22:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		op = "VPINSRD"
+		if vexBits&0x80 != 0 {
+			op = "VPINSRQ"
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.L must be zero")
+	}
+	if (op == "VPINSRB" || op == "VPINSRW") && vexLength == 3 && vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero for %s", op)
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	firstVectorNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (op == "VPINSRQ" || rExt != 0 || xExt != 0 || bExt != 0 || firstVectorNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("64-bit width or extended register in 32-bit mode")
+	}
+	scalar, consumed, err := memory.scalar(code[modRMIndex:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	firstVector := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", firstVectorNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{immediate, scalar, firstVector, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), scalar.String(), firstVector.String(), destination.String()),
+	}
+	return instruction, immediateIndex + 1, true, nil
+}
+
+// decodedX86VPUNPCKInstruction recognizes the complete VEX.128/VEX.256
+// low/high byte, word, dword, and qword unpack family. x/arch v0.14 can split
+// or reject VEX encodings with extended registers, so recover every VEX
+// register and ModRM/SIB memory form before the generic decoder. EVEX forms
+// use the separate decodedX86EVEXPackedUnpackInstruction grammar.
+func decodedX86VPUNPCKInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+3 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+4 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := map[byte]Op{
+		0x60: "VPUNPCKLBW",
+		0x61: "VPUNPCKLWD",
+		0x62: "VPUNPCKLDQ",
+		0x6c: "VPUNPCKLQDQ",
+		0x68: "VPUNPCKHBW",
+		0x69: "VPUNPCKHWD",
+		0x6a: "VPUNPCKHDQ",
+		0x6d: "VPUNPCKHQDQ",
+	}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexLength == 3 && vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	secondSourceNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondSourceNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	firstSource, consumed, err := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86VEXVectorRMOperand(code []byte, mode, bExt, xExt int, segment Reg, vectorPrefix string) (Operand, int, error) {
+	if len(code) == 0 {
+		return Operand{}, 0, fmt.Errorf("missing ModRM byte")
+	}
+	if code[0]>>6 != 3 {
+		return decodedX86VEXRMSource(code, mode, bExt, xExt, segment)
+	}
+	number := int(code[0]&7) + bExt*8
+	if mode == 32 && number >= 8 {
+		return Operand{}, 0, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, number))}, 1, nil
+}
+
+// Preserve both physical integer-dot generations before generic decoding.
+// The equivalent Go-named EVEX row cannot identify an original VEX opcode.
+func decodedX86VNNIInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86IntegerPackedDotInstruction(code, mode)
+}
+
+// decodedX86VariableDwordPermuteInstruction recognizes the complete VEX.256
+// VPERMD/VPERMPS family shared by Go 1.27's _yvpermd table. x/arch v0.14 can
+// reject or split these encodings, so recover every register and ModRM/SIB
+// memory source before consulting the generic decoder. EVEX forms continue
+// through x/arch.
+func decodedX86VariableDwordPermuteInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 2 {
+		return Instr{}, 0, false, nil
+	}
+	vexBits := code[i+2]
+	opcode := code[i+3]
+	op, recognized := map[byte]Op{
+		0x36: "VPERMD",
+		0x16: "VPERMPS",
+	}[opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if vexBits&3 != 1 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.pp must be 66")
+	}
+	if vexBits&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if vexBits&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.L must be one")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	vex1 := code[i+1]
+	rExt := int(^vex1>>7) & 1
+	xExt := int(^vex1>>6) & 1
+	bExt := int(^vex1>>5) & 1
+	modRMIndex := i + 4
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	indicesNumber := int(^vexBits>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || indicesNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	data, consumed, err := decodedX86VEXVectorRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, "Y")
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	indices := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", indicesNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Y%d", destinationNumber))}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{data, indices, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, data.String(), indices.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+// decodedX86EVEXVariableDwordPermuteInstruction covers the Y/Z EVEX forms of
+// Go 1.27's shared VPERMD/VPERMPS _yvpermd table.
+func decodedX86EVEXVariableDwordPermuteInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 2 || p1&0x07 != 5 || (opcode != 0x36 && opcode != 0x16) {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x80 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W must be zero for VPERMD/VPERMPS")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits != 1 && vectorBits != 2 {
+		return Instr{}, 0, true, fmt.Errorf("VPERMD/VPERMPS EVEX form requires Y or Z width")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	if mode == 32 && maskNumber != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 VPERMD/VPERMPS mask form exceeds the Go assembler operand limit")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = 4
+	}
+	data, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	indicesNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if mode == 32 && vectorBits == 2 &&
+		(indicesNumber >= 8 || destinationNumber >= 8 ||
+			modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("386 Z register exceeds the Go assembler frontend's register class")
+	}
+	indices := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, indicesNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{data, indices}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	op := Op("VPERMD")
+	if opcode == 0x16 {
+		op = "VPERMPS"
+	}
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
+
+// decodedX86RandomInstruction recognizes the complete register-only
+// RDRAND/RDSEED/RDPID encoding family. RDPID shares RDSEED's ModRM extension
+// but requires F3 and has only a 32-bit destination. x/arch v0.14 drops the
+// operand from 64-bit RDRAND and cannot decode RDSEED or RDPID, so recover
+// these encodings before consulting the generic decoder.
+func decodedX86RandomInstruction(code []byte, mode int) (syntax string, length int, ok bool) {
+	i := 0
+	rdpid := len(code) > 0 && code[0] == 0xf3
+	if rdpid {
+		i++
+	}
+	bits := 32
+	if len(code) > i && code[i] == 0x66 {
+		bits = 16
+		i++
+	}
+	rex := byte(0)
+	if mode == 64 && len(code) > i && code[i] >= 0x40 && code[i] <= 0x4f {
+		rex = code[i]
+		i++
+		if rex&0x08 != 0 {
+			bits = 64
+		}
+	}
+	if len(code) < i+3 || code[i] != 0x0f || code[i+1] != 0xc7 {
+		return "", 0, false
+	}
+	modRM := code[i+2]
+	if modRM>>6 != 3 {
+		return "", 0, false
+	}
+	family := ""
+	switch modRM >> 3 & 7 {
+	case 6:
+		if rdpid {
+			return "", 0, false
+		}
+		family = "RDRAND"
+	case 7:
+		if rdpid {
+			if bits != 32 {
+				return "", 0, false
+			}
+			family = "RDPID"
+		} else {
+			family = "RDSEED"
+		}
+	default:
+		return "", 0, false
+	}
+	register := int(modRM & 7)
+	if mode == 64 && rex&0x01 != 0 {
+		register += 8
+	}
+	registerNames := [...]string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	if rdpid {
+		return fmt.Sprintf("RDPID %s", registerNames[register]), i + 3, true
+	}
+	width := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+	return fmt.Sprintf("%s%s %s", family, width, registerNames[register]), i + 3, true
+}
+
+// decodedX86VBROADCAST128Instruction recognizes the complete AVX2
+// VBROADCASTF128/I128 m128, Y family. x/arch v0.14 misdecodes these VEX
+// opcodes as legacy scalar instructions, so recover every ModRM/SIB memory
+// form before consulting the generic decoder.
+func decodedX86VBROADCAST128Instruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86VBROADCAST128InstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VBROADCAST128InstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	// VEX.256.66.0F38.W0 1A/5A /r. The unused encoded vvvv field must be
+	// 1111, so the complete third VEX byte is 0x7d.
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 2 || code[i+2] != 0x7d ||
+		(code[i+3] != 0x1a && code[i+3] != 0x5a) {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	vex1 := code[i+1]
+	rExt := int(^vex1>>7) & 1
+	xExt := int(^vex1>>6) & 1
+	bExt := int(^vex1>>5) & 1
+	destinationNumber := int(code[i+4]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	source, consumed, err := memory.scalar(code[i+4:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if source.Kind != OpMem {
+		return Instr{}, 0, true, fmt.Errorf("source must be m128 memory")
+	}
+	destination := Reg(fmt.Sprintf("Y%d", destinationNumber))
+	op := Op("VBROADCASTI128")
+	if code[i+3] == 0x1a {
+		op = "VBROADCASTF128"
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{source, {Kind: OpReg, Reg: destination}},
+		Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination),
+	}
+	return instruction, i + 4 + consumed, true, nil
+}
+
+// decodedX86SHAInstruction recognizes the complete Go 1.27 Intel SHA table:
+// SHA1NEXTE, SHA1MSG1/2, SHA1RNDS4, SHA256MSG1/2, and SHA256RNDS2. Older
+// x/arch decoders reject some raw 0F38 encodings used by minio/sha256-simd.
+func decodedX86SHAInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86SHAInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86SHAInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	rexPrefix := byte(0)
+	if mode == 64 && i < len(code) && code[i]&0xf0 == 0x40 {
+		rexPrefix = code[i]
+		i++
+	}
+	if len(code) < i+4 || code[i] != 0x0f {
+		return Instr{}, 0, false, nil
+	}
+
+	op := Op("")
+	encoding := uint16(code[i+1])<<8 | uint16(code[i+2])
+	if encoding < 0x38c8 || encoding > 0x38cd && encoding != 0x3acc {
+		return Instr{}, 0, false, nil // Negative filter; the shared table owns recognition.
+	}
+	for name, candidate := range x86SHAEncodings {
+		if encoding == candidate {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	immediate := encoding == 0x3acc
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := i + 3
+	modRM := code[modRMIndex]
+	rExt := int(rexPrefix>>2) & 1
+	xExt := int(rexPrefix>>1) & 1
+	bExt := int(rexPrefix) & 1
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && destinationNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+
+	var source Operand
+	consumed := 0
+	if modRM>>6 == 3 {
+		sourceNumber := int(modRM&7) + bExt*8
+		if mode == 32 && sourceNumber >= 8 {
+			return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+		}
+		source = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", sourceNumber))}
+		consumed = 1
+	} else {
+		var decodeErr error
+		source, consumed, decodeErr = memory.scalar(code[modRMIndex:], mode, bExt, xExt, segment, 1)
+		if decodeErr != nil {
+			return Instr{}, 0, true, decodeErr
+		}
+	}
+
+	args := []Operand{source, destination}
+	end := modRMIndex + consumed
+	if immediate {
+		if len(code) <= end {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate byte")
+		}
+		// SHA1RNDS4 consumes only the low two bits. Normalize the raw byte to
+		// Go's Yu2 operand class so the recovered instruction remains valid.
+		args = []Operand{{Kind: OpImm, Imm: int64(code[end] & 3)}, source, destination}
+		end++
+	} else if op == "SHA256RNDS2" {
+		args = []Operand{{Kind: OpReg, Reg: Reg("X0")}, source, destination}
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, end, true, nil
+}
+
+// decodedX86BLSInstruction recognizes the complete BMI1 BLSI/BLSMSK/BLSR
+// register and ModRM/SIB memory families. x/arch v0.14 reports these VEX.NDD
+// encodings as unknown AVX opcodes, so recover them before generic decoding.
+func decodedX86BLSInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86BLSInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86BLSInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 2 || code[i+2]&0x07 != 0 || code[i+3] != 0xf3 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	vex1, vex2 := code[i+1], code[i+2]
+	xExt := int(^vex1>>6) & 1
+	bExt := int(^vex1>>5) & 1
+	width64 := vex2&0x80 != 0
+	destinationNumber := int(^vex2>>3) & 15
+	modRM := code[i+4]
+	family := ""
+	switch modRM >> 3 & 7 {
+	case 1:
+		family = "BLSR"
+	case 2:
+		family = "BLSMSK"
+	case 3:
+		family = "BLSI"
+	default:
+		return Instr{}, 0, true, fmt.Errorf("invalid opcode extension /%d", modRM>>3&7)
+	}
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	if mode == 32 && (xExt != 0 || bExt != 0 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended register in 32-bit mode")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	source, consumed, err := memory.scalar(code[i+4:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destination, valid := decodedX86GeneralRegister(destinationNumber)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid destination register %d", destinationNumber)
+	}
+	op := Op(family + "L")
+	if width64 && mode == 64 {
+		op = Op(family + "Q")
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{source, {Kind: OpReg, Reg: destination}},
+		Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination),
+	}
+	return instruction, i + 4 + consumed, true, nil
+}
+
+// decodedX86MULXInstruction recognizes the complete BMI2 MULX register and
+// ModRM/SIB memory family. x/arch rejects this VEX.NDD encoding even though
+// Go's assembler and the semantic lowerer support MULXL/MULXQ.
+func decodedX86MULXInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86MULXInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86MULXInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i, segment, addressOverride := x86RawSegmentPrefixes(code)
+	if len(code) < i+5 || code[i] != 0xc4 || code[i+1]&0x1f != 2 || code[i+2]&0x07 != 3 || code[i+3] != 0xf6 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	vex1, vex2 := code[i+1], code[i+2]
+	if vex2&0x04 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.L must be zero")
+	}
+	rExt := int(^vex1>>7) & 1
+	xExt := int(^vex1>>6) & 1
+	bExt := int(^vex1>>5) & 1
+	width64 := vex2&0x80 != 0
+	lowRegister := int(^vex2>>3) & 15
+	modRM := code[i+4]
+	highRegister := int(modRM>>3&7) + rExt*8
+	// Native-PC observation ignores W outside long mode, as the actual ISA
+	// does. The zero-value ordinary raw decoder retains its old role/width
+	// restriction; a byte boundary cannot broaden that source contract.
+	if mode == 32 && (width64 && !memory.physicalPC || rExt != 0 || xExt != 0 || bExt != 0 || lowRegister >= 8 || highRegister >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("64-bit width or extended register in 32-bit mode")
+	}
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	source, consumed, err := memory.scalar(code[i+4:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	low, valid := decodedX86GeneralRegister(lowRegister)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid low destination register %d", lowRegister)
+	}
+	high, valid := decodedX86GeneralRegister(highRegister)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid high destination register %d", highRegister)
+	}
+	op := Op("MULXL")
+	if width64 && mode == 64 {
+		op = "MULXQ"
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{source, {Kind: OpReg, Reg: low}, {Kind: OpReg, Reg: high}},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, source.String(), low, high),
+	}
+	return instruction, i + 4 + consumed, true, nil
+}
+
+func decodedX86VEXRMSource(code []byte, mode, bExt, xExt int, segment Reg) (Operand, int, error) {
+	return decodedX86RMSource(code, mode, bExt, xExt, segment, 1)
+}
+
+func decodedX86RMSource(code []byte, mode, bExt, xExt int, segment Reg, disp8Scale int) (Operand, int, error) {
+	return decodedX86RMSourceWithPC(code, mode, bExt, xExt, segment, disp8Scale, false)
+}
+
+func decodedX86RMSourceWithPC(code []byte, mode, bExt, xExt int, segment Reg, disp8Scale int, physicalPC bool) (Operand, int, error) {
+	if len(code) == 0 {
+		return Operand{}, 0, fmt.Errorf("missing ModRM byte")
+	}
+	if disp8Scale <= 0 {
+		return Operand{}, 0, fmt.Errorf("invalid disp8 scale %d", disp8Scale)
+	}
+	modRM := code[0]
+	mod := int(modRM >> 6)
+	rm := int(modRM & 7)
+	if mod == 3 {
+		register, ok := decodedX86GeneralRegister(rm + bExt*8)
+		if !ok || mode == 32 && rm+bExt*8 >= 8 {
+			return Operand{}, 0, fmt.Errorf("invalid source register")
+		}
+		return Operand{Kind: OpReg, Reg: register}, 1, nil
+	}
+
+	mem := MemRef{Segment: segment}
+	consumed := 1
+	readDisp8 := func() error {
+		if len(code) < consumed+1 {
+			return fmt.Errorf("truncated disp8")
+		}
+		mem.Off = int64(int8(code[consumed])) * int64(disp8Scale)
+		consumed++
+		return nil
+	}
+	readDisp32 := func() error {
+		if len(code) < consumed+4 {
+			return fmt.Errorf("truncated disp32")
+		}
+		mem.Off = int64(int32(binary.LittleEndian.Uint32(code[consumed : consumed+4])))
+		consumed += 4
+		return nil
+	}
+
+	if rm == 4 {
+		if len(code) < consumed+1 {
+			return Operand{}, 0, fmt.Errorf("truncated SIB byte")
+		}
+		sib := code[consumed]
+		consumed++
+		indexNumber := int(sib>>3&7) + xExt*8
+		if int(sib>>3&7) != 4 || xExt != 0 {
+			index, ok := decodedX86GeneralRegister(indexNumber)
+			if !ok || mode == 32 && indexNumber >= 8 {
+				return Operand{}, 0, fmt.Errorf("invalid SIB index register")
+			}
+			mem.Index = index
+			mem.Scale = int64(1 << (sib >> 6))
+		}
+		baseBits := int(sib & 7)
+		if mod == 0 && baseBits == 5 {
+			if err := readDisp32(); err != nil {
+				return Operand{}, 0, err
+			}
+		} else {
+			baseNumber := baseBits + bExt*8
+			base, ok := decodedX86GeneralRegister(baseNumber)
+			if !ok || mode == 32 && baseNumber >= 8 {
+				return Operand{}, 0, fmt.Errorf("invalid SIB base register")
+			}
+			mem.Base = base
+		}
+	} else if mod == 0 && rm == 5 {
+		if mode == 64 {
+			if !physicalPC {
+				return Operand{}, 0, fmt.Errorf("RIP-relative source is not source-layout safe")
+			}
+			mem.Base = "RIP"
+		}
+		if err := readDisp32(); err != nil {
+			return Operand{}, 0, err
+		}
+	} else {
+		baseNumber := rm + bExt*8
+		base, ok := decodedX86GeneralRegister(baseNumber)
+		if !ok || mode == 32 && baseNumber >= 8 {
+			return Operand{}, 0, fmt.Errorf("invalid base register")
+		}
+		mem.Base = base
+	}
+
+	switch mod {
+	case 1:
+		if err := readDisp8(); err != nil {
+			return Operand{}, 0, err
+		}
+	case 2:
+		if err := readDisp32(); err != nil {
+			return Operand{}, 0, err
+		}
+	}
+	return Operand{Kind: OpMem, Mem: mem}, consumed, nil
+}
+
+func decodedX86GeneralRegister(number int) (Reg, bool) {
+	names := [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	if number < 0 || number >= len(names) {
+		return "", false
+	}
+	return names[number], true
+}
+
+// x86RawRetpolineTarget recognizes the complete amd64 RETPOLINE(reg) byte
+// family emitted by the Go runtime. Its local CALL and backward PAUSE loop are
+// a speculative-execution barrier; architecturally the sequence replaces the
+// temporary return address with reg and returns to it, which is an indirect
+// tail jump. Requiring every fixed byte prevents arbitrary PC-relative raw
+// control flow from being accepted through this path.
+func x86RawRetpolineTarget(code []byte) (Reg, bool) {
+	if len(code) != 14 ||
+		code[0] != 0xe8 || code[1] != 0x04 || code[2] != 0 || code[3] != 0 || code[4] != 0 ||
+		code[5] != 0xf3 || code[6] != 0x90 || code[7] != 0xeb || code[8] != 0xfc ||
+		(code[9] != 0x48 && code[9] != 0x4c) || code[10] != 0x89 || code[11]&0xc7 != 0x04 ||
+		code[12] != 0x24 || code[13] != 0xc3 {
+		return "", false
+	}
+	register := int(code[11]>>3&7) + int(code[9]>>2&1)*8
+	if register == 4 {
+		return "", false
+	}
+	names := [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	return names[register], true
+}
+
+// Go's assembler omits Intel's N for these no-wait x87 encodings. Keep the
+// entire control/environment alias family on the existing named lowerers.
+var x86RawX87ControlAliases = map[x86asm.Op]Op{
+	x86asm.FNCLEX:  "FCLEX",
+	x86asm.FNINIT:  "FINIT",
+	x86asm.FNSAVE:  "FSAVE",
+	x86asm.FNSTCW:  "FSTCW",
+	x86asm.FNSTENV: "FSTENV",
+	x86asm.FNSTSW:  "FSTSW",
+}
+
+func decodedX86GoSyntax(inst x86asm.Inst, encoding []byte) (string, error) {
+	if err := decodedX86PrefixError(inst); err != nil {
+		return "", err
+	}
+	for _, argument := range inst.Args {
+		if memory, ok := argument.(x86asm.Mem); ok && memory.Base == x86asm.EIP && inst.Op != x86asm.NOP {
+			// The pinned decoder leaves PCRel unset for 67-prefixed EIP
+			// addressing. Its wrapped native instruction address is not a
+			// numerical GP input or a proved source-group RIP relocation.
+			return "", fmt.Errorf("%w: raw x86 EIP-relative memory requires its native instruction address", ErrProbeNeedsContext)
+		}
+	}
+	inst = normalizeDecodedX86MemoryDisplacements(inst)
+	inst = normalizeDecodedX86LEASegments(inst)
+	for _, prefix := range inst.Prefix {
+		if !prefix.IsVEX() {
+			continue
+		}
+		// The pinned x/arch decoder recognizes only these VEX operations.
+		// For other VEX bytes it can incorrectly return an ordinary legacy
+		// opcode with a successful status and the wrong instruction length.
+		// Family-specific decoders above must handle those encodings; never
+		// let generic fallback turn a missing family into valid but wrong IR.
+		switch inst.Op {
+		case x86asm.VMOVDQA, x86asm.VMOVDQU, x86asm.VMOVNTDQ, x86asm.VMOVNTDQA:
+		default:
+			return "", fmt.Errorf("unrecognized VEX instruction decoded as legacy %s", inst.Op)
+		}
+		break
+	}
+	if syntax, recognized, err := decodedX86FarReturn(inst); recognized {
+		return syntax, err
+	}
+	syntax := x86asm.GoSyntax(inst, 0, nil)
+	replaceOp := func(op string) {
+		// A repeater is a separate pseudo-instruction; an actual segment
+		// prefix can precede the mnemonic. Never replace either prefix
+		// with an alias and move the real opcode into its operand list.
+		start := strings.LastIndexByte(syntax, ';') + 1
+		for start < len(syntax) && syntax[start] == ' ' {
+			start++
+		}
+		for _, prefix := range inst.Prefix {
+			switch prefix & 0xff {
+			case x86asm.PrefixES, x86asm.PrefixCS, x86asm.PrefixSS, x86asm.PrefixDS, x86asm.PrefixFS, x86asm.PrefixGS:
+				if strings.HasPrefix(syntax[start:], prefix.String()+" ") {
+					start += len(prefix.String()) + 1
+				}
+			}
+		}
+		end := strings.IndexByte(syntax[start:], ' ')
+		if end < 0 {
+			end = len(syntax)
+		} else {
+			end += start
+		}
+		syntax = syntax[:start] + op + syntax[end:]
+	}
+	if op, ok := decodedX86CacheLineWriteback(encoding); ok {
+		replaceOp(op)
+		return syntax, nil
+	}
+	if op, ok := x86RawX87ControlAliases[inst.Op]; ok {
+		// The Go memory mnemonics encode the 32-bit environment layout.
+		// Mapping a 66-prefixed 14/94-byte legacy layout to them would change
+		// the memory footprint. Keep that unsupported format explicit.
+		if inst.DataSize == 16 && (inst.Op == x86asm.FNSAVE || inst.Op == x86asm.FNSTENV) {
+			return "", fmt.Errorf("raw %s uses a 16-bit environment layout not represented by Go %s", inst.Op, op)
+		}
+		replaceOp(string(op))
+		return syntax, nil
+	}
+	if op, recognized, err := decodedX86X87EnvironmentLoad(inst, encoding); recognized {
+		if err != nil {
+			return "", err
+		}
+		replaceOp(string(op))
+		return syntax, nil
+	}
+
+	switch inst.Op {
+	case x86asm.RDFSBASE, x86asm.RDGSBASE, x86asm.WRFSBASE, x86asm.WRGSBASE:
+		// x/arch prints widthless Intel names. Reuse the complete named
+		// FSGSBASE grammar, selecting L/Q from the actual GPR: an ignored
+		// 66 prefix can set DataSize=16 while the operand remains 32-bit.
+		register, ok := inst.Args[0].(x86asm.Reg)
+		bits := decodedX86RegisterBits(register)
+		if !ok || inst.Mode != 64 || (bits != 32 && bits != 64) {
+			return "", fmt.Errorf("raw %s requires a 32/64-bit GPR in 64-bit mode", inst.Op)
+		}
+		for _, extra := range inst.Args[1:] {
+			if extra != nil {
+				return "", fmt.Errorf("raw %s requires exactly one register", inst.Op)
+			}
+		}
+		for _, prefix := range inst.Prefix {
+			if prefix&0xff == x86asm.PrefixLOCK || prefix&x86asm.PrefixInvalid != 0 {
+				return "", fmt.Errorf("raw %s has an invalid prefix %s", inst.Op, prefix)
+			}
+		}
+		// Segment/address/operand overrides do not affect this register-only
+		// family. Clear them only after rejecting invalid (not ignored) ones.
+		inst.Prefix = x86asm.Prefixes{}
+		syntax = x86asm.GoSyntax(inst, 0, nil)
+		width := "L"
+		if bits == 64 {
+			width = "Q"
+		}
+		replaceOp(inst.Op.String() + width)
+	case x86asm.INC, x86asm.DEC:
+		bits := 0
+		switch destination := inst.Args[0].(type) {
+		case x86asm.Reg:
+			bits = decodedX86RegisterBits(destination)
+		case x86asm.Mem:
+			bits = inst.MemBytes * 8
+		}
+		width := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[bits]
+		if width == "" {
+			return "", fmt.Errorf("raw %s has unsupported destination width %d", inst.Op, bits)
+		}
+		replaceOp(inst.Op.String() + width)
+	case x86asm.SLDT, x86asm.STR, x86asm.SMSW:
+		// x/arch prints the unsuffixed Intel names, while Go's descriptor
+		// grammar selects the destination width in the mnemonic. Memory
+		// destinations are always the architectural 16-bit selector/status.
+		bits := 0
+		switch destination := inst.Args[0].(type) {
+		case x86asm.Mem:
+			bits = 16
+		case x86asm.Reg:
+			bits = decodedX86RegisterBits(destination)
+		}
+		width := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+		if width == "" {
+			return "", fmt.Errorf("raw %s has unsupported destination width %d", inst.Op, bits)
+		}
+		replaceOp(inst.Op.String() + width)
+	case x86asm.PSHUFW:
+		// Physical imm8 bits have no signedness, but Go's complete ymshuf
+		// source table requires Yi8. Render that signed representative in
+		// both modes; the 32-bit generic printer otherwise masks it unsigned.
+		selector, ok := inst.Args[2].(x86asm.Imm)
+		if !ok || selector < 0 || selector > 255 || inst.Args[3] != nil {
+			return "", fmt.Errorf("raw PSHUFW expected an 8-bit selector")
+		}
+		firstSpace := strings.IndexByte(syntax, ' ')
+		firstComma := strings.IndexByte(syntax, ',')
+		if firstSpace < 0 || firstComma < firstSpace {
+			return "", fmt.Errorf("raw PSHUFW has malformed operands")
+		}
+		syntax = syntax[:firstSpace+1] + fmt.Sprintf("$%d", int8(selector)) + syntax[firstComma:]
+	case x86asm.SHLD, x86asm.SHRD:
+		// Go encodes double shifts with the three-operand SHL/SHR form,
+		// whose immediate class is signed Yi8 (single shifts use Yu8).
+		if count, ok := inst.Args[2].(x86asm.Imm); ok {
+			firstSpace := strings.IndexByte(syntax, ' ')
+			firstComma := strings.IndexByte(syntax, ',')
+			if firstSpace < 0 || firstComma < firstSpace {
+				return "", fmt.Errorf("raw %s has malformed double-shift operands", inst.Op)
+			}
+			syntax = syntax[:firstSpace+1] + fmt.Sprintf("$%d", int8(count)) + syntax[firstComma:]
+		}
+	case x86asm.CMPPD, x86asm.CMPPS, x86asm.CMPSD_XMM, x86asm.CMPSS:
+		predicate, ok := inst.Args[2].(x86asm.Imm)
+		if !ok || predicate < 0 || predicate > 255 || inst.Args[3] != nil {
+			return "", fmt.Errorf("raw %s expected an unsigned 8-bit predicate", inst.Op)
+		}
+		// Go's legacy yxcmpi table places the signed predicate last, unlike
+		// both Intel syntax and the vector VCMP family. Reorder typed args
+		// before rendering, preserving register and segment/address details.
+		inst.Args[0], inst.Args[1], inst.Args[2] = x86asm.Imm(int8(predicate)), inst.Args[0], inst.Args[1]
+		syntax = x86asm.GoSyntax(inst, 0, nil)
+		// The 32-bit printer masks negative immediates to uint32. The Go
+		// encoder requires a signed byte, not that unsigned spelling.
+		syntax = syntax[:strings.LastIndexByte(syntax, ',')+1] + fmt.Sprintf(" $%d", int8(predicate))
+		if inst.Op == x86asm.CMPSD_XMM {
+			replaceOp("CMPSD")
+		}
+		return syntax, nil
+	case x86asm.NOP:
+		// The decoder prints NOPL/NOPW according to the encoded data size.
+		// The address operand of a multi-byte x86 NOP is not read, so the
+		// semantic instruction is the operand-free Plan 9 NOP.
+		return "NOP", nil
+	case x86asm.MOVSXD:
+		return decodedX86MOVSXD(inst, encoding)
+	case x86asm.MOVD:
+		// Intel MOVD transfers 32 bits. Go's MOVD spelling instead aliases
+		// AMOVQ and transfers 64 bits for XMM/memory forms.
+		replaceOp("MOVL")
+	case x86asm.MOVDQA:
+		replaceOp("MOVO")
+	case x86asm.MOVDQU:
+		replaceOp("MOVOU")
+	case x86asm.MOVNTDQ:
+		// Go's assembler calls the legacy 128-bit non-temporal store MOVNTO.
+		// MOVNTDQ is reserved for the VEX/EVEX VMOVNTDQ spelling.
+		replaceOp("MOVNTO")
+	case x86asm.MOVSD_XMM:
+		replaceOp("MOVSD")
+	case x86asm.CVTDQ2PS, x86asm.CVTPI2PS:
+		// Go's yxcvm2 table shares CVTPL2PS across SSE X and MMX M sources.
+		replaceOp("CVTPL2PS")
+	case x86asm.CVTPS2DQ, x86asm.CVTPS2PI:
+		// Go's yxcvm1 table likewise names both destinations CVTPS2PL.
+		replaceOp("CVTPS2PL")
+	case x86asm.CVTTPS2DQ, x86asm.CVTTPS2PI:
+		replaceOp("CVTTPS2PL")
+	case x86asm.CVTDQ2PD, x86asm.CVTPI2PD:
+		replaceOp("CVTPL2PD")
+	case x86asm.CVTPD2DQ, x86asm.CVTPD2PI:
+		replaceOp("CVTPD2PL")
+	case x86asm.CVTTPD2DQ, x86asm.CVTTPD2PI:
+		replaceOp("CVTTPD2PL")
+	case x86asm.MUL, x86asm.IMUL, x86asm.DIV, x86asm.IDIV:
+		argumentCount := 0
+		for _, argument := range inst.Args {
+			if argument != nil {
+				argumentCount++
+			}
+		}
+		if argumentCount == 1 {
+			bits := inst.MemBytes * 8
+			if source, ok := inst.Args[0].(x86asm.Reg); ok {
+				bits = decodedX86RegisterBits(source)
+			}
+			width := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[bits]
+			if width == "" {
+				return "", fmt.Errorf("%s has unsupported source width %d", inst.Op, bits)
+			}
+			replaceOp(inst.Op.String() + width)
+		} else if inst.Op == x86asm.IMUL && argumentCount == 3 {
+			destination, ok := inst.Args[0].(x86asm.Reg)
+			if !ok {
+				return "", fmt.Errorf("three-operand IMUL destination is not a register")
+			}
+			width := map[int]string{16: "W", 32: "L", 64: "Q"}[decodedX86RegisterBits(destination)]
+			if width == "" {
+				return "", fmt.Errorf("three-operand IMUL has unsupported destination width %d", decodedX86RegisterBits(destination))
+			}
+			replaceOp("IMUL3" + width)
+		}
+	case x86asm.BSWAP:
+		destination, ok := inst.Args[0].(x86asm.Reg)
+		if !ok {
+			return "", fmt.Errorf("BSWAP destination is not a register")
+		}
+		width := map[int]string{32: "L", 64: "Q"}[decodedX86RegisterBits(destination)]
+		if width == "" {
+			return "", fmt.Errorf("BSWAP has unsupported destination width %d", decodedX86RegisterBits(destination))
+		}
+		replaceOp("BSWAP" + width)
+	case x86asm.MOVBE:
+		bits := inst.MemBytes * 8
+		for _, operand := range inst.Args {
+			if register, ok := operand.(x86asm.Reg); ok {
+				bits = decodedX86RegisterBits(register)
+				break
+			}
+		}
+		width := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+		if width == "" {
+			return "", fmt.Errorf("MOVBE has unsupported operand width %d", bits)
+		}
+		replaceOp("MOVBE" + width)
+	case x86asm.LZCNT, x86asm.TZCNT:
+		// Go names each bit-count width explicitly. x/arch prints the
+		// widthless Intel mnemonic, even for 16- and 64-bit encodings.
+		destination, ok := inst.Args[0].(x86asm.Reg)
+		if !ok {
+			return "", fmt.Errorf("%s destination is not a register", inst.Op)
+		}
+		bits := decodedX86RegisterBits(destination)
+		width := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+		if width == "" {
+			return "", fmt.Errorf("%s has unsupported destination width %d", inst.Op, bits)
+		}
+		replaceOp(inst.Op.String() + width)
+	case x86asm.CVTSI2SS, x86asm.CVTSI2SD:
+		sourceBits := inst.MemBytes * 8
+		if source, ok := inst.Args[1].(x86asm.Reg); ok {
+			sourceBits = decodedX86RegisterBits(source)
+		}
+		sourceWidth := map[int]string{32: "L", 64: "Q"}[sourceBits]
+		if sourceWidth == "" {
+			return "", fmt.Errorf("%s has unsupported decoded source width %d", inst.Op, sourceBits)
+		}
+		resultWidth := "SS"
+		if inst.Op == x86asm.CVTSI2SD {
+			resultWidth = "SD"
+		}
+		replaceOp("CVTS" + sourceWidth + "2" + resultWidth)
+	case x86asm.CVTSS2SI, x86asm.CVTSD2SI, x86asm.CVTTSS2SI, x86asm.CVTTSD2SI:
+		// x/arch prints Intel's SI destination stem (and, in some memory
+		// cases, derives the wrong Plan 9 width). Go's assembler names this
+		// legacy family CVT{T}{SS,SD}2S{L,Q}. Recover the destination width
+		// from REX.W, which is the architectural selector for all four ops.
+		outputWidth := "L"
+		if inst.Mode == 64 {
+			for _, prefix := range inst.Prefix {
+				if prefix.IsREX() && prefix&x86asm.PrefixREXW != 0 {
+					outputWidth = "Q"
+					break
+				}
+			}
+		}
+		name := map[x86asm.Op]string{
+			x86asm.CVTSS2SI:  "CVTSS2S",
+			x86asm.CVTSD2SI:  "CVTSD2S",
+			x86asm.CVTTSS2SI: "CVTTSS2S",
+			x86asm.CVTTSD2SI: "CVTTSD2S",
+		}[inst.Op]
+		replaceOp(name + outputWidth)
+	case x86asm.PACKSSDW:
+		replaceOp("PACKSSLW")
+	case x86asm.PCMPEQD:
+		replaceOp("PCMPEQL")
+	case x86asm.PCMPGTD:
+		replaceOp("PCMPGTL")
+	case x86asm.PMADDWD:
+		replaceOp("PMADDWL")
+	case x86asm.PMULUDQ:
+		replaceOp("PMULULQ")
+	case x86asm.PSLLD:
+		replaceOp("PSLLL")
+	case x86asm.PSRAD:
+		replaceOp("PSRAL")
+	case x86asm.PSRLD:
+		replaceOp("PSRLL")
+	case x86asm.PSUBD:
+		replaceOp("PSUBL")
+	case x86asm.PUNPCKHDQ:
+		replaceOp("PUNPCKHLQ")
+	case x86asm.PUNPCKHWD:
+		replaceOp("PUNPCKHWL")
+	case x86asm.PUNPCKLDQ:
+		replaceOp("PUNPCKLLQ")
+	case x86asm.PUNPCKLWD:
+		replaceOp("PUNPCKLWL")
+	case x86asm.CRC32:
+		bits := inst.MemBytes * 8
+		if source, ok := inst.Args[1].(x86asm.Reg); ok {
+			bits = decodedX86RegisterBits(source)
+		}
+		width := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[bits]
+		if width == "" {
+			return "", fmt.Errorf("CRC32 has unsupported decoded source width %d", bits)
+		}
+		replaceOp("CRC32" + width)
+	case x86asm.MOVSX, x86asm.MOVZX:
+		dst, ok := inst.Args[0].(x86asm.Reg)
+		if !ok {
+			return "", fmt.Errorf("%s destination is not a register", inst.Op)
+		}
+		destinationBits := decodedX86RegisterBits(dst)
+		sourceBits := inst.MemBytes * 8
+		if source, ok := inst.Args[1].(x86asm.Reg); ok {
+			sourceBits = decodedX86RegisterBits(source)
+		}
+		widthLetter := func(bits int) string {
+			switch bits {
+			case 8:
+				return "B"
+			case 16:
+				return "W"
+			case 32:
+				return "L"
+			case 64:
+				return "Q"
+			default:
+				return ""
+			}
+		}
+		sourceLetter := widthLetter(sourceBits)
+		destinationLetter := widthLetter(destinationBits)
+		if sourceLetter == "" || destinationLetter == "" {
+			return "", fmt.Errorf("%s has unsupported decoded widths %d -> %d", inst.Op, sourceBits, destinationBits)
+		}
+		extension := "SX"
+		if inst.Op == x86asm.MOVZX {
+			extension = "ZX"
+		}
+		if sourceBits == 16 && destinationBits == 16 {
+			name := "MOVSWW"
+			if inst.Op == x86asm.MOVZX {
+				name = "MOVZWW"
+			}
+			replaceOp(name)
+		} else {
+			replaceOp("MOV" + sourceLetter + destinationLetter + extension)
+		}
+	}
+	normalizeDecodedX86GoOpcode(inst, &syntax, replaceOp)
+	syntax = normalizeDecodedX86SegmentMemorySyntax(syntax)
+	return syntax, nil
+}
+
+// The pinned x/arch decoder retains ModR/M/SIB disp32 as an unsigned
+// magnitude. Rendering that value as a named Go address changes 64-bit
+// arithmetic and violates Go's signed-displacement checks. Preserve the
+// physical field's sign before every opcode-specific rendering path.
+// MOV A0-A3 instead contains a full absolute moffs address: it must never
+// be narrowed or sign-extended as though it were a ModR/M displacement.
+func normalizeDecodedX86MemoryDisplacements(inst x86asm.Inst) x86asm.Inst {
+	if inst.AddrSize != 32 && inst.AddrSize != 64 {
+		return inst
+	}
+	if opcode := byte(inst.Opcode >> 24); opcode >= 0xa0 && opcode <= 0xa3 {
+		return inst
+	}
+	for index, argument := range inst.Args {
+		if memory, ok := argument.(x86asm.Mem); ok {
+			memory.Disp = int64(int32(memory.Disp))
+			inst.Args[index] = memory
+		}
+	}
+	return inst
+}
+
+// LEA computes only the effective offset. All six segment override prefixes
+// are architecturally irrelevant to it, unlike an actual memory load/store.
+func normalizeDecodedX86LEASegments(inst x86asm.Inst) x86asm.Inst {
+	if inst.Op != x86asm.LEA {
+		return inst
+	}
+	for index, argument := range inst.Args {
+		if memory, ok := argument.(x86asm.Mem); ok {
+			memory.Segment = 0
+			inst.Args[index] = memory
+		}
+	}
+	var prefixes x86asm.Prefixes
+	next := 0
+	for _, prefix := range inst.Prefix {
+		if prefix == 0 {
+			break
+		}
+		switch byte(prefix) {
+		case 0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65:
+			continue
+		}
+		prefixes[next] = prefix
+		next++
+	}
+	inst.Prefix = prefixes
+	return inst
+}
+
+// x/arch prints a raw segment override as GS:0x30 or GS:0x30(AX). The
+// Plan 9 parser represents those same addresses as 48(GS) and 48(AX)(GS).
+// Rewrite only FS/GS operands; other segment and RIP-relative forms retain
+// their original spelling so unsupported address semantics fail closed.
+func normalizeDecodedX86SegmentMemorySyntax(syntax string) string {
+	space := strings.IndexByte(syntax, ' ')
+	if space < 0 {
+		return syntax
+	}
+	args := splitTopLevelCSV(syntax[space+1:])
+	for i, arg := range args {
+		arg = strings.TrimSpace(arg)
+		segment := ""
+		switch {
+		case strings.HasPrefix(arg, "FS:"):
+			segment = "FS"
+		case strings.HasPrefix(arg, "GS:"):
+			segment = "GS"
+		default:
+			continue
+		}
+		address := strings.TrimPrefix(arg, segment+":")
+		open := strings.IndexByte(address, '(')
+		offset := address
+		base := ""
+		if open >= 0 {
+			offset = address[:open]
+			base = address[open:]
+		}
+		if offset == "" {
+			offset = "0"
+		}
+		value, err := strconv.ParseInt(offset, 0, 64)
+		if err != nil || strings.Contains(base, "(IP)") || strings.Contains(base, "(RIP)") {
+			continue
+		}
+		args[i] = fmt.Sprintf("%d%s(%s)", value, base, segment)
+	}
+	return syntax[:space+1] + strings.Join(args, ", ")
+}
+
+// normalizeDecodedX86GoOpcode bridges the architectural names emitted by
+// x/arch's decoder and the semantic names/classes used by Go 1.27's
+// cmd/internal/obj/x86 tables. Go's assembler intentionally uses aliases such
+// as SETOS and CMOVQLE, while x/arch prints Intel names such as SETO and
+// CMOVLE. x/arch also prints the byte-immediate ADD opcode as ADDL even when
+// its destination is an 8-bit register; that spelling is rejected by Go's
+// Yml/Ymb operand classes and must be corrected from the decoded operands.
+func normalizeDecodedX86GoOpcode(inst x86asm.Inst, syntax *string, replaceOp func(string)) {
+	op := strings.ToUpper(inst.Op.String())
+	setAliases := map[string]string{
+		"SETA": "SETHI", "SETAE": "SETCC", "SETB": "SETCS", "SETBE": "SETLS",
+		"SETE": "SETEQ", "SETG": "SETGT", "SETGE": "SETGE", "SETL": "SETLT",
+		"SETLE": "SETLE", "SETNE": "SETNE", "SETNO": "SETOC", "SETNP": "SETPC",
+		"SETNS": "SETPL", "SETO": "SETOS", "SETP": "SETPS", "SETS": "SETMI",
+	}
+	if alias, ok := setAliases[op]; ok {
+		replaceOp(alias)
+		// GoSyntax deliberately omits the B suffix for extended byte registers
+		// (for example it prints SETO R9). Reconstruct the decoded register's
+		// actual byte spelling before reparsing the instruction.
+		if len(inst.Args) > 0 {
+			if reg, ok := inst.Args[0].(x86asm.Reg); ok {
+				*syntax = alias + " " + reg.String()
+			}
+		}
+		return
+	}
+
+	cmovConditions := map[string]string{
+		"CMOVA": "HI", "CMOVAE": "CC", "CMOVB": "CS", "CMOVBE": "LS",
+		"CMOVE": "EQ", "CMOVG": "GT", "CMOVGE": "GE", "CMOVL": "LT",
+		"CMOVLE": "LE", "CMOVNE": "NE", "CMOVNO": "OC", "CMOVNP": "PC",
+		"CMOVNS": "PL", "CMOVO": "OS", "CMOVP": "PS", "CMOVS": "MI",
+	}
+	if condition, ok := cmovConditions[op]; ok {
+		bits := 0
+		for i := 0; i < 2 && i < len(inst.Args); i++ {
+			if reg, ok := inst.Args[i].(x86asm.Reg); ok {
+				if n := decodedX86RegisterBits(reg); n > bits {
+					bits = n
+				}
+			}
+		}
+		if bits == 0 {
+			bits = inst.MemBytes * 8
+		}
+		width := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+		if width != "" {
+			replaceOp("CMOV" + width + condition)
+		}
+		return
+	}
+
+	widthOpcode := decodedX86WidthOpcode(op)
+	if widthOpcode == "" || len(inst.Args) == 0 {
+		return
+	}
+	dstBits := 0
+	if reg, ok := inst.Args[0].(x86asm.Reg); ok {
+		dstBits = decodedX86RegisterBits(reg)
+	} else if _, ok := inst.Args[0].(x86asm.Mem); ok {
+		dstBits = inst.MemBytes * 8
+	}
+	width := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[dstBits]
+	if width != "" {
+		replaceOp(widthOpcode + width)
+	}
+}
+
+func decodedX86WidthOpcode(op string) string {
+	switch op {
+	case "ADD", "ADC", "SBB", "SUB", "AND", "OR", "XOR", "CMP", "TEST":
+		return op
+	case "ROL", "ROR", "RCL", "RCR", "SHL", "SHR", "SAR":
+		return op
+	case "SHLD":
+		return "SHL"
+	case "SHRD":
+		return "SHR"
+	default:
+		return ""
+	}
+}
+
+// Go 1.27 names 0F 18 /0-/3 but not the newer /4, /6 and /7 cache
+// hints. Decode their complete ModRM memory forms directly; /5 and register
+// operands are not instructions. RIP-relative addresses remain rejected by
+// decodedX86RMSource because their byte layout cannot be inferred here.
+func decodedX86ExtendedPrefetchInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segment := Reg("")
+	rex := byte(0)
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			rex = 0
+		case 0x65:
+			segment = GS
+			rex = 0
+		case 0x66:
+			rex = 0
+		case 0x67:
+			addressOverride = true
+			rex = 0
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				i++
+				continue
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	if len(code) < i+3 || code[i] != 0x0f || code[i+1] != 0x18 {
+		return Instr{}, 0, false, nil
+	}
+	extension := code[i+2] >> 3 & 7
+	op := Op("")
+	switch extension {
+	case 4:
+		op = "PREFETCHRST2"
+	case 6:
+		op = "PREFETCHIT1"
+	case 7:
+		op = "PREFETCHIT0"
+	default:
+		return Instr{}, 0, false, nil
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if code[i+2]>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("%s requires a memory operand", op)
+	}
+	address, consumed, err := decodedX86RMSource(code[i+2:], mode, int(rex&1), int(rex>>1&1), segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	return Instr{Op: op, Args: []Operand{address}, Raw: fmt.Sprintf("%s %s", op, address.String())}, i + 2 + consumed, true, nil
+}
+
+// decodedX86CacheLineWritebackInstruction recognizes the complete raw
+// CLFLUSH/CLFLUSHOPT/CLWB memory family before x/arch's generic decoder. In
+// particular, generated assembly in github.com/wencode/hack places a REX
+// prefix before the mandatory 0x66 prefix, which x/arch v0.14 rejects even
+// though x86 hardware accepts the prefix sequence.
+func decodedX86CacheLineWritebackInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	hasDataSizePrefix := false
+	addressOverride := false
+	segment := Reg("")
+	rex := byte(0)
+	hasREX := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			// A legacy prefix after REX makes that REX byte ineffective. Only
+			// the REX prefix immediately preceding the opcode escape applies.
+			rex = 0
+			hasREX = false
+			segment = FS
+			i++
+		case 0x65:
+			rex = 0
+			hasREX = false
+			segment = GS
+			i++
+		case 0x66:
+			rex = 0
+			hasREX = false
+			hasDataSizePrefix = true
+			i++
+		case 0x67:
+			rex = 0
+			hasREX = false
+			addressOverride = true
+			i++
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				hasREX = true
+				i++
+				continue
+			}
+			goto opcode
+		}
+	}
+
+opcode:
+	if len(code) < i+3 || code[i] != 0x0f || code[i+1] != 0xae {
+		return Instr{}, 0, false, nil
+	}
+	modRM := code[i+2]
+	extension := modRM >> 3 & 7
+	op := Op("")
+	switch {
+	case extension == 7 && !hasDataSizePrefix:
+		op = "CLFLUSH"
+	case extension == 7 && hasDataSizePrefix:
+		op = "CLFLUSHOPT"
+	case extension == 6 && hasDataSizePrefix:
+		op = "CLWB"
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if hasREX && rex&0x0c != 0 {
+		return Instr{}, 0, true, fmt.Errorf("REX.W and REX.R are absent from Go 1.27's %s encoding", op)
+	}
+	if modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("%s requires a memory operand", op)
+	}
+	bExt := int(rex & 1)
+	xExt := int(rex>>1) & 1
+	memory, consumed, decodeErr := decodedX86VEXRMSource(code[i+2:], mode, bExt, xExt, segment)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{memory},
+		Raw:  fmt.Sprintf("%s %s", op, memory.String()),
+	}
+	return instruction, i + 2 + consumed, true, nil
+}
+
+// decodedX86CacheLineWriteback recovers instructions which x/arch v0.14
+// cannot distinguish from their older 0F AE encodings. The explicit 0x66
+// mandatory prefix plus the ModRM extension is the architectural distinction:
+// /7 is CLFLUSHOPT and /6 is CLWB. Parse only the actual prefix/opcode region
+// so an identical byte sequence inside a displacement cannot be mistaken for
+// an opcode.
+func decodedX86CacheLineWriteback(encoding []byte) (string, bool) {
+	hasDataSizePrefix := false
+	i := 0
+	for i < len(encoding) {
+		switch encoding[i] {
+		case 0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65, 0x67, 0xf0, 0xf2, 0xf3:
+			i++
+		case 0x66:
+			hasDataSizePrefix = true
+			i++
+		default:
+			if encoding[i] >= 0x40 && encoding[i] <= 0x4f {
+				i++
+				continue
+			}
+			goto opcode
+		}
+	}
+
+opcode:
+	if !hasDataSizePrefix || i+2 >= len(encoding) || encoding[i] != 0x0f || encoding[i+1] != 0xae {
+		return "", false
+	}
+	modRM := encoding[i+2]
+	if modRM>>6 == 3 {
+		return "", false
+	}
+	switch modRM >> 3 & 7 {
+	case 7:
+		return "CLFLUSHOPT", true
+	case 6:
+		return "CLWB", true
+	default:
+		return "", false
+	}
+}
+
+func decodedX86RegisterBits(reg x86asm.Reg) int {
+	switch {
+	case x86asm.AL <= reg && reg <= x86asm.R15B:
+		return 8
+	case x86asm.AX <= reg && reg <= x86asm.R15W:
+		return 16
+	case x86asm.EAX <= reg && reg <= x86asm.R15L:
+		return 32
+	case x86asm.RAX <= reg && reg <= x86asm.R15:
+		return 64
+	default:
+		return 0
+	}
+}
+
+func isX86RawDirective(ins Instr) bool {
+	switch Op(strings.ToUpper(string(ins.Op))) {
+	case OpBYTE, OpWORD, "LONG", "QUAD":
+		return true
+	default:
+		return false
+	}
+}
+
+func x86RawDirectiveBytes(ins Instr) ([]byte, error) {
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return nil, fmt.Errorf("%s expects exactly one resolved integer constant: %q", ins.Op, ins.Raw)
+	}
+	value := uint64(ins.Args[0].Imm)
+	switch Op(strings.ToUpper(string(ins.Op))) {
+	case OpBYTE:
+		return []byte{byte(value)}, nil
+	case OpWORD:
+		var buf [2]byte
+		binary.LittleEndian.PutUint16(buf[:], uint16(value))
+		return buf[:], nil
+	case "LONG":
+		var buf [4]byte
+		binary.LittleEndian.PutUint32(buf[:], uint32(value))
+		return buf[:], nil
+	case "QUAD":
+		var buf [8]byte
+		binary.LittleEndian.PutUint64(buf[:], value)
+		return buf[:], nil
+	default:
+		return nil, fmt.Errorf("not an x86 raw directive: %q", ins.Raw)
+	}
+}
+
+func parseDecodedX86Instruction(syntax string) ([]Instr, error) {
+	file, err := Parse(ArchAMD64, "TEXT decoded(SB), NOSPLIT, $0-0\n"+syntax+"\n")
+	if err != nil {
+		return nil, err
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) < 2 {
+		return nil, fmt.Errorf("decoder syntax produced no instruction")
+	}
+	return append([]Instr(nil), file.Funcs[0].Instrs[1:]...), nil
+}
diff --git a/amd64_raw_abs.go b/amd64_raw_abs.go
new file mode 100644
index 000000000..cc55bfb5b
--- /dev/null
+++ b/amd64_raw_abs.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodedX86RawPackedAbsInstruction implements Go's complete VPABS B/W/D/Q
+// rows: VEX X/Y for B/W/D, EVEX X/Y/Z with optional K masking, and EVEX
+// D/Q memory broadcast. VPABSQ is EVEX-only. VEX B/W/D ignore W; EVEX
+// requires W0 for B/W/D and W1 for Q, independently of the named Go encoder.
+func decodedX86RawPackedAbsInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.pp != 1 || p.opcode < 0x1c || p.opcode > 0x1f {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VPABS: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.evex && !p.fixed || p.vectorLength > 2 || p.upper != 0 {
+		return fail("invalid vector prefix or reserved vvvv bits")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	laneBytes := [...]int{1, 2, 4, 8}[p.opcode-0x1c]
+	if p.evex && p.w != (laneBytes == 8) || !p.evex && (laneBytes == 8 || p.vectorLength == 2) {
+		return fail("invalid W bit or vector length for opcode")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	if p.broadcast && (!p.evex || laneBytes < 4 || registerSource) {
+		return fail("broadcast requires EVEX D/Q memory source")
+	}
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	scale := 16 << p.vectorLength
+	if p.broadcast {
+		scale = laneBytes
+	}
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width, scale)
+	} else {
+		source, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (destinationNumber >= 8 || registerSource && (p.b != 0 || p.x != 0)) {
+		return fail("extended register in 32-bit mode")
+	}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destinationNumber))})
+	op := Op("VPABS" + [...]string{"B", "W", "D", "Q"}[p.opcode-0x1c])
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86PackedAbsEVEX: p.evex}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_abs_test.go b/amd64_raw_abs_test.go
new file mode 100644
index 000000000..ffdf568bd
--- /dev/null
+++ b/amd64_raw_abs_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawPackedAbsForms = []struct {
+	opcode byte
+	op     Op
+	lane   int
+	evex   bool
+}{
+	{0x1c, "VPABSB", 1, false},
+	{0x1d, "VPABSW", 2, false},
+	{0x1e, "VPABSD", 4, false},
+	{0x1f, "VPABSQ", 8, true},
+}
+
+func encodeX86RawPackedAbs(formIndex, width, mask, destination, source int, zeroing, broadcast bool) []byte {
+	form := x86RawPackedAbsForms[formIndex]
+	vectorBits := map[int]int{16: 0, 32: 1, 64: 2}[width]
+	var code []byte
+	if width == 64 || mask != 0 || zeroing || broadcast || form.evex {
+		code = encodeX86EVEXPackedWordMultiply(2, form.opcode, vectorBits, mask, form.evex, zeroing, destination, 0, source)
+		if broadcast {
+			code[3] |= 0x10
+		}
+	} else {
+		code = encodeX86VEXPackedWordMultiply(2, form.opcode, width == 32, false, destination, 0, source)
+	}
+	return code
+}
+
+func TestDecodedX86RawPackedAbsCompleteFamily(t *testing.T) {
+	for formIndex, form := range x86RawPackedAbsForms {
+		for _, width := range []int{16, 32, 64} {
+			for _, masked := range []bool{false, true} {
+				for _, zeroing := range []bool{false, true} {
+					if !masked && zeroing {
+						continue
+					}
+					for _, source := range []int{0, 7, 16, 31} {
+						if !masked && width != 64 && !form.evex && source >= 16 {
+							continue
+						}
+						mask := 0
+						if masked {
+							mask = 3
+						}
+						name := fmt.Sprintf("%s/%d/k%d/z%t/src%d", form.op, width, mask, zeroing, source)
+						t.Run(name, func(t *testing.T) {
+							code := encodeX86RawPackedAbs(formIndex, width, mask, 19, source, zeroing, false)
+							if width != 64 && !masked && !form.evex {
+								code = encodeX86RawPackedAbs(formIndex, width, mask, 11, source, zeroing, false)
+							}
+							got, length, ok, err := decodedX86RawPackedAbsInstruction(code, 64)
+							if err != nil || !ok || length != len(code) || !strings.HasPrefix(string(got.Op), string(form.op)) ||
+								got.Args[0].String() != fmt.Sprintf("%s%d", map[int]string{16: "X", 32: "Y", 64: "Z"}[width], source) {
+								t.Fatalf("decode %x = %+v length=%d ok=%t err=%v", code, got, length, ok, err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+	// Actual bytes from simd@v1.21.1 arith_avx2_amd64.s.
+	real := []byte{0xc4, 0xa2, 0x7d, 0x1e, 0x04, 0x86}
+	got, length, ok, err := decodedX86RawPackedAbsInstruction(real, 64)
+	if err != nil || !ok || length != len(real) || got.Op != "VPABSD" ||
+		got.Args[0].String() != "0(SI)(R8*4)" || got.Args[1].String() != "Y0" {
+		t.Fatalf("decode real VPABSD %x = %+v length=%d ok=%t err=%v", real, got, length, ok, err)
+	}
+}
+
+func TestDecodedX86RawPackedAbsRejectsInvalidForms(t *testing.T) {
+	valid := encodeX86RawPackedAbs(2, 32, 0, 1, 2, false, false)
+	for name, edit := range map[string]func([]byte) []byte{
+		"reserved vvvv": func(b []byte) []byte { b[2] &^= 0x08; return b },
+		"EVEX W1": func([]byte) []byte {
+			code := encodeX86RawPackedAbs(2, 64, 0, 1, 2, false, false)
+			code[2] |= 0x80
+			return code
+		},
+		"truncated":        func(b []byte) []byte { return b[:4] },
+		"address override": func(b []byte) []byte { return append([]byte{0x67}, b...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			bad := edit(append([]byte(nil), valid...))
+			if _, _, matched, err := decodedX86RawPackedAbsInstruction(bad, 64); !matched || err == nil {
+				t.Fatalf("accepted invalid packed absolute %x: matched=%t err=%v", bad, matched, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedAbsObjects(t *testing.T) {
+	const source = `TEXT rawPackedAbs(SB),$0-0
+	BYTE $0xc4
+	BYTE $0xa2
+	BYTE $0x7d
+	BYTE $0x1e
+	BYTE $0x04
+	BYTE $0x86
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-packed-abs.ll", "raw-packed-abs.o", ir)
+		})
+	}
+}
+
+func x86RawPackedAbsConstant(formIndex, width int, broadcast bool) []byte {
+	form := x86RawPackedAbsForms[formIndex]
+	code := encodeX86RawPackedAbs(formIndex, width, 0, 0, 0, false, broadcast)
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = form.lane
+	}
+	for i := 0; i < dataWidth; i++ {
+		code = append(code, byte(i*23+5))
+	}
+	return code
+}
+
+func TestDecodeX86RawPackedAbsConstantCompleteFamily(t *testing.T) {
+	for formIndex, form := range x86RawPackedAbsForms {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && form.lane < 4 {
+					continue
+				}
+				name := fmt.Sprintf("%s/%d/bcst%t", form.op, width, broadcast)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawPackedAbsConstant(formIndex, width, broadcast)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := form.op
+					if broadcast {
+						want += ".BCST"
+					}
+					if len(decoded) != 2 || decoded[0].Op != want ||
+						decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+						decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawPackedAbsConstantRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawPackedAbsConstant(2, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedAbsConstantObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, form := range []struct {
+		formIndex, width int
+		broadcast        bool
+	}{
+		{0, 32, false}, {1, 64, false}, {2, 64, true}, {3, 64, true},
+	} {
+		code := x86RawPackedAbsConstant(form.formIndex, form.width, form.broadcast)
+		name := fmt.Sprintf("rawPackedAbsConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-packed-abs-constant.ll", "raw-packed-abs-constant.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_address_override_test.go b/amd64_raw_address_override_test.go
new file mode 100644
index 000000000..9d156d637
--- /dev/null
+++ b/amd64_raw_address_override_test.go
@@ -0,0 +1,753 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawAddressOverrideDoesNotBorrowCallerPointer(t *testing.T) {
+	for _, access := range []struct {
+		name, old, replacement string
+	}{
+		{"load", "MOVL $7,AX", "BYTE $0x67\nBYTE $0x8b\nBYTE $0x07"},
+		{"store", "MOVL AX,(DX)", "BYTE $0x67\nBYTE $0x89\nBYTE $0x02"},
+	} {
+		for _, triple := range []string{
+			"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+		} {
+			t.Run(access.name+"/"+triple, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, access.old, access.replacement, 1)
+				// These are real stock-Go objects, not executions of a program
+				// that could dereference a truncated incoming address.
+				x86LEAActualTargetGoObject(t, "amd64", triple, assembly)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("physical EA32 %s borrowed a full-width caller pointer: %v", access.name, err)
+				}
+			})
+		}
+	}
+}
+
+func x86AddressOverrideDecoded(t *testing.T, mode int, code []byte) []Instr {
+	t.Helper()
+	instructions, err := x86AddressOverrideDecode(mode, code)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return instructions
+}
+
+func x86AddressOverrideDecode(mode int, code []byte) ([]Instr, error) {
+	arch := "amd64"
+	if mode == 32 {
+		arch = "386"
+	}
+	file, err := Parse(ArchAMD64, "TEXT raw(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+	if err != nil {
+		return nil, err
+	}
+	function, err := decodeX86RawDirectives(file.Funcs[0], arch)
+	if err != nil {
+		return nil, err
+	}
+	return function.Instrs, nil
+}
+
+func x86AddressOverrideNamedBytes(t *testing.T, arch, instruction string) []byte {
+	t.Helper()
+	listing, err := x86ScalarLiteralGoListing(t, arch, "TEXT raw(SB),4,$0-0\n"+instruction+"\nRET\n")
+	if err != nil {
+		t.Fatalf("actual named implicit opcode: %v\n%s", err, listing)
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+			continue
+		}
+		var code []byte
+		for _, field := range fields[1:] {
+			if len(field) != 2 {
+				break
+			}
+			value, err := strconv.ParseUint(field, 16, 8)
+			if err != nil {
+				t.Fatalf("actual named opcode byte: %v\n%s", err, listing)
+			}
+			code = append(code, byte(value))
+		}
+		return code
+	}
+	t.Fatalf("actual named opcode lacks its byte listing:\n%s", listing)
+	return nil
+}
+
+func TestX86RawAddressOverrideGenericMemoryAndImplicitStrings(t *testing.T) {
+	// Cover the generic decoder's explicit read/write/RMW, scalar/vector and
+	// implicit memory shapes. Specialized prefix parsers are a separate scope.
+	forms := []struct {
+		name string
+		code []byte
+	}{
+		{"byte-load", []byte{0x8a, 0x07}}, {"byte-store", []byte{0x88, 0x07}},
+		{"word-load", []byte{0x66, 0x8b, 0x07}}, {"word-store", []byte{0x66, 0x89, 0x07}},
+		{"long-load", []byte{0x8b, 0x07}}, {"long-store", []byte{0x89, 0x07}},
+		{"add-read", []byte{0x03, 0x07}}, {"add-rmw", []byte{0x01, 0x07}},
+		{"compare", []byte{0x3b, 0x07}}, {"test", []byte{0x85, 0x07}},
+		{"exchange", []byte{0x87, 0x07}}, {"increment", []byte{0xff, 0x07}},
+		{"shift-rmw", []byte{0xc1, 0x27, 0x01}},
+		{"movups-load", []byte{0x0f, 0x10, 0x07}}, {"movups-store", []byte{0x0f, 0x11, 0x07}},
+		{"addps", []byte{0x0f, 0x58, 0x07}},
+		{"movsb", []byte{0xa4}}, {"cmpsb", []byte{0xa6}},
+		{"stosb", []byte{0xaa}}, {"lodsb", []byte{0xac}}, {"scasb", []byte{0xae}},
+		{"rep-movsb", []byte{0xf3, 0xa4}}, {"repne-scasb", []byte{0xf2, 0xae}},
+		{"insb", []byte{0x6c}}, {"outsb", []byte{0x6e}}, {"xlat", []byte{0xd7}},
+		{"insw", []byte{0x66, 0x6d}}, {"insl", []byte{0x6d}},
+		{"outsw", []byte{0x66, 0x6f}}, {"outsl", []byte{0x6f}},
+		{"movsw", []byte{0x66, 0xa5}}, {"movsl", []byte{0xa5}},
+		{"cmpsw", []byte{0x66, 0xa7}}, {"cmpsl", []byte{0xa7}},
+		{"stosw", []byte{0x66, 0xab}}, {"stosl", []byte{0xab}},
+		{"lodsw", []byte{0x66, 0xad}}, {"lodsl", []byte{0xad}},
+		{"scasw", []byte{0x66, 0xaf}}, {"scasl", []byte{0xaf}},
+	}
+	for _, mode := range []int{32, 64} {
+		modeForms := append([]struct {
+			name string
+			code []byte
+		}(nil), forms...)
+		if mode == 64 {
+			modeForms = append(modeForms, struct {
+				name string
+				code []byte
+			}{"quad-load", []byte{0x48, 0x8b, 0x07}}, struct {
+				name string
+				code []byte
+			}{"quad-store", []byte{0x48, 0x89, 0x07}})
+			for _, form := range []struct {
+				name string
+				code []byte
+			}{
+				{"movsq", []byte{0x48, 0xa5}}, {"cmpsq", []byte{0x48, 0xa7}},
+				{"stosq", []byte{0x48, 0xab}}, {"lodsq", []byte{0x48, 0xad}},
+				{"scasq", []byte{0x48, 0xaf}},
+			} {
+				modeForms = append(modeForms, form)
+			}
+		}
+		arch := "amd64"
+		if mode == 32 {
+			arch = "386"
+		}
+		var complete []byte
+		for _, form := range modeForms {
+			for _, segment := range []byte{0, 0x64, 0x65} {
+				complete = append(complete, 0x67)
+				if segment != 0 {
+					complete = append(complete, segment)
+				}
+				complete = append(complete, form.code...)
+			}
+		}
+		x86HandoffOriginalBytes(t, arch, append(complete, 0xc3))
+		for _, form := range modeForms {
+			for _, segment := range []byte{0, 0x64, 0x65} {
+				t.Run(fmt.Sprintf("mode%d/%s/segment%02x", mode, form.name, segment), func(t *testing.T) {
+					code := []byte{0x67}
+					if segment != 0 {
+						code = append(code, segment)
+					}
+					code = append(code, form.code...)
+					physical, err := x86asm.Decode(code, mode)
+					if err != nil || physical.Len != len(code) || physical.AddrSize != mode/2 {
+						t.Fatalf("actual decoder input: %+v, %v", physical, err)
+					}
+					instructions, err := x86AddressOverrideDecode(mode, code)
+					if strings.Contains(form.name, "stos") || strings.Contains(form.name, "scas") || strings.HasPrefix(form.name, "ins") {
+						if segment != 0 {
+							// The decoded destination remains ES, but x/arch
+							// leaves this unused FS/GS prefix unmarked. Require
+							// explicit Context, not a GoSyntax parser accident.
+							if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "unbound physical") || instructions != nil {
+								t.Fatalf("unbound segment did not retain Context: %v", err)
+							}
+							return
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					marked := 0
+					for _, instruction := range instructions {
+						if instruction.Op == OpTEXT || instruction.Op == OpRET {
+							continue
+						}
+						if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != mode/2 {
+							t.Fatalf("generic physical memory override lost its restriction: %+v", instruction)
+						}
+						marked++
+						ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+						if mode == 32 {
+							ctx.goarch = "386"
+						}
+						before := output.String()
+						if terminated, err := ctx.lowerInstr(0, 0, instruction, nil, nil); terminated || !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+							t.Fatalf("unbound memory emitted IR: terminated=%t, error=%v", terminated, err)
+						}
+					}
+					if marked == 0 {
+						t.Fatal("lost complete physical memory instruction")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawAddressOverrideAllAddressShapesAndMoffs(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		shapes := [][]byte{}
+		if mode == 32 {
+			// All eight EA16 r/m forms, including disp16-only and BP+disp8.
+			for rm := byte(0); rm < 8; rm++ {
+				shape := []byte{rm}
+				if rm == 6 {
+					shape = append(shape, 0xc0, 0xff)
+				}
+				shapes = append(shapes, shape, []byte{0x40 | rm, 0xc0}, []byte{0x80 | rm, 0xc0, 0xff})
+			}
+		} else {
+			// All base registers and SIB scales; EIP-relative r/m=5 is
+			// deliberately covered by the existing closed EIP boundary.
+			for rm := byte(0); rm < 8; rm++ {
+				if rm != 4 && rm != 5 {
+					shapes = append(shapes, []byte{rm})
+				}
+				if rm != 4 {
+					shapes = append(shapes, []byte{0x40 | rm, 0xc0}, []byte{0x80 | rm, 0xc0, 0xff, 0xff, 0xff})
+				}
+			}
+			for scale := byte(0); scale < 4; scale++ {
+				shapes = append(shapes,
+					[]byte{0x04, scale<<6 | 0x18},
+					[]byte{0x04, scale<<6 | 0x1d, 0xc0, 0xff, 0xff, 0xff})
+			}
+			shapes = append(shapes, []byte{0x04, 0x20}, []byte{0x04, 0x25, 0xc0, 0xff, 0xff, 0xff})
+		}
+		for _, opcode := range []byte{0x8b, 0x89} {
+			for index, shape := range shapes {
+				t.Run(fmt.Sprintf("mode%d/op%02x/shape%d", mode, opcode, index), func(t *testing.T) {
+					code := append([]byte{0x67, opcode}, shape...)
+					found := false
+					for _, instruction := range x86AddressOverrideDecoded(t, mode, code) {
+						if instruction.Op == OpMOVL {
+							found = true
+							if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != mode/2 {
+								t.Fatalf("physical memory shape lost override: %+v", instruction)
+							}
+						}
+					}
+					if !found {
+						t.Fatal("lost actual ModR/M address shape")
+					}
+				})
+			}
+		}
+		for _, opcode := range []byte{0xa0, 0xa1, 0xa2, 0xa3} {
+			t.Run(fmt.Sprintf("mode%d/moffs%02x", mode, opcode), func(t *testing.T) {
+				code := []byte{0x67, opcode, 0xc0, 0xff}
+				if mode == 64 {
+					code = append(code, 0xff, 0xff)
+				}
+				found := false
+				for _, instruction := range x86AddressOverrideDecoded(t, mode, code) {
+					if instruction.Op == "MOVB" || instruction.Op == OpMOVL {
+						found = true
+						if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != mode/2 {
+							t.Fatalf("absolute address override borrowed default addressing: %+v", instruction)
+						}
+					}
+				}
+				if !found {
+					t.Fatal("lost actual moffs operand")
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawAddressOverrideEA32ExtendedSIBFieldsStayRestricted(t *testing.T) {
+	// Physical REX.B/X extend EA32 base/index fields in 64-bit mode. The
+	// index field 4 without REX.X means no index, not an incoming SP grant.
+	for base := byte(0); base < 16; base++ {
+		for index := byte(0); index < 16; index++ {
+			for scale := byte(0); scale < 4; scale++ {
+				t.Run(fmt.Sprintf("base%d/index%d/scale%d", base, index, scale), func(t *testing.T) {
+					rex := byte(0x40) | base>>3 | (index>>3)<<1
+					code := []byte{0x67, rex, 0x8b, 0x44, scale<<6 | (index&7)<<3 | base&7, 0x80}
+					physical, err := x86asm.Decode(code, 64)
+					if err != nil || physical.Len != len(code) || physical.AddrSize != 32 {
+						t.Fatalf("physical extended EA32 fields: %+v, %v", physical, err)
+					}
+					found := false
+					for _, instruction := range x86AddressOverrideDecoded(t, 64, code) {
+						if instruction.Op == OpMOVL {
+							found = true
+							if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != 32 {
+								t.Fatalf("extended EA32 acquired native pointer semantics: %+v", instruction)
+							}
+						}
+					}
+					if !found {
+						t.Fatal("lost extended physical memory form")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawAddressOverrideExistingTypedConsumersRemainBound(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		mode := 64
+		if target.arch == "386" {
+			mode = 32
+		}
+		forms := []struct {
+			name string
+			code []byte
+		}{
+			{"ADCXL", []byte{0x67, 0x66, 0x0f, 0x38, 0xf6, 0x18}},
+			{"ADOXL", []byte{0x67, 0xf3, 0x0f, 0x38, 0xf6, 0x18}},
+			{"ENQCMD", []byte{0x67, 0xf2, 0x0f, 0x38, 0xf8, 0x00}},
+			{"ENQCMDS", []byte{0x67, 0xf3, 0x0f, 0x38, 0xf8, 0x00}},
+			{"UMONITOR", []byte{0x67, 0xf3, 0x0f, 0xae, 0xf3}},
+		}
+		if mode == 64 {
+			forms = append(forms, struct {
+				name string
+				code []byte
+			}{"ADCXQ", []byte{0x67, 0x66, 0x48, 0x0f, 0x38, 0xf6, 0x18}}, struct {
+				name string
+				code []byte
+			}{"ADOXQ", []byte{0x67, 0xf3, 0x48, 0x0f, 0x38, 0xf6, 0x18}})
+		}
+		for _, form := range forms {
+			t.Run(target.triple+"/"+form.name, func(t *testing.T) {
+				assembly := "TEXT raw(SB),4,$0-0\n" + x86RawDisplacementDirectives(form.code) + "RET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly)
+				found := false
+				for _, instruction := range x86AddressOverrideDecoded(t, mode, form.code) {
+					if instruction.Op != Op(form.name) {
+						continue
+					}
+					found = true
+					if instruction.x86SourceRaw == nil || instruction.x86AddressBits != mode/2 || instruction.x86UnboundAddressOverride {
+						t.Fatalf("dedicated typed address receipt changed: %+v", instruction)
+					}
+				}
+				if !found {
+					t.Fatal("lost dedicated width-consuming instruction")
+				}
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var ir string
+				if form.name == "UMONITOR" {
+					// Retain this family's existing physical-width observation;
+					// it does not establish a monitor extent or runtime result.
+					ir, err = Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"raw": {Name: "raw", Ret: Void}},
+					})
+				} else {
+					// ADX and enqueue inputs are absent. Original Go/emitter
+					// objects remain required, while every public API retains
+					// Context instead of inventing numerical or native authority.
+					ir = x86UnboundVoidRawScalarFormatObject(t, assembly, target.arch, target.triple)
+				}
+				if err != nil || !strings.Contains(ir, fmt.Sprintf("to i%d", mode/2)) {
+					t.Fatalf("dedicated consumer lost physical truncation: %v", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "address-consumer.ll", "address-consumer.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86RawAddressOverrideImplicitMaskedStoreAndMonitor(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, form := range []struct {
+			name, named string
+			code        []byte
+		}{
+			{"MASKMOVQ", "MASKMOVQ M1,M0", []byte{0x67, 0x0f, 0xf7, 0xc1}},
+			{"MASKMOVDQU", "MASKMOVDQU X1,X0", []byte{0x67, 0x66, 0x0f, 0xf7, 0xc1}},
+			{"MONITOR", "MONITOR", []byte{0x67, 0x0f, 0x01, 0xc8}},
+		} {
+			t.Run(target.triple+"/"+form.name, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, "TEXT raw(SB),4,$0-0\n"+form.named+"\nRET\n")
+				if encoded := x86AddressOverrideNamedBytes(t, target.arch, form.named); !bytes.HasPrefix(encoded, form.code[1:]) {
+					t.Fatalf("named Go form has different physical opcode: %x, want prefix %x", encoded, form.code[1:])
+				}
+				assembly := "TEXT raw(SB),4,$0-0\n" + x86RawDisplacementDirectives(form.code) + "RET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"raw": {Name: "raw", Ret: Void}},
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("implicit physical address override borrowed default addressing: %v", err)
+				}
+
+				// Keep the complete original default-address byte control.
+				// Removing 0x67 cannot supply an initialized mask/data/DI or
+				// a complete MMX/EMMS region to a bare public entry.
+				control := "TEXT raw(SB),4,$0-0\n" + x86RawDisplacementDirectives(form.code[1:]) + "RET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, control)
+				if form.name != "MONITOR" {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, control, "func raw()", target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("default raw mask store invented its native input owner", api, err)
+						}
+					}
+					// The same physical register/opcode control has genuine LLVM
+					// objects only with independently initialized named inputs.
+					// This does not grant a raw numerical or implicit-address role.
+					source, declaration := x86ImplicitMaskMoveOracleRegisters(target.arch, form.name, "Default", 1, 0)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("initialized default mask-store control lost its original opcode", api, err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							body := x86StringMemoryFunction(t, text, "Default")
+							if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, strings.ToLower(form.name)) ||
+								!strings.Contains(body, "~{memory}") || strings.Contains(body, "call void @llvm.masked.store") ||
+								form.name == "MASKMOVQ" && !strings.Contains(body, "emms") {
+								t.Fatal("default opcode lost its native access or MMX cleanup", api)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+					return
+				}
+				file, err = Parse(ArchAMD64, control)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err = Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"raw": {Name: "raw", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatalf("default-address control regressed: %v", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "implicit-address.ll", "implicit-address.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86RawAddressOverrideImplicitMaskedStoreAllRegisterFields(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, xmm := range []bool{false, true} {
+			last := 7
+			if xmm && mode == 64 {
+				last = 15
+			}
+			for source := 0; source <= last; source++ {
+				for mask := 0; mask <= last; mask++ {
+					t.Run(fmt.Sprintf("mode%d/xmm%t/source%d/mask%d", mode, xmm, source, mask), func(t *testing.T) {
+						code := []byte{0x67}
+						if xmm {
+							code = append(code, 0x66)
+						}
+						if source >= 8 || mask >= 8 {
+							rex := byte(0x40)
+							if source >= 8 {
+								rex |= 4
+							}
+							if mask >= 8 {
+								rex |= 1
+							}
+							code = append(code, rex)
+						}
+						code = append(code, 0x0f, 0xf7, byte(0xc0|(source&7)<<3|(mask&7)))
+						physical, err := x86asm.Decode(code, mode)
+						if err != nil || physical.Len != len(code) || physical.AddrSize != mode/2 {
+							t.Fatalf("physical implicit store: %+v, %v", physical, err)
+						}
+						for _, instruction := range x86AddressOverrideDecoded(t, mode, code) {
+							if instruction.Op == OpTEXT || instruction.Op == OpRET {
+								continue
+							}
+							if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != mode/2 {
+								t.Fatalf("implicit address restriction lost at register alias: %+v", instruction)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawAddressOverrideUnsupportedImplicitDecoderBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			// Go accepts its named VEX spelling, while the pinned x/arch
+			// generic decoder does not implement this opcode. Do not grant
+			// a legacy/default address interpretation to its raw bytes.
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, "TEXT raw(SB),4,$0-0\nVMASKMOVDQU X0,X1\nRET\n")
+			for _, code := range [][]byte{
+				{0xc5, 0xf9, 0xf7, 0xc1}, {0x67, 0xc5, 0xf9, 0xf7, 0xc1},
+				{0x0f, 0x01, 0xfa}, {0x67, 0x0f, 0x01, 0xfa}, // MONITORX
+			} {
+				mode := 64
+				if target.arch == "386" {
+					mode = 32
+				}
+				if _, err := x86AddressOverrideDecode(mode, code); err == nil {
+					t.Fatalf("unsupported implicit raw decoder acquired a consumer: %x", code)
+				}
+			}
+			requireLEANativeGoObject(t, target.arch, "TEXT raw(SB),4,$0-0\nMONITORX\nRET\n", false)
+		})
+	}
+}
+
+func TestX86RawAddressOverrideDoesNotInventMemoryForRegisterForms(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, code := range [][]byte{{0x67, 0x8b, 0xc2}, {0x67, 0x89, 0xc2}, {0x67, 0x03, 0xc2}} {
+			t.Run(fmt.Sprintf("mode%d/%x", mode, code), func(t *testing.T) {
+				physical, err := x86asm.Decode(code, mode)
+				if err != nil || physical.Len != len(code) {
+					t.Fatalf("physical register control: %+v, %v", physical, err)
+				}
+				for _, instruction := range x86AddressOverrideDecoded(t, mode, code) {
+					if instruction.x86UnboundAddressOverride || instruction.x86AddressBits != 0 {
+						t.Fatalf("ignored register prefix gained physical memory semantics: %+v", instruction)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawAddressOverrideRestrictionSurvivesNormalizationAndMutation(t *testing.T) {
+	assembly := "TEXT raw(SB),4,$0-0\nBYTE $0x67\nBYTE $0x8b\nBYTE $0x07\nRET\n"
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for pass := 0; pass < 3; pass++ {
+		file, err = normalizeX86RawFile(file, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		copy := *file
+		copy.Funcs = append([]Func(nil), file.Funcs...)
+		copy.Funcs[0].Instrs = append([]Instr(nil), file.Funcs[0].Instrs...)
+		file = &copy
+		found := false
+		for _, instruction := range file.Funcs[0].Instrs {
+			if instruction.Op != OpMOVL {
+				continue
+			}
+			found = true
+			if !instruction.x86UnboundAddressOverride || instruction.x86AddressBits != 32 {
+				t.Fatal("normalization/copy lost restrictive decoder identity")
+			}
+			for _, width := range []int{0, 16, 32, 64, 128} {
+				mutated := instruction
+				mutated.x86AddressBits = width
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{mutated}}, FuncSig{Ret: Void}, nil)
+				before := output.String()
+				if _, err := ctx.lowerInstr(0, 0, mutated, nil, nil); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+					t.Fatalf("width %d laundered decoder restriction: %v", width, err)
+				}
+			}
+		}
+		if !found {
+			t.Fatal("normalization/copy lost source instruction")
+		}
+	}
+}
+
+func TestX86RawAddressOverrideCannotReuseDefaultCallerCertificate(t *testing.T) {
+	instruction := Instr{Op: OpMOVL, Args: []Operand{
+		{Kind: OpReg, Reg: AX}, {Kind: OpMem, Mem: MemRef{Base: DX}},
+	}}
+	x86CallerRecordMemory(&instruction, 1, 4, true)
+	if !x86CallerMemoryCertified(instruction, 1) {
+		t.Fatal("default-width certificate control is invalid")
+	}
+	for _, width := range []int{0, 16, 32, 64} {
+		mutated := instruction
+		mutated.x86UnboundAddressOverride = true
+		mutated.x86AddressBits = width
+		if x86CallerMemoryCertified(mutated, 1) {
+			t.Fatalf("decoder restriction reused a default-width certificate at width %d", width)
+		}
+		// A change to the spelling or operands cannot turn a restrictive
+		// decoder receipt into a positive LEA/address capability either.
+		mutated.Op = "LEAQ"
+		ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{mutated}}, FuncSig{Ret: Void}, nil)
+		before := output.String()
+		if _, err := ctx.lowerInstr(0, 0, mutated, nil, nil); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+			t.Fatalf("changed opcode bypassed restrictive source identity: %v", err)
+		}
+	}
+}
+
+func TestX86RawAddressOverrideDefaultCallerControlsAndPhysicalSegments(t *testing.T) {
+	for _, replacement := range []string{
+		"MOVL $7,AX\nMOVL AX,(DX)", "MOVL (DI),AX\nADDL $7,AX\nMOVL AX,(DX)",
+	} {
+		for _, triple := range []string{
+			"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+		} {
+			t.Run(triple+"/"+replacement, func(t *testing.T) {
+				assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", replacement, 1)
+				x86LEAActualTargetGoObject(t, "amd64", triple, assembly)
+				pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+				if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+		space  int
+	}{{0x64, FS, 257}, {0x65, GS, 256}} {
+		t.Run(string(segment.reg), func(t *testing.T) {
+			code := []byte{segment.prefix, 0x8b, 0x07}
+			found := false
+			for _, instruction := range x86AddressOverrideDecoded(t, 64, code) {
+				if instruction.Op == OpMOVL {
+					found = true
+					if instruction.x86UnboundAddressOverride || instruction.x86AddressBits != 0 || instruction.Args[0].Mem.Segment != segment.reg {
+						t.Fatalf("ordinary segment/address identity changed: %+v", instruction)
+					}
+				}
+			}
+			if !found {
+				t.Fatal("lost segmented MOVL control")
+			}
+			assembly := "TEXT raw(SB),4,$0-0\n" + x86RawDisplacementDirectives(code) + "RET\n"
+			triple := "x86_64-unknown-linux-gnu"
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			ir := x86UnboundVoidRawScalarFormatObject(t, assembly, "amd64", triple)
+			x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+			initialized := strings.Replace(assembly, x86RawDisplacementDirectives(code),
+				"MOVQ $0,DI\n"+x86RawDisplacementDirectives(code), 1)
+			x86LEAActualTargetGoObject(t, "amd64", triple, initialized)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, initialized, "func raw()", "amd64", triple, api)
+				if err != nil || !strings.Contains(ir, fmt.Sprintf("load volatile i32, ptr addrspace(%d)", segment.space)) {
+					t.Fatalf("initialized default-width physical segment was erased: %s: %v", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawAddressOverrideFiveTargetsAndThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []byte{0x8b, 0x89} {
+			t.Run(fmt.Sprintf("%s/%02x", target.triple, opcode), func(t *testing.T) {
+				assembly, sig, pkg := x86SourceStackNumericalFixture(target.arch,
+					"@MOV x+0(FP),DI\n"+x86RawDisplacementDirectives([]byte{0x67, opcode, 0x07})+"@MOV AX,ret+@WORD(FP)\nRET")
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly)
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := x86SourceStackOptions(target.arch, target.triple, sig)
+				ir, err := Translate(file, opt)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("ordinary API acquired overridden pointer: %v", err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("module API acquired overridden pointer: %v", err)
+				}
+				translated, err := TranslateGoModule(pkg, []byte(assembly), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: opt.ResolveSym,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("typed API acquired overridden pointer: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawAddressOverrideRetainsGenericPhysicalMemoryWidth(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		arch := "amd64"
+		if mode == 32 {
+			arch = "386"
+		}
+		for _, opcode := range []byte{0x8b, 0x89} {
+			t.Run(fmt.Sprintf("mode%d/%02x", mode, opcode), func(t *testing.T) {
+				code := []byte{0x67, opcode, 0x07}
+				assembly := "TEXT raw(SB),4,$0-0\n" + x86RawDisplacementDirectives(code) + "RET\n"
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				function, err := decodeX86RawDirectives(file.Funcs[0], arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, instruction := range function.Instrs {
+					if instruction.Op == OpMOVL {
+						if instruction.x86AddressBits != mode/2 {
+							t.Fatalf("decoded physical address width lost: got %d, want %d; %+v", instruction.x86AddressBits, mode/2, instruction)
+						}
+						return
+					}
+				}
+				t.Fatal("decoded raw source lost its MOVL")
+			})
+		}
+	}
+}
diff --git a/amd64_raw_adx.go b/amd64_raw_adx.go
new file mode 100644
index 000000000..72c4a0e4f
--- /dev/null
+++ b/amd64_raw_adx.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Intel SDM Vol. 2A specifies 66/F3 0F 38 F6 /r for ADCX/ADOX. REX.W
+// alone selects 64 bits: 0x66 is mandatory, not a 16-bit width override.
+// Reuse the decoder's ADD r/m,reg ModRM/SIB grammar, never its flag semantics.
+func decodeX86RawADX(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	return decodeX86RawADXWithMemory(code, offset, mode, x86RawMemoryDecoder{})
+}
+
+func decodeX86RawADXWithMemory(code []byte, offset, mode int, strategy x86RawMemoryDecoder) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 32 && mode != 64 || offset < 0 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	bytes := code[offset:]
+	i := 0
+	var repeat, segment, rex byte
+	operandOverride, addressOverride, locked := false, false, false
+	for i < len(bytes) {
+		switch bytes[i] {
+		case 0xf2, 0xf3:
+			repeat, rex = bytes[i], 0
+		case 0x66:
+			operandOverride, rex = true, 0
+		case 0x67:
+			addressOverride, rex = true, 0
+		case 0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65:
+			segment, rex = bytes[i], 0
+		case 0xf0:
+			locked, rex = true, 0
+		default:
+			if mode == 64 && bytes[i] >= 0x40 && bytes[i] <= 0x4f {
+				rex = bytes[i]
+				i++
+				continue
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	prefix := repeat
+	if prefix == 0 && operandOverride {
+		prefix = 0x66
+	}
+	if prefix != 0x66 && prefix != 0xf3 || len(bytes) < i+3 ||
+		bytes[i] != 0x0f || bytes[i+1] != 0x38 || bytes[i+2] != 0xf6 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	fail := func(reason string) (Instr, int, x86RawLiteralRange, bool, error) {
+		return Instr{}, 0, x86RawLiteralRange{}, true, fmt.Errorf("ADX: %s", reason)
+	}
+	if locked {
+		return fail("LOCK is not permitted")
+	}
+	bits := 32
+	if rex&8 != 0 {
+		bits = 64
+	}
+	var op Op
+	for name, spec := range amd64ADXSpecs {
+		if spec.prefix == prefix && spec.bits == bits {
+			op = name
+			break
+		}
+	}
+	var equivalent []byte
+	if segment == 0x64 || segment == 0x65 {
+		equivalent = append(equivalent, segment)
+	}
+	if addressOverride {
+		equivalent = append(equivalent, 0x67)
+	}
+	if rex != 0 {
+		equivalent = append(equivalent, rex)
+	}
+	equivalent = append(equivalent, 0x03)
+	header := len(equivalent)
+	equivalent = append(equivalent, bytes[i+3:]...)
+	decoded, err := x86asm.Decode(equivalent, mode)
+	if err != nil || decoded.Op != x86asm.ADD || decoded.Len <= header {
+		return fail("truncated or invalid ModRM/SIB address")
+	}
+	length := i + 3 + decoded.Len - header
+	if length > 15 {
+		return fail("encoding exceeds the 15-byte instruction limit")
+	}
+	if strategy.physicalPC {
+		// A whole-object observer needs only the validated instruction's PC
+		// and length. Do not patch RIP bytes, require source-local literal
+		// storage, or return operands that could be mistaken for read facts.
+		return Instr{}, length, x86RawLiteralRange{}, true, nil
+	}
+	if decoded.PCRel != 0 {
+		if decoded.AddrSize != 64 || segment == 0x64 || segment == 0x65 {
+			return fail("PC-relative source needs an unsegmented source-local literal")
+		}
+		patched, data, literal, err := x86RawRIPBytes(code, offset, offset+i+3, bits/8)
+		if err != nil {
+			return Instr{}, 0, x86RawLiteralRange{}, true, err
+		}
+		instruction, _, _, matched, err := decodeX86RawADX(patched, 0, mode)
+		if err != nil || !matched {
+			return fail("cannot represent patched source-local literal")
+		}
+		setX86RawRIPDataOperand(&instruction, 0, data)
+		return instruction, length, literal, true, nil
+	}
+	memory, isMemory := decoded.Args[1].(x86asm.Mem)
+	if isMemory {
+		// The textual parser has only two address groups. Attach FS/GS
+		// structurally so a 16-bit BX+SI address does not gain a third one.
+		memory.Segment = 0
+		decoded.Args[1] = memory
+	}
+	syntax, err := decodedX86GoSyntax(decoded, equivalent[:decoded.Len])
+	if err != nil {
+		return fail("cannot represent decoded operands")
+	}
+	parsed, err := parseDecodedX86Instruction(syntax)
+	if err != nil || len(parsed) != 1 || len(parsed[0].Args) != 2 {
+		return fail("cannot represent decoded register/memory form")
+	}
+	instruction := parsed[0]
+	if isMemory {
+		if memory.Base == 0 && memory.Index == 0 {
+			instruction.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Off: memory.Disp}}
+		}
+		if instruction.Args[0].Kind != OpMem {
+			return fail("cannot represent decoded source as memory")
+		}
+		switch segment {
+		case 0x64:
+			instruction.Args[0].Mem.Segment = FS
+		case 0x65:
+			instruction.Args[0].Mem.Segment = GS
+		}
+	}
+	instruction.Op = op
+	instruction.x86Encoded = true
+	instruction.x86AddressBits = decoded.AddrSize
+	instruction.Raw = fmt.Sprintf("%s %s, %s", op, instruction.Args[0], instruction.Args[1])
+	return instruction, length, x86RawLiteralRange{}, true, nil
+}
diff --git a/amd64_raw_adx_test.go b/amd64_raw_adx_test.go
new file mode 100644
index 000000000..aa2e97f30
--- /dev/null
+++ b/amd64_raw_adx_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ADXGrammarMatchesCompleteGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	table := regexp.MustCompile(`(?s)var yml_rl = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+	if len(table) != 2 || strings.Count(table[1], "argList{") != 1 ||
+		!regexp.MustCompile(`\{Zm_r,\s*1,\s*argList\{Yml, Yrl\}\}`).MatchString(table[1]) {
+		t.Fatal("Go ADX register/memory operand grammar changed")
+	}
+	rows := regexp.MustCompile(`\{A((?:ADCX|ADOX)[LQ]),\s*yml_rl,\s*(Pq[45]w?),\s*opBytes\{0xf6\}\}`).FindAllStringSubmatch(text, -1)
+	if len(rows) != 4 || len(amd64ADXSpecs) != len(rows) {
+		t.Fatal("typed ADX grammar does not match the complete Go encoder family")
+	}
+	for _, row := range rows {
+		spec, ok := amd64ADXSpecs[Op(row[1])]
+		bits, prefix, carry := 32, byte(0x66), amd64ADXCarryCF
+		if strings.HasSuffix(row[2], "w") {
+			bits = 64
+		}
+		if strings.HasPrefix(row[2], "Pq5") {
+			prefix, carry = 0xf3, amd64ADXCarryOF
+		}
+		if !ok || spec.bits != bits || spec.prefix != prefix || spec.carry != carry {
+			t.Fatalf("%s spec %+v does not match Go encoder row %v", row[1], spec, row)
+		}
+	}
+}
+
+func TestX86RawADXEveryRegisterEncoding(t *testing.T) {
+	for op, spec := range amd64ADXSpecs {
+		for _, mode := range []int{32, 64} {
+			if mode == 32 && spec.bits == 64 {
+				continue
+			}
+			registers := 16
+			if mode == 32 {
+				registers = 8
+			}
+			for source := 0; source < registers; source++ {
+				for destination := 0; destination < registers; destination++ {
+					code := []byte{spec.prefix}
+					rex := byte(0x40 | source>>3 | (destination>>3)<<2)
+					if spec.bits == 64 {
+						rex |= 8
+					}
+					if rex != 0x40 {
+						code = append(code, rex)
+					}
+					code = append(code, 0x0f, 0x38, 0xf6, byte(0xc0|(destination&7)<<3|source&7))
+					got, length, _, matched, err := decodeX86RawADX(code, 0, mode)
+					wantSource, _ := decodedX86GeneralRegister(source)
+					wantDestination, _ := decodedX86GeneralRegister(destination)
+					if err != nil || !matched || length != len(code) || got.Op != op ||
+						got.Args[0].Reg != wantSource || got.Args[1].Reg != wantDestination {
+						t.Fatalf("decode %x mode=%d: %+v error=%v", code, mode, got, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawADXAddressAndSegmentForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, mode := range []int{32, 64} {
+		for _, segment := range []byte{0, 0x64, 0x65} {
+			for _, override := range []bool{false, true} {
+				for _, prefix := range []byte{0x66, 0xf3} {
+					code := []byte{prefix}
+					if segment != 0 {
+						code = append(code, segment)
+					}
+					bits := mode
+					if override {
+						code = append(code, 0x67)
+						bits /= 2
+					}
+					code = append(code, 0x0f, 0x38, 0xf6, 0x18)
+					ins, length, _, matched, err := decodeX86RawADX(code, 0, mode)
+					if err != nil || !matched || length != len(code) || ins.x86AddressBits != bits || ins.Args[0].Kind != OpMem {
+						t.Fatalf("decode %x mode=%d: %+v error=%v", code, mode, ins, err)
+					}
+					wantSegment := Reg("")
+					if segment == 0x64 {
+						wantSegment = FS
+					} else if segment == 0x65 {
+						wantSegment = GS
+					}
+					if ins.Args[0].Mem.Segment != wantSegment {
+						t.Fatalf("segment lost: %+v", ins)
+					}
+					var source strings.Builder
+					source.WriteString("TEXT adxaddress(SB),$0-0\n")
+					for _, b := range code {
+						fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+					}
+					source.WriteString("RET\n")
+					arch, triple := "amd64", "x86_64-unknown-linux-gnu"
+					if mode == 32 {
+						arch, triple = "386", "i386-unknown-linux-gnu"
+					}
+					ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), arch, triple)
+					if override && !strings.Contains(ir, fmt.Sprintf(" to i%d", bits)) {
+						t.Fatal("address-size wrapping was not lowered")
+					}
+					compileLLVMToObject(t, llc, triple, "adx-address.ll", "adx-address.o", ir)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawADXSourceLocalRIPAndInvalidEncodings(t *testing.T) {
+	for op, spec := range amd64ADXSpecs {
+		code := []byte{spec.prefix}
+		if spec.bits == 64 {
+			code = append(code, 0x48)
+		}
+		code = append(code, 0x0f, 0x38, 0xf6, 0x1d, 1, 0, 0, 0, 0xc3)
+		for i := 0; i < spec.bits/8; i++ {
+			code = append(code, byte(i+1))
+		}
+		decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, string(op), map[string]bool{})
+		if err != nil || len(decoded) != 2 || decoded[0].Op != op || len(decoded[0].x86RIPLiteralData) != spec.bits/8 {
+			t.Fatalf("source-local literal %x: %+v error=%v", code, decoded, err)
+		}
+		if _, err := decodeX86RawDirectiveGroup(code[:len(code)-1], 64, 0, "truncated literal", map[string]bool{}); err == nil {
+			t.Fatal("accepted incomplete literal")
+		}
+	}
+	for _, code := range [][]byte{
+		{0xf0, 0x66, 0x0f, 0x38, 0xf6, 0xc0},
+		{0x66, 0x0f, 0x38, 0xf6},
+		{0xf3, 0x0f, 0x38, 0xf6, 0x04},
+		{0x66, 0x0f, 0x38, 0xf6, 0x80},
+		append([]byte{0x66}, append([]byte(strings.Repeat("\x67", 11)), 0x0f, 0x38, 0xf6, 0xc0)...),
+	} {
+		if _, _, _, matched, err := decodeX86RawADX(code, 0, 64); !matched || err == nil {
+			t.Fatalf("accepted invalid ADX %x", code)
+		}
+	}
+}
+
+func TestX86RawADXCompleteRegisterAndMemoryForms(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, prefix := range []byte{0x66, 0xf3} {
+			for _, bits := range []int{32, 64} {
+				if mode == 32 && bits == 64 {
+					continue
+				}
+				for _, form := range []struct {
+					name   string
+					modrm  []byte
+					source string
+				}{
+					{"register", []byte{0xd8}, "AX"},
+					{"memory", []byte{0x58, 0x20}, "32(AX)"},
+					{"indexed", []byte{0x5c, 0x88, 0xf0}, "-16(AX)(CX*4)"},
+				} {
+					name := fmt.Sprintf("mode%d/prefix%x/bits%d/%s", mode, prefix, bits, form.name)
+					t.Run(name, func(t *testing.T) {
+						code := []byte{prefix}
+						if bits == 64 {
+							code = append(code, 0x48)
+						}
+						code = append(code, 0x0f, 0x38, 0xf6)
+						code = append(code, form.modrm...)
+						code = append(code, 0xc3)
+						decoded, err := decodeX86RawDirectiveGroup(code, mode, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						stem, width := "ADCX", "L"
+						if prefix == 0xf3 {
+							stem = "ADOX"
+						}
+						if bits == 64 {
+							width = "Q"
+						}
+						if len(decoded) != 2 || decoded[0].Op != Op(stem+width) || decoded[1].Op != OpRET ||
+							len(decoded[0].Args) != 2 || decoded[0].Args[0].String() != form.source || decoded[0].Args[1].Reg != BX {
+							t.Fatalf("decoded %x as %+v, want %s%s %s, BX; RET", code, decoded, stem, width, form.source)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawADXExtendedRegistersFromEthereum(t *testing.T) {
+	for _, form := range []struct {
+		code                []byte
+		op                  Op
+		source, destination Reg
+	}{
+		{[]byte{0x66, 0x4c, 0x0f, 0x38, 0xf6, 0xc8}, "ADCXQ", AX, "R9"},
+		{[]byte{0xf3, 0x4c, 0x0f, 0x38, 0xf6, 0xd3}, "ADOXQ", BX, "R10"},
+		{[]byte{0x66, 0x4d, 0x0f, 0x38, 0xf6, 0xe7}, "ADCXQ", "R15", "R12"},
+	} {
+		code := append(append([]byte(nil), form.code...), 0xc3)
+		decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "Ethereum ADX", map[string]bool{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(decoded) != 2 || decoded[0].Op != form.op ||
+			decoded[0].Args[0].Reg != form.source || decoded[0].Args[1].Reg != form.destination {
+			t.Fatalf("decoded %x as %+v", code, decoded)
+		}
+	}
+}
+
+func TestX86RawADXObjectsAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT adxraw(SB),$0-0\n")
+			for _, prefix := range []byte{0x66, 0xf3} {
+				for _, rex := range []byte{0, 0x48} {
+					if target.arch == "386" && rex != 0 {
+						continue
+					}
+					for _, modrm := range [][]byte{{0xd8}, {0x58, 0x20}, {0x5c, 0x88, 0xf0}} {
+						code := []byte{prefix}
+						if rex != 0 {
+							code = append(code, rex)
+						}
+						code = append(code, 0x0f, 0x38, 0xf6)
+						code = append(code, modrm...)
+						for _, value := range code {
+							fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "adx-raw.ll", "adx-raw.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_aes.go b/amd64_raw_aes.go
new file mode 100644
index 000000000..3d38233f1
--- /dev/null
+++ b/amd64_raw_aes.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// VAES is absent from the pinned generic decoder. Decode its complete actual
+// Go VEX/EVEX family without lending another instruction's operand/PC proof.
+func decodedX86AESInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86AESInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86AESInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i, segment, addressOverride := 0, Reg(""), false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto prefix
+		}
+	}
+prefix:
+	if i >= len(code) {
+		return Instr{}, 0, false, nil
+	}
+	var opcodeIndex, modRMIndex, mapSelect, width, rExt, rHigh, xExt, bExt, vRegister, vHigh, rmHigh int
+	evex := false
+	switch code[i] {
+	case 0xc4:
+		if len(code) < i+4 {
+			return Instr{}, 0, false, nil
+		}
+		p0, p1 := code[i+1], code[i+2]
+		opcodeIndex, modRMIndex, mapSelect = i+3, i+4, int(p0&31)
+		if p1&3 != 1 || x86AESRawOpcode(mapSelect, code[opcodeIndex]) == "" {
+			return Instr{}, 0, false, nil
+		}
+		rExt, xExt, bExt = int(^p0>>7)&1, int(^p0>>6)&1, int(^p0>>5)&1
+		vRegister = int(^p1>>3) & 15
+		width = 16
+		if p1&4 != 0 {
+			width = 32
+		}
+	case 0x62:
+		if len(code) < i+5 {
+			return Instr{}, 0, false, nil
+		}
+		p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+		opcodeIndex, modRMIndex, mapSelect = i+4, i+5, int(p0&3)
+		if p0&0x0c != 0 || p1&3 != 1 || x86AESRawOpcode(mapSelect, code[opcodeIndex]) == "" {
+			return Instr{}, 0, false, nil
+		}
+		evex = true
+		if p1&4 != 4 || p2&0x97 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("AES EVEX has reserved bit/mask/zeroing/broadcast attributes")
+		}
+		rExt, rHigh, xExt, bExt = int(^p0>>7)&1, int(^p0>>4)&1, int(^p0>>6)&1, int(^p0>>5)&1
+		vRegister, vHigh, rmHigh = int(^p1>>3)&15, int(^p2>>3)&1, xExt
+		switch p2 >> 5 & 3 {
+		case 0:
+			width = 16
+		case 1:
+			width = 32
+		case 2:
+			width = 64
+		default:
+			return Instr{}, 0, true, fmt.Errorf("reserved AES EVEX vector length")
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	op := x86AESRawOpcode(mapSelect, code[opcodeIndex])
+	unary := op == "VAESIMC" || op == "VAESKEYGENASSIST"
+	if unary && (evex || width != 16 || vRegister != 0) {
+		return Instr{}, 0, true, fmt.Errorf("AES unary requires VEX.128 with reserved vvvv")
+	}
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing AES ModRM")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("%w: AES native address-size override is not bound", ErrProbeNeedsContext)
+	}
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8 + rHigh*16
+	stateNumber := vRegister + vHigh*16
+	if mode == 32 && (destinationNumber >= 8 || stateNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("%w: extended AES vector in physical mode32", ErrProbeNeedsContext)
+	}
+	if mode == 32 && code[modRMIndex]>>6 == 3 && int(code[modRMIndex]&7)+bExt*8+rmHigh*16 >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("%w: extended AES source vector in physical mode32", ErrProbeNeedsContext)
+	}
+	destination, valid := decodedX86VectorRegister(destinationNumber, width)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid AES destination")
+	}
+	disp8Scale := 1
+	if evex {
+		disp8Scale = width
+	}
+	var source Operand
+	var consumed int
+	var err error
+	if code[modRMIndex]>>6 == 3 {
+		source, consumed, err = decodedX86VectorRMSource(code[modRMIndex:], mode, bExt, xExt, rmHigh, width, segment, disp8Scale)
+	} else {
+		source, consumed, err = decodedX86RMSourceWithPC(code[modRMIndex:], mode, bExt, xExt, segment, disp8Scale, memory.physicalPC)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	length := modRMIndex + consumed
+	args := []Operand{source}
+	if op == "VAESKEYGENASSIST" {
+		if len(code) <= length {
+			return Instr{}, 0, true, fmt.Errorf("missing AES imm8")
+		}
+		args = append([]Operand{{Kind: OpImm, Imm: int64(code[length])}}, args...)
+		length++
+	}
+	if !unary {
+		state, _ := decodedX86VectorRegister(stateNumber, width)
+		args = append(args, Operand{Kind: OpReg, Reg: state})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: destination})
+	spelling := make([]string, len(args))
+	for index, a := range args {
+		spelling[index] = a.String()
+	}
+	return Instr{Op: op, Args: args, Raw: string(op) + " " + strings.Join(spelling, ", "), x86Encoded: true}, length, true, nil
+}
+
+func x86AESRawOpcode(mapSelect int, opcode byte) Op {
+	if mapSelect == 3 && opcode == 0xdf {
+		return "VAESKEYGENASSIST"
+	}
+	if mapSelect == 2 {
+		switch opcode {
+		case 0xdb:
+			return "VAESIMC"
+		case 0xdc:
+			return "VAESENC"
+		case 0xdd:
+			return "VAESENCLAST"
+		case 0xde:
+			return "VAESDEC"
+		case 0xdf:
+			return "VAESDECLAST"
+		}
+	}
+	return ""
+}
diff --git a/amd64_raw_alias_test.go b/amd64_raw_alias_test.go
new file mode 100644
index 000000000..e09fa4f14
--- /dev/null
+++ b/amd64_raw_alias_test.go
@@ -0,0 +1,550 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86RawDecoderPreservesGoOpcodeAliasesAndMandatoryPrefixes(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want Op
+	}{
+		{name: "PACKSSDW is Go PACKSSLW", code: []byte{0x66, 0x0f, 0x6b, 0xca}, want: "PACKSSLW"},
+		{name: "PCMPEQD is Go PCMPEQL", code: []byte{0x66, 0x0f, 0x76, 0xca}, want: "PCMPEQL"},
+		{name: "PCMPGTD is Go PCMPGTL", code: []byte{0x66, 0x0f, 0x66, 0xca}, want: "PCMPGTL"},
+		{name: "PMADDWD is Go PMADDWL", code: []byte{0x66, 0x0f, 0xf5, 0xca}, want: "PMADDWL"},
+		{name: "PMULUDQ is Go PMULULQ", code: []byte{0x66, 0x0f, 0xf4, 0xca}, want: "PMULULQ"},
+		{name: "PSLLD is Go PSLLL", code: []byte{0x66, 0x0f, 0xf2, 0xca}, want: "PSLLL"},
+		{name: "PSRAD is Go PSRAL", code: []byte{0x66, 0x0f, 0xe2, 0xca}, want: "PSRAL"},
+		{name: "PSRLD is Go PSRLL", code: []byte{0x66, 0x0f, 0xd2, 0xca}, want: "PSRLL"},
+		{name: "PSUBD is Go PSUBL", code: []byte{0x66, 0x0f, 0xfa, 0xca}, want: "PSUBL"},
+		{name: "PUNPCKHDQ is Go PUNPCKHLQ", code: []byte{0x66, 0x0f, 0x6a, 0xca}, want: "PUNPCKHLQ"},
+		{name: "PUNPCKHWD is Go PUNPCKHWL", code: []byte{0x66, 0x0f, 0x69, 0xca}, want: "PUNPCKHWL"},
+		{name: "PUNPCKLDQ is Go PUNPCKLLQ", code: []byte{0x66, 0x0f, 0x62, 0xca}, want: "PUNPCKLLQ"},
+		{name: "PUNPCKLWD is Go PUNPCKLWL", code: []byte{0x66, 0x0f, 0x61, 0xca}, want: "PUNPCKLWL"},
+		{name: "MOVDQA is Go MOVO", code: []byte{0x66, 0x0f, 0x6f, 0xc1}, want: "MOVO"},
+		{name: "MOVDQU is Go MOVOU", code: []byte{0xf3, 0x0f, 0x6f, 0xc1}, want: "MOVOU"},
+		{name: "MOVSD XMM is Go MOVSD", code: []byte{0xf2, 0x0f, 0x10, 0xc1}, want: "MOVSD"},
+		{name: "CLFLUSHOPT mandatory prefix", code: []byte{0x66, 0x0f, 0xae, 0x38}, want: "CLFLUSHOPT"},
+		{name: "CLWB mandatory prefix", code: []byte{0x66, 0x0f, 0xae, 0x30}, want: "CLWB"},
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, test := range tests {
+			t.Run(goarch+"/"+test.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range test.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != test.want {
+					t.Fatalf("decoded %#x as %#v, want one %s instruction", test.code, got.Instrs, test.want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawDecoderVBROADCASTI128CompleteFamily(t *testing.T) {
+	tests := []struct {
+		name   string
+		goarch string
+		code   []byte
+		source MemRef
+		dest   Reg
+	}{
+		{name: "low registers", goarch: "amd64", code: []byte{0xc4, 0xe2, 0x7d, 0x5a, 0x13}, source: MemRef{Base: BX}, dest: "Y2"},
+		{name: "extended base", goarch: "amd64", code: []byte{0xc4, 0xc2, 0x7d, 0x5a, 0x13}, source: MemRef{Base: "R11"}, dest: "Y2"},
+		{name: "extended destination", goarch: "amd64", code: []byte{0xc4, 0x62, 0x7d, 0x5a, 0x1b}, source: MemRef{Base: BX}, dest: "Y11"},
+		{name: "extended base and destination with displacement", goarch: "amd64", code: []byte{0xc4, 0x42, 0x7d, 0x5a, 0x70, 0x10}, source: MemRef{Base: "R8", Off: 16}, dest: "Y14"},
+		{name: "extended SIB", goarch: "amd64", code: []byte{0xc4, 0x02, 0x7d, 0x5a, 0x64, 0x88, 0x20}, source: MemRef{Base: "R8", Index: "R9", Scale: 4, Off: 32}, dest: "Y12"},
+		{name: "FS segment", goarch: "amd64", code: []byte{0x64, 0xc4, 0xe2, 0x7d, 0x5a, 0x13}, source: MemRef{Segment: FS, Base: BX}, dest: "Y2"},
+		{name: "32-bit base", goarch: "386", code: []byte{0xc4, 0xe2, 0x7d, 0x5a, 0x53, 0x7f}, source: MemRef{Base: BX, Off: 127}, dest: "Y2"},
+		{name: "32-bit absolute", goarch: "386", code: []byte{0xc4, 0xe2, 0x7d, 0x5a, 0x15, 0x78, 0x56, 0x34, 0x12}, source: MemRef{Off: 0x12345678}, dest: "Y2"},
+	}
+	for _, test := range tests {
+		t.Run(test.goarch+"/"+test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, test.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 {
+				t.Fatalf("decoded %#x as %#v, want one instruction", test.code, got.Instrs)
+			}
+			ins := got.Instrs[0]
+			if ins.Op != "VBROADCASTI128" || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[0].Mem != test.source || ins.Args[1].Kind != OpReg || ins.Args[1].Reg != test.dest {
+				t.Fatalf("decoded %#x as %#v, want VBROADCASTI128 %#v, %s", test.code, ins, test.source, test.dest)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesArchitecturalAliasesToGo127Forms(t *testing.T) {
+	code := []byte{
+		0x41, 0x0f, 0x90, 0xc1, // SETO R9B -> SETOS R9B
+		0x41, 0x0f, 0x92, 0xc1, // SETB R9B -> SETCS R9B
+		0x48, 0x0f, 0x4e, 0xc1, // CMOVLE RAX, RCX -> CMOVQLE AX, CX
+		0x04, 0x01, // ADD $1, AL -> ADDB $1, AL
+	}
+	fn := Func{}
+	for _, value := range code {
+		fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+	}
+	got, err := decodeX86RawDirectives(fn, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []Op{"SETOS", "SETCS", "CMOVQLE", "ADDB"}
+	if len(got.Instrs) != len(want) {
+		t.Fatalf("decoded %#x as %#v, want %d instructions", code, got.Instrs, len(want))
+	}
+	for i, op := range want {
+		if got.Instrs[i].Op != op {
+			t.Errorf("decoded instruction %d as %s, want %s (%q)", i, got.Instrs[i].Op, op, got.Instrs[i].Raw)
+		}
+	}
+	if got.Instrs[0].Args[0].Reg != R9B || got.Instrs[1].Args[0].Reg != R9B {
+		t.Errorf("SETcc byte aliases = %s and %s, want R9B", got.Instrs[0].Args[0].Reg, got.Instrs[1].Args[0].Reg)
+	}
+}
+
+func TestX86RawDecoderNormalizesEveryThreeOperandIMULWidth(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want Op
+	}{
+		{name: "word imm8 register", code: []byte{0x66, 0x6b, 0xf9, 0x07}, want: "IMUL3W"},
+		{name: "long imm8 register", code: []byte{0x6b, 0xf9, 0x07}, want: "IMUL3L"},
+		{name: "quad imm8 register", code: []byte{0x48, 0x6b, 0xf9, 0x07}, want: "IMUL3Q"},
+		{name: "word imm16 memory", code: []byte{0x66, 0x69, 0x78, 0x08, 0x34, 0x12}, want: "IMUL3W"},
+		{name: "long imm32 memory", code: []byte{0x69, 0x78, 0x08, 0x78, 0x56, 0x34, 0x12}, want: "IMUL3L"},
+		{name: "quad imm32 memory", code: []byte{0x48, 0x69, 0x78, 0x08, 0x78, 0x56, 0x34, 0x12}, want: "IMUL3Q"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != test.want || len(got.Instrs[0].Args) != 3 {
+				t.Fatalf("decoded %#x as %#v, want one three-operand %s", test.code, got.Instrs, test.want)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesCompleteBSWAPFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want Op
+		reg  Reg
+	}{
+		{name: "long low register", code: []byte{0x0f, 0xc8}, want: "BSWAPL", reg: AX},
+		{name: "long extended register", code: []byte{0x41, 0x0f, 0xcf}, want: "BSWAPL", reg: Reg("R15")},
+		{name: "quad low register", code: []byte{0x48, 0x0f, 0xc8}, want: "BSWAPQ", reg: AX},
+		{name: "quad extended register", code: []byte{0x49, 0x0f, 0xcf}, want: "BSWAPQ", reg: Reg("R15")},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != test.want || len(got.Instrs[0].Args) != 1 || got.Instrs[0].Args[0].Reg != test.reg {
+				t.Fatalf("decoded %#x as %#v, want %s %s", test.code, got.Instrs, test.want, test.reg)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesCompleteScalarIntegerFloatFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want Op
+	}{
+		{name: "long to float register", code: []byte{0xf3, 0x0f, 0x2a, 0xc8}, want: "CVTSL2SS"},
+		{name: "long to float memory", code: []byte{0xf3, 0x0f, 0x2a, 0x48, 0x08}, want: "CVTSL2SS"},
+		{name: "quad to float register", code: []byte{0xf3, 0x48, 0x0f, 0x2a, 0xc8}, want: "CVTSQ2SS"},
+		{name: "quad to float memory", code: []byte{0xf3, 0x48, 0x0f, 0x2a, 0x48, 0x08}, want: "CVTSQ2SS"},
+		{name: "long to double register", code: []byte{0xf2, 0x0f, 0x2a, 0xc8}, want: "CVTSL2SD"},
+		{name: "long to double memory", code: []byte{0xf2, 0x0f, 0x2a, 0x48, 0x08}, want: "CVTSL2SD"},
+		{name: "quad to double register", code: []byte{0xf2, 0x48, 0x0f, 0x2a, 0xc8}, want: "CVTSQ2SD"},
+		{name: "quad to double memory", code: []byte{0xf2, 0x48, 0x0f, 0x2a, 0x48, 0x08}, want: "CVTSQ2SD"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != test.want || len(got.Instrs[0].Args) != 2 {
+				t.Fatalf("decoded %#x as %#v, want one %s", test.code, got.Instrs, test.want)
+			}
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesCompleteScalarFloatIntegerFamily(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, precision := range []struct {
+			name   string
+			prefix byte
+		}{
+			{name: "SS", prefix: 0xf3},
+			{name: "SD", prefix: 0xf2},
+		} {
+			for _, conversion := range []struct {
+				name   string
+				opcode byte
+			}{
+				{name: "CVT", opcode: 0x2d},
+				{name: "CVTT", opcode: 0x2c},
+			} {
+				for _, width := range []struct {
+					name string
+					rex  []byte
+				}{
+					{name: "L"},
+					{name: "Q", rex: []byte{0x48}},
+				} {
+					if goarch == "386" && width.name == "Q" {
+						continue
+					}
+					for _, source := range []struct {
+						name  string
+						modRM byte
+						disp  []byte
+					}{
+						{name: "register", modRM: 0xc1},
+						{name: "memory", modRM: 0x43, disp: []byte{0x08}},
+					} {
+						name := goarch + "/" + conversion.name + precision.name + "2S" + width.name + "/" + source.name
+						t.Run(name, func(t *testing.T) {
+							code := []byte{precision.prefix}
+							code = append(code, width.rex...)
+							code = append(code, 0x0f, conversion.opcode, source.modRM)
+							code = append(code, source.disp...)
+							fn := Func{}
+							for _, value := range code {
+								fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+							}
+							got, err := decodeX86RawDirectives(fn, goarch)
+							if err != nil {
+								t.Fatal(err)
+							}
+							want := Op(conversion.name + precision.name + "2S" + width.name)
+							if len(got.Instrs) != 1 || got.Instrs[0].Op != want || len(got.Instrs[0].Args) != 2 {
+								t.Fatalf("decoded %#x as %#v, want one %s", code, got.Instrs, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawScalarFloatIntegerReportedEncoding(t *testing.T) {
+	const source = `TEXT rawScalarFloatInteger(SB),$0-0
+	LONG $0x2c0f48f2
+	BYTE $0xc0 // CVTTSD2SQ X0, AX
+	RET
+`
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+			if !strings.Contains(ir, `call i64 asm sideeffect "cvttsd2siq $1, $0"`) || strings.Contains(ir, "fptosi double") {
+				t.Fatalf("raw CVTTSD2SQ semantics missing:\n%s", ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-scalar-float-integer.ll", "raw-scalar-float-integer.o", ir)
+		})
+	}
+}
+
+func TestX86RawDecoderNormalizesCompleteMOVNTDQFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		reg  Reg
+		base Reg
+	}{
+		{name: "low vector and base registers", code: []byte{0x66, 0x0f, 0xe7, 0x13}, reg: Reg("X2"), base: BX},
+		{name: "extended vector register", code: []byte{0x66, 0x44, 0x0f, 0xe7, 0x1b}, reg: Reg("X11"), base: BX},
+		{name: "extended base register", code: []byte{0x66, 0x41, 0x0f, 0xe7, 0x13}, reg: Reg("X2"), base: Reg("R11")},
+		{name: "extended vector and base registers", code: []byte{0x66, 0x45, 0x0f, 0xe7, 0x1b}, reg: Reg("X11"), base: Reg("R11")},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || got.Instrs[0].Op != "MOVNTO" || len(got.Instrs[0].Args) != 2 || got.Instrs[0].Args[0].Reg != test.reg || got.Instrs[0].Args[1].Mem.Base != test.base {
+				t.Fatalf("decoded %#x as %#v, want MOVNTO %s, (%s)", test.code, got.Instrs, test.reg, test.base)
+			}
+		})
+	}
+}
+
+func TestTranslateAMD64MOVNTOCompleteOperandForm(t *testing.T) {
+	const source = `TEXT movnto(SB),$0-0
+	MOVNTO X2, 32(BX)(R8*1)
+	MOVNTO X11, sink<>(SB)
+	RET
+
+GLOBL sink<>(SB),$16
+`
+	ir := x86UnboundVoidScalarFormatObject(t, source, "movnto", "amd64", "x86_64-unknown-linux-gnu")
+	if count := strings.Count(ir, `asm sideeffect "movntdq `); count != 2 {
+		t.Fatalf("MOVNTO emitted %d native stores, want 2:\n%s", count, ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-movnto.ll", "amd64-movnto.o", ir)
+}
+
+func TestDecodedX86CacheLineWritebackCoversMemoryEncodingsWithoutFalsePositives(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+		ok   bool
+	}{
+		{name: "CLFLUSHOPT displacement", code: []byte{0x67, 0x66, 0x0f, 0xae, 0x78, 0x08}, want: "CLFLUSHOPT", ok: true},
+		{name: "CLWB SIB displacement", code: []byte{0x66, 0x0f, 0xae, 0xb4, 0x24, 0x78, 0x56, 0x34, 0x12}, want: "CLWB", ok: true},
+		{name: "CLWB REX base", code: []byte{0x66, 0x41, 0x0f, 0xae, 0x30}, want: "CLWB", ok: true},
+		{name: "plain CLFLUSH", code: []byte{0x0f, 0xae, 0x38}},
+		{name: "plain XSAVEOPT", code: []byte{0x0f, 0xae, 0x30}},
+		{name: "register ModRM", code: []byte{0x66, 0x0f, 0xae, 0xf8}},
+		{name: "opcode bytes in displacement", code: []byte{0x66, 0x8b, 0x80, 0x0f, 0xae, 0x38, 0x00}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, ok := decodedX86CacheLineWriteback(test.code)
+			if got != test.want || ok != test.ok {
+				t.Fatalf("decodedX86CacheLineWriteback(%#x) = %q, %v; want %q, %v", test.code, got, ok, test.want, test.ok)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedWencodeCLFLUSHOPT(t *testing.T) {
+	code := []byte{0x41, 0x66, 0x0f, 0xae, 0x3c, 0x09}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "wencode CLFLUSHOPT sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "CLFLUSHOPT" || len(decoded[0].Args) != 1 || decoded[0].Args[0].String() != "0(CX)(CX*1)" {
+		t.Fatalf("decoded %x as %#v, want CLFLUSHOPT 0(CX)(CX*1)", code, decoded)
+	}
+}
+
+func encodeX86RawCacheLineWriteback(op Op, mode, base, index int) []byte {
+	extension := byte(7)
+	mandatory := op != "CLFLUSH"
+	if op == "CLWB" {
+		extension = 6
+	}
+	var prefixes []byte
+	if mode == 64 {
+		rex := byte(0x40 | base/8 | index/8<<1)
+		if mandatory {
+			prefixes = append(prefixes, 0x66)
+		}
+		prefixes = append(prefixes, rex)
+	} else if mandatory {
+		prefixes = append(prefixes, 0x66)
+	}
+	mod := byte(0)
+	if base&7 == 5 {
+		mod = 1
+	}
+	modRM := mod<<6 | extension<<3 | 4
+	sib := byte(2<<6 | (index&7)<<3 | base&7)
+	code := append(prefixes, 0x0f, 0xae, modRM, sib)
+	if mod == 1 {
+		code = append(code, 0)
+	}
+	return code
+}
+
+func TestDecodedX86RawCacheLineWritebackCompleteRegisterAddressFamily(t *testing.T) {
+	operations := []Op{"CLFLUSH", "CLFLUSHOPT", "CLWB"}
+	count := 0
+	for _, mode := range []int{32, 64} {
+		registers := 8
+		if mode == 64 {
+			registers = 16
+		}
+		for _, op := range operations {
+			for base := 0; base < registers; base++ {
+				for index := 0; index < registers; index++ {
+					if index == 4 {
+						continue // SIB index 4 without X is the no-index encoding.
+					}
+					code := encodeX86RawCacheLineWriteback(op, mode, base, index)
+					got, length, ok, err := decodedX86CacheLineWritebackInstruction(code, mode)
+					baseReg, _ := decodedX86GeneralRegister(base)
+					indexReg, _ := decodedX86GeneralRegister(index)
+					wantMemory := MemRef{Base: baseReg, Index: indexReg, Scale: 4}
+					if err != nil || !ok || length != len(code) || got.Op != op || len(got.Args) != 1 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantMemory {
+						t.Fatalf("decode mode=%d %x = %+v, length=%d, ok=%v, err=%v; want %s %+v", mode, code, got, length, ok, err, op, wantMemory)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 888 {
+		t.Fatalf("covered %d cache-line register-address encodings, want 888", count)
+	}
+}
+
+func TestDecodedX86RawCacheLineWritebackMemoryAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+		op   Op
+		mem  MemRef
+	}{
+		{name: "CLFLUSH base", code: []byte{0x0f, 0xae, 0x3b}, mode: 64, op: "CLFLUSH", mem: MemRef{Base: BX}},
+		{name: "CLFLUSHOPT disp8", code: []byte{0x66, 0x0f, 0xae, 0x7e, 0x7f}, mode: 64, op: "CLFLUSHOPT", mem: MemRef{Base: SI, Off: 127}},
+		{name: "CLWB disp32", code: []byte{0x66, 0x0f, 0xae, 0xb7, 0x78, 0x56, 0x34, 0x12}, mode: 64, op: "CLWB", mem: MemRef{Base: DI, Off: 0x12345678}},
+		{name: "CLFLUSHOPT ineffective REX before 66", code: []byte{0x41, 0x66, 0x0f, 0xae, 0x3c, 0x09}, mode: 64, op: "CLFLUSHOPT", mem: MemRef{Base: CX, Index: CX, Scale: 1}},
+		{name: "CLFLUSHOPT effective REX after 66", code: []byte{0x66, 0x41, 0x0f, 0xae, 0x3c, 0x09}, mode: 64, op: "CLFLUSHOPT", mem: MemRef{Base: "R9", Index: CX, Scale: 1}},
+		{name: "CLWB FS extended SIB", code: []byte{0x64, 0x66, 0x43, 0x0f, 0xae, 0x74, 0x8b, 0x20}, mode: 64, op: "CLWB", mem: MemRef{Segment: FS, Base: "R11", Index: "R9", Scale: 4, Off: 32}},
+		{name: "CLFLUSHOPT 386 absolute", code: []byte{0x66, 0x0f, 0xae, 0x3d, 0x78, 0x56, 0x34, 0x12}, mode: 32, op: "CLFLUSHOPT", mem: MemRef{Off: 0x12345678}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86CacheLineWritebackInstruction(test.code, test.mode)
+			if err != nil || !ok || length != len(test.code) || got.Op != test.op || len(got.Args) != 1 || got.Args[0].Kind != OpMem || got.Args[0].Mem != test.mem {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %s %+v", test.code, got, length, ok, err, test.op, test.mem)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "address override", code: []byte{0x67, 0x66, 0x0f, 0xae, 0x38}, mode: 64},
+		{name: "REX.W", code: []byte{0x66, 0x48, 0x0f, 0xae, 0x38}, mode: 64},
+		{name: "REX.R", code: []byte{0x66, 0x44, 0x0f, 0xae, 0x38}, mode: 64},
+		{name: "register operand", code: []byte{0x66, 0x0f, 0xae, 0xf8}, mode: 64},
+		{name: "RIP relative", code: []byte{0x66, 0x0f, 0xae, 0x3d, 0, 0, 0, 0}, mode: 64},
+		{name: "truncated SIB", code: []byte{0x66, 0x0f, 0xae, 0x3c}, mode: 64},
+		{name: "truncated disp8", code: []byte{0x66, 0x0f, 0xae, 0x78}, mode: 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86CacheLineWritebackInstruction(test.code, test.mode)
+			if !ok || err == nil {
+				t.Fatalf("invalid encoding %x returned ok=%v err=%v", test.code, ok, err)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		{0x0f, 0xae, 0x30},                         // XSAVEOPT, not CLWB.
+		{0x66, 0x0f, 0xae, 0x28},                   // unrelated ModRM extension.
+		{0x66, 0x0f, 0xaf, 0x38},                   // unrelated opcode.
+		{0x66, 0x0f},                               // truncated before the opcode can be identified.
+		{0xf2, 0x66, 0x0f, 0xae, 0x38},             // unsupported mandatory prefix combination.
+		{0x66, 0x0f, 0xae, 0x38, 0x0f, 0xae, 0x38}, // only the first instruction is consumed.
+	} {
+		_, length, ok, err := decodedX86CacheLineWritebackInstruction(code, 64)
+		if len(code) == 7 {
+			if err != nil || !ok || length != 4 {
+				t.Fatalf("concatenated encoding %x returned length=%d ok=%v err=%v", code, length, ok, err)
+			}
+			continue
+		}
+		if ok || err != nil {
+			t.Fatalf("unrelated encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateX86RawAliasesThroughLLVM22(t *testing.T) {
+	const source = `TEXT rawaliases(SB),$0-0
+	BYTE $0x66; BYTE $0x0f; BYTE $0x6b; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x76; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x66; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xf5; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xf4; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xf2; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xe2; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xd2; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0xfa; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x6a; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x69; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x62; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x61; BYTE $0xca
+	BYTE $0x66; BYTE $0x0f; BYTE $0x6f; BYTE $0xc1
+	BYTE $0xf3; BYTE $0x0f; BYTE $0x6f; BYTE $0xc1
+	BYTE $0xf2; BYTE $0x0f; BYTE $0x10; BYTE $0xc1
+	BYTE $0x66; BYTE $0x0f; BYTE $0xae; BYTE $0x38
+	BYTE $0x66; BYTE $0x0f; BYTE $0xae; BYTE $0x30
+	RET
+`
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			// These original bytes supply neither X inputs nor the AX cache
+			// address. Their complete formats remain objects, not public entries.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			for _, want := range []string{"clflushopt $0", "clwb $0", "+clflushopt,+clwb"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw alias lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "x86-raw-aliases.ll", "x86-raw-aliases.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_align_right_test.go b/amd64_raw_align_right_test.go
new file mode 100644
index 000000000..c9491493e
--- /dev/null
+++ b/amd64_raw_align_right_test.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawPALIGNR(immediate byte, mode, source, destination int) []byte {
+	code := []byte{0x66}
+	if mode == 64 {
+		code = append(code, byte(0x40|destination/8<<2|source/8))
+	}
+	modRM := byte(0xc0 | destination&7<<3 | source&7)
+	return append(code, 0x0f, 0x3a, 0x0f, modRM, immediate)
+}
+
+func encodeX86RawVEXVPALIGNR(immediate byte, wide bool, first, second, destination int) []byte {
+	p0 := byte((1-destination/8)<<7 | 1<<6 | (1-first/8)<<5 | 3)
+	p1 := byte((^second&15)<<3 | 1)
+	if wide {
+		p1 |= 4
+	}
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	return []byte{0xc4, p0, p1, 0x0f, modRM, immediate}
+}
+
+func encodeX86RawEVEXVPALIGNR(immediate, vectorBits byte, mask int, zeroing bool, first, second, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 3
+	p1 := byte(^second&15)<<3 | 5
+	p2 := vectorBits<<5 | byte((^second>>4)&1)<<3 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	return []byte{0x62, p0, p1, p2, 0x0f, modRM, immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedIPFSVPALIGNR(t *testing.T) {
+	code := []byte{0xc4, 0xe3, 0x41, 0x0f, 0xc6, 0x04}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "IPFS VPALIGNR sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "VPALIGNR $4, X6, X7, X0"
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, want+" ") {
+		t.Fatalf("decoded %x as %#v, want %q", code, decoded, want)
+	}
+}
+
+func TestDecodedX86RawPALIGNRCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, mode := range []int{32, 64} {
+		registers := 8
+		if mode == 64 {
+			registers = 16
+		}
+		for source := 0; source < registers; source++ {
+			for destination := 0; destination < registers; destination++ {
+				immediate := byte(source*16 + destination)
+				code := encodeX86RawPALIGNR(immediate, mode, source, destination)
+				got, length, ok, err := decodedX86PackedAlignRightInstruction(code, mode)
+				want := fmt.Sprintf("PALIGNR $%d, X%d, X%d", immediate, source, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode mode=%d %x = %+v, length=%d, ok=%v, err=%v; want %q", mode, code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+	}
+	if count != 320 {
+		t.Fatalf("covered %d PALIGNR register encodings, want 320", count)
+	}
+}
+
+func TestDecodedX86RawVPALIGNRCompleteVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for _, wide := range []bool{false, true} {
+		vectorName := "X"
+		if wide {
+			vectorName = "Y"
+		}
+		for first := 0; first < 16; first++ {
+			for second := 0; second < 16; second++ {
+				for destination := 0; destination < 16; destination++ {
+					immediate := byte(first*16 + destination)
+					code := encodeX86RawVEXVPALIGNR(immediate, wide, first, second, destination)
+					got, length, ok, err := decodedX86PackedAlignRightInstruction(code, 64)
+					want := fmt.Sprintf("VPALIGNR $%d, %s%d, %s%d, %s%d", immediate, vectorName, first, vectorName, second, vectorName, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d VEX VPALIGNR register encodings, want 8192", count)
+	}
+}
+
+func TestDecodedX86RawVPALIGNRCompleteEVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+		for _, masking := range []struct {
+			mask    int
+			zeroing bool
+			suffix  string
+		}{
+			{},
+			{mask: 3},
+			{mask: 7, zeroing: true, suffix: ".Z"},
+		} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						immediate := byte(first*8 + destination)
+						code := encodeX86RawEVEXVPALIGNR(immediate, byte(vectorBits), masking.mask, masking.zeroing, first, second, destination)
+						got, length, ok, err := decodedX86PackedAlignRightInstruction(code, 64)
+						args := []string{
+							fmt.Sprintf("$%d", immediate),
+							fmt.Sprintf("%s%d", vectorName, first),
+							fmt.Sprintf("%s%d", vectorName, second),
+						}
+						if masking.mask != 0 {
+							args = append(args, fmt.Sprintf("K%d", masking.mask))
+						}
+						args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+						want := "VPALIGNR" + masking.suffix + " " + strings.Join(args, ", ")
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 294912 {
+		t.Fatalf("covered %d EVEX VPALIGNR register encodings, want 294912", count)
+	}
+}
+
+func TestDecodedX86RawPackedAlignRightMemoryAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{
+			name: "legacy extended SIB",
+			code: []byte{0x64, 0x66, 0x47, 0x0f, 0x3a, 0x0f, 0x64, 0x8b, 0x20, 0xff},
+			want: "PALIGNR $255, 32(R11)(R9*4)(FS), X12",
+		},
+		{
+			name: "VEX extended SIB",
+			code: []byte{0x65, 0xc4, 0x03, 0x15, 0x0f, 0x64, 0x8b, 0x20, 0xfe},
+			want: "VPALIGNR $254, 32(R11)(R9*4)(GS), Y13, Y12",
+		},
+		{
+			name: "EVEX compressed disp8 zero mask",
+			code: []byte{0x64, 0x62, 0x03, 0x15, 0xc2, 0x0f, 0x64, 0x8b, 0x7f, 0xfd},
+			want: "VPALIGNR.Z $253, 8128(R11)(R9*4)(FS), Z29, K2, Z28",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86PackedAlignRightInstruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) || got.Raw != test.want {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", test.code, got, length, ok, err, test.want)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "VEX 386 operand limit", mode: 32, encoding: encodeX86RawVEXVPALIGNR(1, false, 0, 1, 2), wantOK: true},
+		{name: "EVEX 386 operand limit", mode: 32, encoding: encodeX86RawEVEXVPALIGNR(1, 0, 0, false, 0, 1, 2), wantOK: true},
+		{name: "VEX wrong pp", mode: 64, encoding: []byte{0xc4, 0xe3, 0x40, 0x0f, 0xc6, 4}, wantOK: true},
+		{name: "VEX W", mode: 64, encoding: []byte{0xc4, 0xe3, 0xc1, 0x0f, 0xc6, 4}, wantOK: true},
+		{name: "VEX truncated immediate", mode: 64, encoding: []byte{0xc4, 0xe3, 0x41, 0x0f, 0xc6}, wantOK: true},
+		{name: "EVEX W", mode: 64, encoding: []byte{0x62, 0xf3, 0x85, 0x08, 0x0f, 0xc2, 4}, wantOK: true},
+		{name: "EVEX broadcast", mode: 64, encoding: []byte{0x62, 0xf3, 0x05, 0x18, 0x0f, 0x02, 4}, wantOK: true},
+		{name: "EVEX reserved vector length", mode: 64, encoding: []byte{0x62, 0xf3, 0x05, 0x68, 0x0f, 0xc2, 4}, wantOK: true},
+		{name: "EVEX zero without mask", mode: 64, encoding: []byte{0x62, 0xf3, 0x05, 0x88, 0x0f, 0xc2, 4}, wantOK: true},
+		{name: "EVEX truncated immediate", mode: 64, encoding: []byte{0x62, 0xf3, 0x05, 0x08, 0x0f, 0xc2}, wantOK: true},
+		{name: "legacy REX.W", mode: 64, encoding: []byte{0x66, 0x48, 0x0f, 0x3a, 0x0f, 0xc2, 4}, wantOK: true},
+		{name: "legacy RIP relative", mode: 64, encoding: []byte{0x66, 0x0f, 0x3a, 0x0f, 0x05, 0, 0, 0, 0, 4}, wantOK: true},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0xc4, 0xe3, 0x41, 0x0f, 0xc6, 4}, wantOK: true},
+		{name: "wrong opcode", mode: 64, encoding: []byte{0xc4, 0xe3, 0x41, 0x0e, 0xc6, 4}},
+		{name: "wrong map", mode: 64, encoding: []byte{0xc4, 0xe2, 0x41, 0x0f, 0xc6, 4}},
+		{name: "legacy missing 66", mode: 64, encoding: []byte{0x0f, 0x3a, 0x0f, 0xc2, 4}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86PackedAlignRightInstruction(test.encoding, test.mode)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x returned ok=%v err=%v, want ok=%v", test.encoding, ok, err, test.wantOK)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("invalid encoding %x was accepted", test.encoding)
+			}
+			if !test.wantOK && err != nil {
+				t.Fatalf("unrelated encoding %x returned err=%v", test.encoding, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_andn.go b/amd64_raw_andn.go
new file mode 100644
index 000000000..07875065d
--- /dev/null
+++ b/amd64_raw_andn.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86ANDNInstruction recognizes the complete BMI1 ANDNL/ANDNQ
+// Yml,Yrl,Yrl family. x/arch v0.14 reports this VEX.NDS encoding as an
+// unknown AVX opcode, so recover every register and safe ModRM/SIB memory form
+// before generic decoding.
+func decodedX86ANDNInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86ANDNInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86ANDNInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto vex
+		}
+	}
+
+vex:
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 2 || code[i+3] != 0xf2 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	vexExt, vexByte := code[i+1], code[i+2]
+	if vexByte&7 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("reserved ANDN VEX prefix")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if len(code) <= i+4 {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	rExt := int(^vexExt>>7) & 1
+	xExt := int(^vexExt>>6) & 1
+	bExt := int(^vexExt>>5) & 1
+	width64 := vexByte&0x80 != 0
+	secondNumber := int(^vexByte>>3) & 15
+	modRM := code[i+4]
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (secondNumber >= 8 || destinationNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended source or destination register in 32-bit mode")
+	}
+	second, valid := decodedX86GeneralRegister(secondNumber)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid second-source register %d", secondNumber)
+	}
+	destination, valid := decodedX86GeneralRegister(destinationNumber)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid destination register %d", destinationNumber)
+	}
+	first, consumed, err := memory.scalar(code[i+4:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := Op("ANDNL")
+	if width64 && mode == 64 {
+		op = "ANDNQ"
+	}
+	instruction = Instr{
+		Op:   op,
+		Args: []Operand{first, {Kind: OpReg, Reg: second}, {Kind: OpReg, Reg: destination}},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, first.String(), second, destination),
+	}
+	return instruction, i + 4 + consumed, true, nil
+}
diff --git a/amd64_raw_average.go b/amd64_raw_average.go
new file mode 100644
index 000000000..7cdd70fed
--- /dev/null
+++ b/amd64_raw_average.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import "fmt"
+
+// The complete VEX/EVEX physical decoder is the only producer of the private
+// marker which distinguishes raw mode32 masks from named Go's operand limit.
+func decodedX86PackedAverageInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedAverageInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedAverageInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || p.pp != 1 || p.opcode != 0xe0 && p.opcode != 0xe3 {
+		return Instr{}, 0, false, nil
+	}
+	if p.broadcast {
+		return Instr{}, 0, true, fmt.Errorf("packed average has no broadcast or rounding encoding")
+	}
+	op, bits := Op("VPAVGB"), 8
+	if p.opcode == 0xe3 {
+		op, bits = "VPAVGW", 16
+	}
+	// WIG is a hardware property; the named Go encoder always emits W0.
+	return decodedX86BinaryVectorOperandsWithMemory(code, p, mode, op, bits, memory)
+}
diff --git a/amd64_raw_bf16_convert.go b/amd64_raw_bf16_convert.go
new file mode 100644
index 000000000..ec190bbeb
--- /dev/null
+++ b/amd64_raw_bf16_convert.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27 has no named AVX-512 BF16 encodings. Conversion and dot-product
+// instructions share widths, masks and dword broadcasts; only conversion
+// narrows its destination and reserves vvvv.
+func decodedX86RawBF16Instruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || !p.evex || p.mapNumber != 2 || p.pp != 2 || (p.opcode != 0x72 && p.opcode != 0x52) {
+		return Instr{}, 0, false, nil
+	}
+	dot := p.opcode == 0x52
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("raw BF16: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.w || !dot && p.upper != 0 || p.vectorLength > 2 {
+		return fail("reserved EVEX width, source or vector-length field")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero K mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	if p.broadcast && registerSource {
+		return fail("broadcast requires a memory source")
+	}
+	if mode == 32 && (!registerSource && (p.b != 0 || p.x != 0) || p.r != 0 || p.upper >= 8) {
+		return fail("extended address or destination register in 32-bit mode")
+	}
+
+	sourceBytes := 16 << p.vectorLength
+	sourcePrefix := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	destinationPrefix := [...]string{"X", "X", "Y"}[p.vectorLength]
+	if dot {
+		destinationPrefix = sourcePrefix
+	}
+	accessBytes := sourceBytes
+	if p.broadcast {
+		accessBytes = 4
+	}
+	source, consumed, err := decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, sourcePrefix, accessBytes)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if mode == 32 && registerSource {
+		index, _ := amd64VectorRegisterIndex(source.Reg, sourceBytes)
+		if index > 7 {
+			return fail("extended source register in 32-bit mode")
+		}
+	}
+	destination := int(code[p.modRM]>>3&7) + p.r*8
+	op := [...]Op{"VCVTNEPS2BF16X", "VCVTNEPS2BF16Y", "VCVTNEPS2BF16"}[p.vectorLength]
+	if dot {
+		op = "VDPBF16PS"
+	}
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{source}
+	if dot {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", sourcePrefix, p.upper))})
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationPrefix, destination))})
+	parts := make([]string, len(args))
+	for i, arg := range args {
+		parts[i] = arg.String()
+	}
+	return Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(parts, ", ")),
+		x86Encoded: true,
+	}, p.modRM + consumed, true, nil
+}
+
+func decodeX86RawBF16RIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, ok := decodeX86RawVectorEncoding(code[offset:])
+	if !ok || !p.evex || p.mapNumber != 2 || p.pp != 2 || (p.opcode != 0x52 && p.opcode != 0x72) ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRM := offset + p.modRM
+	if len(code) <= modRM || code[modRM]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+	}
+	return x86RawRIPDataThroughDecoder(code, offset, mode, modRM, width, decodedX86RawBF16Instruction, "BF16")
+}
diff --git a/amd64_raw_bf16_convert_test.go b/amd64_raw_bf16_convert_test.go
new file mode 100644
index 000000000..82eab0a00
--- /dev/null
+++ b/amd64_raw_bf16_convert_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawBF16Convert(vectorBits, source, destination, mask int, zeroing, broadcast, memory bool) []byte {
+	if memory {
+		source = 0
+	}
+	p0 := byte((1-destination/8&1)<<7 | (1-source/16)<<6 |
+		(1-source/8&1)<<5 | (1-destination/16)<<4 | 2)
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | destination&7<<3 | source&7)
+	if memory {
+		modRM = byte(0x40 | destination&7<<3)
+	}
+	code := []byte{0x62, p0, 0x7e, p2, 0x72, modRM}
+	if memory {
+		code = append(code, 7)
+	}
+	return code
+}
+
+func TestDecodedX86RawBF16ConvertCompleteLLVM22Forms(t *testing.T) {
+	for vectorBits, names := range []struct {
+		op     Op
+		source string
+		dest   string
+	}{
+		{"VCVTNEPS2BF16X", "X", "X"},
+		{"VCVTNEPS2BF16Y", "Y", "X"},
+		{"VCVTNEPS2BF16", "Z", "Y"},
+	} {
+		for _, memory := range []bool{false, true} {
+			for _, masked := range []bool{false, true} {
+				mask := 0
+				if masked {
+					mask = 3
+				}
+				for _, zeroing := range []bool{false, true} {
+					if zeroing && !masked {
+						continue
+					}
+					for _, broadcast := range []bool{false, true} {
+						if broadcast && !memory {
+							continue
+						}
+						code := encodeX86RawBF16Convert(vectorBits, 20, 21, mask, zeroing, broadcast, memory)
+						got, length, ok, err := decodedX86RawBF16Instruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantOp := names.op
+						if broadcast {
+							wantOp += ".BCST"
+						}
+						if zeroing {
+							wantOp += ".Z"
+						}
+						if got.Op != wantOp || got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s21", names.dest) {
+							t.Fatalf("decode %x = %+v, want %s -> %s21", code, got, wantOp, names.dest)
+						}
+						if !memory && got.Args[0].String() != fmt.Sprintf("%s20", names.source) {
+							t.Fatalf("decode %x source = %s, want %s20", code, got.Args[0], names.source)
+						}
+						if memory {
+							accessBytes := 16 << vectorBits
+							if broadcast {
+								accessBytes = 4
+							}
+							if want := fmt.Sprintf("%d(AX)", 7*accessBytes); got.Args[0].String() != want {
+								t.Fatalf("decode %x source = %s, want exact tuple %s", code, got.Args[0], want)
+							}
+						}
+						if masked && (len(got.Args) != 3 || got.Args[1].String() != "K3") {
+							t.Fatalf("decode %x lost K3: %+v", code, got)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawBF16ConvertRejectsReservedFields(t *testing.T) {
+	valid := encodeX86RawBF16Convert(2, 1, 2, 0, false, false, false)
+	for _, change := range []struct {
+		index int
+		bits  byte
+	}{
+		{2, 0x80}, // EVEX.W
+		{2, 0x08}, // reserved vvvv
+		{3, 0x20}, // reserved LL
+		{3, 0x80}, // zeroing without a K mask
+		{3, 0x10}, // broadcast with register source
+	} {
+		bad := append([]byte(nil), valid...)
+		bad[change.index] ^= change.bits
+		if _, _, ok, err := decodedX86RawBF16Instruction(bad, 64); !ok || err == nil {
+			t.Fatalf("accepted reserved BF16 conversion %x: ok=%v err=%v", bad, ok, err)
+		}
+	}
+	if _, _, ok, err := decodedX86RawBF16Instruction(valid[:5], 64); ok && err == nil {
+		t.Fatal("accepted truncated BF16 conversion")
+	}
+}
+
+func TestTranslateRawBF16ConvertMaskAndBroadcastTargets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawBF16ConvertForms(SB),$0-0\n")
+	for vectorBits := 0; vectorBits < 3; vectorBits++ {
+		for _, memory := range []bool{false, true} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !memory {
+					continue
+				}
+				code := encodeX86RawBF16Convert(vectorBits, 1, 2, 3, true, broadcast, memory)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"rawBF16ConvertForms": {Name: "rawBF16ConvertForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			body := x86StringMemoryFunction(t, ir, "rawBF16ConvertForms")
+			// Count actual instructions inside the function. The original
+			// register/BCST rows never used a full-vector masked load; an
+			// unconditional unused declaration formerly hid that gap.
+			for _, want := range []struct {
+				text  string
+				count int
+			}{
+				{" = call <8 x bfloat> @llvm.x86.vcvtneps2bf16128(", 3},
+				{" = call <8 x bfloat> @llvm.x86.vcvtneps2bf16256(", 3},
+				{" = call <16 x bfloat> @llvm.x86.avx512bf16.cvtneps2bf16.512(", 3},
+				{" = call <4 x i32> @llvm.masked.load.v4i32.p0(", 1},
+				{" = call <8 x i32> @llvm.masked.load.v8i32.p0(", 1},
+				{" = call <16 x i32> @llvm.masked.load.v16i32.p0(", 1},
+				{" = load volatile i32, ", 3},
+				{" = phi i32 ", 3},
+			} {
+				if count := strings.Count(body, want.text); count != want.count {
+					t.Fatalf("BF16 lowering emitted %d uses of %q, want %d", count, want.text, want.count)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "amd64-raw-bf16-convert-forms.ll", "amd64-raw-bf16-convert-forms.o", ir)
+		})
+	}
+}
+
+func TestTranslateRawBF16Convert386Targets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawBF16Convert386(SB),$0-0\n")
+	for vectorBits := 0; vectorBits < 3; vectorBits++ {
+		code := encodeX86RawBF16Convert(vectorBits, 1, 2, 0, false, false, false)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "386",
+				Sigs: map[string]FuncSig{
+					"rawBF16Convert386": {Name: "rawBF16Convert386", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "386-raw-bf16-convert.ll", "386-raw-bf16-convert.o", ir)
+		})
+	}
+}
+
+func TestTranslateRawBF16ConvertGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawBF16Convert(SB),$0-0
+	LONG $0x487ef262; WORD $0x0472; BYTE $0x97 // VCVTNEPS2BF16 (DI)(DX*4), Y0
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		triple string
+		goos   string
+	}{
+		{"x86_64-apple-darwin", "darwin"},
+		{"x86_64-unknown-linux-gnu", "linux"},
+		{"x86_64-pc-windows-msvc", "windows"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "amd64",
+				Sigs: map[string]FuncSig{
+					"rawBF16Convert": {Name: "rawBF16Convert", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "amd64-raw-bf16-convert.ll", "amd64-raw-bf16-convert.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_bf16_dot_test.go b/amd64_raw_bf16_dot_test.go
new file mode 100644
index 000000000..af4ca0d1a
--- /dev/null
+++ b/amd64_raw_bf16_dot_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func rawBF16Dot(length byte, source1, source2, destination, mask int, memory, broadcast, zero bool) []byte {
+	code := encodeX86EVEXFMA3(0x52, false, length, broadcast, zero, mask, destination, source1, source2)
+	code[2] = code[2]&^3 | 2 // EVEX.F3.0F38.W0.
+	if memory {
+		code[1] |= 0x60
+		code[5] = byte(0x40 | (destination&7)<<3)
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeRawBF16DotCompleteFormats(t *testing.T) {
+	for length := byte(0); length < 3; length++ {
+		for _, memory := range []bool{false, true} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !memory {
+					continue
+				}
+				for _, mask := range []int{0, 1, 7} {
+					for _, zero := range []bool{false, true} {
+						if zero && mask == 0 {
+							continue
+						}
+						code := rawBF16Dot(length, 20, 21, 22, mask, memory, broadcast, zero)
+						got, err := decodeX86RawDirectiveGroup(code, 64, 0, "BF16 dot", map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := Op("VDPBF16PS")
+						if broadcast {
+							want += ".BCST"
+						}
+						if zero {
+							want += ".Z"
+						}
+						prefix := [...]string{"X", "Y", "Z"}[length]
+						if len(got) != 1 || got[0].Op != want || !got[0].x86Encoded ||
+							got[0].Args[1].String() != prefix+"20" || got[0].Args[len(got[0].Args)-1].String() != prefix+"22" {
+							t.Fatalf("%x: got %+v, want raw %s %s20 -> %s22", code, got, want, prefix, prefix)
+						}
+						wantSource := prefix + "21"
+						if memory {
+							width := 16 << length
+							if broadcast {
+								width = 4 // Broadcast one BF16 pair, not one 16-bit input.
+							}
+							wantSource = fmt.Sprintf("%d(AX)", width)
+						}
+						if got[0].Args[0].String() != wantSource {
+							t.Fatalf("%x: source %s, want %s", code, got[0].Args[0], wantSource)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeRawBF16DotInvalidFormats(t *testing.T) {
+	for _, change := range []struct {
+		index int
+		bits  byte
+	}{
+		{2, 0x80}, {2, 0x04}, {3, 0x80}, {3, 0x60}, {3, 0x10},
+	} {
+		code := rawBF16Dot(0, 1, 2, 3, 0, false, false, false)
+		code[change.index] ^= change.bits
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid BF16 dot", map[string]bool{}); err == nil {
+			t.Fatalf("accepted reserved BF16 dot %x", code)
+		}
+	}
+	for _, code := range [][]byte{
+		rawBF16Dot(0, 8, 1, 2, 0, false, false, false),
+		rawBF16Dot(1, 1, 8, 2, 0, false, false, false),
+		rawBF16Dot(2, 1, 2, 8, 0, false, false, false),
+	} {
+		if _, err := decodeX86RawDirectiveGroup(code, 32, 0, "386 BF16 extended register", map[string]bool{}); err == nil {
+			t.Fatalf("accepted 386 extended register %x", code)
+		}
+	}
+}
+
+func TestTranslateRawBF16DotLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawBF16Dot(SB),4,$0-0\n")
+	for length := byte(0); length < 3; length++ {
+		for _, memory := range []bool{false, true} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !memory {
+					continue
+				}
+				code := rawBF16Dot(length, 1, 2, 3, 1, memory, broadcast, true)
+				for _, b := range code {
+					fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+				}
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range []struct {
+		arch, triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawBF16Dot": {Name: "rawBF16Dot", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"@llvm.x86.avx512bf16.dpbf16ps.128", "@llvm.x86.avx512bf16.dpbf16ps.256",
+				"@llvm.x86.avx512bf16.dpbf16ps.512", "@llvm.masked.load.v4i32", "phi i32", "+avx512bf16"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %s", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-bf16-dot.ll", "raw-bf16-dot.o", ir)
+			cmd := exec.Command(llc, "-O0", "-mtriple="+target.triple, "-filetype=asm", "-o", "-", "-")
+			cmd.Stdin = strings.NewReader(ir)
+			assembly, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Fatalf("LLVM 22 assembly: %v\n%s", err, assembly)
+			}
+			if !strings.Contains(string(assembly), "vdpbf16ps") {
+				t.Fatalf("BF16 intrinsic did not lower to the native instruction:\n%s", assembly)
+			}
+		})
+	}
+}
+
+func TestRawBF16DotRejectsNamedGoForms(t *testing.T) {
+	const source = "TEXT namedBF16Dot(SB),4,$0-0\nVDPBF16PS X0, X1, X2\nRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, false)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"namedBF16Dot": {Name: "namedBF16Dot", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted VDPBF16PS absent from Go's named assembler table")
+	}
+}
+
+func TestDecodeRawBF16RIPLiteral(t *testing.T) {
+	for length := byte(0); length < 3; length++ {
+		for _, broadcast := range []bool{false, true} {
+			for _, dot := range []bool{false, true} {
+				code := rawBF16Dot(length, 1, 0, 2, 1, false, broadcast, true)
+				if !dot {
+					code = encodeX86RawBF16Convert(int(length), 0, 2, 1, true, broadcast, false)
+				}
+				code[5] = 0x15
+				code = append(code, 1, 0, 0, 0, 0xc3)
+				width := 16 << length
+				if broadcast {
+					width = 4
+				}
+				for index := 0; index < width; index++ {
+					code = append(code, byte(index+1))
+				}
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, "BF16 RIP literal", map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || got[0].Args[0].Kind != OpSym || !got[0].x86RIPLiteral || got[1].Op != OpRET {
+					t.Fatalf("decoded %x as %+v, want source-local literal and RET", code, got)
+				}
+				if _, err := decodeX86RawDirectiveGroup(code[:len(code)-1], 64, 0, "truncated BF16 pool", map[string]bool{}); err == nil {
+					t.Fatal("accepted truncated source-local BF16 pool")
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_raw_binary_float_literal_test.go b/amd64_raw_binary_float_literal_test.go
new file mode 100644
index 000000000..e0452b14c
--- /dev/null
+++ b/amd64_raw_binary_float_literal_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawBinaryFloatLiteral(opcode, pp byte, evex bool, width int, broadcast bool) []byte {
+	var code []byte
+	if evex {
+		code = encodeX86EVEXBinaryFloat(opcode, pp, byte(map[int]int{16: 0, 32: 1, 64: 2}[width]), broadcast, true, 7, 0, 0, 0)
+	} else {
+		code = encodeX86VEXBinaryFloat(opcode, pp, true, width == 32, false, 0, 0, 0)
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if pp >= 2 || broadcast {
+		dataWidth = 4
+		if pp == 1 || pp == 3 {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*11+17))
+	}
+	return code
+}
+
+func TestDecodeX86RawBinaryFloatRIPDataCompleteFamily(t *testing.T) {
+	for _, opcode := range []byte{0x51, 0x58, 0x59, 0x5c, 0x5d, 0x5e, 0x5f} {
+		for pp := byte(0); pp < 4; pp++ {
+			if opcode == 0x51 && pp < 2 {
+				continue
+			}
+			for _, evex := range []bool{false, true} {
+				widths := []int{16, 32}
+				if evex {
+					widths = append(widths, 64)
+				}
+				if pp >= 2 {
+					widths = []int{16}
+				}
+				for _, width := range widths {
+					broadcasts := []bool{false}
+					if evex && pp < 2 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						stem := map[byte]string{0x51: "VSQRT", 0x58: "VADD", 0x59: "VMUL", 0x5c: "VSUB", 0x5d: "VMIN", 0x5e: "VDIV", 0x5f: "VMAX"}[opcode]
+						name := fmt.Sprintf("%s%s/evex%t/%d/bcst%t", stem, []string{"PS", "PD", "SS", "SD"}[pp], evex, width, broadcast)
+						t.Run(name, func(t *testing.T) {
+							code := x86RawBinaryFloatLiteral(opcode, pp, evex, width, broadcast)
+							decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+							if err != nil {
+								t.Fatal(err)
+							}
+							want := Op(stem + []string{"PS", "PD", "SS", "SD"}[pp])
+							if broadcast {
+								want += ".BCST"
+							}
+							if evex {
+								want += ".Z"
+							}
+							if len(decoded) != 2 || decoded[0].Op != want ||
+								decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+								decoded[1].Op != OpRET {
+								t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawBinaryFloatRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawBinaryFloatLiteral(0x58, 0, true, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawBinaryFloatRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	index := 0
+	for _, opcode := range []byte{0x51, 0x58, 0x59, 0x5c, 0x5d, 0x5e, 0x5f} {
+		for pp := byte(0); pp < 4; pp++ {
+			if opcode == 0x51 && pp < 2 {
+				continue
+			}
+			evex := index%2 == 0
+			width := 32
+			if evex {
+				width = 64
+			}
+			if pp >= 2 {
+				width = 16
+			}
+			broadcast := evex && pp < 2
+			code := x86RawBinaryFloatLiteral(opcode, pp, evex, width, broadcast)
+			name := fmt.Sprintf("binaryFloatLiteral%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range code {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+			dataWidth := width
+			if pp >= 2 || broadcast {
+				dataWidth = 4
+				if pp == 1 || pp == 3 {
+					dataWidth = 8
+				}
+			}
+			pools = append(pools, code[len(code)-dataWidth:])
+			index++
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Retain the entire original raw RET and constant pools as Go
+			// objects and public Context controls. This format-only source
+			// has no vector or mask producers; initialized public objects
+			// are independently owned by the complete 124-case directory.
+			x86UnboundVoidFormatSources(t, source.String(), "amd64", triple)
+			ir := x86ScalarFormatObjectUnit(t, normalized, sigs, "amd64", triple, 0)
+			compileLLVMToObject(t, llc, triple, "binary-float-literal.ll", "binary-float-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_binary_vector.go b/amd64_raw_binary_vector.go
new file mode 100644
index 000000000..c77d6ec7f
--- /dev/null
+++ b/amd64_raw_binary_vector.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Decode the shared two-source vector grammar after the family has selected
+// its operation and validated generation/W. The memory source is first in
+// Plan 9 order; EVEX masks and broadcast retain their typed semantics.
+func decodedX86BinaryVectorOperands(code []byte, p x86RawVectorEncoding, mode int, op Op, laneBits int) (Instr, int, bool, error) {
+	return decodedX86BinaryVectorOperandsWithMemory(code, p, mode, op, laneBits, x86RawMemoryDecoder{})
+}
+
+func decodedX86BinaryVectorOperandsWithMemory(code []byte, p x86RawVectorEncoding, mode int, op Op, laneBits int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("%s: %s", op, message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.pp != 1 || p.vectorLength > 2 || p.evex && !p.fixed {
+		return fail("invalid prefix, fixed bit or vector length")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires K1-K7")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.broadcast && (laneBits < 32 || code[p.modRM]>>6 == 3) {
+		return fail("broadcast requires D/Q memory source")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+
+	width := []string{"X", "Y", "Z"}[p.vectorLength]
+	scale := 16 << p.vectorLength
+	if p.broadcast {
+		scale = laneBits / 8
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+
+	var source Operand
+	var size int
+	var err error
+	if p.evex {
+		source, size, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, width, scale)
+	} else {
+		source, size, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+
+	args := []Operand{
+		source,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))},
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	destination := int(code[p.modRM]>>3&7) + p.r*8
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destination))})
+
+	parts := make([]string, len(args))
+	for i, arg := range args {
+		parts[i] = arg.String()
+	}
+	instruction := Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(parts, ", ")),
+		x86Encoded: true,
+	}
+	return instruction, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_bitcount_test.go b/amd64_raw_bitcount_test.go
new file mode 100644
index 000000000..617860662
--- /dev/null
+++ b/amd64_raw_bitcount_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RawBitCountCompleteGo127EncodingFamily(t *testing.T) {
+	type form struct {
+		name string
+		op   Op
+		code []byte
+		mem  bool
+	}
+	var forms []form
+	for _, family := range []struct {
+		name   string
+		opcode byte
+	}{
+		{"LZCNT", 0xbd},
+		{"TZCNT", 0xbc},
+	} {
+		for _, width := range []struct {
+			suffix string
+			prefix []byte
+		}{
+			{"W", []byte{0x66, 0xf3}},
+			{"L", []byte{0xf3}},
+			{"Q", []byte{0xf3, 0x48}},
+		} {
+			for _, source := range []struct {
+				name  string
+				modRM byte
+				mem   bool
+			}{
+				{"register", 0xc1, false},
+				{"memory", 0x08, true},
+			} {
+				code := append(append([]byte{}, width.prefix...), 0x0f, family.opcode, source.modRM)
+				forms = append(forms, form{
+					name: family.name + width.suffix + "/" + source.name,
+					op:   Op(family.name + width.suffix), code: code, mem: source.mem,
+				})
+			}
+		}
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, form := range forms {
+			if goarch == "386" && strings.Contains(form.name, "Q/") {
+				continue
+			}
+			t.Run(goarch+"/"+form.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range form.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != form.op || len(got.Instrs[0].Args) != 2 {
+					t.Fatalf("decoded %#x as %#v, want one %s", form.code, got.Instrs, form.op)
+				}
+				ins := got.Instrs[0]
+				wantDestination := AX
+				if form.mem {
+					wantDestination = CX
+				}
+				if ins.Args[1].Kind != OpReg || ins.Args[1].Reg != wantDestination {
+					t.Fatalf("decoded destination %#v, want %s", ins.Args[1], wantDestination)
+				}
+				if form.mem {
+					if ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != AX {
+						t.Fatalf("decoded memory source %#v, want (AX)", ins.Args[0])
+					}
+				} else if ins.Args[0].Kind != OpReg || ins.Args[0].Reg != CX {
+					t.Fatalf("decoded register source %#v, want CX", ins.Args[0])
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawBitCountExtendedRegisters(t *testing.T) {
+	for _, family := range []struct {
+		opcode byte
+		op     Op
+	}{
+		{0xbc, "TZCNTQ"},
+		{0xbd, "LZCNTQ"},
+	} {
+		for _, test := range []struct {
+			name   string
+			code   []byte
+			source Operand
+			dest   Reg
+		}{
+			{
+				name:   "extended register",
+				code:   []byte{0xf3, 0x4d, 0x0f, family.opcode, 0xc1},
+				source: Operand{Kind: OpReg, Reg: "R9"}, dest: "R8",
+			},
+			{
+				name:   "extended memory base",
+				code:   []byte{0xf3, 0x49, 0x0f, family.opcode, 0x08},
+				source: Operand{Kind: OpMem, Mem: MemRef{Base: "R8"}}, dest: CX,
+			},
+		} {
+			t.Run(string(family.op)+"/"+test.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range test.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != family.op || len(got.Instrs[0].Args) != 2 {
+					t.Fatalf("decoded %#x as %#v, want %s", test.code, got.Instrs, family.op)
+				}
+				ins := got.Instrs[0]
+				if ins.Args[0].Kind != test.source.Kind || ins.Args[0].Reg != test.source.Reg || ins.Args[0].Mem != test.source.Mem || ins.Args[1].Reg != test.dest {
+					t.Fatalf("decoded %#x operands as %#v, want %#v, %s", test.code, ins.Args, test.source, test.dest)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawBitCountCompilesAllForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawbitcount(SB),NOSPLIT,$0-0\n")
+			for _, opcode := range []byte{0xbc, 0xbd} {
+				for _, prefix := range [][]byte{{0x66, 0xf3}, {0xf3}, {0xf3, 0x48}} {
+					if target.goarch == "386" && len(prefix) == 2 && prefix[1] == 0x48 {
+						continue
+					}
+					for _, modRM := range []byte{0xc1, 0x08} {
+						for _, value := range append(append([]byte{}, prefix...), 0x0f, opcode, modRM) {
+							fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+						}
+						source.WriteString("\tNOP\n")
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			// The original complete sequence has no CX producer, and its
+			// partial AX result cannot establish the later memory address.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+			}
+
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.goarch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var initialized, declarations strings.Builder
+			forms := 0
+			for _, opcode := range []byte{0xbc, 0xbd} {
+				for _, prefix := range [][]byte{{0x66, 0xf3}, {0xf3}, {0xf3, 0x48}} {
+					if target.goarch == "386" && len(prefix) == 2 && prefix[1] == 0x48 {
+						continue
+					}
+					for _, modRM := range []byte{0xc1, 0x08} {
+						name := fmt.Sprintf("RawCount%d", forms)
+						inputType, input, result := typ, "CX", "AX"
+						if modRM == 0x08 {
+							inputType, input, result = "*"+typ, "AX", "CX"
+						}
+						fmt.Fprintf(&declarations, "func %s(x %s) %s\n", name, inputType, typ)
+						fmt.Fprintf(&initialized, "TEXT ·%s(SB),4,$0-%d\n%s $0,%s\n%s x+0(FP),%s\n",
+							name, 2*word, move, result, move, input)
+						initialized.WriteString(x86RawDisplacementDirectives(append(append([]byte{}, prefix...), 0x0f, opcode, modRM)))
+						fmt.Fprintf(&initialized, "%s %s,ret+%d(FP)\nRET\n", move, result, word)
+						forms++
+					}
+				}
+			}
+			want := 12
+			if target.goarch == "386" {
+				want = 8
+			}
+			if forms != want {
+				t.Fatal("initialized raw count form inventory changed", forms, want)
+			}
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, initialized.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, initialized.String(), declarations.String(), target.goarch, target.triple, api)
+				if err != nil {
+					t.Fatal("independently initialized original raw count form", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawBitCountRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution requires amd64; required amd64 CI covers this host-inapplicable test")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86RawCountOriginalRuntimeSource
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"rawbitcountsemantics": {
+				Name: "rawbitcountsemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawbitcountsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[72] = {0};
+  rawbitcountsemantics(out);
+  if (*(uint64_t *)(out+0) != UINT64_C(0x12340010)) return 10;
+  if (out[8] != 1 || out[9] != 0) return 11;
+  if (*(uint64_t *)(out+16) != 0) return 12;
+  if (out[24] != 0 || out[25] != 1) return 13;
+  if (*(uint64_t *)(out+32) != 64) return 14;
+  if (out[40] != 1 || out[41] != 0) return 15;
+  if (*(uint64_t *)(out+56) != 55) return 16;
+  if (out[64] != 0 || out[65] != 0) return 17;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_bitcount_semantics", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_raw_bitcount_vector.go b/amd64_raw_bitcount_vector.go
new file mode 100644
index 000000000..0f9214b45
--- /dev/null
+++ b/amd64_raw_bitcount_vector.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawVectorBitCountForm struct {
+	op     Op
+	opcode int
+	w      bool
+}
+
+// The six Go 1.27 _yvexpandpd bit-count rows share the same X/Y/Z and
+// mask grammar. Opcode and W choose the lane operation; only D/Q rows
+// enable scalar-memory broadcast.
+var x86RawVectorBitCountForms = [...]x86RawVectorBitCountForm{
+	{op: "VPLZCNTD", opcode: 0x44},
+	{op: "VPLZCNTQ", opcode: 0x44, w: true},
+	{op: "VPOPCNTB", opcode: 0x54},
+	{op: "VPOPCNTW", opcode: 0x54, w: true},
+	{op: "VPOPCNTD", opcode: 0x55},
+	{op: "VPOPCNTQ", opcode: 0x55, w: true},
+}
+
+func decodedX86RawVectorBitCountInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || !p.evex || p.mapNumber != 2 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var form x86RawVectorBitCountForm
+	for _, candidate := range x86RawVectorBitCountForms {
+		if candidate.opcode == p.opcode && candidate.w == p.w {
+			form = candidate
+			break
+		}
+	}
+	if form.op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("vector bit count: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.upper != 0 || p.vectorLength > 2 {
+		return fail("invalid reserved EVEX encoding bit")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	spec := amd64PackedBitCountSpecs[form.op]
+	modRM := code[p.modRM]
+	registerSource := modRM>>6 == 3
+	if p.broadcast && (registerSource || !spec.broadcast) {
+		return fail("broadcast requires a supported scalar-memory source")
+	}
+	if mode == 32 && !registerSource && (p.b != 0 || p.x != 0) {
+		return fail("extended memory address in 32-bit mode")
+	}
+
+	vectorPrefix := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	vectorBytes := 16 << p.vectorLength
+	registerNumber := int(modRM>>3&7) + p.r*8
+	if mode == 32 && p.vectorLength == 2 && registerNumber >= 8 {
+		return fail("386 Z destination register exceeds Go's encoder class")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, registerNumber))}
+	accessBytes := vectorBytes
+	if p.broadcast {
+		accessBytes = spec.laneBits / 8
+	}
+	source, consumed, err := decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, vectorPrefix, accessBytes)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := form.op
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_bitcount_vector_test.go b/amd64_raw_bitcount_vector_test.go
new file mode 100644
index 000000000..d5fc3f82f
--- /dev/null
+++ b/amd64_raw_bitcount_vector_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVectorBitCount(form x86RawVectorBitCountForm, vectorBits, destination, source, mask int, zeroing, broadcast, memory bool) []byte {
+	if memory {
+		source = 0
+	}
+	p0 := byte((1-destination/8&1)<<7 | (1-source/16)<<6 |
+		(1-source/8&1)<<5 | (1-destination/16)<<4 | 2)
+	p1 := byte(0x7d)
+	if form.w {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	if memory {
+		modRM = byte(0x40 | (destination&7)<<3)
+	}
+	code := []byte{0x62, p0, p1, p2, byte(form.opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestTranslateRawBitCountGorseRegression(t *testing.T) {
+	const source = `TEXT rawVectorPopcount(SB), $0-0
+	LONG $0x48fdf262
+	WORD $0xdb55
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawVectorPopcount": {Name: "rawVectorPopcount", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "llvm.ctpop.v8i64") {
+		t.Fatalf("raw VPOPCNTQ omitted eight-lane population count:\n%s", ir)
+	}
+}
+
+func TestDecodedX86RawVectorBitCountCompleteGoRows(t *testing.T) {
+	if len(x86RawVectorBitCountForms) != len(amd64PackedBitCountSpecs) {
+		t.Fatalf("raw bit-count grammar has %d rows, named lowerer has %d", len(x86RawVectorBitCountForms), len(amd64PackedBitCountSpecs))
+	}
+	seen := make(map[Op]bool)
+	for _, form := range x86RawVectorBitCountForms {
+		spec, ok := amd64PackedBitCountSpecs[form.op]
+		if !ok || seen[form.op] {
+			t.Fatalf("missing or duplicated bit-count spec for %s", form.op)
+		}
+		seen[form.op] = true
+		for vectorBits, prefix := range [...]string{"X", "Y", "Z"} {
+			vectorBytes := 16 << vectorBits
+			for _, memory := range []bool{false, true} {
+				for _, masked := range []bool{false, true} {
+					mask := 0
+					if masked {
+						mask = 3
+					}
+					for _, zeroing := range []bool{false, true} {
+						if zeroing && !masked {
+							continue
+						}
+						for _, broadcast := range []bool{false, true} {
+							if broadcast && (!memory || !spec.broadcast) {
+								continue
+							}
+							code := encodeX86RawVectorBitCount(form, vectorBits, 21, 20, mask, zeroing, broadcast, memory)
+							got, length, recognized, err := decodedX86RawVectorBitCountInstruction(code, 64)
+							if err != nil || !recognized || length != len(code) {
+								t.Fatalf("decode %x = %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+							}
+							wantOp := form.op
+							if broadcast {
+								wantOp += ".BCST"
+							}
+							if zeroing {
+								wantOp += ".Z"
+							}
+							if got.Op != wantOp || got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s21", prefix) {
+								t.Fatalf("decode %x = %+v, want %s and %s21", code, got, wantOp, prefix)
+							}
+							if masked && (len(got.Args) != 3 || got.Args[1].String() != "K3") || !masked && len(got.Args) != 2 {
+								t.Fatalf("decode %x = %+v, lost mask", code, got)
+							}
+							source := got.Args[0]
+							if memory {
+								wantBytes := vectorBytes
+								if broadcast {
+									wantBytes = spec.laneBits / 8
+								}
+								if source.Kind != OpMem || source.Mem.Base != AX || source.Mem.Off != int64(wantBytes) {
+									t.Fatalf("decode %x = %+v, want compressed displacement %d", code, got, wantBytes)
+								}
+							} else if source.String() != fmt.Sprintf("%s20", prefix) {
+								t.Fatalf("decode %x = %+v, want %s20", code, got, prefix)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawVectorBitCountRejectsReservedBits(t *testing.T) {
+	form := x86RawVectorBitCountForms[5]
+	base := encodeX86RawVectorBitCount(form, 2, 2, 1, 3, true, false, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"fixed bit", []byte{base[0], base[1], base[2] &^ 4, base[3], base[4], base[5]}},
+		{"vvvv", []byte{base[0], base[1], base[2] &^ 8, base[3], base[4], base[5]}},
+		{"V prime", []byte{base[0], base[1], base[2], base[3] &^ 8, base[4], base[5]}},
+		{"reserved length", []byte{base[0], base[1], base[2], base[3] | 0x20, base[4], base[5]}},
+		{"zero without mask", []byte{base[0], base[1], base[2], base[3] &^ 7, base[4], base[5]}},
+		{"register broadcast", []byte{base[0], base[1], base[2], base[3] | 0x10, base[4], base[5]}},
+		{"missing ModRM", base[:5]},
+		{"address override", append([]byte{0x67}, base...)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawVectorBitCountInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted reserved encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+	broadcastWord := encodeX86RawVectorBitCount(x86RawVectorBitCountForms[3], 2, 2, 0, 0, false, true, true)
+	if _, _, recognized, err := decodedX86RawVectorBitCountInstruction(broadcastWord, 64); !recognized || err == nil {
+		t.Fatalf("accepted VPOPCNTW broadcast %x", broadcastWord)
+	}
+}
+
+func TestTranslateRawVectorBitCountLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawBitCountFamily(SB), $0-0\n")
+			appendBytes := func(code []byte) {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			for _, form := range x86RawVectorBitCountForms {
+				for vectorBits := 0; vectorBits < 3; vectorBits++ {
+					appendBytes(encodeX86RawVectorBitCount(form, vectorBits, 2, 1, 0, false, false, false))
+					appendBytes(encodeX86RawVectorBitCount(form, vectorBits, 2, 0, 3, true, false, true))
+					if amd64PackedBitCountSpecs[form.op].broadcast {
+						appendBytes(encodeX86RawVectorBitCount(form, vectorBits, 2, 0, 4, false, true, true))
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawBitCountFamily": {Name: "rawBitCountFamily", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "llvm.ctpop") || !strings.Contains(ir, "llvm.ctlz") {
+				t.Fatalf("raw vector bit-count family omitted operations:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-vector-bit-count.ll", "raw-vector-bit-count.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_blend_imm_literal_test.go b/amd64_raw_blend_imm_literal_test.go
new file mode 100644
index 000000000..fde9821ce
--- /dev/null
+++ b/amd64_raw_blend_imm_literal_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawImmediatePackedBlendLiteral(spec rawImmediatePackedBlendSpec, vex bool, width int) []byte {
+	var code []byte
+	if vex {
+		code = encodeX86RawVEXImmediatePackedBlend(spec, byte((width-16)/16), 0, 1, 2, 0xa5)
+	} else {
+		code = encodeX86RawLegacyImmediatePackedBlend(spec, 0, 2, 0xa5)
+	}
+	modRMIndex := len(code) - 2
+	code[modRMIndex] = 0x15 // RIP+disp32; destination remains X/Y2.
+	code = append(code[:modRMIndex+1], append([]byte{1, 0, 0, 0}, code[modRMIndex+1:]...)...)
+	code = append(code, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*7+3))
+	}
+	return code
+}
+
+func TestDecodeX86RawImmediatePackedBlendRIPDataCompleteFamily(t *testing.T) {
+	for _, spec := range rawImmediatePackedBlendSpecs {
+		for _, vex := range []bool{false, true} {
+			if !vex && spec.legacy == "" {
+				continue
+			}
+			widths := []int{16}
+			if vex {
+				widths = append(widths, 32)
+			}
+			for _, width := range widths {
+				name := fmt.Sprintf("%s/vex%t/%d", spec.vector, vex, width)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawImmediatePackedBlendLiteral(spec, vex, width)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := spec.legacy
+					if vex {
+						want = spec.vector
+					}
+					if len(decoded) != 2 || decoded[0].Op != want ||
+						decoded[0].Args[0].Kind != OpImm || decoded[0].Args[0].Imm != 0xa5 ||
+						decoded[0].Args[1].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+						decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+					}
+					if !bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-width:]) {
+						t.Fatalf("source-local data = %x, want %x", decoded[0].x86RIPLiteralData, code[len(code)-width:])
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawImmediatePackedBlendRIPDataRejectsUnsafeSources(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte {
+			code[5] = 127
+			return code
+		},
+		"overlapping instruction": func(code []byte) []byte {
+			code[5] = 0
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawImmediatePackedBlendLiteral(rawImmediatePackedBlendSpecs[2], true, 32))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe packed-blend RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawImmediatePackedBlendRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, spec := range rawImmediatePackedBlendSpecs {
+		for _, vex := range []bool{false, true} {
+			if !vex && spec.legacy == "" {
+				continue
+			}
+			name := string(spec.legacy)
+			width := 16
+			if vex {
+				name = string(spec.vector)
+				width = 32
+			}
+			fmt.Fprintf(&source, "TEXT literal%s(SB),$0-0\n", name)
+			for _, value := range x86RawImmediatePackedBlendLiteral(spec, vex, width) {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			sigs["literal"+name] = FuncSig{Name: "literal" + name, Ret: Void}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(sigs) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(sigs))
+	}
+	for _, fn := range normalized.Funcs {
+		found := false
+		for _, instruction := range fn.Instrs {
+			if !instruction.x86RIPLiteral {
+				continue
+			}
+			if len(instruction.Args) < 2 || !strings.Contains(instruction.Raw, instruction.Args[1].Sym) {
+				t.Fatalf("%s raw text does not name its materialized source: %+v", fn.Sym, instruction)
+			}
+			found = true
+		}
+		if !found {
+			t.Fatalf("%s has no decoded packed-blend literal", fn.Sym)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Keep the complete original raw RET and literal bytes as actual
+			// Go objects plus three public Context outcomes. These seven bare
+			// functions have no old-destination or second-source producers.
+			// Initialized full register/native-memory programs have the separate
+			// 22-form five-target object and whole-producer replay owners.
+			x86UnboundVoidFormatSources(t, source.String(), "amd64", triple)
+			ir := x86InstructionFormatObjectUnit(t, normalized, sigs, "amd64", triple, 0,
+				func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return c.lowerImmediatePackedBlend(instruction.Op, instruction)
+				})
+			for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				compileLLVMToObject(t, llc, triple, "raw-blend-imm-literal.ll", "raw-blend-imm-literal.o", input)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_blend_imm_test.go b/amd64_raw_blend_imm_test.go
new file mode 100644
index 000000000..431e0359e
--- /dev/null
+++ b/amd64_raw_blend_imm_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type rawImmediatePackedBlendSpec struct {
+	opcode byte
+	legacy Op
+	vector Op
+}
+
+var rawImmediatePackedBlendSpecs = []rawImmediatePackedBlendSpec{
+	{opcode: 0x0e, legacy: "PBLENDW", vector: "VPBLENDW"},
+	{opcode: 0x0c, legacy: "BLENDPS", vector: "VBLENDPS"},
+	{opcode: 0x0d, legacy: "BLENDPD", vector: "VBLENDPD"},
+	{opcode: 0x02, vector: "VPBLENDD"},
+}
+
+func encodeX86RawLegacyImmediatePackedBlend(spec rawImmediatePackedBlendSpec, source, destination int, immediate byte) []byte {
+	rex := byte(0x40 | source>>3&1 | destination>>3&1<<2)
+	code := []byte{0x66}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, 0x3a, spec.opcode, byte(0xc0|destination&7<<3|source&7), immediate)
+}
+
+func encodeX86RawVEXImmediatePackedBlend(spec rawImmediatePackedBlendSpec, vectorBits byte, first, second, destination int, immediate byte) []byte {
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^first>>3)&1)<<5 | 3
+	p1 := byte(^second&15)<<3 | vectorBits<<2 | 1
+	return []byte{0xc4, p0, p1, spec.opcode, byte(0xc0 | destination&7<<3 | first&7), immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVBLENDPD(t *testing.T) {
+	// vblendpd $12, %ymm1, %ymm0, %ymm0;
+	// vunpcklps %xmm3, %xmm5, %xmm0
+	code := []byte{0xc4, 0xe3, 0x7d, 0x0d, 0xc1, 0x0c, 0xc5, 0xd0, 0x14, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VBLENDPD sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VBLENDPD $12, Y1, Y0, Y0 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawImmediatePackedBlendCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawImmediatePackedBlendSpecs {
+		if spec.legacy != "" {
+			for source := 0; source < 16; source++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86RawLegacyImmediatePackedBlend(spec, source, destination, 0xa5)
+					got, length, ok, err := decodedX86ImmediatePackedBlendInstruction(code, 64)
+					want := fmt.Sprintf("%s $165, X%d, X%d", spec.legacy, source, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 2; vectorBits++ {
+			vectorName := [...]string{"X", "Y"}[vectorBits]
+			for first := 0; first < 16; first++ {
+				for second := 0; second < 16; second++ {
+					for destination := 0; destination < 16; destination++ {
+						code := encodeX86RawVEXImmediatePackedBlend(spec, vectorBits, first, second, destination, 0x5a)
+						got, length, ok, err := decodedX86ImmediatePackedBlendInstruction(code, 64)
+						want := fmt.Sprintf("%s $90, %s%d, %s%d, %s%d", spec.vector, vectorName, first, vectorName, second, vectorName, destination)
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 33536 {
+		t.Fatalf("covered %d immediate packed-blend register encodings, want 33536", count)
+	}
+}
+
+func TestDecodedX86RawImmediatePackedBlendMemoryAndInvalidForms(t *testing.T) {
+	legacyMemory := []byte{0x66, 0x47, 0x0f, 0x3a, 0x0e, 0x7c, 0x8b, 0x01, 0x7f}
+	got, length, ok, err := decodedX86ImmediatePackedBlendInstruction(legacyMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(legacyMemory) || got.Op != "PBLENDW" || got.Args[0].Imm != 127 || got.Args[2].String() != "X15" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", legacyMemory, got, length, ok, err)
+	}
+	vexMemory := []byte{0xc4, 0x03, 0x75, 0x0d, 0x7c, 0x8b, 0x02, 0xfe}
+	got, length, ok, err = decodedX86ImmediatePackedBlendInstruction(vexMemory, 64)
+	wantMemory.Off = 2
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VBLENDPD" || got.Args[0].Imm != 254 || got.Args[2].String() != "Y1" || got.Args[3].String() != "Y15" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+
+	validLegacy := encodeX86RawLegacyImmediatePackedBlend(rawImmediatePackedBlendSpecs[0], 7, 7, 1)
+	validVEX := encodeX86RawVEXImmediatePackedBlend(rawImmediatePackedBlendSpecs[0], 0, 7, 7, 7, 1)
+	reservedW := encodeX86RawVEXImmediatePackedBlend(rawImmediatePackedBlendSpecs[3], 0, 7, 7, 7, 1)
+	reservedW[2] |= 0x80 // VPBLENDD alone is W0; the other three VEX members are WIG.
+	for name, invalid := range map[string][]byte{
+		"legacy missing immediate": validLegacy[:len(validLegacy)-1],
+		"vex missing immediate":    validVEX[:len(validVEX)-1],
+		"reserved VPBLENDD W":      reservedW,
+		"vex prefix":               {validVEX[0], validVEX[1], validVEX[2] &^ 0x01, validVEX[3], validVEX[4], validVEX[5]},
+		"address override":         append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86ImmediatePackedBlendInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	for _, mode := range []int{32, 64} {
+		for _, w := range []byte{0, 0x80} {
+			physical := append([]byte(nil), validVEX...)
+			physical[2] |= w
+			x86NumericalNativeRequireMC(t, physical, mode, 1, "+avx2")
+			instruction, length, matched, decodeErr := decodedX86ImmediatePackedBlendInstruction(physical, mode)
+			if !matched || decodeErr != nil || length != len(physical) || instruction.Op != "VPBLENDW" || !instruction.x86Encoded {
+				t.Fatalf("physical mode%d WIG VEX encoding %x decoded as %+v, ok=%v, err=%v", mode, physical, instruction, matched, decodeErr)
+			}
+		}
+	}
+}
+
+func TestX86ImmediatePackedBlendGo127ArchitectureOracle(t *testing.T) {
+	const accepted386 = `TEXT ok(SB),$0-0
+	PBLENDW $7, X6, X7
+	BLENDPS $7, X6, X7
+	BLENDPD $7, X6, X7
+	RET
+`
+	requireX86GoAssemblerResult(t, "386", accepted386, true)
+	for _, instruction := range []string{
+		"VPBLENDW $7, X0, X1, X2",
+		"VPBLENDD $7, Y0, Y1, Y2",
+		"VBLENDPS $7, X0, X1, X2",
+		"VBLENDPD $7, Y0, Y1, Y2",
+	} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+	}
+}
+
+func TestTranslateX86RawImmediatePackedBlendTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name        string
+		goarch      string
+		triple      string
+		registerMax int
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", registerMax: 15},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registerMax: 15},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registerMax: 15},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu", registerMax: 7},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc", registerMax: 7},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_immediate_packed_blend(SB),NOSPLIT,$0-0\n")
+			for _, spec := range rawImmediatePackedBlendSpecs {
+				var encodings [][]byte
+				if spec.legacy != "" {
+					encodings = append(encodings, encodeX86RawLegacyImmediatePackedBlend(spec, target.registerMax, target.registerMax, 0xa5))
+				}
+				if target.goarch == "amd64" {
+					encodings = append(encodings, encodeX86RawVEXImmediatePackedBlend(spec, 1, target.registerMax, target.registerMax, target.registerMax, 0x5a))
+				}
+				for _, encoding := range encodings {
+					for _, value := range encoding {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"raw_immediate_packed_blend": {Name: "raw_immediate_packed_blend", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-immediate-packed-blend-"+target.name+".ll", "raw-immediate-packed-blend-"+target.name+".o", ll)
+		})
+	}
+}
diff --git a/amd64_raw_blend_variable.go b/amd64_raw_blend_variable.go
new file mode 100644
index 000000000..54f1d976f
--- /dev/null
+++ b/amd64_raw_blend_variable.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "fmt"
+
+// VEX variable blends encode the mask register in imm8[7:4], not an ordinary
+// immediate. Intel's AVX/AVX2 tables specify 66.0F3A.W0, X/Y widths and no
+// EVEX forms. The low nibble is ignored; in 32-bit mode bit 7 is also ignored.
+func decodedX86VariableBlendInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 3 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	for candidate, spec := range amd64VariableBlendSpecs {
+		if spec.vector && spec.opcode == p.opcode {
+			op = candidate
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("variable blend: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.w || p.pp != 1 {
+		return fail("requires VEX.128/256.66.0F3A.W0")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 {
+		if p.r != 0 || p.x != 0 {
+			return fail("legacy LES encoding is not a 32-bit VEX instruction")
+		}
+		// Three-byte VEX ignores these high register selectors outside
+		// 64-bit mode, independently of the imm8 mask-register selector.
+		p.b = 0
+		p.upper &= 7
+	}
+	prefix := "X"
+	if p.vectorLength != 0 {
+		prefix = "Y"
+	}
+	source, size, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, prefix)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediate := p.modRM + size
+	if len(code) <= immediate {
+		return fail("missing mask-register selector byte")
+	}
+	mask := int(code[immediate] >> 4)
+	if mode == 32 {
+		mask &= 7
+	}
+	reg := func(index int) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, index))}
+	}
+	args := []Operand{reg(mask), source, reg(p.upper), reg(int(code[p.modRM]>>3&7) + p.r*8)}
+	return Instr{
+		// This exact physical four-operand instruction is valid in mode32,
+		// unlike Go's named frontend spelling. No other raw family acquires
+		// that syntax role; the complete source replay seals this flag too.
+		Op: op, Args: args, x86Encoded: true,
+		Raw: fmt.Sprintf("%s %s, %s, %s, %s", op, args[0].String(), source.String(), args[2].String(), args[3].String()),
+	}, immediate + 1, true, nil
+}
diff --git a/amd64_raw_blend_variable_test.go b/amd64_raw_blend_variable_test.go
new file mode 100644
index 000000000..cbbd3df37
--- /dev/null
+++ b/amd64_raw_blend_variable_test.go
@@ -0,0 +1,337 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86VariableBlendTestFamilies = []struct {
+	legacy, vector string
+	bits           int
+	legacyCode     byte
+	vectorCode     byte
+}{
+	{"BLENDVPS", "VBLENDVPS", 32, 0x14, 0x4a},
+	{"BLENDVPD", "VBLENDVPD", 64, 0x15, 0x4b},
+	{"PBLENDVB", "VPBLENDVB", 8, 0x10, 0x4c},
+}
+
+func TestX86VariableBlendGrammarMatchesGoEncoder(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	vector, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, grammar := range []struct {
+		text, table string
+		operands    []string
+	}{
+		{string(legacy), "yblendvpd", []string{"Yxr0, Yxm, Yxr"}},
+		{string(vector), "_yvblendvpd", []string{"Yxr, Yxm, Yxr, Yxr", "Yyr, Yym, Yyr, Yyr"}},
+	} {
+		pattern := `(?s)var ` + grammar.table + ` = \[\]ytab\{(.*?)\n\}`
+		rows := regexp.MustCompile(pattern).FindStringSubmatch(grammar.text)
+		if len(rows) != 2 || strings.Count(rows[1], "argList{") != len(grammar.operands) {
+			t.Fatalf("Go %s operand grammar changed", grammar.table)
+		}
+		for _, operands := range grammar.operands {
+			if !strings.Contains(rows[1], "argList{"+operands+"}") {
+				t.Fatalf("Go %s is missing %s", grammar.table, operands)
+			}
+		}
+	}
+	for _, family := range x86VariableBlendTestFamilies {
+		for _, vex := range []bool{false, true} {
+			op, opcode := family.legacy, family.legacyCode
+			if vex {
+				op, opcode = family.vector, family.vectorCode
+			}
+			spec, ok := amd64VariableBlendSpecs[Op(op)]
+			if !ok || spec.laneBits != family.bits || spec.vector != vex || spec.opcode != int(opcode) {
+				t.Fatalf("incorrect typed spec for %s: %+v", op, spec)
+			}
+			if !vex {
+				row := fmt.Sprintf("{A%s, yblendvpd, Pq4, opBytes{0x%02x}}", op, opcode)
+				if !strings.Contains(string(legacy), row) {
+					t.Fatalf("Go %s opcode changed", op)
+				}
+				continue
+			}
+			pattern := `(?s)\{as: A` + op + `, ytab: (\w+), prefix: Pavx, op: opBytes\{(.*?)\}\}`
+			rows := regexp.MustCompile(pattern).FindAllStringSubmatch(string(vector), -1)
+			if len(rows) != 1 || rows[0][1] != "_yvblendvpd" {
+				t.Fatalf("Go %s opcode grammar changed", op)
+			}
+			entries := strings.Split(strings.TrimSpace(rows[0][2]), "\n")
+			if len(entries) != 2 {
+				t.Fatalf("Go %s must have exactly X/Y forms", op)
+			}
+			for i, width := range []int{128, 256} {
+				want := fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F3A | vexW0, 0x%02X,", width, opcode)
+				if strings.TrimSpace(entries[i]) != want {
+					t.Fatalf("Go %s encoding = %s, want %s", op, entries[i], want)
+				}
+			}
+		}
+	}
+	if len(amd64VariableBlendSpecs) != 6 {
+		t.Fatal("variable-blend specs must cover all six Go mnemonics")
+	}
+}
+
+func TestX86RawVariableBlendEncodingFields(t *testing.T) {
+	for _, family := range x86VariableBlendTestFamilies {
+		for _, length := range []byte{0, 1} {
+			for selector := 0; selector < 256; selector++ {
+				code := []byte{0xc4, 0xe3, 0x69 | length<<2, family.vectorCode, 0xd9, byte(selector)}
+				for _, mode := range []int{32, 64} {
+					got, size, matched, err := decodedX86VariableBlendInstruction(code, mode)
+					mask := selector >> 4
+					if mode == 32 {
+						mask &= 7
+					}
+					prefix := "X"
+					if length != 0 {
+						prefix = "Y"
+					}
+					want := []Operand{
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, mask))},
+						{Kind: OpReg, Reg: Reg(prefix + "1")},
+						{Kind: OpReg, Reg: Reg(prefix + "2")},
+						{Kind: OpReg, Reg: Reg(prefix + "3")},
+					}
+					if err != nil || !matched || size != len(code) || got.Op != Op(family.vector) || !reflect.DeepEqual(got.Args, want) {
+						t.Fatalf("decode %x mode=%d: %+v %v, want %+v", code, mode, got, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawVariableBlend386IgnoredRegisterBits(t *testing.T) {
+	// Intel XED's XMM/YMM_N_32 and XMM/YMM_B_32 tables ignore the high
+	// vvvv and B selectors. R/X must still distinguish VEX from legacy LES.
+	for _, family := range x86VariableBlendTestFamilies {
+		for _, length := range []byte{0, 1} {
+			for _, modRM := range []byte{0xd9, 0x1b} {
+				canonical := []byte{0xc4, 0xe3, 0x69 | length<<2, family.vectorCode, modRM, 0x70}
+				want, _, matched, err := decodedX86VariableBlendInstruction(canonical, 32)
+				if !matched || err != nil {
+					t.Fatalf("canonical %x: %v", canonical, err)
+				}
+				for bits := 0; bits < 4; bits++ {
+					code := append([]byte(nil), canonical...)
+					if bits&1 != 0 {
+						code[1] &^= 0x20
+					}
+					if bits&2 != 0 {
+						code[2] &^= 0x40
+					}
+					code[5] = 0xff
+					got, size, matched, err := decodedX86VariableBlendInstruction(code, 32)
+					if !matched || err != nil || size != len(code) || !reflect.DeepEqual(got.Args, want.Args) {
+						t.Fatalf("386 ignored fields %x: %+v %v, want %+v", code, got, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawVariableBlendInvalidAndMemoryForms(t *testing.T) {
+	for _, family := range x86VariableBlendTestFamilies {
+		code := []byte{0xc4, 0xe3, 0x69, family.vectorCode, 0xd9, 0x00}
+		for _, mutate := range []func([]byte) []byte{
+			func(b []byte) []byte { b[2] |= 0x80; return b }, // W1 is reserved.
+			func(b []byte) []byte { b[2] &^= 3; return b },   // No 66 prefix.
+			func(b []byte) []byte { return b[:4] },           // Missing ModRM.
+			func(b []byte) []byte { return b[:5] },           // Missing selector.
+			func(b []byte) []byte { b[4] = 0x04; return b[:5] },
+			func(b []byte) []byte { b[4] = 0x80; return b[:5] },
+			func(b []byte) []byte { return append([]byte{0x67}, b...) },
+			func(b []byte) []byte { return []byte{0x62, 0xf3, 0x6d, 0x08, b[3], b[4], b[5]} },
+		} {
+			invalid := mutate(append([]byte(nil), code...))
+			if _, _, matched, err := decodedX86VariableBlendInstruction(invalid, 64); !matched || err == nil {
+				t.Fatalf("accepted reserved/truncated encoding %x", invalid)
+			}
+		}
+		if _, _, matched, err := decodedX86VariableBlendInstruction(code, 16); !matched || err == nil {
+			t.Fatal("accepted unsupported mode")
+		}
+		for _, segment := range []struct {
+			prefix byte
+			reg    Reg
+		}{{0x64, FS}, {0x65, GS}} {
+			memory := []byte{segment.prefix, 0xc4, 0x03, 0x69, family.vectorCode, 0x64, 0x88, 0xf9, 0xf7}
+			got, size, matched, err := decodedX86VariableBlendInstruction(memory, 64)
+			want := []Operand{
+				{Kind: OpReg, Reg: "X15"},
+				{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: -7}},
+				{Kind: OpReg, Reg: "X2"},
+				{Kind: OpReg, Reg: "X12"},
+			}
+			if err != nil || !matched || size != len(memory) || !reflect.DeepEqual(got.Args, want) {
+				t.Fatalf("decode %x: %+v %v, want %+v", memory, got, err, want)
+			}
+			if _, _, matched, err := decodedX86VariableBlendInstruction(memory, 32); !matched || err == nil {
+				t.Fatal("accepted legacy LES as a 32-bit VEX instruction")
+			}
+		}
+		rip := []byte{0xc4, 0xe3, 0x69, family.vectorCode, 0x05, 0, 0, 0, 0, 0}
+		if _, _, matched, err := decodedX86VariableBlendInstruction(rip, 64); !matched || err == nil {
+			t.Fatal("accepted source-layout-unsafe RIP addressing")
+		}
+		if _, size, matched, err := decodedX86VariableBlendInstruction(rip, 32); !matched || err != nil || size != len(rip) {
+			t.Fatalf("absolute 32-bit addressing: matched=%t size=%d err=%v", matched, size, err)
+		}
+	}
+	for _, code := range [][]byte{nil, {0xc4}, {0xc4, 0xe2, 0x69, 0x4b, 0xc0, 0}, {0xc4, 0xe3, 0x69, 0x4d, 0xc0, 0}} {
+		if _, _, matched, _ := decodedX86VariableBlendInstruction(code, 64); matched {
+			t.Fatalf("matched unrelated instruction %x", code)
+		}
+	}
+}
+
+func TestX86RawVariableBlendSourceLocalRIPData(t *testing.T) {
+	for _, family := range x86VariableBlendTestFamilies {
+		for vectorLength, width := range []int{16, 32} {
+			code := []byte{
+				0xc4, 0xe3, byte(0x69 | vectorLength<<2), family.vectorCode,
+				0x05, 0x01, 0, 0, 0, 0x70, 0xc3,
+			}
+			for value := 0; value < width; value++ {
+				code = append(code, byte(value))
+			}
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "variable blend RIP", map[string]bool{})
+			if err != nil {
+				t.Fatalf("%s width %d: %v", family.vector, width, err)
+			}
+			if len(decoded) != 2 || decoded[0].Op != Op(family.vector) ||
+				len(decoded[0].x86RIPLiteralData) != width ||
+				decoded[0].Args[1].Kind != OpSym {
+				t.Fatalf("%s width %d: %#v", family.vector, width, decoded)
+			}
+		}
+	}
+}
+
+func TestX86VariableBlendGoRejectedForms(t *testing.T) {
+	for _, family := range x86VariableBlendTestFamilies {
+		for _, form := range []struct {
+			op   string
+			args []string
+		}{
+			{family.legacy, []string{" X0,X1", " X1,X2,X3", " X0,(AX),(BX)", " X0,Y1,X2", " X0,X1,X16", ".Z X0,X1,X2"}},
+			{family.vector, []string{" X0,X1,X2", " (AX),X1,X2,X3", " X0,X1,(AX),X3", " X0,X1,X2,(AX)",
+				" X0,Y1,X2,X3", " X0,X1,Y2,X3", " X0,X1,X2,Y3", " Z0,Z1,Z2,Z3", " X16,X1,X2,X3",
+				" X0,X16,X2,X3", " X0,X1,X16,X3", " X0,X1,X2,X16", ".Z X0,X1,X2,X3", ".BCST X0,(AX),X2,X3", ".SAE X0,X1,X2,X3"}},
+		} {
+			for _, args := range form.args {
+				line := form.op + args
+				requireX86GoAssemblerResult(t, "amd64", "TEXT bad(SB),4,$0-0\n"+line+"\nRET\n", false)
+				assertX86VariableBlendRejected(t, "amd64", "x86_64-unknown-linux-gnu", line)
+			}
+		}
+	}
+}
+
+func TestX86RawVariableBlendGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, family := range x86VariableBlendTestFamilies {
+			for _, width := range []int{0, 16, 32} {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, family.vector, width), func(t *testing.T) {
+					limit := 16
+					if arch == "386" {
+						limit = 8
+					}
+					prefix, op := "X", family.legacy
+					if width != 0 {
+						op = family.vector
+					}
+					if width == 32 {
+						prefix = "Y"
+					}
+					memories := []string{"(AX)", "-7(BP)(CX*4)", "8192(SP)"}
+					if arch == "amd64" {
+						memories = append(memories, "(R8)", "-7(R13)(R15*8)")
+					}
+					var source strings.Builder
+					source.WriteString("TEXT blend(SB),4,$0-0\n")
+					for reg := 0; reg < limit; reg++ {
+						if width == 0 {
+							fmt.Fprintf(&source, "%s X0,X%d,X2\n%s X0,X1,X%d\n", op, reg, op, reg)
+						} else {
+							// Vary the four register fields independently, not as a
+							// redundant Cartesian product of the same grammar.
+							for field := 0; field < 4; field++ {
+								args := []string{prefix + "0", prefix + "1", prefix + "2", prefix + "3"}
+								args[field] = fmt.Sprintf("%s%d", prefix, reg)
+								fmt.Fprintf(&source, "%s %s\n", op, strings.Join(args, ","))
+							}
+						}
+						for _, memory := range memories {
+							if width == 0 {
+								fmt.Fprintf(&source, "%s X0,%s,X%d\n", op, memory, reg)
+							} else {
+								fmt.Fprintf(&source, "%s %s%d,%s,%s2,%s%d\n", op, prefix, reg, memory, prefix, prefix, reg)
+							}
+						}
+					}
+					source.WriteString("RET\n")
+					encoderArch := arch
+					if arch == "386" && width != 0 {
+						// Go's 386 parser rejects four operands before the shared
+						// VEX encoder. The same low-register/address encodings
+						// are valid on i386; decode and compile them there too.
+						requireX86GoAssemblerResult(t, arch, "TEXT bad(SB),4,$0-0\n"+op+" X0,X1,X2,X3\nRET\n", false)
+						encoderArch = "amd64"
+					}
+					code := assembleX87ControlBytes(t, encoderArch, source.String())
+					decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					named, err := Parse(ArchAMD64, source.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := named.Funcs[0].Instrs[1:]
+					if len(decoded.Instrs) != len(want) {
+						t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+					}
+					for i, got := range decoded.Instrs {
+						if got.Op != want[i].Op || !x86RawOperandsMatchGoSource(got.Args, want[i].Args) {
+							t.Fatalf("instruction %d %s operands=%#v, want source %#v", i, got.Op, got.Args, want[i].Args)
+						}
+					}
+					file := x86RawStackObservingFormProbeFile(t, arch, "blend", code)
+					triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+					if arch == "386" {
+						triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+					}
+					for _, triple := range triples {
+						ir := x86UnboundBlendMinposProbeObject(t, file, arch, triple)
+						compileLLVMToObject(t, llc, triple, "raw-blend.ll", "raw-blend.o", ir)
+					}
+					t.Logf("checked %d actual Go encodings", len(want)-1)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_bmi2_shift.go b/amd64_raw_bmi2_shift.go
new file mode 100644
index 000000000..155dd0cbb
--- /dev/null
+++ b/amd64_raw_bmi2_shift.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import "fmt"
+
+// All six Go _ybextrl forms use VEX.L0. Intel XED's hsw-bmi-vex-isa
+// table leaves W unconstrained in not64 mode, so Q bytes decode as L on 386.
+func decodedX86BMI2ShiftInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86BMI2ShiftInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86BMI2ShiftInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.opcode != 0xf7 || p.pp == 0 {
+		return Instr{}, 0, false, nil
+	}
+
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("BMI2 variable shift: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.vectorLength != 0 {
+		return fail("requires VEX.L0 encoding")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+
+	bits := 32
+	if p.w && mode == 64 {
+		bits = 64
+	}
+	var op Op
+	for name, spec := range amd64BMI2ShiftSpecs {
+		if !spec.immediate && spec.bits == bits && spec.prefix == p.pp {
+			op = name
+			break
+		}
+	}
+
+	source, size, err := memory.scalar(code[p.modRM:], mode, p.b, p.x, p.segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	count, _ := decodedX86GeneralRegister(p.upper)
+	destination, _ := decodedX86GeneralRegister(int(code[p.modRM]>>3&7) + p.r*8)
+	instruction := Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: count},
+			source,
+			{Kind: OpReg, Reg: destination},
+		},
+		Raw: fmt.Sprintf("%s %s, %s, %s", op, count, source.String(), destination),
+	}
+	return instruction, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_bmi2_shift_test.go b/amd64_raw_bmi2_shift_test.go
new file mode 100644
index 000000000..951342ddb
--- /dev/null
+++ b/amd64_raw_bmi2_shift_test.go
@@ -0,0 +1,251 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86BMI2ShiftTestOps = []string{
+	"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ",
+}
+
+func TestX86BMI2ShiftGrammarMatchesGoEncoder(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pattern := `(?s)\{as: A((?:SARX|SHLX|SHRX)[LQ]), ytab: (\w+), prefix: Pavx, op: opBytes\{(.*?)\}\}`
+	rows := regexp.MustCompile(pattern).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 6 || len(amd64BMI2ShiftSpecs) != 8 {
+		t.Fatalf("Go family=%d, typed family=%d", len(rows), len(amd64BMI2ShiftSpecs))
+	}
+	for _, row := range rows {
+		spec, ok := amd64BMI2ShiftSpecs[Op(row[1])]
+		prefix := map[int]string{1: "vex66", 2: "vexF3", 3: "vexF2"}[spec.prefix]
+		wide := strings.HasSuffix(row[1], "Q")
+		if !ok || row[2] != "_ybextrl" || (spec.bits == 64) != wide {
+			t.Fatalf("incorrect grammar for %s: %+v", row[1], spec)
+		}
+		for _, token := range []string{"vex128", "vex0F38", "0xF7", prefix} {
+			if !strings.Contains(row[3], token) {
+				t.Fatalf("Go %s missing %s", row[1], token)
+			}
+		}
+		if strings.Contains(row[3], "vexW1") != wide {
+			t.Fatalf("incorrect W for %s", row[1])
+		}
+	}
+	pattern = `(?s)var _ybextrl = \[\]ytab\{(.*?)\n\}`
+	table := regexp.MustCompile(pattern).FindStringSubmatch(string(data))
+	if len(table) != 2 || strings.Count(table[1], "argList{") != 1 || !strings.Contains(table[1], "argList{Yrl, Yml, Yrl}") {
+		t.Fatal("Go BMI2 shift operand grammar changed")
+	}
+}
+
+func TestX86RawBMI2ShiftEncodingFields(t *testing.T) {
+	cases := 0
+	for pp, stem := range map[int]string{1: "SHLX", 2: "SARX", 3: "SHRX"} {
+		for _, wide := range []bool{false, true} {
+			for source := 0; source < 16; source++ {
+				for count := 0; count < 16; count++ {
+					for dst := 0; dst < 16; dst++ {
+						code := encodeRawScalarMove(false, pp, 0xf7, source, count, dst, 0, false)
+						code[1] = code[1]&0xe0 | 2
+						if wide {
+							code[2] |= 0x80
+						}
+						for _, mode := range []int{32, 64} {
+							got, n, matched, err := decodedX86BMI2ShiftInstruction(code, mode)
+							if mode == 32 && (source >= 8 || count >= 8 || dst >= 8) {
+								if !matched || err == nil {
+									t.Fatalf("386 accepted %x", code)
+								}
+								continue
+							}
+							width := "L"
+							if wide && mode == 64 {
+								width = "Q"
+							}
+							sr, _ := decodedX86GeneralRegister(source)
+							cr, _ := decodedX86GeneralRegister(count)
+							dr, _ := decodedX86GeneralRegister(dst)
+							want := []Operand{
+								{Kind: OpReg, Reg: cr},
+								{Kind: OpReg, Reg: sr},
+								{Kind: OpReg, Reg: dr},
+							}
+							if err != nil || !matched || n != len(code) || got.Op != Op(stem+width) || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x mode=%d: %+v %v, want %s %+v", code, mode, got, err, stem+width, want)
+							}
+						}
+						cases++
+					}
+				}
+			}
+		}
+	}
+	if cases != 24576 {
+		t.Fatalf("checked %d encodings, want 24576", cases)
+	}
+}
+
+func TestX86RawBMI2ShiftInvalidAndSegmentForms(t *testing.T) {
+	invalid := [][]byte{
+		{0xc4, 0xe2, 0x7d, 0xf7, 0xc0},             // VEX.L1.
+		{0x62, 0xf2, 0x7d, 0x08, 0xf7, 0xc0},       // EVEX.
+		{0xc4, 0xe2, 0x79, 0xf7},                   // Missing ModRM.
+		{0xc4, 0xe2, 0x79, 0xf7, 0x04},             // Missing SIB.
+		{0xc4, 0xe2, 0x79, 0xf7, 0x80},             // Missing displacement.
+		{0xc4, 0xe2, 0x79, 0xf7, 0x05, 0, 0, 0, 0}, // RIP-relative.
+		{0x67, 0xc4, 0xe2, 0x79, 0xf7, 0x00},       // Address override.
+	}
+	for _, code := range invalid {
+		if _, _, matched, err := decodedX86BMI2ShiftInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x", code)
+		}
+	}
+	if _, _, matched, err := decodedX86BMI2ShiftInstruction([]byte{0xc4, 0xe2, 0x79, 0xf7, 0xc0}, 16); !matched || err == nil {
+		t.Fatal("accepted invalid mode")
+	}
+	for _, code := range [][]byte{nil, {0xc4}, {0xc4, 0xe2, 0x78, 0xf7, 0xc0}, {0xc4, 0xe1, 0x79, 0xf7, 0xc0}} {
+		if _, _, matched, _ := decodedX86BMI2ShiftInstruction(code, 64); matched {
+			t.Fatalf("matched unrelated encoding %x", code)
+		}
+	}
+
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		code := []byte{segment.prefix, 0xc4, 0x02, 0xb1, 0xf7, 0x64, 0x88, 0xf9}
+		got, n, matched, err := decodedX86BMI2ShiftInstruction(code, 64)
+		want := []Operand{
+			{Kind: OpReg, Reg: "R9"},
+			{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: -7}},
+			{Kind: OpReg, Reg: "R12"},
+		}
+		if err != nil || !matched || n != len(code) || got.Op != "SHLXQ" || !reflect.DeepEqual(got.Args, want) {
+			t.Fatalf("decode %x=%+v %v, want %+v", code, got, err, want)
+		}
+	}
+}
+
+func TestX86BMI2ShiftGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BMI2ShiftTestOps {
+			args := []string{
+				" AX,BX", " X0,AX,BX", " AX,X0,BX", " AX,BX,X0",
+				" (AX),BX,CX", " AX,BX,(CX)", " $1,BX,CX",
+				".Z AX,BX,CX", ".BCST AX,(BX),CX",
+			}
+			if arch == "386" {
+				args = append(args, " R8,BX,CX", " AX,R8,CX", " AX,BX,R8")
+			}
+			for _, operands := range args {
+				source := "TEXT bad(SB),4,$0-0\n" + op + operands + "\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{
+					Goarch:       arch,
+					TargetTriple: triple,
+					Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("translator accepted %s%s on %s", op, operands, arch)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawBMI2ShiftGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			regs := []string{"AX", "SP", "DI"}
+			if arch == "amd64" {
+				regs = append(regs, "R8", "R15")
+			}
+
+			var source strings.Builder
+			source.WriteString("TEXT bmi2shift(SB),4,$0-0\n")
+			for _, op := range x86BMI2ShiftTestOps {
+				for _, reg := range regs {
+					for _, input := range []string{reg, "(BX)", "-7(BP)(CX*4)", "8192(SI)"} {
+						fmt.Fprintf(&source, "%s %s,%s,%s\n", op, reg, input, reg)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("got %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if arch == "386" && strings.HasSuffix(string(want[i].Op), "Q") {
+					want[i].Op = Op(strings.TrimSuffix(string(want[i].Op), "Q") + "L")
+				}
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+
+			file := x86RawStackObservingFormProbeFile(t, arch, "bmi2shift", code)
+			triples := []string{
+				"x86_64-apple-darwin",
+				"x86_64-unknown-linux-gnu",
+				"x86_64-pc-windows-msvc",
+			}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-bmi2-shift.ll", "raw-bmi2-shift.o", ir)
+			}
+			t.Logf("checked %d Go encodings", len(want)-1)
+		})
+	}
+}
+
+func TestX86BMI2Shift386IgnoresW(t *testing.T) {
+	for _, op := range []string{"SARXQ", "SHLXQ", "SHRXQ"} {
+		t.Run(op, func(t *testing.T) {
+			// Retain the original Go-accepted source and its missing-input
+			// Context controls. Initialized whole programs have separate owners.
+			source := "TEXT shift(SB),4,$0-0\n" + op + " AX,(BX),CX\nRET\n"
+			ir := x86UnboundVoidScalarFormatObject(t, source, "shift", "386", "i386-unknown-linux-gnu")
+			if !strings.Contains(ir, "load volatile i32, ptr") || !strings.Contains(ir, ", 31\n") ||
+				strings.Contains(ir, "ashr i64") || strings.Contains(ir, "shl i64") || strings.Contains(ir, "lshr i64") {
+				t.Fatalf("386 %s must read exactly four bytes:\n%s", op, ir)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_broadcast_block.go b/amd64_raw_broadcast_block.go
new file mode 100644
index 000000000..f479430ef
--- /dev/null
+++ b/amd64_raw_broadcast_block.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawBlockBroadcastForm struct {
+	op          Op
+	sourceBytes int
+	minLength   int
+	allowX      bool
+}
+
+// Go 1.27's complete EVEX packed-block broadcast rows. The corresponding
+// VEX F128/I128 memory forms have a separate two-form decoder.
+var x86RawBlockBroadcastForms = map[[2]int]x86RawBlockBroadcastForm{
+	{0x19, 0}: {op: "VBROADCASTF32X2", sourceBytes: 8, minLength: 1, allowX: true},
+	{0x59, 0}: {op: "VBROADCASTI32X2", sourceBytes: 8, minLength: 0, allowX: true},
+	{0x1a, 0}: {op: "VBROADCASTF32X4", sourceBytes: 16, minLength: 1},
+	{0x1a, 1}: {op: "VBROADCASTF64X2", sourceBytes: 16, minLength: 1},
+	{0x5a, 0}: {op: "VBROADCASTI32X4", sourceBytes: 16, minLength: 1},
+	{0x5a, 1}: {op: "VBROADCASTI64X2", sourceBytes: 16, minLength: 1},
+	{0x1b, 0}: {op: "VBROADCASTF32X8", sourceBytes: 32, minLength: 2},
+	{0x1b, 1}: {op: "VBROADCASTF64X4", sourceBytes: 32, minLength: 2},
+	{0x5b, 0}: {op: "VBROADCASTI32X8", sourceBytes: 32, minLength: 2},
+	{0x5b, 1}: {op: "VBROADCASTI64X4", sourceBytes: 32, minLength: 2},
+}
+
+// decodedX86RawBlockBroadcastInstruction decodes every EVEX block-broadcast
+// shape, including register-backed X2 sources and K merge/zero masking.
+func decodedX86RawBlockBroadcastInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86RawBlockBroadcastInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86RawBlockBroadcastInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawBlockBroadcastForms[[2]int{p.opcode, w}]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX block broadcast: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.addressOverride || p.broadcast || p.upper != 0 ||
+		p.vectorLength < form.minLength || p.vectorLength > 2 {
+		return fail("invalid EVEX fixed, address, broadcast, vvvv, or vector-length bits")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 == 3 && !form.allowX {
+		return fail("this block width requires a memory source")
+	}
+	destinationNumber := int(modRM>>3&7) + p.r*8
+	if mode == 32 && p.vectorLength == 2 && destinationNumber >= 8 {
+		return fail("386 Z-register exceeds the Go assembler frontend's register class")
+	}
+	vector := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	source, consumed, err := memory.evex(
+		code[p.modRM:], mode, p.b, p.x, p.segment, "X", form.sourceBytes,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := form.op
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, destinationNumber))})
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_broadcast_block_test.go b/amd64_raw_broadcast_block_test.go
new file mode 100644
index 000000000..0816cac40
--- /dev/null
+++ b/amd64_raw_broadcast_block_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawBlockBroadcast(opcode, widthBit, vectorBits, mask int, zeroing, registerSource bool) []byte {
+	p1 := byte(0x7d)
+	if widthBit != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0x40) // disp8(AX), destination 0.
+	if registerSource {
+		modRM = 0xc1 // X1, destination 0.
+	}
+	code := []byte{0x62, 0xf2, p1, p2, byte(opcode), modRM}
+	if !registerSource {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawBlockBroadcastSeBiShogunRegression(t *testing.T) {
+	// Go disassembles the instruction as VBROADCASTI32X4 RIP+1, Z1.
+	code := []byte{0x62, 0xf2, 0x7d, 0x48, 0x5a, 0x0d, 1, 0, 0, 0, 0xc3}
+	for index := 0; index < 16; index++ {
+		code = append(code, byte(index+1))
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "onesCountInt32 AVX512 block broadcast", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VBROADCASTI32X4" ||
+		decoded[0].Args[1].Reg != "Z1" || !decoded[0].x86RIPLiteral {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawBlockBroadcastCompleteGoFamily(t *testing.T) {
+	if len(x86RawBlockBroadcastForms) != 10 {
+		t.Fatalf("modeled %d EVEX block-broadcast rows, want ten", len(x86RawBlockBroadcastForms))
+	}
+	for encoding, form := range x86RawBlockBroadcastForms {
+		for vectorBits := form.minLength; vectorBits <= 2; vectorBits++ {
+			for _, masking := range []struct {
+				mask, zero int
+			}{
+				{}, {mask: 3}, {mask: 7, zero: 1},
+			} {
+				for _, registerSource := range []bool{false, true} {
+					if registerSource && !form.allowX {
+						continue
+					}
+					name := fmt.Sprintf("%s/length%d/mask%d/zero%d/reg%t", form.op, vectorBits, masking.mask, masking.zero, registerSource)
+					t.Run(name, func(t *testing.T) {
+						code := encodeX86RawBlockBroadcast(encoding[0], encoding[1], vectorBits, masking.mask, masking.zero != 0, registerSource)
+						got, length, ok, err := decodedX86RawBlockBroadcastInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantOp := form.op
+						if masking.zero != 0 {
+							wantOp += ".Z"
+						}
+						wantDestination := fmt.Sprintf("%s0", [...]string{"X", "Y", "Z"}[vectorBits])
+						if got.Op != wantOp || got.Args[len(got.Args)-1].String() != wantDestination ||
+							registerSource && got.Args[0].String() != "X1" ||
+							len(got.Args) != 2+map[bool]int{true: 1}[masking.mask != 0] {
+							t.Fatalf("decode %x = %+v, want %s ... %s", code, got, wantOp, wantDestination)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawBlockBroadcastRIPLiteralCompleteFamily(t *testing.T) {
+	for encoding, form := range x86RawBlockBroadcastForms {
+		for vectorBits := form.minLength; vectorBits <= 2; vectorBits++ {
+			code := encodeX86RawBlockBroadcast(encoding[0], encoding[1], vectorBits, 1, false, false)
+			code = code[:6]
+			code[5] = 0x05 // RIP-relative source, destination 0.
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			for index := 0; index < form.sourceBytes; index++ {
+				code = append(code, byte(index+1))
+			}
+			name := fmt.Sprintf("%s/length%d", form.op, vectorBits)
+			t.Run(name, func(t *testing.T) {
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || !got[0].x86RIPLiteral ||
+					len(got[0].x86RIPLiteralData) != form.sourceBytes || got[0].Op != form.op {
+					t.Fatalf("decode %x = %+v", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawBlockBroadcastRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawBlockBroadcast(0x5a, 0, 2, 0, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x10 },  // no EVEX.b broadcast
+		func(code []byte) { code[3] |= 0x80 },  // zeroing needs a mask
+		func(code []byte) { code[3] |= 0x20 },  // vector length 3 reserved
+		func(code []byte) { code[2] &^= 0x08 }, // reserved vvvv
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86RawBlockBroadcastInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	registerSource := encodeX86RawBlockBroadcast(0x5a, 0, 2, 0, false, true)
+	if _, _, ok, err := decodedX86RawBlockBroadcastInstruction(registerSource, 64); !ok || err == nil {
+		t.Fatalf("accepted m128-only register source %x: ok=%v err=%v", registerSource, ok, err)
+	}
+}
+
+func TestTranslateX86RawBlockBroadcastLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawBlockBroadcast(SB),$0-0\n")
+			for encoding, form := range x86RawBlockBroadcastForms {
+				for vectorBits := form.minLength; vectorBits <= 2; vectorBits++ {
+					for _, masking := range []struct {
+						mask int
+						zero bool
+					}{
+						{}, {mask: 3}, {mask: 7, zero: true},
+					} {
+						code := encodeX86RawBlockBroadcast(encoding[0], encoding[1], vectorBits, masking.mask, masking.zero, false)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-block-broadcast.ll", "raw-block-broadcast.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_broadcast_literal.go b/amd64_raw_broadcast_literal.go
new file mode 100644
index 000000000..8f8cc52fc
--- /dev/null
+++ b/amd64_raw_broadcast_literal.go
@@ -0,0 +1,1433 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+type x86RawLiteralRange struct {
+	first  int
+	last   int
+	source int
+}
+
+// decodeX86RawPackedBroadcastLiteral resolves a RIP-relative packed scalar
+// broadcast only when its source bytes live in the same raw directive group.
+// The caller must still prove that those bytes are not reachable instructions.
+// A displacement into another TEXT, a missing constant pool, and segment- or
+// address-size-relative loads stay on the rejecting decoder path.
+func decodeX86RawPackedBroadcastLiteral(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+
+	// A segment or address-size prefix changes the effective source.
+	switch code[offset] {
+	case 0x64, 0x65, 0x67:
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+
+	modRMIndex := -1
+	laneBytes := 0
+	if len(code) >= offset+5 && code[offset] == 0xc4 && code[offset+1]&0x1f == 2 {
+		modRMIndex = offset + 4
+		switch code[offset+3] {
+		case 0x78:
+			laneBytes = 1
+		case 0x79:
+			laneBytes = 2
+		case 0x58:
+			laneBytes = 4
+		case 0x59:
+			laneBytes = 8
+		}
+	} else if len(code) >= offset+6 && code[offset] == 0x62 && code[offset+1]&0x0f == 2 {
+		modRMIndex = offset + 5
+		switch code[offset+4] {
+		case 0x78:
+			laneBytes = 1
+		case 0x79:
+			laneBytes = 2
+		case 0x58:
+			laneBytes = 4
+		case 0x59:
+			laneBytes = 8
+		}
+	}
+	if laneBytes == 0 || modRMIndex < 0 || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	patched, value, literal, err := x86RawRIPLiteral(code, offset, modRMIndex, laneBytes)
+	if err != nil {
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	length := len(patched)
+	instruction, consumed, ok, err := decodedX86VEXPackedBroadcastInstruction(patched, mode)
+	if err != nil || !ok || consumed != length {
+		if err == nil {
+			err = fmt.Errorf("RIP-relative packed broadcast did not match its VEX/EVEX grammar")
+		}
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+
+	setX86RawRIPLiteral(&instruction, value)
+	return instruction, length, literal, true, nil
+}
+
+// decodeX86RawVMOVIntegerLiteral covers all memory-to-X VMOVW/VMOVD/VMOVQ VEX and
+// EVEX encodings, including VMOVQ's alternate F3 7E encoding. The ordinary
+// decoder validates the full grammar after the fixed-length ModRM rewrite.
+func decodeX86RawVMOVIntegerLiteral(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+
+	switch code[offset] {
+	case 0x64, 0x65, 0x67:
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := -1
+	width := 0
+	if len(code) >= offset+4 && code[offset] == 0xc5 {
+		modRMIndex = offset + 3
+		width = x86RawVMOVLoadWidth(code[offset+2], code[offset+1]&3, false, false)
+	} else if len(code) >= offset+5 && code[offset] == 0xc4 && code[offset+1]&0x1f == 1 {
+		modRMIndex = offset + 4
+		width = x86RawVMOVLoadWidth(code[offset+3], code[offset+2]&3, code[offset+2]&0x80 != 0, false)
+	} else if len(code) >= offset+6 && code[offset] == 0x62 {
+		modRMIndex = offset + 5
+		if code[offset+1]&0x0f == 1 {
+			width = x86RawVMOVLoadWidth(code[offset+4], code[offset+2]&3, code[offset+2]&0x80 != 0, true)
+		} else if code[offset+1]&0x0f == 5 && code[offset+4] == 0x6e && code[offset+2]&3 == 1 {
+			width = 2
+		}
+	}
+	if width == 0 || modRMIndex < 0 || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+
+	patched, value, literal, err := x86RawRIPLiteral(code, offset, modRMIndex, width)
+	if err != nil {
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	instruction, consumed, ok, err := decodedX86VMOVQInstruction(patched, mode)
+	if err != nil || !ok || consumed != len(patched) ||
+		len(instruction.Args) != 2 || instruction.Args[0].Kind != OpMem {
+		if err == nil {
+			err = fmt.Errorf("RIP-relative VMOVW/VMOVD/VMOVQ load did not match its VEX/EVEX grammar")
+		}
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	setX86RawRIPLiteral(&instruction, value)
+	return instruction, len(patched), literal, true, nil
+}
+
+// decodeX86RawScalarFloatBroadcastLiteral resolves VBROADCASTSS/SD loads
+// through the same source-local, unreachable constant-pool proof.
+func decodeX86RawScalarFloatBroadcastLiteral(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 2 || p.pp != 1 ||
+		(p.opcode != 0x18 && p.opcode != 0x19) ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 4
+	if p.opcode == 0x19 {
+		width = 8
+	}
+	patched, value, literal, err := x86RawRIPLiteral(code, offset, modRMIndex, width)
+	if err != nil {
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	instruction, consumed, ok, err := decodedX86ScalarBroadcastInstruction(patched, mode)
+	if err != nil || !ok || consumed != len(patched) ||
+		len(instruction.Args) < 2 || instruction.Args[0].Kind != OpMem {
+		if err == nil {
+			err = fmt.Errorf("RIP-relative scalar float broadcast did not match its VEX/EVEX grammar")
+		}
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	setX86RawRIPLiteral(&instruction, value)
+	return instruction, len(patched), literal, true, nil
+}
+
+func x86RawVMOVLoadWidth(opcode, pp byte, width64, evex bool) int {
+	if opcode == 0x6e && pp == 1 {
+		if width64 {
+			return 8
+		}
+		return 4
+	}
+	if opcode == 0x7e && pp == 2 && (width64 == evex) {
+		return 8
+	}
+	return 0
+}
+
+func x86RawRIPLiteral(code []byte, offset, modRMIndex, width int) ([]byte, int64, x86RawLiteralRange, error) {
+	patched, data, literal, err := x86RawRIPBytes(code, offset, modRMIndex, width)
+	if err != nil {
+		return nil, 0, x86RawLiteralRange{}, err
+	}
+	if width > 8 {
+		return nil, 0, x86RawLiteralRange{}, fmt.Errorf("%d-byte RIP literal does not fit an immediate", width)
+	}
+	var value uint64
+	for index, b := range data {
+		value |= uint64(b) << (8 * index)
+	}
+	return patched, int64(value), literal, nil
+}
+
+func x86RawRIPBytes(code []byte, offset, modRMIndex, width int) ([]byte, []byte, x86RawLiteralRange, error) {
+	return x86RawRIPBytesWithSuffix(code, offset, modRMIndex, width, 0)
+}
+
+func x86RawRIPBytesWithSuffix(code []byte, offset, modRMIndex, width, trailingBytes int) ([]byte, []byte, x86RawLiteralRange, error) {
+	if trailingBytes < 0 || len(code) < modRMIndex+5+trailingBytes {
+		return nil, nil, x86RawLiteralRange{}, fmt.Errorf("truncated RIP-relative literal")
+	}
+	length := modRMIndex + 5 + trailingBytes - offset
+	displacement := int32(binary.LittleEndian.Uint32(code[modRMIndex+1 : modRMIndex+5]))
+	first := offset + length + int(displacement)
+	last := first + width
+	if width <= 0 || first < 0 || last > len(code) || last < first {
+		return nil, nil, x86RawLiteralRange{}, fmt.Errorf("RIP-relative literal [%d,%d) is outside directive group", first, last)
+	}
+
+	// A base-register disp32 has the same byte length as RIP+disp32, allowing
+	// the existing VEX/EVEX grammar to validate every other encoding field.
+	patched := append([]byte(nil), code[offset:offset+length]...)
+	patched[modRMIndex-offset] = patched[modRMIndex-offset]&0x38 | 0x80
+	data := append([]byte(nil), code[first:last]...)
+	return patched, data, x86RawLiteralRange{first: first, last: last}, nil
+}
+
+// decodeX86RawPackedMoveRIPData handles source-local X/Y/Z memory loads for
+// the complete packed float and VEX integer move decoder families.
+func decodeX86RawPackedMoveRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	packedFloat := (p.opcode == 0x10 || p.opcode == 0x28) && p.pp <= 1
+	packedInteger := p.opcode == 0x6f && !p.evex && (p.pp == 1 || p.pp == 2)
+	if !matched || p.mapNumber != 1 || (!packedFloat && !packedInteger) ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86PackedMoveInstruction, "packed move",
+	)
+}
+
+// decodeX86RawEVEXPackedIntegerMoveRIPData covers the six EVEX VMOVDQA/DQU
+// load opcodes across X/Y/Z widths and optional K masks.
+func decodeX86RawEVEXPackedIntegerMoveRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 1 || p.opcode != 0x6f ||
+		(p.pp != 1 && p.pp != 2 && p.pp != 3) ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86EVEXPackedIntegerMoveInstruction, "EVEX packed integer move",
+	)
+}
+
+// decodeX86RawVBROADCAST128RIPData resolves both VEX.256 F128/I128
+// m128-to-Y forms through their shared source-memory grammar.
+func decodeX86RawVBROADCAST128RIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		p.vectorLength != 1 || (p.opcode != 0x1a && p.opcode != 0x5a) ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, 16,
+		decodedX86VBROADCAST128Instruction, "VBROADCASTF128/VBROADCASTI128",
+	)
+}
+
+// decodeX86RawPackedLogicalRIPData covers VEX VPAND/ANDN/OR/XOR and their
+// EVEX D/Q counterparts. EVEX.b reads one scalar lane; other forms read the
+// full X/Y/Z-width vector from the same unreachable source-local pool.
+func decodeX86RawPackedLogicalRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 1 || p.pp != 1 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	switch p.opcode {
+	case 0xdb, 0xdf, 0xeb, 0xef:
+	default:
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	decoder := x86RawInstructionDecoder(decodedX86VEXPackedIntegerLogicalInstruction)
+	family := "VEX packed integer logical"
+	if p.evex {
+		decoder = decodedX86EVEXPackedLogicalInstruction
+		family = "EVEX packed logical"
+		if p.broadcast {
+			width = 4
+			if p.w {
+				width = 8
+			}
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width, decoder, family,
+	)
+}
+
+// decodeX86RawFloatLogicalRIPData covers VEX/EVEX VAND/ANDN/OR/XOR PS/PD
+// reads from an unreachable source-local X/Y/Z-width constant pool.
+func decodeX86RawFloatLogicalRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 1 || p.pp > 1 ||
+		p.opcode < 0x54 || p.opcode > 0x57 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	decoder := x86RawInstructionDecoder(decodedX86VEXPackedFloatLogicalInstruction)
+	if p.evex {
+		decoder = decodedX86RawEVEXFloatLogicalInstruction
+		if p.broadcast {
+			width = 4
+			if p.w {
+				width = 8
+			}
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width, decoder, "packed floating logical",
+	)
+}
+
+// decodeX86RawHorizontalFloatRIPData covers VHADD/VHSUB/VADDSUB PS/PD
+// VEX X/Y reads from unreachable source-local vector constants.
+func decodeX86RawHorizontalFloatRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.evex || p.mapNumber != 1 ||
+		(p.pp != 1 && p.pp != 3) || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	switch p.opcode {
+	case 0x7c, 0x7d, 0xd0:
+	default:
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, 16<<p.vectorLength,
+		decodedX86VEXHorizontalFloatInstruction, "horizontal/alternating floating",
+	)
+}
+
+// decodeX86RawImmediatePackedBlendRIPData covers the complete Go 1.27
+// legacy and VEX immediate blend family. The immediate follows disp32, so
+// the pool displacement is relative to the byte after that immediate.
+func decodeX86RawImmediatePackedBlendRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := -1
+	width := 16
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if matched && !p.evex && p.mapNumber == 3 && p.pp == 1 &&
+		p.segment == "" && !p.addressOverride {
+		switch p.opcode {
+		case 0x02, 0x0c, 0x0d, 0x0e:
+			modRMIndex = offset + p.modRM
+			width <<= p.vectorLength
+		}
+	}
+	if modRMIndex < 0 && code[offset] == 0x66 {
+		i := offset + 1
+		if i < len(code) && code[i]&0xf0 == 0x40 {
+			i++ // Optional REX extension for the legacy X registers.
+		}
+		if len(code) >= i+4 && code[i] == 0x0f && code[i+1] == 0x3a {
+			switch code[i+2] {
+			case 0x0c, 0x0d, 0x0e:
+				modRMIndex = i + 3
+			}
+		}
+	}
+	if modRMIndex < 0 || len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86ImmediatePackedBlendInstruction, "immediate packed blend",
+	)
+}
+
+// decodeX86RawCLMULRIPData covers legacy PCLMULQDQ and all VEX/EVEX
+// VPCLMULQDQ widths. The imm8 follows the source displacement.
+func decodeX86RawCLMULRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := -1
+	width := 16
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if matched && p.mapNumber == 3 && p.pp == 1 && p.opcode == 0x44 &&
+		p.segment == "" && !p.addressOverride && p.vectorLength <= 2 {
+		modRMIndex = offset + p.modRM
+		width <<= p.vectorLength
+	}
+	if modRMIndex < 0 && code[offset] == 0x66 {
+		i := offset + 1
+		if i < len(code) && code[i]&0xf0 == 0x40 {
+			i++
+		}
+		if len(code) >= i+4 && code[i] == 0x0f && code[i+1] == 0x3a && code[i+2] == 0x44 {
+			modRMIndex = i + 3
+		}
+	}
+	if modRMIndex < 0 || len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86RawCLMULInstruction, "carryless multiply",
+	)
+}
+
+// decodeX86RawMaskBlendRIPData folds source-local vector constants, or one
+// D/Q broadcast lane, for all six EVEX mask-blend operations.
+func decodeX86RawMaskBlendRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		p.opcode < 0x64 || p.opcode > 0x66 ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+		if p.w {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86RawMaskBlendInstruction, "EVEX mask blend",
+	)
+}
+
+// decodeX86RawScalarMoveRIPData covers memory-to-X VMOVSS/VMOVSD VEX and
+// EVEX encodings plus raw EVEX VMOVSH. The typed scalar decoder enforces
+// reserved fields and masks.
+func decodeX86RawScalarMoveRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	half := p.evex && p.mapNumber == 5 && p.pp == 2
+	if !matched || (p.mapNumber != 1 && !half) || p.opcode != 0x10 ||
+		(p.pp != 2 && p.pp != 3) || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 4
+	if half {
+		width = 2
+	} else if p.pp == 3 {
+		width = 8
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86ScalarMoveInstruction, "scalar move",
+	)
+}
+
+// decodeX86RawMinMaxRIPData covers the complete VEX/EVEX packed integer
+// min/max family. EVEX.b reads one D/Q lane; other forms read a full vector.
+func decodeX86RawMinMaxRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	for _, spec := range amd64PackedIntegerMinMaxSpecs {
+		if p.mapNumber != spec.mapNumber || p.opcode != spec.opcode {
+			continue
+		}
+		if !p.evex && spec.laneBits == 64 {
+			continue
+		}
+		if p.evex && spec.laneBits >= 32 && p.w != (spec.laneBits == 64) {
+			continue
+		}
+		width := 16 << p.vectorLength
+		if p.evex && p.broadcast {
+			width = spec.laneBits / 8
+		}
+		return x86RawRIPDataThroughDecoder(
+			code, offset, mode, modRMIndex, width,
+			decodedX86PackedIntegerMinMaxInstruction, "packed integer min/max",
+		)
+	}
+	return Instr{}, 0, x86RawLiteralRange{}, false, nil
+}
+
+// decodeX86RawPackedCompareRIPData covers all VPCMPEQ/GT B/W/D/Q source
+// memory forms. The ordinary decoder checks the EVEX mask-result grammar.
+func decodeX86RawPackedCompareRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	for _, spec := range amd64PackedIntegerCompareSpecs {
+		if p.mapNumber != spec.mapNumber || p.opcode != spec.opcode {
+			continue
+		}
+		width := 16 << p.vectorLength
+		if p.evex && p.broadcast {
+			width = spec.laneBits / 8
+		}
+		return x86RawRIPDataThroughDecoder(
+			code, offset, mode, modRMIndex, width,
+			decodedX86PackedIntegerCompareInstruction, "packed integer compare",
+		)
+	}
+	return Instr{}, 0, x86RawLiteralRange{}, false, nil
+}
+
+// decodeX86RawVariableShiftRIPData covers the VEX and EVEX per-lane variable
+// shift family, including scalar D/Q memory broadcast in EVEX encodings.
+func decodeX86RawVariableShiftRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 2 || p.pp != 1 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	for _, spec := range amd64PerLaneVariableShiftSpecs {
+		if p.opcode != int(spec.opcode) || p.w != (spec.laneBits != 32) ||
+			!p.evex && !spec.vex {
+			continue
+		}
+		width := 16 << p.vectorLength
+		if p.evex && p.broadcast {
+			width = spec.laneBits / 8
+		}
+		return x86RawRIPDataThroughDecoder(
+			code, offset, mode, modRMIndex, width,
+			decodedX86PerLaneVariableShiftInstruction, "per-lane variable shift",
+		)
+	}
+	return Instr{}, 0, x86RawLiteralRange{}, false, nil
+}
+
+// decodeX86RawVPSHUFBRIPData covers every VEX and EVEX vector-width load
+// accepted by Go's VPSHUFB table. The instruction has no scalar broadcast.
+func decodeX86RawVPSHUFBRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 2 || p.pp != 1 || p.opcode != 0 ||
+		p.w || p.broadcast || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86VPSHUFBInstruction, "VPSHUFB",
+	)
+}
+
+// decodeX86RawPackedArithmeticRIPData covers the complete VEX/EVEX VPADD
+// and VPSUB families, including their D/Q scalar memory broadcasts.
+func decodeX86RawPackedArithmeticRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 1 || p.pp != 1 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	properties, recognized := decodedX86PackedIntegerArithmeticOps[byte(p.opcode)]
+	if !recognized {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.evex && p.broadcast {
+		width = properties.laneBytes
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86PackedIntegerArithmeticInstruction, "packed integer arithmetic",
+	)
+}
+
+// decodeX86RawFMA3RIPData handles all packed and scalar FMA3 encodings.
+// Scalar operations read one lane; packed EVEX.b memory forms broadcast it.
+func decodeX86RawFMA3RIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	half := p.evex && p.mapNumber == 6
+	if !matched || p.mapNumber != 2 && !half || p.pp != 1 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	spec, recognized := decodedX86VEXFMA3Ops[byte(p.opcode)]
+	if !recognized {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if spec.scalar || p.evex && p.broadcast {
+		width = 4
+		if p.w {
+			width = 8
+		}
+		if half {
+			width = 2
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86VEXFMA3Instruction, "FMA3",
+	)
+}
+
+// decodeX86RawBinaryFloatRIPData covers VADD/MUL/SUB/MIN/DIV/MAX packed and
+// scalar forms, including raw AVX-512 FP16, plus scalar VSQRT and packed
+// memory broadcast.
+func decodeX86RawBinaryFloatRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	half := p.evex && p.mapNumber == 5 && (p.pp == 0 || p.pp == 2)
+	if !matched || (p.mapNumber != 1 && !half) || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	switch p.opcode {
+	case 0x58, 0x59, 0x5c, 0x5d, 0x5e, 0x5f:
+	case 0x51:
+		if p.pp < 2 && !half {
+			return Instr{}, 0, x86RawLiteralRange{}, false, nil
+		}
+	default:
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if half {
+		if p.pp == 2 || p.broadcast {
+			width = 2
+		}
+	} else if p.pp >= 2 || p.evex && p.broadcast {
+		width = 4
+		if p.pp == 1 || p.pp == 3 {
+			width = 8
+		}
+	}
+	decoder := decodedX86VEXBinaryFloatInstruction
+	if half && p.opcode == 0x51 && p.pp == 0 {
+		decoder = decodedX86SameWidthConversionInstruction
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decoder, "binary floating",
+	)
+}
+
+// decodeX86RawScalarFlagCompareRIPData covers VCOMIS{S,D} and
+// VUCOMIS{S,D} VEX/EVEX memory sources. EVEX.b remains register-only SAE.
+func decodeX86RawScalarFlagCompareRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 1 || (p.opcode != 0x2e && p.opcode != 0x2f) ||
+		(p.pp != 0 && p.pp != 1) || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 4
+	if p.pp == 1 {
+		width = 8
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86ScalarFlagCompareInstruction, "scalar flag compare",
+	)
+}
+
+// decodeX86RawVectorFloatCompareRIPData accounts for VCMP's trailing imm8
+// when resolving the RIP displacement and its second Plan 9 operand.
+func decodeX86RawVectorFloatCompareRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 1 || p.opcode != 0xc2 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.pp >= 2 || p.evex && p.broadcast {
+		width = 4
+		if p.pp == 1 || p.pp == 3 {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86VectorFloatCompareInstruction, "vector floating compare",
+	)
+}
+
+// decodeX86RawPackedMultiplyRIPData covers the five packed word/D/Q multiply
+// opcode rows, including EVEX D/Q memory broadcast and masked widths.
+func decodeX86RawPackedMultiplyRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.pp != 1 || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	form, recognized := x86PackedMultiplyFormFor(byte(p.mapNumber), byte(p.opcode))
+	if !recognized || p.evex && p.broadcast && form.broadcastByte == 0 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.evex && p.broadcast {
+		width = form.broadcastByte
+		if p.w {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86PackedMultiplyInstruction, "packed multiply",
+	)
+}
+
+// decodeX86RawPackedAbsRIPData resolves source-local X/Y/Z VPABS loads,
+// including the D/Q EVEX memory-broadcast lanes.
+func decodeX86RawPackedAbsRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 2 || p.pp != 1 || p.opcode < 0x1c || p.opcode > 0x1f ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.evex && p.broadcast {
+		width = [...]int{1, 2, 4, 8}[p.opcode-0x1c]
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86RawPackedAbsInstruction, "VPABS",
+	)
+}
+
+// decodeX86RawVEXRoundRIPData accounts for VROUND's trailing imm8 while
+// resolving packed or scalar source-local constant loads.
+func decodeX86RawVEXRoundRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.mapNumber != 3 || p.pp != 1 || p.opcode < 0x08 || p.opcode > 0x0b ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.opcode == 0x0a {
+		width = 4
+	} else if p.opcode == 0x0b {
+		width = 8
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86RawVEXRoundInstruction, "VROUND",
+	)
+}
+
+// decodeX86RawDuplicateMoveRIPData covers legacy, VEX and EVEX MOVDDUP,
+// MOVSLDUP and MOVSHDUP. The X-width DDUP form reads only one 64-bit lane;
+// all other forms read the complete source vector.
+func decodeX86RawDuplicateMoveRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := -1
+	width := 0
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if matched && p.mapNumber == 1 && p.segment == "" && !p.addressOverride {
+		double := p.pp == 3 && p.opcode == 0x12
+		single := p.pp == 2 && (p.opcode == 0x12 || p.opcode == 0x16)
+		if double || single {
+			modRMIndex = offset + p.modRM
+			width = 16 << p.vectorLength
+			if double && p.vectorLength == 0 {
+				width = 8
+			}
+		}
+	} else {
+		i := offset
+		prefix := code[i]
+		if prefix == 0xf2 || prefix == 0xf3 {
+			i++
+			if i < len(code) && code[i]&0xf0 == 0x40 {
+				i++
+			}
+			if len(code) >= i+3 && code[i] == 0x0f &&
+				(prefix == 0xf2 && code[i+1] == 0x12 ||
+					prefix == 0xf3 && (code[i+1] == 0x12 || code[i+1] == 0x16)) {
+				modRMIndex = i + 2
+				width = 16
+				if prefix == 0xf2 {
+					width = 8
+				}
+			}
+		}
+	}
+	if modRMIndex < 0 || len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86DuplicateMoveInstruction, "duplicate move",
+	)
+}
+
+// decodeX86RawVectorByteShiftRIPData resolves EVEX X/Y/Z memory forms of
+// VPSLLDQ and VPSRLDQ, accounting for the trailing shift-count imm8.
+func decodeX86RawVectorByteShiftRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 1 || p.pp != 1 || p.opcode != 0x73 ||
+		p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	group := int(code[modRMIndex]>>3) & 7
+	if group != 3 && group != 7 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, 16<<p.vectorLength, 1, 1,
+		decodedX86RawVectorByteShiftInstruction, "vector byte shift",
+	)
+}
+
+// decodeX86RawPackedMADDRIPData covers VEX and EVEX VPMADDWD/VPMADDUBSW.
+// Their memory operand reads the full vector and never broadcasts.
+func decodeX86RawPackedMADDRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.pp != 1 || p.segment != "" || p.addressOverride ||
+		p.evex && p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	if !(p.mapNumber == 1 && p.opcode == 0xf5 ||
+		p.mapNumber == 2 && p.opcode == 0x04) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	decode := x86RawInstructionDecoder(decodedX86VEXPackedMADDInstruction)
+	if p.evex {
+		decode = decodedX86EVEXPackedMADDInstruction
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, 16<<p.vectorLength,
+		decode, "packed multiply-add",
+	)
+}
+
+// decodeX86RawVariableBlendRIPData covers all three VEX variable-blend
+// mnemonics in their X/Y memory forms. The mask register follows the RIP
+// displacement as an immediate selector, so it contributes to PC-relative
+// target calculation but is not part of the memory operand.
+func decodeX86RawVariableBlendRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || p.evex || p.mapNumber != 3 || p.pp != 1 || p.w ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 1 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	if p.opcode != 0x4a && p.opcode != 0x4b && p.opcode != 0x4c {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, 16<<p.vectorLength, 1, 1,
+		decodedX86VariableBlendInstruction, "variable blend",
+	)
+}
+
+// VPTERNLOGD/Q and VALIGND/Q share Go's immediate three-vector grammar.
+// Their RIP-relative source is a full vector or a scalar broadcast, while
+// imm8 trails the displacement in both cases.
+func decodeX86RawImmediateThreeVectorRIPData(
+	code []byte, offset, mode int, opcode byte,
+	decode x86RawInstructionDecoder, family string,
+) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 3 || p.pp != 1 ||
+		p.opcode != int(opcode) || p.segment != "" || p.addressOverride ||
+		p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+		if p.w {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1, decode, family,
+	)
+}
+
+func decodeX86RawPackedWidenConversionRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 1 || p.pp != 1 ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	ops := x86RawPackedWidenConversionByOpcode
+	if p.w {
+		ops = x86RawPackedDoubleConversionByOpcode
+	}
+	if _, recognized := ops[p.opcode]; !recognized {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 8 << p.vectorLength
+	if p.w {
+		width *= 2
+	}
+	if p.broadcast {
+		width = 4
+		if p.w {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 0, 0,
+		decodedX86PackedWidenConversionInstruction, "packed widening conversion",
+	)
+}
+
+// decodeX86RawLegacySIMDMoveRIPData covers the six 128-bit and two scalar
+// legacy MOV loads in Go's yxmov table. The other direction is a store and
+// does not read the RIP-relative source bytes.
+func decodeX86RawLegacySIMDMoveRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	i := offset
+	prefix := byte(0)
+	unsafeAddress := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64, 0x65, 0x67:
+			unsafeAddress = true
+		case 0x66, 0xf2, 0xf3:
+			if prefix != 0 {
+				return Instr{}, 0, x86RawLiteralRange{}, false, nil
+			}
+			prefix = code[i]
+		default:
+			if code[i] >= 0x40 && code[i] <= 0x4f {
+				i++
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	if len(code) < i+3 || code[i] != 0x0f {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	opcode := code[i+1]
+	valid := opcode == 0x10 ||
+		opcode == 0x28 && (prefix == 0 || prefix == 0x66) ||
+		opcode == 0x6f && (prefix == 0x66 || prefix == 0xf3)
+	if !valid || code[i+2]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	if unsafeAddress {
+		return Instr{}, 0, x86RawLiteralRange{}, true, fmt.Errorf("segment/address override is not source-layout safe")
+	}
+	width := 16
+	if opcode == 0x10 && prefix == 0xf3 {
+		width = 4
+	} else if opcode == 0x10 && prefix == 0xf2 {
+		width = 8
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, i+2, width,
+		decodedX86LegacySIMDMoveInstruction, "legacy SIMD move",
+	)
+}
+
+func decodedX86LegacySIMDMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	inst, err := x86asm.Decode(code, mode)
+	if err != nil || inst.Len <= 0 {
+		return Instr{}, 0, true, err
+	}
+	syntax, err := decodedX86GoSyntax(inst, code[:inst.Len])
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	instrs, err := parseDecodedX86Instruction(syntax)
+	if err != nil || len(instrs) != 1 {
+		if err == nil {
+			err = fmt.Errorf("legacy SIMD move decoded as %d instructions", len(instrs))
+		}
+		return Instr{}, 0, true, err
+	}
+	return instrs[0], inst.Len, true, nil
+}
+
+type x86RawInstructionDecoder func([]byte, int) (Instr, int, bool, error)
+
+// decodeX86RawIndexedPermuteRIPData preserves local vector/scalar constants
+// for the complete VPERMI2/VPERMT2 family.
+func decodeX86RawIndexedPermuteRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		(p.opcode < 0x75 || p.opcode > 0x77) && (p.opcode < 0x7d || p.opcode > 0x7f) ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+		if p.opcode == 0x76 || p.opcode == 0x77 || p.opcode == 0x7e || p.opcode == 0x7f {
+			if p.w {
+				width = 8
+			}
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86IndexedPermuteInstruction, "EVEX indexed permute",
+	)
+}
+
+// decodeX86RawEVEXVariableDwordPermuteRIPData preserves local Y/Z data or
+// scalar broadcast constants for VPERMD and VPERMPS.
+func decodeX86RawEVEXVariableDwordPermuteRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 || p.w ||
+		(p.opcode != 0x36 && p.opcode != 0x16) ||
+		p.segment != "" || p.addressOverride || p.vectorLength < 1 || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86EVEXVariableDwordPermuteInstruction, "EVEX variable dword permute",
+	)
+}
+
+// decodeX86RawMaskCompareRIPData resolves local full-vector or D/Q broadcast
+// constants and accounts for the comparison's trailing imm8.
+func decodeX86RawMaskCompareRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawMaskCompareForms[[2]int{p.opcode, w}]
+	if !matched || !p.evex || p.mapNumber != 3 || p.pp != 1 || !recognized ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = form.laneBytes
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86RawMaskCompareInstruction, "EVEX mask compare",
+	)
+}
+
+// decodeX86RawScaledRoundRIPData accounts for the trailing imm8 while
+// resolving packed vectors, packed broadcasts, and scalar local constants.
+func decodeX86RawScaledRoundRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawScaledRoundForms[[2]int{p.opcode, w}]
+	if !matched || !p.evex || p.mapNumber != 3 || p.pp != 1 || !recognized ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if form.scalar || p.broadcast {
+		width = form.laneBytes
+	}
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 1, 1,
+		decodedX86RawScaledRoundInstruction, "EVEX scaled round",
+	)
+}
+
+// decodeX86RawEVEXUnpackRIPData preserves source-local full-vector and
+// broadcast-lane constants for all eight EVEX integer interleave rows.
+func decodeX86RawEVEXUnpackRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	form, recognized := x86RawEVEXUnpackForms[p.opcode]
+	if !matched || !p.evex || p.mapNumber != 1 || p.pp != 1 || !recognized ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = form.broadcastBytes
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86EVEXPackedUnpackInstruction, "EVEX packed unpack",
+	)
+}
+
+// decodeX86RawBlockBroadcastRIPData resolves source-local m64/m128/m256
+// blocks for all Go EVEX packed-block broadcasts.
+func decodeX86RawBlockBroadcastRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawBlockBroadcastForms[[2]int{p.opcode, w}]
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 || !recognized ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, form.sourceBytes,
+		decodedX86RawBlockBroadcastInstruction, "EVEX block broadcast",
+	)
+}
+
+// decodeX86RawVariableRotateRIPData preserves local vector or scalar
+// constant pools for all four EVEX per-lane variable-rotate forms.
+func decodeX86RawVariableRotateRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		(p.opcode != 0x14 && p.opcode != 0x15) ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 4
+		if p.w {
+			width = 8
+		}
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86RawVariableRotateInstruction, "EVEX variable rotate",
+	)
+}
+
+// decodeX86RawQQToFloatRIPData resolves source-local literal pools for all
+// QWORD-to-PS/PD encodings before the raw-byte decoder treats them as memory.
+func decodeX86RawQQToFloatRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, matched := decodeX86RawVectorEncoding(code[offset:])
+	_, _, recognized := x86RawQQToFloatForm(p)
+	if !matched || !p.evex || !p.w || p.mapNumber != 1 || !recognized ||
+		p.segment != "" || p.addressOverride || p.vectorLength > 2 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + p.modRM
+	if len(code) <= modRMIndex || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 16 << p.vectorLength
+	if p.broadcast {
+		width = 8
+	}
+	return x86RawRIPDataThroughDecoder(
+		code, offset, mode, modRMIndex, width,
+		decodedX86RawQQToFloatInstruction, "QWORD-to-float conversion",
+	)
+}
+
+func x86RawRIPDataThroughDecoder(
+	code []byte, offset, mode, modRMIndex, width int,
+	decode x86RawInstructionDecoder, family string,
+) (Instr, int, x86RawLiteralRange, bool, error) {
+	return x86RawRIPDataThroughDecoderOperand(
+		code, offset, mode, modRMIndex, width, 0, 0, decode, family,
+	)
+}
+
+func x86RawRIPDataThroughDecoderOperand(
+	code []byte, offset, mode, modRMIndex, width, trailingBytes, sourceIndex int,
+	decode x86RawInstructionDecoder, family string,
+) (Instr, int, x86RawLiteralRange, bool, error) {
+	patched, data, literal, err := x86RawRIPBytesWithSuffix(code, offset, modRMIndex, width, trailingBytes)
+	if err != nil {
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	instruction, consumed, ok, err := decode(patched, mode)
+	if err != nil || !ok || consumed != len(patched) ||
+		len(instruction.Args) <= sourceIndex || instruction.Args[sourceIndex].Kind != OpMem {
+		if err == nil {
+			err = fmt.Errorf("RIP-relative %s did not match its grammar", family)
+		}
+		return Instr{}, 0, x86RawLiteralRange{}, true, err
+	}
+	setX86RawRIPDataOperand(&instruction, sourceIndex, data)
+	return instruction, len(patched), literal, true, nil
+}
+
+func setX86RawRIPDataOperand(instruction *Instr, sourceIndex int, data []byte) {
+	instruction.Args[sourceIndex] = Operand{Kind: OpSym, Sym: "·__plan9asm_raw_literal_pending(SB)"}
+	instruction.x86Encoded = true
+	instruction.x86RIPLiteral = true
+	instruction.x86RIPLiteralData = data
+	args := append([]Operand(nil), instruction.Args...)
+	for index := range args {
+		args[index].RegList = append([]Reg(nil), args[index].RegList...)
+	}
+	instruction.x86RIPMemoryRead = x86RawStaticRead{
+		op: instruction.Op, source: sourceIndex, width: int64(len(data)),
+		symbol: instruction.Args[sourceIndex].Sym,
+		object: append([]byte(nil), data...),
+		args:   args,
+	}
+	rawArgs := make([]string, len(instruction.Args))
+	for index, operand := range instruction.Args {
+		rawArgs[index] = operand.String()
+	}
+	instruction.Raw = fmt.Sprintf("%s %s", instruction.Op, strings.Join(rawArgs, ", "))
+}
+
+func setX86RawRIPLiteral(instruction *Instr, value int64) {
+	instruction.Args[0] = Operand{Kind: OpImm, Imm: value}
+	instruction.x86Encoded = true
+	instruction.x86RIPLiteral = true
+	rawArgs := make([]string, len(instruction.Args))
+	for index, operand := range instruction.Args {
+		rawArgs[index] = operand.String()
+	}
+	instruction.Raw = fmt.Sprintf("%s %s", instruction.Op, strings.Join(rawArgs, ", "))
+}
diff --git a/amd64_raw_broadcast_literal_test.go b/amd64_raw_broadcast_literal_test.go
new file mode 100644
index 000000000..177854abd
--- /dev/null
+++ b/amd64_raw_broadcast_literal_test.go
@@ -0,0 +1,497 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawBroadcastLiteral(op Op, encoding string, vectorBits, mask int, zeroing bool) ([]byte, int64) {
+	opcode := map[Op]byte{
+		"VPBROADCASTB": 0x78,
+		"VPBROADCASTW": 0x79,
+		"VPBROADCASTD": 0x58,
+		"VPBROADCASTQ": 0x59,
+	}[op]
+	width := map[Op]int{
+		"VPBROADCASTB": 1,
+		"VPBROADCASTW": 2,
+		"VPBROADCASTD": 4,
+		"VPBROADCASTQ": 8,
+	}[op]
+	value := int64(0)
+	data := make([]byte, width)
+	for i := range data {
+		data[i] = byte(0x11 + i*0x22)
+		value |= int64(data[i]) << (8 * i)
+	}
+
+	var code []byte
+	if encoding == "VEX" {
+		p2 := byte(0x79)
+		if vectorBits == 256 {
+			p2 |= 0x04
+		}
+		code = []byte{0xc4, 0xe2, p2, opcode, 0x05, 1, 0, 0, 0}
+	} else {
+		p1 := byte(0x7d)
+		if op == "VPBROADCASTQ" {
+			p1 |= 0x80
+		}
+		lengthBits := map[int]byte{128: 0, 256: 1, 512: 2}[vectorBits]
+		p2 := lengthBits<<5 | 0x08 | byte(mask)
+		if zeroing {
+			p2 |= 0x80
+		}
+		code = []byte{0x62, 0xf2, p1, p2, opcode, 0x05, 1, 0, 0, 0}
+	}
+	code = append(code, 0xc3)
+	code = append(code, data...)
+	return code, value
+}
+
+func TestDecodeX86RawPackedBroadcastRIPLiteralCompleteFamily(t *testing.T) {
+	for _, op := range []Op{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+		for _, encoding := range []string{"VEX", "EVEX"} {
+			for _, vectorBits := range []int{128, 256, 512} {
+				if encoding == "VEX" && vectorBits == 512 {
+					continue
+				}
+				for _, masking := range []struct {
+					mask    int
+					zeroing bool
+				}{
+					{},
+					{mask: 3},
+					{mask: 7, zeroing: true},
+				} {
+					if encoding == "VEX" && masking.mask != 0 {
+						continue
+					}
+					name := fmt.Sprintf("%s/%s/%d/mask%d/zero%t", op, encoding, vectorBits, masking.mask, masking.zeroing)
+					t.Run(name, func(t *testing.T) {
+						code, value := x86RawBroadcastLiteral(op, encoding, vectorBits, masking.mask, masking.zeroing)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded) != 2 || decoded[0].Op != op && decoded[0].Op != op+".Z" ||
+							len(decoded[0].Args) < 2 || decoded[0].Args[0].Kind != OpImm ||
+							decoded[0].Args[0].Imm != value || !decoded[0].x86Encoded || decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want a literal %s and RET", code, decoded, op)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawPackedBroadcastRIPLiteralObjects(t *testing.T) {
+	var source strings.Builder
+	for index, op := range []Op{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+		name := fmt.Sprintf("literalBroadcast%d", index)
+		code, _ := x86RawBroadcastLiteral(op, "EVEX", 512, 3, false)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Literal data does not supply the original K3 or merge input.
+			// Initialized complete-family programs have their own public objects.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-broadcast-literal.ll", "raw-broadcast-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawPackedBroadcastRIPLiteralRejectsExecutableAndMissingData(t *testing.T) {
+	for _, displacement := range []byte{0xf7, 0xf6, 0x20} {
+		code, _ := x86RawBroadcastLiteral("VPBROADCASTD", "VEX", 256, 0, false)
+		code[5] = displacement
+		if displacement != 0x20 {
+			copy(code[6:9], []byte{0xff, 0xff, 0xff})
+		}
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid RIP literal", map[string]bool{}); err == nil {
+			t.Fatalf("accepted RIP literal displacement %#x", displacement)
+		}
+	}
+	code, _ := x86RawBroadcastLiteral("VPBROADCASTQ", "EVEX", 512, 0, false)
+	code[6] = 5 // Only the last four bytes remain; a QWORD read is truncated.
+	if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "truncated RIP literal", map[string]bool{}); err == nil {
+		t.Fatal("accepted truncated RIP-relative QWORD literal")
+	}
+
+	for _, prefix := range []byte{0x64, 0x65, 0x67} {
+		code, _ := x86RawBroadcastLiteral("VPBROADCASTD", "VEX", 256, 0, false)
+		code = append([]byte{prefix}, code...)
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "prefixed RIP literal", map[string]bool{}); err == nil {
+			t.Fatalf("folded a source with prefix %#x", prefix)
+		}
+	}
+}
+
+func TestDecodeX86RawPackedBroadcastRIPLiteralDoesNotChange386AbsoluteMemory(t *testing.T) {
+	code, _ := x86RawBroadcastLiteral("VPBROADCASTD", "VEX", 256, 0, false)
+	decoded, err := decodeX86RawDirectiveGroup(code, 32, 0, "386 absolute source", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) < 1 || decoded[0].Args[0].Kind != OpMem || decoded[0].x86RIPLiteral {
+		t.Fatalf("changed a 386 absolute memory operand into a literal: %#v", decoded)
+	}
+}
+
+func TestTranslateX86RawPackedBroadcastRIPLiteralRejectsAddressObservedText(t *testing.T) {
+	code, _ := x86RawBroadcastLiteral("VPBROADCASTD", "VEX", 256, 0, false)
+	var source strings.Builder
+	source.WriteString("TEXT address(SB),$0-0\n\tLEAQ raw+1(SB), AX\n\tRET\n")
+	source.WriteString("TEXT raw(SB),$0-0\n\tMOVQ AX, AX\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"address": {Name: "address", Ret: Void},
+			"raw":     {Name: "raw", Ret: Void},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "address-observed RIP-relative raw literal") {
+		t.Fatalf("address-observed raw TEXT was silently folded: %v", err)
+	}
+}
+
+func x86RawVMOVIntegerLiteral(encoding string, width int, alternateQ bool) ([]byte, int64) {
+	var code []byte
+	switch encoding {
+	case "VEX2":
+		if alternateQ {
+			code = []byte{0xc5, 0xfa, 0x7e, 0x05}
+		} else {
+			code = []byte{0xc5, 0xf9, 0x6e, 0x05}
+		}
+	case "VEX3":
+		p1 := byte(0x79)
+		if width == 8 {
+			p1 |= 0x80
+		}
+		opcode := byte(0x6e)
+		if alternateQ {
+			p1 = 0x7a
+			opcode = 0x7e
+		}
+		code = []byte{0xc4, 0xe1, p1, opcode, 0x05}
+	case "EVEX":
+		p1 := byte(0x7d)
+		if width == 8 {
+			p1 |= 0x80
+		}
+		opcode := byte(0x6e)
+		if alternateQ {
+			p1 = 0xfe
+			opcode = 0x7e
+		}
+		code = []byte{0x62, 0xf1, p1, 0x08, opcode, 0x05}
+	}
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	var value int64
+	for index := 0; index < width; index++ {
+		b := byte(0x13 + index*0x11)
+		code = append(code, b)
+		value |= int64(b) << (8 * index)
+	}
+	return code, value
+}
+
+func TestDecodeX86RawVMOVIntegerRIPLiteralCompleteLoadForms(t *testing.T) {
+	for _, test := range []struct {
+		encoding   string
+		width      int
+		alternateQ bool
+	}{
+		{"VEX2", 4, false},
+		{"VEX3", 4, false},
+		{"EVEX", 4, false},
+		{"VEX2", 8, true},
+		{"VEX3", 8, false},
+		{"VEX3", 8, true},
+		{"EVEX", 8, false},
+		{"EVEX", 8, true},
+	} {
+		name := fmt.Sprintf("%s/%d/alternate%t", test.encoding, test.width, test.alternateQ)
+		t.Run(name, func(t *testing.T) {
+			code, value := x86RawVMOVIntegerLiteral(test.encoding, test.width, test.alternateQ)
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			op := Op("VMOVD")
+			if test.width == 8 {
+				op = "VMOVQ"
+			}
+			if len(decoded) != 2 || decoded[0].Op != op || len(decoded[0].Args) != 2 ||
+				decoded[0].Args[0].Kind != OpImm || decoded[0].Args[0].Imm != value ||
+				!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+				t.Fatalf("decoded %x as %#v, want %s literal load and RET", code, decoded, op)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVMOVIntegerRIPLiteralObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, test := range []struct {
+		encoding   string
+		width      int
+		alternateQ bool
+	}{
+		{"VEX2", 4, false}, {"VEX3", 4, false}, {"EVEX", 4, false},
+		{"VEX2", 8, true}, {"VEX3", 8, false}, {"VEX3", 8, true},
+		{"EVEX", 8, false}, {"EVEX", 8, true},
+	} {
+		name := fmt.Sprintf("literalVMOV%d", index)
+		code, _ := x86RawVMOVIntegerLiteral(test.encoding, test.width, test.alternateQ)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-vmov-literal.ll", "raw-vmov-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawVMOVIntegerRIPLiteralRejectsUnsafeSources(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{name: "inside_instruction", edit: func(code []byte) []byte {
+			copy(code[5:9], []byte{0xfa, 0xff, 0xff, 0xff}) // Target the opcode.
+			return code
+		}},
+		{name: "missing_pool", edit: func(code []byte) []byte {
+			code[5] = 0x20
+			return code
+		}},
+		{name: "truncated_pool", edit: func(code []byte) []byte {
+			code[5] = 5 // Only the last four bytes remain.
+			return code
+		}},
+		{name: "segment_override", edit: func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		}},
+		{name: "address_override", edit: func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code, _ := x86RawVMOVIntegerLiteral("VEX3", 8, false)
+			code = test.edit(code)
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, test.name, map[string]bool{}); err == nil {
+				t.Fatalf("folded unsafe raw VMOVQ source: %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVMOVIntegerRIPLiteralRejectsAddressObservedText(t *testing.T) {
+	code, _ := x86RawVMOVIntegerLiteral("VEX3", 8, false)
+	var source strings.Builder
+	source.WriteString("TEXT address(SB),$0-0\n\tLEAQ raw+1(SB), AX\n\tRET\n")
+	source.WriteString("TEXT raw(SB),$0-0\n\tMOVQ AX, AX\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"address": {Name: "address", Ret: Void},
+			"raw":     {Name: "raw", Ret: Void},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "address-observed RIP-relative raw literal") {
+		t.Fatalf("address-observed raw TEXT was silently folded: %v", err)
+	}
+}
+
+func x86RawScalarFloatBroadcastLiteral(double, evex bool, vectorBits, mask int, zeroing bool) ([]byte, int64) {
+	opcode := byte(0x18)
+	width := 4
+	if double {
+		opcode = 0x19
+		width = 8
+	}
+	var code []byte
+	if evex {
+		p1 := byte(0x7d)
+		if double {
+			p1 |= 0x80
+		}
+		p2 := byte(map[int]int{128: 0, 256: 1, 512: 2}[vectorBits]<<5 | 0x08 | mask)
+		if zeroing {
+			p2 |= 0x80
+		}
+		code = []byte{0x62, 0xf2, p1, p2, opcode, 0x05}
+	} else {
+		p1 := byte(0x79)
+		if vectorBits == 256 {
+			p1 |= 0x04
+		}
+		code = []byte{0xc4, 0xe2, p1, opcode, 0x05}
+	}
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	var value int64
+	for index := 0; index < width; index++ {
+		b := byte(0x21 + index*0x13)
+		code = append(code, b)
+		value |= int64(b) << (8 * index)
+	}
+	return code, value
+}
+
+func TestDecodeX86RawScalarFloatBroadcastRIPLiteral(t *testing.T) {
+	for _, test := range []struct {
+		double, evex bool
+		vectorBits   int
+		mask         int
+		zeroing      bool
+	}{
+		{vectorBits: 128}, {vectorBits: 256}, {double: true, vectorBits: 256},
+		{evex: true, vectorBits: 128}, {evex: true, vectorBits: 256, mask: 3},
+		{evex: true, vectorBits: 512, mask: 7, zeroing: true},
+		{double: true, evex: true, vectorBits: 256},
+		{double: true, evex: true, vectorBits: 512, mask: 7, zeroing: true},
+	} {
+		name := fmt.Sprintf("double%t/evex%t/%d/mask%d/zero%t", test.double, test.evex, test.vectorBits, test.mask, test.zeroing)
+		t.Run(name, func(t *testing.T) {
+			code, value := x86RawScalarFloatBroadcastLiteral(test.double, test.evex, test.vectorBits, test.mask, test.zeroing)
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			op := Op("VBROADCASTSS")
+			if test.double {
+				op = "VBROADCASTSD"
+			}
+			if test.zeroing {
+				op += ".Z"
+			}
+			if len(decoded) != 2 || decoded[0].Op != op ||
+				decoded[0].Args[0].Kind != OpImm || decoded[0].Args[0].Imm != value ||
+				!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+				t.Fatalf("decoded %x as %#v, want scalar broadcast of literal", code, decoded)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawScalarFloatBroadcastRIPLiteralObjects(t *testing.T) {
+	var source strings.Builder
+	for index, test := range []struct {
+		double, evex bool
+		vectorBits   int
+		mask         int
+		zeroing      bool
+	}{
+		{vectorBits: 128}, {vectorBits: 256}, {double: true, vectorBits: 256},
+		{evex: true, vectorBits: 128}, {evex: true, vectorBits: 256, mask: 3},
+		{evex: true, vectorBits: 512, mask: 7, zeroing: true},
+		{double: true, evex: true, vectorBits: 256},
+		{double: true, evex: true, vectorBits: 512, mask: 7, zeroing: true},
+	} {
+		name := fmt.Sprintf("scalarFloatLiteral%d", index)
+		code, _ := x86RawScalarFloatBroadcastLiteral(test.double, test.evex, test.vectorBits, test.mask, test.zeroing)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Preserve all original masked/unmasked formats without inventing
+			// missing K or merge bytes in the complete source.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "scalar-float-literal.ll", "scalar-float-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawScalarFloatBroadcastRIPLiteralRejectsUnsafeSources(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{name: "instruction_overlap", edit: func(code []byte) []byte {
+			copy(code[6:10], []byte{0xfa, 0xff, 0xff, 0xff})
+			return code
+		}},
+		{name: "outside_group", edit: func(code []byte) []byte {
+			code[6] = 0x20
+			return code
+		}},
+		{name: "segment_override", edit: func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		}},
+		{name: "address_override", edit: func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code, _ := x86RawScalarFloatBroadcastLiteral(true, true, 512, 0, false)
+			code = test.edit(code)
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, test.name, map[string]bool{}); err == nil {
+				t.Fatalf("folded unsafe scalar broadcast source: %x", code)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_byte_shift.go b/amd64_raw_byte_shift.go
new file mode 100644
index 000000000..31bd4db48
--- /dev/null
+++ b/amd64_raw_byte_shift.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RawVectorByteShiftInstruction covers Go's VPSLLDQ/VPSRLDQ
+// _yvpslldq table: VEX X/Y register forms and EVEX X/Y/Z register or memory
+// forms, all with an imm8. ModRM.reg is the opcode extension (/7 or /3),
+// while VEX.vvvv or EVEX.vvvvv names the destination.
+func decodedX86RawVectorByteShiftInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86RawVectorByteShiftInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86RawVectorByteShiftInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || p.pp != 1 || p.opcode != 0x73 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) <= p.modRM {
+		return Instr{}, 0, true, fmt.Errorf("vector byte shift: missing ModRM byte")
+	}
+	group := int(code[p.modRM]>>3) & 7
+	if group != 3 && group != 7 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("vector byte shift: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride || p.r != 0 || p.vectorLength > 2 ||
+		p.evex && !p.fixed || p.mask != 0 || p.zero || p.broadcast {
+		return fail("invalid prefix, mask or vector length")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	if !p.evex && !registerSource {
+		return fail("VEX byte shift requires a register source")
+	}
+	if mode == 32 && (p.upper >= 8 || registerSource && (p.b != 0 || p.x != 0)) {
+		return fail("extended vector register in 32-bit mode")
+	}
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, width, 16<<p.vectorLength)
+	} else {
+		source, consumed, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := p.modRM + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	op := Op("VPSRLDQ")
+	if group == 7 {
+		op = "VPSLLDQ"
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	args := []Operand{{Kind: OpImm, Imm: int64(code[immIndex])}, source, destination}
+	encoding := x86RawPackedShiftVEX
+	if p.evex {
+		encoding = x86RawPackedShiftEVEX
+	}
+	return Instr{
+		Op: op, Args: args, x86Encoded: true,
+		Raw:                    fmt.Sprintf("%s %s, %s, %s", op, args[0].String(), source.String(), destination.String()),
+		x86PackedShiftEncoding: encoding,
+		x86PackedShiftW:        p.w,
+	}, immIndex + 1, true, nil
+}
diff --git a/amd64_raw_byte_shift_test.go b/amd64_raw_byte_shift_test.go
new file mode 100644
index 000000000..f576cf1ca
--- /dev/null
+++ b/amd64_raw_byte_shift_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVectorByteShift(left, evex bool, width, source, destination int, imm byte) []byte {
+	extension := 3
+	if left {
+		extension = 7
+	}
+	vectorBits := map[int]int{16: 0, 32: 1, 64: 2}[width]
+	var code []byte
+	if evex {
+		code = encodeX86EVEXPackedWordMultiply(1, 0x73, vectorBits, 0, false, false, extension, destination, source)
+	} else {
+		code = encodeX86VEXPackedWordMultiply(1, 0x73, width == 32, false, extension, destination, source)
+	}
+	code[len(code)-1] = byte(0xc0 | extension<<3 | source&7)
+	return append(code, imm)
+}
+
+func TestDecodedX86RawVectorByteShiftCompleteFamily(t *testing.T) {
+	for _, left := range []bool{false, true} {
+		for _, evex := range []bool{false, true} {
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				registers := []int{0, 7, 8, 15}
+				if evex {
+					registers = append(registers, 16, 31)
+				}
+				for _, register := range registers {
+					name := fmt.Sprintf("left%t/evex%t/%d/reg%d", left, evex, width, register)
+					t.Run(name, func(t *testing.T) {
+						code := encodeX86RawVectorByteShift(left, evex, width, register, register, 15)
+						got, length, matched, err := decodedX86RawVectorByteShiftInstruction(code, 64)
+						want := Op("VPSRLDQ")
+						if left {
+							want = "VPSLLDQ"
+						}
+						widthName := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+						if err != nil || !matched || length != len(code) || got.Op != want ||
+							len(got.Args) != 3 || got.Args[0].Imm != 15 ||
+							got.Args[1].String() != fmt.Sprintf("%s%d", widthName, register) ||
+							got.Args[2].String() != fmt.Sprintf("%s%d", widthName, register) {
+							t.Fatalf("decode %x = %+v length=%d matched=%t err=%v", code, got, length, matched, err)
+						}
+					})
+				}
+			}
+		}
+	}
+	// Real bytes from simd@v1.21.1 reduce_avx2_amd64.s.
+	real := []byte{0xc5, 0xf9, 0x73, 0xf8, 0x0f}
+	got, length, matched, err := decodedX86RawVectorByteShiftInstruction(real, 64)
+	if err != nil || !matched || length != len(real) || got.Op != "VPSLLDQ" ||
+		got.Args[1].String() != "X0" || got.Args[2].String() != "X0" {
+		t.Fatalf("decode real VPSLLDQ %x = %+v length=%d matched=%t err=%v", real, got, length, matched, err)
+	}
+}
+
+func TestDecodedX86RawVectorByteShiftRejectsInvalidForms(t *testing.T) {
+	valid := encodeX86RawVectorByteShift(true, false, 16, 0, 0, 15)
+	for name, edit := range map[string]func([]byte) []byte{
+		"wrong pp":         func(b []byte) []byte { b[2] = b[2]&^3 | 2; return b },
+		"truncated imm8":   func(b []byte) []byte { return b[:len(b)-1] },
+		"address override": func(b []byte) []byte { return append([]byte{0x67}, b...) },
+		"wrong group":      func(b []byte) []byte { b[len(b)-2] &^= 0x38; return b },
+	} {
+		t.Run(name, func(t *testing.T) {
+			bad := edit(append([]byte(nil), valid...))
+			if _, _, matched, err := decodedX86RawVectorByteShiftInstruction(bad, 64); matched && err == nil {
+				t.Fatalf("accepted invalid byte shift %x", bad)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVectorByteShiftObjects(t *testing.T) {
+	var source strings.Builder
+	for index, code := range [][]byte{
+		encodeX86RawVectorByteShift(true, false, 16, 0, 0, 15),
+		encodeX86RawVectorByteShift(false, false, 32, 7, 7, 3),
+		encodeX86RawVectorByteShift(true, true, 64, 17, 19, 255),
+	} {
+		name := fmt.Sprintf("rawByteShift%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range append(code, 0xc3) {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-byte-shift.ll", "raw-byte-shift.o", ir)
+		})
+	}
+}
+
+func x86RawVectorByteShiftConstant(left bool, width int) []byte {
+	code := encodeX86RawVectorByteShift(left, true, width, 0, 0, 15)
+	code[len(code)-2] = code[len(code)-2]&0x38 | 0x05
+	imm := code[len(code)-1]
+	code = append(code[:len(code)-1], 1, 0, 0, 0, imm, 0xc3)
+	for i := 0; i < width; i++ {
+		code = append(code, byte(i*19+9))
+	}
+	return code
+}
+
+func TestDecodeX86RawVectorByteShiftConstantCompleteFamily(t *testing.T) {
+	for _, left := range []bool{false, true} {
+		for _, width := range []int{16, 32, 64} {
+			name := fmt.Sprintf("left%t/%d", left, width)
+			t.Run(name, func(t *testing.T) {
+				code := x86RawVectorByteShiftConstant(left, width)
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || got[0].Args[1].Kind != OpSym || !got[0].x86RIPLiteral || got[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want source-local byte-shift data", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawVectorByteShiftConstantRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVectorByteShiftConstant(true, 64)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe byte-shift RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVectorByteShiftConstantObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, width := range []int{16, 32, 64} {
+		code := x86RawVectorByteShiftConstant(index%2 == 0, width)
+		name := fmt.Sprintf("rawByteShiftConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-byte-shift-constant.ll", "raw-byte-shift-constant.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_bzhi.go b/amd64_raw_bzhi.go
new file mode 100644
index 000000000..330f28dba
--- /dev/null
+++ b/amd64_raw_bzhi.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RawBZHIInstruction follows Go's two _ybextrl rows, BZHIL/Q.
+// Both use VEX.128.0F38.W{0,1} F5 /r with a register index, register or
+// memory source, and register destination. In 32-bit mode W is ignored.
+func decodedX86RawBZHIInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86RawBZHIInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86RawBZHIInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	return decodedX86ScalarBitFieldInstructionWithMemory(code, mode, memory, 0xf5, "BZHI")
+}
+
+// BEXTR has the same complete VEX/ModRM/SIB field grammar as BZHI, not
+// its numerical control or FLAGS. Only the physical boundary consumer uses
+// this entry; ordinary source decoding keeps its existing x86asm contract.
+func decodedX86BEXTRInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	return decodedX86ScalarBitFieldInstructionWithMemory(code, mode, memory, 0xf7, "BEXTR")
+}
+
+func decodedX86ScalarBitFieldInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder, opcode int, stem string) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.opcode != opcode || p.pp != 0 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("%s: %s", stem, message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.vectorLength != 0 {
+		return fail("requires VEX.L0 encoding")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+	op := Op(stem + "L")
+	if p.w && mode == 64 {
+		op = Op(stem + "Q")
+	}
+	source, size, err := memory.scalar(code[p.modRM:], mode, p.b, p.x, p.segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	index, _ := decodedX86GeneralRegister(p.upper)
+	destination, _ := decodedX86GeneralRegister(int(code[p.modRM]>>3&7) + p.r*8)
+	return Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: index}, source, {Kind: OpReg, Reg: destination},
+		},
+		Raw: fmt.Sprintf("%s %s, %s, %s", op, index, source.String(), destination),
+	}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_bzhi_test.go b/amd64_raw_bzhi_test.go
new file mode 100644
index 000000000..87c9eeb86
--- /dev/null
+++ b/amd64_raw_bzhi_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func encodeX86RawBZHI(wide bool, source, index, destination int) []byte {
+	code := encodeRawScalarMove(false, 0, 0xf5, source, index, destination, 0, false)
+	code[1] = code[1]&0xe0 | 2
+	if wide {
+		code[2] |= 0x80
+	}
+	return code
+}
+
+func TestDecodedX86RawBZHICompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, wide := range []bool{false, true} {
+		for source := 0; source < 16; source++ {
+			for index := 0; index < 16; index++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86RawBZHI(wide, source, index, destination)
+					got, length, ok, err := decodedX86RawBZHIInstruction(code, 64)
+					wantOp := Op("BZHIL")
+					if wide {
+						wantOp = "BZHIQ"
+					}
+					sr, _ := decodedX86GeneralRegister(source)
+					ir, _ := decodedX86GeneralRegister(index)
+					dr, _ := decodedX86GeneralRegister(destination)
+					want := []Operand{
+						{Kind: OpReg, Reg: ir},
+						{Kind: OpReg, Reg: sr},
+						{Kind: OpReg, Reg: dr},
+					}
+					if err != nil || !ok || length != len(code) || got.Op != wantOp || !reflect.DeepEqual(got.Args, want) {
+						t.Fatalf("decode %x = %+v length=%d ok=%t err=%v, want %s %+v", code, got, length, ok, err, wantOp, want)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d BZHI register forms, want 8192", count)
+	}
+}
+
+func TestDecodedX86RawBZHIRealMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0xc4, 0x62, 0xf0, 0xf5, 0x04, 0xc6}
+	got, length, ok, err := decodedX86RawBZHIInstruction(code, 64)
+	if err != nil || !ok || length != len(code) || got.Op != "BZHIQ" ||
+		len(got.Args) != 3 || got.Args[0].String() != "CX" ||
+		got.Args[1].String() != "0(SI)(AX*8)" || got.Args[2].String() != "R8" {
+		t.Fatalf("decode real simd BZHI %x = %+v length=%d ok=%t err=%v", code, got, length, ok, err)
+	}
+	for name, edit := range map[string]func([]byte) []byte{
+		"L1":               func(b []byte) []byte { b[2] |= 4; return b },
+		"address override": func(b []byte) []byte { return append([]byte{0x67}, b...) },
+		"truncated ModRM":  func(b []byte) []byte { return b[:4] },
+	} {
+		t.Run(name, func(t *testing.T) {
+			bad := edit(append([]byte(nil), code...))
+			if _, _, matched, err := decodedX86RawBZHIInstruction(bad, 64); !matched || err == nil {
+				t.Fatalf("accepted invalid BZHI %x, matched=%t err=%v", bad, matched, err)
+			}
+		})
+	}
+	badPP := append([]byte(nil), code...)
+	badPP[2] |= 1
+	if _, _, matched, _ := decodedX86RawBZHIInstruction(badPP, 64); matched {
+		t.Fatalf("accepted non-BZHI pp encoding %x", badPP)
+	}
+}
+
+func TestTranslateX86RawBZHIRealMemoryObjects(t *testing.T) {
+	code := []byte{0xc4, 0x62, 0xf0, 0xf5, 0x04, 0xc6, 0xc3}
+	file := x86RawUnprovedReturnFormProbeFile(t, "amd64", "rawBZHI", code)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// The original physical memory/index inputs are not initialized.
+			// Keep Go objects and public Context separately from emitter objects.
+			ir := x86UnboundVoidRawProbeObject(t, file, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-bzhi.ll", "raw-bzhi.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_clmul.go b/amd64_raw_clmul.go
new file mode 100644
index 000000000..b2c9e15a2
--- /dev/null
+++ b/amd64_raw_clmul.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RawCLMULInstruction covers Go's complete PCLMULQDQ and
+// VPCLMULQDQ tables: legacy X, VEX X/Y, and EVEX X/Y/Z, each with imm8.
+// The vector ISA has no mask or broadcast, but W is ignored. Go selects W0
+// and limits its named four-operand frontend to amd64; neither restriction
+// invalidates original low-bank WIG bytes in physical 32-bit mode.
+func decodedX86RawCLMULInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if matched && p.mapNumber == 3 && p.pp == 1 && p.opcode == 0x44 {
+		return decodedX86RawVectorCLMULInstruction(code, mode, p)
+	}
+	return decodedX86RawLegacyCLMULInstruction(code, mode)
+}
+
+func decodedX86RawVectorCLMULInstruction(code []byte, mode int, p x86RawVectorEncoding) (Instr, int, bool, error) {
+	return decodedX86RawVectorCLMULInstructionWithMemory(code, mode, p, x86RawMemoryDecoder{})
+}
+
+func decodedX86RawVectorCLMULInstructionWithMemory(code []byte, mode int, p x86RawVectorEncoding, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VPCLMULQDQ: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride || p.vectorLength > 2 ||
+		p.evex && (!p.fixed || p.mask != 0 || p.zero || p.broadcast) {
+		return fail("invalid prefix, mask, broadcast or vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	if mode == 32 && (p.r != 0 || p.upper >= 8 || p.b != 0 || p.x != 0) {
+		return fail("extended register is unavailable in physical 32-bit mode")
+	}
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = memory.evex(
+			code[p.modRM:], mode, p.b, p.x, p.segment, width, 16<<p.vectorLength,
+		)
+	} else {
+		source, consumed, err = memory.vex(
+			code[p.modRM:], mode, p.b, p.x, p.segment, width,
+		)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := p.modRM + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, int(modRM>>3&7)+p.r*8))}
+	imm := Operand{Kind: OpImm, Imm: int64(code[immIndex])}
+	return Instr{
+		Op:         "VPCLMULQDQ",
+		Args:       []Operand{imm, source, second, destination},
+		Raw:        fmt.Sprintf("VPCLMULQDQ %s, %s, %s, %s", imm.String(), source.String(), second.String(), destination.String()),
+		x86Encoded: true,
+	}, immIndex + 1, true, nil
+}
+
+func decodedX86RawLegacyCLMULInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+		case 0x65:
+			segment = GS
+		case 0x67:
+			addressOverride = true
+		default:
+			goto encoding
+		}
+		i++
+	}
+
+encoding:
+	if len(code) <= i || code[i] != 0x66 {
+		return Instr{}, 0, false, nil
+	}
+	i++
+	rex := byte(0)
+	if i < len(code) && code[i]&0xf0 == 0x40 {
+		rex = code[i]
+		i++
+	}
+	if len(code) < i+3 || code[i] != 0x0f || code[i+1] != 0x3a || code[i+2] != 0x44 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("PCLMULQDQ: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if addressOverride || mode == 32 && rex != 0 {
+		return fail("address override or REX prefix is invalid")
+	}
+	modRMIndex := i + 3
+	if len(code) <= modRMIndex {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	destinationNumber := int(modRM>>3&7) + int(rex>>2&1)*8
+	if mode == 32 && destinationNumber >= 8 {
+		return fail("high X register is unavailable in 386 mode")
+	}
+	source, consumed, err := decodedX86VEXVectorRMOperand(
+		code[modRMIndex:], mode, int(rex&1), int(rex>>1&1), segment, "X",
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := modRMIndex + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	imm := Operand{Kind: OpImm, Imm: int64(code[immIndex])}
+	return Instr{
+		Op:         "PCLMULQDQ",
+		Args:       []Operand{imm, source, destination},
+		Raw:        fmt.Sprintf("PCLMULQDQ %s, %s, %s", imm.String(), source.String(), destination.String()),
+		x86Encoded: true,
+	}, immIndex + 1, true, nil
+}
diff --git a/amd64_raw_clmul_test.go b/amd64_raw_clmul_test.go
new file mode 100644
index 000000000..345bc95e2
--- /dev/null
+++ b/amd64_raw_clmul_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawCLMULCode(encoding string, width int, source, second, destination int, immediate byte) []byte {
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	switch encoding {
+	case "legacy":
+		code := []byte{0x66}
+		rex := byte(0x40 | (destination>>3&1)<<2 | source>>3&1)
+		if rex != 0x40 {
+			code = append(code, rex)
+		}
+		return append(code, 0x0f, 0x3a, 0x44, modRM, immediate)
+	case "vex":
+		p0 := byte((1-destination/8)<<7 | 1<<6 | (1-source/8)<<5 | 3)
+		p1 := byte(((^second)&15)<<3 | ((width-16)/16)<<2 | 1)
+		return []byte{0xc4, p0, p1, 0x44, modRM, immediate}
+	default:
+		p0 := byte((1-destination/8&1)<<7 | (1-source/16&1)<<6 |
+			(1-source/8&1)<<5 | (1-destination/16&1)<<4 | 3)
+		p1 := byte(((^second)&15)<<3 | 0x05)
+		p2 := byte(map[int]int{16: 0, 32: 1, 64: 2}[width]<<5 | (1-second/16)<<3)
+		return []byte{0x62, p0, p1, p2, 0x44, modRM, immediate}
+	}
+}
+
+func x86RawCLMULLiteral(encoding string, width int) []byte {
+	code := x86RawCLMULCode(encoding, width, 0, 1, 2, 0x11)
+	modRMIndex := len(code) - 2
+	code[modRMIndex] = 0x15 // RIP+disp32, destination X/Y/Z2.
+	code = append(code[:modRMIndex+1], append([]byte{1, 0, 0, 0}, code[modRMIndex+1:]...)...)
+	code = append(code, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*9+7))
+	}
+	return code
+}
+
+func TestDecodeX86RawCLMULCompleteRegisterFamily(t *testing.T) {
+	for _, encoding := range []string{"legacy", "vex", "evex"} {
+		widths := []int{16}
+		if encoding != "legacy" {
+			widths = append(widths, 32)
+		}
+		if encoding == "evex" {
+			widths = append(widths, 64)
+		}
+		for _, width := range widths {
+			limit := 16
+			if encoding == "evex" {
+				limit = 32
+			}
+			for _, source := range []int{0, 7, 8, limit - 1} {
+				for _, second := range []int{0, 7, limit - 1} {
+					if encoding == "legacy" && second != 0 {
+						continue
+					}
+					for _, destination := range []int{0, 7, limit - 1} {
+						name := fmt.Sprintf("%s/%d/%d/%d/%d", encoding, width, source, second, destination)
+						t.Run(name, func(t *testing.T) {
+							code := x86RawCLMULCode(encoding, width, source, second, destination, 0x11)
+							got, length, ok, err := decodedX86RawCLMULInstruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							prefix := "X"
+							if width == 32 {
+								prefix = "Y"
+							} else if width == 64 {
+								prefix = "Z"
+							}
+							want := fmt.Sprintf("VPCLMULQDQ $17, %s%d, %s%d, %s%d", prefix, source, prefix, second, prefix, destination)
+							if encoding == "legacy" {
+								want = fmt.Sprintf("PCLMULQDQ $17, X%d, X%d", source, destination)
+							}
+							if got.Raw != want {
+								t.Fatalf("decode %x = %q, want %q", code, got.Raw, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawCLMULChecksumAVX2Regression(t *testing.T) {
+	code := []byte{0xc4, 0xe3, 0x61, 0x44, 0xf4, 0x00, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "checksum crc32c AVX2", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Raw != "VPCLMULQDQ $0, X4, X3, X6 /* decoded from checksum crc32c AVX2 */" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawCLMULMemoryForms(t *testing.T) {
+	for _, encoding := range []string{"legacy", "vex", "evex"} {
+		code := x86RawCLMULCode(encoding, 16, 0, 1, 2, 0x11)
+		modRMIndex := len(code) - 2
+		code[modRMIndex] = 0x54 // disp8(SIB), destination X2.
+		code = append(code[:modRMIndex+1], append([]byte{0x88, 0x20}, code[modRMIndex+1:]...)...)
+		got, length, ok, err := decodedX86RawCLMULInstruction(code, 64)
+		wantOffset := int64(32)
+		if encoding == "evex" {
+			wantOffset = 512 // EVEX disp8 scales by the 128-bit memory operand.
+		}
+		if err != nil || !ok || length != len(code) || got.Args[1].Kind != OpMem ||
+			got.Args[1].Mem.Base != AX || got.Args[1].Mem.Index != CX ||
+			got.Args[1].Mem.Scale != 4 || got.Args[1].Mem.Off != wantOffset {
+			t.Fatalf("%s memory source %x decoded as %+v, length=%d, ok=%v, err=%v", encoding, code, got, length, ok, err)
+		}
+	}
+}
+
+func TestDecodeX86RawCLMULRIPDataCompleteFamily(t *testing.T) {
+	for _, encoding := range []string{"legacy", "vex", "evex"} {
+		widths := []int{16}
+		if encoding != "legacy" {
+			widths = append(widths, 32)
+		}
+		if encoding == "evex" {
+			widths = append(widths, 64)
+		}
+		for _, width := range widths {
+			name := fmt.Sprintf("%s/%d", encoding, width)
+			t.Run(name, func(t *testing.T) {
+				code := x86RawCLMULLiteral(encoding, width)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || decoded[0].Args[0].Imm != 0x11 ||
+					decoded[0].Args[1].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+					decoded[1].Op != OpRET ||
+					!bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-width:]) {
+					t.Fatalf("decoded CLMUL literal %x as %#v", code, decoded)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawCLMULRIPDataRejectsUnsafeSources(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source":        func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte { code[6] = 127; return code },
+		"overlapping instruction": func(code []byte) []byte { code[6] = 0; return code },
+		"segment override":        func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address override":        func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawCLMULLiteral("evex", 64))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe CLMUL literal %x", code)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawCLMULRejectsReservedForms(t *testing.T) {
+	valid := x86RawCLMULCode("evex", 64, 0, 1, 2, 0x11)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"mask":              func(code []byte) []byte { code[3] |= 1; return code },
+		"zeroing":           func(code []byte) []byte { code[3] |= 0x80; return code },
+		"broadcast":         func(code []byte) []byte { code[3] |= 0x10; return code },
+		"width":             func(code []byte) []byte { code[3] |= 0x60; return code },
+		"fixed bit":         func(code []byte) []byte { code[2] &^= 4; return code },
+		"address override":  func(code []byte) []byte { return append([]byte{0x67}, code...) },
+		"missing immediate": func(code []byte) []byte { return code[:len(code)-1] },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, _, ok, err := decodedX86RawCLMULInstruction(code, 64); !ok || err == nil {
+				t.Fatalf("accepted reserved CLMUL encoding %x: ok=%v err=%v", code, ok, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawCLMULObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, encoding := range []string{"legacy", "vex", "evex"} {
+		width := []int{16, 32, 64}[index]
+		name := fmt.Sprintf("rawCLMUL%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range x86RawCLMULCode(encoding, width, 0, 1, 2, 0x11) {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		source.WriteString("\tRET\n")
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-clmul.ll", "raw-clmul.o", ir)
+		})
+	}
+}
+
+func TestTranslateX86RawCLMULRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, encoding := range []string{"legacy", "vex", "evex"} {
+		width := []int{16, 32, 64}[index]
+		name := fmt.Sprintf("literalCLMUL%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range x86RawCLMULLiteral(encoding, width) {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-clmul-literal.ll", "raw-clmul-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_compare_float_test.go b/amd64_raw_compare_float_test.go
new file mode 100644
index 000000000..18ffcf829
--- /dev/null
+++ b/amd64_raw_compare_float_test.go
@@ -0,0 +1,373 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Go's yxcmpi table uses X/m, X, signed-imm8 for all four legacy
+// floating compares. Intel decoding instead returns destination, source,
+// unsigned predicate; a generic operand reversal is not the Go grammar.
+func TestX86RawLegacyFloatingCompareCompleteForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var named, raw strings.Builder
+			named.WriteString("TEXT compareforms(SB),4,$0-0\n")
+			raw.WriteString("TEXT compareforms(SB),4,$0-0\n")
+			var expected []byte
+			for _, family := range []struct {
+				op     string
+				prefix []byte
+			}{{"CMPPS", nil}, {"CMPPD", []byte{0x66}}, {"CMPSS", []byte{0xf3}}, {"CMPSD", []byte{0xf2}}} {
+				forms := []struct {
+					source, destination string
+					rex                 byte
+					address             []byte
+				}{{"X1", "X0", 0, []byte{0xc1}}, {"-7(BX)(CX*4)", "X7", 0, []byte{0x7c, 0x8b, 0xf9}}}
+				if arch == "amd64" {
+					forms = append(forms, struct {
+						source, destination string
+						rex                 byte
+						address             []byte
+					}{"X15", "X14", 0x45, []byte{0xf7}})
+				}
+				for _, form := range forms {
+					for predicate := 0; predicate < 256; predicate++ {
+						code := append([]byte(nil), family.prefix...)
+						if form.rex != 0 {
+							code = append(code, form.rex)
+						}
+						code = append(code, 0x0f, 0xc2)
+						code = append(code, form.address...)
+						code = append(code, byte(predicate))
+						instruction := fmt.Sprintf("%s %s, %s, $%d", family.op, form.source, form.destination, int8(predicate))
+						fmt.Fprintln(&named, instruction)
+						expected = append(expected, code...)
+						decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						want, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+instruction+"\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != want.Funcs[0].Instrs[1].Op || !reflect.DeepEqual(decoded.Instrs[0].Args, want.Funcs[0].Instrs[1].Args) {
+							t.Fatalf("decoded %x as %+v, want %s", code, decoded.Instrs, instruction)
+						}
+						// All encodings are checked against Go above; compiling the
+						// low predicates and signed boundary cases exercises every
+						// semantic selector without bloating every target's IR.
+						if predicate < 8 || predicate == 127 || predicate == 128 || predicate == 255 {
+							for _, b := range code {
+								fmt.Fprintf(&raw, "BYTE $%#02x\n", b)
+							}
+						}
+					}
+				}
+			}
+			named.WriteString("RET\n")
+			raw.WriteString("RET\n")
+			expected = append(expected, 0xc3)
+			if got := assembleX87ControlBytes(t, arch, named.String()); !bytes.HasPrefix(got, expected) {
+				t.Fatalf("Go %s compare encodings disagree: got %d bytes, want prefix of %d bytes", arch, len(got), len(expected))
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				ir := x86UnboundVoidRawScalarFormatObject(t, raw.String(), arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-compares.ll", "raw-compares.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawLegacyFloatingCompareRejectsMalformedPredicate(t *testing.T) {
+	for _, predicate := range []x86asm.Arg{nil, x86asm.X0, x86asm.Imm(-1), x86asm.Imm(256)} {
+		inst := x86asm.Inst{Op: x86asm.CMPPS, Mode: 64, Args: x86asm.Args{x86asm.X0, x86asm.X1, predicate}}
+		if _, err := decodedX86GoSyntax(inst, nil); err == nil {
+			t.Fatalf("accepted malformed decoded predicate %v", predicate)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawLegacyFloatingCompareRuntime(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, functions, originals, originalFunctions, goOpcodes strings.Builder
+	goOpcodes.WriteString("TEXT originalopcodes(SB),4,$0-0\n")
+	var expectedOpcodes []byte
+	sigs := make(map[string]FuncSig)
+	for family, prefix := range [][]byte{nil, {0x66}, {0xf3}, {0xf2}} {
+		for memory := 0; memory < 2; memory++ {
+			for predicate := 0; predicate < 256; predicate++ {
+				name := fmt.Sprintf("rawcmp_%d_%d_%d", family, memory, predicate)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ left+8(FP),AX\nMOVQ right+16(FP),BX\nMOVOU (AX),X0\nMOVOU (BX),X1\n", name)
+				code := append([]byte(nil), prefix...)
+				modrm := byte(0xc1)
+				if memory == 1 {
+					modrm = 0x03 // X0, (BX)
+				}
+				code = append(code, 0x0f, 0xc2, modrm, byte(predicate))
+				expectedOpcodes = append(expectedOpcodes, code...)
+				sourceOperand := "X1"
+				if memory == 1 {
+					sourceOperand = "(BX)"
+				}
+				opcode := [...]string{"CMPPS", "CMPPD", "CMPSS", "CMPSD"}[family]
+				fmt.Fprintf(&goOpcodes, "%s %s,X0,$%d\n", opcode, sourceOperand, int8(predicate))
+				for _, b := range code {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+				}
+				source.WriteString("MOVOU X0,(DI)\nRET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(void *,const void *,const void *);\n", name)
+				fmt.Fprintf(&functions, "%s,\n", name)
+				originals.WriteString(x86RawLegacyFloatingCompareOriginalKernel(name, code))
+				fmt.Fprintf(&originalFunctions, "original_%s,\n", name)
+			}
+		}
+	}
+	goOpcodes.WriteString("RET\n")
+	expectedOpcodes = append(expectedOpcodes, 0xc3)
+	if got := assembleX87ControlBytes(t, "amd64", goOpcodes.String()); !bytes.HasPrefix(got, expectedOpcodes) {
+		t.Fatalf("actual Go full imm8 register/(BX) opcode bytes differ: got=%d expected prefix=%d", len(got), len(expectedOpcodes))
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#ifndef _WIN32
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#endif
+` + declarations.String() + `
+typedef void (*comparison)(void *,const void *,const void *);
+static comparison functions[]={
+` + functions.String() + `};
+` + originals.String() + `
+static comparison originals[]={
+` + originalFunctions.String() + `};
+
+// Only predicates 0..7 have the legacy IEEE truth table below. Bits 3..7
+// are reserved: an observed machine result is not a mathematical definition.
+static int predicate(double a,double b,int p) {
+  int unordered=isnan(a)||isnan(b);
+  switch(p) {
+  case 0: return !unordered&&a==b;
+  case 1: return !unordered&&a<b;
+  case 2: return !unordered&&a<=b;
+  case 3: return unordered;
+  case 4: return unordered||a!=b;
+  case 5: return unordered||a>=b;
+  case 6: return unordered||a>b;
+  case 7: return !unordered;
+  default: return -1;
+  }
+}
+
+static unsigned observe(comparison fn,void *out,const void *left,const void *right) {
+  unsigned control=0x1f80,observed;
+  __asm__ volatile("ldmxcsr %0"::"m"(control):"memory");
+  fn(out,left,right);
+  __asm__ volatile("stmxcsr %0":"=m"(observed)::"memory");
+  return observed;
+}
+
+#ifndef _WIN32
+// Preserve the original packed memory opcode's unaligned behavior. The
+// outcome is an observation of this execution environment, not a new policy.
+static int same_unaligned_outcome(comparison actual,comparison original) {
+  int statuses[2];
+  for(int which=0;which<2;which++) {
+    pid_t child=fork();
+    if(child<0) return 1;
+    if(child==0) {
+      struct rlimit no_core={0,0};
+      if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+      _Alignas(16) unsigned char left[32]={0},right[32]={0},out[16];
+      observe(which?original:actual,out,left,right+1);
+      _exit(0);
+    }
+    if(waitpid(child,&statuses[which],0)!=child) return 1;
+    if(WIFEXITED(statuses[which])) {
+      if(WEXITSTATUS(statuses[which])!=0) return 1;
+    } else if(!WIFSIGNALED(statuses[which]) ||
+              (WTERMSIG(statuses[which])!=SIGSEGV && WTERMSIG(statuses[which])!=SIGBUS)) {
+      return 1;
+    }
+  }
+  if(WIFSIGNALED(statuses[0])!=WIFSIGNALED(statuses[1]) ||
+     (WIFSIGNALED(statuses[1]) && WTERMSIG(statuses[0])!=WTERMSIG(statuses[1]))) {
+    fprintf(stderr,"unaligned original opcode outcome differs actual=%x original=%x\n",statuses[0],statuses[1]);
+    return 1;
+  }
+  return 0;
+}
+#endif
+
+int main(void) {
+  uint32_t f[]={0,0x80000000u,0x3f800000u,0xbf800000u,0x7f800000u,0xff800000u,0x7fc12345u};
+  uint64_t d[]={0,0x8000000000000000ull,0x3ff0000000000000ull,0xbff0000000000000ull,0x7ff0000000000000ull,0xfff0000000000000ull,0x7ff8123456789abcull};
+  for(int family=0;family<4;family++) {
+    for(int mem=0;mem<2;mem++) {
+      for(int p=0;p<256;p++) {
+        for(int a=0;a<7;a++) {
+          for(int b=0;b<7;b++) {
+            _Alignas(16) unsigned char left_storage[64],right_storage[64];
+            unsigned char actual_storage[48],original_storage[48],expected[16];
+            unsigned char left_before[64],right_before[64];
+            memset(left_storage,0xa7,sizeof(left_storage));
+            memset(right_storage,0xb9,sizeof(right_storage));
+            memset(actual_storage,0xc3,sizeof(actual_storage));
+            memset(original_storage,0xd5,sizeof(original_storage));
+            unsigned char *left=left_storage+16;
+            // Packed memory remains aligned; scalar memory additionally
+            // exercises a real unaligned address without inventing a shadow.
+            unsigned char *right=right_storage+16+(family>=2 && mem?3:0);
+            unsigned char *got=actual_storage+16,*observed=original_storage+16;
+            int bytes=family&1?8:4,lanes=16/bytes;
+            for(int lane=0;lane<lanes;lane++) {
+              int ai=(a+lane)%7,bi=(b+lane)%7;
+              if(bytes==8) {
+                memcpy(left+lane*bytes,&d[ai],8);
+                memcpy(right+lane*bytes,&d[bi],8);
+              } else {
+                memcpy(left+lane*bytes,&f[ai],4);
+                memcpy(right+lane*bytes,&f[bi],4);
+              }
+            }
+            memcpy(left_before,left_storage,sizeof(left_storage));
+            memcpy(right_before,right_storage,sizeof(right_storage));
+            int index=(family*2+mem)*256+p;
+            unsigned original_csr=observe(originals[index],observed,left,right);
+            unsigned actual_csr=observe(functions[index],got,left,right);
+            if(memcmp(got,observed,16) || actual_csr!=original_csr) {
+              fprintf(stderr,"original opcode mismatch family=%d mem=%d imm8=%d a=%d b=%d CSR=%x/%x\n",
+                      family,mem,p,a,b,actual_csr,original_csr);
+              return 1;
+            }
+            if(memcmp(left_storage,left_before,sizeof(left_storage)) ||
+               memcmp(right_storage,right_before,sizeof(right_storage))) return 2;
+            for(int byte=0;byte<16;byte++) {
+              if(actual_storage[byte]!=0xc3 || actual_storage[32+byte]!=0xc3 ||
+                 original_storage[byte]!=0xd5 || original_storage[32+byte]!=0xd5) return 3;
+            }
+            if(p<8) {
+              memcpy(expected,left,16);
+              for(int lane=0;lane<(family>=2?1:lanes);lane++) {
+                double x,y;
+                if(bytes==8) {
+                  memcpy(&x,left+lane*bytes,8);
+                  memcpy(&y,right+lane*bytes,8);
+                } else {
+                  float xf,yf;
+                  memcpy(&xf,left+lane*bytes,4);
+                  memcpy(&yf,right+lane*bytes,4);
+                  x=xf;
+                  y=yf;
+                }
+                memset(expected+lane*bytes,predicate(x,y,p)?255:0,bytes);
+              }
+              if(memcmp(got,expected,16)) {
+                fprintf(stderr,"independent IEEE mismatch family=%d mem=%d predicate=%d a=%d b=%d\n",family,mem,p,a,b);
+                return 4;
+              }
+            }
+          }
+        }
+      }
+#ifndef _WIN32
+      if(mem && family<2) {
+        const int predicates[]={0,8,255};
+        for(int axis=0;axis<3;axis++) {
+          int p=predicates[axis];
+          int index=(family*2+mem)*256+p;
+          if(same_unaligned_outcome(functions[index],originals[index])) return 5;
+        }
+      }
+#endif
+    }
+  }
+  return 0;
+}
+`
+	execution.compileAndRunLLVM(t, "raw_compare_float", ir, mainC, "-O2")
+	t.Logf("2048 exact original imm8 opcodes ×49 inputs: full X bytes, canaries and MXCSR agree; only 0..7 have independent IEEE truth; transport=%v", execution.prefix)
+}
+
+func x86RawLegacyFloatingCompareOriginalKernel(name string, code []byte) string {
+	var directive strings.Builder
+	for index, b := range code {
+		if index != 0 {
+			directive.WriteByte(',')
+		}
+		fmt.Fprintf(&directive, "0x%02x", b)
+	}
+	return fmt.Sprintf(`
+static __attribute__((noinline)) void original_%s(void *out,const void *left,const void *right) {
+  __asm__ volatile(
+      "movdqu (%%1),%%%%xmm0\n\t"
+      "movdqu (%%%%rbx),%%%%xmm1\n\t"
+      ".byte %s\n\t"
+      "movdqu %%%%xmm0,(%%0)"
+      ::"r"(out),"r"(left),"b"(right)
+      :"xmm0","xmm1","memory");
+}
+`, name, directive.String())
+}
+
+func TestX86RawLegacyFloatingCompareOriginalKernelRetainsReservedBytes(t *testing.T) {
+	for _, prefix := range [][]byte{nil, {0x66}, {0xf3}, {0xf2}} {
+		for _, modrm := range []byte{0xc1, 0x03} {
+			for predicate := 0; predicate < 256; predicate++ {
+				code := append([]byte(nil), prefix...)
+				code = append(code, 0x0f, 0xc2, modrm, byte(predicate))
+				kernel := x86RawLegacyFloatingCompareOriginalKernel("byte_identity", code)
+				var exact strings.Builder
+				for index, b := range code {
+					if index != 0 {
+						exact.WriteByte(',')
+					}
+					fmt.Fprintf(&exact, "0x%02x", b)
+				}
+				if strings.Count(kernel, ".byte ") != 1 || !strings.Contains(kernel, ".byte "+exact.String()+`\n\t`) {
+					t.Fatalf("original kernel altered source bytes %x:\n%s", code, kernel)
+				}
+				for _, required := range []string{`movdqu (%1),%%xmm0`, `movdqu (%%rbx),%%xmm1`, `movdqu %%xmm0,(%0)`, `"b"(right)`, `"memory"`} {
+					if !strings.Contains(kernel, required) {
+						t.Fatalf("original register/memory/output binding lost %q: %x", required, code)
+					}
+				}
+				if predicate >= 8 {
+					folded := append([]byte(nil), code...)
+					folded[len(folded)-1] &= 7
+					if x86RawLegacyFloatingCompareOriginalKernel("byte_identity", folded) == kernel {
+						t.Fatalf("reserved imm8 %d folded to a mathematical predicate", predicate)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_raw_compare_float_transport_test.go b/amd64_raw_compare_float_transport_test.go
new file mode 100644
index 000000000..8adba7148
--- /dev/null
+++ b/amd64_raw_compare_float_transport_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+func TestX86RawLegacyFloatingCompareRuntimeRequiresOwnedGuestTransport(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_raw_compare_float_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const required = "TestCrossLinuxRuntimeMatrixX86RawLegacyFloatingCompareRuntime"
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == required {
+			body = function.Body
+		}
+	}
+	if body == nil {
+		t.Fatal("raw compare runtime is not registered in the required cross-runtime matrix")
+	}
+
+	tools, consumer := 0, 0
+	ast.Inspect(body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if function, ok := call.Fun.(*ast.Ident); ok && function.Name == "x86FloatCompareExecutionTools" {
+			tools++
+		}
+		if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+			if method.Sel.Name == "Skip" || method.Sel.Name == "Skipf" || method.Sel.Name == "SkipNow" {
+				t.Fatal("required raw compare execution cannot substitute a host skip for its guest counterpart")
+			}
+			if receiver, ok := method.X.(*ast.Ident); ok && receiver.Name == "execution" && method.Sel.Name == "compileAndRunLLVM" {
+				consumer++
+			}
+		}
+		return true
+	})
+	if tools != 1 || consumer != 1 {
+		t.Fatalf("required raw comparison must consume its authenticated tools and execution route exactly once: tools=%d consumer=%d", tools, consumer)
+	}
+}
diff --git a/amd64_raw_compress_test.go b/amd64_raw_compress_test.go
new file mode 100644
index 000000000..6c36aee59
--- /dev/null
+++ b/amd64_raw_compress_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawCompressForms = []struct {
+	opcode    int
+	widthBit  int
+	op        Op
+	laneBytes int
+}{
+	{0x63, 0, "VPCOMPRESSB", 1},
+	{0x63, 1, "VPCOMPRESSW", 2},
+	{0x8a, 0, "VCOMPRESSPS", 4},
+	{0x8a, 1, "VCOMPRESSPD", 8},
+	{0x8b, 0, "VPCOMPRESSD", 4},
+	{0x8b, 1, "VPCOMPRESSQ", 8},
+}
+
+func encodeX86RawCompress(opcode, widthBit, vectorBits, mask int, zeroing, memory bool) []byte {
+	p1 := byte(0x7d) // EVEX.vvvv is unused, pp = 66.
+	if widthBit != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xd3) // source register 2, destination register 3.
+	if memory {
+		modRM = 0x50 // source register 2, disp8(AX) destination.
+	}
+	code := []byte{0x62, 0xf2, p1, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawCompressSeBiShogunRegression(t *testing.T) {
+	// Go disassembles the bytes as VCOMPRESSPS Z0, K1, 0(SI)(R9*4).
+	code := []byte{0x62, 0xb2, 0x7d, 0x49, 0x8a, 0x04, 0x8e, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "compressBitsFloat32 AVX512 VCOMPRESSPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VCOMPRESSPS" ||
+		decoded[0].Args[0].Reg != "Z0" || decoded[0].Args[1].Reg != "K1" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawCompressCompleteGoForms(t *testing.T) {
+	if len(x86RawCompressForms) != len(amd64PackedCompressLaneBits) {
+		t.Fatalf("raw/lower compress grammar rows = %d/%d", len(x86RawCompressForms), len(amd64PackedCompressLaneBits))
+	}
+	for _, form := range x86RawCompressForms {
+		for vectorBits, vector := range []string{"X", "Y", "Z"} {
+			for _, variant := range []struct {
+				name    string
+				mask    int
+				zeroing bool
+				memory  bool
+			}{
+				{name: "register"},
+				{name: "masked register", mask: 3},
+				{name: "zeroing register", mask: 7, zeroing: true},
+				{name: "memory", memory: true},
+				{name: "masked memory", mask: 1, memory: true},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", form.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawCompress(form.opcode, form.widthBit, vectorBits, variant.mask, variant.zeroing, variant.memory)
+					got, length, ok, err := decodedX86PackedCompressInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := form.op
+					if variant.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[0].String() != vector+"2" ||
+						!variant.memory && got.Args[len(got.Args)-1].String() != vector+"3" ||
+						variant.memory && got.Args[len(got.Args)-1].String() != fmt.Sprintf("%d(AX)", form.laneBytes) ||
+						len(got.Args) != 2+map[bool]int{true: 1}[variant.mask != 0] {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawCompressRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawCompress(0x8a, 0, 2, 0, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x80 },  // zeroing without mask
+		func(code []byte) { code[3] |= 0x60 },  // reserved vector length
+		func(code []byte) { code[3] |= 0x10 },  // broadcast unavailable
+		func(code []byte) { code[2] &^= 0x08 }, // EVEX.vvvv is reserved
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86PackedCompressInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	badMode32 := encodeX86RawCompress(0x8a, 0, 2, 1, false, false)
+	badMode32[1] &^= 0x80 // The source field has no physical mode32 register.
+	if _, _, ok, err := decodedX86PackedCompressInstruction(badMode32, 32); !ok || err == nil {
+		t.Fatalf("accepted unbound mode32 source bank: ok=%v err=%v", ok, err)
+	}
+}
+
+func TestTranslateX86RawCompressLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawCompress(SB),$0-0\n")
+			for _, form := range x86RawCompressForms {
+				for _, memory := range []bool{false, true} {
+					mask := 1
+					if target.goarch == "386" {
+						mask = 0
+					}
+					code := encodeX86RawCompress(form.opcode, form.widthBit, 0, mask, false, memory)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			// Keep the complete original encoding program, not fictitious
+			// source/mask/address inputs. Initialized raw counterparts have
+			// separate complete X/Y/Z public-object matrices.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-compress.ll", "raw-compress.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_convert_half.go b/amd64_raw_convert_half.go
new file mode 100644
index 000000000..0baabf3c2
--- /dev/null
+++ b/amd64_raw_convert_half.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawHalfConversionForm struct {
+	op        Op
+	mapNumber int
+	opcode    int
+	immediate bool
+	rawOnly   bool
+}
+
+// The complete F16C/AVX-512 half/single conversion rows. The FP16 map5/map6
+// forms are raw-only in Go 1.27. Only legacy VCVTPS2PH reverses ModRM roles
+// and appends imm8; FP16 narrowing instead loads and supports broadcasts.
+var x86RawHalfConversionForms = [...]x86RawHalfConversionForm{
+	{op: "VCVTPH2PS", mapNumber: 2, opcode: 0x13},
+	{op: "VCVTPS2PH", mapNumber: 3, opcode: 0x1d, immediate: true},
+	{op: "VCVTPH2PSX", mapNumber: 6, opcode: 0x13, rawOnly: true},
+	{op: "VCVTPS2PHX", mapNumber: 5, opcode: 0x1d, rawOnly: true},
+}
+
+func decodedX86PackedHalfConversionInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var form x86RawHalfConversionForm
+	for _, candidate := range x86RawHalfConversionForms {
+		if p.mapNumber == candidate.mapNumber && p.opcode == candidate.opcode {
+			form = candidate
+			break
+		}
+	}
+	if form.op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed half conversion: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if form.rawOnly && !p.evex {
+		return fail("FP16 conversion requires EVEX")
+	}
+	if p.upper != 0 || p.w || p.evex && !p.fixed {
+		return fail("invalid reserved vvvv/V', W or EVEX fixed bit")
+	}
+	if p.evex && p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	vectorLength := p.vectorLength
+	op := form.op
+	if p.broadcast && form.rawOnly {
+		if registerSource {
+			vectorLength = 2
+			if form.op == "VCVTPS2PHX" {
+				op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+			} else {
+				// LLVM emits LL=00 for SAE-only; LL does not encode VL here.
+				op += ".SAE"
+			}
+		} else {
+			op += ".BCST"
+		}
+	}
+	if vectorLength > 2 {
+		return fail("reserved vector length")
+	}
+	if form.rawOnly && mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register or address in 32-bit mode")
+	}
+	if !p.evex && mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended VEX register in 32-bit mode")
+	}
+	if p.evex && mode == 32 && code[p.modRM]>>6 != 3 && (p.b != 0 || p.x != 0) {
+		return fail("extended memory address in 32-bit mode")
+	}
+	if p.broadcast && !form.rawOnly {
+		if !p.evex || p.vectorLength != 2 || form.op == "VCVTPH2PS" && code[p.modRM]>>6 != 3 {
+			return fail("SAE requires the EVEX Z-width register form")
+		}
+		op += ".SAE"
+	}
+
+	vector := [...]string{"X", "Y", "Z"}[vectorLength]
+	shorter := "X"
+	if vectorLength == 2 {
+		shorter = "Y"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	modRM := code[p.modRM]
+	regNumber := int(modRM>>3&7) + p.r*8
+	register := func(prefix string) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, regNumber))}
+	}
+	decodeRM := func(prefix string) (Operand, int, error) {
+		if p.evex {
+			width := 8 << vectorLength
+			if form.op == "VCVTPS2PHX" {
+				width *= 2
+			}
+			if form.rawOnly && p.broadcast && !registerSource {
+				width = amd64HalfConversionSpecs[string(form.op)].inputBits / 8
+			}
+			return decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, prefix, width)
+		}
+		return decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, prefix)
+	}
+
+	args := make([]Operand, 0, 4)
+	var consumed int
+	if !form.immediate {
+		sourcePrefix, destinationPrefix := shorter, vector
+		if form.op == "VCVTPS2PHX" {
+			sourcePrefix, destinationPrefix = vector, shorter
+		}
+		source, n, err := decodeRM(sourcePrefix)
+		if err != nil {
+			return Instr{}, 0, true, err
+		}
+		consumed = n
+		args = append(args, source)
+		if p.mask != 0 {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+		}
+		args = append(args, register(destinationPrefix))
+	} else {
+		destination, n, err := decodeRM(shorter)
+		if err != nil {
+			return Instr{}, 0, true, err
+		}
+		consumed = n
+		if len(code) <= p.modRM+consumed {
+			return fail("missing imm8 rounding control")
+		}
+		args = append(args, Operand{Kind: OpImm, Imm: int64(code[p.modRM+consumed])})
+		args = append(args, register(vector))
+		if p.mask != 0 {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+		}
+		args = append(args, destination)
+		consumed++
+	}
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	encoding := x86RawNamedHalfAbsent
+	if !form.rawOnly {
+		encoding = x86RawNamedHalfVEX
+		if p.evex {
+			encoding = x86RawNamedHalfEVEX
+		}
+	}
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86Encoded: form.rawOnly, x86VectorBytes: 16 << vectorLength, x86NamedHalfEncoding: encoding,
+	}, p.modRM + consumed, true, nil
+}
+
+func decodeX86RawFP16ConversionRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, ok := decodeX86RawVectorEncoding(code[offset:])
+	if !ok || !p.evex || p.pp != 1 || p.segment != "" || p.addressOverride ||
+		!(p.mapNumber == 6 && p.opcode == 0x13 || p.mapNumber == 5 && p.opcode == 0x1d) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRM := offset + p.modRM
+	if len(code) <= modRM || code[modRM]&0xc7 != 5 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := 8 << p.vectorLength
+	if p.broadcast {
+		width = 2
+	}
+	if p.mapNumber == 5 {
+		width *= 2
+	}
+	return x86RawRIPDataThroughDecoder(code, offset, mode, modRM, width, decodedX86PackedHalfConversionInstruction, "FP16 conversion")
+}
diff --git a/amd64_raw_convert_half_test.go b/amd64_raw_convert_half_test.go
new file mode 100644
index 000000000..9a331ea84
--- /dev/null
+++ b/amd64_raw_convert_half_test.go
@@ -0,0 +1,241 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVEXHalfConversion(form x86RawHalfConversionForm, width256 bool, reg, rm int, memory bool, immediate byte) []byte {
+	if memory {
+		rm = 0
+	}
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	p0 := byte((1-reg/8)<<7 | 1<<6 | (1-rm/8)<<5 | form.mapNumber)
+	p1 := byte(0x79 | l<<2)
+	modRM := byte(0xc0 | (reg&7)<<3 | rm&7)
+	if memory {
+		modRM = byte(0x40 | (reg&7)<<3)
+	}
+	code := []byte{0xc4, p0, p1, byte(form.opcode), modRM}
+	if memory {
+		code = append(code, 7)
+	}
+	if form.immediate {
+		code = append(code, immediate)
+	}
+	return code
+}
+
+func encodeX86RawEVEXHalfConversion(form x86RawHalfConversionForm, vectorBits, mask int, zeroing, sae bool, reg, rm int, memory bool, immediate byte) []byte {
+	if memory {
+		rm = 0
+	}
+	p0 := byte((1-reg/8&1)<<7 | (1-rm/16)<<6 | (1-rm/8&1)<<5 | (1-reg/16)<<4 | form.mapNumber)
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if sae {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | (reg&7)<<3 | rm&7)
+	if memory {
+		modRM = byte(0x40 | (reg&7)<<3)
+	}
+	code := []byte{0x62, p0, 0x7d, p2, byte(form.opcode), modRM}
+	if memory {
+		code = append(code, 7)
+	}
+	if form.immediate {
+		code = append(code, immediate)
+	}
+	return code
+}
+
+func TestTranslateRawHalfConversionGorseRegression(t *testing.T) {
+	const source = `TEXT rawHalfToSingle(SB), $0-0
+	LONG $0x137da2c4
+	WORD $0x474c
+	BYTE $0xf0
+	RET
+`
+	ir := x86NamedHalfOriginalFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original Gorse half format requires LLVM22")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "gorse-half-format.ll", "gorse-half-format.o", ir)
+}
+
+func TestDecodedX86PackedHalfConversionGorseEVEXMemory(t *testing.T) {
+	cases := []struct {
+		name string
+		code []byte
+		want MemRef
+	}{
+		{
+			name: "SIB",
+			code: []byte{0x62, 0xf2, 0x7d, 0x48, 0x13, 0x0c, 0x4f},
+			want: MemRef{Base: DI, Index: CX, Scale: 2},
+		},
+		{
+			name: "SIB compressed displacement",
+			code: []byte{0x62, 0xf2, 0x7d, 0x48, 0x13, 0x4c, 0x4f, 0x01},
+			want: MemRef{Base: DI, Index: CX, Scale: 2, Off: 32},
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, matched, err := decodedX86PackedHalfConversionInstruction(tc.code, 64)
+			if err != nil || !matched || length != len(tc.code) || got.Op != "VCVTPH2PS" {
+				t.Fatalf("decode %x = %+v length=%d matched=%v err=%v", tc.code, got, length, matched, err)
+			}
+			if len(got.Args) != 2 || got.Args[0].Kind != OpMem || got.Args[0].Mem != tc.want || got.Args[1].Reg != "Z1" {
+				t.Fatalf("decode %x = %+v, want memory %+v and Z1", tc.code, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86PackedHalfConversionGoRowsAndWidths(t *testing.T) {
+	if len(x86RawHalfConversionForms) != 4 ||
+		x86RawHalfConversionForms[0] != (x86RawHalfConversionForm{op: "VCVTPH2PS", mapNumber: 2, opcode: 0x13}) ||
+		x86RawHalfConversionForms[1] != (x86RawHalfConversionForm{op: "VCVTPS2PH", mapNumber: 3, opcode: 0x1d, immediate: true}) {
+		t.Fatalf("packed half conversion grammar does not match the two Go 1.27 opcode rows")
+	}
+	for _, form := range x86RawHalfConversionForms[:2] {
+		for _, width256 := range []bool{false, true} {
+			vector := "X"
+			if width256 {
+				vector = "Y"
+			}
+			for _, memory := range []bool{false, true} {
+				code := encodeX86RawVEXHalfConversion(form, width256, 2, 1, memory, 7)
+				got, length, matched, err := decodedX86PackedHalfConversionInstruction(code, 64)
+				if err != nil || !matched || length != len(code) || got.Op != form.op {
+					t.Fatalf("VEX %x = %+v length=%d matched=%v err=%v", code, got, length, matched, err)
+				}
+				if form.immediate {
+					if len(got.Args) != 3 || got.Args[0].String() != "$7" || got.Args[1].String() != vector+"2" {
+						t.Fatalf("VEX single-to-half %x = %+v", code, got)
+					}
+				} else if len(got.Args) != 2 || got.Args[1].String() != vector+"2" {
+					t.Fatalf("VEX half-to-single %x = %+v", code, got)
+				}
+			}
+		}
+		for vectorBits, vector := range []string{"X", "Y", "Z"} {
+			for _, memory := range []bool{false, true} {
+				for _, masked := range []bool{false, true} {
+					mask := 0
+					if masked {
+						mask = 3
+					}
+					code := encodeX86RawEVEXHalfConversion(form, vectorBits, mask, masked && !memory, false, 21, 20, memory, 9)
+					got, length, matched, err := decodedX86PackedHalfConversionInstruction(code, 64)
+					if err != nil || !matched || length != len(code) {
+						t.Fatalf("EVEX %x = %+v length=%d matched=%v err=%v", code, got, length, matched, err)
+					}
+					wantOp := form.op
+					if masked && !memory {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp {
+						t.Fatalf("EVEX %x op=%s, want %s", code, got.Op, wantOp)
+					}
+					registerIndex := 1
+					if !form.immediate {
+						registerIndex = len(got.Args) - 1
+					}
+					if got.Args[registerIndex].String() != fmt.Sprintf("%s21", vector) {
+						t.Fatalf("EVEX %x = %+v, lost high register", code, got)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86PackedHalfConversionSAEAndInvalidForms(t *testing.T) {
+	for _, form := range x86RawHalfConversionForms[:2] {
+		code := encodeX86RawEVEXHalfConversion(form, 2, 2, true, true, 1, 2, false, 7)
+		got, length, matched, err := decodedX86PackedHalfConversionInstruction(code, 64)
+		if err != nil || !matched || length != len(code) || got.Op != form.op+".SAE.Z" {
+			t.Fatalf("SAE %x = %+v length=%d matched=%v err=%v", code, got, length, matched, err)
+		}
+		invalid := append([]byte(nil), code...)
+		invalid[2] |= 0x80
+		if _, _, matched, err := decodedX86PackedHalfConversionInstruction(invalid, 64); !matched || err == nil {
+			t.Fatalf("W=1 encoding accepted: %x", invalid)
+		}
+		invalid = append([]byte(nil), code...)
+		invalid[3] &^= 7
+		if _, _, matched, err := decodedX86PackedHalfConversionInstruction(invalid, 64); !matched || err == nil {
+			t.Fatalf("zeroing without mask accepted: %x", invalid)
+		}
+	}
+	toHalf := x86RawHalfConversionForms[1]
+	missingImmediate := encodeX86RawVEXHalfConversion(toHalf, false, 1, 2, false, 7)
+	missingImmediate = missingImmediate[:len(missingImmediate)-1]
+	if _, _, matched, err := decodedX86PackedHalfConversionInstruction(missingImmediate, 64); !matched || err == nil {
+		t.Fatalf("missing imm8 accepted: %x", missingImmediate)
+	}
+	fromHalf := x86RawHalfConversionForms[0]
+	invalidMemorySAE := encodeX86RawEVEXHalfConversion(fromHalf, 2, 0, false, true, 1, 0, true, 0)
+	if _, _, matched, err := decodedX86PackedHalfConversionInstruction(invalidMemorySAE, 64); !matched || err == nil {
+		t.Fatalf("half-to-single memory SAE accepted: %x", invalidMemorySAE)
+	}
+}
+
+func TestTranslateRawPackedHalfConversionLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawPackedHalfConversions(SB), $0-0\n")
+			appendBytes := func(code []byte) {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			for _, form := range x86RawHalfConversionForms[:2] {
+				for _, width256 := range []bool{false, true} {
+					appendBytes(encodeX86RawVEXHalfConversion(form, width256, 2, 1, false, 7))
+					appendBytes(encodeX86RawVEXHalfConversion(form, width256, 2, 0, true, 7))
+				}
+				for vectorBits := 0; vectorBits < 3; vectorBits++ {
+					mask := 3
+					if target.goarch == "386" && form.immediate {
+						mask = 0
+					}
+					reg, rm := 21, 20
+					if target.goarch == "386" {
+						reg, rm = 2, 1
+					}
+					appendBytes(encodeX86RawEVEXHalfConversion(form, vectorBits, mask, mask != 0, vectorBits == 2, reg, rm, false, 9))
+					appendBytes(encodeX86RawEVEXHalfConversion(form, vectorBits, mask, false, false, 1, 0, true, 9))
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86NamedHalfOriginalFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-half-conversions.ll", "raw-half-conversions.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_decode_guard_test.go b/amd64_raw_decode_guard_test.go
new file mode 100644
index 000000000..a9d117865
--- /dev/null
+++ b/amd64_raw_decode_guard_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawDecoderRejectsUnrecognizedVEXInsteadOfLegacyInstructions(t *testing.T) {
+	// x/arch v0.14 can return SUB AL,imm instead of an error for these
+	// invalid scalar conversions. Such a successful decode is not semantic support.
+	for _, code := range [][]byte{{0xc5, 0xf8, 0x2c, 0xc1}, {0xc5, 0xf8, 0x2d, 0xc1}, {0xc4, 0xe1, 0xf8, 0x2c, 0xc1}} {
+		for _, arch := range []string{"386", "amd64"} {
+			var source strings.Builder
+			source.WriteString("TEXT f(SB),4,$0-0\n")
+			for _, b := range code {
+				fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+			}
+			source.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"f": {Name: "f", Ret: Void}}}); err == nil {
+				t.Errorf("%s raw %x must fail closed instead of executing legacy arithmetic: %v", arch, code, err)
+			}
+		}
+	}
+}
+
+func TestX86RawDecoderRecognizesSupportedScalarConversionsBeforeLegacyFallback(t *testing.T) {
+	for _, tc := range []struct {
+		code []byte
+		op   Op
+	}{
+		{[]byte{0xc5, 0xfb, 0x2c, 0xc1}, "VCVTTSD2SI"},
+		{[]byte{0xc5, 0xfa, 0x2c, 0xc1}, "VCVTTSS2SI"},
+		{[]byte{0xc4, 0xe1, 0xfb, 0x2c, 0xc1}, "VCVTTSD2SIQ"},
+	} {
+		decoded, err := decodeX86RawDirectives(rawX86Function(tc.code), "amd64")
+		if err != nil || len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != tc.op {
+			t.Errorf("supported VEX %x: %+v, %v; want %s", tc.code, decoded.Instrs, err, tc.op)
+		}
+	}
+}
+
+func TestX86RawDecoderRetainsRecognizedVEXFallback(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc5, 0xf8, 0x77}, {0xc5, 0xf9, 0x6f, 0xc1}, {0xc5, 0xfa, 0x6f, 0xc1},
+		{0xc5, 0xf9, 0xe7, 0x00}, {0xc4, 0xe2, 0x79, 0x2a, 0x00},
+	} {
+		decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+		if err != nil || len(decoded.Instrs) != 1 {
+			t.Fatalf("recognized VEX %x: %+v, %v", code, decoded.Instrs, err)
+		}
+	}
+}
diff --git a/amd64_raw_decode_test.go b/amd64_raw_decode_test.go
new file mode 100644
index 000000000..92d11841e
--- /dev/null
+++ b/amd64_raw_decode_test.go
@@ -0,0 +1,395 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64RawDirectiveSequenceUsesSemanticLowering(t *testing.T) {
+	source := `TEXT rawLoad(SB), NOSPLIT, $256-0
+	MOVQ $0, R11
+	BYTE $0x4e
+	BYTE $0x0f
+	BYTE $0xb7
+	BYTE $0x7c
+	BYTE $0x5c
+	BYTE $0x78
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func rawLoad()", "amd64", triple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("original indexed physical SP bytes acquired a source/frame role", api, err)
+		}
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86ScalarFormatObjectUnit(t, normalized, map[string]FuncSig{"rawLoad": {Name: "rawLoad", Ret: Void}}, "amd64", triple, 256)
+	if strings.Contains(ir, "module asm") {
+		t.Fatalf("raw instructions bypassed semantic lowering:\n%s", ir)
+	}
+	if !strings.Contains(ir, "load i16") || !strings.Contains(ir, "zext i16") {
+		t.Fatalf("decoded MOVWQZX semantics missing:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		x86PackedStringCompileObject(t, llc, triple, ir, level)
+	}
+	// This independent source initializes the exact original physical tuple
+	// and attempts a real Go frame capture. The current frame producer has
+	// no raw-extension contract; retain that boundary as Context explicitly.
+	initialized := strings.Replace(source, "TEXT rawLoad(SB), NOSPLIT, $256-0",
+		"TEXT ·RawLoad(SB),4,$256-16\nMOVQ x+0(FP),AX\nMOVW AX,120(SP)", 1)
+	initialized = strings.Replace(initialized, "\tRET", "\tMOVQ R15,ret+8(FP)\n\tRET", 1)
+	x86LEAActualTargetGoObject(t, "amd64", triple, initialized)
+	pkg, request, _, options := fixedLocalTransportFixture(t, initialized, "func RawLoad(x uint64) uint64", "linux/amd64", triple)
+	goAMD64FramePrepareOwnedToolCache(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	observation, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("initialized raw-SP capture failed outside its source boundary", err)
+		}
+		t.Log("original initialized raw-SP Go object retains source-capture Context; initialized named extension objects have separate owners")
+		return
+	}
+	defer func() {
+		if err := observation.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	expanded, err := observation.preprocess(request.AssemblyFile, []byte(initialized))
+	if err != nil {
+		t.Fatal(err)
+	}
+	initializedFile, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := observation.BindFixedLocal(ctx, pkg, initializedFile, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("captured frame silently acquired a raw physical-extension consumer", err)
+	}
+	t.Log("original raw-SP formats and captured initialized raw-SP Context remain separate from initialized named-extension objects")
+}
+
+func TestX86RawOnlyFunctionUsesSemanticLowering(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		goarch string
+		triple string
+		source string
+	}{
+		{
+			name:   "amd64",
+			goarch: "amd64",
+			triple: "x86_64-unknown-linux-gnu",
+			source: "TEXT raw(SB), NOSPLIT, $0-0\nBYTE $0x90\nBYTE $0xc3\n",
+		},
+		{
+			name:   "386",
+			goarch: "386",
+			triple: "i386-unknown-linux-gnu",
+			source: "TEXT raw(SB), NOSPLIT, $0-0\nBYTE $0x90\nBYTE $0xc3\n",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, test.source)
+			if err != nil {
+				t.Fatalf("Parse() error = %v", err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       test.goarch,
+				TargetTriple: test.triple,
+				Sigs: map[string]FuncSig{
+					"raw": {Name: "raw", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatalf("Translate() error = %v", err)
+			}
+			if strings.Contains(ir, "module asm") {
+				t.Fatalf("raw-only function bypassed instruction validation:\n%s", ir)
+			}
+			if !strings.Contains(ir, "define void @raw()") || !strings.Contains(ir, "ret void") {
+				t.Fatalf("semantic function body missing:\n%s", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawPCRelativeInstructionOutsideDirectiveGroupFailsClosed(t *testing.T) {
+	source := `TEXT rawBranch(SB), NOSPLIT, $0-0
+	MOVQ $0, AX
+	BYTE $0xeb
+	BYTE $0x7f
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	_, err = Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"rawBranch": {Name: "rawBranch", Ret: Void},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "PC-relative") {
+		t.Fatalf("Translate() error = %v, want explicit PC-relative raw-instruction rejection", err)
+	}
+}
+
+func TestX86RawInternalConditionalBranchCompleteFamily(t *testing.T) {
+	targets := []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	}
+	forms := []struct {
+		name  string
+		bytes func(condition byte) []byte
+	}{
+		{name: "short_forward", bytes: func(condition byte) []byte {
+			return []byte{0x70 + condition, 0x01, 0x90, 0xc3}
+		}},
+		{name: "short_backward", bytes: func(condition byte) []byte {
+			return []byte{0x90, 0x70 + condition, 0xfd, 0xc3}
+		}},
+		{name: "near_forward", bytes: func(condition byte) []byte {
+			return []byte{0x0f, 0x80 + condition, 0x01, 0, 0, 0, 0x90, 0xc3}
+		}},
+		{name: "near_backward", bytes: func(condition byte) []byte {
+			return []byte{0x90, 0x0f, 0x80 + condition, 0xf9, 0xff, 0xff, 0xff, 0xc3}
+		}},
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.goarch, func(t *testing.T) {
+			var source strings.Builder
+			sigs := make(map[string]FuncSig)
+			for condition := byte(0); condition < 16; condition++ {
+				for _, form := range forms {
+					name := fmt.Sprintf("rawJcc_%02x_%s", condition, form.name)
+					fmt.Fprintf(&source, "TEXT %s(SB), NOSPLIT, $0-0\n", name)
+					for _, value := range form.bytes(condition) {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+					sigs[name] = FuncSig{Name: name, Ret: Void}
+				}
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, amd64LLVMBlockName("raw_jcc")) {
+				t.Fatalf("synthetic raw branch labels missing:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-jcc-"+target.goarch+".ll", "raw-jcc-"+target.goarch+".o", ir)
+		})
+	}
+}
+
+func TestX86RawMULXReportedEncoding(t *testing.T) {
+	const source = `TEXT rawMULX(SB), NOSPLIT, $0-0
+	BYTE $0xc4
+	BYTE $0x42
+	BYTE $0xe3
+	BYTE $0xf6
+	BYTE $0xf6
+	RET
+`
+	// These original bytes have no R14/DX producers. Keep the complete Go
+	// encoding and private LLVM format object, not a fictitious public entry.
+	ir := x86MULXOriginalFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu",
+		[]string{"MULXQ R14,BX,R14"})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-mulx.ll", "raw-mulx.o", ir)
+}
+
+func TestX86RawMULXCompleteGoAssemblerForms(t *testing.T) {
+	// Go's x86 table defines both register and Yml memory sources for MULXL
+	// and (on amd64) MULXQ. Exercise both widths plus direct, SIB, disp8 and
+	// base-less disp32 ModRM forms, including extended registers.
+	targets := []struct {
+		goarch string
+		triple string
+		forms  [][]byte
+		rows   []string
+	}{
+		{
+			goarch: "amd64",
+			triple: "x86_64-unknown-linux-gnu",
+			forms: [][]byte{
+				{0xc4, 0x42, 0xe3, 0xf6, 0xf6},                               // MULXQ R14, BX, R14
+				{0xc4, 0x42, 0x3b, 0xf6, 0xfe},                               // MULXL R14, R8, R15
+				{0xc4, 0x22, 0xab, 0xf6, 0x5c, 0x88, 0x10},                   // MULXQ 16(AX)(R9*4), R10, R11
+				{0xc4, 0xe2, 0x6b, 0xf6, 0x5c, 0x48, 0x08},                   // MULXL 8(AX)(CX*2), DX, BX
+				{0xc4, 0xe2, 0xfb, 0xf6, 0x0c, 0x25, 0x78, 0x56, 0x34, 0x12}, // MULXQ 0x12345678, AX, CX
+			},
+			rows: []string{
+				"MULXQ R14,BX,R14", "MULXL R14,R8,R15",
+				"MULXQ 16(AX)(R9*4),R10,R11", "MULXL 8(AX)(CX*2),DX,BX",
+				"MULXQ 0x12345678,AX,CX",
+			},
+		},
+		{
+			goarch: "386",
+			triple: "i386-unknown-linux-gnu",
+			forms: [][]byte{
+				{0xc4, 0xe2, 0x73, 0xf6, 0xd0},                         // MULXL AX, CX, DX
+				{0xc4, 0xe2, 0x6b, 0xf6, 0x5c, 0x48, 0x08},             // MULXL 8(AX)(CX*2), DX, BX
+				{0xc4, 0xe2, 0x7b, 0xf6, 0x0d, 0x78, 0x56, 0x34, 0x12}, // MULXL 0x12345678, AX, CX
+			},
+			rows: []string{"MULXL AX,CX,DX", "MULXL 8(AX)(CX*2),DX,BX", "MULXL 0x12345678,AX,CX"},
+		},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range targets {
+		t.Run(target.goarch, func(t *testing.T) {
+			var source strings.Builder
+			for i, encoding := range target.forms {
+				name := fmt.Sprintf("rawMULX_%d", i)
+				fmt.Fprintf(&source, "TEXT %s(SB), NOSPLIT, $0-0\n", name)
+				for _, value := range encoding {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+				source.WriteString("\tRET\n")
+			}
+			// The absolute-address rows remain unbound formats. They cannot
+			// borrow a numerical pointer, DX or a raw-entry permission.
+			ir := x86MULXOriginalFormatObject(t, source.String(), target.goarch, target.triple, target.rows)
+			compileLLVMToObject(t, llc, target.triple, "raw-mulx-forms.ll", "raw-mulx-forms.o", ir)
+		})
+	}
+}
+
+func TestX86RawMULXRejectsLayoutDependentAddressForms(t *testing.T) {
+	tests := []struct {
+		name     string
+		encoding []byte
+	}{
+		{name: "address_size_override", encoding: []byte{0x67, 0xc4, 0xe2, 0x6b, 0xf6, 0x5c, 0x48, 0x08}},
+		{name: "rip_relative", encoding: []byte{0xc4, 0xe2, 0xfb, 0xf6, 0x0d, 0, 0, 0, 0}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawMULX(SB), NOSPLIT, $0-0\n")
+			for _, value := range test.encoding {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawMULX": {Name: "rawMULX", Ret: Void}}})
+			if err == nil || !strings.Contains(err.Error(), "source-layout safe") {
+				t.Fatalf("Translate() error = %v, want source-layout safety rejection", err)
+			}
+		})
+	}
+}
+
+func TestX86RawForwardJumpSkipsEmbeddedDataButStillLowersReachableCode(t *testing.T) {
+	const source = `TEXT rawSignature(SB), NOSPLIT, $0-0
+	BYTE $0xeb
+	BYTE $0x04
+	LONG $0xe77da1c4
+	BYTE $0xc3
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawSignature": {Name: "rawSignature", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "module asm") || !strings.Contains(ir, "ret void") {
+		t.Fatalf("reachable raw control flow was not lowered semantically:\n%s", ir)
+	}
+}
+
+func encodeX86RawRetpoline(register int) []byte {
+	return []byte{0xe8, 0x04, 0, 0, 0, 0xf3, 0x90, 0xeb, 0xfc, byte(0x48 | (register&8)>>1), 0x89, byte(0x04 | (register&7)<<3), 0x24, 0xc3}
+}
+
+func TestX86RawRetpolineFamilyLowersToIndirectTailCalls(t *testing.T) {
+	names := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for register, name := range names {
+		if register == 4 {
+			continue
+		}
+		function := "retpoline" + name
+		fmt.Fprintf(&source, "TEXT %s(SB),NOSPLIT,$0-0\n", function)
+		for _, value := range encodeX86RawRetpoline(register) {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[function] = FuncSig{Name: function, Ret: Void}
+		if got, ok := x86RawRetpolineTarget(encodeX86RawRetpoline(register)); !ok || got != Reg(name) {
+			t.Fatalf("decoded retpoline register %d as %s, ok=%v", register, got, ok)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "module asm") || !strings.Contains(ir, "call i64 %") || !strings.Contains(ir, "ret void") {
+		t.Fatalf("raw retpolines were not lowered as semantic indirect tail calls:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-retpoline.ll", "amd64-raw-retpoline.o", ir)
+}
+
+func TestX86RawRetpolineDecoderRejectsNearMisses(t *testing.T) {
+	for _, offset := range []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 13} {
+		nearMiss := append([]byte(nil), encodeX86RawRetpoline(0)...)
+		nearMiss[offset] ^= 1
+		if _, ok := x86RawRetpolineTarget(nearMiss); ok {
+			t.Fatalf("retpoline decoder accepted byte %d near miss %#v", offset, nearMiss)
+		}
+	}
+	if _, ok := x86RawRetpolineTarget(encodeX86RawRetpoline(4)); ok {
+		t.Fatal("retpoline decoder accepted impossible SP target")
+	}
+}
diff --git a/amd64_raw_descriptor_alias_test.go b/amd64_raw_descriptor_alias_test.go
new file mode 100644
index 000000000..7a5938e4d
--- /dev/null
+++ b/amd64_raw_descriptor_alias_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawDescriptorStoreAliases(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{name: "sldt-memory-amd64", code: []byte{0x0f, 0x00, 0x07}, mode: 64, want: "SLDTW"},
+		{name: "sldt-memory-386", code: []byte{0x0f, 0x00, 0x07}, mode: 32, want: "SLDTW"},
+		{name: "sldt-register-word", code: []byte{0x66, 0x0f, 0x00, 0xc0}, mode: 64, want: "SLDTW"},
+		{name: "sldt-register-long", code: []byte{0x0f, 0x00, 0xc0}, mode: 64, want: "SLDTL"},
+		{name: "sldt-register-quad", code: []byte{0x48, 0x0f, 0x00, 0xc0}, mode: 64, want: "SLDTQ"},
+		{name: "str-memory-amd64", code: []byte{0x0f, 0x00, 0x0f}, mode: 64, want: "STRW"},
+		{name: "str-memory-386", code: []byte{0x0f, 0x00, 0x0f}, mode: 32, want: "STRW"},
+		{name: "str-register-word", code: []byte{0x66, 0x0f, 0x00, 0xc8}, mode: 64, want: "STRW"},
+		{name: "str-register-long", code: []byte{0x0f, 0x00, 0xc8}, mode: 64, want: "STRL"},
+		{name: "str-register-quad", code: []byte{0x48, 0x0f, 0x00, 0xc8}, mode: 64, want: "STRQ"},
+		{name: "smsw-memory-amd64", code: []byte{0x0f, 0x01, 0x27}, mode: 64, want: "SMSWW"},
+		{name: "smsw-memory-386", code: []byte{0x0f, 0x01, 0x27}, mode: 32, want: "SMSWW"},
+		{name: "smsw-register-word", code: []byte{0x66, 0x0f, 0x01, 0xe0}, mode: 64, want: "SMSWW"},
+		{name: "smsw-register-long", code: []byte{0x0f, 0x01, 0xe0}, mode: 64, want: "SMSWL"},
+		{name: "smsw-register-quad", code: []byte{0x48, 0x0f, 0x01, 0xe0}, mode: 64, want: "SMSWQ"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			inst, err := x86asm.Decode(tc.code, tc.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			syntax, err := decodedX86GoSyntax(inst, tc.code)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.HasPrefix(syntax, tc.want+" ") {
+				t.Fatalf("raw %x decoded as %q, want %s", tc.code, syntax, tc.want)
+			}
+		})
+	}
+}
+
+func TestX86RawDescriptorStoreCompiles(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawDescriptorStore(SB),$0-0\n")
+			codes := [][]byte{
+				{0x0f, 0x00, 0x07}, {0x0f, 0x00, 0x0f}, {0x0f, 0x01, 0x27},
+				{0x66, 0x0f, 0x00, 0xc0}, {0x0f, 0x00, 0xc0},
+				{0x66, 0x0f, 0x00, 0xc8}, {0x0f, 0x00, 0xc8},
+				{0x66, 0x0f, 0x01, 0xe0}, {0x0f, 0x01, 0xe0},
+			}
+			if target.goarch == "amd64" {
+				codes = append(codes,
+					[]byte{0x48, 0x0f, 0x00, 0xc0},
+					[]byte{0x48, 0x0f, 0x00, 0xc8},
+					[]byte{0x48, 0x0f, 0x01, 0xe0},
+				)
+			}
+			for _, code := range codes {
+				for _, value := range code {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawDescriptorStore": {Name: "rawDescriptorStore", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-descriptor-store.ll", "raw-descriptor-store.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_displacement_test.go b/amd64_raw_displacement_test.go
new file mode 100644
index 000000000..d3e18ebe8
--- /dev/null
+++ b/amd64_raw_displacement_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func x86RawLEADisplacementEncoding(mode, width, addressBits, shape, scale int, displacement int32) []byte {
+	var encoding []byte
+	if width == 16 {
+		encoding = append(encoding, 0x66)
+	}
+	if addressBits != mode {
+		encoding = append(encoding, 0x67)
+	}
+	if width == 64 {
+		encoding = append(encoding, 0x48)
+	}
+	encoding = append(encoding, 0x8d)
+	if addressBits == 16 {
+		// mod=10, reg=CX, r/m=BX+SI; the displacement is physical disp16.
+		encoding = append(encoding, 0x88)
+		return binary.LittleEndian.AppendUint16(encoding, uint16(displacement))
+	}
+	switch shape {
+	case 0: // AX + disp32
+		encoding = append(encoding, 0x88)
+	case 1: // AX + BX*scale + disp32
+		encoding = append(encoding, 0x8c, byte(scale<<6|3<<3))
+	case 2: // AX*scale + disp32; no base is encoded.
+		encoding = append(encoding, 0x0c, byte(scale<<6|5))
+	case 3: // disp32; SIB has neither a base nor an index.
+		encoding = append(encoding, 0x0c, 0x25)
+	default:
+		panic("unknown raw LEA displacement fixture shape")
+	}
+	return binary.LittleEndian.AppendUint32(encoding, uint32(displacement))
+}
+
+func x86RawDisplacementDirectives(encoding []byte) string {
+	var source strings.Builder
+	for _, value := range encoding {
+		fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+	}
+	return source.String()
+}
+
+func TestX86RawDisplacementRetainsPhysicalSignedField(t *testing.T) {
+	// Intel SDM Vol. 2, section 2.2.1: ModR/M/SIB disp32 is sign-extended
+	// in a 64-bit effective address. x/arch v0.14 exposes it as uint32.
+	for _, mode := range []int{32, 64} {
+		for _, shape := range []int{0, 1, 2, 3} {
+			for _, displacement := range []int32{-1 << 31, -129, -128, -64, -1, 0, 127, 128, 1<<31 - 1} {
+				t.Run(fmt.Sprintf("mode%d/shape%d/%d", mode, shape, displacement), func(t *testing.T) {
+					encoding := x86RawLEADisplacementEncoding(mode, mode, mode, shape, 2, displacement)
+					inst, err := x86asm.Decode(encoding, mode)
+					if err != nil || inst.Len != len(encoding) || inst.Op != x86asm.LEA {
+						t.Fatalf("physical LEA decode: %+v, %v", inst, err)
+					}
+					syntax, err := decodedX86GoSyntax(inst, encoding)
+					if err != nil {
+						t.Fatal(err)
+					}
+					instruction := x86RawDisplacementDecodedLEA(t, mode, encoding)
+					if got := instruction.Args[0].Mem.Off; got != int64(displacement) {
+						t.Fatalf("physical signed disp32 became %d, want %d: %q", got, displacement, syntax)
+					}
+				})
+			}
+		}
+	}
+	// The independently discovered go-cv-simd bytes use REX.R/X and no base.
+	encoding := []byte{0x4e, 0x8d, 0x04, 0x9d, 0xc0, 0xff, 0xff, 0xff}
+	inst, err := x86asm.Decode(encoding, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if syntax, err := decodedX86GoSyntax(inst, encoding); err != nil || syntax != "LEAQ -0x40(R11*4), R8" {
+		t.Fatalf("original no-base extended-index LEA: %q, %v", syntax, err)
+	}
+}
+
+func x86RawDisplacementDecodedLEA(t *testing.T, mode int, encoding []byte) Instr {
+	t.Helper()
+	arch := "amd64"
+	if mode == 32 {
+		arch = "386"
+	}
+	file, err := Parse(ArchAMD64, "TEXT raw(SB),4,$0-0\n"+x86RawDisplacementDirectives(encoding)+"RET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	function, err := decodeX86RawDirectives(file.Funcs[0], arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, instruction := range function.Instrs {
+		if strings.HasPrefix(string(instruction.Op), "LEA") {
+			if len(instruction.Args) != 2 || instruction.Args[0].Kind != OpMem {
+				t.Fatalf("lost physical LEA memory operand: %+v", instruction)
+			}
+			return instruction
+		}
+	}
+	t.Fatal("decoded raw source lost its LEA instruction")
+	return Instr{}
+}
+
+func TestX86RawDisplacementDoesNotSignExtendMOVAbsoluteOffset(t *testing.T) {
+	for _, opcode := range []byte{0xa0, 0xa1, 0xa2, 0xa3} {
+		for _, offset := range []uint64{0x80000000, 0xffffffc0, 0x1122334480000000} {
+			t.Run(fmt.Sprintf("%x/%x", opcode, offset), func(t *testing.T) {
+				encoding := binary.LittleEndian.AppendUint64([]byte{0x48, opcode}, offset)
+				inst, err := x86asm.Decode(encoding, 64)
+				if err != nil || inst.Len != len(encoding) {
+					t.Fatalf("physical MOV moffs decode: %+v, %v", inst, err)
+				}
+				syntax, err := decodedX86GoSyntax(inst, encoding)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if syntax != x86asm.GoSyntax(inst, 0, nil) {
+					t.Fatalf("absolute MOV spelling changed: %q", syntax)
+				}
+				found := false
+				normalized := normalizeDecodedX86MemoryDisplacements(inst)
+				for _, operand := range normalized.Args {
+					if memory, ok := operand.(x86asm.Mem); ok {
+						found = true
+						if uint64(memory.Disp) != offset {
+							t.Fatalf("absolute native offset narrowed: %q", syntax)
+						}
+					}
+				}
+				if !found {
+					t.Fatalf("missing absolute memory operand: %q", syntax)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawDisplacementLEAAllWidthsAndFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		mode := 64
+		if target.arch == "386" {
+			mode = 32
+		}
+		for _, width := range []int{16, 32, 64} {
+			if width > mode {
+				continue
+			}
+			for _, shape := range []int{0, 1, 2, 3} {
+				t.Run(fmt.Sprintf("%s/width%d/shape%d", target.triple, width, shape), func(t *testing.T) {
+					encoding := x86RawLEADisplacementEncoding(mode, width, mode, shape, 2, -64)
+					body := "@MOV x+0(FP),AX\n@MOV $3,BX\n@MOV $0,CX\n" + x86RawDisplacementDirectives(encoding) + "@MOV CX,ret+@WORD(FP)\nRET"
+					source, sig, _ := x86SourceStackNumericalFixture(target.arch, body)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err := Translate(file, x86SourceStackOptions(target.arch, target.triple, sig))
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "raw-disp.ll", "raw-disp.o", ir)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_double_dword.go b/amd64_raw_double_dword.go
new file mode 100644
index 000000000..7860568f9
--- /dev/null
+++ b/amd64_raw_double_dword.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Opcode E6 has three Go 1.27 conversion grammars. VEX.W is ignored; EVEX.W
+// distinguishes the dword/double family from qword/double instructions. LL
+// selects the vector width except when EVEX.b enables rounding or SAE on a
+// register-source 512-bit double-to-dword form.
+func decodedX86PackedDoubleDwordInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedDoubleDwordInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedDoubleDwordInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || p.opcode != 0xe6 || (p.pp != 1 && p.pp != 2 && p.pp != 3) {
+		return Instr{}, 0, false, nil
+	}
+	if p.pp != 2 && (!p.evex || p.w) {
+		return decodedX86PackedNumericConversionInstructionWithMemory(code, mode, memory)
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed double/dword conversion: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.upper != 0 {
+		return fail("reserved vvvv/V' field")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.evex {
+		if p.w != (p.pp != 2) {
+			// EVEX.W selects another conversion family, such as VCVTQQ2PD.
+			return Instr{}, 0, false, nil
+		}
+		if !p.fixed || p.zero && p.mask == 0 {
+			return fail("invalid EVEX fixed, mask or zeroing field")
+		}
+	} else if p.vectorLength > 1 {
+		return fail("invalid VEX vector length")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	if mode == 32 {
+		if p.pp == 2 && (p.r != 0 || registerSource && (p.b != 0 || p.x != 0)) {
+			return fail("signed dword-to-double has no extended physical vector register in 32-bit mode")
+		}
+		if !p.evex && (p.r != 0 || p.b != 0 || p.x != 0) {
+			return fail("extended VEX register in 32-bit mode")
+		}
+		if p.evex && !registerSource && (p.b != 0 || p.x != 0) {
+			return fail("extended memory address in 32-bit mode")
+		}
+	}
+	rounding := p.evex && p.broadcast && registerSource
+	broadcast := p.evex && p.broadcast && !registerSource
+	if p.pp == 2 && rounding {
+		return fail("dword-to-double has no SAE or rounding form")
+	}
+	if p.evex && !rounding && p.vectorLength > 2 {
+		return fail("reserved EVEX vector length")
+	}
+	if p.pp != 2 && rounding && !p.evex {
+		return fail("rounding or SAE requires EVEX")
+	}
+
+	vectorLength := p.vectorLength
+	if rounding {
+		vectorLength = 2 // Register-source SAE/rounding implies 512 bits.
+	}
+	var op Op
+	var sourcePrefix, destinationPrefix string
+	var memoryScale int
+	if p.pp == 2 {
+		op = "VCVTDQ2PD"
+		destinationPrefix = [...]string{"X", "Y", "Z"}[vectorLength]
+		sourcePrefix = "X"
+		if vectorLength == 2 {
+			sourcePrefix = "Y"
+		}
+		memoryScale = 8 << vectorLength
+	} else {
+		stem := "VCVTPD2DQ"
+		if p.pp == 1 {
+			stem = "VCVTTPD2DQ"
+		}
+		sourcePrefix = [...]string{"X", "Y", "Z"}[vectorLength]
+		destinationPrefix = "X"
+		if vectorLength == 2 {
+			destinationPrefix = "Y"
+		}
+		op = Op(stem)
+		if vectorLength < 2 {
+			op = Op(stem + [...]string{"X", "Y"}[vectorLength])
+		}
+		memoryScale = 16 << vectorLength
+	}
+	if mode == 32 {
+		if sourcePrefix == "Z" && registerSource && (p.b != 0 || p.x != 0) {
+			return fail("Z8-Z31 are not Go assembler source registers in 32-bit mode")
+		}
+		if destinationPrefix == "Z" && p.r != 0 {
+			return fail("Z8-Z31 are not Go assembler destination registers in 32-bit mode")
+		}
+	}
+	if _, exists := amd64PackedDoubleDwordOps[string(op)]; !exists {
+		return fail("encoding has no Go packed conversion form")
+	}
+	if rounding {
+		if p.pp == 1 {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+		}
+	} else if broadcast {
+		op += ".BCST"
+		if p.pp == 2 {
+			memoryScale = 4
+		} else {
+			memoryScale = 8
+		}
+	}
+	if p.zero {
+		op += ".Z"
+	}
+
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, sourcePrefix, memoryScale)
+	} else {
+		source, consumed, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, sourcePrefix)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationPrefix, int(code[p.modRM]>>3&7)+p.r*8))}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for i, arg := range args {
+		printed[i] = arg.String()
+	}
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86PackedNumericEVEX: p.evex,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_double_dword_test.go b/amd64_raw_double_dword_test.go
new file mode 100644
index 000000000..cca7db94d
--- /dev/null
+++ b/amd64_raw_double_dword_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawPackedDoubleDwordBaseForms = []struct {
+	op     Op
+	pp     byte
+	length byte
+	evex   bool
+	src    Reg
+	dst    Reg
+}{
+	{"VCVTDQ2PD", 2, 0, false, "X1", "X0"},
+	{"VCVTDQ2PD", 2, 1, false, "X1", "Y0"},
+	{"VCVTDQ2PD", 2, 0, true, "X1", "X0"},
+	{"VCVTDQ2PD", 2, 1, true, "X1", "Y0"},
+	{"VCVTDQ2PD", 2, 2, true, "Y1", "Z0"},
+	{"VCVTPD2DQX", 3, 0, false, "X1", "X0"},
+	{"VCVTPD2DQY", 3, 1, false, "Y1", "X0"},
+	{"VCVTPD2DQX", 3, 0, true, "X1", "X0"},
+	{"VCVTPD2DQY", 3, 1, true, "Y1", "X0"},
+	{"VCVTPD2DQ", 3, 2, true, "Z1", "Y0"},
+	{"VCVTTPD2DQX", 1, 0, false, "X1", "X0"},
+	{"VCVTTPD2DQY", 1, 1, false, "Y1", "X0"},
+	{"VCVTTPD2DQX", 1, 0, true, "X1", "X0"},
+	{"VCVTTPD2DQY", 1, 1, true, "Y1", "X0"},
+	{"VCVTTPD2DQ", 1, 2, true, "Z1", "Y0"},
+}
+
+func TestX86RawPackedDoubleDwordCompleteGo127BaseForms(t *testing.T) {
+	if len(amd64PackedDoubleDwordOps) != 9 {
+		t.Fatalf("packed double/dword grammar has %d entries, want nine", len(amd64PackedDoubleDwordOps))
+	}
+	for _, tc := range x86RawPackedDoubleDwordBaseForms {
+		for _, memory := range []bool{false, true} {
+			name := fmt.Sprintf("%s/LL=%d/EVEX=%t/memory=%t", tc.op, tc.length, tc.evex, memory)
+			t.Run(name, func(t *testing.T) {
+				modRM := byte(0xc1)
+				if memory {
+					modRM = 0x08
+				}
+				var code []byte
+				if tc.evex {
+					w := byte(0)
+					if tc.pp != 2 {
+						w = 0x80
+					}
+					code = []byte{0x62, 0xf1, 0x7c | tc.pp | w, 0x08 | tc.length<<5, 0xe6, modRM}
+				} else {
+					code = []byte{0xc5, 0xf8 | tc.pp | tc.length<<2, 0xe6, modRM}
+				}
+				fn := Func{}
+				for _, value := range code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != tc.op || len(got.Instrs[0].Args) != 2 {
+					t.Fatalf("decoded %#x as %#v, want %s", code, got.Instrs, tc.op)
+				}
+				args := got.Instrs[0].Args
+				if memory {
+					if args[0].Kind != OpMem || args[0].Mem.Base != AX {
+						t.Fatalf("memory source %#x = %+v", code, args[0])
+					}
+				} else if args[0].Kind != OpReg || args[0].Reg != tc.src {
+					t.Fatalf("register source %#x = %+v, want %s", code, args[0], tc.src)
+				}
+				wantDestination := tc.dst
+				if memory {
+					wantDestination = Reg(string(tc.dst[:1]) + "1")
+				}
+				if args[1].Reg != wantDestination {
+					t.Fatalf("destination %#x = %s, want %s", code, args[1].Reg, wantDestination)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawPackedDoubleDwordEncodingAxes(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{"VEX-W-ignored", []byte{0xc4, 0xe1, 0xfe, 0xe6, 0xc1}, "VCVTDQ2PD", []string{"X1", "Y0"}},
+		{"masked", []byte{0x62, 0xf1, 0x7e, 0x09, 0xe6, 0xc1}, "VCVTDQ2PD", []string{"X1", "K1", "X0"}},
+		{"masked-broadcast-zero", []byte{0x62, 0xf1, 0x7e, 0x99, 0xe6, 0x00}, "VCVTDQ2PD.BCST.Z", []string{"0(AX)", "K1", "X0"}},
+		{"round-down-zero", []byte{0x62, 0xf1, 0xff, 0xb9, 0xe6, 0xd8}, "VCVTPD2DQ.RD_SAE.Z", []string{"Z0", "K1", "Y3"}},
+		{"truncate-SAE", []byte{0x62, 0xf1, 0xfd, 0x18, 0xe6, 0xc1}, "VCVTTPD2DQ.SAE", []string{"Z1", "Y0"}},
+		{"extended-source-and-destination", []byte{0x62, 0xa1, 0x7e, 0x08, 0xe6, 0xc1}, "VCVTDQ2PD", []string{"X17", "X16"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, recognized, err := decodedX86PackedDoubleDwordInstruction(tc.code, 64)
+			if !recognized || err != nil || length != len(tc.code) || got.Op != tc.op {
+				t.Fatalf("decode %#x = %+v, %d, %v, %v; want %s", tc.code, got, length, recognized, err, tc.op)
+			}
+			if len(got.Args) != len(tc.args) {
+				t.Fatalf("decode %#x operands = %+v, want %v", tc.code, got.Args, tc.args)
+			}
+			for index, arg := range got.Args {
+				if arg.String() != tc.args[index] {
+					t.Fatalf("decode %#x operand %d = %s, want %s", tc.code, index, arg.String(), tc.args[index])
+				}
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		off  int64
+	}{
+		{"dword-Z-disp8", []byte{0x62, 0xf1, 0x7e, 0x48, 0xe6, 0x40, 0x02}, 64},
+		{"double-Y-disp8", []byte{0x62, 0xf1, 0xff, 0x28, 0xe6, 0x40, 0x02}, 64},
+		{"double-broadcast-disp8", []byte{0x62, 0xf1, 0xff, 0x38, 0xe6, 0x40, 0x02}, 16},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, _, recognized, err := decodedX86PackedDoubleDwordInstruction(tc.code, 64)
+			if !recognized || err != nil || got.Args[0].Kind != OpMem || got.Args[0].Mem.Off != tc.off {
+				t.Fatalf("decode %#x = %+v, %v, %v; want offset %d", tc.code, got, recognized, err, tc.off)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		{0x62, 0xa1, 0x7e, 0x08, 0xe6, 0xc1}, // X17 -> X16.
+		{0x62, 0xa1, 0xff, 0x28, 0xe6, 0xc1}, // Y17 -> X16.
+	} {
+		got, _, recognized, err := decodedX86PackedDoubleDwordInstruction(code, 32)
+		// Both directions now preserve native state. Go accepts these
+		// spellings, but neither can invent physical high mode32 banks.
+		if !recognized || err == nil {
+			t.Fatal("mode32 native conversion fabricated a high physical bank", got, err)
+		}
+	}
+	requireX86GoAssemblerResult(t, "386", "TEXT high(SB),4,$0-0\n\tVCVTDQ2PD X17, K1, X16\n\tVCVTPD2DQY Y17, K1, X16\n\tRET\n", true)
+}
+
+func TestX86RawPackedDoubleDwordRejectsReservedEncodings(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"VEX-vvvv", []byte{0xc5, 0xee, 0xe6, 0xc1}, 64},
+		{"EVEX-vvvv", []byte{0x62, 0xf1, 0x6e, 0x08, 0xe6, 0xc1}, 64},
+		{"EVEX-zero-without-mask", []byte{0x62, 0xf1, 0x7e, 0x88, 0xe6, 0xc1}, 64},
+		{"EVEX-LL3-without-rounding", []byte{0x62, 0xf1, 0x7e, 0x68, 0xe6, 0xc1}, 64},
+		{"dword-register-broadcast", []byte{0x62, 0xf1, 0x7e, 0x18, 0xe6, 0xc1}, 64},
+		{"address-override", []byte{0x67, 0xc5, 0xfe, 0xe6, 0xc1}, 64},
+		{"missing-ModRM", []byte{0xc5, 0xfe, 0xe6}, 64},
+		{"extended-386", []byte{0xc4, 0x61, 0x7e, 0xe6, 0xc1}, 32},
+		{"Z-destination-386", []byte{0x62, 0xe1, 0x7e, 0x48, 0xe6, 0xc1}, 32},
+		{"Z-source-386", []byte{0x62, 0xb1, 0xff, 0x48, 0xe6, 0xc1}, 32},
+		{"extended-memory-386", []byte{0x62, 0xb1, 0x7e, 0x08, 0xe6, 0x01}, 32},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86PackedDoubleDwordInstruction(tc.code, tc.mode); !recognized || err == nil {
+				t.Fatalf("reserved encoding %#x: recognized=%v error=%v", tc.code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestX86RawPackedDoubleDwordCompilesEveryBaseForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawdoubleconversion(SB),4,$0-0\n")
+			encodings := make([][]byte, 0, len(x86RawPackedDoubleDwordBaseForms)+4)
+			for _, form := range x86RawPackedDoubleDwordBaseForms {
+				modRM := byte(0xc1)
+				var code []byte
+				if form.evex {
+					w := byte(0)
+					if form.pp != 2 {
+						w = 0x80
+					}
+					code = []byte{0x62, 0xf1, 0x7c | form.pp | w, 0x08 | form.length<<5, 0xe6, modRM}
+				} else {
+					code = []byte{0xc5, 0xf8 | form.pp | form.length<<2, 0xe6, modRM}
+				}
+				encodings = append(encodings, code)
+			}
+			encodings = append(encodings,
+				[]byte{0x62, 0xf1, 0x7e, 0x99, 0xe6, 0x00},       // Dword broadcast, mask, zero.
+				[]byte{0x62, 0xf1, 0xff, 0xb9, 0xe6, 0xd8},       // Double embedded rounding.
+				[]byte{0x62, 0xf1, 0xff, 0x38, 0xe6, 0x40, 0x02}, // Double broadcast disp8.
+			)
+			if target.goarch == "amd64" {
+				encodings = append(encodings, []byte{0x62, 0xa1, 0x7e, 0x08, 0xe6, 0xc1}) // Physical high X.
+			}
+			for _, code := range encodings {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+				}
+				source.WriteString("\tNOP\n")
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-double-conversion.ll", "raw-double-conversion.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_duplicate_literal_test.go b/amd64_raw_duplicate_literal_test.go
new file mode 100644
index 000000000..e88e88f73
--- /dev/null
+++ b/amd64_raw_duplicate_literal_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawDuplicateMoveConstant(spec rawDuplicateMoveSpec, encoding string, width int, mask int, zeroing bool) []byte {
+	var code []byte
+	switch encoding {
+	case "legacy":
+		code = encodeX86RawLegacyDuplicateMove(spec, 0, 0)
+	case "vex":
+		code = encodeX86RawVEXDuplicateMove(spec, byte(map[int]int{16: 0, 32: 1}[width]), 0, 0)
+	case "evex":
+		code = encodeX86RawEVEXDuplicateMove(spec, byte(map[int]int{16: 0, 32: 1, 64: 2}[width]), mask, zeroing, 0, 0)
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if spec.double && width == 16 {
+		dataWidth = 8
+	}
+	for i := 0; i < dataWidth; i++ {
+		code = append(code, byte(i*37+3))
+	}
+	return code
+}
+
+func TestDecodeX86RawDuplicateMoveConstantCompleteFamily(t *testing.T) {
+	for _, spec := range rawDuplicateMoveSpecs {
+		for _, encoding := range []string{"legacy", "vex", "evex"} {
+			widths := []int{16}
+			if encoding != "legacy" {
+				widths = append(widths, 32)
+			}
+			if encoding == "evex" {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				mask := 0
+				zeroing := false
+				if encoding == "evex" && width == 64 {
+					mask, zeroing = 3, true
+				}
+				name := fmt.Sprintf("%s/%s/%d", spec.vector, encoding, width)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawDuplicateMoveConstant(spec, encoding, width, mask, zeroing)
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := spec.vector
+					if encoding == "legacy" {
+						want = spec.legacy
+					}
+					if zeroing {
+						want += ".Z"
+					}
+					if len(got) != 2 || got[0].Op != want ||
+						got[0].Args[0].Kind != OpSym || !got[0].x86RIPLiteral ||
+						got[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data", code, got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawDuplicateMoveConstantRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawDuplicateMoveConstant(rawDuplicateMoveSpecs[0], "vex", 32, 0, false)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[5] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[5] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe duplicate-move RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawDuplicateMoveConstantObjects(t *testing.T) {
+	var source strings.Builder
+	for index, spec := range rawDuplicateMoveSpecs {
+		code := x86RawDuplicateMoveConstant(spec, "evex", 64, 3, true)
+		name := fmt.Sprintf("rawDuplicateConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			original, signatures := x86UnboundVoidFormatSources(t, source.String(), "amd64", triple)
+			normalized, err := normalizeX86RawFile(original, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := x86DuplicateMoveFormatObjectUnit(t, normalized, signatures, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-duplicate-literal.ll", "raw-duplicate-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_duplicate_test.go b/amd64_raw_duplicate_test.go
new file mode 100644
index 000000000..a7708b256
--- /dev/null
+++ b/amd64_raw_duplicate_test.go
@@ -0,0 +1,334 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type rawDuplicateMoveSpec struct {
+	legacyPrefix byte
+	opcode       byte
+	legacy       Op
+	vector       Op
+	double       bool
+}
+
+var rawDuplicateMoveSpecs = []rawDuplicateMoveSpec{
+	{legacyPrefix: 0xf2, opcode: 0x12, legacy: "MOVDDUP", vector: "VMOVDDUP", double: true},
+	{legacyPrefix: 0xf3, opcode: 0x16, legacy: "MOVSHDUP", vector: "VMOVSHDUP"},
+	{legacyPrefix: 0xf3, opcode: 0x12, legacy: "MOVSLDUP", vector: "VMOVSLDUP"},
+}
+
+func encodeX86RawLegacyDuplicateMove(spec rawDuplicateMoveSpec, source, destination int) []byte {
+	rex := byte(0x40 | source>>3&1 | destination>>3&1<<2)
+	code := []byte{spec.legacyPrefix}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, spec.opcode, byte(0xc0|destination&7<<3|source&7))
+}
+
+func encodeX86RawVEXDuplicateMove(spec rawDuplicateMoveSpec, vectorBits byte, source, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^source>>3)&1)<<5 | 1
+	pp := byte(2)
+	if spec.double {
+		pp = 3
+	}
+	p1 := byte(0x78 | vectorBits<<2 | pp)
+	return []byte{0xc4, p0, p1, spec.opcode, byte(0xc0 | destination&7<<3 | source&7)}
+}
+
+func encodeX86RawEVEXDuplicateMove(spec rawDuplicateMoveSpec, vectorBits byte, mask int, zeroing bool, source, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^source>>4)&1)<<6 |
+		byte((^source>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 1
+	pp := byte(2)
+	if spec.double {
+		pp = 3
+	}
+	p1 := byte(0x7c | pp)
+	if spec.double {
+		p1 |= 0x80
+	}
+	p2 := vectorBits<<5 | 0x08 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	return []byte{0x62, p0, p1, p2, spec.opcode, byte(0xc0 | destination&7<<3 | source&7)}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVMOVSHDUP(t *testing.T) {
+	// vmovshdup %xmm0, %xmm1;
+	// vpermilps $208, %xmm7, %xmm0
+	code := []byte{0xc5, 0xfa, 0x16, 0xc8, 0xc4, 0xe3, 0x79, 0x04, 0xc7, 0xd0}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VMOVSHDUP sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VMOVSHDUP X0, X1 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawDuplicateMoveCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawDuplicateMoveSpecs {
+		for source := 0; source < 16; source++ {
+			for destination := 0; destination < 16; destination++ {
+				code := encodeX86RawLegacyDuplicateMove(spec, source, destination)
+				got, length, ok, err := decodedX86DuplicateMoveInstruction(code, 64)
+				want := fmt.Sprintf("%s X%d, X%d", spec.legacy, source, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 2; vectorBits++ {
+			vectorName := [...]string{"X", "Y"}[vectorBits]
+			for source := 0; source < 16; source++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86RawVEXDuplicateMove(spec, vectorBits, source, destination)
+					got, length, ok, err := decodedX86DuplicateMoveInstruction(code, 64)
+					want := fmt.Sprintf("%s %s%d, %s%d", spec.vector, vectorName, source, vectorName, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{{}, {mask: 3}, {mask: 7, zeroing: true, suffix: ".Z"}} {
+				for source := 0; source < 32; source++ {
+					for destination := 0; destination < 32; destination++ {
+						code := encodeX86RawEVEXDuplicateMove(spec, vectorBits, masking.mask, masking.zeroing, source, destination)
+						got, length, ok, err := decodedX86DuplicateMoveInstruction(code, 64)
+						args := []string{fmt.Sprintf("%s%d", vectorName, source)}
+						if masking.mask != 0 {
+							args = append(args, fmt.Sprintf("K%d", masking.mask))
+						}
+						args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+						want := string(spec.vector) + masking.suffix + " " + strings.Join(args, ", ")
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 29952 {
+		t.Fatalf("covered %d duplicate-move register encodings, want 29952", count)
+	}
+}
+
+func TestDecodedX86RawDuplicateMoveMemoryAndInvalidForms(t *testing.T) {
+	legacyMemory := []byte{0xf3, 0x47, 0x0f, 0x16, 0x7c, 0x8b, 0x01}
+	got, length, ok, err := decodedX86DuplicateMoveInstruction(legacyMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(legacyMemory) || got.Op != "MOVSHDUP" || got.Args[1].String() != "X15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", legacyMemory, got, length, ok, err)
+	}
+	vexMemory := []byte{0xc4, 0x01, 0x7e, 0x16, 0x7c, 0x8b, 0x02}
+	got, length, ok, err = decodedX86DuplicateMoveInstruction(vexMemory, 64)
+	wantMemory.Off = 2
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VMOVSHDUP" || got.Args[1].String() != "Y15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+	evexMemory := []byte{0x62, 0xf1, 0xff, 0x8b, 0x12, 0x50, 0x02}
+	got, length, ok, err = decodedX86DuplicateMoveInstruction(evexMemory, 64)
+	wantMemory = MemRef{Base: "AX", Off: 16}
+	if err != nil || !ok || length != len(evexMemory) || got.Op != "VMOVDDUP.Z" || got.Args[1].String() != "K3" || got.Args[2].String() != "X2" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexMemory, got, length, ok, err)
+	}
+
+	validVEX := encodeX86RawVEXDuplicateMove(rawDuplicateMoveSpecs[1], 0, 7, 7)
+	validEVEX := encodeX86RawEVEXDuplicateMove(rawDuplicateMoveSpecs[1], 2, 0, false, 7, 5)
+	for name, invalid := range map[string][]byte{
+		"vex vvvv":             {validVEX[0], validVEX[1], validVEX[2] &^ 0x08, validVEX[3], validVEX[4]},
+		"evex fixed bit":       {validEVEX[0], validEVEX[1], validEVEX[2] &^ 0x04, validEVEX[3], validEVEX[4], validEVEX[5]},
+		"evex wrong W":         {validEVEX[0], validEVEX[1], validEVEX[2] | 0x80, validEVEX[3], validEVEX[4], validEVEX[5]},
+		"evex vvvvv":           {validEVEX[0], validEVEX[1], validEVEX[2] &^ 0x08, validEVEX[3] &^ 0x08, validEVEX[4], validEVEX[5]},
+		"evex broadcast":       {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x10, validEVEX[4], validEVEX[5]},
+		"evex reserved length": {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x60, validEVEX[4], validEVEX[5]},
+		"zero without mask":    {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x80, validEVEX[4], validEVEX[5]},
+		"address override":     append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86DuplicateMoveInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	highZ386 := encodeX86RawEVEXDuplicateMove(rawDuplicateMoveSpecs[1], 2, 0, false, 8, 2)
+	if instruction, _, matched, decodeErr := decodedX86DuplicateMoveInstruction(highZ386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 high-Z encoding %x decoded as %+v, ok=%v, err=%v", highZ386, instruction, matched, decodeErr)
+	}
+}
+
+func TestX86DuplicateMoveRawGo127ArchitectureOracle(t *testing.T) {
+	const accepted386 = `TEXT ok(SB),$0-0
+	MOVDDUP X6, X7
+	MOVSHDUP X6, X7
+	MOVSLDUP X6, X7
+	VMOVDDUP Y6, Y7
+	VMOVSHDUP X20, K1, X21
+	VMOVSLDUP.Z Y20, K2, Y21
+	VMOVDDUP Z6, K3, Z7
+	RET
+`
+	requireX86GoAssemblerResult(t, "386", accepted386, true)
+	for _, instruction := range []string{
+		"MOVSHDUP X8, X0",
+		"VMOVDDUP Z8, Z0",
+	} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+	}
+}
+
+func TestTranslateX86RawDuplicateMoveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_duplicate_move(SB),NOSPLIT,$0-0\n")
+			for _, spec := range rawDuplicateMoveSpecs {
+				var encodings [][]byte
+				if target.goarch == "amd64" {
+					encodings = append(encodings,
+						encodeX86RawLegacyDuplicateMove(spec, 15, 14),
+						encodeX86RawVEXDuplicateMove(spec, 1, 15, 14),
+						encodeX86RawEVEXDuplicateMove(spec, 2, 7, true, 31, 30),
+					)
+				} else {
+					encodings = append(encodings,
+						encodeX86RawLegacyDuplicateMove(spec, 7, 6),
+						encodeX86RawVEXDuplicateMove(spec, 1, 7, 6),
+						encodeX86RawEVEXDuplicateMove(spec, 0, 1, false, 20, 21),
+						encodeX86RawEVEXDuplicateMove(spec, 2, 2, true, 6, 7),
+					)
+				}
+				for _, encoding := range encodings {
+					for _, value := range encoding {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.goarch, target.triple)
+			normalized, err := normalizeX86RawFile(file, target.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll := x86DuplicateMoveFormatObjectUnit(t, normalized, signatures, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-duplicate-move-"+target.name+".ll", "raw-duplicate-move-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestAMD64DuplicateMoveRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT duplicateMoveSemantics(SB),NOSPLIT,$0-32
+	MOVQ out+0(FP), AX
+	MOVQ source+8(FP), BX
+	MOVQ old+16(FP), CX
+	KMOVQ mask+24(FP), K1
+	VMOVUPS (BX), Y0
+	VMOVSHDUP Y0, Y1
+	VMOVUPS Y1, 0(AX)
+	VMOVSLDUP Y0, Y2
+	VMOVUPS Y2, 32(AX)
+	VMOVDDUP (BX), X3
+	VMOVUPS X3, 64(AX)
+	VMOVUPS (CX), Y4
+	VMOVSHDUP Y0, K1, Y4
+	VMOVUPS Y4, 80(AX)
+	VMOVUPS (CX), Y4
+	VMOVSLDUP.Z Y0, K1, Y4
+	VMOVUPS Y4, 112(AX)
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: I64, Index: 3, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"duplicateMoveSemantics": {Name: "duplicateMoveSemantics", Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void duplicateMoveSemantics(uint32_t *, const uint32_t *, const uint32_t *, uint64_t);
+int main(void) {
+  uint32_t source[8] = {10, 11, 20, 21, 30, 31, 40, 41};
+  uint32_t old[8] = {100, 101, 102, 103, 104, 105, 106, 107};
+  uint32_t out[36] = {0};
+  uint64_t mask = 0x55;
+  duplicateMoveSemantics(out, source, old, mask);
+  uint32_t sh[8] = {11, 11, 21, 21, 31, 31, 41, 41};
+  uint32_t sl[8] = {10, 10, 20, 20, 30, 30, 40, 40};
+  uint32_t dd[4] = {10, 11, 10, 11};
+  for (int i = 0; i < 8; i++) if (out[i] != sh[i]) return 1 + i;
+  for (int i = 0; i < 8; i++) if (out[8+i] != sl[i]) return 20 + i;
+  for (int i = 0; i < 4; i++) if (out[16+i] != dd[i]) return 40 + i;
+  for (int i = 0; i < 8; i++) {
+    uint32_t want = (mask >> i) & 1 ? sh[i] : old[i];
+    if (out[20+i] != want) return 50 + i;
+  }
+  for (int i = 0; i < 8; i++) {
+    uint32_t want = (mask >> i) & 1 ? sl[i] : 0;
+    if (out[28+i] != want) return 70 + i;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "duplicate_move", triple, ll, mainC, runPrefix)
+}
diff --git a/amd64_raw_endbranch.go b/amd64_raw_endbranch.go
new file mode 100644
index 000000000..bad9f5a3f
--- /dev/null
+++ b/amd64_raw_endbranch.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+// ENDBR changes CET tracking, not GP/SIMD, FLAGS or storage. Numerical
+// observers may preserve existing facts only for the exact named/raw form.
+// The lowerer still emits the native opcode; this supplies no entry authority.
+func x86EndBranchPreservesSourceState(ins Instr) bool {
+	if ins.Op != "ENDBR64" && ins.Op != "ENDBR32" || len(ins.Args) != 0 ||
+		ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	if origin == nil {
+		return ins.Op == "ENDBR64" && !ins.x86Encoded
+	}
+	return ins.x86Encoded && origin.op == ins.Op && len(origin.args) == 0
+}
+
+// These instructions have different native effects. Only their preservation
+// of numerical source facts is shared, never their lowering or CET semantics.
+func x86PreservesNumericalSourceState(ins Instr) bool {
+	return x86NOPPreservesSourceState(ins) || x86EndBranchPreservesSourceState(ins)
+}
+
+// ENDBR32/ENDBR64 have fixed, operand-free encodings (Intel SDM, volume 2).
+// x86asm does not decode them yet. Preserve the actual instruction rather than
+// replacing the CET state transition with a NOP. Go names only ENDBR64, so
+// x86Encoded also keeps ENDBR32 confined to validated raw input.
+func decodedX86EndBranchInstruction(code []byte) (Instr, int, bool) {
+	if len(code) < 4 || code[0] != 0xf3 || code[1] != 0x0f || code[2] != 0x1e {
+		return Instr{}, 0, false
+	}
+	var op Op
+	switch code[3] {
+	case 0xfa:
+		op = "ENDBR64"
+	case 0xfb:
+		op = "ENDBR32"
+	default:
+		return Instr{}, 0, false
+	}
+	return Instr{Op: op, Raw: string(op), x86Encoded: true}, 4, true
+}
diff --git a/amd64_raw_endbranch_test.go b/amd64_raw_endbranch_test.go
new file mode 100644
index 000000000..c99c7a70f
--- /dev/null
+++ b/amd64_raw_endbranch_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Intel SDM lists the operand-free F3 0F 1E FA/FB ENDBR64/ENDBR32
+// encodings. Go 1.27 names only ENDBR64; either encoding is valid BYTE data.
+func TestX86RawEndBranchFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, form := range []struct {
+			op   Op
+			last byte
+		}{
+			{"ENDBR64", 0xfa},
+			{"ENDBR32", 0xfb},
+		} {
+			t.Run(string(form.op)+"/"+target.triple, func(t *testing.T) {
+				source := fmt.Sprintf(`TEXT endbranch(SB),$0-0
+	MOVL $17, AX
+	CMPL AX, AX
+	BYTE $0xf3; BYTE $0x0f; BYTE $0x1e; BYTE $0x%02x
+	SETEQ BL
+	ADDL $3, AX
+	RET
+`, form.last)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded.Instrs) != 7 || decoded.Instrs[3].Op != form.op {
+					t.Fatalf("wrong instruction boundaries: %+v", decoded.Instrs)
+				}
+				ir, err := Translate(file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"endbranch": {Name: "endbranch", Ret: I32}},
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("frame-less manual result acquired an ABI return slot", err)
+				}
+				want := fmt.Sprintf(".byte 0xf3, 0x0f, 0x1e, 0x%02x", form.last)
+				for _, result := range []bool{false, true} {
+					program, declaration := source, "func endbranch()"
+					if result {
+						program = strings.Replace(program, "$0-0", "$0-4", 1)
+						program = strings.Replace(program, "\tRET", "\tMOVL AX,ret+0(FP)\n\tRET", 1)
+						declaration = "func endbranch() uint32"
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, program)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, program, declaration, target.arch, target.triple, api)
+						if err != nil || !strings.Contains(ir, want) {
+							t.Fatal("source-bound ENDBR program lost its encoding", api, result, err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawEndBranchPreservesBoundaries(t *testing.T) {
+	// JE targets the second ENDBR after a first four-byte ENDBR and NOP.
+	code := []byte{0x74, 5, 0xf3, 0x0f, 0x1e, 0xfa, 0x90, 0xf3, 0x0f, 0x1e, 0xfb, 0xc3}
+	for _, mode := range []int{32, 64} {
+		instructions, err := decodeX86RawDirectiveGroup(code, mode, 0, "endbranch fixture", map[string]bool{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		var ops []Op
+		for _, instruction := range instructions {
+			if instruction.Op == "ENDBR32" || instruction.Op == "ENDBR64" {
+				ops = append(ops, instruction.Op)
+			}
+		}
+		if len(ops) != 2 || ops[0] != "ENDBR64" || ops[1] != "ENDBR32" {
+			t.Fatalf("mode %d: ENDBR instructions = %v", mode, ops)
+		}
+		for _, incomplete := range [][]byte{{0xf3}, {0xf3, 0x0f}, {0xf3, 0x0f, 0x1e}} {
+			if _, err := decodeX86RawDirectiveGroup(incomplete, mode, 0, "truncated ENDBR", map[string]bool{}); err == nil {
+				t.Fatalf("accepted truncated encoding %x", incomplete)
+			}
+		}
+	}
+}
+
+func TestX86EndBranch32RemainsRawOnly(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, instruction := range []string{"ENDBR32", "ENDBR32 AX", "ENDBR32.Z"} {
+			source := "TEXT invalid(SB),$0-0\n" + instruction + "\nRET\n"
+			requireX86GoAssemblerResult(t, arch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				continue
+			}
+			if _, err := Translate(file, Options{
+				Goarch: arch,
+				Sigs:   map[string]FuncSig{"invalid": {Name: "invalid", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("accepted Go-undefined text form %q on %s", instruction, arch)
+			}
+		}
+	}
+}
+
+const x86EndBranchRuntimeSource = `TEXT endbranchstate(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVL $17, AX
+	CMPL AX, AX
+	BYTE $0xf3; BYTE $0x0f; BYTE $0x1e; BYTE $0x%02x
+	SETEQ 0(DI)
+	SETCS 1(DI)
+	MOVL AX, 4(DI)
+	RET
+`
+
+func TestX86RawEndBranchRuntimePreservesState(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution requires amd64; required amd64 CI covers this host-inapplicable test")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	// This checks GP/flags preservation, not operating-system CET enforcement.
+	// Both instructions remain executable bytes, even on pre-CET CPUs.
+	for _, last := range []byte{0xfa, 0xfb} {
+		t.Run(fmt.Sprintf("%02x", last), func(t *testing.T) {
+			source := fmt.Sprintf(x86EndBranchRuntimeSource, last)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"endbranchstate": {
+						Name: "endbranchstate", Args: []LLVMType{Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+					},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			const mainC = `
+#include <stdint.h>
+struct result { uint8_t zf, cf, padding[2]; uint32_t value; };
+extern void endbranchstate(struct result *);
+int main(void) {
+  struct result out = {0};
+  endbranchstate(&out);
+  return out.zf != 1 || out.cf != 0 || out.value != 17;
+}
+`
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_endbranch_state", triple, ir, mainC, runPrefix)
+		})
+	}
+}
diff --git a/amd64_raw_enqueue.go b/amd64_raw_enqueue.go
new file mode 100644
index 000000000..c2f3336c9
--- /dev/null
+++ b/amd64_raw_enqueue.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Decode the shared ModRM/SIB grammar using an equivalent LEA understood by
+// x/arch. ENQCMD's register width follows address size, not REX.W or 0x66.
+func decodedX86EnqueueInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	var mandatory, segment, rex byte
+	addressOverride, locked := false, false
+	for i < len(code) {
+		switch code[i] {
+		case 0xf2, 0xf3:
+			mandatory, rex = code[i], 0
+		case 0x64, 0x65:
+			segment, rex = code[i], 0
+		case 0x26, 0x2e, 0x36, 0x3e:
+			segment, rex = 0, 0
+		case 0x66:
+			rex = 0
+		case 0x67:
+			addressOverride, rex = true, 0
+		case 0xf0:
+			locked, rex = true, 0
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				i++
+				continue
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	if len(code) < i+3 || code[i] != 0x0f || code[i+1] != 0x38 || code[i+2] != 0xf8 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	for name, prefix := range x86EnqueueOps {
+		if prefix == mandatory {
+			op = Op(name)
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(reason string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("%s: %s", op, reason)
+	}
+	if locked {
+		return fail("LOCK is not permitted")
+	}
+	if len(code) <= i+3 {
+		return fail("missing ModRM byte")
+	}
+	if code[i+3]>>6 == 3 {
+		return fail("the command source must be memory")
+	}
+	var lea []byte
+	if segment != 0 {
+		lea = append(lea, segment)
+	}
+	if addressOverride {
+		lea = append(lea, 0x67)
+	}
+	if mode == 64 {
+		lea = append(lea, rex|0x48)
+	}
+	lea = append(lea, 0x8d)
+	leaHeader := len(lea)
+	lea = append(lea, code[i+3:]...)
+	decoded, err := x86asm.Decode(lea, mode)
+	if err != nil || decoded.Op != x86asm.LEA {
+		return fail("truncated or invalid memory address")
+	}
+	memory, ok := decoded.Args[1].(x86asm.Mem)
+	if !ok {
+		return fail("decoded source is not memory")
+	}
+	if memory.Base == x86asm.RIP || memory.Base == x86asm.EIP {
+		return fail("PC-relative command source requires source-layout context")
+	}
+	// x/arch prints segment overrides as FS:..., while the Plan 9 parser
+	// represents them as (...)(FS). Carry the segment structurally instead.
+	memory.Segment = 0
+	decoded.Args[1] = memory
+	parsed, err := parseDecodedX86Instruction(x86asm.GoSyntax(decoded, 0, nil))
+	if err != nil || len(parsed) != 1 || len(parsed[0].Args) != 2 {
+		return fail("cannot represent decoded memory address")
+	}
+	length := i + 3 + decoded.Len - leaHeader
+	if length > 15 {
+		return fail("encoding exceeds the 15-byte instruction limit")
+	}
+	ins := parsed[0]
+	if memory.Base == 0 && memory.Index == 0 {
+		ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Off: memory.Disp}}
+	}
+	if ins.Args[0].Kind != OpMem {
+		return fail("cannot represent decoded source as memory")
+	}
+	switch segment {
+	case 0x64:
+		ins.Args[0].Mem.Segment = FS
+	case 0x65:
+		ins.Args[0].Mem.Segment = GS
+	}
+	ins.Op = op
+	ins.x86AddressBits = decoded.AddrSize
+	ins.Raw = fmt.Sprintf("%s %s, %s", op, ins.Args[0], ins.Args[1])
+	return ins, length, true, nil
+}
diff --git a/amd64_raw_enqueue_test.go b/amd64_raw_enqueue_test.go
new file mode 100644
index 000000000..285bc2bdd
--- /dev/null
+++ b/amd64_raw_enqueue_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Intel's ENQCMD family uses F2/F3 0F 38 F8 /r, a 64-byte memory
+// source, a GP destination address, and ZF to report retry. Neither
+// spelling is present in Go 1.27's x86 opcode tables; ixl-go uses BYTE.
+// https://www.intel.com/content/dam/develop/external/us/en/documents/architecture-instruction-set-extensions-programming-reference-737410.pdf
+func TestX86RawEnqueueFamilyObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, family := range []struct {
+		name   string
+		prefix byte
+	}{
+		{"ENQCMD", 0xf2},
+		{"ENQCMDS", 0xf3},
+	} {
+		for _, target := range []struct {
+			arch, triple string
+		}{
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(family.name+"/"+target.triple, func(t *testing.T) {
+				source := fmt.Sprintf(`TEXT enqueue(SB),$0-0
+	MOVL $0, AX
+	MOVL $0, BX
+	BYTE $0x%02x; BYTE $0x0f; BYTE $0x38; BYTE $0xf8; BYTE $0x03
+	SETEQ AX
+	RET
+`, family.prefix)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				instruction := decoded.Instrs[len(decoded.Instrs)-3]
+				if instruction.Op != Op(family.name) || len(instruction.Args) != 2 ||
+					instruction.Args[0].Kind != OpMem || instruction.Args[0].Mem.Base != BX ||
+					instruction.Args[1].Kind != OpReg || instruction.Args[1].Reg != AX {
+					t.Fatalf("wrong command source/destination: %+v", instruction)
+				}
+				// The original source has no ABI0 result field and uses null
+				// device/source addresses. It is a format witness, not a closed
+				// public entry or an executable hardware/PASID contract.
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func enqueue() uint32", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("device format invented an initialized ABI0 return", api, err)
+					}
+				}
+				original := *file
+				original.Funcs = []Func{decoded}
+				ir := x86ScalarFormatObjectUnit(t, &original,
+					map[string]FuncSig{"enqueue": {Name: "enqueue", Ret: I32}}, target.arch, target.triple, 0)
+				if !strings.Contains(ir, strings.ToLower(family.name)) {
+					t.Fatalf("lost device command %s", family.name)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawEnqueueAddressGrammar(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, test := range []struct {
+		name        string
+		mode        int
+		code        []byte
+		address     string
+		destination Reg
+		bits        int
+	}{
+		{"base64", 64, []byte{0xf2, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)", AX, 64},
+		{"base32", 32, []byte{0xf3, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)", AX, 32},
+		{"sib_disp8", 64, []byte{0xf2, 0x44, 0x0f, 0x38, 0xf8, 0x54, 0x8b, 0x80}, "-128(BX)(CX*4)", "R10", 64},
+		{"extended_base_index", 64, []byte{0xf2, 0x47, 0x0f, 0x38, 0xf8, 0x14, 0x8b}, "0(R11)(R9*4)", "R10", 64},
+		{"disp32", 32, []byte{0xf2, 0x0f, 0x38, 0xf8, 0xb0, 0x78, 0x56, 0x34, 0x12}, "305419896(AX)", SI, 32},
+		{"absolute32", 32, []byte{0xf2, 0x0f, 0x38, 0xf8, 0x05, 0x00, 0x10, 0x00, 0x00}, "4096()", AX, 32},
+		{"override32", 64, []byte{0x67, 0xf2, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)", AX, 32},
+		{"override16", 32, []byte{0x67, 0xf2, 0x0f, 0x38, 0xf8, 0x00}, "0(BX)(SI*1)", AX, 16},
+		{"fs", 64, []byte{0x64, 0xf2, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)(FS)", AX, 64},
+		{"gs", 32, []byte{0x65, 0xf3, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)(GS)", AX, 32},
+		{"rex_reset", 64, []byte{0x44, 0xf2, 0x0f, 0x38, 0xf8, 0x03}, "0(BX)", AX, 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ins, length, ok, err := decodedX86EnqueueInstruction(test.code, test.mode)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode = %+v, %d, %v, %v", ins, length, ok, err)
+			}
+			if ins.Args[0].String() != test.address || ins.Args[1].Reg != test.destination || ins.x86AddressBits != test.bits {
+				t.Fatalf("decoded %+v address=%s, want %s, %s, %d bits", ins, ins.Args[0], test.address, test.destination, test.bits)
+			}
+			arch, triple := "amd64", "x86_64-unknown-linux-gnu"
+			if test.mode == 32 {
+				arch, triple = "386", "i386-unknown-linux-gnu"
+			}
+			// Retain every original physical address form and its actual Go
+			// bytes. This format has no initialized source/device addresses.
+			source := "TEXT enqueue(SB),$0-0\n" + x86RawDisplacementDirectives(test.code) + "RET\n"
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, arch, triple)
+			for _, flag := range []string{"cf", "of", "slt", "pf"} {
+				if strings.Count(ir, "store i1 false, ptr %flags_"+flag) < 2 {
+					t.Fatalf("missing cleared %s status flag", flag)
+				}
+			}
+			if !strings.Contains(ir, "elementtype([64 x i8])") || !strings.Contains(ir, "; sete $0") {
+				t.Fatal("lost command width or device retry status")
+			}
+			compileLLVMToObject(t, llc, triple, "address.ll", "address.o", ir)
+			if segment := ins.Args[0].Mem.Segment; segment != "" {
+				cmd := exec.Command(llc, "-O0", "-mtriple="+triple, "-filetype=asm", "-o", "-", "-")
+				cmd.Stdin = strings.NewReader(ir)
+				assembly, err := cmd.CombinedOutput()
+				if err != nil {
+					t.Fatalf("emit assembly: %v\n%s", err, assembly)
+				}
+				if !strings.Contains(string(assembly), "%"+strings.ToLower(string(segment))+":") {
+					t.Fatalf("source segment override was lost:\n%s", assembly)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawEnqueueRejectsInvalidEncodings(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xf2, 0x0f, 0x38, 0xf8},
+		{0xf2, 0x0f, 0x38, 0xf8, 0xc3},
+		{0xf3, 0x0f, 0x38, 0xf8, 0x04},
+		{0xf2, 0x0f, 0x38, 0xf8, 0x43},
+		{0xf2, 0x0f, 0x38, 0xf8, 0x83, 0x01},
+		{0xf0, 0xf2, 0x0f, 0x38, 0xf8, 0x03},
+	} {
+		for _, mode := range []int{32, 64} {
+			if _, _, ok, err := decodedX86EnqueueInstruction(code, mode); !ok || err == nil {
+				t.Fatalf("accepted malformed %x in mode %d: recognized=%v err=%v", code, mode, ok, err)
+			}
+		}
+	}
+	for _, code := range [][]byte{
+		{0x0f, 0x38, 0xf8, 0x03},
+		{0xf2, 0x0f, 0x38, 0xf9, 0x03},
+		{0xb8, 0xf2, 0x0f, 0x38, 0xf8},
+	} {
+		if _, _, ok, _ := decodedX86EnqueueInstruction(code, 64); ok {
+			t.Fatalf("claimed another instruction: %x", code)
+		}
+	}
+}
+
+func TestX86EnqueueRejectsInvalidOperands(t *testing.T) {
+	for _, op := range []string{"ENQCMD", "ENQCMDS"} {
+		for _, tail := range []string{" AX, BX", " (AX), X0", " (AX), (BX)", " (AX)", ".Z (AX), BX"} {
+			file, err := Parse(ArchAMD64, "TEXT invalid(SB),$0-0\n"+op+tail+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{
+				"invalid": {Name: "invalid", Ret: Void},
+			}}); err == nil {
+				t.Fatalf("accepted %s%s", op, tail)
+			}
+		}
+	}
+}
diff --git a/amd64_raw_evex_float_logical.go b/amd64_raw_evex_float_logical.go
new file mode 100644
index 000000000..d702be118
--- /dev/null
+++ b/amd64_raw_evex_float_logical.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodedX86RawEVEXFloatLogicalInstruction covers Go 1.27's EVEX
+// VAND/ANDN/OR/XOR PS/PD rows across X/Y/Z, masks, and scalar broadcast.
+func decodedX86RawEVEXFloatLogicalInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86RawEVEXFloatLogicalInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86RawEVEXFloatLogicalInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 1 || p.opcode < 0x54 || p.opcode > 0x57 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX floating logical: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.addressOverride || p.vectorLength > 2 || p.pp > 1 || p.w != (p.pp == 1) {
+		return fail("invalid prefix or vector length")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires K1-K7")
+	}
+	if mode == 32 && p.mask != 0 {
+		return fail("386 masked form exceeds Go's three-operand frontend")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.broadcast && code[p.modRM]>>6 == 3 {
+		return fail("broadcast requires a memory source")
+	}
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	scale := 16 << p.vectorLength
+	if p.broadcast {
+		scale = 4
+		if p.w {
+			scale = 8
+		}
+	}
+	source, consumed, err := memory.evex(
+		code[p.modRM:], mode, p.b, p.x, p.segment, width, scale,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	stem := [...]string{"VAND", "VANDN", "VOR", "VXOR"}[p.opcode-0x54]
+	suffix := "PS"
+	if p.w {
+		suffix = "PD"
+	}
+	op := Op(stem + suffix)
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	destNumber := int(code[p.modRM]>>3&7) + p.r*8
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destNumber))}
+	args := []Operand{source, second}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{
+		Op: op, Args: args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86Encoded: true,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_evex_float_logical_test.go b/amd64_raw_evex_float_logical_test.go
new file mode 100644
index 000000000..7ddbe7a90
--- /dev/null
+++ b/amd64_raw_evex_float_logical_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawEVEXFloatLogicalEncoding(opcode, pp byte, width, mask int, zeroing, broadcast, rip bool) []byte {
+	p1 := byte(0x7c | pp) // EVEX.vvvv names Z0, fixed bit set.
+	if pp == 1 {
+		p1 |= 0x80 // PD requires EVEX.W1.
+	}
+	p2 := byte(map[int]int{16: 0, 32: 1, 64: 2}[width]<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // Z3 first source, Z2 destination.
+	if broadcast {
+		modRM = 0x13 // 0(BX) first source.
+	}
+	if rip {
+		modRM = 0x15 // RIP+disp32 first source.
+	}
+	code := []byte{0x62, 0xf1, p1, p2, opcode, modRM}
+	if rip {
+		code = append(code, 1, 0, 0, 0)
+	}
+	return code
+}
+
+func x86RawEVEXFloatLogicalLiteral(opcode, pp byte, width, mask int, zeroing, broadcast bool) []byte {
+	code := x86RawEVEXFloatLogicalEncoding(opcode, pp, width, mask, zeroing, broadcast, true)
+	code = append(code, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = 4
+		if pp == 1 {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*13+3))
+	}
+	return code
+}
+
+func TestDecodeX86RawEVEXFloatLogicalArithAVX512Regression(t *testing.T) {
+	// Go's assembler decodes these bytes as VANDPS 0(SI)(R8*4), Z0, Z1.
+	code := []byte{0x62, 0xb1, 0x7c, 0x48, 0x54, 0x0c, 0x86, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "arith AVX512 VANDPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VANDPS" ||
+		decoded[0].Args[0].Kind != OpMem ||
+		decoded[0].Args[0].Mem.Base != SI ||
+		decoded[0].Args[0].Mem.Index != "R8" ||
+		decoded[0].Args[0].Mem.Scale != 4 ||
+		decoded[0].Args[1].Reg != "Z0" ||
+		decoded[0].Args[2].Reg != "Z1" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawEVEXFloatLogicalCompleteGo127Family(t *testing.T) {
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			for _, width := range []int{16, 32, 64} {
+				for _, masking := range []struct {
+					mask int
+					zero bool
+				}{
+					{}, {mask: 3}, {mask: 7, zero: true},
+				} {
+					for _, broadcast := range []bool{false, true} {
+						code := x86RawEVEXFloatLogicalEncoding(opcode, pp, width, masking.mask, masking.zero, broadcast, false)
+						got, length, ok, err := decodedX86RawEVEXFloatLogicalInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						want := Op(stem + suffix)
+						if broadcast {
+							want += ".BCST"
+						}
+						if masking.zero {
+							want += ".Z"
+						}
+						if got.Op != want || len(got.Args) != 3+map[bool]int{false: 0, true: 1}[masking.mask != 0] {
+							t.Fatalf("decode %x = %+v, want %s", code, got, want)
+						}
+						if broadcast && got.Args[0].Kind != OpMem || !broadcast && got.Args[0].Reg == "" {
+							t.Fatalf("decode %x has wrong first source: %+v", code, got)
+						}
+					}
+				}
+			}
+		}
+	}
+	high := []byte{0x62, 0x01, 0x04, 0x40, 0x54, 0xff}
+	got, length, ok, err := decodedX86RawEVEXFloatLogicalInstruction(high, 64)
+	if err != nil || !ok || length != len(high) || got.Raw != "VANDPS Z31, Z31, Z31" {
+		t.Fatalf("high EVEX registers %x decoded as %+v, length=%d, ok=%v, err=%v", high, got, length, ok, err)
+	}
+}
+
+func TestDecodeX86RawEVEXFloatLogicalRIPDataCompleteFamily(t *testing.T) {
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			for _, width := range []int{16, 32, 64} {
+				for _, broadcast := range []bool{false, true} {
+					name := fmt.Sprintf("%s%s/%d/bcst%t", stem, suffix, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawEVEXFloatLogicalLiteral(opcode, pp, width, 7, true, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						dataWidth := width
+						if broadcast {
+							dataWidth = 4
+							if pp == 1 {
+								dataWidth = 8
+							}
+						}
+						if len(decoded) != 2 || decoded[0].Args[0].Kind != OpSym ||
+							!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET ||
+							!bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-dataWidth:]) {
+							t.Fatalf("decoded floating logical literal %x as %#v", code, decoded)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXFloatLogicalRejectsUnsafeForms(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated literal":       func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte { code[6] = 127; return code },
+		"overlapping instruction": func(code []byte) []byte { code[6] = 0; return code },
+		"segment override":        func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address override":        func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawEVEXFloatLogicalLiteral(0x54, 0, 64, 7, true, true))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe floating logical literal %x", code)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		x86RawEVEXFloatLogicalEncoding(0x54, 0, 16, 0, true, false, false),
+		{0x62, 0xf1, 0x7c, 0x19, 0x54, 0xd3}, // EVEX.b with a register source.
+	} {
+		if _, _, ok, err := decodedX86RawEVEXFloatLogicalInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("accepted reserved floating logical form %x: ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateX86RawEVEXFloatLogicalRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			name := "literal" + stem + suffix
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range x86RawEVEXFloatLogicalLiteral(opcode, pp, 64, 7, true, true) {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// The original complete bytes have no K7 producer. Preserve their
+			// objects and public Context, not a fabricated initialized mask.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-evex-float-logical-literal.ll", "raw-evex-float-logical-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_evex_insert_test.go b/amd64_raw_evex_insert_test.go
new file mode 100644
index 000000000..8f9b80ced
--- /dev/null
+++ b/amd64_raw_evex_insert_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXPackedInsert(op Op, vectorBits byte, mask int, zeroing bool, first, second, destination int, immediate byte) []byte {
+	opcode := map[Op]byte{
+		"VINSERTF32X4": 0x18,
+		"VINSERTF64X2": 0x18,
+		"VINSERTF32X8": 0x1a,
+		"VINSERTF64X4": 0x1a,
+		"VINSERTI32X4": 0x38,
+		"VINSERTI64X2": 0x38,
+		"VINSERTI32X8": 0x3a,
+		"VINSERTI64X4": 0x3a,
+	}[op]
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 3
+	p1 := byte(^second&15)<<3 | 5
+	if strings.Contains(string(op), "64") {
+		p1 |= 0x80
+	}
+	p2 := vectorBits<<5 | byte((^second>>4)&1)<<3 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM, immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedHasteEVEXPackedInsert(t *testing.T) {
+	code := []byte{0x62, 0xf3, 0xfd, 0x48, 0x38, 0x47, 0x01, 0x01}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "haste VINSERTI64X2 sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "VINSERTI64X2 $1, 16(DI), Z0, Z0"
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, want+" ") {
+		t.Fatalf("decoded %x as %#v, want %q", code, decoded, want)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedInsertCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, family := range []struct {
+		ops        []Op
+		vectorBits []byte
+	}{
+		{
+			ops:        []Op{"VINSERTF32X4", "VINSERTF64X2", "VINSERTI32X4", "VINSERTI64X2"},
+			vectorBits: []byte{1, 2},
+		},
+		{
+			ops:        []Op{"VINSERTF32X8", "VINSERTF64X4", "VINSERTI32X8", "VINSERTI64X4"},
+			vectorBits: []byte{2},
+		},
+	} {
+		for _, op := range family.ops {
+			for _, vectorBits := range family.vectorBits {
+				vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+				firstName := "X"
+				if strings.HasSuffix(string(op), "X8") || strings.HasSuffix(string(op), "X4") && strings.Contains(string(op), "64X4") {
+					firstName = "Y"
+				}
+				for _, masking := range []struct {
+					mask    int
+					zeroing bool
+					suffix  string
+				}{
+					{},
+					{mask: 3},
+					{mask: 7, zeroing: true, suffix: ".Z"},
+				} {
+					for first := 0; first < 32; first++ {
+						for second := 0; second < 32; second++ {
+							for destination := 0; destination < 32; destination++ {
+								immediate := byte(first*8 + destination)
+								code := encodeX86RawEVEXPackedInsert(op, vectorBits, masking.mask, masking.zeroing, first, second, destination, immediate)
+								got, length, ok, err := decodedX86EVEXPackedInsertInstruction(code, 64)
+								args := []string{
+									fmt.Sprintf("$%d", immediate),
+									fmt.Sprintf("%s%d", firstName, first),
+									fmt.Sprintf("%s%d", vectorName, second),
+								}
+								if masking.mask != 0 {
+									args = append(args, fmt.Sprintf("K%d", masking.mask))
+								}
+								args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+								want := string(op) + masking.suffix + " " + strings.Join(args, ", ")
+								if err != nil || !ok || length != len(code) || got.Raw != want {
+									t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 1179648 {
+		t.Fatalf("covered %d EVEX packed-insert register encodings, want 1179648", count)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedInsertMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x62, 0x03, 0x15, 0xc3, 0x3a, 0x64, 0x8b, 0x02, 0xff}
+	got, length, ok, err := decodedX86EVEXPackedInsertInstruction(code, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 64}
+	if err != nil || !ok || length != len(code) || got.Op != "VINSERTI32X8.Z" || len(got.Args) != 5 || got.Args[0].Imm != 255 || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) || got.Args[2].String() != "Z29" || got.Args[3].String() != "K3" || got.Args[4].String() != "Z28" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86RawEVEXPackedInsert("VINSERTI64X2", 2, 0, false, 0, 1, 2, 3)
+	for name, mutate := range map[string]func([]byte){
+		"missing EVEX fixed bit": func(code []byte) { code[2] &^= 0x04 },
+		"EVEX.b":                 func(code []byte) { code[3] |= 0x10 },
+		"reserved length":        func(code []byte) { code[3] |= 0x60 },
+		"zero without mask":      func(code []byte) { code[3] |= 0x80 },
+		"x4 with X output":       func(code []byte) { code[3] &^= 0x60 },
+		"x8 with Y output": func(code []byte) {
+			code[3] = code[3]&^0x60 | 0x20
+			code[4] = 0x3a
+		},
+	} {
+		invalid := append([]byte(nil), valid...)
+		mutate(invalid)
+		if instruction, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	for _, invalid := range [][]byte{
+		{0x62},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4], valid[5], valid[6]},
+		{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4], valid[5], valid[6]},
+		{valid[0], valid[1], valid[2], valid[3], 0x19, valid[5], valid[6]},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("unrelated encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	truncatedImmediate := valid[:len(valid)-1]
+	if _, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(truncatedImmediate, 64); !matched || decodeErr == nil {
+		t.Fatalf("truncated immediate returned ok=%v err=%v", matched, decodeErr)
+	}
+	ripRelative := []byte{0x62, 0xf3, 0xfd, 0x48, 0x38, 0x05, 0, 0, 0, 0, 1}
+	if _, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(ripRelative, 64); !matched || decodeErr == nil {
+		t.Fatalf("RIP-relative encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	addressOverride := append([]byte{0x67}, valid...)
+	if _, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(addressOverride, 64); !matched || decodeErr == nil {
+		t.Fatalf("address-override encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	for _, op := range []Op{"VINSERTF32X4", "VINSERTF64X2", "VINSERTF32X8", "VINSERTF64X4", "VINSERTI32X4", "VINSERTI64X2", "VINSERTI32X8", "VINSERTI64X4"} {
+		vectorBits := byte(1)
+		if strings.HasSuffix(string(op), "X8") || strings.Contains(string(op), "64X4") {
+			vectorBits = 2
+		}
+		invalid := encodeX86RawEVEXPackedInsert(op, vectorBits, 0, false, 0, 0, 1, 0)
+		if _, _, matched, decodeErr := decodedX86EVEXPackedInsertInstruction(invalid, 32); !matched || decodeErr == nil {
+			t.Fatalf("386 %s encoding %x returned ok=%v err=%v", op, invalid, matched, decodeErr)
+		}
+	}
+}
+
+func TestTranslateX86RawEVEXPackedInsertTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			code := [][]byte{
+				encodeX86RawEVEXPackedInsert("VINSERTI64X2", 1, 3, true, 20, 20, 21, 1),
+			}
+			code = append(code,
+				[]byte{0x62, 0xf3, 0xfd, 0x48, 0x38, 0x47, 0x01, 0x01},
+				[]byte{0x62, 0x03, 0x15, 0xc3, 0x3a, 0x64, 0x8b, 0x02, 0xff},
+			)
+			var source strings.Builder
+			source.WriteString("TEXT raw_evex_packed_insert(SB),NOSPLIT,$0-0\n")
+			for _, instruction := range code {
+				for _, value := range instruction {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"raw_evex_packed_insert": {Name: "raw_evex_packed_insert", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-evex-packed-insert-"+target.name+".ll", "raw-evex-packed-insert-"+target.name+".o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_evex_madd.go b/amd64_raw_evex_madd.go
new file mode 100644
index 000000000..ca5bd7395
--- /dev/null
+++ b/amd64_raw_evex_madd.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// decodedX86EVEXPackedMADDInstruction covers the EVEX rows of Go's
+// _yvandnpd optab shared by VPMADDUBSW and VPMADDWD. Neither row permits
+// EVEX.b broadcasting, but both permit K masks and zeroing at X/Y/Z widths.
+func decodedX86EVEXPackedMADDInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86EVEXPackedMADDInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedMADDInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	op := map[[2]int]Op{
+		{1, 0xf5}: "VPMADDWD",
+		{2, 0x04}: "VPMADDUBSW",
+	}[[2]int{p.mapNumber, p.opcode}]
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed multiply-add: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.broadcast || p.addressOverride || p.vectorLength > 2 {
+		return fail("invalid EVEX fixed, width, broadcast, address, or vector-length bits")
+	}
+	// Both opcode-specific ISA rows are WIG. Full validated physical bytes,
+	// including mode32 masks, use the common private decoder producer.
+	return decodedX86BinaryVectorOperandsWithMemory(code, p, mode, op, 16, memory)
+}
diff --git a/amd64_raw_evex_madd_test.go b/amd64_raw_evex_madd_test.go
new file mode 100644
index 000000000..d183a6462
--- /dev/null
+++ b/amd64_raw_evex_madd_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXPackedMADD(op Op, width, mask, destination, first, second int, zeroing, memory bool) []byte {
+	opcode, opcodeMap := byte(0xf5), byte(1)
+	if op == "VPMADDUBSW" {
+		opcode, opcodeMap = 0x04, 2
+	}
+	p0 := byte((1-(destination>>3)&1)<<7 | (1-(first>>4)&1)<<6 |
+		(1-(first>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | int(opcodeMap))
+	p1 := byte(((^second)&15)<<3 | 0x05)
+	p2 := byte(width<<5 | (1-((second>>4)&1))<<3 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | first&7)
+	if memory {
+		modRM = byte(0x40 | (destination&7)<<3)
+		p0 = byte((1-(destination>>3)&1)<<7 | 0x60 | (1-(destination>>4)&1)<<4 | int(opcodeMap))
+	}
+	code := []byte{0x62, p0, p1, p2, opcode, modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawEVEXMADDSeBiShogunRegression(t *testing.T) {
+	// Go's assembler disassembles these bytes as VPMADDUBSW Z1, Z5, Z1.
+	code := []byte{0x62, 0xf2, 0x55, 0x48, 0x04, 0xc9, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "mulInt8 AVX512 VPMADDUBSW", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPMADDUBSW" ||
+		decoded[0].Args[0].Reg != "Z1" || decoded[0].Args[1].Reg != "Z5" ||
+		decoded[0].Args[2].Reg != "Z1" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawEVEXPackedMADDCompleteGoForms(t *testing.T) {
+	for _, op := range []Op{"VPMADDWD", "VPMADDUBSW"} {
+		for width := 0; width < 3; width++ {
+			vector := [...]string{"X", "Y", "Z"}[width]
+			for _, form := range []struct {
+				name        string
+				mask        int
+				zeroing     bool
+				memory      bool
+				destination int
+				first       int
+				second      int
+			}{
+				{name: "register", destination: 2, first: 3, second: 4},
+				{name: "high registers", destination: 18, first: 19, second: 20},
+				{name: "masked", mask: 3, destination: 2, first: 3, second: 4},
+				{name: "zeroing", mask: 7, zeroing: true, destination: 2, first: 3, second: 4},
+				{name: "memory", memory: true, destination: 2, second: 4},
+				{name: "zeroing memory", memory: true, mask: 5, zeroing: true, destination: 2, second: 4},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", op, vector, form.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawEVEXPackedMADD(
+						op, width, form.mask, form.destination, form.first, form.second, form.zeroing, form.memory,
+					)
+					got, length, ok, err := decodedX86EVEXPackedMADDInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := op
+					if form.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[1].String() != fmt.Sprintf("%s%d", vector, form.second) ||
+						got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s%d", vector, form.destination) {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+					if !form.memory && got.Args[0].String() != fmt.Sprintf("%s%d", vector, form.first) {
+						t.Fatalf("decode %x first source = %s", code, got.Args[0])
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXPackedMADDRIPLiteral(t *testing.T) {
+	for _, op := range []Op{"VPMADDWD", "VPMADDUBSW"} {
+		for width := 0; width < 3; width++ {
+			code := encodeX86RawEVEXPackedMADD(op, width, 1, 2, 0, 4, false, false)
+			code[5] = 0x15 // RIP-relative first source, destination 2.
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			literalWidth := 16 << width
+			for index := 0; index < literalWidth; index++ {
+				code = append(code, byte(index+1))
+			}
+			name := fmt.Sprintf("%s/width%d", op, width)
+			t.Run(name, func(t *testing.T) {
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || !got[0].x86RIPLiteral || len(got[0].x86RIPLiteralData) != literalWidth || got[0].Op != op {
+					t.Fatalf("decode %x = %+v", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXPackedMADDRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawEVEXPackedMADD("VPMADDUBSW", 2, 0, 2, 3, 4, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x10 }, // unsupported broadcast
+		func(code []byte) { code[3] |= 0x80 }, // zeroing without mask
+		func(code []byte) { code[3] |= 0x20 }, // reserved vector length
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86EVEXPackedMADDInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateX86RawEVEXPackedMADDLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawEVEXPackedMADD(SB),$0-0\n")
+			for _, op := range []Op{"VPMADDWD", "VPMADDUBSW"} {
+				for width := 0; width < 3; width++ {
+					for _, memory := range []bool{false, true} {
+						code := encodeX86RawEVEXPackedMADD(op, width, 0, 2, 3, 4, false, memory)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawEVEXPackedMADD": {Name: "rawEVEXPackedMADD", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-evex-madd.ll", "raw-evex-madd.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_evex_packed_broadcast_test.go b/amd64_raw_evex_packed_broadcast_test.go
new file mode 100644
index 000000000..9473f0b00
--- /dev/null
+++ b/amd64_raw_evex_packed_broadcast_test.go
@@ -0,0 +1,230 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXPackedBroadcast(op Op, vectorBits byte, mask int, zeroing, vectorSource bool, source, destination int) []byte {
+	opcode := byte(0)
+	width64 := false
+	if vectorSource {
+		switch op {
+		case "VPBROADCASTB":
+			opcode = 0x78
+		case "VPBROADCASTW":
+			opcode = 0x79
+		case "VPBROADCASTD":
+			opcode = 0x58
+		case "VPBROADCASTQ":
+			opcode = 0x59
+			width64 = true
+		}
+	} else {
+		switch op {
+		case "VPBROADCASTB":
+			opcode = 0x7a
+		case "VPBROADCASTW":
+			opcode = 0x7b
+		case "VPBROADCASTD":
+			opcode = 0x7c
+		case "VPBROADCASTQ":
+			opcode = 0x7c
+			width64 = true
+		}
+	}
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^source>>4)&1)<<6 |
+		byte((^source>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 2
+	p1 := byte(0x7d)
+	if width64 {
+		p1 |= 0x80
+	}
+	p2 := vectorBits<<5 | 0x08 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | destination&7<<3 | source&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedHasteEVEXBroadcast(t *testing.T) {
+	code := []byte{0x62, 0x52, 0xfd, 0x48, 0x7c, 0xf2}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "haste VPBROADCASTQ sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "VPBROADCASTQ R10, Z14"
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, want+" ") {
+		t.Fatalf("decoded %x as %#v, want %q", code, decoded, want)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedBroadcastCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, op := range []Op{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+		for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{
+				{},
+				{mask: 3},
+				{mask: 7, zeroing: true, suffix: ".Z"},
+			} {
+				for _, sourceKind := range []struct {
+					vector bool
+					count  int
+					prefix string
+				}{
+					{count: 16, prefix: "R"},
+					{vector: true, count: 32, prefix: "X"},
+				} {
+					for source := 0; source < sourceKind.count; source++ {
+						for destination := 0; destination < 32; destination++ {
+							code := encodeX86RawEVEXPackedBroadcast(op, byte(vectorBits), masking.mask, masking.zeroing, sourceKind.vector, source, destination)
+							got, length, ok, err := decodedX86VEXPackedBroadcastInstruction(code, 64)
+							args := []string{fmt.Sprintf("%s%d", sourceKind.prefix, source)}
+							if !sourceKind.vector {
+								args[0] = decodedX86RegisterNameForTest(source)
+							}
+							if masking.mask != 0 {
+								args = append(args, fmt.Sprintf("K%d", masking.mask))
+							}
+							args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+							want := string(op) + masking.suffix + " " + strings.Join(args, ", ")
+							if err != nil || !ok || length != len(code) || got.Raw != want {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 55296 {
+		t.Fatalf("covered %d EVEX packed-broadcast register encodings, want 55296", count)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedBroadcastMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x65, 0x62, 0x12, 0x7d, 0x2b, 0x58, 0x64, 0x8b, 0x20}
+	got, length, ok, err := decodedX86VEXPackedBroadcastInstruction(code, 64)
+	wantMemory := MemRef{Segment: GS, Base: "R11", Index: "R9", Scale: 4, Off: 128}
+	if err != nil || !ok || length != len(code) || got.Op != "VPBROADCASTD" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) || got.Args[1].String() != "K3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86RawEVEXPackedBroadcast("VPBROADCASTD", 0, 0, false, false, 0, 0)
+	for name, mutate := range map[string]func([]byte){
+		"W on byte":           func(code []byte) { code[2] |= 0x80; code[4] = 0x7a },
+		"used vvvv":           func(code []byte) { code[2] &^= 0x08 },
+		"used high vvvv":      func(code []byte) { code[3] &^= 0x08 },
+		"EVEX.b":              func(code []byte) { code[3] |= 0x10 },
+		"reserved length":     func(code []byte) { code[3] |= 0x60 },
+		"zero without mask":   func(code []byte) { code[3] |= 0x80 },
+		"GP high extension":   func(code []byte) { code[1] &^= 0x40 },
+		"GP opcode on memory": func(code []byte) { code[5] &^= 0xc0 },
+	} {
+		invalid := append([]byte(nil), valid...)
+		mutate(invalid)
+		if instruction, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	for _, invalid := range [][]byte{
+		{0x62},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2], valid[3], 0x77, valid[5]},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("unrelated encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+
+	ripRelative := []byte{0x62, 0xf2, 0x7d, 0x08, 0x58, 0x05, 0, 0, 0, 0}
+	if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(ripRelative, 64); !matched || decodeErr == nil {
+		t.Fatalf("RIP-relative encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	addressOverride := append([]byte{0x67}, valid...)
+	if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(addressOverride, 64); !matched || decodeErr == nil {
+		t.Fatalf("address-override encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	for name, invalid := range map[string][]byte{
+		"extended destination on 386": encodeX86RawEVEXPackedBroadcast("VPBROADCASTD", 0, 0, false, false, 0, 8),
+		"extended source on 386":      encodeX86RawEVEXPackedBroadcast("VPBROADCASTD", 0, 0, false, true, 8, 0),
+	} {
+		if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(invalid, 32); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x returned ok=%v err=%v", name, invalid, matched, decodeErr)
+		}
+	}
+	valid386 := encodeX86RawEVEXPackedBroadcast("VPBROADCASTD", 0, 0, false, false, 7, 7)
+	got, length, ok, err = decodedX86VEXPackedBroadcastInstruction(valid386, 32)
+	if err != nil || !ok || length != len(valid386) || got.Raw != "VPBROADCASTD DI, X7" {
+		t.Fatalf("386 base-register form decoded as %+v, length=%d ok=%v err=%v", got, length, ok, err)
+	}
+}
+
+func TestTranslateX86RawEVEXPackedBroadcastTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			code := [][]byte{
+				encodeX86RawEVEXPackedBroadcast("VPBROADCASTD", 0, 0, false, false, 0, 1),
+				encodeX86RawEVEXPackedBroadcast("VPBROADCASTB", 1, 1, true, true, 1, 2),
+			}
+			if target.goarch == "amd64" {
+				code = append(code, []byte{0x62, 0x52, 0xfd, 0x48, 0x7c, 0xf2})
+			}
+			var source strings.Builder
+			source.WriteString("TEXT raw_evex_packed_broadcast(SB),NOSPLIT,$0-0\n")
+			for _, instruction := range code {
+				for _, value := range instruction {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-evex-packed-broadcast-"+target.name+".ll", "raw-evex-packed-broadcast-"+target.name+".o", ir)
+
+			setup := "MOVL $19, AX\nMOVL $37, CX\nMOVL CX, X1\nKMOVW CX, K1\n"
+			if target.goarch == "amd64" {
+				setup += "MOVL $79, R10\n"
+			}
+			initialized := strings.Replace(source.String(), "\n", "\n"+setup, 1)
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+initialized)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, "func raw_evex_packed_broadcast()", target.goarch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized original raw broadcast sequence", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_raw_evex_packed_float_move_test.go b/amd64_raw_evex_packed_float_move_test.go
new file mode 100644
index 000000000..9ee8ff8bd
--- /dev/null
+++ b/amd64_raw_evex_packed_float_move_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawEVEXPackedFloatMoveCompleteGo127Family(t *testing.T) {
+	// Go 1.27's _yvmovapd table gives VMOVAPS/APD/UPS/UPD the same
+	// bidirectional X/Y/Z and K-masked EVEX forms in addition to the four
+	// legacy VEX rows. These LLVM-verified encodings cover every EVEX opcode,
+	// direction, vector width, mask mode, high-register field, and compressed
+	// disp8 addressing shape used by that table.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "aps x load masked", code: []byte{0x62, 0xf1, 0x7c, 0x09, 0x28, 0xc1}, want: "VMOVAPS X1, K1, X0"},
+		{name: "aps x store compressed disp8", code: []byte{0x62, 0xf1, 0x7c, 0x0a, 0x29, 0x50, 0x01}, want: "VMOVAPS X2, K2, 16(AX)"},
+		{name: "apd y high load masked", code: []byte{0x62, 0xa1, 0xfd, 0x29, 0x28, 0xe5}, want: "VMOVAPD Y21, K1, Y20"},
+		{name: "apd y store masked sib", code: []byte{0x62, 0x91, 0xfd, 0x2a, 0x29, 0x64, 0x88, 0x03}, want: "VMOVAPD Y4, K2, 96(R8)(R9*4)"},
+		{name: "apd z high load zeroing", code: []byte{0x62, 0xa1, 0xfd, 0xcb, 0x28, 0xe5}, want: "VMOVAPD.Z Z21, K3, Z20"},
+		{name: "ups z high load zeroing", code: []byte{0x62, 0x01, 0x7c, 0xcf, 0x10, 0xfe}, want: "VMOVUPS.Z Z30, K7, Z31"},
+		{name: "ups z store compressed disp8", code: []byte{0x62, 0xf1, 0x7c, 0x4e, 0x11, 0x7f, 0x07}, want: "VMOVUPS Z7, K6, 448(DI)"},
+		{name: "upd x load masked", code: []byte{0x62, 0xf1, 0xfd, 0x09, 0x10, 0xd3}, want: "VMOVUPD X3, K1, X2"},
+		{name: "upd x store compressed disp8", code: []byte{0x62, 0xf1, 0xfd, 0x0a, 0x11, 0x60, 0x02}, want: "VMOVUPD X4, K2, 32(AX)"},
+		{name: "ups y memory load zeroing sib", code: []byte{0x62, 0x91, 0x7c, 0xaa, 0x10, 0x64, 0x88, 0x03}, want: "VMOVUPS.Z 96(R8)(R9*4), K2, Y4"},
+		{name: "ups y high store masked", code: []byte{0x62, 0x41, 0x7c, 0x2b, 0x11, 0x4c, 0x24, 0x02}, want: "VMOVUPS Y25, K3, 64(R12)"},
+		{name: "upd z high store masked sib", code: []byte{0x62, 0x01, 0xfd, 0x4b, 0x11, 0x4c, 0x6c, 0x02}, want: "VMOVUPD Z25, K3, 128(R12)(R13*2)"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := decodeX86RawDirectives(rawX86Function(test.code), "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || !strings.HasPrefix(got.Instrs[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %#x as %#v, want %q", test.code, got.Instrs, test.want)
+			}
+		})
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT raw_evex_packed_float_move(SB),NOSPLIT,$0-0\n")
+	for _, test := range tests {
+		for _, value := range test.code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), "amd64", "x86_64-unknown-linux-gnu")
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-evex-packed-float-move.ll", "raw-evex-packed-float-move.o", ir)
+}
+
+func TestX86RawEVEXPackedFloatMoveReportedMinioInstruction(t *testing.T) {
+	code := []byte{0x62, 0xc1, 0x7c, 0x48, 0x10, 0x04, 0x09}
+	got, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Instrs) != 1 || !strings.HasPrefix(got.Instrs[0].Raw, "VMOVUPS 0(R9)(CX*1), Z16 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", got.Instrs)
+	}
+}
diff --git a/amd64_raw_evex_packed_integer_move_test.go b/amd64_raw_evex_packed_integer_move_test.go
new file mode 100644
index 000000000..7aaaa7bf1
--- /dev/null
+++ b/amd64_raw_evex_packed_integer_move_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawEVEXPackedIntegerMoveCompleteGo127Family(t *testing.T) {
+	// Go 1.27 gives VMOVDQA32/64 and VMOVDQU8/16/32/64 the same
+	// 12-row _yvmovdqa32 table: X/Y/Z, load/store, with and without a
+	// nonzero K mask. These LLVM-verified encodings exercise every opcode,
+	// both directions, every vector width, high registers, SIB addressing,
+	// zeroing, and EVEX compressed disp8 scaling.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "dqa32 x load", code: []byte{0x62, 0xf1, 0x7d, 0x08, 0x6f, 0xc1}, want: "VMOVDQA32 X1, X0"},
+		{name: "dqa32 x store compressed disp8", code: []byte{0x62, 0xf1, 0x7d, 0x08, 0x7f, 0x50, 0x01}, want: "VMOVDQA32 X2, 16(AX)"},
+		{name: "dqa64 y high load masked", code: []byte{0x62, 0xa1, 0xfd, 0x29, 0x6f, 0xe5}, want: "VMOVDQA64 Y21, K1, Y20"},
+		{name: "dqa64 y store masked sib", code: []byte{0x62, 0x91, 0xfd, 0x2a, 0x7f, 0x64, 0x88, 0x03}, want: "VMOVDQA64 Y4, K2, 96(R8)(R9*4)"},
+		{name: "dqu8 z high load zeroing", code: []byte{0x62, 0x01, 0x7f, 0xcf, 0x6f, 0xfe}, want: "VMOVDQU8.Z Z30, K7, Z31"},
+		{name: "dqu8 z store compressed disp8", code: []byte{0x62, 0xf1, 0x7f, 0x4e, 0x7f, 0x7f, 0x07}, want: "VMOVDQU8 Z7, K6, 448(DI)"},
+		{name: "dqu16 x load masked", code: []byte{0x62, 0xf1, 0xff, 0x09, 0x6f, 0xd3}, want: "VMOVDQU16 X3, K1, X2"},
+		{name: "dqu16 x store compressed disp8", code: []byte{0x62, 0xf1, 0xff, 0x0a, 0x7f, 0x60, 0x02}, want: "VMOVDQU16 X4, K2, 32(AX)"},
+		{name: "dqu32 y memory load zeroing sib", code: []byte{0x62, 0x91, 0x7e, 0xaa, 0x6f, 0x64, 0x88, 0x03}, want: "VMOVDQU32.Z 96(R8)(R9*4), K2, Y4"},
+		{name: "dqu32 y high store masked", code: []byte{0x62, 0x41, 0x7e, 0x2b, 0x7f, 0x4c, 0x24, 0x02}, want: "VMOVDQU32 Y25, K3, 64(R12)"},
+		{name: "dqu64 z high load masked", code: []byte{0x62, 0x01, 0xfe, 0x4f, 0x6f, 0xf7}, want: "VMOVDQU64 Z31, K7, Z30"},
+		{name: "dqu64 z high store masked sib", code: []byte{0x62, 0x01, 0xfe, 0x4b, 0x7f, 0x4c, 0x6c, 0x02}, want: "VMOVDQU64 Z25, K3, 128(R12)(R13*2)"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := decodeX86RawDirectives(rawX86Function(test.code), "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || !strings.HasPrefix(got.Instrs[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %#x as %#v, want %q", test.code, got.Instrs, test.want)
+			}
+		})
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT raw_evex_packed_integer_move(SB),NOSPLIT,$0-0\n")
+	for _, test := range tests {
+		for _, value := range test.code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), "amd64", "x86_64-unknown-linux-gnu")
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-evex-packed-integer-move.ll", "raw-evex-packed-integer-move.o", ir)
+}
+
+func TestX86RawEVEXPackedIntegerMoveReportedMinioSequence(t *testing.T) {
+	var code []byte
+	for register := byte(0); register < 8; register++ {
+		modRM := byte(0x07 | register<<3)
+		code = append(code, 0x62, 0xf1, 0x7e, 0x48, 0x6f, modRM)
+		if register != 0 {
+			code[len(code)-1] |= 0x40
+			code = append(code, register)
+		}
+	}
+	got, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Instrs) != 8 {
+		t.Fatalf("decoded minio sequence as %d instructions: %#v", len(got.Instrs), got.Instrs)
+	}
+	for index, instruction := range got.Instrs {
+		want := fmt.Sprintf("VMOVDQU32 %d(DI), Z%d", index*64, index)
+		if !strings.HasPrefix(instruction.Raw, want+" ") {
+			t.Fatalf("instruction %d = %q, want %q", index, instruction.Raw, want)
+		}
+	}
+}
+
+func TestX86RawEVEXPackedIntegerMoveZeroingRegisterStoreEncoding(t *testing.T) {
+	for _, spec := range []struct {
+		op Op
+		pp int
+		w  byte
+	}{{"VMOVDQA32", 1, 0}, {"VMOVDQA64", 1, 0x80}, {"VMOVDQU8", 3, 0}, {"VMOVDQU16", 3, 0x80}, {"VMOVDQU32", 2, 0}, {"VMOVDQU64", 2, 0x80}} {
+		for width, prefix := range []string{"X", "Y", "Z"} {
+			for src := 0; src < 32; src++ {
+				for dst := 0; dst < 32; dst++ {
+					code := encodeRawScalarMove(true, spec.pp, 0x11, src, 0, dst, 7, true)
+					code[2] = code[2]&0x7f | spec.w
+					code[3] |= byte(width) << 5
+					code[4] = 0x7f
+					got, size, matched, err := decodedX86EVEXPackedIntegerMoveInstruction(code, 64)
+					want := fmt.Sprintf("%s.Z %s%d, K7, %s%d", spec.op, prefix, src, prefix, dst)
+					if err != nil || !matched || size != len(code) || got.Raw != want {
+						t.Fatalf("decode %x=%q size=%d matched=%v err=%v, want %q", code, got.Raw, size, matched, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawEVEXPackedIntegerMoveRejectsInvalidEVEXForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{name: "broadcast bit", code: []byte{0x62, 0xf1, 0x7e, 0x58, 0x6f, 0xc1}},
+		{name: "zeroing without mask", code: []byte{0x62, 0xf1, 0x7e, 0xc8, 0x6f, 0xc1}},
+		{name: "zeroing store", code: []byte{0x62, 0xf1, 0x7e, 0x89, 0x7f, 0x08}},
+		{name: "reserved vector length", code: []byte{0x62, 0xf1, 0x7e, 0x68, 0x6f, 0xc1}},
+		{name: "address override", code: []byte{0x67, 0x62, 0xf1, 0x7e, 0x48, 0x6f, 0x07}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86EVEXPackedIntegerMoveInstruction(test.code, 64); !ok || err == nil {
+				t.Fatalf("decoded invalid encoding %#x with ok=%v err=%v", test.code, ok, err)
+			}
+		})
+	}
+}
+
+func rawX86Function(code []byte) Func {
+	fn := Func{}
+	for _, value := range code {
+		fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+	}
+	return fn
+}
diff --git a/amd64_raw_evex_packed_logical_test.go b/amd64_raw_evex_packed_logical_test.go
new file mode 100644
index 000000000..5d07749b1
--- /dev/null
+++ b/amd64_raw_evex_packed_logical_test.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXPackedLogical(op Op, vectorBits byte, mask int, zeroing, broadcast bool, first, second, destination int) []byte {
+	opcode := map[Op]byte{
+		"VPANDD":  0xdb,
+		"VPANDQ":  0xdb,
+		"VPANDND": 0xdf,
+		"VPANDNQ": 0xdf,
+		"VPORD":   0xeb,
+		"VPORQ":   0xeb,
+		"VPXORD":  0xef,
+		"VPXORQ":  0xef,
+	}[op]
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 1
+	p1 := byte(^second&15)<<3 | 5
+	if strings.HasSuffix(string(op), "Q") {
+		p1 |= 0x80
+	}
+	p2 := vectorBits<<5 | byte((^second>>4)&1)<<3 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedHasteEVEXPackedLogical(t *testing.T) {
+	code := []byte{0x62, 0xf1, 0xf5, 0x48, 0xef, 0xc9}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "haste VPXORQ sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "VPXORQ Z1, Z1, Z1"
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, want+" ") {
+		t.Fatalf("decoded %x as %#v, want %q", code, decoded, want)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedLogicalCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, op := range []Op{"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"} {
+		for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{
+				{},
+				{mask: 3},
+				{mask: 7, zeroing: true, suffix: ".Z"},
+			} {
+				for first := 0; first < 32; first++ {
+					for second := 0; second < 32; second++ {
+						for destination := 0; destination < 32; destination++ {
+							code := encodeX86RawEVEXPackedLogical(op, byte(vectorBits), masking.mask, masking.zeroing, false, first, second, destination)
+							got, length, ok, err := decodedX86EVEXPackedLogicalInstruction(code, 64)
+							args := []string{
+								fmt.Sprintf("%s%d", vectorName, first),
+								fmt.Sprintf("%s%d", vectorName, second),
+							}
+							if masking.mask != 0 {
+								args = append(args, fmt.Sprintf("K%d", masking.mask))
+							}
+							args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+							want := string(op) + masking.suffix + " " + strings.Join(args, ", ")
+							if err != nil || !ok || length != len(code) || got.Raw != want {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 2359296 {
+		t.Fatalf("covered %d EVEX packed-logical register encodings, want 2359296", count)
+	}
+}
+
+func TestDecodedX86RawEVEXPackedLogicalMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x62, 0x01, 0x95, 0xd3, 0xdb, 0x64, 0x8b, 0x20}
+	got, length, ok, err := decodedX86EVEXPackedLogicalInstruction(code, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 256}
+	if err != nil || !ok || length != len(code) || got.Op != "VPANDQ.BCST.Z" || len(got.Args) != 4 || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) || got.Args[1].String() != "Z29" || got.Args[2].String() != "K3" || got.Args[3].String() != "Z28" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86RawEVEXPackedLogical("VPXORD", 0, 0, false, false, 0, 1, 2)
+	for name, mutate := range map[string]func([]byte){
+		"missing EVEX fixed bit": func(code []byte) { code[2] &^= 0x04 },
+		"reserved length":        func(code []byte) { code[3] |= 0x60 },
+		"zero without mask":      func(code []byte) { code[3] |= 0x80 },
+		"broadcast register":     func(code []byte) { code[3] |= 0x10 },
+	} {
+		invalid := append([]byte(nil), valid...)
+		mutate(invalid)
+		if instruction, _, matched, decodeErr := decodedX86EVEXPackedLogicalInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	for _, invalid := range [][]byte{
+		{0x62},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2], valid[3], 0xee, valid[5]},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86EVEXPackedLogicalInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("unrelated encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	ripRelative := []byte{0x62, 0xf1, 0x75, 0x08, 0xef, 0x15, 0, 0, 0, 0}
+	if _, _, matched, decodeErr := decodedX86EVEXPackedLogicalInstruction(ripRelative, 64); !matched || decodeErr == nil {
+		t.Fatalf("RIP-relative encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	addressOverride := append([]byte{0x67}, valid...)
+	if _, _, matched, decodeErr := decodedX86EVEXPackedLogicalInstruction(addressOverride, 64); !matched || decodeErr == nil {
+		t.Fatalf("address-override encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	for name, invalid := range map[string][]byte{
+		"masked on 386":          encodeX86RawEVEXPackedLogical("VPXORD", 0, 1, false, false, 0, 1, 2),
+		"high Z first on 386":    encodeX86RawEVEXPackedLogical("VPXORD", 2, 0, false, false, 8, 1, 2),
+		"high Z second on 386":   encodeX86RawEVEXPackedLogical("VPXORD", 2, 0, false, false, 0, 8, 2),
+		"high Z destination 386": encodeX86RawEVEXPackedLogical("VPXORD", 2, 0, false, false, 0, 1, 8),
+	} {
+		if _, _, matched, decodeErr := decodedX86EVEXPackedLogicalInstruction(invalid, 32); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x returned ok=%v err=%v", name, invalid, matched, decodeErr)
+		}
+	}
+	valid386 := encodeX86RawEVEXPackedLogical("VPXORD", 1, 0, false, false, 29, 30, 31)
+	got, length, ok, err = decodedX86EVEXPackedLogicalInstruction(valid386, 32)
+	if err != nil || !ok || length != len(valid386) || got.Raw != "VPXORD Y29, Y30, Y31" {
+		t.Fatalf("386 high X/Y register form decoded as %+v, length=%d ok=%v err=%v", got, length, ok, err)
+	}
+}
+
+func TestTranslateX86RawEVEXPackedLogicalTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			first, second, destination := 29, 30, 31
+			if target.goarch == "386" {
+				// Only the physical low bank belongs to this object fixture.
+				// The original high-bank bytes remain a separate Context case.
+				first, second, destination = 5, 6, 7
+			}
+			code := [][]byte{
+				encodeX86RawEVEXPackedLogical("VPXORD", 1, 0, false, false, first, second, destination),
+			}
+			if target.goarch == "amd64" {
+				code = append(code,
+					[]byte{0x62, 0xf1, 0xf5, 0x48, 0xef, 0xc9},
+					[]byte{0x62, 0x01, 0x95, 0xd3, 0xdb, 0x64, 0x8b, 0x20},
+				)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT raw_evex_packed_logical(SB),NOSPLIT,$0-0\n")
+			for _, instruction := range code {
+				for _, value := range instruction {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			if target.goarch == "amd64" {
+				// This original includes a memory access with no address or
+				// mask input. Keep complete format objects and public Context.
+				ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+				compileLLVMToObject(t, llc, target.triple, "raw-evex-packed-logical-"+target.name+".ll", "raw-evex-packed-logical-"+target.name+".o", ir)
+				return
+			}
+			// The original mode32 body only discards a pure register XOR;
+			// it neither accesses native memory nor promises result bytes.
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func raw_evex_packed_logical()", target.goarch, target.triple, api)
+				if err != nil {
+					t.Fatal("original pure dead XOR acquired an unrelated input requirement", api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "raw-evex-packed-logical-"+target.name+".ll", "raw-evex-packed-logical-"+target.name+".o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawEVEXPackedLogicalMode32HighRegistersNeedContext(t *testing.T) {
+	checked := 0
+	for _, op := range []Op{"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"} {
+		for _, vectorBits := range []byte{0, 1} {
+			for _, position := range []int{0, 1, 2} {
+				for _, high := range []int{8, 15, 16, 31} {
+					registers := [3]int{0, 1, 2}
+					registers[position] = high
+					code := encodeX86RawEVEXPackedLogical(op, vectorBits, 0, false, false, registers[0], registers[1], registers[2])
+					var source strings.Builder
+					source.WriteString("TEXT raw_mode32_high(SB),4,$0-0\n")
+					for _, value := range code {
+						fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+					}
+					source.WriteString("RET\n")
+					requireX86GoAssemblerResult(t, "386", source.String(), true)
+					file, err := Parse(ArchAMD64, source.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err := Translate(file, Options{
+						Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+						Sigs: map[string]FuncSig{"raw_mode32_high": {Name: "raw_mode32_high", Ret: Void}},
+					})
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("raw mode32 high-bank bytes %x acquired an unproved physical binding: %v", code, err)
+					}
+					checked++
+				}
+			}
+		}
+	}
+	if checked != 192 {
+		t.Fatalf("checked %d raw mode32 high-bank cases, want 192", checked)
+	}
+}
diff --git a/amd64_raw_evex_qword.go b/amd64_raw_evex_qword.go
new file mode 100644
index 000000000..79aff5aca
--- /dev/null
+++ b/amd64_raw_evex_qword.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These complete EVEX-only qword families share physical field decoding,
+// not operand authority or their independent numerical and memory effects.
+func decodedX86EVEXQwordBinaryInstruction(code []byte, mode int, lookup bool) (instruction Instr, length int, ok bool, err error) {
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto evex
+		}
+	}
+
+evex:
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+6 || code[i] != 0x62 || code[i+1]&0x0f != 2 || code[i+2]&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	op := Op("")
+	switch code[i+4] {
+	case 0xb4:
+		if lookup {
+			return Instr{}, 0, false, nil
+		}
+		op = "VPMADD52LUQ"
+	case 0xb5:
+		if lookup {
+			return Instr{}, 0, false, nil
+		}
+		op = "VPMADD52HUQ"
+	case 0x83, 0x8f:
+		if !lookup {
+			return Instr{}, 0, false, nil
+		}
+		op = "VPMULTISHIFTQB"
+		if code[i+4] == 0x8f {
+			op = "VPSHUFBITQMB"
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if (p1&0x80 != 0) != (op != "VPSHUFBITQMB") {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match %s", op)
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if op == "VPSHUFBITQMB" && (zeroing || p2&0x10 != 0) {
+		return Instr{}, 0, true, fmt.Errorf("mask-result lookup has no zeroing or broadcast encoding")
+	}
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	if op == "VPSHUFBITQMB" && destinationNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("%w: unbound extended K destination field", ErrProbeNeedsContext)
+	}
+	if mode == 32 && (secondSourceNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = 8
+	}
+	firstSource, consumed, decodeErr := decodedX86EVEXRMOperand(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destinationName := vectorName
+	if op == "VPSHUFBITQMB" {
+		destinationName = "K"
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationName, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", "))}, modRMIndex + consumed, true, nil
+}
diff --git a/amd64_raw_evex_unpack.go b/amd64_raw_evex_unpack.go
new file mode 100644
index 000000000..d3444054f
--- /dev/null
+++ b/amd64_raw_evex_unpack.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawEVEXUnpackForm struct {
+	op             Op
+	w              bool
+	broadcastBytes int
+}
+
+// Go 1.27's eight EVEX integer interleave rows. Dword and QDQ sources may
+// use scalar-memory broadcast; byte and word rows may not.
+var x86RawEVEXUnpackForms = map[int]x86RawEVEXUnpackForm{
+	0x60: {op: "VPUNPCKLBW"},
+	0x61: {op: "VPUNPCKLWD"},
+	0x62: {op: "VPUNPCKLDQ", broadcastBytes: 4},
+	0x6c: {op: "VPUNPCKLQDQ", w: true, broadcastBytes: 8},
+	0x68: {op: "VPUNPCKHBW"},
+	0x69: {op: "VPUNPCKHWD"},
+	0x6a: {op: "VPUNPCKHDQ", broadcastBytes: 4},
+	0x6d: {op: "VPUNPCKHQDQ", w: true, broadcastBytes: 8},
+}
+
+func decodedX86EVEXPackedUnpackInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 1 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	form, recognized := x86RawEVEXUnpackForms[p.opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX packed unpack: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.w != form.w || p.addressOverride || p.vectorLength > 2 {
+		return fail("invalid EVEX fixed, element width, address, or vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if mode == 32 && p.mask != 0 {
+		return fail("386 mask form exceeds the Go assembler frontend's operand limit")
+	}
+	modRM := code[p.modRM]
+	if p.broadcast && (form.broadcastBytes == 0 || modRM>>6 == 3) {
+		return fail("broadcast requires an enabled scalar-memory row")
+	}
+	destinationNumber := int(modRM>>3&7) + p.r*8
+	if mode == 32 &&
+		(destinationNumber >= 8 || p.upper >= 8 ||
+			modRM>>6 == 3 && int(modRM&7)+p.b*8+p.x*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("%w: EVEX unpack high register has no proved physical mode32 binding", ErrProbeNeedsContext)
+	}
+	vector := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	disp8Scale := 16 << p.vectorLength
+	if p.broadcast {
+		disp8Scale = form.broadcastBytes
+	}
+	first, consumed, err := decodedX86EVEXRMOperand(
+		code[p.modRM:], mode, p.b, p.x, p.segment, vector, disp8Scale,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := form.op
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, destinationNumber))}
+	args := []Operand{first, second}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_evex_unpack_test.go b/amd64_raw_evex_unpack_test.go
new file mode 100644
index 000000000..7c09d5ae9
--- /dev/null
+++ b/amd64_raw_evex_unpack_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXUnpack(opcode, width, mask int, zeroing, broadcast, memory bool) []byte {
+	form := x86RawEVEXUnpackForms[opcode]
+	p1 := byte(0x5d) // EVEX.vvvv = source register 4, pp = 66.
+	if form.w {
+		p1 |= 0x80
+	}
+	p2 := byte(width<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // first register 3, destination register 2.
+	if memory {
+		modRM = 0x50 // disp8(AX), destination register 2.
+	}
+	code := []byte{0x62, 0xf1, p1, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawEVEXUnpackSeBiShogunRegression(t *testing.T) {
+	// Go's assembler disassembles these bytes as VPUNPCKHDQ Z2, Z3, Z7.
+	code := []byte{0x62, 0xf1, 0x65, 0x48, 0x6a, 0xfa, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "onesCountInt32 AVX512 VPUNPCKHDQ", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPUNPCKHDQ" ||
+		decoded[0].Args[0].Reg != "Z2" || decoded[0].Args[1].Reg != "Z3" ||
+		decoded[0].Args[2].Reg != "Z7" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawEVEXUnpackCompleteGoForms(t *testing.T) {
+	if len(x86RawEVEXUnpackForms) != 8 {
+		t.Fatalf("modeled %d EVEX unpack rows, want eight", len(x86RawEVEXUnpackForms))
+	}
+	for opcode, form := range x86RawEVEXUnpackForms {
+		for width := 0; width < 3; width++ {
+			vector := [...]string{"X", "Y", "Z"}[width]
+			for _, variant := range []struct {
+				name      string
+				mask      int
+				zeroing   bool
+				broadcast bool
+				memory    bool
+			}{
+				{name: "register"},
+				{name: "masked register", mask: 3},
+				{name: "memory", memory: true},
+				{name: "zeroing memory", mask: 7, zeroing: true, memory: true},
+				{name: "broadcast memory", broadcast: true, memory: true},
+				{name: "broadcast zero memory", broadcast: true, mask: 7, zeroing: true, memory: true},
+			} {
+				if variant.broadcast && form.broadcastBytes == 0 {
+					continue
+				}
+				name := fmt.Sprintf("%s/%s/%s", form.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawEVEXUnpack(opcode, width, variant.mask, variant.zeroing, variant.broadcast, variant.memory)
+					got, length, ok, err := decodedX86EVEXPackedUnpackInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := form.op
+					if variant.broadcast {
+						wantOp += ".BCST"
+					}
+					if variant.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[1].String() != vector+"4" ||
+						got.Args[len(got.Args)-1].String() != vector+"2" ||
+						!variant.memory && got.Args[0].String() != vector+"3" {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXUnpackRIPLiteral(t *testing.T) {
+	for opcode, form := range x86RawEVEXUnpackForms {
+		for width := 0; width < 3; width++ {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && form.broadcastBytes == 0 {
+					continue
+				}
+				code := encodeX86RawEVEXUnpack(opcode, width, 1, false, broadcast, false)
+				code[5] = 0x15 // RIP-relative first source, destination 2.
+				code = append(code, 1, 0, 0, 0, 0xc3)
+				literalWidth := 16 << width
+				if broadcast {
+					literalWidth = form.broadcastBytes
+				}
+				for index := 0; index < literalWidth; index++ {
+					code = append(code, byte(index+1))
+				}
+				name := fmt.Sprintf("%s/width%d/broadcast%t", form.op, width, broadcast)
+				t.Run(name, func(t *testing.T) {
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					wantOp := form.op
+					if broadcast {
+						wantOp += ".BCST"
+					}
+					if len(got) != 2 || !got[0].x86RIPLiteral ||
+						len(got[0].x86RIPLiteralData) != literalWidth || got[0].Op != wantOp {
+						t.Fatalf("decode %x = %+v", code, got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXUnpackRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawEVEXUnpack(0x6a, 2, 0, false, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[2] |= 0x80 }, // HDQ requires EVEX.W0
+		func(code []byte) { code[3] |= 0x80 }, // zeroing needs a mask
+		func(code []byte) { code[3] |= 0x10 }, // broadcast requires memory
+		func(code []byte) { code[3] |= 0x20 }, // reserved vector length
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86EVEXPackedUnpackInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	byteBroadcast := encodeX86RawEVEXUnpack(0x60, 2, 0, false, true, true)
+	if _, _, ok, err := decodedX86EVEXPackedUnpackInstruction(byteBroadcast, 64); !ok || err == nil {
+		t.Fatalf("accepted VPUNPCKLBW broadcast %x: ok=%v err=%v", byteBroadcast, ok, err)
+	}
+}
+
+func TestTranslateX86RawEVEXUnpackLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawEVEXUnpack(SB),$0-0\n")
+			for opcode, form := range x86RawEVEXUnpackForms {
+				for width := 0; width < 3; width++ {
+					for _, variant := range []struct {
+						memory, broadcast bool
+					}{
+						{}, {memory: true}, {memory: true, broadcast: true},
+					} {
+						if variant.broadcast && form.broadcastBytes == 0 {
+							continue
+						}
+						code := encodeX86RawEVEXUnpack(opcode, width, 0, false, variant.broadcast, variant.memory)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			// Operand formats do not initialize the original vector/address
+			// inputs. Keep public rejection separate from emitter objects.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-evex-unpack.ll", "raw-evex-unpack.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_expand_test.go b/amd64_raw_expand_test.go
new file mode 100644
index 000000000..dd7dce1be
--- /dev/null
+++ b/amd64_raw_expand_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawExpandForms = []struct {
+	opcode    int
+	widthBit  int
+	op        Op
+	laneBytes int
+}{
+	{0x62, 0, "VPEXPANDB", 1},
+	{0x62, 1, "VPEXPANDW", 2},
+	{0x88, 0, "VEXPANDPS", 4},
+	{0x88, 1, "VEXPANDPD", 8},
+	{0x89, 0, "VPEXPANDD", 4},
+	{0x89, 1, "VPEXPANDQ", 8},
+}
+
+func encodeX86RawExpand(opcode, widthBit, vectorBits, mask int, zeroing, memory bool) []byte {
+	p1 := byte(0x7d) // EVEX.vvvv is unused, pp = 66.
+	if widthBit != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xd3) // source register 3, destination register 2.
+	if memory {
+		modRM = 0x50 // disp8(AX) source, destination register 2.
+	}
+	code := []byte{0x62, 0xf2, p1, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawExpandSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VEXPANDPS.Z Z2, K1, Z3.
+	code := []byte{0x62, 0xf2, 0x7d, 0xc9, 0x88, 0xda, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "fastCumSumFloat32 VEXPANDPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VEXPANDPS.Z" ||
+		decoded[0].Args[0].Reg != "Z2" || decoded[0].Args[1].Reg != "K1" ||
+		decoded[0].Args[2].Reg != "Z3" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawExpandCompleteGoForms(t *testing.T) {
+	if len(x86RawExpandForms) != len(amd64PackedExpandSpecs) {
+		t.Fatalf("raw/lower expand grammar rows = %d/%d", len(x86RawExpandForms), len(amd64PackedExpandSpecs))
+	}
+	for _, form := range x86RawExpandForms {
+		for vectorBits, vector := range []string{"X", "Y", "Z"} {
+			for _, variant := range []struct {
+				name    string
+				mask    int
+				zeroing bool
+				memory  bool
+			}{
+				{name: "register"},
+				{name: "masked register", mask: 3},
+				{name: "zeroing register", mask: 7, zeroing: true},
+				{name: "memory", memory: true},
+				{name: "masked memory", mask: 1, memory: true},
+				{name: "zeroing memory", mask: 4, zeroing: true, memory: true},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", form.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawExpand(form.opcode, form.widthBit, vectorBits, variant.mask, variant.zeroing, variant.memory)
+					got, length, ok, err := decodedX86PackedExpandInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := form.op
+					if variant.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[len(got.Args)-1].String() != vector+"2" ||
+						!variant.memory && got.Args[0].String() != vector+"3" ||
+						variant.memory && got.Args[0].String() != fmt.Sprintf("%d(AX)", form.laneBytes) ||
+						len(got.Args) != 2+map[bool]int{true: 1}[variant.mask != 0] {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawExpandRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawExpand(0x88, 0, 2, 0, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x80 },  // zeroing without mask
+		func(code []byte) { code[3] |= 0x60 },  // reserved vector length
+		func(code []byte) { code[3] |= 0x10 },  // broadcast unavailable
+		func(code []byte) { code[2] &^= 0x08 }, // EVEX.vvvv is reserved
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86PackedExpandInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	badMode32 := encodeX86RawExpand(0x88, 0, 2, 1, false, false)
+	badMode32[1] &^= 0x80 // The destination field has no physical mode32 register.
+	if _, _, ok, err := decodedX86PackedExpandInstruction(badMode32, 32); !ok || err == nil {
+		t.Fatalf("accepted unbound mode32 destination bank: ok=%v err=%v", ok, err)
+	}
+}
+
+func TestTranslateX86RawExpandLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawExpand(SB),$0-0\n")
+			for _, form := range x86RawExpandForms {
+				for _, memory := range []bool{false, true} {
+					mask := 1
+					if target.goarch == "386" {
+						mask = 0
+					}
+					code := encodeX86RawExpand(form.opcode, form.widthBit, 0, mask, false, memory)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			// These original bytes do not establish numerical/native inputs.
+			// Preserve Go, public Context and emitter objects independently
+			// from the complete initialized raw public-object counterparts.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-expand.ll", "raw-expand.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_explicit_mask_move.go b/amd64_raw_explicit_mask_move.go
new file mode 100644
index 000000000..ff3ee6daa
--- /dev/null
+++ b/amd64_raw_explicit_mask_move.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+// Go 1.27's _yvmaskmovpd table describes the four VEX X/Y masked load/store
+// families. Opcode bit 1 selects store; W selects the D/Q integer lane.
+var x86RawExplicitMaskMoveOps = map[int]Op{
+	0x2c: "VMASKMOVPS",
+	0x2d: "VMASKMOVPD",
+	0x8c: "VPMASKMOVD",
+}
+
+func decodedX86ExplicitMaskMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.evex || p.mapNumber != 2 {
+		return Instr{}, 0, false, nil
+	}
+	// The floating store opcodes are 2E/2F; integer stores use 8E.
+	base := p.opcode &^ 2
+	op, known := x86RawExplicitMaskMoveOps[base]
+	if !known {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("explicit mask move: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.pp != 1 || p.vectorLength > 1 || p.w && base != 0x8c {
+		return fail("invalid VEX prefix or width")
+	}
+	if base == 0x8c && p.w {
+		op = "VPMASKMOVQ"
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if code[p.modRM]>>6 == 3 {
+		return fail("explicit mask move requires a memory operand")
+	}
+	width := "X"
+	if p.vectorLength == 1 {
+		width = "Y"
+	}
+	memory, consumed, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, int(code[p.modRM]>>3&7)+p.r*8))}
+	mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	args := []Operand{memory, mask, data}
+	if p.opcode&2 != 0 {
+		args = []Operand{data, mask, memory}
+	}
+	return Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s, %s, %s", op, args[0].String(), args[1].String(), args[2].String()),
+		x86Encoded: true,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_explicit_mask_move_test.go b/amd64_raw_explicit_mask_move_test.go
new file mode 100644
index 000000000..a063fbd19
--- /dev/null
+++ b/amd64_raw_explicit_mask_move_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawExplicitMaskMoveGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawmaskmoveforms(SB),4,$0-0\n")
+			for _, op := range []string{"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ"} {
+				for _, width := range []string{"X", "Y"} {
+					for _, reg := range []int{1, 7, 15} {
+						fmt.Fprintf(&source, "%s 8(AX), %s2, %s%d\n", op, width, width, reg)
+						fmt.Fprintf(&source, "%s %s%d, %s2, 16(BX)\n", op, width, reg, width)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for index, got := range decoded.Instrs {
+				if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+					t.Fatalf("instruction %d = %s %v, want %s %v", index, got.Op, got.Args, want[index].Op, want[index].Args)
+				}
+			}
+			if len(code) == 0 || code[len(code)-1] != 0xc3 {
+				t.Fatal("Go assembler did not end the fixture with RET")
+			}
+			var raw strings.Builder
+			raw.WriteString("TEXT rawmaskmoveforms(SB),4,$0-0\n")
+			for _, value := range code[:len(code)-1] {
+				fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+			}
+			raw.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, raw.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				signatures := map[string]FuncSig{"rawmaskmoveforms": {Name: "rawmaskmoveforms", Ret: Void}}
+				ir, err := Translate(file, Options{
+					Goarch: arch, TargetTriple: triple,
+					Sigs: signatures,
+				})
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original raw formats borrowed missing native address/data/mask inputs", err)
+				}
+				if arch == "386" {
+					// The decoder's exact original high-bank inventory stays above;
+					// physical mode32 success is owned by separate initialized
+					// low-bank named/raw objects, not by rewriting these bytes.
+					continue
+				}
+				normalized, err := normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir = x86ScalarFormatObjectUnit(t, normalized, signatures, arch, triple, 0)
+				compileLLVMToObject(t, llc, triple, "raw-explicit-mask-move.ll", "raw-explicit-mask-move.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawExplicitMaskMoveRejectsInvalidEncodings(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{name: "missing ModRM", code: []byte{0xc4, 0xa2, 0x69, 0x8e}},
+		{name: "register destination", code: []byte{0xc4, 0xe2, 0x69, 0x8e, 0xc1}},
+		{name: "wrong pp", code: []byte{0xc4, 0xa2, 0x68, 0x8e, 0x0c, 0x82}},
+		{name: "floating W1", code: []byte{0xc4, 0xe2, 0xe9, 0x2c, 0x01}},
+		{name: "address override", code: []byte{0x67, 0xc4, 0xa2, 0x69, 0x8e, 0x0c, 0x82}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, matched, err := decodedX86ExplicitMaskMoveInstruction(test.code, 64); !matched || err == nil {
+				t.Fatalf("invalid %x matched=%v error=%v", test.code, matched, err)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		{0xc4, 0xe3, 0x69, 0x8e, 0xc1},
+		{0x62, 0xe2, 0x69, 0x08, 0x8e, 0xc1},
+	} {
+		if _, _, matched, err := decodedX86ExplicitMaskMoveInstruction(code, 64); matched || err != nil {
+			t.Fatalf("other opcode %x matched=%v error=%v", code, matched, err)
+		}
+	}
+}
diff --git a/amd64_raw_far_return.go b/amd64_raw_far_return.go
new file mode 100644
index 000000000..1d07064c4
--- /dev/null
+++ b/amd64_raw_far_return.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// decodedX86FarReturn preserves the actual operand-size attribute before
+// x86asm.GoSyntax erases LRET's width or emits Intel's IRET/IRETD aliases.
+// In both 32- and 64-bit modes a bare far return has a 32-bit operand size;
+// only an effective REX.W promotes it to 64 bits. See Intel SDM volume 2,
+// RET and IRET/IRETD/IRETQ, and Go's shared x86 ynone/yret encoder rows.
+func decodedX86FarReturn(inst x86asm.Inst) (syntax string, recognized bool, err error) {
+	kind := amd64InterruptReturn
+	switch inst.Op {
+	case x86asm.LRET:
+		kind = amd64FarReturn
+	case x86asm.IRET:
+		if inst.DataSize != 16 {
+			return "", true, fmt.Errorf("raw IRET has inconsistent operand size %d", inst.DataSize)
+		}
+	case x86asm.IRETD:
+		if inst.DataSize != 32 {
+			return "", true, fmt.Errorf("raw IRETD has inconsistent operand size %d", inst.DataSize)
+		}
+	case x86asm.IRETQ:
+		if inst.DataSize != 64 {
+			return "", true, fmt.Errorf("raw IRETQ has inconsistent operand size %d", inst.DataSize)
+		}
+	default:
+		return "", false, nil
+	}
+	if (inst.Mode != 32 && inst.Mode != 64) || (inst.Mode == 32 && inst.DataSize == 64) {
+		return "", true, fmt.Errorf("raw %s operand size %d is not supported in mode %d", inst.Op, inst.DataSize, inst.Mode)
+	}
+	for _, prefix := range inst.Prefix {
+		if prefix == 0 {
+			continue
+		}
+		// Register only the size prefixes represented by the typed family.
+		// Never silently drop LOCK, REP, segment or address-size prefixes.
+		// Decoder-rejected prefix orderings remain explicit decode failures.
+		if prefix&x86asm.PrefixInvalid != 0 || (prefix&0xff != x86asm.PrefixDataSize && !prefix.IsREX()) {
+			return "", true, fmt.Errorf("raw %s has an invalid or unregistered prefix %s", inst.Op, prefix)
+		}
+		if prefix.IsREX() && inst.Mode != 64 {
+			return "", true, fmt.Errorf("raw %s has a REX prefix outside 64-bit mode", inst.Op)
+		}
+	}
+	for _, extra := range inst.Args[1:] {
+		if extra != nil {
+			return "", true, fmt.Errorf("raw %s has extra operands", inst.Op)
+		}
+	}
+	argument := ""
+	if inst.Args[0] != nil {
+		immediate, ok := inst.Args[0].(x86asm.Imm)
+		if kind != amd64FarReturn || !ok || immediate < 0 || immediate > 65535 {
+			return "", true, fmt.Errorf("raw %s requires no operand or an encoded unsigned imm16", inst.Op)
+		}
+		argument = fmt.Sprintf(" $%d", immediate)
+	}
+	for op, spec := range amd64FarReturnSpecs {
+		if spec.kind == kind && spec.bits == inst.DataSize {
+			return string(op) + argument, true, nil
+		}
+	}
+	return "", true, fmt.Errorf("raw %s has unregistered operand size %d", inst.Op, inst.DataSize)
+}
diff --git a/amd64_raw_far_return_test.go b/amd64_raw_far_return_test.go
new file mode 100644
index 000000000..0b3e61679
--- /dev/null
+++ b/amd64_raw_far_return_test.go
@@ -0,0 +1,408 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86FarReturnGrammarMatchesActualGoRows(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go")
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := make(map[Op]amd64FarReturnSpec)
+	ast.Inspect(file, func(node ast.Node) bool {
+		row, ok := node.(*ast.CompositeLit)
+		if !ok || len(row.Elts) == 0 {
+			return true
+		}
+		name, ok := row.Elts[0].(*ast.Ident)
+		if !ok || (!strings.HasPrefix(name.Name, "AIRET") && !strings.HasPrefix(name.Name, "ARETF")) {
+			return true
+		}
+		if len(row.Elts) != 4 {
+			t.Fatalf("unrecognized actual Go far-return opcode row %s", name.Name)
+		}
+		operands, ok := row.Elts[1].(*ast.Ident)
+		if !ok || (operands.Name != "ynone" && operands.Name != "yret") {
+			t.Fatalf("unrecognized actual Go far-return operand row: %#v", row.Elts[1])
+		}
+		prefix, ok := row.Elts[2].(*ast.Ident)
+		if !ok {
+			t.Fatalf("unrecognized actual Go far-return prefix: %#v", row.Elts[2])
+		}
+		bits := map[string]int{"Pe": 16, "Px": 32, "Pw": 64}[prefix.Name]
+		if bits == 0 {
+			t.Fatalf("unrecognized actual Go far-return width prefix %s", prefix.Name)
+		}
+		kind := amd64InterruptReturn
+		if operands.Name == "yret" {
+			kind = amd64FarReturn
+		}
+		want[Op(strings.TrimPrefix(name.Name, "A"))] = amd64FarReturnSpec{
+			kind: kind, bits: bits, allowImmediate: operands.Name == "yret",
+		}
+		return false
+	})
+	if len(want) != len(amd64FarReturnSpecs) {
+		t.Fatalf("actual Go rows %v do not match typed inventory %v", want, amd64FarReturnSpecs)
+	}
+	for op, expected := range want {
+		spec, ok := amd64FarReturnSpecs[op]
+		if !ok || spec != expected {
+			t.Fatalf("actual Go %s spec=%+v is missing or differs", op, expected)
+		}
+	}
+	// The row names alone are not operand completeness: audit both entire
+	// referenced ytabs, including the operand-free RETF and imm16 truncation.
+	seen := make(map[string]bool)
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || (value.Names[0].Name != "ynone" && value.Names[0].Name != "yret") {
+			return true
+		}
+		name := value.Names[0].Name
+		if len(value.Values) != 1 {
+			t.Fatalf("unrecognized %s initializer", name)
+		}
+		table, ok := value.Values[0].(*ast.CompositeLit)
+		if !ok {
+			t.Fatalf("unrecognized %s table", name)
+		}
+		classes := make(map[string]bool)
+		for _, element := range table.Elts {
+			row, ok := element.(*ast.CompositeLit)
+			if !ok || len(row.Elts) != 3 {
+				t.Fatalf("unrecognized %s operand row", name)
+			}
+			operands, ok := row.Elts[2].(*ast.CompositeLit)
+			if !ok || len(operands.Elts) > 1 {
+				t.Fatalf("unrecognized %s argument list", name)
+			}
+			class := "none"
+			if len(operands.Elts) == 1 {
+				identifier, ok := operands.Elts[0].(*ast.Ident)
+				if !ok {
+					t.Fatalf("unrecognized %s argument class", name)
+				}
+				class = identifier.Name
+			}
+			if classes[class] {
+				t.Fatalf("duplicate %s argument class %s", name, class)
+			}
+			classes[class] = true
+		}
+		wantCount := 1
+		if name == "yret" {
+			wantCount = 2
+		}
+		if len(classes) != wantCount || !classes["none"] || (name == "yret" && !classes["Yi32"]) {
+			t.Fatalf("actual Go %s forms changed: %v", name, classes)
+		}
+		seen[name] = true
+		return false
+	})
+	if len(seen) != 2 {
+		t.Fatal("actual Go far-return operand tables were not both observed")
+	}
+}
+
+func TestX86RawFarReturnPrefixAndModeAxes(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		mode int
+		code []byte
+		want string
+	}{
+		{name: "bare-386", mode: 32, code: []byte{0xcb}, want: "RETFL"},
+		{name: "bare-amd64", mode: 64, code: []byte{0xcb}, want: "RETFL"},
+		{name: "operand-386", mode: 32, code: []byte{0x66, 0xcb}, want: "RETFW"},
+		{name: "operand-amd64", mode: 64, code: []byte{0x66, 0xcb}, want: "RETFW"},
+		{name: "rex-without-w", mode: 64, code: []byte{0x47, 0xcb}, want: "RETFL"},
+		{name: "rex-w", mode: 64, code: []byte{0x4f, 0xcb}, want: "RETFQ"},
+		{name: "rex-w-overrides-66", mode: 64, code: []byte{0x66, 0x48, 0xcb}, want: "RETFQ"},
+		{name: "repeated-operand", mode: 64, code: []byte{0x66, 0x66, 0xcf}, want: "IRETW"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			inst, err := x86asm.Decode(test.code, test.mode)
+			if err != nil || inst.Len != len(test.code) {
+				t.Fatalf("actual decoder: %+v %v", inst, err)
+			}
+			got, err := decodedX86GoSyntax(inst, test.code)
+			if err != nil || got != test.want {
+				t.Fatalf("actual prefixes %+v DataSize%d: %q %v, want %q", inst.Prefix, inst.DataSize, got, err, test.want)
+			}
+		})
+	}
+	// 48 is an actual DEC opcode in 32-bit mode. Never treat the same
+	// byte string as an unsupported 64-bit far return in that mode.
+	decoded, err := decodeX86RawDirectiveGroup([]byte{0x48, 0xcb}, 32, 0, "32-bit DEC then far return", nil)
+	if err != nil || len(decoded) != 2 || decoded[0].Op != "DECL" || decoded[1].Op != "RETFL" {
+		t.Fatalf("32-bit 48 CB changed instruction boundaries: %+v %v", decoded, err)
+	}
+	decoded, err = decodeX86RawDirectiveGroup([]byte{0x48, 0x66, 0xcb}, 32, 0, "32-bit DEC then 16-bit far return", nil)
+	if err != nil || len(decoded) != 2 || decoded[0].Op != "DECL" || decoded[1].Op != "RETFW" {
+		t.Fatalf("32-bit 48 66 CB changed instruction boundaries: %+v %v", decoded, err)
+	}
+}
+
+func TestX86RawFarReturnRejectsUnprovedForms(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xf0, 0xcb}, {0xf0, 0xcf}, {0xf2, 0xcb}, {0xf3, 0xcf},
+		{0x67, 0xcb}, {0x64, 0xcf}, // Not a registered width-only prefix.
+		{0xca}, {0xca, 0x01}, {0x66}, {0x48},
+		{0x48, 0x66, 0xcb}, // Pinned decoder rejects nonadjacent REX.
+	} {
+		for _, mode := range []int{32, 64} {
+			if mode == 32 && code[0] == 0x48 {
+				continue // Valid DEC, not a REX prefix or prefix ordering.
+			}
+			_, err := decodeX86RawDirectiveGroup(code, mode, 0, "invalid or unregistered raw far return", nil)
+			if err == nil {
+				t.Errorf("accepted unproved %x mode%d", code, mode)
+			}
+		}
+	}
+	for _, inst := range []x86asm.Inst{
+		{Op: x86asm.LRET, Mode: 16, DataSize: 16},
+		{Op: x86asm.LRET, Mode: 32, DataSize: 64},
+		{Op: x86asm.LRET, Mode: 64, DataSize: 8},
+		{Op: x86asm.IRETQ, Mode: 64, DataSize: 32},
+		{Op: x86asm.IRETD, Mode: 64, DataSize: 16},
+		{Op: x86asm.LRET, Mode: 64, DataSize: 32, Args: x86asm.Args{x86asm.Imm(-1)}},
+		{Op: x86asm.LRET, Mode: 64, DataSize: 32, Args: x86asm.Args{x86asm.Imm(65536)}},
+		{Op: x86asm.LRET, Mode: 64, DataSize: 32, Args: x86asm.Args{x86asm.EAX}},
+		{Op: x86asm.LRET, Mode: 64, DataSize: 32, Args: x86asm.Args{nil, x86asm.Imm(1)}},
+		{Op: x86asm.IRETD, Mode: 64, DataSize: 32, Args: x86asm.Args{x86asm.Imm(1)}},
+	} {
+		if got, err := decodedX86GoSyntax(inst, nil); err == nil {
+			t.Errorf("accepted inconsistent raw form %+v as %q", inst, got)
+		}
+	}
+}
+
+func TestX86FarReturnRejectsFloatingAndWidthlessOperands(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		instructions := []string{"LRET", "LRET $4", "RETFL $unknown"}
+		for op := range amd64FarReturnSpecs {
+			for _, argument := range []string{"$0.0", "$-0.0", "$1.5", "$-1.5"} {
+				instructions = append(instructions, string(op)+" "+argument)
+			}
+		}
+		for _, instruction := range instructions {
+			source := "TEXT bad(SB),516,$0-0\n" + instruction + "\n"
+			requireX86GoAssemblerResult(t, arch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				continue
+			}
+			if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Errorf("accepted %s %q outside actual Go integer/width grammar", arch, instruction)
+			}
+		}
+	}
+}
+
+func TestX86RawFarReturnRetainsDecodedWidthAndImmediate(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, width := range []struct {
+			bits   int
+			prefix []byte
+			suffix string
+		}{
+			{bits: 16, prefix: []byte{0x66}, suffix: "W"},
+			{bits: 32, suffix: "L"},
+			{bits: 64, prefix: []byte{0x48}, suffix: "Q"},
+		} {
+			if mode == 32 && width.bits == 64 {
+				continue // 48 is DEC in 32-bit mode, not a width prefix.
+			}
+			for _, form := range []struct {
+				name string
+				code []byte
+				args string
+			}{
+				{name: "IRET", code: []byte{0xcf}},
+				{name: "RETF", code: []byte{0xcb}},
+				{name: "RETF", code: []byte{0xca, 0x00, 0x00}, args: " $0"},
+				{name: "RETF", code: []byte{0xca, 0x34, 0x12}, args: " $4660"},
+				{name: "RETF", code: []byte{0xca, 0xff, 0xff}, args: " $65535"},
+			} {
+				code := append(append([]byte(nil), width.prefix...), form.code...)
+				inst, err := x86asm.Decode(code, mode)
+				if err != nil || inst.Len != len(code) || inst.DataSize != width.bits {
+					t.Fatalf("actual decoder %x mode%d: %+v %v", code, mode, inst, err)
+				}
+				want := form.name + width.suffix + form.args
+				got, err := decodedX86GoSyntax(inst, code)
+				if err != nil || got != want {
+					t.Errorf("%x mode%d DataSize%d: got %q %v, want %q", code, mode, inst.DataSize, got, err, want)
+				}
+				decoded, err := decodeX86RawDirectiveGroup(code, mode, 0, "raw far-return bytes", nil)
+				if err != nil || len(decoded) != 1 || string(decoded[0].Op) != form.name+width.suffix {
+					t.Errorf("whole raw group %x mode%d: %+v %v", code, mode, decoded, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawFarReturnCompleteFiveTargetObjectsMatchGo(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, target := range []struct{ os, arch, triple string }{
+		{os: "darwin", arch: "amd64", triple: "x86_64-apple-darwin"},
+		{os: "linux", arch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{os: "windows", arch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{os: "linux", arch: "386", triple: "i386-unknown-linux-gnu"},
+		{os: "windows", arch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var rawSource strings.Builder
+			sigs := make(map[string]FuncSig)
+			wantBytes := make(map[string][]byte)
+			for op, spec := range amd64FarReturnSpecs {
+				if target.arch == "386" && spec.bits == 64 {
+					continue
+				}
+				forms := []amd64FarReturnForm{{}}
+				if spec.allowImmediate {
+					for _, value := range []uint16{0, 1, 0x1234, 0xffff} {
+						forms = append(forms, amd64FarReturnForm{hasImmediate: true, immediate: value})
+					}
+				}
+				for _, form := range forms {
+					name := fmt.Sprintf("far_%s_%t_%d", op, form.hasImmediate, form.immediate)
+					prefix := []byte(nil)
+					if spec.bits == 16 {
+						prefix = []byte{0x66}
+					} else if spec.bits == 64 {
+						prefix = []byte{0x48}
+					}
+					code := append(prefix, byte(0xcb))
+					if spec.kind == amd64InterruptReturn {
+						code[len(code)-1] = 0xcf
+					} else if form.hasImmediate {
+						code[len(code)-1] = 0xca
+						code = append(code, byte(form.immediate), byte(form.immediate>>8))
+					}
+					raw := fmt.Sprintf("TEXT %s(SB),516,$0-0\n", name)
+					for _, value := range code {
+						raw += fmt.Sprintf("BYTE $0x%02x\n", value)
+					}
+					named := fmt.Sprintf("TEXT %s(SB),516,$0-0\n%s", name, op)
+					if form.hasImmediate {
+						named += fmt.Sprintf(" $%d", form.immediate)
+					}
+					named += "\n"
+					// Independently authenticate the raw and canonical named
+					// encodings with Go, not merely the LLVM assembly spelling.
+					for _, source := range []string{raw, named} {
+						dir := t.TempDir()
+						path := filepath.Join(dir, "far.s")
+						if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+							t.Fatal(err)
+						}
+						command := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "far.o"), path)
+						command.Env = append(os.Environ(), "GOOS="+target.os, "GOARCH="+target.arch, "GOTOOLCHAIN=local")
+						output, err := command.CombinedOutput()
+						parts := make([]string, len(code))
+						for i, value := range code {
+							parts[i] = fmt.Sprintf("%02x", value)
+						}
+						want := regexp.MustCompile(`(?m)^\s*0x0000 ` + strings.Join(parts, " ") + `(?:\s|$)`)
+						if err != nil || !want.Match(output) {
+							t.Fatalf("original Go bytes %x: %v\n%s\n%s", code, err, source, output)
+						}
+					}
+					rawSource.WriteString(raw)
+					sigs[name] = FuncSig{Name: name, Ret: Void}
+					wantBytes[name] = code
+				}
+			}
+			file, err := Parse(ArchAMD64, rawSource.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for op, spec := range amd64FarReturnSpecs {
+				if target.arch == "386" && spec.bits == 64 {
+					continue
+				}
+				if !strings.Contains(ir, spec.encoding(amd64FarReturnForm{})) {
+					t.Errorf("raw %s lost typed byte lowering", op)
+				}
+			}
+			if strings.Count(ir, "unreachable") != len(sigs) {
+				t.Fatal("raw far return lost terminal control semantics")
+			}
+			requireX86RawFarReturnObjectBytes(t, llc, target.triple, ir, wantBytes)
+		})
+	}
+}
+
+func requireX86RawFarReturnObjectBytes(t *testing.T, llc, triple, ir string, want map[string][]byte) {
+	t.Helper()
+	objdump := findLLVM22Tool("llvm-objdump")
+	if objdump == "" {
+		t.Fatal("LLVM22 llvm-objdump is required")
+	}
+	dir := t.TempDir()
+	llPath := filepath.Join(dir, "far.ll")
+	object := filepath.Join(dir, "far.o")
+	if err := os.WriteFile(llPath, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	output, err := exec.Command(llc, "-O0", "-mtriple="+triple, "-filetype=obj", llPath, "-o", object).CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM22 object: %v\n%s", err, output)
+	}
+	output, err = exec.Command(objdump, "-d", object).CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM22 disassembly: %v\n%s", err, output)
+	}
+	// Match each terminal instruction's complete bytes inside its own symbol,
+	// not merely a coincidental sequence in another function or an IR string.
+	sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?(far_[^>]+)>:\n`).FindAllSubmatchIndex(output, -1)
+	seen := make(map[string]bool)
+	for index, section := range sections {
+		name := string(output[section[2]:section[3]])
+		code, ok := want[name]
+		if !ok {
+			t.Fatalf("unexpected emitted far-return symbol %s", name)
+		}
+		end := len(output)
+		if index+1 < len(sections) {
+			end = sections[index+1][0]
+		}
+		parts := make([]string, len(code))
+		for i, value := range code {
+			parts[i] = fmt.Sprintf("%02x", value)
+		}
+		instruction := regexp.MustCompile(`(?m)^\s*[0-9a-f]+:\s+` + strings.Join(parts, " ") + `\s+(?:iret|lret)`)
+		if !instruction.Match(output[section[1]:end]) {
+			t.Fatalf("LLVM22 symbol %s lacks exact terminal bytes %x:\n%s", name, code, output[section[1]:end])
+		}
+		seen[name] = true
+	}
+	if len(seen) != len(want) {
+		t.Fatalf("LLVM22 object contains %d/%d authenticated far-return symbols", len(seen), len(want))
+	}
+}
diff --git a/amd64_raw_float_logical_literal_test.go b/amd64_raw_float_logical_literal_test.go
new file mode 100644
index 000000000..6e966888d
--- /dev/null
+++ b/amd64_raw_float_logical_literal_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawFloatLogicalLiteral(opcode, pp byte, vex3 bool, width int) []byte {
+	code := encodeX86VEXPackedFloatLogical(opcode, pp, vex3, width == 32, false, 1, 2, 0)
+	code[len(code)-1] = 0x0d // RIP+disp32 rather than X0; destination stays X/Y1.
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*13+5))
+	}
+	return code
+}
+
+func TestDecodeX86RawFloatLogicalRIPDataCompleteVEXFamily(t *testing.T) {
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			for _, vex3 := range []bool{false, true} {
+				for _, width := range []int{16, 32} {
+					name := fmt.Sprintf("%s%s/vex3%t/%d", stem, suffix, vex3, width)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawFloatLogicalLiteral(opcode, pp, vex3, width)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded) != 2 || decoded[0].Op != Op(stem+suffix) ||
+							len(decoded[0].Args) != 3 || decoded[0].Args[0].Kind != OpSym ||
+							!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s%s source-local data", code, decoded, stem, suffix)
+						}
+						if !bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-width:]) {
+							t.Fatalf("source-local data = %x, want %x", decoded[0].x86RIPLiteralData, code[len(code)-width:])
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawFloatLogicalRIPDataRejectsUnsafeSources(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte {
+			code[5] = 127
+			return code
+		},
+		"overlapping instruction": func(code []byte) []byte {
+			code[5] = 0
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawFloatLogicalLiteral(0x57, 1, true, 32))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe floating logical RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawFloatLogicalRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			name := fmt.Sprintf("literal%s%s", stem, suffix)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range x86RawFloatLogicalLiteral(opcode, pp, true, 32) {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-float-logical-literal.ll", "raw-float-logical-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_fma3_literal_test.go b/amd64_raw_fma3_literal_test.go
new file mode 100644
index 000000000..5713e0539
--- /dev/null
+++ b/amd64_raw_fma3_literal_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86FMA3Opcodes() []byte {
+	opcodes := make([]byte, 0, len(decodedX86VEXFMA3Ops))
+	for opcode := range decodedX86VEXFMA3Ops {
+		opcodes = append(opcodes, opcode)
+	}
+	sort.Slice(opcodes, func(i, j int) bool { return opcodes[i] < opcodes[j] })
+	return opcodes
+}
+
+func x86RawFMA3Literal(opcode byte, width64, evex bool, width int, broadcast bool) []byte {
+	spec := decodedX86VEXFMA3Ops[opcode]
+	var code []byte
+	if evex {
+		code = encodeX86EVEXFMA3(opcode, width64, byte(map[int]int{16: 0, 32: 1, 64: 2}[width]), broadcast, true, 7, 0, 0, 0)
+	} else {
+		code = encodeX86VEXFMA3(opcode, width64, width == 32, 0, 0, 0)
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if spec.scalar || broadcast {
+		dataWidth = 4
+		if width64 {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*31+13))
+	}
+	return code
+}
+
+func TestDecodeX86RawFMA3RIPDataCompleteFamily(t *testing.T) {
+	for _, opcode := range x86FMA3Opcodes() {
+		spec := decodedX86VEXFMA3Ops[opcode]
+		for _, width64 := range []bool{false, true} {
+			for _, evex := range []bool{false, true} {
+				widths := []int{16, 32}
+				if evex {
+					widths = append(widths, 64)
+				}
+				if spec.scalar {
+					widths = []int{16}
+				}
+				for _, width := range widths {
+					broadcasts := []bool{false}
+					if evex && !spec.scalar {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						name := fmt.Sprintf("%s/evex%t/%d/bcst%t", spec.op(width64), evex, width, broadcast)
+						t.Run(name, func(t *testing.T) {
+							code := x86RawFMA3Literal(opcode, width64, evex, width, broadcast)
+							decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+							if err != nil {
+								t.Fatal(err)
+							}
+							want := spec.op(width64)
+							if broadcast {
+								want += ".BCST"
+							}
+							if evex {
+								want += ".Z"
+							}
+							if len(decoded) != 2 || decoded[0].Op != want ||
+								decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+								decoded[1].Op != OpRET {
+								t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawFMA3RIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawFMA3Literal(0xb8, false, true, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawFMA3RIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, opcode := range x86FMA3Opcodes() {
+		spec := decodedX86VEXFMA3Ops[opcode]
+		width64 := index%2 == 0
+		evex := index%3 == 0
+		width := 32
+		if spec.scalar {
+			width = 16
+		} else if evex {
+			width = 64
+		}
+		broadcast := evex && !spec.scalar
+		code := x86RawFMA3Literal(opcode, width64, evex, width, broadcast)
+		name := fmt.Sprintf("fma3Literal%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		dataWidth := width
+		if spec.scalar || broadcast {
+			dataWidth = 4
+			if width64 {
+				dataWidth = 8
+			}
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Preserve the entire original raw RET and DATA directory as actual
+			// Go objects plus three-API Context: it has no vector/mask inputs.
+			// TestX86RawFMA3InitializedRIPWholeSourceAndRawReturn separately
+			// owns all 60 genuinely initialized public RIP counterparts.
+			x86UnboundVoidFormatSources(t, source.String(), "amd64", triple)
+			ir := x86ScalarFormatObjectUnit(t, normalized, sigs, "amd64", triple, 0)
+			for _, function := range normalized.Funcs {
+				for _, instruction := range function.Instrs {
+					form, known, err := amd64FMA3Properties(instruction, "amd64")
+					if !known {
+						continue
+					}
+					if err != nil {
+						t.Fatal("original RIP format lost its physical operand grammar", err)
+					}
+					mnemonic, _, _ := strings.Cut(strings.ToLower(string(instruction.Op)), ".")
+					x86RawFMA3RequireOriginalNativeFormat(t, ir, mnemonic, form.byteWidth, form.memoryBytes,
+						x86FMA3NativeEVEX(instruction, form))
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "fma3-literal.ll", "fma3-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_fp16_binary_test.go b/amd64_raw_fp16_binary_test.go
new file mode 100644
index 000000000..af05ca28e
--- /dev/null
+++ b/amd64_raw_fp16_binary_test.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var rawFP16BinaryOpcodes = map[byte]Op{
+	0x58: "VADDPH",
+	0x59: "VMULPH",
+	0x5c: "VSUBPH",
+	0x5d: "VMINPH",
+	0x5e: "VDIVPH",
+	0x5f: "VMAXPH",
+}
+
+func encodeRawFP16Binary(opcode, width byte, source1, source2, destination, mask int, memory, broadcast, zero bool) []byte {
+	code := encodeX86EVEXBinaryFloat(opcode, 0, width, broadcast, zero, mask, destination, source1, source2)
+	code[1] = code[1]&^byte(0x0f) | 5
+	if memory {
+		code[5] = byte(0x40 | (destination&7)<<3)
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeRawFP16BinaryGoATReproduction(t *testing.T) {
+	// VADDPH 64(SI)(R8*2), Z1, Z1 from go-highway's GoAT output.
+	code := []byte{0x62, 0xb5, 0x74, 0x48, 0x58, 0x4c, 0x46, 0x01}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "GoAT VADDPH", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VADDPH" {
+		t.Fatalf("decoded %#v, want one VADDPH", decoded)
+	}
+}
+
+func TestDecodeRawFP16BinaryCompleteForms(t *testing.T) {
+	for opcode, baseOp := range rawFP16BinaryOpcodes {
+		for width := byte(0); width < 3; width++ {
+			for _, memory := range []bool{false, true} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && !memory {
+						continue
+					}
+					for _, masked := range []bool{false, true} {
+						mask := 0
+						if masked {
+							mask = 3
+						}
+						for _, zero := range []bool{false, true} {
+							if zero && !masked {
+								continue
+							}
+							code := encodeRawFP16Binary(opcode, width, 20, 21, 22, mask, memory, broadcast, zero)
+							got, length, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("%x: decoded %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							wantOp := baseOp
+							if broadcast {
+								wantOp += ".BCST"
+							}
+							if zero {
+								wantOp += ".Z"
+							}
+							prefix := [...]string{"X", "Y", "Z"}[width]
+							if got.Op != wantOp || !got.x86Encoded ||
+								got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s22", prefix) ||
+								got.Args[1].String() != fmt.Sprintf("%s20", prefix) {
+								t.Fatalf("%x: decoded %+v, want %s on %s", code, got, wantOp, prefix)
+							}
+							if !memory && got.Args[0].String() != fmt.Sprintf("%s21", prefix) {
+								t.Fatalf("%x: wrong register source %+v", code, got)
+							}
+							if masked && (len(got.Args) != 4 || got.Args[2].String() != "K3") {
+								t.Fatalf("%x: missing mask %+v", code, got)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateRawFP16BinaryLLVM22Targets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16Binary(SB),4,$0-0\n")
+	for opcode := range rawFP16BinaryOpcodes {
+		for width := byte(0); width < 3; width++ {
+			for _, memory := range []bool{false, true} {
+				code := encodeRawFP16Binary(opcode, width, 1, 2, 3, 1, memory, memory, true)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Keep the entire original format source. Its absent numerical
+			// inputs require public Context; initialized counterparts below
+			// own complete public objects, independently of this emitter unit.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			if strings.Count(ir, "asm sideeffect") != 36 {
+				t.Fatal("original packed FP16 format inventory changed")
+			}
+			for _, op := range rawFP16BinaryOpcodes {
+				if !strings.Contains(ir, strings.ToLower(string(op))+" ") {
+					t.Fatal("missing original native FP16 operation", op)
+				}
+			}
+			for _, control := range []string{"{1to8}", "{1to16}", "{1to32}", "kmovd "} {
+				if !strings.Contains(ir, control) {
+					t.Fatal("missing original broadcast or full mask", control)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "raw-fp16-binary.ll", "raw-fp16-binary.o", ir)
+		})
+	}
+}
+
+func TestDecodeRawFP16BinaryEmbeddedControlAndRejections(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16Control(SB),4,$0-0\n")
+	for opcode, baseOp := range rawFP16BinaryOpcodes {
+		for control := byte(0); control < 4; control++ {
+			code := encodeRawFP16Binary(opcode, control, 1, 2, 3, 1, false, true, true)
+			got, length, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+			if err != nil || !ok || length != len(code) {
+				t.Fatalf("embedded control %x: %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+			}
+			want := baseOp + ".SAE.Z"
+			if opcode != 0x5d && opcode != 0x5f {
+				want = baseOp + "." + [...]Op{"RN_SAE.Z", "RD_SAE.Z", "RU_SAE.Z", "RZ_SAE.Z"}[control]
+			}
+			if got.Op != want || got.Args[0].String() != "Z2" ||
+				got.Args[1].String() != "Z1" || got.Args[2].String() != "K1" ||
+				got.Args[3].String() != "Z3" {
+				t.Fatalf("embedded control %x: %+v, want %s Z2,Z1,K1,Z3", code, got, want)
+			}
+			for _, value := range code {
+				fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", "x86_64-unknown-linux-gnu")
+	if strings.Count(ir, "asm sideeffect") != 24 {
+		t.Fatal("original embedded-control format inventory changed")
+	}
+	for _, control := range []string{"{rn-sae}", "{rd-sae}", "{ru-sae}", "{rz-sae}", "{sae}"} {
+		if !strings.Contains(ir, control) {
+			t.Fatal("native FP16 operation lost an original embedded control", control)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-fp16-control.ll", "raw-fp16-control.o", ir)
+
+	valid := encodeRawFP16Binary(0x58, 0, 1, 2, 3, 1, false, false, false)
+	for _, mutation := range []struct {
+		name  string
+		index int
+		mask  byte
+	}{
+		{"EVEX.W", 2, 0x80},
+		{"zero without mask", 3, 0x81},
+		{"reserved width", 3, 0x60},
+	} {
+		bad := append([]byte(nil), valid...)
+		bad[mutation.index] ^= mutation.mask
+		if _, _, matched, err := decodedX86VEXBinaryFloatInstruction(bad, 64); !matched || err == nil {
+			t.Errorf("%s %x: matched=%v, err=%v", mutation.name, bad, matched, err)
+		}
+	}
+	if _, _, matched, err := decodedX86VEXBinaryFloatInstruction(valid[:5], 64); matched && err == nil {
+		t.Fatal("accepted truncated FP16 binary encoding")
+	}
+}
+
+func TestTranslateRawFP16Binary386Mask(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16386(SB),4,$0-0\n")
+	for _, code := range [][]byte{
+		encodeRawFP16Binary(0x58, 0, 1, 2, 3, 1, false, false, true),
+		encodeRawFP16Binary(0x5c, 1, 1, 0, 3, 1, true, true, true),
+	} {
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "386", triple)
+			if strings.Count(ir, "asm sideeffect") != 2 ||
+				!strings.Contains(ir, "vaddph ") || !strings.Contains(ir, "vsubph ") {
+				t.Fatal("original mode32 FP16 format inventory changed")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-fp16-386.ll", "raw-fp16-386.o", ir)
+		})
+	}
+}
+
+func TestRawFP16BinaryRejectsNamedGoForm(t *testing.T) {
+	const source = "TEXT invalidNamedHalf(SB),4,$0-0\n\tVADDPH X0, X1, X2\n\tRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, false)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"invalidNamedHalf": {Name: "invalidNamedHalf", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted FP16 mnemonic absent from Go's named assembler table")
+	}
+}
diff --git a/amd64_raw_fp16_convert_runtime_test.go b/amd64_raw_fp16_convert_runtime_test.go
new file mode 100644
index 000000000..73444858d
--- /dev/null
+++ b/amd64_raw_fp16_convert_runtime_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestRawFP16ConversionPortableRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, narrow := range []bool{false, true} {
+		for length := 0; length < 3; length++ {
+			for _, broadcast := range []bool{false, true} {
+				for _, zero := range []bool{false, true} {
+					name := fmt.Sprintf("halfConversion_%t_%d_%t_%t", narrow, length, broadcast, zero)
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+					source.WriteString("MOVQ input+0(FP), AX\nMOVQ out+8(FP), SI\nMOVQ old+16(FP), DI\nMOVQ mask+24(FP), CX\nKMOVQ CX, K1\nVMOVDQU64 (DI), Z0\n")
+					code := rawFP16Conversion(narrow, length, 1, 0, 0, true, broadcast, zero)
+					code[len(code)-1] = 0
+					for _, b := range code {
+						fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+					}
+					source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+					sigs[name] = FuncSig{
+						Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Attrs: "nounwind",
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+						}},
+					}
+					fmt.Fprintf(&declarations, "extern void %s(const void *, void *, const void *, uint64_t);\n", name)
+					input, output, bytes, total, inactive := "halves", "singles", 2, 16, "UINT32_C(0xa5a5a5a5)"
+					if narrow {
+						input, output, bytes, total, inactive = "singles", "halves", 4, 32, "0xa5a5"
+					}
+					if zero {
+						inactive = "0"
+					}
+					index := "lane"
+					if broadcast {
+						index = "0"
+					}
+					fmt.Fprintf(&calls, `
+    {
+        const void *pointer = %s;
+        if ((mask & ((UINT64_C(1) << %d) - 1)) == 0) pointer = NULL;
+        if (mask == 1) {
+            memcpy(guard + page - %d, %s, %d);
+            pointer = guard + page - %d;
+        }
+        %s(pointer, &output, old, mask);
+        for (int lane = 0; lane < %d; lane++) {
+            uint32_t expected = lane < %d ? ((mask & (UINT64_C(1) << lane)) ? %s[%s] : %s) : 0;
+            uint32_t actual = output.%s[lane];
+            if (actual != expected) {
+                fprintf(stderr, "%s mask %%llx lane %%d: %%08x != %%08x\n",
+                        (unsigned long long)mask, lane, actual, expected);
+                return 2;
+            }
+        }
+    }
+`, input, 4<<length, bytes+1, input, bytes, bytes+1, name, total, 4<<length, output, index, inactive, output, name)
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86TestGuardPagesC + `
+int main(void) {
+    if (setup_guard()) return 1;
+    const uint16_t halves[16] = {
+        0x3c00, 0x8000, 0, 0xbc00, 1, 0x03ff, 0x0400, 0x7bff,
+        0x7c00, 0xfc00, 0x3555, 0xb555, 0x4000, 0xc000, 0x7e00, 0xfe00
+    };
+    const uint32_t singles[16] = {
+        0x3f800000, 0x80000000, 0, 0xbf800000, 0x33800000, 0x387fc000, 0x38800000, 0x477fe000,
+        0x7f800000, 0xff800000, 0x3eaaa000, 0xbeaaa000, 0x40000000, 0xc0000000, 0x7fc00000, 0xffc00000
+    };
+    unsigned char old[64];
+    memset(old, 0xa5, sizeof(old));
+    union { uint16_t halves[32]; uint32_t singles[16]; } output;
+    const uint64_t masks[] = {0, 1, 0xffff, 0xaaaa, UINT64_C(1) << 60};
+    for (int mi = 0; mi < 5; mi++) {
+        uint64_t mask = masks[mi];
+` + calls.String() + `
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_conversion_portable", ir, mainC)
+}
+
+func TestRawFP16ConversionRoundingRuntime(t *testing.T) {
+	runPackedHalfRoundingRuntime(t, false)
+}
+
+func TestPackedHalfConversionDirectedRoundingRuntime(t *testing.T) {
+	runPackedHalfRoundingRuntime(t, true)
+}
+
+func runPackedHalfRoundingRuntime(t *testing.T, legacy bool) {
+	t.Helper()
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	for rounding := 0; rounding < 4; rounding++ {
+		name := fmt.Sprintf("halfRound%d", rounding)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ input+0(FP), AX\nMOVQ out+8(FP), SI\nVMOVDQU64 (AX), Z1\n", name)
+		if legacy {
+			fmt.Fprintf(&source, "VCVTPS2PH $%d, Z1, Y0\n", rounding)
+		} else {
+			for _, b := range rawFP16Conversion(true, rounding, 0, 0, 1, false, true, false) {
+				fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+			}
+		}
+		source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Attrs: "nounwind",
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+		fmt.Fprintf(&declarations, "extern void %s(const void *, void *);\n", name)
+		fmt.Fprintf(&calls, `
+    %s(input, output);
+    for (int lane = 0; lane < 32; lane++) {
+        uint16_t want = lane < 16 ? expected[%d][lane %% 8] : 0;
+        if (output[lane] != want) {
+            fprintf(stderr, "%s lane %%d: %%04x != %%04x\n", lane, output[lane], want);
+            return 1;
+        }
+    }
+`, name, rounding, name)
+	}
+	modelSource := source.String()
+	if legacy {
+		var err error
+		modelSource, err = x86NamedHalfRoundingMathematicalSource(modelSource)
+		if err != nil {
+			t.Fatal(err)
+		}
+		x86NamedHalfRoundingOriginalObjects(t, source.String(), llc)
+	}
+	file, err := Parse(ArchAMD64, modelSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + `
+static double half_value(unsigned bits) {
+    unsigned exponent = bits >> 10;
+    double value = bits & 1023;
+    int power = -24;
+    if (exponent) {
+        value += 1024;
+        power = (int)exponent - 25;
+    }
+    while (power < 0) { value *= 0.5; power++; }
+    while (power > 0) { value *= 2; power--; }
+    return value;
+}
+
+// Independent numeric oracle: bracket the float between adjacent positive
+// half values by binary search, then choose a bound according to sign/mode.
+static uint16_t reference(uint32_t bits, int mode) {
+    unsigned sign = bits >> 31;
+    bits &= 0x7fffffff;
+    if (bits >= 0x7f800000) {
+        unsigned payload = bits == 0x7f800000 ? 0 : ((bits >> 13) & 1023) | 512;
+        return (uint16_t)((sign << 15) | 0x7c00 | payload);
+    }
+    float source;
+    memcpy(&source, &bits, 4);
+    double value = source;
+    unsigned low = 0, high = 0x7bff;
+    while (low < high) {
+        unsigned mid = (low + high + 1) / 2;
+        if (half_value(mid) <= value) low = mid;
+        else high = mid - 1;
+    }
+    unsigned result = low;
+    double bottom = half_value(low);
+    if (value != bottom) {
+        if (mode == 0) {
+            double top = low == 0x7bff ? 65536.0 : half_value(low + 1);
+            double midpoint = (bottom + top) * 0.5;
+            if (value > midpoint || (value == midpoint && (low & 1))) result++;
+        } else if ((mode == 1 && sign) || (mode == 2 && !sign)) {
+            result++;
+        }
+    }
+    return (uint16_t)((sign << 15) | result);
+}
+
+int main(void) {
+    // Exact halfway values, signed overflow, and half-subnormal ties.
+    const uint32_t values[8] = {0x3f801000, 0x3f803000, 0xbf801000, 0xbf803000,
+                               0x47800000, 0xc7800000, 0x33000000, 0xb3000000};
+    const uint16_t expected[4][8] = {
+        {0x3c00, 0x3c02, 0xbc00, 0xbc02, 0x7c00, 0xfc00, 0, 0x8000},
+        {0x3c00, 0x3c01, 0xbc01, 0xbc02, 0x7bff, 0xfc00, 0, 0x8001},
+        {0x3c01, 0x3c02, 0xbc00, 0xbc01, 0x7c00, 0xfbff, 1, 0x8000},
+        {0x3c00, 0x3c01, 0xbc00, 0xbc01, 0x7bff, 0xfbff, 0, 0x8000}
+    };
+    uint32_t input[16];
+    uint16_t output[32];
+    for (int lane = 0; lane < 16; lane++) input[lane] = values[lane % 8];
+` + calls.String() + `
+    void (*functions[])(const void *, void *) = {halfRound0, halfRound1, halfRound2, halfRound3};
+    uint32_t random = 0x13579bdf;
+    for (int batch = 0; batch < 4096; batch++) {
+        for (int lane = 0; lane < 16; lane++) {
+            random ^= random << 13;
+            random ^= random >> 17;
+            random ^= random << 5;
+            input[lane] = random;
+        }
+        for (int mode = 0; mode < 4; mode++) {
+            functions[mode](input, output);
+            for (int lane = 0; lane < 16; lane++) {
+                uint16_t want = reference(input[lane], mode);
+                if (output[lane] != want) {
+                    fprintf(stderr, "mode %d input %08x: %04x != %04x\n", mode, input[lane], output[lane], want);
+                    return 2;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+	if legacy {
+		x86NamedHalfCheckOriginalRoundingC(t, mainC)
+	}
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_conversion_rounding", ir, mainC)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		const triple = "x86_64-apple-macosx"
+		x86IR := x86FP16NumericalModelIR(t, file, sigs, triple)
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "fp16_conversion_rounding_x86", triple, x86IR, mainC, []string{"/usr/bin/arch", "-x86_64"})
+	}
+}
diff --git a/amd64_raw_fp16_convert_test.go b/amd64_raw_fp16_convert_test.go
new file mode 100644
index 000000000..339a5a65a
--- /dev/null
+++ b/amd64_raw_fp16_convert_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func rawFP16Conversion(narrow bool, length, mask, destination, source int, memory, control, zero bool) []byte {
+	form := x86RawHalfConversionForm{mapNumber: 6, opcode: 0x13}
+	if narrow {
+		form.mapNumber, form.opcode = 5, 0x1d
+	}
+	code := encodeX86RawEVEXHalfConversion(form, length, mask, zero, control, destination, source, memory, 0)
+	if memory {
+		code[len(code)-1] = 1
+	}
+	return code
+}
+
+func TestRawFP16ConversionCompleteFormats(t *testing.T) {
+	for _, narrow := range []bool{false, true} {
+		for length := 0; length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if length == 3 && (memory || !control) {
+						continue
+					}
+					for _, mask := range []int{0, 1, 7} {
+						for _, zero := range []bool{false, true} {
+							if zero && mask == 0 {
+								continue
+							}
+							code := rawFP16Conversion(narrow, length, mask, 20, 21, memory, control, zero)
+							got, size, ok, err := decodedX86PackedHalfConversionInstruction(code, 64)
+							if err != nil || !ok || size != len(code) || !got.x86Encoded {
+								t.Fatalf("%x: %+v, size=%d, ok=%v, err=%v", code, got, size, ok, err)
+							}
+							vl := length
+							if control && !memory {
+								vl = 2
+							}
+							wide, short := [...]string{"X", "Y", "Z"}[vl], [...]string{"X", "X", "Y"}[vl]
+							src, dst, width := short+"21", wide+"20", 8<<vl
+							want := Op("VCVTPH2PSX")
+							if narrow {
+								want, src, dst, width = "VCVTPS2PHX", wide+"21", short+"20", 16<<vl
+							}
+							if control {
+								if memory {
+									want += ".BCST"
+									width = 2
+									if narrow {
+										width = 4
+									}
+								} else if narrow {
+									want += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[length]
+								} else {
+									want += ".SAE"
+								}
+							}
+							if memory {
+								src = fmt.Sprintf("%d(AX)", width)
+							}
+							if zero {
+								want += ".Z"
+							}
+							if got.Op != want || got.Args[0].String() != src || got.Args[len(got.Args)-1].String() != dst {
+								t.Fatalf("%x: got %+v, want %s %s -> %s", code, got, want, src, dst)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestRawFP16ConversionInvalidFormats(t *testing.T) {
+	for _, narrow := range []bool{false, true} {
+		for _, change := range []struct {
+			index int
+			bits  byte
+		}{
+			{2, 0x80}, {2, 0x04}, {2, 0x08}, {3, 0x08}, {3, 0x80}, {3, 0x60},
+		} {
+			code := rawFP16Conversion(narrow, 0, 0, 0, 1, false, false, false)
+			code[change.index] ^= change.bits
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid FP16 conversion", map[string]bool{}); err == nil {
+				t.Fatalf("accepted reserved encoding %x", code)
+			}
+		}
+		for _, code := range [][]byte{
+			rawFP16Conversion(narrow, 0, 0, 8, 1, false, false, false),
+			rawFP16Conversion(narrow, 0, 0, 1, 8, false, false, false),
+		} {
+			if _, err := decodeX86RawDirectiveGroup(code, 32, 0, "386 high FP16 conversion", map[string]bool{}); err == nil {
+				t.Fatalf("accepted extended register %x", code)
+			}
+		}
+	}
+}
+
+func TestRawFP16ConversionLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16Conversion(SB),4,$0-0\n")
+	for _, narrow := range []bool{false, true} {
+		for length := 0; length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if length == 3 && (memory || !control) {
+						continue
+					}
+					for _, mask := range []int{0, 1} {
+						for _, b := range rawFP16Conversion(narrow, length, mask, 1, 2, memory, control, mask != 0) {
+							fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+						}
+					}
+				}
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			for _, want := range []string{"vcvtph2psx ", "vcvtps2phx ", "vcvtps2phxx ", "vcvtps2phxy ",
+				"{rn-sae}", "{rd-sae}", "{ru-sae}", "{rz-sae}", "{sae}", "asm sideeffect", "+avx512fp16", "+avx512vl"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %s", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-fp16-conversion.ll", "raw-fp16-conversion.o", ir)
+		})
+	}
+}
+
+func TestRawFP16ConversionRIPAndNamedForms(t *testing.T) {
+	for _, narrow := range []bool{false, true} {
+		for length := 0; length < 3; length++ {
+			for _, broadcast := range []bool{false, true} {
+				code := rawFP16Conversion(narrow, length, 1, 0, 0, false, broadcast, true)
+				code[5] = 5
+				code = append(code, 1, 0, 0, 0, 0xc3)
+				width := 8 << length
+				if broadcast {
+					width = 2
+				}
+				if narrow {
+					width *= 2
+				}
+				code = append(code, make([]byte, width)...)
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, "FP16 conversion literal", map[string]bool{})
+				if err != nil || len(got) != 2 || !got[0].x86RIPLiteral || got[0].Args[0].Kind != OpSym {
+					t.Fatalf("%x: %+v, err=%v", code, got, err)
+				}
+				if _, err := decodeX86RawDirectiveGroup(code[:len(code)-1], 64, 0, "truncated FP16 pool", map[string]bool{}); err == nil {
+					t.Fatal("accepted truncated constant pool")
+				}
+			}
+		}
+	}
+	for _, op := range []string{"VCVTPH2PSX", "VCVTPS2PHX"} {
+		source := "TEXT namedFP16Conversion(SB),4,$0-0\n" + op + " X0, X1\nRET\n"
+		requireX86GoAssemblerResult(t, "amd64", source, false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"namedFP16Conversion": {Name: "namedFP16Conversion", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("accepted named %s", op)
+		}
+	}
+}
diff --git a/amd64_raw_fp16_fma_runtime_test.go b/amd64_raw_fp16_fma_runtime_test.go
new file mode 100644
index 000000000..10709f65c
--- /dev/null
+++ b/amd64_raw_fp16_fma_runtime_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute the portable IR on the host, without requiring an AVX512-FP16
+// CPU. Separate object tests check the actual x86 features and every target.
+func TestRawFP16FMAPortableRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, cases strings.Builder
+	sigs := make(map[string]FuncSig)
+	ops := rawFP16FMAOps()
+	for _, opcode := range x86FMA3Opcodes() {
+		op := ops[opcode]
+		scalar := strings.HasSuffix(string(op), "SH")
+		lengths := []byte{1}
+		if scalar {
+			lengths = []byte{0}
+		} else if opcode == 0x98 {
+			lengths = []byte{0, 1, 2}
+		}
+		for _, length := range lengths {
+			for _, zero := range []bool{false, true} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && (scalar || opcode != 0x98) {
+						continue
+					}
+					name := fmt.Sprintf("halfFMA_%x_%d_%t_%t", opcode, length, zero, broadcast)
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+					source.WriteString("MOVQ input+0(FP), DI\nMOVQ memory+8(FP), AX\nMOVQ out+16(FP), SI\nMOVQ mask+24(FP), CX\n")
+					source.WriteString("KMOVQ CX, K1\nVMOVDQU64 (DI), Z0\nVMOVDQU64 64(DI), Z1\n")
+					code := encodeRawFP16FMA(opcode, length, 1, 0, 0, 1, true, broadcast, zero)
+					code[len(code)-1] = 0
+					for _, value := range code {
+						fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+					}
+					source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+					sigs[name] = FuncSig{
+						Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void,
+						Attrs: "nounwind", // Suppress x86-only inference for this portable oracle.
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+							{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+							{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+							{Offset: 24, Type: I64, Index: 3, Field: -1},
+						}},
+					}
+					order := []int{132, 213, 231}[(opcode>>4)-9]
+					mode := int(opcode&15) - 8
+					if mode < 0 {
+						mode += 6 // 6/7 are alternating subtract-even/subtract-odd.
+					} else {
+						mode /= 2
+					}
+					lanes := 8 << length
+					if scalar {
+						lanes = 1
+					}
+					flag := func(value bool) int {
+						if value {
+							return 1
+						}
+						return 0
+					}
+					fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *, uint64_t);\n", name)
+					fmt.Fprintf(&cases, "  {%s, %d, %d, %d, %d, %d, %d},\n", name, order, mode, lanes, flag(scalar), flag(zero), flag(broadcast))
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86TestGuardPagesC + `
+typedef void (*operation)(const void *, const void *, void *, uint64_t);
+struct test_case { operation run; int order, mode, lanes, scalar, zero, broadcast; };
+static struct test_case cases[] = {
+` + cases.String() + `};
+
+// These operands and their exact products/sums fit in binary64. Round only
+// once to FP16, independently of the translator's half-precision FMA.
+static double from_half(uint16_t bits) {
+    _Float16 value;
+    memcpy(&value, &bits, 2);
+    return value;
+}
+
+static uint16_t to_half(double value) {
+    _Float16 result = (_Float16)value;
+    uint16_t bits;
+    memcpy(&bits, &result, 2);
+    return bits;
+}
+
+int main(void) {
+    if (setup_guard()) return 1;
+    uint16_t input[64], memory[32], output[32];
+    for (int lane = 0; lane < 32; lane++) {
+        input[lane] = 0x3c01;       // 1 + 2^-10
+        input[32 + lane] = 0xbc00;  // -1
+        memory[lane] = 0x3bfe;      // 1 - 2^-10
+    }
+    const uint64_t masks[] = {0, 1, 0xaaaaaaaa, 0xffffffff, UINT64_C(1) << 60};
+    for (size_t index = 0; index < sizeof(cases) / sizeof(cases[0]); index++) {
+        struct test_case test = cases[index];
+        for (size_t mi = 0; mi < sizeof(masks) / sizeof(masks[0]); mi++) {
+            uint64_t mask = masks[mi];
+            const void *pointer = memory;
+            if ((mask & ((UINT64_C(1) << test.lanes) - 1)) == 0) pointer = NULL;
+            if (mask == 1) {
+                memcpy(guard + page - 3, memory, 2);
+                pointer = guard + page - 3;
+            }
+            memset(output, 0xcc, sizeof(output));
+            test.run(input, pointer, output, mask);
+            for (int lane = 0; lane < 32; lane++) {
+                uint16_t expected = 0;
+                if (lane < test.lanes && (mask & (UINT64_C(1) << lane))) {
+                    double d = from_half(input[lane]);
+                    double s = from_half(input[32 + lane]);
+                    double m = from_half(memory[test.broadcast ? 0 : lane]);
+                    double a = d, b = m, c = s;
+                    if (test.order == 213) { a = s; b = d; c = m; }
+                    if (test.order == 231) { a = s; b = m; c = d; }
+                    if (test.mode == 2 || test.mode == 3) a = -a;
+                    if (test.mode == 1 || test.mode == 3 ||
+                        (test.mode == 4 && lane % 2 == 0) ||
+                        (test.mode == 5 && lane % 2 != 0)) c = -c;
+                    expected = to_half(a * b + c);
+                } else if (lane < test.lanes && !test.zero) {
+                    expected = input[lane];
+                } else if (test.scalar && lane < 8 && lane != 0) {
+                    expected = input[lane];
+                }
+                if (output[lane] != expected) {
+                    fprintf(stderr, "case %zu order %d mode %d mask %llx lane %d: %04x != %04x\n",
+                            index, test.order, test.mode, (unsigned long long)mask, lane, output[lane], expected);
+                    return 2;
+                }
+            }
+        }
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_fma_portable", ir, mainC)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		const triple = "x86_64-apple-macosx"
+		x86IR, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "fp16_fma_portable_x86", triple, x86IR, mainC, []string{"/usr/bin/arch", "-x86_64"})
+	}
+}
diff --git a/amd64_raw_fp16_fma_test.go b/amd64_raw_fp16_fma_test.go
new file mode 100644
index 000000000..b5bc6ad9c
--- /dev/null
+++ b/amd64_raw_fp16_fma_test.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Intel AVX512-FP16 specification, sections 5.44-5.49: MAP6.66.W0,
+// packed X/Y/Z and scalar LLIG, with the same opcode/order axes as FMA3.
+// Go 1.27 has no named PH/SH FMA forms, so these are raw encodings only.
+func rawFP16FMAOps() map[byte]Op {
+	ops := make(map[byte]Op)
+	for orderIndex, order := range []int{132, 213, 231} {
+		for familyIndex, family := range []string{"VFMADD", "VFMSUB", "VFNMADD", "VFNMSUB"} {
+			for scalarIndex, suffix := range []string{"PH", "SH"} {
+				opcode := byte(0x98 + orderIndex*16 + familyIndex*2 + scalarIndex)
+				ops[opcode] = Op(fmt.Sprintf("%s%d%s", family, order, suffix))
+			}
+		}
+		ops[byte(0x96+orderIndex*16)] = Op(fmt.Sprintf("VFMADDSUB%dPH", order))
+		ops[byte(0x97+orderIndex*16)] = Op(fmt.Sprintf("VFMSUBADD%dPH", order))
+	}
+	return ops
+}
+
+func encodeRawFP16FMA(opcode, length byte, source1, source2, destination, mask int, memory, control, zero bool) []byte {
+	code := encodeX86EVEXFMA3(opcode, false, length, control, zero, mask, destination, source1, source2)
+	code[1] = code[1]&^byte(15) | 6
+	if memory {
+		// Keep register extension tests independent of memory base extensions.
+		code[1] |= 0x60
+		code[5] = byte(0x40 | (destination&7)<<3)
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeRawFP16FMAGoATReproduction(t *testing.T) {
+	for _, tc := range []struct {
+		code []byte
+		op   Op
+	}{
+		{[]byte{0x62, 0xb6, 0x7d, 0x48, 0xa8, 0x24, 0x4a}, "VFMADD213PH"},
+		{[]byte{0x62, 0xf6, 0x7d, 0x48, 0x98, 0x0e}, "VFMADD132PH"},
+		{[]byte{0x62, 0xb6, 0x7d, 0x08, 0x99, 0x0c, 0x76}, "VFMADD132SH"},
+	} {
+		got, err := decodeX86RawDirectiveGroup(tc.code, 64, 0, "GoAT FP16 FMA", map[string]bool{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(got) != 1 || got[0].Op != tc.op || !got[0].x86Encoded {
+			t.Fatalf("%x decoded as %+v, want raw %s", tc.code, got, tc.op)
+		}
+	}
+}
+
+func TestDecodeRawFP16FMACompleteFormats(t *testing.T) {
+	for opcode, base := range rawFP16FMAOps() {
+		scalar := strings.HasSuffix(string(base), "SH")
+		for length := byte(0); length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if scalar && memory && control || !scalar && length == 3 && (!control || memory) {
+						continue
+					}
+					for _, mask := range []int{0, 1, 7} {
+						for _, zero := range []bool{false, true} {
+							if zero && mask == 0 {
+								continue
+							}
+							code := encodeRawFP16FMA(opcode, length, 20, 21, 22, mask, memory, control, zero)
+							got, size, ok, err := decodedX86VEXFMA3Instruction(code, 64)
+							if err != nil || !ok || size != len(code) {
+								t.Fatalf("%x: got %+v, size=%d, ok=%v, err=%v", code, got, size, ok, err)
+							}
+							want := base
+							prefix, width := "X", 16
+							if !scalar {
+								vl := length
+								if control && !memory {
+									vl = 2
+								}
+								prefix, width = [...]string{"X", "Y", "Z"}[vl], 16<<vl
+							}
+							if control {
+								if memory {
+									want += ".BCST"
+								} else {
+									want += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[length]
+								}
+							}
+							if zero {
+								want += ".Z"
+							}
+							if got.Op != want || !got.x86Encoded || got.Args[1].String() != prefix+"20" ||
+								got.Args[len(got.Args)-1].String() != prefix+"22" {
+								t.Fatalf("%x: got %+v, want %s with %s20 and %s22", code, got, want, prefix, prefix)
+							}
+							if memory {
+								if scalar || control {
+									width = 2
+								}
+								if got.Args[0].String() != fmt.Sprintf("%d(AX)", width) {
+									t.Fatalf("%x: wrong compressed displacement: %+v", code, got)
+								}
+							} else if got.Args[0].String() != prefix+"21" {
+								t.Fatalf("%x: wrong register source: %+v", code, got)
+							}
+							if mask != 0 && got.Args[2].String() != fmt.Sprintf("K%d", mask) {
+								t.Fatalf("%x: wrong mask: %+v", code, got)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeRawFP16FMAInvalidFormats(t *testing.T) {
+	valid := encodeRawFP16FMA(0x98, 0, 1, 2, 3, 1, false, false, false)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"wrong-w": func(code []byte) []byte {
+			code[2] |= 0x80
+			return code
+		},
+		"wrong-pp": func(code []byte) []byte {
+			code[2] &^= 3
+			return code
+		},
+		"fixed-bit": func(code []byte) []byte {
+			code[2] &^= 4
+			return code
+		},
+		"zero-k0": func(code []byte) []byte {
+			code[3] = code[3]&^7 | 0x80
+			return code
+		},
+		"packed-vl3": func(code []byte) []byte {
+			code[3] |= 0x60
+			return code
+		},
+		"scalar-broadcast": func(code []byte) []byte {
+			code[3] |= 0x10
+			code[4], code[5] = 0x99, 0x18
+			return code
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, _, ok, err := decodedX86VEXFMA3Instruction(code, 64); !ok || err == nil {
+				t.Fatalf("accepted invalid %x: matched=%v, err=%v", code, ok, err)
+			}
+		})
+	}
+	for _, mode := range []int{32, 64} {
+		for end := 1; end < len(valid); end++ {
+			if _, err := decodeX86RawDirectiveGroup(valid[:end], mode, 0, "truncated FP16 FMA", map[string]bool{}); err == nil {
+				t.Fatalf("accepted truncated %x in mode %d", valid[:end], mode)
+			}
+		}
+	}
+}
+
+func TestDecodeRawFP16FMARIPLiteral(t *testing.T) {
+	for _, opcode := range []byte{0x98, 0x99} {
+		for _, broadcast := range []bool{false, true} {
+			if opcode == 0x99 && broadcast {
+				continue
+			}
+			code := encodeRawFP16FMA(opcode, 1, 1, 0, 2, 1, false, broadcast, true)
+			code[5] = 0x15
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			width := 32
+			if opcode == 0x99 || broadcast {
+				width = 2
+			}
+			for index := 0; index < width; index++ {
+				code = append(code, byte(index+1))
+			}
+			got, err := decodeX86RawDirectiveGroup(code, 64, 0, "FP16 FMA RIP literal", map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got) != 2 || got[0].Args[0].Kind != OpSym || !got[0].x86RIPLiteral || got[1].Op != OpRET {
+				t.Fatalf("decoded %x as %+v, want source-local literal and RET", code, got)
+			}
+		}
+	}
+}
+
+func TestTranslateRawFP16FMALLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch   string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawHalfFMA(SB),4,$0-0\n")
+			for opcode, op := range rawFP16FMAOps() {
+				scalar := strings.HasSuffix(string(op), "SH")
+				for length := byte(0); length < 4; length++ {
+					for _, memory := range []bool{false, true} {
+						for _, control := range []bool{false, true} {
+							if scalar && memory && control || !scalar && length == 3 && (!control || memory) {
+								continue
+							}
+							code := encodeRawFP16FMA(opcode, length, 1, 2, 3, 1, memory, control, true)
+							for _, value := range code {
+								fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+							}
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			// Keep the complete original encoding unit. Its unknown vectors,
+			// mask and address are not initialized by a Void declaration.
+			// Separate initialized programs own public-API object coverage.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			if strings.Count(ir, "asm sideeffect") != 378 {
+				t.Fatal("original FP16 FMA format unit lost native operations")
+			}
+			for _, op := range rawFP16FMAOps() {
+				if !strings.Contains(ir, strings.ToLower(string(op))+" ") {
+					t.Fatal("original FP16 FMA format unit lost family member", op)
+				}
+			}
+			for _, want := range []string{"{rn-sae}", "{rd-sae}", "{ru-sae}", "{rz-sae}",
+				"{1to8}", "{1to16}", "{1to32}", "kmovd", "+avx512fp16"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %s", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-half-fma.ll", "raw-half-fma.o", ir)
+		})
+	}
+}
+
+func TestRawFP16FMARejectsNamedGoForms(t *testing.T) {
+	for _, op := range rawFP16FMAOps() {
+		source := fmt.Sprintf("TEXT namedHalfFMA(SB),4,$0-0\n\t%s X0, X1, X2\n\tRET\n", op)
+		requireX86GoAssemblerResult(t, "amd64", source, false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"namedHalfFMA": {Name: "namedHalfFMA", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("accepted %s absent from Go's named assembler table", op)
+		}
+	}
+}
diff --git a/amd64_raw_fp16_scalar_binary_test.go b/amd64_raw_fp16_scalar_binary_test.go
new file mode 100644
index 000000000..d110b3708
--- /dev/null
+++ b/amd64_raw_fp16_scalar_binary_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var rawFP16ScalarBinaryOpcodes = map[byte]Op{
+	0x51: "VSQRTSH",
+	0x58: "VADDSH",
+	0x59: "VMULSH",
+	0x5c: "VSUBSH",
+	0x5d: "VMINSH",
+	0x5e: "VDIVSH",
+	0x5f: "VMAXSH",
+}
+
+func encodeRawFP16ScalarBinary(opcode, length byte, source1, source2, destination, mask int, memory, control, zero bool) []byte {
+	code := encodeX86EVEXBinaryFloat(opcode, 2, length, control, zero, mask, destination, source1, source2)
+	code[1] = code[1]&^byte(15) | 5
+	if memory {
+		code[5] = byte(0x40 | (destination&7)<<3)
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeRawFP16ScalarBinaryGoATReproduction(t *testing.T) {
+	// VADDSH (SI)(CX*2), X0, X0 from go-highway's GoAT output.
+	code := []byte{0x62, 0xf5, 0x7e, 0x08, 0x58, 0x04, 0x4e}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "GoAT VADDSH", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VADDSH" || !decoded[0].x86Encoded {
+		t.Fatalf("decoded %#v, want one raw VADDSH", decoded)
+	}
+}
+
+func TestDecodeRawFP16ScalarBinaryCompleteForms(t *testing.T) {
+	for opcode, baseOp := range rawFP16ScalarBinaryOpcodes {
+		for length := byte(0); length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, mask := range []int{0, 1, 7} {
+					for _, zero := range []bool{false, true} {
+						if zero && mask == 0 {
+							continue
+						}
+						for _, control := range []bool{false, true} {
+							if control && memory {
+								continue
+							}
+							code := encodeRawFP16ScalarBinary(opcode, length, 20, 21, 22, mask, memory, control, zero)
+							got, size, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+							if err != nil || !ok || size != len(code) {
+								t.Fatalf("%x: got %+v, size=%d, ok=%v, err=%v", code, got, size, ok, err)
+							}
+							wantOp := baseOp
+							if control {
+								if opcode == 0x5d || opcode == 0x5f {
+									wantOp += ".SAE"
+								} else {
+									wantOp += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[length]
+								}
+							}
+							if zero {
+								wantOp += ".Z"
+							}
+							if got.Op != wantOp || !got.x86Encoded || got.Args[1].String() != "X20" ||
+								got.Args[len(got.Args)-1].String() != "X22" {
+								t.Fatalf("%x: got %+v, want %s with X20 and X22", code, got, wantOp)
+							}
+							if memory && got.Args[0].Kind != OpMem || !memory && got.Args[0].String() != "X21" {
+								t.Fatalf("%x: wrong source %+v", code, got)
+							}
+							if mask != 0 && (len(got.Args) != 4 || got.Args[2].String() != fmt.Sprintf("K%d", mask)) {
+								t.Fatalf("%x: wrong mask %+v", code, got)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeRawFP16ScalarBinaryInvalidForms(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"wrong-width", []byte{0x62, 0xf5, 0xfe, 0x08, 0x58, 0xc0}, 64},
+		{"missing-fixed", []byte{0x62, 0xf5, 0x7a, 0x08, 0x58, 0xc0}, 64},
+		{"zero-k0", []byte{0x62, 0xf5, 0x7e, 0x88, 0x58, 0xc0}, 64},
+		{"memory-rounding", []byte{0x62, 0xf5, 0x7e, 0x18, 0x58, 0x00}, 64},
+		{"386-high-register", []byte{0x62, 0x75, 0x7e, 0x08, 0x58, 0xc0}, 32},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86VEXBinaryFloatInstruction(tc.code, tc.mode); !ok || err == nil {
+				t.Fatalf("invalid %x: matched=%v, err=%v", tc.code, ok, err)
+			}
+		})
+	}
+}
+
+func TestDecodeRawFP16BinaryRIPLiteral(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		code      []byte
+		dataWidth int
+		want      Op
+	}{
+		{"scalar", encodeRawFP16ScalarBinary(0x58, 0, 1, 0, 2, 0, false, false, false), 2, "VADDSH"},
+		{"packed", encodeRawFP16Binary(0x58, 0, 1, 0, 2, 0, false, false, false), 16, "VADDPH"},
+		{"broadcast", encodeRawFP16Binary(0x58, 1, 1, 0, 2, 0, false, true, false), 2, "VADDPH.BCST"},
+		{"sqrt-scalar", encodeRawFP16ScalarBinary(0x51, 0, 1, 0, 2, 0, false, false, false), 2, "VSQRTSH"},
+		{"sqrt-packed", rawFP16PackedSqrt(0, 0, 2, 0, false, false, false), 16, "VSQRTPH"},
+		{"sqrt-broadcast", rawFP16PackedSqrt(1, 0, 2, 0, false, true, false), 2, "VSQRTPH.BCST"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			code := append([]byte(nil), tc.code...)
+			code[5] = 0x15
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			for index := 0; index < tc.dataWidth; index++ {
+				code = append(code, byte(index+1))
+			}
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, tc.name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded) != 2 || decoded[0].Op != tc.want ||
+				decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+				decoded[1].Op != OpRET {
+				t.Fatalf("decoded %x as %#v, want %s source-local FP16 literal", code, decoded, tc.want)
+			}
+		})
+	}
+}
+
+func TestTranslateRawFP16ScalarBinaryLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawFP16ScalarBinary(SB),4,$0-0\n")
+			for opcode := range rawFP16ScalarBinaryOpcodes {
+				for _, memory := range []bool{false, true} {
+					code := encodeRawFP16ScalarBinary(opcode, 2, 1, 2, 3, 1, memory, !memory, true)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			if strings.Count(ir, "asm sideeffect") != 14 {
+				t.Fatal("original scalar FP16 format inventory changed")
+			}
+			for _, op := range rawFP16ScalarBinaryOpcodes {
+				if !strings.Contains(ir, strings.ToLower(string(op))+" ") {
+					t.Fatal("missing original native scalar FP16 operation", op)
+				}
+			}
+			for _, want := range []string{"elementtype([2 x i8])", "{ru-sae}", "{sae}", "kmovw "} {
+				if !strings.Contains(ir, want) {
+					t.Fatal("missing original scalar FP16 access or control", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-fp16-scalar-binary.ll", "raw-fp16-scalar-binary.o", ir)
+		})
+	}
+}
+
+func TestRawFP16ScalarRejectsNamedGoForms(t *testing.T) {
+	for _, op := range []Op{"VMOVSH", "VADDSH", "VSUBSH", "VMULSH", "VDIVSH", "VMINSH", "VMAXSH", "VSQRTSH"} {
+		t.Run(string(op), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT namedHalf(SB),4,$0-0\n\t%s X0, X1, X2\n\tRET\n", op)
+			requireX86GoAssemblerResult(t, "amd64", source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"namedHalf": {Name: "namedHalf", Ret: Void}},
+			}); err == nil {
+				t.Fatal("accepted FP16 mnemonic absent from Go's named assembler table")
+			}
+		})
+	}
+}
diff --git a/amd64_raw_fp16_scalar_convert.go b/amd64_raw_fp16_scalar_convert.go
new file mode 100644
index 000000000..26ada1dc0
--- /dev/null
+++ b/amd64_raw_fp16_scalar_convert.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawScalarHalfConversionForm struct {
+	op                    Op
+	mapNumber, pp, opcode int
+	w                     bool
+}
+
+var x86RawScalarHalfConversionForms = [...]x86RawScalarHalfConversionForm{
+	{"VCVTSH2SS", 6, 0, 0x13, false},
+	{"VCVTSS2SH", 5, 0, 0x1d, false},
+	{"VCVTSH2SD", 5, 2, 0x5a, false},
+	{"VCVTSD2SH", 5, 3, 0x5a, true},
+}
+
+func x86RawScalarHalfConversionFormFor(p x86RawVectorEncoding) (x86RawScalarHalfConversionForm, bool) {
+	if p.evex {
+		for _, form := range x86RawScalarHalfConversionForms {
+			if p.mapNumber == form.mapNumber && p.pp == form.pp && p.opcode == form.opcode {
+				return form, true
+			}
+		}
+	}
+	return x86RawScalarHalfConversionForm{}, false
+}
+
+func decodedX86ScalarHalfConversionInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	form, matched := x86RawScalarHalfConversionFormFor(p)
+	if !recognized || !matched {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar half conversion: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.w != form.w || p.zero && p.mask == 0 {
+		return fail("invalid EVEX fixed, width or zeroing field")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.broadcast && code[p.modRM]>>6 != 3 {
+		return fail("scalar conversion does not support memory broadcast")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register or address in 32-bit mode")
+	}
+	spec := amd64HalfConversionSpecs[string(form.op)]
+	source, consumed, err := decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", spec.inputBits/8)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := form.op
+	if p.broadcast {
+		if spec.inputBits == 16 {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+		}
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{source, {Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))}}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	destination := int(code[p.modRM]>>3&7) + p.r*8
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destination))})
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")), x86Encoded: true}, p.modRM + consumed, true, nil
+}
+
+func decodeX86RawScalarHalfConversionRIPData(code []byte, offset, mode int) (Instr, int, x86RawLiteralRange, bool, error) {
+	if mode != 64 || offset >= len(code) {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	p, recognized := decodeX86RawVectorEncoding(code[offset:])
+	form, matched := x86RawScalarHalfConversionFormFor(p)
+	if !recognized || !matched || p.segment != "" || p.addressOverride {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	modRM := offset + p.modRM
+	if len(code) <= modRM || code[modRM]&0xc7 != 5 {
+		return Instr{}, 0, x86RawLiteralRange{}, false, nil
+	}
+	width := amd64HalfConversionSpecs[string(form.op)].inputBits / 8
+	return x86RawRIPDataThroughDecoder(code, offset, mode, modRM, width, decodedX86ScalarHalfConversionInstruction, "scalar half conversion")
+}
diff --git a/amd64_raw_fp16_scalar_convert_runtime_test.go b/amd64_raw_fp16_scalar_convert_runtime_test.go
new file mode 100644
index 000000000..3e85e0579
--- /dev/null
+++ b/amd64_raw_fp16_scalar_convert_runtime_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestRawFP16ScalarConversionPortableRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, tc := range fp16ScalarConversionCases {
+		for _, zero := range []bool{false, true} {
+			name := fmt.Sprintf("scalarHalf_%d_%t", index, zero)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+			source.WriteString("MOVQ input+0(FP), AX\nMOVQ vectors+8(FP), DI\nMOVQ out+16(FP), SI\nMOVQ mask+24(FP), CX\nKMOVQ CX, K1\nVMOVDQU64 (DI), Z0\nVMOVDQU64 64(DI), Z1\n")
+			code := rawFP16ScalarConversion(index, 3, 1, 0, 0, 1, true, false, zero)
+			code[len(code)-1] = 0
+			for _, b := range code {
+				fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+			}
+			source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Attrs: "nounwind",
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+				}},
+			}
+			bits := map[int]uint64{16: 0x4000, 32: 0x40000000, 64: 0x4000000000000000}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *, uint64_t);\n", name)
+			inactive := "memcpy(expected, vectors, output_bytes);"
+			if zero {
+				inactive = "memset(expected, 0, output_bytes);"
+			}
+			fmt.Fprintf(&calls, `
+    {
+        const int input_bytes = %d, output_bytes = %d;
+        uint64_t input = UINT64_C(%d), result = UINT64_C(%d);
+        const void *pointer = NULL;
+        if (mask & 1) {
+            memcpy(guard + page - input_bytes - 1, &input, input_bytes);
+            pointer = guard + page - input_bytes - 1;
+        }
+        memset(expected, 0, sizeof(expected));
+        if (mask & 1) memcpy(expected, &result, output_bytes);
+        else { %s }
+        memcpy(expected + output_bytes, vectors + 64 + output_bytes, 16 - output_bytes);
+        %s(pointer, vectors, output, mask);
+        if (memcmp(expected, output, 64)) {
+            fprintf(stderr, "%s mask %%llx: incorrect low, preserved or upper lanes\n", (unsigned long long)mask);
+            return 2;
+        }
+    }
+`, tc.inputBits/8, tc.outBits/8, bits[tc.inputBits], bits[tc.outBits], inactive, name, name)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86TestGuardPagesC + `
+int main(void) {
+    if (setup_guard()) return 1;
+    unsigned char vectors[128], output[64], expected[64];
+    for (int i = 0; i < 128; i++) vectors[i] = (unsigned char)(0x20 + i);
+    const uint64_t masks[] = {0, 1, 2, UINT64_C(1) << 60, UINT64_MAX};
+    for (int mi = 0; mi < 5; mi++) {
+        uint64_t mask = masks[mi];
+` + calls.String() + `
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_scalar_conversion", ir, mainC)
+}
+
+func TestRawFP16ScalarConversionRoundingRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, index := range []int{1, 3} {
+		for rounding := 0; rounding < 4; rounding++ {
+			name := fmt.Sprintf("scalarRound_%d_%d", index, rounding)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ input+0(FP), AX\nMOVQ out+8(FP), SI\nVMOVDQU64 (AX), Z2\n", name)
+			source.WriteString("VPXORD Z1,Z1,Z1\n") // The complete output includes this scalar passthrough.
+			for _, b := range rawFP16ScalarConversion(index, rounding, 1, 2, 0, 0, false, true, false) {
+				fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+			}
+			source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Attrs: "nounwind",
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, void *);\n", name)
+			input := "single"
+			if index == 3 {
+				input = "wide"
+			}
+			fmt.Fprintf(&calls, `
+        %s(%s, output);
+        if (output[0] != expected[%d][sample]) {
+            fprintf(stderr, "%s sample %%d: %%04x != %%04x\n", sample, output[0], expected[%d][sample]);
+            return 1;
+        }
+`, name, input, rounding, name, rounding)
+			if index == 3 {
+				fmt.Fprintf(&calls, `
+        // These exactly representable doubles straddle a half tie but round
+        // to that same tie in float; a double->float->half chain is wrong.
+        if (sample == 0) {
+            wide[0] = 1.0 + 0x1p-11 + 0x1p-40;
+            %s(wide, output);
+            const uint16_t above[] = {0x3c01, 0x3c00, 0x3c01, 0x3c00};
+            if (output[0] != above[%d]) return 2;
+            wide[0] = 1.0 + 0x1p-11 - 0x1p-40;
+            %s(wide, output);
+            const uint16_t below[] = {0x3c00, 0x3c00, 0x3c01, 0x3c00};
+            if (output[0] != below[%d]) return 3;
+            wide[0] = values[sample];
+        }
+`, name, rounding, name, rounding)
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := strings.ReplaceAll(source.String(), "VPXORD Z1,Z1,Z1\n", "")
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", original)
+	originalFile, err := Parse(ArchAMD64, original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(originalFile, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original full-vector store borrowed missing scalar passthrough bytes", err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + `
+int main(void) {
+    const double values[] = {1 + 0x1p-11, 1 + 3 * 0x1p-11, -1 - 0x1p-11, -1 - 3 * 0x1p-11,
+                             65536, -65536, 0x1p-25, -0x1p-25};
+    const uint16_t expected[4][8] = {
+        {0x3c00, 0x3c02, 0xbc00, 0xbc02, 0x7c00, 0xfc00, 0, 0x8000},
+        {0x3c00, 0x3c01, 0xbc01, 0xbc02, 0x7bff, 0xfc00, 0, 0x8001},
+        {0x3c01, 0x3c02, 0xbc00, 0xbc01, 0x7c00, 0xfbff, 1, 0x8000},
+        {0x3c00, 0x3c01, 0xbc00, 0xbc01, 0x7bff, 0xfbff, 0, 0x8000}
+    };
+    uint16_t output[32];
+    for (int sample = 0; sample < 8; sample++) {
+        double wide[8] = {values[sample]};
+        float single[16] = {(float)values[sample]};
+` + calls.String() + `
+    }
+    return 0;
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_scalar_rounding", ir, mainC)
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		const triple = "x86_64-apple-macosx"
+		x86IR := x86FP16NumericalModelIR(t, file, sigs, triple)
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "fp16_scalar_rounding_x86", triple, x86IR, mainC, []string{"/usr/bin/arch", "-x86_64"})
+	}
+}
diff --git a/amd64_raw_fp16_scalar_convert_test.go b/amd64_raw_fp16_scalar_convert_test.go
new file mode 100644
index 000000000..d0622d51a
--- /dev/null
+++ b/amd64_raw_fp16_scalar_convert_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Intel AVX512-FP16 sections 5.18, 5.19, 5.21 and 5.24 rows.
+var fp16ScalarConversionCases = []struct {
+	op                  Op
+	mapNumber, pp, code byte
+	inputBits, outBits  int
+	w                   bool
+}{
+	{"VCVTSH2SS", 6, 0, 0x13, 16, 32, false},
+	{"VCVTSS2SH", 5, 0, 0x1d, 32, 16, false},
+	{"VCVTSH2SD", 5, 2, 0x5a, 16, 64, false},
+	{"VCVTSD2SH", 5, 3, 0x5a, 64, 16, true},
+}
+
+func rawFP16ScalarConversion(index, length, source1, source2, destination, mask int, memory, control, zero bool) []byte {
+	tc := fp16ScalarConversionCases[index]
+	code := encodeX86EVEXFMA3(tc.code, tc.w, byte(length), control, zero, mask, destination, source1, source2)
+	code[1] = code[1]&0xf0 | tc.mapNumber
+	code[2] = code[2]&^3 | tc.pp
+	if memory {
+		code[1] |= 0x60
+		code[5] = 0x40 | byte(destination&7)<<3
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestRawFP16ScalarConversionFormats(t *testing.T) {
+	for index, tc := range fp16ScalarConversionCases {
+		for length := 0; length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if control && memory {
+						continue
+					}
+					for _, mask := range []int{0, 1, 7} {
+						for _, zero := range []bool{false, true} {
+							if zero && mask == 0 {
+								continue
+							}
+							code := rawFP16ScalarConversion(index, length, 20, 21, 22, mask, memory, control, zero)
+							got, err := decodeX86RawDirectiveGroup(code, 64, 0, "FP16 scalar conversion", map[string]bool{})
+							if err != nil || len(got) != 1 || !got[0].x86Encoded {
+								t.Fatalf("%x: %+v, err=%v", code, got, err)
+							}
+							want := tc.op
+							if control {
+								if tc.inputBits == 16 {
+									want += ".SAE"
+								} else {
+									want += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[length]
+								}
+							}
+							if zero {
+								want += ".Z"
+							}
+							source := "X21"
+							if memory {
+								source = fmt.Sprintf("%d(AX)", tc.inputBits/8)
+							}
+							ins := got[0]
+							if ins.Op != want || ins.Args[0].String() != source || ins.Args[1].String() != "X20" || ins.Args[len(ins.Args)-1].String() != "X22" {
+								t.Fatalf("%x: %+v, want %s %s, X20, [mask], X22", code, ins, want, source)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestRawFP16ScalarConversionInvalidAndNamedForms(t *testing.T) {
+	for index, tc := range fp16ScalarConversionCases {
+		for _, change := range []struct {
+			index int
+			bits  byte
+		}{{2, 4}, {2, 0x80}, {3, 0x80}} {
+			code := rawFP16ScalarConversion(index, 0, 1, 2, 3, 0, false, false, false)
+			code[change.index] ^= change.bits
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid scalar conversion", map[string]bool{}); err == nil {
+				t.Fatalf("accepted reserved %x", code)
+			}
+		}
+		code := rawFP16ScalarConversion(index, 0, 1, 2, 3, 0, true, true, false)
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid scalar broadcast", map[string]bool{}); err == nil {
+			t.Fatalf("accepted scalar broadcast %x", code)
+		}
+		for operand := 0; operand < 3; operand++ {
+			registers := [3]int{1, 2, 3}
+			registers[operand] = 8
+			code := rawFP16ScalarConversion(index, 0, registers[0], registers[1], registers[2], 1, false, false, false)
+			if _, err := decodeX86RawDirectiveGroup(code, 32, 0, "386 high scalar conversion", map[string]bool{}); err == nil {
+				t.Fatalf("accepted 386 extended register %x", code)
+			}
+		}
+		source := "TEXT namedScalarHalf(SB),4,$0-0\n" + string(tc.op) + " X0, X1, X2\nRET\n"
+		requireX86GoAssemblerResult(t, "amd64", source, false)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"namedScalarHalf": {Name: "namedScalarHalf", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("accepted named %s", tc.op)
+		}
+	}
+}
+
+func TestRawFP16ScalarConversionLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawScalarHalf(SB),4,$0-0\n")
+	for index := range fp16ScalarConversionCases {
+		for length := 0; length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, mask := range []int{0, 1} {
+					for _, b := range rawFP16ScalarConversion(index, length, 1, 2, 3, mask, memory, !memory, mask != 0) {
+						fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+					}
+				}
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-scalar-half.ll", "raw-scalar-half.o", ir)
+		})
+	}
+}
+
+func TestRawFP16ScalarConversionRIPLiteral(t *testing.T) {
+	for index, tc := range fp16ScalarConversionCases {
+		code := rawFP16ScalarConversion(index, 3, 1, 0, 0, 1, false, false, true)
+		code[5] = 5
+		code = append(code, 1, 0, 0, 0, 0xc3)
+		code = append(code, make([]byte, tc.inputBits/8)...)
+		got, err := decodeX86RawDirectiveGroup(code, 64, 0, "scalar FP16 literal", map[string]bool{})
+		if err != nil || len(got) != 2 || !got[0].x86RIPLiteral || got[0].Args[0].Kind != OpSym {
+			t.Fatalf("%x: %+v, err=%v", code, got, err)
+		}
+		if _, err := decodeX86RawDirectiveGroup(code[:len(code)-1], 64, 0, "truncated scalar FP16 literal", map[string]bool{}); err == nil {
+			t.Fatal("accepted truncated constant pool")
+		}
+	}
+}
diff --git a/amd64_raw_fp16_scalar_move_test.go b/amd64_raw_fp16_scalar_move_test.go
new file mode 100644
index 000000000..cf5e2bcb9
--- /dev/null
+++ b/amd64_raw_fp16_scalar_move_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeRawFP16ScalarMove(opcode, low, upper, dst, mask int, zero bool, length byte) []byte {
+	code := encodeRawScalarMove(true, 2, opcode, low, upper, dst, mask, zero)
+	code[1] = code[1]&^byte(15) | 5
+	code[3] = code[3]&^byte(0x60) | length<<5
+	return code
+}
+
+func TestDecodeRawFP16ScalarMoveGoATReproduction(t *testing.T) {
+	for _, code := range [][]byte{
+		// VMOVSH (DI)(CX*2), X0 and VMOVSH X0, (DX)(CX*2)
+		// from go-highway's GoAT output.
+		{0x62, 0xf5, 0x7e, 0x08, 0x10, 0x04, 0x4f},
+		{0x62, 0xf5, 0x7e, 0x08, 0x11, 0x04, 0x4a},
+		// A complete add/store group, not just a standalone move.
+		{0x62, 0xf5, 0x7e, 0x08, 0x58, 0x04, 0x4e,
+			0x62, 0xf5, 0x7e, 0x08, 0x11, 0x04, 0x4a},
+	} {
+		decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "GoAT VMOVSH", map[string]bool{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		move := decoded[len(decoded)-1]
+		if move.Op != "VMOVSH" || !move.x86Encoded {
+			t.Fatalf("decoded %#v, want final raw VMOVSH", decoded)
+		}
+	}
+}
+
+func TestDecodeRawFP16ScalarMoveCompleteForms(t *testing.T) {
+	for _, opcode := range []int{0x10, 0x11} {
+		for length := byte(0); length < 4; length++ {
+			for _, registers := range [][3]int{{0, 1, 2}, {7, 8, 15}, {16, 23, 31}} {
+				for _, mask := range []int{0, 1, 7} {
+					for _, zero := range []bool{false, true} {
+						if mask == 0 && zero {
+							continue
+						}
+						low, upper, dst := registers[0], registers[1], registers[2]
+						code := encodeRawFP16ScalarMove(opcode, low, upper, dst, mask, zero, length)
+						got, size, ok, err := decodedX86ScalarMoveInstruction(code, 64)
+						wantOp := Op("VMOVSH")
+						if zero {
+							wantOp += ".Z"
+						}
+						want := []Operand{
+							{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", low))},
+							{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", upper))},
+						}
+						if mask != 0 {
+							want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+						}
+						want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", dst))})
+						if err != nil || !ok || size != len(code) || got.Op != wantOp ||
+							!got.x86Encoded || !reflect.DeepEqual(got.Args, want) {
+							t.Fatalf("%x: got %+v, size=%d, ok=%v, err=%v; want %s %+v", code, got, size, ok, err, wantOp, want)
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, opcode := range []byte{0x10, 0x11} {
+		for length := byte(0); length < 4; length++ {
+			for _, mask := range []byte{0, 1, 7} {
+				for _, zero := range []bool{false, true} {
+					if opcode == 0x11 && zero || mask == 0 && zero {
+						continue
+					}
+					code := []byte{0x62, 0xf5, 0x7e, 0x08 | length<<5 | mask, opcode, 0x04, 0x4f}
+					if zero {
+						code[3] |= 0x80
+					}
+					got, size, ok, err := decodedX86ScalarMoveInstruction(code, 64)
+					if err != nil || !ok || size != len(code) || got.Op != "VMOVSH" && got.Op != "VMOVSH.Z" {
+						t.Fatalf("%x: got %+v, size=%d, ok=%v, err=%v", code, got, size, ok, err)
+					}
+					if opcode == 0x10 && (got.Args[0].Kind != OpMem || got.Args[len(got.Args)-1].Reg != "X0") {
+						t.Fatalf("%x: wrong memory load %+v", code, got)
+					}
+					if opcode == 0x11 && (got.Args[0].Reg != "X0" || got.Args[len(got.Args)-1].Kind != OpMem) {
+						t.Fatalf("%x: wrong memory store %+v", code, got)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeRawFP16ScalarMoveInvalidForms(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"missing-modrm", []byte{0x62, 0xf5, 0x7e, 0x08, 0x10}, 64},
+		{"address-override", []byte{0x67, 0x62, 0xf5, 0x7e, 0x08, 0x10, 0xc0}, 64},
+		{"wrong-width", []byte{0x62, 0xf5, 0xfe, 0x08, 0x10, 0xc0}, 64},
+		{"missing-fixed", []byte{0x62, 0xf5, 0x7a, 0x08, 0x10, 0xc0}, 64},
+		{"broadcast", []byte{0x62, 0xf5, 0x7e, 0x18, 0x10, 0xc0}, 64},
+		{"zero-k0", []byte{0x62, 0xf5, 0x7e, 0x88, 0x10, 0xc0}, 64},
+		{"zero-store", []byte{0x62, 0xf5, 0x7e, 0x89, 0x11, 0x00}, 64},
+		{"memory-vvvv", []byte{0x62, 0xf5, 0x76, 0x08, 0x10, 0x00}, 64},
+		{"memory-vprime", []byte{0x62, 0xf5, 0x7e, 0x00, 0x10, 0x00}, 64},
+		{"386-high-register", []byte{0x62, 0x75, 0x7e, 0x08, 0x10, 0xc0}, 32},
+		{"wrong-mode", []byte{0x62, 0xf5, 0x7e, 0x08, 0x10, 0xc0}, 16},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86ScalarMoveInstruction(tc.code, tc.mode); !ok || err == nil {
+				t.Fatalf("invalid %x: matched=%v, err=%v", tc.code, ok, err)
+			}
+		})
+	}
+}
+
+func TestDecodeRawFP16ScalarMoveRIPLiteral(t *testing.T) {
+	code := []byte{0x62, 0xf5, 0x7e, 0x08, 0x10, 0x05, 1, 0, 0, 0, 0xc3, 0x00, 0x3c}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VMOVSH RIP literal", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VMOVSH" ||
+		decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+		decoded[1].Op != OpRET {
+		t.Fatalf("decoded %x as %#v, want source-local FP16 literal", code, decoded)
+	}
+}
+
+func TestTranslateRawFP16ScalarMoveLLVM22Targets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16ScalarMove(SB),4,$0-0\n")
+	for _, code := range [][]byte{
+		{0x62, 0xf5, 0x7e, 0x08, 0x10, 0x04, 0x4f},
+		{0x62, 0xf5, 0x7e, 0x08, 0x11, 0x04, 0x4f},
+		encodeRawFP16ScalarMove(0x10, 1, 2, 3, 7, true, 3),
+		encodeRawFP16ScalarMove(0x11, 4, 5, 6, 1, false, 1),
+	} {
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawFP16ScalarMove": {Name: "rawFP16ScalarMove", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "load i16") || !strings.Contains(ir, "store i16") {
+				t.Fatalf("missing scalar FP16 memory operation:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-fp16-scalar-move.ll", "raw-fp16-scalar-move.o", ir)
+		})
+	}
+}
+
+func TestTranslateRawFP16ScalarMove386LLVM22Targets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFP16ScalarMove386(SB),4,$0-0\n")
+	for _, code := range [][]byte{
+		{0x62, 0xf5, 0x7e, 0x08, 0x10, 0x04, 0x4f},
+		{0x62, 0xf5, 0x7e, 0x09, 0x11, 0x04, 0x4f},
+		encodeRawFP16ScalarMove(0x10, 1, 2, 3, 1, true, 2),
+	} {
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "386", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawFP16ScalarMove386": {Name: "rawFP16ScalarMove386", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-fp16-scalar-move386.ll", "raw-fp16-scalar-move386.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_fp16_sqrt_test.go b/amd64_raw_fp16_sqrt_test.go
new file mode 100644
index 000000000..2852bda18
--- /dev/null
+++ b/amd64_raw_fp16_sqrt_test.go
@@ -0,0 +1,252 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Intel AVX512-FP16 sections 5.74/5.75. Packed SQRT reserves vvvv;
+// scalar SQRT instead uses it as the source of preserved upper X lanes.
+func rawFP16PackedSqrt(length byte, source, destination, mask int, memory, control, zero bool) []byte {
+	code := encodeRawFP16Binary(0x51, length, 0, source, destination, mask, false, control, zero)
+	if memory {
+		code[1] |= 0x60
+		code[5] = byte(0x40 | (destination&7)<<3)
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestRawFP16PackedSqrtRejectsNamedForms(t *testing.T) {
+	const source = "TEXT namedHalfSqrt(SB),4,$0-0\nVSQRTPH X0, X1\nRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, false)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"namedHalfSqrt": {Name: "namedHalfSqrt", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted VSQRTPH absent from Go's named assembler table")
+	}
+}
+
+func TestRawFP16SqrtPortableRuntime(t *testing.T) {
+	runRawFP16SqrtPortable(t, 0)
+}
+
+func TestRawFP16SqrtWideMaskPortableRuntime(t *testing.T) {
+	for _, length := range []byte{1, 2} {
+		t.Run(fmt.Sprintf("lanes%d", 8<<length), func(t *testing.T) {
+			runRawFP16SqrtPortable(t, length)
+		})
+	}
+}
+
+func runRawFP16SqrtPortable(t *testing.T, length byte) {
+	t.Helper()
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, scalar := range []bool{false, true} {
+		for _, zero := range []bool{false, true} {
+			name := fmt.Sprintf("halfSqrt_%t_%t", scalar, zero)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+			source.WriteString("MOVQ input+0(FP), DI\nMOVQ memory+8(FP), AX\nMOVQ out+16(FP), SI\nMOVQ mask+24(FP), CX\n")
+			source.WriteString("KMOVQ CX, K1\nVMOVDQU64 (DI), Z0\nVMOVDQU64 64(DI), Z1\n")
+			code := rawFP16PackedSqrt(length, 0, 0, 1, true, false, zero)
+			if scalar {
+				code = encodeRawFP16ScalarBinary(0x51, 0, 1, 0, 0, 1, true, false, zero)
+			}
+			code[len(code)-1] = 0
+			for _, b := range code {
+				fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+			}
+			source.WriteString("VMOVDQU64 Z0, (SI)\nRET\n")
+			sigs[name] = FuncSig{
+				Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Attrs: "nounwind",
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: I64, Index: 3, Field: -1},
+				}},
+			}
+			lanes, fallback := 8<<length, "input[lane]"
+			if scalar {
+				lanes = 1
+			}
+			if zero {
+				fallback = "0"
+			}
+			upper := "0"
+			if scalar {
+				upper = "lane < 8 ? input[32 + lane] : 0"
+			}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *, uint64_t);\n", name)
+			fmt.Fprintf(&calls, `
+        %s(input, pointer, output, mask);
+        for (int lane = 0; lane < 32; lane++) {
+            uint16_t expected = lane < %d ? ((mask & (UINT64_C(1) << lane)) ? roots[lane] : %s) : (%s);
+            if (output[lane] != expected) {
+                fprintf(stderr, "%s mask %%llx lane %%d: %%04x != %%04x\n",
+                        (unsigned long long)mask, lane, output[lane], expected);
+                return 2;
+            }
+        }
+`, name, lanes, fallback, upper, name)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86TestGuardPagesC + `
+int main(void) {
+    if (setup_guard()) return 1;
+    // Independent bit-pattern oracle: sqrt(0, -0, 1, 4, 9, 16, 2^-24, +inf).
+    const uint16_t seeds[] = {0, 0x8000, 0x3c00, 0x4400, 0x4880, 0x4c00, 1, 0x7c00};
+    const uint16_t answers[] = {0, 0x8000, 0x3c00, 0x4000, 0x4200, 0x4400, 0x0c00, 0x7c00};
+    const uint64_t masks[] = {0, 1, 0xff, UINT64_C(1) << 60, 0xffff, 0xffff0000, 0x80000000, 0xffffffff};
+    const uint64_t active = ` + fmt.Sprintf("UINT64_C(0x%x)", uint64(1)<<(8<<length)-1) + `;
+    uint16_t memory[32], roots[32];
+    for (int lane = 0; lane < 32; lane++) {
+        memory[lane] = seeds[lane % 8];
+        roots[lane] = answers[lane % 8];
+    }
+    uint16_t input[64], output[32];
+    for (int lane = 0; lane < 64; lane++) input[lane] = (uint16_t)(0x1000 + lane);
+    for (unsigned mi = 0; mi < sizeof(masks) / sizeof(masks[0]); mi++) {
+        uint64_t mask = masks[mi];
+        const void *pointer = memory;
+        if ((mask & active) == 0) pointer = NULL;
+        if (mask == 1) {
+            memcpy(guard + page - 3, memory, 2);
+            pointer = guard + page - 3;
+        }
+` + calls.String() + `
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_sqrt_portable", ir, mainC)
+}
+
+func TestDecodeRawFP16PackedSqrtFormats(t *testing.T) {
+	for length := byte(0); length < 4; length++ {
+		for _, memory := range []bool{false, true} {
+			for _, control := range []bool{false, true} {
+				if length == 3 && (!control || memory) {
+					continue
+				}
+				for _, mask := range []int{0, 1, 7} {
+					for _, zero := range []bool{false, true} {
+						if zero && mask == 0 {
+							continue
+						}
+						code := rawFP16PackedSqrt(length, 20, 21, mask, memory, control, zero)
+						got, size, ok, err := decodedX86SameWidthConversionInstruction(code, 64)
+						if err != nil || !ok || size != len(code) {
+							t.Fatalf("%x: got %+v, size=%d, ok=%v, err=%v", code, got, size, ok, err)
+						}
+						want := Op("VSQRTPH")
+						vl := length
+						if control {
+							if memory {
+								want += ".BCST"
+							} else {
+								want += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[length]
+								vl = 2
+							}
+						}
+						if zero {
+							want += ".Z"
+						}
+						prefix := [...]string{"X", "Y", "Z"}[vl]
+						if got.Op != want || !got.x86Encoded || got.Args[len(got.Args)-1].String() != prefix+"21" {
+							t.Fatalf("%x: got %+v, want raw %s with %s21", code, got, want, prefix)
+						}
+						wantSource := prefix + "20"
+						if memory {
+							width := 16 << vl
+							if control {
+								width = 2
+							}
+							wantSource = fmt.Sprintf("%d(AX)", width)
+						}
+						if got.Args[0].String() != wantSource {
+							t.Fatalf("%x: source %s, want %s", code, got.Args[0], wantSource)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeRawFP16PackedSqrtInvalidForms(t *testing.T) {
+	for _, tc := range []struct {
+		index int
+		bits  byte
+	}{
+		{2, 0x80}, // W1.
+		{2, 0x04}, // Fixed bit cleared.
+		{2, 0x08}, // Reserved vvvv.
+		{3, 0x08}, // Reserved V'.
+		{3, 0x80}, // Zeroing with K0.
+		{3, 0x60}, // Reserved packed length.
+	} {
+		code := rawFP16PackedSqrt(0, 1, 2, 0, false, false, false)
+		code[tc.index] ^= tc.bits
+		if _, _, ok, err := decodedX86SameWidthConversionInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("accepted invalid %x: matched=%v, err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateRawFP16PackedSqrtLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawHalfSqrt(SB),4,$0-0\n")
+	for length := byte(0); length < 4; length++ {
+		for _, memory := range []bool{false, true} {
+			for _, control := range []bool{false, true} {
+				if length == 3 && (!control || memory) {
+					continue
+				}
+				code := rawFP16PackedSqrt(length, 1, 2, 1, memory, control, true)
+				for _, b := range code {
+					fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+				}
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range []struct {
+		arch, triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			for _, want := range []string{"vsqrtph ", "{rn-sae}", "{rd-sae}", "{ru-sae}", "{rz-sae}",
+				"{1to8}", "{1to16}", "{1to32}", "kmovd", "asm sideeffect", "+avx512fp16"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %s", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-half-sqrt.ll", "raw-half-sqrt.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_funnel_shift_test.go b/amd64_raw_funnel_shift_test.go
new file mode 100644
index 000000000..b938de215
--- /dev/null
+++ b/amd64_raw_funnel_shift_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawDirectiveGroupFunnelShiftCompleteFamily(t *testing.T) {
+	// Bytes are Go 1.27 assembler oracle cases spanning immediate/variable,
+	// left/right, W/D/Q, and high EVEX registers.
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "left immediate w", code: []byte{0x62, 0x13, 0xc5, 0x0b, 0x70, 0xd8, 0x41}, want: "VPSHLDW $65, X24, X7, K3, X11"},
+		{name: "left immediate d", code: []byte{0x62, 0x43, 0x05, 0x04, 0x71, 0xd0, 0x2f}, want: "VPSHLDD $47, X8, X31, K4, X26"},
+		{name: "left immediate q", code: []byte{0x62, 0x33, 0xd5, 0x04, 0x71, 0xfe, 0x5e}, want: "VPSHLDQ $94, X22, X21, K4, X15"},
+		{name: "right immediate w", code: []byte{0x62, 0xc3, 0xfd, 0x09, 0x72, 0xf7, 0x1b}, want: "VPSHRDW $27, X15, X0, K1, X22"},
+		{name: "right immediate q", code: []byte{0x62, 0x53, 0xfd, 0x03, 0x73, 0xee, 0x2a}, want: "VPSHRDQ $42, X14, X16, K3, X13"},
+		{name: "left variable w", code: []byte{0x62, 0x32, 0xb5, 0x0f, 0x70, 0xea}, want: "VPSHLDVW X18, X9, K7, X13"},
+		{name: "left variable d", code: []byte{0x62, 0xd2, 0x75, 0x0f, 0x71, 0xff}, want: "VPSHLDVD X15, X1, K7, X7"},
+		{name: "left variable q", code: []byte{0x62, 0x72, 0xf5, 0x07, 0x71, 0xe3}, want: "VPSHLDVQ X3, X17, K7, X12"},
+		{name: "right variable w", code: []byte{0x62, 0xf2, 0xed, 0x0f, 0x72, 0xc2}, want: "VPSHRDVW X2, X2, K7, X0"},
+		{name: "right variable d", code: []byte{0x62, 0x32, 0x1d, 0x0a, 0x73, 0xc7}, want: "VPSHRDVD X23, X12, K2, X8"},
+		{name: "right variable q", code: []byte{0x62, 0x22, 0xa5, 0x09, 0x73, 0xc4}, want: "VPSHRDVQ X20, X11, K1, X24"},
+		{name: "left variable d broadcast zero", code: []byte{0x62, 0xf2, 0x75, 0xdb, 0x71, 0x50, 0x7f}, want: "VPSHLDVD.BCST.Z 508(AX), Z1, K3, Z2"},
+		{name: "right immediate q broadcast zero", code: []byte{0x62, 0xf3, 0xf5, 0xdb, 0x73, 0x50, 0x7f, 0x09}, want: "VPSHRDQ.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			decoded, err := decodeX86RawDirectiveGroup(test.code, 64, 0, test.name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %x as %#v, want %q", test.code, decoded, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86RawFunnelShiftAllRegisterFields(t *testing.T) {
+	for _, operation := range []struct {
+		op       Op
+		opcode   byte
+		mapValue byte
+		w        byte
+		variable bool
+	}{
+		{op: "VPSHLDW", opcode: 0x70, mapValue: 3, w: 1},
+		{op: "VPSHLDD", opcode: 0x71, mapValue: 3},
+		{op: "VPSHLDQ", opcode: 0x71, mapValue: 3, w: 1},
+		{op: "VPSHRDW", opcode: 0x72, mapValue: 3, w: 1},
+		{op: "VPSHRDD", opcode: 0x73, mapValue: 3},
+		{op: "VPSHRDQ", opcode: 0x73, mapValue: 3, w: 1},
+		{op: "VPSHLDVW", opcode: 0x70, mapValue: 2, w: 1, variable: true},
+		{op: "VPSHLDVD", opcode: 0x71, mapValue: 2, variable: true},
+		{op: "VPSHLDVQ", opcode: 0x71, mapValue: 2, w: 1, variable: true},
+		{op: "VPSHRDVW", opcode: 0x72, mapValue: 2, w: 1, variable: true},
+		{op: "VPSHRDVD", opcode: 0x73, mapValue: 2, variable: true},
+		{op: "VPSHRDVQ", opcode: 0x73, mapValue: 2, w: 1, variable: true},
+	} {
+		for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 |
+							byte((^first>>4)&1)<<6 |
+							byte((^first>>3)&1)<<5 |
+							byte((^destination>>4)&1)<<4 | operation.mapValue
+						p1 := operation.w<<7 | byte(^second&15)<<3 | 5
+						p2 := byte(vectorBits)<<5 | byte((^second>>4)&1)<<3
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0x62, p0, p1, p2, operation.opcode, modRM}
+						if !operation.variable {
+							encoding = append(encoding, 0xa5)
+						}
+						instruction, length, ok, err := decodedX86FunnelShiftInstruction(encoding, 64)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("op=%s width=%s first=%d second=%d destination=%d: ok=%v length=%d err=%v", operation.op, vectorName, first, second, destination, ok, length, err)
+						}
+						immediate := ""
+						if !operation.variable {
+							immediate = "$165, "
+						}
+						want := fmt.Sprintf("%s %s%s%d, %s%d, %s%d", operation.op, immediate, vectorName, first, vectorName, second, vectorName, destination)
+						if instruction.Raw != want {
+							t.Fatalf("encoding %x decoded as %q, want %q", encoding, instruction.Raw, want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawFunnelShiftRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "386 immediate operand limit", mode: 32, encoding: []byte{0x62, 0xf3, 0xf5, 0x08, 0x73, 0xc2, 1}, wantOK: true},
+		{name: "386 variable masked operand limit", mode: 32, encoding: []byte{0x62, 0xf2, 0xf5, 0x09, 0x73, 0xc2}, wantOK: true},
+		{name: "386 variable extended register", mode: 32, encoding: []byte{0x62, 0x72, 0xf5, 0x08, 0x73, 0xc2}, wantOK: true},
+		{name: "reserved vector length", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x68, 0x73, 0xc2}, wantOK: true},
+		{name: "word broadcast", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x18, 0x72, 0x10}, wantOK: true},
+		{name: "broadcast register", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x18, 0x73, 0xc2}, wantOK: true},
+		{name: "zero without mask", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x88, 0x73, 0xc2}, wantOK: true},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0x62, 0xf2, 0xf5, 0x08, 0x73, 0xc2}, wantOK: true},
+		{name: "wrong map", mode: 64, encoding: []byte{0x62, 0xf1, 0xf5, 0x08, 0x73, 0xc2}, wantOK: false},
+		{name: "wrong prefix", mode: 64, encoding: []byte{0x62, 0xf2, 0xf4, 0x08, 0x73, 0xc2}, wantOK: false},
+		{name: "word wrong w", mode: 64, encoding: []byte{0x62, 0xf2, 0x75, 0x08, 0x72, 0xc2}, wantOK: true},
+		{name: "truncated immediate", mode: 64, encoding: []byte{0x62, 0xf3, 0xf5, 0x08, 0x73, 0xc2}, wantOK: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86FunnelShiftInstruction(test.encoding, test.mode)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x: ok=%v, want %v (err=%v)", test.encoding, ok, test.wantOK, err)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("encoding %x was recognized without rejection", test.encoding)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_gather.go b/amd64_raw_gather.go
new file mode 100644
index 000000000..f1edd36cc
--- /dev/null
+++ b/amd64_raw_gather.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The eight data-gather spellings share the same opcode axes in Go's
+// _yvgatherdps, _yvgatherdpd and _yvgatherqps tables. The ModRM/SIB operand
+// is VSIB memory: its index is a vector register, never a GP register.
+var x86GatherOps = [4][2]Op{
+	{"VPGATHERDD", "VPGATHERDQ"},
+	{"VPGATHERQD", "VPGATHERQQ"},
+	{"VGATHERDPS", "VGATHERDPD"},
+	{"VGATHERQPS", "VGATHERQPD"},
+}
+
+// The four packed and four floating-point scatter spellings mirror the EVEX
+// gather VSIB axes, but encode the data vector in ModRM.reg and store to VSIB.
+var x86ScatterOps = [4][2]Op{
+	{"VPSCATTERDD", "VPSCATTERDQ"},
+	{"VPSCATTERQD", "VPSCATTERQQ"},
+	{"VSCATTERDPS", "VSCATTERDPD"},
+	{"VSCATTERQPS", "VSCATTERQPD"},
+}
+
+func decodedX86RawScatterInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || !p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		p.opcode < 0xa0 || p.opcode > 0xa3 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("raw scatter: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.vectorLength > 2 || p.mask == 0 || p.zero ||
+		p.broadcast || p.upper&15 != 0 {
+		return fail("invalid EVEX fixed, length, mask, zeroing, broadcast or vvvv bits")
+	}
+	if len(code) < p.modRM+2 {
+		return fail("missing ModRM or VSIB byte")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 == 3 || modRM&7 != 4 {
+		return fail("scatter requires VSIB memory")
+	}
+	w := 0
+	if p.w {
+		w = 1
+	}
+	op := x86ScatterOps[p.opcode-0xa0][w]
+	spec := amd64ScatterSpecs[string(op)]
+	widths := [...]string{"X", "Y", "Z"}
+	dataWidth := widths[p.vectorLength]
+	indexWidth := dataWidth
+	switch spec.table {
+	case amd64GatherDPD:
+		if p.vectorLength > 0 {
+			indexWidth = widths[p.vectorLength-1]
+		}
+	case amd64GatherQPS:
+		if p.vectorLength > 0 {
+			dataWidth = widths[p.vectorLength-1]
+		}
+	}
+	dataNumber := int(modRM>>3&7) + p.r*8
+	indexNumber := int(code[p.modRM+1]>>3&7) + p.x*8 + p.upper&16
+	if mode == 32 && (indexNumber >= 8 || p.b != 0 ||
+		dataWidth == "Z" && dataNumber >= 8) {
+		return fail("extended register unavailable in 32-bit mode")
+	}
+	memory, consumed, err := decodedX86RMSource(
+		code[p.modRM:], mode, p.b, p.x, p.segment, spec.elemBits/8,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	memory.Mem.Index = Reg(fmt.Sprintf("%s%d", indexWidth, indexNumber))
+	memory.Mem.Scale = int64(1 << (code[p.modRM+1] >> 6))
+	data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", dataWidth, dataNumber))}
+	mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))}
+	args := []Operand{data, mask, memory}
+	return Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s %s, %s, %s", op, data.String(), mask.String(), memory.String()),
+	}, p.modRM + consumed, true, nil
+}
+
+func decodedX86RawGatherInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || p.mapNumber != 2 || p.pp != 1 || p.opcode < 0x90 || p.opcode > 0x93 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("raw gather: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.evex && (!p.fixed || p.vectorLength > 2 || p.mask == 0 || p.zero || p.broadcast || p.upper&15 != 0) {
+		return fail("invalid EVEX fixed, length, mask, zeroing, broadcast or vvvv bits")
+	}
+	if len(code) < p.modRM+2 {
+		return fail("missing ModRM or VSIB byte")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 == 3 || modRM&7 != 4 {
+		return fail("gather requires VSIB memory")
+	}
+
+	w := 0
+	if p.w {
+		w = 1
+	}
+	op := x86GatherOps[p.opcode-0x90][w]
+	spec := amd64GatherSpecs[op]
+	widths := [...]string{"X", "Y", "Z"}
+	destinationWidth := widths[p.vectorLength]
+	indexWidth := destinationWidth
+	switch spec.table {
+	case amd64GatherDPD:
+		if p.vectorLength > 0 {
+			indexWidth = widths[p.vectorLength-1]
+		}
+	case amd64GatherQPS:
+		if p.vectorLength > 0 {
+			destinationWidth = widths[p.vectorLength-1]
+		}
+	}
+	destinationNumber := int(modRM>>3&7) + p.r*8
+	indexNumber := int(code[p.modRM+1]>>3&7) + p.x*8
+	if p.evex {
+		indexNumber += p.upper & 16
+	}
+	if mode == 32 && (indexNumber >= 8 || p.b != 0 ||
+		!p.evex && (destinationNumber >= 8 || p.upper >= 8) ||
+		p.evex && destinationWidth == "Z" && destinationNumber >= 8) {
+		return fail("extended register unavailable in 32-bit mode")
+	}
+
+	disp8Scale := 1
+	if p.evex {
+		disp8Scale = spec.elemBits / 8
+	}
+	memory, consumed, err := decodedX86RMSource(code[p.modRM:], mode, p.b, p.x, p.segment, disp8Scale)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	memory.Mem.Index = Reg(fmt.Sprintf("%s%d", indexWidth, indexNumber))
+	memory.Mem.Scale = int64(1 << (code[p.modRM+1] >> 6))
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationWidth, destinationNumber))}
+	var args []Operand
+	if p.evex {
+		mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))}
+		args = []Operand{memory, mask, destination}
+	} else {
+		mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationWidth, p.upper))}
+		args = []Operand{mask, memory, destination}
+	}
+	printed := make([]string, len(args))
+	for i, arg := range args {
+		printed[i] = arg.String()
+	}
+	return Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_gather_test.go b/amd64_raw_gather_test.go
new file mode 100644
index 000000000..c709fb11b
--- /dev/null
+++ b/amd64_raw_gather_test.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawVEXGatherCorpusEncoding(t *testing.T) {
+	const source = "TEXT rawgather(SB),4,$0-0\n\tVPGATHERDD Y2, (R8)(Y0*2), Y1\n\tRET\n"
+	code := assembleX87ControlBytes(t, "amd64", source)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	named, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+	}
+	for i, got := range decoded.Instrs {
+		if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+			t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+		}
+	}
+}
+
+func TestX86RawVEXGatherGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT gatherforms(SB),4,$0-0\n")
+			for _, variants := range x86GatherOps {
+				for _, op := range variants {
+					for width := 0; width < 2; width++ {
+						destinationWidth, indexWidth := "X", "X"
+						if width == 1 {
+							switch amd64GatherSpecs[op].table {
+							case amd64GatherDPS:
+								destinationWidth, indexWidth = "Y", "Y"
+							case amd64GatherDPD:
+								destinationWidth = "Y"
+							case amd64GatherQPS:
+								indexWidth = "Y"
+							}
+						}
+						fmt.Fprintf(&source, "%s %s1, 4(BX)(%s2*2), %s3\n", op, destinationWidth, indexWidth, destinationWidth)
+						fmt.Fprintf(&source, "%s %s1, 256(%s4*8), %s3\n", op, destinationWidth, indexWidth, destinationWidth)
+						if arch == "amd64" {
+							fmt.Fprintf(&source, "%s %s14, -32(R8)(%s13*4), %s15\n", op, destinationWidth, indexWidth, destinationWidth)
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawEVEXGatherGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT evexgatherforms(SB),4,$0-0\n")
+			for _, variants := range x86GatherOps {
+				for _, op := range variants {
+					for width := 0; width < 3; width++ {
+						widths := [...]string{"X", "Y", "Z"}
+						destinationWidth := widths[width]
+						indexWidth := destinationWidth
+						switch amd64GatherSpecs[op].table {
+						case amd64GatherDPD:
+							if width > 0 {
+								indexWidth = widths[width-1]
+							}
+						case amd64GatherQPS:
+							if width > 0 {
+								destinationWidth = widths[width-1]
+							}
+						}
+						fmt.Fprintf(&source, "%s 8(BX)(%s2*4), K1, %s3\n", op, indexWidth, destinationWidth)
+						if arch == "amd64" {
+							fmt.Fprintf(&source, "%s -32(R8)(%s18*2), K7, %s21\n", op, indexWidth, destinationWidth)
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawVEXGatherRejectsMalformedForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"missing SIB", []byte{0xc4, 0xc2, 0x6d, 0x90, 0x0c}, 64},
+		{"register source", []byte{0xc4, 0xc2, 0x6d, 0x90, 0xc0, 0x40}, 64},
+		{"GP index", []byte{0xc4, 0xc2, 0x6d, 0x90, 0x08, 0x40}, 64},
+		{"missing displacement", []byte{0xc4, 0xc2, 0x6d, 0x90, 0x4c, 0x40}, 64},
+		{"address override", []byte{0x67, 0xc4, 0xc2, 0x6d, 0x90, 0x0c, 0x40}, 64},
+		{"high VSIB index on 386", []byte{0xc4, 0x82, 0x6d, 0x90, 0x0c, 0x40}, 32},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, matched, err := decodedX86RawGatherInstruction(test.code, test.mode); !matched || err == nil {
+				t.Fatalf("invalid %x: matched=%v err=%v", test.code, matched, err)
+			}
+		})
+	}
+}
+
+func TestX86RawEVEXGatherRejectsReservedForms(t *testing.T) {
+	const source = "TEXT evexgather(SB),4,$0-0\n\tVPGATHERDD 8(BX)(X2*4), K1, X3\n\tRET\n"
+	assembled := assembleX87ControlBytes(t, "amd64", source)
+	if len(assembled) < 8 || assembled[0] != 0x62 {
+		t.Fatalf("Go did not emit an EVEX gather: %x", assembled)
+	}
+	valid := assembled[:len(assembled)-1]
+	for _, test := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"missing mask", func(code []byte) []byte { code[3] &^= 7; return code }},
+		{"zeroing", func(code []byte) []byte { code[3] |= 0x80; return code }},
+		{"broadcast", func(code []byte) []byte { code[3] |= 0x10; return code }},
+		{"reserved length", func(code []byte) []byte { code[3] |= 0x60; return code }},
+		{"reserved vvvv", func(code []byte) []byte { code[2] &^= 0x08; return code }},
+		{"missing fixed bit", func(code []byte) []byte { code[2] &^= 0x04; return code }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.mutate(append([]byte(nil), valid...))
+			if _, _, matched, err := decodedX86RawGatherInstruction(code, 64); !matched || err == nil {
+				t.Fatalf("invalid %x: matched=%v err=%v", code, matched, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawGatherLLVM22AllTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, form := range []struct {
+		name   string
+		source string
+	}{
+		{"VEX", "TEXT rawgather(SB),4,$0-0\n\tVPGATHERDD X2, (BX)(X0*2), X1\n\tRET\n"},
+		{"EVEX", "TEXT rawgather(SB),4,$0-0\n\tVPGATHERDD (BX)(X0*2), K1, X2\n\tRET\n"},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			for _, target := range []struct {
+				goarch string
+				triple string
+			}{
+				{"amd64", "x86_64-apple-darwin"},
+				{"amd64", "x86_64-unknown-linux-gnu"},
+				{"amd64", "x86_64-pc-windows-msvc"},
+				{"386", "i386-unknown-linux-gnu"},
+				{"386", "i686-pc-windows-msvc"},
+			} {
+				t.Run(target.triple, func(t *testing.T) {
+					code := assembleX87ControlBytes(t, target.goarch, form.source)
+					file := x86RawUnprovedReturnFormProbeFile(t, target.goarch, "rawgather", code)
+					// A terminal byte cannot supply the preceding gather's
+					// index, mask, merge input or native-memory authority.
+					ir := x86UnboundVoidRawProbeObject(t, file, target.goarch, target.triple)
+					compileLLVMToObject(t, llc, target.triple, "raw-gather.ll", "raw-gather.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_raw_gfni.go b/amd64_raw_gfni.go
new file mode 100644
index 000000000..aac52af6b
--- /dev/null
+++ b/amd64_raw_gfni.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The Go 1.27 table has one GFNI family: multiply (0F38 CF, W0) and the
+// affine/inverse pair (0F3A CE/CF, W1). Its VEX rows are X/Y; EVEX adds Z,
+// masks, zeroing and, only for the affine matrix source, qword broadcast.
+func decodedX86GFNIInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok {
+		return Instr{}, 0, false, nil
+	}
+
+	var op Op
+	var immediate bool
+	switch {
+	case p.mapNumber == 2 && p.opcode == 0xcf:
+		op = "VGF2P8MULB"
+	case p.mapNumber == 3 && p.opcode == 0xce:
+		op, immediate = "VGF2P8AFFINEQB", true
+	case p.mapNumber == 3 && p.opcode == 0xcf:
+		op, immediate = "VGF2P8AFFINEINVQB", true
+	default:
+		return Instr{}, 0, false, nil
+	}
+	if p.w != immediate {
+		return Instr{}, 0, true, fmt.Errorf("%s has invalid W bit", op)
+	}
+	if p.broadcast && !immediate {
+		return Instr{}, 0, true, fmt.Errorf("%s has no broadcast form", op)
+	}
+
+	laneBits := 8
+	if immediate {
+		laneBits = 64
+	}
+	instruction, length, _, err := decodedX86BinaryVectorOperands(code, p, mode, op, laneBits)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if !immediate {
+		return instruction, length, true, nil
+	}
+	if len(code) <= length {
+		return Instr{}, 0, true, fmt.Errorf("%s is missing its imm8", op)
+	}
+	instruction.Args = append([]Operand{{Kind: OpImm, Imm: int64(code[length])}}, instruction.Args...)
+	length++
+	parts := make([]string, len(instruction.Args))
+	for index, arg := range instruction.Args {
+		parts[index] = arg.String()
+	}
+	instruction.Raw = fmt.Sprintf("%s %s", instruction.Op, strings.Join(parts, ", "))
+	return instruction, length, true, nil
+}
diff --git a/amd64_raw_gfni_test.go b/amd64_raw_gfni_test.go
new file mode 100644
index 000000000..045651907
--- /dev/null
+++ b/amd64_raw_gfni_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawGFNIGoFECRegression(t *testing.T) {
+	// GoFEC v1.4.2 emits this EVEX-512 affine instruction as BYTE directives.
+	code := []byte{0x62, 0xf3, 0x85, 0x48, 0xce, 0xc8, 0x00}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "GoFEC GFNI", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, "VGF2P8AFFINEQB $0, Z0, Z15, Z1 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawGFNICompleteGoFamily(t *testing.T) {
+	for _, family := range []struct {
+		name   string
+		mapID  byte
+		opcode byte
+		w      byte
+		imm    bool
+	}{
+		{name: "VGF2P8MULB", mapID: 2, opcode: 0xcf},
+		{name: "VGF2P8AFFINEQB", mapID: 3, opcode: 0xce, w: 1, imm: true},
+		{name: "VGF2P8AFFINEINVQB", mapID: 3, opcode: 0xcf, w: 1, imm: true},
+	} {
+		for _, encoding := range []struct {
+			name    string
+			width   int
+			evex    bool
+			masked  bool
+			zeroing bool
+		}{
+			{name: "vex-x", width: 0},
+			{name: "vex-y", width: 1},
+			{name: "evex-x", width: 0, evex: true},
+			{name: "evex-y-mask", width: 1, evex: true, masked: true},
+			{name: "evex-z-zero", width: 2, evex: true, masked: true, zeroing: true},
+		} {
+			t.Run(family.name+"/"+encoding.name, func(t *testing.T) {
+				width := []string{"X", "Y", "Z"}[encoding.width]
+				var code []byte
+				if encoding.evex {
+					last := byte(encoding.width<<5) | 0x08
+					if encoding.masked {
+						last |= 1
+					}
+					if encoding.zeroing {
+						last |= 0x80
+					}
+					code = []byte{0x62, 0xf0 | family.mapID, family.w<<7 | 0x75, last, family.opcode, 0xd0}
+				} else {
+					code = []byte{0xc4, 0xe0 | family.mapID, family.w<<7 | 0x71 | byte(encoding.width<<2), family.opcode, 0xd0}
+				}
+				if family.imm {
+					code = append(code, 0x63)
+				}
+				instruction, length, ok, err := decodedX86GFNIInstruction(code, 64)
+				if !ok || err != nil || length != len(code) {
+					t.Fatalf("decode %x: ok=%v length=%d err=%v", code, ok, length, err)
+				}
+				args := fmt.Sprintf("%s0, %s1", width, width)
+				if family.imm {
+					args = "$99, " + args
+				}
+				if encoding.masked {
+					args += ", K1"
+				}
+				wantOp := family.name
+				if encoding.zeroing {
+					wantOp += ".Z"
+				}
+				want := fmt.Sprintf("%s %s, %s2", wantOp, args, width)
+				if instruction.Raw != want {
+					t.Fatalf("decode %x as %q, want %q", code, instruction.Raw, want)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawGFNIRejectsReservedForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{name: "affine wrong W", code: []byte{0x62, 0xf3, 0x75, 0x48, 0xce, 0xd0, 0x63}},
+		{name: "multiply wrong W", code: []byte{0x62, 0xf2, 0xf5, 0x48, 0xcf, 0xd0}},
+		{name: "multiply broadcast", code: []byte{0x62, 0xf2, 0x75, 0x58, 0xcf, 0x50, 0x01}},
+		{name: "affine broadcast register", code: []byte{0x62, 0xf3, 0xf5, 0x58, 0xce, 0xd0, 0x63}},
+		{name: "zero without mask", code: []byte{0x62, 0xf3, 0xf5, 0xc8, 0xce, 0xd0, 0x63}},
+		{name: "truncated immediate", code: []byte{0x62, 0xf3, 0xf5, 0x48, 0xce, 0xd0}},
+		{name: "reserved vector length", code: []byte{0x62, 0xf3, 0xf5, 0x68, 0xce, 0xd0, 0x63}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86GFNIInstruction(test.code, 64)
+			if !ok || err == nil {
+				t.Fatalf("decode %x: ok=%v err=%v, want recognized rejection", test.code, ok, err)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawGFNIMemoryAndBroadcast(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "vex multiply memory", code: []byte{0xc4, 0xe2, 0x71, 0xcf, 0x50, 0x08}, want: "VGF2P8MULB 8(AX), X1, X2"},
+		{name: "evex affine broadcast", code: []byte{0x62, 0xf3, 0xf5, 0x59, 0xce, 0x50, 0x01, 0x63}, want: "VGF2P8AFFINEQB.BCST $99, 8(AX), Z1, K1, Z2"},
+		{name: "evex inverse broadcast zero", code: []byte{0x62, 0xf3, 0xf5, 0xd9, 0xcf, 0x50, 0x01, 0xa5}, want: "VGF2P8AFFINEINVQB.BCST.Z $165, 8(AX), Z1, K1, Z2"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86GFNIInstruction(test.code, 64)
+			if !ok || err != nil || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode %x = %q, length=%d, ok=%v, err=%v; want %q", test.code, instruction.Raw, length, ok, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawGFNIAllObjectTargets(t *testing.T) {
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawgfni(SB),$0-0\n")
+			for _, instruction := range [][]byte{
+				{0xc4, 0xe2, 0x71, 0xcf, 0xd0},
+				{0xc4, 0xe3, 0xf1, 0xce, 0xd0, 0x63},
+				{0x62, 0xf3, 0xf5, 0xc9, 0xcf, 0xd0, 0xa5},
+			} {
+				for _, value := range instruction {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawgfni": {Name: "rawgfni", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-gfni.ll", "raw-gfni.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_horizontal_float_literal_test.go b/amd64_raw_horizontal_float_literal_test.go
new file mode 100644
index 000000000..fc3bb3160
--- /dev/null
+++ b/amd64_raw_horizontal_float_literal_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawHorizontalFloatLiteral(opcode, pp byte, vex3 bool, width int) []byte {
+	code := encodeX86VEXHorizontalFloat(opcode, pp, vex3, width == 32, false, 1, 2, 0)
+	code[len(code)-1] = 0x0d // RIP+disp32, destination X/Y1.
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*11+7))
+	}
+	return code
+}
+
+func TestDecodeX86RawHorizontalFloatRIPDataCompleteFamily(t *testing.T) {
+	for opcode, stem := range map[byte]string{0x7c: "VHADD", 0x7d: "VHSUB", 0xd0: "VADDSUB"} {
+		for pp, suffix := range map[byte]string{1: "PD", 3: "PS"} {
+			for _, vex3 := range []bool{false, true} {
+				for _, width := range []int{16, 32} {
+					name := fmt.Sprintf("%s%s/vex3%t/%d", stem, suffix, vex3, width)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawHorizontalFloatLiteral(opcode, pp, vex3, width)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded) != 2 || decoded[0].Op != Op(stem+suffix) ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET ||
+							!bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-width:]) {
+							t.Fatalf("decoded %x as %#v", code, decoded)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawHorizontalFloatRIPDataRejectsUnsafeSources(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source":        func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte { code[5] = 127; return code },
+		"overlapping instruction": func(code []byte) []byte { code[5] = 0; return code },
+		"segment override":        func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address override":        func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawHorizontalFloatLiteral(0xd0, 1, true, 32))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe horizontal/alternating RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawHorizontalFloatRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	for opcode, stem := range map[byte]string{0x7c: "VHADD", 0x7d: "VHSUB", 0xd0: "VADDSUB"} {
+		for pp, suffix := range map[byte]string{1: "PD", 3: "PS"} {
+			name := "literal" + stem + suffix
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range x86RawHorizontalFloatLiteral(opcode, pp, true, 32) {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-horizontal-float-literal.ll", "raw-horizontal-float-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_horizontal_integer.go b/amd64_raw_horizontal_integer.go
new file mode 100644
index 000000000..b619228f4
--- /dev/null
+++ b/amd64_raw_horizontal_integer.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "fmt"
+
+// Go's VPHADD/PHSUB family has two _yvaddsubpd rows, X and Y, without
+// EVEX/masks. W is ignored (Go emits W0); Intel XED leaves W unconstrained:
+// https://github.com/intelxed/xed/blob/main/datafiles/avx/avx-isa.txt
+func decodedX86VEXHorizontalIntegerInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	for name, spec := range amd64HorizontalIntegerSpecs {
+		if spec.vector && int(spec.opcode) == p.opcode {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("horizontal integer: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.pp != 1 || p.vectorLength > 1 {
+		return fail("requires VEX.66.0F38 X/Y encoding")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.x != 0 || p.b != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+	width := []string{"X", "Y"}[p.vectorLength]
+	source2, size, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	source1 := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, int(code[p.modRM]>>3&7)+p.r*8))}
+	return Instr{
+		Op: op, Args: []Operand{source2, source1, destination},
+		Raw: fmt.Sprintf("%s %s, %s, %s", op, source2.String(), source1.String(), destination.String()),
+	}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_horizontal_integer_test.go b/amd64_raw_horizontal_integer_test.go
new file mode 100644
index 000000000..fe8272af7
--- /dev/null
+++ b/amd64_raw_horizontal_integer_test.go
@@ -0,0 +1,338 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86RawHorizontalIntegerEncodingAxes(t *testing.T) {
+	count := 0
+	for _, form := range []struct {
+		op     Op
+		opcode byte
+	}{
+		{"VPHADDW", 0x01}, {"VPHADDD", 0x02}, {"VPHADDSW", 0x03},
+		{"VPHSUBW", 0x05}, {"VPHSUBD", 0x06}, {"VPHSUBSW", 0x07},
+	} {
+		for width, prefix := range []string{"X", "Y"} {
+			for _, w := range []bool{false, true} {
+				for dst := 0; dst < 16; dst++ {
+					for src1 := 0; src1 < 16; src1++ {
+						for src2 := 0; src2 < 16; src2++ {
+							code := encodeX86VEXHorizontalFloat(form.opcode, 1, true, width == 1, w, dst, src1, src2)
+							code[1] = code[1]&0xe0 | 2
+							got, size, matched, err := decodedX86VEXHorizontalIntegerInstruction(code, 64)
+							want := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src2))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src1))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, dst))}}
+							if err != nil || !matched || size != len(code) || got.Op != form.op || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x=%+v size=%d matched=%v err=%v; want %s %+v", code, got, size, matched, err, form.op, want)
+							}
+							_, _, matched, err = decodedX86VEXHorizontalIntegerInstruction(code, 32)
+							if !matched || (err != nil) != (dst >= 8 || src1 >= 8 || src2 >= 8) {
+								t.Fatalf("386 decode %x matched=%v err=%v", code, matched, err)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 98304 {
+		t.Fatalf("covered %d encodings, want 98304", count)
+	}
+}
+
+func TestX86RawHorizontalIntegerInvalidAndSegmentForms(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc4, 0xe2, 0x79, 0x02},             // Missing ModRM.
+		{0xc4, 0xe2, 0x79, 0x02, 0x04},       // Missing SIB.
+		{0xc4, 0xe2, 0x79, 0x02, 0x45},       // Missing disp8.
+		{0xc4, 0xe2, 0x78, 0x02, 0xc0},       // pp=none.
+		{0xc4, 0xe2, 0x7a, 0x02, 0xc0},       // pp=F3.
+		{0xc4, 0xe2, 0x7b, 0x02, 0xc0},       // pp=F2.
+		{0x62, 0xf2, 0x7d, 0x08, 0x02, 0xc0}, // No EVEX variant.
+		{0x67, 0xc4, 0xe2, 0x79, 0x02, 0x00},
+	} {
+		if _, _, matched, err := decodedX86VEXHorizontalIntegerInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x matched=%v err=%v", code, matched, err)
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		code := []byte{segment.prefix, 0xc4, 0x02, 0xe5, 0x06, 0x64, 0x88, 0x20}
+		got, size, matched, err := decodedX86VEXHorizontalIntegerInstruction(code, 64)
+		want := []Operand{{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: 32}}, {Kind: OpReg, Reg: "Y3"}, {Kind: OpReg, Reg: "Y12"}}
+		if err != nil || !matched || size != len(code) || got.Op != "VPHSUBD" || !reflect.DeepEqual(got.Args, want) {
+			t.Fatalf("decode %x=%+v %v", code, got, err)
+		}
+	}
+}
+
+func TestX86HorizontalIntegerGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPHADDW", "VPHADDD", "VPHADDSW", "VPHSUBW", "VPHSUBD", "VPHSUBSW"} {
+			lines := []string{op + " X0,Y1,Y2", op + " Z0,Z1,Z2", op + " X0,X1,K1,X2", op + " X0,X1,(AX)", op + ".Z X0,X1,X2", op + ".SAE X0,X1,X2", op + " X16,X0,X1"}
+			for _, line := range lines {
+				dir := t.TempDir()
+				path := filepath.Join(dir, "invalid.s")
+				if err := os.WriteFile(path, []byte("TEXT invalid(SB),4,$0-0\n"+line+"\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), path)
+				cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+				if output, err := cmd.CombinedOutput(); err == nil {
+					t.Fatalf("Go %s accepted %s; repair oracle: %s", arch, line, output)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				assertX86HorizontalIntegerRejected(t, arch, triple, line)
+			}
+		}
+	}
+}
+
+func TestTranslateX86HorizontalIntegerGo386RegisterCompatibility(t *testing.T) {
+	// Go's VEX Yxr/Yyr classes accept X/Y8-15 even for its 386 frontend.
+	// This named compatibility grammar is distinct from architectural raw
+	// 32-bit decoding, which still rejects extended register fields.
+	var source strings.Builder
+	source.WriteString("TEXT compat(SB),4,$0-0\n")
+	for _, op := range []string{"VPHADDW", "VPHADDD", "VPHADDSW", "VPHSUBW", "VPHSUBD", "VPHSUBSW"} {
+		for _, width := range []string{"X", "Y"} {
+			for _, regs := range [][3]int{{8, 0, 1}, {0, 8, 1}, {0, 1, 8}, {15, 14, 13}} {
+				fmt.Fprintf(&source, "%s %s%d,%s%d,%s%d\n", op, width, regs[0], width, regs[1], width, regs[2])
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	assembleX87ControlBytes(t, "386", source.String())
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			options := Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"compat": {Name: "compat", Ret: Void}}}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Go frontend acceptance invented high physical mode32 registers: %v", err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("direct module invented mode32 high registers", err)
+			}
+			translated, err := translateGoModuleInContext(ctx, x86SADGoPackage(t, "386", "()"), []byte(strings.Replace(source.String(), "compat(SB)", "·sad(SB)", 1)), GoModuleOptions{GOARCH: "386", TargetTriple: triple})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("typed module invented mode32 high registers", err)
+			}
+		})
+	}
+}
+
+// All six VEX instructions share Go's two _yvaddsubpd rows (X/Y).
+// The legacy siblings use yxm_q4, except PHADDD's MMX-capable ymmxmm0f38.
+func TestX86RawHorizontalIntegerGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			last := 7
+			if arch == "amd64" {
+				last = 15
+			}
+			var source strings.Builder
+			source.WriteString("TEXT horizontal(SB),4,$0-0\nPHADDD M0,M7\nPHADDD -7(BX)(CX*4),M0\n")
+			for _, op := range []string{"PHADDD", "PHADDSW", "PHADDW", "PHSUBD", "PHSUBSW", "PHSUBW"} {
+				for _, reg := range []int{0, last} {
+					for _, input := range []string{fmt.Sprintf("X%d", last-reg), "(AX)", "-7(BX)(CX*4)", "8192(SI)"} {
+						fmt.Fprintf(&source, "%s %s,X%d\n", op, input, reg)
+					}
+					for _, width := range []string{"X", "Y"} {
+						for _, input := range []string{fmt.Sprintf("%s%d", width, last-reg), "(AX)", "-7(BX)(CX*4)", "8192(SI)"} {
+							fmt.Fprintf(&source, "V%s %s,%s%d,%s%d\n", op, input, width, last-reg, width, reg)
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(want) != 147 || len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions; expected %d, including RET", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+			file := x86RawUnprovedReturnFormProbeFile(t, arch, "horizontal", code)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				// A terminal UD2 removes only the return obligation. It does
+				// not initialize the preceding MMX/vector/address inputs.
+				// Keep all original formats as private objects, independently
+				// of the three public APIs' required Context observations.
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-horizontal.ll", "raw-horizontal.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86HorizontalIntegerInitializedMMXRegionKeepsRawBoundary(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const declaration = "func horizontalMMX(a,b uint64) uint64\n"
+	const source = "TEXT ·horizontalMMX(SB),4,$0-24\nMOVQ a+0(FP),M0\nMOVQ b+8(FP),M7\nPHADDD M0,M7\nMOVQ M7,ret+16(FP)\nEMMS\nRET\n"
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i") {
+				arch = "386"
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			code := assembleX87ControlBytes(t, arch, "TEXT row(SB),4,$0-0\nPHADDD M0,M7\nRET\n")
+			if !reflect.DeepEqual(code, []byte{0x0f, 0x38, 0x02, 0xf8, 0xc3}) {
+				t.Fatal("initialized counterpart lost the original MMX row identity", code)
+			}
+			var bytes strings.Builder
+			for _, value := range code[:len(code)-1] {
+				fmt.Fprintf(&bytes, "BYTE $0x%02x\n", value)
+			}
+			raw := strings.Replace(source, "PHADDD M0,M7\n", bytes.String(), 1)
+			x86LEAActualTargetGoObject(t, arch, triple, raw)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+				if err != nil {
+					t.Fatal("complete named MMX region lost its bounded inputs/EMMS", api, err)
+				}
+				if !strings.Contains(ir, "phaddd") || !strings.Contains(ir, "emms") {
+					t.Fatal("initialized counterpart lost the physical MMX operation/tag closure", api)
+				}
+				compileLLVMToObject(t, llc, triple, "initialized-horizontal-mmx-"+api+".ll", "initialized-horizontal-mmx-"+api+".o", ir)
+				if ir, err := x86ScalarFPBitViewAPI(t, raw, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("typed values and EMMS invented an authenticated raw MMX region", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86HorizontalIntegerViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; separate five-target object tests are required")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, spec := range []struct {
+		op                       string
+		bits, subtract, saturate int
+	}{{"VPHADDW", 16, 0, 0}, {"VPHADDD", 32, 0, 0}, {"VPHADDSW", 16, 0, 1}, {"VPHSUBW", 16, 1, 0}, {"VPHSUBD", 32, 1, 0}, {"VPHSUBSW", 16, 1, 1}} {
+		for width, prefix := range []string{"X", "Y"} {
+			for _, memory := range []bool{false, true} {
+				for dst := 0; dst < 3; dst++ {
+					name := fmt.Sprintf("horizontal%d", index)
+					index++
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),DI\nMOVQ old+24(FP),SI\nVMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (SI),Z2\n", name)
+					input := prefix + "1"
+					if memory {
+						input = "(BX)"
+					}
+					fmt.Fprintf(&source, "%s %s,%s0,%s%d\nVMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\nRET\n", spec.op, input, prefix, prefix, dst, dst, dst, dst)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1}}}}
+					fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *,const void *);\n", name)
+					fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d,%d)) return %d;\n", name, 16<<width, spec.bits/8, spec.subtract, spec.saturate, index)
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var commandPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		commandPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int64_t lane(const uint8_t *p,int bytes) {
+  if(bytes==2) {int16_t v;memcpy(&v,p,2);return v;}
+  int32_t v;memcpy(&v,p,4);return v;
+}
+static int check(void (*fn)(const void *,const void *,void *,const void *),int bytes,int laneBytes,int sub,int sat) {
+  for(int seed=0;seed<128;seed++) {
+    uint8_t a[64],b[64],old[64],out[112],want[64]={0};
+    for(int i=0;i<64;i++) {a[i]=(uint8_t)(seed*17+i*31);b[i]=(uint8_t)(seed*43+i*7);old[i]=(uint8_t)(193-i);}
+    for(int i=0;i<bytes/laneBytes;i++) {
+      int per128=16/laneBytes,pos=i%per128,block=i-pos;
+      const uint8_t *input=pos<per128/2?a:b;
+      int pair=block+2*(pos%(per128/2));
+      int64_t left=lane(input+pair*laneBytes,laneBytes),right=lane(input+(pair+1)*laneBytes,laneBytes);
+      int64_t result=sub?left-right:left+right;
+      if(sat) {if(result<-32768)result=-32768;if(result>32767)result=32767;}
+      uint64_t bits=(uint64_t)result;
+      for(int j=0;j<laneBytes;j++) want[i*laneBytes+j]=(uint8_t)(bits>>(j*8));
+    }
+    fn(a,b,out,old);
+    for(int view=0;view<3;view++) {
+      int offset=view==0?0:view==1?64:96;
+      for(int i=0;i<(64>>view);i++) if(out[offset+i]!=want[i]) {
+        fprintf(stderr,"horizontal mismatch bytes=%d lane=%d sub=%d sat=%d seed=%d view=%d byte=%d\n",bytes,laneBytes,sub,sat,seed,view,i);return 1;
+      }
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "horizontal_integer", triple, ir, mainC, commandPrefix)
+}
diff --git a/amd64_raw_hypercall_test.go b/amd64_raw_hypercall_test.go
new file mode 100644
index 000000000..4545be9bd
--- /dev/null
+++ b/amd64_raw_hypercall_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// KVM defines both vendor encodings of the same zero-operand hypercall ABI:
+// https://docs.kernel.org/virt/kvm/x86/hypercalls.html
+func TestX86RawKVMHypercallFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, op := range []struct {
+		name string
+		last byte
+	}{
+		{name: "VMCALL", last: 0xc1},
+		{name: "VMMCALL", last: 0xd9},
+	} {
+		for _, target := range []struct {
+			arch, triple string
+		}{
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(op.name+"/"+target.triple, func(t *testing.T) {
+				source := fmt.Sprintf(`TEXT hypercall(SB),$0-0
+	MOVL $9, AX
+	MOVL $17, BX
+	MOVL $23, CX
+	MOVL $29, DX
+	MOVL $31, SI
+	BYTE $0x0f; BYTE $0x01; BYTE $0x%02x
+	RET
+`, op.last)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if decoded.Instrs[len(decoded.Instrs)-2].Op != Op(op.name) {
+					t.Fatalf("wrong hypercall decoding: %+v", decoded.Instrs)
+				}
+				word := I64
+				if target.arch == "386" {
+					word = I32
+				}
+				ir, err := Translate(file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"hypercall": {Name: "hypercall", Ret: word}},
+				})
+				if target.arch == "386" {
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("logical mode32 scalar result acquired a raw/native entry contract", err)
+					}
+					normalized, err := normalizeX86RawFile(file, target.arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					// Retain the actual hypercall opcode/constraints and AX
+					// return as an object, not an executable logical ABI proof.
+					ir = x86ScalarFormatObjectUnit(t, normalized,
+						map[string]FuncSig{"hypercall": {Name: "hypercall", Ret: word}}, target.arch, target.triple, 0)
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				for _, want := range []string{
+					`asm sideeffect "` + strings.ToLower(op.name) + `"`,
+					`={ax},0,{bx},{cx},{dx},{si},`, `~{memory}`,
+				} {
+					if !strings.Contains(ir, want) {
+						t.Fatalf("missing hypercall ABI %q", want)
+					}
+				}
+				compileLLVMToObject(t, llc, target.triple, "hypercall.ll", "hypercall.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86KVMHypercallRejectsExplicitOperandsAndSuffixes(t *testing.T) {
+	for _, instruction := range []string{"VMCALL AX", "VMMCALL AX", "VMCALL.Z", "VMMCALL.Z"} {
+		file, err := Parse(ArchAMD64, "TEXT invalid(SB),$0-0\n"+instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{
+			Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"invalid": {Name: "invalid", Ret: Void}},
+		})
+		if err == nil {
+			t.Fatalf("accepted invalid hypercall %q", instruction)
+		}
+	}
+}
diff --git a/amd64_raw_ifma_test.go b/amd64_raw_ifma_test.go
new file mode 100644
index 000000000..44839f777
--- /dev/null
+++ b/amd64_raw_ifma_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawDirectiveGroupIFMACompleteFamily(t *testing.T) {
+	// Bytes come from Go 1.27's avx512_ifma assembler test table and cover
+	// both opcodes, all widths, high registers, memory, and masking.
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "high x high registers", code: []byte{0x62, 0xe2, 0xa5, 0x09, 0xb5, 0xd7}, want: "VPMADD52HUQ X7, X11, K1, X18"},
+		{name: "high y high registers", code: []byte{0x62, 0x82, 0x85, 0x27, 0xb5, 0xcc}, want: "VPMADD52HUQ Y28, Y31, K7, Y17"},
+		{name: "low y memory", code: []byte{0x62, 0xf2, 0xb5, 0x29, 0xb4, 0x94, 0x2c, 0x11, 0, 0, 0}, want: "VPMADD52LUQ 17(SP)(BP*1), Y9, K1, Y2"},
+		{name: "low z high registers", code: []byte{0x62, 0x22, 0xd5, 0x47, 0xb4, 0xe0}, want: "VPMADD52LUQ Z16, Z21, K7, Z28"},
+		{name: "low z broadcast zeroing", code: []byte{0x62, 0xf2, 0xf5, 0xdb, 0xb4, 0x50, 0x7f}, want: "VPMADD52LUQ.BCST.Z 1016(AX), Z1, K3, Z2"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			decoded, err := decodeX86RawDirectiveGroup(test.code, 64, 0, test.name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %x as %#v, want %q", test.code, decoded, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86RawIFMAAllRegisterFields(t *testing.T) {
+	for _, operation := range []struct {
+		opcode byte
+		op     Op
+	}{
+		{opcode: 0xb4, op: "VPMADD52LUQ"},
+		{opcode: 0xb5, op: "VPMADD52HUQ"},
+	} {
+		for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 |
+							byte((^first>>4)&1)<<6 |
+							byte((^first>>3)&1)<<5 |
+							byte((^destination>>4)&1)<<4 | 2
+						p1 := byte(1)<<7 | byte(^second&15)<<3 | 5
+						p2 := byte(vectorBits)<<5 | byte((^second>>4)&1)<<3
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0x62, p0, p1, p2, operation.opcode, modRM}
+						instruction, length, ok, err := decodedX86IFMAInstruction(encoding, 64)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("op=%s width=%s first=%d second=%d destination=%d: ok=%v length=%d err=%v", operation.op, vectorName, first, second, destination, ok, length, err)
+						}
+						want := fmt.Sprintf("%s %s%d, %s%d, %s%d", operation.op, vectorName, first, vectorName, second, vectorName, destination)
+						if instruction.Raw != want {
+							t.Fatalf("encoding %x decoded as %q, want %q", encoding, instruction.Raw, want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawIFMARejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "386 masked extended source", mode: 32, encoding: []byte{0x62, 0xf2, 0xb5, 0x09, 0xb4, 0xc2}, wantOK: true},
+		{name: "386 extended register", mode: 32, encoding: []byte{0x62, 0x72, 0xf5, 0x08, 0xb4, 0xc2}, wantOK: true},
+		{name: "reserved vector length", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x68, 0xb4, 0xc2}, wantOK: true},
+		{name: "broadcast register", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x18, 0xb4, 0xc2}, wantOK: true},
+		{name: "zero without mask", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x88, 0xb5, 0xc2}, wantOK: true},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0x62, 0xf2, 0xf5, 0x08, 0xb4, 0xc2}, wantOK: true},
+		{name: "wrong map", mode: 64, encoding: []byte{0x62, 0xf3, 0xf5, 0x08, 0xb4, 0xc2}, wantOK: false},
+		{name: "wrong prefix", mode: 64, encoding: []byte{0x62, 0xf2, 0xf4, 0x08, 0xb4, 0xc2}, wantOK: false},
+		{name: "wrong w", mode: 64, encoding: []byte{0x62, 0xf2, 0x75, 0x08, 0xb4, 0xc2}, wantOK: true},
+		{name: "truncated", mode: 64, encoding: []byte{0x62, 0xf2, 0xf5, 0x08, 0xb4}, wantOK: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86IFMAInstruction(test.encoding, test.mode)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x: ok=%v, want %v (err=%v)", test.encoding, ok, test.wantOK, err)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("encoding %x was recognized without rejection", test.encoding)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_indexed_permute_test.go b/amd64_raw_indexed_permute_test.go
new file mode 100644
index 000000000..d8c815486
--- /dev/null
+++ b/amd64_raw_indexed_permute_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawIndexedPermuteForms = []struct {
+	opcode    int
+	widthBit  int
+	op        Op
+	laneBytes int
+}{
+	{0x75, 0, "VPERMI2B", 1}, {0x75, 1, "VPERMI2W", 2},
+	{0x76, 0, "VPERMI2D", 4}, {0x76, 1, "VPERMI2Q", 8},
+	{0x77, 0, "VPERMI2PS", 4}, {0x77, 1, "VPERMI2PD", 8},
+	{0x7d, 0, "VPERMT2B", 1}, {0x7d, 1, "VPERMT2W", 2},
+	{0x7e, 0, "VPERMT2D", 4}, {0x7e, 1, "VPERMT2Q", 8},
+	{0x7f, 0, "VPERMT2PS", 4}, {0x7f, 1, "VPERMT2PD", 8},
+}
+
+func TestDecodeX86RawIndexedPermuteSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VPERMT2W Y18, Y19, Y21.
+	code := []byte{0x62, 0xa2, 0xe5, 0x20, 0x7d, 0xea, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "validUTF8 AVX512 VPERMT2W", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPERMT2W" ||
+		decoded[0].Args[0].Reg != "Y18" || decoded[0].Args[1].Reg != "Y19" ||
+		decoded[0].Args[2].Reg != "Y21" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func encodeX86RawIndexedPermute(opcode, widthBit, vectorBits, mask int, broadcast, memory bool) []byte {
+	p1 := byte(0x75) // EVEX.vvvv = vector register 1, pp = 66.
+	if widthBit != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // first source register 3, destination register 2.
+	if memory {
+		modRM = 0x50 // disp8(AX), destination register 2.
+	}
+	code := []byte{0x62, 0xf2, p1, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawIndexedPermuteCompleteGoForms(t *testing.T) {
+	if len(x86RawIndexedPermuteForms) != 12 || len(amd64IndexedPermuteSpecs) != 14 {
+		t.Fatalf("raw/indexed-permute grammar has %d/%d rows, want 12/14", len(x86RawIndexedPermuteForms), len(amd64IndexedPermuteSpecs))
+	}
+	for _, form := range x86RawIndexedPermuteForms {
+		for vectorBits, vector := range []string{"X", "Y", "Z"} {
+			for _, variant := range []struct {
+				name      string
+				mask      int
+				broadcast bool
+				memory    bool
+			}{
+				{name: "register"},
+				{name: "masked register", mask: 3},
+				{name: "memory", memory: true},
+				{name: "masked memory", mask: 7, memory: true},
+				{name: "broadcast memory", broadcast: true, memory: true},
+			} {
+				if variant.broadcast && form.laneBytes < 4 {
+					continue
+				}
+				name := fmt.Sprintf("%s/%s/%s", form.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawIndexedPermute(form.opcode, form.widthBit, vectorBits, variant.mask, variant.broadcast, variant.memory)
+					got, length, ok, err := decodedX86IndexedPermuteInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := form.op
+					if variant.broadcast {
+						wantOp += ".BCST"
+					}
+					if got.Op != wantOp || got.Args[1].String() != vector+"1" ||
+						got.Args[len(got.Args)-1].String() != vector+"2" ||
+						len(got.Args) != 3+map[bool]int{true: 1}[variant.mask != 0] {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawIndexedPermuteRIPLiteral(t *testing.T) {
+	for _, form := range x86RawIndexedPermuteForms {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && form.laneBytes < 4 {
+				continue
+			}
+			code := encodeX86RawIndexedPermute(form.opcode, form.widthBit, 2, 1, broadcast, false)
+			code[5] = 0x15 // RIP-relative first source.
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			literalWidth := 64
+			if broadcast {
+				literalWidth = form.laneBytes
+			}
+			for index := 0; index < literalWidth; index++ {
+				code = append(code, byte(index+1))
+			}
+			name := fmt.Sprintf("%s/broadcast%t", form.op, broadcast)
+			t.Run(name, func(t *testing.T) {
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				wantOp := form.op
+				if broadcast {
+					wantOp += ".BCST"
+				}
+				if len(got) != 2 || !got[0].x86RIPLiteral ||
+					len(got[0].x86RIPLiteralData) != literalWidth || got[0].Op != wantOp {
+					t.Fatalf("decode %x = %+v", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86RawIndexedPermuteLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawIndexedPermute(SB),$0-0\n")
+			for _, opcode := range []int{0x75, 0x76, 0x77, 0x7d, 0x7e, 0x7f} {
+				for _, widthBit := range []int{0, 1} {
+					code := encodeX86RawIndexedPermute(opcode, widthBit, 0, 0, false, false)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+					if opcode == 0x75 || opcode == 0x7d {
+						continue
+					}
+					mask := 3
+					if target.goarch == "386" {
+						mask = 0
+					}
+					code = encodeX86RawIndexedPermute(opcode, widthBit, 0, mask, true, true)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawIndexedPermute": {Name: "rawIndexedPermute", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-indexed-permute.ll", "raw-indexed-permute.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_insertps_mode32_test.go b/amd64_raw_insertps_mode32_test.go
new file mode 100644
index 000000000..c6057a89c
--- /dev/null
+++ b/amd64_raw_insertps_mode32_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func x86RawINSERTPSSource(name string, code []byte) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", name)
+	for _, value := range code {
+		fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func TestX86RawINSERTPSMode32CompleteRegisterGrammar(t *testing.T) {
+	// Go's 386 frontend rejects four operands. BYTE acceptance is a distinct
+	// source role, not permission to accept the equivalent named instruction.
+	for _, row := range []string{
+		"VINSERTPS $28,X7,X7,X7",
+		"VINSERTPS $28,1(BX),X7,X7",
+	} {
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ins.Raw += " /* decoded from BYTE $0xc4 */"
+		if _, known, err := x86InsertExtractProperties(ins, "386"); !known || err == nil {
+			t.Fatalf("a textual annotation granted physical mode32 identity: %+v", ins)
+		}
+	}
+	goAssemblerOracleOutput(t, "386", x86RawINSERTPSSource("f", encodeX86RawVEXINSERTPS(7, 7, 7, 28)), "", true)
+
+	count := 0
+	for source := 0; source < 8; source++ {
+		for base := 0; base < 8; base++ {
+			for destination := 0; destination < 8; destination++ {
+				immediate := byte(source*32 + base*4 + destination)
+				code := encodeX86RawVEXINSERTPS(source, base, destination, immediate)
+				ins, length, known, err := decodedX86InsertPSInstruction(code, 32)
+				if err != nil || !known || length != len(code) || !ins.x86Encoded {
+					t.Fatalf("physical mode32 decode %x: %+v, length=%d, known=%t, err=%v", code, ins, length, known, err)
+				}
+				form, known, err := x86InsertExtractProperties(ins, "386")
+				if err != nil || !known || form.immediate != immediate || form.width != 16 || form.output != 16 || form.memory != -1 {
+					t.Fatalf("physical mode32 grammar %x: %+v, known=%t, err=%v", code, form, known, err)
+				}
+				count++
+			}
+		}
+	}
+	if count != 512 {
+		t.Fatalf("mode32 register axis has %d cases, want 512", count)
+	}
+}
+
+func TestX86RawINSERTPSVEXIgnoredWLLVMOracle(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc not found")
+	}
+	// Intel XED's VINSERTPS patterns do not constrain REXW, unlike adjacent
+	// VINSERTF128 patterns: datafiles/avx/avx-isa.txt. Both VEX.W values decode
+	// to the same instruction; Go's named encoder always chooses W=0.
+	for _, mode := range []int{32, 64} {
+		var input strings.Builder
+		for _, w := range []byte{0, 0x80} {
+			code := encodeX86RawVEXINSERTPS(7, 7, 7, 28)
+			code[2] |= w
+			for _, value := range code {
+				fmt.Fprintf(&input, "%#02x ", value)
+			}
+			input.WriteByte('\n')
+			ins, length, known, err := decodedX86InsertPSInstruction(code, mode)
+			if err != nil || !known || length != len(code) || ins.Raw != "VINSERTPS $28, X7, X7, X7" {
+				t.Fatalf("VEX.WIG mode%d decode %x: %+v, length=%d, known=%t, err=%v", mode, code, ins, length, known, err)
+			}
+		}
+		triple := "i386-unknown-linux-gnu"
+		if mode == 64 {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+avx")
+		command.Stdin = strings.NewReader(input.String())
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil || strings.Count(string(output), "vinsertps\t$28, %xmm7, %xmm7, %xmm7") != 2 {
+			t.Fatalf("LLVM 22 independent VEX.WIG mode%d: %v\n%s", mode, err, output)
+		}
+	}
+}
+
+func TestX86RawINSERTPSMode32MemoryAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Independent ModRM/SIB axes: direct, signed disp8/disp32 and every scale.
+	memory := [][]byte{
+		{0x3b}, {0x7b, 0x80}, {0x7b, 0x7f},
+		{0xbb, 0, 0, 0, 0x80}, {0xbb, 0xff, 0xff, 0xff, 0x7f},
+		{0x7c, 0x33, 1}, {0x7c, 0x73, 1}, {0x7c, 0xb3, 1}, {0x7c, 0xf3, 1},
+	}
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, modRM := range memory {
+		for _, w := range []byte{0, 0x80} {
+			code := append([]byte{0xc4, 0xe3, 0x41 | w, 0x21}, modRM...)
+			code = append(code, 0xff)
+			ins, length, known, err := decodedX86InsertPSInstruction(code, 32)
+			if err != nil || !known || length != len(code) {
+				t.Fatalf("mode32 memory decode %x: %+v, length=%d, known=%t, err=%v", code, ins, length, known, err)
+			}
+			form, known, err := x86InsertExtractProperties(ins, "386")
+			if err != nil || !known || form.memory != 1 || form.spec.chunk != 4 || form.immediate != 255 {
+				t.Fatalf("mode32 memory grammar %x: %+v, known=%t, err=%v", code, form, known, err)
+			}
+			name := fmt.Sprintf("memory%d_w%d", index, w>>7)
+			source.WriteString(x86RawINSERTPSSource(name, code))
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		triples := []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		if arch == "amd64" {
+			triples = []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+		}
+		for _, triple := range triples {
+			ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-insertps-memory.ll", "raw-insertps-memory.o", ir)
+		}
+	}
+}
diff --git a/amd64_raw_insertps_test.go b/amd64_raw_insertps_test.go
new file mode 100644
index 000000000..c09308c6b
--- /dev/null
+++ b/amd64_raw_insertps_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawLegacyINSERTPS(source, destination int, immediate byte) []byte {
+	rex := byte(0x40 | source>>3&1 | destination>>3&1<<2)
+	code := []byte{0x66}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, 0x3a, 0x21, byte(0xc0|destination&7<<3|source&7), immediate)
+}
+
+func encodeX86RawVEXINSERTPS(source, base, destination int, immediate byte) []byte {
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^source>>3)&1)<<5 | 3
+	p1 := byte(^base&15)<<3 | 1
+	return []byte{0xc4, p0, p1, 0x21, byte(0xc0 | destination&7<<3 | source&7), immediate}
+}
+
+func encodeX86RawEVEXINSERTPS(source, base, destination int, immediate byte) []byte {
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^source>>4)&1)<<6 |
+		byte((^source>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 3
+	p1 := byte(^base&15)<<3 | 5
+	p2 := byte((^base>>4)&1) << 3
+	return []byte{0x62, p0, p1, p2, 0x21, byte(0xc0 | destination&7<<3 | source&7), immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVINSERTPS(t *testing.T) {
+	// vinsertps $0x1c, %xmm10, %xmm8, %xmm1;
+	// vshufps $0x24, %xmm0, %xmm1, %xmm0
+	code := []byte{0xc4, 0xc3, 0x39, 0x21, 0xca, 0x1c, 0xc5, 0xf0, 0xc6, 0xc0, 0x24}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VINSERTPS sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VINSERTPS $28, X10, X8, X1 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawINSERTPSCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for source := 0; source < 16; source++ {
+		for destination := 0; destination < 16; destination++ {
+			immediate := byte(source*16 + destination)
+			code := encodeX86RawLegacyINSERTPS(source, destination, immediate)
+			got, length, ok, err := decodedX86InsertPSInstruction(code, 64)
+			want := fmt.Sprintf("INSERTPS $%d, X%d, X%d", immediate, source, destination)
+			if err != nil || !ok || length != len(code) || got.Raw != want {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+			}
+			count++
+		}
+	}
+	for source := 0; source < 16; source++ {
+		for base := 0; base < 16; base++ {
+			for destination := 0; destination < 16; destination++ {
+				immediate := byte(source*16 + destination)
+				code := encodeX86RawVEXINSERTPS(source, base, destination, immediate)
+				got, length, ok, err := decodedX86InsertPSInstruction(code, 64)
+				want := fmt.Sprintf("VINSERTPS $%d, X%d, X%d, X%d", immediate, source, base, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+	}
+	for source := 0; source < 32; source++ {
+		for base := 0; base < 32; base++ {
+			for destination := 0; destination < 32; destination++ {
+				immediate := byte(source*8 + destination)
+				code := encodeX86RawEVEXINSERTPS(source, base, destination, immediate)
+				got, length, ok, err := decodedX86InsertPSInstruction(code, 64)
+				want := fmt.Sprintf("VINSERTPS $%d, X%d, X%d, X%d", immediate, source, base, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+	}
+	if count != 37120 {
+		t.Fatalf("covered %d INSERTPS/VINSERTPS register encodings, want 37120", count)
+	}
+}
+
+func TestDecodedX86RawINSERTPSMemoryAndInvalidForms(t *testing.T) {
+	legacyMemory := []byte{0x66, 0x47, 0x0f, 0x3a, 0x21, 0x7c, 0x8b, 0x01, 0xff}
+	got, length, ok, err := decodedX86InsertPSInstruction(legacyMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(legacyMemory) || got.Op != "INSERTPS" || got.Args[2].String() != "X15" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", legacyMemory, got, length, ok, err)
+	}
+	vexMemory := []byte{0xc4, 0x03, 0x01, 0x21, 0x7c, 0x8b, 0x02, 0x80}
+	got, length, ok, err = decodedX86InsertPSInstruction(vexMemory, 64)
+	wantMemory.Off = 2
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VINSERTPS" || got.Args[2].String() != "X15" || got.Args[3].String() != "X15" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+	evexMemory := []byte{0x62, 0x03, 0x05, 0x00, 0x21, 0x7c, 0x8b, 0x02, 0x40}
+	got, length, ok, err = decodedX86InsertPSInstruction(evexMemory, 64)
+	wantMemory.Off = 8
+	if err != nil || !ok || length != len(evexMemory) || got.Op != "VINSERTPS" || got.Args[2].String() != "X31" || got.Args[3].String() != "X31" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexMemory, got, length, ok, err)
+	}
+
+	validVEX := encodeX86RawVEXINSERTPS(7, 7, 7, 1)
+	validEVEX := encodeX86RawEVEXINSERTPS(31, 31, 31, 1)
+	for name, invalid := range map[string][]byte{
+		"vex vector length":        {validVEX[0], validVEX[1], validVEX[2] | 0x04, validVEX[3], validVEX[4], validVEX[5]},
+		"evex W":                   {validEVEX[0], validEVEX[1], validEVEX[2] | 0x80, validEVEX[3], validEVEX[4], validEVEX[5], validEVEX[6]},
+		"evex mask":                {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 1, validEVEX[4], validEVEX[5], validEVEX[6]},
+		"evex zero":                {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x80, validEVEX[4], validEVEX[5], validEVEX[6]},
+		"evex broadcast":           {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x10, validEVEX[4], validEVEX[5], validEVEX[6]},
+		"truncated vex immediate":  validVEX[:len(validVEX)-1],
+		"truncated evex immediate": validEVEX[:len(validEVEX)-1],
+		"address override":         append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86InsertPSInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	if instruction, _, matched, decodeErr := decodedX86InsertPSInstruction(validEVEX, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 EVEX encoding %x decoded as %+v, ok=%v, err=%v", validEVEX, instruction, matched, decodeErr)
+	}
+	extended386 := encodeX86RawVEXINSERTPS(8, 0, 0, 1)
+	if instruction, _, matched, decodeErr := decodedX86InsertPSInstruction(extended386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 extended encoding %x decoded as %+v, ok=%v, err=%v", extended386, instruction, matched, decodeErr)
+	}
+}
+
+func TestTranslateX86RawINSERTPSTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name        string
+		goarch      string
+		triple      string
+		registerMax int
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", registerMax: 15},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registerMax: 15},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registerMax: 15},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu", registerMax: 7},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc", registerMax: 7},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			code := [][]byte{
+				encodeX86RawLegacyINSERTPS(target.registerMax, target.registerMax, 0xff),
+				encodeX86RawVEXINSERTPS(target.registerMax, target.registerMax, target.registerMax, 0x1c),
+			}
+			if target.goarch == "amd64" {
+				code = append(code, encodeX86RawEVEXINSERTPS(31, 30, 29, 0x80))
+			}
+			var source strings.Builder
+			source.WriteString("TEXT raw_insertps(SB),NOSPLIT,$0-0\n")
+			for _, instruction := range code {
+				for _, value := range instruction {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"raw_insertps": {Name: "raw_insertps", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-insertps-"+target.name+".ll", "raw-insertps-"+target.name+".o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_integer_dot.go b/amd64_raw_integer_dot.go
new file mode 100644
index 000000000..f76102e29
--- /dev/null
+++ b/amd64_raw_integer_dot.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+import "fmt"
+
+func decodedX86IntegerPackedDotInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.evex && p.pp == 2 {
+		return Instr{}, 0, false, nil // BF16 owns EVEX.F3, not integer VNNI.
+	}
+	var op Op
+	for name, spec := range amd64PackedDotProductSpecs {
+		if !spec.bfloat && int(spec.opcode) == p.opcode {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	if p.w {
+		return Instr{}, 0, true, fmt.Errorf("integer dot-product encoding requires W0")
+	}
+	ins, size, known, err := decodedX86BinaryVectorOperands(code, p, mode, op, 32)
+	if err != nil || !known {
+		return ins, size, known, err
+	}
+	if size > 15 {
+		return Instr{}, 0, true, fmt.Errorf("integer dot-product instruction exceeds 15 bytes")
+	}
+	ins.x86VectorBytes = 16 << p.vectorLength
+	ins.x86PackedDotEncoding = x86RawPackedDotVEX
+	if p.evex {
+		ins.x86PackedDotEncoding = x86RawPackedDotEVEX
+	}
+	return ins, size, true, nil
+}
diff --git a/amd64_raw_invalid_prefix_observation_test.go b/amd64_raw_invalid_prefix_observation_test.go
new file mode 100644
index 000000000..230963ab2
--- /dev/null
+++ b/amd64_raw_invalid_prefix_observation_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// BYTE acceptance establishes original bytes only. These instructions are not
+// executed: Intel specifies #UD for their LOCK prefix. The observed decoder
+// marks that prefix invalid; a textual conversion must not erase that fact.
+func TestX86RawInvalidLockPrefixesMustNotDisappear(t *testing.T) {
+	rows := []struct {
+		op      string
+		machine []byte
+	}{
+		{"RDTSC", []byte{0x0f, 0x31}},
+		{"RDTSCP", []byte{0x0f, 0x01, 0xf9}},
+		{"LFENCE", []byte{0x0f, 0xae, 0xe8}},
+		{"MFENCE", []byte{0x0f, 0xae, 0xf0}},
+		{"SFENCE", []byte{0x0f, 0xae, 0xf8}},
+		{"PAUSE", []byte{0xf3, 0x90}},
+	}
+	for _, mode := range []int{32, 64} {
+		arch := "386"
+		if mode == 64 {
+			arch = "amd64"
+		}
+		for _, row := range rows {
+			for _, prefix := range [][]byte{{0xf0}, {0xf0, 0x66}} {
+				t.Run(fmt.Sprintf("%d/%s/%x", mode, row.op, prefix), func(t *testing.T) {
+					code := append(append([]byte(nil), prefix...), row.machine...)
+					original := "TEXT invalid(SB),4,$0-0\n"
+					for _, value := range code {
+						original += fmt.Sprintf("BYTE $%d\n", value)
+					}
+					goAssemblerOracleOutput(t, arch, original+"RET\n", "", true)
+					physical, err := x86asm.Decode(code, mode)
+					if err != nil {
+						t.Fatal("actual pinned decoder observation", err)
+					}
+					invalid := false
+					for _, value := range physical.Prefix {
+						invalid = invalid || value&x86asm.PrefixInvalid != 0
+					}
+					if !invalid {
+						t.Fatalf("decoder did not identify specified LOCK invalidity: %#v", physical)
+					}
+					decoded, conversion := decodeX86RawDirectiveGroup(code, mode, 0, original, nil)
+					t.Logf("actual bytes=%x prefix=%#v GoSyntax=%q whole=%#v error=%v",
+						code, physical.Prefix, x86asm.GoSyntax(physical, 0, nil), decoded, conversion)
+					if conversion == nil {
+						t.Fatal("whole raw decoder erased a machine-invalid prefix")
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86PrefixOriginalBytes(t *testing.T, mode int, code []byte) {
+	t.Helper()
+	arch := "386"
+	if mode == 64 {
+		arch = "amd64"
+	}
+	source := "TEXT prefix(SB),4,$0-0\n"
+	for _, value := range code {
+		source += fmt.Sprintf("BYTE $%d\n", value)
+	}
+	actual := x86OrderingHintGoBytes(t, arch, source+"RET\n")
+	want := append(append([]byte(nil), code...), 0xc3)
+	if !bytes.Equal(actual, want) {
+		t.Fatalf("original BYTE object identity %x, want %x", actual, want)
+	}
+}
+
+// The rule is decoder metadata, not an opcode whitelist. Include width,
+// arithmetic, control, x87 and mnemonic-alias paths through GoSyntax.
+func TestX86RawInvalidPrefixEntireDecodedClass(t *testing.T) {
+	rows := []struct {
+		name string
+		code []byte
+	}{
+		{"MOV", []byte{0x8b, 0xc1}},
+		{"ADD register", []byte{0x01, 0xc8}},
+		{"CMP memory", []byte{0x39, 0x08}},
+		{"TEST memory", []byte{0x85, 0x08}},
+		{"MUL", []byte{0xf7, 0xe1}},
+		{"DIV", []byte{0xf7, 0xf1}},
+		{"LEA", []byte{0x8d, 0x00}},
+		{"NOP", []byte{0x90}},
+		{"INT3", []byte{0xcc}},
+		{"UD2 fault", []byte{0x0f, 0x0b}},
+		{"RET", []byte{0xc3}},
+		{"PACK alias", []byte{0x66, 0x0f, 0x6b, 0xca}},
+		{"FINIT alias", []byte{0xdb, 0xe3}},
+	}
+	for _, mode := range []int{32, 64} {
+		for _, row := range rows {
+			for _, prefix := range [][]byte{{0xf0}, {0xf0, 0x66}, {0x66, 0xf0}, {0xf0, 0xf0}} {
+				t.Run(fmt.Sprintf("%d/%s/%x", mode, row.name, prefix), func(t *testing.T) {
+					code := append(append([]byte(nil), prefix...), row.code...)
+					x86PrefixOriginalBytes(t, mode, code)
+					physical, err := x86asm.Decode(code, mode)
+					if err != nil || physical.Len != len(code) {
+						t.Fatalf("complete original decode %+v: %v", physical, err)
+					}
+					invalid := false
+					for _, value := range physical.Prefix {
+						invalid = invalid || value&x86asm.PrefixInvalid != 0
+					}
+					if !invalid {
+						t.Fatal("actual original bytes lack the expected invalid LOCK metadata")
+					}
+					if syntax, err := decodedX86GoSyntax(physical, code); err == nil {
+						t.Fatalf("invalid metadata became legal syntax %q", syntax)
+					}
+					if got, err := decodeX86RawDirectiveGroup(code, mode, 0, row.name, nil); err == nil {
+						t.Fatalf("invalid metadata escaped whole decoding: %+v", got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawIgnoredPrefixesRemainDistinctFromInvalid(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, row := range []struct {
+			name string
+			code []byte
+			want Op
+		}{
+			{"duplicate operand override", []byte{0x66, 0x66, 0x89, 0xc8}, "MOVW"},
+			{"duplicate address override", []byte{0x67, 0x67, 0x0f, 0x31}, "RDTSC"},
+			{"ignored operand override", []byte{0x66, 0x66, 0x0f, 0x31}, "RDTSC"},
+		} {
+			t.Run(fmt.Sprintf("%d/%s", mode, row.name), func(t *testing.T) {
+				x86PrefixOriginalBytes(t, mode, row.code)
+				physical, err := x86asm.Decode(row.code, mode)
+				if err != nil || physical.Len != len(row.code) {
+					t.Fatalf("complete original decode %+v: %v", physical, err)
+				}
+				ignored := false
+				for _, prefix := range physical.Prefix {
+					if prefix&x86asm.PrefixInvalid != 0 {
+						t.Fatal("legal control has invalid metadata")
+					}
+					ignored = ignored || prefix&x86asm.PrefixIgnored != 0
+				}
+				if !ignored {
+					t.Fatal("control does not observe PrefixIgnored")
+				}
+				got, err := decodeX86RawDirectiveGroup(row.code, mode, 0, row.name, nil)
+				if err != nil || len(got) != 1 || got[0].Op != row.want {
+					t.Fatalf("legal ignored prefix changed: %+v, %v", got, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawValidLockRequiresItsWholeAtomicEffect(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, row := range []struct {
+			name string
+			code []byte
+		}{
+			{"ADD", []byte{0x01, 0x08}},
+			{"AND", []byte{0x21, 0x08}},
+			{"XADD", []byte{0x0f, 0xc1, 0x08}},
+			{"XCHG", []byte{0x87, 0x08}},
+		} {
+			for _, prefix := range [][]byte{{0xf0}, {0xf0, 0xf0}} {
+				t.Run(fmt.Sprintf("%d/%s/%x", mode, row.name, prefix), func(t *testing.T) {
+					code := append(append([]byte(nil), prefix...), row.code...)
+					x86PrefixOriginalBytes(t, mode, code)
+					physical, err := x86asm.Decode(code, mode)
+					if err != nil || physical.Len != len(code) {
+						t.Fatalf("complete original decode %+v: %v", physical, err)
+					}
+					for _, value := range physical.Prefix {
+						if value&x86asm.PrefixInvalid != 0 {
+							t.Fatal("actual legitimate LOCK classified as machine invalid")
+						}
+					}
+					got, err := decodeX86RawDirectiveGroup(code, mode, 0, row.name, nil)
+					t.Logf("bytes=%x syntax=%q parsed=%+v error=%v", code,
+						x86asm.GoSyntax(physical, 0, nil), got, err)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("raw atomic-prefix effect is not bound; may not become a standalone LOCK no-op: %+v/%v", got, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_klogical.go b/amd64_raw_klogical.go
new file mode 100644
index 000000000..c22cef5ce
--- /dev/null
+++ b/amd64_raw_klogical.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RawKLogicalInstruction models Go 1.27's _ykaddb and _yknotb
+// mask-register tables as opcode, width prefix, and K-operand arity. It
+// includes KADD, KAND/ANDN, KOR, KXNOR/XOR, KUNPCK, KNOT, KTEST and KORTEST.
+func decodedX86RawKLogicalInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.evex || p.mapNumber != 1 {
+		return Instr{}, 0, false, nil
+	}
+	stem, arity := x86RawKLogicalOpcode(p.opcode)
+	if stem == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("K-register operation: %s", message)
+	}
+	if p.pp > 1 {
+		return fail("reserved VEX.pp")
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride || p.segment != "" || p.r != 0 || p.b != 0 || p.x != 0 {
+		return fail("invalid address or register extension prefix")
+	}
+	length := 0
+	if arity == 3 {
+		length = 1
+	}
+	if p.vectorLength != length || p.upper >= 8 || arity == 2 && p.upper != 0 {
+		return fail("invalid VEX length or vvvv K register")
+	}
+	op, ok := x86RawKLogicalOperation(stem, p.pp, p.w)
+	if !ok {
+		return fail("reserved width or opcode combination")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 != 3 {
+		return fail("K-register operation requires register operands")
+	}
+	source1 := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", modRM&7))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", modRM>>3&7))}
+	args := []Operand{source1}
+	if arity == 3 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.upper))})
+	}
+	args = append(args, destination)
+	raw := fmt.Sprintf("%s %s, %s", op, source1.String(), destination.String())
+	if arity == 3 {
+		raw = fmt.Sprintf("%s %s, %s, %s", op, source1.String(), args[1].String(), destination.String())
+	}
+	return Instr{Op: op, Args: args, Raw: raw}, p.modRM + 1, true, nil
+}
+
+func x86RawKLogicalOpcode(opcode int) (stem string, arity int) {
+	switch opcode {
+	case 0x4a:
+		return "KADD", 3
+	case 0x41:
+		return "KAND", 3
+	case 0x42:
+		return "KANDN", 3
+	case 0x45:
+		return "KOR", 3
+	case 0x46:
+		return "KXNOR", 3
+	case 0x47:
+		return "KXOR", 3
+	case 0x4b:
+		return "KUNPCK", 3
+	case 0x44:
+		return "KNOT", 2
+	case 0x98:
+		return "KORTEST", 2
+	case 0x99:
+		return "KTEST", 2
+	}
+	return "", 0
+}
+
+func x86RawKLogicalOperation(stem string, pp int, w bool) (Op, bool) {
+	if stem == "KUNPCK" {
+		switch {
+		case pp == 1 && !w:
+			return "KUNPCKBW", true
+		case pp == 0 && !w:
+			return "KUNPCKWD", true
+		case pp == 0 && w:
+			return "KUNPCKDQ", true
+		}
+		return "", false
+	}
+	suffix := "W"
+	if pp == 1 {
+		suffix = "B"
+	}
+	if w {
+		suffix = "Q"
+		if pp == 1 {
+			suffix = "D"
+		}
+	}
+	return Op(stem + suffix), true
+}
diff --git a/amd64_raw_klogical_test.go b/amd64_raw_klogical_test.go
new file mode 100644
index 000000000..bb0897145
--- /dev/null
+++ b/amd64_raw_klogical_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawKLogicalRow struct {
+	opcode byte
+	pp     byte
+	w      bool
+	name   Op
+	ary    int
+}
+
+func x86RawKLogicalRows() []x86RawKLogicalRow {
+	var rows []x86RawKLogicalRow
+	for opcode, stem := range map[byte]string{
+		0x4a: "KADD", 0x41: "KAND", 0x42: "KANDN", 0x45: "KOR",
+		0x46: "KXNOR", 0x47: "KXOR", 0x44: "KNOT",
+		0x98: "KORTEST", 0x99: "KTEST",
+	} {
+		arity := 3
+		if opcode == 0x44 || opcode == 0x98 || opcode == 0x99 {
+			arity = 2
+		}
+		for _, width := range []struct {
+			pp     byte
+			w      bool
+			suffix string
+		}{
+			{pp: 1, suffix: "B"}, {pp: 0, suffix: "W"},
+			{pp: 1, w: true, suffix: "D"}, {pp: 0, w: true, suffix: "Q"},
+		} {
+			rows = append(rows, x86RawKLogicalRow{opcode, width.pp, width.w, Op(stem + width.suffix), arity})
+		}
+	}
+	rows = append(rows,
+		x86RawKLogicalRow{0x4b, 1, false, "KUNPCKBW", 3},
+		x86RawKLogicalRow{0x4b, 0, false, "KUNPCKWD", 3},
+		x86RawKLogicalRow{0x4b, 0, true, "KUNPCKDQ", 3},
+	)
+	return rows
+}
+
+func encodeX86RawKLogical(row x86RawKLogicalRow, source1, source2, destination int) []byte {
+	length := byte(0)
+	if row.ary == 3 {
+		length = 4
+	}
+	vvvv := 0
+	if row.ary == 3 {
+		vvvv = source2
+	}
+	p1 := byte((^vvvv&15)<<3) | length | row.pp
+	modRM := byte(0xc0 | destination<<3 | source1)
+	if row.w {
+		return []byte{0xc4, 0xe1, p1 | 0x80, row.opcode, modRM}
+	}
+	return []byte{0xc5, p1 | 0x80, row.opcode, modRM}
+}
+
+func TestDecodedX86RawKLogicalCompleteGo127Family(t *testing.T) {
+	rows := x86RawKLogicalRows()
+	if len(rows) != 39 {
+		t.Fatalf("modeled %d Go 1.27 K logical/arithmetic/unpack forms, want 39", len(rows))
+	}
+	for _, row := range rows {
+		if _, ok := amd64MaskLogicalSpecs[row.name]; !ok {
+			if _, ok := amd64MaskArithmeticSpecs[row.name]; !ok {
+				if _, ok := amd64MaskUnpackBits[row.name]; !ok {
+					t.Fatalf("%s has no lowering grammar", row.name)
+				}
+			}
+		}
+		for source1 := 0; source1 < 8; source1++ {
+			for source2 := 0; source2 < 8; source2++ {
+				if row.ary == 2 && source2 != 0 {
+					continue
+				}
+				for destination := 0; destination < 8; destination++ {
+					code := encodeX86RawKLogical(row, source1, source2, destination)
+					got, length, ok, err := decodedX86RawKLogicalInstruction(code, 64)
+					if err != nil || !ok || length != len(code) || got.Op != row.name || len(got.Args) != row.ary {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %s", code, got, length, ok, err, row.name)
+					}
+					want := fmt.Sprintf("%s K%d, K%d", row.name, source1, destination)
+					if row.ary == 3 {
+						want = fmt.Sprintf("%s K%d, K%d, K%d", row.name, source1, source2, destination)
+					}
+					if got.Raw != want {
+						t.Fatalf("decode %x = %q, want %q", code, got.Raw, want)
+					}
+					if _, _, ok, err := decodedX86RawKLogicalInstruction(code, 32); !ok || err != nil {
+						t.Fatalf("386 decode %x: ok=%v err=%v", code, ok, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateRawKLogicalArgReduceAVX512Regression(t *testing.T) {
+	const source = "TEXT rawKORW(SB),$0-0\n\tLONG $0xc945fcc5\n\tRET\n"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+			if !strings.Contains(ir, "or i64") {
+				t.Fatalf("KORW did not lower to mask OR:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-korw.ll", "raw-korw.o", ir)
+		})
+	}
+}
+
+func TestTranslateRawKLogicalCompleteGo127FamilyObjects(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawKLogicalFamily(SB),$0-0\n")
+	for _, row := range x86RawKLogicalRows() {
+		for _, value := range encodeX86RawKLogical(row, 1, 2, 3) {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	source.WriteString("\tRET\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			// Keep every original byte and its Go/public-Context/emitter
+			// checks; initialized raw logical programs have separate owners.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-klogical-family.ll", "raw-klogical-family.o", ir)
+		})
+	}
+}
+
+func TestDecodedX86RawKLogicalRejectsReservedForms(t *testing.T) {
+	row := x86RawKLogicalRow{0x45, 0, false, "KORW", 3}
+	base := encodeX86RawKLogical(row, 1, 2, 3)
+	for name, code := range map[string][]byte{
+		"length":           {base[0], base[1] &^ 4, base[2], base[3]},
+		"prefix":           {base[0], base[1] | 2, base[2], base[3]},
+		"high vvvv":        {base[0], base[1] &^ 0x40, base[2], base[3]},
+		"memory source":    {base[0], base[1], base[2], base[3] &^ 0xc0},
+		"address override": append([]byte{0x67}, base...),
+		"missing ModRM":    base[:3],
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86RawKLogicalInstruction(code, 64); !ok || err == nil {
+				t.Fatalf("accepted reserved K encoding %x: ok=%v err=%v", code, ok, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_kshift.go b/amd64_raw_kshift.go
new file mode 100644
index 000000000..ffa78ae57
--- /dev/null
+++ b/amd64_raw_kshift.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27 _ykshiftlb uses opcode 30/31 for right and 32/33 for left;
+// VEX.W distinguishes B/W or D/Q at each opcode.
+var x86RawMaskShiftOps = [4][2]Op{
+	{"KSHIFTRB", "KSHIFTRW"},
+	{"KSHIFTRD", "KSHIFTRQ"},
+	{"KSHIFTLB", "KSHIFTLW"},
+	{"KSHIFTLD", "KSHIFTLQ"},
+}
+
+func decodedX86RawMaskShiftInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || p.evex || p.mapNumber != 3 || p.pp != 1 || p.opcode < 0x30 || p.opcode > 0x33 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("mask shift: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.vectorLength != 0 || p.upper != 0 || p.r != 0 || p.b != 0 || p.x != 0 {
+		return fail("invalid reserved VEX bit")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	if modRM>>6 != 3 {
+		return fail("KSHIFT requires a K-register source")
+	}
+	if len(code) <= p.modRM+1 {
+		return fail("missing imm8 shift count")
+	}
+	w := 0
+	if p.w {
+		w = 1
+	}
+	op := x86RawMaskShiftOps[p.opcode-0x30][w]
+	count := code[p.modRM+1]
+	source := modRM & 7
+	destination := modRM >> 3 & 7
+	args := []Operand{
+		{Kind: OpImm, Imm: int64(count)},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", source))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", destination))},
+	}
+	return Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s $%d, K%d, K%d", op, count, source, destination),
+	}, p.modRM + 2, true, nil
+}
diff --git a/amd64_raw_kshift_test.go b/amd64_raw_kshift_test.go
new file mode 100644
index 000000000..4c843ea68
--- /dev/null
+++ b/amd64_raw_kshift_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawMaskShift(opcode byte, w bool, source, destination int, count byte) []byte {
+	p1 := byte(0x79)
+	if w {
+		p1 |= 0x80
+	}
+	return []byte{0xc4, 0xe3, p1, opcode, byte(0xc0 | destination<<3 | source), count}
+}
+
+func TestTranslateRawMaskShiftGorseRegression(t *testing.T) {
+	const source = `TEXT rawMaskShift(SB), $0-0
+	LONG $0x3179e3c4
+	WORD $0x10d1
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawMaskShift": {Name: "rawMaskShift", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "lshr i64") {
+		t.Fatalf("raw KSHIFTRD omitted mask shift:\n%s", ir)
+	}
+}
+
+func TestDecodedX86RawMaskShiftCompleteGoRows(t *testing.T) {
+	if len(x86RawMaskShiftOps) != 4 {
+		t.Fatal("Go 1.27 KSHIFT opcode family should have four direction/width rows")
+	}
+	seen := make(map[Op]bool)
+	for row, widths := range x86RawMaskShiftOps {
+		for width, op := range widths {
+			spec, ok := amd64MaskArithmeticSpecs[op]
+			if !ok || seen[op] || spec.shift == "" {
+				t.Fatalf("KSHIFT row %d/%d = %s, spec %+v", row, width, op, spec)
+			}
+			seen[op] = true
+			for source := 0; source < 8; source++ {
+				for destination := 0; destination < 8; destination++ {
+					for _, count := range []byte{0, 7, 8, 16, 32, 64, 255} {
+						code := encodeX86RawMaskShift(byte(0x30+row), width != 0, source, destination, count)
+						got, length, recognized, err := decodedX86RawMaskShiftInstruction(code, 64)
+						if err != nil || !recognized || length != len(code) || got.Op != op {
+							t.Fatalf("decode %x = %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+						}
+						if len(got.Args) != 3 || got.Args[0].Imm != int64(count) ||
+							got.Args[1].String() != fmt.Sprintf("K%d", source) ||
+							got.Args[2].String() != fmt.Sprintf("K%d", destination) {
+							t.Fatalf("decode %x = %+v, want $%d, K%d, K%d", code, got, count, source, destination)
+						}
+						if _, _, recognized, err := decodedX86RawMaskShiftInstruction(code, 32); !recognized || err != nil {
+							t.Fatalf("386 decode %x: recognized=%v err=%v", code, recognized, err)
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(seen) != 8 {
+		t.Fatalf("covered %d KSHIFT opcodes, want eight", len(seen))
+	}
+}
+
+func TestDecodedX86RawMaskShiftRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawMaskShift(0x31, false, 1, 2, 16)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"VEX length", []byte{base[0], base[1], base[2] | 4, base[3], base[4], base[5]}},
+		{"vvvv", []byte{base[0], base[1], base[2] &^ 8, base[3], base[4], base[5]}},
+		{"extended register", []byte{base[0], base[1] &^ 0x20, base[2], base[3], base[4], base[5]}},
+		{"memory source", []byte{base[0], base[1], base[2], base[3], base[4] &^ 0xc0, base[5]}},
+		{"missing immediate", base[:5]},
+		{"missing ModRM", base[:4]},
+		{"address override", append([]byte{0x67}, base...)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawMaskShiftInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted invalid encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestTranslateRawMaskShiftLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawMaskShiftFamily(SB), $0-0\n")
+			for row, widths := range x86RawMaskShiftOps {
+				for width := range widths {
+					for _, count := range []byte{0, 16, 255} {
+						code := encodeX86RawMaskShift(byte(0x30+row), width != 0, 1, 2, count)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawMaskShiftFamily": {Name: "rawMaskShiftFamily", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-mask-shift.ll", "raw-mask-shift.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_lea_address_test.go b/amd64_raw_lea_address_test.go
new file mode 100644
index 000000000..1938f3006
--- /dev/null
+++ b/amd64_raw_lea_address_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawDisplacementLEAAddressSizeIdentity(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, addressBits := range []int{mode, mode / 2} {
+			for _, width := range []int{16, 32, 64} {
+				if width > mode {
+					continue
+				}
+				t.Run(fmt.Sprintf("mode%d/address%d/width%d", mode, addressBits, width), func(t *testing.T) {
+					encoding := x86RawLEADisplacementEncoding(mode, width, addressBits, 0, 0, -64)
+					instruction := x86RawDisplacementDecodedLEA(t, mode, encoding)
+					want := 0
+					if addressBits != mode {
+						want = addressBits
+					}
+					if instruction.x86AddressBits != want {
+						t.Fatalf("raw LEA lost physical address size: got %d, want %d", instruction.x86AddressBits, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawDisplacementLEANarrowAddressFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		mode := 64
+		if target.arch == "386" {
+			mode = 32
+		}
+		for _, width := range []int{16, 32, 64} {
+			if width > mode {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/width%d", target.triple, width), func(t *testing.T) {
+				encoding := x86RawLEADisplacementEncoding(mode, width, mode/2, 0, 0, -64)
+				body := "@MOV x+0(FP),AX\n@MOV AX,BX\n@MOV $3,SI\n@MOV $0,CX\n" +
+					x86RawDisplacementDirectives(encoding) + "@MOV CX,ret+@WORD(FP)\nRET"
+				source, sig, _ := x86SourceStackNumericalFixture(target.arch, body)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, x86SourceStackOptions(target.arch, target.triple, sig))
+				if err != nil {
+					t.Fatal(err)
+				}
+				want := "zext i32"
+				if mode == 32 {
+					want = "zext i16"
+				}
+				if !strings.Contains(ir, want) {
+					t.Fatalf("narrow effective offset was not zero-extended before destination: %s", want)
+				}
+				compileLLVMToObject(t, llc, target.triple, "raw-lea-address.ll", "raw-lea-address.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86RawDisplacementLEARejectsUnboundAddressMarkers(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, bits := range []int{1, 8, 16, 32, 64, 128} {
+			if target.arch == "386" && bits == 16 || target.arch == "amd64" && bits == 32 {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%d", target.triple, bits), func(t *testing.T) {
+				instruction := Instr{Op: "LEAL", x86AddressBits: bits, Args: []Operand{
+					{Kind: OpMem, Mem: MemRef{Base: AX}}, {Kind: OpReg, Reg: CX},
+				}}
+				if _, err := x86LEAOperandWidth(instruction, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("forged physical address size gained a grammar: %v", err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = target.arch
+				before := output.String()
+				if ok, terminated, err := ctx.lowerArith("LEAL", instruction); !ok || terminated || !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+					t.Fatalf("invalid raw address marker emitted IR: (%v, %v, %v)", ok, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawDisplacementLEARelativeAndTruncatedRemainClosed(t *testing.T) {
+	for _, encoding := range [][]byte{
+		{0x48, 0x8d, 0x0d, 0xc0, 0xff, 0xff, 0xff},
+		{0x67, 0x48, 0x8d, 0x0d, 0xc0, 0xff, 0xff, 0xff},
+		{0x48, 0x8d}, {0x48, 0x8d, 0x0c},
+		{0x48, 0x8d, 0x0c, 0x25, 0xc0, 0xff, 0xff},
+	} {
+		t.Run(fmt.Sprintf("%x", encoding), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT raw(SB),4,$0-0\n"+x86RawDisplacementDirectives(encoding)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := decodeX86RawDirectives(file.Funcs[0], "amd64"); err == nil {
+				t.Fatal("unbound relative target or truncated LEA became a numerical address")
+			}
+		})
+	}
+}
+
+func TestX86RawDisplacementLEAIgnoresSegmentBase(t *testing.T) {
+	for _, prefix := range []byte{0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65} {
+		t.Run(fmt.Sprintf("prefix%x", prefix), func(t *testing.T) {
+			encoding := append([]byte{prefix}, x86RawLEADisplacementEncoding(64, 64, 64, 0, 0, -64)...)
+			instruction := x86RawDisplacementDecodedLEA(t, 64, encoding)
+			memory := instruction.Args[0].Mem
+			if memory.Segment != "" || memory.Base != AX || memory.Off != -64 {
+				t.Fatalf("LEA used a segment base instead of its effective offset: %+v", memory)
+			}
+		})
+	}
+}
+
+func TestX86RawDisplacementEIPCannotBorrowRIPRelocation(t *testing.T) {
+	for _, opcode := range []byte{0x8d, 0x8b, 0x03} {
+		t.Run(fmt.Sprintf("opcode%x", opcode), func(t *testing.T) {
+			encoding := []byte{0x67, 0x48, opcode, 0x0d, 0xc0, 0xff, 0xff, 0xff}
+			inst, err := x86asm.Decode(encoding, 64)
+			if err != nil || inst.Len != len(encoding) || inst.AddrSize != 32 || inst.PCRel != 0 {
+				t.Fatalf("EIP decoder witness changed: %+v, %v", inst, err)
+			}
+			if syntax, err := decodedX86GoSyntax(inst, encoding); !errors.Is(err, ErrProbeNeedsContext) || syntax != "" {
+				t.Fatalf("unbound EIP-relative address acquired a source relocation: %q, %v", syntax, err)
+			}
+		})
+	}
+}
+
+func TestX86RawDisplacementNonLEASegmentOverridesStayPhysical(t *testing.T) {
+	for _, prefix := range []byte{0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65} {
+		t.Run(fmt.Sprintf("prefix%x", prefix), func(t *testing.T) {
+			encoding := []byte{prefix, 0x48, 0x8b, 0x80, 0xc0, 0xff, 0xff, 0xff}
+			inst, err := x86asm.Decode(encoding, 64)
+			if err != nil || inst.Len != len(encoding) || inst.Op != x86asm.MOV {
+				t.Fatalf("physical segmented MOV witness: %+v, %v", inst, err)
+			}
+			if got := normalizeDecodedX86LEASegments(inst); !reflect.DeepEqual(got, inst) {
+				t.Fatal("LEA normalization stripped an actual load's segment")
+			}
+			original, ok := inst.Args[1].(x86asm.Mem)
+			// In 64-bit mode x/arch already ignores ES/CS/SS/DS. FS and
+			// GS still carry a physical segment base and must not be erased.
+			if !ok || (prefix == 0x64 || prefix == 0x65) && original.Segment == 0 {
+				t.Fatalf("physical MOV lost its segment: %+v", inst)
+			}
+			normalized := normalizeDecodedX86MemoryDisplacements(inst)
+			memory := normalized.Args[1].(x86asm.Mem)
+			if memory.Segment != original.Segment || memory.Base != original.Base || memory.Disp != -64 {
+				t.Fatalf("signed displacement changed actual memory identity: %+v", memory)
+			}
+		})
+	}
+}
+
+func TestX86RawDisplacementNarrowLEADoesNotGrantCallerPointerOrStack(t *testing.T) {
+	for _, modRM := range []byte{0x87, 0x85} { // DI caller pointer, BP private stack.
+		t.Run(fmt.Sprintf("base%x", modRM), func(t *testing.T) {
+			encoding := []byte{0x67, 0x48, 0x8d, modRM, 0xc0, 0xff, 0xff, 0xff}
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)",
+				x86RawDisplacementDirectives(encoding)+"MOVL AX,(DX)", 1)
+			requireLEANativeGoObject(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("narrow physical address borrowed native caller/stack identity: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_lea_runtime_test.go b/amd64_raw_lea_runtime_test.go
new file mode 100644
index 000000000..c94989d94
--- /dev/null
+++ b/amd64_raw_lea_runtime_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86RawLEAAddressRuntimeForm struct {
+	name                      string
+	addressBits, width, shape int
+	scale                     int
+	alias                     bool
+}
+
+func x86RawLEAAddressRuntimeForms(arch string) []x86RawLEAAddressRuntimeForm {
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	var forms []x86RawLEAAddressRuntimeForm
+	for _, addressBits := range []int{mode, mode / 2} {
+		for _, width := range []int{16, 32, 64} {
+			if width > mode {
+				continue
+			}
+			for _, shape := range []int{0, 1, 2, 3} {
+				if addressBits == 16 && shape != 0 {
+					continue // The physical fixture here is BX+SI, not a SIB.
+				}
+				for scale := 0; scale < 4; scale++ {
+					if (shape == 0 || shape == 3) && scale != 0 {
+						continue
+					}
+					for _, alias := range []bool{false, true} {
+						name := fmt.Sprintf("leaA%dW%dS%dC%d", addressBits, width, shape, scale)
+						if alias {
+							name += "Alias"
+						}
+						forms = append(forms, x86RawLEAAddressRuntimeForm{
+							name: name, addressBits: addressBits, width: width,
+							shape: shape, scale: scale, alias: alias,
+						})
+					}
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func x86RawLEAAddressRuntimeSources(arch string) (string, string, string, string, map[string]FuncSig) {
+	mode, word, move, typ, ctype, cmax := 64, 8, "MOVQ", "uint64", "uint64_t", "UINT64_MAX"
+	seed := uint64(0x1122334455667788)
+	if arch == "386" {
+		mode, word, move, typ, ctype, cmax = 32, 4, "MOVL", "uint32", "uint32_t", "UINT32_MAX"
+		seed = 0x55667788
+	}
+	var declarations, assembly, goTest, c strings.Builder
+	declarations.WriteString("package rawlea\n")
+	fmt.Fprintf(&goTest, "package rawlea\nimport \"testing\"\nfunc TestPhysicalAddressMathematics(t *testing.T) {\n"+
+		" values := []%s{0,1,63,64,65,65535,65536,1<<31-1,1<<31,1<<32-1,^%s(0)}\n", typ, typ)
+	if mode == 64 {
+		goTest.WriteString(" values = append(values,1<<32,1<<63,0x1122334455667788)\n")
+	}
+	c.WriteString("#include <stdint.h>\n#if defined(__APPLE__)\n#define LABEL(name) \"_\" name\n#else\n#define LABEL(name) name\n#endif\n")
+	sigs := make(map[string]FuncSig)
+	for _, form := range x86RawLEAAddressRuntimeForms(arch) {
+		fmt.Fprintf(&declarations, "func %s(x %s) %s\n", form.name, typ, typ)
+		encoding := x86RawLEADisplacementEncoding(mode, form.width, form.addressBits, form.shape, form.scale, -64)
+		destination, initial := "CX", fmt.Sprintf("0x%x", seed)
+		if form.alias {
+			destination, initial = "AX", "x"
+			register := byte(0)
+			if form.addressBits == 16 {
+				destination, register = "BX", 3
+			}
+			opcode := bytes.IndexByte(encoding, 0x8d)
+			encoding[opcode+1] = encoding[opcode+1]&^0x38 | register<<3
+		}
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s $3,BX\n%s $0x%x,CX\n",
+			form.name, 2*word, move, move, move, seed)
+		if form.addressBits == 16 {
+			fmt.Fprintf(&assembly, "%s AX,BX\n%s $3,SI\n", move, move)
+		}
+		assembly.WriteString(x86RawDisplacementDirectives(encoding))
+		fmt.Fprintf(&assembly, "%s %s,ret+%d(FP)\nRET\n", move, destination, word)
+		sig := crossUnarySig(arch, "rawlea."+form.name)
+		sigs[sig.Name] = sig
+
+		// These two independent scalar oracles model effective-address width
+		// first and destination width second, never decoded IR or GoSyntax.
+		effective := "x - 64"
+		if form.addressBits == 16 {
+			effective = "x + 3 - 64"
+		} else if form.shape == 1 {
+			effective = fmt.Sprintf("x + 3*%d - 64", 1<<form.scale)
+		} else if form.shape == 2 {
+			effective = fmt.Sprintf("x*%d - 64", 1<<form.scale)
+		} else if form.shape == 3 {
+			effective = "^" + typ + "(63)"
+		}
+		fmt.Fprintf(&goTest, " for _, x := range values {\n  want := %s(%s)\n", typ, effective)
+		if form.addressBits != mode {
+			fmt.Fprintf(&goTest, "  want = %s(uint%d(want))\n", typ, form.addressBits)
+		}
+		if form.width == 16 {
+			fmt.Fprintf(&goTest, "  want = %s(%s)&^%s(65535) | %s(uint16(want))\n", typ, initial, typ, typ)
+		} else if form.width == 32 {
+			fmt.Fprintf(&goTest, "  want = %s(uint32(want))\n", typ)
+		}
+		fmt.Fprintf(&goTest, "  if got := %s(x); got != want { t.Fatalf(\"%s x=%%#x got=%%#x want=%%#x\",x,got,want) }\n }\n", form.name, form.name)
+		fmt.Fprintf(&c, "extern %s %s(%s) __asm__(LABEL(\"rawlea.%s\"));\n", ctype, form.name, ctype, form.name)
+	}
+	goTest.WriteString("}\n")
+	fmt.Fprintf(&c, "int main(void) {\n const %s values[] = {0,1,63,64,65,65535,65536,UINT32_MAX/2,UINT32_MAX/2+1,UINT32_MAX,%s",
+		ctype, cmax)
+	if mode == 64 {
+		c.WriteString(",UINT64_C(1)<<32,UINT64_C(1)<<63,UINT64_C(0x1122334455667788)")
+	}
+	c.WriteString("};\n")
+	for _, form := range x86RawLEAAddressRuntimeForms(arch) {
+		effective := "x - 64"
+		if form.addressBits == 16 {
+			effective = "x + 3 - 64"
+		} else if form.shape == 1 {
+			effective = fmt.Sprintf("x + 3*%d - 64", 1<<form.scale)
+		} else if form.shape == 2 {
+			effective = fmt.Sprintf("x*%d - 64", 1<<form.scale)
+		} else if form.shape == 3 {
+			effective = fmt.Sprintf("(%s)0 - 64", ctype)
+		}
+		fmt.Fprintf(&c, " for (unsigned i=0; i<sizeof(values)/sizeof(values[0]); i++) {\n  %s x=values[i], want=%s;\n", ctype, effective)
+		if form.addressBits != mode {
+			fmt.Fprintf(&c, "  want = (uint%d_t)want;\n", form.addressBits)
+		}
+		if form.width == 16 {
+			initial := fmt.Sprintf("(%s)0x%x", ctype, seed)
+			if form.alias {
+				initial = "x"
+			}
+			fmt.Fprintf(&c, "  want = (%s & ~(%s)65535) | (uint16_t)want;\n", initial, ctype)
+		} else if form.width == 32 {
+			c.WriteString("  want = (uint32_t)want;\n")
+		}
+		fmt.Fprintf(&c, "  if (%s(x)!=want) return 1;\n }\n", form.name)
+	}
+	c.WriteString(" return 0;\n}\n")
+	return declarations.String(), assembly.String(), goTest.String(), c.String(), sigs
+}
+
+func TestX86RawDisplacementLEAAllAddressWidthsAndAliasesFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			_, source, _, _, sigs := x86RawLEAAddressRuntimeSources(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: sigs, ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "rawlea.", 1) }})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-lea-all-ea.ll", "raw-lea-all-ea.o", ir)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawLEAAddressWidthAndAliases(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("raw LEA execution requires its mandatory Linux/amd64 counterpart")
+	}
+	testX86RawLEAAddressRuntime(t, "amd64")
+}
+
+func testX86RawLEAAddressRuntime(t *testing.T, arch string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	goSource, source, goTest, mainC, sigs := x86RawLEAAddressRuntimeSources(arch)
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":   "module rawlea\n\ngo 1.20\n",
+		"value.go": goSource, "value_" + arch + ".s": source, "value_test.go": goTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	args := []string{"test", "-p=2", "-vet=off", "-count=1"}
+	if arch == "386" {
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+			t.Fatal("386 original/raw LEA execution requires the Linux cross driver")
+		}
+		args = append(args, "-exec", "qemu-i386 -L /usr/i686-linux-gnu")
+	}
+	command := exec.CommandContext(ctx, "go", append(args, ".")...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go raw LEA address/alias mathematics: %v\n%s", err, output)
+	}
+	triple := testTargetTriple(runtime.GOOS, arch)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "rawlea.", 1) }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if arch == "386" {
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc", "-no-pie"},
+			"raw_lea_addresses", triple, ir, mainC, []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+		return
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	var prefix []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_lea_addresses", triple, ir, mainC, prefix)
+}
diff --git a/amd64_raw_legacy_packed_convert_test.go b/amd64_raw_legacy_packed_convert_test.go
new file mode 100644
index 000000000..ab8f9d288
--- /dev/null
+++ b/amd64_raw_legacy_packed_convert_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86LegacyPackedConversionForms = []struct {
+	name string
+	code []byte
+	op   Op
+}{
+	{"dword-to-single-X", []byte{0x0f, 0x5b, 0xc1}, "CVTPL2PS"},
+	{"dword-to-single-M", []byte{0x0f, 0x2a, 0xc1}, "CVTPL2PS"},
+	{"single-to-dword-X", []byte{0x66, 0x0f, 0x5b, 0xc1}, "CVTPS2PL"},
+	{"single-to-dword-M", []byte{0x0f, 0x2d, 0xc1}, "CVTPS2PL"},
+	{"truncate-single-X", []byte{0xf3, 0x0f, 0x5b, 0xc1}, "CVTTPS2PL"},
+	{"truncate-single-M", []byte{0x0f, 0x2c, 0xc1}, "CVTTPS2PL"},
+	{"dword-to-double-X", []byte{0xf3, 0x0f, 0xe6, 0xc1}, "CVTPL2PD"},
+	{"dword-to-double-M", []byte{0x66, 0x0f, 0x2a, 0xc1}, "CVTPL2PD"},
+	{"double-to-dword-X", []byte{0xf2, 0x0f, 0xe6, 0xc1}, "CVTPD2PL"},
+	{"double-to-dword-M", []byte{0x66, 0x0f, 0x2d, 0xc1}, "CVTPD2PL"},
+	{"truncate-double-X", []byte{0x66, 0x0f, 0xe6, 0xc1}, "CVTTPD2PL"},
+	{"truncate-double-M", []byte{0x66, 0x0f, 0x2c, 0xc1}, "CVTTPD2PL"},
+}
+
+func TestX86RawLegacyPackedConversionGo127Names(t *testing.T) {
+	for _, form := range x86LegacyPackedConversionForms {
+		t.Run(form.name, func(t *testing.T) {
+			decoded, err := decodeX86RawDirectives(rawX86Function(form.code), "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != form.op {
+				t.Fatalf("raw %#x decoded as %+v; want %s", form.code, decoded.Instrs, form.op)
+			}
+		})
+	}
+}
+
+func TestX86RawLegacyPackedConversionCompilesEveryForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			for index, form := range x86LegacyPackedConversionForms {
+				name := fmt.Sprintf("rawlegacyconversion%d", index)
+				var one strings.Builder
+				fmt.Fprintf(&one, "TEXT %s(SB),4,$0-0\n", name)
+				for _, value := range form.code {
+					fmt.Fprintf(&one, "\tBYTE $%d\n", value)
+				}
+				one.WriteString("\tRET\n")
+				if strings.HasSuffix(form.name, "-M") {
+					// Decode and actual Go objects remain covered. A raw MMX
+					// transport does not certify the physical x87/MMX state.
+					goAssemblerOracleOutput(t, target.goarch, one.String(), "", true)
+					file, err := Parse(ArchAMD64, one.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, err = Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{name: {Name: name, Ret: Void}}})
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unknown raw MMX state got a native numerical-only contract", err)
+					}
+					continue
+				}
+				source.WriteString(one.String())
+			}
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-legacy-conversion.ll", "raw-legacy-conversion.o", ir)
+		})
+	}
+}
+
+func TestX86RawLegacyPackedConversionMMXStateContext(t *testing.T) {
+	for _, name := range []string{"CVTPS2PL", "CVTTPS2PL", "CVTPD2PL", "CVTTPD2PL"} {
+		for _, target := range x86RawReturnTargets {
+			source := "TEXT probe(SB),4,$0-0\n" + name + " X1,M0\nEMMS\nRET\n"
+			code := x86PackedShiftActualGoBytes(t, target.arch, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"probe": {Ret: Void}}}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("EMMS is not a complete entry/caller physical MMX contract", name, err)
+			}
+			var raw strings.Builder
+			raw.WriteString("TEXT probe(SB),4,$0-0\n")
+			for _, value := range code {
+				fmt.Fprintf(&raw, "BYTE $%d\n", value)
+			}
+			rawFile, err := Parse(ArchAMD64, raw.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(rawFile, options); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "MMX/x87 caller contract") {
+				t.Fatal(name, err)
+			}
+		}
+	}
+}
diff --git a/amd64_raw_legacy_packed_move_literal_test.go b/amd64_raw_legacy_packed_move_literal_test.go
new file mode 100644
index 000000000..c7ada3d54
--- /dev/null
+++ b/amd64_raw_legacy_packed_move_literal_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86RawLegacyPackedMoveForms = []struct {
+	name   Op
+	prefix byte
+	opcode byte
+}{
+	{"MOVUPS", 0, 0x10},
+	{"MOVAPS", 0, 0x28},
+	{"MOVUPD", 0x66, 0x10},
+	{"MOVAPD", 0x66, 0x28},
+	{"MOVO", 0x66, 0x6f},
+	{"MOVOU", 0xf3, 0x6f},
+}
+
+func x86RawLegacyPackedMoveConstant(prefix, opcode byte) []byte {
+	return x86RawLegacyPackedMoveConstantRegister(prefix, opcode, 0)
+}
+
+func x86RawLegacyPackedMoveConstantRegister(prefix, opcode byte, register int) []byte {
+	return x86RawLegacySIMDMoveConstant(prefix, opcode, register, 16)
+}
+
+func x86RawLegacySIMDMoveConstant(prefix, opcode byte, register, width int) []byte {
+	var code []byte
+	if prefix != 0 {
+		code = append(code, prefix)
+	}
+	if register >= 8 {
+		code = append(code, 0x44)
+	}
+	code = append(code, 0x0f, opcode, 0x05, 1, 0, 0, 0, 0xc3)
+	for i := 0; i < width; i++ {
+		code = append(code, byte(i*31+7))
+	}
+	return code
+}
+
+func TestDecodeX86RawLegacyScalarMoveConstantCompleteFamily(t *testing.T) {
+	for _, form := range []struct {
+		op     Op
+		prefix byte
+		width  int
+	}{
+		{"MOVSS", 0xf3, 4},
+		{"MOVSD", 0xf2, 8},
+	} {
+		for _, register := range []int{0, 8} {
+			t.Run(fmt.Sprintf("%s/X%d", form.op, register), func(t *testing.T) {
+				code := x86RawLegacySIMDMoveConstant(form.prefix, 0x10, register, form.width)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, string(form.op), map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || decoded[0].Op != form.op ||
+					decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+					decoded[0].Args[1].String() != fmt.Sprintf("X%d", register) ||
+					decoded[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, form.op)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86RawLegacyScalarMoveConstantObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, form := range []struct {
+		prefix byte
+		width  int
+	}{
+		{0xf3, 4}, {0xf2, 8},
+	} {
+		code := x86RawLegacySIMDMoveConstant(form.prefix, 0x10, 8, form.width)
+		name := fmt.Sprintf("legacyScalarMoveConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != 2 || len(normalized.Data[0].Payload) != 4 || len(normalized.Data[1].Payload) != 8 {
+		t.Fatalf("materialized wrong scalar constants: %#v", normalized.Data)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "legacy-scalar-move-literal.ll", "legacy-scalar-move-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawLegacyPackedMoveConstantCompleteFamily(t *testing.T) {
+	for _, form := range x86RawLegacyPackedMoveForms {
+		for _, register := range []int{0, 8} {
+			t.Run(fmt.Sprintf("%s/X%d", form.name, register), func(t *testing.T) {
+				code := x86RawLegacyPackedMoveConstantRegister(form.prefix, form.opcode, register)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, string(form.name), map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || decoded[0].Op != form.name ||
+					decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+					decoded[0].Args[1].String() != fmt.Sprintf("X%d", register) ||
+					decoded[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, form.name)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawLegacyPackedMoveConstantRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawLegacyPackedMoveConstant(0, 0x10)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[3] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[3] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawLegacyPackedMoveConstantObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, form := range x86RawLegacyPackedMoveForms {
+		code := x86RawLegacyPackedMoveConstantRegister(form.prefix, form.opcode, 8)
+		name := fmt.Sprintf("legacyPackedMoveConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		pools = append(pools, code[len(code)-16:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "legacy-packed-move-literal.ll", "legacy-packed-move-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_legacy_scalar_rip.go b/amd64_raw_legacy_scalar_rip.go
new file mode 100644
index 000000000..b6ae2b74d
--- /dev/null
+++ b/amd64_raw_legacy_scalar_rip.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// These Go legacy SSE scalar families read a fixed-width RIP-relative source
+// and update only a vector register or flags. A source-local constant can be
+// materialized without losing an in-place memory write or relocation.
+var x86RawLegacyScalarReadOps = map[Op]bool{
+	"MOVL": true, "MOVQ": true, "MOVLQSX": true,
+	"UCOMISD": true, "UCOMISS": true, "COMISD": true, "COMISS": true,
+	"CMPSS": true, "CMPSD": true,
+	"ADDSS": true, "ADDSD": true, "SUBSS": true, "SUBSD": true,
+	"MULSS": true, "MULSD": true, "DIVSS": true, "DIVSD": true,
+	"MINSS": true, "MINSD": true, "MAXSS": true, "MAXSD": true,
+	"SQRTSS": true, "SQRTSD": true,
+}
+
+func decodeX86RawLegacyScalarRIPData(
+	code []byte, offset int, inst x86asm.Inst, syntax string,
+) (Instr, x86RawLiteralRange, bool, error) {
+	if inst.Mode != 64 || inst.AddrSize != 64 || inst.PCRel != 4 ||
+		inst.MemBytes != 4 && inst.MemBytes != 8 {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	op := Op(strings.Fields(syntax)[0])
+	if !x86RawLegacyScalarReadOps[op] {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	if _, ok := inst.Args[0].(x86asm.Reg); !ok {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	mem, ok := inst.Args[1].(x86asm.Mem)
+	if !ok || mem.Base != x86asm.RIP {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	if len(code) <= offset || code[offset] == 0x64 || code[offset] == 0x65 || code[offset] == 0x67 {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	modRMIndex := offset + inst.PCRelOff - 1
+	if modRMIndex < offset || modRMIndex >= len(code) || code[modRMIndex]&0xc7 != 0x05 {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	trailing := inst.Len - inst.PCRelOff - inst.PCRel
+	if trailing != 0 && (op != "CMPSS" && op != "CMPSD" || trailing != 1) {
+		return Instr{}, x86RawLiteralRange{}, false, nil
+	}
+	patched, data, literal, err := x86RawRIPBytesWithSuffix(code, offset, modRMIndex, inst.MemBytes, trailing)
+	if err != nil {
+		return Instr{}, x86RawLiteralRange{}, true, err
+	}
+	physical, err := x86asm.Decode(patched, 64)
+	if err != nil || physical.Len != len(patched) {
+		return Instr{}, x86RawLiteralRange{}, true, fmt.Errorf("patched legacy scalar encoding is invalid: %v", err)
+	}
+	patchedSyntax, err := decodedX86GoSyntax(physical, patched)
+	if err != nil {
+		return Instr{}, x86RawLiteralRange{}, true, err
+	}
+	instrs, err := parseDecodedX86Instruction(patchedSyntax)
+	if err != nil || len(instrs) != 1 || len(instrs[0].Args) < 2 || instrs[0].Args[0].Kind != OpMem {
+		return Instr{}, x86RawLiteralRange{}, true, fmt.Errorf("patched legacy scalar instruction %q has no memory source: %v", patchedSyntax, err)
+	}
+	setX86RawRIPDataOperand(&instrs[0], 0, data)
+	return instrs[0], literal, true, nil
+}
diff --git a/amd64_raw_legacy_scalar_rip_test.go b/amd64_raw_legacy_scalar_rip_test.go
new file mode 100644
index 000000000..a24daa552
--- /dev/null
+++ b/amd64_raw_legacy_scalar_rip_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawLegacyScalarSourceLocalRIPData(t *testing.T) {
+	for _, op := range []string{
+		"MOVD", "UCOMISD", "UCOMISS", "COMISD", "COMISS",
+		"CMPSS", "CMPSD",
+		"ADDSS", "ADDSD", "SUBSS", "SUBSD", "MULSS", "MULSD",
+		"DIVSS", "DIVSD", "MINSS", "MINSD", "MAXSS", "MAXSD",
+		"SQRTSS", "SQRTSD",
+	} {
+		for _, destination := range []string{"X0", "X10"} {
+			t.Run(op+"/"+destination, func(t *testing.T) {
+				instruction := op + " pool(SB), " + destination
+				if op == "CMPSS" || op == "CMPSD" {
+					instruction += ", $1"
+				}
+				code := assembleX87ControlBytes(t, "amd64",
+					"TEXT scalarRIP(SB),4,$0-0\n\t"+instruction+"\n\tRET\n")
+				inst, err := x86asm.Decode(code, 64)
+				if err != nil || inst.PCRel != 4 || inst.MemBytes <= 0 || inst.Len >= len(code) {
+					t.Fatalf("Go assembler %s %s: %x, decode %+v, %v", op, destination, code, inst, err)
+				}
+				binary.LittleEndian.PutUint32(code[inst.PCRelOff:], 1)
+				for value := 0; value < inst.MemBytes; value++ {
+					code = append(code, byte(value))
+				}
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "scalar RIP", map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || len(decoded[0].x86RIPLiteralData) != inst.MemBytes {
+					t.Fatalf("%s %s decoded as %#v", op, destination, decoded)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawMOVD32PreservesPhysicalWidth(t *testing.T) {
+	const source = "TEXT movd32(SB),4,$0-0\n\tMOVL pool(SB), X0\n\tRET\n"
+	code := assembleX87ControlBytes(t, "amd64", source)
+	physical, err := x86asm.Decode(code, 64)
+	if err != nil || physical.Op != x86asm.MOVD || physical.MemBytes != 4 {
+		t.Fatalf("Go MOVL to X0 encoding: %x, %+v, %v", code, physical, err)
+	}
+	binary.LittleEndian.PutUint32(code[physical.PCRelOff:], 1)
+	code = append(code, 1, 2, 3, 4)
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "MOVD32 literal", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "MOVL" ||
+		len(decoded[0].x86RIPLiteralData) != 4 {
+		t.Fatalf("MOVD32 decoded as %#v", decoded)
+	}
+	var raw strings.Builder
+	raw.WriteString("TEXT ·rawMovd32(SB),4,$0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&raw, "\tBYTE $0x%02x\n", value)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, raw.String(), "func rawMovd32()\n", "amd64", triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "load volatile i32, ptr") ||
+						strings.Contains(ir, "load volatile i64, ptr") {
+						t.Fatal("physical MOVD32 must retain exactly one fault-observable 32-bit load")
+					}
+					compileLLVMToObject(t, llc, triple, "raw-movd32-"+api+".ll", "raw-movd32-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_raw_local_address_test.go b/amd64_raw_local_address_test.go
new file mode 100644
index 000000000..054b61ff8
--- /dev/null
+++ b/amd64_raw_local_address_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawLocalAddressPreservesPointerOffsets(t *testing.T) {
+	// Two RIP-relative LEAs address different bytes of one unreachable table.
+	code := []byte{
+		0x48, 0x8d, 0x05, 0x08, 0, 0, 0, // LEAQ table+0, AX
+		0x48, 0x8d, 0x1d, 0x04, 0, 0, 0, // LEAQ table+3, BX
+		0xc3,
+		1, 2, 3, 4, 5, 6,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "local address table", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 3 || decoded[0].Op != "LEAQ" || decoded[1].Op != "LEAQ" ||
+		decoded[0].Args[1].Reg != AX || decoded[1].Args[1].Reg != BX ||
+		decoded[0].x86RIPAddressOff != 0 || decoded[1].x86RIPAddressOff != 3 {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT localAddress(SB),$0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != 1 || len(normalized.Funcs[0].Instrs) != 4 {
+		t.Fatalf("shared local address layout: %d globals, %d instructions", len(normalized.Data), len(normalized.Funcs[0].Instrs))
+	}
+	firstAddress := normalized.Funcs[0].Instrs[1].Args[0].Sym
+	secondAddress := normalized.Funcs[0].Instrs[2].Args[0].Sym
+	if firstAddress != normalized.Data[0].Sym+"(SB)" ||
+		secondAddress != normalized.Data[0].Sym+"+3(SB)" {
+		t.Fatalf("shared address offsets = %q, %q", firstAddress, secondAddress)
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"localAddress": {Name: "localAddress", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "raw_address") {
+				t.Fatal("shared local-address data global missing")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-local-address.ll", "raw-local-address.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawLocalAddressSharesLiteralPool(t *testing.T) {
+	code := []byte{
+		0x48, 0x8d, 0x05, 0x09, 0, 0, 0, // LEAQ table, AX
+		0x66, 0x0f, 0x6f, 0x05, 0x01, 0, 0, 0, // MOVDQU table, X0
+		0xc3,
+	}
+	for value := byte(0); value < 16; value++ {
+		code = append(code, value)
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "shared literal pool", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 3 || len(decoded[0].x86RIPAddressData) != 16 ||
+		len(decoded[1].x86RIPAddressData) != 16 ||
+		decoded[0].x86RIPAddressOff != 0 || decoded[1].x86RIPAddressOff != 0 {
+		t.Fatalf("shared pool decoded as %#v", decoded)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT localAddressAndLiteral(SB),$0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != 1 ||
+		len(normalized.Funcs[0].Instrs) != 4 ||
+		normalized.Funcs[0].Instrs[1].Args[0].Sym != normalized.Data[0].Sym+"(SB)" ||
+		normalized.Funcs[0].Instrs[2].Args[0].Sym != normalized.Data[0].Sym+"(SB)" {
+		t.Fatalf("local address and literal did not share data: %d globals, %d instructions", len(normalized.Data), len(normalized.Funcs[0].Instrs))
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"localAddressAndLiteral": {Name: "localAddressAndLiteral", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-shared-pool.ll", "raw-shared-pool.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawLocalAddressRejectsReachableCode(t *testing.T) {
+	code := []byte{
+		0x48, 0x8d, 0x05, 0x00, 0, 0, 0, // LEAQ next instruction, AX
+		0xc3,
+	}
+	_, err := decodeX86RawDirectiveGroup(code, 64, 0, "code address", map[string]bool{})
+	if err == nil || !strings.Contains(err.Error(), "no preceding RET") {
+		t.Fatalf("address of reachable code: %v", err)
+	}
+}
+
+func TestDecodeX86RawLocalAddressSignExtendsNegativeDisplacement(t *testing.T) {
+	// LEAQ -7(RIP), AX points to its own first byte, not byte 2^32.
+	code := []byte{0x48, 0x8d, 0x05, 0xf9, 0xff, 0xff, 0xff, 0xc3}
+	_, err := decodeX86RawDirectiveGroup(code, 64, 0, "self address", map[string]bool{})
+	if err == nil || !strings.Contains(err.Error(), "no preceding RET") {
+		t.Fatalf("self-addressed native TEXT must fail with layout reason, got %v", err)
+	}
+}
diff --git a/amd64_raw_logical_literal_test.go b/amd64_raw_logical_literal_test.go
new file mode 100644
index 000000000..e4578d5e6
--- /dev/null
+++ b/amd64_raw_logical_literal_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawPackedLogicalLiteral(op Op, evex bool, width, mask int, zeroing, broadcast bool) []byte {
+	var code []byte
+	if evex {
+		length := byte(map[int]int{16: 0, 32: 1, 64: 2}[width])
+		code = encodeX86RawEVEXPackedLogical(op, length, mask, zeroing, broadcast, 0, 0, 0)
+	} else {
+		opcode := map[Op]byte{"VPAND": 0xdb, "VPANDN": 0xdf, "VPOR": 0xeb, "VPXOR": 0xef}[op]
+		code = encodeX86VEXPackedIntegerLogical(opcode, true, width == 32, false, 0, 0, 0)
+	}
+	code[len(code)-1] = 0x05 // RIP+disp32 rather than X0.
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = 4
+		if strings.HasSuffix(string(op), "Q") {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*9+7))
+	}
+	return code
+}
+
+func TestTranslateX86RawPackedLogicalRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	var pools [][]byte
+	add := func(name string, code []byte, width int) {
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		pools = append(pools, code[len(code)-width:])
+	}
+	for index, op := range []Op{"VPAND", "VPANDN", "VPOR", "VPXOR"} {
+		add(fmt.Sprintf("vexLogical%d", index), x86RawPackedLogicalLiteral(op, false, 32, 0, false, false), 32)
+	}
+	for index, op := range []Op{
+		"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ",
+		"VPORD", "VPORQ", "VPXORD", "VPXORQ",
+	} {
+		width := 4
+		if strings.HasSuffix(string(op), "Q") {
+			width = 8
+		}
+		add(fmt.Sprintf("evexLogical%d", index), x86RawPackedLogicalLiteral(op, true, 64, 7, true, true), width)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Retain every original VEX and EVEX function. The EVEX functions
+			// lack K7; separate complete initialized programs own public objects.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "logical-literal.ll", "logical-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawPackedLogicalRIPDataRejectsUnsafeSources(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{name: "outside_pool", edit: func(code []byte) []byte {
+			code[6] = 0x7f
+			return code
+		}},
+		{name: "overlapping_instruction", edit: func(code []byte) []byte {
+			copy(code[6:10], []byte{0xfa, 0xff, 0xff, 0xff})
+			return code
+		}},
+		{name: "segment_override", edit: func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		}},
+		{name: "address_override", edit: func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.edit(x86RawPackedLogicalLiteral("VPXORD", true, 64, 0, false, false))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, test.name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe packed logical RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawPackedLogicalRIPDataCompleteFamily(t *testing.T) {
+	for _, op := range []Op{"VPAND", "VPANDN", "VPOR", "VPXOR"} {
+		for _, width := range []int{16, 32} {
+			name := fmt.Sprintf("%s/%d", op, width)
+			t.Run(name, func(t *testing.T) {
+				code := x86RawPackedLogicalLiteral(op, false, width, 0, false, false)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || decoded[0].Op != op ||
+					len(decoded[0].Args) != 3 || decoded[0].Args[0].Kind != OpSym ||
+					!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want %s literal source", code, decoded, op)
+				}
+			})
+		}
+	}
+	for _, op := range []Op{
+		"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ",
+		"VPORD", "VPORQ", "VPXORD", "VPXORQ",
+	} {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				name := fmt.Sprintf("%s/%d/bcst%t", op, width, broadcast)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawPackedLogicalLiteral(op, true, width, 7, true, broadcast)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := op
+					if broadcast {
+						want += ".BCST"
+					}
+					want += ".Z"
+					if len(decoded) != 2 || decoded[0].Op != want ||
+						len(decoded[0].Args) != 4 || decoded[0].Args[0].Kind != OpSym ||
+						!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s literal source", code, decoded, want)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_mask_blend.go b/amd64_raw_mask_blend.go
new file mode 100644
index 000000000..6268203b0
--- /dev/null
+++ b/amd64_raw_mask_blend.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RawMaskBlendInstruction covers all six Go 1.27 _yvblendmpd
+// operations across EVEX X/Y/Z, optional K mask and zeroing, and permitted
+// D/Q scalar broadcasts. The shared typed operand decoder handles ModRM/SIB.
+func decodedX86RawMaskBlendInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	var laneBits int
+	switch p.opcode {
+	case 0x65:
+		if p.w {
+			op, laneBits = "VBLENDMPD", 64
+		} else {
+			op, laneBits = "VBLENDMPS", 32
+		}
+	case 0x64:
+		if p.w {
+			op, laneBits = "VPBLENDMQ", 64
+		} else {
+			op, laneBits = "VPBLENDMD", 32
+		}
+	case 0x66:
+		if p.w {
+			op, laneBits = "VPBLENDMW", 16
+		} else {
+			op, laneBits = "VPBLENDMB", 8
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+	if mode == 32 && p.mask != 0 {
+		return Instr{}, 0, true, fmt.Errorf("386 masked %s exceeds Go's three-operand frontend", op)
+	}
+	return decodedX86BinaryVectorOperands(code, p, mode, op, laneBits)
+}
diff --git a/amd64_raw_mask_blend_test.go b/amd64_raw_mask_blend_test.go
new file mode 100644
index 000000000..2474e6626
--- /dev/null
+++ b/amd64_raw_mask_blend_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawMaskBlendEncoding(op Op, width, mask int, zeroing, broadcast, rip bool) []byte {
+	properties := map[Op]struct {
+		opcode byte
+		w      bool
+	}{
+		"VBLENDMPS": {0x65, false}, "VBLENDMPD": {0x65, true},
+		"VPBLENDMD": {0x64, false}, "VPBLENDMQ": {0x64, true},
+		"VPBLENDMB": {0x66, false}, "VPBLENDMW": {0x66, true},
+	}[op]
+	p1 := byte(0x75) // source 2 is register 1, fixed bit and pp=66.
+	if properties.w {
+		p1 |= 0x80
+	}
+	p2 := byte(map[int]int{16: 0, 32: 1, 64: 2}[width]<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // register 3, destination register 2.
+	if broadcast {
+		modRM = 0x13 // 0(BX), destination register 2.
+	}
+	if rip {
+		modRM = 0x15 // RIP+disp32, destination register 2.
+	}
+	code := []byte{0x62, 0xf2, p1, p2, properties.opcode, modRM}
+	if rip {
+		code = append(code, 1, 0, 0, 0)
+	}
+	return code
+}
+
+func TestDecodeX86RawMaskBlend386FrontendBoundary(t *testing.T) {
+	plain := x86RawMaskBlendEncoding("VBLENDMPS", 16, 0, false, false, false)
+	if _, _, ok, err := decodedX86RawMaskBlendInstruction(plain, 32); !ok || err != nil {
+		t.Fatalf("386 unmasked EVEX form: ok=%v err=%v", ok, err)
+	}
+	masked := x86RawMaskBlendEncoding("VBLENDMPS", 16, 1, false, false, false)
+	if _, _, ok, err := decodedX86RawMaskBlendInstruction(masked, 32); !ok || err == nil {
+		t.Fatalf("386 masked EVEX form accepted: ok=%v err=%v", ok, err)
+	}
+}
+
+func x86RawMaskBlendLiteral(op Op, width, mask int, zeroing, broadcast bool) []byte {
+	code := x86RawMaskBlendEncoding(op, width, mask, zeroing, broadcast, true)
+	code = append(code, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = amd64MaskBlendSpecs[op].laneBits / 8
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*7+5))
+	}
+	return code
+}
+
+func TestDecodeX86RawMaskBlendCompleteGo127Family(t *testing.T) {
+	if len(amd64MaskBlendSpecs) != 6 {
+		t.Fatalf("modeled %d mask-blend operations, want six", len(amd64MaskBlendSpecs))
+	}
+	for op, spec := range amd64MaskBlendSpecs {
+		for _, width := range []int{16, 32, 64} {
+			for _, masking := range []struct {
+				mask int
+				zero bool
+			}{
+				{}, {mask: 5}, {mask: 7, zero: true},
+			} {
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && !spec.broadcast {
+						continue
+					}
+					code := x86RawMaskBlendEncoding(op, width, masking.mask, masking.zero, broadcast, false)
+					got, length, ok, err := decodedX86RawMaskBlendInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %s %x = %+v, length=%d, ok=%v, err=%v", op, code, got, length, ok, err)
+					}
+					want := op
+					if broadcast {
+						want += ".BCST"
+					}
+					if masking.zero {
+						want += ".Z"
+					}
+					if got.Op != want || len(got.Args) != 3+map[bool]int{false: 0, true: 1}[masking.mask != 0] ||
+						got.Args[1].Reg != "Z1" && width == 64 {
+						t.Fatalf("decode %s %x = %+v, want %s", op, code, got, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawMaskBlendArgReduceAVX512Regression(t *testing.T) {
+	code := []byte{0x62, 0xf2, 0x75, 0x4d, 0x65, 0xdb, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "argreduce AVX512 mask blend", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VBLENDMPS" ||
+		decoded[0].Raw != "VBLENDMPS Z3, Z1, K5, Z3 /* decoded from argreduce AVX512 mask blend */" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawMaskBlendRIPDataCompleteFamily(t *testing.T) {
+	for op, spec := range amd64MaskBlendSpecs {
+		for _, width := range []int{16, 32, 64} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !spec.broadcast {
+					continue
+				}
+				name := fmt.Sprintf("%s/%d/bcst%t", op, width, broadcast)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawMaskBlendLiteral(op, width, 7, true, broadcast)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					dataWidth := width
+					if broadcast {
+						dataWidth = spec.laneBits / 8
+					}
+					if len(decoded) != 2 || decoded[0].Args[0].Kind != OpSym ||
+						!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET ||
+						!bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-dataWidth:]) {
+						t.Fatalf("decoded mask-blend literal %x as %#v", code, decoded)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawMaskBlendRejectsUnsafeForms(t *testing.T) {
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated literal":       func(code []byte) []byte { return code[:len(code)-1] },
+		"outside directive group": func(code []byte) []byte { code[6] = 127; return code },
+		"overlapping instruction": func(code []byte) []byte { code[6] = 0; return code },
+		"segment override":        func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address override":        func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(x86RawMaskBlendLiteral("VBLENDMPS", 64, 7, true, true))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe mask-blend literal %x", code)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		x86RawMaskBlendEncoding("VPBLENDMB", 16, 3, false, true, false),
+		x86RawMaskBlendEncoding("VBLENDMPS", 16, 0, true, false, false),
+	} {
+		if _, _, ok, err := decodedX86RawMaskBlendInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("accepted reserved mask blend %x: ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateX86RawMaskBlendRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	index := 0
+	for op, spec := range amd64MaskBlendSpecs {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && !spec.broadcast {
+				continue
+			}
+			name := fmt.Sprintf("maskBlendLiteral%d", index)
+			index++
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range x86RawMaskBlendLiteral(op, 64, 7, true, broadcast) {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-mask-blend-literal.ll", "raw-mask-blend-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_mask_broadcast_test.go b/amd64_raw_mask_broadcast_test.go
new file mode 100644
index 000000000..6b60ba647
--- /dev/null
+++ b/amd64_raw_mask_broadcast_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This physical directory is independent of the decoder and is also checked
+// against actual cmd/asm output below. K is a data operand, not a writemask.
+func x86MaskBroadcastPhysicalBytes(op string, width, source, destination int) []byte {
+	p0 := byte(0xf2 ^ ((destination >> 3 & 1) << 7) ^ ((destination >> 4 & 1) << 4))
+	p1, opcode := byte(0x7e), byte(0x3a)
+	if op == "VPBROADCASTMB2Q" {
+		p1, opcode = 0xfe, 0x2a
+	}
+	return []byte{0x62, p0, p1, byte(width<<5 | 8), opcode, byte(0xc0 | destination&7<<3 | source)}
+}
+
+func TestX86BroadcastRawMaskDataOriginalGoBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		source.WriteString("TEXT f(SB),4,$0-0\n")
+		var expected []byte
+		for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+			for width, bank := range []string{"X", "Y", "Z"} {
+				for _, input := range []int{0, 7} {
+					destinations := []int{0, 7}
+					if arch == "amd64" {
+						destinations = append(destinations, 31)
+					}
+					for _, destination := range destinations {
+						fmt.Fprintf(&source, "%s K%d,%s%d\n", op, input, bank, destination)
+						expected = append(expected, x86MaskBroadcastPhysicalBytes(op, width, input, destination)...)
+					}
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		expected = append(expected, 0xc3)
+		actual := assembleX87ControlBytes(t, arch, source.String())
+		if !bytes.Equal(actual, expected) {
+			t.Fatalf("%s actual Go mask broadcast bytes %x, expected %x", arch, actual, expected)
+		}
+		for offset := 0; offset < len(actual)-1; offset += 6 {
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			ins, length, known, err := decodedX86VEXPackedBroadcastInstruction(actual[offset:offset+6], mode)
+			if err != nil || !known || length != 6 {
+				t.Fatalf("%s actual Go bytes %x: known%t length%d err%v", arch, actual[offset:offset+6], known, length, err)
+			}
+			form, recognized, err := x86BroadcastProperties(ins.Op, ins, arch)
+			if err != nil || !recognized || form.kind != x86BroadcastMask {
+				t.Fatalf("%s physical mask grammar %+v: known%t err%v", arch, form, recognized, err)
+			}
+			// This private decoder returns a plain instruction, not a raw-source
+			// entry contract. Its numerical effect requires only its actual K
+			// data input; neither another initialized mask nor the decoder can
+			// manufacture that input or grant native-memory/entry permission.
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				input, _ := amd64ParseKReg(ins.Args[0].Reg)
+				destination, _ := amd64VectorRegisterIndex(ins.Args[1].Reg, form.byteWidth)
+				for _, initialized := range []bool{false, true} {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.masks[(input+1)%len(state.masks)] = true
+					state.masks[input] = initialized
+					before := state.clone()
+					if accepted := consumer.step(ins, &state, nil, 0, arch); accepted != initialized {
+						t.Fatalf("%s %s K%d initialized%t: accepted%t", arch, consumer.name, input, initialized, accepted)
+					}
+					expected := before.clone()
+					if initialized {
+						expected.writeVector(destination, form.byteWidth, ^uint64(0), false)
+					}
+					if !reflect.DeepEqual(state, expected) {
+						t.Fatalf("%s %s changed unrelated state or invented missing input: %+v", arch, consumer.name, state)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastMaskDataUnboundPublicSourceNeedsContext(t *testing.T) {
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, row := range []string{"VPBROADCASTMB2Q K0,X2", "VPBROADCASTMW2D K7,Z2"} {
+			for _, raw := range []bool{false, true} {
+				t.Run(target.triple+"/"+row+fmt.Sprint("/raw", raw), func(t *testing.T) {
+					var source strings.Builder
+					source.WriteString("TEXT f(SB),4,$0-0\n")
+					emitX86GoEncodedTestInstructionForArch(t, &source, row, raw, target.arch)
+					source.WriteString("RET\n")
+					// Raw normalization and a Void result cannot supply the
+					// missing K data. Preserve the original Go object as well
+					// as Context with empty IR through all three public APIs.
+					x86UnboundVoidFormatSource(t, source.String(), "f", target.arch, target.triple)
+				})
+			}
+		}
+	}
+}
+
+func TestX86BroadcastRawMaskDataCompletePhysicalBanks(t *testing.T) {
+	count := 0
+	for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+		for width, bank := range []string{"X", "Y", "Z"} {
+			for input := 0; input < 8; input++ {
+				for destination := 0; destination < 32; destination++ {
+					code := x86MaskBroadcastPhysicalBytes(op, width, input, destination)
+					ins, length, known, err := decodedX86VEXPackedBroadcastInstruction(code, 64)
+					want := fmt.Sprintf("%s K%d, %s%d", op, input, bank, destination)
+					if err != nil || !known || length != 6 || ins.Raw != want {
+						t.Fatalf("decode %x: %+v length%d known%t err%v; want %q", code, ins, length, known, err, want)
+					}
+					_, _, known32, err32 := decodedX86VEXPackedBroadcastInstruction(code, 32)
+					if !known32 || (err32 != nil) != (destination >= 8) {
+						t.Fatalf("mode32 destination%d: known%t err%v", destination, known32, err32)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 1536 {
+		t.Fatalf("physical directory covered %d encodings", count)
+	}
+}
+
+func TestX86BroadcastRawMaskDataReservedAndUnprovedForms(t *testing.T) {
+	for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+		valid := x86MaskBroadcastPhysicalBytes(op, 0, 0, 0)
+		for name, mutate := range map[string]func([]byte){
+			"wrong W":            func(code []byte) { code[2] ^= 0x80 },
+			"missing fixed bit":  func(code []byte) { code[2] &^= 4 },
+			"used vvvv":          func(code []byte) { code[2] &^= 8 },
+			"used high vvvv":     func(code []byte) { code[3] &^= 8 },
+			"source extension B": func(code []byte) { code[1] &^= 0x20 },
+			"source extension X": func(code []byte) { code[1] &^= 0x40 },
+			"writemask":          func(code []byte) { code[3] |= 1 },
+			"zeroing":            func(code []byte) { code[3] |= 0x80 },
+			"broadcast bit":      func(code []byte) { code[3] |= 0x10 },
+			"reserved length":    func(code []byte) { code[3] |= 0x60 },
+			"memory input":       func(code []byte) { code[5] &^= 0xc0 },
+		} {
+			code := append([]byte(nil), valid...)
+			mutate(code)
+			if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(code, 64); !known || err == nil {
+				t.Fatalf("%s %s %x: known%t err%v", op, name, code, known, err)
+			}
+		}
+		for _, prefix := range []byte{0x64, 0x65, 0x67} {
+			code := append([]byte{prefix}, valid...)
+			if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(code, 64); !known || err == nil {
+				t.Fatalf("%s forbidden prefix%x: known%t err%v", op, prefix, known, err)
+			}
+		}
+		if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(valid[:5], 64); !known || err == nil {
+			t.Fatalf("%s missing ModRM: known%t err%v", op, known, err)
+		}
+		for length := 0; length < 5; length++ {
+			if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(valid[:length], 64); known || err != nil {
+				t.Fatalf("%s incomplete prefix length%d: known%t err%v", op, length, known, err)
+			}
+		}
+		for name, mutate := range map[string]func([]byte){
+			"other map":    func(code []byte) { code[1] ^= 1 },
+			"other prefix": func(code []byte) { code[2] ^= 1 },
+			"other opcode": func(code []byte) { code[4] ^= 1 },
+		} {
+			code := append([]byte(nil), valid...)
+			mutate(code)
+			if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(code, 64); known || err != nil {
+				t.Fatalf("%s %s outside grammar: known%t err%v", op, name, known, err)
+			}
+		}
+	}
+}
+
+func TestX86BroadcastRawMaskDataMandatoryPrefixCollision(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for _, row := range []string{"VPBROADCASTMB2Q K0,X0", "VPBROADCASTMW2D K7,Z3", "VPMINUW Z1,Z2,Z3"} {
+			code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if len(code) != 7 || code[0] != 0x62 || code[1]&15 != 2 {
+				t.Fatalf("%s original Go opcode-map witness %q: %x", arch, row, code)
+			}
+			want := Op(strings.Fields(row)[0])
+			prefix := byte(2)
+			if want == "VPMINUW" {
+				prefix = 1
+			}
+			if code[2]&3 != prefix || want != "VPBROADCASTMB2Q" && code[4] != 0x3a {
+				t.Fatalf("%s original mandatory-prefix/opcode witness %q: %x", arch, row, code)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT f(SB),4,$0-0\n")
+			for _, value := range code[:6] {
+				fmt.Fprintf(&source, "BYTE $%#x\n", value)
+			}
+			source.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized, err := decodeX86RawDirectives(file.Funcs[0], arch)
+			if err != nil {
+				t.Fatalf("%s actual Go %q directive route: %v", arch, row, err)
+			}
+			ins := normalized.Instrs[1]
+			if ins.Op != want || ins.x86SourceRaw == nil || ins.x86SourceRaw.op != want {
+				t.Fatalf("%s %q lost original decoded source identity: %+v", arch, row, ins)
+			}
+			if want == "VPMINUW" {
+				if len(ins.Args) != 3 || ins.Args[0].String() != "Z1" || ins.Args[1].String() != "Z2" || ins.Args[2].String() != "Z3" {
+					t.Fatalf("legal min/max sibling changed: %+v", ins)
+				}
+				continue
+			}
+			for name, mutate := range map[string]func([]byte){
+				"reserved mandatory prefix": func(code []byte) { code[2] ^= 1 },
+				"reserved fixed bit":        func(code []byte) { code[2] &^= 4 },
+				"reserved W":                func(code []byte) { code[2] ^= 0x80 },
+				"unproved memory":           func(code []byte) { code[5] &^= 0xc0 },
+			} {
+				invalid := append([]byte(nil), code[:6]...)
+				mutate(invalid)
+				if _, err := decodeX86RawDirectiveGroup(invalid, mode, 0, name, map[string]bool{}); err == nil {
+					t.Fatalf("%s %q %s accepted through another decoder: %x", arch, row, name, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_raw_mask_compare.go b/amd64_raw_mask_compare.go
new file mode 100644
index 000000000..b92e4ba91
--- /dev/null
+++ b/amd64_raw_mask_compare.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawMaskCompareForm struct {
+	op        Op
+	laneBytes int
+}
+
+// The eight signed and unsigned Go 1.27 _yvpcmpb opcode rows are selected
+// by the opcode and EVEX.W, not by a separate decoder for each mnemonic.
+var x86RawMaskCompareForms = map[[2]int]x86RawMaskCompareForm{
+	{0x3f, 0}: {op: "VPCMPB", laneBytes: 1},
+	{0x3f, 1}: {op: "VPCMPW", laneBytes: 2},
+	{0x1f, 0}: {op: "VPCMPD", laneBytes: 4},
+	{0x1f, 1}: {op: "VPCMPQ", laneBytes: 8},
+	{0x3e, 0}: {op: "VPCMPUB", laneBytes: 1},
+	{0x3e, 1}: {op: "VPCMPUW", laneBytes: 2},
+	{0x1e, 0}: {op: "VPCMPUD", laneBytes: 4},
+	{0x1e, 1}: {op: "VPCMPUQ", laneBytes: 8},
+}
+
+func decodedX86RawMaskCompareInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 3 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawMaskCompareForms[[2]int{p.opcode, w}]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX mask compare: %s", message)
+	}
+	if mode != 64 && mode != 32 {
+		return fail("unknown physical x86 mode")
+	}
+	if !p.fixed || p.addressOverride || p.vectorLength > 2 || p.zero || p.r != 0 {
+		return fail("invalid EVEX fixed, address, vector length, zeroing, or K destination extension")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	if mode == 32 && (p.upper >= 8 || modRM>>6 == 3 && int(modRM&7)+8*p.b+16*p.x >= 8) {
+		return fail("extended source vector has no physical mode32 binding")
+	}
+	if p.broadcast && (form.laneBytes < 4 || modRM>>6 == 3) {
+		return fail("broadcast requires a D/Q scalar-memory first source")
+	}
+	vector := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	disp8Scale := 16 << p.vectorLength
+	if p.broadcast {
+		disp8Scale = form.laneBytes
+	}
+	first, consumed, err := decodedX86EVEXRMOperand(
+		code[p.modRM:], mode, p.b, p.x, p.segment, vector, disp8Scale,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := p.modRM + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	op := form.op
+	if p.broadcast {
+		op += ".BCST"
+	}
+	args := []Operand{
+		{Kind: OpImm, Imm: int64(code[immIndex])},
+		first,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, p.upper))},
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", modRM>>3&7))})
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, immIndex + 1, true, nil
+}
diff --git a/amd64_raw_mask_compare_test.go b/amd64_raw_mask_compare_test.go
new file mode 100644
index 000000000..7bd3f9614
--- /dev/null
+++ b/amd64_raw_mask_compare_test.go
@@ -0,0 +1,194 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawMaskCompare(opcode, widthBit, vectorBits, writeMask int, broadcast, memory bool) []byte {
+	p1 := byte(0x5d) // EVEX.vvvv = vector register 4, pp = 66.
+	if widthBit != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | writeMask)
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // first register 3, K destination 2.
+	if memory {
+		modRM = 0x50 // disp8(AX), K destination 2.
+	}
+	code := []byte{0x62, 0xf3, p1, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return append(code, 6)
+}
+
+func TestDecodeX86RawMaskCompareSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VPCMPUB $6, 0(SI)(R8*1), Z0, K0.
+	code := []byte{0x62, 0xb3, 0x7d, 0x48, 0x3e, 0x04, 0x06, 0x06, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "maskBitsLess AVX512 VPCMPUB", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPCMPUB" ||
+		decoded[0].Args[0].Imm != 6 || decoded[0].Args[2].Reg != "Z0" ||
+		decoded[0].Args[3].Reg != "K0" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawMaskCompareCompleteGoForms(t *testing.T) {
+	if len(x86RawMaskCompareForms) != 8 {
+		t.Fatalf("modeled %d EVEX mask-compare rows, want eight", len(x86RawMaskCompareForms))
+	}
+	for encoding, form := range x86RawMaskCompareForms {
+		for vectorBits := 0; vectorBits < 3; vectorBits++ {
+			vector := [...]string{"X", "Y", "Z"}[vectorBits]
+			for _, variant := range []struct {
+				name      string
+				writeMask int
+				broadcast bool
+				memory    bool
+			}{
+				{name: "register"},
+				{name: "masked register", writeMask: 3},
+				{name: "memory", memory: true},
+				{name: "masked memory", writeMask: 7, memory: true},
+				{name: "broadcast memory", broadcast: true, memory: true},
+			} {
+				if variant.broadcast && form.laneBytes < 4 {
+					continue
+				}
+				name := fmt.Sprintf("%s/%s/%s", form.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawMaskCompare(encoding[0], encoding[1], vectorBits, variant.writeMask, variant.broadcast, variant.memory)
+					got, length, ok, err := decodedX86RawMaskCompareInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := form.op
+					if variant.broadcast {
+						wantOp += ".BCST"
+					}
+					if got.Op != wantOp || got.Args[0].Imm != 6 || got.Args[2].String() != vector+"4" ||
+						got.Args[len(got.Args)-1].String() != "K2" ||
+						!variant.memory && got.Args[1].String() != vector+"3" ||
+						len(got.Args) != 4+map[bool]int{true: 1}[variant.writeMask != 0] {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawMaskCompareRIPLiteral(t *testing.T) {
+	for encoding, form := range x86RawMaskCompareForms {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && form.laneBytes < 4 {
+				continue
+			}
+			code := encodeX86RawMaskCompare(encoding[0], encoding[1], 2, 1, broadcast, false)
+			code = code[:6]
+			code[5] = 0x15 // RIP-relative first source, K destination 2.
+			code = append(code, 1, 0, 0, 0, 6, 0xc3)
+			literalWidth := 64
+			if broadcast {
+				literalWidth = form.laneBytes
+			}
+			for index := 0; index < literalWidth; index++ {
+				code = append(code, byte(index+1))
+			}
+			name := fmt.Sprintf("%s/broadcast%t", form.op, broadcast)
+			t.Run(name, func(t *testing.T) {
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				wantOp := form.op
+				if broadcast {
+					wantOp += ".BCST"
+				}
+				if len(got) != 2 || !got[0].x86RIPLiteral ||
+					len(got[0].x86RIPLiteralData) != literalWidth || got[0].Op != wantOp {
+					t.Fatalf("decode %x = %+v", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawMaskCompareRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawMaskCompare(0x3e, 0, 2, 0, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x80 },  // no EVEX zeroing
+		func(code []byte) { code[3] |= 0x20 },  // reserved vector length
+		func(code []byte) { code[3] |= 0x10 },  // byte broadcast unavailable
+		func(code []byte) { code[1] &^= 0x80 }, // K destination extension
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86RawMaskCompareInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	extended := append([]byte(nil), base...)
+	extended[2] &^= 0x40 // Physical source X12, not the valid low-register mode32 row.
+	if _, _, ok, err := decodedX86RawMaskCompareInstruction(extended, 32); !ok || err == nil {
+		t.Fatalf("accepted unbound mode32 source vector: ok=%v err=%v", ok, err)
+	}
+}
+
+func TestTranslateX86RawMaskCompareLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawMaskCompare(SB),$0-0\n")
+			for encoding, form := range x86RawMaskCompareForms {
+				code := encodeX86RawMaskCompare(encoding[0], encoding[1], 0, 0, false, false)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+				if form.laneBytes >= 4 {
+					code = encodeX86RawMaskCompare(encoding[0], encoding[1], 0, 3, true, true)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawMaskCompare": {Name: "rawMaskCompare", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original raw compare formats invented native/mask inputs", err)
+			}
+			normalized, err := normalizeX86RawFile(file, "amd64")
+			if err != nil {
+				t.Fatal("original raw compare format bytes no longer decode", err)
+			}
+			ir = x86InstructionFormatObjectUnit(t, normalized,
+				map[string]FuncSig{"rawMaskCompare": {Name: "rawMaskCompare", Ret: Void}}, "amd64", triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerImmediatePackedCompare(ins.Op, ins) })
+			compileLLVMToObject(t, llc, triple, "raw-mask-compare.ll", "raw-mask-compare.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_mask_move_test.go b/amd64_raw_mask_move_test.go
new file mode 100644
index 000000000..8e06463bb
--- /dev/null
+++ b/amd64_raw_mask_move_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawMaskMoveCompleteGo127Family(t *testing.T) {
+	// Go 1.27's shared _ykmovb table gives KMOVB/W/D/Q the same four
+	// encoding rows: K->memory, K->GP, K-or-memory->K, and GP->K. Cover
+	// every row at every width, plus the extended GP form reported by
+	// github.com/minio/sha256-simd.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "b k to k", code: []byte{0xc5, 0xf9, 0x90, 0xcd}, want: "KMOVB K5, K1"},
+		{name: "b memory to k", code: []byte{0xc5, 0xf9, 0x90, 0x08}, want: "KMOVB 0(AX), K1"},
+		{name: "b k to memory", code: []byte{0xc5, 0xf9, 0x91, 0x00}, want: "KMOVB K0, 0(AX)"},
+		{name: "b k to gp", code: []byte{0xc5, 0xf9, 0x93, 0xc5}, want: "KMOVB K5, AX"},
+		{name: "b gp to k", code: []byte{0xc5, 0xf9, 0x92, 0xe8}, want: "KMOVB AX, K5"},
+		{name: "w k to k", code: []byte{0xc5, 0xf8, 0x90, 0xcd}, want: "KMOVW K5, K1"},
+		{name: "w memory to k", code: []byte{0xc5, 0xf8, 0x90, 0x08}, want: "KMOVW 0(AX), K1"},
+		{name: "w k to memory", code: []byte{0xc5, 0xf8, 0x91, 0x00}, want: "KMOVW K0, 0(AX)"},
+		{name: "w k to gp", code: []byte{0xc5, 0xf8, 0x93, 0xc5}, want: "KMOVW K5, AX"},
+		{name: "w gp to k", code: []byte{0xc5, 0xf8, 0x92, 0xe8}, want: "KMOVW AX, K5"},
+		{name: "d k to k", code: []byte{0xc4, 0xe1, 0xf9, 0x90, 0xcd}, want: "KMOVD K5, K1"},
+		{name: "d memory to k", code: []byte{0xc4, 0xe1, 0xf9, 0x90, 0x08}, want: "KMOVD 0(AX), K1"},
+		{name: "d k to memory", code: []byte{0xc4, 0xe1, 0xf9, 0x91, 0x00}, want: "KMOVD K0, 0(AX)"},
+		{name: "d k to gp", code: []byte{0xc5, 0xfb, 0x93, 0xc5}, want: "KMOVD K5, AX"},
+		{name: "d gp to k", code: []byte{0xc5, 0xfb, 0x92, 0xe8}, want: "KMOVD AX, K5"},
+		{name: "q k to k", code: []byte{0xc4, 0xe1, 0xf8, 0x90, 0xcd}, want: "KMOVQ K5, K1"},
+		{name: "q memory to k", code: []byte{0xc4, 0xe1, 0xf8, 0x90, 0x08}, want: "KMOVQ 0(AX), K1"},
+		{name: "q k to memory", code: []byte{0xc4, 0xe1, 0xf8, 0x91, 0x00}, want: "KMOVQ K0, 0(AX)"},
+		{name: "q k to gp", code: []byte{0xc4, 0xe1, 0xfb, 0x93, 0xc5}, want: "KMOVQ K5, AX"},
+		{name: "q gp to k", code: []byte{0xc4, 0xe1, 0xfb, 0x92, 0xe8}, want: "KMOVQ AX, K5"},
+		{name: "q reported extended gp to k", code: []byte{0xc4, 0xc1, 0xfb, 0x92, 0xce}, want: "KMOVQ R14, K1"},
+		{name: "q extended k to gp", code: []byte{0xc4, 0x61, 0xfb, 0x93, 0xd7}, want: "KMOVQ K7, R10"},
+		{name: "q extended sib memory to k", code: []byte{0xc4, 0x81, 0xf8, 0x90, 0x4c, 0x88, 0x20}, want: "KMOVQ 32(R8)(R9*4), K1"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			fn := Func{}
+			for _, value := range test.code {
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+			}
+			got, err := decodeX86RawDirectives(fn, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(got.Instrs) != 1 || !strings.HasPrefix(got.Instrs[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %#x as %#v, want %q", test.code, got.Instrs, test.want)
+			}
+		})
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch+"/lower", func(t *testing.T) {
+			var unbound strings.Builder
+			unbound.WriteString("TEXT raw_mask_move(SB),NOSPLIT,$0-0\n")
+			for _, test := range tests[:20] {
+				unbound.WriteString(x86RawDisplacementDirectives(test.code))
+			}
+			unbound.WriteString("RET\n")
+			// Preserve the original complete source as a Go-format object and
+			// public Context control. Unknown AX/K inputs are not an ABI.
+			x86UnboundVoidFormatSources(t, unbound.String(), target.goarch, target.triple)
+			for index, test := range tests[:20] {
+				t.Run(test.name, func(t *testing.T) {
+					name := fmt.Sprintf("rawMask%d", index)
+					word, move := 8, "MOVQ"
+					if target.goarch == "386" {
+						word, move = 4, "MOVL"
+					}
+					arguments, extent := "", 0
+					setup := "MOVL $21,AX\n"
+					if strings.Contains(test.want, "(AX)") {
+						arguments, extent = "p *uint64", word
+						setup = move + " p+0(FP),AX\n"
+					}
+					// Each original opcode gets an independent function: a K->AX
+					// result must never become the next row's memory address.
+					source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOVL $91,CX\nKMOVD CX,K0\nKMOVD CX,K5\n%s%sRET\n",
+						name, extent, setup, x86RawDisplacementDirectives(test.code))
+					declaration := fmt.Sprintf("func %s(%s)", name, arguments)
+					x86LEAActualTargetGoObject(t, target.goarch, target.triple, source)
+					// GP transfers ignore encoded W in 32-bit mode: these
+					// original KMOVQ bytes transfer 32 bits. K/memory Q
+					// transfers retain their independent 64-bit width.
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.goarch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("independently initialized original raw mask-move rejected", err)
+							}
+							for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								if arguments != "" {
+									bits := []int{8, 16, 32, 64}[index/5]
+									operation := "load"
+									if strings.Contains(test.name, "k to memory") {
+										operation = "store"
+									}
+									if !strings.Contains(body, fmt.Sprintf("%s volatile i%d", operation, bits)) {
+										t.Fatal("dead raw mask access lost its exact volatile width after optimization", operation, bits)
+									}
+								}
+								compileLLVMToObject(t, llc, target.triple, "raw-mask-move.ll", "raw-mask-move.o", body)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawMaskMoveWholeProducerIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, store := range []bool{false, true} {
+			code := []byte{0xc4, 0xe1, 0xf8, 0x90, 0x08} // KMOVQ 0(AX),K1.
+			if store {
+				code[3], code[4] = 0x91, 0x00 // KMOVQ K0,0(AX).
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVL $91,CX\nKMOVD CX,K0\n%s p+0(FP),AX\n%sRET\n",
+				word, move, x86RawDisplacementDirectives(code))
+			check := x86LegacyFloatReplayCheck(t, arch, source, "func Value(p *uint64)")
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original := file.Funcs[0]
+			ordinal := len(original.Instrs) - 2
+			for _, mutation := range []string{
+				"valid", "origin", "missing-replay", "producer", "opcode", "operand", "original-bytes", "snapshot",
+			} {
+				t.Run(fmt.Sprintf("%s/store=%t/%s", arch, store, mutation), func(t *testing.T) {
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					ins := &candidate.Instrs[ordinal]
+					switch mutation {
+					case "origin":
+						ins.x86SourceRaw = nil
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "opcode":
+						ins.Op = "KMOVW"
+					case "operand":
+						index := 0
+						if store {
+							index = 1
+						}
+						ins.Args[index].Mem.Off = 1
+					case "original-bytes", "snapshot":
+						replay := *original.x86RawReplay
+						if mutation == "original-bytes" {
+							replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+						} else {
+							replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+							replay.normalized[ordinal].Raw += " changed"
+						}
+						candidate.x86RawReplay = &replay
+					}
+					err := check(candidate)
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("initialized original mask source lost its native continuation", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited original raw mask source acquired native access", err)
+					}
+					if err := original.x86RawReplay.validate(original, arch); err != nil {
+						t.Fatal("mutation damaged the unchanged original producer", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_mask_vector_move.go b/amd64_raw_mask_vector_move.go
new file mode 100644
index 000000000..b9d7fdbc7
--- /dev/null
+++ b/amd64_raw_mask_vector_move.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import "fmt"
+
+type decodedX86MaskVectorMoveProperties struct {
+	op           Op
+	maskToVector bool
+}
+
+func decodedX86MaskVectorMoveOpcode(opcode byte, width64 bool) (decodedX86MaskVectorMoveProperties, bool) {
+	width := byte(0)
+	if width64 {
+		width = 1
+	}
+	properties := map[[2]byte]decodedX86MaskVectorMoveProperties{
+		{0x28, 0}: {op: "VPMOVM2B", maskToVector: true},
+		{0x28, 1}: {op: "VPMOVM2W", maskToVector: true},
+		{0x38, 0}: {op: "VPMOVM2D", maskToVector: true},
+		{0x38, 1}: {op: "VPMOVM2Q", maskToVector: true},
+		{0x29, 0}: {op: "VPMOVB2M"},
+		{0x29, 1}: {op: "VPMOVW2M"},
+		{0x39, 0}: {op: "VPMOVD2M"},
+		{0x39, 1}: {op: "VPMOVQ2M"},
+	}[[2]byte{opcode, width}]
+	return properties, properties.op != ""
+}
+
+// decodedX86MaskVectorMoveInstruction recognizes Go 1.27's complete
+// VPMOVM2{B,W,D,Q} and VPMOV{B,W,D,Q}2M family. These EVEX-only instructions
+// have register-only K/X/Y/Z forms and do not permit writemasking, zeroing, or
+// EVEX.b. Recover all vector registers and widths before the generic decoder.
+func decodedX86MaskVectorMoveInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	i := 0
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64, 0x65:
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto evex
+		}
+	}
+
+evex:
+	if mode != 32 && mode != 64 || len(code) < i+6 || code[i] != 0x62 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	if p0&0x0f != 2 || p1&3 != 2 {
+		return Instr{}, 0, false, nil
+	}
+	properties, recognized := decodedX86MaskVectorMoveOpcode(opcode, p1&0x80 != 0)
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("invalid EVEX prefix")
+	}
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if p2&0x97 != 0 {
+		return Instr{}, 0, true, fmt.Errorf("mask/vector moves do not support masking, zeroing, or EVEX.b")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	if modRM>>6 != 3 {
+		return Instr{}, 0, true, fmt.Errorf("mask/vector moves require register operands")
+	}
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	vectorNumber := 0
+	maskNumber := 0
+	if properties.maskToVector {
+		if xExt != 0 || bExt != 0 {
+			return Instr{}, 0, true, fmt.Errorf("K source register cannot be extended")
+		}
+		vectorNumber = int(modRM>>3&7) + rExt*8 + rHighExt*16
+		maskNumber = int(modRM & 7)
+	} else {
+		if rExt != 0 || rHighExt != 0 {
+			return Instr{}, 0, true, fmt.Errorf("K destination register cannot be extended")
+		}
+		vectorNumber = int(modRM&7) + bExt*8 + xExt*16
+		maskNumber = int(modRM >> 3 & 7)
+	}
+	if mode == 32 && vectorNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	vectorPrefix := [...]string{"X", "Y", "Z"}[vectorBits]
+	vector := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, vectorNumber))}
+	mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))}
+	args := []Operand{vector, mask}
+	if properties.maskToVector {
+		args[0], args[1] = args[1], args[0]
+	}
+	return Instr{Op: properties.op, Args: args, Raw: fmt.Sprintf("%s %s, %s", properties.op, args[0].String(), args[1].String())}, modRMIndex + 1, true, nil
+}
diff --git a/amd64_raw_mask_vector_move_test.go b/amd64_raw_mask_vector_move_test.go
new file mode 100644
index 000000000..3ef86ff7f
--- /dev/null
+++ b/amd64_raw_mask_vector_move_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type rawMaskVectorMoveSpec struct {
+	opcode       byte
+	width64      bool
+	op           Op
+	laneBits     int
+	maskToVector bool
+}
+
+var rawMaskVectorMoveSpecs = []rawMaskVectorMoveSpec{
+	{opcode: 0x28, op: "VPMOVM2B", laneBits: 8, maskToVector: true},
+	{opcode: 0x28, width64: true, op: "VPMOVM2W", laneBits: 16, maskToVector: true},
+	{opcode: 0x38, op: "VPMOVM2D", laneBits: 32, maskToVector: true},
+	{opcode: 0x38, width64: true, op: "VPMOVM2Q", laneBits: 64, maskToVector: true},
+	{opcode: 0x29, op: "VPMOVB2M", laneBits: 8},
+	{opcode: 0x29, width64: true, op: "VPMOVW2M", laneBits: 16},
+	{opcode: 0x39, op: "VPMOVD2M", laneBits: 32},
+	{opcode: 0x39, width64: true, op: "VPMOVQ2M", laneBits: 64},
+}
+
+func encodeX86EVEXMaskVectorMove(spec rawMaskVectorMoveSpec, vectorBits byte, vector, mask int) []byte {
+	p0 := byte(2)
+	regField, rmField := vector, mask
+	if spec.maskToVector {
+		p0 |= byte((1-(vector>>3)&1)<<7 | 1<<6 | 1<<5 | (1-(vector>>4)&1)<<4)
+	} else {
+		regField, rmField = mask, vector
+		p0 |= byte(1<<7 | (1-(vector>>4)&1)<<6 | (1-(vector>>3)&1)<<5 | 1<<4)
+	}
+	p1 := byte(15<<3 | 1<<2 | 2)
+	if spec.width64 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 1<<3)
+	modRM := byte(0xc0 | (regField&7)<<3 | rmField&7)
+	return []byte{0x62, p0, p1, p2, spec.opcode, modRM}
+}
+
+func TestDecodedX86EVEXMaskVectorMoveCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawMaskVectorMoveSpecs {
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+			for vector := 0; vector < 32; vector++ {
+				for mask := 0; mask < 8; mask++ {
+					code := encodeX86EVEXMaskVectorMove(spec, vectorBits, vector, mask)
+					got, length, ok, err := decodedX86MaskVectorMoveInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantArgs := []string{fmt.Sprintf("%s%d", prefix, vector), fmt.Sprintf("K%d", mask)}
+					if spec.maskToVector {
+						wantArgs[0], wantArgs[1] = wantArgs[1], wantArgs[0]
+					}
+					if got.Op != spec.op || len(got.Args) != 2 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] {
+						t.Fatalf("decode %x = %+v, want %s %s", code, got, spec.op, strings.Join(wantArgs, ", "))
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 6144 {
+		t.Fatalf("covered %d EVEX mask/vector move encodings, want 6144", count)
+	}
+}
+
+func TestDecodedX86EVEXMaskVectorMoveGoAndWeaviateEncodings(t *testing.T) {
+	tests := []struct {
+		code []byte
+		op   Op
+		args []string
+	}{
+		{code: []byte{0x62, 0x72, 0x7e, 0x48, 0x38, 0xc0}, op: "VPMOVM2D", args: []string{"K0", "Z8"}},
+		{code: []byte{0x62, 0x62, 0x7e, 0x08, 0x28, 0xd4}, op: "VPMOVM2B", args: []string{"K4", "X26"}},
+		{code: []byte{0x62, 0xd2, 0x7e, 0x48, 0x29, 0xc9}, op: "VPMOVB2M", args: []string{"Z9", "K1"}},
+		{code: []byte{0x62, 0x92, 0xfe, 0x28, 0x29, 0xe3}, op: "VPMOVW2M", args: []string{"Y27", "K4"}},
+	}
+	for _, test := range tests {
+		got, length, ok, err := decodedX86MaskVectorMoveInstruction(test.code, 64)
+		if err != nil || !ok || length != len(test.code) {
+			t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+		}
+		if got.Op != test.op || len(got.Args) != 2 || got.Args[0].String() != test.args[0] || got.Args[1].String() != test.args[1] {
+			t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+		}
+	}
+}
+
+func TestDecodedX86EVEXMaskVectorMoveInvalidForms(t *testing.T) {
+	spec := rawMaskVectorMoveSpecs[0]
+	base := encodeX86EVEXMaskVectorMove(spec, 0, 0, 0)
+	invalid := make([][]byte, 0, 9)
+	reservedVVVV := append([]byte(nil), base...)
+	reservedVVVV[2] &^= 0x08
+	reservedHighV := append([]byte(nil), base...)
+	reservedHighV[3] &^= 0x08
+	reservedLength := append([]byte(nil), base...)
+	reservedLength[3] |= 0x60
+	masking := append([]byte(nil), base...)
+	masking[3] |= 0x01
+	zeroing := append([]byte(nil), base...)
+	zeroing[3] |= 0x80
+	broadcast := append([]byte(nil), base...)
+	broadcast[3] |= 0x10
+	memory := append([]byte(nil), base...)
+	memory[5] &^= 0xc0
+	extendedKSource := append([]byte(nil), base...)
+	extendedKSource[1] &^= 0x20
+	vectorToMask := encodeX86EVEXMaskVectorMove(rawMaskVectorMoveSpecs[4], 0, 0, 0)
+	extendedKDestination := append([]byte(nil), vectorToMask...)
+	extendedKDestination[1] &^= 0x80
+	invalid = append(invalid, reservedVVVV, reservedHighV, reservedLength, masking, zeroing, broadcast, memory, extendedKSource, extendedKDestination)
+	for _, code := range invalid {
+		if _, _, ok, err := decodedX86MaskVectorMoveInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateRawEVEXMaskToVectorWeaviateBlockRegression(t *testing.T) {
+	const source = `TEXT rawMaskToVectorBlock(SB), $0-0
+	LONG $0x487e7262; WORD $0xc038
+	LONG $0x4875d162; WORD $0xc8fa
+	LONG $0x487e7262; WORD $0xc738
+	LONG $0x4875d162; WORD $0xc8fa
+	LONG $0x487e7262; WORD $0xc138
+	LONG $0x486dd162; WORD $0xd0fa
+	LONG $0x487e7262; WORD $0xc238
+	LONG $0x4865d162; WORD $0xd8fa
+	LONG $0x487e7262; WORD $0xc338
+	LONG $0x485dd162; WORD $0xe0fa
+	LONG $0x487e7262; WORD $0xc438
+	LONG $0x4855d162; WORD $0xe8fa
+	LONG $0x487e7262; WORD $0xc538
+	LONG $0x484dd162; WORD $0xf0fa
+	LONG $0x487e7262; WORD $0xc638
+	LONG $0x4845d162; WORD $0xf8fa
+	RET
+`
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if strings.Count(ir, "select i1") < 8*16 {
+		t.Fatalf("raw VPMOVM2D block omitted mask expansion:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-mask-to-vector.ll", "amd64-raw-mask-to-vector.o", ir)
+}
diff --git a/amd64_raw_memory_decoder.go b/amd64_raw_memory_decoder.go
new file mode 100644
index 000000000..b10327232
--- /dev/null
+++ b/amd64_raw_memory_decoder.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+// The zero value retains the raw source decoder's layout restrictions. Only
+// original native byte observers select physicalPC: they observe whole native
+// instruction boundaries and discards these operands. A physical RIP+disp32
+// is not a source symbol, bounded literal, numerical value, or read permission.
+type x86RawMemoryDecoder struct {
+	physicalPC bool
+}
+
+func (d x86RawMemoryDecoder) vexTransfer(code []byte, mode, bExt, xExt int, segment Reg, vector bool) (Operand, int, error) {
+	if len(code) == 0 || code[0]>>6 == 3 || !d.physicalPC {
+		return decodedX86VEXRMOperand(code, mode, bExt, xExt, segment, vector)
+	}
+	return decodedX86RMSourceWithPC(code, mode, bExt, xExt, segment, 1, true)
+}
+
+func (d x86RawMemoryDecoder) scalar(code []byte, mode, bExt, xExt int, segment Reg, width int) (Operand, int, error) {
+	return decodedX86RMSourceWithPC(code, mode, bExt, xExt, segment, width, d.physicalPC)
+}
+
+func (d x86RawMemoryDecoder) evex(code []byte, mode, bExt, xExt int, segment Reg, bank string, scale int) (Operand, int, error) {
+	if len(code) == 0 || code[0]>>6 == 3 {
+		return decodedX86EVEXRMOperand(code, mode, bExt, xExt, segment, bank, scale)
+	}
+	return decodedX86RMSourceWithPC(code, mode, bExt, xExt, segment, scale, d.physicalPC)
+}
+
+func (d x86RawMemoryDecoder) vex(code []byte, mode, bExt, xExt int, segment Reg, bank string) (Operand, int, error) {
+	if len(code) == 0 || code[0]>>6 == 3 {
+		return decodedX86VEXVectorRMOperand(code, mode, bExt, xExt, segment, bank)
+	}
+	return decodedX86RMSourceWithPC(code, mode, bExt, xExt, segment, 1, d.physicalPC)
+}
diff --git a/amd64_raw_minmax.go b/amd64_raw_minmax.go
new file mode 100644
index 000000000..b542ec229
--- /dev/null
+++ b/amd64_raw_minmax.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+// VEX B/W/D ignores W. EVEX B/W also ignores W; D/Q shares an opcode with
+// fixed W0/W1, and Q has no VEX encoding. The remaining operand grammar is
+// shared with per-lane shifts, not inferred from the legacy disassembler.
+func decodedX86PackedIntegerMinMaxInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedIntegerMinMaxInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedIntegerMinMaxInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched {
+		return Instr{}, 0, false, nil
+	}
+
+	for name, spec := range amd64PackedIntegerMinMaxSpecs {
+		if p.mapNumber != spec.mapNumber || p.opcode != spec.opcode {
+			continue
+		}
+		if !p.evex && spec.laneBits == 64 {
+			continue
+		}
+		if p.evex && spec.laneBits >= 32 && p.w != (spec.laneBits == 64) {
+			continue
+		}
+
+		return decodedX86BinaryVectorOperandsWithMemory(code, p, mode, Op(name), spec.laneBits, memory)
+	}
+	return Instr{}, 0, false, nil
+}
diff --git a/amd64_raw_minmax_literal_test.go b/amd64_raw_minmax_literal_test.go
new file mode 100644
index 000000000..ee8e40587
--- /dev/null
+++ b/amd64_raw_minmax_literal_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawMinMaxLiteral(op string, evex bool, width, mask int, zeroing, broadcast bool) []byte {
+	spec := amd64PackedIntegerMinMaxSpecs[op]
+	code := encodeRawScalarMove(evex, 1, spec.opcode, 0, 0, 0, mask, zeroing)
+	code[1] = code[1]&0xf0 | byte(spec.mapNumber)
+	code[2] &^= 0x80
+	if spec.laneBits == 64 {
+		code[2] |= 0x80
+	}
+	if evex {
+		code[3] |= byte(map[int]int{16: 0, 32: 1, 64: 2}[width]) << 5
+		if broadcast {
+			code[3] |= 0x10
+		}
+	} else if width == 32 {
+		code[2] |= 0x04
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = spec.laneBits / 8
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*13+9))
+	}
+	return code
+}
+
+func TestDecodeX86RawMinMaxRIPDataCompleteFamily(t *testing.T) {
+	for _, op := range x86MinMaxTestOps {
+		spec := amd64PackedIntegerMinMaxSpecs[op]
+		for _, evex := range []bool{false, true} {
+			if !evex && spec.laneBits == 64 {
+				continue
+			}
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				broadcasts := []bool{false}
+				if evex && spec.broadcast {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					mask, zeroing := 0, false
+					if evex {
+						mask, zeroing = 7, true
+					}
+					name := fmt.Sprintf("%s/evex%t/%d/bcst%t", op, evex, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawMinMaxLiteral(op, evex, width, mask, zeroing, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := Op(op)
+						if broadcast {
+							want += ".BCST"
+						}
+						if zeroing {
+							want += ".Z"
+						}
+						if len(decoded) != 2 || decoded[0].Op != want ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawMinMaxRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawMinMaxLiteral("VPMINSD", true, 64, 7, true, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawMinMaxRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	var pools [][]byte
+	for index, op := range x86MinMaxTestOps {
+		spec := amd64PackedIntegerMinMaxSpecs[op]
+		evex := spec.laneBits == 64
+		width := 32
+		if evex {
+			width = 64
+		}
+		broadcast := evex && spec.broadcast
+		mask, zeroing := 0, false
+		if evex {
+			mask, zeroing = 7, true
+		}
+		code := x86RawMinMaxLiteral(op, evex, width, mask, zeroing, broadcast)
+		name := fmt.Sprintf("minMaxLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		dataWidth := width
+		if broadcast {
+			dataWidth = spec.laneBits / 8
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "minmax-literal.ll", "minmax-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_minmax_test.go b/amd64_raw_minmax_test.go
new file mode 100644
index 000000000..aa49e0ef2
--- /dev/null
+++ b/amd64_raw_minmax_test.go
@@ -0,0 +1,435 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86MinMaxTestOps = []string{
+	"VPMINSB", "VPMINUB", "VPMAXSB", "VPMAXUB",
+	"VPMINSW", "VPMINUW", "VPMAXSW", "VPMAXUW",
+	"VPMINSD", "VPMINUD", "VPMAXSD", "VPMAXUD",
+	"VPMINSQ", "VPMINUQ", "VPMAXSQ", "VPMAXUQ",
+}
+
+func TestX86MinMaxGrammarMatchesGoEncoder(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pattern := `(?s)\{as: A(VPM(?:IN|AX)[SU][BWDQ]), ytab: (\w+), prefix: Pavx, op: opBytes\{(.*?)\}\}`
+	rows := regexp.MustCompile(pattern).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 16 || len(amd64PackedIntegerMinMaxSpecs) != len(rows) {
+		t.Fatalf("Go family=%d, typed family=%d", len(rows), len(amd64PackedIntegerMinMaxSpecs))
+	}
+
+	for _, row := range rows {
+		spec, ok := amd64PackedIntegerMinMaxSpecs[row[1]]
+		if !ok {
+			t.Fatalf("missing %s", row[1])
+		}
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[row[1][len(row[1])-1]]
+		if spec.laneBits != bits || spec.signed != (row[1][5] == 'S') || spec.minimum != strings.HasPrefix(row[1], "VPMIN") {
+			t.Fatalf("incorrect typed semantics for %s: %+v", row[1], spec)
+		}
+		if (row[2] == "_yvandnpd") != (bits != 64) || strings.Contains(row[3], "| vex128") != (bits != 64) {
+			t.Fatalf("incorrect encoding generation for %s", row[1])
+		}
+		if strings.Contains(row[3], "0F38") != (spec.mapNumber == 2) || strings.Contains(row[3], "evexBcst") != spec.broadcast {
+			t.Fatalf("incorrect map/broadcast for %s", row[1])
+		}
+		opcodes := regexp.MustCompile(`0x[0-9A-F]+`).FindAllString(row[3], -1)
+		wantRows := 5
+		if bits == 64 {
+			wantRows = 3
+		}
+		if len(opcodes) != wantRows {
+			t.Fatalf("%s has %d encodings, want %d", row[1], len(opcodes), wantRows)
+		}
+		for _, opcode := range opcodes {
+			if opcode != fmt.Sprintf("0x%X", spec.opcode) {
+				t.Fatalf("%s opcode=%s, typed=%x", row[1], opcode, spec.opcode)
+			}
+		}
+	}
+
+	operandTables := map[string][]string{
+		"_yvandnpd": {
+			"Yxm, Yxr, Yxr", "Yym, Yyr, Yyr",
+			"YxmEvex, YxrEvex, YxrEvex", "YxmEvex, YxrEvex, Yknot0, YxrEvex",
+			"YymEvex, YyrEvex, YyrEvex", "YymEvex, YyrEvex, Yknot0, YyrEvex",
+			"Yzm, Yzr, Yzr", "Yzm, Yzr, Yknot0, Yzr",
+		},
+		"_yvblendmpd": {
+			"YxmEvex, YxrEvex, YxrEvex", "YxmEvex, YxrEvex, Yknot0, YxrEvex",
+			"YymEvex, YyrEvex, YyrEvex", "YymEvex, YyrEvex, Yknot0, YyrEvex",
+			"Yzm, Yzr, Yzr", "Yzm, Yzr, Yknot0, Yzr",
+		},
+	}
+	for name, want := range operandTables {
+		pattern := `(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`
+		table := regexp.MustCompile(pattern).FindStringSubmatch(string(data))
+		if len(table) != 2 {
+			t.Fatal("missing Go operand table", name)
+		}
+		args := regexp.MustCompile(`argList\{([^}]+)\}`).FindAllStringSubmatch(table[1], -1)
+		var got []string
+		for _, arg := range args {
+			got = append(got, arg[1])
+		}
+		if !reflect.DeepEqual(got, want) {
+			t.Fatalf("Go %s rows=%v, want %v", name, got, want)
+		}
+	}
+}
+
+func TestX86MinMaxGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86MinMaxTestOps {
+			lines := []string{
+				op + " X0,Y1,Y2",
+				op + " X0,X1,(AX)",
+				op + ".Z X0,X1,X2",
+				op + ".SAE X0,X1,X2",
+				op + " X0,X1,K0,X2",
+				op + ".BCST X0,X1,X2",
+				op + ".Z.BCST (AX),X1,K1,X2",
+				op + " $1,X1,X2",
+			}
+			if strings.HasSuffix(op, "B") || strings.HasSuffix(op, "W") {
+				lines = append(lines, op+".BCST (AX),X1,X2")
+			}
+			if arch == "386" {
+				lines = append(lines, op+" Z8,Z0,Z1", op+" X0,X1,K1,X2")
+			}
+
+			for _, line := range lines {
+				dir := t.TempDir()
+				path := filepath.Join(dir, "invalid.s")
+				source := "TEXT bad(SB),4,$0-0\n" + line + "\nRET\n"
+				if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), path)
+				cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+				out, err := cmd.CombinedOutput()
+				historicalZero := strings.HasPrefix(runtime.Version(), "go1.20") && strings.Contains(line, ".Z X0")
+				if historicalZero && err != nil || !historicalZero && err == nil {
+					t.Fatalf("Go %s unexpected result for %s: %v %s", arch, line, err, out)
+				}
+
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				assertX86PackedIntegerMinMaxRejected(t, arch, triple, line)
+			}
+		}
+	}
+}
+
+func TestX86MinMaxZeroMaskDoesNotAccessMemory(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable values require the native 64-bit host counterpart")
+	}
+
+	const original = `TEXT zero_mask(SB),4,$0-24
+MOVQ source+0(FP), AX
+MOVQ out+8(FP), DI
+KMOVQ mask+16(FP), K1
+VPMINUD (AX), Y0, K1, Y1
+VMOVUPS Y1, (DI)
+RET
+`
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", original)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, original,
+			"func zero_mask(source,out *byte,mask uint64)", "amd64", triple, api)
+		x86VectorScratchCodegenControl(t, original, "func zero_mask(source,out *byte,mask uint64)",
+			"amd64", triple, ir, err)
+	}
+	// Keep the original source above. This separate initialized program owns
+	// the actual masked-off NULL read, not an invented incoming Y0/Y1 value.
+	initialized := strings.Replace(original, "zero_mask(SB)", "zero_mask_initialized(SB)", 1)
+	initialized = strings.Replace(initialized, "KMOVQ mask", "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nKMOVQ mask", 1)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", initialized)
+	ir, err := x86ScalarFPBitViewAPI(t, initialized,
+		"func zero_mask_initialized(source,out *byte,mask uint64)", "amd64", triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mainC := `
+#include <stddef.h>
+#include <stdint.h>
+
+extern void zero_mask(const void *source, void *out, uint64_t mask);
+
+int main(void) {
+    uint8_t out[32];
+    zero_mask(NULL, out, 0);
+    return 0;
+}
+`
+	mainC = strings.ReplaceAll(mainC, "zero_mask", "zero_mask_initialized")
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "minmax_zero_mask_initialized", triple, ir, mainC)
+}
+
+func TestX86RawMinMaxEncodingFields(t *testing.T) {
+	// The shared operand decoder already has the exhaustive shift-register
+	// product test. Here each min/max member checks every register field and
+	// W interpretation independently, without repeating that product 16 times.
+	opcodes := map[string]byte{
+		"VPMINSB": 0x38, "VPMINUB": 0xda, "VPMAXSB": 0x3c, "VPMAXUB": 0xde,
+		"VPMINSW": 0xea, "VPMINUW": 0x3a, "VPMAXSW": 0xee, "VPMAXUW": 0x3e,
+		"VPMINSD": 0x39, "VPMINUD": 0x3b, "VPMAXSD": 0x3d, "VPMAXUD": 0x3f,
+		"VPMINSQ": 0x39, "VPMINUQ": 0x3b, "VPMAXSQ": 0x3d, "VPMAXUQ": 0x3f,
+	}
+	count := 0
+	for _, op := range x86MinMaxTestOps {
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		mapNumber := byte(2)
+		if op == "VPMINUB" || op == "VPMAXUB" || op == "VPMINSW" || op == "VPMAXSW" {
+			mapNumber = 1
+		}
+		for _, evex := range []bool{false, true} {
+			if !evex && bits == 64 {
+				continue
+			}
+			limit, widths := 16, 2
+			if evex {
+				limit, widths = 32, 3
+			}
+			for width := 0; width < widths; width++ {
+				for axis := 0; axis < 3; axis++ {
+					for register := 0; register < limit; register++ {
+						regs := [3]int{0, 1, 2} // source2, source1, destination.
+						regs[axis] = register
+						variants := 1
+						if !evex || bits < 32 {
+							variants = 2
+						}
+						for variant := 0; variant < variants; variant++ {
+							mask, zero := 0, false
+							if evex {
+								mask = register % 8
+								zero = mask != 0 && register&1 != 0
+							}
+							code := encodeRawScalarMove(evex, 1, 0, regs[0], regs[1], regs[2], mask, zero)
+							code[len(code)-2] = opcodes[op]
+							code[1] = code[1]&0xf0 | mapNumber
+							code[2] &^= 0x80
+							if variant != 0 || bits == 64 {
+								code[2] |= 0x80
+							}
+							if evex {
+								code[3] |= byte(width) << 5
+							} else {
+								code[2] |= byte(width) << 2
+							}
+
+							prefix := []string{"X", "Y", "Z"}[width]
+							args := []Operand{
+								{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, regs[0]))},
+								{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, regs[1]))},
+							}
+							if mask != 0 {
+								args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+							}
+							args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, regs[2]))})
+							wantOp := Op(op)
+							if zero {
+								wantOp += ".Z"
+							}
+
+							got, size, matched, err := decodedX86PackedIntegerMinMaxInstruction(code, 64)
+							if err != nil || !matched || size != len(code) || got.Op != wantOp || !reflect.DeepEqual(got.Args, args) {
+								t.Fatalf("decode %x: %+v %d %v %v; want %s %+v", code, got, size, matched, err, wantOp, args)
+							}
+							_, _, matched, err = decodedX86PackedIntegerMinMaxInstruction(code, 32)
+							if !matched || (err != nil) != (register >= 8) {
+								t.Fatalf("386 decode %x: matched=%v err=%v", code, matched, err)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 9216 {
+		t.Fatalf("covered %d field cases, want 9216", count)
+	}
+}
+
+func TestX86RawMinMax386MaskedObjects(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT masked_minmax(SB),4,$0-0\n")
+	for _, op := range x86MinMaxTestOps {
+		for _, width := range []string{"X", "Y", "Z"} {
+			for _, input := range []string{width + "0", "(AX)"} {
+				for _, suffix := range []string{"", ".Z"} {
+					line := fmt.Sprintf("%s%s %s,%s1,K7,%s2", op, suffix, input, width, width)
+					emitX86GoEncodedTestInstruction(t, &source, line, true)
+				}
+			}
+			if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+				line := fmt.Sprintf("%s.BCST.Z (AX),%s1,K7,%s2", op, width, width)
+				emitX86GoEncodedTestInstruction(t, &source, line, true)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "386", triple)
+		compileLLVMToObject(t, llc, triple, "masked-minmax-386.ll", "masked-minmax-386.o", ir)
+	}
+}
+
+func TestX86RawMinMaxGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			last := 7
+			if arch == "amd64" {
+				last = 31
+			}
+
+			var source strings.Builder
+			source.WriteString("TEXT minmax(SB),4,$0-0\n")
+			for _, op := range x86MinMaxTestOps {
+				broadcast := strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q")
+				for _, width := range []string{"X", "Y", "Z"} {
+					for _, reg := range []int{0, last} {
+						inputs := []string{
+							fmt.Sprintf("%s%d", width, last-reg),
+							"(AX)", "-7(BX)(CX*4)", "64(SI)", "8192(DI)",
+						}
+						for _, input := range inputs {
+							fmt.Fprintf(&source, "%s %s,%s%d,%s%d\n", op, input, width, reg, width, last-reg)
+							if arch == "amd64" {
+								fmt.Fprintf(&source, "%s %s,%s%d,K1,%s%d\n", op, input, width, reg, width, last-reg)
+								fmt.Fprintf(&source, "%s.Z %s,%s%d,K7,%s%d\n", op, input, width, reg, width, last-reg)
+							}
+						}
+						if broadcast {
+							fmt.Fprintf(&source, "%s.BCST -8(BX)(CX*4),%s%d,%s%d\n", op, width, reg, width, last-reg)
+							if arch == "amd64" {
+								fmt.Fprintf(&source, "%s.BCST.Z 64(SI),%s%d,K7,%s%d\n", op, width, reg, width, last-reg)
+							}
+						}
+					}
+					if width != "Z" {
+						fmt.Fprintf(&source, "%s %s0,%s1,%s2\n", op, width, width, width)
+						fmt.Fprintf(&source, "%s (AX),%s1,%s2\n", op, width, width)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+
+			code := assembleX87ControlBytes(t, arch, source.String())
+			got, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(got.Instrs) != len(want) {
+				t.Fatalf("got %d instructions, want %d", len(got.Instrs), len(want))
+			}
+			for i, instruction := range got.Instrs {
+				if instruction.Op != want[i].Op || !reflect.DeepEqual(instruction.Args, want[i].Args) {
+					t.Fatalf("instruction %d: %+v, want %+v", i, instruction, want[i])
+				}
+			}
+
+			file := x86RawUnprovedReturnFormProbeFile(t, arch, "minmax", code)
+			targets := []string{
+				"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+				"i386-unknown-linux-gnu", "i686-pc-windows-msvc",
+			}
+			for _, triple := range targets {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "minmax.ll", "minmax.o", ir)
+			}
+			t.Logf("%s: %d actual Go encodings", arch, len(want)-1)
+		})
+	}
+}
+
+func TestX86RawMinMaxInvalidAndMemoryForms(t *testing.T) {
+	invalid := [][]byte{
+		{0x62, 0xf2, 0x71, 0x0b, 0x39, 0xe0}, // EVEX fixed bit clear.
+		{0x62, 0xf2, 0x75, 0x6b, 0x39, 0xe0}, // Reserved vector length.
+		{0x62, 0xf2, 0x75, 0x88, 0x39, 0xe0}, // Zeroing without mask.
+		{0x62, 0xf2, 0x75, 0x1b, 0x39, 0xe0}, // Register broadcast.
+		{0x62, 0xf2, 0x75, 0x1b, 0x38, 0x00}, // Byte broadcast.
+		{0x62, 0xf2, 0x74, 0x0b, 0x39, 0xe0}, // Wrong mandatory prefix.
+		{0x62, 0xf2, 0x75, 0x0b, 0x39},       // Missing ModRM.
+		{0x62, 0xf2, 0x75, 0x0b, 0x39, 0x04}, // Missing SIB.
+		{0x62, 0xf2, 0x75, 0x0b, 0x39, 0x40}, // Missing disp8.
+		{0x67, 0xc5, 0xf1, 0xda, 0xc0},       // Address-size override.
+		{0xc5, 0xf1, 0xda, 0x05, 0, 0, 0, 0}, // Unrelocated RIP source.
+	}
+	for _, code := range invalid {
+		_, _, matched, err := decodedX86PackedIntegerMinMaxInstruction(code, 64)
+		if !matched || err == nil {
+			t.Fatalf("accepted invalid %x", code)
+		}
+	}
+	if _, _, matched, err := decodedX86PackedIntegerMinMaxInstruction([]byte{0xc5, 0xf1, 0xda, 0xc0}, 16); !matched || err == nil {
+		t.Fatal("accepted 16-bit mode")
+	}
+	for _, code := range [][]byte{nil, {0x62}, {0x90}, {0xc4, 0xe3, 0x79, 0x39, 0xc0}, {0xc4, 0xe2, 0x79, 0x40, 0xc0}} {
+		if _, _, matched, err := decodedX86PackedIntegerMinMaxInstruction(code, 64); matched || err != nil {
+			t.Fatalf("claimed unrelated %x", code)
+		}
+	}
+
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		for _, broadcast := range []bool{false, true} {
+			code := []byte{segment.prefix, 0x62, 0x92, 0xf5, 0xcb, 0x39, 0x64, 0x88, 0xfe}
+			offset, op := int64(-128), Op("VPMINSQ.Z")
+			if broadcast {
+				code[4] |= 0x10
+				offset, op = -16, "VPMINSQ.BCST.Z"
+			}
+			got, size, matched, err := decodedX86PackedIntegerMinMaxInstruction(code, 64)
+			want := MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: offset}
+			if err != nil || !matched || size != len(code) || got.Op != op || !reflect.DeepEqual(got.Args[0].Mem, want) {
+				t.Fatalf("decode %x: %+v, err=%v", code, got, err)
+			}
+		}
+	}
+}
diff --git a/amd64_raw_minpos.go b/amd64_raw_minpos.go
new file mode 100644
index 000000000..32455ed50
--- /dev/null
+++ b/amd64_raw_minpos.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import "fmt"
+
+// Intel XED's AVX table specifies VL128, V66, V0F38 and NOVSR; W is ignored.
+// There are no Y/Z, EVEX, mask, immediate or three-operand forms.
+func decodedX86MinimumPositionInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	spec := amd64MinimumPositionSpecs["VPHMINPOSUW"]
+	if !matched || p.mapNumber != spec.mapNumber || p.opcode != spec.opcode {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("minimum position: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.vectorLength != 0 || p.pp != 1 || p.upper != 0 {
+		return fail("requires VEX.128.66 with reserved vvvv")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.x != 0 || p.b != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	source, size, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	dst := Reg(fmt.Sprintf("X%d", int(code[p.modRM]>>3&7)+p.r*8))
+	return Instr{
+		Op:   "VPHMINPOSUW",
+		Args: []Operand{source, {Kind: OpReg, Reg: dst}},
+		Raw:  fmt.Sprintf("VPHMINPOSUW %s, %s", source.String(), dst),
+	}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_minpos_address_test.go b/amd64_raw_minpos_address_test.go
new file mode 100644
index 000000000..009fcfdf1
--- /dev/null
+++ b/amd64_raw_minpos_address_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func x86MinimumPositionOriginalGoBytes(t *testing.T, arch, source string) []byte {
+	t.Helper()
+	listing, err := x86ScalarLiteralGoListing(t, arch, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var code []byte
+	for _, line := range strings.Split(listing, "\n") {
+		text := strings.TrimLeft(line, "\t ")
+		fields := strings.Fields(text)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		start := strings.IndexByte(text, ' ')
+		if err != nil || int(offset) != len(code) || start < 0 || len(text) < start+48 {
+			t.Fatalf("incomplete/noncontiguous stock Go hex row: %s", line)
+		}
+		gap := false
+		for column := 0; column < 16; column++ {
+			field := text[start+3*column : start+3*(column+1)]
+			if field == "   " {
+				gap = true
+				continue
+			}
+			value, err := strconv.ParseUint(field[1:], 16, 8)
+			if gap || field[0] != ' ' || err != nil {
+				t.Fatalf("invalid stock Go hex column: %q", field)
+			}
+			code = append(code, byte(value))
+		}
+	}
+	if len(code) == 0 {
+		t.Fatal("stock Go omitted the original instruction bytes")
+	}
+	return code
+}
+
+func TestX86RawMinimumPositionInactiveSIBScalePhysicalWitness(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for shift := byte(0); shift < 4; shift++ {
+			// Original legacy PHMINPOSUW 8192(SP),X0. SIB.index=4
+			// suppresses the index; all four scale bit patterns are ignored.
+			code := []byte{0x66, 0x0f, 0x38, 0x41, 0x84, 0x24 | shift<<6, 0, 0x20, 0, 0}
+			original := append([]byte(nil), code...)
+			x86HandoffOriginalBytes(t, arch, code)
+			physical, err := x86asm.Decode(code, mode)
+			memory, ok := physical.Args[1].(x86asm.Mem)
+			base := x86asm.RSP
+			if mode == 32 {
+				base = x86asm.ESP
+			}
+			if err != nil || physical.Len != len(code) || physical.Op != x86asm.PHMINPOSUW ||
+				!ok || memory.Base != base || memory.Index != 0 || memory.Scale != 1<<shift || memory.Disp != 8192 {
+				t.Fatalf("independent full SIB witness: %+v %v", physical, err)
+			}
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			want := Operand{Kind: OpMem, Mem: MemRef{Base: SP, Scale: 1 << shift, Off: 8192}}
+			if err != nil || len(decoded.Instrs) != 1 || len(decoded.Instrs[0].Args) != 2 ||
+				!reflect.DeepEqual(decoded.Instrs[0].Args[0], want) {
+				t.Fatalf("decoder discarded its physical SIB metadata: %+v %v", decoded, err)
+			}
+			if !bytes.Equal(code, original) {
+				t.Fatal("physical witness modified its original instruction bytes")
+			}
+		}
+	}
+}
+
+func x86MinimumPositionAddressSources(arch, name, terminal string) (complete, bounded string, completeCount, boundedCount int) {
+	registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+	if arch == "amd64" {
+		for i := 8; i < 16; i++ {
+			registers = append(registers, fmt.Sprintf("R%d", i))
+		}
+	}
+	var addresses, objectAddresses []string
+	for _, base := range registers {
+		for _, offset := range []int64{0, -128, 127, -129, 128, 8192, -2147483648, 2147483647} {
+			addresses = append(addresses, fmt.Sprintf("%d(%s)", offset, base))
+		}
+		// Both extreme SP offsets belong to the Go encoding domain. Their
+		// combined synthetic allocation exceeds 4 GiB, separately observed
+		// below. Declare the finite LLVM object domain before translation;
+		// never infer it from llc success. Other GP disp32 extremes remain.
+		objectOffsets := []int64{0, -128, 127, -129, 128, 8192}
+		if base != "SP" {
+			objectOffsets = append(objectOffsets, -2147483648, 2147483647)
+		}
+		for _, offset := range objectOffsets {
+			objectAddresses = append(objectAddresses, fmt.Sprintf("%d(%s)", offset, base))
+		}
+	}
+	for _, index := range registers {
+		if index == "SP" {
+			continue // SIB.index=4 is the absent-index witness above.
+		}
+		for _, scale := range []int{1, 2, 4, 8} {
+			indexed := []string{fmt.Sprintf("-7(BP)(%s*%d)", index, scale), fmt.Sprintf("8192(%s*%d)", index, scale)}
+			addresses = append(addresses, indexed...)
+			objectAddresses = append(objectAddresses, indexed...)
+		}
+	}
+	build := func(addresses []string) string {
+		var source strings.Builder
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", name)
+		for _, op := range []string{"PHMINPOSUW", "VPHMINPOSUW"} {
+			for _, address := range addresses {
+				fmt.Fprintf(&source, "%s %s,X0\n", op, address)
+			}
+		}
+		fmt.Fprintln(&source, terminal)
+		return source.String()
+	}
+	return build(addresses), build(objectAddresses), 2 * len(addresses), 2 * len(objectAddresses)
+}
+
+func TestX86RawMinimumPositionGoAddressFormsAllAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, objectSource, completeCount, boundedCount := x86MinimumPositionAddressSources(arch, "addresses", "RET")
+			code := x86MinimumPositionOriginalGoBytes(t, arch, source)
+			parsed, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil || len(decoded.Instrs) != len(parsed.Funcs[0].Instrs)-1 {
+				t.Fatalf("complete original instruction sequence: %+v %v", decoded, err)
+			}
+			for i, instruction := range decoded.Instrs {
+				want := parsed.Funcs[0].Instrs[i+1]
+				if instruction.Op != want.Op || !x86RawOperandsMatchGoSource(instruction.Args, want.Args) {
+					t.Fatalf("original Go address %d %s: physical=%#v source=%#v", i, want.Raw, instruction.Args, want.Args)
+				}
+			}
+			objectCode := x86MinimumPositionOriginalGoBytes(t, arch, objectSource)
+			file := x86RawStackObservingFormProbeFile(t, arch, "addresses", objectCode)
+			before := fmt.Sprintf("%#v", file.Funcs)
+			for _, target := range x86RawReturnTargets {
+				if target.arch != arch {
+					continue
+				}
+				t.Run(target.triple, func(t *testing.T) {
+					// The helper first checks the complete Go object and all
+					// three public Context APIs, then emits a private format unit.
+					ir := x86UnboundBlendMinposProbeObject(t, file, arch, target.triple)
+					if before != fmt.Sprintf("%#v", file.Funcs) {
+						t.Fatal("public translation changed its original raw source")
+					}
+					compileLLVMToObject(t, llc, target.triple, "addresses.ll", "addresses.o", ir)
+				})
+			}
+			t.Logf("actual Go address encodings=%d; bounded LLVM probe encodings=%d; original SP extremes remain an allocator limitation, not N/A or native stack/return permission", completeCount, boundedCount)
+		})
+	}
+}
diff --git a/amd64_raw_minpos_allocator_boundary_test.go b/amd64_raw_minpos_allocator_boundary_test.go
new file mode 100644
index 000000000..eaa9f86ad
--- /dev/null
+++ b/amd64_raw_minpos_allocator_boundary_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are explicit observations of an unresolved synthetic allocation, not
+// successful stack semantics, source rejection, native bounds or runtime tests.
+// Both original Go sources are legal, but lack a bounded initialized AUTO or
+// native stack role and therefore retain public Context. A private format unit
+// still observes the original >4 GiB synthetic allocator: llc O0 rejects its
+// frame offsets. This is neither public success nor native stack permission.
+func TestX86RawMinimumPositionHugeSPAllocatorBoundaryObservation(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Keep the complete mode32 address inventory in both source forms. The
+	// original encoded RET remains a negative stack/continuation control;
+	// the raw compile-only probe replaces only that RET with encoded UD2.
+	source, _, count, _ := x86MinimumPositionAddressSources("386", "giant", "UD2")
+	if count != 240 {
+		t.Fatalf("complete mode32 address denominator changed: %d", count)
+	}
+	namedCode := x86MinimumPositionOriginalGoBytes(t, "386", source)
+	namedFile, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rawSource, _, _, _ := x86MinimumPositionAddressSources("386", "giant", "RET")
+	rawCode := x86MinimumPositionOriginalGoBytes(t, "386", rawSource)
+	x86UnboundVoidFormatSources(t, "TEXT giant(SB),4,$0-0\n"+x86DwordProductDirectives(rawCode),
+		"386", "i386-unknown-linux-gnu")
+	rawFile := x86RawStackObservingFormProbeFile(t, "386", "giant", rawCode)
+	for _, fixture := range []struct {
+		name   string
+		file   *File
+		source string
+		code   []byte
+	}{
+		{"named", namedFile, source, namedCode},
+		{"original-byte-probe", rawFile, rawSource, rawCode},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			file := fixture.file
+			before := fmt.Sprintf("%#v", file.Funcs)
+			for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				// The same complete 240-row typed emitter remains an explicit
+				// private allocation diagnostic, with no cached input proof.
+				privateIR := x86UnboundBlendMinposProbeObject(t, file, "386", triple)
+				if !strings.Contains(privateIR, "%local_stack = alloca [4294967439 x i8]") {
+					t.Fatal("private allocator lost the complete original SP envelope")
+				}
+				for _, api := range []string{"text", "module", "context"} {
+					t.Run(triple+"/"+api, func(t *testing.T) {
+						options := Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"giant": {Name: "giant", Ret: Void}}}
+						var ir string
+						var err error
+						switch api {
+						case "text":
+							ir, err = Translate(file, options)
+						case "module":
+							module, callErr := TranslateModule(file, options)
+							err = callErr
+							if !module.IsNil() {
+								defer module.Dispose()
+								ir = module.String()
+							}
+						case "context":
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							module, callErr := TranslateModuleInContext(ctx, file, options)
+							err = callErr
+							if !module.IsNil() {
+								defer module.Dispose()
+								ir = module.String()
+							}
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || before != fmt.Sprintf("%#v", file.Funcs) {
+							t.Fatalf("unbound source acquired a public AUTO/stack role: %v; complete source unchanged=%t", err, before == fmt.Sprintf("%#v", file.Funcs))
+						}
+						// The exact private source envelope is [-2^31, 2^31-1+16),
+						// plus the original two 64-byte synthetic guards. Reusing
+						// this private IR is not an API translation certificate.
+						dir := t.TempDir()
+						input, object := filepath.Join(dir, "giant.ll"), filepath.Join(dir, "giant.o")
+						if err := os.WriteFile(input, []byte(privateIR), 0600); err != nil {
+							t.Fatal(err)
+						}
+						ctx, cancel := runtimeOracleStageContext(t)
+						defer cancel()
+						command := exec.CommandContext(ctx, llc, "-O0", "-filetype=obj", "-mtriple="+triple, "-o", object, input)
+						output, err := runtimeOracleCombinedOutput(ctx, command)
+						if ctx.Err() != nil {
+							t.Fatalf("bounded compiler observation expired: %v: %s", err, output)
+						}
+						exit, ordinaryExit := err.(*exec.ExitError)
+						if !ordinaryExit || exit.ExitCode() != 1 {
+							t.Fatalf("expected plain LLVM32 O0 offset failure, got %v: %s", err, output)
+						}
+						diagnostic := "error: <unknown>:0:0: 64-bit offset calculated but target is 32-bit"
+						warning := regexp.MustCompile(`^warning: <unknown>:0:0: stack frame size \(([0-9]+)\) exceeds limit \(4294967295\) in function 'InstructionFormat0'$`)
+						errors, warnings := 0, 0
+						text := strings.ReplaceAll(string(output), "\r\n", "\n")
+						if strings.Contains(text, "\r") {
+							t.Fatalf("malformed diagnostic line endings: %q", output)
+						}
+						for _, line := range strings.Split(strings.TrimSpace(text), "\n") {
+							if line == diagnostic {
+								errors++
+								continue
+							}
+							match := warning.FindStringSubmatch(line)
+							if len(match) != 2 {
+								t.Fatalf("unknown diagnostic is not the observed allocator boundary: %s", output)
+							}
+							frameBytes, err := strconv.ParseUint(match[1], 10, 64)
+							if err != nil || frameBytes <= 4294967295 {
+								t.Fatalf("compiler warning did not observe an oversized frame: %s", line)
+							}
+							warnings++
+						}
+						if warnings != 1 || errors == 0 {
+							t.Fatalf("missing/changed exact allocator diagnostics: errors=%d warnings=%d", errors, warnings)
+						}
+						t.Logf("LLVM_ALLOCATOR_BOUNDARY_OBSERVATION: source SHA=%x; original Go code SHA=%x; %s public %s=Context; private InstructionFormat0 local_stack=4294967439 bytes; compiler O0 offset errors=%d, frame warnings=%d; no object/stack correctness/runtime or source-N/A credit", sha256.Sum256([]byte(fixture.source)), sha256.Sum256(fixture.code), fixture.name, api, errors, warnings)
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86MinimumPositionInitializedBoundedAUTOPublicObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const initialized = `TEXT Bounded(SB),4,$32-4
+MOVL $0x12345678,AX
+MOVL AX,tmp-16(SP)
+MOVL AX,tmp-12(SP)
+MOVL AX,tmp-8(SP)
+MOVL AX,tmp-4(SP)
+VMOVUPS tmp-16(SP),X1
+PHMINPOSUW X1,X2
+VPHMINPOSUW tmp-16(SP),X3
+MOVL X2,AX
+MOVL X3,BX
+XORL BX,AX
+MOVL AX,ret+0(FP)
+RET
+`
+	for _, target := range x86RawReturnTargets {
+		for _, missing := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/missing=%t", target.triple, missing), func(t *testing.T) {
+				source := initialized
+				if missing {
+					source = strings.Replace(source, "MOVL AX,tmp-12(SP)\n", "", 1)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Bounded() uint32", target.arch, target.triple, api)
+						if missing {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("bounded AUTO invented the missing original initialized word", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("complete small-frame numerical source rejected", err)
+						}
+						for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86PackedStringCompileObject(t, llc, target.triple, input, "-O0")
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_raw_minpos_test.go b/amd64_raw_minpos_test.go
new file mode 100644
index 000000000..3153317b5
--- /dev/null
+++ b/amd64_raw_minpos_test.go
@@ -0,0 +1,225 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MinimumPositionGrammarMatchesGoEncoder(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	for _, form := range []struct {
+		file, op, table, operands string
+		vector                    bool
+	}{
+		{"asm6.go", "PHMINPOSUW", "yxm_q4", "Yxm, Yxr", false},
+		{"avx_optabs.go", "VPHMINPOSUW", "_yvaesimc", "Yxm, Yxr", true},
+	} {
+		data, err := os.ReadFile(filepath.Join(root, form.file))
+		if err != nil {
+			t.Fatal(err)
+		}
+		text := string(data)
+		spec, ok := amd64MinimumPositionSpecs[Op(form.op)]
+		if !ok || spec.vector != form.vector || spec.mapNumber != 2 || spec.opcode != 0x41 {
+			t.Fatalf("incorrect typed spec for %s: %+v", form.op, spec)
+		}
+		pattern := `(?s)var ` + form.table + ` = \[\]ytab\{(.*?)\n\}`
+		table := regexp.MustCompile(pattern).FindStringSubmatch(text)
+		if len(table) != 2 || strings.Count(table[1], "argList{") != 1 ||
+			!strings.Contains(table[1], "argList{"+form.operands+"}") {
+			t.Fatalf("Go %s operand grammar changed", form.op)
+		}
+		if form.vector {
+			pattern = `(?s)\{as: AVPHMINPOSUW, ytab: (\w+), prefix: Pavx, op: opBytes\{(.*?)\}\}`
+			rows := regexp.MustCompile(pattern).FindAllStringSubmatch(text, -1)
+			if len(rows) != 1 || rows[0][1] != form.table || strings.Count(rows[0][2], "0x41") != 1 {
+				t.Fatal("Go VPHMINPOSUW opcode forms changed")
+			}
+			for _, token := range []string{"vex128", "vex66", "vex0F38", "vexW0"} {
+				if !strings.Contains(rows[0][2], token) {
+					t.Fatalf("Go VPHMINPOSUW missing %s", token)
+				}
+			}
+		} else if !strings.Contains(text, "{APHMINPOSUW, yxm_q4, Pq4, opBytes{0x41}}") {
+			t.Fatal("Go PHMINPOSUW encoding changed")
+		}
+	}
+	if len(amd64MinimumPositionSpecs) != 2 {
+		t.Fatal("minimum-position family must match both Go opcodes")
+	}
+}
+
+func TestX86RawMinimumPositionEncodingFields(t *testing.T) {
+	for _, wide := range []bool{false, true} {
+		for src := 0; src < 16; src++ {
+			for dst := 0; dst < 16; dst++ {
+				code := encodeRawScalarMove(false, 1, 0x41, src, 0, dst, 0, false)
+				code[1] = code[1]&0xe0 | 2
+				if wide {
+					code[2] |= 0x80
+				}
+				for _, mode := range []int{32, 64} {
+					got, size, matched, err := decodedX86MinimumPositionInstruction(code, mode)
+					if mode == 32 && (src >= 8 || dst >= 8) {
+						if !matched || err == nil {
+							t.Fatalf("386 accepted %x", code)
+						}
+						continue
+					}
+					want := []Operand{
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", src))},
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", dst))},
+					}
+					if err != nil || !matched || size != len(code) || got.Op != "VPHMINPOSUW" || !reflect.DeepEqual(got.Args, want) {
+						t.Fatalf("decode %x mode=%d: %+v %v, want %+v", code, mode, got, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawMinimumPositionInvalidAndSegmentForms(t *testing.T) {
+	invalid := [][]byte{
+		{0xc4, 0xe2, 0x7d, 0x41, 0xc0},             // VEX.L1.
+		{0xc4, 0xe2, 0x71, 0x41, 0xc0},             // vvvv is not reserved.
+		{0xc4, 0xe2, 0x78, 0x41, 0xc0},             // No 66 prefix.
+		{0x62, 0xf2, 0x7d, 0x08, 0x41, 0xc0},       // No EVEX form.
+		{0xc4, 0xe2, 0x79, 0x41},                   // Missing ModRM.
+		{0xc4, 0xe2, 0x79, 0x41, 0x04},             // Missing SIB.
+		{0xc4, 0xe2, 0x79, 0x41, 0x80},             // Missing displacement.
+		{0xc4, 0xe2, 0x79, 0x41, 0x05, 0, 0, 0, 0}, // RIP relative.
+		{0x67, 0xc4, 0xe2, 0x79, 0x41, 0x00},       // Address override.
+	}
+	for _, code := range invalid {
+		if _, _, matched, err := decodedX86MinimumPositionInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x", code)
+		}
+	}
+	if _, _, matched, err := decodedX86MinimumPositionInstruction([]byte{0xc4, 0xe2, 0x79, 0x41, 0xc0}, 16); !matched || err == nil {
+		t.Fatal("accepted invalid x86 mode")
+	}
+	for _, code := range [][]byte{nil, {0xc4}, {0xc4, 0xe1, 0x79, 0x41, 0xc0}, {0xc4, 0xe2, 0x79, 0x40, 0xc0}} {
+		if _, _, matched, _ := decodedX86MinimumPositionInstruction(code, 64); matched {
+			t.Fatalf("matched unrelated encoding %x", code)
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		code := []byte{segment.prefix, 0xc4, 0x02, 0x79, 0x41, 0x64, 0x88, 0xf9}
+		got, size, matched, err := decodedX86MinimumPositionInstruction(code, 64)
+		want := []Operand{
+			{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: -7}},
+			{Kind: OpReg, Reg: "X12"},
+		}
+		if err != nil || !matched || size != len(code) || !reflect.DeepEqual(got.Args, want) {
+			t.Fatalf("decode %x: %+v %v, want %+v", code, got, err, want)
+		}
+	}
+}
+
+func TestX86MinimumPositionGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"PHMINPOSUW", "VPHMINPOSUW"} {
+			forms := []string{
+				" X0", " X0,X1,X2", " X0,K1,X1", " X0,(AX)",
+				" M0,M1", " Y0,Y1", " Z0,Z1", " X16,X0", " X0,X16",
+				".Z X0,X1", ".BCST (AX),X1", ".SAE X0,X1",
+			}
+			if arch == "386" && op == "PHMINPOSUW" {
+				forms = append(forms, " X8,X0", " X0,X8")
+			}
+			for _, operands := range forms {
+				line := op + operands
+				requireX86GoAssemblerResult(t, arch, "TEXT bad(SB),4,$0-0\n"+line+"\nRET\n", false)
+				assertX86PackedUnsignedWordMinimumPositionRejected(t, arch, triple, line)
+			}
+		}
+	}
+}
+
+func TestX86RawMinimumPositionGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			limit := 16
+			if arch == "386" {
+				limit = 8
+			}
+			memories := []string{"(AX)", "-7(BP)(CX*4)", "8192(SP)"}
+			if arch == "amd64" {
+				memories = append(memories, "(R8)", "-7(R13)(R15*8)")
+			}
+			var source strings.Builder
+			source.WriteString("TEXT minpos(SB),4,$0-0\n")
+			for _, op := range []string{"PHMINPOSUW", "VPHMINPOSUW"} {
+				for dst := 0; dst < limit; dst++ {
+					for src := 0; src < limit; src++ {
+						fmt.Fprintf(&source, "%s X%d,X%d\n", op, src, dst)
+					}
+					for _, memory := range memories {
+						fmt.Fprintf(&source, "%s %s,X%d\n", op, memory, dst)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := x86MinimumPositionOriginalGoBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !x86RawOperandsMatchGoSource(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d %s operands=%#v, want source %#v", i, got.Op, got.Args, want[i].Args)
+				}
+			}
+			file := x86RawStackObservingFormProbeFile(t, arch, "minpos", code)
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				ir := x86UnboundBlendMinposProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-minpos.ll", "raw-minpos.o", ir)
+			}
+			t.Logf("checked %d actual Go encodings", len(want)-1)
+		})
+	}
+}
+
+func TestX86MinimumPositionGoAccepted386HighNamedRegisters(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT minpos(SB),4,$0-0\n")
+	for reg := 8; reg < 16; reg++ {
+		fmt.Fprintf(&source, "VPHMINPOSUW X%d,X0\nVPHMINPOSUW X0,X%d\nVPHMINPOSUW (AX),X%d\n", reg, reg, reg)
+	}
+	source.WriteString("RET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		x86UnboundVoidFormatSources(t, source.String(), "386", triple)
+	}
+	t.Log("24 Go-accepted high named rows retain original Go objects and public Context, not physical mode32 format objects; complete initialized low-bank objects have a separate five-target owner")
+}
diff --git a/amd64_raw_mixed_layout.go b/amd64_raw_mixed_layout.go
new file mode 100644
index 000000000..8c13c150f
--- /dev/null
+++ b/amd64_raw_mixed_layout.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+// These legacy SSE/SSE2 symbol loads occur between generated raw instruction
+// spans. Their exact Go-assembler lengths are needed only to locate raw
+// PC-relative targets; the named instructions still lower semantically.
+var x86RawMixedSSESymbolReadOps = map[Op]bool{
+	"ADDPD": true, "ADDPS": true, "MULPD": true, "MULPS": true,
+	"ANDPD": true, "ANDPS": true, "ANDNPD": true, "ANDNPS": true,
+	"XORPD": true, "XORPS": true, "CMPPD": true, "CMPPS": true,
+	"PAND": true, "PANDN": true, "POR": true, "PXOR": true,
+	"PADDB": true, "PADDW": true, "PADDL": true, "PADDQ": true,
+	"PSUBL": true, "PCMPGTL": true, "PCMPEQL": true,
+	"PMULHUW": true, "PMADDWL": true, "PMINUB": true, "PMAXUB": true,
+	"MOVQ": true,
+}
+
+func x86RawMixedSSESymbolReadSize(ins Instr) (int, bool) {
+	if !x86RawMixedSSESymbolReadOps[ins.Op] || len(ins.Args) < 2 ||
+		ins.Args[0].Kind != OpSym || ins.Args[1].Kind != OpReg {
+		return 0, false
+	}
+	if _, _, ok := parseSBRef(ins.Args[0].Sym); !ok {
+		return 0, false
+	}
+	register, ok := amd64ParseXReg(ins.Args[1].Reg)
+	if !ok || register >= 16 {
+		return 0, false
+	}
+	compare := ins.Op == "CMPPD" || ins.Op == "CMPPS"
+	if compare {
+		if len(ins.Args) != 3 || ins.Args[2].Kind != OpImm || ins.Args[2].Imm < 0 || ins.Args[2].Imm > 255 {
+			return 0, false
+		}
+	} else if len(ins.Args) != 2 {
+		return 0, false
+	}
+	// 0F opcode, ModRM and disp32 = 7 bytes. Packed-double/integer and
+	// MOVQ forms have one mandatory prefix; X8..X15 add one REX byte.
+	length := 7
+	if ins.Op == "MOVQ" || len(ins.Op) > 0 && ins.Op[0] == 'P' ||
+		len(ins.Op) >= 2 && ins.Op[len(ins.Op)-2:] == "PD" {
+		length++
+	}
+	if register >= 8 {
+		length++
+	}
+	if compare {
+		length++
+	}
+	return length, true
+}
diff --git a/amd64_raw_mixed_layout_test.go b/amd64_raw_mixed_layout_test.go
new file mode 100644
index 000000000..68754640d
--- /dev/null
+++ b/amd64_raw_mixed_layout_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestDecodeX86RawByteIncrementWidth(t *testing.T) {
+	code := []byte{0xfe, 0xc1, 0xc3}
+	inst, err := x86asm.Decode(code, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if inst.Op != x86asm.INC || x86asm.GoSyntax(inst, 0, nil) != "INCL CL" {
+		t.Fatalf("x/arch INC baseline changed: %+v", inst)
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "byte increment", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "INCB" || decoded[0].Args[0].Reg != CL {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawIncrementDecrementCompleteGoForms(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		source.WriteString("TEXT rawIncDec(SB),4,$0-0\n")
+		for _, op := range []string{"INC", "DEC"} {
+			for _, form := range []struct {
+				suffix, register string
+			}{
+				{"B", "CL"}, {"W", "CX"}, {"L", "CX"}, {"Q", "CX"},
+			} {
+				if goarch == "386" && form.suffix == "Q" {
+					continue
+				}
+				fmt.Fprintf(&source, "\t%s%s %s\n", op, form.suffix, form.register)
+				fmt.Fprintf(&source, "\t%s%s 8(AX)\n", op, form.suffix)
+			}
+		}
+		source.WriteString("\tRET\n")
+		code := assembleX87ControlBytes(t, goarch, source.String())
+		decoded, err := decodeX86RawDirectives(rawX86Function(code), goarch)
+		if err != nil {
+			t.Fatalf("%s: %v", goarch, err)
+		}
+		named, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		want := named.Funcs[0].Instrs[1:]
+		if len(decoded.Instrs) != len(want) {
+			t.Fatalf("%s decoded %d instructions, want %d", goarch, len(decoded.Instrs), len(want))
+		}
+		for index, ins := range decoded.Instrs {
+			if ins.Op != want[index].Op || !reflect.DeepEqual(ins.Args, want[index].Args) {
+				t.Fatalf("%s instruction %d=%+v, want %+v", goarch, index, ins, want[index])
+			}
+		}
+	}
+}
+
+func TestX86MixedSSESymbolReadLengthsMatchGoAssembler(t *testing.T) {
+	for op := range x86RawMixedSSESymbolReadOps {
+		for _, register := range []string{"X0", "X10"} {
+			t.Run(string(op)+"/"+register, func(t *testing.T) {
+				instruction := fmt.Sprintf("%s pool(SB), %s", op, register)
+				if op == "CMPPS" || op == "CMPPD" {
+					instruction += ", $5"
+				}
+				source := "TEXT width(SB),4,$0-0\n\t" + instruction + "\n\tRET\n"
+				code := assembleX87ControlBytes(t, "amd64", source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				length, ok := x86RawMixedSSESymbolReadSize(file.Funcs[0].Instrs[1])
+				if !ok || length != len(code)-1 {
+					t.Fatalf("%s length=%d, recognized=%t, Go bytes=%x", instruction, length, ok, code)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86MixedRawJumpAcrossNamedSSERead(t *testing.T) {
+	const source = `TEXT mixedRawJump(SB),4,$0-0
+	BYTE $0xe9
+	LONG $8
+	POR pool(SB), X0
+	BYTE $0xc3
+`
+	code := assembleX87ControlBytes(t, "amd64", source)
+	if len(code) != 14 || code[0] != 0xe9 || code[13] != 0xc3 {
+		t.Fatalf("unexpected Go assembler layout: %x", code)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"mixedRawJump": {Name: "mixedRawJump", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, amd64LLVMBlockName("raw_jcc_")) {
+				t.Fatal("cross-segment branch label missing")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "mixed-raw-jump.ll", "mixed-raw-jump.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_movbe_width_test.go b/amd64_raw_movbe_width_test.go
new file mode 100644
index 000000000..1b2a47211
--- /dev/null
+++ b/amd64_raw_movbe_width_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func x86RawMOVBE(width int, store bool, register int) []byte {
+	var code []byte
+	if width == 16 {
+		code = append(code, 0x66)
+	}
+	rex := byte(0x40 | (register>>3&1)<<2)
+	if width == 64 {
+		rex |= 0x08
+	}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	opcode := byte(0xf0)
+	if store {
+		opcode = 0xf1
+	}
+	code = append(code, 0x0f, 0x38, opcode, byte((register&7)<<3|0x02), 0xc3)
+	return code
+}
+
+func TestDecodeX86RawMOVBECompleteWidthsAndDirections(t *testing.T) {
+	for _, width := range []int{16, 32, 64} {
+		for _, store := range []bool{false, true} {
+			for _, register := range []int{0, 7, 8, 15} {
+				name := fmt.Sprintf("%d/store%t/reg%d", width, store, register)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawMOVBE(width, store, register)
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := map[int]Op{16: "MOVBEW", 32: "MOVBEL", 64: "MOVBEQ"}[width]
+					if len(got) != 2 || got[0].Op != want || got[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s", code, got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawMOVBEObjects(t *testing.T) {
+	file := &File{Arch: ArchAMD64}
+	index := 0
+	for _, width := range []int{16, 32, 64} {
+		for _, store := range []bool{false, true} {
+			name := fmt.Sprintf("rawMOVBE%d", index)
+			probe := x86RawUnprovedReturnFormProbeFile(t, "amd64", name, x86RawMOVBE(width, store, 8))
+			file.Funcs = append(file.Funcs, probe.Funcs...)
+			index++
+		}
+	}
+	if index != 6 {
+		t.Fatal("complete raw MOVBE width/direction directory changed", index)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawProbeObject(t, file, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-movbe.ll", "raw-movbe.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_movemask.go b/amd64_raw_movemask.go
new file mode 100644
index 000000000..38a5d3dfe
--- /dev/null
+++ b/amd64_raw_movemask.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import "fmt"
+
+// Decode Go's VEX _yvmovmskpd family before x/arch can mistake opcode 50/D7
+// for a legacy PUSH/XLATB. The source is always a vector register; ModRM.reg
+// names the GP destination and vvvv is reserved.
+func decodedX86VEXMoveMaskInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.evex || p.mapNumber != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	for name, spec := range amd64MoveMaskSpecs {
+		if spec.vector && spec.opcode == p.opcode && spec.prefix == p.pp {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VEX move mask: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.upper != 0 || p.vectorLength > 1 {
+		return fail("reserved vvvv or vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if code[p.modRM]>>6 != 3 {
+		return fail("source must be a vector register")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	width := "X"
+	if p.vectorLength == 1 {
+		width = "Y"
+	}
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, int(code[p.modRM]&7)+p.b*8))}
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	destinationReg, valid := decodedX86GeneralRegister(destinationNumber)
+	if !valid {
+		return fail("invalid GP destination register")
+	}
+	destination := Operand{Kind: OpReg, Reg: destinationReg}
+	return Instr{
+		Op:   op,
+		Args: []Operand{source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+	}, p.modRM + 1, true, nil
+}
diff --git a/amd64_raw_movemask_test.go b/amd64_raw_movemask_test.go
new file mode 100644
index 000000000..10ade7c72
--- /dev/null
+++ b/amd64_raw_movemask_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86RawMoveMaskForms = []struct {
+	name string
+	code []byte
+	op   Op
+	src  Reg
+	dst  Reg
+}{
+	{"PMOVMSKB/MMX", []byte{0x0f, 0xd7, 0xc1}, "PMOVMSKB", "M1", AX},
+	{"PMOVMSKB/X", []byte{0x66, 0x0f, 0xd7, 0xc1}, "PMOVMSKB", "X1", AX},
+	{"MOVMSKPS/X", []byte{0x0f, 0x50, 0xc1}, "MOVMSKPS", "X1", AX},
+	{"MOVMSKPD/X", []byte{0x66, 0x0f, 0x50, 0xc1}, "MOVMSKPD", "X1", AX},
+	{"VPMOVMSKB/X", []byte{0xc5, 0xf9, 0xd7, 0xc1}, "VPMOVMSKB", "X1", AX},
+	{"VPMOVMSKB/Y", []byte{0xc5, 0xfd, 0xd7, 0xc1}, "VPMOVMSKB", "Y1", AX},
+	{"VMOVMSKPS/X", []byte{0xc5, 0xf8, 0x50, 0xc1}, "VMOVMSKPS", "X1", AX},
+	{"VMOVMSKPS/Y", []byte{0xc5, 0xfc, 0x50, 0xc1}, "VMOVMSKPS", "Y1", AX},
+	{"VMOVMSKPD/X", []byte{0xc5, 0xf9, 0x50, 0xc1}, "VMOVMSKPD", "X1", AX},
+	{"VMOVMSKPD/Y", []byte{0xc5, 0xfd, 0x50, 0xc1}, "VMOVMSKPD", "Y1", AX},
+}
+
+func TestX86RawMoveMaskCompleteGo127Family(t *testing.T) {
+	if len(amd64MoveMaskSpecs) != 6 {
+		t.Fatalf("move-mask grammar has %d operations, want six", len(amd64MoveMaskSpecs))
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, form := range x86RawMoveMaskForms {
+			t.Run(goarch+"/"+form.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range form.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != form.op || len(got.Instrs[0].Args) != 2 {
+					t.Fatalf("decoded %#x as %#v, want %s", form.code, got.Instrs, form.op)
+				}
+				args := got.Instrs[0].Args
+				if args[0].Kind != OpReg || args[0].Reg != form.src || args[1].Kind != OpReg || args[1].Reg != form.dst {
+					t.Fatalf("decoded %#x as %#v, want %s, %s", form.code, args, form.src, form.dst)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawMoveMaskRejectsReservedEncodings(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"reserved-vvvv", []byte{0xc5, 0xe9, 0xd7, 0xc1}, 64},
+		{"memory-source", []byte{0xc5, 0xfd, 0xd7, 0x01}, 64},
+		{"address-override", []byte{0x67, 0xc5, 0xfd, 0xd7, 0xc1}, 64},
+		{"missing-modrm", []byte{0xc5, 0xfd, 0xd7}, 64},
+		{"extended-386", []byte{0xc4, 0x61, 0x7d, 0xd7, 0xc1}, 32},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86VEXMoveMaskInstruction(tc.code, tc.mode); !recognized || err == nil {
+				t.Fatalf("reserved encoding %#x: recognized=%v error=%v", tc.code, recognized, err)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		src  Reg
+		dst  Reg
+	}{
+		{"W-ignored", []byte{0xc4, 0xe1, 0xfd, 0xd7, 0xc1}, "Y1", AX},
+		{"extended-vector-and-GP", []byte{0xc4, 0x41, 0x7d, 0xd7, 0xc8}, "Y8", "R9"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, recognized, err := decodedX86VEXMoveMaskInstruction(tc.code, 64)
+			if !recognized || err != nil || length != len(tc.code) {
+				t.Fatalf("encoding %#x: instruction=%+v length=%d recognized=%v error=%v", tc.code, got, length, recognized, err)
+			}
+			if got.Args[0].Reg != tc.src || got.Args[1].Reg != tc.dst {
+				t.Fatalf("encoding %#x operands = %+v, want %s, %s", tc.code, got.Args, tc.src, tc.dst)
+			}
+		})
+	}
+}
+
+func TestX86RawMoveMaskCompilesEveryGoForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawmovemaskforms(SB),4,$0-0\n")
+			for _, form := range x86RawMoveMaskForms {
+				for _, value := range form.code {
+					fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+				}
+				source.WriteString("\tNOP\n")
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawmovemaskforms": {Name: "rawmovemaskforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-movemask.ll", "raw-movemask.o", ir)
+		})
+	}
+}
+
+func TestX86RawMoveMaskRuntime(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := x86RawMoveMaskOriginalRuntimeSource
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawmovemasksemantics": {
+			Name: "rawmovemasksemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmovemasksemantics(const uint8_t *, uint32_t *);
+int main(void) {
+  uint8_t input[32] = {0};
+  uint32_t out[3] = {0};
+  input[3] = 0x80; input[7] = 0x80; input[15] = 0x80; input[31] = 0x80;
+  rawmovemasksemantics(input, out);
+  if (out[0] != ((1u << 3) | (1u << 7) | (1u << 15) | (1u << 31))) return 1;
+  if (out[1] != ((1u << 0) | (1u << 1) | (1u << 3))) return 2;
+  if (out[2] != ((1u << 0) | (1u << 1) | (1u << 3))) return 3;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_move_mask", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_raw_movhlps.go b/amd64_raw_movhlps.go
new file mode 100644
index 000000000..d5332dbde
--- /dev/null
+++ b/amd64_raw_movhlps.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var x86RawVectorHighLowMoveOps = map[int]Op{
+	0x12: "VMOVHLPS",
+	0x16: "VMOVLHPS",
+}
+
+// The Go 1.27 _yvmovhlps table has exactly two register-only 128-bit rows.
+// ModRM memory encodings belong to the separate VMOVLPS/VMOVHPS family.
+func decodedX86RawVectorHighLowMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || p.mapNumber != 1 || p.pp != 0 {
+		return Instr{}, 0, false, nil
+	}
+	op, owned := x86RawVectorHighLowMoveOps[p.opcode]
+	if !owned {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("vector high/low move: %s", message)
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if code[p.modRM]>>6 != 3 {
+		return Instr{}, 0, false, nil
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.vectorLength != 0 || p.evex && (!p.fixed || p.w || p.mask != 0 || p.zero || p.broadcast) {
+		return fail("invalid 128-bit VEX/EVEX register form")
+	}
+	if !p.evex && mode == 32 && (p.r != 0 || p.upper >= 8) {
+		return fail("extended VEX register in 32-bit mode")
+	}
+	var first Operand
+	var consumed int
+	var err error
+	if p.evex {
+		first, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", 16)
+	} else {
+		first, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))}
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", destinationNumber))}
+	args := []Operand{first, second, destination}
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_movhlps_test.go b/amd64_raw_movhlps_test.go
new file mode 100644
index 000000000..a3a50f8e3
--- /dev/null
+++ b/amd64_raw_movhlps_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVectorHighLowMove(opcode byte, encoding string, first, second, destination int, wig bool) []byte {
+	modRM := byte(0xc0 | (destination&7)<<3 | first&7)
+	switch encoding {
+	case "VEX2":
+		p1 := byte((1-destination/8)<<7 | (^second&15)<<3)
+		return []byte{0xc5, p1, opcode, modRM}
+	case "VEX3":
+		p0 := byte((1-destination/8)<<7 | 1<<6 | (1-first/8)<<5 | 1)
+		p1 := byte((^second & 15) << 3)
+		if wig {
+			p1 |= 0x80
+		}
+		return []byte{0xc4, p0, p1, opcode, modRM}
+	case "EVEX":
+		p0 := byte((1-destination/8&1)<<7 | (1-first/16)<<6 |
+			(1-first/8&1)<<5 | (1-destination/16)<<4 | 1)
+		p1 := byte(4 | (^second&15)<<3)
+		p2 := byte((1 - second/16) << 3)
+		return []byte{0x62, p0, p1, p2, opcode, modRM}
+	default:
+		panic("unknown high/low move encoding")
+	}
+}
+
+func TestTranslateRawVectorHighLowMoveGorseRegression(t *testing.T) {
+	const source = `TEXT rawMoveLowToHigh(SB), $0-0
+	LONG $0xc016f0c5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawMoveLowToHigh": {Name: "rawMoveLowToHigh", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "shufflevector <2 x i64>") {
+		t.Fatalf("raw VMOVLHPS omitted half-lane move:\n%s", ir)
+	}
+}
+
+func TestDecodedX86RawVectorHighLowMoveGoRowsAndEncodings(t *testing.T) {
+	if len(x86RawVectorHighLowMoveOps) != 2 ||
+		x86RawVectorHighLowMoveOps[0x12] != "VMOVHLPS" ||
+		x86RawVectorHighLowMoveOps[0x16] != "VMOVLHPS" {
+		t.Fatal("Go 1.27 _yvmovhlps raw opcode grammar changed")
+	}
+	for opcode, op := range x86RawVectorHighLowMoveOps {
+		for _, test := range []struct {
+			encoding            string
+			first, second, dest int
+			wig                 bool
+		}{
+			{"VEX2", 1, 2, 3, false},
+			{"VEX3", 12, 13, 14, false},
+			{"VEX3", 12, 13, 14, true}, // VEX.W is ignored by the hardware.
+			{"EVEX", 20, 21, 22, false},
+		} {
+			code := encodeX86RawVectorHighLowMove(byte(opcode), test.encoding, test.first, test.second, test.dest, test.wig)
+			got, length, recognized, err := decodedX86RawVectorHighLowMoveInstruction(code, 64)
+			if err != nil || !recognized || length != len(code) || got.Op != op {
+				t.Fatalf("decode %x = %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+			}
+			want := []string{
+				fmt.Sprintf("X%d", test.first),
+				fmt.Sprintf("X%d", test.second),
+				fmt.Sprintf("X%d", test.dest),
+			}
+			if len(got.Args) != len(want) {
+				t.Fatalf("decode %x = %+v, want %v", code, got, want)
+			}
+			for index, operand := range got.Args {
+				if operand.String() != want[index] {
+					t.Fatalf("decode %x = %+v, want %v", code, got, want)
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawVectorHighLowMoveRejectsNonGoForms(t *testing.T) {
+	base := encodeX86RawVectorHighLowMove(0x16, "EVEX", 1, 2, 3, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"fixed bit", []byte{base[0], base[1], base[2] &^ 4, base[3], base[4], base[5]}},
+		{"EVEX W", []byte{base[0], base[1], base[2] | 0x80, base[3], base[4], base[5]}},
+		{"vector length", []byte{base[0], base[1], base[2], base[3] | 0x20, base[4], base[5]}},
+		{"mask", []byte{base[0], base[1], base[2], base[3] | 1, base[4], base[5]}},
+		{"zero", []byte{base[0], base[1], base[2], base[3] | 0x80, base[4], base[5]}},
+		{"broadcast", []byte{base[0], base[1], base[2], base[3] | 0x10, base[4], base[5]}},
+		{"missing ModRM", base[:5]},
+		{"address override", append([]byte{0x67}, base...)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawVectorHighLowMoveInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted invalid encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+	memory := append([]byte(nil), base...)
+	memory[5] = 0x43
+	if _, _, recognized, err := decodedX86RawVectorHighLowMoveInstruction(memory, 64); recognized || err != nil {
+		t.Fatalf("claimed VMOVHPS memory encoding %x: recognized=%v err=%v", memory, recognized, err)
+	}
+}
+
+func TestTranslateRawVectorHighLowMoveLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawHighLowMoveFamily(SB), $0-0\n")
+			for opcode := range x86RawVectorHighLowMoveOps {
+				for _, code := range [][]byte{
+					encodeX86RawVectorHighLowMove(byte(opcode), "VEX2", 1, 2, 3, false),
+					encodeX86RawVectorHighLowMove(byte(opcode), "VEX3", 4, 5, 6, true),
+					encodeX86RawVectorHighLowMove(byte(opcode), "EVEX", 20, 21, 22, false),
+				} {
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, source.String())
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawHighLowMoveFamily": {Name: "rawHighLowMoveFamily", Ret: Void}},
+			})
+			if target.goarch == "386" {
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("original high-bank whole source acquired mode32 numerical authority", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-high-low-move.ll", "raw-high-low-move.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_movsxd.go b/amd64_raw_movsxd.go
new file mode 100644
index 000000000..7cfede571
--- /dev/null
+++ b/amd64_raw_movsxd.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Opcode 63 is ARPL outside 64-bit mode. In 64-bit mode its default
+// operation is a 32-bit copy, 66 selects a 16-bit copy, and effective
+// REX.W selects a 32-to-64-bit sign extension. See Intel SDM volume 2B,
+// MOVSX/MOVSXD. A 16-bit memory operand remains Context: Intel's r/m16
+// and AMD/x86asm's r/m32 descriptions do not establish one read extent.
+func decodedX86MOVSXD(inst x86asm.Inst, encoding []byte) (string, error) {
+	fail := func(reason string) (string, error) {
+		return "", fmt.Errorf("%w: raw MOVSXD %s", ErrProbeNeedsContext, reason)
+	}
+	if inst.Op != x86asm.MOVSXD || inst.Mode != 64 || inst.Len != len(encoding) {
+		return fail("requires its complete 64-bit-mode physical encoding")
+	}
+	physical, decodeErr := x86asm.Decode(encoding, 64)
+	if decodeErr != nil || physical != inst {
+		return fail("does not match the independently decoded original bytes")
+	}
+	// Bind the effective size and register extension to actual bytes, not a
+	// public DataSize or a widthless mnemonic. Deliberately leave unregistered
+	// ignored/repeated/segment/address prefixes outside this closed grammar.
+	index, bits := 0, 32
+	if index < len(encoding) && encoding[index] == 0x66 {
+		bits = 16
+		index++
+	}
+	if index < len(encoding) && encoding[index]&0xf0 == 0x40 {
+		if encoding[index]&8 != 0 {
+			bits = 64
+		}
+		index++
+	}
+	if index+1 >= len(encoding) || encoding[index] != 0x63 || inst.DataSize != bits || inst.AddrSize != 64 {
+		return fail("has an unregistered prefix, opcode or effective size")
+	}
+	destination, register := inst.Args[0].(x86asm.Reg)
+	if !register || decodedX86RegisterBits(destination) != bits || inst.Args[2] != nil || inst.Args[3] != nil {
+		return fail("has inconsistent destination or extra operands")
+	}
+	switch source := inst.Args[1].(type) {
+	case x86asm.Reg:
+		// The pinned decoder describes every 63 source as r/m32, including
+		// 66 register forms. The latter consume only its low sixteen bits.
+		if decodedX86RegisterBits(source) != 32 || encoding[index+1]&0xc0 != 0xc0 {
+			return fail("has inconsistent register source or ModRM")
+		}
+		if bits == 16 {
+			inst.Args[1] = x86asm.AX + (source - x86asm.EAX)
+		}
+	case x86asm.Mem:
+		if encoding[index+1]&0xc0 == 0xc0 || inst.MemBytes != 4 || source.Segment != 0 {
+			return fail("has inconsistent memory source or native read extent")
+		}
+		if bits == 16 {
+			return fail("16-bit memory needs a source-bound vendor read-width contract")
+		}
+	default:
+		return fail("requires a register or memory source")
+	}
+	if bits == 64 {
+		// Go has a width-specific name for the genuine sign extension.
+		syntax := x86asm.GoSyntax(inst, 0, nil)
+		return "MOVLQSX" + syntax[len("MOVSXD"):], nil
+	}
+	inst.Op = x86asm.MOV
+	if bits == 16 {
+		inst.MemBytes = 2
+	}
+	return x86asm.GoSyntax(inst, 0, nil), nil
+}
+
+func x86RawDwordLiteralInput(ins Instr) bool {
+	// This is only the source-stack transfer's input-availability check. The
+	// final consumer must still bind the exact bytes to the allocated DATA
+	// object through x86RawReturnDecodedReadBound; no GP input is inferred.
+	read := ins.x86RIPMemoryRead
+	if ins.Op != "MOVL" && ins.Op != "MOVLQSX" || read.source != 0 || read.width != 4 || len(ins.Args) != 2 ||
+		ins.Args[1].Kind != OpReg || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	result, valid := x86CallerGP(ins.Args[1].Reg)
+	return valid && result != SP && result != BP && result == ins.Args[1].Reg
+}
diff --git a/amd64_raw_movsxd_runtime_test.go b/amd64_raw_movsxd_runtime_test.go
new file mode 100644
index 000000000..f4cf66e9f
--- /dev/null
+++ b/amd64_raw_movsxd_runtime_test.go
@@ -0,0 +1,325 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86MOVSXDNumericalForm struct {
+	name     string
+	encoding []byte
+	bits     int
+	offset   int
+	setup    string
+	result   string
+	inPlace  bool
+	flagSeed int
+}
+
+func x86MOVSXDNumericalForms() []x86MOVSXDNumericalForm {
+	forms := []x86MOVSXDNumericalForm{
+		{name: "wordBX", encoding: []byte{0x66, 0x63, 0xc3}, bits: 16},
+		{name: "wordSI", encoding: []byte{0x66, 0x63, 0xc6}, bits: 16, setup: "MOVQ BX,SI\n"},
+		{name: "wordR9", encoding: []byte{0x66, 0x41, 0x63, 0xc1}, bits: 16, setup: "MOVQ BX,R9\n"},
+		{name: "wordR8", encoding: []byte{0x66, 0x44, 0x63, 0xc3}, bits: 16, result: "MOVQ R8,AX\n"},
+		{name: "wordAlias", encoding: []byte{0x66, 0x63, 0xc0}, bits: 16, setup: "MOVQ BX,AX\n", inPlace: true},
+		{name: "longBX", encoding: []byte{0x63, 0xc3}, bits: 32},
+		{name: "longR9", encoding: []byte{0x41, 0x63, 0xc1}, bits: 32, setup: "MOVQ BX,R9\n"},
+		{name: "longR8", encoding: []byte{0x44, 0x63, 0xc3}, bits: 32, result: "MOVQ R8,AX\n"},
+		{name: "longAlias", encoding: []byte{0x63, 0xc0}, bits: 32, setup: "MOVQ BX,AX\n", inPlace: true},
+		{name: "longMemory", encoding: []byte{0x63, 0x07}, bits: 32},
+		{name: "longUnaligned", encoding: []byte{0x63, 0x47, 0x01}, bits: 32, offset: 1},
+		{name: "longOffset4", encoding: []byte{0x63, 0x47, 0x04}, bits: 32, offset: 4},
+		{name: "longIndexed", encoding: []byte{0x63, 0x04, 0x8f}, bits: 32, setup: "MOVQ $0,CX\n"},
+		{name: "quadBX", encoding: []byte{0x48, 0x63, 0xc3}, bits: 64},
+		{name: "quadR9", encoding: []byte{0x49, 0x63, 0xc1}, bits: 64, setup: "MOVQ BX,R9\n"},
+		{name: "quadR8", encoding: []byte{0x4c, 0x63, 0xc3}, bits: 64, result: "MOVQ R8,AX\n"},
+		{name: "quadAlias", encoding: []byte{0x48, 0x63, 0xc0}, bits: 64, setup: "MOVQ BX,AX\n", inPlace: true},
+		{name: "quadMemory", encoding: []byte{0x48, 0x63, 0x07}, bits: 64},
+		{name: "quadUnaligned", encoding: []byte{0x48, 0x63, 0x47, 0x01}, bits: 64, offset: 1},
+		{name: "quadOffset4", encoding: []byte{0x48, 0x63, 0x47, 0x04}, bits: 64, offset: 4},
+		{name: "quadIndexed", encoding: []byte{0x48, 0x63, 0x04, 0x8f}, bits: 64, setup: "MOVQ $0,CX\n"},
+		{name: "quadOperandOverride", encoding: []byte{0x66, 0x48, 0x63, 0x07}, bits: 64},
+	}
+	var seeded []x86MOVSXDNumericalForm
+	for _, form := range forms {
+		for seed, suffix := range []string{"", "Carry", "Overflow"} {
+			variant := form
+			variant.name += suffix
+			variant.flagSeed = seed
+			seeded = append(seeded, variant)
+		}
+	}
+	return seeded
+}
+
+func x86MOVSXDFlagSeed(seed int) string {
+	switch seed {
+	case 1:
+		// 0-1: CF=1, OF=0, SF=1, PF=1, ZF=0.
+		return "MOVQ $0,R15\nCMPQ R15,$1\n"
+	case 2:
+		// INT64_MIN-1: CF=0, OF=1, SF=0, PF=1, ZF=0.
+		return "MOVQ $0x8000000000000000,R15\nCMPQ R15,$1\n"
+	default:
+		return "CMPQ BX,$0\n"
+	}
+}
+
+func x86MOVSXDNumericalSource() (string, string) {
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package caller\nimport \"unsafe\"\n")
+	for _, form := range x86MOVSXDNumericalForms() {
+		declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint64")
+		declaration = declaration[strings.Index(declaration, "//go:noescape"):]
+		declaration = strings.ReplaceAll(declaration, "kernel", form.name)
+		declaration = strings.Replace(declaration, "func Call(", "func Call"+form.name+"(", 1)
+		declarations.WriteString(declaration)
+		body := "MOVQ (DI),BX\nMOVQ $0x5a6b7c8d9eaf1021,AX\nMOVQ AX,R8\n" + form.setup
+		body += x86MOVSXDFlagSeed(form.flagSeed) + x86MOVSXDBytes(form.encoding) + form.result
+		// Neutral MOVs capture each modeled flag before any arithmetic. The
+		// branch joins preserve definite numeric bytes, not guessed values.
+		body += `MOVQ $0,R9
+MOVQ $0,R10
+MOVQ $0,R11
+MOVQ $0,R12
+MOVQ $0,R13
+JCC noCarry
+MOVQ $1,R9
+noCarry:
+JOC noOverflow
+MOVQ $2,R10
+noOverflow:
+JPL noSign
+MOVQ $4,R11
+noSign:
+JPC noParity
+MOVQ $8,R12
+noParity:
+JNE noZero
+MOVQ $16,R13
+noZero:
+JE done
+ADDQ $7,AX
+done:
+ORQ R9,R10
+ORQ R11,R10
+ORQ R12,R10
+ORQ R13,R10
+SHLQ $48,R10
+XORQ R10,AX
+MOVQ AX,(DX)`
+		machine := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+form.name)
+		assembly.WriteString(strings.Replace(machine, "MOVL $7,AX\nMOVL AX,(DX)", body, 1))
+	}
+	return declarations.String(), assembly.String()
+}
+
+func x86MOVSXDGoOracle() string {
+	var source strings.Builder
+	source.WriteString(`package caller
+import "testing"
+func reference(input uint64, bits, offset uint, inPlace bool, flagSeed uint) uint64 {
+	value := uint64(uint32(input >> (offset*8)))
+	if bits == 16 {
+		seed := uint64(0x5a6b7c8d9eaf1021)
+		if inPlace { seed = input }
+		value = seed & ^uint64(65535) | input & 65535
+	} else if bits == 64 {
+		value = uint64(int64(int32(value)))
+	}
+	if input != 0 || flagSeed != 0 { value += 7 }
+	flags := uint64(0)
+	if input>>63 != 0 { flags |= 4 }
+	var ones uint
+	for byteValue := uint8(input); byteValue != 0; byteValue >>= 1 { ones += uint(byteValue&1) }
+	if ones%2 == 0 { flags |= 8 }
+	if input == 0 { flags |= 16 }
+	if flagSeed == 1 { flags = 1 | 4 | 8 }
+	if flagSeed == 2 { flags = 2 | 8 }
+	return value ^ (flags<<48)
+}
+func TestOriginalMOVSXDNumerical(t *testing.T) {
+`)
+	for _, form := range x86MOVSXDNumericalForms() {
+		fmt.Fprintf(&source, `
+	for iteration := 0; iteration < 16; iteration++ {
+		for _, input := range []uint64{0, 1, 127, 128, 65535, 1<<31, 1<<63, ^uint64(0)} {
+			x := []uint64{input, 0x1122334455667788}
+			y := []uint64{0x8877665544332211, 23}
+			canary := [4]uint64{11, 23, 37, 41}
+			got := Call%[1]s(x, y)
+			want := reference(input, %[2]d, %[3]d, %[4]t, %[5]d)
+			if got != want || x[0] != input || x[1] != 0x1122334455667788 ||
+				y[0] != 0x8877665544332211 || y[1] != 23 || canary != [4]uint64{11,23,37,41} {
+				t.Fatalf("%[1]s got=%%#x want=%%#x input=%%#x canary=%%v", got, want, input, canary)
+			}
+		}
+	}
+`, form.name, form.bits, form.offset, form.inPlace, form.flagSeed)
+	}
+	source.WriteString("}\n")
+	return source.String()
+}
+
+func x86MOVSXDActualGo(t *testing.T, execute bool) {
+	t.Helper()
+	declaration, assembly := x86MOVSXDNumericalSource()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module caller\n\ngo 1.20\n", "value.go": declaration,
+		"value_amd64.s": assembly, "value_test.go": x86MOVSXDGoOracle(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	binary := filepath.Join(dir, "original.test")
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go original raw MOVSXD build: %v\n%s", err, output)
+	}
+	if !execute {
+		return // Object/Go entry transport evidence is not runtime success.
+	}
+	command = exec.CommandContext(ctx, binary, "-test.v", "-test.timeout=2m")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Linux/amd64 MOVSXD mathematical/canary oracle: %v\n%s", err, output)
+	}
+}
+
+func x86MOVSXDCOracle() string {
+	var declarations, checks strings.Builder
+	for index, form := range x86MOVSXDNumericalForms() {
+		fmt.Fprintf(&declarations, "extern void %s(void*,void*,void*,void*) __asm__(LABEL(\"caller.%s\"));\n", form.name, form.name)
+		fmt.Fprintf(&checks, "    if (check(%s, %d, %d, %t, %d)) return %d;\n",
+			form.name, form.bits, form.offset, form.inPlace, form.flagSeed, index+1)
+	}
+	return `#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+` + declarations.String() + `
+static uint64_t reference(uint64_t input, unsigned bits, unsigned offset, bool in_place, unsigned flag_seed) {
+    uint64_t value = (uint32_t)(input >> (offset*8));
+    if (bits == 16) {
+        uint64_t seed = in_place ? input : UINT64_C(0x5a6b7c8d9eaf1021);
+        value = (seed & ~UINT64_C(65535)) | (input & UINT64_C(65535));
+    } else if (bits == 64) {
+        value = (uint64_t)(int64_t)(int32_t)value;
+    }
+    value += input != 0 || flag_seed != 0 ? 7 : 0;
+    uint64_t flags = input >> 63 ? 4 : 0;
+    unsigned ones = 0;
+    for (unsigned byte_value = (unsigned char)input; byte_value; byte_value >>= 1) ones += byte_value & 1;
+    if (!(ones & 1)) flags |= 8;
+    if (!input) flags |= 16;
+    if (flag_seed == 1) flags = 1 | 4 | 8;
+    if (flag_seed == 2) flags = 2 | 8;
+    return value ^ (flags << 48);
+}
+static int check(void (*fn)(void*,void*,void*,void*), unsigned bits, unsigned offset, bool in_place, unsigned flag_seed) {
+    const uint64_t inputs[] = {0, 1, 127, 128, 65535, UINT64_C(1)<<31, UINT64_C(1)<<63, UINT64_MAX};
+    for (unsigned iteration = 0; iteration < 16; iteration++) {
+        for (unsigned index = 0; index < sizeof(inputs)/sizeof(inputs[0]); index++) {
+            uint64_t x[] = {inputs[index], UINT64_C(0x1122334455667788)};
+            uint64_t y[] = {UINT64_C(0x8877665544332211), 23}, length = 2;
+            unsigned char output[10];
+            memset(output, 0xa5, sizeof(output));
+            fn(x, y, output+1, &length);
+            uint64_t got;
+            memcpy(&got, output+1, sizeof(got));
+            if (got != reference(inputs[index], bits, offset, in_place, flag_seed) ||
+                output[0] != 0xa5 || output[9] != 0xa5 || length != 2 ||
+                x[0] != inputs[index] || x[1] != UINT64_C(0x1122334455667788) ||
+                y[0] != UINT64_C(0x8877665544332211) || y[1] != 23) return 1;
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "    return 0;\n}\n"
+}
+
+func x86MOVSXDLLVMNumerical(t *testing.T, runner []string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	declaration, assembly := x86MOVSXDNumericalSource()
+	pkg := x86CallerRuntimePackage(t, declaration, assembly)
+	file := pkg.SourceSelection.Assembly["value_amd64.s"]
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "movsxd-text", triple, ir, x86MOVSXDCOracle(), runner)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "movsxd-module", triple, module.String(), x86MOVSXDCOracle(), runner)
+	ctx = llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+		FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if translation != nil && !translation.Module.IsNil() {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "movsxd-go-module", triple, translation.Module.String(), x86MOVSXDCOracle(), runner)
+}
+
+func TestX86RawMOVSXDOriginalGoBuild(t *testing.T) {
+	x86MOVSXDActualGo(t, false)
+}
+
+func TestX86RawMOVSXDLLVMHostNumerical(t *testing.T) {
+	var runner []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+		t.Log("LLVM numerical diagnostic uses Rosetta; the original no-REX 63 environment failure is retained separately")
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("requires the mandatory Linux/amd64 original-Go plus LLVM counterpart")
+	}
+	x86MOVSXDLLVMNumerical(t, runner)
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64MOVSXDNativeWidths(t *testing.T) {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Skip("required actual Linux/amd64 original-Go and LLVM counterpart; Darwin/Rosetta is not equivalent")
+	}
+	x86MOVSXDActualGo(t, true)
+	x86MOVSXDLLVMNumerical(t, nil)
+}
diff --git a/amd64_raw_movsxd_test.go b/amd64_raw_movsxd_test.go
new file mode 100644
index 000000000..f4e159f69
--- /dev/null
+++ b/amd64_raw_movsxd_test.go
@@ -0,0 +1,464 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func x86MOVSXDBytes(encoding []byte) string {
+	var source strings.Builder
+	for _, value := range encoding {
+		fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+	}
+	return source.String()
+}
+
+func TestX86RawMOVSXDNativeWidths(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		encoding []byte
+		want     string
+	}{
+		{"long register", []byte{0x63, 0xc3}, "MOVL BX, AX"},
+		{"long high source", []byte{0x41, 0x63, 0xc1}, "MOVL R9, AX"},
+		{"long high result", []byte{0x44, 0x63, 0xc3}, "MOVL BX, R8"},
+		{"long alias", []byte{0x63, 0xc0}, "MOVL AX, AX"},
+		{"long memory", []byte{0x63, 0x07}, "MOVL 0(DI), AX"},
+		{"long indexed", []byte{0x63, 0x44, 0x8f, 0x03}, "MOVL 0x3(DI)(CX*4), AX"},
+		{"word register", []byte{0x66, 0x63, 0xc3}, "MOVW BX, AX"},
+		{"word physical SI", []byte{0x66, 0x63, 0xc6}, "MOVW SI, AX"},
+		{"word high source", []byte{0x66, 0x41, 0x63, 0xc1}, "MOVW R9, AX"},
+		{"word high result", []byte{0x66, 0x44, 0x63, 0xc3}, "MOVW BX, R8"},
+		{"quad register", []byte{0x48, 0x63, 0xc3}, "MOVLQSX BX, AX"},
+		{"quad memory", []byte{0x48, 0x63, 0x07}, "MOVLQSX 0(DI), AX"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			inst, err := x86asm.Decode(test.encoding, 64)
+			if err != nil || inst.Op != x86asm.MOVSXD || inst.Len != len(test.encoding) {
+				t.Fatalf("physical decode: %+v %v", inst, err)
+			}
+			got, err := decodedX86GoSyntax(inst, test.encoding)
+			if err != nil || got != test.want {
+				t.Fatalf("physical width: got %q, want %q: %v", got, test.want, err)
+			}
+		})
+	}
+}
+
+func TestX86RawMOVSXDLongCallerOriginalBytes(t *testing.T) {
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)",
+		"MOVQ $0x80000000,BX\nWORD $0xc363\nMOVL AX,(DX)", 1)
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86RawMOVSXDCompleteRegisterModRM(t *testing.T) {
+	registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI",
+		"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for _, bits := range []int{16, 32, 64} {
+		for result := range registers {
+			for source := range registers {
+				var encoding []byte
+				if bits == 16 {
+					encoding = append(encoding, 0x66)
+				}
+				rex := byte(0x40)
+				if bits == 64 {
+					rex |= 8
+				}
+				if result >= 8 {
+					rex |= 4
+				}
+				if source >= 8 {
+					rex |= 1
+				}
+				if rex != 0x40 {
+					encoding = append(encoding, rex)
+				}
+				encoding = append(encoding, 0x63, byte(0xc0+(result%8)*8+source%8))
+				inst, err := x86asm.Decode(encoding, 64)
+				if err != nil {
+					t.Fatal(err)
+				}
+				before := inst
+				got, err := decodedX86GoSyntax(inst, encoding)
+				op := map[int]string{16: "MOVW", 32: "MOVL", 64: "MOVLQSX"}[bits]
+				want := fmt.Sprintf("%s %s, %s", op, registers[source], registers[result])
+				if err != nil || got != want || !reflect.DeepEqual(inst, before) {
+					t.Fatalf("bits=%d bytes=%x: got %q want %q changed=%t: %v", bits, encoding, got, want, inst != before, err)
+				}
+			}
+		}
+	}
+}
+
+func x86MOVSXDDenied(t *testing.T, source string) {
+	t.Helper()
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, source)
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+		if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved raw MOVSXD Translate: %v", err)
+		}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved raw MOVSXD module: %v", err)
+		}
+		if err := x86CallerCoreTranslate(t, pkg, source, triple); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unproved raw MOVSXD Go module: %v", err)
+		}
+	}
+}
+
+func TestX86RawMOVSXDInputAndVendorBoundaries(t *testing.T) {
+	for _, test := range []struct{ name, body string }{
+		{"undefined long source", "WORD $0xc363"},
+		{"partial long source", "MOVW $7,BX\nWORD $0xc363"},
+		{"undefined word source", "BYTE $0x66\nWORD $0xc363"},
+		{"partial word source", "MOVB $7,BX\nBYTE $0x66\nWORD $0xc363"},
+		{"caller pointer long source", "WORD $0xc763"},
+		{"caller pointer word source", "BYTE $0x66\nWORD $0xc763"},
+		{"word overwrites surviving pointer bits", "MOVQ DI,AX\nBYTE $0x66\nWORD $0xc363"},
+		{"native SP source", "WORD $0xc463"},
+		{"native BP source", "BYTE $0x66\nWORD $0xc563"},
+		{"native SP result", "WORD $0xe363"},
+		{"native BP result", "BYTE $0x66\nWORD $0xeb63"},
+		{"g source", "BYTE $0x41\nWORD $0xc663"},
+		{"g result", "BYTE $0x44\nWORD $0xf363"},
+		{"unknown memory", "WORD $0x0363"},
+		{"partial FP pointer slot", "WORD $0x4463\nWORD $0x0824"},
+		{"return PC memory", "WORD $0x0463\nBYTE $0x24"},
+		{"word memory vendor identity absent", "BYTE $0x66\nWORD $0x0763"},
+		{"word indexed vendor identity absent", "BYTE $0x66\nLONG $0x038f4463"},
+		{"address-size memory", "BYTE $0x67\nWORD $0x0763"},
+		{"different initialized bytes join", "CMPQ AX,$0\nJE other\nMOVL $7,BX\nother:\nWORD $0xc363"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", test.body+"\nMOVL AX,(DX)", 1)
+			x86MOVSXDDenied(t, assembly)
+		})
+	}
+}
+
+func TestX86RawMOVSXDRequiresExactEncodingIdentity(t *testing.T) {
+	encoding := []byte{0x63, 0xc3}
+	physical, err := x86asm.Decode(encoding, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, change := range []string{"source", "result", "width", "mode", "extra operand", "bytes", "truncated", "extended"} {
+		t.Run(change, func(t *testing.T) {
+			inst, bytes := physical, append([]byte(nil), encoding...)
+			switch change {
+			case "source":
+				inst.Args[1] = x86asm.ECX
+			case "result":
+				inst.Args[0] = x86asm.ECX
+			case "width":
+				inst.DataSize = 64
+			case "mode":
+				inst.Mode = 32
+			case "extra operand":
+				inst.Args[2] = x86asm.EAX
+			case "bytes":
+				bytes[1] = 0xc1
+			case "truncated":
+				bytes = bytes[:1]
+			case "extended":
+				bytes = append(bytes, 0x90)
+			}
+			if _, err := decodedX86GoSyntax(inst, bytes); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("mismatched native MOVSXD width acquired permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86RawMOVSXDNoncallerDoesNotAcquireInputProof(t *testing.T) {
+	for _, prefix := range []string{"", "MOVW $7,BX\n", "MOVQ x+0(FP),BX\n"} {
+		for _, raw := range []string{"WORD $0xc363", "BYTE $0x66\nWORD $0xc363"} {
+			source, sig, pkg := x86SourceStackNumericalFixture("amd64", prefix+raw+"\nMOVQ AX,ret+8(FP)\nBYTE $0xc3")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := x86SourceStackOptions("amd64", "x86_64-unknown-linux-gnu", sig)
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("noncaller raw scalar width acquired input proof: %v", err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("noncaller raw scalar module acquired input proof: %v", err)
+			}
+			ctx = llvm.NewContext()
+			translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			})
+			if translation != nil {
+				translation.Module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("noncaller raw scalar Go module acquired input proof: %v", err)
+			}
+		}
+	}
+}
+
+func TestX86RawMOVSXDLegacyModeRemainsARPL(t *testing.T) {
+	for _, encoding := range [][]byte{{0x63, 0xc3}, {0x66, 0x63, 0xc3}} {
+		inst, err := x86asm.Decode(encoding, 32)
+		if err != nil || inst.Op != x86asm.ARPL {
+			t.Fatalf("legacy mode opcode identity: %+v %v", inst, err)
+		}
+		syntax, err := decodedX86GoSyntax(inst, encoding)
+		if err != nil || !strings.HasPrefix(syntax, "ARPL ") {
+			t.Fatalf("legacy ARPL must not become a numerical copy: %q %v", syntax, err)
+		}
+	}
+}
+
+func TestX86RawMOVSXDUnregisteredPrefixesStayContext(t *testing.T) {
+	for _, encoding := range [][]byte{
+		{0x66, 0x66, 0x63, 0xc3}, {0x40, 0x41, 0x63, 0xc3},
+		{0xf2, 0x63, 0xc3}, {0xf3, 0x63, 0xc3},
+		{0x67, 0x63, 0x07}, {0x64, 0x63, 0x07}, {0x65, 0x48, 0x63, 0x07},
+	} {
+		inst, err := x86asm.Decode(encoding, 64)
+		if err != nil || inst.Op != x86asm.MOVSXD {
+			continue // Decoder rejection is also closed; it is not object/runtime P.
+		}
+		if _, err := decodedX86GoSyntax(inst, encoding); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unregistered physical prefix %x was silently discarded: %v", encoding, err)
+		}
+	}
+	if inst, err := x86asm.Decode([]byte{0xf0, 0x63, 0xc3}, 64); err == nil && inst.Op == x86asm.MOVSXD {
+		if _, err := decodedX86GoSyntax(inst, []byte{0xf0, 0x63, 0xc3}); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("machine-invalid LOCK MOVSXD was accepted or misclassified as missing context", err)
+		}
+	}
+}
+
+func x86MOVSXDModuleObject(t *testing.T, file *File, options Options, triple, name string) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileLLVMToObject(t, findLLVM22Tool("llc"), triple, name+".ll", name+".o", module.String())
+}
+
+func x86MOVSXDGoModuleObject(t *testing.T, pkg GoPackage, source, triple, name string) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "amd64", TargetTriple: triple,
+	})
+	if translation != nil {
+		defer translation.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileLLVMToObject(t, findLLVM22Tool("llc"), triple, name+".ll", name+".o", translation.Module.String())
+}
+
+func TestX86RawMOVSXDSafeFormatsThreeAPIObjects(t *testing.T) {
+	for _, body := range []string{
+		"MOVL $0x80000000,BX\nWORD $0xc363",
+		"MOVL $0x80000000,R9\nBYTE $0x41\nWORD $0xc163",
+		"MOVL $0x80000000,BX\nBYTE $0x44\nWORD $0xc363\nMOVL R8,AX",
+		"MOVL $0x80000000,AX\nWORD $0xc063",
+		"WORD $0x0763", "WORD $0x4763\nBYTE $1", "MOVL $0,CX\nLONG $0x038f4463",
+		"MOVL $0,CX\nLONG $0x008f4463",
+		"MOVQ $0x1122334455667788,AX\nMOVW $0x8000,BX\nBYTE $0x66\nWORD $0xc363",
+		"MOVQ $0x1122334455667788,AX\nMOVQ $0x8000,SI\nBYTE $0x66\nWORD $0xc663",
+		"MOVQ $0x1122334455667788,AX\nMOVW $0x8000,R9\nWORD $0x4166\nWORD $0xc163",
+		"MOVL $0x80000000,BX\nBYTE $0x48\nWORD $0xc363",
+		"BYTE $0x48\nWORD $0x0763", "WORD $0x4866\nWORD $0x0763",
+	} {
+		assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body+"\nMOVL AX,(DX)", 1)
+		requireX86GoAssemblerResult(t, "amd64", assembly, true)
+		pkg, file := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+		resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatalf("Translate %s: %v\n%s", triple, err, body)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM22 llc required")
+			}
+			compileLLVMToObject(t, llc, triple, "movsxd-text.ll", "movsxd-text.o", ir)
+			x86MOVSXDModuleObject(t, file, options, triple, "movsxd-module")
+			if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+func TestX86RawMOVSXDLiteralExactReadExtent(t *testing.T) {
+	for _, prefix := range []string{"", "BYTE $0x48\n"} {
+		// The literal lies after the native C3, twelve/thirteen bytes from the
+		// entry. Displacement six spans the encoded full result-slot store.
+		body := prefix + "WORD $0x0563\nLONG $6\nWORD $0x8948\nWORD $0x2444\nBYTE $16\nBYTE $0xc3\nLONG $0x80000000"
+		source, sig, pkg := x86SourceStackNumericalFixture("amd64", body)
+		requireX86GoAssemblerResult(t, "amd64", source, true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			options := x86SourceStackOptions("amd64", triple, sig)
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, findLLVM22Tool("llc"), triple, "movsxd-literal.ll", "movsxd-literal.o", ir)
+			x86MOVSXDModuleObject(t, file, options, triple, "movsxd-literal-module")
+			x86MOVSXDGoModuleObject(t, pkg, source, triple, "movsxd-literal-go")
+		}
+		// Preserve the real opcode and displacement; only truncate the object.
+		truncated := strings.TrimSuffix(source, "LONG $0x80000000\n") + "WORD $0x8000\n"
+		truncatedFile, err := Parse(ArchAMD64, truncated)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(truncatedFile, x86SourceStackOptions("amd64", "x86_64-unknown-linux-gnu", sig)); err == nil {
+			t.Fatal("four-byte MOVSXD literal read borrowed a truncated object")
+		}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, truncatedFile, x86SourceStackOptions("amd64", "x86_64-unknown-linux-gnu", sig))
+		if !module.IsNil() {
+			module.Dispose()
+		}
+		ctx.Dispose()
+		if err == nil {
+			t.Fatal("module borrowed a truncated MOVSXD literal")
+		}
+		ctx = llvm.NewContext()
+		translation, err := translateGoModuleInContext(ctx, pkg, []byte(truncated), GoModuleOptions{
+			GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		})
+		if translation != nil {
+			translation.Module.Dispose()
+		}
+		ctx.Dispose()
+		if err == nil {
+			t.Fatal("Go module borrowed a truncated MOVSXD literal")
+		}
+	}
+}
+
+func TestX86RawMOVSXDOriginalGoByteWitness(t *testing.T) {
+	for _, encoding := range [][]byte{
+		{0x63, 0xc3}, {0x66, 0x63, 0xc3}, {0x48, 0x63, 0xc3},
+		{0x41, 0x63, 0xc1}, {0x44, 0x63, 0xc3},
+		{0x66, 0x41, 0x63, 0xc1}, {0x66, 0x44, 0x63, 0xc3},
+		{0x63, 0x07}, {0x63, 0x47, 0x01}, {0x63, 0x44, 0x8f, 0x03},
+		{0x48, 0x63, 0x07}, {0x66, 0x48, 0x63, 0x07},
+		{0x66, 0x63, 0x07}, // Go accepts the raw bytes; native extent remains Context.
+	} {
+		listing, err := x86ExtensionGoListing(t, "amd64", x86MOVSXDBytes(encoding))
+		var bytes strings.Builder
+		for _, value := range append(append([]byte(nil), encoding...), 0xc3) {
+			fmt.Fprintf(&bytes, "%02x ", value)
+		}
+		if err != nil || !strings.Contains(listing, strings.TrimSpace(bytes.String())) {
+			t.Fatalf("actual Go %x byte witness: %v\n%s", encoding, err, listing)
+		}
+	}
+}
+
+func TestX86RawMOVSXDLiteralCannotBorrowStaleCertificate(t *testing.T) {
+	body := "BYTE $0x48\nWORD $0x0563\nLONG $6\nWORD $0x8948\nWORD $0x2444\nBYTE $16\nBYTE $0xc3\nLONG $0x80000000"
+	source, sig, _ := x86SourceStackNumericalFixture("amd64", body)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := x86SourceStackOptions("amd64", "x86_64-unknown-linux-gnu", sig)
+	normalized, err := normalizeX86RawFile(file, "amd64", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, change := range []string{"source width", "opcode", "result", "source", "payload", "missing object", "g result"} {
+		t.Run(change, func(t *testing.T) {
+			mutated := *normalized
+			mutated.Data = append([]DataStmt(nil), normalized.Data...)
+			mutated.Funcs = append([]Func(nil), normalized.Funcs...)
+			mutated.Funcs[0].Instrs = append([]Instr(nil), normalized.Funcs[0].Instrs...)
+			instruction := &mutated.Funcs[0].Instrs[1]
+			instruction.Args = append([]Operand(nil), instruction.Args...)
+			switch change {
+			case "source width":
+				instruction.x86RIPMemoryRead.width = 8
+			case "opcode":
+				instruction.Op = "MOVQ"
+			case "result":
+				instruction.Args[1].Reg = BX
+			case "source":
+				instruction.Args[0] = Operand{Kind: OpReg, Reg: BX}
+			case "g result":
+				instruction.Args[1].Reg = "R14"
+			case "payload":
+				mutated.Data[0].Payload = []byte{1, 2, 3, 4}
+			case "missing object":
+				mutated.Data = nil
+			}
+			if _, err := Translate(&mutated, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed literal Translate: %v", err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, &mutated, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed literal module: %v", err)
+			}
+			// Go-module input is original bytes, not a File carrying a private
+			// certificate. Its independently regenerated, truncated source is
+			// tested above; it cannot accept this mutated certificate as input.
+		})
+	}
+}
diff --git a/amd64_raw_mul_dword_qword.go b/amd64_raw_mul_dword_qword.go
new file mode 100644
index 000000000..bc071c1bb
--- /dev/null
+++ b/amd64_raw_mul_dword_qword.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodedX86DwordToQwordMultiplyInstruction recognizes every VEX and EVEX
+// encoding of VPMULDQ and VPMULUDQ in Go 1.27's _yvandnpd table. x/arch
+// v0.14 does not decode these encodings, so raw BYTE/LONG directive users
+// need the complete X/Y/Z, memory, mask, zeroing, and broadcast family here.
+func decodedX86DwordToQwordMultiplyInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86DwordToQwordMultiplyInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86DwordToQwordMultiplyInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto vex
+		}
+	}
+
+vex:
+	if i >= len(code) {
+		return Instr{}, 0, false, nil
+	}
+
+	var (
+		opcodeIndex int
+		modRMIndex  int
+		mapSelect   int
+		width       int
+		rExt        int
+		rHigh       int
+		xExt        int
+		bExt        int
+		vRegister   int
+		vHigh       int
+		rmHigh      int
+		masked      bool
+		zeroing     bool
+		broadcast   bool
+		mask        int
+		evex        bool
+	)
+
+	switch code[i] {
+	case 0xc5:
+		if len(code) < i+3 {
+			return Instr{}, 0, false, nil
+		}
+		vexByte := code[i+1]
+		opcodeIndex, modRMIndex = i+2, i+3
+		mapSelect = 1
+		if vexByte&3 != 1 || code[opcodeIndex] != 0xf4 {
+			return Instr{}, 0, false, nil
+		}
+		rExt = int(^vexByte>>7) & 1
+		vRegister = int(^vexByte>>3) & 15
+		width = 16
+		if vexByte&4 != 0 {
+			width = 32
+		}
+	case 0xc4:
+		if len(code) < i+4 {
+			return Instr{}, 0, false, nil
+		}
+		vexExt, vexByte := code[i+1], code[i+2]
+		opcodeIndex, modRMIndex = i+3, i+4
+		mapSelect = int(vexExt & 0x1f)
+		if vexByte&3 != 1 || !x86DwordToQwordMultiplyOpcode(mapSelect, code[opcodeIndex]) {
+			return Instr{}, 0, false, nil
+		}
+		ok = true
+		if vexByte&0x80 != 0 {
+			return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+		}
+		rExt = int(^vexExt>>7) & 1
+		xExt = int(^vexExt>>6) & 1
+		bExt = int(^vexExt>>5) & 1
+		vRegister = int(^vexByte>>3) & 15
+		width = 16
+		if vexByte&4 != 0 {
+			width = 32
+		}
+	case 0x62:
+		if len(code) < i+5 {
+			return Instr{}, 0, false, nil
+		}
+		p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+		opcodeIndex, modRMIndex = i+4, i+5
+		mapSelect = int(p0 & 3)
+		if p0&0x0c != 0 || p1&3 != 1 || !x86DwordToQwordMultiplyOpcode(mapSelect, code[opcodeIndex]) {
+			return Instr{}, 0, false, nil
+		}
+		ok, evex = true, true
+		if p1&0x84 != 0x84 {
+			return Instr{}, 0, true, fmt.Errorf("EVEX.W must be one and reserved bit must be set")
+		}
+		rExt = int(^p0>>7) & 1
+		rHigh = int(^p0>>4) & 1
+		xExt = int(^p0>>6) & 1
+		bExt = int(^p0>>5) & 1
+		vRegister = int(^p1>>3) & 15
+		vHigh = int(^p2>>3) & 1
+		rmHigh = xExt
+		zeroing = p2&0x80 != 0
+		broadcast = p2&0x10 != 0
+		mask = int(p2 & 7)
+		masked = mask != 0
+		switch p2 >> 5 & 3 {
+		case 0:
+			width = 16
+		case 1:
+			width = 32
+		case 2:
+			width = 64
+		default:
+			return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+		}
+	default:
+		return Instr{}, 0, false, nil
+	}
+
+	if !ok {
+		ok = true
+	}
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRM := code[modRMIndex]
+	if evex && broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	if zeroing && !masked {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHigh*16
+	secondNumber := vRegister + vHigh*16
+	if mode == 32 && (destinationNumber >= 8 || secondNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector or address register in 32-bit mode")
+	}
+	destination, valid := decodedX86VectorRegister(destinationNumber, width)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid destination vector register %d", destinationNumber)
+	}
+	second, valid := decodedX86VectorRegister(secondNumber, width)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid second-source vector register %d", secondNumber)
+	}
+	disp8Scale := 1
+	if evex {
+		disp8Scale = width
+		if broadcast {
+			disp8Scale = 8
+		}
+	}
+	var first Operand
+	var consumed int
+	if memory.physicalPC && modRM>>6 != 3 {
+		first, consumed, err = memory.scalar(code[modRMIndex:], mode, bExt, xExt, segment, disp8Scale)
+	} else {
+		first, consumed, err = decodedX86VectorRMSource(code[modRMIndex:], mode, bExt, xExt, rmHigh, width, segment, disp8Scale)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+
+	op := "VPMULUDQ"
+	if mapSelect == 2 {
+		op = "VPMULDQ"
+	}
+	var suffixes []string
+	if broadcast {
+		suffixes = append(suffixes, "BCST")
+	}
+	if zeroing {
+		suffixes = append(suffixes, "Z")
+	}
+	if len(suffixes) != 0 {
+		op += "." + strings.Join(suffixes, ".")
+	}
+	args := []Operand{first, {Kind: OpReg, Reg: second}}
+	if masked {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: destination})
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: Op(op), Args: args, Raw: op + " " + strings.Join(rawArgs, ", "), x86Encoded: true}, modRMIndex + consumed, true, nil
+}
+
+func x86DwordToQwordMultiplyOpcode(mapSelect int, opcode byte) bool {
+	return mapSelect == 1 && opcode == 0xf4 || mapSelect == 2 && opcode == 0x28
+}
+
+func decodedX86VectorRMSource(code []byte, mode, bExt, xExt, highExt, width int, segment Reg, disp8Scale int) (Operand, int, error) {
+	if len(code) == 0 {
+		return Operand{}, 0, fmt.Errorf("missing ModRM byte")
+	}
+	if code[0]>>6 != 3 {
+		return decodedX86RMSource(code, mode, bExt, xExt, segment, disp8Scale)
+	}
+	number := int(code[0]&7) + bExt*8 + highExt*16
+	if mode == 32 && number >= 8 {
+		return Operand{}, 0, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	register, ok := decodedX86VectorRegister(number, width)
+	if !ok {
+		return Operand{}, 0, fmt.Errorf("invalid first-source vector register %d", number)
+	}
+	return Operand{Kind: OpReg, Reg: register}, 1, nil
+}
+
+func decodedX86VectorRegister(number, width int) (Reg, bool) {
+	prefix := ""
+	switch width {
+	case 16:
+		prefix = "X"
+	case 32:
+		prefix = "Y"
+	case 64:
+		prefix = "Z"
+	default:
+		return "", false
+	}
+	if number < 0 || number >= 32 {
+		return "", false
+	}
+	return Reg(fmt.Sprintf("%s%d", prefix, number)), true
+}
diff --git a/amd64_raw_mul_dword_qword_test.go b/amd64_raw_mul_dword_qword_test.go
new file mode 100644
index 000000000..fdcaccd53
--- /dev/null
+++ b/amd64_raw_mul_dword_qword_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RawDwordToQwordMultiplyReportedEncoding(t *testing.T) {
+	const source = `
+TEXT rawVPMULUDQ(SB),$0-0
+	BYTE $0xc5
+	BYTE $0xfd
+	BYTE $0xf4
+	BYTE $0xc2
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "386", triple: "i686-unknown-linux-gnu"},
+		{goarch: "386", triple: "i686-pc-windows-msvc"},
+		{goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			// The original reported bytes have unknown Y inputs. Preserve the
+			// real Go object, public Context and complete emitter object;
+			// initialized product-family objects own the numerical contract.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-vpmuludq.ll", "raw-vpmuludq.o", ir)
+		})
+	}
+}
+
+func TestX86RawDwordToQwordMultiplyCompleteVEXRegisterFields(t *testing.T) {
+	for _, family := range []struct {
+		name   string
+		mapID  byte
+		opcode byte
+	}{
+		{name: "VPMULUDQ", mapID: 1, opcode: 0xf4},
+		{name: "VPMULDQ", mapID: 2, opcode: 0x28},
+	} {
+		for _, width := range []struct {
+			prefix string
+			l      byte
+		}{
+			{prefix: "X", l: 0},
+			{prefix: "Y", l: 1},
+		} {
+			for first := 0; first < 16; first++ {
+				for second := 0; second < 16; second++ {
+					for destination := 0; destination < 16; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 | 1<<6 | byte((^first>>3)&1)<<5 | family.mapID
+						p1 := byte((^second)&15)<<3 | width.l<<2 | 1
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0xc4, p0, p1, family.opcode, modRM}
+						instruction, length, ok, err := decodedX86DwordToQwordMultiplyInstruction(encoding, 64)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("%s %s registers %d,%d,%d: ok=%v length=%d err=%v", family.name, width.prefix, first, second, destination, ok, length, err)
+						}
+						want := []Reg{
+							Reg(fmt.Sprintf("%s%d", width.prefix, first)),
+							Reg(fmt.Sprintf("%s%d", width.prefix, second)),
+							Reg(fmt.Sprintf("%s%d", width.prefix, destination)),
+						}
+						if instruction.Op != Op(family.name) || len(instruction.Args) != len(want) {
+							t.Fatalf("encoding %x decoded as %#v", encoding, instruction)
+						}
+						for index := range want {
+							if instruction.Args[index].Kind != OpReg || instruction.Args[index].Reg != want[index] {
+								t.Fatalf("encoding %x arg %d = %#v, want %s", encoding, index, instruction.Args[index], want[index])
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawDwordToQwordMultiplyCompleteEVEXRegisterFields(t *testing.T) {
+	for _, family := range []struct {
+		name   string
+		mapID  byte
+		opcode byte
+	}{
+		{name: "VPMULUDQ", mapID: 1, opcode: 0xf4},
+		{name: "VPMULDQ", mapID: 2, opcode: 0x28},
+	} {
+		for _, width := range []struct {
+			prefix string
+			ll     byte
+		}{
+			{prefix: "X", ll: 0},
+			{prefix: "Y", ll: 1},
+			{prefix: "Z", ll: 2},
+		} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 | byte((^first>>4)&1)<<6 | byte((^first>>3)&1)<<5 | byte((^destination>>4)&1)<<4 | family.mapID
+						p1 := byte(0x85 | ((^second)&15)<<3)
+						p2 := width.ll<<5 | byte((^second>>4)&1)<<3 | 1
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0x62, p0, p1, p2, family.opcode, modRM}
+						instruction, length, ok, err := decodedX86DwordToQwordMultiplyInstruction(encoding, 64)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("%s %s registers %d,%d,%d: ok=%v length=%d err=%v", family.name, width.prefix, first, second, destination, ok, length, err)
+						}
+						want := []Reg{
+							Reg(fmt.Sprintf("%s%d", width.prefix, first)),
+							Reg(fmt.Sprintf("%s%d", width.prefix, second)),
+							"K1",
+							Reg(fmt.Sprintf("%s%d", width.prefix, destination)),
+						}
+						if instruction.Op != Op(family.name) || len(instruction.Args) != len(want) {
+							t.Fatalf("encoding %x decoded as %#v", encoding, instruction)
+						}
+						for index := range want {
+							if instruction.Args[index].Kind != OpReg || instruction.Args[index].Reg != want[index] {
+								t.Fatalf("encoding %x arg %d = %#v, want %s", encoding, index, instruction.Args[index], want[index])
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawDwordToQwordMultiplyMemoryMaskAndBroadcastForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		encoding []byte
+		wantOp   Op
+		wantArgs int
+		wantMem  bool
+	}{
+		{name: "vex signed base", encoding: []byte{0xc4, 0xe2, 0x31, 0x28, 0x13}, wantOp: "VPMULDQ", wantArgs: 3, wantMem: true},
+		{name: "vex unsigned extended base", encoding: []byte{0xc4, 0xc1, 0x31, 0xf4, 0x13}, wantOp: "VPMULUDQ", wantArgs: 3, wantMem: true},
+		{name: "evex masked memory", encoding: []byte{0x62, 0x71, 0xfd, 0x0e, 0xf4, 0xbc, 0x75, 0xef, 0xff, 0xff, 0xff}, wantOp: "VPMULUDQ", wantArgs: 4, wantMem: true},
+		{name: "evex broadcast", encoding: []byte{0x62, 0x71, 0xfd, 0x1e, 0xf4, 0xbc, 0x75, 0xef, 0xff, 0xff, 0xff}, wantOp: "VPMULUDQ.BCST", wantArgs: 4, wantMem: true},
+		{name: "evex broadcast zero", encoding: []byte{0x62, 0x71, 0xfd, 0x9e, 0xf4, 0xbc, 0x75, 0xef, 0xff, 0xff, 0xff}, wantOp: "VPMULUDQ.BCST.Z", wantArgs: 4, wantMem: true},
+		{name: "evex unmasked", encoding: []byte{0x62, 0x31, 0xfd, 0x08, 0xf4, 0xf8}, wantOp: "VPMULUDQ", wantArgs: 3},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86DwordToQwordMultiplyInstruction(test.encoding, 64)
+			if !ok || err != nil || length != len(test.encoding) {
+				t.Fatalf("encoding %x: ok=%v length=%d err=%v", test.encoding, ok, length, err)
+			}
+			if instruction.Op != test.wantOp || len(instruction.Args) != test.wantArgs || (instruction.Args[0].Kind == OpMem) != test.wantMem {
+				t.Fatalf("encoding %x decoded as %#v", test.encoding, instruction)
+			}
+		})
+	}
+}
+
+func TestX86RawDwordToQwordMultiplyRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+	}{
+		{name: "vex w", mode: 64, encoding: []byte{0xc4, 0xe1, 0xfd, 0xf4, 0xc2}},
+		{name: "evex w", mode: 64, encoding: []byte{0x62, 0x31, 0x7d, 0x0e, 0xf4, 0xf8}},
+		{name: "evex reserved length", mode: 64, encoding: []byte{0x62, 0x31, 0xfd, 0x6e, 0xf4, 0xf8}},
+		{name: "zero without mask", mode: 64, encoding: []byte{0x62, 0x31, 0xfd, 0x88, 0xf4, 0xf8}},
+		{name: "broadcast register", mode: 64, encoding: []byte{0x62, 0x31, 0xfd, 0x1e, 0xf4, 0xf8}},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0xc5, 0xfd, 0xf4, 0xc2}},
+		{name: "rip relative", mode: 64, encoding: []byte{0xc5, 0xfd, 0xf4, 0x05, 0, 0, 0, 0}},
+		{name: "extended 386", mode: 32, encoding: []byte{0xc4, 0x61, 0x79, 0xf4, 0xc0}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86DwordToQwordMultiplyInstruction(test.encoding, test.mode)
+			if !ok || err == nil {
+				t.Fatalf("encoding %x: ok=%v err=%v, want recognized rejection", test.encoding, ok, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_mul_low.go b/amd64_raw_mul_low.go
new file mode 100644
index 000000000..afbc3f1d3
--- /dev/null
+++ b/amd64_raw_mul_low.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27's packed-multiply rows share _yvandnpd's operand grammar. The
+// opcode/map selects the lane operation; EVEX.W selects Q for opcode 40/0F38.
+// VEX.W is ignored, including VPMULLD; it cannot select a VEX qword form.
+// The word operations have no broadcast row, whereas D/Q permit it.
+type x86PackedMultiplyForm struct {
+	mapID         byte
+	opcode        byte
+	vexOp         Op
+	evexW0Op      Op
+	evexW1Op      Op
+	broadcastByte int
+}
+
+var x86PackedMultiplyForms = [...]x86PackedMultiplyForm{
+	{mapID: 1, opcode: 0xd5, vexOp: "VPMULLW", evexW0Op: "VPMULLW", evexW1Op: "VPMULLW"},
+	{mapID: 1, opcode: 0xe5, vexOp: "VPMULHW", evexW0Op: "VPMULHW", evexW1Op: "VPMULHW"},
+	{mapID: 1, opcode: 0xe4, vexOp: "VPMULHUW", evexW0Op: "VPMULHUW", evexW1Op: "VPMULHUW"},
+	{mapID: 2, opcode: 0x0b, vexOp: "VPMULHRSW", evexW0Op: "VPMULHRSW", evexW1Op: "VPMULHRSW"},
+	{mapID: 2, opcode: 0x40, vexOp: "VPMULLD", evexW0Op: "VPMULLD", evexW1Op: "VPMULLQ", broadcastByte: 4},
+}
+
+func x86PackedMultiplyFormFor(mapID, opcode byte) (x86PackedMultiplyForm, bool) {
+	for _, form := range x86PackedMultiplyForms {
+		if form.mapID == mapID && form.opcode == opcode {
+			return form, true
+		}
+	}
+	return x86PackedMultiplyForm{}, false
+}
+
+// Keep the direct decoder used by the exhaustive VPMULLD/Q tests separate
+// from the dispatcher, while sharing its parser with the word-multiply rows.
+func decodedX86PackedMultiplyLowInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	instruction, length, ok, err = decodedX86PackedMultiplyInstruction(code, mode)
+	if !ok || err != nil || instruction.Op == "VPMULLD" || strings.HasPrefix(string(instruction.Op), "VPMULLD.") ||
+		instruction.Op == "VPMULLQ" || strings.HasPrefix(string(instruction.Op), "VPMULLQ.") {
+		return instruction, length, ok, err
+	}
+	return Instr{}, 0, false, nil
+}
+
+func decodedX86PackedMultiplyInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86PackedMultiplyInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedMultiplyInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	if p.evex {
+		return decodedX86EVEXPackedMultiplyInstructionWithMemory(
+			code, p.modRM-5, mode, p.segment, p.addressOverride, memory,
+		)
+	}
+	if p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	form, recognized := x86PackedMultiplyFormFor(byte(p.mapNumber), byte(p.opcode))
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p.addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	modRMIndex := p.modRM
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorName := "X"
+	if p.vectorLength != 0 {
+		vectorName = "Y"
+	}
+	secondSourceNumber := p.upper
+	destinationNumber := int(code[modRMIndex]>>3&7) + p.r*8
+	if mode == 32 && (secondSourceNumber >= 8 || destinationNumber >= 8 ||
+		code[modRMIndex]>>6 == 3 && int(code[modRMIndex]&7)+p.b*8 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	firstSource, consumed, decodeErr := memory.vex(
+		code[modRMIndex:], mode, p.b, p.x, p.segment, vectorName,
+	)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	instruction = Instr{
+		Op:   form.vexOp,
+		Args: []Operand{firstSource, secondSource, destination},
+		Raw:  fmt.Sprintf("%s %s, %s, %s", form.vexOp, firstSource.String(), secondSource.String(), destination.String()),
+	}
+	instruction.x86Encoded = true
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXPackedMultiplyInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXPackedMultiplyInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXPackedMultiplyInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+5 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	if p1&0x07 != 5 {
+		return Instr{}, 0, false, nil
+	}
+	form, recognized := x86PackedMultiplyFormFor(p0&0x0f, code[i+4])
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	vectorBits := (p2 >> 5) & 3
+	if vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+	vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+	vectorWidth := [...]int{16, 32, 64}[vectorBits]
+	width64 := p1&0x80 != 0
+	op := form.evexW0Op
+	if width64 {
+		op = form.evexW1Op
+	}
+	laneBytes := form.broadcastByte
+	if width64 && laneBytes != 0 {
+		laneBytes = 8
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	modRMIndex := i + 5
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	modRM := code[modRMIndex]
+	broadcast := p2&0x10 != 0
+	if broadcast && laneBytes == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast is not available for %s", op)
+	}
+	if broadcast && modRM>>6 == 3 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX broadcast requires a memory source")
+	}
+	secondSourceNumber := (int(^p1>>3) & 15) + (int(^p2>>3)&1)*16
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	firstSourceNumber := int(modRM&7) + bExt*8 + xExt*16
+	if mode == 32 && vectorName == "Z" && (secondSourceNumber >= 8 || destinationNumber >= 8 || modRM>>6 == 3 && firstSourceNumber >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("high Z register is unavailable in 32-bit mode")
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = laneBytes
+	}
+	firstSource, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorName, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	secondSource := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, secondSourceNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorName, destinationNumber))}
+	args := []Operand{firstSource, secondSource}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	if broadcast {
+		op += ".BCST"
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: true}, modRMIndex + consumed, true, nil
+}
diff --git a/amd64_raw_mul_low_test.go b/amd64_raw_mul_low_test.go
new file mode 100644
index 000000000..2a7a1df15
--- /dev/null
+++ b/amd64_raw_mul_low_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXPackedMultiplyLow(width256 bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	p0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 2)
+	p1 := byte(((^source1)&15)<<3 | int(l)<<2 | 1)
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0xc4, p0, p1, 0x40, modRM}
+}
+
+func encodeX86EVEXPackedMultiplyLow(width64 bool, vectorBits byte, mask int, zeroing bool, destination, source1, source2 int) []byte {
+	p0 := byte((1-destination/8&1)<<7 | (1-source2/16)<<6 | (1-source2/8&1)<<5 | (1-destination/16)<<4 | 2)
+	p1 := byte(((^source1)&15)<<3 | 5)
+	if width64 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | byte((^source1>>4)&1)<<3 | byte(mask))
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0x62, p0, p1, p2, 0x40, modRM}
+}
+
+func TestTranslateRawEVEXVPMULLDWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawVPMULLD(SB), $0-0
+	LONG $0x483df262
+	WORD $0xe440
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawVPMULLD": {Name: "rawVPMULLD", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mul <16 x i32>") {
+		t.Fatalf("raw VPMULLD lowering omitted packed multiply:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-evex-vpmulld.ll", "amd64-raw-evex-vpmulld.o", ir)
+}
+
+func TestDecodedX86PackedMultiplyLowCompleteVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for _, width256 := range []bool{false, true} {
+		prefix := "X"
+		if width256 {
+			prefix = "Y"
+		}
+		for destination := 0; destination < 16; destination++ {
+			for source1 := 0; source1 < 16; source1++ {
+				for source2 := 0; source2 < 16; source2++ {
+					code := encodeX86VEXPackedMultiplyLow(width256, destination, source1, source2)
+					got, length, ok, err := decodedX86PackedMultiplyLowInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+					if got.Op != "VPMULLD" || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+						t.Fatalf("decode %x = %+v, want VPMULLD %s", code, got, strings.Join(wantArgs, ", "))
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d VEX packed multiply-low register encodings, want 8192", count)
+	}
+}
+
+func TestDecodedX86PackedMultiplyLowCompleteEVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for _, width := range []struct {
+		width64 bool
+		op      Op
+	}{
+		{op: "VPMULLD"},
+		{width64: true, op: "VPMULLQ"},
+	} {
+		for vectorBits, prefix := range []string{"X", "Y", "Z"} {
+			for destination := 0; destination < 32; destination++ {
+				for source1 := 0; source1 < 32; source1++ {
+					for source2 := 0; source2 < 32; source2++ {
+						code := encodeX86EVEXPackedMultiplyLow(width.width64, byte(vectorBits), 1, false, destination, source1, source2)
+						got, length, ok, err := decodedX86PackedMultiplyLowInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), "K1", fmt.Sprintf("%s%d", prefix, destination)}
+						if got.Op != width.op || len(got.Args) != 4 {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, width.op, strings.Join(wantArgs, ", "))
+						}
+						for index := range wantArgs {
+							if got.Args[index].String() != wantArgs[index] {
+								t.Fatalf("decode %x = %+v, want %s %s", code, got, width.op, strings.Join(wantArgs, ", "))
+							}
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 196608 {
+		t.Fatalf("covered %d EVEX packed multiply-low register encodings, want 196608", count)
+	}
+}
+
+func TestDecodedX86PackedMultiplyLowMemoryAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		name       string
+		width64    bool
+		vectorBits byte
+		op         Op
+		laneBytes  int
+	}{
+		{name: "dword", vectorBits: 2, op: "VPMULLD.BCST.Z", laneBytes: 4},
+		{name: "qword", width64: true, vectorBits: 2, op: "VPMULLQ.BCST.Z", laneBytes: 8},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := encodeX86EVEXPackedMultiplyLow(test.width64, test.vectorBits, 3, true, 21, 20, 0)
+			code[3] |= 0x10
+			code[5] = 0x68
+			code = append(code, 0x7f)
+			got, length, ok, err := decodedX86PackedMultiplyLowInstruction(code, 64)
+			wantSource := fmt.Sprintf("%d(AX)", test.laneBytes*127)
+			if err != nil || !ok || length != len(code) || got.Op != test.op || len(got.Args) != 4 || got.Args[0].String() != wantSource || got.Args[1].String() != "Z20" || got.Args[2].String() != "K3" || got.Args[3].String() != "Z21" {
+				t.Fatalf("decode %x = %+v, length=%d ok=%v err=%v; want %s %s, Z20, K3, Z21", code, got, length, ok, err, test.op, wantSource)
+			}
+		})
+	}
+
+	for name, code := range map[string][]byte{
+		"truncated":    {0xc4, 0xe2},
+		"wrong map":    {0xc4, 0xe1, 0x79, 0x40, 0xc0},
+		"wrong pp":     {0xc4, 0xe2, 0x78, 0x40, 0xc0},
+		"wrong opcode": {0xc4, 0xe2, 0x79, 0x41, 0xc0},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86PackedMultiplyLowInstruction(code, 64); matched || decodeErr != nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, code, instruction, matched, decodeErr)
+		}
+	}
+	invalidBroadcast := encodeX86EVEXPackedMultiplyLow(false, 2, 1, false, 0, 0, 0)
+	invalidBroadcast[3] |= 0x10
+	if _, _, matched, decodeErr := decodedX86PackedMultiplyLowInstruction(invalidBroadcast, 64); !matched || decodeErr == nil {
+		t.Fatalf("register broadcast returned ok=%v err=%v", matched, decodeErr)
+	}
+	zeroWithoutMask := encodeX86EVEXPackedMultiplyLow(false, 2, 0, true, 0, 0, 0)
+	if _, _, matched, decodeErr := decodedX86PackedMultiplyLowInstruction(zeroWithoutMask, 64); !matched || decodeErr == nil {
+		t.Fatalf("zero without mask returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_muldiv_width_test.go b/amd64_raw_muldiv_width_test.go
new file mode 100644
index 000000000..518555666
--- /dev/null
+++ b/amd64_raw_muldiv_width_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawImplicitMulDivWidths(t *testing.T) {
+	for _, form := range []struct {
+		name   string
+		regBit byte
+	}{
+		{"MUL", 4}, {"IMUL", 5}, {"DIV", 6}, {"IDIV", 7},
+	} {
+		for _, width := range []struct {
+			name   string
+			prefix byte
+			opcode byte
+		}{
+			{"B", 0, 0xf6},
+			{"W", 0x66, 0xf7},
+			{"L", 0, 0xf7},
+			{"Q", 0x48, 0xf7},
+		} {
+			for _, memory := range []bool{false, true} {
+				name := fmt.Sprintf("%s%s/mem%t", form.name, width.name, memory)
+				t.Run(name, func(t *testing.T) {
+					var code []byte
+					if width.prefix != 0 {
+						code = append(code, width.prefix)
+					}
+					modRM := byte(0xc2 | form.regBit<<3)
+					if memory {
+						modRM = 0x02 | form.regBit<<3
+					}
+					code = append(code, width.opcode, modRM, 0xc3)
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(got) != 2 || string(got[0].Op) != form.name+width.name || got[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s", code, got, name)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawImplicitMulDivWidthsObjects(t *testing.T) {
+	var source strings.Builder
+	for index, code := range [][]byte{
+		{0xf6, 0xe2, 0xc3},
+		{0x66, 0xf7, 0xea, 0xc3},
+		{0xf7, 0xf2, 0xc3},
+		{0x48, 0xf7, 0xfa, 0xc3},
+	} {
+		name := fmt.Sprintf("rawMulDivWidth%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			original, signatures := x86UnboundVoidFormatSources(t, source.String(), "amd64", triple)
+			normalized, err := normalizeX86RawFile(original, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Original raw bytes and all public Context results stay bound
+			// above. These private units measure native encoding syntax only;
+			// they supply no implicit inputs or raw/native entry contract.
+			ir := x86InstructionFormatObjectUnit(t, normalized, signatures, "amd64", triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					if form, known, err := x86ImplicitDivideProperties(ins.Op, ins, "amd64"); known {
+						if err != nil {
+							return true, false, err
+						}
+						return true, false, c.emitNativeImplicitDivide(form)
+					}
+					terminated, err := c.lowerInstr(0, 0, ins, nil, nil)
+					return true, terminated, err
+				})
+			compileLLVMToObject(t, llc, triple, "raw-muldiv-width.ll", "raw-muldiv-width.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_mulword_test.go b/amd64_raw_mulword_test.go
new file mode 100644
index 000000000..f60615409
--- /dev/null
+++ b/amd64_raw_mulword_test.go
@@ -0,0 +1,273 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86PackedWordMultiplyGoRows = []struct {
+	mapID  byte
+	opcode byte
+	op     Op
+}{
+	{1, 0xd5, "VPMULLW"},
+	{1, 0xe5, "VPMULHW"},
+	{1, 0xe4, "VPMULHUW"},
+	{2, 0x0b, "VPMULHRSW"},
+}
+
+func encodeX86VEXPackedWordMultiply(mapID, opcode byte, width256, w bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	p0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | int(mapID))
+	p1 := byte(((^source1)&15)<<3 | int(l)<<2 | 1)
+	if w {
+		p1 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0xc4, p0, p1, opcode, modRM}
+}
+
+func encodeX86VEX2PackedWordMultiply(opcode byte, width256 bool, destination, source1, source2 int) []byte {
+	vectorBit := 0
+	if width256 {
+		vectorBit = 1
+	}
+	prefix := byte((1-destination/8)<<7 | (^source1&15)<<3 | vectorBit<<2 | 1)
+	modRM := byte(0xc0 | destination&7<<3 | source2&7)
+	return []byte{0xc5, prefix, opcode, modRM}
+}
+
+func encodeX86EVEXPackedWordMultiply(mapID, opcode byte, vectorBits, mask int, w, zeroing bool, destination, source1, source2 int) []byte {
+	p0 := byte((1-destination/8&1)<<7 | (1-source2/16)<<6 | (1-source2/8&1)<<5 | (1-destination/16)<<4 | int(mapID))
+	p1 := byte(((^source1)&15)<<3 | 5)
+	if w {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | ((^source1>>4)&1)<<3 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestTranslateRawVPMULHWOldCorpusRegression(t *testing.T) {
+	const source = `TEXT rawVPMULHW(SB), $0-0
+	LONG $0xe57161c4
+	BYTE $0xc6
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawVPMULHW": {Name: "rawVPMULHW", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mul <8 x i32>") || !strings.Contains(ir, "ashr <8 x i32>") {
+		t.Fatalf("raw VPMULHW omitted packed word multiply:\n%s", ir)
+	}
+}
+
+func TestTranslateRawVEX2PackedWordMultiplyGoccRegression(t *testing.T) {
+	const source = `TEXT rawVEX2WordMultiply(SB), $0-0
+	LONG $0xdbd5cdc5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawVEX2WordMultiply": {Name: "rawVEX2WordMultiply", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mul <16 x i16>") {
+		t.Fatalf("raw VEX2 VPMULLW omitted packed multiplication:\n%s", ir)
+	}
+}
+
+func TestDecodedX86PackedWordMultiplyCompleteGoRows(t *testing.T) {
+	if len(x86PackedMultiplyForms) != len(x86PackedWordMultiplyGoRows)+1 {
+		t.Fatalf("packed multiply grammar has %d rows, want four word rows plus D/Q", len(x86PackedMultiplyForms))
+	}
+	for _, row := range x86PackedWordMultiplyGoRows {
+		form, ok := x86PackedMultiplyFormFor(row.mapID, row.opcode)
+		if !ok || form.vexOp != row.op || form.evexW0Op != row.op || form.evexW1Op != row.op || form.broadcastByte != 0 {
+			t.Fatalf("Go word-multiply row %s/%02x is not modeled completely: %+v", row.op, row.opcode, form)
+		}
+		for _, width256 := range []bool{false, true} {
+			prefix := "X"
+			if width256 {
+				prefix = "Y"
+			}
+			for _, w := range []bool{false, true} {
+				code := encodeX86VEXPackedWordMultiply(row.mapID, row.opcode, width256, w, 8, 1, 6)
+				got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 64)
+				want := fmt.Sprintf("%s %s6, %s1, %s8", row.op, prefix, prefix, prefix)
+				if err != nil || !matched || length != len(code) || got.Raw != want {
+					t.Fatalf("VEX %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+				}
+			}
+			if row.mapID == 1 {
+				code := encodeX86VEX2PackedWordMultiply(row.opcode, width256, 8, 1, 6)
+				got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 64)
+				want := fmt.Sprintf("%s %s6, %s1, %s8", row.op, prefix, prefix, prefix)
+				if err != nil || !matched || length != len(code) || got.Raw != want {
+					t.Fatalf("VEX2 %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+				}
+			}
+		}
+		for vectorBits, prefix := range []string{"X", "Y", "Z"} {
+			for _, w := range []bool{false, true} {
+				for _, masked := range []bool{false, true} {
+					mask := 0
+					if masked {
+						mask = 2
+					}
+					code := encodeX86EVEXPackedWordMultiply(row.mapID, row.opcode, vectorBits, mask, w, masked, 21, 20, 22)
+					got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 64)
+					wantOp := string(row.op)
+					wantArgs := fmt.Sprintf("%s22, %s20, %s21", prefix, prefix, prefix)
+					if masked {
+						wantOp += ".Z"
+						wantArgs = fmt.Sprintf("%s22, %s20, K2, %s21", prefix, prefix, prefix)
+					}
+					want := wantOp + " " + wantArgs
+					if err != nil || !matched || length != len(code) || got.Raw != want {
+						t.Fatalf("EVEX %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86PackedWordMultiplyMemoryAndRejectedForms(t *testing.T) {
+	for _, row := range x86PackedWordMultiplyGoRows {
+		if row.mapID == 1 {
+			code := encodeX86VEX2PackedWordMultiply(row.opcode, true, 2, 1, 0)
+			code[3] = 0x50
+			code = append(code, 0x20)
+			got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 64)
+			want := fmt.Sprintf("%s 32(AX), Y1, Y2", row.op)
+			if err != nil || !matched || length != len(code) || got.Raw != want {
+				t.Fatalf("VEX2 memory %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+			}
+		}
+		code := encodeX86EVEXPackedWordMultiply(row.mapID, row.opcode, 2, 0, false, false, 21, 20, 0)
+		code[5] = 0x68
+		code = append(code, 0x7f)
+		got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 64)
+		want := fmt.Sprintf("%s 8128(AX), Z20, Z21", row.op)
+		if err != nil || !matched || length != len(code) || got.Raw != want {
+			t.Fatalf("memory %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+		}
+		broadcast := append([]byte(nil), code...)
+		broadcast[3] |= 0x10
+		if _, _, matched, err := decodedX86PackedMultiplyInstruction(broadcast, 64); !matched || err == nil {
+			t.Fatalf("word multiply incorrectly accepted EVEX broadcast %x", broadcast)
+		}
+		for vectorBits, prefix := range []string{"X", "Y"} {
+			code := encodeX86EVEXPackedWordMultiply(row.mapID, row.opcode, vectorBits, 0, false, false, 21, 20, 22)
+			got, length, matched, err := decodedX86PackedMultiplyInstruction(code, 32)
+			want := fmt.Sprintf("%s %s22, %s20, %s21", row.op, prefix, prefix, prefix)
+			if err != nil || !matched || length != len(code) || got.Raw != want {
+				t.Fatalf("386 high-register %x = %+v, length=%d matched=%v err=%v; want %s", code, got, length, matched, err, want)
+			}
+		}
+	}
+	invalidZeroing := encodeX86EVEXPackedWordMultiply(1, 0xe5, 0, 0, false, true, 0, 1, 2)
+	if _, _, matched, err := decodedX86PackedMultiplyInstruction(invalidZeroing, 64); !matched || err == nil {
+		t.Fatalf("zero without mask accepted: %x", invalidZeroing)
+	}
+	invalidLength := encodeX86EVEXPackedWordMultiply(1, 0xe5, 3, 0, false, false, 0, 1, 2)
+	if _, _, matched, err := decodedX86PackedMultiplyInstruction(invalidLength, 64); !matched || err == nil {
+		t.Fatalf("reserved vector length accepted: %x", invalidLength)
+	}
+	for _, code := range [][]byte{
+		{0xc4, 0xe3, 0x79, 0xe5, 0xc0},
+		{0xc4, 0xe1, 0x78, 0xe5, 0xc0},
+		{0xc4, 0xe1, 0x79, 0xe6, 0xc0},
+	} {
+		if got, _, matched, err := decodedX86PackedMultiplyInstruction(code, 64); matched || err != nil {
+			t.Fatalf("invalid opcode form %x decoded as %+v, matched=%v err=%v", code, got, matched, err)
+		}
+	}
+}
+
+func TestTranslateRawPackedWordMultiplyLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawPackedWordMultiply(SB), $0-0\n")
+			appendBytes := func(code []byte) {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			for _, row := range x86PackedWordMultiplyGoRows {
+				for _, width256 := range []bool{false, true} {
+					appendBytes(encodeX86VEXPackedWordMultiply(row.mapID, row.opcode, width256, false, 2, 1, 0))
+					if row.mapID == 1 {
+						appendBytes(encodeX86VEX2PackedWordMultiply(row.opcode, width256, 2, 1, 0))
+					}
+				}
+				for vectorBits := 0; vectorBits < 3; vectorBits++ {
+					mask := 3
+					zeroing := true
+					if target.goarch == "386" {
+						mask = 0
+						zeroing = false
+					}
+					destination, second, first := 21, 20, 22
+					if target.goarch == "386" {
+						destination, second, first = 2, 1, 0
+					}
+					appendBytes(encodeX86EVEXPackedWordMultiply(row.mapID, row.opcode, vectorBits, mask, false, zeroing, destination, second, first))
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawPackedWordMultiply": {Name: "rawPackedWordMultiply", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-packed-word-multiply.ll", "raw-packed-word-multiply.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_narrow_single_source.go b/amd64_raw_narrow_single_source.go
new file mode 100644
index 000000000..e13caebc0
--- /dev/null
+++ b/amd64_raw_narrow_single_source.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27's _yvpmovdb/_yvpmovdw rows form a three-by-six grammar:
+// unsigned-saturating, signed-saturating and truncating conversions, each
+// narrowing W/D/Q into B/W/D. The low opcode nibble selects the width pair.
+var x86RawSingleSourceNarrowOps = [3][6]Op{
+	{"VPMOVUSWB", "VPMOVUSDB", "VPMOVUSQB", "VPMOVUSDW", "VPMOVUSQW", "VPMOVUSQD"},
+	{"VPMOVSWB", "VPMOVSDB", "VPMOVSQB", "VPMOVSDW", "VPMOVSQW", "VPMOVSQD"},
+	{"VPMOVWB", "VPMOVDB", "VPMOVQB", "VPMOVDW", "VPMOVQW", "VPMOVQD"},
+}
+
+func decodedX86SingleSourceNarrowInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || !p.evex || p.mapNumber != 2 || p.pp != 2 {
+		return Instr{}, 0, false, nil
+	}
+	group := p.opcode>>4 - 1
+	width := p.opcode & 15
+	if group < 0 || group >= len(x86RawSingleSourceNarrowOps) || width >= 6 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("single-source narrowing: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.w || p.upper != 0 || p.broadcast || p.vectorLength > 2 {
+		return fail("invalid reserved EVEX encoding bit")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+
+	baseOp := x86RawSingleSourceNarrowOps[group][width]
+	spec := amd64SingleSourceNarrowSpecs[string(baseOp)]
+	inputBytes := 16 << p.vectorLength
+	outputBytes := inputBytes * spec.outputBits / spec.inputBits
+	destinationPrefix := "X"
+	if outputBytes > 16 {
+		destinationPrefix = "Y"
+	}
+	modRM := code[p.modRM]
+	registerNumber := int(modRM>>3&7) + p.r*8
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", [...]string{"X", "Y", "Z"}[p.vectorLength], registerNumber))}
+	if mode == 32 && p.vectorLength == 2 && registerNumber >= 8 {
+		return fail("386 Z source register exceeds Go's encoder class")
+	}
+	if mode == 32 && modRM>>6 != 3 && (p.b != 0 || p.x != 0) {
+		return fail("extended memory address in 32-bit mode")
+	}
+	destination, consumed, err := decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, destinationPrefix, outputBytes)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := baseOp
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_narrow_single_source_test.go b/amd64_raw_narrow_single_source_test.go
new file mode 100644
index 000000000..19ed71037
--- /dev/null
+++ b/amd64_raw_narrow_single_source_test.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawSingleSourceNarrow(group, width, vectorBits, source, destination, mask int, zeroing, memory bool) []byte {
+	if memory {
+		destination = 0
+	}
+	p0 := byte((1-source/8&1)<<7 | (1-destination/16)<<6 |
+		(1-destination/8&1)<<5 | (1-source/16)<<4 | 2)
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (source&7)<<3 | destination&7)
+	if memory {
+		modRM = byte(0x40 | (source&7)<<3)
+	}
+	code := []byte{0x62, p0, 0x7e, p2, byte((group+1)<<4 | width), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestTranslateRawNarrowSingleSourceGorseRegression(t *testing.T) {
+	const source = `TEXT rawNarrowSingleSource(SB), $0-0
+	LONG $0x487ef262
+	WORD $0x2c11
+	BYTE $0x07
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawNarrowSingleSource": {Name: "rawNarrowSingleSource", Ret: Void}},
+	})
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original raw regression invented native input registers/address", err)
+	}
+	decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file.Funcs[0] = decoded
+	units, signatures := x86SingleSourceNarrowingFormatUnits(file)
+	if len(units.Funcs) != 1 {
+		t.Fatal("original physical regression lost its single conversion", len(units.Funcs))
+	}
+	ir = x86SingleInstructionFormatObjectUnits(t, units, signatures, "amd64", "x86_64-unknown-linux-gnu",
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerSingleSourceIntegerNarrow(ins.Op, ins) })
+	if !strings.Contains(ir, "icmp ugt") {
+		t.Fatal("raw VPMOVUSDB format omitted unsigned input saturation")
+	}
+}
+
+func TestDecodedX86RawSingleSourceNarrowCompleteGoRows(t *testing.T) {
+	if len(amd64SingleSourceNarrowSpecs) != 18 {
+		t.Fatalf("Go 1.27 single-source narrowing grammar has %d members, want 18", len(amd64SingleSourceNarrowSpecs))
+	}
+	inputBits := [...]int{16, 32, 64, 32, 64, 64}
+	outputBits := [...]int{8, 8, 8, 16, 16, 32}
+	seen := make(map[Op]bool)
+	for group, row := range x86RawSingleSourceNarrowOps {
+		for width, op := range row {
+			spec, ok := amd64SingleSourceNarrowSpecs[string(op)]
+			if !ok || seen[op] || spec.inputBits != inputBits[width] || spec.outputBits != outputBits[width] ||
+				spec.domain != [...]x86SingleSourceNarrowDomain{x86NarrowUnsigned, x86NarrowSigned, x86NarrowTruncate}[group] {
+				t.Fatalf("raw opcode row %d/%d = %s, spec %+v", group, width, op, spec)
+			}
+			seen[op] = true
+			for vectorBits, prefix := range [...]string{"X", "Y", "Z"} {
+				outputBytes := (16 << vectorBits) * spec.outputBits / spec.inputBits
+				outputPrefix := "X"
+				if outputBytes > 16 {
+					outputPrefix = "Y"
+				}
+				for _, memory := range []bool{false, true} {
+					for _, masked := range []bool{false, true} {
+						mask := 0
+						if masked {
+							mask = 3
+						}
+						for _, zeroing := range []bool{false, true} {
+							if zeroing && !masked {
+								continue
+							}
+							code := encodeX86RawSingleSourceNarrow(group, width, vectorBits, 21, 20, mask, zeroing, memory)
+							got, length, recognized, err := decodedX86SingleSourceNarrowInstruction(code, 64)
+							if err != nil || !recognized || length != len(code) {
+								t.Fatalf("decode %x = %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+							}
+							wantOp := op
+							if zeroing {
+								wantOp += ".Z"
+							}
+							if got.Op != wantOp || got.Args[0].String() != fmt.Sprintf("%s21", prefix) {
+								t.Fatalf("decode %x = %+v, want %s and %s21", code, got, wantOp, prefix)
+							}
+							if masked && (len(got.Args) != 3 || got.Args[1].String() != "K3") || !masked && len(got.Args) != 2 {
+								t.Fatalf("decode %x = %+v, lost mask", code, got)
+							}
+							destination := got.Args[len(got.Args)-1]
+							if memory {
+								if destination.Kind != OpMem || destination.Mem.Base != AX || destination.Mem.Off != int64(outputBytes) {
+									t.Fatalf("decode %x = %+v, want compressed displacement %d", code, got, outputBytes)
+								}
+							} else if destination.String() != fmt.Sprintf("%s20", outputPrefix) {
+								t.Fatalf("decode %x = %+v, want %s20", code, got, outputPrefix)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(seen) != len(amd64SingleSourceNarrowSpecs) {
+		t.Fatalf("raw grammar has %d distinct ops, named lowerer has %d", len(seen), len(amd64SingleSourceNarrowSpecs))
+	}
+}
+
+func TestDecodedX86RawSingleSourceNarrowRejectsReservedBits(t *testing.T) {
+	base := encodeX86RawSingleSourceNarrow(0, 1, 2, 2, 1, 3, true, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"W bit", []byte{base[0], base[1], base[2] | 0x80, base[3], base[4], base[5]}},
+		{"fixed bit", []byte{base[0], base[1], base[2] &^ 4, base[3], base[4], base[5]}},
+		{"vvvv", []byte{base[0], base[1], base[2] &^ 8, base[3], base[4], base[5]}},
+		{"V prime", []byte{base[0], base[1], base[2], base[3] &^ 8, base[4], base[5]}},
+		{"broadcast", []byte{base[0], base[1], base[2], base[3] | 0x10, base[4], base[5]}},
+		{"reserved length", []byte{base[0], base[1], base[2], base[3] | 0x20, base[4], base[5]}},
+		{"zero without mask", []byte{base[0], base[1], base[2], base[3] &^ 7, base[4], base[5]}},
+		{"missing ModRM", base[:5]},
+		{"address override", append([]byte{0x67}, base...)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86SingleSourceNarrowInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted reserved encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+	if _, _, recognized, err := decodedX86PerLaneVariableShiftInstruction(base, 64); recognized || err != nil {
+		t.Fatalf("per-lane shift incorrectly owns F3 narrow opcode: recognized=%v err=%v", recognized, err)
+	}
+}
+
+func TestTranslateRawSingleSourceNarrowLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawNarrowFamily(SB), $0-0\n")
+			appendBytes := func(code []byte) {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			for group, row := range x86RawSingleSourceNarrowOps {
+				for width := range row {
+					appendBytes(encodeX86RawSingleSourceNarrow(group, width, 0, 2, 1, 0, false, false))
+				}
+				appendBytes(encodeX86RawSingleSourceNarrow(group, 5, 2, 2, 1, 2, true, false))
+				appendBytes(encodeX86RawSingleSourceNarrow(group, 1, 1, 2, 0, 3, false, true))
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawNarrowFamily": {Name: "rawNarrowFamily", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("bare raw formats invented initialized native entry values", err)
+			}
+			decoded, err := decodeX86RawDirectives(file.Funcs[0], target.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file.Funcs[0] = decoded
+			units, signatures := x86SingleSourceNarrowingFormatUnits(file)
+			if len(units.Funcs) != 24 {
+				t.Fatal("original physical family format disappeared", len(units.Funcs))
+			}
+			x86SingleSourceNarrowingFormatObjects(t, llc, units, signatures, target.goarch, target.triple)
+		})
+	}
+}
diff --git a/amd64_raw_near_return.go b/amd64_raw_near_return.go
new file mode 100644
index 000000000..4e3680f50
--- /dev/null
+++ b/amd64_raw_near_return.go
@@ -0,0 +1,449 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type x86RawNearReturnForm struct {
+	nativeWidth bool
+	cleanup     uint16
+}
+
+// x86RawStaticRead is produced only by a source-local RIP decoder after its
+// complete encoding grammar and access width have been validated. It is not a
+// mnemonic whitelist, a general pointer contract, or permission to store.
+type x86RawStaticRead struct {
+	op     Op
+	source int
+	width  int64
+	symbol string
+	offset int64
+	object []byte
+	args   []Operand
+}
+
+// Only the normalizer's symbol relocation may change a proved operand. Keep
+// an independent snapshot so a caller's edited File cannot authorize a wider
+// vector access, a different mask, or an out-of-range proof index.
+func rebindX86RawStaticRead(ins *Instr, source int, symbol string) error {
+	if source < 0 || source >= len(ins.Args) {
+		return fmt.Errorf("%w: invalid raw static read operand", ErrProbeNeedsContext)
+	}
+	read := ins.x86RIPMemoryRead
+	if read.width != 0 {
+		if read.source != source || read.op != ins.Op || !reflect.DeepEqual(read.args, ins.Args) {
+			return fmt.Errorf("%w: changed raw static read cannot inherit decoder proof", ErrProbeNeedsContext)
+		}
+		read.args = append([]Operand(nil), read.args...)
+		read.args[source].Sym = symbol
+		read.symbol = symbol
+		ins.x86RIPMemoryRead = read
+	}
+	ins.Args[source].Sym = symbol
+	return nil
+}
+
+// C3 and C2 imm16 use the target's native return-PC width. Operand-size
+// overrides and other prefixes require their own physical entry contract;
+// successful decoding alone does not make them ordinary Go/C returns.
+func x86RawNearReturnEncoding(code []byte) x86RawNearReturnForm {
+	if len(code) == 1 && code[0] == 0xc3 {
+		return x86RawNearReturnForm{nativeWidth: true}
+	}
+	if len(code) == 3 && code[0] == 0xc2 {
+		return x86RawNearReturnForm{nativeWidth: true, cleanup: binary.LittleEndian.Uint16(code[1:])}
+	}
+	return x86RawNearReturnForm{}
+}
+
+func validateX86RawNearReturns(fn Func, file *File, opt Options, bindFrame bool) error {
+	hasReturn := false
+	for _, ins := range fn.Instrs {
+		form := ins.x86RawNearReturn
+		if form == nil {
+			continue
+		}
+		hasReturn = true
+		if !form.nativeWidth || form.cleanup != 0 {
+			return fmt.Errorf("%w: raw near RET needs a physical return-width and caller-stack cleanup contract: %q", ErrProbeNeedsContext, ins.Raw)
+		}
+	}
+	if !hasReturn {
+		return nil
+	}
+	name := fn.Sym
+	if opt.ResolveSym != nil {
+		name = opt.ResolveSym(name)
+	}
+	if bindFrame && x86SourceStackBoolCandidate(fn, opt.Sigs[name]) &&
+		(fn.x86SourceStack == nil || fn.x86SourceStack.scalarResult == nil) {
+		return fmt.Errorf("%w: raw ABI0 bool RET requires its complete typed canonical source-stack proof; %s", ErrProbeNeedsContext, fn.x86SourceStackFailure)
+	}
+	// The raw instruction bypasses obj6's RET epilogue. A zero-sized,
+	// stack-unobserving leaf has the same return-PC location as its caller.
+	// All other cases need a native frame/continuation contract, not a guessed
+	// epilogue or an inline RET inside LLVM's independently allocated frame.
+	if fn.FrameSize != 0 || (!x86RawReturnLeafStackUnobserved(fn) && fn.x86SourceStack == nil) {
+		diagnostic := ""
+		if fn.x86SourceStackFailure != "" {
+			diagnostic = "; " + fn.x86SourceStackFailure
+		}
+		return fmt.Errorf("%w: raw near RET requires a proved source stack/continuation; Go's TEXT frame epilogue is not encoded in raw bytes%s", ErrProbeNeedsContext, diagnostic)
+	}
+	if !x86RawReturnMemoryBound(fn, file, opt, bindFrame) {
+		return fmt.Errorf("%w: raw near RET needs bounded typed FP/static memory; ordinary pointers have no native return-PC nonalias contract", ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+// This bounded contract does not infer noalias from a Go pointer type or a
+// register value. It proves only scalar MOV accesses to bound FP slots or a
+// same-file static object, and shared raw decoders' exact source-local reads.
+// Other memory forms need their own complete effects and access-range proof.
+// In particular, this is not a general store whitelist.
+func x86RawReturnMemoryBound(fn Func, file *File, opt Options, bindFrame bool) bool {
+	name := fn.Sym
+	if opt.ResolveSym != nil {
+		name = opt.ResolveSym(name)
+	}
+	sig := opt.Sigs[name]
+	caller := bindFrame && x86CallerNormalizedSourceMatches(fn, sig)
+	if fn.x86SourceStack != nil && fn.x86SourceStack.caller != nil && !caller {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86RawMOVSXDNeedsCaller && !caller {
+			return false // A native width is not an initialized GP-input proof.
+		}
+		read := ins.x86RIPMemoryRead
+		if read.width != 0 && (opt.Goarch == "386" || !x86RawReturnDecodedReadBound(ins, file)) {
+			return false
+		}
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		if _, extension := amd64ScalarExtensionMoveSpecs[op]; extension && !caller && !ins.x86Encoded {
+			// A named extension gains new source-frame effects only through
+			// actual typed caller input availability. Keep the old separately
+			// bound physical/RIP decoder contract distinct from that producer.
+			return false
+		}
+		if _, _, _, memory := x86StringProperties(op); memory {
+			return false
+		}
+		if _, _, memory := x86PortStringProperties(op); memory {
+			return false
+		}
+		if _, memory := amd64ImplicitMaskMoveSpecs[op]; memory || op == "XLAT" {
+			return false
+		}
+		for index, arg := range ins.Args {
+			switch arg.Kind {
+			case OpMem:
+				if caller {
+					if !x86CallerMemoryCertified(ins, index) && op != "LEAW" && op != "LEAL" && op != "LEAQ" {
+						return false
+					}
+					// Caller pointers require their own exact access certificate,
+					// including physical-SP imports. The old numerical FP proof
+					// is not an alternative permission after that certificate is lost.
+					continue
+				}
+				if offset, proved := ins.x86SourceStackFP[index]; bindFrame && fn.x86SourceStack != nil && proved &&
+					x86RawReturnFPBound(offset, x86ScalarMoveMemoryBytes(ins, index, opt.Goarch), sig, opt.Goarch) {
+					continue // Instruction-local, freshly recomputed physical-SP slot proof.
+				}
+				if !bindFrame && fn.x86SourceStack != nil && x86RawReturnStackMemory(arg.Mem) && x86ScalarMoveMemoryBytes(ins, index, opt.Goarch) != 0 {
+					continue // Pure preparation; final normalization binds the exact slot for lowering.
+				}
+				// Even a static symbol plus an index is not a bounded object.
+				// Address-only register expressions have no dereference, but
+				// their later uses still have to satisfy this same contract.
+				if op != "LEAW" && op != "LEAL" && op != "LEAQ" {
+					return false
+				}
+			case OpFP:
+				if caller {
+					if !x86CallerMemoryCertified(ins, index) {
+						return false
+					}
+					continue
+				}
+				if !bindFrame {
+					continue // Pure prepartition normalization retains metadata.
+				}
+				if fn.x86SourceStack == nil && fn.x86FixedLocal == nil &&
+					x86RawReturnMaskParameterReadBound(ins, index, sig, opt.Goarch) {
+					continue // Exact logical numeric input bytes, not native frame/pointer permission.
+				}
+				width := x86ScalarMoveMemoryBytes(ins, index, opt.Goarch)
+				if width == 0 || !x86RawReturnFPBound(arg.FPOffset, width, sig, opt.Goarch) {
+					return false
+				}
+			case OpSym:
+				if read.width != 0 && read.source == index {
+					continue // Exact source and allocated bytes were checked above.
+				}
+				symbol := strings.TrimSpace(arg.Sym)
+				if strings.HasPrefix(symbol, "$") || ins.Op == OpTEXT || ins.Op == OpLABEL {
+					continue
+				}
+				if op == "LEAW" || op == "LEAL" || op == "LEAQ" {
+					continue // Address formation, like OpMem LEA; not a read.
+				}
+				base, offset, static := parseSBRef(symbol)
+				if !static {
+					continue // Non-memory control operands retain their own checks.
+				}
+				if !x86RawReturnStaticBound(base, offset, x86ScalarMoveMemoryBytes(ins, index, opt.Goarch), file) {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+func x86RawReturnDecodedReadIdentity(ins Instr) bool {
+	read := ins.x86RIPMemoryRead
+	if !ins.x86Encoded || !ins.x86RIPLiteral ||
+		read.op != ins.Op || read.source < 0 || read.source >= len(ins.Args) ||
+		!reflect.DeepEqual(read.args, ins.Args) ||
+		read.width <= 0 || read.offset < 0 ||
+		read.width > int64(len(read.object)) || read.offset > int64(len(read.object))-read.width {
+		return false
+	}
+	operand := ins.Args[read.source]
+	if operand.Kind != OpSym || operand.Sym != read.symbol {
+		return false
+	}
+	if len(ins.x86RIPLiteralData) != 0 &&
+		!bytes.Equal(ins.x86RIPLiteralData, read.object[read.offset:read.offset+read.width]) {
+		return false
+	}
+	return true
+}
+
+func x86RawReturnDecodedReadBound(ins Instr, file *File) bool {
+	if file == nil || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	read := ins.x86RIPMemoryRead
+	symbol, offset, ok := parseSBRef(ins.Args[read.source].Sym)
+	if !ok || offset != read.offset || !x86RawReturnStaticBound(symbol, offset, read.width, file) {
+		return false
+	}
+	// Re-normalization and bounded module partitioning retain the data. Do
+	// not use stale constant-specialization bytes after a caller changes it.
+	matched := false
+	for _, datum := range file.Data {
+		if datum.Sym != symbol {
+			continue
+		}
+		if matched || datum.Off != 0 || datum.Width != int64(len(read.object)) || datum.Addr != "" ||
+			!bytes.Equal(datum.Payload, read.object) {
+			return false
+		}
+		matched = true
+	}
+	return matched
+}
+
+func x86RawReturnScalarMoveBytes(op Op) int64 {
+	switch op {
+	case "MOVB":
+		return 1
+	case "MOVW":
+		return 2
+	case "MOVL":
+		return 4
+	case "MOVQ":
+		return 8
+	default:
+		return 0
+	}
+}
+
+func x86RawReturnFPBound(offset, width int64, sig FuncSig, goarch string) bool {
+	if offset < 0 || width <= 0 {
+		return false
+	}
+	const maxOffset = int64(1<<63 - 1)
+	var checked []FrameSlot
+	matched := false
+	for group, slots := range [][]FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for _, slot := range slots {
+			size := x86RawReturnSlotBytes(slot.Type, goarch)
+			if !x86RawReturnSlotMatchesSignature(slot, group, sig) || size == 0 ||
+				slot.Offset < 0 || slot.Offset > maxOffset-size {
+				return false
+			}
+			for _, previous := range checked {
+				previousSize := x86RawReturnSlotBytes(previous.Type, goarch)
+				if slot.Offset < previous.Offset+previousSize && previous.Offset < slot.Offset+size {
+					return false
+				}
+			}
+			checked = append(checked, slot)
+			// Exact whole-slot moves avoid relying on generic partial FP writes
+			// preserving the untouched high bytes. This does not repair those
+			// writes elsewhere in the translator.
+			matched = matched || slot.Offset == offset && width == size
+		}
+	}
+	return matched
+}
+
+func x86RawReturnSlotMatchesSignature(slot FrameSlot, group int, sig FuncSig) bool {
+	if slot.Index < 0 {
+		return false
+	}
+	path := frameSlotFields(slot)
+	if group == 0 {
+		if slot.Index >= len(sig.Args) {
+			return false
+		}
+		typ := sig.Args[slot.Index]
+		if len(path) != 0 {
+			// Reuse the existing flat literal-aggregate grammar. Nested paths
+			// and arrays need a richer validated binding, not a new guessed
+			// layout parser inside the native-return proof.
+			fields, aggregate := parseLiteralStructFields(typ)
+			if !aggregate || len(path) != 1 || path[0] < 0 || path[0] >= len(fields) {
+				return false
+			}
+			typ = fields[path[0]]
+		}
+		return slot.Type == typ
+	}
+	// Classic result slots index the already flattened return tuple. Field
+	// paths are parameter extraction metadata, not a result-slot binding.
+	if sig.Ret == Void || sig.Ret == "" || len(path) != 0 {
+		return false
+	}
+	if fields, aggregate := parseLiteralStructFields(sig.Ret); aggregate {
+		return slot.Index < len(fields) && slot.Type == fields[slot.Index]
+	}
+	return slot.Index == 0 && slot.Type == sig.Ret
+}
+
+func x86RawReturnSlotBytes(typ LLVMType, goarch string) int64 {
+	return x86FrameScalarBytes(typ, goarch)
+}
+
+func x86RawReturnStaticBound(symbol string, offset, width int64, file *File) bool {
+	if file == nil || offset < 0 || width <= 0 {
+		return false
+	}
+	var size int64
+	for _, object := range file.Globl {
+		if object.Sym != symbol {
+			continue
+		}
+		if object.SizeRaw != "" || object.Size < 0 || object.Size > maxDataGlobalSize {
+			return false
+		}
+		if object.Size > size {
+			size = object.Size
+		}
+	}
+	// Match the actual DATA allocation consumer. DATA without a GLOBL still
+	// creates a same-file byte object; holes are initialized to zero. Reuse
+	// its existing checked extent rather than guessing a fixed object size.
+	for _, datum := range file.Data {
+		if datum.Sym != symbol {
+			continue
+		}
+		end, err := dataStmtEnd(datum)
+		if err != nil {
+			return false
+		}
+		if end > size {
+			size = end
+		}
+	}
+	return size >= width && offset <= size-width
+}
+
+func x86RawReturnLeafStackUnobserved(fn Func) bool {
+	hasText := false
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpTEXT {
+			hasText = true
+			_, rest := splitOpcode(ins.Raw)
+			parts := strings.Split(rest, ",")
+			if len(parts) == 3 {
+				expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+					if value, ok := goTextFlagValues[name]; ok {
+						return value
+					}
+					return name
+				})
+				flags, known := parseImmExpr(strings.TrimSpace(expression))
+				if !known || flags & ^uint64(2|4|512) != 0 {
+					return false
+				}
+			} else if len(parts) != 2 {
+				return false
+			}
+			continue
+		}
+		if x86SourceGOperand(ins) {
+			// Stack-unobserving does not mean native-context-unobserving.
+			// Incoming g is opaque; numerical use or clobber needs the same
+			// complete caller and exact saved-identity proof as a framed leaf.
+			return false
+		}
+		op := strings.ToUpper(string(ins.Op))
+		if strings.HasPrefix(op, "PUSH") || strings.HasPrefix(op, "POP") ||
+			strings.HasPrefix(op, "IRET") || strings.HasPrefix(op, "RETF") {
+			return false
+		}
+		switch Op(op) {
+		case OpCALL, "ADJSP", "ENTER", "ENTERL", "ENTERQ", "ENTERW", "LEAVEL", "LEAVEQ", "LEAVEW":
+			return false
+		case OpRET:
+			if len(ins.Args) != 0 {
+				return false
+			}
+		case OpJMP:
+			if len(ins.Args) != 1 || (ins.Args[0].Kind != OpIdent && ins.Args[0].Kind != OpLabel) {
+				return false
+			}
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFPAddr || (operand.Kind == OpFP && operand.FPOffset < 0) {
+				return false
+			}
+			if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+				return false
+			}
+			if operand.Kind == OpMem && x86RawReturnStackMemory(operand.Mem) {
+				return false
+			}
+			// Go's effective-address immediate is OpSym, not OpMem. Use the
+			// same parser and typed register roots as its actual lowering.
+			if operand.Kind == OpSym {
+				symbol := strings.TrimSpace(operand.Sym)
+				if strings.HasPrefix(symbol, "$") {
+					address, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(symbol, "$")))
+					if ok && x86RawReturnStackMemory(address) {
+						return false
+					}
+				}
+			}
+		}
+	}
+	return hasText
+}
+
+func x86RawReturnStackRegister(reg Reg) bool {
+	root, known := amd64FullRegBase(reg)
+	return known && (root == SP || root == BP)
+}
+
+func x86RawReturnStackMemory(memory MemRef) bool {
+	return x86RawReturnStackRegister(memory.Base) || x86RawReturnStackRegister(memory.Index)
+}
diff --git a/amd64_raw_near_return_runtime_test.go b/amd64_raw_near_return_runtime_test.go
new file mode 100644
index 000000000..0676e27cb
--- /dev/null
+++ b/amd64_raw_near_return_runtime_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Observe C2's real caller-SP effect with a source-native continuation. The
+// trampoline restores the original SP before returning to the Go runtime.
+// It is an independent machine-code witness, not a translated C tail call.
+func x86RawNearReturnGoStackOracle(t *testing.T, arch string, runPrefix []string) {
+	t.Helper()
+	move, sub, add, address := "MOVQ", "SUBQ", "ADDQ", "LEAQ"
+	wordBytes := 8
+	if arch == "386" {
+		move, sub, add, address = "MOVL", "SUBL", "ADDL", "LEAL"
+		wordBytes = 4
+	}
+	var assembly strings.Builder
+	for _, cleanup := range []int{0, 4} {
+		fmt.Fprintf(&assembly, `TEXT ·Measure%d(SB),516,$0-%d
+%s SP,BX
+%s $16,SP
+%s resume%d<>(SB),AX
+%s AX,0(SP)
+JMP native%d<>(SB)
+TEXT native%d<>(SB),516,$0-0
+BYTE $0xc2
+WORD $%d
+TEXT resume%d<>(SB),516,$0-0
+%s SP,AX
+%s BX,AX
+%s $%d,AX
+%s BX,SP
+%s AX,ret+0(FP)
+RET
+`, cleanup, wordBytes, move, sub, address, cleanup, move, cleanup, cleanup,
+			cleanup, cleanup, move, sub, add, 16-wordBytes, move, move)
+	}
+	for _, encoding := range []struct{ name, code string }{
+		{"C3", "BYTE $0xc3"}, {"C2", "BYTE $0xc2\nWORD $0"},
+	} {
+		fmt.Fprintf(&assembly, `TEXT ·Result%s(SB),4,$0-4
+CALL value%s<>(SB)
+MOVL AX,ret+0(FP)
+RET
+TEXT value%s<>(SB),4,$0-0
+MOVL $17,AX
+%s
+RET
+`, encoding.name, encoding.name, encoding.name, encoding.code)
+	}
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":                "module example.com/rawreturn\n\ngo 1.20\n",
+		"oracle_" + arch + ".s": assembly.String(),
+		"oracle_test.go": `package rawreturn
+import "testing"
+func Measure0() int
+func Measure4() int
+func ResultC2() int32
+func ResultC3() int32
+func TestActualMachineStack(t *testing.T) {
+  if delta := Measure0(); delta != 0 { t.Fatalf("C2 zero cleanup: SP delta %d", delta) }
+  if delta := Measure4(); delta != 4 { t.Fatalf("C2 imm16=4: SP delta %d", delta) }
+  if ResultC2() != 17 || ResultC3() != 17 { t.Fatal("zero-cleanup raw return lost AX") }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"test", "-vet=off", "-count=1"}
+	if len(runPrefix) != 0 {
+		args = append(args, "-exec", strings.Join(runPrefix, " "))
+	}
+	args = append(args, ".")
+	cmd := exec.Command("go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH="+arch, "CGO_ENABLED=0", "GODEBUG=asyncpreemptoff=1")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go %s raw-return stack oracle: %v\n%s", arch, err, out)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawNearReturn(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("x86 source-stack oracle runs in the required Linux/amd64 cross-runtime gate")
+	}
+	x86RawNearReturnGoStackOracle(t, "amd64", nil)
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var runPrefix []string
+	if crossRosetta {
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	var source strings.Builder
+	for _, encoding := range []struct{ name, code string }{
+		{"rawC3", "BYTE $0xc3"}, {"rawC2", "BYTE $0xc2\nWORD $0"},
+	} {
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\nMOVL $17,AX\n%s\nRET\n", encoding.name, encoding.code)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawC3": {Name: "rawC3", Ret: I32}, "rawC2": {Name: "rawC2", Ret: I32}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+extern int32_t rawC2(void), rawC3(void);
+int main(void) {
+  for (unsigned i=0; i<1024; i++) {
+    volatile uint64_t canary = UINT64_C(0x123456789abcdef0);
+    if (rawC2()!=17 || rawC3()!=17 || canary!=UINT64_C(0x123456789abcdef0)) return 1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_near_return", triple, ir, main, runPrefix)
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" {
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+			t.Fatal("PLAN9ASM_CROSS_EXEC raw-return matrix requires Linux/amd64")
+		}
+		x86RawNearReturnGoStackOracle(t, "386", []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+		ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"rawC3": {Name: "rawC3", Ret: I32}, "rawC2": {Name: "rawC2", Ret: I32}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc", "-no-pie"},
+			"raw_near_return386", "i386-unknown-linux-gnu", ir, main, []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+	}
+}
diff --git a/amd64_raw_near_return_test.go b/amd64_raw_near_return_test.go
new file mode 100644
index 000000000..a15fdc490
--- /dev/null
+++ b/amd64_raw_near_return_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86RawNearReturnCompleteImmediateEncoding(t *testing.T) {
+	if form := x86RawNearReturnEncoding([]byte{0xc3}); !form.nativeWidth || form.cleanup != 0 {
+		t.Fatalf("C3 has no caller cleanup: %+v", form)
+	}
+	code := []byte{0xc2, 0, 0}
+	for cleanup := 0; cleanup <= 65535; cleanup++ {
+		binary.LittleEndian.PutUint16(code[1:], uint16(cleanup))
+		form := x86RawNearReturnEncoding(code)
+		if !form.nativeWidth || form.cleanup != uint16(cleanup) {
+			t.Fatalf("C2 imm16=%d was changed: %+v", cleanup, form)
+		}
+	}
+	for _, code := range [][]byte{nil, {0xc2}, {0xc2, 0}, {0xcb}, {0xca, 0, 0}, {0x66, 0xc3}, {0xf2, 0xc3}, {0xf3, 0xc3}, {0x48, 0xc3}} {
+		if x86RawNearReturnEncoding(code).nativeWidth {
+			t.Errorf("unproved/truncated near return %x became an ordinary return", code)
+		}
+	}
+}
+
+var x86RawReturnTargets = []struct {
+	arch   string
+	triple string
+}{
+	{"386", "i386-unknown-linux-gnu"},
+	{"386", "i686-pc-windows-msvc"},
+	{"amd64", "x86_64-apple-darwin"},
+	{"amd64", "x86_64-unknown-linux-gnu"},
+	{"amd64", "x86_64-pc-windows-msvc"},
+}
+
+func TestX86RawNearReturnNeedsNativeStackContract(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, cleanup := range []uint16{1, 4, 255, 256, 65535} {
+			t.Run(fmt.Sprintf("%s/pop%d", target.triple, cleanup), func(t *testing.T) {
+				// Unlike textual RET $n, these are valid Go BYTE/WORD inputs.
+				// C2 pops the return PC and then adds imm16 to the caller SP.
+				source := fmt.Sprintf("TEXT rawret(SB),4,$0-0\nBYTE $0xc2\nWORD $%d\nRET\n", cleanup)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"rawret": {Name: "rawret", Ret: Void}}}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("native caller cleanup=%d must remain Context, got %v", cleanup, err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("module API lost native cleanup=%d contract, got %v", cleanup, err)
+				}
+				if err := ProbeInstructionSequence(ArchAMD64, target.arch, file.Funcs[0].Instrs[1:3]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("isolated raw cleanup became an ordinary return: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawNearReturnCannotInventGoEpilogue(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, push, pop := "MOVQ", "PUSHQ", "POPQ"
+		if target.arch == "386" {
+			move, push, pop = "MOVL", "PUSHL", "POPL"
+		}
+		for _, source := range []string{
+			"TEXT rawret(SB),4,$8-0\nBYTE $0xc3\nRET\n",
+			"TEXT rawret(SB),4,$0-0\n" + move + " $0,0(SP)\nBYTE $0xc3\nRET\n",
+			"TEXT rawret(SB),4,$0-0\n" + push + " AX\nBYTE $0xc3\n" + pop + " AX\nRET\n",
+			"TEXT rawret(SB),4,$0-0\nBYTE $0x66\nBYTE $0xc3\nRET\n",
+			"TEXT rawret(SB),4,$0-0\nBYTE $0xf2\nBYTE $0xc3\nRET\n",
+			"TEXT rawret(SB),4,$0-0\nBYTE $0xf3\nBYTE $0xc3\nRET\n",
+		} {
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawret": {Name: "rawret", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s raw machine return cannot acquire a Go epilogue or normal stack width; got %v\n%s", target.triple, err, source)
+			}
+		}
+	}
+}
+
+func x86RawStackObservingFormProbeFile(t *testing.T, arch, symbol string, code []byte) *File {
+	t.Helper()
+	return x86RawUnprovedReturnFormProbeFile(t, arch, symbol, code)
+}
+
+// Retain the original Go encoder object as a negative return-contract test.
+// A compile-only operand probe ends in UD2: it cannot promise a caller return
+// after observing a physical stack or dereferencing unbound native pointers.
+// Every preceding instruction byte is unchanged. These objects prove operand
+// lowering, not execution of the original machine-entry function.
+func x86RawUnprovedReturnFormProbeFile(t *testing.T, arch, symbol string, code []byte) *File {
+	t.Helper()
+	if len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatalf("Go form fixture must end in its ordinary encoded RET, got %x", code)
+	}
+	makeFile := func(bytes []byte) *File {
+		var source strings.Builder
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", symbol)
+		for _, value := range bytes {
+			fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+		}
+		requireX86GoAssemblerResult(t, arch, source.String(), true)
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		return file
+	}
+	original := makeFile(code)
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	_, err := Translate(original, Options{Goarch: arch, TargetTriple: triple,
+		Sigs: map[string]FuncSig{symbol: {Name: symbol, Ret: Void}}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("original format fixture must retain its native return-contract failure, got %v", err)
+	}
+	if !strings.Contains(err.Error(), "source stack/continuation") &&
+		!strings.Contains(err.Error(), "bounded typed FP/static memory") {
+		t.Fatalf("unrelated Context error is not a native return-contract witness: %v", err)
+	}
+	probe := append(append([]byte(nil), code[:len(code)-1]...), 0x0f, 0x0b)
+	return makeFile(probe)
+}
+
+func TestX86RawUnprovedReturnFormProbePreservesInstructions(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, instruction := range []string{"MOVL (AX),CX", "MOVL CX,(AX)"} {
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				code := assembleX87ControlBytes(t, target.arch,
+					"TEXT form(SB),4,$0-0\n"+instruction+"\nRET\n")
+				original := append([]byte(nil), code...)
+				file := x86RawUnprovedReturnFormProbeFile(t, target.arch, "form", code)
+				if string(code) != string(original) {
+					t.Fatal("form probe modified its independent Go encoder input")
+				}
+				body := file.Funcs[0].Instrs[1:]
+				if len(body) != len(code)+1 {
+					t.Fatalf("probe directives=%d, want %d", len(body), len(code)+1)
+				}
+				want := append(append([]byte(nil), code[:len(code)-1]...), 0x0f, 0x0b)
+				for index, ins := range body {
+					if ins.Op != OpBYTE || len(ins.Args) != 1 ||
+						ins.Args[0].Kind != OpImm || ins.Args[0].Imm != int64(want[index]) {
+						t.Fatalf("changed operand-form byte %d: %+v, want %#x", index, ins, want[index])
+					}
+				}
+				// Replacing the unproved return with UD2 does not initialize
+				// AX/CX or authorize the preceding native load/store. Retain
+				// the public Context controls and private operand-format object.
+				ir := x86UnboundVoidRawProbeObject(t, file, target.arch, target.triple)
+				if !strings.Contains(ir, `asm sideeffect "ud2"`) || !strings.Contains(ir, "unreachable") {
+					t.Fatal("compile-only form probe invented an ordinary caller return")
+				}
+				compileLLVMToObject(t, llc, target.triple, "memory-form.ll", "memory-form.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86RawNearReturnZeroCleanupLeafObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+			t.Run(target.triple+"/"+strings.ReplaceAll(encoding, "\n", ";"), func(t *testing.T) {
+				source := "TEXT rawret(SB),4,$0-0\nMOVL $17,AX\n" + encoding + "\nRET\n"
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"rawret": {Name: "rawret", Ret: I32}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer module.Dispose()
+				compileLLVMToObject(t, llc, target.triple, "raw-near-ret.ll", "raw-near-ret.o", module.String())
+			})
+		}
+	}
+}
diff --git a/amd64_raw_nop.go b/amd64_raw_nop.go
new file mode 100644
index 000000000..21d194a8d
--- /dev/null
+++ b/amd64_raw_nop.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import "golang.org/x/arch/x86/x86asm"
+
+// The decoder discards NOP's inert ModRM/SIB fields only after validating the
+// complete encoding. Preserve existing source facts through that exact handoff,
+// not through a different physical instruction or an unbound address contract.
+// This observation creates no numerical, pointer, memory or raw-entry fact.
+func x86NOPPreservesSourceState(ins Instr) bool {
+	if ins.Op != "NOP" || len(ins.Args) != 0 || ins.x86Encoded || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	return origin == nil || origin.op == "NOP" && len(origin.args) == 0
+}
+
+// The pinned decoder lacks the REX.W form of 0F 1F /0 (LLVM 22 NOOPQ).
+// Only its operand width is inert. Keep every other prefix and use the decoder
+// for the complete ModRM/SIB/displacement length and prefix validity. This
+// narrowly scoped adapter never changes 90's XCHG/PAUSE aliases or another
+// opcode, and its result is consumed only by the operand-free NOP handoff.
+func decodedX86REXWNOP(code []byte) (x86asm.Inst, bool) {
+	if len(code) > 15 {
+		code = code[:15]
+	}
+	i := 0
+	for i < len(code) {
+		switch code[i] {
+		case 0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65, 0x66, 0x67, 0xf0, 0xf2, 0xf3:
+			i++
+		default:
+			goto opcode
+		}
+	}
+
+opcode:
+	if i+4 > len(code) || code[i]&0xf8 != 0x48 ||
+		code[i+1] != 0x0f || code[i+2] != 0x1f || code[i+3]&0x38 != 0 {
+		return x86asm.Inst{}, false
+	}
+	var adjusted [15]byte
+	copy(adjusted[:], code)
+	adjusted[i] &^= 8
+	inst, err := x86asm.Decode(adjusted[:len(code)], 64)
+	if err != nil || inst.Op != x86asm.NOP || inst.Len <= i+3 {
+		return x86asm.Inst{}, false
+	}
+	return inst, true
+}
diff --git a/amd64_raw_nop_handoff_test.go b/amd64_raw_nop_handoff_test.go
new file mode 100644
index 000000000..fe5531a35
--- /dev/null
+++ b/amd64_raw_nop_handoff_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Intel SDM NOP (90 and 0F 1F /0) has no register or memory effect.
+// Independently enumerate ModRM/SIB and prefix axes, including addresses
+// which would need a caller, segment, stack or PC contract if dereferenced.
+func x86RawNOPWitnesses(mode int) [][]byte {
+	forms := [][]byte{{0x90}, {0x66, 0x90}}
+	for mod := byte(0); mod < 4; mod++ {
+		for rm := byte(0); rm < 8; rm++ {
+			code := []byte{0x0f, 0x1f, mod<<6 | rm}
+			if mod != 3 && rm == 4 {
+				code = append(code, 0x24)
+			}
+			switch {
+			case mod == 1:
+				code = append(code, 0xff)
+			case mod == 2 || mod == 0 && rm == 5:
+				code = append(code, 0xff, 0xff, 0xff, 0x7f)
+			}
+			forms = append(forms, code)
+		}
+	}
+	for sib := 0; sib < 256; sib++ {
+		code := []byte{0x0f, 0x1f, 0x04, byte(sib)}
+		if sib&7 == 5 {
+			code = append(code, 0xff, 0xff, 0xff, 0x7f)
+		}
+		forms = append(forms, code)
+	}
+	for _, prefix := range []byte{0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65, 0x66} {
+		forms = append(forms, []byte{prefix, 0x0f, 0x1f, 0x00})
+	}
+	forms = append(forms, []byte{0x66, 0x0f, 0x1f, 0x84, 0x00, 0, 0, 0, 0})
+	if mode == 32 {
+		// The 16-bit address decoder must not manufacture BX/SI inputs.
+		forms = append(forms, []byte{0x67, 0x0f, 0x1f, 0x00})
+	} else {
+		// Inert EIP-relative address and actual extended REX banks.
+		forms = append(forms, []byte{0x67, 0x0f, 0x1f, 0x05, 0xff, 0xff, 0xff, 0x7f})
+		for rex := byte(0x40); rex < 0x50; rex++ {
+			forms = append(forms, []byte{rex, 0x0f, 0x1f, 0x04, 0x00})
+		}
+	}
+	return forms
+}
+
+func TestX86RawNOPPhysicalFieldsAreInert(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		arch := "amd64"
+		if mode == 32 {
+			arch = "386"
+		}
+		forms := x86RawNOPWitnesses(mode)
+		var complete []byte
+		for _, code := range forms {
+			complete = append(complete, code...)
+		}
+		x86HandoffOriginalBytes(t, arch, complete)
+		for _, code := range forms {
+			t.Run(fmt.Sprintf("mode%d/%x", mode, code), func(t *testing.T) {
+				physical, err := x86asm.Decode(code, mode)
+				// The independent literal object and runtime oracle cover the
+				// pinned decoder's missing REX.W NOP row; do not use the
+				// production adapter as its own acceptance oracle.
+				missingWidth := mode == 64 && code[0]&0xf8 == 0x48
+				if !missingWidth && (err != nil || physical.Op != x86asm.NOP || physical.Len != len(code)) {
+					t.Fatalf("independent NOP encoding: %+v %v", physical, err)
+				}
+				instructions, err := decodeX86RawDirectiveGroup(code, mode, 0, "NOP witness", map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(instructions) != 1 || instructions[0].Op != "NOP" || len(instructions[0].Args) != 0 ||
+					instructions[0].x86UnboundAddressOverride || instructions[0].x86AddressBits != 0 {
+					t.Fatalf("inert address acquired an effect: %+v", instructions)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawNOPGoEncoderWitnesses(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, registration := range []string{
+		"var ydivl = []ytab{\n\t{Zm_o, 2, argList{Yml}},\n}",
+		"{ANOPW, ydivl, Pe, opBytes{0x0f, 0x1f, 00}}",
+		"{ANOPL, ydivl, Px, opBytes{0x0f, 0x1f, 00}}",
+	} {
+		if !strings.Contains(string(table), registration) {
+			t.Fatal("Go NOP encoder changed:", registration)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, spelling := range []string{"NOPL AX", "NOPW AX", "NOPL (AX)", "NOPW -1(AX)(CX*8)"} {
+			code := x86OrderingHintGoBytes(t, arch, "TEXT probe(SB),4,$0-0\n"+spelling+"\n")
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			decoded, err := decodeX86RawDirectiveGroup(code, mode, 0, spelling, map[string]bool{})
+			if err != nil || len(decoded) != 1 || decoded[0].Op != "NOP" {
+				t.Fatalf("actual %s %s bytes %x: %+v %v", arch, spelling, code, decoded, err)
+			}
+		}
+	}
+}
+
+func TestX86RawNOPDoesNotEraseOtherEffectsOrBoundaries(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, code := range [][]byte{
+			{0xf0, 0x90}, {0xf0, 0x0f, 0x1f, 0x00},
+			{0xf0, 0x48, 0x0f, 0x1f, 0x00},
+			{0x0f}, {0x0f, 0x1f}, {0x0f, 0x1f, 0x84, 0x00},
+			{0x48, 0x0f, 0x1f, 0x84, 0x00},
+		} {
+			if _, err := decodeX86RawDirectiveGroup(code, mode, 0, "invalid NOP", map[string]bool{}); err == nil {
+				t.Fatalf("mode %d accepted invalid/truncated bytes %x", mode, code)
+			}
+		}
+		for extension := byte(1); extension < 8; extension++ {
+			code := []byte{0x0f, 0x1f, extension << 3}
+			if _, err := decodeX86RawDirectiveGroup(code, mode, 0, "reserved NOP extension", map[string]bool{}); err == nil {
+				t.Fatalf("reserved /%d NOP accepted", extension)
+			}
+			if _, ok := decodedX86REXWNOP(append([]byte{0x48}, code...)); ok {
+				t.Fatalf("REX.W adapter accepted reserved /%d", extension)
+			}
+		}
+		for _, code := range [][]byte{{0xf3, 0x90}, {0x87, 0xc0}, {0x8b, 0x00}} {
+			instructions, err := decodeX86RawDirectiveGroup(code, mode, 0, "not NOP", map[string]bool{})
+			if err != nil || len(instructions) != 1 || instructions[0].Op == "NOP" {
+				t.Fatalf("mode %d lost non-NOP effect %x: %+v %v", mode, code, instructions, err)
+			}
+		}
+		// A branch into a NOP's ModRM byte is still a mid-instruction edge.
+		interior := []byte{0x74, 1, 0x0f, 0x1f, 0x00, 0xc3}
+		if _, err := decodeX86RawDirectiveGroup(interior, mode, 0, "interior", map[string]bool{}); err == nil {
+			t.Fatal("branch into multi-byte NOP accepted")
+		}
+		boundary := []byte{0x74, 3, 0x0f, 0x1f, 0x00, 0x90, 0xc3}
+		if _, err := decodeX86RawDirectiveGroup(boundary, mode, 0, "boundary", map[string]bool{}); err != nil {
+			t.Fatal("valid branch/NOP boundaries:", err)
+		}
+		// The generic physical handoff remains strict for real memory.
+		physical, err := x86asm.Decode([]byte{0x8b, 0x00}, mode)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := parseDecodedX86PhysicalInstruction(physical, "NOP"); err == nil {
+			t.Fatal("formatter erased a real memory read")
+		}
+	}
+}
+
+func TestX86RawNOPThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		mode := 64
+		if target.arch == "386" {
+			mode = 32
+		}
+		var source strings.Builder
+		source.WriteString("TEXT ·probe(SB),4,$0-4\n")
+		for _, code := range x86RawNOPWitnesses(mode) {
+			source.WriteString(x86RawDisplacementDirectives(code))
+		}
+		source.WriteString("MOVL $73,ret+0(FP)\nRET\n")
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), "package ordering\nfunc probe() uint32\n", target.arch, target.triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if bytes.Contains([]byte(ir), []byte("inttoptr")) {
+					t.Fatal("inert NOP address became a native pointer")
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "nop.ll"), filepath.Join(dir, "nop.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", "-o", object, input))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_raw_nop_result_go127_test.go b/amd64_raw_nop_result_go127_test.go
new file mode 100644
index 000000000..dfef90aa0
--- /dev/null
+++ b/amd64_raw_nop_result_go127_test.go
@@ -0,0 +1,12 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+// The discovering current-Go source combines PCALIGN with literal NOP padding.
+// Go 1.20 rejects PCALIGN; the untagged root still checks every literal NOP and
+// paired native-read contract on both the historical and current SDKs.
+func TestX86RawNOPResultReadWithCurrentGoAlignment(t *testing.T) {
+	x86RawNOPResultReadComposition(t, true)
+}
diff --git a/amd64_raw_nop_result_runtime_unix_test.go b/amd64_raw_nop_result_runtime_unix_test.go
new file mode 100644
index 000000000..27b93ae29
--- /dev/null
+++ b/amd64_raw_nop_result_runtime_unix_test.go
@@ -0,0 +1,72 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86RawNOPPairedNativeRead(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	literal := x86RawDisplacementDirectives([]byte{0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0})
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	for _, vector := range []bool{false, true} {
+		for _, dead := range []bool{false, true} {
+			name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+			read, width, inputByte, outputByte := "MOVQ (DX),AX\n", 8, 0, 0
+			if vector {
+				read, width, inputByte, outputByte = "MOVOU (DX),X1\nMOVQ X1,AX\n", 16, 1, 1
+			}
+			body := literal + read + literal
+			discarded := 0
+			if dead {
+				body += "MOVQ $0x87654321fedcba98,AX\n"
+				discarded = 1
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DX\n%sMOVQ AX,ret+8(FP)\nRET\n", name, body)
+			fmt.Fprintf(&declarations, "func %s(p *[64]byte) uint64\n", name)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+strings.ReplaceAll(body, "(DX)", "(DI)")+"RET\n")
+			var encoded []string
+			for _, b := range code {
+				encoded = append(encoded, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(encoded, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+			fmt.Fprintf(&rows, "{%s,%s,%d,%d,%d,%d},\n", name, original, width, discarded, inputByte, outputByte)
+			count++
+		}
+	}
+	if count != 4 {
+		t.Fatal("incomplete scalar/vector live/dead matrix", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := fmt.Sprintf(x86NativeScalarReadRuntimeC, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "nop-native-read", text, driver, level)
+					if string(output) != "4 native scalar kernels: numerical 512, faults 48, tripwires 2; failures 0\n" {
+						t.Fatal("original NOP/read composition differs from LLVM", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_raw_nop_result_test.go b/amd64_raw_nop_result_test.go
new file mode 100644
index 000000000..7fa090869
--- /dev/null
+++ b/amd64_raw_nop_result_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawNOPResultReadComposition(t *testing.T) {
+	x86RawNOPResultReadComposition(t, false)
+}
+
+func x86RawNOPResultReadComposition(t *testing.T, align bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			mode, word, move := 64, 8, "MOVQ"
+			if target.arch == "386" {
+				mode, word, move = 32, 4, "MOVL"
+			}
+			var literals strings.Builder
+			if align {
+				literals.WriteString("PCALIGN $32\n")
+			}
+			for _, code := range x86RawNOPWitnesses(mode) {
+				literals.WriteString(x86RawDisplacementDirectives(code))
+			}
+			body := fmt.Sprintf("%s p+0(FP),DX\n%sVMOVDQU (DX),Y1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+%d(FP)\nRET",
+				move, literals.String(), word)
+			_, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(p *[64]byte) uint32", body)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			normalized, err := decodeX86RawDirectives(file.Funcs[0], target.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := CheckX86ABI0ResultInitialization(normalized, sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("inert raw bytes granted a standalone native read", err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte) uint32", target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("inert NOPs blocked the independently paired native read", api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "nop-result.ll", "nop-result.o", ir)
+				compileLLVMToObject(t, llc, target.triple, "nop-result-opt.ll", "nop-result-opt.o", x86MulDivRoundOptimize(t, ir))
+			}
+		})
+	}
+}
+
+func TestX86RawNOPResultReadRetainsRawBoundaries(t *testing.T) {
+	literal := x86RawDisplacementDirectives([]byte{0x66, 0x0f, 0x1f, 0x84, 0, 0, 0, 0, 0})
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[64]byte) uint32",
+		"MOVQ p+0(FP),DX\n"+literal+"VMOVDQU (DX),Y1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+8(FP)\nRET")
+	normalized, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	nop := -1
+	for i, ins := range normalized.Instrs {
+		if ins.x86SourceRaw != nil {
+			if nop != -1 || ins.Op != "NOP" {
+				t.Fatal("fixture did not decode one inert raw instruction")
+			}
+			nop = i
+		}
+	}
+	if nop == -1 {
+		t.Fatal("missing actual raw NOP handoff")
+	}
+	for _, mutation := range []string{"original opcode", "original operands", "normalized opcode", "normalized operands", "encoded", "address size", "raw return", "raw TEXT", "source stack", "fixed local"} {
+		t.Run(mutation, func(t *testing.T) {
+			fn := normalized
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			ins := &fn.Instrs[nop]
+			origin := *ins.x86SourceRaw
+			ins.x86SourceRaw = &origin
+			switch mutation {
+			case "original opcode":
+				origin.op = "PAUSE"
+			case "original operands":
+				origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "normalized opcode":
+				ins.Op = "PAUSE"
+			case "normalized operands":
+				ins.Args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "encoded":
+				ins.x86Encoded = true
+			case "address size":
+				ins.x86AddressBits = 32
+			case "raw return":
+				ins.x86RawNearReturn = new(x86RawNearReturnForm)
+			case "raw TEXT":
+				fn.X86RawText = []byte{0x90}
+			case "source stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			}
+			ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("inert padding granted another raw or entry contract", err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_nop_runtime_test.go b/amd64_raw_nop_runtime_test.go
new file mode 100644
index 000000000..d91a00488
--- /dev/null
+++ b/amd64_raw_nop_runtime_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Reuse only the independent GP/FLAGS/MXCSR/canary driver. Replace every tested
+// instruction with a disjoint part of the complete literal-NOP witness set.
+// Noncanonical/null effective addresses must not fault or change native state.
+func x86RawNOPRuntimeFixture(bits int) (declarations, assembly, driver, reference string) {
+	declarations, assembly, driver, reference = x86OrderingHintRuntimeFixture(bits)
+	var batches [4]strings.Builder
+	for i, code := range x86RawNOPWitnesses(bits) {
+		batches[i%len(batches)].WriteString(x86RawDisplacementDirectives(code))
+	}
+	for i, op := range []string{"LFENCE", "MFENCE", "SFENCE", "PAUSE"} {
+		assembly = strings.ReplaceAll(assembly, "\n"+op+"\n", "\n"+batches[i].String())
+	}
+	return
+}
+
+// Portable LLVM execution is distinct from the required original-Go native
+// roots. Rosetta rejects some valid register NOPs (for example 0F 1F C2), so
+// it cannot certify this family's original machine execution.
+func TestX86RawNOPLLVMRuntime(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, assembly, _, reference := x86RawNOPRuntimeFixture(64)
+	ir := x86NarrowOracleIR(t, assembly, declarations, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "nop", ir, reference, level)
+			if string(output) != "ordering observations 256\n" {
+				t.Fatalf("LLVM NOP GP/FLAGS/MXCSR/canary oracle: %q", output)
+			}
+		})
+	}
+}
+
+func TestX86RawNOPOriginal386StaticELFCompileOnly(t *testing.T) {
+	declarations, assembly, driver, _ := x86RawNOPRuntimeFixture(32)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386", declarations, assembly, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual original Go IA32 NOP ELF bytes=%d SHA256=%x; compile only", sealed.size, sealed.hash)
+}
diff --git a/amd64_raw_operand_handoff.go b/amd64_raw_operand_handoff.go
new file mode 100644
index 000000000..9d019d6d8
--- /dev/null
+++ b/amd64_raw_operand_handoff.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// parseDecodedX86PhysicalInstruction is the private decoder handoff, not a Go
+// source grammar extension. GoSyntax orders operands and selects the audited
+// mnemonic; the actual decoder Mem supplies the physical address. In
+// particular, FS:..., default DS/ES, and RIP are not source register groups.
+// Prefix, PC-relative layout, and address-size admission remain the caller's
+// independent checks. No memory/caller/frame certificate is manufactured here.
+func parseDecodedX86PhysicalInstruction(inst x86asm.Inst, syntax string) ([]Instr, error) {
+	physical := normalizeDecodedX86LEASegments(normalizeDecodedX86MemoryDisplacements(inst))
+	const marker = "__plan9asm_decoded_memory_"
+	if strings.Contains(syntax, marker) {
+		return nil, fmt.Errorf("decoded syntax collides with private memory placeholder")
+	}
+	type memoryBinding struct {
+		name    string
+		operand Operand
+	}
+	bindings := make(map[string]memoryBinding)
+	byName := make(map[string]Operand)
+	memoryCount := 0
+	for _, arg := range physical.Args {
+		memory, ok := arg.(x86asm.Mem)
+		if !ok {
+			continue
+		}
+		operand, err := decodedX86PhysicalMemory(memory)
+		if err != nil {
+			return nil, err
+		}
+		name := fmt.Sprintf("%s%d", marker, memoryCount)
+		memoryCount++
+		byName[name] = operand
+		// Use the same pinned formatter only to locate this complete operand
+		// token. Never interpret its text as a public memory/address role.
+		probe := physical
+		probe.Op = x86asm.NOP
+		probe.Prefix = x86asm.Prefixes{}
+		probe.Args = x86asm.Args{memory}
+		text := x86asm.GoSyntax(probe, 0, nil)
+		space := strings.IndexByte(text, ' ')
+		if space < 0 {
+			return nil, fmt.Errorf("decoder formatter omitted its physical memory operand")
+		}
+		text = text[space+1:]
+		spellings := []string{text, strings.TrimPrefix(normalizeDecodedX86SegmentMemorySyntax("NOP "+text), "NOP ")}
+		for _, spelling := range spellings {
+			if prior, exists := bindings[spelling]; exists && prior.operand.Mem != operand.Mem {
+				return nil, fmt.Errorf("ambiguous decoded physical memory %q", spelling)
+			}
+			bindings[spelling] = memoryBinding{name: name, operand: operand}
+		}
+	}
+	for _, prefix := range physical.Prefix {
+		if memoryCount == 0 || prefix&(x86asm.PrefixIgnored|x86asm.PrefixImplicit) != 0 {
+			continue
+		}
+		switch prefix & 0xff {
+		case x86asm.PrefixES, x86asm.PrefixCS, x86asm.PrefixSS, x86asm.PrefixDS, x86asm.PrefixFS, x86asm.PrefixGS:
+			bound := false
+			for _, argument := range physical.Args {
+				if memory, ok := argument.(x86asm.Mem); ok && memory.Segment.String() == prefix.String() {
+					bound = true
+				}
+			}
+			if !bound {
+				// A later operand-size prefix can hide this unused segment
+				// in GoSyntax. Absence from text is not an ignored witness.
+				return nil, fmt.Errorf("%w: raw %s has an unbound physical %s segment prefix", ErrProbeNeedsContext, inst.Op, prefix)
+			}
+		}
+	}
+
+	parts := strings.Split(syntax, ";")
+	consumed := 0
+	for i, part := range parts {
+		part = strings.TrimSpace(part)
+		// GoSyntax prints an architecturally ignored segment before the
+		// opcode (for example FS SCASB). Drop only that actual metadata-tagged
+		// prefix, not a used segment, an invalid prefix, or a textual guess.
+		for _, prefix := range physical.Prefix {
+			switch prefix & 0xff {
+			case x86asm.PrefixES, x86asm.PrefixCS, x86asm.PrefixSS, x86asm.PrefixDS, x86asm.PrefixFS, x86asm.PrefixGS:
+				if !strings.HasPrefix(part, prefix.String()+" ") {
+					continue
+				}
+				if prefix&x86asm.PrefixIgnored == 0 {
+					return nil, fmt.Errorf("%w: raw %s has an unbound physical %s segment prefix", ErrProbeNeedsContext, inst.Op, prefix)
+				}
+				part = strings.TrimPrefix(part, prefix.String()+" ")
+			}
+		}
+		space := strings.IndexByte(part, ' ')
+		if space >= 0 {
+			args := splitTopLevelCSV(part[space+1:])
+			for j, arg := range args {
+				if binding, ok := bindings[strings.TrimSpace(arg)]; ok {
+					args[j] = binding.name
+					consumed++
+				}
+			}
+			part = part[:space+1] + strings.Join(args, ", ")
+		}
+		parts[i] = part
+	}
+	if consumed != memoryCount {
+		return nil, fmt.Errorf("decoded physical memory handoff consumed %d operands, want %d", consumed, memoryCount)
+	}
+	instructions, err := parseDecodedX86Instruction(strings.Join(parts, "; "))
+	if err != nil {
+		return nil, err
+	}
+	if len(instructions) != len(parts) {
+		return nil, fmt.Errorf("decoded instruction/prefix handoff changed instruction count")
+	}
+	restored := 0
+	for i := range instructions {
+		for j, arg := range instructions[i].Args {
+			if arg.Kind != OpIdent {
+				continue
+			}
+			if operand, ok := byName[arg.Ident]; ok {
+				instructions[i].Args[j] = operand
+				restored++
+			}
+		}
+		instructions[i].Raw = strings.TrimSpace(strings.Split(syntax, ";")[i])
+	}
+	if restored != memoryCount {
+		return nil, fmt.Errorf("decoded physical memory handoff restored %d operands, want %d", restored, memoryCount)
+	}
+	return instructions, nil
+}
+
+// The pinned decoder appends L to these environment-load mnemonics, whereas
+// Go's complete ysvrs_mo rows use FLDENV/FRSTOR for the 32-bit layout. Bind the
+// real opcode, full prefix metadata, and complete encoding before dropping
+// that formatter suffix. The 14/94-byte operand-size override is not this
+// 28/108-byte Go layout and remains unsupported.
+func decodedX86X87EnvironmentLoad(inst x86asm.Inst, encoding []byte) (Op, bool, error) {
+	if inst.Op != x86asm.FLDENV && inst.Op != x86asm.FRSTOR {
+		return "", false, nil
+	}
+	witness, err := x86asm.Decode(encoding, inst.Mode)
+	witness = normalizeDecodedX86LEASegments(normalizeDecodedX86MemoryDisplacements(witness))
+	memory, hasMemory := inst.Args[0].(x86asm.Mem)
+	witnessMemory, hasWitnessMemory := witness.Args[0].(x86asm.Mem)
+	if err != nil || witness.Len != len(encoding) || witness.Len != inst.Len ||
+		witness.Op != inst.Op || witness.Opcode != inst.Opcode || witness.Prefix != inst.Prefix ||
+		witness.DataSize != inst.DataSize || witness.AddrSize != inst.AddrSize || witness.MemBytes != inst.MemBytes ||
+		!hasMemory || !hasWitnessMemory || memory != witnessMemory ||
+		inst.Args[1] != nil || inst.Args[2] != nil || inst.Args[3] != nil {
+		return "", true, fmt.Errorf("%w: raw x87 environment load lacks its complete decoder encoding", ErrProbeNeedsContext)
+	}
+	if inst.DataSize != 32 {
+		return "", true, fmt.Errorf("raw %s uses a %d-bit environment layout not represented by Go %s", inst.Op, inst.DataSize, inst.Op)
+	}
+	return Op(inst.Op.String()), true, nil
+}
+
+func decodedX86PhysicalMemory(memory x86asm.Mem) (Operand, error) {
+	register := func(reg x86asm.Reg) (Reg, error) {
+		if reg == 0 {
+			return "", nil
+		}
+		if reg == x86asm.RIP {
+			return Reg("IP"), nil // Consumed only by the separate RIP layout proof.
+		}
+		text := x86asm.GoSyntax(x86asm.Inst{Op: x86asm.NOP, Args: x86asm.Args{reg}}, 0, nil)
+		space := strings.IndexByte(text, ' ')
+		if space < 0 {
+			return "", fmt.Errorf("decoder formatter omitted its physical address register")
+		}
+		text = text[space+1:]
+		value, ok := parseReg(text)
+		if !ok {
+			return "", fmt.Errorf("unsupported decoded physical address register %s", reg)
+		}
+		return value, nil
+	}
+	base, err := register(memory.Base)
+	if err != nil {
+		return Operand{}, err
+	}
+	index, err := register(memory.Index)
+	if err != nil {
+		return Operand{}, err
+	}
+	segment := Reg("")
+	switch memory.Segment {
+	case 0:
+	case x86asm.ES, x86asm.CS, x86asm.SS, x86asm.DS, x86asm.FS, x86asm.GS:
+		segment = Reg(memory.Segment.String())
+	default:
+		return Operand{}, fmt.Errorf("unsupported decoded physical segment %s", memory.Segment)
+	}
+	return Operand{Kind: OpMem, Mem: MemRef{Base: base, Index: index, Scale: int64(memory.Scale), Off: memory.Disp, Segment: segment}}, nil
+}
diff --git a/amd64_raw_operand_handoff_test.go b/amd64_raw_operand_handoff_test.go
new file mode 100644
index 000000000..89fcbfc38
--- /dev/null
+++ b/amd64_raw_operand_handoff_test.go
@@ -0,0 +1,557 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// This oracle assembles literal BYTE directives, not GoSyntax's synthetic
+// memory spelling. Its complete contiguous text bytes independently anchor
+// the private decoder input on both supported SDK test lanes.
+func x86HandoffOriginalBytes(t *testing.T, arch string, code []byte) {
+	t.Helper()
+	source := "TEXT handoff(SB),4,$0-0\n" + x86RawDisplacementDirectives(code)
+	listing, err := x86ScalarLiteralGoListing(t, arch, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var actual []byte
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		if err != nil || int(offset) != len(actual) {
+			t.Fatalf("noncontiguous stock Go bytes: %s", line)
+		}
+		// Both audited objfile.go printers use sixteen fixed three-byte
+		// hex columns, then two spaces and ASCII. Never parse the ASCII
+		// tail as another byte, even when it happens to be "ab" or "f.".
+		text := strings.TrimLeft(line, "\t ")
+		start := strings.IndexByte(text, ' ')
+		if start < 0 || len(text) < start+48 {
+			t.Fatalf("missing complete stock Go hex columns: %s", line)
+		}
+		gap := false
+		for i := 0; i < 16; i++ {
+			field := text[start+3*i : start+3*(i+1)]
+			if field == "   " {
+				gap = true
+				continue
+			}
+			value, err := strconv.ParseUint(field[1:], 16, 8)
+			if gap || field[0] != ' ' || err != nil {
+				t.Fatalf("invalid stock Go hex column: %q", field)
+			}
+			actual = append(actual, byte(value))
+		}
+	}
+	if !bytes.Equal(actual, code) {
+		t.Fatalf("stock Go raw text = %x, want complete %x", actual, code)
+	}
+}
+
+func TestX86PrivateDecoderX87PhysicalMemoryHandoff(t *testing.T) {
+	forms := []struct {
+		op   Op
+		code []byte
+	}{
+		{"FSAVE", []byte{0xdd, 0x74, 0x8b, 0xf9}},
+		{"FSTCW", []byte{0xd9, 0x7c, 0x8b, 0xf9}},
+		{"FSTENV", []byte{0xd9, 0x74, 0x8b, 0xf9}},
+		{"FSTSW", []byte{0xdd, 0x7c, 0x8b, 0xf9}},
+		{"FLDCW", []byte{0xd9, 0x6c, 0x8b, 0xf9}},
+		{"FLDENV", []byte{0xd9, 0x64, 0x8b, 0xf9}},
+		{"FRSTOR", []byte{0xdd, 0x64, 0x8b, 0xf9}},
+	}
+	segments := []struct {
+		prefix byte
+		reg    Reg
+	}{{0x26, ES}, {0x2e, CS}, {0x36, SS}, {0x3e, DS}, {0x64, FS}, {0x65, GS}}
+	for _, arch := range []string{"386", "amd64"} {
+		var complete []byte
+		for _, form := range forms {
+			for _, segment := range segments {
+				complete = append(complete, segment.prefix)
+				complete = append(complete, form.code...)
+			}
+		}
+		complete = append(complete, 0xc3)
+		x86HandoffOriginalBytes(t, arch, complete)
+		for _, form := range forms {
+			for _, segment := range segments {
+				t.Run(arch+"/"+string(form.op)+"/"+string(segment.reg), func(t *testing.T) {
+					code := append([]byte{segment.prefix}, form.code...)
+					decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := Operand{Kind: OpMem, Mem: MemRef{Base: BX, Index: CX, Scale: 4, Off: -7, Segment: segment.reg}}
+					if arch == "amd64" && segment.reg != FS && segment.reg != GS {
+						// In mode64 the actual decoder ignores the legacy flat
+						// segment prefix; it supplies no physical override.
+						want.Mem.Segment = ""
+					}
+					if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != form.op || len(decoded.Instrs[0].Args) != 1 || !reflect.DeepEqual(decoded.Instrs[0].Args[0], want) {
+						t.Fatalf("physical memory changed: %+v, want %s %+v", decoded.Instrs, form.op, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PrivateDecoderImplicitPhysicalSegments(t *testing.T) {
+	forms := []struct {
+		name   string
+		opcode byte
+		source bool
+		dest   bool
+	}{
+		{"MOVS", 0xa4, true, true}, {"CMPS", 0xa6, true, true},
+		{"STOS", 0xaa, false, true}, {"LODS", 0xac, true, false},
+		{"SCAS", 0xae, false, true}, {"INS", 0x6c, false, true},
+		{"OUTS", 0x6e, true, false},
+	}
+	for _, mode := range []int{32, 64} {
+		arch := "amd64"
+		if mode == 32 {
+			arch = "386"
+		}
+		var complete []byte
+		for _, form := range forms {
+			for _, segment := range []byte{0, 0x64, 0x65} {
+				for _, repeat := range []byte{0, 0xf2, 0xf3} {
+					code := []byte{0x67}
+					if repeat != 0 {
+						code = append(code, repeat)
+					}
+					if segment != 0 {
+						code = append(code, segment)
+					}
+					code = append(code, form.opcode)
+					complete = append(complete, code...)
+				}
+			}
+		}
+		complete = append(complete, 0xc3)
+		x86HandoffOriginalBytes(t, arch, complete)
+		for _, form := range forms {
+			for _, segment := range []byte{0, 0x64, 0x65} {
+				for _, repeat := range []byte{0, 0xf2, 0xf3} {
+					t.Run(fmt.Sprintf("mode%d/%s/seg%02x/rep%02x", mode, form.name, segment, repeat), func(t *testing.T) {
+						code := []byte{0x67}
+						if repeat != 0 {
+							code = append(code, repeat)
+						}
+						if segment != 0 {
+							code = append(code, segment)
+						}
+						code = append(code, form.opcode)
+						physical, err := x86asm.Decode(code, mode)
+						if err != nil || physical.Len != len(code) {
+							t.Fatalf("complete physical decode: %+v %v", physical, err)
+						}
+						instructions, err := x86AddressOverrideDecode(mode, code)
+						if !form.source && segment != 0 {
+							// x/arch does not mark this unused FS/GS prefix as
+							// ignored. Do not guess or strip it: precise Context
+							// replaces the old accidental source-parser failure.
+							if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "unbound physical") {
+								t.Fatalf("unbound physical prefix: %v", err)
+							}
+							return
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						var memories []MemRef
+						for _, ins := range instructions {
+							if ins.Op == OpTEXT || ins.Op == OpRET {
+								continue
+							}
+							if !ins.x86UnboundAddressOverride || ins.x86AddressBits != mode/2 {
+								t.Fatalf("lost physical address restriction: %+v", ins)
+							}
+							for _, arg := range ins.Args {
+								if arg.Kind == OpMem {
+									memories = append(memories, arg.Mem)
+								}
+							}
+							ctx, out := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+							ctx.goarch = arch
+							before := out.String()
+							if terminated, err := ctx.lowerInstr(0, 0, ins, nil, nil); terminated || !errors.Is(err, ErrProbeNeedsContext) || out.String() != before {
+								t.Fatalf("unbound physical memory emitted IR: %t %v", terminated, err)
+							}
+						}
+						wantSource := DS
+						if segment == 0x64 {
+							wantSource = FS
+						} else if segment == 0x65 {
+							wantSource = GS
+						}
+						seenSource, seenDest := false, false
+						for _, memory := range memories {
+							if memory.Base == SI && memory.Segment == wantSource {
+								seenSource = true
+							} else if memory.Base == DI && memory.Segment == ES {
+								seenDest = true
+							} else {
+								t.Fatalf("unexpected implicit physical memory: %+v", memory)
+							}
+						}
+						if seenSource != form.source || seenDest != form.dest {
+							t.Fatalf("lost source/destination segments: %+v", memories)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PrivateDecoderRIPPoolAllPublicAPIs(t *testing.T) {
+	code := []byte{0x48, 0x8d, 0x05, 1, 0, 0, 0, 0xc3, 0x41}
+	x86HandoffOriginalBytes(t, "amd64", code)
+	file := mustParseX86RawReturn(t, x86StaticReturnSource("Bound", code))
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // RIP is a mode64-only machine addressing form.
+		}
+		opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+		for _, api := range []string{"text", "module", "owned-module"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				var ir string
+				var err error
+				switch api {
+				case "text":
+					ir, err = Translate(file, opt)
+				case "module":
+					module, callErr := TranslateModule(file, opt)
+					err = callErr
+					if err == nil {
+						ir = module.String()
+						module.Dispose()
+					}
+				default:
+					ctx := llvm.NewContext()
+					module, callErr := TranslateModuleInContext(ctx, file, opt)
+					err = callErr
+					if err == nil {
+						ir = module.String()
+						module.Dispose()
+					}
+					ctx.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc required")
+				}
+				compileLLVMToObject(t, llc, target.triple, "handoff.ll", "handoff.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86PrivateDecoderX87FiveTargetObjects(t *testing.T) {
+	// Object-only controls for the already-supported FS/GS address spaces.
+	// They do not execute an unknown native pointer or prove caller bounds.
+	var code []byte
+	for _, opcode := range [][]byte{
+		{0xdd, 0x30}, {0xd9, 0x38}, {0xd9, 0x30}, {0xdd, 0x38},
+		{0xd9, 0x28}, {0xd9, 0x20}, {0xdd, 0x20},
+		{0xdf, 0x20}, {0xdf, 0x30}, // packed BCD load/store
+	} {
+		for _, segment := range []byte{0x64, 0x65} {
+			code = append(code, segment)
+			code = append(code, opcode...)
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			// This is the same named RET domain as the old x87 positive.
+			// A raw RET plus unknown native memory remains Context.
+			source := x86StaticReturnSource("Bound", code) +
+				"FMOVX 0(AX)(FS),F0\nFMOVXP F0,0(AX)(FS)\n" +
+				"FMOVX 0(AX)(GS),F0\nFMOVXP F0,0(AX)(GS)\nRET\n"
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			file := mustParseX86RawReturn(t, source)
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple, X87Mode: X87Software,
+				Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86X87UnboundOriginalAPI(t, file, opt, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "FSAVE FS:0(AX)") {
+						t.Fatal("complete original raw source acquired native AX/segment storage or an x87 image", err)
+					}
+				})
+			}
+			t.Run("lowerer-unit-object", func(t *testing.T) {
+				ir := x86X87LowererObjectUnit(t, file, target.arch, target.triple)
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc required")
+				}
+				compileLLVMToObject(t, llc, target.triple, "physical-x87-unit.ll", "physical-x87-unit.o", ir)
+			})
+		})
+	}
+}
+
+func TestX86PrivateDecoderHandoffDoesNotWidenSourceOrLayout(t *testing.T) {
+	for _, source := range []string{"FSAVE FS:0(AX)", "MOVSB DS:0(SI),ES:0(DI)", "LEAQ 1(IP),AX"} {
+		t.Run("public/"+source, func(t *testing.T) {
+			if _, err := Parse(ArchAMD64, "TEXT raw(SB),4,$0-0\n"+source+"\nRET\n"); err == nil {
+				t.Fatal("private physical memory spelling became public source syntax")
+			}
+		})
+	}
+	for _, opcode := range [][]byte{{0xdd, 0x30}, {0xd9, 0x30}, {0xd9, 0x20}, {0xdd, 0x20}} {
+		for _, mode := range []int{32, 64} {
+			t.Run(fmt.Sprintf("legacy-layout/%d/%x", mode, opcode), func(t *testing.T) {
+				code := append([]byte{0x66}, opcode...)
+				arch := "amd64"
+				if mode == 32 {
+					arch = "386"
+				}
+				x86HandoffOriginalBytes(t, arch, append(append([]byte(nil), code...), 0xc3))
+				_, err := decodeX86RawDirectives(rawX86Function(code), arch)
+				if err == nil || !strings.Contains(err.Error(), "16-bit environment layout") {
+					t.Fatalf("14/94-byte layout acquired the 28/108-byte alias: %v", err)
+				}
+			})
+		}
+	}
+	code := []byte{0xd9, 0x20}
+	inst, err := x86asm.Decode(code, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*x86asm.Inst){
+		"prefix": func(i *x86asm.Inst) { i.Prefix[0] = x86asm.PrefixFS },
+		"size":   func(i *x86asm.Inst) { i.DataSize = 16 },
+		"length": func(i *x86asm.Inst) { i.Len++ },
+		"memory": func(i *x86asm.Inst) { i.Args[0] = x86asm.Mem{Base: x86asm.RBX} },
+		"extra":  func(i *x86asm.Inst) { i.Args[1] = x86asm.RAX },
+	} {
+		t.Run("alias-witness/"+name, func(t *testing.T) {
+			changed := inst
+			mutate(&changed)
+			if _, recognized, err := decodedX86X87EnvironmentLoad(changed, code); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed decoded observation borrowed the environment alias: %v", err)
+			}
+		})
+	}
+	for _, changed := range [][]byte{{0xd9}, {0xd9, 0x28}, {0xd9, 0x20, 0x90}} {
+		t.Run(fmt.Sprintf("alias-bytes/%x", changed), func(t *testing.T) {
+			if _, recognized, err := decodedX86X87EnvironmentLoad(inst, changed); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed encoding borrowed the environment alias: %v", err)
+			}
+		})
+	}
+	for _, code := range [][]byte{{0x67, 0x48, 0x8d, 0x05, 0, 0, 0, 0}, {0xf0, 0xd9, 0x20}} {
+		t.Run(fmt.Sprintf("physical-boundary/%x", code), func(t *testing.T) {
+			_, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+			if err == nil {
+				t.Fatal("unbound EIP or invalid prefix acquired private memory admission")
+			}
+		})
+	}
+}
+
+func TestX86PrivateDecoderNamedX87MemoryConsumers(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT Bound(SB),4,$0-0\n")
+	var forms []string
+	for _, segment := range []string{"FS", "GS"} {
+		// Named FLDENV is the separately observed stock assembler defect
+		// below, not an accepted object control. Its complete raw opcode
+		// remains in the physical-memory and five-target object matrices.
+		for _, op := range []string{"FSAVE", "FSTCW", "FSTENV", "FSTSW", "FLDCW", "FRSTOR"} {
+			forms = append(forms, fmt.Sprintf("%s 0(AX)(%s)", op, segment))
+		}
+		for _, suffix := range []string{"B", "X", "F", "D", "W", "L", "V"} {
+			forms = append(forms, fmt.Sprintf("FMOV%s 0(AX)(%s),F0", suffix, segment),
+				fmt.Sprintf("FMOV%sP F0,0(AX)(%s)", suffix, segment))
+		}
+	}
+	source.WriteString(strings.Join(forms, "\n") + "\n")
+	source.WriteString("RET\n")
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, form := range forms {
+				t.Run("original-Go/"+form, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, "TEXT Bound(SB),4,$0-0\n"+form+"\nRET\n")
+				})
+			}
+			if t.Failed() {
+				return // Do not claim LLVM equivalence for a rejected Go input.
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			file := mustParseX86RawReturn(t, source.String())
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple, X87Mode: X87Software,
+				Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86X87UnboundOriginalAPI(t, file, opt, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "FSAVE 0(AX)(FS)") {
+						t.Fatal("complete original named source acquired native AX/segment storage or an x87 image", err)
+					}
+				})
+			}
+			t.Run("lowerer-unit-object", func(t *testing.T) {
+				ir := x86X87LowererObjectUnit(t, file, target.arch, target.triple)
+				for _, addressSpace := range []string{"ptr addrspace(256)", "ptr addrspace(257)"} {
+					if !strings.Contains(ir, "getelementptr i8, "+addressSpace) || !strings.Contains(ir, "load i8, "+addressSpace) {
+						t.Fatalf("environment/BCD emitter unit lost %s", addressSpace)
+					}
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc required")
+				}
+				compileLLVMToObject(t, llc, target.triple, "named-x87-unit.ll", "named-x87-unit.o", ir)
+			})
+		})
+	}
+}
+
+func TestX86PrivateDecoderNamedFLDENVStockGoDefect(t *testing.T) {
+	// Do not turn a positionless backend defect into a generic source-rejection
+	// certificate. Bind the entire one-instruction fixture and exact process
+	// outcome separately; raw D9 /4 is independently accepted above.
+	for _, target := range x86RawReturnTargets {
+		for _, segment := range []string{"FS", "GS"} {
+			t.Run(target.triple+"/"+segment, func(t *testing.T) {
+				original := "TEXT Bound(SB),4,$0-0\nFLDENV 0(AX)(" + segment + ")\nRET\n"
+				dir := t.TempDir()
+				input, object := filepath.Join(dir, "fldenv.s"), filepath.Join(dir, "fldenv.o")
+				if err := os.WriteFile(input, []byte(original), 0600); err != nil {
+					t.Fatal(err)
+				}
+				stage, cancelStage := runtimeOracleStageContext(t)
+				defer cancelStage()
+				ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+				defer cancel()
+				driver, driverHash := x86LEAActualSDKDriver(t)
+				goos := "linux"
+				if strings.Contains(target.triple, "apple") {
+					goos = "darwin"
+				} else if strings.Contains(target.triple, "windows") {
+					goos = "windows"
+				}
+				command := exec.CommandContext(ctx, driver, "tool", "asm", "-p", "sourceframe", "-o", object, input)
+				command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+					"GOOS="+goos, "GOARCH="+target.arch, "CGO_ENABLED=0")
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				const diagnostic = "asm: asmand: bad address \nasm: assembly failed\n"
+				if failure := x86UnnamedAsmidxOutcome(output, err, ctx.Err(), diagnostic); failure != nil {
+					t.Fatalf("unknown named FLDENV backend observation: %v\n%s", failure, output)
+				}
+				if goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), false, target.arch) == nil {
+					t.Fatal("positionless backend defect became a source-rejection certificate")
+				}
+				for _, changed := range []string{"", diagnostic + diagnostic, diagnostic + "unexpected\n", "asm: assembly failed\n"} {
+					if x86UnnamedAsmidxOutcome([]byte(changed), err, nil, diagnostic) == nil {
+						t.Fatal("changed/missing/repeated backend diagnostic accepted")
+					}
+				}
+				for _, changed := range []error{nil, errors.New("tool launch"), errors.Join(err, errors.New("cleanup"))} {
+					if x86UnnamedAsmidxOutcome(output, changed, nil, diagnostic) == nil {
+						t.Fatal("missing/unknown/cleanup process failure accepted")
+					}
+				}
+				if x86UnnamedAsmidxOutcome(output, err, context.DeadlineExceeded, diagnostic) == nil {
+					t.Fatal("expired backend observation accepted")
+				}
+				if data, readErr := os.ReadFile(input); readErr != nil || string(data) != original {
+					t.Fatal("original named FLDENV source changed", readErr)
+				}
+				t.Logf("GO_BACKEND_DEFECT not-source-exclusion target=%s source=%q sourceSHA=%x driverSHA=%s diagnosticSHA=%x",
+					target.triple, original, sha256.Sum256([]byte(original)), driverHash, sha256.Sum256(output))
+			})
+		}
+	}
+}
+
+func TestX86PrivateDecoderUnboundSegmentCannotEmit(t *testing.T) {
+	// These are exactly the eighteen old parser-error controls: mode32
+	// STOSB/STOSL/INSB/INSL and mode64 plus STOSQ, each with FS/GS. They
+	// remain unbound machine Context, not new public syntax or object passes.
+	for _, target := range x86RawReturnTargets {
+		forms := [][]byte{{0xaa}, {0xab}, {0x6c}, {0x6d}}
+		mode := 32
+		if target.arch == "amd64" {
+			mode = 64
+			forms = append(forms, []byte{0x48, 0xab})
+		}
+		for _, opcode := range forms {
+			for _, segment := range []byte{0x64, 0x65} {
+				code := append([]byte{0x67, segment}, opcode...)
+				physical, err := x86asm.Decode(code, mode)
+				if err != nil || physical.Len != len(code) {
+					t.Fatal("complete segment observation", physical, err)
+				}
+				memory, ok := physical.Args[0].(x86asm.Mem)
+				if !ok || memory.Segment != x86asm.ES || physical.Prefix[1]&x86asm.PrefixIgnored != 0 {
+					t.Fatal("unbound prefix borrowed an ignored/default-segment identity", physical)
+				}
+				for _, api := range []string{"text", "module", "owned-module"} {
+					t.Run(fmt.Sprintf("%s/%x/%s", target.triple, code, api), func(t *testing.T) {
+						file := mustParseX86RawReturn(t, x86StaticReturnSource("Bound", code)+"RET\n")
+						opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+						var callErr error
+						switch api {
+						case "text":
+							ir, err := Translate(file, opt)
+							callErr = err
+							if ir != "" {
+								t.Fatal("unbound segment emitted text")
+							}
+						case "module":
+							module, err := TranslateModule(file, opt)
+							callErr = err
+							if !module.IsNil() {
+								module.Dispose()
+								t.Fatal("unbound segment emitted a module")
+							}
+						default:
+							ctx := llvm.NewContext()
+							module, err := TranslateModuleInContext(ctx, file, opt)
+							callErr = err
+							if !module.IsNil() {
+								module.Dispose()
+								ctx.Dispose()
+								t.Fatal("unbound segment emitted an owned module")
+							}
+							ctx.Dispose()
+						}
+						if !errors.Is(callErr, ErrProbeNeedsContext) || !strings.Contains(callErr.Error(), "unbound physical") {
+							t.Fatalf("unbound segment lost Context: %v", callErr)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_raw_pack.go b/amd64_raw_pack.go
new file mode 100644
index 000000000..70ed38492
--- /dev/null
+++ b/amd64_raw_pack.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27's four VPACK rows share the same three-operand grammar. The two
+// dword-to-word operations also permit EVEX 32-bit memory broadcast.
+var x86RawPackedNarrowOps = map[[2]int]struct {
+	op        Op
+	broadcast bool
+	evexW0    bool
+}{
+	{1, 0x6b}: {op: "VPACKSSDW", broadcast: true, evexW0: true},
+	{1, 0x63}: {op: "VPACKSSWB"},
+	{2, 0x2b}: {op: "VPACKUSDW", broadcast: true, evexW0: true},
+	{1, 0x67}: {op: "VPACKUSWB"},
+}
+
+func decodedX86VectorPackedSaturatingNarrowInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched {
+		return Instr{}, 0, false, nil
+	}
+	spec, known := x86RawPackedNarrowOps[[2]int{p.mapNumber, p.opcode}]
+	if !known {
+		return Instr{}, 0, false, nil
+	}
+	// Intel's VEX pack rows ignore W. EVEX dword inputs require W0,
+	// while EVEX word inputs also ignore W. Go happens to emit W0 for all;
+	// that chosen encoding is not the complete legal physical grammar.
+	if p.evex && spec.evexW0 && p.w {
+		return Instr{}, 0, true, fmt.Errorf("packed saturating narrow: unsupported W bit")
+	}
+	bits := 16
+	if spec.broadcast {
+		bits = 32
+	}
+	return decodedX86BinaryVectorOperands(code, p, mode, spec.op, bits)
+}
diff --git a/amd64_raw_pack_test.go b/amd64_raw_pack_test.go
new file mode 100644
index 000000000..ee9fd150a
--- /dev/null
+++ b/amd64_raw_pack_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawPackedSaturatingNarrowGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawpackedforms(SB),4,$0-0\n")
+			for _, op := range []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB"} {
+				if arch == "amd64" && op != "PACKUSDW" {
+					fmt.Fprintf(&source, "%s M1, M2\n%s (AX), M2\n", op, op)
+				}
+				fmt.Fprintf(&source, "%s X1, X2\n%s (AX), X2\n", op, op)
+			}
+			if arch == "amd64" {
+				for _, op := range []string{"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"} {
+					for _, width := range []string{"X", "Y"} {
+						fmt.Fprintf(&source, "%s %s1, %s2, %s3\n", op, width, width, width)
+						fmt.Fprintf(&source, "%s 32(AX), %s2, %s3\n", op, width, width)
+						fmt.Fprintf(&source, "%s %s20, %s21, K1, %s22\n", op, width, width, width)
+					}
+					fmt.Fprintf(&source, "%s Z20, Z21, K7, Z22\n", op)
+					fmt.Fprintf(&source, "%s.Z (AX), Z21, K7, Z22\n", op)
+					if op == "VPACKSSDW" || op == "VPACKUSDW" {
+						fmt.Fprintf(&source, "%s.BCST.Z 64(AX), Z21, K7, Z22\n", op)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for index, got := range decoded.Instrs {
+				if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+					t.Fatalf("instruction %d = %s %v, want %s %v", index, got.Op, got.Args, want[index].Op, want[index].Args)
+				}
+			}
+			if len(code) == 0 || code[len(code)-1] != 0xc3 {
+				t.Fatal("Go assembler did not end the fixture with RET")
+			}
+			var raw strings.Builder
+			raw.WriteString("TEXT rawpackedforms(SB),4,$0-0\n")
+			for _, value := range code[:len(code)-1] {
+				fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+			}
+			raw.WriteString("RET\n")
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				// Preserve MMX/X/Y/Z and all mask/broadcast forms as original
+				// objects; neither physical MMX nor unknown inputs gain an entry.
+				ir := x86UnboundVoidRawScalarFormatObject(t, raw.String(), arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-packed-saturating-narrow.ll", "raw-packed-saturating-narrow.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawPackedSaturatingNarrowRegisterAxes(t *testing.T) {
+	for key, spec := range x86RawPackedNarrowOps {
+		for _, width := range []string{"X", "Y", "Z"} {
+			for _, regs := range [][3]int{{0, 1, 2}, {7, 15, 8}, {16, 20, 31}, {31, 30, 29}} {
+				for _, evex := range []bool{false, true} {
+					if !evex && (width == "Z" || regs[0] >= 16 || regs[1] >= 16 || regs[2] >= 16) {
+						continue
+					}
+					var code []byte
+					if evex {
+						vectorBits := byte(strings.Index("XYZ", width))
+						code = encodeX86EVEXPackedMultiplyLow(false, vectorBits, 7, true, regs[0], regs[1], regs[2])
+						code[1] = code[1]&^0x0f | byte(key[0])
+						code[4] = byte(key[1])
+					} else {
+						code = encodeX86VEXPackedMultiplyLow(width == "Y", regs[0], regs[1], regs[2])
+						code[1] = code[1]&^0x1f | byte(key[0])
+						code[3] = byte(key[1])
+					}
+					got, length, matched, err := decodedX86VectorPackedSaturatingNarrowInstruction(code, 64)
+					if !matched || err != nil || length != len(code) {
+						t.Fatalf("decode %x = %+v length=%d matched=%v err=%v", code, got, length, matched, err)
+					}
+					wantOp := spec.op
+					wantArgs := []string{
+						fmt.Sprintf("%s%d", width, regs[2]),
+						fmt.Sprintf("%s%d", width, regs[1]),
+					}
+					if evex {
+						wantOp += ".Z"
+						wantArgs = append(wantArgs, "K7")
+					}
+					wantArgs = append(wantArgs, fmt.Sprintf("%s%d", width, regs[0]))
+					if got.Op != wantOp || len(got.Args) != len(wantArgs) {
+						t.Fatalf("decode %x = %+v, want %s %v", code, got, wantOp, wantArgs)
+					}
+					for index, arg := range got.Args {
+						if arg.String() != wantArgs[index] {
+							t.Fatalf("decode %x arg %d = %s, want %s", code, index, arg.String(), wantArgs[index])
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawPackedSaturatingNarrowRejectsReservedForms(t *testing.T) {
+	base := encodeX86EVEXPackedMultiplyLow(false, 2, 1, false, 2, 3, 4)
+	base[1] = base[1]&^0x0f | 2
+	base[4] = 0x2b
+	bytePackBroadcast := append([]byte(nil), base...)
+	bytePackBroadcast[1] = bytePackBroadcast[1]&^0x0f | 1
+	bytePackBroadcast[3] |= 0x10
+	bytePackBroadcast[4] = 0x63
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{name: "missing ModRM", code: base[:5]},
+		{name: "address override", code: append([]byte{0x67}, base...)},
+		{name: "wrong pp", code: replaceX86Byte(base, 2, base[2]&^3)},
+		{name: "wrong W", code: replaceX86Byte(base, 2, base[2]|0x80)},
+		{name: "missing fixed bit", code: replaceX86Byte(base, 2, base[2]&^4)},
+		{name: "reserved vector length", code: replaceX86Byte(base, 3, base[3]&^0x60|0x60)},
+		{name: "zero without mask", code: replaceX86Byte(base, 3, base[3]&^7|0x80)},
+		{name: "broadcast register", code: replaceX86Byte(base, 3, base[3]|0x10)},
+		{name: "byte pack broadcast", code: bytePackBroadcast},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, matched, err := decodedX86VectorPackedSaturatingNarrowInstruction(test.code, 64); !matched || err == nil {
+				t.Fatalf("invalid %x matched=%v error=%v", test.code, matched, err)
+			}
+		})
+	}
+}
+
+func replaceX86Byte(source []byte, index int, value byte) []byte {
+	copyOfSource := append([]byte(nil), source...)
+	copyOfSource[index] = value
+	return copyOfSource
+}
diff --git a/amd64_raw_packed_arithmetic_literal_test.go b/amd64_raw_packed_arithmetic_literal_test.go
new file mode 100644
index 000000000..df94a575c
--- /dev/null
+++ b/amd64_raw_packed_arithmetic_literal_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86RawPackedArithmeticLiteral(opcode byte, evex bool, width int, broadcast bool) []byte {
+	properties := decodedX86PackedIntegerArithmeticOps[opcode]
+	mask, zeroing := 0, false
+	if evex {
+		mask, zeroing = 7, true
+	}
+	code := encodeRawScalarMove(evex, 1, int(opcode), 0, 0, 0, mask, zeroing)
+	code[1] = code[1]&0xf0 | 1
+	code[2] &^= 0x80
+	if evex && properties.laneBytes == 8 {
+		code[2] |= 0x80
+	}
+	if evex {
+		code[3] |= byte(map[int]int{16: 0, 32: 1, 64: 2}[width]) << 5
+		if broadcast {
+			code[3] |= 0x10
+		}
+	} else if width == 32 {
+		code[2] |= 0x04
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = properties.laneBytes
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*29+11))
+	}
+	return code
+}
+
+func x86PackedArithmeticOpcodes() []byte {
+	opcodes := make([]byte, 0, len(decodedX86PackedIntegerArithmeticOps))
+	for opcode := range decodedX86PackedIntegerArithmeticOps {
+		opcodes = append(opcodes, opcode)
+	}
+	sort.Slice(opcodes, func(i, j int) bool { return opcodes[i] < opcodes[j] })
+	return opcodes
+}
+
+func TestDecodeX86RawPackedArithmeticRIPDataCompleteFamily(t *testing.T) {
+	for _, opcode := range x86PackedArithmeticOpcodes() {
+		properties := decodedX86PackedIntegerArithmeticOps[opcode]
+		for _, evex := range []bool{false, true} {
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				broadcasts := []bool{false}
+				if evex && properties.laneBytes >= 4 {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("%s/evex%t/%d/bcst%t", properties.op, evex, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawPackedArithmeticLiteral(opcode, evex, width, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := properties.op
+						if broadcast {
+							want += ".BCST"
+						}
+						if evex {
+							want += ".Z"
+						}
+						if len(decoded) != 2 || decoded[0].Op != want ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawPackedArithmeticRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawPackedArithmeticLiteral(0xd4, true, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedArithmeticRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	var pools [][]byte
+	for index, opcode := range x86PackedArithmeticOpcodes() {
+		properties := decodedX86PackedIntegerArithmeticOps[opcode]
+		evex := index%2 == 0
+		width := 32
+		if evex {
+			width = 64
+		}
+		broadcast := evex && properties.laneBytes >= 4
+		code := x86RawPackedArithmeticLiteral(opcode, evex, width, broadcast)
+		name := fmt.Sprintf("packedArithmeticLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		dataWidth := width
+		if broadcast {
+			dataWidth = properties.laneBytes
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// The complete original source includes EVEX forms with missing K7.
+			// Keep its Go/emitter objects and public Context independently of
+			// the initialized full-family public object programs.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "packed-arithmetic-literal.ll", "packed-arithmetic-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_packed_compare.go b/amd64_raw_packed_compare.go
new file mode 100644
index 000000000..7cc99c769
--- /dev/null
+++ b/amd64_raw_packed_compare.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func decodedX86PackedIntegerCompareInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedIntegerCompareInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedIntegerCompareInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	var spec amd64PackedIntegerCompareSpec
+	for name, candidate := range amd64PackedIntegerCompareSpecs {
+		if p.mapNumber == candidate.mapNumber && p.opcode == candidate.opcode {
+			op, spec = name, candidate
+			break
+		}
+	}
+	if op == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed integer compare: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.pp != 1 || p.vectorLength > 2 {
+		return fail("invalid prefix or vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	// Intel XED leaves VEX.W and EVEX byte/word W unconstrained. D/Q
+	// EVEX requires W0/W1. MASK_R reserves both destination extension bits.
+	if p.evex && (!p.fixed || p.zero || p.r != 0 || spec.laneBits >= 32 && p.w != (spec.laneBits == 64)) {
+		return fail("invalid EVEX fixed, zeroing, destination or width field")
+	}
+	if p.broadcast && (spec.laneBits < 32 || code[p.modRM]>>6 == 3) {
+		return fail("broadcast requires D/Q memory source")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+	width := []string{"X", "Y", "Z"}[p.vectorLength]
+	byteWidth := 16 << p.vectorLength
+	scale := byteWidth
+	if p.broadcast {
+		scale = spec.laneBits / 8
+		op += ".BCST"
+	}
+	var source Operand
+	var size int
+	var err error
+	if p.evex {
+		source, size, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, width, scale)
+	} else {
+		source, size, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	dst := Reg(fmt.Sprintf("%s%d", width, int(code[p.modRM]>>3&7)+p.r*8))
+	args := []Operand{source, {Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}}
+	if p.evex {
+		dst = Reg(fmt.Sprintf("K%d", code[p.modRM]>>3&7))
+		if p.mask != 0 {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+		}
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: dst})
+	parts := make([]string, len(args))
+	for i, arg := range args {
+		parts[i] = arg.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(parts, ", ")), x86Encoded: true}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_packed_compare_literal_test.go b/amd64_raw_packed_compare_literal_test.go
new file mode 100644
index 000000000..e71aebcd2
--- /dev/null
+++ b/amd64_raw_packed_compare_literal_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawPackedCompareLiteral(op string, evex bool, width int, broadcast bool) []byte {
+	spec := amd64PackedIntegerCompareSpecs[Op(op)]
+	code := encodeRawScalarMove(evex, 1, spec.opcode, 0, 0, 0, 0, false)
+	code[1] = code[1]&0xf0 | byte(spec.mapNumber)
+	code[2] &^= 0x80
+	if evex && spec.laneBits == 64 {
+		code[2] |= 0x80
+	}
+	if evex {
+		code[3] |= byte(map[int]int{16: 0, 32: 1, 64: 2}[width]) << 5
+		if broadcast {
+			code[3] |= 0x10
+		}
+	} else if width == 32 {
+		code[2] |= 0x04
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = spec.laneBits / 8
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*17+5))
+	}
+	return code
+}
+
+func TestDecodeX86RawPackedCompareRIPDataCompleteFamily(t *testing.T) {
+	for _, op := range x86PackedCompareTestOps {
+		for _, evex := range []bool{false, true} {
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				broadcasts := []bool{false}
+				if evex && amd64PackedIntegerCompareSpecs[Op(op)].laneBits >= 32 {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("%s/evex%t/%d/bcst%t", op, evex, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawPackedCompareLiteral(op, evex, width, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := Op(op)
+						if broadcast {
+							want += ".BCST"
+						}
+						if len(decoded) != 2 || decoded[0].Op != want ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawPackedCompareRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawPackedCompareLiteral("VPCMPEQD", true, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedCompareRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	var pools [][]byte
+	for index, op := range x86PackedCompareTestOps {
+		spec := amd64PackedIntegerCompareSpecs[Op(op)]
+		evex := index%2 == 0
+		width := 32
+		if evex {
+			width = 64
+		}
+		broadcast := evex && spec.laneBits >= 32
+		code := x86RawPackedCompareLiteral(op, evex, width, broadcast)
+		name := fmt.Sprintf("packedCompareLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		dataWidth := width
+		if broadcast {
+			dataWidth = spec.laneBits / 8
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Original encodings leave the second vector input undefined.
+			// Preserve their full Go/emitter objects and public Context;
+			// independent initialized literal programs own public objects.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "packed-compare-literal.ll", "packed-compare-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_packed_compare_test.go b/amd64_raw_packed_compare_test.go
new file mode 100644
index 000000000..79c002f08
--- /dev/null
+++ b/amd64_raw_packed_compare_test.go
@@ -0,0 +1,518 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86PackedCompareTestOps = []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"}
+
+func TestX86PackedCompareGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`(?s)\{as: A(\w+), ytab: _yvpcmpeqb, prefix: Pavx, op: opBytes\{(.*?)\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 8 || len(rows) != len(amd64PackedIntegerCompareSpecs) {
+		t.Fatalf("Go has %d family entries, grammar has %d", len(rows), len(amd64PackedIntegerCompareSpecs))
+	}
+	for _, row := range rows {
+		spec, ok := amd64PackedIntegerCompareSpecs[Op(row[1])]
+		if !ok {
+			t.Fatalf("missing Go family member %s", row[1])
+		}
+		width := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[row[1][len(row[1])-1]]
+		if spec.laneBits != width || spec.greater != strings.Contains(row[1], "GT") {
+			t.Fatalf("incorrect semantics for %s: %+v", row[1], spec)
+		}
+		opcodes := regexp.MustCompile(`0x[0-9A-F]+`).FindAllString(row[2], -1)
+		if len(opcodes) != 5 {
+			t.Fatalf("Go %s has %d encodings", row[1], len(opcodes))
+		}
+		for _, opcode := range opcodes {
+			if opcode != fmt.Sprintf("0x%X", spec.opcode) {
+				t.Fatalf("Go opcode %s != spec %+v", opcode, spec)
+			}
+		}
+		if strings.Contains(row[2], "0F38") != (spec.mapNumber == 2) || strings.Contains(row[2], "evexBcst") != (width >= 32) {
+			t.Fatalf("Go map/broadcast does not match %+v: %s", spec, row[2])
+		}
+	}
+	table := regexp.MustCompile(`(?s)var _yvpcmpeqb = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(data))
+	if len(table) != 2 {
+		t.Fatal("missing Go operand table")
+	}
+	args := regexp.MustCompile(`argList\{([^}]+)\}`).FindAllStringSubmatch(table[1], -1)
+	want := []string{"Yxm, Yxr, Yxr", "Yym, Yyr, Yyr", "YxmEvex, YxrEvex, Yk", "YxmEvex, YxrEvex, Yknot0, Yk", "YymEvex, YyrEvex, Yk", "YymEvex, YyrEvex, Yknot0, Yk", "Yzm, Yzr, Yk", "Yzm, Yzr, Yknot0, Yk"}
+	if len(args) != len(want) {
+		t.Fatalf("Go operand rows %d != %d", len(args), len(want))
+	}
+	for i, arg := range args {
+		if arg[1] != want[i] {
+			t.Fatalf("Go row %d=%s, want %s", i, arg[1], want[i])
+		}
+	}
+}
+
+func TestX86RawPackedCompareEncodingAxes(t *testing.T) {
+	count := 0
+	for _, op := range x86PackedCompareTestOps {
+		// The test's encoding map is independent of the implementation spec.
+		opcode := map[string]byte{"VPCMPEQB": 0x74, "VPCMPEQW": 0x75, "VPCMPEQD": 0x76, "VPCMPEQQ": 0x29, "VPCMPGTB": 0x64, "VPCMPGTW": 0x65, "VPCMPGTD": 0x66, "VPCMPGTQ": 0x37}[op]
+		mapNumber := byte(1)
+		if strings.HasSuffix(op, "Q") {
+			mapNumber = 2
+		}
+		for _, evex := range []bool{false, true} {
+			limit, destLimit, widths := 16, 16, 2
+			if evex {
+				limit, destLimit, widths = 32, 8, 3
+			}
+			for width := 0; width < widths; width++ {
+				for src1 := 0; src1 < limit; src1++ {
+					for src2 := 0; src2 < limit; src2++ {
+						for dst := 0; dst < destLimit; dst++ {
+							code := encodeRawScalarMove(evex, 1, int(opcode), src2, src1, dst, 0, false)
+							code[1] = code[1]&0xe0 | mapNumber
+							if evex {
+								// Preserve R' (K destination extension) when replacing map.
+								code[1] |= 0x10
+								code[2] &^= 0x80
+								if mapNumber == 2 {
+									code[2] |= 0x80
+								}
+								code[3] |= byte(width)<<5 | byte(dst)
+							} else {
+								code[2] |= byte(width) << 2
+							}
+							variants := 1
+							if !evex {
+								variants = 2
+							}
+							for variant := 0; variant < variants; variant++ {
+								if variant != 0 {
+									code[2] |= 0x80
+								}
+								got, size, matched, err := decodedX86PackedIntegerCompareInstruction(code, 64)
+								prefix := []string{"X", "Y", "Z"}[width]
+								args := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src2))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src1))}}
+								dest := Reg(fmt.Sprintf("%s%d", prefix, dst))
+								if evex {
+									dest = Reg(fmt.Sprintf("K%d", dst))
+									if dst != 0 {
+										args = append(args, Operand{Kind: OpReg, Reg: dest})
+									}
+								}
+								args = append(args, Operand{Kind: OpReg, Reg: dest})
+								if err != nil || !matched || size != len(code) || got.Op != Op(op) || !reflect.DeepEqual(got.Args, args) {
+									t.Fatalf("decode %x: %+v %d %v %v; want %s %+v", code, got, size, matched, err, op, args)
+								}
+								_, _, matched, err = decodedX86PackedIntegerCompareInstruction(code, 32)
+								if !matched || (err != nil) != (src1 >= 8 || src2 >= 8 || !evex && dst >= 8) {
+									t.Fatalf("386 decode %x: matched=%v err=%v", code, matched, err)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 327680 {
+		t.Fatalf("covered %d encodings, want 327680", count)
+	}
+}
+
+func TestX86RawPackedCompareInvalidAndMemoryForms(t *testing.T) {
+	valid := []byte{0x62, 0xf1, 0x75, 0x0b, 0x76, 0xe0} // VPCMPEQD X0,X1,K3,K4.
+	for name, mutate := range map[string]func([]byte){
+		"fixed": func(b []byte) { b[2] &^= 4 }, "length": func(b []byte) { b[3] |= 0x60 },
+		"zero": func(b []byte) { b[3] |= 0x80 }, "broadcast-register": func(b []byte) { b[3] |= 0x10 },
+		"width": func(b []byte) { b[2] |= 0x80 }, "mask-dest-r": func(b []byte) { b[1] &^= 0x80 },
+		"mask-dest-rprime": func(b []byte) { b[1] &^= 0x10 }, "prefix": func(b []byte) { b[2] &^= 3 },
+	} {
+		b := append([]byte(nil), valid...)
+		mutate(b)
+		if _, _, matched, err := decodedX86PackedIntegerCompareInstruction(b, 64); !matched || err == nil {
+			t.Fatalf("accepted %s %x", name, b)
+		}
+	}
+	for _, b := range [][]byte{valid[:5], {0x62, 0xf1, 0x75, 0x0b, 0x76, 0x04}, {0x62, 0xf1, 0x75, 0x0b, 0x76, 0x40}, append([]byte{0x67}, valid...), {0x62, 0xf1, 0x75, 0x1b, 0x74, 0x00}, {0xc5, 0xf9, 0x74}, {0xc4, 0xe1, 0x79, 0x76, 0x05, 0, 0, 0, 0}} {
+		if _, _, matched, err := decodedX86PackedIntegerCompareInstruction(b, 64); !matched || err == nil {
+			t.Fatalf("accepted invalid %x", b)
+		}
+	}
+	if _, _, matched, err := decodedX86PackedIntegerCompareInstruction(valid, 16); !matched || err == nil {
+		t.Fatal("accepted mode16")
+	}
+	for _, b := range [][]byte{nil, {0x62}, {0x90}, {0xc5, 0xf9, 0x73, 0xc0}} {
+		if _, _, matched, err := decodedX86PackedIntegerCompareInstruction(b, 64); matched || err != nil {
+			t.Fatalf("claimed unrelated %x", b)
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		for _, broadcast := range []bool{false, true} {
+			b := []byte{segment.prefix, 0x62, 0x91, 0x75, 0x4b, 0x76, 0x64, 0x88, 0xfe}
+			offset := int64(-128)
+			op := Op("VPCMPEQD")
+			if broadcast {
+				b[4] |= 0x10
+				offset = -8
+				op += ".BCST"
+			}
+			got, size, matched, err := decodedX86PackedIntegerCompareInstruction(b, 64)
+			want := MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: offset}
+			if err != nil || !matched || size != len(b) || got.Op != op || !reflect.DeepEqual(got.Args[0].Mem, want) {
+				t.Fatalf("decode %x=%+v: %v", b, got, err)
+			}
+		}
+	}
+	// Byte/word EVEX.W is ignored, whereas dword and qword W is fixed.
+	for _, opcode := range []byte{0x74, 0x75, 0x64, 0x65} {
+		b := append([]byte(nil), valid...)
+		b[4] = opcode
+		b[2] |= 0x80
+		if _, _, matched, err := decodedX86PackedIntegerCompareInstruction(b, 64); !matched || err != nil {
+			t.Fatalf("ignored W: %x %v", b, err)
+		}
+	}
+}
+
+func TestX86RawPackedCompareGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			last := 7
+			if arch == "amd64" {
+				last = 31
+			}
+			var source strings.Builder
+			source.WriteString("TEXT compare(SB),4,$0-0\n")
+			for _, op := range x86PackedCompareTestOps {
+				for _, width := range []string{"X", "Y", "Z"} {
+					for _, reg := range []int{0, last} {
+						inputs := []string{fmt.Sprintf("%s%d", width, last-reg), "(AX)", "-7(BX)(CX*4)", "64(SI)", "8192(DI)"}
+						for _, input := range inputs {
+							fmt.Fprintf(&source, "%s %s,%s%d,K0\n", op, input, width, reg)
+							if arch == "amd64" {
+								fmt.Fprintf(&source, "%s %s,%s%d,K7,K7\n", op, input, width, reg)
+							}
+						}
+						if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+							for _, input := range []string{"(AX)", "-8(BX)(CX*4)", "64(SI)", "8192(DI)"} {
+								fmt.Fprintf(&source, "%s.BCST %s,%s%d,K7\n", op, input, width, reg)
+								if arch == "amd64" {
+									fmt.Fprintf(&source, "%s.BCST %s,%s%d,K1,K0\n", op, input, width, reg)
+								}
+							}
+						}
+					}
+					if width != "Z" {
+						for _, input := range []string{width + "0", "(AX)", "-7(BX)(CX*4)", "8192(DI)"} {
+							fmt.Fprintf(&source, "%s %s,%s6,%s7\n", op, input, width, width)
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			got, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(got.Instrs) != len(want) {
+				t.Fatalf("got %d instructions, want %d", len(got.Instrs), len(want))
+			}
+			for i, instruction := range got.Instrs {
+				if instruction.Op != want[i].Op || !reflect.DeepEqual(instruction.Args, want[i].Args) {
+					t.Fatalf("instruction %d: %+v, want %+v", i, instruction, want[i])
+				}
+			}
+			file := x86RawUnprovedReturnFormProbeFile(t, arch, "compare", code)
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "compare.ll", "compare.o", ir)
+			}
+			t.Logf("%s: %d actual Go encodings", arch, len(want)-1)
+		})
+	}
+}
+
+func TestX86PackedCompareGo386HighRegisters(t *testing.T) {
+	for _, op := range x86PackedCompareTestOps {
+		for _, width := range []string{"X", "Y"} {
+			for _, regs := range [][3]int{{8, 0, 1}, {0, 8, 1}, {0, 1, 8}, {15, 14, 13}} {
+				operands := fmt.Sprintf("%s%d,%s%d,%s%d", width, regs[0], width, regs[1], width, regs[2])
+				for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+					t.Run(op+"/"+operands+"/"+triple, func(t *testing.T) {
+						source := "TEXT ·compare(SB),4,$0-0\n" + op + " " + operands + "\nRET\n"
+						// Preserve actual Go frontend acceptance, without treating
+						// those names as physical mode32 register identities.
+						x86LEAActualTargetGoObject(t, "386", triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86PackedIntegerCompareAPI(t, source, "func compare()\n", "386", triple, api)
+								if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Fatalf("frontend high bank borrowed physical permission: IR=%d err=%v", len(ir), err)
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedCompareGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86PackedCompareTestOps {
+			lines := []string{op + " X0,Y1,Y2", op + " Z0,Z1,Z2", op + " X16,X1,X2", op + " X0,X1,(AX)", op + ".Z X0,X1,K1", op + ".SAE X0,X1,K1", op + " X0,X1,K0,K2", op + ".BCST X0,X1,K2"}
+			if strings.HasSuffix(op, "B") || strings.HasSuffix(op, "W") {
+				lines = append(lines, op+".BCST (AX),X1,K2")
+			}
+			if arch == "386" {
+				lines = append(lines, op+" Z8,Z0,K1", op+" X0,X1,K1,K2")
+			}
+			for _, line := range lines {
+				dir := t.TempDir()
+				path := filepath.Join(dir, "invalid.s")
+				if err := os.WriteFile(path, []byte("TEXT bad(SB),4,$0-0\n"+line+"\nRET\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), path)
+				cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+				if out, err := cmd.CombinedOutput(); err == nil {
+					t.Fatalf("Go %s accepted %s: %s", arch, line, out)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				assertX86PackedSignedGreaterThanRejected(t, arch, triple, line)
+			}
+		}
+	}
+}
+
+func TestX86PackedCompareMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	cross := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !cross {
+		t.Skip("execution requires amd64 or Rosetta; five-target object tests remain required")
+	}
+	var source, decl strings.Builder
+	checks := map[string]*strings.Builder{"views": {}, "memory": {}}
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, op := range x86PackedCompareTestOps {
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		greater := 0
+		if strings.Contains(op, "GT") {
+			greater = 1
+		}
+		for w, width := range []string{"X", "Y", "Z"} {
+			for mode := 0; mode < 5; mode++ { // VEX reg/mem; EVEX reg/mem/broadcast.
+				if mode < 2 && w == 2 || mode == 4 && bits < 32 {
+					continue
+				}
+				for alias := 0; alias < 2; alias++ {
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("compare%d", index)
+						index++
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),DI\nVMOVUPS (AX),Z0\n", name)
+						input := "(BX)"
+						if mode == 0 || mode == 2 {
+							source.WriteString("VMOVUPS (BX),Z1\n")
+							input = width + "1"
+						}
+						dst := width + "0"
+						if alias == 1 {
+							dst = width + "1"
+						}
+						if mode < 2 {
+							emitX86GoEncodedTestInstruction(t, &source, fmt.Sprintf("%s %s,%s0,%s", op, input, width, dst), raw)
+							fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\n", alias, alias, alias)
+						} else {
+							dst = "K7"
+							if alias == 1 {
+								dst = "K1"
+							}
+							suffix := ""
+							if mode == 4 {
+								suffix = ".BCST"
+							}
+							source.WriteString("KMOVQ mask+24(FP),K1\n")
+							emitX86GoEncodedTestInstruction(t, &source, fmt.Sprintf("%s%s %s,%s0,K1,%s", op, suffix, input, width, dst), raw)
+							fmt.Fprintf(&source, "KMOVQ %s,(DI)\nVMOVUPS Z0,16(DI)\n", dst)
+						}
+						source.WriteString("RET\n")
+						sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1}}}}
+						fmt.Fprintf(&decl, "extern void %s(const void*,const void*,void*,uint64_t);\n", name)
+						kind := "views"
+						if mode >= 2 {
+							kind = "memory"
+						}
+						fmt.Fprintf(checks[kind], "if(check(%s,%d,%d,%d,%d)) {fprintf(stderr,\"%s failed\\n\");return 1;}\n", name, 16<<w, bits/8, greater, mode, name)
+					}
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if cross {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + x86TestGuardPagesC + decl.String() + `
+static uint64_t lane(const uint8_t *p,int bytes) {uint64_t v=0;memcpy(&v,p,bytes);return v;}
+static int cmp(const uint8_t *a,const uint8_t *b,int bytes,int gt) {
+ uint64_t x=lane(a,bytes),y=lane(b,bytes),sign=UINT64_C(1)<<(bytes*8-1);
+ return gt ? (x^sign)>(y^sign) : x==y;
+}
+static int check(void(*fn)(const void*,const void*,void*,uint64_t),int width,int bytes,int gt,int mode) {
+ for(int n=0;n<64;n++) {
+  uint8_t ab[65],bb[65],out[128],want[112]={0};uint8_t *a=ab+1,*b=bb+1;
+  for(int i=0;i<64;i++) {a[i]=(uint8_t)(i*37+n*19);b[i]=(n%3==0)?a[i]:(uint8_t)(i*13-n*7);}
+  uint64_t mask=(n==0)?0:(n==1)?UINT64_C(1)<<63:(n==2)?UINT64_MAX:UINT64_C(0x5a5a01239876cdef)>>(n%32),expected=0;
+  int lanes=width/bytes;
+  if(mode<2) {
+   for(int i=0;i<lanes;i++) memset(want+i*bytes,cmp(a+i*bytes,b+i*bytes,bytes,gt)?255:0,bytes);
+   memcpy(want+64,want,32);memcpy(want+96,want,16);
+   fn(a,b,out,mask);
+   if(memcmp(out,want,112)) {fprintf(stderr,"vector compare mismatch mode=%d width=%d bytes=%d n=%d\n",mode,width,bytes,n);return 1;}
+  } else {
+   uint64_t active=lanes==64?mask:mask&((UINT64_C(1)<<lanes)-1);
+   for(int i=0;i<lanes;i++) if((active>>i)&1) expected|=(uint64_t)cmp(a+i*bytes,b+(mode==4?0:i*bytes),bytes,gt)<<i;
+   fn(a,(mode>=3 && !active)?NULL:b,out,mask);
+   if(lane(out,8)!=expected || memcmp(out+16,a,64)) {fprintf(stderr,"mask compare mismatch mode=%d width=%d bytes=%d n=%d\n",mode,width,bytes,n);return 1;}
+  }
+ }
+ if(mode>=3) {
+  // Only the enabled source lanes are accessible. This detects an eager
+  // full-width read even when the mask is nonzero, not just NULL/zero mask.
+  uint8_t a[64],out[128];memset(a,0,64);
+  int lanes=width/bytes;
+  for(int enabled=1;enabled<=lanes;enabled++) {
+   int readable=(mode==4)?bytes:enabled*bytes;
+   uint8_t *b=guard+page-readable;memset(b,0,(size_t)readable);
+   uint64_t mask=enabled==64?UINT64_MAX:(UINT64_C(1)<<enabled)-1;
+   fn(a,b,out,mask);
+   if(lane(out,8)!=(gt?0:mask) || memcmp(out+16,a,64))return 1;
+  }
+ }
+ return 0;
+}
+`
+	for _, kind := range []string{"views", "memory"} {
+		t.Run(kind, func(t *testing.T) {
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_compare_"+kind, triple, ir, mainC+"int main(void) {\nif(setup_guard())return 2;\n"+checks[kind].String()+"return free_guard();\n}\n", prefix)
+		})
+	}
+}
+
+func TestX86RawPackedCompare386Mask(t *testing.T) {
+	// Raw instructions have architectural operands, not Go's textual 386
+	// frontend three-operand limit. Both source vectors are physical X0-7.
+	code := assembleX87ControlBytes(t, "amd64", "TEXT compare(SB),4,$0-0\nVPCMPEQB (AX),X1,K2,K3\nRET\n")
+	file := x86RawUnprovedReturnFormProbeFile(t, "386", "compare", code)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir := x86UnboundVoidRawProbeObject(t, file, "386", triple)
+		compileLLVMToObject(t, llc, triple, "masked-386.ll", "masked-386.o", ir)
+	}
+}
+
+func TestX86PackedCompareFrameSpanValidation(t *testing.T) {
+	for _, op := range x86PackedCompareTestOps {
+		for w, width := range []string{"X", "Y", "Z"} {
+			for _, masked := range []bool{false, true} {
+				mask := ""
+				if masked {
+					mask = "K1,"
+				}
+				original := fmt.Sprintf("TEXT frame(SB),4,$0-8\n%s a+0(FP),%s0,%sK7\nRET\n", op, width, mask)
+				file, err := Parse(ArchAMD64, original)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, valid := range []bool{false, true} {
+					chunks := 1
+					if valid {
+						chunks = (16 << w) / 8
+					}
+					sig := FuncSig{Name: "frame", Ret: Void}
+					for i := 0; i < chunks; i++ {
+						sig.Args = append(sig.Args, I64)
+						sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i * 8), Type: I64, Index: i, Field: -1})
+					}
+					options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"frame": sig}}
+					// Preserve the original malformed whole-function contract:
+					// it declares eight bytes and defines neither vector nor mask.
+					requireX86GoAssemblerResult(t, "amd64", original, true)
+					if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original comparison invented inputs or enlarged its explicit TEXT extent", err)
+					}
+					var arguments []string
+					for i := 0; i < chunks; i++ {
+						arguments = append(arguments, fmt.Sprintf("a%d uint64", i))
+					}
+					declaration := "func frame(" + strings.Join(arguments, ",") + ")"
+					initialized := fmt.Sprintf("TEXT frame(SB),4,$0-%d\nMOVL $-1,AX\nKMOVD AX,K1\nVPXORD Z0,Z0,Z0\n%s a0+0(FP),%s0,%sK7\nRET\n",
+						chunks*8, op, width, mask)
+					requireX86GoAssemblerResult(t, "amd64", initialized, true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, initialized, declaration, "amd64", options.TargetTriple, api)
+						if valid && err != nil || !valid && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+							t.Fatalf("%s %s masked=%v valid=%v API=%s: %v", op, width, masked, valid, api, err)
+						}
+						if valid && strings.Contains(ir, " = call <") && strings.Contains(ir, "@llvm.masked.load.") {
+							t.Fatal("FP slots must not be loaded through a contiguous native pointer")
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_raw_packed_dot.go b/amd64_raw_packed_dot.go
new file mode 100644
index 000000000..dcbdc5494
--- /dev/null
+++ b/amd64_raw_packed_dot.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import "fmt"
+
+// Go's _yvdppd/_yvblendpd rows encode VDPPD X and VDPPS X/Y with a
+// three-byte VEX, 66, map 0F3A and imm8. Intel defines VEX.W as ignored.
+// The generic decoder can instead split these bytes into legacy INC/branches.
+// Recover the whole instruction, keeping physical decoding separate from
+// source-layout, numerical-input and native-memory authority.
+func decodedX86VEXPackedDotInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86VEXPackedDotInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXPackedDotInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	segment := Reg("")
+	addressOverride, invalidPrefix, physicalSegment := false, false, false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+		case 0x65:
+			segment = GS
+		case 0x26, 0x2e, 0x36, 0x3e:
+			physicalSegment = true
+		case 0x67:
+			addressOverride = true
+		case 0x66, 0xf2, 0xf3, 0xf0:
+			invalidPrefix = true
+		default:
+			if mode == 64 && code[i]&0xf0 == 0x40 {
+				invalidPrefix = true
+				break
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	if len(code) >= i+5 && code[i] == 0x62 && code[i+1]&7 == 3 &&
+		(code[i+4] == 0x40 || code[i+4] == 0x41) {
+		return Instr{}, 0, true, fmt.Errorf("packed dot products have no EVEX encoding")
+	}
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 3 ||
+		(code[i+3] != 0x40 && code[i+3] != 0x41) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(reason string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VEX packed dot: %s", reason)
+	}
+	if invalidPrefix {
+		return fail("machine-invalid legacy/REX prefix before VEX")
+	}
+	if physicalSegment || addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("%w: VEX packed dot needs its original physical segment/address layout", ErrProbeNeedsContext)
+	}
+	p0, p1, opcode := code[i+1], code[i+2], code[i+3]
+	if p1&3 != 1 {
+		return fail("VEX.pp must select 66")
+	}
+	if opcode == 0x41 && p1&4 != 0 {
+		return fail("VDPPD requires VEX.128")
+	}
+	modRMIndex := i + 4
+	if len(code) <= modRMIndex {
+		return fail("missing ModRM byte")
+	}
+	rExt, xExt, bExt := int(^p0>>7)&1, int(^p0>>6)&1, int(^p0>>5)&1
+	secondNumber := int(^p1>>3) & 15
+	destinationNumber := int(code[modRMIndex]>>3&7) + rExt*8
+	if mode == 32 && (rExt != 0 || xExt != 0 || bExt != 0 || secondNumber >= 8 || destinationNumber >= 8) {
+		return fail("extended register in physical mode32")
+	}
+	bank, width := "X", 16
+	if p1&4 != 0 {
+		bank, width = "Y", 32
+	}
+	first, consumed, err := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, bank)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediateIndex := modRMIndex + consumed
+	if len(code) <= immediateIndex {
+		return fail("missing immediate byte")
+	}
+	length := immediateIndex + 1
+	if length > 15 {
+		return fail("instruction exceeds 15 bytes")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", bank, secondNumber))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", bank, destinationNumber))}
+	op := Op("VDPPS")
+	if opcode == 0x41 {
+		op = "VDPPD"
+	}
+	return Instr{
+		Op: op, Args: []Operand{immediate, first, second, destination},
+		Raw:        fmt.Sprintf("%s %s, %s, %s, %s", op, immediate, first, second, destination),
+		x86Encoded: true, x86VectorBytes: width,
+	}, length, true, nil
+}
diff --git a/amd64_raw_packed_dot_test.go b/amd64_raw_packed_dot_test.go
new file mode 100644
index 000000000..e71e645c4
--- /dev/null
+++ b/amd64_raw_packed_dot_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+type x86RawDotOracleShape struct {
+	op    Op
+	code  byte
+	bank  string
+	width int
+}
+
+var x86RawDotOracleShapes = []x86RawDotOracleShape{
+	{"VDPPD", 0x41, "X", 16},
+	{"VDPPS", 0x40, "X", 16},
+	{"VDPPS", 0x40, "Y", 32},
+}
+
+func x86RawDotOracleHeader(shape x86RawDotOracleShape, destination, second, bExt, xExt int, widthIgnored bool) []byte {
+	p0 := byte((1-destination/8)<<7 | (1-xExt)<<6 | (1-bExt)<<5 | 3)
+	p1 := byte((^second&15)<<3 | 1)
+	if shape.width == 32 {
+		p1 |= 4
+	}
+	if widthIgnored {
+		p1 |= 0x80
+	}
+	return []byte{0xc4, p0, p1, shape.code}
+}
+
+func x86RawDotOracleInstruction(shape x86RawDotOracleShape, first Operand, second, destination int, immediate byte) Instr {
+	return Instr{Op: shape.op, Args: []Operand{
+		{Kind: OpImm, Imm: int64(immediate)}, first,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", shape.bank, second))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", shape.bank, destination))},
+	}}
+}
+
+func x86RawDotRequireDecode(t *testing.T, code []byte, mode int, shape x86RawDotOracleShape, want Instr) {
+	t.Helper()
+	got, length, known, err := decodedX86VEXPackedDotInstruction(code, mode)
+	if err != nil || !known || length != len(code) || got.Op != want.Op ||
+		!reflect.DeepEqual(got.Args, want.Args) || !got.x86Encoded || got.x86VectorBytes != shape.width {
+		t.Fatalf("complete original packed dot %x mode%d: got=%+v length=%d known=%v err=%v want=%+v", code, mode, got, length, known, err, want)
+	}
+	arch := "amd64"
+	if mode == 32 {
+		arch = "386"
+	}
+	if _, known, err := x86PackedReductionProperties(got, arch); !known || err != nil {
+		t.Fatalf("exact physical dot did not share complete typed grammar: %+v: %v", got, err)
+	}
+}
+
+func TestDecodedX86VEXPackedDotCompleteRegistersAndSelectors(t *testing.T) {
+	count := 0
+	for _, mode := range []int{32, 64} {
+		limit := 16
+		if mode == 32 {
+			limit = 8
+		}
+		for _, shape := range x86RawDotOracleShapes {
+			t.Run(fmt.Sprintf("mode%d/%s/%s", mode, shape.op, shape.bank), func(t *testing.T) {
+				for _, widthIgnored := range []bool{false, true} {
+					for destination := 0; destination < limit; destination++ {
+						for second := 0; second < limit; second++ {
+							for first := 0; first < limit; first++ {
+								code := x86RawDotOracleHeader(shape, destination, second, first/8, 0, widthIgnored)
+								code = append(code, byte(0xc0|(destination&7)<<3|first&7), 0xa5)
+								input := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", shape.bank, first))}
+								x86RawDotRequireDecode(t, code, mode, shape, x86RawDotOracleInstruction(shape, input, second, destination, 0xa5))
+								count++
+							}
+						}
+					}
+					// Every imm8 is independent of the register-bank axis. Keep
+					// all ignored and meaningful selector bits for both sources.
+					for immediate := 0; immediate < 256; immediate++ {
+						for _, memory := range []bool{false, true} {
+							code := x86RawDotOracleHeader(shape, 2, 1, 0, 0, widthIgnored)
+							input := Operand{Kind: OpReg, Reg: Reg(shape.bank + "0")}
+							modRM := byte(0xd0)
+							if memory {
+								input = Operand{Kind: OpMem, Mem: MemRef{Base: BX}}
+								modRM = 0x13
+							}
+							code = append(code, modRM, byte(immediate))
+							x86RawDotRequireDecode(t, code, mode, shape, x86RawDotOracleInstruction(shape, input, 1, 2, byte(immediate)))
+						}
+					}
+				}
+			})
+		}
+	}
+	if count != 27648 {
+		t.Fatal("complete two-mode physical register matrix lost rows", count)
+	}
+}
+
+func TestDecodedX86VEXPackedDotMemoryPrefixesAndInvalidBoundaries(t *testing.T) {
+	registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI}
+	for _, mode := range []int{32, 64} {
+		for _, shape := range x86RawDotOracleShapes {
+			t.Run(fmt.Sprintf("mode%d/%s/%s", mode, shape.op, shape.bank), func(t *testing.T) {
+				for mod := 0; mod < 3; mod++ {
+					for rm := 0; rm < 8; rm++ {
+						sibLimit := 1
+						if rm == 4 {
+							sibLimit = 256
+						}
+						for sib := 0; sib < sibLimit; sib++ {
+							if mod == 0 && rm == 5 && mode == 64 {
+								continue // Original RIP layout has its separate negative below.
+							}
+							code := x86RawDotOracleHeader(shape, 2, 1, 0, 0, false)
+							code = append(code, byte(mod<<6|2<<3|rm))
+							mem := MemRef{Base: registers[rm]}
+							absolute := mod == 0 && rm == 5
+							if rm == 4 {
+								code = append(code, byte(sib))
+								mem.Base = registers[sib&7]
+								if sib>>3&7 != 4 {
+									mem.Index, mem.Scale = registers[sib>>3&7], int64(1<<uint(sib>>6))
+								}
+								absolute = mod == 0 && sib&7 == 5
+							}
+							if absolute {
+								mem.Base = ""
+							}
+							switch {
+							case mod == 1:
+								code = append(code, 0xf9)
+								mem.Off = -7
+							case mod == 2 || absolute:
+								var displacement [4]byte
+								binary.LittleEndian.PutUint32(displacement[:], 0x89abcdef)
+								code = append(code, displacement[:]...)
+								mem.Off = -0x76543211
+							}
+							code = append(code, 0x5a)
+							x86RawDotRequireDecode(t, code, mode, shape,
+								x86RawDotOracleInstruction(shape, Operand{Kind: OpMem, Mem: mem}, 1, 2, 0x5a))
+						}
+					}
+				}
+			})
+		}
+	}
+	shape := x86RawDotOracleShapes[2]
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		code := []byte{segment.prefix, 0xc4, 0x03, 0xe5, 0x40, 0x64, 0x88, 0x20, 0xa5}
+		input := Operand{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: 32}}
+		x86RawDotRequireDecode(t, code, 64, shape, x86RawDotOracleInstruction(shape, input, 3, 12, 0xa5))
+		if _, _, known, err := decodedX86VEXPackedDotInstruction(code, 32); !known || err == nil {
+			t.Fatal("physical mode32 borrowed extended GP/vector banks")
+		}
+	}
+	x86RawDotInvalidBoundaryOracle(t)
+}
+
+func x86RawDotInvalidBoundaryOracle(t *testing.T) {
+	t.Helper()
+	valid := []byte{0xc4, 0xe3, 0x71, 0x41, 0xd0, 0xff}
+	for name, code := range map[string][]byte{
+		"missing ModRM":  valid[:4],
+		"missing imm8":   valid[:5],
+		"VDPPD Y":        {0xc4, 0xe3, 0x75, 0x41, 0xd0, 0xff},
+		"wrong pp":       {0xc4, 0xe3, 0x70, 0x41, 0xd0, 0xff},
+		"missing SIB":    {0xc4, 0xe3, 0x71, 0x41, 0x14},
+		"partial disp8":  {0xc4, 0xe3, 0x71, 0x41, 0x53},
+		"partial disp32": {0xc4, 0xe3, 0x71, 0x41, 0x93, 1, 2, 3},
+		"illegal EVEX":   {0x62, 0xf3, 0x75, 0x08, 0x41, 0xd0, 0xff},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if got, _, known, err := decodedX86VEXPackedDotInstruction(code, 64); !known || err == nil {
+				t.Fatalf("invalid/truncated original bytes %x decoded as %+v known=%v err=%v", code, got, known, err)
+			}
+		})
+	}
+	for _, mode := range []int{32, 64} {
+		for _, prefix := range []byte{0x66, 0xf2, 0xf3, 0xf0} {
+			code := append([]byte{prefix}, valid...)
+			if _, _, known, err := decodedX86VEXPackedDotInstruction(code, mode); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("invalid prefix %x mode%d was erased or called Context: known=%v err=%v", code, mode, known, err)
+			}
+		}
+		for _, prefix := range []byte{0x26, 0x2e, 0x36, 0x3e, 0x67} {
+			code := append([]byte{prefix}, valid...)
+			if _, _, known, err := decodedX86VEXPackedDotInstruction(code, mode); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound original physical prefix %x mode%d gained source authority: known=%v err=%v", code, mode, known, err)
+			}
+		}
+	}
+	for _, code := range [][]byte{
+		{0xc4, 0x63, 0x71, 0x41, 0xd0, 0xff},       // R extension.
+		{0xc4, 0xa3, 0x71, 0x41, 0x14, 0x0b, 0xff}, // X extension.
+		{0xc4, 0xc3, 0x71, 0x41, 0xd0, 0xff},       // B extension.
+		{0xc4, 0xe3, 0x39, 0x41, 0xd0, 0xff},       // vvvv source8.
+	} {
+		if _, _, known, err := decodedX86VEXPackedDotInstruction(code, 32); !known || err == nil {
+			t.Fatalf("mode32 high-bank original bytes %x gained authority", code)
+		}
+	}
+	for rex := byte(0x40); rex <= 0x4f; rex++ {
+		if _, _, known, err := decodedX86VEXPackedDotInstruction(append([]byte{rex}, valid...), 64); !known || err == nil {
+			t.Fatal("machine-invalid REX+VEX prefix was discarded", rex)
+		}
+	}
+	tooLong := append([]byte{0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64}, valid...)
+	if _, _, known, err := decodedX86VEXPackedDotInstruction(tooLong, 64); !known || err == nil {
+		t.Fatal("overlong original instruction accepted")
+	}
+	rip := []byte{0xc4, 0xe3, 0x71, 0x41, 0x15, 1, 2, 3, 4, 0xff}
+	if _, _, known, err := decodedX86VEXPackedDotInstruction(rip, 64); !known || err == nil {
+		t.Fatal("unbound RIP input gained source-local storage")
+	}
+	physical, length, known, err := decodedX86VEXPackedDotInstructionWithMemory(rip, 64, x86RawMemoryDecoder{physicalPC: true})
+	if !known || err != nil || length != len(rip) || physical.Args[1].Mem.Base != "RIP" {
+		t.Fatal("physical native boundary observer lost the complete RIP instruction", physical, length, known, err)
+	}
+	for _, code := range [][]byte{{0xc4}, {0xc4, 0xe2, 0x71, 0x41, 0xd0, 0xff}, {0xc4, 0xe3, 0x71, 0x42, 0xd0, 0xff}} {
+		if _, _, known, err := decodedX86VEXPackedDotInstruction(code, 64); known || err != nil {
+			t.Fatalf("unrelated opcode/map %x was claimed by dot family", code)
+		}
+	}
+}
diff --git a/amd64_raw_packed_extend_test.go b/amd64_raw_packed_extend_test.go
new file mode 100644
index 000000000..2753703cd
--- /dev/null
+++ b/amd64_raw_packed_extend_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type rawPackedExtendTestSpec struct {
+	opcode     byte
+	op         Op
+	inputBits  int
+	outputBits int
+}
+
+var rawPackedExtendTestSpecs = []rawPackedExtendTestSpec{
+	{opcode: 0x20, op: "VPMOVSXBW", inputBits: 8, outputBits: 16},
+	{opcode: 0x21, op: "VPMOVSXBD", inputBits: 8, outputBits: 32},
+	{opcode: 0x22, op: "VPMOVSXBQ", inputBits: 8, outputBits: 64},
+	{opcode: 0x23, op: "VPMOVSXWD", inputBits: 16, outputBits: 32},
+	{opcode: 0x24, op: "VPMOVSXWQ", inputBits: 16, outputBits: 64},
+	{opcode: 0x25, op: "VPMOVSXDQ", inputBits: 32, outputBits: 64},
+	{opcode: 0x30, op: "VPMOVZXBW", inputBits: 8, outputBits: 16},
+	{opcode: 0x31, op: "VPMOVZXBD", inputBits: 8, outputBits: 32},
+	{opcode: 0x32, op: "VPMOVZXBQ", inputBits: 8, outputBits: 64},
+	{opcode: 0x33, op: "VPMOVZXWD", inputBits: 16, outputBits: 32},
+	{opcode: 0x34, op: "VPMOVZXWQ", inputBits: 16, outputBits: 64},
+	{opcode: 0x35, op: "VPMOVZXDQ", inputBits: 32, outputBits: 64},
+}
+
+func encodeX86VEXPackedExtend(opcode byte, width256 bool, destination, source int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source/8)<<5 | 2)
+	vex1 := byte(15<<3 | int(l)<<2 | 1)
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func encodeX86EVEXPackedExtend(opcode byte, vectorBits byte, mask int, zeroing bool, destination, source int) []byte {
+	p0 := byte((1-destination/8&1)<<7 | (1-source/16)<<6 | (1-source/8&1)<<5 | (1-destination/16)<<4 | 2)
+	p1 := byte(0x7d)
+	p2 := byte(vectorBits<<5 | 1<<3 | byte(mask))
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestTranslateRawEVEXPackedExtendWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawPackedExtend(SB), $0-0
+	LONG $0x487df262
+	WORD $0x2432
+	BYTE $0x07
+	RET
+`
+	// Original bytes lack DI/AX producers. Keep their Go object and
+	// three-API Context; the independent initialized block owns public success.
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, "zext i8") || !strings.Contains(ir, "to i64") {
+		t.Fatalf("raw VPMOVZXBQ lowering omitted byte-to-qword zero extension:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-evex-packed-extend.ll", "amd64-raw-evex-packed-extend.o", ir)
+}
+
+func TestTranslateRawVEXPackedExtendWeaviateBlockRegression(t *testing.T) {
+	lastExtend := []byte{0xc4, 0xe2, 0x7d, 0x31, 0x7e, 0x18}
+	if got, length, ok, err := decodedX86PackedExtendInstruction(lastExtend, 64); err != nil || !ok || length != len(lastExtend) || got.Op != "VPMOVZXBD" {
+		t.Fatalf("direct decode %x = %+v, length=%d, ok=%v, err=%v", lastExtend, got, length, ok, err)
+	}
+	const source = `TEXT rawPackedExtendBlock(SB), $0-0
+	LONG $0x317de2c4; BYTE $0x26
+	LONG $0x317de2c4; WORD $0x086e
+	LONG $0xe45bfcc5
+	LONG $0xed5bfcc5
+	LONG $0x317de2c4; WORD $0x1076
+	LONG $0xf65bfcc5
+	LONG $0x317de2c4; WORD $0x187e
+	LONG $0xff5bfcc5
+	LONG $0xb85de2c4; BYTE $0x1f
+	LONG $0xb855e2c4; WORD $0x2057
+	LONG $0xb84de2c4; WORD $0x404f
+	LONG $0xb845e2c4; WORD $0x6047
+	RET
+`
+	// This complete unchanged block lacks SI/DI and old accumulator inputs.
+	// Its format object is not initialized public translation or execution.
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if strings.Count(ir, "zext i8") < 4 || strings.Count(ir, "asm sideeffect \"vcvtdq2ps") != 4 {
+		t.Fatalf("raw VPMOVZXBD/VCVTDQ2PS block omitted conversions:\n%s", ir)
+	}
+	ir = x86SignedIntegerFloatOptimize(t, ir)
+	if strings.Count(ir, "asm sideeffect \"vcvtdq2ps") != 4 {
+		t.Fatal("O2 dropped raw VCVTDQ2PS side effects")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-packed-extend-block.ll", "amd64-raw-packed-extend-block.o", ir)
+}
+
+func TestDecodedX86PackedExtendCompleteVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawPackedExtendTestSpecs {
+		for _, width256 := range []bool{false, true} {
+			destinationPrefix := "X"
+			if width256 {
+				destinationPrefix = "Y"
+			}
+			for destination := 0; destination < 16; destination++ {
+				for source := 0; source < 16; source++ {
+					code := encodeX86VEXPackedExtend(spec.opcode, width256, destination, source)
+					got, length, ok, err := decodedX86PackedExtendInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantSource := fmt.Sprintf("X%d", source)
+					wantDestination := fmt.Sprintf("%s%d", destinationPrefix, destination)
+					if got.Op != spec.op || len(got.Args) != 2 || got.Args[0].String() != wantSource || got.Args[1].String() != wantDestination {
+						t.Fatalf("decode %x = %+v, want %s %s, %s", code, got, spec.op, wantSource, wantDestination)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 6144 {
+		t.Fatalf("covered %d VEX packed-extend register encodings, want 6144", count)
+	}
+}
+
+func TestDecodedX86PackedExtendCompleteEVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawPackedExtendTestSpecs {
+		for vectorBits, destinationPrefix := range []string{"X", "Y", "Z"} {
+			destinationBytes := 16 << vectorBits
+			sourcePrefix := "X"
+			if destinationBytes*spec.inputBits/spec.outputBits > 16 {
+				sourcePrefix = "Y"
+			}
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{
+				{},
+				{mask: 3},
+				{mask: 7, zeroing: true, suffix: ".Z"},
+			} {
+				for destination := 0; destination < 32; destination++ {
+					for source := 0; source < 32; source++ {
+						code := encodeX86EVEXPackedExtend(spec.opcode, byte(vectorBits), masking.mask, masking.zeroing, destination, source)
+						got, length, ok, err := decodedX86PackedExtendInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{fmt.Sprintf("%s%d", sourcePrefix, source)}
+						if masking.mask != 0 {
+							wantArgs = append(wantArgs, fmt.Sprintf("K%d", masking.mask))
+						}
+						wantArgs = append(wantArgs, fmt.Sprintf("%s%d", destinationPrefix, destination))
+						if got.Op != spec.op+Op(masking.suffix) || len(got.Args) != len(wantArgs) {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, spec.op+Op(masking.suffix), strings.Join(wantArgs, ", "))
+						}
+						for index := range wantArgs {
+							if got.Args[index].String() != wantArgs[index] {
+								t.Fatalf("decode %x = %+v, want %s %s", code, got, spec.op+Op(masking.suffix), strings.Join(wantArgs, ", "))
+							}
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 110592 {
+		t.Fatalf("covered %d EVEX packed-extend register encodings, want 110592", count)
+	}
+}
+
+func TestDecodedX86PackedExtendCompressedMemoryAndInvalidForms(t *testing.T) {
+	for _, spec := range rawPackedExtendTestSpecs {
+		for vectorBits, destinationPrefix := range []string{"X", "Y", "Z"} {
+			destinationBytes := 16 << vectorBits
+			sourceBytes := destinationBytes * spec.inputBits / spec.outputBits
+			code := encodeX86EVEXPackedExtend(spec.opcode, byte(vectorBits), 2, true, 21, 0)
+			code[5] = 0x68
+			code = append(code, 0x7f)
+			got, length, ok, err := decodedX86PackedExtendInstruction(code, 64)
+			wantSource := fmt.Sprintf("%d(AX)", sourceBytes*127)
+			wantDestination := fmt.Sprintf("%s21", destinationPrefix)
+			if err != nil || !ok || length != len(code) || got.Op != spec.op+".Z" || len(got.Args) != 3 || got.Args[0].String() != wantSource || got.Args[1].String() != "K2" || got.Args[2].String() != wantDestination {
+				t.Fatalf("decode %x = %+v, length=%d ok=%v err=%v; want %s.Z %s, K2, %s", code, got, length, ok, err, spec.op, wantSource, wantDestination)
+			}
+		}
+	}
+
+	valid := encodeX86VEXPackedExtend(0x32, false, 0, 0)
+	invalidVVVV := append([]byte(nil), valid...)
+	invalidVVVV[2] &^= 0x08
+	for name, code := range map[string][]byte{
+		"truncated":        {0xc4, 0xe2},
+		"wrong map":        {0xc4, 0xe1, 0x79, 0x32, 0xc0},
+		"wrong pp":         {0xc4, 0xe2, 0x78, 0x32, 0xc0},
+		"unrelated opcode": {0xc4, 0xe2, 0x79, 0x2f, 0xc0},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86PackedExtendInstruction(code, 64); matched || decodeErr != nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, code, instruction, matched, decodeErr)
+		}
+	}
+	// This family's VEX.W is ignored. It must not be confused with EVEX
+	// dword-to-qword W0, or rejected merely because Go emits canonical W0.
+	if ins, _, matched, err := decodedX86PackedExtendInstruction([]byte{0xc4, 0xe2, 0xf9, 0x32, 0xc0}, 64); !matched || err != nil || ins.Op != "VPMOVZXBQ" {
+		t.Fatalf("legal VEX.WIG form rejected: %+v/%v", ins, err)
+	}
+	if _, _, matched, decodeErr := decodedX86PackedExtendInstruction(invalidVVVV, 64); !matched || decodeErr == nil {
+		t.Fatalf("non-reserved VEX.vvvv encoding %x returned ok=%v err=%v", invalidVVVV, matched, decodeErr)
+	}
+	invalidBroadcast := encodeX86EVEXPackedExtend(0x32, 2, 1, false, 0, 0)
+	invalidBroadcast[3] |= 0x10
+	invalidBroadcast[5] = 0x40
+	invalidBroadcast = append(invalidBroadcast, 1)
+	if _, _, matched, decodeErr := decodedX86PackedExtendInstruction(invalidBroadcast, 64); !matched || decodeErr == nil {
+		t.Fatalf("EVEX broadcast returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_packed_float_move.go b/amd64_raw_packed_float_move.go
new file mode 100644
index 000000000..505887ec1
--- /dev/null
+++ b/amd64_raw_packed_float_move.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's packed move grammars share width, direction and memory axes. The pinned
+// generic decoder can misread VEX moves as legacy instructions or lose their
+// vector width, so decode the complete float and VEX integer families here.
+func decodedX86PackedMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedMoveInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedMoveInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || p.mapNumber != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	store := false
+	switch p.opcode {
+	case 0x28, 0x29:
+		if p.pp > 1 {
+			return Instr{}, 0, false, nil
+		}
+		op = Op("VMOVA" + []string{"PS", "PD"}[p.pp])
+		store = p.opcode == 0x29
+	case 0x10, 0x11:
+		if p.pp > 1 {
+			return Instr{}, 0, false, nil
+		}
+		op = Op("VMOVU" + []string{"PS", "PD"}[p.pp])
+		store = p.opcode == 0x11
+	case 0x6f, 0x7f:
+		if p.evex || (p.pp != 1 && p.pp != 2) {
+			return Instr{}, 0, false, nil
+		}
+		op = Op([]string{"", "VMOVDQA", "VMOVDQU"}[p.pp])
+		store = p.opcode == 0x7f
+	default:
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed float move: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.upper != 0 {
+		return fail("vvvv and V' must be reserved")
+	}
+	if p.evex && (!p.fixed || p.w != (p.pp == 1)) {
+		return fail("invalid EVEX fixed or width bit")
+	}
+	if p.vectorLength > 2 || p.broadcast {
+		return fail("reserved vector length or broadcast bit")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	registerForm := code[p.modRM]>>6 == 3
+	if p.zero && (p.mask == 0 || store && !registerForm) {
+		return fail("zeroing requires a nonzero mask and register destination")
+	}
+	width := []string{"X", "Y", "Z"}[p.vectorLength]
+	regNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && ((!p.evex || width == "Z") && regNumber >= 8) {
+		return fail("extended register unavailable in 32-bit mode")
+	}
+	reg := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, regNumber))}
+	var rm Operand
+	var consumed int
+	var err error
+	if p.evex {
+		rm, consumed, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, width, 16<<p.vectorLength)
+	} else {
+		rm, consumed, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	args := []Operand{rm, reg}
+	if store {
+		args[0], args[1] = reg, rm
+	}
+	if p.mask != 0 {
+		args = []Operand{args[0], {Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))}, args[1]}
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	printed := make([]string, len(args))
+	for i := range args {
+		printed[i] = args[i].String()
+	}
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86PackedVectorMoveEVEX: p.evex,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_packed_float_move_test.go b/amd64_raw_packed_float_move_test.go
new file mode 100644
index 000000000..2f3210d76
--- /dev/null
+++ b/amd64_raw_packed_float_move_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawPackedMoveGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT packedmoves(SB),4,$0-0\n")
+			for _, op := range []string{"VMOVAPS", "VMOVAPD", "VMOVUPS", "VMOVUPD", "VMOVDQA", "VMOVDQU", "VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+				vexInteger := op == "VMOVDQA" || op == "VMOVDQU"
+				widths := []string{"X", "Y", "Z"}
+				if vexInteger {
+					widths = widths[:2]
+				}
+				for _, width := range widths {
+					regs := []int{1, 7}
+					if arch == "amd64" {
+						regs = append(regs, 15, 16, 31)
+					}
+					if vexInteger && arch == "amd64" {
+						regs = regs[:3]
+					}
+					for _, reg := range regs {
+						masks := []string{"", "K1, ", "K7, "}
+						if vexInteger {
+							masks = masks[:1]
+						}
+						for _, mask := range masks {
+							for _, zero := range []bool{false, true} {
+								if zero && (mask == "" || vexInteger) {
+									continue
+								}
+								suffix := ""
+								if zero {
+									suffix = ".Z"
+								}
+								fmt.Fprintf(&source, "%s%s %s0,%s%s%d\n", op, suffix, width, mask, width, reg)
+								memories := []string{"(AX)", "64(BX)(CX*4)", "-4096(SI)"}
+								if arch == "amd64" && vexInteger {
+									memories = append(memories, "32(R8)(R9*2)")
+								}
+								for _, memory := range memories {
+									fmt.Fprintf(&source, "%s%s %s,%s%s%d\n", op, suffix, memory, mask, width, reg)
+									if !zero {
+										fmt.Fprintf(&source, "%s %s%d,%s%s\n", op, width, reg, mask, memory)
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+			var raw strings.Builder
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			// Bound each function's optimizer graph without dropping any
+			// encoding: thousands of moves in one function are unnecessarily
+			// expensive once overlapping register views are kept coherent.
+			for offset, index := 0, 0; offset < len(code)-1; index++ {
+				if index%64 == 0 {
+					if index != 0 {
+						raw.WriteString("RET\n")
+					}
+					name := fmt.Sprintf("packedmoves%d", index/64)
+					fmt.Fprintf(&raw, "TEXT %s(SB),4,$0-0\n", name)
+				}
+				_, size, matched, err := decodedX86PackedMoveInstruction(code[offset:], mode)
+				if !matched {
+					_, size, matched, err = decodedX86EVEXPackedIntegerMoveInstruction(code[offset:], mode)
+				}
+				if !matched || err != nil || size <= 0 {
+					t.Fatalf("instruction boundary at %d: matched=%v size=%d err=%v", offset, matched, size, err)
+				}
+				for _, b := range code[offset : offset+size] {
+					fmt.Fprintf(&raw, "BYTE $%#02x\n", b)
+				}
+				offset += size
+			}
+			raw.WriteString("RET\n")
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				// Every original format byte remains; the source never supplied
+				// incoming native addresses, masks or complete numerical inputs.
+				ir := x86UnboundVoidVectorMoveFormatObject(t, raw.String(), arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-packed-float-moves.ll", "raw-packed-float-moves.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawPackedFloatMoveEncodingAxes(t *testing.T) {
+	count := 0
+	for _, evex := range []bool{false, true} {
+		limit, widths := 16, 2
+		if evex {
+			limit, widths = 32, 3
+		}
+		for _, spec := range []struct {
+			op         Op
+			pp, opcode int
+		}{{"VMOVAPS", 0, 0x28}, {"VMOVAPD", 1, 0x28}, {"VMOVUPS", 0, 0x10}, {"VMOVUPD", 1, 0x10}} {
+			for width := 0; width < widths; width++ {
+				for direction := 0; direction < 2; direction++ {
+					for src := 0; src < limit; src++ {
+						for dst := 0; dst < limit; dst++ {
+							mask, zero := 0, false
+							if evex {
+								mask = (src + dst) & 7
+								zero = mask != 0 && dst&1 != 0
+							}
+							code := encodeRawScalarMove(evex, spec.pp, 0x10+direction, src, 0, dst, mask, zero)
+							if evex {
+								code[2] |= byte(spec.pp) << 7
+								code[3] |= byte(width) << 5
+							} else {
+								code[2] |= byte(width)<<2 | byte(dst&1)<<7 // VEX.W is ignored.
+							}
+							code[len(code)-2] = byte(spec.opcode + direction)
+							got, size, ok, err := decodedX86PackedMoveInstruction(code, 64)
+							op := spec.op
+							if zero {
+								op += ".Z"
+							}
+							prefix := []string{"X", "Y", "Z"}[width]
+							want := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src))}}
+							if mask != 0 {
+								want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+							}
+							want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, dst))})
+							if err != nil || !ok || size != len(code) || got.Op != op || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x=%+v size=%d ok=%v err=%v; want %s %+v", code, got, size, ok, err, op, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 28672 {
+		t.Fatalf("tested %d encodings, want 28672", count)
+	}
+}
+
+func TestX86RawPackedFloatMoveRejectsReservedEncodings(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc5, 0xf8, 0x10},       // Missing ModRM.
+		{0xc5, 0xf8, 0x10, 0x04}, // Missing SIB.
+		{0xc5, 0xf8, 0x10, 0x45}, // Missing displacement.
+		{0xc5, 0xf0, 0x10, 0xc0}, // Reserved vvvv.
+		{0x67, 0xc5, 0xf8, 0x10, 0x00},
+		{0x62, 0xf1, 0x78, 0x08, 0x10, 0xc0}, // Fixed bit.
+		{0x62, 0xf1, 0xfc, 0x08, 0x10, 0xc0}, // PS W1.
+		{0x62, 0xf1, 0x7d, 0x08, 0x10, 0xc0}, // PD W0.
+		{0x62, 0xf1, 0x7c, 0x00, 0x10, 0xc0}, // Reserved V'.
+		{0x62, 0xf1, 0x7c, 0x68, 0x10, 0xc0}, // Reserved length.
+		{0x62, 0xf1, 0x7c, 0x18, 0x10, 0x00}, // Broadcast.
+		{0x62, 0xf1, 0x7c, 0x88, 0x10, 0xc0}, // Zero mask K0.
+		{0x62, 0xf1, 0x7c, 0x89, 0x11, 0x00}, // Zeroing memory store.
+	} {
+		if _, _, ok, err := decodedX86PackedMoveInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid %x: matched=%v err=%v", code, ok, err)
+		}
+	}
+}
diff --git a/amd64_raw_packed_multiply_literal_test.go b/amd64_raw_packed_multiply_literal_test.go
new file mode 100644
index 000000000..acf2150be
--- /dev/null
+++ b/amd64_raw_packed_multiply_literal_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawPackedMultiplyLiteral(form x86PackedMultiplyForm, encoding string, width int, w, broadcast bool) []byte {
+	var code []byte
+	switch encoding {
+	case "vex2":
+		code = encodeX86VEX2PackedWordMultiply(form.opcode, width == 32, 0, 0, 0)
+	case "vex3":
+		code = encodeX86VEXPackedWordMultiply(form.mapID, form.opcode, width == 32, w, 0, 0, 0)
+	case "evex":
+		code = encodeX86EVEXPackedWordMultiply(
+			form.mapID, form.opcode, map[int]int{16: 0, 32: 1, 64: 2}[width],
+			7, w, true, 0, 0, 0,
+		)
+		if broadcast {
+			code[3] |= 0x10
+		}
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = form.broadcastByte
+		if w {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*43+19))
+	}
+	return code
+}
+
+func TestDecodeX86RawPackedMultiplyRIPDataCompleteFamily(t *testing.T) {
+	for _, form := range x86PackedMultiplyForms {
+		encodings := []string{"vex3", "evex"}
+		if form.mapID == 1 {
+			encodings = append(encodings, "vex2")
+		}
+		for _, encoding := range encodings {
+			widths := []int{16, 32}
+			if encoding == "evex" {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				wBits := []bool{false, true}
+				if encoding == "vex2" || encoding == "vex3" && form.opcode == 0x40 {
+					wBits = []bool{false}
+				}
+				for _, w := range wBits {
+					broadcasts := []bool{false}
+					if encoding == "evex" && form.broadcastByte != 0 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						name := fmt.Sprintf("%x/%x/%s/%d/w%t/bcst%t", form.mapID, form.opcode, encoding, width, w, broadcast)
+						t.Run(name, func(t *testing.T) {
+							code := x86RawPackedMultiplyLiteral(form, encoding, width, w, broadcast)
+							decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+							if err != nil {
+								t.Fatal(err)
+							}
+							want := form.vexOp
+							if encoding == "evex" {
+								want = form.evexW0Op
+								if w {
+									want = form.evexW1Op
+								}
+								if broadcast {
+									want += ".BCST"
+								}
+								want += ".Z"
+							}
+							if len(decoded) != 2 || decoded[0].Op != want ||
+								decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+								decoded[1].Op != OpRET {
+								t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawPackedMultiplyRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawPackedMultiplyLiteral(x86PackedMultiplyForms[4], "evex", 64, true, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedMultiplyRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, form := range x86PackedMultiplyForms {
+		encoding := "vex3"
+		width, w, broadcast := 32, false, false
+		if index%2 == 0 {
+			encoding, width = "evex", 64
+			broadcast = form.broadcastByte != 0
+		}
+		code := x86RawPackedMultiplyLiteral(form, encoding, width, w, broadcast)
+		name := fmt.Sprintf("packedMultiplyLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		dataWidth := width
+		if broadcast {
+			dataWidth = form.broadcastByte
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "packed-multiply-literal.ll", "packed-multiply-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_packed_numeric_conversion.go b/amd64_raw_packed_numeric_conversion.go
new file mode 100644
index 000000000..e175aa229
--- /dev/null
+++ b/amd64_raw_packed_numeric_conversion.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Opcode/mandatory-prefix/W select an element conversion. VL selects a
+// physical shape in the shared source grammar; it is not a separate opcode.
+func x86RawPackedNumericName(p x86RawVectorEncoding) Op {
+	if p.mapNumber != 1 {
+		return ""
+	}
+	if !p.evex {
+		switch {
+		case p.opcode == 0x5b && p.pp == 1:
+			return "VCVTPS2DQ"
+		case p.opcode == 0x5b && p.pp == 2:
+			return "VCVTTPS2DQ"
+		case p.opcode == 0xe6 && p.pp == 3:
+			return "VCVTPD2DQ"
+		case p.opcode == 0xe6 && p.pp == 1:
+			return "VCVTTPD2DQ"
+		}
+		return "" // These VEX encodings are WIG, including in mode32.
+	}
+	if p.pp == 1 && p.opcode >= 0x78 && p.opcode <= 0x7b {
+		names := [...]Op{"VCVTTPS2UQQ", "VCVTPS2UQQ", "VCVTTPS2QQ", "VCVTPS2QQ"}
+		name := names[p.opcode-0x78]
+		if p.w {
+			name = Op(strings.Replace(string(name), "PS", "PD", 1))
+		}
+		return name
+	}
+	switch {
+	case p.opcode == 0x5b && p.pp == 1 && !p.w:
+		return "VCVTPS2DQ"
+	case p.opcode == 0x5b && p.pp == 2 && !p.w:
+		return "VCVTTPS2DQ"
+	case p.opcode == 0xe6 && p.pp == 3 && p.w:
+		return "VCVTPD2DQ"
+	case p.opcode == 0xe6 && p.pp == 1 && p.w:
+		return "VCVTTPD2DQ"
+	case (p.opcode == 0x78 || p.opcode == 0x79) && p.pp == 0:
+		name := "VCVT"
+		if p.opcode == 0x78 {
+			name += "T"
+		}
+		if p.w {
+			return Op(name + "PD2UDQ")
+		}
+		return Op(name + "PS2UDQ")
+	case p.opcode == 0x7a && p.pp == 2 && !p.w:
+		return "VCVTUDQ2PD"
+	case p.opcode == 0x7a && p.pp == 3 && !p.w:
+		return "VCVTUDQ2PS"
+	case p.opcode == 0xe6 && p.pp == 2 && p.w:
+		return "VCVTQQ2PD"
+	case p.opcode == 0x7a && p.pp == 2 && p.w:
+		return "VCVTUQQ2PD"
+	case p.opcode == 0x5b && p.pp == 0 && p.w:
+		return "VCVTQQ2PS"
+	case p.opcode == 0x7a && p.pp == 3 && p.w:
+		return "VCVTUQQ2PS"
+	}
+	return ""
+}
+
+func decodedX86PackedNumericConversionInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PackedNumericConversionInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PackedNumericConversionInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched {
+		return Instr{}, 0, false, nil
+	}
+	name := x86RawPackedNumericName(p)
+	if name == "" {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(reason string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed numeric conversion: %s", reason)
+	}
+	if mode != 32 && mode != 64 || p.addressOverride || p.upper != 0 ||
+		p.evex && (!p.fixed || p.zero && p.mask == 0) || len(code) <= p.modRM {
+		return fail("invalid physical mode, prefix, reserved field, or truncated ModRM")
+	}
+	register := code[p.modRM]>>6 == 3
+	embedded := p.evex && p.broadcast && register
+	vl := p.vectorLength
+	if embedded {
+		vl = 2
+	}
+	if vl > 2 || !p.evex && vl > 1 {
+		return fail("reserved vector length")
+	}
+	spec, _ := x86PackedConversionSpecification(name)
+	if spec.sourceBits > spec.destinationBits && vl < 2 {
+		name += [...]Op{"X", "Y"}[vl]
+		spec, _ = x86PackedConversionSpecification(name)
+	}
+	shape := spec.shapes[0]
+	if len(spec.shapes) > 1 {
+		shape = spec.shapes[vl]
+	}
+	if embedded && spec.explicit == "" {
+		return fail("embedded rounding/SAE absent from this conversion")
+	}
+	width := shape.lanes * spec.sourceBits / 8
+	if p.broadcast && !register {
+		width = spec.sourceBits / 8
+	}
+	prefix := map[int]string{16: "X", 32: "Y", 64: "Z"}
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, prefix[shape.sourceBytes], width)
+	} else {
+		source, consumed, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, prefix[shape.sourceBytes])
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if embedded {
+		if spec.explicit == "sae" {
+			name += ".SAE" // LL is ignored for SAE-only register encodings.
+		} else {
+			name += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+		}
+	} else if p.broadcast {
+		name += ".BCST"
+	}
+	if p.zero {
+		name += ".Z"
+	}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix[shape.destinationBytes], int(code[p.modRM]>>3&7)+p.r*8))})
+	ins := Instr{Op: name, Args: args, x86Encoded: true, x86PackedNumericEVEX: p.evex}
+	arch := "amd64"
+	if mode == 32 {
+		arch = "386"
+	}
+	shapeInput := ins
+	if memory.physicalPC && source.Kind == OpMem && source.Mem.Base == "RIP" {
+		// The physical decoder has already checked the complete disp32.
+		// Check the conversion's memory class, not a Go source RIP spelling.
+		// Return the original physical operand; only a boundary observer may
+		// request this mode and it discards all decoded operands.
+		shapeInput.Args = append([]Operand(nil), ins.Args...)
+		shapeInput.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+	}
+	_, _, err = x86PackedConversionProperties(shapeInput, arch)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	printed := make([]string, len(args))
+	for index, operand := range args {
+		printed[index] = operand.String()
+	}
+	ins.Raw = string(name) + " " + strings.Join(printed, ", ")
+	return ins, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_packed_precision_convert.go b/amd64_raw_packed_precision_convert.go
new file mode 100644
index 000000000..ea2675bc1
--- /dev/null
+++ b/amd64_raw_packed_precision_convert.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Opcode 5A with no prefix or 66 converts packed singles to doubles or
+// doubles to singles. Go 1.27 exposes the VEX.128/.256 and EVEX.128/.256/.512
+// forms under VCVTPS2PD and VCVTPD2PSX/Y (or unsuffixed Z). Scalar F2/F3 5A
+// belongs to the separate scalar-precision grammar.
+func decodedX86PackedPrecisionConvertInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || p.opcode != 0x5a || (p.pp != 0 && p.pp != 1) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed precision conversion: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.upper != 0 {
+		return fail("reserved vvvv/V' field")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.evex {
+		if !p.fixed || p.w != (p.pp == 1) || p.zero && p.mask == 0 {
+			return fail("invalid EVEX fixed, width, mask or zeroing field")
+		}
+	}
+
+	registerSource := code[p.modRM]>>6 == 3
+	if mode == 32 {
+		if !p.evex && (p.r != 0 || p.b != 0 || p.x != 0) {
+			return fail("extended VEX register in 32-bit mode")
+		}
+		if p.evex && !registerSource && (p.b != 0 || p.x != 0) {
+			return fail("extended memory address in 32-bit mode")
+		}
+	}
+	embeddedControl := p.evex && p.broadcast && registerSource
+	broadcast := p.evex && p.broadcast && !registerSource
+	if p.evex && !embeddedControl && p.vectorLength > 2 {
+		return fail("reserved EVEX vector length")
+	}
+
+	vectorLength := p.vectorLength
+	if embeddedControl {
+		vectorLength = 2 // SAE or rounding implies the 512-bit register form.
+	}
+	var op Op
+	var sourcePrefix, destinationPrefix string
+	var memoryScale int
+	if p.pp == 0 {
+		op = "VCVTPS2PD"
+		destinationPrefix = [...]string{"X", "Y", "Z"}[vectorLength]
+		sourcePrefix = "X"
+		if vectorLength == 2 {
+			sourcePrefix = "Y"
+		}
+		memoryScale = 8 << vectorLength
+	} else {
+		op = "VCVTPD2PS"
+		if vectorLength < 2 {
+			op += [...]Op{"X", "Y"}[vectorLength]
+		}
+		sourcePrefix = [...]string{"X", "Y", "Z"}[vectorLength]
+		destinationPrefix = "X"
+		if vectorLength == 2 {
+			destinationPrefix = "Y"
+		}
+		memoryScale = 16 << vectorLength
+	}
+	if mode == 32 {
+		if sourcePrefix == "Z" && registerSource && (p.b != 0 || p.x != 0) {
+			return fail("Z8-Z31 are not Go assembler source registers in 32-bit mode")
+		}
+		if destinationPrefix == "Z" && p.r != 0 {
+			return fail("Z8-Z31 are not Go assembler destination registers in 32-bit mode")
+		}
+	}
+	if embeddedControl {
+		if p.pp == 0 {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+		}
+	} else if broadcast {
+		op += ".BCST"
+		if p.pp == 0 {
+			memoryScale = 4
+		} else {
+			memoryScale = 8
+		}
+	}
+	if p.zero {
+		op += ".Z"
+	}
+
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, sourcePrefix, memoryScale)
+	} else {
+		source, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, sourcePrefix)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", destinationPrefix, int(code[p.modRM]>>3&7)+p.r*8))}
+	args := []Operand{source}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for i, arg := range args {
+		printed[i] = arg.String()
+	}
+	return Instr{Op: op, Args: args, x86Encoded: true, x86PackedPrecisionEVEX: p.evex,
+		Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_packed_precision_convert_test.go b/amd64_raw_packed_precision_convert_test.go
new file mode 100644
index 000000000..134d9282c
--- /dev/null
+++ b/amd64_raw_packed_precision_convert_test.go
@@ -0,0 +1,309 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86RawPackedPrecisionForms = []struct {
+	op     Op
+	pp     byte
+	length byte
+	evex   bool
+	src    Reg
+	dst    Reg
+}{
+	{"VCVTPS2PD", 0, 0, false, "X1", "X0"},
+	{"VCVTPS2PD", 0, 1, false, "X1", "Y0"},
+	{"VCVTPS2PD", 0, 0, true, "X1", "X0"},
+	{"VCVTPS2PD", 0, 1, true, "X1", "Y0"},
+	{"VCVTPS2PD", 0, 2, true, "Y1", "Z0"},
+	{"VCVTPD2PSX", 1, 0, false, "X1", "X0"},
+	{"VCVTPD2PSY", 1, 1, false, "Y1", "X0"},
+	{"VCVTPD2PSX", 1, 0, true, "X1", "X0"},
+	{"VCVTPD2PSY", 1, 1, true, "Y1", "X0"},
+	{"VCVTPD2PS", 1, 2, true, "Z1", "Y0"},
+}
+
+func rawPackedPrecisionBytes(pp, length byte, evex, memory bool) []byte {
+	modRM := byte(0xc1)
+	if memory {
+		modRM = 0x08
+	}
+	if evex {
+		w := byte(0)
+		if pp == 1 {
+			w = 0x80
+		}
+		return []byte{0x62, 0xf1, 0x7c | pp | w, 0x08 | length<<5, 0x5a, modRM}
+	}
+	return []byte{0xc5, 0xf8 | pp | length<<2, 0x5a, modRM}
+}
+
+func TestX86RawPackedPrecisionConvertArrowRegression(t *testing.T) {
+	// Arrow emits this VEX.256 VCVTPS2PD as raw bytes. x/arch v0.14
+	// incorrectly starts with a legacy POP rather than decoding the vector op.
+	code := []byte{0xc5, 0xfc, 0x5a, 0x04, 0xba}
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != "VCVTPS2PD" {
+		t.Fatalf("raw %#x decoded as %+v", code, decoded.Instrs)
+	}
+}
+
+func TestX86RawPackedPrecisionConvertCompleteGo127BaseForms(t *testing.T) {
+	if len(x86RawPackedPrecisionForms) != 10 {
+		t.Fatal("Go 1.27 packed 5A table requires ten VEX/EVEX width forms")
+	}
+	for _, form := range x86RawPackedPrecisionForms {
+		for _, memory := range []bool{false, true} {
+			name := fmt.Sprintf("%s/LL=%d/EVEX=%t/memory=%t", form.op, form.length, form.evex, memory)
+			t.Run(name, func(t *testing.T) {
+				code := rawPackedPrecisionBytes(form.pp, form.length, form.evex, memory)
+				decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != form.op {
+					t.Fatalf("raw %#x decoded as %+v; want %s", code, decoded.Instrs, form.op)
+				}
+				args := decoded.Instrs[0].Args
+				if len(args) != 2 {
+					t.Fatalf("raw %#x operands = %+v", code, args)
+				}
+				if memory {
+					if args[0].Kind != OpMem || args[0].Mem.Base != AX {
+						t.Fatalf("raw %#x memory source = %+v", code, args[0])
+					}
+				} else if args[0].Kind != OpReg || args[0].Reg != form.src {
+					t.Fatalf("raw %#x source = %+v; want %s", code, args[0], form.src)
+				}
+				wantDestination := form.dst
+				if memory {
+					wantDestination = Reg(string(form.dst[:1]) + "1")
+				}
+				if args[1].Reg != wantDestination {
+					t.Fatalf("raw %#x destination = %s; want %s", code, args[1].Reg, wantDestination)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawPackedPrecisionConvertEncodingAxes(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{"VEX-W-ignored", []byte{0xc4, 0xe1, 0xfc, 0x5a, 0xc1}, "VCVTPS2PD", []string{"X1", "Y0"}},
+		{"masked", []byte{0x62, 0xf1, 0x7c, 0x09, 0x5a, 0xc1}, "VCVTPS2PD", []string{"X1", "K1", "X0"}},
+		{"broadcast-zero", []byte{0x62, 0xf1, 0x7c, 0x99, 0x5a, 0x00}, "VCVTPS2PD.BCST.Z", []string{"0(AX)", "K1", "X0"}},
+		{"single-to-double-SAE", []byte{0x62, 0xf1, 0x7c, 0x18, 0x5a, 0xc1}, "VCVTPS2PD.SAE", []string{"Y1", "Z0"}},
+		{"double-to-single-round-down", []byte{0x62, 0xf1, 0xfd, 0x39, 0x5a, 0xd8}, "VCVTPD2PS.RD_SAE", []string{"Z0", "K1", "Y3"}},
+		{"extended-registers", []byte{0x62, 0xa1, 0x7c, 0x08, 0x5a, 0xc1}, "VCVTPS2PD", []string{"X17", "X16"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, recognized, err := decodedX86PackedPrecisionConvertInstruction(tc.code, 64)
+			if !recognized || err != nil || length != len(tc.code) || got.Op != tc.op {
+				t.Fatalf("decode %#x = %+v, %d, %v, %v; want %s", tc.code, got, length, recognized, err, tc.op)
+			}
+			if len(got.Args) != len(tc.args) {
+				t.Fatalf("decode %#x operands = %+v; want %v", tc.code, got.Args, tc.args)
+			}
+			for index, arg := range got.Args {
+				if arg.String() != tc.args[index] {
+					t.Fatalf("decode %#x operand %d = %s; want %s", tc.code, index, arg.String(), tc.args[index])
+				}
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		off  int64
+	}{
+		{"single-Z-disp8", []byte{0x62, 0xf1, 0x7c, 0x48, 0x5a, 0x40, 0x02}, 64},
+		{"double-Y-disp8", []byte{0x62, 0xf1, 0xfd, 0x28, 0x5a, 0x40, 0x02}, 64},
+		{"double-broadcast-disp8", []byte{0x62, 0xf1, 0xfd, 0x38, 0x5a, 0x40, 0x02}, 16},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, _, recognized, err := decodedX86PackedPrecisionConvertInstruction(tc.code, 64)
+			if !recognized || err != nil || got.Args[0].Kind != OpMem || got.Args[0].Mem.Off != tc.off {
+				t.Fatalf("decode %#x = %+v, %v, %v; want offset %d", tc.code, got, recognized, err, tc.off)
+			}
+		})
+	}
+	for _, code := range [][]byte{
+		{0x62, 0xa1, 0x7c, 0x08, 0x5a, 0xc1}, // X17 -> X16.
+		{0x62, 0xa1, 0xfd, 0x28, 0x5a, 0xc1}, // Y17 -> X16.
+	} {
+		if got, _, recognized, err := decodedX86PackedPrecisionConvertInstruction(code, 32); !recognized || err != nil || len(got.Args) != 2 {
+			t.Fatalf("386 EVEX high X/Y register %#x = %+v, %v, %v", code, got, recognized, err)
+		}
+	}
+	requireX86GoAssemblerResult(t, "386", "TEXT high(SB),4,$0-0\n\tVCVTPS2PD X17, K1, X16\n\tVCVTPD2PSY Y17, K1, X16\n\tRET\n", true)
+}
+
+func TestX86RawPackedPrecisionConvertRejectsReservedEncodings(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"VEX-vvvv", []byte{0xc5, 0xe8, 0x5a, 0xc1}, 64},
+		{"EVEX-vvvv", []byte{0x62, 0xf1, 0x6c, 0x08, 0x5a, 0xc1}, 64},
+		{"EVEX-zero-without-mask", []byte{0x62, 0xf1, 0x7c, 0x88, 0x5a, 0xc1}, 64},
+		{"EVEX-LL3-without-control", []byte{0x62, 0xf1, 0x7c, 0x68, 0x5a, 0xc1}, 64},
+		{"EVEX-W-mismatch", []byte{0x62, 0xf1, 0xfc, 0x08, 0x5a, 0xc1}, 64},
+		{"address-override", []byte{0x67, 0xc5, 0xf8, 0x5a, 0xc1}, 64},
+		{"missing-ModRM", []byte{0xc5, 0xf8, 0x5a}, 64},
+		{"extended-386", []byte{0xc4, 0x61, 0x78, 0x5a, 0xc1}, 32},
+		{"Z-destination-386", []byte{0x62, 0xe1, 0x7c, 0x48, 0x5a, 0xc1}, 32},
+		{"Z-source-386", []byte{0x62, 0xb1, 0xfd, 0x48, 0x5a, 0xc1}, 32},
+		{"extended-memory-386", []byte{0x62, 0xb1, 0x7c, 0x08, 0x5a, 0x01}, 32},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86PackedPrecisionConvertInstruction(tc.code, tc.mode); !recognized || err == nil {
+				t.Fatalf("reserved encoding %#x: recognized=%v error=%v", tc.code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestX86RawPackedPrecisionConvertCompilesEveryBaseForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawprecisionconversion(SB),4,$0-0\n")
+			encodings := make([][]byte, 0, len(x86RawPackedPrecisionForms)+5)
+			for _, form := range x86RawPackedPrecisionForms {
+				encodings = append(encodings, rawPackedPrecisionBytes(form.pp, form.length, form.evex, false))
+			}
+			encodings = append(encodings,
+				[]byte{0x62, 0xf1, 0x7c, 0x99, 0x5a, 0x00},       // PS broadcast, mask, zero.
+				[]byte{0x62, 0xf1, 0x7c, 0x18, 0x5a, 0xc1},       // PS suppress exceptions.
+				[]byte{0x62, 0xf1, 0xfd, 0x39, 0x5a, 0xd8},       // PD embedded rounding.
+				[]byte{0x62, 0xf1, 0xfd, 0x38, 0x5a, 0x40, 0x02}, // PD broadcast disp8.
+				[]byte{0x62, 0xa1, 0x7c, 0x08, 0x5a, 0xc1},       // EVEX high X in 386/amd64.
+			)
+			for _, code := range encodings {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+				}
+				source.WriteString("\tNOP\n")
+			}
+			source.WriteString("\tRET\n")
+			// Every original byte/NOP/RET and its actual Go object stay intact.
+			// The complete bare source lacks inputs; only the private emitter
+			// checks bound formats, while the initialized raw family is separate.
+			ir := x86PackedPrecisionOriginalFormatObject(t, source.String(), "rawprecisionconversion",
+				target.goarch, target.triple, true, 15, 1)
+			compileLLVMToObject(t, llc, target.triple, "raw-precision-conversion.ll", "raw-precision-conversion.o", ir)
+		})
+	}
+}
+
+func TestX86RawPackedPrecisionConvertRuntimeSemantics(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test only runs on amd64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const namedSource = `
+TEXT packedprecision(SB),4,$0-24
+	MOVQ out+0(FP), AX
+	MOVQ singles+8(FP), BX
+	MOVQ doubles+16(FP), CX
+	VCVTPS2PD (BX), Y1
+	VMOVUPD Y1, (AX)
+	VCVTPD2PSY (CX), X2
+	VMOVUPS X2, 32(AX)
+	VZEROUPPER
+	RET
+`
+	rawSource := strings.NewReplacer(
+		"VCVTPS2PD (BX), Y1", "BYTE $0xc5; BYTE $0xfc; BYTE $0x5a; BYTE $0x0b",
+		"VCVTPD2PSY (CX), X2", "BYTE $0xc5; BYTE $0xfd; BYTE $0x5a; BYTE $0x11",
+	).Replace(namedSource)
+	requireX86GoAssemblerResult(t, "amd64", namedSource, true)
+	requireX86GoAssemblerResult(t, "amd64", rawSource, true)
+
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		runPrefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	options := Options{
+		TargetTriple: triple,
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"packedprecision": {
+				Name: "packedprecision", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void packedprecision(uint8_t *, const float *, const double *);
+int main(void) {
+  const float singles[4] = {1.5f, -2.25f, 3.0f, 4.0f};
+  const double doubles[4] = {1.5, -2.25, 3.0, 4.0};
+  uint8_t out[48];
+  double widened[4];
+  float narrowed[4];
+  memset(out, 0xcc, sizeof(out));
+  packedprecision(out, singles, doubles);
+  memcpy(widened, out, sizeof(widened));
+  memcpy(narrowed, out + 32, sizeof(narrowed));
+  for (int i = 0; i < 4; i++) {
+    if (widened[i] != (double)singles[i]) return 10 + i;
+    if (narrowed[i] != (float)doubles[i]) return 20 + i;
+  }
+  return 0;
+}
+`
+	for _, tc := range []struct{ name, source string }{
+		{"named", namedSource},
+		{"raw", rawSource},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, tc.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "packed_precision_"+tc.name, triple, ir, mainC, runPrefix)
+		})
+	}
+}
diff --git a/amd64_raw_packed_sign.go b/amd64_raw_packed_sign.go
new file mode 100644
index 000000000..c280020d5
--- /dev/null
+++ b/amd64_raw_packed_sign.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27's _yvaddsubpd table gives all three VPSIGN instructions exactly
+// the same VEX.128/VEX.256 register-and-memory operand grammar.
+var x86RawPackedSignOps = [...]Op{"VPSIGNB", "VPSIGNW", "VPSIGND"}
+
+func decodedX86RawPackedSignInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.opcode < 0x08 || p.opcode > 0x0a {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed sign: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.pp != 1 || p.addressOverride {
+		return fail("packed sign requires VEX.66.0F38.WIG without address override")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	width := [...]string{"X", "Y"}[p.vectorLength]
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (destinationNumber >= 8 || p.upper >= 8) {
+		return fail("extended vector register unavailable in 32-bit mode")
+	}
+	source, consumed, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	data := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destinationNumber))}
+	op := x86RawPackedSignOps[p.opcode-0x08]
+	args := []Operand{source, data, destination}
+	printed := []string{source.String(), data.String(), destination.String()}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_packed_sign_test.go b/amd64_raw_packed_sign_test.go
new file mode 100644
index 000000000..05eaf783b
--- /dev/null
+++ b/amd64_raw_packed_sign_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawPackedSignGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawpackedsign(SB),4,$0-0\n")
+			for _, op := range []string{"VPSIGNB", "VPSIGNW", "VPSIGND"} {
+				for _, width := range []string{"X", "Y"} {
+					fmt.Fprintf(&source, "%s %s2, %s3, %s4\n", op, width, width, width)
+					fmt.Fprintf(&source, "%s 24(BX), %s3, %s4\n", op, width, width)
+					if arch == "amd64" {
+						fmt.Fprintf(&source, "%s %s12, %s13, %s14\n", op, width, width, width)
+						fmt.Fprintf(&source, "%s -32(R8), %s13, %s14\n", op, width, width)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for index, got := range decoded.Instrs {
+				if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", index, got, want[index])
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawPackedSignRejectsFormsOutsideGoTable(t *testing.T) {
+	const source = "TEXT rawpackedsign(SB),4,$0-0\nVPSIGNB Y2, Y3, Y4\nRET\n"
+	assembled := assembleX87ControlBytes(t, "amd64", source)
+	if len(assembled) < 6 || assembled[0] != 0xc4 {
+		t.Fatalf("Go did not emit a VEX packed sign: %x", assembled)
+	}
+	valid := assembled[:len(assembled)-1]
+	for _, test := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"wrong prefix", func(code []byte) []byte { code[2] &^= 3; return code }},
+		{"EVEX outside SIGN", func([]byte) []byte {
+			return encodeX86EVEXPackedWordMultiply(2, 0x08, 0, 0, false, false, 4, 3, 2)
+		}},
+		{"address override", func(code []byte) []byte { return append([]byte{0x67}, code...) }},
+		{"missing ModRM", func(code []byte) []byte { return code[:4] }},
+		{"high register on 386", func(code []byte) []byte { code[1] &^= 0x80; return code }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.mutate(append([]byte(nil), valid...))
+			mode := 64
+			if test.name == "high register on 386" {
+				mode = 32
+			}
+			if _, _, recognized, err := decodedX86RawPackedSignInstruction(code, mode); !recognized || err == nil {
+				t.Fatalf("invalid %x: recognized=%v err=%v", code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedSignLLVM22AllTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, form := range []string{
+		"VPSIGNB Y2, Y3, Y4",
+		"VPSIGNW X2, X3, X4",
+		"VPSIGND 16(BX), Y3, Y4",
+	} {
+		for _, target := range []struct {
+			goarch string
+			triple string
+		}{
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(form+"/"+target.triple, func(t *testing.T) {
+				source := "TEXT rawpackedsign(SB),4,$0-0\n" + form + "\nRET\n"
+				code := assembleX87ControlBytes(t, target.goarch, source)
+				x86RawPackedSignIndependentPhysicalPrior(t, form, code, target.triple)
+				var raw strings.Builder
+				raw.WriteString("TEXT rawpackedsign(SB),4,$0-0\n")
+				for _, value := range code {
+					fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+				}
+				// All original bytes and RET remain unchanged. A bare raw
+				// format has no vector/address inputs: its three public APIs
+				// must report Context, while a private emitter proves objects.
+				// The independent 114-row initialized family is exercised by
+				// TestX86PackedAbsSignInitializedObjectsThreeAPIsFiveTargets.
+				file, signatures := x86UnboundVoidFormatSources(t, raw.String(), target.goarch, target.triple)
+				if len(file.Funcs) != 1 || len(file.Data) != 0 || len(file.Globl) != 0 {
+					t.Fatal("original packed-sign format lost its single byte-only body")
+				}
+				decoded, err := decodeX86RawDirectives(file.Funcs[0], target.goarch)
+				if err != nil || len(decoded.Instrs) != 3 || decoded.Instrs[1].Op != Op(strings.Fields(form)[0]) ||
+					decoded.Instrs[2].Op != OpRET || decoded.Instrs[2].x86RawNearReturn == nil {
+					t.Fatal("original packed-sign instruction and encoded RET were not retained", err)
+				}
+				// Private format emission is not the public normalizer's
+				// physical return/nonalias contract. In particular the memory
+				// row cannot borrow that contract merely to compile its format.
+				unit := *file
+				unit.Funcs = []Func{decoded}
+				ir := x86ScalarFormatObjectUnit(t, &unit, signatures, target.goarch, target.triple, 0)
+				for _, operation := range []string{"icmp slt <", "icmp sgt <", "sub <", "select <"} {
+					if !strings.Contains(ir, operation) {
+						t.Fatal("original raw sign format lost its complete integer operation", operation)
+					}
+				}
+				compileLLVMToObject(t, llc, target.triple, "raw-packed-sign.ll", "raw-packed-sign.o", ir)
+			})
+		}
+	}
+}
+
+func x86RawPackedSignIndependentPhysicalPrior(t *testing.T, form string, code []byte, triple string) {
+	t.Helper()
+	// Independent original Go bytes, including the ordinary encoded RET.
+	// Neither a decoder nor a private LLVM format object authenticates these.
+	want := map[string][]byte{
+		"VPSIGNB Y2, Y3, Y4":     {0xc4, 0xe2, 0x65, 0x08, 0xe2, 0xc3},
+		"VPSIGNW X2, X3, X4":     {0xc4, 0xe2, 0x61, 0x09, 0xe2, 0xc3},
+		"VPSIGND 16(BX), Y3, Y4": {0xc4, 0xe2, 0x65, 0x0a, 0x63, 0x10, 0xc3},
+	}
+	if !bytes.Equal(code, want[form]) {
+		t.Fatalf("original complete packed-sign Go bytes changed: %s got=%x want=%x", form, code, want[form])
+	}
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("independent packed-sign physical prior requires LLVM22 llvm-mc")
+	}
+	var input strings.Builder
+	for _, value := range code {
+		fmt.Fprintf(&input, "0x%02x ", value)
+	}
+	input.WriteByte('\n')
+	stage, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple, "--mattr=+avx2")
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	mnemonic := strings.ToLower(strings.Fields(form)[0])
+	if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") ||
+		strings.Count(string(output), mnemonic) != 1 {
+		t.Fatalf("independent LLVM22 original packed-sign decoding failed: %v\n%s", err, output)
+	}
+}
diff --git a/amd64_raw_packed_testmask.go b/amd64_raw_packed_testmask.go
new file mode 100644
index 000000000..e665384c1
--- /dev/null
+++ b/amd64_raw_packed_testmask.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27's _yvpshufbitqmb forms are the product of test polarity (66/F3),
+// B/W versus D/Q opcode, and EVEX.W. Each row has X/Y/Z widths and an
+// optional K write-mask; only D/Q permits scalar-memory broadcast.
+var x86RawPackedTestMaskOps = [2][2][2]Op{
+	{
+		{"VPTESTMB", "VPTESTMW"},
+		{"VPTESTMD", "VPTESTMQ"},
+	},
+	{
+		{"VPTESTNMB", "VPTESTNMW"},
+		{"VPTESTNMD", "VPTESTNMQ"},
+	},
+}
+
+func decodedX86RawPackedTestMaskInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || !p.evex || p.mapNumber != 2 ||
+		(p.pp != 1 && p.pp != 2) || (p.opcode != 0x26 && p.opcode != 0x27) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("packed test mask: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.vectorLength > 2 || p.r != 0 || p.zero {
+		return fail("invalid reserved EVEX encoding bit")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	registerSource := modRM>>6 == 3
+	if p.broadcast && (registerSource || p.opcode != 0x27) {
+		return fail("broadcast requires a D/Q scalar-memory source")
+	}
+	if mode == 32 && !registerSource && (p.b != 0 || p.x != 0) {
+		return fail("extended memory address in 32-bit mode")
+	}
+
+	polarity := p.pp - 1
+	widthGroup := p.opcode - 0x26
+	w := 0
+	if p.w {
+		w = 1
+	}
+	op := x86RawPackedTestMaskOps[polarity][widthGroup][w]
+	laneBits := amd64PackedTestMaskSpecs[string(op)].laneBits
+	vectorPrefix := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	accessBytes := 16 << p.vectorLength
+	if p.broadcast {
+		accessBytes = laneBits / 8
+		op += ".BCST"
+	}
+	first, consumed, err := decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, vectorPrefix, accessBytes)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, p.upper))}
+	args := []Operand{first, second}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	destination := modRM >> 3 & 7
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", destination))})
+	printed := make([]string, len(args))
+	for index, arg := range args {
+		printed[index] = arg.String()
+	}
+	return Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86Encoded: true,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_packed_testmask_test.go b/amd64_raw_packed_testmask_test.go
new file mode 100644
index 000000000..1e9633c3b
--- /dev/null
+++ b/amd64_raw_packed_testmask_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawPackedTestMask(polarity, widthGroup, w, vectorBits, first, second, destination, writeMask int, memory, broadcast bool) []byte {
+	if memory {
+		first = 0
+	}
+	p0 := byte(1<<7 | (1-first/16)<<6 | (1-first/8&1)<<5 | 1<<4 | 2)
+	p1 := byte(4 | (polarity + 1) | (^second&15)<<3)
+	if w != 0 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | (1-second/16)<<3 | writeMask)
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | destination<<3 | first&7)
+	if memory {
+		modRM = byte(0x40 | destination<<3)
+	}
+	code := []byte{0x62, p0, p1, p2, byte(0x26 + widthGroup), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestTranslateRawPackedTestMaskGorseRegression(t *testing.T) {
+	const source = `TEXT rawPackedTestMask(SB), $0-0
+	LONG $0x4875f262
+	WORD $0xc026
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawPackedTestMask": {Name: "rawPackedTestMask", Ret: Void}},
+	})
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original raw test-to-mask invented native entry inputs", err)
+	}
+	decoded, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file.Funcs[0] = decoded
+	ir = x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{
+		"rawPackedTestMask": {Name: "rawPackedTestMask", Ret: Void},
+	}, "amd64", "x86_64-unknown-linux-gnu", 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+		return c.lowerPackedTestMask(ins.Op, ins)
+	})
+	if !strings.Contains(ir, "icmp ne") {
+		t.Fatalf("raw VPTESTMB omitted per-lane mask test:\n%s", ir)
+	}
+}
+
+func TestDecodedX86RawPackedTestMaskCompleteGoRows(t *testing.T) {
+	if len(amd64PackedTestMaskSpecs) != 8 {
+		t.Fatalf("Go 1.27 packed test-mask family has %d members, want eight", len(amd64PackedTestMaskSpecs))
+	}
+	seen := make(map[Op]bool)
+	for polarity, groups := range x86RawPackedTestMaskOps {
+		for widthGroup, widths := range groups {
+			for w, op := range widths {
+				spec, ok := amd64PackedTestMaskSpecs[string(op)]
+				if !ok || seen[op] || spec.testZero != (polarity != 0) ||
+					spec.laneBits != (8<<(widthGroup*2+w)) {
+					t.Fatalf("packed test-mask row %d/%d/%d = %s, spec %+v", polarity, widthGroup, w, op, spec)
+				}
+				seen[op] = true
+				for vectorBits, prefix := range [...]string{"X", "Y", "Z"} {
+					for _, memory := range []bool{false, true} {
+						for _, writeMask := range []int{0, 3} {
+							for _, broadcast := range []bool{false, true} {
+								if broadcast && (!memory || widthGroup == 0) {
+									continue
+								}
+								code := encodeX86RawPackedTestMask(polarity, widthGroup, w, vectorBits, 20, 21, 2, writeMask, memory, broadcast)
+								got, length, recognized, err := decodedX86RawPackedTestMaskInstruction(code, 64)
+								if err != nil || !recognized || length != len(code) {
+									t.Fatalf("decode %x = %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+								}
+								wantOp := op
+								if broadcast {
+									wantOp += ".BCST"
+								}
+								if got.Op != wantOp || got.Args[1].String() != fmt.Sprintf("%s21", prefix) ||
+									got.Args[len(got.Args)-1].String() != "K2" {
+									t.Fatalf("decode %x = %+v, want %s %s21, K2", code, got, wantOp, prefix)
+								}
+								if writeMask != 0 && (len(got.Args) != 4 || got.Args[2].String() != "K3") ||
+									writeMask == 0 && len(got.Args) != 3 {
+									t.Fatalf("decode %x = %+v, lost write mask", code, got)
+								}
+								first := got.Args[0]
+								if memory {
+									wantBytes := 16 << vectorBits
+									if broadcast {
+										wantBytes = spec.laneBits / 8
+									}
+									if first.Kind != OpMem || first.Mem.Base != AX || first.Mem.Off != int64(wantBytes) {
+										t.Fatalf("decode %x = %+v, want compressed displacement %d", code, got, wantBytes)
+									}
+								} else if first.String() != fmt.Sprintf("%s20", prefix) {
+									t.Fatalf("decode %x = %+v, want %s20", code, got, prefix)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(seen) != len(amd64PackedTestMaskSpecs) {
+		t.Fatalf("decoded %d distinct packed test-mask ops, want %d", len(seen), len(amd64PackedTestMaskSpecs))
+	}
+}
+
+func TestDecodedX86RawPackedTestMaskRejectsReservedBits(t *testing.T) {
+	base := encodeX86RawPackedTestMask(0, 0, 0, 2, 1, 2, 3, 0, false, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"fixed bit", []byte{base[0], base[1], base[2] &^ 4, base[3], base[4], base[5]}},
+		{"K register extension", []byte{base[0], base[1] &^ 0x80, base[2], base[3], base[4], base[5]}},
+		{"reserved length", []byte{base[0], base[1], base[2], base[3] | 0x20, base[4], base[5]}},
+		{"zeroing", []byte{base[0], base[1], base[2], base[3] | 0x80, base[4], base[5]}},
+		{"register broadcast", []byte{base[0], base[1], base[2], base[3] | 0x10, base[4], base[5]}},
+		{"missing ModRM", base[:5]},
+		{"address override", append([]byte{0x67}, base...)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawPackedTestMaskInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted invalid encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+	byteBroadcast := encodeX86RawPackedTestMask(0, 0, 0, 2, 0, 1, 2, 0, true, true)
+	if _, _, recognized, err := decodedX86RawPackedTestMaskInstruction(byteBroadcast, 64); !recognized || err == nil {
+		t.Fatalf("accepted byte broadcast %x", byteBroadcast)
+	}
+}
+
+func TestTranslateRawPackedTestMaskLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawPackedTestMaskFamily(SB), $0-0\n")
+			for polarity, groups := range x86RawPackedTestMaskOps {
+				for widthGroup, widths := range groups {
+					for w := range widths {
+						for vectorBits := 0; vectorBits < 3; vectorBits++ {
+							for _, code := range [][]byte{
+								encodeX86RawPackedTestMask(polarity, widthGroup, w, vectorBits, 1, 2, 3, 0, false, false),
+								encodeX86RawPackedTestMask(polarity, widthGroup, w, vectorBits, 0, 2, 3, 4, true, widthGroup != 0),
+							} {
+								for _, value := range code {
+									fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+								}
+							}
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"rawPackedTestMaskFamily": {Name: "rawPackedTestMaskFamily", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("bare physical test-to-mask formats invented source/mask values", err)
+			}
+			decoded, err := decodeX86RawDirectives(file.Funcs[0], target.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file.Funcs[0] = decoded
+			if len(decoded.Instrs) != 50 {
+				t.Fatal("original 48 raw forms lost TEXT/RET or an instruction", len(decoded.Instrs))
+			}
+			ir = x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{
+				"rawPackedTestMaskFamily": {Name: "rawPackedTestMaskFamily", Ret: Void},
+			}, target.goarch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+				return c.lowerPackedTestMask(ins.Op, ins)
+			})
+			compileLLVMToObject(t, llc, target.triple, "raw-packed-test-mask.ll", "raw-packed-test-mask.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_packed_widen_conversion.go b/amd64_raw_packed_widen_conversion.go
new file mode 100644
index 000000000..4ae731b95
--- /dev/null
+++ b/amd64_raw_packed_widen_conversion.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+// The eight packed float-to-(u)int64 conversions share Go 1.27's
+// _yvcvtps2qq and _yvcvtpd2qq grammars. Their source width is determined
+// by the float lane size and destination width, with common mask, zeroing,
+// broadcast, and embedded rounding/SAE rules.
+var x86RawPackedWidenConversionByOpcode = map[int]Op{
+	0x7b: "VCVTPS2QQ",
+	0x79: "VCVTPS2UQQ",
+	0x7a: "VCVTTPS2QQ",
+	0x78: "VCVTTPS2UQQ",
+}
+
+var x86RawPackedDoubleConversionByOpcode = map[int]Op{
+	0x7b: "VCVTPD2QQ",
+	0x79: "VCVTPD2UQQ",
+	0x7a: "VCVTTPD2QQ",
+	0x78: "VCVTTPD2UQQ",
+}
+
+func decodedX86PackedWidenConversionInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 1 || p.pp != 1 || p.opcode < 0x78 || p.opcode > 0x7b {
+		return Instr{}, 0, false, nil
+	}
+	return decodedX86PackedNumericConversionInstruction(code, mode)
+}
diff --git a/amd64_raw_packed_widen_conversion_test.go b/amd64_raw_packed_widen_conversion_test.go
new file mode 100644
index 000000000..c55f8767c
--- /dev/null
+++ b/amd64_raw_packed_widen_conversion_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86RawPackedWidenConversionOps = []Op{
+	"VCVTPS2QQ", "VCVTPS2UQQ", "VCVTTPS2QQ", "VCVTTPS2UQQ",
+	"VCVTPD2QQ", "VCVTPD2UQQ", "VCVTTPD2QQ", "VCVTTPD2UQQ",
+}
+
+func x86RawPackedWidenConversionGoForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT rawPackedWidenConversion(SB),4,$0-0\n")
+	for _, op := range x86RawPackedWidenConversionOps {
+		registers := []struct{ source, destination string }{
+			{"X0", "X1"}, {"X0", "Y1"}, {"Y0", "Z1"},
+		}
+		if strings.Contains(string(op), "PD2") {
+			registers = []struct{ source, destination string }{
+				{"X0", "X1"}, {"Y0", "Y1"}, {"Z0", "Z1"},
+			}
+		}
+		for _, registers := range registers {
+			fmt.Fprintf(&source, "\t%s %s, %s\n", op, registers.source, registers.destination)
+			fmt.Fprintf(&source, "\t%s 0(AX), %s\n", op, registers.destination)
+			fmt.Fprintf(&source, "\t%s %s, K1, %s\n", op, registers.source, registers.destination)
+			fmt.Fprintf(&source, "\t%s.Z 0(AX), K1, %s\n", op, registers.destination)
+			fmt.Fprintf(&source, "\t%s.BCST 0(AX), %s\n", op, registers.destination)
+		}
+		roundingSource := "Y0"
+		if strings.Contains(string(op), "PD2") {
+			roundingSource = "Z0"
+		}
+		if strings.HasPrefix(string(op), "VCVTT") {
+			fmt.Fprintf(&source, "\t%s.SAE %s, Z1\n", op, roundingSource)
+		} else {
+			fmt.Fprintf(&source, "\t%s.RN_SAE %s, Z1\n", op, roundingSource)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestDecodeX86RawPackedWidenConversionCompleteGoForms(t *testing.T) {
+	source := x86RawPackedWidenConversionGoForms()
+	code := assembleX87ControlBytes(t, "amd64", source)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	named, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+	}
+	for index, got := range decoded.Instrs {
+		if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+			t.Fatalf("instruction %d=%+v, want %+v", index, got, want[index])
+		}
+	}
+}
+
+func TestDecodeX86RawPackedWidenConversionSourceLocalRIPData(t *testing.T) {
+	for _, double := range []bool{false, true} {
+		ops := x86RawPackedWidenConversionByOpcode
+		if double {
+			ops = x86RawPackedDoubleConversionByOpcode
+		}
+		for opcode, op := range ops {
+			for vectorLength := 0; vectorLength < 3; vectorLength++ {
+				for _, broadcast := range []bool{false, true} {
+					p2 := byte(0x08 | vectorLength<<5)
+					width := 8 << vectorLength
+					p1 := byte(0x7d)
+					if double {
+						p1 |= 0x80
+						width *= 2
+					}
+					if broadcast {
+						p2 |= 0x10
+						width = 4
+						if double {
+							width = 8
+						}
+					}
+					code := []byte{0x62, 0xf1, p1, p2, byte(opcode), 0x05, 1, 0, 0, 0, 0xc3}
+					for value := 0; value < width; value++ {
+						code = append(code, byte(value))
+					}
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "packed widening conversion RIP", map[string]bool{})
+					if err != nil {
+						t.Fatalf("%s width %d broadcast=%t: %v", op, width, broadcast, err)
+					}
+					if len(decoded) != 2 || len(decoded[0].x86RIPLiteralData) != width ||
+						decoded[0].Args[0].Kind != OpSym {
+						t.Fatalf("%s width %d broadcast=%t: %#v", op, width, broadcast, decoded)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawPackedWidenConversionLLVM22Objects(t *testing.T) {
+	source := x86RawPackedWidenConversionGoForms()
+	code := assembleX87ControlBytes(t, "amd64", source)
+	file := x86RawUnprovedReturnFormProbeFile(t, "amd64", "rawPackedWidenConversion", code)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawProbeObject(t, file, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-packed-widen.ll", "raw-packed-widen.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_parallel_bits.go b/amd64_raw_parallel_bits.go
new file mode 100644
index 000000000..1ec0d6d07
--- /dev/null
+++ b/amd64_raw_parallel_bits.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import "fmt"
+
+// PDEP/PEXT share Go's _yandnl register/memory-mask grammar. Intel XED's
+// datafiles/hswbmi/hsw-bmi-vex-isa.xed.txt confirms W is ignored in not64
+// mode, while L must be zero. This is BMI2, not an arbitrary AVX fallback.
+func decodedX86ParallelBitsInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86ParallelBitsInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86ParallelBitsInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || p.opcode != 0xf5 || (p.pp != 2 && p.pp != 3) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("parallel bit operation: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.vectorLength != 0 {
+		return fail("requires VEX.L0 encoding")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended register in 32-bit mode")
+	}
+	bits := 32
+	if p.w && mode == 64 {
+		bits = 64
+	}
+	var op Op
+	for name, spec := range x86TernaryGPSpecs {
+		if spec.operation != x86TernaryANDN && spec.bits == bits && spec.prefix == p.pp {
+			op = name
+			break
+		}
+	}
+	mask, size, err := memory.scalar(code[p.modRM:], mode, p.b, p.x, p.segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	src, _ := decodedX86GeneralRegister(p.upper)
+	dst, _ := decodedX86GeneralRegister(int(code[p.modRM]>>3&7) + p.r*8)
+	return Instr{Op: op, Args: []Operand{mask, {Kind: OpReg, Reg: src}, {Kind: OpReg, Reg: dst}}, Raw: fmt.Sprintf("%s %s, %s, %s", op, mask.String(), src, dst)}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_parallel_bits_test.go b/amd64_raw_parallel_bits_test.go
new file mode 100644
index 000000000..43d6cf6b7
--- /dev/null
+++ b/amd64_raw_parallel_bits_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RawParallelBitsGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			regs := []string{"AX", "SP", "DI"}
+			if arch == "amd64" {
+				regs = append(regs, "R8", "R15")
+			}
+			var source strings.Builder
+			source.WriteString("TEXT parallelbits(SB),4,$0-0\n")
+			// Go _yandnl: one register/memory mask, source GP, destination GP
+			// row, independently encoded by each of PDEPL/Q and PEXTL/Q.
+			for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+				for _, dst := range regs {
+					for _, mask := range []string{dst, "(BX)", "-7(BP)(CX*4)", "8192(SI)"} {
+						fmt.Fprintf(&source, "%s %s,%s,%s\n", op, mask, dst, dst)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("got %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if arch == "386" && strings.HasSuffix(string(want[i].Op), "Q") {
+					want[i].Op = Op(strings.TrimSuffix(string(want[i].Op), "Q") + "L")
+				}
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+			file := x86RawStackObservingFormProbeFile(t, arch, "parallelbits", code)
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-parallel-bits.ll", "raw-parallel-bits.o", ir)
+			}
+			t.Logf("checked %d Go encodings", len(want)-1)
+		})
+	}
+}
+
+func TestX86RawParallelBitsEncodingAxes(t *testing.T) {
+	count := 0
+	for _, deposit := range []bool{false, true} {
+		for _, wide := range []bool{false, true} {
+			pp, op := 2, "PEXT"
+			if deposit {
+				pp, op = 3, "PDEP"
+			}
+			for mask := 0; mask < 16; mask++ {
+				for src := 0; src < 16; src++ {
+					for dst := 0; dst < 16; dst++ {
+						code := encodeRawScalarMove(false, pp, 0xf5, mask, src, dst, 0, false)
+						code[1] = code[1]&0xe0 | 2
+						if wide {
+							code[2] |= 0x80
+						}
+						for _, mode := range []int{32, 64} {
+							got, n, matched, err := decodedX86ParallelBitsInstruction(code, mode)
+							if mode == 32 && (mask >= 8 || src >= 8 || dst >= 8) {
+								if !matched || err == nil {
+									t.Fatalf("386 accepted %x", code)
+								}
+								continue
+							}
+							width := "L"
+							if wide && mode == 64 {
+								width = "Q"
+							}
+							mr, _ := decodedX86GeneralRegister(mask)
+							sr, _ := decodedX86GeneralRegister(src)
+							dr, _ := decodedX86GeneralRegister(dst)
+							want := []Operand{{Kind: OpReg, Reg: mr}, {Kind: OpReg, Reg: sr}, {Kind: OpReg, Reg: dr}}
+							if err != nil || !matched || n != len(code) || got.Op != Op(op+width) || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x mode=%d: %+v %v, want %s %+v", code, mode, got, err, op+width, want)
+							}
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 16384 {
+		t.Fatalf("covered %d encodings", count)
+	}
+}
+
+func TestX86RawParallelBitsInvalidAndSegmentForms(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc4, 0xe2, 0x7a, 0xf5}, {0xc4, 0xe2, 0x7a, 0xf5, 0x04}, {0xc4, 0xe2, 0x7a, 0xf5, 0x45},
+		{0xc4, 0xe2, 0x7e, 0xf5, 0xc0},       // Reserved L=1.
+		{0x62, 0xf2, 0x7e, 0x08, 0xf5, 0xc0}, // Not a Go EVEX family.
+		{0x67, 0xc4, 0xe2, 0x7a, 0xf5, 0x00},
+	} {
+		if _, _, matched, err := decodedX86ParallelBitsInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x", code)
+		}
+	}
+	if _, _, matched, err := decodedX86ParallelBitsInstruction([]byte{0xc4, 0xe2, 0x7a, 0xf5, 0xc0}, 16); !matched || err == nil {
+		t.Fatal("accepted invalid mode")
+	}
+	for _, code := range [][]byte{nil, {0xc4}, {0xc4, 0xe2, 0x78, 0xf5, 0xc0}, {0xc4, 0xe1, 0x7a, 0xf5, 0xc0}} {
+		if _, _, matched, _ := decodedX86ParallelBitsInstruction(code, 64); matched {
+			t.Fatalf("matched unrelated encoding %x", code)
+		}
+	}
+	for _, seg := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		code := []byte{seg.prefix, 0xc4, 0x02, 0xb2, 0xf5, 0x64, 0x88, 0xf9}
+		got, n, matched, err := decodedX86ParallelBitsInstruction(code, 64)
+		want := []Operand{{Kind: OpMem, Mem: MemRef{Segment: seg.reg, Base: "R8", Index: "R9", Scale: 4, Off: -7}}, {Kind: OpReg, Reg: "R9"}, {Kind: OpReg, Reg: "R12"}}
+		if err != nil || !matched || n != len(code) || got.Op != "PEXTQ" || !reflect.DeepEqual(got.Args, want) {
+			t.Fatalf("decode %x=%+v %v, want %+v", code, got, err, want)
+		}
+	}
+}
+
+func TestX86ParallelBitsGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			for _, args := range []string{" AX,BX", " X0,AX,BX", " AX,X0,BX", " AX,BX,X0", " AX,(BX),CX", " AX,BX,(CX)", " $1,BX,CX", ".Z AX,BX,CX", ".BCST (AX),BX,CX"} {
+				source := "TEXT invalid(SB),4,$0-0\n" + op + args + "\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"invalid": {Name: "invalid", Ret: Void}}}); err == nil {
+					t.Fatalf("translator accepted %s%s on %s", op, args, arch)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ParallelBitsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; separate five-target object tests are required")
+	}
+	source, decl, checks, sigs := x86ParallelBitsOriginalRuntimeFixture(t)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := x86ParallelBitsOriginalRuntimeDriver(decl.String(), checks.String())
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "parallel_bits", triple, ir, mainC, prefix)
+}
+
+func TestX86ParallelBits386IgnoresW(t *testing.T) {
+	// Intel XED hsw-bmi-vex-isa.xed.txt has unconstrained W in not64
+	// mode: both Go-accepted L and Q spellings access only a 32-bit mask.
+	for _, op := range []string{"PDEPQ", "PEXTQ"} {
+		source := "TEXT width386(SB),4,$0-0\n" + op + " (AX),BX,CX\nRET\n"
+		assembleX87ControlBytes(t, "386", source)
+		ir := x86UnboundVoidScalarFormatObject(t, source, "width386", "386", "i386-unknown-linux-gnu")
+		if strings.Contains(ir, "lshr i64") || !strings.Contains(ir, "lshr i32") || !strings.Contains(ir, "load volatile i32, ptr") {
+			t.Fatalf("386 %s failed to normalize width", op)
+		}
+	}
+}
diff --git a/amd64_raw_permute128_test.go b/amd64_raw_permute128_test.go
new file mode 100644
index 000000000..b0057ceeb
--- /dev/null
+++ b/amd64_raw_permute128_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVPERM2X128(opcode, immediate byte, first, second, destination int) []byte {
+	p0 := byte((1-destination/8)<<7 | 1<<6 | (1-first/8)<<5 | 3)
+	p1 := byte((^second&15)<<3 | 5)
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	return []byte{0xc4, p0, p1, opcode, modRM, immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedPsiphonVPERM2I128(t *testing.T) {
+	code := []byte{0xc4, 0xe3, 0x6d, 0x46, 0xc3, 0x20}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "Psiphon VPERM2I128 sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const want = "VPERM2I128 $32, Y3, Y2, Y0"
+	if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, want+" ") {
+		t.Fatalf("decoded %x as %#v, want %q", code, decoded, want)
+	}
+}
+
+func TestDecodedX86RawVPERM2X128CompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, operation := range []struct {
+		opcode byte
+		name   string
+	}{
+		{opcode: 0x06, name: "VPERM2F128"},
+		{opcode: 0x46, name: "VPERM2I128"},
+	} {
+		for first := 0; first < 16; first++ {
+			for second := 0; second < 16; second++ {
+				for destination := 0; destination < 16; destination++ {
+					immediate := byte(first*16 + destination)
+					code := encodeX86RawVPERM2X128(operation.opcode, immediate, first, second, destination)
+					got, length, ok, err := decodedX86Permute128Instruction(code, 64)
+					want := fmt.Sprintf("%s $%d, Y%d, Y%d, Y%d", operation.name, immediate, first, second, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d VPERM2F128/VPERM2I128 register encodings, want 8192", count)
+	}
+}
+
+func TestDecodedX86RawVPERM2X128MemoryAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{
+			name: "VPERM2F128 extended SIB",
+			code: []byte{0x65, 0xc4, 0x03, 0x15, 0x06, 0x64, 0x8b, 0x20, 0xff},
+			want: "VPERM2F128 $255, 32(R11)(R9*4)(GS), Y13, Y12",
+		},
+		{
+			name: "VPERM2I128 extended SIB",
+			code: []byte{0x64, 0xc4, 0x03, 0x15, 0x46, 0x64, 0x8b, 0x20, 0xfe},
+			want: "VPERM2I128 $254, 32(R11)(R9*4)(FS), Y13, Y12",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86Permute128Instruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) || got.Raw != test.want {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", test.code, got, length, ok, err, test.want)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "386 unavailable vvvv register", mode: 32, encoding: encodeX86RawVPERM2X128(0x46, 1, 0, 8, 2), wantOK: true},
+		{name: "wrong pp", mode: 64, encoding: []byte{0xc4, 0xe3, 0x6c, 0x46, 0xc3, 4}, wantOK: true},
+		{name: "W", mode: 64, encoding: []byte{0xc4, 0xe3, 0xed, 0x46, 0xc3, 4}, wantOK: true},
+		{name: "128-bit vector length", mode: 64, encoding: []byte{0xc4, 0xe3, 0x69, 0x46, 0xc3, 4}, wantOK: true},
+		{name: "truncated immediate", mode: 64, encoding: []byte{0xc4, 0xe3, 0x6d, 0x46, 0xc3}, wantOK: true},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0xc4, 0xe3, 0x6d, 0x46, 0xc3, 4}, wantOK: true},
+		{name: "legacy prefix", mode: 64, encoding: []byte{0x66, 0xc4, 0xe3, 0x6d, 0x46, 0xc3, 4}},
+		{name: "wrong opcode", mode: 64, encoding: []byte{0xc4, 0xe3, 0x6d, 0x47, 0xc3, 4}},
+		{name: "wrong map", mode: 64, encoding: []byte{0xc4, 0xe2, 0x6d, 0x46, 0xc3, 4}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86Permute128Instruction(test.encoding, test.mode)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x returned ok=%v err=%v, want ok=%v", test.encoding, ok, err, test.wantOK)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("invalid encoding %x was accepted", test.encoding)
+			}
+			if !test.wantOK && err != nil {
+				t.Fatalf("unrelated encoding %x returned err=%v", test.encoding, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_permute_inlane_test.go b/amd64_raw_permute_inlane_test.go
new file mode 100644
index 000000000..c34cfc3e6
--- /dev/null
+++ b/amd64_raw_permute_inlane_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVEXInLaneFloatingPermute(double, immediate bool, vectorBits byte, first, second, destination int, imm byte) []byte {
+	mapNumber := byte(2)
+	opcode := byte(0x0c)
+	if immediate {
+		mapNumber = 3
+		opcode = 0x04
+	}
+	if double {
+		opcode++
+	}
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^first>>3)&1)<<5 | mapNumber
+	p1 := byte(^second&15)<<3 | vectorBits<<2 | 1
+	if immediate {
+		p1 = 0x78 | vectorBits<<2 | 1
+	}
+	code := []byte{0xc4, p0, p1, opcode, byte(0xc0 | destination&7<<3 | first&7)}
+	if immediate {
+		code = append(code, imm)
+	}
+	return code
+}
+
+func encodeX86RawEVEXInLaneFloatingPermute(double, immediate bool, vectorBits byte, mask int, zeroing, broadcast bool, first, second, destination int, imm byte) []byte {
+	mapNumber := byte(2)
+	opcode := byte(0x0c)
+	if immediate {
+		mapNumber = 3
+		opcode = 0x04
+	}
+	if double {
+		opcode++
+	}
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | mapNumber
+	p1 := byte(^second&15)<<3 | 5
+	p2 := vectorBits<<5 | byte((^second>>4)&1)<<3 | byte(mask)
+	if immediate {
+		p1 = 0x7d
+		p2 |= 0x08
+	}
+	if double {
+		p1 |= 0x80
+	}
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	code := []byte{0x62, p0, p1, p2, opcode, byte(0xc0 | destination&7<<3 | first&7)}
+	if immediate {
+		code = append(code, imm)
+	}
+	return code
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVPERMILPS(t *testing.T) {
+	// vpermilps $180, %ymm2, %ymm3;
+	// vblendps $72, %ymm3, %ymm1, %ymm3
+	code := []byte{0xc4, 0xe3, 0x7d, 0x04, 0xda, 0xb4, 0xc4, 0xe3, 0x75, 0x0c, 0xdb, 0x48}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VPERMILPS sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VPERMILPS $180, Y2, Y3 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawInLaneFloatingPermuteCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, double := range []bool{false, true} {
+		op := "VPERMILPS"
+		if double {
+			op = "VPERMILPD"
+		}
+		for vectorBits := byte(0); vectorBits < 2; vectorBits++ {
+			vectorName := [...]string{"X", "Y"}[vectorBits]
+			for first := 0; first < 16; first++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86RawVEXInLaneFloatingPermute(double, true, vectorBits, first, 0, destination, 0xa5)
+					got, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(code, 64)
+					want := fmt.Sprintf("%s $165, %s%d, %s%d", op, vectorName, first, vectorName, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+			for first := 0; first < 16; first++ {
+				for second := 0; second < 16; second++ {
+					for destination := 0; destination < 16; destination++ {
+						code := encodeX86RawVEXInLaneFloatingPermute(double, false, vectorBits, first, second, destination, 0)
+						got, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(code, 64)
+						want := fmt.Sprintf("%s %s%d, %s%d, %s%d", op, vectorName, first, vectorName, second, vectorName, destination)
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{{}, {mask: 3}, {mask: 7, zeroing: true, suffix: ".Z"}} {
+				for first := 0; first < 32; first++ {
+					for destination := 0; destination < 32; destination++ {
+						code := encodeX86RawEVEXInLaneFloatingPermute(double, true, vectorBits, masking.mask, masking.zeroing, false, first, 0, destination, 0x5a)
+						got, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(code, 64)
+						args := []string{"$90", fmt.Sprintf("%s%d", vectorName, first)}
+						if masking.mask != 0 {
+							args = append(args, fmt.Sprintf("K%d", masking.mask))
+						}
+						args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+						want := op + masking.suffix + " " + strings.Join(args, ", ")
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+				for first := 0; first < 32; first++ {
+					for second := 0; second < 32; second++ {
+						for destination := 0; destination < 32; destination++ {
+							code := encodeX86RawEVEXInLaneFloatingPermute(double, false, vectorBits, masking.mask, masking.zeroing, false, first, second, destination, 0)
+							got, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(code, 64)
+							args := []string{fmt.Sprintf("%s%d", vectorName, first), fmt.Sprintf("%s%d", vectorName, second)}
+							if masking.mask != 0 {
+								args = append(args, fmt.Sprintf("K%d", masking.mask))
+							}
+							args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+							want := op + masking.suffix + " " + strings.Join(args, ", ")
+							if err != nil || !ok || length != len(code) || got.Raw != want {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 625664 {
+		t.Fatalf("covered %d in-lane floating-permute register encodings, want 625664", count)
+	}
+}
+
+func TestDecodedX86RawInLaneFloatingPermuteMemoryAndInvalidForms(t *testing.T) {
+	vexMemory := []byte{0xc4, 0x03, 0x7d, 0x05, 0x7c, 0x8b, 0x02, 0xfe}
+	got, length, ok, err := decodedX86InLaneFloatingPermuteInstruction(vexMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 2}
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VPERMILPD" || got.Args[0].Imm != 254 || got.Args[2].String() != "Y15" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+	evexImmediateMemory := []byte{0x62, 0xf3, 0xfd, 0xdb, 0x05, 0x50, 0x02, 0x07}
+	got, length, ok, err = decodedX86InLaneFloatingPermuteInstruction(evexImmediateMemory, 64)
+	wantMemory = MemRef{Base: "AX", Off: 16}
+	if err != nil || !ok || length != len(evexImmediateMemory) || got.Op != "VPERMILPD.BCST.Z" || got.Args[0].Imm != 7 || got.Args[2].String() != "K3" || got.Args[3].String() != "Z2" || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexImmediateMemory, got, length, ok, err)
+	}
+	evexVariableMemory := []byte{0x62, 0xf2, 0x75, 0x38, 0x0c, 0x50, 0x02}
+	got, length, ok, err = decodedX86InLaneFloatingPermuteInstruction(evexVariableMemory, 64)
+	wantMemory = MemRef{Base: "AX", Off: 8}
+	if err != nil || !ok || length != len(evexVariableMemory) || got.Op != "VPERMILPS.BCST" || got.Args[1].String() != "Y1" || got.Args[2].String() != "Y2" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexVariableMemory, got, length, ok, err)
+	}
+
+	validVEXImmediate := encodeX86RawVEXInLaneFloatingPermute(false, true, 0, 7, 0, 7, 1)
+	validEVEXVariable := encodeX86RawEVEXInLaneFloatingPermute(false, false, 2, 0, false, false, 7, 6, 5, 0)
+	validEVEXImmediate := encodeX86RawEVEXInLaneFloatingPermute(false, true, 2, 0, false, false, 7, 0, 5, 1)
+	for name, invalid := range map[string][]byte{
+		"vex missing immediate": validVEXImmediate[:len(validVEXImmediate)-1],
+		"vex W":                 {validVEXImmediate[0], validVEXImmediate[1], validVEXImmediate[2] | 0x80, validVEXImmediate[3], validVEXImmediate[4], validVEXImmediate[5]},
+		"vex prefix":            {validVEXImmediate[0], validVEXImmediate[1], validVEXImmediate[2] &^ 0x01, validVEXImmediate[3], validVEXImmediate[4], validVEXImmediate[5]},
+		"vex immediate vvvv":    {validVEXImmediate[0], validVEXImmediate[1], validVEXImmediate[2] &^ 0x08, validVEXImmediate[3], validVEXImmediate[4], validVEXImmediate[5]},
+		"evex fixed bit":        {validEVEXVariable[0], validEVEXVariable[1], validEVEXVariable[2] &^ 0x04, validEVEXVariable[3], validEVEXVariable[4], validEVEXVariable[5]},
+		"evex wrong W":          {validEVEXVariable[0], validEVEXVariable[1], validEVEXVariable[2] | 0x80, validEVEXVariable[3], validEVEXVariable[4], validEVEXVariable[5]},
+		"evex immediate vvvvv":  {validEVEXImmediate[0], validEVEXImmediate[1], validEVEXImmediate[2] &^ 0x08, validEVEXImmediate[3] &^ 0x08, validEVEXImmediate[4], validEVEXImmediate[5], validEVEXImmediate[6]},
+		"evex reserved length":  {validEVEXVariable[0], validEVEXVariable[1], validEVEXVariable[2], validEVEXVariable[3] | 0x60, validEVEXVariable[4], validEVEXVariable[5]},
+		"zero without mask":     {validEVEXVariable[0], validEVEXVariable[1], validEVEXVariable[2], validEVEXVariable[3] | 0x80, validEVEXVariable[4], validEVEXVariable[5]},
+		"register broadcast":    {validEVEXVariable[0], validEVEXVariable[1], validEVEXVariable[2], validEVEXVariable[3] | 0x10, validEVEXVariable[4], validEVEXVariable[5]},
+		"address override":      append([]byte{0x67}, validVEXImmediate...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86InLaneFloatingPermuteInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	masked386 := encodeX86RawEVEXInLaneFloatingPermute(false, false, 0, 1, false, false, 0, 1, 2, 0)
+	if instruction, _, matched, decodeErr := decodedX86InLaneFloatingPermuteInstruction(masked386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 masked encoding %x decoded as %+v, ok=%v, err=%v", masked386, instruction, matched, decodeErr)
+	}
+	highZ386 := encodeX86RawEVEXInLaneFloatingPermute(false, false, 2, 0, false, false, 8, 1, 2, 0)
+	if instruction, _, matched, decodeErr := decodedX86InLaneFloatingPermuteInstruction(highZ386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 high-Z encoding %x decoded as %+v, ok=%v, err=%v", highZ386, instruction, matched, decodeErr)
+	}
+}
+
+func TestX86InLaneFloatingPermuteRawGo127ArchitectureOracle(t *testing.T) {
+	const accepted386 = `TEXT ok(SB),$0-0
+	VPERMILPS $7, X0, X1
+	VPERMILPD X0, X1, X2
+	VPERMILPS $7, X20, X21
+	VPERMILPD Z0, Z6, Z7
+	RET
+`
+	requireX86GoAssemblerResult(t, "386", accepted386, true)
+	for _, instruction := range []string{
+		"VPERMILPS $7, Z8, Z0",
+		"VPERMILPD Z0, Z1, Z8",
+		"VPERMILPS X0, X1, K1, X2",
+	} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+	}
+}
+
+func TestTranslateX86RawInLaneFloatingPermuteTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_in_lane_floating_permute(SB),NOSPLIT,$0-0\n")
+			for _, double := range []bool{false, true} {
+				var encodings [][]byte
+				if target.goarch == "amd64" {
+					encodings = append(encodings,
+						encodeX86RawVEXInLaneFloatingPermute(double, true, 1, 15, 0, 14, 0xa5),
+						encodeX86RawVEXInLaneFloatingPermute(double, false, 1, 15, 14, 13, 0),
+						encodeX86RawEVEXInLaneFloatingPermute(double, true, 2, 7, true, false, 31, 0, 30, 0x5a),
+						encodeX86RawEVEXInLaneFloatingPermute(double, false, 2, 3, false, false, 31, 30, 29, 0),
+					)
+				} else {
+					encodings = append(encodings,
+						encodeX86RawVEXInLaneFloatingPermute(double, true, 1, 7, 0, 6, 0xa5),
+						encodeX86RawVEXInLaneFloatingPermute(double, false, 1, 7, 6, 5, 0),
+						encodeX86RawEVEXInLaneFloatingPermute(double, true, 0, 0, false, false, 20, 0, 21, 0x5a),
+						encodeX86RawEVEXInLaneFloatingPermute(double, false, 2, 0, false, false, 5, 6, 7, 0),
+					)
+				}
+				for _, encoding := range encodings {
+					for _, value := range encoding {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			physical, contextual := 8, 0
+			if target.goarch == "386" {
+				physical, contextual = 6, 2
+			}
+			ll := x86InLanePermuteUnboundFormatObject(t, source.String(), target.goarch, target.triple, physical, contextual)
+			compileLLVMToObject(t, llc, target.triple, "raw-in-lane-floating-permute-"+target.name+".ll", "raw-in-lane-floating-permute-"+target.name+".o", ll)
+		})
+	}
+}
diff --git a/amd64_raw_portio.go b/amd64_raw_portio.go
new file mode 100644
index 000000000..2428c7984
--- /dev/null
+++ b/amd64_raw_portio.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86ScalarPortIOInstruction covers Go's complete yin table: input
+// and output, byte/word/long, with either an immediate port or implicit DX.
+// x/arch's GoSyntax prints the architectural accumulator and DX operands,
+// whereas Go's assembler source syntax omits both. Its old decoder also calls
+// the byte encodings INL/OUTL. Decode these small fixed forms from the opcode.
+func decodedX86ScalarPortIOInstruction(code []byte) (Instr, int, bool, error) {
+	if len(code) == 0 {
+		return Instr{}, 0, false, nil
+	}
+	index := 0
+	word := false
+	if code[index] == 0x66 {
+		word = true
+		index++
+		if len(code) == index {
+			return Instr{}, 0, false, nil
+		}
+	}
+	opcode := code[index]
+	if opcode < 0xe4 || (opcode > 0xe7 && opcode < 0xec) || opcode > 0xef {
+		return Instr{}, 0, false, nil
+	}
+	input := opcode == 0xe4 || opcode == 0xe5 || opcode == 0xec || opcode == 0xed
+	byteWidth := opcode&1 == 0
+	name := "OUT"
+	if input {
+		name = "IN"
+	}
+	width := "L"
+	if byteWidth {
+		width = "B"
+	} else if word {
+		width = "W"
+	}
+	index++
+	var args []Operand
+	if opcode >= 0xe4 && opcode <= 0xe7 {
+		if len(code) == index {
+			return Instr{}, 0, true, fmt.Errorf("missing immediate port byte")
+		}
+		args = []Operand{{Kind: OpImm, Imm: int64(code[index])}}
+		index++
+	}
+	op := Op(name + width)
+	raw := string(op)
+	if len(args) != 0 {
+		raw = fmt.Sprintf("%s $%d", op, args[0].Imm)
+	}
+	return Instr{Op: op, Args: args, Raw: raw}, index, true, nil
+}
diff --git a/amd64_raw_portio_test.go b/amd64_raw_portio_test.go
new file mode 100644
index 000000000..a35a5d359
--- /dev/null
+++ b/amd64_raw_portio_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawScalarPortIOCompleteEncodingFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		op   Op
+		port int64
+	}{
+		{"in byte immediate", []byte{0xe4, 0x7f}, "INB", 0x7f},
+		{"in word immediate", []byte{0x66, 0xe5, 0x7f}, "INW", 0x7f},
+		{"in long immediate", []byte{0xe5, 0x7f}, "INL", 0x7f},
+		{"in byte DX", []byte{0xec}, "INB", -1},
+		{"in word DX", []byte{0x66, 0xed}, "INW", -1},
+		{"in long DX", []byte{0xed}, "INL", -1},
+		{"out byte immediate", []byte{0xe6, 0x7f}, "OUTB", 0x7f},
+		{"out word immediate", []byte{0x66, 0xe7, 0x7f}, "OUTW", 0x7f},
+		{"out long immediate", []byte{0xe7, 0x7f}, "OUTL", 0x7f},
+		{"out byte DX", []byte{0xee}, "OUTB", -1},
+		{"out word DX", []byte{0x66, 0xef}, "OUTW", -1},
+		{"out long DX", []byte{0xef}, "OUTL", -1},
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, test := range tests {
+			t.Run(goarch+"/"+test.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range test.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 {
+					t.Fatalf("decoded %#x as %#v, want one instruction", test.code, got.Instrs)
+				}
+				ins := got.Instrs[0]
+				wantArgs := 0
+				if test.port >= 0 {
+					wantArgs = 1
+				}
+				if ins.Op != test.op || len(ins.Args) != wantArgs {
+					t.Fatalf("decoded %#x as %#v, want %s with port %d", test.code, ins, test.op, test.port)
+				}
+				if test.port >= 0 && (ins.Args[0].Kind != OpImm || ins.Args[0].Imm != test.port) {
+					t.Fatalf("decoded %#x port as %#v, want $%d", test.code, ins.Args[0], test.port)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawScalarPortIOImmediateByteRange(t *testing.T) {
+	for _, opcode := range []byte{0xe4, 0xe5, 0xe6, 0xe7} {
+		for port := 0; port < 256; port++ {
+			instruction, length, ok, err := decodedX86ScalarPortIOInstruction([]byte{opcode, byte(port)})
+			if !ok || err != nil || length != 2 || len(instruction.Args) != 1 || instruction.Args[0].Imm != int64(port) {
+				t.Fatalf("opcode %#x port %d: instruction=%#v length=%d recognized=%t error=%v", opcode, port, instruction, length, ok, err)
+			}
+		}
+		_, _, ok, err := decodedX86ScalarPortIOInstruction([]byte{opcode})
+		if !ok || err == nil {
+			t.Fatalf("opcode %#x with missing port: recognized=%t error=%v", opcode, ok, err)
+		}
+	}
+}
+
+func TestX86RawScalarPortIOCompilesEveryForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawportio(SB),NOSPLIT,$0-0\n")
+			for _, code := range [][]byte{
+				{0xe4, 0x7f}, {0x66, 0xe5, 0x7f}, {0xe5, 0x7f},
+				{0xec}, {0x66, 0xed}, {0xed},
+				{0xe6, 0x7f}, {0x66, 0xe7, 0x7f}, {0xe7, 0x7f},
+				{0xee}, {0x66, 0xef}, {0xef},
+			} {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+				}
+				source.WriteString("\tNOP\n")
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawportio": {Name: "rawportio", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-portio.ll", "raw-portio.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_prefetch_hint_test.go b/amd64_raw_prefetch_hint_test.go
new file mode 100644
index 000000000..275642faf
--- /dev/null
+++ b/amd64_raw_prefetch_hint_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawExtendedPrefetchHints(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{goarch: "386", triple: "i386-unknown-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawExtendedPrefetch(SB),$0-0\n")
+			codes := [][]byte{
+				{0x0f, 0x18, 0x20},                   // /4, base register
+				{0x0f, 0x18, 0x30},                   // /6, base register
+				{0x0f, 0x18, 0x38},                   // /7, base register
+				{0x65, 0x0f, 0x18, 0x74, 0x8b, 0xf9}, // /6, GS and SIB with disp8
+			}
+			if target.goarch == "amd64" {
+				codes = append(codes, []byte{0x4d, 0x0f, 0x18, 0x7c, 0x8c, 0x10}) // /7, extended base/index
+			}
+			for _, code := range codes {
+				for _, value := range code {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+				}
+			}
+			source.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawExtendedPrefetch": {Name: "rawExtendedPrefetch", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-extended-prefetch.ll", "raw-extended-prefetch.o", ir)
+		})
+	}
+}
+
+func TestX86RawExtendedPrefetchHintsRejectInvalidForms(t *testing.T) {
+	for _, code := range [][]byte{
+		{0x0f, 0x18, 0x28},             // /5 is reserved.
+		{0x0f, 0x18, 0xf0},             // /6 requires memory.
+		{0x67, 0x0f, 0x18, 0x30},       // Address-size override is not modeled.
+		{0x0f, 0x18, 0x35, 0, 0, 0, 0}, // RIP-relative address has no proven source layout.
+	} {
+		var source strings.Builder
+		source.WriteString("TEXT badRawPrefetch(SB),$0-0\n")
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+		}
+		source.WriteString("RET\n")
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"badRawPrefetch": {Name: "badRawPrefetch", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("accepted unsupported raw prefetch form %x", code)
+		}
+	}
+}
diff --git a/amd64_raw_prefix.go b/amd64_raw_prefix.go
new file mode 100644
index 000000000..69f4c743c
--- /dev/null
+++ b/amd64_raw_prefix.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Intel specifies that the r/m field is ignored for each unprefixed register
+// fence encoding. The pinned decoder recognizes only the canonical r/m=0,
+// and the cache-line recognizer otherwise mistakes SFENCE /7 for CLFLUSH.
+// Do not strip or reinterpret any prefix here: those remain independently
+// decoded and validated, including LOCK and the distinct 66 memory forms.
+func decodedX86OrderingFenceInstruction(code []byte, mode int) (Instr, int, bool) {
+	if mode != 32 && mode != 64 || len(code) < 3 || code[0] != 0x0f || code[1] != 0xae || code[2]>>6 != 3 {
+		return Instr{}, 0, false
+	}
+	op := Op("")
+	switch code[2] >> 3 & 7 {
+	case 5:
+		op = "LFENCE"
+	case 6:
+		op = "MFENCE"
+	case 7:
+		op = "SFENCE"
+	default:
+		return Instr{}, 0, false
+	}
+	return Instr{Op: op}, 3, true
+}
+
+// x/arch keeps invalidity in metadata that GoSyntax can erase or print as a
+// standalone prefix with the real instruction in its operands. Reject before
+// any width/alias rewrite. PrefixIgnored alone is not machine invalidity.
+func decodedX86PrefixError(inst x86asm.Inst) error {
+	for _, prefix := range inst.Prefix {
+		if prefix&x86asm.PrefixInvalid != 0 {
+			return fmt.Errorf("raw %s has a machine-invalid prefix 0x%02x", inst.Op, byte(prefix))
+		}
+	}
+	for _, prefix := range inst.Prefix {
+		if prefix&0xff == x86asm.PrefixLOCK && prefix&x86asm.PrefixIgnored == 0 {
+			// This is valid native syntax, not invalid source. The existing
+			// standalone LOCK lowerer cannot bind a printed whole RMW or its
+			// atomic effect. Do not silently discard the following opcode.
+			return fmt.Errorf("%w: raw LOCK %s requires its complete atomic prefix/operand effect", ErrProbeNeedsContext, inst.Op)
+		}
+		if prefix&(x86asm.PrefixIgnored|x86asm.PrefixImplicit) != 0 {
+			continue
+		}
+		switch prefix {
+		case x86asm.PrefixXACQUIRE, x86asm.PrefixXRELEASE, x86asm.PrefixBND:
+			// GoSyntax uses only the low prefix byte for REP/REPNE. That
+			// textual repeater is not the original transactional or bounds
+			// effect and can leak onto a later string operation.
+			return fmt.Errorf("%w: raw %s %s requires its complete native prefix effect", ErrProbeNeedsContext, prefix, inst.Op)
+		}
+	}
+	return nil
+}
diff --git a/amd64_raw_prefix_class_test.go b/amd64_raw_prefix_class_test.go
new file mode 100644
index 000000000..a0824a60f
--- /dev/null
+++ b/amd64_raw_prefix_class_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86OrderingHintsPhysicalFenceRMIsIgnored(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, row := range []struct {
+			op   Op
+			base byte
+		}{
+			{"LFENCE", 0xe8},
+			{"MFENCE", 0xf0},
+			{"SFENCE", 0xf8},
+		} {
+			for rm := byte(0); rm < 8; rm++ {
+				t.Run(fmt.Sprintf("%d/%s/rm=%d", mode, row.op, rm), func(t *testing.T) {
+					code := []byte{0x0f, 0xae, row.base | rm}
+					x86PrefixOriginalBytes(t, mode, code)
+					got, err := decodeX86RawDirectiveGroup(code, mode, 0, "physical fence", nil)
+					if err != nil || len(got) != 1 || got[0].Op != row.op || len(got[0].Args) != 0 {
+						t.Fatalf("physical ignored-r/m fence changed: %x: %+v/%v", code, got, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// The complete Intel LOCK list is independent of the translator. The original
+// named Go object binds width, destination and opcode; no RMW is executed here.
+// Valid raw LOCK remains Context until the complete atomic effect is bound.
+func TestX86RawValidLockCompleteRMWClass(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		mode := 32
+		widths := "BWL"
+		if arch == "amd64" {
+			mode = 64
+			widths += "Q"
+		}
+		var forms []string
+		for _, stem := range []string{"ADD", "ADC", "AND", "OR", "SBB", "SUB", "XOR", "CMPXCHG", "XADD", "XCHG"} {
+			for _, width := range widths {
+				reg := "CX"
+				if width == 'B' {
+					reg = "CL"
+				}
+				forms = append(forms, fmt.Sprintf("%s%c %s,(AX)", stem, width, reg))
+			}
+		}
+		for _, stem := range []string{"INC", "DEC", "NEG", "NOT"} {
+			for _, width := range widths {
+				forms = append(forms, fmt.Sprintf("%s%c (AX)", stem, width))
+			}
+		}
+		for _, stem := range []string{"BTC", "BTR", "BTS"} {
+			for _, width := range strings.TrimPrefix(widths, "B") {
+				forms = append(forms, fmt.Sprintf("%s%c CX,(AX)", stem, width))
+			}
+		}
+		forms = append(forms, "CMPXCHG8B (AX)")
+		if arch == "amd64" {
+			forms = append(forms, "CMPXCHG16B (AX)")
+		}
+		want := 49
+		if arch == "amd64" {
+			want = 67
+		}
+		if len(forms) != want {
+			t.Fatal("complete native-width LOCK inventory changed", arch, len(forms))
+		}
+		for _, form := range forms {
+			t.Run(arch+"/"+form, func(t *testing.T) {
+				source := "TEXT locked(SB),4,$0-0\nLOCK\n" + form + "\nRET\n"
+				actual := x86OrderingHintGoBytes(t, arch, source)
+				if len(actual) < 3 || actual[0] != 0xf0 || actual[len(actual)-1] != 0xc3 {
+					t.Fatalf("original named LOCK object lacks complete prefix/body/RET: %x", actual)
+				}
+				code := actual[:len(actual)-1]
+				physical, err := x86asm.Decode(code, mode)
+				if err != nil || physical.Len != len(code) {
+					t.Fatalf("actual complete LOCK instruction %+v: %v", physical, err)
+				}
+				for _, prefix := range physical.Prefix {
+					if prefix&x86asm.PrefixInvalid != 0 {
+						t.Fatal("accepted memory RMW has invalid machine LOCK", physical)
+					}
+				}
+				got, err := decodeX86RawDirectiveGroup(code, mode, 0, source, nil)
+				if !errors.Is(err, ErrProbeNeedsContext) || len(got) != 0 {
+					t.Fatalf("complete valid LOCK silently lost atomic/body effects: %+v/%v", got, err)
+				}
+				// The simple named (AX) form ends in its ModRM byte. Change only
+				// mod to register addressing, retaining the original opcode/width.
+				// BYTE acceptance binds invalid machine bytes, not ISA validity.
+				bad := append([]byte(nil), code...)
+				bad[len(bad)-1] |= 0xc0
+				x86PrefixOriginalBytes(t, mode, bad)
+				if got, err := decodeX86RawDirectiveGroup(bad, mode, 0, "invalid register-only LOCK "+form, nil); err == nil {
+					t.Fatalf("complete LOCK class admitted register-only RMW: %x/%+v", bad, got)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawVisibleEffectPrefixesNeedWholeContract(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, code := range [][]byte{
+			{0xf3, 0x89, 0x08}, // XRELEASE MOVL CX,(AX), no explicit LOCK.
+			{0xf3, 0x87, 0x08}, // XRELEASE on implicitly locked XCHG.
+			{0xf2, 0x87, 0x08}, // XACQUIRE on implicitly locked XCHG.
+			{0xf2, 0xc3},       // BND RET, not an ordinary near return.
+		} {
+			t.Run(fmt.Sprintf("%d/%x", mode, code), func(t *testing.T) {
+				x86PrefixOriginalBytes(t, mode, code)
+				physical, err := x86asm.Decode(code, mode)
+				if err != nil || physical.Len != len(code) {
+					t.Fatal("complete original prefixed object", physical, err)
+				}
+				got, err := decodeX86RawDirectiveGroup(code, mode, 0, "whole effect prefix", nil)
+				t.Logf("bytes=%x actualPrefix=%#v GoSyntax=%q parsed=%+v error=%v", code,
+					physical.Prefix, x86asm.GoSyntax(physical, 0, nil), got, err)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("visible native effect became an ordinary opcode/string repeat without a contract", err)
+				}
+			})
+		}
+	}
+}
+
+// These BYTE objects observe conversion, not a new string/caller contract.
+// Visible prefixes must either retain the complete body or fail closed.
+func TestX86RawVisibleStringPrefixesRetainBody(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, row := range []struct {
+			name string
+			code []byte
+			body Op
+		}{
+			{"REP MOVSB", []byte{0xf3, 0xa4}, "MOVSB"},
+			{"REPE CMPSB", []byte{0xf3, 0xa6}, "CMPSB"},
+			{"REPNE CMPSB", []byte{0xf2, 0xa6}, "CMPSB"},
+			{"duplicate REP MOVSB", []byte{0xf3, 0xf3, 0xa4}, "MOVSB"},
+			{"XRELEASE MOV", []byte{0xf3, 0x89, 0x08}, "MOVL"},
+			{"XACQUIRE LOCK ADD", []byte{0xf2, 0xf0, 0x01, 0x08}, "ADDL"},
+			{"XRELEASE LOCK ADD", []byte{0xf3, 0xf0, 0x01, 0x08}, "ADDL"},
+		} {
+			t.Run(fmt.Sprintf("%d/%s", mode, row.name), func(t *testing.T) {
+				x86PrefixOriginalBytes(t, mode, row.code)
+				physical, err := x86asm.Decode(row.code, mode)
+				if err != nil || physical.Len != len(row.code) {
+					t.Fatal("complete physical visible prefix", physical, err)
+				}
+				got, err := decodeX86RawDirectiveGroup(row.code, mode, 0, row.name, nil)
+				t.Logf("actual bytes=%x syntax=%q whole=%+v error=%v", row.code,
+					x86asm.GoSyntax(physical, 0, nil), got, err)
+				if err != nil {
+					return
+				}
+				body := false
+				for _, instruction := range got {
+					body = body || instruction.Op == row.body
+				}
+				if !body {
+					t.Fatal("visible prefix conversion discarded its actual instruction body", got)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_raw_qq_to_float.go b/amd64_raw_qq_to_float.go
new file mode 100644
index 000000000..38b3869f2
--- /dev/null
+++ b/amd64_raw_qq_to_float.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+// x86RawQQToFloatForm maps opcode and mandatory prefix to the Go 1.27
+// QWORD-to-PS/PD optabs. PS narrows the Y/Z destination by one vector width.
+func x86RawQQToFloatForm(p x86RawVectorEncoding) (base Op, narrow bool, ok bool) {
+	switch {
+	case p.opcode == 0x5b && p.pp == 0:
+		return "VCVTQQ2PS", true, true
+	case p.opcode == 0x7a && p.pp == 3:
+		return "VCVTUQQ2PS", true, true
+	case p.opcode == 0xe6 && p.pp == 2:
+		return "VCVTQQ2PD", false, true
+	case p.opcode == 0x7a && p.pp == 2:
+		return "VCVTUQQ2PD", false, true
+	default:
+		return "", false, false
+	}
+}
+
+// decodedX86RawQQToFloatInstruction handles all four EVEX QWORD-to-PS/PD
+// conversion families, including every X/Y/Z, K-mask, broadcast, and
+// maximum-width embedded-rounding form.
+func decodedX86RawQQToFloatInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || !p.w || p.mapNumber != 1 {
+		return Instr{}, 0, false, nil
+	}
+	if _, _, known := x86RawQQToFloatForm(p); !known {
+		return Instr{}, 0, false, nil
+	}
+	return decodedX86PackedNumericConversionInstruction(code, mode)
+}
diff --git a/amd64_raw_qq_to_float_test.go b/amd64_raw_qq_to_float_test.go
new file mode 100644
index 000000000..4f8c77066
--- /dev/null
+++ b/amd64_raw_qq_to_float_test.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawQQToPSEncoding(unsigned bool, vectorBits, mask int, zeroing, broadcast, memory bool) []byte {
+	p1, opcode := byte(0xfc), byte(0x5b)
+	if unsigned {
+		p1, opcode = 0xff, 0x7a
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc1) // source register 1, destination register 0.
+	if memory {
+		modRM = 0x40 // disp8(AX), destination register 0.
+	}
+	code := []byte{0x62, 0xf1, p1, p2, opcode, modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func x86RawQQToPDEncoding(unsigned bool, vectorBits, mask int, zeroing, broadcast, memory bool) []byte {
+	code := x86RawQQToPSEncoding(unsigned, vectorBits, mask, zeroing, broadcast, memory)
+	code[2] = 0xfe // EVEX.W1, F3 mandatory prefix.
+	if !unsigned {
+		code[4] = 0xe6
+	}
+	return code
+}
+
+func TestDecodeX86RawQQToPSRampAVX512Regression(t *testing.T) {
+	// Go's assembler decodes these bytes as VCVTQQ2PS Z5, Y16.
+	code := []byte{0x62, 0xe1, 0xfc, 0x48, 0x5b, 0xc5, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "ramp AVX512 QQ to PS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VCVTQQ2PS" ||
+		decoded[0].Args[0].Reg != "Z5" || decoded[0].Args[1].Reg != "Y16" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawQQToPDRampAVX512Regression(t *testing.T) {
+	// Go's assembler decodes these bytes as VCVTQQ2PD Z4, Z12.
+	code := []byte{0x62, 0x71, 0xfe, 0x48, 0xe6, 0xe4, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "ramp AVX512 QQ to PD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VCVTQQ2PD" ||
+		decoded[0].Args[0].Reg != "Z4" || decoded[0].Args[1].Reg != "Z12" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawQQToPSCompleteGoForms(t *testing.T) {
+	for _, unsigned := range []bool{false, true} {
+		base := "VCVTQQ2PS"
+		if unsigned {
+			base = "VCVTUQQ2PS"
+		}
+		for width := 0; width < 3; width++ {
+			baseOp := base + [...]string{"X", "Y", ""}[width]
+			source := [...]string{"X1", "Y1", "Z1"}[width]
+			destination := [...]string{"X0", "X0", "Y0"}[width]
+			for _, form := range []struct {
+				name      string
+				mask      int
+				zeroing   bool
+				broadcast bool
+				memory    bool
+				op        string
+			}{
+				{name: "register", op: baseOp},
+				{name: "masked register", mask: 3, op: baseOp},
+				{name: "zero register", mask: 7, zeroing: true, op: baseOp + ".Z"},
+				{name: "memory", memory: true, op: baseOp},
+				{name: "broadcast memory", memory: true, broadcast: true, op: baseOp + ".BCST"},
+				{name: "broadcast zero memory", mask: 7, zeroing: true, memory: true, broadcast: true, op: baseOp + ".BCST.Z"},
+			} {
+				name := fmt.Sprintf("%s/width%d/%s", base, width, form.name)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawQQToPSEncoding(unsigned, width, form.mask, form.zeroing, form.broadcast, form.memory)
+					got, length, ok, err := decodedX86RawQQToFloatInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					if got.Op != Op(form.op) || got.Args[len(got.Args)-1].String() != destination {
+						t.Fatalf("decode %x = %+v, want %s ... %s", code, got, form.op, destination)
+					}
+					if !form.memory && got.Args[0].String() != source {
+						t.Fatalf("decode %x source = %s, want %s", code, got.Args[0], source)
+					}
+					if len(got.Args) != 2+map[bool]int{true: 1}[form.mask != 0] {
+						t.Fatalf("decode %x operands = %+v", code, got.Args)
+					}
+				})
+			}
+		}
+		for rounding := 0; rounding < 4; rounding++ {
+			code := x86RawQQToPSEncoding(unsigned, rounding, 4, true, true, false)
+			got, length, ok, err := decodedX86RawQQToFloatInstruction(code, 64)
+			want := base + [...]string{".RN_SAE.Z", ".RD_SAE.Z", ".RU_SAE.Z", ".RZ_SAE.Z"}[rounding]
+			if err != nil || !ok || length != len(code) || string(got.Op) != want ||
+				got.Args[0].String() != "Z1" || got.Args[2].String() != "Y0" {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %s Z1, K4, Y0", code, got, length, ok, err, want)
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawQQToPDCompleteGoForms(t *testing.T) {
+	for _, unsigned := range []bool{false, true} {
+		base := "VCVTQQ2PD"
+		if unsigned {
+			base = "VCVTUQQ2PD"
+		}
+		for width := 0; width < 3; width++ {
+			vector := [...]string{"X", "Y", "Z"}[width]
+			for _, form := range []struct {
+				name      string
+				mask      int
+				zeroing   bool
+				broadcast bool
+				memory    bool
+				suffix    string
+			}{
+				{name: "register"},
+				{name: "masked zero register", mask: 5, zeroing: true, suffix: ".Z"},
+				{name: "memory", memory: true},
+				{name: "broadcast memory", memory: true, broadcast: true, suffix: ".BCST"},
+				{name: "broadcast zero memory", memory: true, broadcast: true, mask: 7, zeroing: true, suffix: ".BCST.Z"},
+			} {
+				name := fmt.Sprintf("%s/width%d/%s", base, width, form.name)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawQQToPDEncoding(unsigned, width, form.mask, form.zeroing, form.broadcast, form.memory)
+					got, length, ok, err := decodedX86RawQQToFloatInstruction(code, 64)
+					if err != nil || !ok || length != len(code) || got.Op != Op(base+form.suffix) ||
+						got.Args[len(got.Args)-1].String() != vector+"0" {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					if !form.memory && got.Args[0].String() != vector+"1" {
+						t.Fatalf("decode %x source = %s, want %s1", code, got.Args[0], vector)
+					}
+				})
+			}
+		}
+		for rounding := 0; rounding < 4; rounding++ {
+			code := x86RawQQToPDEncoding(unsigned, rounding, 4, true, true, false)
+			got, length, ok, err := decodedX86RawQQToFloatInstruction(code, 64)
+			want := base + [...]string{".RN_SAE.Z", ".RD_SAE.Z", ".RU_SAE.Z", ".RZ_SAE.Z"}[rounding]
+			if err != nil || !ok || length != len(code) || string(got.Op) != want ||
+				got.Args[0].String() != "Z1" || got.Args[2].String() != "Z0" {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %s Z1, K4, Z0", code, got, length, ok, err, want)
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawQQToFloatRIPLiteral(t *testing.T) {
+	for _, kind := range []struct {
+		name   string
+		encode func(bool, int, int, bool, bool, bool) []byte
+	}{
+		{name: "PS", encode: x86RawQQToPSEncoding},
+		{name: "PD", encode: x86RawQQToPDEncoding},
+	} {
+		for _, unsigned := range []bool{false, true} {
+			for width := 0; width < 3; width++ {
+				for _, broadcast := range []bool{false, true} {
+					code := kind.encode(unsigned, width, 1, false, broadcast, false)
+					code[5] = 0x05 // RIP-relative source, destination 0.
+					code = append(code, 1, 0, 0, 0, 0xc3)
+					literalWidth := 16 << width
+					if broadcast {
+						literalWidth = 8
+					}
+					for index := 0; index < literalWidth; index++ {
+						code = append(code, byte(index+1))
+					}
+					name := fmt.Sprintf("%s/unsigned%t/width%d/broadcast%t", kind.name, unsigned, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded) != 2 || !decoded[0].x86RIPLiteral ||
+							len(decoded[0].x86RIPLiteralData) != literalWidth ||
+							broadcast != strings.Contains(string(decoded[0].Op), ".BCST") {
+							t.Fatalf("decoded %x as %+v", code, decoded)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+// Preserve this original complete byte-only fixture for both its direct-format
+// objects and its separate public missing-input contract.
+func x86RawQQToFloatOriginalSource(arch string) string {
+	var source strings.Builder
+	source.WriteString("TEXT rawQQToFloat(SB),$0-0\n")
+	appendBytes := func(code []byte) {
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+		}
+	}
+	for _, encode := range []func(bool, int, int, bool, bool, bool) []byte{
+		x86RawQQToPSEncoding,
+		x86RawQQToPDEncoding,
+	} {
+		for _, unsigned := range []bool{false, true} {
+			for width := 0; width < 3; width++ {
+				appendBytes(encode(unsigned, width, 0, false, false, false))
+				appendBytes(encode(unsigned, width, 0, false, false, true))
+				appendBytes(encode(unsigned, width, 0, false, true, true))
+				if arch == "amd64" {
+					appendBytes(encode(unsigned, width, 7, true, false, false))
+					appendBytes(encode(unsigned, width, 7, true, true, true))
+				}
+			}
+			if arch == "amd64" {
+				for rounding := 0; rounding < 4; rounding++ {
+					appendBytes(encode(unsigned, rounding, 4, true, true, false))
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateX86RawQQToFloatLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			source := x86RawQQToFloatOriginalSource(target.goarch)
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			// These unchanged byte-only formats have no input producers.
+			// Keep their actual Go objects and all three public Context
+			// controls, then compile every row through the format-only owner.
+			// Initialized public objects have their independent counterpart.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-qq-to-float.ll", "raw-qq-to-float.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawQQToPSRejectsInvalidForms(t *testing.T) {
+	zeroWithoutMask := x86RawQQToPSEncoding(false, 0, 0, true, false, false)
+	reservedLength := x86RawQQToPSEncoding(false, 3, 0, false, false, false)
+	reservedVVVV := x86RawQQToPSEncoding(false, 0, 0, false, false, false)
+	reservedVVVV[2] &^= 0x08
+	for _, code := range [][]byte{zeroWithoutMask, reservedLength, reservedVVVV} {
+		if _, _, ok, err := decodedX86RawQQToFloatInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid %x returned ok=%v, err=%v", code, ok, err)
+		}
+	}
+}
diff --git a/amd64_raw_qword_permute.go b/amd64_raw_qword_permute.go
new file mode 100644
index 000000000..fa0bf1291
--- /dev/null
+++ b/amd64_raw_qword_permute.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's _yvpermq table gives VPERMQ and VPERMPD the same operand grammar.
+// The 0F3A encodings use imm8 control; the EVEX-only 0F38 encodings use a
+// vector control operand. The table below keeps the opcode split explicit.
+var x86RawQwordPermutes = map[[2]int]Op{
+	{3, 0x00}: "VPERMQ",
+	{3, 0x01}: "VPERMPD",
+	{2, 0x36}: "VPERMQ",
+	{2, 0x16}: "VPERMPD",
+}
+
+func decodedX86RawQwordPermuteInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.pp != 1 || !p.w {
+		return Instr{}, 0, false, nil
+	}
+	op, known := x86RawQwordPermutes[[2]int{p.mapNumber, p.opcode}]
+	if !known {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("qword permute: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.vectorLength < 1 || p.vectorLength > 2 || !p.evex && p.vectorLength != 1 {
+		return fail("only Y and Z vector lengths are in Go's qword permute table")
+	}
+	if p.evex && !p.fixed {
+		return fail("invalid EVEX fixed bit")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	immediate := p.mapNumber == 3
+	if !immediate && !p.evex {
+		return fail("variable-control form requires EVEX")
+	}
+	if immediate && p.upper != 0 {
+		return fail("immediate form reserves vvvv and V'")
+	}
+	registerSource := code[p.modRM]>>6 == 3
+	if p.broadcast && (registerSource || !p.evex) {
+		return fail("broadcast requires EVEX memory source")
+	}
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (!p.evex && destinationNumber >= 8 ||
+		width == "Z" && (destinationNumber >= 8 || !immediate && p.upper >= 8)) {
+		return fail("destination or control register unavailable in 32-bit mode")
+	}
+
+	scale := 16 << p.vectorLength
+	if p.broadcast {
+		scale = 8
+	}
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width, scale)
+	} else {
+		source, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if mode == 32 && width == "Z" && source.Kind == OpReg {
+		index, _ := amd64VectorRegisterIndex(source.Reg, 64)
+		if index >= 8 {
+			return fail("Z source register unavailable in 32-bit mode")
+		}
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destinationNumber))}
+	args := make([]Operand, 0, 4)
+	if immediate {
+		if len(code) <= p.modRM+consumed {
+			return fail("missing immediate byte")
+		}
+		args = append(args, Operand{Kind: OpImm, Imm: int64(code[p.modRM+consumed])})
+	} else {
+		args = append(args, source)
+		source = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	}
+	args = append(args, source)
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	length := p.modRM + consumed
+	if immediate {
+		length++
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, length, true, nil
+}
diff --git a/amd64_raw_qword_permute_test.go b/amd64_raw_qword_permute_test.go
new file mode 100644
index 000000000..a442b90f2
--- /dev/null
+++ b/amd64_raw_qword_permute_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawQwordPermuteGoEncoderForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawqwordpermute(SB),4,$0-0\n")
+			for _, op := range []string{"VPERMQ", "VPERMPD"} {
+				fmt.Fprintf(&source, "%s $216, Y2, Y2\n", op)
+				fmt.Fprintf(&source, "%s $1, 64(BX), Y3\n", op)
+				fmt.Fprintf(&source, "%s $2, Y20, Y21\n", op)
+				if arch == "amd64" {
+					fmt.Fprintf(&source, "%s $3, Z20, Z21\n", op)
+				} else {
+					fmt.Fprintf(&source, "%s $3, Z0, Z1\n", op)
+				}
+				fmt.Fprintf(&source, "%s.BCST $4, 8(BX), Y21\n", op)
+				fmt.Fprintf(&source, "%s Y0, Y1, Y2\n", op)
+				fmt.Fprintf(&source, "%s (BX), Y1, Y2\n", op)
+				fmt.Fprintf(&source, "%s Y20, Y21, Y22\n", op)
+				if arch == "amd64" {
+					fmt.Fprintf(&source, "%s.BCST 16(BX), Z21, Z22\n", op)
+				} else {
+					fmt.Fprintf(&source, "%s.BCST 16(BX), Z1, Z2\n", op)
+				}
+				if arch == "amd64" {
+					fmt.Fprintf(&source, "%s.Z $5, -32(R8), K2, Z21\n", op)
+					fmt.Fprintf(&source, "%s.Z Z20, Z21, K3, Z22\n", op)
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for index, got := range decoded.Instrs {
+				if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", index, got, want[index])
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawQwordPermuteRejectsMalformedForms(t *testing.T) {
+	const source = "TEXT rawqwordpermute(SB),4,$0-0\nVPERMQ $1, Y2, Y3\nRET\n"
+	assembled := assembleX87ControlBytes(t, "amd64", source)
+	if len(assembled) < 7 || assembled[0] != 0xc4 {
+		t.Fatalf("Go did not emit a VEX permute: %x", assembled)
+	}
+	valid := assembled[:len(assembled)-1]
+	for _, test := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"missing immediate", func(code []byte) []byte { return code[:len(code)-1] }},
+		{"reserved vvvv", func(code []byte) []byte { code[2] &^= 0x08; return code }},
+		{"wrong vector length", func(code []byte) []byte { code[2] &^= 0x04; return code }},
+		{"address override", func(code []byte) []byte { return append([]byte{0x67}, code...) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.mutate(append([]byte(nil), valid...))
+			if _, _, recognized, err := decodedX86RawQwordPermuteInstruction(code, 64); !recognized || err == nil {
+				t.Fatalf("invalid %x: recognized=%v err=%v", code, recognized, err)
+			}
+		})
+	}
+	const evexSource = "TEXT rawqwordpermute(SB),4,$0-0\nVPERMPD.Z Z1, Z2, K1, Z3\nRET\n"
+	evex := assembleX87ControlBytes(t, "amd64", evexSource)
+	if len(evex) < 7 || evex[0] != 0x62 {
+		t.Fatalf("Go did not emit an EVEX permute: %x", evex)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"missing mask", func(code []byte) []byte { code[3] &^= 7; return code }},
+		{"invalid vector length", func(code []byte) []byte { code[3] &^= 0x60; return code }},
+		{"missing fixed bit", func(code []byte) []byte { code[2] &^= 4; return code }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.mutate(append([]byte(nil), evex[:len(evex)-1]...))
+			if _, _, recognized, err := decodedX86RawQwordPermuteInstruction(code, 64); !recognized || err == nil {
+				t.Fatalf("invalid %x: recognized=%v err=%v", code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawQwordPermuteLLVM22AllTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, form := range []string{
+		"VPERMQ $216, Y2, Y3",
+		"VPERMPD Z1, Z2, Z3",
+	} {
+		for _, target := range []struct {
+			goarch string
+			triple string
+		}{
+			{"amd64", "x86_64-apple-darwin"},
+			{"amd64", "x86_64-unknown-linux-gnu"},
+			{"amd64", "x86_64-pc-windows-msvc"},
+			{"386", "i386-unknown-linux-gnu"},
+			{"386", "i686-pc-windows-msvc"},
+		} {
+			t.Run(form+"/"+target.triple, func(t *testing.T) {
+				source := "TEXT rawqwordpermute(SB),4,$0-0\n" + form + "\nRET\n"
+				code := assembleX87ControlBytes(t, target.goarch, source)
+				var raw strings.Builder
+				raw.WriteString("TEXT rawqwordpermute(SB),4,$0-0\n")
+				for _, value := range code {
+					fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+				}
+				if actual := assembleX87ControlBytes(t, target.goarch, raw.String()); !bytes.Equal(actual, code) {
+					t.Fatal("complete original Go BYTE source changed its instruction or RET bytes", actual, code)
+				}
+				// Preserve complete BYTE/RET Go objects and all public Context
+				// controls before independently normalizing the private emitter
+				// unit. Neither raw identity nor an unbound RET supplies NUM.
+				ir := x86ElementPermuteUnboundFormatObject(t, raw.String(), target.goarch, target.triple, 1, 0)
+				x86ElementPermuteCompileFormatObjects(t, llc, target.triple, ir)
+			})
+		}
+	}
+}
diff --git a/amd64_raw_rdpid_test.go b/amd64_raw_rdpid_test.go
new file mode 100644
index 000000000..dafd8d26f
--- /dev/null
+++ b/amd64_raw_rdpid_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawRDPIDCompleteRegisterFamily(t *testing.T) {
+	registers := [...]string{
+		"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI",
+		"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
+	}
+	for _, mode := range []int{32, 64} {
+		count := 8
+		if mode == 64 {
+			count = len(registers)
+		}
+		for register := 0; register < count; register++ {
+			code := []byte{0xf3}
+			if register >= 8 {
+				code = append(code, 0x41)
+			}
+			code = append(code, 0x0f, 0xc7, byte(0xf8|register&7))
+			decoded, err := decodeX86RawDirectiveGroup(code, mode, 0, "RDPID raw bytes", nil)
+			if err != nil {
+				t.Fatalf("mode %d, %x: %v", mode, code, err)
+			}
+			if len(decoded) != 1 || decoded[0].Op != "RDPID" || len(decoded[0].Args) != 1 ||
+				decoded[0].Args[0].Reg != Reg(registers[register]) {
+				t.Fatalf("mode %d, %x decoded as %+v", mode, code, decoded)
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawRDPIDReportedByteArena(t *testing.T) {
+	const source = `TEXT rawRDPID(SB),$0-0
+	BYTE $0xF3; BYTE $0x0F; BYTE $0xC7; BYTE $0xF9
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"rawRDPID": {Name: "rawRDPID", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@llvm.x86.rdpid()") {
+		t.Fatalf("raw RDPID did not call the RDPID intrinsic:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "raw-rdpid.ll", "raw-rdpid.o", ir)
+}
diff --git a/amd64_raw_return_fp_width_contract_test.go b/amd64_raw_return_fp_width_contract_test.go
new file mode 100644
index 000000000..1ade2f726
--- /dev/null
+++ b/amd64_raw_return_fp_width_contract_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86RawReturnScalarFrame(word int, typ LLVMType) FuncSig {
+	return FuncSig{Name: "Raw", Args: []LLVMType{typ}, Ret: typ,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: int64(word), Type: typ, Index: 0, Field: -1}},
+		}}
+}
+
+// A byte/word write to a wider FP slot must preserve the untouched bytes.
+// The bounded raw-return contract does not establish that partial-width
+// lowering, even when the access is inside the declared scalar's bounds.
+// These original returning sources are never executed or rewritten as passes.
+func TestX86RawReturnPartialFPAccessNeedsContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		partialMoves := []string{"MOVB", "MOVW"}
+		if word == 8 {
+			partialMoves = append(partialMoves, "MOVL")
+		}
+		for _, partial := range partialMoves {
+			for _, access := range []string{
+				partial + " $17,x+0(FP)\n" + move + " x+0(FP),AX",
+				partial + " x+0(FP),AX",
+				fmt.Sprintf("%s $17,ret+%d(FP)", partial, word),
+				fmt.Sprintf("%s ret+%d(FP),AX", partial, word),
+			} {
+				for _, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+					t.Run(target.triple+"/"+access+"/"+encoding, func(t *testing.T) {
+						source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s\n%s\nRET\n", 2*word, access, encoding)
+						requireX86GoAssemblerResult(t, target.arch, source, true)
+						opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{"Raw": x86RawReturnScalarFrame(word, typ)}}
+						x86RawReturnPointerAPIs(t, source, opt, true)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawReturnActualGoDeclarationRejectsPartialFPStore(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, declaration := "MOVQ", 8, "func Raw(x uint64) uint64"
+		if target.arch == "386" {
+			move, word, declaration = "MOVL", 4, "func Raw(x uint32) uint32"
+		}
+		source := fmt.Sprintf("TEXT ·Raw(SB),4,$0-%d\nMOVB $17,x+0(FP)\n%s x+0(FP),AX\n%s AX,ret+%d(FP)\nBYTE $0xc3\nRET\n", 2*word, move, move, word)
+		requireX86GoAssemblerResult(t, target.arch, source, true)
+		pkg := mustGoPackage(t, "test/rawret", "package rawret\n"+declaration+"\n")
+		options := GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple,
+			ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") }}
+		ctx := llvm.NewContext()
+		translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), options)
+		if translation != nil {
+			translation.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s actual declaration authorized an unproved partial FP store: %v", target.triple, err)
+		}
+	}
+}
+
+func TestX86RawReturnFrameSlotMustMatchSignature(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		for _, test := range []struct {
+			name   string
+			mutate func(*FuncSig)
+		}{
+			{"overlap-parameter", func(sig *FuncSig) {
+				sig.Args = append(sig.Args, I32)
+				sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(word / 2), Type: I32, Index: 1, Field: -1})
+			}},
+			{"overlap-result", func(sig *FuncSig) { sig.Frame.Results[0].Offset = int64(word / 2) }},
+			{"parameter-type", func(sig *FuncSig) { sig.Args[0] = I8 }},
+			{"parameter-scalar-field", func(sig *FuncSig) { sig.Frame.Params[0].Field = 0 }},
+			{"parameter-scalar-path", func(sig *FuncSig) { sig.Frame.Params[0].Fields = []int{0} }},
+			{"parameter-field-type", func(sig *FuncSig) {
+				sig.Args[0] = LLVMType("{ i8, ptr }")
+				sig.Frame.Params[0].Field = 0
+			}},
+			{"parameter-field-index", func(sig *FuncSig) {
+				sig.Args[0] = LLVMType("{ ptr, " + string(typ) + " }")
+				sig.Frame.Params[0].Field = 2
+			}},
+			{"parameter-negative-path", func(sig *FuncSig) {
+				sig.Args[0] = LLVMType("{ ptr, " + string(typ) + " }")
+				sig.Frame.Params[0].Fields = []int{-1}
+			}},
+			{"parameter-nested-path", func(sig *FuncSig) {
+				sig.Args[0] = LLVMType("{ ptr, " + string(typ) + " }")
+				sig.Frame.Params[0].Fields = []int{1, 0}
+			}},
+			{"result-type", func(sig *FuncSig) { sig.Ret = I8 }},
+			{"result-scalar-field", func(sig *FuncSig) { sig.Frame.Results[0].Field = 0 }},
+			{"result-scalar-path", func(sig *FuncSig) { sig.Frame.Results[0].Fields = []int{0} }},
+			{"result-tuple-type", func(sig *FuncSig) { sig.Ret = "{ i8, ptr }" }},
+			{"result-tuple-field", func(sig *FuncSig) {
+				sig.Ret = LLVMType("{ " + string(typ) + ", ptr }")
+				sig.Frame.Results[0].Field = 1
+			}},
+		} {
+			t.Run(target.triple+"/"+test.name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+0(FP),AX\n%s AX,ret+%d(FP)\nBYTE $0xc3\nRET\n", 2*word, move, move, word)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				sig := x86RawReturnScalarFrame(word, typ)
+				test.mutate(&sig)
+				x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Raw": sig}}, true)
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundAggregateScalarSlotObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		for _, explicitPath := range []bool{false, true} {
+			for _, tupleResult := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/path%t/tuple%t", target.triple, explicitPath, tupleResult), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+%d(FP),AX\n%s AX,ret+%d(FP)\nBYTE $0xc3\nRET\n", 3*word, move, word, move, 2*word)
+					requireX86GoAssemblerResult(t, target.arch, source, true)
+					sig := FuncSig{Name: "Raw", Args: []LLVMType{LLVMType("{ ptr, " + string(typ) + " }")}, Ret: typ,
+						Frame: FrameLayout{
+							Params:  []FrameSlot{{Offset: int64(word), Type: typ, Index: 0, Field: 1}},
+							Results: []FrameSlot{{Offset: int64(2 * word), Type: typ, Index: 0, Field: -1}},
+						}}
+					if explicitPath {
+						sig.Frame.Params[0].Field = -1
+						sig.Frame.Params[0].Fields = []int{1}
+					}
+					if tupleResult {
+						sig.Ret = LLVMType("{ ptr, " + string(typ) + " }")
+						sig.Frame.Results = []FrameSlot{
+							{Offset: int64(2 * word), Type: Ptr, Index: 0, Field: -1},
+							{Offset: int64(3 * word), Type: typ, Index: 1, Field: -1},
+						}
+						source = fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+%d(FP),AX\n%s $0,ret0+%d(FP)\n%s AX,ret1+%d(FP)\nBYTE $0xc3\nRET\n", 4*word, move, word, move, 2*word, move, 3*word)
+						requireX86GoAssemblerResult(t, target.arch, source, true)
+					}
+					opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Raw": sig}}
+					x86RawReturnPointerAPIs(t, source, opt, false)
+					ir, err := Translate(mustParseX86RawReturn(t, source), opt)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "bound-field.ll", "bound-field.o", ir)
+				})
+			}
+		}
+	}
+}
+
+// Object evidence only: this independent UD2 harness cannot return to a caller
+// and is never executed. It exposes existing generic partial FP lowering; a
+// compiled object does not certify preservation of bytes outside the write.
+func TestX86PartialFPStoreCompileOnlyEvidence(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, typ := 8, I64
+			if target.arch == "386" {
+				word, typ = 4, I32
+			}
+			source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\nMOVB $17,x+0(FP)\nUD2\nRET\n", 2*word)
+			dir := t.TempDir()
+			asm, object := filepath.Join(dir, "partial.s"), filepath.Join(dir, "partial.o")
+			if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			cmd := exec.Command("go", "tool", "asm", "-p", "example.com/partial", "-o", object, asm)
+			cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+target.arch)
+			if out, err := cmd.CombinedOutput(); err != nil {
+				t.Fatalf("Go assembler failed: %v\n%s", err, out)
+			}
+			out, err := exec.Command("go", "tool", "objdump", "-s", "Raw", object).CombinedOutput()
+			if err != nil || !strings.Contains(string(out), "MOVB $0x11") {
+				t.Fatalf("Go object did not retain the one-byte write: %v\n%s", err, out)
+			}
+			t.Logf("actual Go object, not executed:\n%s", out)
+			ir, err := Translate(mustParseX86RawReturn(t, source), Options{
+				Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"Raw": x86RawReturnScalarFrame(word, typ)},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, "17") || strings.Contains(line, "fp_arg") || strings.Contains(line, "zext i8") ||
+					strings.Contains(line, "store "+string(typ)+" %") || strings.Contains(line, "classic_frame") {
+					t.Log("generic lowering observation (not a semantic pass):", line)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "partial-compile-only.ll", "partial-compile-only.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_return_pointer_contract_test.go b/amd64_raw_return_pointer_contract_test.go
new file mode 100644
index 000000000..ffe4b0785
--- /dev/null
+++ b/amd64_raw_return_pointer_contract_test.go
@@ -0,0 +1,300 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are compile-only contract counterexamples, not programs that mutate a
+// live return address. Go acceptance proves source grammar, never alias safety.
+func x86RawReturnPointerAPIs(t *testing.T, source string, opt Options, wantContext bool) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "owned-module", "annotated"} {
+		var callErr error
+		switch api {
+		case "text":
+			_, callErr = Translate(file, opt)
+		case "module":
+			module, err := TranslateModule(file, opt)
+			if err == nil {
+				module.Dispose()
+			}
+			callErr = err
+		default:
+			ctx := llvm.NewContext()
+			options := opt
+			options.AnnotateSource = api == "annotated"
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err == nil {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			callErr = err
+		}
+		if wantContext && !errors.Is(callErr, ErrProbeNeedsContext) {
+			t.Errorf("%s did not reject an unproved native continuation: %v", api, callErr)
+		}
+		if !wantContext && callErr != nil {
+			t.Errorf("%s rejected a bounded FP/static leaf: %v", api, callErr)
+		}
+	}
+}
+
+func TestX86RawReturnPointerMemoryNeedsContinuationContract(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		instructions := []string{
+			"MOVB $0,(AX)", "MOVW $0,1(AX)", "MOVL $0,4(AX)",
+			"MOVB (AX),AL", "ADDL $1,(AX)", "XCHGL AX,(AX)",
+			"MOVOU X0,(AX)", "SETEQ (AX)", "BTSL $1,(AX)",
+			"VMASKMOVPS X0,X1,(AX)", "VMASKMOVPD X0,X1,(AX)",
+			"VPMASKMOVD X0,X1,(AX)", "VPMASKMOVQ X0,X1,(AX)",
+			"VMOVDQU32 X0,K1,(AX)",
+			move + " AX,BX\nMOVB $0,(BX)",
+			move + " $saved<>(SB),AX\nMOVB $0,(AX)",
+			"MOVB $0,saved<>(SB)(AX*1)",
+			"MOVB $0,0(AX)(CX*2)",
+		}
+		if target.arch == "amd64" {
+			instructions = append(instructions, "MOVQ $0,8(AX)")
+		}
+		for _, instruction := range instructions {
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				source := fmt.Sprintf("GLOBL saved<>(SB),8,$32\nTEXT Raw(SB),4,$0-%d\n%s p+0(FP),AX\n%s\nBYTE $0xc3\nRET\n", word, move, instruction)
+				// Go permits indexed static-base addressing in 386, but rejects
+				// this spelling in amd64. Keep the latter as a defensive parsed
+				// source negative, not a positive Go format witness.
+				goAccepted := target.arch == "386" || instruction != "MOVB $0,saved<>(SB)(AX*1)"
+				requireX86GoAssemblerResult(t, target.arch, source, goAccepted)
+				sig := FuncSig{Name: "Raw", Args: []LLVMType{Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+				x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Raw": sig}}, true)
+			})
+		}
+	}
+}
+
+func TestX86RawReturnImplicitMemoryNeedsContinuationContract(t *testing.T) {
+	instructions := []string{"XLAT", "MASKMOVQ M0,M1", "MASKMOVOU X0,X1", "MASKMOVDQU X0,X1", "VMASKMOVDQU X0,X1"}
+	for op := range x86StringSpecs {
+		instructions = append(instructions, string(op))
+	}
+	for _, op := range []string{"INSB", "INSW", "INSL", "OUTSB", "OUTSW", "OUTSL"} {
+		instructions = append(instructions, op)
+	}
+	sort.Strings(instructions)
+	for _, target := range x86RawReturnTargets {
+		for _, instruction := range instructions {
+			if target.arch == "386" && strings.HasSuffix(instruction, "Q") && !strings.HasPrefix(instruction, "MASK") {
+				continue // Go's 32-bit string table has no Q-width forms.
+			}
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				source := "TEXT Raw(SB),4,$0-0\n" + instruction + "\nBYTE $0xc3\nRET\n"
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Ret: Void}}}, true)
+			})
+		}
+	}
+}
+
+func TestX86RawReturnFPRequiresBoundTypedSlot(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		for _, frame := range []FrameLayout{
+			{}, {Params: []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}}},
+		} {
+			offset := 0
+			if len(frame.Params) != 0 {
+				offset = 100
+			}
+			source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+%d(FP),AX\nBYTE $0xc3\nRET\n", word, move, offset)
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Args: []LLVMType{typ}, Ret: typ, Frame: frame}}}, true)
+		}
+		source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s AX,ret+%d(FP)\nBYTE $0xc3\nRET\n", 2*word, move, word)
+		requireX86GoAssemblerResult(t, target.arch, source, true)
+		x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+			Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Args: []LLVMType{typ}, Ret: typ,
+				Frame: FrameLayout{Results: []FrameSlot{{Offset: int64(word), Type: typ, Index: 1, Field: -1}}}}}}, true)
+	}
+}
+
+func TestX86RawReturnMemoryRangeAndUnknownShapeNeedContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		for _, test := range []struct {
+			name, instruction string
+			slot              FrameSlot
+		}{
+			{"fp-too-narrow", move + " x+0(FP),AX", FrameSlot{Type: I8, Index: 0, Field: -1}},
+			{"fp-unrecognized-type", move + " x+0(FP),AX", FrameSlot{Type: "i128", Index: 0, Field: -1}},
+			{"fp-unbound-index", move + " x+0(FP),AX", FrameSlot{Type: typ, Index: 1, Field: -1}},
+			{"static-before-region", "MOVL AX,saved<>-1(SB)", FrameSlot{Type: typ, Index: 0, Field: -1}},
+			{"static-after-region", "MOVL AX,saved<>+32(SB)", FrameSlot{Type: typ, Index: 0, Field: -1}},
+			{"static-cross-end", "MOVL AX,saved<>+30(SB)", FrameSlot{Type: typ, Index: 0, Field: -1}},
+			{"static-no-object-contract", "MOVL AX,unknown(SB)", FrameSlot{Type: typ, Index: 0, Field: -1}},
+		} {
+			t.Run(target.triple+"/"+test.name, func(t *testing.T) {
+				source := fmt.Sprintf("GLOBL saved<>(SB),8,$32\nTEXT Raw(SB),4,$0-%d\n%s\nBYTE $0xc3\nRET\n", word, test.instruction)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				x86RawReturnPointerAPIs(t, source, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Args: []LLVMType{typ}, Ret: typ,
+						Frame: FrameLayout{Params: []FrameSlot{test.slot}}}}}, true)
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundFPAndStaticObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		for _, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+			for _, pointer := range []bool{false, true} {
+				valueType := typ
+				if pointer {
+					valueType = Ptr
+				}
+				source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+0(FP),AX\n%s AX,ret+%d(FP)\n%s\nRET\n", 2*word, move, move, word, encoding)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				sig := FuncSig{Name: "Raw", Args: []LLVMType{valueType}, Ret: valueType,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: valueType, Index: 0, Field: -1}},
+						Results: []FrameSlot{{Offset: int64(word), Type: valueType, Index: 0, Field: -1}}}}
+				opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Raw": sig}}
+				x86RawReturnPointerAPIs(t, source, opt, false)
+				ir, err := Translate(mustParseX86RawReturn(t, source), opt)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "fp-return.ll", "fp-return.o", ir)
+			}
+			source := "GLOBL saved<>(SB),8,$32\nTEXT Raw(SB),4,$0-0\nMOVL $17,AX\nMOVL AX,saved<>+4(SB)\nMOVL saved<>+4(SB),AX\n" + encoding + "\nRET\n"
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Ret: I32}}}
+			x86RawReturnPointerAPIs(t, source, opt, false)
+			ir, err := Translate(mustParseX86RawReturn(t, source), opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "static-return.ll", "static-return.o", ir)
+		}
+	}
+}
+
+func TestX86RawReturnPrepartitionRetainsFinalFrameValidation(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word, typ := "MOVQ", 8, I64
+		if target.arch == "386" {
+			move, word, typ = "MOVL", 4, I32
+		}
+		source := fmt.Sprintf("TEXT Raw(SB),4,$0-%d\n%s x+0(FP),AX\nBYTE $0xc3\nRET\n", word, move)
+		file, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), target.arch)
+		if err != nil {
+			t.Fatal("pure preparation must not discard the future typed frame:", err)
+		}
+		opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+			Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Args: []LLVMType{typ}, Ret: typ}}}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, file, opt)
+		if err == nil {
+			module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("prepartition preparation erased the final missing-frame contract:", err)
+		}
+		sig := opt.Sigs["Raw"]
+		sig.Frame.Params = []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}}
+		opt.Sigs["Raw"] = sig
+		ctx = llvm.NewContext()
+		module, err = TranslateModuleInContext(ctx, file, opt)
+		if err == nil {
+			module.Dispose()
+		}
+		ctx.Dispose()
+		if err != nil {
+			t.Fatal("existing consumer's bound signature was not consumed:", err)
+		}
+	}
+}
+
+func TestX86RawReturnActualGoDeclarationContract(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, test := range []struct {
+			name, declaration, body string
+			argSize                 int
+			context                 bool
+		}{
+			{"pointer-store", "func Raw(*byte)", move + " p+0(FP),AX\nMOVB $0,(AX)", word, true},
+			{"unknown-fp", "func Raw(uintptr) uintptr", move + " p+100(FP),AX", 2 * word, true},
+			{"typed-pointer-transport", "func Raw(*byte) *byte", fmt.Sprintf("%s p+0(FP),AX\n%s AX,ret+%d(FP)", move, move, word), 2 * word, false},
+			{"typed-static-global", "func Raw() uint32", "MOVL $17,AX\nMOVL AX,saved<>+4(SB)\nMOVL saved<>+4(SB),AX\nMOVL AX,ret+0(FP)", 4, false},
+		} {
+			t.Run(target.triple+"/"+test.name, func(t *testing.T) {
+				source := fmt.Sprintf("GLOBL saved<>(SB),8,$32\nTEXT ·Raw(SB),4,$0-%d\n%s\nBYTE $0xc3\nRET\n", test.argSize, test.body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				pkg := mustGoPackage(t, "test/rawret", "package rawret\n"+test.declaration+"\n")
+				options := GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple,
+					ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") }}
+				tr, err := TranslateGoModule(pkg, []byte(source), options)
+				if tr != nil {
+					defer tr.Module.Dispose()
+				}
+				if test.context {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("a Go pointer/declaration invented a return-PC contract:", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal("actual declaration's bounded typed frame rejected:", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "declared-return.ll", "declared-return.o", tr.Module.String())
+			})
+		}
+	}
+}
+
+func mustParseX86RawReturn(t *testing.T, source string) *File {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file
+}
diff --git a/amd64_raw_return_source_address_runtime_test.go b/amd64_raw_return_source_address_runtime_test.go
new file mode 100644
index 000000000..a2e73c1ce
--- /dev/null
+++ b/amd64_raw_return_source_address_runtime_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// The original native reference executes Go's actual LEA and raw C3 bytes,
+// not an encoding manufactured by the translator. Register arguments here
+// are an explicit numerical custom ABI, never a native-pointer permission.
+func TestCrossLinuxRuntimeMatrixX86RawReturnSourceAddressNumerical(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var assembly, oracle, checks strings.Builder
+	oracle.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+	sigs := make(map[string]FuncSig)
+	for _, width := range []string{"L", "Q"} {
+		for _, scale := range []int{1, 2, 4, 8} {
+			name := fmt.Sprintf("address%s%d", width, scale)
+			source := fmt.Sprintf("TEXT %s(SB),4,$0-0\nMOV%s $-7(AX)(CX*%d),AX\nBYTE $0xc3\nRET\n", name, width, scale)
+			assembly.WriteString(source)
+			code := x86PackedShiftActualGoBytes(t, "amd64", source)
+			instruction, err := x86asm.Decode(code, 64)
+			if err != nil || instruction.Op != x86asm.LEA || instruction.Len >= len(code) || code[instruction.Len] != 0xc3 {
+				t.Fatalf("actual Go address rewrite/raw return lost: %x / %v", code, err)
+			}
+			var bytes strings.Builder
+			for _, value := range code[:instruction.Len+1] {
+				if bytes.Len() != 0 {
+					bytes.WriteByte(',')
+				}
+				fmt.Fprintf(&bytes, "0x%02x", value)
+			}
+			oracle.WriteString(x86OriginalSysVDeclaration("uint64_t", "original"+name, "uint64_t,uint64_t"))
+			fmt.Fprintf(&oracle, `
+extern uint64_t %[1]s(uint64_t,uint64_t);
+__asm__(".text\n.globl " LABEL("original%[1]s") "\n"
+        LABEL("original%[1]s") ":\n"
+        "movq %%rdi,%%rax\nmovq %%rsi,%%rcx\n.byte %[2]s\n");
+`, name, bytes.String())
+			want := fmt.Sprintf("a+%d*b-7", scale)
+			if width == "L" {
+				want = "(uint64_t)(uint32_t)(" + want + ")"
+			}
+			fmt.Fprintf(&checks, `
+    { uint64_t want=%[1]s;
+      if (%[2]s(a,b)!=want || original%[2]s(a,b)!=want) {
+        fprintf(stderr,"raw RET address %[2]s seed %%u\n",seed); return 1;
+      }
+    }
+`, want, name)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{I64, I64}, ArgRegs: []Reg{AX, CX}, Ret: I64}
+		}
+	}
+	oracle.WriteString(`int main(void) {
+  for (unsigned seed=0; seed<256; seed++) {
+    uint64_t a=UINT64_C(0x1313939382827272)*seed,b=~a;
+` + checks.String() + `
+  }
+  puts("RAW_RET_NUMERICAL_ADDRESS_2048_OK");
+  return 0;
+}
+`)
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		output := execution.compileAndRunLLVM(t, "raw-return-address", ir, oracle.String(), level)
+		if string(output) != "RAW_RET_NUMERICAL_ADDRESS_2048_OK\n" {
+			t.Fatalf("missing complete numerical original/LLVM oracle: %q", output)
+		}
+	}
+}
diff --git a/amd64_raw_return_source_address_test.go b/amd64_raw_return_source_address_test.go
new file mode 100644
index 000000000..8ff3cecae
--- /dev/null
+++ b/amd64_raw_return_source_address_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Go progedit rewrites the whole MOVL/Q TYPE_ADDR family to LEAL/Q before
+// classification. A raw near RET must not prohibit a purely numerical,
+// stack-unobserving address calculation or inherit unrelated source proofs.
+func TestX86RawReturnSourceAddressLeafThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"L"}
+		if target.arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, address := range []string{"8(AX)", "-8(AX)(CX*1)", "16(AX)(CX*2)", "32(AX)(CX*4)", "64(AX)(CX*8)", "8(CX*4)", "(1<<4)(AX)"} {
+				t.Run(target.triple+"/"+width+"/"+address, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·addr(SB),4,$0-0\nMOVL $3,AX\nMOVL $2,CX\nMOV%s $%s,BX\nBYTE $0xc3\nRET\n", width, address)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					before := fmt.Sprintf("%#v", file.Funcs)
+					pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+					resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							context := llvm.NewContext()
+							defer context.Dispose()
+							var ir string
+							var err error
+							switch api {
+							case "text":
+								ir, err = Translate(file, options)
+							case "module":
+								var module llvm.Module
+								module, err = TranslateModuleInContext(context, file, options)
+								if !module.IsNil() {
+									defer module.Dispose()
+									ir = module.String()
+								}
+							case "GoModule":
+								var result *GoModuleTranslation
+								result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+									GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+								if result != nil && !result.Module.IsNil() {
+									defer result.Module.Dispose()
+									ir = result.Module.String()
+								}
+							}
+							if err != nil {
+								t.Fatal(err)
+							}
+							compileLLVMToObject(t, llc, target.triple, "raw-return-address.ll", "raw-return-address.o", ir)
+							if before != fmt.Sprintf("%#v", file.Funcs) {
+								t.Fatal("derived address changed the original source")
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawReturnSourceAddressCannotInheritProof(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := Parse(ArchAMD64, "TEXT addr(SB),4,$0-0\nMOVL $8(AX)(CX*4),BX\nBYTE $0xc3\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Name: "addr", Ret: Void}}}
+		normalized, err := normalizeX86RawFile(file, arch, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, field := range []string{"sourceStack", "fixedLocal", "rawText", "LOCK", "frame", "scalarConstant", "g", "memory", "encodedSibling"} {
+			t.Run(arch+"/"+field, func(t *testing.T) {
+				copy := *normalized
+				copy.Funcs = append([]Func(nil), normalized.Funcs...)
+				fn := &copy.Funcs[0]
+				fn.Instrs = append([]Instr(nil), fn.Instrs...)
+				fn.Instrs[1].Args = append([]Operand(nil), fn.Instrs[1].Args...)
+				switch field {
+				case "sourceStack":
+					fn.x86SourceStack = &x86SourceStackProof{}
+				case "fixedLocal":
+					fn.x86FixedLocal = &x86FixedLocalProof{}
+				case "rawText":
+					fn.X86RawText = []byte{0xc3}
+				case "LOCK":
+					fn.Instrs = append(fn.Instrs, Instr{Op: "LOCK"})
+				case "frame":
+					fn.FrameSize = 8
+				case "scalarConstant":
+					fn.Instrs[1].Op = "MOVW"
+				case "g":
+					fn.Instrs = append(fn.Instrs, Instr{Op: "MOVQ", Args: []Operand{{Kind: OpReg, Reg: "R14"}, {Kind: OpReg, Reg: AX}}})
+				case "memory":
+					fn.Instrs = append(fn.Instrs, Instr{Op: "MOVL", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX}}, {Kind: OpReg, Reg: DX}}})
+				case "encodedSibling":
+					fn.Instrs = append(fn.Instrs, Instr{Op: "MOVL", Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}, x86Encoded: true})
+				}
+				before := fmt.Sprintf("%#v", fn)
+				if _, err := normalizeX86SourceIntegerAddresses(&copy, options); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("adapter inherited %s proof or native effect: %v", field, err)
+				}
+				if before != fmt.Sprintf("%#v", fn) || !reflect.DeepEqual(file.Funcs[0].Instrs[1].Args, normalized.Funcs[0].Instrs[1].Args) {
+					t.Fatal("rejection modified original instructions")
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_raw_return_source_stack.go b/amd64_raw_return_source_stack.go
new file mode 100644
index 000000000..b5aced6ee
--- /dev/null
+++ b/amd64_raw_return_source_stack.go
@@ -0,0 +1,971 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// This is a source ABI0 stack, not LLVM's physical stack or an incoming native
+// pointer. It is enabled only after all returns and all stack uses are proved.
+// Ordinary pointers need a separately consumed complete Go caller proof.
+// Nonzero TEXT frames, calls and private-stack address escape cannot use it.
+type x86SourceStackProof struct {
+	minimum      int64
+	word         int64
+	caller       *x86GoCallerRegionProof
+	scalarResult *x86SourceStackScalarProof
+	// Exact public normalized source bytes, excluding private certificates.
+	normalized [32]byte
+	// Diagnostic-only finite replay counts, never used as permission inputs.
+	countedIterations [4]int
+}
+
+// Bind raw stack producer identity before consulting Go's named PUSH/POP
+// deltasp rules. Edited normalized instructions cannot borrow that origin.
+type x86SourceRawInstruction struct {
+	op          Op
+	args        []Operand
+	vectorBytes int
+	addressBits int // Exact decoded mode; not an address-size or native-entry permission.
+	// Conversion-only physical identity, captured explicitly by the decoder.
+	// A zero value is absent, not an SSE/VEX or non-MMX assertion.
+	packedConversion x86RawPackedConversionIdentity
+	// A low-bank unmasked packed move still retains its physical generation.
+	packedMove      x86RawPackedMoveIdentity
+	packedReduction x86RawPackedReductionIdentity
+	ternaryLogic    x86RawTernaryLogicIdentity
+	// An absent mode snapshot cannot claim a legacy compare continuation.
+	legacyFloatCompare x86RawLegacyFloatCompareIdentity
+	comi               x86RawCOMIIdentity
+	floatMinMax        x86RawFloatMinMaxIdentity
+	// Neither an absent snapshot nor a low bank implies a VEX conversion.
+	scalarPrecision    x86RawScalarPrecisionIdentity
+	scalarFloatInteger x86RawScalarFloatIntegerIdentity
+	packedPrecision    x86RawPackedPrecisionIdentity
+	namedHalf          x86RawNamedHalfIdentity
+	fma3               x86RawFMA3Identity
+	explicitMaskMove   x86RawExplicitMaskMoveIdentity
+	packedShift        x86RawPackedShiftIdentity
+	packedAbs          x86RawPackedAbsIdentity
+	packedDot          x86RawPackedDotIdentity
+	permute128         x86RawPermute128Identity
+	zeroExtend         x86RawZeroExtendIdentity
+	scalarSegmentLoad  x86RawScalarSegmentLoadIdentity
+}
+
+type x86SourceStackAddress struct {
+	// original distinguishes the caller's opaque BP from an entry-SP offset.
+	original bool
+	offset   int64
+}
+
+type x86SourceStackCell struct {
+	offset              int64
+	width               int64
+	bp                  *x86SourceStackAddress
+	flags               bool
+	numericFlags        bool
+	partialNumericFlags uint8
+	caller              *x86CallerPointerValue
+	known               uint8
+	canonical           uint8
+	scalarFlags         uint8
+	gOriginal           bool
+}
+
+type x86SourceStackState struct {
+	sp                  int64
+	bp                  x86SourceStackAddress
+	cells               []x86SourceStackCell
+	numericFlags        bool
+	partialNumericFlags uint8
+	callers             map[Reg]x86CallerPointerValue
+	known               map[Reg]uint8
+	vectors             map[Reg]uint64
+	masks               map[Reg]bool
+	gOriginal           bool
+	scalarResult        *x86SourceStackScalarState
+}
+
+const x86SourceStackLimit = int64(1 << 20)
+
+// Recompute the proof on every final normalization. No caller-supplied signature,
+// changed source, or prepartition result inherits a cached admission flag.
+func normalizeX86RawReturnSourceStack(fn Func, opt Options, bindFrame bool, original ...Func) Func {
+	input := fn
+	if len(original) != 0 {
+		input = original[0]
+	}
+	fn.x86SourceStack = nil
+	fn.x86SourceStackFailure = ""
+	reject := func(index int, reason string) Func {
+		fn.x86SourceStackFailure = fmt.Sprintf("normalized instruction %d: %s", index, reason)
+		return fn
+	}
+	if fn.FrameSize != 0 || strings.Contains(fn.Sym, "<ABIInternal>") {
+		return fn
+	}
+	hasRawReturn := false
+	for _, ins := range fn.Instrs {
+		if form := ins.x86RawNearReturn; form != nil {
+			if !form.nativeWidth || form.cleanup != 0 {
+				return fn
+			}
+			hasRawReturn = true
+		}
+	}
+	if !hasRawReturn {
+		return fn
+	}
+	word, nativeMove, nativeSuffix := int64(8), Op("MOVQ"), "Q"
+	if opt.Goarch == "386" {
+		word, nativeMove, nativeSuffix = 4, "MOVL", "L"
+	}
+	name := fn.Sym
+	if opt.ResolveSym != nil {
+		name = opt.ResolveSym(name)
+	}
+	sig, hasSig := opt.Sigs[name]
+	physicalBool := bindFrame && hasSig && x86SourceStackBoolCandidate(fn, sig)
+	if physicalBool {
+		// This argument is a request-local Options value. Match the public
+		// ArchAMD64 default for the complete grammar; do not rewrite the
+		// caller's bound Options or the raw decoder's original mode spelling.
+		opt.Goarch = x86SourceStackScalarArch(opt.Goarch)
+	}
+	caller := bindFrame && hasSig && x86CallerRegionSourceMatches(sig, input, opt.Goarch)
+	if !caller {
+		for index, instruction := range fn.Instrs {
+			if _, known, _ := x86ExplicitIMULProperties(instruction.Op, instruction, opt.Goarch); known {
+				return reject(index, "explicit multiply needs a complete typed caller input proof")
+			}
+			if _, known, _ := x86ConditionalMoveProperties(instruction.Op, instruction, opt.Goarch); known {
+				return reject(index, "conditional move needs a complete typed caller input and flags proof")
+			}
+			if _, conditionalSet, _ := x86ConditionalSetProperties(instruction.Op, instruction, opt.Goarch); conditionalSet {
+				return reject(index, "conditional byte output needs a complete typed caller input proof")
+			}
+			if _, extension := amd64ScalarExtensionMoveSpecs[instruction.Op]; extension || instruction.x86RawMOVSXDNeedsCaller {
+				if x86RawDwordLiteralInput(instruction) {
+					continue
+				}
+				// The old scalar slot contract proves frame bounds, not GP
+				// input availability. It cannot authorize a new extension read
+				// of unknown or partially initialized native entry registers.
+				return reject(index, "scalar extension needs a complete typed caller input proof")
+			}
+		}
+	}
+	if !caller && !physicalBool && x86RawReturnLeafStackUnobserved(fn) {
+		return fn
+	}
+	if bindFrame && hasSig && !caller {
+		opt.Goarch = x86SourceStackScalarArch(opt.Goarch)
+	}
+	if bindFrame && (!hasSig || !caller && !x86SourceStackScalarABI0(sig, fn.ArgSize, opt.Goarch)) {
+		return fn
+	}
+
+	// Validate the complete source, including dead instructions. A dead CALL
+	// still changes Go's source prologue; unknown stack effects stay Context.
+	labels := map[string]int{}
+	var instructions []int
+	goDeltas := map[int]int64{}
+	var goDelta int64
+	hasText := false
+	for index, ins := range fn.Instrs {
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		if op == OpTEXT {
+			if hasText || !x86RawReturnLeafStackUnobserved(Func{Instrs: []Instr{ins}}) {
+				return fn
+			}
+			hasText = true
+		}
+		if op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+				return fn
+			}
+			if _, duplicate := labels[ins.Args[0].Sym]; duplicate {
+				return fn
+			}
+			labels[ins.Args[0].Sym] = len(instructions)
+			continue
+		}
+		vectorMove := caller && x86CallerVectorMoveKnown(ins)
+		if !x86SourceStackInstructionKnown(ins, nativeMove, nativeSuffix, opt.Goarch) && !vectorMove {
+			return reject(index, "unregistered source-stack effect: "+string(ins.Op))
+		}
+		if x86LEAWidth(ins.Op, opt.Goarch) != 0 && ins.Op != Op("LEA"+nativeSuffix) && !caller {
+			// The older scalar stack proof establishes a continuation, not
+			// numerical GP initialization. Only the actual caller's complete
+			// must-defined transfer can authorize these additional widths.
+			return reject(index, "non-native-width LEA requires actual numerical caller source")
+		}
+		if opt.Goarch == "amd64" && !caller && x86SourceGOperand(ins) {
+			if _, stack := amd64StackWidthSpecs[op]; !stack {
+				return reject(index, "g numerical/address use requires actual caller source")
+			}
+		}
+		if caller && !vectorMove && !x86CallerScalarOperands(ins) {
+			return reject(index, "unregistered caller-region operand bank: "+string(ins.Op))
+		}
+		if _, stack := amd64StackWidthSpecs[op]; stack && ins.x86SourceRaw != nil &&
+			(ins.x86SourceRaw.op != op || !reflect.DeepEqual(ins.x86SourceRaw.args, ins.Args)) {
+			return fn
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFPAddr || (operand.Kind == OpFP && operand.FPOffset < 0) {
+				return fn
+			}
+			if operand.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+				// Address-of is not an ordinary numeric immediate, regardless of
+				// the register spelling or whether its later value is overwritten.
+				return fn
+			}
+		}
+		instructions = append(instructions, index)
+		goDeltas[index] = goDelta
+		// cmd/internal/obj/x86 preprocess adjusts named FP operands using
+		// its linear deltasp. BYTE/WORD pushes are opaque to that pass.
+		if spec, stack := amd64StackWidthSpecs[op]; stack && ins.x86SourceRaw == nil {
+			width := int64(spec.bits / 8)
+			if spec.mode == amd64StackPushValue || spec.mode == amd64StackPushFlags {
+				goDelta += width
+			} else {
+				goDelta -= width
+			}
+			if goDelta < -x86SourceStackLimit || goDelta > x86SourceStackLimit {
+				return fn
+			}
+		}
+	}
+	if !hasText || len(instructions) == 0 {
+		return fn
+	}
+
+	copyFn := fn
+	copyFn.Instrs = append([]Instr(nil), fn.Instrs...)
+	for index := range copyFn.Instrs {
+		copyFn.Instrs[index].Args = append([]Operand(nil), fn.Instrs[index].Args...)
+		copyFn.Instrs[index].x86SourceStackFP = nil
+		copyFn.Instrs[index].x86CallerMemory = nil
+	}
+	states := map[int]x86SourceStackState{}
+	work := []int{0}
+	states[0] = x86SourceStackState{bp: x86SourceStackAddress{original: true}, gOriginal: true}
+	proof := &x86SourceStackProof{word: word}
+	if bindFrame && hasSig && (!caller || sig.Ret == I1) {
+		states[0] = x86SourceStackState{bp: x86SourceStackAddress{original: true}, gOriginal: true,
+			scalarResult: x86SourceStackScalarInitial(fn, sig, opt.Goarch)}
+		if states[0].scalarResult == nil || caller {
+			return reject(0, "physical scalar result requires its independent scalar declaration")
+		}
+	}
+	if caller {
+		proof.caller = sig.x86CallerRegions
+		states[0] = x86SourceStackState{
+			bp:        x86SourceStackAddress{original: true},
+			callers:   make(map[Reg]x86CallerPointerValue),
+			known:     make(map[Reg]uint8),
+			vectors:   make(map[Reg]uint64),
+			masks:     make(map[Reg]bool),
+			gOriginal: true,
+		}
+	}
+	transfer := func(pc int, ins *Instr, state *x86SourceStackState) (bool, string) {
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		if op == OpRET {
+			if word == 8 && !state.gOriginal {
+				return false, "unrestored original g identity at source return"
+			}
+			if len(ins.Args) != 0 || state.sp != 0 || !state.bp.original || goDeltas[instructions[pc]] != 0 {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+			if value := state.scalarResult; value != nil && !value.complete() {
+				return false, "physical scalar result lacks initialized/canonical bytes on every return"
+			}
+			return true, ""
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFP && state.sp+goDeltas[instructions[pc]] != 0 {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+		}
+
+		if spec, stack := amd64StackWidthSpecs[op]; stack {
+			if !x86SourceStackStep(spec, ins, state, word) {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+		} else if !x86SourceStackAddressStep(ins, state, nativeMove, nativeSuffix, word) {
+			return false, "unproved source-stack or ABI0 continuation effect"
+		}
+		if state.sp < -x86SourceStackLimit || state.sp > 0 {
+			return false, "unproved source-stack or ABI0 continuation effect"
+		}
+		if state.sp < proof.minimum {
+			proof.minimum = state.sp
+		}
+		for operandIndex, operand := range ins.Args {
+			if operand.Kind != OpMem || !x86RawReturnStackMemory(operand.Mem) {
+				continue
+			}
+			if x86LEAWidth(ins.Op, opt.Goarch) != 0 {
+				continue // The address step proved its destination and range.
+			}
+			width := x86ScalarMoveMemoryBytes(*ins, operandIndex, opt.Goarch)
+			memory := operand.Mem
+			if width == 0 || memory.Sym != "" || memory.Index != "" || memory.Segment != "" ||
+				ins.x86AddressBits != 0 {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+			base := state.sp
+			if memory.Base == BP {
+				if state.bp.original {
+					return false, "unproved source-stack or ABI0 continuation effect"
+				}
+				base = state.bp.offset
+			} else if memory.Base != SP {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+			// Source entry SP[0:word] is the return PC. Only declaration-backed
+			// data at entry SP+word can be mapped to FP shadow storage.
+			if memory.Off < -x86SourceStackLimit || memory.Off > x86SourceStackLimit {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+			offset := base + memory.Off - word
+			if offset < 0 || offset > fn.ArgSize || width > fn.ArgSize-offset {
+				return false, "unproved source-stack or ABI0 continuation effect"
+			}
+			if bindFrame {
+				if !x86RawReturnFPBound(offset, width, sig, opt.Goarch) {
+					return false, "unproved source-stack or ABI0 continuation effect"
+				}
+				if ins.x86SourceStackFP == nil {
+					ins.x86SourceStackFP = map[int]int64{}
+				}
+				ins.x86SourceStackFP[operandIndex] = offset
+			}
+		}
+		pointerFlags := false
+		if caller {
+			var valid bool
+			if x86CallerVectorMoveKnown(*ins) {
+				valid = x86CallerVectorMoveStep(ins, state, sig.x86CallerRegions)
+			} else {
+				pointerFlags, valid = x86CallerScalarStep(ins, state, sig.x86CallerRegions)
+			}
+			if !valid {
+				return false, "unproved caller-region effect: " + string(ins.Op)
+			}
+			x86CallerGDefinition(*ins, state)
+		}
+		if !x86SourceStackFlagsStepForArch(*ins, state, opt.Goarch) {
+			return false, "unproved source-stack or ABI0 continuation effect"
+		}
+		if pointerFlags {
+			x86SourceStackSetNumericFlags(state, 0)
+		}
+		if state.scalarResult != nil && !state.scalarResult.step(*ins, opt.Goarch) {
+			return false, "physical scalar result has an undefined numerical input or effect"
+		}
+
+		return false, ""
+	}
+	returned := false
+	acyclic := (caller || states[0].scalarResult != nil) && x86CallerReachableAcyclic(copyFn, instructions, labels)
+	if caller && !acyclic {
+		if plan := deriveX86CallerCountedPlan(input, copyFn, instructions, labels); plan != nil {
+			first, reason := replayX86CallerCountedPlan(plan, &copyFn, instructions, states[0], proof.caller, transfer)
+			if reason != "" {
+				return reject(0, reason)
+			}
+			minimum := proof.minimum
+			proof.minimum = 0
+			for index := range copyFn.Instrs {
+				copyFn.Instrs[index].x86CallerMemory = nil
+				copyFn.Instrs[index].x86SourceStackFP = nil
+			}
+			finalPlan := deriveX86CallerCountedPlan(input, copyFn, instructions, labels)
+			if !reflect.DeepEqual(plan, finalPlan) {
+				return reject(0, "counted-loop plan changed during independent replay")
+			}
+			second, reason := replayX86CallerCountedPlan(finalPlan, &copyFn, instructions, states[0], proof.caller, transfer)
+			if reason != "" || minimum != proof.minimum || !reflect.DeepEqual(first, second) {
+				return reject(0, "counted-loop final access/state replay changed: "+reason)
+			}
+			for _, visit := range second {
+				if _, header := finalPlan.headers[visit.pc]; header {
+					proof.countedIterations[visit.residue]++
+				}
+			}
+			var err error
+			proof.normalized, err = x86CallerSourceFingerprint(copyFn)
+			if err != nil {
+				return fn
+			}
+			copyFn.x86SourceStack = proof
+			return copyFn
+		}
+	}
+	final := false
+	scalarByteWork := 0
+	for budget := 0; ; budget++ {
+		if len(work) == 0 {
+			if !acyclic || final {
+				break
+			}
+			// Discard every provisional certificate. Independently replay all
+			// final reachable inputs, once, after the finite merge fixed point.
+			final = true
+			budget = 0
+			for pc, index := range instructions {
+				copyFn.Instrs[index].x86CallerMemory = nil
+				copyFn.Instrs[index].x86SourceStackFP = nil
+				if _, reachable := states[pc]; reachable {
+					work = append(work, pc)
+				}
+			}
+		}
+		if budget >= 8192 {
+			return fn
+		}
+		pc := work[0]
+		work = work[1:]
+		state := states[pc]
+		if value := state.scalarResult; value != nil {
+			scalarByteWork += 8 * (2*len(value.bytes.fp) + 33 + 2*len(state.cells))
+			if scalarByteWork > 64<<20 {
+				return reject(instructions[pc], "physical scalar source-CFG byte budget exhausted")
+			}
+		}
+		if caller {
+			state = x86CloneCallerState(state)
+		} else {
+			state.cells = append([]x86SourceStackCell(nil), state.cells...)
+			state.scalarResult = state.scalarResult.clone()
+		}
+		ins := &copyFn.Instrs[instructions[pc]]
+		ins.x86CallerMemory = nil
+		ins.x86SourceStackFP = nil
+		op := Op(normalizeInstructionOpcode(ins.Op))
+		isReturn, reason := transfer(pc, ins, &state)
+		if reason != "" {
+			return reject(instructions[pc], reason)
+		}
+		if isReturn {
+			returned = true
+			continue
+		}
+		successors := []int{pc + 1}
+		if op == OpJMP || isAMD64ConditionalBranch(op) {
+			if len(ins.Args) != 1 {
+				return fn
+			}
+			operand := ins.Args[0]
+			label := operand.Sym
+			if operand.Kind == OpIdent {
+				label = operand.Ident
+			}
+			target, known := labels[label]
+			if operand.Kind == OpMem && operand.Mem.Base == PC && operand.Mem.Index == "" &&
+				operand.Mem.Sym == "" && operand.Mem.Off >= -int64(len(instructions)) && operand.Mem.Off <= int64(len(instructions)) {
+				target, known = pc+int(operand.Mem.Off), true
+			} else if operand.Kind != OpLabel && operand.Kind != OpIdent {
+				return fn
+			}
+			if !known {
+				return fn
+			}
+			if op == OpJMP {
+				successors = []int{target}
+			} else {
+				successors = append(successors, target)
+			}
+		}
+		for _, next := range successors {
+			if next < 0 || next >= len(instructions) {
+				return fn // Fallthrough cannot invent a source continuation.
+			}
+			if old, visited := states[next]; visited {
+				if !reflect.DeepEqual(old, state) {
+					if !acyclic {
+						return reject(instructions[next], "different source-stack or caller-region states at join")
+					}
+					var merged x86SourceStackState
+					var valid bool
+					if caller {
+						merged, valid = x86CallerAcyclicMerge(old, state, sig.x86CallerRegions)
+					} else {
+						merged, valid = x86SourceStackScalarMerge(old, state)
+					}
+					if !valid {
+						return reject(instructions[next], "different source-stack or caller-region states at join")
+					}
+					if reflect.DeepEqual(old, merged) {
+						continue
+					}
+					if final {
+						return reject(instructions[next], "caller-region changed during final certificate replay")
+					}
+					states[next] = merged
+					work = append(work, next)
+				}
+				continue
+			}
+			if final {
+				return reject(instructions[next], "new caller-region state during final certificate replay")
+			}
+			states[next] = state
+			work = append(work, next)
+		}
+	}
+	if !returned {
+		return fn
+	}
+	if states[0].scalarResult != nil {
+		proof.scalarResult = sealX86SourceStackScalar(copyFn, input, sig, proof)
+		if proof.scalarResult == nil {
+			return reject(0, "physical scalar result source seal failed")
+		}
+	}
+	if caller {
+		var err error
+		proof.normalized, err = x86CallerSourceFingerprint(copyFn)
+		if err != nil {
+			return fn
+		}
+	}
+	copyFn.x86SourceStack = proof
+	return copyFn
+}
+
+func x86SourceStackScalarABI0(sig FuncSig, argSize int64, arch string) bool {
+	if len(sig.ArgRegs) != 0 || argSize <= 0 || argSize > x86SourceStackLimit || len(sig.Frame.Results) != 1 ||
+		len(sig.Frame.Params) != len(sig.Args) || len(sig.Args) == 0 {
+		return false
+	}
+	seen := map[int]bool{}
+	for _, slot := range sig.Frame.Params {
+		width := x86FrameScalarBytes(slot.Type, arch)
+		if !x86SourceStackScalarType(slot.Type) || len(frameSlotFields(slot)) != 0 ||
+			slot.Index < 0 || slot.Index >= len(sig.Args) || slot.Type != sig.Args[slot.Index] ||
+			width == 0 || !x86RawReturnFPBound(slot.Offset, width, sig, arch) ||
+			slot.Offset > argSize || width > argSize-slot.Offset || seen[slot.Index] {
+			return false
+		}
+		seen[slot.Index] = true
+	}
+	slot := sig.Frame.Results[0]
+	width := x86FrameScalarBytes(slot.Type, arch)
+	return x86SourceStackScalarType(slot.Type) && slot.Type == sig.Ret && width != 0 &&
+		x86RawReturnFPBound(slot.Offset, width, sig, arch) && slot.Offset <= argSize && width <= argSize-slot.Offset
+}
+
+func x86SourceStackScalarType(typ LLVMType) bool {
+	switch typ {
+	case I1, I8, I16, I32, I64:
+		return true
+	default:
+		return false
+	}
+}
+
+func x86SourceStackInstructionKnown(ins Instr, nativeMove Op, suffix, arch string) bool {
+	if _, known, err := x86CounterControlProperties(ins.Op, ins, arch); known {
+		return err == nil // Original raw/address metadata cannot borrow named count semantics.
+	}
+	if _, known, err := x86ExplicitIMULProperties(ins.Op, ins, arch); known {
+		return err == nil
+	}
+	if _, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch); known {
+		return err == nil
+	}
+	if _, known, err := x86OrderingHintProperties(ins.Op, ins, arch); known {
+		return err == nil
+	}
+	op := Op(normalizeInstructionOpcode(x86SourceMoveInstruction(ins, arch).Op))
+	if _, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); recognized {
+		return err == nil
+	}
+	if op == OpTEXT || op == OpRET || op == OpJMP || isAMD64ConditionalBranch(op) {
+		return true
+	}
+	if spec, stack := amd64StackWidthSpecs[op]; stack {
+		return string(ins.Op) == string(op) && (spec.bits == 16 || (spec.bits == 32 && arch == "386") || (spec.bits == 64 && arch == "amd64"))
+	}
+	if op == nativeMove || x86LEAWidth(ins.Op, arch) != 0 || x86RawReturnScalarMoveBytes(op) != 0 {
+		return true
+	}
+	if _, recognized, err := x86ScalarExtensionProperties(op, ins, arch); recognized {
+		return err == nil
+	}
+	// This bounded numerical contract does not infer effects for opaque raw,
+	// native/system calls, aggregate/vector memory, or instructions with hidden
+	// stack inputs. These remain Context, not unsupported decoder forms.
+	for _, base := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST", "INC", "DEC", "NEG", "NOT", "SHL", "SHR", "SAR"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			if op == Op(base+width) && (width != "Q" || arch == "amd64") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func x86SourceStackStep(spec amd64StackWidthSpec, ins *Instr, state *x86SourceStackState, word int64) bool {
+	width := int64(spec.bits / 8)
+	push := spec.mode == amd64StackPushValue || spec.mode == amd64StackPushFlags
+	flags := spec.mode == amd64StackPushFlags || spec.mode == amd64StackPopFlags
+	if flags && len(ins.Args) != 0 || !flags && len(ins.Args) != 1 {
+		return false
+	}
+	cell := x86SourceStackCell{width: width, flags: flags, numericFlags: state.numericFlags, partialNumericFlags: state.partialNumericFlags}
+	if state.scalarResult != nil && flags {
+		cell.scalarFlags = state.scalarResult.bytes.flags
+	}
+	if !flags {
+		operand := ins.Args[0]
+		if operand.Kind != OpReg && (!push || operand.Kind != OpImm) {
+			return false // Memory/segment stack transfers need a separate contract.
+		}
+		if operand.Kind == OpReg {
+			if x86SegmentRegisterOperand(operand) || operand.Reg == SP {
+				return false
+			}
+			if x86RawReturnStackRegister(operand.Reg) {
+				if operand.Reg != BP || width != word {
+					return false
+				}
+				value := state.bp
+				cell.bp = &value
+			}
+			if x86SourceGRegister(operand.Reg) && state.gOriginal && push {
+				if word != 8 || width != word || operand.Reg != "R14" {
+					return false // A partial token cannot preserve the opaque g identity.
+				}
+				cell.gOriginal = true
+			}
+			if state.callers != nil && operand.Reg != BP {
+				root, valid := x86CallerGP(operand.Reg)
+				if !valid {
+					return false
+				}
+				if pointer, present := state.callers[root]; present {
+					if width != word || operand.Reg != root {
+						return false
+					}
+					value := pointer
+					cell.caller = &value
+				}
+				cell.known = state.known[root]
+			}
+			if state.scalarResult != nil && operand.Reg != BP {
+				arch := "amd64"
+				if word == 4 {
+					arch = "386"
+				}
+				index, mask, valid := x86ResultGP(operand.Reg, width, arch)
+				if !valid {
+					return false
+				}
+				cell.known = state.scalarResult.bytes.gp[index] & mask
+				cell.canonical = state.scalarResult.bytes.canonicalGP[index] & mask
+			}
+		}
+		if state.scalarResult != nil && operand.Kind == OpImm {
+			if operand.ImmRaw != "" || operand.ImmIsFloat {
+				return false
+			}
+			cell.known = uint8((uint16(1) << uint(width)) - 1)
+			cell.canonical = fixedLocalConstantBooleans(operand.Imm, width)
+		}
+	}
+	if push {
+		state.sp -= width
+		cell.offset = state.sp
+		// A new store replaces the covered old cell, never reuses stale data.
+		for len(state.cells) != 0 && state.cells[len(state.cells)-1].offset <= state.sp {
+			state.cells = state.cells[:len(state.cells)-1]
+		}
+		state.cells = append(state.cells, cell)
+		return true
+	}
+	if len(state.cells) == 0 {
+		return false
+	}
+	// Restoring a saved SP may discard lower private cells. The next POP must
+	// still read a complete initialized source PUSH of the same physical width.
+	for len(state.cells) != 0 && state.cells[len(state.cells)-1].offset < state.sp {
+		state.cells = state.cells[:len(state.cells)-1]
+	}
+	if len(state.cells) == 0 {
+		return false
+	}
+	saved := state.cells[len(state.cells)-1]
+	if saved.offset != state.sp || saved.width != width {
+		return false
+	}
+	if flags != saved.flags {
+		return false // Scalar bytes and complete hardware FLAGS are not interchangeable.
+	}
+	if flags {
+		state.numericFlags = saved.numericFlags
+		state.partialNumericFlags = saved.partialNumericFlags
+		if state.scalarResult != nil {
+			state.scalarResult.bytes.flags = saved.scalarFlags
+		}
+	}
+	if state.scalarResult != nil && !flags && ins.Args[0].Reg != BP {
+		arch := "amd64"
+		if word == 4 {
+			arch = "386"
+		}
+		index, mask, valid := x86ResultGP(ins.Args[0].Reg, width, arch)
+		if !valid {
+			return false
+		}
+		value := &state.scalarResult.bytes
+		value.gp[index] = value.gp[index]&^mask | saved.known&mask
+		value.canonicalGP[index] = value.canonicalGP[index]&^mask | saved.canonical&mask
+		if width == 4 && word == 8 {
+			value.gp[index] |= 240
+			value.canonicalGP[index] |= 240
+		}
+	}
+	if saved.bp != nil {
+		if flags || ins.Args[0].Reg != BP {
+			return false // A saved frame pointer cannot become numeric output.
+		}
+		state.bp = *saved.bp
+	} else if !flags && ins.Args[0].Reg == BP {
+		return false
+	}
+	if saved.gOriginal {
+		if flags || word != 8 || width != word || ins.Args[0].Reg != "R14" {
+			return false // The saved opaque g never becomes an ordinary GP value.
+		}
+		state.gOriginal = true
+		delete(state.callers, "R14")
+		delete(state.known, "R14")
+	} else if !flags && x86SourceGRegister(ins.Args[0].Reg) {
+		state.gOriginal = false
+	}
+	if state.callers != nil && !flags && ins.Args[0].Reg != BP {
+		root, valid := x86CallerGP(ins.Args[0].Reg)
+		if !valid {
+			return false
+		}
+		if _, pointer := state.callers[root]; pointer && width != word {
+			return false
+		}
+		delete(state.callers, root)
+		if saved.caller != nil {
+			if width != word || ins.Args[0].Reg != root {
+				return false
+			}
+			state.callers[root] = *saved.caller
+		}
+		if saved.gOriginal {
+			delete(state.known, root)
+		} else if width == word {
+			state.known[root] = saved.known
+		} else {
+			mask := x86CallerByteMask(ins.Args[0].Reg, width)
+			state.known[root] = state.known[root]&^mask | saved.known&mask
+		}
+	}
+	state.cells = state.cells[:len(state.cells)-1]
+	state.sp += width
+	return true
+}
+
+// Source SP arithmetic operates on a Go stack address, not our LLVM private
+// allocation's address. Its flags cannot be assumed equivalent. This bounded
+// proof permits numerical redefinitions and matching FLAGS save/restore, but
+// never exposes incomplete FLAGS as scalar data or invents incoming flags.
+func x86SourceStackFlagsStep(ins Instr, state *x86SourceStackState) bool {
+	return x86SourceStackFlagsStepForArch(ins, state, "amd64")
+}
+
+func x86SourceStackFlagsStepForArch(ins Instr, state *x86SourceStackState, arch string) bool {
+	if form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch); known {
+		return err == nil && x86SourceStackNumericFlagsRead(state, x86ByteConditionFlags(form.condition))
+	}
+	op := Op(normalizeInstructionOpcode(ins.Op))
+	if condition, conditionalSet := x86ConditionalSetConditions[op]; conditionalSet {
+		return x86SourceStackNumericFlagsRead(state, x86ByteConditionFlags(condition)) // SETcc preserves flags.
+	}
+	if effect, known, err := x86TypedCounterControlByteEffect(ins.Op, ins, arch); known {
+		if err != nil || state.callers == nil && state.scalarResult == nil {
+			return false // A physical stack identity alone proves no numerical counter.
+		}
+		// The existing caller or scalar-result transfer owns every NUM read/write.
+		// Zero FLAGS reads require no producer; no status bit is defined here.
+		return x86SourceStackNumericFlagMask(state)&effect.flagsRead == effect.flagsRead
+	}
+	if isAMD64ConditionalBranch(op) {
+		return isAMD64CounterZeroBranch(op) || x86SourceStackNumericFlagsRead(state, x86ByteBranchFlags(op))
+	}
+	if state.callers != nil {
+		if effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch); known {
+			mask := x86SourceStackNumericFlagMask(state)
+			if err != nil || mask&effect.flagsRead != effect.flagsRead {
+				return false
+			}
+			for _, operand := range ins.Args {
+				if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+					x86SourceStackSetNumericFlags(state, 0)
+					return true // Source address arithmetic never defines numerical flags.
+				}
+			}
+			x86SourceStackSetNumericFlags(state, mask&^effect.flagsKilled|effect.flagsDefined)
+			return true
+		}
+	}
+	name := string(op)
+	if len(name) < 2 {
+		return true
+	}
+	base := name[:len(name)-1]
+	switch base {
+	case "ADC", "SBB":
+		return state.numericFlags
+	case "ADD", "SUB", "AND", "OR", "XOR", "CMP", "TEST", "NEG":
+		x86SourceStackSetNumericFlags(state, x86ByteFlagsAll)
+		for _, operand := range ins.Args {
+			if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+				x86SourceStackSetNumericFlags(state, 0)
+			}
+		}
+	case "SHL", "SHR", "SAR":
+		// Masked zero counts preserve prior flags; OF is undefined for larger
+		// counts. They need a per-bit contract before serving as a new witness.
+		x86SourceStackSetNumericFlags(state, 0)
+	}
+	return true
+}
+
+func x86SourceStackAddressStep(ins *Instr, state *x86SourceStackState, nativeMove Op, suffix string, word int64) bool {
+	arch := "amd64"
+	if word == 4 {
+		arch = "386"
+	}
+	op := Op(normalizeInstructionOpcode(x86SourceMoveInstruction(*ins, arch).Op))
+	lea := x86LEAWidth(ins.Op, arch) != 0
+	if lea {
+		if _, err := x86LEAOperandWidth(*ins, arch); err != nil {
+			return false
+		}
+	}
+	if form, recognized, err := x86ScalarExtensionProperties(op, *ins, arch); recognized {
+		if err != nil || x86RawReturnStackRegister(form.result) ||
+			form.source.Kind == OpReg && x86RawReturnStackRegister(form.source.Reg) {
+			return false
+		}
+	}
+	if len(ins.Args) == 2 && op == nativeMove && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg &&
+		x86RawReturnStackRegister(ins.Args[0].Reg) && x86RawReturnStackRegister(ins.Args[1].Reg) {
+		source, destination := ins.Args[0].Reg, ins.Args[1].Reg
+		if source != SP && source != BP || destination != SP && destination != BP {
+			return false
+		}
+		value := state.bp
+		if source == SP {
+			value = x86SourceStackAddress{offset: state.sp}
+		}
+		if destination == BP {
+			state.bp = value
+			return true
+		}
+		if value.original {
+			return false
+		}
+		state.sp = value.offset
+		return true
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg && ins.Args[1].Reg == SP {
+		if ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+			value := int64(ins.Args[0].Imm)
+			if word == 4 {
+				value = int64(int32(value)) // Raw 386 immediates retain unsigned bits.
+			}
+			if value < -x86SourceStackLimit || value > x86SourceStackLimit {
+				return false
+			}
+			switch op {
+			case Op("ADD" + suffix):
+				state.sp += value
+				return true
+			case Op("SUB" + suffix):
+				state.sp -= value
+				return true
+			case Op("AND" + suffix):
+				alignment := -value
+				if alignment < 1 || alignment > word || alignment&(alignment-1) != 0 {
+					return false // The Go entry contract proves native-word alignment only.
+				}
+				state.sp &= value
+				return true
+			}
+		}
+		if op == Op("LEA"+suffix) && ins.Args[0].Kind == OpMem {
+			memory := ins.Args[0].Mem
+			if memory.Index != "" || memory.Sym != "" || memory.Segment != "" ||
+				memory.Off < -x86SourceStackLimit || memory.Off > x86SourceStackLimit || ins.x86AddressBits != 0 {
+				return false
+			}
+			base := state.sp
+			if memory.Base == BP && !state.bp.original {
+				base = state.bp.offset
+			} else if memory.Base != SP {
+				return false
+			}
+			state.sp = base + memory.Off
+			return true
+		}
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+			return false // No implicit narrowing, arithmetic, or address escape.
+		}
+		if lea && operand.Kind == OpMem && x86RawReturnStackMemory(operand.Mem) {
+			return false // An owned stack address may not escape into an ordinary GP.
+		}
+	}
+	return true
+}
+
+// Source pushes and pops must use the same byte-addressable SP as MOV/LEA/
+// alignment. The legacy amd64 virtual value stack is intentionally unchanged
+// for sources without this complete source-stack proof.
+func (c *amd64Ctx) pushSourceStackValue(typ LLVMType, width int64, value string) error {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return err
+	}
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %d\n", next, sp, width)
+	if err := c.storeRegUnchecked(SP, "%"+next); err != nil {
+		return err
+	}
+	ptr := c.ptrFromAddrI64("%" + next)
+	fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1\n", typ, value, ptr)
+	return nil
+}
+
+func (c *amd64Ctx) popSourceStackValue(typ LLVMType, width int64) (string, error) {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return "", err
+	}
+	ptr := c.ptrFromAddrI64(sp)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", value, typ, ptr)
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", next, sp, width)
+	if err := c.storeRegUnchecked(SP, "%"+next); err != nil {
+		return "", err
+	}
+	return "%" + value, nil
+}
diff --git a/amd64_raw_return_source_stack_runtime_test.go b/amd64_raw_return_source_stack_runtime_test.go
new file mode 100644
index 000000000..6a17adf5a
--- /dev/null
+++ b/amd64_raw_return_source_stack_runtime_test.go
@@ -0,0 +1,287 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type x86SourceStackRuntimeCase struct {
+	name  string
+	width int
+	body  string
+	flags bool
+}
+
+func x86SourceStackRuntimeCases(arch string) []x86SourceStackRuntimeCase {
+	word, suffix, rawMove := 8, "Q", "WORD $0x8948\nBYTE $0xe5"
+	rawRestore := "WORD $0x8948\nBYTE $0xec"
+	rawAlign := "LONG $0xf8e48348"
+	if arch == "386" {
+		word, suffix, rawMove = 4, "L", "WORD $0xe589"
+		rawRestore, rawAlign = "WORD $0xec89", "WORD $0xe483\nBYTE $0xfc"
+	}
+	var cases []x86SourceStackRuntimeCase
+	for _, width := range []int{8, 16, 32, 64} {
+		if arch == "386" && width == 64 {
+			continue
+		}
+		move := map[int]string{8: "MOVB", 16: "MOVW", 32: "MOVL", 64: "MOVQ"}[width]
+		cases = append(cases, x86SourceStackRuntimeCase{
+			name: fmt.Sprintf("Physical%d", width), width: width,
+			body: fmt.Sprintf("%s %d(SP),AX\nADD%s $7,AX\n%s AX,%d(SP)\nBYTE $0xc3", move, word, suffix, move, 2*word),
+		})
+	}
+	finish := fmt.Sprintf("ADD%s $7,AX\nMOV%s AX,ret+%d(FP)\nBYTE $0xc3", suffix, suffix, word)
+	start := "MOV" + suffix + " x+0(FP),AX\n"
+	cases = append(cases,
+		x86SourceStackRuntimeCase{name: "BalancedRaw", width: word * 8,
+			body: start + "BYTE $0x55\n" + rawMove + "\n" + rawAlign + "\n" + rawRestore + "\nBYTE $0x5d\n" + finish},
+		x86SourceStackRuntimeCase{name: "BalancedNamed", width: word * 8,
+			body: start + "PUSH" + suffix + " BP\nMOV" + suffix + " SP,BP\nPUSH" + suffix + " AX\nMOV" + suffix + " $0,AX\nPOP" + suffix + " AX\nMOV" + suffix + " BP,SP\nPOP" + suffix + " BP\n" + finish},
+		x86SourceStackRuntimeCase{name: "WordData", width: word * 8,
+			body: start + "PUSHW AX\nMOVW $0,AX\nPOPW AX\n" + finish},
+		x86SourceStackRuntimeCase{name: "WordImmediate", width: word * 8,
+			body: start + "PUSHW $65530\nPOPW AX\n" + finish},
+		x86SourceStackRuntimeCase{name: "Branch", width: word * 8,
+			body: start + "CMP" + suffix + " AX,$1\nJE done\nADD" + suffix + " $0,BX\ndone:\n" + finish},
+		x86SourceStackRuntimeCase{name: "FlagsStack", width: word * 8, flags: true,
+			body: start + "CMP" + suffix + " AX,$1\nPUSHF" + suffix + "\n" +
+				fmt.Sprintf("SUB%s $%d,SP\nADD%s $%d,SP\n", suffix, word, suffix, word) +
+				"POPF" + suffix + "\nADC" + suffix + " $0,AX\n" + finish},
+	)
+	for _, flagSuffix := range []string{"W", suffix} {
+		cases = append(cases, x86SourceStackRuntimeCase{
+			name: "Flags" + flagSuffix, width: word * 8, flags: true,
+			body: start + "CMP" + suffix + " AX,$1\nPUSHF" + flagSuffix + "\nADD" + suffix + " $0,BX\nPOPF" + flagSuffix + "\nADC" + suffix + " $0,AX\n" + finish,
+		})
+	}
+	return cases
+}
+
+func x86SourceStackRuntimeSource(arch string) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, test := range x86SourceStackRuntimeCases(arch) {
+		word, move := int64(8), "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		ty := map[int]LLVMType{8: I8, 16: I16, 32: I32, 64: I64}[test.width]
+		text, sig, _ := x86SourceStackTypedFixture(arch, fmt.Sprintf("uint%d", test.width), ty, word, move, test.body)
+		source.WriteString(strings.ReplaceAll(text, "·Value", "·"+test.name))
+		sig.Name = test.name
+		sigs[test.name] = sig
+	}
+	word := int64(8)
+	if arch == "386" {
+		word = 4
+	}
+	text, sig, _ := x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+		"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+	source.WriteString(strings.ReplaceAll(text, "·Value", "·PhysicalBool"))
+	sig.Name = "PhysicalBool"
+	sigs[sig.Name] = sig
+	// Preserve the original identity kernel above byte-for-byte. This sibling
+	// observes a physical result byte before its final logical bool conversion:
+	// prematurely truncating the intermediate 2 to i1 would return false.
+	text, sig, _ = x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+		"MOVB $2,@RESULT(SP)\nMOVB @RESULT(SP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+	source.WriteString(strings.ReplaceAll(text, "·Value", "·PhysicalBoolIntermediate"))
+	sig.Name = "PhysicalBoolIntermediate"
+	sigs[sig.Name] = sig
+	text, sig, _ = x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+		"MOVB $2,ret+@WORD(FP)\nMOVB ret+@WORD(FP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3")
+	source.WriteString(strings.ReplaceAll(text, "·Value", "·PhysicalBoolNamedFP"))
+	sig.Name = "PhysicalBoolNamedFP"
+	sigs[sig.Name] = sig
+	return source.String(), sigs
+}
+
+func x86SourceStackGoOracle(arch string) string {
+	var goSource strings.Builder
+	goSource.WriteString("package sourceframe\nimport \"testing\"\n")
+	for _, test := range x86SourceStackRuntimeCases(arch) {
+		fmt.Fprintf(&goSource, "func %s(x uint%d) uint%d\n", test.name, test.width, test.width)
+	}
+	goSource.WriteString("func PhysicalBool(x bool) bool\n")
+	goSource.WriteString("func PhysicalBoolIntermediate(x bool) bool\n")
+	goSource.WriteString("func PhysicalBoolNamedFP(x bool) bool\n")
+	goSource.WriteString("func TestNumerical(t *testing.T) {\n")
+	for _, test := range x86SourceStackRuntimeCases(arch) {
+		fmt.Fprintf(&goSource, `
+	for iteration := 0; iteration < 64; iteration++ {
+		for _, input := range []uint%d{0, 1, 17, 253, ^uint%d(0)-3} {
+			want := input + 7
+`, test.width, test.width)
+		if test.flags {
+			goSource.WriteString("\t\t\tif input == 0 { want++ }\n")
+		}
+		if test.name == "WordImmediate" {
+			fmt.Fprintf(&goSource, "\t\t\twant = ((input & ^uint%d(65535)) | 65530) + 7\n", test.width)
+		}
+		fmt.Fprintf(&goSource, `
+			canary := [4]uint64{11, 23, 37, 41}
+			if got := %s(input); got != want || canary != [4]uint64{11, 23, 37, 41} {
+				t.Fatalf("%s(%%#x)=%%#x, want %%#x; canary=%%v", input, got, want, canary)
+			}
+		}
+	}
+`, test.name, test.name)
+	}
+	goSource.WriteString("\tif PhysicalBool(false) || !PhysicalBool(true) { t.Fatal(\"bool byte slot\") }\n")
+	goSource.WriteString("\tcanary := [4]uint64{11,23,37,41}\n\tif !PhysicalBoolIntermediate(false) || !PhysicalBoolIntermediate(true) || !PhysicalBoolNamedFP(false) || !PhysicalBoolNamedFP(true) || canary != [4]uint64{11,23,37,41} { t.Fatal(\"physical/named intermediate bool byte/canary\") }\n}\n")
+	return goSource.String()
+}
+
+func x86SourceStackActualGoNumerical(t *testing.T, arch string, runner []string) {
+	t.Helper()
+	dir := t.TempDir()
+	source, _ := x86SourceStackRuntimeSource(arch)
+	for name, text := range map[string]string{
+		"go.mod":               "module example.invalid/sourceframeoracle\n\ngo 1.20\n",
+		"value_" + arch + ".s": source,
+		"value_test.go":        x86SourceStackGoOracle(arch),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"test", "-p=2", "-vet=off", "-count=1"}
+	if len(runner) != 0 {
+		args = append(args, "-exec", strings.Join(runner, " "))
+	}
+	args = append(args, ".")
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	env := append(os.Environ(), "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Dir, command.Env, command.WaitDelay = dir, env, 2*time.Second
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go %s original source numerical oracle: %v\n%s", arch, err, output)
+	}
+}
+
+func x86SourceStackCOracle(arch string) string {
+	var source strings.Builder
+	source.WriteString("#include <stdint.h>\n")
+	source.WriteString("#include <stdbool.h>\nextern bool PhysicalBool(bool);\nextern bool PhysicalBoolIntermediate(bool);\n")
+	source.WriteString("extern bool PhysicalBoolNamedFP(bool);\n")
+	for _, test := range x86SourceStackRuntimeCases(arch) {
+		fmt.Fprintf(&source, "extern uint%d_t %s(uint%d_t);\n", test.width, test.name, test.width)
+	}
+	source.WriteString("int main(void) {\n")
+	for _, test := range x86SourceStackRuntimeCases(arch) {
+		fmt.Fprintf(&source, `
+	for (unsigned iteration = 0; iteration < 64; iteration++) {
+		const uint%d_t inputs[] = {0, 1, 17, 253, (uint%d_t)-4};
+		for (unsigned index = 0; index < sizeof(inputs)/sizeof(inputs[0]); index++) {
+			const uint%d_t input = inputs[index];
+			uint%d_t want = input + 7;
+`, test.width, test.width, test.width, test.width)
+		if test.flags {
+			source.WriteString("\t\t\tif (input == 0) want++;\n")
+		}
+		if test.name == "WordImmediate" {
+			fmt.Fprintf(&source, "\t\t\twant = (input & ~(uint%d_t)65535) | 65530;\n\t\t\twant += 7;\n", test.width)
+		}
+		fmt.Fprintf(&source, `
+			volatile uint64_t canary = UINT64_C(0x123456789abcdef0);
+			if (%s(input) != want || canary != UINT64_C(0x123456789abcdef0)) return 1;
+		}
+	}
+`, test.name)
+	}
+	source.WriteString("\tif (PhysicalBool(false) || !PhysicalBool(true)) return 2;\n")
+	source.WriteString("\tvolatile uint64_t boolCanary = UINT64_C(0x123456789abcdef0);\n\tif (!PhysicalBoolIntermediate(false) || !PhysicalBoolIntermediate(true) || !PhysicalBoolNamedFP(false) || !PhysicalBoolNamedFP(true) || boolCanary != UINT64_C(0x123456789abcdef0)) return 3;\n\treturn 0;\n}\n")
+	return source.String()
+}
+
+func TestX86RawReturnBoundSourceStackRuntimeForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		source, sigs := x86SourceStackRuntimeSource(target.arch)
+		requireX86GoAssemblerResult(t, target.arch, source, true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs,
+			ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, target.triple, "source-stack-forms.ll", "source-stack-forms.o", ir)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawSourceStackNumerical(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("x86 source-stack numerical oracle runs in the required Linux/amd64 cross-runtime gate")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	t.Run("amd64", func(t *testing.T) {
+		x86SourceStackActualGoNumerical(t, "amd64", nil)
+		source, sigs := x86SourceStackRuntimeSource("amd64")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs,
+			ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "source_stack64", triple, ir, x86SourceStackCOracle("amd64"), runner)
+	})
+	// This required native owner must execute the original physical 386 bool
+	// bytes too, even when the broader ARM/QEMU matrix is not selected. Explicit
+	// cross execution retains its old dynamic guest transport independently.
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" || runtime.GOOS == "linux" && runtime.GOARCH == "amd64" {
+		if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+			t.Fatal("PLAN9ASM_CROSS_EXEC source-stack matrix requires Linux/amd64")
+		}
+		t.Run("386", func(t *testing.T) {
+			runner = nil
+			compiler := []string{"i686-linux-gnu-gcc", "-static", "-no-pie"}
+			if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" {
+				runner = []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"}
+				compiler = []string{"i686-linux-gnu-gcc", "-no-pie"}
+			}
+			x86SourceStackActualGoNumerical(t, "386", runner)
+			source, sigs := x86SourceStackRuntimeSource("386")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: sigs,
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler,
+				"source_stack32", "i386-unknown-linux-gnu", ir, x86SourceStackCOracle("386"), runner)
+		})
+	}
+}
diff --git a/amd64_raw_return_source_stack_test.go b/amd64_raw_return_source_stack_test.go
new file mode 100644
index 000000000..ee4a777ec
--- /dev/null
+++ b/amd64_raw_return_source_stack_test.go
@@ -0,0 +1,389 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86SourceStackNumericalFixture(arch, body string) (string, FuncSig, GoPackage) {
+	word, move, typ, llvmType := int64(8), "MOVQ", "uint64", I64
+	if arch == "386" {
+		word, move, typ, llvmType = 4, "MOVL", "uint32", I32
+	}
+	return x86SourceStackTypedFixture(arch, typ, llvmType, word, move, body)
+}
+
+func x86SourceStackTypedFixture(arch, typ string, llvmType LLVMType, word int64, move, body string) (string, FuncSig, GoPackage) {
+	body = strings.NewReplacer("@MOV", move, "@WORD", fmt.Sprint(word), "@RESULT", fmt.Sprint(2*word)).Replace(body)
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n", 2*word, body)
+	sig := FuncSig{Name: "sourceframe.Value", Args: []LLVMType{llvmType}, Ret: llvmType,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: llvmType, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: word, Type: llvmType, Index: 0, Field: -1}},
+		}}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "value.go", "package sourceframe\nfunc Value(x "+typ+") "+typ+"\nfunc callee()\n", 0)
+	if err != nil {
+		panic(err)
+	}
+	pkg, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("sourceframe", fset, []*ast.File{file}, nil)
+	if err != nil {
+		panic(err)
+	}
+	return source, sig, GoPackage{Path: "sourceframe", Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func x86SourceStackOptions(arch, triple string, sig FuncSig) Options {
+	return Options{Goarch: arch, TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "sourceframe.", 1) },
+		Sigs:       map[string]FuncSig{sig.Name: sig},
+	}
+}
+
+func TestX86RawReturnBoundSourceStackNumerical(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		push, pop, arithmetic, address, align := "PUSHQ", "POPQ", "ADDQ", "LEAQ", 8
+		if target.arch == "386" {
+			push, pop, arithmetic, address, align = "PUSHL", "POPL", "ADDL", "LEAL", 4
+		}
+		for _, fixture := range []struct{ name, body string }{
+			{"physical", "@MOV @WORD(SP),AX\n" + arithmetic + " $7,AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3"},
+			{"balanced", "@MOV x+0(FP),AX\n" + push + " BP\n@MOV SP,BP\nAND" + strings.TrimPrefix(arithmetic, "ADD") + fmt.Sprintf(" $-%d,SP\n", align) + arithmetic + " $7,AX\n@MOV BP,SP\n" + pop + " BP\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3"},
+			{"nested", "@MOV x+0(FP),AX\n" + push + " BP\n@MOV SP,BP\n" + push + " BX\n" + push + " AX\n" + address + " -2*@WORD(BP),SP\n" + pop + " AX\n" + pop + " BX\n@MOV BP,SP\n" + pop + " BP\n" + arithmetic + " $7,AX\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3"},
+		} {
+			t.Run(target.triple+"/"+fixture.name, func(t *testing.T) {
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, fixture.body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := x86SourceStackOptions(target.arch, target.triple, sig)
+				ir, err := Translate(file, opt)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "source-frame.ll", "source-frame.o", ir)
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err != nil {
+					ctx.Dispose()
+					t.Fatal(err)
+				}
+				module.Dispose()
+				ctx.Dispose()
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if err != nil {
+					ctx.Dispose()
+					t.Fatal(err)
+				}
+				translation.Module.Dispose()
+				ctx.Dispose()
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackRetainsContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		push, pop, sub, align := "PUSHQ", "POPQ", "SUBQ", 16
+		if target.arch == "386" {
+			push, pop, sub, align = "PUSHL", "POPL", "SUBL", 8
+		}
+		for _, body := range []string{
+			"@MOV @WORD(SP),AX\n@MOV AX,0(SP)\nBYTE $0xc3",
+			"@MOV @WORD(SP),AX\n@MOV AX,@WORD-1(SP)\nBYTE $0xc3",
+			push + " AX\nBYTE $0xc3",
+			push + " BP\n@MOV SP,BP\n" + pop + " AX\nBYTE $0xc3",
+			push + " BP\n@MOV SP,BP\nAND" + strings.TrimPrefix(sub, "SUB") + fmt.Sprintf(" $-%d,SP\n", align) + "@MOV BP,SP\n" + pop + " BP\nBYTE $0xc3",
+			push + " BP\n@MOV SP,BP\n@MOV BP,AX\n@MOV BP,SP\n" + pop + " BP\nBYTE $0xc3",
+			"LEA" + strings.TrimPrefix(sub, "SUB") + " (SP),AX\nBYTE $0xc3",
+			"@MOV @WORD(SP),AX\n@MOV AX,(BX)\nBYTE $0xc3",
+			"CALL ·callee(SB)\nBYTE $0xc3",
+			"@MOV $0,SP\nBYTE $0xc3",
+			"CMP" + strings.TrimPrefix(sub, "SUB") + " $0,AX\nJE alternate\n" + push + " AX\nalternate:\nBYTE $0xc3",
+		} {
+			t.Run(target.triple+"/"+body, func(t *testing.T) {
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, body)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := x86SourceStackOptions(target.arch, target.triple, sig)
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved source continuation became callable: %v", err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("module accepted unproved source continuation: %v", err)
+				}
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if err == nil {
+					translation.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("declaration API accepted unproved source continuation: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackGoFPProducerOffsets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, push, pop, move, rawPush, rawPop := int64(8), "PUSHQ", "POPQ", "MOVQ", "BYTE $0x50", "BYTE $0x59"
+		if target.arch == "386" {
+			word, push, pop, move = 4, "PUSHL", "POPL", "MOVL"
+		}
+		for _, test := range []struct {
+			name, body string
+			accepted   bool
+		}{
+			{"named FP after named push", push + " CX\n" + move + " x+0(FP),AX\n" + pop + " CX\n" + move + " AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+			{"raw push physical shifted argument", rawPush + "\n" + move + " @RESULT(SP),AX\n" + rawPop + "\n" + move + " AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+			{"raw push cannot shift Go FP", rawPush + "\n" + move + " x+0(FP),AX\n" + rawPop + "\n" + move + " AX,ret+@WORD(FP)\nBYTE $0xc3", false},
+			{"partial scalar access", fmt.Sprintf("MOVB %d(SP),AX\n%s AX,ret+@WORD(FP)\nBYTE $0xc3", word, move), false},
+			{"stack index", move + " @WORD(SP)(CX*1),AX\n" + move + " AX,ret+@WORD(FP)\nBYTE $0xc3", false},
+			{"original BP is not argument frame", move + " @WORD(BP),AX\n" + move + " AX,ret+@WORD(FP)\nBYTE $0xc3", false},
+		} {
+			t.Run(target.triple+"/"+test.name, func(t *testing.T) {
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, test.body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := x86SourceStackOptions(target.arch, target.triple, sig)
+				_, err = Translate(file, opt)
+				if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("source ABI0 transport accepted=%t: %v", test.accepted, err)
+				}
+				ctx := llvm.NewContext()
+				module, moduleErr := TranslateModuleInContext(ctx, file, opt)
+				if moduleErr == nil {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if test.accepted && moduleErr != nil || !test.accepted && !errors.Is(moduleErr, ErrProbeNeedsContext) {
+					t.Fatalf("module ABI0 transport accepted=%t: %v", test.accepted, moduleErr)
+				}
+				ctx = llvm.NewContext()
+				translation, bindingErr := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if bindingErr == nil {
+					translation.Module.Dispose()
+				}
+				ctx.Dispose()
+				if test.accepted && bindingErr != nil || !test.accepted && !errors.Is(bindingErr, ErrProbeNeedsContext) {
+					t.Fatalf("declaration ABI0 transport accepted=%t: %v", test.accepted, bindingErr)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackScalarMoveWidths(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, add := int64(8), "ADDQ"
+		if target.arch == "386" {
+			word, add = 4, "ADDL"
+		}
+		for _, typ := range []struct {
+			goType string
+			llvm   LLVMType
+			move   string
+		}{
+			{"bool", I1, "MOVB"},
+			{"uint8", I8, "MOVB"}, {"uint16", I16, "MOVW"}, {"uint32", I32, "MOVL"}, {"uint64", I64, "MOVQ"},
+		} {
+			if target.arch == "386" && typ.llvm == I64 {
+				continue // Go's 386 GP ABI transports this value as two slots.
+			}
+			t.Run(target.triple+"/"+typ.goType, func(t *testing.T) {
+				body := "@MOV @WORD(SP),AX\n" + add + " $7,AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3"
+				if typ.llvm == I1 {
+					body = "@MOV @WORD(SP),AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3"
+				}
+				source, sig, pkg := x86SourceStackTypedFixture(target.arch, typ.goType, typ.llvm, word, typ.move, body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, x86SourceStackOptions(target.arch, target.triple, sig))
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "scalar-sp.ll", "scalar-sp.o", ir)
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, x86SourceStackOptions(target.arch, target.triple, sig))
+				if err != nil {
+					ctx.Dispose()
+					t.Fatal(err)
+				}
+				module.Dispose()
+				ctx.Dispose()
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if err != nil {
+					ctx.Dispose()
+					t.Fatal(err)
+				}
+				translation.Module.Dispose()
+				ctx.Dispose()
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackDoesNotTrustChangedSignature(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		source, sig, _ := x86SourceStackNumericalFixture(target.arch, "@MOV @WORD(SP),AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		prepared, err := NormalizeRawFileForTranslation(file, target.arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, change := range []string{"no frame", "wrong type", "wrong offset", "wrong index", "custom registers", "pointer", "wrong size"} {
+			t.Run(target.triple+"/"+change, func(t *testing.T) {
+				changed := sig
+				changed.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+				changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+				changed.Args = append([]LLVMType(nil), sig.Args...)
+				switch change {
+				case "no frame":
+					changed.Frame = FrameLayout{}
+				case "wrong type":
+					changed.Frame.Params[0].Type = I8
+				case "wrong offset":
+					changed.Frame.Params[0].Offset = 1
+				case "wrong index":
+					changed.Frame.Params[0].Index = 1
+				case "custom registers":
+					changed.ArgRegs = []Reg{AX}
+				case "pointer":
+					changed.Args[0], changed.Frame.Params[0].Type = Ptr, Ptr
+				case "wrong size":
+					changed.Frame.Results[0].Offset = 1 << 20
+				}
+				if _, err := Translate(prepared, x86SourceStackOptions(target.arch, target.triple, changed)); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("prepartition metadata trusted a changed contract: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackFlagsNeedNumericalProvenance(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		suffix, word := "Q", 8
+		if target.arch == "386" {
+			suffix, word = "L", 4
+		}
+		start := "@MOV @WORD(SP),AX\n"
+		finish := "@MOV AX,@RESULT(SP)\nBYTE $0xc3"
+		movement := fmt.Sprintf("SUB%s $%d,SP\nADD%s $%d,SP\n", suffix, word, suffix, word)
+		for _, test := range []struct {
+			name, body string
+			accepted   bool
+		}{
+			{"entry carry", start + "ADC" + suffix + " $0,AX\n" + finish, false},
+			{"SP-derived flags", start + movement + "JS done\ndone:\n" + finish, false},
+			{"flags exposed as scalar", start + "CMP" + suffix + " AX,$1\nPUSHF" + suffix + "\nPOP" + suffix + " AX\n" + finish, false},
+			{"scalar replaces flags", start + "PUSH" + suffix + " AX\nPOPF" + suffix + "\nADC" + suffix + " $0,AX\n" + finish, false},
+			{"different flag origins join", start + "CMP" + suffix + " AX,$1\nJE done\n" + movement + "done:\nADC" + suffix + " $0,AX\n" + finish, false},
+			{"saved numeric flags restored", start + "CMP" + suffix + " AX,$1\nPUSHF" + suffix + "\n" + movement + "POPF" + suffix + "\nADC" + suffix + " $0,AX\n" + finish, true},
+		} {
+			t.Run(target.triple+"/"+test.name, func(t *testing.T) {
+				source, sig, pkg := x86SourceStackNumericalFixture(target.arch, test.body)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, x86SourceStackOptions(target.arch, target.triple, sig))
+				if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("numerical flags contract accepted=%t: %v", test.accepted, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, x86SourceStackOptions(target.arch, target.triple, sig))
+				if err == nil {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("module flags contract accepted=%t: %v", test.accepted, err)
+				}
+				ctx = llvm.NewContext()
+				translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple})
+				if err == nil {
+					translation.Module.Dispose()
+				}
+				ctx.Dispose()
+				if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("declaration flags contract accepted=%t: %v", test.accepted, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnBoundSourceStackDoesNotTrustEditedRawProducer(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		source, sig, _ := x86SourceStackNumericalFixture(target.arch,
+			"BYTE $0x50\n@MOV @RESULT(SP),AX\nBYTE $0x59\n@MOV AX,ret+@WORD(FP)\nBYTE $0xc3")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		prepared, err := NormalizeRawFileForTranslation(file, target.arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index := range prepared.Funcs[0].Instrs {
+			ins := &prepared.Funcs[0].Instrs[index]
+			if spec, stack := amd64StackWidthSpecs[ins.Op]; stack && spec.mode == amd64StackPushValue {
+				ins.Args = []Operand{{Kind: OpReg, Reg: BX}}
+				break
+			}
+		}
+		if _, err := Translate(prepared, x86SourceStackOptions(target.arch, target.triple, sig)); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s edited raw producer kept an original-Go prologue certificate: %v", target.triple, err)
+		}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, prepared, x86SourceStackOptions(target.arch, target.triple, sig))
+		if err == nil {
+			module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s module trusted edited raw producer: %v", target.triple, err)
+		}
+	}
+}
diff --git a/amd64_raw_rorx.go b/amd64_raw_rorx.go
new file mode 100644
index 000000000..5d86b79d1
--- /dev/null
+++ b/amd64_raw_rorx.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import "fmt"
+
+// decodedX86RORXInstruction recognizes the complete BMI2 RORXL/RORXQ Yml,
+// Yrl, imm8 family, including register and every source-layout-safe ModRM/SIB
+// memory form. x/arch v0.14 reports the VEX.0F3A encoding as an unknown AVX
+// opcode, so it must be recovered before generic decoding.
+func decodedX86RORXInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86RORXInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86RORXInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto vex
+		}
+	}
+
+vex:
+	if len(code) < i+4 || code[i] != 0xc4 || code[i+1]&0x1f != 3 || code[i+3] != 0xf0 {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, true, fmt.Errorf("unsupported x86 mode %d", mode)
+	}
+	vexExt, vexByte := code[i+1], code[i+2]
+	if vexByte&3 != 3 || vexByte&4 != 0 || vexByte&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("reserved RORX VEX prefix")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+	if len(code) <= i+4 {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	rExt := int(^vexExt>>7) & 1
+	xExt := int(^vexExt>>6) & 1
+	bExt := int(^vexExt>>5) & 1
+	width64 := vexByte&0x80 != 0
+	modRM := code[i+4]
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && destinationNumber >= 8 {
+		return Instr{}, 0, true, fmt.Errorf("extended destination register in 32-bit mode")
+	}
+	destination, valid := decodedX86GeneralRegister(destinationNumber)
+	if !valid {
+		return Instr{}, 0, true, fmt.Errorf("invalid destination register %d", destinationNumber)
+	}
+	source, consumed, err := memory.scalar(code[i+4:], mode, bExt, xExt, segment, 1)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if len(code) <= i+4+consumed {
+		return Instr{}, 0, true, fmt.Errorf("missing imm8")
+	}
+	immediate := int64(code[i+4+consumed])
+	op := Op("RORXL")
+	if width64 && mode == 64 {
+		op = "RORXQ"
+	}
+	instruction = Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpImm, Imm: immediate},
+			source,
+			{Kind: OpReg, Reg: destination},
+		},
+		Raw: fmt.Sprintf("%s $%d, %s, %s", op, immediate, source.String(), destination),
+	}
+	return instruction, i + 5 + consumed, true, nil
+}
diff --git a/amd64_raw_rotate_variable.go b/amd64_raw_rotate_variable.go
new file mode 100644
index 000000000..0f6564d27
--- /dev/null
+++ b/amd64_raw_rotate_variable.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodedX86RawVariableRotateInstruction covers the four EVEX per-lane
+// variable rotates in Go's _yvblendmpd table: left/right, D/Q, X/Y/Z,
+// optional mask, zeroing, and scalar-memory broadcast.
+func decodedX86RawVariableRotateInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 2 || p.pp != 1 ||
+		(p.opcode != 0x14 && p.opcode != 0x15) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX variable rotate: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.addressOverride || p.vectorLength > 2 {
+		return fail("invalid EVEX fixed, address, or vector-length bits")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if mode == 32 && p.mask != 0 {
+		return fail("386 mask form exceeds the Go assembler frontend's operand limit")
+	}
+	modRM := code[p.modRM]
+	if p.broadcast && modRM>>6 == 3 {
+		return fail("EVEX.b broadcast requires memory")
+	}
+	destinationNumber := int(modRM>>3&7) + p.r*8
+	if mode == 32 && (p.upper >= 8 || destinationNumber >= 8 ||
+		modRM>>6 == 3 && int(modRM&7)+p.b*8+p.x*16 >= 8) {
+		return fail("extended vector register in 32-bit mode")
+	}
+	vector := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	width := 16 << p.vectorLength
+	laneBytes := 4
+	if p.w {
+		laneBytes = 8
+	}
+	disp8Scale := width
+	if p.broadcast {
+		disp8Scale = laneBytes
+	}
+	first, consumed, err := decodedX86EVEXRMOperand(
+		code[p.modRM:], mode, p.b, p.x, p.segment, vector, disp8Scale,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	op := Op("VPRORVD")
+	if p.opcode == 0x15 {
+		op = "VPROLVD"
+	}
+	if p.w {
+		op = Op(strings.TrimSuffix(string(op), "D") + "Q")
+	}
+	if p.broadcast {
+		op += ".BCST"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, destinationNumber))}
+	args := []Operand{first, second}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_rotate_variable_test.go b/amd64_raw_rotate_variable_test.go
new file mode 100644
index 000000000..4aae5cdde
--- /dev/null
+++ b/amd64_raw_rotate_variable_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVariableRotate(op Op, width, mask, destination, first, second int, zeroing, broadcast, memory bool) []byte {
+	opcode := byte(0x14)
+	if strings.HasPrefix(string(op), "VPROL") {
+		opcode = 0x15
+	}
+	p0 := byte((1-(destination>>3)&1)<<7 | (1-(first>>4)&1)<<6 |
+		(1-(first>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 2)
+	p1 := byte(((^second)&15)<<3 | 0x05)
+	if strings.HasSuffix(string(op), "Q") {
+		p1 |= 0x80
+	}
+	p2 := byte(width<<5 | (1-((second>>4)&1))<<3 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | first&7)
+	if memory {
+		modRM = byte(0x40 | (destination&7)<<3)
+		p0 = byte((1-(destination>>3)&1)<<7 | 0x60 | (1-(destination>>4)&1)<<4 | 2)
+	}
+	code := []byte{0x62, p0, p1, p2, opcode, modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodeX86RawVariableRotateSeBiShogunRegression(t *testing.T) {
+	// Go's assembler disassembles these bytes as VPROLVD Z0, Z1, Z1.
+	code := []byte{0x62, 0xf2, 0x75, 0x48, 0x15, 0xc8, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "rotlInt32 AVX512 VPROLVD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPROLVD" ||
+		decoded[0].Args[0].Reg != "Z0" || decoded[0].Args[1].Reg != "Z1" ||
+		decoded[0].Args[2].Reg != "Z1" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawVariableRotateCompleteGoForms(t *testing.T) {
+	for _, op := range []Op{"VPROLVD", "VPROLVQ", "VPRORVD", "VPRORVQ"} {
+		for width := 0; width < 3; width++ {
+			vector := [...]string{"X", "Y", "Z"}[width]
+			for _, form := range []struct {
+				name        string
+				mask        int
+				zeroing     bool
+				broadcast   bool
+				memory      bool
+				destination int
+				first       int
+				second      int
+			}{
+				{name: "register", destination: 2, first: 3, second: 4},
+				{name: "high registers", destination: 18, first: 19, second: 20},
+				{name: "masked zeroing", mask: 7, zeroing: true, destination: 2, first: 3, second: 4},
+				{name: "memory", memory: true, destination: 2, second: 4},
+				{name: "broadcast memory", broadcast: true, memory: true, destination: 2, second: 4},
+				{name: "broadcast zeroing memory", broadcast: true, memory: true, mask: 5, zeroing: true, destination: 2, second: 4},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", op, vector, form.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawVariableRotate(
+						op, width, form.mask, form.destination, form.first, form.second,
+						form.zeroing, form.broadcast, form.memory,
+					)
+					got, length, ok, err := decodedX86RawVariableRotateInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := op
+					if form.broadcast {
+						wantOp += ".BCST"
+					}
+					if form.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[1].String() != fmt.Sprintf("%s%d", vector, form.second) ||
+						got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s%d", vector, form.destination) {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+					if !form.memory && got.Args[0].String() != fmt.Sprintf("%s%d", vector, form.first) {
+						t.Fatalf("decode %x first source = %s", code, got.Args[0])
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVariableRotateRIPLiteral(t *testing.T) {
+	for _, op := range []Op{"VPROLVD", "VPROLVQ", "VPRORVD", "VPRORVQ"} {
+		for width := 0; width < 3; width++ {
+			for _, broadcast := range []bool{false, true} {
+				code := encodeX86RawVariableRotate(op, width, 1, 2, 0, 4, false, broadcast, false)
+				code[5] = 0x15 // RIP-relative first source, destination 2.
+				code = append(code, 1, 0, 0, 0, 0xc3)
+				literalWidth := 16 << width
+				if broadcast {
+					literalWidth = 4
+					if strings.HasSuffix(string(op), "Q") {
+						literalWidth = 8
+					}
+				}
+				for index := 0; index < literalWidth; index++ {
+					code = append(code, byte(index+1))
+				}
+				name := fmt.Sprintf("%s/width%d/broadcast%t", op, width, broadcast)
+				t.Run(name, func(t *testing.T) {
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(got) != 2 || !got[0].x86RIPLiteral || len(got[0].x86RIPLiteralData) != literalWidth {
+						t.Fatalf("decode %x = %+v", code, got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVariableRotateRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawVariableRotate("VPROLVD", 2, 0, 2, 3, 4, false, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x10 }, // broadcast requires memory
+		func(code []byte) { code[3] |= 0x80 }, // zeroing requires a mask
+		func(code []byte) { code[3] |= 0x20 }, // reserved vector length
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86RawVariableRotateInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestTranslateX86RawVariableRotateLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawVariableRotate(SB),$0-0\n")
+			for _, op := range []Op{"VPROLVD", "VPROLVQ", "VPRORVD", "VPRORVQ"} {
+				for width := 0; width < 3; width++ {
+					for _, form := range []struct {
+						memory, broadcast bool
+					}{
+						{}, {memory: true}, {memory: true, broadcast: true},
+					} {
+						code := encodeX86RawVariableRotate(op, width, 0, 2, 3, 4, false, form.broadcast, form.memory)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86PackedRotateUnboundFormatObject(t, source.String(), target.goarch, target.triple, 36, 0)
+			compileLLVMToObject(t, llc, target.triple, "raw-variable-rotate.ll", "raw-variable-rotate.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_round.go b/amd64_raw_round.go
new file mode 100644
index 000000000..7810be8e6
--- /dev/null
+++ b/amd64_raw_round.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodedX86RawVEXRoundInstruction implements Go's four VROUND PS/PD/SS/SD
+// opcode rows. The packed forms reserve vvvv; scalar forms use it as their
+// upper-lane source. Every form has a trailing imm8.
+func decodedX86RawVEXRoundInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 3 || p.pp != 1 || p.opcode < 0x08 || p.opcode > 0x0b {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VROUND: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.w || p.addressOverride {
+		return fail("requires VEX.W0 without address override")
+	}
+	scalar := p.opcode >= 0x0a
+	if scalar && p.vectorLength != 0 || !scalar && p.upper != 0 {
+		return fail("invalid scalar vector length or packed reserved vvvv")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (destinationNumber >= 8 || p.upper >= 8 || p.b != 0 || p.x != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	width := "X"
+	if p.vectorLength != 0 {
+		width = "Y"
+	}
+	source, consumed, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := p.modRM + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	args := []Operand{{Kind: OpImm, Imm: int64(code[immIndex])}, source}
+	if scalar {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destinationNumber))})
+	op := [...]Op{"VROUNDPS", "VROUNDPD", "VROUNDSS", "VROUNDSD"}[p.opcode-0x08]
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, immIndex + 1, true, nil
+}
diff --git a/amd64_raw_round_test.go b/amd64_raw_round_test.go
new file mode 100644
index 000000000..570fde9b1
--- /dev/null
+++ b/amd64_raw_round_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVEXRound(opcode byte, width256 bool, destination, upper, source int, imm byte) []byte {
+	code := encodeX86VEXPackedWordMultiply(3, opcode, width256, false, destination, upper, source)
+	return append(code, imm)
+}
+
+func TestDecodedX86RawVEXRoundCompleteFamily(t *testing.T) {
+	for _, form := range []struct {
+		opcode byte
+		op     Op
+		scalar bool
+	}{
+		{0x08, "VROUNDPS", false},
+		{0x09, "VROUNDPD", false},
+		{0x0a, "VROUNDSS", true},
+		{0x0b, "VROUNDSD", true},
+	} {
+		for _, width256 := range []bool{false, true} {
+			if form.scalar && width256 {
+				continue
+			}
+			for _, source := range []int{0, 7, 8, 15} {
+				for _, imm := range []byte{0, 9, 255} {
+					name := fmt.Sprintf("%s/y%t/src%d/imm%d", form.op, width256, source, imm)
+					t.Run(name, func(t *testing.T) {
+						code := encodeX86RawVEXRound(form.opcode, width256, 11, 3, source, imm)
+						if !form.scalar {
+							code = encodeX86RawVEXRound(form.opcode, width256, 11, 0, source, imm)
+						}
+						got, length, matched, err := decodedX86RawVEXRoundInstruction(code, 64)
+						if err != nil || !matched || length != len(code) || got.Op != form.op ||
+							got.Args[0].Kind != OpImm || got.Args[0].Imm != int64(imm) ||
+							got.Args[1].String() != fmt.Sprintf("%s%d", map[bool]string{false: "X", true: "Y"}[width256], source) {
+							t.Fatalf("decode %x = %+v length=%d matched=%t err=%v", code, got, length, matched, err)
+						}
+						if form.scalar && (len(got.Args) != 4 || got.Args[2].String() != "X3") {
+							t.Fatalf("scalar upper-lane operand missing: %+v", got)
+						}
+					})
+				}
+			}
+		}
+	}
+	// Actual bytes in simd@v1.21.1 arith_avx2_amd64.s.
+	real := []byte{0xc4, 0xa3, 0x7d, 0x08, 0x04, 0x86, 0x09}
+	got, length, matched, err := decodedX86RawVEXRoundInstruction(real, 64)
+	if err != nil || !matched || length != len(real) || got.Op != "VROUNDPS" ||
+		got.Args[1].String() != "0(SI)(R8*4)" || got.Args[2].String() != "Y0" {
+		t.Fatalf("decode real VROUNDPS %x = %+v length=%d matched=%t err=%v", real, got, length, matched, err)
+	}
+}
+
+func TestDecodedX86RawVEXRoundRejectsInvalidForms(t *testing.T) {
+	packed := encodeX86RawVEXRound(0x08, true, 0, 0, 0, 9)
+	scalar := encodeX86RawVEXRound(0x0a, false, 0, 1, 0, 9)
+	for name, bad := range map[string][]byte{
+		"packed reserved vvvv": func() []byte {
+			b := append([]byte(nil), packed...)
+			b[2] &^= 0x08
+			return b
+		}(),
+		"scalar L1": func() []byte {
+			b := append([]byte(nil), scalar...)
+			b[2] |= 0x04
+			return b
+		}(),
+		"W1": func() []byte {
+			b := append([]byte(nil), packed...)
+			b[2] |= 0x80
+			return b
+		}(),
+		"truncated imm8":   packed[:len(packed)-1],
+		"address override": append([]byte{0x67}, packed...),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, _, matched, err := decodedX86RawVEXRoundInstruction(bad, 64); !matched || err == nil {
+				t.Fatalf("accepted invalid VROUND %x: matched=%t err=%v", bad, matched, err)
+			}
+		})
+	}
+}
+
+func x86RawVEXRoundConstant(opcode byte, width256 bool) []byte {
+	code := encodeX86RawVEXRound(opcode, width256, 0, 0, 0, 9)
+	code[len(code)-2] = 0x05
+	imm := code[len(code)-1]
+	code = append(code[:len(code)-1], 1, 0, 0, 0, imm, 0xc3)
+	width := 16
+	if width256 {
+		width = 32
+	}
+	if opcode == 0x0a {
+		width = 4
+	} else if opcode == 0x0b {
+		width = 8
+	}
+	for i := 0; i < width; i++ {
+		code = append(code, byte(i*17+11))
+	}
+	return code
+}
+
+func TestDecodeX86RawVEXRoundConstantCompleteFamily(t *testing.T) {
+	for _, opcode := range []byte{0x08, 0x09, 0x0a, 0x0b} {
+		for _, wide := range []bool{false, true} {
+			if opcode >= 0x0a && wide {
+				continue
+			}
+			name := fmt.Sprintf("%02x/y%t", opcode, wide)
+			t.Run(name, func(t *testing.T) {
+				code := x86RawVEXRoundConstant(opcode, wide)
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || got[0].Args[1].Kind != OpSym || !got[0].x86RIPLiteral || got[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want source-local round constant", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawVEXRoundConstantRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVEXRoundConstant(0x08, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[5] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[5] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe VROUND RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVEXRoundObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, opcode := range []byte{0x08, 0x09, 0x0a, 0x0b} {
+		code := x86RawVEXRoundConstant(opcode, opcode < 0x0a)
+		name := fmt.Sprintf("rawVEXRound%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86RawRoundOriginalModuleObjects(t, file, source.String(), triple, sigs)
+			compileLLVMToObject(t, llc, triple, "raw-vex-round.ll", "raw-vex-round.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_sad.go b/amd64_raw_sad.go
new file mode 100644
index 000000000..d8c5e6bba
--- /dev/null
+++ b/amd64_raw_sad.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27 has three vector SAD encodings: VPSADBW is 66/0F/F6 in
+// VEX X/Y and EVEX X/Y/Z, VMPSADBW is VEX 66/0F3A/42 with imm8 in X/Y,
+// and VDBPSADBW is the corresponding EVEX X/Y/Z immediate form with an
+// optional writemask. Legacy PSADBW and MPSADBW use the x86asm path.
+func decodedX86RawPackedSADInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, recognized := decodeX86RawVectorEncoding(code)
+	if !recognized || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	withImmediate := false
+	switch {
+	case p.mapNumber == 1 && p.opcode == 0xf6:
+		op = "VPSADBW"
+	case p.mapNumber == 3 && p.opcode == 0x42 && !p.evex:
+		op, withImmediate = "VMPSADBW", true
+	case p.mapNumber == 3 && p.opcode == 0x42 && p.evex:
+		op, withImmediate = "VDBPSADBW", true
+	default:
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("%s: %s", op, message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.w && op == "VDBPSADBW" || p.vectorLength > 2 || p.evex && !p.fixed {
+		return fail("invalid width or EVEX fixed bit")
+	}
+	if !p.evex && p.vectorLength == 2 {
+		return fail("VEX does not encode Z registers")
+	}
+	if p.broadcast || p.mask != 0 && op != "VDBPSADBW" ||
+		p.zero && (op != "VDBPSADBW" || p.mask == 0) {
+		return fail("invalid broadcast, writemask or zeroing form")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0 || p.upper >= 8) {
+		return fail("extended vector register in 32-bit mode")
+	}
+
+	width := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	var first Operand
+	var consumed int
+	var err error
+	if p.evex {
+		first, consumed, err = decodedX86EVEXRMOperand(
+			code[p.modRM:], mode, p.b, p.x, p.segment, width, 16<<p.vectorLength,
+		)
+	} else {
+		first, consumed, err = decodedX86VEXVectorRMOperand(
+			code[p.modRM:], mode, p.b, p.x, p.segment, width,
+		)
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	length := p.modRM + consumed
+	if withImmediate && len(code) <= length {
+		return fail("missing imm8 byte")
+	}
+	second := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, p.upper))}
+	destinationNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && destinationNumber >= 8 {
+		return fail("extended destination register in 32-bit mode")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, destinationNumber))}
+	args := []Operand{first, second}
+	if withImmediate {
+		args = append([]Operand{{Kind: OpImm, Imm: int64(code[length])}}, args...)
+		length++
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	if p.zero {
+		op += ".Z"
+	}
+	parts := make([]string, len(args))
+	for index, arg := range args {
+		parts[index] = arg.String()
+	}
+	return Instr{
+		Op:         op,
+		Args:       args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(parts, ", ")),
+		x86Encoded: true,
+	}, length, true, nil
+}
diff --git a/amd64_raw_sad_test.go b/amd64_raw_sad_test.go
new file mode 100644
index 000000000..1dfcbad35
--- /dev/null
+++ b/amd64_raw_sad_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawPackedSAD(op Op, vectorBits, first, second, destination, mask int, zero, memory bool) []byte {
+	if memory {
+		first = 0
+	}
+	mapNumber, opcode := byte(1), byte(0xf6)
+	if op != "VPSADBW" && op != "VPSADBW.EVEX" {
+		mapNumber, opcode = 3, 0x42
+	}
+	modRM := byte(0xc0 | destination&7<<3 | first&7)
+	if memory {
+		modRM = byte(0x40 | destination&7<<3)
+	}
+	var code []byte
+	if op == "VDBPSADBW" || op == "VPSADBW.EVEX" {
+		p0 := byte((1-destination/8&1)<<7 | (1-first/16)<<6 |
+			(1-first/8&1)<<5 | (1-destination/16)<<4 | int(mapNumber))
+		p1 := byte((^second&15)<<3 | 4 | 1)
+		p2 := byte(vectorBits<<5 | (1-second/16)<<3 | mask)
+		if zero {
+			p2 |= 0x80
+		}
+		code = []byte{0x62, p0, p1, p2, opcode, modRM}
+	} else {
+		p0 := byte((1-destination/8&1)<<7 | 1<<6 |
+			(1-first/8&1)<<5 | int(mapNumber))
+		p1 := byte((^second&15)<<3 | vectorBits<<2 | 1)
+		code = []byte{0xc4, p0, p1, opcode, modRM}
+	}
+	if memory {
+		code = append(code, 1)
+	}
+	if op != "VPSADBW" && op != "VPSADBW.EVEX" {
+		code = append(code, 0x39)
+	}
+	return code
+}
+
+func TestTranslateRawPackedSADGorseRegression(t *testing.T) {
+	const source = `TEXT rawPackedSAD(SB), $0-0
+	LONG $0xd3f6edc5
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		ir := x86UnboundVoidRawScalarFormatObject(t, source, target.arch, target.triple)
+		compileLLVMToObject(t, llc, target.triple, "raw-gorse-sad.ll", "raw-gorse-sad.o", ir)
+	}
+}
+
+func TestTranslateRawPackedSADLegacyForms(t *testing.T) {
+	const source = `TEXT rawLegacySAD(SB), $0-0
+	BYTE $0x66; BYTE $0x0f; BYTE $0xf6; BYTE $0xc1
+	BYTE $0x66; BYTE $0x0f; BYTE $0x3a; BYTE $0x42; BYTE $0xc1; BYTE $0x01
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		ir := x86UnboundVoidRawScalarFormatObject(t, source, target.arch, target.triple)
+		compileLLVMToObject(t, llc, target.triple, "raw-legacy-sad.ll", "raw-legacy-sad.o", ir)
+	}
+}
+
+func TestDecodedX86RawPackedSADGoRows(t *testing.T) {
+	for _, test := range []struct {
+		encoded Op
+		want    Op
+		widths  int
+	}{
+		{"VPSADBW", "VPSADBW", 2},
+		{"VPSADBW.EVEX", "VPSADBW", 3},
+		{"VMPSADBW", "VMPSADBW", 2},
+		{"VDBPSADBW", "VDBPSADBW", 3},
+	} {
+		if _, ok := amd64PackedSADSpecs[test.want]; !ok {
+			t.Fatalf("missing lowerer for Go row %s", test.want)
+		}
+		for vectorBits := 0; vectorBits < test.widths; vectorBits++ {
+			for _, memory := range []bool{false, true} {
+				for _, mask := range []int{0, 3} {
+					if mask != 0 && test.encoded != "VDBPSADBW" {
+						continue
+					}
+					for _, zero := range []bool{false, true} {
+						if zero && mask == 0 {
+							continue
+						}
+						code := encodeX86RawPackedSAD(test.encoded, vectorBits, 4, 5, 2, mask, zero, memory)
+						got, length, recognized, err := decodedX86RawPackedSADInstruction(code, 64)
+						if err != nil || !recognized || length != len(code) {
+							t.Fatalf("decode %x: %+v length=%d recognized=%v err=%v", code, got, length, recognized, err)
+						}
+						wantOp := test.want
+						if zero {
+							wantOp += ".Z"
+						}
+						if got.Op != wantOp || got.Args[len(got.Args)-1].String() != fmt.Sprintf("%s2", "XYZ"[vectorBits:vectorBits+1]) {
+							t.Fatalf("decode %x: %+v, want %s", code, got, wantOp)
+						}
+						if memory {
+							firstIndex := 0
+							if test.want != "VPSADBW" {
+								firstIndex = 1
+							}
+							if got.Args[firstIndex].Kind != OpMem {
+								t.Fatalf("decode %x did not retain memory: %+v", code, got)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawPackedSADRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawPackedSAD("VPSADBW", 1, 1, 2, 3, 0, false, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		// WIG W0/W1 pairs have their own independent LLVM decoder oracle.
+		{"VDB W1", func() []byte {
+			code := encodeX86RawPackedSAD("VDBPSADBW", 0, 1, 2, 3, 0, false, false)
+			code[2] |= 0x80
+			return code
+		}()},
+		{"missing ModRM", base[:4]},
+		{"address override", append([]byte{0x67}, base...)},
+		{"missing immediate", encodeX86RawPackedSAD("VMPSADBW", 0, 1, 2, 3, 0, false, false)[:5]},
+		{"VDB broadcast", func() []byte {
+			code := encodeX86RawPackedSAD("VDBPSADBW", 0, 0, 2, 3, 0, false, true)
+			code[3] |= 0x10
+			return code
+		}()},
+		{"VPSADBW writemask", func() []byte {
+			code := encodeX86RawPackedSAD("VPSADBW.EVEX", 0, 1, 2, 3, 0, false, false)
+			code[3] |= 3
+			return code
+		}()},
+		{"VDB zero without mask", encodeX86RawPackedSAD("VDBPSADBW", 0, 1, 2, 3, 0, true, false)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawPackedSADInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted invalid %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestTranslateRawPackedSADLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawPackedSADFamily(SB), $0-0\n")
+			for _, test := range []struct {
+				op     Op
+				width  int
+				mask   int
+				zero   bool
+				memory bool
+			}{
+				{op: "VPSADBW", width: 1},
+				{op: "VPSADBW.EVEX", width: 2, memory: true},
+				{op: "VMPSADBW", width: 1, memory: true},
+				{op: "VDBPSADBW", width: 2, mask: 3, zero: true, memory: true},
+			} {
+				code := encodeX86RawPackedSAD(
+					test.op, test.width, 1, 2, 3, test.mask, test.zero, test.memory,
+				)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-packed-sad.ll", "raw-packed-sad.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_same_width_conversion.go b/amd64_raw_same_width_conversion.go
new file mode 100644
index 000000000..9da6d1820
--- /dev/null
+++ b/amd64_raw_same_width_conversion.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type decodedX86SameWidthConversionProperties struct {
+	op        Op
+	laneBytes int
+	sae       bool
+}
+
+func decodedX86SameWidthConversionOpcode(opcode, pp byte) (decodedX86SameWidthConversionProperties, bool) {
+	properties := map[[2]byte]decodedX86SameWidthConversionProperties{
+		{0x5b, 0}: {op: "VCVTDQ2PS", laneBytes: 4},
+		{0x5b, 1}: {op: "VCVTPS2DQ", laneBytes: 4},
+		{0x5b, 2}: {op: "VCVTTPS2DQ", laneBytes: 4, sae: true},
+		{0x51, 0}: {op: "VSQRTPS", laneBytes: 4},
+		{0x51, 1}: {op: "VSQRTPD", laneBytes: 8},
+	}[[2]byte{opcode, pp}]
+	return properties, properties.op != ""
+}
+
+// decodedX86SameWidthConversionInstruction recognizes every VEX and EVEX
+// encoding behind Go 1.27's _yvcvtdq2ps table: VCVTDQ2PS, VCVTPS2DQ,
+// VCVTTPS2DQ, VSQRTPD, and VSQRTPS. It covers X/Y/Z registers, ModRM/SIB
+// memory, masking, zeroing, broadcasts, embedded rounding, SAE, and compressed
+// displacements before the generic decoder can consume an incorrect length.
+func decodedX86SameWidthConversionInstruction(code []byte, mode int) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86SameWidthConversionInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86SameWidthConversionInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if p, valid := decodeX86RawVectorEncoding(code); valid && p.mapNumber == 1 && p.opcode == 0x5b &&
+		(p.pp == 1 || p.pp == 2) && (!p.evex || !p.w) {
+		return decodedX86PackedNumericConversionInstructionWithMemory(code, mode, memory)
+	}
+	i := 0
+	segment := Reg("")
+	addressOverride := false
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			segment = FS
+			i++
+		case 0x65:
+			segment = GS
+			i++
+		case 0x67:
+			addressOverride = true
+			i++
+		default:
+			goto vectorPrefix
+		}
+	}
+
+vectorPrefix:
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) > i && code[i] == 0x62 {
+		return decodedX86EVEXSameWidthConversionInstructionWithMemory(code, i, mode, segment, addressOverride, memory)
+	}
+
+	var vexLength, rExt, xExt, bExt int
+	var vexBits, opcode byte
+	switch {
+	case len(code) >= i+4 && code[i] == 0xc5:
+		vexLength = 2
+		vexBits = code[i+1]
+		rExt = int(^vexBits>>7) & 1
+		opcode = code[i+2]
+	case len(code) >= i+5 && code[i] == 0xc4 && code[i+1]&0x1f == 1:
+		vexLength = 3
+		vexBits = code[i+2]
+		rExt = int(^code[i+1]>>7) & 1
+		xExt = int(^code[i+1]>>6) & 1
+		bExt = int(^code[i+1]>>5) & 1
+		opcode = code[i+3]
+	default:
+		return Instr{}, 0, false, nil
+	}
+	properties, recognized := decodedX86SameWidthConversionOpcode(opcode, vexBits&3)
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	// CVTDQ2PS and packed SQRT are VEX.WIG in both machine modes.
+	// This does not relax their independently validated EVEX.W fields.
+	ignoredWidth := properties.op == "VCVTDQ2PS" || properties.op == "VSQRTPS" || properties.op == "VSQRTPD"
+	if vexLength == 3 && vexBits&0x80 != 0 && !ignoredWidth {
+		return Instr{}, 0, true, fmt.Errorf("VEX.W must be zero")
+	}
+	if vexBits&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("VEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	opcodeIndex := i + vexLength
+	modRMIndex := opcodeIndex + 1
+	if len(code) <= modRMIndex {
+		return Instr{}, 0, true, fmt.Errorf("missing ModRM byte")
+	}
+	vectorPrefix := "X"
+	if vexBits&0x04 != 0 {
+		vectorPrefix = "Y"
+	}
+	modRM := code[modRMIndex]
+	destinationNumber := int(modRM>>3&7) + rExt*8
+	if mode == 32 && (destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.vex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	instruction = Instr{
+		Op:   properties.op,
+		Args: []Operand{source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s", properties.op, source.String(), destination.String()),
+	}
+	return instruction, modRMIndex + consumed, true, nil
+}
+
+func decodedX86EVEXSameWidthConversionInstruction(code []byte, i, mode int, segment Reg, addressOverride bool) (instruction Instr, length int, ok bool, err error) {
+	return decodedX86EVEXSameWidthConversionInstructionWithMemory(code, i, mode, segment, addressOverride, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXSameWidthConversionInstructionWithMemory(code []byte, i, mode int, segment Reg, addressOverride bool, memory x86RawMemoryDecoder) (instruction Instr, length int, ok bool, err error) {
+	if len(code) < i+6 {
+		return Instr{}, 0, false, nil
+	}
+	p0, p1, p2 := code[i+1], code[i+2], code[i+3]
+	opcode := code[i+4]
+	half := p0&0x0f == 5 && opcode == 0x51 && p1&3 == 0
+	if p0&0x0f != 1 && !half {
+		return Instr{}, 0, false, nil
+	}
+	properties, recognized := decodedX86SameWidthConversionOpcode(opcode, p1&3)
+	if half {
+		properties = decodedX86SameWidthConversionProperties{op: "VSQRTPH", laneBytes: 2}
+	}
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	ok = true
+	if p1&0x04 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("invalid EVEX prefix")
+	}
+	width64 := p1&0x80 != 0
+	wantWidth64 := properties.laneBytes == 8
+	if width64 != wantWidth64 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.W does not match conversion element type")
+	}
+	if p1&0x78 != 0x78 || p2&0x08 == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX.vvvv must be reserved")
+	}
+	if addressOverride {
+		return Instr{}, 0, true, fmt.Errorf("address-size override is not source-layout safe")
+	}
+
+	modRMIndex := i + 5
+	modRM := code[modRMIndex]
+	vectorBits := (p2 >> 5) & 3
+	evexB := p2&0x10 != 0
+	registerSource := modRM>>6 == 3
+	embeddedControl := evexB && registerSource
+	broadcast := evexB && !registerSource
+	if !embeddedControl && vectorBits == 3 {
+		return Instr{}, 0, true, fmt.Errorf("reserved EVEX vector length")
+	}
+
+	vectorPrefix := "Z"
+	vectorWidth := 64
+	if !embeddedControl {
+		vectorPrefix = [...]string{"X", "Y", "Z"}[vectorBits]
+		vectorWidth = [...]int{16, 32, 64}[vectorBits]
+	}
+	disp8Scale := vectorWidth
+	if broadcast {
+		disp8Scale = properties.laneBytes
+	}
+	maskNumber := int(p2 & 7)
+	zeroing := p2&0x80 != 0
+	if zeroing && maskNumber == 0 {
+		return Instr{}, 0, true, fmt.Errorf("EVEX zeroing requires a nonzero mask")
+	}
+
+	rExt := int(^p0>>7) & 1
+	rHighExt := int(^p0>>4) & 1
+	xExt := int(^p0>>6) & 1
+	bExt := int(^p0>>5) & 1
+	destinationNumber := int(modRM>>3&7) + rExt*8 + rHighExt*16
+	sqrt := opcode == 0x51 && !half
+	if mode == 32 && (maskNumber != 0 && !half && !sqrt && properties.op != "VCVTDQ2PS" || destinationNumber >= 8 || modRM>>6 == 3 && int(modRM&7)+bExt*8+xExt*16 >= 8) {
+		return Instr{}, 0, true, fmt.Errorf("extended vector register or mask in 32-bit mode")
+	}
+	source, consumed, decodeErr := memory.evex(code[modRMIndex:], mode, bExt, xExt, segment, vectorPrefix, disp8Scale)
+	if decodeErr != nil {
+		return Instr{}, 0, true, decodeErr
+	}
+
+	op := properties.op
+	if broadcast {
+		op += ".BCST"
+	}
+	if embeddedControl {
+		if properties.sae {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[vectorBits]
+		}
+	}
+	if zeroing {
+		op += ".Z"
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vectorPrefix, destinationNumber))}
+	args := []Operand{source}
+	if maskNumber != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", maskNumber))})
+	}
+	args = append(args, destination)
+	rawArgs := make([]string, len(args))
+	for index := range args {
+		rawArgs[index] = args[index].String()
+	}
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(rawArgs, ", ")),
+		x86Encoded: half || sqrt, x86SqrtEVEX: sqrt,
+		x86PackedNumericEVEX: properties.op == "VCVTDQ2PS",
+	}, modRMIndex + consumed, true, nil
+}
diff --git a/amd64_raw_same_width_conversion_test.go b/amd64_raw_same_width_conversion_test.go
new file mode 100644
index 000000000..48d98a08b
--- /dev/null
+++ b/amd64_raw_same_width_conversion_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type rawSameWidthConversionSpec struct {
+	opcode    byte
+	pp        byte
+	evexW     bool
+	op        Op
+	laneBytes int
+	sae       bool
+}
+
+var rawSameWidthConversionSpecs = []rawSameWidthConversionSpec{
+	{opcode: 0x5b, pp: 0, op: "VCVTDQ2PS", laneBytes: 4},
+	{opcode: 0x5b, pp: 1, op: "VCVTPS2DQ", laneBytes: 4},
+	{opcode: 0x5b, pp: 2, op: "VCVTTPS2DQ", laneBytes: 4, sae: true},
+	{opcode: 0x51, pp: 1, evexW: true, op: "VSQRTPD", laneBytes: 8},
+	{opcode: 0x51, pp: 0, op: "VSQRTPS", laneBytes: 4},
+}
+
+func encodeX86VEXSameWidthConversion(spec rawSameWidthConversionSpec, vex3, width256 bool, destination, source int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	if !vex3 {
+		vex1 := byte((1-(destination>>3)&1)<<7 | 15<<3 | int(l)<<2 | int(spec.pp))
+		return []byte{0xc5, vex1, spec.opcode, modRM}
+	}
+	vex0 := byte((1-(destination>>3)&1)<<7 | 1<<6 | (1-(source>>3)&1)<<5 | 1)
+	vex1 := byte(15<<3 | int(l)<<2 | int(spec.pp))
+	return []byte{0xc4, vex0, vex1, spec.opcode, modRM}
+}
+
+func encodeX86EVEXSameWidthConversion(spec rawSameWidthConversionSpec, vectorBits byte, broadcastOrControl, zeroing bool, mask, destination, source int) []byte {
+	p0 := byte((1-(destination>>3)&1)<<7 | (1-(source>>4)&1)<<6 | (1-(source>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 1)
+	p1 := byte(15<<3 | 1<<2 | int(spec.pp))
+	if spec.evexW {
+		p1 |= 0x80
+	}
+	p2 := byte(int(vectorBits)<<5 | 1<<3 | mask)
+	if broadcastOrControl {
+		p2 |= 0x10
+	}
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	return []byte{0x62, p0, p1, p2, spec.opcode, modRM}
+}
+
+func TestDecodedX86VEXSameWidthConversionCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawSameWidthConversionSpecs {
+		for _, vex3 := range []bool{false, true} {
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				sourceLimit := 16
+				if !vex3 {
+					sourceLimit = 8
+				}
+				for destination := 0; destination < 16; destination++ {
+					for source := 0; source < sourceLimit; source++ {
+						code := encodeX86VEXSameWidthConversion(spec, vex3, width256, destination, source)
+						got, length, ok, err := decodedX86SameWidthConversionInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{fmt.Sprintf("%s%d", prefix, source), fmt.Sprintf("%s%d", prefix, destination)}
+						if got.Op != spec.op || len(got.Args) != 2 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, spec.op, strings.Join(wantArgs, ", "))
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 3840 {
+		t.Fatalf("covered %d VEX same-width conversion encodings, want 3840", count)
+	}
+}
+
+func TestDecodedX86EVEXSameWidthConversionCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawSameWidthConversionSpecs {
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+			for destination := 0; destination < 32; destination++ {
+				for source := 0; source < 32; source++ {
+					code := encodeX86EVEXSameWidthConversion(spec, vectorBits, false, false, 1, destination, source)
+					got, length, ok, err := decodedX86SameWidthConversionInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantArgs := []string{fmt.Sprintf("%s%d", prefix, source), "K1", fmt.Sprintf("%s%d", prefix, destination)}
+					if got.Op != spec.op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+						t.Fatalf("decode %x = %+v, want %s %s", code, got, spec.op, strings.Join(wantArgs, ", "))
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 15360 {
+		t.Fatalf("covered %d EVEX same-width conversion encodings, want 15360", count)
+	}
+}
+
+func TestDecodedX86EVEXSameWidthConversionModifiersMemoryAndInvalid(t *testing.T) {
+	find := func(op Op) rawSameWidthConversionSpec {
+		t.Helper()
+		for _, spec := range rawSameWidthConversionSpecs {
+			if spec.op == op {
+				return spec
+			}
+		}
+		t.Fatalf("missing raw same-width spec %s", op)
+		return rawSameWidthConversionSpec{}
+	}
+	convert := find("VCVTDQ2PS")
+	truncate := find("VCVTTPS2DQ")
+	sqrt := find("VSQRTPD")
+	tests := []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{name: "vex weaviate", code: []byte{0xc5, 0xfc, 0x5b, 0xe4}, op: "VCVTDQ2PS", args: []string{"Y4", "Y4"}},
+		{name: "broadcast zeroing", code: []byte{0x62, 0xf1, 0x7c, 0xdb, 0x5b, 0x50, 0x7f}, op: "VCVTDQ2PS.BCST.Z", args: []string{"508(AX)", "K3", "Z2"}},
+		{name: "round up", code: encodeX86EVEXSameWidthConversion(convert, 2, true, false, 2, 4, 5), op: "VCVTDQ2PS.RU_SAE", args: []string{"Z5", "K2", "Z4"}},
+		{name: "truncate sae zeroing", code: encodeX86EVEXSameWidthConversion(truncate, 0, true, true, 3, 6, 7), op: "VCVTTPS2DQ.SAE.Z", args: []string{"Z7", "K3", "Z6"}},
+		{name: "sqrt round zero", code: encodeX86EVEXSameWidthConversion(sqrt, 3, true, false, 0, 8, 9), op: "VSQRTPD.RZ_SAE", args: []string{"Z9", "Z8"}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86SameWidthConversionInstruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+			if got.Op != test.op || len(got.Args) != len(test.args) {
+				t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+			}
+			for index := range test.args {
+				if got.Args[index].String() != test.args[index] {
+					t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+				}
+			}
+		})
+	}
+
+	zeroWithoutMask := encodeX86EVEXSameWidthConversion(convert, 0, false, true, 0, 0, 0)
+	reservedLength := encodeX86EVEXSameWidthConversion(convert, 3, false, false, 0, 0, 0)
+	wrongW := encodeX86EVEXSameWidthConversion(convert, 0, false, false, 0, 0, 0)
+	wrongW[2] |= 0x80
+	for _, code := range [][]byte{zeroWithoutMask, reservedLength, wrongW} {
+		if _, _, ok, err := decodedX86SameWidthConversionInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
diff --git a/amd64_raw_scalar_broadcast.go b/amd64_raw_scalar_broadcast.go
new file mode 100644
index 000000000..7d492e2c5
--- /dev/null
+++ b/amd64_raw_scalar_broadcast.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import "fmt"
+
+// Go's _yvbroadcastss/_yvbroadcastsd tables share the typed VEX/EVEX
+// prefix grammar. The scalar input width, output width and mask are separate
+// axes: SD has no 128-bit destination, and disp8 scales by scalar input size.
+func decodedX86ScalarBroadcastInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86ScalarBroadcastInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86ScalarBroadcastInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 2 || (p.opcode != 0x18 && p.opcode != 0x19) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar broadcast: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.pp != 1 || p.upper != 0 || p.broadcast {
+		return fail("reserved prefix, vvvv/V' or broadcast field")
+	}
+	double := p.opcode == 0x19
+	if p.vectorLength > 2 || double && p.vectorLength == 0 {
+		return fail("invalid vector width")
+	}
+	if p.evex {
+		if !p.fixed || p.w != double {
+			return fail("invalid EVEX fixed or width bit")
+		}
+	} else if p.w {
+		return fail("VEX.W must be zero")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	op, bytes := Op("VBROADCASTSS"), 4
+	if double {
+		op, bytes = "VBROADCASTSD", 8
+	}
+	var source Operand
+	var size int
+	var err error
+	if p.evex {
+		source, size, err = memory.evex(code[p.modRM:], mode, p.b, p.x, p.segment, "X", bytes)
+	} else {
+		source, size, err = memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	reg := int(code[p.modRM]>>3&7) + p.r*8
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", []string{"X", "Y", "Z"}[p.vectorLength], reg))}
+	args := []Operand{source, destination}
+	printed := source.String() + ", " + destination.String()
+	if p.mask != 0 {
+		mask := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))}
+		args = []Operand{source, mask, destination}
+		printed = source.String() + ", " + mask.String() + ", " + destination.String()
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, printed)}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_scalar_broadcast_test.go b/amd64_raw_scalar_broadcast_test.go
new file mode 100644
index 000000000..681aec420
--- /dev/null
+++ b/amd64_raw_scalar_broadcast_test.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RawScalarBroadcastGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Go 1.27 _yvbroadcastss has 2 VEX + 6 EVEX rows;
+	// _yvbroadcastsd has 1 VEX + 4 EVEX rows (no X destination).
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT broadcasts(SB),4,$0-0\n")
+			regs := []int{0, 7}
+			if arch == "amd64" {
+				regs = append(regs, 15, 16, 31)
+			}
+			for _, op := range []string{"VBROADCASTSS", "VBROADCASTSD"} {
+				for _, width := range []string{"X", "Y", "Z"} {
+					if op == "VBROADCASTSD" && width == "X" {
+						continue
+					}
+					for _, reg := range regs {
+						for _, input := range []string{fmt.Sprintf("X%d", reg), "(AX)", "16(BX)(CX*4)", "-64(SI)"} {
+							for _, form := range []struct{ suffix, mask string }{{"", ""}, {"", "K1,"}, {".Z", "K7,"}} {
+								fmt.Fprintf(&source, "%s%s %s,%s%s%d\n", op, form.suffix, input, form.mask, width, reg)
+							}
+						}
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+			file := x86RawUnprovedReturnFormProbeFile(t, arch, "broadcasts", code)
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-scalar-broadcast.ll", "raw-scalar-broadcast.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawScalarBroadcastEncodingAxes(t *testing.T) {
+	count := 0
+	for _, evex := range []bool{false, true} {
+		limit, widths := 16, 2
+		if evex {
+			limit, widths = 32, 3
+		}
+		for _, double := range []bool{false, true} {
+			for width := 0; width < widths; width++ {
+				if double && width == 0 {
+					continue
+				}
+				for src := 0; src < limit; src++ {
+					for dst := 0; dst < limit; dst++ {
+						mask, zero := 0, false
+						if evex {
+							mask = (src + dst) & 7
+							zero = mask != 0 && dst&1 != 0
+						}
+						code := encodeRawScalarMove(evex, 1, 0x10, src, 0, dst, mask, zero)
+						op, opcode := Op("VBROADCASTSS"), byte(0x18)
+						if double {
+							op, opcode = "VBROADCASTSD", 0x19
+						}
+						if evex {
+							code[1] = code[1]&0xf0 | 2
+							code[3] |= byte(width) << 5
+							code[4] = opcode
+							if double {
+								code[2] |= 0x80
+							}
+						} else {
+							code[1] = code[1]&0xe0 | 2
+							code[2] |= byte(width) << 2
+							code[3] = opcode
+						}
+						got, size, ok, err := decodedX86ScalarBroadcastInstruction(code, 64)
+						if zero {
+							op += ".Z"
+						}
+						args := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", src))}}
+						if mask != 0 {
+							args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+						}
+						args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", []string{"X", "Y", "Z"}[width], dst))})
+						if err != nil || !ok || size != len(code) || got.Op != op || !reflect.DeepEqual(got.Args, args) {
+							t.Fatalf("decode %x=%+v size=%d ok=%v err=%v; want %s %+v", code, got, size, ok, err, op, args)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 5888 {
+		t.Fatalf("tested %d encodings, want 5888", count)
+	}
+}
+
+func TestX86RawScalarBroadcastRejectsReservedEncodings(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc4, 0xe2, 0x79, 0x18},       // Missing ModRM.
+		{0xc4, 0xe2, 0x79, 0x18, 0x04}, // Missing SIB.
+		{0xc4, 0xe2, 0x79, 0x18, 0x45}, // Missing displacement.
+		{0xc4, 0xe2, 0x79, 0x19, 0xc0}, // SD has no 128-bit output.
+		{0xc4, 0xe2, 0xf9, 0x18, 0xc0}, // VEX.W must be zero.
+		{0xc4, 0xe2, 0x71, 0x18, 0xc0}, // Reserved vvvv.
+		{0x67, 0xc4, 0xe2, 0x79, 0x18, 0x00},
+		{0x62, 0xf2, 0x79, 0x08, 0x18, 0xc0}, // Missing EVEX fixed bit.
+		{0x62, 0xf2, 0xfd, 0x08, 0x18, 0xc0}, // SS W1.
+		{0x62, 0xf2, 0x7d, 0x28, 0x19, 0xc0}, // SD W0.
+		{0x62, 0xf2, 0x7d, 0x00, 0x18, 0xc0}, // Reserved V'.
+		{0x62, 0xf2, 0x7d, 0x68, 0x18, 0xc0}, // Reserved LL.
+		{0x62, 0xf2, 0x7d, 0x18, 0x18, 0xc0}, // Reserved EVEX.b.
+		{0x62, 0xf2, 0x7d, 0x88, 0x18, 0xc0}, // Zeroing with K0.
+	} {
+		if _, _, matched, err := decodedX86ScalarBroadcastInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x matched=%v err=%v", code, matched, err)
+		}
+	}
+}
+
+func TestX86ScalarBroadcastGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VBROADCASTSS", "VBROADCASTSD"} {
+			instructions := []string{op + " AX,Y0", op + " Y0,Y1", op + " X0,AX", op + " X0,K0,Y0", op + ".Z X0,Y0", op + ".SAE X0,Y0", op + " X0,K1,(AX)"}
+			if op == "VBROADCASTSD" {
+				instructions = append(instructions, op+" X0,X1")
+			}
+			if arch == "386" {
+				instructions = append(instructions, op+" X0,Z8")
+			}
+			for _, instruction := range instructions {
+				source := "TEXT invalidbroadcast(SB),4,$0-0\n" + instruction + "\nRET\n"
+				dir := t.TempDir()
+				name := filepath.Join(dir, "invalid.s")
+				if err := os.WriteFile(name, []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), name)
+				cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+				if output, err := cmd.CombinedOutput(); err == nil {
+					if instruction != op+".Z X0,Y0" || goToolchainAtLeast(runtime.Version(), 1, 27) {
+						t.Fatalf("Go %s accepted %s; repair the oracle expectation: %s", arch, instruction, output)
+					}
+					// Old Go accepts maskless .Z but emits a reserved EVEX
+					// zeroing/K0 encoding. Verify both that exact historical
+					// mismatch and the raw decoder's rejection, then require
+					// the named translator's rejection below too.
+					code := assembleX87ControlBytes(t, arch, source)
+					mode := 64
+					if arch == "386" {
+						mode = 32
+					}
+					p, prefixMatched := decodeX86RawVectorEncoding(code)
+					_, _, matched, err := decodedX86ScalarBroadcastInstruction(code, mode)
+					if !prefixMatched || !p.evex || !p.zero || p.mask != 0 || !matched || err == nil || !strings.Contains(err.Error(), "zeroing requires a nonzero mask") {
+						t.Fatalf("historical maskless .Z did not emit rejected EVEX zeroing/K0: %x %v", code, err)
+					}
+					t.Logf("%s/%s emits reserved zeroing/K0; both translators reject it", runtime.Version(), arch)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					continue
+				}
+				_, err = Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"invalidbroadcast": {Name: "invalidbroadcast", Ret: Void}}})
+				if err == nil {
+					t.Errorf("%s accepted Go-rejected %s", arch, instruction)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarBroadcastMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; separate five-target object tests are required")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, spec := range []struct {
+		op   string
+		bits int
+	}{{"VBROADCASTSS", 32}, {"VBROADCASTSD", 64}} {
+		for width, reg := range []string{"X0", "Y0", "Z0"} {
+			if spec.bits == 64 && width == 0 {
+				continue
+			}
+			for form := 0; form < 6; form++ {
+				name := fmt.Sprintf("broadcast%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ old+0(FP),BX\nMOVQ mem+8(FP),AX\nMOVQ out+16(FP),DI\nMOVQ mask+24(FP),CX\nKMOVQ CX,K7\nVMOVUPS (BX),Z0\n", name)
+				input := "(AX)"
+				if form >= 3 {
+					source.WriteString("VMOVUPS (AX),X1\n")
+					input = "X1"
+				}
+				op, mask := spec.op, ""
+				if form%3 != 0 {
+					mask = "K7,"
+				}
+				if form%3 == 2 {
+					op += ".Z"
+				}
+				fmt.Fprintf(&source, "%s %s,%s%s\nVMOVUPS Z0,(DI)\nVMOVUPS Y0,64(DI)\nVMOVUPS X0,96(DI)\nRET\n", op, input, mask, reg)
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1}}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *,uint64_t);\n", name)
+				faultcheck := 0
+				if form < 3 && form%3 != 0 {
+					faultcheck = 1
+				}
+				fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d,%d)) return %d;\n", name, 16<<width, spec.bits/8, form%3, faultcheck, index)
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+` + declarations.String() + `
+static int check(void (*fn)(const void *,const void *,void *,uint64_t),int bytes,int lane,int form,int faultcheck) {
+  uint64_t masks[]={0,1,2,UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX,UINT64_C(1)<<63};
+  for(int m=0;m<6;m++) {
+    _Alignas(64) uint8_t old[64],mem[16],out[112];
+    for(int i=0;i<64;i++) old[i]=(uint8_t)(197-i*3);
+    for(int i=0;i<16;i++) mem[i]=(uint8_t)(17+i*7);
+    uint64_t active=masks[m]&((UINT64_C(1)<<(bytes/lane))-1);
+    fn(old,faultcheck && !active ? 0 : mem,out,masks[m]);
+    for(int view=0;view<3;view++) for(int i=0;i<(64>>view);i++) {
+      int enabled=form==0 || ((masks[m]>>(i/lane))&1);
+      uint8_t want=i>=bytes ? 0 : enabled ? mem[i%lane] : form==2 ? 0 : old[i];
+      int offset=view==0 ? 0 : view==1 ? 64 : 96;
+      if(out[offset+i]!=want) {fprintf(stderr,"broadcast mismatch bytes=%d lane=%d form=%d mask=%d view=%d byte=%d\n",bytes,lane,form,m,view,i);return 1;}
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_broadcast", triple, ir, mainC, prefix)
+}
diff --git a/amd64_raw_scalar_extract_test.go b/amd64_raw_scalar_extract_test.go
new file mode 100644
index 000000000..fe211e74e
--- /dev/null
+++ b/amd64_raw_scalar_extract_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type rawPackedScalarExtractSpec struct {
+	op        Op
+	mapNumber byte
+	opcode    byte
+	width64   bool
+}
+
+var rawPackedScalarExtractSpecs = []rawPackedScalarExtractSpec{
+	{op: "VPEXTRB", mapNumber: 3, opcode: 0x14},
+	{op: "VPEXTRW", mapNumber: 3, opcode: 0x15},
+	{op: "VPEXTRW", mapNumber: 1, opcode: 0xc5},
+	{op: "VPEXTRD", mapNumber: 3, opcode: 0x16},
+	{op: "VPEXTRQ", mapNumber: 3, opcode: 0x16, width64: true},
+	{op: "VEXTRACTPS", mapNumber: 3, opcode: 0x17},
+}
+
+func encodeX86RawVEXPackedScalarExtract(spec rawPackedScalarExtractSpec, source, destination int, immediate byte) []byte {
+	p0 := byte((^source>>3)&1)<<7 | 0x40 | byte((^destination>>3)&1)<<5 | spec.mapNumber
+	p1 := byte(0x79)
+	if spec.width64 {
+		p1 |= 0x80
+	}
+	modRM := byte(0xc0 | source&7<<3 | destination&7)
+	return []byte{0xc4, p0, p1, spec.opcode, modRM, immediate}
+}
+
+func encodeX86RawEVEXPackedScalarExtract(spec rawPackedScalarExtractSpec, source, destination int, immediate byte) []byte {
+	p0 := byte((^source>>3)&1)<<7 |
+		0x40 |
+		byte((^destination>>3)&1)<<5 |
+		byte((^source>>4)&1)<<4 |
+		spec.mapNumber
+	p1 := byte(0x7d)
+	if spec.width64 {
+		p1 |= 0x80
+	}
+	modRM := byte(0xc0 | source&7<<3 | destination&7)
+	return []byte{0x62, p0, p1, 0x08, spec.opcode, modRM, immediate}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVEXTRACTPS(t *testing.T) {
+	// vmovss %xmm0, (%rdi); vextractps $1, %xmm0, 4(%rdi)
+	code := []byte{0xc5, 0xfa, 0x11, 0x07, 0xc4, 0xe3, 0x79, 0x17, 0x47, 0x04, 0x01}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VEXTRACTPS sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VMOVSS X0, 0(DI) ") || !strings.HasPrefix(decoded[1].Raw, "VEXTRACTPS $1, X0, 4(DI) ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawPackedScalarExtractCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawPackedScalarExtractSpecs {
+		for source := 0; source < 16; source++ {
+			for destination := 0; destination < 16; destination++ {
+				immediate := byte(source*16 + destination)
+				code := encodeX86RawVEXPackedScalarExtract(spec, source, destination, immediate)
+				got, length, ok, err := decodedX86PackedScalarExtractInstruction(code, 64)
+				want := fmt.Sprintf("%s $%d, X%d, %s", spec.op, immediate, source, mustDecodedX86GeneralRegister(t, destination))
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 16; destination++ {
+				immediate := byte(source*16 + destination)
+				code := encodeX86RawEVEXPackedScalarExtract(spec, source, destination, immediate)
+				got, length, ok, err := decodedX86PackedScalarExtractInstruction(code, 64)
+				want := fmt.Sprintf("%s $%d, X%d, %s", spec.op, immediate, source, mustDecodedX86GeneralRegister(t, destination))
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+	}
+	if count != 4608 {
+		t.Fatalf("covered %d packed scalar-extract register encodings, want 4608", count)
+	}
+}
+
+func TestDecodedX86RawPackedScalarExtractMemoryAndInvalidForms(t *testing.T) {
+	vexMemory := []byte{0xc4, 0x03, 0x79, 0x17, 0x7c, 0x8b, 0x01, 0xff}
+	got, length, ok, err := decodedX86PackedScalarExtractInstruction(vexMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VEXTRACTPS" || len(got.Args) != 3 || got.Args[1].String() != "X15" || got.Args[2].Kind != OpMem || !reflect.DeepEqual(got.Args[2].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+
+	evexMemory := []byte{0x62, 0x03, 0xfd, 0x08, 0x16, 0x7c, 0x8b, 0x02, 0x01}
+	got, length, ok, err = decodedX86PackedScalarExtractInstruction(evexMemory, 64)
+	wantMemory.Off = 16
+	if err != nil || !ok || length != len(evexMemory) || got.Op != "VPEXTRQ" || len(got.Args) != 3 || got.Args[1].String() != "X31" || got.Args[2].Kind != OpMem || !reflect.DeepEqual(got.Args[2].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexMemory, got, length, ok, err)
+	}
+
+	twoByteVEX := []byte{0xc5, 0xf9, 0xc5, 0xc1, 0x01}
+	got, length, ok, err = decodedX86PackedScalarExtractInstruction(twoByteVEX, 64)
+	if err != nil || !ok || length != len(twoByteVEX) || got.Raw != "VPEXTRW $1, X0, CX" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", twoByteVEX, got, length, ok, err)
+	}
+
+	validVEX := encodeX86RawVEXPackedScalarExtract(rawPackedScalarExtractSpecs[0], 7, 7, 1)
+	validEVEX := encodeX86RawEVEXPackedScalarExtract(rawPackedScalarExtractSpecs[0], 31, 15, 1)
+	for name, invalid := range map[string][]byte{
+		"vex reserved vvvv":        {validVEX[0], validVEX[1], validVEX[2] &^ 0x08, validVEX[3], validVEX[4], validVEX[5]},
+		"vex vector length":        {validVEX[0], validVEX[1], validVEX[2] | 0x04, validVEX[3], validVEX[4], validVEX[5]},
+		"evex mask":                {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 1, validEVEX[4], validEVEX[5], validEVEX[6]},
+		"evex vector length":       {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x20, validEVEX[4], validEVEX[5], validEVEX[6]},
+		"evex missing fixed bit":   {validEVEX[0], validEVEX[1], validEVEX[2] &^ 0x04, validEVEX[3], validEVEX[4], validEVEX[5], validEVEX[6]},
+		"truncated vex immediate":  validVEX[:len(validVEX)-1],
+		"truncated evex immediate": validEVEX[:len(validEVEX)-1],
+		"address override":         append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86PackedScalarExtractInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	if instruction, _, matched, decodeErr := decodedX86PackedScalarExtractInstruction(validEVEX, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 EVEX encoding %x decoded as %+v, ok=%v, err=%v", validEVEX, instruction, matched, decodeErr)
+	}
+	extended386 := encodeX86RawVEXPackedScalarExtract(rawPackedScalarExtractSpecs[0], 8, 0, 1)
+	if instruction, _, matched, decodeErr := decodedX86PackedScalarExtractInstruction(extended386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 extended encoding %x decoded as %+v, ok=%v, err=%v", extended386, instruction, matched, decodeErr)
+	}
+}
+
+func TestTranslateX86RawPackedScalarExtractTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name        string
+		goarch      string
+		triple      string
+		registerMax int
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", registerMax: 15},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registerMax: 15},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registerMax: 15},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu", registerMax: 7},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc", registerMax: 7},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_packed_scalar_extract(SB),NOSPLIT,$0-0\n")
+			for _, spec := range rawPackedScalarExtractSpecs {
+				code := encodeX86RawVEXPackedScalarExtract(spec, target.registerMax, target.registerMax, 1)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+				}
+				if target.goarch == "amd64" {
+					code = encodeX86RawEVEXPackedScalarExtract(spec, 31, 15, 1)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"raw_packed_scalar_extract": {Name: "raw_packed_scalar_extract", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-packed-scalar-extract-"+target.name+".ll", "raw-packed-scalar-extract-"+target.name+".o", ir)
+		})
+	}
+}
+
+func mustDecodedX86GeneralRegister(t *testing.T, number int) Reg {
+	t.Helper()
+	reg, ok := decodedX86GeneralRegister(number)
+	if !ok {
+		t.Fatalf("missing general register %d", number)
+	}
+	return reg
+}
diff --git a/amd64_raw_scalar_flag_compare.go b/amd64_raw_scalar_flag_compare.go
new file mode 100644
index 000000000..1f4c245a7
--- /dev/null
+++ b/amd64_raw_scalar_flag_compare.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import "fmt"
+
+// Go's four _yvcomisd entries share X/m,X and EVEX register-only SAE.
+// Prefix fields stay typed: EVEX.b means SAE here, never memory broadcast;
+// disp8 scales by the scalar width. VEX W and EVEX LL are ignored. Intel
+// SDM COMISS/UCOMISS explicitly warns that VEX.L=1 can behave unpredictably
+// across processor generations; decoder acceptance is not a portable opcode
+// contract and cannot authorize changing those original bytes to VEX.L=0.
+func decodedX86ScalarFlagCompareInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || (p.opcode != 0x2e && p.opcode != 0x2f) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar flag compare: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if (p.pp != 0 && p.pp != 1) || p.upper != 0 || p.mask != 0 || p.zero {
+		return fail("reserved prefix, vvvv/V', mask or zeroing field")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	double := p.pp == 1
+	if p.evex && (!p.fixed || p.w != double) {
+		return fail("invalid EVEX fixed or scalar width bit")
+	}
+	if p.broadcast && code[p.modRM]>>6 != 3 {
+		return fail("SAE requires a register source")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	op := Op("VCOMISS")
+	if p.opcode == 0x2e {
+		op = "VUCOMISS"
+	}
+	bytes := 4
+	if double {
+		op = op[:len(op)-1] + "D"
+		bytes = 8
+	}
+	if p.broadcast {
+		op += ".SAE"
+	}
+	var source Operand
+	var size int
+	var err error
+	if p.evex {
+		source, size, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", bytes)
+	} else {
+		source, size, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if !p.evex && p.vectorLength != 0 {
+		return Instr{}, 0, true, fmt.Errorf("%w: scalar flag comparison VEX.L=1 lacks a portable physical opcode contract", ErrProbeNeedsContext)
+	}
+	dst := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", int(code[p.modRM]>>3&7)+p.r*8))}
+	return Instr{Op: op, Args: []Operand{source, dst}, Raw: fmt.Sprintf("%s %s, %s", op, source.String(), dst.String()),
+		x86ScalarFlagCompareEVEX: p.evex,
+	}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_scalar_flag_compare_literal_test.go b/amd64_raw_scalar_flag_compare_literal_test.go
new file mode 100644
index 000000000..ce4362100
--- /dev/null
+++ b/amd64_raw_scalar_flag_compare_literal_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawScalarFlagCompareLiteral(op string, encoding string) []byte {
+	pp, opcode := 0, 0x2f
+	if strings.HasPrefix(op, "VU") {
+		opcode = 0x2e
+	}
+	width := 4
+	if strings.HasSuffix(op, "SD") {
+		pp, width = 1, 8
+	}
+	var code []byte
+	if encoding == "vex2" {
+		code = []byte{0xc5, byte(0xf8 | pp), byte(opcode), 0x05}
+	} else {
+		evex := encoding == "evex"
+		code = encodeRawScalarMove(evex, pp, opcode, 0, 0, 0, 0, false)
+		if evex && width == 8 {
+			code[2] |= 0x80
+		}
+		code[len(code)-1] = 0x05
+	}
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*37+21))
+	}
+	return code
+}
+
+func TestDecodeX86RawScalarFlagCompareRIPDataCompleteFamily(t *testing.T) {
+	for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, encoding := range []string{"vex2", "vex3", "evex"} {
+			name := op + "/" + encoding
+			t.Run(name, func(t *testing.T) {
+				code := x86RawScalarFlagCompareLiteral(op, encoding)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded) != 2 || decoded[0].Op != Op(op) ||
+					decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+					decoded[1].Op != OpRET {
+					t.Fatalf("decoded %x as %#v, want %s source-local scalar", code, decoded, op)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawScalarFlagCompareRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawScalarFlagCompareLiteral("VUCOMISD", "evex")
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+		"EVEX SAE memory": func(code []byte) []byte {
+			code[3] |= 0x10
+			return code
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawScalarFlagCompareRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	index := 0
+	for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, encoding := range []string{"vex2", "vex3", "evex"} {
+			code := x86RawScalarFlagCompareLiteral(op, encoding)
+			name := fmt.Sprintf("flagCompareLiteral%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range code {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+			width := 4
+			if strings.HasSuffix(op, "SD") {
+				width = 8
+			}
+			pools = append(pools, code[len(code)-width:])
+			index++
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sigs) != len(file.Funcs) || len(sigs) != 12 {
+		t.Fatal("complete original COMI RIP TEXT/declaration inventory changed")
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Supply only the missing X0 input in a separately named companion.
+	// Inserting before the complete original BYTE block preserves every raw
+	// byte, its RIP displacement, its terminal RET and all source-local data.
+	const header = "(SB),$0-0\n"
+	const initializedHeader = "(SB),$0-0\nPXOR X0,X0\n"
+	initialized := strings.ReplaceAll(source.String(), header, initializedHeader)
+	if strings.Count(source.String(), header) != 12 || strings.Count(initialized, "PXOR X0,X0\n") != 12 ||
+		strings.ReplaceAll(initialized, initializedHeader, header) != source.String() {
+		t.Fatal("initialized RIP companion changed more than each missing X0 producer")
+	}
+	var declarations strings.Builder
+	for _, function := range file.Funcs {
+		fmt.Fprintf(&declarations, "func %s()\n", function.Sym)
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86COMIOriginalFormatObject(t, source.String(), "amd64", triple)
+			x86COMICompileOriginalFormatObjects(t, llc, triple, "flag-compare-literal", ir)
+			x86COMIOriginalProducerObjects(t, initialized, declarations.String(), "amd64", triple)
+		})
+	}
+}
diff --git a/amd64_raw_scalar_flag_compare_test.go b/amd64_raw_scalar_flag_compare_test.go
new file mode 100644
index 000000000..68343beb1
--- /dev/null
+++ b/amd64_raw_scalar_flag_compare_test.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawScalarFlagCompareGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Go 1.27 _yvcomisd has one VEX and one EVEX X/m,X row for
+	// each of the four opcodes. Only EVEX register sources permit SAE.
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			regs := []int{0, 7}
+			if arch == "amd64" {
+				regs = append(regs, 8, 15, 16, 31)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT flagcompare(SB),4,$0-0\n")
+			for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+				for _, dst := range regs {
+					for _, src := range regs {
+						fmt.Fprintf(&source, "%s X%d,X%d\n%s.SAE X%d,X%d\n", op, src, dst, op, src, dst)
+					}
+					for _, mem := range []string{"(AX)", "12(BX)(CX*4)", "-32(SI)", "8192(DI)"} {
+						fmt.Fprintf(&source, "%s %s,X%d\n", op, mem, dst)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+			file := x86RawUnprovedReturnFormProbeFile(t, arch, "flagcompare", code)
+			triples := []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"}
+			if arch == "386" {
+				triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+			}
+			for _, triple := range triples {
+				// Retain the original named and byte-exact RET programs as
+				// uninitialized public Context, independently of the UD2 probe.
+				x86UnboundVoidFormatSource(t, source.String(), "flagcompare", arch, triple)
+				originalRaw := "TEXT flagcompare(SB),4,$0-0\n" + x86DwordProductDirectives(code)
+				x86UnboundVoidFormatSource(t, originalRaw, "flagcompare", arch, triple)
+				ir := x86COMIOriginalProbeFormatObject(t, file, arch, triple)
+				x86COMICompileOriginalFormatObjects(t, llc, triple, "raw-flag-compare", ir)
+			}
+			t.Logf("checked %d Go encodings", len(want)-1)
+		})
+	}
+}
+
+func TestX86RawScalarFlagCompareEncodingAxes(t *testing.T) {
+	count, contexts := 0, 0
+	for _, evex := range []bool{false, true} {
+		limit, variants := 16, 4 // WIG; L1 is an explicit source-context boundary.
+		if evex {
+			limit, variants = 32, 8 // EVEX.LL ignored, SAE on/off.
+		}
+		for _, double := range []bool{false, true} {
+			for _, unordered := range []bool{false, true} {
+				pp, opcode, op := 0, 0x2f, Op("VCOMISS")
+				if unordered {
+					opcode, op = 0x2e, "VUCOMISS"
+				}
+				if double {
+					pp, op = 1, op[:len(op)-1]+"D"
+				}
+				for src := 0; src < limit; src++ {
+					for dst := 0; dst < limit; dst++ {
+						for variant := 0; variant < variants; variant++ {
+							code := encodeRawScalarMove(evex, pp, opcode, src, 0, dst, 0, false)
+							wantOp := op
+							if evex {
+								code[2] &^= 0x80
+								if double {
+									code[2] |= 0x80
+								}
+								code[3] |= byte(variant&3) << 5
+								if variant&4 != 0 {
+									code[3] |= 0x10
+									wantOp += ".SAE"
+								}
+							} else {
+								code[2] |= byte(variant&1)<<2 | byte(variant>>1)<<7
+							}
+							got, size, matched, err := decodedX86ScalarFlagCompareInstruction(code, 64)
+							if !evex && variant&1 != 0 {
+								if !matched || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatalf("VEX.L1 lost physical opcode boundary: %x %v", code, err)
+								}
+								count++
+								contexts++
+								continue
+							}
+							want := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", src))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", dst))}}
+							if err != nil || !matched || size != len(code) || got.Op != wantOp || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x=%+v size=%d matched=%v err=%v; want %s %+v", code, got, size, matched, err, wantOp, want)
+							}
+							_, _, matched, err = decodedX86ScalarFlagCompareInstruction(code, 32)
+							if !matched || (err != nil) != (src >= 8 || dst >= 8) {
+								t.Fatalf("386 decode %x matched=%v err=%v", code, matched, err)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 36864 || contexts != 2048 {
+		t.Fatalf("tested %d encodings with %d VEX.L1 contexts, want 36864/2048", count, contexts)
+	}
+}
+
+func TestX86RawScalarFlagCompareInvalidAndMemoryForms(t *testing.T) {
+	for _, code := range [][]byte{nil, {0xc5}, {0xc4, 0xe2, 0x78, 0x2e, 0xc0}, {0xc5, 0xf8, 0x58, 0xc0}} {
+		if _, _, matched, _ := decodedX86ScalarFlagCompareInstruction(code, 64); matched {
+			t.Fatalf("matched unrelated encoding %x", code)
+		}
+	}
+	if _, _, matched, err := decodedX86ScalarFlagCompareInstruction([]byte{0xc5, 0xf8, 0x2e, 0xc0}, 16); !matched || err == nil {
+		t.Fatalf("accepted unsupported mode: matched=%v err=%v", matched, err)
+	}
+	for _, code := range [][]byte{
+		{0xc5, 0xf8, 0x2e},
+		{0xc5, 0xf8, 0x2e, 0x04}, // Missing SIB.
+		{0xc5, 0xf8, 0x2e, 0x45}, // Missing displacement.
+		{0xc5, 0xfa, 0x2e, 0xc0}, // Wrong pp.
+		{0xc5, 0xfb, 0x2e, 0xc0},
+		{0xc5, 0xf0, 0x2e, 0xc0}, // Reserved vvvv.
+		{0x67, 0xc5, 0xf8, 0x2e, 0x00},
+		{0x62, 0xf1, 0x78, 0x08, 0x2e, 0xc0}, // Missing fixed bit.
+		{0x62, 0xf1, 0xfc, 0x08, 0x2e, 0xc0}, // SS W1.
+		{0x62, 0xf1, 0x7d, 0x08, 0x2e, 0xc0}, // SD W0.
+		{0x62, 0xf1, 0x7c, 0x00, 0x2e, 0xc0}, // Reserved V'.
+		{0x62, 0xf1, 0x7c, 0x88, 0x2e, 0xc0}, // Zeroing.
+		{0x62, 0xf1, 0x7c, 0x09, 0x2e, 0xc0}, // Masking.
+		{0x62, 0xf1, 0x7c, 0x18, 0x2e, 0x00}, // SAE with memory.
+	} {
+		if _, _, matched, err := decodedX86ScalarFlagCompareInstruction(code, 64); !matched || err == nil {
+			t.Fatalf("accepted %x matched=%v err=%v", code, matched, err)
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		for _, double := range []bool{false, true} {
+			for _, evex := range []bool{false, true} {
+				code := []byte{segment.prefix, 0xc4, 0x01, 0x78, 0x2e, 0x64, 0x88, 0xf9}
+				wantOff, op := int64(-7), Op("VUCOMISS")
+				if double {
+					code[3] |= 1
+					op = "VUCOMISD"
+				}
+				if evex {
+					code = []byte{segment.prefix, 0x62, 0x01, 0x7c, 0x08, 0x2e, 0x64, 0x88, 0xf9}
+					wantOff *= 4
+					if double {
+						code[3] |= 0x81
+						wantOff *= 2
+					}
+				}
+				dst := Reg("X12")
+				if evex {
+					dst = "X28"
+				}
+				want := []Operand{{Kind: OpMem, Mem: MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: wantOff}}, {Kind: OpReg, Reg: dst}}
+				got, size, matched, err := decodedX86ScalarFlagCompareInstruction(code, 64)
+				if err != nil || !matched || size != len(code) || got.Op != op || !reflect.DeepEqual(got.Args, want) {
+					t.Fatalf("decode %x=%+v %v; want %s %+v", code, got, err, op, want)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFlagCompareGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+			for _, args := range []string{" Y0,X1", " X0,Y1", " Z0,X1", " (AX),(BX)", " X0,K1,X1", ".Z X0,X1", ".BCST (AX),X1", ".SAE (AX),X1", ".RN_SAE X0,X1"} {
+				line := op + args
+				source := "TEXT rejected(SB),4,$0-0\n" + line + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"rejected": {Name: "rejected", Ret: Void}}}); err == nil {
+					t.Fatalf("translator accepted %s for %s", line, arch)
+				}
+			}
+		}
+	}
+}
+
+func x86COMIRawNativeCompare(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	source, sigs, mainC, _ := x86COMIRawNativeFixture(t)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%v", optimized), func(t *testing.T) {
+			input := ir
+			if optimized {
+				input = x86MulDivRoundOptimize(t, input)
+			}
+			for _, backend := range []string{"-O0", "-O2"} {
+				t.Run("backend"+backend, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "raw-comi", input, mainC, backend)
+				})
+			}
+		})
+	}
+}
+
+func x86COMIRawNativeFixture(t *testing.T) (string, map[string]FuncSig, string, int) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, reg := range []int{0, 16} {
+			for _, form := range []string{"register", "memory", "sae"} {
+				name := fmt.Sprintf("flagcompare%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ out+16(FP),DI\nVMOVUPS (AX),Z%d\nVMOVUPS (BX),Z%d\nMOVL $2147483647,CX\nADDL $1,CX\n", name, reg, reg+1)
+				input, suffix := fmt.Sprintf("X%d", reg+1), ""
+				if form == "memory" {
+					input = "(BX)"
+				}
+				if form == "sae" {
+					suffix = ".SAE"
+				}
+				code := assembleX87ControlBytes(t, "amd64", fmt.Sprintf("TEXT probe(SB),4,$0-0\n%s%s %s,X%d\nRET\n", op, suffix, input, reg))
+				for _, b := range code[:len(code)-1] {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+				}
+				source.WriteString("SETEQ (DI)\nSETCS 1(DI)\nSETPS 2(DI)\nSETMI 3(DI)\nSETOS 4(DI)\n")
+				fmt.Fprintf(&source, "VMOVUPS Z%d,8(DI)\nVMOVUPS Z%d,72(DI)\nRET\n", reg, reg+1)
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", name)
+				double := 0
+				if strings.HasSuffix(op, "SD") {
+					double = 1
+				}
+				fmt.Fprintf(&checks, "if(check(%s,%d)) return %d;\n", name, double, index)
+			}
+		}
+	}
+	// Compare EFLAGS with native UCOMIS{S,D}. This oracle checks comparison,
+	// NaN, signed-zero and register-preservation semantics, not MXCSR exception
+	// delivery or SAE suppression, which require a separate floating-state audit.
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static const uint64_t doubles[]={0,0x8000000000000000ULL,0x3ff0000000000000ULL,0xbff0000000000000ULL,0x4004000000000000ULL,0xc004000000000000ULL,0x7ff0000000000000ULL,0xfff0000000000000ULL,0x7ff8000000000001ULL,0x7ff0000000000001ULL,1,0x7fefffffffffffffULL};
+static const uint32_t singles[]={0,0x80000000,0x3f800000,0xbf800000,0x40200000,0xc0200000,0x7f800000,0xff800000,0x7fc00001,0x7f800001,1,0x7f7fffff};
+static int check(void (*fn)(const void *,const void *,void *),int isDouble) {
+ for(int i=0;i<12;i++) for(int j=0;j<12;j++) {
+  uint8_t a[64],b[64],out[136]={0},want[5];
+  for(int k=0;k<64;k++) {a[k]=(uint8_t)(k*7+91);b[k]=(uint8_t)(k*31+5);}
+  if(isDouble) {
+   double x,y;memcpy(a,&doubles[i],8);memcpy(b,&doubles[j],8);memcpy(&x,a,8);memcpy(&y,b,8);
+   __asm__ volatile("ucomisd %6,%5; sete %0; setb %1; setp %2; sets %3; seto %4":"=qm"(want[0]),"=qm"(want[1]),"=qm"(want[2]),"=qm"(want[3]),"=qm"(want[4]):"x"(x),"x"(y):"cc");
+  } else {
+   float x,y;memcpy(a,&singles[i],4);memcpy(b,&singles[j],4);memcpy(&x,a,4);memcpy(&y,b,4);
+   __asm__ volatile("ucomiss %6,%5; sete %0; setb %1; setp %2; sets %3; seto %4":"=qm"(want[0]),"=qm"(want[1]),"=qm"(want[2]),"=qm"(want[3]),"=qm"(want[4]):"x"(x),"x"(y):"cc");
+  }
+  fn(a,b,out);
+  if(memcmp(out,want,5)||memcmp(out+8,a,64)||memcmp(out+72,b,64)) {
+   fprintf(stderr,"flag compare mismatch double=%d i=%d j=%d\n",isDouble,i,j);return 1;
+  }
+ }
+ return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	return source.String(), sigs, mainC, index
+}
diff --git a/amd64_raw_scalar_float_to_int.go b/amd64_raw_scalar_float_to_int.go
new file mode 100644
index 000000000..60a7c82bd
--- /dev/null
+++ b/amd64_raw_scalar_float_to_int.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import "fmt"
+
+// Decode the complete Go 1.27 scalar floating-point-to-GP family. Signed
+// forms have VEX and EVEX encodings; unsigned forms are EVEX-only. The named
+// lowerer and this decoder share amd64ScalarFloatToIntSpecs so W, F2/F3,
+// truncation, and signedness cannot drift between the two entry points.
+func decodedX86ScalarFloatToIntegerInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || (p.pp != 2 && p.pp != 3) {
+		return Instr{}, 0, false, nil
+	}
+	if p.opcode != 0x2c && p.opcode != 0x2d && p.opcode != 0x78 && p.opcode != 0x79 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar float-to-integer: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	unsigned := p.opcode == 0x78 || p.opcode == 0x79
+	truncating := p.opcode == 0x2c || p.opcode == 0x78
+	if unsigned && !p.evex {
+		return fail("unsigned conversion requires EVEX")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.upper != 0 {
+		return fail("reserved vvvv/V' field")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register encoding in 32-bit mode")
+	}
+	if p.evex {
+		if !p.fixed || p.mask != 0 || p.zero || p.r >= 2 {
+			return fail("invalid EVEX fixed, mask, zeroing or GP extension field")
+		}
+		if p.broadcast && code[p.modRM]>>6 != 3 {
+			return fail("SAE or embedded rounding requires register source")
+		}
+		// EVEX.L'L is ignored without embedded rounding (and for CVTT SAE).
+		// Unlike VEX.L=1, Intel defines these as LLIG encodings.
+	} else if p.vectorLength != 0 {
+		return fail("scalar conversion requires VEX.128")
+	}
+
+	inputBits := 32
+	if p.pp == 3 {
+		inputBits = 64
+	}
+	outputBits := 32
+	if p.w {
+		outputBits = 64
+	}
+	var op Op
+	for name, spec := range amd64ScalarFloatToIntSpecs {
+		if spec.vector && spec.inputBits == inputBits && spec.outputBits == outputBits &&
+			spec.truncating == truncating && spec.unsigned == unsigned {
+			op = name
+			break
+		}
+	}
+	if op == "" {
+		return fail("encoding has no Go scalar conversion form")
+	}
+	if p.evex && p.broadcast {
+		if truncating {
+			op += ".SAE"
+		} else {
+			op += [...]Op{".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE"}[p.vectorLength]
+		}
+	}
+	var source Operand
+	var consumed int
+	var err error
+	if p.evex {
+		source, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", inputBits/8)
+	} else {
+		source, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destinationNumber := int(code[p.modRM]>>3&7) + (p.r&1)*8
+	destinationReg, valid := decodedX86GeneralRegister(destinationNumber)
+	if !valid {
+		return fail("invalid GP destination")
+	}
+	destination := Operand{Kind: OpReg, Reg: destinationReg}
+	instruction := Instr{
+		Op:                        op,
+		Args:                      []Operand{source, destination},
+		Raw:                       fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+		x86ScalarFloatIntegerEVEX: p.evex,
+	}
+	arch := "amd64"
+	if mode == 32 {
+		arch = "386"
+	}
+	_, _, err = x86ScalarFloatIntegerProperties(instruction, arch)
+	return instruction, p.modRM + consumed, true, err
+}
diff --git a/amd64_raw_scalar_float_to_int_test.go b/amd64_raw_scalar_float_to_int_test.go
new file mode 100644
index 000000000..53126f7f1
--- /dev/null
+++ b/amd64_raw_scalar_float_to_int_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func rawScalarFloatToIntBytes(spec amd64ScalarFloatToIntSpec, memory, evex bool) []byte {
+	opcode := byte(0x2d)
+	if spec.truncating {
+		opcode = 0x2c
+	}
+	if spec.unsigned {
+		opcode = 0x79
+		if spec.truncating {
+			opcode = 0x78
+		}
+	}
+	pp := byte(2) // F3: single precision.
+	if spec.inputBits == 64 {
+		pp = 3 // F2: double precision.
+	}
+	modRM := byte(0xc1) // X1 -> AX.
+	if memory {
+		modRM = 0x08 // (AX) -> CX.
+	}
+	if evex {
+		p1 := byte(0x7c) | pp
+		if spec.outputBits == 64 {
+			p1 |= 0x80
+		}
+		return []byte{0x62, 0xf1, p1, 0x08, opcode, modRM}
+	}
+	if spec.outputBits == 64 {
+		return []byte{0xc4, 0xe1, 0xf8 | pp, opcode, modRM}
+	}
+	return []byte{0xc5, 0xf8 | pp, opcode, modRM}
+}
+
+func TestX86RawScalarFloatToIntegerCompleteGo127Family(t *testing.T) {
+	count := 0
+	for op, spec := range amd64ScalarFloatToIntSpecs {
+		if !spec.vector {
+			continue
+		}
+		for _, evex := range []bool{false, true} {
+			if spec.unsigned && !evex {
+				continue // Go has no unsigned VEX encoding.
+			}
+			for _, memory := range []bool{false, true} {
+				name := fmt.Sprintf("%s/evex=%t/memory=%t", op, evex, memory)
+				t.Run(name, func(t *testing.T) {
+					code := rawScalarFloatToIntBytes(spec, memory, evex)
+					fn := Func{}
+					for _, value := range code {
+						fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+					}
+					got, err := decodeX86RawDirectives(fn, "amd64")
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(got.Instrs) != 1 || got.Instrs[0].Op != op || len(got.Instrs[0].Args) != 2 {
+						t.Fatalf("decoded %#x as %#v, want %s", code, got.Instrs, op)
+					}
+					wantSource := Operand{Kind: OpReg, Reg: "X1"}
+					wantDestination := AX
+					if memory {
+						wantSource = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+						wantDestination = CX
+					}
+					args := got.Instrs[0].Args
+					if args[0].Kind != wantSource.Kind || args[0].Reg != wantSource.Reg || args[0].Mem != wantSource.Mem || args[1].Reg != wantDestination {
+						t.Fatalf("decoded %#x operands as %#v, want %+v, %s", code, args, wantSource, wantDestination)
+					}
+				})
+				count++
+			}
+		}
+	}
+	if count != 48 {
+		t.Fatalf("tested %d raw VEX/EVEX forms, want 48", count)
+	}
+}
+
+func TestX86RawScalarFloatToIntegerRoundingAndEncodingAxes(t *testing.T) {
+	base := []byte{0x62, 0xf1, 0x7f, 0x08, 0x2d, 0xc1}
+	for _, tc := range []struct {
+		name string
+		p2   byte
+		want Op
+	}{
+		{"round-nearest", 0x18, "VCVTSD2SI.RN_SAE"},
+		{"round-down", 0x38, "VCVTSD2SI.RD_SAE"},
+		{"round-up", 0x58, "VCVTSD2SI.RU_SAE"},
+		{"round-zero", 0x78, "VCVTSD2SI.RZ_SAE"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			code := append([]byte(nil), base...)
+			code[3] = tc.p2
+			got, length, recognized, err := decodedX86ScalarFloatToIntegerInstruction(code, 64)
+			if !recognized || err != nil || length != len(code) || got.Op != tc.want {
+				t.Fatalf("decode %#x = %+v, %d, %v, %v; want %s", code, got, length, recognized, err, tc.want)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		want Op
+		src  Reg
+		dst  Reg
+	}{
+		{"signed-SAE", []byte{0x62, 0xf1, 0x7f, 0x18, 0x2c, 0xc1}, "VCVTTSD2SI.SAE", "X1", AX},
+		{"unsigned-SAE", []byte{0x62, 0xf1, 0x7f, 0x18, 0x78, 0xc1}, "VCVTTSD2USIL.SAE", "X1", AX},
+		{"extended-vector", []byte{0x62, 0xb1, 0x7f, 0x08, 0x78, 0xc1}, "VCVTTSD2USIL", "X17", AX},
+		{"extended-GP", []byte{0x62, 0x71, 0x7f, 0x08, 0x78, 0xc1}, "VCVTTSD2USIL", "X1", "R8"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, recognized, err := decodedX86ScalarFloatToIntegerInstruction(tc.code, 64)
+			if !recognized || err != nil || length != len(tc.code) || got.Op != tc.want ||
+				got.Args[0].Reg != tc.src || got.Args[1].Reg != tc.dst {
+				t.Fatalf("decode %#x = %+v, %d, %v, %v; want %s %s, %s", tc.code, got, length, recognized, err, tc.want, tc.src, tc.dst)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		off  int64
+	}{
+		{"SS-disp8-scale", []byte{0x62, 0xf1, 0x7e, 0x08, 0x79, 0x48, 0x02}, 8},
+		{"SD-disp8-scale", []byte{0x62, 0xf1, 0x7f, 0x08, 0x79, 0x48, 0x02}, 16},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, _, recognized, err := decodedX86ScalarFloatToIntegerInstruction(tc.code, 64)
+			if !recognized || err != nil || got.Args[0].Kind != OpMem || got.Args[0].Mem.Off != tc.off {
+				t.Fatalf("decode %#x = %+v, %v, %v; want displacement %d", tc.code, got, recognized, err, tc.off)
+			}
+		})
+	}
+}
+
+func TestX86RawScalarFloatToIntegerRejectsReservedEncodings(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"VEX-vector-length", []byte{0xc5, 0xff, 0x2c, 0xc1}, 64},
+		{"VEX-vvvv", []byte{0xc5, 0xeb, 0x2c, 0xc1}, 64},
+		{"EVEX-mask", []byte{0x62, 0xf1, 0x7f, 0x09, 0x2c, 0xc1}, 64},
+		{"EVEX-zero", []byte{0x62, 0xf1, 0x7f, 0x88, 0x2c, 0xc1}, 64},
+		{"EVEX-vvvv", []byte{0x62, 0xf1, 0x6f, 0x08, 0x2c, 0xc1}, 64},
+		{"EVEX-SAE-memory", []byte{0x62, 0xf1, 0x7f, 0x18, 0x2c, 0x00}, 64},
+		{"address-override", []byte{0x67, 0xc5, 0xfb, 0x2c, 0xc1}, 64},
+		{"missing-ModRM", []byte{0xc5, 0xfb, 0x2c}, 64},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86ScalarFloatToIntegerInstruction(tc.code, tc.mode); !recognized || err == nil {
+				t.Fatalf("reserved encoding %#x: recognized=%v error=%v", tc.code, recognized, err)
+			}
+		})
+	}
+}
+
+func TestX86RawScalarFloatToIntegerCompilesEveryGoForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawscalarconvert(SB),4,$0-0\n")
+			for _, spec := range amd64ScalarFloatToIntSpecs {
+				if !spec.vector {
+					continue
+				}
+				for _, evex := range []bool{false, true} {
+					if spec.unsigned && !evex {
+						continue
+					}
+					for _, memory := range []bool{false, true} {
+						for _, value := range rawScalarFloatToIntBytes(spec, memory, evex) {
+							fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+						}
+						source.WriteString("\tNOP\n")
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-scalar-convert.ll", "raw-scalar-convert.o", ir)
+		})
+	}
+}
+
+func x86RawScalarFloatToIntegerNativeRuntime(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareEVEX)
+	const source = `TEXT rawfloattointsemantics(SB),4,$0-16
+	MOVQ input+0(FP), BX
+	MOVQ out+8(FP), DI
+	BYTE $0xc5; BYTE $0xfb; BYTE $0x2c; BYTE $0x03
+	MOVL AX, 0(DI)
+	BYTE $0xc5; BYTE $0xfb; BYTE $0x2d; BYTE $0x03
+	MOVL AX, 4(DI)
+	BYTE $0x62; BYTE $0xf1; BYTE $0x7f; BYTE $0x08; BYTE $0x78; BYTE $0x03
+	MOVL AX, 8(DI)
+	BYTE $0x62; BYTE $0xf1; BYTE $0x7f; BYTE $0x08; BYTE $0x79; BYTE $0x03
+	MOVL AX, 12(DI)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "amd64", TargetTriple: execution.triple,
+		Sigs: map[string]FuncSig{"rawfloattointsemantics": {
+			Name: "rawfloattointsemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloattointsemantics(const double *, uint32_t *);
+int main(void) {
+  double input = 2.75;
+  uint32_t out[4] = {0};
+  rawfloattointsemantics(&input, out);
+  if (out[0] != 2) return 1;
+  if (out[1] != 3) return 2;
+  if (out[2] != 2) return 3;
+  if (out[3] != 3) return 4;
+  return 0;
+}
+`
+	execution.compileAndRunLLVM(t, "raw-float-to-integer", ir, mainC, "-O2")
+}
diff --git a/amd64_raw_scalar_integer_float_test.go b/amd64_raw_scalar_integer_float_test.go
new file mode 100644
index 000000000..0a5ddc014
--- /dev/null
+++ b/amd64_raw_scalar_integer_float_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXScalarIntegerFloat(pp byte, width64, vex3 bool, destination, passthrough, source int) []byte {
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	if !vex3 {
+		vex1 := byte((1-(destination>>3)&1)<<7 | (^passthrough&15)<<3 | int(pp))
+		return []byte{0xc5, vex1, 0x2a, modRM}
+	}
+	vex0 := byte((1-(destination>>3)&1)<<7 | 1<<6 | (1-(source>>3)&1)<<5 | 1)
+	vex1 := byte((^passthrough&15)<<3 | int(pp))
+	if width64 {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, 0x2a, modRM}
+}
+
+func encodeX86EVEXScalarIntegerFloat(unsigned bool, pp byte, width64 bool, vectorBits byte, rounding bool, destination, passthrough, source int) []byte {
+	opcode := byte(0x2a)
+	if unsigned {
+		opcode = 0x7b
+	}
+	p0 := byte((1-(destination>>3)&1)<<7 | 1<<6 | (1-(source>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 1)
+	p1 := byte((^passthrough&15)<<3 | 1<<2 | int(pp))
+	if width64 {
+		p1 |= 0x80
+	}
+	p2 := byte(int(vectorBits)<<5 | (^passthrough>>4&1)<<3)
+	if rounding {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func scalarIntegerFloatRawOp(unsigned bool, pp byte, width64 bool) Op {
+	prefix := "VCVTSI2"
+	if unsigned {
+		prefix = "VCVTUSI2"
+	}
+	result := "SS"
+	if pp == 3 {
+		result = "SD"
+	}
+	source := "L"
+	if width64 {
+		source = "Q"
+	}
+	return Op(prefix + result + source)
+}
+
+func TestTranslateRawVEXScalarIntegerFloatWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawScalarIntegerFloat(SB), $0-0
+	LONG $0xc82aeac5
+	LONG $0xc02a9ac5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawScalarIntegerFloat": {Name: "rawScalarIntegerFloat", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Count(ir, "call float @llvm.experimental.constrained.sitofp.f32.i32") != 2 {
+		t.Fatalf("raw VCVTSI2SSL lowering omitted signed conversions:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-scalar-integer-float.ll", "amd64-raw-scalar-integer-float.o", ir)
+}
+
+func TestDecodedX86VEXScalarIntegerFloatCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, pp := range []byte{2, 3} {
+		for destination := 0; destination < 16; destination++ {
+			for passthrough := 0; passthrough < 16; passthrough++ {
+				for source := 0; source < 8; source++ {
+					code := encodeX86VEXScalarIntegerFloat(pp, false, false, destination, passthrough, source)
+					assertDecodedX86ScalarIntegerFloat(t, code, scalarIntegerFloatRawOp(false, pp, false), destination, passthrough, source, "")
+					count++
+				}
+			}
+		}
+		for _, width64 := range []bool{false, true} {
+			for destination := 0; destination < 16; destination++ {
+				for passthrough := 0; passthrough < 16; passthrough++ {
+					for source := 0; source < 16; source++ {
+						code := encodeX86VEXScalarIntegerFloat(pp, width64, true, destination, passthrough, source)
+						assertDecodedX86ScalarIntegerFloat(t, code, scalarIntegerFloatRawOp(false, pp, width64), destination, passthrough, source, "")
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 20480 {
+		t.Fatalf("covered %d VEX scalar integer-to-float encodings, want 20480", count)
+	}
+}
+
+func TestDecodedX86EVEXScalarIntegerFloatCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, unsigned := range []bool{false, true} {
+		for _, pp := range []byte{2, 3} {
+			for _, width64 := range []bool{false, true} {
+				for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+					for destination := 0; destination < 32; destination++ {
+						for passthrough := 0; passthrough < 32; passthrough++ {
+							for source := 0; source < 16; source++ {
+								code := encodeX86EVEXScalarIntegerFloat(unsigned, pp, width64, vectorBits, false, destination, passthrough, source)
+								assertDecodedX86ScalarIntegerFloat(t, code, scalarIntegerFloatRawOp(unsigned, pp, width64), destination, passthrough, source, "")
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 393216 {
+		t.Fatalf("covered %d EVEX scalar integer-to-float encodings, want 393216", count)
+	}
+}
+
+func TestDecodedX86EVEXScalarIntegerFloatRoundingMemoryAndInvalid(t *testing.T) {
+	for vectorBits, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+		code := encodeX86EVEXScalarIntegerFloat(false, 2, true, byte(vectorBits), true, 17, 18, 9)
+		assertDecodedX86ScalarIntegerFloat(t, code, "VCVTSI2SSQ."+Op(suffix), 17, 18, 9, "")
+	}
+	memory := []byte{0x62, 0xe1, 0xff, 0x00, 0x2a, 0x60, 0x02}
+	got, length, ok, err := decodedX86ScalarIntegerFloatInstruction(memory, 64)
+	if err != nil || !ok || length != len(memory) || got.Op != "VCVTSI2SDQ" || len(got.Args) != 3 || got.Args[0].String() != "16(AX)" || got.Args[1].String() != "X16" || got.Args[2].String() != "X20" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", memory, got, length, ok, err)
+	}
+
+	roundingMemory := encodeX86EVEXScalarIntegerFloat(false, 2, true, 0, true, 0, 0, 0)
+	roundingMemory[len(roundingMemory)-1] = 0
+	nonRounding := encodeX86EVEXScalarIntegerFloat(false, 3, false, 0, true, 0, 0, 0)
+	invalid := [][]byte{
+		encodeX86VEXScalarIntegerFloat(1, false, false, 0, 0, 0),
+		encodeX86EVEXScalarIntegerFloat(false, 2, false, 3, false, 0, 0, 0),
+		roundingMemory,
+		nonRounding,
+	}
+	for _, code := range invalid {
+		if _, _, ok, err := decodedX86ScalarIntegerFloatInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
+
+func assertDecodedX86ScalarIntegerFloat(t *testing.T, code []byte, op Op, destination, passthrough, source int, sourceText string) {
+	t.Helper()
+	got, length, ok, err := decodedX86ScalarIntegerFloatInstruction(code, 64)
+	if err != nil || !ok || length != len(code) {
+		t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+	if sourceText == "" {
+		sourceText = decodedX86ScalarIntegerFloatTestRegister(source)
+	}
+	wantArgs := []string{sourceText, fmt.Sprintf("X%d", passthrough), fmt.Sprintf("X%d", destination)}
+	if got.Op != op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+		t.Fatalf("decode %x = %+v, want %s %s", code, got, op, strings.Join(wantArgs, ", "))
+	}
+}
+
+func decodedX86ScalarIntegerFloatTestRegister(number int) string {
+	register, ok := decodedX86GeneralRegister(number)
+	if !ok {
+		return fmt.Sprintf("invalid%d", number)
+	}
+	return string(register)
+}
diff --git a/amd64_raw_scalar_move.go b/amd64_raw_scalar_move.go
new file mode 100644
index 000000000..944e5d004
--- /dev/null
+++ b/amd64_raw_scalar_move.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// x86RawVectorEncoding separates the shared VEX/EVEX prefix axes from a
+// family's operand grammar. Register numbers are decoded (not complemented).
+type x86RawVectorEncoding struct {
+	modRM, mapNumber, pp, opcode int
+	r, x, b, upper               int
+	vectorLength, mask           int
+	evex, w, zero, broadcast     bool
+	fixed, addressOverride       bool
+	segment                      Reg
+}
+
+func decodeX86RawVectorEncoding(code []byte) (p x86RawVectorEncoding, ok bool) {
+	i := 0
+	for i < len(code) {
+		switch code[i] {
+		case 0x64:
+			p.segment = FS
+		case 0x65:
+			p.segment = GS
+		case 0x67:
+			p.addressOverride = true
+		default:
+			goto vector
+		}
+		i++
+	}
+	return p, false
+vector:
+	if i >= len(code) {
+		return p, false
+	}
+	var bits byte
+	switch code[i] {
+	case 0xc5:
+		if len(code) < i+3 {
+			return p, false
+		}
+		bits = code[i+1]
+		p.r, p.mapNumber, p.modRM = int(^bits>>7)&1, 1, i+3
+	case 0xc4:
+		if len(code) < i+4 {
+			return p, false
+		}
+		first := code[i+1]
+		bits = code[i+2]
+		p.r, p.x, p.b = int(^first>>7)&1, int(^first>>6)&1, int(^first>>5)&1
+		p.mapNumber, p.modRM, p.w = int(first&31), i+4, bits&0x80 != 0
+	case 0x62:
+		if len(code) < i+5 {
+			return p, false
+		}
+		first, last := code[i+1], code[i+3]
+		bits = code[i+2]
+		p.evex, p.w, p.fixed = true, bits&0x80 != 0, bits&4 != 0
+		p.r, p.x, p.b = (int(^first>>7)&1)|(int(^first>>4)&1)<<1, int(^first>>6)&1, int(^first>>5)&1
+		p.mapNumber, p.modRM = int(first&15), i+5
+		p.vectorLength, p.mask = int(last>>5)&3, int(last&7)
+		p.zero, p.broadcast = last&0x80 != 0, last&0x10 != 0
+		p.upper = (int(^last>>3) & 1) << 4
+	default:
+		return p, false
+	}
+	p.opcode, p.pp = int(code[p.modRM-1]), int(bits&3)
+	p.upper |= int(^bits>>3) & 15
+	if !p.evex {
+		p.vectorLength = int(bits>>2) & 1
+	}
+	return p, true
+}
+
+// Go's _yvmovsd grammar is shared by VMOVSS and VMOVSD. Opcodes 10 and 11
+// both encode three-register merges; memory forms reserve vvvv and EVEX V'.
+func decodedX86ScalarMoveInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || (p.opcode != 0x10 && p.opcode != 0x11) {
+		return Instr{}, 0, false, nil
+	}
+	fp16 := p.evex && p.mapNumber == 5 && p.pp == 2
+	if !fp16 && (p.mapNumber != 1 || (p.pp != 2 && p.pp != 3)) {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar move: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	// EVEX VMOVSH is LLIG; VMOVSS/SD reserve every nonzero length.
+	if (!fp16 && p.vectorLength != 0) || p.broadcast {
+		return fail("scalar moves require 128-bit encoding without broadcast/rounding")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	spec := map[int]struct {
+		op    Op
+		bytes int
+	}{2: {"VMOVSS", 4}, 3: {"VMOVSD", 8}}[p.pp]
+	if fp16 {
+		spec.op, spec.bytes = "VMOVSH", 2
+	}
+	if p.evex && (!p.fixed || p.w != (spec.bytes == 8)) {
+		return fail("invalid EVEX fixed or width bit")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	registerForm := code[p.modRM]>>6 == 3
+	if !registerForm && p.upper != 0 {
+		return fail("memory forms reserve vvvv and V'")
+	}
+	store := p.opcode == 0x11
+	if store && !registerForm && p.zero {
+		return fail("memory stores cannot zero-mask")
+	}
+	regNumber := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (regNumber >= 8 || p.upper >= 8 || p.b != 0 || p.x != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	var rm Operand
+	var consumed int
+	var err error
+	if p.evex {
+		rm, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", spec.bytes)
+	} else {
+		rm, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	reg := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", regNumber))}
+	source, destination := rm, reg
+	if store {
+		source, destination = reg, rm
+	}
+	args := []Operand{source}
+	if registerForm {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))})
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, destination)
+	op := spec.op
+	if p.zero {
+		op += ".Z"
+	}
+	printed := make([]string, len(args))
+	for i := range args {
+		printed[i] = args[i].String()
+	}
+	return Instr{
+		Op: op, Args: args,
+		Raw:        fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+		x86Encoded: fp16,
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_scalar_move_literal_test.go b/amd64_raw_scalar_move_literal_test.go
new file mode 100644
index 000000000..6bfb2910e
--- /dev/null
+++ b/amd64_raw_scalar_move_literal_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawScalarMoveLiteral(double bool, encoding string, mask int, zeroing bool) []byte {
+	pp := byte(2)
+	width := 4
+	if double {
+		pp = 3
+		width = 8
+	}
+	var code []byte
+	switch encoding {
+	case "VEX2":
+		code = []byte{0xc5, 0xf8 | pp, 0x10, 0x05}
+	case "VEX3":
+		code = []byte{0xc4, 0xe1, 0x78 | pp, 0x10, 0x05}
+	case "EVEX":
+		p1 := byte(0x7c) | pp
+		if double {
+			p1 |= 0x80
+		}
+		p2 := byte(0x08 | mask)
+		if zeroing {
+			p2 |= 0x80
+		}
+		code = []byte{0x62, 0xf1, p1, p2, 0x10, 0x05}
+	}
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*17+5))
+	}
+	return code
+}
+
+func TestDecodeX86RawScalarMoveRIPDataCompleteLoadForms(t *testing.T) {
+	type masking struct {
+		mask    int
+		zeroing bool
+	}
+	for _, double := range []bool{false, true} {
+		for _, encoding := range []string{"VEX2", "VEX3", "EVEX"} {
+			maskings := []masking{{}}
+			if encoding == "EVEX" {
+				maskings = append(maskings, masking{mask: 3}, masking{mask: 7, zeroing: true})
+			}
+			for _, masking := range maskings {
+				name := fmt.Sprintf("double%t/%s/mask%d/zero%t", double, encoding, masking.mask, masking.zeroing)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawScalarMoveLiteral(double, encoding, masking.mask, masking.zeroing)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := Op("VMOVSS")
+					if double {
+						want = "VMOVSD"
+					}
+					if masking.zeroing {
+						want += ".Z"
+					}
+					if len(decoded) != 2 || decoded[0].Op != want ||
+						decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+						decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawScalarMoveRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for _, double := range []bool{false, true} {
+		for _, encoding := range []string{"VEX2", "VEX3", "EVEX"} {
+			name := fmt.Sprintf("scalarMoveLiteral%d", len(sigs))
+			mask, zeroing := 0, false
+			if encoding == "EVEX" {
+				mask, zeroing = 7, true
+			}
+			code := x86RawScalarMoveLiteral(double, encoding, mask, zeroing)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range code {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+			width := 4
+			if double {
+				width = 8
+			}
+			pools = append(pools, code[len(code)-width:])
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	var initializedSource, initializedDeclarations strings.Builder
+	for index, function := range file.Funcs {
+		if index%3 == 2 {
+			continue // The original EVEX source has no K7 producer.
+		}
+		text, valid := x86RawReplaySourceText(function)
+		if !valid {
+			t.Fatal("original initialized VEX constant source lost its bytes")
+		}
+		initializedSource.WriteString(text)
+		fmt.Fprintf(&initializedDeclarations, "func %s()\n", function.Sym)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Keep all six original functions and pools in format coverage.
+			// Only the two EVEX functions lack numerical mask inputs.
+			ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "scalar-move-literal.ll", "scalar-move-literal.o", ir)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, initializedSource.String(), initializedDeclarations.String(), "amd64", triple, api)
+				if err != nil {
+					t.Fatal("valid original unmasked constants regressed", api, err)
+				}
+				compileLLVMToObject(t, llc, triple, "initialized-scalar-literal.ll", "initialized-scalar-literal.o", ir)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawScalarMoveRIPDataRejectsUnsafeSources(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{name: "missing_pool", edit: func(code []byte) []byte {
+			code[6] = 0x40
+			return code
+		}},
+		{name: "instruction_overlap", edit: func(code []byte) []byte {
+			copy(code[6:10], []byte{0xfa, 0xff, 0xff, 0xff})
+			return code
+		}},
+		{name: "segment_override", edit: func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		}},
+		{name: "address_override", edit: func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.edit(x86RawScalarMoveLiteral(true, "EVEX", 0, false))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, test.name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe scalar-move source %x", code)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_scalar_move_test.go b/amd64_raw_scalar_move_test.go
new file mode 100644
index 000000000..7ef9d4172
--- /dev/null
+++ b/amd64_raw_scalar_move_test.go
@@ -0,0 +1,332 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawScalarMoveCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT scalarmoves(SB),4,$0-0\n")
+	var lines []string
+	for _, op := range []string{"VMOVSS", "VMOVSD"} {
+		for _, registers := range [][]int{{0, 1, 7}, {8, 9, 15}, {16, 23, 31}} {
+			for _, mask := range []string{"", "K1, ", "K7, "} {
+				for _, suffix := range []string{"", ".Z"} {
+					if mask == "" && suffix != "" {
+						continue
+					}
+					for _, memory := range []string{"(AX)", "-8(R11)(R9*4)", "1024(R11)"} {
+						lines = append(lines, fmt.Sprintf("%s%s %s, %sX%d", op, suffix, memory, mask, registers[2]))
+						if suffix == "" {
+							lines = append(lines, fmt.Sprintf("%s X%d, %s%s", op, registers[0], mask, memory))
+						}
+					}
+					lines = append(lines, fmt.Sprintf("%s%s X%d, X%d, %sX%d", op, suffix, registers[0], registers[1], mask, registers[2]))
+				}
+			}
+		}
+	}
+	source.WriteString(strings.Join(lines, "\n") + "\nRET\n")
+	code := assembleX87ControlBytes(t, "amd64", source.String())
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := file.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+	}
+	for i, ins := range decoded.Instrs {
+		if ins.Op != want[i].Op || !reflect.DeepEqual(ins.Args, want[i].Args) {
+			t.Fatalf("instruction %d decoded %+v, want %+v", i, ins, want[i])
+		}
+	}
+	rawFile := x86RawUnprovedReturnFormProbeFile(t, "amd64", "scalarmoves", code)
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		ir := x86UnboundVoidRawVectorMoveProbeObject(t, rawFile, "amd64", triple)
+		compileLLVMToObject(t, llc, triple, "raw-scalar-moves.ll", "raw-scalar-moves.o", ir)
+	}
+}
+
+func TestTranslate386VectorScalarMoveCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT moves386(SB),4,$0-0\n")
+	for _, op := range []string{"VMOVSS", "VMOVSD"} {
+		for _, x := range []string{"X1", "X15", "X31"} {
+			fmt.Fprintf(&source, "%s (AX),%s\n%s %s,(BX)\n%s %s,X2,X3\n%s (AX),K7,%s\n%s.Z (AX),K7,%s\n%s %s,K7,(BX)\n", op, x, op, x, op, x, op, x, op, x, op, x)
+		}
+	}
+	source.WriteString("RET\n")
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), "386", triple)
+		compileLLVMToObject(t, llc, triple, "scalar-moves386.ll", "scalar-moves386.o", ir)
+	}
+	// Raw 32-bit encodings use the architectural X0-X7 range; named Go
+	// compatibility rows above also expose high EVEX register classes.
+	rawSource := strings.NewReplacer("X15", "X1", "X31", "X1").Replace(source.String())
+	code := assembleX87ControlBytes(t, "386", rawSource)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	named, err := Parse(ArchAMD64, rawSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("386 raw instruction count=%d, want %d", len(decoded.Instrs), len(want))
+	}
+	for i, got := range decoded.Instrs {
+		if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+			t.Fatalf("386 instruction %d=%+v, want %+v", i, got, want[i])
+		}
+	}
+}
+
+// Unlike Go's canonical encoder, exercise both equivalent register directions
+// and every independent R/R'/B/X/vvvv/V' bit, including EVEX masking.
+func encodeRawScalarMove(evex bool, pp, opcode, low, upper, dst, mask int, zero bool) []byte {
+	reg, rm := dst, low
+	if opcode == 0x11 {
+		reg, rm = low, dst
+	}
+	modrm := byte(0xc0 | (reg&7)<<3 | rm&7)
+	if !evex {
+		return []byte{0xc4, byte((^reg>>3&1)<<7 | 0x40 | (^rm>>3&1)<<5 | 1), byte((^upper&15)<<3 | pp), byte(opcode), modrm}
+	}
+	p0 := byte((^reg>>3&1)<<7 | (^rm>>4&1)<<6 | (^rm>>3&1)<<5 | (^reg>>4&1)<<4 | 1)
+	p1 := byte((^upper&15)<<3 | 4 | pp)
+	if pp == 3 {
+		p1 |= 0x80
+	}
+	p2 := byte((^upper>>4&1)<<3 | mask)
+	if zero {
+		p2 |= 0x80
+	}
+	return []byte{0x62, p0, p1, p2, byte(opcode), modrm}
+}
+
+func TestDecodedX86RawScalarMoveRegisterEncodings(t *testing.T) {
+	count := 0
+	for _, evex := range []bool{false, true} {
+		limit := 16
+		if evex {
+			limit = 32
+		}
+		for pp, op := range map[int]Op{2: "VMOVSS", 3: "VMOVSD"} {
+			for _, opcode := range []int{0x10, 0x11} {
+				for low := 0; low < limit; low++ {
+					for upper := 0; upper < limit; upper++ {
+						for dst := 0; dst < limit; dst++ {
+							mask, zero := 0, false
+							if evex {
+								mask = (low + upper + dst) & 7
+								zero = mask != 0 && dst&1 != 0
+							}
+							code := encodeRawScalarMove(evex, pp, opcode, low, upper, dst, mask, zero)
+							got, size, ok, err := decodedX86ScalarMoveInstruction(code, 64)
+							wantOp := op
+							if zero {
+								wantOp += ".Z"
+							}
+							want := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", low))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", upper))}}
+							if mask != 0 {
+								want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+							}
+							want = append(want, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", dst))})
+							if err != nil || !ok || size != len(code) || got.Op != wantOp || !reflect.DeepEqual(got.Args, want) {
+								t.Fatalf("decode %x = %+v, size=%d, ok=%v, err=%v; want %s %+v", code, got, size, ok, err, wantOp, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 147456 {
+		t.Fatalf("covered %d encodings, want 147456", count)
+	}
+}
+
+func TestDecodedX86RawScalarMoveMemoryAndInvalidForms(t *testing.T) {
+	for pp, op := range map[int]Op{2: "VMOVSS", 3: "VMOVSD"} {
+		for _, segment := range []byte{0x64, 0x65} {
+			code := []byte{segment, 0x62, 0x01, byte(0x7c | pp), 0x08, 0x10, 0x7c, 0x8b, 0xff}
+			scale := int64(4)
+			if pp == 3 {
+				code[3] |= 0x80
+				scale = 8
+			}
+			got, size, ok, err := decodedX86ScalarMoveInstruction(code, 64)
+			seg := FS
+			if segment == 0x65 {
+				seg = GS
+			}
+			wantMem := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: -scale, Segment: seg}
+			if err != nil || !ok || size != len(code) || got.Op != op || len(got.Args) != 2 || !reflect.DeepEqual(got.Args[0].Mem, wantMem) || got.Args[1].Reg != "X31" {
+				t.Fatalf("decode %x = %+v, size=%d, ok=%v, err=%v; want memory %+v", code, got, size, ok, err, wantMem)
+			}
+		}
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"missing-modrm", []byte{0xc5, 0xfa, 0x10}, 64},
+		{"missing-sib", []byte{0xc5, 0xfa, 0x10, 0x04}, 64},
+		{"missing-displacement", []byte{0xc5, 0xfa, 0x10, 0x45}, 64},
+		{"address-override", []byte{0x67, 0xc5, 0xfa, 0x10, 0xc0}, 64},
+		{"vex-length", []byte{0xc5, 0xfe, 0x10, 0xc0}, 64},
+		{"vex-memory-vvvv", []byte{0xc5, 0xf2, 0x10, 0x00}, 64},
+		{"evex-fixed", []byte{0x62, 0xf1, 0x7a, 0x08, 0x10, 0xc0}, 64},
+		{"evex-ss-width", []byte{0x62, 0xf1, 0xfe, 0x08, 0x10, 0xc0}, 64},
+		{"evex-sd-width", []byte{0x62, 0xf1, 0x7f, 0x08, 0x10, 0xc0}, 64},
+		{"evex-length", []byte{0x62, 0xf1, 0x7e, 0x28, 0x10, 0xc0}, 64},
+		{"evex-broadcast", []byte{0x62, 0xf1, 0x7e, 0x18, 0x10, 0xc0}, 64},
+		{"zero-k0", []byte{0x62, 0xf1, 0x7e, 0x88, 0x10, 0xc0}, 64},
+		{"memory-vprime", []byte{0x62, 0xf1, 0x7e, 0x00, 0x10, 0x00}, 64},
+		{"zero-store", []byte{0x62, 0xf1, 0x7e, 0x89, 0x11, 0x00}, 64},
+		{"386-high-register", []byte{0xc5, 0x7a, 0x10, 0xc0}, 32},
+		{"wrong-mode", []byte{0xc5, 0xfa, 0x10, 0xc0}, 16},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86ScalarMoveInstruction(tc.code, tc.mode); !ok || err == nil {
+				t.Fatalf("invalid %x: matched=%v, err=%v", tc.code, ok, err)
+			}
+		})
+	}
+	for _, code := range [][]byte{nil, {0x64}, {0xc5}, {0xc4, 0xe1}, {0x62, 0xf1, 0x7e}, {0xc5, 0xf9, 0x10, 0xc0}, {0xc5, 0xfa, 0x5a, 0xc0}} {
+		if _, _, ok, err := decodedX86ScalarMoveInstruction(code, 64); ok || err != nil {
+			t.Fatalf("unrelated/truncated prefix %x: matched=%v, err=%v", code, ok, err)
+		}
+	}
+}
+
+func TestX86RawScalarMoveRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; three-target object coverage is required separately")
+	}
+	var source, declarations, calls strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, pp := range []int{2, 3} {
+		width := 4
+		if pp == 3 {
+			width = 8
+		}
+		for _, kind := range []string{"merge10", "merge11", "load", "store"} {
+			for _, encoding := range []string{"vex", "evex", "masked", "zero"} {
+				if kind == "store" && encoding == "zero" {
+					continue
+				}
+				mask, zero := 0, encoding == "zero"
+				if encoding == "masked" || zero {
+					mask = 1
+				}
+				opcode := 0x10
+				if kind == "merge11" || kind == "store" {
+					opcode = 0x11
+				}
+				code := encodeRawScalarMove(encoding != "vex", pp, opcode, 0, 1, 2, mask, zero)
+				if kind == "load" || kind == "store" {
+					// Memory is (AX), destination/source X2. vvvv/V' must be reserved.
+					code = encodeRawScalarMove(encoding != "vex", pp, opcode, 2, 0, 2, mask, zero)
+					code[len(code)-1] = 0x10
+				}
+				name := fmt.Sprintf("rawscalarmove%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ in+8(FP),SI\nMOVQ mem+16(FP),AX\nMOVQ mask+24(FP),CX\nKMOVQ CX,K1\nVMOVUPS 32(SI),Y2\nVMOVUPS 32(SI),Z2\nMOVOU (SI),X0\nMOVOU 16(SI),X1\nMOVOU 32(SI),X2\n", name)
+				for _, b := range code {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+				}
+				source.WriteString("MOVOU X2,(DI)\nVMOVUPS Y2,16(DI)\nVMOVUPS Z2,48(DI)\nRET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(void *,const void *,void *,uint64_t);\n", name)
+				zeroFlag := 0
+				if zero {
+					zeroFlag = 1
+				}
+				fmt.Fprintf(&calls, "if (check(%s,%q,%d,%d,%d)) return %d;\n", name, kind, width, mask, zeroFlag, index)
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple, runPrefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations.String() + `
+static int check(void (*fn)(void *,const void *,void *,uint64_t), const char *kind, int width, int masked, int zero) {
+  for (int m=0;m<4;m++) {
+    uint8_t in[96], out[112], want[16], mem[32], old[32];
+    for (int i=0;i<96;i++) in[i]=(uint8_t)(17+i*3);
+    for (int i=0;i<32;i++) mem[i]=old[i]=(uint8_t)(255-i*7);
+    int active=!masked || (m&1), store=strcmp(kind,"store")==0, load=strcmp(kind,"load")==0;
+    memcpy(want,in+32,16);
+    if (!store) {
+      if (load) memset(want,0,16); else memcpy(want,in+16,16);
+      if (active) memcpy(want,load ? mem+1 : in,width);
+      else if (zero) memset(want,0,width); else memcpy(want,in+32,width);
+    }
+    fn(out,in,mem+1,(uint64_t)m);
+    if (memcmp(out,want,16)) { fprintf(stderr,"%s width=%d mask=%d zero=%d register mismatch\n",kind,width,m,zero); return 1; }
+    for (int v=0;v<2;v++) {
+      int start=v ? 48 : 16, bytes=v ? 64 : 32;
+      for (int b=0;b<bytes;b++) {
+        uint8_t expected=store ? in[32+b] : b<16 ? want[b] : 0;
+        if (out[start+b]!=expected) { fprintf(stderr,"%s width=%d mask=%d alias byte=%d mismatch\n",kind,width,m,b); return 1; }
+      }
+    }
+    if (store && active) memcpy(old+1,in+32,width);
+    if (memcmp(mem,old,32)) { fprintf(stderr,"unexpected scalar memory write\n"); return 1; }
+    // A cleared low mask bit suppresses the access, regardless of high bits.
+    if (masked && !(m&1) && (load || store)) {
+      fn(out,in,0,(uint64_t)m);
+      if (memcmp(out,want,16)) return 1;
+    }
+  }
+  return 0;
+}
+int main(void) {
+` + calls.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_scalar_move", triple, ir, mainC, runPrefix)
+}
diff --git a/amd64_raw_scalar_precision_convert_test.go b/amd64_raw_scalar_precision_convert_test.go
new file mode 100644
index 000000000..83d5ef71b
--- /dev/null
+++ b/amd64_raw_scalar_precision_convert_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type rawScalarPrecisionConvertSpec struct {
+	legacyPrefix byte
+	legacy       Op
+	vector       Op
+	inputBytes   int
+}
+
+var rawScalarPrecisionConvertSpecs = []rawScalarPrecisionConvertSpec{
+	{legacyPrefix: 0xf3, legacy: "CVTSS2SD", vector: "VCVTSS2SD", inputBytes: 4},
+	{legacyPrefix: 0xf2, legacy: "CVTSD2SS", vector: "VCVTSD2SS", inputBytes: 8},
+}
+
+func encodeX86RawLegacyScalarPrecisionConvert(spec rawScalarPrecisionConvertSpec, source, destination int) []byte {
+	rex := byte(0x40 | source>>3&1 | destination>>3&1<<2)
+	code := []byte{spec.legacyPrefix}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, 0x5a, byte(0xc0|destination&7<<3|source&7))
+}
+
+func encodeX86RawVEXScalarPrecisionConvert(spec rawScalarPrecisionConvertSpec, first, second, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^first>>3)&1)<<5 | 1
+	pp := byte(3)
+	if spec.inputBytes == 4 {
+		pp = 2
+	}
+	p1 := byte(^second&15)<<3 | pp
+	return []byte{0xc4, p0, p1, 0x5a, byte(0xc0 | destination&7<<3 | first&7)}
+}
+
+func encodeX86RawEVEXScalarPrecisionConvert(spec rawScalarPrecisionConvertSpec, control int, mask int, zeroing bool, first, second, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 1
+	pp := byte(3)
+	if spec.inputBytes == 4 {
+		pp = 2
+	}
+	p1 := byte(^second&15)<<3 | 4 | pp
+	if spec.inputBytes == 8 {
+		p1 |= 0x80
+	}
+	p2 := byte((^second>>4)&1)<<3 | byte(mask)
+	if control >= 0 {
+		p2 |= 0x10 | byte(control)<<5
+	}
+	if zeroing {
+		p2 |= 0x80
+	}
+	return []byte{0x62, p0, p1, p2, 0x5a, byte(0xc0 | destination&7<<3 | first&7)}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVCVTSD2SS(t *testing.T) {
+	// vcvtsd2ss %xmm0, %xmm0, %xmm0;
+	// vmovsd (%rcx), %xmm1
+	code := []byte{0xc5, 0xfb, 0x5a, 0xc0, 0xc5, 0xfb, 0x10, 0x09}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VCVTSD2SS sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VCVTSD2SS X0, X0, X0 ") || !strings.HasPrefix(decoded[1].Raw, "VMOVSD 0(CX), X1 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawScalarPrecisionConvertCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawScalarPrecisionConvertSpecs {
+		for source := 0; source < 16; source++ {
+			for destination := 0; destination < 16; destination++ {
+				code := encodeX86RawLegacyScalarPrecisionConvert(spec, source, destination)
+				got, length, ok, err := decodedX86ScalarPrecisionConvertInstruction(code, 64)
+				want := fmt.Sprintf("%s X%d, X%d", spec.legacy, source, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+		for first := 0; first < 16; first++ {
+			for second := 0; second < 16; second++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86RawVEXScalarPrecisionConvert(spec, first, second, destination)
+					got, length, ok, err := decodedX86ScalarPrecisionConvertInstruction(code, 64)
+					want := fmt.Sprintf("%s X%d, X%d, X%d", spec.vector, first, second, destination)
+					if err != nil || !ok || length != len(code) || got.Raw != want {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+					}
+					count++
+				}
+			}
+		}
+		controls := []int{-1, 0}
+		if spec.inputBytes == 8 {
+			controls = []int{-1, 0, 1, 2, 3}
+		}
+		for _, control := range controls {
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+			}{{}, {mask: 3}, {mask: 7, zeroing: true}} {
+				for first := 0; first < 32; first++ {
+					for second := 0; second < 32; second++ {
+						for destination := 0; destination < 32; destination++ {
+							code := encodeX86RawEVEXScalarPrecisionConvert(spec, control, masking.mask, masking.zeroing, first, second, destination)
+							got, length, ok, err := decodedX86ScalarPrecisionConvertInstruction(code, 64)
+							suffix := ""
+							if control >= 0 {
+								if spec.inputBytes == 4 {
+									suffix = ".SAE"
+								} else {
+									suffix = "." + [...]string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}[control]
+								}
+							}
+							if masking.zeroing {
+								suffix += ".Z"
+							}
+							args := []string{fmt.Sprintf("X%d", first), fmt.Sprintf("X%d", second)}
+							if masking.mask != 0 {
+								args = append(args, fmt.Sprintf("K%d", masking.mask))
+							}
+							args = append(args, fmt.Sprintf("X%d", destination))
+							want := string(spec.vector) + suffix + " " + strings.Join(args, ", ")
+							if err != nil || !ok || length != len(code) || got.Raw != want {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 696832 {
+		t.Fatalf("covered %d scalar precision-conversion register encodings, want 696832", count)
+	}
+}
+
+func TestDecodedX86RawScalarPrecisionConvertMemoryAndInvalidForms(t *testing.T) {
+	legacyMemory := []byte{0xf3, 0x47, 0x0f, 0x5a, 0x7c, 0x8b, 0x01}
+	got, length, ok, err := decodedX86ScalarPrecisionConvertInstruction(legacyMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(legacyMemory) || got.Op != "CVTSS2SD" || got.Args[1].String() != "X15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", legacyMemory, got, length, ok, err)
+	}
+	vexMemory := []byte{0xc4, 0x01, 0x73, 0x5a, 0x7c, 0x8b, 0x02}
+	got, length, ok, err = decodedX86ScalarPrecisionConvertInstruction(vexMemory, 64)
+	wantMemory.Off = 2
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VCVTSD2SS" || got.Args[1].String() != "X1" || got.Args[2].String() != "X15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+	evexMemory := []byte{0x62, 0xf1, 0x56, 0x83, 0x5a, 0x50, 0x02}
+	got, length, ok, err = decodedX86ScalarPrecisionConvertInstruction(evexMemory, 64)
+	wantMemory = MemRef{Base: "AX", Off: 8}
+	if err != nil || !ok || length != len(evexMemory) || got.Op != "VCVTSS2SD.Z" || got.Args[1].String() != "X21" || got.Args[2].String() != "K3" || got.Args[3].String() != "X2" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexMemory, got, length, ok, err)
+	}
+
+	validVEX := encodeX86RawVEXScalarPrecisionConvert(rawScalarPrecisionConvertSpecs[0], 7, 6, 5)
+	validEVEXSS := encodeX86RawEVEXScalarPrecisionConvert(rawScalarPrecisionConvertSpecs[0], -1, 0, false, 7, 6, 5)
+	validEVEXSD := encodeX86RawEVEXScalarPrecisionConvert(rawScalarPrecisionConvertSpecs[1], -1, 0, false, 7, 6, 5)
+	for name, invalid := range map[string][]byte{
+		"vex W":                   {validVEX[0], validVEX[1], validVEX[2] | 0x80, validVEX[3], validVEX[4]},
+		"vex L":                   {validVEX[0], validVEX[1], validVEX[2] | 0x04, validVEX[3], validVEX[4]},
+		"evex fixed bit":          {validEVEXSS[0], validEVEXSS[1], validEVEXSS[2] &^ 0x04, validEVEXSS[3], validEVEXSS[4], validEVEXSS[5]},
+		"evex SS wrong W":         {validEVEXSS[0], validEVEXSS[1], validEVEXSS[2] | 0x80, validEVEXSS[3], validEVEXSS[4], validEVEXSS[5]},
+		"evex SD wrong W":         {validEVEXSD[0], validEVEXSD[1], validEVEXSD[2] &^ 0x80, validEVEXSD[3], validEVEXSD[4], validEVEXSD[5]},
+		"evex length without SAE": {validEVEXSS[0], validEVEXSS[1], validEVEXSS[2], validEVEXSS[3] | 0x20, validEVEXSS[4], validEVEXSS[5]},
+		"zero without mask":       {validEVEXSS[0], validEVEXSS[1], validEVEXSS[2], validEVEXSS[3] | 0x80, validEVEXSS[4], validEVEXSS[5]},
+		"SS explicit rounding":    {validEVEXSS[0], validEVEXSS[1], validEVEXSS[2], validEVEXSS[3] | 0x30, validEVEXSS[4], validEVEXSS[5]},
+		"address override":        append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86ScalarPrecisionConvertInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	roundingMemory := []byte{0x62, 0xf1, 0xff, 0x10, 0x5a, 0x00}
+	if instruction, _, matched, decodeErr := decodedX86ScalarPrecisionConvertInstruction(roundingMemory, 64); !matched || decodeErr == nil {
+		t.Fatalf("rounding memory encoding %x decoded as %+v, ok=%v, err=%v", roundingMemory, instruction, matched, decodeErr)
+	}
+	masked386 := encodeX86RawEVEXScalarPrecisionConvert(rawScalarPrecisionConvertSpecs[0], -1, 1, false, 0, 1, 2)
+	if instruction, _, matched, decodeErr := decodedX86ScalarPrecisionConvertInstruction(masked386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 masked encoding %x decoded as %+v, ok=%v, err=%v", masked386, instruction, matched, decodeErr)
+	}
+}
+
+func TestTranslateX86RawScalarPrecisionConvertTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_scalar_precision_convert(SB),NOSPLIT,$0-0\n")
+			for _, spec := range rawScalarPrecisionConvertSpecs {
+				var encodings [][]byte
+				if target.goarch == "amd64" {
+					control := 0
+					if spec.inputBytes == 8 {
+						control = 3
+					}
+					encodings = append(encodings,
+						encodeX86RawLegacyScalarPrecisionConvert(spec, 15, 14),
+						encodeX86RawVEXScalarPrecisionConvert(spec, 15, 14, 13),
+						encodeX86RawEVEXScalarPrecisionConvert(spec, -1, 3, true, 31, 30, 29),
+						encodeX86RawEVEXScalarPrecisionConvert(spec, control, 7, true, 31, 30, 29),
+					)
+				} else {
+					control := 0
+					if spec.inputBytes == 8 {
+						control = 2
+					}
+					encodings = append(encodings,
+						encodeX86RawLegacyScalarPrecisionConvert(spec, 7, 6),
+						encodeX86RawVEXScalarPrecisionConvert(spec, 7, 6, 5),
+						encodeX86RawEVEXScalarPrecisionConvert(spec, -1, 0, false, 20, 21, 22),
+						encodeX86RawEVEXScalarPrecisionConvert(spec, control, 0, false, 20, 21, 22),
+					)
+				}
+				for _, encoding := range encodings {
+					for _, value := range encoding {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			ll := x86ScalarPrecisionOriginalFormatObject(t, source.String(), "raw_scalar_precision_convert", target.goarch, target.triple, true)
+			compileLLVMToObject(t, llc, target.triple, "raw-scalar-precision-convert-"+target.name+".ll", "raw-scalar-precision-convert-"+target.name+".o", ll)
+		})
+	}
+}
diff --git a/amd64_raw_scalar_reciprocal.go b/amd64_raw_scalar_reciprocal.go
new file mode 100644
index 000000000..32baf491a
--- /dev/null
+++ b/amd64_raw_scalar_reciprocal.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import "fmt"
+
+// Intel RCPSS/RSQRTSS share legacy F3.0F and VEX.LIG.F3.0F.WIG
+// register/m32 rows. Ignored W/L bits do not widen the selected scalar or
+// change the upper source. EVEX belongs to other estimate families.
+func decodedX86RawScalarReciprocalInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, vector := decodeX86RawVectorEncoding(code)
+	if vector {
+		if p.mapNumber != 1 || p.pp != 2 || p.opcode != 0x52 && p.opcode != 0x53 {
+			return Instr{}, 0, false, nil
+		}
+	} else {
+		i := 0
+		mandatory := false
+		for i < len(code) {
+			switch code[i] {
+			case 0x64:
+				p.segment = FS
+			case 0x65:
+				p.segment = GS
+			case 0x67:
+				p.addressOverride = true
+			case 0xf3:
+				mandatory = true
+			default:
+				goto legacy
+			}
+			i++
+		}
+	legacy:
+		rex := byte(0)
+		if i < len(code) && code[i]&0xf0 == 0x40 {
+			rex = code[i]
+			i++
+		}
+		if !mandatory || len(code) < i+2 || code[i] != 0x0f || code[i+1] != 0x52 && code[i+1] != 0x53 {
+			return Instr{}, 0, false, nil
+		}
+		p.opcode, p.modRM = int(code[i+1]), i+2
+		p.r, p.x, p.b = int(rex>>2&1), int(rex>>1&1), int(rex&1)
+		if mode == 32 && rex != 0 {
+			return Instr{}, 0, true, fmt.Errorf("scalar reciprocal: REX unavailable in 32-bit mode")
+		}
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("scalar reciprocal: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.evex || p.addressOverride {
+		return fail("EVEX or address-size override has no scalar estimate source contract")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.x != 0 || p.b != 0 || p.upper >= 8) {
+		return fail("extended physical register in 32-bit mode")
+	}
+	source, consumed, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", int(code[p.modRM]>>3&7)+p.r*8))}
+	op := Op("RCPSS")
+	if p.opcode == 0x52 {
+		op = "RSQRTSS"
+	}
+	args := []Operand{source, destination}
+	printed := source.String() + ", " + destination.String()
+	if vector {
+		op = "V" + op
+		base := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))}
+		args = []Operand{source, base, destination}
+		printed = source.String() + ", " + base.String() + ", " + destination.String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, printed)}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_scaled_round.go b/amd64_raw_scaled_round.go
new file mode 100644
index 000000000..fb0fb3029
--- /dev/null
+++ b/amd64_raw_scaled_round.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86RawScaledRoundForm struct {
+	op        Op
+	laneBytes int
+	scalar    bool
+}
+
+// Go 1.27's eight EVEX RNDSCALE/REDUCE opcode rows. Both operations share
+// the same packed/scalar immediate and modifier grammar.
+var x86RawScaledRoundForms = map[[2]int]x86RawScaledRoundForm{
+	{0x08, 0}: {op: "VRNDSCALEPS", laneBytes: 4},
+	{0x09, 1}: {op: "VRNDSCALEPD", laneBytes: 8},
+	{0x0a, 0}: {op: "VRNDSCALESS", laneBytes: 4, scalar: true},
+	{0x0b, 1}: {op: "VRNDSCALESD", laneBytes: 8, scalar: true},
+	{0x56, 0}: {op: "VREDUCEPS", laneBytes: 4},
+	{0x56, 1}: {op: "VREDUCEPD", laneBytes: 8},
+	{0x57, 0}: {op: "VREDUCESS", laneBytes: 4, scalar: true},
+	{0x57, 1}: {op: "VREDUCESD", laneBytes: 8, scalar: true},
+}
+
+func decodedX86RawScaledRoundInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 3 || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	w := 0
+	if p.w {
+		w = 1
+	}
+	form, recognized := x86RawScaledRoundForms[[2]int{p.opcode, w}]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("EVEX scaled round: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if !p.fixed || p.addressOverride || p.vectorLength > 2 ||
+		form.scalar && (mode == 32 || p.vectorLength != 0) ||
+		!form.scalar && p.upper != 0 {
+		return fail("invalid EVEX fixed, address, vector length, or vvvv")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if p.zero && p.mask == 0 {
+		return fail("zeroing requires a nonzero mask")
+	}
+	if mode == 32 && p.mask != 0 {
+		return fail("386 mask form exceeds the Go assembler frontend's operand limit")
+	}
+	modRM := code[p.modRM]
+	registerSource := modRM>>6 == 3
+	sae := p.broadcast && registerSource
+	broadcast := p.broadcast && !registerSource
+	if form.scalar && broadcast || !form.scalar && sae && p.vectorLength != 2 {
+		return fail("SAE or broadcast is unavailable for this operand width")
+	}
+	destinationNumber := int(modRM>>3&7) + p.r*8
+	if mode == 32 && p.vectorLength == 2 &&
+		(destinationNumber >= 8 || registerSource && int(modRM&7)+p.b*8+p.x*16 >= 8) {
+		return fail("386 Z-register exceeds the Go assembler frontend's register class")
+	}
+	vector := [...]string{"X", "Y", "Z"}[p.vectorLength]
+	disp8Scale := 16 << p.vectorLength
+	if form.scalar || broadcast {
+		disp8Scale = form.laneBytes
+	}
+	source, consumed, err := decodedX86EVEXRMOperand(
+		code[p.modRM:], mode, p.b, p.x, p.segment, vector, disp8Scale,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immIndex := p.modRM + consumed
+	if len(code) <= immIndex {
+		return fail("missing imm8")
+	}
+	op := form.op
+	if broadcast {
+		op += ".BCST"
+	}
+	if sae {
+		op += ".SAE"
+	}
+	if p.zero {
+		op += ".Z"
+	}
+	args := []Operand{{Kind: OpImm, Imm: int64(code[immIndex])}, source}
+	if form.scalar {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))})
+	}
+	if p.mask != 0 {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", p.mask))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", vector, destinationNumber))})
+	printed := make([]string, len(args))
+	for index := range args {
+		printed[index] = args[index].String()
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("%s %s", op, strings.Join(printed, ", "))}, immIndex + 1, true, nil
+}
diff --git a/amd64_raw_scaled_round_test.go b/amd64_raw_scaled_round_test.go
new file mode 100644
index 000000000..96c11d6dc
--- /dev/null
+++ b/amd64_raw_scaled_round_test.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawScaledRound(op Op, vectorBits, mask int, zeroing, evexB, memory bool) []byte {
+	var opcode byte
+	var w, scalar bool
+	for encoding, form := range x86RawScaledRoundForms {
+		if form.op == op {
+			opcode = byte(encoding[0])
+			w = encoding[1] != 0
+			scalar = form.scalar
+			break
+		}
+	}
+	p1 := byte(0x7d)
+	if scalar {
+		p1 = 0x6d // EVEX.vvvv = X2 passthrough.
+	}
+	if w {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if evexB {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd1) // first register 1, destination register 2.
+	if scalar {
+		modRM = 0xd9 // first register 1, destination register 3.
+	}
+	if memory {
+		modRM = 0x50 // disp8(AX), destination register 2.
+		if scalar {
+			modRM = 0x58 // disp8(AX), destination register 3.
+		}
+	}
+	code := []byte{0x62, 0xf3, p1, p2, opcode, modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return append(code, 9)
+}
+
+func TestDecodeX86RawScaledRoundSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VRNDSCALEPS $9, 0(SI)(R8*4), Z0.
+	code := []byte{0x62, 0xb3, 0x7d, 0x48, 0x08, 0x04, 0x86, 0x09, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "floorFloat32 AVX512 VRNDSCALEPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VRNDSCALEPS" ||
+		decoded[0].Args[0].Imm != 9 || decoded[0].Args[2].Reg != "Z0" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawScaledRoundCompleteGoForms(t *testing.T) {
+	if len(x86RawScaledRoundForms) != 8 {
+		t.Fatalf("modeled %d scaled-round rows, want eight", len(x86RawScaledRoundForms))
+	}
+	for _, form := range x86RawScaledRoundForms {
+		maxLength := 2
+		if form.scalar {
+			maxLength = 0
+		}
+		for vectorBits := 0; vectorBits <= maxLength; vectorBits++ {
+			for _, variant := range []struct {
+				name    string
+				mask    int
+				zeroing bool
+				evexB   bool
+				memory  bool
+				suffix  string
+			}{
+				{name: "register"},
+				{name: "masked zero register", mask: 7, zeroing: true, suffix: ".Z"},
+				{name: "memory", memory: true},
+				{name: "broadcast memory", evexB: true, memory: true, suffix: ".BCST"},
+				{name: "SAE register", evexB: true, suffix: ".SAE"},
+			} {
+				if form.scalar && variant.suffix == ".BCST" ||
+					!form.scalar && variant.suffix == ".SAE" && vectorBits != 2 {
+					continue
+				}
+				name := fmt.Sprintf("%s/length%d/%s", form.op, vectorBits, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawScaledRound(form.op, vectorBits, variant.mask, variant.zeroing, variant.evexB, variant.memory)
+					got, length, ok, err := decodedX86RawScaledRoundInstruction(code, 64)
+					if err != nil || !ok || length != len(code) || got.Op != form.op+Op(variant.suffix) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantDestination := fmt.Sprintf("%s2", [...]string{"X", "Y", "Z"}[vectorBits])
+					if form.scalar {
+						wantDestination = "X3"
+					}
+					if got.Args[0].Imm != 9 || got.Args[len(got.Args)-1].String() != wantDestination {
+						t.Fatalf("decode %x = %+v, want $9 ... %s", code, got, wantDestination)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawScaledRoundRIPLiteral(t *testing.T) {
+	for _, form := range x86RawScaledRoundForms {
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && form.scalar {
+				continue
+			}
+			vectorBits := 2
+			if form.scalar {
+				vectorBits = 0
+			}
+			code := encodeX86RawScaledRound(form.op, vectorBits, 1, false, broadcast, false)
+			code = code[:6]
+			code[5] = 0x15 // RIP-relative first source, destination 2.
+			if form.scalar {
+				code[5] = 0x1d // destination 3.
+			}
+			code = append(code, 1, 0, 0, 0, 9, 0xc3)
+			literalWidth := 16 << vectorBits
+			if form.scalar || broadcast {
+				literalWidth = form.laneBytes
+			}
+			for index := 0; index < literalWidth; index++ {
+				code = append(code, byte(index+1))
+			}
+			name := fmt.Sprintf("%s/broadcast%t", form.op, broadcast)
+			t.Run(name, func(t *testing.T) {
+				got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got) != 2 || !got[0].x86RIPLiteral || len(got[0].x86RIPLiteralData) != literalWidth {
+					t.Fatalf("decode %x = %+v", code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeX86RawScaledRoundRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawScaledRound("VRNDSCALEPS", 2, 0, false, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[3] |= 0x80 },  // zeroing needs a mask
+		func(code []byte) { code[3] |= 0x20 },  // reserved vector length
+		func(code []byte) { code[2] &^= 0x08 }, // packed reserved vvvv
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86RawScaledRoundInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	scalarBroadcast := encodeX86RawScaledRound("VRNDSCALESS", 0, 0, false, true, true)
+	if _, _, ok, err := decodedX86RawScaledRoundInstruction(scalarBroadcast, 64); !ok || err == nil {
+		t.Fatalf("accepted scalar broadcast %x: ok=%v err=%v", scalarBroadcast, ok, err)
+	}
+}
+
+func TestTranslateX86RawScaledRoundLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawScaledRound(SB),$0-0\n")
+			for _, op := range []Op{"VRNDSCALEPS", "VRNDSCALEPD", "VREDUCEPS", "VREDUCEPD"} {
+				code := encodeX86RawScaledRound(op, 0, 0, false, false, false)
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			if target.goarch == "amd64" {
+				for _, op := range []Op{"VRNDSCALESS", "VRNDSCALESD", "VREDUCESS", "VREDUCESD"} {
+					code := encodeX86RawScaledRound(op, 0, 0, false, false, false)
+					for _, value := range code {
+						fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-scaled-round.ll", "raw-scaled-round.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_scatter_test.go b/amd64_raw_scatter_test.go
new file mode 100644
index 000000000..21d5a4a19
--- /dev/null
+++ b/amd64_raw_scatter_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawScatterSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VSCATTERQPS Y2, K1, 0(DI)(Z1*4).
+	code := []byte{0x62, 0xf2, 0x7d, 0x49, 0xa3, 0x14, 0x8f, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "convolveFloat32 AVX512 VSCATTERQPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VSCATTERQPS" ||
+		decoded[0].Args[0].Reg != "Y2" || decoded[0].Args[1].Reg != "K1" ||
+		decoded[0].Args[2].Mem.Index != "Z1" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func x86RawScatterGoForms(goarch string) string {
+	var source strings.Builder
+	source.WriteString("TEXT rawScatterForms(SB),4,$0-0\n")
+	widths := [...]string{"X", "Y", "Z"}
+	for _, family := range x86ScatterOps {
+		for _, op := range family {
+			spec := amd64ScatterSpecs[string(op)]
+			for width := 0; width < 3; width++ {
+				dataWidth := widths[width]
+				indexWidth := dataWidth
+				switch spec.table {
+				case amd64GatherDPD:
+					if width > 0 {
+						indexWidth = widths[width-1]
+					}
+				case amd64GatherQPS:
+					if width > 0 {
+						dataWidth = widths[width-1]
+					}
+				}
+				fmt.Fprintf(&source, "\t%s %s1, K1, 8(BX)(%s2*4)\n", op, dataWidth, indexWidth)
+				if goarch == "amd64" {
+					fmt.Fprintf(&source, "\t%s %s21, K7, -32(R8)(%s18*2)\n", op, dataWidth, indexWidth)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestDecodeX86RawScatterCompleteGoForms(t *testing.T) {
+	expected := map[Op]bool{
+		"VPSCATTERDD": true, "VPSCATTERDQ": true,
+		"VPSCATTERQD": true, "VPSCATTERQQ": true,
+		"VSCATTERDPS": true, "VSCATTERDPD": true,
+		"VSCATTERQPS": true, "VSCATTERQPD": true,
+	}
+	for _, family := range x86ScatterOps {
+		for _, op := range family {
+			if !expected[op] {
+				t.Fatalf("unexpected or repeated scatter opcode %s", op)
+			}
+			delete(expected, op)
+		}
+	}
+	if len(expected) != 0 {
+		t.Fatalf("missing Go scatter opcodes: %v", expected)
+	}
+	for _, goarch := range []string{"amd64", "386"} {
+		t.Run(goarch, func(t *testing.T) {
+			source := x86RawScatterGoForms(goarch)
+			code := assembleX87ControlBytes(t, goarch, source)
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(decoded.Instrs) != len(want) {
+				t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+			}
+			for i, got := range decoded.Instrs {
+				if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+					t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+				}
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawScatterRejectsMalformedForms(t *testing.T) {
+	valid := []byte{0x62, 0xf2, 0x7d, 0x49, 0xa3, 0x14, 0x8f}
+	for _, variant := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"missing mask", func(code []byte) []byte { code[3] &^= 7; return code }},
+		{"zeroing", func(code []byte) []byte { code[3] |= 0x80; return code }},
+		{"broadcast", func(code []byte) []byte { code[3] |= 0x10; return code }},
+		{"reserved length", func(code []byte) []byte { code[3] |= 0x60; return code }},
+		{"register destination", func(code []byte) []byte { code[5] |= 0xc0; return code }},
+		{"missing SIB", func(code []byte) []byte { return code[:6] }},
+		{"reserved vvvv", func(code []byte) []byte { code[2] &^= 0x08; return code }},
+	} {
+		t.Run(variant.name, func(t *testing.T) {
+			code := variant.mutate(append([]byte(nil), valid...))
+			if _, _, matched, err := decodedX86RawScatterInstruction(code, 64); !matched || err == nil {
+				t.Fatalf("invalid %x: matched=%v err=%v", code, matched, err)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawScatterLLVM22AllTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x86RawScatterGoForms(target.goarch)
+			code := assembleX87ControlBytes(t, target.goarch, source)
+			file := x86RawUnprovedReturnFormProbeFile(t, target.goarch, "rawScatterForms", code)
+			// Bare encoder rows have no index, data, mask or address producers.
+			// Retain their three public Context controls and actual Go bytes,
+			// then compile every unchanged row through the private format owner.
+			ir := x86UnboundVoidRawProbeObject(t, file, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-scatter.ll", "raw-scatter.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_segment_absolute_test.go b/amd64_raw_segment_absolute_test.go
new file mode 100644
index 000000000..a13dfad57
--- /dev/null
+++ b/amd64_raw_segment_absolute_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawSegmentAbsoluteMemory(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		want string
+		base bool
+	}{
+		{name: "gs-absolute", code: []byte{0x65, 0x48, 0x8b, 0x04, 0x25, 0x30, 0, 0, 0}, want: "48(GS)"},
+		{name: "fs-absolute", code: []byte{0x64, 0x48, 0x8b, 0x04, 0x25, 0x30, 0, 0, 0}, want: "48(FS)"},
+		{name: "gs-base", code: []byte{0x65, 0x48, 0x8b, 0x40, 0x30}, want: "48(AX)(GS)", base: true},
+		{name: "fs-base", code: []byte{0x64, 0x48, 0x8b, 0x40, 0x30}, want: "48(AX)(FS)", base: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			inst, err := x86asm.Decode(tc.code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			syntax, err := decodedX86GoSyntax(inst, tc.code)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(syntax, tc.want) {
+				t.Fatalf("raw %x decoded as %q, want memory %s", tc.code, syntax, tc.want)
+			}
+
+			var source strings.Builder
+			source.WriteString("TEXT rawSegmentMemory(SB),$0-0\n")
+			for _, value := range tc.code {
+				fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+			}
+			source.WriteString("RET\n")
+			assembly := source.String()
+			triple := "x86_64-unknown-linux-gnu"
+			if tc.base {
+				ir := x86UnboundVoidRawScalarFormatObject(t, assembly, "amd64", triple)
+				x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+				assembly = strings.Replace(assembly, "\nBYTE", "\nMOVQ $0,AX\nBYTE", 1)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", triple, assembly)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly, "func rawSegmentMemory()", "amd64", triple, api)
+				if err != nil {
+					t.Fatal("raw hardware segment with all explicit numerical offsets", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_raw_segment_base_test.go b/amd64_raw_segment_base_test.go
new file mode 100644
index 000000000..5a36ecaaa
--- /dev/null
+++ b/amd64_raw_segment_base_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Intel's F3 0F AE /0..3 register encodings correspond to all eight rows in
+// Go's asm6.go: RDFSBASE, RDGSBASE, WRFSBASE and WRGSBASE, each with L/Q width.
+var rawSegmentBaseTestOps = [...]string{"RDFSBASE", "RDGSBASE", "WRFSBASE", "WRGSBASE"}
+
+func rawSegmentBaseTestEncoding(operation, bits, register int) []byte {
+	code := []byte{0xf3}
+	rex := byte(0x40)
+	if bits == 64 {
+		rex |= 8
+	}
+	if register >= 8 {
+		rex |= 1
+	}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, 0xae, byte(0xc0|operation<<3|register&7))
+}
+
+func TestX86RawSegmentBaseCompleteRegisterFamily(t *testing.T) {
+	if len(amd64SegmentBaseSpecs) != 2*len(rawSegmentBaseTestOps) {
+		t.Fatal("raw encoding tests must cover the complete named segment-base grammar")
+	}
+	registers := [...]Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for operation, name := range rawSegmentBaseTestOps {
+		for _, width := range []struct {
+			bits   int
+			suffix string
+		}{{32, "L"}, {64, "Q"}} {
+			for register, wantRegister := range registers {
+				wantOp := Op(name + width.suffix)
+				t.Run(string(wantOp)+"/"+string(wantRegister), func(t *testing.T) {
+					code := rawSegmentBaseTestEncoding(operation, width.bits, register)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segment-base bytes", nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(decoded) != 1 || decoded[0].Op != wantOp || len(decoded[0].Args) != 1 ||
+						decoded[0].Args[0].Kind != OpReg || decoded[0].Args[0].Reg != wantRegister {
+						t.Fatalf("%x decoded as %+v, want %s %s", code, decoded, wantOp, wantRegister)
+					}
+					if _, ok := amd64SegmentBaseSpecs[wantOp]; !ok {
+						t.Fatalf("raw opcode %s has no typed named grammar", wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawSegmentBaseIgnoredPrefixesPreserveRegisterWidth(t *testing.T) {
+	for operation, name := range rawSegmentBaseTestOps {
+		for _, bits := range []int{32, 64} {
+			for _, prefix := range []byte{0x66, 0x67, 0x64, 0x65} {
+				for _, afterREP := range []bool{false, true} {
+					code := rawSegmentBaseTestEncoding(operation, bits, 11)
+					if afterREP {
+						code = append([]byte{0xf3, prefix}, code[1:]...)
+					} else {
+						code = append([]byte{prefix}, code...)
+					}
+					inst, err := x86asm.Decode(code, 64)
+					if err != nil || inst.Len != len(code) {
+						t.Fatalf("decode %x: %+v, %v", code, inst, err)
+					}
+					got, err := decodedX86GoSyntax(inst, code)
+					width := "L"
+					if bits == 64 {
+						width = "Q"
+					}
+					want := name + width + " R11"
+					if err != nil || got != want {
+						t.Errorf("%x (DataSize=%d): got %q, %v; want %q", code, inst.DataSize, got, err, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawSegmentBaseRejectsInvalidDecodedForms(t *testing.T) {
+	for _, op := range []x86asm.Op{x86asm.RDFSBASE, x86asm.RDGSBASE, x86asm.WRFSBASE, x86asm.WRGSBASE} {
+		for _, args := range []x86asm.Args{
+			{}, {x86asm.Imm(1)}, {x86asm.Mem{Base: x86asm.RAX}},
+			{x86asm.AL}, {x86asm.AX}, {x86asm.X0},
+			{x86asm.RAX, x86asm.RBX}, {x86asm.RAX, nil, nil, x86asm.RBX},
+		} {
+			inst := x86asm.Inst{Op: op, Mode: 64, DataSize: 64, Args: args}
+			if got, err := decodedX86GoSyntax(inst, nil); err == nil {
+				t.Errorf("accepted invalid %s operands %v as %q", op, args, got)
+			}
+		}
+	}
+	for operation := range rawSegmentBaseTestOps {
+		code := rawSegmentBaseTestEncoding(operation, 64, 3)
+		for _, invalid := range []struct {
+			name string
+			code []byte
+			mode int
+		}{
+			{"lock", append([]byte{0xf0}, code...), 64},
+			{"memory", []byte{0xf3, 0x48, 0x0f, 0xae, byte(operation << 3)}, 64},
+			{"truncated", code[:len(code)-1], 64},
+			{"32-bit-mode", rawSegmentBaseTestEncoding(operation, 32, 3), 32},
+		} {
+			t.Run(rawSegmentBaseTestOps[operation]+"/"+invalid.name, func(t *testing.T) {
+				if got, err := decodeX86RawDirectiveGroup(invalid.code, invalid.mode, 0, "invalid segment-base bytes", nil); err == nil {
+					t.Fatalf("accepted invalid %x as %+v", invalid.code, got)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86RawSegmentBaseMatchesNamedFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			var raw, named strings.Builder
+			for _, source := range []*strings.Builder{&raw, &named} {
+				source.WriteString("TEXT segmentbase(SB),$0-0\nMOVQ $-1, BX\n")
+			}
+			// Keep the whole reported gVisor sequence, including SWAPGS before
+			// RDGSBASEQ, as well as every sibling operation and operand width.
+			for _, value := range []byte{0x0f, 0x01, 0xf8, 0xf3, 0x48, 0x0f, 0xae, 0xcb} {
+				fmt.Fprintf(&raw, "BYTE $%#x\n", value)
+			}
+			named.WriteString("SWAPGS\nRDGSBASEQ BX\n")
+			for operation, name := range rawSegmentBaseTestOps {
+				for _, bits := range []int{32, 64} {
+					for _, value := range rawSegmentBaseTestEncoding(operation, bits, 3) {
+						fmt.Fprintf(&raw, "BYTE $%#x\n", value)
+					}
+					width := "L"
+					if bits == 64 {
+						width = "Q"
+					}
+					fmt.Fprintf(&named, "%s%s BX\n", name, width)
+				}
+			}
+			var irs []string
+			for _, source := range []*strings.Builder{&raw, &named} {
+				source.WriteString("RET\n")
+				requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{
+					Goarch: "amd64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"segmentbase": {Name: "segmentbase", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				// LLVM assigns a different temporary filename on each parse.
+				// Compare every semantic line, excluding only that metadata.
+				lines := strings.Split(ir, "\n")
+				for index, line := range lines {
+					if strings.HasPrefix(line, "; ModuleID = ") || strings.HasPrefix(line, "source_filename = ") {
+						lines[index] = ""
+					}
+				}
+				irs = append(irs, strings.Join(lines, "\n"))
+			}
+			if irs[0] != irs[1] {
+				t.Fatalf("raw and named segment-base semantics differ:\nraw:\n%s\nnamed:\n%s", irs[0], irs[1])
+			}
+			compileLLVMToObject(t, llc, triple, "raw-segment-base.ll", "raw-segment-base.o", irs[0])
+		})
+	}
+}
diff --git a/amd64_raw_segment_load_test.go b/amd64_raw_segment_load_test.go
new file mode 100644
index 000000000..2b4c6ca66
--- /dev/null
+++ b/amd64_raw_segment_load_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawSegmentInitializedLoadForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			forms := 0
+			for _, segment := range []struct {
+				prefix byte
+			}{{0x64}, {0x65}} {
+				for _, width := range []int{1, 2, 4, 8} {
+					if target.arch == "386" && width == 8 {
+						continue
+					}
+					for _, address := range []string{"absolute", "base", "indexed"} {
+						name := fmt.Sprintf("Segment%d", forms)
+						fmt.Fprintf(&declarations, "func %s()\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\nMOVL $0,AX\nMOVL $1,CX\n", name)
+						code := []byte{segment.prefix}
+						if width == 2 {
+							code = append(code, 0x66)
+						} else if width == 8 {
+							code = append(code, 0x48)
+						}
+						opcode := byte(0x8b)
+						if width == 1 {
+							opcode = 0x8a
+						}
+						code = append(code, opcode)
+						switch address {
+						case "absolute":
+							if target.arch == "386" {
+								code = append(code, 0x15)
+							} else {
+								code = append(code, 0x14, 0x25)
+							}
+							code = append(code, 48, 0, 0, 0)
+						case "base":
+							code = append(code, 0x50, 48)
+						case "indexed":
+							code = append(code, 0x54, 0x48, 48)
+						}
+						source.WriteString(x86RawDisplacementDirectives(code))
+						source.WriteString("RET\n")
+						forms++
+					}
+				}
+			}
+			want := 24
+			if target.arch == "386" {
+				want = 18
+			}
+			if forms != want {
+				t.Fatal("complete raw segment load inventory changed", forms, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized physical segment load lost its paired native read", api, err)
+				}
+				for _, output := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if strings.Count(output, "load volatile ") != want {
+						t.Fatal("dead-result physical segment read was lost or duplicated", api, output)
+					}
+					for _, space := range []int{256, 257} {
+						for _, width := range []int{1, 2, 4, 8} {
+							if target.arch == "386" && width == 8 {
+								continue
+							}
+							read := fmt.Sprintf("load volatile i%d, ptr addrspace(%d)", width*8, space)
+							if strings.Count(output, read) != 3 {
+								t.Fatal("physical segment read width or address space changed", api, read, output)
+							}
+						}
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, output, level)
+					}
+				}
+				for _, foreign := range []string{"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, foreign, api); err == nil || ir != "" {
+						t.Fatal("physical segment source acquired a foreign backend", api, foreign, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawSegmentLoadRetainsInputsAndSourceIdentity(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		mode, word := 32, int64(4)
+		if arch == "amd64" {
+			mode, word = 64, 8
+		}
+		for _, prefix := range []byte{0x64, 0x65} {
+			instructions := x86AddressOverrideDecoded(t, mode, []byte{prefix, 0x8b, 0x54, 0x48, 48})
+			if len(instructions) != 3 || instructions[0].Op != OpTEXT || instructions[2].Op != OpRET {
+				t.Fatal("single physical segment load lost identity", instructions)
+			}
+			original := instructions[1]
+			if !x86RawScalarSegmentLoadSource(original, arch) {
+				t.Fatal("exact physical segment load lacks decoder-bound identity", arch, original)
+			}
+			for _, register := range []Reg{AX, CX} {
+				index, _, _ := x86ResultGP(register, word, arch)
+				for missing := 0; missing <= int(word); missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[1] = 0xff, 0xff
+					if missing < int(word) {
+						state.gp[index] &^= 1 << uint(missing)
+					} else {
+						state.pointerGP[index] = true
+					}
+					before := state.clone()
+					if accepted, known := x86LoweredScalarNativeLoad(original, &state, nil, 0, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("physical segment offset acquired missing NUM or pointer bits", arch, register, missing)
+					}
+				}
+			}
+			for _, mutation := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"encoding", func(ins *Instr) { ins.x86Encoded = false }},
+				{"absent-mode", func(ins *Instr) { ins.x86SourceRaw.scalarSegmentLoad.arch = "" }},
+				{"foreign-mode", func(ins *Instr) { ins.x86SourceRaw.scalarSegmentLoad.arch = "other" }},
+				{"physical-mode", func(ins *Instr) {
+					ins.x86SourceRaw.scalarSegmentLoad.arch = "386"
+					if arch == "386" {
+						ins.x86SourceRaw.scalarSegmentLoad.arch = "amd64"
+					}
+				}},
+				{"width", func(ins *Instr) { ins.x86SourceRaw.scalarSegmentLoad.bytes++ }},
+				{"prefix", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"origin-prefix", func(ins *Instr) { ins.x86SourceRaw.scalarSegmentLoad.segmentPrefix = 0x65 }},
+				{"address", func(ins *Instr) { ins.x86AddressBits = 16 }},
+				{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+				{"opcode", func(ins *Instr) { ins.Op = "MOVW" }},
+				{"source", func(ins *Instr) { ins.Args[0].Mem.Off++ }},
+				{"destination", func(ins *Instr) { ins.Args[1].Reg = BX }},
+				{"segment", func(ins *Instr) { ins.Args[0].Mem.Segment = GS }},
+			} {
+				if mutation.name == "segment" && prefix == 0x65 {
+					continue // The FS case independently changes the actual segment.
+				}
+				changed := cloneX86ReplayInstrs([]Instr{original})[0]
+				mutation.change(&changed)
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.gp[0], state.gp[1] = 0xff, 0xff
+				before := state.clone()
+				if x86RawScalarSegmentLoadSource(changed, arch) {
+					t.Fatal("edited raw segment source reused its decoder identity", arch, mutation.name)
+				}
+				if accepted, _ := x86LoweredScalarNativeLoad(changed, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("edited raw segment source obtained a numerical continuation", arch, mutation.name)
+				}
+			}
+		}
+	}
+	assembly := "TEXT ·Segment(SB),4,$0-0\nMOVL $0,AX\n" + x86RawDisplacementDirectives([]byte{0x64, 0x8b, 0x40, 48}) + "RET\n"
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err = normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"operand", "receipt", "replay"} {
+		changed := *file
+		changed.Funcs = append([]Func(nil), file.Funcs...)
+		changed.Funcs[0].Instrs = cloneX86ReplayInstrs(file.Funcs[0].Instrs)
+		switch mutation {
+		case "operand":
+			changed.Funcs[0].Instrs[2].Args[0].Mem.Off++
+		case "receipt":
+			changed.Funcs[0].Instrs[2].x86SourceRaw = nil
+		case "replay":
+			replay := *changed.Funcs[0].x86RawReplay
+			replay.source = strings.Replace(replay.source, "MOVL $0,AX", "MOVL $1,AX", 1)
+			changed.Funcs[0].x86RawReplay = &replay
+		}
+		ir, err := Translate(&changed, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs:       map[string]FuncSig{"Segment": {Name: "Segment", Ret: Void}},
+			ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }})
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("edited complete raw source bypassed its sealed replay", mutation, err)
+		}
+	}
+}
diff --git a/amd64_raw_segment_move_test.go b/amd64_raw_segment_move_test.go
new file mode 100644
index 000000000..63309a2bc
--- /dev/null
+++ b/amd64_raw_segment_move_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestDecodedX86RawSegmentMoveCompleteRegisterFamily(t *testing.T) {
+	segments := []string{"ES", "CS", "SS", "DS", "FS", "GS"}
+	count := 0
+	for _, mode := range []int{32, 64} {
+		registers := 8
+		if mode == 64 {
+			registers = 16
+		}
+		for segmentNumber, segment := range segments {
+			for general := 0; general < registers; general++ {
+				rex := byte(0)
+				if mode == 64 && general >= 8 {
+					rex = 0x41
+				}
+				for _, direction := range []struct {
+					opcode byte
+					want   string
+				}{
+					{opcode: 0x8e, want: fmt.Sprintf("MOVW %s, %s", decodedX86RegisterNameForTest(general), segment)},
+					{opcode: 0x8c, want: fmt.Sprintf("MOVW %s, %s", segment, decodedX86RegisterNameForTest(general))},
+				} {
+					code := make([]byte, 0, 3)
+					if rex != 0 {
+						code = append(code, rex)
+					}
+					code = append(code, direction.opcode, byte(0xc0|segmentNumber<<3|general&7))
+					got, length, ok, err := decodedX86SegmentMoveInstruction(code, mode)
+					if err != nil || !ok || length != len(code) || got.Raw != direction.want {
+						t.Fatalf("decode mode=%d %x = %+v, length=%d, ok=%v, err=%v; want %q", mode, code, got, length, ok, err, direction.want)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 288 {
+		t.Fatalf("covered %d raw segment-register moves, want 288", count)
+	}
+}
+
+func decodedX86RegisterNameForTest(number int) string {
+	reg, ok := decodedX86GeneralRegister(number)
+	if !ok {
+		panic(number)
+	}
+	return string(reg)
+}
+
+func TestDecodedX86RawSegmentMoveMemoryAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		mode int
+		code []byte
+		want string
+	}{
+		{
+			name: "load FS from extended SIB with FS override",
+			mode: 64,
+			code: []byte{0x64, 0x43, 0x8e, 0x64, 0x8b, 0x20},
+			want: "MOVW 32(R11)(R9*4)(FS), FS",
+		},
+		{
+			name: "store GS to extended SIB with GS override",
+			mode: 64,
+			code: []byte{0x65, 0x43, 0x8c, 0x6c, 0x8b, 0x20},
+			want: "MOVW GS, 32(R11)(R9*4)(GS)",
+		},
+		{
+			name: "386 absolute memory",
+			mode: 32,
+			code: []byte{0x66, 0x8e, 0x1d, 0x78, 0x56, 0x34, 0x12},
+			want: "MOVW 305419896(), DS",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86SegmentMoveInstruction(test.code, test.mode)
+			if err != nil || !ok || length != len(test.code) || got.Raw != test.want {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", test.code, got, length, ok, err, test.want)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name     string
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "reserved segment six", encoding: []byte{0x8e, 0xf0}, wantOK: true},
+		{name: "reserved segment seven", encoding: []byte{0x8c, 0xf8}, wantOK: true},
+		{name: "REX.R reserved segment", encoding: []byte{0x44, 0x8e, 0xc0}, wantOK: true},
+		{name: "RIP relative", encoding: []byte{0x8e, 0x1d, 0, 0, 0, 0}, wantOK: true},
+		{name: "address override", encoding: []byte{0x67, 0x8e, 0xd8}, wantOK: true},
+		{name: "truncated", encoding: []byte{0x8e}, wantOK: false},
+		{name: "unrelated opcode", encoding: []byte{0x8f, 0xd8}, wantOK: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86SegmentMoveInstruction(test.encoding, 64)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x returned ok=%v err=%v, want ok=%v", test.encoding, ok, err, test.wantOK)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("invalid encoding %x was accepted", test.encoding)
+			}
+			if !test.wantOK && err != nil {
+				t.Fatalf("unrelated encoding %x returned err=%v", test.encoding, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_segment_prefixes.go b/amd64_raw_segment_prefixes.go
new file mode 100644
index 000000000..818627ee5
--- /dev/null
+++ b/amd64_raw_segment_prefixes.go
@@ -0,0 +1,20 @@
+package plan9asm
+
+// x86RawSegmentPrefixes retains physical prefix observations without deciding
+// whether a particular instruction or source mode accepts them.
+func x86RawSegmentPrefixes(code []byte) (length int, segment Reg, addressOverride bool) {
+	for length < len(code) {
+		switch code[length] {
+		case 0x64:
+			segment = FS
+		case 0x65:
+			segment = GS
+		case 0x67:
+			addressOverride = true
+		default:
+			return
+		}
+		length++
+	}
+	return
+}
diff --git a/amd64_raw_segment_prefixes_bench_test.go b/amd64_raw_segment_prefixes_bench_test.go
new file mode 100644
index 000000000..e92b13c50
--- /dev/null
+++ b/amd64_raw_segment_prefixes_bench_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// The bytes retain independent VEX float, EVEX funnel, SHA and scalar
+// precision fixtures from their existing raw-family tests.
+type rawPrefixQualificationFixture struct {
+	name   string
+	code   []byte
+	decode func([]byte, int) (Instr, int, bool, error)
+}
+
+func rawPrefixQualificationFixtures() []rawPrefixQualificationFixture {
+	return []rawPrefixQualificationFixture{
+		{"vex-float-memory", []byte{0xc4, 0x01, 0xe5, 0x58, 0x64, 0x88, 0x20}, decodedX86VEXBinaryFloatInstruction},
+		{"evex-funnel-memory", []byte{0x62, 0xf3, 0xf5, 0xdb, 0x73, 0x50, 0x7f, 0x09}, decodedX86FunnelShiftInstruction},
+		{"legacy-sha-register", []byte{0x0f, 0x38, 0xc8, 0xca}, decodedX86SHAInstruction},
+		{"scalar-precision-memory", []byte{0x62, 0xf1, 0x56, 0x83, 0x5a, 0x50, 0x02}, decodedX86ScalarPrecisionConvertInstruction},
+	}
+}
+
+var rawPrefixQualificationSink Instr
+
+func BenchmarkX86RawPrefixDecoders(b *testing.B) {
+	for _, fixture := range rawPrefixQualificationFixtures() {
+		for _, mode := range []int{32, 64} {
+			for _, variant := range []struct {
+				name   string
+				prefix []byte
+				cut    int
+			}{
+				{"original", nil, len(fixture.code)},
+				{"last-segment", []byte{0x65, 0x64}, len(fixture.code)},
+				{"address-override", []byte{0x64, 0x67, 0x65}, len(fixture.code)},
+				{"nonmatch", []byte{0x90}, len(fixture.code)},
+				{"truncated", []byte{0x64}, 1},
+			} {
+				b.Run(fmt.Sprintf("%s/mode%d/%s", fixture.name, mode, variant.name), func(b *testing.B) {
+					code := append(append([]byte(nil), variant.prefix...), fixture.code[:variant.cut]...)
+					// Compare acceptance and exact errors outside timing. Cases
+					// deliberately include matched, nonmatching and invalid input.
+					fixture.decode(code, mode)
+					b.ReportAllocs()
+					b.ResetTimer()
+					for iteration := 0; iteration < b.N; iteration++ {
+						rawPrefixQualificationSink, _, _, _ = fixture.decode(code, mode)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_raw_segment_prefixes_test.go b/amd64_raw_segment_prefixes_test.go
new file mode 100644
index 000000000..7dc2bb3cc
--- /dev/null
+++ b/amd64_raw_segment_prefixes_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import "testing"
+
+// Candidate-only owner. Do not install/run this against baseline, where the
+// helper does not exist; a missing symbol would not establish a product RED.
+func TestX86RawSegmentPrefixTuples(t *testing.T) {
+	for _, test := range []struct {
+		code    []byte
+		length  int
+		segment Reg
+		address bool
+	}{
+		{nil, 0, "", false},
+		{[]byte{0x64}, 1, FS, false},
+		{[]byte{0x65}, 1, GS, false},
+		{[]byte{0x67, 0x67}, 2, "", true},
+		{[]byte{0x64, 0x65}, 2, GS, false},
+		{[]byte{0x65, 0x64}, 2, FS, false},
+		{[]byte{0x65, 0x67, 0x64, 0x67}, 4, FS, true},
+		{[]byte{0x64, 0x90, 0x65, 0x67}, 1, FS, false},
+	} {
+		length, segment, address := x86RawSegmentPrefixes(test.code)
+		if length != test.length || segment != test.segment || address != test.address {
+			t.Fatalf("%x: got (%d,%s,%v), want (%d,%s,%v)", test.code, length, segment, address, test.length, test.segment, test.address)
+		}
+	}
+	// All 256 next bytes, preceded by each physical segment/address state.
+	for _, prefix := range []struct {
+		code    []byte
+		segment Reg
+		address bool
+	}{
+		{nil, "", false}, {[]byte{0x64}, FS, false}, {[]byte{0x65}, GS, false},
+		{[]byte{0x67}, "", true}, {[]byte{0x64, 0x67}, FS, true}, {[]byte{0x65, 0x67}, GS, true},
+	} {
+		for next := 0; next < 256; next++ {
+			code := append(append([]byte(nil), prefix.code...), byte(next), 0x90, 0x65, 0x67)
+			wantLength, wantSegment, wantAddress := len(prefix.code), prefix.segment, prefix.address
+			switch byte(next) {
+			case 0x64:
+				wantLength++
+				wantSegment = FS
+			case 0x65:
+				wantLength++
+				wantSegment = GS
+			case 0x67:
+				wantLength++
+				wantAddress = true
+			}
+			length, segment, address := x86RawSegmentPrefixes(code)
+			if length != wantLength || segment != wantSegment || address != wantAddress {
+				t.Fatalf("%x: got (%d,%s,%v), want (%d,%s,%v)", code, length, segment, address, wantLength, wantSegment, wantAddress)
+			}
+		}
+	}
+}
diff --git a/amd64_raw_sha_test.go b/amd64_raw_sha_test.go
new file mode 100644
index 000000000..7875b2b32
--- /dev/null
+++ b/amd64_raw_sha_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86SHACompleteGo127Family(t *testing.T) {
+	// Go 1.27 exposes every Intel SHA extension opcode. Cover register and
+	// memory sources, REX-extended X registers, the SHA1 immediate, and the
+	// implicit X0 operand used by SHA256RNDS2.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "sha1 next e", code: []byte{0x0f, 0x38, 0xc8, 0xca}, want: "SHA1NEXTE X2, X1"},
+		{name: "sha1 message 1 high destination", code: []byte{0x44, 0x0f, 0x38, 0xc9, 0xf4}, want: "SHA1MSG1 X4, X14"},
+		{name: "sha1 message 2 memory", code: []byte{0x41, 0x0f, 0x38, 0xca, 0x54, 0x8c, 0x20}, want: "SHA1MSG2 32(R12)(CX*4), X2"},
+		{name: "sha256 message 1", code: []byte{0x0f, 0x38, 0xcc, 0xe5}, want: "SHA256MSG1 X5, X4"},
+		{name: "sha256 message 2", code: []byte{0x0f, 0x38, 0xcd, 0xf5}, want: "SHA256MSG2 X5, X6"},
+		{name: "sha1 rounds 4", code: []byte{0x0f, 0x3a, 0xcc, 0xd1, 0x03}, want: "SHA1RNDS4 $3, X1, X2"},
+		{name: "sha256 rounds 2 implicit x0", code: []byte{0x0f, 0x38, 0xcb, 0xda}, want: "SHA256RNDS2 X0, X2, X3"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86SHAInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("SHA encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioSHA256RNDS2(t *testing.T) {
+	code := []byte{0x0f, 0x38, 0xcb, 0xda}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio SHA256RNDS2", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "SHA256RNDS2" || !strings.HasPrefix(decoded[0].Raw, "SHA256RNDS2 X0, X2, X3 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_shiftrotate_test.go b/amd64_raw_shiftrotate_test.go
new file mode 100644
index 000000000..3669004fd
--- /dev/null
+++ b/amd64_raw_shiftrotate_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawShiftRotateCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var lines []string
+			widths := []string{"B", "W", "L"}
+			mode := 32
+			if arch == "amd64" {
+				mode = 64
+				widths = append(widths, "Q")
+			}
+			for _, stem := range []string{"ROL", "ROR", "RCL", "RCR", "SHL", "SHR", "SAR"} {
+				for _, width := range widths {
+					destinations := []string{"AX", "-7(BX)(CX*4)"}
+					if width == "B" {
+						destinations = []string{"AL", "AH", "-7(BX)(CX*4)"}
+					}
+					if arch == "amd64" {
+						destinations = append(destinations, "R11")
+					}
+					for _, dst := range destinations {
+						for _, count := range []string{"$1", "$255", "CL"} {
+							lines = append(lines, fmt.Sprintf("%s%s %s, %s", stem, width, count, dst))
+						}
+					}
+				}
+			}
+			for _, stem := range []string{"SHL", "SHR"} {
+				for _, width := range widths[1:] {
+					for _, dst := range []string{"BX", "-7(BX)(CX*4)"} {
+						for _, count := range []string{"$-128", "$127", "CL"} {
+							lines = append(lines, fmt.Sprintf("%s%s %s, AX, %s", stem, width, count, dst))
+						}
+					}
+				}
+			}
+			named := "TEXT shifts(SB),4,$0-0\n" + strings.Join(lines, "\n") + "\nRET\n"
+			code := assembleX87ControlBytes(t, arch, named)
+			offset := 0
+			var raw strings.Builder
+			raw.WriteString("TEXT shifts(SB),4,$0-0\n")
+			for _, line := range lines {
+				inst, err := x86asm.Decode(code[offset:], mode)
+				if err != nil {
+					t.Fatalf("Go encoded %s: %v", line, err)
+				}
+				encoded := code[offset : offset+inst.Len]
+				decoded, err := decodeX86RawDirectives(rawX86Function(encoded), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+line+"\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != want.Funcs[0].Instrs[1].Op || !reflect.DeepEqual(decoded.Instrs[0].Args, want.Funcs[0].Instrs[1].Args) {
+					t.Fatalf("decoded %x as %+v, want %s", encoded, decoded.Instrs, line)
+				}
+				for _, b := range encoded {
+					fmt.Fprintf(&raw, "BYTE $%#02x\n", b)
+				}
+				offset += inst.Len
+			}
+			raw.WriteString("RET\n")
+			file, err := Parse(ArchAMD64, raw.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				// Counts, carry, data and physical addresses remain unbound.
+				// Replay the complete original source before direct format emission.
+				ir := x86UnboundVoidRawProbeObject(t, file, arch, triple)
+				compileLLVMToObject(t, llc, triple, "raw-shifts.ll", "raw-shifts.o", ir)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_static_return_runtime_test.go b/amd64_raw_static_return_runtime_test.go
new file mode 100644
index 000000000..9174e8aef
--- /dev/null
+++ b/amd64_raw_static_return_runtime_test.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// The Go oracle uses an ordinary declared result slot. It does not pretend
+// that Go ABI0 returns a scalar in AX. The translated raw-RIP counterpart has
+// the same fixed-width read and data, transported through its typed C result.
+func runX86StaticReadNumericOracle(t *testing.T, arch, triple string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	values := []uint64{0, 1, 0x80000001, 0xffffffff, 0x89abcdef01234567, 0xfedcba9876543210}
+	var raw, native, declarations, goMain, cMain strings.Builder
+	goMain.WriteString("package main\nfunc main(){\n")
+	cMain.WriteString("typedef unsigned int u32; typedef unsigned long long u64;\n")
+	var cChecks strings.Builder
+	cChecks.WriteString("int main(void){\n")
+	sigs := make(map[string]FuncSig)
+	count := 0
+	for _, width := range []int{4, 8} {
+		if arch == "386" && width == 8 {
+			continue // The 386 scalar MOVQ spelling is not an integer GP read.
+		}
+		for index, value := range values {
+			name := fmt.Sprintf("Read%d_%d", width, index)
+			typ, goType, cType, move := I32, "uint32", "u32", "MOVL"
+			if width == 8 {
+				typ, goType, cType, move = I64, "uint64", "u64", "MOVQ"
+			} else {
+				value = uint64(uint32(value))
+			}
+			fmt.Fprintf(&declarations, "func %s()(r %s)\n", name, goType)
+			fmt.Fprintf(&goMain, "if got:=%s(); got!=%s(0x%x){panic(\"%s\")}\n", name, goType, value, name)
+			fmt.Fprintf(&cMain, "extern %s %s(void);\n", cType, name)
+			fmt.Fprintf(&cChecks, "if(%s()!=0x%xULL)return %d;\n", name, value, count+1)
+			fmt.Fprintf(&native, "DATA pool%d_%d<>+0(SB)/%d,$0x%x\nGLOBL pool%d_%d<>(SB),8,$%d\nTEXT ·%s(SB),4,$0-%d\n%s pool%d_%d<>(SB),AX\n%s AX,r+0(FP)\nBYTE $0xc3\n",
+				width, index, width, value, width, index, width, name, width, move, width, index, move)
+			if arch == "amd64" {
+				code := []byte{0x8b, 0x05, 1, 0, 0, 0, 0xc3}
+				if width == 8 {
+					code = append([]byte{0x48}, code...)
+				}
+				data := make([]byte, 8)
+				binary.LittleEndian.PutUint64(data, value)
+				raw.WriteString(x86StaticReturnSource(name, append(code, data[:width]...)))
+			} else {
+				// Same-file DATA allocations are architecture-neutral. In 386
+				// mode these are static absolute references, never RIP reads.
+				fmt.Fprintf(&raw, "DATA pool%d_%d<>+0(SB)/%d,$0x%x\nTEXT %s(SB),4,$0-0\n%s pool%d_%d<>(SB),AX\nBYTE $0xc3\n",
+					width, index, width, value, name, move, width, index)
+			}
+			sigs[name] = FuncSig{Name: name, Ret: typ}
+			count++
+		}
+	}
+	if arch == "amd64" {
+		// A source-local LEA makes the pool mutable through its returned
+		// address. The shared read proof must not resurrect specialization.
+		declarations.WriteString("func Mutable()(p *uint64,v uint64)\n")
+		native.WriteString("DATA mutable<>+0(SB)/8,$0x123456789abcdef\nGLOBL mutable<>(SB),16,$8\nTEXT ·Mutable(SB),4,$0-16\nLEAQ mutable<>(SB),AX\nMOVQ AX,p+0(FP)\nMOVQ mutable<>(SB),BX\nMOVQ BX,v+8(FP)\nBYTE $0xc3\n")
+		goMain.WriteString("p,v:=Mutable();if p==nil||v!=0x123456789abcdef{panic(\"initial mutable\")}\n*p=0xfedcba9876543210\nq,v:=Mutable();if p!=q||v!=0xfedcba9876543210{panic(\"changed mutable\")}\n")
+		code := []byte{
+			0x48, 0x8d, 0x1d, 0x08, 0, 0, 0, // LEAQ pool,BX.
+			0x48, 0x8b, 0x05, 0x01, 0, 0, 0, // MOVQ pool,AX.
+			0xc3,
+		}
+		data := make([]byte, 8)
+		binary.LittleEndian.PutUint64(data, 0x123456789abcdef)
+		raw.WriteString(x86StaticReturnSource("Mutable", append(code, data...)))
+		sigs["Mutable"] = FuncSig{Name: "Mutable", Ret: I64}
+		cMain.WriteString("extern u64 Mutable(void); extern u64 MutablePool[];\n")
+		cChecks.WriteString("if(Mutable()!=0x123456789abcdefULL)return 98;\nMutablePool[0]=0xfedcba9876543210ULL;\nif(Mutable()!=0xfedcba9876543210ULL)return 99;\n")
+	}
+	goMain.WriteString("}\n")
+	cChecks.WriteString("return 0;}\n")
+	cMain.WriteString(cChecks.String())
+	goSource := strings.Replace(goMain.String(), "func main", declarations.String()+"func main", 1)
+	project := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":  "module example.com/static-read-oracle\ngo 1.20\n",
+		"main.go": goSource, "read_" + arch + ".s": native.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(project, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(project, gotoolchain.HostExecutable("oracle"))
+	cmd := exec.Command("go", "build", "-o", executable, ".")
+	cmd.Dir = project
+	goos := runtime.GOOS
+	if len(runner) != 0 {
+		goos = "linux"
+	}
+	cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch, "CGO_ENABLED=0", "GOWORK=off", "GOTOOLCHAIN=local")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go static-read oracle build: %v\n%s", err, output)
+	}
+	run := append(append([]string(nil), runner...), executable)
+	if output, err := exec.Command(run[0], run[1:]...).CombinedOutput(); err != nil {
+		t.Fatalf("actual Go static-read oracle run: %v\n%s", err, output)
+	}
+	t.Logf("actual Go %s: %d ordinary static scalar result cases", arch, count)
+	file := mustParseX86RawReturn(t, raw.String())
+	opt := Options{Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string {
+			if strings.HasPrefix(symbol, "·__plan9asm_raw_address_") {
+				return "MutablePool"
+			}
+			return symbol
+		}}
+	for _, api := range []string{"text", "module", "owned-module"} {
+		var ir string
+		switch api {
+		case "text":
+			var err error
+			ir, err = Translate(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+		case "module":
+			module, err := TranslateModule(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir = module.String()
+			module.Dispose()
+		default:
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				ctx.Dispose()
+				t.Fatal(err)
+			}
+			ir = module.String()
+			module.Dispose()
+			ctx.Dispose()
+		}
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "static-read-"+api, triple, ir, cMain.String(), runner)
+		t.Logf("LLVM 22 %s/%s: %d scalar cases", arch, api, count)
+	}
+}
+
+func TestX86RawReturnStaticReadNumericOracle(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("host-inapplicable: x86 scalar oracle runs in the required Linux/amd64 cross-runtime gate")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	compiler := []string{clang, "-target", triple}
+	if runtime.GOOS == "darwin" {
+		output, err := exec.Command("xcrun", "--show-sdk-path").CombinedOutput()
+		if err != nil {
+			t.Fatalf("required Darwin SDK: %v\n%s", err, output)
+		}
+		compiler = append(compiler, "-isysroot", strings.TrimSpace(string(output)))
+	}
+	runX86StaticReadNumericOracle(t, "amd64", triple, compiler, nil)
+}
+
+func TestCrossLinuxRuntimeMatrixX86RawStaticRead(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		return // The explicit cross job runs this required counterpart.
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross static-read oracle requires Linux/amd64 runner")
+	}
+	qemu, err := exec.LookPath("qemu-i386")
+	if err != nil {
+		t.Fatal("required pinned qemu-i386:", err)
+	}
+	output, err := exec.Command(qemu, "--version").CombinedOutput()
+	if err != nil || !strings.Contains(string(output), "version 10.2.3") {
+		t.Fatalf("required QEMU 10.2.3: %v\n%s", err, output)
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required 386 cross compiler:", err)
+	}
+	runX86StaticReadNumericOracle(t, "386", "i386-unknown-linux-gnu", []string{compiler, "-no-pie"}, []string{qemu, "-L", "/usr/i686-linux-gnu"})
+}
diff --git a/amd64_raw_static_return_test.go b/amd64_raw_static_return_test.go
new file mode 100644
index 000000000..d0d4061db
--- /dev/null
+++ b/amd64_raw_static_return_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86StaticReturnSource(name string, code []byte) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", name)
+	for _, value := range code {
+		fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+	}
+	return source.String()
+}
+
+func TestX86RawReturnSharedRIPReadContract(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	cases := []struct {
+		name  string
+		code  []byte
+		width int
+	}{
+		{"legacy-i32", []byte{0x8b, 0x05, 1, 0, 0, 0, 0xc3, 1, 2, 3, 4}, 4},
+		{"legacy-i64", []byte{0x48, 0x8b, 0x05, 1, 0, 0, 0, 0xc3, 1, 2, 3, 4, 5, 6, 7, 8}, 8},
+		{"legacy-vector", x86RawLegacyPackedMoveConstant(0xf3, 0x6f), 16},
+		{"vex-vector", x86RawPackedMoveLiteral(false, 32), 32},
+		{"evex-vector", x86RawPackedMoveLiteral(true, 64), 64},
+		{"broadcast-f32", x86RawBinaryFloatLiteral(0x58, 0, true, 64, true), 4},
+		{"broadcast-f64", x86RawBinaryFloatLiteral(0x58, 1, true, 64, true), 8},
+		{"scalar-f32", x86RawBinaryFloatLiteral(0x58, 2, false, 16, false), 4},
+		{"scalar-f64", x86RawBinaryFloatLiteral(0x58, 3, false, 16, false), 8},
+		{"nonfirst-source", x86RawCLMULLiteral("legacy", 16), 16},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			source := x86StaticReturnSource("Bound", test.code)
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			prepared, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), "amd64")
+			if err != nil {
+				t.Fatal("shared RIP read rejected before materialization:", err)
+			}
+			if len(prepared.Data) != 1 || prepared.Data[0].Width != int64(test.width) {
+				t.Fatalf("materialized data: %+v, want exact width %d", prepared.Data, test.width)
+			}
+			for _, target := range x86RawReturnTargets {
+				if target.arch != "amd64" {
+					continue // RIP-relative addressing exists only in 64-bit mode.
+				}
+				opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+				x86RawReturnPointerAPIs(t, source, opt, false)
+				ir, err := Translate(prepared, opt)
+				if err != nil {
+					t.Fatal("prepartition/final validation disagreed:", err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "bounded-rip.ll", "bounded-rip.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86RawReturnStaticDATAExtents(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, offset := range []int{0, 4, 5} {
+			source := fmt.Sprintf("DATA pool<>+4(SB)/4,$0x76543210\nTEXT Bound(SB),4,$0-0\nMOVL pool<>+%d(SB),AX\nBYTE $0xc3\n", offset)
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: I32}}}
+			x86RawReturnPointerAPIs(t, source, opt, offset == 5)
+			if offset != 5 {
+				ir, err := Translate(mustParseX86RawReturn(t, source), opt)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "bounded-data.ll", "bounded-data.o", ir)
+			}
+		}
+	}
+}
+
+func TestX86RawReturnMaterializedReadCannotAuthorizeChangedSource(t *testing.T) {
+	source := x86StaticReturnSource("Bound", x86RawPackedMoveLiteral(false, 32))
+	mutations := map[string]func(*File){
+		"opcode store": func(file *File) {
+			file.Funcs[0].Instrs[1].Op = "VMOVDQU"
+			args := file.Funcs[0].Instrs[1].Args
+			args[0], args[1] = args[1], args[0]
+		},
+		"unrecognized opcode": func(file *File) {
+			file.Funcs[0].Instrs[1].Op = "UNRECOGNIZED"
+		},
+		"pointer operand": func(file *File) {
+			file.Funcs[0].Instrs[1].Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+		},
+		"shifted source": func(file *File) {
+			file.Funcs[0].Instrs[1].Args[0].Sym = file.Data[0].Sym + "+1(SB)"
+		},
+		"missing data": func(file *File) {
+			file.Data = nil
+		},
+		"short object": func(file *File) {
+			file.Data[0].Width--
+			file.Data[0].Payload = file.Data[0].Payload[:len(file.Data[0].Payload)-1]
+		},
+		"changed payload": func(file *File) {
+			payload := append([]byte(nil), file.Data[0].Payload...)
+			payload[0] ^= 0xff
+			file.Data[0].Payload = payload
+		},
+		"extra DATA write": func(file *File) {
+			file.Data = append(file.Data, DataStmt{Sym: file.Data[0].Sym, Width: 1, Value: 0xff})
+		},
+		"wrong pending index": func(file *File) {
+			file.Funcs[0].Instrs[1].Args[1] = Operand{Kind: OpSym, Sym: "·__plan9asm_raw_literal_pending(SB)"}
+		},
+	}
+	for name, mutate := range mutations {
+		t.Run(name, func(t *testing.T) {
+			file, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutate(file)
+			for _, target := range x86RawReturnTargets {
+				if target.arch != "amd64" {
+					continue
+				}
+				opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+				// Test every final API on this exact prepared/changed file.
+				if x86RawReturnMemoryBound(file.Funcs[0], file, opt, true) {
+					t.Fatal("a decoded read authorized changed source or missing backing")
+				}
+				for _, api := range []string{"text", "module", "owned-module"} {
+					var callErr error
+					switch api {
+					case "text":
+						_, callErr = Translate(file, opt)
+					case "module":
+						module, err := TranslateModule(file, opt)
+						if err == nil {
+							module.Dispose()
+						}
+						callErr = err
+					default:
+						ctx := llvm.NewContext()
+						module, err := TranslateModuleInContext(ctx, file, opt)
+						if err == nil {
+							module.Dispose()
+						}
+						ctx.Dispose()
+						callErr = err
+					}
+					if !errors.Is(callErr, ErrProbeNeedsContext) {
+						t.Errorf("%s changed prepared source bypassed the read contract: %v", api, callErr)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawReturnRIPReadRequires64BitDecodeContext(t *testing.T) {
+	source := x86StaticReturnSource("Bound", x86RawPackedMoveLiteral(false, 32))
+	file, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	opt := Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+	_, err = Translate(file, opt)
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("64-bit RIP proof was reused as a 32-bit absolute-address proof: %v", err)
+	}
+}
+
+func TestX86RawReturnSharedAddressPoolRetainsExactReadRange(t *testing.T) {
+	code := []byte{
+		0x48, 0x8d, 0x05, 0x09, 0, 0, 0, // LEAQ pool,AX.
+		0xf3, 0x0f, 0x6f, 0x05, 0x09, 0, 0, 0, // MOVOU pool+8,X0.
+		0xc3,
+	}
+	code = append(code, make([]byte, 32)...)
+	source := x86StaticReturnSource("Bound", code)
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		file, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), target.arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		read := file.Funcs[0].Instrs[2]
+		if len(read.x86RIPLiteralData) != 0 || read.x86RIPMemoryRead.offset != 8 ||
+			read.x86RIPMemoryRead.width != 16 || len(read.x86RIPMemoryRead.object) != 32 {
+			t.Fatalf("shared runtime read lost range or acquired specialization: %+v", read)
+		}
+		opt := Options{Goarch: target.arch, TargetTriple: target.triple,
+			Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+		x86RawReturnPointerAPIs(t, source, opt, false)
+		ir, err := Translate(file, opt)
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, target.triple, "shared-pool.ll", "shared-pool.o", ir)
+		file.Funcs[0].Instrs[2].Args[0].Sym = file.Data[0].Sym + "+17(SB)"
+		if x86RawReturnMemoryBound(file.Funcs[0], file, opt, true) {
+			t.Fatal("changed read extending outside the shared object retained decoder proof")
+		}
+	}
+}
+
+func TestX86RawReturnReadProofBindsCompleteOperandShape(t *testing.T) {
+	source := x86StaticReturnSource("Bound", x86RawPackedMoveLiteral(true, 32))
+	file, err := NormalizeRawFileForTranslation(mustParseX86RawReturn(t, source), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The same valid EVEX opcode now requests twice the memory width. A
+	// private proof tied only to Op/source-index would incorrectly survive.
+	read := &file.Funcs[0].Instrs[1]
+	read.Args[len(read.Args)-1].Reg = "Z0"
+	opt := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: Void}}}
+	if x86RawReturnMemoryBound(file.Funcs[0], file, opt, true) {
+		t.Error("wider destination inherited a 32-byte decoded read proof")
+	}
+	_, err = Translate(file, opt)
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Errorf("changed vector width reached final translation without Context: %v", err)
+	}
+}
diff --git a/amd64_raw_svm.go b/amd64_raw_svm.go
new file mode 100644
index 000000000..8517e834b
--- /dev/null
+++ b/amd64_raw_svm.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+// decodedX86SystemManagementInstruction covers AMD's fixed 0F 01 D8-DF
+// system-management family and Intel's matching KVM hypercall, VMCALL.
+// golang.org/x/arch/x86asm does not decode
+// these privileged instructions, so packages conventionally spell them as
+// Plan 9 BYTE directives even though LLVM 22 can assemble their mnemonics.
+func decodedX86SystemManagementInstruction(code []byte) (Instr, int, bool) {
+	if len(code) < 3 || code[0] != 0x0f || code[1] != 0x01 {
+		return Instr{}, 0, false
+	}
+	if code[2] == 0xc1 {
+		return Instr{Op: "VMCALL", Raw: "VMCALL"}, 3, true
+	}
+	if code[2] < 0xd8 || code[2] > 0xdf {
+		return Instr{}, 0, false
+	}
+	ops := [...]Op{
+		"VMRUN",
+		"VMMCALL",
+		"VMLOAD",
+		"VMSAVE",
+		"STGI",
+		"CLGI",
+		"SKINIT",
+		"INVLPGA",
+	}
+	op := ops[code[2]-0xd8]
+	return Instr{Op: op, Raw: string(op)}, 3, true
+}
diff --git a/amd64_raw_svm_test.go b/amd64_raw_svm_test.go
new file mode 100644
index 000000000..c8faba1a1
--- /dev/null
+++ b/amd64_raw_svm_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86RawDecoderCompleteAMDSystemManagementFamily(t *testing.T) {
+	family := []struct {
+		opcode byte
+		op     Op
+	}{
+		{opcode: 0xd8, op: "VMRUN"},
+		{opcode: 0xd9, op: "VMMCALL"},
+		{opcode: 0xda, op: "VMLOAD"},
+		{opcode: 0xdb, op: "VMSAVE"},
+		{opcode: 0xdc, op: "STGI"},
+		{opcode: 0xdd, op: "CLGI"},
+		{opcode: 0xde, op: "SKINIT"},
+		{opcode: 0xdf, op: "INVLPGA"},
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, test := range family {
+			t.Run(goarch+"/"+string(test.op), func(t *testing.T) {
+				fn := Func{Instrs: []Instr{
+					{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: 0x0f}}},
+					{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: 0x01}}},
+					{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(test.opcode)}}},
+				}}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != test.op || len(got.Instrs[0].Args) != 0 {
+					t.Fatalf("decoded 0f 01 %02x as %#v, want one operand-free %s", test.opcode, got.Instrs, test.op)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86RawAMDSystemManagementFamilyAllTargets(t *testing.T) {
+	const source = `TEXT svmfamily(SB),$0-0
+	BYTE $0x0f; BYTE $0x01; BYTE $0xd8 // VMRUN
+	BYTE $0x0f; BYTE $0x01; BYTE $0xd9 // VMMCALL
+	BYTE $0x0f; BYTE $0x01; BYTE $0xda // VMLOAD
+	BYTE $0x0f; BYTE $0x01; BYTE $0xdb // VMSAVE
+	BYTE $0x0f; BYTE $0x01; BYTE $0xdc // STGI
+	BYTE $0x0f; BYTE $0x01; BYTE $0xdd // CLGI
+	BYTE $0x0f; BYTE $0x01; BYTE $0xde // SKINIT
+	BYTE $0x0f; BYTE $0x01; BYTE $0xdf // INVLPGA
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs:         map[string]FuncSig{"svmfamily": {Name: "svmfamily", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"vmrun", "vmmcall", "vmload", "vmsave", "stgi", "clgi", "skinit", "invlpga"} {
+				if !strings.Contains(ll, `asm sideeffect "`+op+`"`) {
+					t.Fatalf("translated IR does not retain %s:\n%s", op, ll)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-svm-family-"+target.name+".ll", "raw-svm-family-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateX86AMDSystemManagementFamilyRejectsOperands(t *testing.T) {
+	for _, op := range []string{"VMRUN", "VMMCALL", "VMLOAD", "VMSAVE", "STGI", "CLGI", "SKINIT", "INVLPGA"} {
+		file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+op+" AX\n")
+		if err != nil {
+			t.Fatalf("Parse(%s AX) error = %v", op, err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "x86_64-unknown-linux-gnu",
+			Goarch:       "amd64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted operand form for fixed no-operand %s", op)
+		}
+	}
+}
diff --git a/amd64_raw_text_blob_test.go b/amd64_raw_text_blob_test.go
new file mode 100644
index 000000000..e9c9311ec
--- /dev/null
+++ b/amd64_raw_text_blob_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestX86AddressSensitiveRawTextBlobReportedURootFarJump(t *testing.T) {
+	const source = x86URootFarJumpOriginalSource
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, signatures := x86UnboundVoidFormatSources(t, source, target.goarch, target.triple)
+			normalized := x86URootFarJumpNormalizedFile(t, file, target.goarch)
+
+			// The complete original setup has public Context above. This
+			// private object owns only the selected raw TEXT's physical bytes;
+			// it supplies no executable setup or writable-code contract.
+			var format strings.Builder
+			fmt.Fprintf(&format, "target triple = %q\n", target.triple)
+			if err := emitX86AddressSensitiveRawText(&format, normalized.Funcs[1], signatures["farjump64"]); err != nil {
+				t.Fatal(err)
+			}
+			ir := format.String()
+			if !strings.Contains(ir, "define void @farjump64()") ||
+				!strings.Contains(ir, "naked noinline") ||
+				!strings.Contains(ir, `.byte 255, 45, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0`) {
+				t.Fatalf("byte-exact naked raw TEXT body missing:\n%s", ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-text-"+target.name+".ll", "raw-text-"+target.name+".o", ir)
+			assertX86RawTextAssemblyBytes(t, llc, target.triple, ir, []byte{0xff, 0x2d, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0})
+		})
+	}
+}
+
+func TestX86AddressSensitiveRawTextLeadingPCALIGNFormats(t *testing.T) {
+	for _, alignment := range []int{8, 16, 32, 64, 128, 256, 512, 1024, 2048} {
+		t.Run(strconv.Itoa(alignment), func(t *testing.T) {
+			source := fmt.Sprintf(`TEXT refer(SB),$0-0
+	LEAQ data(SB), AX
+	RET
+TEXT data(SB),$0
+	PCALIGN $%d
+	LONG $0xdeadbeef
+`, alignment)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for pass := 0; pass < 2; pass++ {
+				file, err = normalizeX86RawFile(file, "amd64")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got := file.Funcs[1].X86RawAlign; got != int64(alignment) {
+					t.Fatalf("alignment after normalization = %d, want %d", got, alignment)
+				}
+			}
+		})
+	}
+}
+
+func assertX86RawTextAssemblyBytes(t *testing.T, llc, triple, ir string, want []byte) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "raw-text.ll")
+	if err := os.WriteFile(path, []byte(ir), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command(llc, "-mtriple="+triple, "-filetype=asm", "-o", "-", path)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM 22 assembly emission failed: %v\n%s", err, out)
+	}
+	var got []byte
+	for _, line := range strings.Split(string(out), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) != 2 || fields[0] != ".byte" {
+			continue
+		}
+		value, err := strconv.ParseUint(fields[1], 0, 8)
+		if err != nil {
+			t.Fatalf("parse emitted byte line %q: %v", line, err)
+		}
+		got = append(got, byte(value))
+	}
+	if string(got) != string(want) {
+		t.Fatalf("LLVM 22 emitted raw TEXT bytes %v, want %v\n%s", got, want, out)
+	}
+}
+
+func TestX86AddressSensitiveRawTextBlobSelection(t *testing.T) {
+	const source = `TEXT refs(SB),NOSPLIT,$0-0
+	MOVL AX, farjump32+1(SB)
+	LEAQ gdt(SB), CX
+	MOVL info(SB), BX
+	RET
+TEXT farjump32(SB),NOSPLIT,$0-0
+	BYTE $0xea; LONG $0; WORD $0x18
+TEXT gdt(SB),NOSPLIT,$0-0
+	QUAD $0; QUAD $0x00cf9a000000ffff
+TEXT info(SB),NOSPLIT,$0-0
+	LONG $0
+TEXT semantic(SB),NOSPLIT,$0-0
+	BYTE $0x90; BYTE $0xc3
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	wants := map[string][]byte{
+		"farjump32": {0xea, 0, 0, 0, 0, 0x18, 0},
+		"gdt":       {0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0, 0x9a, 0xcf, 0},
+		"info":      {0, 0, 0, 0},
+	}
+	for _, fn := range normalized.Funcs {
+		want, selected := wants[fn.Sym]
+		if selected && string(fn.X86RawText) != string(want) {
+			t.Fatalf("%s raw TEXT bytes %v, want %v", fn.Sym, fn.X86RawText, want)
+		}
+		if fn.Sym == "semantic" && fn.X86RawText != nil {
+			t.Fatal("unaddressed raw instruction body bypassed semantic decoding")
+		}
+	}
+}
+
+// Older x86 assemblers recognize PCALIGN in the parser but have no backend
+// implementation. Observe that exact tool defect separately; it is neither a
+// successful Go object nor a source-format rejection. LLVM objects below are
+// still required on every supported library toolchain.
+func x86AlignedRawTextGoObject(t *testing.T, source string) {
+	t.Helper()
+	directory := t.TempDir()
+	assembly, object := filepath.Join(directory, "aligned.s"), filepath.Join(directory, "aligned.o")
+	if err := os.WriteFile(assembly, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "example.com/forms", "-o", object, assembly)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	// Joined pipe or cleanup failures are infrastructure errors, even when
+	// they contain the assembler's expected exit status and diagnostic.
+	exit, directExit := err.(*exec.ExitError)
+	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
+	if !goToolchainAtLeast(runtime.Version(), 1, 22) && ctx.Err() == nil && directExit && exit.ExitCode() == 1 &&
+		len(lines) == 2 && strings.HasPrefix(lines[0], "asm: asmins: missing op ") &&
+		strings.Contains(lines[0], "(<unknown line number>)\tPCALIGN\t$32") && lines[1] == "asm: assembly failed" {
+		t.Logf("GO_PCAlign_BACKEND_DEFECT_OBSERVED compiler=%s target=linux/amd64; no successful Go object claimed: %s", runtime.Version(), output)
+		return
+	}
+	if failure := goAssemblerOracleOutcome(assembly, object, output, err, ctx.Err(), true, "amd64", "example.com/forms"); failure != nil {
+		t.Fatalf("actual aligned raw TEXT compiler observation: %v\n%s", failure, output)
+	}
+}
+
+func TestX86AddressSensitiveAlignedRawTextBlobReportedURoot(t *testing.T) {
+	const source = `TEXT trampoline_start(SB),$0-0
+	LEAQ stack_top(SB), AX
+	MOVQ (AX), AX
+	RET
+TEXT stack_top(SB),$0
+	PCALIGN $32
+	LONG $0xdeadbeef
+`
+	x86AlignedRawTextGoObject(t, source)
+
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var blob *Func
+	for index := range normalized.Funcs {
+		if normalized.Funcs[index].Sym == "stack_top" {
+			blob = &normalized.Funcs[index]
+		}
+	}
+	if blob == nil || string(blob.X86RawText) != string([]byte{0xef, 0xbe, 0xad, 0xde}) || blob.X86RawAlign != 32 {
+		t.Fatalf("aligned raw TEXT was not retained: %+v", blob)
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	addressOnly := strings.Replace(source, "\tMOVQ (AX), AX\n", "", 1)
+	x86AlignedRawTextGoObject(t, addressOnly)
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "linux", triple: "x86_64-unknown-linux-gnu"},
+		{name: "darwin", triple: "x86_64-apple-darwin"},
+		{name: "windows", triple: "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			options := Options{
+				Goarch:       "amd64",
+				TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{
+					"trampoline_start": {Name: "trampoline_start", Ret: Void},
+					"stack_top":        {Name: "stack_top", Ret: Void},
+				},
+			}
+			ir, err := Translate(file, options)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("addressing four raw TEXT bytes authorized an eight-byte read", err)
+			}
+			// The original source and blob checks above remain unchanged.
+			// This separate address-only program checks alignment and emitted
+			// bytes without pretending that the original load had an owner.
+			addressFile, err := Parse(ArchAMD64, addressOnly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err = Translate(addressFile, options)
+			if err != nil || ir == "" {
+				t.Fatal("separate address-only raw TEXT program lost its object path", err)
+			}
+			if !strings.Contains(ir, "define void @stack_top()") || !strings.Contains(ir, " align 32 {") {
+				t.Fatal("aligned raw TEXT declaration missing")
+			}
+			compileLLVMToObject(t, llc, target.triple, "aligned-raw-text.ll", "aligned-raw-text.o", ir)
+			assertX86RawTextAssemblyBytes(t, llc, target.triple, ir, []byte{0xef, 0xbe, 0xad, 0xde})
+		})
+	}
+}
diff --git a/amd64_raw_text_contract_test.go b/amd64_raw_text_contract_test.go
new file mode 100644
index 000000000..21c463f20
--- /dev/null
+++ b/amd64_raw_text_contract_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86URootFarJumpOriginalSource = `TEXT setup(SB),NOSPLIT,$0-0
+	MOVL AX, farjump64+6(SB)
+	JMP farjump64(SB)
+TEXT farjump64(SB),NOSPLIT,$0-0
+	BYTE $0xff; BYTE $0x2d; LONG $0
+	LONG $0
+	LONG $8
+`
+
+func x86URootFarJumpNormalizedFile(t *testing.T, file *File, arch string) *File {
+	t.Helper()
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("complete original far-jump source could not be normalized", err)
+	}
+	if len(normalized.Funcs) != 2 || normalized.Funcs[0].Sym != "setup" || normalized.Funcs[1].Sym != "farjump64" ||
+		len(normalized.Data) != 0 || len(normalized.Globl) != 0 {
+		t.Fatal("original setup/raw-TEXT inventory changed")
+	}
+	if len(normalized.Funcs[0].Instrs) != 3 || normalized.Funcs[0].X86RawText != nil ||
+		!reflect.DeepEqual(normalized.Funcs[0].Instrs, file.Funcs[0].Instrs) {
+		t.Fatal("raw TEXT selection omitted or rewrote the original setup instructions")
+	}
+	want := []byte{0xff, 0x2d, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0}
+	if len(normalized.Funcs[1].Instrs) != 6 || !bytes.Equal(normalized.Funcs[1].X86RawText, want) {
+		t.Fatalf("complete original 14-byte far-jump inventory changed: %x", normalized.Funcs[1].X86RawText)
+	}
+	return normalized
+}
+
+func TestX86AddressSensitiveRawTextFarJumpOriginalContextAndInventory(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			// Stock Go accepts the complete original source. Its public LLVM
+			// translation still needs initialized AX and writable TEXT backing.
+			file, _ := x86UnboundVoidFormatSources(t, x86URootFarJumpOriginalSource, target.arch, target.triple)
+			x86URootFarJumpNormalizedFile(t, file, target.arch)
+		})
+	}
+}
+
+func TestX86AddressSensitiveRawTextStoreNeedsSourceAndWritableData(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			name       string
+			initialize string
+			text       bool
+			context    bool
+		}{
+			{name: "owned-data-initialized", initialize: "MOVL $7, AX\n"},
+			{name: "owned-data-uninitialized", context: true},
+			{name: "owned-data-partial-input", initialize: "MOVW $7, AX\n", context: true},
+			{name: "text-initialized", initialize: "MOVL $7, AX\n", text: true, context: true},
+			{name: "text-uninitialized", text: true, context: true},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				storage := "GLOBL cell(SB),NOPTR,$14\n"
+				var tail string
+				declarations := "func patch()\n"
+				if row.text {
+					storage = ""
+					tail = "TEXT cell(SB),NOSPLIT,$0-0\nBYTE $0xff; BYTE $0x2d; LONG $0\nLONG $0\nLONG $8\n"
+					declarations += "func cell()\n"
+				}
+				source := storage + "TEXT patch(SB),NOSPLIT,$0-0\n" + row.initialize + "MOVL AX, cell+6(SB)\nRET\n" + tail
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+						if row.context {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "MOVL AX, cell+6(SB)") {
+								t.Fatal("static store invented numerical input or writable TEXT backing", err)
+							}
+						} else if err != nil || ir == "" {
+							t.Fatal("initialized store to actual module-owned writable DATA failed", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_raw_text_frame.go b/amd64_raw_text_frame.go
new file mode 100644
index 000000000..164368807
--- /dev/null
+++ b/amd64_raw_text_frame.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Naked emission preserves the raw directive bytes, not obj6's additional
+// Go frame, wrapper or stack-split prologue. Keep this source boundary explicit
+// even when the body's bytes are data rather than decodable instructions.
+func validateX86AddressSensitiveRawText(fn Func, goarch string) error {
+	if fn.FrameSize != 0 || fn.ArgSize != 0 {
+		return fmt.Errorf("%w: address-sensitive raw TEXT needs its source Go frame/argument transport contract", ErrProbeNeedsContext)
+	}
+	if len(fn.Instrs) == 0 || fn.Instrs[0].Op != OpTEXT {
+		return fmt.Errorf("%w: address-sensitive raw TEXT needs an actual source TEXT header", ErrProbeNeedsContext)
+	}
+	_, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) != 2 && len(parts) != 3 {
+		return fmt.Errorf("%w: address-sensitive raw TEXT needs a resolved source header", ErrProbeNeedsContext)
+	}
+	if !strings.HasPrefix(strings.TrimSpace(parts[len(parts)-1]), "$") {
+		return fmt.Errorf("%w: address-sensitive raw TEXT needs a known source frame", ErrProbeNeedsContext)
+	}
+	frame, args, err := parseTEXTFrame(parts)
+	if err != nil || frame != fn.FrameSize || args != fn.ArgSize {
+		return fmt.Errorf("%w: address-sensitive raw TEXT source frame differs from its retained metadata", ErrProbeNeedsContext)
+	}
+	var flags uint64
+	if len(parts) == 3 {
+		expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+			if value, known := goTextFlagValues[name]; known {
+				return value
+			}
+			return name
+		})
+		var known bool
+		flags, known = parseImmExpr(strings.TrimSpace(expression))
+		if !known {
+			return fmt.Errorf("%w: address-sensitive raw TEXT flags need actual Go source context", ErrProbeNeedsContext)
+		}
+	}
+	if flags & ^uint64(2|4|512) != 0 {
+		return fmt.Errorf("%w: address-sensitive raw TEXT requires unmodeled Go prologue/entry flags", ErrProbeNeedsContext)
+	}
+	if goarch == "386" && flags&4 == 0 {
+		return fmt.Errorf("%w: address-sensitive 386 raw TEXT cannot omit Go's stack-split prologue", ErrProbeNeedsContext)
+	}
+	return nil
+}
diff --git a/amd64_raw_text_frame_test.go b/amd64_raw_text_frame_test.go
new file mode 100644
index 000000000..5ebdbda45
--- /dev/null
+++ b/amd64_raw_text_frame_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86AddressSensitiveFrameSource(arch, text string) string {
+	address := "LEAQ"
+	if arch == "386" {
+		address = "LEAL"
+	}
+	return fmt.Sprintf("TEXT refer(SB),4,$0-0\n%s blob(SB),AX\nRET\nTEXT blob(SB),%s\nBYTE $0xc3\n", address, text)
+}
+
+func requireX86RawTextContextAPIs(t *testing.T, file *File, opt Options) {
+	t.Helper()
+	for _, api := range []string{"text", "module", "owned-module", "annotated"} {
+		var callErr error
+		switch api {
+		case "text":
+			_, callErr = Translate(file, opt)
+		case "module":
+			module, err := TranslateModule(file, opt)
+			if err == nil {
+				module.Dispose()
+			}
+			callErr = err
+		default:
+			ctx := llvm.NewContext()
+			options := opt
+			options.AnnotateSource = api == "annotated"
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err == nil {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			callErr = err
+		}
+		if !errors.Is(callErr, ErrProbeNeedsContext) {
+			t.Errorf("%s omitted raw TEXT's source prologue/Go-frame contract: %v", api, callErr)
+		}
+	}
+}
+
+func TestX86AddressSensitiveRawTextNeedsSourceFrameContract(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, text := range []string{"4,$8-0", "4,$16-0", "4,$0-8", "32,$0-0"} {
+			t.Run(target.triple+"/"+text, func(t *testing.T) {
+				source := x86AddressSensitiveFrameSource(target.arch, text)
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				requireX86RawTextContextAPIs(t, file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"refer": {Name: "refer", Ret: Void}, "blob": {Name: "blob", Ret: Void}},
+				})
+			})
+		}
+	}
+}
+
+func TestX86AddressSensitiveRawTextCannotBypassGoFrameTransport(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, sig := range []FuncSig{
+			{Name: "blob", Ret: Void, Args: []LLVMType{I32}, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I32, Field: -1}}}},
+			{Name: "blob", Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I32, Field: -1}}}},
+		} {
+			t.Run(target.triple+"/"+string(sig.Ret), func(t *testing.T) {
+				source := x86AddressSensitiveFrameSource(target.arch, "4,$0-0")
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				requireX86RawTextContextAPIs(t, file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"refer": {Name: "refer", Ret: Void}, "blob": sig},
+				})
+			})
+		}
+	}
+}
+
+func TestX86AddressSensitiveRawText386CannotOmitStackSplit(t *testing.T) {
+	// obj6's automatic NOSPLIT leaf promotion is amd64-only. An unflagged
+	// 386 TEXT has real TLS/stack-check bytes before the raw source body.
+	plain := assembleX87ControlBytes(t, "386", "TEXT blob(SB),$0-0\nBYTE $0xc3\n")
+	nosplit := assembleX87ControlBytes(t, "386", "TEXT blob(SB),4,$0-0\nBYTE $0xc3\n")
+	if len(nosplit) != 1 || nosplit[0] != 0xc3 || len(plain) <= len(nosplit) {
+		t.Fatalf("Go source prologue witness is not independent: plain=%x NOSPLIT=%x", plain, nosplit)
+	}
+	t.Logf("actual Go 386 source TEXT bytes: unflagged=%x NOSPLIT=%x", plain, nosplit)
+	file, err := Parse(ArchAMD64, x86AddressSensitiveFrameSource("386", "$0-0"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	requireX86RawTextContextAPIs(t, file, Options{
+		Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"refer": {Name: "refer", Ret: Void}, "blob": {Name: "blob", Ret: Void}},
+	})
+}
+
+func TestX86AddressSensitiveRawTextFramelessBytesRemainExact(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		flags := []string{"4,$0-0", "6,$0-0", "516,$0-0"}
+		if target.arch == "amd64" {
+			// obj6 promotes this raw-only, zero-frame amd64 leaf to NOSPLIT.
+			flags = append(flags, "$0-0")
+		}
+		for _, text := range flags {
+			t.Run(target.triple+"/"+text, func(t *testing.T) {
+				original := assembleX87ControlBytes(t, target.arch, "TEXT blob(SB),"+text+"\nBYTE $0xc3\n")
+				if len(original) != 1 || original[0] != 0xc3 {
+					t.Fatalf("source Go TEXT unexpectedly adds a native prologue: %x", original)
+				}
+				file, err := Parse(ArchAMD64, x86AddressSensitiveFrameSource(target.arch, text))
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, Options{
+					Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"refer": {Name: "refer", Ret: Void}, "blob": {Name: "blob", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer module.Dispose()
+				compileLLVMToObject(t, llc, target.triple, "frameless-raw-text.ll", "frameless-raw-text.o", module.String())
+				assertX86RawTextAssemblyBytes(t, llc, target.triple, module.String(), original)
+			})
+		}
+	}
+}
diff --git a/amd64_raw_unaligned_load.go b/amd64_raw_unaligned_load.go
new file mode 100644
index 000000000..0f9dd45e1
--- /dev/null
+++ b/amd64_raw_unaligned_load.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import "fmt"
+
+func decodedX86VEXUnalignedLoadInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.mapNumber != 1 || p.opcode != 0xf0 || p.pp != 3 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VLDDQU: %s", message)
+	}
+	if mode != 32 && mode != 64 || p.evex || p.vectorLength > 1 || p.upper != 0 || p.addressOverride {
+		return fail("invalid mode, VEX generation, length, reserved vvvv or address size")
+	}
+	if len(code) <= p.modRM || code[p.modRM]>>6 == 3 {
+		return fail("missing or non-memory ModRM")
+	}
+	if mode == 32 && (p.r != 0 || p.b != 0 || p.x != 0) {
+		return fail("extended register unavailable in physical mode32")
+	}
+	bank := []string{"X", "Y"}[p.vectorLength]
+	source, size, err := decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, bank)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if p.modRM+size > 15 {
+		return fail("instruction exceeds 15 bytes")
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", bank, int(code[p.modRM]>>3&7)+p.r*8))}
+	ins := Instr{Op: "VLDDQU", Args: []Operand{source, destination}, x86Encoded: true}
+	ins.Raw = fmt.Sprintf("VLDDQU %s,%s", source.String(), destination.String())
+	return ins, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_unaligned_load_test.go b/amd64_raw_unaligned_load_test.go
new file mode 100644
index 000000000..fa2d5e66d
--- /dev/null
+++ b/amd64_raw_unaligned_load_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestDecodedX86VEXUnalignedLoadCompleteMemoryForms(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		limit := 8
+		if mode == 64 {
+			limit = 16
+		}
+		for _, memory := range []struct {
+			encoded []byte
+			source  string
+		}{
+			{[]byte{0x00}, "(AX)"},
+			{[]byte{0x40, 0x81}, "-127(AX)"},
+			{[]byte{0x80, 0x78, 0x56, 0x34, 0x12}, "305419896(AX)"},
+			{[]byte{0x44, 0x8b, 0x10}, "16(BX)(CX*4)"},
+		} {
+			for _, segment := range []struct {
+				prefix []byte
+				name   Reg
+			}{{nil, ""}, {[]byte{0x64}, FS}, {[]byte{0x65}, GS}} {
+				for width, bank := range []string{"X", "Y"} {
+					for destination := 0; destination < limit; destination++ {
+						for _, header := range [][]byte{
+							{0xc5, byte(0xfb ^ destination/8<<7 | width<<2), 0xf0},
+							{0xc4, byte(0xe1 ^ destination/8<<7), byte(0x7b | width<<2), 0xf0},
+							{0xc4, byte(0xe1 ^ destination/8<<7), byte(0xfb | width<<2), 0xf0},
+						} {
+							code := append(append([]byte(nil), segment.prefix...), header...)
+							address := append([]byte(nil), memory.encoded...)
+							address[0] |= byte(destination&7) << 3
+							code = append(code, address...)
+							want := x86ScalarLaneInstruction(t, fmt.Sprintf("VLDDQU %s,%s%d", memory.source, bank, destination))
+							want.Args[0].Mem.Segment = segment.name
+							got, length, known, err := decodedX86VEXUnalignedLoadInstruction(append(code, 0xcc), mode)
+							if err != nil || !known || length != len(code) || got.Op != want.Op ||
+								!reflect.DeepEqual(got.Args, want.Args) || !got.x86Encoded {
+								t.Fatalf("complete VLDDQU %x mode%d: got=%+v length=%d known=%v err=%v want=%+v", code, mode, got, length, known, err, want)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86VEXUnalignedLoadInvalidAndWholeBoundaries(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, test := range []struct {
+			name string
+			code []byte
+		}{
+			{"reserved-vvvv", []byte{0xc4, 0xe1, 0x73, 0xf0, 0x00}},
+			{"register-source", []byte{0xc4, 0xe1, 0x7b, 0xf0, 0xc0}},
+			{"missing-modrm", []byte{0xc4, 0xe1, 0x7b, 0xf0}},
+			{"missing-sib", []byte{0xc4, 0xe1, 0x7b, 0xf0, 0x04}},
+			{"missing-disp8", []byte{0xc4, 0xe1, 0x7b, 0xf0, 0x40}},
+			{"short-disp32", []byte{0xc4, 0xe1, 0x7b, 0xf0, 0x80, 0, 0, 0}},
+			{"no-evex-form", []byte{0x62, 0xf1, 0x7f, 0x08, 0xf0, 0x00}},
+			{"address-layout", []byte{0x67, 0xc4, 0xe1, 0x7b, 0xf0, 0x00}},
+		} {
+			t.Run(fmt.Sprintf("mode%d/%s", mode, test.name), func(t *testing.T) {
+				_, _, known, err := decodedX86VEXUnalignedLoadInstruction(test.code, mode)
+				if !known || err == nil {
+					t.Fatal("invalid or incomplete physical VLDDQU accepted", known, err)
+				}
+			})
+		}
+		t.Run(fmt.Sprintf("mode%d/maximum-instruction-length", mode), func(t *testing.T) {
+			base := []byte{0xc4, 0xe1, 0x7b, 0xf0, 0x40, 1}
+			valid := append(bytes.Repeat([]byte{0x64}, 9), base...)
+			if _, length, known, err := decodedX86VEXUnalignedLoadInstruction(valid, mode); !known || err != nil || length != 15 {
+				t.Fatal("complete legal 15-byte boundary lost", length, known, err)
+			}
+			invalid := append(bytes.Repeat([]byte{0x64}, 10), base...)
+			if _, _, known, err := decodedX86VEXUnalignedLoadInstruction(invalid, mode); !known || err == nil {
+				t.Fatal("machine-invalid instruction longer than 15 bytes accepted", known, err)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_unpack_float_test.go b/amd64_raw_unpack_float_test.go
new file mode 100644
index 000000000..4f6378d74
--- /dev/null
+++ b/amd64_raw_unpack_float_test.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type rawFloatingUnpackSpec struct {
+	opcode byte
+	double bool
+	high   bool
+}
+
+var rawFloatingUnpackSpecs = []rawFloatingUnpackSpec{
+	{opcode: 0x14},
+	{opcode: 0x15, high: true},
+	{opcode: 0x14, double: true},
+	{opcode: 0x15, double: true, high: true},
+}
+
+func (spec rawFloatingUnpackSpec) op(vector bool) Op {
+	name := "UNPCKL"
+	if spec.high {
+		name = "UNPCKH"
+	}
+	if vector {
+		name = "V" + name
+	}
+	if spec.double {
+		name += "PD"
+	} else {
+		name += "PS"
+	}
+	return Op(name)
+}
+
+func encodeX86RawLegacyFloatingUnpack(spec rawFloatingUnpackSpec, source, destination int) []byte {
+	code := []byte{}
+	if spec.double {
+		code = append(code, 0x66)
+	}
+	rex := byte(0x40 | source>>3&1 | destination>>3&1<<2)
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, spec.opcode, byte(0xc0|destination&7<<3|source&7))
+}
+
+func encodeX86RawVEXFloatingUnpack(spec rawFloatingUnpackSpec, vectorBits byte, first, second, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 | 0x40 | byte((^first>>3)&1)<<5 | 1
+	p1 := byte(^second&15)<<3 | vectorBits<<2
+	if spec.double {
+		p1 |= 1
+	}
+	return []byte{0xc4, p0, p1, spec.opcode, byte(0xc0 | destination&7<<3 | first&7)}
+}
+
+func encodeX86RawEVEXFloatingUnpack(spec rawFloatingUnpackSpec, vectorBits byte, mask int, zeroing, broadcast bool, first, second, destination int) []byte {
+	p0 := byte((^destination>>3)&1)<<7 |
+		byte((^first>>4)&1)<<6 |
+		byte((^first>>3)&1)<<5 |
+		byte((^destination>>4)&1)<<4 | 1
+	p1 := byte(^second&15)<<3 | 4
+	if spec.double {
+		p1 |= 0x81
+	}
+	p2 := vectorBits<<5 | byte((^second>>4)&1)<<3 | byte(mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	return []byte{0x62, p0, p1, p2, spec.opcode, byte(0xc0 | destination&7<<3 | first&7)}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedSegDSPVUNPCKLPS(t *testing.T) {
+	// vunpcklps %xmm3, %xmm5, %xmm0;
+	// vinsertf128 $1, %xmm0, %ymm0, %ymm0
+	code := []byte{0xc5, 0xd0, 0x14, 0xc3, 0xc4, 0xe3, 0x7d, 0x18, 0xc0, 0x01}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "segdsp VUNPCKLPS sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || !strings.HasPrefix(decoded[0].Raw, "VUNPCKLPS X3, X5, X0 ") {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodedX86RawFloatingUnpackCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for _, spec := range rawFloatingUnpackSpecs {
+		for first := 0; first < 16; first++ {
+			for destination := 0; destination < 16; destination++ {
+				code := encodeX86RawLegacyFloatingUnpack(spec, first, destination)
+				got, length, ok, err := decodedX86FloatingUnpackInstruction(code, 64)
+				want := fmt.Sprintf("%s X%d, X%d", spec.op(false), first, destination)
+				if err != nil || !ok || length != len(code) || got.Raw != want {
+					t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+				}
+				count++
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 2; vectorBits++ {
+			vectorName := [...]string{"X", "Y"}[vectorBits]
+			for first := 0; first < 16; first++ {
+				for second := 0; second < 16; second++ {
+					for destination := 0; destination < 16; destination++ {
+						code := encodeX86RawVEXFloatingUnpack(spec, vectorBits, first, second, destination)
+						got, length, ok, err := decodedX86FloatingUnpackInstruction(code, 64)
+						want := fmt.Sprintf("%s %s%d, %s%d, %s%d", spec.op(true), vectorName, first, vectorName, second, vectorName, destination)
+						if err != nil || !ok || length != len(code) || got.Raw != want {
+							t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+						}
+						count++
+					}
+				}
+			}
+		}
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			vectorName := [...]string{"X", "Y", "Z"}[vectorBits]
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{{}, {mask: 3}, {mask: 7, zeroing: true, suffix: ".Z"}} {
+				for first := 0; first < 32; first++ {
+					for second := 0; second < 32; second++ {
+						for destination := 0; destination < 32; destination++ {
+							code := encodeX86RawEVEXFloatingUnpack(spec, vectorBits, masking.mask, masking.zeroing, false, first, second, destination)
+							got, length, ok, err := decodedX86FloatingUnpackInstruction(code, 64)
+							args := []string{fmt.Sprintf("%s%d", vectorName, first), fmt.Sprintf("%s%d", vectorName, second)}
+							if masking.mask != 0 {
+								args = append(args, fmt.Sprintf("K%d", masking.mask))
+							}
+							args = append(args, fmt.Sprintf("%s%d", vectorName, destination))
+							want := string(spec.op(true)) + masking.suffix + " " + strings.Join(args, ", ")
+							if err != nil || !ok || length != len(code) || got.Raw != want {
+								t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v; want %q", code, got, length, ok, err, want)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 1213440 {
+		t.Fatalf("covered %d floating-unpack register encodings, want 1213440", count)
+	}
+}
+
+func TestDecodedX86RawFloatingUnpackMemoryAndInvalidForms(t *testing.T) {
+	legacyMemory := []byte{0x66, 0x47, 0x0f, 0x15, 0x7c, 0x8b, 0x01}
+	got, length, ok, err := decodedX86FloatingUnpackInstruction(legacyMemory, 64)
+	wantMemory := MemRef{Base: "R11", Index: "R9", Scale: 4, Off: 1}
+	if err != nil || !ok || length != len(legacyMemory) || got.Op != "UNPCKHPD" || got.Args[1].String() != "X15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", legacyMemory, got, length, ok, err)
+	}
+	vexMemory := []byte{0xc4, 0x01, 0x75, 0x14, 0x7c, 0x8b, 0x02}
+	got, length, ok, err = decodedX86FloatingUnpackInstruction(vexMemory, 64)
+	wantMemory.Off = 2
+	if err != nil || !ok || length != len(vexMemory) || got.Op != "VUNPCKLPD" || got.Args[1].String() != "Y1" || got.Args[2].String() != "Y15" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", vexMemory, got, length, ok, err)
+	}
+	evexMemory := []byte{0x62, 0x01, 0x85, 0xdf, 0x15, 0x7c, 0x8b, 0x02}
+	got, length, ok, err = decodedX86FloatingUnpackInstruction(evexMemory, 64)
+	wantMemory.Off = 16
+	if err != nil || !ok || length != len(evexMemory) || got.Op != "VUNPCKHPD.BCST.Z" || got.Args[1].String() != "Z15" || got.Args[2].String() != "K7" || got.Args[3].String() != "Z31" || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", evexMemory, got, length, ok, err)
+	}
+
+	validVEX := encodeX86RawVEXFloatingUnpack(rawFloatingUnpackSpecs[0], 0, 7, 7, 7)
+	validEVEX := encodeX86RawEVEXFloatingUnpack(rawFloatingUnpackSpecs[0], 2, 0, false, false, 7, 7, 7)
+	for name, invalid := range map[string][]byte{
+		"vex W":                  {validVEX[0], validVEX[1], validVEX[2] | 0x80, validVEX[3], validVEX[4]},
+		"vex prefix":             {validVEX[0], validVEX[1], validVEX[2] | 0x02, validVEX[3], validVEX[4]},
+		"evex missing fixed bit": {validEVEX[0], validEVEX[1], validEVEX[2] &^ 0x04, validEVEX[3], validEVEX[4], validEVEX[5]},
+		"evex prefix":            {validEVEX[0], validEVEX[1], validEVEX[2] | 0x02, validEVEX[3], validEVEX[4], validEVEX[5]},
+		"evex reserved length":   {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x60, validEVEX[4], validEVEX[5]},
+		"zero without mask":      {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x80, validEVEX[4], validEVEX[5]},
+		"register broadcast":     {validEVEX[0], validEVEX[1], validEVEX[2], validEVEX[3] | 0x10, validEVEX[4], validEVEX[5]},
+		"address override":       append([]byte{0x67}, validVEX...),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86FloatingUnpackInstruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, invalid, instruction, matched, decodeErr)
+		}
+	}
+	masked386 := encodeX86RawEVEXFloatingUnpack(rawFloatingUnpackSpecs[0], 2, 1, false, false, 0, 1, 2)
+	if instruction, _, matched, decodeErr := decodedX86FloatingUnpackInstruction(masked386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 masked encoding %x decoded as %+v, ok=%v, err=%v", masked386, instruction, matched, decodeErr)
+	}
+	highZ386 := encodeX86RawEVEXFloatingUnpack(rawFloatingUnpackSpecs[0], 2, 0, false, false, 8, 1, 2)
+	if instruction, _, matched, decodeErr := decodedX86FloatingUnpackInstruction(highZ386, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 high-Z encoding %x decoded as %+v, ok=%v, err=%v", highZ386, instruction, matched, decodeErr)
+	}
+}
+
+func TestX86FloatingUnpackGo127ArchitectureOracle(t *testing.T) {
+	const accepted386 = `TEXT ok(SB),$0-0
+	VUNPCKLPS X20, X21, X22
+	VUNPCKLPD Y20, Y21, Y22
+	VUNPCKHPS Z5, Z6, Z7
+	VUNPCKHPD.BCST 8(AX), X20, X21
+	RET
+`
+	requireX86GoAssemblerResult(t, "386", accepted386, true)
+	for _, instruction := range []string{
+		"VUNPCKLPS Z8, Z1, Z2",
+		"VUNPCKHPS Z0, Z1, K1, Z2",
+	} {
+		requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n", false)
+	}
+}
+
+func TestTranslateX86RawFloatingUnpackTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name        string
+		goarch      string
+		triple      string
+		registerMax int
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin", registerMax: 15},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu", registerMax: 15},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc", registerMax: 15},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu", registerMax: 7},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc", registerMax: 7},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT raw_floating_unpack(SB),NOSPLIT,$0-0\n")
+			for _, spec := range rawFloatingUnpackSpecs {
+				code := [][]byte{
+					encodeX86RawLegacyFloatingUnpack(spec, target.registerMax, target.registerMax),
+					encodeX86RawVEXFloatingUnpack(spec, 1, target.registerMax, target.registerMax, target.registerMax),
+				}
+				if target.goarch == "amd64" {
+					code = append(code, encodeX86RawEVEXFloatingUnpack(spec, 2, 7, true, false, 31, 30, 29))
+				} else {
+					code = append(code, encodeX86RawEVEXFloatingUnpack(spec, 2, 0, false, false, 7, 6, 5))
+				}
+				for _, instruction := range code {
+					for _, value := range instruction {
+						fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			if target.goarch == "386" {
+				// These unmasked, register-only rows may propagate unknown
+				// bytes when every output is dead. They do not invent NUM.
+				x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+source.String())
+				exposed := strings.Replace(source.String(), "$0-0", "$0-4", 1)
+				exposed = strings.Replace(exposed, "\tRET\n", "MOVL X5,AX\nMOVL AX,ret0+0(FP)\nRET\n", 1)
+				x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+exposed)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func raw_floating_unpack()", target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("dead register-only unpack lost its complete source check", api, err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+					ir, err = x86ScalarFPBitViewAPI(t, exposed, "func raw_floating_unpack() uint32", target.goarch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead unpack scratch acquired an observable initialized result", api, err)
+					}
+				}
+				return
+			}
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-floating-unpack-"+target.name+".ll", "raw-floating-unpack-"+target.name+".o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_unreachable_tail_test.go b/amd64_raw_unreachable_tail_test.go
new file mode 100644
index 000000000..1096e2d11
--- /dev/null
+++ b/amd64_raw_unreachable_tail_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateX86UnreachableRawTailAfterReturn(t *testing.T) {
+	const source = `
+TEXT rawtail(SB),$0-0
+	RET
+GLOBL structtbl(SB),$8
+	BYTE $0x7b; BYTE $0x7d; BYTE $0x5b; BYTE $0x5d
+	BYTE $0x22; BYTE $0x3a; BYTE $0x2c; BYTE $0x27
+GLOBL wordtbl(SB),$4
+	BYTE $0x74; BYTE $0x68; BYTE $0x6e; BYTE $0x6b
+`
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.goarch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       target.goarch,
+				Sigs: map[string]FuncSig{
+					"rawtail": {Name: "rawtail", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "structtbl") || !strings.Contains(ll, "wordtbl") {
+				t.Fatal("GLOBL declarations disappeared from IR")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "x86-raw-unreachable-tail.ll", "x86-raw-unreachable-tail.o", ll)
+		})
+	}
+}
+
+func TestTranslateX86LabeledRawTailRemainsReachable(t *testing.T) {
+	const source = `
+TEXT rawtail(SB),$0-0
+	JMP tail
+	RET
+tail:
+	BYTE $0x7b; BYTE $0x7d
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"rawtail": {Name: "rawtail", Ret: Void},
+		},
+	}); err == nil || !strings.Contains(err.Error(), "outside directive group") {
+		t.Fatalf("reachable malformed raw tail was not rejected: %v", err)
+	}
+}
+
+func TestTranslateX86AddressObservedRawTailFailsClosed(t *testing.T) {
+	const source = `
+TEXT rawtail(SB),$0-0
+	RET
+	BYTE $0x7b; BYTE $0x7d
+TEXT address(SB),$0-0
+	MOVQ $rawtail(SB), AX
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Goarch:       "amd64",
+		Sigs: map[string]FuncSig{
+			"rawtail": {Name: "rawtail", Ret: Void},
+			"address": {Name: "address", Ret: Void},
+		},
+	}); err == nil || !strings.Contains(err.Error(), "address-observed raw tail") {
+		t.Fatalf("accepted layout-sensitive raw tail: %v", err)
+	}
+}
diff --git a/amd64_raw_valign_test.go b/amd64_raw_valign_test.go
new file mode 100644
index 000000000..c86661631
--- /dev/null
+++ b/amd64_raw_valign_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeX86RawVectorAlignCompleteGo127Family(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "dword x high masked", code: []byte{0x62, 0xa3, 0x55, 0x01, 0x03, 0xf4, 0xca}, want: "VALIGND $202, X20, X21, K1, X22"},
+		{name: "qword y memory zeroing", code: []byte{0x62, 0xd3, 0xf5, 0xaa, 0x03, 0x50, 0x03, 0x96}, want: "VALIGNQ.Z $150, 96(R8), Y1, K2, Y2"},
+		{name: "dword z register", code: []byte{0x62, 0x73, 0x55, 0x48, 0x03, 0xce, 0xca}, want: "VALIGND $202, Z6, Z5, Z9"},
+		{name: "dword z broadcast high masked", code: []byte{0x62, 0x53, 0x7d, 0x54, 0x03, 0x4c, 0x24, 0x7f, 0x44}, want: "VALIGND.BCST $68, 508(R12), Z16, K4, Z9"},
+		{name: "qword z broadcast zeroing", code: []byte{0x62, 0xf3, 0xf5, 0xdb, 0x03, 0x50, 0x7f, 0x09}, want: "VALIGNQ.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			decoded, err := decodeX86RawDirectiveGroup(test.code, 64, 0, "VALIGN", map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded) != 1 || !strings.HasPrefix(decoded[0].Raw, test.want+" ") {
+				t.Fatalf("decoded %x as %#v, want %q", test.code, decoded, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86RawVectorAlignAllRegisterFields(t *testing.T) {
+	for _, lane := range []struct {
+		w  byte
+		op Op
+	}{
+		{w: 0, op: "VALIGND"},
+		{w: 1, op: "VALIGNQ"},
+	} {
+		for vectorBits, vectorName := range []string{"X", "Y", "Z"} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						p0 := byte((^destination>>3)&1)<<7 |
+							byte((^first>>4)&1)<<6 |
+							byte((^first>>3)&1)<<5 |
+							byte((^destination>>4)&1)<<4 | 3
+						p1 := lane.w<<7 | byte(^second&15)<<3 | 5
+						p2 := byte(vectorBits)<<5 | byte((^second>>4)&1)<<3
+						modRM := byte(0xc0 | destination&7<<3 | first&7)
+						encoding := []byte{0x62, p0, p1, p2, 0x03, modRM, 0xa5}
+						instruction, length, ok, err := decodedX86VectorAlignInstruction(encoding, 64)
+						if !ok || err != nil || length != len(encoding) {
+							t.Fatalf("op=%s width=%s first=%d second=%d destination=%d: ok=%v length=%d err=%v", lane.op, vectorName, first, second, destination, ok, length, err)
+						}
+						want := fmt.Sprintf("%s $165, %s%d, %s%d, %s%d", lane.op, vectorName, first, vectorName, second, vectorName, destination)
+						if instruction.Raw != want {
+							t.Fatalf("encoding %x decoded as %q, want %q", encoding, instruction.Raw, want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawVectorAlignRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, test := range []struct {
+		name     string
+		mode     int
+		encoding []byte
+		wantOK   bool
+	}{
+		{name: "386 operand limit", mode: 32, encoding: []byte{0x62, 0xf3, 0x75, 0x08, 0x03, 0xc2, 0x01}, wantOK: true},
+		{name: "reserved vector length", mode: 64, encoding: []byte{0x62, 0xf3, 0x75, 0x68, 0x03, 0xc2, 0x01}, wantOK: true},
+		{name: "broadcast register", mode: 64, encoding: []byte{0x62, 0xf3, 0x75, 0x18, 0x03, 0xc2, 0x01}, wantOK: true},
+		{name: "zero without mask", mode: 64, encoding: []byte{0x62, 0xf3, 0x75, 0x88, 0x03, 0xc2, 0x01}, wantOK: true},
+		{name: "address override", mode: 64, encoding: []byte{0x67, 0x62, 0xf3, 0x75, 0x08, 0x03, 0xc2, 0x01}, wantOK: true},
+		{name: "missing immediate", mode: 64, encoding: []byte{0x62, 0xf3, 0x75, 0x08, 0x03, 0xc2}, wantOK: false},
+		{name: "wrong map", mode: 64, encoding: []byte{0x62, 0xf2, 0x75, 0x08, 0x03, 0xc2, 0x01}, wantOK: false},
+		{name: "wrong prefix", mode: 64, encoding: []byte{0x62, 0xf3, 0x74, 0x08, 0x03, 0xc2, 0x01}, wantOK: false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VectorAlignInstruction(test.encoding, test.mode)
+			if ok != test.wantOK {
+				t.Fatalf("encoding %x: ok=%v, want %v (err=%v)", test.encoding, ok, test.wantOK, err)
+			}
+			if test.wantOK && err == nil {
+				t.Fatalf("encoding %x was recognized without rejection", test.encoding)
+			}
+		})
+	}
+}
diff --git a/amd64_raw_variable_shift.go b/amd64_raw_variable_shift.go
new file mode 100644
index 000000000..51ad2eb09
--- /dev/null
+++ b/amd64_raw_variable_shift.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+// Go has five VEX+EVEX D/Q members and four EVEX-only W/Q members.
+// All use per-element counts, not the scalar count of VPSLL/PSRL/PSRA.
+func decodedX86PerLaneVariableShiftInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86PerLaneVariableShiftInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86PerLaneVariableShiftInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	// F3.0F38 opcodes 10-12 are single-source narrowing instructions,
+	// not a malformed 66.0F38 per-lane shift. Other wrong prefixes remain
+	// owned here so callers get an explicit invalid-form diagnostic.
+	if !matched || p.mapNumber != 2 || p.pp == 2 {
+		return Instr{}, 0, false, nil
+	}
+	var op Op
+	var spec amd64PerLaneVariableShiftSpec
+	owned := false
+	for name, candidate := range amd64PerLaneVariableShiftSpecs {
+		if int(candidate.opcode) != p.opcode {
+			continue
+		}
+		owned = true
+		if p.w == (candidate.laneBits != 32) {
+			op, spec = Op(name), candidate
+			break
+		}
+	}
+	if !owned {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("per-lane variable shift: %s", message)
+	}
+	if op == "" {
+		return fail("invalid element width bit")
+	}
+	if !p.evex && !spec.vex {
+		return fail("instruction requires EVEX encoding")
+	}
+
+	ins, consumed, known, err := decodedX86BinaryVectorOperandsWithMemory(code, p, mode, op, spec.laneBits, memory)
+	if known && err == nil {
+		ins.x86PackedShiftEncoding = x86RawPackedShiftVEX
+		if p.evex {
+			ins.x86PackedShiftEncoding = x86RawPackedShiftEVEX
+		}
+		ins.x86PackedShiftW = p.w
+	}
+	return ins, consumed, known, err
+}
diff --git a/amd64_raw_variable_shift_literal_test.go b/amd64_raw_variable_shift_literal_test.go
new file mode 100644
index 000000000..a8562e2f4
--- /dev/null
+++ b/amd64_raw_variable_shift_literal_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawVariableShiftLiteral(op string, evex bool, width int, broadcast bool) []byte {
+	spec := amd64PerLaneVariableShiftSpecs[op]
+	mask, zeroing := 0, false
+	if evex {
+		mask, zeroing = 7, true
+	}
+	code := encodeRawScalarMove(evex, 1, int(spec.opcode), 0, 0, 0, mask, zeroing)
+	code[1] = code[1]&0xf0 | 2
+	code[2] &^= 0x80
+	if spec.laneBits != 32 {
+		code[2] |= 0x80
+	}
+	if evex {
+		code[3] |= byte(map[int]int{16: 0, 32: 1, 64: 2}[width]) << 5
+		if broadcast {
+			code[3] |= 0x10
+		}
+	} else if width == 32 {
+		code[2] |= 0x04
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	dataWidth := width
+	if broadcast {
+		dataWidth = spec.laneBits / 8
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*19+3))
+	}
+	return code
+}
+
+func TestDecodeX86RawVariableShiftRIPDataCompleteFamily(t *testing.T) {
+	for _, op := range x86VariableShiftTestOps {
+		spec := amd64PerLaneVariableShiftSpecs[op]
+		for _, evex := range []bool{false, true} {
+			if !evex && !spec.vex {
+				continue
+			}
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				broadcasts := []bool{false}
+				if evex && spec.laneBits >= 32 {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("%s/evex%t/%d/bcst%t", op, evex, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawVariableShiftLiteral(op, evex, width, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := Op(op)
+						if broadcast {
+							want += ".BCST"
+						}
+						if evex {
+							want += ".Z"
+						}
+						if len(decoded) != 2 || decoded[0].Op != want ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVariableShiftRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVariableShiftLiteral("VPSLLVQ", true, 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVariableShiftRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, op := range x86VariableShiftTestOps {
+		spec := amd64PerLaneVariableShiftSpecs[op]
+		evex := !spec.vex || index%2 == 0
+		width := 32
+		if evex {
+			width = 64
+		}
+		broadcast := evex && spec.laneBits >= 32
+		code := x86RawVariableShiftLiteral(op, evex, width, broadcast)
+		name := fmt.Sprintf("variableShiftLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		dataWidth := width
+		if broadcast {
+			dataWidth = spec.laneBits / 8
+		}
+		pools = append(pools, code[len(code)-dataWidth:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86PackedShiftRawFormatObject(t, file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			compileLLVMToObject(t, llc, triple, "variable-shift-literal.ll", "variable-shift-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_variable_shift_test.go b/amd64_raw_variable_shift_test.go
new file mode 100644
index 000000000..bf98eebe8
--- /dev/null
+++ b/amd64_raw_variable_shift_test.go
@@ -0,0 +1,469 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86VariableShiftTestOps = []string{"VPSLLVW", "VPSLLVD", "VPSLLVQ", "VPSRLVW", "VPSRLVD", "VPSRLVQ", "VPSRAVW", "VPSRAVD", "VPSRAVQ"}
+
+func TestX86VariableShiftGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`(?s)\{as: A(VPS(?:LL|RL|RA)V[WDQ]), ytab: (\w+), prefix: Pavx, op: opBytes\{(.*?)\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 9 || len(rows) != len(amd64PerLaneVariableShiftSpecs) {
+		t.Fatalf("Go entries=%d, grammar=%d", len(rows), len(amd64PerLaneVariableShiftSpecs))
+	}
+	for _, row := range rows {
+		spec, ok := amd64PerLaneVariableShiftSpecs[row[1]]
+		if !ok {
+			t.Fatalf("missing %s", row[1])
+		}
+		bits := map[byte]int{'W': 16, 'D': 32, 'Q': 64}[row[1][len(row[1])-1]]
+		operation := "shl"
+		if strings.HasPrefix(row[1], "VPSRL") {
+			operation = "lshr"
+		}
+		if strings.HasPrefix(row[1], "VPSRA") {
+			operation = "ashr"
+		}
+		if spec.laneBits != bits || spec.operation != operation || spec.arithmetic != (operation == "ashr") {
+			t.Fatalf("Go semantics differ for %s: %+v", row[1], spec)
+		}
+		vex := bits != 16 && row[1] != "VPSRAVQ"
+		if spec.vex != vex || (row[2] == "_yvandnpd") != vex || strings.Contains(row[3], "| vex128") != vex || strings.Contains(row[3], "evexBcst") != (bits != 16) {
+			t.Fatalf("Go encoding surface changed for %s: %s", row[1], row[3])
+		}
+		for _, opcode := range regexp.MustCompile(`0x[0-9A-F]+`).FindAllString(row[3], -1) {
+			if opcode != fmt.Sprintf("0x%X", spec.opcode) {
+				t.Fatalf("Go opcode %s != spec %+v", opcode, spec)
+			}
+		}
+	}
+}
+
+func TestX86RawVariableShiftGoEncoderForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			last := 7
+			if arch == "amd64" {
+				last = 31
+			}
+			var source strings.Builder
+			source.WriteString("TEXT shifts(SB),4,$0-0\n")
+			for _, op := range x86VariableShiftTestOps {
+				for _, width := range []string{"X", "Y", "Z"} {
+					for _, reg := range []int{0, last} {
+						for _, input := range []string{fmt.Sprintf("%s%d", width, last-reg), "(AX)", "-7(BX)(CX*4)", "64(SI)", "8192(DI)"} {
+							fmt.Fprintf(&source, "%s %s,%s%d,%s%d\n", op, input, width, reg, width, last-reg)
+							if arch == "amd64" {
+								fmt.Fprintf(&source, "%s %s,%s%d,K1,%s%d\n%s.Z %s,%s%d,K7,%s%d\n", op, input, width, reg, width, last-reg, op, input, width, reg, width, last-reg)
+							}
+						}
+						if !strings.HasSuffix(op, "W") {
+							for _, input := range []string{"-8(BX)(CX*4)", "64(SI)"} {
+								fmt.Fprintf(&source, "%s.BCST %s,%s%d,%s%d\n", op, input, width, reg, width, last-reg)
+								if arch == "amd64" {
+									fmt.Fprintf(&source, "%s.BCST %s,%s%d,K1,%s%d\n%s.BCST.Z %s,%s%d,K7,%s%d\n", op, input, width, reg, width, last-reg, op, input, width, reg, width, last-reg)
+								}
+							}
+						}
+					}
+					// Low registers force the VEX row where available, even when the
+					// high-register rows above necessarily select EVEX on amd64.
+					if width != "Z" {
+						fmt.Fprintf(&source, "%s %s0,%s1,%s2\n%s (AX),%s1,%s2\n", op, width, width, width, op, width, width)
+					}
+				}
+			}
+			source.WriteString("RET\n")
+			code := assembleX87ControlBytes(t, arch, source.String())
+			got, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			named, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := named.Funcs[0].Instrs[1:]
+			if len(got.Instrs) != len(want) {
+				t.Fatalf("got %d instructions, want %d", len(got.Instrs), len(want))
+			}
+			for i, instruction := range got.Instrs {
+				if instruction.Op != want[i].Op || !reflect.DeepEqual(instruction.Args, want[i].Args) {
+					t.Fatalf("instruction %d: %+v, want %+v", i, instruction, want[i])
+				}
+			}
+			var raw strings.Builder
+			raw.WriteString("TEXT shifts(SB),4,$0-0\n")
+			for _, value := range code {
+				fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+			}
+			file, err := Parse(ArchAMD64, raw.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (arch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				options := Options{Goarch: arch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"shifts": {Name: "shifts", Ret: Void}}}
+				if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original raw near RET acquired a native return/memory/input contract", err)
+				}
+				// Whole-file normalization correctly rejects this unbound
+				// native RET. Compile the independently byte-checked decoder
+				// output as an instruction-only unit, preserving its RET;
+				// do not replace RET by UD2 to manufacture public success.
+				units := *file
+				units.Funcs = []Func{got}
+				units.Funcs[0].Sym = "shifts"
+				units.Funcs[0].Instrs = append([]Instr{file.Funcs[0].Instrs[0]}, got.Instrs...)
+				ir := x86InstructionFormatObjectUnit(t, &units, options.Sigs, arch, triple, 0,
+					func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+						return c.lowerX86PackedShift(ins.Op, ins)
+					})
+				compileLLVMToObject(t, llc, triple, "shifts.ll", "shifts.o", ir)
+			}
+			t.Logf("%s: %d actual Go encodings", arch, len(want)-1)
+		})
+	}
+}
+
+func TestX86VariableShiftGoRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86VariableShiftTestOps {
+			lines := []string{op + " X0,Y1,Y2", op + " X0,X1,(AX)", op + ".Z X0,X1,X2", op + ".SAE X0,X1,X2", op + " X0,X1,K0,X2", op + ".BCST X0,X1,X2", op + ".Z.BCST (AX),X1,K1,X2", op + " $1,X1,X2"}
+			if strings.HasSuffix(op, "W") {
+				lines = append(lines, op+".BCST (AX),X1,X2")
+			}
+			if arch == "386" {
+				lines = append(lines, op+" Z8,Z0,Z1", op+" X0,X1,K1,X2")
+			}
+			for _, line := range lines {
+				// Go 1.20 emitted reserved zeroing/K0 for maskless .Z. Preserve
+				// the strict named/raw rejection even for that historical encoder.
+				{
+					dir := t.TempDir()
+					path := filepath.Join(dir, "invalid.s")
+					if err := os.WriteFile(path, []byte("TEXT bad(SB),4,$0-0\n"+line+"\nRET\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), path)
+					cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch)
+					out, err := cmd.CombinedOutput()
+					historicalZero := strings.HasPrefix(runtime.Version(), "go1.20") && strings.Contains(line, ".Z X0")
+					if historicalZero && err != nil || !historicalZero && err == nil {
+						t.Fatalf("Go %s unexpected acceptance for %s (historical zeroing=%v): %v %s", arch, line, historicalZero, err, out)
+					}
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				assertX86PerLaneVariableShiftRejected(t, arch, triple, line)
+			}
+		}
+	}
+}
+
+func TestX86RawVariableShiftEncodingAxes(t *testing.T) {
+	count := 0
+	for _, op := range x86VariableShiftTestOps {
+		bits := map[byte]int{'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		opcode := map[string]int{"VPSLLVW": 0x12, "VPSLLVD": 0x47, "VPSLLVQ": 0x47, "VPSRLVW": 0x10, "VPSRLVD": 0x45, "VPSRLVQ": 0x45, "VPSRAVW": 0x11, "VPSRAVD": 0x46, "VPSRAVQ": 0x46}[op]
+		for _, evex := range []bool{false, true} {
+			if !evex && (bits == 16 || op == "VPSRAVQ") {
+				continue
+			}
+			limit, widths := 16, 2
+			if evex {
+				limit, widths = 32, 3
+			}
+			for width := 0; width < widths; width++ {
+				for src1 := 0; src1 < limit; src1++ {
+					for src2 := 0; src2 < limit; src2++ {
+						for dst := 0; dst < limit; dst++ {
+							mask := 0
+							zero := false
+							if evex {
+								mask = (dst + src1 + src2) % 8
+								zero = mask != 0 && src2&1 != 0
+							}
+							code := encodeRawScalarMove(evex, 1, 0, src2, src1, dst, mask, zero)
+							code[len(code)-2] = byte(opcode)
+							code[1] = code[1]&0xf0 | 2
+							code[2] &^= 0x80
+							if bits != 32 {
+								code[2] |= 0x80
+							}
+							if evex {
+								code[3] |= byte(width) << 5
+							} else {
+								code[2] |= byte(width) << 2
+							}
+							got, size, matched, err := decodedX86PerLaneVariableShiftInstruction(code, 64)
+							prefix := []string{"X", "Y", "Z"}[width]
+							wantOp := Op(op)
+							if zero {
+								wantOp += ".Z"
+							}
+							args := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src2))}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, src1))}}
+							if mask != 0 {
+								args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("K%d", mask))})
+							}
+							args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, dst))})
+							if err != nil || !matched || size != len(code) || got.Op != wantOp || !reflect.DeepEqual(got.Args, args) {
+								t.Fatalf("decode %x: %+v %d %v %v; want %s %+v", code, got, size, matched, err, wantOp, args)
+							}
+							_, _, matched, err = decodedX86PerLaneVariableShiftInstruction(code, 32)
+							if !matched || (err != nil) != (src1 >= 8 || src2 >= 8 || dst >= 8) {
+								t.Fatalf("386 decode %x matched=%v err=%v", code, matched, err)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 925696 {
+		t.Fatalf("covered %d encodings, want 925696", count)
+	}
+}
+
+func TestX86RawVariableShiftInvalidAndMemoryForms(t *testing.T) {
+	valid := []byte{0x62, 0xf2, 0xf5, 0x0b, 0x47, 0xe0}
+	for name, mutate := range map[string]func([]byte){"fixed": func(b []byte) { b[2] &^= 4 }, "length": func(b []byte) { b[3] |= 0x60 }, "zero-mask": func(b []byte) { b[3] = 0x88 }, "broadcast-register": func(b []byte) { b[3] |= 0x10 }, "prefix": func(b []byte) { b[2] &^= 3 }} {
+		b := append([]byte(nil), valid...)
+		mutate(b)
+		if _, _, matched, err := decodedX86PerLaneVariableShiftInstruction(b, 64); !matched || err == nil {
+			t.Fatalf("accepted %s %x", name, b)
+		}
+	}
+	for _, b := range [][]byte{valid[:5], {0x62, 0xf2, 0xf5, 0x0b, 0x47, 0x04}, {0x62, 0xf2, 0xf5, 0x0b, 0x47, 0x40}, append([]byte{0x67}, valid...), {0x62, 0xf2, 0xf5, 0x1b, 0x12, 0x00}, {0x62, 0xf2, 0x75, 0x0b, 0x12, 0xc0}, {0xc4, 0xe2, 0xf9, 0x46, 0xc0}, {0xc4, 0xe2, 0xf9, 0x12, 0xc0}, {0xc4, 0xe2, 0xf9, 0x47, 0x05, 0, 0, 0, 0}} {
+		if _, _, matched, err := decodedX86PerLaneVariableShiftInstruction(b, 64); !matched || err == nil {
+			t.Fatalf("accepted invalid %x", b)
+		}
+	}
+	if _, _, matched, err := decodedX86PerLaneVariableShiftInstruction(valid, 16); !matched || err == nil {
+		t.Fatal("accepted mode16")
+	}
+	for _, b := range [][]byte{nil, {0x62}, {0x90}, {0xc4, 0xe1, 0xf9, 0x47, 0xc0}, {0xc4, 0xe2, 0xf9, 0x48, 0xc0}} {
+		if _, _, matched, err := decodedX86PerLaneVariableShiftInstruction(b, 64); matched || err != nil {
+			t.Fatalf("claimed unrelated %x", b)
+		}
+	}
+	for _, segment := range []struct {
+		prefix byte
+		reg    Reg
+	}{{0x64, FS}, {0x65, GS}} {
+		for _, broadcast := range []bool{false, true} {
+			b := []byte{segment.prefix, 0x62, 0x92, 0xf5, 0xcb, 0x47, 0x64, 0x88, 0xfe}
+			offset := int64(-128)
+			op := Op("VPSLLVQ.Z")
+			if broadcast {
+				b[4] |= 0x10
+				offset = -16
+				op = "VPSLLVQ.BCST.Z"
+			}
+			got, size, matched, err := decodedX86PerLaneVariableShiftInstruction(b, 64)
+			want := MemRef{Segment: segment.reg, Base: "R8", Index: "R9", Scale: 4, Off: offset}
+			if err != nil || !matched || size != len(b) || got.Op != op || !reflect.DeepEqual(got.Args[0].Mem, want) {
+				t.Fatalf("decode %x=%+v: %v", b, got, err)
+			}
+		}
+	}
+}
+
+func TestX86RawVariableShift386MaskedObjects(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT shifts(SB),4,$0-0\n")
+	for _, op := range x86VariableShiftTestOps {
+		for _, width := range []string{"X", "Y", "Z"} {
+			for _, input := range []string{width + "0", "(AX)"} {
+				for _, suffix := range []string{"", ".Z"} {
+					emitX86GoEncodedTestInstruction(t, &source, fmt.Sprintf("%s%s %s,%s1,K7,%s2", op, suffix, input, width, width), true)
+				}
+			}
+			if !strings.HasSuffix(op, "W") {
+				emitX86GoEncodedTestInstruction(t, &source, fmt.Sprintf("%s.BCST.Z (AX),%s1,K7,%s2", op, width, width), true)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		ir := x86PackedShiftRawFormatObject(t, file, Options{Goarch: "386", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"shifts": {Name: "shifts", Ret: Void}}})
+		compileLLVMToObject(t, llc, triple, "masked-shifts-386.ll", "masked-shifts-386.o", ir)
+	}
+}
+
+func TestX86VariableShiftMemoryAndViewsRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	cross := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !cross {
+		t.Skip("execution requires amd64 or Rosetta; five-target object tests remain required")
+	}
+	var source, decl strings.Builder
+	checks := map[string]*strings.Builder{"views": {}, "memory": {}}
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, op := range x86VariableShiftTestOps {
+		bits := map[byte]int{'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		operation := 0
+		if strings.HasPrefix(op, "VPSRL") {
+			operation = 1
+		}
+		if strings.HasPrefix(op, "VPSRA") {
+			operation = 2
+		}
+		for w, width := range []string{"X", "Y", "Z"} {
+			for mode := 0; mode < 5; mode++ { // reg/mem unmasked, reg/mem masked, broadcast masked.
+				if mode == 4 && bits == 16 {
+					continue
+				}
+				for _, zero := range []bool{false, true} {
+					if zero && mode < 2 {
+						continue
+					}
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("shift%d", index)
+						index++
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ data+0(FP),AX\nMOVQ counts+8(FP),BX\nMOVQ out+16(FP),DI\nVMOVUPS (AX),Z0\n", name)
+						input := "(BX)"
+						if mode == 0 || mode == 2 {
+							source.WriteString("VMOVUPS (BX),Z1\n")
+							input = width + "1"
+						} else if raw {
+							source.WriteString("VMOVUPS (AX),Z1\n")
+						}
+						suffix, mask := "", ""
+						if mode == 4 {
+							suffix = ".BCST"
+						}
+						if zero {
+							suffix += ".Z"
+						}
+						if mode >= 2 {
+							source.WriteString("KMOVQ mask+24(FP),K1\n")
+							mask = "K1,"
+						}
+						dst := 0
+						if raw {
+							dst = 1
+						}
+						emitX86GoEncodedTestInstruction(t, &source, fmt.Sprintf("%s%s %s,%s0,%s%s%d", op, suffix, input, width, mask, width, dst), raw)
+						fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\nRET\n", dst, dst, dst)
+						sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I64, Index: 3, Field: -1}}}}
+						fmt.Fprintf(&decl, "extern void %s(const void*,const void*,void*,uint64_t);\n", name)
+						kind := "views"
+						if mode >= 2 {
+							kind = "memory"
+						}
+						z := 0
+						if zero {
+							z = 1
+						}
+						oldCounts := 0
+						if raw && (mode == 0 || mode == 2) {
+							oldCounts = 1
+						}
+						fmt.Fprintf(checks[kind], "if(check(%s,%d,%d,%d,%d,%d,%d)){fprintf(stderr,\"%s failed\\n\");return 1;}\n", name, 16<<w, bits/8, operation, mode, z, oldCounts, name)
+					}
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if cross {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + x86TestGuardPagesC + decl.String() + `
+static uint64_t lane(const uint8_t *p,int bytes){uint64_t v=0;memcpy(&v,p,bytes);return v;}
+static uint64_t shifted(uint64_t value,uint64_t count,int bits,int op){
+ uint64_t limit=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1,sign=UINT64_C(1)<<(bits-1);
+ if(count>=(uint64_t)bits)return op==2 && (value&sign)?limit:0;
+ if(op==0)return (value<<count)&limit;
+ uint64_t result=value>>count;
+ if(op==2 && (value&sign) && count)result|=limit^(limit>>count);
+ return result;
+}
+static int check(void(*fn)(const void*,const void*,void*,uint64_t),int width,int bytes,int op,int mode,int zero,int oldCounts){
+ for(int n=0;n<96;n++){
+  uint8_t ab[65],bb[65],out[112],want[112]={0};uint8_t *a=ab+1,*b=bb+1;
+  uint64_t counts[]={0,1,(uint64_t)bytes*8-1,(uint64_t)bytes*8,(uint64_t)bytes*8+1,UINT64_MAX,UINT64_C(1)<<(bytes*8-1)};
+  for(int i=0;i<64;i++)a[i]=(uint8_t)(i*31+n*17);
+  for(int i=0;i<64/bytes;i++){uint64_t count=counts[(n+i)%7];memcpy(b+i*bytes,&count,bytes);}
+  int lanes=width/bytes;uint64_t mask=n==0?0:n==1?UINT64_C(1)<<63:n==2?UINT64_MAX:UINT64_C(0x5a5a01239876cdef)>>(n%32);
+  uint64_t active=mask&((UINT64_C(1)<<lanes)-1);
+  for(int i=0;i<lanes;i++){
+   uint64_t value=lane(a+i*bytes,bytes),count=lane(b+(mode==4?0:i*bytes),bytes);
+   uint64_t result=mode<2 || ((mask>>i)&1)?shifted(value,count,bytes*8,op):zero?0:oldCounts?lane(b+i*bytes,bytes):value;
+   memcpy(want+i*bytes,&result,bytes);
+  }
+  memcpy(want+64,want,32);memcpy(want+96,want,16);
+  fn(a,mode>=3 && !active?NULL:b,out,mask);
+  if(memcmp(out,want,112)){fprintf(stderr,"width=%d bytes=%d op=%d mode=%d zero=%d n=%d\n",width,bytes,op,mode,zero,n);return 1;}
+ }
+ if(mode>=3){
+  int lanes=width/bytes;
+  for(int enabled=1;enabled<=lanes;enabled++){
+   uint8_t a[64],out[112],want[112]={0};memset(a,0xff,64);
+   int readable=mode==4?bytes:enabled*bytes;uint8_t *b=guard+page-readable;
+   memset(b,0,(size_t)readable);
+   uint64_t mask=(UINT64_C(1)<<enabled)-1;
+   for(int i=0;i<lanes;i++)if(i<enabled || !zero)memset(want+i*bytes,255,(size_t)bytes);
+   memcpy(want+64,want,32);memcpy(want+96,want,16);
+   fn(a,b,out,mask);if(memcmp(out,want,112))return 1;
+  }
+ }
+ return 0;
+}
+`
+	for _, kind := range []string{"views", "memory"} {
+		t.Run(kind, func(t *testing.T) {
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "variable_shift_"+kind, triple, ir, mainC+"int main(void){\nif(setup_guard())return 2;\n"+checks[kind].String()+"return free_guard();}\n", prefix)
+		})
+	}
+}
diff --git a/amd64_raw_vbroadcastf128_test.go b/amd64_raw_vbroadcastf128_test.go
new file mode 100644
index 000000000..46735d833
--- /dev/null
+++ b/amd64_raw_vbroadcastf128_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawVBROADCASTF128Literal() []byte {
+	code := []byte{0xc4, 0xe2, 0x7d, 0x1a, 0x15, 1, 0, 0, 0, 0xc3}
+	for index := 0; index < 16; index++ {
+		code = append(code, byte(index*11+1))
+	}
+	return code
+}
+
+func TestDecodeX86RawVBROADCASTF128CompleteMemoryFamily(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mode   int
+		code   []byte
+		source MemRef
+		dest   Reg
+	}{
+		{name: "base", mode: 64, code: []byte{0xc4, 0xe2, 0x7d, 0x1a, 0x13}, source: MemRef{Base: BX}, dest: "Y2"},
+		{name: "extended base", mode: 64, code: []byte{0xc4, 0xc2, 0x7d, 0x1a, 0x13}, source: MemRef{Base: "R11"}, dest: "Y2"},
+		{name: "extended destination", mode: 64, code: []byte{0xc4, 0x62, 0x7d, 0x1a, 0x1b}, source: MemRef{Base: BX}, dest: "Y11"},
+		{name: "SIB", mode: 64, code: []byte{0xc4, 0x02, 0x7d, 0x1a, 0x64, 0x88, 0x20}, source: MemRef{Base: "R8", Index: "R9", Scale: 4, Off: 32}, dest: "Y12"},
+		{name: "FS", mode: 64, code: []byte{0x64, 0xc4, 0xe2, 0x7d, 0x1a, 0x13}, source: MemRef{Segment: FS, Base: BX}, dest: "Y2"},
+		{name: "386 absolute", mode: 32, code: []byte{0xc4, 0xe2, 0x7d, 0x1a, 0x15, 0x78, 0x56, 0x34, 0x12}, source: MemRef{Off: 0x12345678}, dest: "Y2"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86VBROADCAST128Instruction(test.code, test.mode)
+			if err != nil || !ok || length != len(test.code) || got.Op != "VBROADCASTF128" ||
+				len(got.Args) != 2 || got.Args[0].Kind != OpMem || got.Args[0].Mem != test.source ||
+				got.Args[1].Reg != test.dest {
+				t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawVBROADCASTF128RIPData(t *testing.T) {
+	code := x86RawVBROADCASTF128Literal()
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VBROADCASTF128 literal", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VBROADCASTF128" ||
+		decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+		decoded[1].Op != OpRET || !bytes.Equal(decoded[0].x86RIPLiteralData, code[len(code)-16:]) {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawVBROADCASTF128RejectsReservedAndUnsafeSources(t *testing.T) {
+	for name, code := range map[string][]byte{
+		"register source": {0xc4, 0xe2, 0x7d, 0x1a, 0xd1},
+		"128-bit vector":  {0xc4, 0xe2, 0x79, 0x1a, 0x13},
+		"nonzero vvvv":    {0xc4, 0xe2, 0x75, 0x1a, 0x13},
+		"W1":              {0xc4, 0xe2, 0xfd, 0x1a, 0x13},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, _, ok, err := decodedX86VBROADCAST128Instruction(code, 64); ok && err == nil {
+				t.Fatalf("accepted reserved VBROADCASTF128 encoding %x", code)
+			}
+		})
+	}
+	for _, displacement := range []byte{0, 127} {
+		code := x86RawVBROADCASTF128Literal()
+		code[5] = displacement
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "unsafe F128 literal", map[string]bool{}); err == nil {
+			t.Fatalf("accepted unsafe literal displacement %#x", displacement)
+		}
+	}
+}
+
+func TestTranslateX86RawVBROADCASTF128Objects(t *testing.T) {
+	var source strings.Builder
+	for _, value := range x86RawVBROADCASTF128Literal() {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	sourceText := "TEXT rawBroadcastF128(SB),$0-0\n" + source.String()
+	requireX86GoAssemblerResult(t, "amd64", sourceText, true)
+	file, err := Parse(ArchAMD64, sourceText)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"rawBroadcastF128": {Name: "rawBroadcastF128", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-vbroadcastf128.ll", "raw-vbroadcastf128.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vecflags.go b/amd64_raw_vecflags.go
new file mode 100644
index 000000000..2d50a7615
--- /dev/null
+++ b/amd64_raw_vecflags.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "fmt"
+
+// Go's _yvptest table has the same X/m128,X and Y/m256,Y grammar for all
+// three VEX vector-test instructions. Legacy PTEST uses the same two-operand
+// shape but is decoded by x/arch's existing SSE path.
+var x86RawVectorTestOpcodes = map[int]Op{
+	0x17: "VPTEST",
+	0x0e: "VTESTPS",
+	0x0f: "VTESTPD",
+}
+
+func decodedX86VEXVectorTestInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86VEXVectorTestInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86VEXVectorTestInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || p.evex || p.mapNumber != 2 {
+		return Instr{}, 0, false, nil
+	}
+	op, recognized := x86RawVectorTestOpcodes[p.opcode]
+	if !recognized {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("VEX vector test: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.pp != 1 || p.upper != 0 || p.vectorLength > 1 {
+		return fail("invalid 66 prefix, reserved vvvv or vector length")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if mode == 32 && (p.r != 0 || p.x != 0 || p.b != 0) {
+		return fail("extended register in 32-bit mode")
+	}
+	width := "X"
+	if p.vectorLength == 1 {
+		width = "Y"
+	}
+	source, size, err := memory.vex(code[p.modRM:], mode, p.b, p.x, p.segment, width)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", width, int(code[p.modRM]>>3&7)+p.r*8))}
+	return Instr{
+		Op:   op,
+		Args: []Operand{source, destination},
+		Raw:  fmt.Sprintf("%s %s, %s", op, source.String(), destination.String()),
+	}, p.modRM + size, true, nil
+}
diff --git a/amd64_raw_vecflags_test.go b/amd64_raw_vecflags_test.go
new file mode 100644
index 000000000..9ebd4f85d
--- /dev/null
+++ b/amd64_raw_vecflags_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawVectorTestCompleteGo127EncodingFamily(t *testing.T) {
+	if len(x86RawVectorTestOpcodes) != len(amd64VectorTestSpecs)-1 {
+		t.Fatalf("raw VEX vector-test opcode table has %d entries, named grammar has %d VEX entries", len(x86RawVectorTestOpcodes), len(amd64VectorTestSpecs)-1)
+	}
+	for _, op := range x86RawVectorTestOpcodes {
+		if spec, ok := amd64VectorTestSpecs[op]; !ok || !spec.vector {
+			t.Fatalf("raw opcode %s has no matching named VEX grammar", op)
+		}
+	}
+
+	type form struct {
+		name string
+		op   Op
+		code []byte
+		src  Operand
+		dst  Reg
+	}
+	var forms []form
+	for _, spec := range []struct {
+		name   Op
+		opcode byte
+		legacy bool
+	}{
+		{"PTEST", 0x17, true},
+		{"VPTEST", 0x17, false},
+		{"VTESTPS", 0x0e, false},
+		{"VTESTPD", 0x0f, false},
+	} {
+		for _, width := range []struct {
+			name string
+			vex3 byte
+		}{
+			{"X", 0x79},
+			{"Y", 0x7d},
+		} {
+			if spec.legacy && width.name == "Y" {
+				continue
+			}
+			for _, source := range []struct {
+				name  string
+				modRM byte
+				value Operand
+			}{
+				{"register", 0xc1, Operand{Kind: OpReg, Reg: Reg(width.name + "1")}},
+				{"memory", 0x08, Operand{Kind: OpMem, Mem: MemRef{Base: AX}}},
+			} {
+				code := []byte{0xc4, 0xe2, width.vex3, spec.opcode, source.modRM}
+				if spec.legacy {
+					code = []byte{0x66, 0x0f, 0x38, spec.opcode, source.modRM}
+				}
+				dest := Reg(width.name + "0")
+				if source.name == "memory" {
+					dest = Reg(width.name + "1")
+				}
+				forms = append(forms, form{
+					name: string(spec.name) + "/" + width.name + "/" + source.name,
+					op:   spec.name, code: code, src: source.value, dst: dest,
+				})
+			}
+		}
+	}
+	for _, goarch := range []string{"386", "amd64"} {
+		for _, form := range forms {
+			t.Run(goarch+"/"+form.name, func(t *testing.T) {
+				fn := Func{}
+				for _, value := range form.code {
+					fn.Instrs = append(fn.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(value)}}})
+				}
+				got, err := decodeX86RawDirectives(fn, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(got.Instrs) != 1 || got.Instrs[0].Op != form.op || len(got.Instrs[0].Args) != 2 {
+					t.Fatalf("decoded %#x as %#v, want %s", form.code, got.Instrs, form.op)
+				}
+				ins := got.Instrs[0]
+				if ins.Args[0].Kind != form.src.Kind || ins.Args[0].Reg != form.src.Reg || ins.Args[0].Mem != form.src.Mem || ins.Args[1].Reg != form.dst {
+					t.Fatalf("decoded %#x operands as %#v, want %#v, %s", form.code, ins.Args, form.src, form.dst)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawVectorTestRejectsReservedEncodings(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"missing-66", []byte{0xc4, 0xe2, 0x78, 0x17, 0xc1}, 64},
+		{"nonzero-vvvv", []byte{0xc4, 0xe2, 0x71, 0x17, 0xc1}, 64},
+		{"address-override", []byte{0x67, 0xc4, 0xe2, 0x79, 0x17, 0x08}, 64},
+		{"missing-modrm", []byte{0xc4, 0xe2, 0x79, 0x17}, 64},
+		{"extended-386", []byte{0xc4, 0x62, 0x79, 0x17, 0xc1}, 32},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86VEXVectorTestInstruction(tc.code, tc.mode); !recognized || err == nil {
+				t.Fatalf("reserved encoding %#x: recognized=%v error=%v", tc.code, recognized, err)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		code []byte
+		want Operand
+	}{
+		{"W-ignored", []byte{0xc4, 0xe2, 0xf9, 0x17, 0xc1}, Operand{Kind: OpReg, Reg: "X1"}},
+		{"SIB-memory", []byte{0xc4, 0xe2, 0x7d, 0x0f, 0x44, 0x88, 0x20}, Operand{Kind: OpMem, Mem: MemRef{Base: AX, Index: CX, Scale: 4, Off: 32}}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, length, recognized, err := decodedX86VEXVectorTestInstruction(tc.code, 64)
+			if !recognized || err != nil || length != len(tc.code) {
+				t.Fatalf("encoding %#x: instruction=%+v length=%d recognized=%v error=%v", tc.code, got, length, recognized, err)
+			}
+			if !reflect.DeepEqual(got.Args[0], tc.want) {
+				t.Fatalf("source = %+v, want %+v", got.Args[0], tc.want)
+			}
+		})
+	}
+}
+
+func TestX86RawVectorTestCompilesEveryForm(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawvectortest(SB),NOSPLIT,$0-0\n")
+			for _, spec := range []struct {
+				opcode byte
+				legacy bool
+			}{
+				{0x17, true}, {0x17, false}, {0x0e, false}, {0x0f, false},
+			} {
+				for _, width := range []byte{0x79, 0x7d} {
+					if spec.legacy && width == 0x7d {
+						continue
+					}
+					for _, modRM := range []byte{0xc1, 0x08} {
+						code := []byte{0xc4, 0xe2, width, spec.opcode, modRM}
+						if spec.legacy {
+							code = []byte{0x66, 0x0f, 0x38, spec.opcode, modRM}
+						}
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $%d\n", value)
+						}
+						source.WriteString("\tNOP\n")
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"rawvectortest": {Name: "rawvectortest", Ret: Void}},
+			})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original raw vector-test formats invented native or register inputs", err)
+			}
+			x86LEAActualTargetGoObject(t, target.goarch, target.triple, "#include \"textflag.h\"\n"+source.String())
+			file, err = normalizeX86RawFile(file, target.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir = x86InstructionFormatObjectUnit(t, file,
+				map[string]FuncSig{"rawvectortest": {Name: "rawvectortest", Ret: Void}}, target.goarch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					if ins.Op == "NOP" {
+						return true, false, nil
+					}
+					return c.lowerVectorTest(ins.Op, ins)
+				})
+			compileLLVMToObject(t, llc, target.triple, "raw-vector-test.ll", "raw-vector-test.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vector_float_compare_literal_test.go b/amd64_raw_vector_float_compare_literal_test.go
new file mode 100644
index 000000000..00b51fc32
--- /dev/null
+++ b/amd64_raw_vector_float_compare_literal_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawVectorFloatCompareLiteral(pp byte, encoding string, width int, broadcast bool) []byte {
+	var code []byte
+	switch encoding {
+	case "vex2":
+		code = encodeX86VEX2VectorFloatCompare(pp, width == 32, 0, 0, 0, 12)
+	case "vex3":
+		code = encodeX86VEXVectorFloatCompare(pp, width == 32, 0, 0, 0, 12)
+	case "evex":
+		code = encodeX86EVEXVectorFloatCompare(
+			pp, byte(map[int]int{16: 0, 32: 1, 64: 2}[width]),
+			broadcast, 1, 1, 0, 0, 12,
+		)
+	}
+	modRMIndex := len(code) - 2
+	code[modRMIndex] = 0x05
+	immediate := code[len(code)-1]
+	code = append(code[:modRMIndex+1], 1, 0, 0, 0, immediate, 0xc3)
+	dataWidth := width
+	if pp >= 2 || broadcast {
+		dataWidth = 4
+		if pp == 1 || pp == 3 {
+			dataWidth = 8
+		}
+	}
+	for index := 0; index < dataWidth; index++ {
+		code = append(code, byte(index*41+15))
+	}
+	return code
+}
+
+func TestDecodeX86RawVectorFloatCompareRIPDataCompleteFamily(t *testing.T) {
+	for pp := byte(0); pp < 4; pp++ {
+		for _, encoding := range []string{"vex2", "vex3", "evex"} {
+			widths := []int{16, 32}
+			if encoding == "evex" {
+				widths = append(widths, 64)
+			}
+			if pp >= 2 {
+				widths = []int{16}
+			}
+			for _, width := range widths {
+				broadcasts := []bool{false}
+				if encoding == "evex" && pp < 2 {
+					broadcasts = append(broadcasts, true)
+				}
+				for _, broadcast := range broadcasts {
+					name := fmt.Sprintf("%s/%s/%d/bcst%t", vectorFloatCompareRawOp(pp), encoding, width, broadcast)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawVectorFloatCompareLiteral(pp, encoding, width, broadcast)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						want := vectorFloatCompareRawOp(pp)
+						if broadcast {
+							want += ".BCST"
+						}
+						if len(decoded) != 2 || decoded[0].Op != want ||
+							decoded[0].Args[0].Kind != OpImm || decoded[0].Args[0].Imm != 12 ||
+							decoded[0].Args[1].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVectorFloatCompareRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVectorFloatCompareLiteral(1, "evex", 64, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+		"EVEX zeroing": func(code []byte) []byte {
+			code[3] |= 0x80
+			return code
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVectorFloatCompareRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	var pools [][]byte
+	index := 0
+	for pp := byte(0); pp < 4; pp++ {
+		for _, encoding := range []string{"vex2", "vex3", "evex"} {
+			width := 16
+			if pp < 2 {
+				width = 32
+				if encoding == "evex" {
+					width = 64
+				}
+			}
+			broadcast := encoding == "evex" && pp < 2
+			code := x86RawVectorFloatCompareLiteral(pp, encoding, width, broadcast)
+			name := fmt.Sprintf("vectorCompareLiteral%d", index)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			for _, value := range code {
+				fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+			}
+			dataWidth := width
+			if pp >= 2 || broadcast {
+				dataWidth = 4
+				if pp == 1 || pp == 3 {
+					dataWidth = 8
+				}
+			}
+			pools = append(pools, code[len(code)-dataWidth:])
+			index++
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// Original encodings lack vector and mask inputs. Preserve their
+			// entire Go/emitter object and public Context contracts; independent
+			// initialized literal programs own the public object matrix.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "vector-compare-literal.ll", "vector-compare-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vector_float_compare_test.go b/amd64_raw_vector_float_compare_test.go
new file mode 100644
index 000000000..eded5c4f3
--- /dev/null
+++ b/amd64_raw_vector_float_compare_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXVectorFloatCompare(pp byte, width256 bool, destination, secondSource, firstSource int, immediate byte) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	vex0 := byte((1-(destination>>3)&1)<<7 | 1<<6 | (1-(firstSource>>3)&1)<<5 | 1)
+	vex1 := byte((^secondSource&15)<<3 | int(l)<<2 | int(pp))
+	modRM := byte(0xc0 | (destination&7)<<3 | firstSource&7)
+	return []byte{0xc4, vex0, vex1, 0xc2, modRM, immediate}
+}
+
+func encodeX86VEX2VectorFloatCompare(pp byte, width256 bool, destination, secondSource, firstSource int, immediate byte) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	vex1 := byte((1-(destination>>3)&1)<<7 | (^secondSource&15)<<3 | int(l)<<2 | int(pp))
+	modRM := byte(0xc0 | (destination&7)<<3 | firstSource&7)
+	return []byte{0xc5, vex1, 0xc2, modRM, immediate}
+}
+
+func encodeX86EVEXVectorFloatCompare(pp, vectorBits byte, broadcastOrSAE bool, writeMask, destinationMask, secondSource, firstSource int, immediate byte) []byte {
+	p0 := byte(1<<7 | (1-(firstSource>>4)&1)<<6 | (1-(firstSource>>3)&1)<<5 | 1<<4 | 1)
+	p1 := byte((^secondSource&15)<<3 | 1<<2 | int(pp))
+	if pp == 1 || pp == 3 {
+		p1 |= 0x80
+	}
+	p2 := byte(int(vectorBits)<<5 | (^secondSource>>4&1)<<3 | writeMask)
+	if broadcastOrSAE {
+		p2 |= 0x10
+	}
+	modRM := byte(0xc0 | (destinationMask&7)<<3 | firstSource&7)
+	return []byte{0x62, p0, p1, p2, 0xc2, modRM, immediate}
+}
+
+func vectorFloatCompareRawOp(pp byte) Op {
+	return [...]Op{"VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"}[pp]
+}
+
+func TestTranslateRawEVEXVectorFloatCompareWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawVectorFloatCompare(SB), $0-0
+	LONG $0x483cf162; WORD $0x06c2; BYTE $0x0c
+	RET
+`
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, `asm sideeffect "vcmpps $$12,`) {
+		t.Fatalf("raw EVEX VCMPPS lowering omitted floating compare:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vector-float-compare.ll", "amd64-raw-vector-float-compare.o", ir)
+}
+
+func TestDecodedX86VEXVectorFloatCompareCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for pp := byte(0); pp < 4; pp++ {
+		widths := []bool{false, true}
+		if pp >= 2 {
+			widths = []bool{false}
+		}
+		for _, width256 := range widths {
+			prefix := "X"
+			if width256 {
+				prefix = "Y"
+			}
+			for destination := 0; destination < 16; destination++ {
+				for secondSource := 0; secondSource < 16; secondSource++ {
+					for firstSource := 0; firstSource < 16; firstSource++ {
+						code := encodeX86VEXVectorFloatCompare(pp, width256, destination, secondSource, firstSource, 0xa5)
+						got, length, ok, err := decodedX86VectorFloatCompareInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{"$165", fmt.Sprintf("%s%d", prefix, firstSource), fmt.Sprintf("%s%d", prefix, secondSource), fmt.Sprintf("%s%d", prefix, destination)}
+						if got.Op != vectorFloatCompareRawOp(pp) || len(got.Args) != 4 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] || got.Args[3].String() != wantArgs[3] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, vectorFloatCompareRawOp(pp), strings.Join(wantArgs, ", "))
+						}
+						count++
+					}
+					for firstSource := 0; firstSource < 8; firstSource++ {
+						code := encodeX86VEX2VectorFloatCompare(pp, width256, destination, secondSource, firstSource, 0xa5)
+						got, length, ok, err := decodedX86VectorFloatCompareInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{"$165", fmt.Sprintf("%s%d", prefix, firstSource), fmt.Sprintf("%s%d", prefix, secondSource), fmt.Sprintf("%s%d", prefix, destination)}
+						if got.Op != vectorFloatCompareRawOp(pp) || len(got.Args) != 4 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] || got.Args[3].String() != wantArgs[3] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, vectorFloatCompareRawOp(pp), strings.Join(wantArgs, ", "))
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 36864 {
+		t.Fatalf("covered %d VEX vector floating compare encodings, want 36864", count)
+	}
+}
+
+func TestDecodedX86EVEXVectorFloatCompareCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for pp := byte(0); pp < 4; pp++ {
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+			if pp >= 2 {
+				prefix = "X"
+			}
+			for destinationMask := 0; destinationMask < 8; destinationMask++ {
+				for secondSource := 0; secondSource < 32; secondSource++ {
+					for firstSource := 0; firstSource < 32; firstSource++ {
+						code := encodeX86EVEXVectorFloatCompare(pp, vectorBits, false, 1, destinationMask, secondSource, firstSource, 0x5a)
+						got, length, ok, err := decodedX86VectorFloatCompareInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{"$90", fmt.Sprintf("%s%d", prefix, firstSource), fmt.Sprintf("%s%d", prefix, secondSource), "K1", fmt.Sprintf("K%d", destinationMask)}
+						if got.Op != vectorFloatCompareRawOp(pp) || len(got.Args) != 5 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] || got.Args[3].String() != wantArgs[3] || got.Args[4].String() != wantArgs[4] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, vectorFloatCompareRawOp(pp), strings.Join(wantArgs, ", "))
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 98304 {
+		t.Fatalf("covered %d EVEX vector floating compare encodings, want 98304", count)
+	}
+}
+
+func TestDecodedX86EVEXVectorFloatCompareModifiersMemoryAndInvalid(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{name: "weaviate memory", code: []byte{0x62, 0xf1, 0x3c, 0x48, 0xc2, 0x06, 0x0c}, op: "VCMPPS", args: []string{"$12", "0(SI)", "Z8", "K0"}},
+		{name: "packed broadcast", code: []byte{0x62, 0xf1, 0xfd, 0x59, 0xc2, 0x48, 0x02, 0x7f}, op: "VCMPPD.BCST", args: []string{"$127", "16(AX)", "Z0", "K1", "K1"}},
+		{name: "packed sae", code: encodeX86EVEXVectorFloatCompare(0, 2, true, 2, 7, 20, 21, 31), op: "VCMPPS.SAE", args: []string{"$31", "Z21", "Z20", "K2", "K7"}},
+		{name: "scalar lig", code: encodeX86EVEXVectorFloatCompare(3, 1, false, 0, 4, 3, 21, 27), op: "VCMPSD", args: []string{"$27", "X21", "X3", "K4"}},
+		{name: "scalar sae", code: encodeX86EVEXVectorFloatCompare(2, 3, true, 3, 5, 1, 11, 47), op: "VCMPSS.SAE", args: []string{"$47", "X11", "X1", "K3", "K5"}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86VectorFloatCompareInstruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+			if got.Op != test.op || len(got.Args) != len(test.args) {
+				t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+			}
+			for index := range test.args {
+				if got.Args[index].String() != test.args[index] {
+					t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+				}
+			}
+		})
+	}
+
+	scalarBroadcast := encodeX86EVEXVectorFloatCompare(2, 0, true, 0, 0, 0, 0, 0)
+	scalarBroadcast[len(scalarBroadcast)-2] = 0
+	invalid := [][]byte{
+		encodeX86VEXVectorFloatCompare(2, true, 0, 0, 0, 0),
+		encodeX86EVEXVectorFloatCompare(0, 3, false, 0, 0, 0, 0, 0),
+		scalarBroadcast,
+	}
+	for _, code := range invalid {
+		if _, _, ok, err := decodedX86VectorFloatCompareInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+}
diff --git a/amd64_raw_vector_literal_test.go b/amd64_raw_vector_literal_test.go
new file mode 100644
index 000000000..364feac21
--- /dev/null
+++ b/amd64_raw_vector_literal_test.go
@@ -0,0 +1,341 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawPackedMoveLiteral(evex bool, width int) []byte {
+	var code []byte
+	if evex {
+		length := byte(map[int]int{16: 0, 32: 1, 64: 2}[width])
+		code = []byte{0x62, 0xf1, 0x7c, length<<5 | 0x08, 0x10, 0x05}
+	} else {
+		p1 := byte(0x7e)
+		if width == 16 {
+			p1 = 0x7a
+		}
+		code = []byte{0xc5, p1, 0x6f, 0x05}
+	}
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*7+3))
+	}
+	return code
+}
+
+func TestDecodeX86RawPackedMoveRIPDataCompleteWidths(t *testing.T) {
+	for _, test := range []struct {
+		evex  bool
+		width int
+	}{
+		{false, 16}, {false, 32},
+		{true, 16}, {true, 32}, {true, 64},
+	} {
+		name := fmt.Sprintf("evex%t/width%d", test.evex, test.width)
+		t.Run(name, func(t *testing.T) {
+			code := x86RawPackedMoveLiteral(test.evex, test.width)
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(decoded) != 2 || !decoded[0].x86RIPLiteral ||
+				len(decoded[0].Args) < 2 || decoded[0].Args[0].Kind != OpSym ||
+				decoded[1].Op != OpRET {
+				t.Fatalf("decoded %x as %#v, want source-local vector constant", code, decoded)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedMoveRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, test := range []struct {
+		evex  bool
+		width int
+	}{
+		{false, 16}, {false, 32},
+		{true, 16}, {true, 32}, {true, 64},
+	} {
+		name := fmt.Sprintf("vectorLiteral%d", index)
+		code := x86RawPackedMoveLiteral(test.evex, test.width)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(sigs) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(sigs))
+	}
+	for index, datum := range normalized.Data {
+		width := []int{16, 32, 16, 32, 64}[index]
+		code := x86RawPackedMoveLiteral(index >= 2, width)
+		want := code[len(code)-width:]
+		if datum.Width != int64(width) || !bytes.Equal(datum.Payload, want) {
+			t.Fatalf("constant %d = %x width %d, want %x", index, datum.Payload, datum.Width, want)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "vector-literal.ll", "vector-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawPackedMoveRIPDataRejectsUnsafeSources(t *testing.T) {
+	// The same opcode byte is used by scalar VMOVSS/SD; this packed-move
+	// decoder must leave those encodings to the scalar grammar.
+	for _, code := range [][]byte{
+		{0xc5, 0xfa, 0x10, 0x05, 1, 0, 0, 0},
+		{0xc5, 0xfb, 0x10, 0x05, 1, 0, 0, 0},
+	} {
+		if _, _, _, matched, _ := decodeX86RawPackedMoveRIPData(code, 0, 64); matched {
+			t.Fatalf("packed move claimed scalar encoding %x", code)
+		}
+	}
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{name: "instruction_overlap", edit: func(code []byte) []byte {
+			copy(code[6:10], []byte{0xfa, 0xff, 0xff, 0xff})
+			return code
+		}},
+		{name: "missing_pool", edit: func(code []byte) []byte {
+			code[6] = 0x7f
+			return code
+		}},
+		{name: "truncated_pool", edit: func(code []byte) []byte {
+			code[6] = 2
+			return code
+		}},
+		{name: "segment_override", edit: func(code []byte) []byte {
+			return append([]byte{0x64}, code...)
+		}},
+		{name: "address_override", edit: func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			code := test.edit(x86RawPackedMoveLiteral(true, 64))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, test.name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP vector source: %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawPackedMoveRIPDataRejectsAddressObservedText(t *testing.T) {
+	code := x86RawPackedMoveLiteral(true, 64)
+	var source strings.Builder
+	source.WriteString("TEXT address(SB),$0-0\n\tLEAQ raw+1(SB), AX\n\tRET\n")
+	source.WriteString("TEXT raw(SB),$0-0\n\tMOVQ AX, AX\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"address": {Name: "address", Ret: Void},
+			"raw":     {Name: "raw", Ret: Void},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "address-observed RIP-relative raw literal") {
+		t.Fatalf("address-observed raw TEXT was silently folded: %v", err)
+	}
+}
+
+func x86RawEVEXPackedIntegerMoveLiteral(pp byte, wide bool, width, mask int, zeroing bool) []byte {
+	p1 := byte(0x7c) | pp
+	if wide {
+		p1 |= 0x80
+	}
+	p2 := byte(map[int]int{16: 0, 32: 1, 64: 2}[width]<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	code := []byte{0x62, 0xf1, p1, p2, 0x6f, 0x05, 1, 0, 0, 0, 0xc3}
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*5+1))
+	}
+	return code
+}
+
+func TestDecodeX86RawEVEXPackedIntegerMoveRIPDataCompleteFamily(t *testing.T) {
+	for _, form := range []struct {
+		pp   byte
+		wide bool
+		op   Op
+	}{
+		{1, false, "VMOVDQA32"}, {1, true, "VMOVDQA64"},
+		{2, false, "VMOVDQU32"}, {2, true, "VMOVDQU64"},
+		{3, false, "VMOVDQU8"}, {3, true, "VMOVDQU16"},
+	} {
+		for _, width := range []int{16, 32, 64} {
+			for _, mask := range []int{0, 3, 7} {
+				zeroing := mask == 7
+				name := fmt.Sprintf("%s/%d/mask%d", form.op, width, mask)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawEVEXPackedIntegerMoveLiteral(form.pp, form.wide, width, mask, zeroing)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					op := form.op
+					if zeroing {
+						op += ".Z"
+					}
+					if len(decoded) != 2 || decoded[0].Op != op ||
+						len(decoded[0].Args) < 2 || decoded[0].Args[0].Kind != OpSym ||
+						!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data load", code, decoded, op)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateX86RawEVEXPackedIntegerMoveRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	forms := []struct {
+		pp   byte
+		wide bool
+	}{
+		{1, false}, {1, true}, {2, false},
+		{2, true}, {3, false}, {3, true},
+	}
+	for index, form := range forms {
+		name := fmt.Sprintf("evexIntegerLiteral%d", index)
+		code := x86RawEVEXPackedIntegerMoveLiteral(form.pp, form.wide, 64, 7, true)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			// These original six sources have no K7 producer. Preserve their
+			// complete byte/format coverage, not invented initialized masks.
+			ir := x86UnboundVoidVectorMoveFormatObject(t, source.String(), "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "evex-integer-literal.ll", "evex-integer-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawEVEXPackedIntegerMoveRIPDataRejectsUnsafeSource(t *testing.T) {
+	for _, displacement := range []byte{0x7f, 2} {
+		code := x86RawEVEXPackedIntegerMoveLiteral(2, false, 64, 0, false)
+		code[6] = displacement
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "unsafe EVEX integer source", map[string]bool{}); err == nil {
+			t.Fatalf("accepted out-of-group EVEX integer source %x", code)
+		}
+	}
+}
+
+func x86RawVBROADCASTI128Literal() []byte {
+	code := []byte{0xc4, 0xe2, 0x7d, 0x5a, 0x05, 1, 0, 0, 0, 0xc3}
+	for index := 0; index < 16; index++ {
+		code = append(code, byte(index*11+2))
+	}
+	return code
+}
+
+func TestDecodeX86RawVBROADCASTI128RIPData(t *testing.T) {
+	code := x86RawVBROADCASTI128Literal()
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VBROADCASTI128 literal", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VBROADCASTI128" ||
+		len(decoded[0].Args) != 2 || decoded[0].Args[0].Kind != OpSym ||
+		!decoded[0].x86RIPLiteral || decoded[1].Op != OpRET {
+		t.Fatalf("decoded %x as %#v, want VBROADCASTI128 source-local data", code, decoded)
+	}
+}
+
+func TestTranslateX86RawVBROADCASTI128RIPDataObjects(t *testing.T) {
+	code := x86RawVBROADCASTI128Literal()
+	var source strings.Builder
+	source.WriteString("TEXT blockLiteral(SB),$0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != 1 || !bytes.Equal(normalized.Data[0].Payload, code[len(code)-16:]) {
+		t.Fatalf("VBROADCASTI128 constant = %#v, want the exact source bytes", normalized.Data)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "amd64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"blockLiteral": {Name: "blockLiteral", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "block-literal.ll", "block-literal.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawVBROADCASTI128RIPDataRejectsUnsafeSource(t *testing.T) {
+	for _, displacement := range []byte{3, 0x7f} {
+		code := x86RawVBROADCASTI128Literal()
+		code[5] = displacement
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "unsafe block broadcast", map[string]bool{}); err == nil {
+			t.Fatalf("accepted out-of-group VBROADCASTI128 source %x", code)
+		}
+	}
+}
diff --git a/amd64_raw_vector_zero.go b/amd64_raw_vector_zero.go
new file mode 100644
index 000000000..25cc82dcb
--- /dev/null
+++ b/amd64_raw_vector_zero.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+// The pinned x/arch decoder calls both VEX.L variants VZEROUPPER and accepts
+// reserved pp/vvvv values. Decode this complete zero-operand family before
+// generic fallback, binding the actual bytes rather than its printed opcode.
+func decodedX86VectorZeroInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	i, forbidden := 0, false
+	for i < len(code) {
+		prefix := code[i]
+		switch {
+		case prefix == 0x26 || prefix == 0x2e || prefix == 0x36 || prefix == 0x3e || prefix == 0x64 || prefix == 0x65 || prefix == 0x67:
+		case prefix == 0x66 || prefix == 0xf0 || prefix == 0xf2 || prefix == 0xf3 || mode == 64 && prefix >= 0x40 && prefix <= 0x4f:
+			forbidden = true
+		default:
+			goto prefixEnd
+		}
+		i++
+	}
+prefixEnd:
+	if i >= len(code) || code[i] != 0xc4 && code[i] != 0xc5 {
+		return Instr{}, 0, false, nil
+	}
+	payload, opcode, length := i+1, i+2, i+3
+	if code[i] == 0xc4 {
+		payload, opcode, length = i+2, i+3, i+4
+	}
+	if opcode >= len(code) {
+		return Instr{}, 0, false, nil
+	}
+	if mode == 32 && code[i+1]&0xc0 != 0xc0 {
+		// These bytes are legacy LES/LDS, not a mode32 VEX prefix.
+		return Instr{}, 0, false, nil
+	}
+	if code[opcode] != 0x77 || code[i] == 0xc4 && code[i+1]&31 != 1 {
+		return Instr{}, 0, false, nil
+	}
+	if mode != 32 && mode != 64 || forbidden || length > 15 || code[payload]&3 != 0 || code[payload]&0x78 != 0x78 {
+		return Instr{}, 0, true, fmt.Errorf("reserved raw VEX vector-zero encoding %x in mode%d", code[:length], mode)
+	}
+	for op, spec := range x86VectorZeroSpecs {
+		if spec.vexLength == code[payload]>>2&1 {
+			return Instr{Op: op, Raw: string(op)}, length, true, nil
+		}
+	}
+	return Instr{}, 0, true, fmt.Errorf("unregistered raw VEX vector-zero length")
+}
diff --git a/amd64_raw_vex_binary_float_test.go b/amd64_raw_vex_binary_float_test.go
new file mode 100644
index 000000000..a0fe58ab1
--- /dev/null
+++ b/amd64_raw_vex_binary_float_test.go
@@ -0,0 +1,346 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86VEXBinaryFloatTestOpcodes = map[byte]string{
+	0x58: "VADD",
+	0x59: "VMUL",
+	0x5c: "VSUB",
+	0x5d: "VMIN",
+	0x5e: "VDIV",
+	0x5f: "VMAX",
+}
+
+func encodeX86VEXBinaryFloat(opcode, pp byte, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | int(pp))
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 1)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | int(pp))
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func encodeX86EVEXBinaryFloat(opcode, pp, vectorBits byte, broadcastOrRounding, zeroing bool, mask, destination, source1, source2 int) []byte {
+	p0 := byte((1-(destination>>3)&1)<<7 | (1-(source2>>4)&1)<<6 | (1-(source2>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 1)
+	p1 := byte((^source1&15)<<3 | 1<<2 | int(pp))
+	if pp == 1 || pp == 3 {
+		p1 |= 0x80
+	}
+	p2 := byte(int(vectorBits)<<5 | (^source1>>4&1)<<3 | mask)
+	if broadcastOrRounding {
+		p2 |= 0x10
+	}
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestTranslateRawVEXBinaryFloatWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawBinary(SB), $0-0
+	LONG $0x0e5cf2c5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawBinary": {Name: "rawBinary", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@llvm.experimental.constrained.fsub.f32(") || !strings.Contains(ir, "@__plan9asm_add_sub_special_f32(") {
+		t.Fatalf("raw VSUBSS lowering omitted scalar subtraction:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-binary-float.ll", "amd64-raw-vex-binary-float.o", ir)
+}
+
+func TestTranslateRawScalarSqrtKelindarRegression(t *testing.T) {
+	const source = `TEXT rawScalarSqrt(SB), $0-0
+	LONG $0xdc51dac5
+	RET
+`
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, `asm sideeffect "vsqrtss`) {
+		t.Fatalf("raw VSQRTSS omitted square root:\n%s", ir)
+	}
+}
+
+func TestDecodedX86RawScalarSqrtCompleteGoRows(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{"VEX single register", []byte{0xc5, 0xea, 0x51, 0xd9}, "VSQRTSS X1, X2, X3"},
+		{"VEX double register", []byte{0xc5, 0xeb, 0x51, 0xd9}, "VSQRTSD X1, X2, X3"},
+		{"VEX single memory", []byte{0xc5, 0xea, 0x51, 0x18}, "VSQRTSS 0(AX), X2, X3"},
+		{"VEX double memory", []byte{0xc5, 0xeb, 0x51, 0x58, 0x10}, "VSQRTSD 16(AX), X2, X3"},
+		{"EVEX single mask zero", []byte{0x62, 0xa1, 0x56, 0x81, 0x51, 0xf4}, "VSQRTSS.Z X20, X21, K1, X22"},
+		{"EVEX double mask zero", []byte{0x62, 0xa1, 0xd7, 0x81, 0x51, 0xf4}, "VSQRTSD.Z X20, X21, K1, X22"},
+		{"EVEX single rounding", []byte{0x62, 0xf1, 0x6e, 0x18, 0x51, 0xd9}, "VSQRTSS.RN_SAE X1, X2, X3"},
+		{"EVEX double rounding", []byte{0x62, 0xf1, 0xef, 0x38, 0x51, 0xd9}, "VSQRTSD.RD_SAE X1, X2, X3"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, recognized, err := decodedX86VEXBinaryFloatInstruction(test.code, 64)
+			if err != nil || !recognized || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode %x: raw=%q length=%d recognized=%v err=%v; want %q", test.code, instruction.Raw, length, recognized, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslateRawScalarSqrtLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			encodings := [][]byte{
+				{0xc5, 0xea, 0x51, 0xd9},
+				{0xc5, 0xeb, 0x51, 0x58, 0x10},
+				{0x62, 0xf1, 0x6e, 0x18, 0x51, 0xd9},
+				{0x62, 0xf1, 0xef, 0x38, 0x51, 0xd9},
+			}
+			if target.goarch == "amd64" {
+				encodings = append(encodings,
+					[]byte{0x62, 0xa1, 0x56, 0x81, 0x51, 0xf4},
+					[]byte{0x62, 0xa1, 0xd7, 0x81, 0x51, 0xf4},
+				)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT rawScalarSqrtFamily(SB), $0-0\n")
+			for _, code := range encodings {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-scalar-sqrt.ll", "raw-scalar-sqrt.o", ir)
+		})
+	}
+}
+
+func TestTranslateRawEVEXBinaryFloatWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawBinaryEVEX(SB), $0-0
+	LONG $0x48347162
+	WORD $0x0e5c
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawBinaryEVEX": {Name: "rawBinaryEVEX", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@llvm.experimental.constrained.fsub.v16f32(") || !strings.Contains(ir, "@__plan9asm_add_sub_special_f32(") {
+		t.Fatalf("raw EVEX VSUBPS lowering omitted packed subtraction:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-evex-binary-float.ll", "amd64-raw-evex-binary-float.o", ir)
+}
+
+func TestDecodedX86VEXBinaryFloatCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	suffixes := map[byte]string{0: "PS", 1: "PD", 2: "SS", 3: "SD"}
+	for opcode, stem := range x86VEXBinaryFloatTestOpcodes {
+		for pp, suffix := range suffixes {
+			scalar := pp >= 2
+			for _, vex3 := range []bool{false, true} {
+				widths := []bool{false, true}
+				if scalar {
+					widths = []bool{false}
+				}
+				for _, width256 := range widths {
+					prefix := "X"
+					if width256 {
+						prefix = "Y"
+					}
+					for _, widthIgnored := range []bool{false, true} {
+						if !vex3 && widthIgnored {
+							continue
+						}
+						source2Limit := 16
+						if !vex3 {
+							source2Limit = 8
+						}
+						for destination := 0; destination < 16; destination++ {
+							for source1 := 0; source1 < 16; source1++ {
+								for source2 := 0; source2 < source2Limit; source2++ {
+									code := encodeX86VEXBinaryFloat(opcode, pp, vex3, width256, widthIgnored, destination, source1, source2)
+									got, length, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+									if err != nil || !ok || length != len(code) {
+										t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+									}
+									wantOp := Op(stem + suffix)
+									wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+									if got.Op != wantOp || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+										t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+									}
+									count++
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 368640 {
+		t.Fatalf("covered %d VEX binary floating register encodings, want 368640", count)
+	}
+}
+
+func TestDecodedX86EVEXBinaryFloatCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	suffixes := map[byte]string{0: "PS", 1: "PD", 2: "SS", 3: "SD"}
+	for opcode, stem := range x86VEXBinaryFloatTestOpcodes {
+		for pp, suffix := range suffixes {
+			vectorLengths := []byte{0, 1, 2}
+			for _, vectorBits := range vectorLengths {
+				prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+				if pp >= 2 {
+					prefix = "X"
+				}
+				for destination := 0; destination < 32; destination++ {
+					for source1 := 0; source1 < 32; source1++ {
+						for source2 := 0; source2 < 32; source2++ {
+							code := encodeX86EVEXBinaryFloat(opcode, pp, vectorBits, false, false, 1, destination, source1, source2)
+							got, length, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							wantOp := Op(stem + suffix)
+							wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), "K1", fmt.Sprintf("%s%d", prefix, destination)}
+							if got.Op != wantOp || len(got.Args) != 4 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] || got.Args[3].String() != wantArgs[3] {
+								t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 2359296 {
+		t.Fatalf("covered %d EVEX binary floating register encodings, want 2359296", count)
+	}
+}
+
+func TestDecodedX86EVEXBinaryFloatModifiersAndMemory(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{name: "packed zeroing", code: encodeX86EVEXBinaryFloat(0x58, 0, 1, false, true, 3, 29, 28, 21), op: "VADDPS.Z", args: []string{"Y21", "Y28", "K3", "Y29"}},
+		{name: "packed broadcast zeroing", code: []byte{0x62, 0xf1, 0xed, 0xd9, 0x58, 0x08}, op: "VADDPD.BCST.Z", args: []string{"0(AX)", "Z2", "K1", "Z1"}},
+		{name: "packed round nearest", code: []byte{0x62, 0xf1, 0xed, 0x19, 0x58, 0xcb}, op: "VADDPD.RN_SAE", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "packed round down", code: []byte{0x62, 0xf1, 0xed, 0x39, 0x58, 0xcb}, op: "VADDPD.RD_SAE", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "packed round up", code: []byte{0x62, 0xf1, 0xed, 0x59, 0x58, 0xcb}, op: "VADDPD.RU_SAE", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "packed round zero zeroing", code: []byte{0x62, 0xf1, 0xed, 0xf9, 0x58, 0xcb}, op: "VADDPD.RZ_SAE.Z", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "packed sae", code: []byte{0x62, 0xf1, 0xed, 0x59, 0x5f, 0xcb}, op: "VMAXPD.SAE", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "scalar round up", code: encodeX86EVEXBinaryFloat(0x5c, 2, 2, true, false, 2, 5, 6, 7), op: "VSUBSS.RU_SAE", args: []string{"X7", "X6", "K2", "X5"}},
+		{name: "scalar sae zeroing", code: encodeX86EVEXBinaryFloat(0x5d, 3, 0, true, true, 4, 8, 9, 10), op: "VMINSD.SAE.Z", args: []string{"X10", "X9", "K4", "X8"}},
+		{name: "compressed memory", code: []byte{0x62, 0x71, 0x34, 0x48, 0x5c, 0x4e, 0x02}, op: "VSUBPS", args: []string{"128(SI)", "Z9", "Z9"}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86VEXBinaryFloatInstruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+			if got.Op != test.op || len(got.Args) != len(test.args) {
+				t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+			}
+			for index := range test.args {
+				if got.Args[index].String() != test.args[index] {
+					t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+				}
+			}
+		})
+	}
+
+	scalarBroadcast := encodeX86EVEXBinaryFloat(0x58, 2, 0, true, false, 0, 0, 0, 0)
+	scalarBroadcast[len(scalarBroadcast)-1] = 0
+	wrongW := encodeX86EVEXBinaryFloat(0x58, 0, 0, false, false, 0, 0, 0, 0)
+	wrongW[2] ^= 0x80
+	invalid := [][]byte{
+		encodeX86EVEXBinaryFloat(0x58, 0, 0, false, true, 0, 0, 0, 0),
+		encodeX86EVEXBinaryFloat(0x58, 0, 3, false, false, 0, 0, 0, 0),
+		scalarBroadcast,
+		wrongW,
+	}
+	for _, code := range invalid {
+		if _, _, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid EVEX encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+
+	mode32 := encodeX86EVEXBinaryFloat(0x58, 0, 0, false, false, 1, 0, 0, 0)
+	if _, _, ok, err := decodedX86VEXBinaryFloatInstruction(mode32, 32); !ok || err == nil {
+		t.Fatalf("masked EVEX form in 32-bit mode returned ok=%v err=%v", ok, err)
+	}
+}
+
+func TestDecodedX86VEXBinaryFloatMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x01, 0xe5, 0x58, 0x64, 0x88, 0x20}
+	got, length, ok, err := decodedX86VEXBinaryFloatInstruction(code, 64)
+	wantSource := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VADDPD" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource || got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXBinaryFloat(0x58, 0, true, false, false, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc5},
+		{0xc4, valid[1] ^ 1, valid[2], valid[3], valid[4]},
+		encodeX86VEXBinaryFloat(0x5a, 0, true, false, false, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXBinaryFloatInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	scalarY := encodeX86VEXBinaryFloat(0x58, 2, true, true, false, 0, 0, 0)
+	if _, _, matched, decodeErr := decodedX86VEXBinaryFloatInstruction(scalarY, 64); !matched || decodeErr == nil {
+		t.Fatalf("scalar VEX.256 encoding %x returned ok=%v err=%v", scalarY, matched, decodeErr)
+	}
+	extended := encodeX86VEXBinaryFloat(0x58, 0, true, false, false, 8, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXBinaryFloatInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vex_fma3_test.go b/amd64_raw_vex_fma3_test.go
new file mode 100644
index 000000000..e99d8b19f
--- /dev/null
+++ b/amd64_raw_vex_fma3_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXFMA3(opcode byte, width64, width256 bool, destination, source1, source2 int) []byte {
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 2)
+	vex1 := byte(((^source1)&15)<<3 | 1)
+	if width64 {
+		vex1 |= 0x80
+	}
+	if width256 {
+		vex1 |= 0x04
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func encodeX86EVEXFMA3(opcode byte, width64 bool, vectorBits byte, broadcastOrRounding, zeroing bool, mask, destination, source1, source2 int) []byte {
+	p0 := byte((1-(destination>>3)&1)<<7 | (1-(source2>>4)&1)<<6 | (1-(source2>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 2)
+	p1 := byte((^source1&15)<<3 | 1<<2 | 1)
+	if width64 {
+		p1 |= 0x80
+	}
+	p2 := byte(int(vectorBits)<<5 | (^source1>>4&1)<<3 | mask)
+	if broadcastOrRounding {
+		p2 |= 0x10
+	}
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM}
+}
+
+func TestTranslateRawVEXFMA3WeaviateRegression(t *testing.T) {
+	const source = `TEXT rawFMA(SB), $0-0
+	LONG $0x985de2c4; BYTE $0x1e
+	RET
+`
+	// The complete original lacks its SI address and Y3/Y4 producers. Keep
+	// its actual Go object and all three public Context results. This private
+	// emitter object is not initialized public translation or native execution;
+	// TestX86RawFMA3OriginalWeaviateInputsAndInitializedCounterparts owns that
+	// independent, genuinely initialized public object matrix.
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	x86RawFMA3RequireOriginalNativeFormat(t, ir, "vfmadd132ps", 32, 32, false)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-fma3.ll", "amd64-raw-vex-fma3.o", ir)
+}
+
+func TestTranslateRawEVEXFMA3WeaviateRegression(t *testing.T) {
+	const source = `TEXT rawFMAEVEX(SB), $0-0
+	LONG $0x4835d262; WORD $0xc9b8
+	RET
+`
+	// Unchanged original bytes have no Z1/Z9 producers. The public Context,
+	// private format object and initialized public counterpart are distinct.
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	x86RawFMA3RequireOriginalNativeFormat(t, ir, "vfmadd231ps", 64, 0, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-evex-fma3.ll", "amd64-raw-evex-fma3.o", ir)
+}
+
+func x86RawFMA3RequireOriginalNativeFormat(t *testing.T, ir, mnemonic string, width, memoryBytes int, evex bool) {
+	t.Helper()
+	var native string
+	for _, line := range strings.Split(ir, "\n") {
+		if strings.Contains(line, "asm sideeffect") && strings.Contains(line, mnemonic+" ") {
+			if native != "" {
+				t.Fatal("original format duplicated its native FMA opcode", mnemonic)
+			}
+			native = line
+		}
+		if strings.Contains(line, "call ") && strings.Contains(line, "@llvm.fma.") {
+			t.Fatal("original native FMA format was replaced by pure arithmetic", mnemonic, line)
+		}
+	}
+	constraint := "=x,0,"
+	if evex {
+		constraint = "=v,0,"
+	}
+	if native == "" || !strings.Contains(native, fmt.Sprintf("<%d x float> asm sideeffect", width/4)) ||
+		!strings.Contains(native, "\""+constraint) || !strings.Contains(native, "~{fpsr}") ||
+		!strings.Contains(native, "~{memory}") || strings.Contains(native, "~{flags}") {
+		t.Fatal("original native FMA lost physical carrier, tied old destination, FP/access effects or FLAGS preservation", mnemonic, native)
+	}
+	if memoryBytes != 0 {
+		if !strings.Contains(native, fmt.Sprintf("elementtype([%d x i8])", memoryBytes)) || !strings.Contains(native, ",*m") {
+			t.Fatal("original native FMA lost its exact memory tuple", mnemonic, native)
+		}
+	} else if strings.Contains(native, "elementtype(") || strings.Contains(native, ",*m") {
+		t.Fatal("original register FMA invented a memory operand", mnemonic, native)
+	}
+}
+
+func TestDecodedX86VEXFMA3CompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, spec := range decodedX86VEXFMA3Ops {
+		for _, width64 := range []bool{false, true} {
+			widths := []bool{false, true}
+			if spec.scalar {
+				widths = []bool{false}
+			}
+			for _, width256 := range widths {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				var registers [16]Reg
+				for index := range registers {
+					registers[index] = Reg(fmt.Sprintf("%s%d", prefix, index))
+				}
+				wantOp := spec.op(width64)
+				for destination := 0; destination < 16; destination++ {
+					for source1 := 0; source1 < 16; source1++ {
+						for source2 := 0; source2 < 16; source2++ {
+							code := encodeX86VEXFMA3(opcode, width64, width256, destination, source1, source2)
+							got, length, ok, err := decodedX86VEXFMA3Instruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							if got.Op != wantOp || len(got.Args) != 3 ||
+								got.Args[0].Kind != OpReg || got.Args[0].Reg != registers[source2] ||
+								got.Args[1].Kind != OpReg || got.Args[1].Reg != registers[source1] ||
+								got.Args[2].Kind != OpReg || got.Args[2].Reg != registers[destination] {
+								t.Fatalf("decode %x = %+v, want %s %s,%s,%s", code, got, wantOp, registers[source2], registers[source1], registers[destination])
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 393216 {
+		t.Fatalf("covered %d VEX FMA3 register encodings, want 393216", count)
+	}
+	t.Logf("exhaustively checked %d VEX FMA3 register encodings", count)
+}
+
+func TestDecodedX86EVEXFMA3CompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, spec := range decodedX86VEXFMA3Ops {
+		for _, width64 := range []bool{false, true} {
+			vectorLengths := []byte{0, 1, 2}
+			for _, vectorBits := range vectorLengths {
+				prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+				if spec.scalar {
+					prefix = "X"
+				}
+				var registers [32]Reg
+				for index := range registers {
+					registers[index] = Reg(fmt.Sprintf("%s%d", prefix, index))
+				}
+				wantOp := spec.op(width64)
+				for destination := 0; destination < 32; destination++ {
+					for source1 := 0; source1 < 32; source1++ {
+						for source2 := 0; source2 < 32; source2++ {
+							code := encodeX86EVEXFMA3(opcode, width64, vectorBits, false, false, 1, destination, source1, source2)
+							got, length, ok, err := decodedX86VEXFMA3Instruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							if got.Op != wantOp || len(got.Args) != 4 ||
+								got.Args[0].Kind != OpReg || got.Args[0].Reg != registers[source2] ||
+								got.Args[1].Kind != OpReg || got.Args[1].Reg != registers[source1] ||
+								got.Args[2].Kind != OpReg || got.Args[2].Reg != "K1" ||
+								got.Args[3].Kind != OpReg || got.Args[3].Reg != registers[destination] {
+								t.Fatalf("decode %x = %+v, want %s %s,%s,K1,%s", code, got, wantOp, registers[source2], registers[source1], registers[destination])
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 5898240 {
+		t.Fatalf("covered %d EVEX FMA3 register encodings, want 5898240", count)
+	}
+	t.Logf("exhaustively checked %d EVEX FMA3 register encodings", count)
+}
+
+func TestDecodedX86EVEXFMA3ModifiersAndMemory(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		op   Op
+		args []string
+	}{
+		{name: "packed zeroing", code: encodeX86EVEXFMA3(0xb8, false, 1, false, true, 3, 29, 28, 21), op: "VFMADD231PS.Z", args: []string{"Y21", "Y28", "K3", "Y29"}},
+		{name: "packed broadcast zeroing", code: []byte{0x62, 0xf2, 0xed, 0xd9, 0x98, 0x08}, op: "VFMADD132PD.BCST.Z", args: []string{"0(AX)", "Z2", "K1", "Z1"}},
+		{name: "packed round nearest", code: encodeX86EVEXFMA3(0xa8, true, 0, true, false, 1, 1, 2, 3), op: "VFMADD213PD.RN_SAE", args: []string{"Z3", "Z2", "K1", "Z1"}},
+		{name: "packed round down", code: encodeX86EVEXFMA3(0xba, false, 1, true, false, 2, 4, 5, 6), op: "VFMSUB231PS.RD_SAE", args: []string{"Z6", "Z5", "K2", "Z4"}},
+		{name: "packed round up", code: encodeX86EVEXFMA3(0x9c, true, 2, true, false, 3, 7, 8, 9), op: "VFNMADD132PD.RU_SAE", args: []string{"Z9", "Z8", "K3", "Z7"}},
+		{name: "packed round zero zeroing", code: encodeX86EVEXFMA3(0xae, false, 3, true, true, 4, 10, 11, 12), op: "VFNMSUB213PS.RZ_SAE.Z", args: []string{"Z12", "Z11", "K4", "Z10"}},
+		{name: "scalar round up", code: encodeX86EVEXFMA3(0xb9, false, 2, true, false, 5, 13, 14, 15), op: "VFMADD231SS.RU_SAE", args: []string{"X15", "X14", "K5", "X13"}},
+		{name: "compressed memory", code: []byte{0x62, 0xd2, 0x35, 0x48, 0xb8, 0x49, 0x02}, op: "VFMADD231PS", args: []string{"128(R9)", "Z9", "Z1"}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86VEXFMA3Instruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+			if got.Op != test.op || len(got.Args) != len(test.args) {
+				t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+			}
+			for index := range test.args {
+				if got.Args[index].String() != test.args[index] {
+					t.Fatalf("decode %x = %+v, want %s %s", test.code, got, test.op, strings.Join(test.args, ", "))
+				}
+			}
+		})
+	}
+
+	scalarBroadcast := encodeX86EVEXFMA3(0x99, false, 0, true, false, 0, 0, 0, 0)
+	scalarBroadcast[len(scalarBroadcast)-1] = 0
+	wrongPP := encodeX86EVEXFMA3(0x98, false, 0, false, false, 0, 0, 0, 0)
+	wrongPP[2] &^= 1
+	invalid := [][]byte{
+		encodeX86EVEXFMA3(0x98, false, 0, false, true, 0, 0, 0, 0),
+		encodeX86EVEXFMA3(0x98, false, 3, false, false, 0, 0, 0, 0),
+		scalarBroadcast,
+		wrongPP,
+	}
+	for _, code := range invalid {
+		if _, _, ok, err := decodedX86VEXFMA3Instruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid EVEX encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+
+	mode32 := encodeX86EVEXFMA3(0x98, false, 0, false, false, 1, 0, 0, 0)
+	got, length, ok, err := decodedX86VEXFMA3Instruction(mode32, 32)
+	if !ok || err != nil || length != len(mode32) || got.Op != "VFMADD132PS" || len(got.Args) != 4 ||
+		got.x86FMA3Encoding != x86RawFMA3EVEX || got.x86Encoded {
+		t.Fatalf("valid physical mode32 masked EVEX lost its complete decode/generation: %+v length=%d ok=%v err=%v", got, length, ok, err)
+	}
+	for index, want := range []string{"X0", "X0", "K1", "X0"} {
+		if got.Args[index].Kind != OpReg || got.Args[index].String() != want {
+			t.Fatal("physical mode32 masked EVEX changed an original register/mask operand", index, got.Args)
+		}
+	}
+	// Physical low-bank EVEX validity does not authorize unaddressable mode32
+	// banks. Exercise each source/destination extension independently.
+	for _, registers := range [][3]int{{8, 0, 0}, {0, 8, 0}, {0, 0, 8}, {16, 0, 0}, {0, 16, 0}, {0, 0, 16}} {
+		extended := encodeX86EVEXFMA3(0x98, false, 0, false, false, 1,
+			registers[0], registers[1], registers[2])
+		if _, _, matched, decodeErr := decodedX86VEXFMA3Instruction(extended, 32); !matched || decodeErr == nil ||
+			!strings.Contains(decodeErr.Error(), "extended register in 32-bit mode") {
+			t.Fatalf("physical mode32 extended-bank form %v returned ok=%v err=%v", registers, matched, decodeErr)
+		}
+	}
+	// Go's named four-operand mode32 grammar remains a distinct restriction.
+	// Require an actual normal assembler rejection as well as the typed guard;
+	// raw physical acceptance must not silently widen that named grammar.
+	const named = "TEXT named386(SB),4,$0-0\nVFMADD132PS X0,X0,K1,X0\nRET\n"
+	goAssemblerOracleOutput(t, "386", named, "", false)
+	if _, known, err := amd64FMA3Properties(x86ScalarLaneInstruction(t, "VFMADD132PS X0,X0,K1,X0"), "386"); !known || err == nil {
+		t.Fatal("raw physical acceptance widened Go's named mode32 mask grammar", known, err)
+	}
+}
+
+func TestDecodedX86VEXFMA3MemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x02, 0xe5, 0x98, 0x64, 0x88, 0x20}
+	got, length, ok, err := decodedX86VEXFMA3Instruction(code, 64)
+	wantSource := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VFMADD132PD" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource || got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXFMA3(0x98, false, false, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc4},
+		{valid[0], valid[1] ^ 3, valid[2], valid[3], valid[4]},
+		encodeX86VEXFMA3(0x95, false, false, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXFMA3Instruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	invalidPP := []byte{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4]}
+	if _, _, matched, decodeErr := decodedX86VEXFMA3Instruction(invalidPP, 64); !matched || decodeErr == nil {
+		t.Fatalf("invalid pp encoding %x returned ok=%v err=%v", invalidPP, matched, decodeErr)
+	}
+	scalarY := encodeX86VEXFMA3(0x99, false, true, 0, 0, 0)
+	if _, _, matched, decodeErr := decodedX86VEXFMA3Instruction(scalarY, 64); !matched || decodeErr == nil {
+		t.Fatalf("scalar VEX.256 encoding %x returned ok=%v err=%v", scalarY, matched, decodeErr)
+	}
+	extended := encodeX86VEXFMA3(0x98, false, false, 8, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXFMA3Instruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vex_horizontal_float_test.go b/amd64_raw_vex_horizontal_float_test.go
new file mode 100644
index 000000000..99ea1daa4
--- /dev/null
+++ b/amd64_raw_vex_horizontal_float_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXHorizontalFloat(opcode, pp byte, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | int(pp))
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 1)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | int(pp))
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestTranslateRawVEXHorizontalFloatWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawHorizontal(SB), $0-0
+	LONG $0xc07cffc5
+	RET
+`
+	ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ir, "vhaddps ") || !strings.Contains(ir, "~{fpsr}") {
+		t.Fatalf("raw VHADDPS lowering omitted horizontal addition:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-horizontal-float.ll", "amd64-raw-vex-horizontal-float.o", ir)
+}
+
+func TestDecodedX86VEXHorizontalFloatCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, stem := range map[byte]string{0x7c: "VHADD", 0x7d: "VHSUB", 0xd0: "VADDSUB"} {
+		for pp, suffix := range map[byte]string{1: "PD", 3: "PS"} {
+			for _, vex3 := range []bool{false, true} {
+				for _, width256 := range []bool{false, true} {
+					prefix := "X"
+					if width256 {
+						prefix = "Y"
+					}
+					for _, widthIgnored := range []bool{false, true} {
+						if !vex3 && widthIgnored {
+							continue
+						}
+						source2Limit := 16
+						if !vex3 {
+							source2Limit = 8
+						}
+						for destination := 0; destination < 16; destination++ {
+							for source1 := 0; source1 < 16; source1++ {
+								for source2 := 0; source2 < source2Limit; source2++ {
+									code := encodeX86VEXHorizontalFloat(opcode, pp, vex3, width256, widthIgnored, destination, source1, source2)
+									got, length, ok, err := decodedX86VEXHorizontalFloatInstruction(code, 64)
+									if err != nil || !ok || length != len(code) {
+										t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+									}
+									wantOp := Op(stem + suffix)
+									wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+									if got.Op != wantOp || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+										t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+									}
+									count++
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 122880 {
+		t.Fatalf("covered %d VEX horizontal and alternating floating register encodings, want 122880", count)
+	}
+}
+
+func TestTranslateRawVEXAddSubComplexAVX2Regression(t *testing.T) {
+	const source = "TEXT rawAddSub(SB),$0-0\n\tLONG $0xc1d0f9c5\n\tRET\n"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+			if !strings.Contains(ir, "fsub double") || !strings.Contains(ir, "fadd double") {
+				t.Fatalf("VADDSUBPD omitted alternating arithmetic:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-vaddsub.ll", "raw-vaddsub.o", ir)
+		})
+	}
+}
+
+func TestX86RawAddSubInitializedPublicInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			// The original VADDSUBPD bytes are unchanged. Independent typed
+			// inputs provide both vectors, and the complete result is observed.
+			loadSecond := "MOVUPD b+16(FP),X1\n"
+			source := "TEXT Value(SB),4,$0-48\nMOVUPD a+0(FP),X0\n" + loadSecond +
+				"LONG $0xc1d0f9c5\nMOVUPD X0,ret+32(FP)\nRET\n"
+			const declaration = "func Value(a,b [16]byte) [16]byte"
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			named := strings.Replace(source, "LONG $0xc1d0f9c5", "VADDSUBPD X1,X0,X0", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, named, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+					t.Fatal("initialized named counterpart must precede raw comparison", api, err)
+				}
+			}
+			x86RawNumericalFamilyObjects(t, source, declaration, target.arch, target.triple)
+			for _, api := range []string{"text", "module", "Go"} {
+				missing := strings.Replace(source, loadSecond, "", 1)
+				ir, err := x86ScalarFPBitViewAPI(t, missing, declaration, target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw arithmetic borrowed its missing second vector", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestDecodedX86VEXHorizontalFloatMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x01, 0xe5, 0x7d, 0x64, 0x88, 0x20}
+	got, length, ok, err := decodedX86VEXHorizontalFloatInstruction(code, 64)
+	wantSource := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VHSUBPD" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource || got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+	code[4] = 0xd0
+	got, length, ok, err = decodedX86VEXHorizontalFloatInstruction(code, 64)
+	if err != nil || !ok || length != len(code) || got.Op != "VADDSUBPD" ||
+		got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource ||
+		got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("VADDSUBPD memory source %x decoded as %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXHorizontalFloat(0x7c, 1, true, false, false, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc5},
+		{0xc4, valid[1] ^ 1, valid[2], valid[3], valid[4]},
+		encodeX86VEXHorizontalFloat(0x7e, 1, true, false, false, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXHorizontalFloatInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	invalidPP := encodeX86VEXHorizontalFloat(0x7c, 0, true, false, false, 0, 0, 0)
+	if _, _, matched, decodeErr := decodedX86VEXHorizontalFloatInstruction(invalidPP, 64); !matched || decodeErr == nil {
+		t.Fatalf("invalid pp encoding %x returned ok=%v err=%v", invalidPP, matched, decodeErr)
+	}
+	extended := encodeX86VEXHorizontalFloat(0x7c, 1, true, false, false, 8, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXHorizontalFloatInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vex_integration_test.go b/amd64_raw_vex_integration_test.go
new file mode 100644
index 000000000..9ab0d6fb8
--- /dev/null
+++ b/amd64_raw_vex_integration_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import "testing"
+
+func TestTranslateX86RawVEXVNNIAndVariableDwordPermuteAllTargets(t *testing.T) {
+	const source = `TEXT rawvexfamilies(SB),$0-0
+	// {vex} VPDPBUSD X2, X1, X0.
+	BYTE $0xc4; BYTE $0xe2; BYTE $0x71; BYTE $0x50; BYTE $0xc2
+	// {vex} VPERMD Y5, Y3, Y4.
+	BYTE $0xc4; BYTE $0xe2; BYTE $0x65; BYTE $0x36; BYTE $0xe5
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		goarch string
+		triple string
+	}{
+		{name: "darwin-amd64", goarch: "amd64", triple: "x86_64-apple-darwin"},
+		{name: "linux-amd64", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+		{name: "windows-amd64", goarch: "amd64", triple: "x86_64-pc-windows-msvc"},
+		{name: "linux-386", goarch: "386", triple: "i386-unknown-linux-gnu"},
+		{name: "windows-386", goarch: "386", triple: "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			// Keep both original raw opcodes and their whole Go object, but
+			// do not mistake this input-free format unit for a numerical ABI.
+			ll := x86UnboundVoidRawScalarFormatObject(t, source, target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-vex-families-"+target.name+".ll", "raw-vex-families-"+target.name+".o", ll)
+		})
+	}
+}
diff --git a/amd64_raw_vex_packed_float_logical_test.go b/amd64_raw_vex_packed_float_logical_test.go
new file mode 100644
index 000000000..9f2665c69
--- /dev/null
+++ b/amd64_raw_vex_packed_float_logical_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86VEXPackedFloatLogicalTestOpcodes = map[byte]string{
+	0x54: "VAND",
+	0x55: "VANDN",
+	0x56: "VOR",
+	0x57: "VXOR",
+}
+
+func encodeX86VEXPackedFloatLogical(opcode, pp byte, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | int(pp))
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 1)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | int(pp))
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestTranslateRawVEXPackedFloatLogicalWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawLogical(SB), $0-0
+	WORD $0x8944; BYTE $0xc8
+	WORD $0xe083; BYTE $0x03
+	LONG $0xc057f8c5
+	WORD $0xc931
+	RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			// Keep every original byte, including the read of unknown R9.
+			// Its format object is not an initialized public source program.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+			if !strings.Contains(ir, "xor <4 x i32>") {
+				t.Fatalf("raw VXORPS lowering omitted vector xor:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "amd64-raw-vex-logical.ll", "amd64-raw-vex-logical.o", ir)
+
+			initialized := strings.Replace(source, "TEXT rawLogical(SB), $0-0\n",
+				"TEXT rawLogical(SB), $0-4\nMOVL value+0(FP), R9\n", 1)
+			x86LEAActualTargetGoObject(t, "amd64", triple, initialized)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, "func rawLogical(value uint32)", "amd64", triple, api)
+					if err != nil {
+						t.Fatal("initialized original raw logical sequence", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestDecodedX86VEXPackedFloatLogicalCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, stem := range x86VEXPackedFloatLogicalTestOpcodes {
+		for pp, suffix := range map[byte]string{0: "PS", 1: "PD"} {
+			for _, vex3 := range []bool{false, true} {
+				for _, width256 := range []bool{false, true} {
+					prefix := "X"
+					if width256 {
+						prefix = "Y"
+					}
+					for _, widthIgnored := range []bool{false, true} {
+						if !vex3 && widthIgnored {
+							continue
+						}
+						source2Limit := 16
+						if !vex3 {
+							source2Limit = 8
+						}
+						for destination := 0; destination < 16; destination++ {
+							for source1 := 0; source1 < 16; source1++ {
+								for source2 := 0; source2 < source2Limit; source2++ {
+									code := encodeX86VEXPackedFloatLogical(opcode, pp, vex3, width256, widthIgnored, destination, source1, source2)
+									got, length, ok, err := decodedX86VEXPackedFloatLogicalInstruction(code, 64)
+									if err != nil || !ok || length != len(code) {
+										t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+									}
+									wantOp := Op(stem + suffix)
+									wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+									if got.Op != wantOp || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+										t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+									}
+									count++
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 163840 {
+		t.Fatalf("covered %d VEX packed floating logical register encodings, want 163840", count)
+	}
+}
+
+func TestDecodedX86VEXPackedFloatLogicalMemoryForms(t *testing.T) {
+	tests := []struct {
+		name   string
+		code   []byte
+		op     Op
+		source MemRef
+		second Reg
+		dest   Reg
+	}{
+		{name: "base", code: []byte{0xc4, 0xe1, 0x78, 0x57, 0x00}, op: "VXORPS", source: MemRef{Base: AX}, second: "X0", dest: "X0"},
+		{name: "extended SIB displacement and FS", code: []byte{0x64, 0xc4, 0x01, 0x65, 0x54, 0x64, 0x88, 0x20}, op: "VANDPD", source: MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}, second: "Y3", dest: "Y12"},
+		{name: "base displacement and GS", code: []byte{0x65, 0xc5, 0xec, 0x56, 0x4d, 0x7f}, op: "VORPS", source: MemRef{Segment: GS, Base: BP, Off: 0x7f}, second: "Y2", dest: "Y1"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got, length, ok, err := decodedX86VEXPackedFloatLogicalInstruction(test.code, 64)
+			if err != nil || !ok || length != len(test.code) {
+				t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", test.code, got, length, ok, err)
+			}
+			if got.Op != test.op || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != test.source || got.Args[1].Kind != OpReg || got.Args[1].Reg != test.second || got.Args[2].Kind != OpReg || got.Args[2].Reg != test.dest {
+				t.Fatalf("decode %x = %+v, want %s %+v, %s, %s", test.code, got, test.op, test.source, test.second, test.dest)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VEXPackedFloatLogicalRejectsReservedForms(t *testing.T) {
+	valid := encodeX86VEXPackedFloatLogical(0x57, 0, true, false, false, 0, 0, 0)
+	for _, code := range [][]byte{
+		{0xc5},
+		{0xc4, valid[1] ^ 1, valid[2], valid[3], valid[4]},
+		encodeX86VEXPackedFloatLogical(0x58, 0, true, false, false, 0, 0, 0),
+	} {
+		if got, _, ok, err := decodedX86VEXPackedFloatLogicalInstruction(code, 64); ok || err != nil {
+			t.Fatalf("reserved encoding %x decoded as %+v, ok=%v, err=%v", code, got, ok, err)
+		}
+	}
+	reservedPP := encodeX86VEXPackedFloatLogical(0x57, 2, true, false, false, 0, 0, 0)
+	if _, _, ok, err := decodedX86VEXPackedFloatLogicalInstruction(reservedPP, 64); !ok || err == nil {
+		t.Fatalf("reserved pp encoding %x returned ok=%v err=%v", reservedPP, ok, err)
+	}
+	ripRelative := []byte{0xc5, 0xec, 0x56, 0x0d, 0x78, 0x56, 0x34, 0x12}
+	if _, _, ok, err := decodedX86VEXPackedFloatLogicalInstruction(ripRelative, 64); !ok || err == nil {
+		t.Fatalf("source-layout-unsafe RIP-relative encoding %x returned ok=%v err=%v", ripRelative, ok, err)
+	}
+	extended := encodeX86VEXPackedFloatLogical(0x57, 0, true, false, false, 8, 8, 8)
+	if _, _, ok, err := decodedX86VEXPackedFloatLogicalInstruction(extended, 32); !ok || err == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", ok, err)
+	}
+}
diff --git a/amd64_raw_vex_packed_integer_logical_test.go b/amd64_raw_vex_packed_integer_logical_test.go
new file mode 100644
index 000000000..576222fc5
--- /dev/null
+++ b/amd64_raw_vex_packed_integer_logical_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86VEXPackedIntegerLogicalTestOpcodes = map[byte]Op{
+	0xdb: "VPAND",
+	0xdf: "VPANDN",
+	0xeb: "VPOR",
+	0xef: "VPXOR",
+}
+
+func encodeX86VEXPackedIntegerLogical(opcode byte, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | 1)
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 1)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | 1)
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestTranslateRawVEXPackedIntegerLogicalWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawLogical(SB), $0-0
+	LONG $0xc0eff9c5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawLogical": {Name: "rawLogical", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "xor <16 x i8>") {
+		t.Fatalf("raw VPXOR lowering omitted vector xor:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-integer-logical.ll", "amd64-raw-vex-integer-logical.o", ir)
+}
+
+func TestDecodedX86VEXPackedIntegerLogicalCompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, wantOp := range x86VEXPackedIntegerLogicalTestOpcodes {
+		for _, vex3 := range []bool{false, true} {
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				for _, widthIgnored := range []bool{false, true} {
+					if !vex3 && widthIgnored {
+						continue
+					}
+					source2Limit := 16
+					if !vex3 {
+						source2Limit = 8
+					}
+					for destination := 0; destination < 16; destination++ {
+						for source1 := 0; source1 < 16; source1++ {
+							for source2 := 0; source2 < source2Limit; source2++ {
+								code := encodeX86VEXPackedIntegerLogical(opcode, vex3, width256, widthIgnored, destination, source1, source2)
+								got, length, ok, err := decodedX86VEXPackedIntegerLogicalInstruction(code, 64)
+								if err != nil || !ok || length != len(code) {
+									t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+								}
+								wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+								if got.Op != wantOp || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+									t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 81920 {
+		t.Fatalf("covered %d VEX packed integer logical register encodings, want 81920", count)
+	}
+}
+
+func TestDecodedX86VEXPackedIntegerLogicalMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x01, 0xe5, 0xdb, 0x64, 0x88, 0x20}
+	got, length, ok, err := decodedX86VEXPackedIntegerLogicalInstruction(code, 64)
+	wantSource := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VPAND" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource || got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXPackedIntegerLogical(0xef, true, false, false, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc5},
+		{0xc4, valid[1] ^ 1, valid[2], valid[3], valid[4]},
+		encodeX86VEXPackedIntegerLogical(0xee, true, false, false, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXPackedIntegerLogicalInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	invalidPP := []byte{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4]}
+	if _, _, matched, decodeErr := decodedX86VEXPackedIntegerLogicalInstruction(invalidPP, 64); !matched || decodeErr == nil {
+		t.Fatalf("invalid pp encoding %x returned ok=%v err=%v", invalidPP, matched, decodeErr)
+	}
+	extended := encodeX86VEXPackedIntegerLogical(0xef, true, false, false, 8, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXPackedIntegerLogicalInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vex_packed_integer_move_test.go b/amd64_raw_vex_packed_integer_move_test.go
new file mode 100644
index 000000000..17ef6b597
--- /dev/null
+++ b/amd64_raw_vex_packed_integer_move_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86RawVEXPackedIntegerMoveCorpusEncoding(t *testing.T) {
+	const source = "TEXT corpusmove(SB),4,$0-0\n\tVMOVDQU -32(SI)(CX*4), Y14\n\tRET\n"
+	code := assembleX87ControlBytes(t, "amd64", source)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	named, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+	}
+	for i, got := range decoded.Instrs {
+		if got.Op != want[i].Op || !reflect.DeepEqual(got.Args, want[i].Args) {
+			t.Fatalf("instruction %d=%+v, want %+v", i, got, want[i])
+		}
+	}
+}
+
+func TestX86RawVEXPackedIntegerMoveRejectsReservedForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{"missing ModRM", []byte{0xc5, 0xfe, 0x6f}, 64},
+		{"missing SIB", []byte{0xc5, 0xfe, 0x6f, 0x04}, 64},
+		{"missing displacement", []byte{0xc5, 0xfe, 0x6f, 0x44, 0x24}, 64},
+		{"reserved vvvv", []byte{0xc5, 0xf6, 0x6f, 0xc0}, 64},
+		{"extended register in 386", []byte{0xc5, 0x7e, 0x6f, 0xc0}, 32},
+		{"address override", []byte{0x67, 0xc5, 0xfe, 0x6f, 0xc0}, 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, matched, err := decodedX86PackedMoveInstruction(test.code, test.mode); !matched || err == nil {
+				t.Fatalf("invalid %x: matched=%v err=%v", test.code, matched, err)
+			}
+		})
+	}
+}
+
+func TestX86RawVEXPackedIntegerMoveIgnoresWBit(t *testing.T) {
+	for _, code := range [][]byte{
+		{0xc4, 0xe1, 0x7e, 0x6f, 0xc0},
+		{0xc4, 0xe1, 0xfe, 0x6f, 0xc0},
+	} {
+		got, size, matched, err := decodedX86PackedMoveInstruction(code, 64)
+		if err != nil || !matched || size != len(code) || got.Op != "VMOVDQU" ||
+			!reflect.DeepEqual(got.Args, []Operand{{Kind: OpReg, Reg: "Y0"}, {Kind: OpReg, Reg: "Y0"}}) {
+			t.Fatalf("decode %x=%+v size=%d matched=%v err=%v", code, got, size, matched, err)
+		}
+	}
+}
diff --git a/amd64_raw_vex_packed_madd_literal_test.go b/amd64_raw_vex_packed_madd_literal_test.go
new file mode 100644
index 000000000..84df43a1a
--- /dev/null
+++ b/amd64_raw_vex_packed_madd_literal_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawVEXPackedMADDConstant(opcode byte, opcodeMap int, vex3, width256, w bool) []byte {
+	code := encodeX86VEXPackedMADD(opcode, opcodeMap, vex3, width256, w, 0, 0, 0)
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	width := 16
+	if width256 {
+		width = 32
+	}
+	for i := 0; i < width; i++ {
+		code = append(code, byte(i*29+13))
+	}
+	return code
+}
+
+func TestDecodeX86RawVEXPackedMADDLiteralCompleteFamily(t *testing.T) {
+	for _, form := range []struct {
+		opcode byte
+		mapID  int
+		op     Op
+		vex2   bool
+	}{
+		{0xf5, 1, "VPMADDWD", true},
+		{0x04, 2, "VPMADDUBSW", false},
+	} {
+		for _, vex3 := range []bool{false, true} {
+			if !vex3 && !form.vex2 {
+				continue
+			}
+			for _, width256 := range []bool{false, true} {
+				for _, w := range []bool{false, true} {
+					if !vex3 && w {
+						continue
+					}
+					name := fmt.Sprintf("%s/vex3=%t/y=%t/w=%t", form.op, vex3, width256, w)
+					t.Run(name, func(t *testing.T) {
+						code := x86RawVEXPackedMADDConstant(form.opcode, form.mapID, vex3, width256, w)
+						decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+						if err != nil {
+							t.Fatal(err)
+						}
+						if len(decoded) != 2 || decoded[0].Op != form.op ||
+							decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+							decoded[1].Op != OpRET {
+							t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, form.op)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVEXPackedMADDLiteralRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVEXPackedMADDConstant(0xf5, 1, false, false, false)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlap": func(code []byte) []byte {
+			code[4] = 0
+			return code
+		},
+		"outside": func(code []byte) []byte {
+			code[4] = 127
+			return code
+		},
+		"segment": func(code []byte) []byte { return append([]byte{0x64}, code...) },
+		"address": func(code []byte) []byte { return append([]byte{0x67}, code...) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVEXPackedMADDLiteralObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, form := range []struct {
+		opcode byte
+		mapID  int
+	}{
+		{0xf5, 1}, {0x04, 2},
+	} {
+		code := x86RawVEXPackedMADDConstant(form.opcode, form.mapID, true, true, false)
+		name := fmt.Sprintf("packedMADDConstant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		pools = append(pools, code[len(code)-32:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "packed-madd-literal.ll", "packed-madd-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vex_packed_madd_test.go b/amd64_raw_vex_packed_madd_test.go
new file mode 100644
index 000000000..052c64c0e
--- /dev/null
+++ b/amd64_raw_vex_packed_madd_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXPackedMADD(opcode byte, opcodeMap int, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | 1)
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | opcodeMap)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | 1)
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestTranslateRawVEXPackedMADDWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawMADD(SB), $0-0
+	LONG $0xd4f5edc5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawMADD": {Name: "rawMADD", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mul <16 x i32>") {
+		t.Fatalf("raw VPMADDWD lowering omitted packed multiplication:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-packed-madd.ll", "amd64-raw-vex-packed-madd.o", ir)
+}
+
+func TestDecodedX86VEXPackedMADDCompleteRegisterFamily(t *testing.T) {
+	tests := []struct {
+		opcode    byte
+		opcodeMap int
+		op        Op
+		vex2      bool
+	}{
+		{opcode: 0xf5, opcodeMap: 1, op: "VPMADDWD", vex2: true},
+		{opcode: 0x04, opcodeMap: 2, op: "VPMADDUBSW"},
+	}
+	count := 0
+	for _, test := range tests {
+		for _, vex3 := range []bool{false, true} {
+			if !vex3 && !test.vex2 {
+				continue
+			}
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				for _, widthIgnored := range []bool{false, true} {
+					if !vex3 && widthIgnored {
+						continue
+					}
+					source2Limit := 16
+					if !vex3 {
+						source2Limit = 8
+					}
+					for destination := 0; destination < 16; destination++ {
+						for source1 := 0; source1 < 16; source1++ {
+							for source2 := 0; source2 < source2Limit; source2++ {
+								code := encodeX86VEXPackedMADD(test.opcode, test.opcodeMap, vex3, width256, widthIgnored, destination, source1, source2)
+								got, length, ok, err := decodedX86VEXPackedMADDInstruction(code, 64)
+								if err != nil || !ok || length != len(code) {
+									t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+								}
+								wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+								if got.Op != test.op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+									t.Fatalf("decode %x = %+v, want %s %s", code, got, test.op, strings.Join(wantArgs, ", "))
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 36864 {
+		t.Fatalf("covered %d VEX packed multiply-add register encodings, want 36864", count)
+	}
+}
+
+func TestDecodedX86VEXPackedMADDMemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x02, 0xe5, 0x04, 0x64, 0x88, 0x20}
+	got, length, ok, err := decodedX86VEXPackedMADDInstruction(code, 64)
+	wantSource := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VPMADDUBSW" || len(got.Args) != 3 || got.Args[0].Kind != OpMem || got.Args[0].Mem != wantSource || got.Args[1].String() != "Y3" || got.Args[2].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXPackedMADD(0xf5, 1, true, false, false, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc5},
+		encodeX86VEXPackedMADD(0xf4, 1, true, false, false, 0, 0, 0),
+		encodeX86VEXPackedMADD(0x04, 1, true, false, false, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXPackedMADDInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	invalidPP := []byte{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4]}
+	if _, _, matched, decodeErr := decodedX86VEXPackedMADDInstruction(invalidPP, 64); !matched || decodeErr == nil {
+		t.Fatalf("invalid pp encoding %x returned ok=%v err=%v", invalidPP, matched, decodeErr)
+	}
+	extended := encodeX86VEXPackedMADD(0xf5, 1, true, false, false, 8, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXPackedMADDInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vex_packed_shuffle_test.go b/amd64_raw_vex_packed_shuffle_test.go
new file mode 100644
index 000000000..eaef494b4
--- /dev/null
+++ b/amd64_raw_vex_packed_shuffle_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXPackedShuffle(pp byte, vex3, width256, widthIgnored bool, destination, source int, immediate byte) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | 15<<3 | int(l)<<2 | int(pp))
+		return []byte{0xc5, vex1, 0x70, modRM, immediate}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source/8)<<5 | 1)
+	vex1 := byte(15<<3 | int(l)<<2 | int(pp))
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, 0x70, modRM, immediate}
+}
+
+func TestTranslateRawVEXPackedShuffleWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawShuffle(SB), $0-0
+	LONG $0xc870f9c5
+	BYTE $0x1b
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawShuffle": {Name: "rawShuffle", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "shufflevector <16 x i8>") ||
+		!strings.Contains(ir, "<16 x i32> <i32 12, i32 13, i32 14, i32 15, i32 8, i32 9, i32 10, i32 11, i32 4, i32 5, i32 6, i32 7, i32 0, i32 1, i32 2, i32 3>") {
+		t.Fatalf("raw VPSHUFD lowering omitted packed shuffle:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-packed-shuffle.ll", "amd64-raw-vex-packed-shuffle.o", ir)
+}
+
+func TestDecodedX86PackedShuffleCompleteVEXRegisterFamily(t *testing.T) {
+	tests := []struct {
+		pp byte
+		op Op
+	}{
+		{pp: 1, op: "VPSHUFD"},
+		{pp: 2, op: "VPSHUFHW"},
+		{pp: 3, op: "VPSHUFLW"},
+	}
+	count := 0
+	for _, test := range tests {
+		for _, vex3 := range []bool{false, true} {
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				for _, widthIgnored := range []bool{false, true} {
+					if !vex3 && widthIgnored {
+						continue
+					}
+					sourceLimit := 16
+					if !vex3 {
+						sourceLimit = 8
+					}
+					for destination := 0; destination < 16; destination++ {
+						for source := 0; source < sourceLimit; source++ {
+							immediate := byte(destination<<4 | source)
+							code := encodeX86VEXPackedShuffle(test.pp, vex3, width256, widthIgnored, destination, source, immediate)
+							got, length, ok, err := decodedX86PackedShuffleInstruction(code, 64)
+							if err != nil || !ok || length != len(code) {
+								t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+							}
+							wantArgs := []string{fmt.Sprintf("$%d", immediate), fmt.Sprintf("%s%d", prefix, source), fmt.Sprintf("%s%d", prefix, destination)}
+							if got.Op != test.op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+								t.Fatalf("decode %x = %+v, want %s %s", code, got, test.op, strings.Join(wantArgs, ", "))
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 3840 {
+		t.Fatalf("covered %d VEX packed shuffle register encodings, want 3840", count)
+	}
+}
+
+func TestDecodedX86PackedShuffleCompleteGo127Family(t *testing.T) {
+	// Go 1.27 assigns these three instructions the shared _yvpshufd table.
+	// The cases cover VEX/EVEX X/Y/Z, WIG, high registers, memory, masks,
+	// zeroing, the VPSHUFD-only broadcast, and compressed disp8.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "vex d reported weaviate", code: []byte{0xc5, 0xf9, 0x70, 0xc8, 0x1b}, want: "VPSHUFD $27, X0, X1"},
+		{name: "vex hw y WIG memory", code: []byte{0x64, 0xc4, 0x01, 0xfe, 0x70, 0x64, 0x88, 0x20, 0x5a}, want: "VPSHUFHW $90, 32(R8)(R9*4)(FS), Y12"},
+		{name: "evex d x high masked", code: []byte{0x62, 0x71, 0x7d, 0x0c, 0x70, 0xca, 0x7e}, want: "VPSHUFD $126, X2, K4, X9"},
+		{name: "evex hw x high masked WIG", code: []byte{0x62, 0x41, 0xfe, 0x0a, 0x70, 0xfb, 0x0d}, want: "VPSHUFHW $13, X11, K2, X31"},
+		{name: "evex lw y high masked", code: []byte{0x62, 0xe1, 0x7f, 0x2a, 0x70, 0xdf, 0x00}, want: "VPSHUFLW $0, Y7, K2, Y19"},
+		{name: "evex d z broadcast zeroing", code: []byte{0x62, 0xf1, 0x7d, 0xdb, 0x70, 0x50, 0x7f, 0x09}, want: "VPSHUFD.BCST.Z $9, 508(AX), K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86PackedShuffleInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("packed shuffle encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86PackedShuffleRejectsInvalidForms(t *testing.T) {
+	valid := encodeX86VEXPackedShuffle(1, true, false, false, 0, 0, 1)
+	invalidVVVV := append([]byte(nil), valid...)
+	invalidVVVV[2] &^= 0x08
+	for name, code := range map[string][]byte{
+		"truncated":      {0xc5},
+		"wrong opcode":   {0xc5, 0xf9, 0x71, 0xc0, 1},
+		"wrong map":      {0xc4, 0xe2, 0x79, 0x70, 0xc0, 1},
+		"unrelated pp":   {0xc5, 0xf8, 0x70, 0xc0, 1},
+		"EVEX D with W1": {0x62, 0xf1, 0xfd, 0x08, 0x70, 0xc0, 1},
+	} {
+		if instruction, _, matched, decodeErr := decodedX86PackedShuffleInstruction(code, 64); matched || decodeErr != nil {
+			t.Fatalf("%s encoding %x decoded as %+v, ok=%v, err=%v", name, code, instruction, matched, decodeErr)
+		}
+	}
+	if _, _, matched, decodeErr := decodedX86PackedShuffleInstruction(invalidVVVV, 64); !matched || decodeErr == nil {
+		t.Fatalf("non-reserved VEX.vvvv encoding %x returned ok=%v err=%v", invalidVVVV, matched, decodeErr)
+	}
+	extended := encodeX86VEXPackedShuffle(1, true, false, false, 8, 8, 1)
+	if _, _, matched, decodeErr := decodedX86PackedShuffleInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+	invalidBroadcast := []byte{0x62, 0xf1, 0x7e, 0x5b, 0x70, 0x50, 0x7f, 1}
+	if _, _, matched, decodeErr := decodedX86PackedShuffleInstruction(invalidBroadcast, 64); !matched || decodeErr == nil {
+		t.Fatalf("VPSHUFHW broadcast returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vextract128_test.go b/amd64_raw_vextract128_test.go
new file mode 100644
index 000000000..3cde8176d
--- /dev/null
+++ b/amd64_raw_vextract128_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXTRACT128(opcode, immediate byte, source, destination int) []byte {
+	vex0 := byte((1-source/8)<<7 | 1<<6 | (1-destination/8)<<5 | 3)
+	modRM := byte(0xc0 | (source&7)<<3 | destination&7)
+	return []byte{0xc4, vex0, 0x7d, opcode, modRM, immediate}
+}
+
+func encodeX86EVEXTRACT(opcode, immediate byte, width64 bool, vectorBits byte, mask int, zeroing bool, source, destination int) []byte {
+	p0 := byte((1-source/8&1)<<7 | (1-destination/16)<<6 | (1-destination/8&1)<<5 | (1-source/16)<<4 | 3)
+	p1 := byte(0x7d)
+	if width64 {
+		p1 |= 0x80
+	}
+	p2 := byte(vectorBits<<5 | 1<<3 | byte(mask))
+	if zeroing {
+		p2 |= 0x80
+	}
+	modRM := byte(0xc0 | (source&7)<<3 | destination&7)
+	return []byte{0x62, p0, p1, p2, opcode, modRM, immediate}
+}
+
+func TestTranslateRawVEXTRACT128WeaviateRegression(t *testing.T) {
+	const source = `TEXT rawExtract(SB), $0-0
+	LONG $0x197de3c4; WORD $0x01c1
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawExtract": {Name: "rawExtract", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "shufflevector <32 x i8>") {
+		t.Fatalf("raw VEXTRACTF128 lowering omitted vector extract:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vextract128.ll", "amd64-raw-vextract128.o", ir)
+}
+
+func TestDecodedX86VEXTRACT128CompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, wantOp := range map[byte]Op{0x19: "VEXTRACTF128", 0x39: "VEXTRACTI128"} {
+		for source := 0; source < 16; source++ {
+			for destination := 0; destination < 16; destination++ {
+				for immediate := 0; immediate < 256; immediate++ {
+					code := encodeX86VEXTRACT128(opcode, byte(immediate), source, destination)
+					got, length, ok, err := decodedX86VEXTRACT128Instruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					if got.Op != wantOp || len(got.Args) != 3 || got.Args[0].Imm != int64(immediate) || got.Args[1].String() != fmt.Sprintf("Y%d", source) || got.Args[2].String() != fmt.Sprintf("X%d", destination) {
+						t.Fatalf("decode %x = %+v, want %s $%d, Y%d, X%d", code, got, wantOp, immediate, source, destination)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 131072 {
+		t.Fatalf("covered %d VEXTRACT128 register encodings, want 131072", count)
+	}
+}
+
+func TestDecodedX86VEXTRACT128MemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x03, 0x7d, 0x39, 0x64, 0x88, 0x20, 0xff}
+	got, length, ok, err := decodedX86VEXTRACT128Instruction(code, 64)
+	wantDestination := MemRef{Segment: FS, Base: "R8", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VEXTRACTI128" || len(got.Args) != 3 || got.Args[0].Imm != 0xff || got.Args[1].String() != "Y12" || got.Args[2].Kind != OpMem || got.Args[2].Mem != wantDestination {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VEXTRACT128(0x19, 1, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc4},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4], valid[5]},
+		encodeX86VEXTRACT128(0x18, 1, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXTRACT128Instruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	for _, invalid := range [][]byte{
+		{valid[0], valid[1], valid[2] &^ 1, valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2] &^ 4, valid[3], valid[4], valid[5]},
+		{valid[0], valid[1], valid[2] | 0x80, valid[3], valid[4], valid[5]},
+	} {
+		if _, _, matched, decodeErr := decodedX86VEXTRACT128Instruction(invalid, 64); !matched || decodeErr == nil {
+			t.Fatalf("reserved encoding %x returned ok=%v err=%v", invalid, matched, decodeErr)
+		}
+	}
+	extended := encodeX86VEXTRACT128(0x19, 1, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXTRACT128Instruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("32-bit extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+}
+
+func TestTranslateRawEVEXTRACTWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawEVEXTRACT(SB), $0-0
+	LONG $0x48fdf362
+	WORD $0xc13b
+	BYTE $0x01
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawEVEXTRACT": {Name: "rawEVEXTRACT", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "shufflevector <64 x i8>") {
+		t.Fatalf("raw VEXTRACTI64X4 lowering omitted 256-bit block extract:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-evextract.ll", "amd64-raw-evextract.o", ir)
+}
+
+func TestDecodedX86VEXTRACTCompleteEVEXRegisterFamily(t *testing.T) {
+	tests := []struct {
+		opcode      byte
+		width64     bool
+		op          Op
+		outputBytes int
+		vectorBits  []byte
+	}{
+		{opcode: 0x19, op: "VEXTRACTF32X4", outputBytes: 16, vectorBits: []byte{1, 2}},
+		{opcode: 0x19, width64: true, op: "VEXTRACTF64X2", outputBytes: 16, vectorBits: []byte{1, 2}},
+		{opcode: 0x1b, op: "VEXTRACTF32X8", outputBytes: 32, vectorBits: []byte{2}},
+		{opcode: 0x1b, width64: true, op: "VEXTRACTF64X4", outputBytes: 32, vectorBits: []byte{2}},
+		{opcode: 0x39, op: "VEXTRACTI32X4", outputBytes: 16, vectorBits: []byte{1, 2}},
+		{opcode: 0x39, width64: true, op: "VEXTRACTI64X2", outputBytes: 16, vectorBits: []byte{1, 2}},
+		{opcode: 0x3b, op: "VEXTRACTI32X8", outputBytes: 32, vectorBits: []byte{2}},
+		{opcode: 0x3b, width64: true, op: "VEXTRACTI64X4", outputBytes: 32, vectorBits: []byte{2}},
+	}
+	count := 0
+	for _, test := range tests {
+		for _, vectorBits := range test.vectorBits {
+			sourcePrefix := [...]string{"", "Y", "Z"}[vectorBits]
+			destinationPrefix := "X"
+			if test.outputBytes == 32 {
+				destinationPrefix = "Y"
+			}
+			for _, masking := range []struct {
+				mask    int
+				zeroing bool
+				suffix  string
+			}{
+				{},
+				{mask: 3},
+				{mask: 7, zeroing: true, suffix: ".Z"},
+			} {
+				for source := 0; source < 32; source++ {
+					for destination := 0; destination < 32; destination++ {
+						immediate := byte(source<<3 | destination&7)
+						code := encodeX86EVEXTRACT(test.opcode, immediate, test.width64, vectorBits, masking.mask, masking.zeroing, source, destination)
+						got, length, ok, err := decodedX86VEXTRACT128Instruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{fmt.Sprintf("$%d", immediate), fmt.Sprintf("%s%d", sourcePrefix, source)}
+						if masking.mask != 0 {
+							wantArgs = append(wantArgs, fmt.Sprintf("K%d", masking.mask))
+						}
+						wantArgs = append(wantArgs, fmt.Sprintf("%s%d", destinationPrefix, destination))
+						wantOp := test.op + Op(masking.suffix)
+						if got.Op != wantOp || len(got.Args) != len(wantArgs) {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+						}
+						for index := range wantArgs {
+							if got.Args[index].String() != wantArgs[index] {
+								t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+							}
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 36864 {
+		t.Fatalf("covered %d EVEX vector extract register encodings, want 36864", count)
+	}
+}
+
+func TestDecodedX86VEXTRACTCompleteEVEXMemoryAndInvalidForms(t *testing.T) {
+	tests := []struct {
+		opcode      byte
+		width64     bool
+		op          Op
+		outputBytes int
+		vectorBits  byte
+	}{
+		{opcode: 0x19, op: "VEXTRACTF32X4", outputBytes: 16, vectorBits: 1},
+		{opcode: 0x19, width64: true, op: "VEXTRACTF64X2", outputBytes: 16, vectorBits: 2},
+		{opcode: 0x1b, op: "VEXTRACTF32X8", outputBytes: 32, vectorBits: 2},
+		{opcode: 0x1b, width64: true, op: "VEXTRACTF64X4", outputBytes: 32, vectorBits: 2},
+		{opcode: 0x39, op: "VEXTRACTI32X4", outputBytes: 16, vectorBits: 1},
+		{opcode: 0x39, width64: true, op: "VEXTRACTI64X2", outputBytes: 16, vectorBits: 2},
+		{opcode: 0x3b, op: "VEXTRACTI32X8", outputBytes: 32, vectorBits: 2},
+		{opcode: 0x3b, width64: true, op: "VEXTRACTI64X4", outputBytes: 32, vectorBits: 2},
+	}
+	for _, test := range tests {
+		code := encodeX86EVEXTRACT(test.opcode, 0xff, test.width64, test.vectorBits, 2, false, 21, 0)
+		code[5] = 0x68
+		code = append(code[:6], append([]byte{0x7f}, code[6:]...)...)
+		got, length, ok, err := decodedX86VEXTRACT128Instruction(code, 64)
+		wantSourcePrefix := [...]string{"", "Y", "Z"}[test.vectorBits]
+		wantDestination := fmt.Sprintf("%d(AX)", test.outputBytes*127)
+		if err != nil || !ok || length != len(code) || got.Op != test.op || len(got.Args) != 4 || got.Args[0].Imm != 0xff || got.Args[1].String() != fmt.Sprintf("%s21", wantSourcePrefix) || got.Args[2].String() != "K2" || got.Args[3].String() != wantDestination {
+			t.Fatalf("decode %x = %+v, length=%d ok=%v err=%v; want %s $255, %s21, K2, %s", code, got, length, ok, err, test.op, wantSourcePrefix, wantDestination)
+		}
+	}
+
+	valid := encodeX86EVEXTRACT(0x3b, 1, true, 2, 1, false, 0, 0)
+	for name, mutate := range map[string]func([]byte){
+		"used vvvv":       func(code []byte) { code[2] &^= 0x08 },
+		"broadcast":       func(code []byte) { code[3] |= 0x10 },
+		"reserved length": func(code []byte) { code[3] |= 0x20 },
+	} {
+		code := append([]byte(nil), valid...)
+		mutate(code)
+		if _, _, matched, decodeErr := decodedX86VEXTRACT128Instruction(code, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x returned ok=%v err=%v", name, code, matched, decodeErr)
+		}
+	}
+	memoryZero := encodeX86EVEXTRACT(0x3b, 1, true, 2, 1, true, 0, 0)
+	memoryZero[5] = 0x00
+	memoryZero = append(memoryZero[:6], append([]byte{0, 0, 0, 0}, memoryZero[6:]...)...)
+	if _, _, matched, decodeErr := decodedX86VEXTRACT128Instruction(memoryZero, 64); !matched || decodeErr == nil {
+		t.Fatalf("zeroing memory encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vinserti128_test.go b/amd64_raw_vinserti128_test.go
new file mode 100644
index 000000000..122fbff64
--- /dev/null
+++ b/amd64_raw_vinserti128_test.go
@@ -0,0 +1,226 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func encodeX86VINSERT128(opcode, immediate byte, firstSource, secondSource, destination int) []byte {
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-firstSource/8)<<5 | 3)
+	vexBits := byte((^secondSource&15)<<3 | 1<<2 | 1)
+	modRM := byte(0xc0 | (destination&7)<<3 | firstSource&7)
+	return []byte{0xc4, vex0, vexBits, opcode, modRM, immediate}
+}
+
+func encodeX86VEXPackedBroadcast(opcode byte, wide bool, source, destination int) []byte {
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source/8)<<5 | 2)
+	vexBits := byte(0x79)
+	if wide {
+		vexBits |= 1 << 2
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source&7)
+	return []byte{0xc4, vex0, vexBits, opcode, modRM}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedInfectiousVINSERTI128(t *testing.T) {
+	code := []byte{
+		0xc4, 0xe3, 0x4d, 0x38, 0xf6, 0x01,
+		0xc4, 0xe3, 0x45, 0x38, 0xff, 0x01,
+		0xc4, 0x62, 0x7d, 0x78, 0xc5,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "infectious VINSERTI128 sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{
+		"VINSERTI128 $1, X6, Y6, Y6",
+		"VINSERTI128 $1, X7, Y7, Y7",
+		"VPBROADCASTB X5, Y8",
+	}
+	if len(decoded) != len(want) {
+		t.Fatalf("decoded %d instructions as %#v, want %d", len(decoded), decoded, len(want))
+	}
+	for index := range want {
+		if !strings.HasPrefix(decoded[index].Raw, want[index]+" ") {
+			t.Fatalf("instruction %d decoded as %q, want %q", index, decoded[index].Raw, want[index])
+		}
+	}
+}
+
+func TestDecodedX86RawVINSERTI128Go127OracleCases(t *testing.T) {
+	for _, test := range []struct {
+		code []byte
+		want string
+	}{
+		{code: []byte{0xc4, 0xe3, 0x05, 0x38, 0x13, 0x07}, want: "VINSERTI128 $7, 0(BX), Y15, Y2"},
+		{code: []byte{0xc4, 0xc3, 0x05, 0x38, 0x13, 0x07}, want: "VINSERTI128 $7, 0(R11), Y15, Y2"},
+		{code: []byte{0xc4, 0xe3, 0x05, 0x38, 0xd2, 0x07}, want: "VINSERTI128 $7, X2, Y15, Y2"},
+		{code: []byte{0xc4, 0x43, 0x05, 0x38, 0xdb, 0x07}, want: "VINSERTI128 $7, X11, Y15, Y11"},
+	} {
+		instruction, length, ok, err := decodedX86VINSERT128Instruction(test.code, 64)
+		if !ok || err != nil || length != len(test.code) || instruction.Raw != test.want {
+			t.Fatalf("decoded %x as (%#v, %d, %v, %v), want %q", test.code, instruction, length, ok, err, test.want)
+		}
+	}
+}
+
+func TestDecodedX86RawVINSERT128CompleteRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, wantOp := range map[byte]Op{0x18: "VINSERTF128", 0x38: "VINSERTI128"} {
+		for firstSource := 0; firstSource < 16; firstSource++ {
+			for secondSource := 0; secondSource < 16; secondSource++ {
+				for destination := 0; destination < 16; destination++ {
+					immediate := byte(firstSource*16 + destination)
+					code := encodeX86VINSERT128(opcode, immediate, firstSource, secondSource, destination)
+					got, length, ok, err := decodedX86VINSERT128Instruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantArgs := []string{
+						fmt.Sprintf("$%d", immediate),
+						fmt.Sprintf("X%d", firstSource),
+						fmt.Sprintf("Y%d", secondSource),
+						fmt.Sprintf("Y%d", destination),
+					}
+					if got.Op != wantOp || len(got.Args) != len(wantArgs) {
+						t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+					}
+					for index := range wantArgs {
+						if got.Args[index].String() != wantArgs[index] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+						}
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d VINSERT128 register encodings, want 8192", count)
+	}
+}
+
+func TestDecodedX86RawVINSERT128MemoryAndInvalidForms(t *testing.T) {
+	code := []byte{0x64, 0xc4, 0x03, 0x15, 0x38, 0x64, 0x8b, 0x20, 0xff}
+	got, length, ok, err := decodedX86VINSERT128Instruction(code, 64)
+	wantMemory := MemRef{Segment: FS, Base: "R11", Index: "R9", Scale: 4, Off: 32}
+	if err != nil || !ok || length != len(code) || got.Op != "VINSERTI128" || len(got.Args) != 4 || got.Args[0].Imm != 0xff || got.Args[1].Kind != OpMem || !reflect.DeepEqual(got.Args[1].Mem, wantMemory) || got.Args[2].String() != "Y13" || got.Args[3].String() != "Y12" {
+		t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+	}
+
+	valid := encodeX86VINSERT128(0x38, 1, 0, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc4},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4], valid[5]},
+		encodeX86VINSERT128(0x39, 1, 0, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VINSERT128Instruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	for name, mutate := range map[string]func([]byte){
+		"wrong pp":         func(code []byte) { code[2] &^= 1 },
+		"VEX.W":            func(code []byte) { code[2] |= 0x80 },
+		"VEX.128":          func(code []byte) { code[2] &^= 4 },
+		"address override": func(code []byte) { copy(code[1:], code); code[0] = 0x67 },
+	} {
+		code := append([]byte(nil), valid...)
+		if name == "address override" {
+			code = append(code, 0)
+		}
+		mutate(code)
+		if _, _, matched, decodeErr := decodedX86VINSERT128Instruction(code, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x returned ok=%v err=%v", name, code, matched, decodeErr)
+		}
+	}
+	truncatedImmediate := valid[:len(valid)-1]
+	if _, _, matched, decodeErr := decodedX86VINSERT128Instruction(truncatedImmediate, 64); !matched || decodeErr == nil {
+		t.Fatalf("truncated immediate returned ok=%v err=%v", matched, decodeErr)
+	}
+	if _, _, matched, decodeErr := decodedX86VINSERT128Instruction(valid, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 VINSERT128 returned ok=%v err=%v", matched, decodeErr)
+	}
+}
+
+func TestDecodedX86RawVEXPackedBroadcastCompleteRegisterFamily(t *testing.T) {
+	operations := map[byte]Op{
+		0x78: "VPBROADCASTB",
+		0x79: "VPBROADCASTW",
+		0x58: "VPBROADCASTD",
+		0x59: "VPBROADCASTQ",
+	}
+	count := 0
+	for opcode, wantOp := range operations {
+		for _, wide := range []bool{false, true} {
+			for source := 0; source < 16; source++ {
+				for destination := 0; destination < 16; destination++ {
+					code := encodeX86VEXPackedBroadcast(opcode, wide, source, destination)
+					got, length, ok, err := decodedX86VEXPackedBroadcastInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					prefix := "X"
+					if wide {
+						prefix = "Y"
+					}
+					wantArgs := []string{fmt.Sprintf("X%d", source), fmt.Sprintf("%s%d", prefix, destination)}
+					if got.Op != wantOp || len(got.Args) != 2 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] {
+						t.Fatalf("decode %x = %+v, want %s %s", code, got, wantOp, strings.Join(wantArgs, ", "))
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 2048 {
+		t.Fatalf("covered %d VEX packed-broadcast register encodings, want 2048", count)
+	}
+}
+
+func TestDecodedX86RawVEXPackedBroadcastMemoryAndInvalidForms(t *testing.T) {
+	for opcode, wantOp := range map[byte]Op{0x78: "VPBROADCASTB", 0x79: "VPBROADCASTW", 0x58: "VPBROADCASTD", 0x59: "VPBROADCASTQ"} {
+		code := []byte{0x65, 0xc4, 0x02, 0x7d, opcode, 0x64, 0x8b, 0x20}
+		got, length, ok, err := decodedX86VEXPackedBroadcastInstruction(code, 64)
+		wantMemory := MemRef{Segment: GS, Base: "R11", Index: "R9", Scale: 4, Off: 32}
+		if err != nil || !ok || length != len(code) || got.Op != wantOp || len(got.Args) != 2 || got.Args[0].Kind != OpMem || !reflect.DeepEqual(got.Args[0].Mem, wantMemory) || got.Args[1].String() != "Y12" {
+			t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+		}
+	}
+
+	valid := encodeX86VEXPackedBroadcast(0x78, true, 0, 0)
+	for _, invalid := range [][]byte{
+		{0xc4},
+		{valid[0], valid[1] ^ 1, valid[2], valid[3], valid[4]},
+		encodeX86VEXPackedBroadcast(0x77, true, 0, 0),
+	} {
+		if instruction, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(invalid, 64); matched || decodeErr != nil {
+			t.Fatalf("invalid encoding %x decoded as %+v, ok=%v, err=%v", invalid, instruction, matched, decodeErr)
+		}
+	}
+	for name, mutate := range map[string]func([]byte){
+		"wrong pp":  func(code []byte) { code[2] &^= 1 },
+		"VEX.W":     func(code []byte) { code[2] |= 0x80 },
+		"used vvvv": func(code []byte) { code[2] &^= 0x08 },
+	} {
+		code := append([]byte(nil), valid...)
+		mutate(code)
+		if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(code, 64); !matched || decodeErr == nil {
+			t.Fatalf("%s encoding %x returned ok=%v err=%v", name, code, matched, decodeErr)
+		}
+	}
+	ripRelative := []byte{0xc4, 0xe2, 0x7d, 0x78, 0x05, 0, 0, 0, 0}
+	if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(ripRelative, 64); !matched || decodeErr == nil {
+		t.Fatalf("RIP-relative encoding returned ok=%v err=%v", matched, decodeErr)
+	}
+	extended := encodeX86VEXPackedBroadcast(0x78, true, 8, 8)
+	if _, _, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(extended, 32); !matched || decodeErr == nil {
+		t.Fatalf("386 extended-register form returned ok=%v err=%v", matched, decodeErr)
+	}
+	valid386 := encodeX86VEXPackedBroadcast(0x78, true, 7, 7)
+	got, length, matched, decodeErr := decodedX86VEXPackedBroadcastInstruction(valid386, 32)
+	if decodeErr != nil || !matched || length != len(valid386) || got.Raw != "VPBROADCASTB X7, Y7" {
+		t.Fatalf("386 base-register form decoded as %+v, length=%d ok=%v err=%v", got, length, matched, decodeErr)
+	}
+}
diff --git a/amd64_raw_vmov_half_memory.go b/amd64_raw_vmov_half_memory.go
new file mode 100644
index 000000000..61bc8ca44
--- /dev/null
+++ b/amd64_raw_vmov_half_memory.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go 1.27 uses one _yvmovhpd operand table for all four VEX/EVEX half-vector
+// memory moves. Register-only 0F 12/16 forms are the separate VMOVHLPS and
+// VMOVLHPS family and are decoded before this function.
+func decodedX86RawVectorHalfMemoryInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	p, ok := decodeX86RawVectorEncoding(code)
+	if !ok || p.mapNumber != 1 || (p.pp != 0 && p.pp != 1) {
+		return Instr{}, 0, false, nil
+	}
+	if p.opcode != 0x12 && p.opcode != 0x13 && p.opcode != 0x16 && p.opcode != 0x17 {
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("vector half memory move: %s", message)
+	}
+	if mode != 32 && mode != 64 {
+		return fail("unsupported x86 mode")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if p.vectorLength != 0 || p.mask != 0 || p.zero || p.broadcast {
+		return fail("invalid vector length, mask, zeroing, or broadcast")
+	}
+	if p.evex && (!p.fixed || p.w != (p.pp == 1)) {
+		return fail("invalid EVEX fixed or W bit")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	if code[p.modRM]>>6 == 3 {
+		if p.pp == 0 {
+			return Instr{}, 0, false, nil
+		}
+		return fail("Go's VMOVHPD/VMOVLPD forms require memory")
+	}
+
+	var memory Operand
+	var consumed int
+	var err error
+	if p.evex {
+		memory, consumed, err = decodedX86EVEXRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X", 8)
+	} else {
+		memory, consumed, err = decodedX86VEXVectorRMOperand(code[p.modRM:], mode, p.b, p.x, p.segment, "X")
+	}
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	if memory.Kind != OpMem {
+		return fail("expected ModRM memory operand")
+	}
+
+	op := Op("VMOVLPS")
+	if p.pp == 1 {
+		op = "VMOVLPD"
+	}
+	if p.opcode == 0x16 || p.opcode == 0x17 {
+		if p.pp == 0 {
+			op = "VMOVHPS"
+		} else {
+			op = "VMOVHPD"
+		}
+	}
+	store := p.opcode == 0x13 || p.opcode == 0x17
+	vector := int(code[p.modRM]>>3&7) + p.r*8
+	if mode == 32 && (vector >= 8 || p.upper >= 8) {
+		return fail("extended vector register in 32-bit mode")
+	}
+	register := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", vector))}
+	args := []Operand{memory, {Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))}, register}
+	if store {
+		if p.upper != 0 {
+			return fail("store reserves the VEX/EVEX vvvv field")
+		}
+		args = []Operand{register, memory}
+	}
+	printed := make([]string, len(args))
+	for i, arg := range args {
+		printed[i] = arg.String()
+	}
+	return Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s %s", op, strings.Join(printed, ", ")),
+	}, p.modRM + consumed, true, nil
+}
diff --git a/amd64_raw_vmov_half_memory_test.go b/amd64_raw_vmov_half_memory_test.go
new file mode 100644
index 000000000..837bcc515
--- /dev/null
+++ b/amd64_raw_vmov_half_memory_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawVectorHalfMemory(op Op, encoding string, vector, upper int, store, wig bool) []byte {
+	high := strings.Contains(string(op), "H")
+	pd := strings.HasSuffix(string(op), "PD")
+	opcode := byte(0x12)
+	if high {
+		opcode = 0x16
+	}
+	if store {
+		opcode++
+		upper = 0
+	}
+	pp := byte(0)
+	if pd {
+		pp = 1
+	}
+	modRM := byte((vector&7)<<3 | 2)
+	rExt := byte(1 - ((vector >> 3) & 1))
+	switch encoding {
+	case "VEX2":
+		p1 := rExt<<7 | byte(^upper&15)<<3 | pp
+		return []byte{0xc5, p1, opcode, modRM}
+	case "VEX3":
+		p0 := rExt<<7 | 1 // SIB index and base are R13 and R12.
+		p1 := byte(^upper&15)<<3 | pp
+		if wig {
+			p1 |= 0x80
+		}
+		return []byte{0xc4, p0, p1, opcode, (modRM & 0x38) | 0x44, 0xac, 2}
+	case "EVEX":
+		r2Ext := byte(1 - ((vector >> 4) & 1))
+		p0 := rExt<<7 | r2Ext<<4 | 1
+		p1 := byte(^upper&15)<<3 | 4 | pp
+		if pd {
+			p1 |= 0x80
+		}
+		p2 := byte((1 - ((upper >> 4) & 1)) << 3)
+		return []byte{0x62, p0, p1, p2, opcode, (modRM & 0x38) | 0x44, 0xac, 2}
+	default:
+		panic("unknown half-vector encoding")
+	}
+}
+
+func TestTranslateRawVMOVHPDPathtracerRegression(t *testing.T) {
+	const source = `
+TEXT rawVMOVHPD(SB),$0-0
+	MOVQ $0, DX
+	LONG $0x0217f9c5 // VMOVHPD X0, (DX)
+	RET
+`
+	file, signatures := x86UnboundVoidFormatSource(t, source, "rawVMOVHPD", "amd64", "x86_64-unknown-linux-gnu")
+	file, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll := x86MoveHalfFormatObjectUnit(t, file, signatures, "amd64", "x86_64-unknown-linux-gnu")
+	if !strings.Contains(ll, "extractelement <2 x i64>") {
+		t.Fatalf("raw VMOVHPD did not store the high lane:\n%s", ll)
+	}
+}
+
+func TestDecodedX86RawVectorHalfMemoryCompleteGo127Family(t *testing.T) {
+	for _, op := range []Op{"VMOVLPS", "VMOVHPS", "VMOVLPD", "VMOVHPD"} {
+		for _, store := range []bool{false, true} {
+			for _, encoding := range []string{"VEX2", "VEX3", "EVEX"} {
+				vector, upper := 3, 4
+				if encoding == "VEX3" {
+					vector, upper = 11, 12
+				}
+				if encoding == "EVEX" {
+					vector, upper = 20, 21
+				}
+				code := encodeX86RawVectorHalfMemory(op, encoding, vector, upper, store, encoding == "VEX3")
+				got, length, recognized, err := decodedX86RawVectorHalfMemoryInstruction(code, 64)
+				if err != nil || !recognized || length != len(code) || got.Op != op {
+					t.Fatalf("decode %s %s store=%v bytes=%x: got=%+v length=%d recognized=%v err=%v", op, encoding, store, code, got, length, recognized, err)
+				}
+				memoryIndex := 0
+				registerIndex := 2
+				if store {
+					memoryIndex, registerIndex = 1, 0
+				}
+				if got.Args[memoryIndex].Kind != OpMem || got.Args[registerIndex].Reg != Reg(fmt.Sprintf("X%d", vector)) {
+					t.Fatalf("decoded wrong memory/register operands for %x: %+v", code, got.Args)
+				}
+				memory := got.Args[memoryIndex].Mem
+				if encoding == "VEX2" && (memory.Base != DX || memory.Off != 0) {
+					t.Fatalf("decoded wrong VEX2 memory operand for %x: %+v", code, memory)
+				}
+				if encoding == "VEX3" && (memory.Base != "R12" || memory.Index != "R13" || memory.Scale != 4 || memory.Off != 2) {
+					t.Fatalf("decoded wrong VEX3 memory operand for %x: %+v", code, memory)
+				}
+				if encoding == "EVEX" && (memory.Base != "R12" || memory.Index != "R13" || memory.Scale != 4 || memory.Off != 16) {
+					t.Fatalf("decoded wrong EVEX memory operand for %x: %+v", code, memory)
+				}
+				if !store && got.Args[1].Reg != Reg(fmt.Sprintf("X%d", upper)) {
+					t.Fatalf("decoded wrong upper-lane register for %x: %+v", code, got.Args)
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86RawVectorHalfMemoryRejectsInvalidForms(t *testing.T) {
+	valid := encodeX86RawVectorHalfMemory("VMOVHPD", "EVEX", 20, 21, false, false)
+	for _, test := range []struct {
+		name string
+		code []byte
+	}{
+		{"missing ModRM", valid[:5]},
+		{"wrong fixed bit", append([]byte(nil), valid...)},
+		{"wrong W bit", append([]byte(nil), valid...)},
+		{"vector length", append([]byte(nil), valid...)},
+		{"mask", append([]byte(nil), valid...)},
+		{"zeroing", append([]byte(nil), valid...)},
+		{"broadcast", append([]byte(nil), valid...)},
+		{"register operand", append([]byte(nil), valid...)},
+		{"RIP relative", append([]byte(nil), valid...)},
+	} {
+		switch test.name {
+		case "wrong fixed bit":
+			test.code[2] &^= 4
+		case "wrong W bit":
+			test.code[2] &^= 0x80
+		case "vector length":
+			test.code[3] |= 0x20
+		case "mask":
+			test.code[3] |= 1
+		case "zeroing":
+			test.code[3] |= 0x80
+		case "broadcast":
+			test.code[3] |= 0x10
+		case "register operand":
+			test.code[5] |= 0xc0
+		case "RIP relative":
+			test.code[5] = 0x05
+		}
+		t.Run(test.name, func(t *testing.T) {
+			if _, _, recognized, err := decodedX86RawVectorHalfMemoryInstruction(test.code, 64); !recognized || err == nil {
+				t.Fatalf("accepted invalid half-vector encoding %x: recognized=%v err=%v", test.code, recognized, err)
+			}
+		})
+	}
+	store := encodeX86RawVectorHalfMemory("VMOVHPD", "VEX2", 3, 0, true, false)
+	store[1] &^= 0x08 // A non-reserved VEX.vvvv field is not a Go store form.
+	if _, _, recognized, err := decodedX86RawVectorHalfMemoryInstruction(store, 64); !recognized || err == nil {
+		t.Fatalf("accepted store with non-reserved vvvv: recognized=%v err=%v", recognized, err)
+	}
+	extended := encodeX86RawVectorHalfMemory("VMOVHPD", "VEX3", 11, 12, false, false)
+	if _, _, recognized, err := decodedX86RawVectorHalfMemoryInstruction(extended, 32); !recognized || err == nil {
+		t.Fatalf("accepted 386 extended register form: recognized=%v err=%v", recognized, err)
+	}
+}
+
+func TestTranslateRawX86VectorHalfMemoryLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawHalfMemory(SB),$0-0\n")
+			if target.goarch == "386" {
+				source.WriteString("\tMOVL $0, DX\n")
+			} else {
+				source.WriteString("\tMOVQ $0, DX\n")
+			}
+			for _, op := range []Op{"VMOVLPS", "VMOVHPS", "VMOVLPD", "VMOVHPD"} {
+				for _, store := range []bool{false, true} {
+					encodings := []string{"VEX2"}
+					if target.goarch == "amd64" {
+						encodings = append(encodings, "VEX3", "EVEX")
+					}
+					for _, encoding := range encodings {
+						vector, upper := 3, 4
+						if encoding == "VEX3" {
+							vector, upper = 11, 12
+						}
+						if encoding == "EVEX" {
+							vector, upper = 20, 21
+						}
+						for _, value := range encodeX86RawVectorHalfMemory(op, encoding, vector, upper, store, false) {
+							fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, signatures := x86UnboundVoidFormatSource(t, source.String(), "rawHalfMemory", target.goarch, target.triple)
+			file, err := normalizeX86RawFile(file, target.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll := x86MoveHalfFormatObjectUnit(t, file, signatures, target.goarch, target.triple)
+			for _, want := range []string{"extractelement <2 x i64>", "insertelement <2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("half-vector lowering omitted %q", want)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "raw-half-memory.ll", "raw-half-memory.o", ll)
+		})
+	}
+}
diff --git a/amd64_raw_vmovq_test.go b/amd64_raw_vmovq_test.go
new file mode 100644
index 000000000..9b8fb18ea
--- /dev/null
+++ b/amd64_raw_vmovq_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateRawVEXVMOVDWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawVMOVD(SB), $0-0
+	LONG $0x7e79c1c4
+	BYTE $0xc7
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawVMOVD": {Name: "rawVMOVD", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "extractelement <4 x i32>") {
+		t.Fatalf("raw VMOVD lowering omitted scalar extraction:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-vex-vmovd.ll", "amd64-raw-vex-vmovd.o", ir)
+}
+
+func TestDecodedX86VMOVQInstructionCompleteVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "x_to_gp", code: []byte{0xc4, 0xe1, 0xf9, 0x7e, 0xc8}, want: "VMOVQ X1, AX"},
+		{name: "x_to_x", code: []byte{0xc4, 0xe1, 0x79, 0xd6, 0xc8}, want: "VMOVQ X1, X0"},
+		{name: "gp_to_x", code: []byte{0xc4, 0xe1, 0xf9, 0x6e, 0xc8}, want: "VMOVQ AX, X1"},
+		{name: "x_to_x_f3", code: []byte{0xc5, 0xfa, 0x7e, 0xc8}, want: "VMOVQ X0, X1"},
+		{name: "memory_to_extended_x", code: []byte{0xc5, 0x7a, 0x7e, 0x5e, 0x20}, want: "VMOVQ 32(SI), X11"},
+		{name: "extended_x_to_sib_memory", code: []byte{0xc4, 0x21, 0xf9, 0x7e, 0x94, 0x8c, 0x78, 0x56, 0x34, 0x12}, want: "VMOVQ X10, 305419896(SP)(R9*4)"},
+		{name: "reported_weaviate_vmovd", code: []byte{0xc4, 0xc1, 0x79, 0x7e, 0xc7}, want: "VMOVD X0, R15"},
+		{name: "vmovd_extended_gp_to_x", code: []byte{0xc4, 0xc1, 0x79, 0x6e, 0xcf}, want: "VMOVD R15, X1"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VMOVQInstruction(test.code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(test.code) {
+				t.Fatalf("length = %d, want %d", length, len(test.code))
+			}
+			if instruction.Raw != test.want {
+				t.Fatalf("instruction = %q, want %q", instruction.Raw, test.want)
+			}
+		})
+	}
+}
+
+func encodeX86VEXVMOVDQ(opcode, pp byte, vex3, width64 bool, vector, rm int) []byte {
+	modRM := byte(0xc0 | (vector&7)<<3 | rm&7)
+	if !vex3 {
+		vex1 := byte((1-vector/8)<<7 | 15<<3 | int(pp))
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-vector/8)<<7 | 1<<6 | (1-rm/8)<<5 | 1)
+	vex1 := byte(15<<3 | int(pp))
+	if width64 {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestDecodedX86VMOVDQCompleteVEXRegisterFamily(t *testing.T) {
+	tests := []struct {
+		opcode   byte
+		pp       byte
+		width64  bool
+		op       Op
+		reverse  bool
+		vectorRM bool
+		vex2     bool
+	}{
+		{opcode: 0x7e, pp: 1, op: "VMOVD", vex2: true},
+		{opcode: 0x6e, pp: 1, op: "VMOVD", reverse: true, vex2: true},
+		{opcode: 0x7e, pp: 1, width64: true, op: "VMOVQ"},
+		{opcode: 0xd6, pp: 1, op: "VMOVQ", vectorRM: true, vex2: true},
+		{opcode: 0x6e, pp: 1, width64: true, op: "VMOVQ", reverse: true},
+		{opcode: 0x7e, pp: 2, op: "VMOVQ", reverse: true, vectorRM: true, vex2: true},
+	}
+	count := 0
+	for _, test := range tests {
+		for _, vex3 := range []bool{false, true} {
+			if !vex3 && !test.vex2 {
+				continue
+			}
+			rmLimit := 16
+			if !vex3 {
+				rmLimit = 8
+			}
+			for vector := 0; vector < 16; vector++ {
+				for rm := 0; rm < rmLimit; rm++ {
+					code := encodeX86VEXVMOVDQ(test.opcode, test.pp, vex3, test.width64, vector, rm)
+					got, length, ok, err := decodedX86VMOVQInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					rmName := fmt.Sprintf("R%d", rm)
+					if rm < 8 {
+						rmName = [...]string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}[rm]
+					}
+					if test.vectorRM {
+						rmName = fmt.Sprintf("X%d", rm)
+					}
+					wantArgs := []string{fmt.Sprintf("X%d", vector), rmName}
+					if test.reverse {
+						wantArgs[0], wantArgs[1] = wantArgs[1], wantArgs[0]
+					}
+					if got.Op != test.op || len(got.Args) != 2 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] {
+						t.Fatalf("decode %x = %+v, want %s %s", code, got, test.op, strings.Join(wantArgs, ", "))
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 2048 {
+		t.Fatalf("covered %d VEX VMOVD/VMOVQ register encodings, want 2048", count)
+	}
+}
+
+func TestDecodedX86VMOVDQCompleteGo127EVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "d high x to gp", code: []byte{0x62, 0x61, 0x7d, 0x08, 0x7e, 0xf8}, want: "VMOVD X31, AX"},
+		{name: "d gp to high x", code: []byte{0x62, 0x61, 0x7d, 0x08, 0x6e, 0xf8}, want: "VMOVD AX, X31"},
+		{name: "q high x to gp", code: []byte{0x62, 0x61, 0xfd, 0x08, 0x7e, 0xf8}, want: "VMOVQ X31, AX"},
+		{name: "q x to high x", code: []byte{0x62, 0x91, 0xfd, 0x08, 0xd6, 0xc7}, want: "VMOVQ X0, X31"},
+		{name: "q gp to high x", code: []byte{0x62, 0x61, 0xfd, 0x08, 0x6e, 0xf8}, want: "VMOVQ AX, X31"},
+		{name: "q high x to x alternate", code: []byte{0x62, 0xf1, 0xfe, 0x08, 0x7e, 0xc7}, want: "VMOVQ X7, X0"},
+		{name: "d high x to compressed memory", code: []byte{0x62, 0x61, 0x7d, 0x08, 0x7e, 0x78, 0x7f}, want: "VMOVD X31, 508(AX)"},
+		{name: "q compressed memory to high x", code: []byte{0x62, 0x61, 0xfd, 0x08, 0x6e, 0x78, 0x7f}, want: "VMOVQ 1016(AX), X31"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VMOVQInstruction(test.code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as %+v length=%d ok=%v, want %q", test.code, instruction, length, ok, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VMOVQInstructionRejectsInvalidVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc5, 0xfa, 0x7e}, mode: 64},
+		{name: "vex_l_one", code: []byte{0xc5, 0xfe, 0x7e, 0xc8}, mode: 64},
+		{name: "used_vvvv", code: []byte{0xc5, 0xf2, 0x7e, 0xc8}, mode: 64},
+		{name: "w_one_in_386", code: []byte{0xc4, 0xe1, 0xf9, 0x6e, 0xc8}, mode: 32},
+		{name: "extended_register_in_386", code: []byte{0xc5, 0x7a, 0x7e, 0xc0}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc5, 0xfa, 0x7e, 0x05, 0, 0, 0, 0}, mode: 64},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VMOVQInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VMOVQ-family encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
diff --git a/amd64_raw_vmovw_test.go b/amd64_raw_vmovw_test.go
new file mode 100644
index 000000000..9cc1b2bf4
--- /dev/null
+++ b/amd64_raw_vmovw_test.go
@@ -0,0 +1,390 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Intel AVX512-FP16 section 5.61: EVEX.128.66.MAP5.WIG 6E/7E.
+// The ModRM.reg operand is always X; ModRM.r/m is GP or m16, never X.
+func rawVMOVW(load, wide bool, vector, general int, memory bool) []byte {
+	p0 := byte(0xf5)
+	p0 &^= byte((vector>>3&1)<<7 | (vector>>4&1)<<4 | (general>>3&1)<<5)
+	p1 := byte(0x7d)
+	if wide {
+		p1 |= 0x80
+	}
+	opcode := byte(0x7e)
+	if load {
+		opcode = 0x6e
+	}
+	modRM := byte(0xc0 | (vector&7)<<3 | general&7)
+	if memory {
+		modRM = 0x40 | byte(vector&7)<<3 | byte(general&7)
+	}
+	code := []byte{0x62, p0, p1, 0x08, opcode, modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestRawVMOVWCompleteFormats(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		vectors, generals := 8, 8
+		if mode == 64 {
+			vectors, generals = 32, 16
+		}
+		for _, load := range []bool{false, true} {
+			for _, wide := range []bool{false, true} {
+				for vector := 0; vector < vectors; vector++ {
+					for general := 0; general < generals; general++ {
+						code := rawVMOVW(load, wide, vector, general, false)
+						got, n, ok, err := decodedX86VMOVQInstruction(code, mode)
+						if err != nil || !ok || n != len(code) || got.Op != "VMOVW" || !got.x86Encoded {
+							t.Fatalf("mode %d %x: %+v, n=%d, matched=%v, err=%v", mode, code, got, n, ok, err)
+						}
+						xIndex := 0
+						if load {
+							xIndex = 1
+						}
+						wantGeneral, _ := decodedX86GeneralRegister(general)
+						if got.Args[xIndex].String() != fmt.Sprintf("X%d", vector) || got.Args[1-xIndex].Kind != OpReg ||
+							got.Args[1-xIndex].Reg != wantGeneral {
+							t.Fatalf("%x: wrong operands %+v", code, got.Args)
+						}
+					}
+				}
+				code := rawVMOVW(load, wide, 1, 0, true)
+				got, _, ok, err := decodedX86VMOVQInstruction(code, mode)
+				if err != nil || !ok {
+					t.Fatalf("%x: matched=%v, err=%v", code, ok, err)
+				}
+				memoryIndex := 1
+				if load {
+					memoryIndex = 0
+				}
+				if got.Args[memoryIndex].String() != "2(AX)" {
+					t.Fatalf("%x: expected two-byte displacement scaling, got %+v", code, got.Args)
+				}
+			}
+		}
+	}
+}
+
+func TestRawVMOVWInvalidFormats(t *testing.T) {
+	for _, change := range []struct {
+		index int
+		bits  byte
+	}{
+		{2, 4}, {2, 8}, {3, 8}, {3, 1}, {3, 0x80}, {3, 0x10}, {3, 0x20}, {3, 0x40}, {1, 0x40},
+	} {
+		code := rawVMOVW(true, false, 0, 1, false)
+		code[change.index] ^= change.bits
+		if _, err := decodeX86RawDirectiveGroup(code, 64, 0, "invalid VMOVW", map[string]bool{}); err == nil {
+			t.Fatalf("accepted reserved VMOVW %x", code)
+		}
+	}
+	for _, code := range [][]byte{rawVMOVW(true, false, 8, 0, false), rawVMOVW(false, true, 0, 8, false)} {
+		if _, err := decodeX86RawDirectiveGroup(code, 32, 0, "386 high VMOVW", map[string]bool{}); err == nil {
+			t.Fatalf("accepted 386 extended register %x", code)
+		}
+	}
+}
+
+func TestRawVMOVWLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	type form struct {
+		name         string
+		code         []byte
+		load, memory bool
+	}
+	var forms []form
+	var complete []byte
+	for _, load := range []bool{false, true} {
+		for _, wide := range []bool{false, true} {
+			for _, memory := range []bool{false, true} {
+				code := rawVMOVW(load, wide, 1, 0, memory)
+				forms = append(forms, form{fmt.Sprintf("rawWordForm%d", len(forms)), code, load, memory})
+				complete = append(complete, code...)
+			}
+		}
+	}
+	var source strings.Builder
+	// Retain the original eight-form, sequential function. Independent
+	// one-form functions prevent an unrelated transfer from satisfying a
+	// width, native-memory effect or GP-zero-extension assertion.
+	source.WriteString("TEXT rawWordMove(SB),4,$0-0\n")
+	source.WriteString(x86RawDisplacementDirectives(complete))
+	source.WriteString("RET\n")
+	for _, f := range forms {
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n", f.name)
+		source.WriteString(x86RawDisplacementDirectives(f.code))
+		source.WriteString("RET\n")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		// BYTE acceptance alone is not an encoding oracle: require the exact
+		// contiguous stock-Go object text, including the original final RET.
+		x86HandoffOriginalBytes(t, arch, append(append([]byte(nil), complete...), 0xc3))
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			// Keep the original unknown GP/X/m16 inputs as format-only
+			// objects and public Context controls. Initialized declarations
+			// and executed guard-page checks have independent test owners.
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			ir = strings.ReplaceAll(ir, "@InstructionFormat0(", "@rawWordMove(")
+			for index, f := range forms {
+				ir = strings.ReplaceAll(ir, fmt.Sprintf("@InstructionFormat%d(", index+1), "@"+f.name+"(")
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := parseIRModuleInContext(ctx, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := rawVMOVWFunctionEffects(module, "rawWordMove", 2, 2, 2); err != nil {
+				t.Fatal(err)
+			}
+			mode := 64
+			if target.arch == "386" {
+				mode = 32
+			}
+			for _, f := range forms {
+				t.Run(f.name, func(t *testing.T) {
+					ins, size, known, err := decodedX86VMOVQInstruction(f.code, mode)
+					if err != nil || !known || size != len(f.code) || ins.Op != "VMOVW" || !ins.x86Encoded {
+						t.Fatalf("raw-only decoder receipt changed: %+v size=%d known=%t err=%v", ins, size, known, err)
+					}
+					properties, known, err := x86GPSIMDTransferProperties(ins, target.arch)
+					if err != nil || !known || properties.bits != 16 || !properties.spec.rawOnly || properties.mmx ||
+						properties.destinationX != f.load || properties.sourceX == f.load || (properties.memory >= 0) != f.memory ||
+						properties.memoryWrite != (f.memory && !f.load) {
+						t.Fatalf("16-bit raw-only transfer role changed: %+v known=%t err=%v", properties, known, err)
+					}
+					loads, stores, extensions := 0, 0, 0
+					if f.memory {
+						if f.load {
+							loads = 1
+						} else {
+							stores = 1
+						}
+					} else if !f.load {
+						extensions = 1
+					}
+					if err := rawVMOVWFunctionEffects(module, f.name, loads, stores, extensions); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+			rawVMOVWStoreCheckerMutations(t, ctx, module)
+			compileLLVMToObject(t, llc, target.triple, "raw-vmovw.ll", "raw-vmovw.o", ir)
+		})
+	}
+}
+
+func rawVMOVWFunctionEffects(module llvm.Module, name string, wantLoads, wantStores, wantExtensions int) error {
+	function := module.NamedFunction(name)
+	if function.IsNil() {
+		return fmt.Errorf("missing raw VMOVW function %s", name)
+	}
+	feature := false
+	for _, attribute := range function.GetFunctionAttributes() {
+		if attribute.IsString() && attribute.GetStringKind() == "target-features" {
+			for _, item := range strings.Split(attribute.GetStringValue(), ",") {
+				feature = feature || item == "+avx512fp16"
+			}
+		}
+	}
+	if !feature {
+		return fmt.Errorf("%s lost its private raw VMOVW ISA attribute", name)
+	}
+	loads, stores, extensions := 0, 0, 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+			if !ins.IsAZExtInst().IsNil() && ins.Operand(0).Type().TypeKind() == llvm.IntegerTypeKind &&
+				ins.Operand(0).Type().IntTypeWidth() == 16 && ins.Type().IntTypeWidth() == 64 {
+				extensions++
+			}
+			var typ llvm.Type
+			var pointer llvm.Value
+			load := !ins.IsALoadInst().IsNil()
+			if load {
+				typ, pointer = ins.Type(), ins.Operand(0)
+			} else if !ins.IsAStoreInst().IsNil() {
+				typ, pointer = ins.Operand(0).Type(), ins.Operand(1)
+			} else {
+				continue
+			}
+			if x86GPSIMDStoreTargetsBackingAlloca(pointer) {
+				continue // Virtual register banks are not original native memory.
+			}
+			if typ.TypeKind() != llvm.IntegerTypeKind || typ.IntTypeWidth() != 16 || !ins.IsVolatile() ||
+				ins.Alignment() != 1 || pointer.IsAIntToPtrInst().IsNil() {
+				return fmt.Errorf("%s lost exact native m16 type/effect/address: %s", name, ins.String())
+			}
+			if load {
+				loads++
+			} else {
+				stores++
+			}
+		}
+	}
+	if loads != wantLoads || stores != wantStores || extensions != wantExtensions {
+		return fmt.Errorf("%s m16 loads/stores/GP zero-extensions=%d/%d/%d, want=%d/%d/%d",
+			name, loads, stores, extensions, wantLoads, wantStores, wantExtensions)
+	}
+	return nil
+}
+
+func rawVMOVWStoreCheckerMutations(t *testing.T, ctx llvm.Context, module llvm.Module) {
+	t.Helper()
+	function := module.NamedFunction("rawWordForm1") // X1 -> m16, W=0.
+	var store llvm.Value
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+			if !ins.IsAStoreInst().IsNil() && !x86GPSIMDStoreTargetsBackingAlloca(ins.Operand(1)) {
+				if !store.IsNil() {
+					t.Fatal("mutation fixture has multiple native stores")
+				}
+				store = ins
+			}
+		}
+	}
+	if store.IsNil() {
+		t.Fatal("mutation fixture has no native store")
+	}
+	original := function.String()
+	for _, mutation := range []struct{ name, replacement string }{
+		{"volatility", strings.Replace(store.String(), "store volatile", "store", 1)},
+		{"width", "store volatile i32 1" + store.String()[strings.IndexByte(store.String(), ','):]},
+		{"alignment", strings.Replace(store.String(), "align 1", "align 2", 1)},
+		{"missing", "; removed original native m16 store"},
+	} {
+		t.Run("checker-"+mutation.name, func(t *testing.T) {
+			if strings.Count(original, store.String()) != 1 || strings.Count(module.String(), original) != 1 {
+				t.Fatal("mutation does not bind the exact one-form function/store")
+			}
+			changed := strings.Replace(module.String(), original, strings.Replace(original, store.String(), mutation.replacement, 1), 1)
+			candidate, err := parseIRModuleInContext(ctx, changed)
+			if !candidate.IsNil() {
+				defer candidate.Dispose()
+			}
+			if err != nil {
+				t.Fatal("mutation must remain valid LLVM IR", err)
+			}
+			if err := llvm.VerifyModule(candidate, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("mutation must remain a valid LLVM module", err)
+			}
+			if err := rawVMOVWFunctionEffects(candidate, "rawWordForm1", 0, 1, 0); err == nil {
+				t.Fatal("native m16 mutation escaped the per-function checker")
+			}
+		})
+	}
+}
+
+func TestRawVMOVWPortableRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT wordMove(SB),4,$0-24\nMOVQ input+0(FP), AX\nMOVQ out+8(FP), SI\nMOVQ vector+16(FP), DI\nVMOVDQU64 (DI), Z0\nMOVQ $-1, CX\n")
+	for _, code := range [][]byte{
+		{0x62, 0xf5, 0x7d, 0x08, 0x6e, 0x00}, // m16 -> X0; no wider memory access.
+		{0x62, 0xf5, 0xfd, 0x08, 0x7e, 0xc1}, // X0 -> CX; WIG, zero-extend.
+	} {
+		for _, b := range code {
+			fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+		}
+	}
+	source.WriteString("MOVQ CX, (SI)\nVMOVDQU64 Z0, 8(SI)\nMOVQ $-1, CX\n")
+	for _, code := range [][]byte{
+		{0x62, 0xf5, 0x7d, 0x08, 0x6e, 0xc1}, // CX -> X0, truncate and clear all upper lanes.
+		{0x62, 0xf5, 0xfd, 0x08, 0x7e, 0x00}, // X0 -> m16; exactly two bytes.
+	} {
+		for _, b := range code {
+			fmt.Fprintf(&source, "BYTE $0x%02x\n", b)
+		}
+	}
+	source.WriteString("VMOVDQU64 Z0, 72(SI)\nRET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: testTargetTriple(runtime.GOOS, runtime.GOARCH),
+		Sigs: map[string]FuncSig{"wordMove": {
+			Name: "wordMove", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Attrs: "nounwind",
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + x86TestGuardPagesC + `
+extern void wordMove(void *, void *, const void *);
+int main(void) {
+    if (setup_guard()) return 1;
+    uint64_t output[17], vector[8];
+    memset(vector, 0xff, sizeof(vector));
+    for (int offset = 2; offset <= 3; offset++) {
+        unsigned char *pointer = guard + page - offset;
+        uint16_t input = 0x8123;
+        memcpy(pointer, &input, 2);
+        wordMove(pointer, output, vector);
+        if (output[0] != input || output[1] != input || output[9] != 0xffff) return 2;
+        for (int lane = 2; lane < 9; lane++) if (output[lane] != 0) return 3;
+        for (int lane = 10; lane < 17; lane++) if (output[lane] != 0) return 4;
+        memcpy(&input, pointer, 2);
+        if (input != 0xffff) return 5;
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "vmovw_portable", ir, mainC)
+}
+
+func TestRawVMOVWRIPLiteralAndNamedRejection(t *testing.T) {
+	code := []byte{0x62, 0xf5, 0x7d, 8, 0x6e, 5, 1, 0, 0, 0, 0xc3, 0x23, 0x81}
+	got, err := decodeX86RawDirectiveGroup(code, 64, 0, "word RIP literal", map[string]bool{})
+	if err != nil || len(got) != 2 || !got[0].x86RIPLiteral || got[0].Args[0].Kind != OpImm || got[0].Args[0].Imm != 0x8123 {
+		t.Fatalf("literal: %+v, err=%v", got, err)
+	}
+	if _, err := decodeX86RawDirectiveGroup(code[:len(code)-1], 64, 0, "truncated word pool", map[string]bool{}); err == nil {
+		t.Fatal("accepted truncated word pool")
+	}
+	const source = "TEXT namedWordMove(SB),4,$0-0\nVMOVW X0, AX\nRET\n"
+	for _, arch := range []string{"amd64", "386"} {
+		goAssemblerOracleOutput(t, arch, source, "", false)
+		t.Run(arch+"/named-three-APIs", func(t *testing.T) {
+			x86RequireZeroMaskAPIOutcome(t, arch, strings.Replace(source, "namedWordMove", "f", 1), false)
+		})
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"namedWordMove": {Name: "namedWordMove", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted VMOVW absent from Go's named assembler table")
+	}
+}
diff --git a/amd64_raw_vnni_test.go b/amd64_raw_vnni_test.go
new file mode 100644
index 000000000..29b03b3db
--- /dev/null
+++ b/amd64_raw_vnni_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import "testing"
+
+func TestDecodedX86VNNIInstructionCompleteVEXFamily(t *testing.T) {
+	for _, test := range []struct {
+		opcode byte
+		op     Op
+	}{
+		{0x50, "VPDPBUSD"},
+		{0x51, "VPDPBUSDS"},
+		{0x52, "VPDPWSSD"},
+		{0x53, "VPDPWSSDS"},
+	} {
+		t.Run(string(test.op), func(t *testing.T) {
+			code := []byte{0xc4, 0xe2, 0x71, test.opcode, 0xc2}
+			instruction, length, ok, err := decodedX86VNNIInstruction(code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(code) {
+				t.Fatalf("length = %d, want %d", length, len(code))
+			}
+			want := string(test.op) + " X2, X1, X0"
+			if instruction.Op != test.op || instruction.Raw != want {
+				t.Fatalf("instruction = %#v, want %q", instruction, want)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{
+			name: "y_extended_registers",
+			code: []byte{0xc4, 0x42, 0x15, 0x50, 0xdc},
+			mode: 64,
+			want: "VPDPBUSD Y12, Y13, Y11",
+		},
+		{
+			name: "x_memory_sib_disp8",
+			code: []byte{0xc4, 0x62, 0x11, 0x50, 0x5c, 0x88, 0x20},
+			mode: 64,
+			want: "VPDPBUSD 32(AX)(CX*4), X13, X11",
+		},
+		{
+			name: "y_memory_negative_disp8",
+			code: []byte{0xc4, 0x62, 0x65, 0x51, 0x64, 0x35, 0xef},
+			mode: 64,
+			want: "VPDPBUSDS -17(BP)(SI*1), Y3, Y12",
+		},
+		{
+			name: "x_memory_extended_address",
+			code: []byte{0xc4, 0x82, 0x39, 0x52, 0x74, 0x7e, 0x07},
+			mode: 64,
+			want: "VPDPWSSD 7(R14)(R15*2), X8, X6",
+		},
+		{
+			name: "y_386_memory",
+			code: []byte{0xc4, 0xe2, 0x65, 0x53, 0x64, 0x35, 0xef},
+			mode: 32,
+			want: "VPDPWSSDS -17(BP)(SI*1), Y3, Y4",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VNNIInstruction(test.code, test.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode = (%#v, %d, %v), want %q", instruction, length, ok, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VNNIInstructionRejectsInvalidVEXForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc4, 0xe2, 0x71, 0x50}, mode: 64},
+		{name: "vex_pp_zero", code: []byte{0xc4, 0xe2, 0x70, 0x50, 0xc2}, mode: 64},
+		{name: "vex_w_one", code: []byte{0xc4, 0xe2, 0xf1, 0x50, 0xc2}, mode: 64},
+		{name: "address_override", code: []byte{0x67, 0xc4, 0xe2, 0x71, 0x50, 0xc2}, mode: 64},
+		{name: "extended_register_in_386", code: []byte{0xc4, 0x42, 0x15, 0x50, 0xdc}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc4, 0xe2, 0x71, 0x50, 0x05, 0, 0, 0, 0}, mode: 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VNNIInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VNNI encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVNNIReportedSequence(t *testing.T) {
+	code := []byte{
+		0xc4, 0x42, 0x15, 0x50, 0xdc,
+		0xc4, 0x62, 0x7d, 0x50, 0xc7,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "go-pherence VEX VNNI sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 {
+		t.Fatalf("decoded %d instructions, want 2: %#v", len(decoded), decoded)
+	}
+	for _, instruction := range decoded {
+		if instruction.Op != "VPDPBUSD" {
+			t.Fatalf("decoded op = %s, want VPDPBUSD", instruction.Op)
+		}
+	}
+}
diff --git a/amd64_raw_vpadd_test.go b/amd64_raw_vpadd_test.go
new file mode 100644
index 000000000..75be16de6
--- /dev/null
+++ b/amd64_raw_vpadd_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86VEXPackedIntegerArithmetic(opcode byte, vex3, width256, widthIgnored bool, destination, source1, source2 int) []byte {
+	l := byte(0)
+	if width256 {
+		l = 1
+	}
+	modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+	if !vex3 {
+		vex1 := byte((1-destination/8)<<7 | ((^source1)&15)<<3 | int(l)<<2 | 1)
+		return []byte{0xc5, vex1, opcode, modRM}
+	}
+	vex0 := byte((1-destination/8)<<7 | 1<<6 | (1-source2/8)<<5 | 1)
+	vex1 := byte(((^source1)&15)<<3 | int(l)<<2 | 1)
+	if widthIgnored {
+		vex1 |= 0x80
+	}
+	return []byte{0xc4, vex0, vex1, opcode, modRM}
+}
+
+func TestDecodedX86PackedIntegerAddCompleteVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, properties := range decodedX86PackedIntegerArithmeticOps {
+		if !strings.HasPrefix(string(properties.op), "VPADD") {
+			continue
+		}
+		for _, vex3 := range []bool{false, true} {
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				for _, widthIgnored := range []bool{false, true} {
+					if !vex3 && widthIgnored {
+						continue
+					}
+					source2Limit := 16
+					if !vex3 {
+						source2Limit = 8
+					}
+					for destination := 0; destination < 16; destination++ {
+						for source1 := 0; source1 < 16; source1++ {
+							for source2 := 0; source2 < source2Limit; source2++ {
+								code := encodeX86VEXPackedIntegerArithmetic(opcode, vex3, width256, widthIgnored, destination, source1, source2)
+								got, length, ok, err := decodedX86PackedIntegerArithmeticInstruction(code, 64)
+								if err != nil || !ok || length != len(code) {
+									t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+								}
+								wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+								if got.Op != properties.op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+									t.Fatalf("decode %x = %+v, want %s %s", code, got, properties.op, strings.Join(wantArgs, ", "))
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 163840 {
+		t.Fatalf("covered %d VEX packed integer add register encodings, want 163840", count)
+	}
+}
+
+func TestDecodedX86PackedIntegerSubtractCompleteVEXRegisterFamily(t *testing.T) {
+	subtractOps := map[byte]struct {
+		op        Op
+		laneBytes int
+	}{
+		0xf8: {op: "VPSUBB", laneBytes: 1},
+		0xf9: {op: "VPSUBW", laneBytes: 2},
+		0xfa: {op: "VPSUBD", laneBytes: 4},
+		0xfb: {op: "VPSUBQ", laneBytes: 8},
+		0xe8: {op: "VPSUBSB", laneBytes: 1},
+		0xe9: {op: "VPSUBSW", laneBytes: 2},
+		0xd8: {op: "VPSUBUSB", laneBytes: 1},
+		0xd9: {op: "VPSUBUSW", laneBytes: 2},
+	}
+	count := 0
+	for opcode, properties := range subtractOps {
+		for _, vex3 := range []bool{false, true} {
+			for _, width256 := range []bool{false, true} {
+				prefix := "X"
+				if width256 {
+					prefix = "Y"
+				}
+				for _, widthIgnored := range []bool{false, true} {
+					if !vex3 && widthIgnored {
+						continue
+					}
+					source2Limit := 16
+					if !vex3 {
+						source2Limit = 8
+					}
+					for destination := 0; destination < 16; destination++ {
+						for source1 := 0; source1 < 16; source1++ {
+							for source2 := 0; source2 < source2Limit; source2++ {
+								code := encodeX86VEXPackedIntegerArithmetic(opcode, vex3, width256, widthIgnored, destination, source1, source2)
+								got, length, ok, err := decodedX86PackedIntegerArithmeticInstruction(code, 64)
+								if err != nil || !ok || length != len(code) {
+									t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+								}
+								wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), fmt.Sprintf("%s%d", prefix, destination)}
+								if got.Op != properties.op || len(got.Args) != 3 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] {
+									t.Fatalf("decode %x = %+v, want %s %s", code, got, properties.op, strings.Join(wantArgs, ", "))
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 163840 {
+		t.Fatalf("covered %d VEX packed integer subtract register encodings, want 163840", count)
+	}
+}
+
+func TestDecodedX86PackedIntegerArithmeticCompleteEVEXRegisterFamily(t *testing.T) {
+	count := 0
+	for opcode, properties := range decodedX86PackedIntegerArithmeticOps {
+		for vectorBits := byte(0); vectorBits < 3; vectorBits++ {
+			prefix := [...]string{"X", "Y", "Z"}[vectorBits]
+			for destination := 0; destination < 32; destination++ {
+				for source1 := 0; source1 < 32; source1++ {
+					for source2 := 0; source2 < 32; source2++ {
+						p0 := byte((1-(destination>>3)&1)<<7 | (1-(source2>>4)&1)<<6 | (1-(source2>>3)&1)<<5 | (1-(destination>>4)&1)<<4 | 1)
+						p1 := byte((^source1&15)<<3 | 1<<2 | 1)
+						if properties.laneBytes == 8 {
+							p1 |= 0x80
+						}
+						p2 := byte(int(vectorBits)<<5 | (^source1>>4&1)<<3 | 1)
+						modRM := byte(0xc0 | (destination&7)<<3 | source2&7)
+						code := []byte{0x62, p0, p1, p2, opcode, modRM}
+						got, length, ok, err := decodedX86PackedIntegerArithmeticInstruction(code, 64)
+						if err != nil || !ok || length != len(code) {
+							t.Fatalf("decode %x returned %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+						}
+						wantArgs := []string{fmt.Sprintf("%s%d", prefix, source2), fmt.Sprintf("%s%d", prefix, source1), "K1", fmt.Sprintf("%s%d", prefix, destination)}
+						if got.Op != properties.op || len(got.Args) != 4 || got.Args[0].String() != wantArgs[0] || got.Args[1].String() != wantArgs[1] || got.Args[2].String() != wantArgs[2] || got.Args[3].String() != wantArgs[3] {
+							t.Fatalf("decode %x = %+v, want %s %s", code, got, properties.op, strings.Join(wantArgs, ", "))
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 1572864 {
+		t.Fatalf("covered %d EVEX packed integer arithmetic encodings, want 1572864", count)
+	}
+}
+
+func TestTranslateRawVPSUBDWeaviateRegression(t *testing.T) {
+	const source = `TEXT rawPackedSubtract(SB), $0-0
+	LONG $0xd5faedc5
+	RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawPackedSubtract": {Name: "rawPackedSubtract", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "sub <8 x i32>") {
+		t.Fatalf("raw VPSUBD lowering omitted vector subtraction:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "amd64-raw-packed-subtract.ll", "amd64-raw-packed-subtract.o", ir)
+}
+
+func TestDecodedX86PackedIntegerArithmeticCompleteGo127Family(t *testing.T) {
+	// Go 1.27 uses _yvandnpd for all sixteen VPADD/VPSUB variants. These LLVM 22
+	// encodings cover every opcode plus VEX/EVEX X/Y/Z, high registers,
+	// memory, masking, zeroing, D/Q broadcast, and compressed disp8.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "vex byte x high", code: []byte{0xc5, 0x79, 0xfc, 0xc1}, want: "VPADDB X1, X0, X8"},
+		{name: "vex qword y high memory", code: []byte{0xc4, 0x41, 0x6d, 0xd4, 0x4c, 0x24, 0x20}, want: "VPADDQ 32(R12), Y2, Y9"},
+		{name: "byte x high masked", code: []byte{0x62, 0xa1, 0x55, 0x01, 0xfc, 0xf4}, want: "VPADDB X20, X21, K1, X22"},
+		{name: "word y memory zeroing", code: []byte{0x62, 0xd1, 0x75, 0xaa, 0xfd, 0x50, 0x03}, want: "VPADDW.Z 96(R8), Y1, K2, Y2"},
+		{name: "dword reported minio", code: []byte{0x62, 0x51, 0x45, 0x48, 0xfe, 0xc4}, want: "VPADDD Z12, Z7, Z8"},
+		{name: "qword z broadcast zeroing", code: []byte{0x62, 0xf1, 0xf5, 0xdb, 0xd4, 0x50, 0x7f}, want: "VPADDQ.BCST.Z 1016(AX), Z1, K3, Z2"},
+		{name: "signed byte z high", code: []byte{0x62, 0x31, 0x7d, 0x40, 0xec, 0xc9}, want: "VPADDSB Z17, Z16, Z9"},
+		{name: "signed word x high memory masked", code: []byte{0x62, 0x41, 0x3d, 0x04, 0xed, 0x4c, 0x24, 0x02}, want: "VPADDSW 32(R12), X24, K4, X25"},
+		{name: "unsigned byte y high masked", code: []byte{0x62, 0xa1, 0x55, 0x21, 0xdc, 0xf4}, want: "VPADDUSB Y20, Y21, K1, Y22"},
+		{name: "unsigned word z memory zeroing", code: []byte{0x62, 0xf1, 0x75, 0xcb, 0xdd, 0x50, 0x7f}, want: "VPADDUSW.Z 8128(AX), Z1, K3, Z2"},
+		{name: "subtract dword weaviate", code: []byte{0xc5, 0xed, 0xfa, 0xd5}, want: "VPSUBD Y5, Y2, Y2"},
+		{name: "subtract qword broadcast zeroing", code: []byte{0x62, 0xf1, 0xf5, 0xdb, 0xfb, 0x50, 0x7f}, want: "VPSUBQ.BCST.Z 1016(AX), Z1, K3, Z2"},
+		{name: "subtract unsigned word z memory zeroing", code: []byte{0x62, 0xf1, 0x75, 0xcb, 0xd9, 0x50, 0x7f}, want: "VPSUBUSW.Z 8128(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86PackedIntegerArithmeticInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("VPADD encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPADDD(t *testing.T) {
+	code := []byte{0x62, 0x51, 0x45, 0x48, 0xfe, 0xc4}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPADDD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPADDD" || !strings.HasPrefix(decoded[0].Raw, "VPADDD Z12, Z7, Z8 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpermd_test.go b/amd64_raw_vpermd_test.go
new file mode 100644
index 000000000..fd64e92c0
--- /dev/null
+++ b/amd64_raw_vpermd_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeX86RawEVEXVariableDwordPermute(opcode, vectorBits, mask int, zeroing, broadcast, memory bool) []byte {
+	p2 := byte(vectorBits<<5 | 0x08 | mask)
+	if zeroing {
+		p2 |= 0x80
+	}
+	if broadcast {
+		p2 |= 0x10
+	}
+	modRM := byte(0xd3) // data register 3, destination register 2.
+	if memory {
+		modRM = 0x50 // disp8(AX) data, destination register 2.
+	}
+	code := []byte{0x62, 0xf2, 0x75, p2, byte(opcode), modRM}
+	if memory {
+		code = append(code, 1)
+	}
+	return code
+}
+
+func TestDecodedX86VariableDwordPermuteInstructionCompleteVEXFamily(t *testing.T) {
+	for _, test := range []struct {
+		opcode byte
+		op     Op
+	}{
+		{0x36, "VPERMD"},
+		{0x16, "VPERMPS"},
+	} {
+		t.Run(string(test.op), func(t *testing.T) {
+			code := []byte{0xc4, 0xe2, 0x25, test.opcode, 0xd6}
+			instruction, length, ok, err := decodedX86VariableDwordPermuteInstruction(code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(code) {
+				t.Fatalf("length = %d, want %d", length, len(code))
+			}
+			want := string(test.op) + " Y6, Y11, Y2"
+			if instruction.Op != test.op || instruction.Raw != want {
+				t.Fatalf("instruction = %#v, want %q", instruction, want)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{
+			name: "extended_registers",
+			code: []byte{0xc4, 0x42, 0x05, 0x36, 0xdb},
+			mode: 64,
+			want: "VPERMD Y11, Y15, Y11",
+		},
+		{
+			name: "memory_sib_disp8",
+			code: []byte{0xc4, 0x62, 0x15, 0x36, 0x5c, 0x88, 0x20},
+			mode: 64,
+			want: "VPERMD 32(AX)(CX*4), Y13, Y11",
+		},
+		{
+			name: "memory_negative_disp8",
+			code: []byte{0xc4, 0x62, 0x65, 0x16, 0x64, 0x35, 0xef},
+			mode: 64,
+			want: "VPERMPS -17(BP)(SI*1), Y3, Y12",
+		},
+		{
+			name: "386_registers",
+			code: []byte{0xc4, 0xe2, 0x65, 0x36, 0xe5},
+			mode: 32,
+			want: "VPERMD Y5, Y3, Y4",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VariableDwordPermuteInstruction(test.code, test.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode = (%#v, %d, %v), want %q", instruction, length, ok, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawEVEXVPERMDSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VPERMD Z2, Z0, Z3.
+	code := []byte{0x62, 0xf2, 0x7d, 0x48, 0x36, 0xda, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "cumMinInt32 AVX512 VPERMD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPERMD" ||
+		decoded[0].Args[0].Reg != "Z2" || decoded[0].Args[1].Reg != "Z0" ||
+		decoded[0].Args[2].Reg != "Z3" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawEVEXVariableDwordPermuteCompleteGoForms(t *testing.T) {
+	for _, family := range []struct {
+		opcode int
+		op     Op
+	}{
+		{0x36, "VPERMD"},
+		{0x16, "VPERMPS"},
+	} {
+		for vectorIndex, vector := range []string{"Y", "Z"} {
+			vectorBits := vectorIndex + 1
+			for _, variant := range []struct {
+				name      string
+				mask      int
+				zeroing   bool
+				broadcast bool
+				memory    bool
+			}{
+				{name: "register"},
+				{name: "masked register", mask: 3},
+				{name: "memory", memory: true},
+				{name: "zeroing memory", mask: 7, zeroing: true, memory: true},
+				{name: "broadcast memory", broadcast: true, memory: true},
+				{name: "broadcast zeroing memory", mask: 1, zeroing: true, broadcast: true, memory: true},
+			} {
+				name := fmt.Sprintf("%s/%s/%s", family.op, vector, variant.name)
+				t.Run(name, func(t *testing.T) {
+					code := encodeX86RawEVEXVariableDwordPermute(family.opcode, vectorBits, variant.mask, variant.zeroing, variant.broadcast, variant.memory)
+					got, length, ok, err := decodedX86EVEXVariableDwordPermuteInstruction(code, 64)
+					if err != nil || !ok || length != len(code) {
+						t.Fatalf("decode %x = %+v, length=%d, ok=%v, err=%v", code, got, length, ok, err)
+					}
+					wantOp := family.op
+					if variant.broadcast {
+						wantOp += ".BCST"
+					}
+					if variant.zeroing {
+						wantOp += ".Z"
+					}
+					if got.Op != wantOp || got.Args[1].String() != vector+"1" ||
+						got.Args[len(got.Args)-1].String() != vector+"2" ||
+						!variant.memory && got.Args[0].String() != vector+"3" ||
+						len(got.Args) != 3+map[bool]int{true: 1}[variant.mask != 0] {
+						t.Fatalf("decode %x = %+v, want %s", code, got, wantOp)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXVariableDwordPermuteRIPLiteral(t *testing.T) {
+	for _, family := range []struct {
+		opcode int
+		op     Op
+	}{
+		{0x36, "VPERMD"},
+		{0x16, "VPERMPS"},
+	} {
+		for vectorBits := 1; vectorBits <= 2; vectorBits++ {
+			for _, broadcast := range []bool{false, true} {
+				code := encodeX86RawEVEXVariableDwordPermute(family.opcode, vectorBits, 1, false, broadcast, false)
+				code[5] = 0x15 // RIP-relative first source.
+				code = append(code, 1, 0, 0, 0, 0xc3)
+				literalWidth := 16 << vectorBits
+				if broadcast {
+					literalWidth = 4
+				}
+				for index := 0; index < literalWidth; index++ {
+					code = append(code, byte(index+1))
+				}
+				name := fmt.Sprintf("%s/width%d/broadcast%t", family.op, vectorBits, broadcast)
+				t.Run(name, func(t *testing.T) {
+					got, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if len(got) != 2 || !got[0].x86RIPLiteral ||
+						len(got[0].x86RIPLiteralData) != literalWidth {
+						t.Fatalf("decode %x = %+v", code, got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXVariableDwordPermuteRejectsInvalidForms(t *testing.T) {
+	base := encodeX86RawEVEXVariableDwordPermute(0x36, 2, 0, false, false, false)
+	for _, mutate := range []func([]byte){
+		func(code []byte) { code[2] |= 0x80 },  // Go's EVEX.W is zero
+		func(code []byte) { code[3] &^= 0x60 }, // no X-width EVEX form
+		func(code []byte) { code[3] |= 0x80 },  // zeroing without mask
+		func(code []byte) { code[3] |= 0x10 },  // broadcast requires memory
+	} {
+		code := append([]byte(nil), base...)
+		mutate(code)
+		if _, _, ok, err := decodedX86EVEXVariableDwordPermuteInstruction(code, 64); !ok || err == nil {
+			t.Fatalf("invalid encoding %x returned ok=%v err=%v", code, ok, err)
+		}
+	}
+	if _, _, ok, err := decodedX86EVEXVariableDwordPermuteInstruction(
+		encodeX86RawEVEXVariableDwordPermute(0x16, 2, 1, false, false, false), 32,
+	); !ok || err == nil {
+		t.Fatalf("accepted 386 masked form: ok=%v err=%v", ok, err)
+	}
+}
+
+func TestTranslateX86RawEVEXVariableDwordPermuteLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch string
+		triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT rawVariableDwordPermute(SB),$0-0\n")
+			for _, opcode := range []int{0x36, 0x16} {
+				for _, vectorBits := range []int{1, 2} {
+					mask := 1
+					if target.goarch == "386" {
+						mask = 0
+					}
+					for _, memory := range []bool{false, true} {
+						code := encodeX86RawEVEXVariableDwordPermute(opcode, vectorBits, mask, false, false, memory)
+						for _, value := range code {
+							fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+						}
+					}
+				}
+			}
+			source.WriteString("\tRET\n")
+			requireX86GoAssemblerResult(t, target.goarch, source.String(), true)
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.goarch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "raw-vpermd.ll", "raw-vpermd.o", ir)
+		})
+	}
+}
+
+func TestDecodedX86VariableDwordPermuteInstructionRejectsInvalidVEXForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc4, 0xe2, 0x25, 0x36}, mode: 64},
+		{name: "vex_l_zero", code: []byte{0xc4, 0xe2, 0x21, 0x36, 0xd6}, mode: 64},
+		{name: "vex_pp_zero", code: []byte{0xc4, 0xe2, 0x24, 0x36, 0xd6}, mode: 64},
+		{name: "vex_w_one", code: []byte{0xc4, 0xe2, 0xa5, 0x36, 0xd6}, mode: 64},
+		{name: "address_override", code: []byte{0x67, 0xc4, 0xe2, 0x25, 0x36, 0xd6}, mode: 64},
+		{name: "extended_register_in_386", code: []byte{0xc4, 0x42, 0x05, 0x36, 0xdb}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc4, 0xe2, 0x25, 0x36, 0x05, 0, 0, 0, 0}, mode: 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VariableDwordPermuteInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VPERMD/VPERMPS encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVPERMDReportedSequence(t *testing.T) {
+	code := []byte{
+		0xc4, 0xe2, 0x25, 0x36, 0xd6,
+		0xc4, 0xe2, 0x7d, 0x36, 0xd6,
+		0xc4, 0xe2, 0x35, 0x36, 0xd6,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "go-pherence VEX VPERMD sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 3 {
+		t.Fatalf("decoded %d instructions, want 3: %#v", len(decoded), decoded)
+	}
+	for _, instruction := range decoded {
+		if instruction.Op != "VPERMD" {
+			t.Fatalf("decoded op = %s, want VPERMD", instruction.Op)
+		}
+	}
+}
diff --git a/amd64_raw_vpermi2_test.go b/amd64_raw_vpermi2_test.go
new file mode 100644
index 000000000..53087be30
--- /dev/null
+++ b/amd64_raw_vpermi2_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86VPERMI2CompleteGo127Family(t *testing.T) {
+	// Go 1.27 shares _yvblendmpd across VPERMI2B/W/D/Q/PS/PD. These
+	// LLVM-verified bytes cover all six opcodes, X/Y/Z widths, high registers,
+	// memory, masking, zeroing, broadcast, and compressed disp8 scaling.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "b x high masked", code: []byte{0x62, 0xa2, 0x55, 0x01, 0x75, 0xf4}, want: "VPERMI2B X20, X21, K1, X22"},
+		{name: "w y memory zeroing", code: []byte{0x62, 0xd2, 0xf5, 0xaa, 0x75, 0x50, 0x03}, want: "VPERMI2W.Z 96(R8), Y1, K2, Y2"},
+		{name: "d z high", code: []byte{0x62, 0x32, 0x7d, 0x40, 0x76, 0xc9}, want: "VPERMI2D Z17, Z16, Z9"},
+		{name: "d z broadcast zeroing", code: []byte{0x62, 0xf2, 0x75, 0xdb, 0x76, 0x50, 0x7f}, want: "VPERMI2D.BCST.Z 508(AX), Z1, K3, Z2"},
+		{name: "q reported minio", code: []byte{0x62, 0x22, 0xb5, 0x48, 0x76, 0xf2}, want: "VPERMI2Q Z18, Z9, Z30"},
+		{name: "q y high memory masked", code: []byte{0x62, 0x42, 0xbd, 0x24, 0x76, 0x4c, 0x24, 0x02}, want: "VPERMI2Q 64(R12), Y24, K4, Y25"},
+		{name: "ps x high masked", code: []byte{0x62, 0xa2, 0x55, 0x01, 0x77, 0xf4}, want: "VPERMI2PS X20, X21, K1, X22"},
+		{name: "pd z broadcast zeroing", code: []byte{0x62, 0xf2, 0xf5, 0xdb, 0x77, 0x50, 0x7f}, want: "VPERMI2PD.BCST.Z 1016(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86IndexedPermuteInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("VPERMI2 encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPERMI2Q(t *testing.T) {
+	code := []byte{0x62, 0x22, 0xb5, 0x48, 0x76, 0xf2}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPERMI2Q", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPERMI2Q" || !strings.HasPrefix(decoded[0].Raw, "VPERMI2Q Z18, Z9, Z30 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpermq_test.go b/amd64_raw_vpermq_test.go
new file mode 100644
index 000000000..61ca796fc
--- /dev/null
+++ b/amd64_raw_vpermq_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "testing"
+
+func TestDecodedX86VPERMQInstructionCompleteVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{name: "register", code: []byte{0xc4, 0xe3, 0xfd, 0x00, 0xc9, 0x39}, mode: 64, want: "VPERMQ $57, Y1, Y1"},
+		{name: "extended_registers", code: []byte{0xc4, 0x43, 0xfd, 0x00, 0xca, 0xff}, mode: 64, want: "VPERMQ $255, Y10, Y9"},
+		{name: "memory_disp8", code: []byte{0xc4, 0xe3, 0xfd, 0x00, 0x4e, 0x20, 0x01}, mode: 64, want: "VPERMQ $1, 32(SI), Y1"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VPERMQInstruction(test.code, test.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(test.code) {
+				t.Fatalf("length = %d, want %d", length, len(test.code))
+			}
+			if instruction.Raw != test.want {
+				t.Fatalf("instruction = %q, want %q", instruction.Raw, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VPERMQInstructionRejectsInvalidVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc4, 0xe3, 0xfd, 0x00}, mode: 64},
+		{name: "truncated_immediate", code: []byte{0xc4, 0xe3, 0xfd, 0x00, 0xc9}, mode: 64},
+		{name: "vex_l_zero", code: []byte{0xc4, 0xe3, 0xf9, 0x00, 0xc9, 0x39}, mode: 64},
+		{name: "used_vvvv", code: []byte{0xc4, 0xe3, 0xed, 0x00, 0xc9, 0x39}, mode: 64},
+		{name: "extended_register_in_386", code: []byte{0xc4, 0x43, 0xfd, 0x00, 0xca, 0xff}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc4, 0xe3, 0xfd, 0x00, 0x0d, 0, 0, 0, 0, 0x39}, mode: 64},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VPERMQInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VPERMQ encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVPERMQSequence(t *testing.T) {
+	code := []byte{
+		0xc4, 0xe3, 0xfd, 0x00, 0xc9, 0x39,
+		0xc4, 0xe3, 0xfd, 0x00, 0xd2, 0x4e,
+		0xc4, 0xe3, 0xfd, 0x00, 0xdb, 0x93,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VPERMQ raw sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 3 {
+		t.Fatalf("decoded %d instructions, want 3: %#v", len(decoded), decoded)
+	}
+	for _, instruction := range decoded {
+		if instruction.Op != "VPERMQ" {
+			t.Fatalf("decoded op = %s, want VPERMQ", instruction.Op)
+		}
+	}
+}
diff --git a/amd64_raw_vpinsr_evex.go b/amd64_raw_vpinsr_evex.go
new file mode 100644
index 000000000..1a938d5e4
--- /dev/null
+++ b/amd64_raw_vpinsr_evex.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27's _yvpinsrb table has one EVEX.128 row for each scalar width.
+// VEX forms use decodedX86VPINSRInstruction; the EVEX row extends X
+// base/destination registers to X31 and scales disp8 by the scalar width.
+func decodedX86EVEXVPINSRInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	return decodedX86EVEXVPINSRInstructionWithMemory(code, mode, x86RawMemoryDecoder{})
+}
+
+func decodedX86EVEXVPINSRInstructionWithMemory(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.pp != 1 {
+		return Instr{}, 0, false, nil
+	}
+	op := Op("")
+	laneBytes := 0
+	switch {
+	case p.mapNumber == 3 && p.opcode == 0x20 && !p.w:
+		op, laneBytes = "VPINSRB", 1
+	case p.mapNumber == 1 && p.opcode == 0xc4 && !p.w:
+		op, laneBytes = "VPINSRW", 2
+	case p.mapNumber == 3 && p.opcode == 0x22 && !p.w:
+		op, laneBytes = "VPINSRD", 4
+	case p.mapNumber == 3 && p.opcode == 0x22 && p.w:
+		op, laneBytes = "VPINSRQ", 8
+	default:
+		return Instr{}, 0, false, nil
+	}
+	fail := func(message string) (Instr, int, bool, error) {
+		return Instr{}, 0, true, fmt.Errorf("raw EVEX %s: %s", op, message)
+	}
+	if mode != 64 {
+		return fail("Go assembler exposes this EVEX form only on amd64")
+	}
+	if p.addressOverride {
+		return fail("address-size override is not source-layout safe")
+	}
+	if !p.fixed || p.vectorLength != 0 || p.mask != 0 || p.zero || p.broadcast {
+		return fail("invalid EVEX fixed, length, mask, zeroing or broadcast bits")
+	}
+	if len(code) <= p.modRM {
+		return fail("missing ModRM byte")
+	}
+	modRM := code[p.modRM]
+	source, consumed, err := memory.scalar(
+		code[p.modRM:], mode, p.b, p.x, p.segment, laneBytes,
+	)
+	if err != nil {
+		return Instr{}, 0, true, err
+	}
+	immediateIndex := p.modRM + consumed
+	if len(code) <= immediateIndex {
+		return fail("missing immediate byte")
+	}
+	immediate := Operand{Kind: OpImm, Imm: int64(code[immediateIndex])}
+	base := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", p.upper))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", int(modRM>>3&7)+p.r*8))}
+	args := []Operand{immediate, source, base, destination}
+	return Instr{
+		Op:   op,
+		Args: args,
+		Raw:  fmt.Sprintf("%s %s, %s, %s, %s", op, immediate.String(), source.String(), base.String(), destination.String()),
+	}, immediateIndex + 1, true, nil
+}
diff --git a/amd64_raw_vpinsr_evex_test.go b/amd64_raw_vpinsr_evex_test.go
new file mode 100644
index 000000000..fd2e4b37d
--- /dev/null
+++ b/amd64_raw_vpinsr_evex_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86RawEVEXVPINSRForms = []struct {
+	op        Op
+	mapNumber int
+	opcode    byte
+	width64   bool
+	laneBytes int
+}{
+	{"VPINSRB", 3, 0x20, false, 1},
+	{"VPINSRW", 1, 0xc4, false, 2},
+	{"VPINSRD", 3, 0x22, false, 4},
+	{"VPINSRQ", 3, 0x22, true, 8},
+}
+
+func x86RawEVEXVPINSRGoForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT rawVPINSR(SB),4,$0-0\n")
+	for _, form := range x86RawEVEXVPINSRForms {
+		fmt.Fprintf(&source, "\t%s $5, AX, X20, X21\n", form.op)
+		fmt.Fprintf(&source, "\t%s $255, %d(BX), X20, X21\n", form.op, form.laneBytes)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestDecodeX86RawEVEXVPINSRSeBiShogunRegression(t *testing.T) {
+	// Go disassembles these bytes as VPINSRB $5, 1(SI)(R9*1), X6, X16.
+	code := []byte{0x62, 0xa3, 0x4d, 0x08, 0x20, 0x44, 0x0e, 0x01, 0x05, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "bitshuffleU8 AVX512 VPINSRB", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 2 || decoded[0].Op != "VPINSRB" ||
+		decoded[0].Args[0].Imm != 5 || decoded[0].Args[2].Reg != "X6" ||
+		decoded[0].Args[3].Reg != "X16" {
+		t.Fatalf("decoded %x as %#v", code, decoded)
+	}
+}
+
+func TestDecodeX86RawEVEXVPINSRCompleteGoForms(t *testing.T) {
+	if len(x86RawEVEXVPINSRForms) != 4 {
+		t.Fatalf("EVEX VPINSR grammar has %d entries, want four", len(x86RawEVEXVPINSRForms))
+	}
+	source := x86RawEVEXVPINSRGoForms()
+	code := assembleX87ControlBytes(t, "amd64", source)
+	decoded, err := decodeX86RawDirectives(rawX86Function(code), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	named, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := named.Funcs[0].Instrs[1:]
+	if len(decoded.Instrs) != len(want) {
+		t.Fatalf("decoded %d instructions, want %d", len(decoded.Instrs), len(want))
+	}
+	for index, got := range decoded.Instrs {
+		if got.Op != want[index].Op || !reflect.DeepEqual(got.Args, want[index].Args) {
+			t.Fatalf("instruction %d=%+v, want %+v", index, got, want[index])
+		}
+	}
+}
+
+func TestDecodeX86RawEVEXVPINSRRejectsInvalidForms(t *testing.T) {
+	base := []byte{0x62, 0xa3, 0x4d, 0x08, 0x20, 0x44, 0x0e, 0x01, 0x05}
+	for _, variant := range []struct {
+		name   string
+		mutate func([]byte) []byte
+	}{
+		{"mask", func(code []byte) []byte { code[3] |= 1; return code }},
+		{"zeroing", func(code []byte) []byte { code[3] |= 0x80; return code }},
+		{"broadcast", func(code []byte) []byte { code[3] |= 0x10; return code }},
+		{"vector length", func(code []byte) []byte { code[3] |= 0x20; return code }},
+		{"address override", func(code []byte) []byte { return append([]byte{0x67}, code...) }},
+		{"truncated immediate", func(code []byte) []byte { return code[:len(code)-1] }},
+	} {
+		t.Run(variant.name, func(t *testing.T) {
+			code := variant.mutate(append([]byte(nil), base...))
+			if _, _, matched, err := decodedX86EVEXVPINSRInstruction(code, 64); !matched || err == nil {
+				t.Fatalf("invalid %x: matched=%v err=%v", code, matched, err)
+			}
+		})
+	}
+	if _, _, matched, err := decodedX86EVEXVPINSRInstruction(base, 32); !matched || err == nil {
+		t.Fatalf("accepted 386 EVEX VPINSR: matched=%v err=%v", matched, err)
+	}
+}
+
+func TestTranslateX86RawEVEXVPINSRLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin",
+		"x86_64-unknown-linux-gnu",
+		"x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			source := x86RawEVEXVPINSRGoForms()
+			code := assembleX87ControlBytes(t, "amd64", source)
+			file := x86RawUnprovedReturnFormProbeFile(t, "amd64", "rawVPINSR", code)
+			// The original rows omit their GP/vector/address inputs. Their
+			// public Context and independent physical objects are separate gates.
+			ir := x86UnboundVoidRawProbeObject(t, file, "amd64", triple)
+			compileLLVMToObject(t, llc, triple, "raw-vpinsr.ll", "raw-vpinsr.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vpinsr_test.go b/amd64_raw_vpinsr_test.go
new file mode 100644
index 000000000..56b13e983
--- /dev/null
+++ b/amd64_raw_vpinsr_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "testing"
+
+func TestDecodedX86VPINSRInstructionCompleteVEXFamily(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{name: "byte_register", code: []byte{0xc4, 0xe3, 0x79, 0x20, 0xc1, 0x02}, mode: 64, want: "VPINSRB $2, CX, X0, X0"},
+		{name: "word_two_byte_vex", code: []byte{0xc5, 0xf9, 0xc4, 0xc1, 0x02}, mode: 64, want: "VPINSRW $2, CX, X0, X0"},
+		{name: "dword_register", code: []byte{0xc4, 0xe3, 0x79, 0x22, 0xc1, 0x02}, mode: 64, want: "VPINSRD $2, CX, X0, X0"},
+		{name: "qword_register", code: []byte{0xc4, 0xe3, 0xf9, 0x22, 0xc1, 0x02}, mode: 64, want: "VPINSRQ $2, CX, X0, X0"},
+		{name: "qword_memory_disp8", code: []byte{0xc4, 0x63, 0xa1, 0x22, 0x5e, 0x28, 0x01}, mode: 64, want: "VPINSRQ $1, 40(SI), X11, X11"},
+		{name: "extended_registers", code: []byte{0xc4, 0x43, 0x31, 0x22, 0xca, 0x01}, mode: 64, want: "VPINSRD $1, R10, X9, X9"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VPINSRInstruction(test.code, test.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(test.code) {
+				t.Fatalf("length = %d, want %d", length, len(test.code))
+			}
+			if instruction.Raw != test.want {
+				t.Fatalf("instruction = %q, want %q", instruction.Raw, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VPINSRInstructionRejectsInvalidVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc4, 0xe3, 0xf9, 0x22}, mode: 64},
+		{name: "truncated_immediate", code: []byte{0xc4, 0xe3, 0xf9, 0x22, 0xc1}, mode: 64},
+		{name: "vex_l_one", code: []byte{0xc4, 0xe3, 0xfd, 0x22, 0xc1, 0x02}, mode: 64},
+		{name: "vex_pp_zero", code: []byte{0xc4, 0xe3, 0xf8, 0x22, 0xc1, 0x02}, mode: 64},
+		{name: "qword_in_386", code: []byte{0xc4, 0xe3, 0xf9, 0x22, 0xc1, 0x02}, mode: 32},
+		{name: "extended_register_in_386", code: []byte{0xc4, 0x43, 0x31, 0x22, 0xca, 0x01}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc4, 0xe3, 0xf9, 0x22, 0x05, 0, 0, 0, 0, 0x02}, mode: 64},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VPINSRInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VPINSR encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVPINSRQSequence(t *testing.T) {
+	code := []byte{0xc4, 0x63, 0xa1, 0x22, 0x5e, 0x28, 0x01}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VPINSRQ raw sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPINSRQ" {
+		t.Fatalf("decoded = %#v, want one VPINSRQ", decoded)
+	}
+}
diff --git a/amd64_raw_vpror_test.go b/amd64_raw_vpror_test.go
new file mode 100644
index 000000000..ec8393ff6
--- /dev/null
+++ b/amd64_raw_vpror_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86PackedImmediateRotateCompleteGo127Family(t *testing.T) {
+	// Go 1.27's _yvprold table covers the four EVEX immediate rotate
+	// instructions across X/Y/Z, memory, masks, zeroing, broadcast, high
+	// registers, and compressed disp8. LLVM 22 verified these bytes.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "left dword x high masked", code: []byte{0x62, 0xb1, 0x4d, 0x01, 0x72, 0xcc, 0x06}, want: "VPROLD $6, X20, K1, X22"},
+		{name: "left qword y memory zeroing", code: []byte{0x62, 0xd1, 0xed, 0xaa, 0x72, 0x48, 0x03, 0x07}, want: "VPROLQ.Z $7, 96(R8), K2, Y2"},
+		{name: "right dword reported minio", code: []byte{0x62, 0xf1, 0x2d, 0x48, 0x72, 0xc4, 0x06}, want: "VPRORD $6, Z4, Z10"},
+		{name: "right dword z broadcast high masked", code: []byte{0x62, 0xd1, 0x35, 0x5c, 0x72, 0x44, 0x24, 0x7f, 0x44}, want: "VPRORD.BCST $68, 508(R12), K4, Z9"},
+		{name: "right qword z broadcast zeroing", code: []byte{0x62, 0xf1, 0xed, 0xdb, 0x72, 0x40, 0x7f, 0x09}, want: "VPRORQ.BCST.Z $9, 1016(AX), K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86PackedImmediateRotateInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("packed immediate rotate encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPRORD(t *testing.T) {
+	code := []byte{0x62, 0xf1, 0x2d, 0x48, 0x72, 0xc4, 0x06}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPRORD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPRORD" || !strings.HasPrefix(decoded[0].Raw, "VPRORD $6, Z4, Z10 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpshift_test.go b/amd64_raw_vpshift_test.go
new file mode 100644
index 000000000..b4fd57876
--- /dev/null
+++ b/amd64_raw_vpshift_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86PackedLogicalShiftCompleteGo127Family(t *testing.T) {
+	// Go 1.27's _yvpslld table covers six logical shifts with both immediate
+	// and XMM/m128 uniform-count encodings. These LLVM 22 bytes also cover
+	// VEX/EVEX, every width, masks, zeroing, broadcast, high registers, and
+	// compressed disp8.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "vex immediate right dword", code: []byte{0xc5, 0xb5, 0x72, 0xd2, 0x07}, want: "VPSRLD $7, Y2, Y9"},
+		{name: "vex count left qword memory", code: []byte{0xc4, 0x41, 0x6d, 0xf3, 0x4c, 0x24, 0x20}, want: "VPSLLQ 32(R12), Y2, Y9"},
+		{name: "immediate left word", code: []byte{0x62, 0xb1, 0x4d, 0x01, 0x71, 0xf4, 0x06}, want: "VPSLLW $6, X20, K1, X22"},
+		{name: "immediate left dword", code: []byte{0x62, 0xd1, 0x6d, 0xaa, 0x72, 0x70, 0x03, 0x07}, want: "VPSLLD.Z $7, 96(R8), K2, Y2"},
+		{name: "immediate left qword", code: []byte{0x62, 0xb1, 0xb5, 0x48, 0x73, 0xf1, 0x44}, want: "VPSLLQ $68, Z17, Z9"},
+		{name: "immediate right word", code: []byte{0x62, 0xd1, 0x35, 0x24, 0x71, 0x54, 0x24, 0x02, 0x0a}, want: "VPSRLW $10, 64(R12), K4, Y25"},
+		{name: "immediate right dword reported minio", code: []byte{0x62, 0x91, 0x05, 0x48, 0x72, 0xd6, 0x0a}, want: "VPSRLD $10, Z30, Z15"},
+		{name: "immediate right qword broadcast", code: []byte{0x62, 0xf1, 0xed, 0xdb, 0x73, 0x50, 0x7f, 0x09}, want: "VPSRLQ.BCST.Z $9, 1016(AX), K3, Z2"},
+		{name: "count left word", code: []byte{0x62, 0xa1, 0x55, 0x01, 0xf1, 0xf4}, want: "VPSLLW X20, X21, K1, X22"},
+		{name: "count left dword memory", code: []byte{0x62, 0xd1, 0x75, 0xaa, 0xf2, 0x50, 0x03}, want: "VPSLLD.Z 48(R8), Y1, K2, Y2"},
+		{name: "count left qword", code: []byte{0x62, 0x31, 0xfd, 0x40, 0xf3, 0xc9}, want: "VPSLLQ X17, Z16, Z9"},
+		{name: "count right word memory", code: []byte{0x62, 0x41, 0x3d, 0x04, 0xd1, 0x4c, 0x24, 0x02}, want: "VPSRLW 32(R12), X24, K4, X25"},
+		{name: "count right dword", code: []byte{0x62, 0xa1, 0x55, 0x21, 0xd2, 0xf4}, want: "VPSRLD X20, Y21, K1, Y22"},
+		{name: "count right qword memory", code: []byte{0x62, 0xf1, 0xf5, 0xcb, 0xd3, 0x50, 0x7f}, want: "VPSRLQ.Z 2032(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86PackedUniformShiftInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("packed logical shift encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86PackedArithmeticShiftStreamVByteRegression(t *testing.T) {
+	code := []byte{0xc5, 0xfd, 0x72, 0xe0, 0x1f}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "streamvbyte VPSRAD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPSRAD" || !strings.HasPrefix(decoded[0].Raw, "VPSRAD $31, Y0, Y0 ") {
+		t.Fatalf("decoded streamvbyte VPSRAD as %#v", decoded)
+	}
+}
+
+func TestDecodedX86PackedArithmeticShiftCompleteGo127Family(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{"VEX immediate word", []byte{0xc5, 0xe9, 0x71, 0xe1, 0x03}, "VPSRAW $3, X1, X2"},
+		{"VEX immediate dword", []byte{0xc5, 0xed, 0x72, 0xe1, 0x07}, "VPSRAD $7, Y1, Y2"},
+		{"EVEX immediate qword", []byte{0x62, 0xf1, 0xed, 0x48, 0x72, 0xe1, 0x07}, "VPSRAQ $7, Z1, Z2"},
+		{"VEX packed count word", []byte{0xc5, 0xed, 0xe1, 0xd9}, "VPSRAW X1, Y2, Y3"},
+		{"EVEX packed count dword", []byte{0x62, 0xf1, 0x6d, 0x48, 0xe2, 0xd9}, "VPSRAD X1, Z2, Z3"},
+		{"EVEX packed count qword", []byte{0x62, 0xf1, 0xed, 0x48, 0xe2, 0xd9}, "VPSRAQ X1, Z2, Z3"},
+		{"EVEX dword broadcast zeroing", []byte{0x62, 0xf1, 0x6d, 0xbb, 0x72, 0x20, 0x07}, "VPSRAD.BCST.Z $7, 0(AX), K3, Y2"},
+		{"EVEX qword broadcast high register", []byte{0x62, 0xf1, 0xed, 0xd3, 0x72, 0x60, 0x01, 0x07}, "VPSRAQ.BCST.Z $7, 8(AX), K3, Z18"},
+		{"EVEX qword high register packed count", []byte{0x62, 0xa1, 0xd5, 0xc1, 0xe2, 0xf4}, "VPSRAQ.Z X20, Z21, K1, Z22"},
+		{"EVEX word memory zeroing", []byte{0x62, 0xd1, 0x35, 0xaa, 0x71, 0x60, 0x01, 0x03}, "VPSRAW.Z $3, 32(R8), K2, Y9"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, recognized, err := decodedX86PackedUniformShiftInstruction(test.code, 64)
+			if err != nil || !recognized || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode %x: raw=%q length=%d recognized=%v err=%v; want %q", test.code, instruction.Raw, length, recognized, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslateRawPackedArithmeticShiftLLVM22Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name, goarch, triple string
+	}{
+		{"darwin-amd64", "amd64", "x86_64-apple-darwin"},
+		{"linux-amd64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"windows-amd64", "amd64", "x86_64-pc-windows-msvc"},
+		{"linux-386", "386", "i386-unknown-linux-gnu"},
+		{"windows-386", "386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			encodings := [][]byte{
+				{0xc5, 0xe9, 0x71, 0xe1, 0x03},
+				{0xc5, 0xed, 0x72, 0xe1, 0x07},
+				{0x62, 0xf1, 0xed, 0x48, 0x72, 0xe1, 0x07},
+				{0xc5, 0xed, 0xe1, 0xd9},
+				{0x62, 0xf1, 0x6d, 0x48, 0xe2, 0xd9},
+				{0x62, 0xf1, 0xed, 0x48, 0xe2, 0xd9},
+			}
+			encodings = append(encodings, []byte{0x62, 0xf1, 0x6d, 0xbb, 0x72, 0x20, 0x07})
+			var source strings.Builder
+			source.WriteString("TEXT packedArithmeticShiftRaw(SB), $0-0\n")
+			for _, code := range encodings {
+				for _, value := range code {
+					fmt.Fprintf(&source, "\tBYTE $0x%02x\n", value)
+				}
+			}
+			source.WriteString("\tRET\n")
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := x86PackedShiftRawFormatObject(t, file, Options{
+				Goarch:       target.goarch,
+				TargetTriple: target.triple,
+				Sigs:         map[string]FuncSig{"packedArithmeticShiftRaw": {Name: "packedArithmeticShiftRaw", Ret: Void}},
+			})
+			compileLLVMToObject(t, llc, target.triple, "raw-arithmetic-shift.ll", "raw-arithmetic-shift.o", ir)
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPSRLD(t *testing.T) {
+	code := []byte{0x62, 0x91, 0x05, 0x48, 0x72, 0xd6, 0x0a}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPSRLD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPSRLD" || !strings.HasPrefix(decoded[0].Raw, "VPSRLD $10, Z30, Z15 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpshufb_literal_test.go b/amd64_raw_vpshufb_literal_test.go
new file mode 100644
index 000000000..ab6713b2c
--- /dev/null
+++ b/amd64_raw_vpshufb_literal_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawVPSHUFBLiteral(evex bool, width, mask int, zeroing bool) []byte {
+	code := encodeRawScalarMove(evex, 1, 0, 0, 0, 0, mask, zeroing)
+	code[1] = code[1]&0xf0 | 2
+	if evex {
+		code[3] |= byte(map[int]int{16: 0, 32: 1, 64: 2}[width]) << 5
+	} else if width == 32 {
+		code[2] |= 0x04
+	}
+	code[len(code)-1] = 0x05
+	code = append(code, 1, 0, 0, 0, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*23+7))
+	}
+	return code
+}
+
+func TestDecodeX86RawVPSHUFBRIPDataCompleteFamily(t *testing.T) {
+	for _, evex := range []bool{false, true} {
+		widths := []int{16, 32}
+		if evex {
+			widths = append(widths, 64)
+		}
+		for _, width := range widths {
+			masks := []int{0}
+			if evex {
+				masks = append(masks, 7)
+			}
+			for _, mask := range masks {
+				name := fmt.Sprintf("evex%t/%d/mask%d", evex, width, mask)
+				t.Run(name, func(t *testing.T) {
+					code := x86RawVPSHUFBLiteral(evex, width, mask, mask != 0)
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := Op("VPSHUFB")
+					if mask != 0 {
+						want += ".Z"
+					}
+					if len(decoded) != 2 || decoded[0].Op != want ||
+						decoded[0].Args[0].Kind != OpSym || !decoded[0].x86RIPLiteral ||
+						decoded[1].Op != OpRET {
+						t.Fatalf("decoded %x as %#v, want %s source-local data", code, decoded, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeX86RawVPSHUFBRIPDataRejectsUnsafeSources(t *testing.T) {
+	valid := x86RawVPSHUFBLiteral(true, 64, 7, true)
+	for name, mutate := range map[string]func([]byte) []byte{
+		"truncated source": func(code []byte) []byte { return code[:len(code)-1] },
+		"overlapping instruction": func(code []byte) []byte {
+			code[6] = 0
+			return code
+		},
+		"outside directive group": func(code []byte) []byte {
+			code[6] = 127
+			return code
+		},
+		"segment override": func(code []byte) []byte {
+			return append([]byte{0x65}, code...)
+		},
+		"address override": func(code []byte) []byte {
+			return append([]byte{0x67}, code...)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := mutate(append([]byte(nil), valid...))
+			if _, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{}); err == nil {
+				t.Fatalf("accepted unsafe RIP source %x", code)
+			}
+		})
+	}
+}
+
+func TestTranslateX86RawVPSHUFBRIPDataObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var pools [][]byte
+	for index, form := range []struct {
+		evex  bool
+		width int
+		mask  int
+	}{
+		{false, 16, 0}, {false, 32, 0},
+		{true, 16, 0}, {true, 32, 7}, {true, 64, 7},
+	} {
+		code := x86RawVPSHUFBLiteral(form.evex, form.width, form.mask, form.mask != 0)
+		name := fmt.Sprintf("vpshufbLiteral%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+		for _, value := range code {
+			fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+		}
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		pools = append(pools, code[len(code)-form.width:])
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(normalized.Data) != len(pools) {
+		t.Fatalf("materialized %d constants, want %d", len(normalized.Data), len(pools))
+	}
+	for index, datum := range normalized.Data {
+		if !bytes.Equal(datum.Payload, pools[index]) {
+			t.Fatalf("constant %d = %x, want %x", index, datum.Payload, pools[index])
+		}
+	}
+	again, err := normalizeX86RawFile(normalized, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(again.Data) != len(pools) {
+		t.Fatalf("second normalization materialized %d constants, want %d", len(again.Data), len(pools))
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "<16 x i32> <i32 7, i32 14, i32 5, i32 12, i32 3, i32 10, i32 16, i32 16, i32 16, i32 16, i32 16, i32 4, i32 11, i32 2, i32 9, i32 0>") {
+				t.Fatal("missing lane-local and high-bit-zero byte shuffle")
+			}
+			compileLLVMToObject(t, llc, triple, "vpshufb-literal.ll", "vpshufb-literal.o", ir)
+		})
+	}
+}
diff --git a/amd64_raw_vpshufb_test.go b/amd64_raw_vpshufb_test.go
new file mode 100644
index 000000000..fb8282dda
--- /dev/null
+++ b/amd64_raw_vpshufb_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86VPSHUFBCompleteGo127Family(t *testing.T) {
+	// Go 1.27's _yvandnpd table gives VPSHUFB VEX X/Y forms and EVEX
+	// X/Y/Z forms, including high registers, memory, K masking, zeroing,
+	// and EVEX compressed disp8 scaling. LLVM 22 verified these bytes.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "vex x high destination", code: []byte{0xc4, 0x62, 0x79, 0x00, 0xc1}, want: "VPSHUFB X1, X0, X8"},
+		{name: "vex y high memory", code: []byte{0xc4, 0x42, 0x6d, 0x00, 0x4c, 0x24, 0x20}, want: "VPSHUFB 32(R12), Y2, Y9"},
+		{name: "evex x high masked", code: []byte{0x62, 0xa2, 0x55, 0x01, 0x00, 0xf4}, want: "VPSHUFB X20, X21, K1, X22"},
+		{name: "evex y memory zeroing", code: []byte{0x62, 0xd2, 0x75, 0xaa, 0x00, 0x50, 0x03}, want: "VPSHUFB.Z 96(R8), Y1, K2, Y2"},
+		{name: "evex z high", code: []byte{0x62, 0x32, 0x7d, 0x40, 0x00, 0xc9}, want: "VPSHUFB Z17, Z16, Z9"},
+		{name: "evex z compressed memory zeroing", code: []byte{0x62, 0xf2, 0x75, 0xcb, 0x00, 0x50, 0x7f}, want: "VPSHUFB.Z 8128(AX), Z1, K3, Z2"},
+		{name: "reported minio", code: []byte{0x62, 0xc2, 0x7d, 0x40, 0x00, 0xc3}, want: "VPSHUFB Z11, Z16, Z16"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VPSHUFBInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("VPSHUFB encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPSHUFB(t *testing.T) {
+	code := []byte{0x62, 0xc2, 0x7d, 0x40, 0x00, 0xc3}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPSHUFB", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPSHUFB" || !strings.HasPrefix(decoded[0].Raw, "VPSHUFB Z11, Z16, Z16 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpternlog_test.go b/amd64_raw_vpternlog_test.go
new file mode 100644
index 000000000..99149643e
--- /dev/null
+++ b/amd64_raw_vpternlog_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86RawImmediateThreeVectorSourceLocalRIPData(t *testing.T) {
+	for _, family := range []struct {
+		opcode byte
+		name   string
+	}{{0x25, "VPTERNLOG"}, {0x03, "VALIGN"}} {
+		for _, qword := range []bool{false, true} {
+			for vectorLength := 0; vectorLength < 3; vectorLength++ {
+				for _, broadcast := range []bool{false, true} {
+					p1 := byte(0x7d)
+					laneWidth := 4
+					suffix := "D"
+					if qword {
+						p1 |= 0x80
+						laneWidth = 8
+						suffix = "Q"
+					}
+					p2 := byte(0x08 | vectorLength<<5)
+					width := 16 << vectorLength
+					if broadcast {
+						p2 |= 0x10
+						width = laneWidth
+					}
+					code := []byte{0x62, 0xf3, p1, p2, family.opcode, 0x05, 1, 0, 0, 0, 0xca, 0xc3}
+					for value := 0; value < width; value++ {
+						code = append(code, byte(value))
+					}
+					decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "immediate three-vector RIP", map[string]bool{})
+					if err != nil {
+						t.Fatalf("%s%s width %d broadcast=%t: %v", family.name, suffix, width, broadcast, err)
+					}
+					if len(decoded) != 2 || len(decoded[0].x86RIPLiteralData) != width {
+						t.Fatalf("%s%s width %d broadcast=%t: %#v", family.name, suffix, width, broadcast, decoded)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestDecodedX86TernaryLogicCompleteGo127Family(t *testing.T) {
+	// Go 1.27 shares _yvalignd between VPTERNLOGD/Q. These LLVM 22 bytes
+	// cover X/Y/Z, high registers, memory, masks, zeroing, broadcast, and
+	// compressed disp8 for both lane widths.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "dword x high masked", code: []byte{0x62, 0xa3, 0x55, 0x01, 0x25, 0xf4, 0xca}, want: "VPTERNLOGD $202, X20, X21, K1, X22"},
+		{name: "qword y memory zeroing", code: []byte{0x62, 0xd3, 0xf5, 0xaa, 0x25, 0x50, 0x03, 0x96}, want: "VPTERNLOGQ.Z $150, 96(R8), Y1, K2, Y2"},
+		{name: "dword reported minio", code: []byte{0x62, 0x73, 0x55, 0x48, 0x25, 0xce, 0xca}, want: "VPTERNLOGD $202, Z6, Z5, Z9"},
+		{name: "dword z broadcast high masked", code: []byte{0x62, 0x53, 0x7d, 0x54, 0x25, 0x4c, 0x24, 0x7f, 0x44}, want: "VPTERNLOGD.BCST $68, 508(R12), Z16, K4, Z9"},
+		{name: "qword z broadcast zeroing", code: []byte{0x62, 0xf3, 0xf5, 0xdb, 0x25, 0x50, 0x7f, 0x09}, want: "VPTERNLOGQ.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86TernaryLogicInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("ternary-logic encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVPTERNLOGD(t *testing.T) {
+	code := []byte{0x62, 0x73, 0x55, 0x48, 0x25, 0xce, 0xca}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VPTERNLOGD", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VPTERNLOGD" || !strings.HasPrefix(decoded[0].Raw, "VPTERNLOGD $202, Z6, Z5, Z9 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vpunpck_test.go b/amd64_raw_vpunpck_test.go
new file mode 100644
index 000000000..166dffb4d
--- /dev/null
+++ b/amd64_raw_vpunpck_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import "testing"
+
+func TestDecodedX86VPUNPCKInstructionCompleteVEXFamily(t *testing.T) {
+	for _, test := range []struct {
+		opcode byte
+		op     Op
+	}{
+		{0x60, "VPUNPCKLBW"},
+		{0x61, "VPUNPCKLWD"},
+		{0x62, "VPUNPCKLDQ"},
+		{0x6c, "VPUNPCKLQDQ"},
+		{0x68, "VPUNPCKHBW"},
+		{0x69, "VPUNPCKHWD"},
+		{0x6a, "VPUNPCKHDQ"},
+		{0x6d, "VPUNPCKHQDQ"},
+	} {
+		t.Run(string(test.op), func(t *testing.T) {
+			code := []byte{0xc5, 0xe9, test.opcode, 0xcb}
+			instruction, length, ok, err := decodedX86VPUNPCKInstruction(code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(code) {
+				t.Fatalf("length = %d, want %d", length, len(code))
+			}
+			if instruction.Op != test.op || instruction.Raw != string(test.op)+" X3, X2, X1" {
+				t.Fatalf("instruction = %#v", instruction)
+			}
+		})
+	}
+
+	for _, test := range []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "y_memory", code: []byte{0xc5, 0xed, 0x6d, 0x4e, 0x20}, want: "VPUNPCKHQDQ 32(SI), Y2, Y1"},
+		{name: "extended_registers", code: []byte{0xc4, 0x41, 0x41, 0x6d, 0xf7}, want: "VPUNPCKHQDQ X15, X7, X14"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VPUNPCKInstruction(test.code, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok || length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decode = (%#v, %d, %v), want %q", instruction, length, ok, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86VPUNPCKInstructionRejectsInvalidVEXForms(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc5, 0xe9, 0x6d}, mode: 64},
+		{name: "vex_pp_zero", code: []byte{0xc5, 0xe8, 0x6d, 0xcb}, mode: 64},
+		{name: "vex_w_one", code: []byte{0xc4, 0xe1, 0xe9, 0x6d, 0xcb}, mode: 64},
+		{name: "extended_register_in_386", code: []byte{0xc4, 0x41, 0x41, 0x6d, 0xf7}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc5, 0xe9, 0x6d, 0x0d, 0, 0, 0, 0}, mode: 64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VPUNPCKInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VPUNPCK encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVPUNPCKSequence(t *testing.T) {
+	code := []byte{
+		0xc4, 0xc1, 0x41, 0x6d, 0xf7,
+		0xc5, 0x41, 0x6c, 0xff,
+		0xc4, 0xc1, 0x11, 0x6d, 0xff,
+		0xc5, 0x61, 0x6c, 0xfb,
+		0xc4, 0xc1, 0x69, 0x6d, 0xd7,
+		0xc4, 0x41, 0x09, 0x6c, 0xfe,
+		0xc4, 0xc1, 0x61, 0x6d, 0xdf,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VPUNPCK raw sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 7 {
+		t.Fatalf("decoded %d instructions, want 7: %#v", len(decoded), decoded)
+	}
+	for _, instruction := range decoded {
+		if instruction.Op != "VPUNPCKHQDQ" && instruction.Op != "VPUNPCKLQDQ" {
+			t.Fatalf("decoded unexpected op %s", instruction.Op)
+		}
+	}
+}
diff --git a/amd64_raw_vshuff_blocks_test.go b/amd64_raw_vshuff_blocks_test.go
new file mode 100644
index 000000000..9a508d672
--- /dev/null
+++ b/amd64_raw_vshuff_blocks_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86Shuffle128BitBlocksCompleteGo127Family(t *testing.T) {
+	// Go 1.27 shares _yvshuff32x4 across these four instructions. Its
+	// EVEX-only rows cover Y/Z register or memory sources, high registers,
+	// K masking, zeroing, scalar broadcast, and compressed disp8 scaling.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "f32 y high masked", code: []byte{0x62, 0xa3, 0x55, 0x21, 0x23, 0xf4, 0x06}, want: "VSHUFF32X4 $6, Y20, Y21, K1, Y22"},
+		{name: "f32 z memory zeroing", code: []byte{0x62, 0xd3, 0x75, 0xca, 0x23, 0x50, 0x03, 0x07}, want: "VSHUFF32X4.Z $7, 192(R8), Z1, K2, Z2"},
+		{name: "f64 reported minio", code: []byte{0x62, 0x23, 0x8d, 0x40, 0x23, 0xc0, 0xee}, want: "VSHUFF64X2 $238, Z16, Z30, Z24"},
+		{name: "f64 z broadcast zeroing", code: []byte{0x62, 0xf3, 0xf5, 0xdb, 0x23, 0x50, 0x7f, 0x09}, want: "VSHUFF64X2.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+		{name: "i32 y high memory masked", code: []byte{0x62, 0x43, 0x3d, 0x24, 0x43, 0x4c, 0x24, 0x02, 0x0a}, want: "VSHUFI32X4 $10, 64(R12), Y24, K4, Y25"},
+		{name: "i32 z high", code: []byte{0x62, 0x33, 0x7d, 0x40, 0x43, 0xc9, 0x44}, want: "VSHUFI32X4 $68, Z17, Z16, Z9"},
+		{name: "i64 y high masked", code: []byte{0x62, 0xa3, 0xd5, 0x21, 0x43, 0xf4, 0x06}, want: "VSHUFI64X2 $6, Y20, Y21, K1, Y22"},
+		{name: "i64 z broadcast zeroing", code: []byte{0x62, 0xf3, 0xf5, 0xdb, 0x43, 0x50, 0x7f, 0x09}, want: "VSHUFI64X2.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86Shuffle128BitBlocksInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("shuffle-block encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) || instruction.Raw != test.want {
+				t.Fatalf("decoded %x as length=%d raw=%q, want length=%d raw=%q", test.code, length, instruction.Raw, len(test.code), test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioVSHUFF64X2(t *testing.T) {
+	code := []byte{0x62, 0x23, 0x8d, 0x40, 0x23, 0xc0, 0xee}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio VSHUFF64X2", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VSHUFF64X2" || !strings.HasPrefix(decoded[0].Raw, "VSHUFF64X2 $238, Z16, Z30, Z24 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
diff --git a/amd64_raw_vshufps_test.go b/amd64_raw_vshufps_test.go
new file mode 100644
index 000000000..b43c7973b
--- /dev/null
+++ b/amd64_raw_vshufps_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDecodedX86VSHUFPSInstructionCompleteVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+		want string
+	}{
+		{name: "x_register", code: []byte{0xc5, 0x78, 0xc6, 0xc1, 0x44}, mode: 64, want: "VSHUFPS $68, X1, X0, X8"},
+		{name: "y_register", code: []byte{0xc5, 0x6c, 0xc6, 0xcb, 0x44}, mode: 64, want: "VSHUFPS $68, Y3, Y2, Y9"},
+		// Retain the old negative's exact bytes as the ISA's valid WIG form.
+		{name: "vex_w_one", code: []byte{0xc4, 0xe1, 0xbc, 0xc6, 0xc1, 0x44}, mode: 64, want: "VSHUFPS $68, Y1, Y8, Y0"},
+		{name: "extended_registers", code: []byte{0xc4, 0x41, 0x3c, 0xc6, 0xd1, 0xdd}, mode: 64, want: "VSHUFPS $221, Y9, Y8, Y10"},
+		{name: "memory_disp8", code: []byte{0xc5, 0xec, 0xc6, 0x56, 0x20, 0x01}, mode: 64, want: "VSHUFPS $1, 32(SI), Y2, Y2"},
+		{name: "pd extended registers", code: []byte{0xc4, 0x41, 0x3d, 0xc6, 0xd1, 0xdd}, mode: 64, want: "VSHUFPD $221, Y9, Y8, Y10"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VSHUFPSInstruction(test.code, test.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("encoding was not recognized")
+			}
+			if length != len(test.code) {
+				t.Fatalf("length = %d, want %d", length, len(test.code))
+			}
+			if instruction.Raw != test.want {
+				t.Fatalf("instruction = %q, want %q", instruction.Raw, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodedX86PackedFloatShuffleCompleteEVEXFamily(t *testing.T) {
+	// Go 1.27 assigns VSHUFPS and VSHUFPD the shared
+	// _yvgf2p8affineinvqb table. Its EVEX rows cover X/Y/Z register or
+	// memory sources, high registers, K masking, zeroing, and scalar
+	// broadcast. The byte sequences below are verified by LLVM 22.
+	tests := []struct {
+		name string
+		code []byte
+		want string
+	}{
+		{name: "ps x high masked", code: []byte{0x62, 0xa1, 0x54, 0x01, 0xc6, 0xf4, 0x06}, want: "VSHUFPS $6, X20, X21, K1, X22"},
+		{name: "ps y memory zeroing", code: []byte{0x62, 0xd1, 0x74, 0xaa, 0xc6, 0x50, 0x03, 0x07}, want: "VSHUFPS.Z $7, 96(R8), Y1, K2, Y2"},
+		{name: "ps z high", code: []byte{0x62, 0x31, 0x7c, 0x40, 0xc6, 0xc9, 0x44}, want: "VSHUFPS $68, Z17, Z16, Z9"},
+		{name: "ps z broadcast zeroing", code: []byte{0x62, 0xf1, 0x74, 0xdb, 0xc6, 0x50, 0x7f, 0x09}, want: "VSHUFPS.BCST.Z $9, 508(AX), Z1, K3, Z2"},
+		{name: "pd x high masked", code: []byte{0x62, 0xa1, 0xd5, 0x01, 0xc6, 0xf4, 0x06}, want: "VSHUFPD $6, X20, X21, K1, X22"},
+		{name: "pd y memory zeroing", code: []byte{0x62, 0xd1, 0xf5, 0xaa, 0xc6, 0x50, 0x03, 0x07}, want: "VSHUFPD.Z $7, 96(R8), Y1, K2, Y2"},
+		{name: "pd z high", code: []byte{0x62, 0x31, 0xfd, 0x40, 0xc6, 0xc9, 0x44}, want: "VSHUFPD $68, Z17, Z16, Z9"},
+		{name: "pd z broadcast zeroing", code: []byte{0x62, 0xf1, 0xf5, 0xdb, 0xc6, 0x50, 0x7f, 0x09}, want: "VSHUFPD.BCST.Z $9, 1016(AX), Z1, K3, Z2"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			instruction, length, ok, err := decodedX86VSHUFPSInstruction(test.code, 64)
+			if !ok {
+				t.Fatal("packed float shuffle encoding was not recognized")
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if length != len(test.code) {
+				t.Fatalf("decoded length = %d, want %d", length, len(test.code))
+			}
+			if instruction.Raw != test.want {
+				t.Fatalf("decoded %x as %q, want %q", test.code, instruction.Raw, test.want)
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupReportedMinioEVEXVSHUFPS(t *testing.T) {
+	code := []byte{0x62, 0x31, 0x7c, 0x40, 0xc6, 0xc9, 0x44}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "minio EVEX VSHUFPS", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 1 || decoded[0].Op != "VSHUFPS" || !strings.HasPrefix(decoded[0].Raw, "VSHUFPS $68, Z17, Z16, Z9 ") {
+		t.Fatalf("decoded reported minio bytes as %#v", decoded)
+	}
+}
+
+func TestDecodedX86VSHUFPSInstructionRejectsInvalidVEXForms(t *testing.T) {
+	tests := []struct {
+		name string
+		code []byte
+		mode int
+	}{
+		{name: "truncated_modrm", code: []byte{0xc5, 0x7c, 0xc6}, mode: 64},
+		{name: "truncated_immediate", code: []byte{0xc5, 0x7c, 0xc6, 0xc1}, mode: 64},
+		{name: "vex_pp_f3", code: []byte{0xc5, 0x7e, 0xc6, 0xc1, 0x44}, mode: 64},
+		{name: "extended_register_in_386", code: []byte{0xc5, 0x78, 0xc6, 0xc1, 0x44}, mode: 32},
+		{name: "rip_relative", code: []byte{0xc5, 0xfc, 0xc6, 0x05, 0, 0, 0, 0, 0x44}, mode: 64},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, _, ok, err := decodedX86VSHUFPSInstruction(test.code, test.mode)
+			if !ok {
+				t.Fatal("VSHUFPS encoding was not recognized")
+			}
+			if err == nil {
+				t.Fatal("invalid encoding was accepted")
+			}
+		})
+	}
+}
+
+func TestDecodeX86RawDirectiveGroupVSHUFPSSequence(t *testing.T) {
+	code := []byte{
+		0xc5, 0x7c, 0xc6, 0xc1, 0x44,
+		0xc5, 0xfc, 0xc6, 0xc1, 0xee,
+		0xc5, 0x6c, 0xc6, 0xcb, 0x44,
+		0xc5, 0xec, 0xc6, 0xd3, 0xee,
+		0xc4, 0xc1, 0x3c, 0xc6, 0xd9, 0xdd,
+	}
+	decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "VSHUFPS raw sequence", map[string]bool{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(decoded) != 5 {
+		t.Fatalf("decoded %d instructions, want 5: %#v", len(decoded), decoded)
+	}
+	for _, instruction := range decoded {
+		if instruction.Op != "VSHUFPS" {
+			t.Fatalf("decoded op = %s, want VSHUFPS", instruction.Op)
+		}
+	}
+}
diff --git a/amd64_raw_waitpkg.go b/amd64_raw_waitpkg.go
new file mode 100644
index 000000000..ea3d5d3f5
--- /dev/null
+++ b/amd64_raw_waitpkg.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import "fmt"
+
+// WAITPKG shares the 0F AE group with fences, CLWB and FSGSBASE. Mandatory
+// prefix plus mod=3 and /6 select the family; REX.B selects the GP register.
+// See Intel SDM volume 2B (UMONITOR, UMWAIT, TPAUSE), not x86asm's legacy
+// MFENCE decoding of these bytes.
+func decodedX86WaitPackageInstruction(code []byte, mode int) (Instr, int, bool, error) {
+	if mode != 32 && mode != 64 {
+		return Instr{}, 0, false, nil
+	}
+	i := 0
+	var repeat, segment, rex byte
+	operandOverride, addressOverride, locked := false, false, false
+	for i < len(code) {
+		switch code[i] {
+		case 0xf2, 0xf3:
+			repeat, rex = code[i], 0
+		case 0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65:
+			segment, rex = code[i], 0
+		case 0x66:
+			operandOverride, rex = true, 0
+		case 0x67:
+			addressOverride, rex = true, 0
+		case 0xf0:
+			locked, rex = true, 0
+		default:
+			if mode == 64 && code[i] >= 0x40 && code[i] <= 0x4f {
+				rex = code[i]
+				i++
+				continue
+			}
+			goto opcode
+		}
+		i++
+	}
+
+opcode:
+	prefix := repeat
+	if prefix == 0 && operandOverride {
+		prefix = 0x66
+	}
+	if prefix == 0 || len(code) < i+2 || code[i] != 0x0f || code[i+1] != 0xae {
+		return Instr{}, 0, false, nil
+	}
+	if len(code) < i+3 {
+		return Instr{}, 0, true, fmt.Errorf("truncated WAITPKG ModRM")
+	}
+	modrm := code[i+2]
+	if modrm&0x38 != 0x30 || modrm>>6 != 3 {
+		// In particular, 66 0F AE /6 with a memory operand is CLWB.
+		return Instr{}, 0, false, nil
+	}
+	if locked || i+3 > 15 {
+		return Instr{}, 0, true, fmt.Errorf("invalid WAITPKG LOCK prefix or instruction length")
+	}
+	var op Op
+	for name, spec := range amd64ImplicitSystemSpecs {
+		if spec.rawPrefix == prefix {
+			op = name
+			break
+		}
+	}
+	register, ok := decodedX86GeneralRegister(int(modrm&7) + int(rex&1)*8)
+	if !ok || op == "" {
+		return Instr{}, 0, true, fmt.Errorf("invalid WAITPKG register or mandatory prefix")
+	}
+	ins := Instr{
+		Op: op, Args: []Operand{{Kind: OpReg, Reg: register}},
+		Raw: fmt.Sprintf("%s %s", op, register), x86Encoded: true,
+	}
+	if amd64ImplicitSystemSpecs[op].operand == amd64ImplicitSystemAddressGP {
+		ins.x86AddressBits = mode
+		if addressOverride {
+			ins.x86AddressBits /= 2
+		}
+		ins.x86SegmentPrefix = segment
+	}
+	return ins, i + 3, true, nil
+}
diff --git a/amd64_raw_waitpkg_test.go b/amd64_raw_waitpkg_test.go
new file mode 100644
index 000000000..e4f61e538
--- /dev/null
+++ b/amd64_raw_waitpkg_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Intel SDM volume 2B: UMONITOR/UMWAIT/TPAUSE share 0F AE /6, mod=3.
+// Go 1.27 uses ywrfsbase's single Yrl operand for all three spellings.
+func TestX86RawWaitPackageFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, form := range []struct {
+			op     Op
+			prefix byte
+		}{{"UMONITOR", 0xf3}, {"UMWAIT", 0xf2}, {"TPAUSE", 0x66}} {
+			t.Run(target.triple+"/"+string(form.op), func(t *testing.T) {
+				code := []byte{form.prefix}
+				if target.arch == "amd64" {
+					// ixl-go's UMONITOR uses REX.W; W does not select its width.
+					code = append(code, 0x48)
+				}
+				code = append(code, 0x0f, 0xae, 0xf0)
+				var source strings.Builder
+				source.WriteString("TEXT waitpkg(SB),$0-0\n")
+				for _, value := range code {
+					fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+				}
+				source.WriteString("RET\n")
+				requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				var ir string
+				if form.op == "UMONITOR" {
+					// Address-monitoring retains its separate existing contract.
+					ir, err = Translate(file, Options{
+						Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"waitpkg": {Name: "waitpkg", Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					ir = x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+				}
+				if !strings.Contains(ir, strings.ToLower(string(form.op))) {
+					t.Fatalf("decoded %x as another instruction", code)
+				}
+				compileLLVMToObject(t, llc, target.triple, "waitpkg.ll", "waitpkg.o", ir)
+			})
+		}
+	}
+}
+
+func TestX86WaitPackageClearsOtherFlags(t *testing.T) {
+	for _, op := range []string{"UMWAIT", "TPAUSE"} {
+		source := "TEXT flags(SB),$0-0\n" + op + " BX\nRET\n"
+		ir := x86UnboundVoidScalarFormatObject(t, source, "flags", "amd64", "x86_64-unknown-linux-gnu")
+		_, after, ok := strings.Cut(ir, "asm sideeffect")
+		if !ok {
+			t.Fatal("no hardware wait operation")
+		}
+		for _, flag := range []string{"z", "slt", "pf", "of"} {
+			if !strings.Contains(after, "store i1 false, ptr %flags_"+flag) {
+				t.Errorf("%s did not clear %s after capturing carry", op, flag)
+			}
+		}
+	}
+}
+
+func TestX86RawWaitPackageRegisterGrammar(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		registerCount := 8
+		if mode == 64 {
+			registerCount = 16
+		}
+		for _, form := range []struct {
+			op     Op
+			prefix byte
+		}{{"UMONITOR", 0xf3}, {"UMWAIT", 0xf2}, {"TPAUSE", 0x66}} {
+			for register := 0; register < registerCount; register++ {
+				for _, ignoredREX := range []byte{0, 2, 4, 8, 14} {
+					code := []byte{form.prefix, 0x67}
+					if mode == 64 {
+						code = append(code, 0x40|ignoredREX|byte(register>>3))
+					}
+					code = append(code, 0x0f, 0xae, 0xf0|byte(register&7))
+					ins, length, ok, err := decodedX86WaitPackageInstruction(code, mode)
+					wantRegister, _ := decodedX86GeneralRegister(register)
+					if err != nil || !ok || length != len(code) || ins.Op != form.op ||
+						len(ins.Args) != 1 || ins.Args[0].Reg != wantRegister {
+						t.Fatalf("mode=%d bytes=%x: %+v, length=%d, ok=%v, err=%v", mode, code, ins, length, ok, err)
+					}
+					if form.op == "UMONITOR" && ins.x86AddressBits != mode/2 {
+						t.Fatalf("UMONITOR address size = %d, want %d", ins.x86AddressBits, mode/2)
+					}
+				}
+			}
+		}
+	}
+	for _, other := range [][]byte{
+		{0x0f, 0xae, 0xf0},       // MFENCE
+		{0x66, 0x0f, 0xae, 0x30}, // CLWB (AX)
+		{0xf3, 0x0f, 0xae, 0xc0}, // RDFSBASEL AX
+		{0xf3, 0x0f, 0xae, 0x30}, // a memory encoding, not WAITPKG
+		{0xf2, 0x0f, 0xae, 0x30}, // a memory encoding, not WAITPKG
+	} {
+		if _, _, ok, _ := decodedX86WaitPackageInstruction(other, 64); ok {
+			t.Fatalf("claimed another 0F AE family: %x", other)
+		}
+	}
+	for _, invalid := range [][]byte{
+		{0xf3, 0x0f, 0xae},
+		{0xf0, 0xf3, 0x0f, 0xae, 0xf0},
+		append(bytes.Repeat([]byte{0x67}, 12), 0xf3, 0x0f, 0xae, 0xf0),
+	} {
+		if _, err := decodeX86RawDirectiveGroup(invalid, 64, 0, "invalid WAITPKG", map[string]bool{}); err == nil {
+			t.Fatalf("accepted invalid WAITPKG encoding %x", invalid)
+		}
+	}
+}
+
+func TestX86RawWaitPackageMonitorAddressOverrides(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch, triple string
+		mode         int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 64},
+		{"amd64", "x86_64-apple-darwin", 64},
+		{"amd64", "x86_64-pc-windows-msvc", 64},
+		{"386", "i386-unknown-linux-gnu", 32},
+		{"386", "i686-pc-windows-msvc", 32},
+	} {
+		for _, segment := range []byte{0x26, 0x2e, 0x36, 0x3e, 0x64, 0x65} {
+			t.Run(fmt.Sprintf("%s/%02x", target.triple, segment), func(t *testing.T) {
+				source := fmt.Sprintf(`TEXT monitor(SB),$0-0
+	BYTE $0x%02x
+	BYTE $0x67; BYTE $0xf3; BYTE $0x0f; BYTE $0xae; BYTE $0xf3
+	RET
+`, segment)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"monitor": {Name: "monitor", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, fmt.Sprintf(".byte 0x%02x; umonitor", segment)) ||
+					!strings.Contains(ir, fmt.Sprintf("zext i%d", target.mode/2)) {
+					t.Fatal("lost monitor segment or narrow address semantics")
+				}
+				compileLLVMToObject(t, llc, target.triple, "monitor.ll", "monitor.o", ir)
+			})
+		}
+	}
+}
diff --git a/amd64_raw_x87_control_test.go b/amd64_raw_x87_control_test.go
new file mode 100644
index 000000000..187e54987
--- /dev/null
+++ b/amd64_raw_x87_control_test.go
@@ -0,0 +1,425 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86RawX87AliasFamilyMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantTables := map[Op]string{"FCLEX": "ynone", "FINIT": "ynone", "FSAVE": "ysvrs_om", "FSTCW": "ysvrs_om", "FSTENV": "ysvrs_om", "FSTSW": "ystsw"}
+	if len(x86RawX87ControlAliases) != len(wantTables) {
+		t.Fatalf("raw x87 control grammar has %d aliases, want %d", len(x86RawX87ControlAliases), len(wantTables))
+	}
+	for decoded, goOp := range x86RawX87ControlAliases {
+		if decoded.String() != "FN"+string(goOp)[1:] || !isX87Op(goOp) {
+			t.Fatalf("raw %s does not resolve to the Go x87 lowerer for %s", decoded, goOp)
+		}
+		row := regexp.MustCompile(`\{A` + string(goOp) + `,\s*(\w+),`).FindSubmatch(data)
+		if len(row) != 2 || string(row[1]) != wantTables[goOp] {
+			t.Fatalf("Go %s row = %q, want operand table %s", goOp, row, wantTables[goOp])
+		}
+	}
+}
+
+func TestX86RawX87EnvironmentAddressSpaces(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		source.WriteString("TEXT x87segments(SB),4,$0-0\n")
+		for _, opcode := range [][]byte{{0xdd, 0x30}, {0xd9, 0x38}, {0xd9, 0x30}, {0xdd, 0x38}} {
+			for _, segment := range []byte{0x64, 0x65} {
+				for _, b := range append([]byte{segment}, opcode...) {
+					fmt.Fprintf(&source, "BYTE $%#02x\n", b)
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		file, err := Parse(ArchAMD64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		ir, err := Translate(file, Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"x87segments": {Name: "x87segments", Ret: Void}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "x87-segments.ll", "x87-segments.o", ir)
+	}
+}
+
+func TestX86RawX87DoesNotWidenLegacyEnvironmentFormat(t *testing.T) {
+	for _, code := range [][]byte{{0x66, 0xdd, 0x30}, {0x66, 0xd9, 0x30}} {
+		inst, err := x86asm.Decode(code, 64)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := decodedX86GoSyntax(inst, code); err == nil {
+			t.Fatalf("silently treated 16-bit environment %x as the Go 32-bit environment form", code)
+		}
+	}
+}
+
+// asm6.go's FCLEX/FINIT/FSAVE/FSTCW/FSTENV/FSTSW rows encode the
+// no-wait forms, despite omitting Intel's N in their Go mnemonic.
+func x87NoWaitFixtures() []struct {
+	code []byte
+	text string
+} {
+	return []struct {
+		code []byte
+		text string
+	}{
+		{[]byte{0xdb, 0xe2}, "FCLEX"},
+		{[]byte{0xdb, 0xe3}, "FINIT"},
+		{[]byte{0xdd, 0x30}, "FSAVE (AX)"},
+		{[]byte{0xd9, 0x38}, "FSTCW (AX)"},
+		{[]byte{0xd9, 0x30}, "FSTENV (AX)"},
+		{[]byte{0xdd, 0x38}, "FSTSW (AX)"},
+		{[]byte{0xdf, 0xe0}, "FSTSW AX"},
+		{[]byte{0xdd, 0x74, 0x8b, 0xf9}, "FSAVE -7(BX)(CX*4)"},
+		{[]byte{0xd9, 0x7c, 0x8b, 0xf9}, "FSTCW -7(BX)(CX*4)"},
+		{[]byte{0xd9, 0x74, 0x8b, 0xf9}, "FSTENV -7(BX)(CX*4)"},
+		{[]byte{0xdd, 0x7c, 0x8b, 0xf9}, "FSTSW -7(BX)(CX*4)"},
+	}
+}
+
+func TestX86RawX87NoWaitCompleteGoForms(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64"} {
+		t.Run(goarch, func(t *testing.T) {
+			var named, raw strings.Builder
+			named.WriteString("TEXT x87control(SB),4,$0-0\n")
+			raw.WriteString("TEXT x87control(SB),4,$0-0\n")
+			var expectedBytes []byte
+			for _, test := range x87NoWaitFixtures() {
+				fmt.Fprintln(&named, test.text)
+				expectedBytes = append(expectedBytes, test.code...)
+				for _, b := range test.code {
+					fmt.Fprintf(&raw, "BYTE $%#02x\n", b)
+				}
+				decoded, err := decodeX86RawDirectives(rawX86Function(test.code), goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want, err := Parse(ArchAMD64, "TEXT f(SB),$0-0\n"+test.text+"\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(decoded.Instrs) != 1 || decoded.Instrs[0].Op != want.Funcs[0].Instrs[1].Op || !reflect.DeepEqual(decoded.Instrs[0].Args, want.Funcs[0].Instrs[1].Args) {
+					t.Fatalf("decoded %x as %+v, want %s", test.code, decoded.Instrs, test.text)
+				}
+			}
+			named.WriteString("RET\n")
+			raw.WriteString("RET\n")
+			expectedBytes = append(expectedBytes, 0xc3)
+			code := assembleX87ControlBytes(t, goarch, named.String())
+			if !bytes.HasPrefix(code, expectedBytes) {
+				t.Fatalf("Go %s encoded no-wait family as %x, want prefix %x", goarch, code, expectedBytes)
+			}
+			for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				if (goarch == "386") != strings.HasPrefix(triple, "i") {
+					continue
+				}
+				for _, mode := range []X87Mode{X87Auto, X87Software} {
+					var irs []string
+					for _, source := range []string{named.String(), raw.String()} {
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir, err := Translate(file, Options{Goarch: goarch, TargetTriple: triple, X87Mode: mode, Sigs: map[string]FuncSig{"x87control": {Name: "x87control", Ret: Void}}})
+						if err != nil {
+							t.Fatal(err)
+						}
+						irs = append(irs, ir)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					for _, ir := range irs {
+						compileLLVMToObject(t, llc, triple, "x87-control.ll", "x87-control.o", ir)
+					}
+				}
+			}
+		})
+	}
+}
+
+func assembleX87ControlBytes(t *testing.T, goarch, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	name := filepath.Join(dir, "control.s")
+	if err := os.WriteFile(name, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "control.o"), name)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+goarch)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go assembler: %v\n%s", err, out)
+	}
+	var code []byte
+	for _, line := range strings.Split(string(out), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		if err != nil || int(offset) != len(code) {
+			t.Fatalf("noncontiguous assembler bytes: %s", line)
+		}
+		for i, field := range fields[1:] {
+			if i >= 16 || len(field) != 2 {
+				break
+			}
+			value, err := strconv.ParseUint(field, 16, 8)
+			if err != nil {
+				break
+			}
+			code = append(code, byte(value))
+		}
+	}
+	return code
+}
+
+func TestX86RawX87ClearExceptionRuntimeSemantics(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("execution requires amd64 or Rosetta; all-host x86 object tests remain required")
+	}
+	const source = `TEXT rawClear(SB),$0-0
+BYTE $0xdb; BYTE $0xe2
+RET
+TEXT namedClear(SB),$0-0
+FCLEX
+RET
+TEXT rawInit(SB),$0-0
+BYTE $0xdb; BYTE $0xe3
+RET
+TEXT namedInit(SB),$0-0
+FINIT
+RET
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, name := range []string{"rawClear", "namedClear", "rawInit", "namedInit"} {
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple, prefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <stdio.h>
+extern void rawClear(void), namedClear(void), rawInit(void), namedInit(void);
+static void seed(void) {
+  uint16_t cw=0x077f;
+  __asm__ volatile("fninit; fldcw %0; fldz; fldz; fdivp; fstp %%st(0)" : : "m"(cw) : "st");
+}
+static uint16_t sw(void) { uint16_t v; __asm__ volatile("fnstsw %0":"=a"(v)); return v; }
+static uint16_t cw(void) { uint16_t v; __asm__ volatile("fnstcw %0":"=m"(v)); return v; }
+int main(void) {
+  void (*f[])(void)={rawClear,namedClear,rawInit,namedInit};
+  for (int i=0;i<4;i++) {
+    seed();
+    if (!(sw()&1) || cw()!=0x077f) return 20;
+    f[i]();
+    if ((sw()&0x80ff) || cw()!=(i<2 ? 0x077f : 0x037f)) {
+      fprintf(stderr,"x87 operation %d did not update hardware: sw=%x cw=%x\n",i,sw(),cw());
+      __asm__ volatile("fninit"); return 1;
+    }
+  }
+  __asm__ volatile("fninit"); return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_x87_clear", triple, ir, mainC, prefix)
+}
+
+func TestX86RawX87SoftwareClearPreservesAllStatusFields(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("hardware status oracle requires amd64 or Rosetta")
+	}
+	const source = `TEXT clearModeledStatus(SB),4,$0-16
+MOVQ env+0(FP),BX
+FLDENV (BX)
+BYTE $0xdb; BYTE $0xe2
+XORL AX,AX
+FSTSW AX
+MOVQ AX,ret+8(FP)
+RET
+`
+	// The original source has no source-authenticated Tag/TOP shape at RET.
+	// Keep it as a Context control. The executed counterpart differs only by
+	// a final FINIT after the captured result, not by an invented entry fact.
+	_, err := x86X87InitializedWordAPI(t, source, "func clearModeledStatus(env *byte) uint64",
+		"amd64", "x86_64-unknown-linux-gnu", "text", X87Software)
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "logical x87 value stack is not balanced at RET") {
+		t.Fatal("complete original source borrowed an unknown empty value stack", err)
+	}
+	bounded := strings.Replace(source, "MOVQ AX,ret+8(FP)\nRET\n", "MOVQ AX,ret+8(FP)\nFINIT\nRET\n", 1)
+	if bounded == source {
+		t.Fatal("bounded runtime counterpart lost its exact final-reset anchor")
+	}
+	file, err := Parse(ArchAMD64, bounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if crossRosetta {
+		triple, prefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, X87Mode: X87Software, Sigs: map[string]FuncSig{
+		"clearModeledStatus": {Name: "clearModeledStatus", Args: []LLVMType{Ptr}, Ret: I64, Frame: FrameLayout{
+			Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}, Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint64_t clearModeledStatus(const void *);
+int main(void) {
+  struct { unsigned char bytes[28]; } env={{0}};
+  uint16_t control=0x037f, tags=0xffff;
+  memcpy(env.bytes,&control,2); memcpy(env.bytes+8,&tags,2);
+  for (unsigned v=0;v<=0xffff;v++) {
+    uint16_t status=v, expected;
+    memcpy(env.bytes+4,&status,2);
+    __asm__ volatile("fldenv %1; fnclex; fnstsw %0" : "=a"(expected) : "m"(env) : "memory");
+    uint64_t got=clearModeledStatus(&env);
+    if (got!=expected) {
+      fprintf(stderr,"status %x: got %llx, hardware %x\n",v,(unsigned long long)got,expected);
+      __asm__ volatile("fninit"); return 1;
+    }
+  }
+  __asm__ volatile("fninit"); return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "x87_software_clear", triple, ir, mainC, prefix)
+}
+
+func TestX86X87WordStoresToFPParametersAndResults(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"FSTCW", "FSTSW"} {
+		for _, kind := range []string{"param", "result"} {
+			name := op + kind
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-10\nFINIT\n", name)
+			if kind == "param" {
+				fmt.Fprintf(&source, "%s input+0(FP)\nMOVW input+0(FP),AX\nMOVW AX,ret+8(FP)\n", op)
+			} else {
+				fmt.Fprintf(&source, "%s ret+8(FP)\n", op)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{I16}, Ret: I16, Frame: FrameLayout{
+				Params: []FrameSlot{{Offset: 0, Type: I16, Index: 0, Field: -1}}, Results: []FrameSlot{{Offset: 8, Type: I16, Index: 0, Field: -1}},
+			}}
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern uint16_t FSTCWparam(uint16_t),FSTCWresult(uint16_t),FSTSWparam(uint16_t),FSTSWresult(uint16_t);
+int main(void) {
+  return FSTCWparam(0xffff)!=0x037f || FSTCWresult(0xffff)!=0x037f ||
+         FSTSWparam(0xffff)!=0 || FSTSWresult(0xffff)!=0;
+}
+`
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc", "i386-unknown-linux-gnu", "i686-pc-windows-msvc", "x86_64-w64-windows-gnu"} {
+		goarch := "amd64"
+		if strings.HasPrefix(triple, "i") {
+			goarch = "386"
+		}
+		for _, mode := range []X87Mode{X87Auto, X87Software} {
+			t.Run(fmt.Sprintf("%s/%d", triple, mode), func(t *testing.T) {
+				ir, err := Translate(file, Options{Goarch: goarch, TargetTriple: triple, X87Mode: mode, Sigs: sigs})
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "x87-fp.ll", "x87-fp.o", ir)
+				crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && triple == "x86_64-apple-darwin" && rosettaAvailable()
+				hostOS := map[string]string{"darwin": "apple-darwin", "linux": "linux-gnu", "windows": "windows-msvc"}[runtime.GOOS]
+				if crossRosetta || (goarch == runtime.GOARCH && hostOS != "" && strings.Contains(triple, hostOS)) {
+					var prefix []string
+					if crossRosetta {
+						prefix = []string{"/usr/bin/arch", "-x86_64"}
+					}
+					runtimeTriple := testTargetTriple(runtime.GOOS, goarch)
+					// Windows CI provides MinGW, not the MSVC CRT. Retain the
+					// MSVC object check above, but regenerate the runtime module
+					// for the actual linker ABI instead of requesting MSVC libs.
+					runtimeIR, err := Translate(file, Options{Goarch: goarch, TargetTriple: runtimeTriple, X87Mode: mode, Sigs: sigs})
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileAndRunRuntimeTestForTarget(t, llc, clang, "x87_fp", runtimeTriple, runtimeIR, mainC, prefix)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87WordStoresRejectUnknownFPSlots(t *testing.T) {
+	for _, op := range []string{"FSTCW", "FSTSW"} {
+		file, err := Parse(ArchAMD64, "TEXT bad(SB),4,$0-0\n"+op+" unknown+24(FP)\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+				t.Fatalf("%s accepted %s store to an undeclared FP slot", arch, op)
+			}
+		}
+	}
+}
diff --git a/amd64_register_bool_result.go b/amd64_register_bool_result.go
new file mode 100644
index 000000000..ffe3f256e
--- /dev/null
+++ b/amd64_register_bool_result.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import "strings"
+
+func x86RegisterBoolResultNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" || !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return false
+	}
+	if sig.Ret == I1 {
+		return true
+	}
+	for _, slot := range sig.Frame.Results {
+		if slot.Type == I1 {
+			return true
+		}
+	}
+	return false
+}
+
+// Canonicality is a second must-fact beside byte initialization. This helper
+// does not establish reads, FLAGS, memory or entry authority; the caller first
+// executes the independent complete typed source transfer and then intersects
+// these facts with its actual initialized GP bytes. Unmodeled effects revoke
+// facts, never invent a value. Original Op/Raw/certificate identity is retained.
+func x86RegisterCanonicalBytesAfter(original Instr, before [16]uint8, arch string) [16]uint8 {
+	if next, known := x86SegmentQueryCanonicalBytesAfter(original, before, arch); known {
+		return next
+	}
+	ins := x86SourceMoveInstruction(original, arch)
+	next := before
+	if _, known, err := x86DuplicateMoveProperties(ins.Op, ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+		return next // No GP write; vector results cannot create canonical bool facts.
+	}
+	read := func(operand Operand, width int64) uint8 {
+		if operand.Kind == OpImm && operand.ImmRaw == "" && !operand.ImmIsFloat {
+			return fixedLocalConstantBooleans(operand.Imm, width)
+		}
+		if operand.Kind == OpReg {
+			if root, _, valid := x86ResultGP(operand.Reg, width, arch); valid {
+				return before[root] >> fixedLocalBooleanShift(operand.Reg) & uint8((uint16(1)<<uint(width))-1)
+			}
+		}
+		return 0 // Neither numerical memory bytes nor a vector imply 0/1.
+	}
+	write := func(reg Reg, width int64, canonical uint8) {
+		root, mask, valid := x86ResultGP(reg, width, arch)
+		if !valid {
+			return
+		}
+		canonical <<= fixedLocalBooleanShift(reg)
+		if width == 4 && arch == "amd64" {
+			mask, canonical = 255, canonical|240
+		}
+		next[root] = next[root]&^mask | canonical&mask
+	}
+	if form, width, known, err := x86SwapProperties(ins, arch); known {
+		if err != nil || !x86ResultNamedPredicateInstruction(ins) {
+			return [16]uint8{}
+		}
+		if form.nop {
+			return next
+		}
+		write(form.register.Reg, width, read(form.other, width))
+		if form.other.Kind == OpReg {
+			write(form.other.Reg, width, read(form.register, width))
+		}
+		return next // Reads use the original array, including overlapping AH/AL.
+	}
+	if bits, known, err := x86ByteSwapProperties(ins.Op, ins, arch); known {
+		if err != nil {
+			return [16]uint8{}
+		}
+		width := int64(bits / 8)
+		write(ins.Args[0].Reg, width, x86ByteSwapByteMask(read(ins.Args[0], width), bits))
+		return next
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known {
+		if err == nil && form.destination.Kind == OpReg {
+			write(form.destination.Reg, 1, 1)
+		}
+		return next
+	}
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 && len(ins.Args) == 2 {
+		if ins.Args[1].Kind == OpReg {
+			// Mixed high-byte/REX source spellings need the actual physical
+			// view; do not let a legacy alias manufacture a bool result.
+			if width == 1 && x86CompareExchangeHasREXByteView(x86CompareExchangeForm{source: ins.Args[0], destination: ins.Args[1]}) {
+				for _, operand := range ins.Args {
+					if operand.Kind == OpReg && fixedLocalBooleanShift(operand.Reg) != 0 {
+						return [16]uint8{}
+					}
+				}
+			}
+			write(ins.Args[1].Reg, width, read(ins.Args[0], width))
+		}
+		return next
+	}
+	if form, known, err := x86ScalarExtensionProperties(ins.Op, ins, arch); known {
+		if err != nil {
+			return [16]uint8{}
+		}
+		from, to := int64(form.spec.sourceBits/8), int64(form.spec.destinationBits/8)
+		canonical := read(form.source, from)
+		// Every zero-extended high byte is zero. Sign extension also yields
+		// zero high bytes when the original highest byte itself is 0/1.
+		if !form.spec.signed || canonical&(1<<uint(from-1)) != 0 {
+			for index := from; index < to; index++ {
+				canonical |= 1 << uint(index)
+			}
+		}
+		write(form.result, to, canonical)
+		return next
+	}
+	if form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch); known {
+		if err != nil {
+			return [16]uint8{}
+		}
+		width := int64(form.bits / 8)
+		write(form.destination.Reg, width, read(form.source, width)&read(form.destination, width))
+		return next
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known {
+		if err != nil {
+			return [16]uint8{}
+		}
+		if form.destination.Kind != OpReg {
+			return next
+		}
+		width := int64(form.spec.bits / 8)
+		canonical := uint8(0)
+		if x86ScalarXORZeroRegister(form, width) {
+			canonical = uint8((uint16(1) << uint(width)) - 1)
+		} else {
+			first, previous := read(form.source, width), read(form.destination, width)
+			switch form.spec.stem {
+			case "AND":
+				canonical = first | previous // Any 0/1 byte bounds the AND.
+			case "OR", "XOR":
+				canonical = first & previous
+			}
+		}
+		write(form.destination.Reg, width, canonical)
+		return next
+	}
+	if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known {
+		if err == nil {
+			return next
+		} // Only FLAGS are written.
+		return [16]uint8{}
+	}
+	if effect, known, err := x86TypedCounterControlByteEffect(ins.Op, ins, arch); known {
+		if err != nil {
+			return [16]uint8{}
+		}
+		for _, operand := range effect.operands {
+			if operand.write && operand.operand.Kind == OpReg {
+				write(operand.operand.Reg, operand.width, 0)
+			}
+		}
+		return next // A decrement supplies NUM, never a newly canonical count.
+	}
+	if ins.Op == "NOP" || ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+		return next
+	}
+	if _, known, err := x86DirectiveProperties(ins); known && err == nil {
+		return next
+	}
+	if form, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+		for _, output := range x86ImplicitDivideWrites(form) {
+			write(output.operand.Reg, output.width, 0)
+		}
+		return next // A quotient/remainder is numerical, never a newly canonical bool.
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if operand.write && operand.operand.Kind == OpReg {
+				write(operand.operand.Reg, operand.width, 0)
+			}
+		}
+		return next // Complete effects preserve only genuinely unwritten GP bytes.
+	}
+	return [16]uint8{}
+}
diff --git a/amd64_register_bool_result_runtime_test.go b/amd64_register_bool_result_runtime_test.go
new file mode 100644
index 000000000..7e409dfc2
--- /dev/null
+++ b/amd64_register_bool_result_runtime_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var amd64RegisterBoolConditions = strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS")
+
+// This encoder fixture needs Go's explicit standalone runtime assembler
+// permission for an ABIInternal selector. It is NOT a captured SDK source or
+// an authenticated native Go caller. The complete original function bytes are
+// executed below through an independently declared AX/BX adapter.
+func amd64RegisterBoolOriginalBytes(t *testing.T, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	args := append(arm64ClosureGoAsmArgs(t), "-S", "-o", object, input)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "GOTOOLCHAIN=local", "GOFLAGS=")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, "amd64"); failure != nil {
+		t.Fatalf("complete original Go ABIInternal encoder fixture: %v\n%s", failure, output)
+	}
+	size := -1
+	var code []byte
+	for _, line := range strings.Split(string(output), "\n") {
+		fields := strings.Fields(line)
+		if strings.Contains(line, " STEXT ") {
+			if size != -1 {
+				t.Fatal("encoder fixture must retain exactly one complete function")
+			}
+			for _, field := range fields {
+				if strings.HasPrefix(field, "size=") {
+					size, err = strconv.Atoi(strings.TrimPrefix(field, "size="))
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+		}
+		if len(fields) >= 1 && fields[0] == "rel" {
+			t.Fatal("standalone byte execution cannot invent an external relocation", line)
+		}
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		if err != nil || int(offset) != len(code) {
+			t.Fatal("incomplete/noncontiguous original function bytes", line)
+		}
+		for index, field := range fields[1:] {
+			if index == 16 || len(field) != 2 {
+				break
+			}
+			value, err := strconv.ParseUint(field, 16, 8)
+			if err != nil {
+				break
+			}
+			code = append(code, byte(value))
+		}
+	}
+	if size <= 0 || len(code) != size {
+		t.Fatalf("original function byte extent: got %d, actual STEXT size %d", len(code), size)
+	}
+	return code
+}
+
+func amd64RegisterBoolOriginalAdapter(t *testing.T, triple string, index int, source string) string {
+	t.Helper()
+	var encoded []string
+	for _, value := range amd64RegisterBoolOriginalBytes(t, source) {
+		encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+	}
+	prefix, inputA, inputB, observations := "", "%rdi", "%rsi", "%rdx"
+	if strings.Contains(triple, "darwin") {
+		prefix = "_"
+	}
+	if strings.Contains(triple, "windows") {
+		inputA, inputB, observations = "%rcx", "%rdx", "%r8"
+	}
+	core, adapter := fmt.Sprintf("%sOriginalBody%d", prefix, index), fmt.Sprintf("%sOriginal%d", prefix, index)
+	// C preserves RBX/R12-R15; the fixture uses only AX/BX/CX/DX. Observe
+	// untouched stack words and independent GP canaries, not unspecified AX
+	// upper bytes interpreted as a bool or a physical Go entry guarantee.
+	text := ".text\n" + core + ":\n.byte " + strings.Join(encoded, ",") + "\n.globl " + adapter + "\n" + adapter + ":\n" +
+		"pushq %rbx\npushq %r12\npushq %r13\npushq %r14\npushq %r15\nsubq $32,%rsp\n" +
+		"movq " + observations + ",%r12\nmovq " + inputA + ",%rax\nmovq " + inputB + ",%rbx\n" +
+		"movabsq $0x123456789abcdef0,%r13\nmovabsq $0xfedcba9876543210,%r14\nmovabsq $0x876543210fedcba9,%r15\n" +
+		"movabsq $0x5a5a5a5a5a5a5a5a,%r10\nmovq %r10,0(%rsp)\nmovq %r10,8(%rsp)\n" +
+		"movabsq $0x6b6b6b6b6b6b6b6b,%r10\nmovq %r10,16(%rsp)\nmovq %r10,24(%rsp)\ncallq " + core + "\n" +
+		"movq 0(%rsp),%r10\nmovq %r10,0(%r12)\nmovq 8(%rsp),%r10\nmovq %r10,8(%r12)\n" +
+		"movq 16(%rsp),%r10\nmovq %r10,16(%r12)\nmovq 24(%rsp),%r10\nmovq %r10,24(%r12)\n" +
+		"movq %r13,32(%r12)\nmovq %r14,40(%r12)\nmovq %r15,48(%r12)\n" +
+		"addq $32,%rsp\npopq %r15\npopq %r14\npopq %r13\npopq %r12\npopq %rbx\nretq\n"
+	return fmt.Sprintf("__asm__(%q);\nextern uint64_t Original%d(uint64_t,uint64_t,uint64_t*);\n", text, index)
+}
+
+func TestAMD64RegisterBoolThreeTargetOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var bodies []string
+	for _, op := range amd64RegisterBoolConditions {
+		bodies = append(bodies, "CMPQ AX,BX\n"+op+" AX")
+	}
+	for op := range amd64ScalarExtensionMoveSpecs {
+		bodies = append(bodies, "MOVQ $257,CX\n"+string(op)+" CX,AX")
+	}
+	for op := range x86ConditionalMoveSpecs {
+		bodies = append(bodies, "CMPQ AX,BX\nMOVQ $1,CX\nMOVQ $0,AX\n"+string(op)+" CX,AX")
+	}
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		bodies = append(bodies, alias+" $257,AX")
+	}
+	var source, declarations strings.Builder
+	for index, body := range bodies {
+		name := fmt.Sprintf("Bool%d", index)
+		source.WriteString(strings.ReplaceAll(amd64RegisterBoolSource(body), "·view", "·"+name))
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) bool\n", name)
+	}
+	requireAMD64RegisterResultGoObject(t, source.String())
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal(triple, api, err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				x86ResultInitializationObject(t, llc, triple, input, "register-bool")
+			}
+		}
+	}
+	t.Log("all16 SETcc, all14 extensions, all48 CMOV rows and all3 MOVQ source spellings; full originals, three APIs/targets and O0/O2 objects")
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64RegisterCanonicalBoolInstructionBytes(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var source, declarations, originals, wrappers, prototypes, checks strings.Builder
+	type fixture struct{ body, expected string }
+	var rows []fixture
+	for index, op := range amd64RegisterBoolConditions {
+		rows = append(rows, fixture{"CMPQ AX,BX\n" + op + " AX", fmt.Sprintf("(a&~UINT64_C(255))|want[%d]", index)})
+	}
+	rows = append(rows, []fixture{
+		{"MOVB $0,AX", "a&~UINT64_C(255)"}, {"MOVB $1,AX", "(a&~UINT64_C(255))|1"},
+		{"MOVW $257,AX", "(a&~UINT64_C(65535))|257"}, {"MOVL $257,AX", "257"},
+		{"MOVQ $257,AX", "257"}, {"MOVD $257,AX", "257"}, {"MOVDQ2Q $257,AX", "257"},
+		{"XORQ AX,AX", "0"}, {"ANDQ $1,AX", "a&1"}, {"ANDB $1,AX", "(a&~UINT64_C(255))|(a&1)"},
+		{"CMPQ AX,BX\nSETNE BX\nMOVB BX,AX", "(a&~UINT64_C(255))|want[10]"},
+		{"CMPQ AX,BX\nSETEQ BX\nMOVBQZX BX,AX", "want[2]"},
+		{"MOVB $1,CH\nMOVB CH,AL", "(a&~UINT64_C(255))|1"},
+		{"MOVW $257,CX\nMOVB CH,AL", "(a&~UINT64_C(255))|1"},
+		{"MOVB $0,CX\nMOVB $1,DX\nORB DX,CX\nMOVB CX,AX", "(a&~UINT64_C(255))|1"},
+		{"MOVB $2,AX\nANDB $1,AX", "a&~UINT64_C(255)"},
+	}...)
+	for index, row := range rows {
+		name := fmt.Sprintf("Bool%d", index)
+		original := strings.ReplaceAll(amd64RegisterBoolSource(row.body), "·view", "·"+name)
+		source.WriteString(original)
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) bool\n", name)
+		originals.WriteString(amd64RegisterBoolOriginalAdapter(t, execution.triple, index, original))
+		fmt.Fprintf(&wrappers, "\ndefine i32 @Probe%d(i64 %%a,i64 %%b) {\n %%v=call i1 @%s(i64 %%a,i64 %%b)\n %%r=zext i1 %%v to i32\n ret i32 %%r\n}\n", index, name)
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(uint64_t,uint64_t);\n", index)
+		fmt.Fprintf(&checks, "{uint64_t observed[7]={0},raw=Original%d(a,b,observed),expected=%s;uint32_t logical=Probe%d(a,b);\n"+
+			"if(raw!=expected || (raw&255)>1 || logical!=(raw&255) || !canaries(observed)){fprintf(stderr,\"row=%d a=%%llx b=%%llx raw=%%llx expected=%%llx LLVM=%%u\\n\",(unsigned long long)a,(unsigned long long)b,(unsigned long long)raw,(unsigned long long)expected,logical);return 1;}}\n", index, row.expected, index, index)
+	}
+	// Noncanonical bytes are genuinely executed only by the raw observer.
+	// They must remain Context for every logical translator API, not be
+	// compared after lossy truncation to i1 (2->0, 3->1).
+	for offset, value := range []int{2, 3, 255} {
+		index := len(rows) + offset
+		original := amd64RegisterBoolSource(fmt.Sprintf("MOVB $%d,AX", value))
+		originals.WriteString(amd64RegisterBoolOriginalAdapter(t, execution.triple, index, original))
+		fmt.Fprintf(&checks, "{uint64_t observed[7]={0},raw=Original%d(a,b,observed);if(raw!=((a&~UINT64_C(255))|%d) || !canaries(observed))return 2;}\n", index, value)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + originals.String() + prototypes.String() + `
+static int canaries(const uint64_t *p) {
+    return p[0]==UINT64_C(0x5a5a5a5a5a5a5a5a)&&p[1]==p[0]&&
+        p[2]==UINT64_C(0x6b6b6b6b6b6b6b6b)&&p[3]==p[2]&&
+        p[4]==UINT64_C(0x123456789abcdef0)&&p[5]==UINT64_C(0xfedcba9876543210)&&
+        p[6]==UINT64_C(0x876543210fedcba9);
+}
+int main(void) {
+    const uint64_t inputs[]={0,1,2,3,UINT64_C(0x8000000000000000),UINT64_C(0x7fffffffffffffff),UINT64_MAX};
+    unsigned seen[16]={0};
+    for(unsigned sample=0;sample<7;sample++) for(uint64_t b=0;b<4;b++) {
+        uint64_t a=inputs[sample],r=a-b;
+        unsigned cf=a<b,zf=r==0,sf=r>>63,of=((a^b)&(a^r))>>63;
+        uint8_t parity=r;parity^=parity>>4;parity^=parity>>2;parity^=parity>>1;
+        unsigned pf=(parity&1)==0;
+        unsigned want[]={!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf};
+        for(unsigned i=0;i<16;i++)seen[i]|=1U<<want[i];
+` + checks.String() + `
+    }
+    for(unsigned i=0;i<16;i++) if(seen[i]!=3)return 3;
+    puts("complete Go encoder bytes/AX-BX adapter; canonical low byte, raw upper bytes and stack/GP canaries; LLVM i1-to-i32 only");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, optimized := range []bool{false, true} {
+			input, level := ir+wrappers.String(), "-O0"
+			if optimized {
+				input, level = x86MulDivRoundOptimize(t, input), "-O2"
+			}
+			t.Logf("%s/%s: %s", api, level, execution.compileAndRunLLVM(t, "register-canonical-bool", input, driver, level))
+		}
+	}
+	t.Log("32 canonical functions x 28 inputs x 3 APIs x O0/O2; all16 conditions both outcomes; three noncanonical raw-byte controls. Not a native Go caller/C _Bool ABI certificate.")
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64CanonicalBoolByteRepresentation(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var assembly, declarations, rows strings.Builder
+	for index, op := range amd64RegisterBoolConditions {
+		fmt.Fprintf(&assembly, "TEXT ·Bool%d(SB),4,$0-17\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nCMPQ AX,BX\n%s CX\nMOVB CX,ret+16(FP)\nRET\n", index, op)
+		fmt.Fprintf(&declarations, "func Bool%d(a,b uint64) bool\n", index)
+		fmt.Fprintf(&rows, "{Bool%d,Observe%d},\n", index, index)
+	}
+	for index, value := range []int{2, 3, 255} {
+		fmt.Fprintf(&assembly, "TEXT ·Bool%d(SB),4,$0-17\nMOVB $%d,ret+16(FP)\nRET\n", 16+index, value)
+		fmt.Fprintf(&declarations, "func Bool%d(a,b uint64) bool\n", 16+index)
+	}
+	for index := 0; index < 19; index++ {
+		fmt.Fprintf(&declarations, "func Observe%d(a,b uint64)(raw,adjacent,input uint64)\n", index)
+		fmt.Fprintf(&assembly, `TEXT ·Observe%d(SB),4,$32-40
+MOVQ a+0(FP),AX
+MOVQ AX,0(SP)
+MOVQ b+8(FP),AX
+MOVQ AX,8(SP)
+MOVQ $0x5a5a5a5a5a5a5a5a,AX
+MOVQ AX,16(SP)
+MOVQ $0x6b6b6b6b6b6b6b6b,AX
+MOVQ AX,24(SP)
+CALL ·Bool%d(SB)
+MOVQ 16(SP),AX
+MOVQ AX,raw+16(FP)
+MOVQ 24(SP),AX
+MOVQ AX,adjacent+24(FP)
+MOVQ 0(SP),AX
+MOVQ AX,input+32(FP)
+RET
+`, index, index)
+	}
+	oracle := `package framefixture
+import "testing"
+func TestOriginal(t *testing.T) {
+    rows:=[]struct{call func(uint64,uint64)bool;observe func(uint64,uint64)(uint64,uint64,uint64)}{
+` + rows.String() + `}
+    inputs:=[]uint64{0,1,2,3,1<<63,(1<<63)-1,^uint64(0)}
+    seen:=[16]uint8{}
+    for _,a:=range inputs {for b:=uint64(0);b<4;b++ {
+        r:=a-b;cf,zf,sf:=a<b,r==0,r>>63!=0;of:=((a^b)&(a^r))>>63!=0
+        parity:=byte(r);parity^=parity>>4;parity^=parity>>2;parity^=parity>>1;pf:=parity&1==0
+        want:=[]bool{!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf}
+        for i,row:=range rows {
+            expected:=uint64(0);if want[i]{expected=1}
+            if row.call(a,b)!=want[i]{t.Fatalf("canonical Go bool caller row %d",i)}
+            raw,adjacent,input:=row.observe(a,b)
+            if raw!=0x5a5a5a5a5a5a5a00|expected||adjacent!=0x6b6b6b6b6b6b6b6b||input!=a{t.Fatalf("raw bool byte/canaries row %d: %x %x %x",i,raw,adjacent,input)}
+            seen[i]|=1<<expected
+        }
+        for i,observe:=range []func(uint64,uint64)(uint64,uint64,uint64){Observe16,Observe17,Observe18}{
+            raw,adjacent,input:=observe(a,b);value:=[]uint64{2,3,255}[i]
+            if raw!=0x5a5a5a5a5a5a5a00|value||adjacent!=0x6b6b6b6b6b6b6b6b||input!=a{t.Fatal("noncanonical raw byte was normalized")}
+        }
+    }}
+    for i,outcomes:=range seen{if outcomes!=3{t.Fatalf("SETcc row %d lacks both outcomes",i)}}
+}
+`
+	fixedLocalPackedRunOriginal(t, execution, assembly.String(), declarations.String(), oracle, true)
+	t.Logf("actual %s/amd64 owned Go ABI0 bool caller/return-byte representation; all16 SETcc outcomes and 2/3/255 raw-byte controls. Separate from ABIInternal caller authorization.", runtime.GOOS)
+}
diff --git a/amd64_register_bool_result_test.go b/amd64_register_bool_result_test.go
new file mode 100644
index 000000000..3709ea387
--- /dev/null
+++ b/amd64_register_bool_result_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func amd64RegisterBoolSource(body string) string {
+	return "TEXT ·view<ABIInternal>(SB),4,$0-17\n" + body + "\nRET\n"
+}
+
+func TestAMD64RegisterBoolCanonicalResultThreeAPIs(t *testing.T) {
+	for _, body := range []string{
+		"MOVB $0,AX", "MOVB $1,AX", "MOVW $257,AX", "MOVL $257,AX", "MOVQ $257,AX",
+		"MOVD $257,AX", "MOVDQ2Q $257,AX", "XORQ AX,AX", "ANDQ $1,AX", "ANDB $1,AX",
+		"CMPQ AX,BX\nSETEQ AX", "CMPQ AX,BX\nSETNE BX\nMOVB BX,AX",
+		"CMPQ AX,BX\nSETEQ BX\nMOVBQZX BX,AX",
+		"MOVB $1,CH\nMOVB CH,AL", "MOVW $257,CX\nMOVB CH,AL",
+		"MOVB $0,CX\nMOVB $1,DX\nORB DX,CX\nMOVB CX,AX",
+	} {
+		t.Run(body, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, amd64RegisterBoolSource(body), "func view(a,b uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Errorf("%s: proven canonical low result byte rejected: %v", api, err)
+				}
+			}
+		})
+	}
+	for _, op := range strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS") {
+		t.Run(op, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, amd64RegisterBoolSource("CMPQ AX,BX\n"+op+" AX"), "func view(a,b uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Errorf("%s: actual Go SETcc canonical byte rejected: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterBoolInitializedIsNotCanonical(t *testing.T) {
+	for name, body := range map[string]string{
+		"two": "MOVB $2,AX", "three": "MOVB $3,AX", "ff": "MOVB $255,AX",
+		"linear-two": "MOVQ $2,AX", "linear-three": "MOVL $3,AX", "linear-ff": "MOVQ $255,AX",
+		"incoming-integer": "MOVB AX,AX", "unknown-flags": "SETEQ AX", "wrong-byte": "MOVB $1,AH",
+		"widened-unknown-argument": "MOVQ $0,BX\nMOVB $1,AX\nCMPQ AX,BX\nSETEQ AX",
+		"noncanonical-overwrite":   "MOVB $1,AX\nINCB AX",
+		"vector-overwrite":         "MOVB $1,AX\nPXOR X0,X0\nMOVQ X0,AX",
+		"one-noncanonical-edge":    "CMPQ AX,BX\nJE done\nMOVB $2,AX\nJMP exit\ndone:\nMOVB $1,AX\nexit:",
+		"raw":                      "BYTE $0x90\nMOVB $1,AX", "FP-result": "MOVB $1,ret+16(FP)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			declaration := "func view(a,b uint64) bool\n"
+			if name == "widened-unknown-argument" {
+				declaration = "func view(a uint8,b uint64) bool\n"
+				body = strings.ReplaceAll(body, "MOVB $1,AX\n", "")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, amd64RegisterBoolSource(body), declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: arbitrary/unknown/noncanonical result gained an i1 transport: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterBoolDoesNotInitializeUpperGPBytes(t *testing.T) {
+	for _, move := range []string{"MOVB", "MOVW"} {
+		pkg := mustGoPackage(t, "registerbool", "package registerbool\nfunc view() uint64\n")
+		sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := Parse(ArchAMD64, "TEXT ·view<ABIInternal>(SB),4,$0-8\n"+move+" $1,AX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		consumer := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: sig, goarch: "amd64"}
+		if err := consumer.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: a canonical byte manufactured unspecified upper result bytes: %v", move, err)
+		}
+	}
+	for _, declaration := range []string{"func view(a bool) bool\n", "func view(a uint64) (bool,bool)\n"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			_, err := x86ScalarFPBitViewAPI(t, amd64RegisterBoolSource("MOVB $1,AX"), declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if api == "Go" && declaration == "func view(a bool) bool\n" {
+				// A complete GoModule now supplies its own call-local typed
+				// argument plan. It initializes only the declared low byte;
+				// the raw APIs and multiple-result boundary remain unchanged.
+				// VirtualBoolPortableValues separately executes both bool values.
+				if err != nil {
+					t.Errorf("complete typed bool argument lost its declaration binding: %v", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s: unbound bool argument/aggregate result was inferred: %v", api, err)
+			}
+		}
+	}
+}
+
+func TestAMD64RegisterBoolCanonicalTypedTransferFamilies(t *testing.T) {
+	check := func(body string, canonical bool) {
+		t.Helper()
+		for _, api := range []string{"text", "module", "Go"} {
+			_, err := x86ScalarFPBitViewAPI(t, amd64RegisterBoolSource(body), "func view(a,b uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if canonical && err != nil || !canonical && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s canonical=%v: %s: %v", api, canonical, body, err)
+			}
+		}
+	}
+	// The complete official source extension family, including the unusual
+	// word-read ymb rows, composes with physical per-byte facts, not type/name
+	// exemptions. A known low byte is retained; sign/zero extension cannot
+	// make an arbitrary source low byte canonical.
+	for op := range amd64ScalarExtensionMoveSpecs {
+		t.Run(string(op), func(t *testing.T) {
+			check("MOVQ $257,CX\n"+string(op)+" CX,AX", true)
+			check("MOVQ $258,CX\n"+string(op)+" CX,AX", false)
+		})
+	}
+	for _, suffix := range []string{"B", "W", "L", "Q"} {
+		for _, op := range []string{"AND", "OR", "XOR"} {
+			t.Run(op+suffix, func(t *testing.T) {
+				check("MOVQ $1,CX\n"+op+suffix+" CX,AX", op == "AND")
+				check("MOVQ $1,CX\nMOVQ $0,AX\n"+op+suffix+" CX,AX", true)
+				check("MOVQ $2,CX\nMOVQ $6,AX\n"+op+suffix+" CX,AX", false)
+			})
+		}
+	}
+	for op := range x86ConditionalMoveSpecs {
+		t.Run(string(op), func(t *testing.T) {
+			check("CMPQ AX,BX\nMOVQ $1,CX\nMOVQ $0,AX\n"+string(op)+" CX,AX", true)
+			check("CMPQ AX,BX\nMOVQ $2,CX\nMOVQ $0,AX\n"+string(op)+" CX,AX", false)
+			check("CMPQ AX,BX\nMOVQ $1,CX\nMOVQ $2,AX\n"+string(op)+" CX,AX", false)
+			check("MOVQ $1,CX\nMOVQ $0,AX\n"+string(op)+" CX,AX", false)
+		})
+	}
+	check("CMPQ AX,BX\nJE yes\nMOVB $0,AX\nJMP done\nyes:\nMOVB $1,AX\ndone:", true)
+	check("MOVB $1,AH\nMOVB AH,R8\nMOVB R8,AX", false) // Actual REX is not AH.
+	check("MOVB $1,CH\nMOVBQSX CH,AX", false)          // Actual REX is not CH.
+}
+
+func TestAMD64RegisterBoolCanonicalFactJoinsAndIdentity(t *testing.T) {
+	first := x86ResultState{}
+	first.gp[0], first.canonicalGP[0] = 255, 255
+	second := first
+	second.canonicalGP[0] = 254
+	if joined := first.intersect(second); joined.gp[0] != 255 || joined.canonicalGP[0] != 254 {
+		t.Fatal("canonicality must intersect independently of initialized bytes", joined)
+	}
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		file, err := Parse(ArchAMD64, amd64RegisterBoolSource(alias+" $257,AX"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0].Instrs[1]
+		facts := x86RegisterCanonicalBytesAfter(original, [16]uint8{}, "amd64")
+		if facts[0] != 255 || original.Op != Op(alias) || original.Raw != file.Funcs[0].Instrs[1].Raw {
+			t.Fatal("source-only dispatch must preserve original identity and exact canonical bytes", alias, facts)
+		}
+	}
+}
diff --git a/amd64_register_result.go b/amd64_register_result.go
new file mode 100644
index 000000000..ef0a2aedd
--- /dev/null
+++ b/amd64_register_result.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+)
+
+func amd64IntegerRegisterResultBytes(typ LLVMType) int64 {
+	switch typ {
+	case I8:
+		return 1
+	case I16:
+		return 2
+	case I32:
+		return 4
+	case I64:
+		return 8
+	}
+	return 0
+}
+
+// This restriction-only selector reads the declared return type, never Frame
+// validity or the instruction stream. A missing/malformed layout must still
+// reach the same cached complete-source check as an ordinary valid tuple.
+func amd64RegisterTupleResultNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" || !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return false
+	}
+	fields, tuple := parseLiteralStructFields(sig.Ret)
+	if !tuple || len(fields) < 2 {
+		return false
+	}
+	for _, field := range fields {
+		if amd64IntegerRegisterResultBytes(field) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// A flattened LLVM return does not retain Go's whole-value assignment rule.
+// Consume the already selected declaration once: structs recurse, arrays with
+// more than one element need stack transport, and every complete result must
+// fit the remaining numerical register bank. This grants no storage access.
+func goAMD64NumericalRegisterResults(fn *types.Func) bool {
+	sig, ok := fn.Type().(*types.Signature)
+	if !ok || sig.Recv() != nil || sig.Variadic() {
+		return false
+	}
+	var leaves func(types.Type) (int, bool)
+	leaves = func(typ types.Type) (int, bool) {
+		switch typ := typ.Underlying().(type) {
+		case *types.Basic:
+			return 1, typ.Info()&types.IsInteger != 0
+		case *types.Array:
+			if typ.Len() == 0 {
+				return 0, true
+			}
+			if typ.Len() == 1 {
+				return leaves(typ.Elem())
+			}
+		case *types.Struct:
+			count := 0
+			for index := 0; index < typ.NumFields(); index++ {
+				n, valid := leaves(typ.Field(index).Type())
+				if !valid || n > 9-count {
+					return 0, false
+				}
+				count += n
+			}
+			return count, true
+		}
+		return 0, false
+	}
+	used := 0
+	for index := 0; index < sig.Results().Len(); index++ {
+		n, valid := leaves(sig.Results().At(index).Type())
+		if !valid || n > 9-used {
+			return false // Do not partially assign a result that belongs on the stack.
+		}
+		used += n
+	}
+	return true
+}
+
+// This lowering-only query observes the already modeled scalar register entry,
+// not ABI0 FP fields. The source must explicitly select ABIInternal. It grants
+// neither physical Go entry/closure/TLS state nor incoming spill-frame backing.
+// See Go's cmd/compile/abi-internal.md, amd64 integer register assignment.
+func checkAMD64RegisterResultInitialization(fn Func, sig FuncSig, transfer x86ResultSourceTransfer) error {
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: amd64 register result initialization: %s", ErrProbeNeedsContext, reason)
+	}
+	registers := [...]Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"}
+	if !strings.HasSuffix(fn.Sym, "<ABIInternal>") || len(sig.ArgRegs) != 0 ||
+		sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		sig.WASMContext != "" || sig.WASMNative || sig.amd64GoArguments == nil && len(sig.Args) > len(registers) ||
+		len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil {
+		return fail("requires a complete ordinary scalar register entry")
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+			ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return fail("raw/native source needs its separate entry contract")
+		}
+	}
+	resultWidth := amd64IntegerRegisterResultBytes(sig.Ret)
+	if sig.Ret == I1 {
+		resultWidth = 1
+	}
+	var resultWidths []int64
+	if sig.Ret == Void {
+		if len(sig.Frame.Results) != 0 {
+			return fail("Void entry cannot declare a result transport")
+		}
+	} else if fields, tuple := parseLiteralStructFields(sig.Ret); tuple {
+		if len(fields) < 2 || len(fields) > len(registers) || len(sig.Frame.Results) != len(fields) {
+			return fail("requires one complete flat integer register tuple")
+		}
+		resultWidths = make([]int64, len(fields))
+		for index, typ := range fields {
+			result := sig.Frame.Results[index]
+			bytes := amd64IntegerRegisterResultBytes(typ)
+			if bytes == 0 || result.Type != typ || result.Index != index || result.Field != -1 || len(result.Fields) != 0 {
+				return fail("tuple result transport differs from its integer signature")
+			}
+			resultWidths[index] = bytes
+		}
+	} else {
+		if resultWidth == 0 || len(sig.Frame.Results) != 1 {
+			return fail("requires one complete integer register result")
+		}
+		result := sig.Frame.Results[0]
+		if result.Type != sig.Ret || result.Index != 0 || result.Field != -1 || len(result.Fields) != 0 {
+			return fail("result transport differs from the scalar signature")
+		}
+		resultWidths = []int64{resultWidth}
+	}
+	initial := x86ResultState{}
+	if entry := sig.amd64GoArguments; entry != nil {
+		if !entry.valid(fn, sig, "amd64") {
+			return fail("typed argument carrier lost its live original compiler/source binding")
+		}
+		var valid bool
+		initial, valid = amd64GoArgumentInitialState(entry.plan)
+		if !valid {
+			return fail("invalid declared typed argument carrier bytes")
+		}
+	} else {
+		for index, typ := range sig.Args {
+			bytes := amd64IntegerRegisterResultBytes(typ)
+			if typ == Ptr {
+				bytes = 8
+			}
+			if bytes == 0 {
+				return fail("aggregate, floating, boolean or spilled argument needs its own register contract")
+			}
+			reg, mask, valid := x86ResultGP(registers[index], bytes, "amd64")
+			if !valid {
+				return fail("invalid integer register assignment")
+			}
+			if typ == Ptr {
+				initial.pointerGP[reg] = true // Opaque identity, not numerical bytes or bounds.
+				initial.callerAddressGP[reg] = true
+			} else {
+				initial.gp[reg] = mask // Narrow inputs do not initialize the unspecified upper bytes.
+			}
+		}
+	}
+	// No FP/AUTO ownership is imported from a classic signature or TEXT size.
+	// The register role must close separately before gaining any stack storage.
+	if sig.Ret == I1 {
+		original := transfer
+		transfer = func(pc int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			if isX86RawDirective(ins) {
+				return false
+			}
+			before := state.canonicalGP
+			if !original(pc, ins, state, owned, resultOffset, arch) {
+				return false
+			}
+			state.canonicalGP = x86RegisterCanonicalBytesAfter(ins, before, arch)
+			for index := range state.gp {
+				state.canonicalGP[index] &= state.gp[index]
+			}
+			return true
+		}
+	}
+	return checkX86ResultSourceFlow(fn, initial, nil, 0, "amd64", transfer,
+		func(state x86ResultState, pc int) error {
+			// The complete source flow still runs; only the result at RET is optional.
+			if sig.Ret == Void {
+				return nil
+			}
+			for index, bytes := range resultWidths {
+				reg, mask, _ := x86ResultGP(registers[index], bytes, "amd64")
+				if state.gp[reg]&mask != mask {
+					return fail(fmt.Sprintf("%s result bytes are not initialized on every path to RET %d", registers[index], pc))
+				}
+				if sig.Ret == I1 && state.canonicalGP[reg]&mask != mask {
+					return fail(fmt.Sprintf("AX bool result byte is not canonical zero/one on every path to RET %d", pc))
+				}
+			}
+			return nil
+		})
+}
diff --git a/amd64_register_result_runtime_test.go b/amd64_register_result_runtime_test.go
new file mode 100644
index 000000000..29a4408e9
--- /dev/null
+++ b/amd64_register_result_runtime_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func amd64RegisterResultMatrix(t *testing.T) (source, declarations, checks string) {
+	t.Helper()
+	var asm, decl, calls strings.Builder
+	count := 0
+	for _, family := range []struct {
+		suffix string
+		width  int
+	}{{"B", 1}, {"W", 2}, {"D", 4}, {"Q", 8}} {
+		for _, prefix := range []string{"", "V"} {
+			for lane := 0; lane < 16/family.width; lane++ {
+				name := fmt.Sprint("lane", count)
+				asm.WriteString(strings.ReplaceAll(amd64RegisterLaneFixture(prefix+"PINSR"+family.suffix, lane), "·view", "·"+name))
+				fmt.Fprintf(&decl, "func %s(value,seed uint64) uint64\n", name)
+				fmt.Fprintf(&calls, "if(check(%s,%d,%d)){fprintf(stderr,\"%s failed\\n\");return 1;}\n", name, family.width, lane, name)
+				count++
+			}
+		}
+	}
+	if count != 60 {
+		t.Fatal("incomplete register-entry scalar insertion matrix", count)
+	}
+	return asm.String(), decl.String(), calls.String()
+}
+
+func requireAMD64RegisterResultGoObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "source.s"), filepath.Join(dir, "source.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	// The shared flag probe handles Go 1.20's explicit -compiling-runtime.
+	args := append(arm64ClosureGoAsmArgs(t), "-o", object, input)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, "amd64"); failure != nil {
+		t.Fatalf("original Go register-entry object: %v\n%s", failure, output)
+	}
+}
+
+func TestAMD64RegisterResultThreeTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	source, declarations, _ := amd64RegisterResultMatrix(t)
+	requireAMD64RegisterResultGoObject(t, source)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, optimized := range []bool{false, true} {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					x86ResultInitializationObject(t, llc, triple, text, "register-result")
+				}
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64RegisterResultScalarLanes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	source, declarations, checks := amd64RegisterResultMatrix(t)
+	var header strings.Builder
+	header.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	for index := 0; index < 60; index++ {
+		fmt.Fprintf(&header, "extern uint64_t lane%d(uint64_t,uint64_t);\n", index)
+	}
+	const reference = `
+static int check(uint64_t (*fn)(uint64_t,uint64_t), unsigned width, unsigned lane) {
+  const uint64_t values[] = {0, UINT64_MAX, UINT64_C(0x8070605040302010),
+                            UINT64_C(0xfedcba9876543210)};
+  for (unsigned a = 0; a < 4; a++) {
+    for (unsigned b = 0; b < 4; b++) {
+      uint8_t bytes[16] = {0};
+      uint64_t low, high;
+      memcpy(bytes, &values[b], 8);
+      memcpy(bytes + width * lane, &values[a], width);
+      memcpy(&low, bytes, 8);
+      memcpy(&high, bytes + 8, 8);
+      uint64_t got = fn(values[a], values[b]);
+      if (got != (low ^ high)) {
+        fprintf(stderr, "width=%u lane=%u a=%u b=%u got=%llx want=%llx\n",
+                width, lane, a, b, (unsigned long long)got, (unsigned long long)(low ^ high));
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+	main := header.String() + reference + "int main(void){\n" + checks + "return 0;}\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86MulDivRoundOptimize(t, text)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "register-results", triple, text, main, prefix)
+			}
+		})
+	}
+	t.Log("60 register-entry forms × 16 independent byte inputs × 3 APIs × O0/O2; portable lowering, not a physical Go call bridge")
+}
diff --git a/amd64_register_result_test.go b/amd64_register_result_test.go
new file mode 100644
index 000000000..f082834cf
--- /dev/null
+++ b/amd64_register_result_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func amd64RegisterLaneFixture(op string, lane int) string {
+	destination := "X0"
+	insert := fmt.Sprintf("%s $%d,AX,X0", op, lane)
+	if strings.HasPrefix(op, "V") {
+		destination = "X1"
+		insert += ",X1"
+	}
+	return fmt.Sprintf("TEXT ·view<ABIInternal>(SB),4,$0-24\nMOVQ BX,X0\n%s\nPEXTRQ $1,%s,CX\nMOVQ %s,AX\nXORQ CX,AX\nRET\n",
+		insert, destination, destination)
+}
+
+// The explicit register entry has no initialized ABI0 FP fields. This is the
+// same seed/insert pattern as the SDK hash routines, without AES or globals.
+func TestAMD64RegisterResultScalarLaneThreeAPIs(t *testing.T) {
+	for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ"} {
+		t.Run(op, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, amd64RegisterLaneFixture(op, 255),
+					"func view(value,seed uint64) uint64\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Errorf("%s: register result incorrectly requires ABI0 result storage: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterResultKeepsUnknownInputsAndSourceRoles(t *testing.T) {
+	const declaration = "func view(value,seed uint64) uint64\n"
+	source := amd64RegisterLaneFixture("PINSRQ", 1)
+	for name, bad := range map[string]string{
+		"ABI0":             strings.ReplaceAll(source, "<ABIInternal>", ""),
+		"unknown input":    strings.ReplaceAll(source, "$1,AX,X0", "$1,R12,X0"),
+		"unknown return":   strings.ReplaceAll(source, "RET", "MOVQ R12,AX\nRET"),
+		"ABI0 input":       strings.ReplaceAll(source, "MOVQ BX,X0", "MOVQ seed+8(FP),X0"),
+		"ABI0 result":      strings.ReplaceAll(source, "RET", "MOVQ AX,ret+16(FP)\nRET"),
+		"hidden g":         strings.ReplaceAll(source, "$1,AX,X0", "$1,R14,X0"),
+		"hidden closure":   strings.ReplaceAll(source, "$1,AX,X0", "$1,DX,X0"),
+		"physical stack":   strings.ReplaceAll(source, "MOVQ BX,X0", "MOVQ (SP),X0"),
+		"unbound call":     strings.ReplaceAll(source, "RET", "CALL ·Unknown(SB)\nRET"),
+		"path loses value": strings.ReplaceAll(source, "RET", "CMPQ BX,$0\nJE done\nMOVQ R12,AX\ndone:\nRET"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				_, err := x86ScalarFPBitViewAPI(t, bad, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: unbound entry/input/result was accepted: %v", api, err)
+				}
+			}
+		})
+	}
+	t.Run("modeled timestamp", func(t *testing.T) {
+		// Its actual AX/DX output is numerical, not an unknown source effect.
+		known := strings.ReplaceAll(source, "RET", "RDTSC\nRET")
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewAPI(t, known, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+				t.Errorf("%s: modeled timestamp return rejected: %v", api, err)
+			}
+		}
+	})
+}
+
+func TestAMD64RegisterResultIntegerWidthsAndEveryArgumentRegister(t *testing.T) {
+	registers := []string{"AX", "BX", "CX", "DI", "SI", "R8", "R9", "R10", "R11"}
+	for _, width := range []struct{ typ, insert, extract string }{
+		{"uint8", "PINSRB", "PEXTRB"}, {"uint16", "PINSRW", "PEXTRW"},
+		{"uint32", "PINSRD", "PEXTRD"}, {"uint64", "PINSRQ", "PEXTRQ"},
+	} {
+		for index, reg := range registers {
+			t.Run(fmt.Sprintf("%s/%s", width.typ, reg), func(t *testing.T) {
+				parameters := strings.TrimSuffix(strings.Repeat(width.typ+",", index+1), ",")
+				declaration := fmt.Sprintf("func view(%s) %s\n", parameters, width.typ)
+				source := fmt.Sprintf("TEXT ·view<ABIInternal>(SB),4,$0-80\n%s $0,%s,X0\n%s $0,X0,AX\nRET\n",
+					width.insert, reg, width.extract)
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Errorf("%s: initialized selected scalar bytes rejected: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64RegisterResultRejectsUnmodeledTransport(t *testing.T) {
+	source := amd64RegisterLaneFixture("PINSRQ", 1)
+	for _, declaration := range []string{
+		"func view(value uint8,seed uint64) uint64", // Unknown upper argument bytes.
+		"func view(value uint16,seed uint64) uint64",
+		"func view(value uint32,seed uint64) uint64",
+		"func view(value *uint64,seed uint64) uint64", // Pointer is not numeric.
+		"func view(value [2]uint64,seed uint64) uint64",
+		"func view(value float64,seed uint64) uint64",
+		"func view(value bool,seed uint64) uint64",
+		"func view(value,seed uint64) *uint64",
+		"func view(value,seed uint64) bool",
+		"func view(" + strings.TrimSuffix(strings.Repeat("uint64,", 10), ",") + ") uint64",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			pkg := mustGoPackage(t, "registerresult", "package registerresult\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: sig, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unmodeled transport gained register initialization:", err)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("register role escaped into the standalone ABI0 observer:", err)
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterResultCompleteTupleKeepsSeparateABI0Observer(t *testing.T) {
+	// This original source already initializes both numerical result registers:
+	// AX holds value^seed and BX retains the complete second input. Admission
+	// by the paired register observer does not initialize either ABI0 FP slot.
+	const declaration = "func view(value,seed uint64) (uint64,uint64)"
+	source := amd64RegisterLaneFixture("PINSRQ", 1)
+	pkg := mustGoPackage(t, "registerresult", "package registerresult\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		if _, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+			t.Errorf("%s: the existing complete numerical tuple was rejected: %v", api, err)
+		}
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("register result role escaped into the standalone ABI0 observer:", err)
+	}
+}
diff --git a/amd64_register_tuple_result_test.go b/amd64_register_tuple_result_test.go
new file mode 100644
index 000000000..b361e129e
--- /dev/null
+++ b/amd64_register_tuple_result_test.go
@@ -0,0 +1,350 @@
+package plan9asm
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+type amd64RegisterTupleRuntimeCase struct {
+	name, declaration string
+	results           []string
+}
+
+func amd64RegisterTupleRuntimeCases() []amd64RegisterTupleRuntimeCase {
+	return []amd64RegisterTupleRuntimeCase{
+		{name: "nine", results: []string{"uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64"}},
+		{name: "widths", results: []string{"uint8", "uint16", "uint32"}},
+		{name: "struct", results: []string{"uint64", "uint64", "uint64"}, declaration: "func tuple(seed uint64) (struct{ A,B uint64 },uint64)"},
+		{name: "array-one", results: []string{"uint64", "uint64", "uint64"}, declaration: "func tuple(seed uint64) ([1]uint64,uint64,uint64)"},
+		{name: "array-zero", results: []string{"uint64", "uint64", "uint64"}, declaration: "func tuple(seed uint64) ([0]uint64,uint64,uint64,uint64)"},
+	}
+}
+
+func amd64RegisterTupleRuntimeInputs(t *testing.T, test amd64RegisterTupleRuntimeCase, api string) (string, string) {
+	t.Helper()
+	source, declaration := amd64RegisterTupleFixture(test.results)
+	if test.declaration != "" {
+		declaration = test.declaration
+	}
+	pkg := mustGoPackage(t, "tupleruntime", "package tupleruntime\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("tuple", pkg.Types.Scope().Lookup("tuple").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fields, tuple := parseLiteralStructFields(sig.Ret)
+	if !tuple || len(fields) != len(test.results) || len(sig.Args) != 1 || sig.Args[0] != I64 {
+		t.Fatalf("runtime shim differs from the actual declared LLVM signature: %+v", sig)
+	}
+	var shim strings.Builder
+	fmt.Fprintf(&shim, "\ndefine void @observe_tuple(ptr %%out, i64 %%seed) {\n  %%value = call %s @tuple(i64 %%seed)\n", sig.Ret)
+	var widths []string
+	for index, typ := range fields {
+		bytes := amd64IntegerRegisterResultBytes(typ)
+		if bytes == 0 {
+			t.Fatal("non-numerical tuple shim field", typ)
+		}
+		widths = append(widths, fmt.Sprint(8*bytes))
+		fmt.Fprintf(&shim, "  %%v%d = extractvalue %s %%value, %d\n", index, sig.Ret, index)
+		value := fmt.Sprintf("%%v%d", index)
+		if typ != I64 {
+			fmt.Fprintf(&shim, "  %%wide%d = zext %s %s to i64\n", index, typ, value)
+			value = fmt.Sprintf("%%wide%d", index)
+		}
+		fmt.Fprintf(&shim, "  %%p%d = getelementptr i64, ptr %%out, i64 %d\n  store i64 %s, ptr %%p%d, align 8\n", index, index, value, index)
+	}
+	shim.WriteString("  ret void\n}\n")
+	main := strings.ReplaceAll(amd64RegisterTupleValueOracle, "@WIDTHS@", strings.Join(widths, ","))
+	main = strings.ReplaceAll(main, "@COUNT@", fmt.Sprint(len(fields)))
+	return ir + shim.String(), main
+}
+
+const amd64RegisterTupleValueOracle = `
+#include <stdint.h>
+#include <stdio.h>
+extern void observe_tuple(uint64_t *, uint64_t);
+int main(void) {
+  const uint64_t guard=UINT64_C(0xabcdef7654321098);
+  const unsigned widths[]={@WIDTHS@};
+  volatile uint64_t seed=UINT64_C(0xfedcba9876543210);
+  for(unsigned iteration=0;iteration<32;iteration++) {
+    uint64_t out[11];
+    for(unsigned i=0;i<11;i++) out[i]=guard;
+    if(iteration==0) seed=0;
+    else if(iteration==1) seed=UINT64_MAX;
+    else seed=seed*UINT64_C(6364136223846793005)+1;
+    observe_tuple(out+1,seed);
+    if(out[0]!=guard) return 2;
+    for(unsigned field=0;field<@COUNT@;field++) {
+      uint64_t expected=seed+UINT64_C(28800)+field;
+      if(widths[field]<64) expected&=(UINT64_C(1)<<widths[field])-1;
+      if(out[field+1]!=expected) {
+        fprintf(stderr,"field=%u got=%llx expected=%llx\n",field,(unsigned long long)out[field+1],(unsigned long long)expected);
+        return 3;
+      }
+    }
+    for(unsigned i=@COUNT@+1;i<11;i++) if(out[i]!=guard) return 4;
+  }
+  puts("REGISTER_TUPLE_TRANSLATED_PASS fields=@COUNT@ calls=32");
+  return 0;
+}
+`
+
+func TestAMD64RegisterTupleResultRuntimeArtifacts(t *testing.T) {
+	for _, test := range amd64RegisterTupleRuntimeCases() {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				ir, main := amd64RegisterTupleRuntimeInputs(t, test, api)
+				data, err := json.Marshal(map[string]string{"case": test.name, "api": api,
+					"ir": base64.StdEncoding.EncodeToString([]byte(ir)), "main": base64.StdEncoding.EncodeToString([]byte(main))})
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Log("REGISTER_TUPLE_RUNTIME_INPUT=" + string(data))
+			})
+		}
+	}
+}
+
+var amd64RegisterTupleCases = [][]string{
+	{"uint64", "uint64"},
+	{"uint64", "uint64", "uint64"},
+	{"uint64", "uint64", "uint64", "uint64"},
+	{"uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64", "uint64"},
+	{"uint8", "uint16", "uint32"},
+	{"uint16", "uint32", "uint64"},
+	{"uint32", "uint64", "uint8"},
+	{"uint64", "uint8", "uint16"},
+}
+
+// A value-preserving, already modeled instruction family selects the existing
+// mandatory register-result observer. Plain legacy MOV/RET is not that query.
+const amd64RegisterTupleAudit = "MOVQ AX,X0\nPINSRQ $0,AX,X0\nMOVQ X0,AX\n"
+
+func amd64RegisterTupleFixture(results []string) (source, declaration string) {
+	registers := []string{"AX", "BX", "CX", "DI", "SI", "R8", "R9", "R10", "R11"}
+	source = "TEXT ·tuple<ABIInternal>(SB),4,$0\nADDQ $28800,AX\n"
+	for index := 1; index < len(results); index++ {
+		source += fmt.Sprintf("MOVQ AX,%s\nADDQ $%d,%s\n", registers[index], index, registers[index])
+	}
+	return source + "RET\n", "func tuple(seed uint64) (" + strings.Join(results, ",") + ")\n"
+}
+
+func TestAMD64RegisterTupleResultOriginalGo(t *testing.T) {
+	for _, results := range amd64RegisterTupleCases {
+		t.Run(strings.Join(results, "_"), func(t *testing.T) {
+			source, _ := amd64RegisterTupleFixture(results)
+			requireAMD64RegisterResultGoObject(t, source)
+		})
+	}
+}
+
+// The existing virtual register entry must close every numerical result. It
+// does not acquire physical Go calls, stack slots, pointer bounds or an env.
+func TestAMD64RegisterTupleResultThreeAPIs(t *testing.T) {
+	for _, results := range amd64RegisterTupleCases {
+		t.Run(strings.Join(results, "_"), func(t *testing.T) {
+			source, declaration := amd64RegisterTupleFixture(results)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Errorf("%s: complete register tuple rejected: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterTupleResultObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, results := range amd64RegisterTupleCases {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(triple+"/"+strings.Join(results, "_")+"/"+api, func(t *testing.T) {
+					source, declaration := amd64RegisterTupleFixture(results)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, optimized := range []bool{false, true} {
+						body := ir
+						if optimized {
+							body = x86MulDivRoundOptimize(t, body)
+						}
+						x86ResultInitializationObject(t, llc, triple, body, "register-tuple")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestAMD64RegisterTupleResultEveryReturnRequiresEveryField(t *testing.T) {
+	const declaration = "func tuple() (uint64,uint64,uint64)\n"
+	const source = "TEXT ·tuple<ABIInternal>(SB),4,$0\nMOVQ $1,AX\nMOVQ $2,BX\nMOVQ $3,CX\nRET\n"
+	for name, changed := range map[string]string{
+		"missing second":    strings.Replace(source, "MOVQ $2,BX\n", "", 1),
+		"missing third":     strings.Replace(source, "MOVQ $3,CX\n", "", 1),
+		"partial second":    strings.Replace(source, "MOVQ $2,BX", "MOVB $2,BL", 1),
+		"unknown third":     strings.Replace(source, "MOVQ $3,CX", "MOVQ R12,CX", 1),
+		"lost on one path":  strings.Replace(source, "MOVQ $3,CX", "RDTSC\nCMPQ AX,$0\nJE done\nMOVQ $3,CX\ndone:", 1),
+		"physical stack":    strings.Replace(source, "MOVQ $3,CX", "MOVQ (SP),CX", 1),
+		"hidden closure":    strings.Replace(source, "MOVQ $3,CX", "MOVQ DX,CX", 1),
+		"hidden runtime g":  strings.Replace(source, "MOVQ $3,CX", "MOVQ R14,CX", 1),
+		"unbound call":      strings.Replace(source, "RET", "CALL ·Unknown(SB)\nRET", 1),
+		"logical FP result": strings.Replace(source, "RET", "MOVQ CX,ret+16(FP)\nRET", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				_, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if name == "unbound call" && err != nil {
+					continue // The existing unresolved declaration error is also a real rejection.
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: unclosed tuple accepted: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterTupleResultTransportGuards(t *testing.T) {
+	const source = "TEXT ·tuple<ABIInternal>(SB),4,$0\nMOVQ $1,AX\nMOVQ $2,BX\nMOVQ $3,CX\n" + amd64RegisterTupleAudit + "RET\n"
+	for _, declaration := range []string{
+		"func tuple() (*uint64,uint64,uint64)",
+		"func tuple() (float64,uint64,uint64)",
+		"func tuple() (bool,uint64,uint64)",
+		"func tuple() ([2]uint64,uint64)",
+		"func tuple() (uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64)",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: another result transport accepted: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterTupleResultGoSourceShapes(t *testing.T) {
+	for _, declaration := range []string{
+		"func tuple(seed uint64) (struct{ A,B uint64 },uint64)",
+		"func tuple(seed uint64) (struct{ Pair struct{ A,B uint64 }; C uint64 })",
+		"func tuple(seed uint64) ([1]uint64,uint64,uint64)",
+		"func tuple(seed uint64) ([0]uint64,uint64,uint64,uint64)",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			source, _ := amd64RegisterTupleFixture([]string{"uint64", "uint64", "uint64"})
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Errorf("%s: valid recursively assigned Go numerical leaves: %v", api, err)
+				}
+			}
+		})
+	}
+	for _, declaration := range []string{
+		"func tuple(seed uint64) ([2]uint64,uint64)",
+		"func tuple(seed uint64) (struct{ A [2]uint64 },uint64)",
+	} {
+		t.Run(declaration, func(t *testing.T) {
+			pkg := mustGoPackage(t, "tuplesource", "package tuplesource\n"+declaration)
+			source, _ := amd64RegisterTupleFixture([]string{"uint64", "uint64", "uint64"})
+			flattened, err := DeriveGoFuncABI0Signature("tuple", pkg.Types.Scope().Lookup("tuple").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				for _, override := range []bool{false, true} {
+					var manual func(string) (FuncSig, bool)
+					if override {
+						manual = func(string) (FuncSig, bool) { return flattened, true }
+					}
+					_, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api, manual)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s override=%v: real Go stack result acquired numerical registers: %v", api, override, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterTupleResultSignatureGuards(t *testing.T) {
+	source, declaration := amd64RegisterTupleFixture([]string{"uint64", "uint64", "uint64"})
+	pkg := mustGoPackage(t, "tupleguard", "package tupleguard\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("tuple", pkg.Types.Scope().Lookup("tuple").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*FuncSig){
+		"no frame slots": func(sig *FuncSig) { sig.Frame.Results = nil },
+		"permuted slots": func(sig *FuncSig) {
+			sig.Frame.Results[0], sig.Frame.Results[1] = sig.Frame.Results[1], sig.Frame.Results[0]
+		},
+		"missing slot":              func(sig *FuncSig) { sig.Frame.Results = sig.Frame.Results[:2] },
+		"duplicate index":           func(sig *FuncSig) { sig.Frame.Results[1].Index = 0 },
+		"out of range index":        func(sig *FuncSig) { sig.Frame.Results[1].Index = 3 },
+		"wrong slot type":           func(sig *FuncSig) { sig.Frame.Results[1].Type = I32 },
+		"nested field":              func(sig *FuncSig) { sig.Frame.Results[1].Field = 0 },
+		"nested path":               func(sig *FuncSig) { sig.Frame.Results[1].Fields = []int{0} },
+		"custom argument registers": func(sig *FuncSig) { sig.ArgRegs = []Reg{AX} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := sig
+			changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+			change(&changed)
+			ctx := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: changed, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("malformed result transport was accepted: %v", err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				manual := func(string) (FuncSig, bool) { return changed, true }
+				_, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api, manual)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: malformed layout bypassed the common result audit: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64RegisterTupleResultDispatch(t *testing.T) {
+	fn := Func{Sym: "tuple<ABIInternal>"}
+	for name, sig := range map[string]FuncSig{
+		"no frame":         {Ret: "{ i64, i64, i64 }"},
+		"wrong frame type": {Ret: "{ i64, i64, i64 }", Frame: FrameLayout{Results: []FrameSlot{{Type: Ptr}}}},
+		"custom registers": {Ret: "{ i64, i64, i64 }", ArgRegs: []Reg{AX}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if !x86TypedFPResultNeedsProof(fn, sig, "amd64") {
+				t.Fatal("integer tuple skipped the common audit because its Frame/role was invalid")
+			}
+		})
+	}
+	for _, arch := range []string{"386", "arm", "arm64", "wasm"} {
+		if x86TypedFPResultNeedsProof(fn, FuncSig{Ret: "{ i64, i64, i64 }"}, arch) {
+			t.Fatal("AMD64 register tuple restriction changed another architecture:", arch)
+		}
+	}
+	for _, name := range []string{"tuple", "tuple<ABI0>"} {
+		if x86TypedFPResultNeedsProof(Func{Sym: name}, FuncSig{Ret: "{ i64, i64, i64 }"}, "amd64") {
+			t.Fatal("register tuple restriction inferred a missing selector:", name)
+		}
+	}
+}
diff --git a/amd64_register_tuple_runtime_linux_amd64_test.go b/amd64_register_tuple_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..1de1f77bd
--- /dev/null
+++ b/amd64_register_tuple_runtime_linux_amd64_test.go
@@ -0,0 +1,34 @@
+//go:build linux && amd64 && go1.27
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixAMD64RegisterTupleSDKKernel(t *testing.T) {
+	TestAMD64RegisterTupleResultSDKOriginalGoObject(t)
+	execution := x86FloatCompareExecutionTools(t)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir := amd64RegisterTupleSDKIR(t, api)
+			for _, optimized := range []bool{false, true} {
+				body, label := ir, "IR-O0"
+				if optimized {
+					body, label = x86MulDivRoundOptimize(t, ir), "IR-O2"
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(label+"/backend"+level, func(t *testing.T) {
+						output := execution.compileAndRunLLVM(t, "sdk-register-tuple", body, amd64RegisterTupleKernelOracle, level)
+						const expected = "SDK_REGISTER_TUPLE_KERNEL_PASS cases=64 fields=192"
+						if strings.TrimSpace(string(output)) != expected {
+							t.Fatalf("independent kernel/errno/tuple/canary oracle: %q", output)
+						}
+						t.Log("64 calls and 192 independently expected scalar fields; C uses only a void/pointer output shim")
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_register_tuple_sdk_go127_test.go b/amd64_register_tuple_sdk_go127_test.go
new file mode 100644
index 000000000..6ee53d284
--- /dev/null
+++ b/amd64_register_tuple_sdk_go127_test.go
@@ -0,0 +1,201 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// Read the actual selected SDK declaration and assembly. No guessed ManualSig
+// replaces its source-owned seven inputs and three register results.
+func amd64RegisterTupleSDKSource(t *testing.T) (GoPackage, string, []byte) {
+	t.Helper()
+	const path = "internal/runtime/syscall/linux"
+	root := runtime.GOROOT()
+	directory := filepath.Join(root, "src", filepath.FromSlash(path))
+	declaration, err := os.ReadFile(filepath.Join(directory, "syscall_linux.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "syscall_linux.go", declaration, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var selected *ast.FuncDecl
+	for _, item := range file.Decls {
+		function, ok := item.(*ast.FuncDecl)
+		if ok && function.Name.Name == "Syscall6" {
+			if selected != nil || function.Recv != nil || function.Body != nil {
+				t.Fatal("SDK register entry declaration is not unique/bodyless")
+			}
+			selected = function
+		}
+	}
+	if selected == nil {
+		t.Fatal("selected SDK register entry declaration is absent")
+	}
+	// This selected declaration uses only built-in uintptr types. Keeping the
+	// original FuncType avoids importing or rechecking unrelated SDK bodies.
+	view := &ast.File{Name: file.Name, Decls: []ast.Decl{selected}}
+	config := types.Config{Sizes: types.SizesFor("gc", "amd64")}
+	typed, err := config.Check(path, fset, []*ast.File{view}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "asm_linux_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := PreprocessAssemblySource(string(assembly), AssemblyPreprocessOptions{
+		FileName: "asm_linux_amd64.s",
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if name != "textflag.h" {
+				return "", nil, fmt.Errorf("unexpected SDK include %q", name)
+			}
+			name = filepath.Join(root, "pkg", "include", name)
+			data, err := os.ReadFile(name)
+			return name, data, err
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual SDK=%s declarationSHA256=%x assemblySHA256=%x", root, sha256.Sum256(declaration), sha256.Sum256(assembly))
+	return GoPackage{Path: path, Types: typed, Syntax: []*ast.File{view}}, expanded, assembly
+}
+
+func TestAMD64RegisterTupleResultSDKOriginalGoObject(t *testing.T) {
+	pkg, _, source := amd64RegisterTupleSDKSource(t)
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "source.s"), filepath.Join(dir, "source.o")
+	if err := os.WriteFile(input, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	root := runtime.GOROOT()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(root, "bin", "go"), "tool", "asm",
+		"-p", pkg.Path, "-I", filepath.Join(root, "pkg", "include"), "-o", object, input)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64")
+	data, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, data, err, ctx.Err(), true, "amd64"); failure != nil {
+		t.Fatalf("actual original SDK assembly: %v\n%s", failure, data)
+	}
+}
+
+func amd64RegisterTupleSDKIR(t *testing.T, api string) string {
+	t.Helper()
+	pkg, source, _ := amd64RegisterTupleSDKSource(t)
+	ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// C sees a void function and an output pointer. The internal LLVM tuple is
+	// extracted here; its three-word return is never mistaken for the C ABI.
+	return ir + `
+define void @observe_sdk_tuple(ptr %out, i64 %n, i64 %a1, i64 %a2, i64 %a3, i64 %a4, i64 %a5, i64 %a6) {
+  %r = call { i64, i64, i64 } @Syscall6(i64 %n, i64 %a1, i64 %a2, i64 %a3, i64 %a4, i64 %a5, i64 %a6)
+  %r0 = extractvalue { i64, i64, i64 } %r, 0
+  %r1 = extractvalue { i64, i64, i64 } %r, 1
+  %r2 = extractvalue { i64, i64, i64 } %r, 2
+  %p1 = getelementptr i64, ptr %out, i64 1
+  %p2 = getelementptr i64, ptr %out, i64 2
+  store i64 %r0, ptr %out, align 8
+  store i64 %r1, ptr %p1, align 8
+  store i64 %r2, ptr %p2, align 8
+  ret void
+}
+`
+}
+
+func TestAMD64RegisterTupleResultSDKThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir := amd64RegisterTupleSDKIR(t, api)
+			for _, optimized := range []bool{false, true} {
+				body := ir
+				if optimized {
+					body = x86MulDivRoundOptimize(t, body)
+				}
+				x86ResultInitializationObject(t, llc, "x86_64-unknown-linux-gnu", body, "sdk-register-tuple")
+			}
+			t.Logf("SDK_REGISTER_TUPLE_IR_BASE64=%s", base64.StdEncoding.EncodeToString([]byte(ir)))
+		})
+	}
+}
+
+const amd64RegisterTupleKernelOracle = `
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/syscall.h>
+
+extern void observe_sdk_tuple(uint64_t *, uint64_t, uint64_t, uint64_t,
+                              uint64_t, uint64_t, uint64_t, uint64_t);
+
+static void reference(uint64_t result[3], uint64_t number, uint64_t a3) {
+  uint64_t ax, dx;
+  register uint64_t r10 __asm__("r10") = 0;
+  register uint64_t r8 __asm__("r8") = 0;
+  register uint64_t r9 __asm__("r9") = 0;
+  __asm__ volatile("syscall"
+      : "=a"(ax), "=d"(dx)
+      : "0"(number), "D"(UINT64_C(0)), "S"(UINT64_C(0)), "1"(a3),
+        "r"(r10), "r"(r8), "r"(r9)
+      : "rcx", "r11", "cc", "memory");
+  if (ax >= (uint64_t)-4095) {
+    result[0] = UINT64_MAX;
+    result[1] = 0;
+    result[2] = -ax;
+  } else {
+    result[0] = ax;
+    result[1] = dx;
+    result[2] = 0;
+  }
+}
+
+int main(void) {
+  const uint64_t guard = UINT64_C(0x9acefedb01234567);
+  const uint64_t numbers[] = {SYS_getpid, UINT64_MAX};
+  unsigned cases = 0;
+  for (unsigned iteration = 0; iteration < 32; ++iteration) {
+    const uint64_t a3 = UINT64_C(0x7263548190abcdef) ^ iteration;
+    for (unsigned which = 0; which < 2; ++which) {
+      uint64_t expected[3];
+      uint64_t output[] = {guard, 13, 29, 47, guard};
+      errno = EDOM;
+      reference(expected, numbers[which], a3);
+      if (errno != EDOM) return 2;
+      observe_sdk_tuple(output + 1, numbers[which], 0, 0, a3, 0, 0, 0);
+      if (errno != EDOM || output[0] != guard || output[4] != guard) return 3;
+      for (unsigned field = 0; field < 3; ++field) {
+        if (output[field + 1] != expected[field]) {
+          fprintf(stderr, "case=%u field=%u got=%llx want=%llx\n", which, field,
+                  (unsigned long long)output[field + 1], (unsigned long long)expected[field]);
+          return 4;
+        }
+      }
+      if (which == 1 && expected[2] != ENOSYS) return 5;
+      ++cases;
+    }
+  }
+  printf("SDK_REGISTER_TUPLE_KERNEL_PASS cases=%u fields=%u\n", cases, 3 * cases);
+  return cases == 64 ? 0 : 6;
+}
+`
diff --git a/amd64_register_tuple_values_linux_amd64_test.go b/amd64_register_tuple_values_linux_amd64_test.go
new file mode 100644
index 000000000..e77d28896
--- /dev/null
+++ b/amd64_register_tuple_values_linux_amd64_test.go
@@ -0,0 +1,35 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixAMD64RegisterTupleValues(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, test := range amd64RegisterTupleRuntimeCases() {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				ir, main := amd64RegisterTupleRuntimeInputs(t, test, api)
+				for _, optimized := range []bool{false, true} {
+					body, label := ir, "IR-O0"
+					if optimized {
+						body, label = x86MulDivRoundOptimize(t, ir), "IR-O2"
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(label+"/backend"+level, func(t *testing.T) {
+							output := execution.compileAndRunLLVM(t, "register-tuple-values", body, main, level)
+							expected := fmt.Sprintf("REGISTER_TUPLE_TRANSLATED_PASS fields=%d calls=32", len(test.results))
+							if strings.TrimSpace(string(output)) != expected {
+								t.Fatalf("independent tuple values/truncation/canaries: %q", output)
+							}
+						})
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_register_void_test.go b/amd64_register_void_test.go
new file mode 100644
index 000000000..c41a0a1ed
--- /dev/null
+++ b/amd64_register_void_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This derives an ordinary language signature, not a compiler/native entry,
+// a physical frame, a pointer extent or any initialized memory contents.
+func amd64RegisterVoidSource(t *testing.T, declaration, body string) (Func, FuncSig, string) {
+	t.Helper()
+	_, sig, source := x86ScalarFPVoidSource(t, declaration, body, "amd64")
+	source = strings.Replace(source, "·view(SB)", "·view<ABIInternal>(SB)", 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("ordinary register-void fixture lost its complete source", err)
+	}
+	return file.Funcs[0], sig, source
+}
+
+func TestAMD64RegisterVoidKeepsDeclaredInputsAndFullFlow(t *testing.T) {
+	registers := []Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"}
+	cases := 0
+	for _, width := range []struct {
+		typ, move string
+		bytes     int64
+	}{
+		{"uint8", "MOVB", 1}, {"uint16", "MOVW", 2},
+		{"uint32", "MOVL", 4}, {"uint64", "MOVQ", 8},
+	} {
+		for index, register := range registers {
+			t.Run(width.typ+"/"+string(register), func(t *testing.T) {
+				declaration := "func view(" + strings.TrimSuffix(strings.Repeat(width.typ+",", index+1), ",") + ")\n"
+				body := fmt.Sprintf("%s %s,R12", width.move, register)
+				fn, sig, _ := amd64RegisterVoidSource(t, declaration, body)
+				seen, shapes := 0, 0
+				err := checkAMD64RegisterResultInitialization(fn, sig,
+					func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+						if ins.Raw != body {
+							t.Fatal("unexpected source effect in the input counterexample", ins.Raw)
+						}
+						if state.shapeOnly {
+							shapes++
+							return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+						}
+						seen++
+						for carrier, reg := range registers {
+							position, _, valid := x86ResultGP(reg, width.bytes, arch)
+							if !valid {
+								t.Fatal("invalid original argument carrier", reg)
+							}
+							want := uint8(0)
+							if carrier <= index {
+								want = uint8(1<<uint(width.bytes)) - 1
+							}
+							if state.gp[position] != want || state.pointerGP[position] {
+								t.Fatal("Void changed declared carrier bytes or pointer roles", reg, state.gp[position], want)
+							}
+						}
+						return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+					})
+				if err != nil || seen != 1 || shapes != 1 {
+					t.Fatal("ordinary Void must consume both source shape and actual input/effect", seen, shapes, err)
+				}
+			})
+			cases++
+		}
+	}
+	if cases != 36 {
+		t.Fatal("incomplete ordinary argument-width/carrier matrix", cases)
+	}
+
+	t.Run("pointer-is-not-numerical", func(t *testing.T) {
+		fn, sig, _ := amd64RegisterVoidSource(t, "func view(input *uint64)\n", "MOVQ AX,BX\nMOVQ BX,CX")
+		seen, shapes := 0, 0
+		err := checkAMD64RegisterResultInitialization(fn, sig,
+			func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				if state.shapeOnly {
+					shapes++
+					return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+				}
+				register := AX
+				if seen != 0 {
+					register = BX
+				}
+				position, _, _ := x86ResultGP(register, 8, arch)
+				if !state.pointerGP[position] || !state.callerAddressGP[position] || state.gp[position] != 0 {
+					t.Fatal("Void discarded the original opaque pointer role or invented numerical bytes")
+				}
+				seen++
+				return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+			})
+		if err != nil || seen != 2 || shapes != 2 {
+			t.Fatal("Void pointer copies require the complete original source shape and flow", seen, shapes, err)
+		}
+	})
+
+	t.Run("no-AX-result", func(t *testing.T) {
+		fn, sig, _ := amd64RegisterVoidSource(t, "func view()\n", "MOVQ $7,BX")
+		seen, shapes := 0, 0
+		err := checkAMD64RegisterResultInitialization(fn, sig,
+			func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				if state.shapeOnly {
+					shapes++
+					return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+				}
+				position, _, _ := x86ResultGP(AX, 8, arch)
+				if state.gp[position] != 0 {
+					t.Fatal("the Void entry fabricated AX initialization")
+				}
+				seen++
+				return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+			})
+		if err != nil || seen != 1 || shapes != 1 {
+			t.Fatal("Void has no AX result but retains both source shape and reaching effects", seen, shapes, err)
+		}
+	})
+}
+
+func TestAMD64RegisterVoidWholeFunctionThreeAPIsAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	var assembly, declarations strings.Builder
+	fixtures := 0
+	for index, fixture := range []struct {
+		declaration, body string
+	}{
+		{"func view(input uint8)\n", "MOVB AX,R12"},
+		{"func view(input uint16)\n", "MOVW AX,R12"},
+		{"func view(input uint32)\n", "MOVL AX,R12"},
+		{"func view(input uint64)\n", "MOVQ AX,R12"},
+		{"func view(input *uint64)\n", "MOVQ AX,BX\nMOVQ BX,CX"},
+		{"func view()\n", "MOVQ $7,BX"},
+		{"func view(input *uint64)\n", "MOVQ (AX),BX"},
+	} {
+		_, _, source := amd64RegisterVoidSource(t, fixture.declaration, fixture.body)
+		name := fmt.Sprintf("consume%d", index)
+		assembly.WriteString(strings.Replace(source, "·view<", "·"+name+"<", 1))
+		declarations.WriteString(strings.Replace(fixture.declaration, "view(", name+"(", 1))
+		fixtures++
+	}
+	if fixtures != 7 {
+		t.Fatal("incomplete integer/pointer/empty/native-read Void source matrix", fixtures)
+	}
+	requireAMD64RegisterResultGoObject(t, assembly.String())
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), "amd64", triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("ordinary typed Void entry requires no fabricated result", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					text := ir
+					if level == "-O2" {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					if strings.Count(text, "load volatile i64,") != 1 {
+						t.Fatal("Void discarded or duplicated its exact native qword read", api, level)
+					}
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64RegisterVoidCannotWaiveFaultingInputsAndSourceRoles(t *testing.T) {
+	for _, fixture := range []struct {
+		name, declaration, body string
+		registerProofOnly       bool
+	}{
+		{"undefined-base", "func view(input uint64)\n", "MOVQ (R10),AX", false},
+		{"NUM-is-not-pointer", "func view(input uint64)\n", "MOVQ (AX),BX", false},
+		{"hidden-closure", "func view(input uint64)\n", "MOVQ 8(DX),BX", false},
+		{"hidden-g", "func view(input uint64)\n", "MOVQ (R14),AX", false},
+		{"physical-stack", "func view(input uint64)\n", "MOVQ (SP),AX", true},
+		{"ABI0-input", "func view(input uint64)\n", "MOVQ input+0(FP),AX", true},
+		{"ABI0-store", "func view(input uint64)\n", "MOVQ AX,input+0(FP)", true},
+		{"one-path-fault", "func view(input uint64)\n", "CMPQ AX,$0\nJE done\nMOVQ (R10),BX\ndone:", false},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			fn, sig, source := amd64RegisterVoidSource(t, fixture.declaration, fixture.body)
+			declaration := fixture.declaration
+			if fixture.registerProofOnly {
+				// The legacy ordinary-MOV path can use logical frame fields without
+				// this register-entry proof. Its public admission is not a native
+				// ABIInternal frame contract. Keep the exact original source here,
+				// and make the paired-read public counterexample explicit below.
+				err := checkAMD64RegisterResultInitialization(fn, sig,
+					func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+						return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+					})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original SP/FP source acquired register-entry ownership", err)
+				}
+				declaration = "func view(input *uint64)\n"
+				_, _, source = amd64RegisterVoidSource(t, declaration, "MOVQ (AX),R10\n"+fixture.body)
+				requireAMD64RegisterResultGoObject(t, source)
+			}
+			if fixture.name == "NUM-is-not-pointer" {
+				err := checkAMD64RegisterResultInitialization(fn, sig,
+					func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+						return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+					})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone register query acquired native storage authority", err)
+				}
+				requireAMD64RegisterResultGoObject(t, source)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if fixture.name == "NUM-is-not-pointer" {
+					if err != nil || !strings.Contains(ir, "load volatile i64,") {
+						t.Fatal("complete NUM input lost its paired native read", api, err)
+					}
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					continue
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Error("Void waived a faulting read or its original source/entry role", api, err)
+				}
+			}
+		})
+	}
+
+	t.Run("unbound-call", func(t *testing.T) {
+		const declaration = "func view(input uint64)\n"
+		_, _, source := amd64RegisterVoidSource(t, declaration, "CALL ·unknown(SB)")
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err == nil || ir != "" {
+				t.Error("Void admitted a call without its required signature", api, err)
+			}
+		}
+	})
+}
+
+func TestAMD64RegisterVoidRejectsForgedResultsAndEntries(t *testing.T) {
+	for _, change := range []string{"ABI0", "manual-registers", "result-without-slot", "slot-on-Void", "raw", "physical-address-mode", "WASM-entry"} {
+		t.Run(change, func(t *testing.T) {
+			fn, sig, _ := amd64RegisterVoidSource(t, "func view(input uint64)\n", "MOVQ AX,BX")
+			switch change {
+			case "ABI0":
+				fn.Sym = strings.TrimSuffix(fn.Sym, "<ABIInternal>")
+			case "manual-registers":
+				sig.ArgRegs = []Reg{AX}
+			case "result-without-slot":
+				sig.Ret = I64
+			case "slot-on-Void":
+				sig.Frame.Results = append(sig.Frame.Results, sig.Frame.Params[0])
+			case "raw":
+				fn.Instrs[1].x86Encoded = true
+			case "physical-address-mode":
+				fn.Instrs[1].x86AddressBits = 32
+			case "WASM-entry":
+				sig.WASMContext = "go"
+			}
+			calls := 0
+			err := checkAMD64RegisterResultInitialization(fn, sig,
+				func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+					calls++
+					return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+				})
+			if !errors.Is(err, ErrProbeNeedsContext) || calls != 0 {
+				t.Fatal("Void admitted contradictory result/entry metadata", calls, err)
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_arithmetic_native.go b/amd64_scalar_arithmetic_native.go
new file mode 100644
index 000000000..228f4a0d2
--- /dev/null
+++ b/amd64_scalar_arithmetic_native.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import "fmt"
+
+// The existing whole Go-table grammar supplies operand width, encoded byte
+// aliases and carry roles. This query selects only its memory-to-register
+// arithmetic/logical rows; it supplies no memory or entry capability.
+func x86ScalarArithmeticNativeReadProperties(ins Instr, arch string) (x86LockScalarRMWForm, bool, error) {
+	form, known, err := x86ScalarArithmeticReadProperties(ins, arch)
+	if !known || err != nil {
+		return form, known, err
+	}
+	return form, x86OrdinaryNativeMemoryOperand(form.source, arch), nil
+}
+
+func x86ScalarArithmeticReadProperties(ins Instr, arch string) (x86LockScalarRMWForm, bool, error) {
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known {
+		return form, false, nil
+	}
+	if err != nil {
+		return form, true, err
+	}
+	switch form.spec.stem {
+	case "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR":
+	default:
+		return form, false, nil
+	}
+	if form.source.Kind != OpMem || form.source.Mem.Sym != "" ||
+		form.destination.Kind != OpReg {
+		return form, false, nil
+	}
+	return form, true, nil
+}
+
+func (c *amd64Ctx) evalScalarArithmeticSource(ins Instr, typ LLVMType) (string, Operand, error) {
+	form, known, err := x86ScalarArithmeticReadProperties(ins, c.goarch)
+	if err != nil {
+		return "", Operand{}, err
+	}
+	if !known || !c.nativeMemoryOperand(ins, 0) {
+		value, err := c.evalIntSized(ins.Args[0], typ)
+		return value, ins.Args[1], err
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		form.destination.Reg != ins.Args[1].Reg && (form.destination.Reg == SP || form.destination.Reg == BP) {
+		return "", Operand{}, fmt.Errorf("%w: scalar arithmetic needs its original native address/register contract", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+	if err != nil {
+		return "", Operand{}, err
+	}
+	value := c.newTmp()
+	// Preserve the fault and exact read even when all numerical results and
+	// flags are discarded. Do not assert alignment, bounds or pointee validity.
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+	return "%" + value, form.destination, nil
+}
+
+// Only the lowering paired with the exact volatile source load may consume
+// its numerical continuation. The destination and incoming carry still need
+// every source byte/flag. Public declaration and caller observers stay strict.
+func x86LoweredScalarArithmeticNativeRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ScalarArithmeticNativeReadProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	width := int64(form.spec.bits / 8)
+	index, _, valid := x86ResultGP(form.destination.Reg, width, arch)
+	if !valid || state.pointerGP[index] ||
+		form.spec.carryInput && state.flags&x86ByteFlagCF == 0 ||
+		!x86ResultRead(form.destination, width, state, owned, arch) ||
+		!x86ResultReadWithNativeGPContinuation(ins, form.source, width, state, owned, arch) {
+		return false, true
+	}
+	if !x86ResultStore(form.destination, width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true
+}
diff --git a/amd64_scalar_arithmetic_native_result_test.go b/amd64_scalar_arithmetic_native_result_test.go
new file mode 100644
index 000000000..1b91f7228
--- /dev/null
+++ b/amd64_scalar_arithmetic_native_result_test.go
@@ -0,0 +1,264 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Keep this inventory independent of the production descriptors. These are
+// all four widths of Go's add/subtract, carry/borrow and logical families.
+var x86ScalarArithmeticNativeNames = []string{
+	"ADDB", "ADDW", "ADDL", "ADDQ",
+	"SUBB", "SUBW", "SUBL", "SUBQ",
+	"ADCB", "ADCW", "ADCL", "ADCQ",
+	"SBBB", "SBBW", "SBBL", "SBBQ",
+	"ANDB", "ANDW", "ANDL", "ANDQ",
+	"ORB", "ORW", "ORL", "ORQ",
+	"XORB", "XORW", "XORL", "XORQ",
+}
+
+func TestX86ScalarArithmeticNativeSparseBytesFlagsAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86ScalarArithmeticNativeNames {
+			width := map[byte]int64{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+			if arch == "386" && width == 8 {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" -1(DX)(BX*1),CX")
+				base, _, _ := x86ResultGP(DX, 4, arch)
+				index, _, _ := x86ResultGP(BX, 4, arch)
+				destination, mask, _ := x86ResultGP(CX, width, arch)
+				for seed := 0; seed < 256; seed++ {
+					for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+						state := x86ResultState{flags: flags}
+						state.pointerGP[base], state.gp[index], state.gp[destination] = true, 0xff, uint8(seed)
+						want := state.clone()
+						accepted := uint8(seed)&mask == mask &&
+							(!strings.HasPrefix(op, "ADC") && !strings.HasPrefix(op, "SBB") || flags&x86ByteFlagCF != 0)
+						if accepted {
+							want.flags = x86ByteFlagsAll
+							if strings.HasPrefix(op, "AND") || strings.HasPrefix(op, "OR") || strings.HasPrefix(op, "XOR") {
+								want.flags &^= x86ByteFlagAF // Logical AF is undefined, not preserved.
+							}
+							if width == 4 {
+								want.gp[destination] = 0xff
+							}
+						}
+						if got, known := x86LoweredScalarArithmeticNativeRead(ins, &state, nil, 0, arch); !known || got != accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("arithmetic changed byte/FLAGS roles", seed, flags, got, accepted, state, want)
+						}
+					}
+				}
+				for _, origin := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment", "pointer destination"} {
+					changed := ins
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.pointerGP[base], state.gp[index], state.gp[destination] = true, 0xff, 0xff
+					switch origin {
+					case "decoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "raw return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address":
+						changed.x86AddressBits = 32
+					case "unbound address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "pointer destination":
+						state.pointerGP[destination] = true
+					}
+					before := state.clone()
+					if accepted, known := x86LoweredScalarArithmeticNativeRead(changed, &state, nil, 0, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("unbound origin acquired native arithmetic", origin, state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarArithmeticNativeOriginalREXByteAliases(t *testing.T) {
+	for _, row := range []struct {
+		op   string
+		byte byte
+	}{{"ADDB", 0x02}, {"SUBB", 0x2a}, {"ADCB", 0x12}, {"SBBB", 0x1a},
+		{"ANDB", 0x22}, {"ORB", 0x0a}, {"XORB", 0x32}} {
+		for ordinal, reg := range []string{"AH", "CH", "DH", "BH"} {
+			for _, address := range []string{"(DX)", "(R8)", "(DX)(R9*2)"} {
+				instruction := row.op + " " + address + "," + reg
+				code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+instruction+"\nRET\n")
+				want := []byte{row.byte, byte(0x22 + ordinal*8), 0xc3}
+				effective := Reg(reg)
+				if address == "(R8)" {
+					want = []byte{0x41, row.byte, byte(0x20 + ordinal*8), 0xc3}
+				} else if address == "(DX)(R9*2)" {
+					want = []byte{0x42, row.byte, byte(0x24 + ordinal*8), 0x4a, 0xc3}
+				}
+				if address != "(DX)" {
+					effective = []Reg{SP, BP, SI, DI}[ordinal]
+				}
+				if !reflect.DeepEqual(code, want) {
+					t.Fatalf("original REX/ModRM view changed: %s: %x != %x", instruction, code, want)
+				}
+				ins := x86ScalarLaneInstruction(t, instruction)
+				form, known, err := x86ScalarArithmeticNativeReadProperties(ins, "amd64")
+				if !known || err != nil || form.destination.Reg != effective {
+					t.Fatal("typed destination differs from actual Go encoding", instruction, form, err)
+				}
+				if address != "(DX)" && ordinal < 2 {
+					c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.Value", Ret: Void}, nil)
+					before := output.String()
+					if _, _, err := c.evalScalarArithmeticSource(ins, I8); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+						t.Fatal("arithmetic manufactured a physical SP/BP alias", err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarArithmeticNativeResultsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range x86ScalarArithmeticNativeNames {
+				if target.arch == "386" && strings.HasSuffix(op, "Q") {
+					goAssemblerOracleOutput(t, target.arch, "TEXT f(SB),4,$0-0\n"+op+" (DX),CX\nRET\n", "", false)
+					continue
+				}
+				for _, address := range []string{"(DX)", "-1(DX)(BX*1)"} {
+					body := "CMPL BX,BX\n" + op + " " + address + ",CX"
+					asm, decl := x86ExtensionNativeFixture(fmt.Sprintf("F%d", count), target.arch, body, false)
+					source.WriteString(asm)
+					declarations.WriteString(strings.ReplaceAll(decl, "*[4]byte", "*[16]byte"))
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("native arithmetic lost its paired numerical continuation", api, err)
+				}
+				for _, optimized := range []bool{false, true} {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					if strings.Count(text, "load volatile i") != count {
+						t.Fatal("native arithmetic lost its exact observable reads", api, optimized, count)
+					}
+					compileLLVMToObject(t, llc, target.triple, "arithmetic-native.ll", "arithmetic-native.o", text)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarArithmeticDeadNativeReadsSurviveOptimization(t *testing.T) {
+	for _, op := range x86ScalarArithmeticNativeNames {
+		t.Run(op, func(t *testing.T) {
+			source, declaration := x86ExtensionNativeFixture("Value", "amd64", "CMPL BX,BX\n"+op+" (DX),CX", true)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			width := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[op[len(op)-1]]
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if strings.Count(text, fmt.Sprintf("load volatile i%d,", width)) != 1 {
+						t.Errorf("%s dead native read must retain exactly %d bits", api, width)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarArithmeticNativeRetainsPublicAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86ScalarArithmeticNativeNames {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				body := fmt.Sprintf("%s p+0(FP),DX\nMOVL $0,CX\nCMPL CX,CX\n%s (DX),CX\nMOVL CX,ret0+%d(FP)\nRET", move, op, word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *[16]byte) uint32", body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unpaired declaration check acquired native storage", err)
+					}
+				}
+				for name, body := range map[string]string{
+					"unknown base":       op + " (DI),CX",
+					"numeric base":       "MOVL $42,DX\n" + op + " (DX),CX",
+					"unknown index":      op + " (DX)(SI*1),CX",
+					"pointer index":      op + " (DX)(DX*1),CX",
+					"unknown result":     op + " (DX),DI\n" + move + " DI,CX",
+					"pointer result":     op + " (DX),DX\n" + move + " DX,CX",
+					"native store":       op + " CX,(DX)",
+					"unknown store data": op + " DI,(DX)",
+					"unknown store base": op + " CX,(DI)",
+					"destroyed pointer":  "MOVL $42,DX\n" + op + " (DX),CX",
+				} {
+					t.Run(name, func(t *testing.T) {
+						source, declaration := x86ExtensionNativeFixture("Value", arch, "CMPL BX,BX\n"+body, false)
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						if name == "numeric base" || name == "destroyed pointer" {
+							x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if name == "numeric base" || name == "destroyed pointer" {
+								bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[op[len(op)-1]]
+								if err != nil || strings.Count(ir, fmt.Sprintf("load volatile i%d,", bits)) != 1 {
+									t.Fatal("complete NUM address lost its exact scalar arithmetic read", api, err)
+								}
+								x86NumericNativeAddressObject(t, ir, triple)
+								continue
+							}
+							if name == "native store" {
+								// The paired RMW consumer now models this complete
+								// read/write. Preserve its exact former negative and
+								// require independent missing-input controls above.
+								if err != nil || ir == "" {
+									t.Fatal("complete paired native RMW lost its inputs", api, err)
+								}
+								llc := findLLVM22Tool("llc")
+								if llc == "" {
+									t.Fatal("LLVM22 llc required")
+								}
+								for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+									if strings.Count(text, "load volatile") != 1 || strings.Count(text, "store volatile") != 1 {
+										t.Fatal("native RMW lost its exact observable read/write", api)
+									}
+									compileLLVMToObject(t, llc, triple, "paired-rmw.ll", "paired-rmw.o", text)
+								}
+								continue
+							}
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("native arithmetic acquired an unproved source effect", api, err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_arithmetic_native_runtime_unix_test.go b/amd64_scalar_arithmetic_native_runtime_unix_test.go
new file mode 100644
index 000000000..a7179b0e3
--- /dev/null
+++ b/amd64_scalar_arithmetic_native_runtime_unix_test.go
@@ -0,0 +1,209 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarArithmeticNativeResultsAndFaults(t *testing.T) {
+	x86ScalarArithmeticNativeRuntime(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarArithmeticNativeFlagsAndAliases(t *testing.T) {
+	x86ScalarArithmeticNativeRuntime(t, true)
+}
+
+func x86ScalarArithmeticNativeRuntime(t *testing.T, flagsAndAliases bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	appendKernel := func(op string, width, carry int, dead, flags bool, alias string) {
+		name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+		comparison := "CMPL BX,BX\n"
+		nativeComparison := "MOVL $1,R10\nCMPL R10,R10\n"
+		if carry != 0 {
+			comparison = "CMPL BX,$2\n"
+			nativeComparison = "MOVL $1,R10\nCMPL R10,$2\n"
+		}
+		body := comparison + op + " -1(DX)(BX*1),CX"
+		native := "MOVQ $0x87654321fedcba98,AX\n" + nativeComparison + op + " (DI),AX\n"
+		mode := 0 // value result
+		if flags {
+			body += "\n" + x86ScalarArithmeticNativeFlagObserver + "\nMOVQ AX,CX"
+			native += x86ScalarArithmeticNativeFlagObserver + "\n"
+			mode = 1
+		}
+		if alias != "" {
+			effective := "SI"
+			if alias == "BH" {
+				effective = "DI"
+			}
+			body = "MOVQ DX,R8\nMOVQ $0x87654321fedcba98," + effective + "\n" + comparison + op + " (R8)," + alias + "\nMOVQ " + effective + ",CX"
+			native = "MOVQ DI,R8\nMOVQ $0x87654321fedcba98," + effective + "\n" + nativeComparison + op + " (R8)," + alias + "\nMOVQ " + effective + ",AX\n"
+		}
+		if dead {
+			body += "\nMOVQ $0x87654321fedcba98,CX"
+			native += "MOVQ $0x87654321fedcba98,AX\n"
+		}
+		assembly, declaration := x86ExtensionNativeFixture(name, "amd64", body, false)
+		source.WriteString(assembly)
+		declarations.WriteString(strings.ReplaceAll(declaration, "*[4]byte", "*[16]byte"))
+		code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+native+"RET\n")
+		var bytes []string
+		for _, b := range code {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+		}
+		symbol := original
+		if strings.Contains(execution.triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+		operation, discarded := 0, 0
+		if strings.HasPrefix(op, "SUB") || strings.HasPrefix(op, "SBB") {
+			operation = 1
+		} else if strings.HasPrefix(op, "AND") {
+			operation = 2
+		} else if strings.HasPrefix(op, "OR") {
+			operation = 3
+		} else if strings.HasPrefix(op, "XOR") {
+			operation = 4
+		}
+		if dead {
+			discarded = 1
+		}
+		effectiveCarry := 0
+		if strings.HasPrefix(op, "ADC") || strings.HasPrefix(op, "SBB") {
+			effectiveCarry = carry
+		}
+		fmt.Fprintf(&rows, "{%s,%s,%d,%d,%d,%d,%d},\n", name, original, width, operation, effectiveCarry, discarded, mode)
+		count++
+	}
+	for _, op := range x86ScalarArithmeticNativeNames {
+		width := map[byte]int{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+		for carry := 0; carry < 2; carry++ {
+			if flagsAndAliases {
+				appendKernel(op, width, carry, false, true, "")
+				if width == 1 {
+					for _, alias := range []string{"DH", "BH"} {
+						appendKernel(op, width, carry, false, false, alias)
+					}
+				}
+			} else {
+				for _, dead := range []bool{false, true} {
+					appendKernel(op, width, carry, dead, false, "")
+				}
+			}
+		}
+	}
+	wantCount := 112
+	if flagsAndAliases {
+		wantCount = 84
+	}
+	if count != wantCount {
+		t.Fatal("incomplete arithmetic/native state matrix", count, wantCount)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	// Reuse only the independent process/guard-page machinery. The arithmetic
+	// reference below does not consume a production descriptor or lowering.
+	start := strings.Index(x86ExtensionNativeRuntimeC, "static uint64_t reference(")
+	end := strings.Index(x86ExtensionNativeRuntimeC, "static int fault(")
+	if start < 0 || end <= start {
+		t.Fatal("missing complete fault-harness boundary")
+	}
+	driverTemplate := x86ExtensionNativeRuntimeC[:start] + x86ScalarArithmeticNativeReferenceC + "\n" + x86ExtensionNativeRuntimeC[end:]
+	driverTemplate = strings.NewReplacer(
+		"unsigned width, destination, sign, dead;", "unsigned width, operation, carry, dead, flags;",
+		"uint8_t bytes[8];", "uint8_t bytes[16];",
+		"const uint8_t *p=bytes+(pattern&1);", `
+            uint8_t *p=bytes+(pattern&1);
+            uint64_t mask=k.width==8?UINT64_MAX:(UINT64_C(1)<<(k.width*8))-1;
+            uint64_t sign=UINT64_C(1)<<(k.width*8-1), a=seed&mask;
+            const uint64_t edges[]={0,1,mask,mask-1,sign,sign-1,a,a-1,a+1,~a,-a,-a-1};
+            if(pattern<sizeof(edges)/sizeof(*edges)) {
+                for(unsigned b=0;b<k.width;b++) p[b]=(uint8_t)(edges[pattern]>>(8*b));
+            }`,
+		"28 extension kernels", fmt.Sprintf("%d scalar arithmetic kernels", count),
+	).Replace(driverTemplate)
+	driver := fmt.Sprintf(driverTemplate, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "scalar-arithmetic-native", text, driver, level)
+					want := fmt.Sprintf("%d scalar arithmetic kernels: numerical %d, fault %d, tripwires 2; failures 0\n", count, count*128, count*12)
+					if string(output) != want {
+						t.Fatal("original Go/LLVM arithmetic differs", string(output), want)
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+// Capture every SETcc-observable status bit before combining them with
+// flag-writing arithmetic. MOV/SETcc preserve the original flags.
+const x86ScalarArithmeticNativeFlagObserver = `MOVL $0,AX
+MOVL $0,SI
+MOVL $0,DI
+MOVL $0,R10
+MOVL $0,R11
+SETCS AL
+SETEQ SIB
+SETMI DIB
+SETOS R10B
+SETPS R11B
+SHLL $1,SI
+SHLL $2,DI
+SHLL $3,R10
+SHLL $4,R11
+ORL SI,AX
+ORL DI,AX
+ORL R10,AX
+ORL R11,AX`
+
+const x86ScalarArithmeticNativeReferenceC = `
+static uint64_t reference(Kernel k, const uint8_t *p) {
+    if(k.dead) return seed;
+    uint64_t input=0;
+    for(unsigned b=0;b<k.width;b++) input|=(uint64_t)p[b]<<(8*b);
+    unsigned bits=k.width*8;
+    uint64_t mask=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1;
+    uint64_t a=seed&mask, sign=UINT64_C(1)<<(bits-1);
+    uint64_t value;
+    switch(k.operation) {
+    case 0: value=a+input+k.carry; break;
+    case 1: value=a-input-k.carry; break;
+    case 2: value=a&input; break;
+    case 3: value=a|input; break;
+    default: value=a^input; break;
+    }
+    value&=mask;
+    if(k.flags) {
+        unsigned cf=0, of=0;
+        if(k.operation<2) {
+            cf=k.operation==1?(a<input || (k.carry && a==input)):
+                (value<a || (k.carry && value==a));
+            of=(((k.operation==1?(a^input):~(a^input))&(a^value)&sign)!=0);
+        }
+        unsigned ones=0;
+        for(unsigned bit=0;bit<8;bit++) ones+=(value>>bit)&1;
+        return cf|((value==0)<<1)|(((value&sign)!=0)<<2)|(of<<3)|((ones%%2==0)<<4);
+    }
+    if(k.width<4) return (seed&~mask)|value;
+    return value;
+}
+`
diff --git a/amd64_scalar_bitcount.go b/amd64_scalar_bitcount.go
new file mode 100644
index 000000000..0fdc22f28
--- /dev/null
+++ b/amd64_scalar_bitcount.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarBitCountKind uint8
+
+const (
+	x86PopulationCount x86ScalarBitCountKind = iota
+	x86LeadingZeroCount
+	x86TrailingZeroCount
+)
+
+type x86ScalarBitCountSpec struct {
+	bits int
+	kind x86ScalarBitCountKind
+}
+
+// Complete Go yml_rl/ycrc32l scalar count rows. Shape, lowering and numerical
+// byte effects share this table; it grants no native memory/caller permission.
+var x86ScalarBitCountSpecs = map[Op]x86ScalarBitCountSpec{
+	"POPCNTW": {16, x86PopulationCount}, "POPCNTL": {32, x86PopulationCount}, "POPCNTQ": {64, x86PopulationCount},
+	"LZCNTW": {16, x86LeadingZeroCount}, "LZCNTL": {32, x86LeadingZeroCount}, "LZCNTQ": {64, x86LeadingZeroCount},
+	"TZCNTW": {16, x86TrailingZeroCount}, "TZCNTL": {32, x86TrailingZeroCount}, "TZCNTQ": {64, x86TrailingZeroCount},
+}
+
+func x86ScalarBitCountProperties(op Op, ins Instr, arch string) (x86ScalarBitCountSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ScalarBitCountSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	fail := func() (x86ScalarBitCountSpec, bool, error) {
+		return spec, true, fmt.Errorf("%s %s outside Go scalar bit-count grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 || dotted ||
+		len(ins.Args) != 2 || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, arch) {
+		return fail()
+	}
+	if source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(source.Reg, arch) {
+			return fail()
+		}
+	} else if !isAMD64MemoryOperand(source) ||
+		source.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(source.Sym), "$") {
+		return fail()
+	}
+	if source.Kind == OpMem && !x86MemoryRegistersValidForArch(source.Mem, arch) {
+		return fail()
+	}
+	return spec, true, nil
+}
+
+func x86TypedScalarBitCountByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86ScalarBitCountProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	defined := x86ByteFlagCF | x86ByteFlagZF
+	if spec.kind == x86PopulationCount {
+		defined = x86ByteFlagsAll
+	}
+	width := int64(spec.bits / 8)
+	return x86TypedByteEffect{
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: ins.Args[0], width: width, read: true},
+			{index: 1, operand: ins.Args[1], width: width, write: true},
+		},
+		flagsDefined: defined,
+		flagsKilled:  x86ByteFlagsAll,
+	}, true, nil
+}
+
+func (c *amd64Ctx) lowerScalarBitCount(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86ScalarBitCountProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	typ := amd64IntegerTypeForBits(spec.bits)
+	var value string
+	if isAMD64MemoryOperand(ins.Args[0]) {
+		bytes, readErr := c.loadX86PackedShiftBytes(ins.Args[0], spec.bits/8, true)
+		err = readErr
+		if err == nil {
+			integer := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", integer, spec.bits/8, bytes, typ)
+			value = "%" + integer
+		}
+	} else {
+		value, err = c.evalIntSized(ins.Args[0], typ)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	count := c.newTmp()
+	if spec.kind == x86PopulationCount {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.ctpop.%s(%s %s)\n", count, typ, typ, typ, value)
+	} else {
+		intrinsic := "cttz"
+		if spec.kind == x86LeadingZeroCount {
+			intrinsic = "ctlz"
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %s, i1 false)\n", count, typ, intrinsic, typ, typ, value)
+	}
+	inputZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", inputZero, typ, value)
+	if spec.kind == x86PopulationCount {
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", inputZero, c.flagsZSlot)
+		c.clearX86StatusFlags(x86StatusAll &^ x86StatusZF)
+	} else {
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", inputZero, c.flagsCFSlot)
+		zero := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %%%s, 0\n", zero, typ, count)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	}
+	return true, false, c.storeRegSized(ins.Args[1].Reg, typ, "%"+count)
+}
+
+// Only the paired exact volatile emitter supplies native numerical bytes.
+// Widths, writes and defined/killed FLAGS remain the complete typed effect;
+// standalone queries and callers acquire no pointer or memory permission.
+func x86LoweredScalarBitCountNativeRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	effect, known, err := x86TypedScalarBitCountByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Sym != "" {
+		return false, false
+	}
+	for _, operand := range effect.operands {
+		if operand.read && !x86ResultReadWithNativeContinuation(ins, operand.operand, operand.width, state, owned, arch, true) {
+			return false, true
+		}
+	}
+	for _, operand := range effect.operands {
+		if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
diff --git a/amd64_scalar_bitcount_test.go b/amd64_scalar_bitcount_test.go
new file mode 100644
index 000000000..02b8db39c
--- /dev/null
+++ b/amd64_scalar_bitcount_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarBitCountCompleteGoRows(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := []string{
+		"{ALZCNTL, yml_rl, Pf3, opBytes{0xbd}}",
+		"{ALZCNTQ, yml_rl, Pfw, opBytes{0xbd}}",
+		"{ALZCNTW, yml_rl, Pef3, opBytes{0xbd}}",
+		"{APOPCNTW, yml_rl, Pef3, opBytes{0xb8}}",
+		"{APOPCNTL, yml_rl, Pf3, opBytes{0xb8}}",
+		"{APOPCNTQ, yml_rl, Pfw, opBytes{0xb8}}",
+		"{ATZCNTW, ycrc32l, Pe, opBytes{0xf3, 0x0f, 0xbc, 0}}",
+		"{ATZCNTL, ycrc32l, Px, opBytes{0xf3, 0x0f, 0xbc, 0}}",
+		"{ATZCNTQ, ycrc32l, Pw, opBytes{0xf3, 0x0f, 0xbc, 0}}",
+	}
+	if len(x86ScalarBitCountSpecs) != len(rows) {
+		t.Fatal("incomplete scalar count family")
+	}
+	for _, row := range append(rows,
+		"var yml_rl = []ytab{\n\t{Zm_r, 1, argList{Yml, Yrl}},\n}",
+		"var ycrc32l = []ytab{\n\t{Zlitm_r, 0, argList{Yml, Yrl}},\n}") {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("complete original Go encoding row changed:", row)
+		}
+	}
+	for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			op := Op(family + suffix)
+			for _, arch := range []string{"amd64", "386"} {
+				for _, input := range []string{"AX", "AL", "X0", "$3", "$table(SB)", "4(AX)(CX*2)", "table(SB)"} {
+					for _, output := range []string{"BX", "AH", "X1", "4(BX)"} {
+						source := fmt.Sprintf("TEXT probe(SB),4,$0-0\n%s %s,%s\nRET\n", op, input, output)
+						valid := !(arch == "386" && suffix == "Q") && output == "BX" &&
+							(input == "AX" || input == "4(AX)(CX*2)" || input == "table(SB)")
+						goAssemblerOracleOutput(t, arch, source, "", valid)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						_, known, err := x86ScalarBitCountProperties(op, file.Funcs[0].Instrs[1], arch)
+						if !known || (err == nil) != valid {
+							t.Fatalf("%s %s %s,%s: known=%t error=%v", arch, op, input, output, known, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitCountFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		word, typ, move := 8, "uint64", "MOVQ"
+		if target.arch == "386" {
+			word, typ, move = 4, "uint32", "MOVL"
+		}
+		var declarations, source strings.Builder
+		declarations.WriteString("package ordering\n")
+		for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			for _, suffix := range []string{"W", "L", "Q"} {
+				if target.arch == "386" && suffix == "Q" {
+					continue // Independently Go-rejected above, not a skipped test.
+				}
+				op := family + suffix
+				name := strings.ToLower(op)
+				fmt.Fprintf(&declarations, "func %s(x %s) %s\n", name, typ, typ)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s $0,BX\n%s AX,BX\n%s BX,ret0+%d(FP)\nRET\n",
+					name, 2*word, move, move, op, move, word)
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "count.ll"), filepath.Join(dir, "count.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_bitfield_forms.go b/amd64_scalar_bitfield_forms.go
new file mode 100644
index 000000000..3e5bd3b33
--- /dev/null
+++ b/amd64_scalar_bitfield_forms.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarBitFieldKind uint8
+
+const (
+	x86BitFieldExtract x86ScalarBitFieldKind = iota
+	x86BitFieldZeroHigh
+)
+
+type x86ScalarBitFieldSpec struct {
+	kind         x86ScalarBitFieldKind
+	bits         int
+	controlBytes int64
+	flagsDefined uint8
+}
+
+// BEXTR and BZHI share the complete Go _ybextrl grammar, not their control
+// bytes or FLAGS. W selects a qword only in mode64; mode32 keeps the spelling.
+var x86ScalarBitFieldSpecs = map[Op]x86ScalarBitFieldSpec{
+	"BEXTRL": {x86BitFieldExtract, 32, 2, x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF},
+	"BEXTRQ": {x86BitFieldExtract, 64, 2, x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF},
+	"BZHIL":  {x86BitFieldZeroHigh, 32, 1, x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF},
+	"BZHIQ":  {x86BitFieldZeroHigh, 64, 1, x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF},
+}
+
+type x86ScalarBitFieldForm struct {
+	bits                         int
+	control, source, destination Operand
+	spec                         x86ScalarBitFieldSpec
+}
+
+func x86ScalarBitFieldProperties(op Op, ins Instr, arch string) (x86ScalarBitFieldForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ScalarBitFieldSpecs[Op(name)]
+	form := x86ScalarBitFieldForm{bits: spec.bits, spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "386" {
+		form.bits = 32
+	}
+	fail := func() (x86ScalarBitFieldForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go scalar bit-field grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 3 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	form.control, form.source, form.destination = ins.Args[0], ins.Args[1], ins.Args[2]
+	for _, operand := range []Operand{form.control, form.destination} {
+		if operand.Kind != OpReg || !isX86YrlRegisterForArch(operand.Reg, arch) {
+			return fail()
+		}
+	}
+	if form.source.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.source.Reg, arch) {
+			return fail()
+		}
+	} else if !isAMD64MemoryOperand(form.source) || !x86PackedShiftMemoryValid(form.source, arch) ||
+		x86NamedMultiplyMemoryError(form.source, arch) != nil {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86ScalarBitFieldFamilyProperties(op Op, ins Instr, arch string, kind x86ScalarBitFieldKind) (x86ScalarBitFieldForm, bool, error) {
+	form, known, err := x86ScalarBitFieldProperties(op, ins, arch)
+	if !known || form.spec.kind != kind {
+		return form, false, nil
+	}
+	return form, true, err
+}
diff --git a/amd64_scalar_bitscan.go b/amd64_scalar_bitscan.go
new file mode 100644
index 000000000..8c2118205
--- /dev/null
+++ b/amd64_scalar_bitscan.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarBitScanSpec struct {
+	bits    int
+	reverse bool
+}
+
+// All six Go yml_rl rows. Zero input cannot independently initialize the
+// destination: current Intel SDM preserves it, with a historical dword upper
+// half exception. Only a whole native opcode retains that target's behavior.
+var x86ScalarBitScanSpecs = map[Op]x86ScalarBitScanSpec{
+	"BSFW": {16, false}, "BSFL": {32, false}, "BSFQ": {64, false},
+	"BSRW": {16, true}, "BSRL": {32, true}, "BSRQ": {64, true},
+}
+
+func x86ScalarBitScanProperties(op Op, ins Instr, arch string) (x86ScalarBitScanSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ScalarBitScanSpecs[Op(name)]
+	if !known {
+		return spec, false, nil
+	}
+	// This is exactly the same complete Yml-to-Yrl operand grammar as the
+	// registered count family. Reuse only its shape, never its defined value
+	// or status flags, and preserve the original source instruction identity.
+	shape := ins
+	shape.Op = Op(fmt.Sprintf("POPCNT%s", name[len(name)-1:]))
+	_, _, err := x86ScalarBitCountProperties(shape.Op, shape, arch)
+	if dotted || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || err != nil {
+		return spec, true, fmt.Errorf("%s %s outside Go scalar bit-scan grammar: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
diff --git a/amd64_scalar_bitscan_execution_driver_test.go b/amd64_scalar_bitscan_execution_driver_test.go
new file mode 100644
index 000000000..c429bf16f
--- /dev/null
+++ b/amd64_scalar_bitscan_execution_driver_test.go
@@ -0,0 +1,382 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86BitScanOriginalExecutionDriver(t *testing.T, fixture x86BitScanExecutionFixture) string {
+	t.Helper()
+	typ := "uint64"
+	if fixture.arch == "386" {
+		typ = "uint32"
+	}
+	var registrations, inputs, priors strings.Builder
+	for _, row := range fixture.rows {
+		public, observe := "Guard"+row.name, "nil"
+		if row.role >= 3 {
+			public, observe = "nil", row.name
+		}
+		fmt.Fprintf(&registrations, "{%s,%s,%d},\n", public, observe, row.role)
+	}
+	for _, value := range x86BitScanExecutionValues {
+		fmt.Fprintf(&inputs, "0x%x,", value)
+	}
+	for _, prior := range x86BitScanExecutionPriors {
+		fmt.Fprintf(&priors, "0x%x,", prior)
+	}
+	source := `package main
+	import "fmt"
+` + fixture.declarations + fixture.observerDeclarations + fixture.callerDeclarations + `
+type word = ` + typ + `
+//go:noinline
+func snapshot(p *[4]word) [4]word { return *p }
+func main() {
+ rows:=[]struct{public func(*[4]word,word,word,uint32,uint32);observe func(*[4]word,word,word,word);role int}{
+` + registrations.String() + `}
+ inputs:=[]uint64{` + inputs.String() + `}
+ priors:=[]uint64{` + priors.String() + `}
+ for _,x:=range inputs {for _,prior:=range priors {for status:=0;status<64;status++ {
+  seed:=uint64(0)
+  for bit,position:=range []uint{0,2,4,6,7,11}{seed|=uint64(status>>bit&1)<<position}
+  for _,row:=range rows {
+   left,right:=word(uint64(0x1122334455667788)^seed),word(uint64(0x8877665544332211)^prior)
+   guards:=[4]word{left,0,0,right}
+   before:=snapshot(&guards)
+   var value,flags word
+   if row.role<3 {
+    row.public(&guards,word(x),word(prior),uint32(seed),uint32(prior))
+    if guards[2]!=1{panic("original ABI0 argument/result-adjacent outgoing guards modified")}
+    value=guards[1]
+   }else{
+    row.observe(&guards,word(x),word(prior),word(seed))
+    value,flags=guards[1],guards[2]&2261
+   }
+   after:=snapshot(&guards)
+   if after[0]!=before[0]||after[3]!=before[3]{panic("original observer result-array boundary modified")}
+   fmt.Printf("%016x %04x\n",uint64(value),uint64(flags))
+  }
+ }}}
+}
+`
+	formatted, err := format.Source([]byte(source))
+	if err != nil {
+		t.Fatal("original driver must be complete actual Go source", err)
+	}
+	return string(formatted)
+}
+
+// A test-private view of the compiler's physical helper, never a Go source or
+// Options capability. Public numerical functions still expose portable ZF only.
+func x86BitScanExecutionStatusShim(t *testing.T, fixture x86BitScanExecutionFixture, ir string) string {
+	t.Helper()
+	word := 64
+	if fixture.arch == "386" {
+		word = 32
+	}
+	var output strings.Builder
+	for _, row := range fixture.rows {
+		if row.role < 3 {
+			continue
+		}
+		spec := x86ScalarBitScanSpecs[Op(row.op)]
+		helper := x86BitScanHelperName("__plan9asm_bitscan_0_", fixture.arch, Op(row.op))
+		if !strings.Contains(ir, "@"+helper+"(") {
+			t.Fatal("test status shim needs this actual module's internal helper", helper)
+		}
+		fmt.Fprintf(&output, "define void @%s(ptr %%out, i%d %%x, i%d %%prior, i%d %%seed) {\nentry:\n", row.name, word, word, word)
+		input := "%x"
+		if spec.bits != word {
+			fmt.Fprintf(&output, "  %%input = trunc i%d %%x to i%d\n", word, spec.bits)
+			input = "%input"
+		}
+		prior := "%prior"
+		if row.role == 4 {
+			prior = "%x"
+		}
+		fmt.Fprintf(&output, "  %%result = call { i%d, i%d } @%s(i%d %s, i%d %s, i%d %%seed)\n", word, word, helper, spec.bits, input, word, prior, word)
+		fmt.Fprintf(&output, "  %%value = extractvalue { i%d, i%d } %%result, 0\n  %%flags = extractvalue { i%d, i%d } %%result, 1\n", word, word, word, word)
+		fmt.Fprintf(&output, "  %%valuep = getelementptr i%d, ptr %%out, i32 1\n  %%flagsp = getelementptr i%d, ptr %%out, i32 2\n", word, word)
+		fmt.Fprintf(&output, "  store i%d %%value, ptr %%valuep\n  store i%d %%flags, ptr %%flagsp\n  ret void\n}\n", word, word)
+	}
+	return ir + "\n" + output.String()
+}
+
+func x86BitScanLLVMExecutionDriver(fixture x86BitScanExecutionFixture) string {
+	typ, stack := "uint64_t", "movq %%rsp,%0"
+	if fixture.arch == "386" {
+		typ, stack = "uint32_t", "movl %%esp,%0"
+	}
+	var declarations, registrations, inputs, priors strings.Builder
+	for _, row := range fixture.rows {
+		public, observe := row.name, "NULL"
+		if row.role >= 3 {
+			public, observe = "NULL", row.name
+			fmt.Fprintf(&declarations, "extern void %s(word*,word,word,word);\n", row.name)
+		} else {
+			fmt.Fprintf(&declarations, "extern word %s(word,word,uint32_t,uint32_t);\n", row.name)
+		}
+		fmt.Fprintf(&registrations, "{%s,%s,%d},\n", public, observe, row.role)
+	}
+	for _, value := range x86BitScanExecutionValues {
+		fmt.Fprintf(&inputs, "UINT64_C(0x%x),", value)
+	}
+	for _, prior := range x86BitScanExecutionPriors {
+		fmt.Fprintf(&priors, "UINT64_C(0x%x),", prior)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+
+typedef ` + typ + ` word;
+
+static __attribute__((always_inline)) inline uintptr_t stack_pointer(void) {
+    uintptr_t value;
+    __asm__ volatile("` + stack + `" : "=r"(value) : : "memory");
+    return value;
+}
+
+` + declarations.String() + `
+static const struct {
+    word (*public)(word, word, uint32_t, uint32_t);
+    void (*observe)(word *, word, word, word);
+    int role;
+} rows[] = {
+` + registrations.String() + `};
+
+int main(int argc, char **argv) {
+    if (argc != 2)
+        return 1;
+
+    FILE *reference = fopen(argv[1], "r");
+    if (!reference)
+        return 2;
+
+    const uint64_t inputs[] = {` + inputs.String() + `},
+        priors[] = {` + priors.String() + `};
+    unsigned checks = 0;
+
+    for (unsigned x = 0; x < sizeof(inputs) / sizeof(inputs[0]); x++)
+        for (unsigned p = 0; p < sizeof(priors) / sizeof(priors[0]); p++)
+            for (unsigned status = 0; status < 64; status++) {
+                uint64_t seed = 0;
+                const unsigned positions[] = {0, 2, 4, 6, 7, 11};
+                for (unsigned bit = 0; bit < 6; bit++)
+                    seed |= ((status >> bit) & 1u) << positions[bit];
+
+                for (unsigned r = 0; r < sizeof(rows) / sizeof(rows[0]); r++) {
+                    const word left = (word)(UINT64_C(0x1122334455667788) ^ seed),
+                        right = (word)(UINT64_C(0x8877665544332211) ^ priors[p]);
+                    volatile word guards[] = {left, 0, 0, right};
+                    word value = 0, flags = 0;
+                    const uintptr_t stackBefore = stack_pointer();
+
+                    if (rows[r].role < 3)
+                        value = rows[r].public((word)inputs[x], (word)priors[p],
+                                              (uint32_t)seed, (uint32_t)priors[p]);
+                    else {
+                        rows[r].observe((word *)guards, (word)inputs[x],
+                                        (word)priors[p], (word)seed);
+                        value = guards[1];
+                        flags = guards[2] & 2261u;
+                    }
+
+                    const uintptr_t stackAfter = stack_pointer();
+                    unsigned long long expectedValue = 0, expectedFlags = 0;
+                    if (fscanf(reference, "%llx %llx", &expectedValue, &expectedFlags) != 2 ||
+                        (uint64_t)value != expectedValue ||
+                        (uint64_t)flags != expectedFlags ||
+                        guards[0] != left || guards[3] != right ||
+                        stackBefore != stackAfter) {
+                        fprintf(stderr,
+                            "bit-scan row=%u x=%llx prior=%llx seed=%llx value=%llx flags=%llx original=%llx/%llx SP=%llx/%llx or result-array boundary mismatch\n",
+                            r, (unsigned long long)inputs[x],
+                            (unsigned long long)priors[p], (unsigned long long)seed,
+                            (unsigned long long)value, (unsigned long long)flags,
+                            expectedValue, expectedFlags,
+                            (unsigned long long)stackBefore,
+                            (unsigned long long)stackAfter);
+                        fclose(reference);
+                        return 3;
+                    }
+                    checks++;
+                }
+            }
+
+    unsigned long long extraValue, extraFlags;
+    if (fscanf(reference, "%llx %llx", &extraValue, &extraFlags) != EOF) {
+        fclose(reference);
+        return 4;
+    }
+    if (fclose(reference))
+        return 5;
+
+    printf("bit-scan original/LLVM NUM+six-status+canaries checks=%u\n", checks);
+    return 0;
+}
+`
+}
+
+func x86BitScanExecuteOriginalAndLLVM(t *testing.T, arch string, execution x86FloatCompareExecution) {
+	t.Helper()
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	if execution.triple != triple || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("native bit-scan oracle needs exact direct Linux transport")
+	}
+	fixture := x86BitScanExecutionFixtureFor(t, arch)
+	dir := t.TempDir()
+	sources := map[string]string{
+		"go.mod":                 "module bitscanexec\n\ngo 1.20\n",
+		"main.go":                x86BitScanOriginalExecutionDriver(t, fixture),
+		"public_" + arch + ".s":  fixture.public,
+		"status_" + arch + ".s":  fixture.observers,
+		"callers_" + arch + ".s": fixture.callers,
+	}
+	for name, source := range sources {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("original complete source=%s SHA256=%x", name, sha256.Sum256([]byte(source)))
+	}
+	original := filepath.Join(dir, "original")
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	command := exec.Command(driver, "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOFLAGS=", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	verifyOriginal := func() {
+		for name, source := range sources {
+			actual, err := os.ReadFile(filepath.Join(dir, name))
+			if err != nil || string(actual) != source {
+				t.Fatal("complete original input changed", name, err)
+			}
+		}
+		if actualDriver, actualHash := x86LEAActualSDKDriver(t); actualDriver != driver || actualHash != driverHash {
+			t.Fatal("original source driver changed")
+		}
+	}
+	run := func(executable string, arguments ...string) []byte {
+		if arch != "386" {
+			return execution.run(t, executable, arguments...)
+		}
+		sealed, err := x87IA32StaticExecutable(executable)
+		if err != nil {
+			t.Fatal("native bit-scan i386 needs a complete static ELF", err)
+		}
+		return x87IA32RunDirect(t, sealed, arguments, os.Environ())
+	}
+	verifyOriginal()
+	observations := run(original)
+	if err := x86BitScanExecutionCheckRecords(fixture, observations); err != nil {
+		t.Fatal("original hardware destination/ZF/whole observation failed", err)
+	}
+	reference := filepath.Join(dir, "original.records")
+	if err := os.WriteFile(reference, observations, 0600); err != nil {
+		t.Fatal(err)
+	}
+	verifyRecords := func() {
+		actual, err := os.ReadFile(reference)
+		if err != nil || string(actual) != string(observations) {
+			t.Fatal("original records changed around LLVM observation", err)
+		}
+	}
+	count := len(fixture.rows) * len(x86BitScanExecutionValues) * len(x86BitScanExecutionPriors) * 64
+	want := fmt.Sprintf("bit-scan original/LLVM NUM+six-status+canaries checks=%d\n", count)
+	t.Logf("native original Go arch=%s records=%d driver=%x output=%x", arch, count, driverHash, sha256.Sum256(observations))
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, fixture.public, fixture.declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete original numerical source failed", err)
+			}
+			ir = x86BitScanExecutionStatusShim(t, fixture, ir)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, input)
+					}
+					executable := execution.compileLLVM(t, "bitscan", input, x86BitScanLLVMExecutionDriver(fixture), level)
+					verifyRecords()
+					if output := run(executable, reference); string(output) != want {
+						t.Fatal("native original-Go/LLVM destination/status/canary disagreement", string(output))
+					}
+					verifyRecords()
+					verifyOriginal()
+				})
+			}
+		})
+	}
+	verifyOriginal()
+	verifyRecords()
+}
+
+func TestX86ScalarBitScanExecutionPhysicalStatusShimKeepsPublicRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		fixture := x86BitScanExecutionFixtureFor(t, arch)
+		// Parse the complete original Go driver without building or executing.
+		x86BitScanOriginalExecutionDriver(t, fixture)
+		for _, api := range []string{"text", "module", "Go"} {
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			ir, err := x86ScalarFPBitViewAPI(t, fixture.public, fixture.declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal(err)
+			}
+			shim := x86BitScanExecutionStatusShim(t, fixture, ir)
+			ctx := llvm.NewContext()
+			module, err := parseIRModuleInContext(ctx, shim)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			ctx.Dispose()
+			if err != nil {
+				t.Fatal("test-private complete shim IR malformed", err)
+			}
+			if strings.Contains(ir, "@Observe") || strings.Count(shim, "define void @Observe") != len(fixture.rows)*2/5 {
+				t.Fatal("physical observer leaked into ordinary public NUM module")
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitScanExecutionStatusObservationDoesNotAuthorizePublicFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		fixture := x86BitScanExecutionFixtureFor(t, arch)
+		typ, move, word, triple := "uint64", "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			typ, move, word, triple = "uint32", "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for _, row := range fixture.rows {
+			if row.role != 0 {
+				continue
+			}
+			for _, consumer := range []string{"SETCS ret+RESULT(FP)", "SETPS ret+RESULT(FP)", "SETMI ret+RESULT(FP)", "SETOS ret+RESULT(FP)", "LAHF\nMOVB AH,ret+RESULT(FP)"} {
+				declaration := fmt.Sprintf("func view(x,prior %s) byte\n", typ)
+				body := fmt.Sprintf("%s x+0(FP),AX\n%s prior+%d(FP),BX\n%s AX,BX\n%s", move, move, word, row.op, consumer)
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+row.op+"/"+consumer+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("test-only physical flag shim granted public nonportable flag permission", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_bitscan_execution_fixture_test.go b/amd64_scalar_bitscan_execution_fixture_test.go
new file mode 100644
index 000000000..338d1472b
--- /dev/null
+++ b/amd64_scalar_bitscan_execution_fixture_test.go
@@ -0,0 +1,348 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"math/bits"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86BitScanExecutionRow struct {
+	name, op string
+	role     int // Prior, Alias, ZeroFlag, original-only Observe, ObserveAlias.
+}
+
+type x86BitScanExecutionFixture struct {
+	arch, public, declarations, observers, observerDeclarations string
+	callers, callerDeclarations                                 string
+	rows                                                        []x86BitScanExecutionRow
+}
+
+var x86BitScanExecutionValues = []uint64{0, 1, 7, 128, 255, 0x10000, 0x80000000, 0x8000000000000000, ^uint64(0)}
+var x86BitScanExecutionPriors = []uint64{0, ^uint64(0), 0x1122334455667788, 0x8877665544332211}
+
+func x86BitScanExecutionSeed(index int) uint64 {
+	var result uint64
+	for bit, position := range []uint{0, 2, 4, 6, 7, 11} {
+		result |= uint64(index>>bit&1) << position
+	}
+	return result
+}
+
+func x86BitScanExecutionFixtureFor(t *testing.T, arch string) x86BitScanExecutionFixture {
+	t.Helper()
+	source, declarations := x86BitScanOriginalObjectFixture(t, arch)
+	fixture := x86BitScanExecutionFixture{arch: arch, public: source, declarations: declarations,
+		callers: "#include \"funcdata.h\"\n"}
+	word, typ, suffix := 8, "uint64", "Q"
+	if arch == "386" {
+		word, typ, suffix = 4, "uint32", "L"
+	}
+	for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+		if arch == "386" && strings.HasSuffix(op, "Q") {
+			continue // No Go mode32 Q instruction exists; its grammar stays rejected.
+		}
+		for role, prefix := range []string{"Prior", "Alias", "ZeroFlag", "Observe", "ObserveAlias"} {
+			name := prefix + op
+			fixture.rows = append(fixture.rows, x86BitScanExecutionRow{name, op, role})
+			if role < 3 {
+				declaration, caller := x86BitScanExecutionGuardCallerFor(t, arch, name)
+				fixture.callerDeclarations += declaration
+				fixture.callers += caller
+				continue
+			}
+			fixture.observerDeclarations += fmt.Sprintf("func %s(out *[4]%s,x,prior,status %s)\n", name, typ, typ)
+			destination := "BX"
+			if role == 4 {
+				destination = "AX"
+			}
+			// Independent original-only physical observation. Neither this
+			// FLAGS seed nor its pointer writes enters the public translator.
+			fixture.observers += fmt.Sprintf(`TEXT ·%s(SB),4,$0-%d
+MOV%s out+0(FP),DI
+MOV%s x+%d(FP),AX
+MOV%s prior+%d(FP),BX
+MOV%s status+%d(FP),CX
+AND%s $2261,CX
+OR%s $2,CX
+PUSH%s CX
+POPF%s
+%s AX,%s
+PUSHF%s
+POP%s DX
+MOV%s %s,%d(DI)
+MOV%s DX,%d(DI)
+RET
+`, name, 4*word, suffix, suffix, word, suffix, 2*word, suffix, 3*word,
+				suffix, suffix, suffix, suffix, op, destination, suffix, suffix,
+				suffix, destination, word, suffix, 2*word)
+		}
+	}
+	return fixture
+}
+
+// Original-only callers check the actual ABI0 outgoing arguments and two
+// adjacent post-result slots. They are not translated source or caller proof.
+func x86BitScanExecutionGuardCallerFor(t *testing.T, arch, name string) (string, string) {
+	t.Helper()
+	word, typ, suffix := 8, "uint64", "Q"
+	if arch == "386" {
+		word, typ, suffix = 4, "uint32", "L"
+	}
+	declaration := fmt.Sprintf("func Guard%s(out *[4]%s,x,prior %s,a,b uint32)\n", name, typ, typ)
+	pkg := mustGoPackage(t, "caller", "package caller\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("Guard"+name, pkg.Types.Scope().Lookup("Guard"+name).(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil || len(sig.Frame.Params) != 5 || len(sig.Frame.Results) != 0 || sig.Frame.Params[1].Offset != int64(word) || sig.Frame.Params[2].Offset != int64(2*word) || sig.Frame.Params[3].Offset != int64(3*word) || sig.Frame.Params[4].Offset != int64(3*word+4) {
+		t.Fatal("original caller lost its complete actual Go ABI0 layout", err)
+	}
+	result := 2*word + 8
+	arguments := []struct {
+		name          string
+		input, output int
+		suffix        string
+	}{{"x", word, 0, suffix}, {"prior", 2 * word, word, suffix}, {"a", 3 * word, 2 * word, "L"}, {"b", 3*word + 4, 2*word + 4, "L"}}
+	var assembly strings.Builder
+	fmt.Fprintf(&assembly, "TEXT ·Guard%s(SB),4,$%d-%d\nNO_LOCAL_POINTERS\n", name, result+3*word, 3*word+8)
+	for _, argument := range arguments {
+		fmt.Fprintf(&assembly, "MOV%s %s+%d(FP),AX\nMOV%s AX,%d(SP)\n", argument.suffix, argument.name, argument.input, argument.suffix, argument.output)
+	}
+	for index, value := range []int{0x77a7a7a7, 0x2468ace, 0x13579bdf} {
+		fmt.Fprintf(&assembly, "MOV%s $%#x,%d(SP)\n", suffix, value, result+index*word)
+	}
+	fmt.Fprintf(&assembly, "CALL ·%s(SB)\nMOV%s out+0(FP),DI\nMOV%s $1,BX\n", name, suffix, suffix)
+	for index, value := range []int{0x2468ace, 0x13579bdf} {
+		fmt.Fprintf(&assembly, "MOV%s $%#x,AX\nMOV%s %d(SP),CX\nCMP%s AX,CX\nJNE broken\n", suffix, value, suffix, result+(index+1)*word, suffix)
+	}
+	for _, argument := range arguments {
+		fmt.Fprintf(&assembly, "MOV%s %s+%d(FP),AX\nMOV%s %d(SP),CX\nCMP%s AX,CX\nJNE broken\n", argument.suffix, argument.name, argument.input, argument.suffix, argument.output, argument.suffix)
+	}
+	fmt.Fprintf(&assembly, "JMP guarded\nbroken:\nMOV%s $0,BX\nguarded:\nMOV%s BX,%d(DI)\nMOV%s %d(SP),AX\nMOV%s AX,%d(DI)\nRET\n", suffix, suffix, 2*word, suffix, result, suffix, word)
+	return declaration, assembly.String()
+}
+
+func x86BitScanExecutionWord(value uint64, arch string) uint64 {
+	if arch == "386" {
+		return uint64(uint32(value))
+	}
+	return value
+}
+
+// An independent numeric oracle. The historical dword-zero high half has two
+// allowed physical observations; only actual original-Go records choose one.
+// Other five status flags have no invented mathematical expectation.
+func x86BitScanExecutionAccepts(row x86BitScanExecutionRow, arch string, x, prior, got, flags uint64) bool {
+	x, prior = x86BitScanExecutionWord(x, arch), x86BitScanExecutionWord(prior, arch)
+	if got != x86BitScanExecutionWord(got, arch) || flags&^uint64(2261) != 0 {
+		return false
+	}
+	width := map[byte]int{'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+	input := x
+	if width < 64 {
+		input &= uint64(1)<<width - 1
+	}
+	if row.role == 1 || row.role == 4 {
+		prior = x
+	}
+	if row.role < 3 && flags != 0 || row.role >= 3 && (flags>>6&1 == 1) != (input == 0) {
+		return false
+	}
+	want := prior
+	if input != 0 {
+		want = uint64(bits.TrailingZeros64(input))
+		if strings.HasPrefix(row.op, "BSR") {
+			want = uint64(63 - bits.LeadingZeros64(input))
+		}
+		if width == 16 {
+			want |= prior &^ 0xffff
+		}
+	}
+	if row.role == 2 && input == 0 {
+		want ^= uint64(1) << map[string]uint{"amd64": 63, "386": 31}[arch]
+	}
+	if got == want {
+		return true
+	}
+	if input == 0 && width == 32 && arch == "amd64" {
+		old := prior & 0xffffffff
+		if row.role == 2 {
+			old ^= uint64(1) << 63
+		}
+		return got == old
+	}
+	return false
+}
+
+func x86BitScanExecutionVisit(fixture x86BitScanExecutionFixture, visit func(x, prior, seed uint64, row x86BitScanExecutionRow) error) error {
+	for _, x := range x86BitScanExecutionValues {
+		for _, prior := range x86BitScanExecutionPriors {
+			for status := 0; status < 64; status++ {
+				for _, row := range fixture.rows {
+					if err := visit(x, prior, x86BitScanExecutionSeed(status), row); err != nil {
+						return err
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func x86BitScanExecutionCheckRecords(fixture x86BitScanExecutionFixture, output []byte) error {
+	lines := strings.Split(strings.TrimSuffix(string(output), "\n"), "\n")
+	index := 0
+	err := x86BitScanExecutionVisit(fixture, func(x, prior, seed uint64, row x86BitScanExecutionRow) error {
+		if index >= len(lines) {
+			return fmt.Errorf("missing original physical observation %d", index)
+		}
+		fields := strings.Fields(lines[index])
+		if len(fields) != 2 {
+			return fmt.Errorf("invalid original physical observation %d", index)
+		}
+		value, valueErr := strconv.ParseUint(fields[0], 16, 64)
+		flags, flagsErr := strconv.ParseUint(fields[1], 16, 64)
+		if valueErr != nil || flagsErr != nil || !x86BitScanExecutionAccepts(row, fixture.arch, x, prior, value, flags) {
+			return fmt.Errorf("original %s x=%x prior=%x seed=%x observation %d: %q", row.name, x, prior, seed, index, lines[index])
+		}
+		index++
+		return nil
+	})
+	if err == nil && index != len(lines) {
+		err = fmt.Errorf("unexpected original observation count %d (want %d)", len(lines), index)
+	}
+	return err
+}
+
+func TestX86ScalarBitScanExecutionOracleDoesNotInventZeroOrFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		fixture := x86BitScanExecutionFixtureFor(t, arch)
+		wantNames := 6
+		if arch == "386" {
+			wantNames = 4
+		}
+		if len(fixture.rows) != 5*wantNames || strings.Count(fixture.public, "TEXT ·") != 3*wantNames || strings.Count(fixture.observers, "TEXT ·") != 2*wantNames {
+			t.Fatal("complete original public/physical source inventory missing")
+		}
+		if strings.Count(fixture.callers, "TEXT ·Guard") != 3*wantNames || strings.Count(fixture.callers, "CALL ·") != 3*wantNames || strings.Count(fixture.callers, "NO_LOCAL_POINTERS") != 3*wantNames || strings.Count(fixture.callers, "0x2468ace") != 6*wantNames || strings.Count(fixture.callers, "0x13579bdf") != 6*wantNames {
+			t.Fatal("actual ABI0 outgoing argument/result-adjacent guard inventory missing")
+		}
+		if strings.Contains(fixture.public, "PUSH") || strings.Contains(fixture.public, "POPF") || strings.Count(fixture.observers, "PUSH"+map[string]string{"amd64": "Q", "386": "L"}[arch]) != 2*wantNames {
+			t.Fatal("test-only physical FLAGS observation leaked into numerical source")
+		}
+		for _, row := range fixture.rows {
+			prior := x86BitScanExecutionWord(0x1122334455667788, arch)
+			if row.role == 1 || row.role == 4 {
+				continue // Its prior is the actual source, separately covered below.
+			}
+			flags, good := uint64(0), prior
+			if row.role >= 3 {
+				flags = 1 << 6
+			}
+			if row.role == 2 {
+				good ^= uint64(1) << map[string]uint{"amd64": 63, "386": 31}[arch]
+			}
+			if !x86BitScanExecutionAccepts(row, arch, 0, prior, good, flags) {
+				t.Fatal("known zero prior was not retained", row)
+			}
+			for _, invented := range []uint64{16, 32, 64, ^uint64(0)} {
+				if x86BitScanExecutionAccepts(row, arch, 0, prior, invented, flags) {
+					t.Fatal("old software zero result became an allowed physical observation", row, invented)
+				}
+			}
+			if row.role >= 3 {
+				for seed := 0; seed < 64; seed++ {
+					other := x86BitScanExecutionSeed(seed) | 1<<6
+					if !x86BitScanExecutionAccepts(row, arch, 0, prior, good, other) || x86BitScanExecutionAccepts(row, arch, 0, prior, good, other&^(1<<6)) {
+						t.Fatal("oracle guessed nonportable status bits or ignored portable ZF")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitScanExecutionOracleCompleteWidthsAliasesAndRecords(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		fixture := x86BitScanExecutionFixtureFor(t, arch)
+		for _, row := range fixture.rows {
+			width := map[byte]int{'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+			for _, x := range []uint64{0, 1, 7, 128, 255, 1 << (width - 1)} {
+				prior := x86BitScanExecutionWord(0x1122334455667788, arch)
+				if row.role == 1 || row.role == 4 {
+					prior = x86BitScanExecutionWord(x, arch)
+				}
+				want := prior
+				if x != 0 {
+					want = uint64(bits.TrailingZeros64(x))
+					if strings.HasPrefix(row.op, "BSR") {
+						want = uint64(63 - bits.LeadingZeros64(x))
+					}
+					if width == 16 {
+						want |= prior &^ 0xffff
+					}
+				}
+				if row.role == 2 && x == 0 {
+					want ^= uint64(1) << map[string]uint{"amd64": 63, "386": 31}[arch]
+				}
+				flags := uint64(0)
+				if row.role >= 3 && x == 0 {
+					flags = 1 << 6
+				}
+				if !x86BitScanExecutionAccepts(row, arch, x, prior, want, flags) || x86BitScanExecutionAccepts(row, arch, x, prior, want^0x8000, flags) {
+					t.Fatal("scan width/prior/alias numeric model changed", arch, row, x)
+				}
+			}
+			if arch == "amd64" && width == 32 {
+				prior := uint64(0x1122334455667788)
+				x := uint64(0)
+				if row.role == 1 || row.role == 4 {
+					x, prior = 1<<32, 1<<32 // A zero dword with live high alias bytes.
+				}
+				flags, full, low := uint64(0), prior, prior&0xffffffff
+				if row.role >= 3 {
+					flags = 1 << 6
+				}
+				if row.role == 2 {
+					full, low = full^(1<<63), low^(1<<63)
+				}
+				if !x86BitScanExecutionAccepts(row, arch, x, prior, full, flags) || !x86BitScanExecutionAccepts(row, arch, x, prior, low, flags) || x86BitScanExecutionAccepts(row, arch, x, prior, low|1<<40, flags) {
+					t.Fatal("oracle guessed old/new CPU dword-zero upper behavior", row)
+				}
+			}
+		}
+		// A complete synthetic record stream certifies the reader's checking,
+		// not execution. Give the nonportable five flags arbitrary values.
+		one := x86BitScanExecutionFixture{arch: arch, rows: []x86BitScanExecutionRow{{"ObserveBSFQ", "BSFQ", 3}}}
+		if arch == "386" {
+			one.rows[0].name, one.rows[0].op = "ObserveBSFL", "BSFL"
+		}
+		var records strings.Builder
+		err := x86BitScanExecutionVisit(one, func(x, prior, seed uint64, row x86BitScanExecutionRow) error {
+			x, prior = x86BitScanExecutionWord(x, arch), x86BitScanExecutionWord(prior, arch)
+			value, flags := prior, seed&^(1<<6)
+			if x == 0 {
+				flags |= 1 << 6
+			} else {
+				value = uint64(bits.TrailingZeros64(x))
+			}
+			fmt.Fprintf(&records, "%016x %04x\n", value, flags)
+			return nil
+		})
+		if err != nil || x86BitScanExecutionCheckRecords(one, []byte(records.String())) != nil {
+			t.Fatal("bounded complete record reader rejected numeric/ZF observations", err)
+		}
+		lines := strings.Split(strings.TrimSuffix(records.String(), "\n"), "\n")
+		for _, bad := range []string{
+			strings.Join(lines[:len(lines)-1], "\n") + "\n",
+			records.String() + "0 0\n",
+			"not-a-record\n" + strings.Join(lines[1:], "\n") + "\n",
+			"0000000000000040 0040\n" + strings.Join(lines[1:], "\n") + "\n",
+			"0000000000000000 0000\n" + strings.Join(lines[1:], "\n") + "\n",
+		} {
+			if x86BitScanExecutionCheckRecords(one, []byte(bad)) == nil {
+				t.Fatal("missing/extra/invalid/invented-zero/ZF record escaped validation")
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_bitscan_execution_linux_amd64_test.go b/amd64_scalar_bitscan_execution_linux_amd64_test.go
new file mode 100644
index 000000000..128a2ea33
--- /dev/null
+++ b/amd64_scalar_bitscan_execution_linux_amd64_test.go
@@ -0,0 +1,36 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86BitScanNativeAMD64OriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native bit-scan owner requires LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	x86BitScanExecuteOriginalAndLLVM(t, "amd64", execution)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86BitScanNative386OriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("native i386 bit-scan owner requires LLVM22/i686 compiler", err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		// Keep one fixed outgoing C frame so the SP observation does not
+		// mistake GCC's deferred caller-argument cleanup for an unbalanced
+		// compiler helper. This changes no translated Go source/ABI role.
+		compiler: []string{compiler, "-static", "-no-pie", "-maccumulate-outgoing-args"}}
+	x86BitScanExecuteOriginalAndLLVM(t, "386", execution)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_scalar_bitscan_execution_object_test.go b/amd64_scalar_bitscan_execution_object_test.go
new file mode 100644
index 000000000..02ad3cd71
--- /dev/null
+++ b/amd64_scalar_bitscan_execution_object_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Compile the exact native fixtures on every development host. This checks
+// original ABI0 callers, physical observers and test-private LLVM shims before
+// the Linux owners execute them; object success never stands in for execution.
+func TestX86ScalarBitScanExecutionCompleteOriginalGoLinksAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete native bit-scan fixtures require LLVM22 llc")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			fixture := x86BitScanExecutionFixtureFor(t, arch)
+			dir := t.TempDir()
+			sources := map[string]string{
+				"go.mod":                 "module bitscanexec\n\ngo 1.20\n",
+				"main.go":                x86BitScanOriginalExecutionDriver(t, fixture),
+				"public_" + arch + ".s":  fixture.public,
+				"status_" + arch + ".s":  fixture.observers,
+				"callers_" + arch + ".s": fixture.callers,
+			}
+			for name, source := range sources {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Logf("original complete input=%s SHA256=%x", name, sha256.Sum256([]byte(source)))
+			}
+			driver, driverHash := x86LEAActualSDKDriver(t)
+			verify := func() {
+				for name, source := range sources {
+					actual, err := os.ReadFile(filepath.Join(dir, name))
+					if err != nil || string(actual) != source {
+						t.Fatal("complete original fixture changed", name, err)
+					}
+				}
+				actualDriver, actualHash := x86LEAActualSDKDriver(t)
+				if actualDriver != driver || actualHash != driverHash {
+					t.Fatal("original fixture compiler changed")
+				}
+			}
+			original := filepath.Join(dir, "original")
+			command := exec.Command(driver, "build", "-p=1", "-o", original, ".")
+			command.Dir = dir
+			command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+				"GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOFLAGS=", "GOMAXPROCS=2")
+			verify()
+			x86FloatCompareCaptureCommand(t, command)
+			verify()
+			info, err := os.Lstat(original)
+			if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatal("original complete Go executable is missing or invalid", err)
+			}
+
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, fixture.public, fixture.declarations, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original numerical fixture failed", err)
+					}
+					ir = x86BitScanExecutionStatusShim(t, fixture, ir)
+					for _, optimize := range []bool{false, true} {
+						input := ir
+						if optimize {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimize, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, triple, input, level)
+							})
+						}
+					}
+				})
+			}
+			verify()
+		})
+	}
+}
diff --git a/amd64_scalar_bitscan_execution_policy_test.go b/amd64_scalar_bitscan_execution_policy_test.go
new file mode 100644
index 000000000..dc3ff64e9
--- /dev/null
+++ b/amd64_scalar_bitscan_execution_policy_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarBitScanRuntimeNativeOwnersCannotEmulateOrSkip(t *testing.T) {
+	const path = "amd64_scalar_bitscan_execution_linux_amd64_test.go"
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal("required original-Go/LLVM bit-scan execution owners absent", err)
+	}
+	if err := x86BitScanNativeOwnerPolicy(source); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func x86BitScanNativeOwnerPolicy(source []byte) error {
+	source = normalizeNativeOwnerPolicySource(source)
+	if !strings.HasPrefix(string(source), "//go:build linux && amd64\n") {
+		return fmt.Errorf("required bit-scan counterparts lost their native Linux owner")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "native-owner.go", source, 0)
+	if err != nil {
+		return err
+	}
+	roots := map[string]string{
+		"TestCrossLinuxRuntimeMatrixX86BitScanNativeAMD64OriginalGoAndLLVM": "amd64",
+		"TestCrossLinuxRuntimeMatrixX86BitScanNative386OriginalGoAndLLVM":   "386",
+	}
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		arch, required := roots[fn.Name.Name]
+		if !required {
+			continue
+		}
+		gates, executions := 0, 0
+		var gatePositions []token.Pos
+		var executionPosition token.Pos
+		var invalid error
+		topLevel := make(map[*ast.CallExpr]bool)
+		for _, statement := range fn.Body.List {
+			if expression, ok := statement.(*ast.ExprStmt); ok {
+				if call, ok := expression.X.(*ast.CallExpr); ok {
+					topLevel[call] = true
+				}
+			}
+		}
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			switch value := node.(type) {
+			case *ast.CallExpr:
+				if name, ok := value.Fun.(*ast.Ident); ok {
+					if name.Name == "x87IA32RequireNativeHost" {
+						gates++
+						gatePositions = append(gatePositions, value.Pos())
+						if !topLevel[value] {
+							invalid = fmt.Errorf("native observation must run at top level")
+						}
+					}
+					if name.Name == "x86BitScanExecuteOriginalAndLLVM" {
+						executions++
+						executionPosition = value.Pos()
+						if !topLevel[value] {
+							invalid = fmt.Errorf("native execution must run at top level")
+						}
+						if len(value.Args) != 3 {
+							invalid = fmt.Errorf("runtime oracle lost its complete architecture")
+							return false
+						}
+						literal, ok := value.Args[1].(*ast.BasicLit)
+						if !ok || literal.Value != strconv.Quote(arch) {
+							invalid = fmt.Errorf("native owner selected another architecture")
+						}
+					}
+				}
+				if name, ok := value.Fun.(*ast.SelectorExpr); ok && strings.HasPrefix(name.Sel.Name, "Skip") {
+					invalid = fmt.Errorf("missing native tools or failed execution cannot skip")
+				}
+			case *ast.KeyValueExpr:
+				if name, ok := value.Key.(*ast.Ident); ok && (name.Name == "prefix" || name.Name == "preserveArgv0") {
+					invalid = fmt.Errorf("native owner inserted a guest/emulator transport")
+				}
+			case *ast.ReturnStmt:
+				invalid = fmt.Errorf("required native owner cannot return before observation")
+			case *ast.BasicLit:
+				if value.Kind == token.STRING {
+					literal, err := strconv.Unquote(value.Value)
+					if err != nil || strings.Contains(literal, "qemu") || literal == "-exec" {
+						invalid = fmt.Errorf("native owner inserted an execution fallback: %v", err)
+					}
+				}
+			}
+			return true
+		})
+		if invalid != nil {
+			return invalid
+		}
+		if gates != 2 || executions != 1 {
+			return fmt.Errorf("native before/after observation or whole execution absent: %s", fn.Name.Name)
+		}
+		if !(gatePositions[0] < executionPosition && executionPosition < gatePositions[1]) {
+			return fmt.Errorf("native observation must surround the actual execution: %s", fn.Name.Name)
+		}
+		delete(roots, fn.Name.Name)
+	}
+	if len(roots) != 0 {
+		return fmt.Errorf("required native denominator incomplete: %v", roots)
+	}
+	return nil
+}
+
+func TestX86ScalarBitScanRuntimeNativePolicyRejectsMutation(t *testing.T) {
+	source, err := os.ReadFile("amd64_scalar_bitscan_execution_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const call = "\tx86BitScanExecuteOriginalAndLLVM(t, \"amd64\", execution)"
+	const gate = "\tx87IA32RequireNativeHost(t)"
+	text := string(normalizeNativeOwnerPolicySource(source))
+	for name, mutation := range map[string]string{
+		"missing after":     strings.Replace(text, call+"\n"+gate, call, 1),
+		"both before":       strings.Replace(text, call+"\n"+gate, gate+"\n"+call, 1),
+		"both after":        strings.Replace(strings.Replace(text, gate+"\n", "", 1), call+"\n"+gate, call+"\n"+gate+"\n"+gate, 1),
+		"conditional after": strings.Replace(text, call+"\n"+gate, call+"\n\tif false {\n"+gate+"\n\t}", 1),
+		"conditional run":   strings.Replace(text, call, "\tif false {\n"+call+"\n\t}", 1),
+		"early return":      strings.Replace(text, call, "\treturn\n"+call, 1),
+		"skip":              strings.Replace(text, call, "\tt.Skip(\"missing tool\")\n"+call, 1),
+		"prefix":            strings.Replace(text, "{llc: llc,", "{prefix: []string{\"guest\"}, llc: llc,", 1),
+		"preserve argv":     strings.Replace(text, "{llc: llc,", "{preserveArgv0: true, llc: llc,", 1),
+		"wrong arch":        strings.Replace(text, call, strings.Replace(call, "amd64", "386", 1), 1),
+		"wrong native tags": strings.Replace(text, "linux && amd64", "darwin && amd64", 1),
+		"missing root":      strings.Replace(text, "TestCrossLinuxRuntimeMatrixX86BitScanNativeAMD64OriginalGoAndLLVM", "NoRequiredAMD64Root", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if mutation == text {
+				t.Fatal("policy mutation did not change actual native owner source")
+			}
+			if x86BitScanNativeOwnerPolicy([]byte(mutation)) == nil {
+				t.Fatal("invalid native lifecycle/transport owner accepted")
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_bitscan_native.go b/amd64_scalar_bitscan_native.go
new file mode 100644
index 000000000..fcb273227
--- /dev/null
+++ b/amd64_scalar_bitscan_native.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+func x86BitScanHelperOps(file *File, arch string) []Op {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	seen := make(map[Op]bool)
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if _, known, err := x86ScalarBitScanProperties(ins.Op, ins, arch); known && err == nil {
+				seen[Op(strings.ToUpper(string(ins.Op)))] = true
+			}
+		}
+	}
+	ops := make([]Op, 0, len(seen))
+	for op := range seen {
+		ops = append(ops, op)
+	}
+	sort.Slice(ops, func(i, j int) bool { return ops[i] < ops[j] })
+	return ops
+}
+
+func x86BitScanNamespace(file *File, arch string, resolve func(string) string, sigs map[string]FuncSig) string {
+	if len(x86BitScanHelperOps(file, arch)) == 0 {
+		return ""
+	}
+	return x86CompilerHelperNamespace(file, resolve, sigs, "bitscan")
+}
+
+func x86BitScanHelperName(namespace, arch string, op Op) string {
+	return namespace + arch + "_" + strings.ToLower(string(op))
+}
+
+func emitX86BitScanHelpers(b *strings.Builder, file *File, arch, namespace string) {
+	if namespace == "" {
+		return
+	}
+	word, push, pop := I64, "pushq", "popq"
+	if arch == "386" {
+		word, push, pop = I32, "pushl", "popl"
+	}
+	for _, op := range x86BitScanHelperOps(file, arch) {
+		spec := x86ScalarBitScanSpecs[op]
+		typ := amd64IntegerTypeForBits(spec.bits)
+		modifier := map[int]string{16: "w", 32: "k", 64: "q"}[spec.bits]
+		mnemonic := strings.ToLower(string(op))
+		name := x86BitScanHelperName(namespace, arch, op)
+		fmt.Fprintf(b, "define internal { %s, %s } @%s(%s %%source, %s %%prior, %s %%status) noinline noredzone {\nentry:\n", word, word, name, typ, word, word)
+		// Seed only virtual status representatives, never privileged FLAGS,
+		// direction/ID or a claimed physical caller-entry identity. The source
+		// observer still permits only portable ZF after a scan. Unknown other
+		// bits stay unobservable; a zero seed does not establish their validity.
+		fmt.Fprintf(b, "  %%masked = and %s %%status, %d\n  %%seed = or %s %%masked, 2\n", word, x86StatusAll, word)
+		assembly := fmt.Sprintf("%s $4; popf%s; %s ${3:%s}, ${0:%s}; pushf%s; %s $1", push, strings.TrimPrefix(pop, "pop"), mnemonic, modifier, modifier, strings.TrimPrefix(pop, "pop"), pop)
+		// The full native prior is tied to the full native output. In
+		// particular no software r32 writeback chooses the dword-zero upper
+		// behavior. Balanced temporary stack use lives only in this compiler
+		// helper; noinline+noredzone protects callers' red zones and source SP.
+		fmt.Fprintf(b, "  %%result = call { %s, %s } asm sideeffect %q, \"=r,=r,0,r,r,~{memory},~{dirflag},~{fpsr},~{flags}\"(%s %%prior, %s %%source, %s %%seed)\n", word, word, assembly, word, typ, word)
+		fmt.Fprintf(b, "  ret { %s, %s } %%result\n}\n\n", word, word)
+	}
+}
+
+func (c *amd64Ctx) lowerScalarBitScan(op Op, ins Instr) (bool, bool, error) {
+	arch := c.goarch
+	if arch == "" {
+		arch = "amd64" // The existing direct emitter's shape default.
+	}
+	spec, known, err := x86ScalarBitScanProperties(op, ins, arch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if c.bitScanNS == "" || !x86ScalarFloatIntegerNativeTarget(arch, c.targetTriple) {
+		return true, false, fmt.Errorf("%w: bit scan needs its compiler-owned bridge and matching explicit x86 target", ErrProbeNeedsContext)
+	}
+	typ, word := amd64IntegerTypeForBits(spec.bits), I64
+	if arch == "386" {
+		word = I32
+	}
+	var source string
+	if ins.Args[0].Kind == OpReg {
+		source, err = c.evalIntSized(ins.Args[0], typ)
+	} else {
+		// Retain each existing source role and exact-width volatile native
+		// read; FP/AUTO/SB observations do not become native storage authority.
+		var bytes string
+		bytes, err = c.loadX86PackedShiftBytes(ins.Args[0], spec.bits/8, true)
+		if err == nil {
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", name, spec.bits/8, bytes, typ)
+			source = "%" + name
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	prior, err := c.loadReg(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	status := c.packX86Flags()
+	if word == I32 {
+		prior, status = c.truncI64(prior, I32), c.truncI64(status, I32)
+	}
+	result, value, flags := c.newTmp(), c.newTmp(), c.newTmp()
+	name := x86BitScanHelperName(c.bitScanNS, arch, Op(strings.ToUpper(string(op))))
+	returnType := fmt.Sprintf("{ %s, %s }", word, word)
+	fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, %s %s)\n", result, returnType, name, typ, source, word, prior, word, status)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n  %%%s = extractvalue %s %%%s, 1\n", value, returnType, result, flags, returnType, result)
+	for _, flag := range c.x86StatusFlagSlots() {
+		shift, bit := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %d\n  %%%s = trunc %s %%%s to i1\n  store i1 %%%s, ptr %s\n", shift, word, flags, flag.bit, bit, word, shift, bit, flag.slot)
+	}
+	output := "%" + value
+	if word == I32 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, output)
+		output = "%" + wide
+	}
+	return true, false, c.storeReg(ins.Args[1].Reg, output)
+}
diff --git a/amd64_scalar_bitscan_object_test.go b/amd64_scalar_bitscan_object_test.go
new file mode 100644
index 000000000..7fd9b1160
--- /dev/null
+++ b/amd64_scalar_bitscan_object_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Complete source-mode cohorts, not cropped functions. Every supported name
+// retains an independent six-status ADD producer, prior destination, full-word
+// output, source/destination alias and portable ZF consumer. Q rows have no
+// legal mode32 transport; their named grammar rejection is checked separately.
+func x86BitScanOriginalObjectFixture(t *testing.T, arch string) (source, declarations string) {
+	t.Helper()
+	move, typ, word := "MOVQ", "uint64", int64(8)
+	if arch == "386" {
+		move, typ, word = "MOVL", "uint32", 4
+	}
+	for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+		if arch == "386" && strings.HasSuffix(op, "Q") {
+			continue
+		}
+		for _, role := range []string{"Prior", "Alias", "ZeroFlag"} {
+			name := role + op
+			declaration := fmt.Sprintf("func %s(x,prior %s,a,b uint32) %s\n", name, typ, typ)
+			pkg := mustGoPackage(t, "scans", "package scans\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+			if err != nil || len(sig.Frame.Params) != 4 || len(sig.Frame.Results) != 1 {
+				t.Fatal("complete original typed scan layout unavailable", err)
+			}
+			if sig.Frame.Params[1].Offset != word || sig.Frame.Params[2].Offset != 2*word || sig.Frame.Params[3].Offset != 2*word+4 || sig.Frame.Results[0].Offset != 2*word+8 {
+				t.Fatal("actual Go scan ABI0 field layout changed", sig.Frame)
+			}
+			destination := "BX"
+			if role == "Alias" {
+				destination = "AX"
+			}
+			result := sig.Frame.Results[0].Offset
+			body := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s prior+%d(FP),BX\nMOVL a+%d(FP),CX\nMOVL b+%d(FP),DX\nADDL DX,CX\n%s AX,%s\n", name, result+word, move, move, word, 2*word, 2*word+4, op, destination)
+			if role == "ZeroFlag" {
+				// Read only portable ZF, then combine its byte into an ordinary
+				// numeric result. This grants neither bool nor other FLAGS roles.
+				body += fmt.Sprintf("SETEQ DL\nMOVBLZX DL,CX\nSHL%s $%d,CX\nXOR%s CX,%s\n", strings.TrimPrefix(move, "MOV"), word*8-1, strings.TrimPrefix(move, "MOV"), destination)
+			}
+			body += fmt.Sprintf("%s %s,ret+%d(FP)\nRET\n", move, destination, result)
+			source += body
+			declarations += declaration
+		}
+	}
+	return source, declarations
+}
+
+func TestX86ScalarBitScanCompleteOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete bit-scan objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86BitScanOriginalObjectFixture(t, target.arch)
+			count := 18
+			if target.arch == "386" {
+				count = 12
+			}
+			if strings.Count(source, "TEXT ·") != count || strings.Count(source, "ADDL DX,CX") != count {
+				t.Fatal("complete source/status producer inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original scan cohort failed", err)
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input := ir
+						if optimizeIR {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimizeIR, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarBitScanCompleteObjectFixtureNumericalRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source, declarations := x86BitScanOriginalObjectFixture(t, arch)
+		// Pure/IR counterpart only. Actual Go and LLVM objects belong to the
+		// separate required five-target root and are never inferred here.
+		x86ResultGPSIMDAdmissionAPIs(t, arch, source, declarations, true)
+	}
+}
diff --git a/amd64_scalar_compare_fault_runtime_unix_test.go b/amd64_scalar_compare_fault_runtime_unix_test.go
new file mode 100644
index 000000000..f686707fc
--- /dev/null
+++ b/amd64_scalar_compare_fault_runtime_unix_test.go
@@ -0,0 +1,101 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarCompareDeadReadFaults(t *testing.T) {
+	t.Run("scalar-sqrt", x86ScalarSqrtDeadReadFaultRuntime)
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, native, prototypes, pairs strings.Builder
+	for index, op := range x86ScalarCompareNames("amd64") {
+		name, original := fmt.Sprintf("dead%d", index), fmt.Sprintf("original%d", index)
+		// TEST $0 still reads its entire original memory operand. Neither its
+		// tautological flags nor a later independent result may suppress faults.
+		instruction := x86ScalarCompareInstruction(op, "(AX)", "$0")
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ p+0(FP),AX\n%s\nRET\n", name, instruction)
+		fmt.Fprintf(&declarations, "func %s(p *byte)\n", name)
+		code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+x86ScalarCompareInstruction(op, "(DI)", "$0")+"\nRET\n")
+		var bytes []string
+		for _, b := range code {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+		}
+		symbol := original
+		if strings.Contains(execution.triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*),%s(uint8_t*);\n", name, original)
+		fmt.Fprintf(&pairs, "{%s,%s,%d},\n", original, name, []int{1, 2, 4, 8}[index%4])
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + native.String() + `
+typedef void (*program)(uint8_t*);
+static const struct { program original,translated; int width; } pairs[]={
+` + pairs.String() + `};
+static int outcome(program fn,uint8_t *p) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        fn(p); _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    uint8_t *data=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(data==MAP_FAILED || mprotect(data+page,page,PROT_NONE)) return 2;
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(int available=0;available<=8;++available) {
+            int expected=available<pairs[i].width;
+            int a=outcome(pairs[i].original,data+page-available);
+            int b=outcome(pairs[i].translated,data+page-available);
+            if(a!=expected || b!=expected) {
+                fprintf(stderr,"dead compare=%u available=%d want=%d Go=%d LLVM=%d\n",i,available,expected,a,b);
+                return 1;
+            }
+        }
+    }
+    if(munmap(data,2*page)) return 3;
+    puts("8 compare/test dead reads x 9 guard extents");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "scalar-compare-dead", pipeline.ir, main, pipeline.level)
+					if string(output) != "8 compare/test dead reads x 9 guard extents\n" {
+						t.Fatalf("missing whole-width Go/LLVM fault receipt: %s", output)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_compare_forms.go b/amd64_scalar_compare_forms.go
new file mode 100644
index 000000000..50f1142e6
--- /dev/null
+++ b/amd64_scalar_compare_forms.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// The complete Go ycmpb/ycmpl and yxorb/ytestl rows differ in immediate
+// direction. These are operand roles, not a backing or initialization proof.
+type x86ScalarCompareForm struct {
+	bits   int
+	test   bool
+	args   [2]Operand
+	memory int
+}
+
+func x86ScalarCompareProperties(op Op, ins Instr, arch string) (x86ScalarCompareForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base := strings.SplitN(name, ".", 2)[0]
+	form := x86ScalarCompareForm{memory: -1}
+	switch base {
+	case "CMPB", "TESTB":
+		form.bits = 8
+	case "CMPW", "TESTW":
+		form.bits = 16
+	case "CMPL", "TESTL":
+		form.bits = 32
+	case "CMPQ", "TESTQ":
+		form.bits = 64
+	default:
+		return form, false, nil
+	}
+	form.test = strings.HasPrefix(base, "TEST")
+	fail := func(reason string) (x86ScalarCompareForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if name != base || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) ||
+		arch != "386" && arch != "amd64" || arch == "386" && form.bits == 64 || len(ins.Args) != 2 {
+		return fail("has an invalid mode, suffix, identity or operand count")
+	}
+	copy(form.args[:], ins.Args)
+	immediatePosition := 1
+	if form.test {
+		immediatePosition = 0
+	}
+	registers, immediates := 0, 0
+	needsTLS := false
+	for index, operand := range form.args {
+		if projected, segment, err := x86NamedSegmentMemorySource(ins, operand, arch); segment && !x86SourceTLSMemoryRole(operand, arch) {
+			if err != nil {
+				return fail("has an invalid named segment memory operand")
+			}
+			operand, form.args[index] = projected, projected
+		}
+		switch operand.Kind {
+		case OpImm:
+			if index != immediatePosition || operand.ImmIsFloat || operand.ImmRaw != "" ||
+				arch == "amd64" && (operand.Imm < -1<<31 || operand.Imm > 1<<32-1) {
+				return fail("requires a resolved Yi32 integer in its original operand position")
+			}
+			form.args[index].Imm = amd64ScalarAddSubImmediateInt64(operand.Imm, form.bits)
+			immediates++
+		case OpReg:
+			allowed := isX86YrlRegisterForArch(operand.Reg, arch)
+			if form.bits == 8 {
+				allowed = isGoYmbRegisterForArch(operand.Reg, arch)
+			}
+			if !allowed {
+				return fail("uses a register outside its Go Yrb/Yrl class")
+			}
+			registers++
+		default:
+			if operand.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+				// Non-shared 386's Yi32 includes relocated symbol addresses,
+				// but Go can emit the address relocation only for the L width.
+				// This syntax does not make the address numerical in a result proof.
+				if arch != "386" || index != immediatePosition {
+					return fail("has no relocated Yi32 row in this mode/position")
+				}
+				address := Operand{Kind: OpSym, Sym: strings.TrimPrefix(strings.TrimSpace(operand.Sym), "$")}
+				if _, _, valid := x86ScalarCompareSBAddress(address, arch); !valid {
+					return fail("has an unresolved relocated immediate")
+				}
+				if form.bits != 32 {
+					return form, true, fmt.Errorf("%w: Go %s short relocated immediate has no original relocation sink: %q", ErrProbeNeedsContext, op, ins.Raw)
+				}
+				immediates++
+				continue
+			}
+			tls := x86SourceTLSMemoryRole(operand, arch)
+			if form.memory >= 0 || !tls && !x86ScalarCompareMemoryValid(operand, arch) {
+				return fail("requires at most one encodable Ymb/Yml memory operand")
+			}
+			form.memory = index
+			needsTLS = needsTLS || tls
+		}
+	}
+	if registers == 0 && (form.memory < 0 || immediates != 1) {
+		return fail("does not match any complete Go compare/test row")
+	}
+	if needsTLS {
+		// Check the complete row first: a TLS annotation cannot make a bad
+		// register, immediate direction, or second memory operand valid.
+		return form, true, fmt.Errorf("%w: %s %s TLS memory needs its actual Go OS/arch/shared progedit, relocation and native TLS address contract: %q", ErrProbeNeedsContext, arch, op, ins.Raw)
+	}
+	if arch == "amd64" && form.bits == 8 && x86CompareExchangeHasREXByteView(x86CompareExchangeForm{
+		source: form.args[0], destination: form.args[1],
+	}) {
+		for index, operand := range form.args {
+			if operand.Kind == OpReg && (operand.Reg == AH || operand.Reg == CH || operand.Reg == DH || operand.Reg == BH) {
+				form.args[index].Reg = amd64YmbEffectiveRegister(operand.Reg, 16)
+			}
+		}
+	}
+	return form, true, nil
+}
+
+func x86ScalarCompareMemoryValid(operand Operand, arch string) bool {
+	if operand.Kind == OpFP {
+		return true // Its separate logical frame consumer validates the byte span.
+	}
+	if operand.Kind == OpSym {
+		if strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+			return false
+		}
+		if _, _, valid := x86ScalarCompareSBAddress(operand, arch); valid {
+			return true
+		}
+		address, err := parseInt(strings.TrimSpace(operand.Sym))
+		return err == nil && (address == int64(int32(address)) || arch == "386" && address == int64(uint32(address)))
+	}
+	if operand.Kind != OpMem {
+		return false
+	}
+	memory := operand.Mem
+	if x86SymbolIndexedMemoryError(memory, arch) != nil || unresolvedX86MemoryOffsetError(memory) != nil ||
+		memory.IndexExt != "" || memory.Segment != "" && memory.Segment != FS && memory.Segment != GS {
+		return false
+	}
+	if memory.Sym != "" {
+		var valid bool
+		_, memory, valid = x86ScalarCompareSBAddress(operand, arch)
+		if !valid {
+			return false
+		}
+	}
+	return x86MemoryRegistersValidForArch(memory, arch) &&
+		(memory.Off == int64(int32(memory.Off)) || arch == "386" && memory.Off == int64(uint32(memory.Off))) &&
+		(memory.Index == "" && memory.Scale == 0 || memory.Index != "" && memory.Index != SP &&
+			(memory.Scale == 1 || memory.Scale == 2 || memory.Scale == 4 || memory.Scale == 8))
+}
+
+// Unlike the same-file DATA reader this recognizes an address, including a
+// negative displacement, without claiming an allocated or initialized extent.
+func x86ScalarCompareSBAddress(operand Operand, arch string) (string, MemRef, bool) {
+	memory, valid := x86SBMemoryAddressRole(operand, arch)
+	if !valid || memory.OffRaw != "" || memory.IndexExt != "" {
+		return "", MemRef{}, false
+	}
+	base, offset, valid := parseSBRef(memory.Sym)
+	if !valid || base == "" || strings.IndexAny(base, "$+(),[] \t") >= 0 ||
+		memory.Off > 0 && offset > math.MaxInt64-memory.Off ||
+		memory.Off < 0 && offset < math.MinInt64-memory.Off {
+		return "", MemRef{}, false
+	}
+	offset += memory.Off
+	if offset != int64(int32(offset)) && !(arch == "386" && offset == int64(uint32(offset))) {
+		return "", MemRef{}, false
+	}
+	return base, memory, true
+}
diff --git a/amd64_scalar_compare_forms_test.go b/amd64_scalar_compare_forms_test.go
new file mode 100644
index 000000000..ffdc22b51
--- /dev/null
+++ b/amd64_scalar_compare_forms_test.go
@@ -0,0 +1,351 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarCompareCompleteActualGoTables(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, body := range map[string]string{
+		"ycmpb": `{Z_ib, 1, argList{Yal, Yi32}}, {Zm_ibo, 2, argList{Ymb, Yi32}},
+{Zm_r, 1, argList{Ymb, Yrb}}, {Zr_m, 1, argList{Yrb, Ymb}},`,
+		"ycmpl": `{Zm_ibo, 2, argList{Yml, Yi8}}, {Z_il, 1, argList{Yax, Yi32}},
+{Zm_ilo, 2, argList{Yml, Yi32}}, {Zm_r, 1, argList{Yml, Yrl}}, {Zr_m, 1, argList{Yrl, Yml}},`,
+		"yxorb": `{Zib_, 1, argList{Yi32, Yal}}, {Zibo_m, 2, argList{Yi32, Ymb}},
+{Zr_m, 1, argList{Yrb, Ymb}}, {Zm_r, 1, argList{Ymb, Yrb}},`,
+		"ytestl": `{Zil_, 1, argList{Yi32, Yax}}, {Zilo_m, 2, argList{Yi32, Yml}},
+{Zr_m, 1, argList{Yrl, Yml}}, {Zm_r, 1, argList{Yml, Yrl}},`,
+	} {
+		start := strings.Index(string(data), "var "+table+" = []ytab{")
+		if start < 0 {
+			t.Fatal("actual Go omitted complete comparison table", table)
+		}
+		actual := strings.SplitN(strings.SplitN(string(data)[start:], "\n}", 2)[0], "[]ytab{", 2)[1]
+		got, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+		want, wantErr := x86SignedPackedFloatGoOpcodeTokens(body)
+		if err != nil || wantErr != nil || !reflect.DeepEqual(got, want) {
+			t.Fatal("actual Go comparison table changed", table)
+		}
+	}
+}
+
+// Independent rows for ycmpb/ycmpl/yxorb/ytestl. Accumulator, general register,
+// both register/memory directions and all immediate encoding transitions.
+func x86ScalarCompareOracleRows(op, arch string) []string {
+	rows := []string{"AX,CX", "CX,AX", "AX,8(DX)", "8(DX),AX", "AX,data-3(SB)", "data+3(SB),AX",
+		"8(FS),AX", "AX,8(GS)", "-7(DX)(CX*2),AX", "0,AX"}
+	for _, immediate := range []string{"0", "1", "127", "128", "255", "256", "-128", "-129", "32768", "65535", "2147483647", "2147483648", "4294967295", "-2147483648"} {
+		for _, value := range []string{"AX", "CX", "8(DX)", "data(SB)"} {
+			operands := value + ",$" + immediate
+			if strings.HasPrefix(op, "TEST") {
+				operands = "$" + immediate + "," + value
+			}
+			rows = append(rows, operands)
+		}
+	}
+	if strings.HasSuffix(op, "B") {
+		rows = append(rows, "AH,BL", "CH,DH", "BP,SI", "DI,AX")
+		if arch == "amd64" {
+			rows = append(rows, "CH,R8B", "R9B,BH", "DIB,8(R12)")
+		}
+	} else {
+		rows = append(rows, "SP,BP", "DI,SI")
+		if arch == "amd64" {
+			rows = append(rows, "R8,R15", "16(R12)(R9*8),R11")
+		}
+	}
+	if arch == "386" {
+		rows = append(rows, "data(SB)(SP),AX", "AX,data(SB)(CX*4)")
+		if strings.HasSuffix(op, "L") {
+			rows = append(rows, strings.TrimPrefix(x86ScalarCompareInstruction(op, "AX", "$data(SB)"), op+" "))
+		}
+	}
+	return rows
+}
+
+func TestX86ScalarCompareCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, deadRegisters, deadDeclarations strings.Builder
+			var initialized, unknownMemory []x86OriginalGPInitializedFormat
+			privateOnly := 0
+			index := 0
+			for _, op := range x86ScalarCompareNames(target.arch) {
+				for _, row := range x86ScalarCompareOracleRows(op, target.arch) {
+					body := op + " " + row
+					ins := x86PureGPUnknownInstruction(t, body)
+					form, known, err := x86ScalarCompareProperties(ins.Op, ins, target.arch)
+					if !known || err != nil {
+						t.Fatalf("typed shape %s: %v", body, err)
+					}
+					name := fmt.Sprintf("form%d", index)
+					original := fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, body)
+					source.WriteString(original)
+					if form.memory >= 0 {
+						memory, partner := form.args[form.memory], form.args[1-form.memory]
+						hardwareOnly := memory.Kind == OpMem && memory.Mem.Segment != "" &&
+							memory.Mem.Base == "" && memory.Mem.Index == "" && partner.Kind == OpImm
+						if !hardwareOnly {
+							unknownMemory = append(unknownMemory, x86OriginalGPInitializedFormat{
+								source: original, declaration: "func " + name + "()",
+							})
+						}
+					} else if x86ScalarCompareOrdinaryDeadRegisters(form, target.arch) {
+						deadRegisters.WriteString(original)
+						fmt.Fprintf(&deadDeclarations, "func %s()\n", name)
+					}
+					fixture, reason := x86ScalarCompareOriginalInitializedFormat(target.arch, name, body, form)
+					if reason == "" {
+						initialized = append(initialized, fixture)
+					} else {
+						privateOnly++
+						t.Logf("original compare row %d keeps its independent role: %s: %s", index, body, reason)
+					}
+					index++
+				}
+			}
+			want := map[string]int{"amd64": 566, "386": 426}[target.arch]
+			if index != want {
+				t.Fatal("complete original compare inventory changed", index, want)
+			}
+			wantInitialized := map[string]int{"amd64": 420, "386": 306}[target.arch]
+			if len(initialized) != wantInitialized || privateOnly != want-wantInitialized {
+				t.Fatal("original compare input partition changed", len(initialized), privateOnly, wantInitialized)
+			}
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			ir := x86SingleInstructionFormatObjectUnits(t, file, signatures, target.arch, target.triple,
+				func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+					return c.lowerCmpBt(instruction.Op, instruction)
+				})
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+			}
+			for row, fixture := range unknownMemory {
+				t.Run(fmt.Sprintf("unbound-memory/row%d", row), func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("unbound original comparison acquired numerical inputs", api, err)
+						}
+					}
+				})
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run("dead-registers/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, deadRegisters.String(), deadDeclarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("ordinary dead comparison registers changed domain", err)
+					}
+				})
+			}
+			x86OriginalGPInitializedFormatObjects(t, initialized, target.arch, target.triple)
+			t.Logf("%d unchanged Go/private LLVM comparison formats; %d initialized counterparts; %d independent physical/static/address roles",
+				index, len(initialized), privateOnly)
+		})
+	}
+}
+
+func x86ScalarCompareOrdinaryDeadRegisters(form x86ScalarCompareForm, arch string) bool {
+	for _, operand := range form.args {
+		if operand.Kind == OpImm {
+			continue
+		}
+		if operand.Kind != OpReg || x86OriginalGPPhysicalRegister(operand.Reg, arch) {
+			return false
+		}
+	}
+	return true
+}
+
+func x86ScalarCompareOriginalInitializedFormat(arch, name, body string, form x86ScalarCompareForm) (x86OriginalGPInitializedFormat, string) {
+	// Both compare operands are reads. Reuse the test's ordinary two-input
+	// producer builder; this does not project a compare into a product BT form.
+	first, second := form.args[0], form.args[1]
+	if form.memory == 0 || second.Kind == OpImm {
+		first, second = second, first
+	}
+	for _, operand := range []Operand{first, second} {
+		if operand.Kind == OpSym && strings.HasPrefix(operand.Sym, "$") {
+			return x86OriginalGPInitializedFormat{}, "relocated immediate retains its source-bound numerical role"
+		}
+	}
+	for _, operand := range []*Operand{&first, &second} {
+		if operand.Kind == OpReg {
+			if base, _, alias := amd64ByteAlias(operand.Reg); alias {
+				operand.Reg = base
+			}
+		}
+	}
+	return x86BitTestOriginalInitializedFormat(arch, name, body, x86BitTestForm{index: first, destination: second})
+}
+
+func TestX86ScalarCompareMalformedForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86ScalarCompareNames(arch) {
+			bad := []string{"(AX),(CX)", "$1,$2", "X0,AX", "AX", "AX,CX,DX", "AX,K1"}
+			if strings.HasPrefix(op, "CMP") {
+				bad = append(bad, "$1,AX")
+			} else {
+				bad = append(bad, "AX,$1")
+			}
+			if strings.HasSuffix(op, "B") && arch == "386" {
+				bad = append(bad, "SP,AX")
+			} else if !strings.HasSuffix(op, "B") {
+				bad = append(bad, "AL,AX")
+			}
+			if arch == "amd64" {
+				bad = append(bad, strings.TrimPrefix(x86ScalarCompareInstruction(op, "AX", "$4294967296"), op+" "))
+			}
+			for _, row := range bad {
+				body := op + " " + row
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+				ins := x86PureGPUnknownInstruction(t, body)
+				if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Errorf("invalid Go form admitted: %s %s", arch, body)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareShortRelocationBackendDefect(t *testing.T) {
+	for _, op := range []string{"CMPB", "CMPW", "TESTB", "TESTW"} {
+		t.Run(op, func(t *testing.T) {
+			body := x86ScalarCompareInstruction(op, "AX", "$data(SB)")
+			original := "TEXT f(SB),4,$0-0\n" + body + "\nRET\n"
+			dir := t.TempDir()
+			source, object := filepath.Join(dir, "forms.s"), filepath.Join(dir, "forms.o")
+			if err := os.WriteFile(source, []byte(original), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "asm", "-o", object, source)
+			command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=386", "GOTOOLCHAIN=local")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			exit, exited := err.(*exec.ExitError)
+			if ctx.Err() != nil || !exited || exit.ProcessState == nil || !exit.ProcessState.Exited() ||
+				exit.ExitCode() != 1 || string(output) != "asm: need reloc for $data(SB)\nasm: reloc\n" {
+				t.Fatalf("unknown short relocation backend observation: %v; context %v\n%s", err, ctx.Err(), output)
+			}
+			if goAssemblerOracleOutcome(source, object, output, err, ctx.Err(), false, "386") == nil {
+				t.Fatal("backend defect became an illegal-source certificate")
+			}
+			if data, err := os.ReadFile(source); err != nil || string(data) != original {
+				t.Fatal("original source changed during backend observation", err)
+			}
+			ins := x86PureGPUnknownInstruction(t, body)
+			if _, known, err := x86ScalarCompareProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("missing original bytes became an ordinary numerical form: %v", err)
+			}
+			t.Log("GO_ASSEMBLER_DEFECT_OBSERVATION: short immediate relocation has no sink; not source rejection or a compiled Go object")
+		})
+	}
+}
+
+func TestX86ScalarCompareConditionalReadBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		ctx := &amd64Ctx{goarch: arch, resolve: func(s string) string { return s }}
+		for _, op := range x86ScalarCompareNames(arch) {
+			ins := x86PureGPUnknownInstruction(t, x86ScalarCompareInstruction(op, "-7(DX)", "AX"))
+			form, _, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			full := x86ResultState{flags: x86ByteFlagsAll}
+			full.gp[0] = 0xff
+			full.pointerGP[2] = true
+			before := full.clone()
+			if accepted, known := ctx.scalarCompareNativeResultTransfer(ins, &full, nil, arch); !known || !accepted {
+				t.Fatal("bounded-free external read rejected", arch, op)
+			}
+			before.flags = x86ByteFlagsAll
+			if form.test {
+				before.flags &^= x86ByteFlagAF
+			}
+			if !reflect.DeepEqual(full, before) {
+				t.Fatal("compare acquired more than its defined flags", arch, op)
+			}
+			for b := 0; b < form.bits/8; b++ {
+				state := before.clone()
+				state.gp[0] &^= 1 << uint(b)
+				original := state.clone()
+				if accepted, _ := ctx.scalarCompareNativeResultTransfer(ins, &state, nil, arch); accepted || !reflect.DeepEqual(state, original) {
+					t.Fatal("uninitialized register byte gained flags", arch, op, b)
+				}
+			}
+			for name, mutate := range map[string]func(*Instr){
+				"address-size": func(i *Instr) { i.x86AddressBits = 32 },
+				"unbound-size": func(i *Instr) { i.x86UnboundAddressOverride = true },
+				"raw":          func(i *Instr) { i.x86Encoded = true },
+				"float":        func(i *Instr) { i.Args[1-form.memory] = Operand{Kind: OpImm, ImmIsFloat: true} },
+				"unresolved":   func(i *Instr) { i.Args[1-form.memory] = Operand{Kind: OpImm, ImmRaw: "not_defined"} },
+			} {
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				mutate(&changed)
+				state := before.clone()
+				if accepted, _ := ctx.scalarCompareNativeResultTransfer(changed, &state, nil, arch); accepted {
+					t.Fatal("unbound read accepted", arch, op, name)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareNativeSourceAddressRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		ctx := &amd64Ctx{resolve: func(s string) string { return s }, sigs: map[string]FuncSig{"function": {Name: "aliasedFunction"}},
+			continuations: map[string]x86Continuation{"continuation": {}}}
+		state := x86ResultState{}
+		state.pointerGP[0], state.gp[1] = true, 0xff
+		for _, address := range []string{"-7(AX)", "8(AX)(CX*2)"} {
+			operand := x86PureGPUnknownInstruction(t, "CMPL "+address+",$1").Args[0]
+			if !ctx.scalarCompareNativeAddress(operand, &state, arch) {
+				t.Fatal("valid address role rejected", arch, address)
+			}
+		}
+		for _, address := range []string{"external-7(SB)", "external+7(SB)", "function(SB)", "aliasedFunction(SB)", "continuation(SB)", "$external(SB)", "(FS)", "(GS)", "(DX)", "(AX)(DX*4)", "0", "(SP)"} {
+			operand := x86PureGPUnknownInstruction(t, "CMPL "+address+",$1").Args[0]
+			if ctx.scalarCompareNativeAddress(operand, &state, arch) {
+				t.Fatal("unbound address role accepted", arch, address)
+			}
+		}
+		if arch == "386" {
+			for _, address := range []string{"external(SB)(SP)", "external(SB)(FS)", "external(SB)(X15)", "external(SB)(CX*4)"} {
+				operand := x86PureGPUnknownInstruction(t, "CMPL "+address+",$1").Args[0]
+				if ctx.scalarCompareNativeAddress(operand, &state, arch) {
+					t.Fatal("named address acquired source-layout authority", address)
+				}
+				if !x86ScalarCompareMemoryValid(operand, arch) {
+					t.Fatal("Go ignored base or active index lost its syntax", address)
+				}
+			}
+			operand := x86PureGPUnknownInstruction(t, "CMPL external(SB)(DX*4),$1").Args[0]
+			if ctx.scalarCompareNativeAddress(operand, &state, arch) {
+				t.Fatal("active unknown named index treated as ignored base")
+			}
+		}
+	}
+	ins := x86PureGPUnknownInstruction(t, "CMPB AH,R8B")
+	var ir strings.Builder
+	ctx := &amd64Ctx{goarch: "amd64", b: &ir}
+	if _, _, err := ctx.lowerCmpBt(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || ir.Len() != 0 {
+		t.Fatalf("unbound REX SP alias emitted code: %v", err)
+	}
+}
diff --git a/amd64_scalar_compare_native_read.go b/amd64_scalar_compare_native_read.go
new file mode 100644
index 000000000..4381239c4
--- /dev/null
+++ b/amd64_scalar_compare_native_read.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+// The paired compare/test emitter performs a volatile native read. If it
+// continues, the comparison's inputs are numerical and its defined flags are
+// available. This does not assert that an address is backed, in bounds, aligned
+// or writable; no pointer identity, memory bytes or reusable proof is produced.
+func (c *amd64Ctx) scalarCompareNativeResultTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	if ins.x86NumericalRead != nil {
+		return false, false // The immutable source-layout certificate owns this read.
+	}
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil {
+		return false, true
+	}
+	if form.memory < 0 {
+		// The shared ordinary source transfer owns register-only effects,
+		// including separately authenticated caller/literal address predicates.
+		// A native-memory retry must not intercept those independent roles.
+		return false, false
+	}
+	for index, operand := range form.args {
+		if index != form.memory || !x86OrdinaryNativeMemoryOperand(operand, arch) {
+			if operand.Kind == OpReg && !state.shapeOnly {
+				register, _, valid := x86ResultGP(operand.Reg, int64(form.bits/8), arch)
+				if valid && state.pointerGP[register] {
+					return false, true
+				}
+			}
+			if !x86ResultRead(operand, int64(form.bits/8), state, owned, arch) {
+				return false, true
+			}
+			continue
+		}
+		if !x86ResultReadWithNativeGPContinuation(ins, operand, int64(form.bits/8), state, owned, arch) {
+			return false, true
+		}
+	}
+	state.flags = x86ByteFlagsAll
+	if form.test {
+		state.flags &^= x86ByteFlagAF
+	}
+	return true, true
+}
+
+func (c *amd64Ctx) scalarCompareNativeAddress(operand Operand, state *x86ResultState, arch string) bool {
+	// This rule deliberately excludes unbound TLS/segments, absolute numerical
+	// addresses, unknown GP bases and virtual frame addresses. External SB needs
+	// its existing actual-source numerical certificate: a volatile read alone
+	// cannot establish that an LLVM global preserves original Go field layout.
+	return x86ResultIncomingPointerReadAddressIdentity(operand, state, arch)
+}
diff --git a/amd64_scalar_compare_native_test.go b/amd64_scalar_compare_native_test.go
new file mode 100644
index 000000000..0eb9c42d0
--- /dev/null
+++ b/amd64_scalar_compare_native_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ScalarCompareNames(arch string) []string {
+	var names []string
+	for _, stem := range []string{"CMP", "TEST"} {
+		for _, suffix := range []string{"B", "W", "L", "Q"} {
+			if arch != "386" || suffix != "Q" {
+				names = append(names, stem+suffix)
+			}
+		}
+	}
+	return names
+}
+
+func x86ScalarCompareInstruction(op, memory, other string) string {
+	if strings.HasPrefix(op, "TEST") {
+		return op + " " + other + "," + memory
+	}
+	return op + " " + memory + "," + other
+}
+
+func x86ScalarCompareResultSource(name, body string) string {
+	// PEXTRD, unlike the older MOVL X0,AX compatibility path, actually invokes
+	// the private scalar-result observer. Both branches initialize every byte.
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-4\n%s\nJE equal\nMOVL $7,AX\nMOVL AX,X0\nJMP done\nequal:\nPXOR X0,X0\ndone:\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n", name, body)
+}
+
+func TestX86ScalarCompareSourceDataResultFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			source.WriteString("GLOBL external(SB),8,$16\n")
+			for index, op := range x86ScalarCompareNames(target.arch) {
+				name := fmt.Sprintf("compare%d", index)
+				source.WriteString(x86ScalarCompareResultSource(name, x86ScalarCompareInstruction(op, "external+3(SB)", "$1")))
+				fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "compare.ll", "compare.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarCompareUnboundExternalResultStaysContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86ScalarCompareNames(target.arch) {
+			for _, offset := range []int{-7, 0, 3} {
+				source := x86ScalarCompareResultSource("view", x86ScalarCompareInstruction(op, fmt.Sprintf("external%+d(SB)", offset), "$1"))
+				for _, api := range []string{"text", "module", "Go"} {
+					_, err := x86ScalarFPBitViewAPI(t, source, "var external [32]byte\nfunc view() uint32", target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("external source-layout guard bypassed: %s/%s/%s/%d: %v", target.triple, api, op, offset, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86ScalarComparePointerSource(arch, name, setup, compare, tail string) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := x86ScalarCompareResultSource(name, move+" p+0(FP),DX\n"+setup+compare+"\n"+tail)
+	source = strings.Replace(source, "$0-4", fmt.Sprintf("$0-%d", word+4), 1)
+	return strings.ReplaceAll(source, "ret+0(FP)", fmt.Sprintf("ret+%d(FP)", word))
+}
+
+func TestX86ScalarCompareIncomingPointerResultFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, op := range x86ScalarCompareNames(target.arch) {
+				name := fmt.Sprintf("view%d", index)
+				compare := x86ScalarCompareInstruction(op, "-7(DX)(CX*2)", "$1")
+				source.WriteString(x86ScalarComparePointerSource(target.arch, name, "MOVL $4,CX\n", compare, ""))
+				fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "compare-pointer.ll", "compare-pointer.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarCompareIncomingPointerDoesNotGrantOtherEffects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, op := range x86ScalarCompareNames(target.arch) {
+			for _, row := range []struct{ name, setup, address, partner, tail string }{
+				{"unknown-index", "", "(DX)(CX*2)", "$1", ""},
+				{"opaque-index", move + " p+0(FP),CX\n", "(DX)(CX*2)", "$1", ""},
+				{"numeric-not-pointer", move + " $1234,DX\n", "(DX)", "$1", ""},
+				{"unknown-numerical-input", "", "(DX)", "AX", ""},
+				{"opaque-numerical-input", move + " p+0(FP),AX\n", "(DX)", "AX", ""},
+				{"no-reusable-backing-credit", "", "(DX)", "$1", "MOVL (DX),DX\nMOVL (DX),AX\n"},
+				{"no-write-data-credit", "", "(DX)", "$1", "MOVL BX,(DX)\n"},
+				{"no-segment-credit", "", "(FS)", "$1", ""},
+				{"unknown-segment-offset", "", "8(CX)(FS*2)", "$1", ""},
+				{"opaque-segment-offset", move + " p+0(FP),CX\n", "8(CX)(FS*2)", "$1", ""},
+			} {
+				source := x86ScalarComparePointerSource(target.arch, "view", row.setup,
+					x86ScalarCompareInstruction(op, row.address, row.partner), row.tail)
+				paired := row.name == "numeric-not-pointer" || row.name == "no-reusable-backing-credit"
+				if paired {
+					x86RequireNumericNativeSourceContext(t, source, "func view(p *byte) uint32", target.arch)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *byte) uint32", target.arch, target.triple, api)
+					if paired {
+						bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[op[len(op)-1]]
+						reads := 1
+						if row.name == "no-reusable-backing-credit" {
+							reads = 3
+						}
+						if err != nil || !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", bits)) || strings.Count(ir, "load volatile") != reads ||
+							row.name == "no-reusable-backing-credit" && strings.Count(ir, "load volatile i32,") < 2 {
+							t.Fatalf("independent NUM reads lost their widths or effects %s/%s/%s/%s: %v", target.triple, op, row.name, api, err)
+						}
+						x86NumericNativeAddressObject(t, ir, target.triple)
+						continue
+					}
+					if row.name == "no-segment-credit" {
+						// Keep the original tuple. Its absolute hardware base
+						// needs no incoming GP numerical or pointer authority.
+						if err != nil || !strings.Contains(ir, "ptr addrspace(257)") || !strings.Contains(ir, "load volatile") {
+							t.Fatalf("original hardware-segment read was lost %s/%s/%s: %v", target.triple, op, api, err)
+						}
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("conditional read expanded authority %s/%s/%s/%s: %v", target.triple, op, row.name, api, err)
+					}
+				}
+			}
+			if strings.HasPrefix(op, "TEST") {
+				source := x86ScalarComparePointerSource(target.arch, "view", "",
+					x86ScalarCompareInstruction(op, "(DX)", "$1"), "LAHF\n")
+				if _, err := x86ScalarFPBitViewAPI(t, source, "func view(p *byte) uint32", target.arch, target.triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("TEST undefined AF became observable: %s/%s: %v", target.triple, op, err)
+				}
+			}
+		}
+	}
+}
+
+// The compare's continuation grants no credit to another read. Ordinary MOVL
+// now has its own paired volatile load and numerical effect; both operations
+// must survive even though the MOVL result is dead. Overwriting DX revokes its
+// pointer identity; a later complete NUM read needs its own paired effect.
+func TestX86ScalarCompareAndMoveRetainIndependentNativeReads(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			names := x86ScalarCompareNames(target.arch)
+			for index, op := range names {
+				name := fmt.Sprintf("CompareMove%d", index)
+				compare := x86ScalarCompareInstruction(op, "(DX)", "$1")
+				source.WriteString(x86ScalarComparePointerSource(target.arch, name, "", compare, "MOVL (DX),AX\n"))
+				fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("separately paired native reads rejected", api, err)
+				}
+				for level, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if got := strings.Count(text, "load volatile"); got < 2*len(names) {
+						t.Fatal("a native read borrowed earlier backing or was discarded", api, level, got)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, text, fmt.Sprintf("compare-move-%s-O%d", api, level*2))
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_compare_runtime_test.go b/amd64_scalar_compare_runtime_test.go
new file mode 100644
index 000000000..523a8780e
--- /dev/null
+++ b/amd64_scalar_compare_runtime_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarCompareFlags(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, native, prototypes, pairs strings.Builder
+	count := 0
+	for _, op := range x86ScalarCompareNames("amd64") {
+		rows := []string{"(DX),CX", "CX,(DX)"}
+		for _, immediate := range []string{"0", "127", "128", "255", "32768", "65535", "2147483648", "4294967295", "-2147483648"} {
+			rows = append(rows, strings.TrimPrefix(x86ScalarCompareInstruction(op, "(DX)", "$"+immediate), op+" "))
+		}
+		if strings.HasSuffix(op, "B") {
+			rows = append(rows, "CH,(DX)", "(DX),CH", "CL,CH", "CH,CL", "BH,R8B", "R8B,DH")
+		}
+		for _, row := range rows {
+			name, original := fmt.Sprintf("compare%d", count), fmt.Sprintf("original%d", count)
+			mask := 0x8d5 // CF, PF, AF, ZF, SF, OF only.
+			if strings.HasPrefix(op, "TEST") {
+				mask &^= 0x10 // TEST leaves AF undefined; never invent an oracle value.
+			}
+			body := op + " " + row
+			setup, originalSetup := "", ""
+			if strings.Contains(row, "R8B") {
+				setup = "MOVQ x+8(FP),DI\nMOVQ x+8(FP),SI\nMOVQ x+8(FP),R8\nNOTQ R8\n"
+				originalSetup = "MOVQ SI,DI\nMOVQ SI,R8\nNOTQ R8\n"
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ p+0(FP),DX\nMOVQ x+8(FP),CX\n%s%s\nPUSHFQ\nPOPQ AX\nANDQ $%d,AX\nMOVQ AX,ret+16(FP)\nRET\n", name, setup, body, mask)
+			fmt.Fprintf(&declarations, "func %s(p *byte,x uint64) uint64\n", name)
+			originalBody := strings.ReplaceAll(body, "DX", "DI")
+			code := x86PackedShiftActualGoBytes(t, "amd64", fmt.Sprintf("TEXT f(SB),4,$0-0\nMOVQ SI,CX\n%s%s\nPUSHFQ\nPOPQ AX\nANDQ $%d,AX\nRET\n", originalSetup, originalBody, mask))
+			if len(code) < 9 || code[len(code)-1] != 0xc3 {
+				t.Fatal("original Go flags program is incomplete", body, code)
+			}
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(uint8_t*,uint64_t);\n", name)
+			prototypes.WriteString(x86OriginalSysVDeclaration("uint64_t", original, "uint8_t*,uint64_t"))
+			fmt.Fprintf(&pairs, "{%s,%s},\n", original, name)
+			count++
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + native.String() + x86OriginalSysVPointer("uint64_t", "original_program", "uint8_t*,uint64_t") + `
+typedef uint64_t (*program)(uint8_t*,uint64_t);
+static const struct { original_program original; program translated; } pairs[]={
+` + pairs.String() + `};
+int main(void) {
+    const uint64_t patterns[]={0,1,15,16,127,128,255,256,32767,32768,65535,65536,
+        UINT64_C(0x7fffffff),UINT64_C(0x80000000),UINT64_C(0xffffffff),
+        UINT64_C(0x7fffffffffffffff),UINT64_C(0x8000000000000000),
+        UINT64_C(0xffffffffffffffff),UINT64_C(0x55aa0123cdef9876)};
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(unsigned a=0;a<sizeof(patterns)/sizeof(*patterns);++a) {
+            uint8_t data[24]; memset(data,0xa5,sizeof(data));
+            memcpy(data+3,&patterns[a],8);
+            for(unsigned b=0;b<sizeof(patterns)/sizeof(*patterns);++b) {
+                uint64_t x=pairs[i].original(data+3,patterns[b]);
+                uint64_t y=pairs[i].translated(data+3,patterns[b]);
+                if(x!=y || data[2]!=0xa5 || data[11]!=0xa5) {
+                    fprintf(stderr,"compare=%u a=%u b=%u original=%llx llvm=%llx\n",
+                        i,a,b,(unsigned long long)x,(unsigned long long)y);
+                    return 1;
+                }
+            }
+        }
+    }
+    printf("%zu original Go compare/test programs x 361 patterns\n",sizeof(pairs)/sizeof(*pairs));
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "scalar-compare-flags", pipeline.ir, main, pipeline.level)
+					if string(output) != fmt.Sprintf("%d original Go compare/test programs x 361 patterns\n", count) {
+						t.Fatalf("missing complete original/LLVM numerical receipt: %s", output)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_compare_tls_test.go b/amd64_scalar_compare_tls_test.go
new file mode 100644
index 000000000..f73f42cdc
--- /dev/null
+++ b/amd64_scalar_compare_tls_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TLS is an address annotation consumed by Go's OS/arch/-shared progedit,
+// not a numerical SIB index. Exercise every comparison row without granting
+// a native TLS source, relocation, layout, or caller-memory contract.
+func x86ScalarCompareTLSRows(op, arch string, direct bool) []string {
+	bases := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+	if arch == "amd64" {
+		bases = append(bases, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	}
+	var addresses []string
+	for _, base := range bases {
+		for _, scale := range []int{1, 2, 4, 8} {
+			for _, offset := range []int{-8, 0, 8} {
+				addresses = append(addresses, fmt.Sprintf("%d(%s)(TLS*%d)", offset, base, scale))
+			}
+		}
+	}
+	if direct {
+		addresses = append(addresses, "-8(TLS)", "0(TLS)", "8(TLS)", "0(TLS)(TLS*1)")
+	}
+	addresses = append(addresses, "0(TLS*1)", "0(AX)(TLS)", "0(FS)(TLS*1)",
+		"0(GS)(TLS*8)", "slot(FP)(TLS*1)", "slot(SP)(TLS*8)")
+	if arch == "386" {
+		addresses = append(addresses, "data(SB)(TLS*1)", "data(SB)(TLS)")
+	}
+	var rows []string
+	for _, address := range addresses {
+		rows = append(rows, op+" "+address+",AX", op+" AX,"+address,
+			x86ScalarCompareInstruction(op, address, "$1"))
+	}
+	return rows
+}
+
+func x86ScalarCompareTLSGoObject(t *testing.T, source, arch, goos string, shared bool) {
+	t.Helper()
+	dir := t.TempDir()
+	path, object := filepath.Join(dir, "tls.s"), filepath.Join(dir, "tls.o")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	args := []string{"tool", "asm", "-p", "tlsforms", "-o", object}
+	if shared {
+		args = append(args, "-shared")
+	}
+	args = append(args, path)
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch,
+		"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "CGO_ENABLED=0")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(path, object, output, err, ctx.Err(), true, arch); failure != nil {
+		t.Fatalf("%v\n%s", failure, output)
+	}
+}
+
+func TestX86ScalarCompareTLSActualGoProfiles(t *testing.T) {
+	for _, profile := range []struct {
+		arch, goos     string
+		shared, direct bool
+	}{
+		{"386", "linux", false, false}, {"386", "linux", true, false},
+		{"386", "windows", false, false}, {"386", "freebsd", false, true},
+		{"amd64", "linux", false, true}, {"amd64", "linux", true, false},
+		{"amd64", "darwin", false, true}, {"amd64", "windows", false, false},
+	} {
+		t.Run(fmt.Sprintf("%s/%s/shared=%v", profile.goos, profile.arch, profile.shared), func(t *testing.T) {
+			var source strings.Builder
+			index := 0
+			for _, op := range x86ScalarCompareNames(profile.arch) {
+				for _, row := range x86ScalarCompareTLSRows(op, profile.arch, profile.direct) {
+					fmt.Fprintf(&source, "TEXT ·tls%d(SB),4,$0-0\n%s\nRET\n", index, row)
+					index++
+				}
+			}
+			x86ScalarCompareTLSGoObject(t, source.String(), profile.arch, profile.goos, profile.shared)
+			t.Logf("%d original Go TLS forms", index)
+		})
+	}
+}
+
+func TestX86ScalarCompareTLSRequiresContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ScalarCompareNames(arch) {
+			for _, row := range x86ScalarCompareTLSRows(op, arch, true) {
+				ins := x86PureGPUnknownInstruction(t, row)
+				if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s: expected native TLS Context, got %v", arch, row, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareTLSAPIsFailClosed(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86ScalarCompareNames(target.arch) {
+			for _, address := range []string{"0(CX)(TLS*1)", "-8(SP)(TLS*8)", "8(TLS)"} {
+				for _, row := range []string{op + " " + address + ",AX", op + " AX," + address,
+					x86ScalarCompareInstruction(op, address, "$1")} {
+					source := "TEXT ·probe(SB),4,$0-0\n" + row + "\nRET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func probe()", target.arch, target.triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("TLS must return Context and no IR: error=%v, IR=%s", err, ir)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareTLSMalformedRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ScalarCompareNames(arch) {
+			rows := []string{"0(CX)(TLS*1),0(DX)(TLS*1)", "0(CX)(TLS*1),X0", "X0,0(CX)(TLS*1)",
+				"TLS,AX", "AX,TLS", "0(CX)(TLS*1)", "0(CX)(TLS*1),AX,BX"}
+			if strings.HasPrefix(op, "CMP") {
+				rows = append(rows, "$1,0(CX)(TLS*1)")
+			} else {
+				rows = append(rows, "0(CX)(TLS*1),$1")
+			}
+			for _, row := range rows {
+				body := op + " " + row
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+				ins := x86PureGPUnknownInstruction(t, body)
+				if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("invalid row was hidden by TLS: %s %s: %v", arch, body, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareTLSMalformedTypedBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ScalarCompareNames(arch) {
+			for _, change := range []struct {
+				name   string
+				mutate func(*Instr)
+			}{
+				{"unknown-base", func(ins *Instr) { ins.Args[0].Mem.Base = "UNKNOWN" }},
+				{"vector-base", func(ins *Instr) { ins.Args[0].Mem.Base = "X0" }},
+				{"bad-scale", func(ins *Instr) { ins.Args[0].Mem.Scale = 3 }},
+				{"unresolved-offset", func(ins *Instr) { ins.Args[0].Mem.OffRaw = "missing" }},
+				{"extended-index", func(ins *Instr) { ins.Args[0].Mem.IndexExt = ExtendUXTW }},
+				{"unknown-segment", func(ins *Instr) { ins.Args[0].Mem.Segment = "UNKNOWN" }},
+				{"unknown-symbol-role", func(ins *Instr) { ins.Args[0].Mem.Sym = "data(UNKNOWN)" }},
+				{"invalid-symbol", func(ins *Instr) { ins.Args[0].Mem.Sym = "$data(SB)" }},
+				{"suffix", func(ins *Instr) { ins.Op += ".Z" }},
+				{"float-immediate", func(ins *Instr) {
+					ins.Args = []Operand{ins.Args[0], {Kind: OpImm, ImmIsFloat: true}}
+					if strings.HasPrefix(op, "TEST") {
+						ins.Args[0], ins.Args[1] = ins.Args[1], ins.Args[0]
+					}
+				}},
+				{"unresolved-immediate", func(ins *Instr) {
+					ins.Args = []Operand{ins.Args[0], {Kind: OpImm, ImmRaw: "$missing"}}
+					if strings.HasPrefix(op, "TEST") {
+						ins.Args[0], ins.Args[1] = ins.Args[1], ins.Args[0]
+					}
+				}},
+			} {
+				t.Run(arch+"/"+op+"/"+change.name, func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, op+" 0(CX)(TLS*1),AX")
+					change.mutate(&ins)
+					if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("malformed typed row was hidden by TLS: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_flag_compare_af_runtime_test.go b/amd64_scalar_flag_compare_af_runtime_test.go
new file mode 100644
index 000000000..d8976f111
--- /dev/null
+++ b/amd64_scalar_flag_compare_af_runtime_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Every ISA partition executes the original Go opcode and LLVM lowering on
+// its required execution owner. This checks integer flags and whole inputs;
+// separate COMI status/fault oracles check MXCSR and exceptional effects.
+const x86ScalarCompareAFGoReference = `package scalarstatus
+
+import (
+ "encoding/binary"
+ "math"
+ "testing"
+)
+
+type kernel struct {
+ fn func(*[96]byte, *[16]byte, *[16]byte, uint64)
+ width int
+ alias bool
+}
+
+func TestOriginalScalarCompareStatus(t *testing.T) {
+ values := []float64{math.Inf(-1), -2, -1, math.Copysign(0,-1), 0, 1, 2, math.Inf(1), math.NaN()}
+ for n,k := range kernels {
+  for _,a := range values {
+   for _,b := range values {
+    var left,right [16]byte
+    for i := range left { left[i]=byte(0x41+i); right[i]=byte(0xb1+i) }
+    if k.width==32 {
+     binary.LittleEndian.PutUint32(left[:],math.Float32bits(float32(a)))
+     binary.LittleEndian.PutUint32(right[:],math.Float32bits(float32(b)))
+    } else {
+     binary.LittleEndian.PutUint64(left[:],math.Float64bits(a))
+     binary.LittleEndian.PutUint64(right[:],math.Float64bits(b))
+    }
+    originalLeft,originalRight:=left,right
+    comparedRight:=b
+    expectedRight:=right
+    if k.alias { comparedRight=a; expectedRight=left }
+    want:=uint64(0)
+    if math.IsNaN(a)||math.IsNaN(comparedRight) { want=0x45 } else if a==comparedRight { want=0x40 } else if a<comparedRight { want=1 }
+    for _,seed:=range []uint64{0,0x8d5} {
+     var out [96]byte
+     for i:=range out { out[i]=0xa7 }
+     k.fn(&out,&left,&right,seed)
+     flags:=binary.LittleEndian.Uint64(out[:])&0x8d5
+     if flags!=want||out[8]!=byte(want)|2 { t.Fatalf("kernel%d width%d a=%g b=%g seed=%x flags=%x lahf=%x want=%x",n,k.width,a,b,seed,flags,out[8],want) }
+     expected:=[]byte{byte(want&1),byte(want>>2&1),byte(want>>6&1),0,0,0}
+     for i,v:=range expected { if out[9+i]!=v { t.Fatalf("kernel%d SETcc%d",n,i) } }
+     for i:=0;i<16;i++ { if out[32+i]!=left[i]||out[48+i]!=expectedRight[i] { t.Fatalf("kernel%d input vector clobber",n) } }
+     if left!=originalLeft||right!=originalRight { t.Fatalf("kernel%d original input changed",n) }
+     for i,v:=range out { if (i>=15&&i<32||i>=64)&&v!=0xa7 { t.Fatalf("kernel%d canary%d",n,i) } }
+    }
+   }
+  }
+ }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86ScalarCompareAFOriginalGo(t *testing.T) {
+	x86ScalarCompareAFOriginalGo(t, x86FloatCompareSSE)
+}
+
+func x86ScalarCompareAFRuntimeCases(axis x86FloatCompareRuntimeISA) []x86ScalarCompareAFCase {
+	var cases []x86ScalarCompareAFCase
+	for _, row := range x86ScalarCompareAFCases("amd64", true) {
+		owner := x86FloatCompareSSE
+		if strings.HasPrefix(row.op, "V") {
+			owner = x86FloatCompareVEX
+			if row.dst >= 16 || row.src >= 16 || strings.HasSuffix(row.op, ".SAE") {
+				owner = x86FloatCompareEVEX
+			}
+		}
+		if owner == axis {
+			cases = append(cases, row)
+		}
+	}
+	return cases
+}
+
+func x86ScalarCompareAFOriginalGo(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	x86FloatCompareRuntimeTools(t, axis)
+	dir := t.TempDir()
+	for name, contents := range x86ScalarCompareAFOriginalFiles(axis) {
+		data := []byte(contents)
+		if strings.HasSuffix(name, ".go") {
+			var err error
+			data, err = format.Source(data)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	driver, _ := x86LEAActualSDKDriver(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go ISA%d status: %v\n%s", axis, err, output)
+	}
+	t.Logf("%d original ISA%d kernels ×81 pairs ×2 AF seeds, all six status bits/LAHF/SETcc and full input/output canaries", len(x86ScalarCompareAFRuntimeCases(axis)), axis)
+}
+
+func x86ScalarCompareAFOriginalFiles(axis x86FloatCompareRuntimeISA) map[string]string {
+	cases := x86ScalarCompareAFRuntimeCases(axis)
+	var declarations, kernels strings.Builder
+	kernels.WriteString("var kernels=[]kernel{\n")
+	for _, row := range cases {
+		fmt.Fprintf(&declarations, "func %s(*[96]byte,*[16]byte,*[16]byte,uint64)\n", row.name)
+		fmt.Fprintf(&kernels, "{%s,%d,%t},\n", row.name, row.bits, row.dst == row.src)
+	}
+	kernels.WriteString("}\n")
+	return map[string]string{
+		"go.mod":         "module scalarstatus\n\ngo 1.20\n",
+		"status.go":      "package scalarstatus\n" + declarations.String(),
+		"status_amd64.s": x86ScalarCompareAFAssembly("amd64", cases),
+		"status_test.go": x86ScalarCompareAFGoReference + kernels.String(),
+	}
+}
+
+const x86ScalarCompareAFCReference = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+typedef void (*kernel)(uint8_t*,uint8_t*,uint8_t*,uint64_t);
+
+static int check(kernel fn, unsigned width, unsigned n, unsigned alias,
+                 double a, double b, uint64_t seed) {
+ uint8_t left[16], right[16], out[96], oldLeft[16], oldRight[16];
+ for(unsigned i=0; i<16; i++) {
+  left[i] = 0x41+i;
+  right[i] = 0xb1+i;
+ }
+ if(width == 32) {
+  float l=a, r=b;
+  memcpy(left, &l, 4);
+  memcpy(right, &r, 4);
+ } else {
+  memcpy(left, &a, 8);
+  memcpy(right, &b, 8);
+ }
+ memcpy(oldLeft, left, 16);
+ memcpy(oldRight, right, 16);
+ memset(out, 0xa7, 96);
+
+ fn(out, left, right, seed);
+
+ double comparedRight = alias ? a : b;
+ uint64_t want = isnan(a)||isnan(comparedRight) ? 0x45 :
+                 a==comparedRight ? 0x40 : a<comparedRight ? 1 : 0, got;
+ memcpy(&got, out, 8);
+ got &= 0x8d5;
+ if(got != want || out[8] != (want|2)) {
+  fprintf(stderr, "scalar status kernel%u width%u a=%g b=%g seed=%llx flags=%llx lahf=%x want=%llx\n",
+          n, width, a, b, (unsigned long long)seed, (unsigned long long)got,
+          out[8], (unsigned long long)want);
+  return 1;
+ }
+
+ const uint8_t cc[] = {want&1, (want>>2)&1, (want>>6)&1, 0, 0, 0};
+ for(unsigned i=0; i<6; i++) {
+  if(out[9+i] != cc[i]) {
+   fprintf(stderr, "SETcc%u\n", i);
+   return 1;
+  }
+ }
+
+ if(memcmp(out+32, left, 16) || memcmp(out+48, alias ? left : right, 16) ||
+    memcmp(left, oldLeft, 16) || memcmp(right, oldRight, 16)) {
+  fprintf(stderr, "vector/input canary\n");
+  return 1;
+ }
+ for(unsigned i=0; i<96; i++) {
+  if(((i>=15 && i<32) || i>=64) && out[i] != 0xa7) {
+   fprintf(stderr, "output canary%u\n", i);
+   return 1;
+  }
+ }
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86ScalarCompareAFLLVM(t *testing.T) {
+	x86ScalarCompareAFLLVM(t, x86FloatCompareSSE)
+}
+
+func x86ScalarCompareAFLLVM(t *testing.T, axis x86FloatCompareRuntimeISA) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	cases := x86ScalarCompareAFRuntimeCases(axis)
+	file, err := Parse(ArchAMD64, x86ScalarCompareAFAssembly("amd64", cases))
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86ScalarCompareAFRuntimeC(cases)
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			ir, err := Translate(file, x86ScalarCompareAFOptions("amd64", execution.triple, cases))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if optimized {
+				ir = x86MulDivRoundOptimize(t, ir)
+			}
+			for _, backend := range []string{"-O0", "-O2"} {
+				t.Run("backend"+backend, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "scalar-compare-af", ir, main, backend)
+				})
+			}
+			t.Logf("%d translated ISA%d kernels ×81 pairs ×2 AF seeds; integer flags and complete input/output canaries", len(cases), axis)
+		})
+	}
+}
+
+func x86ScalarCompareAFRuntimeC(cases []x86ScalarCompareAFCase) string {
+	var declarations, checks strings.Builder
+	for i, row := range cases {
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,uint8_t*,uint8_t*,uint64_t);\n", row.name)
+		alias := 0
+		if row.dst == row.src {
+			alias = 1
+		}
+		fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d,a,b,seed)) {\n return 1;\n}\n", row.name, row.bits, i, alias)
+	}
+	return x86ScalarCompareAFCReference + declarations.String() + `
+int main(void) {
+ const double values[] = {-INFINITY, -2, -1, -0.0, 0, 1, 2, INFINITY, NAN};
+ for(unsigned i=0; i<9; i++) {
+  for(unsigned j=0; j<9; j++) {
+   for(unsigned s=0; s<2; s++) {
+    double a=values[i], b=values[j];
+    uint64_t seed = s ? 0x8d5 : 0;
+` + checks.String() + "   }\n  }\n }\n return 0;\n}\n"
+}
diff --git a/amd64_scalar_flag_compare_af_test.go b/amd64_scalar_flag_compare_af_test.go
new file mode 100644
index 000000000..7a88324ed
--- /dev/null
+++ b/amd64_scalar_flag_compare_af_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ScalarCompareAFCase struct {
+	name, op string
+	bits     int
+	dst, src int
+	memory   bool
+}
+
+// asm6.go's yxm is X/m,X. Each of the four avx_optabs.go entries
+// independently has VEX X/m,X and EVEX X/m,X (N4/N8, SAE register only).
+// Neither table grants masks, zeroing, broadcast, or a Y/Z operand.
+func x86ScalarCompareAFCases(arch string, extended bool) []x86ScalarCompareAFCase {
+	var cases []x86ScalarCompareAFCase
+	for _, op := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		bits := 32
+		if strings.HasSuffix(op, "D") {
+			bits = 64
+		}
+		banks := []int{0, 7}
+		if arch == "amd64" && extended {
+			banks = append(banks, 8, 15)
+			if strings.HasPrefix(op, "V") {
+				banks = append(banks, 16, 31)
+			}
+		}
+		for _, dst := range banks {
+			src := 1
+			if dst != 0 {
+				src = dst - 1
+			}
+			for _, memory := range []bool{false, true} {
+				cases = append(cases, x86ScalarCompareAFCase{fmt.Sprintf("status%d", len(cases)), op, bits, dst, src, memory})
+			}
+			cases = append(cases, x86ScalarCompareAFCase{fmt.Sprintf("status%d", len(cases)), op, bits, dst, dst, false})
+			if strings.HasPrefix(op, "V") {
+				cases = append(cases, x86ScalarCompareAFCase{fmt.Sprintf("status%d", len(cases)), op + ".SAE", bits, dst, src, false})
+			}
+		}
+	}
+	return cases
+}
+
+func x86ScalarCompareAFAssembly(arch string, cases []x86ScalarCompareAFCase) string {
+	move, slot := "Q", 8
+	if arch == "386" {
+		move, slot = "L", 4
+	}
+	var source strings.Builder
+	for _, row := range cases {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", row.name, 4*slot)
+		fmt.Fprintf(&source, "MOV%s out+0(FP),DI\nMOV%s left+%d(FP),BX\nMOV%s right+%d(FP),DX\nMOV%s seed+%d(FP),CX\n", move, move, slot, move, 2*slot, move, 3*slot)
+		load, store := "MOVUPS", "MOVUPS"
+		if row.dst >= 16 || row.src >= 16 {
+			load, store = "VMOVUPS", "VMOVUPS"
+		}
+		fmt.Fprintf(&source, "%s (BX),X%d\n", load, row.dst)
+		if row.src != row.dst {
+			fmt.Fprintf(&source, "%s (DX),X%d\n", load, row.src)
+		}
+		fmt.Fprintf(&source, "PUSH%s CX\nPOPF%s\n", move, move)
+		operand := fmt.Sprintf("X%d", row.src)
+		if row.memory {
+			operand = "0(DX)"
+		}
+		fmt.Fprintf(&source, "%s %s,X%d\nPUSHF%s\nPOP%s CX\nMOV%s CX,0(DI)\nLAHF\nMOVB AH,8(DI)\n", row.op, operand, row.dst, move, move, move)
+		source.WriteString("SETCS 9(DI)\nSETPS 10(DI)\nSETEQ 11(DI)\nSETMI 12(DI)\nSETOS 13(DI)\nSETLT 14(DI)\n")
+		fmt.Fprintf(&source, "%s X%d,32(DI)\n%s X%d,48(DI)\nRET\n", store, row.dst, store, row.src)
+	}
+	return source.String()
+}
+
+func x86ScalarCompareAFOptions(arch, triple string, cases []x86ScalarCompareAFCase) Options {
+	typ, slot := I64, int64(8)
+	if arch == "386" {
+		typ, slot = I32, 4
+	}
+	sigs := make(map[string]FuncSig, len(cases))
+	for _, row := range cases {
+		sigs[row.name] = FuncSig{Name: row.name, Args: []LLVMType{Ptr, Ptr, Ptr, typ}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: slot, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 2 * slot, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 3 * slot, Type: typ, Index: 3, Field: -1},
+			}},
+		}
+	}
+	return Options{Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	}
+}
+
+func TestX86ScalarCompareAFCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			cases := x86ScalarCompareAFCases(target.arch, true)
+			source := x86ScalarCompareAFAssembly(target.arch, cases)
+			// This generic receipt helper really invokes the selected SDK on
+			// every target, including Go 1.20; no current-table early return.
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			if receipt == nil {
+				t.Fatal("missing actual source/object receipt")
+			}
+			var declarations strings.Builder
+			for _, row := range cases {
+				fmt.Fprintf(&declarations, "func %s(*[96]byte,*[16]byte,*[16]byte,uintptr)\n", row.name)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+							objectIR := ir
+							if optimized {
+								objectIR = x86MulDivRoundOptimize(t, objectIR)
+							}
+							compileLLVMToObject(t, llc, target.triple, "scalar-status.ll", "scalar-status.o", objectIR)
+						})
+					}
+				})
+			}
+			t.Logf("%d eight-op register/memory/SAE kernels; physical mode32 bank stays X0-X7", len(cases))
+		})
+	}
+}
+
+func TestX86ScalarCompareAFMalformedFormsRemainRejected(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+			for _, operands := range []string{"Y1,X0", "X1,Y0", "X1,(AX)", "X1,X0,X2"} {
+				t.Run(arch+"/"+op+"/"+operands, func(t *testing.T) {
+					source := "TEXT ·invalid(SB),4,$0-0\n" + op + " " + operands + "\nRET\n"
+					// These common rejected forms invoke both actual SDKs.
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					file, err := Parse(ArchAMD64, source)
+					if err == nil {
+						_, err = Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{
+							"invalid": {Name: "invalid", Ret: Void},
+						}})
+					}
+					if err == nil {
+						t.Fatalf("malformed %s acquired translation authority", source)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_float_integer_boundaries_test.go b/amd64_scalar_float_integer_boundaries_test.go
new file mode 100644
index 000000000..4a8e6f6e5
--- /dev/null
+++ b/amd64_scalar_float_integer_boundaries_test.go
@@ -0,0 +1,235 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarFloatIntegerHelperOwnership(t *testing.T) {
+	for _, operation := range []Op{"ADDQ", "MOVQ", "UNKNOWN.CVTSS2SL", "CVTSS2SL"} {
+		var ir strings.Builder
+		ctx := amd64Ctx{b: &ir, goarch: "amd64", targetTriple: "x86_64-unknown-linux-gnu"}
+		ins := x86ScalarLaneInstruction(t, "MOVQ AX,BX")
+		known, terminated, err := ctx.lowerScalarFloatToInteger(operation, ins)
+		_, effectKnown, effectErr := x86TypedScalarFloatIntegerByteEffect(operation, ins, "amd64")
+		want := operation == "CVTSS2SL"
+		if known != want || effectKnown != want || (err != nil) != want || (effectErr != nil) != want || terminated || ir.Len() != 0 {
+			t.Fatal("family helper claimed foreign dispatch or emitted before validation", operation, known, effectKnown, err, effectErr, ir.String())
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerTypedEveryByteAndFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86ScalarFloatIntegerOracleNames() {
+			if arch == "386" && !strings.HasPrefix(name, "V") && strings.HasSuffix(name, "Q") {
+				continue
+			}
+			width := 4
+			if strings.Contains(name, "SD") {
+				width = 8
+			}
+			for missing := -1; missing < 64; missing++ {
+				ins := x86ScalarLaneInstruction(t, name+" X1,AX")
+				state := &x86ResultState{flags: 0x3f}
+				known := ^uint64(0)
+				if missing >= 0 {
+					known &^= 1 << uint(missing)
+				}
+				state.writeVector(1, 64, known, false)
+				state.pointerGP[0] = true
+				accepted := x86ResultTransfer(ins, state, nil, 0, arch)
+				want := missing < 0 || missing >= width
+				if accepted != want || state.flags != 0x3f || state.vectorBytes(1) != known ||
+					accepted && (state.gp[0] != 0xff || state.pointerGP[0]) {
+					t.Fatal("scalar read/write/flags boundary", arch, name, missing, accepted, state)
+				}
+			}
+			for _, kind := range []string{"FP", "AUTO", "SB", "pointer"} {
+				for missing := -1; missing < width; missing++ {
+					owned := make([]bool, 16)
+					state := &x86ResultState{fp: make([]bool, 16), auto: make([]bool, 16)}
+					for i := range owned {
+						owned[i], state.fp[i], state.auto[i] = i != missing, i != missing, i != missing
+					}
+					operand := "value+0(FP)"
+					switch kind {
+					case "AUTO":
+						operand = "local-16(SP)"
+					case "SB":
+						operand = "external(SB)"
+					case "pointer":
+						operand = "(BX)"
+						state.pointerGP[3] = true
+					}
+					accepted := x86ResultTransfer(x86ScalarLaneInstruction(t, name+" "+operand+",AX"), state, owned, 0, arch)
+					want := (kind == "FP" || kind == "AUTO") && missing == -1
+					if accepted != want {
+						t.Fatal("memory role acquired unwritten bytes", arch, name, kind, missing, accepted)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerSourceAndRawBoundaries(t *testing.T) {
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		for _, text := range []string{"Y0,AX", "Z0,AX", "M0,AX", "K1,AX", "$1,AX", "X0,X1", "X0,AH", "X0,K1", "X0,(BX)"} {
+			if _, known, err := x86ScalarFloatIntegerProperties(x86ScalarLaneInstruction(t, name+" "+text), "amd64"); !known || err == nil {
+				t.Fatal("bad operand accepted", name, text, err)
+			}
+		}
+		for _, suffix := range []string{".", ".Z", ".BCST", ".SAE.SAE", ".RN_SAE.Z"} {
+			if _, _, err := x86ScalarFloatIntegerProperties(x86ScalarLaneInstruction(t, name+suffix+" X0,AX"), "amd64"); err == nil {
+				t.Fatal("bad suffix accepted", name, suffix)
+			}
+		}
+		for _, change := range []string{"offset", "index", "scale", "base", "SP index", "symbol address"} {
+			ins := x86ScalarLaneInstruction(t, name+" (BX),AX")
+			switch change {
+			case "offset":
+				ins.Args[0].Mem.OffRaw = "missing"
+			case "index":
+				ins.Args[0].Mem.IndexExt = "missing"
+			case "scale":
+				ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+			case "base":
+				ins.Args[0].Mem.Base = "X0"
+			case "SP index":
+				ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = SP, 1
+			case "symbol address":
+				ins.Args[0] = Operand{Kind: OpSym, Sym: "$data(SB)"}
+			}
+			if _, _, err := x86ScalarFloatIntegerProperties(ins, "amd64"); err == nil {
+				t.Fatal("constructed memory accepted", name, change)
+			}
+		}
+	}
+	for _, mode := range []int{32, 64} {
+		for _, w := range []byte{0, 0x80} {
+			for _, ll := range []byte{0, 0x20, 0x40, 0x60} {
+				for _, opcode := range []byte{0x2c, 0x2d, 0x78, 0x79} {
+					code := []byte{0x62, 0xf1, 0x7e | w, 0x08 | ll, opcode, 0x81, 1, 0, 0, 0}
+					ins, length, known, err := decodedX86ScalarFloatToIntegerInstruction(code, mode)
+					if !known || err != nil || length != len(code) || !ins.x86ScalarFloatIntegerEVEX {
+						t.Fatal("EVEX WIG/LLIG byte identity", mode, code, ins, length, err)
+					}
+					for end := 0; end < len(code); end++ {
+						_, consumed, recognized, err := decodedX86ScalarFloatToIntegerInstruction(code[:end], mode)
+						if recognized && err == nil || consumed > end {
+							t.Fatal("truncated full encoding accepted", code, end, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerWholeFileTargetAndResultBoundaries(t *testing.T) {
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, dead := range []bool{false, true} {
+				before := ""
+				if dead {
+					before = "RET\n"
+				}
+				for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", "i386-unknown-linux-gnu", "x86_64madeup-unknown-linux-gnu"} {
+					source := "TEXT ·view(SB),4,$0-0\n" + before + name + " X0,AX\nRET\n"
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", "amd64", triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("missing native target was not rejected", name, api, dead, triple, err)
+					}
+				}
+			}
+			for _, initialized := range []bool{false, true} {
+				setup := ""
+				if initialized {
+					setup = "XORPS X0,X0\n"
+				}
+				source := "TEXT ·view(SB),4,$0-4\n" + setup + name + " X0,AX\nMOVL AX,X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if !initialized {
+					x86VectorScratchCodegenControl(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					continue
+				}
+				if initialized && err != nil || !initialized && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("result initialization boundary", name, api, initialized, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerFiveTargetsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, decl strings.Builder
+			count := 0
+			for _, row := range x86ScalarFloatIntegerFormRows(target.arch) {
+				ins := x86ScalarLaneInstruction(t, row)
+				if _, _, err := x86ScalarFloatIntegerProperties(ins, target.arch); err != nil {
+					continue // Already asserted separately as high-bank Context.
+				}
+				// Physical stack writes and logical FP/AUTO have independent
+				// ABI storage tests; this object axis is ordinary registers/mem.
+				if strings.Contains(row, "FP)") || strings.Contains(row, "SP)") || ins.Args[1].Reg == SP || strings.Contains(row, "(FS)") || strings.Contains(row, "(GS)") {
+					continue
+				}
+				fmt.Fprintf(&source, "TEXT ·probe%d(SB),4,$0-0\n%s\nRET\n", count, row)
+				fmt.Fprintf(&decl, "func probe%d()\n", count)
+				count++
+			}
+			ir := x86UnboundVoidRawScalarFormatObject(t, source.String(), target.arch, target.triple)
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				compileLLVMToObject(t, llc, target.triple, "scalar-float-int.ll", "scalar-float-int.o", input)
+			}
+			t.Logf("%d unchanged original Go formats; 3 public APIs require input Context; 2 private emitter IR object pipelines, no initialized/native claim", count)
+		})
+	}
+}
+
+func TestX86ScalarFloatIntegerLogicalFPByteBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range x86ScalarFloatIntegerOracleNames() {
+			if target.arch == "386" && !strings.HasPrefix(name, "V") && strings.HasSuffix(name, "Q") {
+				continue
+			}
+			bits, parameters, result := 32, "a,b,c,d uint8", 4
+			if strings.Contains(name, "SD") {
+				bits, parameters, result = 64, "a,b,c,d uint16", 8
+			}
+			if target.arch == "amd64" {
+				result = 8 // ABI0 aligns the input/result boundary to a word.
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				for _, invalid := range []string{"", "past end", "pointer", "padding"} {
+					params, offset := parameters, 0
+					switch invalid {
+					case "past end":
+						offset = 1
+					case "pointer":
+						params = "a *uint64"
+					case "padding":
+						params = "a uint8,b uint32"
+					}
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s a+%d(FP),AX\nMOVL AX,X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+%d(FP)\nRET\n", result+4, name, offset, result)
+					_, err := x86ScalarFPBitViewAPI(t, source, "func view("+params+") uint32\n", target.arch, target.triple, api)
+					if invalid == "" && err != nil || invalid != "" && err == nil {
+						t.Fatal("logical FP conversion byte boundary", target.triple, name, bits, api, invalid, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_float_integer_family_test.go b/amd64_scalar_float_integer_family_test.go
new file mode 100644
index 000000000..416f54055
--- /dev/null
+++ b/amd64_scalar_float_integer_family_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Go namespace, not derived from the production conversion map.
+func x86ScalarFloatIntegerOracleNames() []string {
+	var names []string
+	for _, precision := range []string{"SS", "SD"} {
+		for _, prefix := range []string{"CVT", "CVTT"} {
+			for _, width := range []string{"L", "Q"} {
+				names = append(names, prefix+precision+"2S"+width)
+				vwidth := ""
+				if width == "Q" {
+					vwidth = "Q"
+				}
+				names = append(names, "V"+prefix+precision+"2SI"+vwidth)
+				names = append(names, "V"+prefix+precision+"2USI"+width)
+			}
+		}
+	}
+	return names
+}
+
+func TestX86ScalarFloatIntegerMode32WIGOriginalGo(t *testing.T) {
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		if !strings.HasPrefix(name, "V") || !strings.HasSuffix(name, "Q") {
+			continue
+		}
+		for _, operand := range []string{"X0", "7(BX)"} {
+			t.Run(name+"/"+operand, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-0\n%s %s,AX\nRET\n", name, operand)
+				ir := x86UnboundVoidScalarFormatObject(t, source, "view", "386", "i386-unknown-linux-gnu")
+				if !strings.Contains(ir, "call i32 asm sideeffect") || strings.Contains(ir, "call i64 asm sideeffect") {
+					t.Fatal("actual Go W1 format lost its mode32 WIG dword output", ir)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc required")
+				}
+				compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "mode32-wig.ll", "mode32-wig.o", ir)
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_float_integer_fault_runtime_test.go b/amd64_scalar_float_integer_fault_runtime_test.go
new file mode 100644
index 000000000..6a6039634
--- /dev/null
+++ b/amd64_scalar_float_integer_fault_runtime_test.go
@@ -0,0 +1,136 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerDeadFaults(t *testing.T) {
+	x86ScalarFloatIntegerDeadFaults(t, false, false)
+}
+
+func x86ScalarFloatIntegerDeadFaults(t *testing.T, vector, nativeTraps bool) {
+	axis := x86FloatCompareSSE
+	if vector {
+		axis = x86FloatCompareEVEX
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	if nativeTraps && (runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || len(execution.prefix) != 0) {
+		t.Fatal("unmasked MXCSR traps require the actual native Linux AMD64 counterpart")
+	}
+	var source, decl, native, prototypes, pairs strings.Builder
+	count := 0
+	for _, op := range x86ScalarFloatIntegerOracleNames() {
+		if strings.HasPrefix(op, "V") != vector {
+			continue
+		}
+		fn, original := fmt.Sprintf("fault%d", count), fmt.Sprintf("original%d", count)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DI\nMOVQ csr+8(FP),SI\nLDMXCSR (SI)\n%s (DI),AX\nXORL AX,AX\nRET\n", fn, op)
+		fmt.Fprintf(&decl, "func %s(p *uint64,csr *uint32)\n", fn)
+		code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\nLDMXCSR (SI)\n"+op+" (DI),AX\nXORL AX,AX\nRET\n")
+		var bytes []string
+		for _, b := range code {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+		}
+		symbol := original
+		if strings.Contains(execution.triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&native, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern void %s(uint64_t*,uint32_t*),%s(uint64_t*,uint32_t*);\n", fn, original)
+		width := 4
+		if strings.Contains(op, "SD") {
+			width = 8
+		}
+		fmt.Fprintf(&pairs, "{%s,%s,%d},\n", original, fn, width)
+		count++
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	trapChecks := 0
+	if nativeTraps {
+		trapChecks = 1
+	}
+	driver := fmt.Sprintf("#define NATIVE_TRAP_CHECKS %d\n", trapChecks) + `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + native.String() + prototypes.String() + `
+typedef void (*program)(uint64_t*,uint32_t*);
+static const struct {program original,translated;int width;} pairs[]={
+` + pairs.String() + `};
+static int outcome(program fn,uint8_t *p,uint32_t csr) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        fn((uint64_t*)p,&csr); _exit(0);
+    }
+    int status;
+    if(waitpid(child,&status,0)!=child) return -1;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status)) {
+        int sig=WTERMSIG(status);
+        if(sig==SIGSEGV || sig==SIGBUS) return 1;
+        if(sig==SIGFPE) return 2;
+    }
+    return -1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    uint8_t *p=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(p==MAP_FAILED || mprotect(p+page,page,PROT_NONE)) return 2;
+    memset(p,0,page);
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);i++) {
+        for(int available=0;available<=pairs[i].width+1;available++) {
+            int want=available<pairs[i].width;
+            int a=outcome(pairs[i].original,p+page-available,0x1f80);
+            int b=outcome(pairs[i].translated,p+page-available,0x1f80);
+            if(a!=want || b!=want) {
+                fprintf(stderr,"dead scalar read=%u available=%d want=%d Go=%d LLVM=%d\n",i,available,want,a,b);
+                return 3;
+            }
+        }
+        for(int event=0;NATIVE_TRAP_CHECKS && event<2;event++) {
+            uint64_t bits=pairs[i].width==8 ? (event?UINT64_C(0x3ff8000000000000):UINT64_C(0x7ff8123456789abc)) : (event?UINT64_C(0x3fc00000):UINT64_C(0x7fc12345));
+            memcpy(p,&bits,8);
+            uint32_t csr=event?0x0f80:0x1f00;
+            int a=outcome(pairs[i].original,p,csr),b=outcome(pairs[i].translated,p,csr);
+            if(a!=2 || b!=2) {
+                fprintf(stderr,"dead scalar exception=%u event=%d Go=%d LLVM=%d\n",i,event,a,b);
+                return 4;
+            }
+        }
+    }
+    if(munmap(p,2*page)) return 5;
+    printf("original Go/LLVM dead scalar reads matched; native unmasked IE/PE checks=%d\n",NATIVE_TRAP_CHECKS);
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), decl.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "scalar-dead-fault", pipeline.ir, driver, pipeline.level)
+					if string(output) != fmt.Sprintf("original Go/LLVM dead scalar reads matched; native unmasked IE/PE checks=%d\n", trapChecks) {
+						t.Fatal("missing complete dead-fault receipt", string(output))
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_float_integer_forms.go b/amd64_scalar_float_integer_forms.go
new file mode 100644
index 000000000..19ac68821
--- /dev/null
+++ b/amd64_scalar_float_integer_forms.go
@@ -0,0 +1,165 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// One grammar for Go's yxcvfl/yxcvfq and _yvcvtsd2si/_yvcvtsd2usil
+// rows. Operand acceptance is not a native address or ABI certificate.
+type x86ScalarFloatIntegerForm struct {
+	spec       amd64ScalarFloatToIntSpec
+	outputBits int
+	suffix     string
+	evex       bool
+	memory     bool
+}
+
+func x86ScalarFloatIntegerProperties(ins Instr, arch string) (x86ScalarFloatIntegerForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64ScalarFloatToIntSpecs[Op(name)]
+	f := x86ScalarFloatIntegerForm{spec: spec, outputBits: spec.outputBits, suffix: suffix, evex: spec.unsigned || dotted || ins.x86ScalarFloatIntegerEVEX}
+	if !known {
+		return f, false, nil
+	}
+	fail := func() (x86ScalarFloatIntegerForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go scalar float-to-integer grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || len(ins.Args) != 2 ||
+		ins.Args[1].Kind != OpReg || !isX86YrlRegisterForArch(ins.Args[1].Reg, arch) {
+		return fail()
+	}
+	if !spec.vector {
+		if dotted || arch == "386" && spec.outputBits == 64 {
+			return fail()
+		}
+	} else {
+		if dotted {
+			valid := spec.truncating && suffix == "SAE"
+			if !spec.truncating {
+				valid = suffix == "RN_SAE" || suffix == "RD_SAE" || suffix == "RU_SAE" || suffix == "RZ_SAE"
+			}
+			if !valid || ins.Args[0].Kind != OpReg {
+				return fail()
+			}
+		}
+		if arch == "386" {
+			// VEX.W1 and EVEX.W1 are ignored outside 64-bit mode. Keep the
+			// original Q spelling, but all consumers observe a dword write.
+			f.outputBits = 32
+		}
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		index, valid := amd64ParseXReg(source.Reg)
+		if !valid || !spec.vector && index >= 16 || !spec.vector && arch == "386" && index >= 8 {
+			return fail()
+		}
+		if arch == "386" && index >= 8 {
+			return f, true, fmt.Errorf("%w: %s lacks a physical mode32 high-X register identity", ErrProbeNeedsContext, ins.Op)
+		}
+		f.evex = f.evex || index >= 16
+	} else {
+		if source.Kind == OpMem {
+			if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+				return f, true, err
+			}
+			if source.Mem.OffRaw != "" || source.Mem.IndexExt != "" {
+				return fail()
+			}
+			if arch == "386" && strings.HasSuffix(source.Mem.Sym, "(SB)") {
+				source.Mem.Base = ""
+			}
+		}
+		if !isAMD64MemoryOperand(source) || !x86PackedShiftMemoryValid(source, arch) {
+			return fail()
+		}
+		f.memory = true
+	}
+	return f, true, nil
+}
+
+func x86TypedScalarFloatIntegerByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64ScalarFloatToIntSpecs[Op(base)]; !known {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("scalar conversion effect/source mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	f, known, err := x86ScalarFloatIntegerProperties(ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: int64(f.spec.inputBits / 8), read: true},
+		{index: 1, operand: ins.Args[1], width: int64(f.outputBits / 8), write: true},
+	}}, true, nil // Integer FLAGS are unchanged, independently of MXCSR.
+}
+
+func x86ResultScalarFloatIntegerStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	return x86ResultScalarFloatIntegerStepWithRead(ins, state, owned, resultOffset, arch, false)
+}
+
+// Only lowering the original native conversion may consume an opaque pointer
+// as a conditional m32/m64 input. The same opcode preserves exact access and
+// MXCSR exceptions even for dead results. The strict observer cannot borrow
+// this continuation; neither path creates pointee, raw, frame or caller facts.
+func x86ResultScalarFloatIntegerStepWithRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, native bool) (bool, bool) {
+	f, known, err := x86ScalarFloatIntegerProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if native && !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawScalarFloatIntegerSource(ins, arch) {
+			return false, true
+		}
+		// Only this exact original opcode owns its native access. Keep its
+		// physical EVEX metadata and every input obligation unchanged.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	width := int64(f.spec.inputBits / 8)
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		index, _ := amd64ParseXReg(source.Reg) // The shared grammar bound it.
+		mask := x86CallerVectorByteMask(width)
+		if state.vectorBytes(index)&mask != mask {
+			return false, true
+		}
+	} else if !x86ResultReadWithNativeContinuation(ins, source, width, state, owned, arch, native) {
+		return false, true
+	}
+	return x86ResultStore(ins.Args[1], int64(f.outputBits/8), state, owned, resultOffset, arch), true
+}
+
+func x86ScalarFloatIntegerNativeTarget(arch, triple string) bool {
+	parts := strings.Split(triple, "-")
+	if len(parts) < 3 {
+		return false
+	}
+	if arch == "amd64" {
+		return parts[0] == "x86_64"
+	}
+	return arch == "386" && (parts[0] == "i386" || parts[0] == "i486" || parts[0] == "i586" || parts[0] == "i686")
+}
+
+func validateX86ScalarFloatIntegerFile(file *File, opt Options) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	needed := false
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			_, known, err := x86ScalarFloatIntegerProperties(ins, opt.Goarch)
+			if known && err != nil {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+			needed = needed || known
+		}
+	}
+	if needed && !x86ScalarFloatIntegerNativeTarget(opt.Goarch, opt.TargetTriple) {
+		return fmt.Errorf("%w: scalar float-to-integer needs its native x86 MXCSR target, got %q/%q", ErrProbeNeedsContext, opt.Goarch, opt.TargetTriple)
+	}
+	return nil
+}
diff --git a/amd64_scalar_float_integer_grammar_test.go b/amd64_scalar_float_integer_grammar_test.go
new file mode 100644
index 000000000..66edfc640
--- /dev/null
+++ b/amd64_scalar_float_integer_grammar_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ScalarFloatIntegerIndependentCompleteEncoderRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var yxcvfl = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yrl}},\n}",
+		"var yxcvfq = []ytab{\n\t{Zm_r_xm, 2, argList{Yxm, Yrl}},\n}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("complete legacy operand table changed", row)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		wide, vector := strings.HasSuffix(name, "Q"), strings.HasPrefix(name, "V")
+		trunc, unsigned := strings.Contains(name, "CVTT"), strings.Contains(name, "USI")
+		pp, bytes := "F3", 4
+		if strings.Contains(name, "SD") {
+			pp, bytes = "F2", 8
+		}
+		opcode := "0x2D"
+		if trunc {
+			opcode = "0x2C"
+		}
+		if !vector {
+			entry := fmt.Sprintf("{A%s, yxcvfl, P%s, opBytes{%s}}", name, strings.ToLower(pp), strings.ToLower(opcode))
+			if wide {
+				entry = fmt.Sprintf("{A%s, yxcvfq, Pw, opBytes{P%s, %s}}", name, strings.ToLower(pp), strings.ToLower(opcode))
+			}
+			if !strings.Contains(string(legacy), entry) {
+				t.Fatal("legacy opcode attributes changed", entry)
+			}
+			count++
+			continue
+		}
+		if unsigned {
+			opcode = "0x79"
+			if trunc {
+				opcode = "0x78"
+			}
+		}
+		word, attribute := 0, "evexRoundingEnabled"
+		if wide {
+			word = 1
+		}
+		if trunc {
+			attribute = "evexSaeEnabled"
+		}
+		var opbytes []string
+		if !unsigned {
+			opbytes = append(opbytes, fmt.Sprintf("avxEscape | vex128 | vex%s | vex0F | vexW%d", pp, word), opcode)
+		}
+		opbytes = append(opbytes, fmt.Sprintf("avxEscape | evex128 | evex%s | evex0F | evexW%d", pp, word), fmt.Sprintf("evexN%d | %s", bytes, attribute), opcode)
+		index, offset := 0, 0
+		for _, row := range rules {
+			if row.Opcode != name {
+				continue
+			}
+			table, class, zcase, advance := "_yvcvtsd2si", "Yxm", "Zvex_rm_v_r", 2
+			if unsigned {
+				table = "_yvcvtsd2usil"
+			}
+			if unsigned || index == 1 {
+				class, zcase, advance = "YxmEvex", "Zevex_rm_v_r", 3
+			}
+			if row.Ytab != table || row.Prefix != "Pavx" || row.RowIndex != index || row.EncodingOffset != offset ||
+				row.ZCase != zcase || row.ZOffset != advance || !reflect.DeepEqual(row.Classes, []string{class, "Yrl"}) || !reflect.DeepEqual(row.OpBytes, opbytes) {
+				t.Fatalf("%s complete independent encoder row changed: %+v", name, row)
+			}
+			index, offset, count = index+1, offset+advance, count+1
+		}
+		want := 2
+		if unsigned {
+			want = 1
+		}
+		if index != want {
+			t.Fatal("missing encoder rows", name, index, want)
+		}
+	}
+	if count != 32 {
+		t.Fatal("expected all 32 encoder rows across 24 names", count)
+	}
+}
+
+func x86ScalarFloatIntegerFormRows(arch string) []string {
+	var rows []string
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		vector := strings.HasPrefix(name, "V")
+		if arch == "386" && !vector && strings.HasSuffix(name, "Q") {
+			continue
+		}
+		limit := 16
+		if vector {
+			limit = 32
+		} else if arch == "386" {
+			limit = 8
+		}
+		for index := 0; index < limit; index++ {
+			rows = append(rows, fmt.Sprintf("%s X%d,AX", name, index))
+		}
+		gp := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+		if arch == "amd64" {
+			gp = append(gp, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		}
+		for _, destination := range gp {
+			rows = append(rows, name+" X1,"+destination)
+		}
+		for _, address := range []string{"-3(BX)", "8(BX)(CX*4)", "value+0(FP)", "local-8(SP)", "·data(SB)", "(FS)", "(GS)"} {
+			rows = append(rows, name+" "+address+",AX")
+		}
+		if vector {
+			suffixes := []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}
+			if strings.Contains(name, "CVTT") {
+				suffixes = []string{"SAE"}
+			}
+			for _, suffix := range suffixes {
+				rows = append(rows, name+"."+suffix+" X0,AX")
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86ScalarFloatIntegerWholeRegisterAndAddressGrammar(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		rows := x86ScalarFloatIntegerFormRows(arch)
+		for index, row := range rows {
+			fmt.Fprintf(&source, "TEXT f%d(SB),4,$8-8\n%s\nRET\n", index, row)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		for _, row := range rows {
+			ins := x86ScalarLaneInstruction(t, row)
+			_, known, err := x86ScalarFloatIntegerProperties(ins, arch)
+			index, xreg := amd64ParseXReg(ins.Args[0].Reg)
+			context := arch == "386" && xreg && index >= 8
+			if !known || context && !errors.Is(err, ErrProbeNeedsContext) || !context && err != nil {
+				t.Fatal("actual Go accepted grammar mismatch", arch, row, err)
+			}
+		}
+		t.Logf("%s: %d independently Go-assembled register/address/suffix witnesses", arch, len(rows))
+	}
+}
diff --git a/amd64_scalar_float_integer_matrix_runtime_test.go b/amd64_scalar_float_integer_matrix_runtime_test.go
new file mode 100644
index 000000000..ecd48ad01
--- /dev/null
+++ b/amd64_scalar_float_integer_matrix_runtime_test.go
@@ -0,0 +1,150 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These are integer bit patterns, never host floating casts. Include both
+// zeros, signed subnormals, normal fractions, qNaN/sNaN, infinities and both
+// sides of signed/unsigned 32/64-bit result boundaries.
+var x86ScalarFloatIntegerSSInputs = []uint64{
+	0, 0x80000000, 1, 0x80000001, 0x3f000000, 0xbf000000, 0x3fc00000, 0xbfc00000,
+	0x7fc12345, 0x7f812345, 0xffc12345, 0xff812345, 0x7f800000, 0xff800000,
+	0x4effffff, 0x4f000000, 0xceffffff, 0xcf000000, 0xcf000001,
+	0x4f7fffff, 0x4f800000, 0x5effffff, 0x5f000000, 0xdf000000, 0xdf000001,
+	0x5f7fffff, 0x5f800000, 0x7f7fffff,
+}
+
+var x86ScalarFloatIntegerSDInputs = []uint64{
+	0, 0x8000000000000000, 1, 0x8000000000000001, 0x3fe0000000000000, 0xbfe0000000000000, 0x3ff8000000000000, 0xbff8000000000000,
+	0x7ff8123456789abc, 0x7ff0123456789abc, 0xfff8123456789abc, 0xfff0123456789abc, 0x7ff0000000000000, 0xfff0000000000000,
+	0x41dfffffffc00000, 0x41e0000000000000, 0xc1dfffffffc00000, 0xc1e0000000000000, 0xc1e0000000200000,
+	0x41efffffffe00000, 0x41f0000000000000, 0x43dfffffffffffff, 0x43e0000000000000, 0xc3e0000000000000, 0xc3e0000000000001,
+	0x43efffffffffffff, 0x43f0000000000000, 0x7fefffffffffffff,
+}
+
+func x86ScalarFloatIntegerNumericalFixture(vector bool) (assembly, declarations, original, driver string, count int) {
+	var asm, decl, gcalls, cdecl, ccalls strings.Builder
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		if strings.HasPrefix(name, "V") != vector {
+			continue
+		}
+		suffixes := []string{""}
+		if vector {
+			if strings.Contains(name, "CVTT") {
+				suffixes = append(suffixes, ".SAE")
+			} else {
+				suffixes = append(suffixes, ".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE")
+			}
+		}
+		for _, suffix := range suffixes {
+			fn := fmt.Sprintf("matrix%d", count)
+			precision := 0
+			if strings.Contains(name, "SD") {
+				precision = 1
+			}
+			fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-20\nSTMXCSR saved-4(SP)\nMOVQ out+0(FP),DI\nMOVQ bits+8(FP),AX\nMOVQ AX,X0\nLDMXCSR csr+16(FP)\nMOVQ $-1,CX\nCMPQ CX,$-1\n%s%s X0,AX\nMOVQ AX,0(DI)\nSTMXCSR 8(DI)\nSETEQ 16(DI)\nSETCS 17(DI)\nSETOS 18(DI)\nSETMI 19(DI)\nSETPC 20(DI)\nLDMXCSR saved-4(SP)\nRET\n", fn, name, suffix)
+			fmt.Fprintf(&decl, "func %s(out *[4]uint64,bits uint64,csr uint32)\n", fn)
+			sae := 0
+			if suffix != "" {
+				sae = 1
+			}
+			fmt.Fprintf(&gcalls, "check(%d,%d,%d,%s)\n", count, precision, sae, fn)
+			fmt.Fprintf(&cdecl, "extern void %s(uint64_t*,uint64_t,uint32_t);\n", fn)
+			fmt.Fprintf(&ccalls, "check(%d,%d,%d,%s);\n", count, precision, sae, fn)
+			count++
+		}
+	}
+	var gvalues, cvalues strings.Builder
+	for _, values := range [][]uint64{x86ScalarFloatIntegerSSInputs, x86ScalarFloatIntegerSDInputs} {
+		gvalues.WriteString("{")
+		cvalues.WriteString("{")
+		for _, value := range values {
+			fmt.Fprintf(&gvalues, "%#x,", value)
+			fmt.Fprintf(&cvalues, "UINT64_C(%#x),", value)
+		}
+		gvalues.WriteString("},")
+		cvalues.WriteString("},")
+	}
+	original = `package main
+import "fmt"
+var inputs = [][]uint64{` + gvalues.String() + `}
+func check(index,precision,sae int,fn func(*[4]uint64,uint64,uint32)) {
+    for n,bits:=range inputs[precision] {
+        for rc:=0;rc<4;rc++ { for controls:=0;controls<4;controls++ {
+            csr:=uint32(0x1f80|rc<<13|0x21)
+            if controls&1!=0 {csr|=0x40}; if controls&2!=0 {csr|=0x8000}
+            if sae!=0 {csr &^= 0x1080} // SAE must also suppress unmasked IE/PE.
+            out:=[4]uint64{0x1111111111111111,0x2222222222222222,0x3333333333333333,0x4444444444444444}
+            fn(&out,bits,csr)
+            fmt.Printf("%d %d %d %d %016x %016x %016x %016x\n",index,n,rc,controls,out[0],out[1],out[2],out[3])
+        }}
+    }
+}
+` + decl.String() + "func main(){\n" + gcalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static const uint64_t inputs[2][28]={` + cvalues.String() + `};
+static void check(unsigned index,unsigned precision,unsigned sae,void (*fn)(uint64_t*,uint64_t,uint32_t)) {
+    for(unsigned n=0;n<28;n++) for(unsigned rc=0;rc<4;rc++) for(unsigned controls=0;controls<4;controls++) {
+        uint32_t csr=0x1f80|(rc<<13)|0x21;
+        if(controls&1) csr|=0x40; if(controls&2) csr|=0x8000;
+        if(sae) csr&=~UINT32_C(0x1080);
+        uint64_t out[]={UINT64_C(0x1111111111111111),UINT64_C(0x2222222222222222),UINT64_C(0x3333333333333333),UINT64_C(0x4444444444444444)};
+        fn(out,inputs[precision][n],csr);
+        printf("%u %u %u %u %016llx %016llx %016llx %016llx\n",index,n,rc,controls,(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2],(unsigned long long)out[3]);
+    }
+}
+` + cdecl.String() + "int main(void){\n" + ccalls.String() + "return 0;}\n"
+	return asm.String(), decl.String(), original, driver, count
+}
+
+func x86ScalarFloatIntegerNumericalMatrix(t *testing.T, vector bool) {
+	t.Helper()
+	axis := x86FloatCompareSSE
+	if vector {
+		axis = x86FloatCompareEVEX
+	}
+	execution := x86FloatCompareRuntimeTools(t, axis)
+	assembly, declarations, original, driver, count := x86ScalarFloatIntegerNumericalFixture(vector)
+	want := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, original)
+	if rows := strings.Count(string(want), "\n"); rows != count*28*16 {
+		t.Fatalf("incomplete original Go receipt: %d expected %d", rows, count*28*16)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%v/backend%s", optimized, level), func(t *testing.T) {
+						got := execution.compileAndRunLLVM(t, "scalar-conversion-matrix", input, driver, level)
+						if string(got) != string(want) {
+							actual, expected := strings.Split(string(got), "\n"), strings.Split(string(want), "\n")
+							for i := 0; i < len(actual) && i < len(expected); i++ {
+								if actual[i] != expected[i] {
+									t.Fatalf("row %d: LLVM %s; original Go %s", i, actual[i], expected[i])
+								}
+							}
+							t.Fatal("output length differs from complete original Go receipt")
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerLegacyIEEEAndFlags(t *testing.T) {
+	x86ScalarFloatIntegerNumericalMatrix(t, false)
+}
diff --git a/amd64_scalar_float_integer_native.go b/amd64_scalar_float_integer_native.go
new file mode 100644
index 000000000..0f5417829
--- /dev/null
+++ b/amd64_scalar_float_integer_native.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// LLVM fptosi/fptoui produce poison outside the result domain. Even constrained
+// conversions do not specify x86's indefinite integer or complete MXCSR effect.
+// Execute one original-class instruction, including when its GP result is dead.
+func (c *amd64Ctx) emitNativeScalarFloatInteger(ins Instr, f x86ScalarFloatIntegerForm) error {
+	mnemonic := "cvt"
+	if f.spec.truncating {
+		mnemonic += "t"
+	}
+	if f.spec.inputBits == 32 {
+		mnemonic += "ss2"
+	} else {
+		mnemonic += "sd2"
+	}
+	if f.spec.unsigned {
+		mnemonic += "usi"
+	} else {
+		mnemonic += "si"
+	}
+	if f.outputBits == 64 {
+		mnemonic += "q"
+	} else {
+		mnemonic += "l"
+	}
+	if f.spec.vector {
+		mnemonic = "v" + mnemonic
+	}
+	if f.evex {
+		mnemonic = "{evex} " + mnemonic
+	}
+	if f.suffix != "" {
+		rounding := strings.ToLower(strings.ReplaceAll(f.suffix, "_", "-"))
+		mnemonic += " {" + rounding + "},"
+	}
+
+	source := ins.Args[0]
+	var value, typ, constraint, operand string
+	if source.Kind == OpReg || source.Kind == OpFP {
+		var err error
+		value, err = c.evalScalarFloatForInteger(source, f.spec.inputBits)
+		if err != nil {
+			return err
+		}
+		typ, constraint, operand = string(amd64FloatingTypeForBits(f.spec.inputBits)), "x", "$1"
+		if f.evex {
+			constraint = "v"
+		}
+	} else {
+		pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return err
+		}
+		segment := ""
+		if pointerType == "ptr addrspace(256)" {
+			segment = "%gs:"
+		} else if pointerType == "ptr addrspace(257)" {
+			segment = "%fs:"
+		}
+		value = pointer
+		typ = fmt.Sprintf("%s elementtype([%d x i8])", pointerType, f.spec.inputBits/8)
+		constraint, operand = "*m", segment+"$1"
+	}
+	result := c.newTmp()
+	outputType := amd64IntegerTypeForBits(f.outputBits)
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s)\n", result, outputType,
+		mnemonic+" "+operand+", $0", "=r,"+constraint+",~{memory},~{fpsr}", typ, value)
+	return c.storeRegSized(ins.Args[1].Reg, outputType, "%"+result)
+}
diff --git a/amd64_scalar_float_integer_native_avx512_linux_amd64_test.go b/amd64_scalar_float_integer_native_avx512_linux_amd64_test.go
new file mode 100644
index 000000000..445ca9172
--- /dev/null
+++ b/amd64_scalar_float_integer_native_avx512_linux_amd64_test.go
@@ -0,0 +1,18 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+// CPUID/OS-state preflight and complete native fixtures remain required.
+func TestCrossLinuxRuntimeMatrixX86RawScalarFloatToIntegerNative(t *testing.T) {
+	x86RawScalarFloatToIntegerNativeRuntime(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeVectorMatrix(t *testing.T) {
+	x86ScalarFloatIntegerNumericalMatrix(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeVectorDeadFaults(t *testing.T) {
+	x86ScalarFloatIntegerDeadFaults(t, true, true)
+}
diff --git a/amd64_scalar_float_integer_runtime_linux_amd64_test.go b/amd64_scalar_float_integer_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..e010aac39
--- /dev/null
+++ b/amd64_scalar_float_integer_runtime_linux_amd64_test.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeLegacyUnmaskedTraps(t *testing.T) {
+	x86ScalarFloatIntegerDeadFaults(t, false, true)
+}
diff --git a/amd64_scalar_float_integer_status_runtime_test.go b/amd64_scalar_float_integer_status_runtime_test.go
new file mode 100644
index 000000000..ccf669f9e
--- /dev/null
+++ b/amd64_scalar_float_integer_status_runtime_test.go
@@ -0,0 +1,128 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Constants deliberately reach O2: testing only dynamic finite inputs cannot
+// detect poison deleting observable stores or folding away MXCSR exceptions.
+// Expected bits and status come from the original Go-assembled instructions.
+func x86ScalarFloatIntegerConstantOracle() (assembly, declarations, original, driver string) {
+	var asm, decl, goCalls, cDecl, cCalls strings.Builder
+	index := 0
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		if strings.HasPrefix(name, "V") {
+			continue
+		}
+		values := []uint64{0x7fc12345, 0x7f800000, 0xff800000, 0x4f000000, 0x3fc00000, 1}
+		if strings.Contains(name, "SD") {
+			values = []uint64{0x7ff8123456789abc, 0x7ff0000000000000, 0xfff0000000000000, 0x43e0000000000000, 0x3ff8000000000000, 1}
+		}
+		for _, bits := range values {
+			function := fmt.Sprintf("probe%d", index)
+			fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$8-12\nSTMXCSR saved-4(SP)\nMOVQ out+0(FP),DI\nMOVQ $%#x,AX\nMOVQ AX,X0\nLDMXCSR csr+8(FP)\n%s X0,AX\nMOVQ AX,(DI)\nSTMXCSR 8(DI)\nLDMXCSR saved-4(SP)\nRET\n", function, bits, name)
+			fmt.Fprintf(&decl, "func %s(out *[4]uint64, csr uint32)\n", function)
+			fmt.Fprintf(&goCalls, "check(%d,%s)\n", index, function)
+			fmt.Fprintf(&cDecl, "extern void %s(uint64_t*,uint32_t);\n", function)
+			fmt.Fprintf(&cCalls, "check(%d,%s);\n", index, function)
+			index++
+		}
+	}
+	original = `package main
+import "fmt"
+func check(index int, fn func(*[4]uint64,uint32)) {
+    for mode:=0; mode<4; mode++ {
+        out:=[4]uint64{0x1111111111111111,0x2222222222222222,0x3333333333333333,0x4444444444444444}
+        fn(&out,0x1f80|uint32(mode)<<13)
+        fmt.Printf("%d %d %016x %016x %016x %016x\n",index,mode,out[0],out[1],out[2],out[3])
+    }
+}
+` + decl.String() + "func main(){\n" + goCalls.String() + "}\n"
+	driver = `#include <stdint.h>
+#include <stdio.h>
+static void check(int index,void (*fn)(uint64_t*,uint32_t)) {
+    for(unsigned mode=0; mode<4; mode++) {
+        uint64_t out[]={UINT64_C(0x1111111111111111),UINT64_C(0x2222222222222222),UINT64_C(0x3333333333333333),UINT64_C(0x4444444444444444)};
+        fn(out,0x1f80|(mode<<13));
+        printf("%d %u %016llx %016llx %016llx %016llx\n",index,mode,(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2],(unsigned long long)out[3]);
+    }
+}
+` + cDecl.String() + "int main(void){\n" + cCalls.String() + "return 0;}\n"
+	return asm.String(), decl.String(), original, driver
+}
+
+func x86ScalarFloatIntegerOriginalOutput(t *testing.T, execution x86FloatCompareExecution, assembly, main string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":  "module example.invalid/scalarfloatinteger\ngo 1.20\n",
+		"main.go": main, "original_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOARCH=amd64", "GOOS="+runtime.GOOS, "CGO_ENABLED=0", "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go float-to-integer oracle: %v\n%s", err, output)
+	}
+	return execution.run(t, binary)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerOriginalConstantsAndMXCSR(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	assembly, declarations, main, driver := x86ScalarFloatIntegerConstantOracle()
+	original := x86ScalarFloatIntegerOriginalOutput(t, execution, assembly, main)
+	want := strings.Split(strings.TrimSpace(string(original)), "\n")
+	if len(want) != 192 {
+		t.Fatalf("original Go produced %d rows, want 48 functions x 4 MXCSR modes", len(want))
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, ir)
+				}
+				for _, backend := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%v/backend%s", optimized, backend), func(t *testing.T) {
+						output := execution.compileAndRunLLVM(t, "scalar-conversion", input, driver, backend)
+						got := strings.Split(strings.TrimSpace(string(output)), "\n")
+						if len(got) != len(want) {
+							t.Fatalf("LLVM row count=%d original=%d", len(got), len(want))
+						}
+						mismatches := 0
+						for index := range want {
+							if got[index] != want[index] {
+								if mismatches == 0 {
+									t.Logf("first mismatch: original %s; LLVM %s", want[index], got[index])
+								}
+								mismatches++
+							}
+						}
+						if mismatches != 0 {
+							t.Errorf("original Go value/MXCSR/canary mismatches=%d/%d", mismatches, len(want))
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_fp_bit_runtime_test.go b/amd64_scalar_fp_bit_runtime_test.go
new file mode 100644
index 000000000..f4425a842
--- /dev/null
+++ b/amd64_scalar_fp_bit_runtime_test.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func x86ScalarFPBitRuntimeSources() (string, string) {
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package bitview\n")
+	for _, fixture := range x86ScalarFPBitFixtures() {
+		if strings.Contains(fixture.name, "byte-fields") || strings.Contains(fixture.name, "-fields-") {
+			continue // Independent-field byte layouts have separate object coverage.
+		}
+		name := strings.ReplaceAll(fixture.name, "-", "_")
+		if name[0] >= '0' && name[0] <= '9' {
+			name = "bits_" + name
+		}
+		declarations.WriteString(strings.Replace(fixture.declaration, "view(", name+"(", 1))
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\n%s\nRET\n", name, fixture.args, fixture.body)
+	}
+	return declarations.String(), assembly.String()
+}
+
+func x86ScalarFPOriginalGoBits(t *testing.T) {
+	t.Helper()
+	declarations, assembly := x86ScalarFPBitRuntimeSources()
+	// Execute original baseline SSE only. The VEX/mask source objects are
+	// independently assembled; their LLVM logical-byte oracle needs no AVX ISA.
+	const driver = `package bitview
+import (
+ "math"
+ "testing"
+)
+
+// A bodyless call with an actual buffer address makes all canary bytes
+// observable to the compiler; these are not constant-folded local arrays.
+func observe(memory *[64]byte)
+func getCSR() uint32
+func setCSR(value uint32)
+
+func TestOriginalBits(t *testing.T) {
+ savedCSR:=getCSR()
+ defer setCSR(savedCSR)
+ state := uint64(0x7182329ab3293821)
+ edges := []uint64{0,1,^uint64(0),0x8000000000000000,
+  0x7ff0000000000001,0xfff8456781234567,0x80000001,0x7f812345}
+ for iteration:=0;iteration<256;iteration++ {
+  state ^= state<<13; state ^= state>>7; state ^= state<<17
+  x,y:=state,state^0x8192736455aaccff
+  if iteration<len(edges) { x=edges[iteration] }
+  var canary [64]byte
+  for i:=range canary { canary[i]=byte(i*19+iteration) }
+  before:=canary
+  csr:=uint32(0x1f80)|uint32(iteration&63)|uint32(iteration&3)<<13
+  if iteration&4!=0 { csr|=1<<6 }
+  if iteration&8!=0 { csr|=1<<15 }
+  setCSR(csr)
+  observe(&canary)
+  if got:=low_int64(x);got!=uint32(x) { t.Fatalf("low %x",got) }
+  if got:=high_int64(int64(x));got!=uint32(x>>32) { t.Fatalf("high %x",got) }
+  if got:=cross_uint32(uint32(x),uint32(y));got!=uint64(uint32(x))|uint64(uint32(y))<<32 { t.Fatalf("cross %x",got) }
+  want:=x&^uint64(0xffffffff0000)|uint64(uint32(y))<<16
+  if got:=store_subword(x,y);got!=want { t.Fatalf("store got=%x want=%x",got,want) }
+  if got:=read_written_result(x);got!=^uint32(0) { t.Fatalf("result %x",got) }
+  if got:=inverse32(math.Float32frombits(uint32(x)));got!=uint32(x) { t.Fatalf("inverse32 %x",got) }
+  if got:=inverse64(math.Float64frombits(x));got!=x { t.Fatalf("inverse64 %x",got) }
+  if got:=getCSR();got!=csr { t.Fatalf("MXCSR got=%x want=%x",got,csr) }
+  observe(&canary)
+  if canary!=before { t.Fatal("full memory canary changed") }
+ }
+}
+`
+	formatted, err := format.Source([]byte(driver))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This observation helper is not translated or granted a caller contract.
+	assembly += "TEXT ·observe(SB),4,$0-8\nMOVQ memory+0(FP),AX\nMOVOU (AX),X0\nMOVOU 16(AX),X0\nMOVOU 32(AX),X0\nMOVOU 48(AX),X0\nRET\n"
+	assembly += "TEXT ·getCSR(SB),4,$0-4\nSTMXCSR ret+0(FP)\nRET\nTEXT ·setCSR(SB),4,$0-4\nLDMXCSR value+0(FP)\nRET\n"
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module bitview\n\ngo 1.20\n", "value.go": declarations,
+		"value_amd64.s": assembly, "value_test.go": string(formatted),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	driverPath, _ := x86LEAActualSDKDriver(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driverPath, "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go scalar bit views: %v\n%s", err, output)
+	} else {
+		t.Logf("original Go baseline SSE/GP: 7 kernels x 256 bit patterns, full observable canary: %s", output)
+	}
+}
+
+const x86ScalarFPBitCOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <xmmintrin.h>
+extern uint32_t low_int64(uint64_t),high_int64(uint64_t),read_written_result(uint64_t);
+extern uint64_t cross_uint32(uint32_t,uint32_t),store_subword(uint64_t,uint64_t);
+extern uint32_t vex_low_int64(uint64_t),vex_high_int64(uint64_t),vex_read_written_result(uint64_t);
+extern uint64_t vex_cross_uint32(uint32_t,uint32_t),vex_store_subword(uint64_t,uint64_t);
+extern uint32_t masked_load_0_zerofalse(uint64_t,uint64_t),masked_load_0_zerotrue(uint64_t,uint64_t);
+extern uint32_t masked_load_1_zerofalse(uint64_t,uint64_t),masked_load_1_zerotrue(uint64_t,uint64_t);
+extern uint64_t masked_store_0(uint64_t,uint64_t),masked_store_1(uint64_t,uint64_t);
+extern uint64_t masked_double_load_0_zerofalse(uint64_t,uint64_t),masked_double_load_0_zerotrue(uint64_t,uint64_t);
+extern uint64_t masked_double_load_1_zerofalse(uint64_t,uint64_t),masked_double_load_1_zerotrue(uint64_t,uint64_t);
+extern uint64_t masked_double_store_0(uint64_t,uint64_t),masked_double_store_1(uint64_t,uint64_t);
+extern uint32_t inverse32(float);
+extern uint64_t inverse64(double);
+
+int main(void) {
+ unsigned savedCSR=_mm_getcsr();
+ uint64_t state=UINT64_C(0x7182329ab3293821);
+ const uint64_t edges[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+  UINT64_C(0x7ff0000000000001),UINT64_C(0xfff8456781234567),0x80000001,0x7f812345};
+ for (unsigned iteration=0;iteration<256;iteration++) {
+  state^=state<<13;
+  state^=state>>7;
+  state^=state<<17;
+  uint64_t x=state,y=state^UINT64_C(0x8192736455aaccff);
+  if (iteration<sizeof(edges)/sizeof(edges[0])) {
+   x=edges[iteration];
+  }
+  volatile uint8_t canary[64];
+  uint8_t before[64];
+  for (unsigned i=0;i<64;i++) {
+   before[i]=(uint8_t)(i*19+iteration);
+   canary[i]=before[i];
+  }
+  uint64_t cross=(uint64_t)(uint32_t)x|((uint64_t)(uint32_t)y<<32);
+  uint64_t patched=x&~UINT64_C(0xffffffff0000)|((uint64_t)(uint32_t)y<<16);
+  uint32_t low=(uint32_t)x;
+  float single;
+  double pair;
+  memcpy(&single,&low,sizeof(single));
+  memcpy(&pair,&x,sizeof(pair));
+  unsigned csr=0x1f80|(iteration&63)|((iteration&3)<<13);
+  if (iteration&4) {
+   csr|=1<<6;
+  }
+  if (iteration&8) {
+   csr|=1<<15;
+  }
+  _mm_setcsr(csr);
+  if (inverse32(single)!=low || inverse64(pair)!=x) {
+   return 5;
+  }
+  if (low_int64(x)!=(uint32_t)x || high_int64(x)!=(uint32_t)(x>>32) ||
+      cross_uint32((uint32_t)x,(uint32_t)y)!=cross || store_subword(x,y)!=patched ||
+      read_written_result(x)!=UINT32_MAX) {
+   return 1;
+  }
+  if (vex_low_int64(x)!=(uint32_t)x || vex_high_int64(x)!=(uint32_t)(x>>32) ||
+      vex_cross_uint32((uint32_t)x,(uint32_t)y)!=cross || vex_store_subword(x,y)!=patched ||
+      vex_read_written_result(x)!=UINT32_MAX) {
+   return 2;
+  }
+  if (masked_load_0_zerofalse(x,y)!=(uint32_t)y || masked_load_0_zerotrue(x,y)!=0 ||
+      masked_load_1_zerofalse(x,y)!=(uint32_t)(x>>32) ||
+      masked_load_1_zerotrue(x,y)!=(uint32_t)(x>>32) ||
+      masked_store_0(x,y)!=x || masked_store_1(x,y)!=patched) {
+   return 3;
+  }
+  if (masked_double_load_0_zerofalse(x,y)!=y || masked_double_load_0_zerotrue(x,y)!=0 ||
+      masked_double_load_1_zerofalse(x,y)!=x || masked_double_load_1_zerotrue(x,y)!=x ||
+      masked_double_store_0(x,y)!=x || masked_double_store_1(x,y)!=y) {
+   return 6;
+  }
+  if (_mm_getcsr()!=csr) {
+   return 7;
+  }
+  for (unsigned i=0;i<64;i++) {
+   if (canary[i]!=before[i]) {
+    return 4;
+   }
+  }
+ }
+ _mm_setcsr(savedCSR);
+ puts("24 kernels x 256 patterns; full bit and canary equality");
+ return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFPBitViewsOriginalBitsAndCanaries(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	x86ScalarFPOriginalGoBits(t)
+	declarations, assembly := x86ScalarFPBitRuntimeSources()
+	declarations = strings.TrimPrefix(declarations, "package bitview\n")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"0", "2"} {
+				t.Run("O"+level, func(t *testing.T) {
+					text := ir
+					if level == "2" {
+						text = x86SignedIntegerFloatOptimize(t, text)
+					}
+					x86ScalarFPBitRuntime(t, llc, clang, triple, text, "-O"+level, prefix)
+				})
+			}
+		})
+	}
+}
+
+func x86ScalarFPBitRuntime(t *testing.T, llc, clang, triple, ir, level string, prefix []string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "view.ll"), filepath.Join(dir, "view.o")
+	source, executable := filepath.Join(dir, "oracle.c"), filepath.Join(dir, gotoolchain.HostExecutable("oracle"))
+	process := runtimeOracleProcessSource(t, dir)
+	for path, text := range map[string]string{input: ir, source: x86ScalarFPBitCOracle} {
+		if err := os.WriteFile(path, []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, command := range []*exec.Cmd{
+		exec.Command(llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", object),
+		exec.Command(clang, "-target", triple, level, object, source, process, "-o", executable),
+	} {
+		x86FloatCompareCaptureCommand(t, command)
+	}
+	arguments := runtimeOracleGuestArguments(t, prefix, executable)
+	output := x86FloatCompareCaptureCommand(t, exec.Command(arguments[0], arguments[1:]...))
+	if string(output) != "24 kernels x 256 patterns; full bit and canary equality\n" {
+		t.Fatalf("unexpected scalar bit oracle receipt: %q", output)
+	}
+	t.Logf("LLVM22 %s logical byte execution: %s", level, output)
+}
diff --git a/amd64_scalar_fp_bit_views_test.go b/amd64_scalar_fp_bit_views_test.go
new file mode 100644
index 000000000..802e91777
--- /dev/null
+++ b/amd64_scalar_fp_bit_views_test.go
@@ -0,0 +1,223 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86ScalarFPBitViewAPI(t *testing.T, source, declaration, arch, triple, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+	return x86ScalarFPBitViewPackageAPI(t, source, pkg, arch, triple, api)
+}
+
+func x86ScalarFPBitViewPackageAPI(t *testing.T, source string, pkg GoPackage, arch, triple, api string) (string, error) {
+	return x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, arch, triple, api, nil)
+}
+
+func x86ScalarFPBitViewPackageAPIWithManual(t *testing.T, source string, pkg GoPackage, arch, triple, api string,
+	manual func(string) (FuncSig, bool)) (string, error) {
+	t.Helper()
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		module, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: arch, TargetTriple: triple, ResolveSym: resolve, ManualSig: manual,
+		})
+		if module != nil && !module.Module.IsNil() {
+			defer module.Module.Dispose()
+			return module.Module.String(), err
+		}
+		return "", err
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, manual)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: signatures}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api != "module" {
+		t.Fatal("unknown scalar FP bit-view API", api)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+type x86ScalarFPBitFixture struct {
+	name, declaration, body string
+	args                    int
+}
+
+func x86ScalarFPBitFixtures() []x86ScalarFPBitFixture {
+	fixtures := []x86ScalarFPBitFixture{
+		{"low-int64", "func view(x uint64) uint32\n", "MOVSS x+0(FP),X7\nMOVSS X7,ret+8(FP)", 12},
+		{"high-int64", "func view(x int64) uint32\n", "MOVSS x+4(FP),X7\nMOVSS X7,ret+8(FP)", 12},
+		{"cross-uint32", "func view(a,b uint32) uint64\n", "MOVSD a+0(FP),X7\nMOVSD X7,ret+8(FP)", 16},
+		{"store-subword", "func view(x,y uint64) uint64\n", "MOVSD x+0(FP),X1\nMOVSD X1,ret+16(FP)\nMOVSS y+8(FP),X7\nMOVSS X7,ret+18(FP)", 24},
+		{"read-written-result", "func view(x uint64) uint32\n", "MOVL $-1,AX\nMOVL AX,ret+8(FP)\nMOVSS ret+8(FP),X7\nMOVSS X7,ret+8(FP)", 12},
+		{"cross-result-fields", "func view(x uint64) (a,b uint32)\n", "MOVSD x+0(FP),X7\nMOVSD X7,a+8(FP)\nMOVSS b+12(FP),X7\nMOVSS X7,b+12(FP)", 16},
+	}
+	for _, fixture := range append([]x86ScalarFPBitFixture(nil), fixtures...) {
+		fixture.name = "vex-" + fixture.name
+		fixture.body = strings.ReplaceAll(strings.ReplaceAll(fixture.body, "MOVSS ", "VMOVSS "), "MOVSD ", "VMOVSD ")
+		fixtures = append(fixtures, fixture)
+	}
+	fixtures = append(fixtures,
+		x86ScalarFPBitFixture{"inverse32", "func view(x float32) uint32\n", "MOVL x+0(FP),AX\nMOVL AX,ret+8(FP)", 12},
+		x86ScalarFPBitFixture{"inverse64", "func view(x float64) uint64\n", "MOVQ x+0(FP),X7\nMOVQ X7,ret+8(FP)", 16},
+	)
+	for offset := 1; offset < 4; offset++ {
+		for _, prefix := range []string{"", "V"} {
+			fixtures = append(fixtures, x86ScalarFPBitFixture{
+				fmt.Sprintf("%ssubbyte%d", prefix, offset), "func view(x uint64) uint32\n",
+				fmt.Sprintf("%sMOVSS x+%d(FP),X7\n%sMOVSS X7,ret+8(FP)", prefix, offset, prefix), 12,
+			})
+		}
+	}
+	for _, bits := range []int{32, 64} {
+		op, typ, width := "MOVSS", "uint32", bits/8
+		if bits == 64 {
+			op, typ = "MOVSD", "uint64"
+		}
+		for _, prefix := range []string{"", "V"} {
+			fixtures = append(fixtures, x86ScalarFPBitFixture{
+				fmt.Sprintf("%s%d-byte-fields", prefix, bits),
+				fmt.Sprintf("func view(x [%d]byte) %s\n", width, typ),
+				fmt.Sprintf("%s%s x+0(FP),X7\n%s%s X7,ret+%d(FP)", prefix, op, prefix, op, width), 2 * width,
+			})
+			for _, goType := range []string{"uint", "int", "float"} {
+				fixtures = append(fixtures, x86ScalarFPBitFixture{
+					fmt.Sprintf("%s%d-%s-natural", prefix, bits, goType),
+					fmt.Sprintf("func view(x %s%d) uint%d\n", goType, bits, bits),
+					fmt.Sprintf("%s%s x+0(FP),X7\n%s%s X7,ret+8(FP)", prefix, op, prefix, op), 8 + width,
+				})
+			}
+			for _, fieldType := range []string{"int8", "int16", "uint16"} {
+				fieldWidth := 2
+				if fieldType == "int8" {
+					fieldWidth = 1
+				}
+				fixtures = append(fixtures, x86ScalarFPBitFixture{
+					fmt.Sprintf("%s%d-fields-%s", prefix, bits, fieldType),
+					fmt.Sprintf("func view(x [%d]%s) %s\n", width/fieldWidth, fieldType, typ),
+					fmt.Sprintf("%s%s x+0(FP),X7\n%s%s X7,ret+%d(FP)", prefix, op, prefix, op, width), 2 * width,
+				})
+			}
+		}
+	}
+	for _, prefix := range []string{"", "V"} {
+		fixtures = append(fixtures, x86ScalarFPBitFixture{
+			prefix + "mixed-float-integer", "func view(a float32,b int32) uint64\n",
+			fmt.Sprintf("%sMOVSD a+0(FP),X7\n%sMOVSD X7,ret+8(FP)", prefix, prefix), 16,
+		})
+	}
+	for _, active := range []int{0, 1} {
+		for _, zero := range []bool{false, true} {
+			suffix := ""
+			if zero {
+				suffix = ".Z"
+			}
+			fixtures = append(fixtures, x86ScalarFPBitFixture{
+				fmt.Sprintf("masked-load-%d-zero%t", active, zero), "func view(x,y uint64) uint32\n",
+				fmt.Sprintf("MOVSS y+8(FP),X7\nMOVL $%d,AX\nKMOVD AX,K1\nVMOVSS%s x+4(FP),K1,X7\nMOVSS X7,ret+16(FP)", active, suffix), 20,
+			})
+		}
+		fixtures = append(fixtures, x86ScalarFPBitFixture{
+			fmt.Sprintf("masked-store-%d", active), "func view(x,y uint64) uint64\n",
+			fmt.Sprintf("MOVSD x+0(FP),X1\nMOVSD X1,ret+16(FP)\nMOVSS y+8(FP),X7\nMOVL $%d,AX\nKMOVD AX,K1\nVMOVSS X7,K1,ret+18(FP)", active), 24,
+		})
+	}
+	for _, active := range []int{0, 1} {
+		for _, zero := range []bool{false, true} {
+			suffix := ""
+			if zero {
+				suffix = ".Z"
+			}
+			fixtures = append(fixtures, x86ScalarFPBitFixture{
+				fmt.Sprintf("masked-double-load-%d-zero%t", active, zero), "func view(x,y uint64) uint64\n",
+				fmt.Sprintf("MOVSD y+8(FP),X7\nMOVL $%d,AX\nKMOVD AX,K1\nVMOVSD%s x+0(FP),K1,X7\nMOVSD X7,ret+16(FP)", active, suffix), 24,
+			})
+		}
+		fixtures = append(fixtures, x86ScalarFPBitFixture{
+			fmt.Sprintf("masked-double-store-%d", active), "func view(x,y uint64) uint64\n",
+			fmt.Sprintf("MOVSD x+0(FP),X1\nMOVSD X1,ret+16(FP)\nMOVSD y+8(FP),X7\nMOVL $%d,AX\nKMOVD AX,K1\nVMOVSD X7,K1,ret+16(FP)", active), 24,
+		})
+	}
+	return fixtures
+}
+
+func x86ScalarFPBitAssembly(t *testing.T, fixture x86ScalarFPBitFixture, arch string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+fixture.declaration)
+	sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	body := fixture.body
+	pattern := regexp.MustCompile(`ret\+(\d+)\(FP\)`)
+	matches := pattern.FindAllStringSubmatch(body, -1)
+	if len(matches) != 0 {
+		base, _ := strconv.Atoi(matches[0][1])
+		for _, match := range matches[1:] {
+			if offset, _ := strconv.Atoi(match[1]); offset < base {
+				base = offset
+			}
+		}
+		delta := sig.Frame.Results[0].Offset - int64(base)
+		body = pattern.ReplaceAllStringFunc(body, func(operand string) string {
+			offset, _ := strconv.Atoi(pattern.FindStringSubmatch(operand)[1])
+			return fmt.Sprintf("ret+%d(FP)", int64(offset)+delta)
+		})
+	}
+	end := int64(0)
+	for _, slot := range sig.Frame.Results {
+		if current := slot.Offset + x86FrameTypeSize(slot.Type); current > end {
+			end = current
+		}
+	}
+	return fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\nRET\n", end, body)
+}
+
+func TestX86ScalarFPBitViewsOriginalAcceptedThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, fixture := range x86ScalarFPBitFixtures() {
+		for _, target := range x86RawReturnTargets {
+			t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+				source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+				receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				t.Logf("original Go scalar bit-view object receipt: %+v", receipt)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_fp_bytes.go b/amd64_scalar_fp_bytes.go
new file mode 100644
index 000000000..a394fe139
--- /dev/null
+++ b/amd64_scalar_fp_bytes.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// These are logical ABI0 field views, not a pointer to a native incoming frame.
+// Every byte is resolved independently, so neither padding nor a pointer field
+// acquires numeric permissions from an adjacent scalar. Signedness is absent
+// here: MOVSS/MOVSD transport bits and do not perform numeric conversions.
+func (c *amd64Ctx) scalarFPSpan(off int64, bits int) (bool, error) {
+	fail := func(reason string) (bool, error) {
+		return false, fmt.Errorf("%w: scalar FP bit view at +%d(FP): %s", ErrProbeNeedsContext, off, reason)
+	}
+	if bits != 32 && bits != 64 || off < 0 || off > math.MaxInt64-int64(bits/8) {
+		return fail("invalid or overflowing byte span")
+	}
+	result := false
+	for current := off; current < off+int64(bits/8); current++ {
+		matches := 0
+		for _, group := range []struct {
+			slots  []FrameSlot
+			result bool
+		}{{c.sig.Frame.Params, false}, {c.fpResults, true}} {
+			for _, slot := range group.slots {
+				width := x86FrameTypeSize(slot.Type)
+				if slot.Type == Ptr {
+					width = int64(goWordSize(c.goarch))
+				}
+				if width <= 0 || slot.Offset < 0 || slot.Offset > math.MaxInt64-width {
+					return fail("invalid typed field extent")
+				}
+				if current < slot.Offset || current >= slot.Offset+width {
+					continue
+				}
+				switch slot.Type {
+				case I8, I16, I32, I64, LLVMType("float"), LLVMType("double"):
+				default:
+					return fail("byte is not a declared integer or floating scalar")
+				}
+				matches++
+				result = result || group.result
+			}
+		}
+		if matches != 1 {
+			return fail(fmt.Sprintf("byte %d has %d declared fields", current, matches))
+		}
+	}
+	return result, nil
+}
+
+func (c *amd64Ctx) scalarFPResultInitialized() error {
+	if !c.fpScalarChecked {
+		c.fpScalarChecked = true
+		c.fpScalarCheckErr = c.checkLoweredScalarFPResultInitialization()
+	}
+	if _, codegenOnly := c.fpScalarCheckErr.(*x86LoweredVectorEntryAuditError); codegenOnly {
+		return nil // Exact paired success, retaining the failed strict cache.
+	}
+	if _, incomplete := c.fpScalarCheckErr.(*x86IncompleteResultError); incomplete &&
+		(c.fpMixedBoolBytes || x86OrdinaryScalarTupleResultRole(c.fpScalarSource, c.sig, c.goarch)) {
+		// Ordinary Go callers may inspect a numerical tuple field only on the
+		// path that writes it. Keep the actual strict error cached: this does
+		// not grant the complete-proof capabilities guarded by that cache.
+		return nil
+	}
+	return c.fpScalarCheckErr
+}
+
+// A full store may span multiple independently allocated result fields. It
+// preserves the existing whole-field writer contract only when every touched
+// result field is completely overwritten; covering one field's prefix is not
+// enough. scalarFPSpan has already checked extent arithmetic and every byte.
+func (c *amd64Ctx) scalarFPStoreCoversResultFields(off int64, bits int) bool {
+	end := off + int64(bits/8)
+	for _, slot := range c.fpResults {
+		slotEnd := slot.Offset + x86FrameTypeSize(slot.Type)
+		if off < slotEnd && slot.Offset < end && (off > slot.Offset || end < slotEnd) {
+			return false
+		}
+	}
+	return true
+}
+
+// Preserve only the existing complete floating-field writer contract. A new
+// integer, mixed, or subfield bit view cannot borrow that contract to read an
+// undefined X register, even when its store overwrites the whole result.
+func (c *amd64Ctx) scalarFPStoreCoversFloatingFields(off int64, bits int) bool {
+	end := off + int64(bits/8)
+	for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.fpResults} {
+		for _, slot := range slots {
+			slotEnd := slot.Offset + x86FrameTypeSize(slot.Type)
+			if off >= slotEnd || slot.Offset >= end {
+				continue
+			}
+			if slot.Type != LLVMType("float") && slot.Type != LLVMType("double") ||
+				off > slot.Offset || end < slotEnd {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// All logical scalar consumers share this role decision. A new parameter
+// byte view cannot evade must-initialized source checking by subsequently
+// writing an old, complete floating result field. The exact natural inputs
+// below are the pre-existing scalar contracts, not native frame backing.
+func (c *amd64Ctx) scalarFPViewNeedsInitialization(off int64, bits int, write bool) (bool, error) {
+	result, err := c.scalarFPSpan(off, bits)
+	if err != nil {
+		return false, err
+	}
+	if write {
+		return !c.scalarFPStoreCoversFloatingFields(off, bits) ||
+			result && !c.scalarFPStoreCoversResultFields(off, bits), nil
+	}
+	if result {
+		return true, nil
+	}
+	first, found := c.fpParam(off)
+	if !found {
+		return true, nil
+	}
+	if bits == 32 && (first.Type == I32 || first.Type == LLVMType("float")) ||
+		bits == 64 && (first.Type == I64 || first.Type == LLVMType("double")) {
+		return false, nil
+	}
+	if bits == 64 && first.Type == LLVMType("float") {
+		second, found := c.fpParam(off + 4)
+		if found && second.Type == LLVMType("float") {
+			return false, nil
+		}
+	}
+	return true, nil
+}
+
+func (c *amd64Ctx) validateScalarFPSourceViews() error {
+	if err := c.validateMixedBoolResultRole(); err != nil {
+		return err
+	}
+	if x86OrdinaryIntegerFPStoreNeedsProof(c.fpScalarSource, c.sig, c.goarch) {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if x86TypedFPResultNeedsProof(c.fpScalarSource, c.sig, c.goarch) {
+		if err := c.integerEffectResultInitialized("typed numerical effect"); err != nil {
+			return err
+		}
+	}
+	if c.sig.amd64GoArguments != nil {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if c.fpScalarSource.x86ContinuationFlow != nil {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if c.fpScalarSource.x86SourceStack != nil && c.sig.Ret == I1 {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if _, valid := x86DirectTailResultRegion(c.fpScalarSource, c.sig, c.goarch); valid {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	if x86OrdinaryResultAddressNeedsProof(c.fpScalarSource, c.sig, c.goarch) ||
+		x86OrdinaryParameterAddressNeedsProof(c.fpScalarSource, c.sig, c.goarch) {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	// A logical i1 return cannot bypass canonical Go-byte/result validation
+	// merely because the complete body contains no FP/SIMD view. The independent
+	// ABI0 role requires its complete canonical declared-byte proof too.
+	if x86RegisterBoolResultNeedsProof(c.fpScalarSource, c.sig, c.goarch) || x86ABI0BoolResultNeedsProof(c.sig, c.goarch) {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	integerResult := false
+	for _, slot := range c.fpResults {
+		if slot.Type == I8 || slot.Type == I16 || slot.Type == I32 || slot.Type == I64 {
+			integerResult = true
+			break
+		}
+	}
+	for _, ins := range c.fpScalarSource.Instrs {
+		if x86LogicalPackedFPStoreBytes(ins, c.goarch) != 0 {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := x86TimestampProperties(ins.Op, ins, c.goarch); c.sig.Ret == Void && known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if width := x86IntegerFPMoveWidth(ins, c.goarch); width != 0 && len(ins.Args) == 2 {
+			for index, operand := range ins.Args {
+				if operand.Kind == OpFP {
+					if _, err := c.integerFPByteView(operand.FPOffset, width, index == 1); err != nil {
+						return err
+					}
+				}
+			}
+		}
+		if _, known, err := x86ByteSwapProperties(ins.Op, ins, c.goarch); c.sig.Ret != Void && known && err == nil {
+			if err := c.byteSwapResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := x86SignedIntegerFloatProperties(ins, c.goarch); integerResult && known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := x86UnsignedIntegerFloatProperties(ins, c.goarch); integerResult && known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := x86MXCSRProperties(ins, c.goarch); known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := amd64PackedStringCompareProperties(ins.Op, ins, c.goarch); integerResult && known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if integerResult && x86ResultCallerAddressDifferenceNeedsProof(ins, c.sig, c.goarch) {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if _, known, err := x86ScalarBitScanProperties(ins.Op, ins, c.goarch); integerResult && known && err == nil {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+		if form, known, err := x86GPSIMDTransferProperties(ins, c.goarch); integerResult && known && err == nil {
+			staticStore := form.memoryWrite && x86ScalarFPStaticSymbolMemory(ins.Args[form.memory])
+			ordinaryRegister := form.memory < 0 && !form.mmx && !form.spec.rawOnly &&
+				ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg &&
+				!ins.x86Encoded && ins.x86SourceRaw == nil && ins.x86RawNearReturn == nil &&
+				ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0
+			if staticStore || ordinaryRegister {
+				// Register-only GP/X moves can feed an ordinary GP-to-FP
+				// result store without a later lane probe. Sparse numerical
+				// bytes require the same complete, cached source proof. This
+				// grants no raw/MMX/native role or canonical bool knowledge.
+				// Static stores retain their existing independent trigger.
+				if err := c.scalarFPResultInitialized(); err != nil {
+					return err
+				}
+			}
+		}
+		form, recognized, err := amd64ScalarVectorMoveProperties(ins, c.goarch)
+		if !recognized || err != nil || form.spec.rawOnly || form.memory < 0 {
+			continue // The normal dispatcher retains malformed/raw-family errors.
+		}
+		operand := ins.Args[form.memory]
+		if operand.Kind != OpFP {
+			continue
+		}
+		needs, err := c.scalarFPViewNeedsInitialization(operand.FPOffset, form.spec.bits, form.memoryWrite)
+		if err != nil {
+			return err
+		}
+		if form.mask >= 0 || needs {
+			if err := c.scalarFPResultInitialized(); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// This is only a reason to require the complete result proof. A validated
+// ordinary SB role can have either parser representation; its grouped spelling
+// grants neither an address envelope nor an FP/result alias to that proof.
+func x86ScalarFPStaticSymbolMemory(operand Operand) bool {
+	var symbol string
+	switch operand.Kind {
+	case OpSym:
+		symbol = operand.Sym
+	case OpMem:
+		symbol = operand.Mem.Sym
+	default:
+		return false
+	}
+	return strings.HasSuffix(strings.TrimSpace(symbol), "(SB)")
+}
+
+func (c *amd64Ctx) loadScalarFPBits(off int64, bits int) (string, error) {
+	needs, err := c.scalarFPViewNeedsInitialization(off, bits, false)
+	if err != nil {
+		return "", err
+	}
+	if needs {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return "", err
+		}
+	}
+	bytes, err := c.loadFPVectorBytes(off, bits/8)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, bits/8, bytes, bits)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeScalarFPBits(off int64, bits int, value string) error {
+	needs, err := c.scalarFPViewNeedsInitialization(off, bits, true)
+	if err != nil {
+		return err
+	}
+	// Only complete floating-field stores retain the existing contract. New
+	// numeric bit views must prove the source as well as the result bytes;
+	// whole overwrite does not initialize an unknown source register.
+	if needs {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to <%d x i8>\n", bytes, bits, value, bits/8)
+	return c.storeFPVectorBytes(off, bits/8, "%"+bytes, "")
+}
+
+func (c *amd64Ctx) storeScalarFPFloat(off int64, bits int, value string) error {
+	if _, err := c.scalarFPSpan(off, bits); err != nil {
+		return err
+	}
+	typ := "float"
+	if bits == 64 {
+		typ = "double"
+	}
+	integer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to i%d\n", integer, typ, value, bits)
+	return c.storeScalarFPBits(off, bits, "%"+integer)
+}
diff --git a/amd64_scalar_fp_caller_read.go b/amd64_scalar_fp_caller_read.go
new file mode 100644
index 000000000..0635d11e7
--- /dev/null
+++ b/amd64_scalar_fp_caller_read.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "reflect"
+
+// A short-lived observation join, never a public native-memory capability.
+// The map key is the original normalized instruction ordinal, not a mutable
+// Instr pointer or an opcode-only lookup. Public/direct transfers cannot make it.
+type x86ScalarFPCallerRead struct {
+	op   Op
+	raw  string
+	args []Operand
+}
+
+func x86ScalarFPCallerReads(fn Func, sig FuncSig, arch string) map[int]x86ScalarFPCallerRead {
+	if arch != "amd64" || sig.Ret != Void || len(sig.Frame.Results) != 0 ||
+		!x86CallerNormalizedSourceMatches(fn, sig) {
+		return nil
+	}
+	reads := make(map[int]x86ScalarFPCallerRead)
+	for ordinal, ins := range fn.Instrs {
+		form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+		if !known || err != nil || form.memory != 0 || form.memoryWrite || form.aligned ||
+			form.source.Kind != OpMem || !x86CallerMemoryCertified(ins, 0) {
+			continue
+		}
+		access := ins.x86CallerMemory[0]
+		if access.write || access.width != 16 {
+			continue
+		}
+		// Whole source, signature and private caller identity were matched
+		// above. Freeze the operand bytes locally; JSON or a copied instruction
+		// certificate cannot recreate this whole-function entry context.
+		args := append([]Operand(nil), ins.Args...)
+		for index := range args {
+			args[index].RegList = append([]Reg(nil), ins.Args[index].RegList...)
+		}
+		reads[ordinal] = x86ScalarFPCallerRead{
+			op: ins.Op, raw: ins.Raw, args: args,
+		}
+	}
+	return reads
+}
+
+func (read x86ScalarFPCallerRead) transfer(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+	if arch != "amd64" || read.op != ins.Op || read.raw != ins.Raw ||
+		!reflect.DeepEqual(read.args, ins.Args) || !x86CallerMemoryCertified(ins, 0) {
+		return false
+	}
+	form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.memory != 0 || form.memoryWrite || form.aligned ||
+		!x86ResultIncomingPointerAddressIdentity(form.source, state, arch) {
+		return false
+	}
+	effect, known, err := x86TypedLegacyPackedMoveByteEffect(ins.Op, ins, arch)
+	if !known || err != nil || effect.dynamicMemory || effect.flagsRead != 0 ||
+		effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+		return false
+	}
+	for _, operand := range effect.operands {
+		if !operand.read {
+			continue
+		}
+		if operand.index == 0 && operand.width == 16 && !operand.write &&
+			reflect.DeepEqual(operand.operand, read.args[0]) {
+			// Defined numerical bytes come only from the existing exact caller
+			// read. Opaque GP identity/index checks above add no pointee grant.
+			continue
+		}
+		if !x86ResultRead(operand.operand, operand.width, state, owned, arch) {
+			return false
+		}
+	}
+	for _, operand := range effect.operands {
+		if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+			return false
+		}
+	}
+	return true // The legacy descriptor preserves all numerical FLAGS.
+}
diff --git a/amd64_scalar_fp_data_read.go b/amd64_scalar_fp_data_read.go
new file mode 100644
index 000000000..8910a7e72
--- /dev/null
+++ b/amd64_scalar_fp_data_read.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+// This map describes actual same-module numeric storage, not external Go
+// variables or a reusable source/return certificate. All typed read consumers
+// still request their complete native width, independently of a selected lane.
+func x86LoweredScalarDataReads(file *File, resolve func(string) string, sigs map[string]FuncSig, arch string) map[x86StaticSBAddress]int64 {
+	if file == nil || file.Arch != ArchAMD64 || resolve == nil {
+		return nil
+	}
+	// No local object can supply a read extent. Avoid allocating a directory
+	// or observing unrelated function/external symbols through a user resolver.
+	if len(file.Data) == 0 && len(file.Globl) == 0 {
+		return nil
+	}
+	type object struct {
+		size    int64
+		invalid bool
+	}
+	objects := make(map[string]object)
+	for _, global := range file.Globl {
+		name := resolveAssemblyDataSymbol(global.Sym, resolve)
+		current := objects[name]
+		if global.SizeRaw != "" || global.Size < 0 || global.Size > maxDataGlobalSize {
+			current.invalid = true
+		}
+		if global.Size > current.size {
+			current.size = global.Size
+		}
+		objects[name] = current
+	}
+	for _, datum := range file.Data {
+		name := resolveAssemblyDataSymbol(datum.Sym, resolve)
+		current := objects[name]
+		end, err := dataStmtEnd(datum)
+		if err != nil || datum.Addr != "" {
+			// Reject relocations in the entire resolved object, not merely
+			// the selected raw name or currently read range.
+			current.invalid = true
+		}
+		if end > current.size {
+			current.size = end
+		}
+		objects[name] = current
+	}
+	for _, function := range file.Funcs {
+		name := resolve(function.Sym)
+		current := objects[name]
+		current.invalid = true
+		objects[name] = current
+	}
+	for name, signature := range sigs {
+		for _, symbol := range []string{name, funcSigSymbol(name, signature)} {
+			current := objects[symbol]
+			current.invalid = true
+			objects[symbol] = current
+		}
+	}
+	reads := make(map[x86StaticSBAddress]int64)
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			for _, operand := range ins.Args {
+				address, valid := x86StaticSBReadAddress(operand, arch)
+				if !valid {
+					continue
+				}
+				if graph := file.x86ContinuationGraph; graph != nil {
+					if _, codeTable := graph.tables[address.symbol]; codeTable {
+						continue // Mutable code carriers are not numerical BSS/literal bytes.
+					}
+				}
+				current := objects[resolveAssemblyDataSymbol(address.symbol, resolve)]
+				if !current.invalid && current.size > 0 && current.size <= maxDataGlobalSize && address.offset < current.size {
+					reads[address] = current.size - address.offset
+				}
+			}
+		}
+	}
+	return reads
+}
diff --git a/amd64_scalar_fp_data_read_runtime_unix_test.go b/amd64_scalar_fp_data_read_runtime_unix_test.go
new file mode 100644
index 000000000..ca3443364
--- /dev/null
+++ b/amd64_scalar_fp_data_read_runtime_unix_test.go
@@ -0,0 +1,80 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarDataResultsOriginalGoAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	goos := "linux"
+	if strings.Contains(execution.triple, "apple") {
+		goos = "darwin"
+	}
+	bodies := x86ScalarResultDataReadBodies("amd64")
+	var names []string
+	for name := range bodies {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	var source, declarations, calls, cDeclarations strings.Builder
+	source.WriteString(x86ScalarResultDataTable)
+	var functions []string
+	for _, name := range names {
+		body := strings.ReplaceAll(bodies[name], "PXOR X1,X1", "MOVOU table<>(SB),X1")
+		body = strings.ReplaceAll(body, "PXOR X0,X0", "MOVOU table<>(SB),X0")
+		for lane := 0; lane < 4; lane++ {
+			function := fmt.Sprintf("dataResult%d", len(functions))
+			functions = append(functions, function)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n%sPEXTRD $%d,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", function, body, lane)
+			fmt.Fprintf(&declarations, "func %s() uint32\n", function)
+			fmt.Fprintf(&calls, "fmt.Println(%s())\n", function)
+			fmt.Fprintf(&cDeclarations, "extern uint32_t %s(void);\n", function)
+		}
+	}
+	program := "package main\nimport \"fmt\"\n" + declarations.String() + "func main(){\n" + calls.String() + "}\n"
+	directory := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod": "module scalar_data_oracle\n\ngo 1.20\n", "main.go": program, "data.s": source.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(directory, "original")
+	environment := []string{"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=amd64", "GOOS=" + goos}
+	dataGlobalAlignmentCommand(t, directory, environment, "go", "build", "-p=2", "-o", original, ".")
+	results := strings.Fields(string(execution.run(t, original)))
+	if len(results) != len(functions) {
+		t.Fatalf("original Go executed %d results, want %d", len(results), len(functions))
+	}
+	var checks strings.Builder
+	for index, function := range functions {
+		value, err := strconv.ParseUint(results[index], 10, 32)
+		if err != nil {
+			t.Fatal("original Go result is not a uint32", err)
+		}
+		fmt.Fprintf(&checks, "if (%s()!=UINT32_C(%d)) { fprintf(stderr,%q); return 1; }\n",
+			function, value, function+" differs from actual original Go\n")
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDeclarations.String() + "int main(void){\n" + checks.String() + "return 0;\n}\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(api+"/"+level, func(t *testing.T) {
+				execution.compileAndRunLLVM(t, "scalar-data-result", ir, main, level)
+			})
+		}
+	}
+	t.Logf("%d actual Go linked DATA-backed scalar results compared with three LLVM APIs at both optimization levels", len(functions))
+}
diff --git a/amd64_scalar_fp_data_read_test.go b/amd64_scalar_fp_data_read_test.go
new file mode 100644
index 000000000..6cf4bb790
--- /dev/null
+++ b/amd64_scalar_fp_data_read_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This directory intentionally crosses instruction families. The new input
+// is an emitted same-file DATA object, not a CRC-specific opcode exception.
+func x86ScalarResultDataReadBodies(arch string) map[string]string {
+	bodies := map[string]string{
+		"MOVD":      "MOVD table<>+16(SB),X1\n",
+		"MOVL":      "MOVL table<>+16(SB),X1\n",
+		"MOVQ":      "MOVQ table<>+16(SB),X1\n",
+		"VMOVD":     "VMOVD table<>+16(SB),X1\n",
+		"VMOVQ":     "VMOVQ table<>+16(SB),X1\n",
+		"MOVSS":     "MOVSS table<>+16(SB),X1\n",
+		"MOVSD":     "MOVSD table<>+16(SB),X1\n",
+		"PXOR":      "PXOR X1,X1\nPXOR table<>+16(SB),X1\n",
+		"PAND":      "PXOR X1,X1\nPAND table<>+16(SB),X1\n",
+		"PADDB":     "PXOR X1,X1\nPADDB table<>+16(SB),X1\n",
+		"PCLMULQDQ": "PXOR X1,X1\nPCLMULQDQ $17,table<>+16(SB),X1\n",
+	}
+	for _, name := range []string{"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD"} {
+		bodies[name] = name + " table<>+16(SB),X1\n"
+	}
+	for _, pair := range [][2]string{
+		{"PSRLW", "VPSRLW"}, {"PSRLL", "VPSRLD"}, {"PSRLQ", "VPSRLQ"},
+		{"PSLLW", "VPSLLW"}, {"PSLLL", "VPSLLD"}, {"PSLLQ", "VPSLLQ"},
+	} {
+		bodies[pair[0]] = "PXOR X1,X1\n" + pair[0] + " table<>+16(SB),X1\n"
+		bodies[pair[1]] = "PXOR X0,X0\n" + pair[1] + " table<>+16(SB),X0,X1\n"
+	}
+	if arch == "amd64" {
+		bodies["VPCLMULQDQ"] = "PXOR X0,X0\nVPCLMULQDQ $17,table<>+16(SB),X0,X1\n"
+	}
+	return bodies
+}
+
+const x86ScalarResultDataTable = `DATA table<>+0(SB)/8,$0x0123456789abcdef
+DATA table<>+16(SB)/8,$0xfedcba9876543210
+DATA table<>+24(SB)/8,$0x1020304050607080
+GLOBL table<>(SB),8,$32
+`
+
+func TestX86LoweredScalarDataWithoutLocalStorageDoesNotResolve(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, body := range []string{
+			"MOVL value+0(FP),AX\nRET\n",
+			"MOVOU external(SB),X1\nRET\n",
+			"CALL ·callee(SB)\nRET\n",
+		} {
+			t.Run(arch+"/"+strings.Fields(body)[0], func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·view(SB),4,$0-8\n"+body)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var calls []string
+				resolve := func(symbol string) string {
+					calls = append(calls, symbol)
+					return strings.TrimPrefix(symbol, "·")
+				}
+				sigs := map[string]FuncSig{"view": {Name: "view", Ret: Void}, "callee": {Name: "callee", Ret: Void}}
+				reads := x86LoweredScalarDataReads(file, resolve, sigs, arch)
+				if reads != nil || len(calls) != 0 {
+					t.Fatalf("without emitted storage there is no DATA directory or resolver work: reads=%v calls=%v", reads, calls)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultSameFileDataMatrix(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for name, body := range x86ScalarResultDataReadBodies(target.arch) {
+			t.Run(target.triple+"/"+name, func(t *testing.T) {
+				source := x86ScalarResultDataTable + "TEXT ·view(SB),4,$0-4\n" + body +
+					"PEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+					if err != nil {
+						t.Errorf("%s: emitted same-file DATA did not supply numerical input: %v", api, err)
+						continue
+					}
+					compileLLVMToObject(t, llc, target.triple, "data-read.ll", "data-read.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultSameFileDataBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for name, source := range map[string]string{
+			"external":        "MOVOU external(SB),X1\n",
+			"negative offset": "MOVOU table<>-1(SB),X1\n",
+			"beyond end":      "MOVOU table<>+17(SB),X1\n",
+			"entirely beyond": "MOVOU table<>+32(SB),X1\n",
+			"unknown index":   "MOVOU table<>+0(SB)(AX*1),X1\n",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				source = x86ScalarResultDataTable + "TEXT ·view(SB),4,$0-4\n" + source +
+					"PEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", arch, triple, api); err == nil || name != "unknown index" && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s did not reject missing DATA extent: %v", api, err)
+					}
+				}
+			})
+		}
+		for _, size := range []int{4, 8, 15, 16} {
+			t.Run(fmt.Sprintf("%s/extent-%d", arch, size), func(t *testing.T) {
+				// An initialized allocation includes zero-filled holes. Width is
+				// still the complete native read, not the selected result lane.
+				for _, op := range []string{"MOVOU", "PSRLQ", "PSLLW"} {
+					source := fmt.Sprintf("GLOBL table<>(SB),8,$%d\nTEXT ·view(SB),4,$0-4\nPXOR X1,X1\n%s table<>(SB),X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", size, op)
+					for _, api := range []string{"text", "module", "Go"} {
+						_, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", arch, triple, api)
+						if size < 16 && !errors.Is(err, ErrProbeNeedsContext) || size == 16 && err != nil {
+							t.Fatalf("%s/%s size=%d: %v", op, api, size, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultDataDoesNotGrantStandaloneProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for name, body := range x86ScalarResultDataReadBodies(arch) {
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32",
+				body+"PEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET")
+			data, err := Parse(ArchAMD64, x86ScalarResultDataTable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file.Data, file.Globl = data.Data, data.Globl
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s/%s standalone query gained emitted storage: %v", arch, name, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86LoweredScalarResultDataRelocationRemainsContext(t *testing.T) {
+	source := strings.Replace(x86ScalarResultDataTable, "$0xfedcba9876543210", "$·external(SB)", 1) +
+		"TEXT ·view(SB),4,$0-4\nMOVOU table<>+16(SB),X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s treated a linker pointer as a numerical constant: %v", api, err)
+		}
+	}
+}
+
+func TestX86LoweredScalarResultDataResolvedObjectIdentity(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86ScalarResultDataTable+
+		"TEXT ·view(SB),4,$0-4\nMOVOU table<>+16(SB),X1\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string {
+		if strings.TrimPrefix(sym, "·") == "alias<>" {
+			return "table<>"
+		}
+		return strings.TrimPrefix(sym, "·")
+	}
+	address := x86StaticSBAddress{symbol: "table<>", offset: 16}
+	if reads := x86LoweredScalarDataReads(file, resolve, nil, "amd64"); reads[address] != 16 {
+		t.Fatal("actual resolved DATA object lost its complete range", reads)
+	}
+	for _, change := range []string{"alias relocation", "alias unresolved extent", "alias function", "signature symbol", "signature LLVM name"} {
+		t.Run(change, func(t *testing.T) {
+			mutated := *file
+			mutated.Data = append([]DataStmt(nil), file.Data...)
+			mutated.Globl = append([]GloblStmt(nil), file.Globl...)
+			mutated.Funcs = append([]Func(nil), file.Funcs...)
+			var sigs map[string]FuncSig
+			switch change {
+			case "alias relocation":
+				mutated.Data = append(mutated.Data, DataStmt{Sym: "alias<>", Off: 0, Width: 8, Addr: "·external(SB)"})
+			case "alias unresolved extent":
+				mutated.Globl = append(mutated.Globl, GloblStmt{Sym: "alias<>", SizeRaw: "missing"})
+			case "alias function":
+				mutated.Funcs = append(mutated.Funcs, Func{Sym: "·alias<>"})
+			case "signature symbol":
+				sigs = map[string]FuncSig{"table<>": {Ret: Void}}
+			case "signature LLVM name":
+				sigs = map[string]FuncSig{"other": {Name: "table<>", Ret: Void}}
+			}
+			if reads := x86LoweredScalarDataReads(&mutated, resolve, sigs, "amd64"); len(reads) != 0 {
+				t.Fatal("raw name bypassed complete resolved object validation", reads)
+			}
+		})
+	}
+}
+
+func TestX86LoweredScalarResultDataReadScopeDoesNotEscape(t *testing.T) {
+	state := x86ResultState{loweredStaticReads: map[x86StaticSBAddress]int64{{symbol: "table<>"}: 16}}
+	read := Operand{Kind: OpSym, Sym: "table<>(SB)"}
+	if !x86ResultRead(read, 16, &state, nil, "amd64") || x86ResultRead(read, 17, &state, nil, "amd64") {
+		t.Fatal("ephemeral reader did not enforce exact complete width")
+	}
+	for _, copy := range []x86ResultState{state.clone(), state.intersect(state)} {
+		if copy.loweredStaticReads != nil || x86ResultRead(read, 16, &copy, nil, "amd64") {
+			t.Fatal("a reaching CFG state retained the temporary DATA reader")
+		}
+	}
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint32",
+		"MOVOU table<>(SB),X1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET")
+	ctx := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: sig, goarch: "amd64",
+		fpScalarData: map[x86StaticSBAddress]int64{{symbol: "table<>"}: 16}}
+	if err := ctx.checkLoweredScalarFPResultInitialization(); err != nil {
+		t.Fatal("ephemeral DATA read did not close the lowering-only result", err)
+	}
+	if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("private lowering changed the standalone source query", err)
+	}
+}
diff --git a/amd64_scalar_fp_float_initialization.go b/amd64_scalar_fp_float_initialization.go
new file mode 100644
index 000000000..ce9553ec9
--- /dev/null
+++ b/amd64_scalar_fp_float_initialization.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+// This transfer consumes existing typed arithmetic syntax solely for numeric
+// byte definedness. Native reads, caller certificates, ISA, exceptions and
+// MXCSR remain the lowerer's independent contracts. X/Y/Z views share complete
+// physical-bank byte state, including legacy preservation and vector clearing.
+func x86ScalarFPFloatBinaryTransfer(ins Instr, form x86FloatBinaryForm, state *x86ResultState, owned []bool, arch string) bool {
+	return x86ScalarFPFloatBinaryTransferWithRead(ins, form, state, owned, arch, false)
+}
+
+// Only the paired native emitter can supply an active source value after its
+// exact access continues. Register, mask and merge inputs remain independent.
+func x86ScalarFPFloatBinaryTransferWithRead(ins Instr, form x86FloatBinaryForm,
+	state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.bits == 16 {
+		original, valid := x86RawFP16BinarySourceForm(ins, arch)
+		if !nativeRead || !valid || original.x86FloatBinaryForm != form {
+			return false
+		}
+		// Only this local read consumes the paired access. Original identity
+		// remains required and no raw/caller/memory permission escapes.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	} else if form.bits != 32 && form.bits != 64 {
+		return false
+	}
+	width := int64(form.byteWidth)
+	if form.scalar {
+		width = int64(form.bits / 8)
+	}
+	required := x86CallerVectorByteMask(width)
+	xreg := func(operand Operand) (int, bool) {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		return index, operand.Kind == OpReg && valid && index < len(state.xmm) &&
+			(arch != "386" || index < 8) && (!form.legacy || index < 16)
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	for _, input := range []int{form.first, form.second} {
+		if form.literal && input == form.first {
+			continue
+		}
+		if input == form.memory {
+			// FP/AUTO have independently initialized logical byte envelopes.
+			// A GP/SB native address cannot obtain authority from this query.
+			if !x86ResultReadWithNativeContinuation(ins, ins.Args[input], int64(form.memoryBytes), state, owned, arch, nativeRead) {
+				return false
+			}
+			continue
+		}
+		index, valid := xreg(ins.Args[input])
+		if !valid || state.vectorBytes(index)&required != required {
+			return false
+		}
+	}
+	destination, valid := xreg(ins.Args[form.destination])
+	if !valid {
+		return false
+	}
+	old := state.vectorBytes(destination)
+	if form.mask >= 0 && !form.zeroing && old&required != required {
+		return false
+	}
+	known := x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.legacy {
+		known = old | required
+	} else if form.scalar {
+		second, valid := xreg(ins.Args[form.second])
+		if !valid {
+			return false
+		}
+		known = required | state.vectorBytes(second)&^required
+	}
+	state.writeVector(destination, form.byteWidth, known, form.legacy)
+	return true
+}
diff --git a/amd64_scalar_fp_initialization.go b/amd64_scalar_fp_initialization.go
new file mode 100644
index 000000000..26c3a050a
--- /dev/null
+++ b/amd64_scalar_fp_initialization.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+// This private transfer extends the existing must-initialized result analysis
+// for logical scalar views and existing exact same-Void-source whole128 caller
+// reads. It does not expand the public asmdecl-filter query, caller admission,
+// frame backing, or pointer permissions.
+func checkX86ScalarFPResultInitialization(fn Func, sig FuncSig, arch string) error {
+	reads := x86ScalarFPCallerReads(fn, sig, arch)
+	if fn.x86DirectTailRoot != nil {
+		reads = nil // No helper may borrow another TEXT's caller-read ordinal.
+	}
+	return checkX86ABI0ResultInitializationAtSource(fn, sig, arch,
+		func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			if read, present := reads[ordinal]; present {
+				return read.transfer(ins, state, owned, resultOffset, arch)
+			}
+			return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+		}, true)
+}
+
+func x86ScalarFPResultTransfer(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+	if accepted, known := x86ResultSingleSourceNarrowStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultExplicitMaskMoveStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86MaskLogicalResultStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86MaskVectorResultStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultNonTemporalVectorStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86MaskValueResultStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultX87ValueStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultX87StatusProjection(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSDKLiteralStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultNumericalReadStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultFloatingHelperStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultFloatCompareStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch); known && err == nil &&
+		form.memory < 0 && x86ResultNamedPredicateInstruction(ins) {
+		// A nontrapping register copy transports only the source's numerical
+		// bytes. Unknown bytes stay unknown; legacy upper aliases and FLAGS
+		// are preserved. Memory and raw observers keep their strict path.
+		source, _ := amd64ParseXReg(form.source.Reg)
+		destination, _ := amd64ParseXReg(form.destination.Reg)
+		state.writeVector(destination, 16, state.vectorBytes(source), true)
+		return true
+	}
+	if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known {
+		return err == nil && x86ResultPackedVectorMoveTransfer(ins, form, state, owned, resultOffset, arch, false)
+	}
+	if form, known, err := x86PackedLogicalProperties(ins, arch); known {
+		return err == nil && x86ScalarFPLogicalTransfer(ins, form, state, owned, arch)
+	}
+	if f, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+		return err == nil && x86ResultGPSIMDTransfer(ins, f, state, owned, resultOffset, arch)
+	}
+	if form, recognized, err := x86FloatAddSubProperties(ins, arch); recognized {
+		return err == nil && x86ScalarFPFloatBinaryTransfer(ins, form.x86FloatBinaryForm, state, owned, arch)
+	}
+	if form, recognized, err := x86FloatMulDivProperties(ins, arch); recognized {
+		return err == nil && x86ScalarFPFloatBinaryTransfer(ins, form.x86FloatBinaryForm, state, owned, arch)
+	}
+	if accepted, known := x86ResultFloatMinMaxStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86MaskMoveResultStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, arch); known {
+		// A sparse low-product NUM projection is not the complete source
+		// input contract. Keep the existing word-family guard after marked
+		// literal/read validation, including Void and paired native reads.
+		return err == nil && x86ResultFixedVectorInputs(ins, form.x86PackedBinaryForm, false, state, owned, arch)
+	}
+	form, recognized, err := amd64ScalarVectorMoveProperties(ins, arch)
+	if !recognized || form.spec.legacy {
+		return x86ResultTransfer(ins, state, owned, resultOffset, arch)
+	}
+	return err == nil && x86ScalarVectorMoveResultTransfer(ins, form, state, owned, resultOffset, arch, false)
+}
+
+// Every typed X/Y/Z form consumes the same physical-bank byte domain. Physical
+// MMX remains separate; no vector effect turns a native pointer into FP data.
+func x86ScalarFPLogicalTransfer(ins Instr, form x86PackedLogicalForm, state *x86ResultState, owned []bool, arch string) bool {
+	return x86ScalarFPLogicalTransferWithRead(ins, form, state, owned, arch, false)
+}
+
+func x86ScalarFPLogicalTransferWithRead(ins Instr, form x86PackedLogicalForm, state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.mmx {
+		return false
+	}
+	xreg := func(operand Operand) (int, bool) {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		return index, operand.Kind == OpReg && valid && index < len(state.xmm) && (arch != "386" || index < 8)
+	}
+	second, valid := xreg(ins.Args[form.second])
+	if !valid {
+		return false
+	}
+	destination, valid := xreg(ins.Args[form.destination])
+	if !valid {
+		return false
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	first := x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false // Even a zero mask supplies no missing native envelope.
+		}
+	} else {
+		index, valid := xreg(ins.Args[form.first])
+		if !valid {
+			return false
+		}
+		first = state.vectorBytes(index)
+	}
+	known := x86PackedLogicalDefinedBytes(ins, form, first,
+		state.vectorBytes(second), state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, known, form.legacy)
+	return true
+}
diff --git a/amd64_scalar_fp_initialized_test.go b/amd64_scalar_fp_initialized_test.go
new file mode 100644
index 000000000..9e98a93ef
--- /dev/null
+++ b/amd64_scalar_fp_initialized_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarFPBitViewsMaskedParameterLoadsRequireDefinedInputs(t *testing.T) {
+	for _, bits := range []int{32, 64} {
+		op := "MOVSS"
+		if bits == 64 {
+			op = "MOVSD"
+		}
+		for name, before := range map[string]string{
+			"unknown mask":     "",
+			"partial GP mask":  "MOVB $1,AX\nKMOVD AX,K1\n",
+			"branch-only mask": "MOVL $1,AX\nCMPL AX,$0\nJE joined\nKMOVD AX,K1\njoined:\n",
+			"unknown merge":    "MOVL $0,AX\nKMOVD AX,K1\n",
+			"partial merge":    "MOVSS x+0(FP),X1\nMOVSS X1,X7\nMOVL $0,AX\nKMOVD AX,K1\n",
+		} {
+			for _, zeroing := range []bool{false, true} {
+				// Partial X initialization matters only to an eight-byte merge;
+				// zeroing does not read the old low destination lane.
+				if name == "partial merge" && (bits == 32 || zeroing) || name == "unknown merge" && zeroing {
+					continue
+				}
+				suffix := ""
+				if zeroing {
+					suffix = ".Z"
+				}
+				fixture := x86ScalarFPBitFixture{
+					name:        fmt.Sprintf("%d/%s/zero%t", bits, name, zeroing),
+					declaration: fmt.Sprintf("func view(x uint64) uint%d\n", bits),
+					body:        before + fmt.Sprintf("V%s%s x+0(FP),K1,X7\n%s X7,ret+8(FP)", op, suffix, op),
+				}
+				x86ScalarFPInitializationContextFixture(t, fixture, name == "unknown merge" || name == "partial merge")
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsWholeNumericStoresRequireDefinedSource(t *testing.T) {
+	for _, fixture := range []x86ScalarFPBitFixture{
+		{name: "integer32", declaration: "func view() uint32\n", body: "MOVSS X7,ret+0(FP)"},
+		{name: "integer64", declaration: "func view() uint64\n", body: "MOVSD X7,ret+0(FP)"},
+		{name: "two-integers", declaration: "func view() (a,b uint32)\n", body: "VMOVSD X7,a+0(FP)"},
+		{name: "mixed", declaration: "func view() (a float32,b uint32)\n", body: "MOVSD X7,a+0(FP)"},
+		{name: "partial-register", declaration: "func view(x uint64) uint64\n", body: "MOVSS x+0(FP),X1\nMOVSS X1,X7\nVMOVSD X7,ret+8(FP)"},
+		{name: "branch-only-register", declaration: "func view(x uint64) uint32\n", body: "MOVL $1,AX\nCMPL AX,$0\nJE joined\nMOVSS x+0(FP),X7\njoined:\nMOVSS X7,ret+8(FP)"},
+	} {
+		x86ScalarFPInitializationContextFixture(t, fixture, true)
+	}
+}
+
+func x86ScalarFPInitializationContextFixture(t *testing.T, fixture x86ScalarFPBitFixture, ordinaryScratch ...bool) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+			source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+				if target.arch == "amd64" && (fixture.name == "Y-unmodeled-wide" || fixture.name == "Z-unmodeled-wide" || len(ordinaryScratch) == 1 && ordinaryScratch[0]) {
+					x86VectorScratchCodegenControl(t, source, fixture.declaration, target.arch, target.triple, ir, err)
+					continue
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Errorf("%s unknown numeric input acquired a value: %v\n%s", api, err, ir)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarFPBitViewsKnownMaskedLoadControls(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, bits := range []int{32, 64} {
+		op := "MOVSS"
+		if bits == 64 {
+			op = "MOVSD"
+		}
+		for _, zeroing := range []bool{false, true} {
+			for _, active := range []int{0, 1} {
+				suffix, initialize := "", op+" y+8(FP),X7\n"
+				if zeroing {
+					suffix, initialize = ".Z", ""
+				}
+				fixture := x86ScalarFPBitFixture{
+					name:        fmt.Sprintf("%d/mask%d/zero%t", bits, active, zeroing),
+					declaration: fmt.Sprintf("func view(x,y uint64) uint%d\n", bits),
+					body:        initialize + fmt.Sprintf("MOVL $%d,AX\nKMOVD AX,K1\nV%s%s x+0(FP),K1,X7\n%s X7,ret+16(FP)", active, op, suffix, op),
+				}
+				for _, target := range x86RawReturnTargets {
+					t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+						source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+							if err != nil {
+								t.Fatalf("%s initialized control: %v", api, err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsMaskedHelperCannotUseMissingSourceProof(t *testing.T) {
+	for _, bits := range []int{32, 64} {
+		t.Run(fmt.Sprint(bits), func(t *testing.T) {
+			var ir strings.Builder
+			ctx := newAMD64Ctx(&ir, Func{}, FuncSig{
+				Args: []LLVMType{I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			}, nil, nil, false)
+			if _, err := ctx.loadX86ScalarMemoryIf(Operand{Kind: OpFP}, bits, "false"); !errors.Is(err, ErrProbeNeedsContext) || ir.Len() != 0 {
+				t.Fatalf("masked helper manufactured a source or emitted a branch: %v\n%s", err, ir.String())
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_fp_logical_test.go b/amd64_scalar_fp_logical_test.go
new file mode 100644
index 000000000..a4be1b553
--- /dev/null
+++ b/amd64_scalar_fp_logical_test.go
@@ -0,0 +1,277 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent Go yxm/ymm and AVX _yvaddsubpd/_yvandnpd/_yvblendmpd
+// witnesses. Do not derive the private-consumer denominator from its registry.
+var x86ScalarFPLogicalOpcodes = []string{
+	"ANDPS", "ANDPD", "ANDNPS", "ANDNPD", "ORPS", "ORPD", "XORPS", "XORPD",
+	"PAND", "PANDN", "POR", "PXOR",
+	"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD",
+	"VPAND", "VPANDN", "VPOR", "VPXOR",
+	"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ",
+}
+
+var x86ScalarFPLogicalEVEXOpcodes = []string{
+	"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD",
+	"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ",
+}
+
+func x86ScalarFPLogicalRow(op string) (row string, destination int) {
+	if strings.HasPrefix(op, "V") {
+		return op + " X0,X1,X2", 2
+	}
+	return op + " X0,X1", 1
+}
+
+func TestX86ScalarFPLogicalCompleteXFormsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	if len(x86ScalarFPLogicalOpcodes) != 32 {
+		t.Fatal("independent Go logical family denominator changed")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86ScalarFPLogicalCompleteSource(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("complete logical inputs lost result initialization: %v", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "logical-results-"+api+".ll", "logical-results-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
+
+func x86ScalarFPLogicalCompleteSource(t *testing.T, arch string) (string, string) {
+	t.Helper()
+	var source, declarations strings.Builder
+	count := 0
+	add := func(body, params string, resultOffset int) {
+		fmt.Fprintf(&source, "TEXT ·logical%d(SB),4,$0-%d\n%s\nRET\n", count, resultOffset+8, body)
+		fmt.Fprintf(&declarations, "func logical%d(%s) uint64\n", count, params)
+		count++
+	}
+	const inputs = "MOVL $1,AX\nMOVL AX,X0\nMOVL $3,BX\nMOVL BX,X1\n"
+	for _, op := range x86ScalarFPLogicalOpcodes {
+		row, destination := x86ScalarFPLogicalRow(op)
+		add(inputs+row+fmt.Sprintf("\nMOVQ X%d,ret+0(FP)", destination), "", 0)
+		if !strings.HasPrefix(op, "V") {
+			// Complete numerical FP bytes are not a native m128 backing or
+			// alignment witness for legacy SSE. Its public Context/fault
+			// contract is tested independently of private byte definedness.
+			continue
+		}
+		memory := op + " a+0(FP),X1"
+		memory += ",X2"
+		add(inputs+memory+fmt.Sprintf("\nMOVQ X%d,ret+16(FP)", destination), "a,b uint64", 16)
+	}
+	for _, op := range x86ScalarFPLogicalEVEXOpcodes {
+		add(inputs+op+".BCST a+0(FP),X1,X2\nMOVQ X2,ret+8(FP)", "a uint64", 8)
+		if arch == "amd64" {
+			// Go's mode32 parser/grammar has no four-operand masked row.
+			// The unmasked and broadcast rows above still compile on both
+			// mode32 targets; mask variants are not host-selected skips.
+			for _, suffix := range []string{"", ".Z"} {
+				init := inputs + "KMOVW AX,K1\n"
+				if suffix == "" {
+					init += "MOVL AX,X2\n"
+				}
+				add(init+op+suffix+" X0,X1,K1,X2\nMOVQ X2,ret+0(FP)", "", 0)
+			}
+		}
+	}
+	want := 68
+	if arch == "amd64" {
+		want = 100
+	}
+	if count != want {
+		t.Fatalf("complete independent %s logical source denominator changed: %d want%d", arch, count, want)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ScalarFPLogicalMaskMergeZeroAndCompleteMemoryBytes(t *testing.T) {
+	for _, op := range x86ScalarFPLogicalEVEXOpcodes {
+		for _, suffix := range []string{"", ".Z"} {
+			t.Run(op+suffix, func(t *testing.T) {
+				ins := x86YMMReadSource(t, op+suffix+" X0,X1,K1,X2")
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 16; missing++ {
+						state := x86ResultState{}
+						state.xmm[0], state.xmm[1], state.xmm[2] = 0xffff, 0xffff, 0xffff
+						state.masks[1] = true
+						if missing >= 0 {
+							state.xmm[input] &^= uint16(1) << uint(missing)
+						}
+						want := state.xmm[0] & state.xmm[1]
+						if suffix == "" {
+							want &= state.xmm[2]
+						}
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") || state.xmm[2] != want {
+							t.Fatalf("mask dependency input%d missing%d: got%04x want%04x", input, missing, state.xmm[2], want)
+						}
+						state.masks[1] = false
+						before := state.clone()
+						if x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(before, state) {
+							t.Fatal("unknown mask acquired a write or numerical proof")
+						}
+					}
+				}
+			})
+		}
+	}
+	for _, op := range x86ScalarFPLogicalOpcodes {
+		variants := []string{op}
+		for _, evex := range x86ScalarFPLogicalEVEXOpcodes {
+			if op == evex {
+				variants = append(variants, op+".BCST", op+".BCST.Z")
+			}
+		}
+		for _, name := range variants {
+			t.Run(name+"/FP-memory", func(t *testing.T) {
+				row := name + " a+0(FP),X1"
+				if strings.HasSuffix(name, ".Z") {
+					row += ",K1,X2"
+				} else if strings.HasPrefix(name, "V") {
+					row += ",X2"
+				}
+				ins := x86YMMReadSource(t, row)
+				width := 16
+				if strings.Contains(name, ".BCST") {
+					width = 4
+					if strings.HasSuffix(op, "PD") || strings.HasSuffix(op, "Q") {
+						width = 8
+					}
+				}
+				for missing := -1; missing < width; missing++ {
+					state := x86ResultState{fp: make([]bool, 16)}
+					owned := make([]bool, 16)
+					state.xmm[1], state.xmm[2], state.masks[1] = 0xffff, 0xffff, true
+					for i := range owned {
+						owned[i], state.fp[i] = true, i != missing
+					}
+					if got := x86ScalarFPResultTransfer(ins, &state, owned, 16, "amd64"); got != (missing == -1) {
+						t.Fatalf("potential FP read width%d missing%d: accepted%t", width, missing, got)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFPLogicalEveryByteAndExactZeroIdiom(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ScalarFPLogicalOpcodes {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				row, destination := x86ScalarFPLogicalRow(op)
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				for input := 0; input < 2; input++ {
+					for missing := -1; missing < 16; missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+						if missing >= 0 {
+							state.xmm[input] &^= uint16(1) << uint(missing)
+						}
+						want := state.xmm[0] & state.xmm[1]
+						before := state.clone()
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || state.xmm[destination] != want {
+							t.Fatalf("%s input%d missing%d: initialized bytes=%04x, want %04x", row, input, missing, state.xmm[destination], want)
+						}
+						before.xmm[destination] = want
+						if strings.HasPrefix(op, "V") {
+							before.vectorUpper[destination] = ^uint64(0xffff)
+						}
+						if !reflect.DeepEqual(before, state) {
+							t.Fatal("logical definedness changed unrelated GP/FP/flags/mask/pointer state")
+						}
+					}
+				}
+				zero := strings.Contains(op, "XOR") || strings.Contains(op, "ANDN")
+				if strings.HasPrefix(op, "V") {
+					ins.Args[1] = ins.Args[0]
+				} else {
+					ins.Args[0] = ins.Args[1]
+				}
+				state := x86ResultState{}
+				want := uint16(0)
+				if zero {
+					want = 0xffff
+				}
+				if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || state.xmm[destination] != want {
+					t.Fatalf("exact register zero idiom %s: got %04x want %04x", op, state.xmm[destination], want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFPLogicalKeepsUnknownResultAndNativeMemoryBoundaries(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown input":       "PXOR X0,X1\nMOVQ X1,ret+0(FP)",
+		"partial low qword":   "MOVSS $1.0,X2\nMOVSS X2,X0\nPXOR X0,X1\nMOVQ X1,ret+0(FP)",
+		"native pointer read": "MOVQ $1,AX\nPXOR (AX),X0\nMOVQ X0,ret+0(FP)",
+		"unknown global read": "PXOR input(SB),X0\nMOVQ X0,ret+0(FP)",
+		"missing result":      "PXOR X0,X0\nMOVQ X0,output(SB)",
+		"unknown global data": "MOVQ X0,output(SB)\nMOVQ X0,ret+0(FP)",
+		"unknown merge":       "PXOR X0,X0\nMOVL $1,AX\nKMOVW AX,K1\nVPXORD X0,X0,K1,X2\nMOVQ X2,ret+0(FP)",
+		"unknown mask":        "PXOR X0,X0\nVPXORD.Z X0,X0,K1,X2\nMOVQ X2,ret+0(FP)",
+		"unknown wider bank":  "VPXOR Y0,Y2,Y1\nMOVQ X1,ret+0(FP)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := "TEXT ·view(SB),4,$0-8\n" + body + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint64\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if name == "unknown input" || name == "partial low qword" || name == "unknown merge" || name == "unknown wider bank" || name == "native pointer read" {
+					x86VectorScratchCodegenControl(t, source, "func view() uint64\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					if name == "native pointer read" && (!strings.Contains(ir, "call <4 x float> asm sideeffect \"pxor ($2), $0\"") || !strings.Contains(ir, "~{memory}")) {
+						t.Fatal("NUM address lost its original m128 PXOR read", api)
+					}
+					continue
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s acquired result or memory permission: %v\n%s", api, err, ir)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarFPLogicalNumericalSBStoreKeepsIndependentResult(t *testing.T) {
+	const source = "GLOBL slot<>(SB),16,$8\nTEXT ·view(SB),4,$0-8\nPXOR X0,X0\nMOVQ X0,slot<>(SB)\nMOVQ X0,ret+0(FP)\nRET\n"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint64\n", target.arch, target.triple, api)
+					if err != nil || !strings.Contains(ir, "store volatile i64") {
+						t.Fatalf("numeric SB side effect lost before independent result: %v", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "logical-sb-"+api+".ll", "logical-sb-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_fp_native_read.go b/amd64_scalar_fp_native_read.go
new file mode 100644
index 000000000..12f5b5ed6
--- /dev/null
+++ b/amd64_scalar_fp_native_read.go
@@ -0,0 +1,965 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// Exact private codegen-only outcome after a complete paired recheck. The
+// original strict cause stays cached and cannot grant complete storage roles.
+type x86LoweredVectorEntryAuditError struct{ error }
+
+func (err *x86LoweredVectorEntryAuditError) Unwrap() error {
+	return err.error
+}
+
+// This is a lowering-only numerical availability check. A paired original
+// opcode or volatile unaligned load either faults or produces its active
+// destination bytes; masked inactive bytes retain their separate rule. It does not
+// assert that the pointer is valid, aligned, in bounds, nonaliasing or backed by
+// initialized Go storage. Those conditions must not be optimizer assumptions.
+//
+// The declaration-only observers cannot use this rule: without the paired
+// original native opcode emission, their query supplies no such conditional
+// result. In particular, this never creates a caller-memory or raw-RET token.
+func (c *amd64Ctx) checkLoweredScalarFPResultInitialization() error {
+	fn, sig, arch := c.fpScalarSource, c.sig, c.goarch
+	rawPermute128 := x86Permute128RawReplayRequired(fn, arch)
+	if x86COMIRawReplayRequired(fn, arch) || x86FloatMinMaxRawReplayRequired(fn, arch) || x86ScalarPrecisionRawReplayRequired(fn, arch) ||
+		x86ExplicitMaskMoveRawReplayRequired(fn, arch) || x86PackedShiftRawReplayRequired(fn, arch) ||
+		x86PackedDotRawReplayRequired(fn, arch) || x86ZeroExtendRawReplayRequired(fn, arch) ||
+		x86PackedPrecisionRawReplayRequired(fn, arch) || rawPermute128 {
+		if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+			return err
+		}
+	}
+	var nativeMMX *x86NativeMMXRegion
+	named := true
+	for _, ins := range fn.Instrs {
+		named = named && x86ResultNamedPredicateInstruction(ins)
+	}
+	if named {
+		var err error
+		nativeMMX, err = newX86NativeMMXRegion(fn, c.fpSourceSig, arch, c.targetTriple)
+		if err != nil {
+			return err
+		}
+	}
+	if owned, err := c.checkCustomHelperBoolSource(); owned || err != nil {
+		return err
+	}
+	if x86StaticIntegerResultSourceCandidate(fn, sig, arch) {
+		return c.checkStaticIntegerResultInitialization()
+	}
+	if fn.x86ContinuationFlow != nil {
+		if err := c.checkContinuationResultSource(); err != nil {
+			return err
+		}
+		sig = c.fpSourceSig
+	}
+	if fn.x86FixedLocal != nil {
+		return c.checkFixedLocalResultInitialization()
+	}
+	if fn.x86SourceStack != nil && fn.x86SourceStack.scalarResult != nil {
+		return c.checkSourceStackScalarResultInitialization()
+	}
+	if calls := fn.x86BoolCalls; calls != nil && calls.registerTail != nil {
+		return calls.checkCustomRegisterTail(fn, sig, arch)
+	}
+	if calls := fn.x86BoolCalls; calls != nil && calls.tail != nil {
+		return calls.checkTailTerminal(fn, sig, arch)
+	}
+	strictErr := checkX86ScalarFPResultInitialization(fn, sig, arch)
+	customRegisterBool := arch == "386" && sig.Ret == I1 && len(sig.ArgRegs) != 0
+	logicalScalar := x86LogicalScalarResultNeedsProof(sig, arch)
+	if customRegisterBool || logicalScalar {
+		strictErr = checkX86LogicalRegisterResultInitialization(fn, sig, arch,
+			func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+			}, customRegisterBool, false)
+	}
+	registerEntry := arch == "amd64" && strings.HasSuffix(fn.Sym, "<ABIInternal>")
+	if registerEntry {
+		strictErr = checkAMD64RegisterResultInitialization(fn, sig,
+			func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+			})
+	}
+	_, incompleteResults := strictErr.(*x86IncompleteResultError)
+	ordinaryIncomplete := incompleteResults && x86OrdinaryScalarTupleResultRole(fn, sig, arch)
+	if (strictErr == nil || ordinaryIncomplete) && nativeMMX == nil {
+		// Complete numerical bytes do not authenticate the original source.
+		// Keep the existing native/frame owners independent, but apply the
+		// same restriction-only replay before ordinary strict success too.
+		// This branch returns, so the later paired path never repeats it.
+		if len(fn.X86RawText) == 0 && fn.x86SourceStack == nil && fn.x86FixedLocal == nil {
+			if err := x86LoweredNumericalProducerReplay(fn, arch); err != nil {
+				return err
+			}
+		}
+		return strictErr
+	}
+	if selected, err := c.checkRawLogicalScalarResult(); selected {
+		return err
+	}
+	if selected, err := c.checkRawLiteralResults(); selected {
+		return err
+	}
+	if x86TrapOnlyLogicalFPSourceRole(fn, sig, arch) {
+		if err := c.checkTrapOnlyLogicalFPResultInitialization(); err == nil {
+			c.fpScalarTrapOnly = true
+			return nil
+		}
+	}
+	// Native/raw entry contracts are established before ordinary lowering.
+	// Do not let this conditional byte rule create or supplement one.
+	if len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil {
+		return strictErr
+	}
+	if err := x86LoweredNumericalProducerReplay(fn, arch); err != nil {
+		return err // One restriction-only source check, never an input/native capability.
+	}
+	boundRawClear := false
+	boundRawUnaligned := false
+	boundRawConversion := false
+	boundRawMinMax := false
+	boundRawReduction := false
+	boundRawTernary := false
+	boundRawFloatMinMax := false
+	boundRawScalarPrecision := false
+	boundRawExplicitMaskMove := false
+	boundRawPackedShift := false
+	boundRawPackedDot := false
+	boundRawZeroExtend := false
+	boundRawPackedPrecision := false
+	for _, ins := range fn.Instrs {
+		if x86RawMaskMoveSource(ins, arch) {
+			continue // Exact mask data retains independent input, native-address and width checks.
+		}
+		if x86RawNamedHalfSource(ins, arch) {
+			continue // One whole-producer replay above; no new value, address or entry fact.
+		}
+		if x86RawPermute128Source(ins, arch) {
+			if !rawPermute128 {
+				return strictErr
+			}
+			continue // The complete replay above grants no missing input or memory fact.
+		}
+		if x86RawPackedPrecisionSource(ins, arch) {
+			if !boundRawPackedPrecision && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawPackedPrecision = true
+			continue // Exact source/generation grants no missing FP, mask, merge or memory input.
+		}
+		if x86RawZeroExtendSource(ins, arch) {
+			if !boundRawZeroExtend && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawZeroExtend = true
+			continue // Exact source identity supplies no missing address, mask or data bytes.
+		}
+		if x86RawPackedDotSource(ins, arch) {
+			if !boundRawPackedDot && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawPackedDot = true
+			continue // Exact generation/replay grants no arithmetic input or memory fact.
+		}
+		if x86RawPackedShiftSource(ins, arch) {
+			if !boundRawPackedShift && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawPackedShift = true
+			continue // Exact physical identity grants no count, data, mask, address or entry fact.
+		}
+		if x86RawExplicitMaskMoveSource(ins, arch) {
+			if !boundRawExplicitMaskMove && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawExplicitMaskMove = true
+			continue // Exact VEX source grants no mask, address, memory or entry fact.
+		}
+		if x86RawFloatMinMaxSource(ins, arch) {
+			if !boundRawFloatMinMax && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawFloatMinMax = true
+			continue // Physical generation supplies no missing inputs, memory or entry role.
+		}
+		if x86RawScalarPrecisionSource(ins, arch) {
+			if !boundRawScalarPrecision && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawScalarPrecision = true
+			continue // Exact mode/generation retains every active, merge, mask and native input obligation.
+		}
+		if x86RawScalarFloatIntegerSource(ins, arch) {
+			continue // Whole replay above supplies no pointer, data, MXCSR or native entry fact.
+		}
+		if x86RawLegacyFloatCompareSource(ins, arch) {
+			continue // Exact legacy compare bytes supply no missing input, native entry or backing.
+		}
+		if x86RawCOMISource(ins, arch) {
+			continue // Complete replay above binds the exact comparison, never its input or entry facts.
+		}
+		if x86RawTernaryLogicSource(ins, arch) {
+			if !boundRawTernary && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawTernary = true
+			continue // Exact mode/selector/operands supply no entry, pointer or reusable backing.
+		}
+		if x86RawScalarReciprocalSource(ins, arch) {
+			continue // Exact source identity retains scalar data, upper bytes and native m32 obligations.
+		}
+		if x86RawUnalignedLoadSource(ins, arch) {
+			if !boundRawUnaligned && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawUnaligned = true
+			continue // Exact original load/replay supplies no pointer or raw-entry permission.
+		}
+		if x86RawMoveHalfSource(ins, arch) {
+			continue // Exact sealed m64 moves grant no missing input, storage or raw-entry fact.
+		}
+		if x86RawVectorMoveSource(ins, arch) {
+			continue // Exact typed moves retain all numerical, mask and native address obligations.
+		}
+		if x86RawIntegerMinMaxSource(ins, arch) {
+			if !boundRawMinMax && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawMinMax = true
+			continue // Complete replay and typed shape supply no missing inputs or raw entry.
+		}
+		if x86RawPackedReductionSource(ins, arch) {
+			if !boundRawReduction && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawReduction = true
+			continue // Exact selectors, physical mode and native effects remain independent obligations.
+		}
+		if x86RawCompactSource(ins, arch) {
+			continue // Exact compact/expand bytes retain all mask, data and native address obligations.
+		}
+		if x86RawPackedConversionSource(ins, arch) {
+			if !boundRawConversion && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+				return strictErr
+			}
+			boundRawConversion = true
+			continue // Exact physical identity retains every typed input and native MXCSR/access obligation.
+		}
+		if x86RawPackedIntegerCompareSource(ins, arch) {
+			continue // Exact legacy/VEX/EVEX data retains every input, mask and paired native access obligation.
+		}
+		if x86RawBroadcastSource(ins, arch) {
+			continue // Exact scalar/block/K-data source retains every numerical and native E6 input obligation.
+		}
+		if x86RawBlendMinposSource(ins, arch) {
+			continue // Exact raw data retains independent mask, aliases and full native tuple obligations.
+		}
+		if x86RawImmediateBlendSource(ins, arch) {
+			continue // Whole replay retains selector, original mode and every native/source input obligation.
+		}
+		if x86RawCLMULSource(ins, arch) {
+			continue // Exact selector/data identity retains its whole native tuple and independent selected qwords.
+		}
+		if x86RawImmediatePackedCompareSource(ins, arch) {
+			continue // Exact immediate/data identity supplies no entry or missing numerical/memory input.
+		}
+		if x86RawQwordLookupSource(ins, arch) {
+			continue // Complete raw data/control inputs retain their separate memory and result obligations.
+		}
+		if x86RawVectorTestSource(ins, arch) {
+			continue // Exact data tests retain all input bytes and native source accesses.
+		}
+		if x86RawIFMASource(ins, arch) {
+			continue // Exact integer FMA retains its separate accumulator, mask and native-read obligations.
+		}
+		if x86RawFMA3Source(ins, arch) {
+			continue // Whole producer replay and native FMA preserve all three input obligations.
+		}
+		if x86RawSHASource(ins, arch) {
+			continue // Exact SHA bytes retain all source/state and native m128 obligations.
+		}
+		if x86RawAESSource(ins, arch) {
+			continue // Exact integer-crypto data keeps every source and state-byte obligation.
+		}
+		if x86RawCMOVSource(ins, arch) {
+			continue // Exact conditional data retains its own predicate and potential inputs.
+		}
+		if x86RawMOVBESource(ins, arch) {
+			continue // Decoder identity grants neither native input bytes nor a destination pointer.
+		}
+		if x86RawTernaryGPSource(ins, arch) {
+			continue // Exact source identity does not supply numerical inputs or native memory.
+		}
+		if x86RawADXSource(ins, arch) {
+			continue // Only the bound default address mode shares the typed carry chain.
+		}
+		if x86RawAlternatingFloatSource(ins, arch) {
+			continue // Exact original arithmetic retains every real vector and memory input.
+		}
+		if x86RawMULXSource(ins, arch) {
+			continue // Exact identity supplies neither implicit DX nor native address inputs.
+		}
+		if x86RawScalarObserverSource(ins, arch) {
+			continue // Existing typed count/mask effects retain all numerical inputs.
+		}
+		if x86RawScalarSegmentLoadSource(ins, arch) {
+			continue // Paired scalar reads retain hardware segments and exact numerical offsets.
+		}
+		if x86RawVectorZeroSource(ins, arch) {
+			continue // Exact implicit SIMD writes preserve independent native input roles.
+		}
+		if x86RawBMI2ShiftSource(ins, arch) {
+			continue // Exact shifts/rotates retain their complete count/data obligations.
+		}
+		if x86RawLegacyScalarShiftSource(ins, arch) {
+			continue // Exact legacy counts/data retain the paired ISA-outcome and native RMW proof.
+		}
+		if x86RawAccumulatorSignExtendSource(ins, arch) {
+			continue // Exact implicit GP arithmetic preserves its independent input obligations.
+		}
+		if x86RawDwordProductResultSource(ins, arch) {
+			continue // Exact decoded integer inputs retain their own mask/address obligations.
+		}
+		if _, valid := x86RawVMOVWResultForm(ins, arch); valid {
+			continue // Exact GP/X/m16 effects share no raw entry or native frame permission.
+		}
+		if _, valid := x86RawFP16ConversionSourceForm(ins, arch); valid {
+			continue // Exact conversion identity retains independent input and mask obligations.
+		}
+		if x86RawFP16SqrtSource(ins, arch) {
+			continue // Square-root inputs remain guarded by the shared typed byte effect.
+		}
+		if _, valid := x86RawFP16FMASourceForm(ins, arch); valid {
+			continue // FMA retains all three inputs, including a zeroing destination.
+		}
+		if _, valid := x86RawFP16BinarySourceForm(ins, arch); valid {
+			continue // Binary input/merge/upper bytes retain their own typed effect.
+		}
+		if _, valid := x86EnqueueSourceForm(ins, arch); valid {
+			continue // Exact device submission retains its own two-address native effect.
+		}
+		if x86EndBranchPreservesSourceState(ins) {
+			continue // Exact native CET tracking preserves inputs, not memory or entry permissions.
+		}
+		if ins.x86Encoded || ins.x86RawNearReturn != nil ||
+			ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return strictErr
+		}
+		if ins.x86SourceRaw != nil {
+			if x86MaskLogicalPreservesStorage(ins) {
+				continue // Exact K-only source has independent mask/FLAGS effects, not memory or entry authority.
+			}
+			if x86RegisterQueryPreservesSourceState(ins) {
+				// Exact original/normalized register producers share their
+				// checked inputs/outputs. They add no memory,
+				// raw-return, stack or native-entry authority to this continuation.
+				continue
+			}
+			if x86X87RawClearInstruction(ins) {
+				if !boundRawClear && (fn.x86RawReplay == nil || fn.x86RawReplay.validate(fn, arch) != nil) {
+					return strictErr
+				}
+				boundRawClear = true
+				continue
+			}
+			// The physical decoder already validated the complete NOP and
+			// its prefixes before discarding inert ModRM/SIB address fields.
+			// Ordinary padding has no memory, register, FLAGS or entry effect.
+			// Preserve the sealed original/normalized identity; no other raw
+			// instruction may borrow a named load's conditional result rule.
+			if !x86NOPPreservesSourceState(ins) {
+				return strictErr
+			}
+		}
+	}
+	lockPrefixes := x86ResultSourceLockPrefixes(fn, arch)
+	addressBitStores := x86LeafNativeAddressBitStoreScope(fn, c.fpSourceSig, arch)
+	stringMemory, err := x86ResultStringMemorySourcePlan(fn, arch)
+	if err != nil {
+		return err
+	}
+	ownedVectorReads := c.ownedIndexedVectorReads(fn, c.fpSourceSig, arch)
+	funcvalReads, err := c.goReadOnlyStorage.funcvalReadsFor(fn)
+	if err != nil {
+		return err
+	}
+	transfer := func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		shiftBits := state.shiftBits
+		state.shiftBits = x86ResultShiftBits{} // Only the immediately following instruction may consume it.
+		state.loweredStaticReads = c.fpScalarData
+		state.goReadOnlyRead = c.goReadOnlyStorage.readFor(ins, arch)
+		defer func() { state.loweredStaticReads, state.goReadOnlyRead = nil, nil }()
+		keepAddressBits := false
+		defer func() {
+			if !keepAddressBits {
+				state.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+			}
+		}()
+		if accepted, known := goFuncvalReadTransfer(funcvalReads, ordinal, ins, state, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultSDKLiteralStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Consume the exact bound source before an overlapping native-memory family.
+		}
+		if accepted, known := x86ResultNumericalReadStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // A checked mutable SB source keeps its own lifetime and byte effects.
+		}
+		if accepted, known := c.loweredElidedSchedulerHookStep(ins, state, arch); known {
+			return accepted // The existing elision does not supply a callable ABI.
+		}
+		if accepted, known := x86LoweredLinuxSyscallStep(ins, state, owned, resultOffset, arch, c.targetTriple); known {
+			return accepted // The paired raw kernel transition supplies no libc, pointer or continuation role.
+		}
+		if operand, width, valid := x86OwnedIndexedVectorReadAt(ownedVectorReads, ordinal, ins); valid {
+			// Ordinary private tables never precede complete SDK source owners.
+			state.literalMemoryOperand, state.literalMemoryBytes = &operand, width
+			defer func() { state.literalMemoryOperand, state.literalMemoryBytes = nil, 0 }()
+		}
+		if accepted, known := x86ResultImmediateBlendStep(ins, state, owned, arch, true); known {
+			return accepted // Legacy Type4 opcode or exact volatile VEX tuple retains dead reads and faults.
+		}
+		if accepted, known := x86ResultBlendMinposStep(ins, state, owned, arch, true); known {
+			return accepted // Legacy original opcodes and VEX whole volatile reads retain exact native faults.
+		}
+		if c.dataBPSource {
+			if accepted, known := x86ResultDataBPStep(ins, state, owned, resultOffset); known {
+				return accepted // Source-defined opaque BP, never physical frame or numerical pointer bits.
+			}
+		}
+		if accepted, known := x86ResultXLATStep(ins, state, owned, arch, true); known {
+			return accepted // Only the paired exact volatile m8 consumes the unsigned AL index and native BX input.
+		}
+		if accepted, known := x86ResultAlternatingFloatStep(ins, state, owned, arch, true); known {
+			return accepted // The VEX tuple remains observable even when its numerical result is dead.
+		}
+		if accepted, known := x86ResultRoundStep(ins, state, owned, arch, true); known {
+			return accepted // Scalar active bytes and copied upper bytes remain distinct.
+		}
+		if accepted, known := x86ResultVSIBStep(ins, state, arch, true); known {
+			return accepted // Exact indexed continuation; never an ordinary contiguous native tuple.
+		}
+		if accepted, known := x86ResultFourSourceStep(ins, state, owned, arch, true); known {
+			return accepted // One complete original opcode owns its m128 access and sequential native exceptions.
+		}
+		if accepted, known := x86ResultFMA3Step(ins, state, owned, arch, true); known {
+			return accepted // The original FMA retains all three inputs, its exact tuple and native MXCSR effects.
+		}
+		if accepted, known := x86ResultScalarPrecisionStep(ins, state, owned, arch, true); known {
+			return accepted // The paired original scalar conversion retains m32/m64 and MXCSR effects.
+		}
+		if accepted, known := x86ResultScalarFloatIntegerStepWithRead(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // The whole native conversion retains exact scalar reads and MXCSR even for Void.
+		}
+		if accepted, known := x86ResultNamedHalfStep(ins, state, owned, arch, true); known {
+			return accepted // The exact original conversion/store retains MXCSR and active native accesses.
+		}
+		if accepted, known := x86ResultPackedPrecisionStep(ins, state, owned, arch, true); known {
+			return accepted // The paired original packed conversion retains exact E2 reads and MXCSR effects.
+		}
+		if accepted, known := x86ResultPackedAbsSignStep(ins, state, owned, arch, true); known {
+			return accepted // Exact native reads and K inputs remain required for dead packed integer results.
+		}
+		if accepted, known := x86ResultIntegerMinMaxStep(ins, state, owned, arch, true); known {
+			return accepted // The paired E4 reader retains active exact-width volatile faults.
+		}
+		if accepted, known := x86ResultTernaryLogicContinuationStep(ins, state, owned, arch, true); known {
+			return accepted // Exact E4 reads survive constant selectors and dead Boolean results.
+		}
+		if accepted, known := x86LoweredRawPackedReductionStep(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultPackedReductionStep(ins, state, owned, arch, true); known {
+			return accepted // Paired whole native reduction retains exact reads and MXCSR/exception behavior.
+		}
+		if accepted, known := x86ResultMaskBlendStep(ins, state, owned, arch, true); known {
+			return accepted // The shared E4 reader retains exact volatile active-lane accesses.
+		}
+		if accepted, known := x86ResultPackedDotStep(ins, state, owned, arch, true); known {
+			return accepted // Paired E4 dwords retain active volatile reads, even for dead results.
+		}
+		if accepted, known := x86ResultPermute128Step(ins, state, owned, arch, true); known {
+			return accepted // Type6 retains the whole m256 access even for two zero halves.
+		}
+		if accepted, known := x86ResultElementPermuteStep(ins, state, owned, arch, true); known {
+			return accepted // E4NF retains the whole tuple/broadcast even at K=0 or for Void.
+		}
+		if accepted, known := x86ResultPackedFloatShuffleStep(ins, state, owned, arch, true); known {
+			return accepted // Same full E4NF access, with both selected numerical sources.
+		}
+		if accepted, known := x86ResultNativeLEAAddressBitsStep(ins, state, owned, arch, addressBitStores); known {
+			keepAddressBits = accepted
+			return accepted
+		}
+		if accepted, known := x86ResultUnalignedLoadStep(ins, state, owned, arch, true); known {
+			return accepted // Only the paired original opcode retains native overfetch and optional #AC.
+		}
+		if accepted, known := x86LoweredRawVectorMoveStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Only the exact move form shares this lowering-local provenance projection.
+		}
+		if accepted, known := x86LoweredScalarVectorMoveMemoryStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Exact active volatile m32/m64, without a reusable pointee fact.
+		}
+		if accepted, known := x86ResultScalarReciprocalStep(ins, state, owned, arch, true); known {
+			return accepted // Actual scalar estimate keeps the independent exact m32 access and MXCSR contract.
+		}
+		if accepted, known := x86ResultPackedReciprocalStep(ins, state, owned, arch, true); known {
+			return accepted // Only the paired original packed opcode owns its native access and alignment fault.
+		}
+		if accepted, known := x86ResultLegacyScalarMoveStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // Only the paired exact volatile legacy m32/m64 read supplies its conditional scalar bytes.
+		}
+		if accepted, known := x86ResultSegmentQueryStep(ins, state, owned, arch, true); known {
+			return accepted // Paired exact volatile m16; no backing or reusable read permission.
+		}
+		if accepted, known := x86ResultMoveHalfStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // Paired volatile m64 and selected halves preserve independent native inputs.
+		}
+		if accepted, known := x86LoweredADXResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredMULXResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Exact native read, implicit DX and both products; no FLAGS write.
+		}
+		if accepted, known := x86LoweredTernaryGPResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredMOVBEResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredRawScalarObserverStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredVectorZeroResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredBMI2ShiftResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredScalarShiftChoiceStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Only this producer-specific emitter materializes finite ISA-undefined outputs.
+		}
+		if accepted, known := x86LoweredAccumulatorSignExtendResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredImplicitDivideStep(ins, state, owned, arch); known {
+			return accepted // Only the original native #DE/access emitter supplies this continuation.
+		}
+		if accepted, known := x86LoweredImplicitMultiplyNativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted // Exact volatile input, with the existing implicit outputs and CF/OF only.
+		}
+		if accepted, known := x86LoweredExplicitIMULNativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted // The same exact native reader retains two/three-operand input roles.
+		}
+		if accepted, known := x86LoweredDwordProductResultStep(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredPackedConversionResultStep(ins, state, owned, arch); known {
+			return accepted // The complete original conversion is still emitted, including dead native effects.
+		}
+		if accepted, known := x86LoweredRawVMOVWResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredFP16ConversionStep(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredFP16FMAStep(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredFP16BinaryStep(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredEnqueueResultStep(ins, state, arch); known {
+			return accepted
+		}
+		if accepted, known := nativeMMX.transfer(ordinal, ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredNativeMXCSRStep(ins, state, arch); known {
+			return accepted
+		}
+		if accepted, known := c.scalarStaticAddressValueTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := c.scalarStaticMoveTransfer(ins, state, owned, arch); known {
+			return accepted // Exact owned writable bytes, never an external symbol or pointer-as-NUM grant.
+		}
+		if accepted, known := c.scalarStaticRMWTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := c.scalarStaticExchangeTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := stringMemory.transfer(ordinal, ins, state, arch); known {
+			return accepted
+		}
+		if ins.Op == "LOCK" {
+			prefix, bound := lockPrefixes[ordinal]
+			return bound && reflect.DeepEqual(prefix, ins)
+		}
+		if boundRawClear && x86X87RawClearInstruction(ins) {
+			return x86ResultX87BoundRawClear(ins, state, owned, resultOffset, arch)
+		}
+		if accepted, known := c.x87EnvironmentReadResultStep(ins, state, arch); known {
+			return accepted
+		}
+		if accepted, known := c.x87NativeFloatingMoveResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredStackNativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredStackNativeStore(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := c.x87HardwareControlResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // The same actual hardware emitter writes the full i16.
+		}
+		if accepted, known := c.x87HardwareRoundingResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // No ambient environment fact reaches the standalone query.
+		}
+		if accepted, known := x86LoweredCompareExchangeResultStepWithAddressBits(ins, state, owned, arch, addressBitStores); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredExchangeResultStepWithAddressBits(ins, state, owned, arch, addressBitStores); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredCRC32NativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted // The same typed emitter retains the exact volatile source read.
+		}
+		if accepted, known := x86LoweredScalarBitCountNativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultBitScanStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The paired scan emitter retains its exact volatile source read.
+		}
+		if accepted, known := x86ResultScalarBitFieldStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredBLSNativeRead(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultNonTemporalVectorStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredMOVNTIResultStep(ins, state, owned, arch); known {
+			return accepted // The original opcode retains cache policy and mandatory native write/faults.
+		}
+		if accepted, known := x86ResultFloatCompareStep(ins, state, owned, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86ResultExplicitMaskMoveStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // The whole original mask move retains active memory faults and writes.
+		}
+		if accepted, known := x86ResultImplicitMaskMoveStep(ins, state, arch, true); known {
+			return accepted // Preserve the original implicit address and non-temporal access, including zero masks.
+		}
+		if accepted, known := x86ResultFloatingHelperStep(ins, state, owned, arch, true); known {
+			return accepted // The complete native opcode retains MXCSR, exceptions and masked accesses.
+		}
+		if accepted, known := x86ResultSqrtStep(ins, state, owned, arch, true); known {
+			return accepted // The paired native opcode retains scalar/packed MXCSR effects.
+		}
+		if accepted, known := x86LoweredRawCOMIStep(ins, state, owned, arch); known {
+			return accepted // Only the bound original opcode owns this local numerical read.
+		}
+		if accepted, known := x86ResultCOMIStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The original scalar comparison retains exact read and MXCSR effects.
+		}
+		if accepted, known := x86ResultSignedIntegerFloatStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The same typed emitter retains an exact volatile source read.
+		}
+		if accepted, known := x86ResultUnsignedIntegerFloatStep(ins, state, owned, arch, true); known {
+			return accepted // The original EVEX opcode owns exact reads, MXCSR and precision exceptions.
+		}
+		if accepted, known := x86ResultSignedPackedFloatStep(ins, state, owned, arch, true); known {
+			return accepted // The original native opcode retains rounding, exception and memory effects.
+		}
+		if accepted, known := x86ResultPackedConversionStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The paired conversion retains its exact access and MXCSR effects.
+		}
+		if form, known, err := x86FloatAddSubProperties(ins, arch); known {
+			return err == nil && x86ScalarFPFloatBinaryTransferWithRead(ins, form.x86FloatBinaryForm, state, owned, arch, true)
+		}
+		if form, known, err := x86FloatMulDivProperties(ins, arch); known {
+			return err == nil && x86ScalarFPFloatBinaryTransferWithRead(ins, form.x86FloatBinaryForm, state, owned, arch, true)
+		}
+		if accepted, known := x86ResultFloatMinMaxStep(ins, state, owned, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86ResultPackedStringStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // Paired emitter retains the full volatile m128 read.
+		}
+		if accepted, known := x86ResultPackedZeroExtendStep(ins, state, owned, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86ResultPackedSignExtendStep(ins, state, owned, arch, true); known {
+			return accepted // Named SX shares exact E5 reads, never the separate raw ZX identity.
+		}
+		if accepted, known := x86ResultByteShuffleStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // Same full-tuple E4NF read or original legacy m128 opcode.
+		}
+		if accepted, known := x86ResultImmediateShuffleStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The paired full tuple or m32 read survives zero masks and dead results.
+		}
+		if accepted, known := x86ResultPackedAlignStep(ins, state, owned, arch, true); known {
+			return accepted // Full E4NF tuples and the original legacy alignment/fault opcode.
+		}
+		if accepted, known := x86ResultLegacyIntegerNativeReadStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, recognized := x86LoweredBlockNativeMemory(ins, state, owned, resultOffset, arch); recognized {
+			return accepted
+		}
+		if accepted, recognized := x86LoweredScalarExtensionRead(ins, state, owned, resultOffset, arch); recognized {
+			return accepted
+		}
+		if accepted, known := x86LoweredCMOVResultStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // The complete source read remains unconditional, regardless of the predicate.
+		}
+		if accepted, recognized := x86LoweredScalarNativeLoad(ins, state, owned, resultOffset, arch); recognized {
+			return accepted
+		}
+		if accepted, recognized := x86LoweredScalarNativeStoreWithAddressBits(ins, state, owned, arch, addressBitStores); recognized {
+			return accepted
+		}
+		if accepted, recognized := x86LoweredScalarMemoryRMW(ins, state, owned, arch); recognized {
+			return accepted
+		}
+		if accepted, known := x86LoweredScalarShiftMemory(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if accepted, known := x86MaskMoveResultStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // The same KMOV emitter retains the complete volatile native width.
+		}
+		if accepted, known := x86LoweredNativeConditionalSet(ins, state, arch); known {
+			return accepted // The same typed SETcc emitter preserves its exact volatile byte write.
+		}
+		if accepted, known := x86LoweredIFMAStep(ins, state, owned, arch); known {
+			return accepted // The typed emitter retains exact guarded qword reads and EVEX upper-zeroing.
+		}
+		if accepted, known := x86ResultQwordLookupStep(ins, state, owned, arch, true); known {
+			return accepted // E4 controls and E4NF qword data retain their separate native access shapes.
+		}
+		if accepted, known := x86LoweredFixedVectorNativeRead(ins, state, owned, arch); known {
+			return accepted // The typed emitter retains full E4NF or guarded E4 native accesses.
+		}
+		if accepted, known := x86ResultSADStep(ins, state, owned, arch, true); known {
+			return accepted // The same SAD emitter retains the full tuple and legacy m128 opcode.
+		}
+		if accepted, known := x86ResultSHAStep(ins, state, owned, arch, true); known {
+			return accepted // Native m128 keeps the original opcode, including dead-result faults.
+		}
+		if accepted, known := x86LoweredAESResultStep(ins, state, owned, arch); known {
+			return accepted // Exact legacy opcodes and vector volatile reads retain the full source tuple.
+		}
+		if accepted, known := x86LoweredVectorTestResultStep(ins, state, owned, arch); known {
+			return accepted // One original memory opcode retains the entire read and captures its FLAGS.
+		}
+		if accepted, known := x86ResultPackedNarrowStep(ins, state, owned, arch, true); known {
+			return accepted // The same emitter retains the complete E4NF tuple or original legacy opcode.
+		}
+		if accepted, known := x86ResultSingleSourceNarrowStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredRawPackedShiftStep(ins, state, owned, arch); known {
+			return accepted // Only the exact sealed shift projects onto the existing typed byte effect.
+		}
+		if accepted, known := x86ResultPackedShiftStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // Uniform m128, E4NF tuples and guarded E4 reads retain their independent shapes.
+		}
+		if accepted, known := x86ResultPackedUnpackStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // Unpack retains the full E4NF tuple even with zero masks or dead results.
+		}
+		if accepted, known := x86ResultDuplicateMoveStep(ins, state, owned, arch, true); known {
+			return accepted // Duplicate selectors retain exact E4NF/E5NF tuples and legacy alignment faults.
+		}
+		if accepted, known := x86ResultVectorArithmeticStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // The same add/sub emitter retains exact E4 reads and inactive-lane suppression.
+		}
+		if accepted, known := x86LoweredPackedIntegerCompareStep(ins, state, owned, arch); known {
+			return accepted // The exact original form shares only the existing vector/K-result and E4 effects.
+		}
+		if accepted, known := x86LoweredImmediatePackedCompareStep(ins, state, owned, arch); known {
+			return accepted // Original raw selectors retain their complete paired E4 input effects.
+		}
+		if accepted, known := x86ResultVectorCompareStepWithRead(ins, state, owned, arch, true); known {
+			return accepted // Complete vector/K-result compares retain their exact native source accesses.
+		}
+		if accepted, known := x86ResultPackedTestMaskStep(ins, state, owned, arch, true); known {
+			return accepted // Only the paired original E4 accesses supply memory-derived K values.
+		}
+		if accepted, known := x86LoweredRawBroadcastStep(ins, state, owned, arch); known {
+			return accepted // Exact raw scalar/block/K-data forms share only their paired typed E6 effects.
+		}
+		if accepted, known := x86LoweredCLMULStep(ins, state, owned, arch); known {
+			return accepted // Original legacy opcode or whole volatile vector tuple retains every native read.
+		}
+		if len(ins.Args) != 0 && ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Sym == "" {
+			if accepted, known := x86ResultBroadcastStepWithRead(ins, state, owned, arch, true); known {
+				return accepted // Only scalar/block native reads need this paired E6 continuation.
+			}
+		}
+		if form, known, err := x86PackedLogicalProperties(ins, arch); known {
+			// Only the paired emitter supplies these conditional native values.
+			// Standalone queries and physical MMX keep their separate contracts.
+			if err != nil || !x86ScalarFPLogicalTransferWithRead(ins, form, state, owned, arch, true) {
+				return false
+			}
+			if extra := shiftBits.definedBytes(ins, form, c.fpShiftLiterals, arch); extra != 0 {
+				destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+				state.writeVector(destination, form.byteWidth, state.vectorBytes(destination)|extra, form.legacy)
+			}
+			return true
+		}
+		if accepted, recognized := x86LoweredScalarArithmeticNativeRead(ins, state, owned, resultOffset, arch); recognized {
+			return accepted
+		}
+		if accepted, known := c.scalarPackedLogicalFPWriteTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := c.scalarPSLogicalFPWriteTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := c.scalarBitTestFPShadowTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86LoweredNativeBitTest(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, recognized := x86ResultScalarLaneStepWithRead(ins, state, owned, resultOffset, arch, true); recognized {
+			return accepted
+		}
+		if form, known, err := x86GPSIMDTransferProperties(ins, arch); known && err == nil && form.memory >= 0 {
+			return x86ResultGPSIMDTransferWithNativeMemory(ins, form, state, owned, resultOffset, arch, true)
+		}
+		if accepted, known := c.scalarCompareNativeResultTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultCompactExpandMemoryStep(ins, state, owned, resultOffset, arch, true); known {
+			return accepted // Same guarded native emitter; public observers keep logical-only memory.
+		}
+		if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known && err == nil &&
+			form.ordinaryMemory(ins, arch) && x86ResultNamedPredicateInstruction(ins) &&
+			(form.memory == 0 && x86ResultIncomingPointerReadAddressIdentity(ins.Args[0], state, arch) ||
+				form.memoryWrite && x86ResultIncomingPointerAddressIdentity(ins.Args[form.memory], state, arch)) {
+			// The emitter preserves the original aligned opcode, or the
+			// unaligned full/guarded tuple with volatile accesses. If it continues,
+			// active bytes are numerical; inactive bytes still require the
+			// typed merge/zero rule. No pointer validity is asserted.
+			return x86ResultPackedVectorMoveTransfer(ins, form, state, owned, resultOffset, arch, true)
+		}
+		form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+		if known && err == nil && form.memoryWrite && x86ResultNamedPredicateInstruction(ins) &&
+			form.destination.Kind == OpMem && form.destination.Mem.Sym == "" &&
+			x86OrdinaryNativeMemoryOperand(form.destination, arch) {
+			// All seven whole128 legacy names retain their exact native
+			// store opcode and its alignment/fault contract. This consumes
+			// numerical source bytes plus an incoming-pointer address only;
+			// no logical storage, validity, extent or later-read fact follows.
+			return x86ResultRead(form.source, 16, state, owned, arch) &&
+				x86ResultIncomingPointerAddressIdentity(form.destination, state, arch)
+		}
+		if accepted, known := x86LoweredLegacyPackedMoveRead(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		next := state.clone()
+		// A reaching-state clone deliberately drops temporary readers.
+		// This isolated attempt is still inside the same lowering transfer.
+		next.loweredStaticReads = state.loweredStaticReads
+		next.goReadOnlyRead = state.goReadOnlyRead
+		if x86ScalarFPResultTransfer(ins, &next, owned, resultOffset, arch) {
+			*state = next
+			return true
+		}
+		if accepted, known := x86ResultUnusedFPAddressStep(ins, state, owned, resultOffset, arch); known {
+			return accepted // Mapped logical storage only; no initialized address bits.
+		}
+		if accepted, known := x86ResultUnknownSBAddressStep(ins, state, arch); known {
+			return accepted // Address calculation only; written address bits stay unknown.
+		}
+		return x86LoweredPureGPUnknownTransfer(ins, state, arch)
+	}
+	if registerEntry {
+		return checkAMD64RegisterResultInitialization(fn, sig, transfer)
+	}
+	if customRegisterBool || logicalScalar {
+		return checkX86LogicalRegisterResultInitialization(fn, sig, arch, transfer, customRegisterBool, true)
+	}
+	vectorEntry := arch == "amd64" && nativeMMX == nil && fn.FrameSize == 0 &&
+		(len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0)
+	if vectorEntry && fn.x86ResultFlowBudget == nil {
+		// Keep the original paired attempt and optional entry fallback in one
+		// accumulated envelope, including callers without an existing owner.
+		fn.x86ResultFlowBudget = new(x86ResultFlowBudget)
+	}
+	if err := checkX86ABI0ResultInitializationWithTrapOnly(fn, sig, arch, transfer, true, false, true); err != nil {
+		if !vectorEntry || !x86OrdinaryScalarCodegenSource(fn, sig, arch) {
+			return err
+		}
+		return c.checkLoweredVectorEntry(fn, sig, arch, transfer, err)
+	}
+	c.nativeMMXRegion = nativeMMX
+	return nil
+}
+
+func (c *amd64Ctx) checkLoweredVectorEntry(fn Func, sig FuncSig, arch string,
+	transfer x86ResultSourceTransfer, strict error) error {
+	if c.usedRegs == nil || c.usedXRegs == nil || c.usedYRegs == nil || c.usedZRegs == nil || c.usedKRegs == nil || len(c.blocks) == 0 {
+		return strict // A standalone audit has no lowering-owned allocation plan.
+	}
+	c.scanUsedRegs()
+	vectors := c.vectorAllocationWidths()
+	if len(vectors) == 0 {
+		return strict
+	}
+	// The same bounded solver and transfer recheck every effect and RET. The
+	// source-graph budget accumulates this fallback; it is never reset. Initial
+	// values come only from actual zeroed vector slots, not the complete bank.
+	err := checkX86ABI0ResultInitializationWithVectorEntry(fn, sig, arch, transfer, true, false, true, vectors)
+	if err != nil {
+		if _, partial := err.(*x86IncompleteResultError); !partial || !x86OrdinaryScalarTupleResultRole(fn, sig, arch) {
+			return err
+		}
+	}
+	return &x86LoweredVectorEntryAuditError{strict}
+}
+
+// Only the lowering observer may consume a paired exact-width volatile load
+// from a typed emitter. Continued execution supplies active numerical source
+// bytes, even if a later selector discards them; masked inactive bytes keep
+// the family's independent merge/zero rule.
+// Family-specific lane/zero/alias effects remain independent. This grants no
+// validity, bounds, write, frame, caller or raw-entry permission.
+func x86ResultReadWithNativeContinuation(ins Instr, source Operand, width int64, state *x86ResultState, owned []bool, arch string, conditionalNativeRead bool) bool {
+	return x86ResultReadWithNativeAddress(ins, source, width, state, owned, arch, conditionalNativeRead, false)
+}
+
+// Scalar GP forms independently normalize named segment syntax. Vector and
+// raw consumers keep their existing continuation and source domains.
+func x86ResultReadWithNativeGPContinuation(ins Instr, source Operand, width int64, state *x86ResultState, owned []bool, arch string) bool {
+	return x86ResultReadWithNativeAddress(ins, source, width, state, owned, arch, true, true)
+}
+
+func x86ResultReadWithNativeAddress(ins Instr, source Operand, width int64, state *x86ResultState, owned []bool, arch string, conditionalNativeRead, segmentRead bool) bool {
+	if x86ResultRead(source, width, state, owned, arch) {
+		return true
+	}
+	if !(conditionalNativeRead && source.Kind == OpMem && source.Mem.Sym == "" &&
+		ins.x86NumericalRead == nil && !ins.x86Encoded && ins.x86SourceRaw == nil && ins.x86RawNearReturn == nil &&
+		ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0 &&
+		x86OrdinaryNativeMemoryOperand(source, arch)) {
+		return false
+	}
+	if segmentRead {
+		if accepted, segment := x86ResultNativeSegmentAddress(ins, source, state, owned, arch); segment {
+			return accepted
+		}
+	}
+	return x86ResultIncomingPointerReadAddressIdentity(source, state, arch) ||
+		x86ResultNativeNumericAddress(source, state, arch)
+}
diff --git a/amd64_scalar_fp_native_read_test.go b/amd64_scalar_fp_native_read_test.go
new file mode 100644
index 000000000..be81c96cb
--- /dev/null
+++ b/amd64_scalar_fp_native_read_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LoweredScalarResultExactNativeRead(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86LegacyMoveNativeOracle {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				var source, declaration strings.Builder
+				for lane := 0; lane < 4; lane++ {
+					name := fmt.Sprintf("view%d", lane)
+					fmt.Fprintf(&declaration, "func %s(p *[16]byte) uint32\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s (AX),X1\nPEXTRD $%d,X1,CX\nMOVL CX,ret+%d(FP)\nRET\n",
+						name, word+4, move, row.name, lane, word)
+				}
+				goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal("exact emitted read did not supply its returned numerical bytes:", err)
+						}
+						if strings.Count(ir, "asm sideeffect \""+row.native+" ($1), $0\"") != 4 {
+							t.Fatal("result proof was not paired with every original native read")
+						}
+						compileLLVMToObject(t, llc, target.triple, "native-result.ll", "native-result.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultDoesNotGrantStandaloneMemoryProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86LegacyMoveNativeOracle {
+			body := fmt.Sprintf("%s p+0(FP),AX\n%s (AX),X1\nPEXTRD $0,X1,CX\nMOVL CX,ret0+%d(FP)\nRET", move, row.name, word)
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *[16]byte) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s/%s declaration-only query acquired native backing: %v", arch, row.name, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86LoweredScalarResultNativePointerPropagation(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move, add, lea := 8, "MOVQ", "ADDQ", "LEAQ"
+		if target.arch == "386" {
+			word, move, add, lea = 4, "MOVL", "ADDL", "LEAL"
+		}
+		for name, body := range map[string]string{
+			"copy":   move + " AX,DX\nMOVOU (DX),X1\n",
+			"offset": add + " $16,AX\nMOVOU (AX),X1\n",
+			"index":  "MOVL $2,CX\nMOVOU 8(AX)(CX*4),X1\n",
+			"lea":    "MOVL $2,CX\n" + lea + " 8(AX)(CX*4),DX\nMOVOU (DX),X1\n",
+			"both paths": "MOVL $1,CX\nCMPL CX,$0\nJE other\n" + move + " AX,DX\nJMP end\nother:\n" +
+				lea + " 16(AX),DX\nend:\nMOVOU (DX),X1\n",
+		} {
+			t.Run(target.triple+"/"+name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s p+0(FP),AX\n%sPEXTRD $2,X1,CX\nMOVL CX,ret+%d(FP)\nRET\n",
+					word+4, move, body, word)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[32]byte) uint32\n", target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(api, err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "native-pointer.ll", "native-pointer.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultNativeReadBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		load := move + " p+0(FP),AX\n"
+		finish := fmt.Sprintf("PEXTRD $0,X1,CX\nMOVL CX,ret+%d(FP)\nRET\n", word)
+		for name, body := range map[string]string{
+			"unknown base":       "MOVOU (DI),X1\n",
+			"numeric base":       "MOVL $42,AX\nMOVOU (AX),X1\n",
+			"lost identity":      load + "MOVL $42,AX\nMOVOU (AX),X1\n",
+			"unknown index":      load + "MOVOU (AX)(DI*1),X1\n",
+			"pointer index":      load + "MOVOU (AX)(AX*1),X1\n",
+			"native store":       load + "MOVOU (AX),X1\nMOVOU X1,(AX)\n",
+			"unknown store data": load + "MOVOU (AX),X1\nMOVOU X0,(AX)\n",
+			"unknown store base": load + "MOVOU (AX),X1\nMOVOU X1,(DI)\n",
+			"unknown lane":       load + "MOVOU (AX),X0\n",
+			"missing path":       load + "MOVL $1,CX\nCMPL CX,$0\nJE done\nMOVOU (AX),X1\ndone:\n",
+			"incoming write":     load + "MOVOU (AX),X1\nMOVL $42,p+0(FP)\n",
+			"unbound static":     "MOVOU ·external(SB),X1\n",
+			"unbound segment":    "MOVOU (FS),X1\n",
+			"mixed pointer join": load + "MOVL $1,CX\nCMPL CX,$0\nJE other\n" + move +
+				" AX,DX\nJMP end\nother:\nMOVL $42,DX\nend:\nMOVOU (DX),X1\n",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n", word+4) + body + finish
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[16]byte) uint32\n", arch, triple, api)
+					if name == "native store" {
+						// Both inputs are now modeled by the complete paired store
+						// consumer. Keep this exact former negative as an object
+						// control, with unknown data/address negatives beside it.
+						if err != nil || ir == "" {
+							t.Fatal("complete paired native store lost its inputs", api, err)
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM22 llc required")
+						}
+						for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							compileLLVMToObject(t, llc, triple, "paired-store.ll", "paired-store.o", text)
+						}
+						continue
+					}
+					if arch == "amd64" && (name == "unknown lane" || name == "unknown store data" || name == "missing path") {
+						x86VectorScratchCodegenControl(t, source, "func view(p *[16]byte) uint32\n", arch, triple, ir, err)
+						accesses := 1
+						if name == "unknown store data" {
+							accesses = 2
+						}
+						if strings.Count(ir, "asm sideeffect \"movdqu ") != accesses || strings.Count(ir, "~{memory}") < accesses {
+							t.Fatal("scratch choice lost the original m128 MOVOU accesses", api)
+						}
+						continue
+					}
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s borrowed native/result authority: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredScalarResultRawOriginCannotBorrowConditionalRead(t *testing.T) {
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[16]byte) uint32",
+		"MOVQ p+0(FP),AX\nMOVOU (AX),X1\nPEXTRD $0,X1,CX\nMOVL CX,ret0+8(FP)\nRET")
+	for _, change := range []string{"decoded", "address size", "unknown address size", "raw TEXT", "source stack", "fixed local"} {
+		t.Run(change, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			switch change {
+			case "decoded":
+				fn.Instrs[2].x86Encoded = true
+			case "address size":
+				fn.Instrs[2].x86AddressBits = 32
+			case "unknown address size":
+				fn.Instrs[2].x86UnboundAddressOverride = true
+			case "raw TEXT":
+				fn.X86RawText = []byte{0xc3}
+			case "source stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			}
+			ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+			if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved raw entry acquired ordinary conditional effect: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_fp_pure_gp.go b/amd64_scalar_fp_pure_gp.go
new file mode 100644
index 000000000..eefd67de1
--- /dev/null
+++ b/amd64_scalar_fp_pure_gp.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+// x86LoweredPureGPUnknownTransfer is a lowering-only availability fallback for
+// a closed set of nontrapping, register/immediate GP operations. Unavailable
+// scratch inputs are not initialized: their dependent outputs stay unknown.
+// A later result, address, store or control use must pass the ordinary check.
+//
+// The caller first tries ordinary transfer on a separate state clone and uses
+// this function only after failure. No partially mutated failed state may be
+// supplied. The public/declaration-only checker deliberately has no fallback.
+func x86LoweredPureGPUnknownTransfer(ins Instr, state *x86ResultState, arch string) bool {
+	if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg && operand.Kind != OpImm ||
+			operand.Kind == OpImm && (operand.ImmRaw != "" || operand.ImmIsFloat) {
+			return false
+		}
+	}
+	if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known {
+		if err != nil || !form.test || form.memory >= 0 {
+			return false
+		}
+		unknown := false
+		for _, operand := range form.args {
+			if operand.Kind == OpImm {
+				continue
+			}
+			index, mask, valid := x86ResultGP(operand.Reg, int64(form.bits/8), arch)
+			if operand.Kind != OpReg || !valid || state.pointerGP[index] {
+				return false
+			}
+			unknown = unknown || state.gp[index]&mask != mask
+		}
+		if !unknown {
+			return false // Preserve the ordinary fully numerical transfer.
+		}
+		// The paired TEST emitter always clears CF/OF, independently of
+		// its scratch bits. ZF/SF/PF still depend on those bits, AF is
+		// undefined, and no numerical register/pointer fact is produced.
+		// Memory is excluded: its faulting read must never be skipped.
+		state.flags = x86ByteFlagCF | x86ByteFlagOF
+		return true
+	}
+
+	// Keep the nontrapping domain explicit. Future additions to the general
+	// effect directory (e.g. division or a native effect) cannot opt in merely
+	// by describing their byte inputs and outputs.
+	shift, isShift, shiftErr := x86ScalarShiftProperties(ins.Op, ins, arch)
+	extension, isExtension, extensionErr := x86ScalarExtensionProperties(ins.Op, ins, arch)
+	rmw, isRMW, rmwErr := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	_, isIMUL, imulErr := x86ExplicitIMULProperties(ins.Op, ins, arch)
+	_, isCMOV, cmovErr := x86ConditionalMoveProperties(ins.Op, ins, arch)
+	if !isShift && !isExtension && !isRMW && !isIMUL && !isCMOV ||
+		shiftErr != nil || extensionErr != nil || rmwErr != nil || imulErr != nil || cmovErr != nil {
+		return false
+	}
+	effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+	if !known || err != nil || effect.dynamicMemory {
+		return false
+	}
+
+	unknown := state.flags&effect.flagsRead != effect.flagsRead
+	for _, operand := range effect.operands {
+		if operand.operand.Kind == OpImm && !operand.write {
+			continue
+		}
+		if operand.operand.Kind != OpReg {
+			return false
+		}
+		index, mask, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+		if !valid || operand.read && state.pointerGP[index] {
+			return false // An opaque incoming pointer is never a numerical input.
+		}
+		if operand.read && state.gp[index]&mask != mask {
+			unknown = true
+		}
+	}
+	if !unknown {
+		return false // Do not turn some other strict failure into success.
+	}
+
+	before := state.gp
+	for _, operand := range effect.operands {
+		if !operand.write {
+			continue
+		}
+		index, mask, _ := x86ResultGP(operand.operand.Reg, operand.width, arch)
+		defined := uint8(0)
+		if isExtension {
+			defined = x86LoweredExtensionKnownBytes(extension, before, arch)
+		} else if isShift && !shift.bmi2 && shift.count.Kind == OpImm && shift.maskedCount() == 0 {
+			defined = before[index] & mask // Group2 count0 leaves its low bytes unchanged.
+		} else if isRMW {
+			defined = x86LoweredRMWKnownBytes(rmw.spec, effect, before, state.flags, arch)
+			// The dependency directory uses low-relative bytes. The actual
+			// typed operand still owns high-byte aliases such as AH/DH.
+			for view := mask; view&1 == 0; view >>= 1 {
+				defined <<= 1
+			}
+		}
+		state.gp[index] = before[index]&^mask | defined
+		if operand.width == 4 {
+			state.gp[index] |= 0xf0 // Architectural dword write clears upper32.
+		}
+		state.pointerGP[index] = false
+	}
+	flagsWritten := effect.flagsDefined | effect.flagsKilled
+	if isShift && !shift.bmi2 && shift.count.Kind == OpReg {
+		// flagsDefined means unconditionally initialized, not every possible
+		// write. In particular variable count0 can preserve old flags, while
+		// a nonzero count computes new flags from the unknown data/count.
+		flagsWritten = x86ByteFlagsAll
+		switch shift.stem {
+		case "RCL", "RCR", "ROL", "ROR":
+			flagsWritten = x86ByteFlagCF | x86ByteFlagOF
+		}
+	}
+	state.flags &^= flagsWritten
+	return true
+}
+
+func x86LoweredRMWKnownBytes(spec x86LockScalarRMWSpec, effect x86TypedByteEffect, before [16]uint8,
+	flags uint8, arch string) uint8 {
+	inputs := uint8(0xff)
+	for _, operand := range effect.operands {
+		if !operand.read || operand.operand.Kind == OpImm {
+			continue
+		}
+		root, mask, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+		if !valid {
+			return 0
+		}
+		known := before[root] & mask
+		for mask&1 == 0 {
+			known >>= 1
+			mask >>= 1
+		}
+		inputs &= known
+	}
+	var result uint8
+	for output := 0; output < spec.bits/8; output++ {
+		mask, carry := spec.numericalByteInputs(output)
+		if mask != 0 && inputs&mask == mask && (!carry || flags&x86ByteFlagCF != 0) {
+			result |= 1 << uint(output)
+		}
+	}
+	return result
+}
+
+// Extensions copy individual source bytes. Zero fill is independent of every
+// source bit; sign fill depends only on the source's most significant byte.
+func x86LoweredExtensionKnownBytes(form x86ScalarExtensionForm, before [16]uint8, arch string) uint8 {
+	sourceWidth := int64(form.spec.sourceBits / 8)
+	index, mask, _ := x86ResultGP(form.source.Reg, sourceWidth, arch)
+	input := before[index] & mask
+	for mask&1 == 0 {
+		mask >>= 1
+		input >>= 1
+	}
+	known := input
+	if !form.spec.signed || input&(1<<uint(sourceWidth-1)) != 0 {
+		for b := sourceWidth; b < int64(form.spec.destinationBits/8); b++ {
+			known |= 1 << uint(b)
+		}
+	}
+	return known
+}
diff --git a/amd64_scalar_fp_pure_gp_extract_test.go b/amd64_scalar_fp_pure_gp_extract_test.go
new file mode 100644
index 000000000..6d88df773
--- /dev/null
+++ b/amd64_scalar_fp_pure_gp_extract_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// PEXTRD deliberately activates the lowering-only result observer. An ordinary
+// GP return alone does not establish that this callback was actually invoked.
+func TestX86LoweredPureGPUnknownPEXTRDExactScratchUpdate(t *testing.T) {
+	for _, overwrite := range []bool{false, true} {
+		tail := ""
+		if overwrite {
+			tail = "MOVQ $0,DI\nCMPL AX,AX\n"
+		}
+		source := `TEXT ·view(SB),4,$0-4
+VPXORQ Z1,Z1,Z1
+ADDQ $64,DI
+VPTERNLOGD $255,Z0,Z0,Z1
+PEXTRD $0,X1,AX
+` + tail + `MOVL AX,ret+0(FP)
+RET
+`
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Fatalf("independent result lost after unobserved ADDQ: overwrite=%t API=%s: %v", overwrite, api, err)
+			}
+		}
+	}
+	// Keep the declaration-only query strict. It must not inherit a private
+	// lowering fallback simply because the emitted LLVM counterpart is safe.
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint32",
+		"ADDQ $64,DI\nMOVL $37,AX\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret0+0(FP)\nRET")
+	for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+		err := check(file.Funcs[0], sig, "amd64")
+		if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "ADDQ $64,DI") {
+			t.Fatal("unpaired observer acquired lowering-only permission", err)
+		}
+	}
+}
+
+func TestX86LoweredPureGPUnknownPEXTRDCompleteExistingFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		for index, row := range x86PureGPUnknownCases(target.arch) {
+			fmt.Fprintf(&declarations, "func pureExtract%d() uint32\n", index)
+			fmt.Fprintf(&source, "TEXT ·pureExtract%d(SB),4,$0-4\nMOVL $1,AX\nCMPL AX,AX\n%s\nMOVL $37,AX\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n", index, row.body)
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal(target.triple, api, err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "pure-extract.ll", "pure-extract.o", ir)
+		}
+	}
+}
+
+func TestX86LoweredPureGPUnknownPEXTRDObservableBoundaries(t *testing.T) {
+	for _, body := range []string{
+		"MOVL DI,X0",
+		"MOVL DI,ret+0(FP)",
+		"MOVL (DI),AX",
+		"MOVL DI,(AX)",
+		"JE finish\nfinish:",
+		"SETCS ret+0(FP)",
+	} {
+		source := "TEXT ·view(SB),4,$0-4\nMOVL $37,AX\nMOVL AX,X0\nADDQ $64,DI\n" + body + "\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("observable unknown value or flags accepted", body, api, err)
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_fp_pure_gp_runtime_linux_amd64_test.go b/amd64_scalar_fp_pure_gp_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..4ff782229
--- /dev/null
+++ b/amd64_scalar_fp_pure_gp_runtime_linux_amd64_test.go
@@ -0,0 +1,11 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import "testing"
+
+// Rosetta does not advertise BMI2. This separate mandatory native owner must
+// execute all eight BMI2 witnesses; an absent ISA/tool is a failure, not a skip.
+func TestCrossLinuxRuntimeMatrixX86PureGPUnknownBMI2DeadOutputs(t *testing.T) {
+	x86PureGPUnknownRuntime(t, true)
+}
diff --git a/amd64_scalar_fp_pure_gp_runtime_test.go b/amd64_scalar_fp_pure_gp_runtime_test.go
new file mode 100644
index 000000000..bcbe65ff7
--- /dev/null
+++ b/amd64_scalar_fp_pure_gp_runtime_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PureGPUnknownDeadOutputs(t *testing.T) {
+	x86PureGPUnknownRuntime(t, false)
+}
+
+func x86PureGPUnknownRuntime(t *testing.T, bmi2 bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declaration, prototypes, originals, pairs strings.Builder
+	var cases []x86PureGPUnknownCase
+	for _, row := range x86PureGPUnknownCases("amd64") {
+		isBMI2 := strings.HasPrefix(row.body, "SARX") || strings.HasPrefix(row.body, "SHLX") ||
+			strings.HasPrefix(row.body, "SHRX") || strings.HasPrefix(row.body, "RORX")
+		if isBMI2 == bmi2 {
+			cases = append(cases, row)
+		}
+	}
+	for index, row := range cases {
+		name, original := fmt.Sprintf("view%d", index), fmt.Sprintf("original%d", index)
+		// seed is deliberately not imported into LLVM scratch registers. The
+		// original Go byte oracle supplies several possible physical values;
+		// neither program's observable result may depend on those values.
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-20\nMOVL $1,AX\nCMPL AX,AX\n%s\nMOVSS x+0(FP),X0\nMOVSS X0,ret+16(FP)\nRET\n", name, row.body)
+		fmt.Fprintf(&declaration, "func %s(x,seed uint64) uint32\n", name)
+		actual := x86PackedShiftActualGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\nPUSHQ BX\nMOVQ SI,BX\nMOVQ SI,CX\nMOVQ SI,DX\nMOVL $1,AX\nCMPL AX,AX\n"+row.body+"\nMOVL DI,AX\nPOPQ BX\nRET\n")
+		if len(actual) < 20 || actual[len(actual)-1] != 0xc3 {
+			t.Fatal("incomplete original Go byte program", row.body, actual)
+		}
+		var bytes []string
+		for _, b := range actual {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+		}
+		symbol := original
+		if strings.Contains(execution.triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern uint32_t %s(uint64_t,uint64_t);\n", name)
+		prototypes.WriteString(x86OriginalSysVDeclaration("uint32_t", original, "uint64_t,uint64_t"))
+		fmt.Fprintf(&pairs, "{%s,%s},\n", name, original)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	requireBMI2 := 0
+	if bmi2 {
+		requireBMI2 = 1
+	}
+	main := fmt.Sprintf("#define REQUIRE_BMI2 %d\n", requireBMI2) + `
+#include <stdint.h>
+#include <stdio.h>
+#include <xmmintrin.h>
+` + prototypes.String() + originals.String() + x86OriginalSysVPointer("uint32_t", "original_program", "uint64_t,uint64_t") + `
+typedef uint32_t (*program)(uint64_t,uint64_t);
+struct pair { program translated; original_program original; };
+static const struct pair pairs[]={
+` + pairs.String() + `};
+int main(void) {
+    __builtin_cpu_init();
+    if(REQUIRE_BMI2 && !__builtin_cpu_supports("bmi2")) {
+        fprintf(stderr,"original Go BMI2 oracle requires BMI2 execution\n");
+        return 2;
+    }
+    const uint64_t seeds[]={0,1,15,31,32,63,64,255,UINT64_MAX,
+        UINT64_C(0x0123456789abcdef),UINT64_C(0x8000000000000000)};
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(unsigned s=0;s<sizeof(seeds)/sizeof(*seeds);++s) {
+            for(unsigned n=0;n<17;++n) {
+                uint64_t x=UINT64_C(0x9e3779b97f4a7c15)*n;
+                uint32_t saved=_mm_getcsr(),csr=0x1f80|((n%4)<<13);
+                _mm_setcsr(csr);
+                uint32_t a=pairs[i].original(x,seeds[s]);
+                uint32_t b=pairs[i].translated(x,seeds[s]);
+                uint32_t after=_mm_getcsr();
+                _mm_setcsr(saved);
+                if(a!=(uint32_t)x || b!=a || after!=csr) {
+                    fprintf(stderr,"kernel=%u seed=%u pattern=%u original=%x llvm=%x want=%x\n",
+                        i,s,n,a,b,(uint32_t)x);
+                    return 1;
+                }
+            }
+        }
+    }
+    printf("%zu pure GP programs x 11 seeds x 17 observable patterns\n",sizeof(pairs)/sizeof(*pairs));
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					out := execution.compileAndRunLLVM(t, "pure-gp-unknown", pipeline.ir, main, pipeline.level)
+					want := fmt.Sprintf("%d pure GP programs x 11 seeds x 17 observable patterns\n", len(cases))
+					if string(out) != want {
+						t.Fatalf("unexpected original/LLVM receipt: %q", out)
+					}
+					t.Log(strings.TrimSpace(string(out)))
+				})
+			}
+		})
+	}
+	t.Logf("original Go opcode/LLVM numerical observations; transport=%s/%s, not a foreign native-ABI certificate", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/amd64_scalar_fp_pure_gp_test.go b/amd64_scalar_fp_pure_gp_test.go
new file mode 100644
index 000000000..f935a0a6f
--- /dev/null
+++ b/amd64_scalar_fp_pure_gp_test.go
@@ -0,0 +1,392 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86PureGPUnknownCase struct {
+	body     string
+	width    int64
+	flags    uint8
+	zeroFrom int64
+}
+
+// Independent closed family inventory: no production opcode/spec iteration.
+func x86PureGPUnknownCases(arch string) []x86PureGPUnknownCase {
+	var cases []x86PureGPUnknownCase
+	add := func(body string, width int64, flags uint8) {
+		cases = append(cases, x86PureGPUnknownCase{body: body, width: width, flags: flags})
+	}
+	for _, width := range []struct {
+		suffix string
+		bytes  int64
+	}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+		if arch == "386" && width.bytes == 8 {
+			continue
+		}
+		for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR", "INC", "DEC", "NEG", "NOT", "BTC", "BTR", "BTS"} {
+			if width.bytes == 1 && strings.HasPrefix(stem, "BT") {
+				continue
+			}
+			flags := uint8(x86ByteFlagsAll)
+			if stem == "INC" || stem == "DEC" {
+				flags &^= x86ByteFlagCF
+			}
+			if stem == "NOT" {
+				flags = 0
+			}
+			if strings.HasPrefix(stem, "BT") {
+				flags &^= x86ByteFlagZF
+			}
+			if stem == "INC" || stem == "DEC" || stem == "NEG" || stem == "NOT" {
+				add(stem+width.suffix+" DX", width.bytes, flags)
+			} else {
+				for _, source := range []string{"BX", "$7"} {
+					add(stem+width.suffix+" "+source+",DX", width.bytes, flags)
+				}
+			}
+		}
+		for _, stem := range []string{"RCL", "RCR", "ROL", "ROR", "SHL", "SHR", "SAR"} {
+			flags := uint8(x86ByteFlagsAll)
+			if strings.HasPrefix(stem, "R") {
+				flags = x86ByteFlagCF | x86ByteFlagOF
+			}
+			for _, count := range []string{"$1", "CX"} {
+				add(stem+width.suffix+" "+count+",DX", width.bytes, flags)
+			}
+		}
+		if width.bytes == 1 {
+			continue
+		}
+		for _, stem := range []string{"SHL", "SHR"} {
+			add(stem+width.suffix+" $1,BX,DX", width.bytes, x86ByteFlagsAll)
+			if width.bytes > 2 {
+				add(stem+width.suffix+" CX,BX,DX", width.bytes, x86ByteFlagsAll)
+			}
+		}
+		for _, operands := range []string{"BX,DX", "$7,DX"} {
+			add("IMUL"+width.suffix+" "+operands, width.bytes, x86ByteFlagsAll)
+		}
+		add("IMUL3"+width.suffix+" $7,BX,DX", width.bytes, x86ByteFlagsAll)
+		for _, condition := range []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"} {
+			add("CMOV"+width.suffix+condition+" BX,DX", width.bytes, 0)
+		}
+	}
+	for _, suffix := range []string{"L", "Q"} {
+		width := int64(4)
+		if suffix == "Q" && arch == "amd64" {
+			width = 8
+		}
+		for _, stem := range []string{"SARX", "SHLX", "SHRX"} {
+			add(stem+suffix+" CX,BX,DX", width, 0)
+		}
+		add("RORX"+suffix+" $1,BX,DX", width, 0)
+	}
+	for _, extension := range []struct {
+		op           string
+		source, dest int64
+		zero         bool
+		mode64       bool
+	}{
+		{"MOVBWSX", 1, 2, false, false}, {"MOVBWZX", 1, 2, true, false},
+		{"MOVBLSX", 1, 4, false, false}, {"MOVBLZX", 1, 4, true, false},
+		{"MOVBQSX", 1, 8, false, true}, {"MOVBQZX", 1, 8, true, true},
+		{"MOVWLSX", 2, 4, false, false}, {"MOVWLZX", 2, 4, true, false},
+		{"MOVWQSX", 2, 8, false, true}, {"MOVWQZX", 2, 8, true, true},
+		{"MOVLQSX", 4, 8, false, true}, {"MOVLQZX", 4, 8, true, false},
+		{"MOVSWW", 2, 2, false, false}, {"MOVZWW", 2, 2, true, false},
+	} {
+		if arch == "386" && extension.mode64 {
+			continue
+		}
+		if arch == "386" && extension.op == "MOVLQZX" {
+			extension.dest = 4
+		}
+		add(extension.op+" BX,DX", extension.dest, 0)
+		if extension.zero {
+			cases[len(cases)-1].zeroFrom = extension.source
+		}
+	}
+	return cases
+}
+
+func x86PureGPUnknownInstruction(t *testing.T, body string) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86LoweredPureGPUnknownCompleteFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86PureGPUnknownCases(arch) {
+			t.Run(arch+"/"+row.body, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, row.body)
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.gp[0] = 0xff
+				before := state.clone()
+				strict := state.clone()
+				if x86ScalarFPResultTransfer(ins, &strict, nil, 0, arch) {
+					t.Fatal("strict transfer unexpectedly accepts undefined input")
+				}
+				if !x86LoweredPureGPUnknownTransfer(ins, &state, arch) {
+					t.Fatal("pure GP unknown value prevented an independent result")
+				}
+				want := uint8(0)
+				if row.width == 4 {
+					want = 0xf0
+				}
+				if row.zeroFrom > 0 {
+					for b := row.zeroFrom; b < row.width; b++ {
+						want |= 1 << uint(b)
+					}
+				}
+				before.gp[2], before.flags = want, x86ByteFlagsAll&^row.flags
+				if !reflect.DeepEqual(state, before) {
+					t.Fatalf("availability differs: got GP=%x flags=%x, want GP=%x flags=%x", state.gp, state.flags, before.gp, before.flags)
+				}
+			})
+		}
+	}
+}
+
+func x86PureGPUnknownTransferForTest(ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+	next := state.clone()
+	if x86ScalarFPResultTransfer(ins, &next, owned, offset, arch) {
+		*state = next
+		return true
+	}
+	return x86LoweredPureGPUnknownTransfer(ins, state, arch)
+}
+
+func TestX86LoweredPureGPUnknownObservableBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for name, tail := range map[string]string{
+			"dead":               "MOVL $37,AX\nMOVL AX,ret0+0(FP)\nRET",
+			"result":             "MOVL DX,ret0+0(FP)\nRET",
+			"branch":             "JE other\nMOVL $1,AX\nJMP done\nother:\nMOVL $2,AX\ndone:\nMOVL AX,ret0+0(FP)\nRET",
+			"address":            "MOVL (DX),AX\nMOVL AX,ret0+0(FP)\nRET",
+			"store":              "MOVL DX,(AX)\nMOVL $37,ret0+0(FP)\nRET",
+			"scalar SIMD result": "MOVL DX,X0\nMOVSS X0,ret0+0(FP)\nRET",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32", "ADDL $64,DX\n"+tail)
+				check := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+					return x86PureGPUnknownTransferForTest(ins, state, owned, offset, arch)
+				}
+				err := checkX86ABI0ResultInitializationAtSource(file.Funcs[0], sig, arch, check, true)
+				if name == "dead" {
+					if err != nil {
+						t.Fatal(err)
+					}
+				} else if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("observable undefined input accepted: %v", err)
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("public checker changed: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredPureGPUnknownRejectsOtherEffects(t *testing.T) {
+	for _, body := range []string{"DIVL BX", "IDIVL BX", "IMULL BX", "MULL BX", "MOVL BX,DX", "ADDL (BX),DX", "ADDL x+0(FP),DX", "ADDL BX,(DX)", "ADDL $1,SP", "ADDL $1,BP", "ADDSS X0,X1", "PAND X0,X1", "CALL ·other(SB)", "ADDL $MISSING,DX", "ADDL $1.0,DX", "SHLW CX,BX,DX"} {
+		t.Run(body, func(t *testing.T) {
+			state := x86ResultState{}
+			before := state.clone()
+			if x86LoweredPureGPUnknownTransfer(x86PureGPUnknownInstruction(t, body), &state, "amd64") {
+				t.Fatal("non-pure/unsupported effect acquired fallback")
+			}
+			if !reflect.DeepEqual(state, before) {
+				t.Fatal("rejected effect mutated availability")
+			}
+		})
+	}
+}
+
+func TestX86LoweredPureGPUnknownPartialBytesFlagsAndPointers(t *testing.T) {
+	for _, row := range []struct {
+		body                     string
+		bx, dx, cx               uint8
+		flags, wantDX, wantFlags uint8
+	}{
+		{"ADDB BL,DH", 0xfe, 0xff, 0xff, x86ByteFlagsAll, 0xfd, 0},
+		{"ADDW BX,DX", 0xfd, 0xff, 0xff, x86ByteFlagsAll, 0xfd, 0},
+		{"ADDL BX,DX", 0xfe, 0xff, 0xff, x86ByteFlagsAll, 0xf0, 0},
+		{"ADDQ BX,DX", 0x7f, 0xff, 0xff, x86ByteFlagsAll, 0x7f, 0},
+		{"INCW DX", 0xff, 0xfd, 0xff, x86ByteFlagsAll, 0xfd, x86ByteFlagCF},
+		{"NOTW DX", 0xff, 0xfd, 0xff, x86ByteFlagsAll, 0xfd, x86ByteFlagsAll},
+		{"SHLL $0,DX", 0xff, 0xfd, 0xff, x86ByteFlagsAll, 0xfd, x86ByteFlagsAll},
+		{"BTSL BX,DX", 0xfe, 0xff, 0xff, x86ByteFlagsAll, 0xf0, x86ByteFlagZF},
+		{"SHLL CX,DX", 0xff, 0xff, 0xfe, x86ByteFlagsAll, 0xf0, 0},
+		{"ROLL CX,DX", 0xff, 0xff, 0xfe, x86ByteFlagsAll, 0xf0, x86ByteFlagsAll &^ (x86ByteFlagCF | x86ByteFlagOF)},
+		{"SHLXL CX,BX,DX", 0xff, 0xff, 0xfe, x86ByteFlagsAll, 0xf0, x86ByteFlagsAll},
+		{"ADCL $7,DX", 0xff, 0xff, 0xff, x86ByteFlagsAll &^ x86ByteFlagCF, 0xf0, 0},
+		{"CMOVLEQ BX,DX", 0xff, 0xff, 0xff, x86ByteFlagsAll &^ x86ByteFlagZF, 0xf0, x86ByteFlagsAll &^ x86ByteFlagZF},
+		{"MOVBLZX BH,DX", 0xfd, 0xff, 0xff, x86ByteFlagsAll, 0xfe, x86ByteFlagsAll},
+		{"MOVWQZX BX,DX", 0xfd, 0xff, 0xff, x86ByteFlagsAll, 0xfd, x86ByteFlagsAll},
+		{"MOVWQSX BX,DX", 0xfd, 0xff, 0xff, x86ByteFlagsAll, 0x01, x86ByteFlagsAll},
+		{"MOVWQSX BX,DX", 0xfe, 0xff, 0xff, x86ByteFlagsAll, 0xfe, x86ByteFlagsAll},
+	} {
+		t.Run(row.body, func(t *testing.T) {
+			state := x86ResultState{flags: row.flags}
+			state.gp[1], state.gp[2], state.gp[3] = row.cx, row.dx, row.bx
+			before := state.clone()
+			if !x86LoweredPureGPUnknownTransfer(x86PureGPUnknownInstruction(t, row.body), &state, "amd64") {
+				t.Fatal("unknown dependency was rejected")
+			}
+			before.gp[2], before.flags = row.wantDX, row.wantFlags
+			if !reflect.DeepEqual(state, before) {
+				t.Fatalf("got GP=%x flags=%x; want GP=%x flags=%x", state.gp, state.flags, before.gp, before.flags)
+			}
+		})
+	}
+	for _, body := range []string{"ADDL BX,DX", "MOVWQZX BX,DX", "CMOVLEQ BX,DX", "SHLXL CX,BX,DX"} {
+		for _, pointer := range []int{2, 3} {
+			ins := x86PureGPUnknownInstruction(t, body)
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.pointerGP[pointer] = true
+			before := state.clone()
+			accepted := x86LoweredPureGPUnknownTransfer(ins, &state, "amd64")
+			writeOnly := pointer == 2 && (strings.HasPrefix(body, "MOV") || strings.HasPrefix(body, "SHLX"))
+			if accepted != writeOnly {
+				t.Fatalf("%s pointer%d accepted=%t", body, pointer, accepted)
+			}
+			if !accepted && !reflect.DeepEqual(state, before) {
+				t.Fatal("rejected pointer changed state")
+			}
+			if accepted && state.pointerGP[pointer] {
+				t.Fatal("written pointer identity survived")
+			}
+		}
+	}
+	for _, mutation := range []string{"known", "raw", "origin", "address", "segment", "foreign"} {
+		ins := x86PureGPUnknownInstruction(t, "ADDL BX,DX")
+		state, arch := x86ResultState{}, "amd64"
+		switch mutation {
+		case "known":
+			state.gp[2], state.gp[3] = 0xff, 0xff
+		case "raw":
+			ins.x86Encoded = true
+		case "origin":
+			ins.x86SourceRaw = &x86SourceRawInstruction{}
+		case "address":
+			ins.x86AddressBits = 32
+		case "segment":
+			ins.x86SegmentPrefix = 0x64
+		case "foreign":
+			arch = "arm64"
+		}
+		before := state.clone()
+		if x86LoweredPureGPUnknownTransfer(ins, &state, arch) || !reflect.DeepEqual(state, before) {
+			t.Fatal("invalid fallback", mutation)
+		}
+	}
+}
+
+func TestX86LoweredPureGPUnknownOriginalGoAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for i, row := range x86PureGPUnknownCases(target.arch) {
+				name := fmt.Sprintf("view%d", i)
+				// A scalar FP bit view activates the actual lowering-only result
+				// check, while the dead GP computation remains unobservable.
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVL $1,AX\nCMPL AX,AX\n%s\nMOVSS x+0(FP),X0\nMOVSS X0,ret+8(FP)\nRET\n", name, row.body)
+				fmt.Fprintf(&declarations, "func %s(x uint64) uint32\n", name)
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "pure-gp.ll", "pure-gp.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86LoweredPureGPUnknownRequiredBytesAndFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86PureGPUnknownCases(arch) {
+			ins := x86PureGPUnknownInstruction(t, row.body)
+			effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+			if !known || err != nil {
+				t.Fatal(row.body, known, err)
+			}
+			complete := x86ResultState{flags: x86ByteFlagsAll}
+			for index := range complete.gp {
+				complete.gp[index] = 0xff
+			}
+			for _, operand := range effect.operands {
+				if !operand.read || operand.operand.Kind != OpReg {
+					continue
+				}
+				index, mask, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+				if !valid {
+					t.Fatal("invalid typed GP role", row.body, operand)
+				}
+				for bit := uint8(1); bit != 0; bit <<= 1 {
+					if mask&bit == 0 {
+						continue
+					}
+					state := complete.clone()
+					state.gp[index] &^= bit
+					strict := state.clone()
+					if x86ScalarFPResultTransfer(ins, &strict, nil, 0, arch) ||
+						!x86LoweredPureGPUnknownTransfer(ins, &state, arch) {
+						t.Fatalf("%s/%s missing register%d byte%x did not propagate", arch, row.body, index, bit)
+					}
+					if state.gp[2] == 0xff {
+						t.Fatalf("%s/%s unknown input became a fully initialized result", arch, row.body)
+					}
+				}
+			}
+			for flag := uint8(1); flag <= x86ByteFlagOF; flag <<= 1 {
+				if effect.flagsRead&flag == 0 {
+					continue
+				}
+				state := complete.clone()
+				state.flags &^= flag
+				if !x86LoweredPureGPUnknownTransfer(ins, &state, arch) || state.gp[2] == 0xff {
+					t.Fatalf("%s/%s unknown flag%x did not propagate", arch, row.body, flag)
+				}
+			}
+		}
+	}
+}
+
+func TestX86LoweredPureGPUnknownObservableThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for name, body := range map[string]string{
+			"branch":  "JE done\nMOVL $1,AX\ndone:",
+			"address": "MOVL (DX),AX",
+			"store":   "MOVL DX,(AX)",
+			"result":  "MOVL DX,X0",
+		} {
+			t.Run(target.triple+"/"+name, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-12\nMOVSS x+0(FP),X0\nADDL $64,DX\n" + body + "\nMOVSS X0,ret+8(FP)\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view(x uint64) uint32\n", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s observable unknown bits accepted: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_fp_span_test.go b/amd64_scalar_fp_span_test.go
new file mode 100644
index 000000000..060c62629
--- /dev/null
+++ b/amd64_scalar_fp_span_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarFPBitViewsEveryLogicalByteAndBoundary(t *testing.T) {
+	for _, bits := range []int{32, 64} {
+		for missing := -1; missing < bits/8; missing++ {
+			var slots []FrameSlot
+			for offset := 0; offset < bits/8; offset++ {
+				if offset != missing {
+					slots = append(slots, FrameSlot{Offset: int64(offset), Type: I8, Index: offset, Field: -1})
+				}
+			}
+			for _, masked := range []bool{false, true} {
+				for _, write := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%d/missing%d/mask%t/write%t", bits, missing, masked, write), func(t *testing.T) {
+						var ir strings.Builder
+						ctx := newAMD64Ctx(&ir, Func{}, FuncSig{Frame: FrameLayout{Params: slots}}, nil, nil, false)
+						if _, err := ctx.scalarFPSpan(0, bits); (err == nil) != (missing == -1) {
+							t.Fatalf("byte span result: %v", err)
+						}
+						if missing == -1 {
+							return // Positive actual loads/stores are covered by objects and runtime.
+						}
+						var err error
+						operand := Operand{Kind: OpFP}
+						if write {
+							mask := ""
+							if masked {
+								mask = "0"
+							}
+							err = ctx.storeVectorScalarMemory(operand, bits, "1", mask)
+						} else if masked {
+							_, err = ctx.loadX86ScalarMemoryIf(operand, bits, "false")
+						} else {
+							_, err = ctx.loadScalarFPBits(0, bits)
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || ir.Len() != 0 {
+							t.Fatalf("missing byte granted scalar access/IR: %v\n%s", err, ir.String())
+						}
+					})
+				}
+			}
+		}
+	}
+	for name, slots := range map[string][]FrameSlot{
+		"pointer":  {{Type: Ptr, Field: -1}},
+		"bool":     {{Type: I1, Field: -1}, {Offset: 1, Type: I32, Index: 1, Field: -1}},
+		"overlap":  {{Type: I64, Field: -1}, {Offset: 2, Type: I32, Index: 1, Field: -1}},
+		"overflow": {{Offset: math.MaxInt64 - 1, Type: I64, Field: -1}},
+		"negative": {{Offset: -1, Type: I64, Field: -1}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var ir strings.Builder
+			ctx := newAMD64Ctx(&ir, Func{}, FuncSig{Frame: FrameLayout{Params: slots}}, nil, nil, false)
+			if _, err := ctx.loadScalarFPBits(0, 32); !errors.Is(err, ErrProbeNeedsContext) || ir.Len() != 0 {
+				t.Fatalf("unbound layout accepted: %v\n%s", err, ir.String())
+			}
+		})
+	}
+}
+
+func TestX86ScalarFPBitViewsResultReadsNeedAllPathInitialization(t *testing.T) {
+	for name, body := range map[string]string{
+		"entry read":        "MOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)",
+		"partial source":    "MOVB $1,AX\nMOVL AX,ret+8(FP)\nMOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)",
+		"partial result":    "MOVW $1,ret+8(FP)\nMOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)",
+		"missing branch":    "MOVL $1,AX\nCMPL AX,$0\nJE joined\nMOVL $1,ret+8(FP)\njoined:\nMOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)",
+		"unknown call":      "MOVL $1,ret+8(FP)\nCALL ·other(SB)\nMOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)",
+		"loop entry read":   "MOVL $1,AX\nloop:\nMOVSS ret+8(FP),X0\nMOVSS X0,ret+8(FP)\nSUBL $1,AX\nJNE loop",
+		"undefined mask":    "MOVL $1,ret+8(FP)\nVMOVSS ret+8(FP),K1,X0\nMOVSS X0,ret+8(FP)",
+		"masked only write": "MOVL $0,AX\nKMOVD AX,K1\nMOVSS x+0(FP),X0\nVMOVSS X0,K1,ret+8(FP)",
+	} {
+		for _, target := range x86RawReturnTargets {
+			t.Run(name+"/"+target.triple, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-12\n" + body + "\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(x uint64) uint32", target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("%s undefined result became numeric: %v\n%s", api, err, ir)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsReadonlyCallerBoundariesRemainContext(t *testing.T) {
+	for _, body := range []string{
+		"MOVSS (DI),X0\nMOVSS X0,(DI)",
+		"VMOVSD (SI),X0\nVMOVSD X0,(SI)",
+		"MOVL $0,AX\nKMOVD AX,K1\nVMOVSS.Z (BX),K1,X0\nVMOVSS X0,(DX)",
+		"MOVSS (SP),X0\nMOVSS X0,(DX)",
+	} {
+		t.Run(body, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", assembly)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("readonly/unknown backing acquired permission: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86ScalarFPBitViewsPrivateInitializationDoesNotExpandAsmDecl(t *testing.T) {
+	fixture := x86ScalarFPBitFixture{
+		name: "private-mask", declaration: "func view(x,y uint64) uint64\n",
+		body: "MOVSD x+0(FP),X0\nMOVSD X0,ret+16(FP)\nMOVSS y+8(FP),X1\n" +
+			"MOVL $1,AX\nKMOVD AX,K1\nVMOVSS X1,K1,ret+18(FP)", args: 24,
+	}
+	source := x86ScalarFPBitAssembly(t, fixture, "amd64")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+fixture.declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	function := file.Funcs[0]
+	sig := signatures[resolve(function.Sym)]
+	if err := checkX86ScalarFPResultInitialization(function, sig, "amd64"); err != nil {
+		t.Fatalf("private numerical-byte query: %v", err)
+	}
+	if err := CheckX86ABI0ResultInitialization(function, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("private mask transfer expanded public asmdecl authority: %v", err)
+	}
+}
diff --git a/amd64_scalar_fp_symbol_result_test.go b/amd64_scalar_fp_symbol_result_test.go
new file mode 100644
index 000000000..c8890279e
--- /dev/null
+++ b/amd64_scalar_fp_symbol_result_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// Go's mode32 SB memory role ignores a Reg annotation and uses an Index.
+// Neither spelling is an ABI0 result write. Keep this denominator independent
+// of the transfer registry so a new parser representation cannot bypass RET.
+func TestX86ScalarFPStaticSymbolStoresCannotReplaceResult(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		for _, destination := range []string{
+			"slot<>(SB)", "slot<>(SB)(AX)", "slot<>(SB)(CX*1)", "slot<>(SB)(AX)(CX*2)",
+		} {
+			t.Run(op+"/"+destination, func(t *testing.T) {
+				source := fmt.Sprintf("GLOBL slot<>(SB),16,$16\nTEXT ·view(SB),4,$0-8\nPXOR X0,X0\n%s X0,%s\nRET\n", op, destination)
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint64\n", "386", triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Errorf("%s %s static store substituted for unwritten result: %v; IR bytes=%d", triple, api, err, len(ir))
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFPStaticSymbolStoresKeepCFGAndPointerBoundaries(t *testing.T) {
+	for _, tc := range []struct {
+		name, body, declaration string
+		args                    int
+	}{
+		{
+			name:        "result absent on one return path",
+			body:        "MOVL $1,AX\nCMPL AX,AX\nJE missing\nPXOR X0,X0\nMOVQ X0,ret+0(FP)\nRET\nmissing:\nPXOR X0,X0\nMOVQ X0,slot<>(SB)\nRET",
+			declaration: "func view() uint64\n",
+			args:        8,
+		},
+		{
+			name:        "pointer bits through X are not numeric output",
+			body:        "MOVQ p+0(FP),AX\nMOVQ AX,X0\nMOVQ X0,slot<>(SB)\nPXOR X1,X1\nMOVQ X1,ret+8(FP)\nRET",
+			declaration: "func view(p *byte) uint64\n",
+			args:        16,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := fmt.Sprintf("GLOBL slot<>(SB),16,$16\nTEXT ·view(SB),4,$0-%d\n%s\n", tc.args, tc.body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, tc.declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s borrowed result or pointer authority: %v; IR bytes=%d", api, err, len(ir))
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_fp_view_roles_test.go b/amd64_scalar_fp_view_roles_test.go
new file mode 100644
index 000000000..60a9f49a4
--- /dev/null
+++ b/amd64_scalar_fp_view_roles_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarFPBitViewsNewParameterReadsRequireWholeSourceFacts(t *testing.T) {
+	for _, fixture := range []x86ScalarFPBitFixture{
+		{name: "integer-low", declaration: "func view(x uint64) float32\n", body: "MOVSS x+0(FP),X1\nVMOVSS X1,X1,K1,X0\nMOVSS X0,ret+8(FP)"},
+		{name: "integer-suboffset", declaration: "func view(x uint64) float32\n", body: "MOVSS x+2(FP),X1\nVMOVSS X1,X1,K1,X0\nMOVSS X0,ret+8(FP)"},
+		{name: "cross-fields", declaration: "func view(a,b uint32) float64\n", body: "MOVSD a+0(FP),X1\nVMOVSD X1,X1,K1,X0\nMOVSD X0,ret+8(FP)"},
+		{name: "mixed-fields", declaration: "func view(a float32,b uint32) float64\n", body: "MOVSD a+0(FP),X1\nVMOVSD X1,X1,K1,X0\nMOVSD X0,ret+8(FP)"},
+		{name: "unknown-low", declaration: "func view(x uint64) float64\n", body: "MOVSS x+0(FP),X1\nVMOVSD X7,X1,X0\nMOVSD X0,ret+8(FP)"},
+		{name: "branch-only-low", declaration: "func view(x uint64) float32\n", body: "MOVSS x+0(FP),X1\nMOVL $1,AX\nCMPL AX,$0\nJE joined\nMOVSS X1,X7\njoined:\nVMOVSS X7,X1,X0\nMOVSS X0,ret+8(FP)"},
+	} {
+		// Go's four-operand masked register rows are AMD64-only. Keep
+		// their original mode32 rejection separate from numerical Context.
+		reject386 := fixture.name != "unknown-low" && fixture.name != "branch-only-low"
+		x86ScalarFPViewContextFixture(t, fixture, reject386, !reject386)
+	}
+}
+
+func TestX86ScalarFPBitViewsActualHighBankNumericalFacts(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, bits := range []int{32, 64} {
+		move := "MOVSS"
+		if bits == 64 {
+			move = "MOVSD"
+		}
+		for index := 16; index < 32; index++ {
+			fixture := x86ScalarFPBitFixture{
+				name:        fmt.Sprintf("%d/X%d", bits, index),
+				declaration: fmt.Sprintf("func view(x uint64) uint%d\n", bits),
+				body:        fmt.Sprintf("MOVL $1,AX\nKMOVD AX,K1\nV%s.Z x+0(FP),K1,X%d\nV%s X%d,ret+8(FP)", move, index, move, index),
+			}
+			for _, target := range x86RawReturnTargets {
+				t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+					source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+						if target.arch == "386" {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Errorf("%s mode32 high spelling acquired a physical bank: %v\n%s", api, err, ir)
+							}
+							continue
+						}
+						if err != nil {
+							t.Errorf("%s actual AMD64 EVEX bank lacks numerical facts: %v", api, err)
+							continue
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsHighBankFactsIntersectAllPaths(t *testing.T) {
+	for _, fixture := range []x86ScalarFPBitFixture{
+		{name: "unknown-high-mask", declaration: "func view(x uint64) uint64\n", body: "VMOVSD.Z x+0(FP),K1,X31\nVMOVSD X31,ret+8(FP)"},
+		{name: "unknown-high-merge", declaration: "func view(x uint64) uint64\n", body: "MOVL $0,AX\nKMOVD AX,K1\nVMOVSD x+0(FP),K1,X31\nVMOVSD X31,ret+8(FP)"},
+		{name: "partial-high", declaration: "func view(x uint64) uint64\n", body: "MOVSS x+0(FP),X1\nVMOVSS X1,X31,X31\nVMOVSD X31,ret+8(FP)"},
+		{name: "branch-only-high", declaration: "func view(x uint64) uint64\n", body: "MOVL $1,AX\nKMOVD AX,K1\nCMPL AX,$0\nJE joined\nVMOVSD.Z x+0(FP),K1,X31\njoined:\nVMOVSD X31,ret+8(FP)"},
+		{name: "unknown-upper-fullX", declaration: "func view(x uint64) uint32\n", body: "MOVSS x+0(FP),X1\nVMOVSS X1,X31,X31\nVADDPS X31,X31,X31\nVMOVSS X31,ret+8(FP)"},
+	} {
+		x86ScalarFPInitializationContextFixture(t, fixture, fixture.name != "unknown-high-mask")
+	}
+	left, right := x86ResultState{}, x86ResultState{}
+	for index := range left.xmm {
+		left.xmm[index], right.xmm[index] = 0xffff, 0xffff
+	}
+	for missing := 0; missing < 16; missing++ {
+		right.xmm[31] = 0xffff &^ (uint16(1) << uint(missing))
+		merged := left.intersect(right)
+		if merged.xmm[31] != right.xmm[31] || left.xmm[31] != 0xffff {
+			t.Fatalf("high-bank byte %d did not intersect independently", missing)
+		}
+		merged.xmm[31] = 0
+		if right.xmm[31] == 0 || left.xmm[31] != 0xffff {
+			t.Fatal("mutating merged state changed a predecessor")
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsNewReadHelperRequiresSourceBeforeIR(t *testing.T) {
+	var output strings.Builder
+	ctx := newAMD64Ctx(&output, Func{}, FuncSig{
+		Args: []LLVMType{I64}, Ret: LLVMType("float"),
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: LLVMType("float"), Index: 0, Field: -1}},
+		},
+	}, nil, nil, false)
+	if _, err := ctx.loadScalarFPBits(0, 32); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+		t.Fatalf("new parameter byte view manufactured source evidence: %v\n%s", err, output.String())
+	}
+}
+
+func TestX86ScalarFPBitViewsTypedFloatingEffectsNeedAllInputs(t *testing.T) {
+	for _, operation := range []string{"ADD", "SUB", "MUL", "DIV"} {
+		for _, bits := range []int{32, 64} {
+			move, suffix, packed := "MOVSS", "SS", "PS"
+			if bits == 64 {
+				move, suffix, packed = "MOVSD", "SD", "PD"
+			}
+			prefix := fmt.Sprintf("%s x+0(FP),X0\n", move)
+			for name, body := range map[string]string{
+				"undefined-low":   prefix + operation + suffix + " X7,X0",
+				"undefined-fullX": prefix + "V" + operation + packed + " X7,X0,X0",
+				"unknown-mask":    prefix + "V" + operation + suffix + " X0,X0,K1,X0",
+				"branch-only":     prefix + "MOVL $1,AX\nCMPL AX,$0\nJE joined\n" + move + " x+0(FP),X7\njoined:\n" + operation + suffix + " X7,X0",
+			} {
+				fixture := x86ScalarFPBitFixture{
+					name:        fmt.Sprintf("%s%d/%s", operation, bits, name),
+					declaration: fmt.Sprintf("func view(x uint64) uint%d\n", bits),
+					body:        body + fmt.Sprintf("\n%s X0,ret+8(FP)", move),
+				}
+				x86ScalarFPViewContextFixture(t, fixture, name == "unknown-mask", name != "unknown-mask")
+			}
+			// The new numeric view supplies no missing byte, even to a zero
+			// mask or a scalar broadcast. This independent declaration leaves
+			// a real alignment hole before the uint64 field.
+			fixture := x86ScalarFPBitFixture{
+				name:        fmt.Sprintf("%s%d/memory-hole", operation, bits),
+				declaration: fmt.Sprintf("func view(a byte,x uint64) uint%d\n", bits),
+				body:        fmt.Sprintf("%s x+8(FP),X0\nV%s%s.BCST a+0(FP),X0,X0\n%s X0,ret+16(FP)", move, operation, packed, move),
+			}
+			x86ScalarFPInitializationContextFixture(t, fixture)
+		}
+	}
+}
+
+func x86ScalarFPViewContextFixture(t *testing.T, fixture x86ScalarFPBitFixture, actualGoRejectsMode32, ordinaryScratch bool) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+			source := x86ScalarFPBitAssembly(t, fixture, target.arch)
+			if actualGoRejectsMode32 && target.arch == "386" {
+				goAssemblerOracleOutput(t, target.arch, source, "", false)
+			} else {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+				if target.arch == "amd64" && ordinaryScratch {
+					x86VectorScratchCodegenControl(t, source, fixture.declaration, target.arch, target.triple, ir, err)
+					continue
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Errorf("%s source lacks whole numerical facts: %v\n%s", api, err, ir)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarFPBitViewsTypedFloatingControlsKeepPublicQueryClosed(t *testing.T) {
+	for _, fixture := range x86FloatBinaryFPFixtures(t) {
+		t.Run(fixture.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, fixture.assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], fixture.sig, "amd64"); err != nil {
+				t.Errorf("existing complete numeric byte-field consumer: %v", err)
+			}
+			if err := checkX86ABI0ResultInitialization(file.Funcs[0], fixture.sig, "amd64", x86ResultTransfer, false); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("private numerical facts widened public asmdecl query: %v", err)
+			}
+		})
+	}
+	// Y/Z effects are not represented by this X-byte proof. Do not truncate
+	// their required source width into a known low-X witness.
+	for _, bank := range []string{"Y", "Z"} {
+		fixture := x86ScalarFPBitFixture{
+			name:        bank + "-unmodeled-wide",
+			declaration: "func view(x uint64) uint32\n",
+			body:        "MOVSS x+0(FP),X0\nVADDPS " + bank + "0," + bank + "0," + bank + "0\nMOVSS X0,ret+8(FP)",
+		}
+		x86ScalarFPInitializationContextFixture(t, fixture)
+	}
+}
diff --git a/amd64_scalar_fp_void_test.go b/amd64_scalar_fp_void_test.go
new file mode 100644
index 000000000..5455bf1a2
--- /dev/null
+++ b/amd64_scalar_fp_void_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// The declaration supplies logical ABI0 fields only. It does not supply a
+// native incoming-frame pointer, a caller certificate or an allocation extent.
+func x86ScalarFPVoidSource(t *testing.T, declaration, body, arch string) (*File, FuncSig, string) {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sig.Ret != Void || len(sig.Frame.Results) != 0 {
+		t.Fatal("fixture must derive an actual typed void signature")
+	}
+	end := int64(0)
+	for _, slot := range sig.Frame.Params {
+		if current := slot.Offset + x86FrameScalarBytes(slot.Type, arch); current > end {
+			end = current
+		}
+	}
+	source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\nRET\n", end, body)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, sig, source
+}
+
+func TestX86ScalarFPBitViewsVoidOriginalObjectsAndThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, shape := range []struct {
+		name, declaration string
+		offset32          int
+	}{
+		{"scalar", "func view(x uint64)\n", 2},
+		{"bytes", "func view(x [8]byte)\n", 1},
+		{"nested", "type Words struct { A [2]uint16; B uint32 }\nfunc view(x Words)\n", 2},
+	} {
+		for _, move := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+			offset := 0
+			if strings.HasSuffix(move, "SS") {
+				offset = shape.offset32
+			}
+			body := fmt.Sprintf("%s x+%d(FP),X1", move, offset)
+			for _, target := range x86RawReturnTargets {
+				t.Run(shape.name+"/"+move+"/"+target.triple, func(t *testing.T) {
+					file, sig, source := x86ScalarFPVoidSource(t, shape.declaration, body, target.arch)
+					receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					t.Logf("actual original typed-void source object: %+v", receipt)
+					if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+						t.Errorf("private input/effect query requires a fabricated result: %v", err)
+					}
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("private void query expanded public result admission: %v", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, shape.declaration, target.arch, target.triple, api)
+						if err != nil {
+							t.Errorf("%s rejected defined typed-void parameter bytes: %v", api, err)
+							continue
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsVoidUnknownInputsRemainContext(t *testing.T) {
+	for _, fixture := range []x86ScalarFPBitFixture{
+		{name: "unknown-mask", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nVMOVSS.Z x+2(FP),K1,X0"},
+		{name: "unknown-merge", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVL $1,AX\nKMOVD AX,K1\nVMOVSS x+2(FP),K1,X0"},
+		{name: "partial-lane", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVSS X1,X0\nVMOVSD X0,X1,X2"},
+		{name: "branch-only", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVL $1,AX\nCMPL AX,$0\nJE joined\nMOVSS X1,X7\njoined:\nVMOVSS X7,X1,X0"},
+		{name: "native-address", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVL $1,AX\nMOVSS (AX),X0"},
+		{name: "partial-native-address", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVB $1,AL\nMOVSS (AX),X0"},
+		{name: "readonly-input", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nMOVSS X1,x+2(FP)"},
+		{name: "pointer-bytes", declaration: "func view(x *uint64)\n", body: "MOVSS x+0(FP),X1"},
+		{name: "alignment-hole", declaration: "func view(a byte,x uint64)\n", body: "MOVSS a+0(FP),X1"},
+		{name: "unknown-call", declaration: "func view(x uint64)\n", body: "MOVSS x+2(FP),X1\nCALL ·other(SB)"},
+	} {
+		for _, target := range x86RawReturnTargets {
+			t.Run(fixture.name+"/"+target.triple, func(t *testing.T) {
+				file, sig, source := x86ScalarFPVoidSource(t, fixture.declaration, fixture.body, target.arch)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("void discarded an unknown input/effect: %v", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, fixture.declaration, target.arch, target.triple, api)
+					if target.arch == "amd64" && (fixture.name == "unknown-merge" || fixture.name == "partial-lane" || fixture.name == "branch-only") {
+						x86VectorScratchCodegenControl(t, source, fixture.declaration, target.arch, target.triple, ir, err)
+						continue
+					}
+					if fixture.name == "native-address" {
+						if err != nil || !strings.Contains(ir, "load volatile i32,") {
+							t.Fatal("complete numerical address lost its fault-preserving scalar read", api, err)
+						}
+						x86RequireNumericNativeSourceContext(t, source, fixture.declaration, target.arch)
+						x86NumericNativeAddressObject(t, ir, target.triple)
+						continue
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Errorf("%s void manufactured byte/address authority: %v\n%s", api, err, ir)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsVoidKnownMaskedMergeControls(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, move := range []string{"MOVSS", "MOVSD"} {
+		for _, active := range []int{0, 1} {
+			for _, zero := range []bool{false, true} {
+				suffix := ""
+				if zero {
+					suffix = ".Z"
+				}
+				body := fmt.Sprintf("%s x+0(FP),X0\nMOVL $%d,AX\nKMOVD AX,K1\nV%s%s x+0(FP),K1,X0", move, active, move, suffix)
+				for _, target := range x86RawReturnTargets {
+					t.Run(fmt.Sprintf("%s/active%d/zero%t/%s", move, active, zero, target.triple), func(t *testing.T) {
+						declaration := "func view(x [8]byte)\n"
+						_, _, source := x86ScalarFPVoidSource(t, declaration, body, target.arch)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil {
+								t.Errorf("%s lost initialized masked-void control: %v", api, err)
+								continue
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPBitViewsVoidLayoutAndEveryByteStayBound(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		file, sig, _ := x86ScalarFPVoidSource(t, "func view(x [8]byte)\n", "MOVSD x+0(FP),X0", arch)
+		for missing := range sig.Frame.Params {
+			t.Run(fmt.Sprintf("%s/missing-%d", arch, missing), func(t *testing.T) {
+				changed := sig
+				changed.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+				changed.Frame.Params = append(changed.Frame.Params[:missing], changed.Frame.Params[missing+1:]...)
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], changed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("void read invented missing byte %d: %v", missing, err)
+				}
+			})
+		}
+		for name, mutate := range map[string]func(*Func, *FuncSig){
+			"nonvoid-return-without-result": func(_ *Func, sig *FuncSig) { sig.Ret = I64 },
+			"void-with-result": func(_ *Func, sig *FuncSig) {
+				sig.Frame.Results = []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}}
+			},
+			"short-argument-extent":     func(fn *Func, _ *FuncSig) { fn.ArgSize = 7 },
+			"missing-argument-extent":   func(fn *Func, _ *FuncSig) { fn.ArgSize = 0 },
+			"oversized-argument-extent": func(fn *Func, _ *FuncSig) { fn.ArgSize = 4097 },
+			"overlapping-parameters": func(_ *Func, sig *FuncSig) {
+				sig.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+				sig.Frame.Params[1].Offset = 0
+			},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				fn, changed := file.Funcs[0], sig
+				mutate(&fn, &changed)
+				if err := checkX86ScalarFPResultInitialization(fn, changed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("void source/type/layout mutation acquired facts: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_integer_fp_bytes.go b/amd64_scalar_integer_fp_bytes.go
new file mode 100644
index 000000000..af4a3d3d6
--- /dev/null
+++ b/amd64_scalar_integer_fp_bytes.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// A named GP move's FP operand describes instruction bytes, not a coercion to
+// the first logical field. Keep exact natural scalar transfers on their old
+// routes (in particular, opaque pointers). A new partial/interior/cross-field
+// view must be handled here, including a failed proof; it cannot fall back to
+// the legacy first-slot conversion or an unresolved-offset zero.
+func (c *amd64Ctx) integerFPByteView(off, width int64, write bool) (bool, error) {
+	return c.integerFPByteViewMode(off, width, write, false)
+}
+
+func (c *amd64Ctx) integerFPByteViewMode(off, width int64, write, exactBits bool) (bool, error) {
+	if c.goarch == "386" && width == 8 {
+		return true, fmt.Errorf("%w: mode32 has no GP qword FP move; X/m64 retains its separate typed consumer", ErrProbeNeedsContext)
+	}
+	if c.fpScalarSource.x86SourceStack != nil || c.fpScalarSource.x86FixedLocal != nil ||
+		len(c.sig.Frame.Params)+len(c.fpResults) == 0 {
+		return false, nil // Independently bound physical storage retains its consumer.
+	}
+	if !exactBits && x86IntegerFPNaturalTransfer(c.sig.Frame.Params, c.fpResults, off, width, write, c.goarch) {
+		return false, nil
+	}
+	fail := func(reason string) (bool, error) {
+		return true, fmt.Errorf("%w: integer FP byte view +%d/%d: %s", ErrProbeNeedsContext, off, width, reason)
+	}
+	if width != 1 && width != 2 && width != 4 && width != 8 || off < 0 || off > math.MaxInt64-width {
+		return fail("invalid or overflowing span")
+	}
+	for current := off; current < off+width; current++ {
+		matches := 0
+		for _, group := range []struct {
+			slots  []FrameSlot
+			result bool
+		}{{c.sig.Frame.Params, false}, {c.fpResults, true}} {
+			for _, slot := range group.slots {
+				size := x86FrameScalarBytes(slot.Type, c.goarch)
+				if size <= 0 || slot.Offset < 0 || slot.Offset > math.MaxInt64-size {
+					return fail("invalid scalar field extent")
+				}
+				if current < slot.Offset || current >= slot.Offset+size {
+					continue
+				}
+				if slot.Type == Ptr {
+					return fail("pointer bits retain their independent role")
+				}
+				if write && !group.result {
+					if slot.Type == I1 {
+						return fail("bool parameter writes retain their independent role")
+					}
+					if err := c.scalarFPResultInitialized(); err != nil {
+						return true, err
+					}
+					if !c.fpScalarTrapOnly {
+						return fail("parameter write needs its complete trap-only shadow role")
+					}
+				}
+				matches++
+			}
+		}
+		if matches != 1 {
+			return fail(fmt.Sprintf("byte %d has %d scalar fields", current, matches))
+		}
+	}
+	// Numerical definedness, canonical bool bytes and all source/native roles
+	// are checked once for the complete original function, not inferred from the
+	// layout or from zero-initialized implementation allocas.
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return true, err
+	}
+	for current := off; current < off+width; current++ {
+		slot, _, _ := c.fpVectorSlot(current)
+		if slot.Type == I1 && !c.abi0BoolResultByteStorage() {
+			return fail("physical bool bytes lack a checked canonical role")
+		}
+	}
+	return true, nil
+}
+
+func x86IntegerFPNaturalTransfer(params, results []FrameSlot, off, width int64, write bool, arch string) bool {
+	for group, slots := range [][]FrameSlot{params, results} {
+		for _, slot := range slots {
+			if slot.Offset == off && x86FrameScalarBytes(slot.Type, arch) == width {
+				// Legacy evalFPToI64 handles floating parameters, but its
+				// result branch has no floating bit view. Reuse the checked
+				// byte engine rather than its unresolved-result zero.
+				if group == 1 && !write && (slot.Type == "float" || slot.Type == "double") {
+					return false
+				}
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// The linear emitter also coerces the first FP field. Select the shared byte
+// emitter/proof for new views on every public API, not only for functions that
+// independently need CFG lowering (for example, mixed canonical bool tuples).
+// This is solely a routing decision; the selected consumer must prove the role.
+func x86IntegerFPByteMovesNeedCFG(fn Func, sig FuncSig, arch string) bool {
+	if x86OrdinaryIntegerFPStoreNeedsProof(fn, sig, arch) {
+		return true
+	}
+	if fn.x86SourceStack != nil || fn.x86FixedLocal != nil || len(sig.Frame.Params)+len(sig.Frame.Results) == 0 {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		width := x86IntegerFPMoveWidth(ins, arch)
+		if width == 0 || len(ins.Args) != 2 {
+			continue
+		}
+		for index, operand := range ins.Args {
+			if operand.Kind == OpFP && !x86IntegerFPNaturalTransfer(sig.Frame.Params, sig.Frame.Results, operand.FPOffset, width, index == 1, arch) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Ordinary declared integer results cannot publish unknown bytes simply
+// because the final FP store is an exact natural field. This is a cost gate
+// for the existing complete proof, not another ABI/state/alias producer.
+// Logical bool-input aliases, existing virtual-SP/mutable FP storage and bound
+// native/custom entry roles retain their independent consumers. This direct
+// GP/FP admission class does not model those storage domains; a new byte view
+// still goes through integerFPByteView and cannot borrow this separation.
+func x86OrdinaryIntegerFPStoreNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if (sig.Ret != I8 && sig.Ret != I16 && sig.Ret != I32 && sig.Ret != I64) ||
+		len(sig.Frame.Results) != 1 || !x86DirectGPFPResultSourceRole(fn, sig, arch) {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if x86IntegerFPMoveWidth(ins, arch) != 0 && len(ins.Args) == 2 && ins.Args[1].Kind == OpFP {
+			return true
+		}
+	}
+	return false
+}
+
+func x86DirectGPFPResultSourceRole(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" || sig.Ret == Void || len(sig.Frame.Results) == 0 ||
+		fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || len(sig.ArgRegs) != 0 ||
+		sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative ||
+		sig.amd64GoArguments != nil || sig.x86FixedLocal != nil || sig.x86CallerRegions != nil || sig.x86BorrowedBoolTail ||
+		len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86RawReplay != nil ||
+		fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil || len(fn.x86ContinuationAddresses) != 0 ||
+		len(fn.x86IndirectLabels) != 0 || fn.x86BoolCalls != nil || fn.x86BoolReadonlyInputs {
+		return false
+	}
+	for _, slot := range sig.Frame.Params {
+		if slot.Type == I1 {
+			return false // No new readonly logical-bool input/address role is inferred.
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" || isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil ||
+			ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return false
+		}
+		if _, stack, err := x86StackWidthProperties(ins, arch); stack && err == nil {
+			return false // Implicit value/FLAGS stack storage retains the same independent role.
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFPAddr || operand.Kind == OpMem && (operand.Mem.Base == SP || operand.Mem.Index == SP) {
+				return false // Existing logical address/storage consumer, not native AUTO authority.
+			}
+		}
+		if _, _, _, address := x86LogicalFPLEAWriteShape(ins, arch); address {
+			return false
+		}
+		if x86IntegerFPMoveWidth(ins, arch) != 0 && len(ins.Args) == 2 && ins.Args[1].Kind == OpFP {
+			width, offset := x86IntegerFPMoveWidth(ins, arch), ins.Args[1].FPOffset
+			for _, slot := range sig.Frame.Params {
+				if slot.Offset == offset && x86FrameScalarBytes(slot.Type, arch) == width {
+					return false // Preserve the old exact-natural writable input shadow.
+				}
+			}
+		}
+	}
+	return true
+}
+
+// This dispatch is only a cost/transport selector for the existing named GP
+// move lowerer. Vector/MMX forms keep their own grammar and permissions; Go's
+// MOVD/MOVDQ2Q aliases retain their original instruction identity.
+func x86IntegerFPMoveWidth(original Instr, arch string) int64 {
+	ins := x86SourceMoveInstruction(original, arch)
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg {
+			continue
+		}
+		if _, ok := amd64ParseXReg(operand.Reg); ok {
+			return 0
+		}
+		if _, ok := amd64ParseYReg(operand.Reg); ok {
+			return 0
+		}
+		if _, ok := amd64ParseZReg(operand.Reg); ok {
+			return 0
+		}
+		if _, ok := amd64ParseMReg(operand.Reg); ok {
+			return 0
+		}
+	}
+	switch ins.Op {
+	case "MOVB":
+		return 1
+	case "MOVW":
+		return 2
+	case "MOVL":
+		return 4
+	case "MOVQ":
+		if arch != "386" {
+			return 8
+		}
+	}
+	return 0
+}
+
+func (c *amd64Ctx) loadIntegerFPBytes(off int64, typ LLVMType) (string, bool, error) {
+	return c.loadIntegerFPBytesMode(off, typ, false)
+}
+
+func (c *amd64Ctx) loadIntegerFPBytesMode(off int64, typ LLVMType, exactBits bool) (string, bool, error) {
+	bits, _ := amd64IntegerTypeBits(typ)
+	handled, err := c.integerFPByteViewMode(off, int64(bits/8), false, exactBits)
+	if !handled || err != nil {
+		return "", handled, err
+	}
+	bytes, err := c.loadFPVectorBytesMode(off, bits/8, true)
+	if err != nil {
+		return "", true, err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to %s\n", value, bits/8, bytes, typ)
+	return "%" + value, true, nil
+}
+
+func (c *amd64Ctx) storeIntegerFPBytes(off int64, typ LLVMType, value string) (bool, error) {
+	bits, _ := amd64IntegerTypeBits(typ)
+	handled, err := c.integerFPByteView(off, int64(bits/8), true)
+	if !handled || err != nil {
+		return handled, err
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <%d x i8>\n", bytes, typ, value, bits/8)
+	return true, c.storeFPVectorBytesMode(off, bits/8, "%"+bytes, "", true)
+}
diff --git a/amd64_scalar_integer_fp_bytes_test.go b/amd64_scalar_integer_fp_bytes_test.go
new file mode 100644
index 000000000..2ba395318
--- /dev/null
+++ b/amd64_scalar_integer_fp_bytes_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86IntegerFPByteRoleCase struct {
+	name, declaration, body string
+	args                    int
+}
+
+func x86IntegerFPByteRoleCases(word int) []x86IntegerFPByteRoleCase {
+	return []x86IntegerFPByteRoleCase{
+		{"undefined-wide-source", "func Value() (uint8,uint8)", "MOVW AX,ret+0(FP)\nRET", 2},
+		{"undefined-neighbor-read", "func Value() (uint8,uint8,uint16)", "MOVB $1,ret+0(FP)\nMOVW ret+0(FP),AX\nMOVW AX,ret+2(FP)\nRET", 4},
+		{"result-padding", "func Value() (uint8,uint32)", "MOVL $1,AX\nMOVL AX,ret+0(FP)\nMOVL AX,ret+4(FP)\nRET", 8},
+		{"noncanonical-bool", "func Value() (bool,uint8)", "MOVW $0x0202,AX\nMOVW AX,ret+0(FP)\nRET", 2},
+		{"parameter-write", "func Value(x uint16) uint16", fmt.Sprintf("MOVB $1,x+1(FP)\nMOVW $1,ret+%d(FP)\nRET", word), word + 2},
+		{"partial-pointer-read", "func Value(p *uint64) uint16", fmt.Sprintf("MOVW p+1(FP),AX\nMOVW AX,ret+%d(FP)\nRET", word), word + 2},
+		{"partial-pointer-write", "func Value() *uint64", "MOVW $1,ret+0(FP)\nRET", word},
+		{"unknown-interior-read", "func Value() (uint32,uint32)", "MOVL $1,ret+0(FP)\nMOVL ret+6(FP),AX\nMOVL AX,ret+4(FP)\nRET", 8},
+		{"unknown-cfg-source", "func Value(x uint32) (uint8,uint8)", fmt.Sprintf("MOVL x+0(FP),AX\nCMPL AX,$0\nJE bad\nMOVW $0x0201,BX\nJMP join\nbad:\nNOP\njoin:\nMOVW BX,ret+%d(FP)\nRET", word), word + 2},
+	}
+}
+
+const x86IntegerFPByteStatusSource = "TEXT ·Value(SB),4,$0-5\nCLD\nMOVL $0,AX\nCMPL AX,$0\nMOVL $0x04030201,BX\nMOVL BX,ret+0(FP)\nMOVW ret+1(FP),CX\nSETEQ DX\nMOVB DX,ret+4(FP)\nRET\n"
+
+func TestX86IntegerFPByteViewsKeepIndependentRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86IntegerFPByteRoleCases(word) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n", row.args, row.body)
+					ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("new byte view borrowed an independent role: output=%t, error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/natural-pointer/"+api, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s AX,ret+%d(FP)\nRET\n", 2*word, move, move, word)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *uint64) *uint64", target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("exact natural pointer transfer changed: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86IntegerFPByteViewsMode32QwordKeepsVectorConsumer(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				for _, gp := range []struct{ role, source string }{{"store", "MOVL $1,AX\n" + alias + " AX,ret+0(FP)"}, {"load", alias + " ret+0(FP),AX\nMOVL AX,ret+0(FP)\nMOVL AX,ret+4(FP)"}} {
+					t.Run(target.triple+"/"+alias+"/GP/"+api+"/"+gp.role, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·Value(SB),4,$0-8\n"+gp.source+"\nRET\n", "func Value() uint64", target.arch, target.triple, api)
+						if err == nil || ir != "" {
+							t.Fatalf("mode32 GP qword borrowed X/m64: output=%t, error=%v", ir != "", err)
+						}
+					})
+				}
+				t.Run(target.triple+"/"+alias+"/X/"+api, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-8\nPXOR X0,X0\n" + alias + " X0,ret+0(FP)\n" + alias + " ret+0(FP),X1\n" + alias + " X1,ret+0(FP)\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint64", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("legal mode32 X/m64 route changed: %v", err)
+					}
+				})
+			}
+		}
+	}
+	ctx := newX86Ctx(&strings.Builder{}, Func{}, FuncSig{}, nil, nil, "386", "", false)
+	ctx.fpResults = []FrameSlot{{Offset: 0, Type: I64}}
+	for _, write := range []bool{false, true} {
+		if handled, err := ctx.integerFPByteView(0, 8, write); !handled || !errors.Is(err, ErrProbeNeedsContext) || ctx.fpScalarChecked {
+			t.Fatalf("descriptor admitted mode32 GP qword: handled=%t, error=%v", handled, err)
+		}
+	}
+}
+
+func TestX86IntegerFPByteViewsPreserveStatusAndDirection(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, x86IntegerFPByteStatusSource, "func Value() (uint8,uint8,uint8,uint8,bool)", target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal(err)
+				}
+				x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{1, 2, 3, 4, 1})
+			})
+		}
+	}
+}
+
+func TestX86IntegerFPByteViewsDescriptorCannotCreateStorage(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name string
+			off  int64
+			slot FrameSlot
+		}{
+			{"pointer", 0, FrameSlot{Offset: 0, Type: Ptr}},
+			{"padding", 2, FrameSlot{Offset: 0, Type: I8}},
+			{"unsupported-type", 0, FrameSlot{Offset: 0, Type: "{ i8, i8 }"}},
+			{"negative-offset", -1, FrameSlot{Offset: 0, Type: I32}},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ctx := newX86Ctx(&strings.Builder{}, Func{}, FuncSig{}, nil, nil, arch, "", false)
+				ctx.fpResults = []FrameSlot{row.slot}
+				handled, err := ctx.integerFPByteView(row.off, 2, false)
+				if !handled || !errors.Is(err, ErrProbeNeedsContext) || ctx.fpScalarChecked {
+					t.Fatalf("layout created a source/storage proof: handled=%t, checked=%t, error=%v", handled, ctx.fpScalarChecked, err)
+				}
+			})
+		}
+		t.Run(arch+"/physical-bool-needs-role", func(t *testing.T) {
+			ctx := newX86Ctx(&strings.Builder{}, Func{}, FuncSig{}, nil, nil, arch, "", false)
+			ctx.fpResults = []FrameSlot{{Offset: 0, Type: I1}}
+			ctx.classicFrame = "%unbound_frame"
+			if err := ctx.storeFPVectorBytesMode(0, 1, "zeroinitializer", "", true); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("byte engine acquired physical bool storage without canonical proof: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_lane_caller_test.go b/amd64_scalar_lane_caller_test.go
new file mode 100644
index 000000000..74f1c95a3
--- /dev/null
+++ b/amd64_scalar_lane_caller_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarLaneCallerCompleteBoundedRegions(t *testing.T) {
+	for _, size := range []struct{ suffix, typ string }{{"B", "uint8"}, {"W", "uint16"}, {"D", "uint32"}, {"Q", "uint64"}} {
+		for _, prefix := range []string{"", "V"} {
+			for _, memory := range []bool{false, true} {
+				name := prefix + size.suffix + fmt.Sprint(memory)
+				t.Run(name, func(t *testing.T) {
+					source := strings.ReplaceAll(x86CallerFixtureSource, "float32", size.typ)
+					row := prefix + "PINSR" + size.suffix + " $0,AX,X0"
+					if memory {
+						row = strings.Replace(row, "AX", "(DI)", 1)
+					}
+					out := "X0"
+					if prefix != "" {
+						row += ",X1"
+						out = "X1"
+					}
+					body := row + "\n" + prefix + "PEXTR" + size.suffix + " $0," + out + ",(DX)"
+					assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+					goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+					pkg, _ := x86CallerCoreFixture(t, source, assembly)
+					for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+						if err := x86CallerCoreTranslate(t, pkg, assembly, triple); err != nil {
+							t.Fatal(err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneCallerRetainsUnknownAndPointerBoundaries(t *testing.T) {
+	for _, tc := range []struct{ name, body string }{
+		{"unknown-lane", "PINSRD $1,AX,X0\nPEXTRD $0,X0,(DX)"},
+		{"unknown-GP", "PINSRD $0,BX,X0\nPEXTRD $0,X0,(DX)"},
+		{"pointer-source", "PINSRD $0,DI,X0\nPEXTRD $0,X0,(DX)"},
+		{"private-SP-source", "PINSRD $0,SP,X0\nPEXTRD $0,X0,(DX)"},
+		{"input-write", "PINSRD $0,AX,X0\nPEXTRD $0,X0,(DI)"},
+		{"out-of-result", "PINSRQ $0,AX,X0\nPEXTRQ $0,X0,(DX)"},
+		{"local-length-crosses-bound", "PINSRQ $0,1(CX),X0\nPEXTRD $0,X0,(DX)"},
+		{"unknown-address", "PINSRD $0,(BX),X0\nPEXTRD $0,X0,(DX)"},
+		{"unknown-call", "PINSRD $0,AX,X0\nCALL unknown(SB)\nPEXTRD $0,X0,(DX)"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", tc.body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed lane/caller role acquired continuation: %v", err)
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_lane_definedness_test.go b/amd64_scalar_lane_definedness_test.go
new file mode 100644
index 000000000..eb98814f3
--- /dev/null
+++ b/amd64_scalar_lane_definedness_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarLaneDefinedBytesSharedConsumers(t *testing.T) {
+	for _, prefix := range []string{"", "V"} {
+		for _, size := range []struct {
+			name string
+			bits int
+		}{{"B", 8}, {"W", 16}, {"D", 32}, {"Q", 64}} {
+			for lane := 0; lane < 128/size.bits; lane++ {
+				t.Run(fmt.Sprintf("%s%s/%d", prefix, size.name, lane), func(t *testing.T) {
+					row := fmt.Sprintf("%sPINSR%s $%d,AX,X0", prefix, size.name, lane)
+					if prefix != "" {
+						row += ",X1"
+					}
+					ins := x86ScalarLaneInstruction(t, row)
+					form, known, err := x86ScalarLaneProperties(ins, "amd64")
+					if !known || err != nil {
+						t.Fatal(form, err)
+					}
+					state := x86ResultState{}
+					state.gp[0] = 0xff
+					if ok, known := x86ResultScalarLaneStep(ins, &state, nil, 0, "amd64"); !known || !ok {
+						t.Fatal("initialized scalar source rejected")
+					}
+					index := 0
+					if prefix != "" {
+						index = 1
+					}
+					want := uint16((uint64(1)<<uint(size.bits/8) - 1) << uint(lane*size.bits/8))
+					if state.xmm[index] != want {
+						t.Fatalf("unknown old lanes were washed: %04x/%04x", state.xmm[index], want)
+					}
+					caller := x86SourceStackState{known: map[Reg]uint8{AX: 0xff}, vectors: map[Reg]uint64{"Z0": 0, "Z1": 0}, callers: map[Reg]x86CallerPointerValue{}}
+					if !x86CallerScalarLaneStep(&ins, form, &caller, nil) || uint16(caller.vectors[Reg(fmt.Sprintf("Z%d", index))]) != want {
+						t.Fatal("caller/result effect drift")
+					}
+					upper := caller.vectors[Reg(fmt.Sprintf("Z%d", index))] >> 16
+					if prefix == "" && upper != 0 || prefix != "" && upper != ^uint64(0)>>16 {
+						t.Fatal("encoding upper-alias effect drift")
+					}
+					for _, extractPrefix := range []string{"", "V"} {
+						for selected := 0; selected < 128/size.bits; selected++ {
+							extract := x86ScalarLaneInstruction(t, fmt.Sprintf("%sPEXTR%s $%d,X%d,BX", extractPrefix, size.name, selected, index))
+							copyState := state
+							ok, known := x86ResultScalarLaneStep(extract, &copyState, nil, 0, "amd64")
+							if !known || ok != (selected == lane) {
+								t.Fatal("extraction consumed unselected/unknown lane", extract, ok)
+							}
+						}
+					}
+					for _, taint := range []string{"undefined-GP", "incoming-pointer"} {
+						bad := state
+						if taint == "undefined-GP" {
+							bad.gp[0] = 0
+						} else {
+							bad.pointerGP[0] = true
+						}
+						if ok, _ := x86ResultScalarLaneStep(ins, &bad, nil, 0, "amd64"); ok {
+							t.Fatal("scalar insert granted unknown/pointer source", taint)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneResultAPIMustInitializeOnlyObservedBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, tc := range []struct {
+			name, body string
+			good       bool
+		}{
+			{"selected-only", "MOVL k+0(FP),AX\nPINSRD $0,AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+8(FP)\n", true},
+			{"unknown-selected", "MOVL k+0(FP),AX\nPINSRD $1,AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+8(FP)\n", false},
+			{"unknown-old-low", "PINSRD $1,k+0(FP),X0\nMOVL X0,ret+8(FP)\n", false},
+			{"unknown-GP", "PINSRD $0,AX,X0\nMOVL X0,ret+8(FP)\n", false},
+			{"uninitialized-result-read", "PINSRD $0,ret+8(FP),X0\nMOVL X0,ret+8(FP)\n", false},
+			{"input-store", "MOVL k+0(FP),X0\nPEXTRD $0,X0,k+0(FP)\nMOVL X0,ret+8(FP)\n", false},
+			{"partial-join", "MOVL k+0(FP),AX\nCMPL AX,$0\nJE skip\nPINSRD $0,AX,X0\nskip:\nMOVL X0,ret+8(FP)\n", false},
+			// The memory-to-X MOVL defines all 16 bytes (zeroing bytes 4..15).
+			// Once AES has registered byte effects, this complete input is a
+			// positive control, not an unknown-instruction rejection.
+			{"registered-AES-complete-input", "MOVL k+0(FP),X0\nPINSRD $1,k+0(FP),X0\nAESENC X0,X0\nMOVL X0,ret+8(FP)\n", true},
+			// Inserting only lane 1 leaves bytes 0..3 and 8..15 undefined.
+			// Registering AES must not grant those potential result inputs.
+			{"registered-AES-missing-input-bytes", "PINSRD $1,k+0(FP),X0\nAESENC X0,X0\nMOVL X0,ret+8(FP)\n", false},
+		} {
+			t.Run(target.triple+"/"+tc.name, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-12\n" + tc.body + "RET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k,h uint32) uint32\n", target.arch, target.triple, api)
+					if target.arch == "amd64" && (tc.name == "unknown-selected" || tc.name == "unknown-old-low" || tc.name == "partial-join" || tc.name == "registered-AES-missing-input-bytes") {
+						x86VectorScratchCodegenControl(t, source, "func view(k,h uint32) uint32\n", target.arch, target.triple, ir, err)
+						continue
+					}
+					if (err == nil) != tc.good || !tc.good && ir != "" {
+						t.Fatalf("%s result domain: %v / %q", api, err, ir)
+					}
+					if tc.good {
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "selected.ll", "selected.o", ir)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarPSLaneResultSelectors(t *testing.T) {
+	for _, op := range []string{"INSERTPS", "VINSERTPS"} {
+		for immediate := 0; immediate < 256; immediate++ {
+			row := fmt.Sprintf("%s $%d,X0,X1", op, immediate)
+			if op[0] == 'V' {
+				row += ",X2"
+			}
+			ins := x86ScalarLaneInstruction(t, row)
+			state := x86ResultState{}
+			state.xmm[0] = 0xf << uint((immediate>>6)*4)
+			state.xmm[1] = 0xf0
+			if ok, known := x86ResultScalarLaneStep(ins, &state, nil, 0, "amd64"); !known || !ok {
+				t.Fatal(op, immediate)
+			}
+			want := uint16(0xf0)&^(uint16(0xf)<<uint((immediate>>4&3)*4)) | uint16(0xf)<<uint((immediate>>4&3)*4)
+			for lane := 0; lane < 4; lane++ {
+				if immediate&(1<<lane) != 0 {
+					want |= uint16(0xf) << uint(lane*4)
+				}
+			}
+			dst := 1
+			if op[0] == 'V' {
+				dst = 2
+			}
+			if state.xmm[dst] != want {
+				t.Fatal("PS source/target/zero-mask mismatch", op, immediate, state.xmm[dst], want)
+			}
+		}
+	}
+	for _, op := range []string{"EXTRACTPS", "VEXTRACTPS"} {
+		for lane := 0; lane < 4; lane++ {
+			ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,X0,AX", op, lane))
+			state := x86ResultState{}
+			state.xmm[0] = 0xf << uint(lane*4)
+			if ok, known := x86ResultScalarLaneStep(ins, &state, nil, 0, "amd64"); !known || !ok || state.gp[0] != 0xff {
+				t.Fatal("selected PS bytes rejected")
+			}
+			state.xmm[0] &= ^uint16(1 << uint(lane*4))
+			if ok, _ := x86ResultScalarLaneStep(ins, &state, nil, 0, "amd64"); ok {
+				t.Fatal("PS unknown byte was initialized")
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneCallerMemoryShapeExactWidths(t *testing.T) {
+	for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ", "PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ", "VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ"} {
+		width := map[byte]int64{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[op[len(op)-1]]
+		row, index := op+" $1,(AX),X1", 1
+		if strings.Contains(op, "EXTR") {
+			row, index = op+" $1,X1,(AX)", 2
+		} else if op[0] == 'V' {
+			row += ",X2"
+		}
+		ins := x86ScalarLaneInstruction(t, row)
+		actual, write, valid := x86InstructionMemoryShape(ins, index, "amd64")
+		if !valid || actual != width || write != strings.Contains(op, "EXTR") {
+			t.Fatal("memory role widened", op, actual, write, valid)
+		}
+		if _, _, valid = x86InstructionMemoryShape(ins, 0, "amd64"); valid {
+			t.Fatal("immediate acquired memory role", op)
+		}
+	}
+}
diff --git a/amd64_scalar_lane_effects.go b/amd64_scalar_lane_effects.go
new file mode 100644
index 000000000..53102acf0
--- /dev/null
+++ b/amd64_scalar_lane_effects.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+// These are defined-byte effects only. Caller-region native reads retain their
+// independent bounds proof; declaration-only results require initialized bytes.
+func x86CallerScalarLaneStep(ins *Instr, f x86ScalarLaneForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	width := int64(f.bits / 8)
+	if f.memory >= 0 && !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, width, !f.insert) {
+		return false
+	}
+	if f.insert {
+		known := x86CallerVectorByteMask(width)
+		if f.memory < 0 {
+			root, valid := x86CallerGP(f.transferReg)
+			_, pointer := state.callers[root]
+			if !valid || root == SP || root == BP || pointer || uint64(state.known[root])&known != known {
+				return false
+			}
+		}
+		destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+		base := state.vectors[x86CallerVectorRoot(ins.Args[f.base].Reg)]
+		state.vectors[destination] = x86ScalarLaneInsertKnown(f, base, known, state.vectors[destination])
+		return true
+	}
+	source := state.vectors[x86CallerVectorRoot(ins.Args[f.source].Reg)]
+	low := x86CallerVectorByteMask(width)
+	if source>>uint(f.offset)&low != low {
+		return false
+	}
+	if f.memory >= 0 {
+		return true
+	}
+	return x86CallerNumericWrite(f.transferReg, int64(f.gpBits/8), state)
+}
+
+func x86ResultScalarLaneStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	return x86ResultScalarLaneStepWithRead(ins, state, owned, resultOffset, arch, false)
+}
+
+func x86ResultScalarLaneStepWithRead(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, conditionalNativeRead bool) (bool, bool) {
+	f, known, err := x86ScalarLaneProperties(ins, arch)
+	if !known {
+		// Scalar and block transfers share the validated imm8/source/target
+		// grammar, but select bytes from their distinct physical widths.
+		ps, recognized, failure := x86InsertExtractProperties(ins, arch)
+		if !recognized {
+			return false, false
+		}
+		if failure != nil {
+			return false, true
+		}
+		if !ps.spec.scalar {
+			return x86ResultBlockTransfer(ins, ps, state, owned, resultOffset, arch), true
+		}
+		return x86ResultScalarPSLaneStep(ins, ps, state, owned, resultOffset, arch, conditionalNativeRead), true
+	}
+	if err != nil {
+		return false, true
+	}
+	width := int64(f.bits / 8)
+	low := x86CallerVectorByteMask(width)
+	if f.insert {
+		if f.memory >= 0 {
+			if !x86ResultReadWithNativeContinuation(ins, ins.Args[f.source], width, state, owned, arch, conditionalNativeRead) {
+				return false, true
+			}
+		} else {
+			readWidth := int64(4)
+			if f.bits == 64 {
+				readWidth = 8
+			}
+			index, _, valid := x86ResultGP(f.transferReg, readWidth, arch)
+			if !valid || state.pointerGP[index] || uint64(state.gp[index])&low != low {
+				return false, true
+			}
+		}
+		base, _ := amd64ParseXReg(ins.Args[f.base].Reg)
+		destination, _ := amd64ParseXReg(ins.Args[f.destination].Reg)
+		state.writeVector(destination, 16,
+			x86ScalarLaneInsertKnown(f, state.vectorBytes(base), low, state.vectorBytes(destination)), f.legacy)
+		return true, true
+	}
+	source, _ := amd64ParseXReg(ins.Args[f.source].Reg)
+	if uint64(state.xmm[source])>>uint(f.offset)&low != low {
+		return false, true
+	}
+	destination := ins.Args[f.destination]
+	if f.memory < 0 {
+		destination.Reg = f.transferReg
+		width = int64(f.gpBits / 8)
+	}
+	if x86ResultScalarLaneNativeStore(ins, destination, state, arch, conditionalNativeRead) {
+		return true, true
+	}
+	return x86ResultStore(destination, width, state, owned, resultOffset, arch), true
+}
+
+// Only the paired exact-width volatile emitter may continue a named native
+// scalar store. Its selected source bytes have already been checked; the
+// write creates no numerical, storage, pointer or later-read fact.
+func x86ResultScalarLaneNativeStore(ins Instr, destination Operand, state *x86ResultState, arch string, paired bool) bool {
+	return paired && x86ResultNamedPredicateInstruction(ins) && ins.x86NumericalRead == nil &&
+		x86OrdinaryNativeMemoryOperand(destination, arch) &&
+		x86ResultIncomingPointerAddressIdentity(destination, state, arch)
+}
+
+func x86ResultScalarPSLaneStep(ins Instr, f x86InsertExtractForm, state *x86ResultState, owned []bool, resultOffset int64, arch string, conditionalNativeRead bool) bool {
+	source := uint16(0)
+	if f.memory >= 0 {
+		if f.spec.insert && !x86ResultReadWithNativeContinuation(ins, ins.Args[f.memory], 4, state, owned, arch, conditionalNativeRead) {
+			return false
+		}
+		source = 0xf
+	} else {
+		index, _ := amd64ParseXReg(ins.Args[f.source].Reg)
+		source = state.xmm[index]
+	}
+	if !f.spec.insert {
+		index, _ := amd64ParseXReg(ins.Args[f.source].Reg)
+		if state.xmm[index]>>uint(f.offset)&0xf != 0xf {
+			return false
+		}
+		if x86ResultScalarLaneNativeStore(ins, ins.Args[f.destination], state, arch, conditionalNativeRead) {
+			return true
+		}
+		return x86ResultStore(ins.Args[f.destination], 4, state, owned, resultOffset, arch)
+	}
+	base, _ := amd64ParseXReg(ins.Args[f.base].Reg)
+	destination, _ := amd64ParseXReg(ins.Args[f.destination].Reg)
+	if f.memory < 0 {
+		source >>= uint(f.immediate>>6) * 4
+	}
+	lane := uint(f.immediate>>4&3) * 4
+	known := state.xmm[base]&^(uint16(0xf)<<lane) | (source&0xf)<<lane
+	for index := 0; index < 4; index++ {
+		if f.immediate&(1<<index) != 0 {
+			known |= uint16(0xf) << uint(index*4)
+		}
+	}
+	state.writeVector(destination, 16, uint64(known), f.spec.legacy)
+	return true
+}
diff --git a/amd64_scalar_lane_effects_test.go b/amd64_scalar_lane_effects_test.go
new file mode 100644
index 000000000..3a58ff0ad
--- /dev/null
+++ b/amd64_scalar_lane_effects_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// This is the memHash32AES input/insert/result pattern without borrowing AES
+// effects, native pointers or any package-specific permission. The original
+// typed ABI0 frame independently supplies both numerical scalar inputs.
+func TestX86ScalarLaneInsertResultInitializationFirstParty(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			const source = "TEXT ·view(SB),4,$0-12\nMOVL h+4(FP),X0\nPINSRD $1,k+0(FP),X0\nMOVL X0,ret+8(FP)\nRET\n"
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k,h uint32) uint32\n", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("original initialized scalar lane insert did not close its result: %v", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "scalar-lane-result-"+api+".ll", "scalar-lane-result-"+api+".o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarLaneInsertCompleteNamesRetainTypedResults(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ"} {
+			if target.arch == "386" && (op == "PINSRQ" || op[0] == 'V') {
+				continue // Go's complete 386 frontend excludes these named forms.
+			}
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				args := "$1,k+0(FP),X0"
+				if op[0] == 'V' {
+					args += ",X1"
+				}
+				output := "X0"
+				if op[0] == 'V' {
+					output = "X1"
+				}
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-24\nMOVQ h+8(FP),X0\n%s %s\nMOVQ %s,ret+16(FP)\nRET\n", op, args, output)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k,h uint64) uint64\n", target.arch, target.triple, api); err != nil || ir == "" {
+						t.Errorf("%s lost initialized insertion result: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_scalar_lane_forms.go b/amd64_scalar_lane_forms.go
new file mode 100644
index 000000000..59efa3f70
--- /dev/null
+++ b/amd64_scalar_lane_forms.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Scalar lane transfers select bytes, not an entire initialized vector. The
+// encoding grammar grants no caller region, native backing, or pointee facts.
+type x86ScalarLaneForm struct {
+	insert, legacy                  bool
+	bits, source, base, destination int
+	memory, offset, gpBits          int
+	transferReg                     Reg
+}
+
+func x86ScalarLaneProperties(ins Instr, arch string) (x86ScalarLaneForm, bool, error) {
+	op, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	f := x86ScalarLaneForm{source: 1, base: -1, destination: 2, memory: -1}
+	allowM := false
+	if spec, known := amd64PackedIntegerInsertSpecs[op]; known {
+		f.insert, f.legacy, f.bits, f.base = true, spec.legacy, spec.laneBits, 2
+		allowM = spec.legacy && spec.laneBits != 16
+		if !spec.legacy {
+			f.destination = 3
+		}
+	} else if spec, known := amd64PackedScalarExtractSpecs[Op(op)]; known && op != "EXTRACTPS" && op != "VEXTRACTPS" {
+		f.legacy, f.bits, allowM = !spec.vector, spec.bits, spec.allowMMX
+	} else {
+		return f, false, nil
+	}
+	fail := func() (x86ScalarLaneForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go scalar-lane grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != f.destination+1 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" ||
+		arch == "386" && (f.legacy && f.bits == 64 || f.insert && !f.legacy) {
+		return fail()
+	}
+	if arch == "386" && !f.insert && !f.legacy && f.bits == 64 {
+		// Preserve the original Go Q/W1 source identity, but use the actual
+		// non-64-bit WIG operation: imm[1:0], r32/m32, not a qword followed
+		// by GP truncation. Memory writes and all byte consumers agree.
+		f.bits = 32
+	}
+	vectorIndex, high := 0, Reg("")
+	xreg := func(arg Operand) bool {
+		index, valid := amd64ParseXReg(arg.Reg)
+		limit := 32
+		if f.legacy {
+			limit = 16
+			if arch == "386" {
+				limit = 8
+			}
+		}
+		if arg.Kind != OpReg || !valid || index >= limit {
+			return false
+		}
+		vectorIndex = index
+		if arch == "386" && index >= 8 {
+			high = arg.Reg
+		}
+		return true
+	}
+	transfer := ins.Args[f.destination]
+	if f.insert {
+		if !xreg(ins.Args[f.base]) || !xreg(ins.Args[f.destination]) {
+			return fail()
+		}
+		transfer = ins.Args[f.source]
+	} else if !xreg(ins.Args[f.source]) {
+		return fail()
+	}
+	minimum := int64(0)
+	if !f.insert && !f.legacy && vectorIndex < 16 {
+		minimum = -128 // VEX Yi8 and Yu8 rows; EVEX only Yu8.
+	}
+	immediate := ins.Args[0].Imm
+	if arch == "386" && !ins.x86Encoded {
+		immediate = int64(int32(immediate)) // Stock Go oclass TYPE_CONST.
+	}
+	if immediate < minimum || immediate > 255 {
+		return fail()
+	}
+	f.offset = (int(byte(immediate)) & (128/f.bits - 1)) * (f.bits / 8)
+	f.gpBits = f.bits
+	if !f.insert && f.gpBits < 32 {
+		f.gpBits = 32
+	}
+	if isAMD64MemoryOperand(transfer) && x86PackedShiftMemoryValid(transfer, arch) {
+		f.memory = f.destination
+		if f.insert {
+			f.memory = f.source
+		}
+	} else if transfer.Kind == OpReg && isX86YrlRegisterForArch(transfer.Reg, arch) {
+		f.transferReg = transfer.Reg
+	} else if index, valid := amd64ParseMReg(transfer.Reg); transfer.Kind == OpReg && valid && allowM && !ins.x86Encoded {
+		// Go's legacy Ymm here is a ModRM GP-number spelling, not an MMX
+		// bank read/write. Physical decoded instructions already name GP.
+		f.transferReg = amd64MMXEncodingGP(index)
+	} else {
+		return fail()
+	}
+	if high != "" {
+		return f, true, fmt.Errorf("%w: 386 scalar-lane %s lacks a physical high-bank identity", ErrProbeNeedsContext, high)
+	}
+	return f, true, nil
+}
+
+func (c *amd64Ctx) bindScalarLaneForm(op Op, ins Instr) (Instr, x86ScalarLaneForm, bool, error) {
+	if ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return ins, x86ScalarLaneForm{}, true, fmt.Errorf("scalar-lane dispatch/source mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	f, known, err := x86ScalarLaneProperties(ins, c.goarch)
+	if err == nil && known && f.memory >= 0 && ins.Args[f.memory].Kind == OpFP {
+		err = c.scalarLaneFPSpan(ins.Args[f.memory].FPOffset, f.bits)
+	}
+	if err == nil && known {
+		for _, slot := range c.fpResults {
+			if slot.Type == I8 || slot.Type == I16 || slot.Type == I32 || slot.Type == I64 {
+				// Extraction into a GP followed by an ordinary FP store must
+				// not evade the same original whole-source byte proof.
+				err = c.scalarFPResultInitialized()
+				break
+			}
+		}
+	}
+	return ins, f, known, err
+}
+
+func validateX86ScalarLaneFile(file *File, arch string) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if _, known, err := x86ScalarLaneProperties(ins, arch); known && err != nil {
+				return fmt.Errorf("%s: %w", fn.Sym, err)
+			}
+		}
+	}
+	return nil
+}
+
+// Both caller and result consumers use this same selected-byte writeback.
+// Legacy keeps the wider alias; VEX/EVEX clears all bytes above X128.
+func x86ScalarLaneInsertKnown(f x86ScalarLaneForm, base, source, old uint64) uint64 {
+	low := x86CallerVectorByteMask(int64(f.bits / 8))
+	lane := low << uint(f.offset)
+	known := base&0xffff&^lane | (source&low)<<uint(f.offset)
+	upper := ^uint64(0xffff)
+	if f.legacy {
+		upper &= old
+	}
+	return upper | known
+}
diff --git a/amd64_scalar_lane_forms_test.go b/amd64_scalar_lane_forms_test.go
new file mode 100644
index 000000000..fa20de761
--- /dev/null
+++ b/amd64_scalar_lane_forms_test.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86ScalarLaneInstruction(t *testing.T, row string) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86ScalarLaneCompleteGoTables(t *testing.T) {
+	read := func(name string) string {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return string(data)
+	}
+	legacy, vector := read("asm6.go"), read("avx_optabs.go")
+	compact := func(s string) string { return strings.ToLower(strings.Join(strings.Fields(s), "")) }
+	for name, expected := range map[string]string{
+		"yinsr":  "{Zibm_r,3,argList{Yu8,Ymm,Yxr}},",
+		"yinsrw": "{Zibm_r,2,argList{Yu8,Yml,Yxr}},",
+		"yextr":  "{Zibr_m,3,argList{Yu8,Yxr,Ymm}},",
+		"yextrw": "{Zibm_r,2,argList{Yu8,Yxr,Yrl}},{Zibr_m,2,argList{Yu8,Yxr,Yml}},",
+	} {
+		block := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(legacy)
+		if len(block) != 2 || compact(block[1]) != compact(expected) {
+			t.Fatalf("actual complete %s table changed: %v", name, block)
+		}
+	}
+	for name, expected := range map[string]string{
+		"_yvpinsrb":    "{zcase:Zvex_i_rm_v_r,zoffset:2,args:argList{Yu8,Yml,Yxr,Yxr}},{zcase:Zevex_i_rm_v_r,zoffset:3,args:argList{Yu8,Yml,YxrEvex,YxrEvex}},",
+		"_yvextractps": "{zcase:Zvex_i_r_rm,zoffset:0,args:argList{Yu8,Yxr,Yml}},{zcase:Zvex_i_r_rm,zoffset:2,args:argList{Yi8,Yxr,Yml}},{zcase:Zevex_i_r_rm,zoffset:3,args:argList{Yu8,YxrEvex,Yml}},",
+		"_yvpextrw":    "{zcase:Zvex_i_r_rm,zoffset:0,args:argList{Yu8,Yxr,Yml}},{zcase:Zvex_i_r_rm,zoffset:2,args:argList{Yi8,Yxr,Yml}},{zcase:Zvex_i_rm_r,zoffset:0,args:argList{Yu8,Yxr,Yrl}},{zcase:Zvex_i_rm_r,zoffset:2,args:argList{Yi8,Yxr,Yrl}},{zcase:Zevex_i_r_rm,zoffset:3,args:argList{Yu8,YxrEvex,Yml}},{zcase:Zevex_i_rm_r,zoffset:3,args:argList{Yu8,YxrEvex,Yrl}},",
+	} {
+		block := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(vector)
+		if len(block) != 2 || compact(block[1]) != compact(expected) {
+			t.Fatalf("actual complete %s table changed: %v", name, block)
+		}
+	}
+	var names []string
+	for _, action := range []string{"INSR", "EXTR"} {
+		for _, size := range []struct{ suffix, opcode, tuple string }{
+			{"B", map[string]string{"INSR": "20", "EXTR": "14"}[action], "1"},
+			{"W", map[string]string{"INSR": "c4", "EXTR": "15"}[action], "2"},
+			{"D", map[string]string{"INSR": "22", "EXTR": "16"}[action], "4"},
+			{"Q", map[string]string{"INSR": "22", "EXTR": "16"}[action], "8"},
+		} {
+			name := "P" + action + size.suffix
+			names = append(names, name, "V"+name)
+			table, prefix, opbytes := "yinsr", "Pq", "0x3a,0x"+size.opcode+",00"
+			if action == "EXTR" {
+				table = "yextr"
+			}
+			if size.suffix == "Q" {
+				prefix = "Pq3"
+			}
+			if size.suffix == "W" {
+				if action == "INSR" {
+					table = "yinsrw"
+					opbytes = "0xc4,00"
+				} else {
+					table = "yextrw"
+					opbytes = "0xc5,0,0x3a,0x15,0"
+				}
+			}
+			if !strings.Contains(compact(legacy), compact("{A"+name+","+table+","+prefix+",opBytes{"+opbytes+"}},")) {
+				t.Fatal("actual legacy opcode changed", name)
+			}
+			vt := "_yvpinsrb"
+			if action == "EXTR" {
+				vt = "_yvextractps"
+				if size.suffix == "W" {
+					vt = "_yvpextrw"
+				}
+			}
+			vmap, vw := "0F3A", "0"
+			if size.suffix == "W" && action == "INSR" {
+				vmap = "0F"
+			}
+			if size.suffix == "Q" {
+				vw = "1"
+			}
+			body := "avxEscape|vex128|vex66|vex" + vmap + "|vexW" + vw + ",0x" + size.opcode + ",avxEscape|evex128|evex66|evex" + vmap + "|evexW" + vw + ",evexN" + size.tuple + ",0x" + size.opcode + ","
+			if action == "EXTR" && size.suffix == "W" {
+				body = "avxEscape|vex128|vex66|vex0F3A|vexW0,0x15,avxEscape|vex128|vex66|vex0F|vexW0,0xc5,avxEscape|evex128|evex66|evex0F3A|evexW0,evexN2,0x15,avxEscape|evex128|evex66|evex0F|evexW0,0,0xc5,"
+			}
+			entry := "{as:A" + "V" + name + ",ytab:" + vt + ",prefix:Pavx,op:opBytes{" + body + "}},"
+			if !strings.Contains(compact(vector), compact(entry)) {
+				t.Fatalf("actual complete VEX/EVEX W/pp/opcode/tuple changed: %s", name)
+			}
+		}
+	}
+	var actual []string
+	for name := range amd64PackedIntegerInsertSpecs {
+		actual = append(actual, name)
+	}
+	for name := range amd64PackedScalarExtractSpecs {
+		if !strings.HasSuffix(string(name), "PS") {
+			actual = append(actual, string(name))
+		}
+	}
+	sort.Strings(names)
+	sort.Strings(actual)
+	if !reflect.DeepEqual(names, actual) {
+		t.Fatal("incomplete typed family", names, actual)
+	}
+}
+
+func TestX86ScalarLaneGoBytesAndEncodedGPSpellings(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, action := range []string{"INSR", "EXTR"} {
+			for _, suffix := range []string{"B", "W", "D", "Q"} {
+				if arch == "386" && suffix == "Q" {
+					continue
+				}
+				op := "P" + action + suffix
+				for index, gp := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+					if suffix == "W" {
+						break
+					} // yinsrw/yextrw have no Ymm selector.
+					t.Run(arch+"/"+op+"/"+gp, func(t *testing.T) {
+						row := fmt.Sprintf("%s $255,%s,X1", op, gp)
+						alias := fmt.Sprintf("%s $255,M%d,X1", op, index)
+						if action == "EXTR" {
+							row = fmt.Sprintf("%s $255,X1,%s", op, gp)
+							alias = fmt.Sprintf("%s $255,X1,M%d", op, index)
+						}
+						bytes := func(row string) []byte {
+							var result []byte
+							for _, line := range strings.Split(string(x86InsertExtractGoListing(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")), "\n") {
+								result = append(result, x86InsertExtractListedBytes(line)...)
+							}
+							return result
+						}
+						if !reflect.DeepEqual(bytes(row), bytes(alias)) {
+							t.Fatal("original Go Ymm encoding is not the GP identity", row, alias)
+						}
+						f, known, err := x86ScalarLaneProperties(x86ScalarLaneInstruction(t, alias), arch)
+						if !known || err != nil || f.transferReg != Reg(gp) {
+							t.Fatal("typed selected GP identity differs", f, known, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneGrammarRejectsAdjacentClasses(t *testing.T) {
+	for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ", "PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ", "VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ"} {
+		row := op + " $1,AX,X1"
+		if strings.Contains(op, "EXTR") {
+			row = op + " $1,X1,AX"
+		} else if op[0] == 'V' {
+			row += ",X2"
+		}
+		for _, mutate := range []string{"float", "unresolved", "suffix", "mask", "vector-kind", "gp-byte"} {
+			t.Run(op+"/"+mutate, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				switch mutate {
+				case "float":
+					ins.Args[0].ImmIsFloat = true
+				case "unresolved":
+					ins.Args[0].ImmRaw = "missing"
+				case "suffix":
+					ins.Op += ".Z"
+				case "mask":
+					ins.Args = append(ins.Args, Operand{Kind: OpReg, Reg: "K1"})
+				case "vector-kind":
+					ins.Args[2].Reg = "Y1"
+				case "gp-byte":
+					if strings.Contains(op, "EXTR") {
+						ins.Args[len(ins.Args)-1].Reg = "AL"
+					} else {
+						ins.Args[1].Reg = "AL"
+					}
+				}
+				if _, known, err := x86ScalarLaneProperties(ins, "amd64"); !known || err == nil {
+					t.Fatal("invalid form acquired typed effect", ins)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarLaneGoImmediateClassBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ", "PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ", "VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ"} {
+			insert, vector := strings.Contains(op, "INSR"), op[0] == 'V'
+			for _, value := range []int64{-129, -128, -1, 0, 255, 256, 1 << 32, 1<<32 + 255, -(1 << 32), 1<<32 - 128} {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, op, value), func(t *testing.T) {
+					row := fmt.Sprintf("%s $%d,X0,AX", op, value)
+					if insert {
+						row = fmt.Sprintf("%s $%d,AX,X0", op, value)
+						if vector {
+							row += ",X1"
+						}
+					}
+					classified := value
+					if arch == "386" {
+						classified = int64(int32(value))
+					}
+					minimum := int64(0) // Complete legacy and V-insert Yu8 rows.
+					if vector && !insert {
+						minimum = -128 // Complete low-X VEX extract Yi8 rows.
+					}
+					accepted := classified >= minimum && classified <= 255 &&
+						!(arch == "386" && (insert && vector || !vector && op[len(op)-1] == 'Q'))
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", accepted)
+					ins := x86ScalarLaneInstruction(t, row)
+					form, known, err := x86ScalarLaneProperties(ins, arch)
+					if !known || (err == nil) != accepted || accepted && form.offset != int(byte(value))%(128/form.bits)*(form.bits/8) {
+						t.Fatalf("actual Go class/typed lane disagreement: %+v known=%t err=%v", form, known, err)
+					}
+					if ins.Args[0].Imm != value {
+						t.Fatal("class observation changed the original source operand")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_lane_fp.go b/amd64_scalar_lane_fp.go
new file mode 100644
index 000000000..23599b9a1
--- /dev/null
+++ b/amd64_scalar_lane_fp.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+)
+
+// A narrow lane's FP bytes are independent logical numeric fields. This is
+// neither physical frame backing nor a pointer/padding permission. Unlike
+// native memory, these separately allocated fields cannot be read as a wide
+// first-slot load. Every new narrow view also consumes the whole-source proof.
+func (c *amd64Ctx) scalarLaneFPSpan(off int64, bits int) error {
+	if bits == 32 || bits == 64 {
+		_, err := c.scalarFPSpan(off, bits)
+		return err
+	}
+	fail := func() error {
+		return fmt.Errorf("%w: scalar-lane FP byte span +%d/%d lacks complete numeric fields", ErrProbeNeedsContext, off, bits)
+	}
+	if bits != 8 && bits != 16 || off < 0 || off > math.MaxInt64-int64(bits/8) {
+		return fail()
+	}
+	for current := off; current < off+int64(bits/8); current++ {
+		matches := 0
+		for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.fpResults} {
+			for _, slot := range slots {
+				width := x86FrameTypeSize(slot.Type)
+				if width <= 0 || slot.Offset < 0 || slot.Offset > math.MaxInt64-width {
+					return fail()
+				}
+				if current >= slot.Offset && current < slot.Offset+width {
+					if slot.Type != I8 && slot.Type != I16 && slot.Type != I32 && slot.Type != I64 && slot.Type != "float" && slot.Type != "double" {
+						return fail()
+					}
+					matches++
+				}
+			}
+		}
+		if matches != 1 {
+			return fail()
+		}
+	}
+	return nil
+}
+
+func (c *amd64Ctx) loadScalarLaneFPBits(off int64, bits int) (string, error) {
+	if bits >= 32 {
+		return c.loadScalarFPBits(off, bits)
+	}
+	if err := c.scalarLaneFPSpan(off, bits); err != nil {
+		return "", err
+	}
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return "", err
+	}
+	bytes, err := c.loadFPVectorBytes(off, bits/8)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, bits/8, bytes, bits)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeScalarLaneFPBits(off int64, bits int, value string) error {
+	if bits >= 32 {
+		return c.storeScalarFPBits(off, bits, value)
+	}
+	if err := c.scalarLaneFPSpan(off, bits); err != nil {
+		return err
+	}
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return err
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to <%d x i8>\n", bytes, bits, value, bits/8)
+	return c.storeFPVectorBytes(off, bits/8, "%"+bytes, "")
+}
diff --git a/amd64_scalar_lane_mode32_test.go b/amd64_scalar_lane_mode32_test.go
new file mode 100644
index 000000000..1cd7800f5
--- /dev/null
+++ b/amd64_scalar_lane_mode32_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// The Go name retains W=1, but physical non-64-bit execution ignores that
+// bit. Bind the source encoder independently from the effective byte effect.
+func TestX86ScalarLaneMode32QUsesActualDwordEncoding(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, destination := range []string{"AX", "1(BX)"} {
+		for _, immediate := range []int{0, 1, 2, 3, 128, 255, -1, -128} {
+			t.Run(fmt.Sprintf("%s/%d", destination, immediate), func(t *testing.T) {
+				row := fmt.Sprintf("VPEXTRQ $%d,X0,%s", immediate, destination)
+				code := assembleX87ControlBytes(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				if len(code) < 7 || code[0] != 0xc4 || code[1] != 0xe3 || code[2] != 0xf9 || code[3] != 0x16 || code[len(code)-1] != 0xc3 {
+					t.Fatalf("actual Go W1 source bytes changed: %x", code)
+				}
+				var input strings.Builder
+				for _, value := range code[:len(code)-1] {
+					fmt.Fprintf(&input, "%#02x ", value)
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=i386-unknown-linux-gnu", "--mattr=+avx")
+				command.Stdin = strings.NewReader(input.String())
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				cancel()
+				// LLVM22 spells W1 as Q even for the i386 triple (and prints
+				// RAX for the register operand). This is an encoding observer,
+				// not a physical-width authority or native mode32 execution.
+				if err != nil || !strings.Contains(string(output), fmt.Sprintf("vpextrq\t$%d, %%xmm0,", byte(immediate))) || strings.Contains(string(output), "warning:") {
+					t.Fatalf("LLVM22 exact W1 encoding observation: %v\n%s", err, output)
+				}
+				dword := assembleX87ControlBytes(t, "386", "TEXT f(SB),4,$0-0\n"+strings.Replace(row, "VPEXTRQ", "VPEXTRD", 1)+"\nRET\n")
+				withoutW := append([]byte(nil), code...)
+				withoutW[2] &^= 0x80
+				if string(withoutW) != string(dword) {
+					t.Fatalf("actual Go Q/D bytes differ outside the ignored W bit: %x / %x", code, dword)
+				}
+				// Intel SDM Vol2 PEXTRB/PEXTRD/PEXTRQ, note2 and operation:
+				// non-64-bit W is ignored, with imm[1:0] and r32/m32.
+				for _, ins := range []Instr{x86ScalarLaneInstruction(t, row), func() Instr {
+					fn, err := decodeX86RawDirectives(rawX86Function(code), "386")
+					if err != nil || len(fn.Instrs) != 2 {
+						t.Fatalf("complete physical byte decode: %v %+v", err, fn)
+					}
+					return fn.Instrs[0]
+				}()} {
+					form, known, err := x86ScalarLaneProperties(ins, "386")
+					if err != nil || !known || form.bits != 32 || form.gpBits != 32 || form.offset != int(byte(immediate)&3)*4 {
+						t.Fatalf("source/raw effective WIG lane differs from native bytes: %+v known=%t err=%v", form, known, err)
+					}
+					if destination != "AX" {
+						width, write, valid := x86InstructionMemoryShape(ins, 2, "386")
+						if !valid || !write || width != 4 {
+							t.Fatal("physical memory effect was widened", width, write, valid)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarLaneMode32QResultBytesThreeAPIs(t *testing.T) {
+	for _, target := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, memory := range []bool{false, true} {
+			for lane := 0; lane < 4; lane++ {
+				t.Run(fmt.Sprintf("%s/memory=%t/lane=%d", target, memory, lane), func(t *testing.T) {
+					body := fmt.Sprintf("PINSRD $%d,k+0(FP),X0\nVPEXTRQ $%d,X0,AX\nMOVL AX,ret+4(FP)\n", lane, lane)
+					if memory {
+						body = fmt.Sprintf("PINSRD $%d,k+0(FP),X0\nVPEXTRQ $%d,X0,ret+4(FP)\n", lane, lane)
+					}
+					source := "TEXT ·view(SB),4,$0-8\n" + body + "RET\n"
+					goAssemblerOracleOutput(t, "386", source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k uint32) uint32\n", "386", target, api)
+						if err != nil || !strings.Contains(ir, "extractelement <4 x i32>") || strings.Contains(ir, "extractelement <2 x i64>") {
+							t.Fatalf("%s observes an unknown Q lane/overwrites adjacent result bytes: %v\n%s", api, err, ir)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target, "wig.ll", "wig.o", ir)
+					}
+					// A four-byte insertion cannot define any other dword.
+					bad := strings.Replace(source, fmt.Sprintf("PINSRD $%d", lane), fmt.Sprintf("PINSRD $%d", (lane+1)&3), 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, bad, "func view(k uint32) uint32\n", "386", target, api); err == nil || ir != "" {
+							t.Fatalf("%s changed lane granted unknown bytes: %v", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_lane_native_result_test.go b/amd64_scalar_lane_native_result_test.go
new file mode 100644
index 000000000..4bff74ddf
--- /dev/null
+++ b/amd64_scalar_lane_native_result_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent enumeration of Go's scalar memory insertion families. Their
+// complete encoder rows/attributes have separate original-Go table oracles.
+var x86ScalarLaneNativeOracle = []struct {
+	op, extract string
+	width       int
+}{
+	{"PINSRB", "PEXTRB $255", 1},
+	{"PINSRW", "PEXTRW $255", 2},
+	{"PINSRD", "PEXTRD $255", 4},
+	{"PINSRQ", "PEXTRQ $255", 8},
+	{"VPINSRB", "VPEXTRB $255", 1},
+	{"VPINSRW", "VPEXTRW $255", 2},
+	{"VPINSRD", "VPEXTRD $255", 4},
+	{"VPINSRQ", "VPEXTRQ $255", 8},
+	{"INSERTPS", "PEXTRD $1", 4},
+	{"VINSERTPS", "VPEXTRD $1", 4},
+}
+
+func x86ScalarLaneNativeFixture(name, arch, op, extract, address string, high bool) (string, string) {
+	word, move, typ := 8, "MOVQ", "uint64"
+	if arch == "386" {
+		word, move, typ = 4, "MOVL", "uint32"
+	}
+	base, destination := "X0", "X0"
+	if strings.HasPrefix(op, "V") {
+		destination = "X1"
+		if high {
+			base, destination = "X16", "X17"
+		}
+	}
+	immediate := 255
+	if strings.HasSuffix(op, "PS") {
+		immediate = 0xd0 // Memory ignores source selector; insert into lane one.
+	}
+	row := fmt.Sprintf("%s $%d,%s,%s", op, immediate, address, base)
+	if strings.HasPrefix(op, "V") {
+		row += "," + destination
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DX\nMOVL $1,BX\n%s\n%s,%s,AX\n%s AX,ret+%d(FP)\nRET\n",
+		name, 2*word, move, row, extract, destination, move, word)
+	return source, fmt.Sprintf("func %s(p *[8]byte) %s\n", name, typ)
+}
+
+func TestX86ScalarLaneNativeResultsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86ScalarLaneNativeOracle {
+				if target.arch == "386" && (row.width == 8 || strings.HasPrefix(row.op, "V")) {
+					asm, _ := x86ScalarLaneNativeFixture("Rejected", target.arch, row.op, row.extract, "(DX)", false)
+					goAssemblerOracleOutput(t, target.arch, asm, "", false)
+					continue // Actual Go rejection, not a skipped supported target.
+				}
+				for _, address := range []string{"(DX)", "-1(DX)(BX*1)"} {
+					for _, high := range []bool{false, true} {
+						if high && !strings.HasPrefix(row.op, "V") {
+							continue
+						}
+						asm, decl := x86ScalarLaneNativeFixture(fmt.Sprintf("F%d", count), target.arch, row.op, row.extract, address, high)
+						source.WriteString(asm)
+						declarations.WriteString(decl)
+						count++
+					}
+				}
+			}
+			want := 30
+			if target.arch == "386" {
+				want = 8
+			}
+			if count != want {
+				t.Fatal("incomplete native insertion matrix", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("native scalar-lane read lost its conditional result:", err)
+					}
+					if strings.Count(ir, "load volatile i") != count {
+						t.Fatal("missing paired native scalar reads")
+					}
+					compileLLVMToObject(t, llc, target.triple, "scalar-lane-native.ll", "scalar-lane-native.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarLaneNativeResultsKeepStandaloneAndUnknownBoundaries(t *testing.T) {
+	for _, row := range x86ScalarLaneNativeOracle {
+		t.Run(row.op, func(t *testing.T) {
+			source, decl := x86ScalarLaneNativeFixture("Value", "amd64", row.op, row.extract, "(DX)", false)
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", strings.TrimSpace(decl),
+				strings.ReplaceAll(strings.SplitN(source, "\n", 2)[1], "ret+8(FP)", "ret0+8(FP)"))
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone observer acquired native memory", err)
+				}
+			}
+			for name, address := range map[string]string{
+				"unknown base": "(DI)", "unknown index": "(DX)(SI*1)",
+				"pointer index": "(DX)(DX*1)", "virtual frame": "(SP)",
+				"unbound symbol": "·external(SB)",
+			} {
+				t.Run(name, func(t *testing.T) {
+					bad, declaration := x86ScalarLaneNativeFixture("Value", "amd64", row.op, row.extract, address, false)
+					goAssemblerOracleOutput(t, "amd64", bad, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						if _, err := x86ScalarFPBitViewAPI(t, bad, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unknown address acquired result bytes", api, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarLaneNativeResultBytesAndOrigins(t *testing.T) {
+	for _, row := range x86ScalarLaneNativeOracle {
+		t.Run(row.op, func(t *testing.T) {
+			source, _ := x86ScalarLaneNativeFixture("Value", "amd64", row.op, row.extract, "-1(DX)(BX*1)", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[3]
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			base, _, _ := x86ResultGP(DX, 8, "amd64")
+			index, _, _ := x86ResultGP(BX, 8, "amd64")
+			state.pointerGP[base], state.gp[index] = true, 0xff
+			state.writeVector(0, 64, 0x0123456789ab0080, false)
+			state.writeVector(1, 64, 0xfedcba9876540000, false)
+			before := state.clone()
+			ok, known := x86ResultScalarLaneStepWithRead(ins, &state, nil, 0, "amd64", true)
+			destination, offset := 0, 16-row.width
+			if strings.HasSuffix(row.op, "PS") {
+				offset = 4
+			}
+			lane := ((uint64(1) << uint(row.width)) - 1) << uint(offset)
+			want := uint64(0x80) | lane
+			if strings.HasPrefix(row.op, "V") {
+				destination = 1
+				want |= ^uint64(0xffff)
+			} else {
+				want |= uint64(0x0123456789ab0000)
+			}
+			if !ok || !known || state.vectorBytes(destination) != want || state.flags != before.flags ||
+				state.gp != before.gp || state.pointerGP != before.pointerGP {
+				t.Fatalf("native insertion changed unrelated defined bytes: accepted=%t known=%t got=%x want=%x", ok, known, state.vectorBytes(destination), want)
+			}
+			for _, mutation := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment"} {
+				changed, rejected := ins, before.clone()
+				switch mutation {
+				case "decoded":
+					changed.x86Encoded = true
+				case "raw":
+					changed.x86SourceRaw = new(x86SourceRawInstruction)
+				case "raw return":
+					changed.x86RawNearReturn = new(x86RawNearReturnForm)
+				case "address":
+					changed.x86AddressBits = 32
+				case "unbound address":
+					changed.x86UnboundAddressOverride = true
+				case "segment":
+					changed.x86SegmentPrefix = 0x64
+				}
+				if accepted, _ := x86ResultScalarLaneStepWithRead(changed, &rejected, nil, 0, "amd64", true); accepted || !reflect.DeepEqual(rejected, before) {
+					t.Fatal("unbound instruction origin acquired native result bytes", mutation)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarLaneNativeResultsKeepWholeSourceBoundaries(t *testing.T) {
+	for _, row := range x86ScalarLaneNativeOracle {
+		t.Run(row.op, func(t *testing.T) {
+			source, decl := x86ScalarLaneNativeFixture("Value", "amd64", row.op, row.extract, "(DX)", false)
+			destination := "X0"
+			if strings.HasPrefix(row.op, "V") {
+				destination = "X1"
+			}
+			extract := row.extract + "," + destination + ",AX"
+			missing := strings.Replace(source, row.op+" $", "CMPL BX,$0\nJE after\n"+row.op+" $", 1)
+			missing = strings.Replace(missing, extract, "after:\n"+extract, 1)
+			for name, bad := range map[string]string{
+				"unknown lane":         strings.Replace(source, extract, "PEXTRD $0,"+destination+",AX", 1),
+				"lost pointer":         strings.Replace(source, row.op+" $", "MOVL $1,DX\n"+row.op+" $", 1),
+				"missing path":         missing,
+				"unknown native store": strings.Replace(source, extract, row.extract+","+destination+",(DI)\n"+extract, 1),
+				"incoming write":       strings.Replace(source, extract, "MOVQ $42,p+0(FP)\n"+extract, 1),
+			} {
+				t.Run(name, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "amd64", bad, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, bad, decl, "amd64", "x86_64-unknown-linux-gnu", api)
+						if name == "lost pointer" {
+							if err != nil || x86NumericNativeVolatileReadBytes(t, ir) != row.width {
+								t.Fatal("insertion lost its exact numeric-address read", api, err)
+							}
+							x86RequireNumericNativeSourceContext(t, bad, decl, "amd64")
+							x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+						} else if name == "unknown lane" || name == "missing path" {
+							x86VectorScratchCodegenControl(t, bad, decl, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+							if x86NumericNativeVolatileReadBytes(t, ir) != row.width {
+								t.Fatal("scratch insertion changed its original native read width", api)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("native insertion widened another source contract", api, err)
+						}
+					}
+				})
+			}
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", strings.TrimSpace(decl),
+				strings.ReplaceAll(strings.SplitN(source, "\n", 2)[1], "ret+8(FP)", "ret0+8(FP)"))
+			for _, origin := range []string{"raw TEXT", "source stack", "fixed local"} {
+				fn := file.Funcs[0]
+				switch origin {
+				case "raw TEXT":
+					fn.X86RawText = []byte{0xc3}
+				case "source stack":
+					fn.x86SourceStack = new(x86SourceStackProof)
+				case "fixed local":
+					fn.x86FixedLocal = new(x86FixedLocalProof)
+				}
+				ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+				if err := ctx.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("native insertion bypassed original entry boundary", origin, err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_lane_native_runtime_unix_test.go b/amd64_scalar_lane_native_runtime_unix_test.go
new file mode 100644
index 000000000..cf6c0c868
--- /dev/null
+++ b/amd64_scalar_lane_native_runtime_unix_test.go
@@ -0,0 +1,181 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// VEX/EVEX numerical results use the independent original legacy SSE operation
+// as reference. This is not native AVX512 execution or an upper-alias oracle;
+// the separate complete-byte runtime root owns the alias axis.
+func TestCrossLinuxRuntimeMatrixX86ScalarLaneNativeResultsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	for _, row := range x86ScalarLaneNativeOracle {
+		for discarded := 0; discarded < 3; discarded++ {
+			if discarded == 2 && !strings.HasSuffix(row.op, "PS") {
+				continue // The zero-selector axis belongs only to INSERTPS.
+			}
+			name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+			asm, decl := x86ScalarLaneNativeFixture(name, "amd64", row.op, row.extract, "-1(DX)(BX*1)", false)
+			immediate := 255
+			if strings.HasSuffix(row.op, "PS") && discarded != 2 {
+				immediate = 0xd0
+			}
+			if discarded == 2 {
+				asm = strings.Replace(asm, "$208,", "$255,", 1)
+			}
+			native := fmt.Sprintf("%s $%d,(DI),X0\n%s,X0,AX\n",
+				strings.TrimPrefix(row.op, "V"), immediate, strings.TrimPrefix(row.extract, "V"))
+			if discarded == 1 {
+				asm = strings.Replace(asm, "MOVQ AX,ret+8(FP)", "MOVQ $0x87654321fedcba98,AX\nMOVQ AX,ret+8(FP)", 1)
+				native += "MOVQ $0x87654321fedcba98,AX\n"
+			}
+			source.WriteString(asm)
+			declarations.WriteString(decl)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+native+"RET\n")
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+			fmt.Fprintf(&rows, "{%s,%s,%d,%d},\n", name, original, row.width, discarded)
+			count++
+		}
+	}
+	if count != 22 {
+		t.Fatal("incomplete live/dead/zero scalar insertion family", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	driver := fmt.Sprintf(x86NativeScalarReadRuntimeC, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "scalar-lane-native", text, driver, level)
+					if string(output) != "22 native scalar kernels: numerical 2816, faults 264, tripwires 2; failures 0\n" {
+						t.Fatal("original/LLVM scalar insertion results or read widths differ:", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+// Scalar insertion, widening and GP/X transfer regressions share only their byte-read
+// reference and process/fault harness, not their generated Go/LLVM programs.
+const x86NativeScalarReadRuntimeC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+%s
+%s
+typedef uint64_t (*Program)(const uint8_t*);
+typedef struct {
+    Program translated, original;
+    unsigned width, discarded;
+    unsigned input_bytes, output_bytes;
+} Kernel;
+static const Kernel kernels[] = {%s};
+
+static uint64_t reference(Kernel k, const uint8_t *p) {
+    if (k.discarded == 1) return UINT64_C(0x87654321fedcba98);
+    if (k.discarded == 2) return 0;
+    uint64_t value = 0;
+    if (k.output_bytes) {
+        for (unsigned b = 0; b < 8; b++) {
+            unsigned part = b %% k.output_bytes;
+            if (part < k.input_bytes) {
+                unsigned source = b / k.output_bytes * k.input_bytes + part;
+                value |= (uint64_t)p[source] << (8*b);
+            }
+        }
+        return value;
+    }
+    for (unsigned b = 0; b < k.width; b++) value |= (uint64_t)p[b] << (8*b);
+    return value;
+}
+
+static int fault(Program run, const uint8_t *p) {
+    pid_t child = fork();
+    if (child < 0) return -1;
+    if (child == 0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        volatile uint64_t result = run(p);
+        (void)result;
+        _exit(0);
+    }
+    int status = 0;
+    if (waitpid(child, &status, 0) != child) return -2;
+    if (WIFEXITED(status)) return WEXITSTATUS(status) ? -3 : 0;
+    if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGSEGV || WTERMSIG(status) == SIGBUS)) return 1;
+    return -4;
+}
+
+static uint64_t missing_read(const uint8_t *p) { (void)p; return 0; }
+static uint64_t too_wide(const uint8_t *p) { return *(volatile const uint64_t*)p; }
+
+int main(void) {
+    long page = sysconf(_SC_PAGESIZE);
+    if (page < 128) return 1;
+    uint8_t *memory = mmap(0, 2*page, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+    if (memory == MAP_FAILED || mprotect(memory+page, page, PROT_NONE)) return 2;
+    memset(memory, 0xa7, page);
+    if (fault(missing_read, NULL) != 0 || fault(too_wide, memory+page-4) != 1) return 3;
+
+    unsigned numerical = 0, faults = 0;
+    for (unsigned i = 0; i < sizeof(kernels)/sizeof(kernels[0]); i++) {
+        Kernel k = kernels[i];
+        for (unsigned pattern = 0; pattern < 64; pattern++) {
+            uint8_t bytes[64], before[64];
+            for (unsigned b = 0; b < sizeof(bytes); b++) bytes[b] = (uint8_t)(pattern*37+b*11);
+            memcpy(before, bytes, sizeof(bytes));
+            const uint8_t *p = bytes+(pattern&1);
+            uint64_t want = reference(k, p);
+            if (k.original(p) != want || k.translated(p) != want || memcmp(bytes, before, sizeof(bytes))) {
+                fprintf(stderr, "kernel %%u pattern %%u expected %%llx\n", i, pattern, (unsigned long long)want);
+                return 4;
+            }
+            numerical += 2;
+        }
+        for (unsigned address = 0; address < 6; address++) {
+            unsigned available[] = {0, 0, k.width ? k.width-1 : 0, k.width, k.width+1, 0};
+            const uint8_t *p = address == 0 ? NULL : address == 5 ? memory+1 : memory+page-available[address];
+            int want = k.width != 0 && address < 3;
+            if (fault(k.original, p) != want || fault(k.translated, p) != want) {
+                fprintf(stderr, "kernel %%u address %%u expected fault %%d\n", i, address, want);
+                return 5;
+            }
+            faults += 2;
+        }
+    }
+    if (munmap(memory, 2*page)) return 6;
+    printf("%%zu native scalar kernels: numerical %%u, faults %%u, tripwires 2; failures 0\n",
+           sizeof(kernels)/sizeof(kernels[0]), numerical, faults);
+    return 0;
+}
+`
diff --git a/amd64_scalar_lane_native_store_test.go b/amd64_scalar_lane_native_store_test.go
new file mode 100644
index 000000000..f6e26bfc6
--- /dev/null
+++ b/amd64_scalar_lane_native_store_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This inventory is independent of the implementation dispatch maps. Complete
+// encoder attributes remain owned by the scalar-lane and PS Go-table oracles.
+func x86ScalarLaneNativeStoreRows(arch string) []struct {
+	op       string
+	width    int
+	selector int
+} {
+	var rows []struct {
+		op       string
+		width    int
+		selector int
+	}
+	for _, vector := range []bool{false, true} {
+		for index, width := range []int{1, 2, 4, 8} {
+			if arch == "386" && !vector && width == 8 {
+				continue // The independent Go-table oracle owns this rejected row.
+			}
+			op := "PEXTR" + []string{"B", "W", "D", "Q"}[index]
+			if vector {
+				op = "V" + op
+			}
+			if arch == "386" && width == 8 {
+				width = 4 // Physical VEX.WIG, not a qword store then truncation.
+			}
+			rows = append(rows, struct {
+				op       string
+				width    int
+				selector int
+			}{op, width, 255})
+		}
+		op, selector := "EXTRACTPS", 3
+		if vector {
+			op, selector = "VEXTRACTPS", 255
+		}
+		rows = append(rows, struct {
+			op       string
+			width    int
+			selector int
+		}{op, 4, selector})
+	}
+	return rows
+}
+
+func TestX86ScalarLaneNativeStoresSelectedBytesAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86ScalarLaneNativeStoreRows(arch)
+		if len(rows) != map[string]int{"amd64": 10, "386": 9}[arch] {
+			t.Fatal("incomplete independent scalar native store inventory", arch, len(rows))
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,X1,-1(BX)(CX*2)", row.op, row.selector))
+				selected := x86CallerVectorByteMask(int64(row.width)) << uint(16-row.width)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.pointerGP[3] = true
+				state.gp[1] = uint8(1)<<uint(x86ResultPointerWord(arch)) - 1
+				state.writeVector(1, 64, selected, false)
+				before := state.clone()
+				accepted, known := x86ResultScalarLaneStepWithRead(ins, &state, nil, 0, arch, true)
+				if !accepted || !known || !reflect.DeepEqual(state, before) {
+					t.Fatal("paired scalar store must consume only selected bytes without creating state", accepted, known)
+				}
+				if accepted, _ := x86ResultScalarLaneStep(ins, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone observer acquired native store permission")
+				}
+				for missing := 0; missing < 16; missing++ {
+					changed := before.clone()
+					changed.writeVector(1, 64, selected&^(uint64(1)<<uint(missing)), false)
+					original := changed.clone()
+					accepted, known := x86ResultScalarLaneStepWithRead(ins, &changed, nil, 0, arch, true)
+					if !known || accepted != (missing < 16-row.width) || !reflect.DeepEqual(changed, original) {
+						t.Fatal("selected-byte dependency widened or missing input was invented", missing, accepted, known)
+					}
+				}
+				for _, mutation := range []string{"pointer", "index", "pointer-index", "encoded", "raw", "address", "unbound-address", "segment", "raw-return", "float", "unresolved"} {
+					changed, input := ins, before.clone()
+					changed.Args = append([]Operand(nil), ins.Args...)
+					switch mutation {
+					case "pointer":
+						input.pointerGP[3] = false
+					case "index":
+						input.gp[1] >>= 1
+					case "pointer-index":
+						input.pointerGP[1] = true
+						input.gp[1] = 0 // An actual opaque-pointer import revokes NUM bytes.
+					case "encoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "address":
+						changed.x86AddressBits = 32
+					case "unbound-address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "raw-return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "float":
+						changed.Args[0].ImmIsFloat = true
+					case "unresolved":
+						changed.Args[0].ImmRaw = "UNKNOWN"
+					}
+					original := input.clone()
+					if accepted, _ := x86ResultScalarLaneStepWithRead(changed, &input, nil, 0, arch, true); accepted || !reflect.DeepEqual(input, original) {
+						t.Fatal("unproved origin/address/selector acquired a native store", mutation)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarLaneNativeStoresFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			var source, declarations strings.Builder
+			counts := make(map[int]int)
+			for index, row := range x86ScalarLaneNativeStoreRows(target.arch) {
+				name := fmt.Sprintf("Store%d", index)
+				fmt.Fprintf(&declarations, "func %s(out,input *byte)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),BX\n%s input+%d(FP),DX\nMOVL $1,CX\nMOVUPS (DX),X1\n%s $%d,X1,-1(BX)(CX*2)\n%s $%d,X1,-1(BX)(CX*2)\nRET\n",
+					name, 2*word, move, move, word, row.op, row.selector, row.op, row.selector)
+				counts[row.width] += 2
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original scalar store family rejected", err)
+					}
+					for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for width, count := range counts {
+							if strings.Count(input, fmt.Sprintf("store volatile i%d ", width*8)) != count {
+								t.Fatal("exact overwritten native stores were removed or widened", width, count)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "scalar-native-stores.ll", "scalar-native-stores.o", input)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarLaneNativeStoreVoidRequiresSelectedInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, row := range x86ScalarLaneNativeStoreRows(target.arch) {
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool=%t", target.triple, row.op, unused), func(t *testing.T) {
+					declaration, extent := "func Value(out *byte)", word
+					if unused {
+						declaration, extent = "func Value(out *byte,unused bool)", word+1
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),BX\n%s $%d,X1,(BX)\nRET\n", extent, move, row.op, row.selector)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if target.arch == "amd64" {
+							x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+							if strings.Count(ir, fmt.Sprintf("store volatile i%d ", row.width*8)) != 1 {
+								t.Fatal("scratch source changed the selected native store width", api)
+							}
+							continue
+						}
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool invented selected vector bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_lane_objects_test.go b/amd64_scalar_lane_objects_test.go
new file mode 100644
index 000000000..dd3d10c2d
--- /dev/null
+++ b/amd64_scalar_lane_objects_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarLaneExtractAllDeclaredWidthsThreeAPIObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, prefix := range []string{"", "V"} {
+			for _, size := range []struct {
+				suffix, typ string
+				width       int
+			}{{"B", "uint8", 1}, {"W", "uint16", 2}, {"D", "uint32", 4}, {"Q", "uint64", 8}} {
+				if target.arch == "386" && prefix == "" && size.suffix == "Q" {
+					continue
+				} // Go absent legacy Q; explicit rejection root remains.
+				op := prefix + "PEXTR" + size.suffix
+				t.Run(target.triple+"/"+op, func(t *testing.T) {
+					width, typ := size.width, size.typ
+					if target.arch == "386" && op == "VPEXTRQ" {
+						width, typ = 4, "uint32" // Actual non-64-bit WIG effect.
+					}
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVQ h+8(FP),X0\n%s $255,X0,ret+16(FP)\nRET\n", 16+width, op)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(k,h uint64) "+typ+"\n", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatalf("%s independent typed result bytes: %v", api, err)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "extract.ll", "extract.o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneNativeWidthsVolatileFiveTargets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"PINSRB", "PINSRW", "PINSRD", "PINSRQ", "VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ", "PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ", "VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ"} {
+			insert := strings.Contains(op, "INSR")
+			if target.arch == "386" && (op == "PINSRQ" || op == "PEXTRQ" || insert && op[0] == 'V') {
+				continue
+			}
+			bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+			if target.arch == "386" && op == "VPEXTRQ" {
+				bits = 32
+			}
+			for _, mem := range []string{"3(AX)", "8(AX)(BX*2)", "0(FS)", "0(GS)"} {
+				t.Run(target.triple+"/"+op+"/"+mem, func(t *testing.T) {
+					row := op + " $255," + mem + ",X0"
+					if !insert {
+						row = op + " $255,X0," + mem
+					} else if op[0] == 'V' {
+						row += ",X1"
+					}
+					source := "TEXT ·view(SB),4,$0-0\n" + row + "\nRET\n"
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					if !insert {
+						// Keep every original native/segment spelling and width.
+						// Unknown source bytes/addresses are Context, not a public
+						// initialized store; the independent matrix owns that axis.
+						ir := x86UnboundVoidScalarFormatObject(t, source, "view", target.arch, target.triple)
+						if !strings.Contains(ir, fmt.Sprintf("store volatile i%d", bits)) {
+							t.Fatal("original extraction format lost its exact native write")
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "native-width.ll", "native-width.o", ir)
+						return
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", target.arch, target.triple, api)
+						if err != nil {
+							t.Fatalf("%s native memory grammar: %v", api, err)
+						}
+						effect := "load volatile"
+						if !insert {
+							effect = "store volatile"
+						}
+						if !strings.Contains(ir, fmt.Sprintf("%s i%d", effect, bits)) {
+							t.Fatal("lost original physical width/dead side effect", api, op)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "native-width.ll", "native-width.o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneMode32HighBanksAndNamedQKeepContext(t *testing.T) {
+	for _, op := range []string{"VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ"} {
+		for _, index := range []int{8, 15, 16, 31} {
+			source := fmt.Sprintf("TEXT ·view(SB),4,$0-0\n%s $1,X%d,AX\nRET\n", op, index)
+			goAssemblerOracleOutput(t, "386", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", "386", "i386-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("named Go bytes granted impossible physical mode32 bank: %s %v", api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarLaneFPDoesNotGrantPointerPaddingOrPartialResults(t *testing.T) {
+	for _, tc := range []struct {
+		decl, body      string
+		ordinaryCodegen bool
+	}{
+		{"func view(k *byte) uint32\n", "PINSRB $0,k+0(FP),X0\nMOVL X0,ret+8(FP)\n", false},
+		{"func view(a byte,b uint32) uint32\n", "PINSRW $0,hole+1(FP),X0\nMOVL X0,ret+8(FP)\n", false},
+		{"func view(k uint64) uint64\n", "MOVQ k+0(FP),X0\nPEXTRB $0,X0,ret+8(FP)\n", false},
+		{"func view(k uint32) uint32\n", "PINSRD $1,k+0(FP),X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+8(FP)\n", true},
+		{"func view(k uint32) uint32\n", "PINSRD $0,BX,X0\nMOVL k+0(FP),AX\nMOVL AX,ret+8(FP)\n", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			source := "TEXT ·view(SB),4,$0-24\n" + tc.body + "RET\n"
+			ir, err := x86ScalarFPBitViewAPI(t, source, tc.decl, "amd64", "x86_64-unknown-linux-gnu", api)
+			if tc.ordinaryCodegen {
+				x86VectorScratchCodegenControl(t, source, tc.decl, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				continue
+			}
+			if err == nil || ir != "" {
+				t.Fatalf("unproved FP/mixed/unused input acquired initialization: %s %v", api, err)
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_lane_original_go_test.go b/amd64_scalar_lane_original_go_test.go
new file mode 100644
index 000000000..ffaf2b9ba
--- /dev/null
+++ b/amd64_scalar_lane_original_go_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The original stock-Go program contains legacy SSE only. Its full immediate,
+// real m8/m16/m32/m64 accesses, flags and input/output canaries are independent
+// of the translator. Rosetta is diagnostic; native Linux remains its own axis.
+func TestCrossLinuxRuntimeMatrixX86ScalarLaneOriginalGo(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var assembly, declarations, checks strings.Builder
+	declarations.WriteString("package oracle\n")
+	count := 0
+	for _, bits := range []int{8, 16, 32, 64} {
+		for _, insert := range []bool{false, true} {
+			for _, memory := range []bool{false, true} {
+				for lane := 0; lane < 128/bits; lane++ {
+					name := fmt.Sprint("Lane", count)
+					count++
+					fmt.Fprintf(&declarations, "func %s(out,in *[96]byte,seed uint64)\n", name)
+					fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ seed+16(FP),CX\nMOVUPS (BX),X0\nMOVUPS (AX),X1\nMOVQ $-1,R11\nSTMXCSR 76(AX)\nCMPQ AX,AX\nSTC\n", name)
+					op := "P"
+					if insert {
+						op += "INSR"
+					} else {
+						op += "EXTR"
+					}
+					op += map[int]string{8: "B", 16: "W", 32: "D", 64: "Q"}[bits]
+					if insert {
+						operand := "CX"
+						if memory {
+							operand = "3(BX)"
+						}
+						fmt.Fprintf(&assembly, "%s $%d,%s,X1\nMOVUPS X1,(AX)\n", op, lane, operand)
+					} else {
+						operand := "R11"
+						if memory {
+							operand = "3(AX)"
+						}
+						fmt.Fprintf(&assembly, "%s $%d,X0,%s\n", op, lane, operand)
+						if !memory {
+							assembly.WriteString("MOVQ R11,64(AX)\n")
+						}
+					}
+					assembly.WriteString("SETCS 72(AX)\nSETNE 73(AX)\nSTMXCSR 80(AX)\nRET\n")
+					fmt.Fprintf(&checks, "check(t,%s,%d,%d,%t,%t)\n", name, bits/8, lane, insert, memory)
+				}
+			}
+		}
+	}
+	if count != 120 {
+		t.Fatal("original legacy scalar-lane denominator", count)
+	}
+	const tests = `package oracle
+import("testing";"encoding/binary";"runtime")
+func check(t *testing.T,fn func(*[96]byte,*[96]byte,uint64),width,lane int,insert,memory bool){
+ for sample:=0;sample<257;sample++{
+  var input,output [96]byte
+  for i:=range input{input[i]=byte(i*37+sample*71);output[i]=byte(i*19+sample*13)}
+  before,want:=input,output
+  seed:=[4]uint64{0,^uint64(0),0x9876fedcba543210,0x8000000000000001}[sample%4]
+  if insert{
+   for i:=0;i<width;i++{v:=byte(seed>>uint(i*8));if memory{v=input[3+i]};want[lane*width+i]=v}
+  }else if memory{copy(want[3:3+width],input[lane*width:lane*width+width])
+  }else{var value uint64;for i:=0;i<width;i++{value|=uint64(input[lane*width+i])<<uint(i*8)};binary.LittleEndian.PutUint64(want[64:72],value)}
+  want[72],want[73]=1,0
+  fn(&output,&input,seed)
+  if binary.LittleEndian.Uint32(output[76:80])!=binary.LittleEndian.Uint32(output[80:84]){t.Fatal("original changed MXCSR")}
+  copy(want[76:84],output[76:84])
+  if input!=before||output!=want{t.Fatalf("original width=%d lane=%d ins=%t mem=%t sample=%d got=%x want=%x",width,lane,insert,memory,sample,output,want)}
+ }
+}
+func TestOriginal(t *testing.T){runtime.LockOSThread();defer runtime.UnlockOSThread()
+`
+	formatted, err := format.Source([]byte(tests + checks.String() + "}\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	dir := t.TempDir()
+	for name, data := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations.String(), "value_amd64.s": assembly.String(), "value_test.go": string(formatted)} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original.test")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "test", "-c", "-p=2", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "CGO_ENABLED=0", "GOARCH=amd64", "GOOS="+runtime.GOOS)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go source/object/asmdecl: %v\n%s", err, output)
+	}
+	output = execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatal("missing original full-body result", string(output))
+	}
+	t.Logf("%d original Go legacy SSE kernels ×257 patterns, actual stock-Go ABI callers and physical scalar accesses; native Linux required separately", count)
+}
diff --git a/amd64_scalar_lane_result_test.go b/amd64_scalar_lane_result_test.go
new file mode 100644
index 000000000..edf9cfaa7
--- /dev/null
+++ b/amd64_scalar_lane_result_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarLanePublicResultUsesSelectedBytesAndMustJoin(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		result := 8
+		if arch == "386" {
+			result = 4
+		}
+		for _, tc := range []struct {
+			name, body string
+			good       bool
+		}{
+			{"selected", "MOVL k+0(FP),AX\nPINSRD $1,AX,X0\nPEXTRD $1,X0,AX\n", true},
+			{"unwritten", "MOVL k+0(FP),AX\nPINSRD $1,AX,X0\nPEXTRD $0,X0,AX\n", false},
+			{"unknown-GP-unused-output", "PINSRD $1,BX,X0\nMOVL k+0(FP),AX\n", false},
+			{"partial-join", "MOVL k+0(FP),AX\nCMPL AX,$0\nJE missing\nPINSRD $1,AX,X0\nmissing:\nPEXTRD $1,X0,AX\n", false},
+			{"unknown-AES", "MOVL k+0(FP),AX\nPINSRD $1,AX,X0\nAESENC X0,X0\nPEXTRD $1,X0,AX\n", false},
+		} {
+			t.Run(arch+"/"+tc.name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(k uint32) uint32", tc.body+fmt.Sprintf("MOVL AX,ret+%d(FP)\nRET", result))
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); (err == nil) != tc.good {
+					t.Fatalf("public byte observer granted whole vector/unused input/unknown effect: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarLaneRawResultCannotReuseStaleGPInitialization(t *testing.T) {
+	count := 0
+	for _, target := range x86RawReturnTargets {
+		for _, prefix := range []string{"", "V"} {
+			for _, kind := range []struct{ suffix, typ, move string }{
+				{"B", "uint8", "MOVB"}, {"W", "uint16", "MOVW"}, {"D", "uint32", "MOVL"}, {"Q", "uint64", "MOVQ"},
+			} {
+				// These are explicitly the already-admitted physical forms.
+				// Mode32 four-operand/Q inserts retain their existing boundary.
+				if target.arch == "386" && (prefix == "V" || kind.suffix == "Q") {
+					continue
+				}
+				count++
+				t.Run(target.triple+"/"+prefix+kind.suffix, func(t *testing.T) {
+					load, argument := "MOVL", "uint32"
+					bits := map[string]int{"B": 8, "W": 16, "D": 32, "Q": 64}[kind.suffix]
+					if bits == 64 {
+						load, argument = "MOVQ", "uint64"
+					}
+					lane, result := 128/bits-1, 8
+					if target.arch == "386" {
+						result = 4
+					}
+					for _, good := range []bool{true, false} {
+						selected := lane
+						if !good {
+							selected = 0
+						}
+						rows := fmt.Sprintf("%sPINSR%s $%d,AX,X0", prefix, kind.suffix, lane)
+						if prefix != "" {
+							rows += ",X0"
+						}
+						rows += fmt.Sprintf("\n%sPEXTR%s $%d,X0,AX\n", prefix, kind.suffix, selected)
+						code := assembleX87ControlBytes(t, target.arch, "TEXT f(SB),4,$0-0\n"+rows+"RET\n")
+						if len(code) < 2 || code[len(code)-1] != 0xc3 {
+							t.Fatalf("actual original Go scalar pair lacks exact terminal RET: %x", code)
+						}
+						var raw strings.Builder
+						for _, value := range code[:len(code)-1] {
+							fmt.Fprintf(&raw, "BYTE $%#02x\n", value)
+						}
+						decl := fmt.Sprintf("func view(k %s) %s\n", argument, kind.typ)
+						source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s k+0(FP),AX\n%s%s AX,ret+%d(FP)\nRET\n", result+bits/8, load, raw.String(), kind.move, result)
+						goAssemblerOracleOutput(t, target.arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, decl, target.arch, target.triple, api)
+							if (err == nil) != good || !good && ir != "" {
+								t.Fatalf("%s original raw pair used stale GP bytes instead of selected source lane: good=%t err=%v", api, good, err)
+							}
+							if good {
+								compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "raw-lane.ll", "raw-lane.o", ir)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+	if count != 30 {
+		t.Fatalf("physical source-result matrix changed: %d / 30", count)
+	}
+}
diff --git a/amd64_scalar_lane_runtime_test.go b/amd64_scalar_lane_runtime_test.go
new file mode 100644
index 000000000..1df64d880
--- /dev/null
+++ b/amd64_scalar_lane_runtime_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The full virtual Z observation proves lowering bytes, not physical AVX512
+// execution. The original legacy Go counterpart is an independent root below.
+func TestCrossLinuxRuntimeMatrixX86ScalarLaneCompleteBytes(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, vector := range []bool{false, true} {
+		for _, bits := range []int{8, 16, 32, 64} {
+			for _, insert := range []bool{false, true} {
+				for _, memory := range []bool{false, true} {
+					for lane := 0; lane < 128/bits; lane++ {
+						op := "P"
+						if vector {
+							op = "VP"
+						}
+						if insert {
+							op += "INSR"
+						} else {
+							op += "EXTR"
+						}
+						op += map[int]string{8: "B", 16: "W", 32: "D", 64: "Q"}[bits]
+						name := fmt.Sprint("lane", count)
+						count++
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ seed+16(FP),CX\nVMOVUPS (BX),Z0\nVMOVUPS (AX),Z1\nCMPQ AX,AX\nSTC\n", name)
+						if insert {
+							transfer := "CX"
+							if memory {
+								transfer = "3(BX)"
+							}
+							fmt.Fprintf(&source, "%s $%d,%s,X1", op, lane, transfer)
+							if vector {
+								source.WriteString(",X1")
+							}
+							source.WriteString("\nVMOVUPS Z1,(AX)\n")
+						} else {
+							transfer := "R11"
+							if memory {
+								transfer = "3(AX)"
+							}
+							fmt.Fprintf(&source, "MOVQ $-1,R11\n%s $%d,X0,%s\n", op, lane, transfer)
+							if !memory {
+								source.WriteString("MOVQ R11,64(AX)\n")
+							}
+						}
+						source.WriteString("SETCS 72(AX)\nSETNE 73(AX)\nRET\n")
+						sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}, {Offset: 16, Type: I64, Index: 2, Field: -1},
+						}}}
+						fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+						fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d,%d,%d))return %d;\n", name, bits/8, lane, x86FloatAddSubBoolInt(insert), x86FloatAddSubBoolInt(memory), x86FloatAddSubBoolInt(vector), count)
+					}
+				}
+			}
+		}
+	}
+	if count != 240 {
+		t.Fatal("complete independent scalar-lane runtime denominator", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static int check(void (*fn)(uint8_t*,const uint8_t*,uint64_t),unsigned width,unsigned lane,int insert,int memory,int vector) {
+ const uint64_t seeds[]={0,UINT64_MAX,UINT64_C(0x9876fedcba543210),UINT64_C(0x8000000000000001)};
+ for(unsigned sample=0;sample<8;sample++) {
+  uint8_t input[82],saved[82],output[84],want[84];
+  for(unsigned i=0;i<82;i++)input[i]=i*37+sample*71;
+  for(unsigned i=0;i<84;i++)output[i]=i*19+sample*13;
+  memcpy(saved,input,sizeof(input));memcpy(want,output,sizeof(output));
+  uint64_t seed=seeds[sample%4];
+  if(insert) {
+   const uint8_t *from=memory?input+4:(const uint8_t*)&seed;
+   memcpy(want+1+lane*width,from,width);
+   if(vector)memset(want+17,0,48);
+  } else if(memory)memcpy(want+4,input+1+lane*width,width);
+  else {uint64_t value=0;memcpy(&value,input+1+lane*width,width);memcpy(want+65,&value,8);}
+  want[73]=1;want[74]=0;
+  unsigned csr=0x9fc5,after;__asm__ volatile("ldmxcsr %0"::"m"(csr));
+  fn(output+1,input+1,seed);__asm__ volatile("stmxcsr %0":"=m"(after));
+  if(after!=csr||memcmp(input,saved,sizeof(input))||memcmp(output,want,sizeof(output))) {
+   for(unsigned i=0;i<84;i++)if(output[i]!=want[i])fprintf(stderr,"lane width=%u lane=%u ins=%d mem=%d vec=%d sample=%u byte=%u got=%x want=%x\n",width,lane,insert,memory,vector,sample,i,output[i],want[i]);
+   return 1;
+  }
+ }
+ return 0;
+}
+`
+	main := reference + declarations.String() + "int main(void){\n" + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprint("IR_O2=", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar-lane-bytes", triple, text, main, prefix)
+		})
+	}
+	t.Log("240 independent full-byte programs × 8 patterns × IR absent/present O2; backend retains existing default O2, no physical AVX512 claim")
+}
diff --git a/amd64_scalar_literal_mode32_fixture_test.go b/amd64_scalar_literal_mode32_fixture_test.go
new file mode 100644
index 000000000..091dd9e76
--- /dev/null
+++ b/amd64_scalar_literal_mode32_fixture_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarLiteralMode32ObjectFixtureKeepsPhysicalBank(t *testing.T) {
+	for _, wide := range []int{32, 64} {
+		t.Run(fmt.Sprint(wide), func(t *testing.T) {
+			original := x86ScalarLiteralForms(wide == 64)
+			if !reflect.DeepEqual(x86ScalarLiteralTargetForms(wide, "amd64"), original) {
+				t.Fatal("AMD64 original literal/value/mask denominator changed")
+			}
+			var expected []x86ScalarLiteralForm
+			for _, form := range original {
+				if form.register == 31 {
+					if form.value.zero && form.masked {
+						continue
+					}
+					form.register = 7
+				}
+				expected = append(expected, form)
+			}
+			if !reflect.DeepEqual(x86ScalarLiteralTargetForms(wide, "386"), expected) {
+				t.Fatal("physical controls changed original literal/value/mask axes beyond the explicit register/source-role split")
+			}
+			file, err := Parse(ArchAMD64, x86ScalarLiteralAssembly(wide, "386"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, function := range file.Funcs {
+				for _, instruction := range function.Instrs {
+					for _, operand := range instruction.Args {
+						if operand.Kind != OpReg {
+							continue
+						}
+						index, vector := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+						if vector && index >= 8 {
+							t.Errorf("LLVM object fixture borrowed unbound mode32 bank: %s / %s", function.Sym, instruction.Raw)
+						}
+					}
+				}
+			}
+			want := 28
+			if wide == 64 {
+				want = 46 // six low-bank masked positive-zero literals are Go-invalid.
+			}
+			if len(file.Funcs) != want {
+				t.Fatalf("physical fixture functions=%d, want %d with rejected source axes retained separately", len(file.Funcs), want)
+			}
+		})
+	}
+}
+
+func TestX86ScalarLiteralMode32HighSourceRetainsContext(t *testing.T) {
+	vectorLiterals := x86ScalarLiteralActualGoRewriteSet(t)
+	for _, bank := range []string{"X", "Y"} {
+		t.Run("originalCarrier"+bank, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT literal(SB),4,$0-0\nVMOVUPS (AX),%s31\nRET\n", bank)
+			// Both historical/current assemblers must actually emit this
+			// accepted high-bank carrier; a V literal rejection on old Go
+			// is separate and cannot stand in for this original object.
+			x86ScalarLiteralGoListing(t, "386", source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, recognized, err := amd64PackedVectorMoveProperties(file.Funcs[0].Instrs[1], "386"); !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("accepted original carrier acquired physical mode32 identity: recognized=%t err=%v", recognized, err)
+			}
+		})
+	}
+	checked := 0
+	for _, form := range x86ScalarLiteralForms(true) {
+		if form.register != 31 {
+			continue
+		}
+		checked++
+		t.Run(form.name, func(t *testing.T) {
+			// This is the exact high-bank source from the original object
+			// fixture, including its packed input/output carriers. Frontend
+			// acceptance is not a physical mode32 bank certificate.
+			source := x86ScalarLiteralAssemblyForForms(64, "386", []x86ScalarLiteralForm{form})
+			listing, err := x86ScalarLiteralExpectedGoListing(t, "386", source, vectorLiterals)
+			if (err == nil) != vectorLiterals {
+				t.Fatalf("actual selected SDK high-bank source: %v\n%s", err, listing)
+			}
+			t.Logf("original high-bank sourceSHA=%x listingSHA=%x accepted=%t\n%s", sha256.Sum256([]byte(source)), sha256.Sum256([]byte(listing)), vectorLiterals, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := "literal." + form.name
+			sig := FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+				}},
+			}
+			for _, triple := range []string{"i386-unknown-linux-gnu", "i386-pc-windows-msvc"} {
+				ir, err := Translate(file, Options{Goarch: "386", TargetTriple: triple,
+					Sigs:       map[string]FuncSig{name: sig},
+					ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) },
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s original high-bank carrier acquired a physical binding or IR: %v", triple, err)
+				}
+			}
+		})
+	}
+	if checked != 24 {
+		t.Fatalf("original high-bank denominator=%d, want 24", checked)
+	}
+}
+
+func TestX86ScalarLiteralMode32ZeroMaskSourceEncoding(t *testing.T) {
+	vectorLiterals := x86ScalarLiteralActualGoRewriteSet(t)
+	for _, op := range []string{"VMOVSS", "VMOVSD"} {
+		for _, value := range x86ScalarLiteralValues[:3] {
+			for _, register := range []int{7, 8, 31} {
+				for _, shape := range []struct{ suffix, mask string }{
+					{}, {mask: "K1,"}, {suffix: ".Z", mask: "K1,"},
+				} {
+					instruction := fmt.Sprintf("%s%s $%s,%sX%d", op, shape.suffix, value.text, shape.mask, register)
+					t.Run(instruction, func(t *testing.T) {
+						zeroRewrite := value.zero && register < 16
+						accepted := vectorLiterals && !(zeroRewrite && (register >= 8 || shape.mask != ""))
+						source := "TEXT literal(SB),4,$0-0\n" + instruction + "\nRET\n"
+						listing, err := x86ScalarLiteralExpectedGoListing(t, "386", source, accepted)
+						if (err == nil) != accepted {
+							t.Fatalf("selected SDK zero/mask rewrite: %v\n%s", err, listing)
+						}
+						t.Logf("actual zero/mask sourceSHA=%x listingSHA=%x accepted=%t\n%s", sha256.Sum256([]byte(source)), sha256.Sum256([]byte(listing)), accepted, source)
+						if !accepted {
+							return // an actual source rejection, not an object or Skip.
+						}
+						prefix := "c5"
+						if register >= 16 || shape.mask != "" {
+							prefix = "62"
+						} else if zeroRewrite {
+							prefix = "0f"
+						}
+						found := false
+						for _, line := range strings.Split(listing, "\n") {
+							fields := strings.Fields(line)
+							if len(fields) >= 2 && fields[0] == "0x0000" && len(fields[1]) == 2 {
+								found = true
+								if fields[1] != prefix {
+									t.Fatalf("actual encoder prefix=%s, want %s\n%s", fields[1], prefix, listing)
+								}
+								break
+							}
+						}
+						if !found {
+							t.Fatalf("accepted object lost its actual instruction bytes\n%s", listing)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_memory_rmw.go b/amd64_scalar_memory_rmw.go
new file mode 100644
index 000000000..5b1048c8f
--- /dev/null
+++ b/amd64_scalar_memory_rmw.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import "fmt"
+
+// The ordinary memory destinations use the complete existing scalar grammar.
+// Bit strings and bound LOCK keep their independent effects and dispatch.
+func x86ScalarMemoryRMWProperties(op Op, ins Instr, arch string) (x86LockScalarRMWForm, bool, error) {
+	form, known, err := x86LockScalarRMWProperties(op, ins, arch)
+	if !known || form.spec.bitString {
+		return form, false, nil
+	}
+	if err != nil {
+		return form, true, err
+	}
+	return form, isAMD64MemoryOperand(form.destination), nil
+}
+
+func (c *amd64Ctx) loadScalarRMWDestination(op Op, ins Instr, destination Operand, typ LLVMType) (string, func(string) error, error) {
+	form, known, err := x86ScalarMemoryRMWProperties(op, ins, c.goarch)
+	if err != nil {
+		return "", nil, err
+	}
+	if !known || !c.nativeMemoryOperand(ins, len(ins.Args)-1) {
+		if form.spec.stem == "INC" || form.spec.stem == "DEC" {
+			// Preserve the existing logical GP/FP/AUTO byte-view consumer;
+			// only actual native memory gets the new paired access above it.
+			value, err := c.evalIntSized(destination, typ)
+			return value, func(value string) error {
+				return c.storeScalarIntegerOperand(destination, typ, value)
+			}, err
+		}
+		return c.loadIntDestination(destination, typ)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return "", nil, fmt.Errorf("%w: scalar RMW needs its original native address size", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.destination)
+	if err != nil {
+		return "", nil, err
+	}
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", loaded, typ, pointerType, pointer)
+	return "%" + loaded, func(value string) error {
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+		return nil
+	}, nil
+}
+
+func (c *amd64Ctx) lowerScalarMemoryRMW(op Op, ins Instr) (bool, bool, error) {
+	if c.namedAtomicLock {
+		return false, false, nil
+	}
+	form, known, err := x86ScalarMemoryRMWProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	local := ins
+	local.Op = op
+	local.Args = append([]Operand(nil), ins.Args...)
+	if !form.spec.unary {
+		if form.source.Kind == OpReg && form.source.Reg != ins.Args[0].Reg &&
+			x86LogicalSourceFrameRegister(form.source.Reg, c.goarch) {
+			return true, false, fmt.Errorf("%w: RMW byte source needs its physical SP/BP role", ErrProbeNeedsContext)
+		}
+		local.Args[0] = form.source // Only local dispatch, never rewrite either source snapshot.
+	}
+	switch form.spec.stem {
+	case "ADD", "SUB":
+		return c.lowerScalarAddSub(op, local)
+	case "ADC", "SBB":
+		return c.lowerScalarADCSBB(op, local)
+	case "INC", "DEC":
+		return c.lowerScalarIncDec(op, local)
+	case "NEG", "NOT":
+		return c.lowerScalarUnaryYmb(op, local)
+	}
+
+	// The remaining shared rows are AND/OR/XOR, not implicitly locked atomics.
+	typ := amd64IntegerTypeForBits(form.spec.bits)
+	source, err := c.evalIntSized(form.source, typ)
+	if err != nil {
+		return true, false, err
+	}
+	old, store, err := c.loadScalarRMWDestination(op, local, form.destination, typ)
+	if err != nil {
+		return true, false, err
+	}
+	operation := map[string]string{"AND": "and", "OR": "or", "XOR": "xor"}[form.spec.stem]
+	if operation == "" {
+		return true, false, fmt.Errorf("unregistered scalar memory RMW effect %s", op)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, operation, typ, old, source)
+	value := "%" + result
+	if err := store(value); err != nil {
+		return true, false, err
+	}
+	c.clearX86StatusFlags(x86StatusCF | x86StatusOF)
+	zero, sign := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, typ, value)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", zero, c.flagsZSlot)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", sign, typ, value)
+	fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", sign, c.flagsSltSlot)
+	c.setParityFlagSized(typ, value)
+	return true, false, nil // AF remains architecturally undefined, not an input fact.
+}
+
+func x86LoweredScalarMemoryRMW(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86ScalarMemoryRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86OrdinaryNativeMemoryOperand(form.destination, arch) {
+		return false, known && err != nil
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		!x86ResultNativeRMWAddress(ins, form.destination, state, owned, arch) {
+		return false, true
+	}
+	if !form.spec.unary && !x86ResultRead(form.source, int64(form.spec.bits/8), state, owned, arch) ||
+		(form.spec.stem == "ADC" || form.spec.stem == "SBB") && state.flags&x86ByteFlagCF == 0 {
+		return false, true
+	}
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true // No GP, logical storage, pointee or reusable memory facts are added.
+}
diff --git a/amd64_scalar_memory_rmw_linux_amd64_test.go b/amd64_scalar_memory_rmw_linux_amd64_test.go
new file mode 100644
index 000000000..039d0bb5c
--- /dev/null
+++ b/amd64_scalar_memory_rmw_linux_amd64_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86UnlockedScalarRMWNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	declarations, source, driver, reference, count := x86UnlockedScalarRMWRuntimeFixture("amd64", true)
+	if count != 156 {
+		t.Fatal("complete ordinary AMD64 kernel denominator changed", count)
+	}
+	want := fmt.Sprintf("unlocked observations %d\n", count*292*2*8)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "amd64", declarations, source, driver)
+	if output := execution.run(t, original); string(output) != want {
+		t.Fatalf("actual original Go ordinary memory/FLAGS/MXCSR/canary oracle: %q", output)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86OrderingHintTranslateAPI(t, api, source, declarations, "amd64", execution.triple)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				if output := execution.compileAndRunLLVM(t, "ordinary-rmw", ir, reference, level); string(output) != want {
+					t.Fatalf("native LLVM ordinary memory/FLAGS/MXCSR/canary oracle: %q", output)
+				}
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86UnlockedScalarRMWNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("required LLVM22 and IA32 static compiler unavailable", err)
+	}
+	declarations, source, driver, reference, count := x86UnlockedScalarRMWRuntimeFixture("386", true)
+	if count != 117 {
+		t.Fatal("complete ordinary IA32 kernel denominator changed", count)
+	}
+	want := fmt.Sprintf("unlocked observations %d\n", count*292*2*8)
+	directory := t.TempDir()
+	original := x86OrderingHintBuildOriginal(t, directory, "linux", "386", declarations, source, driver)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != want {
+		t.Fatalf("actual original Go ordinary IA32 full-width/status/canary oracle: %q", output)
+	}
+	triple := "i386-unknown-linux-gnu"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86OrderingHintTranslateAPI(t, api, source, declarations, "386", triple)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				input := filepath.Join(directory, api+level+".ll")
+				object := filepath.Join(directory, api+level+".o")
+				main := filepath.Join(directory, api+level+".c")
+				executable := filepath.Join(directory, api+level)
+				for name, contents := range map[string]string{input: ir, main: reference} {
+					if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+triple,
+					"-filetype=obj", input, "-o", object))
+				x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie",
+					object, main, "-O2", "-o", executable))
+				sealed, err := x87IA32StaticExecutable(executable)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != want {
+					t.Fatalf("native LLVM IA32 ordinary full-width/FLAGS/MXCSR/canary oracle: %q", output)
+				}
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_scalar_memory_rmw_runtime_test.go b/amd64_scalar_memory_rmw_runtime_test.go
new file mode 100644
index 000000000..81e5afa37
--- /dev/null
+++ b/amd64_scalar_memory_rmw_runtime_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86UnlockedScalarRMWRuntimeFixture(arch string, native bool) (declarations, assembly, driver, reference string, count int) {
+	word, cWord, suffix, slot := "uint64", "uint64_t", "Q", 8
+	if arch == "386" {
+		word, cWord, suffix, slot = "uint32", "uint32_t", "L", 4
+	}
+	var decl, source, goRows, prototypes, cRows strings.Builder
+	decl.WriteString("package main\n")
+	for _, row := range x86LockScalarRuntimeCases(arch) {
+		if strings.HasPrefix(row.stem, "BT") {
+			continue // Bit strings retain their separate typed and runtime family.
+		}
+		count++
+		fmt.Fprintf(&decl, "func %s(memory *[128]byte,output *[8]uint64,offset,value,seed %s)\n", row.name, word)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", row.name, slot*5)
+		fmt.Fprintf(&source, "MOV%s memory+0(FP),SI\nMOV%s output+%d(FP),DI\nMOV%s offset+%d(FP),AX\n",
+			suffix, suffix, slot, suffix, slot*2)
+		fmt.Fprintf(&source, "ADD%s AX,SI\nMOV%s value+%d(FP),CX\nMOV%s seed+%d(FP),DX\nPUSH%s DX\nPOPF%s\n",
+			suffix, suffix, slot*3, suffix, slot*4, suffix, suffix)
+		if native {
+			source.WriteString("STMXCSR 24(DI)\n")
+		}
+		statusMask := x86ScalarRuntimeStatusMask(row.stem)
+		// Refine the saved word in the original source, before any native
+		// output store. A C-side mask alone cannot initialize unknown bits.
+		fmt.Fprintf(&source, "%s\nPUSHF%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,0(DI)\nMOV%s CX,8(DI)\nMOV%s DX,16(DI)\n",
+			row.body, suffix, suffix, suffix, statusMask, suffix, suffix, suffix)
+		if native {
+			source.WriteString("STMXCSR 32(DI)\n")
+		}
+		source.WriteString("RET\n")
+		fmt.Fprintf(&goRows, "{%s,%q,%d,%t,%d},\n", row.name, row.stem, row.width, row.immediate, row.literal)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,uint64_t*,%s,%s,%s);\n", row.name, cWord, cWord, cWord)
+		immediate := 0
+		if row.immediate {
+			immediate = 1
+		}
+		fmt.Fprintf(&cRows, "{%s,%q,%d,%d,UINT64_C(%d)},\n", row.name, row.stem, row.width, immediate, row.literal)
+	}
+	if strings.Contains(source.String(), "LOCK") {
+		panic("ordinary scalar memory source acquired a LOCK prefix")
+	}
+	driver = strings.NewReplacer("@WORD@", word, "@ROWS@", goRows.String(),
+		"lock observations", "unlocked observations").Replace(x86LockScalarOriginalReference)
+	oracle := x86ScalarMemoryIndependentC + x86UnlockedScalarPortableDriverC
+	if native {
+		oracle = x86LockScalarIndependentC
+	}
+	reference = strings.NewReplacer("@WORD@", cWord, "@PROTOTYPES@", prototypes.String(),
+		"@ROWS@", cRows.String(), "lock observations", "unlocked observations").Replace(oracle)
+	return decl.String(), source.String(), driver, reference, count
+}
+
+func TestX86UnlockedScalarRMWObservationUsesOnlyDefinedStatus(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, native := range []bool{false, true} {
+			_, source, _, _, count := x86UnlockedScalarRMWRuntimeFixture(arch, native)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil || len(file.Funcs) != count {
+				t.Fatal("complete observation source lost a kernel", arch, native, err)
+			}
+			for _, function := range file.Funcs {
+				observations := 0
+				for index, instruction := range function.Instrs {
+					if instruction.Op != "PUSHFQ" && instruction.Op != "PUSHFL" {
+						continue
+					}
+					if index == 0 || index+2 >= len(function.Instrs) {
+						t.Fatal("saved FLAGS lost its complete source neighborhood")
+					}
+					operation := string(function.Instrs[index-1].Op)
+					mask := int64(0x8d5)
+					if strings.HasPrefix(operation, "AND") || strings.HasPrefix(operation, "OR") || strings.HasPrefix(operation, "XOR") {
+						mask = 0x8c5
+					}
+					refinement := function.Instrs[index+2]
+					if !strings.HasPrefix(string(refinement.Op), "AND") || len(refinement.Args) != 2 ||
+						refinement.Args[0].Kind != OpImm || refinement.Args[0].Imm != mask ||
+						refinement.Args[1].Kind != OpReg || refinement.Args[1].Reg != AX {
+						t.Fatal("saved FLAGS borrowed undefined or unmodeled bits", arch, native, operation)
+					}
+					observations++
+				}
+				if observations != 1 {
+					t.Fatal("ordinary kernel lost its single complete FLAGS observation", function.Sym)
+				}
+			}
+		}
+	}
+}
+
+func x86UnlockedScalarRMWPortableRuntime(t *testing.T, api string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	arch, want := "amd64", 156
+	if strconv.IntSize == 32 {
+		arch, want = "386", 117
+	}
+	declarations, source, _, reference, count := x86UnlockedScalarRMWRuntimeFixture(arch, false)
+	if count != want {
+		t.Fatal("complete ordinary arithmetic/immediate-boundary denominator changed", count, want)
+	}
+	originalTriple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		originalTriple = "i386-unknown-linux-gnu"
+	}
+	x86LEAActualTargetGoObject(t, arch, originalTriple, source)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := x86OrderingHintTranslateAPI(t, api, source, declarations, arch, triple)
+	if err != nil || ir == "" {
+		t.Fatal("complete initialized ordinary memory/FLAGS source rejected", api, err)
+	}
+	for _, optimized := range []bool{false, true} {
+		text := ir
+		if optimized {
+			text = x86DwordProductIROptimize(t, ir)
+		}
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "ordinary-rmw", triple, text, reference, nil, level)
+			})
+		}
+	}
+	if !t.Failed() {
+		t.Logf("%d complete ordinary kernels, %d observations per backend: memory bytes, defined/preserved FLAGS, source registers and canaries; portable LLVM, not original-Go native execution",
+			count, count*292*2*8)
+	}
+}
+
+func TestX86UnlockedScalarRMWPortableTextRuntime(t *testing.T) {
+	x86UnlockedScalarRMWPortableRuntime(t, "text")
+}
+
+func TestX86UnlockedScalarRMWPortableModuleRuntime(t *testing.T) {
+	x86UnlockedScalarRMWPortableRuntime(t, "module")
+}
+
+func TestX86UnlockedScalarRMWPortableGoRuntime(t *testing.T) {
+	x86UnlockedScalarRMWPortableRuntime(t, "Go")
+}
+
+// The independent arithmetic is shared with the original-Go/native oracle.
+// This portable driver observes no MXCSR or host-native x86 instruction.
+const x86UnlockedScalarPortableDriverC = `
+int main(void) {
+    static const uint64_t edges[] = {0,1,15,16,17,127,128,255,256,32767,32768,65535,
+        0x7fffffff,0x80000000,0xffffffff,0x7fffffffffffffff,0x8000000000000000,UINT64_MAX};
+    const uint64_t sentinel = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    unsigned observations = 0;
+    for (unsigned kernel = 0; kernel < sizeof(kernels)/sizeof(kernels[0]); kernel++) {
+        const struct kernel *k = &kernels[kernel];
+        for (unsigned sample = 0; sample < 292; sample++) {
+            uint64_t a = sample/16, b = sample%16;
+            if (sample >= 256) {
+                a = edges[(sample-256)/2];
+                b = edges[((sample-256)/2+1+6*(sample%2))%18];
+            }
+            b = (word)b;
+            for (unsigned state = 0; state < 2; state++) {
+                for (unsigned offset = 64; offset < 72; offset++) {
+                    uint64_t seed = state ? 0x12 : 0x8c7, out[8];
+                    uint8_t memory[128], expected[128];
+                    for (unsigned i = 0; i < 128; i++) {
+                        memory[i] = (i*73+19)^(sample*29);
+                    }
+                    store(memory, offset, k->width, a);
+                    memcpy(expected, memory, 128);
+                    for (unsigned i = 0; i < 8; i++) {
+                        out[i] = sentinel;
+                    }
+                    uint64_t valid, flags = reference(k, expected, offset, b, seed, &valid);
+                    k->fn(memory, out, offset, b, seed);
+                    uint64_t word_mask = (word)~(word)0;
+                    if (memcmp(memory, expected, 128) || (out[0]&valid) != flags ||
+                        (out[1]&word_mask) != b || (out[2]&word_mask) != seed) {
+                        fprintf(stderr, "%s/%u sample=%u offset=%u flags=%llx/%llx mask=%llx\n",
+                            k->op, k->width, sample, offset, (unsigned long long)out[0],
+                            (unsigned long long)flags, (unsigned long long)valid);
+                        return 1;
+                    }
+                    for (unsigned i = 0; i < 3; i++) {
+                        if ((out[i]&~word_mask) != (sentinel&~word_mask)) return 2;
+                    }
+                    for (unsigned i = 3; i < 8; i++) {
+                        if (out[i] != sentinel) return 3;
+                    }
+                    observations++;
+                }
+            }
+        }
+    }
+    unsigned expected = (unsigned)(sizeof(kernels)/sizeof(kernels[0]))*292*2*8;
+    if (observations != expected) return 4;
+    printf("unlocked observations %u\n", observations);
+    return 0;
+}
+`
diff --git a/amd64_scalar_move_alias.go b/amd64_scalar_move_alias.go
new file mode 100644
index 000000000..46b58db16
--- /dev/null
+++ b/amd64_scalar_move_alias.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import "fmt"
+
+// These are opposite directions of the same 32-bit GP move. Direction is a
+// source constraint: neither spelling inherits MOVL's other operand classes.
+type x86ScalarMoveAliasSpec struct {
+	canonical           Op
+	bytes               int64
+	load                bool
+	rawExtension        bool
+	requiresResultProof bool
+}
+
+func x86ScalarMoveAliasSpecification(op Op) (x86ScalarMoveAliasSpec, bool) {
+	switch op {
+	case "MOVQL":
+		return x86ScalarMoveAliasSpec{canonical: "MOVL", bytes: 4, requiresResultProof: true}, true
+	case "MOVLQZX":
+		return x86ScalarMoveAliasSpec{canonical: "MOVL", bytes: 4, load: true, rawExtension: true}, true
+	default:
+		return x86ScalarMoveAliasSpec{}, false
+	}
+}
+
+type x86ScalarMoveAliasForm struct {
+	spec                x86ScalarMoveAliasSpec
+	source, destination Operand
+}
+
+func x86ScalarMoveAliasProperties(op Op, ins Instr, arch string) (x86ScalarMoveAliasForm, bool, error) {
+	spec, known := x86ScalarMoveAliasSpecification(op)
+	if !known {
+		return x86ScalarMoveAliasForm{}, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	// Existing physical scalar extensions retain their numerical consumer;
+	// the source-only alias view cannot provide native/frame/caller authority.
+	if !x86ResultNamedPredicateInstruction(ins) && spec.rawExtension {
+		return x86ScalarMoveAliasForm{}, false, nil
+	}
+	fail := func() (x86ScalarMoveAliasForm, bool, error) {
+		return x86ScalarMoveAliasForm{}, true, fmt.Errorf("%s %s requires its original directional 32-bit GP move form: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || ins.Op != op || len(ins.Args) != 2 ||
+		!x86ResultNamedPredicateInstruction(ins) {
+		return fail()
+	}
+	gp := func(operand Operand) bool {
+		return operand.Kind == OpReg && isX86YrlRegisterForArch(operand.Reg, arch)
+	}
+	rm := func(operand Operand) bool {
+		if gp(operand) {
+			return true
+		}
+		if spec.load && operand.Kind == OpMem {
+			// Keep the established extension grammar, including its source
+			// offset/macro contract. Storage owners still bind each access.
+			return x86MemoryRegistersValidForArch(operand.Mem, arch)
+		}
+		return isAMD64MemoryOperand(operand) && x86PackedShiftMemoryValid(operand, arch)
+	}
+	source, destination := ins.Args[0], ins.Args[1]
+	memory := destination
+	if spec.load {
+		memory = source
+	}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, memory, arch); segment {
+		if err != nil {
+			return x86ScalarMoveAliasForm{}, true, err
+		}
+		if spec.load {
+			source = projected
+		} else {
+			destination = projected
+		}
+	}
+	if spec.load && (!rm(source) || !gp(destination)) || !spec.load && (!gp(source) || !rm(destination)) {
+		return fail()
+	}
+	return x86ScalarMoveAliasForm{spec, source, destination}, true, nil
+}
+
+// Consumers use a local value only. Entry validation and each storage owner
+// still check the actual mode and original instruction; this projection grants
+// no source, address, NUM or producer identity. Ordinary opcodes return without
+// allocation, case conversion or textual parsing.
+func x86SourceMoveInstruction(ins Instr, arch string) Instr {
+	switch ins.Op {
+	case "MOVD", "MOVDQ2Q":
+		return x86GoMOVQSourceInstruction(ins)
+	case "MOVQL", "MOVLQZX":
+		if form, known, err := x86ScalarMoveAliasProperties(ins.Op, ins, arch); known && err == nil {
+			if !form.spec.load || arch == "386" {
+				// The old 32->64 extension keeps its existing consumer. In
+				// mode32 both aliases copy one unchanged ordinary GP word.
+				ins.Op = form.spec.canonical
+			}
+		}
+	}
+	return ins
+}
+
+func x86TypedScalarMoveAliasEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ScalarMoveAliasProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	writeWidth := form.spec.bytes
+	if form.spec.load && arch != "386" {
+		writeWidth = 8
+	}
+	return x86TypedByteEffect{requiresResultProof: form.spec.requiresResultProof, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.source, width: form.spec.bytes, read: true},
+		{index: 1, operand: form.destination, width: writeWidth, write: true},
+	}}, true, nil
+}
diff --git a/amd64_scalar_move_native_result_test.go b/amd64_scalar_move_native_result_test.go
new file mode 100644
index 000000000..202d69e7b
--- /dev/null
+++ b/amd64_scalar_move_native_result_test.go
@@ -0,0 +1,277 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarMoveNativeOriginalHighByteEncodings(t *testing.T) {
+	for ordinal, reg := range []string{"AH", "CH", "DH", "BH"} {
+		for _, address := range []string{"(DX)", "(R8)", "(DX)(R9*2)"} {
+			body := "TEXT native(SB),4,$0-0\nMOVB " + address + "," + reg + "\nRET\n"
+			code := x86OrderingHintGoBytes(t, "amd64", body)
+			want := []byte{0x8a, byte(0x22 + ordinal*8), 0xc3}
+			if address == "(R8)" {
+				want = []byte{0x41, 0x8a, byte(0x20 + ordinal*8), 0xc3}
+			} else if address == "(DX)(R9*2)" {
+				want = []byte{0x42, 0x8a, byte(0x24 + ordinal*8), 0x4a, 0xc3}
+			}
+			if !reflect.DeepEqual(code, want) {
+				t.Fatalf("original Go high-byte encoding changed: %s %s = %x, want %x", address, reg, code, want)
+			}
+			ins := x86ScalarLaneInstruction(t, "MOVB "+address+","+reg)
+			form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, "amd64")
+			effective := Reg(reg)
+			if address != "(DX)" {
+				effective = []Reg{SP, BP, SI, DI}[ordinal]
+			}
+			if !known || err != nil || form.destination != effective || form.bytes != 1 {
+				t.Fatal("typed native load differs from original ModRM/REX role", form, err)
+			}
+			if address != "(DX)" && ordinal < 2 {
+				c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.Value", Ret: Void}, nil)
+				before := output.String()
+				if err := c.lowerScalarNativeLoad(form, ins); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+					t.Fatal("REX alias manufactured a physical SP/BP write", err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarMoveNativeByteEffectsAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			op    string
+			width int
+		}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}, {"MOVD", 8}} {
+			if arch == "386" && row.width == 8 {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" -1(DX)(BX*1),CX")
+				base, _, _ := x86ResultGP(DX, 4, arch)
+				index, _, _ := x86ResultGP(BX, 4, arch)
+				destination, _, _ := x86ResultGP(CX, 4, arch)
+				for seed := 0; seed < 256; seed++ {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.pointerGP[base] = true
+					state.pointerGP[destination] = true
+					state.gp[index] = 0xff
+					state.gp[destination] = uint8(seed)
+					want := state.clone()
+					want.pointerGP[destination] = false
+					mask := uint8(0xff)
+					if row.width < 4 {
+						mask = uint8(1<<row.width) - 1
+					}
+					want.gp[destination] |= mask
+					if accepted, known := x86LoweredScalarNativeLoad(ins, &state, nil, 0, arch); !accepted || !known || !reflect.DeepEqual(state, want) {
+						t.Fatal("scalar load changed byte/FLAGS/pointer roles", seed, state, want)
+					}
+				}
+				for _, origin := range []string{"decoded", "raw", "raw return", "address", "unbound address", "segment"} {
+					changed := ins
+					switch origin {
+					case "decoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "raw return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address":
+						changed.x86AddressBits = 32
+					case "unbound address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					}
+					state := x86ResultState{}
+					state.pointerGP[base], state.gp[index] = true, 0xff
+					before := state.clone()
+					if accepted, _ := x86LoweredScalarNativeLoad(changed, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("native load acquired an unbound origin", origin, state)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarMoveNativeRejectsMalformedAddressesBeforeIR(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ", "MOVD"} {
+		t.Run(op, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+op+" 8(BAD),AX\nRET\n", "", false)
+			ins := Instr{Op: Op(op), Raw: op + " 8(BAD),AX", Args: []Operand{
+				{Kind: OpMem, Mem: MemRef{Base: "BAD", Off: 8}}, {Kind: OpReg, Reg: AX},
+			}}
+			c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.Value", Ret: Void}, nil)
+			before := output.String()
+			if handled, _, err := c.lowerMov(ins.Op, ins); !handled || err == nil || output.String() != before {
+				t.Fatal("malformed address created a zero/native read", handled, err)
+			}
+		})
+	}
+}
+
+func TestX86ScalarMoveNativeKeepsNamedAddressRolesSeparate(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVW", "MOVL"} {
+		for _, address := range []string{"table<>(SB)(R8)", "table<>(SB)(SP)", "table<>(SB)(AX)(CX*2)"} {
+			instruction := op + " " + address + ",AX"
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", "", true)
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if _, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, "386"); known || err != nil {
+				t.Fatal("register-addressed read consumed Go's distinct SB address role", instruction, err)
+			}
+		}
+	}
+}
+
+func TestX86ScalarMoveNativeRetainsPublicAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ", "MOVD"} {
+			if arch == "386" && (op == "MOVQ" || op == "MOVD") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				body := fmt.Sprintf("%s p+0(FP),DX\nMOVL $0,CX\n%s (DX),CX\nMOVL CX,ret0+%d(FP)\nRET", move, op, word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *[16]byte) uint32", body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone query acquired native storage", err)
+					}
+				}
+				t.Run("paired-native-load-and-store", func(t *testing.T) {
+					// Retain the original complete source. This is now the
+					// independently paired NUM store, not a load-only grant.
+					source, declaration := x86ExtensionNativeFixture("Value", arch, op+" (DX),CX\n"+op+" CX,(DX)", false)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM22 llc required")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil || ir == "" || !strings.Contains(ir, "load volatile ") || !strings.Contains(ir, "store volatile ") {
+							t.Fatal("paired load/store lost a complete native effect", api, err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, ir, level)
+						}
+					}
+				})
+				for name, body := range map[string]string{
+					"unknown base":       op + " (DI),CX",
+					"numeric base":       "MOVL $42,DX\n" + op + " (DX),CX",
+					"unknown index":      op + " (DX)(SI*1),CX",
+					"pointer index":      op + " (DX)(DX*1),CX",
+					"pointer destroyed":  op + " (DX),DX\nMOVB (DX),CX",
+					"unbound store":      op + " (DX),CX\n" + op + " CX,(SI)",
+					"mixed pointer join": "CMPL BX,$0\nJE other\n" + move + " DX,DI\nJMP end\nother:\nMOVL $42,DI\nend:\n" + op + " (DI),CX",
+				} {
+					t.Run(name, func(t *testing.T) {
+						source, declaration := x86ExtensionNativeFixture("Value", arch, body, false)
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if name == "numeric base" || name == "pointer destroyed" && (op == "MOVL" || op == "MOVQ" || op == "MOVD") {
+								bits := map[string]int{"MOVB": 8, "MOVW": 16, "MOVL": 32, "MOVQ": 64, "MOVD": 64}[op]
+								reads := 1
+								if name == "pointer destroyed" {
+									reads = 2
+								}
+								if err != nil || strings.Count(ir, "load volatile ") != reads || !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", bits)) || reads == 2 && !strings.Contains(ir, "load volatile i8,") {
+									t.Fatal("complete NUM move address lost its exact independent accesses", api, err)
+								}
+								x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+								x86NumericNativeAddressObject(t, ir, triple)
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("native continuation widened its source contract", api, err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+// The original sing-tun checksum counterexample reaches an ordinary scalar
+// load before VPEXTRQ consumes the result proof. Reproduce that whole class
+// without importing or compiling the external library.
+func TestX86ScalarMoveNativeResultsThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ", "MOVD"} {
+				if target.arch == "386" && (op == "MOVQ" || op == "MOVD") {
+					goAssemblerOracleOutput(t, target.arch, "TEXT f(SB),4,$0-0\n"+op+" (DX),CX\nRET\n", "", false)
+					continue
+				}
+				for _, address := range []string{"(DX)", "-1(DX)(BX*1)"} {
+					body, decl := x86ExtensionNativeFixture(fmt.Sprintf("Value%d", count), target.arch, op+" "+address+",CX", false)
+					source.WriteString(body)
+					declarations.WriteString(strings.ReplaceAll(decl, "*[4]byte", "*[16]byte"))
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("ordinary native MOV lost its paired numerical continuation", err)
+					}
+					if strings.Count(ir, "load volatile i") != count {
+						t.Fatal("ordinary native MOV lacks its exact observable read", count)
+					}
+					for _, optimized := range []bool{false, true} {
+						text := ir
+						if optimized {
+							text = x86MulDivRoundOptimize(t, text)
+						}
+						stem := fmt.Sprintf("scalar-move-native-%t", optimized)
+						compileLLVMToObject(t, llc, target.triple, stem+".ll", stem+".o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarMoveDeadNativeReadSurvivesOptimization(t *testing.T) {
+	for _, row := range []struct {
+		op    string
+		width int
+	}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}, {"MOVD", 8}} {
+		t.Run(row.op, func(t *testing.T) {
+			source, decl := x86ExtensionNativeFixture("Value", "amd64", row.op+" (DX),CX", true)
+			decl = strings.ReplaceAll(decl, "*[4]byte", "*[16]byte")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, decl, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want := fmt.Sprintf("load volatile i%d,", row.width*8)
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if strings.Count(text, want) != 1 {
+						t.Errorf("%s dead %s lost its exact native read", api, row.op)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_move_native_runtime_unix_test.go b/amd64_scalar_move_native_runtime_unix_test.go
new file mode 100644
index 000000000..a447b39e5
--- /dev/null
+++ b/amd64_scalar_move_native_runtime_unix_test.go
@@ -0,0 +1,120 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarMoveNativeResultsAndFaults(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, originals, rows strings.Builder
+	count := 0
+	for _, row := range []struct {
+		op, rexAlias string
+		width        int
+	}{{"MOVB", "", 1}, {"MOVW", "", 2}, {"MOVL", "", 4}, {"MOVQ", "", 8}, {"MOVD", "", 8},
+		{"MOVB", "DH", 1}, {"MOVB", "BH", 1}} {
+		for _, dead := range []bool{false, true} {
+			name, original := fmt.Sprintf("F%d", count), fmt.Sprintf("Original%d", count)
+			body := row.op + " -1(DX)(BX*1),CX"
+			native := "MOVQ $0x87654321fedcba98,AX\n" + row.op + " (DI),AX\n"
+			if row.rexAlias != "" {
+				effective := "SI"
+				if row.rexAlias == "BH" {
+					effective = "DI"
+				}
+				body = "MOVQ DX,R8\nMOVQ $0x87654321fedcba98," + effective + "\nMOVB (R8)," + row.rexAlias + "\nMOVQ " + effective + ",CX"
+				native = "MOVQ DI,R8\nMOVQ $0x87654321fedcba98," + effective + "\nMOVB (R8)," + row.rexAlias + "\nMOVQ " + effective + ",AX\n"
+			}
+			if dead {
+				body += "\nMOVQ $0x87654321fedcba98,CX"
+				native += "MOVQ $0x87654321fedcba98,AX\n"
+			}
+			assembly, declaration := x86ExtensionNativeFixture(name, "amd64", body, false)
+			source.WriteString(assembly)
+			declarations.WriteString(strings.ReplaceAll(declaration, "*[4]byte", "*[16]byte"))
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+native+"RET\n")
+			var bytes []string
+			for _, b := range code {
+				bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*);\nextern uint64_t %s(const uint8_t*);\n", name, original)
+			discarded := 0
+			if dead {
+				discarded = 1
+			}
+			fmt.Fprintf(&rows, "{%s,%s,%d,%d,0,%d},\n", name, original, row.width, row.width, discarded)
+			count++
+		}
+	}
+	if count != 14 {
+		t.Fatal("incomplete scalar native read family", count)
+	}
+	// Keep every original live/dead kernel. The additional ordinary register
+	// entry has no result at all; its C adapter supplies the comparison value,
+	// so both value and protected-page checks still require the native load.
+	// This compares instruction effects, not a C-to-Go ABIInternal call bridge.
+	source.WriteString("TEXT ·VoidLoad<ABIInternal>(SB),4,$0-8\nMOVQ (AX),BX\nRET\n")
+	declarations.WriteString("func VoidLoad(p *uint64)\n")
+	prototypes.WriteString(`extern void VoidLoad(const uint8_t*);
+static uint64_t VoidAdapter(const uint8_t *p) {
+    VoidLoad(p);
+    return UINT64_C(0x87654321fedcba98);
+}
+`)
+	voidCode := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\nMOVQ (DI),AX\nMOVQ $0x87654321fedcba98,AX\nRET\n")
+	var voidBytes []string
+	for _, value := range voidCode {
+		voidBytes = append(voidBytes, fmt.Sprintf("0x%02x", value))
+	}
+	voidSymbol := "OriginalVoid"
+	if strings.Contains(execution.triple, "apple") {
+		voidSymbol = "_" + voidSymbol
+	}
+	fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+voidSymbol+"\n"+voidSymbol+":\n.byte "+strings.Join(voidBytes, ",")+"\n")
+	prototypes.WriteString("extern uint64_t OriginalVoid(const uint8_t*);\n")
+	rows.WriteString("{VoidAdapter,OriginalVoid,8,8,0,1},\n")
+	count++
+	if count != 15 {
+		t.Fatal("Void removed a previous native scalar kernel", count)
+	}
+	requireAMD64RegisterResultGoObject(t, source.String())
+	// Reuse the independent fork/guard-page harness, not the implementation's
+	// operand/effect descriptors. Add byte preservation and room for an
+	// unaligned full-qword input to its scalar value reference.
+	driverTemplate := strings.NewReplacer(
+		"if(k.destination==2)", "if(k.destination==1) return (seed&~UINT64_C(0xff))|(value&0xff);\n    if(k.destination==2)",
+		"uint8_t bytes[8];", "uint8_t bytes[16];",
+		"28 extension kernels", "15 scalar move kernels",
+	).Replace(x86ExtensionNativeRuntimeC)
+	driver := fmt.Sprintf(driverTemplate, prototypes.String(), originals.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					text, level := ir, "-O0"
+					if optimized {
+						text, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "scalar-move-native", text, driver, level)
+					if string(output) != "15 scalar move kernels: numerical 1920, fault 180, tripwires 2; failures 0\n" {
+						t.Fatal("original Go/LLVM native reads differ", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_native_load.go b/amd64_scalar_native_load.go
new file mode 100644
index 000000000..2904994c8
--- /dev/null
+++ b/amd64_scalar_native_load.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Register-addressed memory-to-GP rows of Go's ymovb/ymovw/ymovl/ymovq tables.
+// Register, immediate, static-symbol, FP/AUTO, MMX/X and system-register rows
+// keep their own consumers, including Go's distinct symbol-address roles.
+// This is an ordinary native load shape, not a memory-ownership certificate.
+type x86ScalarNativeLoadForm struct {
+	source      Operand
+	destination Reg
+	bytes       int64
+}
+
+// The decoder binds mode and physical shape separately from source/ABI
+// permissions. Only the paired volatile scalar reader consumes this identity.
+type x86RawScalarSegmentLoadIdentity struct {
+	arch          string
+	bytes         int64
+	segmentPrefix byte
+}
+
+func x86ScalarSegmentLoadRawIdentity(ins Instr, arch string) x86RawScalarSegmentLoadIdentity {
+	arch = x86SourceStackScalarArch(arch)
+	if arch != "amd64" && arch != "386" {
+		return x86RawScalarSegmentLoadIdentity{}
+	}
+	ins.x86Encoded = true // Physical memory is already normalized by the decoder.
+	form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.source.Mem.Segment != FS && form.source.Mem.Segment != GS {
+		return x86RawScalarSegmentLoadIdentity{}
+	}
+	return x86RawScalarSegmentLoadIdentity{arch, form.bytes, ins.x86SegmentPrefix}
+}
+
+func x86RawScalarSegmentLoadSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	identity := x86ScalarSegmentLoadRawIdentity(ins, arch)
+	return ins.x86Encoded && origin != nil && identity.arch != "" && identity == origin.scalarSegmentLoad &&
+		origin.op == ins.Op && reflect.DeepEqual(origin.args, ins.Args) &&
+		origin.vectorBytes == ins.x86VectorBytes && origin.addressBits == ins.x86AddressBits &&
+		ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0 &&
+		ins.x86RawNearReturn == nil && !ins.x86RIPLiteral && ins.x86NumericalRead == nil
+}
+
+func x86ScalarNativeLoadProperties(op Op, ins Instr, arch string) (x86ScalarNativeLoadForm, bool, error) {
+	form, known, err := x86ScalarRegisterLoadProperties(op, ins, arch)
+	if !known || err != nil {
+		return form, known, err
+	}
+	if !x86OrdinaryNativeMemoryOperand(form.source, arch) {
+		return x86ScalarNativeLoadForm{}, false, nil
+	}
+	return form, true, nil
+}
+
+// The machine grammar is independent of whether BP denotes an ordinary
+// native input, a private frame, or an unavailable physical entry register.
+// Each consumer must select that role before calling the common emitter.
+func x86ScalarRegisterLoadProperties(op Op, ins Instr, arch string) (x86ScalarNativeLoadForm, bool, error) {
+	if form, known, err := x86ScalarMoveAliasProperties(op, ins, arch); known {
+		if err != nil {
+			return x86ScalarNativeLoadForm{}, true, err
+		}
+		if form.spec.load {
+			return x86ScalarNativeLoadForm{}, false, nil // Existing extension storage consumer.
+		}
+		op = form.spec.canonical
+	}
+	local := ins
+	local.Op = op
+	canonical := x86SourceMoveInstruction(local, arch).Op
+	width := x86RawReturnScalarMoveBytes(canonical)
+	if width == 0 || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg {
+		return x86ScalarNativeLoadForm{}, false, nil
+	}
+	source, destination := ins.Args[0], ins.Args[1].Reg
+	if source.Mem.Sym != "" {
+		return x86ScalarNativeLoadForm{}, false, nil
+	}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, source, arch); segment {
+		if err != nil {
+			return x86ScalarNativeLoadForm{}, true, err
+		}
+		source = projected
+	}
+	validRegister := isX86YrlRegisterForArch(destination, arch)
+	if width == 1 {
+		validRegister = isGoYmbRegisterForArch(destination, arch)
+	}
+	if !validRegister {
+		return x86ScalarNativeLoadForm{}, false, nil
+	}
+	if arch == "386" && width == 8 || !x86PackedShiftMemoryValid(source, arch) {
+		return x86ScalarNativeLoadForm{}, true, fmt.Errorf("invalid %s native scalar load: %q", arch, ins.Raw)
+	}
+	if width == 1 && arch != "386" &&
+		(x86ExtensionHighRegister(source.Mem.Base) || x86ExtensionHighRegister(source.Mem.Index)) {
+		// Go emits the actual REX byte even with AH/CH/DH/BH source
+		// spellings. Their ModRM numbers then name SP/BP/SI/DI low bytes.
+		switch destination {
+		case AH, CH, DH, BH:
+			destination = amd64YmbEffectiveRegister(destination, 16)
+		}
+	}
+	return x86ScalarNativeLoadForm{source, destination, width}, true, nil
+}
+
+func (c *amd64Ctx) scalarNativeLoadProperties(op Op, ins Instr) (x86ScalarNativeLoadForm, bool, error) {
+	if c.nativeMemoryOperand(ins, 0) {
+		return x86ScalarRegisterLoadProperties(op, ins, c.goarch)
+	}
+	return x86ScalarNativeLoadProperties(op, ins, c.goarch)
+}
+
+func (c *amd64Ctx) lowerScalarNativeLoad(form x86ScalarNativeLoadForm, ins Instr) error {
+	if form.destination != ins.Args[1].Reg && (form.destination == SP || form.destination == BP) {
+		return fmt.Errorf("%w: REX byte alias needs its physical SP/BP write contract", ErrProbeNeedsContext)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return fmt.Errorf("%w: scalar MOV needs its original native address size", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.source)
+	if err != nil {
+		return err
+	}
+	typ := amd64IntegerTypeForBits(int(form.bytes * 8))
+	loaded := c.newTmp()
+	// The fault/read remains observable even when the numerical result is
+	// discarded. This asserts no pointee extent, alignment or nonaliasing.
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", loaded, typ, pointerType, pointer)
+	return c.storeRegSized(form.destination, typ, "%"+loaded)
+}
+
+func x86LoweredScalarNativeLoad(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) && !x86RawScalarSegmentLoadSource(ins, arch) || ins.x86NumericalRead != nil {
+		return false, true // Physical emission does not grant a named numerical continuation.
+	}
+	if x86LogicalSourceFrameRegister(form.destination, arch) {
+		return false, true
+	}
+	if form.source.Mem.Segment != "" {
+		// The hardware segment base is an implicit input of this exact
+		// volatile emitter, not an initialized AS0 pointer or GP zero.
+		// Any explicit offset base still needs its full numerical value;
+		// opaque caller/pointer identities cannot supply those bits.
+		for _, register := range []Reg{form.source.Mem.Base, form.source.Mem.Index} {
+			if register == "" {
+				continue
+			}
+			word := x86ResultPointerWord(arch)
+			index, _, valid := x86ResultGP(register, word, arch)
+			if !valid || !state.shapeOnly && state.pointerGP[index] ||
+				!x86ResultRead(Operand{Kind: OpReg, Reg: register}, word, state, owned, arch) {
+				return false, true
+			}
+		}
+		return x86ResultStore(Operand{Kind: OpReg, Reg: form.destination}, form.bytes, state, owned, resultOffset, arch), true
+	}
+	if !x86ResultReadWithNativeContinuation(ins, form.source, form.bytes, state, owned, arch, true) {
+		return false, true
+	}
+	return x86ResultStore(Operand{Kind: OpReg, Reg: form.destination}, form.bytes, state, owned, resultOffset, arch), true
+}
diff --git a/amd64_scalar_native_rmw_test.go b/amd64_scalar_native_rmw_test.go
new file mode 100644
index 000000000..e43072b3f
--- /dev/null
+++ b/amd64_scalar_native_rmw_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86UnlockedScalarRMWRows(arch string) []x86LockScalarOracleForm {
+	var rows []x86LockScalarOracleForm
+	for _, row := range x86LockScalarOracleForms(arch) {
+		if !strings.HasPrefix(row.op, "BT") {
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86UnlockedScalarRMWFixture(arch, instruction string, result bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	bytes := word * 2
+	declaration := "func Value(p *[16]byte,value uintptr)"
+	finish := ""
+	if result {
+		bytes += 4
+		declaration += " uint32"
+		finish = fmt.Sprintf("MOVL $7,AX\nMOVL AX,ret+%d(FP)\n", word*2)
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\n%s value+%d(FP),CX\nMOVL $1,BX\nCLC\n%s\n%sRET\n",
+		bytes, move, move, word, strings.Replace(instruction, "1(SI)", "-1(DI)(BX*1)", 1), finish)
+	return source, declaration
+}
+
+func TestX86UnlockedScalarRMWCompleteFamilyThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86UnlockedScalarRMWRows(target.arch)
+			want := 72
+			if target.arch == "386" {
+				want = 54
+			}
+			if len(rows) != want {
+				t.Fatal("incomplete independent scalar RMW family", len(rows), want)
+			}
+			var complete, declarations strings.Builder
+			for index, row := range rows {
+				source, declaration := x86UnlockedScalarRMWFixture(target.arch, row.text, true)
+				name := fmt.Sprintf("RMW%d", index)
+				complete.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+				declarations.WriteString(strings.Replace(declaration, "Value", name, 1) + "\n")
+				for _, result := range []bool{true, false} {
+					t.Run(fmt.Sprintf("%s/result=%t", row.text, result), func(t *testing.T) {
+						source, declaration := x86UnlockedScalarRMWFixture(target.arch, row.text, result)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+								if err != nil || ir == "" {
+									t.Fatal("complete numerical RMW lost its paired native continuation", err)
+								}
+							})
+						}
+					})
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, complete.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run("complete-objects/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, complete.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						x86UnlockedScalarRMWCheckBodies(t, text, rows)
+						if strings.Count(text, "load volatile i") != want || strings.Count(text, "store volatile i") != want ||
+							strings.Contains(text, "atomicrmw ") || strings.Contains(text, "lock; ") {
+							t.Fatal("unlocked family lost exact native accesses or acquired atomic semantics")
+						}
+						for _, backend := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, backend)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+// Bind each original body, not just totals or unused helper definitions.
+func x86UnlockedScalarRMWCheckBodies(t *testing.T, ir string, rows []x86LockScalarOracleForm) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for index, row := range rows {
+		function := module.NamedFunction(fmt.Sprintf("RMW%d", index))
+		if function.IsNil() || function.FirstBasicBlock().IsNil() {
+			t.Fatal("original native RMW body disappeared", row.text)
+		}
+		body := function.String()
+		for _, atomic := range []string{"atomicrmw ", "cmpxchg ", "load atomic ", "store atomic ", "lock;"} {
+			if strings.Contains(body, atomic) {
+				t.Fatal("ordinary body acquired an implicit atomic effect", row.text, atomic)
+			}
+		}
+		bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+		loads, stores := 0, 0
+		for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+			for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+				opcode := instruction.InstructionOpcode()
+				if opcode != llvm.Load && opcode != llvm.Store || !instruction.IsVolatile() {
+					continue
+				}
+				typ := instruction.Type()
+				if opcode == llvm.Store {
+					typ = instruction.Operand(0).Type()
+					stores++
+				} else {
+					loads++
+				}
+				if typ.TypeKind() != llvm.IntegerTypeKind || typ.IntTypeWidth() != bits || instruction.Alignment() != 1 {
+					t.Fatal("body has an inexact native RMW width/alignment", row.text, instruction.String())
+				}
+			}
+		}
+		if loads != 1 || stores != 1 {
+			t.Fatal("original body lost its exact paired native access", row.text, loads, stores)
+		}
+	}
+}
+
+func TestX86UnlockedScalarRMWCannotAcquireImplicitLockFromAtomicEntry(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86UnlockedScalarRMWRows(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row.text)
+				context, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{instruction}}, FuncSig{Ret: Void}, nil)
+				context.goarch = arch
+				before, temporary := output.String(), context.tmp
+				known, terminated, err := context.lowerAtomic(instruction.Op, instruction)
+				if known || terminated || err != nil || output.String() != before || context.tmp != temporary {
+					t.Fatal("atomic entry must not silently lock an ordinary instruction", known, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnlockedScalarRMWEmitterKeepsNativeWidthAndNonAtomicIdentity(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86UnlockedScalarRMWRows(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				// This is an unbound emitter unit, not initialized source,
+				// native-memory permission or an executable entry fixture.
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				ctx.blocks = []amd64Block{{instrs: []Instr{ins}}}
+				if _, err := ctx.lowerInstr(0, 0, ins, nil, nil); err != nil {
+					t.Fatal(err)
+				}
+				bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[row.op[len(row.op)-1]]
+				text := output.String()
+				if strings.Count(text, fmt.Sprintf("load volatile i%d,", bits)) != 1 ||
+					strings.Count(text, fmt.Sprintf("store volatile i%d ", bits)) != 1 ||
+					strings.Contains(text, "atomicrmw ") || strings.Contains(text, "lock; ") {
+					t.Fatal("unlocked native RMW lost its exact volatile width or became atomic", text)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnlockedScalarRMWDoesNotInventInputsResultsOrStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple, resultOffset := "x86_64-unknown-linux-gnu", 16
+		if arch == "386" {
+			triple, resultOffset = "i386-unknown-linux-gnu", 8
+		}
+		for _, row := range x86UnlockedScalarRMWRows(arch) {
+			if strings.Contains(row.text, "$1") {
+				continue // Source-format positives are complete; these mutations need GP input.
+			}
+			for _, result := range []bool{true, false} {
+				source, declaration := x86UnlockedScalarRMWFixture(arch, row.text, result)
+				variants := map[string]string{
+					"unknown-base":  strings.Replace(source, "p+0(FP),DI", "p+0(FP),SI", 1),
+					"numeric-base":  strings.Replace(source, "CLC\n", "MOVL $42,DI\nCLC\n", 1),
+					"unknown-index": strings.Replace(source, "MOVL $1,BX\n", "", 1),
+					"pointer-index": strings.Replace(source, "MOVL $1,BX\n", "MOVL DI,BX\n", 1),
+				}
+				if result {
+					variants["missing-result"] = strings.Replace(source,
+						fmt.Sprintf("MOVL AX,ret+%d(FP)\n", resultOffset), "", 1)
+				}
+				if strings.Contains(row.text, ",") {
+					variants["unknown-value"] = strings.Replace(source, ",CX\n", ",DX\n", 1)
+					move := "MOVQ"
+					if arch == "386" {
+						move = "MOVL"
+					}
+					variants["pointer-value"] = strings.Replace(source, "CLC\n", move+" DI,CX\nCLC\n", 1)
+				}
+				if strings.HasPrefix(row.op, "ADC") || strings.HasPrefix(row.op, "SBB") {
+					variants["unknown-carry"] = strings.Replace(source, "CLC\n", "", 1)
+				}
+				for name, changed := range variants {
+					t.Run(fmt.Sprintf("%s/%s/result=%t/%s", arch, row.text, result, name), func(t *testing.T) {
+						if changed == source {
+							t.Fatal("negative mutation did not change the source")
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+								if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Fatal("unlocked RMW manufactured a source, carry or native address", err)
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_native_store.go b/amd64_scalar_native_store.go
new file mode 100644
index 000000000..79e850478
--- /dev/null
+++ b/amd64_scalar_native_store.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's GP stores share their address classes with Zm_r loads. Yi32 immediate
+// rows retain their own encoded width, including sign extension for MOVQ.
+// FP/AUTO, static symbols, segments and SIMD/MMX keep their separate roles.
+type x86ScalarNativeStoreForm struct {
+	source      Operand
+	destination Operand
+	bytes       int64
+}
+
+func x86ScalarNativeStoreProperties(op Op, ins Instr, arch string) (x86ScalarNativeStoreForm, bool, error) {
+	if len(ins.Args) != 2 || !x86OrdinaryNativeMemoryOperand(ins.Args[1], arch) {
+		return x86ScalarNativeStoreForm{}, false, nil
+	}
+	return x86ScalarRegisterStoreProperties(op, ins, arch)
+}
+
+func x86ScalarRegisterStoreProperties(op Op, ins Instr, arch string) (x86ScalarNativeStoreForm, bool, error) {
+	if form, known, err := x86ScalarMoveAliasProperties(op, ins, arch); known {
+		if err != nil {
+			return x86ScalarNativeStoreForm{}, true, err
+		}
+		op = form.spec.canonical
+	}
+	if len(ins.Args) != 2 || (ins.Args[0].Kind != OpReg && ins.Args[0].Kind != OpImm) || ins.Args[1].Kind != OpMem ||
+		ins.Args[1].Mem.Sym != "" || ins.Args[1].Mem.Segment != "" ||
+		ins.Args[1].Mem.Index == FS || ins.Args[1].Mem.Index == GS {
+		return x86ScalarNativeStoreForm{}, false, nil
+	}
+	projected := ins
+	projected.Op = op
+	source := ins.Args[0]
+	register := source
+	if source.Kind == OpImm {
+		register = Operand{Kind: OpReg, Reg: AX} // Validate only the shared native address/width row.
+	}
+	projected.Args = []Operand{ins.Args[1], register}
+	form, known, err := x86ScalarRegisterLoadProperties(op, projected, arch)
+	if !known || err != nil {
+		return x86ScalarNativeStoreForm{}, known, err
+	}
+	if source.Kind == OpImm {
+		if source.ImmRaw != "" || source.ImmIsFloat ||
+			arch != "386" && (source.Imm < -2147483648 || source.Imm > 4294967295) {
+			return x86ScalarNativeStoreForm{}, true, fmt.Errorf("%s %s native store needs Go's resolved Yi32 immediate: %q", arch, op, ins.Raw)
+		}
+		source.Imm = amd64ScalarAddSubImmediateInt64(source.Imm, int(form.bytes*8))
+	} else {
+		source.Reg = form.destination // Preserve the actual Go byte/REX interpretation.
+	}
+	return x86ScalarNativeStoreForm{source, form.source, form.bytes}, true, nil
+}
+
+func (c *amd64Ctx) scalarNativeStoreProperties(op Op, ins Instr) (x86ScalarNativeStoreForm, bool, error) {
+	if c.nativeMemoryOperand(ins, 1) {
+		return x86ScalarRegisterStoreProperties(op, ins, c.goarch)
+	}
+	return x86ScalarNativeStoreProperties(op, ins, c.goarch)
+}
+
+func (c *amd64Ctx) lowerScalarNativeStore(form x86ScalarNativeStoreForm, ins Instr) error {
+	if form.source.Kind == OpReg && form.source.Reg != ins.Args[0].Reg && (form.source.Reg == SP || form.source.Reg == BP) {
+		return fmt.Errorf("%w: REX byte alias needs its physical SP/BP read contract", ErrProbeNeedsContext)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return fmt.Errorf("%w: scalar MOV needs its original native address size", ErrProbeNeedsContext)
+	}
+	typ := amd64IntegerTypeForBits(int(form.bytes * 8))
+	value, err := c.evalIntSized(form.source, typ)
+	if err != nil {
+		return err
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(form.destination)
+	if err != nil {
+		return err
+	}
+	// Preserve even a dead write/fault, with no alignment, extent or alias
+	// assumptions. Continuing this one effect grants no reusable memory fact.
+	fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+	return nil
+}
+
+func x86LoweredScalarNativeStore(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86LoweredScalarNativeStoreWithAddressBits(ins, state, owned, arch, false)
+}
+
+// This scope is not an initialized-value or memory certificate. The complete
+// source flow must separately establish the actual typed address-bit input and
+// native destination. Calls, physical entries and other storage owners cannot
+// borrow this leaf-only bit-copy continuation or its lack of Go safepoints.
+func x86LeafNativeAddressBitStoreScope(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" || fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") ||
+		len(sig.ArgRegs) != 0 || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86DirectTailRoot != nil || sig.x86CallerRegions != nil {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpCALL || !x86ResultNamedPredicateInstruction(ins) {
+			return false
+		}
+	}
+	for _, slot := range sig.Frame.Params {
+		if slot.Type == Ptr && slot.Index >= 0 && slot.Index < len(sig.Args) && sig.Args[slot.Index] == Ptr {
+			return true
+		}
+	}
+	return false
+}
+
+func x86LoweredScalarNativeStoreWithAddressBits(ins Instr, state *x86ResultState, owned []bool,
+	arch string, addressBits bool) (bool, bool) {
+	form, known, err := x86ScalarNativeStoreProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		(form.source.Kind == OpReg && x86LogicalSourceFrameRegister(form.source.Reg, arch)) ||
+		!(x86ResultIncomingPointerAddressIdentity(form.destination, state, arch) ||
+			x86ResultNativeNumericAddress(form.destination, state, arch)) {
+		return false, true
+	}
+	if addressBits && form.bytes == x86ResultPointerWord(arch) && form.source.Kind == OpReg {
+		if root, _, valid := x86ResultGP(form.source.Reg, form.bytes, arch); valid && state.callerAddressGP[root] {
+			// Copy exactly one complete word of actual caller-address bits.
+			// No NUM, pointee, GC-root, escape-safety or reusable address fact
+			// follows from this original volatile effect, even when it succeeds.
+			return true, true
+		}
+	}
+	if addressBits && form.source.Kind == OpReg {
+		if register, mask, valid := x86ResultGP(form.source.Reg, form.bytes, arch); valid &&
+			int(state.nativeLEAAddressBits.register) == register && state.nativeLEAAddressBits.bytes != 0 &&
+			(state.gp[register]|state.nativeLEAAddressBits.bytes)&mask == mask {
+			return true, true // Observe exact adjacent LEA bits without granting numerical initialization.
+		}
+	}
+	// A native NUM store likewise changes no logical bytes or register facts.
+	// Standalone, caller and physical-frame observers have no paired emitter.
+	return x86ResultRead(form.source, form.bytes, state, owned, arch), true
+}
diff --git a/amd64_scalar_physical_move_forms.go b/amd64_scalar_physical_move_forms.go
new file mode 100644
index 000000000..ba38c351d
--- /dev/null
+++ b/amd64_scalar_physical_move_forms.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Complete scalar GP move operand roles, independent of native storage,
+// frame or numerical-input authority. GP/XMM rows use their existing form.
+type x86ScalarPhysicalMoveForm struct {
+	source, destination Operand
+	bits                int
+	address             bool
+}
+
+func x86ScalarPhysicalMoveProperties(ins Instr, arch string) (x86ScalarPhysicalMoveForm, bool, error) {
+	width := x86RawReturnScalarMoveBytes(ins.Op)
+	f := x86ScalarPhysicalMoveForm{bits: int(width * 8)}
+	if width == 0 {
+		return f, false, nil
+	}
+	fail := func() (x86ScalarPhysicalMoveForm, bool, error) {
+		return f, true, fmt.Errorf("%s scalar GP move shape: %q", arch, ins.Raw)
+	}
+	if len(ins.Args) != 2 ||
+		arch != "amd64" && arch != "386" || arch == "386" && width == 8 {
+		return fail()
+	}
+	f.source, f.destination = ins.Args[0], ins.Args[1]
+	gp := func(o Operand) bool {
+		if o.Kind != OpReg {
+			return false
+		}
+		if width == 1 {
+			return isGoYmbRegisterForArch(o.Reg, arch)
+		}
+		return isX86YrlRegisterForArch(o.Reg, arch)
+	}
+	mem := func(o Operand) bool { return x86ScalarCompareMemoryValid(o, arch) }
+	if f.source.Kind == OpSym && strings.HasPrefix(f.source.Sym, "$") {
+		address := f.source
+		address.Sym = strings.TrimPrefix(address.Sym, "$")
+		_, _, valid := x86ScalarCompareSBAddress(address, arch)
+		if width == 1 || !valid || !gp(f.destination) {
+			return fail()
+		}
+		f.address = true
+		return f, true, nil
+	}
+	if !gp(f.destination) && !mem(f.destination) ||
+		!gp(f.source) && !mem(f.source) && f.source.Kind != OpImm ||
+		!gp(f.destination) && !gp(f.source) && f.source.Kind != OpImm {
+		return fail()
+	}
+	if f.source.Kind == OpImm {
+		value := f.source.Imm
+		if f.source.ImmRaw != "" || f.source.ImmIsFloat ||
+			(width != 8 || !gp(f.destination)) && (value < -2147483648 || value > 4294967295) {
+			return fail()
+		}
+		if width != 8 || !gp(f.destination) {
+			f.source.Imm = amd64ScalarAddSubImmediateInt64(value, f.bits)
+		}
+	}
+	if width == 1 && x86CompareExchangeHasREXByteView(x86CompareExchangeForm{source: f.source, destination: f.destination}) {
+		for _, o := range []*Operand{&f.source, &f.destination} {
+			if o.Kind == OpReg && (o.Reg == AH || o.Reg == CH || o.Reg == DH || o.Reg == BH) {
+				o.Reg = amd64YmbEffectiveRegister(o.Reg, 16)
+			}
+		}
+	}
+	return f, true, nil
+}
diff --git a/amd64_scalar_precision_forms.go b/amd64_scalar_precision_forms.go
new file mode 100644
index 000000000..798eff65f
--- /dev/null
+++ b/amd64_scalar_precision_forms.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarPrecisionSpec struct {
+	inputBits, outputBits int
+	legacy                bool
+}
+
+// Input and output precision are independent. In particular, a copied upper
+// starts after the output scalar, while the memory tuple has the input width.
+var x86ScalarPrecisionSpecs = map[Op]x86ScalarPrecisionSpec{
+	"CVTSS2SD": {32, 64, true}, "CVTSD2SS": {64, 32, true},
+	"VCVTSS2SD": {32, 64, false}, "VCVTSD2SS": {64, 32, false},
+}
+
+type x86ScalarPrecisionForm struct {
+	x86FloatBinaryForm
+	spec x86ScalarPrecisionSpec
+	sae  bool
+}
+
+// Generation is a native ISA restriction, not numerical-input authority.
+// Plain low-bank physical EVEX must not silently become its VEX spelling.
+func x86ScalarPrecisionNativeEVEX(ins Instr, form x86ScalarPrecisionForm) bool {
+	if form.spec.legacy {
+		return false
+	}
+	if ins.x86ScalarPrecisionEVEX || form.mask >= 0 || form.sae || form.rounding != "" {
+		return true
+	}
+	for _, operand := range ins.Args {
+		if index, vector := amd64ParseXReg(operand.Reg); operand.Kind == OpReg && vector && index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ScalarPrecisionProperties(op Op, ins Instr, arch string) (x86ScalarPrecisionForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ScalarPrecisionSpecs[Op(base)]
+	form := x86ScalarPrecisionForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	controls, valid := parseAMD64BinaryFloatingSuffix(suffix)
+	if !valid || dotted && suffix == "" || spec.legacy && dotted || controls.broadcast ||
+		controls.sae && spec.inputBits != 32 || controls.rounding != "" && spec.inputBits != 64 ||
+		ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return form, true, fmt.Errorf("%s %s outside Go scalar precision controls: %q", arch, op, ins.Raw)
+	}
+	// Only the complete operand axes are projected. The original opcode and
+	// control are retained by this form and by every numerical/native consumer.
+	local, contextual := x86VectorValueMemoryInput(ins, arch)
+	local.Op = Op(base)
+	if controls.zeroing {
+		local.Op += ".Z"
+	}
+	var err error
+	form.x86FloatBinaryForm, err = x86FloatBinaryOperandProperties(local, arch, spec.inputBits, spec.legacy, true, false, "scalar precision conversion")
+	form.rounding, form.sae = controls.rounding, controls.sae
+	if err != nil {
+		return form, true, err
+	}
+	if form.memory >= 0 {
+		if controls.sae || controls.rounding != "" {
+			return form, true, fmt.Errorf("%s %s embedded control requires a register source", arch, op)
+		}
+		if contextual {
+			return form, true, x86VectorValueMemoryContext(ins)
+		}
+		if err := x86NamedMultiplyMemoryError(ins.Args[0], arch); err != nil {
+			return form, true, err
+		}
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, true, err
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return form, true, fmt.Errorf("%w: %s needs its original default address mode", ErrProbeNeedsContext, op)
+	}
+	return form, true, nil
+}
+
+func x86TypedScalarPrecisionByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ScalarPrecisionProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for index, operand := range ins.Args {
+		width := int64(16)
+		if index == 0 {
+			width = int64(form.spec.inputBits / 8)
+		} else if index == form.mask {
+			width = 8
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: index, operand: operand, width: width,
+			read:  index != form.destination || form.spec.legacy || form.mask >= 0 && !form.zeroing,
+			write: index == form.destination,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_scalar_reciprocal_forms.go b/amd64_scalar_reciprocal_forms.go
new file mode 100644
index 000000000..936b1921d
--- /dev/null
+++ b/amd64_scalar_reciprocal_forms.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarReciprocalSpec struct {
+	opcode byte
+	vector bool
+}
+
+// Go's yxm and _yvrcpss tables contain exactly these scalar estimate forms.
+// RCP14/28, packed estimates, EVEX and masks have separate source grammars.
+var x86ScalarReciprocalSpecs = map[Op]x86ScalarReciprocalSpec{
+	"RCPSS": {0x53, false}, "RSQRTSS": {0x52, false},
+	"VRCPSS": {0x53, true}, "VRSQRTSS": {0x52, true},
+}
+
+type x86ScalarReciprocalForm struct {
+	spec              x86ScalarReciprocalSpec
+	base, destination int
+}
+
+func x86ScalarReciprocalProperties(op Op, ins Instr, arch string) (x86ScalarReciprocalForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86ScalarReciprocalSpecs[Op(name)]
+	form := x86ScalarReciprocalForm{spec: spec, base: 1, destination: len(ins.Args) - 1}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86ScalarReciprocalForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go scalar reciprocal grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	want := 2
+	if spec.vector {
+		want = 3
+	}
+	if len(ins.Args) != want {
+		return fail()
+	}
+	vector := func(operand Operand) bool {
+		index, valid := amd64ParseXReg(operand.Reg)
+		limit := 16
+		if !spec.vector && arch == "386" {
+			limit = 8
+		}
+		return operand.Kind == OpReg && valid && index < limit
+	}
+	if !vector(ins.Args[form.base]) || !vector(ins.Args[form.destination]) {
+		return fail()
+	}
+	source := ins.Args[0]
+	if !vector(source) {
+		if spec.vector && x86Mode32UnboundVEXMemorySource(source, arch) {
+			return form, true, fmt.Errorf("%w: 386 %s extended source base has no physical address binding", ErrProbeNeedsContext, op)
+		}
+		if !isAMD64MemoryOperand(source) || !x86PackedShiftMemoryValid(source, arch) {
+			return fail()
+		}
+		if err := x86NamedMultiplyMemoryError(source, arch); err != nil {
+			return form, true, err
+		}
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, true, err
+	}
+	return form, true, nil
+}
+
+// Go's non-SIB asmandsz branch accepts an extended base spelling before
+// physical mode32 binding. asmidx rejects extended base/index SIB forms.
+// This recognizes frontend syntax only; it supplies no address permission.
+func x86Mode32UnboundVEXMemorySource(source Operand, arch string) bool {
+	if arch != "386" || source.Kind != OpMem || source.Mem.Index != "" || source.Mem.Base == "R12" ||
+		x86MemoryRegistersValidForArch(source.Mem, arch) {
+		return false
+	}
+	frontend := source
+	if frontend.Mem.Off == int64(uint32(frontend.Mem.Off)) {
+		// Normalize only this grammar check, never the original operand.
+		frontend.Mem.Off = int64(int32(frontend.Mem.Off))
+	}
+	return x86PackedShiftMemoryValid(frontend, "amd64") && x86NamedMultiplyMemoryError(frontend, "amd64") == nil
+}
+
+func x86TypedScalarReciprocalByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86ScalarReciprocalProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for index, operand := range ins.Args {
+		width := int64(16)
+		if index == 0 {
+			width = 4
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: index, operand: operand, width: width,
+			read: index == 0 || index == form.base, write: index == form.destination,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_scalar_relocation_runtime_linux_test.go b/amd64_scalar_relocation_runtime_linux_test.go
new file mode 100644
index 000000000..7127961ce
--- /dev/null
+++ b/amd64_scalar_relocation_runtime_linux_test.go
@@ -0,0 +1,138 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarAbsoluteRelocation(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	compiler, compilerErr := exec.LookPath("i686-linux-gnu-gcc")
+	qemu, qemuErr := exec.LookPath("qemu-i386")
+	if llc == "" || compilerErr != nil || qemuErr != nil {
+		t.Fatal("LLVM 22, IA32 Linux compiler and pinned QEMU required", compilerErr, qemuErr)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·Value(SB),4,$0-0\n")
+	index := 0
+	for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		for _, seed := range []uint32{0, 0xffffffff, 0x81234567} {
+			for _, carry := range []string{"CLC", "STC"} {
+				fmt.Fprintf(&source, "MOVL $%d,AX\n%s\n%sL $·cell+8(SB),AX\nMOVL AX,·result+%d(SB)\nMOVL $0,BX\nSETCS BX\nMOVL BX,·result+%d(SB)\n",
+					seed, carry, stem, index*8, index*8+4)
+				index++
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	if index != 42 {
+		t.Fatal("incomplete independent operation/seed/carry matrix", index)
+	}
+	run := func(executable string) {
+		t.Helper()
+		command := runtimeOracleGuestArguments(t, []string{qemu, "-L", "/usr/i686-linux-gnu"}, executable)
+		if output := x86FloatCompareCaptureCommand(t, exec.Command(command[0], command[1:]...)); string(output) != "OK 42\n" {
+			t.Fatalf("incomplete IA32 relocated-value/carry observations: %q", output)
+		}
+	}
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386",
+		"package main\nfunc Value()\n", source.String(), x86ScalarRelocationOriginalGo)
+	run(original)
+	llvmSource, llvmReference := x86ScalarRelocationOwnedLLVMFixture(t, source.String(), x86ScalarRelocationReferenceC)
+	for _, api := range []string{"text", "module", "go"} {
+		ir, err := x86AddressMemoryAPI(t, api, llvmSource, "386", "i386-unknown-linux-gnu")
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(api+level, func(t *testing.T) {
+				dir := t.TempDir()
+				input, driver := filepath.Join(dir, "source.ll"), filepath.Join(dir, "reference.c")
+				object, executable := filepath.Join(dir, "source.o"), filepath.Join(dir, "reference")
+				for name, data := range map[string]string{input: ir, driver: llvmReference} {
+					if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+				x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-O2", "-no-pie", object, driver, "-o", executable))
+				run(executable)
+			})
+		}
+	}
+}
+
+const x86ScalarRelocationOriginalGo = `package main
+import ("fmt"; "unsafe")
+var cell = [32]byte{0xa7}
+var result [84]uint32
+func main() {
+    Value()
+    address := uint64(uintptr(unsafe.Pointer(&cell[8])))
+    index := 0
+    for operation := 0; operation < 7; operation++ {
+        for _, initial := range []uint64{0, 0xffffffff, 0x81234567} {
+            for carry := uint64(0); carry < 2; carry++ {
+                var value, flag uint64
+                switch operation {
+                case 0: value = initial + address; flag = value >> 32
+                case 1: value = initial - address; if initial < address { flag = 1 }
+                case 2: value = initial + address + carry; flag = value >> 32
+                case 3: value = initial - address - carry; if initial < address + carry { flag = 1 }
+                case 4: value = initial & address
+                case 5: value = initial | address
+                case 6: value = initial ^ address
+                }
+                if result[index*2] != uint32(value) || result[index*2+1] != uint32(flag) {
+                    panic(fmt.Sprintf("original relocation case %d: %x/%x want %x/%x", index, result[index*2], result[index*2+1], uint32(value), flag))
+                }
+                index++
+            }
+        }
+    }
+    fmt.Printf("OK %d\n", index)
+}
+`
+
+const x86ScalarRelocationReferenceC = `
+#include <stdint.h>
+#include <stdio.h>
+uint8_t cell[32] = {0xa7};
+uint32_t result[84];
+extern void Value(void);
+int main(void) {
+    Value();
+    uint64_t address = (uintptr_t)&cell[8];
+    uint32_t seeds[] = {0, UINT32_MAX, 0x81234567};
+    unsigned index = 0;
+    for (unsigned operation = 0; operation < 7; operation++) {
+        for (unsigned seed = 0; seed < 3; seed++) {
+            for (unsigned carry = 0; carry < 2; carry++, index++) {
+                uint64_t initial = seeds[seed], value = 0, flag = 0;
+                switch (operation) {
+                case 0: value = initial + address; flag = value >> 32; break;
+                case 1: value = initial - address; flag = initial < address; break;
+                case 2: value = initial + address + carry; flag = value >> 32; break;
+                case 3: value = initial - address - carry; flag = initial < address + carry; break;
+                case 4: value = initial & address; break;
+                case 5: value = initial | address; break;
+                case 6: value = initial ^ address; break;
+                }
+                if (result[index*2] != (uint32_t)value || result[index*2+1] != flag) {
+                    fprintf(stderr, "LLVM relocation case %u: %x/%x want %x/%x\n", index,
+                        result[index*2], result[index*2+1], (uint32_t)value, (uint32_t)flag);
+                    return 1;
+                }
+            }
+        }
+    }
+    printf("OK %u\n", index);
+    return 0;
+}
+`
diff --git a/amd64_scalar_relocation_storage_fixture_test.go b/amd64_scalar_relocation_storage_fixture_test.go
new file mode 100644
index 000000000..170f2d182
--- /dev/null
+++ b/amd64_scalar_relocation_storage_fixture_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const x86ScalarRelocationStoragePrefix = "DATA ·cell+0(SB)/1,$0xa7\n" +
+	"GLOBL ·cell(SB),16,$32\nGLOBL ·result(SB),16,$336\n"
+
+// This captures the original unmodified ASM builder and reference payloads,
+// not the runtime driver's wiring, tool selection or implementation methods.
+func x86ScalarRelocationOriginalFixture(t *testing.T) (assembly, originalGo, reference string, driver []byte) {
+	t.Helper()
+	driver, err := os.ReadFile("amd64_scalar_relocation_runtime_linux_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(driver)
+	start := strings.Index(text, "\tvar source strings.Builder\n")
+	end := strings.Index(text, "\trun := func(")
+	if start < 0 || end <= start || fmt.Sprintf("%x", sha256.Sum256(driver[start:end])) !=
+		"9494401542aad43bd2b99e91c60c2deba1d8e26e6cbd3537fceb0122df49a0c7" {
+		t.Fatal("original complete 42-case ASM construction changed")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·Value(SB),4,$0-0\n")
+	index := 0
+	for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		for _, seed := range []uint32{0, 0xffffffff, 0x81234567} {
+			for _, carry := range []string{"CLC", "STC"} {
+				fmt.Fprintf(&source, "MOVL $%d,AX\n%s\n%sL $·cell+8(SB),AX\nMOVL AX,·result+%d(SB)\nMOVL $0,BX\nSETCS BX\nMOVL BX,·result+%d(SB)\n",
+					seed, carry, stem, index*8, index*8+4)
+				index++
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	assembly = source.String()
+	if index != 42 || fmt.Sprintf("%x", sha256.Sum256([]byte(assembly))) !=
+		"f616eb040c6a5e958c9f6273b764aab7434675ab0b2b892d7004fb94a01bebda" {
+		t.Fatal("original complete ASM payload changed")
+	}
+	parsed, err := parser.ParseFile(token.NewFileSet(), "original.go", driver, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values := make(map[string]string)
+	for _, declaration := range parsed.Decls {
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok || general.Tok != token.CONST {
+			continue
+		}
+		for _, spec := range general.Specs {
+			value := spec.(*ast.ValueSpec)
+			if len(value.Names) == 1 && len(value.Values) == 1 {
+				literal, ok := value.Values[0].(*ast.BasicLit)
+				if ok && literal.Kind == token.STRING {
+					values[value.Names[0].Name], err = strconv.Unquote(literal.Value)
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+		}
+	}
+	originalGo, reference = values["x86ScalarRelocationOriginalGo"], values["x86ScalarRelocationReferenceC"]
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(originalGo))) != "0ac7f99dc09dd95dd05e3de1d4688a3f758b9f75c9af502d3f4aaf9622482bea" ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(reference))) != "33173d2c83173a738d76aecedced3372f5c42fcdcdafea102ec5c604d35cf0ca" {
+		t.Fatal("original stock-Go/C comparisons or storage definitions changed")
+	}
+	return
+}
+
+// LLVM owns the actual objects; C only names them. Neither a C declaration nor
+// a linked address supplies a standalone source/storage capability.
+func x86ScalarRelocationOwnedLLVMFixture(t *testing.T, assembly, reference string) (string, string) {
+	t.Helper()
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(assembly))) != "f616eb040c6a5e958c9f6273b764aab7434675ab0b2b892d7004fb94a01bebda" ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(reference))) != "33173d2c83173a738d76aecedced3372f5c42fcdcdafea102ec5c604d35cf0ca" {
+		t.Fatal("owned counterpart requires the complete original ASM/C")
+	}
+	for _, pair := range [][2]string{
+		{"uint8_t cell[32] = {0xa7};", "extern uint8_t cell[32];"},
+		{"uint32_t result[84];", "extern uint32_t result[84];"},
+	} {
+		if strings.Count(reference, pair[0]) != 1 {
+			t.Fatal("one exact original C storage definition required", pair[0])
+		}
+		reference = strings.Replace(reference, pair[0], pair[1], 1)
+	}
+	return x86ScalarRelocationStoragePrefix + assembly, reference
+}
+
+func TestX86ScalarAbsoluteRelocationOriginalProgramRetainsUnboundStorage(t *testing.T) {
+	assembly, originalGo, _, _ := x86ScalarRelocationOriginalFixture(t)
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386",
+		"package main\nfunc Value()\n", assembly, originalGo)
+	if _, err := x87IA32StaticExecutable(original); err != nil {
+		t.Fatal("complete original stock-Go IA32 executable prior", err)
+	}
+	for _, api := range []string{"text", "module", "go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86AddressMemoryAPI(t, api, assembly, "386", "i386-unknown-linux-gnu")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original unbound C/Go storage became public source authority", err)
+			}
+		})
+	}
+}
+
+func TestX86ScalarAbsoluteRelocationOwnedOriginalProgramObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	original, _, reference, _ := x86ScalarRelocationOriginalFixture(t)
+	assembly, companion := x86ScalarRelocationOwnedLLVMFixture(t, original, reference)
+	if !strings.HasSuffix(assembly, original) || strings.Count(companion, "extern uint8_t cell[32];") != 1 ||
+		strings.Count(companion, "extern uint32_t result[84];") != 1 {
+		t.Fatal("counterpart changed original instructions or lost actual module-owned storage")
+	}
+	for _, target := range x86AddressMemoryTargets("386") {
+		t.Run(target, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", target, assembly)
+			for _, api := range []string{"text", "module", "go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86AddressMemoryAPI(t, api, assembly, "386", target)
+					if err != nil || ir == "" {
+						t.Fatal("same complete original program with actual owned storage", err)
+					}
+					if !strings.Contains(ir, "ptrtoint ptr") || strings.Contains(ir, "load i32, ptr @cell") ||
+						strings.Contains(ir, "load volatile i32, ptr @cell") {
+						t.Fatal("R_ADDR value became a pointee read")
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86ScalarRelocationRuntimeStorageWiring(source []byte) error {
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "runtime.go", source, 0)
+	if err != nil {
+		return err
+	}
+	var function *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if candidate, ok := declaration.(*ast.FuncDecl); ok && candidate.Name.Name == "TestCrossLinuxRuntimeMatrixX86ScalarAbsoluteRelocation" {
+			function = candidate
+		}
+	}
+	if function == nil || function.Body == nil {
+		return fmt.Errorf("missing complete original runtime owner")
+	}
+	var body bytes.Buffer
+	if err := format.Node(&body, set, function.Body); err != nil {
+		return err
+	}
+	text := body.String()
+	// Formatting the AST removes comments. Every required call consumes the
+	// exact bound source/C, not an unused variable or printed command marker.
+	ordered := []string{
+		`x86OrderingHintBuildOriginal(t, t.TempDir(), "linux", "386",`,
+		`"package main\nfunc Value()\n", source.String(), x86ScalarRelocationOriginalGo)`,
+		`run(original)`,
+		`llvmSource, llvmReference := x86ScalarRelocationOwnedLLVMFixture(t, source.String(), x86ScalarRelocationReferenceC)`,
+		`for _, api := range []string{"text", "module", "go"}`,
+		`x86AddressMemoryAPI(t, api, llvmSource, "386", "i386-unknown-linux-gnu")`,
+		`for _, level := range []string{"-O0", "-O2"}`,
+		`map[string]string{input: ir, driver: llvmReference}`,
+		`exec.Command(llc, level, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", input, "-o", object)`,
+		`exec.Command(compiler, "-O2", "-no-pie", object, driver, "-o", executable)`,
+		`run(executable)`,
+	}
+	offset := 0
+	for _, required := range ordered {
+		at := strings.Index(text[offset:], required)
+		if at < 0 || strings.Count(text, required) != 1 {
+			return fmt.Errorf("missing exact owned storage/execution contract: %s", required)
+		}
+		offset += at + len(required)
+	}
+	return nil
+}
+
+func TestX86ScalarAbsoluteRelocationRuntimeUsesActualOwnedStorage(t *testing.T) {
+	_, _, _, original := x86ScalarRelocationOriginalFixture(t)
+	binding := "\tllvmSource, llvmReference := x86ScalarRelocationOwnedLLVMFixture(t, source.String(), x86ScalarRelocationReferenceC)\n"
+	wiredAPI := `x86AddressMemoryAPI(t, api, llvmSource, "386", "i386-unknown-linux-gnu")`
+	unwiredAPI := `x86AddressMemoryAPI(t, api, source.String(), "386", "i386-unknown-linux-gnu")`
+	wiredC := `map[string]string{input: ir, driver: llvmReference}`
+	unwiredC := `map[string]string{input: ir, driver: x86ScalarRelocationReferenceC}`
+	unwired := string(original)
+	for _, pair := range [][2]string{{binding, ""}, {wiredAPI, unwiredAPI}, {wiredC, unwiredC}} {
+		if strings.Count(unwired, pair[0]) != 1 {
+			t.Fatal("actual owner lost one exact source/storage binding", pair[0])
+		}
+		unwired = strings.Replace(unwired, pair[0], pair[1], 1)
+	}
+	if x86ScalarRelocationRuntimeStorageWiring([]byte(unwired)) == nil {
+		t.Fatal("independent unwired owner acquired an owned-storage contract")
+	}
+	complete := strings.Replace(unwired, "\trun(original)\n", "\trun(original)\n"+binding, 1)
+	complete = strings.Replace(complete, `x86AddressMemoryAPI(t, api, source.String(), "386", "i386-unknown-linux-gnu")`,
+		`x86AddressMemoryAPI(t, api, llvmSource, "386", "i386-unknown-linux-gnu")`, 1)
+	complete = strings.Replace(complete, `map[string]string{input: ir, driver: x86ScalarRelocationReferenceC}`,
+		`map[string]string{input: ir, driver: llvmReference}`, 1)
+	if complete != string(original) {
+		t.Fatal("independent binding round trip changed the actual complete runtime owner")
+	}
+	if err := x86ScalarRelocationRuntimeStorageWiring([]byte(complete)); err != nil {
+		t.Fatal("independent complete wiring control", err)
+	}
+	for _, mutation := range [][2]string{
+		{`(t, source.String(), x86ScalarRelocationReferenceC)`, `(t, "wrong", x86ScalarRelocationReferenceC)`},
+		{`(t, source.String(), x86ScalarRelocationReferenceC)`, `(t, source.String(), "wrong")`},
+		{`(t, api, llvmSource,`, `(t, api, source.String(),`},
+		{`driver: llvmReference`, `driver: x86ScalarRelocationReferenceC`},
+		{`x86OrderingHintBuildOriginal(`, `otherBuilder(`},
+		{`run(original)`, `_ = original`},
+		{`[]string{"text", "module", "go"}`, `[]string{"text", "module"}`},
+		{`[]string{"-O0", "-O2"}`, `[]string{"-O0"}`},
+		{`run(executable)`, `_ = executable`},
+	} {
+		changed := strings.Replace(complete, mutation[0], mutation[1], 1)
+		if changed == complete || x86ScalarRelocationRuntimeStorageWiring([]byte(changed)) == nil {
+			t.Fatal("incomplete source/storage/execution substitution passed", mutation)
+		}
+	}
+	if err := x86ScalarRelocationRuntimeStorageWiring(original); err != nil {
+		t.Fatal("actual original owner has not bound its LLVM storage counterpart", err)
+	}
+}
diff --git a/amd64_scalar_relocation_test.go b/amd64_scalar_relocation_test.go
new file mode 100644
index 000000000..3f42ebc98
--- /dev/null
+++ b/amd64_scalar_relocation_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// yaddl's Yi32 rows have an absolute four-byte relocation sink on non-shared
+// 386. TYPE_ADDR is still not a memory operand or a caller/frame capability.
+func TestX86ScalarAbsoluteRelocationCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		for _, destination := range []string{"AX", "BX", "CX", "DX", "SI", "DI", "BP", "SP", "(AX)", "·sink(SB)"} {
+			row := stem + "L $·cell+8(SB)," + destination
+			t.Run(row, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\nMOVL $0,AX\nCLC\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				ins := x86PureGPUnknownInstruction(t, row)
+				if _, known, err := x86LockScalarRMWProperties(ins.Op, ins, "386"); !known || err != nil {
+					t.Fatalf("Go-accepted absolute source was lost by typed grammar: %v", err)
+				}
+				// Physical SP/BP and native writes retain separate entry/storage
+				// contracts. Their source rows above are Go-object observations.
+				if destination == "SP" || destination == "BP" || destination == "(AX)" {
+					return
+				}
+				for _, target := range x86AddressMemoryTargets("386") {
+					for _, api := range []string{"text", "module", "go"} {
+						ir, err := x86AddressMemoryAPI(t, api, source, "386", target)
+						if destination == "·sink(SB)" {
+							// The original source declares neither external object's
+							// storage. Keep its complete Go/emitter objects, not a
+							// fabricated public numerical-memory proof. Independent
+							// initialized DATA counterparts exercise public lowering.
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("unbound original storage acquired public input facts", err)
+							}
+							if api != "text" {
+								continue
+							}
+							file, parseErr := Parse(ArchAMD64, source)
+							if parseErr != nil {
+								t.Fatal(parseErr)
+							}
+							ir = x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}, "386", target, 0)
+						} else if err != nil {
+							t.Fatalf("%s %s: %v", target, api, err)
+						}
+						if !strings.Contains(ir, "ptrtoint ptr") || strings.Contains(ir, "load i32, ptr @cell") {
+							t.Fatal("relocated immediate became a source memory read")
+						}
+						x86ResultInitializationObject(t, llc, target, ir, "scalar-relocation")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarAbsoluteRelocationSourceAxesAndBoundaries(t *testing.T) {
+	for _, source := range []string{
+		"$·cell(SB)", "$cell<>-8(SB)", "$other·cell+8(SB)", "$runtime·callbackasm(SB)",
+		"$·cell(SB)(AX)", "$·cell(SB)(CX*4)", "$·cell(SB)(R8)(X1*4)",
+	} {
+		row := "SUBL " + source + ",AX"
+		goAssemblerOracleOutput(t, "386", "TEXT ·Value(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+		ins := x86PureGPUnknownInstruction(t, row)
+		if _, known, err := x86LockScalarRMWProperties(ins.Op, ins, "386"); !known || err != nil {
+			t.Fatalf("relocation source axis %s: %v", source, err)
+		}
+	}
+	for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, width := range "BWLQ" {
+				if arch == "386" && width == 'L' {
+					continue
+				}
+				row := fmt.Sprintf("%s%c $·cell(SB),AX", stem, width)
+				ins := x86PureGPUnknownInstruction(t, row)
+				if _, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Fatalf("relocation widened beyond its actual four-byte source-mode sink: %s %s", arch, row)
+				}
+				// B/W have no relocation sink; an assembler backend diagnostic
+				// is not source-rejection evidence. AMD64 uses Yiauto, not Yi32.
+				if arch == "amd64" {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_rmw_tls_test.go b/amd64_scalar_rmw_tls_test.go
new file mode 100644
index 000000000..c21368cb7
--- /dev/null
+++ b/amd64_scalar_rmw_tls_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ScalarRMWTLSRows(arch string) []string {
+	var rows []string
+	for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR", "INC", "DEC", "NEG", "NOT", "BTC", "BTR", "BTS"} {
+		unary := stem == "INC" || stem == "DEC" || stem == "NEG" || stem == "NOT"
+		bitString := strings.HasPrefix(stem, "BT")
+		for _, width := range "BWLQ" {
+			if width == 'Q' && arch == "386" || width == 'B' && bitString {
+				continue
+			}
+			opcode := stem + string(width)
+			for _, address := range []string{"8(TLS)", "8(CX)(TLS*1)", "8(CX)(TLS*4)"} {
+				if unary {
+					rows = append(rows, opcode+" "+address)
+					continue
+				}
+				rows = append(rows, opcode+" AX,"+address, opcode+" $1,"+address)
+				if !bitString {
+					rows = append(rows, opcode+" "+address+",AX")
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86ScalarRMWTLSCompleteFamilyNeedsSourceContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86ScalarRMWTLSRows(arch)
+		var original strings.Builder
+		for index, row := range rows {
+			fmt.Fprintf(&original, "TEXT ·tls%d(SB),4,$0-0\n%s\nRET\n", index, row)
+		}
+		goos := "linux"
+		if arch == "386" {
+			goos = "freebsd" // This actual profile accepts direct TLS source.
+		}
+		x86ScalarCompareTLSGoObject(t, original.String(), arch, goos, false)
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, row)
+				_, recognized, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if !recognized || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-accepted TLS row must retain its source role: %v", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·probe(SB),4,$0-0\n"+row+"\nRET\n",
+						"func probe()", arch, "", api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("%s emitted or reclassified unbound TLS: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarRMWTLSCannotHideMalformedOperands(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ScalarRMWTLSRows(arch) {
+			for _, mutate := range []func(*MemRef){
+				func(memory *MemRef) { memory.Scale = 3 },
+				func(memory *MemRef) { memory.OffRaw = "missing" },
+				func(memory *MemRef) { memory.IndexExt = ExtendUXTW },
+			} {
+				ins := x86PureGPUnknownInstruction(t, row)
+				for index := range ins.Args {
+					if ins.Args[index].Kind == OpMem {
+						mutate(&ins.Args[index].Mem)
+					}
+				}
+				_, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s invalid TLS shape hidden by Context: %+v: %v", arch, ins.Args, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_shift_flags.go b/amd64_scalar_shift_flags.go
new file mode 100644
index 000000000..3c1b49d56
--- /dev/null
+++ b/amd64_scalar_shift_flags.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import "fmt"
+
+// Keep defined, preserved and ISA-choice arms separate. Only the paired result
+// observer may consume these finite choices; the ordinary typed effect retains
+// its stricter availability contract. Nothing restores native entry FLAGS.
+func (c *amd64Ctx) emitScalarShiftFlags(stem string, bits int, before, result, count string, double bool) {
+	ty := amd64IntegerTypeForBits(bits)
+	predicate := func(comparison string, amount int) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp %s i64 %s, %d\n", name, comparison, count, amount)
+		return "%" + name
+	}
+	nonzero, multiple := predicate("ne", 0), predicate("ugt", 1)
+	outside := "false"
+	if double && bits == 16 {
+		outside = predicate("ugt", bits)
+	}
+	bit := func(value, index string) string {
+		if bits != 64 {
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", truncated, index, ty)
+			index = "%" + truncated
+		}
+		shifted, flag := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shifted, ty, value, index)
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i1\n", flag, ty, shifted)
+		return "%" + flag
+	}
+	write := func(slot, value, choice, old string) {
+		if old == "" {
+			old = c.loadFlag(slot)
+		}
+		if choice != "false" {
+			value = c.emitScalarShiftArchitecturalChoice(I1, choice, value)
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i1 %s, i1 %s\n", selected, nonzero, value, old)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", selected, slot)
+	}
+	msb := bit(result, fmt.Sprint(bits-1))
+	var cf, overflow string
+	if !double && (stem == "ROL" || stem == "ROR") {
+		if stem == "ROL" {
+			cf = bit(result, "0")
+		} else {
+			cf = msb
+		}
+		write(c.flagsCFSlot, cf, "false", "")
+		other := cf
+		if stem == "ROR" {
+			other = bit(result, fmt.Sprint(bits-2))
+		}
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %s, %s\n", name, msb, other)
+		overflow = "%" + name
+	} else {
+		// Clamp only the bit-index calculation, so count0 and out-of-range
+		// B/W counts cannot produce LLVM poison even on an inactive select.
+		zero := predicate("eq", 0)
+		minimum := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 1, i64 %s\n", minimum, zero, count)
+		large := predicate("ugt", bits)
+		bounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %d, i64 %%%s\n", bounded, large, bits, minimum)
+		index := c.newTmp()
+		if stem == "SHL" || stem == "SAL" {
+			fmt.Fprintf(c.b, "  %%%s = sub i64 %d, %%%s\n", index, bits, bounded)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, 1\n", index, bounded)
+		}
+		cf = bit(before, "%"+index)
+		cfChoice := outside
+		if !double && stem != "SAR" && bits < 32 {
+			cfChoice = predicate("uge", bits)
+		}
+		write(c.flagsCFSlot, cf, cfChoice, "")
+		oldMSB := bit(before, fmt.Sprint(bits-1))
+		if double {
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, %s\n", name, oldMSB, msb)
+			overflow = "%" + name
+		} else if stem == "SAR" {
+			overflow = "false"
+		} else if stem == "SHR" {
+			overflow = oldMSB
+		} else {
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, %s\n", name, msb, cf)
+			overflow = "%" + name
+		}
+		zf, sf := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zf, ty, result)
+		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", sf, ty, result)
+		write(c.flagsZSlot, "%"+zf, outside, "")
+		write(c.flagsSltSlot, "%"+sf, outside, "")
+		oldPF := c.loadFlag(c.flagsPFSlot)
+		c.setParityFlagSized(ty, result)
+		write(c.flagsPFSlot, c.loadFlag(c.flagsPFSlot), outside, oldPF)
+		// AF is unspecified for every nonzero scalar/double shift. Its
+		// zero-count arm still preserves the actual old availability/value.
+		write(c.flagsAFSlot, "false", "true", "")
+	}
+	// The formula is used only at count1; at count0 the outer write preserves
+	// old OF, and count>1 selects one frozen finite architectural choice.
+	write(c.flagsOFSlot, overflow, multiple, "")
+}
diff --git a/amd64_scalar_shift_form_reuse_test.go b/amd64_scalar_shift_form_reuse_test.go
new file mode 100644
index 000000000..8271f0fb8
--- /dev/null
+++ b/amd64_scalar_shift_form_reuse_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftEmitterRetainsBMI2FamilyBoundary(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"SARXL CX,BX,AX", "SARXQ CX,BX,AX",
+			"SHLXL CX,BX,AX", "SHLXQ CX,BX,AX",
+			"SHRXL CX,BX,AX", "SHRXQ CX,BX,AX",
+			"RORXL $7,BX,AX", "RORXQ $7,BX,AX",
+		} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			original := file.Funcs[0].Instrs[1]
+			for _, ins := range []Instr{original, {Op: original.Op}, {Op: "SHLQ", Args: original.Args}} {
+				t.Run(arch+"/"+row+"/"+string(ins.Op), func(t *testing.T) {
+					var output strings.Builder
+					output.WriteString("existing IR\n")
+					ctx := amd64Ctx{b: &output, goarch: arch, tmp: 7}
+					known, terminated, err := ctx.lowerScalarShiftRotate(original.Op, ins)
+					if known || terminated || err != nil || ctx.tmp != 7 || output.String() != "existing IR\n" {
+						t.Fatalf("BMI2 reached the Group2 emitter: known=%t terminal=%t error=%v tmp=%d IR=%q", known, terminated, err, ctx.tmp, output.String())
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_shift_memory.go b/amd64_scalar_shift_memory.go
new file mode 100644
index 000000000..153d8cf69
--- /dev/null
+++ b/amd64_scalar_shift_memory.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import "fmt"
+
+// The validated shift grammar supplies the exact physical width and operand
+// index. Preserve a native access even at count zero or when its result dies.
+// Logical FP/AUTO storage keeps its existing independent byte-view contracts.
+func (c *amd64Ctx) loadScalarShiftOperand(ins Instr, index int, typ LLVMType) (string, func(string) error, error) {
+	operand := ins.Args[index]
+	store := func(value string) error {
+		return c.storeScalarIntegerOperand(operand, typ, value)
+	}
+	if operand.Kind == OpFP && x86ResultNamedPredicateInstruction(ins) {
+		if value, handled, err := c.loadIntegerFPBytesMode(operand.FPOffset, typ, true); handled || err != nil {
+			return value, store, err
+		}
+	}
+	if !isAMD64MemoryOperand(operand) || operand.Kind == OpFP ||
+		!(c.nativeMemoryOperand(ins, index) ||
+			x86CallerMemoryCertified(ins, index) || c.fixedLocalMemoryCertified(ins, index)) {
+		value, err := c.evalIntSized(operand, typ)
+		return value, store, err
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return "", nil, fmt.Errorf("%w: scalar shift needs its original native address size", ErrProbeNeedsContext)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(operand)
+	if err != nil {
+		return "", nil, err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+	return "%" + value, func(value string) error {
+		fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+		return nil
+	}, nil
+}
+
+// Continuing the paired access supplies numerical values, not pointee bounds,
+// reusable memory facts, a raw entry or a declaration-only read permission.
+func x86LoweredScalarShiftMemory(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch)
+	if !known || err != nil || !form.hasMemory() {
+		return false, known && err != nil
+	}
+	nativeDestination := x86OrdinaryNativeMemoryOperand(form.destination, arch)
+	nativeSource := form.sourceIndex >= 0 && x86OrdinaryNativeMemoryOperand(form.source, arch)
+	if !nativeDestination && !nativeSource {
+		return false, false // Existing logical storage consumes the shared descriptor.
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, true
+	}
+	return x86LoweredScalarShiftTransfer(ins, form, state, owned, resultOffset, arch), true
+}
+
+func x86LoweredScalarShiftTransfer(ins Instr, form x86ScalarShiftForm, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) bool {
+	effect := form.inputEffect()
+	if state.flags&effect.flagsRead != effect.flagsRead {
+		return false
+	}
+	nativeDestination := x86OrdinaryNativeMemoryOperand(form.destination, arch)
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false
+	}
+	// Check every input and address before overwriting aliased registers.
+	for _, input := range effect.operands {
+		if !input.read {
+			continue
+		}
+		if nativeDestination && input.index == form.destinationIndex {
+			if !x86ResultIncomingPointerAddressIdentity(input.operand, state, arch) {
+				return false
+			}
+			continue
+		}
+		if input.operand.Kind == OpReg {
+			index, _, valid := x86ResultGP(input.operand.Reg, input.width, arch)
+			// The independent shape clone retains original entry pointer
+			// roles, not this instruction's reaching register roles. Earlier
+			// source writes may already have replaced them. Only real
+			// dataflow states decide whether an input is opaque or numerical.
+			if !valid || !state.shapeOnly && state.pointerGP[index] {
+				return false
+			}
+		}
+		if !x86ResultReadWithNativeContinuation(ins, input.operand, input.width, state, owned, arch, true) {
+			return false
+		}
+	}
+	if !nativeDestination && !x86ResultStore(form.destination, int64(form.bits/8), state, owned, resultOffset, arch) {
+		return false
+	}
+	state.flags = form.outcome().availableFlags(state.flags)
+	return true
+}
diff --git a/amd64_scalar_shift_memory_linux_amd64_test.go b/amd64_scalar_shift_memory_linux_amd64_test.go
new file mode 100644
index 000000000..f2cbca18c
--- /dev/null
+++ b/amd64_scalar_shift_memory_linux_amd64_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarShiftMemoryNative(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	rows := x86ShiftMemoryRuntimeRows("amd64")
+	if len(rows) != 144 {
+		t.Fatal("incomplete native defined-count memory family", len(rows))
+	}
+	for first := 0; first < len(rows); first += 72 {
+		t.Run(fmt.Sprint("batch-", first/72), func(t *testing.T) {
+			batch := rows[first : first+72]
+			source, declaration, driver := x86ShiftMemoryRuntimeFixture("amd64", batch)
+			x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+			var definitions, functions strings.Builder
+			definitions.WriteString("#define ORIGINAL_NATIVE 1\n")
+			for i, row := range batch {
+				name := fmt.Sprint("OriginalMemoryShift", i)
+				// SysV supplies p/out/value/count/seed in DI/SI/DX/CX/R8.
+				// All touched GPs are caller-clobbered; stack depth is balanced.
+				body := "TEXT native(SB),4,$0-0\nMOVQ DX,AX\nPUSHQ R8\nPOPFQ\n" + row.text +
+					fmt.Sprintf("\nPUSHFQ\nPOPQ DX\nANDQ $%d,DX\nMOVQ DX,0(SI)\nMOVQ AX,8(SI)\nMOVQ CX,16(SI)\nRET\n", row.flags)
+				code := x86OrderingHintGoBytes(t, "amd64", body)
+				var bytes []string
+				for _, b := range code {
+					bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+				}
+				fmt.Fprintf(&definitions, "extern void %s(uint8_t*,uint64_t*,word,word,word);\n", name)
+				fmt.Fprintf(&definitions, "__asm__(%q);\n", ".text\n.globl "+name+"\n"+name+":\n.byte "+strings.Join(bytes, ",")+"\n")
+				fmt.Fprintf(&functions, "%s,\n", name)
+			}
+			fmt.Fprintf(&definitions, "static void (*originals[])(uint8_t*,uint64_t*,word,word,word) = {%s};\n", functions.String())
+			definitions.WriteString(x86ShiftMemoryNativeFaultC)
+			driver = strings.Replace(driver, "/* Original Go opcode definitions. */", definitions.String(), 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, optimized := range []bool{false, true} {
+						text := ir
+						if optimized {
+							text = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								output := execution.compileAndRunLLVM(t, "scalar-shift-memory-native", text, driver, level)
+								want := fmt.Sprintf("scalar shift memory observations %d\n", len(batch)*256*7*2)
+								if string(output) != want {
+									t.Fatal("native numerical/fault denominator incomplete", string(output), want)
+								}
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+const x86ShiftMemoryNativeFaultC = `
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static int outcome(void (*fn)(uint8_t*,uint64_t*,word,word,word), uint8_t *p, word count) {
+    pid_t child = fork();
+    if (child < 0) return -1;
+    if (!child) {
+        struct rlimit limit = {0,0};
+        if (setrlimit(RLIMIT_CORE,&limit)) _exit(2);
+        uint64_t output[8] = {0};
+        fn(p,output,UINT64_MAX,count,0x8c7);
+        _exit(0);
+    }
+    int status;
+    if (waitpid(child,&status,0) != child) return -1;
+    if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGSEGV || WTERMSIG(status) == SIGBUS)) return 1;
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) return 0;
+    return -1;
+}
+
+static int check_faults(void) {
+    long page = sysconf(_SC_PAGESIZE);
+    if (page <= 0) return 1;
+    uint8_t *memory = mmap(NULL,page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+    if (memory == MAP_FAILED || mprotect(memory+page,page,PROT_NONE)) return 1;
+    unsigned observations = 0;
+    const word counts[] = {0,1,255};
+    for (unsigned kernel = 0; kernel < sizeof(kernels)/sizeof(kernels[0]); kernel++) {
+        const Kernel k = kernels[kernel];
+        void (*implementations[])(uint8_t*,uint64_t*,word,word,word) = {k.fn,originals[kernel]};
+        for (unsigned which = 0; which < 2; which++) {
+            for (unsigned c = 0; c < 3; c++) {
+                uint8_t *last = memory+page-k.bits/8-1;
+                if (outcome(implementations[which],last,counts[c]) != 0 ||
+                    outcome(implementations[which],last+1,counts[c]) != 1 ||
+                    outcome(implementations[which],NULL,counts[c]) != 1) {
+                    fprintf(stderr,"kernel%u impl%u count%llu: exact width/NULL fault mismatch\n",
+                        kernel,which,(unsigned long long)counts[c]);
+                    return 1;
+                }
+                if (mprotect(memory,page,PROT_READ)) return 1;
+                int result = outcome(implementations[which],memory+32,counts[c]);
+                if (mprotect(memory,page,PROT_READ|PROT_WRITE)) return 1;
+                if (result != (k.kind >= 10 ? 0 : 1)) {
+                    fprintf(stderr,"kernel%u impl%u count%llu: read-only RMW fault mismatch\n",
+                        kernel,which,(unsigned long long)counts[c]);
+                    return 1;
+                }
+                observations += 4;
+            }
+        }
+    }
+    if (munmap(memory,page*2)) return 1;
+    return observations != sizeof(kernels)/sizeof(kernels[0])*2*3*4;
+}
+`
diff --git a/amd64_scalar_shift_pipeline_bench_test.go b/amd64_scalar_shift_pipeline_bench_test.go
new file mode 100644
index 000000000..909567ac7
--- /dev/null
+++ b/amd64_scalar_shift_pipeline_bench_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Parse outside the timer; include complete public Translate, result analysis,
+// lowering, LLVM verification and IR serialization. Each initialized kernel
+// writes its actual arithmetic result to the declared ABI0 result slot.
+func BenchmarkX86ScalarShiftTranslation(b *testing.B) {
+	for _, row := range []string{
+		"SHLQ $7,AX",
+		"SARL CX,AX",
+		"RCLB $10,AL",
+		"RCRW CX,AX",
+		"SHLW $16,BX,AX",
+		"SHRL CX,BX,AX",
+		"RCRQ $0,AX",
+		"RORXL $7,BX,AX", // Adjacent BMI2 dispatch remains independent.
+	} {
+		b.Run(row, func(b *testing.B) {
+			source := "TEXT scalarshift(SB),4,$0-8\n" +
+				"MOVQ $-8127,AX\nMOVQ $32769,BX\nMOVQ $3,CX\nCLC\n" +
+				strings.Repeat(row+"\n", 32) + "MOVQ AX,ret+0(FP)\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				b.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"scalarshift": {
+					Name: "scalarshift", Ret: I64,
+					Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Field: -1}}},
+				}}}
+			if _, err := Translate(file, options); err != nil {
+				b.Fatal("benchmark must translate successfully before timing", err)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if _, err := Translate(file, options); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/amd64_scalar_sqrt_fault_runtime_unix_test.go b/amd64_scalar_sqrt_fault_runtime_unix_test.go
new file mode 100644
index 000000000..fe3b6bcbb
--- /dev/null
+++ b/amd64_scalar_sqrt_fault_runtime_unix_test.go
@@ -0,0 +1,173 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Called by the existing scalar dead-read cross-runtime owner. These SSE2
+// memory operations have dead numerical results but observable exact-width
+// reads. Neither an LLVM optimizer nor the C compiler may erase those reads.
+func x86ScalarSqrtDeadReadFaultRuntime(t *testing.T) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, originals, pairs strings.Builder
+	for _, row := range []struct {
+		op     string
+		width  int
+		prefix byte
+	}{{"SQRTSS", 4, 0xf3}, {"SQRTSD", 8, 0xf2}} {
+		for _, forceNull := range []bool{false, true} {
+			name := "Dead" + row.op
+			zeroSource := ""
+			originalAddress := "p"
+			nativeZero := ""
+			forced := 0
+			if forceNull {
+				name += "Null"
+				zeroSource = "MOVL $0,AX\n"
+				originalAddress = "NULL"
+				nativeZero = "MOVL $0,DI\n"
+				forced = 1
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVQ p+0(FP),AX\n%s%s (AX),X1\nMOVL $23063,ret+8(FP)\nRET\n", name, zeroSource, row.op)
+			fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+			actual := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+nativeZero+row.op+" (DI),X1\nRET\n")
+			memoryOpcode := []byte{row.prefix, 0x0f, 0x51, 0x0f, 0xc3}
+			if !bytes.HasSuffix(actual, memoryOpcode) || !forceNull && !bytes.Equal(actual, memoryOpcode) ||
+				forceNull && len(actual) <= len(memoryOpcode) {
+				t.Fatal("original Go scalar memory SQRT/RET or forced address encoding changed", row.op, forceNull, actual)
+			}
+			fmt.Fprintf(&originals, "extern uint32_t %s(const uint8_t*);\n", name)
+			fmt.Fprintf(&originals, "static uint32_t Original%s(const uint8_t *p) {\n", name)
+			fmt.Fprintf(&originals, "    (void)p;\n    const uint8_t *address = %s;\n", originalAddress)
+			fmt.Fprintf(&originals, "    __asm__ volatile(\"%s (%%0), %%%%xmm1\"::\"r\"(address):\"xmm1\",\"memory\");\n", strings.ToLower(row.op))
+			originals.WriteString("    return UINT32_C(23063);\n}\n")
+			fmt.Fprintf(&pairs, "{Original%s,%s,%d,%d},\n", name, name, row.width, forced)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := fmt.Sprintf(x86ScalarSqrtDeadReadFaultC, originals.String(), pairs.String())
+	if err := runtimeOracleFaultCorePolicy(main); err != nil {
+		t.Fatal("SQRT fault children must retain the shared resource policy", err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("missing complete scalar SQRT source translation", err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, ir)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							output := execution.compileAndRunLLVM(t, "scalar-sqrt-dead-read", text, main, level)
+							if string(output) != "sqrt dead reads=4 memory outcomes=24 classifier tripwires=5 failures=0\n" {
+								t.Fatal("original/transformed scalar reads or fault classification differ", string(output))
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+const x86ScalarSqrtDeadReadFaultC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+` + numericalRuntimeFaultObservationC + `
+%s
+typedef uint32_t (*program)(const uint8_t*);
+static const struct { program original, translated; unsigned width, force_null; } kernels[] = {
+%s};
+
+static void unexpected_signal(int signum) { _exit(signum == SIGILL ? 125 : 126); }
+
+static int outcome(program fn, const uint8_t *p, uint8_t *fault_region, size_t fault_bytes) {
+    pid_t child = fork();
+    if (child < 0) return -1;
+    if (child == 0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        if (signal(SIGILL, unexpected_signal) == SIG_ERR ||
+            signal(SIGALRM, unexpected_signal) == SIG_ERR) _exit(127);
+        alarm(3);
+        numerical_fault_begin(fault_region, fault_bytes);
+        uint32_t marker = fn(p);
+        _exit(marker == UINT32_C(23063) ? 0 : 124);
+    }
+    int status = 0;
+    if (waitpid(child, &status, 0) != child) return -2;
+    if (numerical_fault_status(status)) return 1;
+    if (WIFEXITED(status) && WEXITSTATUS(status) == 0) return 0;
+    if (WIFSIGNALED(status)) return -1000 - WTERMSIG(status);
+    return -2000 - WEXITSTATUS(status);
+}
+
+static uint32_t missing_read(const uint8_t *p) { (void)p; return UINT32_C(23063); }
+static uint32_t too_wide(const uint8_t *p) {
+    __asm__ volatile("movdqu (%%0), %%%%xmm0"::"r"(p):"xmm0","memory");
+    return UINT32_C(23063);
+}
+static uint32_t illegal(const uint8_t *p) { (void)p; __asm__ volatile("ud2"); return 0; }
+static uint32_t timed_out(const uint8_t *p) { (void)p; raise(SIGALRM); return 0; }
+
+int main(void) {
+    long page = sysconf(_SC_PAGESIZE);
+    if (page < 128) return 1;
+    size_t length = (size_t)page;
+    uint8_t *memory = mmap(NULL, 2*length, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
+    if (memory == MAP_FAILED) return 2;
+    if (mprotect(memory+length, length, PROT_NONE)) { munmap(memory, 2*length); return 3; }
+    uint8_t *guard = memory + length;
+    int failed = 0;
+    unsigned observations = 0;
+    // These tripwires reject a missing read, an over-wide read, an illegal
+    // instruction and an alarm. Only synchronous faults in the bound region
+    // become memory outcomes; SIGILL and deadlines cannot impersonate them.
+    if (outcome(missing_read, NULL, NULL, length) != 0 ||
+        outcome(missing_read, guard-3, guard, length) != 0 ||
+        outcome(too_wide, guard-5, guard, length) != 1 ||
+        outcome(illegal, NULL, NULL, length) >= 0 ||
+        outcome(timed_out, NULL, NULL, length) >= 0) failed = 1;
+    for (unsigned kernel = 0; kernel < 4; ++kernel) {
+        unsigned width = kernels[kernel].width;
+        uint64_t one = width == 4 ? UINT64_C(0x3f800000) : UINT64_C(0x3ff0000000000000);
+        uint8_t *valid = guard-width-1;
+        memcpy(valid, &one, width);
+        for (unsigned address = 0; address < 3; ++address) {
+            const uint8_t *p = address == 0 ? NULL : address == 1 ? guard-width+1 : valid;
+            const uint8_t *effective = kernels[kernel].force_null ? NULL : p;
+            uint8_t *fault = effective == NULL ? NULL : guard;
+            int expected = kernels[kernel].force_null || address != 2;
+            int original = outcome(kernels[kernel].original, p, fault, length);
+            int translated = outcome(kernels[kernel].translated, p, fault, length);
+            observations += 2;
+            if (original != expected || translated != expected) {
+                fprintf(stderr, "sqrt kernel=%%u width=%%u forced-null=%%u address=%%u original=%%d translated=%%d want=%%d\n",
+                    kernel, width, kernels[kernel].force_null, address, original, translated, expected);
+                failed = 1;
+            }
+        }
+    }
+    if (munmap(memory, 2*length)) failed = 1;
+    if (failed || observations != 24) return 4;
+    puts("sqrt dead reads=4 memory outcomes=24 classifier tripwires=5 failures=0");
+    return 0;
+}
+`
diff --git a/amd64_scalar_static_load.go b/amd64_scalar_static_load.go
new file mode 100644
index 000000000..0e1acfc39
--- /dev/null
+++ b/amd64_scalar_static_load.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import "fmt"
+
+type x86ScalarStaticLoadForm struct {
+	source      Operand
+	destination Reg
+	bytes       int64
+	extension   bool
+}
+
+// Reuse the complete scalar MOV/extension grammar, not its independent SDK
+// source capability. A normalized copy describes only the effective SB row;
+// the returned operand always retains the caller's original representation.
+func x86ScalarStaticLoadProperties(ins Instr, arch string) (x86ScalarStaticLoadForm, bool) {
+	if len(ins.Args) != 2 || !x86ResultNamedPredicateInstruction(ins) {
+		return x86ScalarStaticLoadForm{}, false
+	}
+	address, valid := x86StaticSBReadAddress(ins.Args[0], arch)
+	if !valid {
+		return x86ScalarStaticLoadForm{}, false
+	}
+	projected := x86SourceMoveInstruction(ins, arch)
+	projected.Args = []Operand{
+		{Kind: OpSym, Sym: fmt.Sprintf("%s%+d(SB)", address.symbol, address.offset)},
+		ins.Args[1],
+	}
+	form, valid := x86NumericalSBReadProperties(projected, arch)
+	if !valid || form.spec.compare || form.spec.vector != x86NumericalSBScalar ||
+		form.operand != 0 || form.partner != 1 {
+		return x86ScalarStaticLoadForm{}, false
+	}
+	return x86ScalarStaticLoadForm{
+		source: ins.Args[0], destination: ins.Args[1].Reg,
+		bytes: form.spec.sourceBytes, extension: form.spec.extension,
+	}, true
+}
+
+// Ordinary Go declarations supply numerical input only for this exact read.
+// The original module-owned DATA, SDK and raw consumers remain independent.
+func (c *amd64Ctx) lowerGoReadOnlyLoad(ins Instr) (bool, error) {
+	form, known := x86ScalarStaticLoadProperties(ins, c.goarch)
+	if !known || c.goReadOnlyStorage.readFor(ins, c.goarch) == nil && !c.goReadOnlyStorage.funcvalGlobalRead(ins, c.goarch) {
+		return false, nil
+	}
+	if err := c.scalarFPResultInitialized(); err != nil {
+		return true, err
+	}
+	if form.extension {
+		return true, c.lowerScalarExtensionMove(ins.Op, ins)
+	}
+	return true, c.lowerScalarNativeLoad(x86ScalarNativeLoadForm{
+		source: form.source, destination: form.destination, bytes: form.bytes,
+	}, ins)
+}
diff --git a/amd64_scalar_vector_literal_runtime_test.go b/amd64_scalar_vector_literal_runtime_test.go
new file mode 100644
index 000000000..e54d30c7b
--- /dev/null
+++ b/amd64_scalar_vector_literal_runtime_test.go
@@ -0,0 +1,387 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type x86ScalarLiteralForm struct {
+	name, op string
+	value    x86ScalarLiteralValue
+	width    int
+	register int
+	masked   bool
+	active   bool
+	zeroing  bool
+}
+
+func x86ScalarLiteralForms(extended bool) []x86ScalarLiteralForm {
+	var forms []x86ScalarLiteralForm
+	for _, op := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+		width := 4
+		if strings.HasSuffix(op, "SD") {
+			width = 8
+		}
+		for _, value := range x86ScalarLiteralValues {
+			forms = append(forms, x86ScalarLiteralForm{name: op + value.name, op: op, value: value, width: width})
+		}
+		if extended && strings.HasPrefix(op, "V") {
+			for _, value := range x86ScalarLiteralValues[:3] {
+				for _, mask := range []struct {
+					name                 string
+					masked, active, zero bool
+				}{
+					{name: "plain"},
+					{name: "mergeOff", masked: true},
+					{name: "mergeOn", masked: true, active: true},
+					{name: "zeroOff", masked: true, zero: true},
+				} {
+					forms = append(forms, x86ScalarLiteralForm{
+						name: op + value.name + mask.name, op: op, value: value, width: width,
+						register: 31, masked: mask.masked, active: mask.active, zeroing: mask.zero,
+					})
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func (form x86ScalarLiteralForm) legacyEncoding() bool {
+	return !strings.HasPrefix(form.op, "V") || form.value.zero && form.register < 16
+}
+
+func (form x86ScalarLiteralForm) bits() uint64 {
+	if form.width == 4 {
+		return uint64(form.value.bits32)
+	}
+	return form.value.bits64
+}
+
+func x86ScalarLiteralTargetForms(wide int, arch string) []x86ScalarLiteralForm {
+	forms := x86ScalarLiteralForms(wide == 64)
+	if arch != "386" {
+		return forms
+	}
+	var physical []x86ScalarLiteralForm
+	for _, form := range forms {
+		if form.register >= 8 {
+			// These are low physical-bank object controls, not a binding for
+			// Go-accepted high-bank encodings. Keep the original high forms in
+			// the separate actual-source/Context regression.
+			form.register = 7
+			if form.value.zero && form.masked {
+				// The frontend rewrites positive zero in X0-X15 to XORPS,
+				// whose retained mask makes this original source Go-invalid.
+				continue
+			}
+		}
+		physical = append(physical, form)
+	}
+	return physical
+}
+
+func x86ScalarLiteralAssembly(wide int, arch string) string {
+	return x86ScalarLiteralAssemblyForForms(wide, arch, x86ScalarLiteralTargetForms(wide, arch))
+}
+
+func x86ScalarLiteralAssemblyForForms(wide int, arch string, forms []x86ScalarLiteralForm) string {
+	var source strings.Builder
+	word, pointerMove := 8, "MOVQ"
+	if arch == "386" {
+		word, pointerMove = 4, "MOVL"
+	}
+	for _, form := range forms {
+		view := fmt.Sprintf("Y%d", form.register)
+		// Retain the original high-bank source shape in its negative test;
+		// ordinary object controls use physical low banks on mode32.
+		zView := wide == 64 && (arch != "386" || form.register < 16)
+		if zView {
+			view = fmt.Sprintf("Z%d", form.register)
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),AX\n%s output+%d(FP),BX\nVMOVUPS (AX),%s\n",
+			form.name, word*2, pointerMove, pointerMove, word, view)
+		suffix, mask := "", ""
+		if form.masked {
+			active := 0
+			if form.active {
+				active = 1
+			}
+			fmt.Fprintf(&source, "MOVL $%d,CX\nKMOVW CX,K1\n", active)
+			mask = "K1,"
+		}
+		if form.zeroing {
+			suffix = ".Z"
+		}
+		xStore := "MOVUPS"
+		if form.register >= 16 {
+			xStore = "VMOVUPS"
+		}
+		fmt.Fprintf(&source, "%s%s $%s,%sX%d\n%s X%d,(BX)\nVMOVUPS Y%d,16(BX)\n",
+			form.op, suffix, form.value.text, mask, form.register, xStore, form.register, form.register)
+		if zView {
+			fmt.Fprintf(&source, "VMOVUPS Z%d,48(BX)\n", form.register)
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String()
+}
+
+func x86ScalarLiteralIR(t *testing.T, wide int, arch, triple string) string {
+	t.Helper()
+	assembly := x86ScalarLiteralAssembly(wide, arch)
+	requireX86GoAssemblerResult(t, arch, assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	word := int64(8)
+	if arch == "386" {
+		word = 4
+	}
+	sigs := make(map[string]FuncSig)
+	for _, form := range x86ScalarLiteralTargetForms(wide, arch) {
+		symbol := "literal." + form.name
+		sigs[symbol] = FuncSig{
+			Name: symbol, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: word, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	ir, err := Translate(file, Options{
+		Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestX86ScalarLiteralFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, wide := range []int{32, 64} {
+		for _, target := range []struct{ arch, triple string }{
+			{arch: "amd64", triple: "x86_64-unknown-linux-gnu"},
+			{arch: "amd64", triple: "x86_64-apple-darwin"},
+			{arch: "amd64", triple: "x86_64-pc-windows-msvc"},
+			{arch: "386", triple: "i386-unknown-linux-gnu"},
+			{arch: "386", triple: "i386-pc-windows-msvc"},
+		} {
+			t.Run(fmt.Sprintf("%d/%s", wide, target.triple), func(t *testing.T) {
+				ir := x86ScalarLiteralIR(t, wide, target.arch, target.triple)
+				compileLLVMToObject(t, llc, target.triple, "scalar-literals.ll", "scalar-literals.o", ir)
+			})
+		}
+	}
+}
+
+func x86ScalarLiteralActualGoOracle(t *testing.T) {
+	t.Helper()
+	var declarations, tests strings.Builder
+	declarations.WriteString("package literal\nimport \"unsafe\"\n")
+	tests.WriteString("package literal\nimport (\"testing\"; \"unsafe\")\nfunc TestLiteralBytes(t *testing.T) {\n")
+	for _, form := range x86ScalarLiteralForms(false) {
+		fmt.Fprintf(&declarations, "func %s(input, output unsafe.Pointer)\n", form.name)
+		fmt.Fprintf(&tests, `
+	for iteration := 0; iteration < 32; iteration++ {
+		var input [80]byte
+		var output [160]byte
+		for index := range input {
+			input[index] = byte(index*17 + iteration)
+		}
+		for index := range output {
+			output[index] = byte(index*7 + iteration)
+		}
+		beforeInput, want := input, output
+		const bits uint64 = %[2]d
+		for _, view := range [][2]int{{0,16},{16,32}} {
+			for lane := 0; lane < view[1]; lane++ {
+				value := byte(0)
+				if lane < %[3]d {
+					value = byte(bits >> (8*lane))
+				} else if %[4]t && lane >= 16 {
+					value = input[lane]
+				}
+				want[16+view[0]+lane] = value
+			}
+		}
+		%[1]s(unsafe.Pointer(&input[0]), unsafe.Pointer(&output[16]))
+		if output != want || input != beforeInput {
+			t.Fatalf("%[1]s iteration=%%d got=%%x want=%%x inputChanged=%%t", iteration, output, want, input != beforeInput)
+		}
+	}
+`, form.name, form.bits(), form.width, form.legacyEncoding())
+	}
+	tests.WriteString("}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module literal\n\ngo 1.20\n", "literal.go": declarations.String(),
+		"literal_amd64.s": x86ScalarLiteralAssembly(32, "amd64"), "literal_test.go": tests.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go floating-literal full-byte oracle: %v\n%s", err, output)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarFloatingLiteralBytes(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	// This original Go oracle executes low-register AVX forms. Extended and
+	// masked AVX512 forms below have Go objects and a portable LLVM/C oracle;
+	// those are not a claim that this host executes original AVX512 bytes.
+	if goToolchainAtLeast(runtime.Version(), 1, 27) {
+		x86ScalarLiteralActualGoOracle(t)
+	}
+	for _, wide := range []int{32, 64} {
+		var source strings.Builder
+		source.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#if defined(__APPLE__)
+#define LABEL(name) "_" name
+#else
+#define LABEL(name) name
+#endif
+`)
+		for _, form := range x86ScalarLiteralForms(wide == 64) {
+			fmt.Fprintf(&source, "extern void %s(void*,void*) __asm__(LABEL(\"literal.%s\"));\n", form.name, form.name)
+		}
+		source.WriteString("int main(void) {\n")
+		for _, form := range x86ScalarLiteralForms(wide == 64) {
+			mergeOff, legacy := 0, 0
+			if form.masked && !form.active && !form.zeroing {
+				mergeOff = 1
+			}
+			if form.legacyEncoding() {
+				legacy = 1
+			}
+			bits := form.bits()
+			if form.masked && !form.active && form.zeroing {
+				bits = 0
+			}
+			fmt.Fprintf(&source, `
+	for (unsigned iteration = 0; iteration < 32; iteration++) {
+		uint8_t input[80], output[160], before_input[80], want[160];
+		for (unsigned index = 0; index < sizeof(input); index++) {
+			input[index] = index*17 + iteration;
+		}
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			output[index] = index*7 + iteration;
+		}
+		memcpy(before_input, input, sizeof(input));
+		memcpy(want, output, sizeof(output));
+		const uint64_t bits = UINT64_C(%[2]d);
+		const unsigned offsets[] = {0,16,48}, widths[] = {16,32,%[6]d};
+		for (unsigned view = 0; view < (%[6]d == 64 ? 3 : 2); view++) {
+			for (unsigned lane = 0; lane < widths[view]; lane++) {
+				uint8_t value = 0;
+				if (lane < %[3]d) {
+					value = %[5]d ? input[lane] : bits >> (8*lane);
+				} else if (%[4]d && lane >= 16) {
+					value = input[lane];
+				}
+				want[16+offsets[view]+lane] = value;
+			}
+		}
+		%[1]s(input, output + 16);
+		for (unsigned index = 0; index < sizeof(output); index++) {
+			if (output[index] != want[index]) {
+				fprintf(stderr, "%[1]s wide=%[6]d iteration=%%u byte=%%u got=%%02x want=%%02x\n", iteration, index, output[index], want[index]);
+				return 1;
+			}
+		}
+		if (memcmp(input, before_input, sizeof(input))) {
+			return 2;
+		}
+	}
+`, form.name, bits, form.width, legacy, mergeOff, wide)
+		}
+		source.WriteString("\treturn 0;\n}\n")
+		triple := testTargetTriple(runtime.GOOS, "amd64")
+		var runner []string
+		if crossRosetta {
+			runner = []string{"/usr/bin/arch", "-x86_64"}
+		}
+		compileAndRunRuntimeTestForTarget(t, llc, clang, fmt.Sprintf("scalar_literals_%d", wide), triple,
+			x86ScalarLiteralIR(t, wide, "amd64", triple), source.String(), runner)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarLiteralFloat32Rounding(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("requires the Linux/amd64 runtime counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	assembly := "TEXT rounding(SB),4,$0-8\nMOVQ output+0(FP),AX\nMOVSS $1.25,X0\nMOVSS X0,(AX)\nRET\n"
+	requireX86GoAssemblerResult(t, "amd64", assembly, true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{
+		"rounding": {
+			Name: "rounding", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := `#include <stdint.h>
+#include <stdio.h>
+#if defined(__APPLE__)
+extern void rounding(void*) __asm__("_rounding");
+#else
+extern void rounding(void*);
+#endif
+int main(void) {
+	uint32_t output = 0xdeadbeef;
+	rounding(&output);
+	if (output != UINT32_C(0x3fa00000)) {
+		fprintf(stderr, "MOVSS $1.25 got=%08x want=3fa00000\n", output);
+		return 1;
+	}
+	return 0;
+}
+`
+	var runner []string
+	if crossRosetta {
+		runner = []string{"/usr/bin/arch", "-x86_64"}
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "scalar_literal_rounding", triple, ir, source, runner)
+}
diff --git a/amd64_scalar_vector_literal_source_test.go b/amd64_scalar_vector_literal_source_test.go
new file mode 100644
index 000000000..bd4807c41
--- /dev/null
+++ b/amd64_scalar_vector_literal_source_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// This is a test oracle for the invoked stock assembler, not an alternative
+// translator grammar. Inspect the actual GOROOT rather than guessing a version
+// boundary: Go 1.20 rewrites only MOVSS/SD, while current Go also rewrites VMOV.
+func x86ScalarLiteralActualGoRewriteSet(t *testing.T) bool {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err = filepath.EvalSymlinks(driver)
+	if err != nil || driver != filepath.Join(root, "bin", gotoolchain.HostExecutable("go")) {
+		t.Fatalf("literal oracle requires this toolchain's stock Go driver: %v", err)
+	}
+	run := func(arguments ...string) string {
+		stage, cancelStage := runtimeOracleStageContext(t)
+		defer cancelStage()
+		ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+		defer cancel()
+		command := exec.CommandContext(ctx, driver, arguments...)
+		command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local")
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		if err != nil {
+			t.Fatalf("actual Go literal driver failed: %v\n%s", err, output)
+		}
+		return strings.TrimSpace(string(output))
+	}
+	environment := strings.Split(run("env", "GOROOT", "GOVERSION"), "\n")
+	if len(environment) != 2 || environment[1] != runtime.Version() {
+		t.Fatalf("actual Go literal driver/toolchain mismatch: %q", environment)
+	}
+	actualRoot, err := filepath.EvalSymlinks(environment[0])
+	if err != nil || actualRoot != root {
+		t.Fatalf("actual Go literal GOROOT mismatch: %v", err)
+	}
+	assembler := run("tool", "-n", "asm")
+	if !filepath.IsAbs(assembler) {
+		t.Fatalf("unrecognized actual assembler route: %q", assembler)
+	}
+	paths := map[string]string{
+		"go": driver, "asm": assembler,
+		"obj6.go":       filepath.Join(root, "src", "cmd", "internal", "obj", "x86", "obj6.go"),
+		"asm6.go":       filepath.Join(root, "src", "cmd", "internal", "obj", "x86", "asm6.go"),
+		"avx_optabs.go": filepath.Join(root, "src", "cmd", "internal", "obj", "x86", "avx_optabs.go"),
+	}
+	digests := make(map[string][sha256.Size]byte)
+	var source []byte
+	for _, name := range []string{"go", "asm", "obj6.go", "asm6.go", "avx_optabs.go"} {
+		data, err := os.ReadFile(paths[name])
+		if err != nil || len(data) == 0 {
+			t.Fatalf("missing literal oracle input %s: %v", name, err)
+		}
+		digests[name] = sha256.Sum256(data)
+		t.Logf("actual %s %s SHA256=%x", runtime.Version(), name, digests[name])
+		if name == "obj6.go" {
+			source = data
+		}
+	}
+	t.Cleanup(func() {
+		for name, path := range paths {
+			data, err := os.ReadFile(path)
+			if err != nil || sha256.Sum256(data) != digests[name] {
+				t.Errorf("actual literal oracle input %s changed during object checks: %v", name, err)
+			}
+		}
+	})
+	vector, err := x86ScalarLiteralRewriteSet(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return vector
+}
+
+const x86ScalarLiteralZeroRewriteBody = `
+if p.From.Type == obj.TYPE_FCONST {
+	if f := p.From.Val.(float64); math.Float64bits(f) == 0 {
+		if p.To.Type == obj.TYPE_REG && REG_X0 <= p.To.Reg && p.To.Reg <= REG_X15 {
+			p.As = AXORPS
+			p.From = p.To
+			break
+		}
+	}
+}
+fallthrough
+`
+
+func x86ScalarLiteralRewriteSet(source []byte) (bool, error) {
+	file, err := parser.ParseFile(token.NewFileSet(), "actual-obj6.go", source, 0)
+	if err != nil {
+		return false, err
+	}
+	var progedit *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "progedit" {
+			continue
+		}
+		if progedit != nil || function.Body == nil {
+			return false, fmt.Errorf("missing or duplicate actual Go progedit body")
+		}
+		progedit = function
+	}
+	if progedit == nil {
+		return false, fmt.Errorf("actual Go progedit missing")
+	}
+	known := map[string]bool{"AMOVSS": true, "AMOVSD": true, "AVMOVSS": true, "AVMOVSD": true}
+	cases := make(map[string]*ast.CaseClause)
+	for _, statement := range progedit.Body.List {
+		switchStatement, ok := statement.(*ast.SwitchStmt)
+		if !ok || switchStatement.Init != nil {
+			continue
+		}
+		selector, ok := switchStatement.Tag.(*ast.SelectorExpr)
+		if !ok || selector.Sel.Name != "As" {
+			continue
+		}
+		base, ok := selector.X.(*ast.Ident)
+		if !ok || base.Name != "p" {
+			continue
+		}
+		for _, statement := range switchStatement.Body.List {
+			clause, ok := statement.(*ast.CaseClause)
+			if !ok {
+				return false, fmt.Errorf("unrecognized progedit switch entry")
+			}
+			for _, expression := range clause.List {
+				name, ok := expression.(*ast.Ident)
+				if !ok || !known[name.Name] {
+					continue
+				}
+				if cases[name.Name] != nil {
+					return false, fmt.Errorf("duplicate actual Go literal case %s", name.Name)
+				}
+				cases[name.Name] = clause
+			}
+		}
+	}
+	vector := cases["AVMOVSS"] != nil
+	if vector != (cases["AVMOVSD"] != nil) {
+		return false, fmt.Errorf("partial actual Go V literal rewrite family")
+	}
+	// A newly nested or conditional registration cannot silently inherit the
+	// reviewed top-level cases. Account for every literal case in progedit.
+	allCases := make(map[string]int)
+	ast.Inspect(progedit.Body, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok {
+			return true
+		}
+		for _, expression := range clause.List {
+			name, ok := expression.(*ast.Ident)
+			if ok && known[name.Name] {
+				allCases[name.Name]++
+			}
+		}
+		return true
+	})
+	for name := range known {
+		want := 0
+		if cases[name] != nil {
+			want = 1
+		}
+		if allCases[name] != want {
+			return false, fmt.Errorf("unrecognized conditional/nested literal case %s", name)
+		}
+	}
+	for _, legacy := range []string{"AMOVSS", "AMOVSD"} {
+		clause := cases[legacy]
+		if clause == nil {
+			return false, fmt.Errorf("unrecognized actual Go literal case %s", legacy)
+		}
+		expected := []string{legacy}
+		if vector {
+			expected = append(expected, "AV"+legacy[1:])
+		}
+		if len(clause.List) != len(expected) {
+			return false, fmt.Errorf("unknown actual Go literal case members %s", legacy)
+		}
+		for index, expression := range clause.List {
+			name, ok := expression.(*ast.Ident)
+			if !ok || name.Name != expected[index] || cases[name.Name] != clause {
+				return false, fmt.Errorf("unknown actual Go literal case membership %s", legacy)
+			}
+		}
+		actual, err := x86ScalarLiteralBodySyntax(clause.Body)
+		if err != nil {
+			return false, err
+		}
+		fixture, err := parser.ParseFile(token.NewFileSet(), "known-rewrite.go", "package p\nfunc progedit() {\n"+x86ScalarLiteralZeroRewriteBody+"}\n", 0)
+		if err != nil {
+			return false, err
+		}
+		expectedBody, err := x86ScalarLiteralBodySyntax(fixture.Decls[0].(*ast.FuncDecl).Body.List)
+		if err != nil || actual != expectedBody {
+			return false, fmt.Errorf("unknown actual Go zero/literal rewrite body %s: %v", legacy, err)
+		}
+	}
+	return vector, nil
+}
+
+func x86ScalarLiteralBodySyntax(statements []ast.Stmt) (string, error) {
+	var text bytes.Buffer
+	err := format.Node(&text, token.NewFileSet(), &ast.BlockStmt{List: statements})
+	return text.String(), err
+}
+
+func TestX86ScalarLiteralRewriteSourceIsFailClosed(t *testing.T) {
+	fixture := func(ss, sd, body string) string {
+		return "package x86\nfunc progedit() { switch p.As { case " + ss + ":\n" + body + "case " + sd + ":\n" + body + "} }\n"
+	}
+	legacy := fixture("AMOVSS", "AMOVSD", x86ScalarLiteralZeroRewriteBody)
+	current := fixture("AMOVSS, AVMOVSS", "AMOVSD, AVMOVSD", x86ScalarLiteralZeroRewriteBody)
+	for _, test := range []struct {
+		name, source  string
+		vector, valid bool
+	}{
+		{name: "legacy", source: legacy, valid: true},
+		{name: "current", source: current, vector: true, valid: true},
+		{name: "partial", source: fixture("AMOVSS, AVMOVSS", "AMOVSD", x86ScalarLiteralZeroRewriteBody)},
+		{name: "wrong family", source: fixture("AMOVSS, AVMOVSD", "AMOVSD, AVMOVSS", x86ScalarLiteralZeroRewriteBody)},
+		{name: "extra case", source: fixture("AMOVSS, AVMOVSS, AOTHER", "AMOVSD, AVMOVSD", x86ScalarLiteralZeroRewriteBody)},
+		{name: "nonidentifier", source: fixture("AMOVSS, obj.AVMOVSS", "AMOVSD", x86ScalarLiteralZeroRewriteBody)},
+		{name: "duplicate function", source: current + strings.TrimPrefix(current, "package x86\n")},
+		{name: "duplicate clause", source: strings.Replace(current, "switch p.As {", "switch p.As { case AMOVSS: "+x86ScalarLiteralZeroRewriteBody, 1)},
+		{name: "nested registration", source: strings.Replace(current, "switch p.As {", "if condition { switch p.As { case AVMOVSS: break } }; switch p.As {", 1)},
+		{name: "wrong function", source: strings.Replace(current, "func progedit", "func other", 1)},
+		{name: "wrong switch", source: strings.Replace(current, "switch p.As", "switch q.As", 1)},
+		{name: "missing legacy", source: strings.Replace(current, "AMOVSS, AVMOVSS", "AVMOVSS", 1)},
+		{name: "negative zero washed", source: strings.Replace(current, "math.Float64bits(f) == 0", "f == 0", 1)},
+		{name: "high bank rewrite", source: strings.Replace(current, "REG_X15", "REG_X31", 1)},
+		{name: "different zero opcode", source: strings.Replace(current, "AXORPS", "AVXORPS", 1)},
+		{name: "missing fallthrough", source: strings.Replace(current, "fallthrough", "break", 1)},
+		{name: "malformed", source: "package x86\nfunc progedit( {"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			vector, err := x86ScalarLiteralRewriteSet([]byte(test.source))
+			if (err == nil) != test.valid || test.valid && vector != test.vector {
+				t.Fatalf("rewrite classification vector=%t err=%v, expected vector=%t valid=%t", vector, err, test.vector, test.valid)
+			}
+		})
+	}
+}
+
+func TestX86ScalarLiteralActualInventoryCannotSkipHistoricalAssembler(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_scalar_vector_literal_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	found := false
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86ScalarLiteralActualGoRewriteInventory" {
+			continue
+		}
+		found = true
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			selector, ok := call.Fun.(*ast.SelectorExpr)
+			if ok && (selector.Sel.Name == "Skip" || selector.Sel.Name == "Skipf" || selector.Sel.Name == "SkipNow") {
+				t.Error("actual Go literal inventory must observe historical accepted and rejected source forms, not skip the toolchain")
+			}
+			return true
+		})
+	}
+	if !found {
+		t.Fatal("actual Go inventory consumer missing")
+	}
+}
diff --git a/amd64_scalar_vector_literal_test.go b/amd64_scalar_vector_literal_test.go
new file mode 100644
index 000000000..73016f09a
--- /dev/null
+++ b/amd64_scalar_vector_literal_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// obj6.progedit tests the original float64 bits for positive zero before
+// rounding an SS constant to float32. In particular, underflow is a pool load,
+// not the legacy XORPS rewrite. Keep independent expected IEEE bit patterns.
+type x86ScalarLiteralValue struct {
+	name, text string
+	bits32     uint32
+	bits64     uint64
+	zero       bool
+}
+
+var x86ScalarLiteralValues = []x86ScalarLiteralValue{
+	{name: "positiveZero", text: "0.0", zero: true},
+	{name: "negativeZero", text: "-0.0", bits32: 0x80000000, bits64: 0x8000000000000000},
+	{name: "fraction", text: "1.25", bits32: 0x3fa00000, bits64: 0x3ff4000000000000},
+	{name: "negative", text: "-2.5", bits32: 0xc0200000, bits64: 0xc004000000000000},
+	{name: "roundEven", text: "1.000000059604644775390625", bits32: 0x3f800000, bits64: 0x3ff0000010000000},
+	{name: "underflow", text: "1e-50", bits64: 0x358dee7a4ad4b81f},
+	{name: "overflow32", text: "1e40", bits32: 0x7f800000, bits64: 0x483d6329f1c35ca5},
+}
+
+func x86ScalarLiteralGoListing(t *testing.T, arch, source string) (string, error) {
+	t.Helper()
+	return x86ScalarLiteralExpectedGoListing(t, arch, source, true)
+}
+
+func x86ScalarLiteralExpectedGoListing(t *testing.T, arch, source string, wantSuccess bool) (string, error) {
+	listing, _, err := x86ScalarLiteralGoProfileObject(t, arch, "linux", source, false, wantSuccess)
+	return listing, err
+}
+
+// A profile-aware test observer only; this never creates a production source lease.
+func x86ScalarLiteralGoProfileObject(t *testing.T, arch, goos, source string, shared, wantSuccess bool) (string, []byte, error) {
+	t.Helper()
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "literal.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+	defer cancel()
+	object := filepath.Join(dir, "literal.o")
+	args := []string{"tool", "asm", "-S", "-p", "literal", "-o", object}
+	if shared {
+		args = append(args, "-shared")
+	}
+	args = append(args, asm)
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), args...)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS="+goos, "GOARCH="+arch)
+	listing, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, listing, err, ctx.Err(), wantSuccess, arch); failure != nil {
+		t.Fatalf("%v\n%s", failure, listing)
+	}
+	var objectBytes []byte
+	if wantSuccess {
+		bytes, readErr := os.ReadFile(object)
+		if readErr != nil || len(bytes) == 0 {
+			t.Fatalf("actual literal object receipt: %v", readErr)
+		}
+		objectBytes = bytes
+		t.Logf("ACTUAL_LITERAL_OBJECT arch=%s sourceSHA=%x objectSHA=%x bytes=%d listingSHA=%x", arch,
+			sha256.Sum256([]byte(source)), sha256.Sum256(bytes), len(bytes), sha256.Sum256(listing))
+	}
+	return string(listing), objectBytes, err
+}
+
+func TestX86ScalarLiteralActualGoRewriteInventory(t *testing.T) {
+	vectorLiterals := x86ScalarLiteralActualGoRewriteSet(t)
+	acceptedObjects, concreteRejections := 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+			legacy := !strings.HasPrefix(op, "V")
+			for _, value := range x86ScalarLiteralValues {
+				for _, register := range []int{0, 7, 8, 15, 16, 31} {
+					zeroRewrite := value.zero && register < 16
+					accepted := !legacy || register < 16 && (arch != "386" || register < 8)
+					if arch == "386" && zeroRewrite && register >= 8 {
+						accepted = false // the rewritten legacy XORPS is illegal in 32-bit mode
+					}
+					instruction := fmt.Sprintf("%s $%s,X%d", op, value.text, register)
+					source := "TEXT literal(SB),4,$0-0\n" + instruction + "\nRET\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					form, recognized, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch)
+					if !recognized || (err == nil) != accepted || accepted && (!form.literal || form.legacyZero != zeroRewrite) {
+						t.Fatalf("%s %s literal rewrite axes = %+v / %v", arch, instruction, form, err)
+					}
+					// The translator retains the current Go grammar above. The
+					// stock assembler below is independently checked against its
+					// own inspected progedit; older Go has no V literal rewrite.
+					actualAccepted := accepted && (legacy || vectorLiterals)
+					listing, err := x86ScalarLiteralExpectedGoListing(t, arch, source, actualAccepted)
+					if (err == nil) != actualAccepted {
+						t.Fatalf("%s %s actual Go expected accepted=%t: %v\n%s", arch, instruction, actualAccepted, err, listing)
+					}
+					if !actualAccepted {
+						if !legacy && !vectorLiterals && !strings.Contains(listing, "invalid instruction:") {
+							t.Fatalf("historical V literal lacks a concrete invalid-instruction diagnostic: %s", listing)
+						}
+						concreteRejections++
+						continue
+					}
+					acceptedObjects++
+					// The same actual Go object establishes the generation that
+					// owns upper-lane semantics; a VMOV spelling alone is not it.
+					var prefix byte
+					found := false
+					for _, line := range strings.Split(listing, "\n") {
+						fields := strings.Fields(line)
+						if len(fields) < 2 || fields[0] != "0x0000" || len(fields[1]) != 2 {
+							continue
+						}
+						first, err := strconv.ParseUint(fields[1], 16, 8)
+						if err == nil {
+							prefix, found = byte(first), true
+							break
+						}
+					}
+					if !found || (legacy || zeroRewrite) && (prefix == 0xc4 || prefix == 0xc5 || prefix == 0x62) ||
+						!legacy && !zeroRewrite && (register < 16 && prefix != 0xc5 || register >= 16 && prefix != 0x62) {
+						t.Fatalf("%s %s actual encoding prefix=%02x does not match the final rewrite\n%s", arch, instruction, prefix, listing)
+					}
+					if zeroRewrite {
+						if !strings.Contains(listing, "XORPS") || strings.Contains(listing, "$f32.") || strings.Contains(listing, "$f64.") {
+							t.Fatalf("positive zero did not become legacy XORPS: %s", listing)
+						}
+					} else {
+						pool := fmt.Sprintf("$f64.%016x", value.bits64)
+						if strings.HasSuffix(op, "SS") {
+							pool = fmt.Sprintf("$f32.%08x", value.bits32)
+						}
+						if !strings.Contains(listing, pool) {
+							t.Fatalf("constant-pool rounding/sign differs: expected %s\n%s", pool, listing)
+						}
+					}
+				}
+			}
+		}
+	}
+	wantObjects := 84
+	if vectorLiterals {
+		wantObjects = 248
+	}
+	if acceptedObjects != wantObjects || acceptedObjects+concreteRejections != 336 {
+		t.Fatalf("actual literal inventory cardinality changed: objects=%d rejections=%d", acceptedObjects, concreteRejections)
+	}
+	t.Logf("actual stock Go vector-literal rewrite=%t: %d physical objects, %d concrete source rejections across 336 formats", vectorLiterals, acceptedObjects, concreteRejections)
+}
+
+func TestX86ScalarLiteralGoOperandGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"VMOVSS", "VMOVSD"} {
+			for _, value := range x86ScalarLiteralValues[:3] {
+				for _, register := range []int{0, 8, 31} {
+					for _, shape := range []struct {
+						name, suffix, middle string
+						mask                 int
+					}{
+						{name: "two", mask: -1},
+						{name: "mask1", middle: "K1,", mask: 1},
+						{name: "mask7zero", suffix: ".Z", middle: "K7,", mask: 1},
+						{name: "three merge", middle: "X1,", mask: -1},
+						{name: "four merge", middle: "X1,K1,", mask: 2},
+						{name: "four zero", suffix: ".Z", middle: "X1,K7,", mask: 2},
+					} {
+						zeroRewrite := value.zero && register < 16
+						accepted := shape.name == "two" || shape.mask == 1 && !zeroRewrite
+						if arch == "386" && zeroRewrite && register >= 8 {
+							accepted = false
+						}
+						instruction := fmt.Sprintf("%s%s $%s,%sX%d", op, shape.suffix, value.text, shape.middle, register)
+						source := "TEXT literal(SB),4,$0-0\n" + instruction + "\nRET\n"
+						t.Run(arch+"/"+instruction, func(t *testing.T) {
+							requireX86GoAssemblerResult(t, arch, source, accepted)
+							file, err := Parse(ArchAMD64, source)
+							if err != nil {
+								t.Fatal(err)
+							}
+							form, recognized, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch)
+							if !recognized || (err == nil) != accepted || accepted && (!form.literal || form.mask != shape.mask || form.upper != -1 || form.memory != -1) {
+								t.Fatalf("actual Go literal grammar expected accepted=%t: %+v / %v", accepted, form, err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarLiteralKnownByteEffectsFollowFinalEncoding(t *testing.T) {
+	for _, example := range []struct {
+		instruction string
+		old, want   uint64
+		maskKnown   bool
+	}{
+		{instruction: "MOVSS $1.25,X0", want: 0xffff},
+		{instruction: "MOVSD $-0.0,X0", old: 0xffff00000000, want: 0xffff0000ffff},
+		{instruction: "VMOVSS $0.0,X0", want: 0xffff},
+		{instruction: "VMOVSD $0.0,X0", old: 0xffff00000000, want: 0xffff0000ffff},
+		{instruction: "VMOVSS $1e-50,X0", want: ^uint64(0)},
+		{instruction: "VMOVSD $-0.0,X0", want: ^uint64(0)},
+		{instruction: "VMOVSS $0.0,X31", want: ^uint64(0)},
+		{instruction: "VMOVSS $1.25,K1,X0", want: ^uint64(0xf), maskKnown: true},
+		{instruction: "VMOVSD.Z $1.25,K1,X0", want: ^uint64(0), maskKnown: true},
+	} {
+		file, err := Parse(ArchAMD64, "TEXT literal(SB),4,$0-0\n"+example.instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		destination := x86CallerVectorRoot(instruction.Args[len(instruction.Args)-1].Reg)
+		state := x86SourceStackState{
+			vectors: map[Reg]uint64{destination: example.old}, masks: map[Reg]bool{"K1": example.maskKnown},
+		}
+		if !x86CallerVectorMoveKnown(instruction) || !x86CallerVectorMoveStep(&instruction, &state, nil) {
+			t.Fatalf("literal transfer rejected %s", example.instruction)
+		}
+		if got := state.vectors[destination]; got != example.want {
+			t.Fatalf("%s byte initialization got=%016x want=%016x", example.instruction, got, example.want)
+		}
+		if len(instruction.x86CallerMemory) != 0 {
+			t.Fatal("literal constant pool acquired a user-memory access certificate")
+		}
+	}
+}
+
+func TestX86ScalarLiteralCallerRegionFreshWrites(t *testing.T) {
+	for _, op := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+		typ := "float32"
+		if strings.HasSuffix(op, "SD") {
+			typ = "float64"
+		}
+		for _, value := range x86ScalarLiteralValues {
+			body := fmt.Sprintf("%s $%s,X0\n%s X0,(DX)", op, value.text, op)
+			source := strings.ReplaceAll(x86CallerFixtureSource, "float32", typ)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			requireX86GoAssemblerResult(t, "amd64", assembly, true)
+			pkg, _ := x86CallerCoreFixture(t, source, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatalf("%s %s exact caller-region literal rejected: %v", op, value.text, err)
+			}
+		}
+	}
+}
+
+func TestX86ScalarLiteralRejectsIntegerUnresolvedAndInvalidMaskAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{
+			"MOVSS $0,X0", "MOVSD $1,X0", "MOVSD $7,X0", "VMOVSS $0,X0", "VMOVSD $1,X0",
+			"MOVSS $1.25,K1,X0", "MOVSD.Z $1.25,X0", "VMOVSS.Z $1.25,X0",
+			"VMOVSS $1.25,K0,X0", "VMOVSD $-0.0,K8,X0", "VMOVSS $1.25,(AX)",
+			"VMOVSD $1.25,X1,K1,X0", "VMOVSS $0.0,K1,X0", "VMOVSD.Z $0.0,K1,X15",
+		} {
+			source := "TEXT literal(SB),4,$0-0\n" + instruction + "\nRET\n"
+			requireX86GoAssemblerResult(t, arch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				continue
+			}
+			if _, _, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch); err == nil {
+				t.Fatalf("literal grammar accepted %s %s", arch, instruction)
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			if _, err := Translate(file, Options{Goarch: arch, TargetTriple: triple,
+				Sigs: map[string]FuncSig{"literal": {Name: "literal", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("lowerer accepted %s %s", arch, instruction)
+			}
+		}
+	}
+	for _, op := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+		file, err := Parse(ArchAMD64, "TEXT literal(SB),4,$0-0\n"+op+" $1.25,X0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		file.Funcs[0].Instrs[1].Args[0].ImmRaw = "unresolved"
+		if _, _, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], "amd64"); err == nil {
+			t.Fatal("unresolved immediate inherited a literal-pool rewrite")
+		}
+	}
+}
diff --git a/amd64_scalar_vector_move_forms.go b/amd64_scalar_vector_move_forms.go
new file mode 100644
index 000000000..4796660c2
--- /dev/null
+++ b/amd64_scalar_vector_move_forms.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64ScalarVectorMoveSpec struct {
+	bits    int
+	legacy  bool
+	rawOnly bool
+}
+
+// MOVSS/SD share yxmov; VMOVSS/SD share all twelve _yvmovsd rows.
+// VMOVSH is a separate raw-only FP16 encoding, not a named Go instruction.
+var amd64ScalarVectorMoveSpecs = map[Op]amd64ScalarVectorMoveSpec{
+	"MOVSS": {bits: 32, legacy: true}, "MOVSD": {bits: 64, legacy: true},
+	"VMOVSS": {bits: 32}, "VMOVSD": {bits: 64},
+	"VMOVSH": {bits: 16, rawOnly: true},
+}
+
+type amd64ScalarVectorMoveForm struct {
+	spec        amd64ScalarVectorMoveSpec
+	low         int
+	upper       int // -1 when there is no register upper-lane source
+	destination int
+	mask        int // -1 when unmasked
+	memory      int // -1 for register-to-register forms
+	memoryWrite bool
+	zeroing     bool
+	literal     bool // frontend constant-pool rewrite, not a user memory operand
+	legacyZero  bool // obj6.progedit rewrites positive zero in X0-X15 to XORPS
+}
+
+// This is operand grammar only. It grants no memory bounds, initialized data,
+// K-register value, or source continuation. Both lowerer and source proof use
+// the exact same direction/width/merge axes.
+func amd64ScalarVectorMoveProperties(ins Instr, goarch string) (amd64ScalarVectorMoveForm, bool, error) {
+	name := strings.ToUpper(string(ins.Op))
+	base, suffix, _ := strings.Cut(name, ".")
+	spec, recognized := amd64ScalarVectorMoveSpecs[Op(base)]
+	if !recognized {
+		return amd64ScalarVectorMoveForm{}, false, nil
+	}
+	form := amd64ScalarVectorMoveForm{
+		spec: spec, low: 0, upper: -1, destination: len(ins.Args) - 1,
+		mask: -1, memory: -1, zeroing: suffix == "Z",
+	}
+	fail := func() (amd64ScalarVectorMoveForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands/suffix are outside the scalar vector-move grammar: %q", goarch, base, ins.Raw)
+	}
+	if spec.rawOnly && !ins.x86Encoded || suffix != "" && suffix != "Z" ||
+		goarch == "386" && len(ins.Args) > 3 && !ins.x86Encoded && !x86RawScalarVectorMoveIdentity(ins, goarch) {
+		return fail()
+	}
+	vector := func(operand Operand) bool {
+		if !amd64ScalarXOperand(operand) {
+			return false
+		}
+		if !spec.legacy {
+			return true
+		}
+		index, _ := amd64ParseXReg(operand.Reg)
+		return index < 16 && (goarch != "386" || index < 8)
+	}
+	if len(ins.Args) >= 2 && ins.Args[0].Kind == OpImm {
+		literal := ins.Args[0]
+		if spec.rawOnly || !literal.ImmIsFloat || literal.ImmRaw != "" || !vector(ins.Args[form.destination]) {
+			return fail()
+		}
+		index, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+		form.literal, form.legacyZero = true, literal.Imm == 0 && index < 16
+		if goarch == "386" && form.legacyZero && index >= 8 {
+			return fail() // the final legacy XORPS cannot address X8-X15 in mode32
+		}
+		switch len(ins.Args) {
+		case 2:
+			if suffix != "" {
+				return fail()
+			}
+		case 3:
+			// A pool memory source has no register upper-merge source. The
+			// positive-zero rewrite retains RestArgs/Scond, which makes a
+			// masked low-register XORPS invalid in Go's final optab.
+			if spec.legacy || form.legacyZero || !amd64NonzeroKOperand(ins.Args[1]) {
+				return fail()
+			}
+			form.mask = 1
+		default:
+			return fail()
+		}
+		return form, true, nil
+	}
+	if spec.legacy {
+		if suffix != "" || len(ins.Args) != 2 {
+			return fail()
+		}
+		if vector(ins.Args[0]) && (vector(ins.Args[1]) || isAMD64MemoryOperand(ins.Args[1])) {
+			if isAMD64MemoryOperand(ins.Args[1]) {
+				form.memory, form.memoryWrite = 1, true
+			}
+			return form, true, nil
+		}
+		if isAMD64MemoryOperand(ins.Args[0]) && vector(ins.Args[1]) {
+			form.memory = 0
+			return form, true, nil
+		}
+		return fail()
+	}
+	merge := func(mask int) bool {
+		return vector(ins.Args[0]) && vector(ins.Args[1]) && vector(ins.Args[form.destination]) &&
+			(mask < 0 || amd64NonzeroKOperand(ins.Args[mask]))
+	}
+	switch len(ins.Args) {
+	case 2:
+		if form.zeroing {
+			return fail()
+		}
+	case 3:
+		if merge(-1) {
+			if form.zeroing {
+				return fail()
+			}
+			form.upper = 1
+			return form, true, nil
+		}
+		form.mask = 1
+		if !amd64NonzeroKOperand(ins.Args[1]) {
+			return fail()
+		}
+	case 4:
+		if !merge(2) {
+			return fail()
+		}
+		form.upper, form.mask = 1, 2
+		return form, true, nil
+	default:
+		return fail()
+	}
+	if vector(ins.Args[0]) && isAMD64MemoryOperand(ins.Args[form.destination]) && !form.zeroing {
+		form.memory, form.memoryWrite = form.destination, true
+		return form, true, nil
+	}
+	if isAMD64MemoryOperand(ins.Args[0]) && vector(ins.Args[form.destination]) {
+		form.memory = 0
+		return form, true, nil
+	}
+	return fail()
+}
diff --git a/amd64_scalar_vector_move_forms_test.go b/amd64_scalar_vector_move_forms_test.go
new file mode 100644
index 000000000..4656712f7
--- /dev/null
+++ b/amd64_scalar_vector_move_forms_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86ScalarMoveExpectedAxes struct {
+	operands, suffix string
+	memory, upper    int
+	mask             int
+	write, zero      bool
+}
+
+func TestAMD64ScalarVectorMoveGrammarCompleteGoFamilies(t *testing.T) {
+	want := map[Op]amd64ScalarVectorMoveSpec{
+		"MOVSS": {bits: 32, legacy: true}, "MOVSD": {bits: 64, legacy: true},
+		"VMOVSS": {bits: 32}, "VMOVSD": {bits: 64},
+		"VMOVSH": {bits: 16, rawOnly: true},
+	}
+	if !reflect.DeepEqual(amd64ScalarVectorMoveSpecs, want) {
+		t.Fatalf("scalar move family differs from yxmov / _yvmovsd plus the distinct raw FP16 family: %+v", amd64ScalarVectorMoveSpecs)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+			legacy := !strings.HasPrefix(op, "V")
+			forms := []x86ScalarMoveExpectedAxes{
+				{operands: "(AX),X1", memory: 0, upper: -1, mask: -1},
+				{operands: "X1,(AX)", memory: 1, write: true, upper: -1, mask: -1},
+			}
+			if legacy {
+				forms = append(forms, x86ScalarMoveExpectedAxes{operands: "X1,X7", memory: -1, upper: -1, mask: -1})
+			} else {
+				forms = append(forms,
+					x86ScalarMoveExpectedAxes{operands: "X1,X2,X31", memory: -1, upper: 1, mask: -1},
+					x86ScalarMoveExpectedAxes{operands: "(AX),K7,X31", memory: 0, upper: -1, mask: 1},
+					x86ScalarMoveExpectedAxes{operands: "(AX),K7,X31", suffix: ".Z", memory: 0, upper: -1, mask: 1, zero: true},
+					x86ScalarMoveExpectedAxes{operands: "X31,K7,(AX)", memory: 2, write: true, upper: -1, mask: 1})
+				if arch == "amd64" {
+					forms = append(forms,
+						x86ScalarMoveExpectedAxes{operands: "X1,X2,K7,X31", memory: -1, upper: 1, mask: 2},
+						x86ScalarMoveExpectedAxes{operands: "X1,X2,K7,X31", suffix: ".Z", memory: -1, upper: 1, mask: 2, zero: true})
+				}
+			}
+			for _, expected := range forms {
+				instruction := op + expected.suffix + " " + expected.operands
+				source := "TEXT forms(SB),4,$0-0\n" + instruction + "\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, recognized, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch)
+				if !recognized || err != nil || form.memory != expected.memory || form.memoryWrite != expected.write ||
+					form.upper != expected.upper || form.mask != expected.mask || form.zeroing != expected.zero {
+					t.Fatalf("%s %s grammar axes = %+v / %v", arch, instruction, form, err)
+				}
+			}
+		}
+	}
+}
+
+func TestAMD64ScalarVectorMoveGrammarRejectsInvalidGoAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{
+			"MOVSS $1,X0", "MOVSD $0,X0", "MOVSS X16,X0", "MOVSD X0,X16",
+			"MOVSS.Z (AX),X0", "MOVSD Y0,X0", "MOVSS (AX),(BX)",
+			"VMOVSS X0,X1", "VMOVSD.Z (AX),X0", "VMOVSS.Z X0,K1,(AX)",
+			"VMOVSD (AX),K0,X0", "VMOVSS X0,X1,K0,X2", "VMOVSD Y0,X1,X2",
+			"VMOVSS X0,(AX),X1", "VMOVSD.BCST (AX),X0", "VMOVSD X0,K1,X1",
+		} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT forms(SB),4,$0-0\n" + instruction + "\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					return
+				}
+				if _, _, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch); err == nil {
+					t.Fatalf("grammar accepted invalid %s %s", arch, instruction)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				if _, err := Translate(file, Options{Goarch: arch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"forms": {Name: "forms", Ret: Void}},
+				}); err == nil {
+					t.Fatalf("lowerer accepted invalid %s %s", arch, instruction)
+				}
+			})
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{"VMOVSH (AX),X0", "MOVSS X8,X0"} {
+			if instruction == "MOVSS X8,X0" && arch == "amd64" {
+				continue
+			}
+			source := fmt.Sprintf("TEXT forms(SB),4,$0-0\n%s\nRET\n", instruction)
+			requireX86GoAssemblerResult(t, arch, source, false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, _, err := amd64ScalarVectorMoveProperties(file.Funcs[0].Instrs[1], arch); err == nil {
+				t.Fatalf("named/architecture restriction omitted for %s %s", arch, instruction)
+			}
+		}
+	}
+}
diff --git a/amd64_scalar_vector_move_memory.go b/amd64_scalar_vector_move_memory.go
new file mode 100644
index 000000000..e289337c9
--- /dev/null
+++ b/amd64_scalar_vector_move_memory.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+import "fmt"
+
+// Only the scalar move emitter's exact four/eight-byte register-addressed
+// native access participates. This supplies no FP/AUTO/static backing, segment
+// input, extent, alignment, pointer validity or source continuation permission.
+func x86ScalarVectorMoveOrdinaryMemory(operand Operand, bits int, arch string) bool {
+	return (bits == 32 || bits == 64) && operand.Kind == OpMem &&
+		operand.Mem.Sym == "" && operand.Mem.Segment == "" &&
+		x86OrdinaryNativeMemoryOperand(operand, arch)
+}
+
+func (c *amd64Ctx) loadScalarVectorMoveNativeMemory(source Operand, bits int) (string, error) {
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", loaded, bits, pointerType, pointer)
+	return "%" + loaded, nil
+}
diff --git a/amd64_scalar_vector_move_result.go b/amd64_scalar_vector_move_result.go
new file mode 100644
index 000000000..584fd0f05
--- /dev/null
+++ b/amd64_scalar_vector_move_result.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+// The strict observer and lowering-local raw/native continuations consume one
+// scalar move byte effect. A captured physical form is never reparsed after
+// provenance projection, especially for mode32's actual four-operand encoding.
+func x86ScalarVectorMoveResultTransfer(ins Instr, form amd64ScalarVectorMoveForm,
+	state *x86ResultState, owned []bool, resultOffset int64, arch string, native bool) bool {
+	if form.spec.legacy || form.spec.rawOnly || form.spec.bits != 32 && form.spec.bits != 64 {
+		return false
+	}
+	width := int64(form.spec.bits / 8)
+	lowMask := uint16(1)<<uint(width) - 1
+	xreg := func(operand Operand) (int, bool) {
+		index, valid := amd64ParseXReg(operand.Reg)
+		return index, operand.Kind == OpReg && valid && index < len(state.xmm) && (arch != "386" || index < 8)
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	first, last := ins.Args[form.low], ins.Args[form.destination]
+	if source, valid := xreg(first); valid {
+		if state.xmm[source]&lowMask != lowMask {
+			return false
+		}
+	} else if !form.literal && !x86ResultReadWithNativeContinuation(ins, first, width, state, owned, arch, native) {
+		return false
+	}
+	if form.memoryWrite {
+		if native && x86ScalarVectorMoveOrdinaryMemory(last, form.spec.bits, arch) &&
+			x86ResultIncomingPointerAddressIdentity(last, state, arch) {
+			// The exact active native write never reads old destination bytes
+			// and establishes no initialized logical or reusable memory fact.
+			return true
+		}
+		if form.mask >= 0 {
+			return x86ResultRead(last, width, state, owned, arch)
+		}
+		return x86ResultStore(last, width, state, owned, resultOffset, arch)
+	}
+	destination, valid := xreg(last)
+	if !valid {
+		return false
+	}
+	if form.mask >= 0 && !form.zeroing && state.xmm[destination]&lowMask != lowMask {
+		return false
+	}
+	known := uint16(0xffff)
+	if form.upper >= 0 {
+		upper, valid := xreg(ins.Args[form.upper])
+		if !valid {
+			return false
+		}
+		known = state.xmm[upper]&^lowMask | lowMask
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known = known&^lowMask | known&state.xmm[destination]&lowMask
+	}
+	state.writeVector(destination, 16, uint64(known), false)
+	return true
+}
diff --git a/amd64_scaled_round_helper_objects_test.go b/amd64_scaled_round_helper_objects_test.go
new file mode 100644
index 000000000..469c9f243
--- /dev/null
+++ b/amd64_scaled_round_helper_objects_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86ScaledRoundSelectedMembers = []struct {
+	op     string
+	bits   int
+	scalar bool
+	reduce bool
+}{
+	{"VRNDSCALEPS", 32, false, false},
+	{"VRNDSCALEPD", 64, false, false},
+	{"VRNDSCALESS", 32, true, false},
+	{"VRNDSCALESD", 64, true, false},
+	{"VREDUCEPS", 32, false, true},
+	{"VREDUCEPD", 64, false, true},
+	{"VREDUCESS", 32, true, true},
+	{"VREDUCESD", 64, true, true},
+}
+
+func x86ScaledRoundSelectedPublicSource(arch string) (string, string) {
+	pointerBytes, move, extent := 8, "MOVQ", 28
+	if arch == "386" {
+		pointerBytes, move, extent = 4, "MOVL", 16
+	}
+	var source, declarations strings.Builder
+	for _, member := range x86ScaledRoundSelectedMembers {
+		if arch == "386" && member.scalar {
+			continue // Go's named scalar row has four operands, absent in 386.
+		}
+		name := "Selected" + member.op
+		fmt.Fprintf(&declarations, "func %s(out, source, upper *[16]byte, control uint32)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),AX\n%s source+%d(FP),BX\n%s upper+%d(FP),CX\nLDMXCSR control+%d(FP)\nVMOVUPS (CX),X1\n",
+			name, extent, move, move, pointerBytes, move, 2*pointerBytes, 3*pointerBytes)
+		operands := "(BX),X2"
+		if member.scalar {
+			operands = "(BX),X1,X2"
+		}
+		fmt.Fprintf(&source, "%s $49,%s\nVMOVUPS X2,(AX)\nRET\n", member.op, operands)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ScaledRoundCompleteTypedHelperRequirements(t *testing.T) {
+	for _, member := range x86ScaledRoundSelectedMembers {
+		t.Run(member.op, func(t *testing.T) {
+			operands := "X0,X2"
+			if member.scalar {
+				operands = "X0,X1,X2"
+			} else {
+				// Packed SAE requires Z; never infer helper requirements from
+				// an invalid operand/suffix combination.
+				operands = "Z0,Z2"
+			}
+			file, err := Parse(ArchAMD64, "TEXT Requirements(SB),4,$0-0\n"+member.op+".SAE $49,"+operands+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var helper strings.Builder
+			emitAMD64FMA3RoundingHelpers(&helper, file, "amd64")
+			for _, bits := range []int{32, 64} {
+				want := 0
+				if member.reduce && member.bits == bits {
+					want = 1
+				}
+				for _, name := range []string{"__plan9asm_add_sub_round_f", "__plan9asm_fma3_round_f"} {
+					typ := "float"
+					if bits == 64 {
+						typ = "double"
+					}
+					definition := fmt.Sprintf("define internal %s @%s%d(", typ, name, bits)
+					if got := strings.Count(helper.String(), definition); got != want {
+						t.Fatalf("typed %s emitted %d definitions for %s, want %d", member.op, got, definition, want)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScaledRoundPublicThreeAPISelectedRoundingObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+		// Goarch and backend are independent public options. These two
+		// object-only projections retain x86 MXCSR while exercising the real
+		// software fallback. They do not claim a native AMD64-to-386 Go ABI,
+		// or cross-ISA public MXCSR support on ARM/wasm.
+		{"amd64", "i386-unknown-linux-gnu"},
+		{"amd64", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.arch+"/"+target.triple, func(t *testing.T) {
+			source, declarations := x86ScaledRoundSelectedPublicSource(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("fully initialized public selected-rounding source rejected", err)
+					}
+					for _, member := range x86ScaledRoundSelectedMembers {
+						if target.arch == "386" && member.scalar {
+							continue
+						}
+						body := x86StringMemoryFunction(t, ir, "Selected"+member.op)
+						if x86ScalarFloatIntegerNativeTarget(target.arch, target.triple) {
+							if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, strings.ToLower(member.op)) {
+								t.Fatal("matching native target lost its original opcode", member.op)
+							}
+						} else if member.reduce {
+							call := fmt.Sprintf("@__plan9asm_add_sub_round_f%d(", member.bits)
+							if !strings.Contains(body, call) || strings.Contains(body, " = fsub ") {
+								t.Fatal("portable public REDUCE lost selected-rounding subtraction", member.op)
+							}
+						}
+					}
+					for _, pipeline := range []struct {
+						name, backend string
+						optimized     bool
+					}{
+						{"backend_O0", "-O0", false},
+						{"backend_O2", "-O2", false},
+						{"IR_O2/backend_O2", "-O2", true},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							text := ir
+							if pipeline.optimized {
+								text = x86DwordProductIROptimize(t, ir)
+							}
+							x86PackedStringCompileObject(t, llc, target.triple, text, pipeline.backend)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_scaled_round_report_test.go b/amd64_scaled_round_report_test.go
new file mode 100644
index 000000000..241acaeb5
--- /dev/null
+++ b/amd64_scaled_round_report_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86ScaledRoundOriginalCReportExactLineTransport(t *testing.T) {
+	const line = "original C exact IEEE observations 35328 failures 0"
+	for _, test := range []struct {
+		name, output string
+		accepted     bool
+	}{
+		{"LF", line + "\n", true},
+		{"Windows-CRLF", line + "\r\n", true},
+		{"missing-terminator", line, false},
+		{"CR-only", line + "\r", false},
+		{"LF-CR", line + "\n\r", false},
+		{"CR-CRLF", line + "\r\r\n", false},
+		{"empty", "", false},
+		{"truncated", line[:len(line)-1] + "\n", false},
+		{"leading-space", " " + line + "\n", false},
+		{"trailing-space", line + " \r\n", false},
+		{"tab", line + "\t\n", false},
+		{"NUL", line + "\x00\n", false},
+		{"extra-before", "compiler warning\n" + line + "\n", false},
+		{"extra-after", line + "\r\nwarning\r\n", false},
+		{"extra-empty-line", line + "\n\n", false},
+		{"duplicate-LF", line + "\n" + line + "\n", false},
+		{"duplicate-CRLF", line + "\r\n" + line + "\r\n", false},
+		{"mixed-line-endings", line + "\n" + line + "\r\n", false},
+		{"lower-count", strings.Replace(line, "35328", "35327", 1) + "\n", false},
+		{"higher-count", strings.Replace(line, "35328", "35329", 1) + "\r\n", false},
+		{"leading-zero-count", strings.Replace(line, "35328", "035328", 1) + "\n", false},
+		{"signed-count", strings.Replace(line, "35328", "+35328", 1) + "\n", false},
+		{"nonzero-failures", strings.Replace(line, "failures 0", "failures 1", 1) + "\r\n", false},
+		{"signed-zero-failures", strings.Replace(line, "failures 0", "failures -0", 1) + "\n", false},
+		{"extra-zero-failures", line + "0\n", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := x86ScaledRoundOriginalCReportComplete([]byte(test.output)); got != test.accepted {
+				t.Fatalf("exact original C report acceptance=%t, want %t for %q", got, test.accepted, test.output)
+			}
+		})
+	}
+}
diff --git a/amd64_scaled_round_selected_rounding_test.go b/amd64_scaled_round_selected_rounding_test.go
new file mode 100644
index 000000000..d02d9c6f2
--- /dev/null
+++ b/amd64_scaled_round_selected_rounding_test.go
@@ -0,0 +1,364 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"math"
+	"math/big"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol. 2C, Table 5-27 and ReduceArgumentSP/DP specify that the
+// final subtraction uses the same selected RC as ROUND, not ambient RC.
+// https://cdrdv2-public.intel.com/774492/325383-sdm-vol-2abcd.pdf
+// This oracle performs both operations on exact rationals, then rounds once
+// to the destination's IEEE precision. It shares no translator bit algorithm.
+func x86ScaledRoundExactIEEE(input uint64, bits, scale, mode int, daz, reduce bool) uint64 {
+	fraction, bias, precision := uint(23), 127, uint(24)
+	exponentMask := uint64(0x7f800000)
+	if bits == 64 {
+		fraction, bias, precision = 52, 1023, 53
+		exponentMask = 0x7ff0000000000000
+	}
+	sign := uint64(1) << (bits - 1)
+	magnitude := input & (sign - 1)
+	fractionMask := uint64(1)<<fraction - 1
+	if magnitude >= exponentMask {
+		if magnitude > exponentMask {
+			return input | uint64(1)<<(fraction-1)
+		}
+		if reduce {
+			return 0
+		}
+		return input
+	}
+	if magnitude == 0 || (daz && magnitude < uint64(1)<<fraction) {
+		if reduce {
+			if mode == 1 {
+				return sign
+			}
+			return 0
+		}
+		return input & sign
+	}
+
+	exponent := int(magnitude >> fraction)
+	significand := magnitude & fractionMask
+	if exponent == 0 {
+		exponent = 1
+	} else {
+		significand |= uint64(1) << fraction
+	}
+	numerator := new(big.Int).SetUint64(significand)
+	denominator := big.NewInt(1)
+	shift := exponent - bias - int(fraction)
+	if shift >= 0 {
+		numerator.Lsh(numerator, uint(shift))
+	} else {
+		denominator.Lsh(denominator, uint(-shift))
+	}
+	if input&sign != 0 {
+		numerator.Neg(numerator)
+	}
+	value := new(big.Rat).SetFrac(numerator, denominator)
+	unit := new(big.Int).Lsh(big.NewInt(1), uint(scale))
+	scaled := new(big.Rat).Mul(value, new(big.Rat).SetInt(unit))
+	integer, remainder := new(big.Int), new(big.Int)
+	integer.QuoRem(scaled.Num(), scaled.Denom(), remainder)
+	if remainder.Sign() != 0 {
+		increment := false
+		switch mode {
+		case 0:
+			distance := new(big.Int).Lsh(new(big.Int).Abs(remainder), 1)
+			comparison := distance.Cmp(scaled.Denom())
+			increment = comparison > 0 || comparison == 0 && integer.Bit(0) != 0
+		case 1:
+			increment = value.Sign() < 0
+		case 2:
+			increment = value.Sign() > 0
+		}
+		if increment {
+			integer.Add(integer, big.NewInt(int64(value.Sign())))
+		}
+	}
+	result := new(big.Rat).SetFrac(integer, unit)
+	if reduce {
+		result.Sub(value, result)
+	}
+	if result.Sign() == 0 {
+		if reduce {
+			if mode == 1 {
+				return sign
+			}
+			return 0
+		}
+		return input & sign
+	}
+	rounding := []big.RoundingMode{big.ToNearestEven, big.ToNegativeInf, big.ToPositiveInf, big.ToZero}
+	rounded := new(big.Float).SetPrec(precision).SetMode(rounding[mode]).SetRat(result)
+	if bits == 32 {
+		value, _ := rounded.Float32()
+		return uint64(math.Float32bits(value))
+	}
+	value64, _ := rounded.Float64()
+	return math.Float64bits(value64)
+}
+
+func TestX86ScaledRoundExactIEEEReferenceControls(t *testing.T) {
+	for _, row := range []struct {
+		bits, mode int
+		input      uint64
+		round      uint64
+		reduce     uint64
+	}{
+		{32, 1, 0x80000001, 0xbe000000, 0x3dffffff},
+		{32, 2, 1, 0x3e000000, 0xbdffffff},
+		{64, 1, 0x8000000000000001, 0xbfc0000000000000, 0x3fbfffffffffffff},
+		{64, 2, 1, 0x3fc0000000000000, 0xbfbfffffffffffff},
+		{32, 0, 1, 0, 1},
+		{64, 0, 1, 0, 1},
+	} {
+		if got := x86ScaledRoundExactIEEE(row.input, row.bits, 3, row.mode, false, false); got != row.round {
+			t.Fatalf("independent ROUND%d input=%x mode=%d: got %x want %x", row.bits, row.input, row.mode, got, row.round)
+		}
+		if got := x86ScaledRoundExactIEEE(row.input, row.bits, 3, row.mode, false, true); got != row.reduce {
+			t.Fatalf("independent REDUCE%d input=%x mode=%d: got %x want %x", row.bits, row.input, row.mode, got, row.reduce)
+		}
+	}
+}
+
+func x86ScaledRoundSelectedRoundingRows() string {
+	var rows strings.Builder
+	for _, bits := range []int{32, 64} {
+		inputs := []uint64{0x3fc00000, 0x40200000, 0xbfc00000, 0xc0200000,
+			0x3fb00000, 0xbfb00000, 0, 0x80000000, 0x7f800000, 0xff800000,
+			0x7fc12345, 0xff812345, 1, 0x80000001, 0x4e800000, 0x3f800001}
+		if bits == 64 {
+			inputs = []uint64{0x3ff8000000000000, 0x4004000000000000, 0xbff8000000000000,
+				0xc004000000000000, 0x3ff6000000000000, 0xbff6000000000000, 0,
+				0x8000000000000000, 0x7ff0000000000000, 0xfff0000000000000,
+				0x7ff8123456789abc, 0xfff0123456789abc, 1, 0x8000000000000001,
+				0x41d0000000000000, 0x3ff0000000000001}
+		}
+		for scale := 0; scale < 16; scale++ {
+			for mode := 0; mode < 4; mode++ {
+				for daz := 0; daz < 2; daz++ {
+					for operation := 0; operation < 2; operation++ {
+						for _, input := range inputs {
+							want := x86ScaledRoundExactIEEE(input, bits, scale, mode, daz != 0, operation != 0)
+							fmt.Fprintf(&rows, "{%d,%d,%d,%d,%d,UINT64_C(0x%x),UINT64_C(0x%x)},\n",
+								bits, scale, mode, daz, operation, input, want)
+						}
+					}
+				}
+			}
+		}
+	}
+	// Retain the complete original 8,192-row matrix above. Supplement only
+	// the small/grid boundary that makes the final subtraction inexact:
+	// either side of half-step, retained-unit ties and discarded bits.
+	for _, bits := range []int{32, 64} {
+		fraction, bias := uint(23), uint64(127)
+		if bits == 64 {
+			fraction, bias = 52, 1023
+		}
+		for scale := 0; scale < 16; scale++ {
+			regular := bias - uint64(scale)
+			half := (regular - 1) << fraction
+			middle := (regular - 4) << fraction
+			unit := (regular - 1 - uint64(fraction)) << fraction
+			inputs := []uint64{half - 1, half, half + 1, middle, middle + 1,
+				middle + (uint64(1) << (fraction - 1)) - 1,
+				middle + (uint64(1) << fraction) - 1, unit, unit + 1,
+				unit - 1}
+			for _, magnitude := range inputs {
+				for negative := 0; negative < 2; negative++ {
+					input, mode := magnitude, 2
+					if negative != 0 {
+						input |= uint64(1) << (bits - 1)
+						mode = 1
+					}
+					want := x86ScaledRoundExactIEEE(input, bits, scale, mode, false, true)
+					fmt.Fprintf(&rows, "{%d,%d,%d,0,1,UINT64_C(0x%x),UINT64_C(0x%x)},\n", bits, scale, mode, input, want)
+				}
+			}
+		}
+	}
+	return rows.String()
+}
+
+const x86ScaledRoundSelectedRoundingTable = `
+typedef struct { unsigned bits,scale,mode,daz,reduce; uint64_t input,want; } Row;
+static const Row rows[] = {
+ROWS
+};
+`
+
+func x86ScaledRoundOriginalCReference(t *testing.T) string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_lower_scaled_round_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var reference string
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "qualifyAMD64ScaledRoundRuntimeSemantics" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if ok && len(value.Names) == 1 && value.Names[0].Name == "mainC" && len(value.Values) == 1 {
+				literal, valid := value.Values[0].(*ast.BasicLit)
+				if !valid || literal.Kind != token.STRING || reference != "" {
+					t.Fatal("original C reference is not one complete literal")
+				}
+				reference, err = strconv.Unquote(literal.Value)
+			}
+			return true
+		})
+	}
+	start := strings.Index(reference, "static int inc(")
+	end := strings.Index(reference, "static uint32_t u32(")
+	if err != nil || start < 0 || end <= start {
+		t.Fatal("original four C reference helpers lost their complete boundaries", err)
+	}
+	return reference[start:end]
+}
+
+func x86ScaledRoundOriginalCReportComplete(output []byte) bool {
+	report := string(output)
+	return report == "original C exact IEEE observations 35328 failures 0\n" ||
+		report == "original C exact IEEE observations 35328 failures 0\r\n"
+}
+
+func TestX86ScaledRoundOriginalCReferenceSelectedRounding(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM22 clang required for the actual original C reference")
+	}
+	source := "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n#include <fenv.h>\n#pragma STDC FENV_ACCESS ON\n" +
+		x86ScaledRoundOriginalCReference(t) + strings.Replace(x86ScaledRoundSelectedRoundingTable, "ROWS", x86ScaledRoundSelectedRoundingRows(), 1) + `
+int main(void) {
+ const int modes[]={FE_TONEAREST,FE_DOWNWARD,FE_UPWARD,FE_TOWARDZERO};
+ int original=fegetround(); unsigned failures=0,observations=0;
+ for(unsigned ambient=0;ambient<4;ambient++) {
+  if(fesetround(modes[ambient])) return 2;
+  for(unsigned i=0;i<sizeof(rows)/sizeof(rows[0]);i++) {
+   const Row *r=&rows[i]; uint64_t got;
+   if(r->bits==32) got=r->reduce?reduce32((uint32_t)r->input,r->scale,r->mode,r->daz):round32((uint32_t)r->input,r->scale,r->mode,r->daz);
+   else got=r->reduce?reduce64(r->input,r->scale,r->mode,r->daz):round64(r->input,r->scale,r->mode,r->daz);
+   if(got!=r->want || fegetround()!=modes[ambient]) {
+    if(failures++<12) fprintf(stderr,"original C bits=%u reduce=%u scale=%u selected=%u ambient=%u daz=%u input=%llx got=%llx want=%llx rounding_after=%d\n",r->bits,r->reduce,r->scale,r->mode,ambient,r->daz,(unsigned long long)r->input,(unsigned long long)got,(unsigned long long)r->want,fegetround());
+   }
+   observations++;
+  }
+ }
+ if(fesetround(original)) return 3;
+ printf("original C exact IEEE observations %u failures %u\n",observations,failures);
+ return failures!=0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			directory := t.TempDir()
+			input, executable := filepath.Join(directory, "reference.c"), filepath.Join(directory, "reference")
+			if runtime.GOOS == "windows" {
+				executable += ".exe"
+			}
+			if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			arguments := []string{level, "-frounding-math", input, "-o", executable}
+			if runtime.GOOS != "windows" {
+				arguments = append(arguments, "-lm")
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			x86FloatCompareCaptureCommand(t, runtimeOracleNativeCCommand(t, ctx, clang, arguments...))
+			output := x86FloatCompareCaptureCommand(t, exec.Command(executable))
+			if !x86ScaledRoundOriginalCReportComplete(output) {
+				t.Fatalf("incomplete original C observations: %s", output)
+			}
+		})
+	}
+}
+
+func TestX86ScaledRoundPortableSelectedRoundingExactIEEE(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var ir, declarations strings.Builder
+	source, _ := x86ScaledRoundSelectedPublicSource("amd64")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Use the real whole-module requirements, not hand-written declarations
+	// that could conceal a missing public helper registration.
+	emitAMD64Prelude(&ir, "amd64", file)
+	for _, bits := range []int{32, 64} {
+		for operation := 0; operation < 2; operation++ {
+			for scale := 0; scale < 16; scale++ {
+				name := fmt.Sprintf("scaled_%d_%d_%d", bits, operation, scale)
+				fmt.Fprintf(&ir, "define i64 @%s(i64 %%source, i32 %%mode, i32 %%daz) {\nentry:\n", name)
+				input := "%source"
+				if bits == 32 {
+					ir.WriteString("  %input = trunc i64 %source to i32\n")
+					input = "%input"
+				}
+				fmt.Fprintf(&ir, "  %%vector = insertelement <1 x i%d> poison, i%d %s, i32 0\n  %%flush = icmp ne i32 %%daz, 0\n", bits, bits, input)
+				// This is expressly a private portable mathematical entry, not a
+				// public source/ABI or native x86 MXCSR certificate. Both packed
+				// and scalar fallback lowering call this exact shared producer.
+				ctx := newX86Ctx(&ir, Func{}, FuncSig{}, nil, nil, "amd64", triple, false)
+				result := ctx.emitScaledRoundBits(1, bits, "%vector", "%flush", "%mode", uint8(scale), amd64ScaledRoundMode(operation))
+				fmt.Fprintf(&ir, "  %%low = extractelement <1 x i%d> %s, i32 0\n", bits, result)
+				if bits == 32 {
+					ir.WriteString("  %out = zext i32 %low to i64\n  ret i64 %out\n}\n")
+				} else {
+					ir.WriteString("  ret i64 %low\n}\n")
+				}
+				fmt.Fprintf(&declarations, "extern uint64_t %s(uint64_t,unsigned,unsigned);\n", name)
+			}
+		}
+	}
+	var functions strings.Builder
+	functions.WriteString("typedef uint64_t (*Kernel)(uint64_t,unsigned,unsigned);\nstatic const Kernel kernels[2][2][16]={\n")
+	for _, bits := range []int{32, 64} {
+		functions.WriteString("{\n")
+		for operation := 0; operation < 2; operation++ {
+			functions.WriteString("{")
+			for scale := 0; scale < 16; scale++ {
+				fmt.Fprintf(&functions, "scaled_%d_%d_%d,", bits, operation, scale)
+			}
+			functions.WriteString("},\n")
+		}
+		functions.WriteString("},\n")
+	}
+	functions.WriteString("};\n")
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + functions.String() +
+		strings.Replace(x86ScaledRoundSelectedRoundingTable, "ROWS", x86ScaledRoundSelectedRoundingRows(), 1) + `
+int main(void) {
+ unsigned failures=0,observations=0;
+ for(unsigned i=0;i<sizeof(rows)/sizeof(rows[0]);i++) {
+  const Row *r=&rows[i]; uint64_t got=kernels[r->bits==64][r->reduce][r->scale](r->input,r->mode,r->daz);
+  if(got!=r->want && failures++<12) fprintf(stderr,"portable LLVM bits=%u reduce=%u scale=%u selected=%u daz=%u input=%llx got=%llx want=%llx\n",r->bits,r->reduce,r->scale,r->mode,r->daz,(unsigned long long)r->input,(unsigned long long)got,(unsigned long long)r->want);
+  observations++;
+ }
+ printf("portable exact IEEE observations %u failures %u\n",observations,failures);
+ return failures!=0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "scaled-round-selected-ieee", triple, ir.String(), main)
+}
diff --git a/amd64_segment_query_complete_test.go b/amd64_segment_query_complete_test.go
new file mode 100644
index 000000000..7a16d2bfd
--- /dev/null
+++ b/amd64_segment_query_complete_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86SegmentQueryCompleteInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for complete selector-query objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var source, declarations strings.Builder
+			functions, nativeReads := 0, 0
+			for _, row := range x86SegmentQueryOracle {
+				if target.arch == "386" && row.bytes == 8 {
+					continue
+				}
+				for _, role := range []string{"register", "FP", "native"} {
+					name := fmt.Sprintf("Query%s%s", row.op, role)
+					parameter, selector := "uint16", "AX"
+					prepare := "MOVW selector+0(FP),AX\n"
+					if role == "FP" {
+						selector, prepare = "selector+0(FP)", ""
+					} else if role == "native" {
+						parameter, selector = "*uint16", "(AX)"
+						prepare = move + " selector+0(FP),AX\n"
+						nativeReads++
+					}
+					query, result := row.op+" "+selector, "CX"
+					if row.bytes != 0 {
+						query += ",CX"
+					} else {
+						result = "DX"
+					}
+					body := prepare + move + " $0x13572468,CX\nSTC\n" + query + "\n"
+					if row.bytes == 0 {
+						body += "SETEQ DL\nMOVBLZX DL,DX\n"
+					}
+					body += fmt.Sprintf("%s %s,ret0+%d(FP)\nRET\n", move, result, word)
+					declaration := fmt.Sprintf("func Value(selector %s) %s", parameter, typ)
+					_, _, _, original := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					source.WriteString(strings.Replace(original, "Value(SB)", name+"(SB)", 1))
+					declarations.WriteString(strings.Replace(declaration, "Value(", name+"(", 1) + "\n")
+					functions++
+				}
+			}
+			want := 24
+			if target.arch == "386" {
+				want = 18
+			}
+			if functions != want || functions > 64 {
+				t.Fatal("complete bounded selector-query object inventory changed", functions, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized selector-query public objects rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "load volatile i16, ptr") != nativeReads {
+							t.Fatal("native selectors lost their exact two-byte access", nativeReads)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86SegmentQueryNativeReaderSourceBoundaries(t *testing.T) {
+	for _, row := range x86SegmentQueryOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			if arch == "386" && row.bytes == 8 {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				text := row.op + " (BX)"
+				if row.bytes != 0 {
+					text += ",CX"
+				}
+				ins := x86ScalarLaneInstruction(t, text)
+				initial := x86ResultState{flags: x86ByteFlagCF, direction: x86ResultDirectionBackward}
+				initial.pointerGP[3] = true
+				initial.gp[1] = 0xff
+				state := initial.clone()
+				if got, known := x86ResultSegmentQueryStep(ins, &state, nil, arch, false); !known || got || !reflect.DeepEqual(state, initial) {
+					t.Fatal("standalone shape manufactured native selector bytes")
+				}
+				if got, known := x86ResultSegmentQueryStep(ins, &state, nil, arch, true); !known || !got ||
+					state.flags != x86ByteFlagCF|x86ByteFlagZF || state.direction != initial.direction || !state.pointerGP[3] {
+					t.Fatal("paired m16 continuation lost its precise FLAGS/address effects")
+				}
+				for _, mutation := range []string{"pointer", "old", "encoded", "raw", "segment", "address", "return"} {
+					if mutation == "old" && row.bytes == 0 {
+						continue
+					}
+					changed, state := ins, initial.clone()
+					switch mutation {
+					case "pointer":
+						state.pointerGP[3] = false
+					case "old":
+						state.gp[1] = 0
+					case "encoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "address":
+						changed.x86AddressBits = 32
+					case "return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					}
+					before := state.clone()
+					if got, _ := x86ResultSegmentQueryStep(changed, &state, nil, arch, true); got || !reflect.DeepEqual(state, before) {
+						t.Fatal("native continuation supplied missing input or mutated a rejected state", mutation)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SegmentQueryVoidAndUnusedBoolRetainInputs(t *testing.T) {
+	for _, row := range x86SegmentQueryOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			if arch == "386" && row.bytes == 8 {
+				continue
+			}
+			for _, signature := range []string{"func Value()", "func Value(unused bool)"} {
+				t.Run(arch+"/"+row.op+"/"+signature, func(t *testing.T) {
+					move := "MOVQ"
+					triple := "x86_64-unknown-linux-gnu"
+					if arch == "386" {
+						move, triple = "MOVL", "i386-unknown-linux-gnu"
+					}
+					query := row.op + " AX"
+					if row.bytes != 0 {
+						query += ",CX"
+					}
+					args := 0
+					if strings.Contains(signature, "unused bool") {
+						args = 1
+					}
+					for _, inputs := range []string{"MOVW $0,AX\n" + move + " $7,CX\n", move + " $7,CX\n", "MOVB $0,AL\n" + move + " $7,CX\n"} {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n", args) + inputs + query + "\nRET\n"
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, signature, arch, triple, api)
+							if strings.HasPrefix(inputs, "MOVW") {
+								if err != nil || ir == "" {
+									t.Fatal("complete Void query inputs rejected", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void or unused bool hid missing selector bytes", api, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SegmentQueryRejectsBeforeDispatchMutation(t *testing.T) {
+	for _, row := range x86SegmentQueryOracle {
+		original := x86SegmentQueryOracleInstruction(t, row.op, row.bytes != 0)
+		for _, mutation := range []string{"identity", "suffix", "source", "count", "index"} {
+			ins := original
+			ins.Args = append([]Operand(nil), original.Args...)
+			op := ins.Op
+			switch mutation {
+			case "identity":
+				ins.Op = "MOVL"
+			case "suffix":
+				op, ins.Op = Op(row.op+".Z"), Op(row.op+".Z")
+			case "source":
+				ins.Args[0] = Operand{Kind: OpImm, Imm: 0}
+			case "count":
+				ins.Args = append(ins.Args, Operand{Kind: OpReg, Reg: DX})
+			case "index":
+				ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: BX, Index: SP, Scale: 2}}
+			}
+			var output strings.Builder
+			context := &amd64Ctx{goarch: "amd64", b: &output}
+			if known, terminated, err := context.lowerSegmentQuery(op, ins); !known || terminated || err == nil || output.Len() != 0 {
+				t.Fatal("invalid complete query shape emitted partial IR", row.op, mutation, err, output.String())
+			}
+		}
+	}
+}
+
+func TestX86SegmentQueryConditionalDwordNeverInventsCanonicalHighBytes(t *testing.T) {
+	for _, op := range []string{"LARL", "LSLL"} {
+		ins := x86SegmentQueryOracleInstruction(t, op, true)
+		for _, upper := range []uint8{0, 0x50, 0xf0} {
+			before := [16]uint8{0xa5, upper | 0x0f, 0x5a}
+			after := x86RegisterCanonicalBytesAfter(ins, before, "amd64")
+			if after[0] != before[0] || after[1] != upper || after[2] != before[2] {
+				t.Fatal("conditional dword write manufactured canonical upper bytes", op, before, after)
+			}
+		}
+	}
+}
diff --git a/amd64_segment_query_forms.go b/amd64_segment_query_forms.go
new file mode 100644
index 000000000..9b8f3b467
--- /dev/null
+++ b/amd64_segment_query_forms.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The complete Go yml_rl/ydivl selector-query family shares one typed shape.
+// Destination width does not enlarge the selector's two-byte source tuple.
+func x86SegmentQueryProperties(op Op, ins Instr, arch string) (amd64SegmentQueryForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64SegmentQuerySpecs[Op(name)]
+	form := amd64SegmentQueryForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (amd64SegmentQueryForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go selector-query grammar: %q", arch, op, ins.Raw)
+	}
+	want := 2
+	if spec.bits == 0 {
+		want = 1
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && spec.bits == 64 || dotted ||
+		len(ins.Args) != want || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail()
+	}
+	form.selector = ins.Args[0]
+	if form.selector.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.selector.Reg, arch) {
+			return fail()
+		}
+	} else if !x86PackedShiftMemoryValid(form.selector, arch) || x86NamedMultiplyMemoryError(form.selector, arch) != nil {
+		return fail()
+	}
+	if want == 2 {
+		destination := ins.Args[1]
+		if destination.Kind != OpReg || !isX86YrlRegisterForArch(destination.Reg, arch) {
+			return fail()
+		}
+		form.destination = destination.Reg
+	}
+	return form, true, nil
+}
+
+func x86TypedSegmentQueryByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86SegmentQueryProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, flagsDefined: x86ByteFlagZF,
+		operands: []x86TypedByteOperand{{index: 0, operand: form.selector, width: 2, read: true}}}
+	if form.spec.bits != 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: 1, operand: ins.Args[1], width: int64(form.spec.bits / 8), read: true, write: true,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_segment_test.go b/amd64_segment_test.go
index 9dd820d1a..a263ae89e 100644
--- a/amd64_segment_test.go
+++ b/amd64_segment_test.go
@@ -1,46 +1,83 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
 
 func TestTranslateAMD64SegmentMemory(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
 	src := `
-TEXT loadGS(SB),NOSPLIT,$0-0
+TEXT ·loadGS(SB),4,$0-0
 	MOVQ 0x30(GS), DI
 	MOVQ DI, 0(CX)(GS)
 	MOVQ -8(FS), AX
 	RET
 `
-	file, err := Parse(ArchAMD64, src)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ir, err := Translate(file, Options{
-		TargetTriple: "x86_64-pc-windows-msvc",
-		Sigs: map[string]FuncSig{
-			"loadGS": {Name: "loadGS", Ret: Void},
-		},
-		Goarch: "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, want := range []string{
-		"load i64, ptr addrspace(256)",
-		"store i64",
-		"ptr addrspace(256)",
-		"load i64, ptr addrspace(257)",
-	} {
-		if !strings.Contains(ir, want) {
-			t.Fatalf("segment-relative output missing %q:\n%s", want, ir)
-		}
-	}
-	if strings.Contains(ir, "0x30(GS)") {
-		t.Fatalf("segment-relative memory was emitted as a symbol:\n%s", ir)
+	triple := "x86_64-pc-windows-msvc"
+	x86LEAActualTargetGoObject(t, "amd64", triple, src)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, src, "func loadGS()", "amd64", triple, api)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" ||
+				!strings.Contains(err.Error(), "unclosed source effect at instruction 1: MOVQ DI, 0(CX)(GS)") {
+				t.Fatal("complete original source lost its unbound native-store boundary", err)
+			}
+		})
+	}
+	// This independent read-only counterpart removes exactly the unbound
+	// store. The complete original above remains a Go-format-positive,
+	// translation-Context control, not a successful native-write fixture.
+	store := "\tMOVQ DI, 0(CX)(GS)\n"
+	if strings.Count(src, store) != 1 {
+		t.Fatal("original full segment fixture changed its single native store")
+	}
+	readOnly := strings.Replace(src, store, "", 1)
+	if strings.Count(readOnly, "MOVQ") != 2 || strings.Count(readOnly, "TEXT ") != 1 {
+		t.Fatal("read-only counterpart lost an original segment read or TEXT")
+	}
+	x86LEAActualTargetGoObject(t, "amd64", triple, readOnly)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("read-only/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, readOnly, "func loadGS()", "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("independent read-only segment counterpart was rejected", err)
+			}
+			for _, irLevel := range []string{"0", "2"} {
+				output := ir
+				if irLevel == "2" {
+					output = x86DwordProductIROptimize(t, ir)
+				}
+				for _, want := range []string{
+					"load volatile i64, ptr addrspace(256)",
+					"load volatile i64, ptr addrspace(257)",
+				} {
+					if strings.Count(output, want) != 1 {
+						t.Fatalf("segment-relative output missing %q:\n%s", want, output)
+					}
+				}
+				if strings.Count(output, "load volatile ") != 2 {
+					t.Fatal("dead-result segment reads were duplicated or eliminated", output)
+				}
+				for _, line := range strings.Split(output, "\n") {
+					if strings.Contains(line, "store ") && strings.Contains(line, "ptr addrspace(") {
+						t.Fatal("read-only counterpart acquired a native segment store", line)
+					}
+				}
+				if strings.Contains(output, "0x30(GS)") {
+					t.Fatalf("segment-relative memory was emitted as a symbol:\n%s", output)
+				}
+				for _, backendLevel := range []string{"0", "2"} {
+					t.Run("IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+						x86PackedStringCompileObject(t, llc, triple, output, "-O"+backendLevel)
+					})
+				}
+			}
+		})
 	}
 }
 
diff --git a/amd64_sha_family_objects_test.go b/amd64_sha_family_objects_test.go
new file mode 100644
index 000000000..044f375d2
--- /dev/null
+++ b/amd64_sha_family_objects_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86SHADefaultGoarchNativeTarget(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\nPXOR X1,X1\nSHA1MSG1 X1,X1\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}}
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			if api == "text" {
+				if ir, err := Translate(file, options); err != nil || ir == "" {
+					t.Fatal("default amd64 Go source lost its explicit native target", err)
+				}
+				return
+			}
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := TranslateModuleInContext(context, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil || module.IsNil() {
+				t.Fatal("default amd64 Go source lost its explicit native target", err)
+			}
+		})
+	}
+}
+
+func TestX86SHABackendIgnoresOrdinaryNamesAndUnusedDeclarations(t *testing.T) {
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, `target triple = "aarch64-unknown-linux-gnu"
+declare <4 x i32> @llvm.x86.sha1msg1(<4 x i32>, <4 x i32>)
+define void @SHA1MSG1() { ret void }
+define void @ordinary() { call void @SHA1MSG1() ret void }
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	if err := validateTranslatedBackend(nil, Options{}, module); err != nil {
+		t.Fatal("an ordinary function name or unused declaration constrained the backend", err)
+	}
+}
+
+func TestX86SHABackendRequirement(t *testing.T) {
+	for _, row := range x86SHAOracleInputs {
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+				t.Run(row.name+"/"+api+"/"+triple, func(t *testing.T) {
+					body := "PXOR X0,X0\nPXOR X1,X1\nPXOR X2,X2\n" +
+						x86SHAOracleRow(row.name, "X1", "X2", 3) + "\nRET"
+					ir, err := targetBackendRequest(t, api, triple, targetBackendCase{arch: ArchAMD64, goarch: "amd64", body: body})
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("SHA target-specific operation escaped to an unspecified or foreign backend", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SHALoweringUsesExactLLVMOperations(t *testing.T) {
+	// A format unit isolates the original semantic bug from the independent
+	// initialized-source gate. It is not a successful public translation.
+	for _, row := range x86SHAOracleInputs {
+		t.Run(row.name, func(t *testing.T) {
+			instruction := x86SHAOracleRow(row.name, "X1", "X2", 3)
+			source := "TEXT sha(SB),4,$0-0\n" + instruction + "\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, map[string]FuncSig{"sha": {Name: "sha", Ret: Void}},
+				"amd64", "x86_64-unknown-linux-gnu", 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerVec(ins.Op, ins) })
+			if !strings.Contains(ir, "call <4 x i32> @llvm.x86."+strings.ToLower(row.name)+"(") {
+				t.Fatal("SHA must use its exact operation, not approximate lane additions")
+			}
+		})
+	}
+}
+
+func TestX86SHAInitializedNamedRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var source, declarations strings.Builder
+				count := 0
+				for _, row := range x86SHAOracleInputs {
+					selectors := []int{0}
+					if row.name == "SHA1RNDS4" {
+						selectors = []int{0, 1, 2, 3}
+					}
+					for _, selector := range selectors {
+						name := fmt.Sprintf("Value%d", count)
+						count++
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVL a+0(FP),AX\nMOVL b+4(FP),BX\n", name)
+						// Initialize only numerically consumed dwords; untouched
+						// input lanes must not be silently borrowed from alloca zero.
+						for register, mask := range []uint16{row.implicit, row.source, row.old} {
+							for lane := 0; lane < 4; lane++ {
+								if mask&(15<<uint(lane*4)) != 0 {
+									gp := []string{"AX", "BX", "AX"}[register]
+									fmt.Fprintf(&source, "PINSRD $%d,%s,X%d\n", lane, gp, register)
+								}
+							}
+						}
+						instruction := x86SHAOracleRow(row.name, "X1", "X2", selector)
+						if raw {
+							instruction = x86RawNumericalInstruction(t, target.arch, instruction)
+						}
+						fmt.Fprintf(&source, "%s\nPEXTRD $0,X2,AX\nMOVL AX,ret+8(FP)\nRET\n", instruction)
+						fmt.Fprintf(&declarations, "func %s(a,b uint32) uint32\n", name)
+					}
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("initialized original SHA results failed", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestGoAMD64FixedLocalSHAObjects(t *testing.T) {
+	var assembly, declarations strings.Builder
+	rows := fixedLocalSHACases()
+	for index, row := range rows {
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(fixedLocalVEXAssembly(row), "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a uint64) uint64\n", name)
+	}
+	fixedLocalCompleteVectorObjects(t, assembly.String(), declarations.String(), len(rows))
+}
diff --git a/amd64_sha_family_test.go b/amd64_sha_family_test.go
new file mode 100644
index 000000000..db1858275
--- /dev/null
+++ b/amd64_sha_family_test.go
@@ -0,0 +1,235 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Intel input inventory, in little-endian byte order. Memory
+// operands still read the complete m128 even where register words are unused.
+var x86SHAOracleInputs = []struct {
+	name                  string
+	source, old, implicit uint16
+}{
+	{"SHA1NEXTE", 0xffff, 0xf000, 0},
+	{"SHA1MSG1", 0xff00, 0xffff, 0},
+	{"SHA1MSG2", 0x0fff, 0xffff, 0},
+	{"SHA1RNDS4", 0xffff, 0xffff, 0},
+	{"SHA256MSG1", 0x000f, 0xffff, 0},
+	{"SHA256MSG2", 0xff00, 0xffff, 0},
+	{"SHA256RNDS2", 0xffff, 0xffff, 0x00ff},
+}
+
+func x86SHAOracleRow(name, source, destination string, immediate int) string {
+	args := source + "," + destination
+	if name == "SHA1RNDS4" {
+		args = fmt.Sprintf("$%d,", immediate) + args
+	} else if name == "SHA256RNDS2" {
+		args = "X0," + args
+	}
+	return name + " " + args
+}
+
+func TestX86SHAIndependentCompleteGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{ASHA(?:1|256)[A-Z0-9]+, [^\n]+`).FindAllString(string(data), -1)
+	if len(rows) != 7 {
+		t.Fatal("complete legacy SHA opcode inventory changed", len(rows))
+	}
+	for index, row := range x86SHAOracleInputs {
+		table, prefix := "yaes", "Px"
+		code := []string{"0x0f, 0x38, 0xc8", "0x0f, 0x38, 0xc9", "0x0f, 0x38, 0xca", "0x3a, 0xcc", "0x0f, 0x38, 0xcc", "0x0f, 0x38, 0xcd", "0x0f, 0x38, 0xcb"}[index]
+		if row.name == "SHA1RNDS4" {
+			table, prefix = "ysha1rnds4", "Pm"
+		} else if row.name == "SHA256RNDS2" {
+			table = "ysha256rnds2"
+		}
+		want := fmt.Sprintf("{A%s, %s, %s, opBytes{%s, 0}}", row.name, table, prefix, code)
+		if !strings.Contains(string(data), want) {
+			t.Fatal("complete SHA encoding row changed", want)
+		}
+	}
+	for table, want := range map[string]string{
+		"yaes":         "{Zlitm_r, 2, argList{Yxm, Yxr}},",
+		"ysha1rnds4":   "{Zibm_r, 2, argList{Yu2, Yxm, Yxr}},",
+		"ysha256rnds2": "{Zlit_m_r, 0, argList{Yxr0, Yxm, Yxr}},",
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(match) != 2 || strings.Join(strings.Fields(string(match[1])), " ") != want {
+			t.Fatal("complete SHA argument classes changed", table, match)
+		}
+	}
+}
+
+func TestX86SHASelectedInputsSharedConsumers(t *testing.T) {
+	for _, row := range x86SHAOracleInputs {
+		for _, source := range []string{"X1", "X2", "X0"} {
+			operation := x86SHAOracleRow(row.name, source, "X2", 3)
+			t.Run(operation, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, operation)
+				_, sig, _ := fixedLocalVEXFixture(t, operation)
+				needed := map[Reg]uint16{"Z2": row.old, "Z0": row.implicit}
+				needed[x86CallerVectorRoot(Reg(source))] |= row.source
+				for input, mask := range needed {
+					for missing := -1; missing < 16; missing++ {
+						local := x86FixedLocalState{vectors: map[Reg]uint64{}, flags: x86ByteFlagsAll}
+						result := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+						for root, known := range needed {
+							if root == input && missing >= 0 {
+								known &^= uint16(1) << uint(missing)
+							}
+							local.vectors[root] = uint64(known) | 1<<60
+							index := int(root[1] - '0')
+							result.writeVector(index, 64, local.vectors[root], false)
+						}
+						wantFull := missing < 0 || mask&(uint16(1)<<uint(missing)) == 0
+						proof := &x86FixedLocalProof{}
+						if err := fixedLocalStep(&ins, &local, sig, proof, 0); err != nil {
+							t.Fatal("nontrapping SHA register transfer lacks shared effect", operation, err)
+						}
+						for _, transfer := range []func(Instr, *x86ResultState, []bool, int64, string) bool{x86ResultTransfer, x86ScalarFPResultTransfer} {
+							copy := result.clone()
+							if !transfer(ins, &copy, nil, 0, "amd64") || copy.vectorBytes(2) != local.vectors["Z2"] {
+								t.Fatal("result and private-frame SHA numerical bytes differ", operation, input, missing)
+							}
+							if copy.flags != result.flags || copy.direction != result.direction {
+								t.Fatal("SHA changed independent flags/direction")
+							}
+						}
+						if (local.vectors["Z2"]&0xffff == 0xffff) != wantFull || local.vectors["Z2"]>>16 != 1<<44 || local.flags != x86ByteFlagsAll {
+							t.Fatal("unused SHA bytes became mandatory or missing state became defined", operation, input, missing, local.vectors)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SHAFullMemoryAndGrammarGuards(t *testing.T) {
+	for _, row := range x86SHAOracleInputs {
+		for missing := -1; missing < 16; missing++ {
+			operation := x86SHAOracleRow(row.name, "a+0(FP)", "X2", 3)
+			t.Run(fmt.Sprintf("%s/missing%d", row.name, missing), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, operation)
+				state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll}
+				state.xmm[0], state.xmm[2] = row.implicit, row.old
+				owned := make([]bool, 16)
+				for i := range owned {
+					owned[i], state.fp[i] = true, i != missing
+				}
+				before := state.clone()
+				got := x86ResultTransfer(ins, &state, owned, 16, "amd64")
+				if got != (missing < 0) || got && state.xmm[2] != 0xffff || !got && !reflect.DeepEqual(state, before) {
+					t.Fatal("SHA numerical word mask replaced its complete memory envelope", got, state)
+				}
+			})
+		}
+	}
+	for _, operation := range []string{
+		"SHA256RNDS2 X1,X2,X3", "SHA256RNDS2 X0,X1", "SHA1RNDS4 $-1,X1,X2", "SHA1RNDS4 $4,X1,X2",
+		"SHA1RNDS4 $0.5,X1,X2", "SHA1MSG1 Y1,X2", "SHA1MSG1 X16,X2", "SHA1MSG1 X1,(AX)", "SHA1MSG1.Z X1,X2",
+	} {
+		t.Run(operation, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, operation)
+			_, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if !known || err == nil {
+				t.Fatal("invalid SHA form was not rejected by its shared grammar", known, err)
+			}
+		})
+	}
+}
+
+func fixedLocalSHACases() []string {
+	var rows []string
+	for _, family := range x86SHAOracleInputs {
+		selectors := []int{0}
+		if family.name == "SHA1RNDS4" {
+			selectors = []int{0, 1, 2, 3}
+		}
+		for _, selector := range selectors {
+			for _, source := range []string{"X0", "X1", "X2", "64(BP)", "(SI)"} {
+				rows = append(rows, x86SHAOracleRow(family.name, source, "X2", selector))
+			}
+		}
+	}
+	return rows
+}
+
+func TestGoAMD64FixedLocalSHACompleteFamily(t *testing.T) {
+	rows := fixedLocalSHACases()
+	if len(rows) != 50 {
+		t.Fatal("SHA complete selector/alias/memory inventory changed", len(rows))
+	}
+	var source strings.Builder
+	for index, row := range rows {
+		source.WriteString(strings.Replace(fixedLocalVEXAssembly(row), "·Value", fmt.Sprintf("·Value%d", index), 1))
+	}
+	requireX86GoAssemblerResult(t, "amd64", source.String(), true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			fn, sig, _ := fixedLocalVEXFixture(t, row)
+			if _, err := proveX86FixedLocal(fn, sig); err != nil {
+				t.Fatal("initialized original Go SHA function lacks fixed-local support", err)
+			}
+		})
+	}
+	for _, source := range []string{"65(BP)", "256(BP)", "(AX)"} {
+		for _, family := range x86SHAOracleInputs {
+			operation := x86SHAOracleRow(family.name, source, "X2", 0)
+			fn, sig, assembly := fixedLocalVEXFixture(t, operation)
+			if source == "(AX)" {
+				operand := 0
+				if family.name == "SHA1RNDS4" || family.name == "SHA256RNDS2" {
+					operand = 1
+				}
+				fixedLocalRequireNumericControl(t, fn, sig, assembly, "func Value(p *uint64,a uint64) uint64",
+					operation, operand, 16, false, strings.ToLower(family.name))
+				continue
+			}
+			if _, err := proveX86FixedLocal(fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("SHA acquired unaligned, uninitialized or unauthenticated memory", family.name, source, err)
+			}
+		}
+	}
+}
+
+func TestX86SHAOriginalPhysicalBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var rows []string
+		for _, family := range x86SHAOracleInputs {
+			for _, source := range []string{"X1", "X7", "16(AX)(CX*2)", "16(BP)", "·data(SB)"} {
+				rows = append(rows, x86SHAOracleRow(family.name, source, "X2", 3))
+			}
+		}
+		code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nRET")
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for index, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				physical := code[pcs[index]:pcs[index+1]]
+				boundaries, _, err := x86NumericalNativeBoundaries(physical, mode)
+				if err != nil || len(boundaries) != 1 || boundaries[0].Length != len(physical) {
+					t.Fatal("original Go SHA bytes lack exact whole-TEXT boundary", fmt.Sprintf("%x", physical), err)
+				}
+				for end := 1; end < len(physical); end++ {
+					if _, _, err := x86NumericalNativeBoundaries(physical[:end], mode); err == nil {
+						t.Fatal("truncated SHA instruction acquired a complete boundary", end)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_sha_forms.go b/amd64_sha_forms.go
new file mode 100644
index 000000000..be440808c
--- /dev/null
+++ b/amd64_sha_forms.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Complete Go legacy SHA rows. The same encoding identity selects the
+// grammar, numerical dependencies, native decoder and LLVM operation.
+var x86SHAEncodings = map[Op]uint16{
+	"SHA1NEXTE": 0x38c8, "SHA1MSG1": 0x38c9, "SHA1MSG2": 0x38ca,
+	"SHA1RNDS4": 0x3acc, "SHA256RNDS2": 0x38cb,
+	"SHA256MSG1": 0x38cc, "SHA256MSG2": 0x38cd,
+}
+
+type x86SHAForm struct {
+	op                          Op
+	encoding                    uint16
+	source, destination, memory int
+	immediate                   uint8
+	sourceOperand               Operand
+}
+
+func x86SHAProperties(op Op, ins Instr, arch string) (x86SHAForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	encoding, known := x86SHAEncodings[Op(name)]
+	if !known {
+		return x86SHAForm{}, false, nil
+	}
+	f := x86SHAForm{op: Op(name), encoding: encoding, destination: 1, memory: -1}
+	fail := func() (x86SHAForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go SHA grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) {
+		return fail()
+	}
+	count := 2
+	if encoding == 0x3acc || encoding == 0x38cb {
+		count, f.source, f.destination = 3, 1, 2
+	}
+	if len(ins.Args) != count {
+		return fail()
+	}
+	if encoding == 0x3acc {
+		selector := ins.Args[0]
+		if arch == "386" && !ins.x86Encoded {
+			selector.Imm = int64(int32(selector.Imm))
+		}
+		if !amd64UnsignedImmediate(selector, 2) || selector.ImmIsFloat || selector.ImmRaw != "" {
+			return fail()
+		}
+		f.immediate = uint8(selector.Imm)
+	} else if encoding == 0x38cb && (ins.Args[0].Kind != OpReg || ins.Args[0].Reg != "X0") {
+		return fail()
+	}
+	register := func(a Operand) bool {
+		index, valid := amd64ParseXReg(a.Reg)
+		return a.Kind == OpReg && valid && index < 16 && (arch != "386" || index < 8)
+	}
+	if !register(ins.Args[f.destination]) {
+		return fail()
+	}
+	f.sourceOperand = ins.Args[f.source]
+	if isAMD64MemoryOperand(f.sourceOperand) {
+		if !x86PackedShiftMemoryValid(f.sourceOperand, arch) || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return fail()
+		}
+		if f.sourceOperand.Kind == OpMem {
+			if !x86ConditionalMoveOffsetKnown(f.sourceOperand.Mem) {
+				return fail()
+			}
+			if err := x86SymbolIndexedMemoryError(f.sourceOperand.Mem, arch); err != nil {
+				return f, true, err
+			}
+			if f.source == 1 && !ins.x86Encoded && ins.x86SourceRaw == nil {
+				// Go encodes segment prefixes from From/To, not From3.
+				f.sourceOperand.Mem.Segment = ""
+				if f.sourceOperand.Mem.Base == FS || f.sourceOperand.Mem.Base == GS {
+					f.sourceOperand.Mem.Base = ""
+				}
+			}
+		}
+		f.memory = f.source
+	} else if !register(f.sourceOperand) {
+		return fail()
+	}
+	return f, true, nil
+}
+
+// Required bytes for one output byte: source, old destination, implicit X0.
+// Copy/XOR dependencies retain byte precision. Rotates, carries and rounds
+// conservatively require complete input dwords; unrelated dwords stay unused.
+func x86SHAByteInputs(encoding uint16, out int) (source, old, implicit uint64) {
+	lane, within := out/4, uint(out%4)
+	word := func(lane int) uint64 { return uint64(15) << uint(lane*4) }
+	switch encoding {
+	case 0x38c8:
+		if lane < 3 {
+			return uint64(1) << uint(out), 0, 0
+		}
+		return word(3), word(3), 0
+	case 0x38c9:
+		if lane < 2 {
+			return uint64(1) << uint((lane+2)*4+int(within)), uint64(1) << uint(out), 0
+		}
+		return 0, uint64(1)<<uint(out) | uint64(1)<<uint(out-8), 0
+	case 0x38ca:
+		if lane == 0 {
+			return word(2), word(0) | word(3), 0
+		}
+		return word(lane - 1), word(lane), 0
+	case 0x3acc:
+		return uint64(0xffff) << uint((3-lane)*4) & 0xffff, 0xffff, 0
+	case 0x38cc:
+		if lane == 3 {
+			return word(0), word(3), 0
+		}
+		return 0, word(lane) | word(lane+1), 0
+	case 0x38cd:
+		old = word(lane)
+		if lane >= 2 {
+			old |= word(lane - 2)
+		}
+		return word(lane%2 + 2), old, 0
+	case 0x38cb:
+		return [4]uint64{0x00ff, 0x00ff, 0xffff, 0xffff}[lane],
+			[4]uint64{0x0fff, 0xffff, 0xf0ff, 0xffff}[lane],
+			[4]uint64{0x000f, 0x00ff, 0x000f, 0x00ff}[lane]
+	}
+	return 0, 0, 0
+}
+
+func x86SHADefinedBytes(f x86SHAForm, source, old, implicit uint64) uint64 {
+	var result uint64
+	for out := 0; out < 16; out++ {
+		s, d, x := x86SHAByteInputs(f.encoding, out)
+		if source&s == s && old&d == d && implicit&x == x {
+			result |= uint64(1) << uint(out)
+		}
+	}
+	return result
+}
+
+func x86TypedSHAByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86SHAProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	var source, old, implicit uint64
+	for out := 0; out < 16; out++ {
+		s, d, x := x86SHAByteInputs(f.encoding, out)
+		source, old, implicit = source|s, old|d, implicit|x
+	}
+	if f.memory >= 0 {
+		source = 0 // A register dependency mask never narrows the m128 access.
+	}
+	e := x86TypedByteEffect{requiresResultProof: true,
+		vector: x86TypedVectorEffect{x86TypedVectorUpperPreserve, 16},
+		operands: []x86TypedByteOperand{
+			{index: f.source, operand: f.sourceOperand, width: 16, read: true, requiredBytes: source},
+			{index: f.destination, operand: ins.Args[f.destination], width: 16, read: true, write: true, requiredBytes: old},
+		}}
+	if implicit != 0 {
+		e.operands = append(e.operands, x86TypedByteOperand{index: 0, operand: ins.Args[0], width: 16, read: true, requiredBytes: implicit})
+	}
+	return e, true, nil
+}
+
+func x86ResultSHAStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86SHAProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawOrdinaryVectorSourceAt(ins, arch, f.source) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	input := uint64(0xffff)
+	if f.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, f.sourceOperand, 16, state, owned, arch, native) {
+			return false, true
+		}
+	} else {
+		index, _ := amd64ParseXReg(f.sourceOperand.Reg)
+		input = state.vectorBytes(index)
+	}
+	destination, _ := amd64ParseXReg(ins.Args[f.destination].Reg)
+	defined := x86SHADefinedBytes(f, input, state.vectorBytes(destination), state.vectorBytes(0))
+	state.writeVector(destination, 16, defined, true)
+	return true, true
+}
+
+func x86RawSHASource(ins Instr, arch string) bool {
+	f, known, err := x86SHAProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSourceAt(ins, arch, f.source)
+}
+
+func fixedLocalSHAStep(ins *Instr, state *x86FixedLocalState, proof *x86FixedLocalProof, residue int) (bool, error) {
+	f, known, err := x86SHAProperties(ins.Op, *ins, "amd64")
+	if !known {
+		return false, nil
+	}
+	if err != nil {
+		return true, goAMD64FrameContext("fixed local SHA shape is not closed")
+	}
+	source := state.vectors[x86CallerVectorRoot(f.sourceOperand.Reg)]
+	if f.memory >= 0 {
+		if _, _, err := fixedLocalReadMemory(ins, f.memory, state, proof, residue, 16, 16); err != nil {
+			return true, err
+		}
+		source = 0xffff
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	old := state.vectors[destination]
+	state.vectors[destination] = old&^uint64(0xffff) | x86SHADefinedBytes(f, source, old, state.vectors["Z0"])
+	return true, nil
+}
diff --git a/amd64_sha_native_linux_amd64_test.go b/amd64_sha_native_linux_amd64_test.go
new file mode 100644
index 000000000..52165e8d1
--- /dev/null
+++ b/amd64_sha_native_linux_amd64_test.go
@@ -0,0 +1,19 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalSHA(t *testing.T) {
+	execution := fixedLocalVEXNativeTools(t)
+	t.Logf("%s", execution.run(t, fixedLocalSHARuntimePreflight(t, execution)))
+	// Original Go independently computes all 128 result bits and legacy
+	// upper aliases after every operation, for 16 asymmetric input patterns.
+	fixedLocalVectorRuntime(t, execution, true, fixedLocalSHARuntimeKernels(t))
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixGoAMD64SHAFaults(t *testing.T) {
+	execution := fixedLocalVEXNativeTools(t)
+	t.Logf("%s", execution.run(t, fixedLocalSHARuntimePreflight(t, execution)))
+	fixedLocalSHAFaultRuntime(t, execution, true)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_sha_runtime_unix_test.go b/amd64_sha_runtime_unix_test.go
new file mode 100644
index 000000000..71135789b
--- /dev/null
+++ b/amd64_sha_runtime_unix_test.go
@@ -0,0 +1,156 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func fixedLocalSHARuntimeKernels(t *testing.T) []fixedLocalVEXRuntimeKernel {
+	t.Helper()
+	var kernels []fixedLocalVEXRuntimeKernel
+	count := 0
+	for _, family := range x86SHAOracleInputs {
+		selectors := []int{0}
+		if family.name == "SHA1RNDS4" {
+			selectors = []int{0, 1, 2, 3}
+		}
+		for _, selector := range selectors {
+			var operations []string
+			for _, source := range []string{"X0", "X1", "X2", "64(BP)", "(SI)"} {
+				operations = append(operations, x86SHAOracleRow(family.name, source, "X2", selector))
+			}
+			for _, source := range []string{"X1", "X0"} {
+				operations = append(operations, x86SHAOracleRow(family.name, source, "X0", selector))
+			}
+			kernels = append(kernels, fixedLocalVEXRuntimeKernel{
+				shape: fmt.Sprintf("%s/%d", family.name, selector), operations: operations,
+			})
+			count += len(operations)
+		}
+	}
+	if len(kernels) != 10 || count != 70 {
+		t.Fatal("complete SHA original-execution inventory changed", len(kernels), count)
+	}
+	return kernels
+}
+
+func fixedLocalSHARuntimePreflight(t *testing.T, execution x86FloatCompareExecution) string {
+	t.Helper()
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "sha.c"), filepath.Join(directory, "sha")
+	const program = `#include <stdio.h>
+#include <string.h>
+#include <cpuid.h>
+__attribute__((target("sha,sse2"))) static int original_sha(void) {
+    unsigned bits;
+    __asm__ volatile("pxor %%xmm0,%%xmm0; sha1msg1 %%xmm0,%%xmm0; pmovmskb %%xmm0,%0"
+                     : "=r"(bits) :: "xmm0");
+    return bits==0;
+}
+int main(void) {
+    __builtin_cpu_init();
+    int sha=!!__builtin_cpu_supports("sha");
+    unsigned a, b, c, d, signature;
+    char vendor[13]={0};
+    __cpuid(0,a,b,c,d);
+    memcpy(vendor,&b,4);
+    memcpy(vendor+4,&d,4);
+    memcpy(vendor+8,&c,4);
+    __cpuid(1,signature,b,c,d);
+    printf("fixed-frame native SHA=%d vendor=%s signature=%08x\n",sha,vendor,signature);
+    return sha && original_sha() ? 0 : 1;
+}
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	return executable
+}
+
+func TestGoAMD64FixedLocalSHARuntimeObjects(t *testing.T) {
+	execution := fixedLocalPackedCompileOnlyTools(t)
+	fixedLocalSHARuntimePreflight(t, execution)
+	fixedLocalVectorRuntime(t, execution, false, fixedLocalSHARuntimeKernels(t))
+}
+
+func fixedLocalSHAFaultRuntime(t *testing.T, execution x86FloatCompareExecution, execute bool) {
+	t.Helper()
+	var source, declarations, prototypes, originals, rows strings.Builder
+	declarations.WriteString("package shafault\n")
+	count := 0
+	for _, family := range x86SHAOracleInputs {
+		for _, dead := range []bool{false, true} {
+			name := fmt.Sprintf("F%d", count)
+			count++
+			operation := x86SHAOracleRow(family.name, "(DI)", "X2", 3)
+			store, nativeStore := "", ""
+			if !dead {
+				store = "MOVQ out+8(FP),SI\nMOVOU X2,(SI)\n"
+				nativeStore = "MOVOU X2,(SI)\n"
+			}
+			initialize := "PXOR X0,X0\nPXOR X2,X2\n"
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),DI\n%s%s\n%sRET\n", name, initialize, operation, store)
+			fmt.Fprintf(&declarations, "func %s(p *[16]byte,out *[16]byte)\n", name)
+			original := "Original" + name
+			for _, symbol := range []string{name, original} {
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint8_t*);\n", symbol)
+			}
+			actual := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+initialize+operation+"\n"+nativeStore+"RET\n")
+			var encoded []string
+			for _, value := range actual {
+				encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+			}
+			symbol := original
+			if strings.Contains(execution.triple, "apple") {
+				symbol = "_" + symbol
+			}
+			fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(encoded, ",")+"\n")
+			fmt.Fprintf(&rows, "{%s,%s,16,1},\n", name, original)
+		}
+	}
+	if count != 14 {
+		t.Fatal("complete SHA live/dead fault inventory changed", count)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir := x86NarrowOracleIR(t, source.String(), declarations.String(), execution.triple)
+	// Intel XED marks SHA m128 REQUIRES_ALIGNMENT, but original Go opcodes
+	// execute unaligned on some native CPUs. Observe both unaligned addresses
+	// independently per original opcode and require exact translated agreement.
+	// All other full-width/guard-page/dead-read expectations remain fixed; this
+	// does not relax the separate private-frame alignment proof or AES owner.
+	// https://github.com/intelxed/xed/blob/main/datafiles/sha/sha-isa.xed.txt
+	const alignment = `#define NATIVE_ALIGNMENT 0
+#define ALIGNMENT_OBSERVED(k,a,f) printf("sha alignment kernel%u address%u fault%d\n",k,a,f)
+`
+	driver := alignment + fmt.Sprintf(x86AESFaultC, prototypes.String(), originals.String(), rows.String())
+	driver = strings.ReplaceAll(driver, "aes live/dead", "sha live/dead")
+	driver = strings.ReplaceAll(driver, "AES kernel", "SHA kernel")
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input := ir
+			if level == "-O2" {
+				input = x86DwordProductIROptimize(t, ir)
+			}
+			if !execute {
+				execution.compileLLVM(t, "sha-fault", input, driver, level)
+				return
+			}
+			output := execution.compileAndRunLLVM(t, "sha-fault", input, driver, level)
+			want := fmt.Sprintf("sha live/dead kernels %d exact fault outcomes %d tripwires 4 failures 0\n", count, count*18)
+			if !strings.HasSuffix(string(output), want) || strings.Count(string(output), "sha alignment kernel") != count*2 {
+				t.Fatal("original SHA live/dead m128 fault comparison", string(output))
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+func TestGoAMD64SHAFaultRuntimeObjects(t *testing.T) {
+	fixedLocalSHAFaultRuntime(t, fixedLocalPackedCompileOnlyTools(t), false)
+}
diff --git a/amd64_shuffle_blocks_forms.go b/amd64_shuffle_blocks_forms.go
new file mode 100644
index 000000000..c19e4ede8
--- /dev/null
+++ b/amd64_shuffle_blocks_forms.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var amd64Shuffle128BitBlockLaneBits = map[string]int{
+	"VSHUFF32X4": 32,
+	"VSHUFI32X4": 32,
+	"VSHUFF64X2": 64,
+	"VSHUFI64X2": 64,
+}
+
+type x86Shuffle128BitBlocksForm struct {
+	x86PackedBinaryForm
+	laneBits  int
+	immediate uint8
+}
+
+func x86Shuffle128BitBlocksProperties(op Op, ins Instr, arch string) (x86Shuffle128BitBlocksForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := amd64Shuffle128BitBlockLaneBits[base]
+	f := x86Shuffle128BitBlocksForm{laneBits: bits}
+	if !known {
+		return f, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		len(ins.Args) != 4 && len(ins.Args) != 5 || arch == "386" && (!ins.x86Encoded || len(ins.Args) == 5) {
+		return f, true, fmt.Errorf("%s %s has an unbound dispatch or operand count", arch, op)
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || !amd64UnsignedImmediate(immediate, 8) {
+		return f, true, fmt.Errorf("%s requires its unsigned-byte selector", op)
+	}
+	local := ins
+	local.Op, local.Args = op, ins.Args[1:]
+	form, err := x86ConflictFunnelOperandGrammar(local, arch,
+		x86PackedBinarySpec{encoding: x86PackedLogicalEVEX, broadcastBytes: bits / 8, zeroing: true}, false)
+	form.first++
+	form.second++
+	form.destination++
+	if form.mask >= 0 {
+		form.mask++
+	}
+	if form.memory >= 0 {
+		form.memory++
+	}
+	f.x86PackedBinaryForm, f.immediate = form, uint8(immediate.Imm)
+	if err == nil && form.byteWidth != 32 && form.byteWidth != 64 {
+		err = fmt.Errorf("%s requires a Y or Z carrier", op)
+	}
+	return f, true, err
+}
+
+func x86TypedShuffle128BitBlocksByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86Shuffle128BitBlocksProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedFixedVectorInputs(ins, form.x86PackedBinaryForm, false), true, nil
+}
diff --git a/amd64_signed_integer_scalar_float.go b/amd64_signed_integer_scalar_float.go
new file mode 100644
index 000000000..b16fd7250
--- /dev/null
+++ b/amd64_signed_integer_scalar_float.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86SignedIntegerFloatSpec struct {
+	sourceBits, resultBits int
+	legacy, rounding       bool
+}
+
+// Go's complete yxcvlf/yxcvqf and signed _yvcvtsi2sdl family. The
+// unsigned, packed, and float-to-integer families have separate contracts.
+var x86SignedIntegerFloatSpecs = map[Op]x86SignedIntegerFloatSpec{
+	"CVTSL2SS": {32, 32, true, false}, "CVTSL2SD": {32, 64, true, false},
+	"CVTSQ2SS": {64, 32, true, false}, "CVTSQ2SD": {64, 64, true, false},
+	"VCVTSI2SSL": {32, 32, false, true}, "VCVTSI2SDL": {32, 64, false, false},
+	"VCVTSI2SSQ": {64, 32, false, true}, "VCVTSI2SDQ": {64, 64, false, true},
+}
+
+type x86SignedIntegerFloatForm struct {
+	spec                                   x86SignedIntegerFloatSpec
+	sourceBits, upper, destination, memory int
+	rounding                               string
+}
+
+func x86SignedIntegerFloatProperties(ins Instr, goarch string) (x86SignedIntegerFloatForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86SignedIntegerFloatSpecs[Op(base)]
+	if !recognized {
+		return x86SignedIntegerFloatForm{}, false, nil
+	}
+	return x86IntegerScalarFloatOperandProperties(ins, goarch, spec)
+}
+
+// The signed and unsigned families share operand axes, not arithmetic,
+// native generation or source/caller permissions.
+func x86IntegerScalarFloatOperandProperties(ins Instr, goarch string, spec x86SignedIntegerFloatSpec) (x86SignedIntegerFloatForm, bool, error) {
+	_, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	f := x86SignedIntegerFloatForm{spec: spec, sourceBits: spec.sourceBits, upper: 1, destination: len(ins.Args) - 1, memory: -1}
+	fail := func() (x86SignedIntegerFloatForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s operands/suffix outside Go integer-to-scalar-float grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" {
+		return fail()
+	}
+	if spec.legacy {
+		if dotted || len(ins.Args) != 2 || goarch == "386" && spec.sourceBits == 64 {
+			return fail()
+		}
+		f.upper = f.destination
+	} else {
+		if len(ins.Args) != 3 || dotted && suffix == "" {
+			return fail()
+		}
+		if suffix != "" {
+			if !spec.rounding || ins.Args[0].Kind != OpReg {
+				return fail()
+			}
+			switch suffix {
+			case "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE":
+				f.rounding = suffix
+			default:
+				return fail()
+			}
+		}
+		// Intel's VEX.W1/EVEX.W1 is ignored outside 64-bit mode.
+		if goarch == "386" {
+			f.sourceBits = 32
+		}
+	}
+	for _, index := range []int{f.upper, f.destination} {
+		arg := ins.Args[index]
+		n, valid := amd64ParseXReg(arg.Reg)
+		if arg.Kind != OpReg || !valid || spec.legacy && n >= 16 {
+			return fail()
+		}
+		if goarch == "386" && n >= 8 {
+			return f, true, fmt.Errorf("%w: %s mode32 cannot address physical X%d even when Go emits its named VEX/EVEX form", ErrProbeNeedsContext, ins.Op, n)
+		}
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		if !(&amd64Ctx{goarch: goarch}).isGoYrlRegister(source) {
+			return fail()
+		}
+	} else if isAMD64MemoryOperand(source) {
+		if source.Kind == OpSym {
+			text := strings.TrimSpace(source.Sym)
+			_, absolute := parseInt(text)
+			if strings.HasPrefix(text, "$") || !strings.HasSuffix(text, "(SB)") && absolute != nil {
+				return fail()
+			}
+		}
+		if source.Kind == OpMem {
+			m := source.Mem
+			if m.Off != int64(int32(m.Off)) && (goarch != "386" || m.Off != int64(uint32(m.Off))) ||
+				!x86MemoryRegistersValidForArch(m, goarch) || m.Index != "" &&
+				(m.Index == SP || m.Scale != 1 && m.Scale != 2 && m.Scale != 4 && m.Scale != 8) {
+				return fail()
+			}
+		}
+		f.memory = 0
+	} else {
+		return fail()
+	}
+	return f, true, nil
+}
+
+func (c *amd64Ctx) lowerSignedIntegerScalarFloat(op Op, ins Instr) (bool, bool, error) {
+	if ins.Op == "" {
+		ins.Op = op
+	} else if !strings.EqualFold(string(ins.Op), string(op)) {
+		base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+		if _, known := x86SignedIntegerFloatSpecs[Op(base)]; known {
+			return true, false, fmt.Errorf("signed scalar conversion helper opcode %s conflicts with instruction %s", op, ins.Op)
+		}
+		return false, false, nil
+	}
+	f, known, err := x86SignedIntegerFloatProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if ins.Args[0].Kind == OpFP {
+		if err := c.validateFPVectorSpan(ins.Args[0].FPOffset, f.sourceBits/8); err != nil {
+			return true, false, fmt.Errorf("%w: signed conversion FP source: %v", ErrProbeNeedsContext, err)
+		}
+	}
+	integer, err := c.loadSignedIntegerFloatSource(ins.Args[0], f.sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	typ := amd64IntegerTypeForBits(f.sourceBits)
+	floatType := "float"
+	if f.spec.resultBits == 64 {
+		floatType = "double"
+	}
+	var low string
+	if f.rounding == "" {
+		converted, bits := c.newTmp(), c.newTmp()
+		if c.goarch == "386" {
+			// LLVM 22's default i386 constrained conversion uses x87 and its
+			// control word, not the source instruction's MXCSR. Use a private
+			// scalar SSE result; the virtual upper lanes are handled below.
+			// W1 is ignored in mode32, so even nominal Q forms consume i32.
+			mnemonic := "cvtsi2ssl"
+			if f.spec.resultBits == 64 {
+				mnemonic = "cvtsi2sdl"
+			}
+			fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, \"=x,r\"(i32 %s)\n", converted, floatType, mnemonic+" $1, $0", integer)
+		} else {
+			// Unlike plain sitofp, this cannot fold constant inputs using
+			// default rounding or discard the real MXCSR precision exception.
+			// LDMXCSR/STMXCSR operate on that same hardware state, not a shadow.
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.experimental.constrained.sitofp.f%d.i%d(%s %s, metadata !\"round.dynamic\", metadata !\"fpexcept.strict\")\n", converted, floatType, f.spec.resultBits, f.sourceBits, typ, integer)
+		}
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to i%d\n", bits, floatType, converted, f.spec.resultBits)
+		low = "%" + bits
+	} else {
+		// Widen the integer work representation to contain double's 53-bit
+		// significand even for mode32 WIG forms. No floating operation is
+		// introduced: embedded SAE must not change ambient sticky flags.
+		if f.sourceBits == 32 {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", wide, integer)
+			integer = "%" + wide
+		}
+		low = c.emitRoundedScalarIntegerToFloatBits(integer, amd64ScalarIntegerFloatSpec{sourceBits: 64, resultBits: f.spec.resultBits}, f.rounding)
+	}
+	baseBytes, err := c.loadX(ins.Args[f.upper].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	base := c.bitcastVectorBytesToIntegerLanes(16, 128/f.spec.resultBits, f.spec.resultBits, baseBytes)
+	if f.spec.legacy {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to %s\n", value, f.spec.resultBits, low, floatType)
+		return true, false, c.storeLegacyScalarMoveRegister(ins.Args[f.destination].Reg, "%"+value, f.spec.resultBits, true)
+	}
+	return true, false, c.storeScalarMoveRegister(ins.Args[f.destination].Reg, f.spec.resultBits, low, base, "", false)
+}
+
+func (c *amd64Ctx) loadSignedIntegerFloatSource(arg Operand, bits int) (string, error) {
+	if arg.Kind == OpReg {
+		return c.evalIntSized(arg, amd64IntegerTypeForBits(bits))
+	}
+	if arg.Kind == OpFP {
+		bytes, err := c.loadFPVectorBytes(arg.FPOffset, bits/8)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to i%d\n", value, bits/8, bytes, bits)
+		return "%" + value, nil
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(arg)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	// Preserve the original native access/fault even if all result bytes
+	// are subsequently overwritten; there is no suppressing mask form.
+	fmt.Fprintf(c.b, "  %%%s = load volatile i%d, %s %s, align 1\n", value, bits, pointerType, pointer)
+	return "%" + value, nil
+}
diff --git a/amd64_signed_integer_scalar_float_forms_test.go b/amd64_signed_integer_scalar_float_forms_test.go
new file mode 100644
index 000000000..0122daaf7
--- /dev/null
+++ b/amd64_signed_integer_scalar_float_forms_test.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86SignedIntegerFloatRows(arch string) []string {
+	var rows []string
+	for _, bits := range []string{"L", "Q"} {
+		for _, lane := range []string{"SS", "SD"} {
+			if arch != "386" || bits == "L" {
+				for _, source := range []string{"AX", "8(BX)", "(BX)(SI*4)"} {
+					rows = append(rows, "CVTS"+bits+"2"+lane+" "+source+",X1")
+				}
+			}
+			op := "VCVTSI2" + lane + bits
+			for _, source := range []string{"AX", "8(BX)", "(BX)(SI*4)"} {
+				rows = append(rows, op+" "+source+",X0,X1")
+			}
+			if lane != "SD" || bits != "L" {
+				for _, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					rows = append(rows, op+"."+suffix+" AX,X0,X1")
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86SignedIntegerScalarFloatCompleteGoTablesAndObjects(t *testing.T) {
+	if len(x86SignedIntegerFloatSpecs) != 8 {
+		t.Fatal("incomplete signed family")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + strings.Join(x86SignedIntegerFloatRows(target.arch), "\n") + "\nRET\n"
+			if target.arch == "amd64" {
+				source = strings.Replace(source, "\nRET", "\nVCVTSI2SSL R15,X29,X30\nVCVTSI2SDQ.RU_SAE R8,X31,X31\nCVTSL2SS AX,X15\nRET", 1)
+			}
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"f": {Ret: Void}}}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				var ir string
+				var err error
+				if api == "Translate" {
+					ir, err = Translate(file, opt)
+				} else {
+					ir, err = func() (string, error) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						var module llvm.Module
+						var moduleErr error
+						if api == "TranslateModule" {
+							module, moduleErr = TranslateModule(file, opt)
+						} else {
+							module, moduleErr = TranslateModuleInContext(ctx, file, opt)
+						}
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						if moduleErr != nil {
+							return "", moduleErr
+						}
+						return module.String(), nil
+					}()
+				}
+				if err != nil {
+					t.Fatalf("%s: %v", api, err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc required")
+				}
+				compileLLVMToObject(t, llc, target.triple, api+".ll", api+".o", ir)
+			}
+		})
+	}
+}
+
+func TestX86SignedIntegerScalarFloatActualGoPerOpcodeAttributes(t *testing.T) {
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // historical toolchain has its own actual assembler oracle below
+	}
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, row := range strings.Split(string(data), "{as: A") {
+		op := strings.SplitN(row, ",", 2)[0]
+		if !strings.HasPrefix(op, "VCVTSI2") {
+			continue
+		}
+		body := strings.SplitN(row, "\n\t}},", 2)[0]
+		spec, known := x86SignedIntegerFloatSpecs[Op(op)]
+		if !known || !strings.Contains(body, "_yvcvtsi2sdl") || strings.Contains(body, "Masking") || strings.Contains(body, "Zeroing") || strings.Contains(body, "Bcst") || strings.Contains(body, "SaeEnabled") ||
+			strings.Contains(body, "RoundingEnabled") != spec.rounding || !strings.Contains(body, fmt.Sprintf("evexN%d", spec.sourceBits/8)) {
+			t.Fatalf("actual Go per-opcode flags changed: %s", body)
+		}
+		count++
+	}
+	if count != 4 {
+		t.Fatalf("actual signed vector family contains %d opcodes", count)
+	}
+	data, err = os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{ACVTSL2SD, yxcvlf, Pf2, opBytes{0x2a}}", "{ACVTSL2SS, yxcvlf, Pf3, opBytes{0x2a}}",
+		"{ACVTSQ2SD, yxcvqf, Pw, opBytes{Pf2, 0x2a}}", "{ACVTSQ2SS, yxcvqf, Pw, opBytes{Pf3, 0x2a}}",
+	} {
+		if !strings.Contains(string(data), row) {
+			t.Fatalf("actual Go legacy row changed: %s", row)
+		}
+	}
+}
+
+func TestX86SignedIntegerScalarFloatMode32FeaturesFollowValidSource(t *testing.T) {
+	for _, row := range []struct{ instruction, want string }{
+		{"CVTSL2SS AX,X0", "+sse"},
+		{"CVTSL2SD AX,X0", "+sse2"},
+		{"VCVTSI2SSL AX,X0,X1", "+sse"},
+		{"VCVTSI2SDL AX,X0,X1", "+sse2"},
+		{"VCVTSI2SSQ AX,X0,X1", "+sse"},
+		{"VCVTSI2SDQ AX,X0,X1", "+sse2"},
+		{"VCVTSI2SSQ.RU_SAE AX,X0,X1", ""},
+		{"VCVTSI2SDQ.RD_SAE AX,X0,X1", ""},
+		{"CVTSQ2SS AX,X0", ""},
+		{"VCVTSI2SSL AX,X8,X1", ""},
+		{"VCVTSI2SSL.Z AX,X0,X1", ""},
+	} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "386", file.Funcs[0]); got != row.want {
+			t.Fatalf("%s mode32 features %q, want %q", row.instruction, got, row.want)
+		}
+		if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", file.Funcs[0]); got != "" {
+			t.Fatalf("%s changed amd64 ISA baseline: %q", row.instruction, got)
+		}
+	}
+}
+
+func TestX86SignedIntegerScalarFloatGrammarAndHelperIdentity(t *testing.T) {
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		args := "AX,X0"
+		if strings.HasPrefix(op, "V") {
+			args = "AX,X0,X1"
+		}
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+op+" "+args+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		for _, declared := range []Op{"", Op(op), "CVTSL2SS", "VCVTSI2SDQ", "BOGUS"} {
+			ins.Op = declared
+			c, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.String()
+			ok, _, err := c.lowerSignedIntegerScalarFloat(Op(op), ins)
+			if declared != "" && declared != Op(op) {
+				if !ok || err == nil || output.String() != before {
+					t.Fatalf("%s/%s conflict emitted IR: %v", op, declared, err)
+				}
+			} else if !ok || err != nil {
+				t.Fatalf("%s/%s valid identity failed: %v", op, declared, err)
+			}
+		}
+	}
+	for _, row := range []string{
+		"CVTSL2SS.RN_SAE AX,X0", "CVTSQ2SD AX,Y0", "CVTSL2SS $1,X0", "CVTSL2SD X0,X1", "CVTSL2SS AX,X16",
+		"VCVTSI2SSL AX,X0", "VCVTSI2SSL AX,Y0,X1", "VCVTSI2SSL AX,X0,K1,X1", "VCVTSI2SSL.Z AX,X0,X1",
+		"VCVTSI2SSL.SAE AX,X0,X1", "VCVTSI2SSL.BCST (BX),X0,X1", "VCVTSI2SDL.RN_SAE AX,X0,X1",
+		"VCVTSI2SSQ.RD_SAE (BX),X0,X1", "VCVTSI2SSL. AX,X0,X1", "VCVTSI2SSL X0,X1,X2",
+	} {
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		assertX86ScalarIntegerFloatRejected(t, "amd64", "x86_64-unknown-linux-gnu", row)
+	}
+	for _, row := range []string{"CVTSQ2SS AX,X0", "CVTSQ2SD AX,X0", "VCVTSI2SSL R8,X0,X1"} {
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		assertX86ScalarIntegerFloatRejected(t, "386", "i386-unknown-linux-gnu", row)
+	}
+	for _, row := range []string{"VCVTSI2SSL AX,X8,X1", "VCVTSI2SDQ.RU_SAE AX,X1,X31"} {
+		source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		file, _ := Parse(ArchAMD64, source)
+		if _, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("mode32 high named bank became physical success: %v", err)
+		}
+	}
+}
+
+func TestX86SignedIntegerScalarFloatFPSpanGrammarBeforeEmission(t *testing.T) {
+	for _, row := range []string{"CVTSL2SS value+0(FP),X0", "CVTSQ2SD value+0(FP),X0", "VCVTSI2SSL value+0(FP),X0,X1", "VCVTSI2SDQ value+0(FP),X0,X1"} {
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		f, _, _ := x86SignedIntegerFloatProperties(ins, "amd64")
+		for missing := -1; missing < f.sourceBits/8; missing++ {
+			sig := FuncSig{Args: make([]LLVMType, f.sourceBits/8), Ret: Void}
+			for i := range sig.Args {
+				sig.Args[i] = I8
+				if i != missing {
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i), Type: I8, Index: i, Field: -1})
+				}
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+			before := output.String()
+			known, _, err := ctx.lowerSignedIntegerScalarFloat(ins.Op, ins)
+			if !known || (err != nil) != (missing >= 0) || missing >= 0 && output.String() != before {
+				t.Fatalf("%s missing%d: %v", row, missing, err)
+			}
+		}
+	}
+	for _, row := range []string{"VCVTSI2SSL (AX)(SP*2),X0,X1", "CVTSL2SS 2147483648(BX),X0", "VCVTSI2SSQ $symbol(SB),X0,X1", "VCVTSI2SSL (AX)(SI*3),X0,X1"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			continue
+		}
+		ins := file.Funcs[0].Instrs[1]
+		ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+		before := output.String()
+		known, _, err := ctx.lowerSignedIntegerScalarFloat(ins.Op, ins)
+		if !known || err == nil || output.String() != before {
+			t.Fatalf("invalid source emitted IR: %s %v", row, err)
+		}
+	}
+}
diff --git a/amd64_signed_integer_scalar_float_go_oracle_test.go b/amd64_signed_integer_scalar_float_go_oracle_test.go
new file mode 100644
index 000000000..38d2b672a
--- /dev/null
+++ b/amd64_signed_integer_scalar_float_go_oracle_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86SignedIntegerFloatFPFixture(t *testing.T) (string, string, map[string]FuncSig) {
+	t.Helper()
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package oracle\n")
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		name := strings.ToLower(op)
+		fmt.Fprintf(&declarations, "func %s(a,b,c,d,e,f,g,h byte,csr uint32)(value uint64,flags uint32)\n", name)
+		args := "a+0(FP),X0"
+		if strings.HasPrefix(op, "V") {
+			args = "a+0(FP),X0,X1"
+		}
+		destination := "X0"
+		if strings.HasPrefix(op, "V") {
+			destination = "X1"
+		}
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$8-28\nSTMXCSR saved-4(SP)\nLDMXCSR csr+8(FP)\n%s %s\nMOVQ %s,AX\n", name, op, args, destination)
+		if strings.Contains(op, "SS") {
+			assembly.WriteString("MOVL AX,AX\n")
+		}
+		assembly.WriteString("MOVQ AX,value+16(FP)\nSTMXCSR flags+24(FP)\nLDMXCSR saved-4(SP)\nRET\n")
+	}
+	source := assembly.String()
+	pkg := mustGoPackage(t, "oracle", declarations.String())
+	sigs := map[string]FuncSig{}
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		name := strings.ToLower(op)
+		decl := pkg.Types.Scope().Lookup(name).(*types.Func)
+		sig, err := DeriveGoFuncABI0Signature(name, decl, "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(sig.Frame.Params) != 9 || sig.Frame.Results[0].Offset != 16 || sig.Frame.Results[1].Offset != 24 {
+			t.Fatalf("actual ABI0 parameter/result fields changed: %+v", sig.Frame)
+		}
+		sigs[name] = sig
+	}
+	return declarations.String(), source, sigs
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatOriginalGoRCAndFPFields(t *testing.T) {
+	_, _, _, _ = x86FloatAddSubRuntimeTools(t)
+	declarations, assembly, _ := x86SignedIntegerFloatFPFixture(t)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	var checks strings.Builder
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		sourceBits := 32
+		if strings.Contains(op, "Q") {
+			sourceBits = 64
+		}
+		resultBits := 32
+		if strings.Contains(op, "SD") {
+			resultBits = 64
+		}
+		fmt.Fprintf(&checks, `for _,input:=range inputs { for mode:=0;mode<4;mode++ { for _,control:=range controls {
+ csr:=control|uint32(mode)<<13
+ got,flags:=%s(byte(input),byte(input>>8),byte(input>>16),byte(input>>24),byte(input>>32),byte(input>>40),byte(input>>48),byte(input>>56),csr)
+ want,inexact:=rounded(input,%d,%d,mode);expectedFlags:=csr;if inexact{expectedFlags|=32}
+ if got!=want||flags!=expectedFlags{t.Fatalf("%s input=%%x mode=%%d got=%%x want=%%x csr=%%x want=%%x",input,mode,got,want,flags,expectedFlags)}
+ } } }
+`, strings.ToLower(op), sourceBits, resultBits, op)
+	}
+	const reference = `package oracle
+import("testing";"math";"math/big")
+func rounded(input uint64,sourceBits,resultBits,mode int)(uint64,bool){
+ value:=int64(input);if sourceBits==32{value=int64(int32(input))}
+ precision:=uint(24);if resultBits==64{precision=53}
+ modes:=[]big.RoundingMode{big.ToNearestEven,big.ToNegativeInf,big.ToPositiveInf,big.ToZero}
+ exact:=new(big.Int).SetInt64(value)
+ rounded:=new(big.Float).SetMode(modes[mode]).SetPrec(precision).SetInt(exact)
+ f,_:=rounded.Float64();bits:=math.Float64bits(f);if resultBits==32{bits=uint64(math.Float32bits(float32(f)))}
+ return bits,rounded.Acc()!=big.Exact
+}
+func TestActualGoSignedRCAndFP(t *testing.T){
+ inputs:=[]uint64{0,1,0xffffffffffffffff,0x80000000,0x7fffffff,0xffffffff80000000,0x8000000000000000,0x7fffffffffffffff,0x1000001,0xfffffffffeffffff,0x20000000000001,0xffdfffffffffffff,0x100000001}
+ for i:=uint64(0);i<256;i++{inputs=append(inputs,0xd31733a6287fbbc3*i+0x92c481352)}
+ controls:=[]uint32{0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0}
+`
+	test := reference + checks.String() + "}\n"
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module oracle\n\ngo 1.20\n", "oracle.go": declarations, "oracle_amd64.s": assembly, "oracle_test.go": test} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-count=1", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original Go signed conversion/RC/FP fields: %v\n%s", err, output)
+	}
+	t.Log("8 actual original Go opcodes x269 signed inputs x4 RC x6 DAZ/FTZ/sticky controls; genuine derived ABI0 FP fields")
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatTranslatedFPFields(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	_, source, sigs := x86SignedIntegerFloatFPFixture(t)
+	// The normal callable implementation has no incoming hidden native ABI.
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs, ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declarations, checks, wrappers strings.Builder
+	for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		sourceBits, resultBits := 32, 32
+		if strings.Contains(op, "Q") {
+			sourceBits = 64
+		}
+		if strings.Contains(op, "SD") {
+			resultBits = 64
+		}
+		name := strings.ToLower(op)
+		// LLVM's logical multi-result aggregate is not C's struct-return
+		// ABI (notably Win64's hidden sret pointer). Keep that call entirely
+		// inside LLVM, crossing into C only through scalar/pointer arguments.
+		fmt.Fprintf(&declarations, "extern void observe_%s(uint64_t*,uint32_t*,uint64_t,uint32_t);\n", name)
+		fmt.Fprintf(&wrappers, "define void @observe_%s(ptr %%value, ptr %%flags, i64 %%input, i32 %%csr) {\nentry:\n", name)
+		var arguments []string
+		for index := 0; index < 8; index++ {
+			fmt.Fprintf(&wrappers, "  %%shift%d = lshr i64 %%input, %d\n", index, index*8)
+			fmt.Fprintf(&wrappers, "  %%byte%d = trunc i64 %%shift%d to i8\n", index, index)
+			arguments = append(arguments, fmt.Sprintf("i8 %%byte%d", index))
+		}
+		arguments = append(arguments, "i32 %csr")
+		fmt.Fprintf(&wrappers, "  %%result = call {i64, i32} @%s(%s)\n", name, strings.Join(arguments, ", "))
+		wrappers.WriteString(`  %v = extractvalue {i64, i32} %result, 0
+  %f = extractvalue {i64, i32} %result, 1
+  store i64 %v, ptr %value
+  store i32 %f, ptr %flags
+  ret void
+}
+`)
+		fmt.Fprintf(&checks, `for(unsigned sample=0;sample<256;sample++)for(unsigned mode=0;mode<4;mode++){
+ uint64_t input=UINT64_C(0xd31733a6287fbbc3)*sample+UINT64_C(0x1000001);unsigned csr=0x9fc5|(mode<<13),before,after;
+ __asm__ volatile("stmxcsr %%0":"=m"(before));
+ uint64_t want=sse_convert(input,%d,%d,csr);unsigned wantCSR=sse_csr;
+ struct {uint64_t before,value,after;} result={UINT64_C(0x123456789abcdef),0,UINT64_C(0xfedcba987654321)};
+ struct {uint32_t before,value,after;} flags={0x12345678,0,0x87654321};
+ observe_%s(&result.value,&flags.value,input,csr);
+ __asm__ volatile("stmxcsr %%0":"=m"(after));
+ if(result.before!=UINT64_C(0x123456789abcdef)||result.after!=UINT64_C(0xfedcba987654321)||flags.before!=0x12345678||flags.after!=0x87654321)return 2;
+ if(result.value!=want||flags.value!=wantCSR||after!=before){fprintf(stderr,"FP %s input=%%llx got=%%llx want=%%llx flags=%%x want=%%x after=%%x before=%%x\n",(unsigned long long)input,(unsigned long long)result.value,(unsigned long long)want,flags.value,wantCSR,after,before);return 1;}
+}
+`, sourceBits, resultBits, name, name)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-conversion-fp", triple, x86SignedIntegerFloatOptimize(t, ir+wrappers.String()), x86SignedIntegerFloatSSEOracle+declarations.String()+"int main(void){"+checks.String()+"return 0;}\n", prefix)
+}
+
+func TestX86SignedIntegerScalarFloatMode32PreservesNativeMXCSRInstruction(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc/objdump required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		const source = "TEXT f(SB),4,$0-16\nCVTSL2SS integer+0(FP),X0\nCVTSL2SD integer+0(FP),X1\nVCVTSI2SSL integer+0(FP),X2,X3\nVCVTSI2SDL integer+0(FP),X2,X3\nVCVTSI2SSQ integer+0(FP),X2,X3\nVCVTSI2SDQ integer+0(FP),X2,X3\nMOVSS X0,single+4(FP)\nMOVSD X1,double+8(FP)\nRET\n"
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := mustGoPackage(t, "oracle", "package oracle\nfunc f(integer int32)(single float32,double float64)\n")
+		sig, err := DeriveGoFuncABI0Signature("f", pkg.Types.Scope().Lookup("f").(*types.Func), "386", types.SizesFor("gc", "386"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "386", TargetTriple: triple, Sigs: map[string]FuncSig{"f": sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		dir := t.TempDir()
+		input, object := filepath.Join(dir, "conversion.ll"), filepath.Join(dir, "conversion.o")
+		if err := os.WriteFile(input, []byte(x86SignedIntegerFloatOptimize(t, ir)), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, llc, "-mtriple="+triple, "-filetype=obj", input, "-o", object)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("mode32 object: %v\n%s", err, output)
+		}
+		ctx, cancel = runtimeOracleStageContext(t)
+		command = exec.CommandContext(ctx, objdump, "-d", object)
+		output, err = runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		if err != nil {
+			t.Fatalf("mode32 native decode: %v\n%s", err, output)
+		}
+		if strings.Count(string(output), "cvtsi2ss") != 3 || strings.Count(string(output), "cvtsi2sd") != 3 || strings.Contains(string(output), "fild") {
+			t.Fatalf("%s lost source SSE/MXCSR conversion to x87:\n%s", triple, output)
+		}
+		t.Logf("%s: original Go accepted all six mode32 default forms; optimized native object retains three signed32 SSE conversions per result width, no x87", triple)
+	}
+}
diff --git a/amd64_signed_integer_scalar_float_raw_test.go b/amd64_signed_integer_scalar_float_raw_test.go
new file mode 100644
index 000000000..236f2a178
--- /dev/null
+++ b/amd64_signed_integer_scalar_float_raw_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestX86SignedIntegerScalarFloatMode32WIGActualGoAndRaw(t *testing.T) {
+	for _, row := range []struct {
+		source string
+		code   []byte
+		op     Op
+	}{
+		{"VCVTSI2SSQ AX,X0,X1", []byte{0xc4, 0xe1, 0xfa, 0x2a, 0xc8}, "VCVTSI2SSQ"},
+		{"VCVTSI2SDQ AX,X0,X1", []byte{0xc4, 0xe1, 0xfb, 0x2a, 0xc8}, "VCVTSI2SDQ"},
+	} {
+		listing := x86InsertExtractGoListing(t, "386", "TEXT f(SB),4,$0-0\n"+row.source+"\nRET\n")
+		var actual []byte
+		for _, line := range strings.Split(string(listing), "\n") {
+			actual = append(actual, x86InsertExtractListedBytes(line)...)
+		}
+		if !bytes.Equal(actual, append(append([]byte{}, row.code...), 0xc3)) {
+			t.Fatalf("actual Go mode32 W1 object changed: %x", actual)
+		}
+		ins, length, recognized, err := decodedX86ScalarIntegerFloatInstruction(row.code, 32)
+		if !recognized || err != nil || length != len(row.code) || ins.Op != row.op {
+			t.Fatalf("mode32 raw object identity: %+v/%v", ins, err)
+		}
+		f, recognized, err := x86SignedIntegerFloatProperties(ins, "386")
+		if !recognized || err != nil || f.sourceBits != 32 {
+			t.Fatalf("WIG did not preserve physical signed32 input: %+v/%v", f, err)
+		}
+	}
+	// EVEX compressed displacement uses the *physical* W0 tuple in mode32,
+	// not the W1 tuple obtained by decoding the same bytes as 64-bit code.
+	code := []byte{0x62, 0xf1, 0xff, 0x08, 0x2a, 0x48, 0x02}
+	for _, mode := range []int{32, 64} {
+		ins, _, known, err := decodedX86ScalarIntegerFloatInstruction(code, mode)
+		want := int64(16)
+		if mode == 32 {
+			want = 8
+		}
+		if !known || err != nil || ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Off != want {
+			t.Fatalf("EVEX mode%d displacement: %+v/%v want%d", mode, ins, err, want)
+		}
+	}
+}
diff --git a/amd64_signed_integer_scalar_float_runtime_test.go b/amd64_signed_integer_scalar_float_runtime_test.go
new file mode 100644
index 000000000..9ae3b008a
--- /dev/null
+++ b/amd64_signed_integer_scalar_float_runtime_test.go
@@ -0,0 +1,263 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86SignedIntegerFloatOptimize(t *testing.T, ir string) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatalf("LLVM22 O2 signed conversion: %v", err)
+	}
+	return module.String()
+}
+
+// Independent hardware SSE: no production map, LLVM conversion or language
+// cast computes the expected bits or exception flags. Save/restore prevents
+// each oracle sample from changing the tested caller's ambient control word.
+const x86SignedIntegerFloatSSEOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+static uint32_t sse_csr;
+__attribute__((noinline)) static uint64_t sse_convert(uint64_t input,int sourceBits,int resultBits,unsigned csr) {
+ unsigned saved;__asm__ volatile("stmxcsr %0":"=m"(saved));
+ __asm__ volatile("ldmxcsr %0"::"m"(csr):"memory");
+ uint64_t result=0;
+ if(resultBits==32) {
+  float value;
+  if(sourceBits==32){int32_t integer=(int32_t)input;__asm__ volatile("cvtsi2ssl %1,%0":"=x"(value):"r"(integer));}
+  else {int64_t integer=(int64_t)input;__asm__ volatile("cvtsi2ssq %1,%0":"=x"(value):"r"(integer));}
+  uint32_t bits;memcpy(&bits,&value,4);result=bits;
+ } else {
+  double value;
+  if(sourceBits==32){int32_t integer=(int32_t)input;__asm__ volatile("cvtsi2sdl %1,%0":"=x"(value):"r"(integer));}
+  else {int64_t integer=(int64_t)input;__asm__ volatile("cvtsi2sdq %1,%0":"=x"(value):"r"(integer));}
+  memcpy(&result,&value,8);
+ }
+ __asm__ volatile("stmxcsr %0":"=m"(sse_csr));
+ __asm__ volatile("ldmxcsr %0"::"m"(saved):"memory");return result;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatCompleteSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	rows := []string{}
+	for _, row := range x86SignedIntegerFloatRows("amd64") {
+		if strings.Contains(row, "(SI*") {
+			continue
+		}
+		row = strings.Replace(row, "AX,", "R8,", 1)
+		row = strings.Replace(row, "8(BX)", "128(BX)", 1)
+		rows = append(rows, row)
+		if strings.HasPrefix(row, "V") && !strings.Contains(row, "(BX)") {
+			rows = append(rows, strings.Replace(row, "X0,X1", "X0,X0", 1), strings.Replace(row, "X0,X1", "X1,X0", 1))
+		}
+	}
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range rows {
+		file, _ := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		ins := file.Funcs[0].Instrs[1]
+		f, _, err := x86SignedIntegerFloatProperties(ins, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		mode := -1
+		for i, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+			if f.rounding == suffix {
+				mode = i
+			}
+		}
+		name := fmt.Sprintf("convert%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-28\nMOVQ out+0(FP),AX\nMOVQ value+8(FP),R8\nMOVQ pass+16(FP),BX\nLDMXCSR csr+24(FP)\nVMOVUPS (BX),Z0\nVMOVUPS 64(BX),Z1\nSTC\n%s\nVMOVUPS %s,(AX)\nSTMXCSR 64(AX)\nSETCS 68(AX)\nRET\n", name, row, x86CallerVectorRoot(ins.Args[f.destination].Reg))
+		sigs[name] = FuncSig{Args: []LLVMType{Ptr, I64, Ptr, I32}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I32, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,uint64_t,const void*,uint32_t);\n", name)
+		passBank := 0
+		if ins.Args[f.upper].Reg == "X1" {
+			passBank = 64
+		}
+		fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d,%d,%d))return %d;\n", name, f.sourceBits, f.spec.resultBits, x86FloatAddSubBoolInt(f.spec.legacy), passBank, mode, index+10)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const check = `typedef void(*convert)(void*,uint64_t,const void*,uint32_t);
+__attribute__((noinline)) static int check(convert fn,int sourceBits,int resultBits,int legacy,int bank,int mode) {
+ const uint64_t values[]={0,1,UINT64_MAX,2,UINT64_C(0xffffffff80000000),UINT64_C(0x7fffffff),
+ UINT64_C(0x80000000),UINT64_C(0x100000001),UINT64_C(0x1000001),UINT64_C(0xfffffffffeffffff),
+ UINT64_C(0x8000000000000000),UINT64_C(0x7fffffffffffffff),UINT64_C(0x20000000000001),
+ UINT64_C(0xffdfffffffffffff),UINT64_C(0x4000002000000001)};
+ const uint32_t controls[]={0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+ for(unsigned sample=0;sample<256;sample++)for(unsigned ambient=0;ambient<4;ambient++)for(unsigned c=0;c<6;c++) {
+  uint64_t input=sample<15?values[sample]:UINT64_C(0xd31733a6287fbbc3)*sample+UINT64_C(0x92c481352)
+   +((uint64_t)sample<<52);
+  uint8_t pass[138],copy[138],out[71],want[64];
+  memset(pass,0xa7,sizeof(pass));for(unsigned i=0;i<128;i++)pass[i+1]=(uint8_t)(i*37+sample*71);
+  memcpy(pass+129,&input,8);memcpy(copy,pass,sizeof(pass));memset(out,0xc3,sizeof(out));memset(want,0,sizeof(want));
+  unsigned csr=controls[c]|(ambient<<13),operationCSR=(csr&~0x6000u)|((mode<0?ambient:(unsigned)mode)<<13);
+  uint64_t result=sse_convert(input,sourceBits,resultBits,operationCSR);
+  unsigned expectedCSR=mode<0?sse_csr:csr;
+  memcpy(want,pass+1+bank,legacy?64:16);memcpy(want,&result,resultBits/8);
+  fn(out+1,input,pass+1,csr);
+  unsigned after,observed;__asm__ volatile("stmxcsr %0":"=m"(after));memcpy(&observed,out+65,4);
+  if(memcmp(out+1,want,64)||observed!=expectedCSR||after!=expectedCSR) {
+   fprintf(stderr,"signed source/result/legacy/bank/mode=%d/%d/%d/%d/%d input=%llx ambient=%u csr=%x observed=%x want=%x\n",
+    sourceBits,resultBits,legacy,bank,mode,(unsigned long long)input,ambient,csr,observed,expectedCSR);return 1;
+  }
+  if(out[0]!=0xc3||out[69]!=1||out[70]!=0xc3||memcmp(pass,copy,sizeof(pass)))return 2;
+ }
+ return 0;
+}
+`
+	main := x86SignedIntegerFloatSSEOracle + check + declarations.String() + "int main(void){\n" + checks.String() + "unsigned csr=0x1f80;__asm__ volatile(\"ldmxcsr %0\"::\"m\"(csr));return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-integer-float-full", triple, x86SignedIntegerFloatOptimize(t, ir), main, prefix)
+	t.Logf("%d original opcode/rounding/native-memory/alias programs x6144 signed/MXCSR/canary samples", len(rows))
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatNativeReadExtentAndPrecision(t *testing.T) {
+	x86SignedIntegerScalarFloatFaultFixture(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatNativeLinuxPrecisionSignal(t *testing.T) {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Skip("strict native Linux/amd64 precision-signal counterpart; Rosetta observation is not hardware-trap proof")
+	}
+	x86SignedIntegerScalarFloatFaultFixture(t, true)
+}
+
+func x86SignedIntegerScalarFloatFaultFixture(t *testing.T, requireTrap bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, rows strings.Builder
+	sigs := map[string]FuncSig{}
+	var inexact []bool
+	for index, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+		name, args := fmt.Sprintf("read%d", index), "(BX),X0"
+		if strings.HasPrefix(op, "V") {
+			args = "(BX),X0,X1"
+		}
+		// All results are dead: native reads and precision traps must remain
+		// observable even after the LLVM IR and backend optimize the call.
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ input+0(FP),BX\n%s %s\nRET\n", name, op, args)
+		sigs[name] = FuncSig{Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+		fmt.Fprintf(&declarations, "extern void %s(const void*);\n", name)
+		width, resultBits := 4, 32
+		if strings.Contains(op, "Q") {
+			width = 8
+		}
+		if strings.Contains(op, "SD") {
+			resultBits = 64
+		}
+		fmt.Fprintf(&rows, "{%s, %d, %d},\n", name, width, resultBits)
+		inexact = append(inexact, width == 8 || resultBits == 32)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := x86MemoryFaultSupportC + declarations.String() + `
+static const struct {
+    void (*run)(const void *);
+    unsigned width, bits;
+} cases[] = {
+` + rows.String() + "};\n" + x86SignedIntegerFloatFaultMainC
+	executable := execution.compileLLVM(t, "signed-native-fault", x86SignedIntegerFloatOptimize(t, ir), driver, "-O2")
+	for row, losesPrecision := range inexact {
+		for probe := 0; probe < 4; probe++ {
+			original := x86ObserveMemoryFault(t, execution, executable, row, probe, 1)
+			switch probe {
+			case 0, 1:
+				if original != "segv" && original != "bus" {
+					t.Fatalf("row %d probe %d: original SSE did not read its full source: %s", row, probe, original)
+				}
+			case 2:
+				if requireTrap && losesPrecision {
+					if original != "fpe" {
+						t.Fatalf("row %d: original SSE missing required native precision trap: %s", row, original)
+					}
+				} else if original != "return" && (!losesPrecision || original != "fpe") {
+					t.Fatalf("row %d: unexpected original SSE precision outcome: %s", row, original)
+				}
+			case 3:
+				if original != "return" {
+					t.Fatalf("row %d: exact-width accessible source faulted: %s", row, original)
+				}
+			}
+			if got := x86ObserveMemoryFault(t, execution, executable, row, probe, 0); got != original {
+				t.Fatalf("row %d probe %d: translated %s, original SSE %s", row, probe, got, original)
+			}
+		}
+	}
+	t.Log("8 conversion kernels: original SSE and optimized LLVM agree on NULL, partial/full reads and unmasked precision")
+}
+
+const x86SignedIntegerFloatFaultMainC = `
+int main(int argc, char **argv) {
+    if (argc != 4) return 80;
+    unsigned row = (unsigned)atoi(argv[1]);
+    unsigned probe = (unsigned)atoi(argv[2]);
+    unsigned original = (unsigned)atoi(argv[3]);
+    if (row >= sizeof(cases)/sizeof(cases[0]) || probe > 3 || original > 1) return 80;
+    int setup = memory_fault_setup(0);
+    if (setup) return setup;
+    uint64_t inexact = UINT64_C(0x20000001000001);
+    const void *input = NULL;
+    if (probe == 1) input = guard + page - cases[row].width / 2;
+    if (probe == 2) input = &inexact;
+    if (probe == 3) input = guard + page - cases[row].width;
+    unsigned csr = probe == 2 ? 0x0f80 : 0x1f80, saved;
+
+    printf("memory enter %u %u %u\n", row, probe, original);
+    if (fflush(stdout)) return 83;
+    __asm__ volatile("stmxcsr %0" : "=m"(saved));
+    __asm__ volatile("ldmxcsr %0" :: "m"(csr) : "memory");
+    if (!original) {
+        cases[row].run(input);
+    } else if (cases[row].bits == 32) {
+        if (cases[row].width == 4) {
+            __asm__ volatile("cvtsi2ssl (%0),%%xmm0" :: "r"(input) : "xmm0", "memory");
+        } else {
+            __asm__ volatile("cvtsi2ssq (%0),%%xmm0" :: "r"(input) : "xmm0", "memory");
+        }
+    } else {
+        if (cases[row].width == 4) {
+            __asm__ volatile("cvtsi2sdl (%0),%%xmm0" :: "r"(input) : "xmm0", "memory");
+        } else {
+            __asm__ volatile("cvtsi2sdq (%0),%%xmm0" :: "r"(input) : "xmm0", "memory");
+        }
+    }
+    __asm__ volatile("ldmxcsr %0" :: "m"(saved) : "memory");
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout) ? 85 : 0;
+}
+`
diff --git a/amd64_signed_integer_scalar_float_test.go b/amd64_signed_integer_scalar_float_test.go
new file mode 100644
index 000000000..4e14ab429
--- /dev/null
+++ b/amd64_signed_integer_scalar_float_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86SignedIntegerScalarFloatOriginalCaller(t *testing.T) {
+	const body = "VMOVUPS (DI),X0\nVCVTSI2SSL AX,X0,X1\nVMOVSS X1,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedIntegerScalarFloatAmbientConstant(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	const source = "TEXT convert(SB),4,$0-8\nMOVQ out+0(FP),AX\nMOVL $16777217,CX\nCVTSL2SS CX,X0\nMOVSS X0,(AX)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{"convert": sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <stdio.h>
+extern void convert(uint32_t*);
+int main(void) {
+ uint32_t out=0,csr=0x5f80,observed,reference;
+ int32_t value=16777217;
+ __asm__ volatile("ldmxcsr %0;cvtsi2ssl %1,%%xmm0;movd %%xmm0,%2;stmxcsr %3"
+  :"=m"(csr),"+r"(value),"=r"(reference),"=m"(observed):"0"(csr):"xmm0","memory");
+ if(reference!=UINT32_C(0x4b800001)||observed!=(csr|32))return 2;
+ __asm__ volatile("ldmxcsr %0"::"m"(csr):"memory");
+ convert(&out);
+ __asm__ volatile("stmxcsr %0":"=m"(observed)::"memory");
+ if(out!=reference||observed!=(csr|32)){
+  fprintf(stderr,"ambient conversion bits=%x want=%x MXCSR=%x want=%x\n",out,reference,observed,csr|32);
+  return 1;
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-integer-scalar-float-constant", triple, x86SignedIntegerFloatOptimize(t, ir), reference, prefix)
+}
diff --git a/amd64_signed_packed_integer_float.go b/amd64_signed_packed_integer_float.go
new file mode 100644
index 000000000..a8885596a
--- /dev/null
+++ b/amd64_signed_packed_integer_float.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86SignedPackedFloatSpec struct {
+	bits   int
+	legacy bool
+}
+
+// The complete signed dword-to-floating Go namespace. Scalar signed and
+// unsigned packed conversions have different grammars and are not included.
+var x86SignedPackedFloatSpecs = map[Op]x86SignedPackedFloatSpec{
+	"CVTPL2PS": {bits: 32, legacy: true}, "CVTPL2PD": {bits: 64, legacy: true},
+	"VCVTDQ2PS": {bits: 32}, "VCVTDQ2PD": {bits: 64},
+}
+
+type x86SignedPackedFloatForm struct {
+	spec                          x86SignedPackedFloatSpec
+	byteWidth, sourceBytes        int
+	inputBytes, memoryBytes       int
+	destination, memory, mask     int
+	mmx, evex, broadcast, zeroing bool
+	rounding                      string
+}
+
+// Shape and physical encoding only: this does not grant caller memory access,
+// numeric initialization, contiguous FP backing, or an executable host ISA.
+func x86SignedPackedFloatProperties(ins Instr, goarch string) (x86SignedPackedFloatForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, recognized := x86SignedPackedFloatSpecs[Op(base)]
+	if !recognized {
+		return x86SignedPackedFloatForm{}, false, nil
+	}
+	f := x86SignedPackedFloatForm{
+		spec: spec, destination: len(ins.Args) - 1, memory: -1, mask: -1,
+		mmx: ins.x86MMXSourceConversion,
+	}
+	fail := func() (x86SignedPackedFloatForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go signed packed dword-to-float grammar: %q", goarch, ins.Op, ins.Raw)
+	}
+	if goarch != "amd64" && goarch != "386" || len(ins.Args) != 2 && len(ins.Args) != 3 || f.mmx && !spec.legacy {
+		return fail()
+	}
+	suffix, err := parseAMD64PackedDoubleDwordSuffix(strings.ToUpper(string(ins.Op)), base)
+	if err != nil || suffix.sae || spec.legacy && (len(ins.Args) != 2 || strings.ToUpper(string(ins.Op)) != base) {
+		return fail()
+	}
+	f.broadcast, f.zeroing, f.rounding = suffix.broadcast, suffix.zeroing, suffix.rounding
+	if len(ins.Args) == 3 {
+		if !amd64NonzeroKOperand(ins.Args[1]) {
+			return fail()
+		}
+		f.mask = 1
+	} else if f.zeroing {
+		return fail()
+	}
+	destination := ins.Args[f.destination]
+	f.byteWidth = amd64VectorByteWidth(destination.Reg)
+	if destination.Kind != OpReg || !amd64EVEXVectorRegister(destination, f.byteWidth) ||
+		spec.legacy && (!amd64VEXVectorRegister(destination, 16) || goarch == "386" && !amd64Mode32VectorOperand(destination)) {
+		return fail()
+	}
+	f.inputBytes = f.byteWidth * 32 / spec.bits
+	f.sourceBytes = f.byteWidth
+	if spec.bits == 64 {
+		f.sourceBytes = 16
+		if f.byteWidth == 64 {
+			f.sourceBytes = 32
+		}
+	}
+	if f.mmx {
+		f.inputBytes, f.sourceBytes = 8, 8
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		_, mmxRegister := amd64ParseMReg(source.Reg)
+		f.mmx = f.mmx || mmxRegister
+		// Go's ycover admits these GP spellings to Ymm and emits an
+		// MMX opcode, not an integer GP conversion. Never read their GP
+		// value as though it were the physical MMX input.
+		f.mmx = f.mmx || spec.legacy && isAMD64YrlRegister(source.Reg) &&
+			(goarch != "386" || !amd64IsExtendedGPRegister(source.Reg))
+		if f.mmx {
+			if !spec.legacy {
+				return fail()
+			}
+			f.inputBytes, f.sourceBytes = 8, 8
+		} else if !amd64EVEXVectorRegister(source, f.sourceBytes) || spec.legacy &&
+			(!amd64VEXVectorRegister(source, 16) || goarch == "386" && !amd64Mode32VectorOperand(source)) {
+			return fail()
+		}
+	} else if isAMD64MemoryOperand(source) {
+		if !x86SignedPackedFloatMemoryOperand(source, goarch) {
+			return fail()
+		}
+		f.memory, f.memoryBytes = 0, f.inputBytes
+	} else {
+		return fail()
+	}
+	if f.broadcast {
+		if spec.legacy || f.memory < 0 {
+			return fail()
+		}
+		f.memoryBytes = 4
+	}
+	if f.rounding != "" && (spec.bits != 32 || spec.legacy || f.byteWidth != 64 || source.Kind != OpReg) {
+		return fail()
+	}
+	if !spec.legacy {
+		f.evex = ins.x86PackedNumericEVEX || f.byteWidth == 64 || f.mask >= 0 || f.broadcast || f.rounding != ""
+		for _, operand := range []Operand{source, destination} {
+			if operand.Kind == OpReg {
+				index, _ := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+				f.evex = f.evex || index >= 16
+				if goarch == "386" && index >= 8 {
+					return f, true, fmt.Errorf("%w: %s register %s has no physical mode32 binding", ErrProbeNeedsContext, ins.Op, operand.Reg)
+				}
+			}
+		}
+	}
+	return f, true, nil
+}
+
+func amd64Mode32VectorOperand(op Operand) bool {
+	index, valid := amd64VectorRegisterIndex(op.Reg, amd64VectorByteWidth(op.Reg))
+	return valid && index < 8
+}
+
+func x86SignedPackedFloatMemoryOperand(source Operand, goarch string) bool {
+	if source.Kind == OpSym {
+		symbol := strings.TrimSpace(source.Sym)
+		_, absolute := parseInt(symbol)
+		return !strings.HasPrefix(symbol, "$") && (strings.HasSuffix(symbol, "(SB)") || absolute == nil)
+	}
+	if source.Kind != OpMem {
+		return source.Kind == OpFP
+	}
+	displacement := source.Mem.Off
+	return (displacement == int64(int32(displacement)) || goarch == "386" && displacement == int64(uint32(displacement))) &&
+		x86MemoryRegistersValidForArch(source.Mem, goarch) && (source.Mem.Index == "" || source.Mem.Index != SP &&
+		(source.Mem.Scale == 1 || source.Mem.Scale == 2 || source.Mem.Scale == 4 || source.Mem.Scale == 8))
+}
+
+func (c *amd64Ctx) lowerSignedPackedIntegerFloat(op Op, ins Instr) (bool, bool, error) {
+	f, known, err := x86SignedPackedFloatProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !strings.EqualFold(string(op), string(ins.Op)) {
+		return true, false, fmt.Errorf("signed packed conversion opcode identity mismatch: %s versus %s", op, ins.Op)
+	}
+	if f.mmx {
+		// A body whitelist cannot close the caller's physical MMX/x87
+		// observations after RET. A private MM0 scratch would alter a
+		// different register when the source names M1, and also affects
+		// x87 Tag/TOS and pending exceptions. No current producer supplies
+		// that complete entry/caller contract; virtual values are not it.
+		return true, false, fmt.Errorf("%w: MMX source conversion lacks a complete physical MMX/x87 caller contract", ErrProbeNeedsContext)
+	}
+	source := ins.Args[0]
+	// Neither a collection of typed FP fields nor our virtual stack is the
+	// original native backing/alignment/fault contract of packed memory.
+	if source.Kind == OpFP {
+		if err := c.validateFPVectorSpan(source.FPOffset, f.memoryBytes); err != nil {
+			return true, false, err
+		}
+		return true, false, fmt.Errorf("%w: %s packed FP source lacks original native backing", ErrProbeNeedsContext, ins.Op)
+	}
+	if ins.x86AddressBits != 0 || source.Kind == OpMem &&
+		!c.nativeMemoryOperand(ins, f.memory) && !c.fixedLocalMemoryCertified(ins, f.memory) {
+		return true, false, fmt.Errorf("%w: %s packed memory lacks original native address binding", ErrProbeNeedsContext, ins.Op)
+	}
+	return true, false, c.emitSignedPackedIntegerFloat(ins, f)
+}
+
+// One original native packed opcode retains ambient RC/PE/trap ordering,
+// active-lane memory fault suppression and ER+SAE. Do not scalarize or emit
+// plain sitofp: O2 may fold it and lose both dynamic rounding and precision.
+func (c *amd64Ctx) emitSignedPackedIntegerFloat(ins Instr, f x86SignedPackedFloatForm) error {
+	mnemonic := strings.ToLower(strings.Split(string(ins.Op), ".")[0])
+	if f.spec.legacy {
+		mnemonic = "cvtdq2ps"
+		if f.spec.bits == 64 {
+			mnemonic = "cvtdq2pd"
+		}
+	}
+	return c.emitNativePackedConversion(ins, x86NativePackedConversion{
+		byteWidth: f.byteWidth, sourceBytes: f.sourceBytes, memoryBytes: f.memoryBytes,
+		outputBits: f.spec.bits, destination: f.destination, mask: f.mask,
+		lanes: f.byteWidth * 8 / f.spec.bits,
+		mmx:   f.mmx, legacy: f.spec.legacy, evex: f.evex, broadcast: f.broadcast,
+		zeroing: f.zeroing, rounding: f.rounding, mnemonic: mnemonic,
+	})
+}
+
+type x86NativePackedConversion struct {
+	byteWidth, sourceBytes, memoryBytes, outputBits int
+	destination, mask, lanes                        int
+	source                                          int // Explicit family-selected data operand; default zero.
+	mmx, legacy, evex, broadcast, zeroing, sae      bool
+	rounding, mnemonic                              string
+	logicalFPBits                                   int   // Explicit owned-value projection, never native FP backing.
+	immediate                                       *byte // Explicit original imm8, not an arithmetic rounding approximation.
+}
+
+func (c *amd64Ctx) emitNativePackedConversion(ins Instr, f x86NativePackedConversion) error {
+	if f.mmx {
+		return fmt.Errorf("%w: no physical MMX/x87 caller contract", ErrProbeNeedsContext)
+	}
+	typ := amd64FloatingVectorType(f.byteWidth*8/f.outputBits, f.outputBits)
+	old := "zeroinitializer"
+	if f.mask >= 0 && !f.zeroing {
+		value, err := c.loadPackedCompareBytes(ins.Args[f.destination], f.byteWidth)
+		if err != nil {
+			return err
+		}
+		old = "%" + c.newTmp()
+		fmt.Fprintf(c.b, "  %s = bitcast <%d x i8> %s to %s\n", old, f.byteWidth, value, typ)
+	}
+	constraint := "x"
+	if f.evex {
+		constraint = "v"
+	}
+	inputConstraint, inputType, inputTemplate := constraint, fmt.Sprintf("<%d x float>", f.sourceBytes/4), "$2"
+	var input string
+	var err error
+	source := ins.Args[f.source]
+	mnemonic := f.mnemonic
+	prefix := ""
+	if source.Kind == OpReg {
+		bytes, loadErr := c.loadPackedCompareBytes(source, f.sourceBytes)
+		if loadErr != nil {
+			return loadErr
+		}
+		input = "%" + c.newTmp()
+		fmt.Fprintf(c.b, "  %s = bitcast <%d x i8> %s to %s\n", input, f.sourceBytes, bytes, inputType)
+	} else if source.Kind == OpFP && f.logicalFPBits != 0 {
+		input, err = c.loadPackedConversionFPValue(source, f.sourceBytes, f.memoryBytes, f.logicalFPBits, f.broadcast)
+		if err != nil {
+			return err
+		}
+	} else {
+		var pointerType string
+		input, pointerType, _, err = c.packedVectorMemoryPointer(source)
+		if err != nil {
+			return err
+		}
+		inputType, inputConstraint = fmt.Sprintf("%s elementtype([%d x i8])", pointerType, f.memoryBytes), "*m"
+		if pointerType == "ptr addrspace(256)" {
+			inputTemplate = "%gs:" + inputTemplate
+		} else if pointerType == "ptr addrspace(257)" {
+			inputTemplate = "%fs:" + inputTemplate
+		}
+	}
+	if f.evex {
+		mnemonic = "{evex} " + mnemonic
+	}
+	args := fmt.Sprintf("%s %s, %s %s", typ, old, inputType, input)
+	constraints := "=" + constraint + ",0," + inputConstraint
+	if f.mask >= 0 {
+		mask, err := c.loadK(ins.Args[f.mask].Reg)
+		if err != nil {
+			return err
+		}
+		maskMove := "kmovw"
+		if f.lanes > 16 {
+			maskMove = "kmovd"
+		}
+		prefix += maskMove + " ${3:k}, %k1; "
+		constraints += ",r,~{k1}"
+		args += ", i32 " + c.approximateMathMask32(mask)
+	}
+	assembly := prefix + mnemonic + " "
+	if f.immediate != nil {
+		assembly += fmt.Sprintf("$$%d, ", *f.immediate)
+	}
+	if f.rounding != "" {
+		assembly += "{" + strings.ToLower(strings.TrimSuffix(f.rounding, "_SAE")) + "-sae}, "
+	}
+	if f.sae {
+		assembly += "{sae}, "
+	}
+	if f.broadcast && source.Kind != OpFP {
+		inputTemplate += fmt.Sprintf(" {1to%d}", f.lanes)
+	}
+	assembly += inputTemplate + ", $0"
+	if f.mask >= 0 {
+		assembly += " {%k1}"
+		if f.zeroing {
+			assembly += " {z}"
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s)\n", result, typ, assembly, constraints+",~{memory},~{fpsr}", args)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <%d x i8>\n", bytes, typ, result, f.byteWidth)
+	if f.legacy {
+		return c.storeLegacyXViews(ins.Args[f.destination].Reg, "%"+bytes)
+	}
+	return c.storePackedMoveOperand(ins.Args[f.destination], f.byteWidth, "%"+bytes)
+}
diff --git a/amd64_signed_packed_integer_float_fault_linux_amd64_test.go b/amd64_signed_packed_integer_float_fault_linux_amd64_test.go
new file mode 100644
index 000000000..f44bdfad2
--- /dev/null
+++ b/amd64_signed_packed_integer_float_fault_linux_amd64_test.go
@@ -0,0 +1,9 @@
+package plan9asm
+
+import "testing"
+
+// This is a required native-AMD64 axis. Rosetta numeric diagnostics do not
+// establish precision traps or the original memory instruction's fault rules.
+func TestCrossLinuxRuntimeMatrixX86SignedPackedIntegerFloatNativeReadAndPrecisionFaults(t *testing.T) {
+	runX86SignedPackedIntegerFloatNativeReadAndPrecisionFaults(t)
+}
diff --git a/amd64_signed_packed_integer_float_fault_selection_test.go b/amd64_signed_packed_integer_float_fault_selection_test.go
new file mode 100644
index 000000000..0b4fcf73b
--- /dev/null
+++ b/amd64_signed_packed_integer_float_fault_selection_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+func TestX86SignedPackedIntegerFloatRequiredNativeFaultRoot(t *testing.T) {
+	const file = "amd64_signed_packed_integer_float_fault_linux_amd64_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"}, {"linux", "arm64"},
+		{"js", "wasm"}, {"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+	} {
+		ctx := build.Default
+		ctx.GOOS, ctx.GOARCH = target.os, target.arch
+		selected, err := ctx.MatchFile(".", file)
+		if err != nil || selected != (target.os == "linux" && target.arch == "amd64") {
+			t.Fatal("required native fault root selection", target, selected, err)
+		}
+	}
+	parsed, err := parser.ParseFile(token.NewFileSet(), file, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(parsed.Decls) != 2 {
+		t.Fatal("native fault wrapper changed its mandatory entry")
+	}
+	fn, valid := parsed.Decls[1].(*ast.FuncDecl)
+	if !valid || fn.Name.Name != "TestCrossLinuxRuntimeMatrixX86SignedPackedIntegerFloatNativeReadAndPrecisionFaults" ||
+		fn.Body == nil || len(fn.Body.List) != 1 {
+		t.Fatal("required cross-runtime fault root omitted or conditionally skipped")
+	}
+	statement, valid := fn.Body.List[0].(*ast.ExprStmt)
+	if !valid {
+		t.Fatal("native fault wrapper does not directly execute the shared oracle")
+	}
+	call, valid := statement.X.(*ast.CallExpr)
+	if !valid || len(call.Args) != 1 {
+		t.Fatal("native fault wrapper changed its shared oracle call")
+	}
+	callee, valid := call.Fun.(*ast.Ident)
+	argument, argumentValid := call.Args[0].(*ast.Ident)
+	if !valid || !argumentValid || callee.Name != "runX86SignedPackedIntegerFloatNativeReadAndPrecisionFaults" || argument.Name != "t" {
+		t.Fatal("required native fault root did not invoke its owned-lifecycle oracle")
+	}
+}
diff --git a/amd64_signed_packed_integer_float_forms_test.go b/amd64_signed_packed_integer_float_forms_test.go
new file mode 100644
index 000000000..faee6f20f
--- /dev/null
+++ b/amd64_signed_packed_integer_float_forms_test.go
@@ -0,0 +1,510 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/scanner"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86SignedPackedFloatRows(arch string) []string {
+	var rows []string
+	last := 15
+	if arch == "386" {
+		last = 7
+	}
+	for _, op := range []string{"CVTPL2PS", "CVTPL2PD"} {
+		for _, source := range []string{"X0", "M0", "M7", "3(AX)", "16(AX)(CX*4)", "3(FS)", "16(GS)", "256"} {
+			rows = append(rows, fmt.Sprintf("%s %s,X%d", op, source, last))
+		}
+	}
+	for _, op := range []string{"VCVTDQ2PS", "VCVTDQ2PD"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			src := bank
+			if op == "VCVTDQ2PD" {
+				src = "X"
+				if bank == "Z" {
+					src = "Y"
+				}
+			}
+			for _, input := range []string{src + "0", "3(AX)", "16(AX)(CX*4)", "3(FS)", "16(GS)", "256"} {
+				for _, mode := range []string{"", "K1,", "K7,"} {
+					name := op
+					if mode == "K7," {
+						name += ".Z"
+					}
+					rows = append(rows, fmt.Sprintf("%s %s,%s%s7", name, input, mode, bank))
+				}
+			}
+			for _, mask := range []string{"", "K1,", "K7,"} {
+				name := op + ".BCST"
+				if mask == "K7," {
+					name += ".Z"
+				}
+				rows = append(rows, fmt.Sprintf("%s 3(AX),%s%s7", name, mask, bank))
+			}
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("%s %s31,%s31", op, src, bank), fmt.Sprintf("%s %s20,K3,%s21", op, src, bank))
+			}
+		}
+		rows = append(rows, op+" X0,X0")
+		if op == "VCVTDQ2PS" {
+			rows = append(rows, op+" Y0,Y0")
+		}
+	}
+	for _, rc := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+		for _, mask := range []string{"", "K1,", "K7,"} {
+			name := "VCVTDQ2PS." + rc
+			if mask == "K7," {
+				name += ".Z"
+			}
+			rows = append(rows, name+" Z0,"+mask+"Z7")
+		}
+	}
+	return rows
+}
+
+func TestX86SignedPackedIntegerFloatCompleteGoTables(t *testing.T) {
+	dir := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86")
+	legacy, err := os.ReadFile(filepath.Join(dir, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := os.ReadFile(filepath.Join(dir, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var yxcvm2 = []ytab{\n\t{Zm_r_xm, 2, argList{Yxm, Yxr}},\n\t{Zm_r_xm, 2, argList{Ymm, Yxr}},\n}",
+		"{ACVTPL2PD, yxcvm2, Px, opBytes{Pf3, 0xe6, Pe, 0x2a}}", "{ACVTPL2PS, yxcvm2, Pm, opBytes{0x5b, 0, 0x2a, 0}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatalf("actual Go legacy table changed: %s", row)
+		}
+	}
+	for _, table := range []string{"_yvcvtdq2ps", "_yvcvtdq2pd"} {
+		start := strings.Index(string(avx), "var "+table+" = []ytab{")
+		if start < 0 {
+			t.Fatal(table)
+		}
+		body := strings.SplitN(string(avx)[start:], "\n}", 2)[0]
+		if strings.Count(body, "zcase:") != 8 {
+			t.Fatalf("%s rows changed: %s", table, body)
+		}
+		for _, destination := range []string{"YxrEvex", "YyrEvex", "Yzr"} {
+			source := "YxmEvex"
+			if table == "_yvcvtdq2ps" && destination == "YyrEvex" || destination == "Yzr" {
+				source = "YymEvex"
+			}
+			if table == "_yvcvtdq2ps" && destination == "Yzr" {
+				source = "Yzm"
+			}
+			for _, row := range []string{fmt.Sprintf("args: argList{%s, %s}", source, destination), fmt.Sprintf("args: argList{%s, Yknot0, %s}", source, destination)} {
+				if !strings.Contains(body, row) {
+					t.Fatalf("actual %s row changed: %s", table, row)
+				}
+			}
+		}
+	}
+	for name, expected := range x86SignedPackedFloatGoOpcodeRows {
+		if err := x86SignedPackedFloatValidateGoOpcodeRows(string(avx), name, expected); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if len(x86SignedPackedFloatSpecs) != 4 {
+		t.Fatal("signed dword family namespace incomplete")
+	}
+}
+
+// Independent full Go encoder rows: tuple agreement alone cannot establish
+// W, pp, opcode map, opcode byte or the absence of extra SAE/ER attributes.
+// Order is significant because the ytab's zoffset selects these byte groups.
+var x86SignedPackedFloatGoOpcodeRows = map[string]string{
+	"VCVTDQ2PD": `{as: AVCVTDQ2PD, ytab: _yvcvtdq2pd, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vexF3 | vex0F | vexW0, 0xE6,
+		avxEscape | vex256 | vexF3 | vex0F | vexW0, 0xE6,
+		avxEscape | evex128 | evexF3 | evex0F | evexW0, evexN8 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+		avxEscape | evex256 | evexF3 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+		avxEscape | evex512 | evexF3 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0xE6,
+	}},`,
+	"VCVTDQ2PS": `{as: AVCVTDQ2PS, ytab: _yvcvtdq2ps, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex0F | vexW0, 0x5B,
+		avxEscape | vex256 | vex0F | vexW0, 0x5B,
+		avxEscape | evex512 | evex0F | evexW0, evexN64 | evexBcstN4 | evexRoundingEnabled | evexZeroingEnabled, 0x5B,
+		avxEscape | evex128 | evex0F | evexW0, evexN16 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+		avxEscape | evex256 | evex0F | evexW0, evexN32 | evexBcstN4 | evexZeroingEnabled, 0x5B,
+	}},`,
+}
+
+func x86SignedPackedFloatValidateGoOpcodeRows(source, name, expected string) error {
+	marker := "{as: A" + name + ","
+	if strings.Count(source, marker) != 1 {
+		return fmt.Errorf("actual Go %s opcode entry missing or duplicated", name)
+	}
+	start := strings.Index(source, marker)
+	const end = "\n\t}},"
+	length := strings.Index(source[start:], end)
+	if length < 0 {
+		return fmt.Errorf("actual Go %s opcode entry unterminated", name)
+	}
+	actual := source[start : start+length+len(end)]
+	actualTokens, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+	if err != nil {
+		return err
+	}
+	expectedTokens, err := x86SignedPackedFloatGoOpcodeTokens(expected)
+	if err != nil {
+		return err
+	}
+	if strings.Join(actualTokens, "\x00") != strings.Join(expectedTokens, "\x00") {
+		return fmt.Errorf("actual Go %s complete encoding rows changed:\n%s", name, actual)
+	}
+	return nil
+}
+
+func x86SignedPackedFloatGoOpcodeTokens(source string) ([]string, error) {
+	var lexer scanner.Scanner
+	var scanError error
+	file := token.NewFileSet().AddFile("opcode-rows", -1, len(source))
+	lexer.Init(file, []byte(source), func(position token.Position, message string) {
+		scanError = fmt.Errorf("Go opcode row %s: %s", position, message)
+	}, 0)
+	var tokens []string
+	for {
+		_, kind, literal := lexer.Scan()
+		if kind == token.EOF {
+			break
+		}
+		if literal == "" {
+			literal = kind.String()
+		}
+		tokens = append(tokens, literal)
+	}
+	return tokens, scanError
+}
+
+func TestX86SignedPackedIntegerFloatGoOpcodeAttributesCannotChange(t *testing.T) {
+	for name, expected := range x86SignedPackedFloatGoOpcodeRows {
+		t.Run(name, func(t *testing.T) {
+			if err := x86SignedPackedFloatValidateGoOpcodeRows(expected, name, expected); err != nil {
+				t.Fatal(err)
+			}
+			type rowMutation struct{ name, old, replacement string }
+			mutations := []rowMutation{
+				{"VEX W", "vexW0", "vexW1"},
+				{"EVEX W", "evexW0", "evexW1"},
+				{"VEX map", "vex0F", "vex0F38"},
+				{"EVEX map", "evex0F", "evex0F38"},
+				{"VEX pp", "vex128 |", "vex128 | vex66 |"},
+				{"EVEX pp", "evex128 |", "evex128 | evex66 |"},
+				{"tuple", "evexN16", "evexN8"},
+				{"broadcast", "evexBcstN4", "evexBcstN8"},
+				{"zero", " | evexZeroingEnabled", ""},
+				{"SAE", "evexZeroingEnabled", "evexZeroingEnabled | evexSaeEnabled"},
+				{"duplicate entry", expected, expected + "\n" + expected},
+			}
+			if name == "VCVTDQ2PS" {
+				mutations = append(mutations,
+					rowMutation{"opcode", "0x5B", "0x5A"},
+					rowMutation{"ER", " | evexRoundingEnabled", ""})
+			} else {
+				mutations = append(mutations,
+					rowMutation{"opcode", "0xE6", "0xE7"},
+					rowMutation{"ER", "evexZeroingEnabled", "evexZeroingEnabled | evexRoundingEnabled"})
+			}
+			lines := strings.Split(expected, "\n")
+			mutations = append(mutations,
+				rowMutation{"missing row", lines[1] + "\n", ""},
+				rowMutation{"extra row", lines[1], lines[1] + "\n" + lines[1]},
+				rowMutation{"row order", lines[1] + "\n" + lines[2], lines[2] + "\n" + lines[1]})
+			for _, mutation := range mutations {
+				t.Run(mutation.name, func(t *testing.T) {
+					source := strings.Replace(expected, mutation.old, mutation.replacement, 1)
+					if source == expected {
+						t.Fatal("mutation did not change the original row")
+					}
+					if err := x86SignedPackedFloatValidateGoOpcodeRows(source, name, expected); err == nil {
+						t.Fatal("encoding mutation passed the complete Go row contract")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86SignedPackedIntegerFloatCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			sigs := map[string]FuncSig{}
+			rows := x86SignedPackedFloatRows(target.arch)
+			contextRows := 0
+			for index, row := range rows {
+				name := fmt.Sprintf("packed%d", index)
+				one, err := Parse(ArchAMD64, "TEXT "+name+"(SB),4,$0-0\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, _, err := x86SignedPackedFloatProperties(one.Funcs[0].Instrs[1], target.arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if form.mmx {
+					goAssemblerOracleOutput(t, target.arch, "TEXT "+name+"(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+					opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{name: {Ret: Void}}}
+					for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+						if _, err := x86SignedPackedFloatTranslate(one, opt, api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unclosed physical MMX caller was authorized", row, api, err)
+						}
+					}
+					contextRows++
+					continue
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, row)
+				sigs[name] = FuncSig{Ret: Void}
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			opt := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := x86SignedPackedFloatTranslate(file, opt, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("uninitialized original conversion formats acquired vector or native inputs", api, err)
+				}
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, sigs, target.arch, target.triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+				return c.lowerSignedPackedIntegerFloat(ins.Op, ins)
+			})
+			for _, text := range []string{ir, x86SignedIntegerFloatOptimize(t, ir)} {
+				if strings.Contains(text, " = sitofp ") || strings.Contains(text, " = call <16 x float> @llvm.experimental.constrained.sitofp") || strings.Count(text, "asm sideeffect") != len(rows)-contextRows {
+					t.Fatalf("original conversion format lost/scalarized native effects: native=%d expected%d", strings.Count(text, "asm sideeffect"), len(rows)-contextRows)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+			t.Logf("%d actual Go accepted forms: %d emitter-only native objects, %d physical MMX Context rows; initialized public positives have their own complete owner", len(rows), len(rows)-contextRows, contextRows)
+		})
+	}
+}
+
+func x86SignedPackedFloatTranslate(file *File, opt Options, api string) (string, error) {
+	if api == "Translate" {
+		return Translate(file, opt)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	var module llvm.Module
+	var err error
+	if api == "TranslateModule" {
+		module, err = TranslateModule(file, opt)
+	} else {
+		module, err = TranslateModuleInContext(ctx, file, opt)
+	}
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return module.String(), nil
+}
+
+func TestX86SignedPackedIntegerFloatRetainsContextAndInvalidForms(t *testing.T) {
+	for _, row := range []string{
+		"CVTPL2PS AX,X0", "CVTPL2PD X0,Y1", "CVTPL2PS.Z X0,K1,X1", "VCVTDQ2PS Y0,X1", "VCVTDQ2PD Y0,Y1",
+		"VCVTDQ2PD.SAE Y0,Z1", "VCVTDQ2PD.RN_SAE Y0,Z1", "VCVTDQ2PS.SAE Z0,Z1", "VCVTDQ2PS.RU_SAE X0,X1",
+		"VCVTDQ2PS.RU_SAE (AX),Z1", "VCVTDQ2PS.BCST X0,X1", "VCVTDQ2PS.Z X0,X1", "VCVTDQ2PS X0,K0,X1",
+		"VCVTDQ2PS.BCST.RU_SAE (AX),Z1", "VCVTDQ2PS X0,K1,(AX)",
+	} {
+		// Go's yxcvm2 also accepts a GP spelling that encodes an MMX
+		// register. It is not a typed GP-source numerical contract.
+		if row != "CVTPL2PS AX,X0" && row != "VCVTDQ2PS.Z X0,X1" {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); err == nil {
+			t.Fatal("accepted invalid", row)
+		}
+	}
+	for _, row := range []string{"CVTPL2PS (SP),X1", "CVTPL2PD (BP),X1", "VCVTDQ2PS (AX)(BP*2),Y1", "VCVTDQ2PS.Z p+0(FP),K1,Z1", "VCVTDQ2PD p+0(FP),X1"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-64\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		frame := FrameLayout{}
+		args := []LLVMType{}
+		for byte := 0; byte < 64; byte++ {
+			frame.Params = append(frame.Params, FrameSlot{Offset: int64(byte), Type: I8, Index: byte, Field: -1})
+			args = append(args, I8)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": {Ret: Void, Args: args, Frame: frame}}}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("fabricated native backing", row, err)
+		}
+	}
+	for _, row := range []string{"VCVTDQ2PS X8,X0", "VCVTDQ2PS X0,X31", "VCVTDQ2PD X8,Y0", "VCVTDQ2PD Y0,Z8"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "386", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("fabricated mode32 physical bank", row, err)
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatActualGoMasklessZeroBoundary(t *testing.T) {
+	asm, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The old encoder accepts EVEX.z without a nonzero writemask. Observe
+	// its actual source/bytes, rather than guessing from runtime.Version.
+	checksMask := strings.Contains(string(asm), "mask register must be specified for .Z instructions")
+	const row = "VCVTDQ2PS.Z X0,X1"
+	goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", !checksMask)
+	if !checksMask {
+		listing, err := x86ExtensionGoListing(t, "amd64", row)
+		if err != nil {
+			t.Fatal(err, listing)
+		}
+		var code []byte
+		for _, line := range strings.Split(listing, "\n") {
+			code = append(code, x86InsertExtractListedBytes(line)...)
+		}
+		if len(code) < 6 || code[0] != 0x62 || code[3]&0x87 != 0x80 {
+			t.Fatal("historical maskless zero encoding changed", code)
+		}
+		if _, _, known, err := decodedX86SameWidthConversionInstruction(code, 64); !known || err == nil {
+			t.Fatal("invalid maskless zero machine code accepted", code, known, err)
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); err == nil {
+		t.Fatal("maskless zero acquired a valid native contract")
+	}
+}
+
+func TestX86SignedPackedIntegerFloatGoSuffixOrder(t *testing.T) {
+	for _, row := range []string{
+		"VCVTDQ2PS.Z.BCST (AX),K1,X1", "VCVTDQ2PD.Z.BCST (AX),K1,Y1",
+		"VCVTDQ2PS.Z.RN_SAE Z0,K1,Z1", "VCVTDQ2PS.Z.RD_SAE Z0,K1,Z1",
+		"VCVTDQ2PS.Z.RU_SAE Z0,K1,Z1", "VCVTDQ2PS.Z.RZ_SAE Z0,K1,Z1",
+	} {
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", Sigs: map[string]FuncSig{"f": {Ret: Void}}}); err == nil {
+			t.Fatal("accepted invalid modifier order", row)
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatMMXUnclosedCallerContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		registers := []string{"M0", "M1", "M7", "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+		if arch == "amd64" {
+			registers = append(registers, "R8", "R15")
+		}
+		for _, op := range []string{"CVTPL2PS", "CVTPL2PD"} {
+			for _, register := range registers {
+				// The caller can observe physical MM0/M1/Tag/TOS after RET,
+				// even when f itself contains only a conversion and a return.
+				// No body whitelist can certify the absent caller contract.
+				source := "TEXT f(SB),4,$0-0\n" + op + " " + register + ",X0\nRET\n" +
+					"TEXT caller(SB),4,$0-0\nCALL f(SB)\nFXSAVE (AX)\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, known, err := x86SignedPackedFloatProperties(file.Funcs[0].Instrs[1], arch)
+				if !known || err != nil || !form.mmx || form.inputBytes != 8 {
+					t.Fatal("actual Ymm class missing", arch, op, register, form, err)
+				}
+				opt := Options{Goarch: arch, Sigs: map[string]FuncSig{"f": {Ret: Void}, "caller": {Ret: Void}}}
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					if _, err := x86SignedPackedFloatTranslate(file, opt, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("ordinary API fabricated physical MMX caller closure", arch, op, register, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatIdentityAndISAContract(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, tc := range []struct{ row, features string }{
+			{"CVTPL2PS X0,X1", "+sse2"}, {"CVTPL2PD X0,X1", "+sse2"},
+			{"CVTPL2PS M0,X1", "+mmx,+sse"}, {"CVTPL2PD M0,X1", "+mmx,+sse,+sse2"},
+			{"VCVTDQ2PS Y0,Y1", "+avx"}, {"VCVTDQ2PD X0,Y1", "+avx"},
+			{"VCVTDQ2PS X0,K1,X1", "+avx512f,+avx512vl"}, {"VCVTDQ2PD Y0,Z1", "+avx512f"},
+		} {
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+tc.row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, fn); got != tc.features {
+				t.Fatal("source ISA contract", arch, tc.row, got, tc.features)
+			}
+			ins := fn.Instrs[1]
+			if ins.Args[0].Reg == "M0" {
+				continue
+			}
+			var ir strings.Builder
+			ctx := newX86Ctx(&ir, fn, FuncSig{Ret: Void}, testResolveSym("example"), nil, arch, "", false)
+			if err := ctx.emitEntryAllocas(); err != nil {
+				t.Fatal(err)
+			}
+			before := ir.Len()
+			if _, _, err := ctx.lowerSignedPackedIntegerFloat("VCVTUDQ2PS", ins); err == nil || ir.Len() != before {
+				t.Fatal("contradictory source opcode emitted IR", err)
+			}
+			ins.x86AddressBits = 32
+			if _, _, err := ctx.lowerSignedPackedIntegerFloat(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || ir.Len() != before {
+				t.Fatal("unbound address identity emitted IR", err)
+			}
+			ins.x86AddressBits = 0
+			ins.Op = Op(strings.ToLower(string(ins.Op)))
+			if _, _, err := ctx.lowerSignedPackedIntegerFloat(ins.Op, ins); err != nil {
+				t.Fatal("equivalent lowercase helper identity rejected", err)
+			}
+		}
+	}
+	for _, row := range []string{"VCVTDQ2PS.SAE Z0,Z1", "VCVTDQ2PS.RU_SAE (AX),Z1", "VCVTDQ2PD.RN_SAE Y0,Z1"} {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", file.Funcs[0]); got != "" {
+			t.Fatal("invalid signed conversion acquired ISA attributes", row, got)
+		}
+	}
+}
diff --git a/amd64_signed_packed_integer_float_raw_test.go b/amd64_signed_packed_integer_float_raw_test.go
new file mode 100644
index 000000000..d6883d67a
--- /dev/null
+++ b/amd64_signed_packed_integer_float_raw_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestX86SignedPackedIntegerFloatRawPhysicalModes(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, op := range []Op{"VCVTDQ2PS", "VCVTDQ2PD"} {
+		for _, evex := range []bool{false, true} {
+			for length := byte(0); length < 3; length++ {
+				if !evex && length == 2 {
+					continue
+				}
+				for _, memory := range []bool{false, true} {
+					for _, w := range []byte{0, 0x80} {
+						if evex && w != 0 {
+							continue
+						} // W1 is another EVEX family.
+						pp, opcode := byte(0), byte(0x5b)
+						if op == "VCVTDQ2PD" {
+							pp, opcode = 2, 0xe6
+						}
+						modrm := byte(0xc1)
+						if memory {
+							modrm = 0x00
+						}
+						code := []byte{0xc4, 0xe1, 0x78 | pp | length<<2 | w, opcode, modrm}
+						if evex {
+							code = []byte{0x62, 0xf1, 0x7c | pp, 0x89 | length<<5, opcode, modrm}
+						}
+						for _, mode := range []int{32, 64} {
+							var bytes strings.Builder
+							for _, v := range code {
+								fmt.Fprintf(&bytes, "0x%02x ", v)
+							}
+							triple := "x86_64"
+							arch := "amd64"
+							if mode == 32 {
+								triple, arch = "i386", "386"
+							}
+							ctx, cancel := runtimeOracleStageContext(t)
+							command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+avx,+avx512f,+avx512vl")
+							command.Stdin = strings.NewReader(bytes.String() + "\n")
+							out, err := runtimeOracleCombinedOutput(ctx, command)
+							cancel()
+							if err != nil || !strings.Contains(strings.ToUpper(string(out)), string(op)) {
+								t.Fatalf("independent LLVM22 mode%d %x: %v\n%s", mode, code, err, out)
+							}
+							var ins Instr
+							var n int
+							var known bool
+							if op == "VCVTDQ2PS" {
+								ins, n, known, err = decodedX86SameWidthConversionInstruction(code, mode)
+							} else {
+								ins, n, known, err = decodedX86PackedDoubleDwordInstruction(code, mode)
+							}
+							if err != nil || !known || n != len(code) {
+								t.Fatalf("valid physical mode%d %x: %v", mode, code, err)
+							}
+							f, known, err := x86SignedPackedFloatProperties(ins, arch)
+							if err != nil || !known || f.byteWidth != 16<<length || evex && (!f.zeroing || f.mask != 1) {
+								t.Fatalf("physical shape %x: %+v %v", code, f, err)
+							}
+							if memory {
+								want := 16 << length
+								if op == "VCVTDQ2PD" {
+									want /= 2
+								}
+								if f.memoryBytes != want {
+									t.Fatal("raw physical read tuple", f, want)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatRawMMXMemoryIdentity(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, code := range [][]byte{{0x0f, 0x2a, 0x00}, {0x66, 0x0f, 0x2a, 0x00}} {
+			var row strings.Builder
+			for _, value := range code {
+				fmt.Fprintf(&row, "BYTE $0x%02x;", value)
+			}
+			listing, err := x86ExtensionGoListing(t, arch, row.String())
+			if err != nil {
+				t.Fatal("actual Go raw source rejected", err, listing)
+			}
+			var object []byte
+			for _, line := range strings.Split(listing, "\n") {
+				object = append(object, x86InsertExtractListedBytes(line)...)
+			}
+			if len(object) != len(code)+1 || !bytes.Equal(object[:len(code)], code) {
+				t.Fatal("raw Go object changed original bytes", object, code)
+			}
+			triple, opcode := "x86_64", "cvtpi2ps"
+			if arch == "386" {
+				triple = "i386"
+			}
+			if len(code) == 4 {
+				opcode = "cvtpi2pd"
+			}
+			var encoded strings.Builder
+			for _, value := range code {
+				fmt.Fprintf(&encoded, "0x%02x ", value)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+mmx,+sse2")
+			command.Stdin = strings.NewReader(encoded.String() + "\n")
+			out, err := runtimeOracleCombinedOutput(ctx, command)
+			cancel()
+			if err != nil || !strings.Contains(string(out), opcode) {
+				t.Fatalf("independent LLVM22 raw MMX identity %s %x: %v\n%s", arch, code, err, out)
+			}
+			file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row.String()+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			opt := Options{Goarch: arch, Sigs: map[string]FuncSig{"f": {Ret: Void}}}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				if _, err := x86SignedPackedFloatTranslate(file, opt, api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw MMX memory was confused with ordinary SSE input", arch, code, api, err)
+				}
+			}
+			decoded, err := decodeX86RawDirectives(rawX86Function(code), arch)
+			if err != nil || len(decoded.Instrs) != 1 {
+				t.Fatal("raw MMX decode", err, decoded.Instrs)
+			}
+			form, known, err := x86SignedPackedFloatProperties(decoded.Instrs[0], arch)
+			if !known || err != nil || !form.mmx || form.memory != 0 || form.memoryBytes != 8 || form.inputBytes != 8 {
+				t.Fatal("raw MMX original read/state identity lost", code, form, err)
+			}
+			// Value-copy normalization must retain this negative state witness.
+			copy := decoded.Instrs[0]
+			form, _, err = x86SignedPackedFloatProperties(copy, arch)
+			if err != nil || !form.mmx {
+				t.Fatal("raw MMX clone washed physical state identity", err)
+			}
+			// The named memory form is instead Go's ordinary SSE opcode.
+			// Neither its name nor x86Encoded alone identifies raw MMX state.
+			named := copy
+			named.x86MMXSourceConversion = false
+			named.x86Encoded = true
+			form, _, err = x86SignedPackedFloatProperties(named, arch)
+			if err != nil || form.mmx || form.sourceBytes != 16 {
+				t.Fatal("MMX restriction leaked into named SSE shape", form, err)
+			}
+			copy.Op = "VCVTDQ2PS"
+			if _, _, err := x86SignedPackedFloatProperties(copy, arch); err == nil {
+				t.Fatal("contradictory raw MMX provenance accepted as VEX conversion")
+			}
+		}
+	}
+}
+
+func TestX86SignedPackedIntegerFloatActualGoObjectSourceWidths(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{"CVTPL2PS X1,X0", "CVTPL2PD X1,X0", "VCVTDQ2PS Y1,Y0", "VCVTDQ2PD X1,Y0", "VCVTDQ2PD Y1,Z0", "VCVTDQ2PS.Z (AX),K1,Z0", "VCVTDQ2PD.BCST.Z (AX),K1,Y0"} {
+			listing, err := x86ExtensionGoListing(t, arch, row)
+			if err != nil {
+				t.Fatal(row, err, listing)
+			}
+			var code []byte
+			for _, line := range strings.Split(listing, "\n") {
+				code = append(code, x86InsertExtractListedBytes(line)...)
+			}
+			decoded, err := decodeX86RawDirectives(rawX86Function(code[:len(code)-1]), arch)
+			if err != nil || len(decoded.Instrs) != 1 {
+				t.Fatal(row, err, decoded.Instrs)
+			}
+			_, known, err := x86SignedPackedFloatProperties(decoded.Instrs[0], arch)
+			if !known || err != nil {
+				t.Fatal(row, "raw physical properties", err)
+			}
+			triple := x86AddressMemoryTargets(arch)[0]
+			source := "TEXT f(SB),4,$0-0\n" + x86RawDisplacementDirectives(code[:len(code)-1]) + "RET\n"
+			x86UnboundVoidRawScalarFormatObject(t, source, arch, triple)
+		}
+	}
+}
diff --git a/amd64_signed_packed_integer_float_resource_unix_test.go b/amd64_signed_packed_integer_float_resource_unix_test.go
new file mode 100644
index 000000000..361447eb8
--- /dev/null
+++ b/amd64_signed_packed_integer_float_resource_unix_test.go
@@ -0,0 +1,158 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+func TestX86SignedPackedFloatFaultChildDisablesCore(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM22 clang required")
+	}
+	dir := t.TempDir()
+	source, executable := filepath.Join(dir, "resource.c"), filepath.Join(dir, "resource")
+	if err := os.WriteFile(source, []byte(x86SignedPackedFloatChildOracle+x86SignedPackedFloatCoreLimitObserver), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(ctx, runtimeOracleNativeCCommand(t, ctx, clang, "-std=c11", "-O2", source, "-o", executable))
+	cancel()
+	if err != nil {
+		t.Fatalf("compile core-limit observer: %v\n%s", err, output)
+	}
+	for _, mode := range []string{"inherited", "hard-zero"} {
+		t.Run(mode, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, executable, mode))
+			if err != nil {
+				t.Fatalf("core-limit child: %v\n%s", err, output)
+			}
+			if !strings.HasPrefix(string(output), "CORE_LIMIT_CHILD_EXECUTED parent_soft=") {
+				t.Fatalf("resource observer did not execute: %q", output)
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+// This is a source consumer, not a search for a setrlimit string: C comments
+// and literals are single tokens, and the policy must be the first statements
+// in the actual fork-child branch before either callback or canary writes.
+func TestX86SignedPackedFloatFaultChildCorePolicySource(t *testing.T) {
+	if err := x86SignedPackedFloatValidateChildCorePolicy(x86SignedPackedFloatChildOracle); err != nil {
+		t.Fatal(err)
+	}
+	// The real native callback must still traverse that checked fork branch.
+	tokens := strings.Join(x86SignedPackedFloatCTokens(x86SignedPackedFloatFaultOracle), " ")
+	call := strings.Join(x86SignedPackedFloatCTokens("return fault_child(invoke_conversion,&request,csr,expected);"), " ")
+	if strings.Count(tokens, call) != 1 {
+		t.Fatal("native-fault callback bypasses or ambiguously uses the child resource policy")
+	}
+	for _, mutation := range []struct{ name, old, replacement string }{
+		{"removed", "struct rlimit core = {0,0};", ""},
+		{"comment only", "struct rlimit core = {0,0};", "/* struct rlimit core = {0,0}; */"},
+		{"nonzero", "{0,0}", "{1,0}"},
+		{"unchecked", "if (setrlimit(RLIMIT_CORE,&core) != 0) _exit(90);", "setrlimit(RLIMIT_CORE,&core);"},
+		{"success on error", "_exit(90)", "_exit(0)"},
+		{"late", "unsigned char out[18];", "unsigned char out[18];\nstruct rlimit core = {0,0};\nif (setrlimit(RLIMIT_CORE,&core) != 0) _exit(90);"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			source := x86SignedPackedFloatChildOracle
+			if mutation.name == "late" {
+				source = strings.Replace(source, "struct rlimit core = {0,0};\n        if (setrlimit(RLIMIT_CORE,&core) != 0) _exit(90);\n        ", "", 1)
+			}
+			source = strings.Replace(source, mutation.old, mutation.replacement, 1)
+			if err := x86SignedPackedFloatValidateChildCorePolicy(source); err == nil {
+				t.Fatal("invalid child policy passed its structural consumer")
+			}
+		})
+	}
+}
+
+func x86SignedPackedFloatValidateChildCorePolicy(source string) error {
+	tokens := x86SignedPackedFloatCTokens(source)
+	branch := x86SignedPackedFloatCTokens("if (pid == 0) {")
+	policy := x86SignedPackedFloatCTokens("struct rlimit core = {0,0}; if (setrlimit(RLIMIT_CORE,&core) != 0) _exit(90);")
+	matches := 0
+	for index := 0; index+len(branch) <= len(tokens); index++ {
+		if strings.Join(tokens[index:index+len(branch)], " ") != strings.Join(branch, " ") {
+			continue
+		}
+		matches++
+		start := index + len(branch)
+		if start+len(policy) > len(tokens) || strings.Join(tokens[start:start+len(policy)], " ") != strings.Join(policy, " ") {
+			return fmt.Errorf("actual fault_child branch lacks its initial checked core-limit policy")
+		}
+	}
+	if matches != 1 {
+		return fmt.Errorf("ambiguous actual fork-child branch: %d", matches)
+	}
+	return nil
+}
+
+func x86SignedPackedFloatCTokens(source string) []string {
+	var lexer scanner.Scanner
+	lexer.Init(strings.NewReader(source))
+	lexer.Mode = scanner.GoTokens
+	var tokens []string
+	for lexer.Scan() != scanner.EOF {
+		tokens = append(tokens, lexer.TokenText())
+	}
+	return tokens
+}
+
+// Only this disposable C parent changes its limits. An already-safe hard=0
+// environment still forks and checks both child limits; it is not a Skip.
+// No instruction or signal capable of generating a core is invoked here.
+const x86SignedPackedFloatCoreLimitObserver = `
+static void observe_limits(void *out, const void *input, unsigned csr) {
+    (void)input;
+    (void)csr;
+    struct rlimit observed;
+    if (getrlimit(RLIMIT_CORE,&observed)) _exit(92);
+    if (observed.rlim_cur || observed.rlim_max) {
+        fprintf(stderr,"inherited child core soft=%llu hard=%llu\n",
+            (unsigned long long)observed.rlim_cur,(unsigned long long)observed.rlim_max);
+    }
+    const uint64_t limits[2] = {observed.rlim_cur,observed.rlim_max};
+    memcpy(out,limits,sizeof(limits));
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2) return 8;
+    if (!strcmp(argv[1],"hard-zero")) {
+        const struct rlimit zero = {0,0};
+        if (setrlimit(RLIMIT_CORE,&zero)) return 9;
+    } else if (strcmp(argv[1],"inherited")) return 8;
+    struct rlimit saved, raised, unchanged, restored;
+    if (getrlimit(RLIMIT_CORE,&saved)) return 10;
+    raised = saved;
+    raised.rlim_cur = saved.rlim_max == RLIM_INFINITY || saved.rlim_max > 4096 ? 4096 : saved.rlim_max;
+    if (setrlimit(RLIMIT_CORE,&raised)) return 11;
+
+    const unsigned char no_core[16] = {0};
+    int status = fault_child(observe_limits,0,0,no_core);
+    int read_error = getrlimit(RLIMIT_CORE,&unchanged);
+    int restore_error = setrlimit(RLIMIT_CORE,&saved);
+    if (read_error || restore_error || getrlimit(RLIMIT_CORE,&restored)) return 12;
+    if (unchanged.rlim_cur != raised.rlim_cur || unchanged.rlim_max != raised.rlim_max ||
+        restored.rlim_cur != saved.rlim_cur || restored.rlim_max != saved.rlim_max) return 13;
+    if (status) {
+        fprintf(stderr,"child policy status=%d parent soft=%llu hard=%llu\n",status,
+            (unsigned long long)raised.rlim_cur,(unsigned long long)raised.rlim_max);
+        return 14;
+    }
+    printf("CORE_LIMIT_CHILD_EXECUTED parent_soft=%llu child_soft=0 child_hard=0 parent_restored=1\n",
+        (unsigned long long)raised.rlim_cur);
+    return 0;
+}
+`
diff --git a/amd64_signed_packed_integer_float_runtime_test.go b/amd64_signed_packed_integer_float_runtime_test.go
new file mode 100644
index 000000000..1eda17c2f
--- /dev/null
+++ b/amd64_signed_packed_integer_float_runtime_test.go
@@ -0,0 +1,340 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86SignedPackedIntegerFloatAmbientConstant(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	const source = "TEXT constant(SB),4,$0-8\nMOVQ out+0(FP),AX\nMOVQ $0x0100000101000001,CX\nMOVQ CX,X0\nCVTPL2PS X0,X1\nMOVUPS X1,(AX)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{"constant": sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const reference = `#include <stdint.h>
+#include <stdio.h>
+extern void constant(uint32_t*);
+int main(void) {
+    uint32_t out[6] = {0xabcdef01,0,0,0,0,0x12345678}, csr=0x5f80, observed;
+    __asm__ volatile("ldmxcsr %0" :: "m"(csr) : "memory");
+    constant(out+1);
+    __asm__ volatile("stmxcsr %0" : "=m"(observed) :: "memory");
+    if (out[1]!=0x4b800001 || out[2]!=0x4b800001 || out[3] || out[4] || observed!=0x5fa0) {
+        fprintf(stderr,"packed ambient constant bits=%08x/%08x CSR=%x expected4b800001/5fa0\n",out[1],out[2],observed);
+        return 1;
+    }
+    if (out[0]!=0xabcdef01 || out[5]!=0x12345678) return 2;
+    return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-packed-float-constant", triple, x86SignedIntegerFloatOptimize(t, ir), reference, prefix)
+}
+
+func TestCrossLinuxRuntimeMatrixX86SignedPackedIntegerFloatSSE(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range []string{
+		"CVTPL2PS X0,X1", "CVTPL2PS X0,X0", "CVTPL2PS (BX),X1",
+		"CVTPL2PD X0,X1", "CVTPL2PD X0,X0", "CVTPL2PD (BX),X1",
+	} {
+		name := fmt.Sprintf("packed%d", index)
+		out := "X1"
+		if strings.HasSuffix(row, "X0") {
+			out = "X0"
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-28\nMOVQ out+0(FP),AX\nMOVQ input+8(FP),BX\nMOVQ old+16(FP),DX\nLDMXCSR csr+24(FP)\nMOVUPS (BX),X0\nMOVUPS (DX),X1\nSTC\n%s\nMOVUPS %s,(AX)\nSTMXCSR 16(AX)\nSETCS 20(AX)\nRET\n", name, row, out)
+		sigs[name] = FuncSig{Args: []LLVMType{Ptr, Ptr, Ptr, I32}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: I32, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(void*,const void*,const void*,uint32_t);\n", name)
+		fmt.Fprintf(&checks, "if (check(%s,%d)) return %d;\n", name, index, index+1)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := x86SignedPackedFloatSSEOracle + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-packed-float-sse", triple, x86SignedIntegerFloatOptimize(t, ir), main, prefix)
+	t.Log("6 original-Go accepted register/memory/alias programs x1024 inputs x4 RC x6 initial MXCSR states; full16/canaries/CF")
+}
+
+func runX86SignedPackedIntegerFloatNativeReadAndPrecisionFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	ir := x86SignedPackedIntegerFloatFaultIR(t, triple)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "signed-packed-native-fault", triple, ir, x86SignedPackedFloatFaultOracle, prefix)
+}
+
+func TestX86SignedPackedIntegerFloatFaultEffectsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86SignedPackedIntegerFloatFaultIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "signed-packed-fault.ll", "signed-packed-fault.o", ir)
+		})
+	}
+}
+
+func x86SignedPackedIntegerFloatFaultIR(t *testing.T, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, tc := range []struct{ name, op string }{{"packedPS", "CVTPL2PS"}, {"packedPD", "CVTPL2PD"}, {"packedDeadPS", "CVTPL2PS"}} {
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ input+8(FP),BX\n%s (BX),X0\n", tc.name, tc.op)
+		if tc.name != "packedDeadPS" {
+			source.WriteString("MOVUPS X0,(AX)\n")
+		}
+		source.WriteString("RET\n")
+		sigs[tc.name] = FuncSig{Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}}}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir = x86SignedIntegerFloatOptimize(t, ir)
+	// Native output moves are side effects too. Count the conversion family,
+	// not unrelated stores, while requiring the dead conversion to survive O2.
+	for _, function := range []struct{ name, opcode string }{
+		{"packedPS", "cvtdq2ps"}, {"packedPD", "cvtdq2pd"}, {"packedDeadPS", "cvtdq2ps"},
+	} {
+		_, body, found := strings.Cut(ir, "define void @"+function.name+"(")
+		body, _, ended := strings.Cut(body, "\n}")
+		if !found || !ended || strings.Count(body, `asm sideeffect "`+function.opcode+` `) != 1 {
+			t.Fatalf("%s lost its native precision or memory faults:\n%s", function.name, ir)
+		}
+	}
+	return ir
+}
+
+// Both the native-fault oracle and its non-faulting resource test execute
+// this same child branch. The latter does not need an x86 instruction.
+const x86SignedPackedFloatChildOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <signal.h>
+typedef void (*childfn)(void*,const void*,unsigned);
+
+static int fault_child(childfn fn, const void *input, unsigned csr, const unsigned char *expected) {
+    pid_t pid = fork();
+    if (pid < 0) return -1;
+    if (pid == 0) {
+        struct rlimit core = {0,0};
+        if (setrlimit(RLIMIT_CORE,&core) != 0) _exit(90);
+        unsigned char out[18];
+        memset(out,0xc3,sizeof(out));
+        fn(out+1,input,csr);
+        if (out[0]!=0xc3 || out[17]!=0xc3 || expected && memcmp(out+1,expected,16)) _exit(91);
+        _exit(0);
+    }
+    int status;
+    if (waitpid(pid,&status,0)!=pid) return -2;
+    if (WIFSIGNALED(status)) return 128+WTERMSIG(status);
+    if (WIFEXITED(status)) return WEXITSTATUS(status);
+    return -3;
+}
+`
+
+// The original native memory instruction, not a preloaded vector, is the
+// independent fault/read-extent oracle. Each child returns its whole 16-byte
+// result and guards, or a concrete signal. A dead result must still trap.
+const x86SignedPackedFloatFaultOracle = x86SignedPackedFloatChildOracle + `
+#include <sys/mman.h>
+typedef void (*memoryfn)(void*,const void*);
+extern void packedPS(void*,const void*);
+extern void packedPD(void*,const void*);
+extern void packedDeadPS(void*,const void*);
+
+static void originalPS(void *out, const void *input) {
+    __asm__ volatile("cvtdq2ps (%1),%%xmm0; movups %%xmm0,(%0)" ::
+        "r"(out), "r"(input) : "xmm0", "memory");
+}
+
+static void originalPD(void *out, const void *input) {
+    __asm__ volatile("cvtdq2pd (%1),%%xmm0; movups %%xmm0,(%0)" ::
+        "r"(out), "r"(input) : "xmm0", "memory");
+}
+
+static void originalDeadPS(void *out, const void *input) {
+    (void)out;
+    __asm__ volatile("cvtdq2ps (%0),%%xmm0" :: "r"(input) : "xmm0", "memory");
+}
+
+struct conversion_request {
+    memoryfn fn;
+    const void *input;
+};
+
+static void invoke_conversion(void *out, const void *opaque, unsigned csr) {
+    const struct conversion_request *request = opaque;
+    __asm__ volatile("ldmxcsr %0" :: "m"(csr) : "memory");
+    request->fn(out,request->input);
+}
+
+static int child(memoryfn fn, const void *input, unsigned csr, const unsigned char *expected) {
+    const struct conversion_request request = {fn,input};
+    return fault_child(invoke_conversion,&request,csr,expected);
+}
+
+static int compare(memoryfn reference, memoryfn translated, const void *input,
+                   unsigned csr, const unsigned char *expected, int requireFault) {
+    int native = child(reference,input,csr,expected);
+    int got = child(translated,input,csr,expected);
+    int memoryFault = native==128+SIGSEGV || native==128+SIGBUS;
+    int valid = requireFault==1 ? memoryFault : requireFault==2 ? native==128+SIGFPE :
+        requireFault==-1 ? native==0 || memoryFault : native==0;
+    if (native<0 || got!=native || !valid) {
+        fprintf(stderr,"signed packed native fault: original=%d LLVM=%d requiredFault=%d csr=%x\n",native,got,requireFault,csr);
+        return 1;
+    }
+    return 0;
+}
+
+int main(void) {
+    long page = sysconf(_SC_PAGESIZE);
+    if (page<64) return 10;
+    unsigned char *region = mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if (region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 11;
+    _Alignas(16) const int32_t exact[4]={1,-1,2,-2}, inexact[4]={16777217,-16777217,1,-1};
+    const uint32_t single[4]={0x3f800000,0xbf800000,0x40000000,0xc0000000};
+    const uint64_t doubled[2]={UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000)};
+    memcpy(region+page-32,exact,16);
+    memcpy(region+page-16,exact,16);
+    if (compare(originalPS,packedPS,region+page-16,0x1f80,(const unsigned char*)single,0)) return 12;
+    memcpy(region+page-8,exact,8);
+    if (compare(originalPD,packedPD,region+page-8,0x1f80,(const unsigned char*)doubled,0)) return 13;
+    if (compare(originalPS,packedPS,region+page-8,0x1f80,0,1)) return 14;
+    // Preserve the exact original opcode's host alignment behavior. Rosetta
+    // does not establish native AMD64 alignment-fault conformance; if it
+    // returns, the full output must still match independent exact integers.
+    memcpy(region+page-31,exact,16);
+    if (compare(originalPS,packedPS,region+page-31,0x1f80,(const unsigned char*)single,-1)) return 15;
+    if (compare(originalPS,packedPS,0,0x1f80,0,1) || compare(originalPD,packedPD,0,0x1f80,0,1)) return 16;
+    if (compare(originalPS,packedPS,exact,0x0f80,(const unsigned char*)single,0)) return 17;
+    if (compare(originalPS,packedPS,inexact,0x0f80,0,2)) return 18;
+    if (compare(originalDeadPS,packedDeadPS,inexact,0x0f80,0,2)) return 19;
+    if (compare(originalDeadPS,packedDeadPS,0,0x1f80,0,1)) return 20;
+    if (munmap(region,2*page)) return 21;
+    return 0;
+}
+`
+
+// The native original opcode and an independent integer rounding algorithm
+// must agree. No LLVM conversion or result observed from the tested function
+// defines expected bits. Rosetta execution remains a diagnostic ISA axis.
+const x86SignedPackedFloatSSEOracle = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+typedef void (*packedfn)(void*,const void*,const void*,uint32_t);
+
+static uint32_t integer_float(int32_t input, unsigned rounding, int *inexact) {
+    uint32_t sign = input < 0 ? 0x80000000u : 0;
+    uint32_t magnitude = input < 0 ? 0u - (uint32_t)input : (uint32_t)input;
+    if (!magnitude) return 0;
+    unsigned exponent = 31u - (unsigned)__builtin_clz(magnitude);
+    if (exponent <= 23) return sign | ((exponent + 127) << 23) | ((magnitude << (23-exponent)) & 0x7fffffu);
+    unsigned shift = exponent - 23;
+    uint32_t fraction = magnitude & ((1u << shift) - 1), significand = magnitude >> shift;
+    *inexact |= fraction != 0;
+    int increment = rounding == 0 ? fraction > (1u << (shift-1)) ||
+        (fraction == (1u << (shift-1)) && (significand & 1)) :
+        rounding == 1 ? sign && fraction : rounding == 2 ? !sign && fraction : 0;
+    significand += increment;
+    if (significand == 0x1000000u) { significand >>= 1; exponent++; }
+    return sign | ((exponent + 127) << 23) | (significand & 0x7fffffu);
+}
+
+static uint64_t integer_double(int32_t input) {
+    uint64_t sign = input < 0 ? UINT64_C(0x8000000000000000) : 0;
+    uint32_t magnitude = input < 0 ? 0u - (uint32_t)input : (uint32_t)input;
+    if (!magnitude) return 0;
+    unsigned exponent = 31u - (unsigned)__builtin_clz(magnitude);
+    return sign | ((uint64_t)(exponent + 1023) << 52) |
+        (((uint64_t)magnitude << (52-exponent)) & UINT64_C(0xfffffffffffff));
+}
+
+static void original(unsigned char *out, const void *input, const void *old, unsigned csr, int variant) {
+    unsigned saved;
+    __asm__ volatile("stmxcsr %0" : "=m"(saved));
+    __asm__ volatile("ldmxcsr %0; movups (%1),%%xmm0; movups (%2),%%xmm1" ::
+        "m"(csr), "r"(input), "r"(old) : "xmm0", "xmm1", "memory");
+    switch (variant) {
+    case 0: __asm__ volatile("cvtdq2ps %%xmm0,%%xmm1" ::: "xmm1"); break;
+    case 1: __asm__ volatile("cvtdq2ps %%xmm0,%%xmm0" ::: "xmm0"); break;
+    case 2: __asm__ volatile("cvtdq2ps (%0),%%xmm1" :: "r"(input) : "xmm1", "memory"); break;
+    case 3: __asm__ volatile("cvtdq2pd %%xmm0,%%xmm1" ::: "xmm1"); break;
+    case 4: __asm__ volatile("cvtdq2pd %%xmm0,%%xmm0" ::: "xmm0"); break;
+    case 5: __asm__ volatile("cvtdq2pd (%0),%%xmm1" :: "r"(input) : "xmm1", "memory"); break;
+    }
+    if (variant == 1 || variant == 4) __asm__ volatile("movups %%xmm0,(%0)" :: "r"(out) : "memory");
+    else __asm__ volatile("movups %%xmm1,(%0)" :: "r"(out) : "memory");
+    __asm__ volatile("stmxcsr %0" : "=m"(*(uint32_t *)(out+16)) :: "memory");
+    __asm__ volatile("ldmxcsr %0" :: "m"(saved) : "memory");
+}
+
+static int check(packedfn fn, int variant) {
+    static const uint32_t edges[] = {0,1,0xffffffff,0x80000000,0x7fffffff,0x1000001,0xfeffffff,0x1000003,0x1000005,0x2000001,0x4000007,0xfffffff0};
+    static const uint32_t controls[] = {0x1f80,0x1fc0,0x9f80,0x9fc0,0x1f85,0x9fe0};
+    for (unsigned sample=0; sample<1024; sample++) {
+        _Alignas(16) uint32_t input[4];
+        unsigned char old[16], before[16], got[24], native[20], want[16], inputBefore[16];
+        for (unsigned lane=0; lane<4; lane++) {
+            input[lane] = sample<12 ? edges[(sample+lane)%12] : 0xd31733a7u*sample + 0x92c48135u*lane;
+            for (unsigned b=0; b<4; b++) old[lane*4+b] = (unsigned char)(sample+lane*37+b*71);
+        }
+        memcpy(before,old,16);
+        memcpy(inputBefore,input,16);
+        for (unsigned rc=0; rc<4; rc++) for (unsigned c=0; c<6; c++) {
+            unsigned csr = controls[c] | (rc << 13), lanes = variant>=3 ? 2 : 4;
+            int inexact=0;
+            memcpy(want,old,16);
+            for (unsigned lane=0; lane<lanes; lane++) {
+                if (variant>=3) {
+                    uint64_t bits=integer_double((int32_t)input[lane]); memcpy(want+lane*8,&bits,8);
+                } else {
+                    uint32_t bits=integer_float((int32_t)input[lane],rc,&inexact); memcpy(want+lane*4,&bits,4);
+                }
+            }
+            original(native,input,old,csr,variant);
+            unsigned nativeCSR; memcpy(&nativeCSR,native+16,4);
+            if (memcmp(native,want,16) || nativeCSR!=(csr | (inexact ? 0x20 : 0))) return 4;
+            memset(got,0xc3,sizeof(got)); fn(got+1,input,old,csr);
+            unsigned observed; memcpy(&observed,got+17,4);
+            if (memcmp(got+1,want,16) || observed!=nativeCSR) {
+                fprintf(stderr,"packed signed variant=%d sample=%u rc=%u csr=%x observed=%x want=%x first=%08x\n",variant,sample,rc,csr,observed,nativeCSR,input[0]); return 1;
+            }
+            if (got[0]!=0xc3 || got[21]!=1 || got[22]!=0xc3 || got[23]!=0xc3 ||
+                memcmp(old,before,16) || memcmp(input,inputBefore,16)) return 2;
+        }
+    }
+    unsigned csr=0x1f80;
+    __asm__ volatile("ldmxcsr %0" :: "m"(csr) : "memory");
+    return 0;
+}
+`
diff --git a/amd64_signed_packed_integer_float_test.go b/amd64_signed_packed_integer_float_test.go
new file mode 100644
index 000000000..8c1c90e87
--- /dev/null
+++ b/amd64_signed_packed_integer_float_test.go
@@ -0,0 +1,16 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86SignedPackedIntegerFloatOriginalCaller(t *testing.T) {
+	const body = "VMOVUPS (DI),Y0\nVCVTDQ2PS Y0,Y1\nVMOVSS X1,(DX)"
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/amd64_signed_packed_native_storage_test.go b/amd64_signed_packed_native_storage_test.go
new file mode 100644
index 000000000..a90f6b84b
--- /dev/null
+++ b/amd64_signed_packed_native_storage_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are independent original Go corpus examples, not strings generated
+// from the translator's form table. The native opcode needs original storage;
+// a software SP/BP allocation must not impersonate its fault/alignment contract.
+func TestX86SignedPackedFloatOfficialStackStorageContext(t *testing.T) {
+	for _, row := range []string{
+		"VCVTDQ2PD -17(BP), K7, Y6",
+		"VCVTDQ2PS -17(BP)(SI*4), K4, X31",
+		"VCVTDQ2PS 17(SP)(BP*2), K1, Y19",
+		"VCVTDQ2PS 17(SP), K4, X31",
+	} {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{
+				Goarch:       "amd64",
+				TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:         map[string]FuncSig{"f": {Ret: Void}},
+			}
+			assertX86PackedFloatStorageContext(t, file, options)
+		})
+	}
+}
+
+func TestX86SignedPackedFloatAllWidthsZeroMaskStorageContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var original strings.Builder
+			index := 0
+			for _, op := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+				banks, modes := []string{"X"}, []string{""}
+				if strings.HasPrefix(op, "V") {
+					banks = []string{"X", "Y", "Z"}
+					modes = []string{"", "K1,", ".Z K1,", ".BCST.Z K1,"}
+				}
+				for _, bank := range banks {
+					for _, address := range []string{"16(SP)", "16(BP)", "16(AX)(BP*2)"} {
+						for _, mode := range modes {
+							mnemonic, mask := op, mode
+							if split := strings.IndexByte(mode, ' '); split >= 0 {
+								mnemonic += mode[:split]
+								mask = mode[split+1:]
+							}
+							for _, maskValue := range []int{0, 1} {
+								row := fmt.Sprintf("%s %s,%s%s1", mnemonic, address, mask, bank)
+								name := fmt.Sprintf("storage%d", index)
+								index++
+								source, sig, _ := x86OrdinaryBPNativeFixture(t, arch, name, row, address, 0)
+								// Keep the typed pointer in AX. Initialize the entire merging
+								// destination bank, not just its low XMM bytes, and use CX
+								// independently for the explicit mask input.
+								setup := ""
+								if bank == "Y" {
+									setup = "VPXOR Y1,Y1,Y1\n"
+								} else if bank == "Z" {
+									setup = "VPXORD Z1,Z1,Z1\n"
+								}
+								setup += fmt.Sprintf("MOVL $%d,CX\nKMOVW CX,K1\n", maskValue)
+								source = strings.Replace(source, row+"\nRET", setup+row+"\nRET", 1)
+								original.WriteString(source)
+								t.Run(fmt.Sprintf("%s/mask=%d", row, maskValue), func(t *testing.T) {
+									file, err := Parse(ArchAMD64, source)
+									if err != nil {
+										t.Fatal(err)
+									}
+									triple := "x86_64-unknown-linux-gnu"
+									if arch == "386" {
+										triple = "i386-unknown-linux-gnu"
+									}
+									options := x86SourceStackOptions(arch, triple, sig)
+									for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+										t.Run(api, func(t *testing.T) {
+											ir, err := x86PackedFloatStorageAPI(api, file, options)
+											x86RequireOrdinaryBPNativeOutcome(t, arch, address, ir, err)
+										})
+									}
+								})
+							}
+						}
+					}
+				}
+			}
+			if index != 156 {
+				t.Fatalf("storage boundary denominator changed: %d", index)
+			}
+			goAssemblerOracleOutput(t, arch, original.String(), "", true)
+			t.Logf("%d complete original Go forms; all three APIs distinguish ordinary386 BP from physical SP/AMD64 BP", index)
+		})
+	}
+}
+
+func assertX86PackedFloatStorageContext(t *testing.T, file *File, options Options) {
+	t.Helper()
+	for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		_, err := x86PackedFloatStorageAPI(api, file, options)
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s authorized unbound native stack storage: %v", api, err)
+		}
+	}
+}
+
+func x86PackedFloatStorageAPI(api string, file *File, options Options) (string, error) {
+	if api == "Translate" {
+		return Translate(file, options)
+	}
+	var module llvm.Module
+	var err error
+	if api == "TranslateModule" {
+		module, err = TranslateModule(file, options)
+	} else {
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err = TranslateModuleInContext(context, file, options)
+	}
+	if module.IsNil() {
+		return "", err
+	}
+	defer module.Dispose()
+	return module.String(), err
+}
diff --git a/amd64_single_source_narrow_forms.go b/amd64_single_source_narrow_forms.go
new file mode 100644
index 000000000..efa2af6fd
--- /dev/null
+++ b/amd64_single_source_narrow_forms.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86SingleSourceNarrowForm struct {
+	spec                                  amd64SingleSourceNarrowSpec
+	inputBytes, outputBytes, carrierBytes int
+	destination, mask, memory             int
+	zeroing                               bool
+}
+
+func (f x86SingleSourceNarrowForm) undefinedOpcode() bool {
+	return f.zeroing && f.memory >= 0
+}
+
+// Source capacity, active output tuple and physical destination carrier are
+// separate axes. A form grants neither initialized bytes nor memory backing.
+func x86SingleSourceNarrowProperties(op Op, ins Instr, arch string) (x86SingleSourceNarrowForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64SingleSourceNarrowSpecs[name]
+	f := x86SingleSourceNarrowForm{spec: spec, destination: len(ins.Args) - 1, mask: -1, memory: -1, zeroing: dotted}
+	if !known {
+		return f, false, nil
+	}
+	fail := func() (x86SingleSourceNarrowForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside single-source narrowing grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) ||
+		dotted && suffix != "Z" || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fail()
+	}
+	f.inputBytes = amd64VectorByteWidth(ins.Args[0].Reg)
+	if ins.Args[0].Kind != OpReg || !amd64GoPackedVectorMoveRegister(ins.Args[0], f.inputBytes, arch) {
+		return fail()
+	}
+	f.outputBytes = f.inputBytes * spec.outputBits / spec.inputBits
+	f.carrierBytes = 16
+	if f.outputBytes > 16 {
+		f.carrierBytes = 32
+	}
+	if len(ins.Args) == 3 {
+		k, valid := amd64ParseKReg(ins.Args[1].Reg)
+		if ins.Args[1].Kind != OpReg || !valid || k == 0 {
+			return fail()
+		}
+		f.mask = 1
+	}
+	if dotted && f.mask < 0 {
+		return fail()
+	}
+	destination := ins.Args[f.destination]
+	if destination.Kind == OpReg {
+		if !amd64GoPackedVectorMoveRegister(destination, f.carrierBytes, arch) {
+			return fail()
+		}
+	} else {
+		if !isAMD64MemoryOperand(destination) || !x86PackedShiftMemoryValid(destination, arch) {
+			return fail()
+		}
+		f.memory = f.destination
+	}
+	return f, true, nil
+}
+
+func x86TypedSingleSourceNarrowByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86SingleSourceNarrowProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if f.undefinedOpcode() {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: narrowing EVEX.z memory encoding has no ordinary byte continuation", ErrProbeNeedsContext)
+	}
+	width := f.carrierBytes
+	if f.memory >= 0 {
+		width = f.outputBytes
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true,
+		vector: x86TypedVectorEffect{x86TypedVectorUpperZero, 1},
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: ins.Args[0], width: int64(f.inputBytes), read: true},
+			{index: f.destination, operand: ins.Args[f.destination], width: int64(width), write: true,
+				read: f.memory < 0 && f.mask >= 0 && !f.zeroing},
+		}}
+	if effect.operands[1].read {
+		effect.operands[1].requiredBytes = x86CallerVectorByteMask(int64(f.outputBytes))
+	}
+	if f.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.mask, operand: ins.Args[f.mask], width: 8, read: true})
+	}
+	return effect, true, nil
+}
+
+func x86ResultSingleSourceNarrowStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64,
+	arch string, native bool) (bool, bool) {
+	f, known, err := x86SingleSourceNarrowProperties(ins.Op, ins, arch)
+	if !known || err != nil || f.undefinedOpcode() || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	source, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, f.inputBytes)
+	required := x86CallerVectorByteMask(int64(f.inputBytes))
+	if !valid || state.vectorBytes(source)&required != required {
+		return false, true
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	destination := ins.Args[f.destination]
+	if f.memory >= 0 {
+		if native && x86ResultIncomingPointerAddressIdentity(destination, state, arch) {
+			return true, true // Paired store preserves faults, never establishes future NUM bytes.
+		}
+		if f.mask >= 0 && !x86ResultRead(destination, int64(f.outputBytes), state, owned, arch) {
+			return false, true // Inactive logical result bytes must already be known.
+		}
+		return x86ResultStore(destination, int64(f.outputBytes), state, owned, resultOffset, arch), true
+	}
+	index, valid := amd64VectorRegisterIndex(destination.Reg, f.carrierBytes)
+	old := x86CallerVectorByteMask(int64(f.outputBytes))
+	if !valid || f.mask >= 0 && !f.zeroing && state.vectorBytes(index)&old != old {
+		return false, true
+	}
+	state.writeVector(index, f.carrierBytes, ^uint64(0), false)
+	return true, true
+}
diff --git a/amd64_sized_gp_native_read.go b/amd64_sized_gp_native_read.go
new file mode 100644
index 000000000..69fc7951d
--- /dev/null
+++ b/amd64_sized_gp_native_read.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "fmt"
+
+// This shares exact-width load emission, not source, backing or ABI authority.
+func (c *amd64Ctx) evalSizedNativeGPSource(source Operand, typ LLVMType, addressBits int) (string, error) {
+	wordBits := 64
+	if c.goarch == "386" {
+		wordBits = 32
+	}
+	if source.Kind != OpMem && source.Kind != OpSym {
+		return c.evalIntSized(source, typ)
+	}
+	if addressBits != 0 && addressBits != wordBits && addressBits != wordBits/2 {
+		return "", fmt.Errorf("invalid GP read address size %d for %s", addressBits, c.goarch)
+	}
+	ptr, ptrType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	if source.Kind == OpMem && addressBits != 0 && addressBits != wordBits {
+		// Wrap only the effective offset, before the FS/GS hardware base.
+		address, wrapped := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint %s %s to i%d\n", address, ptrType, ptr, addressBits)
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i%d %%%s to %s\n", wrapped, addressBits, address, ptrType)
+		ptr = "%" + wrapped
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, ptrType, ptr)
+	return "%" + value, nil
+}
diff --git a/amd64_sized_nop_forms.go b/amd64_sized_nop_forms.go
new file mode 100644
index 000000000..8458295fb
--- /dev/null
+++ b/amd64_sized_nop_forms.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's two hardware NOP aliases share ydivl/Yml. Its ModRM operand selects
+// encoding bytes only: neither registers nor the described memory are read.
+// Go's operand-rich NOP pseudo and normalized raw NOP keep separate grammars.
+func x86SizedNOPProperties(ins Instr, arch string) (bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if name != "NOPW" && name != "NOPL" {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, fmt.Errorf("%s %s outside complete Go sized-NOP Yml grammar: %q", arch, ins.Op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 1 {
+		return fail()
+	}
+	operand := ins.Args[0]
+	if operand.Kind == OpReg {
+		if !isX86YrlRegisterForArch(operand.Reg, arch) {
+			return fail()
+		}
+	} else if !isAMD64MemoryOperand(operand) || !x86PackedShiftMemoryValid(operand, arch) ||
+		x86NamedMultiplyMemoryError(operand, arch) != nil {
+		return fail()
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return true, fmt.Errorf("%w: sized NOP requires named source or the separate inert raw handoff", ErrProbeNeedsContext)
+	}
+	return true, nil
+}
diff --git a/amd64_source_integer_address.go b/amd64_source_integer_address.go
new file mode 100644
index 000000000..10ba98226
--- /dev/null
+++ b/amd64_source_integer_address.go
@@ -0,0 +1,404 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Go's TYPE_ADDR/NAME_NONE is not uniformly an effective address. obj6.progedit
+// rewrites MOVL/Q to LEAL/Q before asm6.oclass falls through to TYPE_CONST for
+// other opcodes. This source adapter covers the finite scalar integer rows
+// below; it is not a memory, caller, raw-encoder or source-authentication proof.
+// Named SB/AUTO/FP operands retain their existing independent consumers.
+func x86UnnamedSourceAddress(operand Operand) (memory MemRef, matched bool, err error) {
+	if operand.Kind != OpSym || !strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+		return MemRef{}, false, nil
+	}
+	body := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(operand.Sym), "$"))
+	memory, matched, err = parseX86SourceRegisterMemory(body)
+	if err != nil || !matched {
+		return memory, matched, err
+	}
+	if x86SourceMemoryHasSegment(memory) {
+		return MemRef{}, true, fmt.Errorf("%w: unnamed x86 address has an unbound segment/TLS producer: %q", ErrProbeNeedsContext, operand.Sym)
+	}
+	return memory, true, nil
+}
+
+func x86UnnamedSourceAddressInMode(operand Operand, arch string) (MemRef, bool, error) {
+	if operand.Kind != OpSym || !strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+		return x86UnnamedSourceAddress(operand)
+	}
+	normalized := operand
+	normalized.Sym = normalizeGoGRegister(ArchAMD64, operand.Sym)
+	memory, matched, err := x86UnnamedSourceAddress(normalized)
+	if err != nil || !matched || normalized.Sym == operand.Sym {
+		return memory, matched, err
+	}
+	if arch != "amd64" {
+		return MemRef{}, true, fmt.Errorf("x86 source g register annotation is not registered in %s mode: %q", arch, operand.Sym)
+	}
+	return memory, true, nil
+}
+
+// registerIndirect leaves a missing second-group multiplier at zero. This is
+// valid parser metadata, not an encodable SIB scale. TYPE_CONST may ignore it;
+// physical memory and MOVL/Q's derived LEA must validate it independently.
+func parseX86SourceRegisterMemory(body string) (memory MemRef, matched bool, err error) {
+	return parseX86SourceRegisterMemorySyntax(body, false)
+}
+
+// Inventories retain a valid unresolved displacement without inventing its
+// numerical value. TYPE_ADDR consumers still use the strict wrapper above;
+// every translation API separately rejects OffRaw before raw normalization.
+func parseX86SourceRegisterMemorySyntax(body string, retainUnresolved bool) (memory MemRef, matched bool, err error) {
+	if group := x86SymbolPseudoGroup.FindStringSubmatchIndex(body); group != nil {
+		prefix := strings.TrimSpace(body[:group[0]])
+		if _, constant := parseImmExpr(prefix); prefix != "" && !constant {
+			// SP in the second physical group is an Index, not an AUTO
+			// role. The prefix before the first pseudo spelling contains
+			// no pseudo group, so this check cannot recursively nest.
+			_, physical, prefixErr := parseX86SourceRegisterMemorySyntax(prefix, retainUnresolved)
+			if !physical {
+				return MemRef{}, false, nil // Complete named SB/AUTO/FP role, including indexes.
+			}
+			if prefixErr != nil {
+				return MemRef{}, true, prefixErr
+			}
+		}
+	}
+	for open := 0; open < len(body); open++ {
+		if body[open] != '(' {
+			continue
+		}
+		prefix := strings.TrimSpace(body[:open])
+		value, constant := parseImmExpr(prefix)
+		if prefix == "" {
+			constant = true
+		}
+		if !constant {
+			// Named AUTO and SB/FP roles belong to their own consumers. An
+			// ordinary unresolved displacement remains syntax only: validate
+			// every register group below and retain the original expression.
+			if register, _, _, _, groupErr := parseX86SymbolRegisterGroup(body[open:]); groupErr == nil && register != SP {
+				if !retainUnresolved || !x86SourceDisplacementNeedsContext(prefix) {
+					return MemRef{}, true, fmt.Errorf("%w: unresolved x86 source address displacement: %q", ErrProbeNeedsContext, body)
+				}
+				memory.OffRaw = prefix
+			} else {
+				continue // An expression parenthesis or a named address.
+			}
+		}
+		register, scale, scaled, rest, parseErr := parseX86SymbolRegisterGroup(body[open:])
+		if parseErr != nil {
+			// A parenthesized displacement expression precedes, rather than
+			// supplies, the register groups (for example $(1<<4)(AX)).
+			if prefix == "" {
+				depth, end := 0, -1
+				for offset, character := range body[open:] {
+					if character == '(' {
+						depth++
+					} else if character == ')' {
+						depth--
+						if depth == 0 {
+							end = open + offset + 1
+							break
+						}
+					}
+				}
+				if end > open {
+					if _, expression := parseImmExpr(body[open:end]); expression ||
+						x86SourceDisplacementNeedsContext(body[open:end]) {
+						continue
+					}
+				}
+			}
+			return MemRef{}, true, parseErr
+		}
+		memory.Off = int64(value)
+		if scaled {
+			memory.Index, memory.Scale = register, scale
+		} else {
+			memory.Base = register
+			if rest != "" {
+				register, scale, _, rest, parseErr = parseX86SymbolRegisterGroup(rest)
+				if parseErr != nil {
+					return MemRef{}, true, parseErr
+				}
+				memory.Index, memory.Scale = register, scale
+			}
+		}
+		if rest != "" {
+			return MemRef{}, true, fmt.Errorf("unnamed x86 address has extra register groups: %q", body)
+		}
+		return memory, true, nil
+	}
+	return MemRef{}, false, nil
+}
+
+func x86SourceDisplacementNeedsContext(displacement string) bool {
+	// go_tls.h's function-like g(r) macro has not been expanded in a raw
+	// source inventory. It is not the amd64 g register in this position.
+	return strings.TrimSpace(displacement) == "g" || memoryOffsetExpressionNeedsContext(displacement)
+}
+
+func unresolvedX86MemoryOffsetError(memory MemRef) error {
+	if memory.OffRaw == "" {
+		return nil
+	}
+	if memory.Base == SP {
+		if validPPIdentifier(memory.OffRaw) && memory.Off == 0 {
+			return nil // Bare NAME_AUTO supplies its descriptive name and offset zero.
+		}
+		if offset, named := parseNamedStackConstantOffset(memory.OffRaw); named && offset == memory.Off {
+			return nil // Resolved descriptive C_AUTO offset, not a missing constant.
+		}
+	}
+	return fmt.Errorf("%w: unresolved x86 memory offset %q", ErrProbeNeedsContext, memory.OffRaw)
+}
+
+func x86SourceMemoryHasSegment(memory MemRef) bool {
+	for _, register := range []Reg{memory.Base, memory.Index} {
+		switch register {
+		case CS, DS, ES, SS, FS, GS, "TLS":
+			return true
+		}
+	}
+	return false
+}
+
+func validateX86SourceMemoryScale(ins Instr) error {
+	if ins.x86Encoded || ins.x86SourceRaw != nil {
+		return nil // A decoded instruction retains its separate physical contract.
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpMem || operand.Mem.Sym != "" || operand.Mem.Segment != "" || x86SourceMemoryHasSegment(operand.Mem) {
+			continue // Not an ordinary NAME_NONE SIB memory operand.
+		}
+		memory := operand.Mem
+		if memory.Index != "" && (memory.Index == SP || memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8) {
+			return fmt.Errorf("x86 source memory has an unencodable SIB index/scale: %q", ins.Raw)
+		}
+	}
+	return nil
+}
+
+func normalizeX86SourceIntegerAddress(ins Instr, arch string) (Instr, bool, error) {
+	var index = -1
+	var memory MemRef
+	for position, operand := range ins.Args {
+		address, matched, err := x86UnnamedSourceAddressInMode(operand, arch)
+		if err != nil {
+			return ins, false, err
+		}
+		if !matched {
+			continue
+		}
+		if index >= 0 {
+			return ins, false, fmt.Errorf("x86 integer source row cannot contain multiple TYPE_ADDR constants: %q", ins.Raw)
+		}
+		index, memory = position, address
+	}
+	if index < 0 {
+		return ins, false, nil
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return ins, false, fmt.Errorf("%w: source TYPE_ADDR has an unbound physical address-size override", ErrProbeNeedsContext)
+	}
+	if ins.x86Encoded || ins.x86SourceRaw != nil {
+		return ins, false, fmt.Errorf("%w: a source TYPE_ADDR adapter cannot replace a decoded physical instruction", ErrProbeNeedsContext)
+	}
+	if arch != "amd64" && arch != "386" {
+		return ins, false, fmt.Errorf("unsupported x86 source mode %q", arch)
+	}
+	derived := ins
+	derived.Args = append([]Operand(nil), ins.Args...)
+	op := strings.ToUpper(string(x86SourceMoveInstruction(ins, arch).Op))
+	if op == "MOVL" || op == "MOVQ" {
+		if len(ins.Args) != 2 || index != 0 {
+			return ins, false, fmt.Errorf("x86 MOV address rewrite requires source and GP destination: %q", ins.Raw)
+		}
+		derived.Op = Op("LEA" + op[3:])
+		derived.Args[index] = Operand{Kind: OpMem, Mem: memory}
+		if _, err := x86LEAOperandWidth(derived, arch); err != nil {
+			return ins, false, err
+		}
+		return derived, true, nil
+	}
+	value := memory.Off
+	if arch == "386" {
+		value = int64(int32(value)) // asm6.oclass applies this before class selection.
+	}
+	derived.Args[index] = Operand{Kind: OpImm, Imm: value}
+	if err := validateX86SourceIntegerImmediateRow(derived, arch, index); err != nil {
+		return ins, false, err
+	}
+	// All audited Q-width arithmetic/TEST/CMP/IMUL/PUSH rows encode imm32
+	// and the processor sign-extends it. Shift/bit counts remain imm8.
+	if strings.HasSuffix(op, "Q") {
+		switch strings.TrimSuffix(op, "Q") {
+		case "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST", "IMUL", "IMUL3", "PUSH":
+			derived.Args[index].Imm = int64(int32(value))
+		}
+	}
+	return derived, true, nil
+}
+
+// Validate the source role before changing Kind. In particular an x87 or SSE
+// memory-only row must never inherit a permissive FLOAT-immediate lowerer.
+func validateX86SourceIntegerImmediateRow(ins Instr, arch string, index int) error {
+	op := strings.ToUpper(string(ins.Op))
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: %s unnamed TYPE_ADDR integer row: %s: %q", ErrProbeNeedsContext, op, reason, ins.Raw)
+	}
+	if len(op) < 2 || strings.Contains(op, ".") {
+		return fail("opcode/suffix is outside the audited scalar class")
+	}
+	bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[op[len(op)-1]]
+	stem := op[:len(op)-1]
+	if bits == 0 || bits == 64 && arch == "386" {
+		return fail("operand width has no physical source-mode row")
+	}
+	integer32 := func(value int64) bool {
+		return arch == "386" || value >= -2147483648 && value <= 4294967295
+	}
+	registerOrMemory := func(operand Operand) bool {
+		if operand.Kind == OpReg {
+			if bits == 8 {
+				return isGoYmbRegisterForArch(operand.Reg, arch)
+			}
+			return isX86YrlRegisterForArch(operand.Reg, arch)
+		}
+		return isAMD64MemoryOperand(operand)
+	}
+	value := ins.Args[index].Imm
+	switch stem {
+	case "MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "TEST":
+		if len(ins.Args) != 2 || index != 0 || !registerOrMemory(ins.Args[1]) || !integer32(value) {
+			return fail("does not match Yi32 → Ymb/Yml")
+		}
+		if stem == "MOV" && bits != 8 && bits != 16 {
+			return fail("MOVL/Q require their distinct source address rewrite")
+		}
+		if stem == "ADD" || stem == "SUB" || stem == "ADC" || stem == "SBB" {
+			return validateAMD64ScalarAddSubOperands(arch, op, bits, ins.Args[0], ins.Args[1], ins)
+		}
+	case "CMP":
+		if len(ins.Args) != 2 || index != 1 || !registerOrMemory(ins.Args[0]) || !integer32(value) {
+			return fail("does not match Ymb/Yml → Yi32")
+		}
+	case "PUSH":
+		if bits == 8 || bits == 32 && arch != "386" || bits == 64 && arch != "amd64" ||
+			len(ins.Args) != 1 || index != 0 || !integer32(value) {
+			return fail("does not match source-mode PUSHW/L/Q Yi8/Yi32")
+		}
+	case "BT", "BTC", "BTR", "BTS":
+		if bits == 8 || len(ins.Args) != 2 || index != 0 || value < -128 || value > 127 || !registerOrMemory(ins.Args[1]) {
+			return fail("does not match signed Yi8 → Yml")
+		}
+	case "SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR":
+		if index != 0 || value < 0 || value > 255 {
+			return fail("count is not Yu8")
+		}
+		// asm6.movDoubleShift requires From.Type == TYPE_CONST even when
+		// oclass covers this TYPE_ADDR as Yi8. Do not wash that identity away.
+		if len(ins.Args) != 2 || !registerOrMemory(ins.Args[1]) {
+			return fail("does not match Yu8 → Ymb/Yml")
+		}
+	case "IMUL", "IMUL3":
+		three := stem == "IMUL3"
+		if bits == 8 || index != 0 || len(ins.Args) != 2 && !three || len(ins.Args) != 3 && three {
+			return fail("does not match the complete immediate IMUL row")
+		}
+		return validateX86ExplicitIMUL(arch, op, bits, ins, three)
+	default:
+		return fail("opcode has no independently audited integer-immediate source role")
+	}
+	return nil
+}
+
+// This runs only after the original raw/caller/frame proofs. It supplies an
+// immutable lowering view, never a repaired certificate. Only the separately
+// checked, stack-unobserving raw-RET leaf below permits MOVL/Q's numerical LEA
+// rewrite. LOCK/caller/physical-frame proofs retain their original source.
+func normalizeX86SourceIntegerAddresses(file *File, options Options) (*File, error) {
+	if file.Arch != ArchAMD64 {
+		return file, nil
+	}
+	if options.Goarch == "" {
+		options.Goarch = "amd64" // Preserve the existing public default mode.
+	}
+	result := *file
+	result.Funcs = append([]Func(nil), file.Funcs...)
+	for function, source := range file.Funcs {
+		instructions := append([]Instr(nil), source.Instrs...)
+		changed, protected := false, source.x86SourceStack != nil || source.x86FixedLocal != nil || source.X86RawText != nil
+		for _, ins := range source.Instrs {
+			if strings.EqualFold(string(ins.Op), "LOCK") || ins.x86RawNearReturn != nil {
+				protected = true
+			}
+		}
+		for index, ins := range source.Instrs {
+			if err := validateX86SourceMemoryScale(ins); err != nil {
+				return nil, fmt.Errorf("%s: %w", source.Sym, err)
+			}
+			derived, different, err := normalizeX86SourceIntegerAddress(ins, options.Goarch)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", source.Sym, err)
+			}
+			instructions[index], changed = derived, changed || different
+		}
+		if changed {
+			derived := source
+			derived.Instrs = instructions
+			if protected && !x86RawReturnNumericalAddressAdapter(source, derived, file, options) {
+				return nil, fmt.Errorf("%w: %s source address adapter cannot inherit a LOCK/raw/frame certificate", ErrProbeNeedsContext, source.Sym)
+			}
+			result.Funcs[function].Instrs = instructions
+		}
+	}
+	return &result, nil
+}
+
+// A decoded native-width near RET is a return constraint, not permission to
+// address native memory. Recheck both complete views without transferring any
+// stack, caller, frame or other decoded-instruction certificate. This adapter
+// handles only Go's MOVL/Q -> LEAL/Q progedit rule, never TYPE_CONST arithmetic.
+func x86RawReturnNumericalAddressAdapter(source, derived Func, file *File, options Options) bool {
+	if len(source.Instrs) != len(derived.Instrs) || source.FrameSize != 0 || source.x86SourceStack != nil || source.x86FixedLocal != nil ||
+		source.X86RawText != nil || len(source.x86ContinuationAddresses) != 0 || len(source.x86IndirectLabels) != 0 {
+		return false
+	}
+	name := source.Sym
+	if options.ResolveSym != nil {
+		name = options.ResolveSym(name)
+	}
+	sig := options.Sigs[name]
+	if sig.x86CallerRegions != nil || sig.x86FixedLocal != nil {
+		return false
+	}
+	hasReturn := false
+	for index, ins := range source.Instrs {
+		if strings.EqualFold(string(ins.Op), "LOCK") ||
+			ins.x86CallerMemory != nil || ins.x86SourceStackFP != nil || ins.x86FixedLocalMemory != nil {
+			return false
+		}
+		if ins.x86RawNearReturn != nil {
+			hasReturn = true
+		} else if ins.x86Encoded || ins.x86SourceRaw != nil {
+			return false // Another decoder's contract needs its own adapter.
+		}
+		if derived.Instrs[index].Op != ins.Op {
+			op := strings.ToUpper(string(x86SourceMoveInstruction(ins, options.Goarch).Op))
+			if (op != "MOVL" && op != "MOVQ") || string(derived.Instrs[index].Op) != "LEA"+op[3:] {
+				return false
+			}
+		} else if !reflect.DeepEqual(ins.Args, derived.Instrs[index].Args) {
+			return false // A TYPE_CONST rewrite is a different semantic rule.
+		}
+	}
+	return hasReturn && x86RawReturnLeafStackUnobserved(source) && x86RawReturnLeafStackUnobserved(derived) &&
+		validateX86RawNearReturns(source, file, options, true) == nil &&
+		validateX86RawNearReturns(derived, file, options, true) == nil
+}
diff --git a/amd64_source_integer_address_g_test.go b/amd64_source_integer_address_g_test.go
new file mode 100644
index 000000000..cf68adc13
--- /dev/null
+++ b/amd64_source_integer_address_g_test.go
@@ -0,0 +1,424 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/format"
+	goparser "go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86ActualGoGRegistration = `if linkArch == &x86.Linkamd64 {
+	register["g"] = x86.REGG
+}`
+
+func x86ActualGoGRegistrationRule(source []byte) error {
+	set := token.NewFileSet()
+	file, err := goparser.ParseFile(set, "arch.go", source, 0)
+	if err != nil {
+		return err
+	}
+	count, references := 0, 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "archX86" || function.Body == nil {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			index, ok := node.(*ast.IndexExpr)
+			if !ok {
+				return true
+			}
+			name, named := index.X.(*ast.Ident)
+			literal, text := index.Index.(*ast.BasicLit)
+			if named && name.Name == "register" && text && literal.Value == `"g"` {
+				references++
+			}
+			return true
+		})
+		for _, statement := range function.Body.List {
+			conditional, ok := statement.(*ast.IfStmt)
+			if !ok {
+				continue
+			}
+			var body bytes.Buffer
+			if err := format.Node(&body, set, conditional); err != nil {
+				return err
+			}
+			if strings.Contains(body.String(), `register["g"]`) {
+				count++
+				if strings.Join(strings.Fields(body.String()), " ") != strings.Join(strings.Fields(x86ActualGoGRegistration), " ") {
+					return fmt.Errorf("unreviewed actual Go g registration: %s", body.String())
+				}
+			}
+		}
+	}
+	if count != 1 || references != 1 {
+		return fmt.Errorf("actual Go g registration count %d / references %d", count, references)
+	}
+	return nil
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeCPP(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, replacement := range []string{"g", "R14"} {
+			t.Run(arch+"/"+replacement, func(t *testing.T) {
+				source := "#define REG " + replacement + "\nTEXT addr(SB),4,$0-0\nADDL $1(REG),DX\nRET\n"
+				accepted := arch == "amd64" || replacement == "R14"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, accepted)
+				expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{FileName: "g-source.s"})
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, expanded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				original := file.Funcs[0].Instrs[1]
+				if original.Args[0].Sym != "$1("+replacement+")" {
+					t.Fatal("CPP or parser lost the actual source register token")
+				}
+				_, changed, err := normalizeX86SourceIntegerAddress(original, arch)
+				if accepted != (changed && err == nil) {
+					t.Fatalf("CPP token acquired another source architecture: %v", err)
+				}
+			})
+		}
+	}
+	if _, err := Parse(ArchAMD64, "TEXT addr(SB),4,$0-0\nADDL $1(REG),DX\nRET\n"); err == nil {
+		// Unexpanded register identifiers are not a qualified alias. A parser
+		// may retain unknown symbols, but complete normalization must reject.
+		file, _ := Parse(ArchAMD64, "TEXT addr(SB),4,$0-0\nADDL $1(REG),DX\nRET\n")
+		if _, err := normalizeX86SourceIntegerAddresses(file, Options{}); err == nil {
+			t.Fatal("an unresolved CPP register token acquired g qualification")
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeActualRule(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86ActualGoGRegistrationRule(source); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("ACTUAL_G_REGISTER_ROLE sourceSHA=%x Go=%s", sha256.Sum256(source), runtime.Version())
+	for _, change := range [][2]string{
+		{"&x86.Linkamd64", "&x86.Link386"},
+		{`register["g"]`, `register["G"]`},
+		{"x86.REGG", "x86.REG_AX"},
+		{"==", "!="},
+	} {
+		copy := strings.Replace(x86ActualGoGRegistration, change[0], change[1], 1)
+		fixture := "package arch\nfunc archX86() {\n" + copy + "\n}\n"
+		if x86ActualGoGRegistrationRule([]byte(fixture)) == nil {
+			t.Fatal("changed actual architecture qualifier accepted")
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeActualGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, annotation := range []string{"g", "R14"} {
+			for _, address := range []string{
+				"1(" + annotation + ")",
+				"1(" + annotation + "*1)",
+				"1(AX)(" + annotation + "*2)",
+				"1(" + annotation + ")(CX)",
+				"1 ( " + annotation + " )",
+				"1(AX) ( " + annotation + " * 2 )",
+			} {
+				t.Run(arch+"/"+address, func(t *testing.T) {
+					source := "TEXT addr(SB),4,$0-0\nADDL $" + address + ",DX\nRET\n"
+					accepted := arch == "amd64" || annotation == "R14"
+					x86ScalarLiteralExpectedGoListing(t, arch, source, accepted)
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeCompleteConstantRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{
+			"MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST",
+			"SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR", "IMUL", "IMUL3",
+			"BT", "BTC", "BTR", "BTS", "PUSH",
+		} {
+			for _, suffix := range []string{"B", "W", "L", "Q"} {
+				if suffix == "Q" && arch == "386" || stem == "MOV" && suffix != "B" && suffix != "W" ||
+					suffix == "B" && (strings.HasPrefix(stem, "IMUL") || strings.HasPrefix(stem, "BT") || stem == "PUSH") ||
+					stem == "PUSH" && (suffix == "L" && arch != "386" || suffix == "Q" && arch != "amd64") {
+					continue
+				}
+				t.Run(arch+"/"+stem+suffix, func(t *testing.T) {
+					for _, annotation := range []string{"g", "R14"} {
+						operands := "$1(" + annotation + "),DX"
+						if stem == "CMP" {
+							operands = "DX,$1(" + annotation + ")"
+						} else if stem == "IMUL3" {
+							operands = "$1(" + annotation + "),BX,DX"
+						} else if stem == "PUSH" {
+							operands = "$1(" + annotation + ")"
+						}
+						ending := "RET\n"
+						if stem == "PUSH" {
+							ending = "POP" + suffix + " DX\nRET\n"
+						}
+						source := "TEXT addr(SB),4,$0-0\n" + stem + suffix + " " + operands + "\n" + ending
+						accepted := annotation == "R14" || arch == "amd64"
+						if accepted {
+							original := x86PackedShiftActualGoBytes(t, arch, source)
+							plain := x86PackedShiftActualGoBytes(t, arch, strings.ReplaceAll(source, "("+annotation+")", ""))
+							if !bytes.Equal(original, plain) {
+								t.Fatal("ignored annotation changed original instruction bytes")
+							}
+						} else {
+							x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+						}
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						_, changed, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+						if accepted != (changed && err == nil) {
+							t.Fatalf("source g qualifier differs from actual Go: %s: %v", annotation, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeImmutableAndIsolated(t *testing.T) {
+	source := "TEXT addr(SB),4,$0-0\nADDL $1(g),DX\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := file.Funcs[0].Instrs[1]
+	if original.Args[0].Sym != "$1(g)" {
+		t.Fatal("parser destroyed the original register spelling")
+	}
+	derived, err := normalizeX86SourceIntegerAddresses(file, Options{})
+	if err != nil || !reflect.DeepEqual(file.Funcs[0].Instrs[1], original) || derived.Funcs[0].Instrs[1].Args[0].Kind != OpImm {
+		t.Fatalf("mode adapter changed the original input: %v", err)
+	}
+	again, err := normalizeX86SourceIntegerAddresses(derived, Options{})
+	if err != nil || !reflect.DeepEqual(derived, again) {
+		t.Fatal("source g normalization is not idempotent")
+	}
+	for _, role := range []string{"LOCK", "raw", "frame", "addressBits", "encoded"} {
+		t.Run(role, func(t *testing.T) {
+			copy := *file
+			copy.Funcs = append([]Func(nil), file.Funcs...)
+			copy.Funcs[0].Instrs = append([]Instr(nil), file.Funcs[0].Instrs...)
+			switch role {
+			case "LOCK":
+				copy.Funcs[0].Instrs = append(copy.Funcs[0].Instrs, Instr{Op: "LOCK"})
+			case "raw":
+				copy.Funcs[0].X86RawText = []byte{0xc3}
+			case "frame":
+				copy.Funcs[0].x86FixedLocal = &x86FixedLocalProof{}
+			case "addressBits":
+				copy.Funcs[0].Instrs[1].x86AddressBits = 32
+			case "encoded":
+				copy.Funcs[0].Instrs[1].x86Encoded = true
+			}
+			if _, err := normalizeX86SourceIntegerAddresses(&copy, Options{}); err == nil {
+				t.Fatal("g alias inherited an unrelated source/native certificate")
+			}
+		})
+	}
+	for _, symbol := range []string{"$g(SB)", "$g<>(SB)", "$slot(FP)(g)", "$slot(SP)(g)", "$g+1(SB)"} {
+		for _, arch := range []string{"386", "amd64"} {
+			if _, matched, err := x86UnnamedSourceAddressInMode(Operand{Kind: OpSym, Sym: symbol}, arch); matched || err != nil {
+				t.Fatalf("named role became an unnamed g constant: %q / %v", symbol, err)
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			annotation := "g"
+			if target.arch == "386" {
+				annotation = "R14"
+			}
+			source := "TEXT ·addr(SB),4,$0-4\nMOVL $2,DX\n" +
+				"MOVW $1(" + annotation + "),DX\nADDL $1(AX)(" + annotation + "*2),DX\n" +
+				"CMPL DX,$1(" + annotation + ")(CX)\nMOVL DX,ret+0(FP)\nRET\n"
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			pkg := x86AddSubLiteralPackage(t, target.arch, "func addr() uint32\n")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					if strings.Contains(ir, "%reg_R14") || strings.Contains(ir, "%reg_CX") {
+						t.Fatal("ignored annotations became physical register inputs")
+					}
+					compileLLVMToObject(t, llc, target.triple, "g-source.ll", "g-source.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86UnnamedAddressGSourceConstant(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	const source = "TEXT gconstant(SB),4,$0-16\nMOVQ x+0(FP),DX\nADDL $1(g),DX\nMOVQ DX,ret+8(FP)\nRET\n"
+	code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT addr(SB),4,$0-0\nADDL $1(g),DX\nRET\n")
+	plain := x86PackedShiftActualGoBytes(t, "amd64", "TEXT addr(SB),4,$0-0\nADDL $1,DX\nRET\n")
+	if !bytes.Equal(code, plain) || len(code) != 4 || code[3] != 0xc3 {
+		t.Fatalf("unbound actual constant opcode: %x / %x", code, plain)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signature := FuncSig{Name: "gconstant", Args: []LLVMType{I64}, Ret: I64, Frame: FrameLayout{
+		Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+		Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+	}}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: map[string]FuncSig{"gconstant": signature}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := fmt.Sprintf(`
+#include <stdint.h>
+#include <stdio.h>
+extern uint64_t gconstant(uint64_t);
+
+static uint64_t original(uint64_t input) {
+    uint64_t value = input;
+    __asm__ volatile(".byte 0x%02x,0x%02x,0x%02x" : "+d"(value) : : "cc");
+    return value;
+}
+
+int main(void) {
+    for (unsigned seed = 0; seed < 256; seed++) {
+        volatile struct { uint64_t before, input, after; } guarded = {
+            UINT64_C(0x8977665544332211), UINT64_C(0x2398111297893221) * seed,
+            UINT64_C(0x998812345679abcd)
+        };
+        uint64_t input = guarded.input;
+        uint64_t expected = (uint32_t)(input + 1);
+        if (original(input) != expected || gconstant(input) != expected ||
+            guarded.input != input || guarded.before != UINT64_C(0x8977665544332211) ||
+            guarded.after != UINT64_C(0x998812345679abcd)) {
+            fprintf(stderr, "g constant numerical/canary failure %%u\n", seed);
+            return 31;
+        }
+    }
+    puts("G_SOURCE_ORIGINAL_LLVM_MATH_CANARIES_256_OK");
+    return 0;
+}
+`, code[0], code[1], code[2])
+	for _, optimization := range []string{"-O0", "-O2"} {
+		execution.compileAndRunLLVM(t, "g-source-constant", ir, main, optimization)
+	}
+}
+
+func TestX86UnnamedAddressImmediateGSourceModeThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, statement := range []string{
+			"MOVW $1(g),DX",
+			"ADDL $1(g),DX",
+			"ADDL $1(AX)(g*2),DX",
+			"CMPL DX,$1(g)(CX)",
+		} {
+			t.Run(target.triple+"/"+statement, func(t *testing.T) {
+				source := "TEXT ·addr(SB),4,$0-0\nMOVL $2,DX\n" + statement + "\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						var translationErr error
+						switch api {
+						case "text":
+							_, translationErr = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, translationErr = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, translationErr = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								result.Module.Dispose()
+							}
+						}
+						if target.arch == "386" && translationErr == nil {
+							t.Error(fmt.Sprintf("%s accepted unregistered source g after ignored R14 normalization", api))
+						}
+						if target.arch == "amd64" && translationErr != nil {
+							t.Fatalf("actual registered g constant annotation: %v", translationErr)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_source_integer_address_index_test.go b/amd64_source_integer_address_index_test.go
new file mode 100644
index 000000000..b707e9603
--- /dev/null
+++ b/amd64_source_integer_address_index_test.go
@@ -0,0 +1,696 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	goparser "go/parser"
+	"go/printer"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86UnnamedAddressImmediateUnscaledSecondGroup(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, operation := range []string{"MOVL", "MOVQ"} {
+			if arch == "386" && operation == "MOVQ" {
+				continue
+			}
+			for _, address := range []string{"1(AX)(CX)", "-16(BP)(DI)", "0(AX)(AX)"} {
+				t.Run(arch+"/"+operation+"/"+address, func(t *testing.T) {
+					source := "TEXT addr(SB),4,$0-0\n" + operation + " $" + address + ",DX\nRET\n"
+					x86UnnamedScale0OriginalGoRejection(t, arch, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					original := file.Funcs[0].Instrs[1]
+					memory, matched, err := x86UnnamedSourceAddress(original.Args[0])
+					if err != nil || !matched || memory.Index == "" || memory.Scale != 0 {
+						t.Errorf("source Index/Scale0 was changed: %+v, %v", memory, err)
+					}
+					if _, _, err := normalizeX86SourceIntegerAddress(original, arch); err == nil {
+						t.Error("Go-invalid Scale0 became a legal LEA source")
+					}
+				})
+			}
+		}
+	}
+}
+
+// asmidx's scale diagnostic has no source position. Keep the generic oracle
+// strict: this local witness binds one complete MOV source and the exact
+// base/index tuple to the selected SDK's independently inspected diagnostic.
+func x86UnnamedScale0OriginalGoRejection(t *testing.T, arch, source string) {
+	t.Helper()
+	match := regexp.MustCompile(`^TEXT addr\(SB\),4,\$0-0\n(MOVB|MOVW|MOVL|MOVQ|LEAW|LEAL|LEAQ) (\$?)(-?[0-9]+)\((AX|BP)\)\((AX|CX|DI)\),DX\nRET\n$`).FindStringSubmatch(source)
+	if match == nil {
+		// The store controls have exactly the same one-instruction physical
+		// tuple, but bind it from To rather than claiming a From rewrite.
+		store := regexp.MustCompile(`^TEXT addr\(SB\),4,\$0-0\n(MOVB|MOVW|MOVL|MOVQ) DX,(-?[0-9]+)\((AX|BP)\)\((AX|CX|DI)\)\nRET\n$`).FindStringSubmatch(source)
+		if store != nil {
+			match = []string{store[0], store[1], "", store[2], store[3], store[4]}
+		}
+	}
+	if match == nil || arch != "386" && arch != "amd64" || arch == "386" && strings.HasSuffix(match[1], "Q") ||
+		strings.HasPrefix(match[1], "LEA") && match[2] != "" {
+		t.Fatalf("unbound Scale0 rejection fixture: %s / %q", arch, source)
+	}
+	want := x86UnnamedAsmidxDiagnostic(t, match[4], match[5])
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "scale0.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "literal", "-o", filepath.Join(dir, "scale0.o"), asm)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := x86UnnamedAsmidxOutcome(output, err, ctx.Err(), want); failure != nil {
+		t.Fatalf("exact Scale0 source rejection lost its tuple/exit/lifecycle: %v / %v\nwant %q\ngot %q", err, ctx.Err(), want, output)
+	}
+	for _, changed := range []string{
+		strings.Replace(want, "bad address 0/", "bad address 3/", 1),
+		strings.Replace(want, "bad address", "foreign address", 1),
+		want + want, want + "unexpected diagnostic\n", "asm: assembly failed\n", "",
+	} {
+		if x86UnnamedAsmidxOutcome([]byte(changed), err, nil, want) == nil {
+			t.Fatal("local source oracle accepted a changed/repeated/missing diagnostic")
+		}
+	}
+	for _, failure := range []error{nil, errors.New("launch failure"), errors.Join(err, errors.New("cleanup failure"))} {
+		if x86UnnamedAsmidxOutcome(output, failure, nil, want) == nil {
+			t.Fatal("local source oracle accepted an unknown/cleanup process outcome")
+		}
+	}
+	if x86UnnamedAsmidxOutcome(output, err, context.DeadlineExceeded, want) == nil {
+		t.Fatal("local source oracle accepted a timed-out process")
+	}
+	t.Logf("ORIGINAL_SCALE0_REJECTION arch=%s sourceSHA=%x source=%q outputSHA=%x output=%q", arch, sha256.Sum256([]byte(source)), source, sha256.Sum256(output), output)
+}
+
+func x86UnnamedAsmidxOutcome(output []byte, err, contextErr error, expected string) error {
+	exit, ok := err.(*exec.ExitError)
+	if contextErr != nil || !ok || exit.ProcessState == nil || !exit.ProcessState.Exited() || exit.ExitCode() != 1 || string(output) != expected {
+		return fmt.Errorf("unbound asmidx outcome: %v / %v / %q", err, contextErr, output)
+	}
+	return nil
+}
+
+func x86UnnamedAsmidxDiagnostic(t *testing.T, base, index string) string {
+	t.Helper()
+	expression := func(node ast.Node) string {
+		var text bytes.Buffer
+		if err := printer.Fprint(&text, token.NewFileSet(), node); err != nil {
+			t.Fatal(err)
+		}
+		return text.String()
+	}
+	read := func(relative string) *ast.File {
+		path := filepath.Join(runtime.GOROOT(), "src", relative)
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := goparser.ParseFile(token.NewFileSet(), path, data, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("ACTUAL_ASMIDX_SOURCE file=%s SHA=%x", relative, sha256.Sum256(data))
+		return file
+	}
+	file := read("cmd/internal/obj/x86/asm6.go")
+	format, calls := "", 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "asmidx" {
+			continue
+		}
+		ast.Inspect(function, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok || expression(call.Fun) != "ctxt.Diag" || len(call.Args) != 4 {
+				return true
+			}
+			literal, ok := call.Args[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return true
+			}
+			text, err := strconv.Unquote(literal.Value)
+			if err != nil || !strings.HasPrefix(text, "asmidx: bad address") {
+				return true
+			}
+			calls++
+			format = text
+			arguments := expression(call.Args[1]) + "/" + expression(call.Args[2]) + "/" + expression(call.Args[3])
+			if format == "asmidx: bad address %d/%s/%s" && arguments == "scale/rconv(index)/rconv(base)" ||
+				format == "asmidx: bad address %d/%d/%d" && arguments == "scale/index/base" {
+				return true
+			}
+			t.Fatalf("unreviewed actual Go asmidx diagnostic: %s / %s", format, arguments)
+			return false
+		})
+	}
+	if calls != 1 {
+		t.Fatalf("actual Go has %d matching asmidx diagnostics", calls)
+	}
+	if format == "asmidx: bad address %d/%s/%s" {
+		return "asm: " + fmt.Sprintf(format, 0, index, base) + "\nasm: assembly failed\n"
+	}
+	// Older SDKs print obj register IDs. Derive those IDs from the actual
+	// RBaseAMD64 expression and REG_AL+iota declaration, not GoVersion.
+	registerBase, found := int64(0), false
+	ast.Inspect(read("cmd/internal/obj/util.go"), func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || value.Names[0].Name != "RBaseAMD64" {
+			return true
+		}
+		if found || len(value.Values) != 1 {
+			t.Fatal("ambiguous actual RBaseAMD64")
+		}
+		multiply, ok := value.Values[0].(*ast.BinaryExpr)
+		if !ok || multiply.Op != token.MUL {
+			t.Fatal("unreviewed RBaseAMD64 expression")
+		}
+		left, leftErr := strconv.ParseInt(expression(multiply.X), 10, 64)
+		right, rightErr := strconv.ParseInt(expression(multiply.Y), 10, 64)
+		if leftErr != nil || rightErr != nil || left != 2 || right != 1024 {
+			t.Fatal("unreviewed actual RBaseAMD64 factors")
+		}
+		registerBase, found = left*right, true
+		return false
+	})
+	if !found {
+		t.Fatal("actual RBaseAMD64 missing")
+	}
+	ids := map[string]int64{}
+	for _, declaration := range read("cmd/internal/obj/x86/a.out.go").Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST || len(group.Specs) == 0 {
+			continue
+		}
+		first := group.Specs[0].(*ast.ValueSpec)
+		if len(first.Names) != 1 || first.Names[0].Name != "REG_AL" {
+			continue
+		}
+		if len(first.Values) != 1 || expression(first.Values[0]) != "obj.RBaseAMD64 + iota" || len(ids) != 0 {
+			t.Fatal("unreviewed actual REG_AL+iota declaration")
+		}
+		for offset, item := range group.Specs {
+			value, ok := item.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || offset > 0 && len(value.Values) != 0 {
+				break // Later bounds constants are not register enum entries.
+			}
+			ids[strings.TrimPrefix(value.Names[0].Name, "REG_")] = registerBase + int64(offset)
+		}
+	}
+	for offset, name := range x86SymbolIndexedActualRegisterNames(t) {
+		if ids[name] != registerBase+int64(offset) {
+			t.Fatalf("actual register spelling/ID mismatch: %s / %d", name, ids[name])
+		}
+	}
+	baseID, baseOK := ids[base]
+	indexID, indexOK := ids[index]
+	if !baseOK || !indexOK {
+		t.Fatal("fixture register is not in the actual SDK enum")
+	}
+	return "asm: " + fmt.Sprintf(format, 0, indexID, baseID) + "\nasm: assembly failed\n"
+}
+
+func TestX86UnnamedAddressImmediateScale0ConstantFamily(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{
+			"MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST",
+			"SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR", "IMUL", "IMUL3",
+			"BT", "BTC", "BTR", "BTS", "PUSH",
+		} {
+			for _, suffix := range []string{"B", "W", "L", "Q"} {
+				if suffix == "Q" && arch == "386" || stem == "MOV" && suffix != "B" && suffix != "W" ||
+					suffix == "B" && (strings.HasPrefix(stem, "IMUL") || strings.HasPrefix(stem, "BT") || stem == "PUSH") ||
+					stem == "PUSH" && (suffix == "L" && arch != "386" || suffix == "Q" && arch != "amd64") {
+					continue
+				}
+				t.Run(arch+"/"+stem+suffix, func(t *testing.T) {
+					operand := "$1(AX)(CX),DX"
+					if stem == "CMP" {
+						operand = "DX,$1(AX)(CX)"
+					} else if stem == "IMUL3" {
+						operand = "$1(AX)(CX),BX,DX"
+					} else if stem == "PUSH" {
+						operand = "$1(AX)(CX)"
+					}
+					ending := "RET\n"
+					if stem == "PUSH" {
+						ending = "POP" + suffix + " DX\nRET\n"
+					}
+					source := "TEXT addr(SB),4,$0-0\n" + stem + suffix + " " + operand + "\n" + ending
+					original := x86PackedShiftActualGoBytes(t, arch, source)
+					plain := x86PackedShiftActualGoBytes(t, arch, strings.ReplaceAll(source, "(AX)(CX)", ""))
+					if !bytes.Equal(original, plain) {
+						t.Fatalf("constant source consumed its ignored Scale0: %x != %x", original, plain)
+					}
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, _, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateScale0ThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, operation := range []string{"MOVL", "MOVQ"} {
+			if target.arch == "386" && operation == "MOVQ" {
+				continue
+			}
+			t.Run(target.triple+"/"+operation, func(t *testing.T) {
+				source := "TEXT ·addr(SB),4,$0-0\nMOVL $2,AX\nMOVL $3,CX\n" + operation + " $1(AX)(CX),DX\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						var err error
+						switch api {
+						case "text":
+							_, err = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, err = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								result.Module.Dispose()
+							}
+						}
+						if err == nil {
+							t.Error(fmt.Sprintf("%s %s silently changed Scale0 to Scale1", target.arch, api))
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateDirectLEAScale0(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, operation := range []string{"LEAW", "LEAL", "LEAQ"} {
+			if target.arch == "386" && operation == "LEAQ" {
+				continue
+			}
+			t.Run(target.triple+"/"+operation, func(t *testing.T) {
+				x86UnnamedScale0OriginalGoRejection(t, target.arch, "TEXT addr(SB),4,$0-0\n"+operation+" 1(AX)(CX),DX\nRET\n")
+				source := "TEXT ·addr(SB),4,$0-0\nMOVL $2,AX\nMOVL $3,CX\n" + operation + " 1(AX)(CX),DX\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						var err error
+						switch api {
+						case "text":
+							_, err = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, err = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								result.Module.Dispose()
+							}
+						}
+						if err == nil {
+							t.Fatal("direct source LEA silently changed Scale0 to Scale1")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediatePhysicalMemoryThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, suffix := range []string{"B", "W", "L", "Q"} {
+			if target.arch == "386" && suffix == "Q" {
+				continue
+			}
+			for _, store := range []bool{false, true} {
+				instruction := "MOV" + suffix + " 1(AX)(CX),DX"
+				if store {
+					instruction = "MOV" + suffix + " DX,1(AX)(CX)"
+				}
+				t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+					x86UnnamedScale0OriginalGoRejection(t, target.arch, "TEXT addr(SB),4,$0-0\n"+instruction+"\nRET\n")
+					source := "TEXT ·addr(SB),4,$0-0\nMOVL $2,AX\nMOVL $3,CX\nMOVL $4,DX\n" + instruction + "\nRET\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+					resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							context := llvm.NewContext()
+							defer context.Dispose()
+							var err error
+							switch api {
+							case "text":
+								_, err = Translate(file, options)
+							case "module":
+								var module llvm.Module
+								module, err = TranslateModuleInContext(context, file, options)
+								if !module.IsNil() {
+									module.Dispose()
+								}
+							case "GoModule":
+								var result *GoModuleTranslation
+								result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+								if result != nil && !result.Module.IsNil() {
+									result.Module.Dispose()
+								}
+							}
+							if err == nil {
+								t.Fatal("physical memory source with a missing SIB multiplier was accepted")
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediatePhysicalSIBIndexSP(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scale := range []string{"1", "2", "4", "8"} {
+			for _, op := range []string{"MOVL", "LEAL"} {
+				t.Run(arch+"/"+op+"/"+scale, func(t *testing.T) {
+					x86ScalarLiteralExpectedGoListing(t, arch, "TEXT addr(SB),4,$0-0\n"+op+" 1(AX)(SP*"+scale+"),DX\nRET\n", false)
+				})
+			}
+		}
+		for _, address := range []string{"1(AX)(SP)", "1(SP)(CX)"} {
+			t.Run(arch+"/constant/"+address, func(t *testing.T) {
+				// SP as an ignored annotation does not create a SIB or
+				// a private stack read. Only the original TYPE_CONST
+				// role is independently established by these bytes.
+				source := "TEXT addr(SB),4,$0-0\nADDL $" + address + ",DX\nRET\n"
+				original := x86PackedShiftActualGoBytes(t, arch, source)
+				plain := x86PackedShiftActualGoBytes(t, arch, strings.Replace(source, "$"+address, "$1", 1))
+				if !bytes.Equal(original, plain) {
+					t.Fatalf("constant-class source consumed an ignored SP/index: %x != %x", original, plain)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				derived, changed, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+				if err != nil || !changed || derived.Args[0].Kind != OpImm || derived.Args[0].Imm != 1 {
+					t.Fatalf("constant-class SP annotation changed role: %+v / %v", derived, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateCompleteGroupBoundaries(t *testing.T) {
+	valid := []string{
+		"1(AX)", "-16(BP)", "1(SP)", "1(CX*1)", "1(CX*2)", "1(CX*4)", "1(CX*8)",
+		"1(AX)(CX*1)", "1(AX)(CX*2)", "1(AX)(CX*4)", "1(AX)(CX*8)",
+		"1( AX ) ( CX * 2 )",
+	}
+	invalid := []string{
+		"1(AX)(CX*0)", "1(AX)(CX*3)", "1(AX)(CX*01)", "1(AX)(CX*0x1)",
+		"1(AX)(CX*+1)", "1(AX)(CX*-1)", "1(AX)(CX*(1))", "1(AX)(CX*1+1)",
+		"1(AX)(CX*)", "1(AX)(CX*1)(DX)", "1(AX*1)(CX*1)",
+		"1()(CX*1)", "1(AX)(NOTREG*1)",
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, domain := range []struct{ op, prefix string }{{"MOVL", "$"}, {"ADDL", "$"}, {"MOVL", ""}, {"LEAL", ""}} {
+			for _, group := range []struct {
+				addresses []string
+				accepted  bool
+			}{{valid, true}, {invalid, false}} {
+				for _, address := range group.addresses {
+					t.Run(arch+"/"+domain.op+"/"+domain.prefix+address, func(t *testing.T) {
+						source := "TEXT addr(SB),4,$0-0\n" + domain.op + " " + domain.prefix + address + ",DX\nRET\n"
+						x86ScalarLiteralExpectedGoListing(t, arch, source, group.accepted)
+						file, err := Parse(ArchAMD64, source)
+						if err == nil {
+							_, _, err = normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+						}
+						if (err == nil) != group.accepted {
+							t.Fatalf("source group accepted=%t: %v", group.accepted, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediatePhysicalGroupState(t *testing.T) {
+	for _, row := range []struct {
+		text   string
+		memory MemRef
+	}{
+		{"1(AX)", MemRef{Base: AX, Off: 1}},
+		{"1(CX*1)", MemRef{Index: CX, Scale: 1, Off: 1}},
+		{"1(CX*2)", MemRef{Index: CX, Scale: 2, Off: 1}},
+		{"1(AX)(CX)", MemRef{Base: AX, Index: CX, Off: 1}},
+		{"1( AX ) ( CX )", MemRef{Base: AX, Index: CX, Off: 1}},
+		{"1(AX)(CX*1)", MemRef{Base: AX, Index: CX, Scale: 1, Off: 1}},
+		{"(1<<4)(AX)(CX*4)", MemRef{Base: AX, Index: CX, Scale: 4, Off: 16}},
+		{"1(AX)(SP)", MemRef{Base: AX, Index: SP, Off: 1}},
+	} {
+		t.Run(row.text, func(t *testing.T) {
+			operand, err := parseOperandForArch(ArchAMD64, row.text)
+			if err != nil || operand.Kind != OpMem || operand.Mem != row.memory {
+				t.Fatalf("stock-Go source Reg/Index/Scale changed: %+v, want %+v: %v", operand, row.memory, err)
+			}
+		})
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVL", "LEAL"} {
+			x86UnnamedScale0OriginalGoRejection(t, arch, "TEXT addr(SB),4,$0-0\n"+op+" 1(AX)(CX),DX\nRET\n")
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediatePhysicalRoleIsolation(t *testing.T) {
+	for _, source := range []string{
+		"table<>(SB)", "table<>(SB)(AX)(CX)", "a+8(FP)", "a+8(FP)(CX)",
+		"local+8(SP)", "local+8(SP)(AX)(CX)", "2(PC)",
+		"1(FS)", "1(GS)", "1(AX)(FS)", "1(AX)(GS)", "1(TLS)",
+	} {
+		t.Run(source, func(t *testing.T) {
+			// The x86 source adapter must not relabel named/prefix/branch
+			// operands into ordinary SIB permission. Their independent
+			// existing parser and storage/source contracts remain in charge.
+			var before Operand
+			var oldErr error
+			if memory, matched, err := parseX86SymbolIndexedMemory(source); matched {
+				before, oldErr = Operand{Kind: OpMem, Mem: memory}, err
+			} else {
+				before, oldErr = parseOperand(source)
+			}
+			after, err := parseOperandForArch(ArchAMD64, source)
+			if (err == nil) != (oldErr == nil) || err == nil && !reflect.DeepEqual(after, before) {
+				t.Fatalf("independent source role changed: %+v / %v != %+v / %v", after, err, before, oldErr)
+			}
+		})
+	}
+	for _, operand := range []Operand{
+		{Kind: OpSym, Sym: "$1(AX)(CX)"},
+		{Kind: OpMem, Mem: MemRef{Sym: "a+8(FP)", Base: AX, Index: CX}},
+		{Kind: OpMem, Mem: MemRef{Base: AX, Segment: FS, Index: CX}},
+		{Kind: OpMem, Mem: MemRef{Base: AX, Index: FS}},
+		{Kind: OpMem, Mem: MemRef{Base: AX}},
+		{Kind: OpMem, Mem: MemRef{Index: CX, Scale: 1}},
+	} {
+		if err := validateX86SourceMemoryScale(Instr{Args: []Operand{operand}}); err != nil {
+			t.Fatalf("non-SIB/valid missing-register role was rejected: %+v: %v", operand, err)
+		}
+	}
+	for _, scale := range []int64{0, -1, 3, 16} {
+		if err := validateX86SourceMemoryScale(Instr{Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: AX, Index: CX, Scale: scale}}}}); err == nil {
+			t.Fatalf("ordinary source SIB accepted scale %d", scale)
+		}
+	}
+	for _, marker := range []Instr{
+		{x86Encoded: true},
+		{x86SourceRaw: &x86SourceRawInstruction{}},
+	} {
+		marker.Args = []Operand{{Kind: OpMem, Mem: MemRef{Base: AX, Index: CX}}}
+		if err := validateX86SourceMemoryScale(marker); err != nil {
+			t.Fatal("source guard reclassified a decoded physical instruction")
+		}
+	}
+	// ARM64 keeps its independent unscaled-register memory convention.
+	operand, err := parseOperandForArch(ArchARM64, "(R0)(R1)")
+	if err != nil || operand.Mem.Index != "R1" || operand.Mem.Scale != 1 {
+		t.Fatalf("x86 source grammar changed ARM64: %+v / %v", operand, err)
+	}
+}
+
+func TestX86UnnamedAddressImmediateIgnoredRegisterInventory(t *testing.T) {
+	names := x86SymbolIndexedActualRegisterNames(t)
+	for _, arch := range []string{"386", "amd64"} {
+		prefixes := x86SymbolIndexedActualSegmentPrefixes(t, arch)
+		plain := x86PackedShiftActualGoBytes(t, arch, "TEXT addr(SB),4,$0-0\nADDL $1,DX\nRET\n")
+		for _, name := range names {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				// Both Reg and unscaled Index are source annotations in this
+				// TYPE_CONST row. No physical bank read follows from them.
+				source := "TEXT addr(SB),4,$0-0\nADDL $1(" + name + ")(" + name + "),DX\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				derived, changed, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+				if name == "TLS" {
+					// The independent original probe reports need-reloc/reloc,
+					// not a successful constant object or a source N/A proof.
+					// No native TLS producer is present in this fixture.
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unbound TLS source lost Context: %v", err)
+					}
+					return
+				}
+				original := x86PackedShiftActualGoBytes(t, arch, source)
+				want := plain
+				if prefix := prefixes[name]; prefix != 0 {
+					want = append([]byte{prefix}, plain...)
+				}
+				if !bytes.Equal(original, want) {
+					t.Fatalf("original TYPE_ADDR prefix/constant encoding differs: %x != %x", original, want)
+				}
+				if name == "CS" || name == "SS" || name == "DS" || name == "ES" || name == "FS" || name == "GS" || name == "TLS" {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unbound segment/TLS source lost Context: %v", err)
+					}
+					return
+				}
+				if err != nil || !changed || derived.Args[0].Kind != OpImm || derived.Args[0].Imm != 1 {
+					t.Fatalf("ignored source register became a physical input: %+v / %v", derived, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateScale0FiveLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := "TEXT ·addr(SB),4,$0-4\nMOVL $3,AX\nMOVL $2,CX\nMOVL $1,BX\n" +
+				"MOVL $1(AX),DX\nMOVL $1(CX*1),DX\nMOVL $1(AX)(CX*8),DX\n" +
+				"MOVB $1(X31)(Y20),BX\nMOVW $1(R15)(X31),BX\nADDL $1(AX)(CX),BX\n" +
+				"IMUL3L $1(AX)(CX),DX,BX\nCMPL BX,$1(AX)(CX)\n" +
+				"MOVL BX,ret+0(FP)\nRET\n"
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			pkg := x86AddSubLiteralPackage(t, target.arch, "func addr() uint32\n")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					if strings.Contains(ir, "%reg_X31") || strings.Contains(ir, "%reg_Y20") || strings.Contains(ir, "%reg_R15") {
+						t.Fatal("TYPE_CONST annotations acquired physical inputs")
+					}
+					compileLLVMToObject(t, llc, target.triple, "scale0.ll", "scale0.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_source_integer_address_test.go b/amd64_source_integer_address_test.go
new file mode 100644
index 000000000..c2ec8b2f5
--- /dev/null
+++ b/amd64_source_integer_address_test.go
@@ -0,0 +1,567 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// The source rewrite precedes oclass. Keep the complete actual stock-Go rule,
+// including its NAME_EXTERN/STATIC distinction; a version number is not proof.
+const x86SourceAddressGoRewrite = `
+if p.From.Type == obj.TYPE_ADDR && (ctxt.Arch.Family == sys.AMD64 || p.From.Name != obj.NAME_EXTERN && p.From.Name != obj.NAME_STATIC) {
+	switch p.As {
+	case AMOVL:
+		p.As = ALEAL
+		p.From.Type = obj.TYPE_MEM
+	case AMOVQ:
+		p.As = ALEAQ
+		p.From.Type = obj.TYPE_MEM
+	}
+}`
+
+func x86SourceAddressRewriteRule(source []byte) error {
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "obj6.go", source, 0)
+	if err != nil {
+		return err
+	}
+	count := 0
+	var actual string
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "progedit" || function.Body == nil {
+			continue
+		}
+		for _, statement := range function.Body.List {
+			conditional, ok := statement.(*ast.IfStmt)
+			if !ok {
+				continue
+			}
+			var condition bytes.Buffer
+			if err := format.Node(&condition, set, conditional.Cond); err != nil {
+				return err
+			}
+			if !strings.HasPrefix(condition.String(), "p.From.Type == obj.TYPE_ADDR &&") {
+				continue
+			}
+			count++
+			var body bytes.Buffer
+			if err := format.Node(&body, set, conditional); err != nil {
+				return err
+			}
+			actual = body.String()
+		}
+	}
+	if count != 1 || actual != strings.TrimSpace(x86SourceAddressGoRewrite) {
+		return fmt.Errorf("unrecognized stock-Go source-address rewrite (%d rules): %s", count, actual)
+	}
+	return nil
+}
+
+func TestX86UnnamedAddressImmediateActualGoSourceRule(t *testing.T) {
+	// This existing observer binds the invoked driver/asm and complete source
+	// bytes pre/post. Its float rewrite observation does not grant permissions.
+	x86ScalarLiteralActualGoRewriteSet(t)
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "obj6.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86SourceAddressRewriteRule(source); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("SOURCE_ADDRESS_REWRITE Go=%s SHA256=%x", runtime.Version(), sha256.Sum256(source))
+	for _, change := range [][2]string{
+		{"p.From.Type == obj.TYPE_ADDR &&", "p.From.Type == obj.TYPE_MEM &&"},
+		{"ctxt.Arch.Family == sys.AMD64 ||", "ctxt.Arch.Family == sys.I386 ||"},
+		{"p.From.Name != obj.NAME_EXTERN &&", "p.From.Name == obj.NAME_EXTERN &&"},
+		{"p.From.Name != obj.NAME_STATIC", "p.From.Name == obj.NAME_STATIC"},
+		{"case AMOVL:", "case AMOVW:"}, {"p.As = ALEAL", "p.As = AMOVL"},
+		{"p.From.Type = obj.TYPE_MEM", "p.From.Type = obj.TYPE_CONST"},
+		{"case AMOVQ:", "case AMOVB:"}, {"p.As = ALEAQ", "p.As = AMOVQ"},
+	} {
+		t.Run(change[0], func(t *testing.T) {
+			// Mutate the independently matched complete rule, not an earlier
+			// identical token in an unrelated obj6.go function.
+			copy := strings.Replace(x86SourceAddressGoRewrite, change[0], change[1], 1)
+			fixture := "package x86\nfunc progedit() {\n" + copy + "\n}\n"
+			if copy == x86SourceAddressGoRewrite || x86SourceAddressRewriteRule([]byte(fixture)) == nil {
+				t.Fatal("changed actual source rule was accepted")
+			}
+		})
+	}
+}
+
+func TestX86UnnamedAddressImmediateGoDoubleShiftRejectsTypeAddr(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, operation := range []string{"SHLW", "SHLL", "SHLQ", "SHRW", "SHRL", "SHRQ"} {
+			if arch == "386" && strings.HasSuffix(operation, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+operation, func(t *testing.T) {
+				source := "TEXT addr(SB),4,$0-0\n" + operation + " $16(AX),CX,BX\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+				// oclass alone is insufficient: movDoubleShift explicitly
+				// requires TYPE_CONST rather than this original TYPE_ADDR.
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, _, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch); err == nil {
+					t.Fatal("Go-invalid source identity was rewritten into a valid double shift")
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateImmutableAndProtected(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := Parse(ArchAMD64, "TEXT addr(SB),4,$0-0\nMOVL $16(AX)(CX*4),BX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		before := append([]Instr(nil), file.Funcs[0].Instrs...)
+		for index := range before {
+			before[index].Args = append([]Operand(nil), before[index].Args...)
+		}
+		derived, err := normalizeX86SourceIntegerAddresses(file, Options{Goarch: arch})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(before, file.Funcs[0].Instrs) || derived.Funcs[0].Instrs[1].Op != "LEAL" ||
+			derived.Funcs[0].Instrs[1].Raw != before[1].Raw {
+			t.Fatal("adapter changed source or lost its original source spelling")
+		}
+		again, err := normalizeX86SourceIntegerAddresses(derived, Options{Goarch: arch})
+		if err != nil || !reflect.DeepEqual(derived, again) {
+			t.Fatalf("adapter is not idempotent: %v", err)
+		}
+		for _, field := range []string{"addressBits", "addressOverride", "encoded", "LOCK", "rawText", "sourceStack", "fixedLocal"} {
+			t.Run(arch+"/"+field, func(t *testing.T) {
+				protected := *file
+				protected.Funcs = append([]Func(nil), file.Funcs...)
+				protected.Funcs[0].Instrs = append([]Instr(nil), before...)
+				switch field {
+				case "addressBits":
+					protected.Funcs[0].Instrs[1].x86AddressBits = 32
+				case "addressOverride":
+					protected.Funcs[0].Instrs[1].x86UnboundAddressOverride = true
+				case "encoded":
+					protected.Funcs[0].Instrs[1].x86Encoded = true
+				case "LOCK":
+					protected.Funcs[0].Instrs = append(protected.Funcs[0].Instrs, Instr{Op: "LOCK"})
+				case "rawText":
+					protected.Funcs[0].X86RawText = []byte{0xc3}
+				case "sourceStack":
+					protected.Funcs[0].x86SourceStack = &x86SourceStackProof{}
+				case "fixedLocal":
+					protected.Funcs[0].x86FixedLocal = &x86FixedLocalProof{}
+				}
+				if _, err := normalizeX86SourceIntegerAddresses(&protected, Options{Goarch: arch}); err == nil {
+					t.Fatal("address adapter inherited an unrelated original-source/encoder certificate")
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateSourceRoles(t *testing.T) {
+	for _, spelling := range []string{
+		"$·cell(SB)", "$local+16(SP)", "$arg+8(FP)", "16(AX)", "$16",
+		"$·cell(SB)(BX*4)", "$·cell(SB)(AX)(CX*2)",
+		"$runtime·mainPC+16(SB)", "$runtime·mainPC(SB)(BX)",
+		"$runtime·mainPC+16(SB)(BX*1)", "$runtime·mainPC-8(SB)(AX)(CX*4)",
+		"$local+16(SP)(BX*4)", "$arg+8(FP)(AX)(CX*2)",
+	} {
+		operand, err := parseOperandForArch(ArchAMD64, spelling)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, matched, err := x86UnnamedSourceAddress(operand); err != nil || matched {
+			t.Fatalf("independent source role was reclassified: %s: %v", spelling, err)
+		}
+	}
+	for _, address := range []string{"16(FS)", "8(AX)(GS*1)", "16(TLS)", "16(AX)(CX*3)", "16(AX)(CX*01)", "16(AX)(CX*4)(DX*2)"} {
+		operand := Operand{Kind: OpSym, Sym: "$" + address}
+		if _, matched, err := x86UnnamedSourceAddress(operand); !matched || err == nil {
+			t.Fatalf("unbound/invalid source address gained authority: %s / %v", address, err)
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateParenthesizedDisplacement(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, expression := range []string{"(1<<4)", "((1<<4))", "(8+(2*4))", "-((1<<4))"} {
+			t.Run(arch+"/"+expression, func(t *testing.T) {
+				instruction := "MOVW $" + expression + "(AX),BX"
+				fixture := "TEXT addr(SB),4,$0-0\n" + instruction + "\nRET\n"
+				original := x86PackedShiftActualGoBytes(t, arch, fixture)
+				literal := "16"
+				if strings.HasPrefix(expression, "-") {
+					literal = "-16"
+				}
+				plain := x86PackedShiftActualGoBytes(t, arch, strings.Replace(fixture, "$"+expression+"(AX)", "$"+literal, 1))
+				if !bytes.Equal(original, plain) {
+					t.Fatalf("original constant expression changed its encoding: %x != %x", original, plain)
+				}
+				file, err := Parse(ArchAMD64, fixture)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Ret: Void}}}); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+// This matrix is independent of the adapter: classify actual signed offsets
+// from the complete Yi8/Yu8/Yi32 source domains, including the 386 truncation.
+func TestX86UnnamedAddressImmediateCompleteLiteralClassBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, family := range []string{
+			"MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST",
+			"IMUL", "IMUL3", "PUSH", "BT", "BTC", "BTR", "BTS",
+			"SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR",
+		} {
+			for _, suffix := range []string{"B", "W", "L", "Q"} {
+				if family == "MOV" && (suffix == "L" || suffix == "Q") ||
+					suffix == "B" && (strings.HasPrefix(family, "IMUL") || strings.HasPrefix(family, "BT") || family == "PUSH") {
+					continue
+				}
+				for _, value := range []int64{
+					-2147483649, -2147483648, -129, -128, -1, 0, 1, 3, 4, 127,
+					128, 255, 256, 2147483647, 2147483648, 4294967295, 4294967296,
+				} {
+					operation := family + suffix
+					literal := value
+					if arch == "386" {
+						literal = int64(int32(value))
+					}
+					accepted := literal >= -2147483648 && literal <= 4294967295
+					if strings.HasPrefix(family, "BT") {
+						accepted = literal >= -128 && literal <= 127
+					} else if family == "SAL" || family == "SHL" || family == "SHR" || family == "SAR" ||
+						family == "ROL" || family == "ROR" || family == "RCL" || family == "RCR" {
+						accepted = literal >= 0 && literal <= 255 // Yi8 does not cover Yu8.
+					}
+					if arch == "386" && suffix == "Q" || family == "PUSH" &&
+						(suffix == "L" && arch != "386" || suffix == "Q" && arch != "amd64") {
+						accepted = false
+					}
+					t.Run(fmt.Sprintf("%s/%s/%d", arch, operation, value), func(t *testing.T) {
+						annotation := fmt.Sprintf("$%d(AX)(CX*1)", value)
+						operands := annotation + ",BX"
+						if family == "CMP" {
+							operands = "BX," + annotation
+						} else if family == "IMUL3" {
+							operands = annotation + ",CX,BX"
+						} else if family == "PUSH" {
+							operands = annotation
+						}
+						ending := "RET\n"
+						if family == "PUSH" {
+							ending = "POP" + suffix + " BX\nRET\n"
+						}
+						fixture := "TEXT addr(SB),4,$0-0\n" + operation + " " + operands + "\n" + ending
+						listing, goErr := x86ScalarLiteralExpectedGoListing(t, arch, fixture, accepted)
+						if !accepted {
+							t.Logf("ACTUAL_TYPE_ADDR_REJECTION arch=%s instruction=%q error=%v diagnostic=%q", arch, operation+" "+operands, goErr, listing)
+						}
+						file, err := Parse(ArchAMD64, fixture)
+						if err != nil {
+							t.Fatal(err)
+						}
+						_, _, err = normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+						if (err == nil) != accepted {
+							t.Fatalf("literal class mismatch: accepted=%v: %v", accepted, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateDefaultMode(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT addr(SB),4,$0-0\nMOVL $3,AX\nMOVL $16(AX),BX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Sigs: map[string]FuncSig{"addr": {Ret: Void}}}
+	if _, err := normalizeX86SourceIntegerAddresses(file, options); err != nil {
+		t.Fatalf("default AMD64 mode was lost: %v", err)
+	}
+	if _, err := Translate(file, options); err != nil {
+		t.Fatal(err)
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86UnnamedAddressImmediateUnresolvedDisplacement(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, instruction := range []string{"MOVL $UNKNOWN(AX),BX", "MOVW $UNKNOWN(AX)(CX*1),BX"} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT addr(SB),4,$0-0\n" + instruction + "\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Ret: Void}}}); err == nil {
+					t.Fatal("unresolved displacement became a zero-valued literal")
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateThreeAPIsCannotGrantSourceRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, instruction := range []string{
+			"MOVL $16(AX),X0", "MOVL $16(AX),(BX)",
+			"MOVL $UNKNOWN(AX),BX", "MOVW $UNKNOWN(AX)(CX*1),BX",
+			"MOVW $16(FS),BX", "MOVL $16(AX)(GS*1),BX",
+			"MOVL $16(AX)(SP*1),BX", "MOVW $16(AX)(CX*3),BX",
+			"ADDW $16(AX),$8(BX)", "FMOVD $16(AX),F0",
+			"FMOVDP F0,$16(AX)", "MOVSS $16(AX),X0",
+			"SHRW $16(AX),CX,BX", "MOVB $16(AX),BX\nMOVQ BX,(SP)\nBYTE $0xc3",
+		} {
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				source := "TEXT ·addr(SB),4,$0-0\n" + instruction + "\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func addr()\n")
+				resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						var err error
+						switch api {
+						case "text":
+							_, err = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, err = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								result.Module.Dispose()
+							}
+						}
+						if err == nil {
+							t.Fatal("source adapter supplied an unproved memory/encoder/operand role")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateSignExtendedImm32(t *testing.T) {
+	for _, operation := range []string{"ADDQ", "SUBQ", "ADCQ", "SBBQ", "ANDQ", "ORQ", "XORQ", "TESTQ", "CMPQ", "IMULQ", "IMUL3Q", "PUSHQ"} {
+		for _, value := range []string{"0x80000000", "0xffffffff"} {
+			t.Run(operation+"/"+value, func(t *testing.T) {
+				operands := "$" + value + "(AX),BX"
+				if operation == "CMPQ" {
+					operands = "BX,$" + value + "(AX)"
+				} else if operation == "IMUL3Q" {
+					operands = "$" + value + "(AX),CX,BX"
+				} else if operation == "PUSHQ" {
+					operands = "$" + value + "(AX)"
+				}
+				instruction := operation + " " + operands
+				ending := "RET\n"
+				if operation == "PUSHQ" {
+					ending = "POPQ BX\nRET\n"
+				}
+				fixture := "TEXT addr(SB),4,$0-0\n" + instruction + "\n" + ending
+				original := x86PackedShiftActualGoBytes(t, "amd64", fixture)
+				integer, _ := parseImmExpr(value)
+				want := int64(int32(integer))
+				// The signed spelling can select shorter imm8 bytes. Bind the
+				// actual original instruction's decoded imm32 value instead of
+				// claiming that the two source classes have identical widths.
+				decoded, err := x86asm.Decode(original, 64)
+				if err != nil {
+					t.Fatal(err)
+				}
+				found := false
+				for _, argument := range decoded.Args {
+					if immediate, ok := argument.(x86asm.Imm); ok {
+						found = true
+						if int64(immediate) != want {
+							t.Fatalf("actual Go decoded imm32=%d, want %d; original=%x", immediate, want, original)
+						}
+					}
+				}
+				if !found {
+					t.Fatalf("actual Go source has no physical immediate: %x", original)
+				}
+				t.Logf("ORIGINAL_SIGNEXT %s %s bytes=%x decoded=%s", operation, value, original, decoded)
+				file, err := Parse(ArchAMD64, fixture)
+				if err != nil {
+					t.Fatal(err)
+				}
+				derived, changed, err := normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], "amd64")
+				if err != nil || !changed {
+					t.Fatalf("source imm32 class: %v", err)
+				}
+				index := 0
+				if operation == "CMPQ" {
+					index = 1
+				}
+				if derived.Args[index].Kind != OpImm || derived.Args[index].Imm != want {
+					t.Fatalf("native imm32 widened as %d, want %d", derived.Args[index].Imm, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediatePushSourceModes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, suffix := range []string{"B", "W", "L", "Q"} {
+			for _, value := range []string{"-128", "127", "128", "0xffffffff"} {
+				t.Run(arch+"/"+suffix+"/"+value, func(t *testing.T) {
+					valid := suffix == "W" || arch == "386" && suffix == "L" || arch == "amd64" && suffix == "Q"
+					fixture := "TEXT addr(SB),4,$0-0\nPUSH" + suffix + " $" + value + "(AX)(CX*1)\nPOP" + suffix + " BX\nRET\n"
+					if valid {
+						original := x86PackedShiftActualGoBytes(t, arch, fixture)
+						plain := strings.ReplaceAll(fixture, "(AX)(CX*1)", "")
+						if !bytes.Equal(original, x86PackedShiftActualGoBytes(t, arch, plain)) {
+							t.Fatal("PUSH TYPE_ADDR was treated as an effective address")
+						}
+					} else {
+						x86ScalarLiteralExpectedGoListing(t, arch, fixture, false)
+					}
+					file, err := Parse(ArchAMD64, fixture)
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, _, err = normalizeX86SourceIntegerAddress(file.Funcs[0].Instrs[1], arch)
+					if (err == nil) != valid {
+						t.Fatalf("PUSH source mode %s/%s: %v", arch, suffix, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateThreeAPIsFiveLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			pkg := x86AddSubLiteralPackage(t, target.arch, "func addr() uint32\n")
+			var source strings.Builder
+			source.WriteString("TEXT ·addr(SB),4,$0-4\nMOVL $3,AX\nMOVL $2,CX\nMOVL $1,BX\nCLC\n")
+			for _, stem := range []string{"MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST", "SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR", "IMUL", "IMUL3", "BT", "BTC", "BTR", "BTS"} {
+				for _, suffix := range []string{"B", "W", "L", "Q"} {
+					if suffix == "Q" && target.arch == "386" || suffix == "B" && (strings.HasPrefix(stem, "IMUL") || strings.HasPrefix(stem, "BT")) {
+						continue
+					}
+					operands := "$16(AX)(CX*1),BX"
+					if stem == "CMP" {
+						operands = "BX,$16(AX)(CX*1)"
+					} else if stem == "IMUL3" {
+						operands = "$16(AX)(CX*1),CX,BX"
+					}
+					fmt.Fprintf(&source, "%s%s %s\n", stem, suffix, operands)
+				}
+			}
+			// TYPE_CONST ignores source Reg/Index, including non-GP banks.
+			// These are not physical register availability grants in mode32.
+			source.WriteString("MOVB $16(X31)(Y20*1),BX\nMOVW $8(R15)(X30*4),BX\nPUSHW $128(X31)\nPOPW DX\n")
+			if target.arch == "amd64" {
+				source.WriteString("PUSHQ $-128(Y20)\nPOPQ DX\n")
+			} else {
+				source.WriteString("PUSHL $-128(Y20)\nPOPL DX\n")
+			}
+			source.WriteString("MOVL BX,ret+0(FP)\nRET\n")
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					if strings.Contains(ir, "%reg_X31") || strings.Contains(ir, "%reg_Y20") || strings.Contains(ir, "%reg_R15") || strings.Contains(ir, "%reg_X30") {
+						t.Fatal("discarded constant annotations became physical register inputs")
+					}
+					compileLLVMToObject(t, llc, target.triple, "source-address.ll", "source-address.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_source_tls.go b/amd64_source_tls.go
new file mode 100644
index 000000000..f37933ddc
--- /dev/null
+++ b/amd64_source_tls.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import "strings"
+
+// This is a source-address role, not an ordinary SIB address or permission to
+// load memory. Go obj6.progedit may remove the GP base and TLS index altogether;
+// asm6.prefixof/vaddr may instead supply a segment and TLS relocation. Selection
+// depends on GOOS, GOARCH and -shared, not just the spelling or target triple.
+// Callers must return Context for this role until those native facts are bound.
+func x86SourceTLSMemoryRole(operand Operand, arch string) bool {
+	if operand.Kind != OpMem {
+		return false
+	}
+	memory := operand.Mem
+	if memory.Base != TLS && memory.Index != TLS {
+		return false
+	}
+	if memory.OffRaw != "" || memory.IndexExt != "" ||
+		memory.Off != int64(int32(memory.Off)) && !(arch == "386" && memory.Off == int64(uint32(memory.Off))) ||
+		memory.Segment != "" && memory.Segment != FS && memory.Segment != GS {
+		return false
+	}
+	if memory.Index == "" {
+		if memory.Scale != 0 {
+			return false
+		}
+	} else if memory.Scale != 0 && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+		return false
+	}
+	if memory.Sym != "" {
+		return x86SourceNamedTLSMemoryRole(memory, arch)
+	}
+	if memory.Base == TLS {
+		return memory.Segment == "" && (memory.Index == "" || memory.Index == TLS)
+	}
+	if memory.Index != TLS {
+		return false
+	}
+	switch memory.Base {
+	case "", CS, SS, DS, ES, FS, GS:
+		return true // asm6 also accepts an index-only or segment-base annotation.
+	default:
+		// Direct-TLS progedit may remove any AX..R15 source base before
+		// physical mode32 classification. It is still an unbound TLS role.
+		return isAMD64YrlRegister(memory.Base)
+	}
+}
+
+func x86SourceNamedTLSMemoryRole(memory MemRef, arch string) bool {
+	if memory.Segment != "" {
+		return false
+	}
+	symbol := strings.TrimSpace(memory.Sym)
+	var role string
+	for _, suffix := range []string{"(SB)", "(FP)", "(SP)"} {
+		if strings.HasSuffix(symbol, suffix) {
+			role = suffix
+			break
+		}
+	}
+	if role == "" {
+		return false
+	}
+	name, _, valid := parseFP(strings.TrimSuffix(symbol, role) + "(FP)")
+	if !valid || name == "" || name[0] >= '0' && name[0] <= '9' || strings.IndexAny(name, "*/&|^%=!$:[]") >= 0 {
+		return false
+	}
+	if arch == "amd64" {
+		// Named SB is RIP-based and cannot carry TLS. PARAM/AUTO may carry
+		// a TLS Index, but their source Reg must still be absent or SP.
+		return role != "(SB)" && (memory.Base == "" || memory.Base == SP) && memory.Index == TLS
+	}
+	// The 386 named-memory encoder ignores Reg, except that progedit may
+	// rewrite it before encoding. Index still has its own address role.
+	if memory.Base != "" && !x86SymbolGoRegisterName(string(memory.Base)) {
+		return false
+	}
+	return memory.Index == "" || memory.Index == TLS ||
+		memory.Index != SP && isX86YrlRegisterForArch(memory.Index, arch)
+}
diff --git a/amd64_source_tls_move.go b/amd64_source_tls_move.go
new file mode 100644
index 000000000..ff92605ea
--- /dev/null
+++ b/amd64_source_tls_move.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import "fmt"
+
+func validateX86TLSMoveFile(file *File, arch string) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if err := x86SourceTLSMoveError(instruction, arch); err != nil {
+				return fmt.Errorf("%s: %w", function.Sym, err)
+			}
+		}
+	}
+	return nil
+}
+
+// Validate TLS's complete ymovb/w/l/q memory rows before scalar, MMX or XMM
+// dispatch. This does not rewrite TLS to a GP register or a guessed segment.
+// No API here owns Go's runtime TLS relocation, g layout or thread transport.
+func x86SourceTLSMoveError(ins Instr, arch string) error {
+	form, present, err := x86TLSMoveProperties(ins, arch)
+	if !present || err != nil {
+		return err
+	}
+	if form.memory < 0 {
+		return fmt.Errorf("%w: %s needs its actual Go OS/arch/shared TLS source contract: %q", ErrProbeNeedsContext, ins.Op, ins.Raw)
+	}
+	return fmt.Errorf("%w: %s TLS memory needs its actual Go OS/arch/shared progedit, relocation and native TLS address contract: %q", ErrProbeNeedsContext, ins.Op, ins.Raw)
+}
diff --git a/amd64_sqrt_forms.go b/amd64_sqrt_forms.go
new file mode 100644
index 000000000..a046f1a89
--- /dev/null
+++ b/amd64_sqrt_forms.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86SqrtSpec struct {
+	bits           int
+	legacy, scalar bool
+}
+
+// Complete named Go family. Raw-only FP16 has a distinct physical grammar.
+var x86SqrtSpecs = map[Op]x86SqrtSpec{
+	"SQRTSS": {32, true, true}, "SQRTSD": {64, true, true},
+	"SQRTPS": {32, true, false}, "SQRTPD": {64, true, false},
+	"VSQRTSS": {32, false, true}, "VSQRTSD": {64, false, true},
+	"VSQRTPS": {32, false, false}, "VSQRTPD": {64, false, false},
+}
+
+func x86SqrtSpecFor(base Op) (x86SqrtSpec, bool) {
+	if base == "VSQRTPH" || base == "VSQRTSH" {
+		return x86SqrtSpec{bits: 16, scalar: base == "VSQRTSH"}, true
+	}
+	spec, known := x86SqrtSpecs[base]
+	return spec, known
+}
+
+func x86SqrtProperties(ins Instr, arch string) (x86FloatBinaryForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86SqrtSpecFor(Op(base))
+	if !known {
+		return x86FloatBinaryForm{}, false, nil
+	}
+	if spec.bits == 16 && !ins.x86Encoded {
+		return x86FloatBinaryForm{}, true, fmt.Errorf("%s has no named Go assembler form; raw encoding required", ins.Op)
+	}
+	f, err := x86FloatOperandProperties(ins, arch, spec.bits, spec.legacy, spec.scalar, false, !spec.scalar, "sqrt")
+	if err != nil {
+		return f, true, err
+	}
+	if spec.bits == 16 && ins.Args[0].Kind == OpMem {
+		memory := ins.Args[0].Mem
+		if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+			return f, true, err
+		}
+		if memory.OffRaw != "" || memory.IndexExt != "" {
+			return f, true, fmt.Errorf("%s has an unresolved memory displacement or extension", ins.Op)
+		}
+	}
+	// Go's pre-encoding vector names are not physical mode32 registers.
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg {
+			index, vector := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+			if vector && arch == "386" && index >= 8 {
+				return f, true, fmt.Errorf("%w: %s register %s has no physical mode32 binding", ErrProbeNeedsContext, ins.Op, operand.Reg)
+			}
+		}
+	}
+	return f, true, nil
+}
+
+func x86SqrtNativeEVEX(ins Instr, form x86FloatBinaryForm) bool {
+	if form.legacy {
+		return false
+	}
+	if form.bits == 16 || ins.x86SqrtEVEX || form.byteWidth == 64 || form.mask >= 0 || form.broadcast || form.rounding != "" {
+		return true
+	}
+	for _, operand := range ins.Args {
+		if index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth); valid && index >= 16 {
+			return true
+		}
+	}
+	return false
+}
+
+// Numerical definedness is shared by result and caller analysis. This says
+// nothing about the backing or validity of a memory source. The caller must
+// establish that separately before supplying its conditional source bytes.
+func x86SqrtDefinedBytes(f x86FloatBinaryForm, source, upper, old uint64) (uint64, bool) {
+	width := f.byteWidth
+	if f.scalar {
+		width = f.bits / 8
+	}
+	required := x86CallerVectorByteMask(int64(width))
+	if source&required != required || f.mask >= 0 && !f.zeroing && old&required != required {
+		return 0, false
+	}
+	if f.legacy {
+		return old | required, true
+	}
+	if f.scalar {
+		return ^uint64(0xffff) | required | upper&(0xffff&^required), true
+	}
+	return ^uint64(0), true
+}
diff --git a/amd64_stack_address_defect_test.go b/amd64_stack_address_defect_test.go
new file mode 100644
index 000000000..b7151f675
--- /dev/null
+++ b/amd64_stack_address_defect_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// PUSHW's Pe row classifies this as Yi32 but calls vaddr without a relocation
+// sink. This observes that backend defect, not an invalid source form or a
+// successful Go object. The ordinary rejection oracle must not accept it.
+func TestX86StackNamedAddressRelocationSinkDefect(t *testing.T) {
+	const original = "TEXT ·Value(SB),4,$0-0\nPUSHW $other·cell(SB)\nPOPW AX\nRET\n"
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "forms.s"), filepath.Join(dir, "forms.o")
+	if err := os.WriteFile(source, []byte(original), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "asm",
+		"-p", "example.com/forms", "-o", object, source)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=386", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	exit, ok := err.(*exec.ExitError)
+	const diagnostic = "asm: need reloc for $other.cell(SB)\nasm: reloc\n"
+	if ctx.Err() != nil || !ok || exit.ProcessState == nil || !exit.ProcessState.Exited() ||
+		exit.ExitCode() != 1 || string(output) != diagnostic {
+		t.Fatalf("unknown PUSHW backend observation: %v; context %v\n%s", err, ctx.Err(), output)
+	}
+	if goAssemblerOracleOutcome(source, object, output, err, ctx.Err(), false, "386") == nil {
+		t.Fatal("relocation emitter defect became a source-rejection certificate")
+	}
+	if data, err := os.ReadFile(source); err != nil || string(data) != original {
+		t.Fatal("backend observation lost its original source", err)
+	}
+	t.Log("GO_ASSEMBLER_DEFECT_OBSERVATION: PUSHW missing relocation sink; not Go form-rejection or object-compilation evidence")
+}
diff --git a/amd64_stack_address_immediate_test.go b/amd64_stack_address_immediate_test.go
new file mode 100644
index 000000000..284a3b086
--- /dev/null
+++ b/amd64_stack_address_immediate_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86StackPushNamedAddressIsImmediateNotMemory(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, operand := range []string{
+		"$·cell(SB)", "$·cell+8(SB)", "$·cell-8(SB)",
+		"$other·cell(SB)", "$cell<>(SB)", "$runtime·mainPC(SB)",
+		"$·cell+8(SB)(AX)", "$·cell-8(SB)(CX*4)",
+		"$·cell(SB)(R8)(X1*4)",
+	} {
+		t.Run(operand, func(t *testing.T) {
+			source := "TEXT ·Value(SB),4,$0-0\nPUSHL " + operand + "\nPOPL AX\nRET\n"
+			goAssemblerOracleOutput(t, "386", source, "", true)
+			parsed, err := parseOperandForArch(ArchAMD64, operand)
+			if err != nil || parsed.Kind != OpSym || isAMD64MemoryOperand(parsed) {
+				t.Fatalf("named address lost its independent immediate identity: %#v: %v", parsed, err)
+			}
+			for _, target := range x86AddressMemoryTargets("386") {
+				for _, api := range []string{"text", "module", "go"} {
+					t.Run(target+"/"+api, func(t *testing.T) {
+						ir, err := x86AddressMemoryAPI(t, api, source, "386", target)
+						if err != nil {
+							t.Fatal("Go-accepted absolute address immediate was rejected:", err)
+						}
+						if !strings.Contains(ir, "ptrtoint ptr") || strings.Contains(ir, "load i32, ptr @") {
+							t.Fatal("PUSHL acquired a symbolic load instead of the relocation's address")
+						}
+						x86ResultInitializationObject(t, llc, target, ir, "push-address")
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86StackNamedAddressModeAndDestinationBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"PUSHW", "PUSHL", "PUSHQ", "POPW", "POPL", "POPQ"} {
+			if arch == "386" && (op == "PUSHL" || op == "PUSHW") {
+				// Only PUSHL has a valid four-byte relocation emitter. The
+				// selected assembler's PUSHW Pe path supplies no relocation
+				// sink; table-class acceptance is not a source-object proof.
+				continue
+			}
+			for _, operand := range []string{"$·cell(SB)", "$·cell+8(SB)"} {
+				instruction := op + " " + operand
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					for _, target := range x86AddressMemoryTargets(arch) {
+						for _, api := range []string{"text", "module", "go"} {
+							t.Run(target+"/"+api, func(t *testing.T) {
+								if _, err := x86AddressMemoryAPI(t, api, source, arch, target); err == nil {
+									t.Fatal("named address granted a source mode or memory destination outside Go's rules")
+								}
+							})
+						}
+					}
+				})
+			}
+		}
+	}
+
+	for _, arch := range []string{"386", "amd64"} {
+		push, pop := "PUSHQ", "POPQ"
+		if arch == "386" {
+			push, pop = "PUSHL", "POPL"
+		}
+		for _, address := range []string{"$arg+0(FP)", "$local-8(SP)"} {
+			instruction := push + " " + address
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$16-0\n%s\n%s AX\nRET\n", instruction, pop)
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				for _, target := range x86AddressMemoryTargets(arch) {
+					for _, api := range []string{"text", "module", "go"} {
+						if _, err := x86AddressMemoryAPI(t, api, source, arch, target); err == nil {
+							t.Fatal("AUTO/PARAM address acquired an absolute immediate or native stack contract")
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_stack_address_rules_test.go b/amd64_stack_address_rules_test.go
new file mode 100644
index 000000000..f438a79a2
--- /dev/null
+++ b/amd64_stack_address_rules_test.go
@@ -0,0 +1,315 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86StackAddressEncoderCarrier(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "asm6.go", source, 0)
+	if err != nil {
+		return err
+	}
+	canonical := func(node ast.Node) string {
+		var output bytes.Buffer
+		if err := format.Node(&output, token.NewFileSet(), node); err != nil {
+			return ""
+		}
+		return output.String()
+	}
+	variables := make(map[string]*ast.CompositeLit)
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			functions[function.Name.Name] = function
+		}
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok || general.Tok != token.VAR {
+			continue
+		}
+		for _, spec := range general.Specs {
+			value := spec.(*ast.ValueSpec)
+			for index, name := range value.Names {
+				if index < len(value.Values) {
+					if literal, ok := value.Values[index].(*ast.CompositeLit); ok {
+						variables[name.Name] = literal
+					}
+				}
+			}
+		}
+	}
+	const table = `[]ytab{
+		{Zrp_, 1, argList{Yrl}},
+		{Zm_o, 2, argList{Ym}},
+		{Zib_, 1, argList{Yi8}},
+		{Zil_, 1, argList{Yi32}},
+	}`
+	wantTable, err := parser.ParseExpr(table)
+	if err != nil || variables["ypushl"] == nil || canonical(variables["ypushl"]) != canonical(wantTable) {
+		return fmt.Errorf("complete ordered PUSH operand/encoder rows changed")
+	}
+	registrations := map[string]string{
+		"APUSHL": `{APUSHL, ypushl, P32, opBytes{0x50, 0xff, 06, 0x6a, 0x68}}`,
+		"APUSHQ": `{APUSHQ, ypushl, Py, opBytes{0x50, 0xff, 06, 0x6a, 0x68}}`,
+		"APUSHW": `{APUSHW, ypushl, Pe, opBytes{0x50, 0xff, 06, 0x6a, 0x68}}`,
+	}
+	optab := variables["optab"]
+	if optab == nil {
+		return fmt.Errorf("missing complete Go opcode table")
+	}
+	seen := make(map[string]bool)
+	for _, entry := range optab.Elts {
+		row, ok := entry.(*ast.CompositeLit)
+		if !ok || len(row.Elts) == 0 {
+			continue
+		}
+		name := canonical(row.Elts[0])
+		text, relevant := registrations[name]
+		if !relevant {
+			continue
+		}
+		want, err := parser.ParseExpr("[]Optab{" + text + "}")
+		if err != nil || seen[name] || canonical(row) != canonical(want.(*ast.CompositeLit).Elts[0]) {
+			return fmt.Errorf("complete PUSH registration changed: %s", name)
+		}
+		seen[name] = true
+	}
+	if len(seen) != len(registrations) {
+		return fmt.Errorf("incomplete PUSH opcode inventory")
+	}
+	const absolute = `package reference
+func useAbs(ctxt *obj.Link, s *obj.LSym) bool {
+	if ctxt.Headtype == objabi.Hsolaris {
+		return strings.HasPrefix(s.Name, "libc_")
+	}
+	return ctxt.Arch.Family == sys.I386 && !ctxt.Flag_shared
+}`
+	wantAbsolute, err := parser.ParseFile(token.NewFileSet(), "reference.go", absolute, 0)
+	if err != nil || functions["useAbs"] == nil ||
+		canonical(functions["useAbs"]) != canonical(wantAbsolute.Decls[0]) {
+		return fmt.Errorf("absolute-relocation source mode changed")
+	}
+	const address = `package reference
+func oclass() { switch kind {
+case obj.TYPE_ADDR:
+	switch a.Name {
+	case obj.NAME_GOTREF:
+		ctxt.Diag("unexpected TYPE_ADDR with NAME_GOTREF")
+		return Yxxx
+	case obj.NAME_EXTERN, obj.NAME_STATIC:
+		if a.Sym != nil && useAbs(ctxt, a.Sym) { return Yi32 }
+		return Yiauto
+	case obj.NAME_AUTO, obj.NAME_PARAM:
+		return Yiauto
+	}
+	if a.Sym != nil && strings.HasPrefix(a.Sym.Name, "runtime.duff") { return Yi32 }
+	if a.Sym != nil || a.Name != obj.NAME_NONE { ctxt.Diag("unexpected addr: %v", obj.Dconv(p, a)) }
+	fallthrough
+} }`
+	wantAddress, err := parser.ParseFile(token.NewFileSet(), "reference.go", address, 0)
+	if err != nil || functions["oclass"] == nil {
+		return fmt.Errorf("missing complete address classifier")
+	}
+	findAddress := func(function *ast.FuncDecl) *ast.CaseClause {
+		var result *ast.CaseClause
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			clause, ok := node.(*ast.CaseClause)
+			if !ok {
+				return true
+			}
+			for _, expression := range clause.List {
+				if canonical(expression) == "obj.TYPE_ADDR" {
+					result = clause
+				}
+			}
+			return true
+		})
+		return result
+	}
+	actualAddress := findAddress(functions["oclass"])
+	if actualAddress == nil || canonical(actualAddress) != canonical(findAddress(wantAddress.Decls[0].(*ast.FuncDecl))) {
+		return fmt.Errorf("complete named address classification changed")
+	}
+	const emitter = `package reference
+func doasm() { switch encoding {
+case Z_il, Zil_:
+	var a *obj.Addr
+	if yt.zcase == Zil_ { a = &p.From } else { a = &p.To }
+	ab.Put1(byte(op))
+	if o.prefix == Pe {
+		v := vaddr(ctxt, p, a, nil)
+		ab.PutInt16(int16(v))
+	} else { ab.relput4(ctxt, cursym, p, a) }
+} }`
+	findEmitter := func(function *ast.FuncDecl) *ast.CaseClause {
+		if function == nil {
+			return nil
+		}
+		var result *ast.CaseClause
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			clause, ok := node.(*ast.CaseClause)
+			if ok && len(clause.List) == 2 && canonical(clause.List[0]) == "Z_il" && canonical(clause.List[1]) == "Zil_" {
+				result = clause
+			}
+			return true
+		})
+		return result
+	}
+	actualEmitter := findEmitter(functions["doasm"])
+	emitterMatched := false
+	oldEmitter := strings.Replace(emitter, "\tvar a *obj.Addr\n", "", 1)
+	oldEmitter = strings.Replace(oldEmitter, "v := vaddr", "v = vaddr", 1)
+	for _, reference := range []string{emitter, oldEmitter} {
+		want, err := parser.ParseFile(token.NewFileSet(), "reference.go", reference, 0)
+		if err == nil && actualEmitter != nil && canonical(actualEmitter) == canonical(findEmitter(want.Decls[0].(*ast.FuncDecl))) {
+			emitterMatched = true
+		}
+	}
+	if !emitterMatched {
+		return fmt.Errorf("complete PUSH relocation emitter changed")
+	}
+	const relocation = `package reference
+func (ab *AsmBuf) relput4(ctxt *obj.Link, cursym *obj.LSym, p *obj.Prog, a *obj.Addr) {
+	var rel obj.Reloc
+	v := vaddr(ctxt, p, a, &rel)
+	if rel.Siz != 0 {
+		if rel.Siz != 4 { ctxt.Diag("bad reloc") }
+		rel.Off = int32(p.Pc + int64(ab.Len()))
+		cursym.AddRel(ctxt, rel)
+	}
+	ab.PutInt32(int32(v))
+}`
+	oldRelocation := strings.Replace(relocation,
+		"rel.Off = int32(p.Pc + int64(ab.Len()))\n\t\tcursym.AddRel(ctxt, rel)",
+		"r := obj.Addrel(cursym)\n\t\t*r = rel\n\t\tr.Off = int32(p.Pc + int64(ab.Len()))", 1)
+	relocationMatched := false
+	for _, reference := range []string{relocation, oldRelocation} {
+		want, err := parser.ParseFile(token.NewFileSet(), "reference.go", reference, 0)
+		if err == nil && functions["relput4"] != nil && canonical(functions["relput4"]) == canonical(want.Decls[0]) {
+			relocationMatched = true
+		}
+	}
+	if !relocationMatched {
+		return fmt.Errorf("complete four-byte relocation sink changed")
+	}
+	const value = `package reference
+func vaddr(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r *obj.Reloc) int64 {
+	if r != nil { *r = obj.Reloc{} }
+	switch a.Name {
+	case obj.NAME_STATIC, obj.NAME_GOTREF, obj.NAME_EXTERN:
+		s := a.Sym
+		if r == nil {
+			ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
+			log.Fatalf("reloc")
+		}
+		if a.Name == obj.NAME_GOTREF {
+			r.Siz = 4
+			r.Type = objabi.R_GOTPCREL
+		} else if useAbs(ctxt, s) {
+			r.Siz = 4
+			r.Type = objabi.R_ADDR
+		} else {
+			r.Siz = 4
+			r.Type = objabi.R_PCREL
+		}
+		r.Off = -1
+		r.Sym = s
+		r.Add = a.Offset
+		return 0
+	}
+	if (a.Type == obj.TYPE_MEM || a.Type == obj.TYPE_ADDR) && a.Reg == REG_TLS {
+		if r == nil {
+			ctxt.Diag("need reloc for %v", obj.Dconv(p, a))
+			log.Fatalf("reloc")
+		}
+		if !ctxt.Flag_shared || isAndroid || ctxt.Headtype == objabi.Hdarwin {
+			r.Type = objabi.R_TLS_LE
+			r.Siz = 4
+			r.Off = -1
+			r.Add = a.Offset
+		}
+		return 0
+	}
+	return a.Offset
+}`
+	wantValue, err := parser.ParseFile(token.NewFileSet(), "reference.go", value, 0)
+	if err != nil || functions["vaddr"] == nil || canonical(functions["vaddr"]) != canonical(wantValue.Decls[0]) {
+		return fmt.Errorf("complete relocation value calculation changed")
+	}
+	return nil
+}
+
+func TestX86StackNamedAddressCompleteGoRuleCarrier(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86StackAddressEncoderCarrier(source); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ name, from, to string }{
+		{"class", "{Zil_, 1, argList{Yi32}}", "{Zil_, 1, argList{Yiauto}}"},
+		{"arity", "{Zil_, 1, argList{Yi32}}", "{Zil_, 1, argList{Yi32, Yrl}}"},
+		{"encoder", "{Zil_, 1, argList{Yi32}}", "{Zib_, 1, argList{Yi32}}"},
+		{"offset", "{Zil_, 1, argList{Yi32}}", "{Zil_, 2, argList{Yi32}}"},
+		{"mode", "{APUSHL, ypushl, P32,", "{APUSHL, ypushl, Py,"},
+		{"bytes", "{APUSHL, ypushl, P32, opBytes{0x50,", "{APUSHL, ypushl, P32, opBytes{0x51,"},
+		{"shared", "return ctxt.Arch.Family == sys.I386 && !ctxt.Flag_shared", "return ctxt.Arch.Family == sys.I386"},
+		{"absolute", "if a.Sym != nil && useAbs(ctxt, a.Sym) {", "if a.Sym != nil {"},
+		{"emitter", "case Z_il, Zil_:", "case Z_il, Zil_rr:"},
+		{"operand direction", "if yt.zcase == Zil_ {", "if yt.zcase == Z_il {"},
+		{"relocation sink", "v := vaddr(ctxt, p, a, &rel)", "v := vaddr(ctxt, p, a, nil)"},
+		{"absolute relocation", "} else if useAbs(ctxt, s) {", "} else if s != nil {"},
+		{"missing sink", "log.Fatalf(\"reloc\")", "return 0"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			if !strings.Contains(string(source), mutation.from) {
+				t.Fatal("mutation missed its actual source rule")
+			}
+			changed := strings.Replace(string(source), mutation.from, mutation.to, 1)
+			if x86StackAddressEncoderCarrier([]byte(changed)) == nil {
+				t.Fatal("changed source rule retained its family certificate")
+			}
+		})
+	}
+}
+
+func TestX86StackNamedAddressSourceClassDoesNotGrantMemory(t *testing.T) {
+	for _, spelling := range []string{
+		"$·cell(SB)", "$cell<>+8(SB)", " \t$runtime·mainPC(SB)",
+		"$·cell(SB)(AX)", "$·cell(SB)(R8)(X1*4)",
+	} {
+		operand, err := parseOperandForArch(ArchAMD64, strings.TrimSpace(spelling))
+		if err != nil || !x86AbsoluteRelocationSource(operand, "386", 32) || isAMD64MemoryOperand(operand) {
+			t.Fatalf("independent absolute source class changed: %s: %v", spelling, err)
+		}
+		before := operand
+		for _, arch := range []string{"386", "amd64", "arm64"} {
+			for _, bits := range []int{8, 16, 32, 64} {
+				want := arch == "386" && bits == 32
+				if x86AbsoluteRelocationSource(operand, arch, bits) != want || !reflect.DeepEqual(operand, before) {
+					t.Fatal("pure source classification changed operand identity or source mode")
+				}
+			}
+		}
+	}
+	for _, spelling := range []string{
+		"·cell(SB)", "$16(AX)", "$arg+0(FP)", "$local-8(SP)",
+		"$16(SB)", "$·cell*(SB)", "$$·cell(SB)",
+	} {
+		operand, err := parseOperandForArch(ArchAMD64, spelling)
+		if err == nil && x86AbsoluteRelocationSource(operand, "386", 32) {
+			t.Fatal("unregistered source role acquired relocation permission:", spelling)
+		}
+	}
+}
diff --git a/amd64_stack_flags_id_linux_amd64_test.go b/amd64_stack_flags_id_linux_amd64_test.go
new file mode 100644
index 000000000..e1fe517f0
--- /dev/null
+++ b/amd64_stack_flags_id_linux_amd64_test.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import (
+	"os"
+	"testing"
+)
+
+// This prefix is selected by the exhaustive required Linux cross-runtime job.
+// Both originals execute directly: IA32 compilation is not execution evidence.
+func TestCrossLinuxRuntimeMatrixX86StackFlagsIDNativeGo(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	t.Run("OriginalAMD64", TestX86StackFlagsIDNativeGo)
+	t.Run("Original386", func(t *testing.T) {
+		original := x86StackIDOriginalExecutable(t, "linux", "386")
+		sealed, err := x87IA32StaticExecutable(original)
+		if err != nil {
+			t.Fatal(err)
+		}
+		output := x87IA32RunDirect(t, sealed, nil, os.Environ())
+		if string(output) != "original Go stack ID observations 4\n" {
+			t.Fatalf("strict native original Go IA32 four-word oracle: %q", output)
+		}
+	})
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_stack_flags_id_native_linux_test.go b/amd64_stack_flags_id_native_linux_test.go
new file mode 100644
index 000000000..eea90ad28
--- /dev/null
+++ b/amd64_stack_flags_id_native_linux_test.go
@@ -0,0 +1,47 @@
+//go:build linux && (amd64 || 386)
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The original source and all four strict expectations remain unchanged.
+// A host-inapplicable portable lane cannot stand in for this native assertion.
+func TestX86StackFlagsIDNativeGo(t *testing.T) {
+	source := strings.Replace(x86StackIDSource(runtime.GOARCH), "idroundtrip(SB)", "·idroundtrip(SB)", 1)
+	if runtime.GOARCH == "386" {
+		source = strings.Replace(source, "$0-8", "$0-4", 1)
+	}
+	dir := t.TempDir()
+	files := map[string]string{
+		"go.mod":                         "module flagsidnative\n\ngo 1.20\n",
+		"flags_" + runtime.GOARCH + ".s": source,
+		"flags_test.go": `package flagsidnative
+import "testing"
+func idroundtrip(out *[4]uint32)
+func TestOriginalGoAssembly(t *testing.T) {
+  var out [4]uint32
+  idroundtrip(&out)
+  if out != [4]uint32{0x200000, 0x200000, 0x200000, 1} {
+    t.Fatalf("original Go flags roundtrip: %x", out)
+  }
+}
+`,
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin/go"), "test", "-p=2", "-count=1", "-v")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+runtime.GOARCH,
+		"CGO_ENABLED=0", "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+}
diff --git a/amd64_stack_flags_id_test.go b/amd64_stack_flags_id_test.go
new file mode 100644
index 000000000..9379bed64
--- /dev/null
+++ b/amd64_stack_flags_id_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86StackIDSource(goarch string) string {
+	// Go 1.27's asm6.go gives PUSHF/POPF six zero-operand W/L/Q forms.
+	// Intel SDM Volume 2B's POPF description preserves the upper flags on
+	// a 16-bit operand; the CPUID ID bit belongs to EFLAGS/RFLAGS bit 21.
+	// https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-2b-manual.pdf
+	width, flags := "Q", "Q"
+	if goarch == "386" {
+		width, flags = "L", "L"
+	}
+	return fmt.Sprintf(`TEXT idroundtrip(SB),4,$0-8
+	MOV%s out+0(FP), DI
+	PUSHF%s
+	POP%s AX
+	MOV%s AX, CX
+	XOR%s $0x200000, AX
+	PUSH%s AX
+	POPF%s
+	PUSHF%s
+	POP%s AX
+	PUSH%s CX
+	POPF%s
+	XOR%s CX, AX
+	AND%s $0x200000, AX
+	MOVL AX, 0(DI)
+	PUSHF%s
+	POP%s AX
+	OR%s $0x200000, AX
+	PUSH%s AX
+	POPF%s
+	PUSHW $2
+	POPFW
+	PUSHF%s
+	POP%s AX
+	AND%s $0x200000, AX
+	MOVL AX, 4(DI)
+	LAHF
+	SAHF
+	STC
+	PUSHFW
+	CLC
+	POPFW
+	SETCS 12(DI)
+	PUSHF%s
+	POP%s AX
+	AND%s $0x200000, AX
+	MOVL AX, 8(DI)
+	PUSH%s CX
+	POPF%s
+	RET
+`, width, flags, width, width, width, width, flags, flags, width,
+		width, flags, width, width, flags, width, width, width, flags,
+		flags, width, width, flags, width, width, width, flags)
+}
+
+func x86StackIDInitializedSource(t *testing.T, arch string) string {
+	t.Helper()
+	width := "Q"
+	if arch == "386" {
+		width = "L"
+	}
+	source := x86StackIDSource(arch)
+	entry := "\tMOV" + width + " out+0(FP), DI"
+	if strings.Count(source, entry) != 1 || strings.Count(source, "\tLAHF\n") != 1 {
+		t.Fatal("initialized ID fixture lost its unique original entry/AH boundaries")
+	}
+	// Define every arithmetic flag, DF and ID explicitly, rather than borrowing
+	// the emitter's default slots. CMP repairs only the later AND's undefined AF;
+	// neither seed changes the original ID toggle/upper-preservation checks.
+	source = strings.Replace(source, entry, "\tPUSH"+width+" $2\n\tPOPF"+width+"\n"+entry, 1)
+	// Full snapshots transport complete numerical words. Define the status
+	// bits before each; the original checks observe only ID there. Do not
+	// touch PUSHFW: its later CF roundtrip intentionally follows STC.
+	source = strings.ReplaceAll(source, "\tPUSHF"+width+"\n", "\tCMP"+width+" AX, AX\n\tPUSHF"+width+"\n")
+	source = strings.Replace(source, "\tLAHF\n", "\tCMP"+width+" AX, AX\n\tLAHF\n", 1)
+	if arch == "386" {
+		source = strings.Replace(source, "$0-8", "$0-4", 1)
+	}
+	return source
+}
+
+func TestX86StackFlagsIDObjects(t *testing.T) {
+	llc, _, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x86StackIDSource(target.arch)
+			if target.arch == "386" {
+				source = strings.Replace(source, "$0-8", "$0-4", 1)
+			}
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := x86StackIDOptions(target.arch, target.triple)
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original unknown entry/AF state became numerical FLAGS input", err)
+			}
+			initialized := x86StackIDInitializedSource(t, target.arch)
+			requireX86GoAssemblerResult(t, target.arch, initialized, true)
+			file, err = Parse(ArchAMD64, initialized)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := x86PackedFloatStorageAPI(api, file, options)
+				if err != nil {
+					t.Fatal("initialized complete ID program rejected", api, err)
+				}
+				if !strings.Contains(ir, "%flags_id = alloca i1") {
+					t.Fatal("stack flags cannot silently omit the CPUID ID bit")
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func x86StackIDOptions(arch, triple string) Options {
+	return Options{Goarch: arch, TargetTriple: triple,
+		Sigs: map[string]FuncSig{"idroundtrip": {
+			Name: "idroundtrip", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	}
+}
+
+func TestAMD64StackFlagsIDRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	// This executes translated numerical FLAGS/stack state, not original Go
+	// bytes or physical ID. No native x86 opcode or Rosetta is required.
+	file, err := Parse(ArchAMD64, x86StackIDInitializedSource(t, "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, x86StackIDOptions("amd64", triple))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "asm ") {
+		t.Fatal("portable ID oracle acquired a native opcode")
+	}
+	const oracle = `
+#include <stdint.h>
+extern void idroundtrip(uint32_t *);
+int main(void) {
+  uint32_t out[4] = {0};
+  idroundtrip(out);
+  if (out[0] != 0x200000) return 10;
+  if (out[1] != 0x200000) return 11;
+  if (out[2] != 0x200000) return 12;
+  if (out[3] != 1) return 13;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "stack_flags_id", triple, ir, oracle, nil)
+}
diff --git a/amd64_stack_flags_id_transport_test.go b/amd64_stack_flags_id_transport_test.go
new file mode 100644
index 000000000..0a9309df7
--- /dev/null
+++ b/amd64_stack_flags_id_transport_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// The source-role check uses actual SDK selection, not a runtime Skip or a
+// filename convention inferred by this test. Native execution remains required
+// on Linux; portable object/transport observations receive no native credit.
+func TestX86StackFlagsIDOriginalGoBuildRoles(t *testing.T) {
+	for _, target := range []struct {
+		goos, arch string
+		native     bool
+		cross      bool
+	}{
+		{"darwin", "arm64", false, false},
+		{"windows", "amd64", false, false},
+		{"linux", "amd64", true, true},
+		{"linux", "386", true, false},
+	} {
+		t.Run(target.goos+"/"+target.arch, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "list", "-json", ".")
+			command.Env = append(os.Environ(), "GOOS="+target.goos, "GOARCH="+target.arch,
+				"CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=")
+			output, diagnostics, err := runtimeOracleMachineOutput(ctx, command)
+			if err != nil {
+				t.Fatalf("actual SDK source selection: %v\n%s", err, diagnostics)
+			}
+			if len(diagnostics) != 0 {
+				t.Logf("actual Go selection diagnostics: %s", diagnostics)
+			}
+			var selected struct {
+				Dir         string
+				TestGoFiles []string
+			}
+			if err := json.Unmarshal(output, &selected); err != nil {
+				t.Fatal(err)
+			}
+			functions := make(map[string]bool)
+			for _, name := range selected.TestGoFiles {
+				file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(selected.Dir, name), nil, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, declaration := range file.Decls {
+					if function, ok := declaration.(*ast.FuncDecl); ok {
+						functions[function.Name.Name] = true
+					}
+				}
+			}
+			for _, root := range []struct {
+				name string
+				want bool
+			}{
+				{"TestX86StackFlagsIDNativeGo", target.native},
+				{"TestCrossLinuxRuntimeMatrixX86StackFlagsIDNativeGo", target.cross},
+				{"TestX86StackFlagsIDOriginalGoPortableTransport", true},
+			} {
+				if functions[root.name] != root.want {
+					t.Errorf("actual SDK source role %s: selected=%v want=%v", root.name, functions[root.name], root.want)
+				}
+			}
+		})
+	}
+}
+
+func x86StackIDOriginalExecutable(t *testing.T, goos, arch string) string {
+	t.Helper()
+	const driver = `package main
+
+import "fmt"
+
+func main() {
+    var out [4]uint32
+    idroundtrip(&out)
+    if out != [4]uint32{0x200000, 0x200000, 0x200000, 1} {
+        panic(fmt.Sprintf("original Go flags roundtrip: %x", out))
+    }
+    fmt.Println("original Go stack ID observations 4")
+}
+`
+	return x86StackIDOriginalBuild(t, goos, arch, driver)
+}
+
+func x86StackIDOriginalBuild(t *testing.T, goos, arch, driver string) string {
+	t.Helper()
+	source := strings.Replace(x86StackIDSource(arch), "idroundtrip(SB)", "·idroundtrip(SB)", 1)
+	if arch == "386" {
+		source = strings.Replace(source, "$0-8", "$0-4", 1)
+	}
+	const declarations = "package main\nfunc idroundtrip(out *[4]uint32)\n"
+	return x86OrderingHintBuildOriginal(t, t.TempDir(), goos, arch, declarations, source, driver)
+}
+
+// Rosetta's original POPFW currently clears the upper ID bit. This is a
+// complete output-transport diagnostic, not success of the four-word ISA
+// assertion. The unchanged strict reference executes in the required native
+// root; an actually native host cannot bypass it through this diagnostic.
+func TestX86StackFlagsIDOriginalGoPortableTransport(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const driver = `package main
+
+import "fmt"
+
+func main() {
+    var out [4]uint32
+    idroundtrip(&out)
+    fmt.Printf("original Go stack ID transport %08x %08x %08x %08x\n", out[0], out[1], out[2], out[3])
+}
+`
+	original := x86StackIDOriginalBuild(t, runtime.GOOS, "amd64", driver)
+	output := execution.run(t, original)
+	fields := strings.Fields(string(output))
+	if len(fields) != 9 || strings.Join(fields[:5], " ") != "original Go stack ID transport" {
+		t.Fatalf("incomplete original Go transport observations: %q", output)
+	}
+	var observed [4]uint32
+	for index, field := range fields[5:] {
+		value, err := strconv.ParseUint(field, 16, 32)
+		if err != nil || len(field) != 8 {
+			t.Fatalf("invalid complete uint32 observation %q: %v", field, err)
+		}
+		observed[index] = uint32(value)
+	}
+	canonical := fmt.Sprintf("original Go stack ID transport %08x %08x %08x %08x\n",
+		observed[0], observed[1], observed[2], observed[3])
+	if string(output) != canonical {
+		t.Fatalf("extra or noncanonical transport output: %q", output)
+	}
+	want := [4]uint32{0x200000, 0x200000, 0x200000, 1}
+	if observed != want {
+		if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+			t.Fatalf("native-applicable original Go strict ID assertion: got=%x want=%x", observed, want)
+		}
+		t.Logf("ISA DEVIATION: Rosetta original opcode observations=%x strict native expectation=%x; not native ISA P", observed, want)
+	}
+	t.Logf("four original Go observations via %q; transport observation, not native Linux evidence", execution.prefix)
+}
+
+func TestX86StackFlagsIDOriginal386StaticELFCompileOnly(t *testing.T) {
+	original := x86StackIDOriginalExecutable(t, "linux", "386")
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("original Go IA32 static ELF bytes=%d SHA256=%x; compile only, required native execution is separate",
+		sealed.size, sealed.hash)
+}
+
+func TestX86StackFlagsIDRequiredNativeSourceContract(t *testing.T) {
+	const name = "TestCrossLinuxRuntimeMatrixX86StackFlagsIDNativeGo"
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_stack_flags_id_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == name {
+			body = function.Body
+		}
+	}
+	if body == nil {
+		t.Fatal("required Linux selector root is absent")
+	}
+	calls := make(map[string]int)
+	ast.Inspect(body, func(node ast.Node) bool {
+		if identifier, ok := node.(*ast.Ident); ok && identifier.Name == "TestX86StackFlagsIDNativeGo" {
+			calls[identifier.Name]++
+		}
+		if call, ok := node.(*ast.CallExpr); ok {
+			if identifier, ok := call.Fun.(*ast.Ident); ok {
+				calls[identifier.Name]++
+			}
+			if method, ok := call.Fun.(*ast.SelectorExpr); ok &&
+				(method.Sel.Name == "Skip" || method.Sel.Name == "Skipf" || method.Sel.Name == "SkipNow") {
+				t.Error("required native execution cannot skip")
+			}
+		}
+		return true
+	})
+	for function, count := range map[string]int{
+		"x87IA32RequireNativeHost":     2,
+		"TestX86StackFlagsIDNativeGo":  1,
+		"x86StackIDOriginalExecutable": 1,
+		"x87IA32StaticExecutable":      1,
+		"x87IA32RunDirect":             1,
+	} {
+		if calls[function] != count {
+			t.Errorf("required native producer/consumer %s count=%d want=%d", function, calls[function], count)
+		}
+	}
+	// This is the exact original embedded strict reference from the pre-companion
+	// source, not a reconstructed test that silently accepts Rosetta's zeroes.
+	strict, err := parser.ParseFile(token.NewFileSet(), "amd64_stack_flags_id_native_linux_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	matched := 0
+	ast.Inspect(strict, func(node ast.Node) bool {
+		literal, ok := node.(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		value, err := strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.HasPrefix(value, "package flagsidnative\n") {
+			matched++
+			if hash := fmt.Sprintf("%x", sha256.Sum256([]byte(value))); hash !=
+				"635f87191dac5a025ba6676a9abdaa7b0b04b3525c76fe71749474fe353af572" {
+				t.Error("original native Go source/assertions changed", hash)
+			}
+		}
+		return true
+	})
+	if matched != 1 {
+		t.Fatalf("original native strict reference count=%d want=1", matched)
+	}
+}
diff --git a/amd64_stack_native_read.go b/amd64_stack_native_read.go
new file mode 100644
index 000000000..0d6eb0501
--- /dev/null
+++ b/amd64_stack_native_read.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) loadStackValue(source Operand, bits int) (string, error) {
+	typ := amd64StackLLVMType(bits)
+	if !x86RegisterAddressedNativeMemoryOperand(source, c.goarch) {
+		return c.evalIntSized(source, typ)
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+	return "%" + value, nil
+}
+
+func x86LoweredStackNativeRead(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	spec, known, err := x86StackWidthProperties(ins, arch)
+	if !known || err != nil || spec.mode != amd64StackPushValue || len(ins.Args) != 1 ||
+		!x86RegisterAddressedNativeMemoryOperand(ins.Args[0], arch) {
+		return false, false
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		!x86ResultIncomingPointerReadAddressIdentity(ins.Args[0], state, arch) {
+		return false, true
+	}
+	// Only this exact read gets a transfer-local numerical view. The clone
+	// and the defer both revoke it before any successor observes the state.
+	state.literalMemoryOperand, state.literalMemoryBytes = &ins.Args[0], int64(spec.bits/8)
+	defer func() { state.literalMemoryOperand, state.literalMemoryBytes = nil, 0 }()
+	return x86ResultValueStackStep(ins, state, owned, resultOffset, arch)
+}
+
+// This consumes the paired exact volatile POP store, not physical entry SP.
+// Keep the complete private-width/balance/bit proof and reject atomically when
+// an address, source bit or native origin is missing. No memory fact follows.
+func x86LoweredStackNativeStore(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	spec, known, err := x86StackWidthProperties(ins, arch)
+	if !known || err != nil || spec.mode != amd64StackPopValue ||
+		!x86OrdinaryNativeMemoryOperand(ins.Args[0], arch) {
+		return false, false
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		!x86ResultIncomingPointerAddressIdentity(ins.Args[0], state, arch) {
+		return false, true
+	}
+	candidate := state.clone()
+	accepted, recognized := x86ResultValueStackStepWithNativeStore(ins, &candidate, owned, resultOffset, arch, true)
+	if accepted {
+		*state = candidate
+	}
+	return accepted, recognized
+}
diff --git a/amd64_stack_native_store_test.go b/amd64_stack_native_store_test.go
new file mode 100644
index 000000000..a0f4c7dc0
--- /dev/null
+++ b/amd64_stack_native_store_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PrivatePOPNativeStoreExactBitsAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, wide := int(x86ResultPointerWord(arch)), "Q"
+		if arch == "386" {
+			wide = "L"
+		}
+		for _, width := range []struct {
+			suffix string
+			bytes  int
+		}{{"W", 2}, {wide, word}} {
+			t.Run(arch+"/"+width.suffix, func(t *testing.T) {
+				push := x86ScalarLaneInstruction(t, "PUSH"+width.suffix+" AX")
+				pop := x86ScalarLaneInstruction(t, "POP"+width.suffix+" -1(DX)(CX*2)")
+				for missing := -1; missing < width.bytes; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+						valueStack: &x86ResultValueStack{id: true}}
+					state.pointerGP[2] = true
+					state.gp[0], state.gp[1] = 255, uint8(1)<<uint(word)-1
+					if missing >= 0 {
+						state.gp[0] &^= 1 << uint(missing)
+					}
+					if accepted, known := x86ResultValueStackStep(push, &state, nil, 0, arch); !accepted || !known {
+						t.Fatal("private copy cannot invent but must retain unknown pushed bytes")
+					}
+					before := state.clone()
+					accepted, known := x86LoweredStackNativeStore(pop, &state, nil, 0, arch)
+					if !known || accepted != (missing == -1) {
+						t.Fatal("native POP did not retain exact-byte requirements", missing, accepted, known)
+					}
+					if !accepted {
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("rejected native POP mutated reaching private state")
+						}
+						continue
+					}
+					want := before.clone()
+					want.valueStack.bytes = want.valueStack.bytes[:0]
+					want.valueStack.wordCells = 0
+					if !reflect.DeepEqual(state, want) {
+						t.Fatal("native POP changed facts beyond the independently popped private cell")
+					}
+					for _, mutation := range []string{"pointer", "index", "physical", "raw", "address", "segment", "native-return"} {
+						input, changed := before.clone(), pop
+						switch mutation {
+						case "pointer":
+							input.pointerGP[2] = false
+						case "index":
+							input.gp[1] >>= 1
+						case "physical":
+							changed.x86Encoded = true
+						case "raw":
+							changed.x86SourceRaw = new(x86SourceRawInstruction)
+						case "address":
+							changed.x86AddressBits = 32
+						case "segment":
+							changed.x86SegmentPrefix = 0x64
+						case "native-return":
+							changed.x86RawNearReturn = new(x86RawNearReturnForm)
+						}
+						original := input.clone()
+						if accepted, _ := x86LoweredStackNativeStore(changed, &input, nil, 0, arch); accepted || !reflect.DeepEqual(input, original) {
+							t.Fatal("native POP invented address/origin permission", mutation)
+						}
+					}
+					standalone := before.clone()
+					if accepted, _ := x86ResultValueStackStep(pop, &standalone, nil, 0, arch); accepted {
+						t.Fatal("standalone numerical POP observer acquired native store permission")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivatePOPNativeStoresFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, typ, word, wide := "MOVQ", "uint64", 8, "Q"
+			if target.arch == "386" {
+				move, typ, word, wide = "MOVL", "uint32", 4, "L"
+			}
+			for _, width := range []struct {
+				suffix string
+				bytes  int
+			}{{"W", 2}, {wide, word}} {
+				t.Run(width.suffix, func(t *testing.T) {
+					declaration := fmt.Sprintf("func Value(out *byte,value %s) %s\n", typ, typ)
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DX\nMOVL $1,CX\nPUSH%s value+%d(FP)\nPOP%s -1(DX)(CX*2)\nPUSH%s value+%d(FP)\nPOP%s -1(DX)(CX*2)\n%s value+%d(FP),AX\n%s AX,ret+%d(FP)\nRET\n",
+						3*word, move, width.suffix, word, width.suffix, width.suffix, word, width.suffix, move, word, move, 2*word)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("actual bounded private POP lost its native write continuation", err)
+							}
+							for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								if strings.Count(input, fmt.Sprintf("store volatile i%d ", width.bytes*8)) != 2 {
+									t.Fatal("overwritten private POP stores lost exact observable width", width)
+								}
+								compileLLVMToObject(t, llc, target.triple, "private-pop-store.ll", "private-pop-store.o", input)
+							}
+						})
+					}
+					for name, changed := range map[string]string{
+						"unknown stack bytes": strings.ReplaceAll(source, "PUSH"+width.suffix+" value+"+fmt.Sprint(word)+"(FP)", "PUSH"+width.suffix+" AX"),
+						"unknown index":       strings.Replace(source, "MOVL $1,CX\n", "", 1),
+						"unknown base":        strings.Replace(source, move+" out+0(FP),DX\n", "", 1),
+						"unbalanced":          strings.Replace(source, "RET\n", "PUSH"+width.suffix+" $1\nRET\n", 1),
+					} {
+						t.Run(name, func(t *testing.T) {
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api)
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("private POP invented stack/address/balance facts", api, err)
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/amd64_stack_test.go b/amd64_stack_test.go
index 01d819ec5..385297958 100644
--- a/amd64_stack_test.go
+++ b/amd64_stack_test.go
@@ -1,9 +1,7 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
@@ -33,12 +31,33 @@ RET
 			Ret:  I64,
 		},
 	}
-	if _, err := Translate(file, Options{
+	if ir, err := Translate(file, Options{
 		TargetTriple: "x86_64-unknown-linux-gnu",
 		ResolveSym:   resolve,
 		Sigs:         sigs,
 		Goarch:       "amd64",
-	}); err != nil {
-		t.Fatal(err)
+	}); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original entry POP and undeclared result acquired a public ABI", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+src)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, src, "func stackOps() uint64", "amd64", triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original source invented a typed result or initialized stack", api, err)
+				}
+			}
+			ir := x86OriginalStackFormatObject(t, file.Funcs[0], I64, "amd64", triple)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+		})
 	}
 }
diff --git a/amd64_static_sb_address_test.go b/amd64_static_sb_address_test.go
new file mode 100644
index 000000000..4f94d18a8
--- /dev/null
+++ b/amd64_static_sb_address_test.go
@@ -0,0 +1,346 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"math"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// These are independent complete legacy mnemonic families, not a projection
+// of the implementation registry. All share Go's NAME_STATIC memory role.
+func x86StaticSBReadBodies(arch string) map[string]string {
+	bodies := x86ScalarResultDataReadBodies(arch)
+	for _, family := range []string{
+		"ANDPS ANDPD ANDNPS ANDNPD ORPS ORPD XORPS XORPD PAND PANDN POR PXOR",
+		"PAVGB PAVGW",
+		"PMULLW PMULHW PMULHUW PMULHRSW",
+		"PMULLD PMULDQ PMULULQ",
+		"PMADDWL PMADDUBSW",
+		"PSADBW",
+		"PACKSSLW PACKSSWB PACKUSDW PACKUSWB",
+		"PADDB PADDW PADDL PADDQ",
+		"PSUBB PSUBW PSUBL PSUBQ PSUBSB PSUBSW PSUBUSB PSUBUSW",
+		"PCMPEQB PCMPEQW PCMPEQL PCMPEQQ PCMPGTB PCMPGTW PCMPGTL PCMPGTQ",
+		"ADDPS ADDPD SUBPS SUBPD MULPS MULPD DIVPS DIVPD",
+		"PHADDW PHADDD PHADDSW PHSUBW PHSUBD PHSUBSW",
+		"AESENC AESENCLAST AESDEC AESDECLAST AESIMC",
+		"CVTPL2PS CVTPL2PD",
+	} {
+		for _, name := range strings.Fields(family) {
+			bodies[name] = "PXOR X1,X1\n" + name + " table<>+16(SB),X1\n"
+		}
+	}
+	bodies["MPSADBW"] = "PXOR X1,X1\nMPSADBW $5,table<>+16(SB),X1\n"
+	bodies["AESKEYGENASSIST"] = "AESKEYGENASSIST $5,table<>+16(SB),X1\n"
+	for _, name := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW"} {
+		bodies[name] = name + " $5,table<>+16(SB),X1\n"
+	}
+	for _, name := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD"} {
+		bodies[name] = "PXOR X1,X1\n" + name + " table<>+16(SB),X1,$5\n"
+	}
+	for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+		widths := []string{"W", "L"}
+		if arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			name := "CMOV" + width + condition
+			bodies[name] = "MOVL $0,AX\nCMPL AX,AX\n" + name + " table<>+16(SB),AX\n"
+		}
+	}
+	return bodies
+}
+
+func x86StaticSBBodyNames(bodies map[string]string) []string {
+	names := make([]string, 0, len(bodies))
+	for name := range bodies {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+func TestX86StaticSBAnnotationActualGoRoles(t *testing.T) {
+	bodies := x86StaticSBReadBodies("386")
+	for _, offset := range []string{"0", "16", "(2*8)", "-16"} {
+		var plain, annotated strings.Builder
+		plain.WriteString("TEXT roles(SB),4,$0-0\n")
+		annotated.WriteString("TEXT roles(SB),4,$0-0\n")
+		for _, base := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+			for _, name := range x86StaticSBBodyNames(bodies) {
+				body := strings.ReplaceAll(bodies[name], "+16(SB)", "+"+offset+"(SB)")
+				plain.WriteString(body)
+				annotated.WriteString(strings.ReplaceAll(body, "(SB)", "(SB)("+base+")"))
+			}
+		}
+		plain.WriteString("RET\n")
+		annotated.WriteString("RET\n")
+		left := x86PackedShiftActualGoBytes(t, "386", plain.String())
+		right := x86PackedShiftActualGoBytes(t, "386", annotated.String())
+		if !bytes.Equal(left, right) {
+			t.Fatalf("Go NAME_STATIC base annotation changed encoded instructions at offset %s", offset)
+		}
+	}
+	for _, base := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+		for _, scale := range []int{1, 2, 4, 8} {
+			source := func(operand string) string {
+				return "TEXT roles(SB),4,$0-0\nMOVOU " + operand + ",X1\nRET\n"
+			}
+			index := fmt.Sprintf("(CX*%d)", scale)
+			plain := x86PackedShiftActualGoBytes(t, "386", source("table<>+16(SB)"+index))
+			annotated := x86PackedShiftActualGoBytes(t, "386", source("table<>+16(SB)("+base+")"+index))
+			if !bytes.Equal(plain, annotated) {
+				t.Fatalf("base %s displaced actual index %s", base, index)
+			}
+		}
+		goAssemblerOracleOutput(t, "amd64", "TEXT roles(SB),4,$0-0\nMOVOU table<>(SB)("+base+"),X1\nRET\n", "", false)
+	}
+}
+
+func TestX86StaticSBAnnotationLoweredResults(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		bodies := x86ScalarResultDataReadBodies(target.arch)
+		for _, base := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+			if target.arch != "386" && base != "AX" {
+				continue // AMD64's unannotated controls still cover every family.
+			}
+			t.Run(target.triple+"/"+base, func(t *testing.T) {
+				var source, declarations strings.Builder
+				source.WriteString(x86ScalarResultDataTable)
+				for _, name := range x86StaticSBBodyNames(bodies) {
+					body := bodies[name]
+					if target.arch == "386" {
+						body = strings.ReplaceAll(body, "(SB)", "(SB)("+base+")")
+					}
+					fmt.Fprintf(&source, "TEXT ·view%s(SB),4,$0-4\n%sPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", name, body)
+					fmt.Fprintf(&declarations, "func view%s() uint32\n", name)
+				}
+				goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Errorf("%s: bounded static annotation lost numeric result/native role: %v", api, err)
+						continue
+					}
+					compileLLVMToObject(t, llc, target.triple, "static-sb.ll", "static-sb.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticSBAnnotationNativeFamilyMatrix(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		bodies := x86StaticSBReadBodies(target.arch)
+		bases := []string{""}
+		if target.arch == "386" {
+			bases = append(bases, "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI")
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			nativeCount := 0
+			var annotatedIR string
+			for _, base := range bases {
+				t.Run(target.triple+"/"+api+"/"+base, func(t *testing.T) {
+					var source, declarations strings.Builder
+					source.WriteString(x86ScalarResultDataTable)
+					for _, name := range x86StaticSBBodyNames(bodies) {
+						body := bodies[name]
+						if base != "" {
+							body = strings.ReplaceAll(body, "(SB)", "(SB)("+base+")")
+						}
+						fmt.Fprintf(&source, "TEXT ·view%s(SB),4,$0-0\n%sRET\n", name, body)
+						fmt.Fprintf(&declarations, "func view%s()\n", name)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("ignored static base changed native-emitter selection:", err)
+					}
+					count := strings.Count(ir, "asm sideeffect")
+					if base == "" {
+						nativeCount = count
+					}
+					// The three APIs allocate distinct temporary module paths.
+					// Exclude only their two nonsemantic filename records.
+					var comparable strings.Builder
+					for _, line := range strings.Split(ir, "\n") {
+						if !strings.HasPrefix(line, "; ModuleID = ") && !strings.HasPrefix(line, "source_filename = ") {
+							comparable.WriteString(line)
+							comparable.WriteByte('\n')
+						}
+					}
+					if base == "AX" {
+						annotatedIR = comparable.String()
+					}
+					if count == 0 || count != nativeCount {
+						t.Fatalf("native opcode count changed: %d, want %d", count, nativeCount)
+					}
+					// OpMem has a pointer/integer bridge unlike plain OpSym.
+					// Changing only the ignored Reg must emit identical IR.
+					if base != "" && comparable.String() != annotatedIR {
+						original, changed := strings.Split(annotatedIR, "\n"), strings.Split(comparable.String(), "\n")
+						for line := 0; line < len(original) && line < len(changed); line++ {
+							if original[line] != changed[line] {
+								t.Logf("first difference at %d: %q / %q", line, original[line], changed[line])
+								break
+							}
+						}
+						t.Fatal("ignored base annotation changed emitted LLVM semantics")
+					}
+					compileLLVMToObject(t, llc, target.triple, "static-native.ll", "static-native.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestX86StaticSBAnnotationNativeSADFeatures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, name := range []string{"PSADBW", "MPSADBW"} {
+		t.Run(name, func(t *testing.T) {
+			body := x86StaticSBReadBodies("386")[name]
+			source := x86ScalarResultDataTable + "TEXT ·view(SB),4,$0-0\n" + body + "RET\n"
+			goAssemblerOracleOutput(t, "386", source, "", true)
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", "386", "i386-unknown-linux-gnu", "text")
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "sad.ll", "sad.o", ir)
+		})
+	}
+}
+
+func TestX86StaticSBAnnotationResultBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		for name, body := range x86ScalarResultDataReadBodies(arch) {
+			for _, address := range []string{
+				"table<>-1(SB)(AX)", "table<>+32(SB)(AX)",
+				"table<>+16(SB)(AX*1)", "table<>+16(SB)(SP)(CX*2)",
+				"table<>+16(SB)(BP)(DX*4)", "external(SB)(DI)",
+			} {
+				t.Run(arch+"/"+name+"/"+address, func(t *testing.T) {
+					source := x86ScalarResultDataTable + "TEXT ·view(SB),4,$0-4\n" +
+						strings.ReplaceAll(body, "table<>+16(SB)", address) +
+						"PEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						if _, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", arch, triple, api); err == nil {
+							t.Fatalf("%s accepted an unbound static numerical input", api)
+						}
+					}
+				})
+			}
+		}
+	}
+	for _, base := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+		for _, offset := range []string{"0", "16", "(2*8)", "17"} {
+			address := "table<>+" + offset + "(SB)(" + base + ")"
+			source := x86ScalarResultDataTable + "TEXT ·view(SB),4,$0-4\nMOVOU " + address +
+				",X1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				_, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "386", "i386-unknown-linux-gnu", api)
+				if offset == "17" && !errors.Is(err, ErrProbeNeedsContext) || offset != "17" && err != nil {
+					t.Fatalf("%s %s complete extent: %v", api, address, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86StaticSBAnnotationRawAddressBoundaries(t *testing.T) {
+	read, err := parseOperandForArch(ArchAMD64, "table<>+16(SB)(SP)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, x86ScalarResultDataTable+"TEXT view(SB),4,$0-0\nMOVOU table<>+16(SB)(SP),X1\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	state := x86ResultState{loweredStaticReads: x86LoweredScalarDataReads(file, resolve, nil, "386")}
+	for index := range state.gp {
+		state.gp[index] = 0xff // Known indexes still cannot borrow a static extent.
+	}
+	if !x86ResultRead(read, 16, &state, nil, "386") {
+		t.Fatal("valid original static base annotation did not retain complete extent")
+	}
+	for name, change := range map[string]func(*MemRef){
+		"separate offset": func(m *MemRef) { m.Off = 1 },
+		"negative offset": func(m *MemRef) { m.Off = -17 },
+		"offset overflow": func(m *MemRef) { m.Off = math.MaxInt64 },
+		"raw offset":      func(m *MemRef) { m.OffRaw = "unknown" },
+		"segment":         func(m *MemRef) { m.Segment = FS },
+		"TLS":             func(m *MemRef) { m.Base = TLS },
+		"unknown base":    func(m *MemRef) { m.Base = "UNKNOWN" },
+		"dynamic index":   func(m *MemRef) { m.Index, m.Scale = AX, 1 },
+		"unbound scale":   func(m *MemRef) { m.Scale = 1 },
+		"index extension": func(m *MemRef) { m.IndexExt = "SXTW" },
+		"FP role":         func(m *MemRef) { m.Sym = "table<>+16(FP)" },
+		"AUTO role":       func(m *MemRef) { m.Sym = "table<>+16(SP)" },
+		"address value":   func(m *MemRef) { m.Sym = "$table<>+16(SB)" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			mutated := read
+			change(&mutated.Mem)
+			if x86ResultRead(mutated, 16, &state, nil, "386") {
+				t.Fatal("mutated operand borrowed another effective address's DATA bytes")
+			}
+		})
+	}
+	if x86ResultRead(read, 16, &state, nil, "amd64") {
+		t.Fatal("386 base annotation became valid AMD64 RIP-relative memory")
+	}
+	dynamic := Operand{Kind: OpMem, Mem: MemRef{Sym: "table<>(SB)", Base: SP, Index: BP, Scale: 1}}
+	if !x86OrdinaryNativeMemoryOperand(dynamic, "386") || x86ResultRead(dynamic, 16, &state, nil, "386") {
+		t.Fatal("ordinary mode32 BP index was either classified as a frame or borrowed an unindexed static extent")
+	}
+	dynamic.Mem.Index = SP
+	if x86OrdinaryNativeMemoryOperand(dynamic, "386") {
+		t.Fatal("an actual SP index borrowed permission from an ignored SP annotation")
+	}
+	for _, copy := range []x86ResultState{state.clone(), state.intersect(state)} {
+		if x86ResultRead(read, 16, &copy, nil, "386") {
+			t.Fatal("conditional static bytes escaped the current lowering transfer")
+		}
+	}
+}
+
+func TestX86StaticSBAnnotationDoesNotGrantSourceProof(t *testing.T) {
+	for _, base := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"} {
+		body := "MOVOU table<>+16(SB)(" + base + "),X1\nPEXTRD $0,X1,AX\nMOVL AX,ret0+0(FP)\nRET"
+		_, file, sig, _ := x86ResultInitializationFixture(t, "386", "func Value() uint32", body)
+		for _, check := range []func(Func, FuncSig, string) error{
+			CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+		} {
+			if err := check(file.Funcs[0], sig, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s standalone query borrowed the private DATA directory: %v", base, err)
+			}
+		}
+		data := strings.Replace(x86ScalarResultDataTable,
+			"DATA table<>+16(SB)/8,$0xfedcba9876543210", "DATA table<>+16(SB)/4,$external(SB)", 1)
+		source := data + "TEXT ·Value(SB),4,$0-4\n" + body + "\n"
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32\n", "386", "i386-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s/%s treated pointer relocations as numeric DATA: %v", base, api, err)
+			}
+		}
+	}
+}
diff --git a/amd64_string_forms.go b/amd64_string_forms.go
new file mode 100644
index 000000000..59451e8e2
--- /dev/null
+++ b/amd64_string_forms.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86StringSpec struct {
+	kind  string
+	typ   LLVMType
+	width int
+}
+
+var x86StringSpecs = map[Op]x86StringSpec{
+	"MOVSB": {kind: "movs", typ: I8, width: 1},
+	"MOVSW": {kind: "movs", typ: I16, width: 2},
+	"MOVSL": {kind: "movs", typ: I32, width: 4},
+	"MOVSQ": {kind: "movs", typ: I64, width: 8},
+	"STOSB": {kind: "stos", typ: I8, width: 1},
+	"STOSW": {kind: "stos", typ: I16, width: 2},
+	"STOSL": {kind: "stos", typ: I32, width: 4},
+	"STOSQ": {kind: "stos", typ: I64, width: 8},
+	"SCASB": {kind: "scas", typ: I8, width: 1},
+	"SCASW": {kind: "scas", typ: I16, width: 2},
+	"SCASL": {kind: "scas", typ: I32, width: 4},
+	"SCASQ": {kind: "scas", typ: I64, width: 8},
+	"CMPSB": {kind: "cmps", typ: I8, width: 1},
+	"CMPSW": {kind: "cmps", typ: I16, width: 2},
+	"CMPSL": {kind: "cmps", typ: I32, width: 4},
+	"CMPSQ": {kind: "cmps", typ: I64, width: 8},
+	"LODSB": {kind: "lods", typ: I8, width: 1},
+	"LODSW": {kind: "lods", typ: I16, width: 2},
+	"LODSL": {kind: "lods", typ: I32, width: 4},
+	"LODSQ": {kind: "lods", typ: I64, width: 8},
+}
+
+// This name-only query is used by dispatch and helper discovery. A recognized
+// spelling alone does not validate its operands or establish an effect.
+func x86StringProperties(op Op) (kind string, typ LLVMType, width int, ok bool) {
+	spec, ok := x86StringSpecs[Op(normalizeInstructionOpcode(op))]
+	if !ok {
+		return "", "", 0, false
+	}
+	return spec.kind, spec.typ, spec.width, true
+}
+
+// x86StringInstructionProperties validates Go's complete twenty ynone string
+// rows. REP/REPN remain independently dispatched prefixes, not string bodies
+// or inert effects. This grammar grants no memory, entry or FLAGS knowledge.
+func x86StringInstructionProperties(ins Instr, arch string) (x86StringSpec, bool, error) {
+	// Match lowerInstr's existing case normalization, deriving the only head
+	// from the actual instruction. Raw remains diagnostic source text only.
+	op := Op(strings.ToUpper(string(ins.Op)))
+	kind, typ, width, known := x86StringProperties(op)
+	if !known {
+		return x86StringSpec{}, false, nil
+	}
+	if op != Op(normalizeInstructionOpcode(op)) {
+		return x86StringSpec{}, true, fmt.Errorf("%s %s does not accept instruction suffixes: %q", arch, op, ins.Raw)
+	}
+
+	spec := x86StringSpec{kind: kind, typ: typ, width: width}
+	if arch != "386" && arch != "amd64" {
+		return spec, true, fmt.Errorf("%s %s requires an x86 source mode: %q", arch, op, ins.Raw)
+	}
+	if arch == "386" && typ == I64 {
+		return spec, true, fmt.Errorf("386 %s is not in the Go assembler's 32-bit instruction table", op)
+	}
+	if len(ins.Args) != 0 {
+		return spec, true, fmt.Errorf("%s %s takes no operands: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
diff --git a/amd64_string_repeat_prefix.go b/amd64_string_repeat_prefix.go
new file mode 100644
index 000000000..6e792c637
--- /dev/null
+++ b/amd64_string_repeat_prefix.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86StringRepeatPair struct {
+	prefixBlock, prefixInstruction int
+	bodyBlock, bodyInstruction     int
+}
+
+// The lexical prefix carrier is safe only if every incoming source path to
+// its body executes that exact adjacent prefix. Labels emit no instruction,
+// but a branch to a label after the prefix must not acquire the skipped byte.
+// This is a denial-only CFG check, not a string memory or initialized-byte role.
+func (c *amd64Ctx) verifyStringRepeatPrefixes() error {
+	_, err := c.stringRepeatSourceBindings()
+	return err
+}
+
+// Both the result preflight and emission consume this exact complete CFG
+// check. A returned pair identifies source nodes, never initialized bytes,
+// repeat count, memory backing or permission to perform a native access.
+func (c *amd64Ctx) stringRepeatSourceBindings() ([]x86StringRepeatPair, error) {
+	hasRepeat := false
+	for _, block := range c.blocks {
+		for _, ins := range block.instrs {
+			if strings.EqualFold(string(ins.Op), "REP") || strings.EqualFold(string(ins.Op), "REPN") {
+				hasRepeat = true
+				break
+			}
+		}
+		if hasRepeat {
+			break
+		}
+	}
+	if !hasRepeat {
+		return nil, nil
+	}
+	// First nonempty block at/after each position. Together with the transition
+	// prefix sum below, arbitrarily long label chains are checked once, not once
+	// per source prefix. No fixed-point traversal or cycle unrolling is needed.
+	next := make([]int, len(c.blocks)+1)
+	next[len(c.blocks)] = len(c.blocks)
+	for block := len(c.blocks) - 1; block >= 0; block-- {
+		next[block] = next[block+1]
+		if len(c.blocks[block].instrs) != 0 {
+			next[block] = block
+		}
+	}
+	var pairs []x86StringRepeatPair
+	for block, body := range c.blocks {
+		for instruction, prefix := range body.instrs {
+			op := strings.ToUpper(string(prefix.Op))
+			if op != "REP" && op != "REPN" {
+				continue
+			}
+			if len(prefix.Args) != 0 {
+				return nil, fmt.Errorf("%s %s takes no operands: %q", c.goarch, op, prefix.Raw)
+			}
+			bodyBlock, bodyInstruction := block, instruction+1
+			if bodyInstruction == len(body.instrs) {
+				bodyBlock, bodyInstruction = next[block+1], 0
+			}
+			if bodyBlock == len(c.blocks) {
+				return nil, fmt.Errorf("%s %s prefix has no following string instruction", c.goarch, op)
+			}
+			follower := c.blocks[bodyBlock].instrs[bodyInstruction]
+			if _, known, err := x86StringInstructionProperties(follower, c.goarch); known {
+				if err != nil {
+					return nil, err
+				}
+			} else if _, _, known := x86PortStringProperties(follower.Op); known {
+				// Preserve the existing port-string grammar and native I/O
+				// emitter. The common prefix binding creates no I/O permission.
+				if len(follower.Args) != 0 {
+					return nil, fmt.Errorf("%s %s takes no operands: %q", c.goarch, follower.Op, follower.Raw)
+				}
+			} else {
+				return nil, fmt.Errorf("%s %s prefix is unsupported for %s", c.goarch, op, strings.ToUpper(string(follower.Op)))
+			}
+			pairs = append(pairs, x86StringRepeatPair{block, instruction, bodyBlock, bodyInstruction})
+		}
+	}
+	if len(pairs) == 0 {
+		return nil, nil // Unprefixed source retains its original control contract.
+	}
+	context := func(reason string) error {
+		return fmt.Errorf("%w: %s REP/REPN needs its exact source-adjacent CFG binding: %s", ErrProbeNeedsContext, c.goarch, reason)
+	}
+	labels := make(map[string]int, len(c.blocks))
+	for block, body := range c.blocks {
+		if _, duplicate := labels[body.name]; duplicate {
+			return nil, context("ambiguous source label")
+		}
+		labels[body.name] = block
+	}
+	predecessors, onlyPredecessor := make([]int, len(c.blocks)), make([]int, len(c.blocks))
+	for block := range c.blocks {
+		successors, valid := c.sourceBlockSuccessors(block, labels)
+		if !valid {
+			return nil, context("indirect, external or unresolved source control flow")
+		}
+		for edge, target := range successors {
+			if edge > 0 && target == successors[0] {
+				continue // Both outcomes of one conditional edge have one predecessor.
+			}
+			predecessors[target]++
+			onlyPredecessor[target] = block
+		}
+	}
+	badThrough := make([]int, len(c.blocks))
+	for block := 1; block < len(c.blocks); block++ {
+		badThrough[block] = badThrough[block-1]
+		if predecessors[block] != 1 || onlyPredecessor[block] != block-1 {
+			badThrough[block]++
+		}
+	}
+	for _, pair := range pairs {
+		if badThrough[pair.bodyBlock] != badThrough[pair.prefixBlock] {
+			return nil, context("a body or intervening label has an incoming edge that skips its prefix")
+		}
+	}
+	return pairs, nil
+}
diff --git a/amd64_symbol_index.go b/amd64_symbol_index.go
new file mode 100644
index 000000000..0842b2d8e
--- /dev/null
+++ b/amd64_symbol_index.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Non-shared 386 TYPE_ADDR EXTERN/STATIC is Yi32. The registered scalar-L
+// arithmetic and PUSHL rows have a four-byte relocation sink; B/W emitters
+// have none, and ordinary amd64 named addresses are Yiauto. This shared source
+// class grants neither memory access, native stack nor caller permission.
+func x86AbsoluteRelocationSource(operand Operand, goarch string, bits int) bool {
+	if goarch != "386" || bits != 32 || operand.Kind != OpSym {
+		return false
+	}
+	source := strings.TrimSpace(operand.Sym)
+	if !strings.HasPrefix(source, "$") {
+		return false
+	}
+	source = strings.TrimSpace(strings.TrimPrefix(source, "$"))
+	if memory, matched, err := parseX86SymbolIndexedMemory(source); matched {
+		if err != nil {
+			return false
+		}
+		source = memory.Sym
+	}
+	if !strings.HasSuffix(source, "(SB)") {
+		return false
+	}
+	name, _, valid := parseFP(strings.TrimSuffix(source, "(SB)") + "(FP)")
+	return valid && name != "" && !(name[0] >= '0' && name[0] <= '9') &&
+		strings.IndexAny(name, "*/&|^%=!$:[]") < 0
+}
+
+func x86SymbolIndexedControlError(ins Instr) error {
+	switch normalizeInstructionOpcode(ins.Op) {
+	case "CALL", "JMP", "RET":
+		for _, operand := range ins.Args {
+			if operand.Kind == OpMem && strings.HasSuffix(operand.Mem.Sym, "(SB)") {
+				// Go progedit converts named control TYPE_MEM to TYPE_BRANCH,
+				// not an indexed memory read. Parsing does not prove this
+				// target's relocation, entry/continuation or callee transport.
+				return fmt.Errorf("%w: grouped SB control operand needs its Go branch/entry contract", ErrProbeNeedsContext)
+			}
+		}
+	}
+	return nil
+}
+
+// asm6.oclass requires a named PARAM/AUTO base to be absent or SP and rejects
+// ordinary AMD64 EXTERN/STATIC base/index registers (their native base is RIP).
+// In 386, asmandsz ignores Reg for these names but still consumes Index.
+// This describes native operand shape only, never a memory/ABI permission.
+func x86SymbolIndexedMemoryError(memory MemRef, arch string) error {
+	if memory.Sym == "" {
+		return nil
+	}
+	if memory.Base == TLS || memory.Index == TLS {
+		return fmt.Errorf("%w: named-memory TLS needs its actual Go progedit and native TLS address contract", ErrProbeNeedsContext)
+	}
+	if arch == "386" && memory.Base != "" && !isX86YrlRegisterForArch(memory.Base, arch) {
+		// Except for progedit's TLS rewrite above, Go's named-memory encoder
+		// discards Reg, including FS/GS and SIMD annotations. Validate its
+		// complete spelling before discarding it, not its physical GP bank.
+		if !x86SymbolGoRegisterName(string(memory.Base)) {
+			return fmt.Errorf("386 named-memory has an unknown Go Reg annotation")
+		}
+	}
+	validation := memory
+	if arch == "386" {
+		validation.Base = "" // All named 386 TYPE_MEM roles ignore Reg.
+	}
+	switch memory.Index {
+	case "CS", "SS", "DS", "ES", FS, GS:
+		return fmt.Errorf("%w: named-memory segment index needs native segment address provenance", ErrProbeNeedsContext)
+	}
+	if !x86MemoryRegistersValidForArch(validation, arch) || memory.IndexExt != "" ||
+		memory.Index == SP || memory.Index != "" && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+		return fmt.Errorf("%s symbolic memory has an unencodable base/index/scale", arch)
+	}
+	symbol := strings.TrimSpace(memory.Sym)
+	if strings.HasSuffix(symbol, "(FP)") || strings.HasSuffix(symbol, "(SP)") {
+		if arch != "386" && memory.Base != "" && memory.Base != SP {
+			return fmt.Errorf("amd64 named FP/AUTO memory must have an absent or SP base")
+		}
+		return fmt.Errorf("%w: indexed FP/AUTO address needs its original contiguous frame, dynamic extent and address provenance", ErrProbeNeedsContext)
+	}
+	if !strings.HasSuffix(symbol, "(SB)") {
+		return fmt.Errorf("unsupported x86 symbolic memory role: %q", memory.Sym)
+	}
+	if arch != "386" && (memory.Base != "" || memory.Index != "" || memory.Scale != 0) {
+		return fmt.Errorf("amd64 Go SB memory cannot combine RIP with a base/index register")
+	}
+	return nil
+}
+
+func (c *amd64Ctx) addrFromSymbolIndexedAddress(memory MemRef) (string, error) {
+	if c.goarch == "386" && strings.HasSuffix(memory.Sym, "(SB)") {
+		// TYPE_ADDR is Yi32 in non-shared 386, not Yiauto. The source
+		// registers are annotations on a relocated immediate, not inputs to
+		// an effective-address calculation (unlike TYPE_MEM/LEA).
+		for _, register := range []Reg{memory.Base, memory.Index} {
+			if register != "" && !x86SymbolGoRegisterName(string(register)) {
+				return "", fmt.Errorf("386 symbolic address has an unknown Go register annotation")
+			}
+		}
+		if memory.IndexExt != "" {
+			return "", fmt.Errorf("386 symbolic address has an unknown register extension")
+		}
+		switch memory.Index {
+		case "CS", "DS", "ES", FS, GS:
+			return "", fmt.Errorf("%w: relocated immediate segment Index needs its source-encoder prefix contract", ErrProbeNeedsContext)
+		}
+		memory.Base, memory.Index, memory.IndexExt, memory.Scale = "", "", "", 0
+	}
+	return c.addrFromMem(memory)
+}
diff --git a/amd64_tailcall_aggregate_test.go b/amd64_tailcall_aggregate_test.go
new file mode 100644
index 000000000..5c2b2f2ae
--- /dev/null
+++ b/amd64_tailcall_aggregate_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestAMD64TailCallAdaptsABIEquivalentAggregateReturns(t *testing.T) {
+	tests := []struct {
+		name      string
+		callerRet LLVMType
+		calleeRet LLVMType
+		cast      string
+	}{
+		{
+			name:      "integer slot to pointer slot",
+			callerRet: LLVMType("{ i64, ptr }"),
+			calleeRet: LLVMType("{ i64, i64 }"),
+			cast:      "inttoptr i64",
+		},
+		{
+			name:      "pointer slot to integer slot",
+			callerRet: LLVMType("{ i64, i64 }"),
+			calleeRet: LLVMType("{ i64, ptr }"),
+			cast:      "ptrtoint ptr",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			caller := FuncSig{Name: "example.wrapper", Args: []LLVMType{Ptr}, Ret: tt.callerRet}
+			callee := FuncSig{Name: "example.words", Args: []LLVMType{Ptr}, Ret: tt.calleeRet}
+			c, b := newAMD64CtxWithFuncForTest(t, Func{}, caller, map[string]FuncSig{
+				"example.words": callee,
+			})
+
+			if err := c.tailCallAndRet(Operand{Kind: OpSym, Sym: "words(SB)"}); err != nil {
+				t.Fatalf("tailCallAndRet() error = %v", err)
+			}
+			got := b.String()
+			for _, want := range []string{
+				"call " + string(tt.calleeRet) + " @\"example.words\"(ptr %arg0)",
+				"extractvalue " + string(tt.calleeRet),
+				tt.cast,
+				"insertvalue " + string(tt.callerRet),
+				"ret " + string(tt.callerRet),
+			} {
+				if !strings.Contains(got, want) {
+					t.Fatalf("tailCallAndRet() missing %q:\n%s", want, got)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64TailCallRejectsABIIncompatibleAggregateReturns(t *testing.T) {
+	tests := []struct {
+		name      string
+		callerRet LLVMType
+		calleeRet LLVMType
+	}{
+		{name: "different field count", callerRet: LLVMType("{ i64, ptr }"), calleeRet: LLVMType("{ i64 }")},
+		{name: "floating slot", callerRet: LLVMType("{ i64, ptr }"), calleeRet: LLVMType("{ i64, double }")},
+		{name: "different integer width", callerRet: LLVMType("{ i64, ptr }"), calleeRet: LLVMType("{ i64, i32 }")},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			caller := FuncSig{Name: "example.wrapper", Args: []LLVMType{Ptr}, Ret: tt.callerRet}
+			callee := FuncSig{Name: "example.words", Args: []LLVMType{Ptr}, Ret: tt.calleeRet}
+			c, _ := newAMD64CtxWithFuncForTest(t, Func{}, caller, map[string]FuncSig{
+				"example.words": callee,
+			})
+
+			if err := c.tailCallAndRet(Operand{Kind: OpSym, Sym: "words(SB)"}); err == nil {
+				t.Fatal("tailCallAndRet() unexpectedly accepted ABI-incompatible aggregate returns")
+			}
+		})
+	}
+}
+
+func Test386TailCallAdaptsABIEquivalentAggregateReturns(t *testing.T) {
+	caller := FuncSig{Name: "example.wrapper", Args: []LLVMType{Ptr}, Ret: LLVMType("{ i32, ptr }")}
+	callee := FuncSig{Name: "example.words", Args: []LLVMType{Ptr}, Ret: LLVMType("{ i32, i32 }")}
+	var b strings.Builder
+	c := newX86Ctx(&b, Func{}, caller, testResolveSym("example"), map[string]FuncSig{
+		"example.words": callee,
+	}, "386", "i386-unknown-linux-gnu", false)
+	if err := c.emitEntryAllocas(); err != nil {
+		t.Fatalf("emitEntryAllocas() error = %v", err)
+	}
+
+	if err := c.tailCallAndRet(Operand{Kind: OpSym, Sym: "words(SB)"}); err != nil {
+		t.Fatalf("tailCallAndRet() error = %v", err)
+	}
+	got := b.String()
+	for _, want := range []string{
+		"call { i32, i32 } @\"example.words\"(ptr %arg0)",
+		"inttoptr i32",
+		"insertvalue { i32, ptr }",
+		"ret { i32, ptr }",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("tailCallAndRet() missing %q:\n%s", want, got)
+		}
+	}
+}
diff --git a/amd64_ternary_gp_forms.go b/amd64_ternary_gp_forms.go
new file mode 100644
index 000000000..6a87e9a97
--- /dev/null
+++ b/amd64_ternary_gp_forms.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86TernaryGPOperation uint8
+
+const (
+	x86TernaryANDN x86TernaryGPOperation = iota
+	x86TernaryPDEP
+	x86TernaryPEXT
+)
+
+type x86TernaryGPSpec struct {
+	bits      int
+	operation x86TernaryGPOperation
+	prefix    int
+}
+
+// These families share Go's complete _yandnl operand grammar, not their
+// operation or FLAGS effects. MULX has a different read/write role.
+var x86TernaryGPSpecs = map[Op]x86TernaryGPSpec{
+	"ANDNL": {bits: 32, operation: x86TernaryANDN},
+	"ANDNQ": {bits: 64, operation: x86TernaryANDN},
+	"PDEPL": {bits: 32, operation: x86TernaryPDEP, prefix: 3},
+	"PDEPQ": {bits: 64, operation: x86TernaryPDEP, prefix: 3},
+	"PEXTL": {bits: 32, operation: x86TernaryPEXT, prefix: 2},
+	"PEXTQ": {bits: 64, operation: x86TernaryPEXT, prefix: 2},
+}
+
+type x86TernaryGPForm struct {
+	spec                       x86TernaryGPSpec
+	first, second, destination Operand
+}
+
+func x86TernaryGPProperties(op Op, ins Instr, arch string) (x86TernaryGPForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86TernaryGPSpecs[Op(name)]
+	form := x86TernaryGPForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	if arch == "386" {
+		form.spec.bits = 32 // VEX.W is ignored, including the Q source spelling.
+	}
+	fail := func() (x86TernaryGPForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside Go _yandnl grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 3 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	form.first, form.second, form.destination = ins.Args[0], ins.Args[1], ins.Args[2]
+	for _, operand := range []Operand{form.second, form.destination} {
+		if operand.Kind != OpReg || !isX86YrlRegisterForArch(operand.Reg, arch) {
+			return fail()
+		}
+	}
+	if form.first.Kind == OpReg {
+		if !isX86YrlRegisterForArch(form.first.Reg, arch) {
+			return fail()
+		}
+	} else if !x86ScalarCompareMemoryValid(form.first, arch) {
+		return fail()
+	}
+	return form, true, nil
+}
+
+func x86TypedTernaryGPByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86TernaryGPProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.spec.bits / 8)
+	effect := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.first, width: width, read: true},
+		{index: 1, operand: form.second, width: width, read: true},
+		{index: 2, operand: form.destination, width: width, write: true},
+	}}
+	if form.spec.operation == x86TernaryANDN {
+		effect.flagsKilled = x86ByteFlagsAll
+		effect.flagsDefined = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+	}
+	return effect, true, nil
+}
+
+func x86RawTernaryGPSource(ins Instr, arch string) bool {
+	_, known, err := x86TernaryGPProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86LoweredTernaryGPResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86TernaryGPProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if x86ResultNamedPredicateInstruction(ins) && !x86OrdinaryNativeMemoryOperand(form.first, arch) {
+		return false, false // Ordinary named register/logical storage uses the strict transfer.
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawTernaryGPSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	if !x86OrdinaryNativeMemoryOperand(form.first, arch) {
+		return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+	}
+	effect, _, _ := x86TypedTernaryGPByteEffect(local.Op, local, arch)
+	for _, input := range effect.operands {
+		if input.read && !x86ResultReadWithNativeContinuation(local, input.operand, input.width, state, owned, arch, true) {
+			return false, true
+		}
+	}
+	if !x86ResultStore(form.destination, int64(form.spec.bits/8), state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
diff --git a/amd64_ternary_logic_boundary_test.go b/amd64_ternary_logic_boundary_test.go
new file mode 100644
index 000000000..359e9ca3d
--- /dev/null
+++ b/amd64_ternary_logic_boundary_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryPhysicalDecoderKeepsReservedAndModeBoundaries(t *testing.T) {
+	for _, row := range x86TernaryCompleteOracleRows() {
+		if row.memory || row.mask >= 0 {
+			continue
+		}
+		code := x86TernaryIndependentFixtureBytes(row)
+		for name, mutate := range map[string]func([]byte) []byte{
+			"missing immediate": func(code []byte) []byte { return code[:len(code)-1] },
+			"reserved LL":       func(code []byte) []byte { code[3] |= 0x60; return code },
+			"zero without mask": func(code []byte) []byte { code[3] |= 0x80; return code },
+			"register BCST":     func(code []byte) []byte { code[3] |= 0x10; return code },
+			"address override":  func(code []byte) []byte { return append([]byte{0x67}, code...) },
+		} {
+			for _, mode := range []int{32, 64} {
+				changed := mutate(append([]byte(nil), code...))
+				if _, _, known, err := decodedX86TernaryLogicInstruction(changed, mode); known && err == nil {
+					t.Fatal("invalid physical ternary encoding accepted", row.row, name, mode)
+				}
+			}
+		}
+		for _, field := range []struct {
+			index int
+			clear byte
+		}{{1, 0x80}, {1, 0x10}, {1, 0x20}, {1, 0x40}, {2, 0x40}, {3, 0x08}} {
+			changed := append([]byte(nil), code...)
+			changed[field.index] &^= field.clear
+			if _, _, known, err := decodedX86TernaryLogicInstruction(changed, 64); !known || err != nil {
+				t.Fatal("valid AMD64 high bank was lost", row.row, field, err)
+			}
+			if _, _, known, err := decodedX86TernaryLogicInstruction(changed, 32); !known || err == nil {
+				t.Fatal("physical386 borrowed an AMD64 high vector bank", row.row, field, err)
+			}
+		}
+		align := append([]byte(nil), code...)
+		align[4] = 0x03
+		if _, _, known, err := decodedX86VectorAlignInstruction(align, 32); !known || err == nil {
+			t.Fatal("ternary-only physical386 repair changed the separate VALIGN boundary")
+		}
+	}
+}
+
+func TestX86TernaryRawContinuationRequiresWholeReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86TernaryCompleteOracleRows() {
+			code := x86TernaryIndependentFixtureBytes(row)
+			source, _ := x86TernaryInitializedFixture("Value", arch, x86RawDisplacementDirectives(code))
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := file.Funcs[0]
+			sig := FuncSig{Name: "Value", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+			for _, mutation := range []string{"none", "missing replay", "changed spelling", "changed origin", "raw entry"} {
+				candidate := function
+				candidate.Instrs = cloneX86ReplayInstrs(function.Instrs)
+				switch mutation {
+				case "missing replay":
+					candidate.x86RawReplay = nil
+				case "changed spelling":
+					candidate.Instrs[1].Raw += " changed"
+				case "changed origin":
+					for index := range candidate.Instrs {
+						if origin := candidate.Instrs[index].x86SourceRaw; origin != nil {
+							origin.ternaryLogic.encoded = false
+						}
+					}
+				case "raw entry":
+					candidate.X86RawText = []byte{0x90}
+				}
+				consumer := amd64Ctx{fpScalarSource: candidate, sig: sig, fpSourceSig: sig, goarch: arch}
+				err := consumer.checkLoweredScalarFPResultInitialization()
+				if mutation == "none" && err != nil || mutation != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("paired ternary numerical role lost complete source or gained raw entry", arch, row.row, mutation, err)
+				}
+			}
+		}
+	}
+}
+
+func x86TernaryInitializedLiteralSource(index int, row x86TernaryOracleRow) string {
+	code := x86TernaryIndependentFixtureBytes(row)
+	// Replace the ordinary address with RIP+disp32 to a complete literal
+	// after the original raw RET. Immediate remains part of the instruction.
+	code = append(append(append([]byte(nil), code[:5]...), 0x15, 1, 0, 0, 0), 150, 0xc3)
+	for at := 0; at < row.sourceWidth; at++ {
+		code = append(code, byte(at*29+11))
+	}
+	return fmt.Sprintf("TEXT ·Literal%d(SB),4,$0-0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nMOVL $85,CX\nKMOVD CX,K7\n%s",
+		index, x86RawDisplacementDirectives(code))
+}
+
+func TestX86TernaryIndependentLiteralOwnerKeepsCompleteInputs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("ternary original literal objects require LLVM22")
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, row := range x86TernaryCompleteOracleRows() {
+		if !row.memory {
+			continue
+		}
+		program := x86TernaryInitializedLiteralSource(count, row)
+		source.WriteString(program)
+		fmt.Fprintf(&declarations, "func Literal%d()\n", count)
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, program), "amd64")
+		if err != nil || len(file.Data) != 1 || len(file.Data[0].Payload) != row.sourceWidth {
+			t.Fatal("literal lost its complete original DATA tuple", row.row, err)
+		}
+		ins := file.Funcs[0].Instrs[5]
+		address, valid := x86StaticSBReadAddress(ins.Args[1], "amd64")
+		if !valid || !x86RawTernaryLogicLiteralForm(ins, "amd64") {
+			t.Fatal("literal lost its separately bound source identity")
+		}
+		for _, mutation := range []string{"none", "short DATA", "missing mask", "changed tuple", "removed origin"} {
+			if mutation == "missing mask" && row.mask < 0 {
+				continue
+			}
+			state := x86TernaryNativeOracleState("amd64", row.width)
+			state.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(row.sourceWidth)}
+			changed := cloneX86ReplayInstrs([]Instr{ins})[0]
+			switch mutation {
+			case "short DATA":
+				state.loweredStaticReads[address]--
+			case "missing mask":
+				state.masks[7] = false
+			case "changed tuple":
+				changed.x86RIPMemoryRead.width--
+			case "removed origin":
+				changed.x86SourceRaw = nil
+			}
+			if accepted, known := x86ResultTernaryLogicStep(changed, &state, nil, "amd64"); !known || accepted != (mutation == "none") {
+				t.Fatal("literal borrowed missing DATA, mask or identity", row.row, mutation, accepted, known)
+			}
+		}
+		count++
+	}
+	if count != 36 {
+		t.Fatal("incomplete full/broadcast/mask literal directory", count)
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // RIP+disp32 is a physical64 DATA role, not mode32 absolute addressing.
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized original raw literal/RET failed its independent DATA owner", err)
+				}
+				for _, pipeline := range []struct{ ir, level string }{
+					{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+				} {
+					x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_ternary_logic_complete_test.go b/amd64_ternary_logic_complete_test.go
new file mode 100644
index 000000000..2c4315603
--- /dev/null
+++ b/amd64_ternary_logic_complete_test.go
@@ -0,0 +1,277 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryTypedEffectsRetainAllTruthTableDependencies(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, aliases := range [][3]int{{2, 1, 0}, {2, 2, 0}, {2, 1, 2}, {2, 1, 1}, {2, 2, 2}} {
+					for selector := 0; selector < 256; selector++ {
+						for _, mode := range []string{"", "merge", "zero"} {
+							suffix, mask := "", ""
+							if mode != "" {
+								mask = ",K7"
+							}
+							if mode == "zero" {
+								suffix = ".Z"
+							}
+							row := fmt.Sprintf("%s%s $%d,%s%d,%s%d%s,%s%d", opcode, suffix, selector, bank, aliases[2], bank, aliases[1], mask, bank, aliases[0])
+							ins := x86ScalarLaneInstruction(t, row)
+							if arch == "386" {
+								ins.x86Encoded = true // Physical grammar only, never an origin or entry certificate.
+								ins.x86VectorBytes = amd64VectorByteWidth(ins.Args[len(ins.Args)-1].Reg)
+							}
+							effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+							if !known || err != nil || !effect.requiresResultProof {
+								t.Fatal("complete selector lost its typed effect", arch, row, known, err)
+							}
+							reads := map[int]bool{}
+							for _, operand := range effect.operands {
+								if register, valid := amd64VectorRegisterIndex(operand.operand.Reg, amd64VectorByteWidth(operand.operand.Reg)); valid && operand.read {
+									reads[register] = true
+								}
+							}
+							for register := 0; register < 3; register++ {
+								want := !ternaryResultBitKnown(selector, aliases, register) || mode == "merge" && aliases[0] == register
+								if reads[register] != want {
+									t.Fatal("typed effect invented or lost a physical Boolean dependency", arch, row, register, reads[register], want)
+								}
+							}
+							if effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+								t.Fatal("Boolean truth table changed FLAGS", row, effect)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86TernaryNativeOracleState(arch string, width int) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward, masks: [8]bool{7: true}}
+	for register := 0; register < 3; register++ {
+		state.writeVector(register, 64, 0xa5a55a5affff0000|x86CallerVectorByteMask(int64(width)), true)
+	}
+	state.gp[0], state.gp[1], state.pointerGP[0] = 0xff, 0xff, true
+	if arch == "386" {
+		state.gp[0], state.gp[1] = 0x0f, 0x0f
+	}
+	return state
+}
+
+func TestX86TernaryRawIdentityMemoryAndIndependentState(t *testing.T) {
+	rows := x86TernaryCompleteOracleRows()
+	raw := x86TernaryOriginalRawRows(t, rows)
+	var source strings.Builder
+	for index, row := range raw {
+		fmt.Fprintf(&source, "TEXT F%d(SB),4,$0-0\n%s\nRET\n", index, row)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source.String()), arch)
+		if err != nil || len(file.Funcs) != 54 {
+			t.Fatal("complete physical ternary source normalization failed", arch, err)
+		}
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				function := file.Funcs[index]
+				ins := function.Instrs[1]
+				if !x86RawTernaryLogicSource(ins, arch) {
+					t.Fatal("actual mode/selector/vector fields lost immutable source identity")
+				}
+				initial := x86TernaryNativeOracleState(arch, row.width)
+				state := initial.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, initial) {
+					t.Fatal("standalone query borrowed a paired raw/native permission")
+				}
+				if accepted, known := x86ResultTernaryLogicContinuationStep(ins, &state, nil, arch, true); !accepted || !known {
+					t.Fatal("complete initialized exact raw inputs failed their paired E4 transfer")
+				}
+				want := initial.clone()
+				want.writeVector(2, row.width, x86CallerVectorByteMask(int64(row.width)), false)
+				if !reflect.DeepEqual(state, want) {
+					t.Fatal("ternary transfer changed independent registers, FLAGS, DF, pointers or upper aliases")
+				}
+				addresses := [16]bool{0: true, 3: true}
+				if !x86ResultPreservesPrivateStorage(ins, arch) ||
+					x86ResultDirectionAfterSource(ins, initial.direction, arch) != initial.direction ||
+					x86ResultCallerAddressesAfter(ins, addresses, nil, arch) != addresses {
+					t.Fatal("exact raw vector effect lost existing private/DF/caller identity facts")
+				}
+				for register := 0; register < 3; register++ {
+					if row.memory && register == 0 {
+						continue // Its physical operand is a volatile memory read, not vector0.
+					}
+					for missing := 0; missing < 64; missing++ {
+						before := initial.clone()
+						before.writeVector(register, 64, before.vectorBytes(register)&^(uint64(1)<<uint(missing)), true)
+						state := before.clone()
+						if accepted, known := x86ResultTernaryLogicContinuationStep(ins, &state, nil, arch, true); !accepted || !known {
+							t.Fatal("nontrapping unknown Boolean input must propagate, never become an invented initialized value")
+						}
+						output := x86CallerVectorByteMask(int64(row.width))
+						if missing < row.width {
+							output &^= uint64(1) << uint(missing) // Selector150 consumes A XOR B XOR C.
+						}
+						want := before.clone()
+						want.writeVector(2, row.width, output, false)
+						if !reflect.DeepEqual(state, want) {
+							t.Fatal("unknown byte or unrelated storage was silently initialized", register, missing)
+						}
+					}
+				}
+				for _, mutate := range []func(*Instr){
+					func(ins *Instr) { ins.Op = "UNKNOWN" },
+					func(ins *Instr) { ins.Args[0].Imm ^= 1 },
+					func(ins *Instr) { ins.Args[2].Reg = "X7" },
+					func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = "X7" },
+					func(ins *Instr) { ins.x86Encoded = false },
+					func(ins *Instr) { ins.x86VectorBytes++ },
+					func(ins *Instr) { ins.x86AddressBits = 32 },
+					func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+					func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+					func(ins *Instr) { ins.x86SourceRaw = nil },
+					func(ins *Instr) {
+						origin := *ins.x86SourceRaw
+						origin.ternaryLogic = x86RawTernaryLogicIdentity{}
+						ins.x86SourceRaw = &origin
+					},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{ins})[0]
+					mutate(&changed)
+					state := initial.clone()
+					if x86RawTernaryLogicSource(changed, arch) {
+						t.Fatal("edited selector/shape/mode borrowed original raw identity")
+					}
+					if accepted, _ := x86ResultTernaryLogicContinuationStep(changed, &state, nil, arch, true); accepted || !reflect.DeepEqual(state, initial) {
+						t.Fatal("rejected raw identity mutated numerical or native state")
+					}
+				}
+				other := "386"
+				if arch == "386" {
+					other = "amd64"
+				}
+				if x86RawTernaryLogicSource(ins, other) {
+					t.Fatal("physical ternary origin borrowed another creation mode")
+				}
+				clone := cloneX86ReplayInstrs(function.Instrs)
+				if clone[1].x86SourceRaw == ins.x86SourceRaw || !x86RawTernaryLogicSource(clone[1], arch) {
+					t.Fatal("immutable replay clone lost or shared mutable physical metadata")
+				}
+				if row.mask >= 0 {
+					state := initial.clone()
+					state.masks[7] = false
+					before := state.clone()
+					if accepted, _ := x86ResultTernaryLogicContinuationStep(ins, &state, nil, arch, true); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("unknown K input borrowed constant-selector or dead-result permission")
+					}
+				}
+				if row.memory {
+					state := initial.clone()
+					state.pointerGP[0] = false
+					before := state.clone()
+					expected := before.clone()
+					expected.writeVector(2, row.width, x86CallerVectorByteMask(int64(row.width)), false)
+					if accepted, known := x86ResultTernaryLogicContinuationStep(ins, &state, nil, arch, true); !known || !accepted || !reflect.DeepEqual(state, expected) {
+						t.Fatal("numerical native read changed independent state or acquired a pointer role")
+					}
+					for _, available := range []uint8{0, 1} {
+						partial := before.clone()
+						partial.gp[0] = available
+						unchanged := partial.clone()
+						if accepted, _ := x86ResultTernaryLogicContinuationStep(ins, &partial, nil, arch, true); accepted || !reflect.DeepEqual(partial, unchanged) {
+							t.Fatal("unknown or partial numerical address acquired native input bytes", available)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86TernaryInitializedFixture(name, arch, instruction string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s p+0(FP),BX\n"+
+			"MOVL $1,CX\nMOVL $85,DX\nKMOVD DX,K7\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"+
+			"STC\n%s\nVMOVDQU64 Z2,(BX)\nSETCS 64(BX)\nRET\n", name, word, move, move, instruction),
+		"func " + name + "(p *byte)\n"
+}
+
+func TestX86TernaryCompleteInitializedNamedRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete ternary initialized objects require LLVM22")
+	}
+	rows := x86TernaryCompleteOracleRows()
+	raw := x86TernaryOriginalRawRows(t, rows)
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			spellings := []string{"raw"}
+			if target.arch == "amd64" {
+				spellings = append(spellings, "named")
+			}
+			for _, spelling := range spellings {
+				t.Run(spelling, func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows {
+						instruction := row.row
+						if spelling == "raw" {
+							instruction = raw[index]
+						}
+						body, declaration := x86TernaryInitializedFixture(fmt.Sprintf("Ternary%d", index), target.arch, instruction)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete initialized ternary public program failed", err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							for _, pipeline := range []struct{ name, ir, backend string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.backend)
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	t.Log("432 complete initialized source kernels, all3 APIs and3 LLVM22 object paths; not original AVX512 execution")
+}
+
+func TestX86TernaryVoidRetainsMaskAndNativeAddressObligations(t *testing.T) {
+	for _, row := range x86TernaryCompleteOracleRows() {
+		if !row.memory && row.mask < 0 {
+			continue // Nontrapping dead register results may remain unknown.
+		}
+		for _, unusedBool := range []bool{false, true} {
+			extent, declaration := 0, "func Missing()"
+			if unusedBool {
+				extent, declaration = 1, "func Missing(unused bool)"
+			}
+			source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s\nRET\n", extent, strings.Replace(row.row, "$150", "$0", 1))
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("constant selector/Void/unused bool invented a mask or native address", row.row, unusedBool, api, err)
+				}
+			}
+		}
+	}
+}
diff --git a/amd64_ternary_logic_fault_runtime_unix_test.go b/amd64_ternary_logic_fault_runtime_unix_test.go
new file mode 100644
index 000000000..f91987f99
--- /dev/null
+++ b/amd64_ternary_logic_fault_runtime_unix_test.go
@@ -0,0 +1,131 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This oracle's original C uses only integers and POSIX page protection. It
+// executes the portable lowering on the actual host, not an AVX512 instruction
+// or MXCSR substitute. The separate MXCSR value owner keeps its x86 tools.
+func x86TernaryGuardPageRuntimeTools(t *testing.T) (llc, clang, triple string, prefix []string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	return llc, clang, testTargetTriple(runtime.GOOS, runtime.GOARCH), nil
+}
+
+// E4 permits suppression by inactive mask lanes, not by a constant truth table
+// or a dead destination. This portable guard-page oracle does not execute
+// original AVX512 instructions; actual Go objects establish source acceptance.
+func TestCrossLinuxRuntimeMatrixX86TernaryDeadReadsAndMaskedFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86TernaryGuardPageRuntimeTools(t)
+	var source, declarations, cases strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	for _, bits := range []int{32, 64} {
+		for width, bank := range map[int]string{16: "X", 32: "Y", 64: "Z"} {
+			for broadcast := 0; broadcast < 2; broadcast++ {
+				for masking := 0; masking < 3; masking++ {
+					name := fmt.Sprint("ternaryFault", count)
+					count++
+					op := "VPTERNLOGD"
+					if bits == 64 {
+						op = "VPTERNLOGQ"
+					}
+					if broadcast != 0 {
+						op += ".BCST"
+					}
+					if masking == 2 {
+						op += ".Z"
+					}
+					mask := ""
+					if masking != 0 {
+						mask = ",K1"
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ k+8(FP),CX\nKMOVQ CX,K1\n%s $0,(AX),%s1%s,%s2\nRET\n", name, op, bank, mask, bank)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}}}}
+					fmt.Fprintf(&declarations, "extern void %s(const uint8_t*,uint64_t);\n", name)
+					fmt.Fprintf(&cases, "{%s,%d,%d,%d,%d},\n", name, width, bits/8, broadcast, masking)
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+struct test {void (*run)(const uint8_t*,uint64_t);unsigned width,lane,broadcast,mask;};
+` + declarations.String() + "static const struct test cases[]={\n" + cases.String() + `};
+static int observe(const struct test *test,const uint8_t *p,uint64_t mask) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        test->run(p,mask);
+        _exit(0);
+    }
+    int status=0;
+    if(waitpid(child,&status,0)!=child) return -2;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -3;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    for(unsigned i=0;i<sizeof(cases)/sizeof(cases[0]);i++) {
+        const struct test *test=cases+i;
+        unsigned lanes=test->width/test->lane;
+        uint64_t masks[]={0,1,UINT64_C(1)<<(lanes-1),UINT64_C(1)<<63,UINT64_MAX};
+        unsigned extents[]={0,test->lane-1,test->lane,test->width-1,test->width};
+        for(unsigned m=0;m<5;m++) for(unsigned e=0;e<5;e++) {
+            unsigned required=0;
+            for(unsigned lane=0;lane<lanes;lane++) {
+                if(!test->mask || (masks[m]>>lane&1))
+                    required=test->broadcast?test->lane:(lane+1)*test->lane;
+            }
+            int expected=required>extents[e];
+            int got=observe(test,region+page-extents[e],masks[m]);
+            if(got!=expected) {
+                fprintf(stderr,"case=%u mask=%llx extent=%u got=%d want=%d\n",i,(unsigned long long)masks[m],extents[e],got,expected);
+                return 3;
+            }
+        }
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	for _, optimize := range []bool{false, true} {
+		text := ir
+		if optimize {
+			text = x86MulDivRoundOptimize(t, text)
+		}
+		t.Run(fmt.Sprint("IR_O2=", optimize), func(t *testing.T) {
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "ternary-faults", triple, text, driver, prefix)
+		})
+	}
+	t.Logf("%d E4 forms x5 masks x5 guard extents x2 IR pipelines; constant truth/dead output remains observable", count)
+}
diff --git a/amd64_ternary_logic_forms.go b/amd64_ternary_logic_forms.go
new file mode 100644
index 000000000..390f45afd
--- /dev/null
+++ b/amd64_ternary_logic_forms.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86TernaryLogicForm struct {
+	laneBits, byteWidth, destination int
+	mask, memory, memoryBytes        int
+	broadcast, zeroing               bool
+	inputs                           [3]int // Intel A=old destination, B=vvvv, C=r/m.
+	terms                            uint8  // Boolean algebraic normal form coefficients.
+}
+
+// Go's complete _yvalignd grammar is shared by D/Q. Encoding validation
+// establishes neither initialized bytes nor permission to access native memory.
+func x86TernaryLogicProperties(op Op, ins Instr, arch string) (x86TernaryLogicForm, bool, error) {
+	base, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	bits, known := amd64TernaryLogicSpecs[Op(base)]
+	if !known {
+		return x86TernaryLogicForm{}, false, nil
+	}
+	f := x86TernaryLogicForm{laneBits: bits, destination: len(ins.Args) - 1, mask: -1, memory: -1}
+	fail := func() (x86TernaryLogicForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go ternary-logic grammar: %q", arch, op, ins.Raw)
+	}
+	// The named 386 frontend rejects four/five operands, independently of
+	// the legal low-bank EVEX physical forms observed by the raw decoder.
+	physical32 := arch == "386" && (ins.x86Encoded || ins.x86SourceRaw != nil)
+	if arch != "amd64" && !physical32 || ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return fail()
+	}
+	switch suffix {
+	case "":
+		if dotted {
+			return fail()
+		}
+	case "Z":
+		f.zeroing = true
+	case "BCST":
+		f.broadcast = true
+	case "BCST.Z":
+		f.broadcast, f.zeroing = true, true
+	default:
+		return fail()
+	}
+	if len(ins.Args) != 4 && len(ins.Args) != 5 {
+		return fail()
+	}
+	if len(ins.Args) == 5 {
+		if !amd64NonzeroKOperand(ins.Args[3]) {
+			return fail()
+		}
+		f.mask = 3
+	} else if f.zeroing {
+		return fail()
+	}
+	immediate, integer := x86ImmediateShuffleConstant(ins.Args[0], arch, ins.x86Encoded)
+	if !integer || immediate.Imm < 0 || immediate.Imm > 255 {
+		return fail()
+	}
+	f.byteWidth = amd64VectorByteWidth(ins.Args[f.destination].Reg)
+	register := func(operand Operand) bool {
+		index, valid := amd64VectorRegisterIndex(operand.Reg, f.byteWidth)
+		return amd64EVEXVectorRegister(operand, f.byteWidth) && valid && (arch != "386" || index < 8)
+	}
+	if !register(ins.Args[f.destination]) || !register(ins.Args[2]) {
+		return fail()
+	}
+	source := ins.Args[1]
+	if isAMD64MemoryOperand(source) {
+		if !x86PackedShiftMemoryValid(source, arch) {
+			return fail()
+		}
+		if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return f, true, fmt.Errorf("%w: ternary logic has no bound native address-size override", ErrProbeNeedsContext)
+		}
+		if source.Kind == OpMem {
+			if err := x86SymbolIndexedMemoryError(source.Mem, arch); err != nil {
+				return f, true, err
+			}
+			if source.Mem.OffRaw != "" || source.Mem.IndexExt != "" {
+				return fail()
+			}
+		}
+		f.memory, f.memoryBytes = 1, f.byteWidth
+		if f.broadcast {
+			f.memoryBytes = bits / 8
+		}
+	} else if f.broadcast || !register(source) {
+		return fail()
+	}
+	f.inputs = [3]int{f.destination, 2, 1}
+	representatives := [3]int{0, 1, 2}
+	for role, index := range f.inputs {
+		for earlier := 0; earlier < role; earlier++ {
+			other := f.inputs[earlier]
+			if ins.Args[index].Kind == OpReg && ins.Args[other].Kind == OpReg && ins.Args[index].Reg == ins.Args[other].Reg {
+				representatives[role] = representatives[earlier]
+				break
+			}
+		}
+	}
+	f.terms = x86TernaryLogicTerms(uint8(immediate.Imm), representatives)
+	return f, true, nil
+}
+
+// Convert the truth table to its unique XOR-of-ANDs representation. First
+// identify equal physical inputs, so x XOR x and independent input variables
+// disappear before emission. This avoids relying on LLVM undef cancellation.
+func x86TernaryLogicTerms(immediate uint8, representatives [3]int) uint8 {
+	var coefficients [8]uint8
+	for assignment := range coefficients {
+		truth := 0
+		for _, representative := range representatives {
+			truth = truth*2 + (assignment>>uint(representative))&1
+		}
+		coefficients[assignment] = immediate >> uint(truth) & 1
+	}
+	for bit := 1; bit < 8; bit <<= 1 {
+		for subset := range coefficients {
+			if subset&bit != 0 {
+				coefficients[subset] ^= coefficients[subset^bit]
+			}
+		}
+	}
+	var terms uint8
+	for subset, coefficient := range coefficients {
+		terms |= coefficient << uint(subset)
+	}
+	return terms
+}
+
+func (f x86TernaryLogicForm) dependencies() uint8 {
+	var inputs uint8
+	for subset := 1; subset < 8; subset++ {
+		if f.terms>>uint(subset)&1 != 0 {
+			inputs |= uint8(subset)
+		}
+	}
+	return inputs
+}
+
+func x86TypedTernaryLogicByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86TernaryLogicProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	dependencies := form.dependencies()
+	if form.mask >= 0 && !form.zeroing {
+		dependencies |= 1 // An inactive merging lane retains the old A value.
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for role, index := range form.inputs {
+		width := form.byteWidth
+		read := dependencies>>uint(role)&1 != 0
+		if index == form.memory {
+			// Physical E4 access remains observable even when the selected
+			// Boolean function does not depend on its loaded numerical value.
+			width, read = form.memoryBytes, true
+		}
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: index, operand: ins.Args[index], width: int64(width),
+			read: read, write: index == form.destination,
+		})
+	}
+	if form.mask >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.mask, operand: ins.Args[form.mask], width: 8, read: true,
+		})
+	}
+	return effect, true, nil
+}
diff --git a/amd64_ternary_logic_forms_test.go b/amd64_ternary_logic_forms_test.go
new file mode 100644
index 000000000..13da21930
--- /dev/null
+++ b/amd64_ternary_logic_forms_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryTypedGrammarActualGoCompleteRows(t *testing.T) {
+	var source strings.Builder
+	count := 0
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, memory := range []string{bank + "29", "-64(AX)(CX*4)", "data+0(FP)", "·data(SB)"} {
+				for _, mode := range []string{"", "merge", "zero", "broadcast", "broadcast_zero"} {
+					broadcast := strings.HasPrefix(mode, "broadcast")
+					if broadcast && memory == bank+"29" {
+						continue
+					}
+					suffix, mask := "", ""
+					if broadcast {
+						suffix = ".BCST"
+					}
+					if mode == "merge" || mode == "zero" || mode == "broadcast_zero" {
+						mask = ",K7"
+					}
+					if strings.HasSuffix(mode, "zero") {
+						suffix += ".Z"
+					}
+					row := fmt.Sprintf("%s%s $255,%s,%s30%s,%s31", op, suffix, memory, bank, mask, bank)
+					ins := x86ScalarLaneInstruction(t, row)
+					if _, recognized, err := x86TernaryLogicProperties(ins.Op, ins, "amd64"); !recognized || err != nil {
+						t.Fatal(row, err)
+					}
+					fmt.Fprintf(&source, "TEXT form%d(SB),4,$0-64\n%s\nRET\n", count, row)
+					count++
+				}
+			}
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch == "amd64" {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		} else {
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", false)
+		}
+	}
+	t.Logf("%d independent Go opcode/width/source/mask/broadcast witnesses", count)
+}
+
+func TestX86TernaryTypedGrammarRejectsFabricatedOperands(t *testing.T) {
+	for _, mutate := range []func(*Instr){
+		func(ins *Instr) { ins.Args[0].ImmRaw = "unresolved" },
+		func(ins *Instr) { ins.Args[0].ImmIsFloat = true },
+		func(ins *Instr) { ins.Args[1].Mem.OffRaw = "unresolved" },
+		func(ins *Instr) { ins.Args[1].Mem.IndexExt = "UXTW" },
+		func(ins *Instr) { ins.Args[1].Mem.Index, ins.Args[1].Mem.Scale = CX, 3 },
+		func(ins *Instr) { ins.Args[1].Mem.Index, ins.Args[1].Mem.Scale = SP, 1 },
+		func(ins *Instr) { ins.Args[1].Mem.Base = "R16" },
+		func(ins *Instr) { ins.Args[1].Mem.Off = 1 << 32 },
+		func(ins *Instr) { ins.x86AddressBits = 32 },
+		func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+	} {
+		ins := x86ScalarLaneInstruction(t, "VPTERNLOGD $150,(AX),X1,X2")
+		mutate(&ins)
+		if _, known, err := x86TernaryLogicProperties(ins.Op, ins, "amd64"); !known || err == nil {
+			t.Fatalf("fabricated source accepted: %#v", ins)
+		}
+		state := x86ResultState{}
+		if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+			t.Fatal("malformed source received numerical credit")
+		}
+	}
+}
+
+func TestX86TernaryNativeSegmentsAndUnboundAddresses(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·view(SB),4,$0-0\n")
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, memory := range []string{"8(AX)(FS)", "8(AX)(GS)"} {
+				fmt.Fprintf(&source, "%s.BCST.Z $255,%s,%s1,K1,%s2\n", op, memory, bank, bank)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Both actual Go mode32 rejection axes are covered above.
+		}
+		// Retain the original twelve source rows, actual Go objects, both
+		// segment address spaces and emitter objects. This source has neither
+		// an initialized K1 nor a bound segment address; it is not a public
+		// numerical or ABI success. Complete initialized ordinary-memory
+		// counterparts live in the independent 54-row public object matrix.
+		file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+		ir := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+		for _, space := range []string{"ptr addrspace(256)", "ptr addrspace(257)"} {
+			if !strings.Contains(ir, space) {
+				t.Fatal("original segment format address space erased", space)
+			}
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+		}
+	}
+	for _, unbound := range []bool{false, true} {
+		ins := x86ScalarLaneInstruction(t, "VPTERNLOGD $0,(AX),X1,X2")
+		ins.x86AddressBits = 32
+		ins.x86UnboundAddressOverride = unbound
+		var output strings.Builder
+		ctx := amd64Ctx{goarch: "amd64", b: &output}
+		if _, _, err := ctx.lowerTernaryLogic(ins.Op, ins); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+			t.Fatal("unbound native memory emitted IR", err)
+		}
+	}
+}
diff --git a/amd64_ternary_logic_native_regression_test.go b/amd64_ternary_logic_native_regression_test.go
new file mode 100644
index 000000000..a5e9d9612
--- /dev/null
+++ b/amd64_ternary_logic_native_regression_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Keep the discovering programs, complete truth tables, C references and
+// observations independent of this smaller native-input counterexample.
+func x86TernaryOriginalRuntimeProgramsUnchanged(t *testing.T) {
+	t.Helper()
+	for _, original := range []struct{ path, name, hash string }{
+		{"amd64_ternary_logic_runtime_test.go", "TestCrossLinuxRuntimeMatrixX86TernaryAllTruthTablesAndForms", "051de207c52d2a346802faa78b0d505913ded1aae784f585690df6adf19efb9e"},
+		{"amd64_ternary_logic_fault_runtime_unix_test.go", "TestCrossLinuxRuntimeMatrixX86TernaryDeadReadsAndMaskedFaults", "48a52e289c20ccd8fcd5999beb51cdad33e72bfa05cd5a4a6bc7d76b9c2e5d3d"},
+	} {
+		data, err := os.ReadFile(original.path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		set := token.NewFileSet()
+		syntax, err := parser.ParseFile(set, original.path, data, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, declaration := range syntax.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Name.Name != original.name {
+				continue
+			}
+			start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+			body := string(data[start:end])
+			if original.name == "TestCrossLinuxRuntimeMatrixX86TernaryDeadReadsAndMaskedFaults" {
+				// Only the host selector changes: preserve the old complete
+				// function hash, including every ASM/C byte, case and observation.
+				const portable = "llc, clang, triple, prefix := x86TernaryGuardPageRuntimeTools(t)"
+				const previous = "llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)"
+				if strings.Count(body, portable) != 1 {
+					t.Fatal("original integer guard-page oracle lost actual-host execution")
+				}
+				body = strings.Replace(body, portable, previous, 1)
+			}
+			if fmt.Sprintf("%x", sha256.Sum256([]byte(body))) != original.hash {
+				t.Fatal("original ternary runtime source/reference/observations changed", original.name)
+			}
+			found = true
+		}
+		if !found {
+			t.Fatal("original ternary runtime disappeared", original.name)
+		}
+	}
+}
+
+func TestX86TernaryInitializedNativeReadRetainsConstantAccess(t *testing.T) {
+	x86TernaryOriginalRuntimeProgramsUnchanged(t)
+	for _, opcode := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+			fixture := func(first string) string {
+				return "TEXT ·view(SB),4,$0-16\nMOVQ out+0(FP),AX\nMOVQ p+8(FP),SI\n" +
+					opcode + " $0," + first + "," + bank + "1," + bank + "2\nVMOVDQU64 Z2,(AX)\nRET\n"
+			}
+			register, memory := fixture(bank+"0"), fixture("(SI)")
+			goAssemblerOracleOutput(t, "amd64", register+strings.Replace(memory, "·view", "·memory", 1), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(opcode+"/"+bank+"/"+api, func(t *testing.T) {
+					// Selector zero needs no vector data, but its physical memory
+					// form must still access the incoming pointer. The positive
+					// register control must succeed before diagnosing that gap.
+					if _, err := x86ScalarFPBitViewAPI(t, register, "func view(out,p *byte)", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Fatal("register positive control failed before native-read comparison", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, memory, "func view(out,p *byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatal("changing only r/m to a genuine incoming pointer lost paired E4 continuation", err)
+					}
+					if !strings.Contains(ir, fmt.Sprintf("load volatile <%d x i8>", width)) {
+						t.Fatal("constant truth table or dead numerical input removed the original memory access")
+					}
+				})
+			}
+		}
+	}
+}
+
+type x86TernaryOracleRow struct {
+	row                        string
+	width, sourceWidth, mask   int
+	destination, laneBits      int
+	broadcast, zeroing, memory bool
+}
+
+// Two Go opcodes, three physical widths, register/full-tuple/broadcast
+// sources and unmasked/merging/zeroing modes. All 256 Boolean selectors and
+// five register-alias partitions already have their independent cheap oracle
+// in TestX86TernaryResultCompleteBooleanDomain; do not multiply that axis by
+// this physical matrix or by target object compilation.
+func x86TernaryCompleteOracleRows() []x86TernaryOracleRow {
+	var rows []x86TernaryOracleRow
+	for _, opcode := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		bits := 32
+		if opcode == "VPTERNLOGQ" {
+			bits = 64
+		}
+		for _, bank := range []struct {
+			name  string
+			width int
+		}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+			for _, source := range []string{"register", "memory", "broadcast"} {
+				for _, mode := range []string{"", "merge", "zero"} {
+					row := x86TernaryOracleRow{
+						width: bank.width, sourceWidth: bank.width, laneBits: bits,
+						mask: -1, destination: 3, memory: source != "register",
+						broadcast: source == "broadcast", zeroing: mode == "zero",
+					}
+					first, suffix, mask := bank.name+"0", "", ""
+					if row.memory {
+						first = "-64(AX)(CX*4)"
+					}
+					if row.broadcast {
+						suffix, row.sourceWidth = ".BCST", bits/8
+					}
+					if mode != "" {
+						mask, row.mask, row.destination = ",K7", 3, 4
+					}
+					if row.zeroing {
+						suffix += ".Z"
+					}
+					row.row = fmt.Sprintf("%s%s $150,%s,%s1%s,%s2", opcode, suffix, first, bank.name, mask, bank.name)
+					rows = append(rows, row)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86TernaryCompleteOfficialGoAttributes(t *testing.T) {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	begin := strings.Index(text, "var _yvalignd = []ytab{")
+	if begin < 0 {
+		t.Fatal("official Go omitted the ternary operand table")
+	}
+	table := strings.SplitN(text[begin:], "\n}", 2)[0]
+	if strings.Count(table, "{zcase:") != 6 {
+		t.Fatal("official ternary operand-table denominator changed", table)
+	}
+	for _, classes := range [][2]string{{"YxmEvex", "YxrEvex"}, {"YymEvex", "YyrEvex"}, {"Yzm", "Yzr"}} {
+		for _, row := range []string{
+			"{zcase: Zevex_i_rm_v_r, zoffset: 0, args: argList{Yu8, " + classes[0] + ", " + classes[1] + ", " + classes[1] + "}}",
+			"{zcase: Zevex_i_rm_v_k_r, zoffset: 3, args: argList{Yu8, " + classes[0] + ", " + classes[1] + ", Yknot0, " + classes[1] + "}}",
+		} {
+			if !strings.Contains(table, row) {
+				t.Fatal("complete Go ternary zcase/offset/operand classes changed", row)
+			}
+		}
+	}
+	for _, opcode := range []struct{ name, w, broadcast string }{
+		{"VPTERNLOGD", "evexW0", "evexBcstN4"},
+		{"VPTERNLOGQ", "evexW1", "evexBcstN8"},
+	} {
+		begin := strings.Index(text, "{as: A"+opcode.name+",")
+		if begin < 0 {
+			t.Fatal("official Go omitted ternary member", opcode.name)
+		}
+		block := strings.SplitN(text[begin:], "\n\t}},", 2)[0]
+		if !strings.Contains(block, "ytab: _yvalignd, prefix: Pavx, op: opBytes{") || strings.Count(block, "avxEscape") != 3 {
+			t.Fatal("official ternary opcode/header/width denominator changed", block)
+		}
+		for _, width := range []struct{ encoding, tuple string }{{"evex128", "evexN16"}, {"evex256", "evexN32"}, {"evex512", "evexN64"}} {
+			attributes := "avxEscape | " + width.encoding + " | evex66 | evex0F3A | " + opcode.w + ", " +
+				width.tuple + " | " + opcode.broadcast + " | evexZeroingEnabled, 0x25,"
+			if !strings.Contains(block, attributes) {
+				t.Fatal("complete ternary opcode/map/W/tuple/broadcast/zeroing attributes changed", attributes)
+			}
+		}
+	}
+}
+
+func TestX86TernaryCompleteTypedClassRegistration(t *testing.T) {
+	x86TernaryCompleteOfficialGoAttributes(t)
+	rows := x86TernaryCompleteOracleRows()
+	if len(rows) != 54 {
+		t.Fatal("complete two-name/nine-mode/three-width ternary inventory changed", len(rows))
+	}
+	var source strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&source, "TEXT ternaryFormat%d(SB),4,$0-0\n%s\nRET\n", index, row.row)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	for _, row := range rows {
+		t.Run(row.row, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if !known || err != nil || !effect.requiresResultProof {
+				t.Fatal("complete ternary class lacks mandatory typed numerical effects", known, err)
+			}
+			reads, writes := make(map[int]bool), make(map[int]bool)
+			for _, operand := range effect.operands {
+				want := int64(row.width)
+				if operand.index == 1 {
+					want = int64(row.sourceWidth)
+				} else if operand.index == row.mask {
+					want = 8
+				}
+				if operand.index == 0 || operand.width != want {
+					t.Fatal("selector is not vector data; full tuple, BCST and K widths must remain distinct", operand)
+				}
+				reads[operand.index] = reads[operand.index] || operand.read
+				writes[operand.index] = writes[operand.index] || operand.write
+			}
+			// Selector 150 is A XOR B XOR C, so even zero masking
+			// consumes the old destination as data, not merely for merge.
+			if !reads[1] || !reads[2] || !reads[row.destination] || !writes[row.destination] ||
+				row.mask >= 0 && !reads[row.mask] || writes[1] || writes[2] ||
+				effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+				t.Fatal("ternary source/old-destination/mask roles or unchanged FLAGS lost", effect)
+			}
+		})
+	}
+}
diff --git a/amd64_ternary_logic_physical_test.go b/amd64_ternary_logic_physical_test.go
new file mode 100644
index 000000000..ca3fda9ef
--- /dev/null
+++ b/amd64_ternary_logic_physical_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent EVEX.66.0F3A.W0/W1.25 /r ib witnesses use only banks 0-2
+// and AX+CX*4. Their low-bank physical mode32 encodings are valid even
+// though Go's named 386 frontend cannot express four or five operands.
+func x86TernaryIndependentFixtureBytes(row x86TernaryOracleRow) []byte {
+	p1, p2 := byte(0x75), byte(0x08)
+	if row.laneBits == 64 {
+		p1 |= 0x80
+	}
+	switch row.width {
+	case 32:
+		p2 |= 0x20
+	case 64:
+		p2 |= 0x40
+	}
+	if row.mask >= 0 {
+		p2 |= 7
+	}
+	if row.zeroing {
+		p2 |= 0x80
+	}
+	if row.broadcast {
+		p2 |= 0x10
+	}
+	code := []byte{0x62, 0xf3, p1, p2, 0x25}
+	if row.memory {
+		// ModRM: dst=2, mod01, SIB; SIB: scale4, CX, AX.
+		// EVEX disp8 scales by the complete tuple or BCST element.
+		code = append(code, 0x54, 0x88, byte(int8(-64/row.sourceWidth)))
+	} else {
+		code = append(code, 0xd0)
+	}
+	return append(code, 150)
+}
+
+func x86TernaryOriginalRawRows(t *testing.T, rows []x86TernaryOracleRow) []string {
+	t.Helper()
+	var instructions []string
+	var expected []byte
+	var raw []string
+	for _, row := range rows {
+		instructions = append(instructions, row.row)
+		code := x86TernaryIndependentFixtureBytes(row)
+		expected = append(expected, code...)
+		raw = append(raw, strings.TrimSuffix(x86RawDisplacementDirectives(code), "\n"))
+	}
+	expected = append(expected, 0xc3)
+	listing, err := x86ExtensionGoListing(t, "amd64", strings.Join(instructions, "\n"))
+	if err != nil {
+		t.Fatalf("actual complete ternary Go byte listing: %v\n%s", err, listing)
+	}
+	var actual []byte
+	for _, line := range strings.Split(listing, "\n") {
+		actual = append(actual, x86InsertExtractListedBytes(line)...)
+	}
+	if !bytes.Equal(actual, expected) {
+		t.Fatalf("whole Go ternary bytes, including final RET, differ from independent EVEX fields\ngot  %x\nwant %x\n%s", actual, expected, listing)
+	}
+	return raw
+}
+
+func TestX86TernaryPhysicalMode32KeepsCompleteRawClass(t *testing.T) {
+	rows := x86TernaryCompleteOracleRows()
+	raw := x86TernaryOriginalRawRows(t, rows)
+	if len(raw) != 54 {
+		t.Fatal("complete physical ternary matrix changed", len(raw))
+	}
+	var source strings.Builder
+	for index, instruction := range raw {
+		fmt.Fprintf(&source, "TEXT rawTernary%d(SB),4,$0-0\n%s\nRET\n", index, instruction)
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch == "386" {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		}
+	}
+	for _, row := range rows {
+		t.Run(row.row, func(t *testing.T) {
+			named := x86ScalarLaneInstruction(t, row.row)
+			if _, known, err := x86TernaryLogicProperties(named.Op, named, "386"); !known || err == nil {
+				t.Fatal("named386 operand limit must remain independent of physical EVEX support", known, err)
+			}
+			code := x86TernaryIndependentFixtureBytes(row)
+			ins, length, known, err := decodedX86TernaryLogicInstruction(code, 32)
+			if !known || err != nil || length != len(code) {
+				t.Fatal("legal low-bank physical386 ternary encoding borrowed named frontend rejection", known, length, err)
+			}
+			form, known, err := x86TernaryLogicProperties(ins.Op, ins, "386")
+			if !known || err != nil || !ins.x86Encoded || ins.x86VectorBytes != row.width ||
+				form.byteWidth != row.width || form.memoryBytes != row.sourceWidth && row.memory ||
+				form.broadcast != row.broadcast || form.zeroing != row.zeroing || form.mask != row.mask {
+				t.Fatal("physical mode/width/mask/broadcast metadata lost", ins, form, known, err)
+			}
+		})
+	}
+}
diff --git a/amd64_ternary_logic_result.go b/amd64_ternary_logic_result.go
new file mode 100644
index 000000000..a453d65db
--- /dev/null
+++ b/amd64_ternary_logic_result.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+func x86ResultTernaryLogicStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultTernaryLogicContinuationStep(ins, state, owned, arch, false)
+}
+
+// Only the paired lowering observer may consume the exact E4 volatile reads.
+// Boolean independence, zero masks and dead results supply no pointer or
+// reusable backing. The standalone transfer retains its original boundary.
+func x86ResultTernaryLogicContinuationStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, recognized, err := x86TernaryLogicProperties(ins.Op, ins, arch)
+	if !recognized {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		literal := state.loweredStaticReads != nil && x86RawTernaryLogicLiteralForm(ins, arch)
+		if !literal && (!nativeRead || !x86RawTernaryLogicSource(ins, arch)) {
+			return false, true
+		}
+		// Capture the physical form above. A lowering-local numerical view
+		// must not reapply the separate named386 arity limit afterward.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultTernaryLogicInputs(ins, form, state, owned, arch, nativeRead), true
+}
+
+func x86ResultTernaryLogicInputs(ins Instr, form x86TernaryLogicForm, state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.mask >= 0 {
+		index, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[index] {
+			return false
+		}
+	}
+	// Fault suppression and truth-table independence never grant authority to
+	// read an unknown address or a partially described memory tuple.
+	if form.memory >= 0 && !x86ResultReadWithNativeContinuation(ins, ins.Args[form.memory], int64(form.memoryBytes), state, owned, arch, nativeRead) {
+		return false
+	}
+	known := x86CallerVectorByteMask(int64(form.byteWidth))
+	dependencies := form.dependencies()
+	if form.mask >= 0 && !form.zeroing {
+		dependencies |= 1 // Inactive merging lanes preserve A.
+	}
+	for role, argument := range form.inputs {
+		if dependencies>>uint(role)&1 == 0 || argument == form.memory {
+			continue
+		}
+		index, _ := amd64VectorRegisterIndex(ins.Args[argument].Reg, form.byteWidth)
+		known &= state.vectorBytes(index)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, known, false)
+	return true
+}
diff --git a/amd64_ternary_logic_result_test.go b/amd64_ternary_logic_result_test.go
new file mode 100644
index 000000000..0e32f3e56
--- /dev/null
+++ b/amd64_ternary_logic_result_test.go
@@ -0,0 +1,241 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryResultWholeCFGAndUnknownInputs(t *testing.T) {
+	for _, fixture := range []struct {
+		row  string
+		pass bool
+	}{
+		{"VPTERNLOGD $0,Z0,Z1,Z2", true},
+		{"VPTERNLOGQ $255,Z0,Z1,Z2", true},
+		{"VPTERNLOGD $60,Z0,Z2,Z2", true},   // A XOR B, A=B.
+		{"VPTERNLOGQ $90,Z2,Z1,Z2", true},   // A XOR C, A=C.
+		{"VPTERNLOGD $102,Z0,Z0,Z2", true},  // B XOR C, B=C.
+		{"VPTERNLOGQ $150,Z2,Z2,Z2", false}, // A XOR A XOR A remains A.
+		{"VPTERNLOGD $150,Z0,Z1,Z2", false},
+	} {
+		source := "TEXT ·view(SB),4,$0-4\n" + fixture.row + "\nPEXTRD $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if !fixture.pass {
+				x86VectorScratchCodegenControl(t, source, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				continue
+			}
+			if err != nil {
+				t.Fatal(fixture.row, api, err)
+			}
+		}
+	}
+	for _, other := range []string{"VPTERNLOGD $255,Z0,Z1,Z2", "NOP"} {
+		source := `TEXT ·view(SB),4,$0-12
+MOVL a+0(FP),AX
+CMPL AX,$0
+JE other
+VPTERNLOGD $255,Z0,Z1,Z2
+JMP joined
+other:
+` + other + `
+joined:
+VPTERNLOGQ $240,Z0,Z1,Z2
+PEXTRD $0,X2,AX
+MOVL AX,ret+8(FP)
+RET
+`
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if other == "NOP" {
+				x86VectorScratchCodegenControl(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				continue
+			}
+			if err != nil {
+				t.Fatal("CFG joined an unknown predecessor as initialized", api, err)
+			}
+		}
+	}
+	const deadRead = `TEXT ·view(SB),4,$0-4
+JMP finish
+VPTERNLOGD $0,(AX),Z1,Z2
+finish:
+MOVL $1,AX
+MOVL AX,X2
+PEXTRD $0,X2,AX
+MOVL AX,ret+0(FP)
+RET
+`
+	goAssemblerOracleOutput(t, "amd64", deadRead, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		if _, err := x86ScalarFPBitViewAPI(t, deadRead, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("constant truth table bypassed dead unbound memory", api, err)
+		}
+	}
+}
+
+// This oracle enumerates physical register assignments independently of the
+// production Boolean normal form. Missing bytes may have either bit value.
+func ternaryResultBitKnown(immediate int, registers [3]int, unknown int) bool {
+	for assignment := 0; assignment < 8; assignment++ {
+		truth := func(bits int) int {
+			index := 0
+			for _, register := range registers {
+				index = index*2 + (bits>>uint(register))&1
+			}
+			return immediate >> uint(index) & 1
+		}
+		if truth(assignment) != truth(assignment^(1<<uint(unknown))) {
+			return false
+		}
+	}
+	return true
+}
+
+func TestX86TernaryResultCompleteBooleanDomain(t *testing.T) {
+	partitions := [][3]int{{2, 1, 0}, {2, 2, 0}, {2, 1, 2}, {2, 1, 1}, {2, 2, 2}}
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for width, bank := range map[int]string{16: "X", 32: "Y", 64: "Z"} {
+			for _, registers := range partitions {
+				for immediate := 0; immediate < 256; immediate++ {
+					for _, mode := range []string{"", "merge", "zero"} {
+						suffix, mask := "", ""
+						if mode != "" {
+							mask = ",K3"
+						}
+						if mode == "zero" {
+							suffix = ".Z"
+						}
+						row := fmt.Sprintf("%s%s $%d,%s%d,%s%d%s,%s%d", op, suffix, immediate, bank, registers[2], bank, registers[1], mask, bank, registers[0])
+						ins := x86ScalarLaneInstruction(t, row)
+						for missing := 0; missing < 3; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{3: true}}
+							for register := 0; register < 3; register++ {
+								state.writeVector(register, 64, ^uint64(0), false)
+							}
+							// Every other byte is unknown; verify byte-local effects.
+							state.writeVector(missing, 64, 0x5555555555555555, false)
+							before := state.clone()
+							if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+								t.Fatalf("missing complete typed effect: %s", row)
+							}
+							known := ternaryResultBitKnown(immediate, registers, missing)
+							known = known && (mode != "merge" || missing != registers[0])
+							want := ^uint64(0)
+							if !known {
+								want &^= 0xaaaaaaaaaaaaaaaa & x86CallerVectorByteMask(int64(width))
+							}
+							if state.vectorBytes(registers[0]) != want || state.flags != before.flags {
+								t.Fatalf("%s unknown bank%d: got %016x, want %016x", row, missing, state.vectorBytes(registers[0]), want)
+							}
+							for register := 0; register < 3; register++ {
+								if register != registers[0] && state.vectorBytes(register) != before.vectorBytes(register) {
+									t.Fatal("unrelated bank changed", row)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86TernaryRejectsNonIntegerAndMalformedMemory(t *testing.T) {
+	for _, immediate := range []string{"0.0", "1.5"} {
+		row := "VPTERNLOGD $" + immediate + ",X0,X1,X2"
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu"}); err == nil {
+			t.Errorf("accepted floating truth table: %s", row)
+		}
+	}
+}
+
+func TestX86TernaryResultMemoryAndMaskBoundaries(t *testing.T) {
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, source := range []string{"(AX)", "·external(SB)", "0", "a+0(FP)"} {
+			for _, suffix := range []string{"", ".BCST"} {
+				row := fmt.Sprintf("%s%s $255,%s,Z1,Z2", op, suffix, source)
+				ins := x86ScalarLaneInstruction(t, row)
+				width := 64
+				if suffix != "" {
+					width = 4
+					if op == "VPTERNLOGQ" {
+						width = 8
+					}
+				}
+				for missing := -1; missing < 64; missing++ {
+					state := x86ResultState{fp: make([]bool, 64)}
+					owned := make([]bool, 64)
+					for at := range state.fp {
+						state.fp[at] = at != missing
+						owned[at] = true
+					}
+					got := x86ResultTransfer(ins, &state, owned, 0, "amd64")
+					want := source == "a+0(FP)" && (missing < 0 || missing >= width)
+					if got != want {
+						t.Fatalf("memory authority/full envelope: %s missing%d got%t want%t", row, missing, got, want)
+					}
+				}
+			}
+		}
+	}
+	for _, suffix := range []string{"", ".Z"} {
+		ins := x86ScalarLaneInstruction(t, "VPTERNLOGD"+suffix+" $255,Z0,Z1,K3,Z2")
+		state := x86ResultState{}
+		if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+			t.Fatal("constant Boolean value bypassed unknown mask")
+		}
+	}
+}
+
+func TestX86TernaryResultThreeAPIsAndActualGoTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, immediate := range []int{0, 255, 150, 170, 204, 240} {
+				fmt.Fprintf(&declarations, "func ternary%d() uint32\n", count)
+				fmt.Fprintf(&source, "TEXT ·ternary%d(SB),4,$0-4\n", count)
+				// With three equal unknown inputs, XOR3 and projections remain
+				// unknown. Initialize those cases through an independent move.
+				if immediate != 0 && immediate != 255 {
+					fmt.Fprintf(&source, "VPXORQ %[1]s1,%[1]s1,%[1]s1\n", bank)
+				}
+				fmt.Fprintf(&source, "%s $%d,%s1,%s1,%s1\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", op, immediate, bank, bank, bank)
+				count++
+			}
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch == "386" {
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", false)
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api); err == nil {
+					t.Fatal("mode32 accepted Go's rejected four-operand family", api)
+				}
+			}
+			continue
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+			if err != nil {
+				t.Fatal(target.triple, api, err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "ternary-results.ll", "ternary-results.o", ir)
+		}
+	}
+}
diff --git a/amd64_ternary_logic_runtime_test.go b/amd64_ternary_logic_runtime_test.go
new file mode 100644
index 000000000..4dedd5943
--- /dev/null
+++ b/amd64_ternary_logic_runtime_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86TernaryAllTruthTablesAndForms(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, cases strings.Builder
+	sigs := map[string]FuncSig{}
+	count := 0
+	add := func(op, bank string, width, bits, immediate, maskMode, memory int, aliases [3]int) {
+		name := fmt.Sprint("ternaryRuntime", count)
+		count++
+		suffix, mask := "", ""
+		if memory == 2 {
+			suffix = ".BCST"
+		}
+		if maskMode > 0 {
+			mask = ",K3"
+		}
+		if maskMode == 2 {
+			suffix += ".Z"
+		}
+		first := fmt.Sprintf("%s%d", bank, aliases[2])
+		if memory > 0 {
+			first = "(SI)"
+		}
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-48
+MOVQ out+0(FP),AX
+MOVQ a+8(FP),BX
+MOVQ b+16(FP),CX
+MOVQ c+24(FP),SI
+MOVQ k+32(FP),DX
+VMOVDQU64 (SI),Z0
+VMOVDQU64 (CX),Z1
+VMOVDQU64 (BX),Z2
+KMOVQ DX,K3
+STC
+%s%s $%d,%s,%s%d%s,%s%d
+VMOVDQU64 Z2,(AX)
+SETCS 64(AX)
+RET
+`, name, op, suffix, immediate, first, bank, aliases[1], mask, bank, aliases[0])
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+		fmt.Fprintf(&cases, "{%s,%d,%d,%d,%d,%d,{%d,%d,%d}},\n", name, width, bits/8, immediate, maskMode, memory, aliases[0], aliases[1], aliases[2])
+	}
+	for _, spec := range []struct {
+		op   string
+		bits int
+	}{{"VPTERNLOGD", 32}, {"VPTERNLOGQ", 64}} {
+		for width, bank := range map[int]string{16: "X", 32: "Y", 64: "Z"} {
+			for immediate := 0; immediate < 256; immediate++ {
+				add(spec.op, bank, width, spec.bits, immediate, 0, 0, [3]int{2, 1, 0})
+			}
+			for _, aliases := range [][3]int{{2, 1, 0}, {2, 2, 0}, {2, 1, 2}, {2, 1, 1}, {2, 2, 2}} {
+				for mask := 0; mask <= 2; mask++ {
+					for memory := 0; memory <= 2; memory++ {
+						for _, immediate := range []int{0, 255, 150, 202} {
+							add(spec.op, bank, width, spec.bits, immediate, mask, memory, aliases)
+						}
+					}
+				}
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const helper = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+struct test {
+    void (*run)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+    unsigned width,lane,immediate,mask,memory,aliases[3];
+};
+`
+	driver := helper + declarations.String() + "static const struct test cases[]={\n" + cases.String() + `};
+int main(void) {
+    const uint64_t masks[]={0,UINT64_MAX,1,0xaaaa,0x5555,UINT64_C(1)<<63};
+    uint32_t saved=_mm_getcsr();
+    for(unsigned test=0;test<sizeof(cases)/sizeof(cases[0]);test++)
+    for(unsigned sample=0;sample<12;sample++) {
+        const struct test *c=cases+test;
+        uint8_t inputs[3][66],before[3][66],output[67];
+        for(unsigned r=0;r<3;r++) for(unsigned i=0;i<66;i++)
+            inputs[r][i]=(uint8_t)(i*(r*23+13)+sample*(r*19+51));
+        memcpy(before,inputs,sizeof(inputs));
+        memset(output,0xa7,sizeof(output));
+        uint64_t mask=masks[sample%6];
+        uint32_t csr=0x1f80|(sample&3)<<13|(sample&63);
+        _mm_setcsr(csr);
+        c->run(output+1,inputs[2]+1,inputs[1]+1,inputs[0]+1,mask);
+        uint32_t after=_mm_getcsr();
+        _mm_setcsr(saved);
+        if(after!=csr || output[0]!=0xa7 || output[66]!=0xa7 || output[65]!=1 ||
+           memcmp(inputs,before,sizeof(inputs))) return 1;
+        for(unsigned i=0;i<64;i++) {
+            unsigned want=0;
+            if(i<c->width) {
+                if(c->mask && !(mask>>(i/c->lane)&1)) {
+                    want=c->mask==2?0:inputs[c->aliases[0]][i+1];
+                } else {
+                    unsigned a=inputs[c->aliases[0]][i+1];
+                    unsigned b=inputs[c->aliases[1]][i+1];
+                    unsigned third=c->memory?inputs[0][1+(c->memory==2?i%c->lane:i)]:inputs[c->aliases[2]][i+1];
+                    for(unsigned bit=0;bit<8;bit++) {
+                        unsigned index=((a>>bit&1)<<2)|((b>>bit&1)<<1)|(third>>bit&1);
+                        want|=(c->immediate>>index&1)<<bit;
+                    }
+                }
+            }
+            if(output[i+1]!=want) {
+                fprintf(stderr,"case=%u sample=%u byte=%u got=%x want=%x\n",test,sample,i,output[i+1],want);
+                return 2;
+            }
+        }
+    }
+    return 0;
+}
+`
+	for _, optimize := range []bool{false, true} {
+		text := ir
+		if optimize {
+			text = x86MulDivRoundOptimize(t, text)
+		}
+		t.Run(fmt.Sprint("IR_O2=", optimize), func(t *testing.T) {
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "ternary-complete", triple, text, driver, prefix)
+		})
+	}
+	t.Logf("%d kernels x12 values/masks, all64 alias bytes, carry/MXCSR/input canaries, all256 truth tables; portable LLVM, not original native AVX512 execution", count)
+}
diff --git a/amd64_timestamp_family_test.go b/amd64_timestamp_family_test.go
new file mode 100644
index 000000000..75da63ff5
--- /dev/null
+++ b/amd64_timestamp_family_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TimestampInstructionsMustNotUseConstantOutputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"RDTSC", "RDTSCP"} {
+			t.Run(arch+"/"+string(op), func(t *testing.T) {
+				source := "TEXT clock(SB),4,$0-0\n" + string(op) + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before := output.Len()
+				handled, terminated, err := ctx.lowerArith(op, file.Funcs[0].Instrs[1])
+				if !handled || terminated || err != nil {
+					t.Fatalf("whole timestamp instruction: %t/%t/%v", handled, terminated, err)
+				}
+				ir := output.String()[before:]
+				if !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(string(op))+"\"") {
+					t.Fatalf("actual timestamp instruction replaced by constants:\n%s", ir)
+				}
+				outputCount := 2
+				if op == "RDTSCP" {
+					outputCount = 3
+				}
+				if strings.Count(ir, "extractvalue") != outputCount ||
+					strings.Count(ir, "zext i32") != outputCount {
+					t.Fatalf("complete zero-extended architectural outputs absent:\n%s", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86TimestampMalformedOperandsFailBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"RDTSC", "RDTSCP"} {
+			for _, operand := range []string{"AX", "(AX)", "$1", "AX,DX"} {
+				t.Run(arch+"/"+string(op)+"/"+operand, func(t *testing.T) {
+					source := "TEXT clock(SB),4,$0-0\n" + string(op) + " " + operand + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := output.String()
+					handled, terminated, err := ctx.lowerArith(op, file.Funcs[0].Instrs[1])
+					if !handled || terminated || err == nil || before != output.String() {
+						t.Fatalf("malformed timestamp produced IR: %t/%t/%v", handled, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86TimestampOriginalFixture(op Op) (declaration, assembly string) {
+	name := strings.ToLower(string(op))
+	return x86TimestampOriginalFixtureWithFlags(op, name, 0x8c7)
+}
+
+func x86TimestampOriginalFixtureWithFlags(op Op, name string, flags uint64) (declaration, assembly string) {
+	declaration = fmt.Sprintf("func %s(out *[8]uint64)\n", name)
+	assembly = fmt.Sprintf(`TEXT ·%s(SB),4,$0-8
+    MOVQ out+0(FP),DI
+    MOVQ $-1,AX
+    MOVQ $-1,DX
+    MOVQ $0xa1b2c3d4e5f60718,CX
+    MOVQ $0x7e6d5c4b3a291807,BX
+    PUSHQ $%#x
+    POPFQ
+    %s
+    MOVQ AX,0(DI)
+    MOVQ DX,8(DI)
+    MOVQ CX,16(DI)
+    MOVQ BX,24(DI)
+    PUSHFQ
+    POPQ R8
+    MOVQ R8,32(DI)
+    STMXCSR 40(DI)
+    RET
+`, name, flags, op)
+	return
+}
+
+func x86Timestamp386OriginalFixture(op Op) (declaration, assembly string) {
+	name := strings.ToLower(string(op))
+	return x86Timestamp386OriginalFixtureWithFlags(op, name, 0x8c7)
+}
+
+func x86Timestamp386OriginalFixtureWithFlags(op Op, name string, flags uint64) (declaration, assembly string) {
+	declaration = fmt.Sprintf("func %s(out *[8]uint32)\n", name)
+	assembly = fmt.Sprintf(`TEXT ·%s(SB),4,$0-4
+    MOVL out+0(FP),DI
+    MOVL $-1,AX
+    MOVL $-1,DX
+    MOVL $0x5f60718,CX
+    MOVL $0x3a291807,BX
+    PUSHL $%#x
+    POPFL
+    %s
+    MOVL AX,0(DI)
+    MOVL DX,4(DI)
+    MOVL CX,8(DI)
+    MOVL BX,12(DI)
+    PUSHFL
+    POPL SI
+    MOVL SI,16(DI)
+    STMXCSR 20(DI)
+    RET
+`, name, flags, op)
+	return
+}
+
+// Complementary inputs cover both values of all six architectural status
+// bits. In particular, AF must be observed, not dropped from the oracle mask.
+func x86TimestampRuntimeFixtures(goarch string) (declarations, assembly string) {
+	var decl, source strings.Builder
+	for _, op := range []Op{"RDTSC", "RDTSCP"} {
+		for index, seed := range []uint64{0x8c7, 0x12} {
+			name := strings.ToLower(string(op))
+			if index != 0 {
+				name += "_af"
+			}
+			var declaration, body string
+			switch goarch {
+			case "amd64":
+				declaration, body = x86TimestampOriginalFixtureWithFlags(op, name, seed)
+			case "386":
+				declaration, body = x86Timestamp386OriginalFixtureWithFlags(op, name, seed)
+			default:
+				panic("timestamp fixture requires an x86 architecture")
+			}
+			decl.WriteString(declaration)
+			source.WriteString(body)
+		}
+	}
+	return decl.String(), source.String()
+}
+
+func TestX86TimestampStatusOracleRejectsEverySingleBitMutation(t *testing.T) {
+	const mask uint64 = 0x8d5 // CF, PF, AF, ZF, SF, OF.
+	for _, expected := range []uint64{0x8c5, 0x10} {
+		if expected&mask != expected {
+			t.Fatal("invalid independent status seed")
+		}
+		for _, bit := range []uint{0, 2, 4, 6, 7, 11} {
+			mutated := expected ^ (uint64(1) << bit)
+			if mutated&mask == expected {
+				t.Fatalf("status bit %d mutation was invisible to the oracle", bit)
+			}
+		}
+	}
+	// Retain the precise former blind spot as an independent control.
+	if uint64(0x8d5)&0x8c5 != 0x8c5 {
+		t.Fatal("former AF-blind predicate no longer reproduces")
+	}
+}
diff --git a/amd64_timestamp_forms.go b/amd64_timestamp_forms.go
new file mode 100644
index 000000000..a40688933
--- /dev/null
+++ b/amd64_timestamp_forms.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86TimestampSpec struct {
+	outputs amd64ImplicitRegisterSet
+	opBytes []byte // Complete Go ynone/Pm row, including its literal terminator.
+}
+
+// Zero-operand syntax and implicit data flow are separate from native ISA
+// availability. Executing the whole instruction retains TSC/AUX and faults;
+// no software zero or host-clock substitute is an architectural timestamp.
+var x86TimestampSpecs = map[Op]x86TimestampSpec{
+	"RDTSC":  {amd64ImplicitAX | amd64ImplicitDX, []byte{0x31}},
+	"RDTSCP": {amd64ImplicitAX | amd64ImplicitDX | amd64ImplicitCX, []byte{0x01, 0xf9, 0}},
+}
+
+func x86TimestampProperties(op Op, ins Instr, arch string) (x86TimestampSpec, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := x86TimestampSpecs[Op(name)]
+	if !known {
+		return x86TimestampSpec{}, false, nil
+	}
+	if len(ins.Args) != 0 {
+		return spec, true, fmt.Errorf("%s takes no operands: %q", name, ins.Raw)
+	}
+	if dotted || arch != "amd64" && arch != "386" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s requires the exact zero-operand Go timestamp form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func x86TimestampRegisters(spec x86TimestampSpec) []Reg {
+	registers := []Reg{AX, DX}
+	if spec.outputs&amd64ImplicitCX != 0 {
+		registers = append(registers, CX)
+	}
+	return registers
+}
+
+// These implicit dword writes share the original zero-operand grammar and
+// output directory with the native emitter. They read no numerical input and
+// preserve integer FLAGS/DF. Initialization alone grants no entry, memory or
+// caller authority, nor a claim that the hardware instruction cannot fault.
+func x86TypedTimestampByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	spec, known, err := x86TimestampProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	if !x86TimestampPreservesSourceState(ins) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: timestamp original/normalized source identity differs", ErrProbeNeedsContext)
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true}
+	for _, register := range x86TimestampRegisters(spec) {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: 4, write: true,
+		})
+	}
+	return effect, true, nil
+}
+
+// Both x86 modes have the same exact zero-operand state footprint. This
+// instruction-local observation authorizes neither a function's raw entry nor
+// storage. Raw handoffs must retain the decoder's original opcode and operands.
+func x86TimestampPreservesSourceState(ins Instr) bool {
+	_, known := x86TimestampSpecs[Op(strings.ToUpper(string(ins.Op)))]
+	return known && x86RegisterQueryPreservesSourceState(ins)
+}
+
+func (c *amd64Ctx) lowerX86Timestamp(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86TimestampProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	registers := x86TimestampRegisters(spec)
+	resultType := "{ i32, i32 }"
+	constraints := "={ax},={dx}"
+	if spec.outputs&amd64ImplicitCX != 0 {
+		resultType = "{ i32, i32, i32 }"
+		constraints += ",={cx}"
+	}
+	// Compiler clobbers are conservative scheduling constraints, not a claim
+	// that RDTSC serializes the CPU or changes the source's arithmetic flags.
+	constraints += ",~{dirflag},~{fpsr},~{flags},~{memory}"
+	call := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q()\n",
+		call, resultType, strings.ToLower(string(op)), constraints)
+	for index, register := range registers {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, resultType, call, index)
+		if err := c.storeRegSized(register, I32, "%"+value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
diff --git a/amd64_timestamp_ia32_fixtures_test.go b/amd64_timestamp_ia32_fixtures_test.go
new file mode 100644
index 000000000..52913c721
--- /dev/null
+++ b/amd64_timestamp_ia32_fixtures_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+const x86Timestamp386OriginalDriver = `package main
+
+import (
+    "fmt"
+    "runtime"
+)
+
+func main() {
+    runtime.LockOSThread()
+    observations := 0
+    expectedFlags := []uint32{0x8c5, 0x10, 0x8c5, 0x10}
+    for index, sample := range []func(*[8]uint32){rdtsc, rdtsc_af, rdtscp, rdtscp_af} {
+        for iteration := 0; iteration < 64; iteration++ {
+            out := [8]uint32{0, 0, 0, 0, 0, 0, 0x23456789, 0x2468ace0}
+            sample(&out)
+            if uint64(out[0]) | uint64(out[1]) << 32 == 0 ||
+                    out[3] != 0x3a291807 || out[4] & 0x8d5 != expectedFlags[index] ||
+                    out[6] != 0x23456789 || out[7] != 0x2468ace0 ||
+                    index < 2 && out[2] != 0x5f60718 {
+                panic(fmt.Sprintf("original IA32 timestamp %d: %x", index, out))
+            }
+            observations++
+        }
+    }
+    fmt.Printf("original IA32 timestamp observations %d\n", observations)
+}
+`
+
+const x86Timestamp386IndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+
+extern void rdtsc(uint32_t *);
+extern void rdtsc_af(uint32_t *);
+extern void rdtscp(uint32_t *);
+extern void rdtscp_af(uint32_t *);
+
+static uint64_t read_counter(unsigned *aux) {
+    unsigned low, high, native_aux;
+    __asm__ volatile("lfence; rdtscp; lfence" : "=a"(low), "=d"(high), "=c"(native_aux) :: "memory");
+    *aux = native_aux;
+    return (uint64_t)low | (uint64_t)high << 32;
+}
+
+int main(void) {
+    void (*samples[])(uint32_t *) = { rdtsc, rdtsc_af, rdtscp, rdtscp_af };
+    const uint32_t expected_flags[] = { 0x8c5, 0x10, 0x8c5, 0x10 };
+    unsigned observations = 0, stable_aux_observations = 0;
+    for (unsigned index = 0; index < 4; index++) {
+        for (unsigned iteration = 0; iteration < 64; iteration++) {
+            unsigned before_csr, after_csr, before_aux, after_aux;
+            uint32_t out[8] = {0, 0, 0, 0, 0, 0, 0x23456789, 0x2468ace0};
+            __asm__ volatile("stmxcsr %0" : "=m"(before_csr));
+            uint64_t before = read_counter(&before_aux);
+            samples[index](out);
+            uint64_t after = read_counter(&after_aux);
+            __asm__ volatile("stmxcsr %0" : "=m"(after_csr));
+            uint64_t got = (uint64_t)out[0] | (uint64_t)out[1] << 32;
+            if (!got || got < before || got > after ||
+                    out[3] != 0x3a291807 || (out[4] & 0x8d5) != expected_flags[index] ||
+                    out[5] != before_csr || after_csr != before_csr ||
+                    out[6] != 0x23456789 || out[7] != 0x2468ace0 ||
+                    (index < 2 && out[2] != 0x5f60718)) {
+                fprintf(stderr, "IA32 timestamp %u counter=%llx window=%llx..%llx flags=%x\n",
+                    index, (unsigned long long)got, (unsigned long long)before,
+                    (unsigned long long)after, out[4]);
+                return 1;
+            }
+            if (index >= 2 && before_aux == after_aux) {
+                if (out[2] != before_aux) {
+                    fprintf(stderr, "IA32 timestamp AUX=%x reference=%x\n", out[2], before_aux);
+                    return 2;
+                }
+                stable_aux_observations++;
+            }
+            observations++;
+        }
+    }
+    if (!stable_aux_observations) {
+        fprintf(stderr, "no stable independent IA32 AUX window observed\n");
+        return 3;
+    }
+    printf("IA32 timestamp observations %u\n", observations);
+    return 0;
+}
+`
diff --git a/amd64_timestamp_linux_amd64_test.go b/amd64_timestamp_linux_amd64_test.go
new file mode 100644
index 000000000..2ebc339d1
--- /dev/null
+++ b/amd64_timestamp_linux_amd64_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This required CI counterpart executes on the actual Linux/amd64 kernel.
+// The static ELF32 transport rejects emulators and changed executables.
+func TestCrossLinuxRuntimeMatrixX86TimestampNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required native IA32 C compiler:", err)
+	}
+	declarations, assembly := x86TimestampRuntimeFixtures("386")
+	declarations = "package main\n" + declarations
+	goAssemblerOracleOutput(t, "386", assembly, "", true)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":  "module timestamp386\n\ngo 1.20\n",
+		"decl.go": declarations, "timestamp_386.s": assembly,
+		"main.go": x86Timestamp386OriginalDriver,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original-go")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=2", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=386", "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	sealed, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "original IA32 timestamp observations 256\n" {
+		t.Fatalf("unchanged original Go IA32 timestamp execution: %q", output)
+	}
+
+	pkg := mustGoPackage(t, "timestamp386", declarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+		GOARCH: "386", TargetTriple: "i386-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if err != nil {
+		if translated != nil && !translated.Module.IsNil() {
+			translated.Module.Dispose()
+		}
+		t.Fatal(err)
+	}
+	if translated == nil || translated.Module.IsNil() {
+		t.Fatal("successful IA32 translation did not produce a module")
+	}
+	ir := translated.Module.String()
+	verifyError := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction)
+	// Do not let native executable compilation keep a live module unnecessarily.
+	translated.Module.Dispose()
+	if verifyError != nil {
+		t.Fatal(verifyError)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			input, object := filepath.Join(dir, "timestamp"+level+".ll"), filepath.Join(dir, "timestamp"+level+".o")
+			main, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "timestamp"+level)
+			for name, contents := range map[string]string{input: ir, main: x86Timestamp386IndependentC} {
+				if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(llc, level,
+				"-mtriple=i386-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+			x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie",
+				object, main, "-O2", "-o", executable))
+			sealed, err := x87IA32StaticExecutable(executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "IA32 timestamp observations 256\n" {
+				t.Fatalf("LLVM IA32 TSC/AUX/flags/MXCSR/canaries: %q", output)
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_timestamp_result_effect_test.go b/amd64_timestamp_result_effect_test.go
new file mode 100644
index 000000000..e34042aa0
--- /dev/null
+++ b/amd64_timestamp_result_effect_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86TimestampVoidCannotBorrowUnwrittenImplicitRegisters(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVL", 4, "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			move, word, triple = "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		}
+		for _, row := range []struct {
+			op, source string
+			valid      bool
+		}{
+			{"RDTSC", "AX", true}, {"RDTSC", "DX", true}, {"RDTSC", "CX", false},
+			{"RDTSCP", "AX", true}, {"RDTSCP", "DX", true}, {"RDTSCP", "CX", true},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.op+"/"+row.source+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Clock(SB),4,$0-%d\n%s p+0(FP),DI\n%s\nMOVL %s,(DI)\nRET\n",
+						word, move, row.op, row.source)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Clock(p *uint32)", arch, triple, api)
+					if row.valid {
+						if err != nil || ir == "" {
+							t.Fatal("actual timestamp output lost its native store continuation", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("RDTSC invented RDTSCP's CX output in a Void function", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86TimestampNumericalEffectsUseCompleteImplicitOutputSpec(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"RDTSC", "RDTSCP"} {
+			t.Run(arch+"/"+string(op), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, string(op))
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				for index := range state.pointerGP {
+					state.pointerGP[index], state.callerAddressGP[index] = true, true
+				}
+				before := state.clone()
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("whole native timestamp outputs have no numerical effect")
+				}
+				want := before.clone()
+				outputs := []int{0, 2} // AX, DX; RDTSCP additionally defines CX.
+				if op == "RDTSCP" {
+					outputs = append(outputs, 1)
+				}
+				addresses := before.callerAddressGP
+				for _, index := range outputs {
+					want.gp[index], want.pointerGP[index], addresses[index] = 0xff, false, false
+				}
+				if !reflect.DeepEqual(state, want) {
+					t.Fatal("timestamp invented or killed unrelated numerical/status/domain facts")
+				}
+				if after := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch); after != addresses {
+					t.Fatal("timestamp GP write footprint lost an unrelated pointer or retained an overwritten one")
+				}
+			})
+		}
+	}
+}
+
+func TestX86TimestampInitializedScalarResultsThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"RDTSC", "RDTSCP"} {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				declaration, result, tail := "uint64", 8, ""
+				if op == "RDTSCP" {
+					declaration, result, tail = "(uint64,uint32)", 12, "MOVL CX,aux+8(FP)\n"
+				}
+				source := fmt.Sprintf("TEXT ·Clock(SB),4,$0-%d\n%s\nMOVL AX,stamp+0(FP)\nMOVL DX,stamp+4(FP)\n%sRET\n", result, op, tail)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Clock() "+declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("actual native implicit dword results lost their typed output bytes", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86TimestampRawCompositionRetainsExactOriginalRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []Op{"RDTSC", "RDTSCP"} {
+			code := []byte{0x0f, 0x31}
+			if opcode == "RDTSCP" {
+				code = []byte{0x0f, 0x01, 0xf9}
+			}
+			x86RegisterQueryRawCompositionRoles(t, arch, opcode, code, "")
+		}
+	}
+}
+
+// The same original/normalized identity boundary protects timestamps and CPU
+// queries; each caller supplies independent bytes and required input setup.
+func x86RegisterQueryRawCompositionRoles(t *testing.T, arch string, opcode Op, code []byte, initialization string) {
+	t.Helper()
+	move, word := "MOVL", 4
+	if arch == "amd64" {
+		move, word = "MOVQ", 8
+	}
+	body := fmt.Sprintf("%s p+0(FP),DI\n%sMOVL AX,ret+%d(FP)\nSTMXCSR (DI)\nRET",
+		move, initialization+x86RawDisplacementDirectives(code), word)
+	_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *uint32) uint32", body)
+	normalized, err := decodeX86RawDirectives(file.Funcs[0], arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	position := -1
+	for index, ins := range normalized.Instrs {
+		if ins.x86SourceRaw != nil {
+			if ins.Op != opcode || position != -1 {
+				t.Fatal("original timestamp did not decode to exactly one instruction")
+			}
+			position = index
+		}
+	}
+	if position < 0 {
+		t.Fatal("missing exact raw timestamp handoff")
+	}
+	for _, mutation := range []string{"unchanged", "original-opcode", "original-operands", "normalized-opcode",
+		"normalized-operands", "encoded", "address-size", "unbound-address", "segment-prefix",
+		"raw-return", "raw-TEXT", "source-stack", "fixed-local"} {
+		t.Run(arch+"/"+string(opcode)+"/"+mutation, func(t *testing.T) {
+			fn := normalized
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			ins := &fn.Instrs[position]
+			origin := *ins.x86SourceRaw
+			ins.x86SourceRaw = &origin
+			switch mutation {
+			case "original-opcode":
+				origin.op = "NOP"
+			case "original-operands":
+				origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "normalized-opcode":
+				ins.Op = "NOP"
+			case "normalized-operands":
+				ins.Args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "encoded":
+				ins.x86Encoded = true
+			case "address-size":
+				ins.x86AddressBits = 32
+			case "unbound-address":
+				ins.x86UnboundAddressOverride = true
+			case "segment-prefix":
+				ins.x86SegmentPrefix = 0x64
+			case "raw-return":
+				ins.x86RawNearReturn = new(x86RawNearReturnForm)
+			case "raw-TEXT":
+				fn.X86RawText = code
+			case "source-stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed-local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			}
+			consumer := &amd64Ctx{fpScalarSource: fn, sig: sig, fpSourceSig: sig, goarch: arch}
+			err := consumer.checkLoweredScalarFPResultInitialization()
+			if mutation == "unchanged" {
+				if err != nil {
+					t.Fatal("complete matching register query lost its paired native continuation", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("raw register query granted a mismatched source/entry/storage role", err)
+			}
+		})
+	}
+}
diff --git a/amd64_timestamp_rule_consumers_test.go b/amd64_timestamp_rule_consumers_test.go
new file mode 100644
index 000000000..9dfe29799
--- /dev/null
+++ b/amd64_timestamp_rule_consumers_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// Portable compile control for the unchanged native CI reference, not an
+// execution result. It prevents a platform-only driver from going unchecked
+// on development hosts that cannot directly run IA32 executables.
+func TestX86Timestamp386OriginalNativeReferenceCompiles(t *testing.T) {
+	declarations, source := x86TimestampRuntimeFixtures("386")
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module timestamp386\n\ngo 1.20\n", "decl.go": "package main\n" + declarations,
+		"main.go": x86Timestamp386OriginalDriver, "timestamp_386.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("original-go"))
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=386", "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	sealed, err := x87IA32StaticExecutable(executable)
+	if err != nil || sealed.verify() != nil {
+		t.Fatalf("actual original native IA32 reference did not compile as stable ELF32: %v", err)
+	}
+	t.Log("actual original Go static IA32 executable compiled; not executed on this portable axis")
+}
+
+func TestX86TimestampCompleteOfficialRulesAndActualEncodedIdentity(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("Go timestamp zero-operand ordered row changed")
+	}
+	if len(x86TimestampSpecs) != 2 {
+		t.Fatal("timestamp family must have exactly two canonical opcodes")
+	}
+	for _, row := range []struct {
+		op               Op
+		registration     string
+		literal, machine []byte
+		outputs          amd64ImplicitRegisterSet
+	}{
+		{"RDTSC", "{ARDTSC, ynone, Pm, opBytes{0x31}}",
+			[]byte{0x31}, []byte{0x0f, 0x31}, amd64ImplicitAX | amd64ImplicitDX},
+		{"RDTSCP", "{ARDTSCP, ynone, Pm, opBytes{0x01, 0xf9, 0}}",
+			[]byte{0x01, 0xf9, 0}, []byte{0x0f, 0x01, 0xf9},
+			amd64ImplicitAX | amd64ImplicitDX | amd64ImplicitCX},
+	} {
+		if !strings.Contains(string(table), row.registration) {
+			t.Fatal("complete actual Go prefix/literal row changed", row.registration)
+		}
+		spec := x86TimestampSpecs[row.op]
+		if !bytes.Equal(spec.opBytes, row.literal) || spec.outputs != row.outputs {
+			t.Fatal("typed timestamp metadata differs from independent complete row", row.op, spec)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+string(row.op), func(t *testing.T) {
+				source := "TEXT clock(SB),4,$0-0\n" + string(row.op) + "\nRET\n"
+				actual := assembleX87ControlBytes(t, arch, source)
+				expected := append(append([]byte(nil), row.machine...), 0xc3)
+				if !bytes.Equal(actual, expected) {
+					t.Fatalf("actual Go canonical machine code: %x want %x", actual, expected)
+				}
+				mode := 64
+				if arch == "386" {
+					mode = 32
+				}
+				decoded, err := decodeX86RawDirectiveGroup(actual[:len(actual)-1], mode, 0, source, map[string]bool{})
+				if err != nil || len(decoded) != 1 {
+					t.Fatalf("actual Go timestamp raw consumer: %#v/%v", decoded, err)
+				}
+				before := fmt.Sprintf("%#v", decoded[0])
+				got, known, err := x86TimestampProperties(row.op, decoded[0], arch)
+				if !known || err != nil || !reflect.DeepEqual(got, spec) || before != fmt.Sprintf("%#v", decoded[0]) {
+					t.Fatal("raw timestamp identity changed effects/input", decoded, got, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86TimestampDispatchIdentityAndImplicitOutputLiveness(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"RDTSC", "RDTSCP"} {
+			file, err := Parse(ArchAMD64, "TEXT clock(SB),4,$0-0\n"+string(op)+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, identity := range []Op{"", op, Op(strings.ToLower(string(op))), "MOVQ", Op(string(op) + ".BAD")} {
+				t.Run(arch+"/"+string(op)+"/identity="+string(identity), func(t *testing.T) {
+					instruction := file.Funcs[0].Instrs[1]
+					instruction.Op = identity
+					input := fmt.Sprintf("%#v", instruction)
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					ir, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerX86Timestamp(op, instruction)
+					invalid := identity != "" && !strings.EqualFold(string(identity), string(op))
+					if !known || terminated || (err != nil) != invalid ||
+						invalid && (ir != output.String() || temporary != ctx.tmp) ||
+						input != fmt.Sprintf("%#v", instruction) {
+						t.Fatal("timestamp identity emitted before rejection or mutated its input", identity, err)
+					}
+				})
+			}
+			for _, invalidArch := range []string{"", "arm", "arm64", "wasm"} {
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = invalidArch
+				before, temporary := output.String(), ctx.tmp
+				if known, terminated, err := ctx.lowerX86Timestamp(op, file.Funcs[0].Instrs[1]); !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+					t.Fatal("unrelated target admitted timestamp grammar", invalidArch, err)
+				}
+			}
+			for _, suffix := range []string{".Z", ".SAE", ".BCST"} {
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before, temporary := output.String(), ctx.tmp
+				if known, terminated, err := ctx.lowerX86Timestamp(Op(string(op)+suffix), file.Funcs[0].Instrs[1]); !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+					t.Fatal("timestamp suffix emitted before grammar rejection", suffix, err)
+				}
+			}
+			ctx, _ := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			for _, reg := range []Reg{AX, DX, CX} {
+				required := reg != CX || op == "RDTSCP"
+				if ctx.usedRegs[reg] != required || (ctx.regSlot[reg] != "") != required {
+					t.Fatal("implicit architectural result omitted without explicit operand", op, reg)
+				}
+			}
+		}
+	}
+}
+
+func TestX86TimestampNamedAndRawThreeAPIsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, raw := range []bool{false, true} {
+			var source strings.Builder
+			declarations := "package timestamp\n"
+			if !raw {
+				decl, body := x86TimestampRuntimeFixtures(target.arch)
+				declarations += decl
+				source.WriteString(body)
+			} else {
+				for _, op := range []Op{"RDTSC", "RDTSCP"} {
+					declaration, original := x86TimestampOriginalFixture(op)
+					if target.arch == "386" {
+						declaration, original = x86Timestamp386OriginalFixture(op)
+					}
+					declarations += declaration
+					actual := assembleX87ControlBytes(t, target.arch,
+						"TEXT clock(SB),4,$0-0\n"+string(op)+"\nRET\n")
+					var literal strings.Builder
+					for _, value := range actual[:len(actual)-1] {
+						fmt.Fprintf(&literal, "BYTE $%d\n", value)
+					}
+					original = strings.Replace(original, "    "+string(op)+"\n", literal.String(), 1)
+					source.WriteString(original)
+				}
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			pkg := mustGoPackage(t, "timestamp", declarations)
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", target.triple, raw, api), func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					if api == "Go" {
+						translated, err := translateGoModuleInContext(ctx, pkg, []byte(source.String()), GoModuleOptions{
+							GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+						})
+						if translated != nil && !translated.Module.IsNil() {
+							defer translated.Module.Dispose()
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir = translated.Module.String()
+					} else {
+						file, err := Parse(ArchAMD64, source.String())
+						if err != nil {
+							t.Fatal(err)
+						}
+						sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+						if err != nil {
+							t.Fatal(err)
+						}
+						options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+						if api == "text" {
+							ir, err = Translate(file, options)
+						} else {
+							module, failure := TranslateModuleInContext(ctx, file, options)
+							if !module.IsNil() {
+								defer module.Dispose()
+								ir = module.String()
+							}
+							err = failure
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+					expectedPerOpcode := 2
+					if raw {
+						expectedPerOpcode = 1
+					}
+					for _, opcode := range []string{"rdtsc", "rdtscp"} {
+						if strings.Count(ir, "asm sideeffect \""+opcode+"\"") != expectedPerOpcode {
+							t.Fatal("object consumer lost the actual architectural timestamp", opcode)
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "timestamp.ll", "timestamp.o", ir)
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_timestamp_runtime_test.go b/amd64_timestamp_runtime_test.go
new file mode 100644
index 000000000..623c18c61
--- /dev/null
+++ b/amd64_timestamp_runtime_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func TestCrossLinuxRuntimeMatrixX86TimestampOriginalAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	// First execute the unchanged Go objects. A missing/unsupported native ISA
+	// fails this axis; it is not permission to accept a constant LLVM result.
+	x86TimestampRunOriginalGo(t, execution)
+	declarations, assembly := x86TimestampRuntimeFixtures("amd64")
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	ir := x86NarrowOracleIR(t, assembly, "package timestamp\n"+declarations, execution.triple)
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "timestamp", ir, x86TimestampIndependentC, level)
+			if string(output) != "timestamp observations 256\n" {
+				t.Fatalf("independent timestamp/register/flags/canary oracle: %q", output)
+			}
+		})
+	}
+}
+
+func x86TimestampRunOriginalGo(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	declarations, assembly := x86TimestampRuntimeFixtures("amd64")
+	const driver = `package main
+
+import (
+    "fmt"
+    "runtime"
+)
+
+func main() {
+    runtime.LockOSThread()
+    observations := 0
+    expectedFlags := []uint64{0x8c5, 0x10, 0x8c5, 0x10}
+    for index, sample := range []func(*[8]uint64){rdtsc, rdtsc_af, rdtscp, rdtscp_af} {
+        for iteration := 0; iteration < 64; iteration++ {
+            out := [8]uint64{0, 0, 0, 0, 0, 0, 0xabcdef0123456789, 0x13579bdf2468ace0}
+            sample(&out)
+            stamp := out[0] | out[1] << 32
+            if stamp == 0 || out[0] >> 32 != 0 || out[1] >> 32 != 0 ||
+                    out[3] != 0x7e6d5c4b3a291807 || out[4] & 0x8d5 != expectedFlags[index] ||
+                    out[6] != 0xabcdef0123456789 || out[7] != 0x13579bdf2468ace0 {
+                panic(fmt.Sprintf("original timestamp %d: %x", index, out))
+            }
+            if index < 2 && out[2] != 0xa1b2c3d4e5f60718 || index >= 2 && out[2] >> 32 != 0 {
+                panic(fmt.Sprintf("original timestamp CX %d: %x", index, out))
+            }
+            observations++
+        }
+    }
+    fmt.Printf("original timestamp observations %d\n", observations)
+}
+`
+	dir := t.TempDir()
+	for name, text := range map[string]string{
+		"go.mod": "module timestamp\n\ngo 1.20\n", "main.go": driver,
+		"decl.go": "package main\n" + declarations, "timestamp_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, gotoolchain.HostExecutable("original-go"))
+	command := exec.Command("go", "build", "-p=1", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOARCH=amd64", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	if output := execution.run(t, executable); string(output) != "original timestamp observations 256\n" {
+		t.Fatalf("actual original Go objects did not establish timestamp semantics: %q", output)
+	}
+	t.Log("256 original Go timestamp/register/all-status-flags/canary observations")
+}
+
+const x86TimestampIndependentC = `
+#include <stdint.h>
+#include <stdio.h>
+
+extern void rdtsc(uint64_t *);
+extern void rdtsc_af(uint64_t *);
+extern void rdtscp(uint64_t *);
+extern void rdtscp_af(uint64_t *);
+
+static uint64_t read_counter(unsigned *aux) {
+    unsigned low, high, native_aux;
+    __asm__ volatile("lfence; rdtscp; lfence" : "=a"(low), "=d"(high), "=c"(native_aux) :: "memory");
+    *aux = native_aux;
+    return (uint64_t)low | (uint64_t)high << 32;
+}
+
+int main(void) {
+    void (*samples[])(uint64_t *) = { rdtsc, rdtsc_af, rdtscp, rdtscp_af };
+    const uint64_t expected_flags[] = { 0x8c5, 0x10, 0x8c5, 0x10 };
+    unsigned observations = 0, stable_aux_observations = 0;
+    for (unsigned index = 0; index < 4; index++) {
+        for (unsigned iteration = 0; iteration < 64; iteration++) {
+            unsigned before_csr, after_csr, before_aux, after_aux;
+            uint64_t out[8] = { 0, 0, 0, 0, 0, 0,
+                UINT64_C(0xabcdef0123456789), UINT64_C(0x13579bdf2468ace0) };
+            __asm__ volatile("stmxcsr %0" : "=m"(before_csr));
+            uint64_t before = read_counter(&before_aux);
+            samples[index](out);
+            uint64_t after = read_counter(&after_aux);
+            __asm__ volatile("stmxcsr %0" : "=m"(after_csr));
+            uint64_t got = out[0] | out[1] << 32;
+            if (!got || got < before || got > after || out[0] >> 32 || out[1] >> 32 ||
+                    out[3] != UINT64_C(0x7e6d5c4b3a291807) || (out[4] & 0x8d5) != expected_flags[index] ||
+                    out[5] != before_csr || after_csr != before_csr ||
+                    out[6] != UINT64_C(0xabcdef0123456789) ||
+                    out[7] != UINT64_C(0x13579bdf2468ace0)) {
+                fprintf(stderr, "timestamp %u got=%llx window=%llx..%llx flags=%llx csr=%llx/%x/%x\n",
+                    index, (unsigned long long)got, (unsigned long long)before, (unsigned long long)after,
+                    (unsigned long long)out[4], (unsigned long long)out[5], before_csr, after_csr);
+                return 1;
+            }
+            if ((index < 2 && out[2] != UINT64_C(0xa1b2c3d4e5f60718)) || (index >= 2 && out[2] >> 32)) {
+                fprintf(stderr, "timestamp CX %u=%llx\n", index, (unsigned long long)out[2]);
+                return 2;
+            }
+            // A migrated CPU may have a different AUX. A stable independently
+            // observed window must nevertheless retain the real third output.
+            if (index >= 2 && before_aux == after_aux) {
+                if (out[2] != before_aux) {
+                    fprintf(stderr, "timestamp AUX got=%llx reference=%x\n",
+                        (unsigned long long)out[2], before_aux);
+                    return 3;
+                }
+                stable_aux_observations++;
+            }
+            observations++;
+        }
+    }
+    if (!stable_aux_observations) {
+        fprintf(stderr, "no stable independent AUX window observed\n");
+        return 4;
+    }
+    printf("timestamp observations %u\n", observations);
+    return 0;
+}
+`
diff --git a/amd64_tls_move_alias_test.go b/amd64_tls_move_alias_test.go
new file mode 100644
index 000000000..e807901ff
--- /dev/null
+++ b/amd64_tls_move_alias_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TLSMoveSourceYrlRangePrecedesMode32Encoding(t *testing.T) {
+	var original strings.Builder
+	original.WriteString("TEXT f(SB),4,$0-0\n")
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD"} {
+		for index := 8; index <= 15; index++ {
+			row := fmt.Sprintf("%s TLS,R%d", op, index)
+			original.WriteString(row + "\n")
+			if err := x86SourceTLSMoveError(x86PureGPUnknownInstruction(t, row), "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Go's pre-encoding NOP row lost its complete source range: %s: %v", row, err)
+			}
+		}
+	}
+	original.WriteString("RET\n")
+	x86ScalarCompareTLSGoObject(t, original.String(), "386", "freebsd", false)
+	for _, row := range []string{"MOVL 0(R8)(TLS*1),AX", "MOVL AX,0(R15)(TLS*4)"} {
+		if err := x86SourceTLSMoveError(x86PureGPUnknownInstruction(t, row), "386"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("direct TLS removed source base became a physical bank rejection: %s: %v", row, err)
+		}
+		x86ScalarCompareTLSGoObject(t, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "386", "freebsd", false)
+	}
+}
+
+func TestX86TLSMoveMOVDAliasRetainsCompleteBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, operands := range []string{"8(TLS),X0", "X7,0(CX)(TLS*4)", "8(TLS),M0"} {
+			instruction := x86PureGPUnknownInstruction(t, "MOVD "+operands)
+			if err := x86SourceTLSMoveError(instruction, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s MOVD %s lost its source TLS contract: %v", arch, operands, err)
+			}
+		}
+		for _, operands := range []string{"TLS,X0", "AX,TLS", "8(TLS),Y0", "$1.5,8(TLS)", "8(TLS),X0,X1"} {
+			instruction := x86PureGPUnknownInstruction(t, "MOVD "+operands)
+			if err := x86SourceTLSMoveError(instruction, arch); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s invalid MOVD %s hidden by TLS: %v", arch, operands, err)
+			}
+		}
+		var source strings.Builder
+		for _, operands := range []string{"8(TLS),X0", "X7,0(CX)(TLS*4)", "8(TLS),M0"} {
+			source.WriteString("TEXT f(SB),4,$0-0\n")
+			source.WriteString("MOVD " + operands + "\nRET\n")
+			// Each independent fixture retains a single native source body.
+			x86ScalarCompareTLSGoObject(t, source.String(), arch, "freebsd", false)
+			source.Reset()
+		}
+	}
+}
diff --git a/amd64_tls_move_encoder_test.go b/amd64_tls_move_encoder_test.go
new file mode 100644
index 000000000..f4f321c41
--- /dev/null
+++ b/amd64_tls_move_encoder_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86TLSMoveCompleteIndependentGoMovtab(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := func(source string) string {
+		return strings.Join(strings.Fields(source), "")
+	}
+	var actual []string
+	for _, row := range regexp.MustCompile(`\{AMOV[LQ],\s*Ytls,[^\n]+`).FindAllString(string(source), -1) {
+		actual = append(actual, compact(row))
+	}
+	want := []string{
+		"{AMOVL,Ytls,Ynone,Yrl,movTLSReg,[4]uint8{0,0,0,0}},",
+		"{AMOVQ,Ytls,Ynone,Yrl,movTLSReg,[4]uint8{0,0,0,0}},",
+	}
+	if !reflect.DeepEqual(actual, want) {
+		t.Fatalf("complete Ytls encoder rows changed: %v", actual)
+	}
+	// Retain every segment-register MOVW memory row and opcode extension.
+	// Those shapes are part of TLS memory grammar, but grant no segment state.
+	var segments []string
+	for _, row := range regexp.MustCompile(`\{AMOVW,\s*(?:Y(?:es|cs|ss|ds|fs|gs),\s*Ynone,\s*Yml|Yml,\s*Ynone,\s*Y(?:es|cs|ss|ds|fs|gs)),[^\n]+`).FindAllString(string(source), -1) {
+		segments = append(segments, compact(row))
+	}
+	var expected []string
+	for _, classes := range []struct{ source, destination, zcase, opcode string }{
+		{"Yseg", "Yml", "movRegMem", "0x8c"}, {"Yml", "Yseg", "movMemReg", "0x8e"},
+	} {
+		for index, class := range []string{"Yes", "Ycs", "Yss", "Yds", "Yfs", "Ygs"} {
+			expected = append(expected, "{AMOVW,"+strings.ReplaceAll(classes.source, "Yseg", class)+",Ynone,"+
+				strings.ReplaceAll(classes.destination, "Yseg", class)+","+classes.zcase+",[4]uint8{"+classes.opcode+","+
+				string(rune('0'+index))+",0,0}},")
+		}
+	}
+	if !reflect.DeepEqual(segments, expected) {
+		t.Fatalf("complete TLS segment/memory encoder rows changed: %v", segments)
+	}
+}
diff --git a/amd64_tls_move_grammar.go b/amd64_tls_move_grammar.go
new file mode 100644
index 000000000..561bd0e53
--- /dev/null
+++ b/amd64_tls_move_grammar.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// This is source grammar, not a native-register, thread or storage permission.
+// Go's complete MOVQ source aliases include the mode32 MMX/XMM memory rows.
+// Width describes the physical memory transfer, never a virtual GP slot.
+type x86TLSMoveForm struct {
+	op      Op
+	bits    int
+	memory  int // -1 is the Ytls-to-Yrl pseudo-register row
+	write   bool
+	gp      bool
+	mmx     bool
+	xmm     bool
+	segment bool
+}
+
+func x86TLSMoveProperties(ins Instr, arch string) (x86TLSMoveForm, bool, error) {
+	form := x86TLSMoveForm{memory: -1}
+	op := strings.ToUpper(string(ins.Op))
+	base := strings.SplitN(op, ".", 2)[0]
+	_, alias := x86GoMOVQSourceAliases[Op(base)]
+	if base != "MOVB" && base != "MOVW" && base != "MOVL" && base != "MOVQ" && !alias {
+		return form, false, nil
+	}
+	present := false
+	for _, operand := range ins.Args {
+		present = present || operand.Kind == OpReg && operand.Reg == TLS ||
+			operand.Kind == OpMem && (operand.Mem.Base == TLS || operand.Mem.Index == TLS)
+	}
+	if !present {
+		return form, false, nil
+	}
+	bad := func(reason string) (x86TLSMoveForm, bool, error) {
+		return x86TLSMoveForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || op != base || len(ins.Args) != 2 {
+		return bad("has an invalid mode, suffix or operand count")
+	}
+	if alias {
+		base = string(x86GoMOVQSourceAliases[Op(base)])
+	}
+	form.op = Op(base)
+	form.bits = map[string]int{"MOVB": 8, "MOVW": 16, "MOVL": 32, "MOVQ": 64}[base]
+	source, destination := ins.Args[0], ins.Args[1]
+	if source.Kind == OpReg && source.Reg == TLS {
+		// progedit checks the complete AX..R15 source range before mode32
+		// encoding. Direct profiles NOP even R8..R15 and the other width.
+		// Accepting this source role grants no physical mode32 register bank.
+		if base != "MOVL" && base != "MOVQ" || destination.Kind != OpReg || !isAMD64YrlRegister(destination.Reg) {
+			return bad("requires the original Ytls-to-Yrl row")
+		}
+		form.gp = true
+		return form, true, nil
+	}
+	for index, operand := range ins.Args {
+		if operand.Kind == OpMem && (operand.Mem.Base == TLS || operand.Mem.Index == TLS) {
+			if form.memory >= 0 || !x86SourceTLSMemoryRole(operand, arch) {
+				return bad("requires one encodable TLS memory role")
+			}
+			form.memory = index
+		}
+	}
+	if form.memory < 0 {
+		return bad("has no row with a TLS destination register")
+	}
+	form.write = form.memory == 1
+	other := ins.Args[1-form.memory]
+	valid := false
+	switch other.Kind {
+	case OpImm:
+		valid = form.write && !other.ImmIsFloat && other.ImmRaw == "" &&
+			(base != "MOVQ" || arch == "amd64") &&
+			(arch == "386" || other.Imm >= -1<<31 && other.Imm <= 1<<32-1)
+	case OpReg:
+		form.gp = isX86YrlRegisterForArch(other.Reg, arch) && (base != "MOVQ" || arch == "amd64")
+		if base == "MOVB" {
+			form.gp = isGoYmbRegisterForArch(other.Reg, arch)
+		}
+		if base == "MOVW" {
+			switch other.Reg {
+			case CS, SS, DS, ES, FS, GS:
+				form.segment = true
+			}
+		}
+		if base == "MOVL" || base == "MOVQ" {
+			_, form.mmx = amd64ParseMReg(other.Reg)
+			index, xmm := amd64ParseXReg(other.Reg)
+			form.xmm = xmm && index < 16 && (arch == "amd64" || index < 8)
+		}
+		valid = form.gp || form.mmx || form.xmm || form.segment
+	case OpSym:
+		if form.write && arch == "386" && base != "MOVQ" && strings.HasPrefix(other.Sym, "$") {
+			_, _, valid = x86ScalarCompareSBAddress(Operand{Kind: OpSym, Sym: strings.TrimPrefix(other.Sym, "$")}, arch)
+		}
+	}
+	if !valid {
+		return bad("operands do not match a complete Go move row")
+	}
+	return form, true, nil
+}
diff --git a/amd64_tls_move_source_banks_test.go b/amd64_tls_move_source_banks_test.go
new file mode 100644
index 000000000..5192e7828
--- /dev/null
+++ b/amd64_tls_move_source_banks_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86TLSOriginalRegisterNames(t *testing.T) []string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/list6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, declaration := range file.Decls {
+		group, valid := declaration.(*ast.GenDecl)
+		if !valid || group.Tok != token.VAR {
+			continue
+		}
+		for _, specification := range group.Specs {
+			value, valid := specification.(*ast.ValueSpec)
+			if !valid || len(value.Names) != 1 || value.Names[0].Name != "Register" || len(value.Values) != 1 {
+				continue
+			}
+			list, valid := value.Values[0].(*ast.CompositeLit)
+			if !valid {
+				t.Fatal("unknown complete Go x86 register-name registration")
+			}
+			for _, element := range list.Elts {
+				literal, valid := element.(*ast.BasicLit)
+				if !valid || literal.Kind != token.STRING {
+					t.Fatal("nonliteral Go x86 register name")
+				}
+				name, err := strconv.Unquote(literal.Value)
+				if err != nil || name == "" {
+					t.Fatal("invalid original Go register name")
+				}
+				names = append(names, name)
+			}
+		}
+	}
+	if len(names) != 201 || names[16] != "AX" || names[31] != "R15" || names[len(names)-1] != "MAXREG" {
+		t.Fatalf("complete Go x86 register-name inventory changed: %d names", len(names))
+	}
+	return names
+}
+
+func TestX86TLSMoveDirectNOPAllRegisteredDestinationClasses(t *testing.T) {
+	originalNames := x86TLSOriginalRegisterNames(t)
+	for _, profile := range []struct{ target, arch string }{{"linux", "amd64"}, {"freebsd", "386"}} {
+		t.Run(profile.target+"/"+profile.arch, func(t *testing.T) {
+			names := append(append([]string(nil), originalNames...), "SB", "FP", "PC", "UNREGISTERED")
+			if profile.arch == "amd64" {
+				names = append(names, "g") // The independently registered AMD64-only R14 alias.
+			}
+			accepted, rejected, contextual := 0, 0, 0
+			for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q"} {
+				for index, register := range names {
+					row := op + " TLS," + register
+					wantNOP := index >= 16 && index <= 31 || register == "g"
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "bank.s"), filepath.Join(dir, "bank.o")
+					if err := os.WriteFile(input, []byte("TEXT f(SB),4,$0-0\n"+row+"\nRET\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					args := []string{"tool", "asm", "-p", "tlsbanks", "-o", object}
+					if wantNOP {
+						args = append(args, "-S")
+					}
+					args = append(args, input)
+					ctx, cancel := runtimeOracleStageContext(t)
+					command := exec.CommandContext(ctx, "go", args...)
+					command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS="+profile.target, "GOARCH="+profile.arch,
+						"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=", "GOAMD64=v1", "GO386=sse2")
+					output, err := runtimeOracleCombinedOutput(ctx, command)
+					contextErr := ctx.Err()
+					cancel()
+					if err == nil {
+						if !wantNOP {
+							t.Fatalf("unmodeled actual Go acceptance: %s %s\n%s", profile.arch, row, output)
+						}
+						if failure := goAssemblerOracleOutcome(input, object, output, err, contextErr, true, profile.arch); failure != nil {
+							t.Fatal(failure)
+						}
+						noops := 0
+						for _, line := range strings.Split(string(output), "\n") {
+							record := goAMD64FrameRow.FindStringSubmatch(line)
+							if record != nil && strings.TrimSpace(record[3]) == "NOP" {
+								noops++
+							}
+						}
+						if noops != 1 || !strings.Contains(string(output), "size=1 ") {
+							t.Fatalf("accepted source is not one zero-width NOP and RET: %s\n%s", row, output)
+						}
+						if typed := x86SourceTLSMoveError(x86PureGPUnknownInstruction(t, row), profile.arch); !errors.Is(typed, ErrProbeNeedsContext) {
+							t.Fatalf("actual source NOP lacks its explicit binding boundary: %s: %v", row, typed)
+						}
+						accepted++
+						continue
+					}
+					if wantNOP {
+						t.Fatalf("actual Go lost its registered source NOP: %s: %v\n%s", row, err, output)
+					}
+					if failure := goAssemblerOracleOutcome(input, object, output, err, contextErr, false, profile.arch); failure == nil {
+						rejected++
+						continue
+					}
+					// A compiler/backend diagnostic without a complete fixture-bound
+					// rejection remains Context, never successful source coverage.
+					exit, exited := err.(*exec.ExitError)
+					if contextErr != nil || !exited || exit.ExitCode() != 1 || len(output) == 0 {
+						t.Fatalf("unknown/infrastructure bank observation: %s: %v\n%s", row, err, output)
+					}
+					contextual++
+					t.Logf("native bank Context: %s %s: %s", profile.arch, row, strings.TrimSpace(string(output)))
+				}
+			}
+			want := 64
+			if profile.arch == "amd64" {
+				want = 68
+			}
+			if accepted != want || accepted+rejected+contextual != 4*len(names) {
+				t.Fatal("complete destination-bank probe inventory changed")
+			}
+			t.Logf("%s: actual source NOPs=%d ordinary Go rejections=%d Context=%d total=%d",
+				fmt.Sprint(profile), accepted, rejected, contextual, 4*len(names))
+		})
+	}
+}
diff --git a/amd64_tls_move_test.go b/amd64_tls_move_test.go
new file mode 100644
index 000000000..58a1a7abc
--- /dev/null
+++ b/amd64_tls_move_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86TLSMoveRows(arch string, direct bool) []string {
+	var rows []string
+	word := "MOVQ"
+	if arch == "386" {
+		word = "MOVL"
+	}
+	rows = append(rows, word+" TLS,AX", word+" TLS,CX", word+" TLS,SP", word+" TLS,BP")
+	addresses := []string{"0(CX)(TLS*1)", "-8(BP)(TLS*2)", "8(SP)(TLS*4)",
+		"0(AX)(TLS)", "0(TLS*8)", "0(FS)(TLS*1)", "slot(FP)(TLS*1)", "slot(SP)(TLS*1)"}
+	if arch == "386" {
+		addresses = append(addresses, "data(SB)(TLS)", "data(SB)(TLS*1)")
+	}
+	if direct {
+		addresses = append(addresses, "-8(TLS)", "0(TLS)", "8(TLS)")
+		// Direct-TLS progedit removes both spellings before the special
+		// movTLSReg emitter can enforce the machine's native pointer width.
+		rows = append(rows, "MOVL TLS,DX", "MOVQ TLS,DX")
+	}
+	for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+		var registers []string
+		if op == "MOVL" || op == "MOVQ" {
+			registers = append(registers, "M0", "M7", "X0", "X7")
+			if arch == "amd64" {
+				registers = append(registers, "X8", "X15")
+			}
+		}
+		if op == "MOVB" {
+			registers = append(registers, "AL", "BL", "AH", "BH")
+		}
+		if op == "MOVW" {
+			registers = append(registers, "CS", "SS", "DS", "ES", "FS", "GS")
+		}
+		if op != "MOVQ" || arch == "amd64" {
+			registers = append(registers, "AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI")
+			if op == "MOVB" && arch == "386" {
+				registers = []string{"AL", "BL", "AH", "BH", "AX", "CX", "DX", "BX", "BP", "SI", "DI"}
+			}
+			if arch == "amd64" {
+				registers = append(registers, "R8", "R15")
+			}
+		}
+		for _, address := range addresses {
+			for _, register := range registers {
+				rows = append(rows, op+" "+address+","+register, op+" "+register+","+address)
+			}
+			if op != "MOVQ" || arch == "amd64" {
+				for _, immediate := range []string{"0", "1", "-2147483648", "4294967295"} {
+					rows = append(rows, op+" $"+immediate+","+address)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86TLSMoveActualGoProfiles(t *testing.T) {
+	for _, profile := range []struct {
+		arch, goos     string
+		shared, direct bool
+	}{
+		{"386", "linux", false, false}, {"386", "linux", true, false},
+		{"386", "windows", false, false}, {"386", "freebsd", false, true},
+		{"amd64", "linux", false, true}, {"amd64", "linux", true, false},
+		{"amd64", "darwin", false, true}, {"amd64", "windows", false, false},
+	} {
+		t.Run(fmt.Sprintf("%s/%s/shared=%v", profile.goos, profile.arch, profile.shared), func(t *testing.T) {
+			var source strings.Builder
+			rows := x86TLSMoveRows(profile.arch, profile.direct)
+			assembled, defects := 0, 0
+			for index, row := range rows {
+				// Go's shared 386 PIC rewrite borrows the destination register
+				// for MOVL named SB loads. MMX/XMM cannot serve as an address
+				// base there. Those native backend defects are tested separately;
+				// the same source rows are accepted by non-shared Go profiles.
+				if profile.arch == "386" && profile.shared && x86TLSMoveShared386SBVectorLoad(row) {
+					defects++
+					continue
+				}
+				fmt.Fprintf(&source, "TEXT ·tls%d(SB),4,$0-0\n%s\nRET\n", index, row)
+				assembled++
+			}
+			x86ScalarCompareTLSGoObject(t, source.String(), profile.arch, profile.goos, profile.shared)
+			t.Logf("%d actual Go TLS move rows; %d separately checked native backend defects", assembled, defects)
+		})
+	}
+}
+
+func x86TLSMoveShared386SBVectorLoad(row string) bool {
+	return strings.HasPrefix(row, "MOVL data(SB)(TLS*1),") && (strings.Contains(row, ",M") || strings.Contains(row, ",X"))
+}
+
+func TestX86TLSMoveShared386SBBackendDefect(t *testing.T) {
+	count := 0
+	for _, row := range x86TLSMoveRows("386", false) {
+		if !x86TLSMoveShared386SBVectorLoad(row) {
+			continue
+		}
+		count++
+		t.Run(row, func(t *testing.T) {
+			dir := t.TempDir()
+			path, object := filepath.Join(dir, "tls.s"), filepath.Join(dir, "tls.o")
+			original := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+			if err := os.WriteFile(path, []byte(original), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, "go", "tool", "asm", "-shared", "-o", object, path)
+			command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=386", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			exit, exited := err.(*exec.ExitError)
+			register := strings.Split(row, ",")[1]
+			want := "asm: asmand: bad address data(" + register + ")(TLS*1)\nasm: assembly failed\n"
+			if ctx.Err() != nil || !exited || exit.ExitCode() != 1 || string(output) != want {
+				t.Fatalf("unknown shared 386 TLS backend observation: %v\n%s", err, output)
+			}
+			if goAssemblerOracleOutcome(path, object, output, err, ctx.Err(), false, "386") == nil {
+				t.Fatal("backend address failure became an illegal-source certificate")
+			}
+			if err := x86SourceTLSMoveError(x86PureGPUnknownInstruction(t, row), "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("missing native profile became accepted LLVM: %v", err)
+			}
+		})
+	}
+	if count != 4 {
+		t.Fatalf("shared profile partition omitted native defects: %d", count)
+	}
+}
+
+func TestX86TLSMoveTypedBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+			for _, mutation := range []struct {
+				name   string
+				mutate func(*Instr)
+			}{
+				{"scale", func(ins *Instr) { ins.Args[0].Mem.Scale = 3 }},
+				{"offset", func(ins *Instr) { ins.Args[0].Mem.OffRaw = "missing" }},
+				{"unknown-base", func(ins *Instr) { ins.Args[0].Mem.Base = "UNKNOWN" }},
+				{"extension", func(ins *Instr) { ins.Args[0].Mem.IndexExt = ExtendUXTW }},
+				{"symbol", func(ins *Instr) { ins.Args[0].Mem.Sym = "$data(SB)" }},
+				{"suffix", func(ins *Instr) { ins.Op += ".Z" }},
+				{"immediate-raw", func(ins *Instr) {
+					ins.Args = []Operand{{Kind: OpImm, ImmRaw: "$missing"}, ins.Args[0]}
+				}},
+				{"immediate-float", func(ins *Instr) {
+					ins.Args = []Operand{{Kind: OpImm, ImmIsFloat: true}, ins.Args[0]}
+				}},
+			} {
+				t.Run(arch+"/"+op+"/"+mutation.name, func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, op+" 0(CX)(TLS*1),AX")
+					mutation.mutate(&ins)
+					if err := x86SourceTLSMoveError(ins, arch); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("invalid typed row hidden by TLS: %v", err)
+					}
+				})
+			}
+			ins := x86PureGPUnknownInstruction(t, op+" 0(CX)(TLS*1),AX")
+			if err := x86SourceTLSMoveError(ins, "unknown"); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown mode hidden by TLS: %v", err)
+			}
+		}
+	}
+	for _, op := range []string{"MOVL", "MOVQ"} {
+		for _, body := range []string{op + " 0(CX)(TLS*1),X8", op + " X15,0(CX)(TLS*1)"} {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+			if err := x86SourceTLSMoveError(x86PureGPUnknownInstruction(t, body), "386"); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("386 high X bank hidden by TLS: %v", err)
+			}
+		}
+	}
+}
+
+func TestX86TLSMoveMalformedSourceRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+			for _, operands := range []string{"AX,TLS", "TLS,TLS", "TLS,X0", "TLS,0(CX)(TLS*1)",
+				"0(CX)(TLS*1),0(DX)(TLS*1)", "0(CX)(TLS*1),$1", "0(CX)(TLS*1),Y0", "0(CX)(TLS*1),K1",
+				"$1.5,0(CX)(TLS*1)", "0(CX)(TLS*1)", "AX,0(CX)(TLS*1),BX"} {
+				body := op + " " + operands
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+				ins := x86PureGPUnknownInstruction(t, body)
+				if err := x86SourceTLSMoveError(ins, arch); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("bad source row was hidden by TLS: %s %s: %v", arch, body, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86TLSMoveUnreachableSourceFailsClosed(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []string{"MOVB 8(TLS),AX", "MOVW AX,0(CX)(TLS*1)", "MOVL TLS,AX", "MOVQ 8(TLS),X0"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				source := "TEXT ·probe(SB),4,$0-0\nJMP done\n" + row + "\ndone:\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func probe()", target.arch, target.triple, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s %s %s: unreachable TLS source escaped: %v\n%s", target.arch, row, api, err, ir)
+				}
+			}
+		}
+	}
+}
+
+func TestX86TLSAddressFallbackFailsClosed(t *testing.T) {
+	for _, body := range []string{"ADDL 8(TLS),AX", "ANDL 8(TLS),AX", "ADDL 8(CX)(TLS*1),AX", "ANDL 8(CX)(TLS*1),AX"} {
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·probe(SB),4,$0-0\n"+body+"\nRET\n", "func probe()", "amd64", "x86_64-unknown-linux-gnu", api)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("%s %s: generic TLS address became zero: %v\n%s", body, api, err, ir)
+			}
+		}
+	}
+	context := &amd64Ctx{goarch: "amd64"}
+	if value, err := context.loadReg(TLS); !errors.Is(err, ErrProbeNeedsContext) || value != "" {
+		t.Fatalf("missing TLS slot invented a value: %q, %v", value, err)
+	}
+	if value, err := context.loadReg(AX); err != nil || value != "0" {
+		t.Fatalf("ordinary missing-register behavior changed: %q, %v", value, err)
+	}
+}
+
+func TestX86TLSMoveAPIsFailClosed(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86TLSMoveRows(target.arch, true) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row+"/"+api, func(t *testing.T) {
+					source := "TEXT ·probe(SB),4,$0-0\n" + row + "\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func probe()", target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("unbound TLS move must return Context and no IR: %v\n%s", err, ir)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_translate.go b/amd64_translate.go
index 1439e683d..f7fbe5eab 100644
--- a/amd64_translate.go
+++ b/amd64_translate.go
@@ -9,23 +9,130 @@ type amd64EmitBr func(target string)
 type amd64EmitCondBr func(cond string, target string, fall string) error
 
 func emitAMD64Prelude(b *strings.Builder, goarch string, file *File) {
+	emitX86SHADeclarations(b, file)
 	b.WriteString("declare i64 @syscall(i64, i64, i64, i64, i64, i64, i64)\n")
 	b.WriteString("declare i32 @cliteErrno()\n")
 	// Generic LLVM intrinsics used by amd64 lowering.
 	b.WriteString("declare i64 @llvm.cttz.i64(i64, i1)\n")
 	b.WriteString("declare i32 @llvm.cttz.i32(i32, i1)\n")
+	b.WriteString("declare i16 @llvm.cttz.i16(i16, i1)\n")
 	b.WriteString("declare i64 @llvm.ctlz.i64(i64, i1)\n")
 	b.WriteString("declare i32 @llvm.ctlz.i32(i32, i1)\n")
+	b.WriteString("declare i16 @llvm.ctlz.i16(i16, i1)\n")
 	b.WriteString("declare i64 @llvm.ctpop.i64(i64)\n")
 	b.WriteString("declare i32 @llvm.ctpop.i32(i32)\n")
+	b.WriteString("declare i16 @llvm.ctpop.i16(i16)\n")
+	b.WriteString("declare i32 @llvm.x86.rdpid()\n")
+	b.WriteString("declare i32 @llvm.x86.xbegin()\n")
+	b.WriteString("declare void @llvm.x86.xabort(i8 immarg)\n")
+	b.WriteString("declare void @llvm.x86.xend()\n")
+	b.WriteString("declare i32 @llvm.x86.xtest()\n")
+	for _, family := range []string{"rdrand", "rdseed"} {
+		for _, bits := range []int{16, 32, 64} {
+			fmt.Fprintf(b, "declare { i%d, i32 } @llvm.x86.%s.%d()\n", bits, family, bits)
+		}
+	}
+	for _, laneBits := range []int{8, 16, 32, 64} {
+		for _, byteWidth := range []int{16, 32, 64} {
+			lanes := byteWidth * 8 / laneBits
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.ctpop.v%di%d(<%d x i%d>)\n", lanes, laneBits, lanes, laneBits, lanes, laneBits)
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.ctlz.v%di%d(<%d x i%d>, i1)\n", lanes, laneBits, lanes, laneBits, lanes, laneBits)
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.experimental.vector.compress.v%di%d(<%d x i%d>, <%d x i1>, <%d x i%d>)\n", lanes, laneBits, lanes, laneBits, lanes, laneBits, lanes, lanes, laneBits)
+			fmt.Fprintf(b, "declare void @llvm.masked.compressstore.v%di%d(<%d x i%d>, ptr, <%d x i1>)\n", lanes, laneBits, lanes, laneBits, lanes)
+			fmt.Fprintf(b, "declare void @llvm.masked.compressstore.v%di%d.p256(<%d x i%d>, ptr addrspace(256), <%d x i1>)\n", lanes, laneBits, lanes, laneBits, lanes)
+			fmt.Fprintf(b, "declare void @llvm.masked.compressstore.v%di%d.p257(<%d x i%d>, ptr addrspace(257), <%d x i1>)\n", lanes, laneBits, lanes, laneBits, lanes)
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.masked.expandload.v%di%d(ptr, <%d x i1>, <%d x i%d>)\n", lanes, laneBits, lanes, laneBits, lanes, lanes, laneBits)
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.masked.expandload.v%di%d.p256(ptr addrspace(256), <%d x i1>, <%d x i%d>)\n", lanes, laneBits, lanes, laneBits, lanes, lanes, laneBits)
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.masked.expandload.v%di%d.p257(ptr addrspace(257), <%d x i1>, <%d x i%d>)\n", lanes, laneBits, lanes, laneBits, lanes, lanes, laneBits)
+			if laneBits >= 16 {
+				vectorType := fmt.Sprintf("<%d x i%d>", lanes, laneBits)
+				fmt.Fprintf(b, "declare %s @llvm.fshl.v%di%d(%s, %s, %s)\n", vectorType, lanes, laneBits, vectorType, vectorType, vectorType)
+				fmt.Fprintf(b, "declare %s @llvm.fshr.v%di%d(%s, %s, %s)\n", vectorType, lanes, laneBits, vectorType, vectorType, vectorType)
+			}
+		}
+	}
 	b.WriteString("declare i64 @llvm.bswap.i64(i64)\n")
 	b.WriteString("declare i32 @llvm.bswap.i32(i32)\n")
+	b.WriteString("declare i16 @llvm.bswap.i16(i16)\n")
+	b.WriteString("declare float @llvm.sqrt.f32(float)\n")
 	b.WriteString("declare double @llvm.sqrt.f64(double)\n")
+	b.WriteString("declare <4 x float> @llvm.sqrt.v4f32(<4 x float>)\n")
+	b.WriteString("declare <8 x float> @llvm.sqrt.v8f32(<8 x float>)\n")
+	b.WriteString("declare <16 x float> @llvm.sqrt.v16f32(<16 x float>)\n")
+	b.WriteString("declare <2 x double> @llvm.sqrt.v2f64(<2 x double>)\n")
+	b.WriteString("declare <4 x double> @llvm.sqrt.v4f64(<4 x double>)\n")
+	b.WriteString("declare <8 x double> @llvm.sqrt.v8f64(<8 x double>)\n")
+	b.WriteString("declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>)\n")
+	b.WriteString("declare <4 x float> @llvm.x86.sse.rsqrt.ps(<4 x float>)\n")
+	b.WriteString("declare <8 x float> @llvm.x86.avx.rcp.ps.256(<8 x float>)\n")
+	b.WriteString("declare <8 x float> @llvm.x86.avx.rsqrt.ps.256(<8 x float>)\n")
+	b.WriteString("declare <2 x double> @llvm.x86.sse41.dppd(<2 x double>, <2 x double>, i8 immarg)\n")
+	b.WriteString("declare <4 x float> @llvm.x86.sse41.dpps(<4 x float>, <4 x float>, i8 immarg)\n")
+	b.WriteString("declare <8 x float> @llvm.x86.avx.dp.ps.256(<8 x float>, <8 x float>, i8 immarg)\n")
+	b.WriteString("declare <8 x i16> @llvm.x86.sse41.mpsadbw(<16 x i8>, <16 x i8>, i8 immarg)\n")
+	b.WriteString("declare <16 x i16> @llvm.x86.avx2.mpsadbw(<32 x i8>, <32 x i8>, i8 immarg)\n")
+	b.WriteString("declare i32 @llvm.x86.sse42.pcmpestri128(<16 x i8>, i32, <16 x i8>, i32, i8 immarg)\n")
+	b.WriteString("declare <16 x i8> @llvm.x86.sse42.pcmpestrm128(<16 x i8>, i32, <16 x i8>, i32, i8 immarg)\n")
+	b.WriteString("declare i32 @llvm.x86.sse42.pcmpistri128(<16 x i8>, <16 x i8>, i8 immarg)\n")
+	b.WriteString("declare <16 x i8> @llvm.x86.sse42.pcmpistrm128(<16 x i8>, <16 x i8>, i8 immarg)\n")
+	for _, family := range []string{"pcmpestri", "pcmpistri"} {
+		for _, flag := range []string{"c", "o", "s", "z"} {
+			if family == "pcmpestri" {
+				fmt.Fprintf(b, "declare i32 @llvm.x86.sse42.%s%s128(<16 x i8>, i32, <16 x i8>, i32, i8 immarg)\n", family, flag)
+			} else {
+				fmt.Fprintf(b, "declare i32 @llvm.x86.sse42.%s%s128(<16 x i8>, <16 x i8>, i8 immarg)\n", family, flag)
+			}
+		}
+	}
+	for _, declaration := range []string{
+		"float @llvm.fma.f32(float, float, float)",
+		"double @llvm.fma.f64(double, double, double)",
+		"<4 x float> @llvm.fma.v4f32(<4 x float>, <4 x float>, <4 x float>)",
+		"<8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>)",
+		"<16 x float> @llvm.fma.v16f32(<16 x float>, <16 x float>, <16 x float>)",
+		"<2 x double> @llvm.fma.v2f64(<2 x double>, <2 x double>, <2 x double>)",
+		"<4 x double> @llvm.fma.v4f64(<4 x double>, <4 x double>, <4 x double>)",
+		"<8 x double> @llvm.fma.v8f64(<8 x double>, <8 x double>, <8 x double>)",
+	} {
+		b.WriteString("declare " + declaration + "\n")
+	}
+	for _, declaration := range []string{
+		"float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata)",
+		"double @llvm.experimental.constrained.fma.f64(double, double, double, metadata, metadata)",
+		"<16 x float> @llvm.experimental.constrained.fma.v16f32(<16 x float>, <16 x float>, <16 x float>, metadata, metadata)",
+		"<8 x double> @llvm.experimental.constrained.fma.v8f64(<8 x double>, <8 x double>, <8 x double>, metadata, metadata)",
+	} {
+		b.WriteString("declare " + declaration + "\n")
+	}
+	for _, operation := range []string{"fadd", "fsub", "fmul", "fdiv"} {
+		for _, signature := range []string{
+			"float @llvm.experimental.constrained.%s.f32(float, float, metadata, metadata)",
+			"double @llvm.experimental.constrained.%s.f64(double, double, metadata, metadata)",
+			"<4 x float> @llvm.experimental.constrained.%s.v4f32(<4 x float>, <4 x float>, metadata, metadata)",
+			"<8 x float> @llvm.experimental.constrained.%s.v8f32(<8 x float>, <8 x float>, metadata, metadata)",
+			"<2 x double> @llvm.experimental.constrained.%s.v2f64(<2 x double>, <2 x double>, metadata, metadata)",
+			"<4 x double> @llvm.experimental.constrained.%s.v4f64(<4 x double>, <4 x double>, metadata, metadata)",
+			"<16 x float> @llvm.experimental.constrained.%s.v16f32(<16 x float>, <16 x float>, metadata, metadata)",
+			"<8 x double> @llvm.experimental.constrained.%s.v8f64(<8 x double>, <8 x double>, metadata, metadata)",
+			"<32 x half> @llvm.experimental.constrained.%s.v32f16(<32 x half>, <32 x half>, metadata, metadata)",
+		} {
+			b.WriteString("declare " + fmt.Sprintf(signature, operation) + "\n")
+		}
+	}
 	b.WriteString("declare double @llvm.rint.f64(double)\n")
+	b.WriteString("declare double @llvm.roundeven.f64(double)\n")
+	b.WriteString("declare double @llvm.floor.f64(double)\n")
+	b.WriteString("declare double @llvm.ceil.f64(double)\n")
+	b.WriteString("declare double @llvm.trunc.f64(double)\n")
+	b.WriteString("declare double @llvm.sin.f64(double)\n")
+	b.WriteString("declare double @llvm.cos.f64(double)\n")
+	b.WriteString("declare double @llvm.exp2.f64(double)\n")
+	b.WriteString("declare double @llvm.log2.f64(double)\n")
+	b.WriteString("declare double @atan2(double, double)\n")
+	b.WriteString("declare double @fmod(double, double)\n")
+	b.WriteString("declare double @remainder(double, double)\n")
+	b.WriteString("declare double @tan(double)\n")
 	if goarch == "386" {
-		b.WriteString("declare double @llvm.floor.f64(double)\n")
-		b.WriteString("declare double @llvm.ceil.f64(double)\n")
-		b.WriteString("declare double @llvm.trunc.f64(double)\n")
 		b.WriteString("declare double @llvm.fabs.f64(double)\n")
 	}
 	b.WriteString("declare <16 x i8> @llvm.x86.ssse3.pshuf.b.128(<16 x i8>, <16 x i8>)\n")
@@ -35,6 +142,50 @@ func emitAMD64Prelude(b *strings.Builder, goarch string, file *File) {
 	b.WriteString("declare <2 x i64> @llvm.x86.aesni.aesdeclast(<2 x i64>, <2 x i64>)\n")
 	b.WriteString("declare <2 x i64> @llvm.x86.aesni.aesimc(<2 x i64>)\n")
 	b.WriteString("declare <2 x i64> @llvm.x86.aesni.aeskeygenassist(<2 x i64>, i8 immarg)\n")
+	b.WriteString("declare void @llvm.x86.sse.ldmxcsr(ptr)\n")
+	b.WriteString("declare void @llvm.x86.sse.stmxcsr(ptr)\n")
+	b.WriteString("declare <4 x i32> @llvm.x86.sse2.cvtps2dq(<4 x float>)\n")
+	b.WriteString("declare <4 x i32> @llvm.x86.sse2.cvttps2dq(<4 x float>)\n")
+	b.WriteString("declare <8 x i32> @llvm.x86.avx.cvt.ps2dq.256(<8 x float>)\n")
+	b.WriteString("declare <8 x i32> @llvm.x86.avx.cvtt.ps2dq.256(<8 x float>)\n")
+	b.WriteString("declare <16 x float> @llvm.experimental.constrained.sitofp.v16f32.v16i32(<16 x i32>, metadata, metadata)\n")
+	for _, result := range []struct {
+		bits int
+		typ  string
+	}{{32, "float"}, {64, "double"}} {
+		for _, bits := range []int{32, 64} {
+			fmt.Fprintf(b, "declare %s @llvm.experimental.constrained.sitofp.f%d.i%d(i%d, metadata, metadata)\n", result.typ, result.bits, bits, bits)
+		}
+	}
+	b.WriteString("declare <8 x float> @llvm.experimental.constrained.fptrunc.v8f32.v8f64(<8 x double>, metadata, metadata)\n")
+	for _, lanes := range []int{4, 8, 16} {
+		fmt.Fprintf(b, "declare <%d x half> @llvm.experimental.constrained.fptrunc.v%df16.v%df32(<%d x float>, metadata, metadata)\n", lanes, lanes, lanes, lanes)
+	}
+	b.WriteString("declare float @llvm.rint.f32(float)\n")
+	b.WriteString("declare float @llvm.roundeven.f32(float)\n")
+	b.WriteString("declare float @llvm.trunc.f32(float)\n")
+	b.WriteString("declare float @llvm.floor.f32(float)\n")
+	b.WriteString("declare float @llvm.ceil.f32(float)\n")
+	b.WriteString("declare <16 x float> @llvm.experimental.constrained.sqrt.v16f32(<16 x float>, metadata, metadata)\n")
+	b.WriteString("declare <8 x double> @llvm.experimental.constrained.sqrt.v8f64(<8 x double>, metadata, metadata)\n")
+	b.WriteString("declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata)\n")
+	b.WriteString("declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)\n")
+	b.WriteString("declare i32 @llvm.fptosi.sat.i32.f32(float)\n")
+	b.WriteString("declare i32 @llvm.fptosi.sat.i32.f64(double)\n")
+	for _, conversion := range []struct {
+		name       string
+		resultType string
+		sourceType string
+	}{
+		{name: "fptoui.sat.i32.f32", resultType: "i32", sourceType: "float"},
+		{name: "fptoui.sat.i32.f64", resultType: "i32", sourceType: "double"},
+		{name: "fptosi.sat.i64.f32", resultType: "i64", sourceType: "float"},
+		{name: "fptosi.sat.i64.f64", resultType: "i64", sourceType: "double"},
+		{name: "fptoui.sat.i64.f32", resultType: "i64", sourceType: "float"},
+		{name: "fptoui.sat.i64.f64", resultType: "i64", sourceType: "double"},
+	} {
+		fmt.Fprintf(b, "declare %s @llvm.%s(%s)\n", conversion.resultType, conversion.name, conversion.sourceType)
+	}
 	b.WriteString("\n")
 	// x86-64 CRC32 (SSE4.2) and PCLMULQDQ intrinsics.
 	b.WriteString("declare i64 @llvm.x86.sse42.crc32.64.64(i64, i64)\n")
@@ -44,39 +195,89 @@ func emitAMD64Prelude(b *strings.Builder, goarch string, file *File) {
 	b.WriteString("declare <2 x i64> @llvm.x86.pclmulqdq(<2 x i64>, <2 x i64>, i8 immarg)\n")
 	// SSE2 helpers used by stdlib asm (e.g. internal/bytealg).
 	b.WriteString("declare i32 @llvm.x86.sse2.pmovmskb.128(<16 x i8>)\n")
+	for _, shape := range []struct{ lanes, bits int }{
+		{2, 8}, {4, 8}, {2, 16}, {4, 16}, {2, 32}, // Packed widening source lanes.
+		{8, 8}, // Legacy MMX MASKMOVQ.
+		{16, 8}, {32, 8}, {64, 8}, {8, 16}, {16, 16}, {32, 16},
+		{4, 32}, {8, 32}, {16, 32}, {2, 64}, {4, 64}, {8, 64},
+	} {
+		for _, addressSpace := range []struct {
+			suffix, pointer string
+		}{{".p0", "ptr"}, {".p256", "ptr addrspace(256)"}, {".p257", "ptr addrspace(257)"}} {
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.masked.load.v%di%d%s(%s, <%d x i1>, <%d x i%d>)\n", shape.lanes, shape.bits, shape.lanes, shape.bits, addressSpace.suffix, addressSpace.pointer, shape.lanes, shape.lanes, shape.bits)
+			fmt.Fprintf(b, "declare void @llvm.masked.store.v%di%d%s(<%d x i%d>, %s, <%d x i1>)\n", shape.lanes, shape.bits, addressSpace.suffix, shape.lanes, shape.bits, addressSpace.pointer, shape.lanes)
+		}
+	}
 	b.WriteString("\n")
 	b.WriteString("\n")
-	if goarch == "386" {
-		emit386StringHelpers(b, file)
-	}
+	emitX86StringHelpers(b, file)
+	emitAMD64FMA3RoundingHelpers(b, file, goarch)
 }
 
-func emit386StringHelpers(b *strings.Builder, file *File) {
-	needMOVSB, needMOVSL, needSTOSL, needSCASB := false, false, false, false
+func emitX86StringHelpers(b *strings.Builder, file *File) {
+	needed := make(map[string]struct{})
 	for _, fn := range file.Funcs {
 		for _, ins := range fn.Instrs {
-			switch strings.ToUpper(string(ins.Op)) {
-			case "MOVSB":
-				needMOVSB = true
-			case "MOVSL":
-				needMOVSL = true
-			case "STOSL":
-				needSTOSL = true
-			case "SCASB":
-				needSCASB = true
+			kind, typ, width, ok := x86StringProperties(ins.Op)
+			if !ok {
+				continue
+			}
+			name := x86StringHelperName(kind, width)
+			if _, ok := needed[name]; ok {
+				continue
+			}
+			needed[name] = struct{}{}
+			switch kind {
+			case "movs":
+				emitX86MOVSHelper(b, name, string(typ), width)
+			case "stos":
+				emitX86STOSHelper(b, name, string(typ), width)
+			case "scas":
+				emitX86SCASHelper(b, name, string(typ), width)
+			case "cmps":
+				emitX86CMPSHelper(b, name, string(typ), width)
+			case "lods":
+				emitX86LODSHelper(b, name, string(typ), width)
 			}
 		}
 	}
-	if needMOVSB {
-		emit386MOVSHelper(b, "__plan9asm_movsb", "i8", 1)
-	}
-	if needMOVSL {
-		emit386MOVSHelper(b, "__plan9asm_movsl", "i32", 4)
-	}
-	if needSTOSL {
-		b.WriteString(`define internal void @__plan9asm_rep_stosl(i64 %addr, i32 %value, i64 %count, i1 %backward) {
-entry:
+}
+
+func emitX86MOVSHelper(b *strings.Builder, name, ty string, width int) {
+	fmt.Fprintf(b, "define internal void @%s(i64 %%dst, i64 %%src, i64 %%count, i1 %%backward) {\n", name)
+	b.WriteString(`entry:
+  %step = select i1 %backward, i64 `)
+	fmt.Fprintf(b, "-%d, i64 %d\n", width, width)
+	b.WriteString(`  br label %loop
+loop:
+  %cur_dst = phi i64 [ %dst, %entry ], [ %next_dst, %body ]
+  %cur_src = phi i64 [ %src, %entry ], [ %next_src, %body ]
+  %left = phi i64 [ %count, %entry ], [ %remaining, %body ]
+  %done = icmp eq i64 %left, 0
+  br i1 %done, label %exit, label %body
+body:
+  %dst_ptr = inttoptr i64 %cur_dst to ptr
+  %src_ptr = inttoptr i64 %cur_src to ptr
+`)
+	fmt.Fprintf(b, "  %%value = load volatile %s, ptr %%src_ptr, align 1\n", ty)
+	fmt.Fprintf(b, "  store volatile %s %%value, ptr %%dst_ptr, align 1\n", ty)
+	b.WriteString(`  %next_dst = add i64 %cur_dst, %step
+  %next_src = add i64 %cur_src, %step
+  %remaining = sub i64 %left, 1
   br label %loop
+exit:
+  ret void
+}
+
+`)
+}
+
+func emitX86STOSHelper(b *strings.Builder, name, typ string, width int) {
+	fmt.Fprintf(b, "define internal void @%s(i64 %%addr, %s %%value, i64 %%count, i1 %%backward) {\n", name, typ)
+	b.WriteString(`entry:
+  %step = select i1 %backward, i64 `)
+	fmt.Fprintf(b, "-%d, i64 %d\n", width, width)
+	b.WriteString(`  br label %loop
 loop:
   %cur = phi i64 [ %addr, %entry ], [ %next, %body ]
   %left = phi i64 [ %count, %entry ], [ %remaining, %body ]
@@ -84,9 +285,9 @@ loop:
   br i1 %done, label %exit, label %body
 body:
   %ptr = inttoptr i64 %cur to ptr
-  store i32 %value, ptr %ptr, align 1
-  %step = select i1 %backward, i64 -4, i64 4
-  %next = add i64 %cur, %step
+`)
+	fmt.Fprintf(b, "  store volatile %s %%value, ptr %%ptr, align 1\n", typ)
+	b.WriteString(`  %next = add i64 %cur, %step
   %remaining = sub i64 %left, 1
   br label %loop
 exit:
@@ -94,78 +295,231 @@ exit:
 }
 
 `)
-	}
-	if needSCASB {
-		b.WriteString(`define internal { i64, i64, i1 } @__plan9asm_repne_scasb(i64 %addr, i8 %needle, i64 %count, i1 %backward) {
-entry:
-  br label %loop
+}
+
+func emitX86SCASHelper(b *strings.Builder, name, typ string, width int) {
+	resultType := fmt.Sprintf("{ i64, i64, %s, i1 }", typ)
+	fmt.Fprintf(b, "define internal %s @%s(i64 %%addr, %s %%needle, i64 %%count, i1 %%backward, i1 %%while_equal) {\n", resultType, name, typ)
+	b.WriteString(`entry:
+  %step = select i1 %backward, i64 `)
+	fmt.Fprintf(b, "-%d, i64 %d\n", width, width)
+	b.WriteString(`  br label %loop
 loop:
-  %cur = phi i64 [ %addr, %entry ], [ %next, %miss ]
-  %left = phi i64 [ %count, %entry ], [ %remaining, %miss ]
+  %cur = phi i64 [ %addr, %entry ], [ %scan_next, %scan ]
+  %left = phi i64 [ %count, %entry ], [ %scan_remaining, %scan ]
   %empty = icmp eq i64 %left, 0
-  br i1 %empty, label %not_found, label %scan
+  br i1 %empty, label %empty_exit, label %scan
 scan:
   %ptr = inttoptr i64 %cur to ptr
-  %value = load i8, ptr %ptr, align 1
-  %equal = icmp eq i8 %value, %needle
-  %step = select i1 %backward, i64 -1, i64 1
+`)
+	fmt.Fprintf(b, "  %%value = load volatile %s, ptr %%ptr, align 1\n", typ)
+	fmt.Fprintf(b, "  %%equal = icmp eq %s %%value, %%needle\n", typ)
+	b.WriteString(`  %not_equal = xor i1 %equal, true
+  %repeat_condition = select i1 %while_equal, i1 %equal, i1 %not_equal
   %scan_next = add i64 %cur, %step
   %scan_remaining = sub i64 %left, 1
-  br i1 %equal, label %found, label %miss
-miss:
-  %next = phi i64 [ %scan_next, %scan ]
-  %remaining = phi i64 [ %scan_remaining, %scan ]
-  br label %loop
-found:
-  %found0 = insertvalue { i64, i64, i1 } undef, i64 %scan_next, 0
-  %found1 = insertvalue { i64, i64, i1 } %found0, i64 %scan_remaining, 1
-  %found2 = insertvalue { i64, i64, i1 } %found1, i1 true, 2
-  ret { i64, i64, i1 } %found2
-not_found:
-  %miss0 = insertvalue { i64, i64, i1 } undef, i64 %cur, 0
-  %miss1 = insertvalue { i64, i64, i1 } %miss0, i64 %left, 1
-  %miss2 = insertvalue { i64, i64, i1 } %miss1, i1 false, 2
-  ret { i64, i64, i1 } %miss2
-}
-
+  %more = icmp ne i64 %scan_remaining, 0
+  %continue = and i1 %repeat_condition, %more
+  br i1 %continue, label %loop, label %done
+done:
 `)
-	}
+	fmt.Fprintf(b, "  %%done0 = insertvalue %s undef, i64 %%scan_next, 0\n", resultType)
+	fmt.Fprintf(b, "  %%done1 = insertvalue %s %%done0, i64 %%scan_remaining, 1\n", resultType)
+	fmt.Fprintf(b, "  %%done2 = insertvalue %s %%done1, %s %%value, 2\n", resultType, typ)
+	fmt.Fprintf(b, "  %%done3 = insertvalue %s %%done2, i1 true, 3\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%done3\n", resultType)
+	b.WriteString("empty_exit:\n")
+	fmt.Fprintf(b, "  %%empty0 = insertvalue %s undef, i64 %%cur, 0\n", resultType)
+	fmt.Fprintf(b, "  %%empty1 = insertvalue %s %%empty0, i64 %%left, 1\n", resultType)
+	fmt.Fprintf(b, "  %%empty2 = insertvalue %s %%empty1, %s 0, 2\n", resultType, typ)
+	fmt.Fprintf(b, "  %%empty3 = insertvalue %s %%empty2, i1 false, 3\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%empty3\n}\n\n", resultType)
 }
 
-func emit386MOVSHelper(b *strings.Builder, name, ty string, width int) {
-	fmt.Fprintf(b, "define internal void @%s(i64 %%dst, i64 %%src, i64 %%count, i1 %%backward) {\n", name)
+func emitX86CMPSHelper(b *strings.Builder, name, typ string, width int) {
+	resultType := fmt.Sprintf("{ i64, i64, i64, %s, %s, i1 }", typ, typ)
+	fmt.Fprintf(b, "define internal %s @%s(i64 %%src, i64 %%dst, i64 %%count, i1 %%backward, i1 %%while_equal) {\n", resultType, name)
 	b.WriteString(`entry:
   %step = select i1 %backward, i64 `)
 	fmt.Fprintf(b, "-%d, i64 %d\n", width, width)
 	b.WriteString(`  br label %loop
 loop:
-  %cur_dst = phi i64 [ %dst, %entry ], [ %next_dst, %body ]
-  %cur_src = phi i64 [ %src, %entry ], [ %next_src, %body ]
-  %left = phi i64 [ %count, %entry ], [ %remaining, %body ]
-  %done = icmp eq i64 %left, 0
-  br i1 %done, label %exit, label %body
-body:
-  %dst_ptr = inttoptr i64 %cur_dst to ptr
+  %cur_src = phi i64 [ %src, %entry ], [ %next_src, %scan ]
+  %cur_dst = phi i64 [ %dst, %entry ], [ %next_dst, %scan ]
+  %left = phi i64 [ %count, %entry ], [ %remaining, %scan ]
+  %empty = icmp eq i64 %left, 0
+  br i1 %empty, label %empty_exit, label %scan
+scan:
   %src_ptr = inttoptr i64 %cur_src to ptr
+  %dst_ptr = inttoptr i64 %cur_dst to ptr
 `)
-	fmt.Fprintf(b, "  %%value = load %s, ptr %%src_ptr, align 1\n", ty)
-	fmt.Fprintf(b, "  store %s %%value, ptr %%dst_ptr, align 1\n", ty)
-	b.WriteString(`  %next_dst = add i64 %cur_dst, %step
+	fmt.Fprintf(b, "  %%src_value = load volatile %s, ptr %%src_ptr, align 1\n", typ)
+	fmt.Fprintf(b, "  %%dst_value = load volatile %s, ptr %%dst_ptr, align 1\n", typ)
+	fmt.Fprintf(b, "  %%equal = icmp eq %s %%src_value, %%dst_value\n", typ)
+	b.WriteString(`  %not_equal = xor i1 %equal, true
+  %repeat_condition = select i1 %while_equal, i1 %equal, i1 %not_equal
   %next_src = add i64 %cur_src, %step
+  %next_dst = add i64 %cur_dst, %step
   %remaining = sub i64 %left, 1
-  br label %loop
-exit:
-  ret void
+  %more = icmp ne i64 %remaining, 0
+  %continue = and i1 %repeat_condition, %more
+  br i1 %continue, label %loop, label %done
+done:
+`)
+	fmt.Fprintf(b, "  %%done0 = insertvalue %s undef, i64 %%next_src, 0\n", resultType)
+	fmt.Fprintf(b, "  %%done1 = insertvalue %s %%done0, i64 %%next_dst, 1\n", resultType)
+	fmt.Fprintf(b, "  %%done2 = insertvalue %s %%done1, i64 %%remaining, 2\n", resultType)
+	fmt.Fprintf(b, "  %%done3 = insertvalue %s %%done2, %s %%src_value, 3\n", resultType, typ)
+	fmt.Fprintf(b, "  %%done4 = insertvalue %s %%done3, %s %%dst_value, 4\n", resultType, typ)
+	fmt.Fprintf(b, "  %%done5 = insertvalue %s %%done4, i1 true, 5\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%done5\n", resultType)
+	b.WriteString("empty_exit:\n")
+	fmt.Fprintf(b, "  %%empty0 = insertvalue %s undef, i64 %%cur_src, 0\n", resultType)
+	fmt.Fprintf(b, "  %%empty1 = insertvalue %s %%empty0, i64 %%cur_dst, 1\n", resultType)
+	fmt.Fprintf(b, "  %%empty2 = insertvalue %s %%empty1, i64 %%left, 2\n", resultType)
+	fmt.Fprintf(b, "  %%empty3 = insertvalue %s %%empty2, %s 0, 3\n", resultType, typ)
+	fmt.Fprintf(b, "  %%empty4 = insertvalue %s %%empty3, %s 0, 4\n", resultType, typ)
+	fmt.Fprintf(b, "  %%empty5 = insertvalue %s %%empty4, i1 false, 5\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%empty5\n}\n\n", resultType)
 }
 
+func emitX86LODSHelper(b *strings.Builder, name, typ string, width int) {
+	resultType := fmt.Sprintf("{ i64, i64, %s, i1 }", typ)
+	fmt.Fprintf(b, "define internal %s @%s(i64 %%src, i64 %%count, i1 %%backward) {\n", resultType, name)
+	b.WriteString(`entry:
+  %step = select i1 %backward, i64 `)
+	fmt.Fprintf(b, "-%d, i64 %d\n", width, width)
+	b.WriteString(`  br label %loop
+loop:
+  %cur = phi i64 [ %src, %entry ], [ %next, %load ]
+  %left = phi i64 [ %count, %entry ], [ %remaining, %load ]
+  %empty = icmp eq i64 %left, 0
+  br i1 %empty, label %empty_exit, label %load
+load:
+  %ptr = inttoptr i64 %cur to ptr
 `)
+	fmt.Fprintf(b, "  %%value = load volatile %s, ptr %%ptr, align 1\n", typ)
+	b.WriteString(`  %next = add i64 %cur, %step
+  %remaining = sub i64 %left, 1
+  %more = icmp ne i64 %remaining, 0
+  br i1 %more, label %loop, label %done
+done:
+`)
+	fmt.Fprintf(b, "  %%done0 = insertvalue %s undef, i64 %%next, 0\n", resultType)
+	fmt.Fprintf(b, "  %%done1 = insertvalue %s %%done0, i64 %%remaining, 1\n", resultType)
+	fmt.Fprintf(b, "  %%done2 = insertvalue %s %%done1, %s %%value, 2\n", resultType, typ)
+	fmt.Fprintf(b, "  %%done3 = insertvalue %s %%done2, i1 true, 3\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%done3\n", resultType)
+	b.WriteString("empty_exit:\n")
+	fmt.Fprintf(b, "  %%empty0 = insertvalue %s undef, i64 %%cur, 0\n", resultType)
+	fmt.Fprintf(b, "  %%empty1 = insertvalue %s %%empty0, i64 %%left, 1\n", resultType)
+	fmt.Fprintf(b, "  %%empty2 = insertvalue %s %%empty1, %s 0, 2\n", resultType, typ)
+	fmt.Fprintf(b, "  %%empty3 = insertvalue %s %%empty2, i1 false, 3\n", resultType)
+	fmt.Fprintf(b, "  ret %s %%empty3\n}\n\n", resultType)
 }
 
 func translateFuncAMD64(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, annotateSource bool) error {
 	return translateFuncX86(b, fn, sig, resolve, sigs, "amd64", "", X87Auto, annotateSource)
 }
 
-func translateFuncX86(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, goarch, targetTriple string, x87Mode X87Mode, annotateSource bool) error {
+// emitX86AddressSensitiveRawText emits an exact raw TEXT body as a naked
+// function. Naked inline assembly is intentionally limited to bodies selected
+// by preserveAddressSensitiveX86RawText: their byte addresses are observable,
+// so semantic IR lowering cannot preserve symbol+offset references. The
+// unreachable terminator adds no machine bytes on LLVM 22.
+func emitX86AddressSensitiveRawText(b *strings.Builder, fn Func, sig FuncSig) error {
+	if len(fn.X86RawText) == 0 {
+		return fmt.Errorf("empty address-sensitive raw TEXT body")
+	}
+	if len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0 {
+		return fmt.Errorf("%w: byte-exact naked TEXT cannot synthesize Go frame transport for %s", ErrProbeNeedsContext, fn.Sym)
+	}
+	fmt.Fprintf(b, "define %s %s(", sig.Ret, llvmGlobal(sig.Name))
+	for index, typ := range sig.Args {
+		if index != 0 {
+			b.WriteString(", ")
+		}
+		fmt.Fprintf(b, "%s %%arg%d", typ, index)
+	}
+	b.WriteString(") naked noinline")
+	if fn.X86RawAlign != 0 {
+		fmt.Fprintf(b, " align %d", fn.X86RawAlign)
+	}
+	if sig.Attrs != "" {
+		b.WriteString(" " + sig.Attrs)
+	}
+	b.WriteString(" {\nentry:\n")
+	var assembly strings.Builder
+	assembly.WriteString(".byte ")
+	for index, value := range fn.X86RawText {
+		if index != 0 {
+			assembly.WriteString(", ")
+		}
+		fmt.Fprintf(&assembly, "%d", value)
+	}
+	fmt.Fprintf(b, "  call void asm sideeffect %q, %q()\n", assembly.String(), "~{memory}")
+	b.WriteString("  unreachable\n}\n")
+	return nil
+}
+
+// A jump-only TEXT with multiple direct symbol targets is a relocation
+// anchor. Only its first jump is reachable, but Go emits every relocation;
+// generated ABI0 wrapper keepers use this object-level behavior. Preserve the
+// whole sequence in one naked inline-assembly body. Ordinary IR calls would
+// invent arguments and LLVM could discard the unreachable jumps.
+func amd64IsRelocationAnchor(fn Func, sig FuncSig) bool {
+	if sig.Ret != Void || len(sig.Args) != 0 ||
+		fn.FrameSize != 0 || fn.ArgSize != 0 || len(fn.Instrs) < 3 ||
+		fn.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	for _, ins := range fn.Instrs[1:] {
+		if ins.Op != OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym ||
+			!strings.HasSuffix(strings.TrimSpace(ins.Args[0].Sym), "(SB)") {
+			return false
+		}
+	}
+	return true
+}
+
+func emitX86RelocationAnchor(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig) error {
+	assembly := make([]string, 0, len(fn.Instrs)-1)
+	constraints := make([]string, 0, len(fn.Instrs))
+	args := make([]string, 0, len(fn.Instrs)-1)
+	for index, ins := range fn.Instrs[1:] {
+		target := strings.TrimSuffix(strings.TrimSpace(ins.Args[0].Sym), "(SB)")
+		resolved := resolve(target)
+		targetSig, ok := sigs[resolved]
+		if !ok {
+			return fmt.Errorf("relocation anchor target %q has no signature", resolved)
+		}
+		assembly = append(assembly, fmt.Sprintf("jmp ${%d:c}", index))
+		constraints = append(constraints, "X")
+		args = append(args, "ptr "+llvmGlobal(funcSigSymbol(resolved, targetSig)))
+	}
+	constraints = append(constraints, "~{memory}")
+	fmt.Fprintf(b, "define void %s() naked noinline {\nentry:\n", llvmGlobal(sig.Name))
+	fmt.Fprintf(b, "  call void asm sideeffect %q, %q(%s)\n",
+		strings.Join(assembly, "; "), strings.Join(constraints, ","), strings.Join(args, ", "))
+	b.WriteString("  unreachable\n}\n")
+	return nil
+}
+
+type x86FunctionSource struct {
+	goReadOnlyStorage *goReadOnlyStorage
+	scalarData        map[x86StaticSBAddress]int64
+	shiftLiterals     map[x86StaticSBAddress]x86ShiftLiteral
+	lockNamespace     string
+	bitScanNamespace  string
+	boolCalls         *x86ABI0BoolCallSource
+	declaration       FuncSig
+	inferredAttrs     string
+	fixedLocalResult  *x86FixedLocalResultSnapshot
+
+	staticAddressValues *x86StaticAddressValues
+}
+
+func translateFuncX86(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, goarch, targetTriple string, x87Mode X87Mode, annotateSource bool, sources ...x86FunctionSource) error {
 	fmt.Fprintf(b, "define %s %s(", sig.Ret, llvmGlobal(sig.Name))
 	for i, t := range sig.Args {
 		if i > 0 {
@@ -180,7 +534,31 @@ func translateFuncX86(b *strings.Builder, fn Func, sig FuncSig, resolve func(str
 	b.WriteString(" {\n")
 
 	c := newX86Ctx(b, fn, sig, resolve, sigs, goarch, targetTriple, annotateSource)
-	c.x87Mode = x87Mode
+	if len(sources) == 1 {
+		c.goReadOnlyStorage = sources[0].goReadOnlyStorage
+		c.fpSourceSig = sources[0].declaration
+		c.fpFeatureAttrs = sources[0].inferredAttrs
+		c.fixedLocalResult = sources[0].fixedLocalResult
+		c.lockScalarNS = sources[0].lockNamespace
+		c.bitScanNS = sources[0].bitScanNamespace
+		c.fpScalarData = sources[0].scalarData
+		c.fpShiftLiterals = sources[0].shiftLiterals
+		c.fpStaticAddressValues = sources[0].staticAddressValues
+		if calls := sources[0].boolCalls; calls != nil {
+			c.fpBoolCallSource = calls
+			if plan := calls.callers[fn.Sym]; plan != nil {
+				if !plan.bindLowering(fn, sources[0].declaration, sig, goarch) {
+					return x86ABI0BoolCallContext("lowering lost its original caller/source declaration")
+				}
+				c.fpScalarSource.x86BoolCalls = plan
+				c.fpScalarSource.x86ResultFlowBudget = &calls.budget
+			}
+		}
+	}
+	c.x87Mode = x87Mode // The proof must use the same mode as its paired emitter.
+	if err := c.validateScalarFPSourceViews(); err != nil {
+		return err
+	}
 	if err := c.emitEntryAllocas(); err != nil {
 		return err
 	}
@@ -193,6 +571,16 @@ func translateFuncX86(b *strings.Builder, fn Func, sig FuncSig, resolve func(str
 }
 
 func (c *amd64Ctx) lowerBlocks() error {
+	if err := c.verifyStringRepeatPrefixes(); err != nil {
+		return err
+	}
+	if err := c.verifyNamedLockPrefixes(); err != nil {
+		return err
+	}
+	reachable, err := c.fixedLocalBlockReachability()
+	if err != nil {
+		return err
+	}
 	emitBr := func(target string) {
 		fmt.Fprintf(c.b, "  br label %%%s\n", amd64LLVMBlockName(target))
 	}
@@ -206,6 +594,10 @@ func (c *amd64Ctx) lowerBlocks() error {
 		if bi != 0 {
 			fmt.Fprintf(c.b, "\n%s:\n", amd64LLVMBlockName(blk.name))
 		}
+		if reachable != nil && !reachable[bi] {
+			c.b.WriteString("  unreachable\n")
+			continue
+		}
 
 		terminated := false
 		for ii, ins := range blk.instrs {
@@ -225,7 +617,7 @@ func (c *amd64Ctx) lowerBlocks() error {
 		if c.repeatPrefix != "" && bi+1 == len(c.blocks) {
 			prefix := c.repeatPrefix
 			c.repeatPrefix = ""
-			return fmt.Errorf("386 %s prefix has no following string instruction", prefix)
+			return fmt.Errorf("%s %s prefix has no following string instruction", c.goarch, prefix)
 		}
 		// Fallthrough.
 		if bi+1 < len(c.blocks) {
@@ -238,33 +630,192 @@ func (c *amd64Ctx) lowerBlocks() error {
 }
 
 func (c *amd64Ctx) lowerInstr(bi int, ii int, ins Instr, emitBr amd64EmitBr, emitCondBr amd64EmitCondBr) (terminated bool, err error) {
+	c.namedAtomicLock = bi >= 0 && bi < len(c.blocks) && ii > 0 && ii <= len(c.blocks[bi].instrs) &&
+		strings.EqualFold(string(c.blocks[bi].instrs[ii-1].Op), "LOCK")
+	defer func() { c.namedAtomicLock = false }()
+	if ins.x86UnboundAddressOverride {
+		return false, fmt.Errorf("%w: %s physical address-size %d memory override has no bound ordinary consumer: %q", ErrProbeNeedsContext, c.goarch, ins.x86AddressBits, ins.Raw)
+	}
+	// Arithmetic uses the ordinary scalar emitters, but its bound global
+	// source remains an observable exact-width read even for a dead result.
+	// Scope the role to this original instruction, never the next/raw read.
+	c.goReadOnlyOperand = c.goReadOnlyStorage.readFor(ins, c.goarch)
+	defer func() { c.goReadOnlyOperand = nil }()
+	if c.goReadOnlyOperand != nil {
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return false, err
+		}
+	}
+	if known, err := c.lowerNativeMMXRegionAt(bi, ii, ins); known {
+		return false, err
+	}
+	if err := x86LegacyMMXReadEmitterContext(ins, c.goarch); err != nil {
+		return false, err
+	}
+	if recognized, err := c.lowerNumericalReadAt(ins, bi, ii); recognized {
+		return false, err
+	}
+	if c.fixedLocal != nil {
+		c.fixedMemRoles = make(map[MemRef]MemRef)
+		defer func() { c.fixedMemRoles = nil }()
+		addressView := ins
+		if view, known, err := x86NamedFrameMoveAddressInstruction(ins, c.goarch); known {
+			if err != nil {
+				return false, err
+			}
+			addressView = view
+		}
+		for index, operand := range addressView.Args {
+			if operand.Kind != OpMem {
+				continue
+			}
+			access, certified := c.fixedLocalMemoryAccess(ins, index)
+			if !certified && x86LEAWidth(addressView.Op, c.goarch) == 0 {
+				if !fixedLocalGPAddressOnly(addressView, index) {
+					return false, goAMD64FrameContext("fixed local storage consumer lacks an exact native access certificate")
+				}
+				continue // Sized NOP does not consume an effective address.
+			}
+			if !certified || !access.nativeInput {
+				// Address formation consumes the same original NAME_AUTO bias
+				// as an access, without receiving any DATA-read certificate.
+				physical, err := fixedLocalMemoryAddress(ins, index, c.fixedLocal.frame)
+				if err != nil {
+					return false, err
+				}
+				if !certified {
+					// The original source/frame owner resolves NAME_AUTO. The
+					// numerical grammar must not guess a bare symbolic offset.
+					query := addressView
+					query.Args = append([]Operand(nil), addressView.Args...)
+					query.Args[index].Mem = physical
+					if !fixedLocalGPAddressOnly(query, index) {
+						return false, goAMD64FrameContext("fixed local address lacks its complete typed effect")
+					}
+				}
+				if previous, found := c.fixedMemRoles[operand.Mem]; found && previous != physical {
+					return false, goAMD64FrameContext("fixed local equal parsed operands have conflicting native address roles")
+				}
+				c.fixedMemRoles[operand.Mem] = physical
+			}
+		}
+	}
+	if c.sourceStack != nil && len(ins.x86SourceStackFP) != 0 {
+		ins.Args = append([]Operand(nil), ins.Args...)
+		for index, offset := range ins.x86SourceStackFP {
+			ins.Args[index] = Operand{Kind: OpFP, FPOffset: offset}
+		}
+	}
 	c.allowSPWrite = models386SPWrite(ins)
 	defer func() { c.allowSPWrite = false }()
+	// Go's assembler uses the explicit FP displacement, not the descriptive
+	// name, for machine addressing. Never repair a stale displacement by name:
+	// that would silently change source behavior and hide padding accesses.
 	op := strings.ToUpper(string(ins.Op))
-	c.zeroUpperVector = strings.HasPrefix(op, "V")
-	if c.repeatPrefix != "" && op != "MOVSB" && op != "MOVSL" && op != "STOSL" && op != "SCASB" {
+	_, _, _, regularString := x86StringProperties(Op(op))
+	_, _, portString := x86PortStringProperties(Op(op))
+	if c.repeatPrefix != "" && !regularString && !portString {
 		prefix := c.repeatPrefix
 		c.repeatPrefix = ""
-		return false, fmt.Errorf("386 %s prefix is unsupported for %s", prefix, op)
+		return false, fmt.Errorf("%s %s prefix is unsupported for %s", c.goarch, prefix, op)
 	}
 	if strings.HasPrefix(op, "GET_TLS(") {
 		// Macro-expanded helper from go_tls.h. Keep current simplified model.
 		return false, nil
 	}
+	if _, known, err := x86DirectiveProperties(ins); known {
+		// Native layout and frame permissions are checked independently before
+		// emission. Ordinary semantic IR does not preserve machine PCs or GC
+		// metadata, but the directives do not change its numerical state.
+		return false, err
+	}
 	switch Op(op) {
-	case OpTEXT, OpBYTE, OpWORD:
+	case "LOCK":
+		return false, c.namedLockPrefixBinding(bi, ii, ins)
+	case OpTEXT:
 		return false, nil
+	case OpBYTE, OpWORD, "LONG", "QUAD":
+		return false, fmt.Errorf("%s %s cannot be lowered safely as opaque machine code: %q", c.goarch, op, ins.Raw)
 	case OpRET:
+		if c.directTail.privateCallTransition(bi) {
+			if ii != 0 || len(ins.Args) != 0 || c.directTail.instructions[bi].Op != OpRET {
+				return true, x86DirectTailContext("private RET lost its original source point")
+			}
+			if err := c.lowerPrivateFrameTransition(bi); err != nil {
+				return true, err
+			}
+			emitBr(c.blocks[c.directTail.edges[bi][0]].name)
+			return true, nil
+		}
 		if len(ins.Args) == 1 && ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
 			return true, c.tailCallAndRet(ins.Args[0])
 		}
 		if len(ins.Args) > 1 {
 			return true, fmt.Errorf("amd64 RET expects at most 1 operand: %q", ins.Raw)
 		}
+		if len(ins.Args) == 1 && ins.Args[0].Kind == OpReg && isX86YrlRegisterForArch(ins.Args[0].Reg, c.goarch) {
+			// Go preprocesses RET Rn into its frame epilogue followed by JMP
+			// Rn. It is not an ordinary return or a guessed generic C call.
+			return true, fmt.Errorf("%w: %s register RET needs a native tail-target ABI and frame contract: %q", ErrProbeNeedsContext, c.goarch, ins.Raw)
+		}
+		if len(ins.Args) != 0 {
+			return true, fmt.Errorf("%s RET accepts only no operand, a GP register or a symbol tail target: %q", c.goarch, ins.Raw)
+		}
 		return true, c.lowerRET()
-	case "PCALIGN", "NO_LOCAL_POINTERS", "PCDATA", "FUNCDATA", "NOP",
+	case "NOPW", "NOPL":
+		_, err := x86SizedNOPProperties(ins, c.goarch)
+		return false, err
+	case "NO_LOCAL_POINTERS", "NOP",
 		"PUSH_REGS_HOST_TO_ABI0()", "POP_REGS_HOST_TO_ABI0()":
-		// Alignment directive emitted by stdlib asm; no semantic effect in our IR.
+		// Existing macro handling is separate from the directive grammar.
+		return false, nil
+	case "LAHF", "SAHF":
+		spec, _, err := x86AHFlagsProperties(Op(op), ins, c.goarch)
+		if err != nil {
+			return false, err
+		}
+		if spec.toAH {
+			packed := c.packX86Flags()
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", value, packed)
+			return false, c.storeRegSized(AH, I8, "%"+value)
+		}
+		value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: AH}, I8)
+		if err != nil {
+			return false, err
+		}
+		flagBit := func(bit uint) string {
+			shifted := value
+			if bit != 0 {
+				tmp := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = lshr i8 %s, %d\n", tmp, value, bit)
+				shifted = "%" + tmp
+			}
+			result := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i8 %s to i1\n", result, shifted)
+			return "%" + result
+		}
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", flagBit(0), c.flagsCFSlot)
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", flagBit(2), c.flagsPFSlot)
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", flagBit(4), c.flagsAFSlot)
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", flagBit(6), c.flagsZSlot)
+		// flagsSltSlot represents SF, not the signed condition SF XOR OF.
+		// SAHF changes SF directly and leaves OF untouched.
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", flagBit(7), c.flagsSltSlot)
+		return false, nil
+	case "CLC", "STC", "CMC":
+		form, _, err := x86CarryControlProperties(Op(op), ins, c.goarch)
+		if err != nil {
+			return false, err
+		}
+		if form.complement {
+			oldCarry := c.loadFlag(c.flagsCFSlot)
+			newCarry := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", newCarry, oldCarry)
+			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", newCarry, c.flagsCFSlot)
+		} else {
+			fmt.Fprintf(c.b, "  store i1 %t, ptr %s\n", form.set, c.flagsCFSlot)
+		}
 		return false, nil
 	case "ADJSP":
 		if c.goarch != "386" {
@@ -280,43 +831,264 @@ func (c *amd64Ctx) lowerInstr(bi int, ii int, ins Instr, emitBr amd64EmitBr, emi
 		next := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %d\n", next, sp, int64(ins.Args[0].Imm))
 		return false, c.storeRegUnchecked(SP, "%"+next)
-	case "CLD":
-		if c.goarch != "386" {
-			return false, nil
-		}
-		if len(ins.Args) != 0 {
-			return false, fmt.Errorf("386 CLD takes no operands: %q", ins.Raw)
-		}
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.directionSlot)
-		return false, nil
-	case "STD":
-		if c.goarch != "386" {
-			return false, nil
-		}
-		if len(ins.Args) != 0 {
-			return false, fmt.Errorf("386 STD takes no operands: %q", ins.Raw)
-		}
-		fmt.Fprintf(c.b, "  store i1 true, ptr %s\n", c.directionSlot)
-		return false, nil
+	case "CLD", "STD":
+		_, err := c.lowerDirectionControl(ins)
+		return false, err
 	case "REP", "REPN":
-		if c.goarch != "386" {
-			return false, nil
-		}
 		if len(ins.Args) != 0 {
-			return false, fmt.Errorf("386 %s takes no operands: %q", op, ins.Raw)
+			return false, fmt.Errorf("%s %s takes no operands: %q", c.goarch, op, ins.Raw)
 		}
 		c.repeatPrefix = op
 		return false, nil
 	}
+	// The complete bound LOCK grammar owns dispatch before overlapping
+	// arithmetic and bit-test handlers. Emitting an unused native helper does
+	// not preserve the source instruction's atomic read/modify/write effect.
+	if ok, term, err := c.lowerLockScalarRMW(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerScalarMemoryRMW(Op(op), ins); ok {
+		return term, err
+	}
+	// Scalar ADD/SUB spellings overlap with vector and generic arithmetic
+	// lowerers. Validate the complete Go assembler operand table before those
+	// broader handlers get a chance to accept an illegal form.
+	if ok, term, err := c.lowerScalarAddSub(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerRTM(bi, ii, Op(op), ins, emitCondBr); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerFarReturn(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerLeave(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerXLAT(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerBranch(bi, ii, Op(op), ins, emitBr, emitCondBr); ok {
 		return term, err
 	}
+	// Segment-register MOVW shares scalar MOV spellings with broad vector and
+	// generic move handlers, so validate its narrow ymovtab forms first.
+	if ok, term, err := c.lowerSegmentRegisterMove(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerCmpBt(Op(op), ins); ok {
 		return term, err
 	}
 	if ok, term, err := c.lowerX87(Op(op), ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerDuplicateMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedLowMultiply(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedPhysical(Op(op), ins, ""); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedDotProduct(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedIntegerMinMax(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerHorizontalInteger(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedUnsignedWordMinimumPosition(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerImplicitMaskMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedLogicalShift(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPerLaneVariableShift(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedArithmeticRightShift(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedFloatShuffle(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerShuffle128BitBlocks(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerImmediatePackedBlend(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVariableBlend(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerMaskBlend(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedUnpack(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerQwordPermute(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerInLaneFloatingPermute(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerIndexedPermute(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerLegacyMMXMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerNonTemporalVectorMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerUnalignedVectorLoad(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedVectorMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerInsertExtractFamily(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerInsertPackedSingle(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedByteShuffle(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerScatter(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerAlternatingFloatingAddSubtract(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedNumericConversion(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerSameWidthPackedConversion(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedHalfConversion(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerBF16Convert(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedDoubleDword(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedAbsSign(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVectorScalarIntegerMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerScalarIntegerToFloat(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerLegacyIntegerToFloat(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedExtendMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerParallelBitDepositExtract(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerMXCSR(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedFloatToDword(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedSingleToDouble(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedDoubleToSingle(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedScalarExtract(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedMoveMask(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerMoveHighLowPackedSingle(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVectorLaneExtract(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedSumAbsoluteDifferences(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedFloatingDot(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedIntegerAdd(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedIntegerSubtract(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedScalarBroadcast(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerMaskRegisterBroadcast(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedBlockBroadcast(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedFloatingLogical(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerFMA3(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerEVEXPackedLogical(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedAndNot(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedIntegerCompare(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerImmediatePackedCompare(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedTestMask(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerFloatingCompare(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerPackedSaturatingNarrow(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVariableDwordPermute(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerConditionalSet(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVectorScalarMove(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerVectorScalarFlagCompare(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerConditionalMove(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerFP(Op(op), ins); ok {
 		return term, err
 	}
@@ -326,18 +1098,69 @@ func (c *amd64Ctx) lowerInstr(bi int, ii int, ins Instr, emitBr amd64EmitBr, emi
 	if ok, term, err := c.lowerVec(Op(op), ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerCompareExchange(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerBound(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerAtomic(Op(op), ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerMSRAccess(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerImplicitSystem(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerDescriptorTable(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerSegmentBase(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerXState(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerSystemAddress(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerCacheLineWriteback(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerFixedSystem(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerSystemTransfer(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerEnqueue(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerX86SystemManagement(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerSyscall(Op(op), ins); ok {
 		return term, err
 	}
-	if ok, term, err := c.lowerString(Op(op), ins); ok {
+	if ok, term, err := c.lowerPortIO(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerString(ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerMachineRegisterMove(Op(op), ins); ok {
 		return term, err
 	}
 	if ok, term, err := c.lowerMov(Op(op), ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerScalarShiftRotate(Op(op), ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerScalarIncDec(Op(op), ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerArith(Op(op), ins); ok {
 		return term, err
 	}
@@ -418,9 +1241,7 @@ func (c *amd64Ctx) lowerRetZero() {
 	switch c.sig.Ret {
 	case Void:
 		c.b.WriteString("  ret void\n")
-	case I32:
-		c.b.WriteString("  ret i32 0\n")
 	default:
-		fmt.Fprintf(c.b, "  ret %s 0\n", c.sig.Ret)
+		fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, llvmZeroValue(c.sig.Ret))
 	}
 }
diff --git a/amd64_unaligned_load_forms.go b/amd64_unaligned_load_forms.go
new file mode 100644
index 000000000..fb883773c
--- /dev/null
+++ b/amd64_unaligned_load_forms.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86UnalignedLoadForm struct {
+	byteWidth int
+	spec      amd64UnalignedLoadSpec
+}
+
+func x86UnalignedLoadProperties(op Op, ins Instr, arch string) (x86UnalignedLoadForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64UnalignedLoadSpecs[Op(name)]
+	form := x86UnalignedLoadForm{spec: spec}
+	if !known {
+		return form, false, nil
+	}
+	if arch == "" {
+		arch = "amd64"
+	}
+	fail := func() (x86UnalignedLoadForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s outside complete Go unaligned-load grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 2 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) ||
+		!isAMD64MemoryOperand(ins.Args[0]) || ins.Args[1].Kind != OpReg {
+		return fail()
+	}
+	form.byteWidth = amd64VectorByteWidth(ins.Args[1].Reg)
+	index, vector := amd64VectorRegisterIndex(ins.Args[1].Reg, form.byteWidth)
+	if !vector || form.byteWidth != 16 && form.byteWidth != 32 || form.byteWidth > spec.maxBytes ||
+		index >= 16 || !spec.vector && arch == "386" && index >= 8 {
+		return fail()
+	}
+	if err := x86Mode32VectorRegisterContext(ins, arch); err != nil {
+		return form, true, err
+	}
+	local, contextual := ins, false
+	if spec.vector {
+		local, contextual = x86VectorValueMemoryInput(ins, arch)
+	}
+	if !x86PackedShiftMemoryValid(local.Args[0], arch) {
+		return fail()
+	}
+	if err := x86NamedMultiplyMemoryError(ins.Args[0], arch); err != nil {
+		return form, true, err
+	}
+	if contextual {
+		return form, true, x86VectorValueMemoryContext(ins)
+	}
+	if ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+		return form, true, fmt.Errorf("%w: LDDQU needs its original native address mode", ErrProbeNeedsContext)
+	}
+	return form, true, nil
+}
+
+func x86TypedUnalignedLoadByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86UnalignedLoadProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.byteWidth)
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: ins.Args[0], width: width, read: true},
+		{index: 1, operand: ins.Args[1], width: width, write: true},
+	}}, true, nil
+}
+
+func x86RawUnalignedLoadSource(ins Instr, arch string) bool {
+	_, known, err := x86UnalignedLoadProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// The original opcode can perform implementation-dependent wider/repeated
+// native reads and optional #AC. Logical FP bytes are not that backing.
+func x86ResultUnalignedLoadStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86UnalignedLoadProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !native || !x86ResultNamedPredicateInstruction(ins) && !x86RawUnalignedLoadSource(ins, arch) || ins.Args[0].Kind == OpFP {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	if !x86ResultReadWithNativeContinuation(local, ins.Args[0], int64(form.byteWidth), state, owned, arch, true) {
+		return false, true
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[1].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, x86CallerVectorByteMask(int64(form.byteWidth)), !form.spec.vector)
+	return true, true
+}
diff --git a/amd64_undefined_trap_consumers_test.go b/amd64_undefined_trap_consumers_test.go
new file mode 100644
index 000000000..7a0b0f3f5
--- /dev/null
+++ b/amd64_undefined_trap_consumers_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86UndefinedTrapCompleteTypedDispatchBoundaries(t *testing.T) {
+	if len(x86UndefinedTrapSpecs) != 1 {
+		t.Fatal("UNDEF and physical UD2 must share one canonical grammar")
+	}
+	spec := x86UndefinedTrapSpecs["UNDEF"]
+	if spec.native != "ud2" || !bytes.Equal(spec.opBytes, []byte{0x0f, 0x0b}) {
+		t.Fatal("undefined-instruction specification changed the architectural exception")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"UNDEF", "UD2", "undef", "ud2"} {
+			for _, identity := range []Op{"", op, Op(strings.ToUpper(string(op))), "MOVQ", Op(string(op) + ".BAD")} {
+				t.Run(arch+"/"+string(op)+"/identity="+string(identity), func(t *testing.T) {
+					instruction := Instr{Op: identity, Raw: string(op)}
+					before := fmt.Sprintf("%#v", instruction)
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					ir, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerX86UndefinedTrap(op, instruction)
+					invalid := identity != "" && !strings.EqualFold(string(identity), string(op))
+					if !known || terminated == invalid || (err != nil) != invalid ||
+						invalid && (ir != output.String() || temporary != ctx.tmp) ||
+						before != fmt.Sprintf("%#v", instruction) {
+						t.Fatal("undefined-instruction dispatch mutated input or emitted before rejection", err)
+					}
+				})
+			}
+			for _, suffix := range []string{".Z", ".SAE", ".BCST"} {
+				instruction := Instr{Op: op, Raw: string(op) + suffix}
+				if _, known, err := x86UndefinedTrapProperties(Op(string(op)+suffix), instruction, arch); !known || err == nil {
+					t.Fatal("undefined-instruction grammar admitted an operand modifier", op, suffix)
+				}
+			}
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+		ctx.goarch = arch
+		before, temporary := output.String(), ctx.tmp
+		if known, terminated, err := ctx.lowerX86UndefinedTrap("UD2", Instr{Op: "UD2"}); !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+			t.Fatal("x86 undefined-instruction grammar admitted another architecture", arch, err)
+		}
+	}
+	if _, known, err := x86UndefinedTrapProperties("INT", Instr{}, "amd64"); known || err != nil {
+		t.Fatal("debug/software traps must not acquire the undefined-instruction grammar")
+	}
+}
+
+func x86UndefinedTrapFixture(raw bool) string {
+	op := "UNDEF\n"
+	if raw {
+		op = "BYTE $0x0f\nBYTE $0x0b\n"
+	}
+	return "TEXT ·fault(SB),4,$0-0\n" + op + "RET\n"
+}
+
+// Every API derives its signature from the same actual Go declaration, rather
+// than using a manually supplied signature as its own correctness oracle.
+func x86UndefinedTrapIR(t *testing.T, source, arch, triple, api string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "undefinedtrap", "package undefinedtrap\nfunc fault()\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: arch, TargetTriple: triple, ResolveSym: resolve,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+		}
+		if err != nil || translated == nil || translated.Module.IsNil() {
+			t.Fatalf("Go module undefined-instruction consumer: %v", err)
+		}
+		return translated.Module.String()
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: signatures}
+	if api == "text" {
+		ir, err := Translate(file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return ir
+	}
+	if api != "module" {
+		t.Fatal("unknown undefined-instruction consumer", api)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil || module.IsNil() {
+		t.Fatalf("LLVM module undefined-instruction consumer: %v", err)
+	}
+	return module.String()
+}
+
+func x86UndefinedTrapOptimizedIR(t *testing.T, ir string) string {
+	t.Helper()
+	opt := findLLVM22Tool("opt")
+	if opt == "" {
+		t.Fatal("LLVM 22 opt required")
+	}
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "input.ll"), filepath.Join(dir, "optimized.ll")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(opt, "-S", "-passes=default<O2>", "-verify-each", input, "-o", output))
+	contents, err := os.ReadFile(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return string(contents)
+}
+
+func TestX86UndefinedTrapNamedRawThreeAPIsFiveTargetsRetainFaultObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM 22 llc and llvm-objdump required")
+	}
+	physical := regexp.MustCompile(`(?m)\bud2\b`)
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		for _, raw := range []bool{false, true} {
+			source := x86UndefinedTrapFixture(raw)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", target.triple, raw, api), func(t *testing.T) {
+					ir := x86UndefinedTrapIR(t, source, target.arch, target.triple, api)
+					if strings.Count(ir, `asm sideeffect "ud2"`) != 1 || !strings.Contains(ir, "unreachable") {
+						t.Fatal("consumer lost the exact non-returning architectural fault")
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							optimized := ir
+							if level == "-O2" {
+								optimized = x86UndefinedTrapOptimizedIR(t, ir)
+							}
+							dir := t.TempDir()
+							input, object := filepath.Join(dir, "undefined.ll"), filepath.Join(dir, "undefined.o")
+							if err := os.WriteFile(input, []byte(optimized), 0600); err != nil {
+								t.Fatal(err)
+							}
+							x86FloatCompareCaptureCommand(t, exec.Command(llc, level,
+								"-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+							decoded := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "-d", "--no-show-raw-insn", object))
+							// LLVM 22's Darwin backend also traps the unreachable
+							// terminator, after the explicit UD2. That unreachable
+							// second UD2 does not change the observed exception.
+							expected := 1
+							if strings.Contains(target.triple, "darwin") {
+								expected = 2
+							}
+							if len(physical.FindAll(decoded, -1)) != expected || strings.Contains(string(decoded), "int3") {
+								t.Fatalf("actual object changed/discarded the undefined instruction:\n%s", decoded)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+const x86UndefinedTrapOriginalDriver = `package main
+
+import (
+    "os"
+    "syscall"
+)
+
+func main() {
+    if err := syscall.Setrlimit(syscall.RLIMIT_CORE, &syscall.Rlimit{}); err != nil {
+        panic(err)
+    }
+    fault()
+    os.Exit(91)
+}
+`
+
+func x86UndefinedTrapBuildOriginal(t *testing.T, goos, arch string, raw bool) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module undefinedtrap\n\ngo 1.20\n", "main.go": x86UndefinedTrapOriginalDriver,
+		"decl.go": "package main\nfunc fault()\n", "fault_" + arch + ".s": x86UndefinedTrapFixture(raw),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch, "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	return executable
+}
+
+func TestX86UndefinedTrap386OriginalNativeReferencesCompile(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			executable := x86UndefinedTrapBuildOriginal(t, "linux", "386", raw)
+			sealed, err := x87IA32StaticExecutable(executable)
+			if err != nil || sealed.verify() != nil {
+				t.Fatalf("original IA32 undefined-instruction executable is not stable ELF32: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86UndefinedTrapTypedPropertiesDoNotMutateCanonicalMetadata(t *testing.T) {
+	before := x86UndefinedTrapSpecs["UNDEF"]
+	before.opBytes = append([]byte(nil), before.opBytes...)
+	for _, op := range []Op{"UNDEF", "UD2"} {
+		got, known, err := x86UndefinedTrapProperties(op, Instr{Op: op}, "amd64")
+		if !known || err != nil || !reflect.DeepEqual(before, got) {
+			t.Fatal("canonical and physical consumers disagree", op, got, err)
+		}
+	}
+}
diff --git a/amd64_undefined_trap_family_test.go b/amd64_undefined_trap_family_test.go
new file mode 100644
index 000000000..5898b1d8e
--- /dev/null
+++ b/amd64_undefined_trap_family_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86UndefinedTrapRetainsCompleteOfficialFaultEncoding(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "{obj.AUNDEF, ynone, Px, opBytes{0x0f, 0x0b}}") ||
+		!strings.Contains(string(table), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete Go undefined-instruction row changed")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source := "TEXT fault(SB),4,$0-0\nUNDEF\nRET\n"
+			actual := assembleX87ControlBytes(t, arch, source)
+			if !bytes.Equal(actual, []byte{0x0f, 0x0b, 0xc3}) {
+				t.Fatalf("actual original Go undefined-instruction identity: %x", actual)
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			ctx.goarch = arch
+			before := output.Len()
+			known, terminated, err := ctx.lowerArith("UNDEF", file.Funcs[0].Instrs[1])
+			ir := output.String()[before:]
+			if !known || !terminated || err != nil ||
+				!strings.Contains(ir, "asm sideeffect \"ud2\"") || !strings.Contains(ir, "unreachable") {
+				t.Fatalf("native undefined fault was changed or discarded: %t/%t/%v\n%s", known, terminated, err, ir)
+			}
+		})
+	}
+}
+
+func TestX86UndefinedTrapMalformedOperandsRejectBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, operands := range []string{"AX", "(AX)", "$1", "AX,DX"} {
+			t.Run(arch+"/"+operands, func(t *testing.T) {
+				source := "TEXT fault(SB),4,$0-0\nUNDEF " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before, temporary := output.String(), ctx.tmp
+				known, terminated, err := ctx.lowerArith("UNDEF", file.Funcs[0].Instrs[1])
+				if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+					t.Fatalf("invalid undefined-instruction form emitted IR: %t/%t/%v", known, terminated, err)
+				}
+			})
+		}
+	}
+}
diff --git a/amd64_undefined_trap_forms.go b/amd64_undefined_trap_forms.go
new file mode 100644
index 000000000..510ac9b8e
--- /dev/null
+++ b/amd64_undefined_trap_forms.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86UndefinedTrapSpec struct {
+	native  string
+	opBytes []byte // Complete canonical Go ynone/Px row.
+}
+
+// UNDEF is Go's canonical spelling; UD2 is the physical decoder/internal
+// spelling of the same opcode. Neither spelling is a returning debug trap.
+var x86UndefinedTrapSpecs = map[Op]x86UndefinedTrapSpec{
+	"UNDEF": {native: "ud2", opBytes: []byte{0x0f, 0x0b}},
+}
+
+func x86UndefinedTrapProperties(op Op, ins Instr, arch string) (x86UndefinedTrapSpec, bool, error) {
+	name, _, suffix := strings.Cut(strings.ToUpper(string(op)), ".")
+	canonical := name
+	if name == "UD2" {
+		canonical = "UNDEF"
+	}
+	spec, known := x86UndefinedTrapSpecs[Op(canonical)]
+	if !known {
+		local := ins
+		if local.Op == "" {
+			local.Op = op
+		}
+		if strings.EqualFold(string(local.Op), string(op)) {
+			if form, transfer, err := x86InsertExtractProperties(local, arch); transfer && err == nil && form.undefinedOpcode() {
+				return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+			}
+			if form, move, err := amd64PackedVectorMoveProperties(local, arch); move && err == nil && form.undefinedOpcode() {
+				return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+			}
+			if form, compact, err := x86PackedCompactProperties(op, local, arch); compact && err == nil && form.undefinedOpcode() {
+				return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+			}
+		}
+		if form, narrow, err := x86SingleSourceNarrowProperties(op, ins, arch); narrow && err == nil && form.undefinedOpcode() {
+			return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+		}
+		if form, half, err := x86NamedHalfProperties(op, ins, arch); half && err == nil && form.undefinedOpcode() {
+			return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+		}
+		if form, nonTemporal, err := x86MOVNTIProperties(op, ins, arch); nonTemporal && err == nil && form.trap {
+			return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+		}
+		if form, nonTemporal, err := x86NonTemporalVectorProperties(op, ins, arch); nonTemporal && err == nil && form.trap {
+			// Go's Yml register row encodes a reserved ModRM form. Preserve
+			// its terminal #UD, not fictitious source/GP or memory effects.
+			return x86UndefinedTrapSpec{native: "ud2"}, true, nil
+		}
+		return x86UndefinedTrapSpec{}, false, nil
+	}
+	if suffix || len(ins.Args) != 0 || arch != "386" && arch != "amd64" ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return spec, true, fmt.Errorf("%s %s requires an exact zero-operand undefined-instruction form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func (c *amd64Ctx) lowerX86UndefinedTrap(op Op, ins Instr) (bool, bool, error) {
+	spec, known, err := x86UndefinedTrapProperties(op, ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	// Use the exact architectural fault instruction, not merely unreachable
+	// or a target-dependent generic trap that may select a different signal.
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", spec.native, "~{memory}")
+	c.b.WriteString("  unreachable\n")
+	return true, true, nil
+}
diff --git a/amd64_undefined_trap_linux_amd64_test.go b/amd64_undefined_trap_linux_amd64_test.go
new file mode 100644
index 000000000..ef0971e21
--- /dev/null
+++ b/amd64_undefined_trap_linux_amd64_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// Required Linux counterpart: real IA32 instructions, a sealed static ELF32
+// executable, no emulator or host-inapplicable skip.
+func TestCrossLinuxRuntimeMatrixX86UndefinedTrapNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required LLVM 22 llc/native IA32 compiler: %v", err)
+	}
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			original := x86UndefinedTrapBuildOriginal(t, "linux", "386", raw)
+			sealed, err := x87IA32StaticExecutable(original)
+			if err != nil || sealed.verify() != nil {
+				t.Fatalf("unsealed original IA32 undefined-instruction executable: %v", err)
+			}
+			output, err := x87IA32Capture(t, sealed.path, nil, "", append(os.Environ(), "GOTRACEBACK=system"))
+			if guard := sealed.verify(); guard != nil {
+				t.Fatal(guard)
+			}
+			x86UndefinedTrapRequireOriginalSignal(t, output, err)
+			ir := x86UndefinedTrapIR(t, x86UndefinedTrapFixture(raw), "386", "i386-unknown-linux-gnu", "Go")
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					optimized := ir
+					if level == "-O2" {
+						optimized = x86UndefinedTrapOptimizedIR(t, ir)
+					}
+					dir := t.TempDir()
+					input, object := filepath.Join(dir, "undefined.ll"), filepath.Join(dir, "undefined.o")
+					main, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "undefined")
+					for name, contents := range map[string]string{input: optimized, main: x86UndefinedTrapIndependentC} {
+						if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=i386-unknown-linux-gnu",
+						"-filetype=obj", input, "-o", object))
+					x86FloatCompareCaptureCommand(t, exec.Command(compiler, "-static", "-no-pie", object, main, "-O2", "-o", executable))
+					sealed, err := x87IA32StaticExecutable(executable)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if output := x87IA32RunDirect(t, sealed, nil, os.Environ()); string(output) != "undefined-instruction SIGILL verified\n" {
+						t.Fatalf("native IA32 LLVM fault identity: %q", output)
+					}
+				})
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/amd64_undefined_trap_runtime_unix_test.go b/amd64_undefined_trap_runtime_unix_test.go
new file mode 100644
index 000000000..d2eb7591c
--- /dev/null
+++ b/amd64_undefined_trap_runtime_unix_test.go
@@ -0,0 +1,137 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86UndefinedTrapRequireOriginalSignal(t *testing.T, output []byte, err error) {
+	t.Helper()
+	if !x86UndefinedTrapOriginalSignal(output, err) {
+		t.Fatalf("unchanged Go object did not raise the actual undefined-instruction fault: %v\n%s", err, output)
+	}
+}
+
+func x86UndefinedTrapOriginalSignal(output []byte, err error) bool {
+	// Like the Go-assembler oracle, accept only a directly completed process
+	// outcome. errors.As would hide cleanup, pipe or context failures joined
+	// to the otherwise expected exit status.
+	exit, completed := err.(*exec.ExitError)
+	return completed && exit.ProcessState != nil && exit.ProcessState.Exited() &&
+		exit.ExitCode() == 2 && strings.Contains(string(output), "SIGILL: illegal instruction") &&
+		strings.Contains(string(output), "main.fault")
+}
+
+func TestX86UndefinedTrapExitStatusFixture(t *testing.T) {
+	if os.Getenv("PLAN9ASM_UNDEFINED_EXIT_FIXTURE") == "1" {
+		os.Exit(2)
+	}
+}
+
+func TestX86UndefinedTrapExpectedFaultRejectsUnknownLifecycle(t *testing.T) {
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestX86UndefinedTrapExitStatusFixture$")
+	command.Env = append(os.Environ(), "PLAN9ASM_UNDEFINED_EXIT_FIXTURE=1")
+	_, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	// This parser control obtains a real exit status, but its diagnostic is
+	// deliberately synthetic. It is not an original-Go signal observation.
+	output := []byte("SIGILL: illegal instruction\nmain.fault\n")
+	if !x86UndefinedTrapOriginalSignal(output, err) {
+		t.Fatalf("actual completed exit-2 parser control failed: %v", err)
+	}
+	for _, test := range []struct {
+		name   string
+		err    error
+		output []byte
+	}{
+		{"cleanup", errors.Join(err, errors.New("unknown descendant cleanup")), output},
+		{"deadline", errors.Join(err, context.DeadlineExceeded), output},
+		{"cancellation", errors.Join(err, context.Canceled), output},
+		{"wrapped outcome", fmt.Errorf("unknown wrapper: %w", err), output},
+		{"uncompleted exit", &exec.ExitError{}, output},
+		{"wrong signal", err, []byte("SIGTRAP: trace trap\nmain.fault\n")},
+		{"wrong function", err, []byte("SIGILL: illegal instruction\nmain.other\n")},
+		{"unknown exit", errors.New("unbound process failure"), output},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if x86UndefinedTrapOriginalSignal(test.output, test.err) {
+				t.Fatal("expected-fault parser erased an unknown lifecycle or diagnostic")
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86UndefinedTrapOriginalAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			goos := runtime.GOOS
+			if strings.Contains(execution.triple, "linux") {
+				goos = "linux"
+			}
+			original := x86UndefinedTrapBuildOriginal(t, goos, "amd64", raw)
+			arguments := execution.command(original)
+			ctx, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(ctx, arguments[0], arguments[1:]...)
+			// The Go runtime reports SIGILL and exits 2. It must not escalate
+			// the oracle into a core-producing crash because of inherited env.
+			command.Env = append(os.Environ(), "GOTRACEBACK=system")
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			cancel()
+			x86UndefinedTrapRequireOriginalSignal(t, output, err)
+			ir := x86UndefinedTrapIR(t, x86UndefinedTrapFixture(raw), "amd64", execution.triple, "Go")
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					optimized := ir
+					if level == "-O2" {
+						optimized = x86UndefinedTrapOptimizedIR(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "undefined", optimized, x86UndefinedTrapIndependentC, level)
+					if string(output) != "undefined-instruction SIGILL verified\n" {
+						t.Fatalf("independent real-signal oracle: %q", output)
+					}
+				})
+			}
+		})
+	}
+}
+
+// A child returning normally, an int3/SIGTRAP, and a generic abort all fail.
+// The parent observes the kernel's signal, independently of translator IR.
+const x86UndefinedTrapIndependentC = `
+#include <signal.h>
+#include <stdio.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+extern void fault(void);
+
+int main(void) {
+    pid_t child = fork();
+    if (child < 0) return 1;
+    if (child == 0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        fault();
+        _exit(91);
+    }
+    int status = 0;
+    if (waitpid(child, &status, 0) != child) return 2;
+    if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGILL) {
+        fprintf(stderr, "expected SIGILL, got child status=%x\n", status);
+        return 3;
+    }
+    puts("undefined-instruction SIGILL verified");
+    return 0;
+}
+`
diff --git a/amd64_unnamed_address_immediate_test.go b/amd64_unnamed_address_immediate_test.go
new file mode 100644
index 000000000..125718202
--- /dev/null
+++ b/amd64_unnamed_address_immediate_test.go
@@ -0,0 +1,280 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86UnnamedAddressImmediateActualGoEncoding(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+			if arch == "386" && op == "MOVQ" {
+				continue // Go's Q GP instruction is a different, invalid mode.
+			}
+			for _, address := range []string{"16(AX)", "8(AX)(CX*1)", "-7(BP)", "32(SP)(SI*4)"} {
+				t.Run(arch+"/"+op+"/"+address, func(t *testing.T) {
+					end := strings.IndexByte(address, '(')
+					literal := address[:end]
+					fixture := func(operand string) string {
+						return "TEXT addr(SB),4,$0-0\n" + op + " $" + operand + ",BX\nRET\n"
+					}
+					annotated := x86PackedShiftActualGoBytes(t, arch, fixture(address))
+					comparison := fixture(literal)
+					if op == "MOVL" || op == "MOVQ" {
+						// progedit runs before oclass. These two opcodes become
+						// a memory-class LEA, not a TYPE_CONST instruction.
+						comparison = "TEXT addr(SB),4,$0-0\nLEA" + op[3:] + " " + address + ",BX\nRET\n"
+					}
+					constant := x86PackedShiftActualGoBytes(t, arch, comparison)
+					if !bytes.Equal(annotated, constant) {
+						t.Fatalf("actual progedit/oclass bytes differ: annotated=%x comparison=%x", annotated, constant)
+					}
+					t.Logf("ORIGINAL_TYPE_ADDR arch=%s op=%s operand=$%s bytes=%x", arch, op, address, annotated)
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGoIntegerDomains(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, family := range []string{"MOV", "ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "CMP", "TEST", "SAL", "SHL", "SHR", "SAR", "ROL", "ROR", "RCL", "RCR", "IMUL", "BT", "BTC", "BTR", "BTS"} {
+			for _, suffix := range []string{"B", "W", "L", "Q"} {
+				if family == "MOV" && (suffix == "L" || suffix == "Q") || suffix == "Q" && arch == "386" ||
+					family == "IMUL" && suffix == "B" || strings.HasPrefix(family, "BT") && suffix == "B" {
+					continue
+				}
+				op := family + suffix
+				t.Run(arch+"/"+op, func(t *testing.T) {
+					instruction := op + " $16(AX)(CX*1),BX"
+					if family == "CMP" {
+						instruction = op + " BX,$16(AX)(CX*1)"
+					}
+					fixture := "TEXT addr(SB),4,$0-0\n" + instruction + "\nRET\n"
+					plain := strings.ReplaceAll(fixture, "$16(AX)(CX*1)", "$16")
+					annotated := x86PackedShiftActualGoBytes(t, arch, fixture)
+					constant := x86PackedShiftActualGoBytes(t, arch, plain)
+					if !bytes.Equal(annotated, constant) {
+						t.Fatalf("NAME_NONE register annotations changed literal encoding: annotated=%x plain=%x", annotated, constant)
+					}
+					t.Logf("ORIGINAL_CONSTANT_DOMAIN arch=%s instruction=%q bytes=%x", arch, instruction, annotated)
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateGoMemoryOnlyRejections(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"FMOVB", "FMOVW", "FMOVL", "FMOVV", "FMOVD", "FMOVX"} {
+			for _, instruction := range []string{op + " $16(AX),F0", op + "P F0,$16(AX)"} {
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					fixture := "TEXT addr(SB),4,$0-0\n" + instruction + "\nRET\n"
+					x86ScalarLiteralExpectedGoListing(t, arch, fixture, false)
+					file, err := Parse(ArchAMD64, fixture)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Ret: Void}}}); err == nil {
+						t.Fatal("Go-invalid integer TYPE_ADDR gained an x87 memory/float-literal role")
+					}
+				})
+			}
+		}
+		for _, op := range []string{"MOVSS", "MOVSD", "MOVAPS", "MOVAPD", "MOVUPS", "MOVUPD", "MOVO", "MOVOU", "ADDPS", "ADDPD", "ADDSS", "ADDSD", "MULPS", "MULPD", "MULSS", "MULSD", "DIVPS", "DIVPD", "DIVSS", "DIVSD"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				fixture := "TEXT addr(SB),4,$0-0\n" + op + " $16(AX),X0\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, fixture, false)
+				file, err := Parse(ArchAMD64, fixture)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Ret: Void}}}); err == nil {
+					t.Fatal("Go-invalid integer TYPE_ADDR gained an SSE memory/float-literal role")
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnnamedAddressImmediateTranslation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, instruction := range []string{
+			"MOVB $16(AX),BX", "MOVW $8(AX)(CX*1),BX", "MOVL $-7(AX)(CX*4),BX",
+			"ADDW $16(AX),BX", "SUBL $16(AX),BX", "ADCW $16(AX),BX", "SBBL $16(AX),BX",
+			"ANDL $16(AX),BX", "ORW $16(AX),BX", "XORB $16(AX),BX",
+			"CMPW BX,$16(AX)", "TESTL $16(AX),BX", "SHLL $16(AX),BX",
+			"SHRW $16(AX),BX", "IMULW $16(AX),BX", "IMUL3L $16(AX),CX,BX",
+			"BTW $16(AX),BX", "BTCL $16(AX),BX", "BTRW $16(AX),BX", "BTSL $16(AX),BX",
+		} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT addr(SB),4,$0-0\nMOVL $3,AX\nMOVL $2,CX\nMOVL $1,BX\n" + instruction + "\nRET\n"
+				x86PackedShiftActualGoBytes(t, arch, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"addr": {Ret: Void}}}); err != nil {
+					t.Fatalf("actual Go integer/address source failed translation: %v", err)
+				}
+			})
+		}
+	}
+}
+
+// Execute the same original Go instruction bytes with independently varied
+// AX/CX and a full BX sentinel. This is a first-party integer observation; a
+// Darwin/ARM64 Rosetta execution is diagnostic, not native AMD64 coverage.
+func TestCrossLinuxRuntimeMatrixX86UnnamedAddressImmediateValues(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	for index, row := range []struct {
+		op, operand string
+		bits        int
+		value       uint64
+	}{
+		{"MOVB", "$16(AX)", 8, 16}, {"MOVW", "$8(AX)(CX*1)", 16, 8},
+		{"MOVL", "$-7(AX)(CX*4)", 32, 0xfffffff9}, {"MOVQ", "$32(AX)(CX*8)", 64, 32},
+	} {
+		t.Run(row.op, func(t *testing.T) {
+			var assembly, declarations, checks strings.Builder
+			name := fmt.Sprintf("addr%d", index)
+			fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-24\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),CX\nMOVQ $0x5a77bb9911eecc33,BX\n%s %s,BX\nMOVQ BX,ret+16(FP)\nRET\n", name, row.op, row.operand)
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT addr(SB),4,$0-0\n"+row.op+" "+row.operand+",BX\nRET\n")
+			decoded, err := x86asm.Decode(code, 64)
+			if err != nil || decoded.Len == 0 {
+				t.Fatalf("original single instruction: %x / %v", code, err)
+			}
+			var directive strings.Builder
+			for offset, b := range code[:decoded.Len] {
+				if offset != 0 {
+					directive.WriteByte(',')
+				}
+				fmt.Fprintf(&directive, "0x%02x", b)
+			}
+			fmt.Fprintf(&declarations, "extern uint64_t %s(uint64_t,uint64_t);\nstatic uint64_t original%d(uint64_t a,uint64_t b) {\n uint64_t got;\n __asm__ volatile(\"movq %%1,%%%%rax; movq %%2,%%%%rcx; movabsq $0x5a77bb9911eecc33,%%%%rbx; .byte %s; movq %%%%rbx,%%0\" : \"=r\"(got) : \"r\"(a),\"r\"(b) : \"rax\",\"rcx\",\"rbx\",\"cc\");\n return got;\n}\n", name, index, directive.String())
+			mask := ^uint64(0)
+			if row.bits < 64 {
+				mask = uint64(1)<<uint(row.bits) - 1
+			}
+			want := fmt.Sprintf("UINT64_C(%d)", row.value&mask|uint64(0x5a77bb9911eecc33)&^mask)
+			if row.bits == 32 {
+				want = "(uint64_t)(uint32_t)(a+4*b-7)"
+			} else if row.bits == 64 {
+				want = "(a+8*b+32)"
+			}
+			fmt.Fprintf(&checks, "  { uint64_t want=%s;\n    if (original%d(a,b)!=want || %s(a,b)!=want) { fprintf(stderr,\"bad TYPE_ADDR case %d seed %%u\\n\",seed); return %d; }\n  }\n", want, index, name, index, index+11)
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := make(map[string]FuncSig)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{I64, I64}, Ret: I64, Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+				Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+			}}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			main := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + "int main(void) {\n for(unsigned seed=0;seed<256;seed++) {\n  uint64_t a=UINT64_C(0x1313939382827272)*seed,b=~a;\n" + checks.String() + " }\n puts(\"TYPE_ADDR_NATIVE_MATH_256_OK\");\n return 0;\n}\n"
+			for _, level := range []string{"-O0", "-O2"} {
+				execution.compileAndRunLLVM(t, "unnamed-address", ir, main, level)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86UnnamedAddressImm32MathAndCanaries(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	for _, row := range []struct {
+		operation, expected string
+	}{
+		{"ADDQ", "a-1"}, {"SUBQ", "a+1"}, {"ADCQ", "a-1"}, {"SBBQ", "a+1"},
+		{"ANDQ", "a"}, {"ORQ", "UINT64_MAX"}, {"XORQ", "~a"}, {"IMULQ", "0-a"},
+		{"CMPQ", "(uint64_t)(a<UINT64_MAX)"}, {"TESTQ", "(uint64_t)(a==0)"},
+	} {
+		t.Run(row.operation, func(t *testing.T) {
+			instruction := row.operation + " $0xffffffff(AX),BX"
+			if row.operation == "CMPQ" {
+				instruction = row.operation + " BX,$0xffffffff(AX)"
+			}
+			observation, originalObservation := "", ""
+			if row.operation == "CMPQ" || row.operation == "TESTQ" {
+				flag := "SETCS"
+				cFlag := "setc"
+				if row.operation == "TESTQ" {
+					flag, cFlag = "SETEQ", "sete"
+				}
+				observation = flag + " DL\nMOVBQZX DX,BX\n"
+				originalObservation = cFlag + " %%dl; movzbq %%dl,%%rbx; "
+			}
+			code := x86PackedShiftActualGoBytes(t, "amd64", "TEXT addr(SB),4,$0-0\n"+instruction+"\nRET\n")
+			decoded, err := x86asm.Decode(code, 64)
+			if err != nil || decoded.Len == 0 {
+				t.Fatalf("actual Go single instruction: %x / %v", code, err)
+			}
+			var directive strings.Builder
+			for index, value := range code[:decoded.Len] {
+				if index != 0 {
+					directive.WriteByte(',')
+				}
+				fmt.Fprintf(&directive, "0x%02x", value)
+			}
+			source := "TEXT addr(SB),4,$0-24\nMOVQ a+0(FP),BX\nMOVQ b+8(FP),AX\nCLC\n" + instruction + "\n" + observation + "MOVQ BX,ret+16(FP)\nRET\n"
+			x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			signature := FuncSig{Name: "addr", Args: []LLVMType{I64, I64}, Ret: I64, Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+				Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+			}}
+			ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: map[string]FuncSig{"addr": signature}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			main := fmt.Sprintf(`
+#include <stdint.h>
+#include <stdio.h>
+extern uint64_t addr(uint64_t, uint64_t);
+
+static uint64_t original(uint64_t a, uint64_t b) {
+    uint64_t got;
+    __asm__ volatile("movq %%1,%%%%rbx; movq %%2,%%%%rax; clc; .byte %s; %smovq %%%%rbx,%%0"
+        : "=&r"(got) : "r"(a), "r"(b) : "rax", "rbx", "rdx", "cc");
+    return got;
+}
+
+int main(void) {
+    for (unsigned seed = 0; seed < 256; seed++) {
+        volatile struct { uint64_t before, a, b, after; } input = {
+            UINT64_C(0x8977665544332211), UINT64_C(0x2398111297893221) * seed,
+            UINT64_C(0xabbacafe137a3366) * seed, UINT64_C(0x998812345679abcd)
+        };
+        uint64_t a = input.a, b = input.b;
+        uint64_t want = %s;
+        if (original(a,b) != want || addr(a,b) != want) {
+            fprintf(stderr, "imm32 result %s seed %%u\n", seed);
+            return 31;
+        }
+        if (input.before != UINT64_C(0x8977665544332211) || input.a != a || input.b != b ||
+            input.after != UINT64_C(0x998812345679abcd)) {
+            fputs("input/canary changed\n", stderr);
+            return 32;
+        }
+    }
+    puts("IMM32_MATH_FLAGS_CANARIES_256_OK");
+    return 0;
+}
+`, directive.String(), originalObservation, row.expected, row.operation)
+			for _, optimization := range []string{"-O0", "-O2"} {
+				execution.compileAndRunLLVM(t, "source-imm32", ir, main, optimization)
+			}
+		})
+	}
+}
diff --git a/amd64_unresolved_source_memory_test.go b/amd64_unresolved_source_memory_test.go
new file mode 100644
index 000000000..f48be61e1
--- /dev/null
+++ b/amd64_unresolved_source_memory_test.go
@@ -0,0 +1,311 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// A source inventory must retain every later instruction when a generated
+// header has not supplied an earlier displacement. Retention is not permission
+// to translate that displacement, even when a raw RET follows it.
+func TestX86UnresolvedSourceMemoryPreservesSyntax(t *testing.T) {
+	for _, row := range []struct {
+		address string
+		raw     string
+		base    Reg
+		index   Reg
+		scale   int64
+	}{
+		{"UNKNOWN(AX)", "UNKNOWN", AX, "", 0},
+		{"g_stackguard0(BP)", "g_stackguard0", BP, "", 0},
+		{"g(CX)", "g", CX, "", 0},
+		{"(UNKNOWN+4)(AX)", "(UNKNOWN+4)", AX, "", 0},
+		{"UNKNOWN+4(AX)(CX*2)", "UNKNOWN+4", AX, CX, 2},
+		{"UNKNOWN(AX)(CX)", "UNKNOWN", AX, CX, 0},
+	} {
+		t.Run(row.address, func(t *testing.T) {
+			source := "TEXT one(SB),4,$0-0\nMOVL " + row.address + ",BX\nADDL $7,BX\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var instructions []Instr
+			for _, instruction := range file.Funcs[0].Instrs {
+				if instruction.Op != OpTEXT && instruction.Op != OpLABEL {
+					instructions = append(instructions, instruction)
+				}
+			}
+			if len(instructions) != 3 || instructions[1].Op != "ADDL" {
+				t.Fatal("source inventory lost the instruction after the unresolved operand")
+			}
+			memory := instructions[0].Args[0]
+			if memory.Kind != OpMem || memory.Mem.OffRaw != row.raw || memory.Mem.Off != 0 ||
+				memory.Mem.Base != row.base || memory.Mem.Index != row.index || memory.Mem.Scale != row.scale {
+				t.Fatalf("lost unresolved syntax: %#v", memory)
+			}
+			for _, arch := range []string{"386", "amd64"} {
+				if err := ProbeInstruction(ArchAMD64, arch, instructions[0]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s unresolved memory acquired a lowering witness: %v", arch, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86UnresolvedSourceMemoryThreeAPIsRejectBeforeRawDecoding(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []string{"MOVL", "VMOVD", "PXOR", "LEAL"} {
+			for _, raw := range []bool{false, true} {
+				t.Run(target.triple+"/"+opcode+"/raw="+strconv.FormatBool(raw), func(t *testing.T) {
+					destination := "BX"
+					if opcode == "VMOVD" || opcode == "PXOR" {
+						destination = "X0"
+					}
+					ending := "RET"
+					if raw {
+						ending = "BYTE $0xc3"
+					}
+					source := "TEXT ·Value(SB),4,$0-0\n" + opcode + " UNKNOWN(AX)," + destination + "\n" + ending + "\n"
+					goAssemblerOracleOutput(t, target.arch, source, "", false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+					options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+						Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}}
+					pkg := mustGoPackage(t, "memory", "package memory\nfunc Value()\n")
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							var err error
+							switch api {
+							case "text":
+								var ir string
+								ir, err = Translate(file, options)
+								if ir != "" {
+									t.Fatal("unresolved memory emitted IR")
+								}
+							case "module":
+								var module llvm.Module
+								module, err = TranslateModuleInContext(ctx, file, options)
+								if !module.IsNil() {
+									module.Dispose()
+									t.Fatal("unresolved memory emitted a module")
+								}
+							case "GoModule":
+								var result *GoModuleTranslation
+								result, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+									GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+								if result != nil && !result.Module.IsNil() {
+									result.Module.Dispose()
+									t.Fatal("unresolved memory emitted a Go module")
+								}
+							}
+							if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "UNKNOWN") {
+								t.Fatalf("%s lost the unresolved displacement diagnostic: %v", api, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86UnresolvedSourceMemoryResolvedMacrosThreeAPIsFiveTargets(t *testing.T) {
+	const source = `#define OFFSET (3*8)
+TEXT ·Value(SB),4,$0-0
+MOVL $32,AX
+MOVL OFFSET(AX),BX
+RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, ins := range file.Funcs[0].Instrs {
+				for _, arg := range ins.Args {
+					if arg.Kind == OpMem && (arg.Mem.OffRaw != "" || arg.Mem.Off != 24) {
+						t.Fatalf("resolved macro lost its real displacement: %#v", arg)
+					}
+				}
+			}
+			resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+				Sigs: map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}}
+			// Resolving OFFSET proves only its displacement. The complete NUM
+			// address permits the exact volatile access, never readable backing.
+			format := x86ScalarFormatObjectUnit(t, file, options.Sigs, target.arch, target.triple, 0)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, target.triple, format, level)
+			}
+			pkg := mustGoPackage(t, "memory", "package memory\nfunc Value()\n")
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					var err error
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+							GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil || strings.Count(ir, "load volatile i32,") != 1 || !strings.Contains(ir, "align 1") {
+						t.Fatalf("resolved NUM address lost its exact unaligned dword access: %v", err)
+					}
+					x86RequireNumericNativeSourceContext(t, source, "func Value()", target.arch)
+					x86NumericNativeAddressObject(t, ir, target.triple)
+				})
+			}
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			bound := fmt.Sprintf("#define OFFSET (3*8)\nTEXT ·Value(SB),4,$0-%d\n"+
+				"%s p+0(FP),AX\nMOVL OFFSET(AX),BX\nRET\n", word, move)
+			fixture := x86OriginalGPInitializedFormat{bound, "func Value(p *[32]byte)"}
+			x86OriginalGPInitializedFormatObjects(t, []x86OriginalGPInitializedFormat{fixture}, target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86UnresolvedSourceMemoryCannotHideMalformedPhysicalGroups(t *testing.T) {
+	for _, address := range []string{
+		"UNKNOWN(AX)(CX*3)", "UNKNOWN(AX)(CX*UNKNOWN)", "UNKNOWN(AX)(CX*1)(DX*1)",
+	} {
+		t.Run(address, func(t *testing.T) {
+			// Resolve the displacement for the independent Go syntax rejection:
+			// an undefined macro must not be the reason this negative control fails.
+			for _, arch := range []string{"386", "amd64"} {
+				resolved := "#define UNKNOWN 24\nTEXT one(SB),4,$0-0\nMOVL " + address + ",BX\nRET\n"
+				goAssemblerOracleOutput(t, arch, resolved, "", false)
+			}
+			if _, err := Parse(ArchAMD64, "TEXT one(SB),4,$0-0\nMOVL "+address+",BX\nRET\n"); err == nil {
+				t.Fatal("unresolved displacement hid a malformed physical register group")
+			}
+		})
+	}
+}
+
+// NAME_AUTO's bare identifier is a descriptive stack name with offset zero,
+// not an undefined displacement constant. Keep this independent of the
+// unresolved-expression rejection, and bind it to Go's accepted objects.
+func TestX86UnresolvedSourceMemoryBareStackNamesRemainResolved(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, name := range []string{"tmp", "UNKNOWN"} {
+		for _, target := range x86RawReturnTargets {
+			t.Run(name+"/"+target.triple, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$16-0\nMOVL $7," + name + "(SP)\nMOVL " + name + "(SP),AX\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, ins := range file.Funcs[0].Instrs {
+					for _, arg := range ins.Args {
+						if arg.Kind == OpMem && (arg.Mem.Base != SP || arg.Mem.Off != 0 || arg.Mem.OffRaw != name) {
+							t.Fatalf("bare AUTO syntax lost its name or resolved zero offset: %#v", arg)
+						}
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatalf("resolved bare AUTO name lost its existing object path: %v", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "bare-auto.ll", "bare-auto.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnresolvedSourceMemoryStackNamesCannotResolveExpressions(t *testing.T) {
+	for _, row := range []struct {
+		name     string
+		memory   MemRef
+		resolved bool
+	}{
+		{"bare-auto", MemRef{Base: SP, OffRaw: "tmp"}, true},
+		{"bare-upper-auto", MemRef{Base: SP, OffRaw: "UNKNOWN"}, true},
+		{"named-constant", MemRef{Base: SP, OffRaw: "tmp+4", Off: 4}, true},
+		{"named-expression", MemRef{Base: SP, OffRaw: "tmp-(2*4)", Off: -8}, true},
+		{"missing-constant", MemRef{Base: SP, OffRaw: "tmp+UNKNOWN"}, false},
+		{"malformed-name", MemRef{Base: SP, OffRaw: "tmp-dig"}, false},
+		{"bare-nonzero", MemRef{Base: SP, OffRaw: "tmp", Off: 4}, false},
+		{"wrong-resolved-offset", MemRef{Base: SP, OffRaw: "tmp+4", Off: 0}, false},
+		{"ordinary-macro", MemRef{Base: AX, OffRaw: "tmp"}, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			err := unresolvedX86MemoryOffsetError(row.memory)
+			if row.resolved && err != nil || !row.resolved && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("resolved=%v, got %v", row.resolved, err)
+			}
+		})
+	}
+}
+
+func TestX86UnresolvedSourceMemoryEveryDirectionRejectsBeforeRawDecoding(t *testing.T) {
+	for _, address := range []string{
+		"UNKNOWN(AX)", "(UNKNOWN+4)(AX)", "UNKNOWN(AX)(CX*2)", "UNKNOWN(AX)(FS)", "slot+UNKNOWN(SP)",
+	} {
+		for _, destination := range []bool{false, true} {
+			for _, target := range x86RawReturnTargets {
+				t.Run(address+"/destination="+strconv.FormatBool(destination)+"/"+target.triple, func(t *testing.T) {
+					operands := address + ",BX"
+					if destination {
+						operands = "BX," + address
+					}
+					// The displacement-resolved control proves the physical groups
+					// and direction independently; undefined constants are the only
+					// source rejection used by this test.
+					body := "TEXT ·view(SB),4,$16-0\nMOVL $7,BX\nMOVL " + operands + "\nBYTE $0xc3\n"
+					goAssemblerOracleOutput(t, target.arch, "#define UNKNOWN 24\n"+body, "", true)
+					goAssemblerOracleOutput(t, target.arch, body, "", false)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, body, "func view()\n", target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "UNKNOWN") {
+								t.Fatalf("%s granted an unresolved memory effect: %v", api, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/amd64_unsigned_integer_scalar_float.go b/amd64_unsigned_integer_scalar_float.go
new file mode 100644
index 000000000..8cebf7eb0
--- /dev/null
+++ b/amd64_unsigned_integer_scalar_float.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86UnsignedIntegerFloatForm struct {
+	x86SignedIntegerFloatForm
+	nativeSource Operand
+}
+
+// All four unsigned names have one EVEX three-operand row. Reuse the signed
+// family's operand axes, including mode32 WIG, without registering its caller
+// or raw-source permissions. The original Op and physical source stay intact.
+func x86UnsignedIntegerFloatProperties(ins Instr, arch string) (x86UnsignedIntegerFloatForm, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64ScalarIntegerFloatOps[base]
+	if !known {
+		return x86UnsignedIntegerFloatForm{}, false, nil
+	}
+	form, _, err := x86IntegerScalarFloatOperandProperties(ins, arch, x86SignedIntegerFloatSpec{
+		sourceBits: spec.sourceBits, resultBits: spec.resultBits, rounding: spec.rounding,
+	})
+	if err == nil {
+		err = x86NamedMultiplyMemoryError(ins.Args[0], arch)
+	}
+	result := x86UnsignedIntegerFloatForm{x86SignedIntegerFloatForm: form}
+	if err != nil {
+		return result, true, err
+	}
+	result.nativeSource = ins.Args[0]
+	if arch == "386" && spec.sourceBits == 64 && x86ResultNamedPredicateInstruction(ins) &&
+		result.nativeSource.Kind == OpMem && result.nativeSource.Mem.Sym == "" && result.nativeSource.Mem.Base != "" {
+		// Go's Q row compresses with N8 even in mode32, where hardware
+		// ignores W and scales the encoded disp8 by N4. Preserve the actual
+		// producer address, not the written offset, in a local projection.
+		// A disp32, an absolute/symbolic address and a logical FP field do
+		// not acquire that register-addressed compressed-displacement role.
+		offset := int64(int32(result.nativeSource.Mem.Off))
+		if offset%8 == 0 && offset/8 >= -128 && offset/8 <= 127 {
+			result.nativeSource.Mem.Off = offset / 2
+		}
+	}
+	return result, true, nil
+}
+
+func x86TypedUnsignedIntegerFloatByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, known := amd64ScalarIntegerFloatOps[base]; !known {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("unsigned scalar conversion effect/source mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, known, err := x86UnsignedIntegerFloatProperties(ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	return x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+		{index: 0, operand: form.nativeSource, width: int64(form.sourceBits / 8), read: true},
+		{index: form.upper, operand: ins.Args[form.upper], width: 16, read: true},
+		{index: form.destination, operand: ins.Args[form.destination], width: 16, write: true},
+	}}, true, nil
+}
+
+func x86ResultUnsignedIntegerFloatStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86UnsignedIntegerFloatProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ResultIntegerScalarFloatInputs(ins, form.x86SignedIntegerFloatForm, state, owned, arch, nativeRead), true
+}
+
+func (c *amd64Ctx) lowerUnsignedIntegerScalarFloat(op Op, ins Instr) (bool, bool, error) {
+	if ins.Op == "" {
+		ins.Op = op
+	} else if !strings.EqualFold(string(ins.Op), string(op)) {
+		base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+		if _, known := amd64ScalarIntegerFloatOps[base]; known {
+			return true, false, fmt.Errorf("unsigned scalar conversion helper opcode %s conflicts with instruction %s", op, ins.Op)
+		}
+		return false, false, nil
+	}
+	form, known, err := x86UnsignedIntegerFloatProperties(ins, c.goarch)
+	if !known || err != nil {
+		return known, false, err
+	}
+	if !x86ScalarFloatIntegerNativeTarget(c.goarch, c.targetTriple) || !x86ResultNamedPredicateInstruction(ins) {
+		return true, false, fmt.Errorf("%w: %s needs its original named native x86 MXCSR target", ErrProbeNeedsContext, op)
+	}
+	if c.fpScalarSource.x86SourceStack != nil || c.fpScalarSource.x86FixedLocal != nil {
+		return true, false, fmt.Errorf("%w: %s retains its independent source/frame owner", ErrProbeNeedsContext, op)
+	}
+	if form.memory >= 0 && ins.Args[0].Kind != OpFP && !c.nativeMemoryOperand(ins, form.memory) {
+		return true, false, fmt.Errorf("%w: %s needs owned FP bits or an original native memory source", ErrProbeNeedsContext, op)
+	}
+	return true, false, c.emitNativeUnsignedIntegerScalarFloat(ins, form)
+}
+
+// One complete native opcode owns MXCSR rounding/precision, embedded SAE and
+// exact m32/m64 access, even for dead results. Integer FP is gathered through
+// its existing exact-bit consumer, never presented as a native stack address.
+func (c *amd64Ctx) emitNativeUnsignedIntegerScalarFloat(ins Instr, form x86UnsignedIntegerFloatForm) error {
+	const carrier = "<4 x float>"
+	source := form.nativeSource
+	width := amd64IntegerTypeForBits(form.sourceBits)
+	var value, inputType, constraint, operand string
+	var err error
+	if source.Kind == OpReg {
+		value, err = c.evalIntSized(source, width)
+	} else if source.Kind == OpFP {
+		var handled bool
+		value, handled, err = c.loadIntegerFPBytesMode(source.FPOffset, width, true)
+		if err == nil && !handled {
+			err = fmt.Errorf("%w: %s lacks exact owned FP integer bits", ErrProbeNeedsContext, ins.Op)
+		}
+	}
+	if source.Kind == OpReg || source.Kind == OpFP {
+		inputType, constraint = string(width), "r"
+		modifier := "k"
+		if form.sourceBits == 64 {
+			modifier = "q"
+		}
+		operand = "${2:" + modifier + "}"
+	} else {
+		var pointerType string
+		value, pointerType, _, err = c.packedVectorMemoryPointer(source)
+		inputType = fmt.Sprintf("%s elementtype([%d x i8])", pointerType, form.sourceBits/8)
+		constraint, operand = "*m", "$2"
+	}
+	if err != nil {
+		return err
+	}
+	upper, err := c.loadFloatingVectorOperand(ins.Args[form.upper], 16, 4, 32)
+	if err != nil {
+		return err
+	}
+	mnemonic := "vcvtusi2ss"
+	if form.spec.resultBits == 64 {
+		mnemonic = "vcvtusi2sd"
+	}
+	mnemonic += map[int]string{32: "l", 64: "q"}[form.sourceBits]
+	assembly := mnemonic + " " + operand
+	// Mode32 W1 behaves as W0. In particular, double's exact uint32
+	// conversion ignores EVEX embedded rounding, rather than acquiring Q data.
+	// LLVM's AT&T integer-to-float grammar places RC after the GP source,
+	// unlike its floating-source arithmetic and precision conversions.
+	if form.rounding != "" && (form.sourceBits == 64 || form.spec.resultBits == 32) {
+		assembly += ", {" + strings.ToLower(strings.TrimSuffix(form.rounding, "_SAE")) + "-sae}"
+	}
+	assembly += ", $1, $0"
+	result, bytes := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s)\n", result, carrier, assembly,
+		"=v,v,"+constraint+",~{memory},~{fpsr}", carrier, upper, inputType, value)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, carrier, result)
+	return c.storePackedMoveOperand(ins.Args[form.destination], 16, "%"+bytes)
+}
diff --git a/amd64_vector_alias_test.go b/amd64_vector_alias_test.go
index 797ffc419..85ebd37dc 100644
--- a/amd64_vector_alias_test.go
+++ b/amd64_vector_alias_test.go
@@ -1,56 +1,107 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
 	"fmt"
-	"runtime"
+	"strings"
 	"testing"
 )
 
-func TestAMD64VectorRegisterAliases(t *testing.T) {
-	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
-	if runtime.GOARCH != "amd64" && !crossRosetta {
-		t.Skip("requires amd64 execution")
+type x86VectorAliasCase struct {
+	name, instructions, expected string
+}
+
+var x86VectorAliasCases = []x86VectorAliasCase{
+	{"wide_to_narrow", "VMOVDQU64 (SI), Z1\nMOVOU X1, (DI)", "i < 16 ? in[i] : 0"},
+	{"legacy_preserves_upper", "VMOVDQU64 (SI), Z1\nMOVOU 64(SI), X1\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[64+i] : in[i]"},
+	{"vex128_clears_upper", "VMOVDQU64 (SI), Z1\nMOVOU 64(SI), X2\nVMOVAPS X2, X1\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[64+i] : 0"},
+	{"vex256_clears_upper", "VMOVDQU64 (SI), Z1\nVMOVDQU 64(SI), Y1\nVMOVDQU64 Z1, (DI)", "i < 32 ? in[64+i] : 0"},
+	{"zero_upper", "VMOVDQU64 (SI), Z1\nVZEROUPPER\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[i] : 0"},
+	{"zero_all", "VMOVDQU64 (SI), Z1\nVZEROALL\nVMOVDQU64 Z1, (DI)", "0"},
+}
+
+func x86VectorAliasIR(t *testing.T, arch, triple string, tc x86VectorAliasCase) string {
+	t.Helper()
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·probe(SB),4,$0-%d\n%s in+0(FP), SI\n%s out+%d(FP), DI\n%s\nRET\n",
+		2*word, move, move, word, tc.instructions)
+	goAssemblerOracleOutput(t, arch, source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
 	}
-	llc, clang, ok := findLlcAndClang(t)
-	if !ok {
-		t.Skip("llc/clang not found")
+	// Derive the ABI0 slots from the complete first-party declaration, not
+	// hand-built offsets. Pointee types do not supply a caller/native-frame
+	// certificate. This fixture observes explicitly initialized C buffers.
+	pkg := x86AddSubLiteralPackage(t, arch, "func probe(in *[128]byte, out *[64]byte)\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
 	}
-	triple := testTargetTriple(runtime.GOOS, "amd64")
-	var prefix []string
-	if crossRosetta {
-		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       arch,
+		ResolveSym:   resolve,
+		Sigs:         sigs,
+	})
+	if err != nil {
+		t.Fatal(err)
 	}
-	for _, tc := range []struct{ name, instructions, expected string }{
-		{"wide_to_narrow", "VMOVDQU64 (SI), Z1\nMOVOU X1, (DI)", "i < 16 ? in[i] : 0"},
-		{"legacy_preserves_upper", "VMOVDQU64 (SI), Z1\nMOVOU 64(SI), X1\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[64+i] : in[i]"},
-		{"vex128_clears_upper", "VMOVDQU64 (SI), Z1\nMOVOU 64(SI), X2\nVMOVAPS X2, X1\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[64+i] : 0"},
-		{"vex256_clears_upper", "VMOVDQU64 (SI), Z1\nVMOVDQU 64(SI), Y1\nVMOVDQU64 Z1, (DI)", "i < 32 ? in[64+i] : 0"},
-		{"zero_upper", "VMOVDQU64 (SI), Z1\nVZEROUPPER\nVMOVDQU64 Z1, (DI)", "i < 16 ? in[i] : 0"},
-		{"zero_all", "VMOVDQU64 (SI), Z1\nVZEROALL\nVMOVDQU64 Z1, (DI)", "0"},
+	return ll
+}
+
+func TestX86VectorRegisterAliasesFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch, triple string
+	}{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
 	} {
+		for _, tc := range x86VectorAliasCases {
+			t.Run(target.triple+"/"+tc.name, func(t *testing.T) {
+				ll := x86VectorAliasIR(t, target.arch, target.triple, tc)
+				compileLLVMToObject(t, llc, target.triple, "alias.ll", "alias.o", ll)
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixAMD64VectorRegisterAliases(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	for _, tc := range x86VectorAliasCases {
 		t.Run(tc.name, func(t *testing.T) {
-			source := "TEXT probe(SB),NOSPLIT,$0-16\nMOVQ in+0(FP), SI\nMOVQ out+8(FP), DI\n" + tc.instructions + "\nRET\n"
-			file, err := Parse(ArchAMD64, source)
-			if err != nil {
-				t.Fatal(err)
-			}
-			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "amd64", Sigs: map[string]FuncSig{"probe": {Name: "probe", Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}}}}}})
-			if err != nil {
-				t.Fatal(err)
-			}
+			ll := x86VectorAliasIR(t, "amd64", triple, tc)
 			mainC := fmt.Sprintf(`#include <stdio.h>
 extern void probe(unsigned char *, unsigned char *);
 int main(void) {
- unsigned char in[128], out[64] = {0};
- for (int i = 0; i < 128; ++i) in[i] = (unsigned char)(i + 1);
- probe(in, out);
- for (int i = 0; i < 64; ++i) {
-  unsigned char want = %s;
-  if (out[i] != want) { fprintf(stderr, "byte %%d: got %%u, want %%u\n", i, out[i], want); return 1; }
- }
- return 0;
+    unsigned char in[128], out[66] = {0};
+    for (int i = 0; i < 128; ++i)
+        in[i] = (unsigned char)(i + 1);
+    out[0] = out[65] = 0xa5;
+    probe(in, out + 1);
+    if (out[0] != 0xa5 || out[65] != 0xa5)
+        return 2;
+    for (int i = 0; i < 128; ++i)
+        if (in[i] != (unsigned char)(i + 1))
+            return 3;
+    for (int i = 0; i < 64; ++i) {
+        unsigned char want = %s;
+        if (out[i + 1] != want) {
+            fprintf(stderr, "byte %%d: got %%u, want %%u\n", i, out[i + 1], want);
+            return 1;
+        }
+    }
+    return 0;
 }`, tc.expected)
 			compileAndRunRuntimeTestForTarget(t, llc, clang, "vector_alias", triple, ll, mainC, prefix)
 		})
diff --git a/amd64_vector_arithmetic_go_rows_test.go b/amd64_vector_arithmetic_go_rows_test.go
new file mode 100644
index 000000000..893b36a66
--- /dev/null
+++ b/amd64_vector_arithmetic_go_rows_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VectorArithmeticCompleteGoEncoderRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`(?s)\{as: A(VPADD\w+|VPSUB\w+),.*?\n\t\}\},`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != len(x86ResultVectorArithmeticNames) {
+		t.Fatal("complete Go add/subtract inventory changed", len(rows))
+	}
+	encodings := map[string]byte{
+		"VPADDB": 0xfc, "VPADDW": 0xfd, "VPADDD": 0xfe, "VPADDQ": 0xd4,
+		"VPADDSB": 0xec, "VPADDSW": 0xed, "VPADDUSB": 0xdc, "VPADDUSW": 0xdd,
+		"VPSUBB": 0xf8, "VPSUBW": 0xf9, "VPSUBD": 0xfa, "VPSUBQ": 0xfb,
+		"VPSUBSB": 0xe8, "VPSUBSW": 0xe9, "VPSUBUSB": 0xd8, "VPSUBUSW": 0xd9,
+	}
+	for _, row := range rows {
+		opcode, known := encodings[row[1]]
+		if !known {
+			t.Fatal("unregistered official arithmetic row", row[1])
+		}
+		delete(encodings, row[1])
+		var expected strings.Builder
+		fmt.Fprintf(&expected, "{as: A%s, ytab: _yvandnpd, prefix: Pavx, op: opBytes{\n", row[1])
+		for _, width := range []int{128, 256} {
+			fmt.Fprintf(&expected, "avxEscape | vex%d | vex66 | vex0F | vexW0, 0x%X,\n", width, opcode)
+		}
+		w, broadcast := 0, ""
+		if row[1] == "VPADDD" || row[1] == "VPSUBD" {
+			broadcast = " | evexBcstN4"
+		}
+		if row[1] == "VPADDQ" || row[1] == "VPSUBQ" {
+			w, broadcast = 1, " | evexBcstN8"
+		}
+		for _, width := range []int{128, 256, 512} {
+			fmt.Fprintf(&expected, "avxEscape | evex%d | evex66 | evex0F | evexW%d, evexN%d%s | evexZeroingEnabled, 0x%X,\n", width, w, width/8, broadcast, opcode)
+		}
+		expected.WriteString("}},")
+		if strings.Join(strings.Fields(row[0]), "") != strings.Join(strings.Fields(expected.String()), "") {
+			t.Fatal("complete encoder prefix/opcode/tuple/zeroing attributes changed", row[0])
+		}
+	}
+	if len(encodings) != 0 {
+		t.Fatal("missing official operations", encodings)
+	}
+	start := strings.Index(string(data), "var _yvandnpd =")
+	if start < 0 {
+		t.Fatal("missing original selector table")
+	}
+	table := strings.SplitN(string(data)[start:], "\n}", 2)[0] + "\n}"
+	if err := x86AverageValidateGoYtab(table); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86VectorArithmeticRejectsUnknownFormsAndBanks(t *testing.T) {
+	for _, op := range x86ResultVectorArithmeticNames {
+		for _, operands := range []string{"$1,X1,X2", "X0,Y1,Y2", "X0,X1,K0,X2", "X0,X1,(AX)", "X0,X1", "(AX),(BX),X1", "unknown,X1,X2"} {
+			row := op.name + " " + operands
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+			state := x86ResultState{masks: [8]bool{true, true}}
+			for index := 0; index < 32; index++ {
+				state.writeVector(index, 64, ^uint64(0), false)
+			}
+			if x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") {
+				t.Fatal("unknown Go form acquired numerical effects", row)
+			}
+		}
+		for _, row := range []string{
+			op.name + " X8,X0,X1", op.name + " Y0,Y8,Y1", op.name + " Z0,Z1,Z8",
+		} {
+			// Go admits unbound high X/Y names, but rejects high Z names
+			// in mode32. Neither category supplies a physical register.
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", !strings.Contains(row, "Z8"))
+			state := x86ResultState{}
+			for index := 0; index < 32; index++ {
+				state.writeVector(index, 64, ^uint64(0), false)
+			}
+			if x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "386") {
+				t.Fatal("Go syntax acquired an unproved physical bank", row)
+			}
+		}
+	}
+}
diff --git a/amd64_vector_arithmetic_runtime_test.go b/amd64_vector_arithmetic_runtime_test.go
new file mode 100644
index 000000000..5afa0afd3
--- /dev/null
+++ b/amd64_vector_arithmetic_runtime_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Portable LLVM execution checks all bytes, aliases, masks and FLAGS/CSR.
+// It is not a claim of executing original AVX512 instructions on this host.
+func TestCrossLinuxRuntimeMatrixX86VectorArithmeticResultAliases(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, width := range []int{16, 32, 64} {
+		t.Run(fmt.Sprint(width), func(t *testing.T) {
+			var source, declarations, reference, checks strings.Builder
+			reference.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n#include <xmmintrin.h>\n")
+			reference.WriteString(x86LegacyIntegerArithmeticCMath)
+			reference.WriteString(x86VectorArithmeticResultReference)
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			count := 0
+			for index, op := range x86ResultVectorArithmeticNames {
+				mode := 0
+				if index%8 >= 4 {
+					mode = 1
+					if index%8 >= 6 {
+						mode = 2
+					}
+				}
+				for masking := 0; masking < 3; masking++ {
+					name := fmt.Sprint("VectorArithmetic", count)
+					count++
+					row := op.name
+					if masking == 2 {
+						row += ".Z"
+					}
+					row += " " + bank + "0," + bank + "1"
+					if masking != 0 {
+						row += ",K1"
+					}
+					// Independent, source-one alias and source-two alias.
+					destination := (masking + 2) % 3
+					row += fmt.Sprintf(",%s%d", bank, destination)
+					fmt.Fprintf(&declarations, "func %s(out *[66]byte,a,b *[64]byte,mask uint64)\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\n", name)
+					source.WriteString("MOVQ out+0(FP),AX\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nMOVQ mask+24(FP),DX\n")
+					source.WriteString("VMOVUPS (BX),Z0\nVMOVUPS (CX),Z1\nVMOVUPS (CX),Z2\nKMOVQ DX,K1\nCMPQ AX,AX\nSTC\n")
+					fmt.Fprintf(&source, "%s\nVMOVUPS Z%d,(AX)\nSETCS 64(AX)\nSETNE 65(AX)\nRET\n", row, destination)
+					fmt.Fprintf(&reference, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", name)
+					fmt.Fprintf(&checks, "    if (checkVectorArithmetic(%s,%q,%d,%d,%d,%d,%d,%d)) return 1;\n", name, row, width, op.bits/8, mode, index/8, masking, destination)
+				}
+			}
+			if count != 48 || count > 64 {
+				t.Fatal("incomplete or oversized runtime batch", count)
+			}
+			reference.WriteString("int main(void) {\n" + checks.String() + "    return 0;\n}\n")
+			goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							execution.compileAndRunLLVM(t, "vector-arithmetic", ir, reference.String(), level)
+						})
+					}
+				})
+			}
+			t.Log("48 kernels × 80 inputs × four masks; every output/alias byte, input and flag canaries")
+		})
+	}
+}
+
+const x86VectorArithmeticResultReference = `
+typedef void (*vectorArithmetic)(uint8_t*, const uint8_t*, const uint8_t*, uint64_t);
+
+static int checkVectorArithmetic(vectorArithmetic fn, const char *name,
+                                 int width, int bytes, int mode, int subtract,
+                                 int masking, int destination) {
+    const uint64_t masks[] = {0, UINT64_MAX, UINT64_C(0x5555555555555555), UINT64_C(1) << 63};
+    for (int sample = 0; sample < 80; ++sample) {
+        uint8_t a[64], b[64], originalA[64], originalB[64], out[68];
+        for (int block = 0; block < 4; ++block) {
+            fill(a + block * 16, bytes, sample + block, 0);
+            fill(b + block * 16, bytes, sample + block, 1);
+        }
+        memcpy(originalA, a, sizeof(a));
+        memcpy(originalB, b, sizeof(b));
+        for (unsigned m = 0; m < sizeof(masks) / sizeof(masks[0]); ++m) {
+            uint64_t mask = masks[m];
+            uint32_t before = _mm_getcsr();
+            memset(out, 0xa7, sizeof(out));
+            fn(out + 1, a, b, mask);
+            if (_mm_getcsr() != before || out[0] != 0xa7 || out[67] != 0xa7 ||
+                out[65] != 1 || out[66] != 0 ||
+                memcmp(a, originalA, sizeof(a)) || memcmp(b, originalB, sizeof(b))) {
+                fprintf(stderr, "%s state/input/canary mismatch\n", name);
+                return 1;
+            }
+            for (int i = 0; i < 64; ++i) {
+                uint8_t want = 0;
+                if (i < width) {
+                    int index = i / bytes;
+                    if (!masking || ((mask >> index) & 1)) {
+                        uint64_t x = lane(a + index * bytes, bytes);
+                        uint64_t y = lane(b + index * bytes, bytes);
+                        want = (uint8_t)(math(x, y, bytes, mode, subtract) >> (8 * (i % bytes)));
+                    } else if (masking == 1) {
+                        want = destination == 0 ? a[i] : b[i];
+                    }
+                }
+                if (out[i + 1] != want) {
+                    fprintf(stderr, "%s sample=%d mask=%llx byte=%d got=%x want=%x\n",
+                            name, sample, (unsigned long long)mask, i, out[i + 1], want);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/amd64_vector_broadcast_suffixes.go b/amd64_vector_broadcast_suffixes.go
new file mode 100644
index 000000000..568f0ea31
--- /dev/null
+++ b/amd64_vector_broadcast_suffixes.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type amd64TwoSourcePermuteSuffixes struct {
+	broadcast bool
+	zeroing   bool
+}
+
+func amd64ParseTwoSourcePermuteSuffixes(rawOp, baseOp string) (amd64TwoSourcePermuteSuffixes, error) {
+	var suffixes amd64TwoSourcePermuteSuffixes
+	dot := strings.IndexByte(rawOp, '.')
+	if dot < 0 {
+		return suffixes, nil
+	}
+	parts := strings.Split(rawOp[dot+1:], ".")
+	for index, part := range parts {
+		switch part {
+		case "BCST":
+			if suffixes.broadcast || suffixes.zeroing || index != 0 {
+				return suffixes, fmt.Errorf("amd64 %s has invalid or duplicate .BCST suffix", baseOp)
+			}
+			suffixes.broadcast = true
+		case "Z":
+			if suffixes.zeroing || index != len(parts)-1 {
+				return suffixes, fmt.Errorf("amd64 %s has invalid or duplicate .Z suffix", baseOp)
+			}
+			suffixes.zeroing = true
+		default:
+			return suffixes, fmt.Errorf("amd64 %s has unsupported suffix .%s", baseOp, part)
+		}
+	}
+	return suffixes, nil
+}
diff --git a/amd64_vector_family_test.go b/amd64_vector_family_test.go
new file mode 100644
index 000000000..a9f6596ea
--- /dev/null
+++ b/amd64_vector_family_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func emitX86GoEncodedTestInstruction(t *testing.T, source *strings.Builder, line string, raw bool) {
+	t.Helper()
+	if !raw {
+		source.WriteString(line + "\n")
+		return
+	}
+	code := assembleX87ControlBytes(t, "amd64", "TEXT instruction(SB),4,$0-0\n"+line+"\nRET\n")
+	if len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("Go encoding lacks final RET")
+	}
+	for _, b := range code[:len(code)-1] {
+		fmt.Fprintf(source, "BYTE $%#x\n", b)
+	}
+}
+
+// Shared by native semantic oracles. A single accessible page followed by
+// an inaccessible page detects eager loads from masked-off vector lanes.
+const x86TestGuardPagesC = `
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+static uint8_t *guard;
+static size_t page;
+static uint8_t *guard_mapping;
+static size_t guard_pages;
+
+static int free_guard(void);
+
+static int setup_guard_before(unsigned leading) {
+    if (leading > 1) return 1;
+    guard_pages = 2 + leading;
+#ifdef _WIN32
+    SYSTEM_INFO info;
+    GetSystemInfo(&info);
+    page = info.dwPageSize;
+
+    guard_mapping = VirtualAlloc(NULL, page * guard_pages, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    if (!guard_mapping) return 1;
+    guard = guard_mapping + leading * page;
+    DWORD old;
+    if ((leading && !VirtualProtect(guard_mapping, page, PAGE_NOACCESS, &old)) ||
+            !VirtualProtect(guard + page, page, PAGE_NOACCESS, &old)) {
+        free_guard();
+        return 1;
+    }
+#else
+    long p = sysconf(_SC_PAGESIZE);
+    if (p <= 0) {
+        return 1;
+    }
+    page = (size_t)p;
+
+    guard_mapping = mmap(NULL, page * guard_pages, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    if (guard_mapping == MAP_FAILED) return 1;
+    guard = guard_mapping + leading * page;
+    if ((leading && mprotect(guard_mapping, page, PROT_NONE)) ||
+            mprotect(guard + page, page, PROT_NONE)) {
+        free_guard();
+        return 1;
+    }
+#endif
+    return 0;
+}
+
+static int setup_guard(void) {
+    return setup_guard_before(0);
+}
+
+static int free_guard(void) {
+#ifdef _WIN32
+    return !VirtualFree(guard_mapping, 0, MEM_RELEASE);
+#else
+    return munmap(guard_mapping, page * guard_pages);
+#endif
+}
+`
diff --git a/amd64_vector_test_native.go b/amd64_vector_test_native.go
new file mode 100644
index 000000000..b0dc4e900
--- /dev/null
+++ b/amd64_vector_test_native.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Keep one original memory instruction, including its complete access and
+// fault envelope when FLAGS are discarded. Capturing CF/ZF in the same asm
+// prevents intervening compiler instructions from replacing their values.
+func (c *amd64Ctx) emitVectorTestNativeMemory(ins Instr, form x86VectorTestForm, arch string) error {
+	if !x86ScalarFloatIntegerNativeTarget(arch, c.targetTriple) {
+		return fmt.Errorf("%w: vector-test memory needs its original x86 target", ErrProbeNeedsContext)
+	}
+	value, err := c.loadPackedCompareBytes(ins.Args[1], form.byteWidth)
+	if err != nil {
+		return err
+	}
+	pointer, pointerType, _, err := c.packedVectorMemoryPointer(ins.Args[0])
+	if err != nil {
+		return err
+	}
+	operand := "$2"
+	switch pointerType {
+	case "ptr addrspace(256)":
+		operand = "%gs:" + operand
+	case "ptr addrspace(257)":
+		operand = "%fs:" + operand
+	}
+	assembly := strings.ToLower(string(ins.Op)) + " " + operand + ", $3; setb $0; sete $1"
+	// A bitcast-only floating carrier needs AVX, not AVX2, for a Y input.
+	// No floating arithmetic or conversion can change the source bits.
+	carrier, result := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i8> %s to <%d x float>\n", carrier, form.byteWidth, value, form.byteWidth/4)
+	fmt.Fprintf(c.b, "  %%%s = call { i8, i8 } asm sideeffect %q, %q(%s elementtype([%d x i8]) %s, <%d x float> %%%s)\n",
+		result, assembly, "=q,=q,*m,x,~{flags},~{fpsr},~{memory}", pointerType, form.byteWidth,
+		pointer, form.byteWidth/4, carrier)
+	for index, slot := range []string{c.flagsCFSlot, c.flagsZSlot} {
+		byteValue, boolean := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue { i8, i8 } %%%s, %d\n", byteValue, result, index)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne i8 %%%s, 0\n", boolean, byteValue)
+		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", boolean, slot)
+	}
+	c.clearX86StatusFlags(x86StatusAll &^ (x86StatusCF | x86StatusZF))
+	return nil
+}
diff --git a/amd64_vector_untracked_test.go b/amd64_vector_untracked_test.go
new file mode 100644
index 000000000..87e5b40bf
--- /dev/null
+++ b/amd64_vector_untracked_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestAMD64UntrackedVectorLoadsProduceLLVMValues(t *testing.T) {
+	c := &amd64Ctx{
+		b:        &strings.Builder{},
+		xRegSlot: map[int]string{},
+		yRegSlot: map[int]string{},
+		zRegSlot: map[int]string{},
+	}
+
+	for _, test := range []struct {
+		name string
+		load func(Reg) (string, error)
+	}{
+		{name: "X0", load: c.loadX},
+		{name: "Y0", load: c.loadY},
+		{name: "Z0", load: c.loadZ},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			value, err := test.load(Reg(test.name))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if value != "zeroinitializer" {
+				t.Fatalf("untracked register value = %q; want an untyped LLVM value", value)
+			}
+		})
+	}
+
+	for _, width := range []int{16, 32, 64} {
+		value := c.bitcastVectorBytesToIntegerLanes(width, width/4, 32, "zeroinitializer")
+		if value == "" {
+			t.Fatal("bitcast produced no value")
+		}
+		want := fmt.Sprintf("bitcast <%d x i8> zeroinitializer to <%d x i32>", width, width/4)
+		if !strings.Contains(c.b.String(), want) {
+			t.Fatalf("missing valid LLVM bitcast %q in:\n%s", want, c.b.String())
+		}
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const triple = "x86_64-unknown-linux-gnu"
+	ir := "target triple = \"" + triple + "\"\n" +
+		"define void @untracked_vector_loads() {\nentry:\n" +
+		c.b.String() + "  ret void\n}\n"
+	compileLLVMToObject(t, llc, triple,
+		"amd64-untracked-vector-loads.ll", "amd64-untracked-vector-loads.o", ir)
+}
diff --git a/amd64_vector_value_memory.go b/amd64_vector_value_memory.go
new file mode 100644
index 000000000..fad88ea52
--- /dev/null
+++ b/amd64_vector_value_memory.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "fmt"
+
+// cmd/asm accepts extended GP address spellings in mode32, but their source
+// names do not supply physical 386 registers. Keep that missing role distinct
+// from an invalid operand format; never create numerical/address facts or
+// silently allocate an AMD64 register while translating a 386 function.
+func x86VectorValueMemoryInput(ins Instr, arch string) (Instr, bool) {
+	if arch != "386" {
+		return ins, false
+	}
+	local, contextual := ins, false
+	for index, operand := range ins.Args {
+		// Go's mode32 SIB encoder rejects extended base/index registers;
+		// only the ordinary non-SIB base path accepts these spellings.
+		if operand.Kind != OpMem || operand.Mem.Index != "" || operand.Mem.Scale != 0 ||
+			operand.Mem.Base == "R12" || x86PackedShiftMemoryValid(operand, arch) {
+			continue
+		}
+		shape := operand
+		if shape.Mem.Off == int64(uint32(shape.Mem.Off)) {
+			shape.Mem.Off = int64(int32(shape.Mem.Off))
+		}
+		if x86PackedShiftMemoryValid(shape, "amd64") {
+			if !contextual {
+				local.Args = append([]Operand(nil), ins.Args...)
+			}
+			operand.Mem.Base = AX
+			local.Args[index], contextual = operand, true
+		}
+	}
+	return local, contextual
+}
+
+func x86VectorValueMemoryContext(ins Instr) error {
+	return fmt.Errorf("%w: 386 %s address has no bound physical extended-GP role: %q", ErrProbeNeedsContext, ins.Op, ins.Raw)
+}
diff --git a/amd64_vector_zero_forms.go b/amd64_vector_zero_forms.go
new file mode 100644
index 000000000..7d497cd00
--- /dev/null
+++ b/amd64_vector_zero_forms.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86VectorZeroSpec struct {
+	firstByte int
+	vexLength byte
+}
+
+// Go's complete _yvzeroall table has no operands or suffixes. VEX.L selects
+// the semantic operation, not the register width. Intel SDM Vol. 2C specifies
+// only registers 0-15 in 64-bit mode and 0-7 otherwise; Z16-Z31 are unchanged.
+var x86VectorZeroSpecs = map[Op]x86VectorZeroSpec{
+	"VZEROUPPER": {firstByte: 16, vexLength: 0},
+	"VZEROALL":   {firstByte: 0, vexLength: 1},
+}
+
+type x86VectorZeroForm struct {
+	spec      x86VectorZeroSpec
+	registers int
+}
+
+func x86VectorZeroProperties(ins Instr, arch string) (x86VectorZeroForm, bool, error) {
+	opcode := strings.ToUpper(string(ins.Op))
+	base, _, suffix := strings.Cut(opcode, ".")
+	spec, recognized := x86VectorZeroSpecs[Op(base)]
+	if !recognized {
+		return x86VectorZeroForm{}, false, nil
+	}
+	if suffix || len(ins.Args) != 0 {
+		return x86VectorZeroForm{}, true, fmt.Errorf("%s requires zero operands and no suffix: %q", base, ins.Raw)
+	}
+	registers := 16
+	if arch == "386" {
+		registers = 8
+	} else if arch != "amd64" && arch != "" {
+		return x86VectorZeroForm{}, true, fmt.Errorf("%s requires amd64 or 386, got %q", base, arch)
+	}
+	return x86VectorZeroForm{spec: spec, registers: registers}, true, nil
+}
+
+func (c *amd64Ctx) lowerVectorZero(op Op, ins Instr) (bool, bool, error) {
+	base, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	if _, recognized := x86VectorZeroSpecs[Op(base)]; !recognized {
+		return false, false, nil
+	}
+	if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, false, fmt.Errorf("vector zero dispatch/source opcode mismatch: %s/%s", op, ins.Op)
+	}
+	ins.Op = op
+	form, recognized, err := x86VectorZeroProperties(ins, c.goarch)
+	if err != nil || !recognized {
+		return recognized, false, err
+	}
+	for register := 0; register < form.registers; register++ {
+		for _, view := range []struct {
+			bytes int
+			slots map[int]string
+		}{{16, c.xRegSlot}, {32, c.yRegSlot}, {64, c.zRegSlot}} {
+			slot, live := view.slots[register]
+			if !live || view.bytes <= form.spec.firstByte {
+				continue
+			}
+			pointer := slot
+			alignment := view.bytes
+			if form.spec.firstByte != 0 {
+				tail := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 %d\n", tail, slot, form.spec.firstByte)
+				pointer = "%" + tail
+				alignment = form.spec.firstByte
+			}
+			// A narrow tail store preserves the low X bytes independently in
+			// every live alias. No initial SIMD value or native memory is read.
+			// Omitting align lets LLVM infer 64 for the 48-byte Z tail,
+			// although slot+16 is only 16-aligned. That can produce a
+			// faulting aligned YMM store even to our own stack allocation.
+			fmt.Fprintf(c.b, "  store <%d x i8> zeroinitializer, ptr %s, align %d\n",
+				view.bytes-form.spec.firstByte, pointer, alignment)
+		}
+	}
+	return true, false, nil
+}
+
+func x86CallerVectorZeroStep(form x86VectorZeroForm, state *x86SourceStackState) bool {
+	x86VectorZeroDefinedBytes(form, state.vectors)
+	return true
+}
+
+// Numerical register facts only. Source permissions and executable lowering
+// remain with each consumer; neither an input nor a memory byte is supplied.
+func x86VectorZeroDefinedBytes(form x86VectorZeroForm, vectors map[Reg]uint64) {
+	zeroed := ^x86CallerVectorByteMask(int64(form.spec.firstByte))
+	for register := 0; register < form.registers; register++ {
+		root := Reg(fmt.Sprintf("Z%d", register))
+		vectors[root] |= zeroed
+	}
+}
diff --git a/amd64_vector_zero_forms_test.go b/amd64_vector_zero_forms_test.go
new file mode 100644
index 000000000..f89ec7b1b
--- /dev/null
+++ b/amd64_vector_zero_forms_test.go
@@ -0,0 +1,282 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VectorZeroEveryGoOpcodeAttribute(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	tables := string(data)
+	start := strings.Index(tables, "var _yvzeroall = []ytab{")
+	if start < 0 {
+		t.Fatal("actual Go zero-operand family disappeared")
+	}
+	table := strings.SplitN(tables[start:], "\n}", 2)[0]
+	if strings.Count(table, "zcase:") != 1 || !strings.Contains(table, "{zcase: Zvex, zoffset: 2, args: argList{}},") {
+		t.Fatalf("complete actual Go vector-zero operand table changed: %s", table)
+	}
+	if len(x86VectorZeroSpecs) != 2 || strings.Count(tables, "ytab: _yvzeroall,") != 2 {
+		t.Fatal("incomplete vector-zero family")
+	}
+	for _, row := range []struct {
+		op    Op
+		width string
+		first int
+		bytes string
+	}{
+		{"VZEROUPPER", "vex128", 16, "c5 f8 77"},
+		{"VZEROALL", "vex256", 0, "c5 fc 77"},
+	} {
+		start := strings.Index(tables, "{as: A"+string(row.op)+",")
+		if start < 0 {
+			t.Fatalf("actual Go omitted %s", row.op)
+		}
+		entry := strings.SplitN(tables[start:], "\n\t}},", 2)[0]
+		if strings.Count(entry, "avxEscape") != 1 || !strings.Contains(entry, "ytab: _yvzeroall, prefix: Pavx,") || !strings.Contains(entry, "avxEscape | "+row.width+" | vex0F | vexW0, 0x77,") {
+			t.Fatalf("complete actual Go zero attributes changed: %s", entry)
+		}
+		if x86VectorZeroSpecs[row.op].firstByte != row.first {
+			t.Fatalf("%s implicit byte range differs", row.op)
+		}
+		for _, arch := range []string{"amd64", "386"} {
+			listing, err := x86ExtensionGoListing(t, arch, string(row.op))
+			if err != nil || !strings.Contains(listing, row.bytes) {
+				t.Fatalf("actual Go %s/%s byte identity: %v\n%s", arch, row.op, err, listing)
+			}
+		}
+	}
+}
+
+func TestX86VectorZeroDispatchAndImplicitModeRangeBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []Op{"VZEROUPPER", "VZEROALL"} {
+			for _, identity := range []Op{"", opcode, Op(strings.ToLower(string(opcode))), "UNKNOWN", "VZEROALL.Z"} {
+				var output strings.Builder
+				ctx := &amd64Ctx{b: &output, goarch: arch, xRegSlot: map[int]string{}, yRegSlot: map[int]string{}, zRegSlot: map[int]string{}}
+				for register := 0; register < 32; register++ {
+					ctx.xRegSlot[register] = fmt.Sprintf("%%x%d", register)
+					ctx.yRegSlot[register] = fmt.Sprintf("%%y%d", register)
+					ctx.zRegSlot[register] = fmt.Sprintf("%%z%d", register)
+				}
+				ins := Instr{Op: identity}
+				original := ins
+				known, term, err := ctx.lowerVec(opcode, ins)
+				conflict := identity == "UNKNOWN" || identity == "VZEROALL.Z"
+				if !known || term || (err != nil) != conflict || conflict && output.Len() != 0 || !reflect.DeepEqual(ins, original) {
+					t.Fatalf("dispatch identity %s/%s/%s: %t/%t/%v", arch, opcode, identity, known, term, err)
+				}
+				if conflict {
+					continue
+				}
+				last, views := 16, 3
+				if arch == "386" {
+					last = 8
+				}
+				if opcode == "VZEROUPPER" {
+					views = 2
+				}
+				if strings.Count(output.String(), "  store ") != last*views {
+					t.Fatalf("%s/%s wrong implicit bank writes:\n%s", arch, opcode, output.String())
+				}
+				for register := last; register < 32; register++ {
+					for _, bank := range []string{"x", "y", "z"} {
+						if strings.Contains(output.String(), fmt.Sprintf("ptr %%%s%d\n", bank, register)) || strings.Contains(output.String(), fmt.Sprintf("ptr %%%s%d,", bank, register)) {
+							t.Fatalf("%s touched excluded %s%d", opcode, bank, register)
+						}
+					}
+				}
+			}
+			known, _, err := (&amd64Ctx{b: &strings.Builder{}, goarch: arch}).lowerVec(Op(string(opcode)+".Z"), Instr{})
+			if !known || err == nil {
+				t.Fatal("empty helper identity washed away a suffix")
+			}
+		}
+	}
+}
+
+func TestX86VectorZeroTailAlignment(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []Op{"VZEROUPPER", "VZEROALL"} {
+			t.Run(arch+"/"+string(opcode), func(t *testing.T) {
+				var output strings.Builder
+				ctx := &amd64Ctx{
+					b: &output, goarch: arch,
+					xRegSlot: map[int]string{0: "%x0"},
+					yRegSlot: map[int]string{0: "%y0"},
+					zRegSlot: map[int]string{0: "%z0"},
+				}
+				if _, _, err := ctx.lowerVectorZero(opcode, Instr{Op: opcode}); err != nil {
+					t.Fatal(err)
+				}
+				stores := 0
+				for _, line := range strings.Split(output.String(), "\n") {
+					var width int
+					if _, err := fmt.Sscanf(line, "  store <%d x i8>", &width); err != nil {
+						continue
+					}
+					stores++
+					alignment := width
+					if opcode == "VZEROUPPER" {
+						// Both 32- and 64-byte slots advance by 16. Neither
+						// tail may inherit the full slot's natural alignment.
+						alignment = 16
+					}
+					if !strings.HasSuffix(line, fmt.Sprintf(", align %d", alignment)) {
+						t.Fatalf("tail store overstates or omits its alignment: %s", line)
+					}
+				}
+				want := 3
+				if opcode == "VZEROUPPER" {
+					want = 2
+				}
+				if stores != want {
+					t.Fatalf("got %d live stores, want %d", stores, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86VectorZeroCompleteGoFormsFiveObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const source = "TEXT zeroforms(SB),4,$0-0\nVZEROUPPER\nVZEROALL\nWORD $0xf8c5\nBYTE $0x77\nWORD $0xfcc5\nBYTE $0x77\nRET\n"
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"zeroforms": {Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "vector-zero.ll", "vector-zero.o", ir)
+		})
+	}
+}
+
+func TestX86VectorZeroRejectsMalformedGoFormsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []string{"VZEROUPPER", "VZEROALL"} {
+			for _, tail := range []string{" X0", " AX", " K1", " $1", ".Z", ".BCST", ".SAE", ".RN_SAE"} {
+				row := opcode + tail
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+					requireX86GoAssemblerResult(t, arch, source, false)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before := output.String()
+					ok, _, err := ctx.lowerVec(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1])
+					if !ok || err == nil || output.String() != before {
+						t.Fatalf("malformed zero form emitted/accepted: %t/%v", ok, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86VectorZeroRawOpcodeLengthIdentity(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, prefix := range [][]byte{{0xc5, 0xf8}, {0xc5, 0xfc}, {0xc4, 0xe1, 0x78}, {0xc4, 0xe1, 0x7c}, {0xc4, 0xe1, 0xf8}, {0xc4, 0xe1, 0xfc}} {
+			code := append(append([]byte(nil), prefix...), 0x77)
+			t.Run(fmt.Sprintf("%d/%x", mode, code), func(t *testing.T) {
+				instructions, err := decodeX86RawDirectiveGroup(code, mode, 0, "actual vector-zero bytes", nil)
+				if err != nil || len(instructions) != 1 {
+					t.Fatalf("raw zero failed: %+v/%v", instructions, err)
+				}
+				want := Op("VZEROUPPER")
+				if prefix[len(prefix)-1]&4 != 0 {
+					want = "VZEROALL"
+				}
+				if instructions[0].Op != want || len(instructions[0].Args) != 0 {
+					t.Fatalf("raw %x became %s, want %s without operands", code, instructions[0].Op, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86VectorZeroReservedRawFormsFailClosed(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		for _, code := range [][]byte{
+			{0xc5, 0xf9, 0x77}, {0xc5, 0xfb, 0x77}, {0xc5, 0xe8, 0x77},
+			{0xc4, 0xe1, 0xf9, 0x77}, {0xc4, 0xe1, 0xec, 0x77},
+			{0x66, 0xc5, 0xf8, 0x77}, {0xf2, 0xc5, 0xfc, 0x77}, {0xf0, 0xc5, 0xf8, 0x77},
+			{0xc5}, {0xc5, 0xf8}, {0xc4, 0xe1, 0xf8},
+		} {
+			t.Run(fmt.Sprintf("%d/%x", mode, code), func(t *testing.T) {
+				instructions, err := decodeX86RawDirectiveGroup(code, mode, 0, "reserved zero encoding", nil)
+				if err == nil {
+					t.Fatalf("reserved/truncated raw %x accepted: %+v", code, instructions)
+				}
+				if strings.Contains(fmt.Sprint(instructions), "EMMS") {
+					t.Fatalf("VEX zero was silently decoded as legacy EMMS: %+v", instructions)
+				}
+			})
+		}
+	}
+}
+
+func TestX86VectorZeroAllRawVEXFieldsAndModeDisambiguation(t *testing.T) {
+	accepted := 0
+	for _, mode := range []int{32, 64} {
+		for _, vex3 := range []bool{false, true} {
+			extensions := 1
+			if vex3 {
+				extensions = 8
+			}
+			for extension := 0; extension < extensions; extension++ {
+				for payload := 0; payload < 256; payload++ {
+					code := []byte{0xc5, byte(payload), 0x77}
+					if vex3 {
+						code = []byte{0xc4, byte(extension<<5) | 1, byte(payload), 0x77}
+					}
+					ins, length, known, err := decodedX86VectorZeroInstruction(code, mode)
+					legacy := mode == 32 && code[1]&0xc0 != 0xc0
+					valid := !legacy && payload&3 == 0 && payload&0x78 == 0x78
+					if legacy {
+						if known || err != nil {
+							t.Fatalf("%x mode32 LES/LDS was claimed as VEX zero: %t/%v", code, known, err)
+						}
+						continue
+					}
+					if !known || (err == nil) != valid {
+						t.Fatalf("%x mode%d validity: %t/%v want %t", code, mode, known, err, valid)
+					}
+					if !valid {
+						continue
+					}
+					want := Op("VZEROUPPER")
+					if payload&4 != 0 {
+						want = "VZEROALL"
+					}
+					if ins.Op != want || len(ins.Args) != 0 || length != len(code) {
+						t.Fatalf("%x mode%d changed zero-operation/length: %+v/%d", code, mode, ins, length)
+					}
+					accepted++
+				}
+			}
+		}
+	}
+	if accepted != 46 {
+		t.Fatalf("complete implicit VEX field axis accepted %d, want 46", accepted)
+	}
+}
diff --git a/amd64_vector_zero_runtime_test.go b/amd64_vector_zero_runtime_test.go
new file mode 100644
index 000000000..5fbb5d49b
--- /dev/null
+++ b/amd64_vector_zero_runtime_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86VectorZeroWholeBankSemantics(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	source, sigs, declarations, checks := x86VectorZeroRuntimeFixture(t)
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations + `
+static int checkVectorZero(void (*program)(uint8_t*,const uint8_t*,uint64_t),const char *name,int clearLow) {
+ for(int round=0;round<16;++round) {
+  uint8_t input[2050],output[3596],original[2050];
+  for(int i=0;i<2050;++i) input[i]=(uint8_t)(i*73+round*19+1);
+  memcpy(original,input,sizeof(input));
+  memset(output,0xc3,sizeof(output));
+  uint64_t mask=UINT64_C(0x8123456789abcdef)^(uint64_t)round;
+  uint32_t saved,before=0x1f80|((round%4)<<13)|round,after;
+  __asm__ volatile("stmxcsr %0" : "=m"(saved));
+  __asm__ volatile("ldmxcsr %0" : : "m"(before));
+  program(output+1,input+1,mask);
+  __asm__ volatile("stmxcsr %0" : "=m"(after));
+  __asm__ volatile("ldmxcsr %0" : : "m"(saved));
+  uint64_t gotMask;
+  memcpy(&gotMask,output+3587,8);
+  if(after!=before || output[0]!=0xc3 || output[3595]!=0xc3 || output[3585]!=1 || output[3586]!=0 || gotMask!=mask || memcmp(input,original,sizeof(input))) {
+   fprintf(stderr,"%s flags/MXCSR/K/input/canary failure\n",name);
+   return 1;
+  }
+  for(int reg=0;reg<32;++reg) {
+   const int widths[]={16,32,64},offsets[]={0,16,48};
+   for(int view=0;view<3;++view) for(int byte=0;byte<widths[view];++byte) {
+    uint8_t want=reg<16 && (clearLow || byte>=16) ? 0 : input[1+reg*64+byte];
+    uint8_t got=output[1+reg*112+offsets[view]+byte];
+    if(got!=want) {
+     fprintf(stderr,"%s round=%d reg=%d width=%d byte=%d got=%x want=%x\n",name,round,reg,widths[view],byte,got,want);
+     return 1;
+    }
+   }
+  }
+ }
+ return 0;
+}
+int main(void) {
+` + checks + "return 0;\n}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "vector-zero-complete", triple, ir, main, prefix)
+	t.Log("8 named/VEX2/VEX3/WIG programs; 16 independent complete X/Y/Z-bank, flags, MXCSR, mask and canary inputs each")
+}
+
+func x86VectorZeroRuntimeFixture(t *testing.T) (string, map[string]FuncSig, string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for index, row := range []struct {
+		instruction string
+		clearLow    bool
+	}{
+		{"VZEROUPPER", false}, {"VZEROALL", true},
+		{"WORD $0xf8c5\nBYTE $0x77", false}, {"WORD $0xfcc5\nBYTE $0x77", true},
+		{"LONG $0x77f8e1c4", false}, {"LONG $0x77fce1c4", true},
+		{"LONG $0x7778e1c4", false}, {"LONG $0x777ce1c4", true},
+	} {
+		name := fmt.Sprintf("vectorzero%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ out+0(FP),AX\nMOVQ in+8(FP),BX\nMOVQ mask+16(FP),DX\nKMOVQ DX,K1\n", name)
+		for register := 0; register < 32; register++ {
+			fmt.Fprintf(&source, "VMOVUPS %d(BX),Z%d\n", register*64, register)
+		}
+		source.WriteString("CMPQ AX,AX\nSTC\n")
+		fmt.Fprintln(&source, row.instruction)
+		for register := 0; register < 32; register++ {
+			for _, view := range []struct {
+				bank string
+				off  int
+			}{{"X", 0}, {"Y", 16}, {"Z", 48}} {
+				fmt.Fprintf(&source, "VMOVUPS %s%d,%d(AX)\n", view.bank, register, register*112+view.off)
+			}
+		}
+		source.WriteString("SETCS 3584(AX)\nSETNE 3585(AX)\nKMOVQ K1,DX\nMOVQ DX,3586(AX)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: I64, Index: 2, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+		fmt.Fprintf(&checks, "if(checkVectorZero(%s,\"%s\",%d)) return 1;\n", name, name, x86FloatAddSubBoolInt(row.clearLow))
+	}
+	return source.String(), sigs, declarations.String(), checks.String()
+}
diff --git a/amd64_vex_byte_effects.go b/amd64_vex_byte_effects.go
new file mode 100644
index 000000000..324d91f12
--- /dev/null
+++ b/amd64_vex_byte_effects.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import "strings"
+
+// This is a typed dependency adapter, not a source/storage authority or an
+// opcode whitelist. Each family retains its complete existing operand parser.
+// The current consumer explicitly closes only non-masked VEX; EVEX storage,
+// writemasks and EVEX broadcasts remain with their separately validated owners.
+func x86UnmaskedVEXByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !strings.HasPrefix(strings.ToUpper(string(op)), "V") {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if form, known, err := x86PackedArithmeticProperties(ins.Op, ins, arch, x86PackedArithmeticAdd|x86PackedArithmeticSubtract); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm, true, err)
+	}
+	if form, known, err := x86PackedBinaryEffectProperties(op, ins, arch); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm, form.vex, err)
+	}
+	if form, known, err := x86IntegerMinMaxProperties(op, ins, arch); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm, form.spec.laneBits <= 32, err)
+	}
+	if form, known, err := x86PackedLogicalProperties(ins, arch); known {
+		effect, known, err := x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm,
+			form.spec.encoding != x86PackedLogicalEVEX, err)
+		if err == nil {
+			effect = x86PackedLogicalZeroDependencies(ins, form, effect)
+		}
+		return effect, known, err
+	}
+	if form, known, err := x86ByteShuffleProperties(op, ins, arch); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form, true, err)
+	}
+	if form, known, err := x86CLMULProperties(op, ins, arch); known {
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		if form.legacy || !x86LowVEXVectorOperands(ins) {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("carryless-multiply effect requires its separate non-VEX consumer: %s", ins.Op)
+		}
+		return x86CLMULDependencyEffect(ins, form), true, nil
+	}
+	local := ins
+	local.Op = op
+	if form, known, err := x86InsertExtractProperties(local, arch); known && !form.spec.scalar {
+		if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("block-transfer dispatch/source mismatch: %s/%s", op, ins.Op)
+		}
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		if !form.spec.vex || !x86LowVEXVectorOperands(ins) {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("block-transfer effect requires its separate non-VEX consumer: %s", ins.Op)
+		}
+		return x86BlockTransferDependencyEffect(ins, form), true, nil
+	}
+	if form, known, err := x86ImmediateShuffleProperties(local, arch); known {
+		if ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("immediate-shuffle dispatch/source mismatch: %s/%s", op, ins.Op)
+		}
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		if form.spec.legacy || form.spec.mmx || form.mask >= 0 || form.broadcast || form.zeroing || !x86LowVEXVectorOperands(ins) {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("shuffle effect requires its separate non-VEX consumer: %s", ins.Op)
+		}
+		return x86ImmediateShuffleDependencyEffect(ins, form), true, nil
+	}
+	if form, known, err := x86PackedAlignProperties(op, ins, arch); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm,
+			form.spec.encoding != x86PackedLogicalEVEX, err)
+	}
+	if form, known, err := x86ImmediateBlendProperties(op, ins, arch); known {
+		binary := x86PackedBinaryForm{
+			byteWidth: form.byteWidth, first: form.source, second: form.base, destination: form.destination,
+			legacy: form.legacy, mask: -1, memory: -1,
+		}
+		if form.memory {
+			binary.memory, binary.memoryBytes = form.source, form.byteWidth
+		}
+		return x86UnmaskedVEXBinaryEffect(ins, binary, true, err)
+	}
+	if form, known, err := x86Permute128Properties(op, ins, arch); known {
+		return x86UnmaskedVEXBinaryEffect(ins, form.x86PackedBinaryForm, true, err)
+	}
+	if form, known, err := x86PackedShiftProperties(op, ins, arch); known {
+		return x86UnmaskedVEXShiftEffect(ins, form, err)
+	}
+	if form, known, err := x86BroadcastProperties(op, ins, arch); known {
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		if !form.vex || form.mask >= 0 || form.zeroing || !x86LowVEXVectorOperands(ins) || ins.Args[0].Kind == OpImm {
+			return x86TypedByteEffect{}, true, goAMD64FrameContext("broadcast effect requires its separate non-VEX consumer: %s", ins.Op)
+		}
+		source := x86TypedByteOperand{index: 0, operand: ins.Args[0], width: int64(form.sourceBytes), read: true}
+		if source.operand.Kind == OpReg {
+			// Register storage keeps its complete X alias, but only the
+			// repeated scalar bytes are inputs. Memory reads the exact tuple.
+			source.width, source.requiredBytes = 16, x86CallerVectorByteMask(int64(form.sourceBytes))
+		}
+		return x86TypedByteEffect{
+			vector: x86TypedVectorEffect{x86TypedVectorUpperZero, 1},
+			operands: []x86TypedByteOperand{
+				source,
+				{index: form.destination, operand: ins.Args[form.destination], width: int64(form.byteWidth), write: true},
+			},
+		}, true, nil
+	}
+	return x86TypedByteEffect{}, false, nil
+}
+
+func x86BlockTransferDependencyEffect(ins Instr, form x86InsertExtractForm) x86TypedByteEffect {
+	inputBytes, baseBytes := form.blockInputBytes()
+	width := form.width
+	if form.spec.insert {
+		width = form.spec.chunk
+	}
+	source := x86TypedByteOperand{index: form.source, operand: ins.Args[form.source], width: int64(width), read: true}
+	if source.operand.Kind == OpReg {
+		source.requiredBytes = inputBytes
+	}
+	effect := x86TypedByteEffect{
+		vector:   x86TypedVectorEffect{x86TypedVectorUpperZero, 1},
+		operands: make([]x86TypedByteOperand, 0, 3),
+	}
+	effect.operands = append(effect.operands, source)
+	if form.spec.insert {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: form.base, operand: ins.Args[form.base], width: int64(form.width), read: true, requiredBytes: baseBytes,
+		})
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{
+		index: form.destination, operand: ins.Args[form.destination], width: int64(form.output), write: true,
+	})
+	return effect
+}
+
+// VEX has only the low physical X/Y bank. This check does not infer an
+// encoding from the opcode prefix: opcode-specific EVEX-only forms are also
+// excluded by the validated family descriptor passed by each adapter.
+func x86LowVEXVectorOperands(ins Instr) bool {
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg {
+			continue
+		}
+		width := amd64VectorByteWidth(operand.Reg)
+		if width > 32 || !amd64VEXVectorRegister(operand, width) {
+			return false
+		}
+	}
+	return true
+}
+
+func x86UnmaskedVEXBinaryEffect(ins Instr, form x86PackedBinaryForm, vex bool, err error) (x86TypedByteEffect, bool, error) {
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	if !vex || form.legacy || form.mmx || form.mask >= 0 || form.broadcast || form.zeroing || !x86LowVEXVectorOperands(ins) {
+		return x86TypedByteEffect{}, true, goAMD64FrameContext("vector effect requires its separate non-VEX consumer: %s", ins.Op)
+	}
+	return x86PackedBinaryDependencyEffect(ins, form, ins.Args[form.first]), true, nil
+}
+
+func x86UnmaskedVEXShiftEffect(ins Instr, form x86PackedShiftForm, err error) (x86TypedByteEffect, bool, error) {
+	if err != nil {
+		return x86TypedByteEffect{}, true, err
+	}
+	// The grammar's numerical dimensions distinguish VEX from the EVEX-only
+	// word-per-lane and arithmetic-qword forms without a second opcode list.
+	if form.legacy || form.mmx || form.mask >= 0 || form.broadcast || form.zeroing || !x86LowVEXVectorOperands(ins) ||
+		form.arithmetic && form.laneBits == 64 || form.countMode == x86PackedShiftPerLane && form.laneBits == 16 ||
+		form.countOperand.Kind == OpImm && form.memory == form.data {
+		return x86TypedByteEffect{}, true, goAMD64FrameContext("shift effect requires its separate non-VEX consumer: %s", ins.Op)
+	}
+	return x86PackedShiftDependencyEffect(ins, form), true, nil
+}
+
+// Numerical register dependencies and native access widths are separate axes.
+// Reuse the result model for the union of bytes needed by every output byte;
+// a uniform register count ignores its upper qword, but memory still reads m128.
+func x86PackedShiftDependencyEffect(ins Instr, form x86PackedShiftForm) x86TypedByteEffect {
+	width, countWidth := int64(form.byteWidth), int64(form.byteWidth)
+	if form.countOperand.Kind == OpImm {
+		countWidth = 1
+	} else if form.countMode == x86PackedShiftUniform {
+		countWidth = 16 // The full m128 access is observable, not just its low qword.
+	}
+	var dataBytes, countBytes uint64
+	for output := 0; output < form.byteWidth; output++ {
+		data, count := x86PackedShiftByteInputs(form, output)
+		dataBytes, countBytes = dataBytes|data, countBytes|count
+	}
+	vector := x86TypedVectorEffect{x86TypedVectorUpperZero, 1}
+	if form.legacy {
+		vector = x86TypedVectorEffect{x86TypedVectorUpperPreserve, 16}
+	}
+	effect := x86TypedByteEffect{
+		vector: vector,
+		operands: []x86TypedByteOperand{
+			{index: form.count, operand: form.countOperand, width: countWidth, read: true},
+			{index: form.data, operand: ins.Args[form.data], width: width, read: dataBytes != 0 || ins.Args[form.data].Kind != OpReg},
+			{index: form.destination, operand: ins.Args[form.destination], width: width, write: true},
+		},
+	}
+	if form.countOperand.Kind == OpReg {
+		effect.operands[0].requiredBytes = countBytes
+	}
+	if ins.Args[form.data].Kind == OpReg {
+		effect.operands[1].requiredBytes = dataBytes
+	}
+	return effect
+}
diff --git a/amd64_vsib_forms.go b/amd64_vsib_forms.go
new file mode 100644
index 000000000..57dd5080f
--- /dev/null
+++ b/amd64_vsib_forms.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A VSIB form describes physical operands, not initialized values, backing
+// storage or caller authority. Prefetch has no data operand or result width.
+type x86VSIBForm struct {
+	opcode                  Op
+	spec                    amd64GatherSpec
+	memory, data, mask      Operand
+	indexBytes, dataBytes   int
+	evex, scatter, prefetch bool
+}
+
+func x86VSIBProperties(ins Instr, arch string) (x86VSIBForm, bool, error) {
+	name, _, suffix := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	f := x86VSIBForm{opcode: Op(name)}
+	if spec, ok := amd64GatherSpecs[f.opcode]; ok {
+		f.spec = spec
+	} else if spec, ok := amd64ScatterSpecs[name]; ok {
+		f.spec, f.evex, f.scatter = spec, true, true
+	} else if spec, ok := amd64VSIBPrefetchSpecs[f.opcode]; ok {
+		f.spec = amd64GatherSpec{elemBits: spec.elemBits, indexBits: spec.indexBits}
+		f.evex, f.prefetch = true, true
+		f.scatter, f.indexBytes = spec.direction == amd64VSIBPrefetchScatter, spec.indexBytes
+	} else {
+		return f, false, nil
+	}
+	op := f.opcode
+	if suffix {
+		if f.scatter && !f.prefetch {
+			return f, true, fmt.Errorf("amd64 %s has no suffixes in its Go 1.27 table: %q", op, ins.Raw)
+		}
+		return f, true, fmt.Errorf("amd64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+	}
+	if f.prefetch {
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpMem {
+			return f, true, fmt.Errorf("amd64 %s expects K1..K7 and VSIB memory: %q", op, ins.Raw)
+		}
+		f.mask, f.memory = ins.Args[0], ins.Args[1]
+		maskIndex, ok := amd64ParseKReg(f.mask.Reg)
+		if !ok || maskIndex == 0 {
+			return f, true, fmt.Errorf("amd64 %s requires K1..K7: %q", op, ins.Raw)
+		}
+		if amd64VectorByteWidth(f.memory.Mem.Index) != f.indexBytes {
+			return f, true, fmt.Errorf("amd64 %s has the wrong VSIB index width: %q", op, ins.Raw)
+		}
+	} else if f.scatter {
+		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpMem {
+			return f, true, fmt.Errorf("amd64 %s expects data vector, K1-K7, VSIB memory: %q", op, ins.Raw)
+		}
+		f.data, f.mask, f.memory = ins.Args[0], ins.Args[1], ins.Args[2]
+		maskIndex, ok := amd64ParseKReg(f.mask.Reg)
+		if !ok || maskIndex == 0 {
+			return f, true, fmt.Errorf("amd64 %s requires K1-K7: %q", op, ins.Raw)
+		}
+	} else {
+		if len(ins.Args) != 3 {
+			return f, true, fmt.Errorf("amd64 %s expects exactly three operands from its Go 1.27 gather table: %q", op, ins.Raw)
+		}
+		f.evex = ins.Args[0].Kind == OpMem
+		f.mask, f.memory, f.data = ins.Args[0], ins.Args[1], ins.Args[2]
+		if f.evex {
+			f.memory, f.mask = ins.Args[0], ins.Args[1]
+		}
+		if f.memory.Kind != OpMem || f.data.Kind != OpReg {
+			return f, true, fmt.Errorf("amd64 %s expects vector-mask,memory,vector or memory,K-mask,vector: %q", op, ins.Raw)
+		}
+	}
+	if !f.prefetch {
+		f.dataBytes, f.indexBytes = amd64VectorByteWidth(f.data.Reg), amd64VectorByteWidth(f.memory.Mem.Index)
+		if f.dataBytes == 0 || f.indexBytes == 0 || !amd64GatherTableAllows(f.spec.table, f.evex, f.dataBytes, f.indexBytes) {
+			if f.scatter {
+				return f, true, fmt.Errorf("amd64 %s data/index widths are outside its Go 1.27 table: %q", op, ins.Raw)
+			}
+			return f, true, fmt.Errorf("amd64 %s vector widths are outside its Go 1.27 gather table: %q", op, ins.Raw)
+		}
+	}
+	if err := validateX86VSIBMemory(f.memory.Mem, f.indexBytes, arch); err != nil {
+		return f, true, fmt.Errorf("amd64 %s invalid VSIB memory: %q: %w", op, ins.Raw, err)
+	}
+	dataIndex := 0
+	if !f.prefetch {
+		var ok bool
+		dataIndex, ok = amd64GatherRegisterIndex(f.data.Reg, f.dataBytes, f.evex, arch, false)
+		if !ok {
+			if f.scatter {
+				return f, true, fmt.Errorf("amd64 %s data register is outside its Go 1.27 class: %q", op, ins.Raw)
+			}
+			return f, true, fmt.Errorf("amd64 %s destination is outside its Go 1.27 register class: %q", op, ins.Raw)
+		}
+	}
+	indexIndex, ok := amd64GatherRegisterIndex(f.memory.Mem.Index, f.indexBytes, f.evex, arch, true)
+	if !ok {
+		if f.scatter && !f.prefetch {
+			return f, true, fmt.Errorf("amd64 %s VSIB index is outside its Go 1.27 class: %q", op, ins.Raw)
+		}
+		return f, true, fmt.Errorf("amd64 %s VSIB index is outside its Go 1.27 register class: %q", op, ins.Raw)
+	}
+	if !f.scatter && !f.prefetch {
+		if dataIndex == indexIndex {
+			return f, true, fmt.Errorf("amd64 %s index and destination registers must be distinct: %q", op, ins.Raw)
+		}
+		if f.evex {
+			maskIndex, ok := amd64ParseKReg(f.mask.Reg)
+			if f.mask.Kind != OpReg || !ok || maskIndex == 0 {
+				return f, true, fmt.Errorf("amd64 %s EVEX form requires K1..K7: %q", op, ins.Raw)
+			}
+		} else {
+			maskIndex, ok := amd64GatherRegisterIndex(f.mask.Reg, f.dataBytes, false, arch, false)
+			if f.mask.Kind != OpReg || !ok || amd64VectorByteWidth(f.mask.Reg) != f.dataBytes {
+				return f, true, fmt.Errorf("amd64 %s VEX form requires a destination-width vector mask: %q", op, ins.Raw)
+			}
+			if maskIndex == indexIndex || maskIndex == dataIndex {
+				return f, true, fmt.Errorf("amd64 %s mask, index, and destination registers must be distinct: %q", op, ins.Raw)
+			}
+		}
+	}
+	return f, true, nil
+}
+
+func validateX86VSIBMemory(memory MemRef, indexBytes int, arch string) error {
+	if memory.Index == "" || amd64VectorByteWidth(memory.Index) != indexBytes {
+		return fmt.Errorf("expected a VSIB vector index")
+	}
+	if memory.Scale != 0 && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+		return fmt.Errorf("VSIB scale must be 1, 2, 4, or 8")
+	}
+	if memory.Sym != "" {
+		return fmt.Errorf("Go's x86 assembler does not accept an SB base with VSIB")
+	}
+	if memory.Base != "" && !isX86YrlRegisterForArch(memory.Base, arch) {
+		return fmt.Errorf("VSIB base is not a GP register for %s", arch)
+	}
+	if memory.Segment != "" && memory.Segment != FS && memory.Segment != GS {
+		return fmt.Errorf("unsupported VSIB segment %s", memory.Segment)
+	}
+	return nil
+}
diff --git a/amd64_x87_environment_result.go b/amd64_x87_environment_result.go
new file mode 100644
index 000000000..c6ec22802
--- /dev/null
+++ b/amd64_x87_environment_result.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's complete FLDENV row is Px / D9 /4 with one Ym source. This is the
+// 28-byte environment, not FRSTOR's additional register image or a 16-bit
+// operand-size form. Recognizing the shape grants no native memory authority.
+func x86X87EnvironmentReadProperties(ins Instr, arch string) (Operand, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	if name != "FLDENV" {
+		return Operand{}, false, nil
+	}
+	if arch != "386" && arch != "amd64" || dotted || len(ins.Args) != 1 || !isX87MemoryOperand(ins.Args[0]) {
+		return Operand{}, true, fmt.Errorf("%s FLDENV expects memory source in its unsuffixed Go row: %q", arch, ins.Raw)
+	}
+	if err := x86NamedMultiplyMemoryError(ins.Args[0], arch); err != nil {
+		return Operand{}, true, err
+	}
+	return ins.Args[0], true, nil
+}
+
+// Only the paired Software emitter supplies this conditional observation.
+// Its exact volatile read defines CW/SW values, not native bounds, hardware
+// Tag/TOP, initialized F0..F7, an empty stack, or the FRSTOR register image.
+func (c *amd64Ctx) x87EnvironmentReadResultStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	source, known, err := x86X87EnvironmentReadProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || c.x87Mode != X87Software || state.x87 == nil || state.x87.word == nil ||
+		!x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		source.Kind != OpMem || source.Mem.Sym != "" ||
+		!x86OrdinaryNativeMemoryOperand(source, arch) ||
+		!x86ResultIncomingPointerAddressIdentity(source, state, arch) {
+		return false, true
+	}
+	// Initialized logical FP bytes do not imply a contiguous 28-byte native
+	// allocation: each scalar parameter can have its own small alloca. AUTO,
+	// DATA and logical FP require their own complete backing adapters and do
+	// not inherit the ordinary reaching-pointer read role here.
+	if !state.shapeOnly {
+		x87 := state.x87
+		x87.slots, x87.depth, x87.invalid = 0, 0, true
+		x87.integer = [8]uint8{}
+		x87.status, x87.word.control = 0xffff, 0xffff
+	}
+	return true, true
+}
+
+func x86X87RawClearInstruction(ins Instr) bool {
+	origin := ins.x86SourceRaw
+	return origin != nil && origin.op == "FCLEX" && len(origin.args) == 0 &&
+		ins.Op == "FCLEX" && len(ins.Args) == 0
+}
+
+// Called only after the entire original/decoded/normalized raw source has
+// been replayed and bound to the actual function and mode. A local opcode
+// spelling or copied raw token cannot establish that source identity.
+func x86ResultX87BoundRawClear(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+	if !x86X87RawClearInstruction(ins) {
+		return false
+	}
+	named := ins
+	named.x86SourceRaw = nil
+	accepted, known := x86ResultX87WordStep(named, state, owned, resultOffset, arch)
+	return accepted && known
+}
diff --git a/amd64_x87_flag_compare_linux_amd64_test.go b/amd64_x87_flag_compare_linux_amd64_test.go
new file mode 100644
index 000000000..dd5480dc8
--- /dev/null
+++ b/amd64_x87_flag_compare_linux_amd64_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"syscall"
+	"testing"
+)
+
+// A required cross-runtime counterpart, not a host-skipped 386 object test.
+func TestCrossLinuxRuntimeMatrixX87DirectFlagCompare386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x87IA32NativePreflight(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	t.Run("OriginalGo", func(t *testing.T) {
+		x87IA32OriginalGoDirect(t)
+	})
+	x87DirectFlagCompareRuntime(t, "386", "i386-unknown-linux-gnu", func(t *testing.T, ir, main string) {
+		x87IA32CompileAndRunDirect(t, llc, ir, main)
+	})
+	x87IA32RequireNativeHost(t)
+}
+
+func x87IA32RequireNativeHost(t *testing.T) {
+	t.Helper()
+	var kernel syscall.Utsname
+	if err := syscall.Uname(&kernel); err != nil {
+		t.Fatal(err)
+	}
+	var machine []byte
+	for _, value := range kernel.Machine {
+		if value == 0 {
+			break
+		}
+		machine = append(machine, byte(value))
+	}
+	readObservation := func(name string) ([]byte, error) {
+		file, err := os.Open(name)
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+		bytes, err := io.ReadAll(io.LimitReader(file, (4<<20)+1))
+		if err != nil || len(bytes) > 4<<20 {
+			return nil, fmt.Errorf("unbounded native-host observation: %v", err)
+		}
+		return bytes, nil
+	}
+	cpuinfo, err := readObservation("/proc/cpuinfo")
+	if err != nil {
+		t.Fatal(err)
+	}
+	mappings, err := readObservation("/proc/self/maps")
+	if err != nil {
+		t.Fatal(err)
+	}
+	host, err := elf.Open("/proc/self/exe")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer host.Close()
+	if err := x87IA32NativeEnvironment(runtime.GOOS, runtime.GOARCH, string(machine),
+		string(cpuinfo), string(mappings), host); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("IA32 direct host: %s/%s kernel=%s CPUsha=%x mapsha=%x",
+		runtime.GOOS, runtime.GOARCH, machine, sha256.Sum256(cpuinfo), sha256.Sum256(mappings))
+}
diff --git a/amd64_x87_flag_compare_test.go b/amd64_x87_flag_compare_test.go
new file mode 100644
index 000000000..4ba0038c7
--- /dev/null
+++ b/amd64_x87_flag_compare_test.go
@@ -0,0 +1,297 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type x87FlagCompareCase struct {
+	name string
+	op   string
+	lane int
+}
+
+// Go's complete yfcmv/ycompp direct-EFLAGS compare family: both pop modes,
+// both ordered/unordered exception policies, and every ST(i) register.
+func x87FlagCompareCases() []x87FlagCompareCase {
+	var rows []x87FlagCompareCase
+	for _, op := range []string{"FCOMI", "FCOMIP", "FUCOMI", "FUCOMIP"} {
+		for lane := 0; lane < 8; lane++ {
+			rows = append(rows, x87FlagCompareCase{
+				name: fmt.Sprintf("x87flags%d", len(rows)), op: op, lane: lane,
+			})
+		}
+	}
+	return rows
+}
+
+func x87FlagCompareAssembly(arch string) string {
+	width, args := "Q", 8
+	if arch == "386" {
+		width, args = "L", 4
+	}
+	var source strings.Builder
+	for _, row := range x87FlagCompareCases() {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\nFINIT\n", row.name, args, width)
+		// Eight real initialized x87 stack entries. Comparing ST(0) to itself
+		// needs no missing operand, and pop forms still have valid backing.
+		for i := 0; i < 7; i++ {
+			source.WriteString("FMOVD 8(DI),F0\n")
+		}
+		source.WriteString("FMOVD 0(DI),F0\n")
+		fmt.Fprintf(&source, "PUSH%s 16(DI)\nPOPF%s\n", width, width)
+		if strings.HasPrefix(row.op, "FUCOM") {
+			fmt.Fprintf(&source, "%s F0,F%d\n", row.op, row.lane)
+		} else {
+			fmt.Fprintf(&source, "%s F%d,F0\n", row.op, row.lane)
+		}
+		fmt.Fprintf(&source, "PUSHF%s\nPOP%s AX\nMOV%s AX,24(DI)\nLAHF\nMOVB AH,32(DI)\n", width, width, width)
+		source.WriteString("SETCS 33(DI)\nSETPS 34(DI)\nSETEQ 35(DI)\nSETMI 36(DI)\nSETOS 37(DI)\nSETLT 38(DI)\nFINIT\nRET\n")
+	}
+	return source.String()
+}
+
+func x87FlagCompareOptions(arch, triple string) Options {
+	sigs := make(map[string]FuncSig)
+	for _, row := range x87FlagCompareCases() {
+		sigs[row.name] = FuncSig{
+			Name: row.name, Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}
+	}
+	return Options{
+		Goarch: arch, TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	}
+}
+
+func TestX87DirectFlagCompareCompleteGoObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x87FlagCompareAssembly(target.arch)
+			requireX86GoAssemblerResult(t, target.arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, x87FlagCompareOptions(target.arch, target.triple))
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "x87flags.ll", "x87flags.o", ir)
+		})
+	}
+}
+
+const x87FlagCompareOriginalReference = `package original
+
+import (
+ "encoding/binary"
+ "math"
+ "testing"
+)
+
+type kernel struct {
+ call func(*[64]byte)
+ lane int
+ name string
+}
+
+func TestCompleteStatus(t *testing.T) {
+ values := []float64{0, math.Copysign(0, -1), -1, 1, -19.75, 19.75,
+  math.SmallestNonzeroFloat64, math.MaxFloat64, math.Inf(-1), math.Inf(1), math.NaN()}
+ for _, k := range kernels {
+  for _, a := range values {
+   for _, b := range values {
+    for _, seed := range []uint64{0, 0x8d5} {
+     var out [64]byte
+     for i := range out { out[i] = 0xa7 }
+     binary.LittleEndian.PutUint64(out[0:8], math.Float64bits(a))
+     binary.LittleEndian.PutUint64(out[8:16], math.Float64bits(b))
+     binary.LittleEndian.PutUint64(out[16:24], seed)
+     before := out
+     k.call(&out)
+     right := b
+     if k.lane == 0 { right = a }
+     want := uint64(0)
+     switch {
+     case math.IsNaN(a) || math.IsNaN(right): want = 0x45
+     case a == right: want = 0x40
+     case a < right: want = 1
+     }
+     flags := binary.LittleEndian.Uint64(out[24:32]) & 0x8d5
+     if flags != want || out[32] != byte(want) | 2 {
+      t.Fatalf("%s a=%g b=%g seed=%x flags=%x LAHF=%x want=%x", k.name, a, b, seed, flags, out[32], want)
+     }
+     positions := []uint{0, 2, 6, 7, 11}
+     for i, bit := range positions {
+      if out[33+i] != byte(want >> bit & 1) { t.Fatalf("%s SETcc %d", k.name, bit) }
+     }
+     if out[38] != 0 { t.Fatalf("%s SETLT", k.name) }
+     for i, value := range out {
+      if (i < 24 || i >= 39) && value != before[i] { t.Fatalf("%s canary %d", k.name, i) }
+     }
+    }
+   }
+  }
+ }
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX87DirectFlagCompareOriginalGo(t *testing.T) {
+	x86FloatAddSubRuntimeTools(t)
+	x87DirectFlagCompareOriginalGo(t, "amd64", nil)
+}
+
+func x87DirectFlagCompareOriginalGo(t *testing.T, arch string, runner []string) {
+	t.Helper()
+	dir := x87FlagCompareOriginalDirectory(t, arch)
+	args := []string{"test", "-p=2", "-vet=off", "-count=1"}
+	if len(runner) != 0 {
+		args = append(args, "-exec", strings.Join(runner, " "))
+	}
+	args = append(args, ".")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go full x87 status: %v\n%s", err, output)
+	}
+	t.Log("32 initialized original Go kernels, 121 IEEE value pairs, both AF seeds, all six status flags, LAHF, SETcc and byte canaries")
+}
+
+func x87FlagCompareOriginalDirectory(t *testing.T, arch string) string {
+	t.Helper()
+	var declarations, kernels strings.Builder
+	kernels.WriteString("var kernels = []kernel{\n")
+	for _, row := range x87FlagCompareCases() {
+		fmt.Fprintf(&declarations, "func %s(*[64]byte)\n", row.name)
+		fmt.Fprintf(&kernels, "{%s, %d, %q},\n", row.name, row.lane, row.op)
+	}
+	kernels.WriteString("}\n")
+	dir := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":                  "module original\n\ngo 1.20\n",
+		"original.go":             "package original\n" + declarations.String(),
+		"original_" + arch + ".s": x87FlagCompareAssembly(arch),
+		"original_test.go":        x87FlagCompareOriginalReference + kernels.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+const x87FlagCompareCReference = `
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef void (*kernel)(uint8_t *);
+
+static int check(kernel call, const char *name, int lane,
+                 double a, double b, uint64_t seed) {
+ uint8_t out[64], before[64];
+ memset(out, 0xa7, sizeof(out));
+ memcpy(out, &a, 8);
+ memcpy(out + 8, &b, 8);
+ memcpy(out + 16, &seed, 8);
+ memcpy(before, out, sizeof(out));
+ call(out);
+
+ double right = lane == 0 ? a : b;
+ uint64_t want = isnan(a) || isnan(right) ? 0x45 : a == right ? 0x40 : a < right ? 1 : 0;
+ uint64_t flags;
+ memcpy(&flags, out + 24, 8);
+ flags &= 0x8d5;
+ if (flags != want || out[32] != ((want & 255) | 2)) {
+  fprintf(stderr, "%s lane=%d a=%g b=%g seed=%llx flags=%llx lahf=%x want=%llx\n",
+          name, lane, a, b, (unsigned long long)seed,
+          (unsigned long long)flags, out[32], (unsigned long long)want);
+  return 1;
+ }
+ const unsigned positions[] = {0, 2, 6, 7, 11};
+ for (unsigned i = 0; i < 5; i++) {
+  if (out[33+i] != ((want >> positions[i]) & 1)) {
+   return 2;
+  }
+ }
+ if (out[38] != 0) {
+  return 3;
+ }
+ for (unsigned i = 0; i < 64; i++) {
+  if ((i < 24 || i >= 39) && out[i] != before[i]) {
+   return 4;
+  }
+ }
+ return 0;
+}
+`
+
+func x87DirectFlagCompareRuntime(t *testing.T, arch, triple string, run func(*testing.T, string, string)) {
+	x87DirectFlagCompareRuntimeWithMode(t, arch, triple, X87Auto, run)
+}
+
+func x87DirectFlagCompareRuntimeWithMode(t *testing.T, arch, triple string, mode X87Mode, run func(*testing.T, string, string)) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, x87FlagCompareAssembly(arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declarations, checks strings.Builder
+	for _, row := range x87FlagCompareCases() {
+		fmt.Fprintf(&declarations, "extern void %s(uint8_t *);\n", row.name)
+		fmt.Fprintf(&checks, "    if (check(%s, %q, %d, a, b, seed)) return 1;\n", row.name, row.op, row.lane)
+	}
+	main := x87FlagCompareCReference + declarations.String() + `
+int main(void) {
+ const double values[] = {
+  0, -0.0, -1, 1, -19.75, 19.75, 0x1p-1074, 0x1.fffffffffffffp1023,
+  -INFINITY, INFINITY, NAN
+ };
+ for (unsigned left = 0; left < 11; left++) {
+  for (unsigned right = 0; right < 11; right++) {
+   for (unsigned s = 0; s < 2; s++) {
+    double a = values[left], b = values[right];
+    uint64_t seed = s ? 0x8d5 : 0;
+` + checks.String() + "   }\n  }\n }\n return 0;\n}\n"
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+			options := x87FlagCompareOptions(arch, triple)
+			options.X87Mode = mode
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if optimized {
+				ir = x86MulDivRoundOptimize(t, ir)
+			}
+			run(t, ir, main)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX87DirectFlagCompareLLVM(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	x87DirectFlagCompareRuntime(t, "amd64", triple, func(t *testing.T, ir, main string) {
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "x87-direct-flags", triple, ir, main, prefix)
+	})
+}
diff --git a/amd64_x87_integer_conversion.go b/amd64_x87_integer_conversion.go
new file mode 100644
index 000000000..492cbf297
--- /dev/null
+++ b/amd64_x87_integer_conversion.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+)
+
+// The software FIST value path uses integer-indefinite for a masked invalid
+// conversion, not saturation. LLVM fptosi instead produces poison for NaN or
+// an out-of-range rounded value. Sanitize its actual input before converting,
+// so correctness does not depend on discarding an intermediate poison value.
+// This does not supply an ambient CW, exception/trap or extended-value role.
+func (c *amd64Ctx) convertRoundedX87Integer(value string, bits int) string {
+	typ := amd64IntegerTypeForBits(bits) // The typed W/L/V callers supply 16/32/64.
+	bound := math.Ldexp(1, bits-1)
+	lower, upper := c.newTmp(), c.newTmp()
+	valid, safe := c.newTmp(), c.newTmp()
+	integer, result := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fcmp oge double %s, 0x%016X\n", lower, value, math.Float64bits(-bound))
+	fmt.Fprintf(c.b, "  %%%s = fcmp olt double %s, 0x%016X\n", upper, value, math.Float64bits(bound))
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", valid, lower, upper)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, double %s, double 0.000000e+00\n", safe, valid, value)
+	fmt.Fprintf(c.b, "  %%%s = fptosi double %%%s to %s\n", integer, safe, typ)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %d\n", result, valid, typ, integer, typ, int64(-1)<<uint(bits-1))
+	return "%" + result
+}
diff --git a/amd64_x87_integer_value.go b/amd64_x87_integer_value.go
new file mode 100644
index 000000000..23a04d3a9
--- /dev/null
+++ b/amd64_x87_integer_value.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import "fmt"
+
+// Exact signed integers are a value representation, not a source permission
+// or a remembered adjacent load. Every logical stack cell carries its payload
+// through copies, pushes, pops, rotations and selections. Other writers clear
+// the tag. The floating projection remains the existing binary64 model; this
+// does not establish general extended-precision arithmetic or exception state.
+type x87IntegerValue struct {
+	floating string
+	integer  string
+	exact    string
+}
+
+func (c *amd64Ctx) loadX87IntegerValue(index int) x87IntegerValue {
+	value := x87IntegerValue{floating: c.loadX87(index), integer: "0", exact: "false"}
+	if c.x87ExactSlot[index] != "" {
+		integer, exact := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", integer, c.x87IntegerValueSlot[index])
+		fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", exact, c.x87ExactSlot[index])
+		value.integer, value.exact = "%"+integer, "%"+exact
+	}
+	return value
+}
+
+func (c *amd64Ctx) storeX87IntegerValue(index int, value x87IntegerValue) {
+	c.storeX87(index, value.floating)
+	if c.x87ExactSlot[index] != "" {
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", value.integer, c.x87IntegerValueSlot[index])
+		fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", value.exact, c.x87ExactSlot[index])
+	}
+}
+
+func (c *amd64Ctx) pushX87IntegerValue(value x87IntegerValue) error {
+	for index := len(c.x87Slot) - 1; index > 0; index-- {
+		c.storeX87IntegerValue(index, c.loadX87IntegerValue(index-1))
+	}
+	c.storeX87IntegerValue(0, value)
+	return nil
+}
+
+func (c *amd64Ctx) lowerX87IntegerMove(form x86X87ValueForm) error {
+	bits := int(form.memoryBytes() * 8)
+	typ := amd64IntegerTypeForBits(bits)
+	if form.push {
+		integer, err := c.evalIntSized(form.source, typ)
+		if err != nil {
+			return err
+		}
+		if bits != 64 {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext %s %s to i64\n", wide, typ, integer)
+			integer = "%" + wide
+		}
+		floating := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sitofp i64 %s to double\n", floating, integer)
+		return c.pushX87IntegerValue(x87IntegerValue{"%" + floating, integer, "true"})
+	}
+	value := c.loadX87IntegerValue(0)
+	var integer string
+	if bits == 64 && c.useHardwareX87() {
+		integer = c.convertX87ToI64Hardware()
+	} else {
+		rounded := c.roundX87Software(value.floating)
+		converted := c.convertRoundedX87Integer(rounded, bits)
+		exact := value.integer
+		if bits < 64 {
+			lower, upper := c.newTmp(), c.newTmp()
+			valid, narrow, selected := c.newTmp(), c.newTmp(), c.newTmp()
+			minimum := int64(-1) << uint(bits-1)
+			fmt.Fprintf(c.b, "  %%%s = icmp sge i64 %s, %d\n", lower, exact, minimum)
+			fmt.Fprintf(c.b, "  %%%s = icmp sle i64 %s, %d\n", upper, exact, -minimum-1)
+			fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", valid, lower, upper)
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", narrow, exact, typ)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %d\n", selected, valid, typ, narrow, typ, minimum)
+			exact = "%" + selected
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %s, %s %s\n", selected, value.exact, typ, exact, typ, converted)
+		integer = "%" + selected
+	}
+	if err := c.storeX87TypedMemory(form.destination, typ, integer); err != nil {
+		return err
+	}
+	if form.spec.pop != 0 {
+		c.popX87()
+	}
+	return nil
+}
diff --git a/amd64_x87_native_floating_move.go b/amd64_x87_native_floating_move.go
new file mode 100644
index 000000000..3df91417d
--- /dev/null
+++ b/amd64_x87_native_floating_move.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import "fmt"
+
+func (c *amd64Ctx) x87NativeFloatingMoveResultStep(ins Instr, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86X87ValueProperties(ins, arch)
+	if !known || form.spec.kind != x86X87FloatMove {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, true
+	}
+	return x86ResultX87ValueStepWithMemory(ins, state, owned, resultOffset, arch, false, true)
+}
+
+// Both native floating widths use exact unaligned volatile accesses. Dead
+// moves retain their memory effect; continuing one supplies no later backing,
+// bounds, alignment or caller-storage fact.
+func (c *amd64Ctx) loadX87FloatingMove(source Operand, bits int) (string, error) {
+	if !x86RegisterAddressedNativeMemoryOperand(source, c.goarch) {
+		if bits == 32 {
+			return c.evalF32(source)
+		}
+		return c.evalX87F64(source)
+	}
+	pointer, pointerType, err := c.x87MemoryPointer(source)
+	if err != nil {
+		return "", err
+	}
+	typ := "double"
+	if bits == 32 {
+		typ = "float"
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load volatile %s, %s %s, align 1\n", value, typ, pointerType, pointer)
+	return "%" + value, nil
+}
+
+func (c *amd64Ctx) storeX87NativeFloatingMove(destination Operand, typ LLVMType, value string) (bool, error) {
+	if !x86RegisterAddressedNativeMemoryOperand(destination, c.goarch) {
+		return false, nil
+	}
+	pointer, pointerType, err := c.x87MemoryPointer(destination)
+	if err != nil {
+		return true, err
+	}
+	fmt.Fprintf(c.b, "  store volatile %s %s, %s %s, align 1\n", typ, value, pointerType, pointer)
+	return true, nil
+}
diff --git a/amd64_x87_native_ia32_symlink_unix_test.go b/amd64_x87_native_ia32_symlink_unix_test.go
new file mode 100644
index 000000000..a1bbb9391
--- /dev/null
+++ b/amd64_x87_native_ia32_symlink_unix_test.go
@@ -0,0 +1,24 @@
+//go:build !windows
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestX87IA32StaticELFRejectsSymlink(t *testing.T) {
+	dir := t.TempDir()
+	source := filepath.Join(dir, "original")
+	alias := filepath.Join(dir, "alias")
+	if err := os.WriteFile(source, x87IA32SyntheticELF(), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(source, alias); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := x87IA32StaticExecutable(alias); err == nil {
+		t.Fatal("symlink executable was accepted")
+	}
+}
diff --git a/amd64_x87_native_ia32_test.go b/amd64_x87_native_ia32_test.go
new file mode 100644
index 000000000..e2f55d819
--- /dev/null
+++ b/amd64_x87_native_ia32_test.go
@@ -0,0 +1,340 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This certificate describes a generated executable, not a source/ABI grant.
+type x87IA32Executable struct {
+	path string
+	size int64
+	hash [32]byte
+	info os.FileInfo
+}
+
+func x87IA32ArtifactMode(mode os.FileMode, host string) bool {
+	// Windows can inspect a cross-compiled ELF but does not expose Unix
+	// execute bits. Native Unix runs still require them; ELF PF_X, entry,
+	// identity, complete bytes and static linkage are checked on every host.
+	return mode.IsRegular() && (host == "windows" || mode&0111 != 0)
+}
+
+func x87IA32StaticExecutable(name string) (x87IA32Executable, error) {
+	var result x87IA32Executable
+	info, err := os.Lstat(name)
+	if err != nil || !x87IA32ArtifactMode(info.Mode(), runtime.GOOS) ||
+		info.Size() <= 0 || info.Size() > 64<<20 {
+		return result, fmt.Errorf("IA32 executable must be a bounded regular file: %v", err)
+	}
+	// Bind Windows' lazy Lstat file ID while the path still names the original,
+	// before comparing it with the independently opened descriptor.
+	if !os.SameFile(info, info) {
+		return result, fmt.Errorf("IA32 executable physical identity is unavailable")
+	}
+	physical, err := filepath.EvalSymlinks(name)
+	if err != nil {
+		return result, err
+	}
+	physical, err = filepath.Abs(physical)
+	if err != nil {
+		return result, err
+	}
+	file, err := os.Open(physical)
+	if err != nil {
+		return result, err
+	}
+	defer file.Close()
+	opened, err := file.Stat()
+	if err != nil || !os.SameFile(info, opened) {
+		return result, fmt.Errorf("IA32 executable identity changed: %v", err)
+	}
+	object, err := elf.NewFile(file)
+	if err != nil {
+		return result, err
+	}
+	if object.Class != elf.ELFCLASS32 || object.Data != elf.ELFDATA2LSB ||
+		object.Machine != elf.EM_386 || object.Type != elf.ET_EXEC {
+		return result, fmt.Errorf("IA32 direct execution requires a static ELF32 EM_386 executable")
+	}
+	entry := false
+	for _, program := range object.Progs {
+		if program.Type == elf.PT_INTERP || program.Type == elf.PT_DYNAMIC {
+			return result, fmt.Errorf("IA32 executable has an interpreter or dynamic runtime")
+		}
+		if program.Type == elf.PT_LOAD &&
+			(program.Off > uint64(opened.Size()) || program.Filesz > uint64(opened.Size())-program.Off ||
+				program.Filesz > program.Memsz || program.Memsz > ^uint64(0)-program.Vaddr) {
+			return result, fmt.Errorf("IA32 executable has an unbound load extent")
+		}
+		if program.Type == elf.PT_LOAD && program.Flags&elf.PF_X != 0 &&
+			object.Entry >= program.Vaddr && object.Entry-program.Vaddr < program.Filesz {
+			entry = true
+		}
+	}
+	for _, section := range object.Sections {
+		if section.Type == elf.SHT_DYNAMIC {
+			return result, fmt.Errorf("IA32 executable has dynamic dependencies")
+		}
+	}
+	if !entry {
+		return result, fmt.Errorf("IA32 executable entry lacks file-backed executable code")
+	}
+	digest := sha256.New()
+	if count, err := io.Copy(digest, io.NewSectionReader(file, 0, opened.Size())); err != nil || count != opened.Size() {
+		return result, fmt.Errorf("IA32 executable digest failed: %v", err)
+	}
+	after, err := os.Lstat(name)
+	if err != nil || !os.SameFile(info, after) || after.Size() != info.Size() ||
+		!after.ModTime().Equal(info.ModTime()) {
+		return result, fmt.Errorf("IA32 executable changed during inspection: %v", err)
+	}
+	result.path, result.size = physical, opened.Size()
+	result.info = opened
+	copy(result.hash[:], digest.Sum(nil))
+	return result, nil
+}
+
+func (executable x87IA32Executable) verify() error {
+	actual, err := x87IA32StaticExecutable(executable.path)
+	if err != nil || executable.info == nil || !os.SameFile(actual.info, executable.info) ||
+		actual.path != executable.path || actual.size != executable.size || actual.hash != executable.hash {
+		return fmt.Errorf("IA32 executable changed or is unbound: %v", err)
+	}
+	return nil
+}
+
+func x87IA32NativeEnvironment(goos, goarch, kernel, cpuinfo, mappings string, host *elf.File) error {
+	if goos != "linux" || goarch != "amd64" || strings.TrimSpace(kernel) != "x86_64" ||
+		host == nil || host.Class != elf.ELFCLASS64 || host.Machine != elf.EM_X86_64 {
+		return fmt.Errorf("required IA32 direct oracle needs an actual Linux/AMD64 host")
+	}
+	fields := make(map[string]string)
+	for _, line := range strings.Split(cpuinfo, "\n") {
+		key, value, ok := strings.Cut(line, ":")
+		if ok {
+			fields[strings.TrimSpace(key)] = strings.TrimSpace(value)
+		}
+	}
+	if fields["vendor_id"] != "GenuineIntel" && fields["vendor_id"] != "AuthenticAMD" {
+		return fmt.Errorf("native IA32 CPU identity is not observed")
+	}
+	flags := " " + fields["flags"] + " "
+	if !strings.Contains(flags, " fpu ") || !strings.Contains(flags, " cmov ") {
+		return fmt.Errorf("native IA32 x87/P6 capability is not observed")
+	}
+	lower := strings.ToLower(mappings)
+	if strings.TrimSpace(mappings) == "" || strings.Contains(lower, "qemu") || strings.Contains(lower, "rosetta") {
+		return fmt.Errorf("native process mappings are missing or contain an emulator")
+	}
+	return nil
+}
+
+func x87IA32Capture(t *testing.T, executable string, args []string, dir string, env []string) ([]byte, error) {
+	t.Helper()
+	actual, err := exec.LookPath(executable)
+	if err != nil {
+		return nil, err
+	}
+	actual, err = filepath.EvalSymlinks(actual)
+	if err != nil {
+		return nil, err
+	}
+	actual, err = filepath.Abs(actual)
+	if err != nil {
+		return nil, err
+	}
+	originalInfo, err := os.Stat(actual)
+	if err != nil {
+		return nil, err
+	}
+	digest := func() ([32]byte, error) {
+		var result [32]byte
+		file, err := os.Open(actual)
+		if err != nil {
+			return result, err
+		}
+		defer file.Close()
+		info, err := file.Stat()
+		if err != nil || !info.Mode().IsRegular() || info.Size() > 512<<20 {
+			return result, fmt.Errorf("unbound native oracle executable: %v", err)
+		}
+		hash := sha256.New()
+		if count, err := io.Copy(hash, io.LimitReader(file, (512<<20)+1)); err != nil || count != info.Size() {
+			return result, fmt.Errorf("native oracle tool digest failed: %v", err)
+		}
+		copy(result[:], hash.Sum(nil))
+		return result, nil
+	}
+	before, err := digest()
+	if err != nil {
+		return nil, err
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	// Retain the requested basename: registered tool aliases can dispatch on it.
+	command := exec.CommandContext(ctx, executable, args...)
+	command.Dir, command.Env = dir, env
+	output, runErr := runtimeOracleCombinedOutput(ctx, command)
+	after, guardErr := digest()
+	afterInfo, statErr := os.Stat(actual)
+	resolved, pathErr := exec.LookPath(executable)
+	if pathErr == nil {
+		resolved, pathErr = filepath.EvalSymlinks(resolved)
+	}
+	if pathErr == nil {
+		resolved, pathErr = filepath.Abs(resolved)
+	}
+	if guardErr != nil || statErr != nil || pathErr != nil || resolved != actual ||
+		!os.SameFile(originalInfo, afterInfo) || before != after {
+		return output, fmt.Errorf("native oracle executable changed: run=%v guard=%v", runErr, guardErr)
+	}
+	t.Logf("actual executable=%s sha256=%x argv=%q", actual, before, args)
+	return output, runErr
+}
+
+func x87IA32RunDirect(t *testing.T, executable x87IA32Executable, args []string, env []string) []byte {
+	t.Helper()
+	if err := executable.verify(); err != nil {
+		t.Fatal(err)
+	}
+	output, runErr := x87IA32Capture(t, executable.path, args, "", env)
+	guardErr := executable.verify()
+	if runErr != nil || guardErr != nil {
+		t.Fatalf("required native IA32 execution failed (no emulator fallback): run=%v guard=%v\n%s", runErr, guardErr, output)
+	}
+	t.Logf("IA32 direct ELF bytes=%d sha256=%x argv=%q", executable.size, executable.hash, args)
+	return output
+}
+
+func x87IA32BuildOriginalGo(t *testing.T) x87IA32Executable {
+	t.Helper()
+	dir := x87FlagCompareOriginalDirectory(t, "386")
+	goBinary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	env := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOROOT="+runtime.GOROOT(), "GOFLAGS=", "GOEXPERIMENT=", "GOOS=linux",
+		"GOARCH=386", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	version, err := x87IA32Capture(t, goBinary, []string{"version"}, dir, env)
+	if err != nil || !strings.HasPrefix(string(version), "go version "+runtime.Version()+" ") {
+		t.Fatalf("native oracle SDK identity mismatch: %v\n%s", err, version)
+	}
+	executable := filepath.Join(dir, "original.test")
+	output, err := x87IA32Capture(t, goBinary,
+		[]string{"test", "-c", "-p=2", "-vet=off", "-o", executable, "."}, dir, env)
+	if err != nil || len(output) != 0 {
+		t.Fatalf("original Go IA32 compile failed: %v\n%s", err, output)
+	}
+	result, err := x87IA32StaticExecutable(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual SDK=%s original Go static IA32 ELF bytes=%d sha256=%x (compile only)",
+		runtime.Version(), result.size, result.hash)
+	return result
+}
+
+func x87IA32OriginalGoDirect(t *testing.T) {
+	t.Helper()
+	executable := x87IA32BuildOriginalGo(t)
+	output := x87IA32RunDirect(t, executable,
+		[]string{"-test.run=^TestCompleteStatus$", "-test.count=1", "-test.v"}, os.Environ())
+	complete := regexp.MustCompile(`\A=== RUN   TestCompleteStatus\n--- PASS: TestCompleteStatus \([0-9]+\.[0-9]+s\)\nPASS\n\z`)
+	if !complete.Match(output) {
+		t.Fatalf("original Go complete 7744-sample oracle did not finish:\n%s", output)
+	}
+	t.Log("32 initialized kernels × 121 IEEE pairs × 2 seeds; all six flags, LAHF, SETcc and byte canaries")
+}
+
+func x87IA32CompileAndRunDirect(t *testing.T, llc, ir, main string) {
+	t.Helper()
+	dir := t.TempDir()
+	llPath, object := filepath.Join(dir, "original.ll"), filepath.Join(dir, "original.o")
+	mainPath, binaryPath := filepath.Join(dir, "main.c"), filepath.Join(dir, "translated")
+	for name, contents := range map[string]string{llPath: ir, mainPath: main} {
+		if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	output, err := x87IA32Capture(t, llc,
+		[]string{"-mtriple=i386-unknown-linux-gnu", "-filetype=obj", llPath, "-o", object}, dir, os.Environ())
+	if err != nil || len(output) != 0 {
+		t.Fatalf("LLVM22 IA32 object failed: %v\n%s", err, output)
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err = x87IA32Capture(t, compiler,
+		[]string{"-static", "-no-pie", object, mainPath, "-O2", "-o", binaryPath, "-lm"}, dir, os.Environ())
+	if err != nil || len(output) != 0 {
+		t.Fatalf("static native IA32 C link failed: %v\n%s", err, output)
+	}
+	executable, err := x87IA32StaticExecutable(binaryPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if output := x87IA32RunDirect(t, executable, nil, os.Environ()); len(output) != 0 {
+		t.Fatalf("native IA32 C oracle produced unexpected diagnostics: %s", output)
+	}
+}
+
+func x87IA32PreflightStatus(output []byte) error {
+	if len(output) != 64 {
+		return fmt.Errorf("native IA32 status preflight requires exactly 8 complete observations")
+	}
+	for index := 0; index < 8; index++ {
+		row := output[index*8 : (index+1)*8]
+		flags := binary.LittleEndian.Uint32(row) & 0x8d5
+		if flags != 0x40 || row[4] != 0x42 || row[5] != 0 || row[6] != 0 || row[7] != 0 {
+			return fmt.Errorf("native IA32 x87 preflight row%d flags=%x LAHF=%x; emulator/ISA mismatch", index, flags, row[4])
+		}
+	}
+	return nil
+}
+
+func x87IA32NativePreflight(t *testing.T) {
+	t.Helper()
+	var source strings.Builder
+	source.WriteString(".text\n.globl _start\n_start:\n")
+	index := 0
+	for _, operation := range []string{"fcomi", "fcomip", "fucomi", "fucomip"} {
+		for _, seed := range []uint32{0, 0x8d5} {
+			fmt.Fprintf(&source, "fninit\nfldl value\nfldl value\npushl $%d\npopfl\n%s %%st(1),%%st\npushfl\npopl %%eax\nmovl %%eax,result+%d\nlahf\nmovb %%ah,result+%d\n",
+				seed, operation, index*8, index*8+4)
+			index++
+		}
+	}
+	source.WriteString("movl $4,%eax\nmovl $1,%ebx\nmovl $result,%ecx\nmovl $64,%edx\nint $0x80\nmovl $1,%eax\nxorl %ebx,%ebx\nint $0x80\n.data\n.balign 8\nvalue: .quad 0\nresult: .zero 64\n.section .note.GNU-stack,\"\",@progbits\n")
+	dir := t.TempDir()
+	input, executable := filepath.Join(dir, "preflight.s"), filepath.Join(dir, "preflight")
+	if err := os.WriteFile(input, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err := x87IA32Capture(t, compiler,
+		[]string{"-nostdlib", "-static", "-no-pie", "-Wl,--build-id=none,-e,_start", input, "-o", executable}, dir, os.Environ())
+	if err != nil || len(output) != 0 {
+		t.Fatalf("native IA32 physical preflight build failed: %v\n%s", err, output)
+	}
+	sealed, err := x87IA32StaticExecutable(executable)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x87IA32PreflightStatus(x87IA32RunDirect(t, sealed, nil, os.Environ())); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("actual direct IA32 physical preflight: 4 original opcodes × 2 seeds, full six flags and LAHF")
+}
diff --git a/amd64_x87_native_ia32_transport_test.go b/amd64_x87_native_ia32_transport_test.go
new file mode 100644
index 000000000..22eb226a2
--- /dev/null
+++ b/amd64_x87_native_ia32_transport_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func TestX87IA32ArtifactModeSeparatesHostAndELFPermissions(t *testing.T) {
+	for _, host := range []string{"linux", "darwin", "windows"} {
+		for _, mode := range []os.FileMode{0600, 0700, os.ModeDir | 0700, os.ModeSymlink | 0700} {
+			want := mode.IsRegular() && (host == "windows" || mode&0111 != 0)
+			if got := x87IA32ArtifactMode(mode, host); got != want {
+				t.Errorf("host %s mode %v: got %t, want %t", host, mode, got, want)
+			}
+		}
+	}
+}
+
+func TestX87IA32RequiredNativeTransportSource(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_x87_flag_compare_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]bool{
+		"x87IA32RequireNativeHost":   false,
+		"x87IA32NativePreflight":     false,
+		"x87IA32OriginalGoDirect":    false,
+		"x87IA32CompileAndRunDirect": false,
+	}
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch value := node.(type) {
+		case *ast.BasicLit:
+			if value.Kind == token.STRING {
+				text, err := strconv.Unquote(value.Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if text == "qemu-i386" || text == "-exec" {
+					t.Errorf("required native IA32 oracle still selects emulation: %s", text)
+				}
+			}
+		case *ast.CallExpr:
+			if function, ok := value.Fun.(*ast.Ident); ok {
+				if _, required := want[function.Name]; required {
+					want[function.Name] = true
+				}
+			}
+			if method, ok := value.Fun.(*ast.SelectorExpr); ok && method.Sel.Name == "Skip" {
+				t.Error("required native IA32 oracle cannot skip failed preflight")
+			}
+		}
+		return true
+	})
+	for function, found := range want {
+		if !found {
+			t.Errorf("required native IA32 route lacks %s", function)
+		}
+	}
+}
+
+func TestX87IA32OriginalReferenceMatrixPreserved(t *testing.T) {
+	for _, fixture := range []struct {
+		name, source, hash string
+	}{
+		{"386 assembly", x87FlagCompareAssembly("386"), "09ae2f421502ee1f22367d019e98f83767319bf03e414fdf305ad9afb940dea3"},
+		{"amd64 assembly", x87FlagCompareAssembly("amd64"), "254191f4443a8d3c24c372c5aa5beb820f77e2a7d96a13179ca7fb2b37799664"},
+		{"Go reference", x87FlagCompareOriginalReference, "62784b45ccd0cf0f6c04ec3cb498c744c48f5ba82354a8e2a6041a0067b7ade6"},
+		{"C reference", x87FlagCompareCReference, "ea4efe97b695fe4a398422ba3b32148e2456ed6dac3a4c8c88194080dcec4466"},
+	} {
+		if got := fmt.Sprintf("%x", sha256.Sum256([]byte(fixture.source))); got != fixture.hash {
+			t.Errorf("%s changed: %s", fixture.name, got)
+		}
+	}
+	if got := len(x87FlagCompareCases()); got != 32 {
+		t.Fatalf("original 32-kernel matrix changed: %d", got)
+	}
+}
+
+// This is a synthetic parser fixture, never executed or called native proof.
+func x87IA32SyntheticELF() []byte {
+	data := make([]byte, 85)
+	copy(data, []byte{0x7f, 'E', 'L', 'F', 1, 1, 1})
+	binary.LittleEndian.PutUint16(data[16:], uint16(elf.ET_EXEC))
+	binary.LittleEndian.PutUint16(data[18:], uint16(elf.EM_386))
+	binary.LittleEndian.PutUint32(data[20:], 1)
+	binary.LittleEndian.PutUint32(data[24:], 0x1000)
+	binary.LittleEndian.PutUint32(data[28:], 52)
+	binary.LittleEndian.PutUint16(data[40:], 52)
+	binary.LittleEndian.PutUint16(data[42:], 32)
+	binary.LittleEndian.PutUint16(data[44:], 1)
+	binary.LittleEndian.PutUint32(data[52:], uint32(elf.PT_LOAD))
+	binary.LittleEndian.PutUint32(data[56:], 84)
+	binary.LittleEndian.PutUint32(data[60:], 0x1000)
+	binary.LittleEndian.PutUint32(data[68:], 1)
+	binary.LittleEndian.PutUint32(data[72:], 1)
+	binary.LittleEndian.PutUint32(data[76:], uint32(elf.PF_R|elf.PF_X))
+	binary.LittleEndian.PutUint32(data[80:], 1)
+	data[84] = 0xc3
+	return data
+}
+
+func TestX87IA32StaticELFRejectsUnboundExecutables(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func([]byte)
+	}{
+		{"wrong machine", func(data []byte) { binary.LittleEndian.PutUint16(data[18:], uint16(elf.EM_X86_64)) }},
+		{"wrong class", func(data []byte) { data[4] = 2 }},
+		{"wrong endian", func(data []byte) { data[5] = 2 }},
+		{"relocatable", func(data []byte) { binary.LittleEndian.PutUint16(data[16:], uint16(elf.ET_REL)) }},
+		{"interpreter", func(data []byte) { binary.LittleEndian.PutUint32(data[52:], uint32(elf.PT_INTERP)) }},
+		{"dynamic", func(data []byte) { binary.LittleEndian.PutUint32(data[52:], uint32(elf.PT_DYNAMIC)) }},
+		{"truncated load", func(data []byte) { binary.LittleEndian.PutUint32(data[68:], 2) }},
+		{"outside load", func(data []byte) { binary.LittleEndian.PutUint32(data[56:], 1000) }},
+		{"insufficient mapped memory", func(data []byte) { binary.LittleEndian.PutUint32(data[72:], 0) }},
+		{"missing entry", func(data []byte) { binary.LittleEndian.PutUint32(data[24:], 0x1001) }},
+		{"non executable entry", func(data []byte) { binary.LittleEndian.PutUint32(data[76:], uint32(elf.PF_R)) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			data := x87IA32SyntheticELF()
+			test.edit(data)
+			name := filepath.Join(t.TempDir(), "invalid")
+			if err := os.WriteFile(name, data, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := x87IA32StaticExecutable(name); err == nil {
+				t.Fatal("unbound executable was accepted")
+			}
+		})
+	}
+	if _, err := x87IA32StaticExecutable(t.TempDir()); err == nil {
+		t.Fatal("directory was accepted as an executable")
+	}
+	if _, err := x87IA32StaticExecutable(filepath.Join(t.TempDir(), "missing")); err == nil {
+		t.Fatal("missing executable was accepted")
+	}
+}
+
+func TestX87IA32StaticELFGuardsChangedBytesAndIdentity(t *testing.T) {
+	dir := t.TempDir()
+	name := filepath.Join(dir, "executable")
+	data := x87IA32SyntheticELF()
+	if err := os.WriteFile(name, data, 0700); err != nil {
+		t.Fatal(err)
+	}
+	sealed, err := x87IA32StaticExecutable(name)
+	if err != nil || sealed.verify() != nil {
+		t.Fatalf("synthetic parser control failed: %v", err)
+	}
+	changed := append([]byte(nil), data...)
+	changed[84] = 0x90
+	if err := os.WriteFile(name, changed, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if sealed.verify() == nil {
+		t.Fatal("late-byte executable mutation was accepted")
+	}
+	if err := os.WriteFile(name, data, 0700); err != nil {
+		t.Fatal(err)
+	}
+	sealed, err = x87IA32StaticExecutable(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(name, filepath.Join(dir, "original")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(name, data, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if sealed.verify() == nil {
+		t.Fatal("equal-byte replacement lost its physical identity")
+	}
+	if err := os.Chmod(name, 0600); err != nil {
+		t.Fatal(err)
+	}
+	_, err = x87IA32StaticExecutable(name)
+	if runtime.GOOS == "windows" {
+		if err != nil {
+			t.Fatal("compiled ELF depends on nonexistent Windows Unix execute bits", err)
+		}
+	} else if err == nil {
+		t.Fatal("native Unix executable lost its required execute permission")
+	}
+	file, err := os.Create(filepath.Join(dir, "oversize"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := file.Truncate((64 << 20) + 1); err != nil {
+		t.Fatal(err)
+	}
+	if err := file.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(filepath.Join(dir, "oversize"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := x87IA32StaticExecutable(filepath.Join(dir, "oversize")); err == nil {
+		t.Fatal("oversize artifact was accepted")
+	}
+}
+
+func TestX87IA32StaticELFRejectsDynamicSection(t *testing.T) {
+	data := append(x87IA32SyntheticELF(), make([]byte, 40)...)
+	binary.LittleEndian.PutUint32(data[32:], 85)
+	binary.LittleEndian.PutUint16(data[46:], 40)
+	binary.LittleEndian.PutUint16(data[48:], 1)
+	binary.LittleEndian.PutUint32(data[89:], uint32(elf.SHT_DYNAMIC))
+	name := filepath.Join(t.TempDir(), "dynamic")
+	if err := os.WriteFile(name, data, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := x87IA32StaticExecutable(name); err == nil {
+		t.Fatal("dynamic section was accepted")
+	}
+}
+
+func TestX87IA32NativeEnvironmentCannotUseGuestLabels(t *testing.T) {
+	host := &elf.File{FileHeader: elf.FileHeader{Class: elf.ELFCLASS64, Machine: elf.EM_X86_64}}
+	cpuinfo := "vendor_id: GenuineIntel\nflags: fpu cmov\n"
+	if err := x87IA32NativeEnvironment("linux", "amd64", "x86_64", cpuinfo, "synthetic native mapping", host); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, goos, arch, kernel, cpuinfo, maps string
+		host                                    *elf.File
+	}{
+		{"Darwin guest", "darwin", "amd64", "x86_64", cpuinfo, "mapping", host},
+		{"ARM host", "linux", "arm64", "x86_64", cpuinfo, "mapping", host},
+		{"ARM kernel", "linux", "amd64", "aarch64", cpuinfo, "mapping", host},
+		{"missing physical host", "linux", "amd64", "x86_64", cpuinfo, "mapping", nil},
+		{"unobserved CPU", "linux", "amd64", "x86_64", "processor: 0", "mapping", host},
+		{"missing P6", "linux", "amd64", "x86_64", "vendor_id: GenuineIntel\nflags: fpu", "mapping", host},
+		{"missing x87", "linux", "amd64", "x86_64", "vendor_id: AuthenticAMD\nflags: cmov", "mapping", host},
+		{"QEMU process", "linux", "amd64", "x86_64", cpuinfo, "/usr/bin/qemu-i386", host},
+		{"Rosetta process", "linux", "amd64", "x86_64", cpuinfo, "/rosetta/rosetta", host},
+		{"missing maps", "linux", "amd64", "x86_64", cpuinfo, "", host},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if err := x87IA32NativeEnvironment(test.goos, test.arch, test.kernel, test.cpuinfo, test.maps, test.host); err == nil {
+				t.Fatal("guest or missing native capability was accepted")
+			}
+		})
+	}
+}
+
+func TestX87IA32PreflightPreservesSixFlagRequirement(t *testing.T) {
+	output := make([]byte, 64)
+	for index := 0; index < 8; index++ {
+		binary.LittleEndian.PutUint32(output[index*8:], 0x40)
+		output[index*8+4] = 0x42
+	}
+	if err := x87IA32PreflightStatus(output); err != nil {
+		t.Fatal(err)
+	}
+	for index := 0; index < 8; index++ {
+		bad := append([]byte(nil), output...)
+		binary.LittleEndian.PutUint32(bad[index*8:], 0x8d0)
+		bad[index*8+4] = 0xd2
+		if x87IA32PreflightStatus(bad) == nil {
+			t.Fatalf("QEMU retained AF/SF/OF was accepted at row%d", index)
+		}
+	}
+	if x87IA32PreflightStatus(output[:63]) == nil || x87IA32PreflightStatus(append(output, 0)) == nil {
+		t.Fatal("partial or extra observation was accepted")
+	}
+}
+
+func TestX87IA32OriginalGoStaticELFActualCompile(t *testing.T) {
+	executable := x87IA32BuildOriginalGo(t)
+	if err := executable.verify(); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("actual original 32-kernel Go386 ELF compiled and rechecked; no native execution claim")
+}
diff --git a/amd64_x87_rounding_result.go b/amd64_x87_rounding_result.go
new file mode 100644
index 000000000..e76ca5537
--- /dev/null
+++ b/amd64_x87_rounding_result.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+// Only these two existing branches emit an actual native rounding/conversion
+// operation. W/L stores still use the old software lowerer even in Auto mode;
+// mode selection cannot invent an ambient-CW continuation for those branches.
+// This supplies no numerical representation, memory, entry or FP80 authority.
+func (c *amd64Ctx) x87HardwareRoundingResultStep(ins Instr, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if !c.useHardwareX87() {
+		return false, false
+	}
+	form, known, err := x86X87ValueProperties(ins, arch)
+	if !known || form.spec.kind != x86X87Round &&
+		!(form.spec.kind == x86X87IntegerMove && form.spec.width == 'V' && form.spec.pop == 1) {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	return x86ResultX87ValueStepWithHardwareRounding(ins, state, owned, resultOffset, arch, true)
+}
diff --git a/amd64_x87_word_result.go b/amd64_x87_word_result.go
new file mode 100644
index 000000000..f8944de1b
--- /dev/null
+++ b/amd64_x87_word_result.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+// Auto/Hardware FSTCW emits an actual sideeffect FNSTCW output to the same
+// private i16 control slot before reading it. Only this paired lowering check
+// may consume that capture; a standalone declaration/availability query cannot
+// infer ambient control from the implementation alloca's initial 0x037f.
+func (c *amd64Ctx) x87HardwareControlResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86X87WordProperties(ins, arch)
+	if !known || form.kind != x86X87StoreControl || c.x87Mode == X87Software {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) || state.x87 == nil || state.x87.word == nil {
+		return false, true
+	}
+	next := state.clone()
+	next.x87.word.control = 0xffff
+	accepted, _ := x86ResultX87WordStep(ins, &next, owned, resultOffset, arch)
+	if accepted {
+		*state = next
+	}
+	return accepted, true
+}
diff --git a/amd64_xlat_forms.go b/amd64_xlat_forms.go
new file mode 100644
index 000000000..63e3b128d
--- /dev/null
+++ b/amd64_xlat_forms.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's entire XLAT family is one ynone/Px/D7 row in both x86 modes.
+// AL's unsigned-byte index is not an ordinary full-register SIB operand.
+func x86XLATProperties(op Op, ins Instr, arch string) (bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	if name != "XLAT" {
+		return false, nil
+	}
+	if arch != "amd64" && arch != "386" || dotted || len(ins.Args) != 0 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), string(op)) {
+		return true, fmt.Errorf("%s %s requires its original zero-operand Go XLAT row: %q", arch, op, ins.Raw)
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return true, fmt.Errorf("%w: XLAT needs its original default native address mode", ErrProbeNeedsContext)
+	}
+	return true, nil
+}
+
+func x86TypedXLATByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	known, err := x86XLATProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	// The register footprint is complete. The dynamically selected single
+	// native byte is owned only by the dedicated paired reader, never by a
+	// fabricated ordinary SIB, caller extent or contiguous logical FP slot.
+	return x86TypedByteEffect{requiresResultProof: true, dynamicMemory: true, operands: []x86TypedByteOperand{
+		{index: -1, operand: Operand{Kind: OpReg, Reg: AL}, width: 1, read: true, write: true},
+		{index: -1, operand: Operand{Kind: OpReg, Reg: BX}, width: x86ResultPointerWord(arch), read: true},
+	}}, true, nil
+}
+
+func x86ResultXLATStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	known, err := x86XLATProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !native || !x86ResultRead(Operand{Kind: OpReg, Reg: AL}, 1, state, owned, arch) {
+		return false, true
+	}
+	// Check only the real BX pointer here. The separately checked AL byte is
+	// zero-extended by the emitter; unknown AX high bytes are not index inputs.
+	base := Operand{Kind: OpMem, Mem: MemRef{Base: BX}}
+	if !x86ResultReadWithNativeContinuation(ins, base, 1, state, owned, arch, true) {
+		return false, true
+	}
+	state.gp[0] |= 1
+	state.canonicalGP[0] &^= 1
+	state.pointerGP[0], state.callerAddressGP[0], state.callerAddressOrigin[0] = false, false, 0
+	state.resultAddressGP[0] = x86ResultSlotAddress{}
+	return true, true // Only AL changes. AX's other bytes, FLAGS, DF and BX survive.
+}
diff --git a/arm64_abi.go b/arm64_abi.go
new file mode 100644
index 000000000..9cc10ef02
--- /dev/null
+++ b/arm64_abi.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import "fmt"
+
+type arm64ABIRegisterCursor struct {
+	integer  int
+	floating int
+}
+
+func isARM64ABIFloatingType(typ LLVMType) bool {
+	return typ == LLVMType("float") || typ == LLVMType("double")
+}
+
+func isARM64ABIIntegerType(typ LLVMType) bool {
+	switch typ {
+	case I1, I8, I16, I32, I64, Ptr:
+		return true
+	default:
+		return false
+	}
+}
+
+func (cursor *arm64ABIRegisterCursor) next(typ LLVMType) (Reg, error) {
+	if isARM64ABIFloatingType(typ) {
+		if cursor.floating >= 16 {
+			return "", fmt.Errorf("floating argument exceeds F0-F15")
+		}
+		reg := Reg(fmt.Sprintf("F%d", cursor.floating))
+		cursor.floating++
+		return reg, nil
+	}
+	if !isARM64ABIIntegerType(typ) {
+		return "", fmt.Errorf("unsupported ABI scalar type %s", typ)
+	}
+	if cursor.integer >= 16 {
+		return "", fmt.Errorf("integer argument exceeds R0-R15")
+	}
+	reg := Reg(fmt.Sprintf("R%d", cursor.integer))
+	cursor.integer++
+	return reg, nil
+}
+
+func (c *arm64Ctx) loadABIRegisterValue(reg Reg, typ LLVMType) (string, error) {
+	raw, err := c.loadRegisterWidth(reg, arm64MachineScalarWidth(typ))
+	if err != nil {
+		return "", err
+	}
+	switch typ {
+	case LLVMType("float"):
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", bits, raw)
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", value, bits)
+		return "%" + value, nil
+	case LLVMType("double"):
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", value, raw)
+		return "%" + value, nil
+	default:
+		return c.castI64RegToArg(raw, typ)
+	}
+}
+
+func (c *arm64Ctx) storeABIRegisterValue(reg Reg, typ LLVMType, value string) error {
+	raw, scalar, err := arm64ValueAsI64(c, typ, value)
+	if err != nil {
+		return err
+	}
+	if !scalar {
+		return fmt.Errorf("unsupported ABI scalar type %s", typ)
+	}
+	return c.storeReg(reg, raw)
+}
+
+func (c *arm64Ctx) abiRegisterCallArgs(callee string, sig FuncSig) ([]string, error) {
+	args := make([]string, 0, len(sig.Args))
+	cursor := arm64ABIRegisterCursor{}
+	for argIndex, argType := range sig.Args {
+		if len(sig.ArgRegs) != 0 {
+			if argIndex >= len(sig.ArgRegs) {
+				return nil, fmt.Errorf("arm64 call %q: missing explicit register for argument %d", callee, argIndex)
+			}
+			if _, aggregate := parseLiteralStructFields(argType); aggregate {
+				return nil, fmt.Errorf("arm64 call %q: explicit register for aggregate argument %d is ambiguous", callee, argIndex)
+			}
+			value, err := c.loadABIRegisterValue(sig.ArgRegs[argIndex], argType)
+			if err != nil {
+				return nil, err
+			}
+			args = append(args, fmt.Sprintf("%s %s", argType, value))
+			continue
+		}
+		if fields, aggregate := parseLiteralStructFields(argType); aggregate {
+			value := "undef"
+			for fieldIndex, fieldType := range fields {
+				reg, err := cursor.next(fieldType)
+				if err != nil {
+					return nil, fmt.Errorf("arm64 call %q argument %d field %d: %w", callee, argIndex, fieldIndex, err)
+				}
+				field, err := c.loadABIRegisterValue(reg, fieldType)
+				if err != nil {
+					return nil, err
+				}
+				inserted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %s, %d\n", inserted, argType, value, fieldType, field, fieldIndex)
+				value = "%" + inserted
+			}
+			args = append(args, fmt.Sprintf("%s %s", argType, value))
+			continue
+		}
+		reg, err := cursor.next(argType)
+		if err != nil {
+			return nil, fmt.Errorf("arm64 call %q argument %d: %w", callee, argIndex, err)
+		}
+		value, err := c.loadABIRegisterValue(reg, argType)
+		if err != nil {
+			return nil, err
+		}
+		args = append(args, fmt.Sprintf("%s %s", argType, value))
+	}
+	if len(sig.ArgRegs) > len(sig.Args) {
+		return nil, fmt.Errorf("arm64 call %q: %d explicit argument registers for %d arguments", callee, len(sig.ArgRegs), len(sig.Args))
+	}
+	return args, nil
+}
+
+func (c *arm64Ctx) storeABIRegisterResult(callee string, typ LLVMType, result string) error {
+	cursor := arm64ABIRegisterCursor{}
+	if fields, aggregate := parseLiteralStructFields(typ); aggregate {
+		for fieldIndex, fieldType := range fields {
+			reg, err := cursor.next(fieldType)
+			if err != nil {
+				return fmt.Errorf("arm64 call %q return field %d: %w", callee, fieldIndex, err)
+			}
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, typ, result, fieldIndex)
+			if err := c.storeABIRegisterValue(reg, fieldType, "%"+extracted); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	reg, err := cursor.next(typ)
+	if err != nil {
+		return fmt.Errorf("arm64 call %q unsupported return type %s", callee, typ)
+	}
+	return c.storeABIRegisterValue(reg, typ, result)
+}
diff --git a/arm64_abi0_byte_region_darwin_arm64_test.go b/arm64_abi0_byte_region_darwin_arm64_test.go
new file mode 100644
index 000000000..14d36e407
--- /dev/null
+++ b/arm64_abi0_byte_region_darwin_arm64_test.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64ABI0ByteRegionOriginalHostObservation(t *testing.T) {
+	arm64ABI0ByteRegionOriginalRun(t, "darwin", nil)
+}
diff --git a/arm64_abi0_byte_region_linux_test.go b/arm64_abi0_byte_region_linux_test.go
new file mode 100644
index 000000000..08d078914
--- /dev/null
+++ b/arm64_abi0_byte_region_linux_test.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ABI0ByteRegionOriginal(t *testing.T) {
+	var runner []string
+	if runtime.GOARCH != "arm64" {
+		if runtime.GOARCH != "amd64" || os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+			// Ordinary Linux suites also discover this required counterpart.
+			// Only the explicit guest profile consumes its QEMU tool contract.
+			t.Skip("ARM64 original-code runtime scope needs native ARM64 or the required Linux/amd64 cross-runtime job")
+		}
+		qemu, err := exec.LookPath("qemu-aarch64")
+		if err != nil {
+			t.Fatal("required qemu-aarch64: ", err)
+		}
+		runner = []string{qemu}
+		t.Log("Linux QEMU original ARM64 machine-code observation, not bare-metal native ARM64 proof")
+	} else {
+		t.Log("Linux native ARM64 original-code observation")
+	}
+	arm64ABI0ByteRegionOriginalRun(t, "linux", runner)
+}
diff --git a/arm64_abi0_byte_region_naming_test.go b/arm64_abi0_byte_region_naming_test.go
new file mode 100644
index 000000000..cfefce54e
--- /dev/null
+++ b/arm64_abi0_byte_region_naming_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"bytes"
+	"debug/pe"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The actual fixture's naming statements are compiled with explicit GOOS
+// controls. This is a naming unit and a Windows PE build, not Windows execution.
+func TestARM64ABI0ByteRegionNativeExecutableNaming(t *testing.T) {
+	original, err := os.ReadFile("arm64_abi0_byte_region_role_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "actual-role.go", original, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var naming bytes.Buffer
+	var retained ast.Expr
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestARM64ABI0ByteRegionActualLinuxSourceRole" {
+			continue
+		}
+		collect := false
+		for _, statement := range function.Body.List {
+			if assignment, ok := statement.(*ast.AssignStmt); ok && len(assignment.Lhs) == 1 {
+				if identifier, ok := assignment.Lhs[0].(*ast.Ident); ok {
+					if identifier.Name == "executable" {
+						collect = true
+					}
+					if identifier.Name == "command" {
+						collect = false
+					}
+				}
+			}
+			if collect {
+				if err := format.Node(&naming, set, statement); err != nil {
+					t.Fatal(err)
+				}
+				naming.WriteByte('\n')
+			}
+			if expression, ok := statement.(*ast.ExprStmt); ok {
+				if call, ok := expression.X.(*ast.CallExpr); ok {
+					if identifier, ok := call.Fun.(*ast.Ident); ok && identifier.Name == "arm64ABI0RegionRetain" {
+						if retained != nil || len(call.Args) < 4 {
+							t.Fatal("ambiguous actual artifact retention")
+						}
+						retained = call.Args[len(call.Args)-1]
+					}
+				}
+			}
+		}
+	}
+	if naming.Len() == 0 || retained == nil {
+		t.Fatal("actual source-role naming/retention statements are absent")
+	}
+	var kept bytes.Buffer
+	if err := format.Node(&kept, set, retained); err != nil {
+		t.Fatal(err)
+	}
+	source := fmt.Sprintf(`package main
+
+import (
+	"fmt"
+	"path/filepath"
+)
+
+func names(goos string) (string,string) {
+	dir := "owned-fixture"
+	runtime := struct { GOOS string }{goos}
+	_ = runtime
+	%s
+	return filepath.Base(executable), %s
+}
+
+func main() {
+	for _, goos := range []string{"windows","darwin","linux","freebsd","openbsd"} {
+		executable,retained := names(goos)
+		fmt.Printf("%%s=%%s/%%s\n",goos,executable,retained)
+	}
+}
+`, naming.String(), kept.String())
+	formatted, err := format.Source([]byte(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "names.go"), formatted, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "actual-role-source.txt"), original, 0600); err != nil {
+		t.Fatal(err)
+	}
+	lookup, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "os", "exec", "lp_windows.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "windows-lookup-source.txt"), lookup, 0600); err != nil {
+		t.Fatal(err)
+	}
+	name := "names"
+	if runtime.GOOS == "windows" {
+		name += ".exe"
+	}
+	executable := filepath.Join(dir, name)
+	goTool := filepath.Join(runtime.GOROOT(), "bin", "go")
+	build := func(goos, goarch, output string) {
+		t.Helper()
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		command := exec.CommandContext(ctx, goTool, "build", "-p=2", "-o", output, "names.go")
+		command.Dir = dir
+		command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch, "CGO_ENABLED=0",
+			"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+		if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+			t.Fatalf("actual naming unit build %s/%s: %v\n%s", goos, goarch, err, output)
+		}
+	}
+	build(runtime.GOOS, runtime.GOARCH, executable)
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, executable)
+	command.Dir = dir
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual naming unit execution: %v\n%s", err, output)
+	}
+	build("windows", "amd64", filepath.Join(dir, "windows-naming.exe"))
+	image, err := pe.Open(filepath.Join(dir, "windows-naming.exe"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer image.Close()
+	if image.Machine != pe.IMAGE_FILE_MACHINE_AMD64 || image.NumberOfSections == 0 {
+		t.Fatal("actual Windows build did not produce an AMD64 PE")
+	}
+	arm64ABI0RegionRetain(t, dir, "source-naming-unit-and-Windows-build-only", "names.go",
+		"actual-role-source.txt", "windows-lookup-source.txt", name, "windows-naming.exe")
+	var expected strings.Builder
+	for _, goos := range []string{"windows", "darwin", "linux", "freebsd", "openbsd"} {
+		name := "scope"
+		if goos == "windows" {
+			name += ".exe"
+		}
+		fmt.Fprintf(&expected, "%s=%s/%s\n", goos, name, name)
+	}
+	if string(output) != expected.String() {
+		t.Fatalf("actual native executable/retained filename routing differs (unit, not native Windows):\n%s\nwant:\n%s",
+			output, expected.String())
+	}
+	t.Logf("actual SDK=%s native-source naming controls plus Windows/amd64 PE BUILD ONLY:\n%s",
+		runtime.Version(), output)
+}
diff --git a/arm64_abi0_byte_region_role_test.go b/arm64_abi0_byte_region_role_test.go
new file mode 100644
index 000000000..4b0338b1f
--- /dev/null
+++ b/arm64_abi0_byte_region_role_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This compiles the actual Linux root body with explicit synthetic profile,
+// lookup and run observers. It proves source-role routing, not Linux execution,
+// tool availability, an original ARM64 result or any native ABI permission.
+func TestARM64ABI0ByteRegionActualLinuxSourceRole(t *testing.T) {
+	name := "arm64_abi0_byte_region_linux_test.go"
+	original, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, name, original, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body bytes.Buffer
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == "TestCrossLinuxRuntimeMatrixARM64ABI0ByteRegionOriginal" {
+			if body.Len() != 0 {
+				t.Fatal("duplicate required cross root")
+			}
+			if err := format.Node(&body, set, function.Body); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if body.Len() == 0 {
+		t.Fatal("actual required Linux root is absent")
+	}
+	cases := []struct {
+		name, arch, cross, want string
+		qemu                    bool
+		lookups                 int
+	}{
+		{"ordinary-amd64-empty", "amd64", "", "skip", false, 0},
+		{"ordinary-amd64-zero", "amd64", "0", "skip", false, 0},
+		{"ordinary-amd64-unknown", "amd64", "yes", "skip", false, 0},
+		{"required-amd64", "amd64", "1", "guest", true, 1},
+		{"required-amd64-missing-qemu", "amd64", "1", "fatal", false, 1},
+		{"native-arm64", "arm64", "", "native", false, 0},
+		{"native-arm64-cross-env", "arm64", "1", "native", false, 0},
+		{"ordinary-386", "386", "", "skip", false, 0},
+		{"unsupported-required-386", "386", "1", "skip", false, 0},
+		{"unsupported-required-arm", "arm", "1", "skip", false, 0},
+	}
+	var source strings.Builder
+	source.WriteString(`package main
+
+import "fmt"
+
+var runtime struct { GOARCH string }
+var cross string
+var available bool
+var lookups int
+
+var os = struct { Getenv func(string) string } {
+	Getenv: func(name string) string {
+		if name != "PLAN9ASM_CROSS_EXEC" { panic("unregistered environment") }
+		return cross
+	},
+}
+var exec = struct { LookPath func(string) (string,error) } {
+	LookPath: func(name string) (string,error) {
+		if name != "qemu-aarch64" { panic("unregistered tool") }
+		lookups++
+		if !available { return "",fmt.Errorf("synthetic unavailable QEMU") }
+		return "unit-qemu",nil
+	},
+}
+
+type observer struct { outcome string }
+func (t *observer) Fatal(args ...interface{}) { panic("fatal") }
+func (t *observer) Skip(args ...interface{}) { panic("skip") }
+func (t *observer) Log(args ...interface{}) {}
+func arm64ABI0ByteRegionOriginalRun(t *observer,goos string,runner []string) {
+	if goos != "linux" { panic("wrong original runtime target") }
+	if len(runner)==0 { t.outcome="native";return }
+	if len(runner)!=1 || runner[0]!="unit-qemu" { panic("wrong guest execution prefix") }
+	t.outcome="guest"
+}
+
+func root(t *observer) `)
+	source.Write(body.Bytes())
+	source.WriteString("\n\nfunc main() {\n")
+	for _, test := range cases {
+		fmt.Fprintf(&source, `
+	{
+	runtime.GOARCH=%q
+	cross=%q
+	available=%t
+	lookups=0
+	t:=&observer{outcome:"unobserved"}
+	func() {
+		defer func() { if value:=recover();value!=nil { t.outcome=fmt.Sprint(value) } }()
+		root(t)
+	}()
+	fmt.Printf("%s=%%s/%%d\n",t.outcome,lookups)
+	}
+`, test.arch, test.cross, test.qemu, test.name)
+	}
+	source.WriteString("}\n")
+	formatted, err := format.Source([]byte(source.String()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, data := range map[string][]byte{"scope.go": formatted, "actual-linux-source.txt": original} {
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	goTool := filepath.Join(runtime.GOROOT(), "bin", "go")
+	executable := filepath.Join(dir, "scope")
+	if runtime.GOOS == "windows" {
+		executable += ".exe"
+	}
+	command := exec.CommandContext(ctx, goTool, "build", "-p=2", "-o", executable, "scope.go")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH,
+		"CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual stock Go compilation of source-role unit: %v\n%s", err, output)
+	}
+	ctx, cancel = runtimeOracleStageContext(t)
+	defer cancel()
+	command = exec.CommandContext(ctx, executable)
+	command.Dir = dir
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual source-role unit execution: %v\n%s", err, output)
+	}
+	arm64ABI0RegionRetain(t, dir, "synthetic-source-role", "actual-linux-source.txt", "scope.go", filepath.Base(executable))
+	var expected strings.Builder
+	for _, test := range cases {
+		fmt.Fprintf(&expected, "%s=%s/%d\n", test.name, test.want, test.lookups)
+	}
+	if string(output) != expected.String() {
+		t.Fatalf("actual Linux source-role routing differs; synthetic controls, not native execution:\n%s\nwant:\n%s",
+			output, expected.String())
+	}
+	t.Logf("actual SDK=%s source-role unit outcomes (no ARM64 native runtime):\n%s", runtime.Version(), output)
+}
diff --git a/arm64_abi0_byte_region_sdk_go127_test.go b/arm64_abi0_byte_region_sdk_go127_test.go
new file mode 100644
index 000000000..a0dd54180
--- /dev/null
+++ b/arm64_abi0_byte_region_sdk_go127_test.go
@@ -0,0 +1,102 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The first-party region fixture is not called "stock". This separate root
+// records the real selected SDK assembly and its actual Go-produced archive.
+// Go 1.20 does not contain the returning Or32/And32 declarations.
+func TestARM64ABI0ByteRegionSelectedSDKOriginalArchive(t *testing.T) {
+	dir := t.TempDir()
+	listed := arm64ABI0RegionCommand(t, "linux", dir, "list", "-compiled", "-export", "-json",
+		"internal/runtime/atomic")
+	var selected struct {
+		Dir, ImportPath, Export, BuildID string
+		CompiledGoFiles, SFiles          []string
+	}
+	if err := json.Unmarshal(listed, &selected); err != nil {
+		t.Fatal(err)
+	}
+	wantRoot := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "atomic")
+	physicalRoot, err := filepath.EvalSymlinks(wantRoot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualRoot, err := filepath.EvalSymlinks(selected.Dir)
+	if err != nil || actualRoot != physicalRoot || selected.ImportPath != "internal/runtime/atomic" ||
+		selected.BuildID == "" || selected.Export == "" {
+		t.Fatalf("actual selected SDK package identity changed: %#v: %v", selected, err)
+	}
+	contains := func(files []string, name string) bool {
+		for _, file := range files {
+			if filepath.Base(file) == name {
+				return true
+			}
+		}
+		return false
+	}
+	if !contains(selected.SFiles, "atomic_arm64.s") ||
+		!contains(selected.CompiledGoFiles, "atomic_arm64.go") {
+		t.Fatalf("actual SDK selection does not contain its ARM64 declaration/assembly: %#v", selected)
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil || len(archive) == 0 {
+		t.Fatalf("actual SDK archive missing: %v", err)
+	}
+	originalSHA := sha256.Sum256(archive)
+	members := arm64ABI0RegionCommand(t, "linux", dir, "tool", "pack", "t", selected.Export)
+	if strings.Count("\n"+string(members), "\natomic_arm64.o\n") != 1 {
+		t.Fatalf("actual selected archive must contain exactly one original source object:\n%s", members)
+	}
+	arm64ABI0RegionCommand(t, "linux", dir, "tool", "pack", "x", selected.Export, "atomic_arm64.o")
+	disassembled := arm64ABI0RegionCommand(t, "linux", dir, "tool", "objdump", "-s",
+		`internal/runtime/atomic\.(Or32|And32)$`, "atomic_arm64.o")
+	for _, name := range []string{"Or32", "And32"} {
+		pattern := `(?s)TEXT internal/runtime/atomic\.` + name +
+			`\(SB\)[^\n]*atomic_arm64\.s\n(.*?)(?:\n\n|$)`
+		body := regexp.MustCompile(pattern).FindSubmatch(disassembled)
+		if body == nil {
+			t.Fatalf("actual SDK archive has no source-bound %s native entry:\n%s", name, disassembled)
+		}
+		stores := regexp.MustCompile(`MOVD R[23], 24\(RSP\)`).FindAll(body[1], -1)
+		if len(stores) != 2 {
+			t.Fatalf("both actual %s paths must retain the complete 8-byte native store: %d\n%s", name, len(stores), body[1])
+		}
+	}
+	for _, name := range []string{"atomic_arm64.go", "atomic_arm64.s"} {
+		source, err := os.ReadFile(filepath.Join(actualRoot, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), source, 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("actual selected SDK %s bytes=%d SHA256=%x", name, len(source), sha256.Sum256(source))
+	}
+	for name, data := range map[string][]byte{
+		"selection.json": listed, "original.a": archive, "original.objdump": disassembled, "members.txt": members,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	after, err := os.ReadFile(selected.Export)
+	if err != nil || sha256.Sum256(after) != originalSHA {
+		t.Fatalf("actual archive changed during source/object observation: %v", err)
+	}
+	arm64ABI0RegionRetain(t, dir, "actual-selected-SDK", "selection.json", "original.a",
+		"original.objdump", "members.txt", "atomic_arm64.o", "atomic_arm64.go", "atomic_arm64.s")
+	t.Logf("actual SDK=%s archive bytes=%d SHA256=%x; complete source-bound disassembly:\n%s",
+		runtime.Version(), len(archive), originalSHA, strings.TrimSpace(string(disassembled)))
+	t.Log("selected SDK source/archive identity does not prove all native callers or permit padding clipping")
+}
diff --git a/arm64_abi0_byte_region_witness_test.go b/arm64_abi0_byte_region_witness_test.go
new file mode 100644
index 000000000..f4fdb2859
--- /dev/null
+++ b/arm64_abi0_byte_region_witness_test.go
@@ -0,0 +1,460 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"go/format"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This file records compiler/assembler observations. Nothing captured here is
+// an Options input, a source capability, or authority to discard result bytes.
+type arm64ABI0RegionCase struct {
+	name                  string
+	move                  Op
+	resultBits, storeBits int
+}
+
+func arm64ABI0RegionCases() []arm64ABI0RegionCase {
+	var result []arm64ABI0RegionCase
+	for _, test := range arm64NativeResultTailCases() {
+		result = append(result, arm64ABI0RegionCase{
+			name: test.name(), move: test.op,
+			resultBits: test.resultBits, storeBits: test.storeBits,
+		})
+	}
+	return append(result, arm64ABI0RegionCase{
+		name: "Exact32", move: "MOVW", resultBits: 32, storeBits: 32,
+	})
+}
+
+func (test arm64ABI0RegionCase) declaration() string {
+	return fmt.Sprintf("func %s(input uint64, trace *[4]uint64) (result uint%d)\n",
+		test.name, test.resultBits)
+}
+
+func (test arm64ABI0RegionCase) callee() string {
+	return fmt.Sprintf(`TEXT ·%s(SB),4,$0-%d
+	MOVD input+0(FP),R0
+	MOVD trace+8(FP),R1
+	MOVD $input+0(FP),R2
+	MOVD R2,0(R1)
+	MOVD $result+16(FP),R2
+	MOVD R2,8(R1)
+	MOVD RSP,R2
+	MOVD R2,16(R1)
+	MOVD R30,R2
+	MOVD R2,24(R1)
+	%s R0,result+16(FP)
+	RET
+`, test.name, 16+test.resultBits/8, test.move)
+}
+
+func (test arm64ABI0RegionCase) observer() string {
+	load := map[int]string{8: "MOVBU", 16: "MOVHU", 32: "MOVWU"}[test.resultBits]
+	return fmt.Sprintf(`TEXT ·Observe_%s(SB),4,$96-88
+	MOVD input+0(FP),R0
+	MOVD R0,8(RSP)
+	ADD $40,RSP,R1
+	MOVD R1,16(RSP)
+	MOVD $0xfeedfacecafebeef,R1
+	MOVD R1,24(RSP)
+	MOVD $0x7ac35ef012345678,R1
+	MOVD R1,32(RSP)
+	MOVD R1,40(RSP)
+	MOVD R1,48(RSP)
+	MOVD R1,56(RSP)
+	MOVD R1,64(RSP)
+	MOVD RSP,R1
+	MOVD R1,72(RSP)
+	MOVD 0(RSP),R1
+	MOVD R1,80(RSP)
+	CALL ·%s(SB)
+	MOVD R30,R3
+	MOVD RSP,R1
+	MOVD R1,after+64(FP)
+	MOVD R3,returnPC+80(FP)
+	%s 24(RSP),R0
+	MOVD R0,value+8(FP)
+	MOVD 24(RSP),R0
+	MOVD R0,native+16(FP)
+	MOVD 32(RSP),R0
+	MOVD R0,guard+24(FP)
+	MOVD 40(RSP),R0
+	MOVD R0,incoming+32(FP)
+	MOVD 48(RSP),R0
+	MOVD R0,resultAddress+40(FP)
+	MOVD 56(RSP),R0
+	MOVD R0,calleeSP+48(FP)
+	MOVD 72(RSP),R0
+	MOVD R0,before+56(FP)
+	MOVD 64(RSP),R0
+	CMP R3,R0
+	BNE broken
+	MOVD 80(RSP),R0
+	MOVD 0(RSP),R1
+	CMP R0,R1
+	BNE broken
+	MOVD R0,savedLink+72(FP)
+	RET
+broken:
+	UNDEF
+`, test.name, test.name, load)
+}
+
+func arm64ABI0RegionDeclarations(cases []arm64ABI0RegionCase) string {
+	var source strings.Builder
+	source.WriteString("package main\n\n")
+	for _, test := range cases {
+		source.WriteString(test.declaration())
+		fmt.Fprintf(&source, "func Observe_%s(input uint64) "+
+			"(value,native,guard,incoming,resultAddress,calleeSP,before,after,savedLink,returnPC uint64)\n",
+			test.name)
+		fmt.Fprintf(&source, "func Typed_%s(input uint64, trace *[4]uint64) uint%d {\n"+
+			"return %s(input,trace)\n}\n", test.name, test.resultBits, test.name)
+	}
+	return source.String()
+}
+
+func arm64ABI0RegionCode(t *testing.T, listing, name string) []byte {
+	t.Helper()
+	body := arm64ResultTailAuditSection(t, listing, name)
+	var result []byte
+	for _, row := range regexp.MustCompile(`(?m)^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`).FindAllStringSubmatch(body, -1) {
+		data, err := hex.DecodeString(strings.ReplaceAll(row[1], " ", ""))
+		if err != nil {
+			t.Fatal(err)
+		}
+		result = append(result, data...)
+	}
+	if len(result) == 0 {
+		t.Fatalf("actual object listing has no code for %s", name)
+	}
+	return result
+}
+
+func arm64ABI0RegionCommand(t *testing.T, goos, dir string, args ...string) []byte {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	goTool := filepath.Join(runtime.GOROOT(), "bin", "go")
+	command := exec.CommandContext(ctx, goTool, args...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64",
+		"CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+	t.Logf("actual original command=%q cwd=%q target=%s/arm64 SDK=%s CGO=0 GOENV=off GOWORK=off GOFLAGS=empty",
+		command.Args, command.Dir, goos, runtime.Version())
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual selected SDK command failed: %v\n%s", err, output)
+	}
+	return output
+}
+
+func arm64ABI0RegionRetain(t *testing.T, dir, role string, names ...string) {
+	t.Helper()
+	output := os.Getenv("PLAN9ASM_ABI0_REGION_EVIDENCE")
+	if output == "" {
+		return
+	}
+	identity := sha256.Sum256([]byte(t.Name() + "/" + role))
+	output = filepath.Join(output, fmt.Sprintf("%x", identity[:]))
+	if err := os.MkdirAll(filepath.Dir(output), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(output, 0700); err != nil {
+		t.Fatalf("evidence must not overwrite another observation: %v", err)
+	}
+	for _, name := range names {
+		data, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(output, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("retained %s/%s bytes=%d SHA256=%x", output, name, len(data), sha256.Sum256(data))
+	}
+}
+
+func TestARM64ABI0ByteRegionActualCompilerAndObjectWitness(t *testing.T) {
+	cases := arm64ABI0RegionCases()
+	if len(cases) != 10 {
+		t.Fatalf("nine wide stores plus exact 4-byte control changed: %d", len(cases))
+	}
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			dir := t.TempDir()
+			var assembly strings.Builder
+			for _, test := range cases {
+				assembly.WriteString(strings.ReplaceAll(test.callee(), "·", "main·"))
+			}
+			for name, source := range map[string]string{
+				"decl.go": arm64ABI0RegionDeclarations(cases), "original.s": assembly.String(),
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Logf("first-party source %s bytes=%d SHA256=%x", name, len(source), sha256.Sum256([]byte(source)))
+			}
+			arm64ABI0RegionCommand(t, goos, dir, "tool", "asm", "-p", "main",
+				"-gensymabis", "-o", "symabis", "original.s")
+			listing := arm64ABI0RegionCommand(t, goos, dir, "tool", "asm", "-p", "main",
+				"-S", "-o", "original.o", "original.s")
+			compiled := arm64ABI0RegionCommand(t, goos, dir, "tool", "compile", "-p", "main",
+				"-S", "-symabis", "symabis", "-o", "compiler.o", "decl.go")
+			for _, test := range cases {
+				code := arm64ABI0RegionCode(t, string(listing), "main."+test.name)
+				// The final native STR has source R0, base SP and physical +24.
+				want := map[int]uint32{16: 0x790033e0, 32: 0xb9001be0, 64: 0xf9000fe0}[test.storeBits]
+				if len(code) < 8 || binary.LittleEndian.Uint32(code[len(code)-8:]) != want ||
+					binary.LittleEndian.Uint32(code[len(code)-4:]) != 0xd65f03c0 {
+					t.Fatalf("original native store/RET identity changed: %s code=%x want=%08x", test.name, code, want)
+				}
+				for _, name := range []string{"main." + test.name, "main.Typed_" + test.name} {
+					body := arm64ResultTailAuditSection(t, string(compiled), name)
+					// ABIInternal has two register arguments (16 bytes). Its
+					// outgoing ABI0 region is a different, compiler-owned area.
+					frame := regexp.MustCompile(`\tTEXT\t` + regexp.QuoteMeta(name) + `\(SB\),[^\n]*\$([0-9]+)-16\n`).FindStringSubmatch(body)
+					if frame == nil {
+						t.Fatalf("actual wrapper/caller has no typed 16-byte ABIInternal input extent: %s\n%s", name, body)
+					}
+					bytes, err := strconv.Atoi(frame[1])
+					postRestore := strings.Contains(body, fmt.Sprintf("\tMOVD.P\t%d(RSP), R30\n", bytes))
+					pairRestore := strings.Contains(body, "\tLDP\t-8(RSP), (R29, R30)\n") &&
+						strings.Contains(body, fmt.Sprintf("\tADD\t$%d, RSP\n", bytes))
+					if err != nil || bytes < 32 || bytes > 4096 ||
+						!strings.Contains(body, fmt.Sprintf("\tMOVD.W\tR30, -%d(RSP)\n", bytes)) ||
+						(!postRestore && !pairRestore) ||
+						!strings.Contains(body, "\tCALL\tmain."+test.name+"(SB)\n") {
+						t.Fatalf("actual caller does not reserve/call the complete native region: %s\n%s", name, body)
+					}
+					pair := strings.Contains(body, "\tSTP\t(R0, R1), 8(RSP)\n")
+					individual := strings.Contains(body, "\tMOVD\tR0, 8(RSP)\n") &&
+						strings.Contains(body, "\tMOVD\tR1, 16(RSP)\n")
+					if !pair && !individual {
+						t.Fatalf("actual arguments do not supply complete outgoing [8,24): %s\n%s", name, body)
+					}
+					load := map[int]string{8: "MOVBU", 16: "MOVHU", 32: "MOVWU"}[test.resultBits]
+					for _, instruction := range []string{load + "\t24(RSP), R0", "RET\t(R30)"} {
+						if !strings.Contains(body, "\t"+instruction+"\n") {
+							t.Fatalf("actual typed caller mapping missing %q: %s\n%s", instruction, name, body)
+						}
+					}
+					t.Logf("actual compiler source-bound %s:\n%s", name, body)
+				}
+				t.Logf("actual original code %s=%x; layout is observation, not native backing permission", test.name, code)
+			}
+			for _, name := range []string{"symabis", "original.o", "compiler.o"} {
+				data, err := os.ReadFile(filepath.Join(dir, name))
+				if err != nil || len(data) == 0 {
+					t.Fatalf("missing actual artifact %s: %v", name, err)
+				}
+				t.Logf("actual SDK %s artifact %s bytes=%d SHA256=%x", runtime.Version(), name, len(data), sha256.Sum256(data))
+			}
+			arm64ABI0RegionRetain(t, dir, goos, "decl.go", "original.s", "symabis", "original.o", "compiler.o")
+		})
+	}
+}
+
+func TestARM64ABI0ByteRegionObservationDoesNotGrantSlots(t *testing.T) {
+	for _, test := range arm64ABI0RegionCases() {
+		if test.storeBits == test.resultBits {
+			// Exact-width positive objects are independently required by
+			// TestARM64NativeResultTailExactDeclaredWidthObjects. The trace
+			// addresses here do not grant that positive a new pointer role.
+			continue
+		}
+		pkg := mustGoPackage(t, "main", "package main\n"+test.declaration())
+		sig, err := DeriveGoFuncABI0Signature("main."+test.name,
+			pkg.Types.Scope().Lookup(test.name).(*types.Func), "arm64", types.SizesFor("gc", "arm64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 16 ||
+			frameTypeSize(sig.Frame.Results[0].Type, 8) != int64(test.resultBits/8) {
+			t.Fatalf("declared layout acquired a padding slot: %#v", sig.Frame)
+		}
+		for _, role := range []string{"isolated", "native-caller", "code-address", "data-address"} {
+			source := test.callee()
+			declaration := test.declaration()
+			switch role {
+			case "native-caller":
+				declaration += "func Observer(input uint64,trace *[4]uint64) uint64\n"
+				source += fmt.Sprintf("TEXT ·Observer(SB),4,$48-24\nMOVD input+0(FP),R0\nMOVD R0,8(RSP)\n"+
+					"MOVD trace+8(FP),R0\nMOVD R0,16(RSP)\nCALL ·%s(SB)\n"+
+					"MOVD 24(RSP),R0\nMOVD R0,ret+16(FP)\nRET\n", test.name)
+			case "code-address":
+				declaration += "func Address() uintptr\n"
+				source += fmt.Sprintf("TEXT ·Address(SB),4,$0-8\nMOVD $·%s(SB),R0\nMOVD R0,ret+0(FP)\nRET\n", test.name)
+			case "data-address":
+				source += fmt.Sprintf("DATA entry<>+0(SB)/8,$·%s(SB)\nGLOBL entry<>(SB),8,$8\n", test.name)
+			}
+			t.Run(test.name+"/"+role+"/original-Go-object", func(t *testing.T) {
+				dir := t.TempDir()
+				original := strings.ReplaceAll(source, "·", "main·")
+				if err := os.WriteFile(filepath.Join(dir, "original.s"), []byte(original), 0600); err != nil {
+					t.Fatal(err)
+				}
+				listing := arm64ABI0RegionCommand(t, "linux", dir, "tool", "asm",
+					"-p", "main", "-S", "-o", "original.o", "original.s")
+				object, err := os.ReadFile(filepath.Join(dir, "original.o"))
+				if err != nil || len(object) == 0 {
+					t.Fatalf("actual source role has no original object: %v", err)
+				}
+				arm64ABI0RegionRetain(t, dir, role, "original.s", "original.o")
+				t.Logf("actual SDK=%s source bytes=%d SHA256=%x; object bytes=%d SHA256=%x; listing:\n%s",
+					runtime.Version(), len(original), sha256.Sum256([]byte(original)), len(object), sha256.Sum256(object), listing)
+			})
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(test.name+"/"+role+"/"+api, func(t *testing.T) {
+					_, err := arm64ResultTailAuditTranslate(t, api, arm64LinuxGNUTriple, declaration, source)
+					if test.storeBits > test.resultBits {
+						if err == nil || !strings.Contains(err.Error(), "has no slot") {
+							t.Fatalf("actual caller/allocation observation granted native padding: %v", err)
+						}
+						t.Logf("missing real storage/call-effect producer remains F: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ABI0ByteRegionExactFourByteDeclaredObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	declaration := "func Exact32(input uint64, trace *[4]uint64) (result uint32)\n"
+	source := "TEXT ·Exact32(SB),4,$0-20\nMOVD input+0(FP),R0\nMOVW R0,result+16(FP)\nRET\n"
+	for _, target := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc", "aarch64-unknown-freebsd"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target+"/"+api, func(t *testing.T) {
+				ir, err := arm64ResultTailAuditTranslate(t, api, target, declaration, source)
+				if err != nil {
+					t.Fatalf("actual exact declared width must retain its ordinary contract: %v", err)
+				}
+				compileLLVMToObject(t, llc, target, "exact32.ll", "exact32.o", ir)
+			})
+		}
+	}
+}
+
+func arm64ABI0ByteRegionOriginalBuild(t *testing.T, goos string) (string, string, []byte) {
+	t.Helper()
+	cases := arm64ABI0RegionCases()
+	var assembly, driver strings.Builder
+	driver.WriteString("package main\n\nimport \"fmt\"\n\nfunc main() {\nobservations:=0\n")
+	for _, test := range cases {
+		assembly.WriteString(test.callee())
+		assembly.WriteString(test.observer())
+		mask := ^uint64(0) >> uint(64-test.resultBits)
+		storeMask := ^uint64(0) >> uint(64-test.storeBits)
+		fmt.Fprintf(&driver, `for _, input := range []uint64{0,1,0x7f,0x80,0xff,0x7fff,0x8000,0xffff,0x7fffffff,0x80000000,0xffffffff,0x123456789abcdef0,0xffffffffffffffff} {
+	value,native,guard,incoming,resultAddress,calleeSP,before,after,savedLink,returnPC:=Observe_%s(input)
+	wantNative:=(uint64(0xfeedfacecafebeef)&^uint64(0x%x))|(input&uint64(0x%x))
+	if value!=input&uint64(0x%x)||native!=wantNative||guard!=0x7ac35ef012345678||
+		incoming!=before+8||resultAddress!=before+24||calleeSP!=before||before!=after||savedLink==0||returnPC==0||returnPC&3!=0 {
+		panic(fmt.Sprintf("%s input=%%x value=%%x native=%%x guard=%%x mapping=%%x/%%x SP=%%x/%%x/%%x links=%%x/%%x",input,value,native,guard,incoming,resultAddress,calleeSP,before,after,savedLink,returnPC))
+	}
+	var trace [4]uint64
+	typed:=Typed_%s(input,&trace)
+	if uint64(typed)!=input&uint64(0x%x)||trace[0]==0||trace[1]!=trace[0]+16||trace[2]+8!=trace[0]||trace[3]==0 {
+		panic("actual typed caller/result mapping changed")
+	}
+	observations++
+}
+`, test.name, storeMask, storeMask, mask, test.name, test.name, mask)
+	}
+	driver.WriteString("fmt.Printf(\"ABI0 original same-call region observations %d\\n\",observations)\n}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{"go.mod": "module regionwitness\n\ngo 1.20\n",
+		"decl.go": arm64ABI0RegionDeclarations(cases), "original_arm64.s": assembly.String(), "main.go": driver.String()} {
+		if strings.HasSuffix(name, ".go") {
+			formatted, err := format.Source([]byte(source))
+			if err != nil {
+				t.Fatalf("first-party generated Go source %s: %v", name, err)
+			}
+			source = string(formatted)
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("first-party original source %s bytes=%d SHA256=%x", name, len(source), sha256.Sum256([]byte(source)))
+	}
+	executable := filepath.Join(dir, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	t.Logf("actual original compiler=%q cwd=%q SDK=%s target=%s/arm64 CGO=0",
+		command.Args, command.Dir, runtime.Version(), goos)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual original Go build: %v\n%s", err, output)
+	}
+	before, err := os.ReadFile(executable)
+	if err != nil || len(before) == 0 {
+		t.Fatalf("actual executable missing: %v", err)
+	}
+	return dir, executable, before
+}
+
+func TestARM64ABI0ByteRegionOriginalLinuxELFBuild(t *testing.T) {
+	dir, _, data := arm64ABI0ByteRegionOriginalBuild(t, "linux")
+	image, err := elf.NewFile(bytes.NewReader(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer image.Close()
+	if image.Class != elf.ELFCLASS64 || image.Machine != elf.EM_AARCH64 || image.Type != elf.ET_EXEC {
+		t.Fatalf("required original Linux execution artifact has another identity: %#v", image.FileHeader)
+	}
+	for _, segment := range image.Progs {
+		if segment.Type == elf.PT_INTERP {
+			t.Fatal("CGO-disabled original ARM64 fixture unexpectedly needs an interpreter")
+		}
+	}
+	arm64ABI0RegionRetain(t, dir, "original-Linux-build-only", "go.mod", "decl.go", "original_arm64.s", "main.go", "original")
+	t.Logf("actual SDK=%s original Linux/ARM64 static ELF bytes=%d SHA256=%x; BUILD ONLY, no runtime P",
+		runtime.Version(), len(data), sha256.Sum256(data))
+}
+
+func arm64ABI0ByteRegionOriginalRun(t *testing.T, goos string, runner []string) {
+	t.Helper()
+	dir, executable, before := arm64ABI0ByteRegionOriginalBuild(t, goos)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	args := append(append([]string(nil), runner...), executable)
+	command := exec.CommandContext(ctx, args[0], args[1:]...)
+	command.Dir = dir
+	t.Logf("actual original execution=%q cwd=%q", command.Args, command.Dir)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	want := fmt.Sprintf("ABI0 original same-call region observations %d\n", len(arm64ABI0RegionCases())*13)
+	if err != nil || string(output) != want {
+		t.Fatalf("original full-region identity/bytes/canary/restoration: %v\n%s", err, output)
+	}
+	after, err := os.ReadFile(executable)
+	if err != nil || sha256.Sum256(before) != sha256.Sum256(after) {
+		t.Fatalf("executed original artifact changed: %v", err)
+	}
+	arm64ABI0RegionRetain(t, dir, "executed-original", "go.mod", "decl.go", "original_arm64.s", "main.go", "original")
+	t.Logf("actual SDK=%s target=%s/arm64 prefix=%q ELF-or-MachO bytes=%d SHA256=%x\n%s",
+		runtime.Version(), goos, runner, len(before), sha256.Sum256(before), output)
+	t.Log("source and machine observations only; no compiler-owned transport capability and no benchmark P")
+}
diff --git a/arm64_abi0_tail_binding_test.go b/arm64_abi0_tail_binding_test.go
new file mode 100644
index 000000000..0b9a5fb86
--- /dev/null
+++ b/arm64_abi0_tail_binding_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func arm64ABI0BoundFixture(t *testing.T) (GoPackage, *File, map[string]FuncSig) {
+	t.Helper()
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	pkg, sig := arm64ABI0TailResultSignature(t, declaration)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(goTextSymbolForResolution(symbol), "·") }
+	sigs, err := BindGoARM64ABI0TailDeclarations(pkg, file, resolve, map[string]FuncSig{"Slots": sig})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sigs["Slots"].arm64ABI0TailDeclaration == nil {
+		t.Fatalf("actual typed declaration was not consumed: root=%#v", file.Funcs[0])
+	}
+	return pkg, file, sigs
+}
+
+func TestARM64ABI0TailResultBindingAndPreparedSeal(t *testing.T) {
+	_, file, sigs := arm64ABI0BoundFixture(t)
+	original := arm64ABI0FileSnapshot(file)
+	resolve := func(symbol string) string { return strings.TrimPrefix(goTextSymbolForResolution(symbol), "·") }
+	prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(prepared.Funcs) != 1 || prepared.Funcs[0].arm64ABI0TailSource == nil || !reflect.DeepEqual(original, arm64ABI0FileSnapshot(file)) {
+		t.Fatalf("complete declaration source was not independently sealed: funcs=%d proof=%t", len(prepared.Funcs), prepared.Funcs[0].arm64ABI0TailSource != nil)
+	}
+	normalized, err := normalizeARM64ScalarMemoryFrame(prepared.Funcs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := validateARM64ABI0TailSource(normalized, sigs["Slots"]); err != nil {
+		t.Fatalf("actual FP frame normalization lost the sealed prepared source: %v", err)
+	}
+	if !reflect.DeepEqual(arm64PrivateTailSnapshot(normalized), arm64PrivateTailSnapshot(prepared.Funcs[0])) {
+		t.Fatal("sealed FP normalization is not idempotent")
+	}
+	t.Run("physical-FP-marker", func(t *testing.T) {
+		_, file, sigs := arm64ABI0BoundFixture(t)
+		prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+		if err != nil {
+			t.Fatal(err)
+		}
+		marker := prepared.Funcs[0].Instrs[1].arm64ScalarMemoryFrameOffset
+		if marker == nil {
+			t.Fatal("actual FP load has no bound physical offset")
+		}
+		*marker = *marker + 1
+		if err := validateARM64ABI0TailSource(prepared.Funcs[0], sigs["Slots"]); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("changed physical FP marker retained its result capability: %v", err)
+		}
+	})
+	for _, changed := range []bool{false, true} {
+		t.Run(map[bool]string{false: "prepared", true: "original"}[changed], func(t *testing.T) {
+			_, file, sigs := arm64ABI0BoundFixture(t)
+			prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if changed {
+				file.Funcs[0].ArgSize++
+			} else {
+				prepared.Funcs[0].Instrs[len(prepared.Funcs[0].Instrs)-2].Args[0].Reg = "R7"
+			}
+			if err := validateARM64ABI0TailSource(prepared.Funcs[0], sigs["Slots"]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed source/prepared retained its result capability: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_abi0_tail_declaration.go b/arm64_abi0_tail_declaration.go
new file mode 100644
index 000000000..383e9067d
--- /dev/null
+++ b/arm64_abi0_tail_declaration.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+)
+
+// This is a layout observation, not bodyless-source or memory permission.
+// Only the explicit source binder below produces the separate source record.
+type arm64ABI0Declaration struct {
+	function  *types.Func
+	signature FuncSig
+	argsSize  int64
+	types     string
+}
+
+func arm64ABI0SignatureSnapshot(sig FuncSig) FuncSig {
+	sig.arm64ABI0Declaration, sig.arm64ABI0TailDeclaration = nil, nil
+	sig.arm64NativeScratch = nil
+	sig.Args = append([]LLVMType(nil), sig.Args...)
+	sig.Frame.Params = arm64CopyFPSlots(sig.Frame.Params)
+	sig.Frame.Results = arm64CopyFPSlots(sig.Frame.Results)
+	return sig
+}
+
+func arm64ABI0DeclarationForGo(sig FuncSig, fn *types.Func, sizes, frameSizes types.Sizes) *arm64ABI0Declaration {
+	decl, ok := fn.Type().(*types.Signature)
+	if !ok || fn.Pkg() == nil || fn.Parent() != fn.Pkg().Scope() || decl.Recv() != nil || decl.Variadic() ||
+		decl.Params().Len() > 64 || decl.Results().Len() == 0 || decl.Results().Len() > 16 {
+		return nil
+	}
+	for _, layout := range []types.Sizes{sizes, frameSizes} {
+		if layout == nil || !arm64PaddingDeclarationLayoutMatches(layout, decl) {
+			return nil
+		}
+	}
+	gc := types.SizesFor("gc", "arm64")
+	args, params, end, err := goLLVMArgsAndFrameSlotsForTuple(decl.Params(), "arm64", gc, gc, 0, false)
+	if err != nil {
+		return nil
+	}
+	results, slots, end, err := goLLVMArgsAndFrameSlotsForTuple(decl.Results(), "arm64", gc, gc, goAlignOff(end, 8), true)
+	if err != nil || end < 0 || end > 65536 || !reflect.DeepEqual(args, sig.Args) ||
+		!reflect.DeepEqual(params, sig.Frame.Params) || !reflect.DeepEqual(slots, sig.Frame.Results) ||
+		goTupleRetType(results) != sig.Ret || len(slots) != decl.Results().Len() {
+		return nil
+	}
+	for i, slot := range slots {
+		basic, ok := decl.Results().At(i).Type().Underlying().(*types.Basic)
+		if !ok || basic.Info()&types.IsInteger == 0 || slot.Field != -1 || len(slot.Fields) != 0 ||
+			(slot.Type != I8 && slot.Type != I16 && slot.Type != I32 && slot.Type != I64) {
+			return nil // No aggregate interiors, floating/GC results or guessed layout.
+		}
+	}
+	return &arm64ABI0Declaration{function: fn, signature: arm64ABI0SignatureSnapshot(sig), argsSize: end,
+		types: arm64ABI0DeclarationTypes(decl)}
+}
+
+func arm64ABI0DeclarationTypes(decl *types.Signature) string {
+	identity := types.TypeString(decl, func(pkg *types.Package) string { return pkg.Path() })
+	for _, tuple := range []*types.Tuple{decl.Params(), decl.Results()} {
+		for i := 0; i < tuple.Len(); i++ {
+			identity += "|" + types.TypeString(tuple.At(i).Type().Underlying(), func(pkg *types.Package) string { return pkg.Path() })
+		}
+	}
+	return identity
+}
+
+func (d *arm64ABI0Declaration) matches(sig FuncSig) bool {
+	return d != nil && d.function != nil && d.function.Pkg() != nil &&
+		d.function.Pkg().Scope().Lookup(d.function.Name()) == d.function &&
+		arm64ABI0DeclarationTypes(d.function.Type().(*types.Signature)) == d.types &&
+		reflect.DeepEqual(d.signature, arm64ABI0SignatureSnapshot(sig))
+}
+
+// Hold the actual typed selection as well as independent byte/AST snapshots.
+// A public layout, JSON, or a name-equivalent declaration cannot recreate it.
+type arm64ABI0TailDeclaration struct {
+	declaration *arm64ABI0Declaration
+	packageData GoPackage
+	syntax      []string
+	sources     map[string][]byte
+	selected    []string
+	fset        *token.FileSet
+	file        *File
+	original    File
+	root        Func
+	name        string
+	symbolPath  string
+	object      *ast.Ident
+}
+
+func arm64ABI0Syntax(file *ast.File, fset *token.FileSet) (string, error) {
+	if file == nil || file.Name == nil || fset == nil {
+		return "", fmt.Errorf("incomplete actual Go syntax")
+	}
+	for _, node := range file.Decls {
+		if fn, ok := node.(*ast.FuncDecl); ok && (fn == nil || fn.Name == nil) {
+			return "", fmt.Errorf("incomplete actual Go function declaration")
+		}
+	}
+	var output bytes.Buffer
+	err := format.Node(&output, fset, file)
+	return output.String(), err
+}
+
+func arm64ABI0FileSnapshot(file *File) File {
+	copyFile := *file
+	copyFile.Funcs = append([]Func(nil), file.Funcs...)
+	for i := range copyFile.Funcs {
+		copyFile.Funcs[i] = arm64PrivateTailSnapshot(copyFile.Funcs[i])
+	}
+	copyFile.Data = append([]DataStmt(nil), file.Data...)
+	for i := range copyFile.Data {
+		copyFile.Data[i].Payload = append([]byte(nil), copyFile.Data[i].Payload...)
+	}
+	copyFile.Globl = append([]GloblStmt(nil), file.Globl...)
+	copyFile.UnlinkedPrelude = append([]string(nil), file.UnlinkedPrelude...)
+	return copyFile
+}
+
+func arm64ABI0TailPackageNamespaceMatches(pkg GoPackage, function, symbol string) bool {
+	if pkg.Types == nil {
+		return false
+	}
+	if pkg.Path == pkg.Types.Path() {
+		return true
+	}
+	// Executables use main's symbol namespace while retaining the actual
+	// typechecked source package. This is not an arbitrary package alias.
+	return pkg.Path == "main" && pkg.Types.Name() == "main" && symbol == "main."+function
+}
+
+func (d *arm64ABI0TailDeclaration) matches(sig FuncSig) bool {
+	if d == nil || !d.declaration.matches(sig) || d.file == nil ||
+		!reflect.DeepEqual(d.original, arm64ABI0FileSnapshot(d.file)) || d.packageData.Types == nil ||
+		d.packageData.Types != d.declaration.function.Pkg() || d.packageData.Path != d.symbolPath ||
+		!arm64ABI0TailPackageNamespaceMatches(d.packageData, d.declaration.function.Name(), d.name) {
+		return false
+	}
+	selection := d.packageData.SourceSelection
+	if selection == nil || selection.Fset == nil || selection.Fset != d.fset || selection.TypesInfo == nil ||
+		selection.Sizes == nil || !arm64PaddingDeclarationLayoutMatches(selection.Sizes, d.declaration.function.Type().(*types.Signature)) ||
+		selection.TypesInfo.Defs[d.object] != d.declaration.function ||
+		!reflect.DeepEqual(d.selected, selection.SelectedGoFiles) || len(d.syntax) != len(d.packageData.Syntax) ||
+		len(d.sources) != len(selection.GoSources) {
+		return false
+	}
+	for name, original := range d.sources {
+		if !bytes.Equal(original, selection.GoSources[name]) {
+			return false
+		}
+	}
+	for i, file := range d.packageData.Syntax {
+		text, err := arm64ABI0Syntax(file, selection.Fset)
+		if err != nil || text != d.syntax[i] || file.Name.Name != d.packageData.Types.Name() {
+			return false
+		}
+	}
+	return true
+}
+
+// BindGoARM64ABI0TailDeclarations binds only actually consumed local ABI0 tail
+// roots to the same typechecked bodyless declarations and complete selected Go
+// bytes. It certifies neither ZIP/CPP/tool provenance nor a native extent. The
+// complete source continuation and every return still need their own proof.
+// Neither input is modified. File-only preparation remains strict.
+func BindGoARM64ABI0TailDeclarations(pkg GoPackage, file *File, resolve func(string) string, sigs map[string]FuncSig) (map[string]FuncSig, error) {
+	result := make(map[string]FuncSig, len(sigs))
+	for name, sig := range sigs {
+		result[name] = sig
+	}
+	if file == nil || file.Arch != ArchARM64 {
+		return result, nil
+	}
+	for _, root := range file.Funcs {
+		candidate := arm64ABI0TailCandidate(file, root)
+		if !candidate || strings.HasSuffix(root.Sym, "<ABIInternal>") || strings.HasSuffix(root.Sym, "<>") {
+			continue
+		}
+		if resolve == nil || !strings.HasPrefix(root.Sym, "·") || strings.ContainsAny(strings.TrimPrefix(root.Sym, "·"), "·<>") {
+			return nil, arm64GoABIContext("ABI0 tail needs an exact local declaration/source namespace")
+		}
+		name := resolve(goTextSymbolForResolution(root.Sym))
+		sig := result[name]
+		if len(sig.ArgRegs) != 0 {
+			continue // Existing explicit callable-helper register transport stays separate.
+		}
+		decl := sig.arm64ABI0Declaration
+		selection := pkg.SourceSelection
+		if !decl.matches(sig) || pkg.Types == nil || pkg.Types != decl.function.Pkg() ||
+			!arm64ABI0TailPackageNamespaceMatches(pkg, decl.function.Name(), name) ||
+			decl.function.Name() != strings.TrimPrefix(root.Sym, "·") ||
+			selection == nil || selection.Fset == nil || selection.TypesInfo == nil || selection.Sizes == nil ||
+			len(selection.SelectedGoFiles) == 0 || len(selection.SelectedGoFiles) > 256 ||
+			len(selection.GoSources) != len(selection.SelectedGoFiles) || len(pkg.Syntax) != len(selection.SelectedGoFiles) {
+			return nil, arm64GoABIContext("ABI0 tail lacks its actual selected bodyless declaration")
+		}
+		bound := &arm64ABI0TailDeclaration{
+			declaration: decl, packageData: pkg, sources: make(map[string][]byte),
+			selected: append([]string(nil), selection.SelectedGoFiles...), fset: selection.Fset, file: file,
+			original: arm64ABI0FileSnapshot(file), root: arm64PrivateTailSnapshot(root), name: name, symbolPath: pkg.Path,
+		}
+		total := 0
+		for i, filename := range selection.SelectedGoFiles {
+			source, present := selection.GoSources[filename]
+			total += len(source)
+			if !present || len(source) == 0 || total > 16<<20 || bound.sources[filename] != nil {
+				return nil, arm64GoABIContext("ABI0 tail has an incomplete/oversized selected Go inventory")
+			}
+			parsedSet := token.NewFileSet()
+			parsed, err := parser.ParseFile(parsedSet, filename, source, parser.ParseComments)
+			if err != nil {
+				return nil, arm64GoABIContext("ABI0 tail selected Go source cannot parse: %v", err)
+			}
+			actual, err := arm64ABI0Syntax(pkg.Syntax[i], selection.Fset)
+			fromBytes, parseErr := arm64ABI0Syntax(parsed, parsedSet)
+			if err != nil || parseErr != nil || actual != fromBytes || pkg.Syntax[i].Name.Name != pkg.Types.Name() {
+				return nil, arm64GoABIContext("ABI0 tail typed syntax differs from its complete selected bytes")
+			}
+			bound.syntax = append(bound.syntax, actual)
+			bound.sources[filename] = append([]byte(nil), source...)
+			for _, node := range pkg.Syntax[i].Decls {
+				fn, ok := node.(*ast.FuncDecl)
+				if !ok || fn.Name.Name != decl.function.Name() {
+					continue
+				}
+				if bound.object != nil || fn.Recv != nil || fn.Body != nil ||
+					selection.TypesInfo.Defs[fn.Name] != decl.function || fn.Name.Pos() != decl.function.Pos() ||
+					selection.Fset.Position(fn.Name.Pos()).Filename != filename {
+					return nil, arm64GoABIContext("ABI0 tail declaration role/type identity is not bodyless")
+				}
+				bound.object = fn.Name
+			}
+		}
+		if bound.object == nil || !bound.matches(sig) {
+			return nil, arm64GoABIContext("ABI0 tail has no complete actual bodyless source binding")
+		}
+		sig.arm64ABI0TailDeclaration = bound
+		result[name] = sig
+	}
+	return result, nil
+}
+
+// The source binding is needed only for actual ABI0 private tails. Ordinary
+// files and Phase1 ABIInternal roots do not load a second declaration graph.
+func GoARM64ABI0TailDeclarationBindingNeeded(file *File) bool {
+	if file == nil || file.Arch != ArchARM64 {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		if strings.Contains(fn.Sym, "<") {
+			continue
+		}
+		if arm64ABI0TailCandidate(file, fn) {
+			return true
+		}
+	}
+	return false
+}
+
+func arm64ABI0TailCandidate(file *File, root Func) bool {
+	for _, ins := range root.Instrs {
+		name, tail := arm64PrivateTailTarget(ins)
+		if !tail {
+			continue
+		}
+		for _, helper := range file.Funcs {
+			if helper.Sym != name || helper.ArgSize != 0 {
+				continue
+			}
+			fp := false
+			for _, instruction := range helper.Instrs {
+				for _, arg := range instruction.Args {
+					fp = fp || arg.Kind == OpFP || arg.Kind == OpFPAddr
+				}
+			}
+			if !fp {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func goBindARM64ABI0TailDeclarations(pkg GoPackage, file *File, resolve func(string) string, opt GoModuleOptions) (map[string]FuncSig, error) {
+	if !GoARM64ABI0TailDeclarationBindingNeeded(file) {
+		return nil, nil
+	}
+	sizes, frameSizes := opt.Sizes, opt.FrameSizes
+	if sizes == nil {
+		sizes = types.SizesFor("gc", "arm64")
+	}
+	if frameSizes == nil {
+		frameSizes = sizes
+	}
+	builder := goSigBuilder{
+		sigs: make(map[string]FuncSig), localSigs: make(map[string]bool),
+		scope: pkg.Types.Scope(), sz: sizes, frameSz: frameSizes,
+		linknames: goLinknameRemoteToLocal(pkg.Syntax), pkgPath: pkg.Path,
+		resolve: resolve, goarch: "arm64", manualSig: opt.ManualSig,
+	}
+	if err := builder.addDeclaredFuncSigs(file); err != nil {
+		return nil, fmt.Errorf("%w: ABI0 tail declaration binding: %w", ErrProbeNeedsContext, err)
+	}
+	return BindGoARM64ABI0TailDeclarations(pkg, file, resolve, builder.sigs)
+}
diff --git a/arm64_abi0_tail_declaration_error_test.go b/arm64_abi0_tail_declaration_error_test.go
new file mode 100644
index 000000000..01bceb6c3
--- /dev/null
+++ b/arm64_abi0_tail_declaration_error_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARM64ABI0TailResultMissingDeclarationIsContext(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	for _, test := range []struct {
+		name, source, symbol string
+	}{
+		{
+			name:   "foreign-entry",
+			source: source + "TEXT Alternate(SB),516,$0-16\nB resultbody<>(SB)\n",
+			symbol: "Alternate",
+		},
+		{
+			name:   "missing-local-entry",
+			source: strings.Replace(source, "·Slots", "·Missing", 1),
+			symbol: "Missing",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			// These complete sources really assemble; no unsafe body is run.
+			requireARM64GoABIInternalObject(t, test.source)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ABI0TailResultTranslate(t, test.source, declaration,
+						"aarch64-unknown-linux-gnu", api, nil)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("unbound actual tail declaration lost Context or produced IR: ir=%q err=%v", ir, err)
+					}
+					if api == "GoModule" && (!strings.Contains(err.Error(), test.symbol) ||
+						!strings.Contains(err.Error(), "missing Go declaration for asm symbol")) {
+						t.Fatalf("pre-binding failure lost its original missing-declaration identity/reason: %v", err)
+					}
+				})
+			}
+		})
+	}
+
+	t.Run("ordinary-noncandidate", func(t *testing.T) {
+		ordinary := "TEXT ·Other(SB),516,$0-0\nRET\n"
+		requireARM64GoABIInternalObject(t, ordinary)
+		ir, err := arm64ABI0TailResultTranslate(t, ordinary, declaration,
+			"aarch64-unknown-linux-gnu", "GoModule", nil)
+		if err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" ||
+			!strings.Contains(err.Error(), "missing Go declaration for asm symbol \"·Other\"") {
+			t.Fatalf("ordinary declaration failure changed routing: ir=%q err=%v", ir, err)
+		}
+	})
+}
diff --git a/arm64_abi0_tail_declaration_test.go b/arm64_abi0_tail_declaration_test.go
new file mode 100644
index 000000000..ac147ec51
--- /dev/null
+++ b/arm64_abi0_tail_declaration_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func TestARM64ABI0TailResultActualDeclarationCannotBeForged(t *testing.T) {
+	for name, change := range map[string]func(*GoPackage, *FuncSig){
+		"missing-selection": func(p *GoPackage, _ *FuncSig) { p.SourceSelection = nil },
+		"missing-syntax":    func(p *GoPackage, _ *FuncSig) { p.Syntax = nil },
+		"nil-syntax":        func(p *GoPackage, _ *FuncSig) { p.Syntax[0] = nil },
+		"nil-function": func(p *GoPackage, _ *FuncSig) {
+			p.Syntax[0].Decls[0] = (*ast.FuncDecl)(nil)
+		},
+		"missing-function-name": func(p *GoPackage, _ *FuncSig) {
+			p.Syntax[0].Decls[0].(*ast.FuncDecl).Name = nil
+		},
+		"missing-Fset":       func(p *GoPackage, _ *FuncSig) { p.SourceSelection.Fset = nil },
+		"missing-types-info": func(p *GoPackage, _ *FuncSig) { p.SourceSelection.TypesInfo = nil },
+		"missing-sizes":      func(p *GoPackage, _ *FuncSig) { p.SourceSelection.Sizes = nil },
+		"missing-selected":   func(p *GoPackage, _ *FuncSig) { p.SourceSelection.SelectedGoFiles = nil },
+		"extra-selected": func(p *GoPackage, _ *FuncSig) {
+			p.SourceSelection.SelectedGoFiles = append(p.SourceSelection.SelectedGoFiles, "unknown.go")
+		},
+		"changed-source-bytes": func(p *GoPackage, _ *FuncSig) {
+			p.SourceSelection.GoSources["pkg.go"] = []byte("package abi0result\nfunc Slots(value uint32) (out uint64)\n")
+		},
+		"changed-package-path": func(p *GoPackage, _ *FuncSig) { p.Path = "foreign/abi0result" },
+		"different-package-object": func(p *GoPackage, _ *FuncSig) {
+			other, _ := arm64ABI0TailResultSignature(t, "func Slots(value uint64) (out uint64)")
+			p.Types = other.Types
+		},
+		"same-layout-different-AST-object": func(p *GoPackage, _ *FuncSig) {
+			p.Syntax[0].Decls[0].(*ast.FuncDecl).Name = &ast.Ident{Name: "Slots"}
+		},
+		"bodyful-source-role": func(p *GoPackage, s *FuncSig) {
+			*p, *s = arm64ABI0TailResultSignature(t, "func Slots(value uint64) (out uint64) { return value }")
+		},
+		"only-typed-layout": func(_ *GoPackage, s *FuncSig) { s.arm64ABI0Declaration = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			defer func() {
+				if recovered := recover(); recovered != nil {
+					t.Fatalf("malformed actual source must return Context, not panic: %v", recovered)
+				}
+			}()
+			declaration, source := arm64ABI0TailResultFixture(false, "B")
+			pkg, sig := arm64ABI0TailResultSignature(t, declaration)
+			change(&pkg, &sig)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(name string) string { return strings.TrimPrefix(goTextSymbolForResolution(name), "·") }
+			_, err = BindGoARM64ABI0TailDeclarations(pkg, file, resolve, map[string]FuncSig{"Slots": sig})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("altered type/source/role created a private declaration binding: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ABI0TailResultLiveDeclarationSourceGuard(t *testing.T) {
+	for _, change := range []string{"AST-body", "source-byte", "source-delete", "selected-file", "Defs-object", "package-path", "package-name", "Fset-identity", "slot-layout"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, file, sigs := arm64ABI0BoundFixture(t)
+			resolve := func(name string) string { return strings.TrimPrefix(goTextSymbolForResolution(name), "·") }
+			prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := sigs["Slots"]
+			switch change {
+			case "AST-body":
+				pkg.Syntax[0].Decls[0].(*ast.FuncDecl).Body = &ast.BlockStmt{}
+			case "source-byte":
+				pkg.SourceSelection.GoSources["pkg.go"][0] = 'P'
+			case "source-delete":
+				delete(pkg.SourceSelection.GoSources, "pkg.go")
+			case "selected-file":
+				pkg.SourceSelection.SelectedGoFiles[0] = "foreign.go"
+			case "Defs-object":
+				delete(pkg.SourceSelection.TypesInfo.Defs, pkg.Syntax[0].Decls[0].(*ast.FuncDecl).Name)
+			case "package-path":
+				sig.arm64ABI0TailDeclaration.packageData.Path = "foreign/package"
+			case "package-name":
+				pkg.Types.SetName("foreign")
+			case "Fset-identity":
+				set := token.NewFileSet()
+				if _, err := parser.ParseFile(set, "foreign.go", pkg.SourceSelection.GoSources["pkg.go"], parser.ParseComments); err != nil {
+					t.Fatal(err)
+				}
+				pkg.SourceSelection.Fset = set
+			case "slot-layout":
+				sig.Frame.Results[0].Offset++
+			}
+			if err := validateARM64ABI0TailSource(prepared.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed live source/declaration retained its result-slot capability: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ABI0TailResultDerivationAloneIsNotSourcePermission(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	_, sig := arm64ABI0TailResultSignature(t, declaration)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(goTextSymbolForResolution(name), "·") }
+	prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(prepared.Funcs) != 2 || prepared.Funcs[0].arm64ABI0TailSource != nil {
+		t.Fatal("file-only coalescer granted ABI0 permission")
+	}
+	_, err = Translate(prepared, Options{Goarch: "arm64", ResolveSym: resolve,
+		Sigs: map[string]FuncSig{"Slots": sig}, TargetTriple: "aarch64-unknown-linux-gnu"})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("typed layout alone acquired bodyless declaration permission: %v", err)
+	}
+}
diff --git a/arm64_abi0_tail_loop_test.go b/arm64_abi0_tail_loop_test.go
new file mode 100644
index 000000000..76b1573b5
--- /dev/null
+++ b/arm64_abi0_tail_loop_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+const arm64ABI0TailLoopSource = `TEXT ·Slots(SB),516,$0-24
+MOVD data+0(FP),R0
+MOVD n+8(FP),R1
+MOVD $out+16(FP),R8
+B resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+MOVD $0,R11
+CBZ R1,done
+loop:
+MOVD.P 8(R0),R12
+ADD R12,R11,R11
+SUB $1,R1
+CBNZ R1,loop
+done:
+MOVD R11,(R8)
+RET
+`
+
+func TestCrossLinuxRuntimeMatrixARM64ABI0TailResultInitializedLoop(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const declaration = "func Slots(data *uint64, n uint64) (out uint64)"
+	const program = `package main
+func Slots(data *uint64, n uint64) (out uint64)
+func main() {
+  data := [...]uint64{0xabc,0,1,255,1<<63,^uint64(0),0xdef}
+  original := data
+  for n:=uint64(0); n<=5; n++ {
+    want := uint64(0)
+    for i:=uint64(0); i<n; i++ { want += data[1+i] }
+    out := [3]uint64{0x123,Slots(&data[1],n),0x456}
+    if out != [3]uint64{0x123,want,0x456} { panic("ABI0 initialized-loop result/canaries") }
+    if data != original { panic("ABI0 initialized-loop source changed") }
+  }
+}
+`
+	t.Run("original", func(t *testing.T) {
+		runARM64LocalRegisterGoOracle(t, arm64ABI0TailLoopSource, program, len(runner) != 0)
+	})
+	const main = `#include <stdint.h>
+#include <string.h>
+extern uint64_t Slots(const uint64_t*, uint64_t);
+int main(void) {
+  uint64_t data[] = {0xabc,0,1,255,UINT64_C(1)<<63,UINT64_MAX,0xdef};
+  uint64_t original[7];
+  memcpy(original,data,sizeof data);
+  for (unsigned n=0; n<=5; n++) {
+    uint64_t want=0;
+    for (unsigned i=0; i<n; i++) want+=data[1+i];
+    uint64_t out[] = {0x123,Slots(data+1,n),0x456};
+    if (out[0]!=0x123 || out[1]!=want || out[2]!=0x456) return 11;
+    if (memcmp(data,original,sizeof data)!=0) return 12;
+  }
+  return 0;
+}
+`
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run("LLVM/"+api, func(t *testing.T) {
+			ir, err := arm64ABI0TailResultTranslate(t, arm64ABI0TailLoopSource, declaration, triple, api, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "abi0_tail_loop", triple, ir, main, runner)
+		})
+	}
+	// Removing the zero-count result write or relying on an entry GP value
+	// must fail even though the result alloca happens to be zero-initialized.
+	for _, changed := range []string{
+		strings.Replace(arm64ABI0TailLoopSource, "CBZ R1,done", "CBZ R1,unwritten", 1) + "unwritten:\nRET\n",
+		strings.Replace(arm64ABI0TailLoopSource, "MOVD n+8(FP),R1\n", "", 1),
+	} {
+		requireARM64GoABIInternalObject(t, changed)
+		_, err := arm64ABI0TailResultTranslate(t, changed, declaration, triple, "text", nil)
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unwritten/empty-entry loop acquired result permission: %v", err)
+		}
+	}
+}
diff --git a/arm64_abi0_tail_main_package_test.go b/arm64_abi0_tail_main_package_test.go
new file mode 100644
index 000000000..adfe06efc
--- /dev/null
+++ b/arm64_abi0_tail_main_package_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ABI0MainTailFixture(t *testing.T, packagePath, packageName string, tuple bool) (GoPackage, *File, string, FuncSig) {
+	t.Helper()
+	declaration, source := arm64ABI0TailResultFixture(tuple, "B")
+	goSource := []byte("package " + packageName + "\n" + declaration + "\nfunc main() {}\n")
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "main.go", goSource, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)}
+	sizes := types.SizesFor("gc", "arm64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(packagePath, fset, []*ast.File{syntax}, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := GoPackage{
+		Path: "main", Types: typed, Syntax: []*ast.File{syntax},
+		SourceSelection: &GoSourceSelection{
+			Fset: fset, TypesInfo: info, Sizes: sizes,
+			SelectedGoFiles: []string{"main.go"}, GoSources: map[string][]byte{"main.go": goSource},
+		},
+	}
+	fn := typed.Scope().Lookup("Slots").(*types.Func)
+	sig, err := DeriveGoFuncABI0Signature("main.Slots", fn, "arm64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, file, source, sig
+}
+
+func arm64ABI0MainTailResolve(symbol string) string {
+	return "main." + strings.TrimPrefix(goTextSymbolForResolution(symbol), "·")
+}
+
+func TestARM64ABI0TailMainPackageIdentity(t *testing.T) {
+	for _, path := range []string{"main", "example.com/cmd/abizero", "command-line-arguments"} {
+		for _, tuple := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(fmt.Sprintf("%s/tuple=%t/%s", path, tuple, api), func(t *testing.T) {
+					pkg, file, source, sig := arm64ABI0MainTailFixture(t, path, "main", tuple)
+					originalTypes, originalDeclaration := pkg.Types, pkg.Types.Scope().Lookup("Slots")
+					original := arm64ABI0FileSnapshot(file)
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					opt := Options{
+						Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: arm64ABI0MainTailResolve,
+						Sigs: map[string]FuncSig{"main.Slots": sig},
+					}
+					if api != "GoModule" {
+						var err error
+						opt.Sigs, err = BindGoARM64ABI0TailDeclarations(pkg, file, opt.ResolveSym, opt.Sigs)
+						if err != nil {
+							t.Fatal("actual main-package source owner was rejected:", err)
+						}
+					}
+					var ir string
+					switch api {
+					case "text":
+						var err error
+						ir, err = Translate(file, opt)
+						if err != nil {
+							t.Fatal(err)
+						}
+					case "module":
+						module, err := TranslateModuleInContext(ctx, file, opt)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+							t.Fatal(err)
+						}
+						ir = module.String()
+					case "GoModule":
+						result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+							GOARCH: "arm64", TargetTriple: opt.TargetTriple, ResolveSym: opt.ResolveSym,
+						})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						if err := llvm.VerifyModule(result.Module, llvm.ReturnStatusAction); err != nil {
+							t.Fatal(err)
+						}
+						ir = result.Module.String()
+					}
+					if !strings.Contains(ir, "@main.Slots(") || strings.Contains(ir, "resultbody") {
+						t.Fatal("main entry/private continuation symbols differ from their executable namespace")
+					}
+					if pkg.Types != originalTypes || pkg.Types.Path() != path ||
+						pkg.Types.Scope().Lookup("Slots") != originalDeclaration ||
+						!reflect.DeepEqual(original, arm64ABI0FileSnapshot(file)) {
+						t.Fatal("translation changed the actual typechecked owner or source")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ABI0TailMainPackageNamespaceBoundaries(t *testing.T) {
+	for _, mutation := range []string{"non-main-package", "arbitrary-symbol-path", "foreign-resolver", "different-typed-owner"} {
+		t.Run(mutation, func(t *testing.T) {
+			packageName := "main"
+			if mutation == "non-main-package" {
+				packageName = "library"
+			}
+			pkg, file, _, sig := arm64ABI0MainTailFixture(t, "example.com/cmd/abizero", packageName, false)
+			resolve := arm64ABI0MainTailResolve
+			switch mutation {
+			case "arbitrary-symbol-path":
+				pkg.Path = "foreign/package"
+			case "foreign-resolver":
+				var err error
+				sig, err = DeriveGoFuncABI0Signature("foreign.Slots", pkg.Types.Scope().Lookup("Slots").(*types.Func), "arm64", pkg.SourceSelection.Sizes)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve = func(symbol string) string {
+					return "foreign." + strings.TrimPrefix(goTextSymbolForResolution(symbol), "·")
+				}
+			case "different-typed-owner":
+				other, _, _, _ := arm64ABI0MainTailFixture(t, pkg.Types.Path(), "main", false)
+				pkg.Types = other.Types
+			}
+			_, err := BindGoARM64ABI0TailDeclarations(pkg, file, resolve, map[string]FuncSig{sig.Name: sig})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unrelated namespace or type owner acquired a main-package binding:", err)
+			}
+		})
+	}
+}
+
+func TestARM64ABI0TailMainPackageIdentityRevocation(t *testing.T) {
+	for _, mutation := range []string{"symbol-path", "switch-to-source-path", "source-bytes", "selected-file", "Defs-object", "typed-owner"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, file, _, sig := arm64ABI0MainTailFixture(t, "example.com/cmd/abizero", "main", false)
+			sigs, err := BindGoARM64ABI0TailDeclarations(pkg, file, arm64ABI0MainTailResolve, map[string]FuncSig{sig.Name: sig})
+			if err != nil {
+				t.Fatal("complete original main-package binding prerequisite:", err)
+			}
+			prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, arm64ABI0MainTailResolve)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig = sigs[sig.Name]
+			switch mutation {
+			case "symbol-path":
+				sig.arm64ABI0TailDeclaration.packageData.Path = "foreign/package"
+			case "switch-to-source-path":
+				sig.arm64ABI0TailDeclaration.packageData.Path = pkg.Types.Path()
+			case "source-bytes":
+				pkg.SourceSelection.GoSources["main.go"][0] = '!'
+			case "selected-file":
+				pkg.SourceSelection.SelectedGoFiles[0] = "foreign.go"
+			case "Defs-object":
+				delete(pkg.SourceSelection.TypesInfo.Defs, pkg.Syntax[0].Decls[0].(*ast.FuncDecl).Name)
+			case "typed-owner":
+				other, _, _, _ := arm64ABI0MainTailFixture(t, pkg.Types.Path(), "main", false)
+				sig.arm64ABI0TailDeclaration.packageData.Types = other.Types
+			}
+			if err := validateARM64ABI0TailSource(prepared.Funcs[0], sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed actual source/namespace retained its private-tail binding:", err)
+			}
+		})
+	}
+}
diff --git a/arm64_abi0_tail_result_capability_test.go b/arm64_abi0_tail_result_capability_test.go
new file mode 100644
index 000000000..6251c4b50
--- /dev/null
+++ b/arm64_abi0_tail_result_capability_test.go
@@ -0,0 +1,373 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ABI0TailResultFixture(tuple bool, tail string) (string, string) {
+	if tuple {
+		return "func Slots(value uint64) (low uint64, high uint64)", fmt.Sprintf(`TEXT ·Slots(SB),516,$0-24
+MOVD value+0(FP),R0
+MOVD $low+8(FP),R8
+MOVD $high+16(FP),R9
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+ADD $7,R0,R11
+MOVD R11,(R8)
+SUB $3,R0,R12
+MOVD R12,(R9)
+RET
+`, tail)
+	}
+	return "func Slots(value uint64) (out uint64)", fmt.Sprintf(`TEXT ·Slots(SB),516,$0-16
+MOVD value+0(FP),R0
+MOVD $out+8(FP),R8
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+ADD $7,R0,R11
+MOVD R11,(R8)
+RET
+`, tail)
+}
+
+func arm64ABI0TailResultSignature(t *testing.T, declaration string) (GoPackage, FuncSig) {
+	t.Helper()
+	source := []byte("package abi0result\n" + declaration + "\n")
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "pkg.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)}
+	sizes := types.SizesFor("gc", "arm64")
+	config := types.Config{Sizes: sizes}
+	typed, err := config.Check("test/abi0result", fset, []*ast.File{syntax}, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax},
+		SourceSelection: &GoSourceSelection{Fset: fset, TypesInfo: info, Sizes: sizes,
+			SelectedGoFiles: []string{"pkg.go"}, GoSources: map[string][]byte{"pkg.go": source}}}
+	fn, ok := pkg.Types.Scope().Lookup("Slots").(*types.Func)
+	if !ok {
+		t.Fatal("missing actual typechecked first-party declaration")
+	}
+	sig, err := DeriveGoFuncABI0Signature("Slots", fn, "arm64", types.SizesFor("gc", "arm64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, sig
+}
+
+func arm64ABI0TailResultTranslate(t *testing.T, source, declaration, target, api string, edit func(*FuncSig)) (string, error) {
+	t.Helper()
+	pkg, sig := arm64ABI0TailResultSignature(t, declaration)
+	if edit != nil {
+		edit(&sig)
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	original := fmt.Sprintf("%#v", file)
+	resolve := func(symbol string) string {
+		return strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	options := Options{
+		Goarch: "arm64", TargetTriple: target, ResolveSym: resolve,
+		Sigs: map[string]FuncSig{"Slots": sig},
+	}
+	if api != "GoModule" {
+		options.Sigs, err = BindGoARM64ABI0TailDeclarations(pkg, file, resolve, options.Sigs)
+		if err != nil {
+			return "", err
+		}
+	}
+	var text string
+	switch api {
+	case "text":
+		text, err = Translate(file, options)
+	case "module":
+		module, failure := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			text = module.String()
+		}
+		err = failure
+	case "GoModule":
+		goOptions := GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve}
+		if edit != nil {
+			goOptions.ManualSig = func(name string) (FuncSig, bool) {
+				return sig, name == "Slots"
+			}
+		}
+		result, failure := translateGoModuleInContext(ctx, pkg, []byte(source), goOptions)
+		if result != nil && !result.Module.IsNil() {
+			defer result.Module.Dispose()
+			text = result.Module.String()
+		}
+		err = failure
+	default:
+		t.Fatalf("unknown fixture API %q", api)
+	}
+	if fmt.Sprintf("%#v", file) != original {
+		t.Fatal("ABI0 result-address rejection changed its original source")
+	}
+	return text, err
+}
+
+// The unmodified original source must first assemble with the selected SDK.
+// These objects do not replace the separately initialized numerical oracles.
+func TestARM64ABI0TailResultDeclaredContinuationObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, tuple := range []bool{false, true} {
+		for _, tail := range []string{"B", "JMP", "RET"} {
+			declaration, source := arm64ABI0TailResultFixture(tuple, tail)
+			t.Run(fmt.Sprintf("tuple=%t/%s", tuple, tail), func(t *testing.T) {
+				requireARM64GoABIInternalObject(t, source)
+				for _, target := range []string{
+					"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+					"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+				} {
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(target+"/"+api, func(t *testing.T) {
+							ir, err := arm64ABI0TailResultTranslate(t, source, declaration, target, api, nil)
+							if err != nil {
+								t.Fatalf("declared ABI0 result continuation needs its own capability: %v", err)
+							}
+							if strings.Contains(ir, "resultbody") {
+								t.Fatal("source continuation acquired a fictitious callee ABI")
+							}
+							compileLLVMToObject(t, llc, target, "abi0-result.ll", "abi0-result.o", ir)
+						})
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ABI0TailResultCapabilitiesCannotBeBorrowed(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	for name, change := range map[string]func(*FuncSig){
+		"manual-frame-copy": func(s *FuncSig) {
+			*s = FuncSig{Name: s.Name, Args: append([]LLVMType(nil), s.Args...), Ret: s.Ret,
+				Frame: FrameLayout{Params: arm64CopyFPSlots(s.Frame.Params), Results: arm64CopyFPSlots(s.Frame.Results)}}
+		},
+		"JSON-layout-copy": func(s *FuncSig) {
+			encoded, err := json.Marshal(s)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var public FuncSig
+			if err := json.Unmarshal(encoded, &public); err != nil {
+				t.Fatal(err)
+			}
+			*s = public
+		},
+		"same-layout-other-declaration": func(s *FuncSig) {
+			pkg := mustGoPackage(t, "test/abi0result", "package abi0result\nfunc Other(value uint64) (out uint64)\n")
+			fn := pkg.Types.Scope().Lookup("Other").(*types.Func)
+			var err error
+			*s, err = DeriveGoFuncABI0Signature("Slots", fn, "arm64", types.SizesFor("gc", "arm64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+		},
+		"missing-result": func(s *FuncSig) { s.Frame.Results = nil },
+		"wrong-result-offset": func(s *FuncSig) {
+			s.Frame.Results = arm64CopyFPSlots(s.Frame.Results)
+			s.Frame.Results[0].Offset++
+		},
+		"wrong-result-width": func(s *FuncSig) {
+			s.Frame.Results = arm64CopyFPSlots(s.Frame.Results)
+			s.Frame.Results[0].Type = I32
+		},
+		"wrong-result-identity": func(s *FuncSig) {
+			s.Frame.Results = arm64CopyFPSlots(s.Frame.Results)
+			s.Frame.Results[0].Index++
+		},
+		"wrong-argument":      func(s *FuncSig) { s.Args = []LLVMType{I32} },
+		"fake-register-input": func(s *FuncSig) { s.ArgRegs = []Reg{"R0"} },
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				_, err := arm64ABI0TailResultTranslate(t, source, declaration, "aarch64-unknown-linux-gnu", api, change)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("manual/changed signature obtained ABI0 result capability: %v", err)
+				}
+			})
+		}
+	}
+	_, sig := arm64ABI0TailResultSignature(t, declaration)
+	if !reflect.DeepEqual(sig.Frame.Params, []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}) ||
+		!reflect.DeepEqual(sig.Frame.Results, []FrameSlot{{Offset: 8, Type: I64, Index: 0, Name: "out", Field: -1}}) {
+		t.Fatalf("actual typed first-party ABI0 layout changed: %+v", sig.Frame)
+	}
+}
+
+func TestARM64ABI0TailResultEmptyArgumentsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, tail := range []string{"B", "JMP", "RET"} {
+		source := fmt.Sprintf(`TEXT ·Slots(SB),516,$0-8
+MOVD $out+0(FP),R8
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+MOVD $99,R11
+MOVD R11,(R8)
+RET
+`, tail)
+		requireARM64GoABIInternalObject(t, source)
+		for _, target := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+			"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(tail+"/"+target+"/"+api, func(t *testing.T) {
+					ir, err := arm64ABI0TailResultTranslate(t, source, "func Slots() (out uint64)", target, api, nil)
+					if err != nil {
+						t.Fatalf("actual empty declaration lost its result capability: %v", err)
+					}
+					compileLLVMToObject(t, llc, target, "abi0-empty-result.ll", "abi0-empty-result.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ABI0TailResultOriginalSourceCannotBeChanged(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	for name, mutated := range map[string]string{
+		"result-slot-is-parameter": strings.Replace(source, "$out+8(FP)", "$value+0(FP)", 1),
+		"changed-TEXT-args":        strings.Replace(source, "$0-16", "$0-24", 1),
+		"nonzero-frame":            strings.Replace(source, "$0-16", "$16-16", 1),
+		"unbound-native-layout":    source + "TEXT observer<>(SB),516,$0\nADR resultbody<>(SB),R7\nRET\n",
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				_, err := arm64ABI0TailResultTranslate(t, mutated, declaration, "aarch64-unknown-linux-gnu", api, nil)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("changed original source obtained result-slot permission: %v", err)
+				}
+			})
+		}
+	}
+}
+
+// Each path must produce every byte from actual initialized machine values.
+func TestARM64ABI0TailResultAllPathsAndEmptyEntryAreMandatory(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(true, "B")
+	for name, replacement := range map[string]string{
+		"missing-tuple-result":     "ADD $7,R0,R11\nMOVD R11,(R8)\nRET",
+		"partial-result":           "ADD $7,R0,R11\nMOVW R11,(R8)\nMOVD R11,(R9)\nRET",
+		"conditional-write":        "CBZ R0,done\nMOVD R0,(R8)\nMOVD R0,(R9)\ndone:\nRET",
+		"undefined-GP":             "MOVD R7,(R8)\nMOVD R0,(R9)\nRET",
+		"undefined-FP-alias":       "FMOVD F0,R11\nMOVD R11,(R8)\nMOVD R0,(R9)\nRET",
+		"mixed-result-pointer":     "CBZ R0,joined\nMOVD R9,R8\njoined:\nMOVD R0,(R8)\nMOVD R0,(R9)\nRET",
+		"shifted-result-pointer":   "ADD $4,R8,R8\nMOVD R0,(R8)\nMOVD R0,(R9)\nRET",
+		"partial-result-pointer":   "MOVW R8,R8\nMOVD R0,(R8)\nMOVD R0,(R9)\nRET",
+		"result-pointer-as-value":  "MOVD R8,(R8)\nMOVD R0,(R9)\nRET",
+		"result-pointer-escape":    "MOVD R8,escaped<>(SB)\nMOVD R0,(R8)\nMOVD R0,(R9)\nRET",
+		"result-pointer-writeback": "MOVD.P R0,8(R8)\nMOVD R0,(R9)\nRET",
+	} {
+		at := strings.Index(source, "ADD $7,R0,R11")
+		mutated := source[:at] + replacement + "\n"
+		if name == "result-pointer-escape" {
+			mutated += "GLOBL escaped<>(SB),$8\n"
+		}
+		requireARM64GoABIInternalObject(t, mutated)
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				_, err := arm64ABI0TailResultTranslate(t, mutated, declaration, "aarch64-unknown-linux-gnu", api, nil)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unwritten/escaped/undefined result continuation was admitted: %v", err)
+				}
+			})
+		}
+	}
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run("parameter-is-not-GP-entry/"+api, func(t *testing.T) {
+			mutated := strings.Replace(source, "MOVD value+0(FP),R0\n", "", 1)
+			requireARM64GoABIInternalObject(t, mutated)
+			_, err := arm64ABI0TailResultTranslate(t, mutated, declaration, "aarch64-unknown-linux-gnu", api, nil)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("ABI0 ordinary Args supplied an unproved GP entry value: %v", err)
+			}
+		})
+	}
+}
+
+// This executes only the initialized first-party original Go program, not LLVM
+// or a third-party kernel. It is independent of the proposed capability proof.
+func TestCrossLinuxRuntimeMatrixARM64ABI0TailResultOriginalGoNumerics(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	for _, tail := range []string{"B", "JMP", "RET"} {
+		for _, tuple := range []bool{false, true} {
+			declaration, source := arm64ABI0TailResultFixture(tuple, tail)
+			t.Run(fmt.Sprintf("tuple=%t/%s", tuple, tail), func(t *testing.T) {
+				check := `out := [3]uint64{0xabc,0xbad,0xdef}
+out[1] = Slots(value)
+if out[1] != value+7 || out[0] != 0xabc || out[2] != 0xdef {
+  panic("ABI0 single result/canary")
+}
+`
+				if tuple {
+					check = `out := [4]uint64{0xabc,0xbad,0xbad,0xdef}
+out[1],out[2] = Slots(value)
+if out[1] != value+7 || out[2] != value-3 || out[0] != 0xabc || out[3] != 0xdef {
+  panic("ABI0 tuple result/canary")
+}
+`
+				}
+				main := "package main\n" + declaration + `
+func main() {
+  values := [...]uint64{0,1,3,99,1<<63,1<<63-1,^uint64(0)}
+  original := values
+  for _,value := range values {
+` + check + `
+  }
+  if values != original { panic("ABI0 original inputs changed") }
+}
+`
+				runARM64LocalRegisterGoOracle(t, source, main, len(runner) != 0)
+			})
+		}
+		t.Run("zero-arguments/"+tail, func(t *testing.T) {
+			source := fmt.Sprintf(`TEXT ·Slots(SB),516,$0-8
+MOVD $out+0(FP),R8
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+MOVD $99,R11
+MOVD R11,(R8)
+RET
+`, tail)
+			runARM64LocalRegisterGoOracle(t, source, `package main
+func Slots() (out uint64)
+func main() {
+  out := [3]uint64{0xabc,0xbad,0xdef}
+  out[1] = Slots()
+  if out != [3]uint64{0xabc,99,0xdef} { panic("ABI0 zero-argument result/canary") }
+}
+`, len(runner) != 0)
+		})
+	}
+}
diff --git a/arm64_abi0_tail_results.go b/arm64_abi0_tail_results.go
new file mode 100644
index 000000000..cbb4e5355
--- /dev/null
+++ b/arm64_abi0_tail_results.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Independent result-address state. Zero is ordinary data; -1 retains a lost
+// or mixed capability. Neither initialized LLVM allocas nor function-wide FP
+// routing hints establish that a result was written on every returning path.
+type arm64ABI0ResultState struct {
+	addresses [32]int16
+	written   [16]uint8
+}
+
+func arm64ABI0ResultRegister(reg Reg) (int, bool) {
+	if !strings.HasPrefix(string(reg), "R") {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(string(reg), "R"))
+	return n, err == nil && n >= 0 && n < 31
+}
+
+func (s *arm64ABI0ResultState) address(reg Reg) int16 {
+	if n, ok := arm64ABI0ResultRegister(reg); ok {
+		return s.addresses[n]
+	}
+	return 0
+}
+
+func (s *arm64ABI0ResultState) assign(reg Reg, value int16) {
+	if n, ok := arm64ABI0ResultRegister(reg); ok {
+		s.addresses[n] = value
+	}
+}
+
+func (s *arm64ABI0ResultState) operand(op Operand) bool {
+	if op.Kind == OpSym && strings.HasPrefix(op.Sym, "$") {
+		if memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(op.Sym, "$"))); ok &&
+			(s.address(memory.Base) != 0 || s.address(memory.Index) != 0) {
+			return false // Address spellings cannot wash a Slot into Plain.
+		}
+	}
+	if s.address(op.Reg) != 0 || s.address(op.ShiftReg) != 0 ||
+		s.address(op.Mem.Base) != 0 || s.address(op.Mem.Index) != 0 {
+		return false
+	}
+	for _, reg := range op.RegList {
+		if s.address(reg) != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ABI0ResultIndex(sig FuncSig, off int64) (int, bool) {
+	for i, slot := range sig.Frame.Results {
+		if slot.Offset == off {
+			return i, true
+		}
+	}
+	return 0, false
+}
+
+func arm64ABI0ResultMask(slot FrameSlot) uint8 {
+	return uint8((uint16(1) << uint(frameTypeSize(slot.Type, 8))) - 1)
+}
+
+func (s *arm64ABI0ResultState) step(ins Instr, sig FuncSig) error {
+	reject := func() error {
+		return arm64GoABIContext("ABI0 result capability has an incomplete/escaping effect at %q", ins.Raw)
+	}
+	op := arm64ControlOp(ins)
+	if op == OpTEXT || op == OpLABEL {
+		return nil
+	}
+	if op == OpRET {
+		if len(ins.Args) != 0 {
+			return reject()
+		}
+		for i, slot := range sig.Frame.Results {
+			if s.written[i] != arm64ABI0ResultMask(slot) {
+				return arm64GoABIContext("ABI0 result %d is not completely written on every RET path", i)
+			}
+		}
+		return nil
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg && op == "MOVD" && string(ins.Op) == string(op) {
+		src, dst := ins.Args[0], ins.Args[1].Reg
+		if src.Kind == OpFPAddr {
+			if _, gp := arm64ABI0ResultRegister(dst); !gp {
+				return reject()
+			}
+			index, found := arm64ABI0ResultIndex(sig, src.FPOffset)
+			if !found {
+				return reject()
+			}
+			s.assign(dst, int16(index+1))
+			return nil
+		}
+		if src.Kind == OpReg {
+			if _, gp := arm64ABI0ResultRegister(dst); !gp && s.address(src.Reg) != 0 {
+				return reject()
+			}
+			s.assign(dst, s.address(src.Reg))
+			return nil
+		}
+	}
+	if form, known := arm64RawPrivateMemory(ins); known {
+		if form.store {
+			if !form.gp || len(form.registers) != 1 || form.pre || form.post || form.scratch != nil ||
+				s.address(form.registers[0]) != 0 {
+				return reject()
+			}
+			index, found := 0, false
+			if form.memory.Kind == OpFP {
+				index, found = arm64ABI0ResultIndex(sig, form.memory.FPOffset)
+			} else if form.memory.Kind == OpMem {
+				m := form.memory.Mem
+				capability := s.address(m.Base)
+				if capability > 0 && m.Index == "" && m.Off == 0 && m.OffRaw == "" && m.Sym == "" && m.Segment == "" {
+					index, found = int(capability-1), true
+				}
+			}
+			if !found || index >= len(sig.Frame.Results) || form.elementBytes != frameTypeSize(sig.Frame.Results[index].Type, 8) {
+				return reject() // Never a parameter, heap, SB, partial or affine store.
+			}
+			s.written[index] = arm64ABI0ResultMask(sig.Frame.Results[index])
+			return nil
+		}
+		if !s.operand(form.memory) {
+			return reject() // A result address cannot be read as data or written back.
+		}
+		if form.memory.Kind == OpFP {
+			if _, result := arm64ABI0ResultIndex(sig, form.memory.FPOffset); result {
+				return reject() // Initial scope uses declared parameter loads only.
+			}
+		}
+		for _, reg := range form.registers {
+			s.assign(reg, 0)
+		}
+		if form.pre || form.post {
+			s.assign(form.memory.Mem.Base, 0)
+		}
+		if form.scratch != nil {
+			s.assign("R27", 0)
+		}
+		return nil
+	}
+	if form, handled, err := parseARM64GPDataForm(op, ins); handled {
+		if err != nil {
+			return reject()
+		}
+		for _, input := range form.inputs {
+			if !s.operand(input) {
+				return reject()
+			}
+		}
+		for _, reg := range arm64GPDataOutputRegisters(form) {
+			s.assign(reg, 0)
+		}
+		return nil
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg &&
+		(op == "MOVD" || op == "MOVW" || op == "MOVWU" || op == "MOVH" || op == "MOVHU" || op == "MOVB" || op == "MOVBU") {
+		if !s.operand(ins.Args[0]) || ins.Args[0].Kind == OpFPAddr {
+			return reject()
+		}
+		s.assign(ins.Args[1].Reg, 0)
+		return nil
+	}
+	if form, handled, err := parseARM64StructureMemory(ins); handled {
+		if err != nil || !form.load || !s.operand(form.memory) {
+			return reject()
+		}
+		if form.post {
+			s.assign(form.memory.Mem.Base, 0)
+		}
+		return nil
+	}
+	for _, arg := range ins.Args {
+		if !s.operand(arg) || arg.Kind == OpFPAddr || arg.Kind == OpFP {
+			return reject()
+		}
+	}
+	// Unknown effects still go through the complete normal typed lowerer and
+	// empty-entry must-definition proof. No unknown use can transport a Slot.
+	return nil
+}
+
+func arm64ABI0TailResultProof(fn Func, sig FuncSig) error {
+	if len(fn.Instrs) == 0 || len(fn.Instrs) > arm64PrivateRegisterExpansionBudget || len(sig.Frame.Results) > 16 {
+		return arm64GoABIContext("ABI0 result CFG exceeds its checked bound")
+	}
+	labels := map[string]int{}
+	for i, ins := range fn.Instrs {
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || labels[ins.Args[0].Sym] != 0 {
+				return arm64GoABIContext("ABI0 result CFG has an ambiguous label")
+			}
+			labels[ins.Args[0].Sym] = i
+		}
+	}
+	states := make([]*arm64ABI0ResultState, len(fn.Instrs))
+	states[0] = &arm64ABI0ResultState{}
+	queue := []int{0}
+	steps, returns := 0, 0
+	for len(queue) != 0 {
+		at := queue[0]
+		queue = queue[1:]
+		steps++
+		if steps > 1<<20 {
+			return arm64GoABIContext("ABI0 result CFG did not converge within its work bound")
+		}
+		state := *states[at]
+		ins := fn.Instrs[at]
+		if err := state.step(ins, sig); err != nil {
+			return err
+		}
+		if ins.Op == OpRET {
+			returns++
+			continue
+		}
+		next := []int{at + 1}
+		if ins.Op == "B" || ins.Op == "JMP" || arm64IsConditionalBranch(ins.Op) {
+			if len(ins.Args) == 0 || ins.Args[len(ins.Args)-1].Kind != OpIdent {
+				return arm64GoABIContext("ABI0 result CFG has an external/dynamic branch")
+			}
+			destination, exists := labels[ins.Args[len(ins.Args)-1].Ident]
+			if !exists {
+				return arm64GoABIContext("ABI0 result CFG has an unresolved label")
+			}
+			if ins.Op == "B" || ins.Op == "JMP" {
+				next = []int{destination}
+			} else {
+				next = append(next, destination)
+			}
+		}
+		for _, target := range next {
+			if target >= len(states) {
+				return arm64GoABIContext("ABI0 result CFG falls outside its returning source")
+			}
+			joined := state
+			if old := states[target]; old != nil {
+				for i, cap := range joined.addresses {
+					if cap != old.addresses[i] {
+						joined.addresses[i] = -1
+					}
+				}
+				for i := range joined.written {
+					joined.written[i] &= old.written[i]
+				}
+				if reflect.DeepEqual(joined, *old) {
+					continue
+				}
+			}
+			states[target] = &joined
+			queue = append(queue, target)
+		}
+	}
+	if returns == 0 {
+		return arm64GoABIContext("ABI0 result CFG has no complete returning path")
+	}
+	return nil
+}
diff --git a/arm64_abi0_tail_runtime_test.go b/arm64_abi0_tail_runtime_test.go
new file mode 100644
index 000000000..e8153d00d
--- /dev/null
+++ b/arm64_abi0_tail_runtime_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// The initialized mathematical reference is independent of layout, result
+// routing, LLVM allocas and the capability analysis. Original-Go execution is
+// retained in its own root and is not counted as translated execution.
+func TestCrossLinuxRuntimeMatrixARM64ABI0TailResultLLVMNumerics(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tail := range []string{"B", "JMP", "RET"} {
+		for _, tuple := range []bool{false, true} {
+			declaration, source := arm64ABI0TailResultFixture(tuple, tail)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(fmt.Sprintf("tuple=%t/%s/%s", tuple, tail, api), func(t *testing.T) {
+					ir, err := arm64ABI0TailResultTranslate(t, source, declaration, triple, api, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					prototype := "extern uint64_t Slots(uint64_t);"
+					observation := `out[1] = Slots(value);
+    if (out[1] != value + UINT64_C(7) || out[2] != UINT64_C(0xdef)) return 11;`
+					if tuple {
+						prototype = "struct pair { uint64_t low, high; };\nextern struct pair Slots(uint64_t);"
+						observation = `struct pair got = Slots(value);
+    out[1] = got.low;
+    out[2] = got.high;
+    if (out[1] != value + UINT64_C(7) || out[2] != value - UINT64_C(3)) return 12;`
+					}
+					main := `#include <stdint.h>
+#include <string.h>
+` + prototype + `
+int main(void) {
+  uint64_t values[] = {0, 1, 3, 99, UINT64_C(1)<<63, (UINT64_C(1)<<63)-1, UINT64_MAX};
+  uint64_t original[7];
+  memcpy(original, values, sizeof values);
+  for (unsigned i = 0; i < 7; i++) {
+    uint64_t value = values[i];
+    uint64_t out[4] = {UINT64_C(0xabc), UINT64_C(0xbad), UINT64_C(0xdef), UINT64_C(0x987)};
+    ` + observation + `
+    if (out[0] != UINT64_C(0xabc) || out[3] != UINT64_C(0x987)) return 13;
+  }
+  if (memcmp(original, values, sizeof values) != 0) return 14;
+  return 0;
+}
+`
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "abi0_tail_result", triple, ir, main, runner)
+				})
+			}
+		}
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run("empty/"+tail+"/"+api, func(t *testing.T) {
+				source := fmt.Sprintf(`TEXT ·Slots(SB),516,$0-8
+MOVD $out+0(FP),R8
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+MOVD $99,R11
+MOVD R11,(R8)
+RET
+`, tail)
+				ir, err := arm64ABI0TailResultTranslate(t, source, "func Slots() (out uint64)", triple, api, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				const main = `#include <stdint.h>
+extern uint64_t Slots(void);
+int main(void) {
+  uint64_t out[3] = {UINT64_C(0xabc), UINT64_C(0xbad), UINT64_C(0xdef)};
+  out[1] = Slots();
+  return out[0] == UINT64_C(0xabc) && out[1] == 99 && out[2] == UINT64_C(0xdef) ? 0 : 15;
+}
+`
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "abi0_tail_empty", triple, ir, main, runner)
+			})
+		}
+	}
+}
diff --git a/arm64_abi0_tail_scope_test.go b/arm64_abi0_tail_scope_test.go
new file mode 100644
index 000000000..f444a60fe
--- /dev/null
+++ b/arm64_abi0_tail_scope_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64ABI0TailResultKeepFuncKeepsWholeAudit(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	declaration += "\nfunc Other(value uint64) (out uint64)"
+	source += "TEXT ·Other(SB),516,$0-16\nMOVD value+0(FP),R0\nMOVD R0,out+8(FP)\nRET\n"
+	for _, kept := range []string{"Slots", "Other"} {
+		t.Run(kept, func(t *testing.T) {
+			pkg, _ := arm64ABI0TailResultSignature(t, declaration)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				ResolveSym: func(name string) string { return strings.TrimPrefix(goTextSymbolForResolution(name), "·") },
+				KeepFunc:   func(_, name string) bool { return name == kept },
+			})
+			if result != nil && !result.Module.IsNil() {
+				defer result.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatalf("dropping an unused declaration must not counterfeit a signature mutation: %v", err)
+			}
+			if strings.Count(result.Module.String(), "define ") != 1 {
+				t.Fatal("KeepFunc did not retain exactly the requested root")
+			}
+		})
+	}
+	for _, witness := range []string{
+		"TEXT observer<>(SB),516,$0\nADR resultbody<>(SB),R7\nRET\n",
+		"DATA escaped<>(SB)/8,$resultbody<>(SB)\nGLOBL escaped<>(SB),$8\n",
+	} {
+		pkg, _ := arm64ABI0TailResultSignature(t, declaration)
+		ctx := llvm.NewContext()
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source+witness), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			KeepFunc: func(_, _ string) bool { return false },
+		})
+		if result != nil && !result.Module.IsNil() {
+			result.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("KeepFunc hid a whole-file helper escape witness: %v", err)
+		}
+	}
+}
+
+func TestARM64ABI0TailResultSharedBudgetAndIdempotence(t *testing.T) {
+	_, file, sigs := arm64ABI0BoundFixture(t)
+	resolve := func(name string) string { return strings.TrimPrefix(goTextSymbolForResolution(name), "·") }
+	prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+	if err != nil {
+		t.Fatal(err)
+	}
+	repeated, err := PrepareGoARM64ABI0TailContinuations(prepared, sigs, resolve)
+	if err != nil || !reflect.DeepEqual(prepared, repeated) {
+		t.Fatalf("declaration-backed preparation is not idempotent: %v", err)
+	}
+	if _, err := PrepareGoARM64ABI0TailContinuations(nil, sigs, resolve); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("nil original source was not rejected: %v", err)
+	}
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	call := "TEXT ·Run(SB),4,$0-16\nMOVD x+0(FP),R0\nCALL mix<>(SB)\nMOVD R0,ret+8(FP)\nRET\nTEXT mix<>(SB),516,$0-0\n" +
+		strings.Repeat("ADD $1,R0\n", arm64PrivateRegisterExpansionBudget-4) + "RET\n"
+	pkg, sig := arm64ABI0TailResultSignature(t, declaration)
+	mixed, err := Parse(ArchARM64, source+call)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, err := BindGoARM64ABI0TailDeclarations(pkg, mixed, resolve, map[string]FuncSig{"Slots": sig})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := PrepareGoARM64ABI0TailContinuations(mixed, bound, resolve); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("ABI0 tail gained an independent expansion budget after CALL: %v", err)
+	}
+}
+
+func TestARM64ABI0TailResultUnapprovedDomainsRemainContext(t *testing.T) {
+	_, source := arm64ABI0TailResultFixture(false, "B")
+	for _, declaration := range []string{
+		"func Slots(value uint64) (out float64)",
+		"func Slots(value uint64) (out *uint64)",
+		"func Slots(value uint64) (out [1]uint64)",
+		"func Slots(value uint64) (out bool)",
+		"func Slots(value uint64)",
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(declaration+"/"+api, func(t *testing.T) {
+				_, err := arm64ABI0TailResultTranslate(t, source, declaration, "aarch64-unknown-linux-gnu", api, nil)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unapproved result/layout acquired its slot capability: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ABI0TailResultAddressSyntaxCannotLaunderSlot(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	for _, address := range []string{"$8(R8)", "$(R8)"} {
+		changed := strings.Replace(source, "B resultbody<>(SB)", "MOVD "+address+",R0\nB resultbody<>(SB)", 1)
+		requireARM64GoABIInternalObject(t, changed)
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(address+"/"+api, func(t *testing.T) {
+				_, err := arm64ABI0TailResultTranslate(t, changed, declaration, "aarch64-unknown-linux-gnu", api, nil)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("symbolic address syntax converted a live result-slot pointer to Plain: %v", err)
+				}
+			})
+		}
+	}
+}
+
+// Only assemble these sources. A valid Go object does not authorize a live
+// source SP, closure register, scratch register or caller LR as a data address.
+func TestARM64ABI0TailResultRootAddressSyntaxCannotExposeReservedState(t *testing.T) {
+	declaration, source := arm64ABI0TailResultFixture(false, "B")
+	for _, address := range []string{
+		"$8(RSP)", "$(RSP)", "$8(R26)", "$(R26)",
+		"$8(R27)", "$(R27)", "$8(R30)", "$(R30)",
+	} {
+		changed := strings.Replace(source, "B resultbody<>(SB)", "MOVD "+address+",R0\nB resultbody<>(SB)", 1)
+		t.Run(address, func(t *testing.T) {
+			requireARM64GoABIInternalObject(t, changed)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ABI0TailResultTranslate(t, changed, declaration, "aarch64-unknown-linux-gnu", api, nil)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("unbound reserved source address acquired ABI0 continuation permission: err=%v object=%t", err, ir != "")
+					}
+				})
+			}
+		})
+	}
+}
+
+// These are typed-domain unit tripwires, not original-Go object certificates.
+// The independently accepted source address variants are tested above.
+func TestARM64ABI0TailResultTypedAddressEffectsDoNotLoseSlot(t *testing.T) {
+	_, sig := arm64ABI0TailResultSignature(t, "func Slots(value uint64) (out uint64)")
+	for _, source := range []Operand{
+		{Kind: OpReg, Reg: "R8"},
+		{Kind: OpFPAddr, FPOffset: 8},
+	} {
+		state := arm64ABI0ResultState{}
+		state.assign("R8", 1)
+		instruction := Instr{Op: "MOVD", Args: []Operand{source, {Kind: OpReg, Reg: "F0"}}}
+		if err := state.step(instruction, sig); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("result-slot address acquired an untracked bank: %v", err)
+		}
+	}
+	state := arm64ABI0ResultState{}
+	state.assign("R8", 1)
+	for _, source := range []Operand{
+		{Kind: OpSym, Sym: "$8(R8)"},
+		{Kind: OpSym, Sym: "$(R0)(R8)"},
+		{Kind: OpMem, Mem: MemRef{Base: "R0", Index: "R8"}},
+	} {
+		if state.operand(source) {
+			t.Fatalf("address representation dropped a slot alias: %+v", source)
+		}
+	}
+}
diff --git a/arm64_abi0_tail_source.go b/arm64_abi0_tail_source.go
new file mode 100644
index 000000000..f5a84cbd5
--- /dev/null
+++ b/arm64_abi0_tail_source.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+type arm64ABI0TailSource struct {
+	declaration *arm64ABI0TailDeclaration
+	original    Func
+	helpers     []Func
+	prepared    Func
+}
+
+func arm64ABI0TailRoot(fn Func, sig FuncSig) error {
+	d := sig.arm64ABI0TailDeclaration
+	if !d.matches(sig) || !reflect.DeepEqual(arm64PrivateTailSnapshot(fn), d.root) ||
+		fn.arm64PrivateRegisterEntry || fn.arm64PrivateTailSource != nil || fn.arm64ABI0TailSource != nil ||
+		fn.FrameSize != 0 || arm64SourceGoFrame(fn).present || !arm64SourceFrameFlagsKnown(fn) ||
+		len(fn.Instrs) < 2 || fn.Instrs[0].Op != OpTEXT || strings.Contains(fn.Sym, "<ABI") ||
+		len(sig.ArgRegs) != 0 || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.ARMEntry != nil {
+		return arm64GoABIContext("ABI0 private tail lacks its declaration-bound zero physical frame")
+	}
+	_, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) < 2 || len(parts) > 3 || strings.LastIndex(strings.TrimSpace(parts[len(parts)-1]), "-") <= 1 {
+		return arm64GoABIContext("ABI0 private tail needs complete original TEXT/args")
+	}
+	name, off, ok := parseSBRef(strings.TrimSpace(parts[0]))
+	frame, args, err := parseTEXTFrame(parts)
+	if !ok || off != 0 || name != fn.Sym || err != nil || frame != 0 || args != fn.ArgSize || args != d.declaration.argsSize {
+		return arm64GoABIContext("ABI0 private tail changed its actual TEXT/layout identity")
+	}
+	for _, ins := range fn.Instrs[1:] {
+		if ins.Op == "CALL" || ins.Op == "BL" || ins.Op == "BLR" || ins.Op == OpTEXT {
+			return arm64GoABIContext("ABI0 private tail is not a complete call-free source")
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind == OpFP || arg.Kind == OpFPAddr {
+				continue // Exact parameter/result roles are checked by the CFG proof.
+			}
+			registers := []Reg{arg.Reg, arg.ShiftReg, arg.Mem.Base, arg.Mem.Index}
+			if arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$") {
+				if memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$"))); ok {
+					registers = append(registers, memory.Base, memory.Index)
+				}
+			}
+			for _, reg := range registers {
+				if reg != "" && !arm64PrivateTailDataRegister(reg) && reg != ZR {
+					return arm64GoABIContext("ABI0 private tail touches stack/hidden/reserved state")
+				}
+			}
+			for _, reg := range arg.RegList {
+				if !arm64PrivateTailDataRegister(reg) && reg != ZR {
+					return arm64GoABIContext("ABI0 private tail touches a hidden/reserved register list")
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func validateARM64ABI0TailSource(fn Func, sig FuncSig) error {
+	p := fn.arm64ABI0TailSource
+	if p == nil {
+		return nil
+	}
+	if p.declaration != sig.arm64ABI0TailDeclaration {
+		return arm64GoABIContext("ABI0 continuation lost its declaration object")
+	}
+	if !p.declaration.matches(sig) {
+		return arm64GoABIContext("ABI0 continuation changed its original selected declaration/source")
+	}
+	if !reflect.DeepEqual(arm64PrivateTailSnapshot(fn), p.prepared) {
+		return arm64GoABIContext("ABI0 continuation changed its prepared source")
+	}
+	if err := arm64ABI0TailRoot(p.original, sig); err != nil {
+		return err
+	}
+	for _, helper := range p.helpers {
+		if err := arm64PrivateTailBody(helper); err != nil {
+			return err
+		}
+	}
+	return arm64ABI0TailResultProof(fn, sig)
+}
+
+// PrepareGoARM64ABI0TailContinuations is declaration-backed preparation before
+// KeepFunc/chunks. File-only preparation supplies no ABI0 permissions. Shared
+// CALL/ABIInternal/ABI0 additions consume the same cumulative file allowance.
+func PrepareGoARM64ABI0TailContinuations(file *File, sigs map[string]FuncSig, resolve func(string) string) (*File, error) {
+	if file == nil {
+		return nil, arm64GoABIContext("ABI0 continuation has no original assembly file")
+	}
+	prepared, err := coalesceARM64PrivateRegisterHelpers(file)
+	if err != nil || prepared.Arch != ArchARM64 {
+		return prepared, err
+	}
+	remaining := arm64PrivateRegisterExpansionBudget
+	for _, fn := range prepared.Funcs {
+		if fn.arm64PrivateSourceAdded < 0 || fn.arm64PrivateSourceAdded > remaining {
+			return nil, arm64GoABIContext("ABI0 continuation exceeds the shared cumulative expansion budget")
+		}
+		remaining -= fn.arm64PrivateSourceAdded
+	}
+	return coalesceARM64PrivateTailHelpersWithABI0(prepared, &remaining, sigs, resolve)
+}
diff --git a/arm64_abi0_tail_widths_test.go b/arm64_abi0_tail_widths_test.go
new file mode 100644
index 000000000..4e3e0ad97
--- /dev/null
+++ b/arm64_abi0_tail_widths_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64ABI0TailWidthsFixture(named bool, tail string) (string, string) {
+	declaration := "func Slots(value uint64) (b uint8, h uint16, w uint32, d uint64)"
+	if named {
+		declaration = `type Small uint8
+type Half int16
+type Word uint32
+type Long int64
+func Slots(value uint64) (b Small, h Half, w Word, d Long)`
+	}
+	source := fmt.Sprintf(`TEXT ·Slots(SB),516,$0-24
+MOVD value+0(FP),R0
+MOVD $b+8(FP),R8
+MOVD $h+10(FP),R9
+MOVD $w+12(FP),R10
+MOVD $d+16(FP),R11
+%s resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+ADD $7,R0,R12
+MOVB R12,(R8)
+ADD $3,R0,R13
+MOVH R13,(R9)
+ADD $5,R0,R14
+MOVW R14,(R10)
+ADD $9,R0,R15
+MOVD R15,(R11)
+RET
+`, tail)
+	return declaration, source
+}
+
+func TestARM64ABI0TailResultMixedWidthsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, named := range []bool{false, true} {
+		for _, tail := range []string{"B", "JMP", "RET"} {
+			declaration, source := arm64ABI0TailWidthsFixture(named, tail)
+			requireARM64GoABIInternalObject(t, source)
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+			} {
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(fmt.Sprintf("named=%t/%s/%s/%s", named, tail, target, api), func(t *testing.T) {
+						ir, err := arm64ABI0TailResultTranslate(t, source, declaration, target, api, nil)
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, target, "abi0-widths.ll", "abi0-widths.o", ir)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ABI0TailResultMixedWidths(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const bridge = `
+define void @observe_tail_widths(ptr %out, i64 %value) {
+  %results = call { i8, i16, i32, i64 } @Slots(i64 %value)
+  %b = extractvalue { i8, i16, i32, i64 } %results, 0
+  %h = extractvalue { i8, i16, i32, i64 } %results, 1
+  %w = extractvalue { i8, i16, i32, i64 } %results, 2
+  %d = extractvalue { i8, i16, i32, i64 } %results, 3
+  %b64 = zext i8 %b to i64
+  %h64 = zext i16 %h to i64
+  %w64 = zext i32 %w to i64
+  %hptr = getelementptr i64, ptr %out, i64 1
+  %wptr = getelementptr i64, ptr %out, i64 2
+  %dptr = getelementptr i64, ptr %out, i64 3
+  store i64 %b64, ptr %out, align 8
+  store i64 %h64, ptr %hptr, align 8
+  store i64 %w64, ptr %wptr, align 8
+  store i64 %d, ptr %dptr, align 8
+  ret void
+}
+`
+	const main = `#include <stdint.h>
+#include <string.h>
+extern void observe_tail_widths(uint64_t*, uint64_t);
+int main(void) {
+  uint64_t values[] = {0, 1, 255, 65535, UINT32_MAX, UINT64_C(1)<<63, UINT64_MAX};
+  uint64_t original[7];
+  memcpy(original, values, sizeof values);
+  for (unsigned i = 0; i < 7; i++) {
+    uint64_t value = values[i];
+    uint64_t out[] = {0xabc, 0xbad, 0xbad, 0xbad, 0xbad, 0xdef};
+    observe_tail_widths(out+1, value);
+    if (out[1] != (uint8_t)(value+7) || out[2] != (uint16_t)(value+3) ||
+        out[3] != (uint32_t)(value+5) || out[4] != value+9) return 11;
+    if (out[0] != 0xabc || out[5] != 0xdef) return 12;
+  }
+  return memcmp(original, values, sizeof values) == 0 ? 0 : 13;
+}
+`
+	for _, named := range []bool{false, true} {
+		for _, tail := range []string{"B", "JMP", "RET"} {
+			declaration, source := arm64ABI0TailWidthsFixture(named, tail)
+			t.Run(fmt.Sprintf("original/named=%t/%s", named, tail), func(t *testing.T) {
+				program := "package main\n" + declaration + `
+func main() {
+  values := [...]uint64{0,1,255,65535,1<<32-1,1<<63,^uint64(0)}
+  original := values
+  for _,value := range values {
+    b,h,w,d := Slots(value)
+    out := [6]uint64{0xabc, uint64(uint8(b)), uint64(uint16(h)), uint64(uint32(w)), uint64(d), 0xdef}
+    want := [6]uint64{0xabc, uint64(uint8(value+7)), uint64(uint16(value+3)), uint64(uint32(value+5)), value+9, 0xdef}
+    if out != want { panic("ABI0 mixed-width results/canaries") }
+  }
+  if values != original { panic("ABI0 mixed-width input changed") }
+}
+`
+				runARM64LocalRegisterGoOracle(t, source, program, len(runner) != 0)
+			})
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(fmt.Sprintf("LLVM/named=%t/%s/%s", named, tail, api), func(t *testing.T) {
+					ir, err := arm64ABI0TailResultTranslate(t, source, declaration, triple, api, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "{ i8, i16, i32, i64 }") {
+						t.Fatal("mixed-width typed result tuple was not preserved")
+					}
+					// The observer uses the actual LLVM tuple convention instead of
+					// guessing a C aggregate ABI. It does not produce expected values.
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "abi0_tail_widths", triple, ir+bridge, main, runner)
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_atomic_pair_effects_test.go b/arm64_atomic_pair_effects_test.go
new file mode 100644
index 000000000..c087b466a
--- /dev/null
+++ b/arm64_atomic_pair_effects_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestARM64AtomicPairNamedEffectsMatchRealOutputBankAndMemory(t *testing.T) {
+	for _, family := range []struct {
+		ops   []string
+		args  string
+		lr    bool
+		store bool
+	}{
+		{[]string{"CASPW", "CASPD"}, "(R30,ZR),(R16),(R4,R5)", true, true},
+		{[]string{"CASPW", "CASPD"}, "(R0,R1),(R16),(R30,ZR)", false, true},
+		{[]string{"LDXPW", "LDXP", "LDAXPW", "LDAXP"}, "(R16),(RSP,R1)", false, false},
+		{[]string{"LDXPW", "LDXP", "LDAXPW", "LDAXP"}, "(R16),(R30,ZR)", true, false},
+		{[]string{"STXPW", "STXP", "STLXPW", "STLXP"}, "(R30,ZR),(R16),R0", false, true},
+		{[]string{"STXPW", "STXP", "STLXPW", "STLXP"}, "(R2,R3),(R16),R30", true, true},
+	} {
+		for _, op := range family.ops {
+			t.Run(op+family.args, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT effects(SB),4,$0-0\n%s %s\nRET\n", op, family.args)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				state := &arm64ControlState{
+					regs: map[Reg]arm64ControlValue{
+						SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R30": arm64ControlFromMap(map[string]bool{"label:caller": true}),
+					},
+					memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true})},
+				}
+				ins := file.Funcs[0].Instrs[1]
+				state.transfer(ins, Op(op), false, nil)
+				if !arm64ControlEqual(state.regs[SP], arm64ControlFromMap(map[string]bool{"sp:0": true})) {
+					t.Errorf("data-pair RSP encodes ZR, not a stack-pointer write: %+v", state.regs[SP])
+				}
+				if tainted := arm64ControlHas(state.regs["R30"], ""); tainted != family.lr {
+					t.Errorf("caller LR output taint=%v, want %v; state=%+v", tainted, family.lr, state.regs["R30"])
+				}
+				if tainted := arm64ControlHas(state.memory["sp:0"], ""); tainted != family.store {
+					t.Errorf("saved-memory store taint=%v, want %v", tainted, family.store)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64AtomicPairOutputCannotInventCallerReturn(t *testing.T) {
+	for _, instruction := range []string{
+		"CASPD (R30,ZR),(R16),(R4,R5)",
+		"LDXP (R16),(R30,ZR)",
+		"STLXP (R2,R3),(R16),R30",
+	} {
+		source := "TEXT effects(SB),516,$0-0\n" + instruction + "\nRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+			Sigs: map[string]FuncSig{"effects": {Name: "effects", Ret: Void}},
+		}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s overwrites caller LR and must need context, got %v", instruction, err)
+		}
+	}
+}
+
+func TestARM64AtomicPairNamedSPUsesGoPhysicalZeroOffset(t *testing.T) {
+	for _, frame := range []int{0, 16, 24, 32768} {
+		for _, op := range []string{"CASPW", "CASPD"} {
+			t.Run(fmt.Sprintf("%s/frame%d", op, frame), func(t *testing.T) {
+				offset := 0
+				if frame != 0 {
+					offset = -frame - 8 // Go asm7 NAME_AUTO: autosize - extrasize.
+				}
+				source := fmt.Sprintf("TEXT effects(SB),4,$%d-0\n%s (R0,R1),local%+d(SP),(R2,R3)\nUNDEF\n", frame, op, offset)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized, err := normalizeARM64AtomicPairNamedMemory(file.Funcs[0])
+				if err != nil {
+					t.Fatal(err)
+				}
+				memory := normalized.Instrs[1].Args[1].Mem
+				if memory.Base != "RSP" || memory.Off != 0 || memory.OffRaw != "" {
+					t.Fatalf("C_ZAUTO did not resolve to physical zero-offset SP: %+v", memory)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM 22 llc not found")
+				}
+				for _, triple := range []string{
+					"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+					"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+				} {
+					ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+						Sigs: map[string]FuncSig{"effects": {Name: "effects", Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "named-atomic.ll", "named-atomic.o", ir)
+				}
+				original := file.Funcs[0].Instrs[1].Args[1].Mem
+				if original.Base != SP || original.Off != int64(offset) || original.OffRaw == "" {
+					t.Fatalf("normalization mutated immutable source evidence: %+v", original)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64AtomicPairNamedSPRejectsNonZeroPhysicalOffset(t *testing.T) {
+	for _, offset := range []int{0, -16, -32} {
+		source := fmt.Sprintf("TEXT effects(SB),4,$16-0\nCASPD (R0,R1),local%+d(SP),(R2,R3)\nUNDEF\n", offset)
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+			Sigs: map[string]FuncSig{"effects": {Name: "effects", Ret: Void}},
+		}); err == nil {
+			t.Errorf("accepted named SP offset %d despite Go's nonzero physical-offset rejection", offset)
+		}
+	}
+}
diff --git a/arm64_atomic_pair_forms.go b/arm64_atomic_pair_forms.go
new file mode 100644
index 000000000..74a1ac47e
--- /dev/null
+++ b/arm64_atomic_pair_forms.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import "fmt"
+
+type arm64AtomicPairKind uint8
+
+const (
+	arm64AtomicPairCAS arm64AtomicPairKind = iota
+	arm64AtomicPairLoad
+	arm64AtomicPairStore
+)
+
+type arm64AtomicPairSpec struct {
+	kind arm64AtomicPairKind
+	bits int
+}
+
+// Complete Go asm7 rows 106, 58 and 59, including their oprangeset aliases.
+// Acquire/release spellings currently use the lowerer's conservative seq_cst
+// semantics; they do not change register banks or source memory footprint.
+var arm64AtomicPairSpecs = map[Op]arm64AtomicPairSpec{
+	"CASPW":  {arm64AtomicPairCAS, 32},
+	"CASPD":  {arm64AtomicPairCAS, 64},
+	"LDXPW":  {arm64AtomicPairLoad, 32},
+	"LDXP":   {arm64AtomicPairLoad, 64},
+	"LDAXPW": {arm64AtomicPairLoad, 32},
+	"LDAXP":  {arm64AtomicPairLoad, 64},
+	"STXPW":  {arm64AtomicPairStore, 32},
+	"STXP":   {arm64AtomicPairStore, 64},
+	"STLXPW": {arm64AtomicPairStore, 32},
+	"STLXP":  {arm64AtomicPairStore, 64},
+}
+
+type arm64AtomicPairForm struct {
+	spec     arm64AtomicPairSpec
+	memory   MemRef
+	expected []Reg
+	data     []Reg
+	status   Reg
+}
+
+// Go asm7 classifies NAME_AUTO after adding autosize - extrasize. obj7's
+// logical size is TEXT frame + 8 whenever it creates a frame; its additional
+// alignment/FP space cancels in this address rule. Resolve C_ZAUTO before CFG
+// effects and lowering, so both see the same physical zero-offset SP address.
+func normalizeARM64AtomicPairNamedMemory(fn Func) (Func, error) {
+	logicalFrame := int64(0)
+	if arm64SourceGoFrame(fn).present {
+		if fn.FrameSize < 0 || fn.FrameSize > 1<<63-1-8 {
+			return fn, fmt.Errorf("invalid ARM64 paired atomic source frame size %d", fn.FrameSize)
+		}
+		logicalFrame = fn.FrameSize + 8
+	}
+	copied := false
+	for i, ins := range fn.Instrs {
+		spec, ok := arm64AtomicPairSpecs[arm64ControlOp(ins)]
+		if !ok || spec.kind != arm64AtomicPairCAS || len(ins.Args) != 3 || ins.Args[1].Kind != OpMem {
+			continue
+		}
+		mem := ins.Args[1].Mem
+		if mem.Base != SP || mem.OffRaw == "" {
+			continue
+		}
+		if !arm64NamedStackOffset(mem) {
+			return fn, fmt.Errorf("%w: ARM64 CASP named SP displacement is unresolved: %q", ErrProbeNeedsContext, ins.Raw)
+		}
+		if mem.Off != -logicalFrame {
+			return fn, fmt.Errorf("ARM64 CASP named SP displacement %d plus logical Go frame %d is not zero: %q", mem.Off, logicalFrame, ins.Raw)
+		}
+		if !copied {
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			copied = true
+		}
+		args := append([]Operand(nil), ins.Args...)
+		args[1].Mem.Base, args[1].Mem.Off, args[1].Mem.OffRaw = "RSP", 0, ""
+		fn.Instrs[i].Args = args
+	}
+	return fn, nil
+}
+
+func parseARM64AtomicPairForm(op Op, ins Instr) (arm64AtomicPairForm, bool, error) {
+	spec, handled := arm64AtomicPairSpecs[op]
+	if !handled {
+		return arm64AtomicPairForm{}, false, nil
+	}
+	form, err := parseARM64AtomicPairOperands(spec, ins)
+	if err != nil {
+		return arm64AtomicPairForm{}, true, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	return form, true, nil
+}
+
+func parseARM64AtomicPairOperands(spec arm64AtomicPairSpec, ins Instr) (arm64AtomicPairForm, error) {
+	form := arm64AtomicPairForm{spec: spec}
+	if arm64AtomicOpcodeHasSuffix(ins.Op) {
+		return form, fmt.Errorf("paired atomic opcode has no suffix")
+	}
+	switch spec.kind {
+	case arm64AtomicPairCAS:
+		if len(ins.Args) != 3 || !arm64AtomicRegisterPair(ins.Args[0]) || ins.Args[1].Kind != OpMem || !arm64AtomicRegisterPair(ins.Args[2]) {
+			return form, fmt.Errorf("expects register-pair, zero-offset memory, register-pair")
+		}
+		form.expected, form.memory, form.data = ins.Args[0].RegList, ins.Args[1].Mem, ins.Args[2].RegList
+		if err := validateARM64CASPRegisterPair("source", form.expected); err != nil {
+			return form, err
+		}
+		if err := validateARM64CASPRegisterPair("destination", form.data); err != nil {
+			return form, err
+		}
+	case arm64AtomicPairLoad:
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || !arm64AtomicRegisterPair(ins.Args[1]) {
+			return form, fmt.Errorf("expects zero-offset memory, register-pair")
+		}
+		form.memory, form.data = ins.Args[0].Mem, ins.Args[1].RegList
+		if err := validateARM64ExclusiveLoadPair(form.data); err != nil {
+			return form, err
+		}
+	case arm64AtomicPairStore:
+		if len(ins.Args) != 3 || !arm64AtomicRegisterPair(ins.Args[0]) || ins.Args[1].Kind != OpMem || ins.Args[2].Kind != OpReg {
+			return form, fmt.Errorf("expects register-pair, zero-offset memory, status-register")
+		}
+		form.data, form.memory, form.status = ins.Args[0].RegList, ins.Args[1].Mem, ins.Args[2].Reg
+		if err := validateARM64ExclusiveStorePair(form.data, form.memory.Base, form.status); err != nil {
+			return form, err
+		}
+	default:
+		return form, fmt.Errorf("unrecognized paired atomic grammar")
+	}
+	return form, validateARM64AtomicPairMemory(form.memory, spec.kind == arm64AtomicPairCAS)
+}
+
+func (form arm64AtomicPairForm) outputRegs() []Reg {
+	switch form.spec.kind {
+	case arm64AtomicPairCAS:
+		return form.expected // CASP writes the expected pair, not the new value.
+	case arm64AtomicPairLoad:
+		return form.data
+	case arm64AtomicPairStore:
+		return []Reg{form.status}
+	}
+	return nil
+}
+
+func (state *arm64ControlState) transferAtomicPair(form arm64AtomicPairForm) {
+	memory := Operand{Kind: OpMem, Mem: form.memory}
+	var observed [2]arm64ControlValue
+	if form.spec.kind != arm64AtomicPairStore {
+		for i := range observed {
+			observed[i] = state.source(arm64ControlElement(memory, int64(i*form.spec.bits/8)), false)
+			if form.spec.bits == 32 {
+				// Truncating a code address cannot establish an ordinary return.
+				observed[i] = arm64ControlUnion(observed[i], arm64ControlExternal())
+			}
+		}
+	}
+	if form.spec.kind != arm64AtomicPairLoad {
+		value := arm64ControlExternal()
+		for _, reg := range form.data {
+			if reg != ZR && reg != "RSP" {
+				value = arm64ControlUnion(value, arm64ControlRead(state.regs, reg))
+			}
+		}
+		if key := state.memoryKey(memory, false); key != "" {
+			state.invalidateOverlappingControlCells(key, int64(2*form.spec.bits/8))
+			state.memory[key] = value
+		} else {
+			state.invalidateUnknownStore(memory, value)
+		}
+	}
+	for i, reg := range form.outputRegs() {
+		// Encoding 31 in a data/status bank is ZR, not address-bank SP.
+		if reg == ZR || reg == "RSP" {
+			continue
+		}
+		value := arm64ControlExternal()
+		if form.spec.kind != arm64AtomicPairStore {
+			value = observed[i]
+		}
+		state.write(Operand{Kind: OpReg, Reg: reg}, value, false)
+	}
+}
diff --git a/arm64_atomic_pair_test.go b/arm64_atomic_pair_test.go
new file mode 100644
index 000000000..ba8ae1048
--- /dev/null
+++ b/arm64_atomic_pair_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func translateARM64AtomicPairSource(src string) (string, error) {
+	file, err := Parse(ArchARM64, src)
+	if err != nil {
+		return "", err
+	}
+	return Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"atomicpairforms": {Name: "atomicpairforms", Ret: Void},
+		},
+	})
+}
+
+func TestTranslateARM64AtomicPairFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 has ten paired-atomic opcodes. CASP accepts C_ZOREG and
+	// C_ZAUTO memory, while paired exclusive loads/stores accept C_ZOREG.
+	// Register pairs for LDXP/STXP need not be contiguous; SP/RSP in a data
+	// pair encodes register 31 (ZR), rather than changing the stack pointer.
+	src := `
+TEXT atomicpairforms(SB),4,$16-0
+	CASPW (R0, R1), (R2), (R4, R5)
+	CASPW (R6, R7), local-24(SP), (R10, R11)
+	CASPD (R12, R13), (ZR), (R14, R15)
+	CASPD (R30, ZR), (RSP), (g, R29)
+	LDXPW (R16), (R0, R7)
+	LDXP (RSP), (R30, ZR)
+	LDAXPW (ZR), (RSP, R1)
+	LDAXP (R18_PLATFORM), (R2, R17)
+	STXPW (R3, R3), (R19), R20
+	STXP (RSP, R21), (RSP), ZR
+	STLXPW (ZR, R22), (R23), R24
+	STLXP (R25, R26), (ZR), R27
+	// This is a compile-only operand probe, not a callable program. Some
+	// forms overwrite LR or the implicit frame's saved link, so terminate
+	// explicitly rather than inventing a return contract.
+	UNDEF
+`
+	requireARM64GoAssemblerResult(t, src, true)
+	ll, err := translateARM64AtomicPairSource(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"cmpxchg ptr", "load atomic i64", "load atomic i128", "%exclusive_value"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("paired atomic lowering omitted %q:\n%s", want, ll)
+		}
+	}
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goos   string
+		triple string
+	}{
+		{goos: "darwin", triple: "arm64-apple-macosx"},
+		{goos: "linux", triple: "aarch64-unknown-linux-gnu"},
+		{goos: "windows", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"atomicpairforms": {Name: "atomicpairforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "atomic-pair.ll", "atomic-pair.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64AtomicPairFamilyRejectsFormsOutsideGoOptabs(t *testing.T) {
+	invalid := []string{
+		// CASP requires two even-starting contiguous pairs and zero-offset
+		// C_ZOREG/C_ZAUTO memory.
+		"CASPD (R1, R2), (R3), (R4, R5)",
+		"CASPW (R0, R1), (R3), (R5, R6)",
+		"CASPD (R0, R2), (R3), (R4, R5)",
+		"CASPW (R0, R1), (R3), (R4, R6)",
+		"CASPD (R30, RSP), (R3), (R4, R5)",
+		"CASPW R0, (R3), (R4, R5)",
+		"CASPD (R0, R1), (R3), R4",
+		"CASPW (R0, R1), 8(R3), (R4, R5)",
+		"CASPD (R0, R1), local+8(SP), (R4, R5)",
+		"CASPW (R0, R1), value+0(FP), (R4, R5)",
+		"CASPD (R0, R1), value(SB), (R4, R5)",
+		"CASPW.P (R0, R1), (R3), (R4, R5)",
+
+		// Paired exclusive loads require zero-offset register memory, exactly
+		// two distinct GPR/ZR data registers, and no opcode suffix.
+		"LDXP (R3), (R4, R4)",
+		"LDAXPW (R3), (R4, R4)",
+		"LDXPW 8(R3), (R4, R5)",
+		"LDAXP local+0(SP), (R4, R5)",
+		"LDXP value+0(FP), (R4, R5)",
+		"LDAXPW value(SB), (R4, R5)",
+		"LDXP (R3), R4",
+		"LDAXP (R3), (R4, R5, R6)",
+		"LDXP (R3), (F0, R4)",
+		"LDAXPW.P (R3), (R4, R5)",
+
+		// Paired exclusive stores allow repeated data registers, but the
+		// status register cannot be SP/RSP or overlap either data register or
+		// a non-RSP base register.
+		"STXP (R4, R5), (R6), R4",
+		"STLXPW (R4, R5), (R6), R5",
+		"STXPW (R4, R5), (R6), R6",
+		"STLXP (R4, R5), (ZR), ZR",
+		"STXP (R4, R5), (R6), RSP",
+		"STLXPW R4, (R6), R7",
+		"STXP (R4, R5, R6), (R7), R8",
+		"STLXP (R4, F0), (R6), R7",
+		"STXPW (R4, R5), 8(R6), R7",
+		"STLXP (R4, R5), local+0(SP), R7",
+		"STXP (R4, R5), value+0(FP), R7",
+		"STLXPW (R4, R5), value(SB), R7",
+		"STXP.P (R4, R5), (R6), R7",
+	}
+
+	for _, instruction := range invalid {
+		t.Run(strings.NewReplacer(" ", "_", "(", "", ")", "", ",", "_").Replace(instruction), func(t *testing.T) {
+			src := fmt.Sprintf("TEXT atomicpairforms(SB),4,$16-0\n\t%s\n\tRET\n", instruction)
+			if _, err := translateARM64AtomicPairSource(src); err == nil {
+				t.Fatalf("Translate accepted %q, which is outside the Go 1.27 paired-atomic optabs", instruction)
+			}
+		})
+	}
+}
+
+func TestParseARM64AtomicPairPreservesRSPAndNamedSP(t *testing.T) {
+	file, err := Parse(ArchARM64, `
+TEXT atomicpairforms(SB),4,$16-0
+	CASPD (R0, R1), local+0(SP), (R2, R3)
+	LDAXP (RSP), (RSP, R4)
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	casMem := file.Funcs[0].Instrs[1].Args[1].Mem
+	if casMem.Base != SP || casMem.OffRaw == "" {
+		t.Fatalf("named SP memory = %+v, want pseudo-SP plus preserved name", casMem)
+	}
+	load := file.Funcs[0].Instrs[2]
+	if load.Args[0].Mem.Base != Reg("RSP") || load.Args[1].RegList[0] != Reg("RSP") {
+		t.Fatalf("physical RSP was not preserved: %+v", load.Args)
+	}
+}
+
+func TestARM64AtomicPairInstructionFamily(t *testing.T) {
+	for _, op := range []string{
+		"CASPW", "CASPD",
+		"LDXPW", "LDXP", "LDAXPW", "LDAXP",
+		"STXPW", "STXP", "STLXPW", "STLXP",
+	} {
+		if got := InstructionFamily(ArchARM64, op); got != "atomic-memory" {
+			t.Errorf("InstructionFamily(arm64, %s) = %q, want atomic-memory", op, got)
+		}
+	}
+}
diff --git a/arm64_barrier_encoding_go127_test.go b/arm64_barrier_encoding_go127_test.go
new file mode 100644
index 000000000..4521ca08c
--- /dev/null
+++ b/arm64_barrier_encoding_go127_test.go
@@ -0,0 +1,139 @@
+//go:build go1.27
+// +build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"encoding/hex"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+)
+
+func arm64BarrierAuditOutput(t *testing.T, tool string, arguments []string, input string, environment []string) []byte {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, tool, arguments...)
+	command.Stdin = strings.NewReader(input)
+	command.Env = environment
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("barrier encoding oracle %s: %v\n%s", filepath.Base(tool), err, output)
+	}
+	return output
+}
+
+func arm64BarrierObjectText(t *testing.T, object, triple string) []byte {
+	t.Helper()
+	if strings.Contains(triple, "apple") {
+		file, err := macho.Open(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if section := file.Section("__text"); section != nil {
+			data, err := section.Data()
+			if err != nil {
+				t.Fatal(err)
+			}
+			return data
+		}
+	} else if strings.Contains(triple, "windows") {
+		file, err := pe.Open(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if section := file.Section(".text"); section != nil {
+			data, err := section.Data()
+			if err != nil {
+				t.Fatal(err)
+			}
+			return data
+		}
+	} else {
+		file, err := elf.Open(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if section := file.Section(".text"); section != nil {
+			data, err := section.Data()
+			if err != nil {
+				t.Fatal(err)
+			}
+			return data
+		}
+	}
+	t.Fatalf("missing instruction section in %s object", triple)
+	return nil
+}
+
+func TestARM64SpeculationBarrierMatchesGoAndLLVMEncoding(t *testing.T) {
+	// Go's ASB SYSOP and LLVM's feature-gated SB encode D50330FF.
+	// HINT #7 is D50320FF: accepting either string is not a byte oracle.
+	source := "TEXT barrier(SB),516,$0-0\nSB\nRET\n"
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "original.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing := arm64BarrierAuditOutput(t, "go", []string{"tool", "asm", "-S", "-o", filepath.Join(dir, "original.o"), asm}, "",
+		append(os.Environ(), "GOOS=linux", "GOARCH=arm64"))
+	var native []byte
+	for _, row := range regexp.MustCompile(`(?m)^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`).FindAllSubmatch(listing, -1) {
+		decoded, err := hex.DecodeString(strings.ReplaceAll(string(row[1]), " ", ""))
+		if err != nil {
+			t.Fatal(err)
+		}
+		native = append(native, decoded...)
+	}
+	want := []byte{0xff, 0x30, 0x03, 0xd5}
+	if len(native) < 8 || !bytes.Equal(native[:4], want) || !bytes.Equal(native[4:8], []byte{0xc0, 0x03, 0x5f, 0xd6}) {
+		t.Fatalf("actual Go SB/RET object = %x, want ff3003d5c0035fd6", native)
+	}
+	llc, mc := findLLVM22Tool("llc"), findLLVM22Tool("llvm-mc")
+	if llc == "" || mc == "" {
+		t.Fatal("LLVM 22 llc and llvm-mc are required")
+	}
+	encoding := arm64BarrierAuditOutput(t, mc, []string{"-triple=aarch64", "-mattr=+sb", "-show-encoding"}, "sb\n", os.Environ())
+	if !bytes.Contains(encoding, []byte("[0xff,0x30,0x03,0xd5]")) {
+		t.Fatalf("independent LLVM SB encoding = %s", encoding)
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"barrier": {Name: "barrier", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llPath, object := filepath.Join(t.TempDir(), "barrier.ll"), filepath.Join(t.TempDir(), "barrier.o")
+			if err := os.WriteFile(llPath, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			arm64BarrierAuditOutput(t, llc, []string{"-O0", "-mtriple=" + triple, "-filetype=obj", llPath, "-o", object}, "", os.Environ())
+			text := arm64BarrierObjectText(t, object, triple)
+			// LLVM may independently use XPACLRI (the HINT #7 encoding)
+			// when implementing llvm.returnaddress in the entry harness.
+			// Bind the source operation to its IR and the real SB word,
+			// rather than banning that unrelated compiler-generated effect.
+			if bytes.Count(text, want) != 1 || strings.Contains(ir, `asm sideeffect "hint #7"`) {
+				t.Fatalf("LLVM SB object = %x, source must emit exact SB once, not substitute HINT #7", text)
+			}
+		})
+	}
+}
diff --git a/arm64_barrier_scratch_test.go b/arm64_barrier_scratch_test.go
new file mode 100644
index 000000000..09b4041fd
--- /dev/null
+++ b/arm64_barrier_scratch_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64BarrierPreservesUnknownSourceScratch(t *testing.T) {
+	instructions := []string{"SB"}
+	for _, op := range []string{"DMB", "DSB", "ISB"} {
+		for immediate := 0; immediate < 16; immediate++ {
+			instructions = append(instructions, fmt.Sprintf("%s $%d", op, immediate))
+		}
+	}
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			ins := arm64ImmediateTestInstruction(t, instruction)
+			var ir strings.Builder
+			flow := &arm64MachineAvailability{
+				blocks: []arm64MachineBlock{{name: "entry", effects: []arm64MachineEffect{
+					{register: "R27", unavailable: true, source: "original source memory expansion"},
+				}}},
+				source: instruction, sourceScratch: true,
+			}
+			ctx := &arm64Ctx{b: &ir, machineAvailability: flow}
+			ok, terminated, err := ctx.lowerARM64Barrier(ins.Op, ins)
+			if !ok || terminated || err != nil {
+				t.Fatalf("barrier lowerer = (%v, %v, %v)", ok, terminated, err)
+			}
+			ctx.recordMachineOpaqueIR(0, ins)
+			if err := flow.validateSourceScratch(); err != nil {
+				t.Fatalf("barrier observed a GP scratch it does not read: %v", err)
+			}
+			if !strings.Contains(ir.String(), "~{memory}") || len(flow.blocks[0].effects) != 1 {
+				t.Fatalf("barrier lost its memory clobber or manufactured register effects: %s", ir.String())
+			}
+			// Neutral does not make the original scratch known or permit a
+			// second, unproved native effect in the same source instruction.
+			flow.blocks[0].effects = append(flow.blocks[0].effects, arm64MachineEffect{
+				register: "R27", width: 64, source: "subsequent real R27 read",
+			})
+			if err := flow.validateSourceScratch(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("barrier made R27 available: %v", err)
+			}
+			flow.blocks[0].effects = flow.blocks[0].effects[:1]
+			fmt.Fprintln(&ir, `  call void asm sideeffect "nop", ""()`)
+			ctx.recordMachineOpaqueIR(0, ins)
+			if err := flow.validateSourceScratch(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("validated barrier excused a second opaque callout: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64BarrierRejectsFloatingConstantClass(t *testing.T) {
+	for _, op := range []string{"DMB", "DSB", "ISB"} {
+		for _, literal := range []string{"0.0", "-0.0", "1.5", "-1.5"} {
+			instruction := fmt.Sprintf("%s $%s", op, literal)
+			t.Run(instruction, func(t *testing.T) {
+				requireARM64GoAssemblerResult(t, "TEXT invalid(SB),516,$0-0\n"+instruction+"\nRET\n", false)
+				ins := arm64ImmediateTestInstruction(t, instruction)
+				var ir strings.Builder
+				ctx := &arm64Ctx{b: &ir}
+				ok, _, err := ctx.lowerARM64Barrier(ins.Op, ins)
+				if !ok || err == nil || ir.Len() != 0 {
+					t.Fatalf("Go-invalid floating barrier = (%v, %v), emitted %q", ok, err, ir.String())
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_blocks.go b/arm64_blocks.go
index 537d7b548..a4ccb2419 100644
--- a/arm64_blocks.go
+++ b/arm64_blocks.go
@@ -6,22 +6,25 @@ import (
 )
 
 type arm64Block struct {
-	name   string // source label (or "entry")
-	instrs []Instr
+	name      string
+	instrs    []Instr
+	synthetic bool
 }
 
 func arm64SplitBlocks(fn Func) []arm64Block {
-	blocks := []arm64Block{{name: "entry"}}
+	names := newAssemblyBlockNames(fn)
+	blocks := []arm64Block{{name: names.fresh("entry"), synthetic: true}}
 	cur := 0
 	anon := 0
 
 	startAnon := func() {
 		anon++
-		blocks = append(blocks, arm64Block{name: fmt.Sprintf("anon_%d", anon)})
+		blocks = append(blocks, arm64Block{name: names.fresh(fmt.Sprintf("anon_%d", anon)), synthetic: true})
 		cur = len(blocks) - 1
 	}
 
 	isTerminator := func(ins Instr) bool {
+		ins = arm64ControlDecode(ins)
 		if ins.Op == OpRET {
 			return true
 		}
@@ -30,8 +33,10 @@ func arm64SplitBlocks(fn Func) []arm64Block {
 			op = op[:dot]
 		}
 		switch Op(op) {
+		case "BL", "BLR", "CALL":
+			return true
 		case "B", "JMP", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT", "BHS", "BLS", "BMI", "BPL", "BVS", "BVC",
-			"BCC", "CBZ", "CBNZ", "TBZ", "TBNZ":
+			"BCC", "BCS", "CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ":
 			return true
 		default:
 			return false
@@ -43,8 +48,9 @@ func arm64SplitBlocks(fn Func) []arm64Block {
 			lbl := ins.Args[0].Sym
 			// Labels start a new basic block. If we previously created an empty
 			// synthetic fallthrough block, reuse it by renaming.
-			if len(blocks[cur].instrs) == 0 && strings.HasPrefix(blocks[cur].name, "anon_") {
+			if cur != 0 && len(blocks[cur].instrs) == 0 && blocks[cur].synthetic {
 				blocks[cur].name = lbl
+				blocks[cur].synthetic = false
 				continue
 			}
 			blocks = append(blocks, arm64Block{name: lbl})
@@ -60,37 +66,44 @@ func arm64SplitBlocks(fn Func) []arm64Block {
 	}
 
 	// Drop trailing empty synthetic block if present.
-	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && strings.HasPrefix(blocks[len(blocks)-1].name, "anon_") {
-		blocks = blocks[:len(blocks)-1]
+	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && blocks[len(blocks)-1].synthetic {
+		previous := blocks[len(blocks)-2]
+		lastOp := Op("")
+		if len(previous.instrs) != 0 {
+			lastOp = arm64ControlOp(arm64ControlDecode(previous.instrs[len(previous.instrs)-1]))
+		}
+		if lastOp != "BL" && lastOp != "BLR" && lastOp != "CALL" {
+			blocks = blocks[:len(blocks)-1]
+		}
 	}
 	return blocks
 }
 
-func arm64LLVMBlockName(src string) string {
-	if src == "" {
-		return "bb"
-	}
-	var out []byte
-	for i := 0; i < len(src); i++ {
-		ch := src[i]
-		if (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') {
-			out = append(out, ch)
-			continue
-		}
-		out = append(out, '_')
+func arm64IsLocalBranchLink(ins Instr) bool {
+	op := strings.ToUpper(string(ins.Op))
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		op = op[:dot]
 	}
-	s := string(out)
-	if s == "" {
-		return "bb"
+	if op != "BL" && op != "BLR" && op != "CALL" || len(ins.Args) != 1 {
+		return false
 	}
-	if s[0] >= '0' && s[0] <= '9' {
-		s = "bb_" + s
-	}
-	// Avoid collisions with "entry:" / "ret:" that some tools special-case.
-	if s == "entry" {
-		s = "bb_entry"
+	target := ins.Args[0]
+	switch target.Kind {
+	case OpIdent:
+		return true
+	case OpSym:
+		return !strings.HasSuffix(target.Sym, "(SB)")
+	case OpMem:
+		return target.Mem.Base == PC
+	default:
+		return false
 	}
-	return s
+}
+
+func arm64LLVMBlockName(src string) string {
+	// Encode every non-alphanumeric byte injectively, including underscores.
+	// The block namespace is disjoint from register and SSA temporary names.
+	return "bb_" + amd64LLVMSafeName(src)
 }
 
 func arm64BranchTarget(op Operand) (string, bool) {
diff --git a/arm64_blocks_test.go b/arm64_blocks_test.go
new file mode 100644
index 000000000..e2363f69f
--- /dev/null
+++ b/arm64_blocks_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64SplitBlocksRecognizesEveryConditionalBranchTerminator(t *testing.T) {
+	ops := []Op{
+		"BEQ", "BNE", "BLO", "BLT", "BHI", "BHS", "BLS", "BGE", "BGT", "BLE",
+		"BCC", "BCS", "BMI", "BPL", "BVS", "BVC",
+		"CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ",
+	}
+	for _, op := range ops {
+		t.Run(string(op), func(t *testing.T) {
+			blocks := arm64SplitBlocks(Func{Instrs: []Instr{
+				{Op: op, Raw: string(op)},
+				{Op: "NOP", Raw: "NOP"},
+				{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: "target"}}},
+				{Op: "NOP", Raw: "NOP"},
+			}})
+			if len(blocks) != 3 || len(blocks[0].instrs) != 1 || len(blocks[1].instrs) != 1 || blocks[2].name != "target" {
+				t.Fatalf("arm64SplitBlocks(%s) = %#v, want branch/fallthrough/target blocks", op, blocks)
+			}
+		})
+	}
+}
diff --git a/arm64_borrowed_frame_source_oracle_test.go b/arm64_borrowed_frame_source_oracle_test.go
new file mode 100644
index 000000000..a9e985639
--- /dev/null
+++ b/arm64_borrowed_frame_source_oracle_test.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "testing"
+
+// This is the original borrowed-frame source, not a translated C tail call.
+// Its helper consumes the outgoing slots correctly but has no source-level
+// epilogue for the caller's 48-byte Go frame. Restore real SP/LR/FP in the
+// NOFRAME observation trampoline so the native witness safely returns to Go.
+func TestCrossLinuxRuntimeMatrixARM64BorrowedFrameSourceSPOracle(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	const trampoline = `TEXT ·Measure(SB),516,$0-16
+MOVD out+0(FP),R0
+MOVD RSP,R19
+MOVD R30,R23
+MOVD R29,R24
+SUB $16,RSP
+MOVD R0,8(RSP)
+CALL caller(SB)
+SUB R19,RSP,R0
+ADD $16,R0
+MOVD R19,RSP
+MOVD R24,R29
+MOVD R23,R30
+MOVD R0,ret+8(FP)
+RET
+`
+	runARM64LocalRegisterGoOracle(t, trampoline+arm64BorrowedTailOriginalSource, `package main
+func Measure(*uint64) int64
+func main() {
+  for _,initial:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    out:=initial
+    if delta:=Measure(&out); delta!=-48 { panic(delta) }
+    if out!=7 { panic("original borrowed argument slots changed") }
+  }
+}
+`, len(runner) != 0)
+	t.Log("native Go original borrowed helper writes 7 but returns with SP delta -48; trampoline restores actual caller SP/LR/FP")
+}
diff --git a/arm64_borrowed_tail_cross_test.go b/arm64_borrowed_tail_cross_test.go
new file mode 100644
index 000000000..bdbdcd8c9
--- /dev/null
+++ b/arm64_borrowed_tail_cross_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+const arm64BorrowedTailOriginalSource = `TEXT caller(SB),4,$24-8
+	MOVD out+0(FP), R4
+	MOVD $7, R3
+	MOVD R3, 8(RSP)
+	MOVD R4, 16(RSP)
+	B helper(SB)
+TEXT helper(SB),4,$0-0
+	MOVD vector+0(FP), R3
+	MOVD out+8(FP), R4
+	MOVD R3, (R4)
+	RET
+`
+
+// An ordinary typed LLVM call/return does not implement the native source
+// helper's borrowed SP and missing caller-frame epilogue. The native Go
+// observation oracle retains the original slots and safely measures -48.
+func TestARM64BorrowedTailFrameRequiresNativeStackContract(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64BorrowedTailOriginalSource, true)
+	file, err := Parse(ArchARM64, arm64BorrowedTailOriginalSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		_, err := Translate(file, Options{
+			Goarch: "arm64", TargetTriple: triple,
+			Sigs: map[string]FuncSig{
+				"caller": {
+					Name: "caller", Args: []LLVMType{Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1, Name: "out"},
+					}},
+				},
+				"helper": {
+					Name: "helper", Args: []LLVMType{I64, I64}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: -1, Name: "vector"},
+						{Offset: 8, Type: I64, Index: 1, Field: -1, Name: "out"},
+					}},
+				},
+			},
+		})
+		if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "symbol branch has no implicit Go frame epilogue") {
+			t.Fatalf("%s: native borrowed-frame continuation must remain Context: %v", triple, err)
+		}
+	}
+}
diff --git a/arm64_byte_carrier_binding.go b/arm64_byte_carrier_binding.go
new file mode 100644
index 000000000..77cdf19f1
--- /dev/null
+++ b/arm64_byte_carrier_binding.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64ByteCarrierBinding struct {
+	source     *GoARM64ByteCarrierSource
+	file       *File
+	options    Options
+	symbols    map[string]string
+	signatures map[string][]byte
+	functions  map[string]*arm64ByteCarrierFunction
+}
+
+func (source *GoARM64ByteCarrierSource) revokeCarrier() {
+	if source == nil {
+		return
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if source.identity == source {
+		source.ready = false
+	}
+}
+
+// This checks the existing observation's identity/lifetime only. It neither
+// creates a binding nor substitutes for the complete physical Verify checks.
+func (source *GoARM64ByteCarrierSource) liveCarrier() error {
+	if source == nil {
+		return arm64ByteCarrierContext("missing original source owner")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if source.identity != source {
+		return arm64ByteCarrierContext("copied or uninitialized original source")
+	}
+	err := arm64ByteCarrierLive(source.lease)
+	if !source.ready || err != nil {
+		source.ready = false
+		return errors.Join(arm64ByteCarrierContext("original owner closed or expired"), err)
+	}
+	return nil
+}
+
+func bindARM64ByteCarrier(file *File, options Options) (_ *arm64ByteCarrierBinding, failure error) {
+	if err := rejectMixedNativeAuthorities(options.NumericalReads, options.ARM64ByteCarrierSource); err != nil {
+		return nil, err
+	}
+	source := options.ARM64ByteCarrierSource
+	if source == nil {
+		return nil, arm64ByteCarrierContext("missing original source owner")
+	}
+	defer func() {
+		if failure != nil {
+			source.revokeCarrier()
+		}
+	}()
+	if err := source.Verify(source.lease); err != nil {
+		return nil, err
+	}
+	targets := map[string]string{
+		"aarch64-apple-darwin": "darwin/arm64", "arm64-apple-darwin": "darwin/arm64",
+		"aarch64-unknown-linux-gnu": "linux/arm64", "aarch64-pc-windows-msvc": "windows/arm64",
+		"aarch64-unknown-freebsd": "freebsd/arm64", "aarch64-unknown-openbsd": "openbsd/arm64",
+	}
+	if file == nil || file.Arch != ArchARM64 || options.Goarch != "arm64" || options.ResolveSym == nil ||
+		targets[options.TargetTriple] != source.request.Target || source.guard.selection.Name == "main" ||
+		options.WASMABI != WASMABIDirect || options.X87Mode != X87Auto || len(options.X86TailGroups) != 0 ||
+		len(file.Funcs) == 0 || len(file.Funcs) > 256 || len(options.Sigs) != len(source.declarations) ||
+		!reflect.DeepEqual(arm64ScratchFileSnapshot(file), arm64ScratchFileSnapshot(source.file)) {
+		return nil, arm64ByteCarrierContext("complete private library source/target/options differ")
+	}
+	binding := &arm64ByteCarrierBinding{
+		source: source, file: arm64ScratchFileSnapshot(file), options: options,
+		symbols: make(map[string]string), signatures: make(map[string][]byte), functions: make(map[string]*arm64ByteCarrierFunction),
+	}
+	// Snapshot every signature before calling arbitrary user resolution code.
+	for name, signature := range options.Sigs {
+		binding.signatures[name] = append([]byte(nil), arm64ScratchPublicSignature(signature)...)
+	}
+	for _, function := range binding.file.Funcs {
+		if err := source.liveCarrier(); err != nil {
+			return nil, err
+		}
+		name := strings.TrimPrefix(function.Sym, "·")
+		expected, present := source.declarations[name]
+		resolved := options.ResolveSym(function.Sym)
+		if err := source.liveCarrier(); err != nil {
+			return nil, err
+		}
+		if !present || resolved != expected.Name || !bytes.Equal(binding.signatures[resolved], arm64ScratchPublicSignature(expected)) ||
+			binding.symbols[function.Sym] != "" || binding.functions[resolved] != nil {
+			return nil, arm64ByteCarrierContext("actual declaration/LLVM identity differs or collides")
+		}
+		binding.symbols[function.Sym] = resolved
+		binding.functions[resolved] = &arm64ByteCarrierFunction{source: function, signature: expected,
+			privateName: resolved + ".plan9asm.bytecarrier"}
+	}
+	if err := binding.verifyFileAndOptions(file, options); err != nil {
+		return nil, err
+	}
+	if err := binding.prepareNative(); err != nil {
+		return nil, err
+	}
+	if err := binding.verify(); err != nil {
+		return nil, err
+	}
+	return binding, nil
+}
+
+func (binding *arm64ByteCarrierBinding) verifyFileAndOptions(file *File, options Options) error {
+	if !reflect.DeepEqual(binding.file, arm64ScratchFileSnapshot(file)) || len(options.Sigs) != len(binding.signatures) ||
+		options.ARM64ByteCarrierSource != binding.source || options.TargetTriple != binding.options.TargetTriple ||
+		options.Goarch != binding.options.Goarch || options.WASMABI != binding.options.WASMABI ||
+		options.X87Mode != binding.options.X87Mode || options.AnnotateSource != binding.options.AnnotateSource ||
+		len(options.X86TailGroups) != 0 || options.NumericalReads != nil {
+		return arm64ByteCarrierContext("source/options changed during callbacks or lowering")
+	}
+	for name, prior := range binding.signatures {
+		current, exists := options.Sigs[name]
+		if !exists || !bytes.Equal(prior, arm64ScratchPublicSignature(current)) {
+			return arm64ByteCarrierContext("complete signature inventory changed")
+		}
+	}
+	return nil
+}
+
+func (binding *arm64ByteCarrierBinding) verify() error {
+	if err := binding.source.Verify(binding.source.lease); err != nil {
+		return err
+	}
+	for _, function := range binding.file.Funcs {
+		if err := binding.source.liveCarrier(); err != nil {
+			return err
+		}
+		name := binding.options.ResolveSym(function.Sym)
+		if err := binding.source.liveCarrier(); err != nil {
+			return err
+		}
+		if name != binding.symbols[function.Sym] {
+			return arm64ByteCarrierContext("resolution changed after the original declaration join")
+		}
+	}
+	if err := binding.verifyFileAndOptions(binding.file, binding.options); err != nil {
+		return err
+	}
+	return binding.source.Verify(binding.source.lease)
+}
+
+func translateARM64ByteCarrierModule(ctx llvm.Context, file *File, options Options) (result llvm.Module, failure error) {
+	binding, err := bindARM64ByteCarrier(file, options)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	defer func() {
+		final := errors.Join(binding.verifyFileAndOptions(file, options), binding.verify())
+		if failure != nil || final != nil {
+			binding.source.revokeCarrier()
+			if !result.IsNil() {
+				result.Dispose()
+			}
+			result = llvm.Module{}
+			failure = errors.Join(failure, final)
+		}
+	}()
+	ir, err := binding.emitIR()
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	return parseIRModuleInContext(ctx, ir)
+}
diff --git a/arm64_byte_carrier_completion_go127_test.go b/arm64_byte_carrier_completion_go127_test.go
new file mode 100644
index 000000000..5e2eda7b7
--- /dev/null
+++ b/arm64_byte_carrier_completion_go127_test.go
@@ -0,0 +1,193 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64ByteCarrierOnStack(name string) bool {
+	var pcs [32]uintptr
+	frames := runtime.CallersFrames(pcs[:runtime.Callers(2, pcs[:])])
+	for {
+		frame, more := frames.Next()
+		if strings.HasSuffix(frame.Function, name) {
+			return true
+		}
+		if !more {
+			return false
+		}
+	}
+}
+
+type arm64ByteCarrierLoweringCancelContext struct {
+	context.Context
+	cancel  context.CancelCauseFunc
+	cause   error
+	reached bool
+}
+
+func (owner *arm64ByteCarrierLoweringCancelContext) Err() error {
+	if arm64ByteCarrierOnStack("(*arm64ByteCarrierBinding).emitIR") {
+		owner.reached = true
+		owner.cancel(owner.cause)
+	}
+	return owner.Context.Err()
+}
+
+func TestARM64ByteCarrierOriginalLeaseGuardsLoweringAndCompletion(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, phase := range []string{"lowering", "completion"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(phase+"/"+api, func(t *testing.T) {
+				bounded, release := runtimeOracleStageContext(t)
+				defer release()
+				lease, cancel := context.WithCancelCause(bounded)
+				defer cancel(context.Canceled)
+				cause := errors.New("original owner cancelled during " + phase)
+				instrumented := &arm64ByteCarrierLoweringCancelContext{Context: lease, cancel: cancel, cause: cause}
+				var captureOwner context.Context = lease
+				if phase == "lowering" {
+					captureOwner = instrumented
+				}
+				source, err := CaptureGoARM64ByteCarrierSource(captureOwner, request)
+				if err != nil {
+					t.Fatalf("original capture must precede the actual consumer phase: %v", err)
+				}
+				defer source.Close()
+				completed := false
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+					func(_ *File, options *Options, goOptions *GoModuleOptions) {
+						resolve := testResolveSym(packagePath)
+						callback := func(symbol string) string {
+							if phase == "completion" && arm64ByteCarrierOnStack("translateARM64ByteCarrierModule.func1") {
+								completed = true
+								cancel(cause)
+							}
+							return resolve(symbol)
+						}
+						options.ResolveSym, goOptions.ResolveSym = callback, callback
+					})
+				if phase == "lowering" && !instrumented.reached || phase == "completion" && !completed {
+					t.Fatal("test did not reach its actual lowering/post-module phase")
+				}
+				if !errors.Is(err, cause) || !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("cancelled actual phase returned LLVM output or lost cause: %v", err)
+				}
+				fresh, stop := runtimeOracleStageContext(t)
+				defer stop()
+				if !errors.Is(source.Verify(fresh), cause) {
+					t.Fatal("fresh context revived the cancelled original owner")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ByteCarrierGoFinalMetadataUsesOriginalNames(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	resolve := testResolveSym(packagePath)
+	calibration, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer calibration.Close()
+	count := 0
+	ir, err := arm64ByteCarrierTranslateAPI(t, "Go", calibration, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+		func(_ *File, _ *Options, options *GoModuleOptions) {
+			options.ResolveSym = func(symbol string) string {
+				count++
+				return resolve(symbol)
+			}
+		})
+	if err != nil || ir == "" || count <= len(calibration.file.Funcs) {
+		t.Fatalf("actual successful complete Go callback calibration failed: calls=%d error=%v", count, err)
+	}
+	firstFinal := count - len(calibration.file.Funcs) + 1
+	owner, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	calls, changed := 0, false
+	ir, err = arm64ByteCarrierTranslateAPI(t, "Go", owner, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+		func(_ *File, _ *Options, options *GoModuleOptions) {
+			options.ResolveSym = func(symbol string) string {
+				calls++
+				if calls == firstFinal {
+					changed = true
+					return packagePath + ".foreign_metadata"
+				}
+				return resolve(symbol)
+			}
+		})
+	if !changed || calls != count || !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatalf("final Functions metadata escaped the actual LLVM/signature join: calls=%d/%d error=%v", calls, count, err)
+	}
+	if !errors.Is(owner.Verify(lease), ErrProbeNeedsContext) {
+		t.Fatal("final metadata mismatch did not permanently revoke the original owner")
+	}
+	t.Logf("actual complete callbacks=%d; changed final metadata callback=%d", count, firstFinal)
+}
+
+func TestARM64ByteCarrierMainObservationDoesNotGrantConsumerRole(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	filename := filepath.Join(directory, "decl.go")
+	declarations, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations = []byte(strings.Replace(string(declarations), "package carrierfixture", "package main", 1) + "\nfunc main() {}\n")
+	if err := os.WriteFile(filename, declarations, 0600); err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			owner, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil || owner == nil || owner.report.NativePackagePath != "main" {
+				t.Fatalf("actual main namespace observation failed before consumer: %v", err)
+			}
+			defer owner.Close()
+			ir, err := arm64ByteCarrierTranslateAPI(t, api, owner, pkg, string(assembly), "aarch64-unknown-linux-gnu", nil)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("observational main package acquired private library authority: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_consumer_boundaries_go127_test.go b/arm64_byte_carrier_consumer_boundaries_go127_test.go
new file mode 100644
index 000000000..f37a0026b
--- /dev/null
+++ b/arm64_byte_carrier_consumer_boundaries_go127_test.go
@@ -0,0 +1,170 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestARM64ByteCarrierGoOptionsRemainOriginal(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, test := range []struct {
+		name   string
+		mutate func(GoPackage, *GoModuleOptions)
+	}{
+		{"foreign-source-OS", func(_ GoPackage, options *GoModuleOptions) { options.GOOS = "windows" }},
+		{"missing-source-OS", func(_ GoPackage, options *GoModuleOptions) { options.GOOS = "" }},
+		{"filtered-call-graph", func(_ GoPackage, options *GoModuleOptions) {
+			options.KeepFunc = func(_, _ string) bool { return false }
+		}},
+		{"late-Go-syntax", func(pkg GoPackage, options *GoModuleOptions) {
+			resolve := options.ResolveSym
+			options.ResolveSym = func(symbol string) string {
+				pkg.Syntax[0].Name.Name = "changed"
+				return resolve(symbol)
+			}
+		}},
+		{"late-result-metadata", func(_ GoPackage, options *GoModuleOptions) {
+			resolve := options.ResolveSym
+			calls := 0
+			options.ResolveSym = func(symbol string) string {
+				calls++
+				if calls > 1 {
+					return "example.invalid/foreign." + symbol
+				}
+				return resolve(symbol)
+			}
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			pkg := mustGoPackage(t, packagePath, string(declarations))
+			ir, err := arm64ByteCarrierTranslateAPI(t, "Go", source, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+				func(_ *File, _ *Options, options *GoModuleOptions) { test.mutate(pkg, options) })
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("changed original Go semantics returned LLVM output: %v", err)
+			}
+			if !errors.Is(source.Verify(lease), ErrProbeNeedsContext) {
+				t.Fatal("failed semantic join did not permanently revoke source")
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierConsumersRequireActualOwner(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, kind := range []string{"copy", "JSON", "closed", "cancelled"} {
+		t.Run(kind, func(t *testing.T) {
+			bounded, release := runtimeOracleStageContext(t)
+			defer release()
+			lease, cancel := context.WithCancelCause(bounded)
+			defer cancel(context.Canceled)
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			candidate := source
+			cause := errors.New("original owner cancelled before consumer entry")
+			switch kind {
+			case "copy":
+				candidate = &GoARM64ByteCarrierSource{identity: source, ready: true, lease: lease, guard: source.guard}
+			case "JSON":
+				candidate = new(GoARM64ByteCarrierSource)
+				if err := json.Unmarshal(source.raw, candidate); err != nil {
+					t.Fatal(err)
+				}
+			case "closed":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "cancelled":
+				cancel(cause)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ByteCarrierTranslateAPI(t, api, candidate, pkg, string(assembly), "aarch64-unknown-linux-gnu", nil)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || kind == "cancelled" && !errors.Is(err, cause) {
+						t.Fatalf("non-owner returned output or lost cancellation cause: %v", err)
+					}
+				})
+			}
+			if (kind == "copy" || kind == "JSON") && source.Verify(lease) != nil {
+				t.Fatal("untrusted identity revoked its actual original owner")
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierCallbacksStopAfterSourceClose(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			pkg := mustGoPackage(t, packagePath, string(declarations))
+			calls := 0
+			resolve := testResolveSym(packagePath)
+			ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+				func(_ *File, options *Options, goOptions *GoModuleOptions) {
+					callback := func(symbol string) string {
+						calls++
+						if calls == 1 {
+							if err := source.Close(); err != nil {
+								t.Fatal(err)
+							}
+						}
+						return resolve(symbol)
+					}
+					options.ResolveSym, goOptions.ResolveSym = callback, callback
+				})
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || calls != 1 {
+				t.Fatalf("consumer called after owner Close or returned output: calls=%d error=%v", calls, err)
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_consumer_darwin_arm64_test.go b/arm64_byte_carrier_consumer_darwin_arm64_test.go
new file mode 100644
index 000000000..0e1d872f6
--- /dev/null
+++ b/arm64_byte_carrier_consumer_darwin_arm64_test.go
@@ -0,0 +1,156 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This first RED keeps the real original caller's initialized native cell and
+// adjacent canary. Typed-result-only equality cannot detect a dropped tail.
+func TestARM64ByteCarrierMOVDUint32SameCarrier(t *testing.T) {
+	directory := t.TempDir()
+	var err error
+	directory, err = filepath.EvalSymlinks(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath := "example.invalid/nativecarrier"
+	width := arm64NativeResultTailCase{op: "MOVD", resultBits: 32, storeBits: 64}
+	callee := strings.ToLower(width.name())
+	goSource := "package nativecarrier\n" + strings.ReplaceAll(width.declaration(), width.name(), callee) +
+		"func observe_" + callee + "(input uint64) (value,native,guard uint64)\n"
+	originalTest := `package nativecarrier
+
+import "testing"
+
+func TestOriginalCarrier(t *testing.T) {
+    value, native, guard := observe_movd_u32(0x123456789abcdef0)
+    if value != 0x9abcdef0 || native != 0x123456789abcdef0 || guard != 0x7ac35ef012345678 {
+        t.Fatal("original native bytes or adjacent canary differ")
+    }
+    t.Log("BYTE_CARRIER_MOVD32", value, native, guard)
+}
+`
+	assembly := strings.ReplaceAll(width.source()+arm64NativeResultTailObserver(width), width.name(), callee)
+	for name, data := range map[string]string{
+		"go.mod":  "module " + packagePath + "\ngo 1.20\n",
+		"decl.go": goSource, "original_arm64.s": assembly, "original_test.go": originalTest,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	request.Target = "darwin/arm64"
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOOS=") {
+			request.Environment[index] = "GOOS=darwin"
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	// The runtime driver is created before Capture, but is not a selected
+	// library source. Its go test identity supplies no observation authority.
+	command := exec.CommandContext(ctx, request.GoBinary, "test", "-p=1", "-mod=readonly", "-run=^TestOriginalCarrier$", "-count=1", "-v", ".")
+	command.Dir, command.Env = request.Directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	want := fmt.Sprintf("BYTE_CARRIER_MOVD32 %d %d %d\n", uint64(0x9abcdef0), uint64(0x123456789abcdef0), uint64(0x7ac35ef012345678))
+	if err != nil || strings.Count(string(output), strings.TrimSpace(want)) != 1 || !strings.Contains(string(output), "--- PASS: TestOriginalCarrier") {
+		t.Fatalf("unchanged original Go whole-byte/canary witness: %v\n%s", err, output)
+	}
+	t.Logf("actual original Go same-carrier witness: %s", strings.TrimSpace(want))
+	source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	if len(source.report.Calls) != 1 || len(source.report.Calls[0].SPWrites) != 1 || source.report.Calls[0].SPWrites[0].Bytes != 8 {
+		t.Fatal("original native-width same-call observation is incomplete")
+	}
+	for _, member := range source.report.Archive[1:] {
+		for _, text := range member.Texts {
+			t.Logf("actual original entry/body %s ABI%d code=%x relocations=%+v", text.Name, text.ABI, text.Code, text.Relocations)
+		}
+	}
+	pkg := mustGoPackage(t, packagePath, goSource)
+	resolve := testResolveSym(pkg.Path)
+	triple := "aarch64-apple-darwin"
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM 22 llc and clang are required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			llvmContext := llvm.NewContext()
+			defer llvmContext.Dispose()
+			var ir string
+			var failure error
+			if api == "Go" {
+				translated, err := translateGoModuleInContext(llvmContext, pkg, []byte(assembly), GoModuleOptions{
+					GOOS: "darwin", GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+					ARM64ByteCarrierSource: source,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					ir = translated.Module.String()
+					translated.Module.Dispose()
+				}
+				failure = err
+			} else {
+				file, err := Parse(ArchARM64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				signatures, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: signatures,
+					ARM64ByteCarrierSource: source}
+				if api == "text" {
+					ir, failure = Translate(file, options)
+				} else {
+					module, err := TranslateModuleInContext(llvmContext, file, options)
+					if !module.IsNil() {
+						ir = module.String()
+						module.Dispose()
+					}
+					failure = err
+				}
+			}
+			if failure != nil {
+				t.Fatalf("live original same-carrier MOVD uint32 still lacks its bounded native transport: %v", failure)
+			}
+			ir += fmt.Sprintf(`
+define i32 @byte_carrier_check(i64 %%input) {
+    %%result = call { i64, i64, i64 } %s(i64 %%input)
+    %%value = extractvalue { i64, i64, i64 } %%result, 0
+    %%native = extractvalue { i64, i64, i64 } %%result, 1
+    %%guard = extractvalue { i64, i64, i64 } %%result, 2
+    %%low = and i64 %%input, 4294967295
+    %%typed_ok = icmp eq i64 %%value, %%low
+    %%native_ok = icmp eq i64 %%native, %%input
+    %%guard_ok = icmp eq i64 %%guard, %d
+    %%both = and i1 %%typed_ok, %%native_ok
+    %%all = and i1 %%both, %%guard_ok
+    %%status = select i1 %%all, i32 0, i32 1
+    ret i32 %%status
+}
+`, llvmGlobal(packagePath+".observe_"+callee), uint64(0x7ac35ef012345678))
+			mainC := `#include <stdint.h>
+extern int32_t byte_carrier_check(uint64_t input);
+int main(void) {
+    return byte_carrier_check(UINT64_C(0x123456789abcdef0));
+}
+`
+			compileAndRunRuntimeTest(t, llc, clang, "native_carrier_movd32", ir, mainC)
+		})
+	}
+}
diff --git a/arm64_byte_carrier_consumer_go127_test.go b/arm64_byte_carrier_consumer_go127_test.go
new file mode 100644
index 000000000..998b02dde
--- /dev/null
+++ b/arm64_byte_carrier_consumer_go127_test.go
@@ -0,0 +1,105 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64ByteCarrierConsumersStopAfterOwnerCancellation(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			bounded, release := runtimeOracleStageContext(t)
+			defer release()
+			lease, cancel := context.WithCancelCause(bounded)
+			defer cancel(context.Canceled)
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			cause := errors.New("actual original owner cancelled inside resolver")
+			calls := 0
+			resolve := testResolveSym(packagePath)
+			ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+				func(_ *File, options *Options, goOptions *GoModuleOptions) {
+					callback := func(symbol string) string {
+						calls++
+						if calls == 1 {
+							cancel(cause)
+						}
+						return resolve(symbol)
+					}
+					options.ResolveSym, goOptions.ResolveSym = callback, callback
+				})
+			if err == nil || !errors.Is(err, cause) || ir != "" {
+				t.Fatalf("cancelled original lease returned output or lost its cause: %v", err)
+			}
+			if calls != 1 {
+				t.Fatalf("consumer invoked user callbacks after the original owner was cancelled: %d", calls)
+			}
+			fresh, stop := runtimeOracleStageContext(t)
+			defer stop()
+			if !errors.Is(source.Verify(fresh), ErrProbeNeedsContext) {
+				t.Fatal("fresh later context renewed a revoked original owner")
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierRejectsCallerFrameChainAliases(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	filename := filepath.Join(directory, "original_arm64.s")
+	assembly, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The current source caller allocates 64 physical bytes. The previous
+	// caller's saved FP is still live at new SP+56, not writable local data.
+	// Go assembles this source, but successful encoding is not write authority.
+	assembly = []byte(strings.ReplaceAll(string(assembly), "MOVD R0,guard+24(FP)\n    RET",
+		"MOVD R0,guard+24(FP)\n    MOVD R0,56(RSP)\n    RET"))
+	if !strings.Contains(string(assembly), "56(RSP)") {
+		t.Fatal("actual alias control was not inserted")
+	}
+	if err := os.WriteFile(filename, assembly, 0600); err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatalf("actual compiler/ASM source witness was not captured: %v", err)
+			}
+			defer source.Close()
+			ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), "aarch64-unknown-linux-gnu", nil)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("native store to the previous caller's live FP cell was admitted: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_effects_go127_test.go b/arm64_byte_carrier_effects_go127_test.go
new file mode 100644
index 000000000..881024e2a
--- /dev/null
+++ b/arm64_byte_carrier_effects_go127_test.go
@@ -0,0 +1,131 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64ByteCarrierConsumersRejectUnclosedNativeEffects(t *testing.T) {
+	buildCache := t.TempDir()
+	for _, test := range []struct {
+		name   string
+		mutate func(string) string
+	}{
+		{"undefined-native-tail", func(source string) string {
+			return strings.ReplaceAll(source, "MOVD R1,16(RSP)", "MOVW R1,16(RSP)")
+		}},
+		{"undefined-outgoing-input", func(source string) string {
+			return strings.ReplaceAll(source, "MOVD R0,8(RSP)", "MOVD R0,R0")
+		}},
+		{"saved-LR-write", func(source string) string {
+			return strings.ReplaceAll(source, "MOVD R0,guard+24(FP)\n    RET", "MOVD R0,guard+24(FP)\n    MOVD R0,0(RSP)\n    RET")
+		}},
+		{"platform-register-write", func(source string) string {
+			return strings.ReplaceAll(source, "MOVD R0,guard+24(FP)\n    RET", "MOVD R0,guard+24(FP)\n    MOVD $0x123456789abcdef0,R18_PLATFORM\n    RET")
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			directory, packagePath, _ := arm64ByteCarrierFixture(t)
+			declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			filename := filepath.Join(directory, "original_arm64.s")
+			original, err := os.ReadFile(filename)
+			if err != nil {
+				t.Fatal(err)
+			}
+			assembly := test.mutate(string(original))
+			if assembly == string(original) {
+				t.Fatal("actual source effect control did not change its fixture")
+			}
+			if err := os.WriteFile(filename, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, packagePath, string(declarations))
+			request := arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					lease, release := runtimeOracleStageContext(t)
+					defer release()
+					source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+					if err != nil {
+						t.Fatalf("actual Go-accepted object/source was not observed: %v", err)
+					}
+					defer source.Close()
+					ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, assembly, "aarch64-unknown-linux-gnu", nil)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("unclosed native effect returned LLVM output: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierConsumerSnapshotsRemainWhole(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, kind := range []string{"file", "signature", "signature-inventory", "name", "target"} {
+		for _, api := range []string{"text", "module"} {
+			t.Run(kind+"/"+api, func(t *testing.T) {
+				lease, release := runtimeOracleStageContext(t)
+				defer release()
+				owner, err := CaptureGoARM64ByteCarrierSource(lease, request)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer owner.Close()
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, owner, pkg, string(assembly), "aarch64-unknown-linux-gnu",
+					func(file *File, options *Options, _ *GoModuleOptions) {
+						if kind == "target" {
+							options.TargetTriple = "aarch64-apple-darwin"
+							return
+						}
+						resolve := options.ResolveSym
+						mutated := false
+						options.ResolveSym = func(symbol string) string {
+							name := resolve(symbol)
+							if kind == "name" {
+								return packagePath + ".collision"
+							}
+							if !mutated {
+								mutated = true
+								switch kind {
+								case "file":
+									file.Funcs[0].Instrs[1].Args[1].Reg = "R1"
+								case "signature":
+									signature := options.Sigs[name]
+									signature.Ret = I64
+									options.Sigs[name] = signature
+								case "signature-inventory":
+									options.Sigs[packagePath+".foreign"] = FuncSig{Name: packagePath + ".foreign", Ret: I64}
+								}
+							}
+							return name
+						}
+					})
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("changed complete source/options returned LLVM output: %v", err)
+				}
+				if !errors.Is(owner.Verify(lease), ErrProbeNeedsContext) {
+					t.Fatal("failed whole-source join did not revoke the owner")
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_byte_carrier_emit.go b/arm64_byte_carrier_emit.go
new file mode 100644
index 000000000..68c4be276
--- /dev/null
+++ b/arm64_byte_carrier_emit.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ByteCarrierEmitter struct {
+	output *strings.Builder
+	next   int
+}
+
+func (emitter *arm64ByteCarrierEmitter) temporary() string {
+	emitter.next++
+	return fmt.Sprintf("%%carrier%d", emitter.next)
+}
+
+func (emitter *arm64ByteCarrierEmitter) pointer(root string, offset int64) string {
+	name := emitter.temporary()
+	fmt.Fprintf(emitter.output, "  %s = getelementptr inbounds i8, ptr %s, i64 %d\n", name, root, offset)
+	return name
+}
+
+func (emitter *arm64ByteCarrierEmitter) load(root string, offset, bytes int64, signed bool) string {
+	address, value := emitter.pointer(root, offset), emitter.temporary()
+	fmt.Fprintf(emitter.output, "  %s = load volatile i%d, ptr %s, align 1\n", value, bytes*8, address)
+	if bytes < 8 {
+		wide, operation := emitter.temporary(), "zext"
+		if signed {
+			operation = "sext"
+		}
+		fmt.Fprintf(emitter.output, "  %s = %s i%d %s to i64\n", wide, operation, bytes*8, value)
+		return wide
+	}
+	return value
+}
+
+func (emitter *arm64ByteCarrierEmitter) store(root string, offset, bytes int64, value string) {
+	address := emitter.pointer(root, offset)
+	if bytes < 8 {
+		narrow := emitter.temporary()
+		fmt.Fprintf(emitter.output, "  %s = trunc i64 %s to i%d\n", narrow, value, bytes*8)
+		value = narrow
+	}
+	fmt.Fprintf(emitter.output, "  store volatile i%d %s, ptr %s, align 1\n", bytes*8, value, address)
+}
+
+func (binding *arm64ByteCarrierBinding) emitIR() (string, error) {
+	var output strings.Builder
+	fmt.Fprintf(&output, "target triple = %q\n\n", binding.options.TargetTriple)
+	for _, source := range binding.file.Funcs {
+		if err := binding.source.liveCarrier(); err != nil {
+			return "", err
+		}
+		function := binding.functions[binding.symbols[source.Sym]]
+		if !function.proved {
+			return "", arm64ByteCarrierContext("missing complete native/defined-byte proof")
+		}
+		emitter := arm64ByteCarrierEmitter{output: &output}
+		fmt.Fprintf(&output, "define internal i64 %s(ptr %%incoming) {\nentry:\n", llvmGlobal(function.privateName))
+		if function.allocation != 0 {
+			fmt.Fprintf(&output, "  %%outgoing = alloca [%d x i8], align 1\n", function.allocation-16)
+		}
+		registers := map[Reg]string{ZR: "0"}
+		for _, operation := range function.operations {
+			if err := binding.source.liveCarrier(); err != nil {
+				return "", err
+			}
+			root := "%outgoing"
+			if operation.incoming {
+				root = "%incoming"
+			}
+			switch operation.kind {
+			case "constant":
+				if operation.register != ZR {
+					registers[operation.register] = fmt.Sprintf("%d", operation.constant)
+				}
+			case "move":
+				if operation.register != ZR {
+					registers[operation.register] = registers[operation.from]
+				}
+			case "load":
+				value := emitter.load(root, operation.offset, operation.bytes, operation.signed)
+				if operation.register != ZR {
+					registers[operation.register] = value
+				}
+			case "store":
+				emitter.store(root, operation.offset, operation.bytes, registers[operation.register])
+			case "call":
+				callee, value := binding.functions[operation.callee], emitter.temporary()
+				// This is the same existing outgoing root, not a return-field
+				// alloca or a fresh cell. The complete proof retains full R0.
+				fmt.Fprintf(&output, "  %s = call i64 %s(ptr %%outgoing)\n", value, llvmGlobal(callee.privateName))
+				registers["R0"] = value
+			case "return":
+				fmt.Fprintf(&output, "  ret i64 %s\n", registers["R0"])
+			}
+		}
+		output.WriteString("}\n\n")
+		if err := binding.emitTypedAdapter(&output, function); err != nil {
+			return "", err
+		}
+	}
+	return output.String(), nil
+}
+
+func (binding *arm64ByteCarrierBinding) emitTypedAdapter(output *strings.Builder, function *arm64ByteCarrierFunction) error {
+	if err := binding.source.liveCarrier(); err != nil {
+		return err
+	}
+	signature := function.signature
+	emitter := arm64ByteCarrierEmitter{output: output}
+	fmt.Fprintf(output, "define %s %s(", signature.Ret, llvmGlobal(signature.Name))
+	for index, argument := range signature.Args {
+		if index != 0 {
+			output.WriteString(", ")
+		}
+		fmt.Fprintf(output, "%s %%arg%d", argument, index)
+	}
+	output.WriteString(") {\nentry:\n")
+	// Actual complete compiler wrapper allocation, not rounded ArgWidth.
+	fmt.Fprintf(output, "  %%carrier = alloca [%d x i8], align 1\n", function.entry.dataBytes)
+	for _, parameter := range signature.Frame.Params {
+		address := emitter.pointer("%carrier", parameter.Offset)
+		fmt.Fprintf(output, "  store volatile %s %%arg%d, ptr %s, align 1\n", parameter.Type, parameter.Index, address)
+	}
+	fmt.Fprintf(output, "  %%post_r0 = call i64 %s(ptr %%carrier)\n", llvmGlobal(function.privateName))
+	_, aggregate := parseLiteralStructFields(signature.Ret)
+	result := "poison"
+	for _, field := range signature.Frame.Results {
+		value := emitter.load("%carrier", field.Offset, frameTypeSize(field.Type, 8), false)
+		if field.Type != I64 {
+			narrow := emitter.temporary()
+			fmt.Fprintf(output, "  %s = trunc i64 %s to %s\n", narrow, value, field.Type)
+			value = narrow
+		}
+		if aggregate {
+			inserted := emitter.temporary()
+			fmt.Fprintf(output, "  %s = insertvalue %s %s, %s %s, %d\n", inserted, signature.Ret, result, field.Type, value, field.Index)
+			result = inserted
+		} else {
+			result = value
+		}
+	}
+	fmt.Fprintf(output, "  ret %s %s\n}\n\n", signature.Ret, result)
+	return nil
+}
diff --git a/arm64_byte_carrier_entry.go b/arm64_byte_carrier_entry.go
new file mode 100644
index 000000000..5b127f563
--- /dev/null
+++ b/arm64_byte_carrier_entry.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This offline, private observation is not a live caller region or authority.
+// The consumer must independently bind its complete source, allocation,
+// continuation, initialized bytes and native effects before using a carrier.
+type arm64ByteCarrierEntryObservation struct {
+	allocation, dataStart, dataBytes int64
+	callPC, continuationPC           int64
+	parameterStores, resultLoads     []arm64ByteCarrierMemory
+}
+
+func arm64ByteCarrierTypedEntry(text gostaticstorage.TextRecord, declaration FuncSig) (arm64ByteCarrierEntryObservation, error) {
+	var observed arm64ByteCarrierEntryObservation
+	fail := func() (arm64ByteCarrierEntryObservation, error) {
+		return arm64ByteCarrierEntryObservation{}, arm64ByteCarrierContext("complete actual numeric compiler entry/effects differ")
+	}
+	if text.Name != declaration.Name || text.ABI != 1 || text.Size != int64(len(text.Code)) || len(text.Code)%4 != 0 ||
+		len(text.Code) < 36 || len(text.Relocations) != 1 || len(declaration.Args) < 1 || len(declaration.Args) > 2 ||
+		declaration.Args[0] != I64 || len(declaration.Frame.Params) != len(declaration.Args) ||
+		len(declaration.Frame.Results) == 0 || len(declaration.Frame.Results) > 8 {
+		return fail()
+	}
+	parameter := declaration.Frame.Params[0]
+	if parameter.Offset != 0 || parameter.Type != I64 || parameter.Index != 0 || len(frameSlotFields(parameter)) != 0 {
+		return fail()
+	}
+	parameterEnd := int64(8)
+	if len(declaration.Args) == 2 {
+		second := declaration.Frame.Params[1]
+		if declaration.Args[1] != I32 || second.Offset != 8 || second.Type != I32 || second.Index != 1 ||
+			len(frameSlotFields(second)) != 0 {
+			return fail()
+		}
+		parameterEnd = 12
+	}
+	fields, aggregate := parseLiteralStructFields(declaration.Ret)
+	if !aggregate {
+		fields = []LLVMType{declaration.Ret}
+	}
+	if len(fields) != len(declaration.Frame.Results) {
+		return fail()
+	}
+	word := func(pc int64) uint32 { return binary.LittleEndian.Uint32(text.Code[pc:]) }
+	// The entire observed wrapper is straight-line. The new saved LR at SP+0,
+	// saved FP below SP, and previous caller's live saved FP at SP+allocation-8
+	// are not data. Neither a SUB alone nor a rounded signature size can
+	// produce this observation.
+	first := word(0)
+	if first&^uint32(511<<12) != 0xf8000ffe || word(4) != 0xf81f83fd || word(8) != 0xd10023fd || word(12) != 0xf90007e0 {
+		return fail()
+	}
+	allocation := int64(first >> 12 & 511)
+	if allocation&256 != 0 {
+		allocation -= 512
+	}
+	allocation = -allocation
+	if allocation <= 8 || allocation > 240 || allocation%16 != 0 {
+		return fail()
+	}
+	pc := int64(16)
+	observed.parameterStores = []arm64ByteCarrierMemory{{PC: 12, Offset: 8, Bytes: 8, Instruction: word(12)}}
+	if len(declaration.Args) == 2 {
+		// The original compiler writes only W1 to the declared four-byte
+		// parameter. The following alignment gap is not an initialized field.
+		if len(text.Code) < 40 || word(pc) != 0xb90013e1 {
+			return fail()
+		}
+		observed.parameterStores = append(observed.parameterStores,
+			arm64ByteCarrierMemory{PC: pc, Offset: 16, Bytes: 4, Instruction: word(pc)})
+		pc += 4
+	}
+	call := text.Relocations[0]
+	if call.Offset != pc || call.Size != 4 || call.Type != 9 || call.Add != 0 || call.Target.Name != text.Name ||
+		!call.Target.ABIKnown || call.Target.ABI != 0 || word(pc) != 0x94000000 {
+		return fail()
+	}
+	observed.allocation, observed.dataStart, observed.dataBytes = allocation, 8, allocation-16
+	observed.callPC, observed.continuationPC = pc, pc+4
+	pc += 4
+	previousEnd := parameterEnd
+	for index := 0; index < len(fields); {
+		field := declaration.Frame.Results[index]
+		if field.Index != index || field.Type != fields[index] || len(frameSlotFields(field)) != 0 ||
+			field.Type != I8 && field.Type != I16 && field.Type != I32 && field.Type != I64 ||
+			field.Offset < previousEnd || field.Offset+8+frameTypeSize(field.Type, 8) > allocation-8 || pc+16 > int64(len(text.Code)) {
+			return fail()
+		}
+		instruction := word(pc)
+		width := frameTypeSize(field.Type, 8)
+		if instruction&0xffc003e0 == 0xa94003e0 {
+			// Integer LDP is one complete instruction with two typed read effects.
+			if index+1 >= len(fields) || field.Type != I64 || fields[index+1] != I64 ||
+				declaration.Frame.Results[index+1].Type != I64 || declaration.Frame.Results[index+1].Index != index+1 ||
+				declaration.Frame.Results[index+1].Offset != field.Offset+8 ||
+				len(frameSlotFields(declaration.Frame.Results[index+1])) != 0 || instruction&31 != uint32(index) ||
+				instruction>>10&31 != uint32(index+1) || field.Offset+24 > allocation-8 {
+				return fail()
+			}
+			offset := int64(instruction >> 15 & 127)
+			if offset&64 != 0 {
+				offset -= 128
+			}
+			if offset*8 != field.Offset+8 {
+				return fail()
+			}
+			observed.resultLoads = append(observed.resultLoads,
+				arm64ByteCarrierMemory{PC: pc, Offset: field.Offset + 8, Bytes: 8, Instruction: instruction},
+				arm64ByteCarrierMemory{PC: pc, Offset: field.Offset + 16, Bytes: 8, Instruction: instruction})
+			previousEnd = field.Offset + 16
+			index += 2
+		} else {
+			// Actual gc wrappers use LDRSB/LDRSH/LDRSW into X registers for
+			// signed narrow Go results, and unsigned LDR for unsigned ones.
+			// Both read exactly the declared bytes. The typed adapter returns
+			// that same narrow bit pattern; it never narrows the source body
+			// store or an assembly caller's shared-carrier observation.
+			load := instruction & 0x3fc003e0
+			if load != 0x394003e0 && (load != 0x398003e0 || width == 8) || instruction&31 != uint32(index) ||
+				int64(1)<<(instruction>>30) != width || int64(instruction>>10&4095)*width != field.Offset+8 {
+				return fail()
+			}
+			observed.resultLoads = append(observed.resultLoads, arm64ByteCarrierMemory{
+				PC: pc, Offset: field.Offset + 8, Bytes: width, Instruction: instruction,
+			})
+			previousEnd = field.Offset + width
+			index++
+		}
+		pc += 4
+	}
+	if word(pc) != 0xf85f83fd || word(pc+4) != 0xf84007fe|uint32(allocation)<<12 || word(pc+8) != 0xd65f03c0 {
+		return fail()
+	}
+	for pc += 12; pc < int64(len(text.Code)); pc += 4 {
+		if word(pc) != 0 {
+			return fail()
+		}
+	}
+	return observed, nil
+}
diff --git a/arm64_byte_carrier_entry_go127_test.go b/arm64_byte_carrier_entry_go127_test.go
new file mode 100644
index 000000000..f32974ba8
--- /dev/null
+++ b/arm64_byte_carrier_entry_go127_test.go
@@ -0,0 +1,140 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestARM64ByteCarrierActualTypedEntryFootprint(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoARM64ByteCarrierSource(ctx, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	entries := make(map[string]gostaticstorage.TextRecord)
+	for _, text := range source.report.Archive[1].Texts {
+		if text.ABI == 1 {
+			entries[text.Name] = text
+		}
+	}
+	for _, width := range cases {
+		for _, observer := range []bool{false, true} {
+			name := strings.ToLower(width.name())
+			allocation := int64(32)
+			if observer {
+				name = "observe_" + name
+				allocation = 48
+			}
+			t.Run(name, func(t *testing.T) {
+				declaration := source.declarations[name]
+				text := entries[packagePath+"."+name]
+				if text.Name == "" {
+					t.Fatal("complete actual compiler entry is missing")
+				}
+				observed, err := arm64ByteCarrierTypedEntry(text, declaration)
+				if err != nil {
+					t.Fatalf("actual compiler entry footprint/effects are not closed: %v", err)
+				}
+				if observed.allocation != allocation || observed.dataStart != 8 || observed.dataBytes != allocation-16 ||
+					observed.callPC != 16 || observed.continuationPC != 20 || len(observed.parameterStores) != 1 ||
+					observed.parameterStores[0].Offset != 8 || observed.parameterStores[0].Bytes != 8 ||
+					len(observed.resultLoads) != len(declaration.Frame.Results) {
+					t.Fatalf("actual entry region/continuation/typed effects differ: %+v", observed)
+				}
+				for index, memory := range observed.resultLoads {
+					field := declaration.Frame.Results[index]
+					if memory.Offset != field.Offset+8 || memory.Bytes != frameTypeSize(field.Type, 8) {
+						t.Fatalf("typed entry loaded bytes outside its declared result: %+v", memory)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ByteCarrierTypedEntryRejectsIncompleteEffects(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoARM64ByteCarrierSource(ctx, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	name := strings.ToLower(cases[0].name())
+	var original gostaticstorage.TextRecord
+	for _, text := range source.report.Archive[1].Texts {
+		if text.Name == packagePath+"."+name && text.ABI == 1 {
+			original = text
+		}
+	}
+	if original.Name == "" || len(original.Code) < 36 || len(original.Relocations) != 1 {
+		t.Fatal("actual original entry control is missing")
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func(*gostaticstorage.TextRecord, *FuncSig)
+	}{
+		{"foreign-entry", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Name += ".foreign" }},
+		{"wrong-ABI", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.ABI = 0 }},
+		{"no-allocation", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code, 0xd503201f)
+		}},
+		{"no-FP-save", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[4:], 0xd503201f)
+		}},
+		{"no-FP-binding", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[8:], 0xd503201f)
+		}},
+		{"wrong-param-cell", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[12:], 0xf9000be0)
+		}},
+		{"missing-direct-call", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[16:], 0xd503201f)
+		}},
+		{"wrong-call-target", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Target.Name += ".foreign" }},
+		{"wrong-call-ABI", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Target.ABI = 1 }},
+		{"unknown-call-ABI", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Target.ABIKnown = false }},
+		{"call-addend", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Add = 4 }},
+		{"call-continuation", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Offset += 4 }},
+		{"result-outside-region", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[20:], 0x394083e0)
+		}},
+		{"lost-FP-restore", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[24:], 0xd503201f)
+		}},
+		{"wrong-SP-restore", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[28:], 0xf84107fe)
+		}},
+		{"no-return", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[32:], 0xd503201f)
+		}},
+		{"executable-tail", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[len(text.Code)-4:], 0xd503201f)
+		}},
+		{"overlapping-param", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Params[0].Offset = 8 }},
+		{"padding-as-result", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Results[0].Type = I64 }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			text := original
+			text.Code = append([]byte(nil), original.Code...)
+			text.Relocations = append([]gostaticstorage.TextRelocation(nil), original.Relocations...)
+			declaration := source.declarations[name]
+			declaration.Frame.Params = append([]FrameSlot(nil), declaration.Frame.Params...)
+			declaration.Frame.Results = append([]FrameSlot(nil), declaration.Frame.Results...)
+			test.mutate(&text, &declaration)
+			if _, err := arm64ByteCarrierTypedEntry(text, declaration); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("incomplete/cross-role entry granted a region: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_family_darwin_arm64_test.go b/arm64_byte_carrier_family_darwin_arm64_test.go
new file mode 100644
index 000000000..2c0ded65b
--- /dev/null
+++ b/arm64_byte_carrier_family_darwin_arm64_test.go
@@ -0,0 +1,13 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestARM64ByteCarrierNativeResultFamily(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	arm64ByteCarrierRuntimeFamily(t, "darwin", "aarch64-apple-darwin", llc, []string{clang}, nil)
+}
diff --git a/arm64_byte_carrier_family_linux_test.go b/arm64_byte_carrier_family_linux_test.go
new file mode 100644
index 000000000..284062f2b
--- /dev/null
+++ b/arm64_byte_carrier_family_linux_test.go
@@ -0,0 +1,10 @@
+//go:build go1.27 && (arm64 || amd64)
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixARM64ByteCarrierNativeResults(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	arm64ByteCarrierRuntimeFamily(t, "linux", triple, llc, compiler, runner)
+}
diff --git a/arm64_byte_carrier_go_binding.go b/arm64_byte_carrier_go_binding.go
new file mode 100644
index 000000000..b83689133
--- /dev/null
+++ b/arm64_byte_carrier_go_binding.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"sort"
+)
+
+func arm64ByteCarrierSyntax(file *ast.File) (string, error) {
+	if file == nil || file.Name == nil {
+		return "", arm64ByteCarrierContext("incomplete Go syntax")
+	}
+	var output bytes.Buffer
+	err := ast.Fprint(&output, nil, file, func(name string, value reflect.Value) bool {
+		// Source positions and parser object cycles are not semantics. Retain
+		// all declarations, bodies, comments, directives and identifier text.
+		return value.Type() != reflect.TypeOf(token.Pos(0)) && name != "Obj" && name != "Scope" && name != "Unresolved"
+	})
+	return output.String(), err
+}
+
+func arm64ByteCarrierGoView(source *GoARM64ByteCarrierSource, pkg GoPackage) ([]string, error) {
+	if pkg.Types == nil || pkg.Path != source.request.PackagePath || pkg.Types.Path() != pkg.Path ||
+		pkg.Types.Name() != source.guard.selection.Name || len(pkg.Syntax) != len(source.guard.selection.GoFiles) ||
+		len(pkg.Imports) != 0 || len(pkg.Types.Imports()) != 0 || pkg.SourceSelection != nil ||
+		len(pkg.Types.Scope().Names()) != len(source.report.Declarations) {
+		return nil, arm64ByteCarrierContext("complete typed Go owner/source inventory differs")
+	}
+	var expected, actual []string
+	for _, name := range source.guard.selection.GoFiles {
+		parsed, err := parser.ParseFile(token.NewFileSet(), name, source.report.Sources[name], parser.ParseComments)
+		if err != nil {
+			return nil, arm64ByteCarrierContext("original Go syntax changed: %v", err)
+		}
+		text, err := arm64ByteCarrierSyntax(parsed)
+		if err != nil {
+			return nil, err
+		}
+		expected = append(expected, text)
+	}
+	for _, file := range pkg.Syntax {
+		text, err := arm64ByteCarrierSyntax(file)
+		if err != nil {
+			return nil, err
+		}
+		actual = append(actual, text)
+	}
+	sort.Strings(expected)
+	sort.Strings(actual)
+	if !reflect.DeepEqual(expected, actual) {
+		return nil, arm64ByteCarrierContext("whole original Go syntax differs from the consumer package")
+	}
+	for _, name := range pkg.Types.Scope().Names() {
+		function, valid := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !valid || function.Pkg() != pkg.Types || function.Parent() != pkg.Types.Scope() ||
+			types.TypeString(function.Type(), nil) != source.report.Declarations[name] {
+			return nil, arm64ByteCarrierContext("whole original Go declaration semantics differ")
+		}
+	}
+	return actual, nil
+}
+
+func arm64ByteCarrierGoResult(source *GoARM64ByteCarrierSource, result *GoModuleTranslation) error {
+	if result == nil || result.Module.IsNil() || len(result.Functions) != len(source.file.Funcs) ||
+		len(result.Signatures) != len(source.declarations) {
+		return arm64ByteCarrierContext("complete Go/LLVM function metadata is missing")
+	}
+	for ordinal, original := range source.file.Funcs {
+		name := source.request.PackagePath + "." + original.Sym[len("·"):]
+		function := result.Functions[ordinal]
+		actual, present := result.Signatures[name]
+		expected := source.declarations[original.Sym[len("·"):]]
+		if function.TextSymbol != original.Sym || function.ResolvedSymbol != name || result.Module.NamedFunction(name).IsNil() ||
+			!present || !bytes.Equal(arm64ScratchPublicSignature(actual), arm64ScratchPublicSignature(expected)) {
+			return arm64ByteCarrierContext("Go metadata/LLVM name/signature does not match the frozen actual entry")
+		}
+	}
+	return nil
+}
+
+func finishARM64ByteCarrierGoSource(source *GoARM64ByteCarrierSource, pkg GoPackage, prior []string, result *GoModuleTranslation) error {
+	current, err := arm64ByteCarrierGoView(source, pkg)
+	if err == nil && !reflect.DeepEqual(prior, current) {
+		err = arm64ByteCarrierContext("Go package changed during binding/lowering callbacks")
+	}
+	if result != nil {
+		err = errors.Join(err, arm64ByteCarrierGoResult(source, result))
+	}
+	return errors.Join(err, source.Verify(source.lease))
+}
diff --git a/arm64_byte_carrier_native_proof.go b/arm64_byte_carrier_native_proof.go
new file mode 100644
index 000000000..9629a85e8
--- /dev/null
+++ b/arm64_byte_carrier_native_proof.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"strconv"
+	"strings"
+)
+
+type arm64ByteCarrierOperation struct {
+	kind          string
+	register      Reg
+	from          Reg
+	incoming      bool
+	offset, bytes int64
+	signed        bool
+	constant      uint64
+	callee        string
+}
+
+type arm64ByteCarrierFunction struct {
+	source      Func
+	signature   FuncSig
+	privateName string
+	entry       arm64ByteCarrierEntryObservation
+	allocation  int64
+	operations  []arm64ByteCarrierOperation
+	reads       map[int64]bool
+	writes      map[int64]bool
+	registers   map[Reg]bool
+	proved      bool
+}
+
+func arm64ByteCarrierRegister(register Reg) (uint32, bool) {
+	if register == ZR {
+		return 31, true
+	}
+	if !strings.HasPrefix(string(register), "R") {
+		return 0, false
+	}
+	number, err := strconv.Atoi(strings.TrimPrefix(string(register), "R"))
+	// R18_PLATFORM, R28/g, FP, LR and SP require independent machine-state
+	// roles. An immediate overwrite does not make platform state disposable.
+	return uint32(number), err == nil && number >= 0 && number <= 27 && number != 18
+}
+
+func (binding *arm64ByteCarrierBinding) prepareNative() error {
+	for ordinal, function := range binding.file.Funcs {
+		if err := binding.source.liveCarrier(); err != nil {
+			return err
+		}
+		name := binding.symbols[function.Sym]
+		plan := binding.functions[name]
+		if binding.functions[plan.privateName] != nil {
+			return arm64ByteCarrierContext("generated private body collides with a source entry")
+		}
+		found := false
+		for _, text := range binding.source.report.Archive[1].Texts {
+			if text.Name == name && text.ABI == 1 {
+				entry, err := arm64ByteCarrierTypedEntry(text, plan.signature)
+				if err != nil || found {
+					return arm64ByteCarrierContext("actual complete typed compiler entry differs: %v", err)
+				}
+				plan.entry, found = entry, true
+			}
+		}
+		if !found {
+			return arm64ByteCarrierContext("actual compiler entry is missing")
+		}
+		if err := binding.prepareNativeFunction(plan, ordinal); err != nil {
+			return err
+		}
+	}
+	for _, function := range binding.file.Funcs {
+		if err := binding.proveDefinedBytes(binding.functions[binding.symbols[function.Sym]], make(map[string]bool)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (binding *arm64ByteCarrierBinding) prepareNativeFunction(plan *arm64ByteCarrierFunction, ordinal int) error {
+	text := binding.source.report.Standalone[ordinal]
+	if text.Name != plan.signature.Name || text.ABI != 0 || text.Size != int64(len(text.Code)) || len(text.Code)%4 != 0 || len(text.Code) > 65536 {
+		return arm64ByteCarrierContext("complete native body identity/extent differs")
+	}
+	pc := int64(0)
+	word := func() (uint32, bool) {
+		if pc < 0 || pc+4 > int64(len(text.Code)) {
+			return 0, false
+		}
+		return binary.LittleEndian.Uint32(text.Code[pc:]), true
+	}
+	consume := func(expected uint32) bool {
+		actual, exists := word()
+		if !exists || actual != expected {
+			return false
+		}
+		pc += 4
+		return true
+	}
+	frame := arm64SourceGoFrame(plan.source)
+	if frame.present {
+		first, exists := word()
+		if !exists || first&^uint32(511<<12) != 0xf8000ffe {
+			return arm64ByteCarrierContext("original implicit frame allocation is not closed")
+		}
+		immediate := int64(first >> 12 & 511)
+		if immediate&256 != 0 {
+			immediate -= 512
+		}
+		plan.allocation = -immediate
+		if plan.allocation <= 8 || plan.allocation > 240 || plan.allocation%16 != 0 ||
+			!arm64SourceFrameFlagsKnown(plan.source) || plan.allocation != arm64SourceFrameAutosize(plan.source.FrameSize) ||
+			!consume(first) || !consume(0xf81f83fd) || !consume(0xd10023fd) {
+			return arm64ByteCarrierContext("complete original frame/SP/FP producer differs")
+		}
+	}
+	normalized, err := normalizeARM64ScalarMemoryFrame(plan.source)
+	if err != nil {
+		return err
+	}
+	returned, calls := false, 0
+	for index, instruction := range normalized.Instrs {
+		if err := binding.source.liveCarrier(); err != nil {
+			return err
+		}
+		if instruction.Op == OpTEXT && index == 0 {
+			continue
+		}
+		if returned {
+			return arm64ByteCarrierContext("source continues after its sole native return")
+		}
+		if instruction.Op == "RET" && len(instruction.Args) == 0 {
+			if frame.present && (!consume(0xf85f83fd) || !consume(0xf84007fe|uint32(plan.allocation)<<12)) || !consume(0xd65f03c0) {
+				return arm64ByteCarrierContext("complete native frame/link/continuation restore differs")
+			}
+			plan.operations = append(plan.operations, arm64ByteCarrierOperation{kind: "return"})
+			returned = true
+			continue
+		}
+		if instruction.Op == "CALL" && len(instruction.Args) == 1 {
+			base, offset, valid := parseSBRef(instruction.Args[0].Sym)
+			callee := binding.symbols[base]
+			matched := false
+			for _, call := range binding.source.report.Calls {
+				matched = matched || call.Caller == text.Name && call.Callee == callee && call.SourceInstruction == index &&
+					call.CallPC == pc && call.ContinuationPC == pc+4
+			}
+			if instruction.Args[0].Kind != OpSym || !valid || offset != 0 || callee == "" || !matched || !consume(0x94000000) {
+				return arm64ByteCarrierContext("exact source/native direct-call continuation differs")
+			}
+			plan.operations = append(plan.operations, arm64ByteCarrierOperation{kind: "call", callee: callee})
+			calls++
+			continue
+		}
+		form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(instruction), instruction)
+		if err != nil {
+			return err
+		}
+		if handled {
+			register, valid := arm64ByteCarrierRegister(form.data)
+			incoming := form.memory.Kind == OpFP
+			offset := form.memory.Mem.Off
+			if incoming {
+				offset = form.memory.FPOffset
+			}
+			physical := offset
+			if incoming {
+				physical += plan.allocation + 8
+			}
+			width := int64(form.bits / 8)
+			if !valid || form.pre || form.post || form.scratch || width == 0 ||
+				!incoming && (form.memory.Kind != OpMem || form.memory.Mem.Base != SP || form.memory.Mem.Index != "" || form.memory.Mem.Sym != "") ||
+				physical < 0 || physical%width != 0 || physical/width > 4095 {
+				return arm64ByteCarrierContext("source memory needs an independent address/effect role")
+			}
+			shift := uint32(0)
+			for int64(1)<<shift < width {
+				shift++
+			}
+			expected, kind := uint32(0x390003e0), "store"
+			if !form.store {
+				expected, kind = 0x394003e0, "load"
+				if form.signed {
+					expected = 0x398003e0
+				}
+			}
+			expected |= shift<<30 | uint32(physical/width)<<10 | register
+			if !consume(expected) {
+				return arm64ByteCarrierContext("whole source/normalized/native memory width/offset/register differs")
+			}
+			if !incoming {
+				offset -= 8 // exact fresh outgoing data root, never saved FP/LR
+			}
+			plan.operations = append(plan.operations, arm64ByteCarrierOperation{kind: kind, register: form.data,
+				incoming: incoming, offset: offset, bytes: width, signed: form.signed})
+			continue
+		}
+		if instruction.Op != "MOVD" || len(instruction.Args) != 2 || instruction.Args[1].Kind != OpReg {
+			return arm64ByteCarrierContext("source is outside the closed scalar move/call grammar")
+		}
+		register, valid := arm64ByteCarrierRegister(instruction.Args[1].Reg)
+		if !valid {
+			return arm64ByteCarrierContext("source consumes a hidden machine-state register")
+		}
+		if input := instruction.Args[0]; input.Kind == OpImm && input.ImmRaw == "" && !input.ImmIsFloat {
+			value, first := uint64(0), true
+			for count := 0; count < 4; count++ {
+				actual, exists := word()
+				if !exists || actual&31 != register {
+					break
+				}
+				encoding := actual & 0xff800000
+				bits, position := uint64(actual>>5&65535), uint(actual>>21&3)*16
+				if first && (encoding == 0xd2800000 || encoding == 0x92800000) {
+					value = bits << position
+					if encoding == 0x92800000 {
+						value = ^value
+					}
+				} else if !first && encoding == 0xf2800000 {
+					value = value&^(uint64(65535)<<position) | bits<<position
+				} else {
+					break
+				}
+				pc += 4
+				first = false
+			}
+			if first || value != uint64(input.Imm) {
+				return arm64ByteCarrierContext("complete original constant materialization differs")
+			}
+			plan.operations = append(plan.operations, arm64ByteCarrierOperation{kind: "constant", register: instruction.Args[1].Reg, constant: value})
+		} else if input.Kind == OpReg {
+			from, valid := arm64ByteCarrierRegister(input.Reg)
+			if !valid || !consume(0xaa0003e0|from<<16|register) {
+				return arm64ByteCarrierContext("complete source/native register move differs")
+			}
+			plan.operations = append(plan.operations, arm64ByteCarrierOperation{kind: "move", register: instruction.Args[1].Reg, from: input.Reg})
+		} else {
+			return arm64ByteCarrierContext("nonliteral/address materialization needs a separate source role")
+		}
+	}
+	if !returned || calls != len(text.Relocations) {
+		return arm64ByteCarrierContext("native source/control inventory is incomplete")
+	}
+	for pc < int64(len(text.Code)) {
+		if !consume(0) {
+			return arm64ByteCarrierContext("native body has an executable unconsumed tail")
+		}
+	}
+	return nil
+}
+
+func (binding *arm64ByteCarrierBinding) proveDefinedBytes(plan *arm64ByteCarrierFunction, active map[string]bool) error {
+	if plan.proved {
+		return nil
+	}
+	if active[plan.signature.Name] {
+		return arm64ByteCarrierContext("recursive source needs an independent native call-state proof")
+	}
+	active[plan.signature.Name] = true
+	defer delete(active, plan.signature.Name)
+	plan.reads, plan.writes, plan.registers = make(map[int64]bool), make(map[int64]bool), make(map[Reg]bool)
+	incoming, local, registers := make(map[int64]bool), make(map[int64]bool), map[Reg]bool{ZR: true}
+	for _, parameter := range plan.signature.Frame.Params {
+		for byte := parameter.Offset; byte < parameter.Offset+frameTypeSize(parameter.Type, 8); byte++ {
+			incoming[byte] = true
+		}
+	}
+	for _, operation := range plan.operations {
+		if err := binding.source.liveCarrier(); err != nil {
+			return err
+		}
+		switch operation.kind {
+		case "constant", "move":
+			if operation.kind == "move" && !registers[operation.from] {
+				return arm64ByteCarrierContext("source reads an undefined entry register")
+			}
+			registers[operation.register], plan.registers[operation.register] = true, true
+		case "load", "store":
+			// The original caller's saved FP occupies the frame top even
+			// though this function also saves its own FP below the new SP.
+			defined, capacity := local, plan.allocation-16
+			if operation.incoming {
+				defined, capacity = incoming, plan.entry.dataBytes
+			}
+			if operation.offset < 0 || operation.bytes <= 0 || operation.offset+operation.bytes > capacity {
+				return arm64ByteCarrierContext("native bytes exceed the actual caller-owned data region")
+			}
+			if operation.kind == "store" && !registers[operation.register] {
+				return arm64ByteCarrierContext("native store consumes undefined register bits")
+			}
+			for byte := operation.offset; byte < operation.offset+operation.bytes; byte++ {
+				if operation.kind == "load" {
+					if !defined[byte] {
+						return arm64ByteCarrierContext("native load observes an undefined byte")
+					}
+					if operation.incoming {
+						plan.reads[byte] = true
+					}
+				} else {
+					defined[byte] = true
+					if operation.incoming {
+						plan.writes[byte] = true
+					}
+				}
+			}
+			if operation.kind == "load" {
+				registers[operation.register], plan.registers[operation.register] = true, true
+			}
+		case "call":
+			callee := binding.functions[operation.callee]
+			if callee == nil || callee.allocation != 0 {
+				return arm64ByteCarrierContext("call has no complete native leaf state/effect proof")
+			}
+			if err := binding.proveDefinedBytes(callee, active); err != nil {
+				return err
+			}
+			for register := range callee.registers {
+				if register != "R0" {
+					return arm64ByteCarrierContext("call requires more than its closed R0 poststate carrier")
+				}
+			}
+			for byte := range callee.reads {
+				if byte < 0 || byte >= plan.allocation-16 || !local[byte] {
+					return arm64ByteCarrierContext("call did not initialize the exact incoming native bytes")
+				}
+			}
+			for byte := range callee.writes {
+				if byte < 0 || byte >= plan.allocation-16 {
+					return arm64ByteCarrierContext("callee native write aliases protected/outside caller storage")
+				}
+				local[byte] = true
+			}
+			registers["R0"], plan.registers["R0"] = true, true
+		case "return":
+			if !registers["R0"] {
+				return arm64ByteCarrierContext("return R0 poststate is not defined")
+			}
+			for _, field := range plan.signature.Frame.Results {
+				for byte := field.Offset; byte < field.Offset+frameTypeSize(field.Type, 8); byte++ {
+					if !incoming[byte] {
+						return arm64ByteCarrierContext("typed return observes an undefined result byte")
+					}
+				}
+			}
+		default:
+			return arm64ByteCarrierContext("source operation is outside the closed effect grammar")
+		}
+	}
+	plan.proved = true
+	return nil
+}
diff --git a/arm64_byte_carrier_objects_go127_test.go b/arm64_byte_carrier_objects_go127_test.go
new file mode 100644
index 000000000..3cbae499c
--- /dev/null
+++ b/arm64_byte_carrier_objects_go127_test.go
@@ -0,0 +1,71 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64ByteCarrierActualFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	directory, packagePath, widths := arm64ByteCarrierFixture(t)
+	widths = arm64ByteCarrierExactWidthControl(t, directory, widths)
+	if len(widths) != 10 {
+		t.Fatal("complete nine wider stores and exact MOVW control are required")
+	}
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	base := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, target := range []struct{ goos, triple string }{
+		{"darwin", "aarch64-apple-darwin"},
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"windows", "aarch64-pc-windows-msvc"},
+		{"freebsd", "aarch64-unknown-freebsd"},
+		{"openbsd", "aarch64-unknown-openbsd"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			request := base
+			request.Target = target.goos + "/arm64"
+			request.Environment = append([]string(nil), base.Environment...)
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + target.goos
+				}
+			}
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), target.triple,
+						func(_ *File, _ *Options, options *GoModuleOptions) {
+							// Keeping the whole graph is allowed; filtering it is
+							// independently rejected by the source-bound controls.
+							options.KeepFunc = func(_, _ string) bool { return true }
+						})
+					if err != nil || ir == "" {
+						t.Fatalf("complete original target could not translate: %v", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "carrier.ll", "carrier.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_position_test.go b/arm64_byte_carrier_position_test.go
new file mode 100644
index 000000000..456fd7896
--- /dev/null
+++ b/arm64_byte_carrier_position_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"errors"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestARM64ByteCarrierCallPositionSpelling(t *testing.T) {
+	directory := t.TempDir()
+	const filename = "original_arm64.s"
+	const raw = "CALL ·callee(SB)"
+	source := &GoARM64ByteCarrierSource{
+		request: GoARM64ByteCarrierCaptureRequest{
+			Directory: directory, AssemblyFile: filename,
+		},
+		report: arm64ByteCarrierReport{
+			Sources: map[string][]byte{
+				filename: []byte("TEXT ·caller(SB),$0-0\n\t" + raw + "\nRET\n"),
+			},
+		},
+	}
+	path := filepath.Join(directory, filename)
+	position := gostaticstorage.TextPosition{Start: 4, End: 8, File: path, Line: 2}
+	tests := []struct {
+		name     string
+		position gostaticstorage.TextPosition
+		pc       int64
+		raw      string
+		valid    bool
+	}{
+		{"native", position, 4, raw, true},
+		{"object-slashes", position, 4, raw, true},
+		{"foreign-file", position, 4, raw, false},
+		{"relative-file", position, 4, raw, false},
+		{"unbound-sdk-file", position, 4, raw, false},
+		{"dot-alias", position, 4, raw, false},
+		{"repeated-slash", position, 4, raw, false},
+		{"different-line", position, 4, raw, false},
+		{"missing-line", position, 4, raw, false},
+		{"past-source", position, 4, raw, false},
+		{"pc-before", position, 0, raw, false},
+		{"pc-after", position, 8, raw, false},
+		{"partial-instruction", position, 4, raw, false},
+		{"different-source", position, 4, "CALL ·other(SB)", false},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			switch test.name {
+			case "object-slashes":
+				test.position.File = filepath.ToSlash(path)
+			case "foreign-file":
+				test.position.File = filepath.Join(directory, "other_arm64.s")
+			case "relative-file":
+				test.position.File = filename
+			case "unbound-sdk-file":
+				test.position.File = "$GOROOT/" + filename
+			case "dot-alias":
+				test.position.File = filepath.ToSlash(directory) + "/./" + filename
+			case "repeated-slash":
+				test.position.File = filepath.ToSlash(directory) + "//" + filename
+			case "different-line":
+				test.position.Line = 1
+			case "missing-line":
+				test.position.Line = 0
+			case "past-source":
+				test.position.Line = 5
+			case "partial-instruction":
+				test.position.End = 7
+			}
+			text := gostaticstorage.TextRecord{
+				Positions: []gostaticstorage.TextPosition{test.position},
+			}
+			actual, err := source.callPosition(text, test.pc, test.raw)
+			if test.valid {
+				if err != nil || actual != test.position {
+					t.Fatalf("actual position must remain unchanged: got %+v, %v", actual, err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound source/line/PC accepted: got %+v, %v", actual, err)
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_runtime_go127_test.go b/arm64_byte_carrier_runtime_go127_test.go
new file mode 100644
index 000000000..482d82429
--- /dev/null
+++ b/arm64_byte_carrier_runtime_go127_test.go
@@ -0,0 +1,197 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ByteCarrierExactWidthControl(t *testing.T, directory string, widths []arm64NativeResultTailCase) []arm64NativeResultTailCase {
+	t.Helper()
+	control := arm64NativeResultTailCase{op: "MOVW", resultBits: 32, storeBits: 32}
+	controlName := strings.ToLower(control.name())
+	for name, extra := range map[string]string{
+		"decl.go": strings.ReplaceAll(control.declaration(), control.name(), controlName) +
+			"func observe_" + controlName + "(input uint64) (value,native,guard uint64)\n",
+		"original_arm64.s": strings.ReplaceAll(control.source()+arm64NativeResultTailObserver(control), control.name(), controlName),
+	} {
+		filename := filepath.Join(directory, name)
+		original, err := os.ReadFile(filename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filename, append(original, []byte(extra)...), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return append(widths, control)
+}
+
+func arm64ByteCarrierRuntimeFamily(t *testing.T, goos, triple, llc string, compiler, runner []string) {
+	t.Helper()
+	directory, packagePath, widths := arm64ByteCarrierFixture(t)
+	widths = arm64ByteCarrierExactWidthControl(t, directory, widths)
+	goSource, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs := arm64PaddingRuntimeInputs()
+	var original strings.Builder
+	original.WriteString("package carrierfixture\nimport \"testing\"\nfunc TestOriginalCarrierFamily(t *testing.T) {\n")
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		for _, input := range inputs {
+			resultMask := ^uint64(0) >> uint(64-width.resultBits)
+			storeMask := ^uint64(0) >> uint(64-width.storeBits)
+			fmt.Fprintf(&original, `{ value,native,guard := observe_%s(0x%x)
+if value != 0x%x || native != 0x%x || guard != 0x7ac35ef012345678 { t.Fatal("%s native/canary mismatch") } }
+`, name, input, input&resultMask, uint64(0xfeedfacecafebeef)&^storeMask|input&storeMask, name)
+		}
+	}
+	marker := fmt.Sprintf("ACTUAL_BYTE_CARRIER_FAMILY %d", len(widths)*len(inputs))
+	fmt.Fprintf(&original, "t.Log(%q)\n}\n", marker)
+	if err := os.WriteFile(filepath.Join(directory, "original_test.go"), []byte(original.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	request.Target = goos + "/arm64"
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOOS=") {
+			request.Environment[index] = "GOOS=" + goos
+		}
+	}
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	arguments := []string{"test", "-p=1", "-mod=readonly", "-run=^TestOriginalCarrierFamily$", "-count=1", "-v"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(arguments, "-exec="+quoted)
+	}
+	command := exec.CommandContext(lease, request.GoBinary, append(arguments, ".")...)
+	command.Dir, command.Env = directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(lease, command)
+	if err != nil || strings.Count(string(output), marker) != 1 || !strings.Contains(string(output), "--- PASS: TestOriginalCarrierFamily") {
+		t.Fatalf("unchanged original whole-family native bytes/canary: %v\n%s", err, output)
+	}
+	t.Logf("actual original Go %s observations: %d", request.Target, len(widths)*len(inputs))
+	source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	pkg := mustGoPackage(t, packagePath, string(goSource))
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, optimization := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", api, optimization), func(t *testing.T) {
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), triple, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, "store volatile i64") || !strings.Contains(ir, "store volatile i16") ||
+					!strings.Contains(ir, "store volatile i32") || !strings.Contains(ir, "align 1") {
+					t.Fatal("native memory widths and exact alignment were not retained")
+				}
+				checks, driver := arm64ByteCarrierRuntimeChecks(packagePath, widths, inputs)
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "byte_carrier_family", triple, ir+checks, driver, runner, optimization)
+				t.Logf("actual LLVM22 %s O%d observations: %d", api, optimization, len(widths)*len(inputs))
+			})
+		}
+	}
+}
+
+func arm64ByteCarrierTranslateAPI(t *testing.T, api string, source *GoARM64ByteCarrierSource, pkg GoPackage, assembly, triple string, mutate func(*File, *Options, *GoModuleOptions)) (string, error) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	file, err := Parse(ArchARM64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym(pkg.Path)
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: signatures, ARM64ByteCarrierSource: source}
+	goOptions := GoModuleOptions{GOOS: strings.Split(source.request.Target, "/")[0], GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: resolve, ARM64ByteCarrierSource: source}
+	if mutate != nil {
+		mutate(file, &options, &goOptions)
+	}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api == "module" {
+		module, err := TranslateModuleInContext(context, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			return module.String(), err
+		}
+		return "", err
+	}
+	translated, err := translateGoModuleInContext(context, pkg, []byte(assembly), goOptions)
+	if translated != nil && !translated.Module.IsNil() {
+		defer translated.Module.Dispose()
+		return translated.Module.String(), err
+	}
+	return "", err
+}
+
+func arm64ByteCarrierRuntimeChecks(packagePath string, widths []arm64NativeResultTailCase, inputs []uint64) (string, string) {
+	var checks, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n")
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		resultMask := ^uint64(0) >> uint(64-width.resultBits)
+		storeMask := ^uint64(0) >> uint(64-width.storeBits)
+		fmt.Fprintf(&driver, "extern int32_t check_%s(uint64_t);\n", name)
+		fmt.Fprintf(&checks, `
+define i32 @check_%s(i64 %%input) {
+    %%scalar = call i%d %s(i64 %%input)
+    %%scalar_wide = zext i%d %%scalar to i64
+    %%result = call { i64, i64, i64 } %s(i64 %%input)
+    %%value = extractvalue { i64, i64, i64 } %%result, 0
+    %%native = extractvalue { i64, i64, i64 } %%result, 1
+    %%guard = extractvalue { i64, i64, i64 } %%result, 2
+    %%low = and i64 %%input, %d
+    %%store = and i64 %%input, %d
+    %%expected = or i64 %%store, %d
+    %%scalar_ok = icmp eq i64 %%scalar_wide, %%low
+    %%typed_ok = icmp eq i64 %%value, %%low
+    %%native_ok = icmp eq i64 %%native, %%expected
+    %%guard_ok = icmp eq i64 %%guard, %d
+    %%values = and i1 %%scalar_ok, %%typed_ok
+    %%bytes = and i1 %%native_ok, %%guard_ok
+    %%all = and i1 %%values, %%bytes
+    %%status = select i1 %%all, i32 0, i32 1
+    ret i32 %%status
+}
+`, name, width.resultBits, llvmGlobal(packagePath+"."+name), width.resultBits,
+			llvmGlobal(packagePath+".observe_"+name), resultMask, storeMask,
+			uint64(0xfeedfacecafebeef)&^storeMask, uint64(0x7ac35ef012345678))
+	}
+	driver.WriteString("int main(void) {\nstatic const uint64_t inputs[] = {\n")
+	for _, input := range inputs {
+		fmt.Fprintf(&driver, "UINT64_C(0x%x),\n", input)
+	}
+	driver.WriteString("};\nfor (unsigned i=0; i<sizeof(inputs)/sizeof(inputs[0]); i++) {\n")
+	for _, width := range widths {
+		fmt.Fprintf(&driver, "if (check_%s(inputs[i])) return 1;\n", strings.ToLower(width.name()))
+	}
+	driver.WriteString("}\nreturn 0;\n}\n")
+	return checks.String(), driver.String()
+}
diff --git a/arm64_byte_carrier_signed_darwin_arm64_test.go b/arm64_byte_carrier_signed_darwin_arm64_test.go
new file mode 100644
index 000000000..435a5e300
--- /dev/null
+++ b/arm64_byte_carrier_signed_darwin_arm64_test.go
@@ -0,0 +1,13 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestARM64ByteCarrierSignedNativeResults(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arm64SignedCarrierRuntime(t, "darwin", "aarch64-apple-darwin", llc, []string{clang}, nil)
+}
diff --git a/arm64_byte_carrier_signed_entry_test.go b/arm64_byte_carrier_signed_entry_test.go
new file mode 100644
index 000000000..b2d6e9277
--- /dev/null
+++ b/arm64_byte_carrier_signed_entry_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Offline decoder regressions captured from the actual Go 1.27.1 linux/arm64
+// wrappers in TestARM64ByteCarrierSignedActualWrapper. These bytes grant no
+// source/caller authority; the current-Go test independently reproduces them.
+// Keep this framework check available to the minimum supported Go version.
+func TestARM64ByteCarrierSignedEntrySnapshots(t *testing.T) {
+	for _, row := range []struct {
+		name, resultRead string
+		result           LLVMType
+		bytes            int64
+	}{
+		{"int8", "e0438039", I8, 1}, {"uint8", "e0434039", I8, 1},
+		{"int16", "e0238079", I16, 2}, {"uint16", "e0234079", I16, 2},
+		{"int32", "e01380b9", I32, 4}, {"uint32", "e01340b9", I32, 4},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			code, err := hex.DecodeString("fe0f1ef8fd831ff8fd2300d1e00700f900000094" + row.resultRead +
+				"fd835ff8fe0742f8c0035fd6000000000000000000000000")
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := "example.invalid/signedcarrier.value_" + row.name
+			text := gostaticstorage.TextRecord{
+				Name: name, ABI: 1, Size: int64(len(code)), Code: code,
+				Relocations: []gostaticstorage.TextRelocation{{
+					Offset: 16, Size: 4, Type: 9,
+					Target: gostaticstorage.TextReference{Name: name, ABI: 0, ABIKnown: true},
+				}},
+			}
+			signature := FuncSig{
+				Name: name, Args: []LLVMType{I64}, Ret: row.result,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Type: I64, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: row.result, Field: -1}},
+				},
+			}
+			entry, err := arm64ByteCarrierTypedEntry(text, signature)
+			if err != nil || entry.allocation != 32 || entry.dataStart != 8 || entry.dataBytes != 16 ||
+				entry.callPC != 16 || entry.continuationPC != 20 || len(entry.resultLoads) != 1 ||
+				entry.resultLoads[0].PC != 20 || entry.resultLoads[0].Offset != 16 || entry.resultLoads[0].Bytes != row.bytes {
+				t.Fatal("complete compiler wrapper read effects differ", entry, err)
+			}
+			if row.name == "int32" {
+				// The otherwise consistent size/offset must not let a reserved
+				// 64-bit sign-extending load impersonate an ordinary i64 read.
+				binary.LittleEndian.PutUint32(text.Code[20:], 0xf9800be0)
+				signature.Ret, signature.Frame.Results[0].Type = I64, I64
+				if _, err := arm64ByteCarrierTypedEntry(text, signature); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("reserved 64-bit sign extension accepted", err)
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_signed_go127_test.go b/arm64_byte_carrier_signed_go127_test.go
new file mode 100644
index 000000000..6b48fdd96
--- /dev/null
+++ b/arm64_byte_carrier_signed_go127_test.go
@@ -0,0 +1,79 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func arm64ByteCarrierSignedFixture(t *testing.T) (string, string) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath := "example.invalid/signedcarrier"
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package signedcarrier\n")
+	for _, bits := range []int{8, 16, 32} {
+		for _, prefix := range []string{"int", "uint"} {
+			typ := fmt.Sprintf("%s%d", prefix, bits)
+			name := "value_" + typ
+			fmt.Fprintf(&declarations, "func %s(input uint64) %s\n", name, typ)
+			fmt.Fprintf(&declarations, "func entry_%s(input uint64) %s { return %s(input) }\n", name, typ, name)
+			fmt.Fprintf(&declarations, "func observe_%s(input uint64) (value,native,guard uint64)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVD input+0(FP),R0\nMOVD R0,result+8(FP)\nRET\n", name, 8+bits/8)
+			width := arm64NativeResultTailCase{op: "MOVD", resultBits: bits, storeBits: 64}
+			assembly.WriteString(strings.ReplaceAll(arm64NativeResultTailObserver(width), width.name(), name))
+		}
+	}
+	for name, data := range map[string]string{
+		"go.mod":  "module " + packagePath + "\ngo 1.20\n",
+		"decl.go": declarations.String(), "original_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath
+}
+
+func TestARM64ByteCarrierSignedActualWrapper(t *testing.T) {
+	directory, packagePath := arm64ByteCarrierSignedFixture(t)
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	source, err := CaptureGoARM64ByteCarrierSource(lease, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatalf("actual original owner precondition: %v", err)
+	}
+	defer source.Close()
+	for _, bits := range []int{8, 16, 32} {
+		for _, prefix := range []string{"int", "uint"} {
+			name := fmt.Sprintf("value_%s%d", prefix, bits)
+			t.Run(name, func(t *testing.T) {
+				found := false
+				for _, text := range source.report.Archive[1].Texts {
+					if text.Name != packagePath+"."+name || text.ABI != 1 {
+						continue
+					}
+					found = true
+					if len(text.Code) < 36 {
+						t.Fatal("actual wrapper is incomplete")
+					}
+					t.Logf("actual %s wrapper code=%x result-read@20=%08x", name, text.Code, binary.LittleEndian.Uint32(text.Code[20:]))
+					if _, err := arm64ByteCarrierTypedEntry(text, source.declarations[name]); err != nil {
+						t.Errorf("actual signed/unsigned wrapper effect is not closed: %v", err)
+					}
+				}
+				if !found {
+					t.Fatal("actual compiler did not emit the original ABI1 wrapper")
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_byte_carrier_signed_linux_test.go b/arm64_byte_carrier_signed_linux_test.go
new file mode 100644
index 000000000..6d82b43a3
--- /dev/null
+++ b/arm64_byte_carrier_signed_linux_test.go
@@ -0,0 +1,10 @@
+//go:build go1.27 && (arm64 || amd64)
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixARM64ByteCarrierSignedNativeResults(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	arm64SignedCarrierRuntime(t, "linux", triple, llc, compiler, runner)
+}
diff --git a/arm64_byte_carrier_signed_matrix_go127_test.go b/arm64_byte_carrier_signed_matrix_go127_test.go
new file mode 100644
index 000000000..aedbdb0f7
--- /dev/null
+++ b/arm64_byte_carrier_signed_matrix_go127_test.go
@@ -0,0 +1,211 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type arm64SignedCarrierCase struct {
+	name, typ, load       string
+	resultBits, storeBits int
+	op                    Op
+	signed, twoParameters bool
+}
+
+// Independent scalar memory family: exact and wider native stores retain both
+// signed/unsigned spellings. The logical Go result and native store are separate
+// axes; this inventory is not generated from the consumer's decoder.
+func arm64SignedCarrierCases() []arm64SignedCarrierCase {
+	var result []arm64SignedCarrierCase
+	for _, bits := range []int{8, 16, 32, 64} {
+		for _, signed := range []bool{false, true} {
+			prefix := "uint"
+			load := map[int]string{8: "MOVBU", 16: "MOVHU", 32: "MOVWU", 64: "MOVD"}[bits]
+			if signed {
+				prefix = "int"
+				load = map[int]string{8: "MOVB", 16: "MOVH", 32: "MOVW", 64: "MOVD"}[bits]
+			}
+			for _, store := range []struct {
+				op   Op
+				bits int
+			}{{"MOVB", 8}, {"MOVBU", 8}, {"MOVH", 16}, {"MOVHU", 16}, {"MOVW", 32}, {"MOVWU", 32}, {"MOVD", 64}} {
+				if store.bits < bits {
+					continue
+				}
+				for _, two := range []bool{false, true} {
+					result = append(result, arm64SignedCarrierCase{
+						name: fmt.Sprintf("value_%s%d_%s_two%t", prefix, bits, strings.ToLower(string(store.op)), two),
+						typ:  fmt.Sprintf("%s%d", prefix, bits), load: load, op: store.op,
+						resultBits: bits, storeBits: store.bits, signed: signed, twoParameters: two,
+					})
+				}
+			}
+		}
+	}
+	return result
+}
+
+func arm64SignedCarrierMatrixFixture(t *testing.T) (string, string, []arm64SignedCarrierCase) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath := "example.invalid/signedcarriermatrix"
+	cases := arm64SignedCarrierCases()
+	if len(cases) != 64 {
+		t.Fatal("complete independent signed/store/parameter denominator changed", len(cases))
+	}
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package signedcarriermatrix\n")
+	for _, row := range cases {
+		parameters, resultOffset := "input uint64", 8
+		if row.twoParameters {
+			parameters, resultOffset = parameters+", spare uint32", 16
+		}
+		fmt.Fprintf(&declarations, "func %s(%s) %s\n", row.name, parameters, row.typ)
+		fmt.Fprintf(&declarations, "func observe_%s(input uint64) (value,native,guard,paramgap uint64)\n", row.name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVD input+0(FP),R0\n%s R0,result+%d(FP)\nRET\n",
+			row.name, resultOffset+row.resultBits/8, row.op, resultOffset)
+		fmt.Fprintf(&assembly, "TEXT ·observe_%s(SB),4,$48-40\nMOVD input+0(FP),R0\nMOVD R0,8(RSP)\n", row.name)
+		if row.twoParameters {
+			assembly.WriteString("MOVD $0xabad1dea00123456,R1\nMOVD R1,16(RSP)\n")
+		}
+		fmt.Fprintf(&assembly, "MOVD $0xfeedfacecafebeef,R1\nMOVD R1,%d(RSP)\n"+
+			"MOVD $0x7ac35ef012345678,R1\nMOVD R1,%d(RSP)\nCALL ·%s(SB)\n"+
+			"MOVD %d(RSP),R0\nMOVD R0,native+16(FP)\n%s %d(RSP),R0\nMOVD R0,value+8(FP)\n"+
+			"MOVD %d(RSP),R0\nMOVD R0,guard+24(FP)\n",
+			resultOffset+8, resultOffset+16, row.name, resultOffset+8, row.load, resultOffset+8, resultOffset+16)
+		if row.twoParameters {
+			assembly.WriteString("MOVD 16(RSP),R0\n")
+		} else {
+			assembly.WriteString("MOVD ZR,R0\n")
+		}
+		assembly.WriteString("MOVD R0,paramgap+32(FP)\nRET\n")
+	}
+	for name, data := range map[string]string{
+		"go.mod":  "module " + packagePath + "\ngo 1.20\n",
+		"decl.go": declarations.String(), "original_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath, cases
+}
+
+func arm64SignedCarrierEntry(t *testing.T, source *GoARM64ByteCarrierSource, name string) gostaticstorage.TextRecord {
+	t.Helper()
+	for _, text := range source.report.Archive[1].Texts {
+		if text.Name == source.request.PackagePath+"."+name && text.ABI == 1 {
+			return text
+		}
+	}
+	t.Fatal("missing complete actual compiler entry", name)
+	return gostaticstorage.TextRecord{}
+}
+
+func TestARM64ByteCarrierSignedCompleteWidthObjects(t *testing.T) {
+	buildCache := t.TempDir()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "aarch64-unknown-linux-gnu"}, {"darwin", "aarch64-apple-darwin"},
+		{"windows", "aarch64-pc-windows-msvc"}, {"freebsd", "aarch64-unknown-freebsd"},
+		{"openbsd", "aarch64-unknown-openbsd"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			directory, packagePath, cases := arm64SignedCarrierMatrixFixture(t)
+			request := arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)
+			request.Target = target.goos + "/arm64"
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + target.goos
+				}
+			}
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal("actual source owner", err)
+			}
+			defer source.Close()
+			for _, row := range cases {
+				text := arm64SignedCarrierEntry(t, source, row.name)
+				entry, err := arm64ByteCarrierTypedEntry(text, source.declarations[row.name])
+				if err != nil || len(entry.resultLoads) != 1 || entry.resultLoads[0].Bytes != int64(row.resultBits/8) {
+					t.Fatal("actual logical/native result width mismatch", row.name, entry, err)
+				}
+				base := uint32(0x394003e0)
+				if row.signed && row.resultBits < 64 {
+					base = 0x398003e0
+				}
+				if entry.resultLoads[0].Instruction&0x3fc003e0 != base {
+					t.Fatal("actual compiler sign extension differs", row.name, entry.resultLoads[0])
+				}
+			}
+			declaration, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, packagePath, string(declaration))
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), target.triple, nil)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "signed-carrier-"+api+".ll", "signed-carrier-"+api+".o", ir)
+			}
+			t.Logf("actual original %s/arm64: %d result wrappers and 3 LLVM objects", target.goos, len(cases))
+		})
+	}
+}
+
+func TestARM64ByteCarrierSignedEntryRejectsAdjacentFormats(t *testing.T) {
+	directory, packagePath := arm64ByteCarrierSignedFixture(t)
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	source, err := CaptureGoARM64ByteCarrierSource(lease, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	for _, bits := range []int{8, 16, 32} {
+		name := fmt.Sprintf("value_int%d", bits)
+		original := arm64SignedCarrierEntry(t, source, name)
+		for mutation, edit := range map[string]func(uint32) uint32{
+			"unsigned-width":        func(word uint32) uint32 { return word ^ 1<<30 },
+			"W-result":              func(word uint32) uint32 { return word | 1<<22 },
+			"SIMD":                  func(word uint32) uint32 { return word | 1<<26 },
+			"non-SP-base":           func(word uint32) uint32 { return word &^ (31 << 5) },
+			"wrong-result-register": func(word uint32) uint32 { return word | 1 },
+			"wrong-result-offset":   func(word uint32) uint32 { return word + 1<<10 },
+			"writeback":             func(word uint32) uint32 { return word&^(1<<24) | 1<<10 },
+			"store":                 func(word uint32) uint32 { return word &^ (3 << 22) },
+		} {
+			t.Run(name+"/"+mutation, func(t *testing.T) {
+				text := original
+				text.Code = append([]byte(nil), original.Code...)
+				binary.LittleEndian.PutUint32(text.Code[20:], edit(binary.LittleEndian.Uint32(text.Code[20:])))
+				if _, err := arm64ByteCarrierTypedEntry(text, source.declarations[name]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("adjacent width/native effect acquired result permission", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_byte_carrier_signed_runtime_go127_test.go b/arm64_byte_carrier_signed_runtime_go127_test.go
new file mode 100644
index 000000000..535267970
--- /dev/null
+++ b/arm64_byte_carrier_signed_runtime_go127_test.go
@@ -0,0 +1,155 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func arm64SignedCarrierRuntime(t *testing.T, goos, triple, llc string, compiler, runner []string) {
+	t.Helper()
+	directory, packagePath, cases := arm64SignedCarrierMatrixFixture(t)
+	inputs := arm64PaddingRuntimeInputs()
+	var original strings.Builder
+	original.WriteString("package signedcarriermatrix\nimport \"testing\"\nfunc TestOriginalSignedCarrier(t *testing.T) {\ninputs := []uint64{\n")
+	for _, input := range inputs {
+		fmt.Fprintf(&original, "0x%x,\n", input)
+	}
+	original.WriteString("}\n")
+	for _, row := range cases {
+		args, gap := "input", uint64(0)
+		if row.twoParameters {
+			args, gap = args+",0x123456", 0xabad1dea00123456
+		}
+		resultMask := ^uint64(0) >> uint(64-row.resultBits)
+		storeMask := ^uint64(0) >> uint(64-row.storeBits)
+		fmt.Fprintf(&original, "for _,input := range inputs {\nactual := uint64(int64(%s(%s)))\n"+
+			"expected := input & 0x%x\n", row.name, args, resultMask)
+		if row.signed && row.resultBits < 64 {
+			fmt.Fprintf(&original, "if expected & (uint64(1)<<%d) != 0 { expected |= 0x%x }\n", row.resultBits-1, ^resultMask)
+		}
+		fmt.Fprintf(&original, "value,native,guard,paramgap := observe_%s(input)\n"+
+			"if actual != expected || value != expected || native != (input & 0x%x | 0x%x) || "+
+			"guard != 0x7ac35ef012345678 || paramgap != 0x%x { t.Fatalf(%q, input, actual, value, native, guard, paramgap) }\n}\n",
+			row.name, storeMask, uint64(0xfeedfacecafebeef)&^storeMask, gap,
+			row.name+": input=%x typed=%x value=%x native=%x guard=%x paramgap=%x")
+	}
+	marker := fmt.Sprintf("ORIGINAL_SIGNED_CARRIER %d", len(cases)*len(inputs))
+	fmt.Fprintf(&original, "t.Log(%q)\n}\n", marker)
+	if err := os.WriteFile(filepath.Join(directory, "original_test.go"), []byte(original.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	request.Target = goos + "/arm64"
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOOS=") {
+			request.Environment[index] = "GOOS=" + goos
+		}
+	}
+	args := []string{"test", "-p=1", "-count=1", "-v", "-run", "^TestOriginalSignedCarrier$"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		args = append(args, "-exec", quoted)
+	}
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	command := exec.CommandContext(lease, request.GoBinary, args...)
+	command.Dir, command.Env = directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(lease, command)
+	if err != nil || strings.Count(string(output), marker) != 1 || !strings.Contains(string(output), "--- PASS: TestOriginalSignedCarrier") {
+		t.Fatalf("unchanged original signed/native/canary runtime: %v\n%s", err, output)
+	}
+	t.Logf("actual original Go %s signed/canary observations: %d", request.Target, len(cases)*len(inputs))
+	source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	checks, driver := arm64SignedCarrierRuntimeChecks(packagePath, cases, inputs)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), triple, nil)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, optimization := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", api, optimization), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "signed_carrier", triple, ir+checks, driver, runner, optimization)
+				t.Logf("actual LLVM22 %s O%d signed/canary observations: %d", api, optimization, len(cases)*len(inputs))
+			})
+		}
+	}
+}
+
+func arm64SignedCarrierRuntimeChecks(packagePath string, cases []arm64SignedCarrierCase, inputs []uint64) (string, string) {
+	var checks, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n")
+	for _, row := range cases {
+		args, gap := "i64 %input", uint64(0)
+		if row.twoParameters {
+			args, gap = args+", i32 1193046", 0xabad1dea00123456
+		}
+		fmt.Fprintf(&checks, "define i32 @check_%s(i64 %%input) {\n%%scalar = call i%d %s(%s)\n",
+			row.name, row.resultBits, llvmGlobal(packagePath+"."+row.name), args)
+		if row.resultBits == 64 {
+			checks.WriteString("%scalar_wide = add i64 %scalar, 0\n%expected = add i64 %input, 0\n")
+		} else {
+			extension, shift := "zext", "lshr"
+			if row.signed {
+				extension, shift = "sext", "ashr"
+			}
+			fmt.Fprintf(&checks, "%%scalar_wide = %s i%d %%scalar to i64\n"+
+				"%%shifted = shl i64 %%input, %d\n%%expected = %s i64 %%shifted, %d\n",
+				extension, row.resultBits, 64-row.resultBits, shift, 64-row.resultBits)
+		}
+		storeMask := ^uint64(0) >> uint(64-row.storeBits)
+		fmt.Fprintf(&checks, `%%result = call { i64,i64,i64,i64 } %s(i64 %%input)
+%%value = extractvalue { i64,i64,i64,i64 } %%result, 0
+%%native = extractvalue { i64,i64,i64,i64 } %%result, 1
+%%guard = extractvalue { i64,i64,i64,i64 } %%result, 2
+%%gap = extractvalue { i64,i64,i64,i64 } %%result, 3
+%%store = and i64 %%input, %d
+%%native_expected = or i64 %%store, %d
+%%typed_ok = icmp eq i64 %%scalar_wide, %%expected
+%%value_ok = icmp eq i64 %%value, %%expected
+%%native_ok = icmp eq i64 %%native, %%native_expected
+%%guard_ok = icmp eq i64 %%guard, %d
+%%gap_ok = icmp eq i64 %%gap, %d
+%%typed = and i1 %%typed_ok, %%value_ok
+%%bytes = and i1 %%native_ok, %%guard_ok
+%%both = and i1 %%typed, %%bytes
+%%all = and i1 %%both, %%gap_ok
+%%status = select i1 %%all, i32 0, i32 1
+ret i32 %%status
+}
+`, llvmGlobal(packagePath+".observe_"+row.name), storeMask,
+			uint64(0xfeedfacecafebeef)&^storeMask, uint64(0x7ac35ef012345678), gap)
+		fmt.Fprintf(&driver, "extern int32_t check_%s(uint64_t);\n", row.name)
+	}
+	driver.WriteString("int main(void) {\nconst uint64_t inputs[] = {\n")
+	for _, input := range inputs {
+		fmt.Fprintf(&driver, "UINT64_C(0x%x),\n", input)
+	}
+	driver.WriteString("};\nfor (unsigned i=0; i<sizeof(inputs)/sizeof(inputs[0]); i++) {\n")
+	for _, row := range cases {
+		fmt.Fprintf(&driver, "if (check_%s(inputs[i])) return 1;\n", row.name)
+	}
+	driver.WriteString("}\nreturn 0;\n}\n")
+	return checks.String(), driver.String()
+}
diff --git a/arm64_byte_carrier_source_test.go b/arm64_byte_carrier_source_test.go
new file mode 100644
index 000000000..71b372684
--- /dev/null
+++ b/arm64_byte_carrier_source_test.go
@@ -0,0 +1,651 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Reuse the native-width family, not Or32 or a fabricated allocation. All
+// declarations and assembly calls are private, numeric and in one source file.
+func arm64ByteCarrierFixture(t *testing.T) (string, string, []arm64NativeResultTailCase) {
+	t.Helper()
+	directory := t.TempDir()
+	var err error
+	directory, err = filepath.EvalSymlinks(directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath := "example.invalid/carrierfixture"
+	cases := arm64NativeResultTailCases()
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package carrierfixture\n\n")
+	for _, test := range cases {
+		name := strings.ToLower(test.name())
+		declarations.WriteString(strings.ReplaceAll(test.declaration(), test.name(), name))
+		fmt.Fprintf(&declarations, "func observe_%s(input uint64) (value,native,guard uint64)\n", name)
+		fmt.Fprintf(&declarations, "func entry_%s(input uint64) (uint64,uint64,uint64) {\nreturn observe_%s(input)\n}\n", name, name)
+		assembly.WriteString(strings.ReplaceAll(test.source(), test.name(), name))
+		assembly.WriteString(strings.ReplaceAll(arm64NativeResultTailObserver(test), test.name(), name))
+	}
+	for name, data := range map[string]string{
+		"go.mod":  "module " + packagePath + "\ngo 1.20\n",
+		"decl.go": declarations.String(), "original_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath, cases
+}
+
+func arm64ByteCarrierOriginal(t *testing.T, directory, packagePath string) ([]byte, []byte, []byte) {
+	t.Helper()
+	return arm64ByteCarrierOriginalForOS(t, "linux", directory, packagePath)
+}
+
+func arm64ByteCarrierOriginalForOS(t *testing.T, goos, directory, packagePath string) ([]byte, []byte, []byte) {
+	t.Helper()
+	selection := arm64ABI0RegionCommand(t, goos, directory, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+	var selected goAMD64FrameSelection
+	decoder := json.NewDecoder(bytes.NewReader(selection))
+	if err := decoder.Decode(&selected); err != nil {
+		t.Fatal(err)
+	}
+	var extra any
+	if decoder.Decode(&extra) != io.EOF || selected.ImportPath != packagePath ||
+		len(selected.SFiles) != 1 || selected.SFiles[0] != "original_arm64.s" || selected.Export == "" {
+		t.Fatalf("actual complete first-party source selection differs: %s", selection)
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil {
+		t.Fatal(err)
+	}
+	objectName := filepath.Join(t.TempDir(), "original.o")
+	arm64ABI0RegionCommand(t, goos, directory, "tool", "asm", "-p", packagePath,
+		"-o", objectName, "original_arm64.s")
+	object, err := os.ReadFile(objectName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtins, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return archive, object, builtins
+}
+
+func TestARM64ByteCarrierActualSourceTargetMatrix(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	base := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			archive, object, builtins := arm64ByteCarrierOriginalForOS(t, goos, directory, packagePath)
+			target := goos + "/arm64"
+			if records, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, target); err != nil || len(records) != 18 {
+				t.Fatalf("actual target standalone object differs: %v", err)
+			}
+			if members, err := gostaticstorage.ObserveARM64AssemblyArchive(archive, builtins, target, []string{"original_arm64.s"}); err != nil || len(members) != 3 {
+				t.Fatalf("actual target complete archive differs: %v", err)
+			}
+			request := base
+			request.Target = target
+			request.Environment = append([]string(nil), base.Environment...)
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + goos
+				}
+			}
+			source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			if len(source.report.Calls) != len(cases) || len(source.report.Archive[1].Texts) != 27 {
+				t.Fatal("target lost actual native caller or original typed compiler entry")
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierActualMainPackageIdentity(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	filename := filepath.Join(directory, "decl.go")
+	declarations, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations = bytes.Replace(declarations, []byte("package carrierfixture"), []byte("package main"), 1)
+	declarations = append(declarations, []byte("\nfunc main() {}\n")...)
+	if err := os.WriteFile(filename, declarations, 0600); err != nil {
+		t.Fatal(err)
+	}
+	base := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			// The driver determines its native -p identity from the package role,
+			// not the module's import path. Inspect the actual archive independently.
+			raw := arm64ABI0RegionCommand(t, goos, directory, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			var selected goAMD64FrameSelection
+			decoder := json.NewDecoder(bytes.NewReader(raw))
+			var extra any
+			if decoder.Decode(&selected) != nil || decoder.Decode(&extra) != io.EOF ||
+				selected.Name != "main" || selected.ImportPath != packagePath {
+				t.Fatalf("actual main package selection differs: %s", raw)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			builtins, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/goobj/builtinlist.go"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			members, err := gostaticstorage.ObserveARM64AssemblyArchive(archive, builtins, goos+"/arm64", []string{"original_arm64.s"})
+			if err != nil || len(members) != 3 {
+				t.Fatalf("actual complete main archive differs: %v", err)
+			}
+			for _, text := range members[2].Texts {
+				if !strings.HasPrefix(text.Name, "main.") || text.ABI != 0 {
+					t.Fatalf("original driver did not use the main ASM identity: %+v", text)
+				}
+			}
+			request := base
+			request.Target = goos + "/arm64"
+			request.Environment = append([]string(nil), base.Environment...)
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + goos
+				}
+			}
+			source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+			if err != nil {
+				t.Fatalf("actual main compiler/ASM identities fail their complete source join: %v", err)
+			}
+			defer source.Close()
+			if len(source.report.Calls) != len(cases) {
+				t.Fatal("main source omitted an actual call")
+			}
+			if source.report.NativePackagePath != "main" || source.request.PackagePath != packagePath {
+				t.Fatal("native observation changed the original module identity")
+			}
+			arguments := source.report.Commands[len(source.report.Commands)-1].Arguments
+			if len(arguments) < 5 || arguments[0] != "tool" || arguments[1] != "asm" || arguments[3] != "-p" || arguments[4] != "main" {
+				t.Fatal("standalone namespace is not the actual ordinary driver's identity")
+			}
+			for _, call := range source.report.Calls {
+				if !strings.HasPrefix(call.Caller, "main.") || !strings.HasPrefix(call.Callee, "main.") {
+					t.Fatal("source observation reconstructed main identity from the import path")
+				}
+			}
+		})
+	}
+}
+
+func arm64ByteCarrierRequest(t *testing.T, directory, packagePath string) GoARM64ByteCarrierCaptureRequest {
+	t.Helper()
+	return arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, "")
+}
+
+func arm64ByteCarrierRequestWithBuildCache(t *testing.T, directory, packagePath, buildCache string) GoARM64ByteCarrierCaptureRequest {
+	t.Helper()
+	provided := make(map[string]string)
+	for _, pair := range os.Environ() {
+		key, value, _ := strings.Cut(pair, "=")
+		provided[key] = value
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if key == "GOCACHE" && buildCache != "" {
+			root, err := filepath.EvalSymlinks(buildCache)
+			if err != nil || !filepath.IsAbs(root) {
+				t.Fatalf("shared owned build cache must be absolute: %v", err)
+			}
+			provided[key] = root
+			continue
+		}
+		root, err := filepath.EvalSymlinks(t.TempDir())
+		if err != nil {
+			t.Fatal(err)
+		}
+		provided[key] = root
+	}
+	for key, value := range map[string]string{
+		"GOOS": "linux", "GOARCH": "arm64", "GOARM64": "v8.0", "GOAMD64": "v1",
+		"CGO_ENABLED": "0", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOPROXY": "off", "GOPACKAGESDRIVER": "off",
+	} {
+		provided[key] = value
+	}
+	var environment []string
+	for key, value := range provided {
+		environment = append(environment, key+"="+value)
+	}
+	sort.Strings(environment)
+	binary, err := sourcepath.Resolve(filepath.Join(runtime.GOROOT(), "bin", gotoolchain.HostExecutable("go")))
+	if err != nil {
+		t.Fatal("resolve the actual host Go driver", err)
+	}
+	return GoARM64ByteCarrierCaptureRequest{
+		GoBinary: binary, Directory: directory,
+		PackagePath: packagePath, AssemblyFile: "original_arm64.s", Target: "linux/arm64", Environment: environment,
+	}
+}
+
+func TestARM64ByteCarrierSharedBuildCacheKeepsRequestsIndependent(t *testing.T) {
+	cache := t.TempDir()
+	first := arm64ByteCarrierRequestWithBuildCache(t, t.TempDir(), "example.invalid/first", cache)
+	second := arm64ByteCarrierRequestWithBuildCache(t, t.TempDir(), "example.invalid/second", cache)
+	environment := func(request GoARM64ByteCarrierCaptureRequest) map[string]string {
+		values := make(map[string]string)
+		for _, item := range request.Environment {
+			key, value, _ := strings.Cut(item, "=")
+			values[key] = value
+		}
+		return values
+	}
+	a, b := environment(first), environment(second)
+	if a["GOCACHE"] != b["GOCACHE"] || a["GOCACHE"] == "" {
+		t.Fatal("subtests must reuse the parent's owned build cache")
+	}
+	for _, key := range []string{"GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if a[key] == b[key] || a[key] == a["GOCACHE"] || b[key] == b["GOCACHE"] {
+			t.Fatalf("source observation state shares %s", key)
+		}
+	}
+	if first.Directory == second.Directory || first.PackagePath == second.PackagePath {
+		t.Fatal("independent original source roles were reused")
+	}
+}
+
+func TestARM64ByteCarrierActualSourceObservation(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	// Original compiler success is established independently of the proposed
+	// live source. The factory must then join all original entry/call records.
+	arm64ByteCarrierOriginal(t, directory, packagePath)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+	if err != nil {
+		t.Fatalf("actual complete numeric caller/entry source is not observed: %v", err)
+	}
+	defer source.Close()
+	raw, err := source.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var report struct {
+		Protocol string
+		Calls    []struct {
+			Caller, Callee          string
+			CallPC, ContinuationPC  int64
+			CallerCode, CalleeCode  [32]byte
+			CalleeSPReads, SPWrites []arm64ByteCarrierMemory
+		}
+		Archive []gostaticstorage.TextMember
+	}
+	if err := json.Unmarshal(raw, &report); err != nil || report.Protocol != "actual_go_arm64_byte_carrier_observation_v1" ||
+		len(report.Calls) != len(cases) || len(report.Archive) != 3 || len(report.Archive[1].Texts) != 27 {
+		t.Fatalf("actual complete caller/entry source observation differs: %v", err)
+	}
+	for _, call := range report.Calls {
+		if call.Caller == "" || call.Callee == "" || call.CallPC < 0 || call.ContinuationPC != call.CallPC+4 {
+			t.Fatalf("original call/continuation physical identity differs: %+v", call)
+		}
+		var family *arm64NativeResultTailCase
+		for ordinal := range cases {
+			if call.Callee == packagePath+"."+strings.ToLower(cases[ordinal].name()) {
+				family = &cases[ordinal]
+			}
+		}
+		if family == nil || len(call.CalleeSPReads) != 1 || len(call.SPWrites) != 1 ||
+			call.CalleeSPReads[0].PC != 0 || call.CalleeSPReads[0].Offset != 8 || call.CalleeSPReads[0].Bytes != 8 ||
+			call.SPWrites[0].PC != 4 || call.SPWrites[0].Offset != 16 || call.SPWrites[0].Bytes != int64(family.storeBits/8) {
+			t.Fatalf("actual leaf byte-region mapping is not complete: %+v", call)
+		}
+		for _, text := range report.Archive[2].Texts {
+			if text.Name == call.Caller && sha256.Sum256(text.Code) != call.CallerCode ||
+				text.Name == call.Callee && sha256.Sum256(text.Code) != call.CalleeCode {
+				t.Fatal("call/continuation joined a foreign original native object")
+			}
+		}
+	}
+	for _, test := range cases {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(test.name()+"/no-consumer/"+api, func(t *testing.T) {
+				_, err := arm64ResultTailAuditTranslate(t, api, "aarch64-unknown-linux-gnu", test.declaration(), test.source())
+				if err == nil || !strings.Contains(err.Error(), "FP") {
+					t.Fatalf("source observation fabricated writable FP tail: %v", err)
+				}
+			})
+		}
+	}
+	if err := source.Close(); err != nil || !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatalf("closed source retained a live observation: %v", err)
+	}
+}
+
+func TestARM64ByteCarrierSourceRevocation(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, test := range []struct {
+		name   string
+		mutate func(*GoARM64ByteCarrierSource) func()
+	}{
+		{"native-package-namespace", func(source *GoARM64ByteCarrierSource) func() {
+			prior := source.report.NativePackagePath
+			source.report.NativePackagePath = "main"
+			return func() { source.report.NativePackagePath = prior }
+		}},
+		{"source-request", func(source *GoARM64ByteCarrierSource) func() {
+			prior := source.request.PackagePath
+			source.request.PackagePath += "/foreign"
+			return func() { source.request.PackagePath = prior }
+		}},
+		{"call-continuation", func(source *GoARM64ByteCarrierSource) func() {
+			source.report.Calls[0].ContinuationPC += 4
+			return func() { source.report.Calls[0].ContinuationPC -= 4 }
+		}},
+		{"native-store-width", func(source *GoARM64ByteCarrierSource) func() {
+			source.report.Calls[0].SPWrites[0].Bytes++
+			return func() { source.report.Calls[0].SPWrites[0].Bytes-- }
+		}},
+		{"whole-callee-object", func(source *GoARM64ByteCarrierSource) func() {
+			source.report.Standalone[0].Code[0] ^= 1
+			return func() { source.report.Standalone[0].Code[0] ^= 1 }
+		}},
+		{"original-source-bytes", func(source *GoARM64ByteCarrierSource) func() {
+			name := filepath.Join(directory, "decl.go")
+			prior, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(name, append(append([]byte(nil), prior...), '\n'), 0600); err != nil {
+				t.Fatal(err)
+			}
+			return func() {
+				if err := os.WriteFile(name, prior, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+		}},
+		{"same-bytes-object-inode", func(source *GoARM64ByteCarrierSource) func() {
+			name := filepath.Join(source.guard.owned, "original.o")
+			backup := name + ".saved"
+			prior, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Rename(name, backup); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(name, prior, 0600); err != nil {
+				t.Fatal(err)
+			}
+			return func() {
+				if err := os.Rename(backup, name); err != nil {
+					t.Fatal(err)
+				}
+			}
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			restore := test.mutate(source)
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("changed actual source/caller identity remained live")
+			}
+			restore()
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restoring bytes revived a revoked source")
+			}
+		})
+	}
+	for _, kind := range []string{"nil", "cancelled"} {
+		t.Run(kind, func(t *testing.T) {
+			source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			var invalid context.Context
+			cause := errors.New("source owner explicitly revoked")
+			if kind == "cancelled" {
+				cancelled, stop := context.WithCancelCause(ctx)
+				stop(cause)
+				invalid = cancelled
+			}
+			err = source.Verify(invalid)
+			if !errors.Is(err, ErrProbeNeedsContext) || kind == "cancelled" && !errors.Is(err, cause) ||
+				!errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatalf("invalid context revived a source or lost its actual cause: %v", err)
+			}
+		})
+	}
+	// A copied pointer graph cannot acquire the producer's identity, and
+	// refusing the copy must not revoke or release the original source.
+	source, err := CaptureGoARM64ByteCarrierSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	copied := &GoARM64ByteCarrierSource{identity: source, ready: true, guard: source.guard}
+	if !errors.Is(copied.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(copied.Close(), ErrProbeNeedsContext) || source.Verify(ctx) != nil {
+		t.Fatal("copied source borrowed identity or released the original observation")
+	}
+}
+
+func TestARM64ByteCarrierOriginalLeaseCannotBeRenewed(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	lease, stop := context.WithCancelCause(ctx)
+	defer stop(nil)
+	source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatalf("original bounded lease did not capture its complete source: %v", err)
+	}
+	defer source.Close()
+	cause := errors.New("original source lease ended")
+	stop(cause)
+	err = source.Verify(ctx)
+	if !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(err, cause) {
+		t.Fatalf("fresh verification context renewed the original cancelled source lease: %v", err)
+	}
+	if _, err := source.Readback(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("revoked lease yielded a portable source observation")
+	}
+}
+
+func TestARM64ByteCarrierLeaseCancelsBoundedOperation(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	lease, stop := context.WithCancelCause(ctx)
+	defer stop(nil)
+	source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	operation, release, err := source.executionContext(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer release()
+	cause := errors.New("actual capture lease revoked during operation")
+	stop(cause)
+	select {
+	case <-operation.Done():
+		if !errors.Is(context.Cause(operation), cause) {
+			t.Fatal("bounded operation lost its original lease cause")
+		}
+	case <-ctx.Done():
+		t.Fatal("original lease did not cancel its live operation")
+	}
+}
+
+func TestARM64ByteCarrierSourceRejectsOpenRoles(t *testing.T) {
+	base, packagePath, _ := arm64ByteCarrierFixture(t)
+	request := arm64ByteCarrierRequest(t, base, packagePath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	for _, test := range []struct {
+		name   string
+		file   string
+		change func(string) string
+	}{
+		{"exported-entry", "decl.go", func(text string) string { return text + "\nfunc Visible() {}\n" }},
+		{"function-address", "decl.go", func(text string) string { return text + "\nfunc escaped() { _ = movd_u32 }\n" }},
+		{"pointer-transport", "decl.go", func(text string) string {
+			return strings.Replace(text, "func movd_u32(input uint64)", "func movd_u32(input *uint64)", 1)
+		}},
+		{"linkname", "decl.go", func(text string) string {
+			return strings.Replace(text, "package carrierfixture", "package carrierfixture\nimport _ \"unsafe\"", 1) +
+				"\n//go:linkname movd_u32 foreign.movd_u32\n"
+		}},
+		{"text-declaration-mismatch", "original_arm64.s", func(text string) string { return strings.Replace(text, "$0-12", "$0-16", 1) }},
+		{"native-code-address", "original_arm64.s", func(text string) string {
+			return strings.Replace(text, "MOVD input+0(FP),R0", "MOVD $·movd_u32(SB),R0", 1)
+		}},
+		{"unknown-memory", "original_arm64.s", func(text string) string { return strings.Replace(text, "MOVD R0,8(RSP)", "MOVD R0,(R1)", 1) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			directory, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"go.mod", "decl.go", "original_arm64.s"} {
+				data, err := os.ReadFile(filepath.Join(base, name))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if name == test.file {
+					data = []byte(test.change(string(data)))
+				}
+				if err := os.WriteFile(filepath.Join(directory, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			changed := request
+			changed.Directory = directory
+			// These counterexamples are accepted by the original Go compiler
+			// and assembler. A factory role refusal is not a compiler-error pass.
+			arm64ByteCarrierOriginal(t, directory, packagePath)
+			if source, err := CaptureGoARM64ByteCarrierSource(ctx, changed); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				if source != nil {
+					source.Close()
+				}
+				t.Fatalf("open/contradictory source role was admitted: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierActualArchiveObservation(t *testing.T) {
+	directory, packagePath, cases := arm64ByteCarrierFixture(t)
+	archive, object, builtins := arm64ByteCarrierOriginal(t, directory, packagePath)
+	standalone, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, "linux/arm64")
+	if err != nil {
+		t.Fatalf("actual original Go caller/callee object is not observed: %v", err)
+	}
+	members, err := gostaticstorage.ObserveARM64AssemblyArchive(archive, builtins, "linux/arm64", []string{"original_arm64.s"})
+	if err != nil {
+		t.Fatalf("actual original Go complete caller/entry archive is not observed: %v", err)
+	}
+	if len(members) != 3 || members[1].Name != "_go_.o" || members[2].Name != "original_arm64.o" ||
+		len(standalone) != 18 || len(members[2].Texts) != len(standalone) {
+		t.Fatalf("incomplete original caller/callee/entry inventory: members=%d standalone=%d", len(members), len(standalone))
+	}
+	texts := make(map[string]gostaticstorage.TextRecord)
+	for _, text := range members[2].Texts {
+		texts[text.Name] = text
+	}
+	for _, original := range standalone {
+		archived, exists := texts[original.Name]
+		if !exists || original.ABI != archived.ABI || !bytes.Equal(original.Code, archived.Code) ||
+			len(original.Relocations) != len(archived.Relocations) || len(archived.Positions) == 0 {
+			t.Fatalf("standalone/archive original instruction join differs: %s", original.Name)
+		}
+	}
+	for _, test := range cases {
+		t.Run(test.name(), func(t *testing.T) {
+			name := strings.ToLower(test.name())
+			callee := texts[packagePath+"."+name]
+			caller := texts[packagePath+".observe_"+name]
+			if callee.ABI != 0 || caller.ABI != 0 || len(callee.Code) < 12 || len(caller.Code) == 0 {
+				t.Fatal("original ABI0 caller/callee physical identity is missing")
+			}
+			// The actual native store keeps its whole width even when its Go
+			// result is narrow. No padded FrameSlot is introduced by this test.
+			store := binary.LittleEndian.Uint32(callee.Code[4:8])
+			wanted := map[int]uint32{16: 0x790023e0, 32: 0xb90013e0, 64: 0xf9000be0}[test.storeBits]
+			if store != wanted {
+				t.Fatalf("native store width changed: got=%08x want=%08x", store, wanted)
+			}
+			calls := 0
+			for _, relocation := range caller.Relocations {
+				if relocation.Target.Name != callee.Name {
+					continue
+				}
+				calls++
+				pc := relocation.Offset
+				if relocation.Size != 4 || pc < 0 || pc+8 > int64(len(caller.Code)) ||
+					binary.LittleEndian.Uint32(caller.Code[pc:pc+4])&0xfc000000 != 0x94000000 ||
+					!relocation.Target.ABIKnown || relocation.Target.ABI != callee.ABI {
+					t.Fatalf("original direct call/continuation is not bound: %+v", relocation)
+				}
+			}
+			if calls != 1 {
+				t.Fatalf("same-file caller has %d original direct calls", calls)
+			}
+		})
+	}
+	for _, test := range []struct {
+		name    string
+		data    []byte
+		target  string
+		sources []string
+	}{
+		{"truncated", archive[:len(archive)-1], "linux/arm64", []string{"original_arm64.s"}},
+		{"trailing", append(append([]byte(nil), archive...), 0), "linux/arm64", []string{"original_arm64.s"}},
+		{"wrong-target", archive, "linux/amd64", []string{"original_arm64.s"}},
+		{"omitted-member", archive, "linux/arm64", nil},
+		{"foreign-member", archive, "linux/arm64", []string{"foreign.s"}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, err := gostaticstorage.ObserveARM64AssemblyArchive(test.data, builtins, test.target, test.sources); err == nil {
+				t.Fatal("incomplete or mismatched original archive was accepted")
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_two_scalar_family_darwin_arm64_test.go b/arm64_byte_carrier_two_scalar_family_darwin_arm64_test.go
new file mode 100644
index 000000000..50a6fa2fa
--- /dev/null
+++ b/arm64_byte_carrier_two_scalar_family_darwin_arm64_test.go
@@ -0,0 +1,13 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestARM64ByteCarrierTwoScalarNativeResultFamily(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	arm64ByteCarrierTwoScalarRuntimeFamily(t, "darwin", "aarch64-apple-darwin", llc, []string{clang}, nil)
+}
diff --git a/arm64_byte_carrier_two_scalar_family_linux_test.go b/arm64_byte_carrier_two_scalar_family_linux_test.go
new file mode 100644
index 000000000..290d03ddf
--- /dev/null
+++ b/arm64_byte_carrier_two_scalar_family_linux_test.go
@@ -0,0 +1,10 @@
+//go:build go1.27 && (arm64 || amd64)
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixARM64TwoScalarByteCarrierNativeResults(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	arm64ByteCarrierTwoScalarRuntimeFamily(t, "linux", triple, llc, compiler, runner)
+}
diff --git a/arm64_byte_carrier_two_scalar_go127_test.go b/arm64_byte_carrier_two_scalar_go127_test.go
new file mode 100644
index 000000000..082a230eb
--- /dev/null
+++ b/arm64_byte_carrier_two_scalar_go127_test.go
@@ -0,0 +1,362 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The second parameter is a real declared uint32, not permission to access its
+// following gap. The assembly caller initializes that separate gap explicitly.
+func arm64ByteCarrierTwoScalarFixture(t *testing.T, widths []arm64NativeResultTailCase) (string, string) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath := "example.invalid/twoscalarcarrier"
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package twoscalarcarrier\n\n")
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		fmt.Fprintf(&declarations, "func %s(input uint64, spare uint32) (result uint%d)\n", name, width.resultBits)
+		fmt.Fprintf(&declarations, "func observe_%s(input uint64) (value,native,guard,paramgap uint64)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVD input+0(FP),R0\n%s R0,result+16(FP)\nRET\n",
+			name, 16+width.resultBits/8, width.op)
+		fmt.Fprintf(&assembly, `
+TEXT ·observe_%s(SB),4,$48-40
+    MOVD input+0(FP),R0
+    MOVD R0,8(RSP)
+    MOVD $0xabad1dea00123456,R1
+    MOVD R1,16(RSP)
+    MOVD $0xfeedfacecafebeef,R1
+    MOVD R1,24(RSP)
+    MOVD $0x7ac35ef012345678,R1
+    MOVD R1,32(RSP)
+    CALL ·%s(SB)
+    MOVD 24(RSP),R0
+    MOVD R0,native+16(FP)
+    %s 24(RSP),R0
+    MOVD R0,value+8(FP)
+    MOVD 32(RSP),R0
+    MOVD R0,guard+24(FP)
+    MOVD 16(RSP),R0
+    MOVD R0,paramgap+32(FP)
+    RET
+`, name, name, map[int]string{8: "MOVBU", 16: "MOVHU", 32: "MOVWU"}[width.resultBits])
+	}
+	for name, data := range map[string]string{
+		"go.mod":  "module " + packagePath + "\ngo 1.20\n",
+		"decl.go": declarations.String(), "original_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath
+}
+
+func TestARM64ByteCarrierTwoScalarActualEntryFootprint(t *testing.T) {
+	widths := arm64NativeResultTailCases()
+	directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, widths)
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	source, err := CaptureGoARM64ByteCarrierSource(lease, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatalf("producer precondition: %v", err)
+	}
+	defer source.Close()
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		found := false
+		for _, text := range source.report.Archive[1].Texts {
+			if text.Name != packagePath+"."+name || text.ABI != 1 {
+				continue
+			}
+			found = true
+			entry, err := arm64ByteCarrierTypedEntry(text, source.declarations[name])
+			if err != nil {
+				t.Fatalf("actual two-parameter entry is not closed: %v; code=%x", err, text.Code)
+			}
+			if entry.allocation != 48 || entry.dataStart != 8 || entry.dataBytes != 32 ||
+				entry.callPC != 20 || entry.continuationPC != 24 || len(entry.parameterStores) != 2 ||
+				entry.parameterStores[0].Offset != 8 || entry.parameterStores[0].Bytes != 8 ||
+				entry.parameterStores[1].Offset != 16 || entry.parameterStores[1].Bytes != 4 ||
+				len(entry.resultLoads) != 1 || entry.resultLoads[0].Offset != 24 ||
+				entry.resultLoads[0].Bytes != int64(width.resultBits/8) {
+				t.Fatalf("actual compiler allocation, exact fields or continuation differ: %+v", entry)
+			}
+			t.Logf("actual ABI1 entry %s code=%x allocation=%d callPC=%d continuationPC=%d", name,
+				text.Code, entry.allocation, entry.callPC, entry.continuationPC)
+		}
+		if !found {
+			t.Fatal("original compiler entry is missing")
+		}
+	}
+}
+
+func TestARM64ByteCarrierTwoScalarEntryRejectsFabricatedFields(t *testing.T) {
+	width := arm64NativeResultTailCase{op: "MOVD", resultBits: 32, storeBits: 64}
+	directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, []arm64NativeResultTailCase{width})
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	source, err := CaptureGoARM64ByteCarrierSource(lease, arm64ByteCarrierRequest(t, directory, packagePath))
+	if err != nil {
+		t.Fatalf("producer precondition: %v", err)
+	}
+	defer source.Close()
+	name := strings.ToLower(width.name())
+	var original gostaticstorage.TextRecord
+	for _, text := range source.report.Archive[1].Texts {
+		if text.Name == packagePath+"."+name && text.ABI == 1 {
+			original = text
+		}
+	}
+	if _, err := arm64ByteCarrierTypedEntry(original, source.declarations[name]); err != nil {
+		t.Fatalf("unchanged actual entry positive control failed: %v", err)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func(*gostaticstorage.TextRecord, *FuncSig)
+	}{
+		{"second-store-missing", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[16:], 0xd503201f)
+		}},
+		{"second-store-wrong-register", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[16:], 0xb90013e0)
+		}},
+		{"second-store-authorizes-gap", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[16:], 0xf9000be1)
+		}},
+		{"second-store-in-gap", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[16:], 0xb90017e1)
+		}},
+		{"result-load-from-gap", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code[24:], 0xb94017e0)
+		}},
+		{"result-aliases-saved-FP", func(text *gostaticstorage.TextRecord, _ *FuncSig) {
+			binary.LittleEndian.PutUint32(text.Code, 0xf81e0ffe)
+		}},
+		{"call-at-old-continuation", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Offset = 16 }},
+		{"callee-ABI-not-zero", func(text *gostaticstorage.TextRecord, _ *FuncSig) { text.Relocations[0].Target.ABI = 1 }},
+		{"second-argument-is-pointer", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Args[1] = Ptr }},
+		{"second-argument-is-wide", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Args[1] = I64 }},
+		{"second-field-is-gap", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Params[1].Offset = 12 }},
+		{"second-field-wrong-index", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Params[1].Index = 0 }},
+		{"gap-is-result", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Results[0].Offset = 12 }},
+		{"native-tail-is-field", func(_ *gostaticstorage.TextRecord, signature *FuncSig) { signature.Frame.Results[0].Type = I64 }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			text := original
+			text.Code = append([]byte(nil), original.Code...)
+			text.Relocations = append([]gostaticstorage.TextRelocation(nil), original.Relocations...)
+			declaration := source.declarations[name]
+			declaration.Args = append([]LLVMType(nil), declaration.Args...)
+			declaration.Frame.Params = append([]FrameSlot(nil), declaration.Frame.Params...)
+			declaration.Frame.Results = append([]FrameSlot(nil), declaration.Frame.Results...)
+			test.mutate(&text, &declaration)
+			if _, err := arm64ByteCarrierTypedEntry(text, declaration); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("fabricated two-scalar carrier entry accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ByteCarrierTwoScalarActualSourceTargetMatrix(t *testing.T) {
+	widths := arm64NativeResultTailCases()
+	if len(widths) != 9 {
+		t.Fatal("native-width family is incomplete")
+	}
+	directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, widths)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			request := request
+			request.Target = goos + "/arm64"
+			request.Environment = append([]string(nil), request.Environment...)
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + goos
+				}
+			}
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatalf("producer precondition: %v", err)
+			}
+			defer source.Close()
+			if len(source.report.Calls) != 9 || len(source.report.Standalone) != 18 {
+				t.Fatal("original complete call/body inventory differs")
+			}
+			for _, width := range widths {
+				name := strings.ToLower(width.name())
+				declaration := source.declarations[name]
+				if len(declaration.Frame.Params) != 2 || declaration.Frame.Params[0].Offset != 0 ||
+					declaration.Frame.Params[1].Offset != 8 || declaration.Frame.Params[1].Type != I32 ||
+					len(declaration.Frame.Results) != 1 || declaration.Frame.Results[0].Offset != 16 {
+					t.Fatalf("actual two-scalar fields differ: %+v", declaration.Frame)
+				}
+			}
+			if err := source.Verify(lease); err != nil {
+				t.Fatal(err)
+			}
+			t.Log("actual producer complete: nine callees, nine same-file CALLs, FP0/8 parameters and FP16 result")
+		})
+	}
+}
+
+func TestARM64ByteCarrierTwoScalarNativeWidthConsumers(t *testing.T) {
+	// Reuse immutable compiler artifacts, never a revocable source owner or
+	// a case's original files, temporary outputs or command environment.
+	buildCache := t.TempDir()
+	for _, width := range arm64NativeResultTailCases() {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(width.name()+"/"+api, func(t *testing.T) {
+				// A failed binding revokes its owner. Every case therefore captures
+				// its own actual source; no earlier failure is reused as a RED.
+				directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, []arm64NativeResultTailCase{width})
+				lease, release := runtimeOracleStageContext(t)
+				defer release()
+				request := arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)
+				source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+				if err != nil {
+					t.Fatalf("producer precondition, not consumer RED: %v", err)
+				}
+				defer source.Close()
+				if len(source.report.Calls) != 1 {
+					t.Fatal("original same-file native CALL is missing")
+				}
+				t.Log("actual producer reached P before consumer")
+				goSource, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := mustGoPackage(t, packagePath, string(goSource))
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), "aarch64-unknown-linux-gnu", nil)
+				if err != nil {
+					t.Fatalf("observed two-scalar native-width consumer failed: %v", err)
+				}
+				if !strings.Contains(ir, "(i64 %arg0, i32 %arg1)") || !strings.Contains(ir, "store volatile i32") {
+					t.Fatal("typed second-parameter transport was omitted")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ByteCarrierTwoScalarConsumersRejectUndefinedBytes(t *testing.T) {
+	// Only immutable Go build artifacts are shared. Each case still captures
+	// its own original source, temporary outputs and revocable observation.
+	buildCache := t.TempDir()
+	width := arm64NativeResultTailCase{op: "MOVH", resultBits: 8, storeBits: 16}
+	for _, test := range []struct {
+		name, before, after string
+	}{
+		{"parameter-gap-is-not-defined", "MOVD R1,16(RSP)", "MOVW R1,16(RSP)"},
+		{"native-result-tail-is-not-defined", "MOVD R1,24(RSP)", "MOVW R1,24(RSP)"},
+		{"outgoing-input-is-not-defined", "MOVD R0,8(RSP)", "MOVW R0,8(RSP)"},
+		{"saved-LR-is-not-data", "MOVD R0,paramgap+32(FP)", "MOVD R0,paramgap+32(FP)\n    MOVD R0,0(RSP)"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, []arm64NativeResultTailCase{width})
+				filename := filepath.Join(directory, "original_arm64.s")
+				original, err := os.ReadFile(filename)
+				if err != nil {
+					t.Fatal(err)
+				}
+				assembly := strings.Replace(string(original), test.before, test.after, 1)
+				if assembly == string(original) {
+					t.Fatal("negative did not change the actual source")
+				}
+				if err := os.WriteFile(filename, []byte(assembly), 0600); err != nil {
+					t.Fatal(err)
+				}
+				lease, release := runtimeOracleStageContext(t)
+				defer release()
+				request := arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)
+				source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+				if err != nil {
+					t.Fatalf("original producer precondition: %v", err)
+				}
+				defer source.Close()
+				declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := mustGoPackage(t, packagePath, string(declarations))
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, assembly, "aarch64-unknown-linux-gnu", nil)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("undefined or protected bytes granted output: %v", err)
+				}
+				if !errors.Is(source.Verify(lease), ErrProbeNeedsContext) {
+					t.Fatal("failed byte proof did not revoke its original owner")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ByteCarrierTwoScalarFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	widths := append(arm64NativeResultTailCases(), arm64NativeResultTailCase{op: "MOVW", resultBits: 32, storeBits: 32})
+	directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, widths)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	base := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, target := range []struct{ goos, triple string }{
+		{"darwin", "aarch64-apple-darwin"}, {"linux", "aarch64-unknown-linux-gnu"},
+		{"windows", "aarch64-pc-windows-msvc"}, {"freebsd", "aarch64-unknown-freebsd"},
+		{"openbsd", "aarch64-unknown-openbsd"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			request := base
+			request.Target = target.goos + "/arm64"
+			request.Environment = append([]string(nil), base.Environment...)
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + target.goos
+				}
+			}
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatalf("original producer precondition: %v", err)
+			}
+			defer source.Close()
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), target.triple, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "two-scalar.ll", "two-scalar.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_byte_carrier_two_scalar_runtime_go127_test.go b/arm64_byte_carrier_two_scalar_runtime_go127_test.go
new file mode 100644
index 000000000..4ce4b5541
--- /dev/null
+++ b/arm64_byte_carrier_two_scalar_runtime_go127_test.go
@@ -0,0 +1,166 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func arm64ByteCarrierTwoScalarRuntimeFamily(t *testing.T, goos, triple, llc string, compiler, runner []string) {
+	t.Helper()
+	widths := append(arm64NativeResultTailCases(), arm64NativeResultTailCase{op: "MOVW", resultBits: 32, storeBits: 32})
+	directory, packagePath := arm64ByteCarrierTwoScalarFixture(t, widths)
+	// This independent exact-width control actually consumes the second
+	// parameter. An unused argument or IR spelling alone cannot prove transport.
+	for name, extra := range map[string]string{
+		"decl.go":          "func read_spare(input uint64, spare uint32) (result uint32)\n",
+		"original_arm64.s": "TEXT ·read_spare(SB),4,$0-20\nMOVWU spare+8(FP),R0\nMOVW R0,result+16(FP)\nRET\n",
+	} {
+		filename := filepath.Join(directory, name)
+		original, err := os.ReadFile(filename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filename, append(original, []byte(extra)...), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs := arm64PaddingRuntimeInputs()
+	var original strings.Builder
+	original.WriteString("package twoscalarcarrier\nimport \"testing\"\nfunc TestOriginalTwoScalarFamily(t *testing.T) {\n")
+	original.WriteString("for _, spare := range []uint32{0,1,0x123456,0x89abcdef,0xffffffff} {\n" +
+		"if read_spare(0x123456789abcdef0, spare) != spare { t.Fatal(\"second parameter transport mismatch\") }\n}\n")
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		resultMask := ^uint64(0) >> uint(64-width.resultBits)
+		storeMask := ^uint64(0) >> uint(64-width.storeBits)
+		for _, input := range inputs {
+			fmt.Fprintf(&original, `{ value,native,guard,paramgap := observe_%s(0x%x)
+if value != 0x%x || native != 0x%x || guard != 0x7ac35ef012345678 || paramgap != 0xabad1dea00123456 {
+    t.Fatal("%s native result, adjacent guard or parameter/gap canary mismatch")
+} }
+`, name, input, input&resultMask, uint64(0xfeedfacecafebeef)&^storeMask|input&storeMask, name)
+		}
+	}
+	marker := fmt.Sprintf("ACTUAL_TWO_SCALAR_CARRIER_FAMILY %d", len(widths)*len(inputs))
+	fmt.Fprintf(&original, "t.Log(%q)\n}\n", marker)
+	if err := os.WriteFile(filepath.Join(directory, "original_test.go"), []byte(original.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	request.Target = goos + "/arm64"
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOOS=") {
+			request.Environment[index] = "GOOS=" + goos
+		}
+	}
+	lease, release := runtimeOracleStageContext(t)
+	defer release()
+	arguments := []string{"test", "-p=1", "-mod=readonly", "-run=^TestOriginalTwoScalarFamily$", "-count=1", "-v"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(arguments, "-exec="+quoted)
+	}
+	command := exec.CommandContext(lease, request.GoBinary, append(arguments, ".")...)
+	command.Dir, command.Env = directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(lease, command)
+	if err != nil || strings.Count(string(output), marker) != 1 || !strings.Contains(string(output), "--- PASS: TestOriginalTwoScalarFamily") {
+		t.Fatalf("original Go two-scalar whole-cell/canary precondition: %v\n%s", err, output)
+	}
+	t.Logf("actual original Go %s two-scalar observations: %d", request.Target, len(widths)*len(inputs))
+	source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+	if err != nil {
+		t.Fatalf("producer precondition: %v", err)
+	}
+	defer source.Close()
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	checks, driver := arm64ByteCarrierTwoScalarRuntimeChecks(packagePath, widths, inputs)
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, optimization := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", api, optimization), func(t *testing.T) {
+				ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), triple, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "two_scalar_carrier_family", triple, ir+checks, driver, runner, optimization)
+				t.Logf("actual LLVM22 %s O%d two-scalar observations: %d", api, optimization, len(widths)*len(inputs))
+			})
+		}
+	}
+}
+
+func arm64ByteCarrierTwoScalarRuntimeChecks(packagePath string, widths []arm64NativeResultTailCase, inputs []uint64) (string, string) {
+	var checks, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\nextern uint32_t observe_second_parameter(uint32_t);\n")
+	fmt.Fprintf(&checks, `
+define i32 @observe_second_parameter(i32 %%spare) {
+    %%result = call i32 %s(i64 1311768467463790320, i32 %%spare)
+    ret i32 %%result
+}
+`, llvmGlobal(packagePath+".read_spare"))
+	for _, width := range widths {
+		name := strings.ToLower(width.name())
+		resultMask := ^uint64(0) >> uint(64-width.resultBits)
+		storeMask := ^uint64(0) >> uint(64-width.storeBits)
+		fmt.Fprintf(&driver, "extern int32_t check_%s(uint64_t);\n", name)
+		// C only calls an explicit scalar status shim. LLVM aggregate return
+		// conventions are not assumed to match a C struct ABI.
+		fmt.Fprintf(&checks, `
+define i32 @check_%s(i64 %%input) {
+    %%scalar = call i%d %s(i64 %%input, i32 1193046)
+    %%scalar_wide = zext i%d %%scalar to i64
+    %%result = call { i64, i64, i64, i64 } %s(i64 %%input)
+    %%value = extractvalue { i64, i64, i64, i64 } %%result, 0
+    %%native = extractvalue { i64, i64, i64, i64 } %%result, 1
+    %%guard = extractvalue { i64, i64, i64, i64 } %%result, 2
+    %%paramgap = extractvalue { i64, i64, i64, i64 } %%result, 3
+    %%low = and i64 %%input, %d
+    %%store = and i64 %%input, %d
+    %%expected = or i64 %%store, %d
+    %%scalar_ok = icmp eq i64 %%scalar_wide, %%low
+    %%typed_ok = icmp eq i64 %%value, %%low
+    %%native_ok = icmp eq i64 %%native, %%expected
+    %%guard_ok = icmp eq i64 %%guard, %d
+    %%paramgap_ok = icmp eq i64 %%paramgap, %d
+    %%values = and i1 %%scalar_ok, %%typed_ok
+    %%bytes = and i1 %%native_ok, %%guard_ok
+    %%both = and i1 %%values, %%bytes
+    %%all = and i1 %%both, %%paramgap_ok
+    %%status = select i1 %%all, i32 0, i32 1
+    ret i32 %%status
+}
+`, name, width.resultBits, llvmGlobal(packagePath+"."+name), width.resultBits,
+			llvmGlobal(packagePath+".observe_"+name), resultMask, storeMask,
+			uint64(0xfeedfacecafebeef)&^storeMask, uint64(0x7ac35ef012345678), uint64(0xabad1dea00123456))
+	}
+	driver.WriteString("int main(void) {\n" +
+		"static const uint32_t spares[] = {0,1,0x123456,0x89abcdef,0xffffffff};\n" +
+		"for (unsigned i=0; i<sizeof(spares)/sizeof(spares[0]); i++) {\n" +
+		"if (observe_second_parameter(spares[i]) != spares[i]) return 1;\n}\n" +
+		"static const uint64_t inputs[] = {\n")
+	for _, input := range inputs {
+		fmt.Fprintf(&driver, "UINT64_C(0x%x),\n", input)
+	}
+	driver.WriteString("};\nfor (unsigned i=0; i<sizeof(inputs)/sizeof(inputs[0]); i++) {\n")
+	for _, width := range widths {
+		fmt.Fprintf(&driver, "if (check_%s(inputs[i])) return 1;\n", strings.ToLower(width.name()))
+	}
+	driver.WriteString("}\nreturn 0;\n}\n")
+	return checks.String(), driver.String()
+}
diff --git a/arm64_bytealg_count_sdk_binding_test.go b/arm64_bytealg_count_sdk_binding_test.go
new file mode 100644
index 000000000..31e29c9e8
--- /dev/null
+++ b/arm64_bytealg_count_sdk_binding_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64BytealgCountSDKTranslate(t *testing.T, pkg GoPackage, source []byte, target, api string) (string, error) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	if api == "GoModule" {
+		translated, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return translated.Module.String(), nil
+	}
+	file, err := Parse(ArchARM64, string(source))
+	if err != nil {
+		return "", err
+	}
+	sigs := make(map[string]FuncSig)
+	for _, name := range []string{"Count", "CountString"} {
+		function, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			return "", fmt.Errorf("missing actual SDK Count declaration: %s", name)
+		}
+		sig, err := DeriveGoFuncABI0Signature(name, function, "arm64", types.SizesFor("gc", "arm64"))
+		if err != nil {
+			return "", err
+		}
+		for _, root := range file.Funcs {
+			if resolve(root.Sym) == name && strings.HasSuffix(root.Sym, "<ABIInternal>") {
+				sig.ARM64GoRegisterABI, err = DeriveARM64GoRegisterABI(function, sig)
+				if err != nil {
+					return "", err
+				}
+			}
+		}
+		sigs[name] = sig
+	}
+	sigs, err = BindGoARM64ABI0TailDeclarations(pkg, file, resolve, sigs)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return module.String(), nil
+}
+
+func TestARM64BytealgCountSDKSourceAllAPIsObjects(t *testing.T) {
+	pkg := arm64BytealgCountSDKPackage(t)
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg", "count_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(target, func(t *testing.T) {
+			var reference string
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64BytealgCountSDKTranslate(t, pkg, source, target, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					canonical := indirectMarkerComparableIR(ir)
+					if reference != "" && canonical != reference {
+						t.Fatal("three public APIs changed the original SDK Count source semantics")
+					}
+					reference = canonical
+					compileLLVMToObject(t, llc, target, "sdk-count.ll", "sdk-count.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64BytealgCountSDKSourceBindingRejectsCopiedInventory(t *testing.T) {
+	pkg := arm64BytealgCountSDKPackage(t)
+	// First-party ABI0 continuation with the actual SDK Count declaration.
+	// It is an object/source-identity fixture, not an alternative Count oracle.
+	const source = `TEXT ·Count(SB),516,$0-40
+MOVD b_len+8(FP),R11
+MOVD $ret+32(FP),R8
+B countresult<>(SB)
+TEXT countresult<>(SB),516,$0
+MOVD R11,(R8)
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, axis := range []string{"missing selection", "copied declaration", "changed source bytes", "empty source inventory"} {
+		t.Run(axis, func(t *testing.T) {
+			changed := pkg
+			selection := *pkg.SourceSelection
+			selection.GoSources = make(map[string][]byte)
+			for name, data := range pkg.SourceSelection.GoSources {
+				selection.GoSources[name] = append([]byte(nil), data...)
+			}
+			changed.SourceSelection = &selection
+			switch axis {
+			case "missing selection":
+				changed.SourceSelection = nil
+			case "copied declaration":
+				changed = mustGoPackage(t, pkg.Path, "package bytealg\nfunc Count(b []byte,c byte) int\nfunc CountString(s string,c byte) int\n")
+			case "changed source bytes":
+				for name := range selection.GoSources {
+					if filepath.Base(name) == "count_native.go" {
+						selection.GoSources[name] = []byte(strings.Replace(string(selection.GoSources[name]), "func Count(b", "func Other(b", 1))
+					}
+				}
+			case "empty source inventory":
+				selection.SelectedGoFiles = nil
+				selection.GoSources = map[string][]byte{}
+			}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64BytealgCountSDKTranslate(t, changed, []byte(source), "aarch64-unknown-linux-gnu", api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("invented SDK declaration/source input acquired ABI0 continuation permission: %v", err)
+					}
+				})
+			}
+		})
+	}
+	if ir, err := arm64BytealgCountSDKTranslate(t, pkg, []byte(source), "aarch64-unknown-linux-gnu", "GoModule"); err != nil || ir == "" {
+		t.Fatalf("same unmodified actual SDK declaration/source control failed: %v", err)
+	}
+}
diff --git a/arm64_call_copy_loop_test.go b/arm64_call_copy_loop_test.go
new file mode 100644
index 000000000..f96c5d1d3
--- /dev/null
+++ b/arm64_call_copy_loop_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Derive the external call from the current Go toolchain's real declaration.
+// The test supplies no guessed register inputs or memory/noalias annotation.
+func arm64CallInputMemmoveSig(t *testing.T) FuncSig {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, filepath.Join(testGOROOT(t), "src/runtime/stubs.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var source bytes.Buffer
+	for _, declaration := range file.Decls {
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == "memmove" {
+			if err := format.Node(&source, fset, fn); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if source.Len() == 0 {
+		t.Fatal("actual runtime memmove declaration not found")
+	}
+	pkg := arm64PrivateCallDeclarations(t, source.String())
+	sizes := types.SizesFor("gc", "arm64")
+	sig, err := goFuncSigForDeclaredFunc("memmove", pkg.Types.Scope().Lookup("memmove").(*types.Func), "arm64", sizes, sizes, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return sig
+}
+
+func arm64CallCopyLoopSource(call, copyBody string) string {
+	return fmt.Sprintf(`#include "textflag.h"
+TEXT ·CopyLoop(SB),NOSPLIT,$56-32
+	MOVD dst+0(FP),R7
+	MOVD src+8(FP),R6
+	MOVD n+16(FP),R4
+	CBZ R4,done
+	MOVD R7,8(RSP)
+	MOVD R6,16(RSP)
+	MOVD $1,R5
+	MOVD R5,24(RSP)
+	MOVD R7,32(RSP)
+	MOVD R6,40(RSP)
+	MOVD R4,48(RSP)
+	%s runtime·memmove(SB)
+	MOVD 32(RSP),R7
+	MOVD 40(RSP),R6
+	MOVD 48(RSP),R4
+	ADD $1,R7
+	ADD $1,R6
+	MOVD dst+0(FP),R1
+	MOVD n+16(FP),R3
+	ADD R3,R1,R8
+	SUB R7,R8,R4
+loop:
+	CMP $16,R4
+	BLT bytes
+%s
+	ADD $16,R7
+	ADD $16,R6
+	SUB $16,R4
+	B loop
+bytes:
+	CBZ R4,done
+	MOVBU (R6),R5
+	MOVB R5,(R7)
+	ADD $1,R7
+	ADD $1,R6
+	SUB $1,R4
+	B bytes
+done:
+	MOVD n+16(FP),R0
+	MOVD R0,ret+24(FP)
+	RET
+`, call, copyBody)
+}
+
+func arm64CallCopyLoopModule(t *testing.T, source, target string) string {
+	t.Helper()
+	pkg := arm64PrivateCallDeclarations(t, "func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr\n")
+	callee := arm64CallInputMemmoveSig(t)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: target,
+		ResolveSym: func(sym string) string {
+			return strings.ReplaceAll(goStripABISuffix(strings.TrimPrefix(sym, "·")), "·", ".")
+		},
+		ManualSig: func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer bound.Module.Dispose()
+	return bound.Module.String()
+}
+
+func TestARM64TypedCallReloadCopyLoopObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	pkg := arm64PrivateCallDeclarations(t, "func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr\n")
+	callee := arm64CallInputMemmoveSig(t)
+	resolve := func(sym string) string {
+		return strings.ReplaceAll(goStripABISuffix(strings.TrimPrefix(sym, "·")), "·", ".")
+	}
+	for _, call := range []string{"CALL", "BL"} {
+		for _, tc := range []struct{ name, body string }{
+			{"scalar", "MOVD (R6),R2\nMOVD 8(R6),R5\nMOVD R2,(R7)\nMOVD R5,8(R7)"},
+			{"pair", "LDP (R6),(R2,R5)\nSTP (R2,R5),(R7)"},
+		} {
+			source := arm64CallCopyLoopSource(call, tc.body)
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				t.Run(call+"_"+tc.name+"_"+target, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+						GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+						ManualSig: func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" },
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer bound.Module.Dispose()
+					compileLLVMToObject(t, llc, target, "go-call-loop.ll", "go-call-loop.o", bound.Module.String())
+					opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: bound.Signatures}
+					text, err := Translate(file, opt)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target, "text-call-loop.ll", "text-call-loop.o", text)
+					module, err := TranslateModuleInContext(ctx, file, opt)
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer module.Dispose()
+					compileLLVMToObject(t, llc, target, "module-call-loop.ll", "module-call-loop.o", module.String())
+				})
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64TypedCallReloadCopyLoop(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, call := range []string{"CALL", "BL"} {
+		for _, tc := range []struct{ name, body string }{
+			{"scalar", "MOVD (R6),R2\nMOVD 8(R6),R5\nMOVD R2,(R7)\nMOVD R5,8(R7)"},
+			{"pair", "LDP (R6),(R2,R5)\nSTP (R2,R5),(R7)"},
+		} {
+			t.Run(call+"_"+tc.name, func(t *testing.T) {
+				source := arm64CallCopyLoopSource(call, tc.body)
+				runARM64LocalRegisterGoOracle(t, source, `package main
+import "unsafe"
+func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr
+func main() {
+ for _, n := range []int{0,1,2,7,8,16,17,31,32,33,64,131} {
+  for _, d := range []int{0,1,3,17} {
+   for _, s := range []int{0,1,5,19} {
+    var dst, want, src [160]byte
+    for i := range dst { dst[i]=0xa7; want[i]=0xa7; src[i]=byte(i*37+n*11) }
+    for i:=0;i<n;i++ { want[d+i]=src[s+i] }
+    if CopyLoop(unsafe.Pointer(&dst[d]),unsafe.Pointer(&src[s]),uintptr(n))!=uintptr(n) || dst!=want {
+     panic("actual Go typed CALL/spill/FP-reload/copy-loop mismatch")
+    }
+   }
+  }
+ }
+}
+
+`, len(runner) != 0, "1.20")
+				t.Log("actual Go passed 192 complete-buffer/canary vectors")
+				ir := arm64CallCopyLoopModule(t, source, target)
+				const driver = `#include <stdint.h>
+#include <string.h>
+extern uint64_t CopyLoop(void *, const void *, uint64_t);
+int main(void) {
+ const int sizes[]={0,1,2,7,8,16,17,31,32,33,64,131};
+ const int dstOffsets[]={0,1,3,17}, srcOffsets[]={0,1,5,19};
+ for(int z=0;z<12;z++) {
+  for(int d=0;d<4;d++) {
+   for(int s=0;s<4;s++) {
+    unsigned char dst[160],want[160],src[160];
+    int n=sizes[z],di=dstOffsets[d],si=srcOffsets[s];
+    for(int i=0;i<160;i++) { dst[i]=want[i]=0xa7; src[i]=(unsigned char)(i*37+n*11); }
+    memcpy(want+di,src+si,n);
+    if(CopyLoop(dst+di,src+si,(uint64_t)n)!=(uint64_t)n || memcmp(dst,want,160)) return 1;
+   }
+  }
+ }
+ return 0;
+}
+`
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "call_reload_copy_loop", target, ir, driver, runner)
+			})
+		}
+	}
+}
diff --git a/arm64_call_float_result_test.go b/arm64_call_float_result_test.go
new file mode 100644
index 000000000..ab83f6bad
--- /dev/null
+++ b/arm64_call_float_result_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64TypedCallFloatBits(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·FloatResult(SB),4,$24-16
+MOVD a+0(FP),R5
+MOVD R5,8(RSP)
+CALL ·X(SB)
+FMOVD 16(RSP),F0
+FMOVD F0,R5
+MOVD R5,ret+8(FP)
+RET
+`
+	runARM64LocalRegisterGoOracle(t, source, `package main
+import "math"
+func FloatResult(uint64) uint64
+func X(a uint64) float64 { return math.Float64frombits(a) }
+func main() {
+ for _, a := range []uint64{0,1,0x3ff0000000000000,0x7ff8123456789abc,0x8000000000000000,^uint64(0)} {
+  if got:=FloatResult(a); got!=a { println(got,a); panic("actual Go unsigned-to-floating bit transport") }
+ }
+}
+`, len(runner) != 0, "1.20")
+	pkg := mustGoPackage(t, "test/floatbits", "package floatbits\nfunc FloatResult(uint64) uint64\nfunc X(uint64) float64\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: target,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer bound.Module.Dispose()
+	const driver = `#include <stdint.h>
+#include <string.h>
+extern uint64_t FloatResult(uint64_t);
+double X(uint64_t value) {
+ double result;
+ memcpy(&result,&value,sizeof result);
+ return result;
+}
+int main(void) {
+ const uint64_t inputs[]={0,1,UINT64_C(0x3ff0000000000000),UINT64_C(0x7ff8123456789abc),UINT64_C(0x8000000000000000),UINT64_MAX};
+ for(unsigned i=0;i<sizeof inputs/sizeof inputs[0];i++) {
+  if(FloatResult(inputs[i])!=inputs[i]) return 1;
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "typed_call_float_bits", target, bound.Module.String(), driver, runner)
+}
diff --git a/arm64_call_input_provenance.go b/arm64_call_input_provenance.go
new file mode 100644
index 000000000..b8dda02c1
--- /dev/null
+++ b/arm64_call_input_provenance.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+)
+
+// Read the same leaves that callSym transports through an ordinary LLVM call.
+// A callee cannot implicitly read the caller's virtual register allocas. This
+// describes transport only: it proves neither caller-save preservation nor
+// incoming pointer ownership. Unmodeled hidden inputs keep the legacy fallback.
+func arm64ControlCallInputs(state *arm64ControlState, sig FuncSig, internal bool) ([]arm64ControlValue, bool) {
+	if sig.ARM64ClosureABI != nil {
+		return nil, false
+	}
+	var inputs []arm64ControlValue
+	if internal && sig.ARM64GoRegisterABI != nil {
+		if arm64ValidateGoRegisterABI(sig) != nil {
+			return nil, false
+		}
+		for _, param := range sig.ARM64GoRegisterABI.Params {
+			inputs = append(inputs, arm64ControlRead(state.regs, param.Register))
+		}
+		return inputs, true
+	}
+	if internal && len(sig.ArgRegs) == 0 {
+		return nil, false
+	}
+	if !internal && len(sig.ArgRegs) == 0 && len(sig.Frame.Params) != 0 {
+		seen := make([]bool, len(sig.Args))
+		for _, param := range sig.Frame.Params {
+			width := arm64MachineScalarWidth(param.Type)
+			if param.Index < 0 || param.Index >= len(seen) || width == 0 || param.Offset > 1<<63-1-8 {
+				return nil, false
+			}
+			seen[param.Index] = true
+			inputs = append(inputs, arm64ControlCallFrameRead(state, param.Offset+8, width))
+		}
+		for _, present := range seen {
+			if !present {
+				return nil, false
+			}
+		}
+		return inputs, true
+	}
+	if len(sig.ArgRegs) != 0 {
+		if len(sig.ArgRegs) != len(sig.Args) {
+			return nil, false
+		}
+		for index, typ := range sig.Args {
+			if !isARM64ABIIntegerType(typ) && !isARM64ABIFloatingType(typ) {
+				return nil, false
+			}
+			reg := sig.ArgRegs[index]
+			_, floating := arm64ParseFReg(reg)
+			if !isARM64GeneralOrZeroReg(reg) && !arm64StackReg(reg) && !floating {
+				return nil, false
+			}
+			inputs = append(inputs, arm64ControlRead(state.regs, reg))
+		}
+		return inputs, true
+	}
+	// Match abiRegisterCallArgs' independent GP/FP cursors and flat aggregate
+	// fields. Nested aggregates/arrays are not silently treated as one GP.
+	var cursor arm64ABIRegisterCursor
+	for _, typ := range sig.Args {
+		fields, aggregate := parseLiteralStructFields(typ)
+		if !aggregate {
+			fields = []LLVMType{typ}
+		}
+		for _, field := range fields {
+			reg, err := cursor.next(field)
+			if err != nil {
+				return nil, false
+			}
+			inputs = append(inputs, arm64ControlRead(state.regs, reg))
+		}
+	}
+	return inputs, true
+}
+
+// Control cells conservatively describe eight bytes. An unaligned/narrow
+// transport must include overlapping address witnesses, not only its exact
+// memory key. Unsigned differences avoid signed subtraction overflow.
+func arm64ControlCallFrameRead(state *arm64ControlState, offset int64, width int) arm64ControlValue {
+	value := state.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP, Off: offset}}, false)
+	for key, cell := range state.memory {
+		if !strings.HasPrefix(key, "sp:") {
+			continue
+		}
+		start, err := strconv.ParseInt(key[3:], 10, 64)
+		if err == nil && ((start <= offset && uint64(offset)-uint64(start) < 8) ||
+			(start > offset && uint64(start)-uint64(offset) < uint64((width+7)/8))) {
+			value = arm64ControlUnion(value, arm64ControlAddressTaint(cell))
+		}
+	}
+	return value
+}
diff --git a/arm64_call_input_provenance_test.go b/arm64_call_input_provenance_test.go
new file mode 100644
index 000000000..ea220a8d1
--- /dev/null
+++ b/arm64_call_input_provenance_test.go
@@ -0,0 +1,327 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64TypedCallCodeProvenanceComesFromTransport(t *testing.T) {
+	for _, tc := range []struct {
+		name, argument, escaped string
+		known, proof, frame     bool
+		wantContinuation        bool
+	}{
+		{name: "private_typed", known: true, proof: true, frame: true},
+		{name: "actual_code_argument", known: true, proof: true, frame: true, argument: "label:argument"},
+		{name: "already_escaped_code", known: true, proof: true, frame: true, escaped: "label:escaped"},
+		{name: "unknown_target", proof: true, frame: true, wantContinuation: true},
+		{name: "zero_default", known: true, frame: true, wantContinuation: true},
+		{name: "no_source_frame", known: true, proof: true, wantContinuation: true},
+		{name: "escaped_private_frame", known: true, proof: true, frame: true, escaped: "sp:16", wantContinuation: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			sig := FuncSig{Name: "callee", Args: []LLVMType{Ptr}, Ret: I64,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			}
+			state := &arm64ControlState{
+				unexposedSP: tc.proof,
+				regs: map[Reg]arm64ControlValue{
+					SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R30": arm64ControlFromMap(map[string]bool{"label:continuation": true}),
+					"R19": arm64ControlFromMap(map[string]bool{"label:source_witness": true}),
+				},
+				memory: map[string]arm64ControlValue{
+					"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true}), "sp:8": arm64ControlFromMap(map[string]bool{tc.argument: true}), "fp:0": arm64ControlExternal(),
+				},
+			}
+			if tc.escaped != "" {
+				state.escaped = arm64ControlFromMap(map[string]bool{tc.escaped: true})
+			}
+			ctx := &arm64Ctx{resolve: func(s string) string { return strings.TrimSuffix(s, "(SB)") },
+				sigs: map[string]FuncSig{}, sourceGoFrame: arm64GoFrame{present: tc.frame}, unexposedCallFrame: tc.proof,
+			}
+			if tc.known {
+				ctx.sigs["callee"] = sig
+			}
+			ctx.invalidateControlCallResults(state, Operand{Kind: OpSym, Sym: "callee(SB)"})
+			for name, value := range map[string]arm64ControlValue{"result": state.regs["R0"], "fp": state.memory["fp:0"]} {
+				if arm64ControlHas(value, "label:continuation") != tc.wantContinuation {
+					t.Errorf("%s inherited an untransported automatic link: %v", name, value)
+				}
+				if !tc.wantContinuation && arm64ControlHas(value, "label:source_witness") {
+					t.Errorf("%s inherited an untransported virtual GP: %v", name, value)
+				}
+				if tc.argument != "" && !arm64ControlHas(value, tc.argument) || tc.escaped != "" && strings.HasPrefix(tc.escaped, "label:") && !arm64ControlHas(value, tc.escaped) {
+					t.Errorf("%s lost genuinely observable source code: %v", name, value)
+				}
+			}
+			if !arm64ControlHas(state.regs["R19"], "label:source_witness") || !arm64ControlHas(state.regs["R19"], "") {
+				t.Fatal("typed transport cannot prove caller-save GP preservation or erase its old code witness")
+			}
+			if !arm64ControlHas(state.memory["fp:0"], "") {
+				t.Fatal("fresh private SP does not protect potentially aliased caller FP contents")
+			}
+		})
+	}
+}
+
+func TestARM64TypedCallFPViewsRetainActualSourcePC(t *testing.T) {
+	pkg := mustGoPackage(t, "test/pcviews", "package pcviews\nfunc PCArg(p *uint64)\nfunc X(uint64) uint64\n")
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	for _, input := range []string{
+		"VMOV R30,V0.D[0]\nFMOVD F0,R5",
+		"FMOVD R30,F0\nVMOV V0.D[0],R5",
+	} {
+		t.Run(input, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT ·PCArg(SB),4,$32-8\n%s\nMOVD R5,8(RSP)\nCALL ·X(SB)\nMOVD 16(RSP),R5\nADD $4,R5\nMOVD p+0(FP),R6\nMOVD R5,(R6)\nRET\n", input)
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", "arm64")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				if _, err := Translate(file, Options{Goarch: "arm64", Sigs: sigs, ResolveSym: resolve, TargetTriple: target}); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Translate washed away the actual caller-PC argument: %v", target, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, Options{Goarch: "arm64", Sigs: sigs, ResolveSym: resolve, TargetTriple: target})
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Module washed away the actual caller-PC argument: %v", target, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", ResolveSym: resolve, TargetTriple: target})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s GoModule washed away the actual caller-PC argument: %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64TypedCallInputsMatchEmittedTransports(t *testing.T) {
+	state := &arm64ControlState{
+		regs: map[Reg]arm64ControlValue{
+			SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R0": arm64ControlFromMap(map[string]bool{"label:r0": true}), "R1": arm64ControlFromMap(map[string]bool{"label:r1": true}),
+			"R2": arm64ControlFromMap(map[string]bool{"label:r2": true}), "R30": arm64ControlFromMap(map[string]bool{"label:link": true}),
+			"F0": arm64ControlFromMap(map[string]bool{"label:f0": true}), "V0.D[0]": arm64ControlFromMap(map[string]bool{"label:v0": true}), "Z0.D": arm64ControlFromMap(map[string]bool{"label:z0": true}),
+			"F1": arm64ControlFromMap(map[string]bool{"label:f1": true}),
+		},
+		memory: map[string]arm64ControlValue{
+			"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true}), "sp:8": arm64ControlFromMap(map[string]bool{"label:slot0": true}), "sp:16": arm64ControlFromMap(map[string]bool{"label:slot1": true}),
+		},
+	}
+	registerSig := FuncSig{Args: []LLVMType{"double", I64, "{ i64, double }", Ptr}, Ret: Void}
+	internalSig := registerSig
+	var err error
+	internalSig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(internalSig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		name     string
+		sig      FuncSig
+		internal bool
+		want     []string
+	}{
+		{"independent_gp_fp_banks", registerSig, false, []string{"label:f0", "label:r0", "label:r1", "label:f1", "label:r2"}},
+		{"internal_recursive_banks", internalSig, true, []string{"label:f0", "label:r0", "label:r1", "label:f1", "label:r2"}},
+		{"custom_link_is_real_input", FuncSig{Args: []LLVMType{I64}, ArgRegs: []Reg{"R30"}}, false, []string{"label:link"}},
+		{"custom_sp_is_real_input", FuncSig{Args: []LLVMType{Ptr}, ArgRegs: []Reg{"RSP"}}, false, []string{"sp:0"}},
+		{"zero_args_present_internal", FuncSig{Ret: Void, ARM64GoRegisterABI: &ARM64GoRegisterABI{}}, true, nil},
+		{"classic_aggregate_fields", FuncSig{Args: []LLVMType{"{ ptr, i64 }"}, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: 0}, {Offset: 8, Type: I64, Index: 0, Field: 1},
+		}}}, false, []string{"label:slot0", "label:slot1"}},
+		{"unaligned_saved_link_overlap", FuncSig{Args: []LLVMType{I32}, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: -7, Type: I32, Index: 0, Field: -1},
+		}}}, false, []string{"label:caller"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			inputs, known := arm64ControlCallInputs(state, tc.sig, tc.internal)
+			if !known || len(inputs) != len(tc.want) {
+				t.Fatalf("emitted typed transport not recognized: known=%t inputs=%v", known, inputs)
+			}
+			for index, token := range tc.want {
+				if !arm64ControlHas(inputs[index], token) {
+					t.Errorf("transport leaf %d lost %s: %v", index, token, inputs[index])
+				}
+			}
+			if len(inputs) != 0 && isARM64ABIFloatingType(tc.sig.Args[0]) {
+				for _, alias := range []string{"label:v0", "label:z0"} {
+					if !arm64ControlHas(inputs[0], alias) {
+						t.Errorf("physical FP/V/Z input alias lost %s: %v", alias, inputs[0])
+					}
+				}
+			}
+		})
+	}
+	// A covering scalar write is not permission to forget another physical
+	// view's code witness: this proof does not model every partial SIMD write.
+	state.write(Operand{Kind: OpReg, Reg: "F0"}, arm64ControlExternal(), false)
+	if value := arm64ControlRead(state.regs, "F0"); !arm64ControlHas(value, "label:v0") || !arm64ControlHas(value, "label:z0") {
+		t.Fatalf("covering write silently discarded aliases: %v", value)
+	}
+	for _, tc := range []struct {
+		name     string
+		sig      FuncSig
+		internal bool
+	}{
+		{"hidden_carrier", FuncSig{ARM64ClosureABI: &ARM64ClosureABI{}}, false},
+		{"missing_internal_contract", FuncSig{Ret: Void}, true},
+		{"partial_custom_registers", FuncSig{Args: []LLVMType{Ptr, I64}, ArgRegs: []Reg{"R0"}}, false},
+		{"invalid_custom_register", FuncSig{Args: []LLVMType{Ptr}, ArgRegs: []Reg{"R40"}}, false},
+		{"custom_aggregate", FuncSig{Args: []LLVMType{"{ ptr, i64 }"}, ArgRegs: []Reg{"R0"}}, false},
+		{"nested_generic_aggregate", FuncSig{Args: []LLVMType{"{ ptr, { i64, double } }"}}, false},
+		{"unknown_scalar", FuncSig{Args: []LLVMType{"unrecognized"}}, false},
+		{"gp_bank_overflow", FuncSig{Args: makeRepeatedARM64CallTypes(I64, 17)}, false},
+		{"fp_bank_overflow", FuncSig{Args: makeRepeatedARM64CallTypes("double", 17)}, false},
+		{"frame_offset_overflow", FuncSig{Args: []LLVMType{Ptr}, Frame: FrameLayout{Params: []FrameSlot{{Offset: 1<<63 - 1, Type: Ptr, Index: 0, Field: -1}}}}, false},
+		{"missing_frame_parameter", FuncSig{Args: []LLVMType{Ptr, I64}, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}, false},
+		{"unknown_frame_width", FuncSig{Args: []LLVMType{Ptr}, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: "unrecognized", Index: 0, Field: -1}}}}, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if _, known := arm64ControlCallInputs(state, tc.sig, tc.internal); known {
+				t.Fatal("unproved typed input transport accepted")
+			}
+		})
+	}
+	for _, mutate := range []func(*ARM64GoRegisterABI){
+		func(abi *ARM64GoRegisterABI) { abi.Params = abi.Params[:len(abi.Params)-1] },
+		func(abi *ARM64GoRegisterABI) { abi.Params[0].Register = "R0" },
+	} {
+		sig := registerSig
+		sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+		if err != nil {
+			t.Fatal(err)
+		}
+		mutate(sig.ARM64GoRegisterABI)
+		if _, known := arm64ControlCallInputs(state, sig, true); known {
+			t.Fatal("incomplete/wrong-bank ABIInternal input contract accepted")
+		}
+	}
+}
+
+func makeRepeatedARM64CallTypes(typ LLVMType, count int) []LLVMType {
+	values := make([]LLVMType, count)
+	for index := range values {
+		values[index] = typ
+	}
+	return values
+}
+
+func TestARM64TypedCallFloatingResultsRetainSourcePC(t *testing.T) {
+	pkg := mustGoPackage(t, "test/fpresult", "package fpresult\nfunc PCArg(p *uint64)\n//go:linkname X runtime.X\nfunc X(uint64) float64\n")
+	resolve := func(sym string) string {
+		return strings.ReplaceAll(strings.TrimPrefix(goStripABISuffix(sym), "·"), "·", ".")
+	}
+	for _, tc := range []struct {
+		name, setup, call, result string
+		manual                    bool
+	}{
+		{"classic_register_result", "MOVD R30,R5\nMOVD R5,8(RSP)", "CALL runtime·X(SB)", "FMOVD F0,R5", true},
+		{"internal_fp_result", "MOVD R30,R0", "CALL runtime·X<ABIInternal>(SB)", "FMOVD F0,R5", false},
+		{"classic_stack_result", "MOVD R30,R5\nMOVD R5,8(RSP)", "CALL runtime·X(SB)", "FMOVD 16(RSP),F0\nFMOVD F0,R5", false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			// Clear the old GP witness before reading the floating result.
+			// Otherwise the generic transform's conservative destination read
+			// could hide an omitted F0 result definition in this negative.
+			source := fmt.Sprintf("TEXT ·PCArg(SB),4,$32-8\n%s\n%s\nMOVD $0,R5\n%s\nADD $4,R5\nMOVD p+0(FP),R6\nMOVD R5,(R6)\nRET\n", tc.setup, tc.call, tc.result)
+			requireARM64TypedCallGoSelectorObject(t, source)
+			manual := func(name string) (FuncSig, bool) {
+				return FuncSig{Name: "X", Args: []LLVMType{I64}, ArgRegs: []Reg{"R5"}, Ret: "double"}, name == "runtime.X" && tc.manual
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", "arm64")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, manual)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				opt := Options{Goarch: "arm64", Sigs: sigs, ResolveSym: resolve, TargetTriple: target}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Translate lost source PC through float result: %v", target, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Module lost source PC through float result: %v", target, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", ResolveSym: resolve, TargetTriple: target, ManualSig: manual,
+				})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s GoModule lost source PC through float result: %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func requireARM64TypedCallGoSelectorObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "source.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	help, err := exec.CommandContext(ctx, "go", "tool", "asm", "-h").CombinedOutput()
+	if ctx.Err() != nil || err != nil && len(help) == 0 {
+		t.Fatalf("Go assembler flag discovery: %v / %v\n%s", err, ctx.Err(), help)
+	}
+	args := []string{"tool", "asm", "-p", "runtime"}
+	// Go1.20 requires an explicit runtime flag for source ABI selectors.
+	// Current Go derives that permission from -p and removed this flag.
+	if strings.Contains(string(help), "-compiling-runtime") {
+		args = append(args, "-compiling-runtime")
+	}
+	args = append(args, "-o", filepath.Join(dir, "source.o"), path)
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("Go typed-call selector object: %v\n%s", err, out)
+	}
+}
+
+func TestARM64TypedCallPartialResultRetainsOverlappingPC(t *testing.T) {
+	state := &arm64ControlState{
+		regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+		memory: map[string]arm64ControlValue{"sp:12": arm64ControlFromMap(map[string]bool{"label:source_witness": true})},
+	}
+	sig := FuncSig{Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}}}
+	arm64ControlWriteCallResults(state, sig, false, arm64ControlExternal())
+	if !arm64ControlHas(state.memory["sp:16"], "label:source_witness") {
+		t.Fatal("narrow result washed out code bits from an overlapping control cell")
+	}
+}
diff --git a/arm64_caller_sp_proof_test.go b/arm64_caller_sp_proof_test.go
new file mode 100644
index 000000000..b4f383c01
--- /dev/null
+++ b/arm64_caller_sp_proof_test.go
@@ -0,0 +1,333 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64CallerReturnRequiresRestoredSP(t *testing.T) {
+	for _, header := range []struct {
+		name  string
+		flags int
+		frame int
+	}{
+		{"noframe", 516, 0}, {"zero_leaf", 4, 0}, {"auto_frame", 4, 32},
+	} {
+		for _, instruction := range []string{"B (R30)", "WORD $0xd65f03c0", "RET"} {
+			t.Run(header.name+"/"+instruction, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT callerSP(SB),%d,$%d-0\nSUB $32,RSP\n%s\n", header.flags, header.frame, instruction)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+					"callerSP": {Name: "callerSP", Ret: Void},
+				}})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("caller return must not repair an unbalanced explicit SP delta: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64CallerReturnRejectsUnknownOrMixedSP(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown": `MOVD a+0(FP),R0
+MOVD R0,RSP
+B (R30)`,
+		"mixed": `MOVD a+0(FP),R0
+CBZ R0,done
+SUB $32,RSP
+done:
+WORD $0xd65f03c0`,
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := "TEXT callerSP(SB),516,$0-8\n" + body + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"callerSP": {
+					Name: "callerSP", Args: []LLVMType{I64}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+				},
+			}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown/mixed caller SP needs context: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64CallerReturnSymbolCallHasAutomaticGoFrame(t *testing.T) {
+	for _, instruction := range []string{"B (R30)", "WORD $0xd65f03c0"} {
+		for _, pop := range []string{"", "ADD $16,RSP\n"} {
+			t.Run(instruction+"/"+pop, func(t *testing.T) {
+				// TEXT $0 is not frameless after a symbol CALL: Go allocates
+				// its LR/FP frame. A register branch has no automatic epilogue.
+				source := "TEXT callerSP(SB),4,$0-0\nMOVD R30,8(RSP)\nCALL anchor(SB)\nMOVD 8(RSP),R30\n" + pop + instruction + "\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+					"callerSP": {Name: "callerSP", Ret: Void},
+					"anchor":   {Name: "anchor", Ret: Void},
+				}})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("symbol call introduces an implicit Go frame: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64CallerReturnRejectsEscapedSPInKnownCell(t *testing.T) {
+	// An unknown alias may overwrite the saved entry-SP cell with a different
+	// SP value. Reading the old exact cell must not reestablish a false proof.
+	source := `TEXT callerSP(SB),516,$0-8
+MOVD RSP,R20
+MOVD R20,0(RSP)
+SUB $32,RSP
+MOVD RSP,R21
+ADD $32,RSP
+MOVD a+0(FP),R0
+MOVD R21,(R0)
+MOVD 0(RSP),R22
+MOVD R22,RSP
+B (R30)
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"callerSP": {
+			Name: "callerSP", Args: []LLVMType{I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+		},
+	}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("escaped SP must invalidate a known-cell restoration proof: %v", err)
+	}
+}
+
+func TestARM64CallerReturnSymbolTailsRequireRestoredSP(t *testing.T) {
+	for _, instruction := range []string{"B anchor(SB)", "JMP anchor(SB)", "RET anchor(SB)"} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT callerSP(SB),516,$0-0\nSUB $32,RSP\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"callerSP": {Name: "callerSP", Ret: Void}, "anchor": {Name: "anchor", Ret: Void},
+			}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("symbol tail must not bypass the caller SP proof: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64UnreachableCallerReturnsRetainCFGProof(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, instruction := range []string{"RET", "B (R30)", "B (R0)", "WORD $0xd65f0000"} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT callerSP(SB),516,$0-0\nRET\ndead:\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+			} {
+				ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"callerSP": {Name: "callerSP", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				start := strings.Index(ir, "\nbb_dead:")
+				if start == -1 {
+					t.Fatal("dead source block was dropped instead of retaining its terminator")
+				}
+				block := strings.SplitN(ir[start+1:], "\n\n", 2)[0]
+				if !strings.Contains(block, "unreachable") || strings.Contains(block, "ret void") || strings.Contains(block, "indirectbr") {
+					t.Fatalf("dead terminator must retain an unreachable block, not a synthetic return:\n%s", block)
+				}
+				compileLLVMToObject(t, llc, triple, "unreachable-control.ll", "unreachable-control.o", ir)
+			}
+			// A conditional incoming edge makes the same block reachable.
+			source = "TEXT callerSP(SB),516,$0-0\nCBZ R1,dead\nRET\ndead:\nSUB $32,RSP\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err = Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"callerSP": {Name: "callerSP", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("reachable unproved exit must not become unreachable: %v", err)
+			}
+		})
+	}
+	for _, instruction := range []string{"B R0", "RET.P R30", "BOGUS"} {
+		source := "TEXT callerSP(SB),516,$0-0\nRET\ndead:\n" + instruction + "\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"callerSP": {Name: "callerSP", Ret: Void}}})
+		if err == nil {
+			t.Fatalf("unreachable source must still reject invalid/unsupported instruction %q", instruction)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64CallerSPRestore(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, flags := range []int{4, 516} {
+		for _, instruction := range []string{"B (R30)", "WORD $0xd65f03c0", "RET"} {
+			for _, restore := range []string{
+				"SUB $32,RSP\nADD $32,RSP",
+				"MOVD RSP,R20\nSUB $32,RSP\nMOVD R20,RSP",
+				"STP.W (R0,R6),-32(RSP)\nDMB $11\nMOVD $0,R0\nLDP.P 32(RSP),(R0,R6)",
+			} {
+				name := fmt.Sprintf("callerSPRestore%d", index)
+				index++
+				fmt.Fprintf(&source, `TEXT ·%s(SB),%d,$0-16
+MOVD a+0(FP),R0
+ADD $11,R0
+%s
+MOVD R0,ret+8(FP)
+%s
+`, name, flags, restore, instruction)
+				sigs[name] = arm64LocalRegisterBranchSig(name)
+				fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+				fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+				fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		println(got)
+		panic("caller SP restore mismatch")
+	}
+}
+`, name)
+				fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"caller SP restore mismatch\n");
+		return 1;
+	}
+}
+`, name)
+			}
+		}
+	}
+	for _, frame := range []int{0, 32} {
+		name := fmt.Sprintf("callerSPRestore%d", index)
+		index++
+		call := ""
+		if frame == 0 {
+			call = "CALL ·callerSPAnchor(SB)\n"
+		}
+		fmt.Fprintf(&source, `TEXT ·%s(SB),4,$%d-16
+SUB $32,RSP
+ADD $32,RSP
+%sMOVD a+0(FP),R0
+ADD $11,R0
+MOVD R0,ret+8(FP)
+RET
+`, name, frame, call)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		panic("automatic Go frame return mismatch")
+	}
+}
+`, name)
+		fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"automatic Go frame return mismatch\n");
+		return 1;
+	}
+}
+`, name)
+	}
+	source.WriteString("TEXT ·callerSPAnchor(SB),4,$0-0\nRET\n")
+	goDecl.WriteString("func callerSPAnchor()\n")
+	sigs["callerSPAnchor"] = FuncSig{Name: "callerSPAnchor", Ret: Void}
+	for _, instruction := range []string{"B", "JMP", "RET"} {
+		name := fmt.Sprintf("callerSPRestore%d", index)
+		index++
+		fmt.Fprintf(&source, `TEXT ·%s(SB),516,$0-16
+SUB $32,RSP
+ADD $32,RSP
+%s ·callerSPValueAnchor(SB)
+`, name, instruction)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		panic("typed symbol SP restoration mismatch")
+	}
+}
+`, name)
+		fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"typed symbol SP restoration mismatch\n");
+		return 1;
+	}
+}
+`, name)
+	}
+	source.WriteString(`TEXT ·callerSPValueAnchor(SB),4,$0-16
+MOVD a+0(FP),R0
+ADD $11,R0
+MOVD R0,ret+8(FP)
+RET
+`)
+	goDecl.WriteString("func callerSPValueAnchor(uint64) uint64\n")
+	sigs["callerSPValueAnchor"] = arm64LocalRegisterBranchSig("callerSPValueAnchor")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){ uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "caller_sp_restore", triple, ir, main, runner)
+	t.Logf("%d SP restoration fixtures x 5 inputs passed native Go and LLVM22", index)
+}
diff --git a/arm64_carry_form.go b/arm64_carry_form.go
new file mode 100644
index 000000000..344066dd2
--- /dev/null
+++ b/arm64_carry_form.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// arm64CarryForm is the common Go register grammar for add/subtract and
+// negate-with-carry. It validates syntax only, never supplying incoming flags.
+type arm64CarryForm struct {
+	word, subtract, setFlags, negate bool
+	left, destination                Operand
+}
+
+func parseARM64CarryForm(op Op, ins Instr) (form arm64CarryForm, handled bool, err error) {
+	switch op {
+	case "ADC", "ADCW", "ADCS", "ADCSW":
+	case "SBC", "SBCW", "SBCS", "SBCSW":
+		form.subtract = true
+	case "NGC", "NGCW", "NGCS", "NGCSW":
+		form.negate = true
+	default:
+		return form, false, nil
+	}
+	form.word = op == "ADCW" || op == "ADCSW" || op == "SBCW" || op == "SBCSW" || op == "NGCW" || op == "NGCSW"
+	form.setFlags = op == "ADCS" || op == "ADCSW" || op == "SBCS" || op == "SBCSW" || op == "NGCS" || op == "NGCSW"
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return form, true, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if form.negate {
+		if len(ins.Args) != 2 || !arm64AddSubCarryRegisterOrZero(ins.Args[0], false) ||
+			!arm64AddSubCarryRegisterOrZero(ins.Args[1], false) {
+			return form, true, fmt.Errorf("arm64 %s expects C_ZREG source and destination: %q", op, ins.Raw)
+		}
+		form.destination = ins.Args[1]
+		return form, true, nil
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return form, true, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
+	}
+	if !arm64AddSubCarryRegisterOrZero(ins.Args[0], true) {
+		return form, true, fmt.Errorf("arm64 %s first operand must be a general register or zero: %q", op, ins.Raw)
+	}
+	form.destination = ins.Args[len(ins.Args)-1]
+	if !arm64AddSubCarryRegisterOrZero(form.destination, false) {
+		return form, true, fmt.Errorf("arm64 %s destination must be a general register: %q", op, ins.Raw)
+	}
+	form.left = form.destination
+	if len(ins.Args) == 3 {
+		form.left = ins.Args[1]
+		if !arm64AddSubCarryRegisterOrZero(form.left, false) {
+			return form, true, fmt.Errorf("arm64 %s second operand must be a general register: %q", op, ins.Raw)
+		}
+	}
+	return form, true, nil
+}
diff --git a/arm64_closed_tail_closure_test.go b/arm64_closed_tail_closure_test.go
new file mode 100644
index 000000000..7f5805573
--- /dev/null
+++ b/arm64_closed_tail_closure_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ClosedTailClosure(t *testing.T, body, target, api string) (string, error) {
+	t.Helper()
+	const name = "test/closure.Capture"
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(*uint64) uint64\n")
+	source := "TEXT ·Capture<ABIInternal>(SB),516,$0-16\nMOVD 8(R26),R2\nB body<>(SB)\nTEXT body<>(SB),516,$0\n" + body + "\nRET\n"
+	requireARM64ClosureGoObject(t, source)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := func(symbol string) string {
+		return "test/closure." + strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	entry := *file
+	entry.Funcs = append([]Func(nil), file.Funcs[:1]...)
+	entry.Funcs[0].Instrs = entry.Funcs[0].Instrs[:1]
+	sigs, err := goSigsForAsmFile(pkg, &entry, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	abi := arm64TestClosureABI(name, target)
+	sig := sigs[name]
+	sig.ARM64ClosureABI = &abi
+	sigs[name] = sig
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	switch api {
+	case "text":
+		return Translate(file, options)
+	case "module":
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			if err == nil {
+				return module.String(), nil
+			}
+		}
+		return "", err
+	case "GoModule":
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+			ARM64ClosureABIs: map[string]ARM64ClosureABI{name: abi},
+		})
+		if result != nil && !result.Module.IsNil() {
+			defer result.Module.Dispose()
+			if err == nil {
+				return result.Module.String(), nil
+			}
+		}
+		return "", err
+	default:
+		t.Fatalf("unknown test API %q", api)
+		return "", nil
+	}
+}
+
+func TestARM64ClosedTailClosureReadOnlyCarrier(t *testing.T) {
+	llc, _, _ := findLlcAndClang(t)
+	for _, tc := range []struct{ name, body string }{
+		{"scalar", "MOVD (R0),R0"},
+		{"pair", "LDP (R0),(R0,R1)"},
+		{"floating", "FMOVD (R0),F0\nFMOVD F0,R0"},
+		{"structure", "VLD1 (R0),[V0.D2]\nVMOV V0.D[0],R0"},
+		{"scalar-writeback", "MOVD.P 8(R0),R1\nMOVD R1,R0"},
+		{"pair-writeback", "LDP.P 16(R0),(R1,R2)\nMOVD R1,R0"},
+		{"structure-writeback", "VLD1.P (R0),[V0.D2]\nVMOV V0.D[0],R0"},
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(tc.name+"/"+api, func(t *testing.T) {
+				ir, err := arm64ClosedTailClosure(t, tc.body, "aarch64-unknown-linux-gnu", api)
+				if err != nil {
+					t.Fatalf("closed source-only read cannot mutate or expose its immutable carrier: %v", err)
+				}
+				compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "closure-read.ll", "closure-read.o", ir)
+			})
+		}
+	}
+}
+
+func TestARM64ClosedTailClosureCannotAliasCarrierWrites(t *testing.T) {
+	for _, tc := range []struct{ name, body string }{
+		{"scalar-store", "MOVD R2,(R0)\nMOVD $7,R0"},
+		{"pair-store", "STP (R2,R2),(R0)\nMOVD $7,R0"},
+		{"floating-store", "FMOVD R2,F0\nFMOVD F0,(R0)\nMOVD $7,R0"},
+		{"structure-store", "VDUP R2,V0.D2\nVST1 [V0.D2],(R0)\nMOVD $7,R0"},
+		{"hidden-read", "MOVD 8(R26),R0"},
+		{"hidden-copy", "MOVD R26,R0"},
+		{"hidden-index", "MOVD (R0)(R26),R0"},
+		{"hidden-destination", "MOVD (R0),R26\nMOVD $7,R0"},
+		{"address-materialization", "MOVD $8(R0),R0"},
+		{"unregistered-memory-row", "LDAR (R0),R0"},
+		{"undefined-data-base", "MOVD (R9),R0"},
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(tc.name+"/"+api, func(t *testing.T) {
+				_, err := arm64ClosedTailClosure(t, tc.body, "aarch64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("ordinary pointer inputs acquired an unproved immutable-carrier alias promise: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_closed_tail_helper_test.go b/arm64_closed_tail_helper_test.go
new file mode 100644
index 000000000..5962516b8
--- /dev/null
+++ b/arm64_closed_tail_helper_test.go
@@ -0,0 +1,279 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This first-party source is a continuation, not a separately callable Go
+// function: the private body reads the real ABIInternal caller's pointer and
+// returns through its unchanged caller LR. No private helper signature exists.
+func arm64ClosedTailPointerSource(op string) string {
+	return fmt.Sprintf(`TEXT ·Read<ABIInternal>(SB),516,$0-16
+%s readbody<>(SB)
+TEXT readbody<>(SB),516,$0-0
+MOVD (R0),R0
+RET
+`, op)
+}
+
+func TestARM64ClosedTailPointerOriginalGoObjects(t *testing.T) {
+	for _, op := range []string{"B", "JMP", "RET"} {
+		t.Run(op, func(t *testing.T) {
+			// The stock assembler's runtime selector permission is only an
+			// original object oracle. It does not grant a helper ABI or assert
+			// that an ordinary user package can define ABIInternal assembly.
+			requireARM64GoABIInternalObject(t, arm64ClosedTailPointerSource(op))
+		})
+	}
+}
+
+func TestARM64ClosedTailPointerContinuationThreeAPIs(t *testing.T) {
+	llc, _, _ := findLlcAndClang(t)
+	pkg := mustGoPackage(t, "test/privatetail", "package privatetail\nfunc Read(*uint64) uint64\n")
+	resolve := func(symbol string) string {
+		return strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	for _, op := range []string{"B", "JMP", "RET"} {
+		source := arm64ClosedTailPointerSource(op)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		original, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Bind only the real source declaration through the central derivation.
+		// Passing a fabricated helper FuncSig would hide the actual gap.
+		entry := *file
+		entry.Funcs = append([]Func(nil), file.Funcs[:1]...)
+		entry.Funcs[0].Instrs = entry.Funcs[0].Instrs[:1]
+		sigs, err := goSigsForAsmFile(pkg, &entry, resolve, "arm64", nil, nil, nil)
+		if err != nil || sigs["Read"].ARM64GoRegisterABI == nil {
+			t.Fatalf("real caller declaration lacks its register ABI: %v", err)
+		}
+		for _, target := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+			"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(op+"/"+target+"/"+api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+					var err error
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						module, failure := TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+						err = failure
+					case "GoModule":
+						result, failure := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+							GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+							// The complete original file still reaches preparation;
+							// filtering cannot supply the missing helper permission.
+							KeepFunc: func(_, resolved string) bool { return resolved == "Read" },
+						})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+						err = failure
+					}
+					if !reflect.DeepEqual(file, original) {
+						t.Fatal("translation mutated the complete original source")
+					}
+					if err != nil {
+						t.Fatalf("closed zero-frame source continuation needs no guessed helper ABI: %v", err)
+					}
+					compileLLVMToObject(t, llc, target, "closed-tail.ll", "closed-tail.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func arm64ClosedTailTranslate(t *testing.T, source, declaration, target, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "test/closedtail", "package closedtail\n"+declaration+"\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := func(symbol string) string {
+		return strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	entry := *file
+	entry.Funcs = nil
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			continue
+		}
+		fn.Instrs = fn.Instrs[:1]
+		entry.Funcs = append(entry.Funcs, fn)
+	}
+	sigs, err := goSigsForAsmFile(pkg, &entry, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	switch api {
+	case "text":
+		return Translate(file, options)
+	case "module":
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			if err == nil {
+				return module.String(), nil
+			}
+		}
+		return "", err
+	case "GoModule":
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+			KeepFunc: func(_, resolved string) bool { return resolved != "Excluded" },
+		})
+		if result != nil && !result.Module.IsNil() {
+			defer result.Module.Dispose()
+			if err == nil {
+				return result.Module.String(), nil
+			}
+		}
+		return "", err
+	default:
+		t.Fatalf("unknown test API %q", api)
+		return "", nil
+	}
+}
+
+func TestARM64ClosedTailWholeSourceGuards(t *testing.T) {
+	base := arm64ClosedTailPointerSource("B")
+	for _, tc := range []struct{ name, source string }{
+		{"root-frame", strings.Replace(base, "$0-16", "$16-16", 1)},
+		{"root-unknown-flags", strings.Replace(base, "516,$0-16", "unknown,$0-16", 1)},
+		{"root-unknown-args", strings.Replace(base, "$0-16", "$0", 1)},
+		{"root-call", strings.Replace(base, "B readbody", "CALL external(SB)\nB readbody", 1)},
+		{"same-helper-call-and-tail", strings.Replace(base, "B readbody", "CALL readbody<>(SB)\nB readbody", 1)},
+		{"different-helper-call-and-tail", strings.Replace(base, "B readbody", "CALL mix<>(SB)\nB readbody", 1) + "TEXT mix<>(SB),516,$0-0\nADD $1,R0\nRET\n"},
+		{"helper-frame", strings.Replace(base, "$0-0", "$16-0", 1)},
+		{"helper-fp", strings.Replace(base, "MOVD (R0),R0", "MOVD x+0(FP),R0", 1)},
+		{"helper-sp", strings.Replace(base, "MOVD (R0),R0", "MOVD (RSP),R0", 1)},
+		{"helper-platform", strings.Replace(base, "MOVD (R0),R0", "MOVD R18_PLATFORM,R0", 1)},
+		{"helper-g", strings.Replace(base, "MOVD (R0),R0", "MOVD g,R0", 1)},
+		{"helper-hidden", strings.Replace(base, "MOVD (R0),R0", "MOVD 8(R26),R0", 1)},
+		{"helper-lr", strings.Replace(base, "MOVD (R0),R0", "MOVD R30,R0", 1)},
+		{"helper-scratch", strings.Replace(base, "MOVD (R0),R0", "ADD $0x123456789,R0,R0", 1)},
+		{"helper-memory-scratch", strings.Replace(base, "MOVD (R0),R0", "MOVD 65537(R0),R0", 1)},
+		{"helper-pair-scratch", strings.Replace(base, "MOVD (R0),R0", "LDP 1024(R0),(R0,R1)", 1)},
+		{"helper-fp-memory-scratch", strings.Replace(base, "MOVD (R0),R0", "FMOVD 65536(R0),F0\nFMOVD F0,R0", 1)},
+		{"helper-fp-pair-scratch", strings.Replace(base, "MOVD (R0),R0", "FLDPD 1024(R0),(F0,F1)\nFMOVD F0,R0", 1)},
+		{"helper-unknown-gp", strings.Replace(base, "MOVD (R0),R0", "MOVD R9,R0", 1)},
+		{"helper-unknown-f", strings.Replace(base, "MOVD (R0),R0", "FMOVD F1,R0", 1)},
+		{"helper-unknown-vector", strings.Replace(base, "MOVD (R0),R0", "VMOV V1.D[0],R0", 1)},
+		{"helper-join", strings.Replace(base, "MOVD (R0),R0", "CBZ R0,done\nMOVD $9,R9\ndone:\nMOVD R9,R0", 1)},
+		{"helper-missing-label", strings.Replace(base, "MOVD (R0),R0", "B absent", 1)},
+		{"helper-indirect-control", strings.Replace(base, "MOVD (R0),R0", "B (R0)", 1)},
+		{"helper-nested", strings.Replace(base, "MOVD (R0),R0", "B other<>(SB)", 1) + "TEXT other<>(SB),516,$0\nB readbody<>(SB)\n"},
+		{"helper-fallthrough", strings.TrimSuffix(base, "RET\n")},
+		{"helper-duplicate", base + "TEXT readbody<>(SB),516,$0-0\nMOVD $1,R0\nRET\n"},
+		{"data-address", base + "DATA address<>+0(SB)/8,$readbody<>(SB)\nGLOBL address<>(SB),8,$8\n"},
+		{"data-address-offset", base + "DATA address<>+0(SB)/8,$readbody<>+4(SB)\nGLOBL address<>(SB),8,$8\n"},
+		{"global-identity", base + "GLOBL readbody<>(SB),8,$8\n"},
+		{"excluded-address", base + "TEXT ·Excluded(SB),516,$0-8\nMOVD $readbody<>(SB),R0\nRET\n"},
+		{"excluded-word", base + "TEXT ·Excluded(SB),516,$0-8\nWORD $0xd65f03c0\nRET\n"},
+		{"excluded-adr", base + "TEXT ·Excluded(SB),516,$0-8\nADR label,R0\nlabel:\nRET\n"},
+	} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(tc.name+"/"+api, func(t *testing.T) {
+				_, err := arm64ClosedTailTranslate(t, tc.source, "func Read(*uint64) uint64\nfunc Excluded() uint64", "aarch64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved complete source must stay Context: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ClosedTailLabelsInputsAndBudget(t *testing.T) {
+	base := strings.Replace(arm64ClosedTailPointerSource("B"), "MOVD (R0),R0", "CBZ R0,empty\nMOVD (R0),R0\nRET\nempty:\nMOVD $0,R0", 1)
+	base = strings.Replace(base, "B readbody<>(SB)", "__arm64_tail_3:\nCBZ R0,alternate\nB readbody<>(SB)\nalternate:\nB readbody<>(SB)", 1)
+	base += "TEXT ·Other<ABIInternal>(SB),516,$0-16\nB readbody<>(SB)\n"
+	file, err := Parse(ArchARM64, base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, _ := Parse(ArchARM64, base)
+	prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil || !reflect.DeepEqual(file, original) || len(prepared.Funcs) != 2 {
+		t.Fatalf("complete shared-helper preparation/immutability: %v", err)
+	}
+	second, err := CoalesceARM64PrivateRegisterHelpers(prepared)
+	if err != nil || !reflect.DeepEqual(prepared, second) {
+		t.Fatalf("source preparation is not idempotent: %v", err)
+	}
+	for _, fn := range prepared.Funcs {
+		names := map[string]bool{}
+		for _, block := range arm64SplitBlocks(fn) {
+			name := arm64LLVMBlockName(block.name)
+			if names[name] {
+				t.Fatalf("renamed source labels collide at %q", name)
+			}
+			names[name] = true
+		}
+	}
+	// The CALL half uses 65534 original instructions. The separate three
+	// instruction tail would fit another independent budget, but not the one
+	// file-wide checked budget. No Cartesian allocation is permitted first.
+	call := "TEXT ·Run(SB),4,$0-16\nMOVD x+0(FP),R0\nCALL mix<>(SB)\nMOVD R0,ret+8(FP)\nRET\nTEXT mix<>(SB),516,$0-0\n" +
+		strings.Repeat("ADD $1,R0\n", arm64PrivateRegisterExpansionBudget-4) + "RET\n"
+	for _, source := range []string{call, arm64ClosedTailPointerSource("B")} {
+		parsed, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := CoalesceARM64PrivateRegisterHelpers(parsed); err != nil {
+			t.Fatalf("individual budget control: %v", err)
+		}
+	}
+	mixed, err := Parse(ArchARM64, call+arm64ClosedTailPointerSource("B"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CoalesceARM64PrivateRegisterHelpers(mixed); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("CALL and tail must share the original-source budget: %v", err)
+	}
+	// A public preparation followed by the final API's preparation must not
+	// reset the file's already consumed CALL/tail expansion allowance.
+	parsedCall, err := Parse(ArchARM64, call)
+	if err != nil {
+		t.Fatal(err)
+	}
+	preparedCall, err := CoalesceARM64PrivateRegisterHelpers(parsedCall)
+	if err != nil {
+		t.Fatal(err)
+	}
+	parsedTail, err := Parse(ArchARM64, arm64ClosedTailPointerSource("B"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	reprepared := *preparedCall
+	reprepared.Funcs = append(append([]Func(nil), preparedCall.Funcs...), parsedTail.Funcs...)
+	if _, err := CoalesceARM64PrivateRegisterHelpers(&reprepared); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("repeated public preparation reset its consumed expansion budget: %v", err)
+	}
+}
diff --git a/arm64_closed_tail_runtime_test.go b/arm64_closed_tail_runtime_test.go
new file mode 100644
index 000000000..2b9a05aaf
--- /dev/null
+++ b/arm64_closed_tail_runtime_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ClosedTailFoldSource(tail, helperHeader string) string {
+	return fmt.Sprintf(`TEXT ·Fold<ABIInternal>(SB),516,$0-32
+%s foldbody<>(SB)
+TEXT foldbody<>(SB),%s
+MOVD $0,R3
+CBZ R1,done
+loop:
+PCALIGN $16
+MOVD.P 8(R0),R4
+ADD R4,R3,R3
+SUB $1,R1
+CBNZ R1,loop
+done:
+MOVD R3,(R2)
+MOVD R3,R0
+RET
+`, tail, helperHeader)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ClosedTailContinuation(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct{ tail, header string }{
+		{"B", "516,$0-0"}, {"JMP", "4,$0"}, {"RET", "4,$0-0"},
+	} {
+		t.Run(tc.tail, func(t *testing.T) {
+			source := arm64ClosedTailFoldSource(tc.tail, tc.header)
+			// Identical original assembly executes under the selected actual Go
+			// compiler, including its real ABIInternal call and unchanged LR.
+			runARM64GoInternalOracle(t, source, `package main
+func Fold(*uint64,uint64,*uint64) uint64
+func main() {
+  data := [10]uint64{0xa55a,0,1,9,0x8000000000000000,^uint64(0),3,17,999,0x5aa5}
+  original := data
+  for n:=uint64(0); n<=8; n++ {
+    out := [3]uint64{0xabc,0xbad,0xdef}
+    want := uint64(0)
+    for i:=uint64(0); i<n; i++ { want += data[i+1] }
+    if Fold(&data[1],n,&out[1])!=want || out[1]!=want { panic("source tail fold mismatch") }
+    if out[0]!=0xabc || out[2]!=0xdef || data!=original { panic("source tail canary/input changed") }
+  }
+}
+`, len(runner) != 0)
+			translate := func(target string) string {
+				ir, err := arm64ClosedTailTranslate(t, source, "func Fold(*uint64,uint64,*uint64) uint64", target, "GoModule")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if strings.Contains(ir, "foldbody") {
+					t.Fatal("a source continuation acquired a separate LLVM callee")
+				}
+				return ir
+			}
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+			} {
+				compileLLVMToObject(t, llc, target, "closed-fold.ll", "closed-fold.o", translate(target))
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "closed_tail", triple, translate(triple), `#include <stdint.h>
+#include <string.h>
+extern uint64_t Fold(uint64_t *,uint64_t,uint64_t *);
+int main(void) {
+  uint64_t data[]={0xa55a,0,1,9,UINT64_C(0x8000000000000000),UINT64_MAX,3,17,999,0x5aa5};
+  uint64_t original[10];
+  memcpy(original,data,sizeof data);
+  for (unsigned n=0;n<=8;n++) {
+    uint64_t out[]={0xabc,0xbad,0xdef},want=0;
+    for (unsigned i=0;i<n;i++) want+=data[i+1];
+    if (Fold(data+1,n,out+1)!=want || out[1]!=want) return 1;
+    if (out[0]!=0xabc || out[2]!=0xdef || memcmp(data,original,sizeof data)) return 2;
+  }
+  return 0;
+}
+`, runner)
+		})
+	}
+}
+
+func TestARM64ClosedTailFinalBindingAndZeroArguments(t *testing.T) {
+	const source = `TEXT ·Zero<ABIInternal>(SB),516,$0-8
+B zero<>(SB)
+TEXT zero<>(SB),516,$0
+MOVD $99,R0
+RET
+`
+	llc, _, _ := findLlcAndClang(t)
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run("zero-arguments/"+api, func(t *testing.T) {
+			ir, err := arm64ClosedTailTranslate(t, source, "func Zero() uint64", "aarch64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "zero-tail.ll", "zero-tail.o", ir)
+		})
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "test/closedtail", "package closedtail\nfunc Zero() uint64\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	sigs, err := goSigsForAsmFile(pkg, prepared, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		name string
+		edit func(*Func, *FuncSig)
+	}{
+		{"source", func(f *Func, _ *FuncSig) { f.Instrs[3].Raw = "changed original source" }},
+		{"frame", func(f *Func, _ *FuncSig) { f.FrameSize = 8 }},
+		{"selector", func(f *Func, _ *FuncSig) { f.Sym = "·Zero" }},
+		{"resource-count-is-not-permission", func(f *Func, _ *FuncSig) { f.arm64PrivateSourceAdded = 0 }},
+		{"missing-register-ABI", func(_ *Func, s *FuncSig) { s.ARM64GoRegisterABI = nil }},
+		{"custom-register-ABI", func(_ *Func, s *FuncSig) { s.ArgRegs = []Reg{"R0"} }},
+		{"wrong-result", func(_ *Func, s *FuncSig) { s.Ret = Ptr }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			mutated := *prepared
+			mutated.Funcs = append([]Func(nil), prepared.Funcs...)
+			mutated.Funcs[0].Instrs = append([]Instr(nil), prepared.Funcs[0].Instrs...)
+			sig := sigs["Zero"]
+			tc.edit(&mutated.Funcs[0], &sig)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, &mutated, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolve,
+				Sigs: map[string]FuncSig{"Zero": sig},
+			})
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("mutated continuation binding acquired admission: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_closed_tail_stdlib_test.go b/arm64_closed_tail_stdlib_test.go
new file mode 100644
index 000000000..9a51d15a9
--- /dev/null
+++ b/arm64_closed_tail_stdlib_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ClosedTailOriginalPackage(t *testing.T, family string) (GoPackage, []byte) {
+	t.Helper()
+	root := filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg")
+	declPath := filepath.Join(root, family+"_native.go")
+	asmPath := filepath.Join(root, family+"_arm64.s")
+	decl, err := os.ReadFile(declPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(asmPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, declPath, decl, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := types.Config{Importer: importer.Default()}
+	checked, err := conf.Check("internal/bytealg", fset, []*ast.File{parsed}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Retain the original include bytes. The header is generated by the actual
+	// compiler from the original declaration, not a guessed empty go_asm.h.
+	dir := t.TempDir()
+	run := func(args ...string) {
+		t.Helper()
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		command := exec.CommandContext(ctx, "go", args...)
+		command.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+		if out, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+			t.Fatalf("actual selected SDK original %s object: %v\n%s", family, err, out)
+		}
+	}
+	run("tool", "compile", "-p", "internal/bytealg", "-asmhdr", filepath.Join(dir, "go_asm.h"), "-o", filepath.Join(dir, "decl.o"), declPath)
+	args := append(arm64ClosureGoAsmArgs(t), "-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-I", dir, "-o", filepath.Join(dir, "original.o"), asmPath)
+	run(args...)
+	for path, original := range map[string][]byte{declPath: decl, asmPath: source} {
+		after, err := os.ReadFile(path)
+		if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+			t.Fatalf("original SDK source changed while compiling %s: %v", path, err)
+		}
+	}
+	return GoPackage{Path: checked.Path(), Types: checked, Syntax: []*ast.File{parsed}}, source
+}
+
+func TestARM64ClosedTailOriginalCompareAllAPIsObjects(t *testing.T) {
+	pkg, source := arm64ClosedTailOriginalPackage(t, "compare")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			bound, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target, ResolveSym: arm64ClosureResolve,
+			})
+			if bound != nil && !bound.Module.IsNil() {
+				defer bound.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchARM64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: arm64ClosureResolve, Sigs: bound.Signatures}
+			text, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if indirectMarkerComparableIR(text) != indirectMarkerComparableIR(bound.Module.String()) ||
+				indirectMarkerComparableIR(text) != indirectMarkerComparableIR(module.String()) {
+				t.Fatal("three public APIs disagree on the complete original SDK source")
+			}
+			compileLLVMToObject(t, llc, target, "original-compare.ll", "original-compare.o", text)
+		})
+	}
+}
diff --git a/arm64_closure_abi.go b/arm64_closure_abi.go
new file mode 100644
index 000000000..8b002a7bb
--- /dev/null
+++ b/arm64_closure_abi.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import "strings"
+
+// ARM64ClosureTransport is the physical LLVM transport of a required context.
+// It is independent of Go's R26 source register and ordinary argument banks.
+type ARM64ClosureTransport uint8
+
+const (
+	ARM64ClosureNest ARM64ClosureTransport = iota + 1
+	ARM64ClosureSwiftSelf
+)
+
+// ARM64ClosureABI describes an explicitly supplied, immutable Go funcval
+// carrier. Its first word is this entry's code pointer and its second word is
+// one captured uint64. It is not a third Go parameter or an ABI0 FP slot.
+//
+// The producer must establish the entry identity, carrier layout and lifetime.
+// A signature alone does not authorize direct calls or address-taking: source
+// edges without a matching producer remain Context. Nil is the default.
+type ARM64ClosureABI struct {
+	ContextRegister Reg
+	EntrySymbol     string
+	CodeOffset      int64
+	CodeType        LLVMType
+	CaptureOffset   int64
+	CaptureType     LLVMType
+	Transport       ARM64ClosureTransport
+}
+
+func (abi ARM64ClosureABI) llvmAttribute() string {
+	if abi.Transport == ARM64ClosureSwiftSelf {
+		return "swiftself"
+	}
+	return "nest"
+}
+
+func validateARM64ClosureABI(sig FuncSig, triple string) error {
+	abi := sig.ARM64ClosureABI
+	if abi == nil {
+		return nil
+	}
+	if abi.ContextRegister != "R26" || abi.EntrySymbol != sig.Name || abi.EntrySymbol == "" ||
+		abi.CodeOffset != 0 || abi.CodeType != Ptr || abi.CaptureOffset != 8 || abi.CaptureType != I64 {
+		return arm64GoABIContext("%q needs an exact typed closure carrier and entry identity", sig.Name)
+	}
+	if err := arm64ValidateGoRegisterABI(sig); err != nil {
+		return err
+	}
+	lower := strings.ToLower(triple)
+	if !strings.HasPrefix(lower, "aarch64-") && !strings.HasPrefix(lower, "arm64-") {
+		return arm64GoABIContext("%q closure transport needs an explicit ARM64 target", sig.Name)
+	}
+	want := ARM64ClosureNest
+	for _, platform := range []string{"apple", "darwin", "android", "windows", "win32", "mingw"} {
+		if strings.Contains(lower, platform) {
+			want = ARM64ClosureSwiftSelf
+		}
+	}
+	if abi.Transport != want {
+		return arm64GoABIContext("%q closure transport does not match target %q", sig.Name, triple)
+	}
+	return nil
+}
+
+// This first carrier boundary is deliberately read-only and bounded. It does
+// not infer an environment from arbitrary R26 use or give ordinary pointer
+// operands a noalias promise. The complete original and normalized functions
+// must both satisfy the same gate, including unreachable instructions.
+func validateARM64ClosureSource(fn Func, sig FuncSig) error {
+	if sig.ARM64ClosureABI == nil {
+		return nil
+	}
+	if fn.arm64PrivateTailSource != nil {
+		return validateARM64PrivateTailClosureSource(fn, sig)
+	}
+	if !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return arm64GoABIContext("%q required closure entry needs a source ABIInternal selector", sig.Name)
+	}
+	seen := false
+	for _, original := range fn.Instrs {
+		ins := arm64ControlDecode(original)
+		if ins.Op == "WORD" || ins.Op == "DWORD" {
+			return arm64GoABIContext("%q closure carrier has unproved raw effects", sig.Name)
+		}
+		captureRead := ins.Op == "MOVD" && len(ins.Args) == 2 &&
+			ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Base == "R26" &&
+			ins.Args[0].Mem.Off == sig.ARM64ClosureABI.CaptureOffset &&
+			ins.Args[0].Mem.Sym == "" && ins.Args[0].Mem.OffRaw == "" &&
+			ins.Args[0].Mem.Index == "" && ins.Args[0].Mem.Segment == "" &&
+			ins.Args[1].Kind == OpReg && ins.Args[1].Reg != "R26"
+		for i, arg := range ins.Args {
+			if captureRead && i == 0 {
+				seen = true
+				continue
+			}
+			if arg.Reg == "R26" || arg.ShiftReg == "R26" || arg.Mem.Base == "R26" || arg.Mem.Index == "R26" {
+				return arm64GoABIContext("%q closure context may not be changed, exposed or read outside its capture cell", sig.Name)
+			}
+			for _, reg := range arg.RegList {
+				if reg == "R26" {
+					return arm64GoABIContext("%q closure context escapes through a register list", sig.Name)
+				}
+			}
+			if arg.Kind == OpMem || arg.Kind == OpFP || arg.Kind == OpFPAddr ||
+				(arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$")) {
+				return arm64GoABIContext("%q closure entry has memory/address effects without a carrier alias contract", sig.Name)
+			}
+			if arg.Kind == OpSym {
+				if _, _, memory := parseSBRef(arg.Sym); memory && !arm64ClosureDirectControlTarget(ins, i) {
+					return arm64GoABIContext("%q closure entry has symbol memory effects without a carrier alias contract", sig.Name)
+				}
+			}
+		}
+	}
+	if !seen {
+		return arm64GoABIContext("%q closure contract has no source-bound capture read", sig.Name)
+	}
+	return nil
+}
+
+func arm64ClosureDirectControlTarget(ins Instr, index int) bool {
+	if index != 0 || len(ins.Args) != 1 {
+		return false
+	}
+	switch ins.Op {
+	case "B", "JMP", "RET", "BL", "CALL":
+		return true
+	}
+	return false
+}
+
+func validateARM64ClosureFile(file *File, opt Options, resolve func(string) string) error {
+	if file == nil {
+		return nil // The common parsed-file gate reports this invalid input.
+	}
+	required := false
+	for _, sig := range opt.Sigs {
+		if sig.ARM64ClosureABI == nil {
+			continue
+		}
+		required = true
+		if file.Arch != ArchARM64 || opt.Goarch != "arm64" {
+			return arm64GoABIContext("required ARM64 closure carrier used for another architecture")
+		}
+		if err := validateARM64ClosureABI(sig, opt.TargetTriple); err != nil {
+			return err
+		}
+	}
+	if !required {
+		return nil
+	}
+	checkReference := func(symbol string) error {
+		symbol = strings.TrimLeft(strings.TrimSpace(symbol), "$*")
+		if name, _, ok := parseSBRef(symbol); ok {
+			if sig := opt.Sigs[resolve(name)]; sig.ARM64ClosureABI != nil {
+				return arm64GoABIContext("%q requires a matching typed closure producer; a source reference is not a carrier", sig.Name)
+			}
+		}
+		return nil
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				if err := checkReference(arg.Sym); err != nil {
+					return err
+				}
+				if err := checkReference(arg.Mem.Sym); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	for _, data := range file.Data {
+		if err := checkReference(data.Addr); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/arm64_closure_abi_test.go b/arm64_closure_abi_test.go
new file mode 100644
index 000000000..305f078c0
--- /dev/null
+++ b/arm64_closure_abi_test.go
@@ -0,0 +1,550 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64ClosureEntrySource = `
+TEXT ·Capture<ABIInternal>(SB),4,$0-16
+	MOVD 8(R26), R0
+	RET
+`
+
+func TestARM64ClosureRequiredEntry(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64) uint64\n")
+	name := "test/closure.Capture"
+	tr, err := TranslateGoModule(pkg, []byte(arm64ClosureEntrySource), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+		ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+		ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+	})
+	if err != nil {
+		t.Fatalf("required typed closure entry must translate: %v", err)
+	}
+	tr.Module.Dispose()
+}
+
+func TestARM64ClosureGoSourceIdentityForms(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64) uint64\n")
+	name := "test/closure.Capture"
+	for _, symbol := range []string{"·Capture", "test∕closure·Capture"} {
+		source := strings.Replace(arm64ClosureEntrySource, "·Capture", symbol, 1)
+		requireARM64ClosureGoObject(t, source)
+		ctx := llvm.NewContext()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+			ResolveSym: func(sym string) string {
+				sym = strings.ReplaceAll(goStripABISuffix(sym), "∕", "/")
+				if strings.HasPrefix(sym, "·") {
+					sym = pkg.Path + sym
+				}
+				return strings.ReplaceAll(sym, "·", ".")
+			},
+			ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+		})
+		if err == nil {
+			tr.Module.Dispose()
+		}
+		ctx.Dispose()
+		if err != nil {
+			t.Fatalf("actual Go source identity %q: %v", symbol, err)
+		}
+	}
+}
+
+func arm64TestClosureABI(name, triple string) ARM64ClosureABI {
+	transport := ARM64ClosureNest
+	if strings.Contains(triple, "apple") || strings.Contains(triple, "windows") {
+		transport = ARM64ClosureSwiftSelf
+	}
+	return ARM64ClosureABI{
+		ContextRegister: "R26", EntrySymbol: name,
+		CodeOffset: 0, CodeType: Ptr, CaptureOffset: 8, CaptureType: I64,
+		Transport: transport,
+	}
+}
+
+func arm64ClosureSourceAndPackage(t *testing.T) (GoPackage, []byte) {
+	t.Helper()
+	root := runtime.GOROOT()
+	decl, err := os.ReadFile(filepath.Join(root, "src/internal/bytealg/equal_native.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(root, "src/internal/bytealg/equal_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// These are the selected toolchain's original declarations and full source,
+	// including the genuine go:linkname identity and ABIInternal selectors.
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, filepath.Join(root, "src/internal/bytealg/equal_native.go"), decl, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := types.Config{Importer: importer.Default()}
+	checked, err := conf.Check("internal/bytealg", fset, []*ast.File{parsed}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: checked.Path(), Types: checked, Syntax: []*ast.File{parsed}}, source
+}
+
+func requireARM64ClosureOriginalGoObject(t *testing.T, source []byte) {
+	t.Helper()
+	dir := t.TempDir()
+	// Generate go_asm.h from the original declaration file rather than altering
+	// the selected source's includes or fabricating a macro/layout definition.
+	decl := filepath.Join(runtime.GOROOT(), "src/internal/bytealg/equal_native.go")
+	compile := exec.Command("go", "tool", "compile", "-p", "internal/bytealg", "-asmhdr", filepath.Join(dir, "go_asm.h"), "-o", filepath.Join(dir, "decl.o"), decl)
+	compile.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+	if out, err := compile.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go declarations/header: %v\n%s", err, out)
+	}
+	asm := filepath.Join(dir, "equal_arm64.s")
+	if err := os.WriteFile(asm, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	args := append(arm64ClosureGoAsmArgs(t), "-I", filepath.Join(runtime.GOROOT(), "pkg/include"), "-I", dir, "-o", filepath.Join(dir, "equal.o"), asm)
+	assemble := exec.Command("go", args...)
+	assemble.Env = append(os.Environ(), "GOARCH=arm64", "GOOS=linux")
+	if out, err := assemble.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go original assembly: %v\n%s", err, out)
+	}
+}
+
+var arm64ClosureAsmFlags struct {
+	once sync.Once
+	args []string
+	err  error
+}
+
+func arm64ClosureGoAsmArgs(t *testing.T) []string {
+	t.Helper()
+	arm64ClosureAsmFlags.once.Do(func() {
+		help, err := exec.Command("go", "tool", "asm", "-h").CombinedOutput()
+		if !strings.Contains(string(help), "usage: asm") {
+			arm64ClosureAsmFlags.err = fmt.Errorf("selected Go assembler help is unavailable: %v\n%s", err, help)
+			return
+		}
+		arm64ClosureAsmFlags.args = []string{"tool", "asm", "-p", "runtime"}
+		// Go 1.20's actual parser uses this separate runtime flag. Current Go
+		// derives AllowAsmABI from the package path instead. Query the selected
+		// real tool, not the version used to compile this test or a host guess.
+		if strings.Contains(string(help), "-compiling-runtime") {
+			arm64ClosureAsmFlags.args = append(arm64ClosureAsmFlags.args, "-compiling-runtime")
+		}
+	})
+	if arm64ClosureAsmFlags.err != nil {
+		t.Fatal(arm64ClosureAsmFlags.err)
+	}
+	return append([]string(nil), arm64ClosureAsmFlags.args...)
+}
+
+func requireARM64ClosureGoObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "closure_arm64.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	args := append(arm64ClosureGoAsmArgs(t), "-o", filepath.Join(dir, "closure.o"), asm)
+	cmd := exec.Command("go", args...)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go closure entry/form object: %v\n%s", err, out)
+	}
+}
+
+func arm64ClosureResolve(symbol string) string {
+	symbol = goStripABISuffix(symbol)
+	if strings.HasPrefix(symbol, "·") {
+		return "internal/bytealg." + strings.TrimPrefix(symbol, "·")
+	}
+	return strings.ReplaceAll(symbol, "·", ".")
+}
+
+func TestARM64ClosureOriginalSourceAllAPIsObjects(t *testing.T) {
+	pkg, source := arm64ClosureSourceAndPackage(t)
+	requireARM64ClosureOriginalGoObject(t, source)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			name := "runtime.memequal_varlen"
+			opt := GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: triple, ResolveSym: arm64ClosureResolve,
+				ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, triple)},
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			bound, err := translateGoModuleInContext(ctx, pkg, source, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer bound.Module.Dispose()
+			sig := bound.Signatures[name]
+			if !reflect.DeepEqual(sig.Args, []LLVMType{Ptr, Ptr}) || sig.Ret != I1 || len(sig.ARM64GoRegisterABI.Params) != 2 {
+				t.Fatalf("hidden input changed semantic signature: %+v", sig)
+			}
+			file, err := Parse(ArchARM64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			lowOpt := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: arm64ClosureResolve, Sigs: bound.Signatures}
+			text, err := Translate(file, lowOpt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			moduleCtx := llvm.NewContext()
+			defer moduleCtx.Dispose()
+			module, err := TranslateModuleInContext(moduleCtx, file, lowOpt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			if indirectMarkerComparableIR(text) != indirectMarkerComparableIR(bound.Module.String()) ||
+				indirectMarkerComparableIR(text) != indirectMarkerComparableIR(module.String()) {
+				t.Fatal("public translation APIs disagree on original typed closure source")
+			}
+			want := "ptr " + sig.ARM64ClosureABI.llvmAttribute()
+			if !strings.Contains(text, want+" %closure") {
+				t.Fatalf("required physical context missing %q", want)
+			}
+			compileLLVMToObject(t, llc, triple, "closure.ll", "closure.o", text)
+		})
+	}
+}
+
+func TestARM64ClosureCarrierMalformedAndMissingContexts(t *testing.T) {
+	pkg, source := arm64ClosureSourceAndPackage(t)
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		for _, tc := range []struct {
+			name string
+			edit func(*ARM64ClosureABI)
+		}{
+			{"wrong_register", func(a *ARM64ClosureABI) { a.ContextRegister = "R25" }},
+			{"wrong_identity", func(a *ARM64ClosureABI) { a.EntrySymbol = "runtime.memequal" }},
+			{"wrong_code_offset", func(a *ARM64ClosureABI) { a.CodeOffset = 8 }},
+			{"wrong_code_type", func(a *ARM64ClosureABI) { a.CodeType = I64 }},
+			{"wrong_capture_offset", func(a *ARM64ClosureABI) { a.CaptureOffset = 16 }},
+			{"wrong_capture_width", func(a *ARM64ClosureABI) { a.CaptureType = I32 }},
+			{"absent_transport", func(a *ARM64ClosureABI) { a.Transport = 0 }},
+			{"wrong_transport", func(a *ARM64ClosureABI) { a.Transport = 3 - a.Transport }},
+			{"absent", nil},
+		} {
+			t.Run(triple+"/"+tc.name, func(t *testing.T) {
+				name := "runtime.memequal_varlen"
+				abi := arm64TestClosureABI(name, triple)
+				opt := GoModuleOptions{GOARCH: "arm64", TargetTriple: triple, ResolveSym: arm64ClosureResolve}
+				if tc.edit != nil {
+					tc.edit(&abi)
+					opt.ARM64ClosureABIs = map[string]ARM64ClosureABI{name: abi}
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				tr, err := translateGoModuleInContext(ctx, pkg, source, opt)
+				if err == nil {
+					tr.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved carrier accepted: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ClosureSourceBoundReadOnlyCarrier(t *testing.T) {
+	for _, source := range []string{
+		"MOVD 0(R26),R0", "MOVD 16(R26),R0", "MOVWU 8(R26),R0",
+		"MOVD.P 8(R26),R0", "MOVD.W 8(R26),R0", "MOVD 8(R26),R26",
+		"MOVD R26,R3\nMOVD 8(R3),R0", "ADD $8,R26,R3\nMOVD (R3),R0",
+		"MOVD R0,8(R26)\nMOVD 8(R26),R0", "MOVD R0,(R1)\nMOVD 8(R26),R0",
+		"MOVD R0,saved(SB)\nMOVD 8(R26),R0", "MOVD saved(SB),R0\nMOVD 8(R26),R0",
+		"MOVD R26,saved(SB)\nMOVD 8(R26),R0", "MOVD $8(R26),R3\nMOVD 8(R26),R0",
+		"MOVD 8(R26),R0\nB done\ndead:\nMOVD R26,R3\ndone:",
+		"WORD $0xf9400340", // raw MOVD 0(R26),R0: code word, not capture data.
+		"WORD $0xffffffff\nMOVD 8(R26),R0",
+	} {
+		t.Run(strings.ReplaceAll(source, "\n", ";"), func(t *testing.T) {
+			pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64, uint64) uint64\n")
+			asm := "TEXT ·Capture<ABIInternal>(SB),4,$0-24\n" + source + "\nRET\n"
+			// Raw WORD acceptance is syntax only, never a claim its bits are a
+			// valid executable instruction. The unknown raw negative is retained.
+			requireARM64ClosureGoObject(t, asm)
+			name := "test/closure.Capture"
+			opt := GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+				ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			tr, err := translateGoModuleInContext(ctx, pkg, []byte(asm), opt)
+			if err == nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("source without bounded immutable carrier read accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ClosureDirectReferencesDoNotInventCarrier(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64) uint64\nfunc Caller(uint64) uint64\n")
+	for _, edge := range []string{
+		"CALL ·Capture<ABIInternal>(SB)", "BL ·Capture<ABIInternal>(SB)",
+		"B ·Capture<ABIInternal>(SB)", "JMP ·Capture<ABIInternal>(SB)", "RET ·Capture<ABIInternal>(SB)",
+		"MOVD $·Capture<ABIInternal>(SB),R0", "MOVD ·Capture<ABIInternal>(SB),R0",
+	} {
+		t.Run(edge, func(t *testing.T) {
+			source := arm64ClosureEntrySource + "\nTEXT ·Caller<ABIInternal>(SB),4,$0-16\n" + edge + "\nRET\n"
+			requireARM64ClosureGoObject(t, source)
+			name := "test/closure.Capture"
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+				ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+			})
+			if err == nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("ordinary source edge invented required env: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ClosureDataAndExcludedSiblingDoNotInventCarrier(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64) uint64\nfunc Caller(uint64) uint64\n")
+	for _, extra := range []string{
+		"DATA holder<>(SB)/8,$·Capture<ABIInternal>(SB)\nGLOBL holder<>(SB),8,$8\n",
+		"TEXT ·Caller<ABIInternal>(SB),4,$0-16\nMOVD $·Capture<ABIInternal>(SB),R0\nRET\n",
+	} {
+		source := arm64ClosureEntrySource + "\n" + extra
+		requireARM64ClosureGoObject(t, source)
+		name := "test/closure.Capture"
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+			ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+			KeepFunc:         func(_, resolved string) bool { return resolved == name },
+			ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+		})
+		if err == nil {
+			tr.Module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("DATA or excluded sibling invented carrier: %v", err)
+		}
+	}
+}
+
+func TestARM64ClosureGoBindingRequiresActualDeclaration(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\n")
+	name := "test/closure.Capture"
+	sig := FuncSig{Name: name, Args: []LLVMType{I64}, Ret: I64}
+	var err error
+	sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	tr, err := translateGoModuleInContext(ctx, pkg, []byte(arm64ClosureEntrySource), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+		ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+		ManualSig:        func(string) (FuncSig, bool) { return sig, true },
+		ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+	})
+	if err == nil {
+		tr.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("manual scalar signature fabricated a source declaration: %v", err)
+	}
+}
+
+func TestARM64ClosureNeedsSourceSelectorAndReachingContext(t *testing.T) {
+	pkg := mustGoPackage(t, "test/closure", "package closure\nfunc Capture(uint64) uint64\nfunc Compute()\n")
+	name := "test/closure.Capture"
+	for _, source := range []string{
+		strings.Replace(arm64ClosureEntrySource, "<ABIInternal>", "", 1),
+		strings.Replace(arm64ClosureEntrySource, "<ABIInternal>", "<ABI0>", 1),
+		strings.Replace(arm64ClosureEntrySource, "MOVD 8(R26)", "CALL ·Compute<ABIInternal>(SB)\nMOVD 8(R26)", 1),
+	} {
+		requireARM64ClosureGoObject(t, source)
+		ctx := llvm.NewContext()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: "aarch64-apple-darwin",
+			ResolveSym:       func(sym string) string { return "test/closure." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+			ARM64ClosureABIs: map[string]ARM64ClosureABI{name: arm64TestClosureABI(name, "aarch64-apple-darwin")},
+		})
+		if err == nil {
+			tr.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("missing source entry/reaching context accepted: %v", err)
+		}
+		if strings.Contains(source, "CALL") && !strings.Contains(err.Error(), "R26 read") {
+			t.Fatalf("a call must invalidate the hidden input, not just hit another guard: %v", err)
+		}
+	}
+}
+
+func TestARM64ClosureArchitectureAllAPIsFailClosed(t *testing.T) {
+	for _, arch := range []struct {
+		arch           Arch
+		goarch, triple string
+	}{
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown"},
+	} {
+		sig := FuncSig{Name: "Capture", Args: []LLVMType{I64}, Ret: I64}
+		var err error
+		sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+		if err != nil {
+			t.Fatal(err)
+		}
+		abi := arm64TestClosureABI(sig.Name, "aarch64-unknown-linux-gnu")
+		sig.ARM64ClosureABI = &abi
+		file, err := Parse(arch.arch, "TEXT Capture(SB),$0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		assertARM64ClosureAllAPIsContext(t, file, Options{
+			Goarch: arch.goarch, TargetTriple: arch.triple,
+			Sigs: map[string]FuncSig{sig.Name: sig},
+		})
+	}
+}
+
+func assertARM64ClosureAllAPIsContext(t *testing.T, file *File, opt Options) {
+	t.Helper()
+	if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("text API accepted unproved carrier: %v", err)
+	}
+	if module, err := TranslateModule(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		if err == nil {
+			module.Dispose()
+		}
+		t.Fatalf("module API accepted unproved carrier: %v", err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if module, err := TranslateModuleInContext(ctx, file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		if err == nil {
+			module.Dispose()
+		}
+		t.Fatalf("owned-context API accepted unproved carrier: %v", err)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ClosureOriginalSource(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg, source := arm64ClosureSourceAndPackage(t)
+	name := "runtime.memequal_varlen"
+	abi := arm64TestClosureABI(name, triple)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	tr, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: arm64ClosureResolve,
+		ARM64ClosureABIs: map[string]ARM64ClosureABI{name: abi},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	// The immutable LLVM-side producer owns the exact {entry,size} lifetime.
+	// It transports the whole carrier through Nest/SwiftSelf, not an ordinary
+	// third Go argument, a descriptor env or a synthesized R26 zero.
+	shim := fmt.Sprintf(`
+define i1 @invoke(ptr %%a, ptr %%b, i64 %%size) {
+  %%carrier = alloca {ptr, i64}, align 8
+  store {ptr, i64} {ptr @runtime.memequal_varlen, i64 0}, ptr %%carrier
+  %%sizeptr = getelementptr {ptr, i64}, ptr %%carrier, i64 0, i32 1
+  store i64 %%size, ptr %%sizeptr
+  %%result = call i1 @runtime.memequal_varlen(ptr %s %%carrier, ptr %%a, ptr %%b)
+  ret i1 %%result
+}
+`, abi.llvmAttribute())
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "closure_original", triple, tr.Module.String()+shim, arm64ClosureRuntimeDriver, runner)
+	// Independent actual Go exercises the selected compiler's real interface
+	// equality closure producer and original runtime entry, without importing
+	// unsafe addresses or changing any caller's stack/return link.
+	runARM64GoInternalOracle(t, "#include \"textflag.h\"\nTEXT ·Unused<ABIInternal>(SB),NOSPLIT,$0-0\nRET\n", arm64ClosureGoOracle, len(runner) != 0)
+}
+
+const arm64ClosureRuntimeDriver = `#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+extern bool invoke(const unsigned char *, const unsigned char *, uint64_t);
+int main(void) {
+  unsigned char a[264], b[264];
+  uint64_t sizes[] = {0,1,2,3,4,7,8,15,16,17,23,24,31,32,37,63,64,65,127,128,129,255,256};
+  for (int i=0; i<264; i++) a[i]=b[i]=(unsigned char)(i*131+17);
+  for (int offset=0; offset<4; offset++) {
+    for (unsigned j=0; j<sizeof(sizes)/sizeof(sizes[0]); j++) {
+      uint64_t n=sizes[j];
+      if (!invoke(a+offset,b+offset,n) || !invoke(a+offset,a+offset,n)) return 1;
+      for (uint64_t k=0; k<n; k++) {
+        b[offset+k]^=0x80;
+        if (invoke(a+offset,b+offset,n) || invoke(b+offset,a+offset,n)) return 2;
+        b[offset+k]^=0x80;
+      }
+      if (invoke(a+offset,b+offset,n)!=(memcmp(a+offset,b+offset,n)==0)) return 3;
+    }
+  }
+  return 0;
+}
+`
+
+const arm64ClosureGoOracle = `package main
+func Unused()
+type Bytes24 [24]byte
+func main() {
+  var a,b Bytes24
+  for i:=range a { a[i]=byte(i*131+17); b[i]=a[i] }
+  var x any=a
+  if x!=any(b) { panic("actual Go closure equality") }
+  for i:=range b {
+    b[i]^=0x80
+    if x==any(b) || any(b)==x { panic("actual Go closure inequality") }
+    b[i]^=0x80
+  }
+  if x!=any(b) { panic("actual Go closure restoration") }
+}
+`
diff --git a/arm64_code_address_provenance_test.go b/arm64_code_address_provenance_test.go
new file mode 100644
index 000000000..7a4f6ac1e
--- /dev/null
+++ b/arm64_code_address_provenance_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64CodeAddressTransformsRetainSourceDerivedProvenance(t *testing.T) {
+	inputs := []struct {
+		name  string
+		value arm64ControlValue
+	}{
+		{"pure", arm64ControlFromMap(map[string]bool{"label:caller": true})},
+		{"joined_unknown", arm64ControlFromMap(map[string]bool{"label:caller": true, "": true})},
+		{"already_derived", arm64ControlFromMap(map[string]bool{"label:caller": true, "code-derived:": true, "": true})},
+	}
+	for _, form := range []struct {
+		name, instruction string
+		transforms        bool
+	}{
+		{"move", "MOVD R10,R11", false},
+		{"add_zero", "ADD $0,R10,R11", false},
+		{"sub_zero", "SUB $0,R10,R11", false},
+		{"add_positive", "ADD $4,R10,R11", true},
+		{"add_negative", "ADD $-4,R10,R11", true},
+		{"sub_positive", "SUB $4,R10,R11", true},
+		{"sub_negative", "SUB $-4,R10,R11", true},
+		{"address_positive", "MOVD $4(R10),R11", true},
+		{"address_negative", "MOVD $-4(R10),R11", true},
+		{"dynamic_add", "ADD R12,R10,R11", true},
+		{"dynamic_sub", "SUB R12,R10,R11", true},
+		{"xor", "EOR $4,R10,R11", true},
+		{"or", "ORR $4,R10,R11", true},
+		{"and", "AND $-16,R10,R11", true},
+		{"shift_left", "LSL $2,R10,R11", true},
+		{"shift_right", "LSR $2,R10,R11", true},
+		{"arithmetic_shift", "ASR $2,R10,R11", true},
+		{"rotate", "ROR $2,R10,R11", true},
+		{"signed_narrow", "MOVW R10,R11", true},
+		{"unsigned_narrow", "MOVWU R10,R11", true},
+		{"negate", "NEG R10,R11", true},
+		{"reverse", "REV R10,R11", true},
+	} {
+		t.Run(form.name, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT provenance(SB),4,$16-0\n%s\nRET\n", form.instruction)
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			for _, input := range inputs {
+				t.Run(input.name, func(t *testing.T) {
+					caller := arm64ControlFromMap(map[string]bool{"label:caller": true})
+					state := &arm64ControlState{
+						unexposedSP: true,
+						regs: map[Reg]arm64ControlValue{
+							SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R9": arm64ControlExternal(),
+							"R10": input.value, "R12": arm64ControlExternal(),
+						},
+						memory: map[string]arm64ControlValue{"sp:0": caller},
+					}
+					state.transfer(ins, arm64ControlOp(ins), false, nil)
+					value := state.regs["R11"]
+					derived := form.transforms || arm64ControlHas(input.value, "code-derived:")
+					if arm64ControlHas(value, "code-derived:") != derived || !arm64ControlHas(value, "label:caller") {
+						t.Fatalf("source transform lost code provenance: instruction=%q, input=%v, output=%v", form.instruction, input.value, value)
+					}
+					state.write(Operand{Kind: OpMem, Mem: MemRef{Base: "R9"}}, value, false)
+					intact := arm64ControlEqual(state.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP}}, false), caller)
+					if intact == derived {
+						t.Fatalf("derived=%t must control saved-LR uncertainty, memory=%v, escaped=%v", derived, state.memory, state.escaped)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARM64CodeAddressOffsetRetainsProvenanceAcrossUnknownJoins(t *testing.T) {
+	for _, input := range []arm64ControlValue{
+		arm64ControlFromMap(map[string]bool{"label:caller": true}),
+		arm64ControlFromMap(map[string]bool{"label:caller": true, "": true}),
+		arm64ControlFromMap(map[string]bool{"code-derived:": true, "": true}),
+	} {
+		for _, offset := range []int64{-1 << 63, -4, 4, 1<<63 - 1} {
+			t.Run(fmt.Sprintf("%v/%d", input, offset), func(t *testing.T) {
+				value := arm64ControlOffset(input, offset)
+				if !arm64ControlHas(value, "code-derived:") || !arm64ControlHas(value, "") {
+					t.Fatalf("native-PC offset became ordinary unknown data: %v", value)
+				}
+				state := &arm64ControlState{
+					regs:   map[Reg]arm64ControlValue{"R10": value},
+					memory: map[string]arm64ControlValue{"fp:0": value},
+				}
+				state.merge(&arm64ControlState{
+					regs:   map[Reg]arm64ControlValue{"R10": arm64ControlExternal()},
+					memory: map[string]arm64ControlValue{},
+				})
+				for location, joined := range map[string]arm64ControlValue{
+					"register": state.regs["R10"], "memory": state.memory["fp:0"],
+				} {
+					if !arm64ControlHas(arm64ControlLabels(joined), "code-derived:") || !arm64ControlHas(arm64ControlAddressTaint(joined), "code-derived:") {
+						t.Errorf("%s filtering washed away a source-derived PC: %v", location, joined)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_conditional_compare_effects_test.go b/arm64_conditional_compare_effects_test.go
new file mode 100644
index 000000000..f673229bd
--- /dev/null
+++ b/arm64_conditional_compare_effects_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ConditionalCompareSourceBoundEffects(t *testing.T) {
+	for _, bits := range []int{16, 32, 64} {
+		for _, signaling := range []bool{false, true} {
+			for _, condition := range []int{0, 8, 10, 12, 14, 15} {
+				form, known := decodeARM64RawConditionalCompare(arm64ConditionalTestWord(bits, condition, 10, 0, 31, signaling))
+				if !known {
+					t.Fatal("complete typed raw family missing")
+				}
+				// Every potential input byte is required even when the source
+				// predicate happens to be false; it cannot grant caller data.
+				for hole := -1; hole < 2*bits/8; hole++ {
+					ctx, flow := arm64FlagScratchBankFixture()
+					ctx.targetTriple = "aarch64-unknown-linux-gnu"
+					ctx.vRegSlot = map[int]string{0: "%left", 31: "%right"}
+					flow.used, flow.entry = true, &ARM64GoRegisterABI{}
+					for _, slot := range []string{ctx.flagsNSlot, ctx.flagsZSlot, ctx.flagsCSlot, ctx.flagsVSlot} {
+						ctx.storeFlag(slot, "false")
+					}
+					for source, register := range []string{"V0", "V31"} {
+						for offset := 0; offset < bits; offset += 8 {
+							if hole == source*bits/8+offset/8 {
+								continue
+							}
+							flow.blocks[0].effects = append(flow.blocks[0].effects, arm64MachineEffect{
+								register: register, width: 8, vectorOffset: offset, vectorSpan: true, write: true,
+							})
+						}
+					}
+					before, start := len(flow.blocks[0].effects), ctx.b.Len()
+					if err := ctx.lowerARM64ConditionalCompare(form); err != nil {
+						t.Fatal(err)
+					}
+					ctx.recordMachineOpaqueIR(start, Instr{})
+					reads, flagsRead, flagsWritten := 0, arm64FlagMask(0), arm64FlagMask(0)
+					for _, effect := range flow.blocks[0].effects[before:] {
+						if effect.opaque || effect.store || effect.unavailable {
+							t.Fatalf("conditional compare gained unrelated effects: %+v", effect)
+						}
+						if effect.nzcv != 0 {
+							if effect.write {
+								flagsWritten |= effect.nzcv
+							} else {
+								flagsRead |= effect.nzcv
+							}
+						} else {
+							if effect.write || effect.width != bits || effect.register != "V0" && effect.register != "V31" {
+								t.Fatalf("conditional compare changed SIMD role: %+v", effect)
+							}
+							reads++
+						}
+					}
+					wantRead := []arm64FlagMask{arm64FlagZ, arm64FlagC | arm64FlagZ, arm64FlagN | arm64FlagV, arm64FlagN | arm64FlagV | arm64FlagZ, 0, 0}
+					index := map[int]int{0: 0, 8: 1, 10: 2, 12: 3, 14: 4, 15: 5}[condition]
+					if reads != 2 || flagsWritten != arm64FlagAll || flagsRead != wantRead[index] {
+						t.Fatalf("wrong typed reads/effects: reads=%d flags=%x/%x", reads, flagsRead, flagsWritten)
+					}
+					err := flow.validate()
+					if hole < 0 && err != nil || hole >= 0 && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("input byte hole %d width %d condition %d: %v", hole, bits, condition, err)
+					}
+					start = ctx.b.Len()
+					fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+					ctx.recordMachineOpaqueIR(start, Instr{})
+					if !flow.blocks[0].effects[len(flow.blocks[0].effects)-1].opaque {
+						t.Fatal("native conditional compare proof leaked to another instruction")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ConditionalCompareFlagsFollowWholeCFG(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for condition, spelling := range arm64ConditionalTestConditions {
+			for _, raw := range []bool{false, true} {
+				row := arm64ConditionalTestCase{32, condition, 10, 0, 31, false, raw, false, false}
+				for _, complete := range []bool{false, true} {
+					prefix := ""
+					if complete {
+						prefix = "CMP R0,R0\n"
+					}
+					source := "TEXT comparison(SB),4,$0-0\n" + prefix + "CBZ R0,use\nCMP R0,R0\nuse:\n" + row.instruction() + "\nRET\n"
+					present, err := arm64CompareTargetAPI(t, api, source, "aarch64-unknown-linux-gnu")
+					if complete || condition >= 14 {
+						if !present || err != nil {
+							t.Fatalf("%s %s defined CFG rejected: %v", api, spelling, err)
+						}
+					} else if present || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s %s missing predecessor flags gained output: %t %v", api, spelling, present, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ConditionalCompareDirectHelperBoundaries(t *testing.T) {
+	for _, target := range []string{"", "x86_64-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu"} {
+		ctx, _ := arm64FlagScratchBankFixture()
+		ctx.targetTriple = target
+		instruction := arm64ImmediateTestInstruction(t, "FCCMPS AL,F0,F1,$0")
+		known, _, err := ctx.lowerARM64FloatConditionalCompare(instruction.Op, instruction)
+		if !known || !errors.Is(err, ErrProbeNeedsContext) || ctx.b.Len() != 0 {
+			t.Fatalf("direct helper bypassed target before IR: %t %v", known, err)
+		}
+	}
+	ctx, _ := arm64FlagScratchBankFixture()
+	instruction := arm64ImmediateTestInstruction(t, "FCCMPD AL,F0,F1,$0")
+	if known, _, err := ctx.lowerARM64FloatConditionalCompare("FADDD", instruction); known || err != nil || ctx.b.Len() != 0 {
+		t.Fatal("conditional family claimed an unrelated dispatch operation")
+	}
+	for _, condition := range []string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE"} {
+		ctx, _ := arm64FlagScratchBankFixture()
+		ctx.targetTriple, ctx.flagsKnown, ctx.flagsWritten = "aarch64-unknown-linux-gnu", 0, false
+		instruction := arm64ImmediateTestInstruction(t, "FCCMPS "+condition+",F0,F1,$0")
+		known, _, err := ctx.lowerARM64FloatConditionalCompare(instruction.Op, instruction)
+		if !known || !errors.Is(err, ErrProbeNeedsContext) || strings.Contains(ctx.b.String(), "asm sideeffect") {
+			t.Fatalf("direct helper fabricated source NZCV for %s: %v", condition, err)
+		}
+	}
+}
+
+func TestARM64ConditionalCompareRawPoolRevokesEarlierIntegerFlags(t *testing.T) {
+	for _, bits := range []int{16, 32, 64} {
+		for _, signaling := range []bool{false, true} {
+			for condition := 0; condition < 16; condition++ {
+				for flags := 0; flags < 16; flags++ {
+					word := arm64ConditionalTestWord(bits, condition, flags, 0, 31, signaling)
+					writes, known := arm64RawPoolGPWrites(word)
+					if !known || writes != 0 {
+						t.Fatalf("raw conditional comparison changed its GP domain: %#08x %x %t", word, writes, known)
+					}
+					// CMP X1,#7; FCCMP; NOP. The float comparison may write
+					// either computed or immediate NZCV, so an old integer bound
+					// must not survive merely because there are no GP writes.
+					flow := &arm64RawPoolValues{
+						words:  []uint32{0xf1001c3f, word, 0xd503201f},
+						before: [][]int{{-1}, {0}, {1}},
+					}
+					if _, _, _, valid := flow.affineFlagSourceBefore(2); valid {
+						t.Fatalf("raw FCCMP retained an unrelated integer address bound: %#08x", word)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_conditional_compare_forms_test.go b/arm64_conditional_compare_forms_test.go
new file mode 100644
index 000000000..2a7298be8
--- /dev/null
+++ b/arm64_conditional_compare_forms_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var arm64ConditionalTestConditions = []string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "NV"}
+
+// Independent DDI0602 bit layout, not the production decoder or named table.
+func arm64ConditionalTestWord(bits, condition, nzcv, left, right int, signaling bool) uint32 {
+	word := uint32(0x1e200400) | uint32(left)<<5 | uint32(right)<<16 | uint32(condition)<<12 | uint32(nzcv)
+	if bits == 64 {
+		word |= 1 << 22
+	} else if bits == 16 {
+		word |= 3 << 22
+	}
+	if signaling {
+		word |= 1 << 4
+	}
+	return word
+}
+
+func TestARM64ConditionalCompareCompleteGoTableAndBytes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	sdk := string(data)
+	rows := regexp.MustCompile(`(?m)^\s*\{AFCCMP[^\n]+`).FindAllString(sdk, -1)
+	if len(rows) != 1 {
+		t.Fatalf("Go FCCMP family acquired an unreviewed row: %v", rows)
+	}
+	fields := strings.Split(strings.Trim(strings.TrimSpace(rows[0]), "{},"), ",")
+	for i := range fields {
+		fields[i] = strings.TrimSpace(fields[i])
+	}
+	want := []string{"AFCCMPS", "C_COND", "C_FREG", "C_FREG", "C_VCON", "57", "4", "0", "0", "0"}
+	if len(fields) == 11 {
+		want = append(append([]string{}, want[:5]...), append([]string{"C_NONE"}, want[5:]...)...)
+	}
+	if !reflect.DeepEqual(fields, want) {
+		t.Fatalf("complete Go FCCMP row changed: %v", fields)
+	}
+	alias := regexp.MustCompile(`case AFCCMPS:\s*((?:oprangeset\([^\n]+\)\s*)+)`).FindStringSubmatch(sdk)
+	if len(alias) != 2 || strings.Join(strings.Fields(alias[1]), " ") != "oprangeset(AFCCMPD, t) oprangeset(AFCCMPES, t) oprangeset(AFCCMPED, t)" {
+		t.Fatalf("complete Go FCCMP inheritance changed: %v", alias)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT original(SB),516,$0-0\n")
+	var expected []uint32
+	appendRow := func(operation, condition string, code, flags, left, right, bits int, signaling bool) {
+		line := fmt.Sprintf("%s %s,F%d,F%d,$%d", operation, condition, right, left, flags)
+		source.WriteString(line + "\n")
+		expected = append(expected, arm64ConditionalTestWord(bits, code, flags, left, right, signaling))
+		instruction := arm64ImmediateTestInstruction(t, line)
+		form, known, err := parseARM64ConditionalCompare(instruction.Op, instruction)
+		if !known || err != nil || form.bits != bits || form.signaling != signaling ||
+			form.left != Reg(fmt.Sprintf("F%d", left)) || form.right != Reg(fmt.Sprintf("F%d", right)) || form.nzcv != uint8(flags) {
+			t.Fatalf("typed Go row differs: %s %+v %v", line, form, err)
+		}
+	}
+	for _, operation := range arm64ConditionalCompareNames {
+		bits, signaling := 32, strings.Contains(operation, "E")
+		if strings.HasSuffix(operation, "D") {
+			bits = 64
+		}
+		for condition, spelling := range arm64ConditionalTestConditions {
+			for flags := 0; flags < 16; flags++ {
+				appendRow(operation, spelling, condition, flags, 0, 31, bits, signaling)
+			}
+		}
+		for left := 0; left < 32; left++ {
+			for right := 0; right < 32; right++ {
+				appendRow(operation, "AL", 14, 15, left, right, bits, signaling)
+			}
+		}
+		appendRow(operation, "HS", 2, 0, 31, 0, bits, signaling)
+		appendRow(operation, "LO", 3, 15, 31, 0, bits, signaling)
+	}
+	source.WriteString("RET\n")
+	actual := arm64ImmediateOriginalGoBytes(t, source.String(), "linux")
+	if len(actual) < 4*(len(expected)+1) {
+		t.Fatalf("short actual Go object: %d bytes", len(actual))
+	}
+	for index, word := range expected {
+		if got := binary.LittleEndian.Uint32(actual[index*4:]); got != word {
+			t.Fatalf("original Go case %d got %#08x want %#08x", index, got, word)
+		}
+	}
+	t.Logf("%d actual Go words: complete inherited row, conditions/flags and both register banks", len(expected))
+}
+
+func TestARM64ConditionalCompareRawCompleteFields(t *testing.T) {
+	count := 0
+	for _, bits := range []int{16, 32, 64} {
+		for _, signaling := range []bool{false, true} {
+			check := func(condition, flags, left, right int) {
+				word := arm64ConditionalTestWord(bits, condition, flags, left, right, signaling)
+				form, known := decodeARM64RawConditionalCompare(word)
+				if !known || form.bits != bits || form.signaling != signaling || form.nzcv != uint8(flags) ||
+					form.condition != arm64ConditionalTestConditions[condition] || form.left != Reg(fmt.Sprintf("F%d", left)) || form.right != Reg(fmt.Sprintf("F%d", right)) {
+					t.Fatalf("raw family %#08x: %+v known=%t", word, form, known)
+				}
+				count++
+			}
+			for condition := 0; condition < 16; condition++ {
+				for flags := 0; flags < 16; flags++ {
+					check(condition, flags, 0, 31)
+				}
+			}
+			for left := 0; left < 32; left++ {
+				for right := 0; right < 32; right++ {
+					check(14, 15, left, right)
+				}
+			}
+		}
+	}
+	const fixed = uint32(0xff200c00)
+	for bit := uint(0); bit < 32; bit++ {
+		if fixed&(1<<bit) == 0 {
+			continue
+		}
+		if _, known := decodeARM64RawConditionalCompare(0x1e200400 ^ (1 << bit)); known {
+			t.Fatalf("reserved fixed bit %d admitted", bit)
+		}
+	}
+	if _, known := decodeARM64RawConditionalCompare(0x1ea00400); known {
+		t.Fatal("reserved ftype=2 admitted")
+	}
+	t.Logf("%d independent raw operand/condition/NZCV field observations; not runtime credit", count)
+}
+
+func TestARM64ConditionalCompareNativeIndependentAxisObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT compareMatrix0(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n")
+	for bank := 0; bank < 32; bank++ {
+		fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", bank)
+	}
+	source.WriteString("CMP R0,R0\n")
+	count := 0
+	for _, operation := range arm64ConditionalCompareNames {
+		for _, condition := range append(append([]string{}, arm64ConditionalTestConditions...), "HS", "LO") {
+			fmt.Fprintf(&source, "%s %s,F31,F0,$15\n", operation, condition)
+			count++
+		}
+		for flags := 0; flags < 16; flags++ {
+			fmt.Fprintf(&source, "%s EQ,F0,F31,$%d\n", operation, flags)
+			count++
+		}
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "%s AL,F%d,F%d,$0\n", operation, bank, bank)
+			count++
+		}
+	}
+	for _, bits := range []int{16, 32, 64} {
+		for _, signaling := range []bool{false, true} {
+			for condition := 0; condition < 16; condition++ {
+				fmt.Fprintf(&source, "WORD $%#08x\n", arm64ConditionalTestWord(bits, condition, condition, 31, 0, signaling))
+				count++
+			}
+		}
+	}
+	source.WriteString("CMP R0,R0\nCSET EQ,R2\nMOVD R2,(R1)\nRET\n")
+	for _, target := range []struct{ os, triple string }{{"linux", "aarch64-unknown-linux-gnu"}, {"darwin", "aarch64-apple-darwin"}, {"windows", "aarch64-pc-windows-msvc"}} {
+		t.Run(target.os, func(t *testing.T) {
+			arm64CompareGoObject(t, source.String(), target.os)
+			for api, ir := range arm64CompareMatrixIRs(t, source.String(), "package compare\nfunc compareMatrix0(*[66]uint64,*[69]uint64)\n", target.triple) {
+				optimized := armFloatEffectOptimizedIR(t, ir)
+				if strings.Count(optimized, `asm sideeffect "cmp `) != count {
+					t.Fatalf("API%d lost a native conditional effect", api)
+				}
+				compileLLVMToObject(t, llc, target.triple, "conditional.ll", "conditional.o", optimized)
+			}
+		})
+	}
+	t.Logf("%d initialized independent-axis forms x three APIs x three target objects", count)
+}
+
+func TestARM64ConditionalCompareNativeBoundaryErrors(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+			for _, invalid := range []string{"FCCMPD EQ,F0,F1,$(0.0)", "FCCMPD EQ,F0,F1,$16", "FCCMPD EQ,R0,F1,$0", "FCCMPD.P EQ,F0,F1,$0", "FCCMPD BAD,F0,F1,$0", "WORD $0x1ea00400"} {
+				for _, prefix := range []string{"", "FCCMPS AL,F0,F1,$0\nRET\n"} {
+					source := "TEXT comparison(SB),4,$0-0\n" + prefix + invalid + "\nRET\n"
+					present, err := arm64CompareTargetAPI(t, api, source, triple)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s malformed/dead form became Context/output: %t %v\n%s", api, present, err, source)
+					}
+				}
+			}
+			if triple == "aarch64-unknown-linux-gnu" {
+				continue
+			}
+			for _, instruction := range []string{"FCCMPS AL,F0,F1,$0", "FCCMPED NV,F31,F0,$15", "WORD $0x1ee0e400"} {
+				present, err := arm64CompareTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\nRET\n"+instruction+"\n", triple)
+				if present || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s unbound native target acquired output: %t %v", api, present, err)
+				}
+			}
+		}
+	}
+	for _, operation := range arm64ConditionalCompareNames {
+		for _, arguments := range []string{"EQ,F0,F1,$(0.0)", "EQ,F0,F1,$-1", "EQ,F0,F1,$16", "BAD,F0,F1,$0", "EQ,R0,F1,$0", "EQ,F0,(R1),$0", "EQ,F0,F1"} {
+			requireARM64GoAssemblerResult(t, "TEXT original(SB),4,$0-0\n"+operation+" "+arguments+"\nRET\n", false)
+		}
+	}
+}
diff --git a/arm64_conditional_compare_native_linux_test.go b/arm64_conditional_compare_native_linux_test.go
new file mode 100644
index 000000000..2bc0c27c7
--- /dev/null
+++ b/arm64_conditional_compare_native_linux_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ConditionalCompareDeadNative(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64ConditionalCompareDeadRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ConditionalCompareWholeState(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64ConditionalStatusRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_conditional_compare_native_test.go b/arm64_conditional_compare_native_test.go
new file mode 100644
index 000000000..d77d23676
--- /dev/null
+++ b/arm64_conditional_compare_native_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var arm64ConditionalCompareNames = []string{"FCCMPS", "FCCMPD", "FCCMPES", "FCCMPED"}
+
+func arm64ConditionalCompareDeadFixture() (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index, operation := range arm64ConditionalCompareNames {
+		for mode := 0; mode < 2; mode++ {
+			name := fmt.Sprintf("compareConditional%d_%d", index, mode)
+			fmt.Fprintf(&declarations, "func %s(*[5]uint64,*[4]uint64)\n", name)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+			source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD 24(R0),R2\nMSR R2,FPCR\nMOVD 32(R0),R2\nMSR R2,FPSR\n")
+			move := "FMOVS"
+			if strings.HasSuffix(operation, "D") {
+				move = "FMOVD"
+			}
+			fmt.Fprintf(&source, "%s (R0),F0\n%s 8(R0),F31\nMOVD 16(R0),R2\nCMP $0,R2\n%s NE,F31,F0,$10\n", move, move, operation)
+			if mode == 1 {
+				source.WriteString("CMP R0,R0\n")
+			}
+			source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET CS,R4\nCSET VS,R5\nLSL $3,R2,R2\nLSL $2,R3,R3\nLSL $1,R4,R4\nORR R3,R2,R2\nORR R4,R2,R2\nORR R5,R2,R2\n")
+			source.WriteString("MRS FPSR,R3\nMRS FPCR,R4\nMOVD R2,(R1)\nMOVD R3,8(R1)\nMOVD R4,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func arm64ConditionalCompareDeadRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, declarations := arm64ConditionalCompareDeadFixture()
+	var original, driver strings.Builder
+	original.WriteString(strings.Replace(declarations, "package compare", "package main\nimport \"fmt\"", 1))
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range arm64ConditionalCompareNames {
+		for mode := 0; mode < 2; mode++ {
+			fmt.Fprintf(&driver, "extern void compareConditional%d_%d(uint64_t*,uint64_t*);\n", index, mode)
+		}
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) {\n")
+	count := 0
+	for index, operation := range arm64ConditionalCompareNames {
+		bits := 32
+		if strings.HasSuffix(operation, "D") {
+			bits = 64
+		}
+		values := arm64CompareValues(bits)
+		for _, value := range []uint64{values[6], values[8], values[10], values[2]} {
+			for _, initialFlags := range []uint64{0, 4 << 28} {
+				for _, control := range []uint64{0, 1 << 24} {
+					flags, status := arm64CompareExpected(bits, value, 0, control, strings.Contains(operation, "E"))
+					if initialFlags == 0 {
+						flags, status = 10, 0
+					}
+					status |= 0x10 // Existing cumulative status must not be cleared.
+					for mode := 0; mode < 2; mode++ {
+						wantFlags := flags
+						if mode == 1 {
+							wantFlags = 6
+						}
+						fmt.Fprintf(&original, "{ in:=[5]uint64{%#x,0,%#x,%#x,0x10}; out:=[4]uint64{0,0,0,0x1234}; compareConditional%d_%d(&in,&out); if out!=[4]uint64{%d,%d,%#x,0x1234} { panic(fmt.Sprintf(\"case %d got %%x\",out)) } }\n", value, initialFlags, control, index, mode, wantFlags, status, control, count)
+						fmt.Fprintf(&driver, "{ uint64_t in[5]={%#xULL,0,%#xULL,%#xULL,0x10},out[4]={0,0,0,0x1234}; compareConditional%d_%d(in,out); if(out[0]!=%d || out[1]!=%d || out[2]!=%#xULL || out[3]!=0x1234){fprintf(stderr,\"case %d %s got %%llx %%llx %%llx\\n\",(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2]);return 1;} }\n", value, initialFlags, control, index, mode, wantFlags, status, control, count, operation)
+						count++
+					}
+				}
+			}
+		}
+	}
+	fmt.Fprintf(&original, "fmt.Println(\"ARM64_COMPARE_ORIGINAL_PASS conditional %d rows\")\n}\n", count)
+	driver.WriteString("return 0;\n}\n")
+	arm64ScalarCompareActualGo(t, source, original.String(), goos, runner)
+	for api, ir := range arm64CompareMatrixIRs(t, source, declarations, triple) {
+		for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("api%d/IR_%s/backend_O%d", api, variant.name, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "conditional_compare_dead", triple, variant.ir, driver.String(), runner, level)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ConditionalCompareDeadNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU owner executes the same original Go fixture")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64ConditionalCompareDeadRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_conditional_compare_status_test.go b/arm64_conditional_compare_status_test.go
new file mode 100644
index 000000000..d575774c7
--- /dev/null
+++ b/arm64_conditional_compare_status_test.go
@@ -0,0 +1,296 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64ConditionalTestCase struct {
+	bits, condition, nzcv, left, right int
+	signaling, raw, dead, complete     bool
+}
+
+func arm64ConditionalStatusCases() []arm64ConditionalTestCase {
+	var cases []arm64ConditionalTestCase
+	for _, bits := range []int{16, 32, 64} {
+		for _, signaling := range []bool{false, true} {
+			for _, dead := range []bool{false, true} {
+				cases = append(cases, arm64ConditionalTestCase{bits, 1, 10, 0, 31, signaling, true, dead, true})
+			}
+			if bits != 16 {
+				cases = append(cases, arm64ConditionalTestCase{bits, 1, 10, 0, 31, signaling, false, false, true})
+			}
+		}
+	}
+	for condition := 0; condition < 16; condition++ {
+		cases = append(cases, arm64ConditionalTestCase{32, condition, condition, 31, 0, false, false, false, false})
+	}
+	for flags := 0; flags < 16; flags++ {
+		cases = append(cases, arm64ConditionalTestCase{64, 1, flags, 0, 31, true, false, false, false})
+	}
+	for bank := 0; bank < 32; bank++ {
+		cases = append(cases, arm64ConditionalTestCase{16, 1, 10, bank, bank, true, true, false, false})
+	}
+	return cases
+}
+
+func (row arm64ConditionalTestCase) instruction() string {
+	if row.raw {
+		return fmt.Sprintf("WORD $%#08x", arm64ConditionalTestWord(row.bits, row.condition, row.nzcv, row.left, row.right, row.signaling))
+	}
+	op := "FCCMP"
+	if row.signaling {
+		op += "E"
+	}
+	if row.bits == 32 {
+		op += "S"
+	} else {
+		op += "D"
+	}
+	return fmt.Sprintf("%s %s,F%d,F%d,$%d", op, arm64ConditionalTestConditions[row.condition], row.right, row.left, row.nzcv)
+}
+
+func arm64ConditionalStatusSource(cases []arm64ConditionalTestCase) (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index, row := range cases {
+		name := fmt.Sprintf("compareConditionalStatus%d", index)
+		fmt.Fprintf(&declarations, "func %s(*[68]uint64,*[69]uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", bank)
+		}
+		source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD (R0),R2\nMSR R2,FPCR\nMOVD 8(R0),R2\nMSR R2,FPSR\nMOVD 16(R0),R2\nMOVD 24(R0),R3\nCMP R3,R2\n")
+		source.WriteString(row.instruction() + "\n")
+		if row.dead {
+			source.WriteString("CMP R0,R0\n")
+		}
+		source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET CS,R4\nCSET VS,R5\nLSL $3,R2,R2\nLSL $2,R3,R3\nLSL $1,R4,R4\nORR R3,R2,R2\nORR R4,R2,R2\nORR R5,R2,R2\nMRS FPSR,R3\nMRS FPCR,R4\n")
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VST1.P [V%d.B16],16(R1)\n", bank)
+		}
+		source.WriteString("MOVD R2,(R1)\nMOVD R3,8(R1)\nMOVD R4,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+// Integer condition reference independent of both lowerer and its condValue.
+func arm64ConditionalTestTrue(condition int, flags uint64) bool {
+	n, z, c, v := flags&8 != 0, flags&4 != 0, flags&2 != 0, flags&1 != 0
+	base := [...]bool{z, c, n, v, c && !z, n == v, n == v && !z, true}[condition/2]
+	if condition&1 != 0 && condition != 15 {
+		return !base
+	}
+	return base
+}
+
+func arm64ConditionalStatusPrograms(cases []arm64ConditionalTestCase, declarations string) (string, string) {
+	var original, driver strings.Builder
+	original.WriteString(strings.Replace(declarations, "package compare", "package main\nimport \"fmt\"", 1))
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range cases {
+		fmt.Fprintf(&driver, "extern void compareConditionalStatus%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("var functions=[]func(*[68]uint64,*[69]uint64){\n")
+	driver.WriteString("static void (*functions[])(uint64_t*,uint64_t*)={\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "compareConditionalStatus%d,\n", index)
+		fmt.Fprintf(&driver, "compareConditionalStatus%d,\n", index)
+	}
+	original.WriteString("}\nvar forms=[]struct{bits,left,right,mode,condition,nzcv int; signaling,dead,complete bool}{\n")
+	driver.WriteString("};\nstatic const struct{int bits,left,right,mode,condition,nzcv,signaling,dead,complete;} forms[]={\n")
+	for _, row := range cases {
+		mode, signaling, dead, complete := 0, 0, 0, 0
+		if row.left == row.right {
+			mode = 1
+		}
+		if row.signaling {
+			signaling = 1
+		}
+		if row.dead {
+			dead = 1
+		}
+		if row.complete {
+			complete = 1
+		}
+		fmt.Fprintf(&original, "{%d,%d,%d,%d,%d,%d,%t,%t,%t},\n", row.bits, row.left, row.right, mode, row.condition, row.nzcv, row.signaling, row.dead, row.complete)
+		fmt.Fprintf(&driver, "{%d,%d,%d,%d,%d,%d,%d,%d,%d},\n", row.bits, row.left, row.right, mode, row.condition, row.nzcv, signaling, dead, complete)
+	}
+	original.WriteString("}\nvar truth=[16][4]bool{\n")
+	driver.WriteString("};\nstatic const int truth[16][4]={\n")
+	for condition := 0; condition < 16; condition++ {
+		original.WriteString("{")
+		driver.WriteString("{")
+		for _, flags := range []uint64{6, 8, 2, 3} {
+			valid := arm64ConditionalTestTrue(condition, flags)
+			fmt.Fprintf(&original, "%t,", valid)
+			if valid {
+				driver.WriteString("1,")
+			} else {
+				driver.WriteString("0,")
+			}
+		}
+		original.WriteString("},\n")
+		driver.WriteString("},\n")
+	}
+	original.WriteString("}\nvar samples=[]struct{bits,mode int; a,b,control,flags,quiet,signaling uint64; edge bool}{\n")
+	driver.WriteString("};\nstatic const struct{int bits,mode;uint64_t a,b,control,flags,quiet,signaling;int edge;} samples[]={\n")
+	for _, bits := range []int{16, 32, 64} {
+		for mode := 0; mode < 2; mode++ {
+			for first, left := range arm64CompareValues(bits) {
+				for second, right := range arm64CompareValues(bits) {
+					if mode == 1 && first != second {
+						continue
+					}
+					for rounding := 0; rounding < 4; rounding++ {
+						for controls := 0; controls < 4; controls++ {
+							control := uint64(rounding)<<22 | uint64(controls&1)<<24 | uint64(controls>>1)<<25
+							if bits == 16 && controls&1 != 0 {
+								control |= 1 << 19
+							}
+							flags, quiet := arm64CompareExpected(bits, left, right, control, false)
+							_, signaling := arm64CompareExpected(bits, left, right, control, true)
+							edge := second == 0 || mode == 1
+							fmt.Fprintf(&original, "{%d,%d,%#x,%#x,%#x,%d,%d,%d,%t},\n", bits, mode, left, right, control, flags, quiet, signaling, edge)
+							edgeValue := 0
+							if edge {
+								edgeValue = 1
+							}
+							fmt.Fprintf(&driver, "{%d,%d,%#xULL,%#xULL,%#xULL,%d,%d,%d,%d},\n", bits, mode, left, right, control, flags, quiet, signaling, edgeValue)
+						}
+					}
+				}
+			}
+		}
+	}
+	original.WriteString(`}
+func main() {
+    seeds:=[][2]uint64{{0,0},{0,1},{1,0},{0x8000000000000000,0x7fffffffffffffff}}
+    count:=0
+    for function,form:=range forms {
+        for _,sample:=range samples {
+            if sample.bits!=form.bits || sample.mode!=form.mode || !form.complete && !sample.edge {continue}
+            for seed,values:=range seeds {
+                for _,preset:=range []uint64{0,0x08000012} {
+                    var input [68]uint64
+                    for i:=0;i<64;i++ {input[i]=0x123456789abcdef0+uint64(i)*0x0102030405060708}
+                    mask:=^uint64(0)
+                    if form.bits<64 {mask=(uint64(1)<<form.bits)-1}
+                    input[2*form.left]=input[2*form.left]&^mask|sample.a
+                    if form.mode==0 {input[2*form.right]=input[2*form.right]&^mask|sample.b}
+                    input[64],input[65],input[66],input[67]=sample.control,preset,values[0],values[1]
+                    var output,want [69]uint64
+                    copy(want[:64],input[:64])
+                    want[64],want[65],want[66]=uint64(form.nzcv),preset,sample.control
+                    if truth[form.condition][seed] {
+                        want[64]=sample.flags
+                        if form.signaling {want[65]|=sample.signaling} else {want[65]|=sample.quiet}
+                    }
+                    if form.dead {want[64]=6}
+                    output[67],output[68]=0x123456789abcdef0,0xfedcba9876543210
+                    want[67],want[68]=output[67],output[68]
+                    functions[function](&input,&output)
+                    if output!=want {panic(fmt.Sprintf("function %d seed %d sample %+v got %x want %x",function,seed,sample,output,want))}
+                    count++
+                }
+            }
+        }
+    }
+    fmt.Println("ARM64_COMPARE_ORIGINAL_PASS conditional state",count)
+}
+`)
+	driver.WriteString(`};
+int main(void) {
+    const uint64_t seeds[4][2]={{0,0},{0,1},{1,0},{UINT64_C(0x8000000000000000),UINT64_C(0x7fffffffffffffff)}};
+    unsigned count=0;
+    for(unsigned function=0;function<sizeof(forms)/sizeof(forms[0]);function++) {
+        for(unsigned index=0;index<sizeof(samples)/sizeof(samples[0]);index++) {
+            if(samples[index].bits!=forms[function].bits || samples[index].mode!=forms[function].mode || (!forms[function].complete && !samples[index].edge)) continue;
+            for(unsigned seed=0;seed<4;seed++) {
+                for(unsigned preset=0;preset<2;preset++) {
+                    uint64_t input[68]={0},output[69]={0},want[69]={0};
+                    for(unsigned i=0;i<64;i++) input[i]=UINT64_C(0x123456789abcdef0)+(uint64_t)i*UINT64_C(0x0102030405060708);
+                    uint64_t mask=UINT64_MAX;
+                    if(forms[function].bits<64) mask=(UINT64_C(1)<<forms[function].bits)-1;
+                    unsigned left=2*forms[function].left,right=2*forms[function].right;
+                    input[left]=(input[left]&~mask)|samples[index].a;
+                    if(forms[function].mode==0) input[right]=(input[right]&~mask)|samples[index].b;
+                    input[64]=samples[index].control;input[65]=preset?0x08000012:0;input[66]=seeds[seed][0];input[67]=seeds[seed][1];
+                    for(unsigned i=0;i<64;i++) want[i]=input[i];
+                    want[64]=forms[function].nzcv;want[65]=input[65];want[66]=input[64];
+                    if(truth[forms[function].condition][seed]) {
+                        want[64]=samples[index].flags;
+                        want[65]|=forms[function].signaling?samples[index].signaling:samples[index].quiet;
+                    }
+                    if(forms[function].dead) want[64]=6;
+                    output[67]=want[67]=UINT64_C(0x123456789abcdef0);
+                    output[68]=want[68]=UINT64_C(0xfedcba9876543210);
+                    functions[function](input,output);
+                    for(unsigned word=0;word<69;word++) {
+                        if(output[word]!=want[word]) {
+                            fprintf(stderr,"function %u sample %u seed %u word %u got %llx want %llx\n",function,index,seed,word,(unsigned long long)output[word],(unsigned long long)want[word]);
+                            return 1;
+                        }
+                    }
+                    count++;
+                }
+            }
+        }
+    }
+    printf("ARM64_CONDITIONAL_TRANSLATED_PASS %u\n",count);
+    return 0;
+}
+`)
+	return original.String(), driver.String()
+}
+
+func arm64ConditionalStatusRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	cases := arm64ConditionalStatusCases()
+	if len(cases) != 80 {
+		t.Fatal("complete conditional status partition changed", len(cases))
+	}
+	visited := 0
+	for start := 0; start < len(cases); start += 40 {
+		end := start + 40
+		if end > len(cases) {
+			end = len(cases)
+		}
+		t.Run(fmt.Sprintf("batch%d", start/40), func(t *testing.T) {
+			source, declarations := arm64ConditionalStatusSource(cases[start:end])
+			original, driver := arm64ConditionalStatusPrograms(cases[start:end], declarations)
+			arm64ScalarCompareActualGo(t, source, original, goos, runner)
+			irs := arm64CompareMatrixIRs(t, source, declarations, triple)
+			for api, ir := range irs {
+				for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+					for _, level := range []int{0, 2} {
+						t.Run(fmt.Sprintf("api%d/IR_%s/backend_O%d", api, variant.name, level), func(t *testing.T) {
+							compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "conditional_state", triple, variant.ir, driver, runner, level)
+						})
+					}
+				}
+			}
+		})
+		visited += end - start
+	}
+	if visited != len(cases) {
+		t.Fatal("status partition is not exhaustive")
+	}
+}
+
+func TestARM64ConditionalCompareWholeStateNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU owner executes the same whole-state fixture")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64ConditionalStatusRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_conformance_test.go b/arm64_conformance_test.go
index 940c2c3b0..21189c46b 100644
--- a/arm64_conformance_test.go
+++ b/arm64_conformance_test.go
@@ -1,5 +1,3 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
@@ -12,6 +10,12 @@ import (
 )
 
 func TestARM64ConformanceNativeGo(t *testing.T) {
+	if !currentGoMinorAtLeast(27) {
+		// The translated conformance test still runs on every supported Go
+		// version. Only the native oracle needs the Go 1.27 assembler because
+		// its source intentionally exercises Go 1.27-only aliases.
+		return
+	}
 	crossLinux := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
 	if runtime.GOARCH != "arm64" && !crossLinux {
 		t.Skip("native Go assembler oracle requires an arm64 host")
@@ -69,6 +73,78 @@ func translateARM64Conformance(t *testing.T, triple string) string {
 					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
 				}},
 			},
+			"scalarFloatSquareRoots": {
+				Name: "scalarFloatSquareRoots",
+				Args: []LLVMType{Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				}},
+			},
+			"fusedMultiplyAddSemantics": {
+				Name: "fusedMultiplyAddSemantics",
+				Args: []LLVMType{Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				}},
+			},
+			"pairedAtomicSemantics": {
+				Name: "pairedAtomicSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"vectorPermuteSemantics": {
+				Name: "vectorPermuteSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"vectorWideningShiftSemantics": {
+				Name: "vectorWideningShiftSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"scalarExtendSemantics": {
+				Name: "scalarExtendSemantics",
+				Args: []LLVMType{Ptr, I64},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+				}},
+			},
+			"vectorCountBitsSemantics": {
+				Name: "vectorCountBitsSemantics",
+				Args: []LLVMType{Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+			"unsignedWideningAddSemantics": {
+				Name: "unsignedWideningAddSemantics",
+				Args: []LLVMType{Ptr, Ptr, Ptr},
+				Ret:  Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
 		},
 	})
 	if err != nil {
@@ -96,7 +172,7 @@ func TestARM64ConformanceLLVMRuntime(t *testing.T) {
 	} else {
 		_, clang, ok := findLlcAndClang(t)
 		if !ok {
-			t.Skip("clang not found")
+			t.Fatal("clang not found")
 		}
 		compiler = []string{clang}
 	}
@@ -105,6 +181,15 @@ func TestARM64ConformanceLLVMRuntime(t *testing.T) {
 	mainC := `
 #include <stdint.h>
 extern void families(uint64_t *out, uint64_t *data);
+extern void scalarFloatSquareRoots(uint8_t *out);
+extern void fusedMultiplyAddSemantics(uint8_t *out);
+extern void pairedAtomicSemantics(uint64_t *out, uint64_t *data);
+extern void vectorPermuteSemantics(uint8_t *out, uint8_t *n, uint8_t *m);
+extern void vectorWideningShiftSemantics(uint8_t *out, uint8_t *source);
+extern void scalarExtendSemantics(uint64_t *out, uint64_t value);
+extern void vectorCountBitsSemantics(uint8_t *out, uint8_t *source);
+extern void unsignedWideningAddSemantics(uint8_t *out, uint8_t *narrow, uint8_t *addend);
+
 extern void pairStores(uint64_t *out, uint64_t *data);
 uint64_t pairStoreData[10];
 int main(void) {
@@ -132,6 +217,116 @@ int main(void) {
     for (int i = 0; i < 76; i++)
         if (got[i] != want[i])
             return i + 1;
+	union {
+		uint8_t bytes[16];
+		struct { float s0, s1; double d; } values;
+	} scalar = {0};
+	scalarFloatSquareRoots(scalar.bytes);
+	if (scalar.values.s0 != 2.0f) return 80;
+	if (scalar.values.s1 != 2.0f) return 81;
+	if (scalar.values.d != 4.0) return 82;
+	union {
+		uint8_t bytes[48];
+		struct { float s[4]; double d[4]; } values;
+	} fma = {0};
+	fusedMultiplyAddSemantics(fma.bytes);
+	float fma_s_want[4] = {11.0f, -1.0f, -11.0f, 1.0f};
+	double fma_d_want[4] = {11.0, -1.0, -11.0, 1.0};
+	for (int i = 0; i < 4; i++) {
+		if (fma.values.s[i] != fma_s_want[i]) return 83 + i;
+		if (fma.values.d[i] != fma_d_want[i]) return 87 + i;
+	}
+	uint8_t permute_n[16], permute_m[16], permute_got[96] = {0};
+	for (int i = 0; i < 16; i++) {
+		permute_n[i] = (uint8_t)i;
+		permute_m[i] = (uint8_t)(0x80 + i);
+	}
+	uint8_t widen_narrow[16] = {1, 2, 3, 4, 5, 6, 7, 8, 0xf1, 0xe2, 0xd3, 0xc4, 0xb5, 0xa6, 0x97, 0x88};
+	uint8_t widen_addend[16] = {0xff, 0x00, 0xfe, 0xff, 0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12};
+	uint8_t widen_add_got[96] = {0};
+	unsignedWideningAddSemantics(widen_add_got, widen_narrow, widen_addend);
+	int narrow_widths[6] = {1, 2, 4, 1, 2, 4};
+	for (int group = 0; group < 6; group++) {
+		int narrow_bytes = narrow_widths[group], wide_bytes = 2*narrow_bytes, lanes = 16/wide_bytes;
+		int source_offset = group >= 3 ? 8 : 0;
+		for (int lane = 0; lane < lanes; lane++) {
+			uint64_t narrow_value = 0, addend_value = 0, got = 0;
+			for (int b = 0; b < narrow_bytes; b++) narrow_value |= (uint64_t)widen_narrow[source_offset+lane*narrow_bytes+b] << (8*b);
+			for (int b = 0; b < wide_bytes; b++) {
+				addend_value |= (uint64_t)widen_addend[lane*wide_bytes+b] << (8*b);
+				got |= (uint64_t)widen_add_got[group*16+lane*wide_bytes+b] << (8*b);
+			}
+			uint64_t sum = addend_value + narrow_value;
+			if (wide_bytes < 8) sum &= (1ULL << (8*wide_bytes)) - 1;
+			if (got != sum) return 190 + group;
+		}
+	}
+	vectorPermuteSemantics(permute_got, permute_n, permute_m);
+	for (int i = 0; i < 8; i++) {
+		if (permute_got[2*i] != permute_n[i] || permute_got[2*i+1] != permute_m[i]) return 100;
+		if (permute_got[16+2*i] != permute_n[8+i] || permute_got[16+2*i+1] != permute_m[8+i]) return 101;
+		if (permute_got[32+i] != permute_n[2*i] || permute_got[40+i] != permute_m[2*i]) return 102;
+		if (permute_got[48+i] != permute_n[2*i+1] || permute_got[56+i] != permute_m[2*i+1]) return 103;
+		if (permute_got[64+2*i] != permute_n[2*i] || permute_got[64+2*i+1] != permute_m[2*i]) return 104;
+		if (permute_got[80+2*i] != permute_n[2*i+1] || permute_got[80+2*i+1] != permute_m[2*i+1]) return 105;
+	}
+	uint64_t scalar_extend_got[10] = {0};
+	uint64_t scalar_extend_value = 0x88776655fedcba98ULL;
+	uint64_t scalar_extend_want[10] = {
+		(uint64_t)(int64_t)(int8_t)scalar_extend_value,
+		(uint64_t)(uint32_t)(int32_t)(int8_t)scalar_extend_value,
+		(uint64_t)(int64_t)(int16_t)scalar_extend_value,
+		(uint64_t)(uint32_t)(int32_t)(int16_t)scalar_extend_value,
+		(uint64_t)(int64_t)(int32_t)scalar_extend_value,
+		(uint64_t)(uint8_t)scalar_extend_value,
+		(uint64_t)(uint32_t)(uint8_t)scalar_extend_value,
+		(uint64_t)(uint16_t)scalar_extend_value,
+		(uint64_t)(uint32_t)(uint16_t)scalar_extend_value,
+		(uint64_t)(uint32_t)scalar_extend_value,
+	};
+	scalarExtendSemantics(scalar_extend_got, scalar_extend_value);
+	for (int i = 0; i < 10; i++)
+		if (scalar_extend_got[i] != scalar_extend_want[i]) return 120 + i;
+	uint8_t count_source[16] = {0, 1, 2, 3, 7, 15, 31, 63, 127, 128, 129, 0xaa, 0x55, 0xfe, 0xff, 0x81};
+	uint8_t count_got[32] = {0};
+	vectorCountBitsSemantics(count_got, count_source);
+	for (int i = 0; i < 16; i++) {
+		uint8_t value = count_source[i], count = 0;
+		while (value) { count += value & 1; value >>= 1; }
+		if (count_got[16+i] != count) return 140 + i;
+		if (i < 8 && count_got[i] != count) return 160 + i;
+		if (i >= 8 && count_got[i] != 0) return 170 + i;
+	}
+	uint8_t widening_source[16] = {0, 1, 0x7f, 0x80, 0xff, 2, 0x55, 0xaa, 3, 4, 0x40, 0xc0, 0xfe, 0x81, 0x11, 0xee};
+	uint16_t widening_got[64] = {0};
+	vectorWideningShiftSemantics((uint8_t *)widening_got, widening_source);
+	for (int i = 0; i < 8; i++) {
+		uint16_t low = widening_source[i], high = widening_source[8+i];
+		uint16_t signed_low = (uint16_t)(int16_t)(int8_t)widening_source[i];
+		uint16_t signed_high = (uint16_t)(int16_t)(int8_t)widening_source[8+i];
+		uint16_t want_widening[8] = {low, high, signed_low, signed_high, (uint16_t)(low << 7), (uint16_t)(high << 1), (uint16_t)(signed_low << 3), (uint16_t)(signed_high << 2)};
+		for (int group = 0; group < 8; group++)
+			if (widening_got[group*8+i] != want_widening[group]) return 110 + group;
+	}
+	uint64_t atomic_data[9] __attribute__((aligned(16))) = {
+		0x11, 0x22, 0x33, 0x44,
+		0x0000002200000011ULL, 0x0000004400000033ULL,
+		0x55, 0x66, 0x0000008800000077ULL
+	};
+	uint64_t atomic_want[23] = {
+		0x11, 0x22, 0xaa, 0xbb,
+		0x33, 0x44, 0x33, 0x44,
+		0x11, 0x22, 0x000000bb000000aaULL,
+		0x33, 0x44, 0x0000004400000033ULL,
+		0x55, 0x66, 0, 0xcc, 0xdd,
+		0x77, 0x88, 1, 0x000000aa00000099ULL
+	};
+	uint64_t atomic_got[23] = {0};
+	pairedAtomicSemantics(atomic_got, atomic_data);
+	for (int i = 0; i < 23; i++)
+		if (atomic_got[i] != atomic_want[i])
+			return 100 + i;
+
     uint64_t pairs[20], expected[20];
     for (int i = 0; i < 20; i++)
         pairs[i] = expected[i] = 0xdeadbeef;
diff --git a/arm64_control_exact_reference_test.go b/arm64_control_exact_reference_test.go
new file mode 100644
index 000000000..1ca074560
--- /dev/null
+++ b/arm64_control_exact_reference_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"math/rand"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These map operations are the frozen old semantics. They intentionally keep
+// false entries, nil/empty distinctions and the asymmetric equality rule.
+func arm64ControlFrozenUnion(left, right map[string]bool) map[string]bool {
+	value := make(map[string]bool, len(left)+len(right))
+	for token := range left {
+		value[token] = true
+	}
+	for token := range right {
+		value[token] = true
+	}
+	frame := ""
+	for token := range value {
+		if strings.HasPrefix(token, "sp:") || strings.HasPrefix(token, "fp:") {
+			if frame != "" && frame != token {
+				for candidate := range value {
+					if strings.HasPrefix(candidate, "sp:") || strings.HasPrefix(candidate, "fp:") {
+						delete(value, candidate)
+					}
+				}
+				value[""] = true
+				break
+			}
+			frame = token
+		}
+	}
+	return value
+}
+
+func arm64ControlFrozenEqual(left, right map[string]bool) bool {
+	if len(left) != len(right) {
+		return false
+	}
+	for token := range left {
+		if !right[token] {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ControlFrozenFilter(value map[string]bool, labels bool) map[string]bool {
+	result := make(map[string]bool)
+	for token := range value {
+		selected := token != ""
+		if labels {
+			selected = strings.HasPrefix(token, "label:") || token == "code-derived:"
+		}
+		if selected {
+			result[token] = true
+		}
+	}
+	return result
+}
+
+func arm64ControlFrozenWithToken(value map[string]bool, token string) map[string]bool {
+	if value[token] {
+		return value
+	}
+	result := make(map[string]bool, len(value)+1)
+	for old, present := range value {
+		result[old] = present
+	}
+	result[token] = true
+	return result
+}
+
+func arm64ControlExactReferenceMap(value arm64ControlValue) map[string]bool {
+	if value == nil {
+		return nil
+	}
+	result := make(map[string]bool, arm64ControlCount(value))
+	for token, present := range arm64ControlMap(value) {
+		result[token] = present
+	}
+	return result
+}
+
+func arm64ControlExactReferenceValue(value map[string]bool) arm64ControlValue {
+	if value == nil {
+		return nil
+	}
+	result := arm64ControlFromMap(make(map[string]bool, len(value)))
+	for token, present := range value {
+		result = arm64ControlSetToken(result, token, present)
+	}
+	return result
+}
+
+func TestARM64ControlExactFrozenMapOperations(t *testing.T) {
+	tokens := []string{"", "label:caller", "label:next", "code-derived:", "sp:0", "sp:8", "fp:0", "fpa:8", "invalid", "label:", "sp:invalid"}
+	values := []map[string]bool{nil, {}}
+	random := rand.New(rand.NewSource(917))
+	for sample := 0; sample < 96; sample++ {
+		value := make(map[string]bool)
+		for _, token := range tokens {
+			if choice := random.Intn(3); choice != 0 {
+				value[token] = choice == 2
+			}
+		}
+		values = append(values, value)
+	}
+	for leftIndex, left := range values {
+		for rightIndex, right := range values {
+			a, b := arm64ControlExactReferenceValue(left), arm64ControlExactReferenceValue(right)
+			beforeA, beforeB := arm64ControlExactReferenceMap(a), arm64ControlExactReferenceMap(b)
+			got := arm64ControlExactReferenceMap(arm64ControlUnion(a, b))
+			if want := arm64ControlFrozenUnion(left, right); !reflect.DeepEqual(got, want) {
+				t.Fatalf("union %d/%d: got %v, want %v", leftIndex, rightIndex, got, want)
+			}
+			if arm64ControlEqual(a, b) != arm64ControlFrozenEqual(left, right) {
+				t.Fatalf("asymmetric equality %d/%d changed", leftIndex, rightIndex)
+			}
+			if !reflect.DeepEqual(arm64ControlExactReferenceMap(a), beforeA) || !reflect.DeepEqual(arm64ControlExactReferenceMap(b), beforeB) {
+				t.Fatalf("operation %d/%d mutated a published predecessor", leftIndex, rightIndex)
+			}
+		}
+		value := arm64ControlExactReferenceValue(left)
+		for _, labels := range []bool{false, true} {
+			got := arm64ControlAddressTaint(value)
+			if labels {
+				got = arm64ControlLabels(value)
+			}
+			if !reflect.DeepEqual(arm64ControlExactReferenceMap(got), arm64ControlFrozenFilter(left, labels)) {
+				t.Fatalf("projection %d/%t changed complete token/bool semantics", leftIndex, labels)
+			}
+		}
+		for _, token := range tokens {
+			got := arm64ControlWithToken(value, token)
+			if !reflect.DeepEqual(arm64ControlExactReferenceMap(got), arm64ControlFrozenWithToken(left, token)) {
+				t.Fatalf("copy-on-write %d/%q changed complete token/bool semantics", leftIndex, token)
+			}
+			if !reflect.DeepEqual(arm64ControlExactReferenceMap(value), left) {
+				t.Fatalf("copy-on-write %d/%q modified its old root", leftIndex, token)
+			}
+		}
+	}
+}
diff --git a/arm64_control_exact_set.go b/arm64_control_exact_set.go
new file mode 100644
index 000000000..cfec1dfcb
--- /dev/null
+++ b/arm64_control_exact_set.go
@@ -0,0 +1,406 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/bits"
+	"sort"
+	"strings"
+	"sync"
+)
+
+// A control value owns immutable exact token/bool entries. Only the lazy
+// projections are mutable, and each is published once under its own guard.
+// There is no global interner or cache, and no source/permission memoization.
+type arm64ControlValue = *arm64ControlSet
+
+type arm64ControlSet struct {
+	root        *arm64ControlNode
+	labelsOnce  sync.Once
+	labels      arm64ControlValue
+	addressOnce sync.Once
+	address     arm64ControlValue
+}
+
+type arm64ControlEntry struct {
+	token   string
+	present bool
+}
+
+// A compressed binary trie branches at one hash bit. Hash collisions remain
+// sorted full-string entries in a leaf; a hash never establishes equality.
+type arm64ControlNode struct {
+	hash                uint64
+	split               uint64
+	left, right         *arm64ControlNode
+	entries             []arm64ControlEntry
+	count, falseEntries int
+	frames, labels      int
+	nonUnknown          int
+}
+
+func arm64ControlHash(token string) uint64 {
+	const prime = uint64(1099511628211)
+	hash := uint64(14695981039346656037)
+	for index := 0; index < len(token); index++ {
+		hash = (hash ^ uint64(token[index])) * prime
+	}
+	return hash
+}
+
+func arm64ControlFrameToken(token string) bool {
+	return strings.HasPrefix(token, "sp:") || strings.HasPrefix(token, "fp:")
+}
+
+func arm64ControlLeaf(hash uint64, entries []arm64ControlEntry) *arm64ControlNode {
+	if len(entries) == 0 {
+		return nil
+	}
+	node := &arm64ControlNode{hash: hash, entries: append([]arm64ControlEntry(nil), entries...), count: len(entries)}
+	for _, entry := range entries {
+		if !entry.present {
+			node.falseEntries++
+		}
+		if arm64ControlFrameToken(entry.token) {
+			node.frames++
+		}
+		if strings.HasPrefix(entry.token, "label:") || entry.token == "code-derived:" {
+			node.labels++
+		}
+		if entry.token != "" {
+			node.nonUnknown++
+		}
+	}
+	return node
+}
+
+func arm64ControlBranch(split uint64, left, right *arm64ControlNode) *arm64ControlNode {
+	if left == nil {
+		return right
+	}
+	if right == nil {
+		return left
+	}
+	return &arm64ControlNode{
+		hash: left.hash, split: split, left: left, right: right,
+		count: left.count + right.count, falseEntries: left.falseEntries + right.falseEntries,
+		frames: left.frames + right.frames, labels: left.labels + right.labels,
+		nonUnknown: left.nonUnknown + right.nonUnknown,
+	}
+}
+
+func arm64ControlSplit(left, right uint64) uint64 {
+	if difference := left ^ right; difference != 0 {
+		return uint64(1) << (63 - bits.LeadingZeros64(difference))
+	}
+	return 0
+}
+
+func arm64ControlInsert(node *arm64ControlNode, hash uint64, token string, present bool) *arm64ControlNode {
+	if node == nil {
+		return arm64ControlLeaf(hash, []arm64ControlEntry{{token, present}})
+	}
+	if split := arm64ControlSplit(node.hash, hash); split > node.split {
+		leaf := arm64ControlLeaf(hash, []arm64ControlEntry{{token, present}})
+		if hash&split == 0 {
+			return arm64ControlBranch(split, leaf, node)
+		}
+		return arm64ControlBranch(split, node, leaf)
+	}
+	if node.split != 0 {
+		if hash&node.split == 0 {
+			left := arm64ControlInsert(node.left, hash, token, present)
+			if left == node.left {
+				return node
+			}
+			return arm64ControlBranch(node.split, left, node.right)
+		}
+		right := arm64ControlInsert(node.right, hash, token, present)
+		if right == node.right {
+			return node
+		}
+		return arm64ControlBranch(node.split, node.left, right)
+	}
+	index := sort.Search(len(node.entries), func(index int) bool { return node.entries[index].token >= token })
+	if index < len(node.entries) && node.entries[index].token == token && node.entries[index].present == present {
+		return node
+	}
+	entries := append([]arm64ControlEntry(nil), node.entries...)
+	if index < len(entries) && entries[index].token == token {
+		entries[index].present = present
+	} else {
+		entries = append(entries, arm64ControlEntry{})
+		copy(entries[index+1:], entries[index:])
+		entries[index] = arm64ControlEntry{token, present}
+	}
+	return arm64ControlLeaf(hash, entries)
+}
+
+func arm64ControlLookup(node *arm64ControlNode, hash uint64, token string) bool {
+	for node != nil && node.split != 0 {
+		if hash&node.split == 0 {
+			node = node.left
+		} else {
+			node = node.right
+		}
+	}
+	if node == nil || node.hash != hash {
+		return false
+	}
+	index := sort.Search(len(node.entries), func(index int) bool { return node.entries[index].token >= token })
+	return index < len(node.entries) && node.entries[index].token == token && node.entries[index].present
+}
+
+func arm64ControlVisitNode(node *arm64ControlNode, visit func(uint64, string, bool) bool) bool {
+	if node == nil {
+		return true
+	}
+	if node.split != 0 {
+		return arm64ControlVisitNode(node.left, visit) && arm64ControlVisitNode(node.right, visit)
+	}
+	for _, entry := range node.entries {
+		if !visit(node.hash, entry.token, entry.present) {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ControlCount(value arm64ControlValue) int {
+	if value == nil || value.root == nil {
+		return 0
+	}
+	return value.root.count
+}
+
+func arm64ControlHas(value arm64ControlValue, token string) bool {
+	return value != nil && arm64ControlLookup(value.root, arm64ControlHash(token), token)
+}
+
+func arm64ControlKeys(value arm64ControlValue) []string {
+	keys := make([]string, 0, arm64ControlCount(value))
+	if value != nil {
+		arm64ControlVisitNode(value.root, func(_ uint64, token string, _ bool) bool {
+			keys = append(keys, token)
+			return true
+		})
+	}
+	return keys
+}
+
+func arm64ControlFromMap(entries map[string]bool) arm64ControlValue {
+	if entries == nil {
+		return nil
+	}
+	value := &arm64ControlSet{}
+	for token, present := range entries {
+		value.root = arm64ControlInsert(value.root, arm64ControlHash(token), token, present)
+	}
+	return value
+}
+
+func arm64ControlMap(value arm64ControlValue) map[string]bool {
+	if value == nil {
+		return nil
+	}
+	entries := make(map[string]bool, arm64ControlCount(value))
+	arm64ControlVisitNode(value.root, func(_ uint64, token string, present bool) bool {
+		entries[token] = present
+		return true
+	})
+	return entries
+}
+
+func (value *arm64ControlSet) MarshalJSON() ([]byte, error) {
+	return json.Marshal(arm64ControlMap(value))
+}
+
+func (value *arm64ControlSet) String() string {
+	return fmt.Sprint(arm64ControlMap(value))
+}
+
+func arm64ControlCanonical(value arm64ControlValue) bool {
+	return value != nil && (value.root == nil || value.root.falseEntries == 0 && value.root.frames <= 1)
+}
+
+func arm64ControlSubsetNodes(subset, superset *arm64ControlNode) bool {
+	if subset == nil {
+		return true
+	}
+	if superset == nil || subset.count > superset.count {
+		return false
+	}
+	if subset == superset {
+		return superset.falseEntries == 0
+	}
+	if subset.split == superset.split && arm64ControlSplit(subset.hash, superset.hash) <= subset.split && subset.split != 0 {
+		return arm64ControlSubsetNodes(subset.left, superset.left) && arm64ControlSubsetNodes(subset.right, superset.right)
+	}
+	if superset.split > subset.split && arm64ControlSplit(subset.hash, superset.hash) <= superset.split {
+		if subset.hash&superset.split == 0 {
+			return arm64ControlSubsetNodes(subset, superset.left)
+		}
+		return arm64ControlSubsetNodes(subset, superset.right)
+	}
+	return arm64ControlVisitNode(subset, func(hash uint64, token string, _ bool) bool {
+		return arm64ControlLookup(superset, hash, token)
+	})
+}
+
+func arm64ControlSubset(subset, superset arm64ControlValue) bool {
+	var left, right *arm64ControlNode
+	if subset != nil {
+		left = subset.root
+	}
+	if superset != nil {
+		right = superset.root
+	}
+	return arm64ControlSubsetNodes(left, right)
+}
+
+func arm64ControlEqual(left, right arm64ControlValue) bool {
+	return arm64ControlCount(left) == arm64ControlCount(right) && arm64ControlSubset(left, right)
+}
+
+type arm64ControlProjection uint8
+
+const (
+	arm64ControlAllTokens arm64ControlProjection = iota
+	arm64ControlLabelTokens
+	arm64ControlAddressTokens
+	arm64ControlNonFrameTokens
+)
+
+func arm64ControlProject(node *arm64ControlNode, kind arm64ControlProjection) *arm64ControlNode {
+	if node == nil {
+		return nil
+	}
+	selected := node.count
+	switch kind {
+	case arm64ControlLabelTokens:
+		selected = node.labels
+	case arm64ControlAddressTokens:
+		selected = node.nonUnknown
+	case arm64ControlNonFrameTokens:
+		selected -= node.frames
+	}
+	if selected == 0 {
+		return nil
+	}
+	if selected == node.count && node.falseEntries == 0 {
+		return node
+	}
+	if node.split != 0 {
+		return arm64ControlBranch(node.split, arm64ControlProject(node.left, kind), arm64ControlProject(node.right, kind))
+	}
+	entries := make([]arm64ControlEntry, 0, selected)
+	for _, entry := range node.entries {
+		keep := true
+		switch kind {
+		case arm64ControlLabelTokens:
+			keep = strings.HasPrefix(entry.token, "label:") || entry.token == "code-derived:"
+		case arm64ControlAddressTokens:
+			keep = entry.token != ""
+		case arm64ControlNonFrameTokens:
+			keep = !arm64ControlFrameToken(entry.token)
+		}
+		if keep {
+			entries = append(entries, arm64ControlEntry{entry.token, true})
+		}
+	}
+	return arm64ControlLeaf(node.hash, entries)
+}
+
+func arm64ControlUnionNodes(left, right *arm64ControlNode) *arm64ControlNode {
+	if left == nil {
+		return arm64ControlProject(right, arm64ControlAllTokens)
+	}
+	if right == nil || left == right {
+		return arm64ControlProject(left, arm64ControlAllTokens)
+	}
+	if split := arm64ControlSplit(left.hash, right.hash); split > left.split && split > right.split {
+		left, right = arm64ControlProject(left, arm64ControlAllTokens), arm64ControlProject(right, arm64ControlAllTokens)
+		if left.hash&split == 0 {
+			return arm64ControlBranch(split, left, right)
+		}
+		return arm64ControlBranch(split, right, left)
+	}
+	if left.split != 0 && left.split >= right.split {
+		if left.split == right.split {
+			return arm64ControlBranch(left.split, arm64ControlUnionNodes(left.left, right.left), arm64ControlUnionNodes(left.right, right.right))
+		}
+		if right.hash&left.split == 0 {
+			return arm64ControlBranch(left.split, arm64ControlUnionNodes(left.left, right), arm64ControlProject(left.right, arm64ControlAllTokens))
+		}
+		return arm64ControlBranch(left.split, arm64ControlProject(left.left, arm64ControlAllTokens), arm64ControlUnionNodes(left.right, right))
+	}
+	if right.split != 0 {
+		return arm64ControlUnionNodes(right, left)
+	}
+	root := arm64ControlProject(left, arm64ControlAllTokens)
+	for _, entry := range right.entries {
+		root = arm64ControlInsert(root, right.hash, entry.token, true)
+	}
+	return root
+}
+
+func arm64ControlUnion(left, right arm64ControlValue) arm64ControlValue {
+	if arm64ControlCount(left) >= arm64ControlCount(right) && arm64ControlCanonical(left) && arm64ControlSubset(right, left) {
+		return left
+	}
+	if arm64ControlCount(right) >= arm64ControlCount(left) && arm64ControlCanonical(right) && arm64ControlSubset(left, right) {
+		return right
+	}
+	var a, b *arm64ControlNode
+	if left != nil {
+		a = left.root
+	}
+	if right != nil {
+		b = right.root
+	}
+	root := arm64ControlUnionNodes(a, b)
+	if root != nil && root.frames > 1 {
+		root = arm64ControlProject(root, arm64ControlNonFrameTokens)
+		root = arm64ControlInsert(root, arm64ControlHash(""), "", true)
+	}
+	return &arm64ControlSet{root: root}
+}
+
+func arm64ControlWithToken(value arm64ControlValue, token string) arm64ControlValue {
+	if arm64ControlHas(value, token) {
+		return value
+	}
+	var root *arm64ControlNode
+	if value != nil {
+		root = value.root
+	}
+	return &arm64ControlSet{root: arm64ControlInsert(root, arm64ControlHash(token), token, true)}
+}
+
+func arm64ControlSetToken(value arm64ControlValue, token string, present bool) arm64ControlValue {
+	var root *arm64ControlNode
+	if value != nil {
+		root = value.root
+	}
+	return &arm64ControlSet{root: arm64ControlInsert(root, arm64ControlHash(token), token, present)}
+}
+
+func arm64ControlLabels(value arm64ControlValue) arm64ControlValue {
+	if value == nil {
+		return &arm64ControlSet{}
+	}
+	value.labelsOnce.Do(func() {
+		value.labels = &arm64ControlSet{root: arm64ControlProject(value.root, arm64ControlLabelTokens)}
+	})
+	return value.labels
+}
+
+func arm64ControlAddressTaint(value arm64ControlValue) arm64ControlValue {
+	if value == nil {
+		return &arm64ControlSet{}
+	}
+	value.addressOnce.Do(func() {
+		value.address = &arm64ControlSet{root: arm64ControlProject(value.root, arm64ControlAddressTokens)}
+	})
+	return value.address
+}
diff --git a/arm64_control_exact_set_test.go b/arm64_control_exact_set_test.go
new file mode 100644
index 000000000..54cf8779c
--- /dev/null
+++ b/arm64_control_exact_set_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"sync"
+	"testing"
+)
+
+func arm64ControlExactCheckNode(t *testing.T, node *arm64ControlNode) map[string]bool {
+	t.Helper()
+	entries := make(map[string]bool)
+	arm64ControlVisitNode(node, func(hash uint64, token string, present bool) bool {
+		if _, duplicate := entries[token]; duplicate {
+			t.Fatalf("duplicate complete string %q", token)
+		}
+		entries[token] = present
+		if arm64ControlLookup(node, hash, token) != present {
+			t.Fatalf("lookup %q lost exact bool or collision identity", token)
+		}
+		return true
+	})
+	if node == nil {
+		return entries
+	}
+	falseEntries, frames, labels, nonUnknown := 0, 0, 0, 0
+	for token, present := range entries {
+		if !present {
+			falseEntries++
+		}
+		if arm64ControlFrameToken(token) {
+			frames++
+		}
+		if arm64ControlFrozenFilter(map[string]bool{token: present}, true)[token] {
+			labels++
+		}
+		if token != "" {
+			nonUnknown++
+		}
+	}
+	if node.count != len(entries) || node.falseEntries != falseEntries || node.frames != frames || node.labels != labels || node.nonUnknown != nonUnknown {
+		t.Fatal("node summaries differ from every complete original entry")
+	}
+	if node.split != 0 {
+		if node.split&(node.split-1) != 0 || node.left == nil || node.right == nil {
+			t.Fatal("invalid compressed branch")
+		}
+		arm64ControlExactCheckNode(t, node.left)
+		arm64ControlExactCheckNode(t, node.right)
+	}
+	return entries
+}
+
+func TestARM64ControlExactForcedCollisionKeepsStringsAndBools(t *testing.T) {
+	var root *arm64ControlNode
+	expected := make(map[string]bool)
+	for index := 0; index < 128; index++ {
+		token, present := fmt.Sprintf("label:collision_%03d", index), index%3 != 0
+		root = arm64ControlInsert(root, 7, token, present)
+		expected[token] = present
+	}
+	before := arm64ControlExactCheckNode(t, root)
+	if !reflect.DeepEqual(before, expected) || arm64ControlLookup(root, 7, "label:collision_missing") {
+		t.Fatal("matching hash was used instead of complete string identity")
+	}
+	changed := arm64ControlInsert(root, 7, "label:collision_000", true)
+	if !arm64ControlLookup(changed, 7, "label:collision_000") || arm64ControlLookup(root, 7, "label:collision_000") {
+		t.Fatal("bool update mutated a published collision leaf")
+	}
+	other := arm64ControlInsert(nil, 1<<63, "code-derived:", false)
+	other = arm64ControlInsert(other, 7, "label:collision_new", false)
+	joined := arm64ControlUnionNodes(root, other)
+	want := arm64ControlFrozenUnion(expected, map[string]bool{"code-derived:": false, "label:collision_new": false})
+	if !reflect.DeepEqual(arm64ControlExactCheckNode(t, joined), want) || !reflect.DeepEqual(arm64ControlExactCheckNode(t, root), before) {
+		t.Fatal("collision union changed full keys/bools or an old root")
+	}
+	for _, kind := range []arm64ControlProjection{arm64ControlLabelTokens, arm64ControlAddressTokens} {
+		got := arm64ControlExactCheckNode(t, arm64ControlProject(joined, kind))
+		if !reflect.DeepEqual(got, arm64ControlFrozenFilter(want, kind == arm64ControlLabelTokens)) {
+			t.Fatal("collision projection changed full-string semantics")
+		}
+	}
+}
+
+func TestARM64ControlExactOwnershipAndAsymmetricEquality(t *testing.T) {
+	input := map[string]bool{"label:one": false, "sp:0": true, "fp:8": false, "": false}
+	value := arm64ControlFromMap(input)
+	before := arm64ControlMap(value)
+	input["label:one"], input["new"] = true, true
+	delete(input, "sp:0")
+	if !reflect.DeepEqual(arm64ControlMap(value), before) {
+		t.Fatal("constructor retained caller-owned mutable input")
+	}
+	falseValue := arm64ControlFromMap(map[string]bool{"label:one": false})
+	trueValue := arm64ControlFromMap(map[string]bool{"label:one": true})
+	if !arm64ControlEqual(falseValue, trueValue) || arm64ControlEqual(trueValue, falseValue) || arm64ControlEqual(falseValue, falseValue) {
+		t.Fatal("identity shortcut changed old asymmetric equality")
+	}
+	if empty := arm64ControlUnion(nil, nil); empty == nil || !arm64ControlEqual(nil, empty) {
+		t.Fatal("nil/non-nil empty old semantics changed")
+	}
+	joined := arm64ControlUnion(value, value)
+	if !reflect.DeepEqual(arm64ControlMap(joined), arm64ControlFrozenUnion(before, before)) || !reflect.DeepEqual(arm64ControlMap(value), before) {
+		t.Fatal("false/frame conflict normalization changed old roots")
+	}
+	keys := arm64ControlKeys(value)
+	if len(keys) != 0 {
+		keys[0] = "mutated visitor output"
+	}
+	if !reflect.DeepEqual(arm64ControlMap(value), before) {
+		t.Fatal("visitor leaked a mutable shared slice")
+	}
+}
+
+func TestARM64ControlExactConcurrentProjection(t *testing.T) {
+	input := map[string]bool{"": false, "sp:8": true, "fp:16": false, "code-derived:": false}
+	for index := 0; index < 128; index++ {
+		input[fmt.Sprintf("label:next_%d", index)] = index%2 == 0
+	}
+	value := arm64ControlFromMap(input)
+	wantLabels, wantAddress := arm64ControlFrozenFilter(input, true), arm64ControlFrozenFilter(input, false)
+	var workers sync.WaitGroup
+	for worker := 0; worker < 16; worker++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			for iteration := 0; iteration < 32; iteration++ {
+				labels, address := arm64ControlLabels(value), arm64ControlAddressTaint(value)
+				if !reflect.DeepEqual(arm64ControlMap(labels), wantLabels) || !reflect.DeepEqual(arm64ControlMap(address), wantAddress) {
+					t.Error("concurrent projection changed exact original entries")
+				}
+				derived := arm64ControlWithToken(labels, "new local witness")
+				if arm64ControlHas(labels, "new local witness") || !arm64ControlHas(derived, "new local witness") {
+					t.Error("concurrent transform mutated shared projection")
+				}
+			}
+		}()
+	}
+	workers.Wait()
+	if !reflect.DeepEqual(arm64ControlMap(value), input) || arm64ControlLabels(value) != arm64ControlLabels(value) || arm64ControlAddressTaint(value) != arm64ControlAddressTaint(value) {
+		t.Fatal("projection did not retain immutable per-value ownership")
+	}
+}
+
+func TestARM64ControlExactInsertionPermutation(t *testing.T) {
+	tokens := []string{"", "sp:0", "label:caller", "label:left", "label:right", "code-derived:"}
+	var reference arm64ControlValue
+	for shift := 0; shift < len(tokens); shift++ {
+		var root *arm64ControlNode
+		for index := range tokens {
+			token := tokens[(index+shift)%len(tokens)]
+			root = arm64ControlInsert(root, arm64ControlHash(token), token, true)
+		}
+		value := &arm64ControlSet{root: root}
+		arm64ControlExactCheckNode(t, root)
+		if reference == nil {
+			reference = value
+		} else if !reflect.DeepEqual(root, reference.root) || !arm64ControlEqual(value, reference) || !reflect.DeepEqual(arm64ControlKeys(value), arm64ControlKeys(reference)) {
+			t.Fatal("construction order changed exact visitor/target identities")
+		}
+	}
+}
diff --git a/arm64_control_gp_move.go b/arm64_control_gp_move.go
new file mode 100644
index 000000000..298185446
--- /dev/null
+++ b/arm64_control_gp_move.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+// Scalar GP MOV rows write the complete destination register, unlike MOVK.
+// A narrow register source is an extension, not a pure code-address copy.
+// Literal MOVW uses the W view (clearing its upper half); it never reads Rd.
+// Memory/address forms retain their separate typed grammars.
+type arm64GPRegisterMoveForm struct {
+	op     Op
+	source Operand
+}
+
+// This same form is consumed by the control and private-data interpreters.
+// Recognizing a move describes its numerical syntax, not an entry register or
+// source/frame authority.
+func parseARM64GPRegisterMove(ins Instr) (arm64GPRegisterMoveForm, bool) {
+	op := arm64ControlOp(ins)
+	switch op {
+	case "MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD":
+	default:
+		return arm64GPRegisterMoveForm{}, false
+	}
+	width := arm64RawPrivateScalarBytes(op)
+	if width == 0 || width > 8 || op == "MOVBW" || op == "MOVHW" ||
+		string(ins.Op) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return arm64GPRegisterMoveForm{}, false
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg && isARM64GeneralOrZeroReg(source.Reg) {
+		return arm64GPRegisterMoveForm{op: op, source: source}, true
+	}
+	if source.Kind == OpImm && source.ImmRaw == "" && !source.ImmIsFloat &&
+		(op == "MOVD" || op == "MOVW" || source.Imm == 0) {
+		// The seven zero aliases are rewritten to ZR by Go's progedit;
+		// Other narrow spellings do not have a valid literal encoder.
+		// MOVWU inherits MOVW's rows, but omovconst/omovlconst do not
+		// implement its nonzero literals; accepted syntax is not a proof.
+		return arm64GPRegisterMoveForm{op: op, source: source}, true
+	}
+	return arm64GPRegisterMoveForm{}, false
+}
+
+func (state *arm64ControlState) transferGPRegisterMove(ins Instr) bool {
+	form, known := parseARM64GPRegisterMove(ins)
+	if !known {
+		return false
+	}
+	value := arm64ControlExternal()
+	if form.source.Kind == OpReg {
+		value = state.source(form.source, false)
+		if form.op != "MOVD" {
+			value = arm64ControlUnion(arm64ControlExternal(), arm64ControlLabels(value))
+			if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+				value = arm64ControlWithToken(value, "code-derived:")
+			}
+		}
+	}
+	state.write(ins.Args[1], value, false)
+	return true
+}
diff --git a/arm64_control_gp_move_runtime_test.go b/arm64_control_gp_move_runtime_test.go
new file mode 100644
index 000000000..560319ced
--- /dev/null
+++ b/arm64_control_gp_move_runtime_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+type arm64GPMoveOracle struct {
+	text, goValue, cValue string
+}
+
+func arm64GPMoveOracles() []arm64GPMoveOracle {
+	var forms []arm64GPMoveOracle
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		goValue, cValue := "a", "a"
+		if op != "MOVD" {
+			bits := arm64RawPrivateScalarBytes(Op(op)) * 8
+			if strings.HasSuffix(op, "U") {
+				goValue = fmt.Sprintf("uint64(uint%d(a))", bits)
+				cValue = fmt.Sprintf("(uint64_t)(uint%d_t)a", bits)
+			} else {
+				goValue = fmt.Sprintf("uint64(int%d(a))", bits)
+				cValue = fmt.Sprintf("(uint64_t)(int%d_t)a", bits)
+			}
+		}
+		for _, input := range []string{"R4", "R30"} {
+			forms = append(forms, arm64GPMoveOracle{op + " " + input + ",R30", goValue, cValue})
+		}
+		forms = append(forms, arm64GPMoveOracle{op + " ZR,R30", "uint64(0)", "0"})
+		forms = append(forms, arm64GPMoveOracle{op + " $0,R30", "uint64(0)", "0"})
+	}
+	for _, op := range []string{"MOVW", "MOVD"} {
+		for _, literal := range []int64{-601, 806, 0x12340000} {
+			value := uint64(literal)
+			if op != "MOVD" {
+				value = uint64(uint32(literal))
+			}
+			forms = append(forms, arm64GPMoveOracle{
+				text:    fmt.Sprintf("%s $%d,R30", op, literal),
+				goValue: fmt.Sprintf("uint64(%d)", value),
+				cValue:  fmt.Sprintf("UINT64_C(%d)", value),
+			})
+		}
+	}
+	return forms
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GPMoveSourceInputs(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecls, goChecks, cDecls, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	forms := arm64GPMoveOracles()
+	for index, form := range forms {
+		name := fmt.Sprintf("gpMoveCaller%d", index)
+		body := "MOVD (R0),R4\nMOVD 8(R0),R5\nCMP R5,R4\n"
+		if strings.Contains(form.text, " R30,") {
+			body += "MOVD R4,R30\n"
+		}
+		body += form.text + "\nMOVD R30,(R1)\n" +
+			"CSET VS,R7\nCSET CS,R8\nLSL $1,R8\nORR R8,R7\n" +
+			"CSET EQ,R8\nLSL $2,R8\nORR R8,R7\nCSET MI,R8\nLSL $3,R8\nORR R8,R7\nMOVD R7,8(R1)\n"
+		source.WriteString(strings.Replace(arm64RawZeroFrameFixture(516, false, body), "rawZero", name, 1))
+		sig := arm64RawZeroFrameSig()
+		sig.Name = name
+		sigs[name] = sig
+		fmt.Fprintf(&goDecls, "func %s(*byte, *byte)\n", name)
+		fmt.Fprintf(&goDecls, "func expected%d(a, b, c uint64) (uint64, uint64) {\n result := %s\n return result, flags(a, b, result, 2, 64)\n}\n", index, form.goValue)
+		fmt.Fprintf(&cDecls, "extern void %s(const unsigned char *, unsigned char *);\n", name)
+		fmt.Fprintf(&cDecls, "static uint64_t expected%d(uint64_t a, uint64_t b, uint64_t c, uint64_t *nzcv) {\n uint64_t result = %s;\n *nzcv = flags(a, b, result, 2, 64);\n return result;\n}\n", index, form.cValue)
+		fmt.Fprintf(&goChecks, "check(%s, expected%d)\n", name, index)
+		fmt.Fprintf(&cChecks, "if (check(%s, expected%d)) { return 1; }\n", name, index)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":  "module gpmovecalleroracle\n\ngo 1.20\n",
+		"main.go": arm64GPDataOracleGo + goDecls.String() + "func main() {\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source.String(), "TEXT gpMoveCaller", "TEXT ·gpMoveCaller") +
+			"\nTEXT ·readGoG(SB),516,$0-8\nMOVD g,R0\nMOVD R0,ret+0(FP)\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual Go scalar MOV/LR/canary oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "gp_move_caller", triple, ir,
+		arm64GPDataOracleC+cDecls.String()+"int main(void) {\n"+cChecks.String()+"return 0;\n}\n", runner)
+	t.Logf("%d original Go/LLVM move forms x 128 patterns x 5 unaligned offsets; numeric/NZCV/canaries/caller g and LR", len(forms))
+}
diff --git a/arm64_control_gp_move_test.go b/arm64_control_gp_move_test.go
new file mode 100644
index 000000000..af5df0b66
--- /dev/null
+++ b/arm64_control_gp_move_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestARM64ControlGPMoveUnsignedLiteralHasNoEncoderWitness(t *testing.T) {
+	// Go 1.27 accepts the inherited MOVCON rows, but omovconst leaves
+	// nonzero MOVWU move-wide literals as zero WORDs. Keep the emitted
+	// object as evidence; never execute its undefined instruction here.
+	for _, literal := range []int64{-601, 806, 0x12340000} {
+		dir := t.TempDir()
+		path := filepath.Join(dir, "unsigned.s")
+		source := fmt.Sprintf("TEXT unsigned(SB),516,$0-0\nMOVWU $%d,R30\nRET\n", literal)
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		command := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "unsigned.o"), path)
+		command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "GOTOOLCHAIN=local")
+		output, err := command.CombinedOutput()
+		if err != nil {
+			t.Fatalf("actual Go MOVWU inherited literal row: %v\n%s", err, output)
+		}
+		if !regexp.MustCompile(`(?m)^\s*0x0000 00 00 00 00 c0 03 5f d6`).Match(output) {
+			t.Fatalf("Go MOVWU literal encoder changed; audit before granting overwrite: %d\n%s", literal, output)
+		}
+	}
+}
+
+func TestARM64ControlGPMoveCompleteRegisterRows(t *testing.T) {
+	bytes, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(bytes)
+	for _, family := range []string{"AMOVB", "AMOVH", "AMOVW"} {
+		row := regexp.MustCompile(`(?m)^\s*\{` + family + `, C_ZREG, C_NONE, C_NONE, C_ZREG,(?: C_NONE,)? 45,`)
+		if len(row.FindAllString(source, -1)) != 1 {
+			t.Fatalf("Go narrow GP move row changed: %s", family)
+		}
+		alias := regexp.MustCompile(`case ` + family + `:\s*\n\s*oprangeset\(` + family + `U, t\)`)
+		if !alias.MatchString(source) {
+			t.Fatalf("Go narrow unsigned alias changed: %s", family)
+		}
+	}
+	for _, class := range []string{"C_RSP", "C_ZREG"} {
+		row := regexp.MustCompile(`(?m)^\s*\{AMOVD, ` + class + `, C_NONE, C_NONE, ` + class + `,(?: C_NONE,)? 24,`)
+		if len(row.FindAllString(source, -1)) != 1 {
+			t.Fatalf("Go full GP copy row changed: %s", class)
+		}
+	}
+	for _, op := range []string{"AMOVD", "AMOVW"} {
+		for _, class := range []string{"C_MBCON", "C_MOVCON", "C_BITCON"} {
+			row := regexp.MustCompile(`(?m)^\s*\{` + op + `, ` + class + `, C_NONE, C_NONE, C_(?:ZREG|RSP),(?: C_NONE,)? 32,`)
+			if len(row.FindAllString(source, -1)) != 1 {
+				t.Fatalf("Go single-instruction literal move row changed: %s/%s", op, class)
+			}
+		}
+	}
+}
+
+func TestARM64ControlGPMoveReadsSourceNotOldDestination(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, source := range []string{"R4", "ZR", "$0"} {
+			text := op + " " + source + ",R30"
+			requireARM64GoAssemblerResult(t, "TEXT move(SB),$0-0\n"+text+"\nRET\n", true)
+			file, err := Parse(ArchARM64, "TEXT move(SB),$0-0\n"+text+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:caller": true})},
+				memory: make(map[string]arm64ControlValue),
+			}
+			ins := file.Funcs[0].Instrs[1]
+			state.transfer(ins, ins.Op, false, nil)
+			if value := arm64ControlRead(state.regs, "R30"); arm64ControlCount(value) != 1 || !arm64ControlHas(value, "") {
+				t.Errorf("write-only destination kept old caller code: %s: %v", text, value)
+			}
+		}
+	}
+	for _, op := range []string{"MOVW", "MOVD"} {
+		for _, value := range []int64{-601, 806, 0x12340000, 0x12345678} {
+			text := fmt.Sprintf("%s $%d,R30", op, value)
+			requireARM64GoAssemblerResult(t, "TEXT move(SB),$0-0\n"+text+"\nRET\n", true)
+			file, err := Parse(ArchARM64, "TEXT move(SB),$0-0\n"+text+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			state := &arm64ControlState{regs: map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:caller": true})}, memory: make(map[string]arm64ControlValue)}
+			ins := file.Funcs[0].Instrs[1]
+			state.transfer(ins, ins.Op, false, nil)
+			if labels := arm64ControlLabels(arm64ControlRead(state.regs, "R30")); arm64ControlCount(labels) != 0 {
+				t.Errorf("literal overwrote LR but retained its code bits: %s: %v", text, labels)
+			}
+		}
+	}
+}
+
+func TestARM64ControlGPMoveLiteralToVectorScratch(t *testing.T) {
+	body := `MOVW $-601,R30
+VDUP R30,V22.S4
+FMOVQ F22,(R1)
+`
+	source := arm64RawZeroFrameFixture(516, false, body)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	if !arm64CallFrameUnexposedTyped(file.Funcs[0], sig, nil, nil) {
+		t.Fatal("constant vector scratch was mistaken for escaping caller code")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "constant-vector.ll", "constant-vector.o", ir)
+	}
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		text := op + " R30,R4"
+		file, err := Parse(ArchARM64, "TEXT taint(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{regs: map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:caller": true})}, memory: make(map[string]arm64ControlValue)}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, ins.Op, false, nil)
+		value := arm64ControlRead(state.regs, "R4")
+		if !arm64ControlHas(value, "label:caller") || op != "MOVD" && !arm64ControlHas(value, "code-derived:") {
+			t.Errorf("actual narrow/copy source washed caller code: %s: %v", text, value)
+		}
+	}
+	for _, text := range []string{"MOVK $1,R30", "MOVKW $65536,R30", "MOVW.X $1,R30"} {
+		file, err := Parse(ArchARM64, "TEXT closed(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{regs: map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:caller": true})}, memory: make(map[string]arm64ControlValue)}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, arm64ControlOp(ins), false, nil)
+		if !arm64ControlHas(arm64ControlRead(state.regs, "R30"), "label:caller") {
+			t.Errorf("RMW/unknown move got full overwrite witness: %s", text)
+		}
+	}
+	for _, text := range []string{"MOVW $unknown,R30", "MOVWU $-601,R30", "MOVWU $806,R30", "MOVWU $305419896,R30", "MOVB $1,R30", "FMOVD $0,R30"} {
+		file, err := Parse(ArchARM64, "TEXT unknown(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{regs: make(map[Reg]arm64ControlValue), memory: make(map[string]arm64ControlValue)}
+		if state.transferGPRegisterMove(file.Funcs[0].Instrs[1]) {
+			t.Errorf("unknown/invalid move got overwrite witness: %s", text)
+		}
+	}
+	// Fixed ABI identities cannot be restored by overwriting their bits.
+	for _, fixed := range []string{"g", "R29"} {
+		source := strings.Replace(arm64RawZeroFrameFixture(516, false, "MOVD $0,"+fixed+"\nMOVD R4,(R1)\n"), "WORD $0xa8c17bfd", "WORD $0xa8c107fe", 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposedTyped(file.Funcs[0], sig, nil, nil) {
+			t.Fatalf("constant replacement restored fixed entry identity: %s", fixed)
+		}
+	}
+}
diff --git a/arm64_control_graph_reference_test.go b/arm64_control_graph_reference_test.go
new file mode 100644
index 000000000..cd86c6a46
--- /dev/null
+++ b/arm64_control_graph_reference_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/rand"
+	"strings"
+	"testing"
+)
+
+// This file is copied unchanged into the frozen map-reference source. It uses
+// only the existing whole analysis and public translator, not set internals.
+func arm64ControlFiniteGraph(seed int64) string {
+	random := rand.New(rand.NewSource(seed))
+	var source strings.Builder
+	source.WriteString("TEXT controlGraph(SB),4,$64-0\nMOVD R30,R19\nMOVD $0,R0\n")
+	source.WriteString("CBZ R0,left\nADR right,R2\nMOVD R2,24(RSP)\nB joined\nleft:\nADR helper,R2\nMOVD R2,24(RSP)\njoined:\n")
+	if seed%3 == 0 {
+		source.WriteString("MOVD 24(RSP),R3\nCALL (R3)\n")
+	} else {
+		for calls := 1 + random.Intn(5); calls > 0; calls-- {
+			source.WriteString("CALL helper\n")
+		}
+	}
+	switch seed % 5 {
+	case 0:
+		source.WriteString("MOVD $1,R0\nagain:\nCBZ R0,finished\nSUB $1,R0\nB again\n")
+	case 1:
+		source.WriteString("MOVD R2,(R4)\n")
+	case 2:
+		// Object/analysis only: an unproved indirect native destination is
+		// deliberately never executed by this first-party receipt test.
+		source.WriteString("MOVD $0,R5\nCALL (R5)\n")
+	case 3:
+		source.WriteString("CBZ R0,address_left\nADD $8,RSP,R5\nB address_join\naddress_left:\nADD $16,RSP,R5\naddress_join:\nMOVD R2,(R5)\n")
+	case 4:
+		source.WriteString("MOVD R2,32(RSP)\nMOVW 32(RSP),R6\nMOVD R6,40(RSP)\n")
+	}
+	source.WriteString("finished:\nMOVD R19,R30\nRET\nright:\nMOVD $17,R7\nRET\nhelper:\nMOVD $19,R7\nRET\n")
+	return source.String()
+}
+
+func TestARM64ControlFiniteGraphFrozenReceipts(t *testing.T) {
+	for seed := int64(0); seed < 30; seed++ {
+		t.Run(fmt.Sprintf("seed_%02d", seed), func(t *testing.T) {
+			source := arm64ControlFiniteGraph(seed)
+			goAssemblerOracleOutput(t, "arm64", source, "", true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			ctx := &arm64Ctx{
+				blocks: arm64SplitBlocks(fn), normalizedSource: fn,
+				sig:     FuncSig{Name: "controlGraph", Ret: Void},
+				resolve: func(name string) string { return name },
+			}
+			if err := ctx.prepareLocalControl(); err != nil {
+				t.Fatal(err)
+			}
+			type point struct {
+				Block, Instruction  int
+				Before, Stack, Link arm64ControlValue
+			}
+			var points []point
+			for block, body := range ctx.blocks {
+				for instruction := range body.instrs {
+					key := [2]int{block, instruction}
+					points = append(points, point{block, instruction,
+						ctx.localControl.before[key], ctx.localControl.stackBefore[key], ctx.localControl.linkBefore[key]})
+				}
+			}
+			ir, translateErr := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"controlGraph": {Name: "controlGraph", Ret: Void}},
+			})
+			var diagnostic string
+			if translateErr != nil {
+				if !errors.Is(translateErr, ErrProbeNeedsContext) {
+					t.Fatalf("unexpected non-context source failure: %v", translateErr)
+				}
+				diagnostic = translateErr.Error()
+			}
+			receipt := struct {
+				Original   Func
+				Reachable  []bool
+				Outer      string
+				AutoFrame  bool
+				Points     []point
+				Diagnostic string
+				IR         string
+			}{fn, ctx.localControl.reachable, ctx.localControl.outer, ctx.localControl.autoFrame, points, diagnostic, ir}
+			encoded, err := json.Marshal(receipt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("finite-graph-complete-receipt %s", encoded)
+		})
+	}
+}
diff --git a/arm64_control_growth_test.go b/arm64_control_growth_test.go
new file mode 100644
index 000000000..6d249316c
--- /dev/null
+++ b/arm64_control_growth_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64ControlGrowthValue(targets int) arm64ControlValue {
+	value := arm64ControlExternal()
+	for index := 0; index < targets; index++ {
+		next := arm64ControlFromMap(map[string]bool{fmt.Sprintf("label:continuation_%d", index): true})
+		value = arm64ControlUnion(value, next)
+	}
+	return value
+}
+
+func arm64ControlGrowthCheckValue(tb testing.TB, value arm64ControlValue, targets int) {
+	tb.Helper()
+	if arm64ControlCount(value) != targets+1 || !arm64ControlHas(value, "") {
+		tb.Fatalf("wrong complete target set: %d entries, want %d", arm64ControlCount(value), targets+1)
+	}
+	for index := 0; index < targets; index++ {
+		if !arm64ControlHas(value, fmt.Sprintf("label:continuation_%d", index)) {
+			tb.Fatalf("missing original continuation %d", index)
+		}
+	}
+}
+
+func arm64ControlGrowthFixture(calls, cells int) (Func, error) {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT controlGrowth(SB),4,$%d-0\nMOVD R30,R19\n", (cells+2)*8)
+	for cell := 0; cell < cells; cell++ {
+		fmt.Fprintf(&source, "MOVD R30,%d(RSP)\n", (cell+1)*8)
+	}
+	for call := 0; call < calls; call++ {
+		fmt.Fprintf(&source, "call_%d:\nCALL external(SB)\n", call)
+	}
+	source.WriteString("done:\nMOVD R19,R30\nRET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		return Func{}, err
+	}
+	return file.Funcs[0], nil
+}
+
+func arm64ControlGrowthContext(fn Func) *arm64Ctx {
+	return &arm64Ctx{
+		blocks:           arm64SplitBlocks(fn),
+		normalizedSource: fn,
+		sig:              FuncSig{Name: "controlGrowth", Ret: Void},
+		resolve:          func(name string) string { return name },
+	}
+}
+
+func arm64ControlGrowthCheckPlan(tb testing.TB, ctx *arm64Ctx, calls int) {
+	tb.Helper()
+	plan := ctx.localControl
+	if plan == nil || len(plan.reachable) != len(ctx.blocks) {
+		tb.Fatal("missing complete control plan")
+	}
+	for block, reachable := range plan.reachable {
+		if !reachable {
+			tb.Fatalf("lost original block %d", block)
+		}
+	}
+	var value arm64ControlValue
+	for block, body := range ctx.blocks {
+		for instruction, ins := range body.instrs {
+			if ins.Op == OpRET {
+				value = plan.linkBefore[[2]int{block, instruction}]
+				ctx.currentInstruction = instruction
+				if err := ctx.requireCallerLinkRestored(block, ins); !errors.Is(err, ErrProbeNeedsContext) {
+					tb.Fatalf("unproved native calls gained caller permission: %v", err)
+				}
+			}
+		}
+	}
+	expected := arm64ControlFromMap(map[string]bool{"": true, "label:" + plan.outer: true, "label:done": true})
+	for call := 1; call < calls; call++ {
+		expected = arm64ControlSetToken(expected, fmt.Sprintf("label:call_%d", call), true)
+	}
+	if !arm64ControlEqual(value, expected) {
+		tb.Fatalf("changed original complete return targets: got %v, want %v", value, expected)
+	}
+}
+
+func TestARM64ControlGrowingContinuationAllocation(t *testing.T) {
+	const targets = 512
+	result := testing.Benchmark(func(b *testing.B) {
+		b.ReportAllocs()
+		for iteration := 0; iteration < b.N; iteration++ {
+			value := arm64ControlGrowthValue(targets)
+			arm64ControlGrowthCheckValue(b, value, targets)
+		}
+	})
+	t.Logf("complete %d-target growing query: %s %s", targets, result, result.MemString())
+	// This is a first-party allocation regression, not an analysis limit or
+	// target cap. Every original token above must remain present.
+	if result.AllocedBytesPerOp() > 2<<20 {
+		t.Fatalf("growing query repeatedly copies complete prior token maps: %d bytes/op", result.AllocedBytesPerOp())
+	}
+}
+
+func TestARM64ControlGrowthCompleteNativeCalls(t *testing.T) {
+	fn, err := arm64ControlGrowthFixture(8, 16)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := arm64ControlGrowthContext(fn)
+	if err := ctx.prepareLocalControl(); err != nil {
+		t.Fatal(err)
+	}
+	arm64ControlGrowthCheckPlan(t, ctx, 8)
+}
+
+func TestARM64ControlGrowthActualGoObjects(t *testing.T) {
+	for _, size := range []struct{ calls, cells int }{{8, 16}, {512, 256}} {
+		t.Run(fmt.Sprintf("calls_%d_cells_%d", size.calls, size.cells), func(t *testing.T) {
+			fn, err := arm64ControlGrowthFixture(size.calls, size.cells)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var source strings.Builder
+			for _, instruction := range fn.Instrs {
+				source.WriteString(instruction.Raw + "\n")
+			}
+			goAssemblerOracleOutput(t, "arm64", source.String(), "", true)
+			t.Logf("actual selected Go object source SHA256 %x; unknown native calls retain Context", sha256.Sum256([]byte(source.String())))
+		})
+	}
+}
+
+func BenchmarkARM64ControlGrowingUnion(b *testing.B) {
+	for _, targets := range []int{256, 512, 1024} {
+		b.Run(fmt.Sprintf("targets_%d", targets), func(b *testing.B) {
+			b.ReportAllocs()
+			for iteration := 0; iteration < b.N; iteration++ {
+				value := arm64ControlGrowthValue(targets)
+				arm64ControlGrowthCheckValue(b, value, targets)
+			}
+		})
+	}
+}
+
+func BenchmarkARM64ControlOuterStateClone(b *testing.B) {
+	for _, cells := range []int{128, 256, 512} {
+		b.Run(fmt.Sprintf("cells_%d", cells), func(b *testing.B) {
+			state := arm64ControlSharingState(512)
+			for cell := 0; cell < cells; cell++ {
+				state.memory[fmt.Sprintf("sp:%d", cell*8)] = state.escaped
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				copy := state.clone()
+				if len(copy.memory) != cells || !arm64ControlEqual(copy.escaped, state.escaped) {
+					b.Fatal("outer clone changed complete state")
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkARM64ControlGrowingNativeCFG(b *testing.B) {
+	for _, size := range []struct{ calls, cells int }{{128, 64}, {256, 128}, {512, 256}} {
+		b.Run(fmt.Sprintf("calls_%d_cells_%d", size.calls, size.cells), func(b *testing.B) {
+			fn, err := arm64ControlGrowthFixture(size.calls, size.cells)
+			if err != nil {
+				b.Fatal(err)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				ctx := arm64ControlGrowthContext(fn)
+				if err := ctx.prepareLocalControl(); err != nil {
+					b.Fatal(err)
+				}
+				arm64ControlGrowthCheckPlan(b, ctx, size.calls)
+			}
+		})
+	}
+}
diff --git a/arm64_control_memory_address_kind_test.go b/arm64_control_memory_address_kind_test.go
new file mode 100644
index 000000000..f408fa199
--- /dev/null
+++ b/arm64_control_memory_address_kind_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64ControlMemoryAddressLiteralsAreNotMemoryLoads(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVD $4(R10),R11",
+		"MOVD $-4097(R2),R3",
+		"MOVD $external(SB),R11",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT addressKind(SB),516,$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, accepted := arm64RawPrivateMemory(file.Funcs[0].Instrs[1]); accepted {
+				t.Fatal("address materialization was classified as a memory read")
+			}
+		})
+	}
+}
+
+func TestARM64ControlMemorySymbolLoadsAndStoresRemainTyped(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD", "FMOVS", "FMOVD", "FMOVQ"} {
+		reg := "R11"
+		if op[0] == 'F' {
+			reg = "F11"
+		}
+		for _, store := range []bool{false, true} {
+			instruction := op + " external(SB)," + reg
+			if store {
+				instruction = op + " " + reg + ",external(SB)"
+			}
+			t.Run(instruction, func(t *testing.T) {
+				source := "TEXT memoryKind(SB),516,$0-0\n" + instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, accepted := arm64RawPrivateMemory(file.Funcs[0].Instrs[1])
+				if !accepted || form.store != store || form.elementBytes != arm64RawPrivateScalarBytes(Op(op)) {
+					t.Fatalf("actual symbol memory lost its typed direction/width: %+v", form)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_control_memory_width.go b/arm64_control_memory_width.go
new file mode 100644
index 000000000..e58e0cfa4
--- /dev/null
+++ b/arm64_control_memory_width.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+)
+
+// The private-frame and continuation proofs consume the same scalar and
+// GP/FP-pair grammar. A narrow/FP store never creates an exact saved pointer;
+// its actual byte range can still invalidate an overlapping eight-byte cell.
+func (state *arm64ControlState) transferTypedMemory(ins Instr) bool {
+	form, valid := arm64RawPrivateMemory(ins)
+	if !valid {
+		return false
+	}
+	memory := form.memory
+	if form.post && memory.Kind == OpMem {
+		memory.Mem.Off = 0
+	}
+	// Read the address/old contents before materialization, but a store's R27
+	// transfer input after it. Keep the original base until the memory effect
+	// has been recorded, including when that original base itself is R27.
+	scratch := arm64ControlExternal()
+	if form.scratch != nil {
+		f := *form.scratch
+		if f.scratchAddress && f.memory.Kind == OpFP {
+			scratch = arm64ControlFromMap(map[string]bool{"fpa:" + strconv.FormatInt(f.memory.FPOffset, 10): true})
+		} else if f.scratchAddress && f.scratchBase != "" {
+			base := arm64ControlRead(state.regs, arm64ControlBase(f.scratchBase))
+			if f.scratchKnown {
+				scratch = arm64ControlOffset(base, f.scratchOffset)
+			} else {
+				// Different encoders can produce an address or a literal.
+				// Never retain its old exact LR/private-cell identity.
+				scratch = arm64ControlUnion(arm64ControlExternal(), arm64ControlAddressTaint(base))
+			}
+			if arm64ControlCount(arm64ControlLabels(base)) != 0 {
+				scratch = arm64ControlUnion(scratch, arm64ControlLabels(base))
+				scratch = arm64ControlWithToken(scratch, "code-derived:")
+			}
+		}
+	}
+	var values [2]arm64ControlValue
+	for index, reg := range form.registers {
+		if form.store {
+			values[index] = state.source(Operand{Kind: OpReg, Reg: reg}, false)
+			if form.scratch != nil && reg == "R27" {
+				values[index] = scratch
+			}
+		} else {
+			cell := arm64ControlElement(memory, int64(index)*form.elementBytes)
+			values[index] = state.readMemoryWidth(cell, form.elementBytes, form.gp)
+		}
+	}
+	for index, reg := range form.registers {
+		cell := arm64ControlElement(memory, int64(index)*form.elementBytes)
+		if form.store {
+			state.writeMemoryWidth(cell, values[index], form.elementBytes, form.gp)
+		} else {
+			state.write(Operand{Kind: OpReg, Reg: reg}, values[index], false)
+		}
+	}
+	if form.scratch != nil && (form.store || form.registers[0] != "R27") {
+		state.regs["R27"] = scratch
+	}
+	if form.pre || form.post {
+		base := arm64ControlBase(form.memory.Mem.Base)
+		state.regs[base] = arm64ControlOffset(arm64ControlRead(state.regs, base), form.memory.Mem.Off)
+	}
+	return true
+}
+
+func (state *arm64ControlState) readMemoryWidth(memory Operand, width int64, gp bool) arm64ControlValue {
+	if gp && width == 8 {
+		return state.source(memory, false)
+	}
+	value := arm64ControlUnion(arm64ControlExternal(), arm64ControlLabels(state.source(memory, false)))
+	if key := state.memoryKey(memory, false); strings.HasPrefix(key, "sp:") || strings.HasPrefix(key, "fp:") {
+		// Partial or floating loads can carry bits of a code pointer, but
+		// cannot restore its exact control identity. Inspect every overlap,
+		// including a load beginning inside a saved cell rather than at it.
+		for cell, stored := range state.memory {
+			if arm64ControlMemoryRangesOverlap(key, width, cell, 8) {
+				value = arm64ControlUnion(value, arm64ControlLabels(stored))
+			}
+		}
+	}
+	if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+		value = arm64ControlWithToken(value, "code-derived:")
+	}
+	return value
+}
+
+func (state *arm64ControlState) writeMemoryWidth(memory Operand, value arm64ControlValue, width int64, gp bool) {
+	if gp && width == 8 {
+		state.write(memory, value, false)
+		return
+	}
+	key := state.memoryKey(memory, false)
+	if key == "" {
+		state.invalidateUnknownStore(memory, value)
+		return
+	}
+	state.invalidateOverlappingControlCells(key, width)
+	// Retain transformed code bits without inventing an exact pointer cell.
+	// Unknown ordinary data need not create a new tracked continuation cell.
+	taint := arm64ControlLabels(value)
+	if arm64ControlCount(taint) != 0 {
+		taint = arm64ControlUnion(taint, arm64ControlExternal())
+		taint = arm64ControlWithToken(taint, "code-derived:")
+		for offset := int64(0); offset < width; offset += 8 {
+			cell := arm64ControlElement(memory, offset)
+			part := state.memoryKey(cell, false)
+			if part == "" {
+				state.invalidateUnknownStore(cell, taint)
+				continue
+			}
+			state.memory[part] = arm64ControlUnion(state.memory[part], taint)
+		}
+	}
+}
+
+func arm64ControlMemoryRangesOverlap(first string, firstWidth int64, second string, secondWidth int64) bool {
+	if len(first) < 4 || len(second) < 4 || first[:3] != second[:3] || firstWidth <= 0 || secondWidth <= 0 {
+		return false
+	}
+	left, err := strconv.ParseInt(first[3:], 10, 64)
+	if err != nil {
+		return false
+	}
+	right, err := strconv.ParseInt(second[3:], 10, 64)
+	if err != nil {
+		return false
+	}
+	// Unsigned distance avoids signed overflow at either int64 boundary.
+	if left <= right {
+		return uint64(right)-uint64(left) < uint64(firstWidth)
+	}
+	return uint64(left)-uint64(right) < uint64(secondWidth)
+}
diff --git a/arm64_control_memory_width_runtime_test.go b/arm64_control_memory_width_runtime_test.go
new file mode 100644
index 000000000..4bf33d09b
--- /dev/null
+++ b/arm64_control_memory_width_runtime_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ControlMemoryAdjacent(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	file, sigs, source, cases := arm64ControlMemoryAdjacentFixture(t)
+	var goDeclarations, goChecks, cDeclarations, cChecks strings.Builder
+	for _, tc := range cases {
+		floating := 0
+		if tc.floating {
+			floating = 1
+		}
+		fmt.Fprintf(&goDeclarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const unsigned char *,unsigned char *);\n", tc.name)
+		fmt.Fprintf(&goChecks, "check(%s,%d,%d,%d,%d)\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+		fmt.Fprintf(&cChecks, "if(check(%s,%d,%d,%d,%d)) return 1;\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module adjacentcalleroracle\n\ngo 1.20\n",
+		"main.go": arm64RawPrivateFrameOracleGo + goDeclarations.String() +
+			"func main(){\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT adjacent_", "TEXT ·adjacent_"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go adjacent caller-cell width oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := arm64RawPrivateFrameOracleC + cDeclarations.String() +
+		"int main(void){\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "adjacent_caller_memory", triple, ir, cMain, runner)
+	t.Logf("actual Go + LLVM22/independent numeric C: %d width/sign/pair/writeback/local-call variants x 256 patterns x 5 unaligned offsets; adjacent saved LR/BP, full canaries and real return", len(cases))
+}
diff --git a/arm64_control_memory_width_test.go b/arm64_control_memory_width_test.go
new file mode 100644
index 000000000..c7f3a5ebf
--- /dev/null
+++ b/arm64_control_memory_width_test.go
@@ -0,0 +1,298 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ControlMemoryWidthsPreserveAdjacentCallerCells(t *testing.T) {
+	for _, tc := range []struct {
+		store string
+		width int64
+	}{
+		{"MOVB R4", 1}, {"MOVBU R4", 1}, {"MOVH R4", 2}, {"MOVHU R4", 2},
+		{"MOVW R4", 4}, {"MOVWU R4", 4}, {"MOVD R4", 8},
+		{"FMOVS F0", 4}, {"FMOVD F0", 8}, {"FMOVQ F0", 16},
+		{"STPW (R4,R5)", 8}, {"STP (R4,R5)", 16},
+		{"FSTPS (F0,F1)", 8}, {"FSTPD (F0,F1)", 16}, {"FSTPQ (F0,F1)", 32},
+	} {
+		t.Run(tc.store, func(t *testing.T) {
+			for _, offset := range []int64{-tc.width, 8} {
+				source := fmt.Sprintf("TEXT width(SB),$0-0\n%s,%d(RSP)\nRET\n", tc.store, offset)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				state := &arm64ControlState{
+					regs: map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+					memory: map[string]arm64ControlValue{
+						"sp:0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true}),
+					},
+				}
+				ins := file.Funcs[0].Instrs[1]
+				state.transfer(ins, ins.Op, false, nil)
+				if !arm64ControlEqual(state.memory["sp:0"], arm64ControlFromMap(map[string]bool{"label:entry_lr": true})) {
+					t.Fatalf("adjacent %d-byte store at %d corrupted saved caller: %v", tc.width, offset, state.memory)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64ControlMemoryLiteralZeroAliasWidths(t *testing.T) {
+	for _, tc := range []struct {
+		op    string
+		width int64
+	}{
+		{"MOVB", 1}, {"MOVBU", 1}, {"MOVH", 2}, {"MOVHU", 2},
+		{"MOVW", 4}, {"MOVWU", 4}, {"MOVD", 8},
+	} {
+		source := fmt.Sprintf("TEXT zero(SB),$0-0\n%s $0,%d(RSP)\nRET\n", tc.op, -tc.width)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{
+			regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+			memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, ins.Op, false, nil)
+		if !arm64ControlEqual(state.memory["sp:0"], arm64ControlFromMap(map[string]bool{"label:entry_lr": true})) {
+			t.Errorf("Go literal-zero alias used unknown-width store: %s: %v", tc.op, state.memory)
+		}
+	}
+}
+
+func TestARM64ControlMemoryPartialLoadsAndUnknownStoresStayClosed(t *testing.T) {
+	for _, text := range []string{
+		"MOVB (RSP),R4", "MOVBU (RSP),R4", "MOVH 1(RSP),R4", "MOVHU (RSP),R4",
+		"MOVW (RSP),R4", "MOVWU (RSP),R4", "LDPW (RSP),(R4,R5)", "LDPSW (RSP),(R4,R5)",
+		"FMOVS (RSP),F0", "FMOVD (RSP),F0", "FMOVQ (RSP),F0",
+		"FLDPS (RSP),(F0,F1)", "FLDPD (RSP),(F0,F1)", "FLDPQ (RSP),(F0,F1)",
+	} {
+		file, err := Parse(ArchARM64, "TEXT partial(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{
+			regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+			memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, ins.Op, false, nil)
+		dst := ins.Args[1].Reg
+		if dst == "" {
+			dst = ins.Args[1].RegList[0]
+		}
+		value := arm64ControlRead(state.regs, dst)
+		if !arm64ControlHas(value, "code-derived:") || !arm64ControlHas(value, "") {
+			t.Fatalf("partial/floating load restored exact pointer identity: %s: %v", text, value)
+		}
+	}
+	for _, text := range []string{"FMOVQ F0,(RSP)(R4)", "FSTPQ (F0,F1),(R9)", "MOVD R4,slot(SB)"} {
+		file, err := Parse(ArchARM64, "TEXT unknown(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{
+			regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R9": arm64ControlFromMap(map[string]bool{"sp:0": true})},
+			memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, ins.Op, false, nil)
+		if !arm64ControlHas(state.memory["sp:0"], "") {
+			t.Fatalf("unknown/overlapping store lost caller taint: %s: %v", text, state.memory)
+		}
+	}
+	// Floating code bits must remain tainted across the complete Q-width store,
+	// including a later narrow load from the upper eight bytes.
+	file, err := Parse(ArchARM64, "TEXT bits(SB),$0-0\nFMOVQ F0,(RSP)\nMOVW 12(RSP),R4\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	state := &arm64ControlState{
+		regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "F0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+		memory: make(map[string]arm64ControlValue),
+	}
+	for _, ins := range file.Funcs[0].Instrs[1:3] {
+		state.transfer(ins, ins.Op, false, nil)
+	}
+	if !arm64ControlHas(arm64ControlRead(state.regs, "R4"), "code-derived:") {
+		t.Fatal("upper-half floating store washed away transformed code bits")
+	}
+}
+
+func TestARM64ControlMemoryTypedGrammarRejectsUnknownAliases(t *testing.T) {
+	for _, text := range []string{
+		"MOVB $1,(RSP)", "MOVD $unresolved,(RSP)", "FMOVD $0,(RSP)",
+		"MOVD.X R4,(RSP)", "MOVD.P 8(R9),R9", "LDP.P 16(R9),(R9,R10)",
+		"LDP (RSP),(R9,R9)", "FSTPQ (F0,R4),(RSP)",
+	} {
+		file, err := Parse(ArchARM64, "TEXT invalid(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			continue
+		}
+		state := &arm64ControlState{regs: make(map[Reg]arm64ControlValue), memory: make(map[string]arm64ControlValue)}
+		if state.transferTypedMemory(file.Funcs[0].Instrs[1]) {
+			t.Fatalf("unknown/invalid operand supplied exact-width permission: %s", text)
+		}
+	}
+}
+
+func TestARM64ControlMemoryRangeBoundaries(t *testing.T) {
+	for _, tc := range []struct {
+		first  string
+		width  int64
+		second string
+		other  int64
+		want   bool
+	}{
+		{"sp:-16", 8, "sp:-8", 8, false}, {"sp:-15", 8, "sp:-8", 8, true},
+		{"sp:0", 8, "sp:8", 1, false}, {"sp:0", 8, "sp:7", 1, true},
+		{"sp:-9223372036854775808", 8, "sp:9223372036854775807", 8, false},
+		{"sp:9223372036854775806", 4, "sp:9223372036854775807", 8, true},
+		{"sp:0", 8, "fp:0", 8, false}, {"sp:bad", 8, "sp:0", 8, false},
+	} {
+		if got := arm64ControlMemoryRangesOverlap(tc.first, tc.width, tc.second, tc.other); got != tc.want {
+			t.Fatalf("range (%s,%d)/(%s,%d): got %t want %t", tc.first, tc.width, tc.second, tc.other, got, tc.want)
+		}
+	}
+}
+
+func TestARM64ControlMemoryFixedCallerCellBoundaries(t *testing.T) {
+	for _, token := range []string{"label:entry_lr", "entry-bp:", "entry-g:", "entry-os18:"} {
+		for _, offset := range []int64{-32, -31} {
+			file, err := Parse(ArchARM64, fmt.Sprintf("TEXT fixed(SB),$0-0\nFSTPQ (F0,F1),%d(RSP)\nRET\n", offset))
+			if err != nil {
+				t.Fatal(err)
+			}
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+				memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{token: true})},
+			}
+			ins := file.Funcs[0].Instrs[1]
+			state.transfer(ins, ins.Op, false, nil)
+			if arm64ControlHas(state.memory["sp:0"], "") != (offset == -31) {
+				t.Fatalf("fixed caller cell %s adjacent/one-byte boundary at %d: %v", token, offset, state.memory)
+			}
+		}
+	}
+}
+
+func arm64ControlMemoryAdjacentFixture(t *testing.T) (*File, map[string]FuncSig, string, []arm64RawPrivateMemoryCase) {
+	t.Helper()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var cases []arm64RawPrivateMemoryCase
+	for _, base := range []arm64RawPrivateMemoryCase{
+		{name: "byte", store: "MOVB R4", load: "MOVB", width: 1, count: 1, signBits: 64},
+		{name: "ubyte", store: "MOVBU R4", load: "MOVBU", width: 1, count: 1},
+		{name: "half", store: "MOVH R4", load: "MOVH", width: 2, count: 1, signBits: 64},
+		{name: "uhalf", store: "MOVHU R4", load: "MOVHU", width: 2, count: 1},
+		{name: "word", store: "MOVW R4", load: "MOVW", width: 4, count: 1, signBits: 64},
+		{name: "uword", store: "MOVWU R4", load: "MOVWU", width: 4, count: 1},
+		{name: "double", store: "MOVD R4", load: "MOVD", width: 8, count: 1},
+		{name: "float_s", store: "FMOVS F0", load: "FMOVS", width: 4, count: 1, floating: true},
+		{name: "float_d", store: "FMOVD F0", load: "FMOVD", width: 8, count: 1, floating: true},
+		{name: "float_q", store: "FMOVQ F0", load: "FMOVQ", width: 16, count: 1, floating: true},
+		{name: "pair", store: "STP (R4,R5)", load: "LDP", width: 8, count: 2},
+		{name: "pair_word", store: "STPW (R4,R5)", load: "LDPW", width: 4, count: 2},
+		{name: "pair_signed", store: "STPW (R4,R5)", load: "LDPSW", width: 4, count: 2, signBits: 64},
+		{name: "float_pair_s", store: "FSTPS (F0,F1)", load: "FLDPS", width: 4, count: 2, floating: true},
+		{name: "float_pair_d", store: "FSTPD (F0,F1)", load: "FLDPD", width: 8, count: 2, floating: true},
+		{name: "float_pair_q", store: "FSTPQ (F0,F1)", load: "FLDPQ", width: 16, count: 2, floating: true},
+	} {
+		for _, mode := range []string{"offset", "pre_post", "post_pre"} {
+			for _, call := range []bool{false, true} {
+				tc := base
+				tc.name = "adjacent_" + base.name + "_" + mode
+				if call {
+					tc.name += "_local_call"
+				}
+				storeOp, values, _ := strings.Cut(base.store, " ")
+				prep := "MOVD (R0),R4\nMOVD 8(R0),R5\n"
+				dst := "R9"
+				outputs := "MOVD R9,(R1)\n"
+				if tc.count == 2 {
+					dst = "(R9,R10)"
+					outputs += "MOVD R10,8(R1)\n"
+				}
+				if tc.floating {
+					prep = "FMOVQ (R0),F0\nFMOVQ 16(R0),F1\n"
+					dst = "F2"
+					move := map[int]string{4: "FMOVS", 8: "FMOVD", 16: "FMOVQ"}[tc.width]
+					outputs = move + " F2,(R1)\n"
+					if tc.count == 2 {
+						dst = "(F2,F3)"
+						outputs += fmt.Sprintf("%s F3,%d(R1)\n", move, tc.width)
+					}
+				}
+				width := tc.width * tc.count
+				allocation := (width + 15) &^ 15
+				body := fmt.Sprintf("SUB $64,RSP\n%s\n%s %s,%d(RSP)\n%s %d(RSP),%s\nADD $64,RSP\n", prep, storeOp, values, 64-width, tc.load, 64-width, dst)
+				if mode == "pre_post" {
+					body = fmt.Sprintf("%s\n%s.W %s,-%d(RSP)\n%s.P %d(RSP),%s\n", prep, storeOp, values, allocation, tc.load, allocation, dst)
+				} else if mode == "post_pre" {
+					body = fmt.Sprintf("SUB $%d,RSP\n%s\n%s.P %s,%d(RSP)\n%s.W -%d(RSP),%s\nADD $%d,RSP\n", 2*allocation, prep, storeOp, values, allocation, tc.load, allocation, dst, 2*allocation)
+				}
+				source.WriteString(strings.Replace(arm64RawZeroFrameFixture(516, call, body+outputs), "rawZero", tc.name, 1))
+				sig := arm64RawZeroFrameSig()
+				sig.Name = tc.name
+				sigs[tc.name] = sig
+				cases = append(cases, tc)
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, sigs, source.String(), cases
+}
+
+func TestARM64ControlMemoryAdjacentFrameObjects(t *testing.T) {
+	file, sigs, _, cases := arm64ControlMemoryAdjacentFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "adjacent-frame.ll", "adjacent-frame.o", ir)
+	}
+	t.Logf("actual Go and LLVM22 five-target objects: %d exact-width adjacent caller-cell forms", len(cases))
+}
+
+func TestARM64ControlMemoryOneByteOverlapRemainsTainted(t *testing.T) {
+	for _, source := range []string{
+		"MOVB R4,7(RSP)", "MOVH R4,-1(RSP)", "MOVW R4,-3(RSP)",
+		"MOVD R4,-7(RSP)", "FMOVS F0,-3(RSP)", "FMOVD F0,-7(RSP)",
+		"FMOVQ F0,-15(RSP)", "STPW (R4,R5),-7(RSP)",
+		"STP (R4,R5),-15(RSP)", "FSTPS (F0,F1),-7(RSP)",
+		"FSTPD (F0,F1),-15(RSP)", "FSTPQ (F0,F1),-31(RSP)",
+	} {
+		file, err := Parse(ArchARM64, "TEXT overlap(SB),$0-0\n"+source+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{
+			regs: map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+			memory: map[string]arm64ControlValue{
+				"sp:0": arm64ControlFromMap(map[string]bool{"label:entry_lr": true}),
+			},
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state.transfer(ins, ins.Op, false, nil)
+		if !arm64ControlHas(state.memory["sp:0"], "") {
+			t.Fatalf("one-byte-overlap lost caller-cell taint: %s: %v", source, state.memory)
+		}
+	}
+}
diff --git a/arm64_control_merge_cfg_test.go b/arm64_control_merge_cfg_test.go
new file mode 100644
index 000000000..682a6982a
--- /dev/null
+++ b/arm64_control_merge_cfg_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Object/analysis only: unknown external code is never linked or executed.
+// A shared helper receives growing return sets and writes the exact same set
+// into every original private cell, matching the retained workload dimension.
+func arm64ControlRepeatedHelperSource(calls, cells int) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT repeatedHelper(SB),4,$%d-0\nMOVD R30,R19\n", (cells+2)*8)
+	for call := 0; call < calls; call++ {
+		fmt.Fprintf(&source, "call_%d:\nCALL helper\n", call)
+	}
+	source.WriteString("done:\nMOVD R19,R30\nRET\nhelper:\n")
+	for cell := 0; cell < cells; cell++ {
+		fmt.Fprintf(&source, "MOVD R30,%d(RSP)\n", (cell+1)*8)
+	}
+	source.WriteString("MOVD R30,R20\nCALL external(SB)\nMOVD R20,R30\nRET\n")
+	return source.String()
+}
+
+func arm64ControlRepeatedHelperContext(tb testing.TB, calls, cells int) (*arm64Ctx, string) {
+	tb.Helper()
+	source := arm64ControlRepeatedHelperSource(calls, cells)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		tb.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	return &arm64Ctx{
+		blocks: arm64SplitBlocks(fn), normalizedSource: fn,
+		sig: FuncSig{Name: "repeatedHelper", Ret: Void}, resolve: func(name string) string { return name },
+	}, source
+}
+
+func arm64ControlRepeatedHelperCheck(tb testing.TB, ctx *arm64Ctx, calls int) {
+	tb.Helper()
+	plan := ctx.localControl
+	if plan == nil || len(plan.reachable) != len(ctx.blocks) {
+		tb.Fatal("missing complete growing helper plan")
+	}
+	for _, reachable := range plan.reachable {
+		if !reachable {
+			tb.Fatal("dropped original reachable helper/return block")
+		}
+	}
+	for call := 1; call < calls; call++ {
+		token := fmt.Sprintf("label:call_%d", call)
+		found := false
+		for _, value := range plan.linkBefore {
+			found = found || arm64ControlHas(value, token)
+		}
+		if !found {
+			tb.Fatalf("dropped original return destination %q", token)
+		}
+	}
+}
+
+func TestARM64ControlRepeatedHelperCompleteSourceReceipts(t *testing.T) {
+	for _, size := range []struct{ calls, cells int }{{8, 16}, {32, 32}} {
+		t.Run(fmt.Sprintf("calls_%d_cells_%d", size.calls, size.cells), func(t *testing.T) {
+			ctx, source := arm64ControlRepeatedHelperContext(t, size.calls, size.cells)
+			goAssemblerOracleOutput(t, "arm64", source, "", true)
+			if err := ctx.prepareLocalControl(); err != nil {
+				t.Fatal(err)
+			}
+			arm64ControlRepeatedHelperCheck(t, ctx, size.calls)
+			type point struct {
+				Block, Instruction  int
+				Before, Stack, Link arm64ControlValue
+			}
+			var points []point
+			for block, body := range ctx.blocks {
+				for instruction := range body.instrs {
+					key := [2]int{block, instruction}
+					points = append(points, point{block, instruction, ctx.localControl.before[key],
+						ctx.localControl.stackBefore[key], ctx.localControl.linkBefore[key]})
+				}
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, translateErr := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"repeatedHelper": {Name: "repeatedHelper", Ret: Void}},
+			})
+			if !errors.Is(translateErr, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("unknown external helper gained native/ABI authority: %v", translateErr)
+			}
+			receipt := struct {
+				Source, Outer, Diagnostic, IR string
+				Original                      Func
+				Reachable                     []bool
+				AutoFrame                     bool
+				Points                        []point
+			}{source, ctx.localControl.outer, translateErr.Error(), ir, file.Funcs[0],
+				ctx.localControl.reachable, ctx.localControl.autoFrame, points}
+			encoded, err := json.Marshal(receipt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("repeated-helper-complete-receipt %s", encoded)
+		})
+	}
+}
+
+func BenchmarkARM64ControlRepeatedHelperCFG(b *testing.B) {
+	for _, size := range []struct{ calls, cells int }{{32, 16}, {128, 64}, {512, 256}} {
+		b.Run(fmt.Sprintf("calls_%d_cells_%d", size.calls, size.cells), func(b *testing.B) {
+			prototype, _ := arm64ControlRepeatedHelperContext(b, size.calls, size.cells)
+			fn := prototype.normalizedSource
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				ctx := &arm64Ctx{
+					blocks: arm64SplitBlocks(fn), normalizedSource: fn,
+					sig: prototype.sig, resolve: prototype.resolve,
+				}
+				if err := ctx.prepareLocalControl(); err != nil {
+					b.Fatal(err)
+				}
+				arm64ControlRepeatedHelperCheck(b, ctx, size.calls)
+			}
+		})
+	}
+}
diff --git a/arm64_control_merge_operations.go b/arm64_control_merge_operations.go
new file mode 100644
index 000000000..7344f07e4
--- /dev/null
+++ b/arm64_control_merge_operations.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+// Values are immutable typed sets. This ordered identity includes the raw
+// comparison value, which may differ from a missing-input or alias-read value.
+// It never uses a hash, map identity, or a permission/source certificate.
+type arm64ControlMergeOperands struct {
+	old, left, right arm64ControlValue
+}
+
+type arm64ControlMergeResult struct {
+	value   arm64ControlValue
+	changed bool
+}
+
+// The table belongs to one merge invocation. It is not retained by the state
+// or by an analysis. Shared roots remain immutable after the table is released.
+type arm64ControlMergeOperations map[arm64ControlMergeOperands]arm64ControlMergeResult
+
+func (operations *arm64ControlMergeOperations) union(old, left, right arm64ControlValue) arm64ControlMergeResult {
+	// Preserve the existing allocation-free stable-state case. Identity is
+	// insufficient for false entries or multiple affine frame witnesses.
+	if old == left && left == right && arm64ControlCanonical(left) {
+		return arm64ControlMergeResult{value: left}
+	}
+	key := arm64ControlMergeOperands{old, left, right}
+	if result, present := (*operations)[key]; present {
+		return result
+	}
+	value := arm64ControlUnion(left, right)
+	result := arm64ControlMergeResult{
+		value: value, changed: !arm64ControlEqual(old, value),
+	}
+	if *operations == nil {
+		*operations = make(arm64ControlMergeOperations)
+	}
+	(*operations)[key] = result
+	return result
+}
diff --git a/arm64_control_merge_operations_test.go b/arm64_control_merge_operations_test.go
new file mode 100644
index 000000000..6c94b64b5
--- /dev/null
+++ b/arm64_control_merge_operations_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/rand"
+	"reflect"
+	"testing"
+)
+
+func TestARM64ControlMergeOperationOrderedIdentity(t *testing.T) {
+	values := []arm64ControlValue{nil, {},
+		arm64ControlFromMap(map[string]bool{"label:a": false}),
+		arm64ControlFromMap(map[string]bool{"label:a": true}),
+		arm64ControlFromMap(map[string]bool{"sp:0": true, "fp:8": false}),
+		arm64ControlFromMap(map[string]bool{"": false, "code-derived:": true}),
+	}
+	var collision *arm64ControlNode
+	collision = arm64ControlInsert(collision, 7, "label:collision_a", false)
+	collision = arm64ControlInsert(collision, 7, "label:collision_b", true)
+	values = append(values, &arm64ControlSet{root: collision})
+	var operations arm64ControlMergeOperations
+	for oldIndex, old := range values {
+		for leftIndex, left := range values {
+			for rightIndex, right := range values {
+				want := arm64ControlFrozenUnion(arm64ControlMap(left), arm64ControlMap(right))
+				wantChanged := !arm64ControlFrozenEqual(arm64ControlMap(old), want)
+				result := operations.union(old, left, right)
+				if result.changed != wantChanged || !reflect.DeepEqual(arm64ControlMap(result.value), want) {
+					t.Fatalf("complete ordered triple %d/%d/%d changed", oldIndex, leftIndex, rightIndex)
+				}
+				if again := operations.union(old, left, right); again != result {
+					t.Fatal("same complete ordered inputs did not retain exact result")
+				}
+			}
+		}
+	}
+	// A distinct value carrying the same full strings must not retrieve a
+	// pointer-identity entry, even if the independently computed answer agrees.
+	copy := arm64ControlFromMap(arm64ControlMap(values[3]))
+	operations.union(nil, copy, nil)
+	if _, present := operations[arm64ControlMergeOperands{nil, copy, nil}]; !present {
+		t.Fatal("distinct immutable operand identity was replaced by content/hash inference")
+	}
+}
+
+func TestARM64ControlRepeatedMergeRandomCompleteMapState(t *testing.T) {
+	for seed := int64(0); seed < 100; seed++ {
+		t.Run(fmt.Sprintf("seed_%03d", seed), func(t *testing.T) {
+			random := rand.New(rand.NewSource(seed))
+			values := []arm64ControlValue{nil, {},
+				arm64ControlFromMap(map[string]bool{"label:a": false}),
+				arm64ControlFromMap(map[string]bool{"sp:0": true, "fp:8": false}),
+				arm64ControlFromMap(map[string]bool{"": false, "code-derived:": true}),
+			}
+			for index := 0; index < 8; index++ {
+				entries := make(map[string]bool)
+				for token := 0; token < 16; token++ {
+					if random.Intn(3) != 0 {
+						entries[fmt.Sprintf("label:target_%d", token)] = random.Intn(3) != 0
+					}
+				}
+				values = append(values, arm64ControlFromMap(entries))
+			}
+			makeState := func() *arm64ControlState {
+				state := &arm64ControlState{
+					regs: make(map[Reg]arm64ControlValue), memory: make(map[string]arm64ControlValue),
+					escaped: values[random.Intn(len(values))], unexposedSP: random.Intn(2) == 0,
+				}
+				for _, reg := range []Reg{SP, "R0", "R1", "R30", "F0"} {
+					if random.Intn(3) != 0 {
+						state.regs[reg] = values[random.Intn(len(values))]
+					}
+				}
+				for cell := 0; cell < 16; cell++ {
+					if random.Intn(3) != 0 {
+						state.memory[fmt.Sprintf("sp:%d", cell*8)] = values[random.Intn(len(values))]
+					}
+				}
+				return state
+			}
+			state, other := makeState(), makeState()
+			// Only the destination state has a second view, avoiding any
+			// dependence on unordered sequential incoming alias updates.
+			state.regs["V0"] = values[random.Intn(len(values))]
+			want, incoming := arm64ControlFrozenStateOf(state), arm64ControlFrozenStateOf(other)
+			otherBefore := arm64ControlFrozenStateOf(other)
+			wantChanged := want.merge(incoming)
+			if changed := state.merge(other); changed != wantChanged || !reflect.DeepEqual(arm64ControlFrozenStateOf(state), want) {
+				t.Fatalf("complete original map-state transfer changed (changed %v want %v)", changed, wantChanged)
+			}
+			if !reflect.DeepEqual(arm64ControlFrozenStateOf(other), otherBefore) {
+				t.Fatal("merge modified a predecessor or its shared exact sets")
+			}
+		})
+	}
+}
diff --git a/arm64_control_merge_repeat_test.go b/arm64_control_merge_repeat_test.go
new file mode 100644
index 000000000..1e014e752
--- /dev/null
+++ b/arm64_control_merge_repeat_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// Both operands retain all original tokens. Common entries are deliberately
+// constructed independently, as happens when many incoming paths carry the
+// same logical return destinations without sharing every physical trie node.
+func arm64ControlMergeRepeatedOperands(targets int) (arm64ControlValue, arm64ControlValue) {
+	tokens := make([]string, targets+2)
+	for index := range tokens {
+		tokens[index] = fmt.Sprintf("label:return_%d", index)
+	}
+	sort.Slice(tokens, func(left, right int) bool {
+		return arm64ControlHash(tokens[left]) < arm64ControlHash(tokens[right])
+	})
+	left, right := make(map[string]bool), make(map[string]bool)
+	for _, token := range tokens[:targets] {
+		left[token], right[token] = true, true
+	}
+	left[tokens[targets]], right[tokens[targets+1]] = true, true
+	return arm64ControlFromMap(left), arm64ControlFromMap(right)
+}
+
+func arm64ControlMergeRepeatedState(value arm64ControlValue, cells int) *arm64ControlState {
+	state := &arm64ControlState{
+		regs: map[Reg]arm64ControlValue{
+			SP:    arm64ControlFromMap(map[string]bool{"sp:0": true}),
+			"R30": value,
+		},
+		memory:      make(map[string]arm64ControlValue),
+		escaped:     value,
+		unexposedSP: true,
+	}
+	for cell := 0; cell < cells; cell++ {
+		state.memory[fmt.Sprintf("sp:%d", (cell+1)*8)] = value
+	}
+	return state
+}
+
+func arm64ControlMergeCheckComplete(tb testing.TB, state *arm64ControlState, left, right arm64ControlValue, cells int) {
+	tb.Helper()
+	want := arm64ControlFrozenUnion(arm64ControlMap(left), arm64ControlMap(right))
+	if len(state.memory) != cells || !state.unexposedSP || !arm64ControlEqual(state.regs[SP], arm64ControlFromMap(map[string]bool{"sp:0": true})) {
+		tb.Fatal("merge changed outer frame/ownership or dropped private cells")
+	}
+	for cell := 0; cell < cells; cell++ {
+		key := fmt.Sprintf("sp:%d", (cell+1)*8)
+		if !reflect.DeepEqual(arm64ControlMap(state.memory[key]), want) {
+			tb.Fatalf("changed complete original RET set in cell %s", key)
+		}
+	}
+	if !reflect.DeepEqual(arm64ControlMap(state.escaped), want) || !reflect.DeepEqual(arm64ControlMap(state.regs["R30"]), want) {
+		tb.Fatal("merge changed complete escaped/link target sets")
+	}
+}
+
+func TestARM64ControlRepeatedMergeAllocation(t *testing.T) {
+	const targets, cells = 512, 128
+	left, right := arm64ControlMergeRepeatedOperands(targets)
+	before, incoming := arm64ControlMergeRepeatedState(left, cells), arm64ControlMergeRepeatedState(right, cells)
+	var result *arm64ControlState
+	measurement := testing.Benchmark(func(b *testing.B) {
+		b.ReportAllocs()
+		for iteration := 0; iteration < b.N; iteration++ {
+			result = before.clone()
+			if !result.merge(incoming) {
+				b.Fatal("lost new original return destination")
+			}
+		}
+	})
+	arm64ControlMergeCheckComplete(t, result, left, right, cells)
+	arm64ControlMergeCheckComplete(t, before, left, left, cells)
+	arm64ControlMergeCheckComplete(t, incoming, right, right, cells)
+	t.Logf("complete %d-target/%d-cell repeated merge: %s %s", targets, cells, measurement, measurement.MemString())
+	// A test-only allocation assertion, not a proof/target/work bound. Every
+	// original target and cell was independently checked above.
+	if measurement.AllocedBytesPerOp() > 1<<20 {
+		t.Fatalf("one merge recomputes the identical complete union for every cell: %d bytes/op", measurement.AllocedBytesPerOp())
+	}
+}
+
+func TestARM64ControlRepeatedMergeOrderedFalseNilReference(t *testing.T) {
+	values := []arm64ControlValue{
+		nil, arm64ControlFromMap(map[string]bool{}),
+		arm64ControlFromMap(map[string]bool{"label:a": false}),
+		arm64ControlFromMap(map[string]bool{"label:a": true}),
+		arm64ControlFromMap(map[string]bool{"": false, "fp:8": true}),
+		arm64ControlFromMap(map[string]bool{"sp:0": true, "code-derived:": false}),
+	}
+	for leftIndex, left := range values {
+		for rightIndex, right := range values {
+			name := fmt.Sprintf("ordered_%d_%d", leftIndex, rightIndex)
+			t.Run(name, func(t *testing.T) {
+				state, other := arm64ControlMergeRepeatedState(left, 8), arm64ControlMergeRepeatedState(right, 8)
+				want, incoming := arm64ControlFrozenStateOf(state), arm64ControlFrozenStateOf(other)
+				wantChanged := want.merge(incoming)
+				changed := state.merge(other)
+				if changed != wantChanged || !reflect.DeepEqual(arm64ControlFrozenStateOf(state), want) {
+					t.Fatalf("changed ordered nil/false merge: %v, want %v", changed, wantChanged)
+				}
+			})
+		}
+	}
+}
+
+// Independent old map-state transfer, including ordered asymmetric equality,
+// absent inputs and physical vector aliases. It is not used by production.
+type arm64ControlFrozenState struct {
+	regs        map[Reg]map[string]bool
+	memory      map[string]map[string]bool
+	escaped     map[string]bool
+	unexposedSP bool
+}
+
+func arm64ControlFrozenStateOf(state *arm64ControlState) *arm64ControlFrozenState {
+	result := &arm64ControlFrozenState{
+		regs: make(map[Reg]map[string]bool), memory: make(map[string]map[string]bool),
+		escaped: arm64ControlMap(state.escaped), unexposedSP: state.unexposedSP,
+	}
+	for reg, value := range state.regs {
+		result.regs[reg] = arm64ControlMap(value)
+	}
+	for key, value := range state.memory {
+		result.memory[key] = arm64ControlMap(value)
+	}
+	return result
+}
+
+func (state *arm64ControlFrozenState) read(reg Reg) map[string]bool {
+	reg = arm64ControlBase(reg)
+	value := state.regs[reg]
+	root := arm64MachineRegister(reg)
+	if strings.HasPrefix(root, "V") {
+		for alias, witness := range state.regs {
+			if arm64MachineRegister(alias) == root {
+				value = arm64ControlFrozenUnion(value, witness)
+			}
+		}
+	}
+	if value == nil {
+		return map[string]bool{"": true}
+	}
+	return value
+}
+
+func (state *arm64ControlFrozenState) merge(other *arm64ControlFrozenState) bool {
+	changed := false
+	if state.unexposedSP && !other.unexposedSP {
+		state.unexposedSP, changed = false, true
+	}
+	escaped := arm64ControlFrozenUnion(state.escaped, other.escaped)
+	if !arm64ControlFrozenEqual(state.escaped, escaped) {
+		state.escaped, changed = escaped, true
+	}
+	for reg, value := range other.regs {
+		merged := arm64ControlFrozenUnion(state.read(reg), value)
+		if !arm64ControlFrozenEqual(state.regs[reg], merged) {
+			state.regs[reg], changed = merged, true
+		}
+	}
+	for reg, value := range state.regs {
+		if other.regs[reg] == nil {
+			merged := arm64ControlFrozenUnion(value, map[string]bool{"": true})
+			if !arm64ControlFrozenEqual(value, merged) {
+				state.regs[reg], changed = merged, true
+			}
+		}
+	}
+	for key, value := range other.memory {
+		old := state.memory[key]
+		if old == nil {
+			old = map[string]bool{"": true}
+		}
+		merged := arm64ControlFrozenUnion(old, value)
+		if !arm64ControlFrozenEqual(state.memory[key], merged) {
+			state.memory[key], changed = merged, true
+		}
+	}
+	for key, value := range state.memory {
+		if other.memory[key] == nil {
+			merged := arm64ControlFrozenUnion(value, map[string]bool{"": true})
+			if !arm64ControlFrozenEqual(value, merged) {
+				state.memory[key], changed = merged, true
+			}
+		}
+	}
+	return changed
+}
+
+func BenchmarkARM64ControlRepeatedCellMerge(b *testing.B) {
+	for _, size := range []struct{ targets, cells int }{{128, 64}, {512, 128}, {1024, 256}} {
+		b.Run(fmt.Sprintf("targets_%d_cells_%d", size.targets, size.cells), func(b *testing.B) {
+			left, right := arm64ControlMergeRepeatedOperands(size.targets)
+			before, incoming := arm64ControlMergeRepeatedState(left, size.cells), arm64ControlMergeRepeatedState(right, size.cells)
+			b.ReportAllocs()
+			b.ResetTimer()
+			var result *arm64ControlState
+			for iteration := 0; iteration < b.N; iteration++ {
+				result = before.clone()
+				if !result.merge(incoming) {
+					b.Fatal("missing new original RET target")
+				}
+			}
+			b.StopTimer()
+			arm64ControlMergeCheckComplete(b, result, left, right, size.cells)
+		})
+	}
+}
+
+func BenchmarkARM64ControlRepeatedSubsetMerge(b *testing.B) {
+	for _, size := range []struct{ targets, cells int }{{512, 1}, {512, 128}, {1024, 1}, {1024, 256}} {
+		b.Run(fmt.Sprintf("targets_%d_cells_%d", size.targets, size.cells), func(b *testing.B) {
+			left, extra := arm64ControlMergeRepeatedOperands(size.targets)
+			// Keep equal common keys physically independent, so the complete
+			// successful subset traversal is not hidden by node identity.
+			rightEntries := arm64ControlFrozenUnion(arm64ControlMap(left), arm64ControlMap(extra))
+			right := arm64ControlFromMap(rightEntries)
+			before, incoming := arm64ControlMergeRepeatedState(left, size.cells), arm64ControlMergeRepeatedState(right, size.cells)
+			b.ReportAllocs()
+			b.ResetTimer()
+			var result *arm64ControlState
+			for iteration := 0; iteration < b.N; iteration++ {
+				result = before.clone()
+				if !result.merge(incoming) {
+					b.Fatal("lost larger complete original RET set")
+				}
+			}
+			b.StopTimer()
+			arm64ControlMergeCheckComplete(b, result, left, right, size.cells)
+		})
+	}
+}
diff --git a/arm64_control_scalar_multiply_runtime_test.go b/arm64_control_scalar_multiply_runtime_test.go
new file mode 100644
index 000000000..80195fd63
--- /dev/null
+++ b/arm64_control_scalar_multiply_runtime_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ControlScalarMultiply(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecls, goChecks, cDecls, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, form := range arm64ControlMultiplyForms() {
+		parts := strings.SplitN(form, " ", 2)
+		name := fmt.Sprintf("multiplyCaller%d", index)
+		result := "R30"
+		if len(strings.Split(parts[1], ",")) == 2 {
+			form, result = strings.Replace(form, "R30", "R7", 1), "R7"
+		}
+		body := "MOVD (R0),R4\nMOVD 8(R0),R5\nMOVD 16(R0),R6\nMOVD R5,R7\nCMP R5,R4\n" + form + "\n" +
+			"CSET VS,R8\nCSET CS,R9\nLSL $1,R9\nORR R9,R8\nCSET EQ,R9\nLSL $2,R9\nORR R9,R8\nCSET MI,R9\nLSL $3,R9\nORR R9,R8\n" +
+			"MOVD " + result + ",(R1)\nMOVD R8,8(R1)\n"
+		source.WriteString(strings.Replace(arm64RawZeroFrameFixture(516, false, body), "rawZero", name, 1))
+		sig := arm64RawZeroFrameSig()
+		sig.Name = name
+		sigs[name] = sig
+		fmt.Fprintf(&goDecls, "func %s(*byte,*byte)\n", name)
+		fmt.Fprintf(&cDecls, "extern void %s(const unsigned char*,unsigned char*);\n", name)
+		fmt.Fprintf(&goChecks, "check(%s,%q)\n", name, parts[0])
+		fmt.Fprintf(&cChecks, "if(check(%s,\"%s\"))return 1;\n", name, parts[0])
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const goOracle = `package main
+
+import (
+	"encoding/binary"
+	"math/bits"
+	"strings"
+)
+
+func expected(op string, a, b, c uint64) uint64 {
+	if strings.Contains(op, "ADD") || strings.Contains(op, "SUB") {
+		x, y := a, c
+		if strings.HasPrefix(op, "S") {
+			x = uint64(int64(int32(x)))
+			y = uint64(int64(int32(y)))
+		}
+		if strings.HasPrefix(op, "U") {
+			x = uint64(uint32(x))
+			y = uint64(uint32(y))
+		}
+		r := b + x*y
+		if strings.Contains(op, "SUB") {
+			r = b - x*y
+		}
+		if strings.HasSuffix(op, "W") {
+			r = uint64(uint32(r))
+		}
+		return r
+	}
+	if strings.HasSuffix(op, "H") {
+		hi, _ := bits.Mul64(a, b)
+		if op == "SMULH" {
+			if int64(a) < 0 {
+				hi -= b
+			}
+			if int64(b) < 0 {
+				hi -= a
+			}
+		}
+		return hi
+	}
+	x, y := a, b
+	if strings.HasPrefix(op, "S") {
+		x = uint64(int64(int32(x)))
+		y = uint64(int64(int32(y)))
+	}
+	if strings.HasPrefix(op, "U") {
+		x = uint64(uint32(x))
+		y = uint64(uint32(y))
+	}
+	r := x * y
+	if strings.Contains(op, "NEG") {
+		r = 0 - r
+	}
+	if strings.HasSuffix(op, "W") {
+		r = uint64(uint32(r))
+	}
+	return r
+}
+func check(call func(*byte, *byte), op string) {
+	var input, output, want [96]byte
+	seed := uint64(0x0123456789abcdef)
+	for trial := 0; trial < 128; trial++ {
+		for _, off := range []int{0, 1, 3, 7, 17} {
+			for i := range input {
+				seed = seed*6364136223846793005 + 1
+				input[i] = byte(seed >> 56)
+				output[i] = 0xa5
+				want[i] = 0xa5
+			}
+			a := binary.LittleEndian.Uint64(input[off:])
+			b := binary.LittleEndian.Uint64(input[off+8:])
+			c := binary.LittleEndian.Uint64(input[off+16:])
+			if trial < 64 {
+				a = uint64(1) << trial
+			}
+			if trial == 64 {
+				a = ^uint64(0)
+				b = 1
+			}
+			if trial == 65 {
+				a = 1 << 63
+				b = 1
+			}
+			if trial == 66 {
+				a = 0
+				b = 0
+			}
+			binary.LittleEndian.PutUint64(input[off:], a)
+			binary.LittleEndian.PutUint64(input[off+8:], b)
+			d := a - b
+			flags := uint64(0)
+			if ((a^b)&(a^d))>>63 != 0 {
+				flags |= 1
+			}
+			if a >= b {
+				flags |= 2
+			}
+			if d == 0 {
+				flags |= 4
+			}
+			if d>>63 != 0 {
+				flags |= 8
+			}
+			binary.LittleEndian.PutUint64(want[off:], expected(op, a, b, c))
+			binary.LittleEndian.PutUint64(want[off+8:], flags)
+			snapshot := input
+			call(&input[off], &output[off])
+			if input != snapshot || output != want {
+				panic("multiply math/NZCV/canary/caller mismatch: " + op)
+			}
+		}
+	}
+}
+`
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":         "module multiplycalleroracle\n\ngo 1.20\n",
+		"main.go":        goOracle + goDecls.String() + "func main(){\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source.String(), "TEXT multiplyCaller", "TEXT ·multiplyCaller"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("original Go scalar-multiply/LR caller oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const cOracle = `#include <stdint.h>
+#include <string.h>
+static uint64_t expected(const char *op, uint64_t a, uint64_t b, uint64_t c) {
+  if (strstr(op, "ADD") || strstr(op, "SUB")) {
+    uint64_t x = a, y = c;
+    if (op[0] == 'S') {
+      x = (uint64_t)(int64_t)(int32_t)x;
+      y = (uint64_t)(int64_t)(int32_t)y;
+    }
+    if (op[0] == 'U') {
+      x = (uint32_t)x;
+      y = (uint32_t)y;
+    }
+    uint64_t r = strstr(op, "SUB") ? b - x * y : b + x * y;
+    if (op[strlen(op) - 1] == 'W')
+      r = (uint32_t)r;
+    return r;
+  }
+  if (op[strlen(op) - 1] == 'H') {
+    unsigned __int128 p;
+    if (op[0] == 'S')
+      p = (unsigned __int128)((__int128)(int64_t)a * (__int128)(int64_t)b);
+    else
+      p = (unsigned __int128)a * b;
+    return (uint64_t)(p >> 64);
+  }
+  uint64_t x = a, y = b;
+  if (op[0] == 'S') {
+    x = (uint64_t)(int64_t)(int32_t)x;
+    y = (uint64_t)(int64_t)(int32_t)y;
+  }
+  if (op[0] == 'U') {
+    x = (uint32_t)x;
+    y = (uint32_t)y;
+  }
+  uint64_t r = x * y;
+  if (strstr(op, "NEG"))
+    r = 0 - r;
+  if (op[strlen(op) - 1] == 'W')
+    r = (uint32_t)r;
+  return r;
+}
+static int check(void (*call)(const unsigned char *, unsigned char *), const char *op) {
+  unsigned char input[96], output[96], want[96], snapshot[96];
+  const unsigned offsets[] = {0, 1, 3, 7, 17};
+  uint64_t seed = UINT64_C(0x0123456789abcdef);
+  for (unsigned trial = 0; trial < 128; trial++)
+    for (unsigned o = 0; o < 5; o++) {
+      unsigned off = offsets[o];
+      for (unsigned i = 0; i < 96; i++) {
+        seed = seed * UINT64_C(6364136223846793005) + 1;
+        input[i] = (unsigned char)(seed >> 56);
+        output[i] = 0xa5;
+        want[i] = 0xa5;
+      }
+      uint64_t a, b, c;
+      memcpy(&a, input + off, 8);
+      memcpy(&b, input + off + 8, 8);
+      memcpy(&c, input + off + 16, 8);
+      if (trial < 64)
+        a = UINT64_C(1) << trial;
+      if (trial == 64) {
+        a = UINT64_MAX;
+        b = 1;
+      }
+      if (trial == 65) {
+        a = UINT64_C(1) << 63;
+        b = 1;
+      }
+      if (trial == 66) {
+        a = 0;
+        b = 0;
+      }
+      memcpy(input + off, &a, 8);
+      memcpy(input + off + 8, &b, 8);
+      uint64_t d = a - b, flags = 0;
+      if (((a ^ b) & (a ^ d)) >> 63)
+        flags |= 1;
+      if (a >= b)
+        flags |= 2;
+      if (!d)
+        flags |= 4;
+      if (d >> 63)
+        flags |= 8;
+      uint64_t result = expected(op, a, b, c);
+      memcpy(want + off, &result, 8);
+      memcpy(want + off + 8, &flags, 8);
+      memcpy(snapshot, input, 96);
+      call(input + off, output + off);
+      if (memcmp(input, snapshot, 96) || memcmp(output, want, 96))
+        return 1;
+    }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "multiply_caller", triple, ir,
+		cOracle+cDecls.String()+"int main(void){\n"+cChecks.String()+"return 0;}\n", runner)
+	t.Log("original Go + LLVM22/independent Go and C: 28 forms x 128 patterns x 5 unaligned offsets, numerical low/high/signed/accumulate results, all NZCV sentinels, full canaries and restored LR/BP/SP")
+}
diff --git a/arm64_control_scalar_multiply_test.go b/arm64_control_scalar_multiply_test.go
new file mode 100644
index 000000000..595982064
--- /dev/null
+++ b/arm64_control_scalar_multiply_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func arm64ControlMultiplyForms() []string {
+	var forms []string
+	for _, op := range []string{"MUL", "MULW", "MNEG", "MNEGW", "SMULL", "UMULL", "SMNEGL", "UMNEGL", "SMULH", "UMULH"} {
+		forms = append(forms, op+" R4,R30", op+" R4,R5,R30")
+	}
+	for _, op := range []string{"MADD", "MSUB", "MADDW", "MSUBW", "SMADDL", "SMSUBL", "UMADDL", "UMSUBL"} {
+		forms = append(forms, op+" R4,R5,R6,R30")
+	}
+	return forms
+}
+
+func TestARM64ControlScalarMultiplyCompleteGoRows(t *testing.T) {
+	bytes, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(bytes)
+	for _, family := range []struct {
+		name string
+		rows int
+	}{
+		{name: "AMUL", rows: 2}, {name: "AMADD", rows: 1},
+	} {
+		// Go 1.20 predates optab's extra suffix-class column. Both layouts
+		// retain the same three input classes and one destination class.
+		rows := regexp.MustCompile(`\{`+family.name+`, C_ZREG, C_(?:ZREG|NONE), C_(?:ZREG|NONE), C_ZREG,(?: C_NONE,)? 15,`).FindAllString(source, -1)
+		if len(rows) != family.rows {
+			t.Fatalf("Go %s operand rows changed: %v", family.name, rows)
+		}
+		block := regexp.MustCompile(`case ` + family.name + `:\s*\n((?:\s*oprangeset\([^\n]+\n)+)`).FindStringSubmatch(source)
+		if len(block) != 2 {
+			t.Fatalf("Go %s alias registration not recognized", family.name)
+		}
+		names := []string{strings.TrimPrefix(family.name, "A")}
+		for _, alias := range regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block[1], -1) {
+			names = append(names, alias[1])
+		}
+		registered := make(map[string]bool)
+		for _, form := range arm64ControlMultiplyForms() {
+			parts := strings.SplitN(form, " ", 2)
+			four := len(strings.Split(parts[1], ",")) == 4
+			if four == (family.name == "AMADD") {
+				registered[parts[0]] = true
+			}
+		}
+		if len(registered) != len(names) {
+			t.Fatalf("Go %s names differ from complete fixture: %v vs %v", family.name, names, registered)
+		}
+		for _, name := range names {
+			if !registered[name] {
+				t.Fatalf("Go %s alias %s is unobserved", family.name, name)
+			}
+		}
+	}
+}
+
+func TestARM64ControlScalarMultiplyInputOutputDirection(t *testing.T) {
+	for _, text := range arm64ControlMultiplyForms() {
+		t.Run(text, func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT multiply(SB),$0-0\n"+text+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			requireARM64GoAssemblerResult(t, "TEXT multiply(SB),$0-0\n"+text+"\nRET\n", true)
+			state := &arm64ControlState{regs: map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})}, memory: make(map[string]arm64ControlValue)}
+			state.transfer(ins, ins.Op, false, nil)
+			value := arm64ControlRead(state.regs, "R30")
+			if len(ins.Args) == 2 {
+				if !arm64ControlHas(value, "code-derived:") {
+					t.Fatal("two-operand multiply lost its destination input")
+				}
+			} else if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+				t.Fatalf("write-only multiply destination read its stale LR: %v", value)
+			}
+			// Every explicit source, including an alias of Rd, remains tainted.
+			for index := 0; index < len(ins.Args)-1; index++ {
+				alias := ins
+				alias.Args = append([]Operand(nil), ins.Args...)
+				alias.Args[index].Reg = "R30"
+				state.regs["R30"] = arm64ControlFromMap(map[string]bool{"label:entry_lr": true})
+				state.transfer(alias, alias.Op, false, nil)
+				if !arm64ControlHas(arm64ControlRead(state.regs, "R30"), "code-derived:") {
+					t.Fatalf("source %d alias washed away transformed caller PC", index)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64ControlScalarMultiplyDerivedCodeAndInvalidFormsStayClosed(t *testing.T) {
+	for _, form := range arm64ControlMultiplyForms() {
+		if len(strings.Split(strings.SplitN(form, " ", 2)[1], ",")) == 2 {
+			continue
+		}
+		body := "MOVD R30,R4\n" + form + "\nMOVD R5,(R1)(R30)\n"
+		file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := arm64RawZeroFrameSig()
+		_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("computed caller PC gained a pure-code/disjointness permission: %s: %v", form, err)
+		}
+	}
+	for _, text := range []string{"MUL $1,R4,R30", "MULW R4,(R5),R30", "MUL.P R4,R5,R30", "MULS R4,R5,R30", "MADD R4,R5,R30", "MADD RSP,R4,R5,R30"} {
+		source := "TEXT bad(SB),$0-0\n" + text + "\nRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		ins := file.Funcs[0].Instrs[1]
+		if _, _, valid := arm64ScalarMultiplyInputs(arm64ControlOp(ins), ins); valid {
+			t.Fatalf("invalid Go multiply form supplied a write-direction proof: %s", text)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"bad": {Ret: Void}}}); err == nil {
+			t.Fatalf("invalid Go multiply accepted: %s", text)
+		}
+	}
+}
+
+func TestARM64ControlScalarMultiplyCallerContinuationObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, text := range arm64ControlMultiplyForms() {
+		if len(strings.Split(strings.SplitN(text, " ", 2)[1], ",")) == 2 {
+			continue // This form actually consumes old Rd, independently tested above.
+		}
+		name := fmt.Sprintf("multiplyCaller%d", index)
+		body := text + "\nMOVD R4,(R1)(R30)\n"
+		source.WriteString(strings.Replace(arm64RawZeroFrameFixture(516, false, body), "rawZero", name, 1))
+		sig := arm64RawZeroFrameSig()
+		sig.Name = name
+		sigs[name] = sig
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "multiply-caller.ll", "multiply-caller.o", ir)
+	}
+}
diff --git a/arm64_control_set_sharing_test.go b/arm64_control_set_sharing_test.go
new file mode 100644
index 000000000..fd16c6f61
--- /dev/null
+++ b/arm64_control_set_sharing_test.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This is the frozen, pre-sharing set operation, not a second source proof.
+// Tests compare complete token maps, including unknown and affine identities.
+func arm64ControlUnionReference(left, right arm64ControlValue) arm64ControlValue {
+	return arm64ControlFromMap(arm64ControlFrozenUnion(arm64ControlMap(left), arm64ControlMap(right)))
+}
+
+func arm64ControlSharingState(targets int) *arm64ControlState {
+	value := arm64ControlFromMap(make(map[string]bool, targets+1))
+	value = arm64ControlSetToken(value, "", true)
+	for index := 0; index < targets; index++ {
+		value = arm64ControlSetToken(value, fmt.Sprintf("label:continuation_%d", index), true)
+	}
+	state := &arm64ControlState{
+		regs:    make(map[Reg]arm64ControlValue),
+		memory:  make(map[string]arm64ControlValue),
+		escaped: value,
+	}
+	for index := 0; index < 31; index++ {
+		state.regs[Reg(fmt.Sprintf("R%d", index))] = value
+	}
+	state.regs[SP] = arm64ControlFromMap(map[string]bool{"sp:0": true})
+	state.memory["sp:0"] = value
+	return state
+}
+
+func TestARM64ControlStableMergeDoesNotCopyTargetSets(t *testing.T) {
+	state := arm64ControlSharingState(256)
+	other := state.clone()
+	before := state.clone()
+	allocations := testing.AllocsPerRun(10, func() {
+		if state.merge(other) {
+			t.Fatal("an equal predecessor changed the control proof")
+		}
+	})
+	if !reflect.DeepEqual(state, before) {
+		t.Fatal("stable merge changed complete state")
+	}
+	if allocations != 0 {
+		t.Fatalf("stable merge copied unchanged target sets: %.0f allocations per merge", allocations)
+	}
+}
+
+func TestARM64ControlSharedUnionMatchesCompleteReference(t *testing.T) {
+	tokens := []string{"", "label:caller", "label:local", "code-derived:", "sp:0", "fp:8"}
+	values := []arm64ControlValue{nil, {}}
+	for mask := 0; mask < 1<<len(tokens); mask++ {
+		value := arm64ControlFromMap(make(map[string]bool))
+		for index, token := range tokens {
+			if mask&(1<<index) != 0 {
+				value = arm64ControlSetToken(value, token, true)
+			}
+		}
+		values = append(values, value)
+	}
+	values = append(values, arm64ControlFromMap(map[string]bool{"label:local": false}), arm64ControlFromMap(map[string]bool{"sp:0": false, "fp:8": true}))
+	for leftIndex, left := range values {
+		for rightIndex, right := range values {
+			beforeLeft := arm64ControlCopyForTest(left)
+			beforeRight := arm64ControlCopyForTest(right)
+			got := arm64ControlUnion(left, right)
+			want := arm64ControlUnionReference(left, right)
+			if !reflect.DeepEqual(arm64ControlMap(got), arm64ControlMap(want)) {
+				t.Fatalf("complete union %d/%d differs: got %v, want %v", leftIndex, rightIndex, got, want)
+			}
+			if !reflect.DeepEqual(arm64ControlMap(left), arm64ControlMap(beforeLeft)) || !reflect.DeepEqual(arm64ControlMap(right), arm64ControlMap(beforeRight)) {
+				t.Fatalf("union %d/%d changed a predecessor", leftIndex, rightIndex)
+			}
+			derived := arm64ControlWithToken(got, "new-derived-witness")
+			if !arm64ControlHas(derived, "new-derived-witness") || arm64ControlHas(got, "new-derived-witness") ||
+				!reflect.DeepEqual(arm64ControlMap(left), arm64ControlMap(beforeLeft)) || !reflect.DeepEqual(arm64ControlMap(right), arm64ControlMap(beforeRight)) {
+				t.Fatalf("copy-on-write %d/%d modified a published witness", leftIndex, rightIndex)
+			}
+		}
+	}
+}
+
+func arm64ControlCopyForTest(value arm64ControlValue) arm64ControlValue {
+	return arm64ControlFromMap(arm64ControlMap(value))
+}
+
+func TestARM64ControlSharedValuesDoNotMutatePredecessors(t *testing.T) {
+	caller := arm64ControlFromMap(map[string]bool{"label:caller": true})
+	original := &arm64ControlState{
+		regs: map[Reg]arm64ControlValue{
+			SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R10": caller, "F0": caller,
+		},
+		memory: map[string]arm64ControlValue{"sp:0": caller},
+	}
+	for _, instruction := range []string{
+		"MOVW R10,R11", "MUL R10,R10,R11", "EOR R10,R10,R11",
+		"MOVW (RSP),R11", "VLD1 (RSP),[V0.B16]",
+		"VST1 [V0.B16],16(RSP)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT sharing(SB),4,$32-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			before := arm64ControlCopyForTest(caller)
+			state := original.clone()
+			ins := file.Funcs[0].Instrs[1]
+			state.transfer(ins, arm64ControlOp(ins), false, nil)
+			if !reflect.DeepEqual(arm64ControlMap(caller), arm64ControlMap(before)) || arm64ControlHas(original.regs["R10"], "code-derived:") || arm64ControlHas(original.regs["F0"], "code-derived:") || arm64ControlHas(original.memory["sp:0"], "code-derived:") {
+				t.Fatalf("instruction %q mutated an original reaching definition: %v", instruction, original)
+			}
+		})
+	}
+}
+
+func arm64ControlSharingCFG(calls int) (Func, error) {
+	var source strings.Builder
+	source.WriteString("TEXT controlFanout(SB),516,$0-0\nMOVD R30,R19\n")
+	for index := 0; index < calls; index++ {
+		fmt.Fprintf(&source, "call_%d:\nCALL helper\n", index)
+	}
+	source.WriteString("done:\nMOVD R19,R30\nRET\nhelper:\nRET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		return Func{}, err
+	}
+	return file.Funcs[0], nil
+}
+
+func arm64ControlSharingContext(fn Func) *arm64Ctx {
+	return &arm64Ctx{
+		blocks:           arm64SplitBlocks(fn),
+		normalizedSource: fn,
+		sig:              FuncSig{Name: "controlFanout", Ret: Void},
+		resolve:          func(name string) string { return name },
+	}
+}
+
+func TestARM64ControlSharingFirstPartyCFGCompleteTargets(t *testing.T) {
+	const calls = 32
+	fn, err := arm64ControlSharingCFG(calls)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := arm64ControlSharingContext(fn)
+	if err := ctx.prepareLocalControl(); err != nil {
+		t.Fatal(err)
+	}
+	helper := len(ctx.blocks) - 1
+	targets, err := ctx.localControlTargets(helper)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(targets) != calls {
+		t.Fatalf("helper lost a reaching continuation: got %d, want %d: %v", len(targets), calls, targets)
+	}
+	for index, reachable := range ctx.localControl.reachable {
+		if !reachable {
+			t.Fatalf("first-party block %d disappeared from the CFG", index)
+		}
+	}
+}
+
+func TestARM64ControlSharingOriginalGoAndLLVMObjects(t *testing.T) {
+	fn, err := arm64ControlSharingCFG(32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var source strings.Builder
+	for _, instruction := range fn.Instrs {
+		source.WriteString(instruction.Raw + "\n")
+	}
+	// These common scalar/control forms deliberately consume the actual
+	// selected SDK on both lanes, not a current-table-only early-return helper.
+	goAssemblerOracleOutput(t, "arm64", source.String(), "", true)
+	t.Logf("actual Go source-object witness %x", sha256.Sum256([]byte(source.String())))
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(&File{Arch: ArchARM64, Funcs: []Func{fn}}, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"controlFanout": {Name: "controlFanout", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "control-sharing.ll", "control-sharing.o", ir)
+		})
+	}
+}
+
+func TestARM64ControlSharingFrozenReferenceReceipts(t *testing.T) {
+	for _, calls := range []int{16, 32, 64} {
+		t.Run(fmt.Sprintf("calls_%d", calls), func(t *testing.T) {
+			fn, err := arm64ControlSharingCFG(calls)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := arm64ControlSharingContext(fn)
+			if err := ctx.prepareLocalControl(); err != nil {
+				t.Fatal(err)
+			}
+			// JSON does not support array-valued map keys. Preserve every
+			// block/instruction entry in deterministic original CFG order.
+			type point struct {
+				Block, Instruction  int
+				Before, Stack, Link arm64ControlValue
+			}
+			var points []point
+			for block, body := range ctx.blocks {
+				for instruction := range body.instrs {
+					key := [2]int{block, instruction}
+					points = append(points, point{block, instruction,
+						ctx.localControl.before[key], ctx.localControl.stackBefore[key], ctx.localControl.linkBefore[key]})
+				}
+			}
+			receipt := struct {
+				Original  Func
+				Reachable []bool
+				Outer     string
+				AutoFrame bool
+				Points    []point
+			}{fn, ctx.localControl.reachable, ctx.localControl.outer, ctx.localControl.autoFrame, points}
+			encoded, err := json.Marshal(receipt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("complete-control-receipt %s", encoded)
+			ir, err := Translate(&File{Arch: ArchARM64, Funcs: []Func{fn}}, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"controlFanout": {Name: "controlFanout", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("complete-ir-receipt %x", sha256.Sum256([]byte(ir)))
+		})
+	}
+}
+
+func BenchmarkARM64ControlStableMerge(b *testing.B) {
+	for _, targets := range []int{64, 256, 1024} {
+		b.Run(fmt.Sprintf("targets_%d", targets), func(b *testing.B) {
+			state := arm64ControlSharingState(targets)
+			other := state.clone()
+			b.ReportAllocs()
+			b.ResetTimer()
+			for index := 0; index < b.N; index++ {
+				if state.merge(other) {
+					b.Fatal("stable predecessor changed state")
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkARM64ControlFirstPartyCFG(b *testing.B) {
+	for _, calls := range []int{16, 32, 64} {
+		b.Run(fmt.Sprintf("calls_%d", calls), func(b *testing.B) {
+			fn, err := arm64ControlSharingCFG(calls)
+			if err != nil {
+				b.Fatal(err)
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for index := 0; index < b.N; index++ {
+				if err := arm64ControlSharingContext(fn).prepareLocalControl(); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_ctx.go b/arm64_ctx.go
index e3b644628..618c8bcf8 100644
--- a/arm64_ctx.go
+++ b/arm64_ctx.go
@@ -8,27 +8,63 @@ import (
 )
 
 type arm64Ctx struct {
-	b        *strings.Builder
-	sig      FuncSig
-	resolve  func(string) string
-	sigs     map[string]FuncSig
-	annotate bool
+	b               *strings.Builder
+	sig             FuncSig
+	resolve         func(string) string
+	sigs            map[string]FuncSig
+	annotate        bool
+	targetTriple    string
+	goRegisterEntry bool
+
+	privateRegisterEntry    bool
+	unexposedCallFrame      bool // source/normalized proof for this fresh SP object only
+	privateDataStores       map[[2]int]arm64PrivateDataSpan
+	nanosleepInput          *arm64NanosleepInputProof
+	nanosleepOriginal       *arm64NanosleepInputProof
+	nanosleepOriginalSource Func
+	nanosleepRequired       bool
 
 	tmp int
 
-	blocks []arm64Block
+	blocks              []arm64Block
+	normalizedSource    Func // exact source consumed by the bounded raw-context proof
+	localControl        *arm64LocalControlPlan
+	currentInstruction  int
+	currentBlock        int
+	machineAvailability *arm64MachineAvailability
+
+	rawDataGlobals  map[string]string              // local source label -> LLVM global
+	rawDataOffsets  map[string]int64               // byte offsets for aliases into one pool
+	sourceData      []DataStmt                     // complete file DATA provenance, before function normalization
+	sourceNoopCalls map[string]arm64SourceNoopCall // complete same-file source, never a public call option
 
 	usedRegs map[Reg]bool
 	regSlot  map[Reg]string // reg -> alloca name
 
-	usedVRegs map[int]bool
-	vRegSlot  map[int]string // vreg index -> alloca name (<16 x i8>)
+	usedVRegs       map[int]bool
+	vRegSlot        map[int]string // vreg index -> alloca name (<16 x i8>)
+	usedZRegs       map[int]bool
+	zRegSlot        map[int]string // SVE zreg index -> alloca name (<vscale x 16 x i8>)
+	usedPRegs       map[int]bool
+	pRegSlot        map[int]string // SVE preg index -> alloca name (<vscale x 16 x i1>)
+	usedPNRegs      map[int]bool
+	pnRegSlot       map[int]string // SVE predicate-as-counter index -> alloca name (target("aarch64.svcount"))
+	localStackSlot  string
+	localStackSize  int64
+	frameSize       int64 // TEXT local storage, including accesses through SP aliases
+	sourceGoFrame   arm64GoFrame
+	sourceFrameR20  bool // original + normalized typed Go large-frame producer
+	checkedR20Entry bool // all typed GP/FP reads need a genuine entry/CFG definition
+	checkedABI0Tail bool // declaration-backed result slots; no implicit GP argument bank
+	dynamicStack    *arm64DynamicStackPlan
 
 	flagsNSlot   string
 	flagsZSlot   string
 	flagsCSlot   string
 	flagsVSlot   string
 	flagsWritten bool
+	flagsKnown   arm64FlagMask
+	flagFlow     *arm64FlagFlow
 
 	exclusiveValidSlot string
 	exclusivePtrSlot   string
@@ -36,35 +72,69 @@ type arm64Ctx struct {
 	exclusiveValueSlot string
 
 	fpParams       map[int64]FrameSlot // off(FP) -> slot
+	fpParamAlloca  map[int64]string    // parameter off(FP) -> mutable alloca
 	fpResults      []FrameSlot         // result slots (Index is result index)
 	fpResAllocaOff map[int64]string    // off(FP) -> alloca
 	fpResAllocaIdx map[int]string      // result index -> alloca
 	fpResWritten   map[int]bool        // result index -> direct writes to fp slot
 	fpResAddrTaken map[int]bool        // result index -> fp result slot address escaped
+	fpPaddingReads map[[2]int]arm64FPPaddingRead
 }
 
 func newARM64Ctx(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, annotate bool) *arm64Ctx {
+	return newARM64CtxWithTarget(b, fn, sig, resolve, sigs, "", annotate)
+}
+
+func newARM64CtxWithTarget(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, target string, annotate bool) *arm64Ctx {
 	c := &arm64Ctx{
-		b:              b,
-		sig:            sig,
-		resolve:        resolve,
-		sigs:           sigs,
-		annotate:       annotate,
-		blocks:         arm64SplitBlocks(fn),
-		usedRegs:       map[Reg]bool{},
-		regSlot:        map[Reg]string{},
-		usedVRegs:      map[int]bool{},
-		vRegSlot:       map[int]string{},
-		fpParams:       map[int64]FrameSlot{},
-		fpResAllocaOff: map[int64]string{},
-		fpResAllocaIdx: map[int]string{},
-		fpResWritten:   map[int]bool{},
-		fpResAddrTaken: map[int]bool{},
+		b:                b,
+		sig:              sig,
+		resolve:          resolve,
+		sigs:             sigs,
+		annotate:         annotate,
+		targetTriple:     target,
+		frameSize:        fn.FrameSize,
+		sourceGoFrame:    arm64SourceGoFrame(fn),
+		blocks:           arm64SplitBlocks(fn),
+		normalizedSource: fn,
+		usedRegs:         map[Reg]bool{},
+		regSlot:          map[Reg]string{},
+		usedVRegs:        map[int]bool{},
+		vRegSlot:         map[int]string{},
+		usedZRegs:        map[int]bool{},
+		zRegSlot:         map[int]string{},
+		usedPRegs:        map[int]bool{},
+		pRegSlot:         map[int]string{},
+		usedPNRegs:       map[int]bool{},
+		pnRegSlot:        map[int]string{},
+		fpParams:         map[int64]FrameSlot{},
+		fpParamAlloca:    map[int64]string{},
+		fpResAllocaOff:   map[int64]string{},
+		fpResAllocaIdx:   map[int]string{},
+		fpResWritten:     map[int]bool{},
+		fpResAddrTaken:   map[int]bool{},
+	}
+	c.privateRegisterEntry = fn.arm64PrivateRegisterEntry
+	c.checkedABI0Tail = fn.arm64ABI0TailSource != nil
+	transport := &arm64PrivateFrameTransport{entry: sig, resolve: resolve, sigs: sigs}
+	c.nanosleepInput, c.nanosleepRequired = arm64NanosleepInputForSource(fn, transport, target)
+	if c.nanosleepInput != nil {
+		c.nanosleepInput.owner = c
+		c.nanosleepOriginal, c.nanosleepOriginalSource = c.nanosleepInput, arm64NanosleepCloneSource(fn)
+	}
+	transport.nanosleep = c.nanosleepInput
+	c.unexposedCallFrame = !(c.nanosleepRequired && c.nanosleepInput == nil) &&
+		arm64CallFrameFreshEntry(sig) && sig.ARM64ClosureABI == nil &&
+		(sig.ARM64GoRegisterABI == nil || arm64ValidateGoRegisterABI(sig) == nil) &&
+		arm64CallFrameUnexposedForTransport(fn, transport)
+	if c.unexposedCallFrame {
+		c.privateDataStores, _ = arm64PrivateDataProof(fn, transport)
 	}
 	for _, s := range sig.Frame.Params {
 		c.fpParams[s.Offset] = s
 	}
 	c.fpResults = append([]FrameSlot(nil), sig.Frame.Results...)
+	c.goRegisterEntry = strings.HasSuffix(fn.Sym, "<ABIInternal>") && sig.ARM64GoRegisterABI != nil
 	return c
 }
 
@@ -81,8 +151,9 @@ func (c *arm64Ctx) newTmp() string {
 }
 
 func (c *arm64Ctx) slotName(r Reg) string {
-	// Make the name LLVM-label friendly to keep the IR readable.
-	return "%" + arm64LLVMBlockName("reg_"+string(r))
+	// Storage and source blocks share LLVM's local identifier namespace,
+	// but must have distinct generated roles even for a label named reg_R0.
+	return "%reg_" + amd64LLVMSafeName(string(r))
 }
 
 func (c *arm64Ctx) vSlotName(idx int) string {
@@ -95,8 +166,8 @@ func arm64ParseVReg(r Reg) (idx int, ok bool) {
 		return 0, false
 	}
 	// Strip optional lane suffix: V8.D[0], V5.B16, etc.
-	if dot := strings.IndexByte(s, '.'); dot >= 0 {
-		s = s[:dot]
+	if suffix := strings.IndexAny(s, ".["); suffix >= 0 {
+		s = s[:suffix]
 	}
 	n, err := strconv.Atoi(strings.TrimPrefix(s, "V"))
 	if err != nil || n < 0 || n > 31 {
@@ -117,11 +188,62 @@ func arm64ParseFReg(r Reg) (idx int, ok bool) {
 	return n, true
 }
 
+func arm64ParseZReg(r Reg) (idx int, ok bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "Z") {
+		return 0, false
+	}
+	if suffix := strings.IndexAny(s, ".["); suffix >= 0 {
+		s = s[:suffix]
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "Z"))
+	return n, err == nil && n >= 0 && n <= 31
+}
+
+func arm64ParsePReg(r Reg) (idx int, ok bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "P") {
+		return 0, false
+	}
+	if dot := strings.IndexByte(s, '.'); dot >= 0 {
+		s = s[:dot]
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "P"))
+	return n, err == nil && n >= 0 && n <= 15
+}
+
+func arm64ParsePNReg(r Reg) (idx int, ok bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "PN") {
+		return 0, false
+	}
+	if suffix := strings.IndexAny(s, ".["); suffix >= 0 {
+		s = s[:suffix]
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "PN"))
+	return n, err == nil && n >= 0 && n <= 15
+}
+
 func (c *arm64Ctx) scanUsedRegs() {
 	markReg := func(r Reg) {
 		if r == "" {
 			return
 		}
+		if r == Reg("RSP") {
+			r = SP
+		}
+		if idx, ok := arm64ParseZReg(r); ok {
+			c.usedZRegs[idx] = true
+			return
+		}
+		if idx, ok := arm64ParsePNReg(r); ok {
+			c.usedPNRegs[idx] = true
+			return
+		}
+		if idx, ok := arm64ParsePReg(r); ok {
+			c.usedPRegs[idx] = true
+			return
+		}
 		if idx, ok := arm64ParseVReg(r); ok {
 			c.usedVRegs[idx] = true
 			return
@@ -150,37 +272,885 @@ func (c *arm64Ctx) scanUsedRegs() {
 			}
 		}
 	}
+	markSVEAddForm := func(form arm64RawSVEAdd) {
+		markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+		if form.mode != arm64SVEAddImmediate {
+			markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+		}
+		if form.mode == arm64SVEAddPredicated {
+			markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+		}
+		markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+	}
 
 	for _, blk := range c.blocks {
 		for _, ins := range blk.instrs {
+			if form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins); handled && err == nil && form.scratch {
+				markReg("R27")
+			}
 			for _, op := range ins.Args {
 				markOp(op)
 			}
+			if ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+				if form, ok := decodeARM64RawSystemRegister(uint32(ins.Args[0].Imm)); ok && form.reg != 31 {
+					markReg(Reg(fmt.Sprintf("R%d", form.reg)))
+				}
+				if form, ok := decodeARM64RawCASP(uint32(ins.Args[0].Imm)); ok {
+					for _, reg := range arm64RawCASPRegisterPair(form.expected) {
+						markReg(reg)
+					}
+					for _, reg := range arm64RawCASPRegisterPair(form.newValue) {
+						markReg(reg)
+					}
+					if form.base == 31 {
+						markReg(Reg("RSP"))
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+				}
+				// Specialized raw decoders below predate the shared Go-table
+				// fallback. Also scan the official decoded operands so any
+				// instruction handled by that fallback receives register storage.
+				if decoded, err := decodeARM64RawWordInstruction(ins); err == nil {
+					for _, op := range decoded.Args {
+						markOp(op)
+					}
+				}
+				word := uint32(ins.Args[0].Imm)
+				if decoded, ok := decodeARM64RawSVECharacterMatch(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPredicateBreak(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPredicateIncDec(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPredicateCount(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatMinMax(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatUnary(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatCompare(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerCompare(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPredicateLogical(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPredicatePermute(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVECompact(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVECopy(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerUnary(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVERevd(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEStructuredMemory(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEMultiplyAccumulate(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVETernaryBitwise(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerReduction(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerDot(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEXAR(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEExtraShift(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVESplice(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEReplicateScalar(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEReplicateBlock(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEContiguousMemory(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEUnsignedLoad(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVESignedLoad(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEAddSubWide(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEMultiplyHigh(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEAddressGeneration(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatDivideScale(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatReciprocalStep(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEUnpack(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEAddPairwiseLong(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerMinMax(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerMinMaxReduction(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEPTest(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEMOVPRFX(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIndex(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVELast(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if form, ok := decodeARM64RawTLBI(word); ok && form.register != ZR {
+					markReg(form.register)
+				}
+				if reg, ok := decodeARM64RawICIVAU(word); ok {
+					if reg != ZR {
+						markReg(reg)
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEWhile(word); ok {
+					for _, operand := range decoded.Args {
+						markOp(operand)
+					}
+				}
+				if form, ok := decodeARM64RawSVELD1B(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.vector)))
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.index != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.index)))
+					}
+				}
+				if form, ok := decodeARM64RawStructureLane(word); ok {
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.post && form.postRegister != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.postRegister)))
+					}
+					for i := 0; i < form.count; i++ {
+						markReg(Reg(fmt.Sprintf("V%d", (form.firstRegister+i)%32)))
+					}
+				}
+				if form, ok := decodeARM64RawAES(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSM4(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSM3(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					if form.spec.fourRegisters {
+						markReg(Reg(fmt.Sprintf("V%d", form.third)))
+					}
+				}
+				if form, ok := decodeARM64RawRDMA(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarADDP(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawDotProduct(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.left)))
+					markReg(Reg(fmt.Sprintf("V%d", form.right)))
+				}
+				if form, ok := decodeARM64RawBFloatDot(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.left)))
+					markReg(Reg(fmt.Sprintf("V%d", form.right)))
+				}
+				if form, ok := decodeARM64RawBFloatMatrix(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.left)))
+					markReg(Reg(fmt.Sprintf("V%d", form.right)))
+				}
+				if form, ok := decodeARM64RawMatrixMultiply(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.left)))
+					markReg(Reg(fmt.Sprintf("V%d", form.right)))
+				}
+				if form, ok := decodeARM64RawFloatMultiplyLong(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawVectorFloatNarrow(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawVectorFloatWiden(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFADDP(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					if !form.scalar {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatPairwiseMinMax(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					if !form.scalar {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawTableLookup(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.index)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					for i := 0; i < form.tableCount; i++ {
+						markReg(Reg(fmt.Sprintf("V%d", (form.firstTable+i)%32)))
+					}
+				}
+				if form, ok := decodeARM64RawSQDMULH(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawMUL(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawHalvingAddSub(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawIntegerCompare(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					if !form.zero {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+				}
+				if form, ok := decodeARM64RawMLS(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawPairwiseAddLong(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.sourceReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destReg)))
+				}
+				if form, ok := decodeARM64RawUMULL(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawAddHighNarrow(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawUZP(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawSSHR(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawUSHLL(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawLDnR(word); ok {
+					for i := 0; i < form.count; i++ {
+						markReg(Reg(fmt.Sprintf("V%d", (form.firstRegister+i)%32)))
+					}
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.post && form.postRegister != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.postRegister)))
+					}
+				}
+				if form, ok := decodeARM64RawUMLAL(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawDUPElement(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawMLA(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawCVTF(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSMEOuterProduct(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					markReg(Reg(fmt.Sprintf("P%d", form.firstPred)))
+					markReg(Reg(fmt.Sprintf("P%d", form.secondPred)))
+				}
+				if form, ok := decodeARM64RawSMETileRead(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("R%d", form.row)))
+				}
+				if form, ok := decodeARM64RawSMETileWrite(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("R%d", form.row)))
+				}
+				if form, ok := decodeARM64RawSMETileMemory(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("R%d", form.row)))
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.offset != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.offset)))
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatImmediate(word); ok {
+					if destination, _, ok := arm64SVEFloatElementReg(decoded.Args[len(decoded.Args)-1]); ok {
+						markReg(Reg(fmt.Sprintf("Z%d", destination)))
+					}
+					if decoded.Op == "ZFCPY" {
+						predicate, _ := arm64ParseSVEPredicateMode(decoded.Args[1], "M", 15)
+						markReg(Reg(fmt.Sprintf("P%d", predicate)))
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEDupM(word); ok {
+					if destination, _, ok := arm64ParseSVEZElementReg(decoded.Args[1]); ok {
+						markReg(Reg(fmt.Sprintf("Z%d", destination)))
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatMultiplyAccumulate(word); ok {
+					for _, operand := range decoded.Args {
+						if reg, _, ok := arm64ParseSVEZElementReg(operand); ok {
+							markReg(Reg(fmt.Sprintf("Z%d", reg)))
+						}
+						if reg, ok := arm64ParseSVEPredicateMode(operand, "M", 7); ok {
+							markReg(Reg(fmt.Sprintf("P%d", reg)))
+						}
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEConvert(word); ok {
+					if source, _, ok := arm64ParseSVEZElementReg(decoded.Args[0]); ok {
+						markReg(Reg(fmt.Sprintf("Z%d", source)))
+					}
+					if predicate, ok := arm64ParseSVEPredicateMode(decoded.Args[1], "M", 7); ok {
+						markReg(Reg(fmt.Sprintf("P%d", predicate)))
+					} else if predicate, ok := arm64ParseSVEPredicateMode(decoded.Args[1], "Z", 7); ok {
+						markReg(Reg(fmt.Sprintf("P%d", predicate)))
+					}
+					if destination, _, ok := arm64ParseSVEZElementReg(decoded.Args[2]); ok {
+						markReg(Reg(fmt.Sprintf("Z%d", destination)))
+					}
+				}
+				if form, ok := decodeARM64RawFMLA(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.elementReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.sourceReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawHalfFMA(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.addend)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFMULByElement(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.elementReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.sourceReg)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarHalfUnary(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarVectorFCVTZ(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarFloatBinary(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarFloatCompare(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					if !form.zero {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+				}
+				if form, ok := decodeARM64RawScalarFloatSelect(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawConditionalCompare(word); ok {
+					markReg(form.left)
+					markReg(form.right)
+				}
+				if form, ok := decodeARM64RawScalarFloatImmediate(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarIntToFloat(word); ok {
+					if form.simdInteger {
+						markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					} else if form.source != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.source)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFixedIntToFloat(word); ok {
+					if form.vectorSource {
+						markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					} else if form.source != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.source)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatGPMove(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.floatReg)))
+					if form.gpReg != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.gpReg)))
+					}
+				}
+				if form, ok := decodeARM64RawBFloatConvert(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSHA3(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					if form.kind == arm64RawSHA3EOR3 || form.kind == arm64RawSHA3BCAX {
+						markReg(Reg(fmt.Sprintf("V%d", form.third)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatBinary(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+				}
+				if form, ok := decodeARM64RawReciprocalEstimate(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					if form.binary {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFSQRT(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatAbsNeg(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatMinMaxAcross(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatCompare(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					if !form.zero {
+						markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					}
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawLogical(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.first)))
+					markReg(Reg(fmt.Sprintf("V%d", form.second)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawFloatImmediate(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawModifiedImmediate(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawScalarFCVTToInt(word); ok {
+					markReg(Reg(fmt.Sprintf("F%d", form.source)))
+					if form.destination != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.destination)))
+					}
+				}
+				if form, ok := decodeARM64RawFCVTZ(word); ok {
+					markReg(Reg(fmt.Sprintf("V%d", form.source)))
+					markReg(Reg(fmt.Sprintf("V%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawMoveWide(word); ok && form.destination != 31 {
+					markReg(Reg(fmt.Sprintf("R%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEAddress(word); ok {
+					if form.op != "RDVL" {
+						if form.source == 31 {
+							markReg(SP)
+						} else {
+							markReg(Reg(fmt.Sprintf("R%d", form.source)))
+						}
+					}
+					if form.destination == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.destination)))
+					}
+				}
+				if form, ok := decodeARM64RawSVECnt(word); ok {
+					if form.vector {
+						markReg(Reg(fmt.Sprintf("Z%d.%c", form.destination, map[int]byte{16: 'H', 32: 'S', 64: 'D'}[form.elementBits])))
+					} else if form.destination != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.destination)))
+					}
+				}
+				if form, ok := decodeARM64RawBitfield(word); ok {
+					if form.source != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.source)))
+					}
+					if form.destination != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.destination)))
+					}
+				}
+				if form, ok := decodeARM64RawSVEPTrue(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVELDST1D(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.vector)))
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.registerOffset && form.index != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.index)))
+					}
+				}
+				if form, ok := decodeARM64RawSVELDST1W(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.vector)))
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+					if form.registerOffset && form.index != 31 {
+						markReg(Reg(fmt.Sprintf("R%d", form.index)))
+					}
+				}
+				if reduction, ok := decodeARM64RawSVEFloatMinMaxReduction(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", reduction.form.first)))
+					markReg(Reg(fmt.Sprintf("P%d", reduction.form.predicate)))
+					markReg(reduction.destination)
+				}
+				if reduction, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", reduction.form.source)))
+					markReg(Reg(fmt.Sprintf("P%d", reduction.form.predicate)))
+					markReg(reduction.destination)
+				}
+				if form, ok := decodeARM64RawSVEFloat(word); ok {
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					switch form.kind {
+					case arm64RawSVEFloatFADDV, arm64RawSVEFloatFADDA:
+						markReg(Reg(fmt.Sprintf("F%d", form.destination)))
+						markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					default:
+						markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+						markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+						if form.second != form.first {
+							markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+						}
+					}
+				}
+				if form, ok := decodeARM64RawSVELoadStore(word); ok {
+					if form.predicate {
+						markReg(Reg(fmt.Sprintf("P%d", form.vector)))
+					} else {
+						markReg(Reg(fmt.Sprintf("Z%d", form.vector)))
+					}
+					if form.base == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.base)))
+					}
+				}
+				if form, ok := decodeARM64RawSVEDupImmediate(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEDupGeneral(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+					if form.source == 31 {
+						markReg(SP)
+					} else {
+						markReg(Reg(fmt.Sprintf("R%d", form.source)))
+					}
+				}
+				if form, ok := decodeARM64RawSVEDupElement(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.source)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEAdd(word); ok {
+					markSVEAddForm(form)
+				}
+				if _, form, ok := decodeARM64RawSVEAddSub(word); ok {
+					markSVEAddForm(form)
+				}
+				if form, ok := decodeARM64RawSVEShift(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.source)))
+					if form.mode == arm64SVELSRWidePredicated || form.mode == arm64SVELSRWideUnpredicated || form.mode == arm64SVELSRVectorPredicated {
+						markReg(Reg(fmt.Sprintf("Z%d", form.shifts)))
+					}
+					if form.mode == arm64SVELSRWidePredicated || form.mode == arm64SVELSRVectorPredicated || form.mode == arm64SVELSRImmediatePredicated {
+						markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVESelect(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.falseValue)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.trueValue)))
+					markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEMultiply(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					switch form.mode {
+					case arm64SVEMultiplyPredicated:
+						markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+						markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					case arm64SVEMultiplyUnpredicated:
+						markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					case arm64SVEMultiplyLane:
+						markReg(Reg(fmt.Sprintf("Z%d", form.laneVector)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEEOR(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					if form.mode != arm64SVEEORImmediate {
+						markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					}
+					if form.mode == arm64SVEEORPredicated {
+						markReg(Reg(fmt.Sprintf("P%d", form.predicate)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVETable(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.index)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.firstTable)))
+					if form.tableCount == 2 {
+						markReg(Reg(fmt.Sprintf("Z%d", (form.firstTable+1)%32)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEUMULLB(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					if form.mode == arm64SVEUMULLBVector {
+						markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					} else {
+						markReg(Reg(fmt.Sprintf("Z%d", form.laneVector)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEMultiplyAccumulateLong(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					if form.mode == arm64SVEUMULLBVector {
+						markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					} else {
+						markReg(Reg(fmt.Sprintf("Z%d", form.laneVector)))
+					}
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+				if form, ok := decodeARM64RawSVEPermute(word); ok {
+					markReg(Reg(fmt.Sprintf("Z%d", form.first)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.second)))
+					markReg(Reg(fmt.Sprintf("Z%d", form.destination)))
+				}
+			}
 		}
 	}
 	// Ensure arg regs exist.
+	if c.sig.ARM64ClosureABI != nil {
+		markReg(c.sig.ARM64ClosureABI.ContextRegister)
+	}
+	if c.sig.ARM64GoRegisterABI != nil {
+		for _, slot := range append(append([]ARM64GoRegisterValue(nil), c.sig.ARM64GoRegisterABI.Params...), c.sig.ARM64GoRegisterABI.Results...) {
+			markReg(slot.Register)
+		}
+	}
 	if len(c.sig.ArgRegs) > 0 {
 		for i := 0; i < len(c.sig.Args) && i < len(c.sig.ArgRegs); i++ {
 			markReg(c.sig.ArgRegs[i])
 		}
 	} else {
-		// Go internal ABI on arm64 uses up to 16 integer argument registers.
-		// For aggregate args like {ptr,len,cap} we need registers for each word,
-		// since ABIInternal asm expects those words in consecutive registers.
-		n := 0
-		for _, ty := range c.sig.Args {
-			if fields, ok := parseLiteralStructFields(ty); ok && literalFieldsAllScalar(fields) {
-				n += len(fields)
-			} else {
-				n++
+		cursor := arm64ABIRegisterCursor{}
+		for _, typ := range c.sig.Args {
+			if fields, aggregate := parseLiteralStructFields(typ); aggregate {
+				for _, fieldType := range fields {
+					reg, err := cursor.next(fieldType)
+					if err != nil {
+						break
+					}
+					markReg(reg)
+				}
+				continue
+			}
+			if reg, err := cursor.next(typ); err == nil {
+				markReg(reg)
 			}
 		}
-		for i := 0; i < n && i < 16; i++ {
-			markReg(Reg(fmt.Sprintf("R%d", i)))
+	}
+	// Ensure register-return storage exists for all scalar result classes.
+	if len(c.fpResults) == 0 && c.sig.Ret != Void {
+		cursor := arm64ABIRegisterCursor{}
+		if fields, aggregate := parseLiteralStructFields(c.sig.Ret); aggregate {
+			for _, fieldType := range fields {
+				if reg, err := cursor.next(fieldType); err == nil {
+					markReg(reg)
+				}
+			}
+		} else if reg, err := cursor.next(c.sig.Ret); err == nil {
+			markReg(reg)
 		}
 	}
-	// Ensure return reg exists.
-	markReg(Reg("R0"))
 	// Keep lowering permissive for hand-written stubs that reference ad-hoc
 	// registers via macros/aliases not captured in signatures.
 	for i := 0; i <= 31; i++ {
@@ -197,7 +1167,10 @@ func (c *arm64Ctx) emitEntryAllocasAndArgInit() error {
 	}
 	sort.Strings(regs)
 
-	c.b.WriteString(arm64LLVMBlockName("entry") + ":\n")
+	// Keep allocas in LLVM's entry block and lower the source-level entry as a
+	// separate block. LLVM forbids blockaddress constants that name the actual
+	// entry block, while ARM64 ADR may legally address the first source block.
+	c.b.WriteString("entry:\n")
 	for _, rs := range regs {
 		r := Reg(rs)
 		name := c.slotName(r)
@@ -205,6 +1178,62 @@ func (c *arm64Ctx) emitEntryAllocasAndArgInit() error {
 		fmt.Fprintf(c.b, "  %s = alloca i64\n", name)
 		fmt.Fprintf(c.b, "  store i64 0, ptr %s\n", name)
 	}
+	if c.localControl != nil {
+		if err := c.storeCallerLink(); err != nil {
+			return err
+		}
+	}
+	if spSlot := c.regSlot[SP]; spSlot != "" {
+		minOff, maxOff, err := c.stackOffsetRange()
+		if err != nil {
+			return err
+		}
+		minimum, maximum, err := c.stackMovementRange()
+		if err != nil {
+			return err
+		}
+		minOff += minimum
+		maxOff += maximum
+		// Bound inferred SP movement separately from the explicit TEXT frame.
+		// Go's reflect-call wrappers declare frames up to 1 GiB; the 1 MiB
+		// movement-proof budget must not reject their declared storage.
+		upperBound := arm64MaxLocalStackSpan
+		if c.frameSize > upperBound {
+			upperBound = c.frameSize + arm64MaxLocalStackSpan
+		}
+		if minOff < -arm64MaxLocalStackSpan || maxOff > upperBound {
+			return fmt.Errorf("ARM64 local stack footprint exceeds %d bytes", arm64MaxLocalStackSpan)
+		}
+		const guard = int64(64)
+		bias := guard - minOff
+		size := bias + maxOff + guard
+		if size < 256 {
+			size = 256
+		}
+		c.localStackSlot = "%local_stack"
+		c.localStackSize = size
+		c.emitLocalStackAllocation(size)
+		base := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds [%d x i8], ptr %s, i32 0, i64 %d\n", base, size, c.localStackSlot, bias)
+		addr := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", addr, base)
+		fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", addr, spSlot)
+		if c.sourceFrameR20 {
+			// The physical Go prologue leaves R20 equal to the new body SP.
+			// Only the complete typed, non-escaping source proof enables it.
+			fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", addr, c.regSlot[Reg("R20")])
+		}
+		if c.sourceGoFrame.present {
+			// Go saves the incoming LR at the bottom of every implicit frame,
+			// including a framed leaf. Explicit source loads/stores can observe
+			// this cell; it is not a fabricated source-level local-call link.
+			link, err := c.loadReg(Reg("R30"))
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  store i64 %s, ptr %%%s\n", link, base)
+		}
+	}
 
 	// Vector registers: keep as <16 x i8> to cover most stdlib NEON byte ops.
 	vIdx := make([]int, 0, len(c.usedVRegs))
@@ -213,12 +1242,53 @@ func (c *arm64Ctx) emitEntryAllocasAndArgInit() error {
 	}
 	sort.Ints(vIdx)
 	for _, i := range vIdx {
+		if c.usedZRegs[i] {
+			// Vn/Fn are the low 128/64 bits of Zn, not separate registers.
+			// One scalable slot makes SVE writes visible to NEON/scalar reads.
+			c.vRegSlot[i] = fmt.Sprintf("%%z%d", i)
+			continue
+		}
 		name := c.vSlotName(i)
 		c.vRegSlot[i] = name
 		fmt.Fprintf(c.b, "  %s = alloca <16 x i8>\n", name)
 		fmt.Fprintf(c.b, "  store <16 x i8> zeroinitializer, ptr %s\n", name)
 	}
 
+	zIdx := make([]int, 0, len(c.usedZRegs))
+	for i := range c.usedZRegs {
+		zIdx = append(zIdx, i)
+	}
+	sort.Ints(zIdx)
+	for _, i := range zIdx {
+		name := fmt.Sprintf("%%z%d", i)
+		c.zRegSlot[i] = name
+		fmt.Fprintf(c.b, "  %s = alloca <vscale x 16 x i8>\n", name)
+		fmt.Fprintf(c.b, "  store <vscale x 16 x i8> zeroinitializer, ptr %s\n", name)
+	}
+
+	pIdx := make([]int, 0, len(c.usedPRegs))
+	for i := range c.usedPRegs {
+		pIdx = append(pIdx, i)
+	}
+	sort.Ints(pIdx)
+	for _, i := range pIdx {
+		name := fmt.Sprintf("%%p%d", i)
+		c.pRegSlot[i] = name
+		fmt.Fprintf(c.b, "  %s = alloca <vscale x 16 x i1>\n", name)
+		fmt.Fprintf(c.b, "  store <vscale x 16 x i1> zeroinitializer, ptr %s\n", name)
+	}
+
+	pnIdx := make([]int, 0, len(c.usedPNRegs))
+	for i := range c.usedPNRegs {
+		pnIdx = append(pnIdx, i)
+	}
+	sort.Ints(pnIdx)
+	for _, i := range pnIdx {
+		name := fmt.Sprintf("%%pn%d", i)
+		c.pnRegSlot[i] = name
+		fmt.Fprintf(c.b, "  %s = alloca target(\"aarch64.svcount\")\n", name)
+	}
+
 	// Flags state: model "last CMP/SUBS/ANDS result" as two i64 slots.
 	// This avoids SSA-phi complexity across CFG edges while we bootstrap.
 	// We keep the actual NZCV bits, since stdlib asm relies on carry-based
@@ -247,11 +1317,29 @@ func (c *arm64Ctx) emitEntryAllocasAndArgInit() error {
 	fmt.Fprintf(c.b, "  store ptr null, ptr %s\n", c.exclusivePtrSlot)
 	fmt.Fprintf(c.b, "  %s = alloca i8\n", c.exclusiveSizeSlot)
 	fmt.Fprintf(c.b, "  store i8 0, ptr %s\n", c.exclusiveSizeSlot)
-	fmt.Fprintf(c.b, "  %s = alloca i64\n", c.exclusiveValueSlot)
-	fmt.Fprintf(c.b, "  store i64 0, ptr %s\n", c.exclusiveValueSlot)
+	fmt.Fprintf(c.b, "  %s = alloca i128\n", c.exclusiveValueSlot)
+	fmt.Fprintf(c.b, "  store i128 0, ptr %s\n", c.exclusiveValueSlot)
 
 	// Frame result slots: allocate addressable storage so patterns like
 	// `$ret+off(FP)` and `MOVD x, ret+off(FP)` can work.
+	// ABI0 parameter slots are writable as well: generated assembly commonly
+	// spills an argument back to its own +off(FP) slot across nested calls.
+	for i, p := range c.sig.Frame.Params {
+		if p.Index < 0 || p.Index >= len(c.sig.Args) {
+			return fmt.Errorf("arm64 entry %q: FP parameter slot +%d has invalid argument index %d", c.sig.Name, p.Offset, p.Index)
+		}
+		name := fmt.Sprintf("%%fp_param_%d", i)
+		c.fpParamAlloca[p.Offset] = name
+		fmt.Fprintf(c.b, "  %s = alloca %s\n", name, p.Type)
+		value := fmt.Sprintf("%%arg%d", p.Index)
+		if fields := frameSlotFields(p); len(fields) != 0 {
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", extracted, c.sig.Args[p.Index], value, frameSlotExtractSuffix(p))
+			value = "%" + extracted
+		}
+		fmt.Fprintf(c.b, "  store %s %s, ptr %s\n", p.Type, value, name)
+	}
+
 	for _, r := range c.fpResults {
 		name := fmt.Sprintf("%%fp_ret_%d", r.Index)
 		c.fpResAllocaIdx[r.Index] = name
@@ -260,76 +1348,152 @@ func (c *arm64Ctx) emitEntryAllocasAndArgInit() error {
 		fmt.Fprintf(c.b, "  store %s %s, ptr %s\n", r.Type, llvmZeroValue(r.Type), name)
 	}
 
-	// Map args -> regs (best-effort for ABIInternal-style asm, and for helper<> reg assignments).
-	if len(c.sig.ArgRegs) > 0 {
-		// Custom arg->reg assignment (used by helper<> bodies).
-		for i := 0; i < len(c.sig.Args) && i < len(c.sig.ArgRegs); i++ {
-			r := c.sig.ArgRegs[i]
-			arg := fmt.Sprintf("%%arg%d", i)
-			argTy := c.sig.Args[i]
-			v, ok, err := arm64ValueAsI64(c, argTy, arg)
-			if err != nil {
+	// Map args -> the independent integer and floating-point ABIInternal banks,
+	// or to an explicit helper register assignment.
+	if c.checkedABI0Tail {
+		return nil // ABI0 arguments exist only in their actually loaded FP slots.
+	}
+	if c.sig.ARM64ClosureABI != nil {
+		if err := c.storeABIRegisterValue(c.sig.ARM64ClosureABI.ContextRegister, Ptr, "%closure"); err != nil {
+			return err
+		}
+	}
+	if c.goRegisterEntry {
+		for _, slot := range c.sig.ARM64GoRegisterABI.Params {
+			value := c.extractGoABIValue(c.sig.Args[slot.Index], fmt.Sprintf("%%arg%d", slot.Index), slot)
+			if err := c.storeABIRegisterValue(slot.Register, slot.Type, value); err != nil {
 				return err
 			}
-			if !ok {
-				continue
+		}
+		return nil
+	}
+	if len(c.sig.ArgRegs) > 0 {
+		if len(c.sig.ArgRegs) != len(c.sig.Args) {
+			return fmt.Errorf("arm64 entry %q: %d explicit argument registers for %d arguments", c.sig.Name, len(c.sig.ArgRegs), len(c.sig.Args))
+		}
+		for i, reg := range c.sig.ArgRegs {
+			if _, aggregate := parseLiteralStructFields(c.sig.Args[i]); aggregate {
+				return fmt.Errorf("arm64 entry %q: explicit register for aggregate argument %d is ambiguous", c.sig.Name, i)
 			}
-			if err := c.storeReg(r, v); err != nil {
+			if err := c.storeABIRegisterValue(reg, c.sig.Args[i], fmt.Sprintf("%%arg%d", i)); err != nil {
 				return err
 			}
 		}
 		return nil
 	}
 
-	// Default: flatten aggregate args into consecutive argument registers
-	// following the Go internal ABI word ordering.
-	regIdx := 0
-	for ai := 0; ai < len(c.sig.Args) && regIdx < 16; ai++ {
+	cursor := arm64ABIRegisterCursor{}
+	for ai := 0; ai < len(c.sig.Args); ai++ {
 		arg := fmt.Sprintf("%%arg%d", ai)
 		argTy := c.sig.Args[ai]
-		if fields, ok := parseLiteralStructFields(argTy); ok && literalFieldsAllScalar(fields) {
+		if fields, aggregate := parseLiteralStructFields(argTy); aggregate {
 			for fi, fTy := range fields {
-				if regIdx >= 16 {
-					break
-				}
-				r := Reg(fmt.Sprintf("R%d", regIdx))
-				regIdx++
-				slot, ok := c.regSlot[r]
-				if !ok {
-					continue
+				r, err := cursor.next(fTy)
+				if err != nil {
+					return nil
 				}
 				t := c.newTmp()
 				fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, argTy, arg, fi)
-				v, ok, err := arm64ValueAsI64(c, fTy, "%"+t)
-				if err != nil {
+				if err := c.storeABIRegisterValue(r, fTy, "%"+t); err != nil {
 					return err
 				}
-				if !ok {
-					continue
-				}
-				fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", v, slot)
 			}
 			continue
 		}
 
-		r := Reg(fmt.Sprintf("R%d", regIdx))
-		regIdx++
-		slot, ok := c.regSlot[r]
-		if !ok {
-			continue
-		}
-		v, ok, err := arm64ValueAsI64(c, argTy, arg)
+		r, err := cursor.next(argTy)
 		if err != nil {
-			return err
+			return nil
 		}
-		if !ok {
-			continue
+		if err := c.storeABIRegisterValue(r, argTy, arg); err != nil {
+			return err
 		}
-		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", v, slot)
 	}
 	return nil
 }
 
+// Large Go TEXT frames must not become LLVM's fixed prologue allocation:
+// Windows ARM64's alloc_l unwind code cannot describe 256 MiB or more.
+// A real variable-sized alloca keeps the complete backing object in the body,
+// where LLVM probes it and preserves an unwindable frame-pointer chain.
+// Ordinary frames remain static to avoid an unnecessary dynamic stack path.
+const arm64DynamicFrameThreshold = int64(1 << 20)
+
+func (c *arm64Ctx) emitLocalStackAllocation(size int64) {
+	if size <= arm64DynamicFrameThreshold {
+		fmt.Fprintf(c.b, "  %s = alloca [%d x i8], align 16\n", c.localStackSlot, size)
+		return
+	}
+
+	// The empty asm changes no machine state. Its tied input/output register
+	// returns the exact size, but LLVM cannot fold that opaque result back
+	// into a static alloca, even after an optimized/inlined translation.
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 asm sideeffect \"\", \"=r,0\"(i64 %d)\n", bytes, size)
+	fmt.Fprintf(c.b, "  %s = alloca i8, i64 %%%s, align 16\n", c.localStackSlot, bytes)
+}
+
+func (c *arm64Ctx) stackOffsetRange() (minOff, maxOff int64, err error) {
+	maxOff = c.frameSize
+	if maxOff == -8 {
+		// Go's historical NOFRAME spelling declares no local storage.
+		maxOff = 0
+	}
+	// Go records FuncInfo.Locals as int32. Declared storage has that source
+	// bound, rather than the much smaller limit on inferred SP movement.
+	const maxDeclaredFrame = int64(1<<31 - 1)
+	if maxOff < 0 || maxOff > maxDeclaredFrame {
+		return 0, 0, fmt.Errorf("ARM64 TEXT frame size %d is outside [0,%d] (or -8 for NOFRAME)", c.frameSize, maxDeclaredFrame)
+	}
+	// Explicit SP displacements cannot reveal the extent of an array walked
+	// through a derived register (for example Snappy's 32 KiB hash table).
+	// The declared frame is therefore a lower bound, not an optional hint.
+	add := func(off, size int64) {
+		if off < -arm64MaxLocalStackSpan || off > arm64MaxLocalStackSpan ||
+			size < 0 || size > arm64MaxLocalStackSpan {
+			err = fmt.Errorf("ARM64 local stack operand exceeds %d bytes", arm64MaxLocalStackSpan)
+			return
+		}
+		if off < minOff {
+			minOff = off
+		}
+		if end := off + size; end > maxOff {
+			maxOff = end
+		}
+	}
+	for _, block := range c.blocks {
+		for _, original := range block.instrs {
+			ins := arm64StackInstruction(original)
+			for _, arg := range ins.Args {
+				if arg.Kind == OpMem && (arg.Mem.Base == SP || arg.Mem.Base == Reg("RSP") || arg.Mem.Base == ZR) {
+					// Four 128-bit NEON registers are the largest ordinary
+					// structured transfer. Scalar/pair forms fit this bound too.
+					add(arg.Mem.Off, 64)
+				}
+			}
+			op := strings.ToUpper(string(ins.Op))
+			if (op != "BL" && op != "CALL") || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			symbol := strings.TrimSpace(ins.Args[0].Sym)
+			if !strings.HasSuffix(symbol, "(SB)") || strings.HasSuffix(symbol, "<ABIInternal>(SB)") {
+				continue
+			}
+			sig, ok := c.sigs[c.resolve(strings.TrimSuffix(symbol, "(SB)"))]
+			if !ok || len(sig.ArgRegs) != 0 {
+				continue
+			}
+			for _, slot := range sig.Frame.Params {
+				add(slot.Offset, frameTypeSize(slot.Type, 8))
+			}
+			for _, slot := range sig.Frame.Results {
+				add(slot.Offset, frameTypeSize(slot.Type, 8))
+			}
+		}
+	}
+	return minOff, maxOff, err
+}
+
 func arm64ValueAsI64(c *arm64Ctx, ty LLVMType, v string) (out string, ok bool, err error) {
 	switch ty {
 	case Ptr:
@@ -421,10 +1585,18 @@ func llvmZeroValue(ty LLVMType) string {
 }
 
 func (c *arm64Ctx) loadReg(r Reg) (string, error) {
+	c.recordMachineRegister(r, 64, false)
 	if r == ZR {
 		return "0", nil
 	}
+	if r == Reg("RSP") {
+		r = SP
+	}
 	if _, ok := arm64ParseFReg(r); ok {
+		if flow := c.machineAvailability; flow != nil {
+			flow.suspended++
+			defer func() { flow.suspended-- }()
+		}
 		v, err := c.loadVReg(r)
 		if err != nil {
 			return "", err
@@ -466,9 +1638,13 @@ func (c *arm64Ctx) ptrFromSB(sym string) (ptr string, err error) {
 }
 
 func (c *arm64Ctx) storeReg(r Reg, v string) error {
+	c.recordMachineRegister(r, 64, true)
 	if r == ZR {
 		return nil
 	}
+	if r == Reg("RSP") {
+		r = SP
+	}
 	if _, ok := arm64ParseFReg(r); ok {
 		lanes := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %s, i64 0\n", lanes, v)
@@ -485,6 +1661,7 @@ func (c *arm64Ctx) storeReg(r Reg, v string) error {
 }
 
 func (c *arm64Ctx) loadVReg(r Reg) (string, error) {
+	c.recordMachineRegister(r, 128, false)
 	idx, ok := arm64ParseVReg(r)
 	if !ok {
 		idx, ok = arm64ParseFReg(r)
@@ -502,6 +1679,7 @@ func (c *arm64Ctx) loadVReg(r Reg) (string, error) {
 }
 
 func (c *arm64Ctx) storeVReg(r Reg, v string) error {
+	c.recordMachineRegister(r, arm64WholeScalableRegister, true)
 	idx, ok := arm64ParseVReg(r)
 	if !ok {
 		idx, ok = arm64ParseFReg(r)
@@ -513,6 +1691,10 @@ func (c *arm64Ctx) storeVReg(r Reg, v string) error {
 	if !ok {
 		return fmt.Errorf("arm64: unknown vreg %s", r)
 	}
+	if zSlot := c.zRegSlot[idx]; zSlot != "" {
+		// Architectural NEON/scalar writes clear the scalable upper bits.
+		fmt.Fprintf(c.b, "  store <vscale x 16 x i8> zeroinitializer, ptr %s\n", zSlot)
+	}
 	fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s\n", v, slot)
 	return nil
 }
diff --git a/arm64_dc_zva_data_provenance_test.go b/arm64_dc_zva_data_provenance_test.go
new file mode 100644
index 000000000..a012e15a1
--- /dev/null
+++ b/arm64_dc_zva_data_provenance_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestARM64DCZVADataAddressesNeedNativeExtentContract(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		body    string
+		address string
+	}{
+		{"named-load", "MOVD holder<>(SB),R0\nDC ZVA,R0", "payload<>(SB)"},
+		{"raw-store", "MOVD holder<>(SB),R0\nWORD $0xd50b7420", "payload<>(SB)"},
+		{"offset-relocation", "MOVD holder<>(SB),R0\nDC ZVA,R0", "payload<>+1(SB)"},
+		{"external-relocation", "MOVD holder<>(SB),R0\nDC ZVA,R0", "external(SB)"},
+		{"indirect-load", "MOVD holder<>(SB),R2\nMOVD (R2),R0\nDC ZVA,R0", "payload<>(SB)"},
+		{"unobserved-relocation", "DC ZVA,R0", "payload<>(SB)"},
+		{"unreachable-load", "B clear\ndead:\nMOVD holder<>(SB),R0\nclear:\nDC ZVA,R0", "payload<>(SB)"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := arm64TypedNativeSource(test.body) +
+				"DATA holder<>+0(SB)/8,$" + test.address + "\nGLOBL holder<>(SB),16,$8\n" +
+				"DATA payload<>+0(SB)/8,$7\nGLOBL payload<>(SB),16,$8\n"
+			// These are accepted source relocations, not invalid machine code.
+			// Never execute a hardware-sized store to these small objects.
+			arm64TypedNativeGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(file.Data) != 2 || file.Data[0].Addr != test.address {
+				t.Fatalf("source address provenance was not parsed: %+v", file.Data)
+			}
+			normalized, err := NormalizeRawFileForTranslation(file, "arm64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(file.Data, normalized.Data) {
+				t.Fatal("public normalization discarded DATA address provenance")
+			}
+			fn := file.Funcs[0]
+			if !errors.Is(validateARM64DCZVASource(fn, file.Data), ErrProbeNeedsContext) {
+				t.Error("original source gate ignored the complete file's DATA relocation")
+			}
+			fn, err = normalizeARM64RawPCRelative(fn)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !errors.Is(validateARM64DCZVAAddressSources(arm64SourceGoFrame(fn), fn.FrameSize, arm64SplitBlocks(fn), file.Data), ErrProbeNeedsContext) {
+				t.Error("normalized CFG gate ignored the complete file's DATA relocation")
+			}
+			lowerer, _ := newARM64CtxWithFuncForTest(t, fn, arm64TypedNativeOptions(t, arm64TypedNativeTargets[0]).Sigs["NativeEffects"], nil)
+			lowerer.sourceData = file.Data
+			if !errors.Is(lowerer.requireDCZVANoPrivateAddressSources(), ErrProbeNeedsContext) {
+				t.Error("lowerer dropped source DATA before native store emission")
+			}
+			// On the original implementation this captures the false success:
+			// holder is an eight-byte zero placeholder despite its Go relocation.
+			// Once rejected, there is no returned IR to inspect or execute.
+			ir, err := Translate(file, arm64TypedNativeOptions(t, arm64TypedNativeTargets[0]))
+			if err == nil {
+				for _, line := range strings.Split(ir, "\n") {
+					if strings.Contains(line, "holder") && strings.Contains(line, "global") {
+						t.Logf("unproven relocation translated successfully: %s", line)
+					}
+				}
+			}
+			arm64DCZVARequireContextAllAPIs(t, source)
+		})
+	}
+}
+
+func TestARM64DCZVAScalarDataIsNotAnAddressSource(t *testing.T) {
+	source := arm64TypedNativeSource("MOVD block_size<>(SB),R2\nDC ZVA,R0") +
+		"DATA block_size<>+0(SB)/8,$64\nGLOBL block_size<>(SB),16,$8\n"
+	arm64TypedNativeGoObject(t, source)
+	// A normal SB data read, including memclr's cached hardware block size,
+	// neither takes a materialized object's address nor carries a relocation.
+	arm64TypedNativeAllAPIsAndObjects(t, source, 0, 0)
+}
diff --git a/arm64_dc_zva_effects_test.go b/arm64_dc_zva_effects_test.go
new file mode 100644
index 000000000..8b64889c3
--- /dev/null
+++ b/arm64_dc_zva_effects_test.go
@@ -0,0 +1,336 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64DCZVAControlIsAnUnknownExtentStore(t *testing.T) {
+	file, err := Parse(ArchARM64, arm64TypedNativeSource("DC ZVA,R0"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	state := arm64ControlState{
+		regs: map[Reg]arm64ControlValue{
+			"R0": arm64ControlFromMap(map[string]bool{"label:data": true}), "R30": arm64ControlFromMap(map[string]bool{"label:caller": true}),
+		},
+		memory: map[string]arm64ControlValue{
+			"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true}), "sp:4096": arm64ControlFromMap(map[string]bool{"label:far": true}),
+			"fp:8": arm64ControlFromMap(map[string]bool{"fpa:24": true}),
+		},
+	}
+	before := state.clone()
+	ins := file.Funcs[0].Instrs[1]
+	state.transfer(ins, "DC", false, nil)
+	if !reflect.DeepEqual(state.regs, before.regs) {
+		t.Fatal("DC ZVA reads its address; it must not define a GP destination")
+	}
+	for key, value := range state.memory {
+		if !arm64ControlHas(value, "") {
+			t.Errorf("unknown hardware granule left %s falsely known: %v", key, value)
+		}
+		for _, token := range arm64ControlKeys(before.memory[key]) {
+			if !arm64ControlHas(value, token) {
+				t.Errorf("possible old contents/aliases were discarded at %s: %v", key, value)
+			}
+		}
+	}
+	raw := before.clone()
+	raw.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0xd50b7420}}}, OpWORD, false, nil)
+	if !reflect.DeepEqual(raw, &state) {
+		t.Fatal("raw and named ZVA continuation memory/GP effects diverged")
+	}
+}
+
+func TestARM64DCZVACompleteGoOperationTable(t *testing.T) {
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // Newest table comparison is versioned; the objects still run below.
+	}
+	source, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	row := regexp.MustCompile(`SPOP_([A-Z0-9]+):\s*\{\s*([0-9]+),\s*7,\s*([0-9]+),\s*([0-9]+),\s*true\s*\}`)
+	want := make(map[arm64CacheOperation]arm64SystemFields)
+	for _, match := range row.FindAllStringSubmatch(string(source), -1) {
+		op1, _ := strconv.Atoi(match[2])
+		cm, _ := strconv.Atoi(match[3])
+		op2, _ := strconv.Atoi(match[4])
+		want[arm64CacheOperation(match[1])] = arm64SystemFields{uint8(op1), uint8(cm), uint8(op2)}
+	}
+	if len(want) != 28 || !reflect.DeepEqual(want, arm64CacheOperations) {
+		t.Fatalf("DC must mirror all actual Go cn=7 rows, got %d: %v", len(want), want)
+	}
+}
+
+func TestARM64DCZVACompleteGrammarObjects(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64CacheMaintenanceForms, true)
+	file, err := Parse(ArchARM64, arm64CacheMaintenanceForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, Options{
+				Goarch: "arm64", TargetTriple: target,
+				Sigs: map[string]FuncSig{"cachemaintenanceforms": {Name: "cachemaintenanceforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, target, "dc-family.ll", "dc-family.o", module.String())
+		})
+	}
+}
+
+func TestARM64DCZVAOtherCacheOperationsRemainContext(t *testing.T) {
+	var operations []string
+	for operation := range arm64CacheOperations {
+		if operation != "ZVA" {
+			operations = append(operations, string(operation))
+		}
+	}
+	sort.Strings(operations)
+	for _, operation := range operations {
+		t.Run(operation, func(t *testing.T) {
+			source := arm64TypedNativeSource("DC " + operation + ",R0")
+			arm64TypedNativeGoObject(t, source)
+			arm64DCZVARequireContextAllAPIs(t, source)
+		})
+	}
+}
+
+func TestARM64DCZVASymbolAddressesNeedNativeExtentContract(t *testing.T) {
+	for _, address := range []string{
+		"MOVD $payload<>(SB)", "MOVD $payload<>+1(SB)", "MOVD $payload<>+4096(SB)", "MOVD $external(SB)",
+		"MOVWU $payload<>(SB)",
+	} {
+		t.Run(address, func(t *testing.T) {
+			source := arm64TypedNativeSource(address+",R0\nDC ZVA,R0") +
+				"DATA payload<>+0(SB)/8,$7\nGLOBL payload<>(SB),16,$8\n"
+			// A real Go relocation is valid grammar, not proof that the
+			// separately materialized LLVM object's hardware zero granule
+			// has the same extent/alignment/neighbours as the Go symbol.
+			arm64TypedNativeGoObject(t, source)
+			arm64DCZVARequireContextAllAPIs(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			if !errors.Is(validateARM64DCZVASource(fn, file.Data), ErrProbeNeedsContext) {
+				t.Fatal("original source gate lost SB address-of")
+			}
+			fn, err = normalizeARM64RawPCRelative(fn)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !errors.Is(validateARM64DCZVAAddressSources(arm64SourceGoFrame(fn), fn.FrameSize, arm64SplitBlocks(fn), file.Data), ErrProbeNeedsContext) {
+				t.Fatal("normalized CFG gate lost SB address-of")
+			}
+		})
+	}
+}
+
+func TestARM64DCZVAUnprovenPrivateAddressSourcesRemainContext(t *testing.T) {
+	for name, source := range map[string]string{
+		"frame":           "TEXT ·NativeEffects<ABIInternal>(SB),4,$32\nDC ZVA,R0\nRET\n",
+		"saved-LR":        "TEXT ·NativeEffects<ABIInternal>(SB),4,$32\nBL helper\nDC ZVA,R0\nRET\nhelper:\nB (R30)\n",
+		"SP":              arm64TypedNativeSource("MOVD RSP,R2\nDC ZVA,R0"),
+		"masked-SP":       arm64TypedNativeSource("MOVD RSP,R0\nAND $-64,R0\nDC ZVA,R0"),
+		"FP-pointer-slot": arm64TypedNativeSource("MOVD $ret+8(FP),R2\nADD $1,R2\nDC ZVA,R2"),
+		"FP-data":         arm64TypedNativeSource("MOVD arg+0(FP),R2\nDC ZVA,R0"),
+		"ADR":             arm64TypedNativeSource("ADR here,R2\nDC ZVA,R0\nhere:"),
+		"unreachable-SP":  arm64TypedNativeSource("B clear\ndead:\nMOVD RSP,R2\nclear:\nDC ZVA,R0"),
+		"raw-SP":          arm64TypedNativeSource("WORD $0x910003e2\nDC ZVA,R0"),
+		"DWORD":           arm64TypedNativeSource("DWORD $0x910003e2\nDC ZVA,R0"),
+		"LR-data":         arm64TypedNativeSource("MOVD R30,R2\nDC ZVA,R0"),
+		"unknown-input":   arm64TypedNativeSource("DC ZVA,R9"),
+		"platform-input":  arm64TypedNativeSource("MOVD R0,R18_PLATFORM\nDC ZVA,R18_PLATFORM"),
+		"g-input":         arm64TypedNativeSource("MOVD R0,g\nDC ZVA,g"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			arm64TypedNativeGoObject(t, source)
+			arm64DCZVARequireContextAllAPIs(t, source)
+		})
+	}
+}
+
+func arm64DCZVARequireContextAllAPIs(t *testing.T, source string) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\nfunc NativeEffects(uint64) uint64\n")
+	for _, target := range arm64TypedNativeTargets {
+		opt := arm64TypedNativeOptions(t, target)
+		_, err := Translate(file, opt)
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: Translate requires Context, got %v", target, err)
+		}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, file, opt)
+		if err == nil {
+			module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: Module requires Context, got %v", target, err)
+		}
+		bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+		})
+		if bound != nil {
+			bound.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: Go binding requires Context, got %v", target, err)
+		}
+	}
+}
+
+func TestARM64DCZVAValidatedAddressReads(t *testing.T) {
+	var body strings.Builder
+	for i := 0; i < 30; i++ {
+		if i == 18 || i == 28 {
+			continue
+		}
+		if i != 0 {
+			fmt.Fprintf(&body, "MOVD R0,R%d\n", i)
+		}
+		fmt.Fprintf(&body, "DC ZVA,R%d\n", i)
+	}
+	fmt.Fprintln(&body, "DC ZVA,ZR")
+	// Keep the register-address grammar distinct from caller-return proof.
+	// This compile-only function does not touch memory at runtime.
+	source := arm64TypedNativeSource(body.String())
+	arm64TypedNativeGoObject(t, source)
+	arm64TypedNativeAllAPIsAndObjects(t, source, 0, 0)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Control-only R30 consumption is legal, unlike exposing its LLVM/native
+	// code address as ordinary data. A raw RET word has no Go epilogue.
+	file.Funcs[0].Instrs[len(file.Funcs[0].Instrs)-1] = Instr{
+		Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0xd65f03c0}}, Raw: "WORD $0xd65f03c0",
+	}
+	if _, err := Translate(file, arm64TypedNativeOptions(t, arm64TypedNativeTargets[0])); err != nil {
+		t.Fatalf("raw caller RET was mistaken for a private address observer: %v", err)
+	}
+}
+
+func TestARM64DCZVARawAddressReadsAndSharedEffects(t *testing.T) {
+	fields := arm64CacheOperations["ZVA"]
+	base := uint32(0xd5080000) | uint32(fields.op1)<<16 | 7<<12 |
+		uint32(fields.cm)<<8 | uint32(fields.op2)<<5
+	var body strings.Builder
+	for i := uint32(0); i < 32; i++ {
+		word := base | i
+		form, ok := decodeARM64RawDCZVA(word)
+		if !ok || form.fields != fields || form.operation != "ZVA" {
+			t.Fatalf("raw ZVA rejected complete Rt=%d: %#x", i, word)
+		}
+		effects, ok := arm64RawContinuationEffectsForWord(word)
+		if !ok || !effects.stores || effects.gpWrites != 0 || effects.readsSP ||
+			effects.gpReads != arm64RawGPBit(int(i)) {
+			t.Fatalf("raw ZVA Rt=%d has incorrect bank/store effects: %+v", i, effects)
+		}
+		if i == 18 || i == 28 || i == 30 {
+			// Hidden platform/g state and entry LR as data are not an
+			// ordinary typed external pointer contract.
+			arm64DCZVARequireContextAllAPIs(t, arm64TypedNativeSource(fmt.Sprintf("WORD $0x%08x", word)))
+			continue
+		}
+		if i != 0 && i != 31 {
+			fmt.Fprintf(&body, "MOVD R0,R%d\n", i)
+		}
+		fmt.Fprintf(&body, "WORD $0x%08x\n", word)
+	}
+	source := arm64TypedNativeSource(body.String())
+	arm64TypedNativeGoObject(t, source)
+	arm64TypedNativeAllAPIsAndObjects(t, source, 0, 0)
+	for bit := uint(5); bit < 32; bit++ {
+		if _, ok := decodeARM64RawDCZVA(base ^ (1 << bit)); ok {
+			t.Errorf("raw ZVA decoder ignored fixed bit %d", bit)
+		}
+	}
+}
+
+func TestARM64DCZVAStoreProofIsNotNeutralAndIsEmissionBound(t *testing.T) {
+	var ir strings.Builder
+	flow := &arm64MachineAvailability{
+		blocks: []arm64MachineBlock{{name: "entry"}}, source: "DC ZVA,ZR",
+	}
+	ctx := &arm64Ctx{
+		b: &ir, machineAvailability: flow, flagsKnown: arm64FlagAll, flagsWritten: true,
+		flagsNSlot: "flags_N", flagsZSlot: "flags_Z", flagsCSlot: "flags_C", flagsVSlot: "flags_V",
+	}
+	ctx.emitMachineStoreNativeIR("  call void asm sideeffect %q, %q()\n", "sys #3, c7, c4, #1, xzr", "~{memory}")
+	ctx.recordMachineOpaqueIR(0, Instr{})
+	if len(flow.blocks[0].effects) != 1 || !flow.blocks[0].effects[0].store || flow.blocks[0].effects[0].opaque ||
+		ctx.flagsKnown != arm64FlagAll || !ctx.flagsWritten {
+		t.Fatal("validated ZVA emission must retain an explicit data-store effect")
+	}
+
+	checkEffects := func(wantStores, wantOpaque, wantUnavailable int) {
+		t.Helper()
+		stores, opaque := 0, 0
+		unavailable := make(map[string]int)
+		for _, effect := range flow.blocks[0].effects {
+			switch {
+			case effect.store && !effect.opaque && !effect.unavailable:
+				stores++
+			case effect.opaque && !effect.store && !effect.unavailable:
+				opaque++
+			case effect.unavailable && !effect.store && !effect.opaque && effect.width == 1:
+				unavailable[effect.register]++
+			default:
+				t.Fatalf("unexpected native store effect: %+v", effect)
+			}
+		}
+		if stores != wantStores || opaque != wantOpaque || len(unavailable) != 4 ||
+			ctx.flagsKnown != 0 || ctx.flagsWritten {
+			t.Fatalf("native store effects: stores=%d opaque=%d unavailable=%v known=%#x written=%v",
+				stores, opaque, unavailable, ctx.flagsKnown, ctx.flagsWritten)
+		}
+		for _, slot := range []string{ctx.flagsNSlot, ctx.flagsZSlot, ctx.flagsCSlot, ctx.flagsVSlot} {
+			if unavailable[slot] != wantUnavailable {
+				t.Fatalf("native store revoked %s %d times, want %d", slot, unavailable[slot], wantUnavailable)
+			}
+		}
+	}
+
+	start := ir.Len()
+	fmt.Fprint(&ir, "  call void asm sideeffect \"sys #3, c7, c4, #1, xzr\", \"~{memory}\"()\n")
+	ctx.recordMachineOpaqueIR(start, Instr{})
+	if _, proven := flow.nativeIR[start]; proven {
+		t.Fatal("unproven identical native store borrowed an earlier exact-emission proof")
+	}
+	checkEffects(1, 1, 1)
+
+	start = ir.Len()
+	ctx.emitMachineStoreNativeIR("  call void asm sideeffect %q, %q()\n", "sys #3, c7, c4, #1, xzr", "~{memory}")
+	fmt.Fprint(&ir, "  call void @unknown()\n")
+	ctx.recordMachineOpaqueIR(start, Instr{})
+	checkEffects(2, 2, 2)
+}
diff --git a/arm64_dc_zva_runtime_test.go b/arm64_dc_zva_runtime_test.go
new file mode 100644
index 000000000..60569a8a0
--- /dev/null
+++ b/arm64_dc_zva_runtime_test.go
@@ -0,0 +1,145 @@
+//go:build go1.27
+// +build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64DCZVAEffects(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	original, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/runtime/memclr_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Rename only the entry symbol for a standalone native oracle. All source
+	// instructions and the private block-size cache are the real implementation.
+	source := strings.ReplaceAll(string(original), "runtime·memclrNoHeapPointers", "·Memclr") + `
+TEXT ·ReadDCZID<ABIInternal>(SB),4,$0
+MRS DCZID_EL0,R0
+RET
+TEXT ·ZeroGranule<ABIInternal>(SB),4,$0
+MOVD R0,R2
+CMP $0,R1
+DC ZVA,R0
+EOR R2,R0,R3
+ADD R3,R1,R0
+ADD $9,R0
+CINC NE,R0,R0
+RET
+TEXT ·ZeroGranuleRaw<ABIInternal>(SB),4,$0
+MOVD R0,R2
+CMP $0,R1
+WORD $0xd50b7420
+EOR R2,R0,R3
+ADD R3,R1,R0
+ADD $9,R0
+CINC NE,R0,R0
+RET
+`
+	const declarations = `func Memclr(*byte,uintptr)
+func ReadDCZID() uint64
+func ZeroGranule(*byte,uint64) uint64
+func ZeroGranuleRaw(*byte,uint64) uint64
+`
+	goMain := "package main\nimport \"unsafe\"\n" + declarations + `
+func main() {
+  d:=ReadDCZID()
+  if d&16!=0 { panic("actual DCZID_EL0 prohibits ZVA; native execution not established") }
+  n:=int(uint64(4)<<(d&15))
+  a:=make([]byte,12*n+512)
+  base:=int((-uintptr(unsafe.Pointer(&a[0])))&uintptr(n-1))+n
+  fill:=func() { for i:=range a { a[i]=byte(i*7+3)|1 } }
+  check:=func(start,count int) {
+    for i,b:=range a {
+      want:=byte(i*7+3)|1
+      if i>=start && i<start+count { want=0 }
+      if b!=want { panic("zero extent/canary mismatch") }
+    }
+  }
+  for _,zero:=range []func(*byte,uint64)uint64{ZeroGranule,ZeroGranuleRaw} {
+    for _,offset:=range []int{0,1,n/2,n-1,n,n+1,2*n-1} {
+      for _,input:=range []uint64{0,1,123,1<<63,^uint64(0)} {
+        fill()
+        want:=input+9; if input!=0 { want++ }
+        if zero(&a[base+offset],input)!=want { panic("ZVA GP/NZCV effect mismatch") }
+        check(base+(offset/n)*n,n)
+      }
+    }
+  }
+  for _,offset:=range []int{0,1,15,16,63,n-1} {
+    for _,count:=range []int{0,1,2,3,4,7,8,15,16,17,31,32,63,64,127,128,n-1,n,n+1,2*n+63,8*n+127} {
+      fill()
+      Memclr(&a[base+offset],uintptr(count))
+      check(base+offset,count)
+    }
+  }
+}
+`
+	runARM64GoInternalOracle(t, source, goMain, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/dczva", "package dczva\n"+declarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	const main = `#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+extern void Memclr(uint8_t*,uintptr_t);
+extern uint64_t ReadDCZID(void), ZeroGranule(uint8_t*,uint64_t), ZeroGranuleRaw(uint8_t*,uint64_t);
+static void fill(uint8_t *a,size_t size) {
+  for (size_t i=0;i<size;i++) a[i]=(uint8_t)(i*7+3)|1;
+}
+static int check(uint8_t *a,size_t size,size_t start,size_t count) {
+  for (size_t i=0;i<size;i++) {
+    uint8_t want=(uint8_t)(i*7+3)|1;
+    if (i>=start && i<start+count) want=0;
+    if (a[i]!=want) return 0;
+  }
+  return 1;
+}
+int main(void) {
+  uint64_t d;
+  __asm__ volatile("mrs %0, DCZID_EL0" : "=r"(d));
+  if (ReadDCZID()!=d || (d&16)) return 1;
+  size_t n=UINT64_C(4)<<(d&15),size=12*n+512;
+  uint8_t *a=malloc(size),*native=malloc(size);
+  if (!a || !native) return 2;
+  size_t base=(-(uintptr_t)a&(n-1))+n;
+  size_t nativebase=(-(uintptr_t)native&(n-1))+n;
+  const uint64_t inputs[]={0,1,123,UINT64_C(1)<<63,UINT64_MAX};
+  const size_t offsets[]={0,1,n/2,n-1,n,n+1,2*n-1};
+  uint64_t (*zeros[])(uint8_t*,uint64_t)={ZeroGranule,ZeroGranuleRaw};
+  for (unsigned z=0;z<2;z++) for (unsigned o=0;o<7;o++) for (unsigned k=0;k<5;k++) {
+    fill(a,size); fill(native,size);
+    uint64_t want=inputs[k]+9+(inputs[k]!=0);
+    if (zeros[z](a+base+offsets[o],inputs[k])!=want) return 3;
+    __asm__ volatile("dc zva,%0" :: "r"(native+nativebase+offsets[o]) : "memory");
+    if (!check(a,size,base+(offsets[o]/n)*n,n) ||
+        !check(native,size,nativebase+(offsets[o]/n)*n,n)) return 4;
+  }
+  const size_t starts[]={0,1,15,16,63,n-1};
+  const size_t counts[]={0,1,2,3,4,7,8,15,16,17,31,32,63,64,127,128,n-1,n,n+1,2*n+63,8*n+127};
+  for (unsigned o=0;o<6;o++) for (unsigned k=0;k<21;k++) {
+    fill(a,size);
+    Memclr(a+base+starts[o],counts[k]);
+    if (!check(a,size,base+starts[o],counts[k])) return 5;
+  }
+  free(a); free(native);
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "dc_zva_effects", triple, tr.Module.String(), main, runner)
+}
diff --git a/arm64_decoder_extended_shift_test.go b/arm64_decoder_extended_shift_test.go
new file mode 100644
index 000000000..e47f4e96a
--- /dev/null
+++ b/arm64_decoder_extended_shift_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestARM64DecoderExtendedShiftBoundariesMatchGo(t *testing.T) {
+	// x/arch prints reserved machine encodings too. Go rejects extended
+	// register shifts above four; a decoder spelling is not a Go format.
+	// Check every ADD/SUB W/X and flags alias and every extension, including
+	// all five legal shifts, against the actual invoked Go assembler.
+	for _, op := range []string{"ADD", "ADDS", "ADDW", "ADDSW", "SUB", "SUBS", "SUBW", "SUBSW"} {
+		for _, extension := range []string{"UXTB", "UXTH", "UXTW", "UXTX", "SXTB", "SXTH", "SXTW", "SXTX"} {
+			for shift := 0; shift <= 7; shift++ {
+				instruction := fmt.Sprintf("%s R4.%s<<%d,R5,R9", op, extension, shift)
+				t.Run(instruction, func(t *testing.T) {
+					source := "TEXT decoder_shift(SB),516,$0-0\n" + instruction + "\nRET\n"
+					dir := t.TempDir()
+					path := filepath.Join(dir, "source.s")
+					if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+						t.Fatal(err)
+					}
+					output, goErr := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-o", filepath.Join(dir, "source.o"), path)
+					accepted := shift <= 4
+					if (goErr == nil) != accepted {
+						t.Fatalf("actual Go extended shift accepted=%t: %v\n%s", accepted, goErr, output)
+					}
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					probeErr := ProbeInstruction(ArchARM64, "arm64", file.Funcs[0].Instrs[1])
+					if (probeErr == nil) != accepted {
+						t.Fatalf("probe differs from actual Go extended shift accepted=%t: %v", accepted, probeErr)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_decoder_overlap_test.go b/arm64_decoder_overlap_test.go
new file mode 100644
index 000000000..6a5433815
--- /dev/null
+++ b/arm64_decoder_overlap_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// x/arch's decoder corpus includes machine encodings that Go deliberately
+// rejects. These two cases formerly made a mixed MOVHU form appear fully
+// supported even though writeback would overwrite the loaded destination.
+func TestARM64DecoderWritebackOverlapRejectedLikeGo(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVHU.P 107(R13), R13",
+		"MOVHU.W 192(R2), R2",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT decoderOverlap(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"decoderOverlap": {Name: "decoderOverlap", Ret: Void},
+			}})
+			if err == nil || !strings.Contains(err.Error(), "base/data register overlap") {
+				t.Fatalf("Go-rejected decoder overlap must fail closed, got %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_divide_remainder_cross_runtime_test.go b/arm64_divide_remainder_cross_runtime_test.go
new file mode 100644
index 000000000..9b9fa173a
--- /dev/null
+++ b/arm64_divide_remainder_cross_runtime_test.go
@@ -0,0 +1,372 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64DivRemRuntimeCase struct {
+	op                      string
+	divisor, dividend, dest Reg
+	two                     bool
+}
+
+const arm64DivRemDiscard = uint64(0x123456789abcdef)
+
+// Preserve the complete original Darwin fixture body as a separate entry. Only
+// its first-party symbol is renamed so stock Go and all LLVM APIs can execute
+// it alongside the wider initialized matrix on both native platforms.
+const arm64DivRemOriginalRuntimeSource = `TEXT ·OriginalDivideRem(SB),$0-16
+MOVD input+0(FP),R10
+MOVD output+8(FP),R11
+MOVD 0(R10),R0
+MOVD 8(R10),R1
+MOVD 16(R10),R2
+MOVD 24(R10),R3
+MOVD 32(R10),R4
+MOVD 40(R10),R5
+MOVD 48(R10),R23
+SDIV R1,R0,R6
+SDIVW R1,R0,R7
+UDIV R3,R2,R8
+UDIVW R3,R2,R9
+REM R1,R0,R12
+REMW R1,R0,R13
+UREM R3,R2,R14
+UREMW R3,R2,R15
+SDIV ZR,R0,R16
+UDIV ZR,R2,R17
+REM ZR,R0,R19
+UREM ZR,R2,R20
+SDIV R5,R4,R21
+SDIVW R5,R23,R22
+MOVD R6,0(R11)
+MOVD R7,8(R11)
+MOVD R8,16(R11)
+MOVD R9,24(R11)
+MOVD R12,32(R11)
+MOVD R13,40(R11)
+MOVD R14,48(R11)
+MOVD R15,56(R11)
+MOVD R16,64(R11)
+MOVD R17,72(R11)
+MOVD R19,80(R11)
+MOVD R20,88(R11)
+MOVD R21,96(R11)
+MOVD R22,104(R11)
+RET
+`
+
+func arm64DivRemRuntimeCases() []arm64DivRemRuntimeCase {
+	var cases []arm64DivRemRuntimeCase
+	for _, op := range []string{"SDIV", "SDIVW", "UDIV", "UDIVW", "REM", "REMW", "UREM", "UREMW"} {
+		// Both Go optab rows use C_ZREG throughout. These initialized aliases
+		// cover two/three operands and every ZR role without using R18 or g.
+		// Go REM's implicit R27 quotient is a separate observable-state axis.
+		for _, form := range []arm64DivRemRuntimeCase{
+			{divisor: "R1", dividend: "R0", dest: "R20"},
+			{divisor: "R1", dividend: "R0", dest: "R0", two: true},
+			{divisor: "R1", dividend: "R0", dest: "R0"},
+			{divisor: "R1", dividend: "R0", dest: "R1"},
+			{divisor: "R0", dividend: "R0", dest: "R20"},
+			{divisor: "R0", dividend: "R0", dest: "R0", two: true},
+			{divisor: "R0", dividend: "R0", dest: "R0"},
+			{divisor: ZR, dividend: "R0", dest: "R20"},
+			{divisor: "R1", dividend: ZR, dest: "R20"},
+			{divisor: "R1", dividend: "R0", dest: ZR},
+			{divisor: "R1", dividend: ZR, dest: ZR, two: true},
+			{divisor: ZR, dividend: ZR, dest: ZR},
+		} {
+			form.op = op
+			cases = append(cases, form)
+		}
+	}
+	return cases
+}
+
+func arm64DivRemRuntimeSource(cases []arm64DivRemRuntimeCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·DivideRem(SB),4,$0-16\nMOVD input+0(FP),R10\nMOVD output+8(FP),R11\n")
+	for index, tc := range cases {
+		source.WriteString("MOVD 0(R10),R0\nMOVD 8(R10),R1\nMOVD 16(R10),R6\nMOVD 24(R10),R7\n")
+		fmt.Fprintf(&source, "MOVD $%#x,R20\nCMP R7,R6\n", arm64DivRemDiscard)
+		if tc.two {
+			fmt.Fprintf(&source, "%s %s,%s\n", tc.op, tc.divisor, tc.dest)
+		} else {
+			fmt.Fprintf(&source, "%s %s,%s,%s\n", tc.op, tc.divisor, tc.dividend, tc.dest)
+		}
+		result := tc.dest
+		if result == ZR {
+			result = "R20"
+		}
+		fmt.Fprintf(&source, "MOVD %s,%d(R11)\n", result, index*16)
+		source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET HS,R4\nCSET VS,R5\n")
+		source.WriteString("LSL $1,R3\nLSL $2,R4\nLSL $3,R5\nORR R3,R2\nORR R4,R2\nORR R5,R2\n")
+		fmt.Fprintf(&source, "MOVD R2,%d(R11)\n", index*16+8)
+	}
+	source.WriteString("RET\n")
+	source.WriteString(arm64DivRemOriginalRuntimeSource)
+	return source.String()
+}
+
+func arm64DivRemRuntimeInputs() [][4]uint64 {
+	inputs := [][4]uint64{
+		{9, 2, 0, 0}, {^uint64(8), 2, 0, 1}, {9, ^uint64(1), 1, 0},
+		{1 << 63, ^uint64(0), 1 << 63, 1}, {1 << 31, ^uint64(0), 0, 1 << 63},
+		{^uint64(0), 0, ^uint64(0), 1}, {0, 0, 0, ^uint64(0)},
+		{0xfedcba9880000000, 0x12345678ffffffff, 1 << 63, ^uint64(0)},
+	}
+	seed := uint64(0xabcdef0123456789)
+	for i := 0; i < 64; i++ {
+		var input [4]uint64
+		for index := range input {
+			seed = seed*6364136223846793005 + 1
+			input[index] = seed
+		}
+		inputs = append(inputs, input)
+	}
+	return inputs
+}
+
+func arm64DivRemRuntimeExpected(tc arm64DivRemRuntimeCase, input [4]uint64) uint64 {
+	if tc.dest == ZR {
+		return arm64DivRemDiscard
+	}
+	read := func(reg Reg) uint64 {
+		switch reg {
+		case "R0":
+			return input[0]
+		case "R1":
+			return input[1]
+		case ZR:
+			return 0
+		default:
+			panic("unregistered numerical oracle register")
+		}
+	}
+	numerator, denominator := read(tc.dividend), read(tc.divisor)
+	word := strings.HasSuffix(tc.op, "W")
+	if word {
+		numerator, denominator = uint64(uint32(numerator)), uint64(uint32(denominator))
+	}
+	remainder := strings.Contains(tc.op, "REM")
+	if denominator == 0 {
+		if remainder {
+			return numerator
+		}
+		return 0
+	}
+	signed := strings.HasPrefix(tc.op, "S") || strings.HasPrefix(tc.op, "REM")
+	var result uint64
+	if signed {
+		n, d := int64(numerator), int64(denominator)
+		if word {
+			n, d = int64(int32(numerator)), int64(int32(denominator))
+		}
+		if remainder {
+			result = uint64(n % d)
+		} else {
+			result = uint64(n / d)
+		}
+	} else if remainder {
+		result = numerator % denominator
+	} else {
+		result = numerator / denominator
+	}
+	if word {
+		result = uint64(uint32(result))
+	}
+	return result
+}
+
+func arm64DivRemRuntimeFlags(a, b uint64) uint64 {
+	result := a - b
+	flags := result >> 63
+	if result == 0 {
+		flags |= 2
+	}
+	if a >= b {
+		flags |= 4
+	}
+	flags |= (((a ^ b) & (a ^ result)) >> 63) << 3
+	return flags
+}
+
+func arm64DivRemRuntimePrograms(cases []arm64DivRemRuntimeCase) (goSource, cSource string) {
+	var goText, cText strings.Builder
+	count := len(cases) * 2
+	fmt.Fprintf(&goText, `package main
+func DivideRem(input *[4]uint64, output *[%d]uint64)
+func OriginalDivideRem(input *[7]uint64, output *[14]uint64)
+func main() {
+	type row struct { input [4]uint64; want [%d]uint64 }
+	rows := []row{
+`, count, count)
+	fmt.Fprintf(&cText, `#include <stdint.h>
+#include <stdio.h>
+extern void DivideRem(const uint64_t *, uint64_t *);
+extern void OriginalDivideRem(const uint64_t *, uint64_t *);
+struct row { uint64_t input[4]; uint64_t want[%d]; };
+static const struct row rows[] = {
+`, count)
+	for _, input := range arm64DivRemRuntimeInputs() {
+		fmt.Fprintf(&goText, "\t{input: [4]uint64{%#x,%#x,%#x,%#x}, want: [%d]uint64{", input[0], input[1], input[2], input[3], count)
+		fmt.Fprintf(&cText, "  {{UINT64_C(%#x),UINT64_C(%#x),UINT64_C(%#x),UINT64_C(%#x)}, {", input[0], input[1], input[2], input[3])
+		flags := arm64DivRemRuntimeFlags(input[2], input[3])
+		for _, tc := range cases {
+			result := arm64DivRemRuntimeExpected(tc, input)
+			fmt.Fprintf(&goText, "%#x,%#x,", result, flags)
+			fmt.Fprintf(&cText, "UINT64_C(%#x),UINT64_C(%#x),", result, flags)
+		}
+		goText.WriteString("}},\n")
+		cText.WriteString("}},\n")
+	}
+	fmt.Fprintf(&goText, `
+	}
+	for rowIndex, r := range rows {
+		input := r.input
+		out := struct { left uint64; values [%d]uint64; right uint64 }{
+			left: 0x1122334455667788, right: 0x8877665544332211,
+		}
+		for i := range out.values { out.values[i] = 0xa7a7a7a7a7a7a7a7 }
+		DivideRem(&input, &out.values)
+		if input != r.input || out.left != 0x1122334455667788 || out.right != 0x8877665544332211 {
+			panic("divide/remainder input or canary changed")
+		}
+		for index, want := range r.want {
+			if got := out.values[index]; got != want {
+				println(rowIndex, index, got, want)
+				panic("original Go divide/remainder numerical or NZCV mismatch")
+			}
+		}
+	}
+	originalInput := [7]uint64{0xfffffffffffffff7,2,9,2,0x8000000000000000,0xffffffffffffffff,0x80000000}
+	originalWant := [14]uint64{0xfffffffffffffffc,0xfffffffc,4,4,0xffffffffffffffff,0xffffffff,1,1,0,0,0xfffffffffffffff7,9,0x8000000000000000,0x80000000}
+	original := struct { left uint64; values [14]uint64; right uint64 }{
+		left: 0x1122334455667788, right: 0x8877665544332211,
+	}
+	OriginalDivideRem(&originalInput, &original.values)
+	if original.values != originalWant || original.left != 0x1122334455667788 || original.right != 0x8877665544332211 {
+		panic("complete original divide/remainder body mismatch")
+	}
+}
+`, count)
+	fmt.Fprintf(&cText, `
+};
+int main(void) {
+  for (unsigned row_index = 0; row_index < sizeof(rows)/sizeof(rows[0]); row_index++) {
+    uint64_t input[4];
+    struct { uint64_t left; uint64_t values[%d]; uint64_t right; } out;
+    out.left = UINT64_C(0x1122334455667788);
+    out.right = UINT64_C(0x8877665544332211);
+    for (unsigned i = 0; i < 4; i++) input[i] = rows[row_index].input[i];
+    for (unsigned i = 0; i < %d; i++) out.values[i] = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    DivideRem(input, out.values);
+    if (out.left != UINT64_C(0x1122334455667788) || out.right != UINT64_C(0x8877665544332211)) return 1;
+    for (unsigned i = 0; i < 4; i++) if (input[i] != rows[row_index].input[i]) return 2;
+    for (unsigned i = 0; i < %d; i++) {
+      if (out.values[i] != rows[row_index].want[i]) {
+        fprintf(stderr, "row=%%u result=%%u got=%%llx want=%%llx\n", row_index, i,
+          (unsigned long long)out.values[i], (unsigned long long)rows[row_index].want[i]);
+        return 3;
+      }
+    }
+  }
+  const uint64_t original_input[7] = {
+    UINT64_C(0xfffffffffffffff7),2,9,2,UINT64_C(0x8000000000000000),UINT64_MAX,UINT64_C(0x80000000)
+  };
+  const uint64_t original_want[14] = {
+    UINT64_C(0xfffffffffffffffc),UINT64_C(0xfffffffc),4,4,UINT64_MAX,UINT32_MAX,1,1,0,0,
+    UINT64_C(0xfffffffffffffff7),9,UINT64_C(0x8000000000000000),UINT64_C(0x80000000)
+  };
+  struct { uint64_t left; uint64_t values[14]; uint64_t right; } original = {0};
+  original.left = UINT64_C(0x1122334455667788);
+  original.right = UINT64_C(0x8877665544332211);
+  OriginalDivideRem(original_input, original.values);
+  if (original.left != UINT64_C(0x1122334455667788) || original.right != UINT64_C(0x8877665544332211)) return 4;
+  for (unsigned i = 0; i < 14; i++) if (original.values[i] != original_want[i]) return 5;
+  return 0;
+}
+`, count, count, count)
+	return goText.String(), cText.String()
+}
+
+func arm64DivRemRuntimeIRs(t *testing.T, source, triple string, count int) []string {
+	t.Helper()
+	pkg := mustGoPackage(t, "divrem", fmt.Sprintf(`package divrem
+func DivideRem(input *[4]uint64, output *[%d]uint64)
+func OriginalDivideRem(input *[7]uint64, output *[14]uint64)
+`, count))
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Audit the complete original file before deriving callable declarations.
+	// Source-only continuations must not acquire independent helper signatures.
+	file, err = CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	moduleIR := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	boundIR := bound.Module.String()
+	bound.Module.Dispose()
+	return []string{ir, moduleIR, boundIR}
+}
+
+func TestARM64DivideRemainderInitializedRuntimeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	cases := arm64DivRemRuntimeCases()
+	source := arm64DivRemRuntimeSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin",
+		"aarch64-pc-windows-msvc", "aarch64-w64-windows-gnu",
+	} {
+		for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*2) {
+			compileLLVMToObject(t, llc, triple, fmt.Sprintf("divrem-%d.ll", api), fmt.Sprintf("divrem-%d.o", api), ir)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64DivideRemainderInitialized(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	cases := arm64DivRemRuntimeCases()
+	source := arm64DivRemRuntimeSource(cases)
+	goSource, cSource := arm64DivRemRuntimePrograms(cases)
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*2) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("divrem-%d", api), triple, ir, cSource, runner)
+	}
+	t.Logf("actual Go and all three LLVM APIs: %d U/S W/X divide/remainder forms x %d inputs, aliases/ZR, zero/min-overflow, preserved NZCV and complete canaries", len(cases), len(arm64DivRemRuntimeInputs()))
+}
diff --git a/arm64_divide_remainder_encoding_test.go b/arm64_divide_remainder_encoding_test.go
new file mode 100644
index 000000000..120ba7f6f
--- /dev/null
+++ b/arm64_divide_remainder_encoding_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestARM64DivideRemainderOriginalGoMachineExpansion(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT expansion(SB),4,$0-0\n")
+	var expected []byte
+	registers := map[Reg]uint32{"R0": 0, "R1": 1, "R2": 2, "R27": 27, ZR: 31}
+	cases := arm64RemainderScratchCases()
+	for _, tc := range cases {
+		if tc.two {
+			fmt.Fprintf(&source, "%s %s,%s\n", tc.op, tc.divisor, tc.dest)
+		} else {
+			fmt.Fprintf(&source, "%s %s,%s,%s\n", tc.op, tc.divisor, tc.dividend, tc.dest)
+		}
+		size := uint32(1 << 31)
+		if strings.HasSuffix(tc.op, "W") {
+			size = 0
+		}
+		division := uint32(0x1ac00c00)
+		if strings.HasPrefix(tc.op, "U") {
+			division = 0x1ac00800
+		}
+		divisor, dividend, destination := registers[tc.divisor], registers[tc.dividend], registers[tc.dest]
+		quotient := destination
+		if strings.Contains(tc.op, "REM") {
+			quotient = 27
+		}
+		word := size | division | divisor<<16 | dividend<<5 | quotient
+		var encoded [4]byte
+		binary.LittleEndian.PutUint32(encoded[:], word)
+		expected = append(expected, encoded[:]...)
+		if strings.Contains(tc.op, "REM") {
+			word = size | 0x1b008000 | divisor<<16 | dividend<<10 | 27<<5 | destination
+			binary.LittleEndian.PutUint32(encoded[:], word)
+			expected = append(expected, encoded[:]...)
+		}
+	}
+	source.WriteString("RET\n")
+	expected = append(expected, 0xc0, 0x03, 0x5f, 0xd6)
+	for _, goos := range []string{"linux", "darwin"} {
+		dir := t.TempDir()
+		asm := filepath.Join(dir, "expansion.s")
+		if err := os.WriteFile(asm, []byte(source.String()), 0600); err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+		command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", filepath.Join(dir, "expansion.o"), asm)
+		command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64")
+		listing, err := command.CombinedOutput()
+		cancel()
+		if err != nil {
+			t.Fatalf("%s actual Go expansion object: %v\n%s", goos, err, listing)
+		}
+		var actual []byte
+		// Instruction listing rows also start with a hexadecimal PC, then a
+		// decimal line counter. Require a complete machine word's byte field
+		// so that counter cannot impersonate the object-byte dump.
+		for _, row := range regexp.MustCompile(`(?m)^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`).FindAllSubmatch(listing, -1) {
+			decoded, err := hex.DecodeString(strings.ReplaceAll(string(row[1]), " ", ""))
+			if err != nil {
+				t.Fatal(err)
+			}
+			actual = append(actual, decoded...)
+		}
+		if len(actual) < len(expected) {
+			t.Fatalf("%s Go byte dump truncated: %d actual bytes for %d expected bytes", goos, len(actual), len(expected))
+		}
+		if !bytes.Equal(actual[:len(expected)], expected) {
+			for index, want := range expected {
+				if got := actual[index]; got != want {
+					t.Fatalf("%s Go DIV/REM expansion byte %d: got %#x, want %#x", goos, index, got, want)
+				}
+			}
+		}
+	}
+	t.Logf("%d original Go W/X DIV/REM forms: exact DIV/R27/MSUB and RET bytes on Linux and Darwin", len(cases))
+}
diff --git a/arm64_divide_remainder_form.go b/arm64_divide_remainder_form.go
new file mode 100644
index 000000000..69b511954
--- /dev/null
+++ b/arm64_divide_remainder_form.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64DivideRemainderForm struct {
+	divisor, dividend, destination Operand
+	word, signed, remainder        bool
+}
+
+// Go's two C_ZREG rows cover the eight W/X signed/unsigned forms. REM is
+// expanded to DIV -> R27 then MSUB, not a hardware remainder operation.
+func parseARM64DivideRemainderForm(op Op, ins Instr) (form arm64DivideRemainderForm, handled bool, err error) {
+	switch op {
+	case "SDIV", "SDIVW", "UDIV", "UDIVW", "REM", "REMW", "UREM", "UREMW":
+	default:
+		return form, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return form, true, fmt.Errorf("arm64 %s expects two or three unsuffixed general registers: %q", op, ins.Raw)
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg || !isARM64GeneralOrZeroReg(operand.Reg) {
+			return form, true, fmt.Errorf("arm64 %s expects only general registers or ZR: %q", op, ins.Raw)
+		}
+	}
+	form.divisor, form.dividend, form.destination = ins.Args[0], ins.Args[1], ins.Args[len(ins.Args)-1]
+	form.word = strings.HasSuffix(string(op), "W")
+	form.signed = strings.HasPrefix(string(op), "S") || strings.HasPrefix(string(op), "REM")
+	form.remainder = strings.Contains(string(op), "REM")
+	return form, true, nil
+}
diff --git a/arm64_eval.go b/arm64_eval.go
index a68bf3974..247961392 100644
--- a/arm64_eval.go
+++ b/arm64_eval.go
@@ -13,7 +13,16 @@ func (c *arm64Ctx) imm64(n int64) string {
 // addrI64 computes an i64 address from a MemRef.
 // If postInc is true, mem.Off is treated as post-increment (address displacement is 0).
 func (c *arm64Ctx) addrI64(mem MemRef, postInc bool) (addr string, base Reg, inc int64, err error) {
+	if mem.OffRaw != "" && !arm64NamedStackOffset(mem) {
+		return "", "", 0, fmt.Errorf("arm64: unresolved memory displacement %q", mem.OffRaw)
+	}
 	base = mem.Base
+	// Register encoding 31 denotes SP in an address operand even when the Go
+	// source spells it ZR. RSP is the explicit hardware-stack-pointer spelling;
+	// both use the same modeled stack-pointer slot.
+	if base == ZR || base == Reg("RSP") {
+		base = SP
+	}
 	baseVal, err := c.loadReg(base)
 	if err != nil {
 		return "", "", 0, err
@@ -25,7 +34,11 @@ func (c *arm64Ctx) addrI64(mem MemRef, postInc bool) (addr string, base Reg, inc
 	}
 	sum := baseVal
 	if mem.Index != "" {
-		idxVal, err := c.loadReg(mem.Index)
+		bits, err := arm64RegisterExtensionWidth(mem.IndexExt)
+		if err != nil {
+			return "", "", 0, err
+		}
+		idxVal, err := c.loadRegisterWidth(mem.Index, bits)
 		if err != nil {
 			return "", "", 0, err
 		}
@@ -164,7 +177,11 @@ func (c *arm64Ctx) eval64(op Operand, postInc bool) (string, error) {
 	case OpReg:
 		return c.loadReg(op.Reg)
 	case OpRegExtend:
-		v, err := c.loadReg(op.Reg)
+		bits, err := arm64RegisterExtensionWidth(op.Ext)
+		if err != nil {
+			return "", err
+		}
+		v, err := c.loadRegisterWidth(op.Reg, bits)
 		if err != nil {
 			return "", err
 		}
@@ -249,13 +266,20 @@ func (c *arm64Ctx) eval32(op Operand) (string, error) {
 	case OpImm:
 		return strconv.FormatUint(uint64(uint32(op.Imm)), 10), nil
 	case OpReg:
-		v, err := c.loadReg(op.Reg)
+		v, err := c.loadRegisterWidth(op.Reg, 32)
 		if err != nil {
 			return "", err
 		}
 		return truncate(v), nil
 	case OpRegExtend:
-		v, err := c.loadReg(op.Reg)
+		bits, err := arm64RegisterExtensionWidth(op.Ext)
+		if err != nil {
+			return "", err
+		}
+		if bits > 32 {
+			bits = 32
+		}
+		v, err := c.loadRegisterWidth(op.Reg, bits)
 		if err != nil {
 			return "", err
 		}
@@ -297,7 +321,7 @@ func (c *arm64Ctx) eval32(op Operand) (string, error) {
 		if op.ShiftReg != "" || op.ShiftAmount < 0 || op.ShiftAmount > 31 {
 			return "", fmt.Errorf("arm64: invalid 32-bit shift: %s", op)
 		}
-		v, err := c.loadReg(op.Reg)
+		v, err := c.loadRegisterWidth(op.Reg, 32)
 		if err != nil {
 			return "", err
 		}
@@ -335,6 +359,21 @@ func (c *arm64Ctx) rotateInt(value, typeName string, bits int, shift string) str
 	return "%" + out
 }
 
+func arm64RegisterExtensionWidth(ext ExtendOp) (int, error) {
+	switch ext {
+	case ExtendUXTB, ExtendSXTB:
+		return 8, nil
+	case ExtendUXTH, ExtendSXTH:
+		return 16, nil
+	case ExtendUXTW, ExtendSXTW:
+		return 32, nil
+	case "", ExtendUXTX, ExtendSXTX:
+		return 64, nil
+	default:
+		return 0, fmt.Errorf("arm64: unsupported register extension %q", ext)
+	}
+}
+
 func (c *arm64Ctx) extendReg64(v string, ext ExtendOp) (string, error) {
 	switch ext {
 	case ExtendUXTX, ExtendSXTX:
@@ -369,43 +408,41 @@ func (c *arm64Ctx) extendReg64(v string, ext ExtendOp) (string, error) {
 
 func (c *arm64Ctx) evalFPValue64(op Operand) (string, error) {
 	slot, ok := c.fpParams[op.FPOffset]
-	if !ok {
-		return "", fmt.Errorf("arm64: unsupported FP param slot: %s", op.String())
+	var value string
+	var err error
+	if ok {
+		value, err = c.loadFPParameter(slot)
+	} else if result, found := c.fpResultSlotByOffset(op.FPOffset); found {
+		slot = result
+		value, err = c.loadFPResult(slot)
+	} else {
+		return "", fmt.Errorf("arm64: unsupported FP slot: %s", op.String())
 	}
-	idx := slot.Index
-	if idx < 0 || idx >= len(c.sig.Args) {
-		return "", fmt.Errorf("arm64: FP slot %s invalid arg index %d", op.String(), idx)
+	if err != nil {
+		return "", err
 	}
-	arg := fmt.Sprintf("%%arg%d", idx)
-
 	ty := slot.Type
-	if slot.Field >= 0 {
-		aggTy := c.sig.Args[idx]
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, aggTy, arg, slot.Field)
-		arg = "%" + t
-	}
 
 	switch string(ty) {
 	case "i64":
-		return arg, nil
+		return value, nil
 	case "i32", "i16", "i8", "i1":
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", t, ty, arg)
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", t, ty, value)
 		return "%" + t, nil
 	case "double":
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", t, arg)
+		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", t, value)
 		return "%" + t, nil
 	case "float":
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", t, arg)
+		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", t, value)
 		z := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, t)
 		return "%" + z, nil
 	case "ptr":
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, arg)
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, value)
 		return "%" + t, nil
 	default:
 		return "", fmt.Errorf("arm64: FP slot %s unsupported arg type %q", op.String(), ty)
@@ -414,10 +451,18 @@ func (c *arm64Ctx) evalFPValue64(op Operand) (string, error) {
 
 func (c *arm64Ctx) evalFPAddr64(op Operand) (string, error) {
 	p, ok := c.fpResAllocaOff[op.FPOffset]
+	result := ok
 	if !ok {
-		return "0", nil
+		p, ok = c.fpParamAlloca[op.FPOffset]
+	}
+	if !ok {
+		// The ordinary signature does not recover a caller-owned FP address.
+		// Missing typed backing is context, never a fabricated zero pointer.
+		return "", fmt.Errorf("%w: arm64 FP address %s requires bound typed frame storage", ErrProbeNeedsContext, op.String())
+	}
+	if result {
+		c.markFPResultAddrTaken(op.FPOffset)
 	}
-	c.markFPResultAddrTaken(op.FPOffset)
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, p)
 	return "%" + t, nil
diff --git a/arm64_extr_source_order_test.go b/arm64_extr_source_order_test.go
new file mode 100644
index 000000000..59b49fa2b
--- /dev/null
+++ b/arm64_extr_source_order_test.go
@@ -0,0 +1,339 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/big"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64ExtractDiscard = uint64(0xd00df00dbaadbeef)
+
+type arm64ExtractOrderCase struct {
+	width, shift int
+	form         string
+}
+
+func arm64ExtractOrderCases() []arm64ExtractOrderCase {
+	var cases []arm64ExtractOrderCase
+	for _, width := range []int{32, 64} {
+		for shift := 0; shift < width; shift++ {
+			cases = append(cases, arm64ExtractOrderCase{width, shift, "distinct"})
+			if shift != 0 && shift != 1 && shift != width/2 && shift != width-1 && !(width == 64 && shift == 35) {
+				continue
+			}
+			for _, form := range []string{
+				"alias-low", "alias-high", "same-source", "zero-low", "zero-high", "discard", "ror-explicit", "ror-inplace",
+			} {
+				cases = append(cases, arm64ExtractOrderCase{width, shift, form})
+			}
+		}
+	}
+	return cases
+}
+
+func (tc arm64ExtractOrderCase) operands() (low, high, destination int) {
+	low, high, destination = 4, 5, 6
+	switch tc.form {
+	case "alias-low":
+		destination = 4
+	case "alias-high":
+		destination = 5
+	case "same-source", "ror-explicit":
+		high = low
+	case "ror-inplace":
+		high, destination = low, low
+	case "zero-low":
+		low = 31
+	case "zero-high":
+		high = 31
+	case "discard":
+		destination = 31
+	}
+	return
+}
+
+func (tc arm64ExtractOrderCase) instruction() (instruction, result string) {
+	register := func(number int) string {
+		if number == 31 {
+			return "ZR"
+		}
+		return fmt.Sprintf("R%d", number)
+	}
+	low, high, destination := tc.operands()
+	op := "EXTR"
+	if strings.HasPrefix(tc.form, "ror-") {
+		op = "ROR"
+	}
+	if tc.width == 32 {
+		op += "W"
+	}
+	// Plan 9 places the LOW concatenation word second and HIGH word third.
+	// Arm's encoding prints the reverse source order: extr Rd, Rn(high), Rm(low).
+	instruction = fmt.Sprintf("%s $%d,%s,%s,%s", op, tc.shift, register(low), register(high), register(destination))
+	if tc.form == "ror-explicit" {
+		instruction = fmt.Sprintf("%s $%d,%s,%s", op, tc.shift, register(low), register(destination))
+	} else if tc.form == "ror-inplace" {
+		instruction = fmt.Sprintf("%s $%d,%s", op, tc.shift, register(low))
+	}
+	result = register(destination)
+	if destination == 31 {
+		result = "R6" // A write to ZR must leave this full-width canary intact.
+	}
+	return
+}
+
+func (tc arm64ExtractOrderCase) oracle(low, high uint64) uint64 {
+	if tc.form == "discard" {
+		return arm64ExtractDiscard
+	}
+	switch tc.form {
+	case "same-source", "ror-explicit", "ror-inplace":
+		high = low
+	case "zero-low":
+		low = 0
+	case "zero-high":
+		high = 0
+	}
+	// A mathematical 2N-bit concatenation, independent of the lowerer's
+	// separate lshr/shl/or instructions and its width-limited intermediates.
+	mask := new(big.Int).Sub(new(big.Int).Lsh(big.NewInt(1), uint(tc.width)), big.NewInt(1))
+	lower := new(big.Int).And(new(big.Int).SetUint64(low), mask)
+	upper := new(big.Int).And(new(big.Int).SetUint64(high), mask)
+	joined := new(big.Int).Add(new(big.Int).Lsh(upper, uint(tc.width)), lower)
+	joined.Rsh(joined, uint(tc.shift)).And(joined, mask)
+	return joined.Uint64()
+}
+
+func arm64ExtractOrderSource(constants bool) (string, map[string]FuncSig) {
+	var source strings.Builder
+	signatures := map[string]FuncSig{}
+	for index, tc := range arm64ExtractOrderCases() {
+		name := fmt.Sprintf("Extract%d", index)
+		instruction, result := tc.instruction()
+		if constants {
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVD $0x0123456789abcdef,R4\nMOVD $0xfedcba9876543210,R5\n", name)
+			signatures[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{
+				Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			}}
+		} else {
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVD low+0(FP),R4\nMOVD high+8(FP),R5\n", name)
+			signatures[name] = FuncSig{Name: name, Args: []LLVMType{I64, I64}, Ret: I64, Frame: FrameLayout{
+				Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+				},
+				Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+			}}
+		}
+		resultOffset := 16
+		if constants {
+			resultOffset = 0
+		}
+		fmt.Fprintf(&source, "MOVD $0x%x,R6\n%s\nMOVD %s,ret+%d(FP)\nRET\n", arm64ExtractDiscard, instruction, result, resultOffset)
+	}
+	return source.String(), signatures
+}
+
+func TestARM64EXTRPlan9SourceOrderGoEncoding(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT encoding(SB),4,$0-0\nEXTR $35,R22,R12,R8\n")
+	// The official cmd/asm arm64enc.s example's little-endian 888dd693.
+	want := []uint32{0x93d68d88}
+	for _, tc := range arm64ExtractOrderCases() {
+		instruction, _ := tc.instruction()
+		source.WriteString(instruction + "\n")
+		low, high, destination := tc.operands()
+		base := uint32(0x13800000)
+		if tc.width == 64 {
+			base = 0x93c00000
+		}
+		want = append(want, base|uint32(low)<<16|uint32(tc.shift)<<10|uint32(high)<<5|uint32(destination))
+	}
+	source.WriteString("RET\n")
+	want = append(want, 0xd65f03c0)
+	for _, goos := range []string{"linux", "darwin"} {
+		actual := arm64ImmediateOriginalGoBytes(t, source.String(), goos)
+		if len(actual) < len(want)*4 {
+			t.Fatalf("%s truncated original Go EXTR object: %d bytes", goos, len(actual))
+		}
+		for index, word := range want {
+			if got := binary.LittleEndian.Uint32(actual[index*4:]); got != word {
+				t.Fatalf("%s original Go EXTR word %d = %08x, want %08x", goos, index, got, word)
+			}
+		}
+	}
+}
+
+func TestARM64EXTRPlan9SourceOrderValues(t *testing.T) {
+	source, signatures := arm64ExtractOrderSource(true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, Options{
+		Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple, Sigs: signatures,
+		ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	options.SetVerifyEach(true)
+	if err := module.RunPasses("function(sroa,mem2reg,instcombine,simplifycfg)", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for index, tc := range arm64ExtractOrderCases() {
+		t.Run(fmt.Sprintf("width%d/shift%d/%s", tc.width, tc.shift, tc.form), func(t *testing.T) {
+			fn := module.NamedFunction(fmt.Sprintf("Extract%d", index))
+			if fn.IsNil() {
+				t.Fatal("missing complete numerical fixture")
+			}
+			returns := 0
+			want := tc.oracle(0x0123456789abcdef, 0xfedcba9876543210)
+			for block := fn.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+				for inst := block.FirstInstruction(); !inst.IsNil(); inst = llvm.NextInstruction(inst) {
+					if inst.InstructionOpcode() != llvm.Ret {
+						continue
+					}
+					returns++
+					if inst.OperandsCount() != 1 || inst.Operand(0).Type() != ctx.Int64Type() ||
+						inst.Operand(0).IsAConstantInt().IsNil() || inst.Operand(0).ZExtValue() != want {
+						t.Fatalf("%s: numerical return = %s, want %016x", fn.Name(), inst.String(), want)
+					}
+				}
+			}
+			if returns != 1 {
+				t.Fatalf("expected one numerical return, got %d", returns)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64EXTRPlan9SourceOrder(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, signatures := arm64ExtractOrderSource(false)
+	var goDecls, goRows, cDecls, cRows strings.Builder
+	forms := map[string]int{"distinct": 0, "alias-low": 0, "alias-high": 0,
+		"same-source": 1, "ror-explicit": 1, "ror-inplace": 1, "zero-low": 2, "zero-high": 3, "discard": 4}
+	for index, tc := range arm64ExtractOrderCases() {
+		name := fmt.Sprintf("Extract%d", index)
+		fmt.Fprintf(&goDecls, "func %s(uint64,uint64) uint64\n", name)
+		fmt.Fprintf(&goRows, "{%s,%d,%d,%d},\n", name, tc.width, tc.shift, forms[tc.form])
+		fmt.Fprintf(&cDecls, "extern uint64_t %s(uint64_t,uint64_t);\n", name)
+		fmt.Fprintf(&cRows, "{%s,%d,%d,%d},\n", name, tc.width, tc.shift, forms[tc.form])
+	}
+	// The unchanged source executes first under the actual Go assembler and
+	// compiler. These bit-selection oracles do not repeat LLVM's shift/or IR.
+	goMain := "package main\n" + goDecls.String() + arm64ExtractGoOracle +
+		"var probes = []probe{\n" + goRows.String() + "}\n"
+	runARM64GoInternalOracle(t, source, goMain, len(runner) != 0)
+	cMain := arm64ExtractCOracle + cDecls.String() + "static struct probe probes[] = {\n" + cRows.String() + "};\n" + arm64ExtractCMain
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	pkg := mustGoPackage(t, "test/extrorder", "package extrorder\n"+goDecls.String())
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: signatures, ResolveSym: resolve}
+			var ir string
+			switch api {
+			case "text":
+				ir, err = Translate(file, options)
+			case "module":
+				var module llvm.Module
+				module, err = TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+					ir = module.String()
+				}
+			case "GoModule":
+				var translated *GoModuleTranslation
+				translated, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+				})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+					ir = translated.Module.String()
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimization := range []int{0, 2} {
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "extract_order", triple, ir, cMain, runner, optimization)
+			}
+		})
+	}
+	t.Logf("%d complete EXTR/EXTRW/ROR rows x 64 original input pairs; actual Go and three APIs, LLVM O0/O2", len(arm64ExtractOrderCases()))
+}
+
+const arm64ExtractGoOracle = `
+type probe struct { call func(uint64,uint64) uint64; width,shift,mode uint }
+func expected(p probe, low,high uint64) uint64 {
+  switch p.mode { case 1: high=low; case 2: low=0; case 3: high=0; case 4: return 0xd00df00dbaadbeef }
+  var result uint64
+  for bit:=uint(0); bit<p.width; bit++ {
+    position:=p.shift+bit
+    value:=low
+    if position>=p.width { value=high; position-=p.width }
+    if (value>>position)&1!=0 { result |= uint64(1)<<bit }
+  }
+  return result
+}
+func main() {
+  values:=[]uint64{0,1,^uint64(0),0x0123456789abcdef,0xfedcba9876543210,1<<63,0xffffffff,0xffffffff00000000}
+  for _,p:=range probes { for _,a:=range values { for _,b:=range values {
+    if p.call(a,b)!=expected(p,a,b) { panic("original Go EXTR source-order/value mismatch") }
+  } } }
+}
+`
+
+const arm64ExtractCOracle = `#include <stdint.h>
+#include <stdio.h>
+struct probe { uint64_t (*call)(uint64_t,uint64_t); unsigned width,shift,mode; };
+static uint64_t expected(struct probe p,uint64_t low,uint64_t high) {
+  switch(p.mode) { case 1: high=low; break; case 2: low=0; break; case 3: high=0; break; case 4: return UINT64_C(0xd00df00dbaadbeef); }
+  uint64_t result=0;
+  for(unsigned bit=0;bit<p.width;bit++) {
+    unsigned position=p.shift+bit;
+    uint64_t value=low;
+    if(position>=p.width) { value=high; position-=p.width; }
+    if((value>>position)&1) result |= UINT64_C(1)<<bit;
+  }
+  return result;
+}
+`
+
+const arm64ExtractCMain = `int main(void) {
+  const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(1)<<63,UINT64_C(0xffffffff),UINT64_C(0xffffffff00000000)};
+  for(unsigned i=0;i<sizeof(probes)/sizeof(probes[0]);i++) {
+    for(unsigned a=0;a<8;a++) for(unsigned b=0;b<8;b++) {
+      uint64_t want=expected(probes[i],values[a],values[b]);
+      uint64_t got=probes[i].call(values[a],values[b]);
+      if(got!=want) {
+        fprintf(stderr,"EXTR row=%u width=%u shift=%u mode=%u a=%llx b=%llx got=%llx want=%llx\n",i,probes[i].width,probes[i].shift,probes[i].mode,(unsigned long long)values[a],(unsigned long long)values[b],(unsigned long long)got,(unsigned long long)want);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_fixed_gp_float_runtime_test.go b/arm64_fixed_gp_float_runtime_test.go
new file mode 100644
index 000000000..0e070fcf9
--- /dev/null
+++ b/arm64_fixed_gp_float_runtime_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64FixedGPFloatRuntime(t *testing.T, triple string) (string, string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"scvtf", "ucvtf"} {
+		for _, integerBits := range []int{32, 64} {
+			for _, floatBits := range []int{32, 64} {
+				for _, fractionalBits := range []int{1, integerBits / 2, integerBits} {
+					name := fmt.Sprintf("%s_%d_%d_%d", op, integerBits, floatBits, fractionalBits)
+					gp := map[int]string{32: "w", 64: "x"}[integerBits]
+					fp := map[int]string{32: "s", 64: "d"}[floatBits]
+					instruction := fmt.Sprintf("%s %s31, %s0, #%d", op, fp, gp, fractionalBits)
+					word := assembleARM64LLVMWords(t, []string{instruction}, "")[0]
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVD input+0(FP),R0\nMOVD out+8(FP),R1\nWORD $%#08x\nVST1 [V31.B16],(R1)\nRET\n", name, word)
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{I64, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(uint64_t, void *);\n", name)
+					oracle := fmt.Sprintf("%s %s31, %%%s[input], #%d\\n\\tstr q31, [%%[out]]", op, fp, gp, fractionalBits)
+					fmt.Fprintf(&checks, `    {
+      unsigned char got[16], want[16];
+      memset(got, 0xff, sizeof(got));
+      __asm__ volatile("%s" :: [input]"r"(input), [out]"r"(want) : "v31", "memory");
+      %s(input, got);
+      if (memcmp(got, want, sizeof(got))) return %d;
+    }
+`, oracle, name, len(sigs))
+				}
+			}
+		}
+	}
+	main := "#include <stdint.h>\n#include <string.h>\n" + declarations.String() + `
+int main(void) {
+  const uint64_t inputs[] = {0, 1, UINT64_MAX, 0x8000000000000000ULL,
+    0x7fffffffffffffffULL, 0x80000000, 0xffffffff, 0x01000001,
+    0x0123456789abcdefULL, 0x76543210fedcba98ULL};
+  for (unsigned i = 0; i < sizeof(inputs)/sizeof(inputs[0]); i++) {
+    uint64_t input = inputs[i];
+` + checks.String() + "  }\n  return 0;\n}\n"
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir, main
+}
+
+func TestARM64FixedGPFloatRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64FixedGPFloatRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "fixed_gp.ll", "fixed_gp.o", ir)
+			native := runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" ||
+				runtime.GOOS == "linux" && triple == "aarch64-unknown-linux-gnu"
+			if runtime.GOARCH == "arm64" && native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "fixed_gp", triple, ir, main, nil)
+			}
+		})
+	}
+}
diff --git a/arm64_flag_scratch_bank_test.go b/arm64_flag_scratch_bank_test.go
new file mode 100644
index 000000000..df9bd400c
--- /dev/null
+++ b/arm64_flag_scratch_bank_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64FlagScratchBankFixture() (*arm64Ctx, *arm64MachineAvailability) {
+	flow := &arm64MachineAvailability{
+		blocks: []arm64MachineBlock{{name: "entry"}},
+		source: "unmodeled native callout", sourceScratch: true,
+	}
+	return &arm64Ctx{
+		b: &strings.Builder{}, machineAvailability: flow,
+		flagsNSlot: "%nzcv_N", flagsZSlot: "%nzcv_Z", flagsCSlot: "%nzcv_C", flagsVSlot: "%nzcv_V",
+		flagsKnown: arm64FlagAll, flagsWritten: true,
+	}, flow
+}
+
+func TestARM64FlagScratchBankDoesNotInventOriginalGPScratch(t *testing.T) {
+	ctx, flow := arm64FlagScratchBankFixture()
+	fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+	ctx.recordMachineOpaqueIR(0, Instr{})
+	if ctx.flagsKnown != 0 || ctx.flagsWritten || len(flow.blocks[0].effects) != 5 {
+		t.Fatalf("native callout did not revoke four flags before its opaque effect: %+v", flow.blocks[0].effects)
+	}
+	if err := flow.validateSourceScratch(); err != nil {
+		t.Fatalf("virtual NZCV became a missing original Go GP scratch: %v", err)
+	}
+}
+
+func TestARM64FlagScratchBankRetainsPhysicalGPScratch(t *testing.T) {
+	for _, register := range []Reg{"R27", "R1"} {
+		t.Run(string(register), func(t *testing.T) {
+			ctx, flow := arm64FlagScratchBankFixture()
+			ctx.recordMachineUnavailable(register)
+			fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+			ctx.recordMachineOpaqueIR(0, Instr{})
+			if err := flow.validateSourceScratch(); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "native effects can observe an unbound original Go memory scratch") {
+				t.Fatalf("native callout manufactured physical %s scratch: %v", register, err)
+			}
+		})
+	}
+}
+
+func TestARM64FlagScratchBankRetainsOrderedFlagRejection(t *testing.T) {
+	for _, flag := range []struct {
+		condition string
+		mask      uint8
+	}{
+		{"MI", 0x8}, {"EQ", 0x4}, {"CS", 0x2}, {"VS", 0x1},
+	} {
+		t.Run(flag.condition, func(t *testing.T) {
+			ctx, flow := arm64FlagScratchBankFixture()
+			ctx.flagFlow = &arm64FlagFlow{blocks: []arm64FlagFlowBlock{{name: "entry"}}}
+			ctx.setFlagsSub("10", "4", "6")
+			start := ctx.b.Len()
+			fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+			ctx.recordMachineOpaqueIR(start, Instr{})
+			if _, err := ctx.condValue(flag.condition); err != nil {
+				t.Fatal(err)
+			}
+			if err := flow.validateSourceScratch(); err != nil {
+				t.Fatalf("virtual flag read entered original GP scratch analysis: %v", err)
+			}
+			witness := fmt.Sprintf("condition %s has unknown NZCV bits %#x", flag.condition, flag.mask)
+			if err := ctx.flagFlow.validate(); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), witness) {
+				t.Fatalf("native callout manufactured ordered %s flag bits: %v", flag.condition, err)
+			}
+		})
+	}
+}
+
+func TestARM64FlagScratchBankTagsActualReadWriteAndUnavailable(t *testing.T) {
+	ctx, flow := arm64FlagScratchBankFixture()
+	for _, flag := range []struct {
+		slot string
+		mask arm64FlagMask
+	}{
+		{ctx.flagsNSlot, arm64FlagN}, {ctx.flagsZSlot, arm64FlagZ},
+		{ctx.flagsCSlot, arm64FlagC}, {ctx.flagsVSlot, arm64FlagV},
+	} {
+		ctx.storeFlag(flag.slot, "true")
+		ctx.recordMachineRegister(Reg(flag.slot), 1, false)
+		ctx.recordMachineUnavailable(Reg(flag.slot))
+		for _, effect := range flow.blocks[0].effects[len(flow.blocks[0].effects)-3:] {
+			if effect.nzcv != flag.mask || effect.width != 1 || effect.register != flag.slot {
+				t.Fatalf("actual flag hook lost its typed bank: %+v", effect)
+			}
+		}
+	}
+	ctx.recordMachineUnavailable("R27")
+	ctx.recordMachineRegister("R1", 64, false)
+	ctx.recordMachineRegister("R1", 64, true)
+	for _, effect := range flow.blocks[0].effects[len(flow.blocks[0].effects)-3:] {
+		if effect.nzcv != 0 || effect.width != 64 {
+			t.Fatalf("physical GP effect acquired a virtual flag bank: %+v", effect)
+		}
+	}
+	ctx.regSlot = map[Reg]string{"R27": "%r27", "R1": "%r1"}
+	if err := ctx.lowerMachineRegisterCopy("R27", "R1"); err != nil {
+		t.Fatal(err)
+	}
+	copy := flow.blocks[0].effects[len(flow.blocks[0].effects)-1]
+	if copy.nzcv != 0 || copy.copyFrom != "R27" || copy.register != "R1" || copy.width != 64 {
+		t.Fatalf("validated physical GP copy acquired a virtual flag bank: %+v", copy)
+	}
+}
+
+func TestARM64FlagScratchBankRetainsMachineDefinedness(t *testing.T) {
+	for _, slot := range []string{"%nzcv_N", "%nzcv_Z", "%nzcv_C", "%nzcv_V"} {
+		t.Run(slot, func(t *testing.T) {
+			ctx, flow := arm64FlagScratchBankFixture()
+			flow.used, flow.entry = true, &ARM64GoRegisterABI{}
+			ctx.invalidateARM64Flags(arm64FlagAll)
+			ctx.recordMachineRegister(Reg(slot), 1, false)
+			if err := flow.validateSourceScratch(); err != nil {
+				t.Fatalf("virtual flag entered physical GP scratch analysis: %v", err)
+			}
+			witness := slot + " read (1 bits) is not supplied"
+			if err := flow.validate(); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), witness) {
+				t.Fatalf("virtual flag bank bypassed machine must-defined analysis: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_flags.go b/arm64_flags.go
index e58736655..5e356026a 100644
--- a/arm64_flags.go
+++ b/arm64_flags.go
@@ -6,10 +6,93 @@ import (
 )
 
 func (c *arm64Ctx) storeFlag(slot string, v string) {
+	mask := c.arm64FlagSlotMask(slot)
+	c.flagsKnown |= mask
+	if c.flagFlow != nil {
+		block := &c.flagFlow.blocks[c.flagFlow.current]
+		block.effects = append(block.effects, arm64FlagEffect{write: mask})
+	}
+	c.recordMachineRegister(Reg(slot), 1, true)
 	fmt.Fprintf(c.b, "  store i1 %s, ptr %s\n", v, slot)
 }
 
+func (c *arm64Ctx) arm64FlagSlotMask(slot string) arm64FlagMask {
+	switch slot {
+	case c.flagsNSlot:
+		return arm64FlagN
+	case c.flagsZSlot:
+		return arm64FlagZ
+	case c.flagsCSlot:
+		return arm64FlagC
+	case c.flagsVSlot:
+		return arm64FlagV
+	}
+	return 0
+}
+
+func (c *arm64Ctx) invalidateARM64Flags(mask arm64FlagMask) {
+	c.flagsKnown &^= mask
+	if mask != 0 {
+		c.flagsWritten = false
+	}
+	if c.flagFlow != nil {
+		block := &c.flagFlow.blocks[c.flagFlow.current]
+		block.effects = append(block.effects, arm64FlagEffect{invalidate: mask})
+	}
+	for _, slot := range []string{c.flagsNSlot, c.flagsZSlot, c.flagsCSlot, c.flagsVSlot} {
+		if c.arm64FlagSlotMask(slot)&mask != 0 {
+			c.recordMachineUnavailable(Reg(slot))
+		}
+	}
+}
+
+func (c *arm64Ctx) requireARM64Flags(mask arm64FlagMask, condition string) error {
+	if mask == 0 {
+		return nil
+	}
+	if c.flagFlow != nil {
+		block := &c.flagFlow.blocks[c.flagFlow.current]
+		block.effects = append(block.effects, arm64FlagEffect{read: mask, condition: condition})
+		return nil // A complete reaching write may appear later in source order.
+	}
+	known := c.flagsKnown
+	if c.flagsWritten {
+		known = arm64FlagAll
+	}
+	if mask&^known != 0 {
+		return fmt.Errorf("%w: arm64 condition %s has no prior flags write", ErrProbeNeedsContext, condition)
+	}
+	return nil
+}
+
+func arm64ConditionFlags(condition string) (arm64FlagMask, error) {
+	switch strings.ToUpper(condition) {
+	case "EQ", "NE":
+		return arm64FlagZ, nil
+	case "CS", "HS", "LO", "CC":
+		return arm64FlagC, nil
+	case "HI", "LS":
+		return arm64FlagC | arm64FlagZ, nil
+	case "LT", "GE":
+		return arm64FlagN | arm64FlagV, nil
+	case "GT", "LE":
+		return arm64FlagN | arm64FlagV | arm64FlagZ, nil
+	case "MI", "PL":
+		return arm64FlagN, nil
+	case "VS", "VC":
+		return arm64FlagV, nil
+	case "AL", "NV":
+		return 0, nil
+	default:
+		return 0, fmt.Errorf("arm64: unsupported condition %q", condition)
+	}
+}
+
 func (c *arm64Ctx) setFlagsSub(dst, src, res string) {
+	c.setFlagsSubWithCarry(dst, src, res, "")
+}
+
+func (c *arm64Ctx) setFlagsSubWithCarry(dst, src, res, carryValue string) {
 	// NZCV for subtraction:
 	// Z: res==0
 	// N: res<0 (signed)
@@ -21,8 +104,12 @@ func (c *arm64Ctx) setFlagsSub(dst, src, res string) {
 	fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", z, res)
 	n := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %s, 0\n", n, res)
-	carry := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp uge i64 %s, %s\n", carry, dst, src)
+	carry := carryValue
+	if carry == "" {
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp uge i64 %s, %s\n", t, dst, src)
+		carry = "%" + t
+	}
 
 	// overflow = ((dst ^ src) & (dst ^ res)) < 0
 	x1 := c.newTmp()
@@ -36,11 +123,15 @@ func (c *arm64Ctx) setFlagsSub(dst, src, res string) {
 
 	c.storeFlag(c.flagsZSlot, "%"+z)
 	c.storeFlag(c.flagsNSlot, "%"+n)
-	c.storeFlag(c.flagsCSlot, "%"+carry)
+	c.storeFlag(c.flagsCSlot, carry)
 	c.storeFlag(c.flagsVSlot, "%"+ov)
 }
 
 func (c *arm64Ctx) setFlagsSub32(dst, src, res string) {
+	c.setFlagsSub32WithCarry(dst, src, res, "")
+}
+
+func (c *arm64Ctx) setFlagsSub32WithCarry(dst, src, res, carryValue string) {
 	// SUBSW computes NZCV from the low 32 bits, before the architectural
 	// zero-extension of the result into the 64-bit register file.
 	c.flagsWritten = true
@@ -49,8 +140,12 @@ func (c *arm64Ctx) setFlagsSub32(dst, src, res string) {
 	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", z, res)
 	n := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %s, 0\n", n, res)
-	carry := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp uge i32 %s, %s\n", carry, dst, src)
+	carry := carryValue
+	if carry == "" {
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp uge i32 %s, %s\n", t, dst, src)
+		carry = "%" + t
+	}
 	x1 := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = xor i32 %s, %s\n", x1, dst, src)
 	x2 := c.newTmp()
@@ -62,11 +157,15 @@ func (c *arm64Ctx) setFlagsSub32(dst, src, res string) {
 
 	c.storeFlag(c.flagsZSlot, "%"+z)
 	c.storeFlag(c.flagsNSlot, "%"+n)
-	c.storeFlag(c.flagsCSlot, "%"+carry)
+	c.storeFlag(c.flagsCSlot, carry)
 	c.storeFlag(c.flagsVSlot, "%"+ov)
 }
 
 func (c *arm64Ctx) setFlagsAdd(dst, src, res string) {
+	c.setFlagsAddWithCarry(dst, src, res, "")
+}
+
+func (c *arm64Ctx) setFlagsAddWithCarry(dst, src, res, carryValue string) {
 	// NZCV for addition:
 	// Z: res==0
 	// N: res<0 (signed)
@@ -78,8 +177,12 @@ func (c *arm64Ctx) setFlagsAdd(dst, src, res string) {
 	fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", z, res)
 	n := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %s, 0\n", n, res)
-	carry := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %s\n", carry, res, dst)
+	carry := carryValue
+	if carry == "" {
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %s\n", t, res, dst)
+		carry = "%" + t
+	}
 
 	// overflow = (~(dst ^ src) & (dst ^ res)) < 0
 	x1 := c.newTmp()
@@ -95,7 +198,42 @@ func (c *arm64Ctx) setFlagsAdd(dst, src, res string) {
 
 	c.storeFlag(c.flagsZSlot, "%"+z)
 	c.storeFlag(c.flagsNSlot, "%"+n)
-	c.storeFlag(c.flagsCSlot, "%"+carry)
+	c.storeFlag(c.flagsCSlot, carry)
+	c.storeFlag(c.flagsVSlot, "%"+ov)
+}
+
+func (c *arm64Ctx) setFlagsAdd32(dst, src, res string) {
+	c.setFlagsAdd32WithCarry(dst, src, res, "")
+}
+
+func (c *arm64Ctx) setFlagsAdd32WithCarry(dst, src, res, carryValue string) {
+	// ADDSW/CMNW compute flags from the low 32-bit sum.
+	c.flagsWritten = true
+
+	z := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", z, res)
+	n := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %s, 0\n", n, res)
+	carry := carryValue
+	if carry == "" {
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %s, %s\n", t, res, dst)
+		carry = "%" + t
+	}
+	x1 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i32 %s, %s\n", x1, dst, src)
+	nx1 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i32 %%%s, -1\n", nx1, x1)
+	x2 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i32 %s, %s\n", x2, dst, res)
+	x3 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %%%s\n", x3, nx1, x2)
+	ov := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %%%s, 0\n", ov, x3)
+
+	c.storeFlag(c.flagsZSlot, "%"+z)
+	c.storeFlag(c.flagsNSlot, "%"+n)
+	c.storeFlag(c.flagsCSlot, carry)
 	c.storeFlag(c.flagsVSlot, "%"+ov)
 }
 
@@ -181,22 +319,24 @@ func (c *arm64Ctx) setFlagsLogic32(res string) {
 }
 
 func (c *arm64Ctx) condValue(cond string) (string, error) {
-	if !c.flagsWritten {
-		return "", fmt.Errorf("%w: arm64 condition %s has no prior flags write", ErrProbeNeedsContext, cond)
+	mask, err := arm64ConditionFlags(cond)
+	if err != nil {
+		return "", err
 	}
-	ldN := c.newTmp()
-	ldZ := c.newTmp()
-	ldC := c.newTmp()
-	ldV := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", ldN, c.flagsNSlot)
-	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", ldZ, c.flagsZSlot)
-	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", ldC, c.flagsCSlot)
-	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", ldV, c.flagsVSlot)
-
-	n := "%" + ldN
-	z := "%" + ldZ
-	carry := "%" + ldC
-	v := "%" + ldV
+	if err := c.requireARM64Flags(mask, cond); err != nil {
+		return "", err
+	}
+	load := func(slot string) string {
+		if c.arm64FlagSlotMask(slot)&mask == 0 {
+			return "" // Never load unknown bits which this predicate does not read.
+		}
+		c.recordMachineRegister(Reg(slot), 1, false)
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", value, slot)
+		return "%" + value
+	}
+	n, z := load(c.flagsNSlot), load(c.flagsZSlot)
+	carry, v := load(c.flagsCSlot), load(c.flagsVSlot)
 
 	not := func(x string) string {
 		t := c.newTmp()
@@ -263,3 +403,10 @@ func (c *arm64Ctx) condValue(cond string) (string, error) {
 		return "", fmt.Errorf("arm64: unsupported condition %q", cond)
 	}
 }
+
+type arm64Flags struct {
+	kind  string // "cmp" or "res"
+	dst   string // i64 SSA or constant
+	src   string // i64 SSA or constant (for cmp)
+	width LLVMType
+}
diff --git a/arm64_flags_flow.go b/arm64_flags_flow.go
new file mode 100644
index 000000000..429357275
--- /dev/null
+++ b/arm64_flags_flow.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import "fmt"
+
+type arm64FlagMask uint8
+
+const (
+	arm64FlagV arm64FlagMask = 1 << iota
+	arm64FlagC
+	arm64FlagZ
+	arm64FlagN
+	arm64FlagAll = arm64FlagN | arm64FlagZ | arm64FlagC | arm64FlagV
+)
+
+type arm64FlagEffect struct {
+	read, write, invalidate arm64FlagMask
+	condition               string
+}
+
+// Record effects from lowering rather than duplicate the named/raw/SVE opcode
+// tables. An incoming flag value is needed only for a read before a local write.
+type arm64FlagFlowBlock struct {
+	name       string
+	successors []string
+	effects    []arm64FlagEffect
+	indirect   bool
+	returns    bool
+}
+
+type arm64FlagFlow struct {
+	current       int
+	blocks        []arm64FlagFlowBlock
+	indices       map[string]int
+	continuations []int
+}
+
+func newARM64FlagFlow(blocks []arm64Block) *arm64FlagFlow {
+	flow := &arm64FlagFlow{
+		blocks:  make([]arm64FlagFlowBlock, len(blocks)),
+		indices: make(map[string]int, len(blocks)),
+	}
+	for i, block := range blocks {
+		flow.blocks[i].name = block.name
+		flow.indices[block.name] = i
+		if i+1 < len(blocks) && len(block.instrs) != 0 && arm64IsLocalBranchLink(block.instrs[len(block.instrs)-1]) {
+			flow.continuations = append(flow.continuations, i+1)
+		}
+	}
+	return flow
+}
+
+func (c *arm64Ctx) recordARM64FlagFlowEdges(targets ...string) {
+	if flow := c.machineAvailability; flow != nil && !flow.flagsOnly {
+		block := &flow.blocks[flow.current]
+		block.successors = append(block.successors, targets...)
+	}
+	if c.flagFlow != nil {
+		block := &c.flagFlow.blocks[c.flagFlow.current]
+		block.successors = append(block.successors, targets...)
+	}
+}
+
+func (c *arm64Ctx) emitPredicateBranch(predicate, target, fall string) {
+	c.recordARM64FlagFlowEdges(target, fall)
+	fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n", predicate, arm64LLVMBlockName(target), arm64LLVMBlockName(fall))
+}
+
+func (flow *arm64FlagFlow) validate() error {
+	if len(flow.blocks) == 0 {
+		return nil
+	}
+	// Track each original flag independently. Partial writes cannot define the
+	// other bits, and an invalidation after a write cannot be hidden by a block
+	// summary. OR joins retain an unknown bit from any actual predecessor.
+	before := make([]arm64FlagMask, len(flow.blocks))
+	before[0] = arm64FlagAll
+	seen := make([]bool, len(flow.blocks))
+	seen[0] = true
+	queue := []int{0}
+	queued := make([]bool, len(flow.blocks))
+	queued[0] = true
+	enqueue := func(i int, unknown arm64FlagMask) {
+		changed := !seen[i] || before[i]|unknown != before[i]
+		if changed {
+			seen[i] = true
+			before[i] |= unknown
+			if !queued[i] {
+				queued[i] = true
+				queue = append(queue, i)
+			}
+		}
+	}
+	indirectExpanded, returnsExpanded := false, false
+	var indirectUnknown, returnsUnknown arm64FlagMask
+	for next := 0; next < len(queue); next++ {
+		index := queue[next]
+		queued[index] = false
+		block, unknown := flow.blocks[index], before[index]
+		for _, effect := range block.effects {
+			if effect.read&unknown != 0 {
+				return fmt.Errorf("%w: arm64 condition %s has unknown NZCV bits %#x on a path to block %s",
+					ErrProbeNeedsContext, effect.condition, effect.read&unknown, block.name)
+			}
+			unknown = (unknown &^ effect.write) | effect.invalidate
+		}
+		for _, name := range block.successors {
+			i, ok := flow.indices[name]
+			if !ok {
+				// The ordinary IR verifier diagnoses undefined branch labels.
+				continue
+			}
+			enqueue(i, unknown)
+		}
+		if block.indirect && (!indirectExpanded || indirectUnknown|unknown != indirectUnknown) {
+			// A computed branch can reach an address-taken source label. Do
+			// not misclassify its destination as unreachable. Expand once so
+			// multiple indirect branches cannot create quadratic work.
+			indirectExpanded = true
+			indirectUnknown |= unknown
+			for i := range flow.blocks {
+				enqueue(i, unknown)
+			}
+		}
+		if block.returns && (!returnsExpanded || returnsUnknown|unknown != returnsUnknown) {
+			returnsExpanded = true
+			returnsUnknown |= unknown
+			for _, i := range flow.continuations {
+				enqueue(i, unknown)
+			}
+		}
+	}
+	return nil
+}
diff --git a/arm64_flags_flow_test.go b/arm64_flags_flow_test.go
new file mode 100644
index 000000000..2a678f5e7
--- /dev/null
+++ b/arm64_flags_flow_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"runtime"
+	"testing"
+)
+
+const arm64BackwardFlagsSource = `
+TEXT delayedFlags(SB),4,$0-24
+    MOVD a+0(FP), R0
+    MOVD b+8(FP), R1
+    JMP compare
+use:
+    CSET LO, R2
+    MOVD R2, ret+16(FP)
+    RET
+compare:
+    CMP R1, R0
+    JMP use
+`
+
+func arm64BackwardFlagsSig() FuncSig {
+	return FuncSig{
+		Name: "delayedFlags", Args: []LLVMType{I64, I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			},
+			Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+		},
+	}
+}
+
+func TestARM64FlagsFollowControlFlowNotSourceOrder(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64BackwardFlagsSource, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64BackwardFlagsSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"delayedFlags": arm64BackwardFlagsSig()},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "flags.ll", "flags.o", ir)
+		})
+	}
+}
+
+func TestARM64FlagsRejectUninitializedControlFlowPaths(t *testing.T) {
+	for _, read := range []string{
+		"CSET LO, R1",
+		"CSEL LO, R1, R2, R3",
+		"CCMP LO, R1, R2, $0",
+		"BCC done",
+	} {
+		for _, entry := range []string{
+			"JMP use", "CBZ R0, use", "CBNZ R0, use", "CBZW R0, use",
+			"CBNZW R0, use", "TBZ $0, R0, use", "TBNZ $0, R0, use",
+		} {
+			t.Run(entry+"/"+read, func(t *testing.T) {
+				// A lexical flag write in another path must not make a read
+				// valid on the direct entry -> use path.
+				source := "TEXT missing(SB),4,$0-0\n" + entry + "\nCMP $1, R0\nuse:\n" + read + "\ndone:\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{
+					Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"missing": {Name: "missing", Ret: Void}},
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("uninitialized flag path: got %v, want ErrProbeNeedsContext", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64ConformanceBackwardFlagFlow(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("arm64 native execution or the required Linux cross-runtime matrix")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler := []string{findLLVM22Tool("clang")}
+	var runner []string
+	if cross {
+		triple = "aarch64-unknown-linux-gnu"
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	file, err := Parse(ArchARM64, arm64BackwardFlagsSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"delayedFlags": arm64BackwardFlagsSig()},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern uint64_t delayedFlags(uint64_t, uint64_t);
+int main(void) {
+    uint64_t values[] = {0, 1, 2, UINT64_MAX, UINT64_MAX / 2, UINT64_MAX / 2 + 1};
+    for (unsigned i = 0; i < 6; i++) {
+        for (unsigned j = 0; j < 6; j++) {
+            if (delayedFlags(values[i], values[j]) != (values[i] < values[j])) return 1;
+        }
+    }
+    return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "backward-flags", triple, ir, mainC, runner)
+}
+
+func TestARM64FlagsRejectIndirectAndLocalReturnPaths(t *testing.T) {
+	for _, source := range []string{
+		"TEXT missing(SB),4,$0-0\nADR use, R0\nJMP (R0)\nuse:\nCSET LO, R1\nRET\n",
+		"TEXT missing(SB),4,$0-0\nBL helper\nCSET LO, R1\nRET\nhelper:\nRET\n",
+	} {
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{
+			Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"missing": {Name: "missing", Ret: Void}},
+		})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("indirect flag path: got %v, want ErrProbeNeedsContext", err)
+		}
+	}
+}
diff --git a/arm64_form_continuation_test.go b/arm64_form_continuation_test.go
new file mode 100644
index 000000000..65a665c25
--- /dev/null
+++ b/arm64_form_continuation_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestARM64OperandProbesDoNotInventRestoredSPOrLR(t *testing.T) {
+	for _, instruction := range []string{
+		"BIC $255,R0,RSP",
+		"ORN $255,R0,RSP",
+		"ADRP target,R30",
+		"WORD $0x4e042c1e", // SMOV V0.S[0], LR really writes GP30.
+		"VST1.P [V0.B16],16(RSP)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT form(SB),4,$0-0\n" + instruction + "\ntarget:\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+			} {
+				if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"form": {Name: "form", Ret: Void}},
+				}); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: an unrestored caller continuation must need context, got %v", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64SymbolTailHasWholeFunctionContinuationProof(t *testing.T) {
+	const source = "TEXT caller(SB),4,$0-0\nB sink(SB)\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"caller": {Name: "caller", Ret: Void}, "sink": {Name: "sink", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "proven-tail.ll", "proven-tail.o", ir)
+		})
+	}
+}
diff --git a/arm64_fp.go b/arm64_fp.go
index f067d64e8..967151a7c 100644
--- a/arm64_fp.go
+++ b/arm64_fp.go
@@ -11,6 +11,16 @@ func (c *arm64Ctx) fpResultSlotByOffset(off int64) (slot FrameSlot, ok bool) {
 	return FrameSlot{}, false
 }
 
+func (c *arm64Ctx) loadFPParameter(slot FrameSlot) (string, error) {
+	p, ok := c.fpParamAlloca[slot.Offset]
+	if !ok {
+		return "", fmt.Errorf("arm64: missing FP parameter alloca for +%d(FP)", slot.Offset)
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s\n", value, slot.Type, p)
+	return "%" + value, nil
+}
+
 func (c *arm64Ctx) markFPResultWritten(off int64) {
 	if s, ok := c.fpResultSlotByOffset(off); ok {
 		c.fpResWritten[s.Index] = true
@@ -25,38 +35,50 @@ func (c *arm64Ctx) markFPResultAddrTaken(off int64) {
 
 func (c *arm64Ctx) storeFPResult64(off int64, v64 string) error {
 	slot, ok := c.fpResAllocaOff[off]
+	meta, isResult := c.fpResultSlotByOffset(off)
 	if !ok {
-		return fmt.Errorf("arm64: unsupported FP result slot +%d(FP)", off)
+		slot, ok = c.fpParamAlloca[off]
+		var found bool
+		meta, found = c.fpParams[off]
+		if !ok || !found {
+			return fmt.Errorf("arm64: unsupported FP slot +%d(FP)", off)
+		}
 	}
-	// Find the element type via FrameSlot.
-	meta, found := c.fpResultSlotByOffset(off)
-	if !found {
-		return fmt.Errorf("arm64: missing FP result metadata for +%d(FP)", off)
+	if meta.Type == "" {
+		return fmt.Errorf("arm64: unsupported FP slot +%d(FP)", off)
 	}
 	ty := meta.Type
 
 	switch string(ty) {
 	case "i64":
 		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", v64, slot)
-		c.markFPResultWritten(off)
+		if isResult {
+			c.markFPResultWritten(off)
+		}
 		return nil
 	case "i32", "i16", "i8", "i1":
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", t, v64, ty)
 		fmt.Fprintf(c.b, "  store %s %%%s, ptr %s\n", ty, t, slot)
-		c.markFPResultWritten(off)
+		if isResult {
+			c.markFPResultWritten(off)
+		}
 		return nil
 	case "ptr":
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", t, v64)
 		fmt.Fprintf(c.b, "  store ptr %%%s, ptr %s\n", t, slot)
-		c.markFPResultWritten(off)
+		if isResult {
+			c.markFPResultWritten(off)
+		}
 		return nil
 	case "double":
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", t, v64)
 		fmt.Fprintf(c.b, "  store double %%%s, ptr %s\n", t, slot)
-		c.markFPResultWritten(off)
+		if isResult {
+			c.markFPResultWritten(off)
+		}
 		return nil
 	case "float":
 		t := c.newTmp()
@@ -64,7 +86,9 @@ func (c *arm64Ctx) storeFPResult64(off int64, v64 string) error {
 		b := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", b, t)
 		fmt.Fprintf(c.b, "  store float %%%s, ptr %s\n", b, slot)
-		c.markFPResultWritten(off)
+		if isResult {
+			c.markFPResultWritten(off)
+		}
 		return nil
 	default:
 		return fmt.Errorf("arm64: unsupported FP result slot type %q", ty)
diff --git a/arm64_fp_access.go b/arm64_fp_access.go
new file mode 100644
index 000000000..d3678ebb3
--- /dev/null
+++ b/arm64_fp_access.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+// ARM64FPAccessBytes describes the complete byte width of a wide FP memory
+// operand. It lets assembly-only signature inference retain every accessed
+// word, rather than just the offset written in source. It is not a Go
+// declaration or permission to access padding in a declaration-backed frame.
+// Unknown and malformed forms return zero; translation still validates every
+// operand and the complete supplied frame layout independently.
+func ARM64FPAccessBytes(ins Instr, operand int) int64 {
+	if len(ins.Args) != 2 || operand < 0 || operand >= len(ins.Args) ||
+		ins.Args[operand].Kind != OpFP {
+		return 0
+	}
+	var width int64
+	if spec, ok := arm64IntegerPairSpecs[ins.Op]; ok {
+		memoryIndex := 1
+		if spec.load {
+			memoryIndex = 0
+		}
+		pair := ins.Args[1-memoryIndex]
+		if operand != memoryIndex || pair.Kind != OpRegList || len(pair.RegList) != 2 {
+			return 0
+		}
+		for _, reg := range pair.RegList {
+			if !isARM64GeneralOrZeroReg(reg) {
+				return 0
+			}
+		}
+		if spec.load && pair.RegList[0] == pair.RegList[1] {
+			return 0
+		}
+		width = int64(spec.elementBytes * 2)
+	} else if ins.Op == "FMOVQ" {
+		other := ins.Args[1-operand]
+		if other.Kind != OpReg {
+			return 0
+		}
+		if _, ok := arm64ParseFReg(other.Reg); !ok {
+			return 0
+		}
+		width = 16
+	}
+	const maxOffset = int64(1<<63 - 1)
+	offset := ins.Args[operand].FPOffset
+	if offset < 0 || width == 0 || offset > maxOffset-width {
+		return 0
+	}
+	return width
+}
diff --git a/arm64_fp_access_test.go b/arm64_fp_access_test.go
new file mode 100644
index 000000000..3165f5790
--- /dev/null
+++ b/arm64_fp_access_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestARM64WideFPAccessUsesCompleteIntegerPairGrammar(t *testing.T) {
+	want := map[Op]arm64IntegerPairSpec{
+		"LDP":   {elementBytes: 8, load: true},
+		"LDPW":  {elementBytes: 4, load: true},
+		"LDPSW": {elementBytes: 4, load: true, signed: true},
+		"STP":   {elementBytes: 8},
+		"STPW":  {elementBytes: 4},
+	}
+	if !reflect.DeepEqual(arm64IntegerPairSpecs, want) {
+		t.Fatalf("integer pair grammar changed: %+v", arm64IntegerPairSpecs)
+	}
+	for op, spec := range want {
+		for _, offset := range []int64{0, 1, 7, 8, 512, 16384} {
+			instruction := fmt.Sprintf("%s frame+%d(FP), (R3, R4)", op, offset)
+			memoryIndex := 0
+			if !spec.load {
+				instruction = fmt.Sprintf("%s (R3, R4), frame+%d(FP)", op, offset)
+				memoryIndex = 1
+			}
+			t.Run(instruction, func(t *testing.T) {
+				source := "TEXT span(SB),$0-20000\n" + instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				got := ARM64FPAccessBytes(file.Funcs[0].Instrs[1], memoryIndex)
+				if got != int64(spec.elementBytes*2) {
+					t.Fatalf("byte width=%d, want %d", got, spec.elementBytes*2)
+				}
+			})
+		}
+	}
+	for _, instruction := range []string{
+		"FMOVQ frame+0(FP), F0", "FMOVQ F31, frame+8(FP)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT span(SB),$0-32\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			for i, operand := range ins.Args {
+				if operand.Kind == OpFP && ARM64FPAccessBytes(ins, i) != 16 {
+					t.Fatal("quad FP memory operand lost its full sixteen-byte span")
+				}
+			}
+		})
+	}
+}
+
+func TestARM64WideFPAccessCannotInventSpansForMalformedForms(t *testing.T) {
+	for _, instruction := range []string{
+		"LDP.W frame+0(FP), (R3, R4)", "LDP.P frame+0(FP), (R3, R4)",
+		"LDP frame+0(FP), (R3, R3)", "LDP frame+0(FP), (F3, F4)",
+		"LDP frame+0(FP), R3", "LDP frame+0(FP), (R3, R4), R5",
+		"STP (F3, F4), frame+0(FP)", "LDP (R3, R4), frame+0(FP)",
+		"FMOVQ frame+0(FP), R3", "FMOVQ.W F0, frame+0(FP)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT span(SB),$0-16\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			ins := file.Funcs[0].Instrs[1]
+			for i := -1; i <= len(ins.Args); i++ {
+				if got := ARM64FPAccessBytes(ins, i); got != 0 {
+					t.Fatalf("malformed operand acquired a %d-byte span", got)
+				}
+			}
+		})
+	}
+	for _, offset := range []int64{-8, 1<<63 - 8} {
+		ins := Instr{Op: "LDP", Args: []Operand{
+			{Kind: OpFP, FPOffset: offset},
+			{Kind: OpRegList, RegList: []Reg{"R3", "R4"}},
+		}}
+		if ARM64FPAccessBytes(ins, 0) != 0 {
+			t.Fatalf("invalid/overflowing offset acquired a span: %d", offset)
+		}
+	}
+}
diff --git a/arm64_fp_control.go b/arm64_fp_control.go
new file mode 100644
index 000000000..4fffaeebf
--- /dev/null
+++ b/arm64_fp_control.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// FPCR/FPSR are native floating-point state, separate from the modeled NZCV
+// bank. Their exact register transfers have no implicit GP, SIMD or data-store
+// effects. This registration does not extend to other system registers.
+type arm64FPControlForm struct {
+	read     bool
+	encoding uint16
+	reg      Reg
+}
+
+func arm64FPControlEncoding(name string) (uint16, bool) {
+	switch name {
+	case "FPCR":
+		return 0x5a20, true
+	case "FPSR":
+		return 0x5a21, true
+	default:
+		return 0, false
+	}
+}
+
+func parseARM64FPControl(op Op, instruction Instr) (arm64FPControlForm, bool, error) {
+	if op != "MRS" && op != "MSR" {
+		return arm64FPControlForm{}, false, nil
+	}
+	matched := false
+	for _, operand := range instruction.Args {
+		if operand.Kind == OpIdent {
+			name := strings.ToUpper(operand.Ident)
+			_, known := arm64FPControlEncoding(name)
+			// Printed physical names are a raw-decoder role, not accepted Go
+			// source aliases. Claim them only to reject the malformed source.
+			matched = matched || known || name == "S3_3_C4_C4_0" || name == "S3_3_C4_C4_1"
+		}
+	}
+	if !matched {
+		return arm64FPControlForm{}, false, nil
+	}
+	bad := func() (arm64FPControlForm, bool, error) {
+		return arm64FPControlForm{}, true, fmt.Errorf("arm64 %s FPCR/FPSR requires its system-register/GP pair without a suffix: %q", op, instruction.Raw)
+	}
+	if instruction.Op != op || len(instruction.Args) != 2 {
+		return bad()
+	}
+	form := arm64FPControlForm{read: op == "MRS"}
+	system, data := instruction.Args[0], instruction.Args[1]
+	if !form.read {
+		system, data = data, system
+	}
+	var known bool
+	form.encoding, known = arm64FPControlEncoding(system.Ident)
+	if system.Kind != OpIdent || !known {
+		return bad()
+	}
+	if !form.read && data.Kind == OpImm && data.Imm == 0 && data.ImmRaw == "" && !data.ImmIsFloat {
+		// Go's C_ZCON inherits the C_ZREG case36, not the immediate PSTATE
+		// case37. No nonzero or floating immediate has this role.
+		form.reg = ZR
+	} else if data.Kind == OpReg && isARM64GeneralOrZeroReg(data.Reg) {
+		form.reg = data.Reg
+	} else {
+		return bad()
+	}
+	return form, true, nil
+}
+
+func arm64RawFPControl(form arm64RawSystemRegister) (arm64FPControlForm, bool) {
+	if form.encoding != 0x5a20 && form.encoding != 0x5a21 {
+		return arm64FPControlForm{}, false
+	}
+	register := ZR
+	if form.reg != 31 {
+		register = Reg(fmt.Sprintf("R%d", form.reg))
+	}
+	return arm64FPControlForm{form.read, form.encoding, register}, true
+}
+
+func (c *arm64Ctx) lowerARM64FPControl(form arm64FPControlForm) error {
+	if (form.encoding != 0x5a20 && form.encoding != 0x5a21) || !isARM64GeneralOrZeroReg(form.reg) {
+		return fmt.Errorf("arm64 invalid FPCR/FPSR transfer form")
+	}
+	if !arm64ScalarConversionNativeTarget(c.targetTriple) {
+		return fmt.Errorf("%w: FPCR/FPSR transfers require an explicit native little-endian AArch64 target", ErrProbeNeedsContext)
+	}
+	system := arm64EncodedSystemRegisterName(form.encoding)
+	if form.read {
+		value := c.newTmp()
+		format := "  %%%s = call i64 asm sideeffect %q, %q()\n"
+		if form.reg == "R18" || form.reg == "R28" {
+			// A physical platform/g destination still has no typed entry
+			// role. Do not remove its original opaque-machine boundary.
+			fmt.Fprintf(c.b, format, value, "mrs $0, "+system, "=r,~{memory}")
+		} else {
+			c.emitMachineNeutralNativeIR(format, value, "mrs $0, "+system, "=r,~{memory}")
+		}
+		return c.storeReg(form.reg, "%"+value)
+	}
+	value := "0"
+	if form.reg != ZR {
+		var err error
+		value, err = c.loadReg(form.reg)
+		if err != nil {
+			return err
+		}
+	}
+	// Preserve the actual write even when no later floating operation reads
+	// it. The barrier orders other native FP operations; it is not a store
+	// into the source function's private or caller memory.
+	c.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q(i64 %s)\n",
+		"msr "+system+", $0", "r,~{memory}", value)
+	return nil
+}
+
+func validateARM64FPControlTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			_, matched, err := parseARM64FPControl(arm64ControlOp(instruction), instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+			if instruction.Op != OpWORD || len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+				instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+				continue
+			}
+			if raw, valid := decodeARM64RawSystemRegister(uint32(instruction.Args[0].Imm)); valid {
+				_, matched := arm64RawFPControl(raw)
+				needsNative = needsNative || matched
+			}
+		}
+	}
+	if !needsNative {
+		return nil
+	}
+	// Only this family's files need another raw syntax pass. Check the whole
+	// source before target context, including unreachable malformed WORDs.
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if err := arm64RawWordPreflightError(instruction); err != nil {
+				return err
+			}
+		}
+	}
+	if !arm64ScalarConversionNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm64" {
+		return fmt.Errorf("%w: FPCR/FPSR transfers require an explicit native little-endian AArch64 target, got %q/%q",
+			ErrProbeNeedsContext, options.Goarch, options.TargetTriple)
+	}
+	return nil
+}
diff --git a/arm64_fp_control_consumers_test.go b/arm64_fp_control_consumers_test.go
new file mode 100644
index 000000000..b4330547e
--- /dev/null
+++ b/arm64_fp_control_consumers_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARM64FPControlRequiredRuntimeOwners(t *testing.T) {
+	const filename = "arm64_fp_control_runtime_linux_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "arm64"}, {"darwin", "arm64"},
+		{"windows", "amd64"}, {"js", "wasm"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", filename)
+		if err != nil || selected != (target.os == "linux") {
+			t.Fatal("FP control native owner source selection changed", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, helper := range map[string]string{
+		"TestCrossLinuxRuntimeMatrixARM64FPControlFlags": "arm64FPControlFlagsRuntime",
+		"TestCrossLinuxRuntimeMatrixARM64FPControlState": "arm64FPControlStateRuntime",
+	} {
+		calls := 0
+		for _, declaration := range syntax.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Name.Name != name {
+				continue
+			}
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if ok {
+					if identifier, ok := call.Fun.(*ast.Ident); ok && identifier.Name == helper {
+						calls++
+					}
+				}
+				return true
+			})
+		}
+		if calls != 1 {
+			t.Errorf("required native owner %s lost its real oracle %s", name, helper)
+		}
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") ||
+		!strings.Contains(string(workflow), "PLAN9ASM_CROSS_EXEC: '1'") {
+		t.Fatal("CI no longer selects and enables the FP control runtime owners", err)
+	}
+}
diff --git a/arm64_fp_control_effects_runtime_test.go b/arm64_fp_control_effects_runtime_test.go
new file mode 100644
index 000000000..47f9f5e2b
--- /dev/null
+++ b/arm64_fp_control_effects_runtime_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Retain all three translation entry points and the separate typed-Go
+// consumer. Public TranslateModule uses the global LLVM context; its module
+// is disposed immediately, while the shared helper owns its private context.
+func arm64FPControlIRs(t *testing.T, source, declarations, triple string) []string {
+	t.Helper()
+	irs := arm64CompareMatrixIRs(t, source, declarations, triple)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "compare", declarations)
+	sizes := types.SizesFor("gc", "arm64")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	module, err := TranslateModule(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve})
+	if err != nil {
+		t.Fatal(err)
+	}
+	irs = append(irs, module.String())
+	module.Dispose()
+	return irs
+}
+
+// Go asm7 case35/36 and Arm's MRS/MSR register encodings. The instruction
+// under test transfers FPCR/FPSR, not NZCV; the preceding integer comparison
+// must remain observable by CSET. Both original named and WORD forms execute.
+func arm64FPControlFlagFixture() (source, declarations, original, driver string) {
+	var assembly, goDecl, goMain, cMain strings.Builder
+	goDecl.WriteString("package compare\n")
+	goMain.WriteString("package main\nimport \"fmt\"\n")
+	cMain.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	var names []string
+	for _, register := range []struct {
+		name     string
+		encoding uint32
+		saved    int
+	}{
+		{"FPCR", 0x5a20, 10},
+		{"FPSR", 0x5a21, 11},
+	} {
+		for _, read := range []bool{true, false} {
+			for _, raw := range []bool{false, true} {
+				name := fmt.Sprintf("compareFPControl%d", len(names))
+				names = append(names, name)
+				fmt.Fprintf(&goDecl, "func %s(*uint64, *uint64)\n", name)
+				fmt.Fprintf(&goMain, "func %s(*uint64, *uint64)\n", name)
+				fmt.Fprintf(&cMain, "extern void %s(uint64_t*, uint64_t*);\n", name)
+				fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-16\n", name)
+				assembly.WriteString(`MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+MRS FPCR,R10
+MRS FPSR,R11
+MOVD (R0),R2
+CMP R2,R2
+`)
+				instruction := fmt.Sprintf("MSR R%d,%s", register.saved, register.name)
+				word := uint32(0xd5100000) | register.encoding<<5 | uint32(register.saved)
+				if read {
+					instruction = fmt.Sprintf("MRS %s,R3", register.name)
+					word = 0xd5300000 | register.encoding<<5 | 3
+				}
+				if raw {
+					instruction = fmt.Sprintf("WORD $%#08x", word)
+				}
+				fmt.Fprintln(&assembly, instruction)
+				assembly.WriteString(`CSET EQ,R4
+MOVD R4,(R1)
+MSR R10,FPCR
+MSR R11,FPSR
+RET
+`)
+			}
+		}
+	}
+	goMain.WriteString("func main() {\n")
+	cMain.WriteString("int main(void) {\n")
+	for _, name := range names {
+		fmt.Fprintf(&goMain, `{
+    input, output := uint64(0x8000000000000001), uint64(0)
+    %s(&input, &output)
+    if output != 1 { panic(fmt.Sprintf("%s flags: %%x", output)) }
+}
+`, name, name)
+		fmt.Fprintf(&cMain, `{
+    uint64_t input = UINT64_C(0x8000000000000001), output = 0;
+    %s(&input, &output);
+    if (output != 1) {
+        fprintf(stderr, "%s flags: %%llx\n", (unsigned long long)output);
+        return 1;
+    }
+}
+`, name, name)
+	}
+	goMain.WriteString("fmt.Println(\"ARM64_COMPARE_ORIGINAL_PASS FPCR/FPSR preserve NZCV 8\")\n}\n")
+	cMain.WriteString("return 0;\n}\n")
+	return assembly.String(), goDecl.String(), goMain.String(), cMain.String()
+}
+
+func arm64FPControlFlagsRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, declarations, original, driver := arm64FPControlFlagFixture()
+	arm64ScalarCompareActualGo(t, source, original, goos, runner)
+	irs := arm64FPControlIRs(t, source, declarations, triple)
+	for api, ir := range irs {
+		for _, variant := range []struct{ name, ir string }{
+			{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)},
+		} {
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("api%d/IR_%s/backend_O%d", api, variant.name, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler,
+						"fp_control_flags", triple, variant.ir, driver, runner, level)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64FPControlFlagsNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin counterpart; the required Linux/QEMU owner executes the same original Go oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64FPControlFlagsRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_fp_control_runtime_linux_test.go b/arm64_fp_control_runtime_linux_test.go
new file mode 100644
index 000000000..3c4f29028
--- /dev/null
+++ b/arm64_fp_control_runtime_linux_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64FPControlFlags(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64FPControlFlagsRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FPControlState(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64FPControlStateRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_fp_control_state_test.go b/arm64_fp_control_state_test.go
new file mode 100644
index 000000000..289f6f5ac
--- /dev/null
+++ b/arm64_fp_control_state_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64FPControlStateFixture() (source, declarations, original, driver string) {
+	var assembly, goDecl, goMain, cMain strings.Builder
+	goDecl.WriteString("package compare\n")
+	goMain.WriteString("package main\nimport \"fmt\"\n")
+	cMain.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for mode := 0; mode < 4; mode++ {
+		name := fmt.Sprintf("compareControlState%d", mode)
+		fmt.Fprintf(&goDecl, "func %s(*[2]uint64,*[3]uint64)\n", name)
+		fmt.Fprintf(&goMain, "func %s(*[2]uint64,*[3]uint64)\n", name)
+		fmt.Fprintf(&cMain, "extern void %s(uint64_t*,uint64_t*);\n", name)
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-16\n", name)
+		assembly.WriteString(`MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+MRS FPCR,R10
+MRS FPSR,R11
+MOVD 0(R0),R2
+MOVD 8(R0),R3
+CMP R0,R0
+`)
+		if mode&1 == 0 {
+			assembly.WriteString("MSR R2,FPCR\nMSR R3,FPSR\n")
+		} else {
+			assembly.WriteString("WORD $0xd51b4402\nWORD $0xd51b4423\n")
+		}
+		if mode&2 == 0 {
+			assembly.WriteString("MRS FPCR,R4\nMRS FPSR,R5\n")
+		} else {
+			assembly.WriteString("WORD $0xd53b4404\nWORD $0xd53b4425\n")
+		}
+		assembly.WriteString(`CSET EQ,R6
+MOVD R4,0(R1)
+MOVD R5,8(R1)
+MOVD R6,16(R1)
+MSR R10,FPCR
+MSR R11,FPSR
+RET
+`)
+	}
+	goMain.WriteString(`func main() {
+    count := 0
+    functions := []func(*[2]uint64,*[3]uint64){
+        compareControlState0, compareControlState1,
+        compareControlState2, compareControlState3,
+    }
+    for index, function := range functions {
+        for control := uint64(0); control < 16; control++ {
+            for _, status := range []uint64{0, 1, 0x1f, 0x80, 0x0800009f} {
+                input := [2]uint64{(control&3)<<22 | (control>>2)<<24, status}
+                var output [3]uint64
+                function(&input, &output)
+                want := [3]uint64{input[0], input[1], 1}
+                if output != want {
+                    panic(fmt.Sprintf("control mode=%d input=%x got=%x want=%x", index, input, output, want))
+                }
+                count++
+            }
+        }
+    }
+    fmt.Println("ARM64_COMPARE_ORIGINAL_PASS control roundtrip", count)
+}
+`)
+	cMain.WriteString(`int main(void) {
+    void (*functions[])(uint64_t*,uint64_t*) = {
+        compareControlState0, compareControlState1,
+        compareControlState2, compareControlState3,
+    };
+    const uint64_t statuses[] = {0, 1, 0x1f, 0x80, 0x0800009f};
+    for (unsigned index = 0; index < 4; index++) {
+        for (uint64_t control = 0; control < 16; control++) {
+            for (unsigned sample = 0; sample < 5; sample++) {
+                uint64_t input[2] = {(control&3)<<22 | (control>>2)<<24, statuses[sample]};
+                uint64_t output[3] = {0, 0, 0};
+                functions[index](input, output);
+                if (output[0] != input[0] || output[1] != input[1] || output[2] != 1) {
+                    fprintf(stderr, "control mode=%u control=%llx status=%llx got=%llx/%llx/%llx\n",
+                        index, (unsigned long long)input[0], (unsigned long long)input[1],
+                        (unsigned long long)output[0], (unsigned long long)output[1],
+                        (unsigned long long)output[2]);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`)
+	return assembly.String(), goDecl.String(), goMain.String(), cMain.String()
+}
+
+func arm64FPControlStateRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, declarations, original, driver := arm64FPControlStateFixture()
+	arm64ScalarCompareActualGo(t, source, original, goos, runner)
+	irs := arm64FPControlIRs(t, source, declarations, triple)
+	for api, ir := range irs {
+		for _, variant := range []struct{ name, ir string }{
+			{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)},
+		} {
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("api%d/IR_%s/backend_O%d", api, variant.name, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler,
+						"fp_control_state", triple, variant.ir, driver, runner, level)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64FPControlStateNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin counterpart; the required Linux/QEMU owner executes the same original Go oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64FPControlStateRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_fp_control_test.go b/arm64_fp_control_test.go
new file mode 100644
index 000000000..b8bea5526
--- /dev/null
+++ b/arm64_fp_control_test.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64FPControlTargetAPI(t *testing.T, api, source, triple string) (bool, error) {
+	t.Helper()
+	if api != "public-module" {
+		return arm64CompareTargetAPI(t, api, source, triple)
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return false, err
+	}
+	module, err := TranslateModule(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"comparison": {Name: "comparison", Ret: Void}},
+	})
+	present := !module.IsNil()
+	if present {
+		module.Dispose()
+	}
+	return present, err
+}
+
+func TestARM64FPControlCompleteGoForms(t *testing.T) {
+	contents, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		// The older optab lacks the extra no-operand column. Every actual
+		// operand/encoding/size/attribute remains pinned in either layout.
+		`\{AMRS,\s*C_SPR,\s*C_NONE,\s*C_NONE,\s*C_ZREG,\s*(?:C_NONE,\s*)?35,\s*4,\s*0,\s*0,\s*0\}`,
+		`\{AMSR,\s*C_ZREG,\s*C_NONE,\s*C_NONE,\s*C_SPR,\s*(?:C_NONE,\s*)?36,\s*4,\s*0,\s*0,\s*0\}`,
+	} {
+		if !regexp.MustCompile(row).Match(contents) {
+			t.Fatalf("actual Go MRS/MSR register encoder row changed: %s", row)
+		}
+	}
+	var original strings.Builder
+	original.WriteString("TEXT controlFormats(SB),4,$0-0\n")
+	count := 0
+	for _, register := range []struct {
+		name     string
+		encoding uint16
+	}{{"FPCR", 0x5a20}, {"FPSR", 0x5a21}} {
+		spec, ok := arm64GoSystemRegisters[register.name]
+		if !ok || spec.encoding != register.encoding || !spec.readable || !spec.writable {
+			t.Fatalf("Go system-register role changed for %s", register.name)
+		}
+		for bank := 0; bank < 32; bank++ {
+			name := fmt.Sprintf("R%d", bank)
+			if bank == 18 {
+				name = "R18_PLATFORM"
+			} else if bank == 28 {
+				name = "g"
+			} else if bank == 31 {
+				name = "ZR"
+			}
+			for _, read := range []bool{true, false} {
+				instruction := fmt.Sprintf("MSR %s,%s", name, register.name)
+				word := uint32(0xd5100000) | uint32(register.encoding)<<5 | uint32(bank)
+				if read {
+					instruction = fmt.Sprintf("MRS %s,%s", register.name, name)
+					word |= 1 << 21
+				}
+				file, err := Parse(ArchARM64, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, matched, err := parseARM64FPControl(arm64ControlOp(ins), ins)
+				if !matched || err != nil {
+					t.Fatalf("named grammar %s: %t %v", instruction, matched, err)
+				}
+				raw, matched := decodeARM64RawSystemRegister(word)
+				decoded, control := arm64RawFPControl(raw)
+				if !matched || !control || form != decoded {
+					t.Fatalf("named/raw role disagreement for %s / %#08x", instruction, word)
+				}
+				fmt.Fprintf(&original, "%s\nWORD $%#08x\n", instruction, word)
+				count++
+			}
+		}
+		fmt.Fprintf(&original, "MSR $0,%s\n", register.name)
+	}
+	original.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, original.String(), true)
+	if count != 128 {
+		t.Fatal("incomplete two-register/two-direction/full-GP grammar", count)
+	}
+}
+
+func TestARM64FPControlNativeObjectsAllAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, declarations, _, _ := arm64FPControlFlagFixture()
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		for api, ir := range arm64FPControlIRs(t, source, declarations, triple) {
+			t.Run(fmt.Sprintf("%s/api%d", triple, api), func(t *testing.T) {
+				compileLLVMToObject(t, llc, triple, "control.ll", "control.o", ir)
+			})
+		}
+	}
+}
+
+func TestARM64FPControlNativeTargetAndSourceErrors(t *testing.T) {
+	valid := []string{
+		"MRS FPCR,R0", "MRS FPSR,ZR", "MSR R0,FPCR", "MSR ZR,FPSR", "MSR $0,FPCR",
+		"WORD $0xd53b4400", "WORD $0xd53b443f", "WORD $0xd51b4400", "WORD $0xd51b443f",
+	}
+	invalid := []string{
+		"MRS FPCR", "MRS FPCR,R0,R1", "MRS FPCR,F0", "MRS FPCR,RSP", "MRS FPCR,$0",
+		"MRS.P FPSR,R0", "MSR.P R0,FPCR", "MSR FPCR,R0", "MSR F0,FPSR",
+		"MSR RSP,FPCR", "MSR $1,FPCR", "MSR $-1,FPSR", "MSR $(0.0),FPCR",
+		"MRS fpcr,R0", "MSR R0,fpsr", "MRS S3_3_C4_C4_0,R0", "MSR R0,S3_3_C4_C4_1",
+	}
+	for _, instruction := range invalid {
+		requireARM64GoAssemblerResult(t, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", false)
+	}
+	for _, api := range []string{"text", "module", "Go", "public-module"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "aarch64_be-unknown-linux-gnu"} {
+			for _, instruction := range valid {
+				for _, prefix := range []string{"", "RET\n"} {
+					source := "TEXT comparison(SB),4,$0-0\n" + prefix + instruction + "\nRET\n"
+					present, err := arm64FPControlTargetAPI(t, api, source, triple)
+					if present || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %q unbound native %s accepted: %t %v", api, triple, instruction, present, err)
+					}
+				}
+			}
+			for _, instruction := range invalid {
+				source := "TEXT comparison(SB),4,$0-0\nMRS FPCR,R0\nRET\n" + instruction + "\nRET\n"
+				present, err := arm64FPControlTargetAPI(t, api, source, triple)
+				if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s malformed %s erased by native context: %t %v", api, instruction, present, err)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64FPControlRetainsTypedEntryBoundaries(t *testing.T) {
+	for _, body := range []string{
+		"MSR R9,FPCR", // No source-defined numerical input.
+		"MSR R9,FPSR",
+		"MRS FPCR,R18_PLATFORM", "MRS FPSR,g", "MRS FPCR,R30",
+		"MRS FPSR,R0\nCSET EQ,R0", // A status read does not define NZCV.
+		"CMP R0,R0\nMRS TPIDR_EL0,R1\nCSET EQ,R0",
+		"CMP R0,R0\nMSR R0,TPIDR_EL0\nCSET EQ,R0",
+	} {
+		file, err := Parse(ArchARM64, arm64TypedNativeSource(body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ir, err := Translate(file, arm64TypedNativeOptions(t, "aarch64-unknown-linux-gnu")); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("unproved source gained a machine role: %s: %v", body, err)
+		}
+	}
+	for _, body := range []string{
+		"CMP R0,R0\nMRS FPCR,R1\nCSET EQ,R0",
+		"CMP R0,R0\nMRS FPSR,R1\nCSET EQ,R0",
+		"CMP R0,R0\nMSR R0,FPCR\nCSET EQ,R0",
+		"CMP R0,R0\nMSR $0,FPSR\nCSET EQ,R0",
+	} {
+		file, err := Parse(ArchARM64, arm64TypedNativeSource(body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, arm64TypedNativeOptions(t, "aarch64-unknown-linux-gnu")); err != nil {
+			t.Errorf("exact source-defined FP control lost its flags: %s: %v", body, err)
+		}
+	}
+}
+
+func TestARM64FPControlMalformedWordBeforeTargetContext(t *testing.T) {
+	for _, bad := range []string{"WORD $0xffffffff", "WORD $(0.0)", "WORD R0", "WORD $0,$1"} {
+		for _, body := range []string{
+			bad + "\nMRS FPCR,R0", "MRS FPCR,R0\n" + bad,
+			"MRS FPSR,R0\nRET\n" + bad,
+		} {
+			for _, api := range []string{"text", "module", "Go", "public-module"} {
+				for _, target := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+					source := "TEXT comparison(SB),4,$0-0\n" + body + "\nRET\n"
+					present, err := arm64FPControlTargetAPI(t, api, source, target)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %s malformed WORD hidden by native context: %s: %t %v", api, target, body, present, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_fp_integer_pair_runtime_test.go b/arm64_fp_integer_pair_runtime_test.go
new file mode 100644
index 000000000..971e05a30
--- /dev/null
+++ b/arm64_fp_integer_pair_runtime_test.go
@@ -0,0 +1,339 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64FPPairFamilyRuntime(t *testing.T, triple string) (string, string, string, string) {
+	t.Helper()
+	return arm64FPPairFamilyRuntimeWithObservation(t, triple, false)
+}
+
+func arm64FPPairFamilyRuntimeWithObservation(t *testing.T, triple string, originalWideObservation bool) (string, string, string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"LDP", "LDPW", "LDPSW", "STP", "STPW"} {
+		for _, shape := range []struct {
+			name   string
+			typeOf LLVMType
+			count  int
+			offset int64
+		}{
+			{name: "scalar64", typeOf: I64, count: 3},
+			{name: "partial64", typeOf: I64, count: 3, offset: 4},
+			{name: "scalar32", typeOf: I32, count: 4},
+			{name: "scalar16", typeOf: I16, count: 12},
+			{name: "scalar8", typeOf: I8, count: 24},
+		} {
+			name := strings.ToLower(op) + "_" + shape.name
+			sig := FuncSig{Name: name, Ret: Void}
+			var arguments, frameInit, observedChecks strings.Builder
+			slotBytes := frameTypeSize(shape.typeOf, 8)
+			for i := 0; i < shape.count; i++ {
+				sig.Args = append(sig.Args, shape.typeOf)
+				sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i) * slotBytes, Type: shape.typeOf, Index: i, Field: -1})
+				if i != 0 {
+					arguments.WriteString(", ")
+				}
+				fmt.Fprintf(&arguments, "uint%d_t a%d", slotBytes*8, i)
+				fmt.Fprintf(&frameInit, "    uint%d_t a%d = samples[(iteration + %d) %% 8];\n", slotBytes*8, i, i)
+				fmt.Fprintf(&frameInit, "    memcpy(frame + %d, &a%d, %d);\n", int64(i)*slotBytes, i, slotBytes)
+			}
+			load := strings.HasPrefix(op, "LDP")
+			frameBytes := int64(shape.count) * slotBytes
+			outOffset := frameBytes
+			width := 4
+			if op == "LDP" || op == "STP" {
+				width = 8
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-64\n", name)
+			if !load {
+				for i := 0; i < 2; i++ {
+					index := len(sig.Args)
+					sig.Args = append(sig.Args, I64)
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: frameBytes + int64(i)*8, Type: I64, Index: index, Field: -1})
+				}
+				fmt.Fprintf(&source, "MOVD left+%d(FP), R3\nMOVD right+%d(FP), R4\n", frameBytes, frameBytes+8)
+				arguments.WriteString(", uint64_t left, uint64_t right")
+				outOffset += 16
+			}
+			sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: outOffset, Type: Ptr, Index: len(sig.Args), Field: -1})
+			sig.Args = append(sig.Args, Ptr)
+			arguments.WriteString(", uint64_t *out")
+			fmt.Fprintf(&source, "MOVD out+%d(FP), R10\n", outOffset)
+			if load {
+				fmt.Fprintf(&source, "%s frame+%d(FP), (R3, R4)\nMOVD R3, 0(R10)\nMOVD R4, 8(R10)\n", op, shape.offset)
+				for i := 0; i < 2; i++ {
+					fmt.Fprintf(&observedChecks, "    uint64_t want%d = 0;\n    memcpy(&want%d, frame + %d, %d);\n", i, i, shape.offset+int64(i*width), width)
+					if op == "LDPSW" {
+						fmt.Fprintf(&observedChecks, "    want%d = (uint64_t)(int64_t)(int32_t)want%d;\n", i, i)
+					}
+					fmt.Fprintf(&observedChecks, "    if (out[%d] != want%d) return %d;\n", i, i, i+1)
+				}
+			} else {
+				fmt.Fprintf(&source, "%s (R3, R4), frame+%d(FP)\n", op, shape.offset)
+				var move string
+				switch slotBytes {
+				case 1:
+					move = "MOVBU"
+				case 2:
+					move = "MOVHU"
+				case 4:
+					move = "MOVWU"
+				case 8:
+					move = "MOVD"
+				default:
+					t.Fatalf("unregistered FP scalar observation width %d", slotBytes)
+				}
+				// Retain the original source for the real-Go stale-reference
+				// regression; it is not the canonical numerical fixture.
+				if originalWideObservation && slotBytes < 4 {
+					move = "MOVD"
+				}
+				for i := 0; i < shape.count; i++ {
+					fmt.Fprintf(&source, "%s frame+%d(FP), R5\nMOVD R5, %d(R10)\n", move, int64(i)*slotBytes, i*8)
+					fmt.Fprintf(&observedChecks, "    uint64_t want%d = 0;\n    memcpy(&want%d, frame + %d, %d);\n", i, i, int64(i)*slotBytes, slotBytes)
+					fmt.Fprintf(&observedChecks, "    if (out[%d] != want%d) return %d;\n", i, i, i+1)
+				}
+			}
+			source.WriteString("RET\n")
+			sigs[name] = sig
+			fmt.Fprintf(&declarations, "extern void %s(%s);\n", name, arguments.String())
+			outCount := shape.count
+			if outCount < 2 {
+				outCount = 2
+			}
+			fmt.Fprintf(&declarations, "static int check_%s(void) {\n  for (unsigned iteration = 0; iteration < 8; iteration++) {\n    unsigned char frame[%d];\n    uint64_t out[%d] = {UINT64_MAX, UINT64_MAX};\n", name, frameBytes, outCount)
+			declarations.WriteString(frameInit.String())
+			if !load {
+				declarations.WriteString("    uint64_t left = samples[(iteration + 5) % 8], right = samples[(iteration + 7) % 8];\n")
+				fmt.Fprintf(&declarations, "    memcpy(frame + %d, &left, %d);\n    memcpy(frame + %d, &right, %d);\n", shape.offset, width, shape.offset+int64(width), width)
+			}
+			fmt.Fprintf(&declarations, "    %s(", name)
+			for i := 0; i < shape.count; i++ {
+				fmt.Fprintf(&declarations, "a%d, ", i)
+			}
+			if !load {
+				declarations.WriteString("left, right, ")
+			}
+			declarations.WriteString("out);\n" + observedChecks.String() + "  }\n  return 0;\n}\n")
+			fmt.Fprintf(&checks, "  if (check_%s()) { fprintf(stderr, \"%s failed\\n\"); return %d; }\n", name, name, len(sigs))
+		}
+	}
+
+	const resultsSource = `TEXT result64(SB),$0-32
+	MOVD left+0(FP), R3
+	MOVD right+8(FP), R4
+	STP (R3, R4), ret+16(FP)
+	RET
+TEXT result32(SB),$0-24
+	MOVD left+0(FP), R3
+	MOVD right+8(FP), R4
+	STPW (R3, R4), ret+16(FP)
+	RET
+TEXT resultPartial(SB),$0-48
+	MOVD original0+0(FP), R7
+	MOVD original1+8(FP), R8
+	MOVD R7, ret0+32(FP)
+	MOVD R8, ret1+40(FP)
+	MOVD left+16(FP), R3
+	MOVD right+24(FP), R4
+	STPW (R3, R4), ret+36(FP)
+	RET
+TEXT mixedResult(SB),$0-32
+	MOVD value+0(FP), R7
+	MOVD R7, ret+24(FP)
+	MOVD out+16(FP), R10
+	LDP out+16(FP), (R3, R4)
+	MOVD R3, 0(R10)
+	MOVD R4, 8(R10)
+	RET
+`
+	source.WriteString(resultsSource)
+	for _, name := range []string{"result64", "result32", "resultPartial", "mixedResult"} {
+		sig := FuncSig{Name: name, Args: []LLVMType{I64, I64}, Ret: LLVMType("{ i64, i64 }")}
+		if name == "result32" {
+			sig.Ret = I64
+		} else if name == "resultPartial" {
+			sig.Args = []LLVMType{I64, I64, I64, I64}
+		} else if name == "mixedResult" {
+			sig.Args = []LLVMType{I64, I64, Ptr}
+			sig.Ret = I64
+		}
+		for i, ty := range sig.Args {
+			sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(i * 8), Type: ty, Index: i, Field: -1})
+		}
+		count := 2
+		if sig.Ret == I64 {
+			count = 1
+		}
+		for i := 0; i < count; i++ {
+			sig.Frame.Results = append(sig.Frame.Results, FrameSlot{Offset: int64((len(sig.Args) + i) * 8), Type: I64, Index: i, Field: -1})
+		}
+		sigs[name] = sig
+	}
+	const resultsOracle = `
+typedef struct { uint64_t first, second; } pair64;
+extern pair64 result64(uint64_t, uint64_t);
+extern uint64_t result32(uint64_t, uint64_t);
+extern pair64 resultPartial(uint64_t, uint64_t, uint64_t, uint64_t);
+extern uint64_t mixedResult(uint64_t, uint64_t, uint64_t *);
+static int check_results(void) {
+	for (unsigned i = 0; i < 8; i++) {
+		uint64_t a = samples[i], b = samples[(i + 3) % 8];
+		pair64 p = result64(a, b);
+		if (p.first != a || p.second != b) return 1;
+		if (result32(a, b) != ((uint64_t)(uint32_t)a | ((uint64_t)(uint32_t)b << 32))) return 2;
+		p = resultPartial(UINT64_C(0x0123456789abcdef), UINT64_C(0xfedcba9876543210), a, b);
+		if (p.first != (UINT64_C(0x89abcdef) | ((uint64_t)(uint32_t)a << 32))) return 3;
+		if (p.second != (UINT64_C(0xfedcba9800000000) | (uint32_t)b)) return 4;
+		uint64_t out[2] = {0, 0};
+		if (mixedResult(a, b, out) != a || out[0] != (uintptr_t)out || out[1] != a) return 5;
+	}
+	return 0;
+}
+`
+	const vectorSource = `TEXT fmovqLoad(SB),$0-32
+	MOVD out+24(FP), R10
+	FMOVQ value+4(FP), F0
+	FMOVQ F0, (R10)
+	RET
+TEXT fmovqStore(SB),$0-40
+	MOVD in+24(FP), R9
+	MOVD out+32(FP), R10
+	FMOVQ (R9), F0
+	FMOVQ F0, value+4(FP)
+	MOVD value+0(FP), R3
+	MOVD R3, 0(R10)
+	MOVD value+8(FP), R3
+	MOVD R3, 8(R10)
+	MOVD value+16(FP), R3
+	MOVD R3, 16(R10)
+	RET
+TEXT fmovqFloats(SB),$0-24
+	MOVD out+16(FP), R10
+	FMOVQ value+0(FP), F0
+	FMOVQ F0, (R10)
+	RET
+`
+	source.WriteString(vectorSource)
+	for _, name := range []string{"fmovqLoad", "fmovqStore", "fmovqFloats"} {
+		sig := FuncSig{Name: name, Args: []LLVMType{I64, I64, I64, Ptr}, Ret: Void}
+		if name == "fmovqStore" {
+			sig.Args = append(sig.Args, Ptr)
+		} else if name == "fmovqFloats" {
+			sig.Args = []LLVMType{"float", "float", "float", "float", Ptr}
+		}
+		offset := int64(0)
+		for i, ty := range sig.Args {
+			sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: offset, Type: ty, Index: i, Field: -1})
+			offset += frameTypeSize(ty, 8)
+		}
+		sigs[name] = sig
+	}
+	const vectorOracle = `
+extern void fmovqLoad(uint64_t, uint64_t, uint64_t, unsigned char *);
+extern void fmovqStore(uint64_t, uint64_t, uint64_t, const unsigned char *, uint64_t *);
+extern void fmovqFloats(float, float, float, float, uint32_t *);
+static int check_vectors(void) {
+	for (unsigned i = 0; i < 8; i++) {
+		uint64_t original[3] = {samples[i], samples[(i + 2) % 8], samples[(i + 5) % 8]};
+		unsigned char packed[16];
+		fmovqLoad(original[0], original[1], original[2], packed);
+		if (memcmp(packed, (unsigned char *)original + 4, 16)) return 1;
+		for (unsigned j = 0; j < 16; j++) packed[j] = (unsigned char)(i * 29 + j * 17);
+		uint64_t out[3] = {0, 0, 0}, expected[3];
+		memcpy(expected, original, sizeof expected);
+		memcpy((unsigned char *)expected + 4, packed, sizeof packed);
+		fmovqStore(original[0], original[1], original[2], packed, out);
+		if (memcmp(out, expected, sizeof expected)) return 2;
+	}
+	const uint32_t bits[4] = {UINT32_C(0x3f800000), UINT32_C(0x80000000), UINT32_C(0x40490fdb), UINT32_C(0xc1200000)};
+	float values[4];
+	uint32_t out[4] = {0, 0, 0, 0};
+	memcpy(values, bits, sizeof values);
+	fmovqFloats(values[0], values[1], values[2], values[3], out);
+	if (memcmp(out, bits, sizeof bits)) return 3;
+	return 0;
+}
+`
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static const uint64_t samples[8] = {0, 1, UINT64_MAX, UINT64_C(0x8000000000000000),
+	UINT64_C(0x7fffffff80000000), UINT64_C(0x800000007fffffff),
+	UINT64_C(0x0123456789abcdef), UINT64_C(0xfedcba9876543210)};
+` + declarations.String() + resultsOracle + vectorOracle + "int main(void) {\n" + checks.String() + "  if (check_results()) return 90;\n  return check_vectors();\n}\n"
+	var goDeclarations strings.Builder
+	goTypes := map[LLVMType]string{
+		I8: "uint8", I16: "uint16", I32: "uint32", I64: "uint64",
+		Ptr: "*byte", LLVMType("float"): "float32",
+	}
+	for _, function := range file.Funcs {
+		sig, found := sigs[function.Sym]
+		if !found {
+			t.Fatalf("missing first-party fixture signature for %q", function.Sym)
+		}
+		fmt.Fprintf(&goDeclarations, "func %s(", function.Sym)
+		for i, arg := range sig.Args {
+			goType, found := goTypes[arg]
+			if !found {
+				t.Fatalf("unregistered first-party fixture Go input type %q", arg)
+			}
+			if i != 0 {
+				goDeclarations.WriteString(", ")
+			}
+			fmt.Fprintf(&goDeclarations, "a%d %s", i, goType)
+		}
+		goDeclarations.WriteString(")")
+		switch sig.Ret {
+		case Void:
+		case I64:
+			goDeclarations.WriteString(" uint64")
+		case LLVMType("{ i64, i64 }"):
+			goDeclarations.WriteString(" (uint64, uint64)")
+		default:
+			t.Fatalf("unregistered first-party fixture Go result type %q", sig.Ret)
+		}
+		goDeclarations.WriteByte('\n')
+	}
+	return ir, main, source.String(), goDeclarations.String()
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FPPairFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	ir, main, source, declarations := arm64FPPairFamilyRuntime(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "fp_pair_family", triple, ir, main, runner)
+	for api, apiIR := range arm64ScalarMemoryIRs(t, source, declarations, triple) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("fp_pair_api_%d", api), triple, apiIR, main, runner)
+	}
+	t.Log("unchanged 25 pair/width/partial shapes, four result and three vector cases; initialized C reference through manual transport and all three typed APIs")
+}
+
+func TestARM64FPPairFamilyLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		t.Run(triple, func(t *testing.T) {
+			ir, _, source, declarations := arm64FPPairFamilyRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "fp-pair-family.ll", "fp-pair-family.o", ir)
+			for api, apiIR := range arm64ScalarMemoryIRs(t, source, declarations, triple) {
+				compileLLVMToObject(t, llc, triple, fmt.Sprintf("fp-pair-api-%d.ll", api), fmt.Sprintf("fp-pair-api-%d.o", api), apiIR)
+			}
+		})
+	}
+}
diff --git a/arm64_fp_integer_pair_test.go b/arm64_fp_integer_pair_test.go
new file mode 100644
index 000000000..1d1e1ff8e
--- /dev/null
+++ b/arm64_fp_integer_pair_test.go
@@ -0,0 +1,240 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+func arm64FPPairRuntimeTools(t *testing.T) (llc, triple string, compiler, runner []string) {
+	t.Helper()
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	native := runtime.GOARCH == "arm64" && (runtime.GOOS == "darwin" || runtime.GOOS == "linux")
+	if !native && !cross {
+		t.Skip("ARM64 native execution or the required Linux cross-runtime matrix")
+	}
+	llc = findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	triple = testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler = []string{findLLVM22Tool("clang")}
+	if cross {
+		triple = "aarch64-unknown-linux-gnu"
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+		for _, tool := range []string{compiler[0], runner[0]} {
+			if _, err := exec.LookPath(tool); err != nil {
+				t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+			}
+		}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	if native && runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	return llc, triple, compiler, runner
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FPPairSecondSlot(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT fpPairSecond(SB),$0-24
+	LDP a+0(FP), (R3, R4)
+	MOVD R4, ret+16(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"fpPairSecond": {
+			Name: "fpPairSecond", Args: []LLVMType{I64, I64}, Ret: I64,
+			Frame: FrameLayout{
+				Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+				},
+				Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+			},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t fpPairSecond(uint64_t, uint64_t);
+int main(void) {
+	const uint64_t expected = UINT64_C(0xfedcba9876543210);
+	uint64_t got = fpPairSecond(UINT64_C(0x0123456789abcdef), expected);
+	if (got != expected) {
+		fprintf(stderr, "second FP slot got=%llx want=%llx\n", (unsigned long long)got, (unsigned long long)expected);
+		return 1;
+	}
+	return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "fp_pair_second", triple, ir, main, runner)
+}
+
+func TestARM64FPIntegerPairCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, op := range []string{"LDP", "LDPW", "LDPSW", "STP", "STPW"} {
+		for _, offset := range []int64{0, 1, 2, 4, 512, 16384} {
+			t.Run(fmt.Sprintf("%s/%d", op, offset), func(t *testing.T) {
+				instruction := fmt.Sprintf("%s frame+%d(FP), (R3, R4)", op, offset)
+				if strings.HasPrefix(op, "ST") {
+					instruction = fmt.Sprintf("%s (R3, R4), frame+%d(FP)", op, offset)
+				}
+				source := "TEXT fpPairForms(SB),$0-20000\n\t" + instruction + "\n\tRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Name: "fpPairForms", Args: []LLVMType{I64, I64, I64}, Ret: Void}
+				start := offset &^ 7
+				for i := 0; i < 3; i++ {
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: start + int64(i)*8, Type: I64, Index: i, Field: -1})
+				}
+				for _, triple := range []string{
+					"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+					"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+				} {
+					ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "fp-pair.ll", "fp-pair.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64FPIntegerPairRejectsGoInvalidForms(t *testing.T) {
+	for _, op := range []string{"LDP", "LDPW", "LDPSW", "STP", "STPW"} {
+		for _, suffix := range []string{".W", ".P"} {
+			instruction := op + suffix + " frame+0(FP), (R3, R4)"
+			if strings.HasPrefix(op, "ST") {
+				instruction = op + suffix + " (R3, R4), frame+0(FP)"
+			}
+			t.Run(op+suffix, func(t *testing.T) {
+				source := "TEXT badFP(SB),$0-16\n\t" + instruction + "\n\tRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"badFP": {Name: "badFP", Ret: Void}}})
+				if err == nil {
+					t.Errorf("translator accepted Go-rejected %s", instruction)
+				}
+			})
+		}
+	}
+	for _, op := range []string{"LDP", "LDPW", "LDPSW"} {
+		instruction := op + " frame+0(FP), (R3, R3)"
+		t.Run(op+"/duplicate", func(t *testing.T) {
+			source := "TEXT badFP(SB),$0-16\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"badFP": {
+				Name: "badFP", Args: []LLVMType{I64, I64}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+				}},
+			}}})
+			if err == nil {
+				t.Errorf("translator accepted Go-rejected %s", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64FPIntegerPairRejectsMissingFrameBytes(t *testing.T) {
+	for _, op := range []string{"LDP", "LDPW", "LDPSW", "STP", "STPW"} {
+		for _, slots := range [][]FrameSlot{
+			{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+			{{Offset: 0, Type: I16, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+		} {
+			instruction := op + " frame+0(FP), (R3, R4)"
+			if strings.HasPrefix(op, "ST") {
+				instruction = op + " (R3, R4), frame+0(FP)"
+			}
+			source := "TEXT missingFP(SB),$0-16\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			args := make([]LLVMType, len(slots))
+			for i, slot := range slots {
+				args[i] = slot.Type
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"missingFP": {
+				Name: "missingFP", Args: args, Ret: Void, Frame: FrameLayout{Params: slots},
+			}}})
+			if err == nil || !strings.Contains(err.Error(), "frame range") {
+				t.Errorf("%s must reject absent/padding bytes, got %v", op, err)
+			}
+		}
+	}
+}
+
+func TestARM64FPFrameRangeValidation(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		off    int64
+		size   int64
+		slots  []FrameSlot
+		result bool
+	}{
+		{name: "empty", size: 0},
+		{name: "negative size", size: -1},
+		{name: "oversized", size: 17},
+		{name: "overflow", off: 1<<63 - 8, size: 16},
+		{name: "aggregate", size: 8, slots: []FrameSlot{{Offset: 0, Type: "[2 x i64]"}}},
+		{name: "overlap at start", size: 8, slots: []FrameSlot{{Offset: 0, Type: I64}, {Offset: 0, Type: I32}}},
+		{name: "overlap inside", size: 8, slots: []FrameSlot{{Offset: 0, Type: I64}, {Offset: 4, Type: I32}}},
+		{name: "negative request", off: -8, size: 8, slots: []FrameSlot{{Offset: -8, Type: I64}}},
+		{name: "negative slot", size: 4, slots: []FrameSlot{{Offset: -1, Type: I64}}},
+		{name: "minimum slot subtraction overflow", off: 1<<63 - 17, size: 8, slots: []FrameSlot{{Offset: -1 << 63, Type: I64}}},
+		{name: "negative maximum slot subtraction overflow", off: 1<<63 - 17, size: 8, slots: []FrameSlot{{Offset: -(1<<63 - 1), Type: I64}}},
+		{name: "slot end overflow", off: 1<<63 - 4, size: 1, slots: []FrameSlot{{Offset: 1<<63 - 4, Type: I64}}},
+		{name: "negative result slot", size: 4, slots: []FrameSlot{{Offset: -1, Type: I64}}, result: true},
+		{name: "result slot end overflow", off: 1<<63 - 4, size: 1, slots: []FrameSlot{{Offset: 1<<63 - 4, Type: I64}}, result: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			c := arm64Ctx{sig: FuncSig{Frame: FrameLayout{Params: test.slots}}}
+			if test.result {
+				c.sig.Frame.Params = nil
+				c.fpResults = test.slots
+			}
+			if _, err := c.fpFrameParts(test.off, test.size); err == nil {
+				t.Fatal("invalid FP frame range accepted")
+			}
+		})
+	}
+}
diff --git a/arm64_fp_padding_bits.go b/arm64_fp_padding_bits.go
new file mode 100644
index 000000000..59f7dae65
--- /dev/null
+++ b/arm64_fp_padding_bits.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+// A set bit denotes possible dependence on unspecified source padding, not
+// an uninitialized LLVM value. All F/V/Z views share one 128-bit low bank.
+type arm64PaddingBits [2]uint64
+
+func arm64PaddingMask(bits int) uint64 {
+	if bits >= 64 {
+		return ^uint64(0)
+	}
+	return (uint64(1) << uint(bits)) - 1
+}
+
+func (b arm64PaddingBits) element(bits, lane int) uint64 {
+	offset := bits * lane
+	return b[offset/64] >> uint(offset%64) & arm64PaddingMask(bits)
+}
+
+func (b *arm64PaddingBits) setElement(bits, lane int, value uint64) {
+	offset := bits * lane
+	mask := arm64PaddingMask(bits) << uint(offset%64)
+	b[offset/64] = b[offset/64]&^mask | value<<uint(offset%64)&mask
+}
+
+func arm64PaddingExtend(value uint64, bits int, signed bool, destinationBits int) uint64 {
+	value &= arm64PaddingMask(bits)
+	if signed && value&(uint64(1)<<uint(bits-1)) != 0 {
+		value |= ^arm64PaddingMask(bits)
+	}
+	return value & arm64PaddingMask(destinationBits)
+}
+
+func arm64PaddingShift(value uint64, bits int, shift int64, right, signed bool) uint64 {
+	value &= arm64PaddingMask(bits)
+	if !right {
+		return value << uint(shift) & arm64PaddingMask(bits)
+	}
+	if shift >= int64(bits) {
+		if !signed {
+			return 0
+		}
+		shift = int64(bits - 1)
+	}
+	result := value >> uint(shift)
+	if signed && value&(uint64(1)<<uint(bits-1)) != 0 {
+		result |= arm64PaddingMask(bits) &^ arm64PaddingMask(bits-int(shift))
+	}
+	return result
+}
+
+func arm64PaddingVectorTransfer(form arm64VectorTransferForm, source, old arm64PaddingBits) arm64PaddingBits {
+	if form.copy {
+		if form.lanes == 8 {
+			source[1] = 0
+		}
+		return source
+	}
+	value := source.element(form.bits, form.sourceLane)
+	if form.sourceGP {
+		value = source[0] & arm64PaddingMask(form.bits)
+	}
+	if form.destinationGP {
+		return arm64PaddingBits{value, 0}
+	}
+	result := arm64PaddingBits{}
+	if form.preserve {
+		result = old
+	}
+	for lane := 0; lane < form.lanes; lane++ {
+		result.setElement(form.bits, lane+form.destinationLane, value)
+	}
+	return result
+}
+
+func arm64PaddingVectorShift(op Op, form arm64VectorShiftForm, source, old arm64PaddingBits) arm64PaddingBits {
+	spec, right := arm64VectorShiftRightSpecs[op]
+	result := arm64PaddingBits{}
+	for lane := 0; lane < form.arrangement.lanes; lane++ {
+		value := source.element(form.arrangement.elementBits, lane)
+		shifted := arm64PaddingShift(value, form.arrangement.elementBits, form.shift, right, spec.signed)
+		// Rounding and accumulation include carry propagation. Keep a sound
+		// whole-element dependency rather than pretending they are pure shifts.
+		if spec.rounding && value != 0 || spec.accumulate && (value != 0 || old.element(form.arrangement.elementBits, lane) != 0) {
+			shifted = arm64PaddingMask(form.arrangement.elementBits)
+		}
+		result.setElement(form.arrangement.elementBits, lane, shifted)
+	}
+	return result
+}
diff --git a/arm64_fp_padding_declaration.go b/arm64_fp_padding_declaration.go
new file mode 100644
index 000000000..630e113a1
--- /dev/null
+++ b/arm64_fp_padding_declaration.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"go/types"
+	"reflect"
+)
+
+type arm64FPReadDeclaration struct {
+	signature  FuncSig
+	parameter  FrameSlot
+	paddingEnd int64
+}
+
+// This first contract is only the final direct scalar parameter's ABI0
+// parameter/result alignment gap. Internal aggregate holes, result/tail
+// padding, pointers, custom data models and incomplete signatures stay strict.
+func arm64FPReadDeclarationForGo(sig FuncSig, decl *types.Signature, sizes, frameSizes types.Sizes) *arm64FPReadDeclaration {
+	if decl == nil || decl.Recv() != nil || decl.Variadic() || decl.Params().Len() == 0 ||
+		decl.Results().Len() == 0 || len(sig.Frame.Params) == 0 || len(sig.Frame.Results) == 0 {
+		return nil
+	}
+	last := sig.Frame.Params[len(sig.Frame.Params)-1]
+	if last.Index != decl.Params().Len()-1 || last.Field != -1 || len(last.Fields) != 0 ||
+		(last.Type != I8 && last.Type != I16 && last.Type != I32) {
+		return nil
+	}
+	basic, ok := decl.Params().At(last.Index).Type().Underlying().(*types.Basic)
+	if !ok || basic.Info()&types.IsInteger == 0 {
+		return nil
+	}
+	for _, layout := range []types.Sizes{sizes, frameSizes} {
+		if layout == nil || layout.Sizeof(types.Typ[types.Int]) != 8 ||
+			layout.Sizeof(types.Typ[types.Uintptr]) != 8 || layout.Alignof(types.Typ[types.Int64]) != 8 ||
+			!arm64PaddingDeclarationLayoutMatches(layout, decl) {
+			return nil
+		}
+	}
+	// Compare the entire actual declaration layout with gc's ARM64 model, not
+	// just its word size. A custom Sizes may agree on int yet move an earlier
+	// aggregate or change the narrow parameter's alignment.
+	gc := types.SizesFor("gc", "arm64")
+	args, params, offset, err := goLLVMArgsAndFrameSlotsForTuple(decl.Params(), "arm64", gc, gc, 0, false)
+	if err != nil {
+		return nil
+	}
+	results, resultSlots, _, err := goLLVMArgsAndFrameSlotsForTuple(decl.Results(), "arm64", gc, gc, goAlignOff(offset, 8), true)
+	if err != nil || !reflect.DeepEqual(args, sig.Args) || !reflect.DeepEqual(params, sig.Frame.Params) ||
+		!reflect.DeepEqual(resultSlots, sig.Frame.Results) || goTupleRetType(results) != sig.Ret {
+		return nil
+	}
+	end := last.Offset + frameTypeSize(last.Type, 8)
+	boundary := sig.Frame.Results[0].Offset
+	if last.Offset < 0 || end <= last.Offset || boundary <= end || boundary != goAlignOff(end, 8) {
+		return nil
+	}
+	snapshot := sig
+	snapshot.Args = append([]LLVMType(nil), sig.Args...)
+	snapshot.Frame.Params = arm64CopyFPSlots(sig.Frame.Params)
+	snapshot.Frame.Results = arm64CopyFPSlots(sig.Frame.Results)
+	return &arm64FPReadDeclaration{signature: snapshot, parameter: last, paddingEnd: boundary}
+}
+
+func arm64PaddingDeclarationLayoutMatches(layout types.Sizes, declaration *types.Signature) bool {
+	gc := types.SizesFor("gc", "arm64")
+	seen := make(map[types.Type]bool)
+	var check func(types.Type) bool
+	check = func(typ types.Type) bool {
+		if seen[typ] {
+			return true
+		}
+		if len(seen) >= 4096 || layout.Sizeof(typ) != gc.Sizeof(typ) || layout.Alignof(typ) != gc.Alignof(typ) {
+			return false
+		}
+		seen[typ] = true
+		switch underlying := typ.Underlying().(type) {
+		case *types.Array:
+			return check(underlying.Elem())
+		case *types.Struct:
+			fields := make([]*types.Var, underlying.NumFields())
+			for i := range fields {
+				fields[i] = underlying.Field(i)
+				if !check(fields[i].Type()) {
+					return false
+				}
+			}
+			return reflect.DeepEqual(layout.Offsetsof(fields), gc.Offsetsof(fields))
+		}
+		return true // Pointee/element contents do not change a pointer/header ABI.
+	}
+	for _, tuple := range []*types.Tuple{declaration.Params(), declaration.Results()} {
+		for i := 0; i < tuple.Len(); i++ {
+			if !check(tuple.At(i).Type()) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func arm64CopyFPSlots(slots []FrameSlot) []FrameSlot {
+	copySlots := append([]FrameSlot(nil), slots...)
+	for i := range copySlots {
+		copySlots[i].Fields = append([]int(nil), copySlots[i].Fields...)
+	}
+	return copySlots
+}
+
+func (d *arm64FPReadDeclaration) matches(sig FuncSig) bool {
+	if d == nil || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil ||
+		sig.ARM64ClosureABI != nil || len(sig.ArgRegs) != 0 {
+		return false
+	}
+	sig.arm64FPReadDeclaration = nil
+	sig.arm64ABI0Declaration, sig.arm64ABI0TailDeclaration = nil, nil
+	return reflect.DeepEqual(d.signature, sig)
+}
diff --git a/arm64_fp_padding_family_test.go b/arm64_fp_padding_family_test.go
new file mode 100644
index 000000000..2b03f0861
--- /dev/null
+++ b/arm64_fp_padding_family_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64PaddingCase struct {
+	name, body string
+	parameter  int
+	resultBits int
+	signed     bool
+}
+
+func arm64PaddingCases() []arm64PaddingCase {
+	var cases []arm64PaddingCase
+	for _, parameter := range []int{8, 16, 32} {
+		for _, load := range []Op{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+			width, _ := arm64ScalarMemoryBits(load)
+			if width < parameter {
+				continue
+			}
+			for _, signed := range []bool{false, true} {
+				truncate := map[int]string{8: "MOVB", 16: "MOVH", 32: "MOVW"}[parameter]
+				if !signed {
+					truncate += "U"
+				}
+				cases = append(cases, arm64PaddingCase{
+					name: fmt.Sprintf("narrow%d", len(cases)), parameter: parameter,
+					resultBits: 64, signed: signed,
+					body: fmt.Sprintf("%s rhs+0(FP),R2\n%s R2,R0\n", load, truncate),
+				})
+			}
+		}
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			width := map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[arrangement[0]]
+			if width < parameter {
+				continue
+			}
+			body := fmt.Sprintf("MOVD rhs+0(FP),R2\nVDUP R2,V0.%s\n", arrangement)
+			if shift := width - parameter; shift != 0 {
+				// Go1.20 has no named VSSHR; use the same architectural raw
+				// SSHR route as the original Arrow source, not a version switch.
+				full := len(arrangement) > 1 && (arrangement == "B16" || arrangement == "H8" || arrangement == "S4" || arrangement == "D2")
+				word := encodeARM64ImmediateShiftRight(0x0f000400, width, shift, full, 0, 0)
+				body += fmt.Sprintf("VSHL $%d,V0.%s,V0.%s\nWORD $%#08x\n", shift, arrangement, arrangement, word)
+			}
+			body += fmt.Sprintf("VMOV V0.%c[0],R0\n", arrangement[0])
+			cases = append(cases, arm64PaddingCase{
+				name: fmt.Sprintf("narrow%d", len(cases)), parameter: parameter,
+				body: body, resultBits: width, signed: true,
+			})
+		}
+	}
+	// Match the raw extension/flag use in Arrow independently of vector paths.
+	cases = append(cases, arm64PaddingCase{
+		name: fmt.Sprintf("narrow%d", len(cases)), parameter: 16, resultBits: 64,
+		body: "MOVD rhs+0(FP),R2\nMOVW $0,R11\nWORD $0x6b22a17f\nCSET GT,R0\n",
+	})
+	return cases
+}
+
+func arm64PaddingSource(cases []arm64PaddingCase) (source, declarations string) {
+	var asm, goSource strings.Builder
+	goSource.WriteString("package padbits\n")
+	for _, test := range cases {
+		fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$0-16\n%sMOVD R0,res+8(FP)\nRET\n", test.name, test.body)
+		fmt.Fprintf(&goSource, "func %s(rhs int%d) (res uint64)\n", test.name, test.parameter)
+	}
+	return asm.String(), goSource.String()
+}
+
+func arm64PaddingExpected(test arm64PaddingCase, input uint64) uint64 {
+	var value int64
+	switch test.parameter {
+	case 8:
+		value = int64(int8(input))
+	case 16:
+		value = int64(int16(input))
+	case 32:
+		value = int64(int32(input))
+	}
+	if strings.Contains(test.body, "CSET") {
+		if value < 0 {
+			return 1 // CMP 0, rhs.SXTH: zero > negative.
+		}
+		return 0
+	}
+	if !test.signed {
+		return input & arm64PaddingMask(test.parameter)
+	}
+	return uint64(value) & arm64PaddingMask(test.resultBits)
+}
+
+func TestARM64FPPaddingScalarAndVectorCompleteObjects(t *testing.T) {
+	cases := arm64PaddingCases()
+	source, declarations := arm64PaddingSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	pkg := mustGoPackage(t, "padbits", declarations)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOOS: "linux", GOARCH: "arm64", TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path)})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer translated.Module.Dispose()
+			compileLLVMToObject(t, llc, triple, "padding.ll", "padding.o", translated.Module.String())
+		})
+	}
+	t.Logf("%d typed source cases; seven scalar load aliases and all seven SIMD arrangements", len(cases))
+}
+
+func TestARM64FPPaddingBitMasksDoNotLoseRotationOrSignDependence(t *testing.T) {
+	for _, width := range []int{8, 16, 32, 64} {
+		for shift := 1; shift <= width; shift++ {
+			for _, signed := range []bool{false, true} {
+				mask := uint64(1) << uint(width-1)
+				got := arm64PaddingShift(mask, width, int64(shift), true, signed)
+				if signed && got == 0 {
+					t.Fatalf("unknown sign bit disappeared: width=%d shift=%d", width, shift)
+				}
+				if !signed && shift == width && got != 0 {
+					t.Fatalf("complete unsigned truncation retained bits: %#x", got)
+				}
+			}
+		}
+	}
+	state := arm64PaddingState{"R2": {0xffffffffffff0000, 0}}
+	for _, word := range []bool{false, true} {
+		for shift := int64(1); shift < 32; shift++ {
+			arg := Operand{Kind: OpRegShift, Reg: "R2", ShiftOp: ShiftRotate, ShiftAmount: shift}
+			if state.operand(arg, word) == 0 {
+				t.Fatalf("rotation washed away padding: word=%t shift=%d", word, shift)
+			}
+		}
+	}
+}
diff --git a/arm64_fp_padding_guard_test.go b/arm64_fp_padding_guard_test.go
new file mode 100644
index 000000000..23efa6a71
--- /dev/null
+++ b/arm64_fp_padding_guard_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func arm64PaddingTestInput(t *testing.T, declaration, body string) (Func, FuncSig) {
+	t.Helper()
+	pkg := mustGoPackage(t, "example.invalid/padbits", "package padbits\n"+declaration+"\n")
+	fn := pkg.Types.Scope().Lookup("Narrow").(*types.Func)
+	sig, err := DeriveGoFuncABI0Signature("Narrow", fn, "arm64", types.SizesFor("gc", "arm64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchARM64, "TEXT Narrow(SB),4,$0-16\n"+body+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	function, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	return function, sig
+}
+
+func TestARM64FPPaddingEveryObservableUseStaysContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"result":          "MOVD R2,res+8(FP)",
+		"copy-result":     "MOVD R2,R3\nMOVD R3,res+8(FP)",
+		"flags":           "CMP $0,R2\nMOVD $0,R0\nMOVD R0,res+8(FP)",
+		"extended-flags":  "CMP R2.UXTW,R0\nMOVD R0,res+8(FP)",
+		"branch":          "CBZ R2,done\ndone:\nMOVD $0,R0\nMOVD R0,res+8(FP)",
+		"address":         "MOVD (R2),R0\nMOVD R0,res+8(FP)",
+		"index":           "MOVD (R0)(R2),R0\nMOVD R0,res+8(FP)",
+		"store":           "MOVD R2,(R0)\nMOVD $0,R0\nMOVD R0,res+8(FP)",
+		"vector-store":    "VDUP R2,V0.D2\nVST1 [V0.D2],(R0)\nMOVD $0,R0\nMOVD R0,res+8(FP)",
+		"vector-alias":    "VDUP R2,V0.D2\nVMOV V0.D[0],V0\nVMOV V0.D[0],R0\nMOVD R0,res+8(FP)",
+		"scalar-fp-alias": "VDUP R2,V0.D2\nFMOVD F0,R0\nMOVD R0,res+8(FP)",
+		"rotate":          "AND R2@>16,R0,R0\nMOVD R0,res+8(FP)",
+		"local-call":      "CALL helper\nMOVH R2,R0\nMOVD R0,res+8(FP)\nRET\nhelper:\nRET",
+		"external-call":   "CALL other(SB)\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"native":          "SVC $0\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"unknown":         "WHATEVER\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"unknown-word":    "WORD $0xffffffff\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"return-link":     "MOVD R2,R30\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"fixed-g":         "MOVD R2,R28\nMOVH R2,R0\nMOVD R0,res+8(FP)",
+		"one-path":        "CBZ R0,joined\nMOVH R2,R2\njoined:\nMOVD R2,res+8(FP)",
+		"loop-join":       "loop:\nMOVD R2,R3\nMOVH R2,R2\nCBNZ R0,loop\nMOVD R3,res+8(FP)",
+		"dead-use":        "MOVH R2,R0\nMOVD R0,res+8(FP)\nRET\ndead:\nMOVD rhs+0(FP),R2\nMOVD R2,res+8(FP)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn, sig := arm64PaddingTestInput(t, "func Narrow(rhs int16) (res uint64)", "MOVD rhs+0(FP),R2\n"+body)
+			if _, err := arm64FPPaddingReadProof(fn, fn, sig); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("observable/unknown use obtained representative: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64FPPaddingTypedIdentityAndBothCFGsAreMandatory(t *testing.T) {
+	fn, sig := arm64PaddingTestInput(t, "func Narrow(rhs int16) (res uint64)", "MOVD rhs+0(FP),R2\nMOVH R2,R0\nMOVD R0,res+8(FP)")
+	if sig.arm64FPReadDeclaration == nil {
+		t.Fatal("complete GC ARM64 declaration did not produce private witness")
+	}
+	for name, mutate := range map[string]func(*FuncSig){
+		"arg":      func(s *FuncSig) { s.Args = []LLVMType{I32} },
+		"ret":      func(s *FuncSig) { s.Ret = I32 },
+		"frame":    func(s *FuncSig) { s.Frame.Params = []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}} },
+		"result":   func(s *FuncSig) { s.Frame.Results = []FrameSlot{{Offset: 6, Type: I64, Index: 0, Field: -1}} },
+		"register": func(s *FuncSig) { s.ArgRegs = []Reg{"R2"} },
+		"name":     func(s *FuncSig) { s.Name = "Different" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := sig
+			mutate(&changed)
+			if _, err := arm64FPPaddingReadProof(fn, fn, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed signature retained authority: %v", err)
+			}
+		})
+	}
+	bad, _ := arm64PaddingTestInput(t, "func Narrow(rhs int16) (res uint64)", "MOVD rhs+0(FP),R2\nMOVD R2,res+8(FP)")
+	for _, pair := range [][2]Func{{fn, bad}, {bad, fn}} {
+		if _, err := arm64FPPaddingReadProof(pair[0], pair[1], sig); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("one certified CFG hid other bad use: %v", err)
+		}
+	}
+	bad = fn
+	bad.Instrs = append([]Instr(nil), fn.Instrs...)
+	bad.Instrs[0].Op = "MOVW"
+	if _, err := arm64FPPaddingReadProof(fn, bad, sig); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("changed native load width retained exact source identity: %v", err)
+	}
+}
+
+func TestARM64FPPaddingNoGeneralHoleAddressOrStoreAuthority(t *testing.T) {
+	pkg := mustGoPackage(t, "example.invalid/padbits", "package padbits\ntype Row struct { a byte; b uint64 }\nfunc Narrow(rhs int16) (res uint64)\nfunc Internal(row Row) (res uint64)\n")
+	for _, source := range []string{
+		"TEXT ·Narrow(SB),4,$0-16\nMOVD rhs+2(FP),R0\nMOVD R0,res+8(FP)\nRET\n",
+		"TEXT ·Narrow(SB),4,$0-16\nMOVD R0,rhs+0(FP)\nMOVD R0,res+8(FP)\nRET\n",
+		"TEXT ·Narrow(SB),4,$0-16\nMOVD rhs+0(FP),R2\nMOVD $rhs+2(FP),R0\nMOVH R2,R1\nMOVD R1,res+8(FP)\nRET\n",
+		"TEXT ·Internal(SB),4,$0-24\nMOVD row+0(FP),R2\nMOVB R2,R0\nMOVD R0,res+16(FP)\nRET\n",
+	} {
+		translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)})
+		if err == nil {
+			translated.Module.Dispose()
+			t.Fatalf("generic padding/address/store permission appeared for %s", source)
+		}
+		if !strings.Contains(err.Error(), "FP") && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unexpected failure: %v", err)
+		}
+	}
+}
+
+func TestARM64FPPaddingSevenScalarStoresStillNeedDeclaredBytes(t *testing.T) {
+	pkg := mustGoPackage(t, "padbits", "package padbits\nfunc Narrow(rhs int8) (res uint64)\n")
+	for _, op := range []Op{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		t.Run(string(op), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT ·Narrow(SB),4,$0-16\nMOVD rhs+0(FP),R2\nMOVB R2,R0\n%s R0,rhs+1(FP)\nMOVD R0,res+8(FP)\nRET\n", op)
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path),
+			})
+			if err == nil {
+				translated.Module.Dispose()
+				t.Fatal("read-only bit certificate created a writable padding slot")
+			}
+			if !strings.Contains(err.Error(), "FP") {
+				t.Fatalf("unrelated store rejection: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64FPPaddingConsumerRechecksEveryBoundInput(t *testing.T) {
+	fn, sig := arm64PaddingTestInput(t, "func Narrow(rhs int16) (res uint64)", "MOVD rhs+0(FP),R2\nMOVH R2,R0\nMOVD R0,res+8(FP)")
+	reads, err := arm64FPPaddingReadProof(fn, fn, sig)
+	if err != nil || len(reads) != 1 {
+		t.Fatalf("source proof: %v; reads=%d", err, len(reads))
+	}
+	var key [2]int
+	for k := range reads {
+		key = k
+	}
+	for _, name := range []string{"missing-producer", "changed-signature", "changed-read", "changed-instruction", "changed-operand-in-place", "changed-frame-offset", "changed-decoded-origin", "negative-index"} {
+		t.Run(name, func(t *testing.T) {
+			copyFunc := fn
+			copyFunc.Instrs = append([]Instr(nil), fn.Instrs...)
+			for i := range copyFunc.Instrs {
+				copyFunc.Instrs[i].Args = append([]Operand(nil), fn.Instrs[i].Args...)
+			}
+			context, _ := newARM64CtxWithFuncForTest(t, copyFunc, sig, nil)
+			context.blocks = arm64SplitBlocks(copyFunc)
+			context.currentBlock, context.currentInstruction = key[0], key[1]
+			read := reads[key]
+			context.fpPaddingReads = map[[2]int]arm64FPPaddingRead{key: read}
+			if _, err := context.loadFPFrameBits(0, 8); err != nil {
+				t.Fatalf("unaltered complete consumer fixture: %v", err)
+			}
+			switch name {
+			case "missing-producer":
+				context.sig.arm64FPReadDeclaration = nil
+			case "changed-signature":
+				context.sig.Name = "Different"
+			case "changed-read":
+				read.declared--
+				context.fpPaddingReads[key] = read
+			case "changed-instruction":
+				context.blocks[key[0]].instrs = append([]Instr(nil), context.blocks[key[0]].instrs...)
+				context.blocks[key[0]].instrs[key[1]].Op = "MOVW"
+			case "changed-operand-in-place":
+				context.blocks[key[0]].instrs[key[1]].Args[1].Reg = "R3"
+			case "changed-frame-offset":
+				offset := int64(4096)
+				context.blocks[key[0]].instrs[key[1]].arm64ScalarMemoryFrameOffset = &offset
+			case "changed-decoded-origin":
+				context.blocks[key[0]].instrs[key[1]].arm64Encoded = true
+			case "negative-index":
+				context.currentBlock = -1
+				context.fpPaddingReads[[2]int{-1, key[1]}] = read
+			}
+			if _, err := context.loadFPFrameBits(0, 8); err == nil {
+				t.Fatal("stale/private fabricated consumer record authorized padding")
+			}
+		})
+	}
+}
diff --git a/arm64_fp_padding_inputs_test.go b/arm64_fp_padding_inputs_test.go
new file mode 100644
index 000000000..ad3c56a9d
--- /dev/null
+++ b/arm64_fp_padding_inputs_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"go/types"
+	"testing"
+)
+
+type arm64PaddingChangedSizes struct {
+	types.Sizes
+	change string
+}
+
+func (s arm64PaddingChangedSizes) Sizeof(typ types.Type) int64 {
+	if s.change == "narrow-size" && typ == types.Typ[types.Int16] {
+		return 4
+	}
+	return s.Sizes.Sizeof(typ)
+}
+
+func (s arm64PaddingChangedSizes) Alignof(typ types.Type) int64 {
+	if s.change == "narrow-align" && typ == types.Typ[types.Int16] {
+		return 4
+	}
+	return s.Sizes.Alignof(typ)
+}
+
+func (s arm64PaddingChangedSizes) Offsetsof(fields []*types.Var) []int64 {
+	offsets := append([]int64(nil), s.Sizes.Offsetsof(fields)...)
+	if s.change == "aggregate-offset" && len(offsets) > 1 {
+		offsets[1]++
+	}
+	return offsets
+}
+
+func TestARM64FPPaddingWholeTypedSizesAreRequired(t *testing.T) {
+	pkg := mustGoPackage(t, "padbits", "package padbits\ntype Row struct { a byte; b uint64 }\nfunc Narrow(row Row, rhs int16) (res uint64)\n")
+	declaration := pkg.Types.Scope().Lookup("Narrow").(*types.Func)
+	gc := types.SizesFor("gc", "arm64")
+	sig, err := DeriveGoFuncABI0Signature("Narrow", declaration, "arm64", gc)
+	if err != nil || sig.arm64FPReadDeclaration == nil {
+		t.Fatalf("complete actual GC declaration: %v", err)
+	}
+	for _, change := range []string{"narrow-size", "narrow-align", "aggregate-offset"} {
+		changed := arm64PaddingChangedSizes{Sizes: gc, change: change}
+		for _, layouts := range [][2]types.Sizes{{changed, gc}, {gc, changed}} {
+			if got := arm64FPReadDeclarationForGo(sig, declaration.Type().(*types.Signature), layouts[0], layouts[1]); got != nil {
+				t.Fatalf("%s custom typed/frame layout obtained padding authority", change)
+			}
+		}
+	}
+}
+
+func TestARM64FPPaddingModifiedConstantDependencies(t *testing.T) {
+	forms := append(arm64RawMOVIMVNIForms(), arm64RawORRBICForms()...)
+	for _, form := range forms {
+		for _, immediate := range []byte{0, 1, 0x55, 0x80, 0xff} {
+			word := encodeARM64RawModifiedImmediate(form.opBit, form.cmode, form.q, immediate, 0)
+			decoded, ok := decodeARM64RawModifiedImmediate(word)
+			if !ok {
+				t.Fatal("existing typed constant grammar rejected its complete fixture")
+			}
+			old := arm64PaddingBits{0xffffffffffffffff, 0xffffffffffffffff}
+			state := arm64PaddingState{"V0": old}
+			ins := Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}
+			if !state.transferPaddingRawConstant(ins) {
+				t.Fatal("registered constant family was not consumed")
+			}
+			want := arm64PaddingBits{}
+			if form.op == "VORR" || form.op == "VBIC" {
+				for lane := 0; lane < form.arrangement.lanes; lane++ {
+					want.setElement(form.arrangement.elementBits, lane, arm64PaddingMask(form.arrangement.elementBits)&^decoded.value)
+				}
+			}
+			if got := state.read("V0"); got != want {
+				t.Fatalf("%s cmode=%d Q=%d immediate=%#x: dependency=%#v want=%#v", form.op, form.cmode, form.q, immediate, got, want)
+			}
+		}
+	}
+	for _, operand := range []Operand{
+		{Kind: OpImm, Imm: 0xffffffff},
+		{Kind: OpImm, Imm: 0x4f000400, ImmRaw: "unresolved"},
+		{Kind: OpImm, Imm: 0x4f000400, ImmIsFloat: true},
+		{Kind: OpReg, Reg: "R0"},
+	} {
+		state := arm64PaddingState{"V0": {1, 1}}
+		if state.transferPaddingRawConstant(Instr{Op: OpWORD, Args: []Operand{operand}}) || state.read("V0") != (arm64PaddingBits{1, 1}) {
+			t.Fatal("unknown/unresolved raw constant washed away a dependency")
+		}
+	}
+}
diff --git a/arm64_fp_padding_proof.go b/arm64_fp_padding_proof.go
new file mode 100644
index 000000000..1845b5a54
--- /dev/null
+++ b/arm64_fp_padding_proof.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"fmt"
+	mathbits "math/bits"
+	"reflect"
+	"strings"
+)
+
+type arm64FPPaddingRead struct {
+	instruction Instr
+	offset      int64
+	bytes       int64
+	declared    int64
+}
+
+type arm64PaddingState map[string]arm64PaddingBits
+
+func (s arm64PaddingState) clone() arm64PaddingState {
+	copyState := make(arm64PaddingState, len(s))
+	for reg, value := range s {
+		copyState[reg] = value
+	}
+	return copyState
+}
+
+func (s arm64PaddingState) merge(other arm64PaddingState) bool {
+	changed := false
+	for reg, value := range other {
+		old := s[reg]
+		merged := arm64PaddingBits{old[0] | value[0], old[1] | value[1]}
+		if merged != old {
+			s[reg], changed = merged, true
+		}
+	}
+	return changed
+}
+
+func (s arm64PaddingState) read(reg Reg) arm64PaddingBits {
+	if reg == ZR {
+		return arm64PaddingBits{}
+	}
+	return s[arm64MachineRegister(reg)]
+}
+
+func (s arm64PaddingState) write(reg Reg, value arm64PaddingBits) {
+	if reg != ZR {
+		s[arm64MachineRegister(reg)] = value
+	}
+}
+
+func (s arm64PaddingState) operand(arg Operand, word bool) uint64 {
+	bits := 64
+	if word {
+		bits = 32
+	}
+	value := s.read(arg.Reg)[0] & arm64PaddingMask(bits)
+	switch arg.Kind {
+	case OpReg:
+		return value
+	case OpRegShift:
+		if arg.ShiftReg != "" {
+			return value | s.read(arg.ShiftReg)[0]
+		}
+		if arg.ShiftOp == ShiftRotate {
+			if word {
+				return uint64(mathbits.RotateLeft32(uint32(value), -int(arg.ShiftAmount)))
+			}
+			return mathbits.RotateLeft64(value, -int(arg.ShiftAmount))
+		}
+		return arm64PaddingShift(value, bits, arg.ShiftAmount, arg.ShiftOp != ShiftLeft, arg.ShiftOp == ShiftArith)
+	case OpRegExtend:
+		extendBits, signed := 64, false
+		switch arg.Ext {
+		case ExtendUXTB, ExtendSXTB:
+			extendBits = 8
+		case ExtendUXTH, ExtendSXTH:
+			extendBits = 16
+		case ExtendUXTW, ExtendSXTW:
+			extendBits = 32
+		}
+		signed = arg.Ext == ExtendSXTB || arg.Ext == ExtendSXTH || arg.Ext == ExtendSXTW || arg.Ext == ExtendSXTX
+		return arm64PaddingExtend(value, extendBits, signed, bits) << uint(arg.ShiftAmount) & arm64PaddingMask(bits)
+	}
+	return 0
+}
+
+func (s arm64PaddingState) observes(arg Operand) bool {
+	unknown := func(reg Reg) bool { return s.read(reg) != (arm64PaddingBits{}) }
+	switch arg.Kind {
+	case OpReg, OpRegShift, OpRegExtend:
+		return unknown(arg.Reg) || arg.ShiftReg != "" && unknown(arg.ShiftReg)
+	case OpMem:
+		return unknown(arg.Mem.Base) || arg.Mem.Index != "" && unknown(arg.Mem.Index)
+	case OpRegList:
+		for _, reg := range arg.RegList {
+			if unknown(reg) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func arm64FPPaddingCandidate(ins Instr, decl *arm64FPReadDeclaration) (arm64FPPaddingRead, bool) {
+	form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins)
+	if !handled || err != nil || form.store || form.memory.Kind != OpFP || decl == nil {
+		return arm64FPPaddingRead{}, false
+	}
+	offset, bytes := form.memory.FPOffset, int64(form.bits/8)
+	end := decl.parameter.Offset + frameTypeSize(decl.parameter.Type, 8)
+	if offset < decl.parameter.Offset || offset >= end || bytes <= end-offset || bytes > decl.paddingEnd-offset {
+		return arm64FPPaddingRead{}, false
+	}
+	snapshot := ins
+	snapshot.Args = append([]Operand(nil), ins.Args...)
+	for i := range snapshot.Args {
+		snapshot.Args[i].RegList = append([]Reg(nil), ins.Args[i].RegList...)
+	}
+	if ins.arm64ScalarMemoryFrameOffset != nil {
+		offset := *ins.arm64ScalarMemoryFrameOffset
+		snapshot.arm64ScalarMemoryFrameOffset = &offset
+	}
+	return arm64FPPaddingRead{instruction: snapshot, offset: offset, bytes: bytes, declared: end - offset}, true
+}
+
+func arm64FPPaddingReadProof(original, normalized Func, sig FuncSig) (map[[2]int]arm64FPPaddingRead, error) {
+	decl := sig.arm64FPReadDeclaration
+	if decl == nil {
+		return nil, nil
+	}
+	hasRead := false
+	for _, ins := range normalized.Instrs {
+		if _, candidate := arm64FPPaddingCandidate(ins, decl); candidate {
+			hasRead = true
+		}
+	}
+	if !hasRead {
+		return nil, nil
+	}
+	if !decl.matches(sig) || strings.HasSuffix(original.Sym, "<ABIInternal>") || original.arm64PrivateRegisterEntry {
+		return nil, arm64PaddingContext("missing or changed complete typed ABI0 declaration")
+	}
+	// Prepare an independent copy of the original raw CFG. No partial proof or
+	// normalized-only acceptance can authorize a representative padding value.
+	prepared, err := normalizeARM64ScalarMemoryFrame(original)
+	if err == nil {
+		prepared, err = normalizeARM64AtomicPairNamedMemory(prepared)
+	}
+	if err == nil {
+		prepared, err = normalizeARM64NamedPCRelative(prepared)
+	}
+	if err == nil {
+		prepared, _, err = prepareARM64RawPCRelativeWithReturnClobbers(prepared, arm64RawPoolReturnClobbers(prepared, sig))
+	}
+	if err != nil {
+		return nil, err
+	}
+	first, err := proveARM64FPPaddingBits(prepared, decl)
+	if err != nil {
+		return nil, fmt.Errorf("original source: %w", err)
+	}
+	final, err := proveARM64FPPaddingBits(normalized, decl)
+	if err != nil {
+		return nil, fmt.Errorf("normalized source: %w", err)
+	}
+	if !reflect.DeepEqual(first, final) {
+		return nil, arm64PaddingContext("original/normalized parameter reads disagree")
+	}
+	return final, nil
+}
+
+func arm64PaddingContext(format string, args ...any) error {
+	return fmt.Errorf("%w: ARM64 FP padding bit-use %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func proveARM64FPPaddingBits(fn Func, decl *arm64FPReadDeclaration) (map[[2]int]arm64FPPaddingRead, error) {
+	if len(fn.Instrs) > 32768 {
+		return nil, arm64PaddingContext("source exceeds bounded instruction inventory")
+	}
+	blocks := arm64SplitBlocks(fn)
+	indices := make(map[string]int, len(blocks))
+	for i, block := range blocks {
+		if _, duplicate := indices[block.name]; duplicate {
+			return nil, arm64PaddingContext("duplicate source CFG label")
+		}
+		indices[block.name] = i
+	}
+	before := make([]arm64PaddingState, len(blocks))
+	reads := make(map[[2]int]arm64FPPaddingRead)
+	queue, queued := []int{}, make([]bool, len(blocks))
+	propagate := func(index int, state arm64PaddingState) error {
+		if index < 0 || index >= len(blocks) {
+			return arm64PaddingContext("unknown CFG edge")
+		}
+		changed := false
+		if before[index] == nil {
+			before[index], changed = state.clone(), true
+		} else {
+			changed = before[index].merge(state)
+		}
+		if changed && !queued[index] {
+			queue, queued[index] = append(queue, index), true
+		}
+		return nil
+	}
+	work := 0
+	// Include dead components too; later normalizations cannot erase a bad use.
+	for seed := range blocks {
+		if before[seed] != nil {
+			continue
+		}
+		if err := propagate(seed, arm64PaddingState{}); err != nil {
+			return nil, err
+		}
+		for next := 0; next < len(queue); next++ {
+			bi := queue[next]
+			queued[bi] = false
+			state := before[bi].clone()
+			terminated := false
+			for ii, source := range blocks[bi].instrs {
+				work++
+				if work > 131072 {
+					return nil, arm64PaddingContext("CFG proof exhausted its bounded work")
+				}
+				if handled := state.transferPaddingRawConstant(source); handled {
+					continue
+				}
+				ins := arm64ControlDecode(source)
+				op := arm64ControlOp(ins)
+				if op == OpTEXT {
+					if bi != 0 || ii != 0 {
+						return nil, arm64PaddingContext("unexpected nested TEXT")
+					}
+					continue
+				}
+				if op == "BL" || op == "BLR" || op == "CALL" || op == "DUFFCOPY" || op == "DUFFZERO" ||
+					op == "SVC" || op == "HVC" || op == "SMC" || op == "ERET" || op == OpWORD {
+					return nil, arm64PaddingContext("unknown/native call or instruction: %q", source.Raw)
+				}
+				if op == OpRET {
+					if len(ins.Args) != 0 || state.read("R30") != (arm64PaddingBits{}) || state.read(SP) != (arm64PaddingBits{}) ||
+						state.read("R29") != (arm64PaddingBits{}) || state.read("R28") != (arm64PaddingBits{}) || state.read("R18") != (arm64PaddingBits{}) {
+						return nil, arm64PaddingContext("unbound caller return: %q", source.Raw)
+					}
+					terminated = true
+					break
+				}
+				if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+					if len(ins.Args) == 0 {
+						return nil, arm64PaddingContext("missing CFG target")
+					}
+					for _, arg := range ins.Args[:len(ins.Args)-1] {
+						if state.observes(arg) {
+							return nil, arm64PaddingContext("branch observes padding: %q", source.Raw)
+						}
+					}
+					name, valid := arm64BranchTarget(ins.Args[len(ins.Args)-1])
+					target, present := indices[name]
+					if !valid || !present {
+						return nil, arm64PaddingContext("nonlocal/unknown CFG target: %q", source.Raw)
+					}
+					if err := propagate(target, state); err != nil {
+						return nil, err
+					}
+					if arm64IsConditionalBranch(op) {
+						if err := propagate(bi+1, state); err != nil {
+							return nil, err
+						}
+					}
+					terminated = true
+					break
+				}
+				if read, candidate := arm64FPPaddingCandidate(ins, decl); candidate {
+					reads[[2]int{bi, ii}] = read
+				}
+				if err := state.transferPadding(ins, decl); err != nil {
+					return nil, fmt.Errorf("%w at %q", err, source.Raw)
+				}
+			}
+			if !terminated {
+				if bi+1 >= len(blocks) {
+					return nil, arm64PaddingContext("missing explicit source terminator")
+				}
+				if err := propagate(bi+1, state); err != nil {
+					return nil, err
+				}
+			}
+		}
+		queue = nil
+	}
+	return reads, nil
+}
diff --git a/arm64_fp_padding_reads_test.go b/arm64_fp_padding_reads_test.go
new file mode 100644
index 000000000..784cf6763
--- /dev/null
+++ b/arm64_fp_padding_reads_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64FPPaddingReadNeedsCompleteTypedBitUseProof(t *testing.T) {
+	pkg := mustGoPackage(t, "example.invalid/padbits", "package padbits\nfunc Narrow(rhs int16) (res uint64)\n")
+	for _, body := range []string{
+		"MOVD rhs+0(FP),R2\nMOVH R2,R0\n",
+		"MOVD rhs+0(FP),R2\nVDUP R2,V0.S2\nVSHL $16,V0.S2,V1.S2\nVSSHR $16,V1.S2,V1.S2\nVMOV V1.S[0],R0\n",
+	} {
+		source := "TEXT ·Narrow(SB),4,$0-16\n" + body + "MOVD R0,res+8(FP)\nRET\n"
+		translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			ResolveSym: testResolveSym(pkg.Path),
+		})
+		if err != nil {
+			t.Fatalf("typed source discards every padding bit: %v", err)
+		}
+		translated.Module.Dispose()
+	}
+}
+
+func TestARM64FPPaddingReadCannotInferPermissionFromSparseFrame(t *testing.T) {
+	const source = "TEXT narrow(SB),4,$0-16\nMOVD rhs+0(FP),R2\nMOVH R2,R0\nMOVD R0,res+8(FP)\nRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"narrow": {
+			Name: "narrow", Args: []LLVMType{I16}, Ret: I64,
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I16, Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+			},
+		}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "has no slot") {
+		t.Fatalf("manual sparse slots supplied padding permissions: %v", err)
+	}
+}
diff --git a/arm64_fp_padding_runtime_test.go b/arm64_fp_padding_runtime_test.go
new file mode 100644
index 000000000..2a0e7f2d5
--- /dev/null
+++ b/arm64_fp_padding_runtime_test.go
@@ -0,0 +1,317 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func arm64PaddingRuntimeInputs() []uint64 {
+	values := []uint64{0, 1, 0x7f, 0x80, 0xff, 0x7fff, 0x8000, 0xffff, 0x7fffffff, 0x80000000, 0xffffffff, ^uint64(0)}
+	x := uint64(0x6492b630f84d)
+	for i := 0; i < 64; i++ {
+		x ^= x << 13
+		x ^= x >> 7
+		x ^= x << 17
+		values = append(values, x)
+	}
+	return values
+}
+
+// Only the native Go caller shim writes padding: the translated function and
+// its original native-width load are identical. This makes unspecified bytes
+// vary independently of the real narrow argument instead of assuming zero.
+func arm64PaddingNativeCaller(test arm64PaddingCase) string {
+	move := map[int]string{8: "MOVB", 16: "MOVH", 32: "MOVW"}[test.parameter]
+	return fmt.Sprintf(`
+TEXT ·pad_%s(SB),4,$80-24
+    MOVD noise+8(FP),R0
+    MOVD R0,8(RSP)
+    %s rhs+0(FP),R0
+    %s R0,8(RSP)
+    MOVD $0xcafef00d01234567,R12
+    MOVD R12,24(RSP)
+    MOVD R12,32(RSP)
+    MOVD g,R12
+    MOVD R12,40(RSP)
+    WORD $0xaa1203ec // mov x12,x18: Go's OS-reserved register is not named.
+    MOVD R12,48(RSP)
+    MOVD 0(RSP),R12
+    MOVD R12,56(RSP)
+    MOVD RSP,R12
+    MOVD R12,64(RSP)
+    CALL ·%s(SB)
+    MOVD $0xcafef00d01234567,R12
+    MOVD 24(RSP),R13
+    CMP R12,R13
+    BNE bad_%s
+    MOVD 32(RSP),R13
+    CMP R12,R13
+    BNE bad_%s
+    MOVD 40(RSP),R12
+    CMP g,R12
+    BNE bad_%s
+    MOVD 48(RSP),R13
+    WORD $0xaa1203ec
+    CMP R12,R13
+    BNE bad_%s
+    MOVD 0(RSP),R12
+    MOVD 56(RSP),R13
+    CMP R12,R13
+    BNE bad_%s
+    MOVD RSP,R12
+    MOVD 64(RSP),R13
+    CMP R12,R13
+    BNE bad_%s
+    MOVD 16(RSP),R0
+    MOVD R0,res+16(FP)
+    RET
+bad_%s:
+    MOVD $0xdeadbeeff00dbabe,R0
+    MOVD R0,res+16(FP)
+    RET
+`, test.name, move, move, test.name, test.name, test.name, test.name, test.name, test.name, test.name, test.name)
+}
+
+func TestARM64FPPaddingOriginalGoRandomizedBytes(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("original Go runtime requires an ARM64 host; objects are tested independently")
+	}
+	arm64FPPaddingOriginalGoRandomizedBytes(t, nil)
+}
+
+func arm64FPPaddingOriginalGoRandomizedBytes(t *testing.T, runner []string) {
+	t.Helper()
+	cases := arm64PaddingCases()
+	source, declarations := arm64PaddingSource(cases)
+	declarations = strings.Replace(declarations, "package padbits", "package main", 1)
+	var driver strings.Builder
+	driver.WriteString("package main\n\nimport \"fmt\"\n\n")
+	for _, test := range cases {
+		fmt.Fprintf(&driver, "func pad_%s(rhs int%d, noise uint64) (res uint64)\n", test.name, test.parameter)
+		source += arm64PaddingNativeCaller(test)
+	}
+	driver.WriteString("\nfunc main() {\n")
+	driver.WriteString("    inputs := []uint64{")
+	for _, input := range arm64PaddingRuntimeInputs() {
+		fmt.Fprintf(&driver, "%d,", input)
+	}
+	driver.WriteString("}\n    count := 0\n")
+	count := 0
+	for _, test := range cases {
+		driver.WriteString("    {\n        want := []uint64{")
+		for _, input := range arm64PaddingRuntimeInputs() {
+			fmt.Fprintf(&driver, "%d,", arm64PaddingExpected(test, input))
+			count += 4
+		}
+		fmt.Fprintf(&driver, `}
+        for i, input := range inputs {
+            // Padding varies independently from the real parameter bits.
+            noises := []uint64{0, ^uint64(0), input * 0x9e3779b97f4a7c15, input ^ 0xd1096542b630f84d}
+            for _, noise := range noises {
+                got := pad_%s(int%d(input), noise)
+                if got != want[i] {
+                    panic(fmt.Sprintf("%s input=%%x noise=%%x got=%%x want=%%x", input, noise, got, want[i]))
+                }
+                count++
+            }
+        }
+    }
+`, test.name, test.parameter, test.name)
+	}
+	driver.WriteString("    fmt.Printf(\"padding %d\\n\", count)\n}\n")
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module padbits\n\ngo 1.20\n", "main.go": driver.String(),
+		"decl.go": declarations, "padding_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	args := []string{"run", "-p=1"}
+	if len(runner) != 0 {
+		// Go's -exec parses a quoted argument list, not a shell command.
+		// Retain the exact required runner's executable and sysroot arguments.
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		args = append(args, "-exec="+quoted)
+	}
+	command := exec.CommandContext(ctx, "go", append(args, ".")...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	out, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || string(out) != fmt.Sprintf("padding %d\n", count) {
+		t.Fatalf("original Go random padding, adjacent stack/g/OS18/LR/SP canaries: %v\n%s", err, out)
+	}
+	t.Logf("%d original Go calls with randomized ABI0 padding and control/stack canaries", count)
+}
+
+func TestARM64FPPaddingLLVMIndependentNumericalAndCanaries(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("LLVM numerical execution requires an ARM64 host; cross objects remain mandatory")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arm64FPPaddingLLVMIndependentNumericalAndCanaries(t, llc,
+		testTargetTriple(runtime.GOOS, runtime.GOARCH), []string{clang}, nil)
+}
+
+func arm64FPPaddingLLVMIndependentNumericalAndCanaries(t *testing.T, llc, triple string, compiler, runner []string) {
+	t.Helper()
+	cases := arm64PaddingCases()
+	source, declarations := arm64PaddingSource(cases)
+	pkg := mustGoPackage(t, "padbits", declarations)
+	translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOOS: runtime.GOOS, GOARCH: "arm64", TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translated.Module.Dispose()
+	var driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n\n")
+	for _, test := range cases {
+		symbol := "padbits." + test.name
+		if runtime.GOOS == "darwin" {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&driver, "extern uint64_t %s(int%d_t) __asm__(%q);\n", test.name, test.parameter, symbol)
+	}
+	driver.WriteString("\nint main(void) {\n")
+	for _, test := range cases {
+		for _, input := range arm64PaddingRuntimeInputs() {
+			fmt.Fprintf(&driver, `    {
+        volatile uint64_t guards[2] = { UINT64_C(0xcafef00d01234567), UINT64_C(0x76543210d00fefac) };
+        uint64_t result = %s((int%d_t) UINT64_C(%d));
+        if (result != UINT64_C(%d) || guards[0] != UINT64_C(0xcafef00d01234567) ||
+                guards[1] != UINT64_C(0x76543210d00fefac)) {
+            fprintf(stderr, "%s input=%%llx result=%%llx\n", (unsigned long long) UINT64_C(%d), (unsigned long long) result);
+            return 1;
+        }
+    }
+`, test.name, test.parameter, input, arm64PaddingExpected(test, input), test.name, input)
+		}
+	}
+	driver.WriteString("    return 0;\n}\n")
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "arm64_fp_padding", triple, translated.Module.String(), driver.String(), runner)
+	t.Logf("%d LLVM/C independent numerical cases; no assertion that native padding was initialized", len(cases)*len(arm64PaddingRuntimeInputs()))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FPPadding(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	// The required matrix consumes exactly the existing 46 forms, 76 inputs
+	// and four independent native padding values, including all old canaries.
+	arm64FPPaddingOriginalGoRandomizedBytes(t, runner)
+	arm64FPPaddingLLVMIndependentNumericalAndCanaries(t, llc, triple, compiler, runner)
+}
+
+func arm64PaddingGoExecArguments(args []string) (string, error) {
+	// cmd/internal/quoted.Split in both Go 1.20 and 1.27 treats quoted
+	// contents literally: backslashes are not escapes. Follow quoted.Join's
+	// choice of quote, but explicitly quote empty arguments so they survive.
+	quoted := make([]string, len(args))
+	for i, arg := range args {
+		single := strings.ContainsRune(arg, '\'')
+		double := strings.ContainsRune(arg, '"')
+		switch {
+		case single && double:
+			return "", fmt.Errorf("Go -exec argument %q contains both quote kinds", arg)
+		case arg != "" && !single && !double && !strings.ContainsAny(arg, " \t\n\r"):
+			quoted[i] = arg
+		case !single:
+			quoted[i] = "'" + arg + "'"
+		default:
+			quoted[i] = "\"" + arg + "\""
+		}
+	}
+	return strings.Join(quoted, " "), nil
+}
+
+func TestARM64FPPaddingGoExecArgumentsActualGo(t *testing.T) {
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":  "module paddingexecargv\n\ngo 1.20\n",
+		"main.go": "package main\n\nfunc main() {}\n",
+		"runner/main.go": `package main
+
+import (
+    "encoding/json"
+    "fmt"
+    "os"
+)
+
+func main() {
+    if len(os.Args) < 2 {
+        panic("go -exec did not append the compiled executable")
+    }
+    if _, err := os.Stat(os.Args[len(os.Args)-1]); err != nil {
+        panic(err)
+    }
+    encoded, err := json.Marshal(os.Args[1:len(os.Args)-1])
+    if err != nil {
+        panic(err)
+    }
+    fmt.Println(string(encoded))
+}
+`,
+	} {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	runner := filepath.Join(dir, gotoolchain.HostExecutable("exec runner"))
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", runner, "./runner")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH)
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("compile actual Go argv observer: %v\n%s", err, output)
+	}
+
+	want := []string{"plain", "with space", `back\slash`, "with\ttab", "with\nnewline", "with\rcarriage", "", "single'quote", `double"quote`}
+	encoded, err := arm64PaddingGoExecArguments(append([]string{runner}, want...))
+	if err != nil {
+		t.Fatal(err)
+	}
+	command = exec.CommandContext(ctx, "go", "run", "-p=1", "-exec="+encoded, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual Go -exec argv observer: %v\n%s", err, output)
+	}
+	var got []string
+	if err := json.Unmarshal(output, &got); err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("actual Go -exec changed argv: got %q, want %q, decode %v", got, want, err)
+	}
+}
+
+func TestARM64FPPaddingGoExecArgumentsRejectBothQuotes(t *testing.T) {
+	for _, arg := range []string{`both'"quotes`, "'double with space\"", "'\t\""} {
+		if encoded, err := arm64PaddingGoExecArguments([]string{"runner", arg}); err == nil || encoded != "" {
+			t.Fatalf("unrepresentable argument %q accepted as %q: %v", arg, encoded, err)
+		}
+	}
+}
diff --git a/arm64_fp_padding_transfer.go b/arm64_fp_padding_transfer.go
new file mode 100644
index 000000000..fec822f82
--- /dev/null
+++ b/arm64_fp_padding_transfer.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (s arm64PaddingState) transferPaddingRawConstant(ins Instr) bool {
+	if ins.Op != OpWORD || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm ||
+		ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return false
+	}
+	form, known := decodeARM64RawModifiedImmediate(uint32(ins.Args[0].Imm))
+	if !known {
+		return false
+	}
+	reg := Reg(fmt.Sprintf("V%d", form.destination))
+	result := arm64PaddingBits{}
+	if form.op == "VORR" || form.op == "VBIC" {
+		old := s.read(reg)
+		for lane := 0; lane < form.arrangement.lanes; lane++ {
+			// A known 1 in ORR or 0 in BIC kills just that dependency bit.
+			value := old.element(form.arrangement.elementBits, lane) &^ form.value
+			result.setElement(form.arrangement.elementBits, lane, value)
+		}
+	}
+	s.write(reg, result) // MOVI/MVNI overwrite; Q=0 clears the inactive high bank.
+	return true
+}
+
+func (s arm64PaddingState) transferPadding(ins Instr, decl *arm64FPReadDeclaration) error {
+	op := arm64ControlOp(ins)
+	if form, handled, err := parseARM64ScalarMemoryForm(op, ins); handled {
+		if err != nil {
+			return err
+		}
+		if s.observes(form.memory) {
+			return arm64PaddingContext("address observes unspecified bits")
+		}
+		// Preserve the real source encoder's address-before-scratch-before-data
+		// ordering; this proof never rewrites MOVD into a narrower source op.
+		if form.scratch {
+			s.write("R27", arm64PaddingBits{})
+		}
+		if form.store {
+			if s.read(form.data)[0]&arm64PaddingMask(form.bits) != 0 {
+				return arm64PaddingContext("store observes unspecified bits")
+			}
+			return nil
+		}
+		value := uint64(0)
+		if read, padding := arm64FPPaddingCandidate(ins, decl); padding {
+			value = arm64PaddingMask(form.bits) &^ arm64PaddingMask(int(read.declared*8))
+		}
+		value = arm64PaddingExtend(value, form.bits, form.signed, 64)
+		s.write(form.data, arm64PaddingBits{value, 0})
+		return nil
+	}
+	if op == "VMOV" || op == "VDUP" {
+		form, err := parseARM64VectorTransfer(op, ins)
+		if err != nil {
+			return err
+		}
+		value := arm64PaddingVectorTransfer(form, s.read(form.source), s.read(form.destination))
+		s.write(form.destination, value)
+		return nil
+	}
+	_, rightShift := arm64VectorShiftRightSpecs[op]
+	if op == "VSHL" || rightShift {
+		form, err := parseARM64VectorShift(op, ins)
+		if err != nil {
+			return err
+		}
+		value := arm64PaddingVectorShift(op, form, s.read(form.source), s.read(form.destination))
+		s.write(form.destination, value)
+		return nil
+	}
+	if bits, signed := arm64ScalarMemoryBits(op); bits != 0 && ins.Op == op && len(ins.Args) == 2 &&
+		ins.Args[1].Kind == OpReg && isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		source := ins.Args[0]
+		if source.Kind == OpReg && isARM64GeneralOrZeroReg(source.Reg) {
+			value := arm64PaddingExtend(s.read(source.Reg)[0], bits, signed, 64)
+			s.write(ins.Args[1].Reg, arm64PaddingBits{value, 0})
+			return nil
+		}
+		if source.Kind == OpImm && source.ImmRaw == "" && !source.ImmIsFloat &&
+			(op == "MOVD" || op == "MOVW" || source.Imm == 0) {
+			s.write(ins.Args[1].Reg, arm64PaddingBits{})
+			return nil
+		}
+	}
+	if spec, extend := arm64ScalarExtendSpecs[op]; extend {
+		if _, handled, err := parseARM64GPDataForm(op, ins); !handled || err != nil {
+			return arm64PaddingContext("invalid scalar extend")
+		}
+		destinationBits := 64
+		if spec.wordDestination {
+			destinationBits = 32
+		}
+		value := arm64PaddingExtend(s.read(ins.Args[0].Reg)[0], spec.sourceBits, spec.signed, destinationBits)
+		s.write(ins.Args[1].Reg, arm64PaddingBits{value, 0})
+		return nil
+	}
+	if form, handled, err := parseARM64GPDataForm(op, ins); handled {
+		if err != nil {
+			return err
+		}
+		if form.scratch != nil {
+			s.write("R27", arm64PaddingBits{})
+		}
+		word := strings.HasSuffix(string(op), "W")
+		value := uint64(0)
+		for _, input := range form.inputs {
+			value |= s.operand(input, word)
+		}
+		bits := 64
+		if word {
+			bits = 32
+		}
+		if value != 0 {
+			value = arm64PaddingMask(bits) // Conservative carries/variable shifts.
+		}
+		if len(form.inputs) == 2 && form.inputs[0].Kind == OpImm {
+			constant := uint64(form.inputs[0].Imm) & arm64PaddingMask(bits)
+			left := s.operand(form.inputs[1], word)
+			switch op {
+			case "AND", "ANDW", "ANDS", "ANDSW":
+				value = left & constant
+			case "BIC", "BICW", "BICS", "BICSW", "ORR", "ORRW":
+				value = left &^ constant
+			case "EOR", "EORW":
+				value = left
+			case "LSL", "LSLW", "LSR", "LSRW", "ASR", "ASRW":
+				value = arm64PaddingShift(left, bits, form.inputs[0].Imm, op != "LSL" && op != "LSLW", op == "ASR" || op == "ASRW")
+			}
+		}
+		switch op {
+		case "ADDS", "ADDSW", "SUBS", "SUBSW", "ANDS", "ANDSW", "BICS", "BICSW", "NEGS", "NEGSW", "CMP", "CMPW", "CMN", "CMNW", "TST", "TSTW":
+			if value != 0 {
+				return arm64PaddingContext("flags observe unspecified bits")
+			}
+		}
+		s.write(form.destination.Reg, arm64PaddingBits{value, 0})
+		return nil
+	}
+	if op == "CMP" || op == "CMPW" || op == "CMN" || op == "CMNW" || op == "TST" || op == "TSTW" {
+		word := strings.HasSuffix(string(op), "W")
+		if ins.Op != op || len(ins.Args) != 2 || validateARM64CompareNegativeOperands(ins.Args[0], ins.Args[1], word) != nil {
+			return arm64PaddingContext("unregistered comparison operands")
+		}
+		if s.operand(ins.Args[0], word) != 0 || s.operand(ins.Args[1], word) != 0 {
+			return arm64PaddingContext("comparison observes unspecified bits")
+		}
+		return nil
+	}
+	// Only this explicit operand-complete remainder is admitted. Unrecognized
+	// instructions cannot gain a hidden-state permission merely because their
+	// parser happened to expose no padding-tainted explicit operand.
+	switch op {
+	case "NOP", "VMOVQ", "VADD", "VADDP", "VSUB", "VAND", "VORR", "VEOR", "VBIC",
+		"VCMGT", "VCMGE", "VCMEQ", "VCMHI", "VCMHS", "VCMTST", "VUSHL", "VSSHL", "VUSHLL", "VSSHLL", "VUXTL", "VUXTL2",
+		"CSET", "CSETW", "CSETM", "CSETMW", "FMOVS", "FMOVD", "VLD1", "VLD2", "VLD3", "VLD4", "VST1", "VST2", "VST3", "VST4":
+	default:
+		if (op != "MOVBW" && op != "MOVHW") || !ins.arm64Encoded {
+			return arm64PaddingContext("unregistered whole-source effect %s", op)
+		}
+	}
+	// For these registered instructions no padding-tainted operand, including
+	// a possibly destructive destination, may be consumed. Do not mistake an
+	// unfamiliar effect for a known overwrite and wash away a dependency.
+	for _, arg := range ins.Args {
+		if s.observes(arg) {
+			return arm64PaddingContext("unregistered effect observes unspecified bits")
+		}
+	}
+	return nil
+}
diff --git a/arm64_fp_pair_observation_test.go b/arm64_fp_pair_observation_test.go
new file mode 100644
index 000000000..9be4a0f0b
--- /dev/null
+++ b/arm64_fp_pair_observation_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// The old runtime fixture observed i8/i16 slots with MOVD while its C reference
+// read only one/two bytes. Keep the original source and establish its real Go
+// eight-byte reads before changing any fixture or reference.
+func TestARM64FPPairOriginalGoScalarObservation(t *testing.T) {
+	arm64FPPairGoScalarObservation(t, true)
+}
+
+func TestARM64FPPairCorrectedGoScalarObservation(t *testing.T) {
+	arm64FPPairGoScalarObservation(t, false)
+}
+
+func arm64FPPairGoScalarObservation(t *testing.T, originalWideObservation bool) {
+	t.Helper()
+	_, triple, _, runner := arm64FPPairRuntimeTools(t)
+	_, _, source, _ := arm64FPPairFamilyRuntimeWithObservation(t, triple, originalWideObservation)
+	var assembly, declarations, calls strings.Builder
+	for _, op := range []string{"stp", "stpw"} {
+		for _, width := range []int{1, 2} {
+			name := fmt.Sprintf("%s_scalar%d", op, width*8)
+			start := strings.Index(source, "TEXT "+name+"(SB)")
+			if start < 0 {
+				t.Fatalf("original fixture %s missing", name)
+			}
+			body := source[start:]
+			if end := strings.Index(body[1:], "TEXT "); end >= 0 {
+				body = body[:end+1]
+			}
+			count := 24 / width
+			move := map[int]string{1: "MOVBU", 2: "MOVHU"}[width]
+			if originalWideObservation {
+				move = "MOVD"
+			}
+			for i := 0; i < count; i++ {
+				read := fmt.Sprintf("%s frame+%d(FP), R5\n", move, i*width)
+				if !strings.Contains(body, read) {
+					t.Fatalf("%s no longer has its %s observation %d", name, move, i)
+				}
+			}
+			assembly.WriteString(strings.Replace(body, "TEXT "+name, "TEXT ·"+name, 1))
+			fmt.Fprintf(&declarations, "func %s(", name)
+			for i := 0; i < count; i++ {
+				fmt.Fprintf(&declarations, "a%d uint%d, ", i, width*8)
+			}
+			fmt.Fprintf(&declarations, "left, right uint64, out *[%d]uint64)\n", count)
+			fmt.Fprintf(&calls, "\tcheck(%q, %d, %d, func(values []uint64, left, right uint64) []uint64 {\n", name, width, map[string]int{"stp": 8, "stpw": 4}[op])
+			fmt.Fprintf(&calls, "\t\tvar observed struct { before uint64; data [%d]uint64; after uint64 }\n", count)
+			calls.WriteString("\t\tobserved.before = sentinel\n\t\tobserved.after = sentinel\n")
+			fmt.Fprintf(&calls, "\t\t%s(\n", name)
+			for i := 0; i < count; i++ {
+				fmt.Fprintf(&calls, "\t\t\tuint%d(values[%d]),\n", width*8, i)
+			}
+			calls.WriteString("\t\t\tleft, right, &observed.data,\n\t\t)\n")
+			calls.WriteString("\t\tif observed.before != sentinel || observed.after != sentinel {\n\t\t\tpanic(\"original pair canary changed\")\n\t\t}\n\t\treturn observed.data[:]\n\t})\n")
+		}
+	}
+	program := arm64FPPairOriginalObservationGo + fmt.Sprintf("const wideObservation = %t\n", originalWideObservation) + declarations.String() + "func main() {\n" + calls.String() + `
+	if wideObservation {
+		if oldReferenceMismatches == 0 {
+			panic("original slot-width reference unexpectedly matched MOVD")
+		}
+		fmt.Fprintf(os.Stderr, "original slot-width reference rejected: %d mismatches; actual MOVD eight-byte results and canaries passed\n", oldReferenceMismatches)
+		os.Exit(19)
+	}
+	if oldReferenceMismatches != 0 {
+		panic("corrected byte/half observation disagrees with slot-width reference")
+	}
+	fmt.Fprintln(os.Stderr, "corrected MOVBU/MOVHU slot-width results and canaries passed")
+}
+`
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":           "module originalfppairobservation\n\ngo 1.20\n",
+		"main.go":          program,
+		"original_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original-fp-pair")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if runtime.GOARCH != "arm64" {
+		command.Env = append(command.Env, "GOOS=linux", "GOARCH=arm64")
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go pair compile failed: %v\n%s", err, output)
+	}
+	ctx, cancel = runtimeOracleStageContext(t)
+	defer cancel()
+	if len(runner) == 0 {
+		command = exec.CommandContext(ctx, binary)
+	} else {
+		args := append(append([]string(nil), runner[1:]...), binary)
+		command = exec.CommandContext(ctx, runner[0], args...)
+	}
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	if originalWideObservation {
+		var exit *exec.ExitError
+		if !errors.As(err, &exit) || exit.ExitCode() != 19 ||
+			!strings.Contains(string(output), "actual MOVD eight-byte results and canaries passed") {
+			t.Fatalf("original Go did not establish the stale slot reference: %v\n%s", err, output)
+		}
+	} else if err != nil || !strings.Contains(string(output), "corrected MOVBU/MOVHU slot-width results and canaries passed") {
+		t.Fatalf("corrected Go pair observation failed: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+}
+
+const arm64FPPairOriginalObservationGo = `package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+)
+
+const sentinel = uint64(0xd7a91ce458b2630f)
+var oldReferenceMismatches int
+var samples = [8]uint64{
+	0, 1, ^uint64(0), 0x8000000000000000,
+	0x7fffffff80000000, 0x800000007fffffff,
+	0x0123456789abcdef, 0xfedcba9876543210,
+}
+
+func check(name string, width, pairWidth int, call func([]uint64, uint64, uint64) []uint64) {
+	count := 24 / width
+	for iteration := 0; iteration < len(samples); iteration++ {
+		values := make([]uint64, count)
+		var frame [48]byte
+		for i := range values {
+			values[i] = samples[(iteration+i)%len(samples)]
+			for b := 0; b < width; b++ {
+				frame[i*width+b] = byte(values[i] >> uint(8*b))
+			}
+		}
+		left := samples[(iteration+5)%len(samples)]
+		right := samples[(iteration+7)%len(samples)]
+		binary.LittleEndian.PutUint64(frame[24:], left)
+		binary.LittleEndian.PutUint64(frame[32:], right)
+		for b := 0; b < pairWidth; b++ {
+			frame[b] = byte(left >> uint(8*b))
+			frame[pairWidth+b] = byte(right >> uint(8*b))
+		}
+		observed := call(values, left, right)
+		for i, got := range observed {
+			want := binary.LittleEndian.Uint64(frame[i*width:])
+			var oldWant uint64
+			for b := 0; b < width; b++ {
+				oldWant |= uint64(frame[i*width+b]) << uint(8*b)
+			}
+			if !wideObservation {
+				want = oldWant
+			}
+			if got != want {
+				fmt.Fprintf(os.Stderr, "%s iteration=%d slot=%d got=%016x expected read=%016x\n", name, iteration, i, got, want)
+				os.Exit(73)
+			}
+			if got != oldWant {
+				oldReferenceMismatches++
+			}
+		}
+	}
+}
+`
diff --git a/arm64_fp_parameter_test.go b/arm64_fp_parameter_test.go
new file mode 100644
index 000000000..7926a9533
--- /dev/null
+++ b/arm64_fp_parameter_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64WritableFPParameterSource = `
+TEXT writablefpparameter(SB),$0-16
+	MOVD value+0(FP), R0
+	ADD $1, R0
+	MOVD R0, value+0(FP)
+	MOVD value+0(FP), R1
+	MOVD R1, result+8(FP)
+	RET
+`
+
+func arm64WritableFPParameterSignature() FuncSig {
+	return FuncSig{
+		Name: "writablefpparameter", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		},
+	}
+}
+
+func TestTranslateARM64WritableFPParameterSlot(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64WritableFPParameterSource, true)
+	file, err := Parse(ArchARM64, arm64WritableFPParameterSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"writablefpparameter": arm64WritableFPParameterSignature()},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "%fp_param_0 = alloca i64") || !strings.Contains(ir, "store i64 %arg0, ptr %fp_param_0") {
+				t.Fatalf("writable FP parameter slot was not materialized for %s:\n%s", triple, ir)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-writable-fp-parameter.ll", "arm64-writable-fp-parameter.o", ir)
+		})
+	}
+}
+
+func TestARM64WritableFPParameterRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	file, err := Parse(ArchARM64, arm64WritableFPParameterSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"writablefpparameter": arm64WritableFPParameterSignature()},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern uint64_t writablefpparameter(uint64_t);
+int main(void) { return writablefpparameter(41) == 42 ? 0 : 1; }
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_writable_fp_parameter", triple, ir, mainC, nil)
+}
diff --git a/arm64_fp_range.go b/arm64_fp_range.go
new file mode 100644
index 000000000..3cab1f99b
--- /dev/null
+++ b/arm64_fp_range.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type arm64FPFramePart struct {
+	slot   FrameSlot
+	offset int64
+	size   int64
+}
+
+// fpFrameParts validates an exact byte range before emitting any accesses.
+// Frame fields have independent allocas: their ABI offsets describe byte
+// adjacency, not the physical adjacency of the LLVM allocations.
+func (c *arm64Ctx) fpFrameParts(off, size int64) ([]arm64FPFramePart, error) {
+	const maxOffset = int64(1<<63 - 1)
+	if off < 0 || size <= 0 || size > 16 || off > maxOffset-size {
+		return nil, fmt.Errorf("arm64: invalid FP frame range +%d(FP), size %d", off, size)
+	}
+	// Generated Go argument/result layouts start at zero and advance by
+	// nonnegative field sizes. Reject malformed slot extents before any signed
+	// subtraction or end-offset arithmetic can wrap and appear in-range.
+	for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.fpResults} {
+		for _, slot := range slots {
+			slotSize := frameTypeSize(slot.Type, 8)
+			if slot.Offset < 0 || slot.Offset > maxOffset-slotSize {
+				return nil, fmt.Errorf("arm64: invalid FP frame slot +%d(FP), size %d", slot.Offset, slotSize)
+			}
+		}
+	}
+	var parts []arm64FPFramePart
+	for cursor := off; cursor < off+size; {
+		var found *FrameSlot
+		for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.fpResults} {
+			for _, slot := range slots {
+				slotSize := frameTypeSize(slot.Type, 8)
+				if cursor < slot.Offset || cursor >= slot.Offset+slotSize {
+					continue
+				}
+				if slotSize > 8 {
+					return nil, fmt.Errorf("arm64: FP frame range +%d(FP)..+%d(FP) contains unsupported slot type %q", off, off+size, slot.Type)
+				}
+				if found != nil {
+					return nil, fmt.Errorf("arm64: FP frame range +%d(FP)..+%d(FP) contains overlapping slots at +%d(FP)", off, off+size, cursor)
+				}
+				candidate := slot
+				found = &candidate
+			}
+		}
+		if found == nil {
+			return nil, fmt.Errorf("arm64: FP frame range +%d(FP)..+%d(FP) has no slot at +%d(FP)", off, off+size, cursor)
+		}
+		bytes := frameTypeSize(found.Type, 8) - (cursor - found.Offset)
+		if remaining := off + size - cursor; bytes > remaining {
+			bytes = remaining
+		}
+		for _, slots := range [][]FrameSlot{c.sig.Frame.Params, c.fpResults} {
+			for _, slot := range slots {
+				if slot.Offset > cursor && slot.Offset < cursor+bytes {
+					return nil, fmt.Errorf("arm64: FP frame range +%d(FP)..+%d(FP) contains overlapping slots at +%d(FP)", off, off+size, slot.Offset)
+				}
+			}
+		}
+		parts = append(parts, arm64FPFramePart{slot: *found, offset: cursor, size: bytes})
+		cursor += bytes
+	}
+	return parts, nil
+}
+
+func arm64FPRangeType(size int64) string {
+	if size <= 8 {
+		return "i64"
+	}
+	return "i128"
+}
+
+// loadFPFrameBits packs scalar fragments in ARM64's little-endian byte order.
+// Sub-word and cross-field accesses read only declared frame bytes; padding or
+// missing neighboring slots remain errors, unless a complete typed source
+// bit-use certificate proves a parameter/result gap cannot be observed.
+func (c *arm64Ctx) loadFPFrameBits(off, size int64) (string, error) {
+	parts, err := c.fpFrameParts(off, size)
+	if err != nil {
+		read, certified := c.fpPaddingReads[[2]int{c.currentBlock, c.currentInstruction}]
+		decl := c.sig.arm64FPReadDeclaration
+		if !certified || !decl.matches(c.sig) || read.offset != off || read.bytes != size ||
+			read.declared <= 0 || read.declared >= size || c.currentBlock < 0 || c.currentInstruction < 0 ||
+			c.currentBlock >= len(c.blocks) || c.currentInstruction >= len(c.blocks[c.currentBlock].instrs) ||
+			!reflect.DeepEqual(read.instruction, c.blocks[c.currentBlock].instrs[c.currentInstruction]) {
+			return "", err
+		}
+		want, candidate := arm64FPPaddingCandidate(c.blocks[c.currentBlock].instrs[c.currentInstruction], decl)
+		if !candidate || !reflect.DeepEqual(read, want) {
+			return "", err
+		}
+		// Zero is only an explicit representative of the unobservable bits.
+		// The original source still performs its real native-width MOV and
+		// implicit scratch effects; no padding slot/address/write is created.
+		parts, err = c.fpFrameParts(off, read.declared)
+		if err != nil {
+			return "", err
+		}
+	}
+	ty := arm64FPRangeType(size)
+	packed := "0"
+	for _, part := range parts {
+		value, err := c.evalFPValue64(Operand{Kind: OpFP, FPOffset: part.slot.Offset})
+		if err != nil {
+			return "", err
+		}
+		if shift := (part.offset - part.slot.Offset) * 8; shift != 0 {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", shifted, value, shift)
+			value = "%" + shifted
+		}
+		if part.size < 8 {
+			masked := c.newTmp()
+			mask := ^uint64(0) >> uint(64-part.size*8)
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, value, mask)
+			value = "%" + masked
+		}
+		if ty == "i128" {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", wide, value)
+			value = "%" + wide
+		}
+		if shift := (part.offset - off) * 8; shift != 0 {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shl %s %s, %d\n", shifted, ty, value, shift)
+			value = "%" + shifted
+		}
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or %s %s, %s\n", merged, ty, packed, value)
+		packed = "%" + merged
+	}
+	return packed, nil
+}
+
+// storeFPFrameBits preserves every scalar bit outside the exact write span,
+// including writes beginning in the upper word or spanning separate allocas.
+func (c *arm64Ctx) storeFPFrameBits(off, size int64, value string) error {
+	parts, err := c.fpFrameParts(off, size)
+	if err != nil {
+		return err
+	}
+	ty := arm64FPRangeType(size)
+	for _, part := range parts {
+		fragment := value
+		if shift := (part.offset - off) * 8; shift != 0 {
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %d\n", shifted, ty, fragment, shift)
+			fragment = "%" + shifted
+		}
+		if ty == "i128" {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i128 %s to i64\n", narrow, fragment)
+			fragment = "%" + narrow
+		}
+		if part.size != frameTypeSize(part.slot.Type, 8) {
+			mask := ^uint64(0) >> uint(64-part.size*8)
+			masked := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, fragment, mask)
+			fragment = "%" + masked
+			shift := (part.offset - part.slot.Offset) * 8
+			if shift != 0 {
+				shifted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", shifted, fragment, shift)
+				fragment = "%" + shifted
+			}
+			previous, err := c.evalFPValue64(Operand{Kind: OpFP, FPOffset: part.slot.Offset})
+			if err != nil {
+				return err
+			}
+			kept := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", kept, previous, ^(mask << uint(shift)))
+			merged := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", merged, kept, fragment)
+			fragment = "%" + merged
+		}
+		if err := c.storeFPResult64(part.slot.Offset, fragment); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/arm64_fp_result_read_test.go b/arm64_fp_result_read_test.go
new file mode 100644
index 000000000..cddbe9801
--- /dev/null
+++ b/arm64_fp_result_read_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64ReadFPResultSlot(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		sig    FuncSig
+	}{
+		{
+			name: "integer result",
+			source: `TEXT readintresult(SB),$0-16
+	MOVD value+0(FP), R0
+	MOVD R0, ret+8(FP)
+	MOVD ret+8(FP), R1
+	ADD $1, R1
+	MOVD R1, ret+8(FP)
+	RET
+`,
+			sig: FuncSig{
+				Name: "readintresult", Args: []LLVMType{I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+		},
+		{
+			name: "complex128 result components",
+			source: `TEXT readcomplexresult(SB),$0-48
+	MOVD a_real+0(FP), R0
+	MOVD a_imag+8(FP), R1
+	MOVD b_real+16(FP), R2
+	MOVD b_imag+24(FP), R3
+	MOVD R0, ret+32(FP)
+	MOVD R1, ret+40(FP)
+	FMOVD ret+32(FP), F0
+	FMOVD F0, ret+32(FP)
+	MOVD ret+32(FP), R4
+	MOVD ret+40(FP), R5
+	EOR R2, R4
+	EOR R3, R5
+	MOVD R4, ret+32(FP)
+	MOVD R5, ret+40(FP)
+	RET
+`,
+			sig: FuncSig{
+				Name: "readcomplexresult",
+				Args: []LLVMType{"{ double, double }", "{ double, double }"},
+				Ret:  LLVMType("{ double, double }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: LLVMType("double"), Index: 0, Field: 0},
+						{Offset: 8, Type: LLVMType("double"), Index: 0, Field: 1},
+						{Offset: 16, Type: LLVMType("double"), Index: 1, Field: 0},
+						{Offset: 24, Type: LLVMType("double"), Index: 1, Field: 1},
+					},
+					Results: []FrameSlot{
+						{Offset: 32, Type: LLVMType("double"), Index: 0, Field: -1},
+						{Offset: 40, Type: LLVMType("double"), Index: 1, Field: -1},
+					},
+				},
+			},
+		},
+		{
+			name: "vector-width result read",
+			source: `TEXT readvectorresult(SB),$0-32
+	FMOVQ value+0(FP), F0
+	FMOVQ F0, ret+16(FP)
+	FMOVQ ret+16(FP), F1
+	FMOVQ F1, ret+16(FP)
+	RET
+`,
+			sig: FuncSig{
+				Name: "readvectorresult", Args: []LLVMType{"[2 x i64]"}, Ret: LLVMType("{ i64, i64 }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: 0, Fields: []int{0}},
+						{Offset: 8, Type: I64, Index: 0, Field: 1, Fields: []int{1}},
+					},
+					Results: []FrameSlot{
+						{Offset: 16, Type: I64, Index: 0, Field: -1},
+						{Offset: 24, Type: I64, Index: 1, Field: -1},
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, test.source, true)
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{test.sig.Name: test.sig},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "load "+string(test.sig.Frame.Results[0].Type)+", ptr %fp_ret_0") {
+				t.Fatalf("missing FP result read:\n%s", ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-fp-result-read.ll", "arm64-fp-result-read.o", ir)
+		})
+	}
+}
+
+func TestARM64ReadFPResultSlotRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT readintresult(SB),$0-16
+	MOVD value+0(FP), R0
+	MOVD R0, ret+8(FP)
+	MOVD ret+8(FP), R1
+	ADD $1, R1
+	MOVD R1, ret+8(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-apple-darwin",
+		Sigs: map[string]FuncSig{
+			"readintresult": {
+				Name: "readintresult", Args: []LLVMType{I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern uint64_t readintresult(uint64_t value);
+int main(void) {
+	return readintresult(41) == 42 ? 0 : 1;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_fp_result_read", "aarch64-apple-darwin", ir, mainC, nil)
+}
diff --git a/arm64_framed_raw_branch_runtime_test.go b/arm64_framed_raw_branch_runtime_test.go
new file mode 100644
index 000000000..48561aba6
--- /dev/null
+++ b/arm64_framed_raw_branch_runtime_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64FramedRawBranchFixture() (string, string) {
+	var source, declarations strings.Builder
+	for _, branch := range arm64FramedRawBranches() {
+		name := "raw" + branch.name
+		source.WriteString(arm64FramedRawBranchSource(name, fmt.Sprintf("WORD $%#08x", branch.word)))
+		fmt.Fprintf(&declarations, "func %s(*uint64,*uint64)\n", name)
+	}
+	return source.String(), declarations.String()
+}
+
+// This is independent of NZCV lowering: these boolean identities follow a
+// native subtraction by zero. CBZ's W truncation and TBZ's high bits are separate.
+func arm64FramedRawBranchCondition(branch arm64FramedRawBranchCase) string {
+	conditions := map[string]string{
+		"B": "true", "BEQ": "input == 0", "BNE": "input != 0",
+		"BCS": "true", "BHS": "true", "BCC": "false", "BLO": "false",
+		"BMI": "int64(input) < 0", "BPL": "int64(input) >= 0",
+		"BVS": "false", "BVC": "true", "BHI": "input != 0", "BLS": "input == 0",
+		"BGE": "int64(input) >= 0", "BLT": "int64(input) < 0",
+		"BGT": "int64(input) > 0", "BLE": "int64(input) <= 0",
+		"CBZ": "input == 0", "CBNZ": "input != 0",
+		"CBZW": "uint32(input) == 0", "CBNZW": "uint32(input) != 0",
+	}
+	if branch.op == "TBZ" || branch.op == "TBNZ" {
+		comparison := "=="
+		if branch.op == "TBNZ" {
+			comparison = "!="
+		}
+		return fmt.Sprintf("((input >> %d) & 1) %s 0", branch.bit, comparison)
+	}
+	return conditions[branch.op]
+}
+
+func arm64FramedRawBranchGoCaller(name string) string {
+	return fmt.Sprintf(`
+TEXT ·check_%s(SB),4,$80-24
+MOVD input+0(FP),R0
+MOVD R0,8(RSP)
+MOVD output+8(FP),R0
+MOVD R0,16(RSP)
+MOVD $0x123456789abcdef0,R12
+MOVD R12,24(RSP)
+MOVD R12,32(RSP)
+MOVD g,R12
+MOVD R12,40(RSP)
+WORD $0xaa1203ec // read x18, without changing the reserved register.
+MOVD R12,48(RSP)
+MOVD 0(RSP),R12
+MOVD R12,56(RSP)
+MOVD RSP,R12
+MOVD R12,64(RSP)
+CALL ·%s(SB)
+MOVD $0x123456789abcdef0,R12
+MOVD 24(RSP),R13
+CMP R12,R13
+BNE bad_%s
+MOVD 32(RSP),R13
+CMP R12,R13
+BNE bad_%s
+MOVD 40(RSP),R12
+CMP g,R12
+BNE bad_%s
+MOVD 48(RSP),R13
+WORD $0xaa1203ec
+CMP R12,R13
+BNE bad_%s
+MOVD 0(RSP),R12
+MOVD 56(RSP),R13
+CMP R12,R13
+BNE bad_%s
+MOVD RSP,R12
+MOVD 64(RSP),R13
+CMP R12,R13
+BNE bad_%s
+MOVD $1,R0
+MOVD R0,ret+16(FP)
+RET
+bad_%s:
+MOVD $0,R0
+MOVD R0,ret+16(FP)
+RET
+`, name, name, name, name, name, name, name, name, name)
+}
+
+func arm64FramedRawBranchPrograms() (source, goProgram, cProgram string) {
+	source, declarations := arm64FramedRawBranchFixture()
+	var goMain, cMain strings.Builder
+	goMain.WriteString("package main\nimport \"fmt\"\n" + declarations)
+	cMain.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for _, branch := range arm64FramedRawBranches() {
+		name := "raw" + branch.name
+		fmt.Fprintf(&goMain, "func check_%s(*uint64,*uint64) uint64\n", name)
+		source += arm64FramedRawBranchGoCaller(name)
+		symbol := "largeframe." + name
+		if runtime.GOOS == "darwin" {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&cMain, "extern void %s(uint64_t*,uint64_t*) __asm__(%q);\n", name, symbol)
+	}
+	goMain.WriteString(`
+func main() {
+    inputs := []uint64{0, 1, 0xffffffff, 0x100000000, 0x80000000,
+        0x8000000000000000, 0x7fffffffffffffff, ^uint64(0)}
+    for _, input := range inputs {
+`)
+	cMain.WriteString(`
+int main(void) {
+    const uint64_t inputs[] = {0, 1, UINT64_C(0xffffffff), UINT64_C(0x100000000),
+        UINT64_C(0x80000000), UINT64_C(0x8000000000000000),
+        UINT64_C(0x7fffffffffffffff), UINT64_MAX};
+    for (unsigned i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
+        uint64_t input = inputs[i];
+`)
+	for _, branch := range arm64FramedRawBranches() {
+		name := "raw" + branch.name
+		condition := arm64FramedRawBranchCondition(branch)
+		fmt.Fprintf(&goMain, `
+        {
+            want := uint64(7)
+            if %s {
+                want = 5
+            }
+            data := [3]uint64{0x1234, input, 0x5678}
+            result := [3]uint64{0x9abc, 0, 0xdef0}
+            if check_%s(&data[1], &result[1]) != 1 || result[1] != want ||
+                    data != [3]uint64{0x1234, input, 0x5678} ||
+                    result[0] != 0x9abc || result[2] != 0xdef0 {
+                panic(fmt.Sprintf("%s input=%%x result=%%x want=%%x", input, result[1], want))
+            }
+        }
+`, condition, name, name)
+		condition = strings.NewReplacer("true", "1", "false", "0", "int64(input)", "(int64_t)input", "uint32(input)", "(uint32_t)input").Replace(condition)
+		fmt.Fprintf(&cMain, `
+        {
+            uint64_t data[] = {0x1234, input, 0x5678};
+            uint64_t result[] = {0x9abc, 0, 0xdef0};
+            uint64_t want = (%s) ? 5 : 7;
+            %s(&data[1], &result[1]);
+            if (result[1] != want || data[0] != 0x1234 || data[1] != input ||
+                    data[2] != 0x5678 || result[0] != 0x9abc || result[2] != 0xdef0) {
+                fprintf(stderr, "%s input=%%llx result=%%llx want=%%llx\n",
+                    (unsigned long long)input, (unsigned long long)result[1], (unsigned long long)want);
+                return 1;
+            }
+        }
+`, condition, name, name)
+	}
+	goMain.WriteString("    }\n}\n")
+	cMain.WriteString("    }\n    return 0;\n}\n")
+	return source, goMain.String(), cMain.String()
+}
+
+func TestARM64FramedRawBranchAPIsAndLLVM22Objects(t *testing.T) {
+	source, declarations := arm64FramedRawBranchFixture()
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\n"+declarations)
+	arm64LargeFrameCheckAPIs(t, source, pkg, nil, false, true)
+	t.Logf("%d raw branch forms through three APIs and five target objects", len(arm64FramedRawBranches()))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FramedRawBranchFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, goMain, cMain := arm64FramedRawBranchPrograms()
+	runARM64LocalRegisterGoOracle(t, source, goMain, len(runner) != 0, "1.20")
+	source, declarations := arm64FramedRawBranchFixture()
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\n"+declarations)
+	translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := translated.Module.String()
+	translated.Module.Dispose()
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "framed_raw_branch", triple, ir, cMain, runner)
+	t.Logf("%d original Go/LLVM cases; complete input/output and native Go g/OS18/LR/SP/stack canaries", len(arm64FramedRawBranches())*8)
+}
diff --git a/arm64_framed_raw_branch_test.go b/arm64_framed_raw_branch_test.go
new file mode 100644
index 000000000..61ab15b62
--- /dev/null
+++ b/arm64_framed_raw_branch_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+type arm64FramedRawBranchCase struct {
+	name string
+	word uint32
+	bit  int
+	op   string
+}
+
+// Every branch skips one four-byte instruction. Encoding fields are independent
+// of the translator's decoder; the Go assembler oracle checks the native bytes.
+func arm64FramedRawBranches() []arm64FramedRawBranchCase {
+	cases := []arm64FramedRawBranchCase{{name: "B", word: 0x14000002, op: "B"}}
+	conditions := []struct {
+		op        string
+		condition uint32
+	}{
+		{"BEQ", 0}, {"BNE", 1}, {"BCS", 2}, {"BHS", 2},
+		{"BCC", 3}, {"BLO", 3}, {"BMI", 4}, {"BPL", 5},
+		{"BVS", 6}, {"BVC", 7}, {"BHI", 8}, {"BLS", 9},
+		{"BGE", 10}, {"BLT", 11}, {"BGT", 12}, {"BLE", 13},
+	}
+	for _, condition := range conditions {
+		cases = append(cases, arm64FramedRawBranchCase{
+			name: condition.op, word: 0x54000040 | condition.condition, op: condition.op,
+		})
+	}
+	for _, form := range []struct {
+		op   string
+		base uint32
+	}{
+		{"CBZW", 0x34000000}, {"CBNZW", 0x35000000},
+		{"CBZ", 0xb4000000}, {"CBNZ", 0xb5000000},
+	} {
+		cases = append(cases, arm64FramedRawBranchCase{
+			name: form.op, word: form.base | 0x40 | 2, op: form.op,
+		})
+	}
+	for _, form := range []struct {
+		op   string
+		base uint32
+	}{{"TBZ", 0x36000000}, {"TBNZ", 0x37000000}} {
+		for _, bit := range []int{0, 31, 32, 63} {
+			word := form.base | uint32(bit&31)<<19 | uint32(bit>>5)<<31 | 0x40 | 2
+			cases = append(cases, arm64FramedRawBranchCase{
+				name: fmt.Sprintf("%s%d", form.op, bit), word: word, bit: bit, op: form.op,
+			})
+		}
+	}
+	return cases
+}
+
+func arm64FramedRawBranchSource(name, branch string) string {
+	return fmt.Sprintf(`TEXT ·%s(SB),4,$496-16
+MOVD input+0(FP),R0
+MOVD output+8(FP),R1
+MOVD (R0),R2
+MOVD $5,R3
+CMP $0,R2
+%s
+WORD $0xd28000e3 // movz x3,#7: exact four-byte source width.
+MOVD R3,(R1)
+MOVD R20,R9
+MOVD $0,R9
+MOVD 0(RSP),R30
+RET
+`, name, branch)
+}
+
+func arm64FramedRawBranchProof(t *testing.T, source string) bool {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	fn, err = normalizeARM64ScalarMemoryFrame(fn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return arm64FramedRawBranchFunctionProof(t, fn)
+}
+
+func arm64FramedRawBranchFunctionProof(t *testing.T, fn Func) bool {
+	t.Helper()
+	name := strings.TrimPrefix(fn.Sym, "·")
+	pkg := mustGoPackage(t, "framedbranches", "package framedbranches\nfunc "+name+"(*uint64,*uint64)\n")
+	resolve := testResolveSym(pkg.Path)
+	sig, err := DeriveGoFuncABI0Signature(resolve(fn.Sym), pkg.Types.Scope().Lookup(name).(*types.Func), "arm64", types.SizesFor("gc", "arm64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return arm64CallFrameUnexposedTyped(fn, sig, resolve, map[string]FuncSig{sig.Name: sig})
+}
+
+func TestARM64FramedRawBranchesHaveExactSourceCFG(t *testing.T) {
+	for _, branch := range arm64FramedRawBranches() {
+		t.Run(branch.name, func(t *testing.T) {
+			source := arm64FramedRawBranchSource("raw"+branch.name, fmt.Sprintf("WORD $%#08x", branch.word))
+			requireARM64GoAssemblerResult(t, source, true)
+			if !arm64FramedRawBranchProof(t, source) {
+				t.Fatal("Go-accepted same-source raw branch lost the complete framed proof")
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, blobs, err := prepareARM64RawPCRelative(fn)
+			if err != nil || len(blobs) != 0 {
+				t.Fatalf("raw-PC registration changed executable source role: %v, %d blobs", err, len(blobs))
+			}
+			if !arm64FramedRawBranchFunctionProof(t, prepared) {
+				t.Fatal("actual normalized CFG lost its independent complete proof")
+			}
+		})
+	}
+}
+
+func TestARM64FramedRawBranchCFGDoesNotEraseUnprovedSource(t *testing.T) {
+	const safe = "WORD $0xb4000042"
+	for _, test := range []struct {
+		name, branch string
+	}{
+		{"unknown_word", "WORD $0xffffffff"},
+		{"unregistered_al_condition", "WORD $0x5400004e"},
+		{"unregistered_nv_condition", "WORD $0x5400004f"},
+		{"raw_local_call", "WORD $0x94000002"},
+		{"raw_native_call", "WORD $0xd63f0040"},
+		{"source_unknown_call", "CALL unknown(SB)"},
+		{"raw_native_return", "WORD $0xd65f03c0"},
+		{"indirect_branch", "WORD $0xd61f0040"},
+		{"far_target", "WORD $0x1407ffff"},
+		{"unknown_source_width", "WORD $0x14000002\nMOVD $0x123456789abcdef0,R9"},
+		{"target_inside_ret_epilogue", "WORD $0x14000002\nRET"},
+		{"native_address", "WORD $0x10000042"},
+		{"frame_predicate", "MOVD R20,R2\n" + safe},
+		{"mixed_frame_predicate", "MOVD R20,R2\nWORD $0xb4000040\nMOVD $0,R2\n" + safe},
+		{"prefix_escape", "MOVD R20,(R1)\n" + safe},
+		{"prefix_fixed_g_corruption", "MOVD R20,g\n" + safe},
+		{"prefix_fixed_os_corruption", "WORD $0xaa1403f2\n" + safe},
+		{"prefix_link_corruption", "MOVB R2,1(RSP)\n" + safe},
+		{"branch_sp_delta", "WORD $0xb4000042\nSUB $16,RSP"},
+		{"unknown_sp_index", "MOVD (RSP)(R2),R9\n" + safe},
+		{"dead_escape", "WORD $0x14000002\nMOVD R20,(R1)"},
+		{"dead_native_call", "WORD $0x14000002\nWORD $0xd63f0040"},
+		{"dead_unknown_word", "WORD $0x14000002\nWORD $0xffffffff"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := arm64FramedRawBranchSource("refused", test.branch)
+			if arm64FramedRawBranchProof(t, source) {
+				t.Fatal("raw-PC registration erased an unsafe, dead or unknown component")
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, blobs, err := prepareARM64RawPCRelative(fn)
+			if err == nil && len(blobs) == 0 && arm64FramedRawBranchFunctionProof(t, prepared) {
+				t.Fatal("normalized CFG independently granted an unproved component a frame")
+			}
+		})
+	}
+	for _, change := range []struct{ from, to string }{
+		{"4,$496-16", "516,$496-16"},
+		{"4,$496-16", "4,$496"},
+		{"4,$496-16", "4,$496-8"},
+		{"4,$496-16", "Unknown,$496-16"},
+	} {
+		source := strings.Replace(arm64FramedRawBranchSource("refused", safe), change.from, change.to, 1)
+		if arm64FramedRawBranchProof(t, source) {
+			t.Fatalf("changed source/entry metadata acquired an implicit frame: %+v", change)
+		}
+	}
+}
+
+func TestARM64FramedRawBranchesLoopsAndJoins(t *testing.T) {
+	for _, branch := range []string{
+		"WORD $0xb4000002",                          // CBZ X2,current-PC: both the loop and exit are real.
+		"WORD $0x34000002",                          // The original Arrow instruction's W form.
+		"loop:\nWORD $0xd1000442\nWORD $0xb5ffffe2", // SUB X2,#1; CBNZ X2,previous instruction.
+		"WORD $0xb4000042\nWORD $0xaa1403e9\nWORD $0xd2800009",
+	} {
+		if !arm64FramedRawBranchProof(t, arm64FramedRawBranchSource("looped", branch)) {
+			t.Fatalf("safe complete loop/join lost its source proof: %s", branch)
+		}
+	}
+}
+
+func TestARM64FramedRawBranchOriginalGoEncodingFields(t *testing.T) {
+	// This encoding oracle is separate from framed permission: the complete
+	// register fields include platform/control registers and ZR, which do not
+	// acquire a frame-read permission merely because Go accepts their encoding.
+	var source strings.Builder
+	var expected bytes.Buffer
+	source.WriteString("TEXT fields(SB),4,$0-0\n")
+	forms := 0
+	appendBranch := func(text string, word uint32) {
+		separator := ","
+		if !strings.Contains(text, " ") {
+			separator = " "
+		}
+		// A real NOP at the target prevents Go's branch-chain optimization
+		// from following the next test's unconditional branch instead.
+		fmt.Fprintf(&source, "%s%starget%d\nWORD $0xd503201f\ntarget%d:\nWORD $0xd503201f\n", text, separator, forms, forms)
+		for _, value := range []uint32{word, 0xd503201f, 0xd503201f} {
+			if err := binary.Write(&expected, binary.LittleEndian, value); err != nil {
+				t.Fatal(err)
+			}
+		}
+		forms++
+	}
+	appendBranch("B", 0x14000002)
+	appendBranch("JMP", 0x14000002)
+	for _, branch := range arm64FramedRawBranches()[1:17] {
+		appendBranch(branch.op, branch.word)
+	}
+	for reg := 0; reg < 32; reg++ {
+		name := fmt.Sprintf("R%d", reg)
+		if reg == 18 {
+			name = "R18_PLATFORM"
+		} else if reg == 28 {
+			name = "g"
+		} else if reg == 31 {
+			name = "ZR"
+		}
+		for _, form := range []struct {
+			op   string
+			base uint32
+		}{
+			{"CBZW", 0x34000000}, {"CBNZW", 0x35000000},
+			{"CBZ", 0xb4000000}, {"CBNZ", 0xb5000000},
+		} {
+			appendBranch(form.op+" "+name, form.base|0x40|uint32(reg))
+		}
+		for bit := 0; bit < 64; bit++ {
+			for _, form := range []struct {
+				op   string
+				base uint32
+			}{{"TBZ", 0x36000000}, {"TBNZ", 0x37000000}} {
+				word := form.base | uint32(bit&31)<<19 | uint32(bit>>5)<<31 | 0x40 | uint32(reg)
+				appendBranch(fmt.Sprintf("%s $%d,%s", form.op, bit, name), word)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	if err := binary.Write(&expected, binary.LittleEndian, uint32(0xd65f03c0)); err != nil {
+		t.Fatal(err)
+	}
+	// obj7.span7 pads TEXT bytes with zero words to its 16-byte funcAlign.
+	// These bytes follow the actual RET and are not another source instruction.
+	for expected.Len()%16 != 0 {
+		if err := binary.Write(&expected, binary.LittleEndian, uint32(0)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		actual := arm64ImmediateOriginalGoBytes(t, source.String(), goos)
+		if !bytes.Equal(actual, expected.Bytes()) {
+			for offset := 0; offset+4 <= len(actual) && offset+4 <= expected.Len(); offset += 4 {
+				if !bytes.Equal(actual[offset:offset+4], expected.Bytes()[offset:offset+4]) {
+					t.Fatalf("%s original Go branch word at byte %d: got %x want %x", goos, offset, actual[offset:offset+4], expected.Bytes()[offset:offset+4])
+				}
+			}
+			t.Fatalf("%s original Go branch byte lengths: got %d want %d", goos, len(actual), expected.Len())
+		}
+	}
+	t.Logf("%d original Go encodings per OS: aliases, all 32 register fields and all 64 test-bit fields", forms)
+}
diff --git a/arm64_go_abi0_frame_contract_test.go b/arm64_go_abi0_frame_contract_test.go
new file mode 100644
index 000000000..0818fd948
--- /dev/null
+++ b/arm64_go_abi0_frame_contract_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64DeclaredGoABIInternalNeedsRegisterContract(t *testing.T) {
+	pkg := mustGoPackage(t, "test/internal", "package internal\nfunc Y(uint64) uint64\nfunc X(uint64) uint64\n")
+	for _, branch := range []string{"CALL", "BL", "RET", "B", "JMP"} {
+		source := "TEXT ·Y(SB),4,$0-16\n" + branch + " ·X<ABIInternal>(SB)\n"
+		if branch == "CALL" || branch == "BL" {
+			source += "RET\n"
+		}
+		requireARM64GoABIInternalObject(t, source)
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+			// A manual classic ABI0 frame has no standard register contract.
+			// Actual declarations plus selectors now derive one independently;
+			// overriding that evidence must not silently gain a register ABI.
+			ManualSig: func(name string) (FuncSig, bool) {
+				return sigWithClassicFrame("X", []LLVMType{I64}, I64), name == "X"
+			},
+		})
+		if err == nil {
+			tr.Module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: a manual ABI0 frame cannot prove an explicit register entry: %v", branch, err)
+		}
+	}
+}
+
+func requireARM64GoABIInternalObject(t *testing.T, source string) {
+	t.Helper()
+	// Go reserves explicit selectors for package runtime. This validates the
+	// actual selector grammar, not an ordinary-package rejection or execution.
+	// The shared oracle observes the selected assembler's flags: Go 1.20 also
+	// needs -compiling-runtime, while current Go derives permission from -p.
+	requireARM64TypedCallGoSelectorObject(t, source)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ExplicitRegisterContract(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg := mustGoPackage(t, "test/internal", "package internal\nfunc Y(uint64) uint64\nfunc X(uint64) uint64\n")
+	for _, branch := range []string{"CALL", "BL", "RET", "B", "JMP"} {
+		t.Run(branch, func(t *testing.T) {
+			source := "TEXT ·Y(SB),4,$0-16\nMOVD a+0(FP),R9\n" + branch + " ·X<ABIInternal>(SB)\n"
+			if branch == "CALL" || branch == "BL" {
+				source += "MOVD R0,ret+8(FP)\nRET\n"
+			}
+			requireARM64GoABIInternalObject(t, source)
+			translate := func(target string) string {
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+					ManualSig: func(name string) (FuncSig, bool) {
+						return FuncSig{Name: "X", Args: []LLVMType{I64}, ArgRegs: []Reg{"R9"}, Ret: I64}, name == "X"
+					},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				return tr.Module.String()
+			}
+			for _, target := range []string{
+				"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+			} {
+				compileLLVMToObject(t, llc, target, "explicit-register.ll", "explicit-register.o", translate(target))
+			}
+			const main = `#include <stdint.h>
+extern uint64_t Y(uint64_t);
+uint64_t X(uint64_t a) { return a*7+9; }
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) { if (Y(inputs[i]) != inputs[i]*7+9) return 1; }
+  return 0;
+}
+`
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "explicit_register", triple, translate(triple), main, runner)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64DeclaredGoABI0Shapes(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		name, declarations, body, goCallee, goWant, cCallee, cWant, llvmCallee string
+	}{
+		{
+			name:         "result_only",
+			declarations: "func X() uint64",
+			body:         "CALL ·X(SB)\nMOVD 8(RSP),R9",
+			goCallee:     "func X() uint64 { return 0x123456789abcdef0 }",
+			goWant:       "uint64(0x123456789abcdef0)",
+			cCallee:      "uint64_t X(void) { return UINT64_C(0x123456789abcdef0); }",
+			cWant:        "UINT64_C(0x123456789abcdef0)",
+		},
+		{
+			name:         "narrow",
+			declarations: "func X(uint8) uint8",
+			body:         "MOVD a+0(FP),R9\nMOVB R9,8(RSP)\nCALL ·X(SB)\nMOVBU 16(RSP),R9",
+			goCallee:     "func X(a uint8) uint8 { return a*7+9 }",
+			goWant:       "uint64(uint8(a)*7+9)",
+			cCallee:      "uint8_t X(uint8_t a) { return (uint8_t)(a*7+9); }",
+			cWant:        "(uint8_t)(inputs[i]*7+9)",
+		},
+		{
+			name:         "tuple_result",
+			declarations: "func X(uint64) (uint64,uint64)",
+			body:         "MOVD a+0(FP),R9\nMOVD R9,8(RSP)\nCALL ·X(SB)\nLDP 16(RSP),(R9,R10)\nEOR R10,R9,R9",
+			goCallee:     "func X(a uint64) (uint64,uint64) { return a*7+9,a*11+3 }",
+			goWant:       "(a*7+9)^(a*11+3)",
+			cWant:        "(inputs[i]*7+9)^(inputs[i]*11+3)",
+			llvmCallee: `define { i64, i64 } @X(i64 %a) {
+  %x0 = mul i64 %a, 7
+  %x = add i64 %x0, 9
+  %y0 = mul i64 %a, 11
+  %y = add i64 %y0, 3
+  %r0 = insertvalue { i64, i64 } undef, i64 %x, 0
+  %r = insertvalue { i64, i64 } %r0, i64 %y, 1
+  ret { i64, i64 } %r
+}
+`,
+		},
+		{
+			name:         "nested_aggregate",
+			declarations: "type Pair struct { Lo,Hi uint64 }\ntype Nested struct { A uint64; B Pair }\nfunc X(Nested) uint64",
+			body:         "MOVD a+0(FP),R9\nMOVD R9,8(RSP)\nADD $3,R9\nMOVD R9,16(RSP)\nADD $5,R9\nMOVD R9,24(RSP)\nCALL ·X(SB)\nMOVD 32(RSP),R9",
+			goCallee:     "type Pair struct { Lo,Hi uint64 }; type Nested struct { A uint64; B Pair }; func X(a Nested) uint64 { return a.A*7+a.B.Lo*11+a.B.Hi*13 }",
+			goWant:       "a*7+(a+3)*11+(a+8)*13",
+			cWant:        "inputs[i]*7+(inputs[i]+3)*11+(inputs[i]+8)*13",
+			llvmCallee: `define i64 @X({ i64, { i64, i64 } } %a) {
+  %x = extractvalue { i64, { i64, i64 } } %a, 0
+  %y = extractvalue { i64, { i64, i64 } } %a, 1, 0
+  %z = extractvalue { i64, { i64, i64 } } %a, 1, 1
+  %x1 = mul i64 %x, 7
+  %y1 = mul i64 %y, 11
+  %z1 = mul i64 %z, 13
+  %xy = add i64 %x1, %y1
+  %r = add i64 %xy, %z1
+  ret i64 %r
+}
+`,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := "TEXT ·Y(SB),4,$48-16\n" + tc.body + "\nMOVD R9,ret+8(FP)\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			goMain := "package main\nfunc Y(uint64) uint64\n" + tc.goCallee + "\nfunc main() { for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} { if Y(a) != " + tc.goWant + " { panic(\"ABI0 shape mismatch\") } } }\n"
+			runARM64LocalRegisterGoOracle(t, source, goMain, len(runner) != 0)
+			pkg := mustGoPackage(t, "test/shape", "package shape\nfunc Y(uint64) uint64\n"+tc.declarations+"\n")
+			translate := func(target string) string {
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				ir := tr.Module.String()
+				if tc.llvmCallee != "" {
+					for _, line := range strings.Split(ir, "\n") {
+						if strings.HasPrefix(line, "declare ") && strings.Contains(line, " @X(") {
+							return strings.Replace(ir, line, tc.llvmCallee, 1)
+						}
+					}
+					t.Fatal("missing independent LLVM callee declaration")
+				}
+				return ir
+			}
+			for _, target := range []string{
+				"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+			} {
+				compileLLVMToObject(t, llc, target, "abi0-shape.ll", "abi0-shape.o", translate(target))
+			}
+			main := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern uint64_t Y(uint64_t);
+%s
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) {
+    if (Y(inputs[i]) != (%s)) { fprintf(stderr,"ABI0 shape mismatch\n"); return 1; }
+  }
+  return 0;
+}
+`, tc.cCallee, tc.cWant)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "abi0_shape", triple, translate(triple), main, runner)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64DeclaredGoABI0(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·Y(SB),4,$32-16
+MOVD a+0(FP),R9
+MOVD R9,8(RSP)
+MOVD $111,R0
+MOVD $222,R1
+CALL ·X(SB)
+MOVD 16(RSP),R9
+MOVD R9,ret+8(FP)
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	runARM64LocalRegisterGoOracle(t, source, `package main
+func Y(a uint64) uint64
+func X(a uint64) uint64 { return a*7+9 }
+func main() {
+	for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+		if Y(a) != a*7+9 { panic("declared Go ABI0 frame mismatch") }
+	}
+}
+`, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/abi0", "package abi0\nfunc Y(uint64) uint64\nfunc X(uint64) uint64\n")
+	translate := func(target string) string {
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer tr.Module.Dispose()
+		return tr.Module.String()
+	}
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		compileLLVMToObject(t, llc, target, "declared-go-abi0.ll", "declared-go-abi0.o", translate(target))
+	}
+	const main = `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t Y(uint64_t);
+uint64_t X(uint64_t a) { return a*7+9; }
+int main(void) {
+	uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+	for (unsigned i=0;i<5;i++) {
+		if (Y(inputs[i]) != inputs[i]*7+9) {
+			fprintf(stderr,"declared Go ABI0 frame mismatch\n");
+			return 1;
+		}
+	}
+	return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "declared_go_abi0", triple, translate(triple), main, runner)
+}
diff --git a/arm64_go_internal_aggregate_test.go b/arm64_go_internal_aggregate_test.go
new file mode 100644
index 000000000..e93db4156
--- /dev/null
+++ b/arm64_go_internal_aggregate_test.go
@@ -0,0 +1,496 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Keep the complete stock-Go selected declaration bytes and actual export
+// graph. A copied func signature cannot supply the ABI0 source Binder input.
+func arm64BytealgCountSDKPackage(t *testing.T) GoPackage {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "list", "-p=2", "-compiled", "-export", "-deps", "-json", "internal/bytealg")
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "CGO_ENABLED=0")
+	output, diagnostics, err := runtimeOracleMachineOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual SDK Count selection/export: %v\n%s\n%s", err, output, diagnostics)
+	}
+	type selectedPackage struct {
+		Dir, ImportPath, Name, Export string
+		Standard                      bool
+		GoFiles, CompiledGoFiles      []string
+		CgoFiles, SFiles              []string
+		ImportMap                     map[string]string
+		Error                         *struct{ Err string }
+		DepsErrors                    []struct{ Err string }
+	}
+	decoder := json.NewDecoder(bytes.NewReader(output))
+	exports := make(map[string]string)
+	var root *selectedPackage
+	for {
+		var selected selectedPackage
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatalf("actual SDK selection JSON: %v", err)
+		}
+		if selected.Error != nil || len(selected.DepsErrors) != 0 || !selected.Standard || len(selected.CgoFiles) != 0 {
+			t.Fatalf("unclosed SDK selection: %s: %+v", selected.ImportPath, selected.Error)
+		}
+		if _, duplicate := exports[selected.ImportPath]; duplicate {
+			t.Fatalf("duplicate actual SDK package: %s", selected.ImportPath)
+		}
+		exports[selected.ImportPath] = selected.Export
+		if selected.ImportPath == "internal/bytealg" {
+			copy := selected
+			root = &copy
+		}
+	}
+	canonical, err := filepath.EvalSymlinks(filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg"))
+	if err != nil || root == nil || root.Name != "bytealg" || len(root.CompiledGoFiles) == 0 || len(root.CompiledGoFiles) > 256 {
+		t.Fatalf("missing actual SDK Count root: %v", err)
+	}
+	actual, err := filepath.EvalSymlinks(root.Dir)
+	if err != nil || actual != canonical {
+		t.Fatalf("SDK Count selection changed its original root: %s: %v", root.Dir, err)
+	}
+	selectedASM := false
+	for _, name := range root.SFiles {
+		selectedASM = selectedASM || name == "count_arm64.s"
+	}
+	if !selectedASM {
+		t.Fatal("original Count assembly absent from actual SDK selection")
+	}
+	fset := token.NewFileSet()
+	info := &types.Info{Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object), Types: make(map[ast.Expr]types.TypeAndValue)}
+	sizes := types.SizesFor("gc", "arm64")
+	selection := &GoSourceSelection{Fset: fset, TypesInfo: info, Sizes: sizes, GoSources: make(map[string][]byte)}
+	var syntax []*ast.File
+	guard := make(map[string][32]byte)
+	for _, name := range root.CompiledGoFiles {
+		filename := name
+		if !filepath.IsAbs(filename) {
+			filename = filepath.Join(canonical, filename)
+		}
+		physical, err := filepath.EvalSymlinks(filename)
+		if err != nil || filepath.Dir(physical) != canonical || selection.GoSources[physical] != nil {
+			t.Fatalf("unbound SDK Count selected source: %s: %v", name, err)
+		}
+		source, err := os.ReadFile(physical)
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := parser.ParseFile(fset, physical, source, parser.ParseComments)
+		if err != nil || file.Name.Name != root.Name {
+			t.Fatalf("actual SDK Count declaration parse: %s: %v", name, err)
+		}
+		syntax = append(syntax, file)
+		selection.SelectedGoFiles = append(selection.SelectedGoFiles, physical)
+		selection.GoSources[physical] = source
+		guard[physical] = sha256.Sum256(source)
+	}
+	lookup := func(path string) (io.ReadCloser, error) {
+		if mapped := root.ImportMap[path]; mapped != "" {
+			path = mapped
+		}
+		filename := exports[path]
+		if filename == "" {
+			return nil, fmt.Errorf("missing actual SDK dependency export: %s", path)
+		}
+		data, err := os.ReadFile(filename)
+		if err != nil {
+			return nil, err
+		}
+		guard[filename] = sha256.Sum256(data)
+		return io.NopCloser(bytes.NewReader(data)), nil
+	}
+	config := types.Config{Sizes: sizes, Importer: importer.ForCompiler(fset, "gc", lookup)}
+	typed, err := config.Check(root.ImportPath, fset, syntax, info)
+	if err != nil {
+		t.Fatalf("actual SDK Count type/source recheck: %v", err)
+	}
+	t.Cleanup(func() {
+		for filename, before := range guard {
+			data, err := os.ReadFile(filename)
+			if err != nil || sha256.Sum256(data) != before {
+				t.Errorf("actual SDK Count source/export changed: %s: %v", filename, err)
+			}
+		}
+	})
+	t.Logf("actual SDK Count selection: %s, %d original Go files, %d package export records", root.ImportPath, len(syntax), len(exports))
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax, SourceSelection: selection}
+}
+
+// Go permits explicit ABI selectors only to its trusted runtime assembly.
+// Use a private package and fully qualified main symbols with the assembler's
+// runtime identity. The compiler still receives the real gensymabis output
+// and emits its ordinary Go ABIInternal calls/wrappers from the declaration.
+func runARM64GoInternalOracle(t *testing.T, source, main string, cross bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module internalregisteroracle\n\ngo 1.20\n",
+		"main.go": main, "oracle_arm64.s": strings.ReplaceAll(source, "·", "main·"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Reuse the selected assembler's actual trusted-runtime flags. Go 1.20
+	// requires -compiling-runtime even when -p=runtime is supplied; newer Go
+	// derives ABI-selector permission from -p and removed the separate flag.
+	asmFlags := strings.Join(arm64ClosureGoAsmArgs(t)[2:], " ")
+	args := []string{"run", "-p=2", "-asmflags=internalregisteroracle=" + asmFlags}
+	env := append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0")
+	if cross {
+		args = append(args, "-exec=qemu-aarch64")
+		env = append(env, "GOOS=linux")
+	}
+	args = append(args, ".")
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir, cmd.Env = dir, env
+	if out, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go ABIInternal oracle: %v\n%s", err, out)
+	}
+	t.Log("actual native Go ABIInternal entry/call oracle passed")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalAggregates(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		name, decl, source, goCallee, goCheck, llvmShim, cCheck string
+	}{
+		{
+			name:     "caller_save_redefined",
+			decl:     "func Pass(uint64) uint64\nfunc Compute(uint64) uint64",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nMOVD $99,R9\nEOR R9,R0,R0\nRET\n",
+			goCallee: "func Compute(a uint64) uint64 { return a*7+9 }",
+			goCheck:  "if Pass(a)!=99^(a*7+9) { panic(\"redefined caller-save mismatch\") }",
+			llvmShim: `define i64 @Compute(i64 %a) {
+  %x = mul i64 %a, 7
+  %r = add i64 %x, 9
+  ret i64 %r
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass(i64 %a)
+  ret i64 %r
+}
+`,
+			cCheck: "99^(inputs[i]*7+9)",
+		},
+		{
+			name:     "caller_save_defined_on_both_paths",
+			decl:     "func Pass(uint64) uint64\nfunc Compute(uint64) uint64",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nCBZ R0,left\nMOVD $99,R9\nB done\nleft:\nMOVD $3,R9\ndone:\nEOR R9,R0,R0\nRET\n",
+			goCallee: "func Compute(a uint64) uint64 { return a }",
+			goCheck:  "want:=a^99; if a==0 { want=3 }; if Pass(a)!=want { panic(\"caller-save branch join mismatch\") }",
+			llvmShim: `define i64 @Compute(i64 %a) {
+  ret i64 %a
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass(i64 %a)
+  ret i64 %r
+}
+`,
+			cCheck: "inputs[i]==0?3:inputs[i]^99",
+		},
+		{
+			name:     "flags_redefined_after_call",
+			decl:     "func Pass(uint64) uint64\nfunc Compute(uint64) uint64",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nCMP $0,R0\nCINC NE,R0,R0\nRET\n",
+			goCallee: "func Compute(a uint64) uint64 { return a }",
+			goCheck:  "want:=a; if a!=0 { want++ }; if Pass(a)!=want { panic(\"redefined flags mismatch\") }",
+			llvmShim: `define i64 @Compute(i64 %a) {
+  ret i64 %a
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass(i64 %a)
+  ret i64 %r
+}
+`,
+			cCheck: "inputs[i]+(inputs[i]!=0)",
+		},
+		{
+			name:     "float32_result_width",
+			decl:     "func Pass(uint64) uint64\nfunc Compute(uint64) float32",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nFMOVS F0,R0\nRET\n",
+			goCallee: "func Compute(a uint64) float32 { return 91.5 }",
+			goCheck:  "if Pass(a)!=0x42b70000 { panic(\"float32 register result width mismatch\") }",
+			llvmShim: `define float @Compute(i64 %a) {
+  ret float 9.150000e+01
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass(i64 %a)
+  ret i64 %r
+}
+`,
+			cCheck: "UINT64_C(0x42b70000)",
+		},
+		{
+			name:     "scalar_call",
+			decl:     "func Pass(uint64) uint64\nfunc Compute(uint64) uint64",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nRET\n",
+			goCallee: "func Compute(a uint64) uint64 { return a*7+9 }",
+			goCheck:  "if Pass(a)!=a*7+9 { panic(\"scalar ABIInternal call mismatch\") }",
+			llvmShim: `define i64 @Compute(i64 %a) {
+  %x = mul i64 %a, 7
+  %r = add i64 %x, 9
+  ret i64 %r
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass(i64 %a)
+  ret i64 %r
+}
+`,
+			cCheck: "inputs[i]*7+9",
+		},
+		{
+			name:    "nested_integer_entry",
+			decl:    "type Pair struct { Lo,Hi uint64 }; type Nested struct { A uint64; B Pair }; func Pass(Nested) uint64",
+			source:  "TEXT ·Pass<ABIInternal>(SB),4,$0-32\nEOR R1,R0,R0\nEOR R2,R0,R0\nRET\n",
+			goCheck: "if Pass(Nested{a,Pair{a*7+9,a*11+3}})!=a^(a*7+9)^(a*11+3) { panic(\"nested ABIInternal entry mismatch\") }",
+			llvmShim: `define i64 @invoke(i64 %a) {
+  %x0 = mul i64 %a, 7
+  %x = add i64 %x0, 9
+  %y0 = mul i64 %a, 11
+  %y = add i64 %y0, 3
+  %v0 = insertvalue { i64, { i64, i64 } } undef, i64 %a, 0
+  %v1 = insertvalue { i64, { i64, i64 } } %v0, i64 %x, 1, 0
+  %v = insertvalue { i64, { i64, i64 } } %v1, i64 %y, 1, 1
+  %r = call i64 @Pass({ i64, { i64, i64 } } %v)
+  ret i64 %r
+}
+`,
+			cCheck: "inputs[i]^(inputs[i]*7+9)^(inputs[i]*11+3)",
+		},
+		{
+			name:    "mixed_banks_entry_result",
+			decl:    "type Mixed struct { S float32; D float64; I uint64 }; type Result struct { D float64; I uint64 }; func Pass(Mixed) Result",
+			source:  "TEXT ·Pass<ABIInternal>(SB),4,$0-40\nFMOVD F1,F0\nADD $9,R0\nRET\n",
+			goCheck: "r:=Pass(Mixed{-13.25,91.5,a}); if r.D!=91.5 || r.I!=a+9 { panic(\"mixed ABIInternal banks mismatch\") }",
+			llvmShim: `define i64 @invoke(i64 %a) {
+  %v0 = insertvalue { float, double, i64 } undef, float -1.325000e+01, 0
+  %v1 = insertvalue { float, double, i64 } %v0, double 9.150000e+01, 1
+  %v = insertvalue { float, double, i64 } %v1, i64 %a, 2
+  %r = call { double, i64 } @Pass({ float, double, i64 } %v)
+  %d = extractvalue { double, i64 } %r, 0
+  %i = extractvalue { double, i64 } %r, 1
+  %ok = fcmp oeq double %d, 9.150000e+01
+  %got = select i1 %ok, i64 %i, i64 0
+  ret i64 %got
+}
+`,
+			cCheck: "inputs[i]+9",
+		},
+		{
+			name:    "one_element_array",
+			decl:    "func Pass([1]uint64) [1]uint64",
+			source:  "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nADD $9,R0\nRET\n",
+			goCheck: "if Pass([1]uint64{a})[0]!=a+9 { panic(\"array ABIInternal mismatch\") }",
+			llvmShim: `define i64 @invoke(i64 %a) {
+  %v = insertvalue [1 x i64] undef, i64 %a, 0
+  %r = call i64 @Pass([1 x i64] %v)
+  ret i64 %r
+}
+`,
+			cCheck: "inputs[i]+9",
+		},
+		{
+			name:     "nested_call_mixed_results",
+			decl:     "type Pair struct { Lo,Hi uint64 }; type Nested struct { A uint64; B Pair }; func Pass(Nested) uint64\nfunc Compute(Nested) (uint64,float64,uint64)",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-32\nCALL ·Compute<ABIInternal>(SB)\nFMOVD F0,R9\nEOR R1,R0,R0\nEOR R9,R0,R0\nRET\n",
+			goCallee: "func Compute(a Nested) (uint64,float64,uint64) { return a.A*7+9,91.5,a.B.Hi*11+3 }",
+			goCheck:  "if Pass(Nested{a,Pair{a*7+9,a*11+3}})!=(a*7+9)^0x4056e00000000000^((a*11+3)*11+3) { panic(\"nested ABIInternal result banks mismatch\") }",
+			llvmShim: `define { i64, double, i64 } @Compute({ i64, { i64, i64 } } %v) {
+  %a = extractvalue { i64, { i64, i64 } } %v, 0
+  %hi = extractvalue { i64, { i64, i64 } } %v, 1, 1
+  %x0 = mul i64 %a, 7
+  %x = add i64 %x0, 9
+  %y0 = mul i64 %hi, 11
+  %y = add i64 %y0, 3
+  %r0 = insertvalue { i64, double, i64 } undef, i64 %x, 0
+  %r1 = insertvalue { i64, double, i64 } %r0, double 9.150000e+01, 1
+  %r = insertvalue { i64, double, i64 } %r1, i64 %y, 2
+  ret { i64, double, i64 } %r
+}
+define i64 @invoke(i64 %a) {
+  %x0 = mul i64 %a, 7
+  %x = add i64 %x0, 9
+  %y0 = mul i64 %a, 11
+  %y = add i64 %y0, 3
+  %v0 = insertvalue { i64, { i64, i64 } } undef, i64 %a, 0
+  %v1 = insertvalue { i64, { i64, i64 } } %v0, i64 %x, 1, 0
+  %v = insertvalue { i64, { i64, i64 } } %v1, i64 %y, 1, 1
+  %r = call i64 @Pass({ i64, { i64, i64 } } %v)
+  ret i64 %r
+}
+`,
+			cCheck: "(inputs[i]*7+9)^UINT64_C(0x4056e00000000000)^((inputs[i]*11+3)*11+3)",
+		},
+		{
+			name:     "zero_argument_call",
+			decl:     "func Pass() uint64\nfunc Compute() uint64",
+			source:   "TEXT ·Pass<ABIInternal>(SB),4,$0-8\nCALL ·Compute<ABIInternal>(SB)\nRET\n",
+			goCallee: "func Compute() uint64 { return 0x123456789abcdef0 }",
+			goCheck:  "if Pass()!=0x123456789abcdef0 { panic(\"zero-argument ABIInternal mismatch\") }",
+			llvmShim: `define i64 @Compute() {
+  ret i64 1311768467463790320
+}
+define i64 @invoke(i64 %a) {
+  %r = call i64 @Pass()
+  ret i64 %r
+}
+`,
+			cCheck: "UINT64_C(0x123456789abcdef0)",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			goDecl := tc.decl
+			if tc.goCallee != "" {
+				goDecl = strings.Split(goDecl, "\nfunc Compute")[0] + "\n" + tc.goCallee
+			}
+			runARM64GoInternalOracle(t, tc.source, "package main\n"+goDecl+"\nfunc main() { for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} { _=a; "+tc.goCheck+" } }\n", len(runner) != 0)
+			pkg := mustGoPackage(t, "test/internalaggregate", "package internalaggregate\n"+tc.decl+"\n")
+			translate := func(target string) string {
+				tr, err := TranslateGoModule(pkg, []byte(tc.source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				ir := tr.Module.String()
+				// The independent LLVM callee definition replaces only its exact
+				// external declaration; it does not rewrite translated instructions.
+				ir = strings.ReplaceAll(ir, "declare i64 @Compute(i64)\n", "")
+				ir = strings.ReplaceAll(ir, "declare i64 @Compute()\n", "")
+				ir = strings.ReplaceAll(ir, "declare float @Compute(i64)\n", "")
+				ir = strings.ReplaceAll(ir, "declare { i64, double, i64 } @Compute({ i64, { i64, i64 } })\n", "")
+				return ir + "\n" + tc.llvmShim
+			}
+			for _, target := range []string{
+				"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+			} {
+				compileLLVMToObject(t, llc, target, "go-internal.ll", "go-internal.o", translate(target))
+			}
+			main := fmt.Sprintf(`#include <stdint.h>
+extern uint64_t invoke(uint64_t);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) {
+    uint64_t want=%s;
+    if (invoke(inputs[i])!=want) return 1;
+  }
+  return 0;
+}
+`, tc.cCheck)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "go_internal_aggregate", triple, translate(triple), main, runner)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalBytealgCount(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg", "count_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const goMain = `package main
+import "bytes"
+func Count([]byte,byte) int
+func CountString(string,byte) int
+func main() {
+  var data [641]byte
+  for i:=range data { data[i]=byte(i%19) }
+  original:=data
+  for _,n:=range []int{0,1,15,16,17,31,32,33,255,256,257,640} {
+    for _,offset:=range []int{0,1} {
+      b:=data[offset:offset+n]
+      for _,c:=range []byte{0,7,18,255} {
+        want:=bytes.Count(b,[]byte{c})
+        if Count(b,c)!=want || CountString(string(b),c)!=want { panic("actual bytealg count register contract mismatch") }
+        if data!=original { panic("actual bytealg count input/canary mutation") }
+      }
+    }
+  }
+}
+`
+	runARM64GoInternalOracle(t, string(source), goMain, len(runner) != 0)
+	pkg := arm64BytealgCountSDKPackage(t)
+	const shim = `define i64 @invokeCount(ptr %p, i64 %n, i8 %c) {
+  %b0 = insertvalue { ptr, i64, i64 } undef, ptr %p, 0
+  %b1 = insertvalue { ptr, i64, i64 } %b0, i64 %n, 1
+  %b = insertvalue { ptr, i64, i64 } %b1, i64 %n, 2
+  %r = call i64 @Count({ ptr, i64, i64 } %b, i8 %c)
+  ret i64 %r
+}
+define i64 @invokeCountString(ptr %p, i64 %n, i8 %c) {
+  %s0 = insertvalue { ptr, i64 } undef, ptr %p, 0
+  %s = insertvalue { ptr, i64 } %s0, i64 %n, 1
+  %r = call i64 @CountString({ ptr, i64 } %s, i8 %c)
+  ret i64 %r
+}
+`
+	translate := func(target string) string {
+		tr, err := TranslateGoModule(pkg, source, GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+		})
+		if tr != nil && !tr.Module.IsNil() {
+			defer tr.Module.Dispose()
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		return tr.Module.String() + "\n" + shim
+	}
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc", "aarch64-unknown-freebsd",
+	} {
+		compileLLVMToObject(t, llc, target, "bytealg-count.ll", "bytealg-count.o", translate(target))
+	}
+	const main = `#include <stdint.h>
+extern int64_t invokeCount(uint8_t *,uint64_t,uint8_t);
+extern int64_t invokeCountString(uint8_t *,uint64_t,uint8_t);
+int main(void) {
+  uint8_t data[641], search[]={0,7,18,255};
+  unsigned sizes[]={0,1,15,16,17,31,32,33,255,256,257,640};
+  for (unsigned i=0;i<641;i++) data[i]=i%19;
+  for (unsigned j=0;j<12;j++) for (unsigned off=0;off<2;off++) {
+    for (unsigned k=0;k<4;k++) {
+      int64_t want=0;
+      for(unsigned i=0;i<sizes[j];i++) want+=data[off+i]==search[k];
+      if (invokeCount(data+off,sizes[j],search[k])!=want) return 1;
+      if (invokeCountString(data+off,sizes[j],search[k])!=want) return 2;
+      for (unsigned i=0;i<641;i++) if (data[i]!=i%19) return 3;
+    }
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "go_internal_count", triple, translate(triple), main, runner)
+	t.Log("Count and CountString: 96 samples each, original Go and LLVM/C numerical/input-canary oracles; five target objects")
+}
diff --git a/arm64_go_register_abi.go b/arm64_go_register_abi.go
new file mode 100644
index 000000000..97897e1b4
--- /dev/null
+++ b/arm64_go_register_abi.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// ARM64GoRegisterValue identifies a scalar leaf of an LLVM argument or result.
+// Result values have Index zero and Path relative to the complete LLVM return.
+type ARM64GoRegisterValue struct {
+	Index    int
+	Path     []int
+	Type     LLVMType
+	Register Reg
+}
+
+// ARM64GoRegisterABI describes an entirely register-assigned Go ABIInternal
+// boundary. Its non-nil presence is significant for a zero-argument function.
+// Integer/pointer and floating leaves use independent R0-R15/F0-F15 banks;
+// result assignment restarts both banks. It is not a memory/ownership contract.
+type ARM64GoRegisterABI struct {
+	Params  []ARM64GoRegisterValue
+	Results []ARM64GoRegisterValue
+}
+
+func arm64GoABIContext(format string, args ...any) error {
+	return fmt.Errorf("%w: ARM64 Go ABIInternal %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+// This is the recursive scalar assignment in Go's abiutils.go, restricted to
+// values that are wholly register assigned. Arrays longer than one and a bank
+// overflow require stack-ABI context; do not flatten them into guessed registers.
+func arm64GoABILeaves(typ LLVMType, path []int, visit func(LLVMType, []int) error) error {
+	return goLLVMScalarLeaves(typ, path, 1, visit)
+}
+
+// ABI consumers share the aggregate grammar, but supply their own array bound
+// and leaf callback. A larger bound does not assign registers or frame roles.
+func goLLVMScalarLeaves(typ LLVMType, path []int, arrayLimit uint64, visit func(LLVMType, []int) error) error {
+	if len(path) > 64 {
+		return arm64GoABIContext("aggregate nesting exceeds the bounded contract")
+	}
+	if isARM64ABIIntegerType(typ) || isARM64ABIFloatingType(typ) {
+		return visit(typ, path)
+	}
+	s := strings.TrimSpace(string(typ))
+	var children []LLVMType
+	if strings.HasPrefix(s, "{") && strings.HasSuffix(s, "}") {
+		inner := strings.TrimSpace(s[1 : len(s)-1])
+		depth, start := 0, 0
+		for i, ch := range inner {
+			switch ch {
+			case '{', '[':
+				depth++
+			case '}', ']':
+				depth--
+			case ',':
+				if depth == 0 {
+					children = append(children, LLVMType(strings.TrimSpace(inner[start:i])))
+					start = i + 1
+				}
+			}
+			if depth < 0 {
+				return arm64GoABIContext("malformed aggregate %s", typ)
+			}
+		}
+		if depth != 0 || inner == "" {
+			return arm64GoABIContext("malformed or zero-sized aggregate %s", typ)
+		}
+		children = append(children, LLVMType(strings.TrimSpace(inner[start:])))
+	} else if strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") {
+		count, elem, found := strings.Cut(strings.TrimSpace(s[1:len(s)-1]), " x ")
+		n, err := strconv.ParseUint(count, 10, 64)
+		if !found || err != nil || n == 0 || n > arrayLimit {
+			return arm64GoABIContext("array %s needs a stack/zero-size contract", typ)
+		}
+		for index := uint64(0); index < n; index++ {
+			next := append(append([]int(nil), path...), int(index))
+			if err := goLLVMScalarLeaves(LLVMType(strings.TrimSpace(elem)), next, arrayLimit, visit); err != nil {
+				return err
+			}
+		}
+		return nil
+	} else {
+		return arm64GoABIContext("unrecognized scalar/aggregate type %s", typ)
+	}
+	for i, child := range children {
+		next := append(append([]int(nil), path...), i)
+		if err := goLLVMScalarLeaves(child, next, arrayLimit, visit); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func arm64GoRegisterABIForSig(sig FuncSig) (*ARM64GoRegisterABI, error) {
+	contract := new(ARM64GoRegisterABI)
+	assign := func(index int, typ LLVMType, cursor *arm64ABIRegisterCursor, out *[]ARM64GoRegisterValue) error {
+		return arm64GoABILeaves(typ, nil, func(leaf LLVMType, path []int) error {
+			reg, err := cursor.next(leaf)
+			if err != nil {
+				return arm64GoABIContext("%s: %v; stack assignment is not modeled", sig.Name, err)
+			}
+			*out = append(*out, ARM64GoRegisterValue{Index: index, Path: path, Type: leaf, Register: reg})
+			return nil
+		})
+	}
+	cursor := arm64ABIRegisterCursor{}
+	for i, typ := range sig.Args {
+		if err := assign(i, typ, &cursor, &contract.Params); err != nil {
+			return nil, err
+		}
+	}
+	if sig.Ret != Void {
+		cursor = arm64ABIRegisterCursor{}
+		if err := assign(0, sig.Ret, &cursor, &contract.Results); err != nil {
+			return nil, err
+		}
+	}
+	return contract, nil
+}
+
+func arm64ValidateGoRegisterABI(sig FuncSig) error {
+	if sig.ARM64GoRegisterABI == nil {
+		return arm64GoABIContext("%q needs an explicit complete register contract", sig.Name)
+	}
+	if len(sig.ArgRegs) != 0 {
+		return arm64GoABIContext("%q mixes standard and custom register contracts", sig.Name)
+	}
+	want, err := arm64GoRegisterABIForSig(sig)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(want, sig.ARM64GoRegisterABI) {
+		return arm64GoABIContext("%q has incomplete, mismatched or noncanonical register bindings", sig.Name)
+	}
+	return nil
+}
+
+func arm64GoTypeRegisterAssignable(typ types.Type) bool {
+	switch u := typ.Underlying().(type) {
+	case *types.Array:
+		return u.Len() == 1 && arm64GoTypeRegisterAssignable(u.Elem())
+	case *types.Struct:
+		if u.NumFields() == 0 {
+			return false
+		}
+		for i := 0; i < u.NumFields(); i++ {
+			if !arm64GoTypeRegisterAssignable(u.Field(i).Type()) {
+				return false
+			}
+		}
+		return true
+	case *types.Basic:
+		return u.Info()&(types.IsBoolean|types.IsInteger|types.IsFloat|types.IsComplex|types.IsString) != 0 || u.Kind() == types.UnsafePointer
+	case *types.Pointer, *types.Slice, *types.Interface, *types.Signature, *types.Map, *types.Chan:
+		return true
+	default:
+		return false
+	}
+}
+
+// DeriveARM64GoRegisterABI derives the register-only layout from a real Go
+// function declaration and its corresponding LLVM signature. Callers must
+// separately establish the explicit source ABIInternal selector. An ordinary
+// ABI0 declaration or this layout alone does not select a register entry.
+func DeriveARM64GoRegisterABI(fn *types.Func, sig FuncSig) (*ARM64GoRegisterABI, error) {
+	if fn == nil {
+		return nil, arm64GoABIContext("%q has no Go declaration", sig.Name)
+	}
+	decl, ok := fn.Type().(*types.Signature)
+	if !ok || decl.Variadic() || decl.Recv() != nil {
+		return nil, arm64GoABIContext("%q has no supported fixed function declaration", sig.Name)
+	}
+	for _, tuple := range []*types.Tuple{decl.Params(), decl.Results()} {
+		for i := 0; i < tuple.Len(); i++ {
+			if !arm64GoTypeRegisterAssignable(tuple.At(i).Type()) {
+				return nil, arm64GoABIContext("%q type %s is stack assigned or unrecognized", sig.Name, tuple.At(i).Type())
+			}
+		}
+	}
+	// Require the declaration's actual LLVM transport types, rather than
+	// letting a manual scalar signature impersonate a Go aggregate boundary.
+	sizes := types.SizesFor("gc", "arm64")
+	want, err := goFuncSigForDeclaredFunc(sig.Name, fn, "arm64", sizes, sizes, true)
+	match := err == nil && len(want.Args) == len(sig.Args) && want.Ret == sig.Ret
+	for i := range want.Args {
+		if !match || want.Args[i] != sig.Args[i] {
+			match = false
+			break
+		}
+	}
+	if !match {
+		return nil, arm64GoABIContext("%q LLVM signature does not match its declaration", sig.Name)
+	}
+	return arm64GoRegisterABIForSig(sig)
+}
+
+func arm64GoABIPath(path []int) string {
+	var b strings.Builder
+	for i, index := range path {
+		if i != 0 {
+			b.WriteString(", ")
+		}
+		fmt.Fprintf(&b, "%d", index)
+	}
+	return b.String()
+}
+
+func (c *arm64Ctx) extractGoABIValue(typ LLVMType, value string, slot ARM64GoRegisterValue) string {
+	if len(slot.Path) == 0 {
+		return value
+	}
+	t := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %s\n", t, typ, value, arm64GoABIPath(slot.Path))
+	return "%" + t
+}
+
+func (c *arm64Ctx) collectGoABIValue(typ LLVMType, slots []ARM64GoRegisterValue) (string, error) {
+	value := "undef"
+	for _, slot := range slots {
+		leaf, err := c.loadABIRegisterValue(slot.Register, slot.Type)
+		if err != nil {
+			return "", err
+		}
+		if len(slot.Path) == 0 {
+			value = leaf
+			continue
+		}
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %s, %s\n", t, typ, value, slot.Type, leaf, arm64GoABIPath(slot.Path))
+		value = "%" + t
+	}
+	return value, nil
+}
+
+func (c *arm64Ctx) goABIRegisterCallArgs(sig FuncSig) ([]string, error) {
+	if err := arm64ValidateGoRegisterABI(sig); err != nil {
+		return nil, err
+	}
+	args := make([]string, len(sig.Args))
+	for index, typ := range sig.Args {
+		var slots []ARM64GoRegisterValue
+		for _, slot := range sig.ARM64GoRegisterABI.Params {
+			if slot.Index == index {
+				slots = append(slots, slot)
+			}
+		}
+		value, err := c.collectGoABIValue(typ, slots)
+		if err != nil {
+			return nil, err
+		}
+		args[index] = fmt.Sprintf("%s %s", typ, value)
+	}
+	return args, nil
+}
+
+func (c *arm64Ctx) storeGoABIRegisterResult(sig FuncSig, value string) error {
+	for _, slot := range sig.ARM64GoRegisterABI.Results {
+		leaf := c.extractGoABIValue(sig.Ret, value, slot)
+		if err := c.storeABIRegisterValue(slot.Register, slot.Type, leaf); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/arm64_go_register_abi_test.go b/arm64_go_register_abi_test.go
new file mode 100644
index 000000000..578bec554
--- /dev/null
+++ b/arm64_go_register_abi_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func TestARM64GoRegisterABIAbsentMalformedAndStackContexts(t *testing.T) {
+	for _, declaration := range []string{
+		"func Pass([2]uint64) uint64",
+		"func Pass(uint64) [2]uint64",
+		"func Pass(struct{}) uint64",
+		"func Pass(struct{ Z [0]byte; I uint64 }) uint64",
+		"func Pass(" + strings.TrimSuffix(strings.Repeat("uint64,", 17), ",") + ") uint64",
+		"func Pass(" + strings.TrimSuffix(strings.Repeat("float64,", 17), ",") + ") uint64",
+		"func Pass() (" + strings.TrimSuffix(strings.Repeat("uint64,", 17), ",") + ")",
+	} {
+		pkg := mustGoPackage(t, "test/stackinternal", "package stackinternal\n"+declaration+"\n")
+		for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+			tr, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0\nRET\n"), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target,
+				ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+			})
+			if err == nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s %s: stack/unrecognized contract must fail closed: %v", target, declaration, err)
+			}
+		}
+	}
+
+	sig := FuncSig{Name: "X", Args: []LLVMType{"{ ptr, { double, i64 } }"}, Ret: I64}
+	valid, err := arm64GoRegisterABIForSig(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		name string
+		edit func(*FuncSig)
+	}{
+		{"absent", func(s *FuncSig) { s.ARM64GoRegisterABI = nil }},
+		{"incomplete", func(s *FuncSig) { s.ARM64GoRegisterABI.Params = s.ARM64GoRegisterABI.Params[:2] }},
+		{"wrong_bank", func(s *FuncSig) { s.ARM64GoRegisterABI.Params[1].Register = "R1" }},
+		{"wrong_type", func(s *FuncSig) { s.ARM64GoRegisterABI.Params[0].Type = I64 }},
+		{"wrong_path", func(s *FuncSig) { s.ARM64GoRegisterABI.Params[2].Path = []int{0} }},
+		{"duplicate_register", func(s *FuncSig) { s.ARM64GoRegisterABI.Params[2].Register = "R0" }},
+		{"wrong_result", func(s *FuncSig) { s.ARM64GoRegisterABI.Results[0].Register = "R1" }},
+		{"mixed_custom", func(s *FuncSig) { s.ArgRegs = []Reg{"R9"} }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			copy := sig
+			copy.ARM64GoRegisterABI = &ARM64GoRegisterABI{
+				Params: append([]ARM64GoRegisterValue(nil), valid.Params...), Results: append([]ARM64GoRegisterValue(nil), valid.Results...),
+			}
+			tc.edit(&copy)
+			if err := arm64ValidateGoRegisterABI(copy); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("malformed/absent typed contract accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64GoRegisterABISourceSelectorAndDeclarationRequired(t *testing.T) {
+	pkg := mustGoPackage(t, "test/sourceinternal", "package sourceinternal\nfunc Pass(uint64) uint64\n")
+	fn := pkg.Types.Scope().Lookup("Pass").(*types.Func)
+	sig := sigWithClassicFrame("Pass", []LLVMType{I64}, I64)
+	if _, err := DeriveARM64GoRegisterABI(nil, sig); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("absent declaration accepted: %v", err)
+	}
+	bad := sig
+	bad.Args = []LLVMType{Ptr}
+	if _, err := DeriveARM64GoRegisterABI(fn, bad); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("mismatched declaration accepted: %v", err)
+	}
+	for _, selector := range []string{"", "<ABI0>", "<ABIInternal>"} {
+		source := fmt.Sprintf("TEXT ·Pass%s(SB),4,$0-16\nRET\n", selector)
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		hasContract := tr.Signatures["Pass"].ARM64GoRegisterABI != nil
+		tr.Module.Dispose()
+		if hasContract != (selector == "<ABIInternal>") {
+			t.Fatalf("source %q: unexpected register proof=%t", selector, hasContract)
+		}
+	}
+
+	tr, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\nMOVD a+0(FP),R0\nRET\n"), GoModuleOptions{
+		GOARCH: "arm64", ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+	})
+	if err == nil {
+		tr.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unmodeled ABIInternal FP spill access accepted: %v", err)
+	}
+}
+
+func TestARM64GoRegisterABIControlEffectsUseTypedRegisterLeaves(t *testing.T) {
+	for _, pointer := range []bool{false, true} {
+		sig := sigWithClassicFrame("callee", nil, I64)
+		if pointer {
+			sig = sigWithClassicFrame("callee", []LLVMType{"{ ptr, i64 }"}, I64)
+		}
+		var err error
+		sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64ControlState{
+			regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R0": arm64ControlFromMap(map[string]bool{"sp:0": true}), "R30": arm64ControlFromMap(map[string]bool{"label:continuation": true})},
+			memory: map[string]arm64ControlValue{"sp:0": arm64ControlFromMap(map[string]bool{"label:outer": true}), "sp:8": arm64ControlFromMap(map[string]bool{"": true})},
+		}
+		ctx := &arm64Ctx{resolve: func(s string) string { return goStripABISuffix(strings.TrimPrefix(s, "·")) }, sigs: map[string]FuncSig{"callee": sig}}
+		ctx.invalidateControlCallResults(state, Operand{Kind: OpSym, Sym: "·callee<ABIInternal>(SB)"})
+		if pointer && !arm64ControlHas(state.memory["sp:0"], "") {
+			t.Fatal("nested Ptr register argument failed to invalidate saved-link memory")
+		}
+		if !pointer && arm64ControlHas(state.memory["sp:8"], "label:continuation") {
+			t.Fatal("register result was incorrectly stored in the classic ABI0 frame")
+		}
+	}
+}
+
+func TestARM64GoRegisterABITailCannotBorrowEntryProof(t *testing.T) {
+	sig := FuncSig{Name: "Pass", Args: []LLVMType{I64}, Ret: I64}
+	var err error
+	sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"·Missing<ABIInternal>(SB)", "·Missing<ABI0>(SB)", "·Missing(SB)"} {
+		for _, op := range []string{"B", "JMP", "RET"} {
+			source := "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nADD $9,R0\n" + op + " " + target + "\n"
+			requireARM64GoABIInternalObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"Pass": sig},
+				ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s %s inherited a fabricated target entry/cross-ABI tail contract: %v", op, target, err)
+			}
+		}
+	}
+}
diff --git a/arm64_go_register_availability_test.go b/arm64_go_register_availability_test.go
new file mode 100644
index 000000000..ba251aeb3
--- /dev/null
+++ b/arm64_go_register_availability_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalCallerSaveOracle(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·Pass<ABIInternal>(SB),4,$0-16
+MOVD R0,R9
+CALL ·Compute<ABIInternal>(SB)
+EOR R9,R0,R0
+RET
+TEXT ·Compute<ABIInternal>(SB),4,$0-16
+MOVD $99,R9
+ADD $9,R0
+RET
+`
+	const decl = "func Pass(uint64) uint64\nfunc Compute(uint64) uint64\n"
+	runARM64GoInternalOracle(t, source, "package main\n"+decl+`func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    if Pass(a)!=99^(a+9) { panic("actual Go caller-save R9 mismatch") }
+  }
+}
+`, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/callersave", "package callersave\n"+decl)
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+		})
+		if tr != nil {
+			tr.Module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s: out-of-band R9 result must require a machine-state call contract, got %v", triple, err)
+		}
+	}
+}
+
+func TestARM64GoInternalAvailabilityMissingContext(t *testing.T) {
+	for _, tc := range []struct{ name, before, after, result string }{
+		{"first_gp_read", "", "MOVD R9,R0", "uint64"},
+		{"two_operand_update_is_read", "", "ADD $3,R9\nMOVD R9,R0", "uint64"},
+		{"memory_base", "", "MOVD (R9),R0", "uint64"},
+		{"memory_writeback_base", "", "MOVD.P R0,8(R9)", "uint64"},
+		{"shift_source", "", "EOR R9<<3,R0,R0", "uint64"},
+		{"register_extended_source", "", "ADD R9.UXTW,R0,R0", "uint64"},
+		{"fp_register", "", "FMOVD F9,R0", "uint64"},
+		{"flags_clobbered", "CMP $0,R0\n", "CSET NE,R0", "uint64"},
+		{"carry_clobbered", "CMP $0,R0\n", "ADC ZR,R0", "uint64"},
+		{"negate_carry_clobbered", "CMP $0,R0\n", "NGC R0,R0", "uint64"},
+		{"merge_one_missing_write", "", "CBZ R0,left\nMOVD $99,R9\nB done\nleft:\nNOOP\ndone:\nEOR R9,R0,R0", "uint64"},
+		{"scalar_vector_alias", "", "VMOV V0.D[1],R0", "(uint64,float64)"},
+		{"scalar_result_width", "", "FMOVD F0,R0", "float32"},
+		{"raw_native_effect", "", "WORD $0xd53bd040", "uint64"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			decl := "package availability\nfunc Pass(uint64) uint64\nfunc Compute(uint64) " + tc.result + "\n"
+			pkg := mustGoPackage(t, "test/availability", decl)
+			source := "TEXT ·Pass<ABIInternal>(SB),4,$0-16\n" + tc.before + "CALL ·Compute<ABIInternal>(SB)\n" + tc.after + "\nRET\n"
+			requireARM64GoABIInternalObject(t, source)
+			for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: triple,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				})
+				if tr != nil {
+					tr.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: missing complete machine state must require context, got %v", triple, err)
+				}
+			}
+		})
+	}
+	// The Go declaration initializes only R0, not the ambient native register
+	// file. A register-only entry cannot manufacture a zero R9 input either.
+	pkg := mustGoPackage(t, "test/availabilityentry", "package availabilityentry\nfunc Pass(uint64) uint64\n")
+	tr, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\nMOVD R9,R0\nRET\n"), GoModuleOptions{GOARCH: "arm64"})
+	if tr != nil {
+		tr.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("undeclared register entry: %v", err)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalExplicitCustomTail(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·Pass<ABIInternal>(SB),4,$0-16
+ADD $9,R0
+B customTail<>(SB)
+TEXT customTail<>(SB),516,$0-0
+ADD $7,R0
+RET
+`
+	runARM64GoInternalOracle(t, source, `package main
+func Pass(uint64) uint64
+func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    if Pass(a)!=a+16 { panic("explicit custom tail register mismatch") }
+  }
+}
+`, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/customtail", "package customtail\nfunc Pass(uint64) uint64\n")
+	translate := func(target string) string {
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target,
+			ResolveSym: func(sym string) string {
+				return strings.TrimSuffix(strings.TrimPrefix(goStripABISuffix(sym), "·"), "<>")
+			},
+			ManualSig: func(name string) (FuncSig, bool) {
+				return FuncSig{Name: "customTail", Args: []LLVMType{I64}, Ret: I64, ArgRegs: []Reg{"R0"}}, name == "customTail"
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer tr.Module.Dispose()
+		return tr.Module.String()
+	}
+	for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		compileLLVMToObject(t, llc, target, "custom-tail.ll", "custom-tail.o", translate(target))
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "custom_tail", triple, translate(triple), `#include <stdint.h>
+extern uint64_t Pass(uint64_t);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) if (Pass(inputs[i])!=inputs[i]+16) return 1;
+  return 0;
+}
+`, runner)
+}
diff --git a/arm64_go_register_narrow_test.go b/arm64_go_register_narrow_test.go
new file mode 100644
index 000000000..ed2693d95
--- /dev/null
+++ b/arm64_go_register_narrow_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A Go result declaration promises only its own bits. Native assembly can
+// retain other bits in the physical register; zero-extending a typed LLVM
+// result must not pretend that those extra native bits were transferred.
+func TestCrossLinuxRuntimeMatrixARM64GoInternalNarrowResultHighBits(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	for _, bits := range []int{8, 16, 32} {
+		for _, copy := range []bool{false, true} {
+			t.Run(fmt.Sprintf("uint%d/copy_%t", bits, copy), func(t *testing.T) {
+				body := ""
+				if copy {
+					body = "MOVD R0,R9\nMOVD R9,R0\n"
+				}
+				source := "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\n" + body + "RET\n" +
+					"TEXT ·Compute<ABIInternal>(SB),4,$0-16\nMOVD $0x123456789abcdef0,R0\nRET\n"
+				decl := fmt.Sprintf("func Pass(uint64) uint64\nfunc Compute(uint64) uint%d\n", bits)
+				runARM64GoInternalOracle(t, source, "package main\n"+decl+`func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    if Pass(a)!=0x123456789abcdef0 { panic("actual Go narrow result retains unspecified high bits") }
+  }
+}
+`, len(runner) != 0)
+				pkg := mustGoPackage(t, "test/narrowresult", "package narrowresult\n"+decl)
+				for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+					tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+						GOARCH: "arm64", TargetTriple: target,
+						ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+					})
+					if tr != nil {
+						tr.Module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s: unspecified uint%d result high bits must require context: %v", target, bits, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalNarrowResultConsumers(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const nativeBits = uint64(0x123456789abcdef0)
+	for _, bits := range []int{8, 16, 32} {
+		mask := uint64(1)<<uint(bits) - 1
+		unsigned := nativeBits & mask
+		signed := unsigned
+		if signed&(uint64(1)<<uint(bits-1)) != 0 {
+			signed |= ^mask
+		}
+		suffix := map[int]string{8: "B", 16: "H", 32: "W"}[bits]
+		for _, tc := range []struct {
+			name, body, result string
+			want               uint64
+		}{
+			{"unsigned_extend", "UXT" + suffix + " R9,R0", "uint64", unsigned},
+			{"signed_extend", "SXT" + suffix + " R9,R0", "uint64", signed},
+			{"unsigned_move", "MOV" + suffix + "U R9,R0", "uint64", unsigned},
+			{"signed_move", "MOV" + suffix + " R9,R0", "uint64", signed},
+			{"bitfield_extract", fmt.Sprintf("UBFX $0,R9,$%d,R0", bits), "uint64", unsigned},
+			{"bitfield_shifted_extract", fmt.Sprintf("UBFX $3,R9,$%d,R0", bits-3), "uint64", unsigned >> 3},
+			{"bitfield_signed_extract", fmt.Sprintf("SBFX $0,R9,$%d,R0", bits), "uint64", signed},
+			{"bitfield_insert", fmt.Sprintf("MOVD $-1,R0\nBFI $4,R9,$%d,R0", bits), "uint64", ^(mask << 4) | unsigned<<4},
+			{"bitfield_low_insert", fmt.Sprintf("MOVD $-1,R0\nBFXIL $0,R9,$%d,R0", bits), "uint64", ^mask | unsigned},
+			{"typed_narrow_return", "MOVD R9,R0", fmt.Sprintf("uint%d", bits), unsigned},
+		} {
+			t.Run(fmt.Sprintf("uint%d/%s", bits, tc.name), func(t *testing.T) {
+				source := "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nCALL ·Compute<ABIInternal>(SB)\nMOVD R0,R9\n" + tc.body + "\nRET\n" +
+					"TEXT ·Compute<ABIInternal>(SB),4,$0-16\nMOVD $0x123456789abcdef0,R0\nRET\n"
+				decl := fmt.Sprintf("func Pass(uint64) %s\nfunc Compute(uint64) uint%d\n", tc.result, bits)
+				runARM64GoInternalOracle(t, source, "package main\n"+decl+fmt.Sprintf(`func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    if uint64(Pass(a))!=%d { panic("actual Go narrowed result consumer mismatch") }
+  }
+}
+`, tc.want), len(runner) != 0)
+				pkg := mustGoPackage(t, "test/narrowconsumer", "package narrowconsumer\n"+decl)
+				translate := func(target string) string {
+					tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+						GOARCH: "arm64", TargetTriple: target,
+						ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer tr.Module.Dispose()
+					return tr.Module.String()
+				}
+				for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+					compileLLVMToObject(t, llc, target, "narrow-consumer.ll", "narrow-consumer.o", translate(target))
+				}
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "narrow_consumer", triple, translate(triple), fmt.Sprintf(`#include <stdint.h>
+extern %s Pass(uint64_t);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) if ((uint64_t)Pass(inputs[i])!=UINT64_C(%d)) return 1;
+  return 0;
+}
+`, map[string]string{"uint64": "uint64_t", "uint8": "uint8_t", "uint16": "uint16_t", "uint32": "uint32_t"}[tc.result], tc.want), runner)
+			})
+		}
+	}
+}
+
+func TestARM64GoInternalNarrowMissingBitsContext(t *testing.T) {
+	for _, bits := range []int{8, 16, 32} {
+		for _, body := range []string{
+			"ADD $1,R9,R0",
+			fmt.Sprintf("UBFX $1,R9,$%d,R0", bits),
+			fmt.Sprintf("BFI $4,R9,$%d,R0", bits), // old R0 high bits must be preserved
+			"FMOVD R9,F0\nFMOVD F0,R0",
+			"CBZ R9,done\ndone:\nMOVD $0,R0",
+			"MOVD R9,(RSP)\nMOVD $0,R0", // a full-width memory write observes all bits
+		} {
+			t.Run(fmt.Sprintf("uint%d/%s", bits, body), func(t *testing.T) {
+				source := "TEXT ·Pass<ABIInternal>(SB),4,$16-16\nCALL ·Compute<ABIInternal>(SB)\nMOVD R0,R9\n" + body + "\nRET\n"
+				requireARM64GoABIInternalObject(t, source)
+				pkg := mustGoPackage(t, "test/narrowmissing", fmt.Sprintf("package narrowmissing\nfunc Pass(uint64) uint64\nfunc Compute(uint64) uint%d\n", bits))
+				for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+					tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+						GOARCH: "arm64", TargetTriple: target,
+						ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+					})
+					if tr != nil {
+						tr.Module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s: missing high bits must require context: %v", target, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_go_register_vector_bits_test.go b/arm64_go_register_vector_bits_test.go
new file mode 100644
index 000000000..bd6981c99
--- /dev/null
+++ b/arm64_go_register_vector_bits_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64GoInternalVectorDuplicateInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOV R0,V0.D1", "VMOV R0,V0", "VMOV RSP,V0.B16",
+		"VMOV F0,V0.B16", "VMOV.P R0,V0.B16", "VMOV.W R0,V0.B16",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·Pass<ABIInternal>(SB),4,$0-16\n" + instruction + "\nRET\n"
+			// No ABI selector is needed to prove the invalid operand grammar.
+			requireARM64GoAssemblerResult(t, strings.ReplaceAll(source, "<ABIInternal>", ""), false)
+			pkg := mustGoPackage(t, "test/vectorinvalid", "package vectorinvalid\nfunc Pass(uint64) uint64\n")
+			tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOARCH: "arm64"})
+			if tr != nil {
+				tr.Module.Dispose()
+			}
+			if err == nil {
+				t.Fatalf("invalid Go VMOV form was accepted: %s", instruction)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoInternalNarrowVectorDuplicate(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		arrangement string
+		bits, lanes int
+	}{
+		{"B8", 8, 8}, {"B16", 8, 16}, {"H4", 16, 4}, {"H8", 16, 8},
+		{"S2", 32, 2}, {"S4", 32, 4}, {"D2", 64, 2},
+	} {
+		t.Run(tc.arrangement, func(t *testing.T) {
+			const value = uint64(0x123456789abcdef0)
+			low := value
+			if tc.bits < 64 {
+				low = 0
+				mask := uint64(1)<<uint(tc.bits) - 1
+				for shift := 0; shift < 64; shift += tc.bits {
+					low |= value & mask << uint(shift)
+				}
+			}
+			high := low
+			if tc.bits*tc.lanes == 64 {
+				high = 0
+			}
+			source := "TEXT ·Pass<ABIInternal>(SB),4,$0-24\nCALL ·Compute<ABIInternal>(SB)\nMOVD R0,R9\n" +
+				"VMOV R9,V0." + tc.arrangement + "\nVMOV V0.D[0],R0\nVMOV V0.D[1],R1\nRET\n" +
+				"TEXT ·Compute<ABIInternal>(SB),4,$0-16\nMOVD $0x123456789abcdef0,R0\nRET\n"
+			decl := fmt.Sprintf("func Pass(uint64) (uint64,uint64)\nfunc Compute(uint64) uint%d\n", tc.bits)
+			runARM64GoInternalOracle(t, source, "package main\n"+decl+fmt.Sprintf(`func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    lo,hi:=Pass(a)
+    if lo!=%d || hi!=%d { panic("Go vector broadcast low-bit/upper-half mismatch") }
+  }
+}
+`, low, high), len(runner) != 0)
+			pkg := mustGoPackage(t, "test/vectorbits", "package vectorbits\n"+decl)
+			translate := func(target string) string {
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				return tr.Module.String()
+			}
+			for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+				compileLLVMToObject(t, llc, target, "vector-bits.ll", "vector-bits.o", translate(target))
+			}
+			shim := fmt.Sprintf(`define i64 @invoke(i64 %%a) {
+  %%r = call { i64, i64 } @Pass(i64 %%a)
+  %%lo = extractvalue { i64, i64 } %%r, 0
+  %%hi = extractvalue { i64, i64 } %%r, 1
+  %%oklo = icmp eq i64 %%lo, %d
+  %%okhi = icmp eq i64 %%hi, %d
+  %%ok = and i1 %%oklo, %%okhi
+  %%n = zext i1 %%ok to i64
+  ret i64 %%n
+}
+`, low, high)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "vector_bits", triple, translate(triple)+shim, `#include <stdint.h>
+extern uint64_t invoke(uint64_t);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) if (invoke(inputs[i])!=1) return 1;
+  return 0;
+}
+`, runner)
+		})
+	}
+}
diff --git a/arm64_go_scratch_binding.go b/arm64_go_scratch_binding.go
new file mode 100644
index 000000000..8ad51eca2
--- /dev/null
+++ b/arm64_go_scratch_binding.go
@@ -0,0 +1,418 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"go/ast"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+type arm64ScratchBinding struct {
+	source     *GoARM64ScratchSource
+	context    context.Context
+	file       *File
+	target     string
+	sigs       map[string][]byte
+	symbols    map[string]string
+	closed     map[string]bool
+	calls      map[string]string
+	calleeSigs map[string][]byte
+}
+
+// GoARM64ScratchBindingNeeded is only a capture scheduling predicate. It does
+// not certify a callee or authorize its memory/frame/ABI effects.
+func GoARM64ScratchBindingNeeded(file *File) bool {
+	if file == nil || file.Arch != ArchARM64 {
+		return false
+	}
+	for _, function := range file.Funcs {
+		if function.FrameSize < 32752 {
+			continue
+		}
+		for _, instruction := range function.Instrs {
+			if (instruction.Op == "CALL" || instruction.Op == "BL") && len(instruction.Args) == 1 &&
+				instruction.Args[0].Kind == OpSym && strings.HasSuffix(instruction.Args[0].Sym, "(SB)") &&
+				!strings.Contains(instruction.Args[0].Sym, "<") {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func arm64ScratchFileSnapshot(file *File) *File {
+	copy := *file
+	copy.Funcs = make([]Func, len(file.Funcs))
+	for i, function := range file.Funcs {
+		copy.Funcs[i] = arm64PrivateTailSnapshot(function)
+	}
+	copy.Data = append([]DataStmt(nil), file.Data...)
+	for i := range copy.Data {
+		copy.Data[i].Payload = append([]byte(nil), file.Data[i].Payload...)
+	}
+	copy.Globl = append([]GloblStmt(nil), file.Globl...)
+	copy.UnlinkedPrelude = append([]string(nil), file.UnlinkedPrelude...)
+	return &copy
+}
+
+func arm64ScratchPublicSignature(sig FuncSig) []byte {
+	data, _ := json.Marshal(sig)
+	return data
+}
+
+// BindScratchClosure preserves actual declarations and whole original source.
+// The producer cannot be manufactured with a manual FuncSig or JSON proof.
+func (source *GoARM64ScratchSource) BindScratchClosure(ctx context.Context, file *File, options Options) (Options, error) {
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	if file == nil || file.Arch != ArchARM64 || options.Goarch != "arm64" || options.ResolveSym == nil ||
+		!reflect.DeepEqual(arm64ScratchFileSnapshot(file), arm64ScratchFileSnapshot(source.file)) {
+		return Options{}, arm64ScratchContext("complete original source differs from actual selection")
+	}
+	targets := map[string]string{
+		"aarch64-unknown-linux-gnu": "linux/arm64",
+		"arm64-apple-darwin":        "darwin/arm64",
+		"aarch64-apple-darwin":      "darwin/arm64",
+		"arm64-apple-macosx":        "darwin/arm64",
+		"aarch64-pc-windows-msvc":   "windows/arm64",
+	}
+	if targets[options.TargetTriple] != source.request.Target || options.WASMABI != WASMABIDirect || len(options.X86TailGroups) != 0 {
+		return Options{}, arm64ScratchContext("consumer target differs from the native object")
+	}
+	binding := &arm64ScratchBinding{source: source, context: ctx, file: arm64ScratchFileSnapshot(file),
+		target: options.TargetTriple, sigs: make(map[string][]byte), symbols: make(map[string]string), closed: make(map[string]bool), calls: make(map[string]string), calleeSigs: make(map[string][]byte)}
+	calleeLayouts := make(map[string]FuncSig)
+	for _, function := range file.Funcs {
+		if strings.Contains(function.Sym, "<") || !strings.HasPrefix(function.Sym, "·") {
+			return Options{}, arm64ScratchContext("initial binding requires ordinary same-package source definitions")
+		}
+		name := options.ResolveSym(function.Sym)
+		if name == "" || binding.sigs[name] != nil {
+			return Options{}, arm64ScratchContext("empty or colliding LLVM declaration identity")
+		}
+		object, ok := source.actual.Types.Scope().Lookup(strings.TrimPrefix(function.Sym, "·")).(*types.Func)
+		if !ok || !arm64ScratchBodyless(source.actual.Syntax, object.Name()) {
+			return Options{}, arm64ScratchContext("source has no actual bodyless declaration")
+		}
+		expected, err := DeriveGoFuncABI0Signature(name, object, "arm64", types.SizesFor("gc", "arm64"))
+		actual, present := options.Sigs[name]
+		if err != nil || !present || !bytes.Equal(arm64ScratchPublicSignature(expected), arm64ScratchPublicSignature(actual)) || binding.symbols[function.Sym] != "" {
+			return Options{}, arm64ScratchContext("typed source/LLVM declaration changed")
+		}
+		binding.sigs[name], binding.symbols[function.Sym] = arm64ScratchPublicSignature(actual), name
+	}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if (instruction.Op != "CALL" && instruction.Op != "BL") || len(instruction.Args) != 1 || instruction.Args[0].Kind != OpSym {
+				continue
+			}
+			symbol := strings.TrimSuffix(instruction.Args[0].Sym, "(SB)")
+			if strings.Contains(symbol, "<") {
+				continue
+			}
+			canonical := strings.ReplaceAll(symbol, "·", ".")
+			if strings.HasPrefix(canonical, ".") {
+				canonical = source.actual.Path + canonical
+			}
+			if captured, closed := source.closed[canonical]; closed {
+				name := options.ResolveSym(symbol)
+				actual := captured
+				actual.Name = name
+				calleeLayouts[name] = actual
+				binding.calleeSigs[name] = arm64ScratchPublicSignature(actual)
+				binding.closed[symbol] = true
+				binding.calls[symbol] = name
+			}
+		}
+	}
+	// Deep-copy public slices without stripping existing private declaration
+	// witnesses. The new pointer is never present in the stored expected layout.
+	bound := make(map[string]FuncSig, len(options.Sigs))
+	for name, signature := range options.Sigs {
+		signature.Args = append([]LLVMType(nil), signature.Args...)
+		signature.ArgRegs = append([]Reg(nil), signature.ArgRegs...)
+		signature.Frame.Params = arm64CopyFPSlots(signature.Frame.Params)
+		signature.Frame.Results = arm64CopyFPSlots(signature.Frame.Results)
+		if _, present := binding.sigs[name]; present {
+			signature.arm64NativeScratch = binding
+		}
+		bound[name] = signature
+	}
+	for name, signature := range calleeLayouts {
+		if _, root := binding.sigs[name]; root {
+			continue
+		}
+		signature.arm64NativeScratch = binding
+		bound[name] = signature
+	}
+	options.Sigs = bound
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	return options, nil
+}
+
+func (source *GoARM64ScratchSource) actualCalleeSignature(ctx context.Context, symbol, resolved string) (FuncSig, error) {
+	path := ""
+	for candidate, pkg := range source.packages {
+		if strings.HasPrefix(symbol, candidate+".") && len(candidate) > len(path) &&
+			(candidate == source.actual.Path || pkg.Standard && pkg.Goroot && goAssemblyPathWithinRoot(filepath.Join(source.settings["GOROOT"], "src"), pkg.Dir)) {
+			path = candidate
+		}
+	}
+	if path == "" {
+		return FuncSig{}, arm64ScratchContext("native callee has no actual same-package/SDK declaration role")
+	}
+	pkg, typed := source.typed[path]
+	if !typed {
+		if err := source.typecheck(ctx, GoPackage{}, source.packages[path]); err != nil {
+			return FuncSig{}, err
+		}
+		pkg = source.typed[path]
+	}
+	name := strings.TrimPrefix(symbol, path+".")
+	declaration, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+	if !ok || !arm64ScratchBodyless(pkg.Syntax, name) {
+		return FuncSig{}, arm64ScratchContext("native callee lacks its actual selected bodyless declaration")
+	}
+	return DeriveGoFuncABI0Signature(resolved, declaration, "arm64", types.SizesFor("gc", "arm64"))
+}
+
+func arm64ScratchBodyless(files []*ast.File, name string) bool {
+	count := 0
+	for _, file := range files {
+		for _, declaration := range file.Decls {
+			if function, ok := declaration.(*ast.FuncDecl); ok && function.Name != nil && function.Name.Name == name && function.Recv == nil {
+				if function.Body != nil {
+					return false
+				}
+				count++
+			}
+		}
+	}
+	return count == 1
+}
+
+func arm64ScratchNOSPLIT(function Func) bool {
+	if len(function.Instrs) == 0 || function.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	_, rest := splitOpcode(function.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) != 3 {
+		return false
+	}
+	flags := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+		if value, ok := goTextFlagValues[name]; ok {
+			return value
+		}
+		return name
+	})
+	value, valid := parseImmExpr(strings.TrimSpace(flags))
+	return valid && value&4 != 0 && value & ^uint64(4|512) == 0
+}
+
+func (source *GoARM64ScratchSource) closedNativeCallee(ctx context.Context, symbol string, visiting map[string]bool, depth int) (bool, error) {
+	return source.closedNativeCalleeWithResults(ctx, symbol, visiting, depth, make(map[string]FuncSig))
+}
+
+func (source *GoARM64ScratchSource) closedNativeCalleeWithResults(ctx context.Context, symbol string, visiting map[string]bool, depth int, results map[string]FuncSig) (bool, error) {
+	if depth >= 32 || len(visiting) >= 64 || visiting[symbol] {
+		return false, nil
+	}
+	function, present := source.functions[symbol]
+	if !present {
+		var selected *arm64ScratchPackage
+		for path, pkg := range source.packages {
+			if strings.HasPrefix(symbol, path+".") && (path == source.actual.Path || pkg.Standard && pkg.Goroot &&
+				goAssemblyPathWithinRoot(filepath.Join(source.settings["GOROOT"], "src"), pkg.Dir)) {
+				copy := pkg
+				selected = &copy
+			}
+		}
+		if selected == nil {
+			return false, nil
+		}
+		// Full selected assembly inventory is hashed even when only one source
+		// defines this target. No native module/package alias is guessed.
+		found := ""
+		for _, name := range selected.SFiles {
+			data, err := source.read(filepath.Join(selected.Dir, name))
+			if err != nil {
+				return false, err
+			}
+			for _, line := range strings.Split(string(data), "\n") {
+				fields := strings.Fields(line)
+				if len(fields) < 2 || fields[0] != "TEXT" {
+					continue
+				}
+				candidate := strings.TrimSuffix(strings.TrimSuffix(fields[1], ","), "(SB)")
+				candidate = goStripABISuffix(strings.ReplaceAll(candidate, "·", "."))
+				if strings.HasPrefix(candidate, ".") {
+					candidate = selected.ImportPath + candidate
+				}
+				if candidate == symbol {
+					if found != "" {
+						return false, arm64ScratchContext("ambiguous actual SDK assembly target")
+					}
+					found = name
+				}
+			}
+		}
+		if found == "" {
+			return false, nil
+		}
+		if err := source.captureOriginalAssembly(ctx, *selected, found); err != nil {
+			return false, err
+		}
+		if err := source.captureNativePackage(ctx, *selected); err != nil {
+			return false, err
+		}
+		function, present = source.functions[symbol]
+	}
+	if !present || !arm64ScratchNOSPLIT(function) {
+		return false, nil
+	}
+	var sdkInputs uint64
+	var sdkLayout FuncSig
+	var samePackageLayout FuncSig
+	sdkBody := !strings.HasPrefix(symbol, source.actual.Path+".")
+	if sdkBody {
+		// Opaque SDK code does not pass through this file's ordinary lowerer
+		// availability proof. Its original entry must independently close all
+		// machine inputs using the actual declaration and wrapper transport.
+		layout, err := source.actualCalleeSignature(ctx, symbol, symbol)
+		if err != nil {
+			return false, err
+		}
+		var valid bool
+		sdkInputs, valid = arm64ScratchSDKTuple(function, layout)
+		if !valid || source.abis[symbol] != "ABIInternal" {
+			return false, nil
+		}
+		sdkLayout = layout
+	} else {
+		var err error
+		samePackageLayout, err = source.actualCalleeSignature(ctx, symbol, symbol)
+		if err != nil {
+			return false, err
+		}
+		if source.abis[symbol] != "ABI0" {
+			return false, nil
+		}
+	}
+	bodies := source.native[symbol]
+	if len(bodies) < 2 {
+		return false, nil
+	} // actual uncached assembler AND actual archive member
+	visiting[symbol] = true
+	defer delete(visiting, symbol)
+	calls := make(map[string]FuncSig)
+	for _, body := range bodies {
+		for _, target := range body.calls {
+			target = source.originalObjectCallTarget(target)
+			if target == symbol && source.originalObjectGenerated(body.source) {
+				continue // The exact wrapper's own source body is checked below.
+			}
+			closed, err := source.closedNativeCalleeWithResults(ctx, target, visiting, depth+1, results)
+			if err != nil || !closed {
+				return false, err
+			}
+			if layout, initialized := results[target]; initialized {
+				calls[target] = layout
+				if strings.HasPrefix(target, source.actual.Path+".") {
+					calls["."+strings.TrimPrefix(target, source.actual.Path+".")] = layout
+				}
+			}
+		}
+	}
+	actualAssembly, originalMatched := []uint32(nil), false
+	for _, body := range bodies {
+		if !arm64ScratchNativeDoesNotAccess(body) {
+			return false, nil
+		}
+		if !source.originalObjectGenerated(body.source) {
+			if sdkBody && !arm64ScratchSDKBodyInputs(body, sdkInputs) {
+				return false, nil
+			}
+			if !sdkBody && !arm64ScratchSamePackageInputsWithCalls(function, samePackageLayout, body, calls) {
+				return false, nil
+			}
+			if _, captured := source.originalObjectSource(body.source); !captured {
+				return false, nil
+			}
+			if actualAssembly == nil {
+				actualAssembly = body.code
+			} else if reflect.DeepEqual(actualAssembly, body.code) {
+				originalMatched = true
+			} else {
+				return false, nil
+			}
+		}
+	}
+	if originalMatched && !sdkBody && arm64ScratchNumericCallLayout(samePackageLayout) &&
+		arm64ScratchSourceInputs(function, samePackageLayout, calls, true) {
+		results[symbol] = samePackageLayout
+	}
+	if originalMatched && sdkBody && source.actualABI0Wrapper(symbol, sdkLayout) {
+		// The independent SDK tuple contract accepts only a void result.
+		// Its real wrapper supplies inputs, never initialized result bytes.
+		results[symbol] = sdkLayout
+	}
+	return originalMatched, nil
+}
+
+func verifyARM64ScratchBindings(file *File, options Options) (map[string]*arm64ScratchBinding, error) {
+	bindings := make(map[string]*arm64ScratchBinding)
+	seen := make(map[*arm64ScratchBinding]bool)
+	for _, signature := range options.Sigs {
+		binding := signature.arm64NativeScratch
+		if binding == nil || seen[binding] {
+			continue
+		}
+		seen[binding] = true
+		if err := binding.source.Verify(binding.context); err != nil {
+			return nil, err
+		}
+		if file == nil || file.Arch != ArchARM64 || options.Goarch != "arm64" || options.TargetTriple != binding.target ||
+			options.ResolveSym == nil || !reflect.DeepEqual(arm64ScratchFileSnapshot(file), binding.file) {
+			return nil, arm64ScratchContext("consumer changed whole source or target")
+		}
+		for symbol, name := range binding.symbols {
+			actual, present := options.Sigs[name]
+			if !present || actual.arm64NativeScratch != binding || options.ResolveSym(symbol) != name ||
+				!bytes.Equal(arm64ScratchPublicSignature(actual), binding.sigs[name]) {
+				return nil, arm64ScratchContext("consumer changed a declaration or symbol")
+			}
+		}
+		for symbol, name := range binding.calls {
+			if options.ResolveSym(symbol) != name {
+				return nil, arm64ScratchContext("consumer changed a native call target")
+			}
+		}
+		for name, expected := range binding.calleeSigs {
+			actual, present := options.Sigs[name]
+			if !present || actual.arm64NativeScratch != binding || !bytes.Equal(arm64ScratchPublicSignature(actual), expected) {
+				return nil, arm64ScratchContext("consumer changed an actual native callee ABI0 tuple")
+			}
+		}
+		for symbol := range binding.closed {
+			bindings[symbol] = binding
+		}
+	}
+	return bindings, nil
+}
+
+func (binding *arm64ScratchBinding) hasCall(symbol string) bool {
+	if binding == nil || binding.source == nil {
+		return false
+	}
+	binding.source.mu.Lock()
+	defer binding.source.mu.Unlock()
+	return binding.source.ready && binding.closed[symbol] && binding.context.Err() == nil
+}
diff --git a/arm64_go_scratch_source.go b/arm64_go_scratch_source.go
new file mode 100644
index 000000000..62df126d9
--- /dev/null
+++ b/arm64_go_scratch_source.go
@@ -0,0 +1,879 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// GoARM64ScratchCaptureRequest describes actual stock-Go inputs. No field is
+// a claim that source, an object, a callee or a native frame has been verified.
+type GoARM64ScratchCaptureRequest struct {
+	GoBinary, Directory, AssemblyFile, Target string
+	Environment                               []string
+}
+
+// GoARM64ScratchSource is a live, nonserializable native-source observation.
+// Its only potential permission is that an entire actual callee closure does
+// not observe incoming Go assembler R27 scratch. Independently actual bodyless
+// declarations and wrapper byte transport supply the ordinary call tuple; no
+// memory, stack, caller-save or register-entry permission is supplied here.
+type GoARM64ScratchSource struct {
+	mu               sync.Mutex
+	ready            bool
+	request          GoARM64ScratchCaptureRequest
+	settings         map[string]string
+	inputs           map[string][32]byte
+	generatedPaths   map[string]string
+	bytes            int64
+	owned            string
+	ownedInfo        os.FileInfo
+	selection        []byte
+	packages         map[string]arm64ScratchPackage
+	actual           GoPackage
+	file             *File
+	native           map[string][]arm64ScratchNativeBody
+	ordinal          int
+	functions        map[string]Func
+	loaded           map[string]bool
+	typed            map[string]GoPackage
+	closed           map[string]FuncSig
+	assembly         map[string]bool
+	abis             map[string]string
+	filePrefix       string
+	builtinVersions  map[string]string
+	compilingRuntime bool
+}
+
+type arm64ScratchPackage struct {
+	Dir, ImportPath, Name, Export, ForTest                                         string
+	Standard, Goroot                                                               bool
+	GoFiles, CompiledGoFiles, SFiles, HFiles, Imports                              []string
+	CgoFiles, CFiles, CXXFiles, MFiles, FFiles, SwigFiles, SwigCXXFiles, SysoFiles []string
+	ImportMap                                                                      map[string]string
+	Module                                                                         *struct {
+		Path, Version, Dir, GoMod, GoVersion string
+		Main                                 bool
+		Replace                              json.RawMessage
+	}
+	Error      json.RawMessage
+	DepsErrors []json.RawMessage
+}
+
+type arm64ScratchNativeBody struct {
+	source string
+	code   []uint32
+	calls  []string
+	relocs []arm64ScratchNativeRelocation
+}
+
+type arm64ScratchNativeRelocation struct {
+	at, width    int
+	kind, target string
+	addend       int64
+}
+
+func arm64ScratchContext(format string, args ...any) error {
+	return fmt.Errorf("%w: ARM64 actual native scratch closure: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func (source *GoARM64ScratchSource) run(ctx context.Context, args ...string) ([]byte, error) {
+	if err := source.verifyGeneratedPaths(); err != nil {
+		return nil, err
+	}
+	output, err := goasmcmd.Run(ctx, source.request.Directory, source.request.Environment, source.request.GoBinary, args...)
+	return output, errors.Join(err, source.verifyGeneratedPaths())
+}
+
+func (source *GoARM64ScratchSource) read(name string) ([]byte, error) {
+	data, err := goAMD64FrameRead(name)
+	if err != nil {
+		return nil, err
+	}
+	digest := sha256.Sum256(data)
+	if old, exists := source.inputs[name]; exists {
+		if old != digest {
+			return nil, arm64ScratchContext("input changed during capture: %s", filepath.Base(name))
+		}
+	} else {
+		if len(source.inputs) >= 8192 || int64(len(data)) > 256<<20-source.bytes {
+			return nil, arm64ScratchContext("shared source/tool/archive input budget exceeded")
+		}
+		source.bytes += int64(len(data))
+		source.inputs[name] = digest
+	}
+	return data, nil
+}
+
+func CaptureGoARM64ScratchSource(ctx context.Context, pkg GoPackage, request GoARM64ScratchCaptureRequest) (_ *GoARM64ScratchSource, result error) {
+	if ctx == nil || ctx.Err() != nil || pkg.Types == nil || pkg.Types.Path() != pkg.Path ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || filepath.Ext(request.AssemblyFile) != ".s" {
+		return nil, arm64ScratchContext("requires a live context and actual absolute source/tool inputs")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, arm64ScratchContext("capture context is unbounded")
+	}
+	goos, goarch, valid := strings.Cut(request.Target, "/")
+	if !valid || goarch != "arm64" || goos != "linux" && goos != "darwin" && goos != "windows" {
+		return nil, arm64ScratchContext("target is outside the ordinary ARM64 object domain")
+	}
+	var err error
+	request.Directory, err = sourcepath.Resolve(request.Directory)
+	if err != nil {
+		return nil, err
+	}
+	request.Environment = append([]string(nil), request.Environment...)
+	source := &GoARM64ScratchSource{request: request, settings: make(map[string]string),
+		inputs: make(map[string][32]byte), generatedPaths: make(map[string]string),
+		packages: make(map[string]arm64ScratchPackage), native: make(map[string][]arm64ScratchNativeBody),
+		functions: make(map[string]Func), loaded: make(map[string]bool), typed: make(map[string]GoPackage),
+		closed: make(map[string]FuncSig), assembly: make(map[string]bool), abis: make(map[string]string)}
+	for _, item := range request.Environment {
+		key, value, valid := strings.Cut(item, "=")
+		if !valid || key == "" {
+			return nil, arm64ScratchContext("malformed actual environment")
+		}
+		source.settings[key] = value
+	}
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": goarch, "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOFLAGS": "", "GOEXPERIMENT": ""} {
+		if source.settings[key] != value {
+			return nil, arm64ScratchContext("actual %s is outside the ordinary source role", key)
+		}
+	}
+	if driver := source.settings["GOPACKAGESDRIVER"]; driver != "" && driver != "off" {
+		return nil, arm64ScratchContext("custom package driver requires an independent source role")
+	}
+	if _, err := source.read(request.GoBinary); err != nil {
+		return nil, err
+	}
+	observed, err := source.run(ctx, "env", "-json", "GOROOT", "GOTOOLDIR", "GOCACHE", "GOVERSION", "GOOS", "GOARCH", "CGO_ENABLED", "GOFLAGS", "GOEXPERIMENT")
+	if err != nil {
+		return nil, err
+	}
+	var settings map[string]string
+	if err := json.Unmarshal(observed, &settings); err != nil {
+		return nil, err
+	}
+	for key, value := range settings {
+		if supplied, exists := source.settings[key]; exists && supplied != value {
+			return nil, arm64ScratchContext("actual driver changed %s", key)
+		}
+		source.settings[key] = value
+	}
+	if settings["CGO_ENABLED"] != "0" {
+		return nil, arm64ScratchContext("actual CGO role needs an independent native closure")
+	}
+	root, err := sourcepath.Resolve(settings["GOROOT"])
+	if err != nil || !filepath.IsAbs(root) || !goAssemblyPathWithinRoot(root, request.GoBinary) {
+		return nil, arm64ScratchContext("actual Go binary and SDK differ")
+	}
+	source.settings["GOROOT"] = root
+	version, err := source.read(filepath.Join(root, "VERSION"))
+	if err != nil || strings.Split(string(version), "\n")[0] != settings["GOVERSION"] {
+		return nil, arm64ScratchContext("actual SDK version differs")
+	}
+	for _, tool := range []string{"asm", "compile", "objdump", "pack"} {
+		name, err := source.run(ctx, "tool", "-n", tool)
+		if err != nil {
+			return nil, err
+		}
+		if err := source.readObservedTool(tool, strings.TrimSpace(string(name))); err != nil {
+			return nil, err
+		}
+	}
+	// Backend source is an input identity, not a version-based permission.
+	for _, directory := range []string{"cmd/internal/obj/arm64", "cmd/internal/goobj", "cmd/internal/objabi", "cmd/internal/archive", "cmd/internal/objfile", "cmd/internal/src", "cmd/asm/internal/flags", "cmd/compile/internal/ssagen", "cmd/compile/internal/abi"} {
+		entries, err := os.ReadDir(filepath.Join(root, "src", directory))
+		if err != nil {
+			return nil, err
+		}
+		for _, entry := range entries {
+			if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
+				if _, err := source.read(filepath.Join(root, "src", directory, entry.Name())); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+	if err := source.captureObjectSourceMetadata(root); err != nil {
+		return nil, err
+	}
+	source.selection, err = source.run(ctx, "list", "-deps", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil {
+		return nil, err
+	}
+	decoder := json.NewDecoder(bytes.NewReader(source.selection))
+	for decoder.More() {
+		var selected arm64ScratchPackage
+		if err := decoder.Decode(&selected); err != nil {
+			return nil, err
+		}
+		if selected.ImportPath == "" || len(source.packages) >= 256 || selected.ForTest != "" ||
+			len(selected.Error) != 0 || len(selected.DepsErrors) != 0 {
+			return nil, arm64ScratchContext("unknown or nonordinary actual package selection")
+		}
+		if _, duplicate := source.packages[selected.ImportPath]; duplicate {
+			return nil, arm64ScratchContext("duplicate actual package identity")
+		}
+		source.packages[selected.ImportPath] = selected
+	}
+	selected, present := source.packages[pkg.Path]
+	if !present || selected.Dir != request.Directory || selected.Module == nil || !selected.Module.Main ||
+		len(selected.Module.Replace) != 0 || len(selected.CgoFiles) != 0 || len(selected.SysoFiles) != 0 ||
+		!reflect.DeepEqual(selected.GoFiles, selected.CompiledGoFiles) || selected.Export == "" {
+		return nil, arm64ScratchContext("capture requires the unchanged ordinary main-package selection")
+	}
+	if _, err := source.read(selected.Module.GoMod); err != nil {
+		return nil, err
+	}
+	if _, err := os.Lstat(filepath.Join(selected.Dir, "go.sum")); err == nil {
+		if _, err := source.read(filepath.Join(selected.Dir, "go.sum")); err != nil {
+			return nil, err
+		}
+	} else if !os.IsNotExist(err) {
+		return nil, err
+	}
+	if err := source.typecheck(ctx, pkg, selected); err != nil {
+		return nil, err
+	}
+	temporary := source.settings["TMPDIR"]
+	if !filepath.IsAbs(temporary) {
+		return nil, arm64ScratchContext("actual owned temporary directory must be absolute")
+	}
+	source.owned, err = os.MkdirTemp(temporary, "plan9asm-arm64-native-scratch-")
+	if err != nil {
+		return nil, err
+	}
+	source.ownedInfo, err = os.Lstat(source.owned)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	// Request TMPDIR may be an alias. Bind only this newly created factory
+	// directory to its physical path; original/tool inputs remain strict.
+	canonicalOwned, err := sourcepath.Resolve(source.owned)
+	if err != nil {
+		return nil, err
+	}
+	info, err := os.Lstat(canonicalOwned)
+	if err != nil || !info.IsDir() || !os.SameFile(info, source.ownedInfo) {
+		return nil, arm64ScratchContext("created object directory identity changed: %v", err)
+	}
+	source.owned = canonicalOwned
+	if err := source.captureAssembly(ctx, selected); err != nil {
+		return nil, err
+	}
+	// Finish every transitive native/source/declaration observation before this
+	// token becomes visible. Bind and all consumers only read the sealed maps.
+	for _, function := range source.file.Funcs {
+		for _, instruction := range function.Instrs {
+			if (instruction.Op != "CALL" && instruction.Op != "BL") || len(instruction.Args) != 1 || instruction.Args[0].Kind != OpSym {
+				continue
+			}
+			symbol := strings.TrimSuffix(instruction.Args[0].Sym, "(SB)")
+			if strings.Contains(symbol, "<") {
+				continue
+			}
+			canonical := strings.ReplaceAll(symbol, "·", ".")
+			if strings.HasPrefix(canonical, ".") {
+				canonical = source.actual.Path + canonical
+			}
+			closed, err := source.closedNativeCallee(ctx, canonical, make(map[string]bool), 0)
+			if err != nil {
+				return nil, err
+			}
+			if !closed {
+				continue
+			}
+			layout, err := source.actualCalleeSignature(ctx, canonical, canonical)
+			if err != nil {
+				return nil, err
+			}
+			if source.abis[canonical] == "ABIInternal" && !source.actualABI0Wrapper(canonical, layout) {
+				return nil, arm64ScratchContext("actual SDK ABI0 wrapper does not preserve its declared tuple")
+			}
+			source.closed[canonical] = layout
+		}
+	}
+	source.ready = true
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func (source *GoARM64ScratchSource) typecheck(_ context.Context, supplied GoPackage, selected arm64ScratchPackage) error {
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range selected.GoFiles {
+		if filepath.Base(name) != name {
+			return arm64ScratchContext("nonlocal selected Go filename")
+		}
+		filename := filepath.Join(selected.Dir, name)
+		data, err := source.read(filename)
+		if err != nil {
+			return err
+		}
+		file, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			return err
+		}
+		syntax = append(syntax, file)
+	}
+	lookup := func(path string) (io.ReadCloser, error) {
+		if mapped := selected.ImportMap[path]; mapped != "" {
+			path = mapped
+		}
+		pkg, present := source.packages[path]
+		if !present || pkg.Export == "" {
+			return nil, arm64ScratchContext("missing actual imported export for %s", path)
+		}
+		data, err := source.readObservedExport(pkg)
+		if err != nil {
+			return nil, err
+		}
+		return io.NopCloser(bytes.NewReader(data)), nil
+	}
+	config := types.Config{Importer: importer.ForCompiler(fset, "gc", lookup), Sizes: types.SizesFor("gc", "arm64")}
+	if selected.Module != nil && selected.Module.GoVersion != "" {
+		config.GoVersion = "go" + selected.Module.GoVersion
+	}
+	pkg, err := config.Check(selected.ImportPath, fset, syntax, nil)
+	if err != nil {
+		return arm64ScratchContext("actual selected source failed its independent typecheck: %v", err)
+	}
+	if supplied.Types != nil {
+		for _, name := range pkg.Scope().Names() {
+			actual, ok := pkg.Scope().Lookup(name).(*types.Func)
+			if !ok {
+				continue
+			}
+			claimed, ok := supplied.Types.Scope().Lookup(name).(*types.Func)
+			if !ok || types.TypeString(actual.Type(), nil) != types.TypeString(claimed.Type(), nil) {
+				return arm64ScratchContext("actual declaration differs from loaded type identity")
+			}
+		}
+	}
+	actual := GoPackage{Path: pkg.Path(), Types: pkg, Syntax: syntax}
+	source.typed[pkg.Path()] = actual
+	if supplied.Types != nil {
+		source.actual = actual
+	}
+	return nil
+}
+
+func (source *GoARM64ScratchSource) preprocess(pkg arm64ScratchPackage, name string) (string, error) {
+	filename := filepath.Join(pkg.Dir, name)
+	data, err := source.read(filename)
+	if err != nil {
+		return "", err
+	}
+	// Match the ordinary profile consumer's token-based CPP frontend. Original
+	// files and native objects remain independently bound below; canonical
+	// serialization does not relax the exact selected File or its Raw fields.
+	options := AssemblyPreprocessOptions{
+		FileName: filename, Defines: GoAssemblerDefinesWithEnv(source.settings["GOOS"], "arm64", source.settings),
+		ReadInclude: func(parent, include string) (string, []byte, error) {
+			if filepath.Base(include) != include || include == "go_asm.h" {
+				return "", nil, arm64ScratchContext("generated or redirected include requires its own producer")
+			}
+			name := filepath.Join(pkg.Dir, include)
+			if _, err := os.Lstat(name); os.IsNotExist(err) {
+				name = filepath.Join(source.settings["GOROOT"], "pkg", "include", include)
+			}
+			value, err := source.read(name)
+			return name, value, err
+		},
+	}
+	return PreprocessAssemblySource(string(data), options)
+}
+
+func (source *GoARM64ScratchSource) captureAssembly(ctx context.Context, pkg arm64ScratchPackage) error {
+	present := false
+	for _, name := range pkg.SFiles {
+		present = present || name == source.request.AssemblyFile
+	}
+	if !present {
+		return arm64ScratchContext("original assembly is not selected")
+	}
+	expanded, err := source.preprocess(pkg, source.request.AssemblyFile)
+	if err != nil {
+		return err
+	}
+	expanded = string(ExpandGoAssemblySource(source.actual, []byte(expanded), "arm64"))
+	source.file, err = Parse(ArchARM64, expanded)
+	if err != nil {
+		return err
+	}
+	// Capture every selected assembly member before a Keep/chunk operation.
+	for _, name := range pkg.SFiles {
+		if _, err := source.read(filepath.Join(pkg.Dir, name)); err != nil {
+			return err
+		}
+	}
+	if err := source.captureOriginalAssembly(ctx, pkg, source.request.AssemblyFile); err != nil {
+		return err
+	}
+	return source.captureNativePackage(ctx, pkg)
+}
+
+func (source *GoARM64ScratchSource) captureOriginalAssembly(ctx context.Context, pkg arm64ScratchPackage, name string) error {
+	if filepath.Base(name) != name || filepath.Ext(name) != ".s" {
+		return arm64ScratchContext("unknown selected assembly filename")
+	}
+	filename := filepath.Join(pkg.Dir, name)
+	if source.assembly[filename] {
+		return nil
+	}
+	expanded, err := source.preprocess(pkg, name)
+	if err != nil {
+		return err
+	}
+	file, err := Parse(ArchARM64, expanded)
+	if err != nil {
+		return err
+	}
+	for _, function := range file.Funcs {
+		symbol := strings.ReplaceAll(function.Sym, "·", ".")
+		if strings.HasPrefix(symbol, ".") {
+			symbol = pkg.ImportPath + symbol
+		}
+		symbol = goStripABISuffix(symbol)
+		if _, duplicate := source.functions[symbol]; duplicate {
+			return arm64ScratchContext("duplicate original assembly symbol")
+		}
+		source.functions[symbol] = function
+	}
+	object := filepath.Join(source.owned, fmt.Sprintf("original-%d.o", source.ordinal))
+	source.ordinal++
+	args := []string{"tool", "asm", "-S", "-p", pkg.ImportPath, "-I", pkg.Dir, "-I", filepath.Join(source.settings["GOROOT"], "pkg", "include"), "-o", object}
+	if pkg.Standard && pkg.Goroot && source.compilingRuntime {
+		args = append(args, "-compiling-runtime")
+	}
+	for _, define := range GoAssemblerDefinesWithEnv(source.settings["GOOS"], "arm64", source.settings) {
+		args = append(args, "-D", define)
+	}
+	args = append(args, filename)
+	symabis := filepath.Join(source.owned, fmt.Sprintf("symabis-%d", source.ordinal))
+	argsABI := append([]string(nil), args...)
+	for i := range argsABI {
+		if argsABI[i] == "-S" {
+			argsABI[i] = "-gensymabis"
+		}
+		if argsABI[i] == object {
+			argsABI[i] = symabis
+		}
+	}
+	if _, err := source.run(ctx, argsABI...); err != nil {
+		return err
+	}
+	definitions, err := source.read(symabis)
+	if err != nil {
+		return err
+	}
+	for _, line := range strings.Split(string(definitions), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 {
+			continue
+		}
+		if len(fields) != 3 || fields[0] != "def" && fields[0] != "ref" || fields[2] != "ABI0" && fields[2] != "ABIInternal" {
+			return arm64ScratchContext("unknown actual assembler ABI role")
+		}
+		if fields[0] == "def" {
+			symbol := arm64ScratchLogicalNativeSymbol(pkg.ImportPath, fields[1])
+			// Stock asm's older symabis frontend leaves a same-package name
+			// as "".Name. Its compiler canonicalizes that exact prefix using
+			// the actual selected package. Bind the result to this captured
+			// source definition; this metadata supplies no ABI by itself.
+			if strings.HasPrefix(symbol, `"".`) {
+				symbol = pkg.ImportPath + symbol[2:]
+				if _, present := source.functions[symbol]; !present {
+					return arm64ScratchContext("local assembler ABI definition has no original source")
+				}
+			}
+			if source.abis[symbol] != "" {
+				return arm64ScratchContext("duplicate actual assembler ABI definition")
+			}
+			source.abis[symbol] = fields[2]
+		}
+	}
+	if _, err := source.run(ctx, args...); err != nil {
+		return err
+	}
+	if _, err := source.read(object); err != nil {
+		return err
+	}
+	output, err := source.run(ctx, "tool", "objdump", object)
+	if err != nil {
+		return err
+	}
+	bodies, err := arm64ScratchObjectBodies(output)
+	if err != nil {
+		return err
+	}
+	for symbol, body := range bodies {
+		symbol = arm64ScratchLogicalNativeSymbol(pkg.ImportPath, symbol)
+		source.native[symbol] = append(source.native[symbol], body)
+	}
+	source.assembly[filename] = true
+	return nil
+}
+
+// Go archives retain ABI0 assembly and compiler-generated ABI wrappers as
+// distinct members with the same displayed symbol. Inspect ALL members, not
+// objdump's default first matching entry. All same-name bodies must be safe.
+func (source *GoARM64ScratchSource) captureNativePackage(ctx context.Context, pkg arm64ScratchPackage) error {
+	if len(pkg.CgoFiles)+len(pkg.CFiles)+len(pkg.CXXFiles)+len(pkg.MFiles)+len(pkg.FFiles)+len(pkg.SwigFiles)+len(pkg.SwigCXXFiles)+len(pkg.SysoFiles) != 0 {
+		return arm64ScratchContext("native foreign/object roles are not selected assembly")
+	}
+	archive, err := source.readObservedExport(pkg)
+	if err != nil {
+		return err
+	}
+	members, err := arm64ScratchArchiveMembers(archive)
+	if err != nil {
+		return err
+	}
+	var names []string
+	for symbol := range source.functions {
+		if strings.HasPrefix(symbol, pkg.ImportPath+".") && !source.loaded[symbol] {
+			native := gosym.PackagePrefix(pkg.ImportPath) + strings.TrimPrefix(symbol, pkg.ImportPath)
+			names = append(names, regexp.QuoteMeta(native))
+		}
+	}
+	if len(names) == 0 {
+		return arm64ScratchContext("no actual assembly body for native package")
+	}
+	pattern := "^(" + strings.Join(names, "|") + ")$"
+	for _, member := range members {
+		if member.name == "__.PKGDEF" {
+			continue
+		}
+		if !bytes.HasPrefix(member.data, []byte("go object "+strings.ReplaceAll(source.request.Target, "/", " ")+" ")) {
+			return arm64ScratchContext("archive member is not the actual target Go object")
+		}
+		filename := filepath.Join(source.owned, fmt.Sprintf("native-%d.o", source.ordinal))
+		source.ordinal++
+		// Existing files are never replaced, including members from a second package.
+		file, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+		if err != nil {
+			return err
+		}
+		_, writeErr := file.Write(member.data)
+		if err := errors.Join(writeErr, file.Close()); err != nil {
+			return err
+		}
+		if _, err := source.read(filename); err != nil {
+			return err
+		}
+		output, err := source.run(ctx, "tool", "objdump", "-s", pattern, filename)
+		if err != nil {
+			return err
+		}
+		bodies, err := arm64ScratchObjectBodies(output)
+		if err != nil {
+			return err
+		}
+		for name, body := range bodies {
+			name = arm64ScratchLogicalNativeSymbol(pkg.ImportPath, name)
+			source.native[name] = append(source.native[name], body)
+		}
+	}
+	for symbol := range source.functions {
+		if strings.HasPrefix(symbol, pkg.ImportPath+".") {
+			source.loaded[symbol] = true
+		}
+	}
+	return nil
+}
+
+type arm64ScratchArchiveMember struct {
+	name string
+	data []byte
+}
+
+func arm64ScratchArchiveMembers(data []byte) ([]arm64ScratchArchiveMember, error) {
+	if !bytes.HasPrefix(data, []byte("!<arch>\n")) {
+		return nil, arm64ScratchContext("actual export is not a Go archive")
+	}
+	var result []arm64ScratchArchiveMember
+	names := make(map[string]bool)
+	for offset := 8; offset < len(data); {
+		if len(result) >= 256 || len(data)-offset < 60 || string(data[offset+58:offset+60]) != "`\n" {
+			return nil, arm64ScratchContext("incomplete or over-bound archive header")
+		}
+		header := data[offset : offset+60]
+		name := strings.TrimSpace(string(header[:16]))
+		size, err := strconv.ParseUint(strings.TrimSpace(string(header[48:58])), 10, 32)
+		offset += 60
+		if err != nil || size == 0 || size > uint64(len(data)-offset) || filepath.Base(name) != name || names[name] {
+			return nil, arm64ScratchContext("unknown, duplicate or truncated archive member")
+		}
+		names[name] = true
+		result = append(result, arm64ScratchArchiveMember{name, data[offset : offset+int(size)]})
+		offset += int(size)
+		if offset%2 != 0 {
+			if offset == len(data) || data[offset] != 0 {
+				return nil, arm64ScratchContext("missing archive padding")
+			}
+			offset++
+		}
+	}
+	return result, nil
+}
+
+var arm64ScratchRelocation = regexp.MustCompile(`^\[0:([0-9]+)\](R_[A-Z0-9_]+):([^+\s]+)(?:\+(-?[0-9]+))?$`)
+
+func arm64ScratchObjectBodies(output []byte) (map[string]arm64ScratchNativeBody, error) {
+	result := make(map[string]arm64ScratchNativeBody)
+	name := ""
+	var next uint64
+	for _, line := range strings.Split(string(output), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 {
+			continue
+		}
+		if fields[0] == "TEXT" {
+			if len(fields) != 3 || !strings.HasSuffix(fields[1], "(SB)") {
+				return nil, arm64ScratchContext("unknown native object header")
+			}
+			name = strings.TrimSuffix(fields[1], "(SB)")
+			if _, duplicate := result[name]; duplicate {
+				return nil, arm64ScratchContext("duplicate object body")
+			}
+			result[name] = arm64ScratchNativeBody{source: fields[2]}
+			next = 0
+			continue
+		}
+		if name == "" || len(fields) < 4 || len(fields[2]) != 8 {
+			return nil, arm64ScratchContext("unknown native object row")
+		}
+		pc, err := strconv.ParseUint(strings.TrimPrefix(fields[1], "0x"), 16, 64)
+		word, wordErr := strconv.ParseUint(fields[2], 16, 32)
+		body := result[name]
+		if err != nil || wordErr != nil || len(body.code) != 0 && pc != next {
+			return nil, arm64ScratchContext("native bytes have a gap or overlap")
+		}
+		next = pc + 4
+		body.code = append(body.code, uint32(word))
+		for _, field := range fields[4:] {
+			if strings.Contains(field, "R_") {
+				match := arm64ScratchRelocation.FindStringSubmatch(field)
+				if match == nil {
+					body.relocs = append(body.relocs, arm64ScratchNativeRelocation{at: len(body.code) - 1, kind: "unknown"})
+				} else {
+					width, err := strconv.Atoi(match[1])
+					if err != nil {
+						return nil, arm64ScratchContext("native relocation width overflow")
+					}
+					var addend int64
+					if match[4] != "" {
+						addend, err = strconv.ParseInt(match[4], 10, 64)
+					}
+					if err != nil {
+						return nil, arm64ScratchContext("native relocation width/addend overflow")
+					}
+					body.relocs = append(body.relocs, arm64ScratchNativeRelocation{len(body.code) - 1, width, match[2], match[3], addend})
+					if match[2] == "R_CALLARM64" {
+						body.calls = append(body.calls, match[3])
+					}
+				}
+			}
+		}
+		result[name] = body
+	}
+	return result, nil
+}
+
+// Only these two stock-Go cache observations are transient after a fresh
+// export. Retain every other field, including unknown future fields, the full
+// record ordering and the actual raw observation in source.selection. Module,
+// dependency export, BuildID and complete selected-file identities are not
+// projected to the smaller package struct used for parsing declarations.
+func arm64ScratchSelectionIdentity(observation []byte) ([]byte, error) {
+	decoder := json.NewDecoder(bytes.NewReader(observation))
+	var records []json.RawMessage
+	for {
+		var record map[string]json.RawMessage
+		if err := decoder.Decode(&record); err != nil {
+			if err == io.EOF {
+				break
+			}
+			return nil, err
+		}
+		if record == nil || len(records) >= 256 {
+			return nil, arm64ScratchContext("missing or over-bound source selection record")
+		}
+		delete(record, "Stale")
+		delete(record, "StaleReason")
+		canonical, err := json.Marshal(record)
+		if err != nil {
+			return nil, err
+		}
+		records = append(records, canonical)
+	}
+	if len(records) == 0 {
+		return nil, arm64ScratchContext("empty source selection")
+	}
+	return json.Marshal(records)
+}
+
+// This first wrapper transport domain is deliberately bounded: up to eight
+// complete pointer/integer words and no results. The actual assembler's
+// symabis definition selects ABIInternal; an actual compiler archive member
+// must then implement the opposite ABI0 entry. Merely seeing <autogenerated>
+// or a self relocation cannot establish the incoming stack tuple.
+func (source *GoARM64ScratchSource) actualABI0Wrapper(symbol string, signature FuncSig) bool {
+	if signature.Ret != Void || len(signature.Args) == 0 || len(signature.Args) > 8 ||
+		len(signature.Frame.Results) != 0 || len(signature.Frame.Params) != len(signature.Args) ||
+		len(signature.ArgRegs) != 0 || signature.ARM64GoRegisterABI != nil || signature.ARM64ClosureABI != nil {
+		return false
+	}
+	for i, argument := range signature.Args {
+		slot := signature.Frame.Params[i]
+		if argument != I64 && argument != Ptr || slot.Type != argument || slot.Index != i || slot.Offset != int64(i)*8 {
+			return false
+		}
+	}
+	wrappers := 0
+	for _, body := range source.native[symbol] {
+		if !source.originalObjectGenerated(body.source) {
+			continue
+		}
+		wrappers++
+		code := body.code
+		for len(code) != 0 && code[len(code)-1] == 0 {
+			code = code[:len(code)-1]
+		}
+		if len(code) != len(signature.Args)+7 || len(body.calls) != 1 || source.originalObjectCallTarget(body.calls[0]) != symbol ||
+			code[0]&^uint32(0x1ff<<12) != 0xf8000ffe {
+			return false
+		}
+		// STR x30,[sp,#-autosize]! encodes the physical frame, not the
+		// declaration's logical FP area. Reconstruct the sign, then verify
+		// every actual load is from incoming SP+8+typed parameter offset.
+		autosize := -int64(int32(code[0]<<11) >> 23)
+		if autosize < 16 || autosize > 240 || autosize%16 != 0 ||
+			code[1] != 0xf81f83fd || code[2] != 0xd10023fd {
+			return false
+		}
+		for i, slot := range signature.Frame.Params {
+			offset := autosize + 8 + slot.Offset
+			if offset < 0 || offset%8 != 0 || offset/8 >= 4096 ||
+				code[3+i] != 0xf94003e0|uint32(offset/8)<<10|uint32(i) {
+				return false
+			}
+		}
+		i := len(signature.Args) + 3
+		if code[i] != 0x94000000 || !arm64ScratchGeneratedRestore(code[i+1:i+3], autosize) || code[i+3] != 0xd65f03c0 {
+			return false
+		}
+	}
+	return wrappers == 1
+}
+
+// Stock obj7's two registered small-frame epilogues: separate BP/LR loads,
+// or the older paired BP/LR load followed by the exact SP restoration. This
+// checks physical bytes, not a SDK version or a guessed source frame.
+func arm64ScratchGeneratedRestore(code []uint32, autosize int64) bool {
+	if len(code) != 2 || autosize < 16 || autosize > 240 || autosize%16 != 0 {
+		return false
+	}
+	return code[0] == 0xf85f83fd && code[1] == 0xf84007fe|uint32(autosize)<<12 ||
+		code[0] == 0xa97ffbfd && code[1] == 0x910003ff|uint32(autosize)<<10
+}
+
+func (source *GoARM64ScratchSource) Verify(ctx context.Context) (result error) {
+	if source == nil {
+		return arm64ScratchContext("nil capture")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	defer func() {
+		if result != nil {
+			source.ready = false
+		}
+	}()
+	if !source.ready || ctx == nil || ctx.Err() != nil {
+		return arm64ScratchContext("capture is closed or context expired")
+	}
+	info, err := os.Lstat(source.owned)
+	if err != nil || !info.IsDir() || !os.SameFile(info, source.ownedInfo) {
+		return arm64ScratchContext("owned object directory changed")
+	}
+	if err := source.verifyInputBytes(); err != nil {
+		return err
+	}
+	selection, err := source.run(ctx, "list", "-deps", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil {
+		return arm64ScratchContext("actual source/export selection changed: %v", err)
+	}
+	actual, actualErr := arm64ScratchSelectionIdentity(selection)
+	expected, expectedErr := arm64ScratchSelectionIdentity(source.selection)
+	if actualErr != nil || expectedErr != nil || !bytes.Equal(actual, expected) {
+		return arm64ScratchContext("actual source/export selection changed")
+	}
+	// The actual selection command is inside, not after, this byte guard.
+	// A tool/source/object replacement during that command must revoke the
+	// observation even when its stdout claims the same selected identities.
+	return source.verifyInputBytes()
+}
+
+func (source *GoARM64ScratchSource) verifyInputBytes() error {
+	if err := source.verifyGeneratedPaths(); err != nil {
+		return err
+	}
+	for filename, digest := range source.inputs {
+		data, err := goAMD64FrameRead(filename)
+		if err != nil || sha256.Sum256(data) != digest {
+			return arm64ScratchContext("source/tool/export/object input changed: %s", filepath.Base(filename))
+		}
+	}
+	return nil
+}
+
+func (source *GoARM64ScratchSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	source.ready = false
+	if source.owned == "" {
+		return nil
+	}
+	info, err := os.Lstat(source.owned)
+	if err != nil || !info.IsDir() || !os.SameFile(info, source.ownedInfo) {
+		return arm64ScratchContext("refusing cleanup of replaced owned directory")
+	}
+	err = os.RemoveAll(source.owned)
+	if err == nil {
+		source.owned = ""
+	}
+	return err
+}
diff --git a/arm64_gp_data_inputs.go b/arm64_gp_data_inputs.go
new file mode 100644
index 000000000..a1cbd746a
--- /dev/null
+++ b/arm64_gp_data_inputs.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64GPDataForm struct {
+	inputs      []Operand
+	destination Operand
+	implicit    []Reg
+	scratch     *Operand
+}
+
+// The Go ADD, AND/ANDS, NEG, MVN, LSL, SXTB and BFI rows have a
+// full GP result, even for a W result (which clears its upper half). Only
+// the shorthand and insert rows read the old Rd. This grammar is shared by
+// lowering, continuation values and both may-frame address proofs; an opcode
+// name or a raw GP-write mask alone is never a known overwrite.
+func parseARM64GPDataForm(op Op, ins Instr) (form arm64GPDataForm, handled bool, err error) {
+	if move, handled, err := parseARM64NamedMoveWide(op, ins); handled && move.op != "MOVK" {
+		if err != nil {
+			return form, true, err
+		}
+		// MOVN/Z do not consume the old destination, unlike MOVK's existing
+		// read-modify-write contract. W also overwrites the complete X alias.
+		form.destination = ins.Args[1]
+		return form, true, nil
+	}
+	if bitfield, handled, err := parseARM64NamedBitfield(op, ins); handled {
+		if err != nil {
+			return form, true, err
+		}
+		form.inputs, form.destination = ins.Args[1:2], ins.Args[3]
+		if bitfield.op == "BFM" {
+			form.inputs = []Operand{ins.Args[1], ins.Args[3]}
+		}
+		return form, true, nil
+	}
+	if immediate, handled, err := parseARM64GPImmediateForm(op, ins); handled {
+		if err != nil {
+			return form, true, err
+		}
+		form.inputs = []Operand{ins.Args[0], immediate.left}
+		form.destination = immediate.destination
+		if immediate.scratch {
+			constant := Operand{Kind: OpImm, Imm: int64(immediate.value)}
+			form.scratch = &constant
+			if immediate.left.Reg == "R27" {
+				form.inputs[1] = constant
+			}
+			if immediate.destination.Reg != "R27" {
+				form.implicit = []Reg{"R27"}
+			}
+		}
+		return form, true, nil
+	}
+	family := ""
+	word := strings.HasSuffix(string(op), "W")
+	switch op {
+	case "ADD", "ADDS", "SUB", "SUBS", "ADDW", "ADDSW", "SUBW", "SUBSW":
+		family = "add"
+	case "AND", "ANDW", "EOR", "EORW", "ORR", "ORRW", "BIC", "BICW", "EON", "EONW", "ORN", "ORNW", "ANDS", "ANDSW", "BICS", "BICSW":
+		family = "logical"
+	case "LSL", "LSLW", "LSR", "LSRW", "ASR", "ASRW", "ROR", "RORW":
+		family = "shift"
+	case "NEG", "NEGW", "NEGS", "NEGSW":
+		family = "negate"
+	case "MVN", "MVNW":
+		family = "invert"
+	case "BFI", "BFIW", "BFXIL", "BFXILW", "SBFIZ", "SBFIZW", "SBFX", "SBFXW", "UBFIZ", "UBFIZW", "UBFX", "UBFXW":
+		family = "bitfield"
+	default:
+		if divide, handled, err := parseARM64DivideRemainderForm(op, ins); handled {
+			if err != nil {
+				return form, true, err
+			}
+			form.inputs = []Operand{divide.divisor, divide.dividend}
+			form.destination = divide.destination
+			if divide.remainder && divide.destination.Reg != "R27" {
+				form.implicit = []Reg{"R27"}
+			}
+			return form, true, nil
+		} else if _, ok := arm64ScalarExtendSpecs[op]; ok {
+			family = "extend"
+		} else if inputs, destination, valid := arm64ScalarMultiplyInputs(op, ins); valid {
+			return arm64GPDataForm{inputs: inputs, destination: destination}, true, nil
+		} else {
+			return form, false, nil
+		}
+	}
+	invalid := func() (arm64GPDataForm, bool, error) {
+		return form, true, fmt.Errorf("arm64 %s operands are outside its typed Go GP data rows: %q", op, ins.Raw)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) == 0 {
+		return invalid()
+	}
+	form.destination = ins.Args[len(ins.Args)-1]
+	destinationGP := arm64ScalarMultiplyRegister(form.destination)
+	destinationSP := form.destination.Kind == OpReg && arm64StackReg(form.destination.Reg)
+	if !destinationGP && !destinationSP {
+		return invalid()
+	}
+	bits := int64(64)
+	if word {
+		bits = 32
+	}
+	switch family {
+	case "add", "logical", "shift":
+		if len(ins.Args) != 2 && len(ins.Args) != 3 {
+			return invalid()
+		}
+		source, left := ins.Args[0], form.destination
+		if len(ins.Args) == 3 {
+			left = ins.Args[1]
+		}
+		leftGP := arm64ScalarMultiplyRegister(left)
+		leftSP := left.Kind == OpReg && arm64StackReg(left.Reg)
+		valid := false
+		switch family {
+		case "add":
+			valid = (leftGP || leftSP) && arm64AddFlagsSourceValid(source, word)
+			if (leftSP || destinationSP) && source.Kind == OpRegShift {
+				valid = valid && source.ShiftOp == ShiftLeft && source.ShiftAmount <= 4
+			}
+		case "logical":
+			valid = leftGP && arm64BitClearSourceValid(source, word)
+			if destinationSP {
+				flags := op == "ANDS" || op == "ANDSW" || op == "BICS" || op == "BICSW"
+				valid = valid && !flags && source.Kind == OpImm && len(ins.Args) == 3
+			}
+		case "shift":
+			valid = leftGP && destinationGP && (arm64ScalarMultiplyRegister(source) ||
+				source.Kind == OpImm && source.ImmRaw == "" && !source.ImmIsFloat && source.Imm >= 0 && source.Imm < bits)
+		}
+		if !valid || source.Kind == OpImm && source.ImmIsFloat {
+			return invalid()
+		}
+		form.inputs = []Operand{source, left}
+	case "negate", "invert":
+		if !destinationGP || len(ins.Args) != 2 && (family != "negate" || len(ins.Args) != 1) {
+			return invalid()
+		}
+		source := ins.Args[0]
+		valid := validateARM64NegateSource(source, word) == nil
+		if family == "invert" {
+			valid = source.Kind != OpImm && arm64BitClearSourceValid(source, word)
+		}
+		if !valid {
+			return invalid()
+		}
+		form.inputs = []Operand{source}
+	case "extend":
+		if !destinationGP || len(ins.Args) != 2 || !arm64ScalarMultiplyRegister(ins.Args[0]) {
+			return invalid()
+		}
+		form.inputs = ins.Args[:1]
+	case "bitfield":
+		if !destinationGP || len(ins.Args) != 4 || !arm64ScalarMultiplyRegister(ins.Args[1]) {
+			return invalid()
+		}
+		lsb, width := ins.Args[0], ins.Args[2]
+		if lsb.Kind != OpImm || width.Kind != OpImm || lsb.ImmRaw != "" || width.ImmRaw != "" ||
+			lsb.ImmIsFloat || width.ImmIsFloat || lsb.Imm < 0 || lsb.Imm >= bits || width.Imm <= 0 || width.Imm > bits-lsb.Imm {
+			return invalid()
+		}
+		form.inputs = ins.Args[1:2]
+		if strings.HasPrefix(string(op), "BFI") || strings.HasPrefix(string(op), "BFXIL") {
+			form.inputs = []Operand{ins.Args[1], form.destination}
+		}
+	}
+	return form, true, nil
+}
+
+func arm64GPDataInputRegisters(form arm64GPDataForm) []Reg {
+	registers := make([]Reg, 0, len(form.inputs))
+	for _, input := range form.inputs {
+		if input.Kind == OpReg || input.Kind == OpRegShift || input.Kind == OpRegExtend {
+			registers = append(registers, input.Reg)
+		}
+	}
+	return registers
+}
+
+func arm64GPDataOutputRegisters(form arm64GPDataForm) []Reg {
+	var outputs []Reg
+	if form.destination.Kind == OpReg {
+		outputs = append(outputs, form.destination.Reg)
+	}
+	return append(outputs, form.implicit...)
+}
+
+func (state *arm64ControlState) transferGPData(ins Instr) bool {
+	form, handled, err := parseARM64GPDataForm(arm64ControlOp(ins), ins)
+	if !handled || err != nil {
+		return false
+	}
+	if form.scratch != nil {
+		state.regs["R27"] = arm64ControlExternal()
+	}
+	value := arm64ControlExternal()
+	for _, reg := range arm64GPDataInputRegisters(form) {
+		value = arm64ControlUnion(value, arm64ControlLabels(arm64ControlRead(state.regs, arm64ControlBase(reg))))
+	}
+	if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+		value = arm64ControlWithToken(value, "code-derived:")
+	}
+	for _, reg := range arm64GPDataOutputRegisters(form) {
+		if form.scratch != nil && reg == "R27" && form.destination.Reg != "R27" {
+			continue
+		}
+		state.write(Operand{Kind: OpReg, Reg: reg}, value, false)
+	}
+	return true
+}
diff --git a/arm64_gp_data_inputs_test.go b/arm64_gp_data_inputs_test.go
new file mode 100644
index 000000000..9578e8f45
--- /dev/null
+++ b/arm64_gp_data_inputs_test.go
@@ -0,0 +1,360 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// All rows of the ADD, AND/ANDS, NEG, MVN, LSL, SXTB and BFI
+// families, including their registered W/flags aliases. Rd is R9 here so
+// stock Go can validate the spelling without special raw g-register words.
+func arm64GPDataForms() []string {
+	var forms []string
+	for _, op := range []string{"ADD", "ADDS", "SUB", "SUBS", "ADDW", "ADDSW", "SUBW", "SUBSW"} {
+		for _, source := range []string{"R4", "$17", "R4<<1", "R4.UXTB<<1"} {
+			forms = append(forms, op+" "+source+",R5,R9", op+" "+source+",R9")
+		}
+	}
+	for _, op := range []string{"AND", "ANDW", "EOR", "EORW", "ORR", "ORRW", "BIC", "BICW", "EON", "EONW", "ORN", "ORNW", "ANDS", "ANDSW", "BICS", "BICSW"} {
+		for _, source := range []string{"R4", "$17", "R4<<1"} {
+			forms = append(forms, op+" "+source+",R5,R9", op+" "+source+",R9")
+		}
+	}
+	for _, op := range []string{"LSL", "LSLW", "LSR", "LSRW", "ASR", "ASRW", "ROR", "RORW"} {
+		for _, source := range []string{"$1", "R4"} {
+			forms = append(forms, op+" "+source+",R5,R9", op+" "+source+",R9")
+		}
+	}
+	for _, op := range []string{"NEG", "NEGW", "NEGS", "NEGSW", "MVN", "MVNW"} {
+		forms = append(forms, op+" R4,R9", op+" R4<<1,R9")
+	}
+	for _, op := range []string{"SXTB", "SXTBW", "SXTH", "SXTHW", "SXTW", "UXTB", "UXTBW", "UXTH", "UXTHW", "UXTW"} {
+		forms = append(forms, op+" R4,R9")
+	}
+	for _, op := range []string{"BFI", "BFIW", "BFXIL", "BFXILW", "SBFIZ", "SBFIZW", "SBFX", "SBFXW", "UBFIZ", "UBFIZW", "UBFX", "UBFXW"} {
+		forms = append(forms, op+" $1,R4,$7,R9")
+	}
+	return forms
+}
+
+func arm64GPDataReadsDestination(text string) bool {
+	parts := strings.SplitN(text, " ", 2)
+	count := len(strings.Split(parts[1], ","))
+	op := parts[0]
+	if strings.HasPrefix(op, "BFI") || strings.HasPrefix(op, "BFXIL") {
+		return true
+	}
+	if strings.HasPrefix(op, "NEG") {
+		return count == 1
+	}
+	if strings.HasPrefix(op, "MVN") || strings.HasPrefix(op, "SXT") || strings.HasPrefix(op, "UXT") || count == 4 {
+		return false
+	}
+	return count == 2
+}
+
+func TestARM64GPDataTrueInputsAndFullOverwrite(t *testing.T) {
+	for _, text := range arm64GPDataForms() {
+		t.Run(text, func(t *testing.T) {
+			source := "TEXT direction(SB),$0-0\n" + text + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			mayFrame := arm64PrivateFrameAddress{offset: -16, exact: true}
+			state := &arm64RawPrivateFrameState{
+				regs:   arm64PrivateFrameAddresses{"R9": mayFrame},
+				spills: make(map[int64]arm64PrivateFrameAddress),
+			}
+			readOnly := arm64PrivateFrameAddresses{"R9": mayFrame}
+			reads := arm64GPDataReadsDestination(text)
+			affine := strings.HasPrefix(text, "ADD $") || strings.HasPrefix(text, "SUB $")
+			if valid := state.transfer(ins, ins, 64); valid != (!reads || affine) {
+				t.Fatalf("raw proof destination input=%v, transfer=%v", reads, valid)
+			}
+			if valid := readOnly.transfer(ins, 64); valid != (!reads || affine) {
+				t.Fatalf("read-only proof destination input=%v, transfer=%v", reads, valid)
+			}
+			if !reads {
+				if _, present := state.regs["R9"]; present {
+					t.Fatal("known full overwrite retained a dead may-frame value")
+				}
+				if _, present := readOnly["R9"]; present {
+					t.Fatal("read-only proof retained overwritten may-frame value")
+				}
+			}
+			control := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R9": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+				memory: make(map[string]arm64ControlValue),
+			}
+			control.transfer(ins, ins.Op, false, nil)
+			value := arm64ControlRead(control.regs, "R9")
+			if arm64ControlCount(arm64ControlLabels(value)) != 0 != reads {
+				t.Fatalf("continuation input direction mismatch: %v", value)
+			}
+		})
+	}
+}
+
+func TestARM64GPDataFrameInputAliasesStayClosed(t *testing.T) {
+	for _, text := range []string{
+		"ADD R9,R5,R9", "ADD R4,R9,R9", "ADD R9<<1,R5,R9",
+		"ADD R9.UXTB<<1,R5,R9", "LSL R9,R5,R9", "LSL $1,R9,R9",
+		"SXTB R9,R9", "UBFX $1,R9,$7,R9", "BFI $1,R4,$7,R9",
+		"BFXIL $1,R4,$7,R9", "NEG R9", "AND R4,R9",
+	} {
+		file, err := Parse(ArchARM64, "TEXT inputs(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64RawPrivateFrameState{
+			regs:   arm64PrivateFrameAddresses{"R9": {offset: -16, exact: true}},
+			spills: make(map[int64]arm64PrivateFrameAddress),
+		}
+		if state.transfer(file.Funcs[0].Instrs[1], file.Funcs[0].Instrs[1], 64) {
+			t.Fatalf("true frame input was treated as dead Rd: %s", text)
+		}
+	}
+}
+
+func TestARM64GPDataSavedGOverwriteWholeSource(t *testing.T) {
+	for _, text := range []string{"ADD R4,R5,R28", "LSL $1,R4,R28", "UXTB R4,R28", "UBFX $1,R4,$7,R28"} {
+		body := "WORD $0xa9bf4bfc\n" + text + "\nMOVD R28,(R1)\nWORD $0xa8c14bfc\n"
+		file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := arm64RawZeroFrameSig()
+		if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}}); err != nil {
+			t.Fatalf("saved/restored g scratch false input: %s: %v", text, err)
+		}
+		for _, bad := range []string{
+			strings.Replace(body, "WORD $0xa8c14bfc", "MOVD $0,R28", 1),
+			strings.Replace(body, text, "MOVD RSP,R4\n"+text, 1),
+		} {
+			file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, bad))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}}); err == nil {
+				t.Fatalf("fixed-g or actual frame input gained permission: %s", bad)
+			}
+		}
+	}
+}
+
+func TestARM64GPDataMultiplyUsesExistingCompleteGrammar(t *testing.T) {
+	for _, text := range arm64ControlMultiplyForms() {
+		text = strings.ReplaceAll(text, "R30", "R9")
+		file, err := Parse(ArchARM64, "TEXT multiply(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state := &arm64RawPrivateFrameState{
+			regs: arm64PrivateFrameAddresses{"R9": {}}, spills: make(map[int64]arm64PrivateFrameAddress),
+		}
+		readOnly := state.regs.clone()
+		reads := len(ins.Args) == 2
+		if state.transfer(ins, ins, 64) == reads || readOnly.transfer(ins, 64) == reads {
+			t.Fatalf("multiply operand grammar differed between proofs: %s", text)
+		}
+	}
+}
+
+func TestARM64GPDataCopyJoinEscapeAndSavedIdentityRemainClosed(t *testing.T) {
+	for _, body := range []string{
+		"MOVD RSP,R9\nMOVD R9,R10\nADD R4,R5,R9\nMOVD R10,(R1)\nMOVD $0,R10",
+		"MOVD RSP,R9\nCBZ R0,joined\nADD R4,R5,R9\njoined:\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD RSP,R9\nMOVD R9,R10\nUBFX $1,R4,$7,R9\nMOVD R10,holder(SB)\nMOVD $0,R10",
+		"MOVD RSP,R9\nBFI $1,R4,$7,R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"WORD $0xa9bf4bfc\nADD R4,R5,R28\nMOVB R4,(RSP)\nWORD $0xa8c14bfc",
+		"WORD $0xa9bf4bfc\nADD R4,R5,R28\nMOVD $0,R18\nADD $16,RSP",
+	} {
+		file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, body+"\nMOVD R4,(R1)\n"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := arm64RawZeroFrameSig()
+		if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}}); err == nil {
+			t.Fatalf("overwrite washed a copied/joined escape or caller identity: %s", body)
+		}
+	}
+	for _, body := range []string{
+		"MOVD RSP,R9\nADD R4,R5,R9\nMOVD R9,(R1)",
+		"MOVD RSP,R9\nCBZ R0,other\nADD R4,R5,R9\nB joined\nother:\nUXTB R4,R9\njoined:\nMOVD R9,(R1)",
+	} {
+		file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, body+"\n"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := arm64RawZeroFrameSig()
+		if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}}); err != nil {
+			t.Fatalf("all-path full overwrites did not close the may-frame scope: %s: %v", body, err)
+		}
+	}
+}
+
+func TestARM64GPDataCompleteGoFamiliesAndRows(t *testing.T) {
+	bytes, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(bytes)
+	fixtureNames := make(map[string]bool)
+	for _, text := range arm64GPDataForms() {
+		fixtureNames[strings.SplitN(text, " ", 2)[0]] = true
+	}
+	for _, family := range []struct {
+		name string
+		rows int
+	}{
+		{name: "AADD", rows: 24}, {name: "AAND", rows: 16},
+		{name: "AANDS", rows: 16}, {name: "ANEG", rows: 3},
+		{name: "AMVN", rows: 2}, {name: "ALSL", rows: 4},
+		{name: "ASXTB", rows: 1}, {name: "ABFI", rows: 1},
+	} {
+		rows := regexp.MustCompile(`(?m)^\s*\{`+family.name+`, C_[A-Z0-9]+, C_[A-Z0-9]+, C_[A-Z0-9]+, C_[A-Z0-9]+,`).FindAllString(source, -1)
+		if len(rows) != family.rows {
+			t.Fatalf("Go %s rows changed: expected %d, got %d", family.name, family.rows, len(rows))
+		}
+		start := strings.Index(source, "case "+family.name+":")
+		if start < 0 {
+			t.Fatalf("Go %s alias registration missing", family.name)
+		}
+		block := source[start+len("case "+family.name+":"):]
+		if end := strings.Index(block, "\n\t\tcase "); end >= 0 {
+			block = block[:end]
+		}
+		names := []string{strings.TrimPrefix(family.name, "A")}
+		for _, alias := range regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block, -1) {
+			names = append(names, alias[1])
+		}
+		for _, name := range names {
+			if !fixtureNames[name] {
+				t.Fatalf("Go %s alias has no actual-form fixture: %s", family.name, name)
+			}
+			delete(fixtureNames, name)
+		}
+	}
+	if len(fixtureNames) != 0 {
+		t.Fatalf("fixture opcodes lack source-table registration: %v", fixtureNames)
+	}
+	// The internal ANEG C_NONE row does not imply a public one-operand
+	// spelling: Go's frontend puts that operand in From, not To. Preserve
+	// this exact observed distinction instead of claiming a Go object passed.
+	for _, op := range []string{"NEG", "NEGW", "NEGS", "NEGSW"} {
+		requireARM64GoAssemblerResult(t, "TEXT internal(SB),$0-0\n"+op+" R9\nRET\n", false)
+	}
+}
+
+func TestARM64GPDataShiftExtendImmediateAndInvalidAxes(t *testing.T) {
+	for _, text := range []string{
+		"ADD $4096,R5,R9", "ADD $0x100001,R5,R9", "ADD $0x12345678,R5,R9",
+		"ADD $0x123456789abcdef,R5,R9", "ADD R4>>63,R5,R9", "ADDW R4->31,R5,R9",
+		"AND $0xff00ff00,R5,R9", "AND $0x123456789abcdef,R5,R9", "MVN R4@>63,R9",
+		"LSL $0,R5,R9", "LSL $63,R5,R9", "LSLW $31,R5,R9",
+		"UBFX $63,R4,$1,R9", "BFIW $31,R4,$1,R9",
+	} {
+		requireARM64GoAssemblerResult(t, "TEXT axes(SB),$0-0\n"+text+"\nRET\n", true)
+		file, err := Parse(ArchARM64, "TEXT axes(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := parseARM64GPDataForm(file.Funcs[0].Instrs[1].Op, file.Funcs[0].Instrs[1]); err != nil {
+			t.Fatalf("actual Go operand axis rejected: %s: %v", text, err)
+		}
+	}
+	for _, extension := range []string{"UXTB", "UXTH", "UXTW", "UXTX", "SXTB", "SXTH", "SXTW", "SXTX"} {
+		for _, amount := range []int{0, 4} {
+			text := fmt.Sprintf("ADD R4.%s<<%d,R5,R9", extension, amount)
+			requireARM64GoAssemblerResult(t, "TEXT extension(SB),$0-0\n"+text+"\nRET\n", true)
+		}
+	}
+	for _, text := range []string{
+		"ADD.P R4,R5,R9", "ADD R4@>1,R5,R9", "ADDW R4<<32,R5,R9",
+		"ADD R4.UXTW<<5,R5,R9", "ADD R4<<R5,R6,R9", "ADD F0,R5,R9",
+		"AND R4.UXTW,R5,R9", "AND R4,RSP,R9", "LSL $64,R5,R9",
+		"LSLW $32,R5,R9", "LSL (R4),R5,R9", "SXTB R4,(R9)",
+		"UBFX $63,R4,$2,R9", "UBFX $0,R4,$0,R9",
+		"UBFX $missing,R4,$1,R9", "ADD $1.5,R5,R9",
+	} {
+		requireARM64GoAssemblerResult(t, "TEXT invalid(SB),$0-0\n"+text+"\nRET\n", false)
+		file, err := Parse(ArchARM64, "TEXT invalid(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			continue
+		}
+		ins := file.Funcs[0].Instrs[1]
+		if _, handled, err := parseARM64GPDataForm(arm64ControlOp(ins), ins); !handled || err == nil {
+			t.Fatalf("invalid operand supplied an overwrite proof: %s: %v", text, err)
+		}
+	}
+	// Go's alias encoder accepts this W spelling, but its field crosses
+	// the W bank boundary. The existing lowerer rejects it; it must not
+	// become an address overwrite witness merely because asm accepts it.
+	file, err := Parse(ArchARM64, "TEXT crossBank(SB),$0-0\nBFIW $31,R4,$2,R9\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	requireARM64GoAssemblerResult(t, "TEXT crossBank(SB),$0-0\nBFIW $31,R4,$2,R9\nRET\n", true)
+	if _, _, err := parseARM64GPDataForm("BFIW", file.Funcs[0].Instrs[1]); err == nil {
+		t.Fatal("cross-bank bitfield gained an overwrite proof")
+	}
+	for _, text := range []string{"REV R4,R9", "CLZ R4,R9", "MOVK $1,R9", "WORD $0xffffffff"} {
+		file, err := Parse(ArchARM64, "TEXT unknown(SB),$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := &arm64RawPrivateFrameState{
+			regs: arm64PrivateFrameAddresses{"R9": {}}, spills: make(map[int64]arm64PrivateFrameAddress),
+		}
+		if state.transfer(file.Funcs[0].Instrs[1], file.Funcs[0].Instrs[1], 64) {
+			t.Fatalf("unregistered effects washed may-frame destination: %s", text)
+		}
+	}
+}
+
+func arm64GPDataFamilyFixture(t *testing.T) (*File, map[string]FuncSig, string) {
+	t.Helper()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, form := range arm64GPDataForms() {
+		name := fmt.Sprintf("gpDataCaller%d", index)
+		body := "WORD $0xa9bf4bfc\nMOVD (R0),R4\nMOVD 8(R0),R5\n"
+		if arm64GPDataReadsDestination(form) {
+			body += "MOVD 16(R0),g\n"
+		}
+		body += strings.ReplaceAll(form, "R9", "g") + "\nMOVD g,(R1)\nWORD $0xa8c14bfc\n"
+		source.WriteString(strings.Replace(arm64RawZeroFrameFixture(516, false, body), "rawZero", name, 1))
+		sig := arm64RawZeroFrameSig()
+		sig.Name = name
+		sigs[name] = sig
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, sigs, source.String()
+}
+
+func TestARM64GPDataAllFormsFiveTargetObjects(t *testing.T) {
+	file, sigs, _ := arm64GPDataFamilyFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "gp-data.ll", "gp-data.o", ir)
+	}
+}
diff --git a/arm64_gp_data_runtime_test.go b/arm64_gp_data_runtime_test.go
new file mode 100644
index 000000000..9222d5ae1
--- /dev/null
+++ b/arm64_gp_data_runtime_test.go
@@ -0,0 +1,355 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+type arm64GPDataOracle struct {
+	goValue, cValue string
+	goLeft, cLeft   string
+	goRight, cRight string
+	flagKind, bits  int
+}
+
+// These mathematical expressions are independent of the translator's typed
+// input selector. Both languages receive original input bytes, not IR outputs.
+func arm64GPDataExpected(text string) arm64GPDataOracle {
+	parts := strings.SplitN(text, " ", 2)
+	op, args := parts[0], strings.Split(parts[1], ",")
+	word := strings.HasSuffix(op, "W") && op != "SXTW" && op != "UXTW"
+	if word {
+		op = strings.TrimSuffix(op, "W")
+	}
+	bits := 64
+	if word {
+		bits = 32
+	}
+	a, b := "a", "b"
+	if arm64GPDataReadsDestination(text) && len(args) == 2 {
+		b = "c"
+	}
+	switch args[0] {
+	case "$17":
+		a = "literal17"
+	case "R4<<1":
+		a = "(a << 1)"
+	case "R4.UXTB<<1":
+		a = "((a & 255) << 1)"
+	}
+	goValue, cValue, left, right, flagKind := "", "", b, a, 0
+	switch op {
+	case "ADD", "ADDS":
+		goValue = "(" + b + " + " + a + ")"
+	case "SUB", "SUBS":
+		goValue = "(" + b + " - " + a + ")"
+	case "AND", "ANDS":
+		goValue = "(" + b + " & " + a + ")"
+	case "ORR":
+		goValue = "(" + b + " | " + a + ")"
+	case "EOR":
+		goValue = "(" + b + " ^ " + a + ")"
+	case "BIC", "BICS":
+		goValue, cValue = "("+b+" & ^"+a+")", "("+b+" & ~"+a+")"
+	case "ORN":
+		goValue, cValue = "("+b+" | ^"+a+")", "("+b+" | ~"+a+")"
+	case "EON":
+		goValue, cValue = "("+b+" ^ ^"+a+")", "("+b+" ^ ~"+a+")"
+	case "NEG", "NEGS":
+		goValue, left = "(0 - "+a+")", "0"
+	case "MVN":
+		goValue, cValue = "(^"+a+")", "(~"+a+")"
+	case "LSL", "LSR", "ASR", "ROR":
+		amount := fmt.Sprintf("(a & %d)", bits-1)
+		if args[0] == "$1" {
+			amount = "1"
+		}
+		base := b
+		if word {
+			base = "(b & 0xffffffff)"
+			if b == "c" {
+				base = "(c & 0xffffffff)"
+			}
+		}
+		switch op {
+		case "LSL":
+			goValue = "(" + base + " << " + amount + ")"
+		case "LSR":
+			goValue = "(" + base + " >> " + amount + ")"
+		case "ASR":
+			goValue, cValue = "uint64(int64("+base+") >> "+amount+")", "(uint64_t)((int64_t)"+base+" >> "+amount+")"
+			if word {
+				goValue, cValue = "uint64(int32("+base+") >> "+amount+")", "(uint64_t)((int32_t)"+base+" >> "+amount+")"
+			}
+		case "ROR":
+			goValue = fmt.Sprintf("rotate(%s, %s, %d)", base, amount, bits)
+		}
+	case "SXTB", "SXTH", "SXTW", "UXTB", "UXTH", "UXTW":
+		width := 32
+		if strings.HasSuffix(op, "B") {
+			width = 8
+		} else if strings.HasSuffix(op, "H") {
+			width = 16
+		}
+		goValue = fmt.Sprintf("(a & %d)", (uint64(1)<<uint(width))-1)
+		if strings.HasPrefix(op, "S") {
+			goValue = fmt.Sprintf("signedField(a, %d)", width)
+		}
+	case "BFI":
+		goValue, cValue = "((c & ^uint64(254)) | ((a & 127) << 1))", "((c & ~UINT64_C(254)) | ((a & 127) << 1))"
+	case "BFXIL":
+		goValue, cValue = "((c & ^uint64(127)) | ((a >> 1) & 127))", "((c & ~UINT64_C(127)) | ((a >> 1) & 127))"
+	case "UBFIZ":
+		goValue = "((a & 127) << 1)"
+	case "SBFIZ":
+		goValue = "(signedField(a, 7) << 1)"
+	case "UBFX":
+		goValue = "((a >> 1) & 127)"
+	case "SBFX":
+		goValue = "signedField(a >> 1, 7)"
+	default:
+		panic("unobserved GP oracle spelling: " + text)
+	}
+	if cValue == "" {
+		cValue = goValue
+	}
+	if op == "ADDS" {
+		flagKind = 1
+	} else if op == "SUBS" || op == "NEGS" {
+		flagKind = 2
+	} else if op == "ANDS" || op == "BICS" {
+		flagKind = 3
+	}
+	if word {
+		goValue = "uint64(uint32(" + goValue + "))"
+		cValue = "(uint64_t)(uint32_t)(" + cValue + ")"
+	}
+	if flagKind == 0 {
+		left, right, bits, flagKind = "a", "b", 64, 2 // Original preceding CMP.
+	}
+	return arm64GPDataOracle{
+		goValue: goValue, cValue: cValue, goLeft: left, cLeft: left,
+		goRight: right, cRight: right, flagKind: flagKind, bits: bits,
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GPDataInputs(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	file, sigs, source := arm64GPDataFamilyFixture(t)
+	var goDecls, goChecks, cDecls, cChecks strings.Builder
+	for index, form := range arm64GPDataForms() {
+		name := fmt.Sprintf("gpDataCaller%d", index)
+		oracle := arm64GPDataExpected(form)
+		fmt.Fprintf(&goDecls, "func %s(*byte, *byte)\n", name)
+		fmt.Fprintf(&goDecls, "func expected%d(a, b, c uint64) (uint64, uint64) {\n result := %s\n return result, flags(%s, %s, result, %d, %d)\n}\n", index,
+			oracle.goValue, oracle.goLeft, oracle.goRight, oracle.flagKind, oracle.bits)
+		fmt.Fprintf(&cDecls, "extern void %s(const unsigned char *, unsigned char *);\n", name)
+		fmt.Fprintf(&cDecls, "static uint64_t expected%d(uint64_t a, uint64_t b, uint64_t c, uint64_t *nzcv) {\n uint64_t result = %s;\n *nzcv = flags(%s, %s, result, %d, %d);\n return result;\n}\n", index,
+			oracle.cValue, oracle.cLeft, oracle.cRight, oracle.flagKind, oracle.bits)
+		fmt.Fprintf(&goChecks, "check(%s, expected%d)\n", name, index)
+		fmt.Fprintf(&cChecks, "if (check(%s, expected%d)) { return 1; }\n", name, index)
+	}
+	// Insert the same baseline CMP and post-instruction flag read into all
+	// original functions. MOVD/ORR/LSL do not change flags. g is restored before
+	// returning; actual Go independently reads its caller's g on either side.
+	for _, form := range arm64GPDataForms() {
+		original := strings.ReplaceAll(form, "R9", "g")
+		replacement := "CMP R5,R4\n" + original + "\nMOVD g,(R1)\n" +
+			"CSET VS,R7\nCSET CS,R8\nLSL $1,R8\nORR R8,R7\n" +
+			"CSET EQ,R8\nLSL $2,R8\nORR R8,R7\nCSET MI,R8\nLSL $3,R8\nORR R8,R7\nMOVD R7,8(R1)"
+		source = strings.Replace(source, original+"\nMOVD g,(R1)", replacement, 1)
+	}
+	var err error
+	file, err = Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	requireARM64GoAssemblerResult(t, source, true)
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":  "module gpdatacalleroracle\n\ngo 1.20\n",
+		"main.go": arm64GPDataOracleGo + goDecls.String() + "func main() {\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT gpDataCaller", "TEXT ·gpDataCaller") +
+			"\nTEXT ·readGoG(SB),516,$0-8\nMOVD g,R0\nMOVD R0,ret+0(FP)\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go GP data/g/LR/NZCV/canary oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "gp_data_caller", triple, ir,
+		arm64GPDataOracleC+cDecls.String()+"int main(void) {\n"+cChecks.String()+"return 0;\n}\n", runner)
+	t.Logf("actual Go + LLVM22/independent Go/C: %d forms x 128 patterns x 5 unaligned offsets; numeric/NZCV/full canaries, actual fixed-g/caller return", len(file.Funcs))
+}
+
+const arm64GPDataOracleGo = `package main
+import "encoding/binary"
+
+const literal17 uint64 = 17
+
+func readGoG() uintptr
+
+func signedField(x uint64, width uint) uint64 {
+ return uint64(int64(x << (64-width)) >> (64-width))
+}
+
+func rotate(x, amount uint64, width uint) uint64 {
+ mask := ^uint64(0) >> (64-width)
+ x &= mask
+ amount &= uint64(width-1)
+ return ((x >> amount) | (x << ((0-amount)&uint64(width-1)))) & mask
+}
+
+func flags(left, right, result uint64, kind int, width uint) uint64 {
+ mask := ^uint64(0) >> (64-width)
+ left, right = left&mask, right&mask
+ sign := uint64(1) << (width-1)
+ r := (left-right)&mask
+ if kind == 1 { r = (left+right)&mask }
+ if kind == 3 { r = result&mask }
+ var value uint64
+ if r&sign != 0 { value |= 8 }
+ if r == 0 { value |= 4 }
+ if kind == 2 && left >= right { value |= 2 }
+ if kind == 1 && r < left { value |= 2 }
+ if kind == 2 && ((left^right)&(left^r)&sign) != 0 { value |= 1 }
+ if kind == 1 && ((^(left^right))&(left^r)&sign) != 0 { value |= 1 }
+ return value
+}
+
+func check(call func(*byte,*byte), expected func(uint64,uint64,uint64)(uint64,uint64)) {
+ var input, output, want [96]byte
+ seed := uint64(0x0123456789abcdef)
+ for trial := 0; trial < 128; trial++ {
+  for _, off := range []int{0,1,3,7,17} {
+   for i := range input {
+    seed = seed*6364136223846793005+1
+    input[i] = byte(seed>>56)
+    output[i], want[i] = 0xa5, 0xa5
+   }
+   a := binary.LittleEndian.Uint64(input[off:])
+   b := binary.LittleEndian.Uint64(input[off+8:])
+   c := binary.LittleEndian.Uint64(input[off+16:])
+   if trial < 64 { a = uint64(1) << trial }
+   if trial == 64 { a, b = ^uint64(0), 1 }
+   if trial == 65 { a, b = 1<<63, 1 }
+   if trial == 66 { a, b = 0, 0 }
+   binary.LittleEndian.PutUint64(input[off:], a)
+   binary.LittleEndian.PutUint64(input[off+8:], b)
+   result, nzcv := expected(a,b,c)
+   binary.LittleEndian.PutUint64(want[off:], result)
+   binary.LittleEndian.PutUint64(want[off+8:], nzcv)
+   snapshot := input
+   before := readGoG()
+   call(&input[off], &output[off])
+   if before == 0 || before != readGoG() || input != snapshot || output != want {
+    panic("GP data/NZCV/canary/g/caller mismatch")
+   }
+  }
+ }
+}
+`
+
+const arm64GPDataOracleC = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+
+static const uint64_t literal17 = 17;
+
+static uint64_t signedField(uint64_t x, unsigned width) {
+ return (uint64_t)((int64_t)(x << (64-width)) >> (64-width));
+}
+
+static uint64_t rotate(uint64_t x, uint64_t amount, unsigned width) {
+ uint64_t mask = UINT64_MAX >> (64-width);
+ x &= mask;
+ amount &= width-1;
+ return ((x >> amount) | (x << ((0-amount)&(width-1)))) & mask;
+}
+
+static uint64_t flags(uint64_t left, uint64_t right, uint64_t result, int kind, unsigned width) {
+ uint64_t mask = UINT64_MAX >> (64-width);
+ left &= mask;
+ right &= mask;
+ uint64_t sign = UINT64_C(1) << (width-1);
+ uint64_t r = (left-right)&mask;
+ if (kind == 1) { r = (left+right)&mask; }
+ if (kind == 3) { r = result&mask; }
+ uint64_t value = 0;
+ if (r&sign) { value |= 8; }
+ if (!r) { value |= 4; }
+ if (kind == 2 && left >= right) { value |= 2; }
+ if (kind == 1 && r < left) { value |= 2; }
+ if (kind == 2 && ((left^right)&(left^r)&sign)) { value |= 1; }
+ if (kind == 1 && ((~(left^right))&(left^r)&sign)) { value |= 1; }
+ return value;
+}
+
+static uint64_t readG(void) {
+ uint64_t value;
+ __asm__ volatile("mov %0,x28" : "=r"(value));
+ return value;
+}
+
+static int check(void (*call)(const unsigned char *,unsigned char *),
+                 uint64_t (*expected)(uint64_t,uint64_t,uint64_t,uint64_t *)) {
+ unsigned char input[96], output[96], want[96], snapshot[96];
+ const unsigned offsets[] = {0,1,3,7,17};
+ uint64_t seed = UINT64_C(0x0123456789abcdef);
+ for (unsigned trial = 0; trial < 128; trial++) {
+  for (unsigned o = 0; o < 5; o++) {
+   unsigned off = offsets[o];
+   for (unsigned i = 0; i < 96; i++) {
+    seed = seed*UINT64_C(6364136223846793005)+1;
+    input[i] = (unsigned char)(seed>>56);
+    output[i] = want[i] = 0xa5;
+   }
+   uint64_t a, b, c;
+   memcpy(&a,input+off,8);
+   memcpy(&b,input+off+8,8);
+   memcpy(&c,input+off+16,8);
+   if (trial < 64) { a = UINT64_C(1) << trial; }
+   if (trial == 64) { a = UINT64_MAX; b = 1; }
+   if (trial == 65) { a = UINT64_C(1) << 63; b = 1; }
+   if (trial == 66) { a = b = 0; }
+   memcpy(input+off,&a,8);
+   memcpy(input+off+8,&b,8);
+   uint64_t nzcv, result = expected(a,b,c,&nzcv);
+   memcpy(want+off,&result,8);
+   memcpy(want+off+8,&nzcv,8);
+   memcpy(snapshot,input,96);
+   uint64_t before = readG();
+   call(input+off,output+off);
+   if (before != readG() || memcmp(input,snapshot,96) || memcmp(output,want,96)) {
+    fprintf(stderr,"GP data trial/offset %u/%u\n",trial,off);
+    return 1;
+   }
+  }
+ }
+ return 0;
+}
+`
diff --git a/arm64_gp_immediate.go b/arm64_gp_immediate.go
new file mode 100644
index 000000000..05b62a019
--- /dev/null
+++ b/arm64_gp_immediate.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64GPImmediateForm struct {
+	left, destination Operand
+	value             uint64
+	operation         string
+	word, flags       bool
+	compare, scratch  bool
+	trailingUDF       bool
+}
+
+// The ADD/AND/CMP/TST optabs select cases 2/48/53 or materialize the
+// immediate in R27 in cases 13/28/62. Register classes affect that choice:
+// a ZR CMP input and a non-flag logical ZR destination require the fallback.
+func parseARM64GPImmediateForm(op Op, ins Instr) (f arm64GPImmediateForm, handled bool, err error) {
+	if ins.arm64Encoded {
+		return f, false, nil
+	}
+	base := strings.TrimSuffix(string(op), "W")
+	switch base {
+	case "ADD", "ADDS", "SUB", "SUBS", "CMP", "CMN", "AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST":
+	default:
+		return f, false, nil
+	}
+	if len(ins.Args) == 0 || ins.Args[0].Kind != OpImm {
+		return f, false, nil
+	}
+	invalid := func() (arm64GPImmediateForm, bool, error) {
+		return f, true, fmt.Errorf("arm64 %s immediate is outside its Go GP encoder rows: %q", op, ins.Raw)
+	}
+	f.word = strings.HasSuffix(string(op), "W")
+	f.compare = base == "CMP" || base == "CMN" || base == "TST"
+	f.flags = f.compare || base == "ADDS" || base == "SUBS" || base == "ANDS" || base == "BICS"
+	if string(ins.Op) != string(op) || len(ins.Args) != 2 && (f.compare || len(ins.Args) != 3) ||
+		ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return invalid()
+	}
+	f.value = uint64(ins.Args[0].Imm)
+	if f.word {
+		f.value = uint64(uint32(f.value))
+	}
+	f.left = ins.Args[1]
+	if !f.compare {
+		f.destination = ins.Args[len(ins.Args)-1]
+		if f.destination.Kind != OpReg || !arm64AddressReg(f.destination.Reg) && f.destination.Reg != ZR {
+			return invalid()
+		}
+	}
+	if f.left.Kind != OpReg || !arm64AddressReg(f.left.Reg) && f.left.Reg != ZR {
+		return invalid()
+	}
+	add := base == "ADD" || base == "ADDS" || base == "SUB" || base == "SUBS" || base == "CMP" || base == "CMN"
+	bitmask := f.value
+	if f.word {
+		bitmask *= 0x100000001
+	}
+	logicalImmediate := arm64LogicalBitmaskImmediate(bitmask)
+	if add {
+		f.operation = "add"
+		if base == "SUB" || base == "SUBS" || base == "CMP" {
+			f.operation = "sub"
+		}
+		if !f.compare && (f.left.Reg == ZR || f.destination.Reg == ZR || f.flags && arm64StackReg(f.destination.Reg)) {
+			return invalid()
+		}
+		value := int64(f.value)
+		addImmediate := value >= 0 && (value <= 0xfff || value&0xfff == 0 && value>>12 <= 0xfff)
+		movImmediate := arm64GPImmediateMoveWide(f.value, f.word)
+		splitImmediate := value >= 0 && value <= 0xffffff && !movImmediate && !logicalImmediate
+		f.scratch = f.left.Reg == ZR || !addImmediate && !(splitImmediate && !f.flags)
+		// X case 13's MOV-wide expansion rejects all-zero/all-one values;
+		// W case 13 emits its two MOV words even for those values.
+		if f.compare && (f.left.Reg == ZR && !f.word && (f.value == 0 || f.value == ^uint64(0)) ||
+			arm64StackReg(f.left.Reg) && f.scratch && !movImmediate && !logicalImmediate) {
+			return invalid()
+		}
+		// The X CMP/CMN ZR fallback has a fixed three-word case-13
+		// width. A one-word MOV-wide materialization leaves its last word
+		// zero after the compare: that is a reachable UDF, not padding.
+		f.trailingUDF = f.compare && f.left.Reg == ZR && !f.word && movImmediate
+	} else {
+		f.operation = "and"
+		if base == "ORR" || base == "ORN" {
+			f.operation = "or"
+		} else if base == "EOR" || base == "EON" {
+			f.operation = "xor"
+		}
+		if arm64StackReg(f.left.Reg) || !f.compare && arm64StackReg(f.destination.Reg) &&
+			(f.flags || len(ins.Args) != 3 || !logicalImmediate) {
+			return invalid()
+		}
+		f.scratch = !logicalImmediate || !f.compare && !f.flags && f.destination.Reg == ZR
+		// C_ABCON (>12-bit shifted ADDCON and also a logical mask) is
+		// not compatible with MOVCON. A nonflag ZR destination therefore
+		// selects case 28's three-word fallback instead of case 62.
+		value := int64(f.value)
+		f.trailingUDF = !f.word && !f.compare && !f.flags && f.destination.Reg == ZR &&
+			logicalImmediate && value > 0xfff && value&0xfff == 0 && value>>12 <= 0xfff &&
+			arm64GPImmediateMoveWide(f.value, false)
+	}
+	if f.scratch && f.left.Reg == "R27" && (f.compare || len(ins.Args) == 3) {
+		return invalid() // Go diagnoses an explicit REGTMP source before encoding.
+	}
+	zeroFallback := f.compare && add && f.left.Reg == ZR || !f.compare && !f.flags && f.destination.Reg == ZR
+	if !f.word && zeroFallback && logicalImmediate && arm64GPImmediateLegacyMoves(f.value) > 2 {
+		// Go 1.20's fixed case-13/28 width can truncate the MOV sequence
+		// before the operation. Newer Go encoders use ORR-mask+MOVK. Source
+		// encoder identity is not part of the current public transport;
+		// neither library-build Go version nor opcode spelling supplies it.
+		return f, true, fmt.Errorf("%w: arm64 %s ZR fallback needs its original Go constant encoder", ErrProbeNeedsContext, op)
+	}
+	return f, true, nil
+}
+
+func arm64GPImmediateLegacyMoves(value uint64) int {
+	zero, ones := 0, 0
+	for shift := uint(0); shift < 64; shift += 16 {
+		switch uint16(value >> shift) {
+		case 0:
+			zero++
+		case 0xffff:
+			ones++
+		}
+	}
+	if ones > zero {
+		zero = ones
+	}
+	return 4 - zero
+}
+
+func arm64GPImmediateMoveWide(value uint64, word bool) bool {
+	inverted := ^value
+	if word {
+		inverted = uint64(uint32(inverted))
+	}
+	for shift := uint(0); shift < 64; shift += 16 {
+		mask := uint64(0xffff) << shift
+		if value&^mask == 0 || inverted&^mask == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *arm64Ctx) lowerARM64GPImmediate(op Op, ins Instr) (bool, bool, error) {
+	f, handled, err := parseARM64GPImmediateForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	if f.scratch {
+		if err := c.storeReg("R27", c.imm64(int64(f.value))); err != nil {
+			return true, false, err
+		}
+	}
+	var left string
+	typeName, right := "i64", c.imm64(int64(f.value))
+	if f.word {
+		left, err = c.eval32(f.left)
+		typeName, right = "i32", fmt.Sprint(uint32(f.value))
+	} else {
+		left, err = c.eval64(f.left, false)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	base := strings.TrimSuffix(string(op), "W")
+	if base == "BIC" || base == "BICS" || base == "ORN" || base == "EON" {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, typeName, right)
+		right = "%" + inverted
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, f.operation, typeName, left, right)
+	if f.flags {
+		if f.operation == "add" {
+			if f.word {
+				c.setFlagsAdd32(left, right, "%"+result)
+			} else {
+				c.setFlagsAdd(left, right, "%"+result)
+			}
+		} else if f.operation == "sub" {
+			if f.word {
+				c.setFlagsSub32(left, right, "%"+result)
+			} else {
+				c.setFlagsSub(left, right, "%"+result)
+			}
+		} else if f.word {
+			c.setFlagsLogic32("%" + result)
+		} else {
+			c.setFlagsLogic("%" + result)
+		}
+	}
+	if f.compare {
+		return c.finishARM64GPImmediate(f)
+	}
+	value := "%" + result
+	if f.word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, value)
+		value = "%" + wide
+	}
+	if err := c.storeReg(f.destination.Reg, value); err != nil {
+		return true, false, err
+	}
+	return c.finishARM64GPImmediate(f)
+}
+
+func (c *arm64Ctx) finishARM64GPImmediate(f arm64GPImmediateForm) (bool, bool, error) {
+	if f.trailingUDF {
+		c.emitARM64Exception("udf", 0)
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	}
+	return true, false, nil
+}
diff --git a/arm64_gp_immediate_encoding_test.go b/arm64_gp_immediate_encoding_test.go
new file mode 100644
index 000000000..14725108c
--- /dev/null
+++ b/arm64_gp_immediate_encoding_test.go
@@ -0,0 +1,341 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64ImmediateFaultCase struct {
+	text string
+	move uint32
+	op   uint32
+}
+
+func arm64ImmediateFaultCases() []arm64ImmediateFaultCase {
+	var cases []arm64ImmediateFaultCase
+	for _, tc := range []struct {
+		constant string
+		move     uint32
+	}{
+		{"1", 0xd280003b}, {"4096", 0xd282001b},
+		{"0x1234", 0xd282469b}, {"0xffff0000", 0xd2bffffb}, {"-4096", 0x9281fffb},
+	} {
+		cases = append(cases,
+			arm64ImmediateFaultCase{"CMP $" + tc.constant + ",ZR", tc.move, 0xeb1b03ff},
+			arm64ImmediateFaultCase{"CMN $" + tc.constant + ",ZR", tc.move, 0xab1b03ff})
+	}
+	for _, tc := range []struct {
+		op   string
+		word uint32
+	}{
+		{"AND", 0x8a1b001f}, {"ORR", 0xaa1b001f}, {"EOR", 0xca1b001f},
+		{"BIC", 0x8a3b001f}, {"ORN", 0xaa3b001f}, {"EON", 0xca3b001f},
+	} {
+		cases = append(cases, arm64ImmediateFaultCase{tc.op + " $4096,R0,ZR", 0xd282001b, tc.word})
+	}
+	return cases
+}
+
+func arm64ImmediateFaultSource() (source, declarations string, sigs map[string]FuncSig) {
+	var asm, goDecl strings.Builder
+	sigs = make(map[string]FuncSig)
+	for index, tc := range arm64ImmediateFaultCases() {
+		name := fmt.Sprintf("Fault%d", index)
+		fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, tc.text)
+		fmt.Fprintf(&goDecl, "func %s()\n", name)
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	return asm.String(), goDecl.String(), sigs
+}
+
+func arm64ImmediateOriginalGoBytes(t *testing.T, source, goos string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "original.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", filepath.Join(dir, "original.o"), path)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64")
+	listing, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("original Go %s object: %v\n%s", goos, err, listing)
+	}
+	var output []byte
+	for _, row := range regexp.MustCompile(`(?m)^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`).FindAllSubmatch(listing, -1) {
+		data, err := hex.DecodeString(strings.ReplaceAll(string(row[1]), " ", ""))
+		if err != nil {
+			t.Fatal(err)
+		}
+		output = append(output, data...)
+	}
+	return output
+}
+
+func TestARM64GPImmediateOriginalGoFaultExpansion(t *testing.T) {
+	// Fixed 12-byte Go rows really contain MOV, operation, UDF, followed
+	// by the independent source RET. Do not mistake their zero word for
+	// unreachable alignment or treat Go assembler acceptance as runtime P.
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, tc := range arm64ImmediateFaultCases() {
+			source := "TEXT fault(SB),4,$0-0\n" + tc.text + "\nRET\n"
+			var expected bytes.Buffer
+			for _, word := range []uint32{tc.move, tc.op, 0, 0xd65f03c0} {
+				if err := binary.Write(&expected, binary.LittleEndian, word); err != nil {
+					t.Fatal(err)
+				}
+			}
+			actual := arm64ImmediateOriginalGoBytes(t, source, goos)
+			if !bytes.Equal(actual, expected.Bytes()) {
+				t.Fatalf("%s %s original Go words: got %x want %x", goos, tc.text, actual, expected.Bytes())
+			}
+			ins := arm64ImmediateTestInstruction(t, tc.text)
+			form, handled, err := parseARM64GPImmediateForm(ins.Op, ins)
+			if !handled || err != nil || !form.trailingUDF {
+				t.Fatalf("exact Go tail-zero emission missing: %s: %+v %v", tc.text, form, err)
+			}
+		}
+	}
+}
+
+func arm64ImmediateFaultIRs(t *testing.T, target string) []string {
+	t.Helper()
+	source, declarations, sigs := arm64ImmediateFaultSource()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	pkg := mustGoPackage(t, "test/fault", "package fault\n"+declarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs, ResolveSym: resolve}
+	text, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	module, err := TranslateModuleInContext(ctx, file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer bound.Module.Dispose()
+	return []string{text, module.String(), bound.Module.String()}
+}
+
+func TestARM64GPImmediateFaultObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		for api, ir := range arm64ImmediateFaultIRs(t, target) {
+			if strings.Count(ir, `asm sideeffect "udf #0"`) != len(arm64ImmediateFaultCases()) ||
+				strings.Count(ir, "unreachable") < len(arm64ImmediateFaultCases()) {
+				t.Fatalf("%s API %d missing exact terminating UDF family", target, api)
+			}
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("immediate-fault-%d.ll", api), fmt.Sprintf("immediate-fault-%d.o", api), ir)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GPImmediateFault(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, declarations, _ := arm64ImmediateFaultSource()
+	var calls, cDeclarations, cPointers strings.Builder
+	for index := range arm64ImmediateFaultCases() {
+		fmt.Fprintf(&calls, "case \"%d\": Fault%d()\n", index, index)
+		fmt.Fprintf(&cDeclarations, "extern void Fault%d(void);\n", index)
+		fmt.Fprintf(&cPointers, "Fault%d,\n", index)
+	}
+	dir := t.TempDir()
+	goSource := "package main\nimport \"os\"\n" + declarations + "func main() { switch os.Args[1] {\n" + calls.String() + "} }\n"
+	for name, content := range map[string]string{"go.mod": "module example.com/immediate-fault\n\ngo 1.20\n", "main.go": goSource, "fault_arm64.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-go")
+	ctx, cancel := runtimeOracleStageContext(t)
+	build := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", executable, ".")
+	build.Dir = dir
+	build.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=arm64")
+	if len(runner) != 0 {
+		build.Env = append(build.Env, "GOOS=linux")
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, build)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go fault build: %v\n%s", err, output)
+	}
+	for index := range arm64ImmediateFaultCases() {
+		args := runtimeOracleGuestArguments(t, runner, executable, fmt.Sprint(index))
+		ctx, cancel = runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, args[0], args[1:]...)
+		command.Env = append(os.Environ(), "GOTRACEBACK=single")
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		exit, ok := err.(*exec.ExitError)
+		if !ok || exit.ExitCode() != 2 || !strings.Contains(string(output), "SIGILL: illegal instruction") {
+			t.Fatalf("original Go %s did not deliver SIGILL: %v\n%s", arm64ImmediateFaultCases()[index].text, err, output)
+		}
+	}
+	cSource := fmt.Sprintf(`#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+%s
+static void (*functions[])(void) = {%s};
+int main(void) {
+    struct rlimit no_core = {0,0};
+    if (setrlimit(RLIMIT_CORE,&no_core)) return 1;
+    for (unsigned i=0;i<sizeof(functions)/sizeof(functions[0]);i++) {
+        pid_t child=fork();
+        if (child<0) return 2;
+        if (!child) { functions[i](); _exit(90); }
+        int status;
+        if (waitpid(child,&status,0)!=child || !WIFSIGNALED(status) || WTERMSIG(status)!=SIGILL) return 3;
+    }
+    return 0;
+}
+`, cDeclarations.String(), cPointers.String())
+	for api, ir := range arm64ImmediateFaultIRs(t, target) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("immediate-fault-%d", api), target, ir, cSource, runner)
+	}
+}
+
+func TestARM64GPImmediateOriginalEncoderVariant(t *testing.T) {
+	primary, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This is an original-tool oracle, not a production encoder selector.
+	// Both source versions have the same fixed 12-byte fallback. Only the
+	// authenticated original Go primary source identifies its MOV expansion.
+	modern := strings.Contains(string(primary), "bits.RotateLeft64")
+	words := []uint32{0xd2801ffb, 0xf2a01ffb, 0xf2c01ffb, 0xd65f03c0}
+	scratch, flags := uint64(0x000000ff00ff00ff), 4
+	if modern {
+		words = []uint32{0xb2009ffb, 0xf2801ffb, 0xeb1b03ff, 0xd65f03c0}
+		scratch, flags = 0x00ff00ff00ff00ff, 1
+	}
+	var expected bytes.Buffer
+	for _, word := range words {
+		if err := binary.Write(&expected, binary.LittleEndian, word); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, goos := range []string{"linux", "darwin"} {
+		actual := arm64ImmediateOriginalGoBytes(t, "TEXT variant(SB),4,$0-0\nCMP $0x00ff00ff00ff00ff,ZR\nRET\n", goos)
+		if !bytes.Equal(actual, expected.Bytes()) {
+			t.Fatalf("%s original encoder variant: got %x want %x", goos, actual, expected.Bytes())
+		}
+	}
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	source := `TEXT ·DivideRem(SB),4,$0-16
+MOVD input+0(FP),R10
+MOVD output+8(FP),R11
+MOVD 0(R10),R0
+CMP $5,R0
+CMP $0x00ff00ff00ff00ff,ZR
+MOVD R27,0(R11)
+CSET MI,R2
+CSET HS,R3
+LSL $2,R3
+ORR R3,R2
+MOVD R2,8(R11)
+CMP $5,R0
+AND $0x00ff00ff00ff00ff,R0,ZR
+MOVD R27,16(R11)
+CSET MI,R2
+CSET HS,R3
+LSL $2,R3
+ORR R3,R2
+MOVD R2,24(R11)
+RET
+`
+	goSource := fmt.Sprintf(`package main
+import "fmt"
+func DivideRem(input *[4]uint64, output *[4]uint64)
+func main() {
+    input := [4]uint64{17,0,0,0}
+    initial := input
+    output := struct { left uint64; values [4]uint64; right uint64 }{left:0x1234,right:0x5678}
+    DivideRem(&input,&output.values)
+    want := [4]uint64{%d,%d,%d,4}
+    if input != initial || output.left != 0x1234 || output.right != 0x5678 || output.values != want {
+        panic(fmt.Sprintf("original encoder state/canary got %%x want %%x",output.values,want))
+    }
+}
+`, scratch, flags, scratch)
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	t.Logf("actual original Go modern=%v: exact fallback bytes, R27=%#x, CMP flags=%d; LLVM source without encoder identity remains Context", modern, scratch, flags)
+}
+
+func TestARM64GPImmediateCompleteGoOptabs(t *testing.T) {
+	primary, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(primary)
+	names := make(map[string]bool)
+	for _, tc := range arm64ImmediateOracleCases() {
+		names[tc.op] = true
+	}
+	for _, family := range []struct {
+		name string
+		rows int
+	}{
+		{"AADD", 14}, {"ACMP", 6}, {"AAND", 12}, {"AANDS", 12}, {"ATST", 6},
+	} {
+		pattern := `(?m)^\s*\{` + family.name + `, C_(?:ADDCON2?|MOVCON[23]?|BITCON|MBCON|VCON),[^\n]+`
+		rows := regexp.MustCompile(pattern).FindAllString(source, -1)
+		if len(rows) != family.rows {
+			t.Fatalf("Go %s immediate rows changed: got %d want %d", family.name, len(rows), family.rows)
+		}
+		start := strings.Index(source, "case "+family.name+":")
+		if start < 0 {
+			t.Fatalf("Go alias registration missing: %s", family.name)
+		}
+		block := source[start+len("case "+family.name+":"):]
+		if end := strings.Index(block, "\n\t\tcase "); end >= 0 {
+			block = block[:end]
+		}
+		aliases := []string{strings.TrimPrefix(family.name, "A")}
+		for _, match := range regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block, -1) {
+			aliases = append(aliases, match[1])
+		}
+		for _, name := range aliases {
+			if !names[name] {
+				t.Fatalf("original Go alias lacks the actual numeric family: %s", name)
+			}
+			delete(names, name)
+		}
+	}
+	if len(names) != 0 {
+		t.Fatalf("numeric family names lack original Go registrations: %v", names)
+	}
+	for _, witness := range []string{"case 13:", "case 28:", "case 62:", "case 48:", "case 53:", "cannot use REGTMP as source", "C_ADDCON2"} {
+		if !strings.Contains(source, witness) {
+			t.Fatalf("Go immediate materialization contract changed: missing %q", witness)
+		}
+	}
+}
diff --git a/arm64_gp_immediate_proof_test.go b/arm64_gp_immediate_proof_test.go
new file mode 100644
index 000000000..673a19a1d
--- /dev/null
+++ b/arm64_gp_immediate_proof_test.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ImmediateTestInstruction(t *testing.T, text string) Instr {
+	t.Helper()
+	file, err := Parse(ArchARM64, "TEXT scratch(SB),4,$0-0\n"+text+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestARM64GPImmediateGoOperandClasses(t *testing.T) {
+	for _, tc := range []struct {
+		text    string
+		valid   bool
+		scratch bool
+	}{
+		{"ADD $4096,R27,R1", true, false},
+		{"ADD $0x123456,R27,R1", true, false},
+		{"ADDS $0x123456,R27,R1", false, false},
+		{"ADD $0x1234,R27,R1", false, false},
+		{"ADD $0x1234,R27", true, true},
+		{"EON $0x1234,R27", true, true},
+		{"AND $1,R0,ZR", true, true},
+		{"ANDS $1,R0,ZR", true, false},
+		{"BICS $1,R0,ZR", true, false},
+		{"AND $1,R0,RSP", true, false},
+		{"AND $0x1234,R0,RSP", false, false},
+		{"AND $1,RSP", false, false},
+		{"ADD $1,R0,ZR", false, false},
+		{"ADDS $1,R0,ZR", false, false},
+		{"CMP $4096,R27", true, false},
+		{"CMP $0x1234,R27", false, false},
+		{"CMP $0x1234,RSP", true, true},
+		{"CMP $0x123456,RSP", false, false},
+		{"CMP $0,ZR", false, false},
+		{"CMN $-1,ZR", false, false},
+		{"CMPW $0,ZR", true, true},
+		{"CMNW $-1,ZR", true, true},
+		{"TST $1,ZR", true, false},
+		{"TST $0x1234,ZR", true, true},
+		{"ADDW $0x123456789abcdef,R0,R1", true, true},
+		{"ANDW $0x123456789abcdef,R0,R1", true, true},
+		{"ADDS $1,R0,RSP", false, false},
+		{"ADD $1,ZR,R0", false, false},
+		{"CMP $1,R0,R1", false, false},
+		{"ADD $1.5,R0,R1", false, false},
+		{"ADD $missing,R0,R1", false, false},
+	} {
+		t.Run(tc.text, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, "TEXT classes(SB),4,$0-0\n"+tc.text+"\nRET\n", tc.valid)
+			ins := arm64ImmediateTestInstruction(t, tc.text)
+			before := ins
+			form, handled, err := parseARM64GPImmediateForm(ins.Op, ins)
+			if !handled && !tc.valid {
+				_, handled, err = parseARM64GPDataForm(ins.Op, ins)
+			}
+			if !handled || (err == nil) != tc.valid || tc.valid && form.scratch != tc.scratch {
+				t.Fatalf("class/REGTMP mismatch: handled=%v form=%+v error=%v", handled, form, err)
+			}
+			if !reflect.DeepEqual(ins, before) {
+				t.Fatal("validation mutated the original instruction")
+			}
+			if handled && err != nil && ins.Args[0].Kind == OpImm {
+				var output strings.Builder
+				context := &arm64Ctx{b: &output}
+				if handled, _, err := context.lowerARM64GPImmediate(ins.Op, ins); !handled || err == nil || output.Len() != 0 {
+					t.Fatal("invalid immediate emitted IR before validation")
+				}
+			}
+		})
+	}
+	ins := arm64ImmediateTestInstruction(t, "ADD $1,R0,R1")
+	if _, handled, err := parseARM64GPImmediateForm("SUB", ins); !handled || err == nil {
+		t.Fatal("conflicting dispatch identity supplied a Go encoder proof")
+	}
+}
+
+func TestARM64GPImmediateScratchIndependentProvenance(t *testing.T) {
+	for _, suffix := range []string{"", "W"} {
+		for _, op := range []string{"ADD", "ADDS", "SUB", "SUBS", "CMP", "CMN", "AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST"} {
+			text := op + suffix + " $0x1234,R0"
+			if op != "CMP" && op != "CMN" && op != "TST" {
+				text += ",R1"
+			}
+			ins := arm64ImmediateTestInstruction(t, text)
+			control := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R0": arm64ControlFromMap(map[string]bool{"label:actual_code": true}), "R27": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})},
+				memory: make(map[string]arm64ControlValue),
+			}
+			control.transfer(ins, ins.Op, false, nil)
+			if arm64ControlCount(arm64ControlLabels(control.regs["R27"])) != 0 {
+				t.Fatalf("%s scratch inherited source/old-R27 code provenance", text)
+			}
+			if strings.HasSuffix(text, ",R1") && arm64ControlCount(arm64ControlLabels(control.regs["R1"])) == 0 {
+				t.Fatalf("%s actual result lost its code-derived source", text)
+			}
+			address := arm64PrivateFrameAddress{offset: 16, exact: true}
+			readOnly := arm64PrivateFrameAddresses{"R27": address}
+			raw := &arm64RawPrivateFrameState{regs: readOnly.clone(), spills: make(map[int64]arm64PrivateFrameAddress)}
+			if !readOnly.transfer(ins, 64) || !raw.transfer(ins, ins, 64) {
+				t.Fatalf("%s dead scratch address was still consumed", text)
+			}
+			if _, present := readOnly["R27"]; present {
+				t.Fatalf("%s stale read-only frame provenance", text)
+			}
+			if _, present := raw.regs["R27"]; present {
+				t.Fatalf("%s stale raw frame provenance", text)
+			}
+			numeric := newARM64PrivateDataState()
+			numeric.regs["R27"] = arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{8, 8}}
+			numeric.comparison = arm64PrivateDataCompare{valid: true, leftReg: "R27"}
+			if _, valid := numeric.transfer(ins, 0, 64); !valid {
+				t.Fatalf("%s failed numeric scratch transfer", text)
+			}
+			value := numeric.value("R27")
+			if value.frame || value.interval != (arm64PoolInterval{0x1234, 0x1234}) {
+				t.Fatalf("%s scratch was not an independent exact constant: %+v", text, value)
+			}
+			if numeric.comparison.valid && numeric.comparison.leftReg == "R27" {
+				t.Fatalf("%s retained a stale bound comparison", text)
+			}
+		}
+	}
+	for _, text := range []string{"ADD $1,R27,R1", "ADD $0x123456,R27,R1", "AND $255,R27,R1"} {
+		ins := arm64ImmediateTestInstruction(t, text)
+		state := &arm64ControlState{regs: map[Reg]arm64ControlValue{"R27": arm64ControlFromMap(map[string]bool{"label:entry_lr": true})}, memory: make(map[string]arm64ControlValue)}
+		state.transfer(ins, ins.Op, false, nil)
+		if arm64ControlCount(arm64ControlLabels(state.regs["R27"])) == 0 || arm64ControlCount(arm64ControlLabels(state.regs["R1"])) == 0 {
+			t.Fatalf("non-TMP encoding killed a genuine source witness: %s", text)
+		}
+	}
+}
+
+func TestARM64GPImmediateScratchWholeCallerContext(t *testing.T) {
+	pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch()\n")
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	for _, suffix := range []string{"", "W"} {
+		for _, base := range []string{"ADD", "ADDS", "SUB", "SUBS", "CMP", "CMN", "AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST"} {
+			text := base + suffix + " $0x1234,R0"
+			if base != "CMP" && base != "CMN" && base != "TST" {
+				text += ",R1"
+			}
+			source := "TEXT ·Scratch(SB),4,$0-0\nMOVD R30,R27\nMOVD $17,R0\n" + text + "\nMOVD R27,R30\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true) // Compile only: deliberately invalid continuation.
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: map[string]FuncSig{"Scratch": {Name: "Scratch", Ret: Void}}}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s stale LR accepted by Translate: %v", target, text, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					ctx.Dispose()
+					t.Fatalf("%s %s stale LR accepted by Module: %v", target, text, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s stale LR accepted by GoModule: %v", target, text, err)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64GPImmediateEncodedOriginCannotBeForged(t *testing.T) {
+	for _, word := range []uint32{0x9100041b, 0xb100041f, 0xf10007ff, 0x92401c1b} {
+		original := arm64ImmediateTestInstruction(t, fmt.Sprintf("WORD $%#x", word))
+		decoded, err := decodeARM64RawWordInstruction(original)
+		if err != nil || !decoded.arm64Encoded {
+			t.Fatalf("real WORD origin missing: %v", err)
+		}
+		if _, handled, err := parseARM64GPImmediateForm(decoded.Op, decoded); handled || err != nil {
+			t.Fatalf("raw architectural instruction selected source pseudo expansion: %+v %v", decoded, err)
+		}
+		normalized, err := normalizeARM64RawPCRelative(Func{Instrs: []Instr{decoded}})
+		if err != nil || len(normalized.Instrs) != 1 || !normalized.Instrs[0].arm64Encoded {
+			t.Fatalf("normalization lost authenticated WORD origin: %v", err)
+		}
+		encoded, err := json.Marshal(decoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var supplied Instr
+		if err := json.Unmarshal(encoded, &supplied); err != nil {
+			t.Fatal(err)
+		}
+		if supplied.arm64Encoded {
+			t.Fatal("public JSON acquired private raw origin")
+		}
+	}
+	ins := arm64ImmediateTestInstruction(t, "ADDS $1,R0,ZR")
+	ins.Raw = "WORD $0xb100041f"
+	if _, handled, err := parseARM64GPImmediateForm(ins.Op, ins); !handled || err == nil {
+		t.Fatal("forged source Raw text bypassed Go register classes")
+	}
+}
+
+func TestARM64GPImmediateRawPCWidthUsesActualGoRows(t *testing.T) {
+	for _, text := range []string{"AND $1,R0,ZR", "AND $4096,R0,ZR", "ANDW $1,R0,ZR", "ANDW $4096,R0,ZR"} {
+		ins := arm64ImmediateTestInstruction(t, text)
+		if width, known := arm64RawKnownSourceWidth(Func{}, ins); known {
+			t.Errorf("multiword source acquired physical width %d: %s", width, text)
+		}
+		// The genuine raw address reaches +8. Assuming a four-byte source
+		// pseudo would falsely resolve that PC to the following RET label.
+		source := "TEXT uncertain(SB),4,$0-0\nWORD $0x10000040\n" + text + "\ntarget:\nRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err == nil {
+			t.Errorf("raw ADR acquired a guessed label across multiword source: %s", text)
+		}
+	}
+	for _, text := range []string{"AND $255,R0,R1", "ANDS $255,R0,ZR", "TST $255,ZR"} {
+		if width, known := arm64RawKnownSourceWidth(Func{}, arm64ImmediateTestInstruction(t, text)); !known || width != 4 {
+			t.Fatalf("direct one-word Go row lost exact width: %s", text)
+		}
+	}
+	decoded, err := decodeARM64RawWordInstruction(arm64ImmediateTestInstruction(t, "WORD $0x92401c1f"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if width, known := arm64RawKnownSourceWidth(Func{}, decoded); !known || width != 4 {
+		t.Fatal("actual raw logical WORD lost its physical four-byte width")
+	}
+}
+
+func TestARM64GPImmediateSourceEncoderContext(t *testing.T) {
+	pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch()\n")
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	for _, base := range []string{"CMP", "CMN", "AND", "BIC", "ORR", "ORN", "EOR", "EON"} {
+		text := base + " $0x00ff00ff00ff00ff,ZR"
+		if base != "CMP" && base != "CMN" {
+			text = base + " $0x00ff00ff00ff00ff,R0,ZR"
+		}
+		source := "TEXT ·Scratch(SB),4,$0-0\n" + text + "\nRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+			opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: map[string]FuncSig{"Scratch": {Name: "Scratch", Ret: Void}}}
+			if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s Translate version-dependent fallback %s: %v", target, text, err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err == nil {
+				module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				ctx.Dispose()
+				t.Fatalf("%s Module version-dependent fallback %s: %v", target, text, err)
+			}
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+			if err == nil {
+				bound.Module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s GoModule version-dependent fallback %s: %v", target, text, err)
+			}
+		}
+	}
+}
diff --git a/arm64_gp_immediate_runtime_test.go b/arm64_gp_immediate_runtime_test.go
new file mode 100644
index 000000000..a8aad4f3e
--- /dev/null
+++ b/arm64_gp_immediate_runtime_test.go
@@ -0,0 +1,355 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64ImmediateOracleConstant struct {
+	value             int64
+	add, split, bit64 bool
+	bit32             bool
+}
+
+type arm64ImmediateOracleCase struct {
+	op      string
+	value   int64
+	left    Reg
+	dest    Reg
+	two     bool
+	scratch bool
+	encoded uint32
+}
+
+// These are independent Go encoder-class witnesses, not values derived from
+// the translator's classifier. The original Go runtime checks the table too.
+func arm64ImmediateOracleCases() []arm64ImmediateOracleCase {
+	constants := []arm64ImmediateOracleConstant{
+		{0, true, false, false, false}, {1, true, false, true, true},
+		{4096, true, false, true, true}, {0x1234, false, false, false, false},
+		{0x123456, false, true, false, false}, {0xffff0000, false, false, true, true},
+		{0x123400005678, false, false, false, false},
+		{0x123400005678009a, false, false, false, false},
+		{0x123456789abcdef, false, false, false, false},
+		{-1, false, false, false, false}, {-4096, false, false, true, true},
+		{0x00ff00ff00ff00ff, false, false, true, true},
+		{0x000ffffffffff000, false, false, true, true},
+		{0x0f0f0f0f0f0f0f0f, false, false, true, true},
+	}
+	var cases []arm64ImmediateOracleCase
+	for _, base := range []string{"ADD", "ADDS", "SUB", "SUBS", "CMP", "CMN", "AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST"} {
+		for _, suffix := range []string{"", "W"} {
+			for _, constant := range constants {
+				word := suffix == "W"
+				bitmask := constant.bit64
+				if word {
+					bitmask = constant.bit32
+				}
+				arithmetic := base == "ADD" || base == "ADDS" || base == "SUB" || base == "SUBS" || base == "CMP" || base == "CMN"
+				compare := base == "CMP" || base == "CMN" || base == "TST"
+				flags := compare || strings.HasSuffix(base, "S")
+				encoderVariant := !word && (constant.value == 0x00ff00ff00ff00ff || constant.value == 0x0f0f0f0f0f0f0f0f)
+				scratch := !bitmask
+				if arithmetic {
+					add, split := constant.add, constant.split
+					if word && uint64(constant.value) > 0xffffffff && constant.value >= 0 {
+						// Both wide MOVCON2/3 witnesses truncate to an ordinary
+						// single MOVCON in W mode, not ADDCON2 or ADDCON.
+						add, split = false, false
+					}
+					scratch = !add && !(split && !flags)
+				}
+				if compare {
+					cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: constant.value, left: "R0", scratch: scratch})
+					if base == "TST" || word || constant.value != 0 && constant.value != -1 {
+						if arithmetic && encoderVariant {
+							continue // Independently observed old/new Go encoder context.
+						}
+						// X single-MOV CMP/CMN-to-ZR is Go-accepted, but its
+						// fixed-width expansion ends in UDF. It has separate
+						// original-Go/LLVM fault and exact-byte oracles.
+						if arithmetic && !word && (constant.value == 1 || constant.value == 4096 ||
+							constant.value == 0x1234 || constant.value == 0xffff0000 || constant.value == -4096) {
+							continue
+						}
+						zrScratch := scratch
+						if arithmetic {
+							zrScratch = true
+						}
+						cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: constant.value, left: ZR, scratch: zrScratch})
+					}
+					continue
+				}
+				for _, dest := range []Reg{"R1", "R27"} {
+					cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: constant.value, left: "R0", dest: dest, scratch: scratch})
+				}
+				cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: constant.value, left: "R27", dest: "R27", two: true, scratch: scratch})
+				if !arithmetic {
+					if !flags && (encoderVariant || !word && constant.value == 4096) {
+						continue // X C_ABCON-to-ZR fallback has a separate UDF oracle.
+					}
+					cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: constant.value, left: "R0", dest: ZR, scratch: scratch || !flags})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func arm64ImmediateOracleInstruction(tc arm64ImmediateOracleCase) string {
+	if tc.encoded != 0 {
+		return fmt.Sprintf("WORD $%#x", tc.encoded)
+	}
+	text := fmt.Sprintf("%s $%d,%s", tc.op, tc.value, tc.left)
+	if tc.dest != "" && !tc.two {
+		text += "," + string(tc.dest)
+	}
+	return text
+}
+
+func arm64ImmediateOracleSource(cases []arm64ImmediateOracleCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·DivideRem(SB),4,$0-16\nMOVD input+0(FP),R10\nMOVD output+8(FP),R11\n")
+	for _, tc := range cases {
+		source.WriteString("MOVD 0(R10),R0\nMOVD 8(R10),R27\nMOVD 16(R10),R6\nMOVD 24(R10),R7\nMOVD $107,R1\nCMP R7,R6\n")
+		source.WriteString(arm64ImmediateOracleInstruction(tc) + "\n")
+		result := tc.dest
+		if result == "" || result == ZR {
+			result = "R1"
+		}
+		fmt.Fprintf(&source, "MOVD %s,(R11)\nMOVD R27,8(R11)\n", result)
+		source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET HS,R4\nCSET VS,R5\nLSL $1,R3\nLSL $2,R4\nLSL $3,R5\nORR R3,R2\nORR R4,R2\nORR R5,R2\n")
+		source.WriteString("MOVD R2,16(R11)\nADD $24,R11\n")
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func arm64ImmediateOracleExpected(tc arm64ImmediateOracleCase, input [4]uint64) [3]uint64 {
+	base := strings.TrimSuffix(tc.op, "W")
+	word := strings.HasSuffix(tc.op, "W")
+	right, scratch := uint64(tc.value), input[1]
+	if word {
+		right = uint64(uint32(right))
+	}
+	if tc.scratch {
+		scratch = right
+	}
+	left := input[0]
+	if tc.left == "R27" {
+		left = scratch
+	} else if tc.left == ZR {
+		left = 0
+	}
+	if word {
+		left = uint64(uint32(left))
+	}
+	if base == "BIC" || base == "BICS" || base == "ORN" || base == "EON" {
+		right = ^right
+	}
+	if word {
+		right = uint64(uint32(right))
+	}
+	result, operation := uint64(0), "logic"
+	switch base {
+	case "ADD", "ADDS", "CMN":
+		result, operation = left+right, "add"
+	case "SUB", "SUBS", "CMP":
+		result, operation = left-right, "sub"
+	case "AND", "ANDS", "BIC", "BICS", "TST":
+		result = left & right
+	case "ORR", "ORN":
+		result = left | right
+	case "EOR", "EON":
+		result = left ^ right
+	}
+	width := uint(64)
+	if word {
+		width, result = 32, uint64(uint32(result))
+	}
+	flags := arm64DivRemRuntimeFlags(input[2], input[3])
+	if strings.HasSuffix(base, "S") || tc.dest == "" {
+		flags = 0
+		sign := uint64(1) << (width - 1)
+		if result&sign != 0 {
+			flags |= 1
+		}
+		if result == 0 {
+			flags |= 2
+		}
+		if operation == "add" {
+			if result < left {
+				flags |= 4
+			}
+			if (^(left^right)&(left^result))&sign != 0 {
+				flags |= 8
+			}
+		} else if operation == "sub" {
+			if left >= right {
+				flags |= 4
+			}
+			if ((left^right)&(left^result))&sign != 0 {
+				flags |= 8
+			}
+		}
+	}
+	if tc.dest == "R27" {
+		scratch = result
+	}
+	if tc.dest == "" || tc.dest == ZR {
+		result = 107
+	}
+	return [3]uint64{result, scratch, flags}
+}
+
+func arm64ImmediateOraclePrograms(cases []arm64ImmediateOracleCase) (string, string) {
+	inputs := arm64DivRemRuntimeInputs()[:8]
+	var goData, cData strings.Builder
+	for _, input := range inputs {
+		goData.WriteString("{\n")
+		cData.WriteString("{\n")
+		for _, tc := range cases {
+			for _, value := range arm64ImmediateOracleExpected(tc, input) {
+				fmt.Fprintf(&goData, "%d,", value)
+				fmt.Fprintf(&cData, "UINT64_C(%d),", value)
+			}
+			goData.WriteByte('\n')
+			cData.WriteByte('\n')
+		}
+		goData.WriteString("},\n")
+		cData.WriteString("},\n")
+	}
+	var goInputs, cInputs strings.Builder
+	for _, input := range inputs {
+		fmt.Fprintf(&goInputs, "{%d,%d,%d,%d},\n", input[0], input[1], input[2], input[3])
+		fmt.Fprintf(&cInputs, "{UINT64_C(%d),UINT64_C(%d),UINT64_C(%d),UINT64_C(%d)},\n", input[0], input[1], input[2], input[3])
+	}
+	count := len(cases) * 3
+	goSource := fmt.Sprintf(`package main
+import "fmt"
+func DivideRem(input *[4]uint64, output *[%d]uint64)
+var expected = [...][%d]uint64{%s}
+var inputs = [...][4]uint64{%s}
+func main() {
+ for row, input := range inputs {
+  initial := input
+  var storage [%d]uint64
+  storage[0],storage[len(storage)-1] = 0x12345678,0x87654321
+  output := (*[%d]uint64)(storage[1:])
+  DivideRem(&input,output)
+  if input != initial || storage[0] != 0x12345678 || storage[len(storage)-1] != 0x87654321 { panic("Go canary/input mutation") }
+  for index, want := range expected[row] {
+   if output[index] != want { panic(fmt.Sprintf("Go row %%d case %%d axis %%d got %%#x want %%#x",row,index/3,index%%3,output[index],want)) }
+  }
+ }
+}
+`, count, count, goData.String(), goInputs.String(), count+2, count)
+	cSource := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void DivideRem(uint64_t *,uint64_t *);
+static const uint64_t expected[][%d] = {%s};
+static const uint64_t inputs[][4] = {%s};
+int main(void) {
+ for (unsigned row=0;row<sizeof(inputs)/sizeof(inputs[0]);row++) {
+  uint64_t input[4],storage[%d] = {0};
+  memcpy(input,inputs[row],sizeof(input));
+  storage[0]=0x12345678;storage[%d]=0x87654321;
+  DivideRem(input,storage+1);
+  if (memcmp(input,inputs[row],sizeof(input)) || storage[0]!=0x12345678 || storage[%d]!=0x87654321) return 2;
+  for (unsigned index=0;index<%d;index++) {
+   if (storage[index+1]!=expected[row][index]) {
+    fprintf(stderr,"LLVM row %%u case %%u axis %%u got %%#llx want %%#llx\n",row,index/3,index%%3,(unsigned long long)storage[index+1],(unsigned long long)expected[row][index]);
+    return 1;
+   }
+  }
+ }
+ return 0;
+}
+`, count, cData.String(), cInputs.String(), count+2, count+1, count+1, count)
+	return goSource, cSource
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GPImmediateScratch(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	cases := arm64ImmediateOracleCases()
+	source := arm64ImmediateOracleSource(cases)
+	goSource, cSource := arm64ImmediateOraclePrograms(cases)
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*3) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("gp-immediate-%d", api), triple, ir, cSource, runner)
+	}
+	t.Logf("30 opcode family: %d original-Go/three-API LLVM cases x 8 boundary inputs, result/R27/NZCV/full canaries", len(cases))
+}
+
+func TestARM64GPImmediateScratchCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	cases := arm64ImmediateOracleCases()
+	source := arm64ImmediateOracleSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc", "aarch64-w64-windows-gnu"} {
+		for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*3) {
+			compileLLVMToObject(t, llc, triple, fmt.Sprintf("gp-immediate-%d.ll", api), fmt.Sprintf("gp-immediate-%d.o", api), ir)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GPImmediateEncodedVsSource(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var cases []arm64ImmediateOracleCase
+	for _, suffix := range []string{"", "W"} {
+		bank, zero := "x", "xzr"
+		if suffix == "W" {
+			bank, zero = "w", "wzr"
+		}
+		for _, base := range []string{"AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST"} {
+			mnemonic, mask := strings.ToLower(base), "4096"
+			destination, dest := bank+"1", Reg("R1")
+			switch base {
+			case "BIC", "BICS":
+				mnemonic = strings.Replace(mnemonic, "bic", "and", 1)
+				mask = "-4097"
+			case "ORN":
+				mnemonic, mask = "orr", "-4097"
+			case "EON":
+				mnemonic, mask = "eor", "-4097"
+			case "TST":
+				mnemonic = "ands"
+			}
+			if base == "ANDS" || base == "BICS" || base == "TST" {
+				destination, dest = zero, ZR
+			}
+			assembly := fmt.Sprintf("%s %s,%s0,#%s", mnemonic, destination, bank, mask)
+			word := assembleARM64LLVMWords(t, []string{assembly}, "")[0]
+			if base == "TST" {
+				dest = "" // Compare-class oracle: flags, with no GP result.
+			}
+			cases = append(cases, arm64ImmediateOracleCase{op: base + suffix, value: 4096, left: "R0", dest: dest, encoded: word})
+		}
+		assembly := fmt.Sprintf("adds %s,%s0,#1", zero, bank)
+		word := assembleARM64LLVMWords(t, []string{assembly}, "")[0]
+		cases = append(cases, arm64ImmediateOracleCase{op: "ADDS" + suffix, value: 1, left: "R0", dest: ZR, encoded: word})
+		// Both named ADD and its genuine raw encoding have no implicit R27
+		// output. The named ADDS-to-ZR spelling above is Go-rejected, while
+		// the physical WORD is legal and must not acquire source optab rules.
+		word = assembleARM64LLVMWords(t, []string{fmt.Sprintf("add %s1,%s0,#1", bank, bank)}, "")[0]
+		cases = append(cases,
+			arm64ImmediateOracleCase{op: "ADD" + suffix, value: 1, left: "R0", dest: "R1", encoded: word},
+			arm64ImmediateOracleCase{op: "ADD" + suffix, value: 1, left: "R0", dest: "R1"})
+	}
+	source := arm64ImmediateOracleSource(cases)
+	goSource, cSource := arm64ImmediateOraclePrograms(cases)
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*3) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("raw-immediate-%d", api), triple, ir, cSource, runner)
+	}
+	for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		for api, ir := range arm64DivRemRuntimeIRs(t, source, target, len(cases)*3) {
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("raw-immediate-%d.ll", api), fmt.Sprintf("raw-immediate-%d.o", api), ir)
+		}
+	}
+}
diff --git a/arm64_helper_edge_test.go b/arm64_helper_edge_test.go
index 741b7ae59..85ee5fa04 100644
--- a/arm64_helper_edge_test.go
+++ b/arm64_helper_edge_test.go
@@ -1,6 +1,7 @@
 package plan9asm
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 	"testing"
@@ -127,7 +128,7 @@ func TestARM64AtomicCoverage(t *testing.T) {
 		}
 	}
 
-	mem := arm64MemOp("R10", 32)
+	mem := arm64MemOp("R10", 0)
 	for _, tc := range []Instr{
 		{Op: "LDARW", Args: []Operand{mem, arm64RegOp("R0")}, Raw: "LDARW 32(R10), R0"},
 		{Op: "LDARB", Args: []Operand{mem, arm64RegOp("R1")}, Raw: "LDARB 32(R10), R1"},
@@ -141,19 +142,19 @@ func TestARM64AtomicCoverage(t *testing.T) {
 		{Op: "STLXRW", Args: []Operand{arm64RegOp("R3"), mem, arm64RegOp("R6")}, Raw: "STLXRW R3, 32(R10), R6"},
 		{Op: "STLXRB", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R7")}, Raw: "STLXRB R4, 32(R10), R7"},
 		{Op: "STLXR", Args: []Operand{arm64RegOp("R5"), mem, arm64RegOp("R8")}, Raw: "STLXR R5, 32(R10), R8"},
-		{Op: "SWPALB", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "SWPALB R0, 32(R10), R1"},
-		{Op: "SWPALW", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "SWPALW R2, 32(R10), R3"},
-		{Op: "SWPALD", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "SWPALD R4, 32(R10), R5"},
-		{Op: "LDADDALW", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "LDADDALW R0, 32(R10), R1"},
-		{Op: "LDADDALD", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "LDADDALD R2, 32(R10), R3"},
-		{Op: "LDORALB", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "LDORALB R4, 32(R10), R5"},
-		{Op: "LDORALW", Args: []Operand{arm64RegOp("R6"), mem, arm64RegOp("R7")}, Raw: "LDORALW R6, 32(R10), R7"},
-		{Op: "LDORALD", Args: []Operand{arm64RegOp("R8"), mem, arm64RegOp("R9")}, Raw: "LDORALD R8, 32(R10), R9"},
-		{Op: "LDCLRALB", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "LDCLRALB R0, 32(R10), R1"},
-		{Op: "LDCLRALW", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "LDCLRALW R2, 32(R10), R3"},
-		{Op: "LDCLRALD", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "LDCLRALD R4, 32(R10), R5"},
-		{Op: "CASALW", Args: []Operand{arm64RegOp("R6"), mem, arm64RegOp("R7")}, Raw: "CASALW R6, 32(R10), R7"},
-		{Op: "CASALD", Args: []Operand{arm64RegOp("R8"), mem, arm64RegOp("R9")}, Raw: "CASALD R8, 32(R10), R9"},
+		{Op: "SWPALB", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "SWPALB R0, (R10), R1"},
+		{Op: "SWPALW", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "SWPALW R2, (R10), R3"},
+		{Op: "SWPALD", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "SWPALD R4, (R10), R5"},
+		{Op: "LDADDALW", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "LDADDALW R0, (R10), R1"},
+		{Op: "LDADDALD", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "LDADDALD R2, (R10), R3"},
+		{Op: "LDORALB", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "LDORALB R4, (R10), R5"},
+		{Op: "LDORALW", Args: []Operand{arm64RegOp("R6"), mem, arm64RegOp("R7")}, Raw: "LDORALW R6, (R10), R7"},
+		{Op: "LDORALD", Args: []Operand{arm64RegOp("R8"), mem, arm64RegOp("R9")}, Raw: "LDORALD R8, (R10), R9"},
+		{Op: "LDCLRALB", Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R1")}, Raw: "LDCLRALB R0, (R10), R1"},
+		{Op: "LDCLRALW", Args: []Operand{arm64RegOp("R2"), mem, arm64RegOp("R3")}, Raw: "LDCLRALW R2, (R10), R3"},
+		{Op: "LDCLRALD", Args: []Operand{arm64RegOp("R4"), mem, arm64RegOp("R5")}, Raw: "LDCLRALD R4, (R10), R5"},
+		{Op: "CASALW", Args: []Operand{arm64RegOp("R6"), mem, arm64RegOp("R7")}, Raw: "CASALW R6, (R10), R7"},
+		{Op: "CASALD", Args: []Operand{arm64RegOp("R8"), mem, arm64RegOp("R9")}, Raw: "CASALD R8, (R10), R9"},
 	} {
 		ok, _, err := c.lowerAtomic(tc.Op, tc)
 		mustLowerARM64(t, "lowerAtomic", tc, ok, err)
@@ -251,10 +252,10 @@ func TestARM64ArithmeticCoverage(t *testing.T) {
 		{Op: "ADD", Args: []Operand{arm64ImmOp(2), arm64RegOp("R0")}, Raw: "ADD $2, R0"},
 		{Op: "SUB", Args: []Operand{arm64ImmOp(3), arm64RegOp("R1"), arm64RegOp("R2")}, Raw: "SUB $3, R1, R2"},
 		{Op: "ADDS", Args: []Operand{arm64ImmOp(4), arm64RegOp("R2"), arm64RegOp("R3")}, Raw: "ADDS $4, R2, R3"},
-		{Op: "ADC", Args: []Operand{arm64ImmOp(5), arm64RegOp("R3")}, Raw: "ADC $5, R3"},
-		{Op: "ADCS", Args: []Operand{arm64ImmOp(6), arm64RegOp("R3"), arm64RegOp("R4")}, Raw: "ADCS $6, R3, R4"},
-		{Op: "SBC", Args: []Operand{arm64ImmOp(1), arm64RegOp("R4")}, Raw: "SBC $1, R4"},
-		{Op: "SBCS", Args: []Operand{arm64ImmOp(2), arm64RegOp("R4"), arm64RegOp("R5")}, Raw: "SBCS $2, R4, R5"},
+		{Op: "ADC", Args: []Operand{arm64RegOp("R5"), arm64RegOp("R3")}, Raw: "ADC R5, R3"},
+		{Op: "ADCS", Args: []Operand{arm64RegOp("R6"), arm64RegOp("R3"), arm64RegOp("R4")}, Raw: "ADCS R6, R3, R4"},
+		{Op: "SBC", Args: []Operand{arm64RegOp("R1"), arm64RegOp("R4")}, Raw: "SBC R1, R4"},
+		{Op: "SBCS", Args: []Operand{arm64RegOp("R2"), arm64RegOp("R4"), arm64RegOp("R5")}, Raw: "SBCS R2, R4, R5"},
 		{Op: "ADDW", Args: []Operand{arm64ImmOp(7), arm64RegOp("R5"), arm64RegOp("R6")}, Raw: "ADDW $7, R5, R6"},
 		{Op: "SUBW", Args: []Operand{arm64ImmOp(3), arm64RegOp("R6")}, Raw: "SUBW $3, R6"},
 		{Op: "AND", Args: []Operand{arm64ImmOp(15), arm64RegOp("R6"), arm64RegOp("R7")}, Raw: "AND $15, R6, R7"},
@@ -282,7 +283,7 @@ func TestARM64ArithmeticCoverage(t *testing.T) {
 		{Op: "CMPW", Args: []Operand{arm64RegOp("R1"), arm64RegOp("R2")}, Raw: "CMPW R1, R2"},
 		{Op: "CMN", Args: []Operand{arm64RegOp("R2"), arm64RegOp("R3")}, Raw: "CMN R2, R3"},
 		{Op: "NEG", Args: []Operand{arm64RegOp("R3"), arm64RegOp("R4")}, Raw: "NEG R3, R4"},
-		{Op: "MUL", Args: []Operand{arm64ImmOp(2), arm64RegOp("R4"), arm64RegOp("R5")}, Raw: "MUL $2, R4, R5"},
+		{Op: "MUL", Args: []Operand{arm64RegOp("R2"), arm64RegOp("R4"), arm64RegOp("R5")}, Raw: "MUL R2, R4, R5"},
 		{Op: "UMULH", Args: []Operand{arm64RegOp("R5"), arm64RegOp("R6"), arm64RegOp("R7")}, Raw: "UMULH R5, R6, R7"},
 		{Op: "MADD", Args: []Operand{arm64RegOp("R0"), arm64RegOp("R1"), arm64RegOp("R2"), arm64RegOp("R3")}, Raw: "MADD R0, R1, R2, R3"},
 		{Op: "MSUB", Args: []Operand{arm64RegOp("R3"), arm64RegOp("R4"), arm64RegOp("R5"), arm64RegOp("R6")}, Raw: "MSUB R3, R4, R5, R6"},
@@ -302,6 +303,12 @@ func TestARM64ArithmeticCoverage(t *testing.T) {
 		mustLowerARM64(t, "lowerArith", tc, ok, err)
 	}
 
+	const invalidMultiply = "TEXT immediateMultiply(SB),516,$0-0\nMUL $2,R4,R5\nRET\n"
+	requireARM64GoAssemblerResult(t, invalidMultiply, false)
+	if _, _, err := c.lowerArith("MUL", Instr{Op: "MUL", Args: []Operand{arm64ImmOp(2), arm64RegOp("R4"), arm64RegOp("R5")}, Raw: "MUL $2,R4,R5"}); err == nil {
+		t.Fatal("Go-rejected immediate multiply unexpectedly succeeded")
+	}
+
 	if _, _, err := c.lowerArith("UBFX", Instr{Op: "UBFX", Args: []Operand{arm64ImmOp(63), arm64RegOp("R0"), arm64ImmOp(2), arm64RegOp("R1")}, Raw: "UBFX $63, R0, $2, R1"}); err == nil {
 		t.Fatalf("invalid UBFX unexpectedly succeeded")
 	}
@@ -326,17 +333,12 @@ func TestARM64ArithmeticCoverage(t *testing.T) {
 	if got := arm64CanonicalSysReg("DIT"); got != "S3_3_C4_C2_5" {
 		t.Fatalf("arm64CanonicalSysReg(DIT) = %q", got)
 	}
-	if v, ok := arm64CompileSafeMRSValue("MIDR_EL1"); !ok || v != "0" {
-		t.Fatalf("arm64CompileSafeMRSValue(MIDR_EL1) = (%q, %v)", v, ok)
-	}
-	if _, ok := arm64CompileSafeMRSValue("TPIDR_EL0"); ok {
-		t.Fatalf("arm64CompileSafeMRSValue(TPIDR_EL0) unexpectedly succeeded")
-	}
 
 	out := b.String()
 	for _, want := range []string{
-		`asm sideeffect "mrs $0, TPIDR_EL0"`,
-		`asm sideeffect "msr S3_3_C4_C2_5, $0"`,
+		`asm sideeffect "mrs $0, S3_3_C13_C0_2"`,
+		`asm sideeffect "mrs $0, S3_0_C0_C0_0"`,
+		`asm sideeffect "msr DIT, #1"`,
 		"lshr i64",
 		"lshr i32",
 		"shl i64",
@@ -457,7 +459,7 @@ func TestARM64DataVectorAndBranchCoverage(t *testing.T) {
 		{"MOVBU", false, Instr{Op: "MOVBU", Args: []Operand{arm64RegOp("R10"), arm64MemOp("R20", 20)}, Raw: "MOVBU R10, 20(R20)"}, "data"},
 		{"MOVBU", false, Instr{Op: "MOVBU", Args: []Operand{arm64RegOp("R10"), arm64FPOp(16)}, Raw: "MOVBU R10, ret+16(FP)"}, "data"},
 		{"LDP", true, Instr{Op: "LDP.P", Args: []Operand{arm64MemOp("R20", 16), arm64RegListOp("R0", "R1")}, Raw: "LDP.P 16(R20), [R0, R1]"}, "data"},
-		{"LDP", false, Instr{Op: "LDP", Args: []Operand{arm64FPOp(24), arm64RegListOp("R2", "R3")}, Raw: "LDP arg+24(FP), [R2, R3]"}, "data"},
+		{"LDP", false, Instr{Op: "LDP", Args: []Operand{arm64FPOp(8), arm64RegListOp("R2", "R3")}, Raw: "LDP ret+8(FP), [R2, R3]"}, "data"},
 		{"LDP", false, Instr{Op: "LDP", Args: []Operand{arm64SymOp("example.global(SB)"), arm64RegListOp("R4", "R5")}, Raw: "LDP example.global(SB), [R4, R5]"}, "data"},
 		{"LDPW", true, Instr{Op: "LDPW.P", Args: []Operand{arm64MemOp("R20", 8), arm64RegListOp("R6", "R7")}, Raw: "LDPW.P 8(R20), [R6, R7]"}, "data"},
 		{"STPW", true, Instr{Op: "STPW.P", Args: []Operand{arm64RegListOp("R6", "R7"), arm64MemOp("R20", 8)}, Raw: "STPW.P [R6, R7], 8(R20)"}, "data"},
@@ -466,21 +468,21 @@ func TestARM64DataVectorAndBranchCoverage(t *testing.T) {
 		{"VMOV", false, Instr{Op: "VMOV", Args: []Operand{arm64RegOp("R1"), arm64RegOp("V1.S4")}, Raw: "VMOV R1, V1.S4"}, "vec"},
 		{"VMOV", false, Instr{Op: "VMOV", Args: []Operand{arm64RegOp("R2"), arm64RegOp("V2.D[1]")}, Raw: "VMOV R2, V2.D[1]"}, "vec"},
 		{"VMOV", false, Instr{Op: "VMOV", Args: []Operand{arm64RegOp("V2.D[1]"), arm64RegOp("R3")}, Raw: "VMOV V2.D[1], R3"}, "vec"},
-		{"VMOV", false, Instr{Op: "VMOV", Args: []Operand{arm64RegOp("V1"), arm64RegOp("V3")}, Raw: "VMOV V1, V3"}, "vec"},
-		{"VEOR", false, Instr{Op: "VEOR", Args: []Operand{arm64RegOp("V0"), arm64RegOp("V1"), arm64RegOp("V4")}, Raw: "VEOR V0, V1, V4"}, "vec"},
-		{"VORR", false, Instr{Op: "VORR", Args: []Operand{arm64RegOp("V1"), arm64RegOp("V2"), arm64RegOp("V5")}, Raw: "VORR V1, V2, V5"}, "vec"},
-		{"VLD1", true, Instr{Op: "VLD1.P", Args: []Operand{arm64MemOp("R21", 0), arm64RegOp("V4.B[3]")}, Raw: "VLD1.P (R21), V4.B[3]"}, "vec"},
-		{"VLD1", true, Instr{Op: "VLD1.P", Args: []Operand{arm64MemOp("R21", 0), arm64RegListOp("V4", "V5", "V6", "V7")}, Raw: "VLD1.P (R21), [V4, V5, V6, V7]"}, "vec"},
-		{"VST1", true, Instr{Op: "VST1.P", Args: []Operand{arm64RegListOp("V4", "V5"), arm64MemOp("R21", 0)}, Raw: "VST1.P [V4, V5], (R21)"}, "vec"},
+		{"VMOV", false, Instr{Op: "VMOV", Args: []Operand{arm64RegOp("V1.B16"), arm64RegOp("V3.B16")}, Raw: "VMOV V1.B16, V3.B16"}, "vec"},
+		{"VEOR", false, Instr{Op: "VEOR", Args: []Operand{arm64RegOp("V0.B16"), arm64RegOp("V1.B16"), arm64RegOp("V4.B16")}, Raw: "VEOR V0.B16, V1.B16, V4.B16"}, "vec"},
+		{"VORR", false, Instr{Op: "VORR", Args: []Operand{arm64RegOp("V1.B16"), arm64RegOp("V2.B16"), arm64RegOp("V5.B16")}, Raw: "VORR V1.B16, V2.B16, V5.B16"}, "vec"},
+		{"VLD1", true, Instr{Op: "VLD1.P", Args: []Operand{arm64MemOp("R21", 1), arm64RegOp("V4.B[3]")}, Raw: "VLD1.P 1(R21), V4.B[3]"}, "vec"},
+		{"VLD1", true, Instr{Op: "VLD1.P", Args: []Operand{arm64MemOp("R21", 0), arm64RegListOp("V4.B16", "V5.B16", "V6.B16", "V7.B16")}, Raw: "VLD1.P (R21), [V4.B16, V5.B16, V6.B16, V7.B16]"}, "vec"},
+		{"VST1", true, Instr{Op: "VST1.P", Args: []Operand{arm64RegListOp("V4.B16", "V5.B16"), arm64MemOp("R21", 0)}, Raw: "VST1.P [V4.B16, V5.B16], (R21)"}, "vec"},
 		{"VCMEQ", false, Instr{Op: "VCMEQ", Args: []Operand{arm64RegOp("V4.B16"), arm64RegOp("V5.B16"), arm64RegOp("V6.B16")}, Raw: "VCMEQ V4.B16, V5.B16, V6.B16"}, "vec"},
 		{"VCMEQ", false, Instr{Op: "VCMEQ", Args: []Operand{arm64RegOp("V4.D2"), arm64RegOp("V5.D2"), arm64RegOp("V7.D2")}, Raw: "VCMEQ V4.D2, V5.D2, V7.D2"}, "vec"},
-		{"VAND", false, Instr{Op: "VAND", Args: []Operand{arm64RegOp("V4"), arm64RegOp("V5"), arm64RegOp("V6")}, Raw: "VAND V4, V5, V6"}, "vec"},
+		{"VAND", false, Instr{Op: "VAND", Args: []Operand{arm64RegOp("V4.B16"), arm64RegOp("V5.B16"), arm64RegOp("V6.B16")}, Raw: "VAND V4.B16, V5.B16, V6.B16"}, "vec"},
 		{"VADDP", false, Instr{Op: "VADDP", Args: []Operand{arm64RegOp("V4.B16"), arm64RegOp("V5.B16"), arm64RegOp("V6.B16")}, Raw: "VADDP V4.B16, V5.B16, V6.B16"}, "vec"},
 		{"VADDP", false, Instr{Op: "VADDP", Args: []Operand{arm64RegOp("V4.D2"), arm64RegOp("V5.D2"), arm64RegOp("V7.D2")}, Raw: "VADDP V4.D2, V5.D2, V7.D2"}, "vec"},
 		{"VUADDLV", false, Instr{Op: "VUADDLV", Args: []Operand{arm64RegOp("V6.B16"), arm64RegOp("V7")}, Raw: "VUADDLV V6.B16, V7"}, "vec"},
 		{"VADD", false, Instr{Op: "VADD", Args: []Operand{arm64RegOp("V4.S4"), arm64RegOp("V5.S4"), arm64RegOp("V6.S4")}, Raw: "VADD V4.S4, V5.S4, V6.S4"}, "vec"},
-		{"VADD", false, Instr{Op: "VADD", Args: []Operand{arm64RegOp("V6.D2"), arm64RegOp("V7.D2")}, Raw: "VADD V6.D2, V7.D2"}, "vec"},
-		{"AESE", false, Instr{Op: "AESE", Args: []Operand{arm64RegOp("V0"), arm64RegOp("V1"), arm64RegOp("V2")}, Raw: "AESE V0, V1, V2"}, "vec"},
+		{"VADD", false, Instr{Op: "VADD", Args: []Operand{arm64RegOp("V5.D2"), arm64RegOp("V6.D2"), arm64RegOp("V7.D2")}, Raw: "VADD V5.D2, V6.D2, V7.D2"}, "vec"},
+		{"VDUP", false, Instr{Op: "VDUP", Args: []Operand{arm64RegOp("V0.B[0]"), arm64RegOp("V1.B16")}, Raw: "VDUP V0.B[0], V1.B16"}, "vec"},
 	} {
 		switch tc.kind {
 		case "data":
@@ -507,19 +509,19 @@ func TestARM64DataVectorAndBranchCoverage(t *testing.T) {
 	if _, ok := arm64BranchTarget(arm64RegOp("R0")); ok {
 		t.Fatalf("arm64BranchTarget(reg) unexpectedly succeeded")
 	}
-	if got := arm64LLVMBlockName("9.loop<>"); got != "bb_9_loop__" {
+	if got := arm64LLVMBlockName("9.loop<>"); got != "bb_n_9_2eloop_3c_3e" {
 		t.Fatalf("arm64LLVMBlockName() = %q", got)
 	}
 
-	c.setFlagsSub("10", "4", "6")
 	emitBr := arm64TestEmitBr(c)
 	emitCondBr := arm64TestEmitCondBr(c)
 	for _, tc := range []Instr{
-		{Op: "BL", Args: []Operand{arm64RegOp("R0")}, Raw: "BL R0"},
-		{Op: "CALL", Args: []Operand{arm64MemOp("R20", 8)}, Raw: "CALL 8(R20)"},
+		{Op: "BL", Args: []Operand{arm64RegOp(ZR)}, Raw: "BL ZR"},
+		{Op: "CALL", Args: []Operand{arm64MemOp(ZR, 0)}, Raw: "CALL (ZR)"},
 		{Op: "BL", Args: []Operand{arm64SymOp("helper(SB)")}, Raw: "BL helper(SB)"},
-		{Op: "B", Args: []Operand{arm64RegOp("R1")}, Raw: "B R1"},
-		{Op: "JMP", Args: []Operand{arm64MemOp("R20", 8)}, Raw: "JMP 8(R20)"},
+		{Op: "CALL", Args: []Operand{arm64SymOp("helper(SB)")}, Raw: "CALL helper(SB)"},
+		{Op: "B", Args: []Operand{arm64MemOp(ZR, 0)}, Raw: "B (ZR)"},
+		{Op: "JMP", Args: []Operand{arm64MemOp(ZR, 0)}, Raw: "JMP (ZR)"},
 		{Op: "B", Args: []Operand{arm64SymOp("sink(SB)")}, Raw: "B sink(SB)"},
 		{Op: "BEQ", Args: []Operand{arm64IdentOp("done")}, Raw: "BEQ done"},
 		{Op: "BNE", Args: []Operand{arm64IdentOp("done")}, Raw: "BNE done"},
@@ -536,21 +538,55 @@ func TestARM64DataVectorAndBranchCoverage(t *testing.T) {
 		{Op: "BMI", Args: []Operand{arm64IdentOp("done")}, Raw: "BMI done"},
 		{Op: "BPL", Args: []Operand{arm64IdentOp("done")}, Raw: "BPL done"},
 		{Op: "CBZ", Args: []Operand{arm64RegOp("R2"), arm64IdentOp("done")}, Raw: "CBZ R2, done"},
-		{Op: "CBNZ", Args: []Operand{arm64RegOp("R3"), arm64MemOp(PC, 4)}, Raw: "CBNZ R3, 4(PC)"},
+		{Op: "CBNZ", Args: []Operand{arm64RegOp("R3"), arm64IdentOp("done")}, Raw: "CBNZ R3, done"},
 		{Op: "TBZ", Args: []Operand{arm64ImmOp(1), arm64RegOp("R4"), arm64IdentOp("done")}, Raw: "TBZ $1, R4, done"},
-		{Op: "TBNZ", Args: []Operand{arm64ImmOp(2), arm64RegOp("R5"), arm64MemOp(PC, 0)}, Raw: "TBNZ $2, R5, 0(PC)"},
+		{Op: "TBNZ", Args: []Operand{arm64ImmOp(2), arm64RegOp("R5"), arm64IdentOp("done")}, Raw: "TBNZ $2, R5, done"},
 		{Op: "CBZW", Args: []Operand{arm64RegOp("R6"), arm64IdentOp("done")}, Raw: "CBZW R6, done"},
 		{Op: "CBNZW", Args: []Operand{arm64RegOp("R7"), arm64IdentOp("done")}, Raw: "CBNZW R7, done"},
 	} {
-		ok, _, err := c.lowerBranch(1, tc.Op, tc, emitBr, emitCondBr)
+		// Each row is an independent lowerer fixture. Calls in preceding
+		// rows correctly revoke flags and cannot supply this row's comparison.
+		c.setFlagsSub("10", "4", "6")
+		start := c.b.Len()
+		ok, terminated, err := c.lowerBranch(1, tc.Op, tc, emitBr, emitCondBr)
+		if tc.Op == "B" && len(tc.Args) == 1 && tc.Args[0].Kind == OpSym {
+			// This direct lowerer unit has no complete source CFG proof.
+			// A tail return must not receive fabricated SP/LR provenance.
+			if !ok || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproven direct tail branch must need context, got %v", err)
+			}
+			continue
+		}
 		mustLowerARM64(t, "lowerBranch", tc, ok, err)
+		if tc.Op == "BL" || tc.Op == "CALL" {
+			if tc.Args[0].Kind != OpSym {
+				// The physical zero-address call faults and has no continuation
+				// whose flags could be observed. Keep that real terminal effect.
+				emitted := c.b.String()[start:]
+				if !terminated || !strings.Contains(emitted, "\"blr $0\"") ||
+					!strings.Contains(emitted, "\"r,~{memory}\"(i64 0)\n  unreachable\n") {
+					t.Fatalf("%s lost its physical zero-address terminal call: terminated=%v IR=%s", tc.Raw, terminated, emitted)
+				}
+				continue
+			}
+			if terminated {
+				t.Fatalf("%s lost its actual symbol-call continuation", tc.Raw)
+			}
+			for _, op := range []Op{"BEQ", "BCC", "BMI", "BVS"} {
+				branch := Instr{Op: op, Args: []Operand{arm64IdentOp("done")}, Raw: string(op) + " done"}
+				handled, _, err := c.lowerBranch(1, op, branch, emitBr, emitCondBr)
+				if !handled || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s retained an unknown %s call's flags: handled=%v error=%v", op, tc.Raw, handled, err)
+				}
+			}
+		}
 	}
 
-	if tgt, ok := c.resolveBranchTarget(1, arm64MemOp(PC, -4)); !ok || tgt != c.blocks[1].name {
-		t.Fatalf("resolveBranchTarget(-4(PC)) = (%q, %v)", tgt, ok)
+	if tgt, ok := c.resolveBranchTarget(1, arm64MemOp(PC, -4)); ok {
+		t.Fatalf("unresolved -4(PC) was guessed as (%q, %v)", tgt, ok)
 	}
-	if tgt, ok := c.resolveBranchTarget(1, arm64MemOp(PC, 4)); !ok || tgt != c.blocks[2].name {
-		t.Fatalf("resolveBranchTarget(4(PC)) = (%q, %v)", tgt, ok)
+	if tgt, ok := c.resolveBranchTarget(1, arm64MemOp(PC, 4)); ok {
+		t.Fatalf("unresolved +4(PC) was guessed as (%q, %v)", tgt, ok)
 	}
 	if got, err := c.castI64RegToArg("9", I32); err != nil || got == "" {
 		t.Fatalf("castI64RegToArg(i32) = (%q, %v)", got, err)
@@ -627,7 +663,13 @@ func TestARM64FPOpsCoverage(t *testing.T) {
 			},
 		},
 	}
-	c, b := newARM64CtxWithFuncForTest(t, Func{}, sig, nil)
+	c, b := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{{
+		Op: "FMOVD",
+		Args: []Operand{
+			arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2"), arm64RegOp("F3"), arm64RegOp("F4"),
+		},
+	}}}, sig, nil)
+	c.targetTriple = "aarch64-unknown-linux-gnu"
 	check := func(kind string, ins Instr, ok bool, err error) {
 		t.Helper()
 		if err != nil {
@@ -653,27 +695,27 @@ func TestARM64FPOpsCoverage(t *testing.T) {
 	}
 
 	for _, ins := range []Instr{
-		{Op: "FMOVD", Args: []Operand{arm64SymOp("$1.5"), arm64RegOp("R0")}, Raw: "FMOVD $1.5, R0"},
-		{Op: "FMOVD", Args: []Operand{arm64SymOp("$0x10"), arm64FPOp(48)}, Raw: "FMOVD $0x10, ret+48(FP)"},
-		{Op: "FCMPD", Args: []Operand{arm64FPOp(0), arm64RegOp("R0")}, Raw: "FCMPD arg+0(FP), R0"},
-		{Op: "FCSELD", Args: []Operand{arm64IdentOp("EQ"), arm64FPOp(0), arm64FPOp(8), arm64RegOp("R1")}, Raw: "FCSELD EQ, arg+0(FP), arg+8(FP), R1"},
-		{Op: "FADDD", Args: []Operand{arm64FPOp(0), arm64RegOp("R1")}, Raw: "FADDD arg+0(FP), R1"},
-		{Op: "FSUBD", Args: []Operand{arm64FPOp(8), arm64RegOp("R1"), arm64RegOp("R2")}, Raw: "FSUBD arg+8(FP), R1, R2"},
-		{Op: "FMULD", Args: []Operand{arm64FPOp(16), arm64RegOp("R2")}, Raw: "FMULD arg+16(FP), R2"},
-		{Op: "FDIVD", Args: []Operand{arm64FPOp(24), arm64RegOp("R2"), arm64FPOp(48)}, Raw: "FDIVD arg+24(FP), R2, ret+48(FP)"},
-		{Op: "FMAXD", Args: []Operand{arm64FPOp(32), arm64RegOp("R2")}, Raw: "FMAXD arg+32(FP), R2"},
-		{Op: "FMIND", Args: []Operand{arm64FPOp(40), arm64RegOp("R2"), arm64RegOp("R3")}, Raw: "FMIND arg+40(FP), R2, R3"},
-		{Op: "FMADDD", Args: []Operand{arm64FPOp(0), arm64FPOp(8), arm64FPOp(16), arm64RegOp("R3")}, Raw: "FMADDD arg+0(FP), arg+8(FP), arg+16(FP), R3"},
-		{Op: "FMSUBD", Args: []Operand{arm64FPOp(8), arm64FPOp(16), arm64FPOp(24), arm64RegOp("R4")}, Raw: "FMSUBD arg+8(FP), arg+16(FP), arg+24(FP), R4"},
-		{Op: "FNMSUBD", Args: []Operand{arm64FPOp(16), arm64FPOp(24), arm64FPOp(32), arm64FPOp(56)}, Raw: "FNMSUBD arg+16(FP), arg+24(FP), arg+32(FP), ret+56(FP)"},
-		{Op: "FNMULD", Args: []Operand{arm64FPOp(0), arm64RegOp("R3")}, Raw: "FNMULD arg+0(FP), R3"},
-		{Op: "FNMULD", Args: []Operand{arm64FPOp(8), arm64FPOp(16), arm64RegOp("R4")}, Raw: "FNMULD arg+8(FP), arg+16(FP), R4"},
-		{Op: "FABSD", Args: []Operand{arm64RegOp("R4"), arm64FPOp(48)}, Raw: "FABSD R4, ret+48(FP)"},
-		{Op: "FRINTZD", Args: []Operand{arm64FPOp(0), arm64RegOp("R0")}, Raw: "FRINTZD arg+0(FP), R0"},
-		{Op: "FRINTMD", Args: []Operand{arm64FPOp(8), arm64RegOp("R1")}, Raw: "FRINTMD arg+8(FP), R1"},
-		{Op: "FRINTPD", Args: []Operand{arm64FPOp(16), arm64FPOp(56)}, Raw: "FRINTPD arg+16(FP), ret+56(FP)"},
-		{Op: "FCVTZSD", Args: []Operand{arm64FPOp(0), arm64RegOp("R2")}, Raw: "FCVTZSD arg+0(FP), R2"},
-		{Op: "SCVTFD", Args: []Operand{arm64RegOp("R2"), arm64RegOp("R3")}, Raw: "SCVTFD R2, R3"},
+		{Op: "FMOVD", Args: []Operand{arm64ImmOp(0), arm64RegOp("F0")}, Raw: "FMOVD $0, F0"},
+		{Op: "FMOVD", Args: []Operand{arm64RegOp("F0"), arm64FPOp(48)}, Raw: "FMOVD F0, ret+48(FP)"},
+		{Op: "FCMPD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1")}, Raw: "FCMPD F0, F1"},
+		{Op: "FCSELD", Args: []Operand{arm64IdentOp("EQ"), arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2")}, Raw: "FCSELD EQ, F0, F1, F2"},
+		{Op: "FADDD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1")}, Raw: "FADDD F0, F1"},
+		{Op: "FSUBD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2")}, Raw: "FSUBD F0, F1, F2"},
+		{Op: "FMULD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F2")}, Raw: "FMULD F0, F2"},
+		{Op: "FDIVD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F2"), arm64RegOp("F3")}, Raw: "FDIVD F0, F2, F3"},
+		{Op: "FMAXD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F2")}, Raw: "FMAXD F0, F2"},
+		{Op: "FMIND", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F2"), arm64RegOp("F3")}, Raw: "FMIND F0, F2, F3"},
+		{Op: "FMADDD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2"), arm64RegOp("F3")}, Raw: "FMADDD F0, F1, F2, F3"},
+		{Op: "FMSUBD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2"), arm64RegOp("F4")}, Raw: "FMSUBD F0, F1, F2, F4"},
+		{Op: "FNMSUBD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F2"), arm64RegOp("F4")}, Raw: "FNMSUBD F0, F1, F2, F4"},
+		{Op: "FNMULD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F3")}, Raw: "FNMULD F0, F3"},
+		{Op: "FNMULD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F1"), arm64RegOp("F4")}, Raw: "FNMULD F0, F1, F4"},
+		{Op: "FABSD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("F4")}, Raw: "FABSD F0, F4"},
+		{Op: "FRINTZD", Args: []Operand{arm64RegOp("F1"), arm64RegOp("F2")}, Raw: "FRINTZD F1, F2"},
+		{Op: "FRINTMD", Args: []Operand{arm64RegOp("F2"), arm64RegOp("F3")}, Raw: "FRINTMD F2, F3"},
+		{Op: "FRINTPD", Args: []Operand{arm64RegOp("F3"), arm64RegOp("F4")}, Raw: "FRINTPD F3, F4"},
+		{Op: "FCVTZSD", Args: []Operand{arm64RegOp("F0"), arm64RegOp("R2")}, Raw: "FCVTZSD F0, R2"},
+		{Op: "SCVTFD", Args: []Operand{arm64RegOp("R2"), arm64RegOp("F3")}, Raw: "SCVTFD R2, F3"},
 	} {
 		ok, _, err := c.lowerFP(ins.Op, ins)
 		check("lowerFP", ins, ok, err)
@@ -745,22 +787,22 @@ func TestARM64FPOpsCoverage(t *testing.T) {
 
 	out := b.String()
 	for _, want := range []string{
-		"fcmp oeq double",
-		"fcmp uno double",
+		"fcmp ${1:d}, ${2:d}",
+		"mrs $0, nzcv",
 		"select i1",
-		"fadd double",
-		"fsub double",
-		"fmul double",
-		"fdiv double",
-		"fneg double",
-		"@llvm.maxnum.f64",
-		"@llvm.minnum.f64",
+		"fadd ${0:d}, ${1:d}, ${2:d}",
+		"fsub ${0:d}, ${1:d}, ${2:d}",
+		"fmul ${0:d}, ${1:d}, ${2:d}",
+		"fdiv ${0:d}, ${1:d}, ${2:d}",
+		"fnmul ${0:d}, ${1:d}, ${2:d}",
+		`asm sideeffect "fmax ${0:d}`,
+		`asm sideeffect "fmin ${0:d}`,
 		"@llvm.fabs.f64",
 		"@llvm.trunc.f64",
 		"@llvm.floor.f64",
 		"@llvm.ceil.f64",
-		"fptosi double",
-		"sitofp i64",
+		"fcvtzs ${0:x}, ${1:d}",
+		"scvtf ${0:d}, ${1:x}",
 		"fpext float",
 		"ptrtoint ptr",
 		"bitcast i64",
@@ -780,7 +822,7 @@ func TestARM64BranchAndReturnEdgeCoverage(t *testing.T) {
 		},
 	}
 	var translated strings.Builder
-	if err := translateFuncARM64(&translated, fn, FuncSig{Name: "example.edge", Ret: I64}, testResolveSym("example"), nil, true); err != nil {
+	if err := translateFuncARM64(&translated, fn, FuncSig{Name: "example.edge", Ret: I64}, testResolveSym("example"), nil, nil, true); err != nil {
 		t.Fatalf("translateFuncARM64() error = %v", err)
 	}
 	if !strings.Contains(translated.String(), "ret i64 0") || !strings.Contains(translated.String(), "; s: NOP") {
@@ -823,19 +865,28 @@ func TestARM64BranchAndReturnEdgeCoverage(t *testing.T) {
 			},
 		},
 	}, nil)
-	if ok, _, err := cAgg.lowerData("MOVD", false, Instr{
-		Op:   "MOVD",
-		Args: []Operand{arm64ImmOp(21), arm64FPOp(8)},
-		Raw:  "MOVD $21, ret+8(FP)",
-	}); !ok || err != nil {
-		t.Fatalf("lowerData(MOVD ret+8) = (%v, %v)", ok, err)
-	}
-	if ok, _, err := cAgg.lowerData("MOVW", false, Instr{
-		Op:   "MOVW",
-		Args: []Operand{arm64ImmOp(7), arm64FPOp(16)},
-		Raw:  "MOVW $7, ret+16(FP)",
-	}); !ok || err != nil {
-		t.Fatalf("lowerData(MOVW ret+16) = (%v, %v)", ok, err)
+	// Nonzero immediate-to-memory MOV is not a Go assembler row. Preserve
+	// the same aggregate values using actual register-to-frame stores.
+	for _, invalid := range []string{"MOVD $21, ret+8(FP)", "MOVW $7, ret+16(FP)"} {
+		requireARM64GoAssemblerResult(t, "TEXT retagg(SB),516,$0-24\n"+invalid+"\nRET\n", false)
+	}
+	aggregateSource := `TEXT retagg(SB),516,$0-24
+MOVD $21,R0
+MOVD R0,ret+8(FP)
+MOVW $7,R1
+MOVW R1,ret+16(FP)
+RET
+`
+	requireARM64GoAssemblerResult(t, aggregateSource, true)
+	for _, ins := range []Instr{
+		{Op: "MOVD", Args: []Operand{arm64ImmOp(21), arm64RegOp("R0")}, Raw: "MOVD $21,R0"},
+		{Op: "MOVD", Args: []Operand{arm64RegOp("R0"), arm64FPOp(8)}, Raw: "MOVD R0,ret+8(FP)"},
+		{Op: "MOVW", Args: []Operand{arm64ImmOp(7), arm64RegOp("R1")}, Raw: "MOVW $7,R1"},
+		{Op: "MOVW", Args: []Operand{arm64RegOp("R1"), arm64FPOp(16)}, Raw: "MOVW R1,ret+16(FP)"},
+	} {
+		if ok, _, err := cAgg.lowerData(ins.Op, false, ins); !ok || err != nil {
+			t.Fatalf("lowerData(%s) = (%v, %v)", ins.Raw, ok, err)
+		}
 	}
 	if err := cAgg.lowerRET(); err != nil {
 		t.Fatalf("lowerRET(aggregate) error = %v", err)
@@ -852,8 +903,8 @@ func TestARM64BranchAndReturnEdgeCoverage(t *testing.T) {
 
 	sigs := map[string]FuncSig{
 		"example.structSink": {Name: "example.structSink", Args: []LLVMType{LLVMType("{ i32, i64 }")}, Ret: Void},
-		"example.badarg":     {Name: "example.badarg", Args: []LLVMType{LLVMType("double")}, Ret: Void},
-		"example.badret":     {Name: "example.badret", Args: []LLVMType{I64}, Ret: LLVMType("double")},
+		"example.badarg":     {Name: "example.badarg", Args: []LLVMType{LLVMType("<2 x i64>")}, Ret: Void},
+		"example.badret":     {Name: "example.badret", Args: []LLVMType{I64}, Ret: LLVMType("<2 x i64>")},
 		"example.aggregate":  {Name: "example.aggregate", Ret: LLVMType("{ ptr, i64 }")},
 		"example.voidsame":   {Name: "example.voidsame", Args: []LLVMType{I64}, Ret: Void},
 		"example.badtailret": {Name: "example.badtailret", Args: []LLVMType{I64}, Ret: LLVMType("double")},
@@ -951,8 +1002,71 @@ func TestARM64FPEdgeErrors(t *testing.T) {
 	}
 }
 
+func TestARM64TailCallReturnIntegerWidths(t *testing.T) {
+	integerTypes := []LLVMType{I1, I8, I16, I32, I64}
+	for _, calleeType := range integerTypes {
+		for _, callerType := range integerTypes {
+			if calleeType == callerType {
+				continue
+			}
+			name := fmt.Sprintf("%s_to_%s", calleeType, callerType)
+			t.Run(name, func(t *testing.T) {
+				callee := "example.return_" + name
+				c, b := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{
+					Name: "example.caller_" + name,
+					Ret:  callerType,
+				}, map[string]FuncSig{
+					callee: {Name: callee, Ret: calleeType},
+				})
+				if err := c.tailCallAndRet(arm64SymOp(callee + "(SB)")); err != nil {
+					t.Fatalf("tailCallAndRet(%s -> %s) error = %v", calleeType, callerType, err)
+				}
+				conversion := "zext"
+				calleeBits, _ := armIntegerTypeWidth(calleeType)
+				callerBits, _ := armIntegerTypeWidth(callerType)
+				if calleeBits > callerBits {
+					conversion = "trunc"
+				}
+				for _, want := range []string{
+					fmt.Sprintf("%s %s", conversion, calleeType),
+					fmt.Sprintf("to %s", callerType),
+					fmt.Sprintf("ret %s %%", callerType),
+				} {
+					if !strings.Contains(b.String(), want) {
+						t.Fatalf("tailCallAndRet(%s -> %s) missing %q:\n%s", calleeType, callerType, want, b.String())
+					}
+				}
+			})
+		}
+	}
+
+	for _, tc := range []struct {
+		name       string
+		calleeType LLVMType
+		callerType LLVMType
+		conversion string
+	}{
+		{name: "pointer_to_integer", calleeType: Ptr, callerType: I64, conversion: "ptrtoint ptr"},
+		{name: "integer_to_pointer", calleeType: I64, callerType: Ptr, conversion: "inttoptr i64"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			callee := "example." + tc.name
+			c, b := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.caller_" + tc.name, Ret: tc.callerType}, map[string]FuncSig{
+				callee: {Name: callee, Ret: tc.calleeType},
+			})
+			if err := c.tailCallAndRet(arm64SymOp(callee + "(SB)")); err != nil {
+				t.Fatalf("tailCallAndRet(%s -> %s) error = %v", tc.calleeType, tc.callerType, err)
+			}
+			if got := b.String(); !strings.Contains(got, tc.conversion) || !strings.Contains(got, fmt.Sprintf("ret %s %%", tc.callerType)) {
+				t.Fatalf("tailCallAndRet(%s -> %s) output:\n%s", tc.calleeType, tc.callerType, got)
+			}
+		})
+	}
+}
+
 func TestARM64SyscallCoverage(t *testing.T) {
 	c, b := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.syscall", Ret: Void}, nil)
+	c.targetTriple = "aarch64-unknown-linux-gnu"
 	for _, tc := range []struct {
 		r Reg
 		v string
@@ -971,11 +1085,12 @@ func TestARM64SyscallCoverage(t *testing.T) {
 		}
 	}
 
-	if ok, term, err := c.lowerSyscall("SVC", Instr{Raw: "SVC", Args: nil}); !ok || term || err != nil {
+	if ok, term, err := c.lowerSyscall("SVC", Instr{Op: "SVC", Raw: "SVC", Args: nil}); !ok || term || err != nil {
 		t.Fatalf("lowerSyscall(linux) = (%v, %v, %v)", ok, term, err)
 	}
 
 	darwin, db := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.darwin", Ret: Void}, nil)
+	darwin.targetTriple = "aarch64-apple-darwin"
 	delete(darwin.regSlot, Reg("R8"))
 	for _, tc := range []struct {
 		r Reg
@@ -993,7 +1108,7 @@ func TestARM64SyscallCoverage(t *testing.T) {
 			t.Fatalf("darwin storeReg(%s) error = %v", tc.r, err)
 		}
 	}
-	if ok, term, err := darwin.lowerSyscall("SVC", Instr{Raw: "SVC $0x80", Args: []Operand{{Kind: OpImm, Imm: 0x80}}}); !ok || term || err != nil {
+	if ok, term, err := darwin.lowerSyscall("SVC", Instr{Op: "SVC", Raw: "SVC $0x80", Args: []Operand{{Kind: OpImm, Imm: 0x80}}}); !ok || term || err != nil {
 		t.Fatalf("lowerSyscall(darwin) = (%v, %v, %v)", ok, term, err)
 	}
 	if _, _, err := c.lowerSyscall("SVC", Instr{Raw: "SVC R0", Args: []Operand{{Kind: OpReg, Reg: "R0"}}}); err == nil {
@@ -1009,7 +1124,7 @@ func TestARM64SyscallCoverage(t *testing.T) {
 		"@cliteErrno()",
 		"sub i64 0",
 		"store i1 %t",
-		"store i1 false, ptr %flags_v",
+		"ptr %flags_c",
 	} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
@@ -1072,7 +1187,7 @@ func TestARM64ArithmeticErrorCoverage(t *testing.T) {
 		{Op: "MUL", Raw: "MUL $1", Args: []Operand{arm64ImmOp(1)}},
 		{Op: "MUL", Raw: "MUL $1, label", Args: []Operand{arm64ImmOp(1), arm64IdentOp("label")}},
 		{Op: "MUL", Raw: "MUL $1, R0, label", Args: []Operand{arm64ImmOp(1), arm64RegOp("R0"), arm64IdentOp("label")}},
-		{Op: "UMULH", Raw: "UMULH R0, R1", Args: []Operand{arm64RegOp("R0"), arm64RegOp("R1")}},
+		{Op: "UMULH", Raw: "UMULH R0", Args: []Operand{arm64RegOp("R0")}},
 		{Op: "MADDW", Raw: "MADDW R0, R1, R2", Args: []Operand{arm64RegOp("R0"), arm64RegOp("R1"), arm64RegOp("R2")}},
 		{Op: "MADDW", Raw: "MADDW label, R1, R2, R3", Args: []Operand{arm64IdentOp("label"), arm64RegOp("R1"), arm64RegOp("R2"), arm64RegOp("R3")}},
 		{Op: "MADDW", Raw: "MADDW R0, label, R2, R3", Args: []Operand{arm64RegOp("R0"), arm64IdentOp("label"), arm64RegOp("R2"), arm64RegOp("R3")}},
@@ -1245,19 +1360,18 @@ func TestARM64VectorEdgeCoverage(t *testing.T) {
 		}
 	}
 
-	check("VLD1R", false, Instr{Op: "VLD1R", Raw: "VLD1R (R20), V0"})
 	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV R0, V0.S4", Args: []Operand{arm64RegOp("R0"), arm64RegOp("V0.S4")}})
 	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV V0.S[2], R3", Args: []Operand{arm64RegOp("V0.S[2]"), arm64RegOp("R3")}})
 	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV V1.H[4], R4", Args: []Operand{arm64RegOp("V1.H[4]"), arm64RegOp("R4")}})
 	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV V2.B[7], R5", Args: []Operand{arm64RegOp("V2.B[7]"), arm64RegOp("R5")}})
-	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV V2, R0", Args: []Operand{arm64RegOp("V2"), arm64RegOp("R0")}})
-	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), V3.D[1]", Args: []Operand{arm64MemOp("R20", 0), arm64RegOp("V3.D[1]")}})
-	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), V4.S[1]", Args: []Operand{arm64MemOp("R20", 0), arm64RegOp("V4.S[1]")}})
-	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), V5.H[3]", Args: []Operand{arm64MemOp("R20", 0), arm64RegOp("V5.H[3]")}})
-	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), [V6]", Args: []Operand{arm64MemOp("R20", 0), arm64RegListOp("V6")}})
-	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), [V7, V8, V9]", Args: []Operand{arm64MemOp("R20", 0), arm64RegListOp("V7", "V8", "V9")}})
-	check("VST1", true, Instr{Op: "VST1.P", Raw: "VST1.P [V0], (R20)", Args: []Operand{arm64RegListOp("V0"), arm64MemOp("R20", 0)}})
-	check("VST1", true, Instr{Op: "VST1.P", Raw: "VST1.P [V1, V2, V3], (R20)", Args: []Operand{arm64RegListOp("V1", "V2", "V3"), arm64MemOp("R20", 0)}})
+	check("VMOV", false, Instr{Op: "VMOV", Raw: "VMOV V2.D[0], R0", Args: []Operand{arm64RegOp("V2.D[0]"), arm64RegOp("R0")}})
+	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P 8(R20), V3.D[1]", Args: []Operand{arm64MemOp("R20", 8), arm64RegOp("V3.D[1]")}})
+	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P 4(R20), V4.S[1]", Args: []Operand{arm64MemOp("R20", 4), arm64RegOp("V4.S[1]")}})
+	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P 2(R20), V5.H[3]", Args: []Operand{arm64MemOp("R20", 2), arm64RegOp("V5.H[3]")}})
+	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), [V6.B16]", Args: []Operand{arm64MemOp("R20", 0), arm64RegListOp("V6.B16")}})
+	check("VLD1", true, Instr{Op: "VLD1.P", Raw: "VLD1.P (R20), [V7.B16, V8.B16, V9.B16]", Args: []Operand{arm64MemOp("R20", 0), arm64RegListOp("V7.B16", "V8.B16", "V9.B16")}})
+	check("VST1", true, Instr{Op: "VST1.P", Raw: "VST1.P [V0.B16], (R20)", Args: []Operand{arm64RegListOp("V0.B16"), arm64MemOp("R20", 0)}})
+	check("VST1", true, Instr{Op: "VST1.P", Raw: "VST1.P [V1.B16, V2.B16, V3.B16], (R20)", Args: []Operand{arm64RegListOp("V1.B16", "V2.B16", "V3.B16"), arm64MemOp("R20", 0)}})
 
 	for _, tc := range []Instr{
 		{Op: "VMOV", Raw: "VMOV R0", Args: []Operand{arm64RegOp("R0")}},
@@ -1310,12 +1424,12 @@ func TestARM64BranchErrorCoverage(t *testing.T) {
 	sigs := map[string]FuncSig{
 		"example.ret8":        {Name: "example.ret8", Args: []LLVMType{I64}, Ret: I8},
 		"example.retptr":      {Name: "example.retptr", Args: []LLVMType{I64}, Ret: Ptr},
-		"example.badarg":      {Name: "example.badarg", Args: []LLVMType{LLVMType("double")}, Ret: Void},
-		"example.badret":      {Name: "example.badret", Args: []LLVMType{I64}, Ret: LLVMType("double")},
+		"example.badarg":      {Name: "example.badarg", Args: []LLVMType{LLVMType("<2 x i64>")}, Ret: Void},
+		"example.badret":      {Name: "example.badret", Args: []LLVMType{I64}, Ret: LLVMType("<2 x i64>")},
 		"example.badagg":      {Name: "example.badagg", Args: []LLVMType{LLVMType("{ i32, double }")}, Ret: Void},
 		"example.badargreg":   {Name: "example.badargreg", Args: []LLVMType{I64}, ArgRegs: []Reg{"BAD"}, Ret: Void},
 		"example.casttail":    {Name: "example.casttail", Args: []LLVMType{I32, I64, I64, Ptr}, Ret: I64},
-		"example.badtailtype": {Name: "example.badtailtype", Args: []LLVMType{LLVMType("double")}, ArgRegs: []Reg{"R0"}, Ret: I64},
+		"example.badtailtype": {Name: "example.badtailtype", Args: []LLVMType{LLVMType("<2 x i64>")}, ArgRegs: []Reg{"R0"}, Ret: I64},
 		"example.structtail":  {Name: "example.structtail", Args: []LLVMType{LLVMType("{ i32, i64 }")}, Ret: I64},
 		"example.badtailreg":  {Name: "example.badtailreg", Args: []LLVMType{LLVMType("double")}, ArgRegs: []Reg{"BAD"}, Ret: I64},
 		"example.voidsink2":   {Name: "example.voidsink2", Args: []LLVMType{I64}, Ret: Void},
@@ -1340,11 +1454,11 @@ func TestARM64BranchErrorCoverage(t *testing.T) {
 	emitBr := arm64TestEmitBr(c)
 	emitCondBr := arm64TestEmitCondBr(c)
 
-	if tgt, ok := c.resolveBranchTarget(2, arm64MemOp(PC, 4)); !ok || tgt != c.blocks[2].name {
-		t.Fatalf("resolveBranchTarget(last,+4) = (%q, %v)", tgt, ok)
+	if tgt, ok := c.resolveBranchTarget(2, arm64MemOp(PC, 4)); ok {
+		t.Fatalf("unresolved +4(PC) was guessed as (%q, %v)", tgt, ok)
 	}
-	if tgt, ok := c.resolveBranchTarget(0, arm64MemOp(PC, 0)); !ok || tgt != c.blocks[0].name {
-		t.Fatalf("resolveBranchTarget(0(PC)) = (%q, %v)", tgt, ok)
+	if tgt, ok := c.resolveBranchTarget(0, arm64MemOp(PC, 0)); ok {
+		t.Fatalf("unresolved 0(PC) was guessed as (%q, %v)", tgt, ok)
 	}
 	if _, ok := c.resolveBranchTarget(0, arm64ImmOp(1)); ok {
 		t.Fatalf("resolveBranchTarget($1) unexpectedly succeeded")
@@ -1477,10 +1591,11 @@ func TestARM64BranchErrorCoverage(t *testing.T) {
 		t.Fatalf("tailCallAndRet(casttail) error = %v", err)
 	}
 	for _, want := range []string{
-		"trunc i64 %t3 to i32",
+		"trunc i64",
+		"to i32",
 		"load i64, ptr %reg_R1",
 		"load i64, ptr %reg_R2",
-		"inttoptr i64 %t7 to ptr",
+		"inttoptr i64",
 	} {
 		if !strings.Contains(bTailCast.String(), want) {
 			t.Fatalf("tailCallAndRet(casttail) missing %q:\n%s", want, bTailCast.String())
@@ -1721,8 +1836,8 @@ func TestARM64EvalCoverage(t *testing.T) {
 			t.Fatalf("eval64(%s) = (%q, %v)", op.String(), got, err)
 		}
 	}
-	if got, err := c.eval64(Operand{Kind: OpFPAddr, FPOffset: 88}, false); err != nil || got != "0" {
-		t.Fatalf("eval64(missing fpaddr) = (%q, %v)", got, err)
+	if got, err := c.eval64(Operand{Kind: OpFPAddr, FPOffset: 88}, false); !errors.Is(err, ErrProbeNeedsContext) || got != "" {
+		t.Fatalf("eval64(missing fpaddr) = (%q, %v), want unbound frame context", got, err)
 	}
 	if _, err := c.eval64(Operand{Kind: OpRegShift, Reg: "R1", ShiftOp: ShiftRotate, ShiftReg: "R2"}, false); err == nil {
 		t.Fatalf("eval64(register shift) unexpectedly succeeded")
@@ -1752,18 +1867,20 @@ func TestARM64EvalCoverage(t *testing.T) {
 		t.Fatalf("eval64(bad field type) unexpectedly succeeded")
 	}
 
-	cBadIndex, _ := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{
+	badIndexSig := FuncSig{
 		Name: "example.badidx",
 		Args: []LLVMType{I64},
 		Ret:  Void,
 		Frame: FrameLayout{
 			Params: []FrameSlot{{Offset: 0, Type: I64, Index: 2}},
 		},
-	}, nil)
-	if _, err := cBadIndex.eval64(Operand{Kind: OpFP, FPOffset: 0}, false); err == nil {
-		t.Fatalf("eval64(bad fp index) unexpectedly succeeded")
 	}
-	if _, err := cBadIndex.eval64(Operand{Kind: OpMem, Mem: MemRef{Base: "BAD"}}, false); err == nil {
+	var badIndexOutput strings.Builder
+	cBadIndex := newARM64Ctx(&badIndexOutput, Func{}, badIndexSig, testResolveSym("example"), nil, false)
+	if err := cBadIndex.emitEntryAllocasAndArgInit(); err == nil {
+		t.Fatalf("entry initialization with bad FP argument index unexpectedly succeeded")
+	}
+	if _, err := c.eval64(Operand{Kind: OpMem, Mem: MemRef{Base: "BAD"}}, false); err == nil {
 		t.Fatalf("eval64(bad mem base) unexpectedly succeeded")
 	}
 
diff --git a/arm64_instruction_probe.go b/arm64_instruction_probe.go
new file mode 100644
index 000000000..ce36c1868
--- /dev/null
+++ b/arm64_instruction_probe.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+import "fmt"
+
+// The isolated coverage harness owns this source identity. It is not the
+// original function's frame or a declaration of its native encoder layout.
+// Its instructions end with B (ZR), never an executable caller-return claim.
+const arm64InstructionProbeTEXT = "TEXT plan9asm_probe(SB),516,$0-0\n"
+
+func arm64InstructionProbeFunc(instrs []Instr) (Func, error) {
+	for _, ins := range instrs {
+		if ins.Op == OpTEXT {
+			return Func{}, fmt.Errorf("%w: isolated ARM64 probes cannot replace their compile-only TEXT fixture", ErrProbeNeedsContext)
+		}
+	}
+	fixture, err := Parse(ArchARM64, arm64InstructionProbeTEXT)
+	if err != nil {
+		return Func{}, fmt.Errorf("parse ARM64 instruction probe TEXT fixture: %w", err)
+	}
+	fn := fixture.Funcs[0]
+	// Keep the caller's actual operand/source representation and private
+	// decoder markers. Parsing the fixed header never decodes a named pseudo
+	// instruction or reconstructs operands from its diagnostic Raw text.
+	fn.Instrs = append(fn.Instrs, instrs...)
+	return fn, nil
+}
diff --git a/arm64_lane_decimal_token_runtime_test.go b/arm64_lane_decimal_token_runtime_test.go
new file mode 100644
index 000000000..390437645
--- /dev/null
+++ b/arm64_lane_decimal_token_runtime_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64LaneDecimalTokens(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	decl, original, source := arm64LaneTokenProgram()
+	pkg := mustGoPackage(t, "test/lanetokenruntime", "package tokenruntime\n"+decl)
+	result, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer result.Module.Dispose()
+
+	var goChecks, cDecl, cChecks strings.Builder
+	number := 0
+	for _, tc := range arm64LaneTokenCases() {
+		if !tc.accepted {
+			continue
+		}
+		for form := 0; form < 3; form++ {
+			fmt.Fprintf(&cDecl, "extern uint64_t Token%d(uint64_t);\n", number)
+			goWant, cWant := "a & 255", "a & UINT64_C(255)"
+			if form == 2 {
+				goWant = "repeated"
+				cWant = "(a & UINT64_C(255)) * UINT64_C(0x0101010101010101)"
+			}
+			fmt.Fprintf(&goChecks, "    if got := Token%d(a); got != %s { panic(\"Go lane-token case %d\") }\n", number, goWant, number)
+			fmt.Fprintf(&cChecks, "        if (Token%d(a) != (%s)) { fprintf(stderr, \"LLVM lane-token case %d input %%u\\n\",i); return 1; }\n", number, cWant, number)
+			number++
+		}
+	}
+	if number != 27 {
+		t.Fatalf("accepted-function denominator changed: %d", number)
+	}
+	goMain := "package main\n" + decl + `
+func main() {
+    for _, a := range []uint64{0, 1, 0x123456789abcdef0, 0x8000000000000000, ^uint64(0)} {
+        var repeated uint64
+        for shift := uint(0); shift < 64; shift += 8 {
+            repeated |= (a & 255) << shift
+        }
+` + goChecks.String() + `
+    }
+}
+`
+	// Same lane instructions, explicitly distinct ordinary-Go and translated
+	// register transports. This does not certify any external native caller.
+	runARM64LocalRegisterGoOracle(t, original, goMain, len(runner) != 0, "1.20")
+	cMain := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + `
+int main(void) {
+    const uint64_t inputs[] = {0, 1, UINT64_C(0x123456789abcdef0),
+        UINT64_C(0x8000000000000000), UINT64_MAX};
+    const volatile uint64_t canary = UINT64_C(0x8718369423719654);
+    for (unsigned i = 0; i < 5; i++) {
+        uint64_t a = inputs[i];
+` + cChecks.String() + `
+    }
+    if (canary != UINT64_C(0x8718369423719654)) return 2;
+    return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "lane_decimal_token", triple, result.Module.String(), cMain, runner)
+}
diff --git a/arm64_lane_decimal_token_test.go b/arm64_lane_decimal_token_test.go
new file mode 100644
index 000000000..e8050fd92
--- /dev/null
+++ b/arm64_lane_decimal_token_test.go
@@ -0,0 +1,294 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64LaneTokenDecimalDecoderMatchesGoLimits(t *testing.T) {
+	for _, tc := range []struct {
+		source string
+		value  int
+		valid  bool
+	}{
+		{source: "0", valid: true},
+		{source: "00015", value: 15, valid: true},
+		{source: " 17\t", value: 17, valid: true},
+		{source: "32767", value: 32767, valid: true},
+		{source: "32768"},
+		{source: "999999999999999999999999999999"},
+		{source: ""},
+		{source: " \t"},
+		{source: "+0"},
+		{source: "-0"},
+		{source: "0xf"},
+		{source: "0_1"},
+		{source: "1+1"},
+		{source: "(1<<3)"},
+		{source: "1 5"},
+		{source: "١"},
+		{source: "１"},
+		{source: "LANE"},
+	} {
+		t.Run(tc.source, func(t *testing.T) {
+			value, valid := arm64ParseLaneDecimalToken(tc.source)
+			if valid != tc.valid || valid && value != tc.value {
+				t.Fatalf("decimal token %q: (%d,%v), want (%d,%v)", tc.source, value, valid, tc.value, tc.valid)
+			}
+		})
+	}
+}
+
+func TestARM64LaneTokenRejectedFormatsFailEveryAPI(t *testing.T) {
+	pkg := mustGoPackage(t, "test/lanetokennegative", "package tokennegative\nfunc Pass(uint64) uint64\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	base, err := translateGoModuleInContext(ctx, pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\nRET\n"),
+		GoModuleOptions{GOARCH: "arm64", ResolveSym: testResolveSym(pkg.Path)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer base.Module.Dispose()
+	options := Options{Goarch: "arm64", Sigs: base.Signatures, ResolveSym: testResolveSym(pkg.Path)}
+	for _, tc := range arm64LaneTokenCases() {
+		if tc.accepted {
+			continue
+		}
+		for form := 0; form < 3; form++ {
+			t.Run(fmt.Sprintf("%s/%d", tc.name, form), func(t *testing.T) {
+				source := tc.prefix + "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nVDUP R0,V21.B16\n" +
+					arm64LaneTokenInstruction(form, tc.index) + "\nRET\n"
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, options); err == nil {
+					t.Fatal("text API accepted a Go-rejected index")
+				}
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					module.Dispose()
+				}
+				if err == nil {
+					t.Fatal("module API accepted a Go-rejected index")
+				}
+				result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", ResolveSym: testResolveSym(pkg.Path)})
+				if result != nil {
+					result.Module.Dispose()
+				}
+				if err == nil {
+					t.Fatal("Go-module API accepted a Go-rejected index")
+				}
+			})
+		}
+	}
+}
+
+type arm64LaneTokenCase struct {
+	name, prefix, index string
+	value               int
+	accepted            bool
+}
+
+func arm64LaneTokenCases() []arm64LaneTokenCase {
+	return []arm64LaneTokenCase{
+		{name: "decimal", index: "15", value: 15, accepted: true},
+		{name: "hex", index: "0xf"},
+		{name: "octal-looking", index: "017"},
+		{name: "leading-zero-decimal", index: "015", value: 15, accepted: true},
+		{name: "plus", index: "+15"},
+		{name: "sum", index: "1+1"},
+		{name: "shift", index: "(1<<3)"},
+		{name: "spaces", index: " 15 ", value: 15, accepted: true},
+		{name: "tabs", index: "\t15\t", value: 15, accepted: true},
+		{name: "zero", index: "0", accepted: true},
+		{name: "plus-zero", index: "+0"},
+		{name: "negative-zero", index: "-0"},
+		{name: "underscores", index: "0_1"},
+		{name: "macro-decimal", prefix: "#define LANE 15\n", index: "LANE", value: 15, accepted: true},
+		{name: "macro-alias", prefix: "#define INDEX 15\n#define LANE INDEX\n", index: "LANE", value: 15, accepted: true},
+		{name: "macro-function", prefix: "#define LANE(x) x\n", index: "LANE(15)", value: 15, accepted: true},
+		{name: "macro-space", prefix: "#define LANE  15 \n", index: "LANE", value: 15, accepted: true},
+		{name: "macro-parenthesis", prefix: "#define LANE (15)\n", index: "LANE"},
+		{name: "macro-hex", prefix: "#define LANE 0xf\n", index: "LANE"},
+		{name: "macro-expression", prefix: "#define LANE 1+1\n", index: "LANE"},
+		{name: "named-unbound", index: "LANE"},
+		{name: "named-assignment", prefix: "LANE = 15\n", index: "LANE"},
+	}
+}
+
+func arm64LaneTokenInstruction(form int, index string) string {
+	switch form {
+	case 0:
+		return fmt.Sprintf("VMOV R0,V21.B[%s]", index)
+	case 1:
+		return fmt.Sprintf("VMOV V21.B[%s],R0", index)
+	default:
+		return fmt.Sprintf("VDUP V21.D[%s],V22.B16", index)
+	}
+}
+
+func arm64LaneTokenBody(tc arm64LaneTokenCase, form int) string {
+	instruction := arm64LaneTokenInstruction(form, tc.index)
+	switch form {
+	case 0:
+		return instruction + fmt.Sprintf("\nVMOV V21.B[%d],R0\n", tc.value)
+	case 1:
+		return fmt.Sprintf("VMOV R0,V21.B[%d]\n", tc.value) + instruction + "\n"
+	default:
+		return fmt.Sprintf("VMOV R0,V21.B[%d]\n", tc.value) + instruction + "\nVMOV V22.D[0],R0\n"
+	}
+}
+
+func TestARM64LaneTokenActualGoAndTypedGrammar(t *testing.T) {
+	// Each SDK actually assembles all 66 formats. Go's registerExtension
+	// consumes scanner.Int then ParseInt(base 10, bits 16), not p.expr().
+	for _, tc := range arm64LaneTokenCases() {
+		for form := 0; form < 3; form++ {
+			t.Run(fmt.Sprintf("%s/%d", tc.name, form), func(t *testing.T) {
+				instruction := arm64LaneTokenInstruction(form, tc.index)
+				source := tc.prefix + "TEXT token(SB),4,$0-0\n" + instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, "arm64", source, "", tc.accepted)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					if tc.accepted {
+						t.Fatal(err)
+					}
+					return
+				}
+				found := false
+				for _, ins := range file.Funcs[0].Instrs {
+					if ins.Op != "VMOV" && ins.Op != "VDUP" {
+						continue
+					}
+					found = true
+					_, err := parseARM64VectorTransfer(ins.Op, ins)
+					if (err == nil) != tc.accepted {
+						t.Errorf("typed lane format disagrees with actual Go: %s: %v", instruction, err)
+					}
+				}
+				if !found {
+					t.Fatal("fixture did not retain its instruction")
+				}
+				body := tc.prefix + "VDUP R0,V21.B16\n" + instruction + "\n"
+				if form == 2 {
+					body += "VMOV V22.D[0],R0\n"
+				} else {
+					body += "VMOV V21.D[0],R0\n"
+				}
+				_, err = arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", body+"RET\n")
+				if (err == nil) != tc.accepted {
+					t.Errorf("full typed translation disagrees with actual Go: %s: %v", instruction, err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64LaneTokenCannotChangePhysicalSpanOrBank(t *testing.T) {
+	for _, kind := range []string{"B", "H", "S", "D"} {
+		bits := map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[kind]
+		limit := 128 / bits
+		for _, index := range []string{" +0 ", " -0 ", fmt.Sprint(limit), "32768", "١", "１", "1 5"} {
+			instruction := fmt.Sprintf("VMOV R0,V21.%s[%s]", kind, index)
+			t.Run(instruction, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "arm64", "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+				if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", instruction+"\nRET\n"); err == nil {
+					t.Fatal("invalid lexical index or lane bound acquired authority")
+				}
+			})
+		}
+		index := fmt.Sprintf("\t%03d ", limit-1)
+		body := fmt.Sprintf("VMOV R0,V21.%s[%s]\nVMOV V21.%s[%s],R0\nRET\n", kind, index, kind, index)
+		arm64ImmediateOriginalGoBytes(t, "TEXT valid(SB),4,$0-0\n"+body, "linux")
+		if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", body); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, instruction := range []string{
+		"VMOV R0,V32.B[ 0 ]", "VMOV R0,V21.Q[ 0 ]",
+		"VMOV V21.D[ 15 ],R0", "VDUP V21.D[ 15 ],V22",
+	} {
+		goAssemblerOracleOutput(t, "arm64", "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+		if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", instruction+"\nRET\n"); err == nil {
+			t.Fatalf("lexical decoder replaced an independent bank/width bound: %s", instruction)
+		}
+	}
+	// Unknown input bytes and CFG joins remain independent of legal syntax.
+	for _, body := range []string{
+		"VMOV R0,V21.D[ 0 ]\nVMOV V21.D[ 1 ],R0\nRET\n",
+		"VMOV R9,V21.D[ 0 ]\nVMOV V21.D[ 0 ],R0\nRET\n",
+		"CBZ R0,join\nVMOV R0,V21.D[ 0 ]\njoin:\nVMOV V21.D[ 0 ],R0\nRET\n",
+	} {
+		if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", body); err == nil {
+			t.Fatal("legal whitespace supplied unknown input bits")
+		}
+	}
+}
+
+func arm64LaneTokenProgram() (declarations, ordinary, internal string) {
+	var decl, abi0, reg strings.Builder
+	number := 0
+	for _, tc := range arm64LaneTokenCases() {
+		if !tc.accepted {
+			continue
+		}
+		for form := 0; form < 3; form++ {
+			name := fmt.Sprintf("Token%d", number)
+			number++
+			// cmd/asm rejects even identical macro redefinitions. Each program
+			// function keeps the fixture's original expansion shape with unique
+			// names, rather than changing replacement tokens or sharing state.
+			local := tc
+			replace := strings.NewReplacer("LANE", name+"_LANE", "INDEX", name+"_INDEX")
+			local.prefix, local.index = replace.Replace(tc.prefix), replace.Replace(tc.index)
+			fmt.Fprintf(&decl, "func %s(uint64) uint64\n", name)
+			fmt.Fprintf(&abi0, "%sTEXT ·%s(SB),4,$0-16\nMOVD a+0(FP),R0\n%sMOVD R0,ret+8(FP)\nRET\n", local.prefix, name, arm64LaneTokenBody(local, form))
+			fmt.Fprintf(&reg, "%sTEXT ·%s<ABIInternal>(SB),4,$0-16\n%sRET\n", local.prefix, name, arm64LaneTokenBody(local, form))
+		}
+	}
+	return decl.String(), abi0.String(), reg.String()
+}
+
+func TestARM64LaneTokenAllAPIsAndFiveLLVMObjects(t *testing.T) {
+	decl, ordinary, source := arm64LaneTokenProgram()
+	if bytes := arm64ImmediateOriginalGoBytes(t, ordinary, "linux"); len(bytes) < 27*12 {
+		t.Fatal("original Go object omitted accepted format functions")
+	}
+	pkg := mustGoPackage(t, "test/lanetoken", "package lanetoken\n"+decl)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc missing")
+	}
+	for _, target := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: testResolveSym(pkg.Path)})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer result.Module.Dispose()
+			options := Options{Goarch: "arm64", TargetTriple: target, Sigs: result.Signatures, ResolveSym: testResolveSym(pkg.Path)}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			for api, text := range []string{result.Module.String(), ir, module.String()} {
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("token-%d.ll", api), fmt.Sprintf("token-%d.o", api), text)
+			}
+		})
+	}
+}
diff --git a/arm64_large_frame_availability_test.go b/arm64_large_frame_availability_test.go
new file mode 100644
index 000000000..54739b976
--- /dev/null
+++ b/arm64_large_frame_availability_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64CheckedR20EntryUnknownGPDoesNotBecomeDefined(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc Value(uint64) uint64\n")
+	for _, tc := range []struct{ name, body string }{
+		{"copy", "MOVD R12,R20\nMOVD R20,R0"},
+		{"arithmetic", "ADD $7,R12,R20\nMOVD R20,R0"},
+		{"discarded_copy", "MOVD R12,R20\nMOVD $7,R20\nMOVD R20,R0"},
+		{"join", "MOVD arg+0(FP),R8\nCBZ R8,other\nMOVD R12,R20\nB joined\nother:\nMOVD $7,R20\njoined:\nMOVD R20,R0"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := "TEXT ·Value(SB),4,$496-16\n" + tc.body + "\nMOVD R0,ret+8(FP)\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			arm64LargeFrameCheckAPIs(t, source, pkg, nil, true, false)
+		})
+	}
+}
+
+func TestARM64CheckedR20SoftwareValuesAndTypedFPLoads(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc Value(uint64) uint64\n")
+	for _, text := range []string{
+		"TEXT ·Value(SB),4,$496-16",
+		"TEXT ·Value(SB),4,$224-16",
+		"TEXT ·Value(SB),4,$8-16",
+		"TEXT ·Value(SB),4,$0-16",
+		"TEXT ·Value(SB),516,$0-16",
+	} {
+		for _, body := range []string{
+			"MOVD $7,R20",
+			"MOVD arg+0(FP),R20",
+			"MOVD arg+0(FP),R8\nADD $7,R8,R20",
+		} {
+			t.Run(fmt.Sprintf("%s/%s", text, body), func(t *testing.T) {
+				source := text + "\n" + body + "\nMOVD R20,ret+8(FP)\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				arm64LargeFrameCheckAPIs(t, source, pkg, nil, false, true)
+			})
+		}
+	}
+}
+
+func TestARM64CheckedR20SmallAndNoFrameHaveNoImplicitProducer(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc Value(uint64) uint64\n")
+	for _, text := range []string{
+		"TEXT ·Value(SB),4,$224-16",
+		"TEXT ·Value(SB),4,$8-16",
+		"TEXT ·Value(SB),4,$0-16",
+		"TEXT ·Value(SB),516,$0-16",
+	} {
+		for _, body := range []string{
+			"MOVD R20,ret+8(FP)",
+			"WORD $0xf9400280\nMOVD R0,ret+8(FP)",
+			"MOVD R12,R20\nMOVD R20,ret+8(FP)",
+		} {
+			t.Run(fmt.Sprintf("%s/%s", text, body), func(t *testing.T) {
+				source := text + "\n" + body + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				arm64LargeFrameCheckAPIs(t, source, pkg, nil, true, false)
+			})
+		}
+	}
+}
diff --git a/arm64_large_frame_entry_test.go b/arm64_large_frame_entry_test.go
new file mode 100644
index 000000000..7051fef9e
--- /dev/null
+++ b/arm64_large_frame_entry_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64LargeFrameScalarSource(frame int) string {
+	return fmt.Sprintf(`TEXT ·LargeR20(SB),4,$%d-8
+MOVD $0x123456789abcdef,R8
+MOVD R8,32(RSP)
+WORD $0xf9401280
+MOVD R0,ret+0(FP)
+RET
+`, frame) // Original LDR X0,[X20,#32], not a decoded fixture spelling.
+}
+
+func arm64LargeFrameScalarIRs(t *testing.T, source, triple string) []string {
+	t.Helper()
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc LargeR20() uint64\n")
+	resolve := testResolveSym("largeframe")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	moduleIR := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	boundIR := bound.Module.String()
+	bound.Module.Dispose()
+	return []string{ir, moduleIR, boundIR}
+}
+
+func TestARM64LargeFrameR20EntryProducer(t *testing.T) {
+	source := arm64LargeFrameScalarSource(496)
+	requireARM64GoAssemblerResult(t, source, true)
+	// Static RED witness only: the old LLVM implementation reads R20=0.
+	// Never execute that old LLVM object to demonstrate its null dereference.
+	for api, ir := range arm64LargeFrameScalarIRs(t, source, arm64LinuxGNUTriple) {
+		sp := regexp.MustCompile(`store i64 (%t[0-9]+), ptr %reg_SP`).FindStringSubmatch(ir)
+		if len(sp) != 2 || !strings.Contains(ir, "store i64 "+sp[1]+", ptr %reg_R20") {
+			t.Errorf("API %d accepted the original scalar R20 load without transporting Go's new private SP to R20", api)
+		}
+	}
+}
+
+func TestARM64LargeFrameActualGoPrologue(t *testing.T) {
+	// These are Go source frame sizes, not LLVM allocation sizes. Both Go 1.20
+	// and Go 1.27 must supply the same implicit producer at the exact boundary.
+	type prologueCase struct {
+		name, text, body string
+		frame            int64
+		producer, valid  bool
+	}
+	var cases []prologueCase
+	for _, frame := range []int64{0, 8, 16, 216, 224, 232, 240, 248, 496, 4080, 4088, 4096, 65528} {
+		cases = append(cases, prologueCase{
+			name: fmt.Sprint(frame), text: fmt.Sprintf("TEXT prologue(SB),4,$%d-0", frame),
+			frame: frame, valid: true,
+			producer: frame != 0 && arm64SourceFrameAutosize(frame) > 0xf0,
+		})
+	}
+	cases = append(cases,
+		prologueCase{name: "noframe", text: "TEXT prologue(SB),516,$0-0", valid: true},
+		prologueCase{name: "negative_noframe", text: "TEXT prologue(SB),4,$-8-0", frame: -8, valid: true},
+		prologueCase{name: "source_call_zero", text: "TEXT prologue(SB),4,$0-0", body: "CALL target(SB)", valid: true},
+		prologueCase{name: "source_call_large", text: "TEXT prologue(SB),4,$496-0", body: "CALL target(SB)", frame: 496, producer: true, valid: true},
+		prologueCase{name: "source_blr_large", text: "TEXT prologue(SB),4,$496-0", body: "BL (R9)", frame: 496, producer: true, valid: true},
+		prologueCase{name: "raw_bl_zero", text: "TEXT prologue(SB),4,$0-0", body: "WORD $0x94000000", valid: true},
+		prologueCase{name: "raw_bl_large", text: "TEXT prologue(SB),4,$496-0", body: "WORD $0x94000000", frame: 496, producer: true, valid: true},
+		prologueCase{name: "raw_blr_large", text: "TEXT prologue(SB),4,$496-0", body: "WORD $0xd63f0120", frame: 496, producer: true, valid: true},
+		prologueCase{name: "unaligned_1", text: "TEXT prologue(SB),4,$1-0", frame: 1},
+		prologueCase{name: "unaligned_4", text: "TEXT prologue(SB),4,$4-0", frame: 4},
+		prologueCase{name: "unaligned_230", text: "TEXT prologue(SB),4,$230-0", frame: 230},
+		prologueCase{name: "noframe_nonzero", text: "TEXT prologue(SB),516,$496-0", frame: 496},
+	)
+	for _, target := range []string{"linux", "darwin", "windows"} {
+		for _, tc := range cases {
+			t.Run(target+"/"+tc.name, func(t *testing.T) {
+				dir := t.TempDir()
+				path := filepath.Join(dir, "prologue.s")
+				source := tc.text + "\n" + tc.body + "\nRET\n"
+				if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+				defer cancel()
+				cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", filepath.Join(dir, "prologue.o"), path)
+				cmd.Env = append(os.Environ(), "GOOS="+target, "GOARCH=arm64")
+				listing, err := cmd.CombinedOutput()
+				if !tc.valid {
+					if err == nil {
+						t.Fatalf("actual Go accepted invalid source frame\n%s", listing)
+					}
+					t.Logf("actual Go rejected invalid frame: %s", listing)
+					return
+				}
+				if err != nil {
+					t.Fatalf("actual Go prologue: %v\n%s", err, listing)
+				}
+				producer := regexp.MustCompile(`SUB\s+\$[0-9]+, RSP, R20`).Match(listing)
+				if producer != tc.producer || tc.producer && !strings.Contains(string(listing), "MOVD\tR20, RSP") {
+					t.Fatalf("frame=%d autosize=%d producer=%v want=%v\n%s", tc.frame, arm64SourceFrameAutosize(tc.frame), producer, tc.producer, listing)
+				}
+				t.Logf("source frame %d: actual large-frame R20 producer=%v", tc.frame, producer)
+			})
+		}
+	}
+}
+
+func TestARM64LargeFrameTEXTContractIsNotInferred(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc LargeR20() uint64\n")
+	for _, replacement := range []string{
+		"TEXT ·LargeR20(SB),4,$496",
+		"TEXT ·LargeR20(SB),68,$496-8", // NEEDCTXT is an unproved hidden entry.
+	} {
+		source := strings.Replace(arm64LargeFrameScalarSource(496), "TEXT ·LargeR20(SB),4,$496-8", replacement, 1)
+		requireARM64GoAssemblerResult(t, source, true)
+		arm64LargeFrameCheckAPIs(t, source, pkg, nil, true, false)
+	}
+	file, err := Parse(ArchARM64, arm64LargeFrameScalarSource(496))
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	fn.FrameSize = 504
+	if arm64SourceFrameR20(fn) {
+		t.Fatal("changed parsed frame borrowed the original TEXT producer")
+	}
+	fn = file.Funcs[0]
+	fn.ArgSize = 16
+	if arm64SourceFrameR20(fn) {
+		t.Fatal("changed parsed argument size borrowed the original TEXT producer")
+	}
+}
+
+func TestARM64LargeFrameProducerDoesNotBorrowABIInternal(t *testing.T) {
+	// Bind the same explicit runtime identity in all three translation APIs.
+	// The shared selector oracle queries the actual assembler flags: Go 1.20
+	// also requires the stock driver's -compiling-runtime, unlike current Go.
+	pkg := mustGoPackage(t, "runtime", "package runtime\nfunc Value() uint64\n")
+	const source = `TEXT runtime·Value<ABIInternal>(SB),4,$496-8
+MOVD $7,R20
+MOVD R20,R0
+RET
+`
+	requireARM64TypedCallGoSelectorObject(t, source)
+	for _, ir := range arm64LargeFrameCheckAPIs(t, source, pkg, nil, false, true) {
+		sp := regexp.MustCompile(`store i64 (%t[0-9]+), ptr %reg_SP`).FindStringSubmatch(ir)
+		if len(sp) == 2 && strings.Contains(ir, "store i64 "+sp[1]+", ptr %reg_R20") {
+			t.Fatal("software-defined ABIInternal R20 borrowed the separate ABI0 implicit producer")
+		}
+	}
+	// A complete ABIInternal signature defines its actual parameter/result
+	// leaves, not an unmodelled prologue scratch value.
+	read := strings.Replace(source, "MOVD $7,R20\nMOVD R20,R0", "MOVD 32(R20),R0", 1)
+	requireARM64TypedCallGoSelectorObject(t, read)
+	arm64LargeFrameCheckAPIs(t, read, pkg, nil, true, false)
+}
diff --git a/arm64_large_frame_memory_test.go b/arm64_large_frame_memory_test.go
new file mode 100644
index 000000000..ab55accc8
--- /dev/null
+++ b/arm64_large_frame_memory_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64LargeFrameMemoryFixture(t *testing.T) (string, GoPackage, []arm64RawPrivateMemoryCase) {
+	t.Helper()
+	shapes := arm64RawPrivateMemoryCases()
+	var instructions []string
+	for _, shape := range shapes {
+		instructions = append(instructions, strings.ReplaceAll(shape.store, "[sp", "[x20"), strings.ReplaceAll(shape.load, "[sp", "[x20"))
+	}
+	words := assembleARM64LLVMWords(t, instructions, "")
+	var source, declarations strings.Builder
+	var cases []arm64RawPrivateMemoryCase
+	for index, shape := range shapes {
+		store, load := fmt.Sprintf("WORD $%#08x", words[2*index]), fmt.Sprintf("WORD $%#08x", words[2*index+1])
+		for _, named := range []bool{false, true} {
+			if named {
+				decoded := make([]string, 2)
+				legal := true
+				for part := range decoded {
+					ins, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(words[2*index+part])}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					// These two raw sign-extension spellings are not Go frontend
+					// mnemonics; the original WORD cases remain fully covered.
+					op := arm64ControlOp(ins)
+					legal = legal && op != "MOVBW" && op != "MOVHW"
+					decoded[part] = strings.Split(ins.Raw, " /*")[0]
+				}
+				if !legal {
+					continue
+				}
+				store, load = decoded[0], decoded[1]
+			}
+			shape.name = fmt.Sprintf("r20_%03d_%t", index, named)
+			cases = append(cases, shape)
+			fmt.Fprintf(&declarations, "func %s(*byte,*byte)\n", shape.name)
+			fmt.Fprintf(&source, `TEXT ·%s(SB),4,$496-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+ADD $64,R20,R20
+`, shape.name)
+			if shape.floating {
+				source.WriteString("FMOVQ (R0),F0\nFMOVQ 16(R0),F1\n")
+			} else {
+				source.WriteString("MOVD (R0),R4\nMOVD 8(R0),R5\n")
+			}
+			source.WriteString(store + "\n" + load + "\n")
+			if shape.floating {
+				op := map[int]string{4: "FMOVS", 8: "FMOVD", 16: "FMOVQ"}[shape.width]
+				fmt.Fprintf(&source, "%s F2,(R1)\n", op)
+				if shape.count == 2 {
+					fmt.Fprintf(&source, "%s F3,%d(R1)\n", op, shape.width)
+				}
+			} else {
+				source.WriteString("MOVD R9,(R1)\n")
+				if shape.count == 2 {
+					source.WriteString("MOVD R10,8(R1)\n")
+				}
+			}
+			source.WriteString("MOVD 0(RSP),R30\nRET\n")
+		}
+	}
+	return source.String(), mustGoPackage(t, "largeframe", "package main\n"+declarations.String()), cases
+}
+
+func arm64LargeFrameCheckAPIs(t *testing.T, source string, pkg GoPackage, mutate func(map[string]FuncSig), wantContext, objects bool) []string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym("largeframe")
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if mutate != nil {
+		mutate(sigs)
+	}
+	llc := findLLVM22Tool("llc")
+	if objects && llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var emitted []string
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+		check := func(api string, err error) {
+			t.Helper()
+			if wantContext {
+				for name, sig := range sigs {
+					if sig.Name != name && err != nil && strings.Contains(err.Error(), "signature name mismatch") {
+						return // The shared identity validator rejects before lowering.
+					}
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s/%s: want Context, got %v", triple, api, err)
+				}
+			} else if err != nil {
+				t.Errorf("%s/%s: %v", triple, api, err)
+			}
+		}
+		ir, err := Translate(file, options)
+		check("Translate", err)
+		ctx := llvm.NewContext()
+		module, moduleErr := TranslateModuleInContext(ctx, file, options)
+		moduleIR := ""
+		if moduleErr == nil {
+			moduleIR = module.String()
+			module.Dispose()
+		}
+		check("Module", moduleErr)
+		bound, boundErr := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+			ManualSig: func(name string) (FuncSig, bool) {
+				if mutate == nil {
+					return FuncSig{}, false
+				}
+				sig, ok := sigs[name]
+				return sig, ok
+			},
+		})
+		boundIR := ""
+		if boundErr == nil {
+			boundIR = bound.Module.String()
+			bound.Module.Dispose()
+		}
+		check("GoModule", boundErr)
+		ctx.Dispose()
+		if !wantContext && err == nil && moduleErr == nil && boundErr == nil {
+			for api, output := range []string{ir, moduleIR, boundIR} {
+				emitted = append(emitted, output)
+				if objects {
+					compileLLVMToObject(t, llc, triple, fmt.Sprintf("large-frame-%d.ll", api), fmt.Sprintf("large-frame-%d.o", api), output)
+				}
+			}
+		}
+	}
+	return emitted
+}
+
+func TestARM64LargeFrameMemoryFamilyAPIsAndObjects(t *testing.T) {
+	source, pkg, cases := arm64LargeFrameMemoryFixture(t)
+	requireARM64GoAssemblerResult(t, source, true)
+	arm64LargeFrameCheckAPIs(t, source, pkg, nil, false, true)
+	t.Logf("%d raw/named scalar, signed-load, GP/FP pair, offset/unscaled/pre/post variants; 3 APIs x 5 objects", len(cases))
+}
+
+func TestARM64LargeFrameSourceAndTransportStayFailClosed(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc LargeR20() uint64\n")
+	base := arm64LargeFrameScalarSource(496)
+	for _, tc := range []struct{ name, body string }{
+		{"saved_lr", "MOVD $0,R8\nMOVD R8,(R20)"},
+		{"partial_lr", "MOVB R8,1(R20)"},
+		{"lr_transform", "ADD $1,R30,R30"},
+		{"result_escape", "MOVD R20,R0"},
+		{"fp_escape", "MOVD R20,ret+0(FP)"},
+		{"global_escape", "MOVD R20,holder(SB)"},
+		{"heap_escape", "MOVD R20,(R8)"},
+		{"vector_escape", "VMOV R20,V0.D[0]\nVST1 [V0.B16],(R8)"},
+		{"address_spill_partial", "MOVD R20,64(RSP)\nMOVB R8,65(RSP)"},
+		{"address_spill_fp_load", "MOVD R20,64(RSP)\nFMOVD 64(RSP),F0"},
+		{"low_bound", "MOVD -16(R20),R9"},
+		{"high_bound", "MOVD 504(R20),R9"},
+		{"unknown_index", "MOVD (R20)(R8),R9"},
+		{"unknown_transform", "EOR R8,R20\nMOVD (R20),R9"},
+		{"mixed_offsets", "CBZ R8,other\nADD $16,R20,R9\nB join\nother:\nADD $24,R20,R9\njoin:\nMOVD (R9),R10"},
+		{"mixed_external", "CBZ R8,other\nMOVD R20,R9\nB join\nother:\nMOVD R8,R9\njoin:\nMOVD (R9),R10"},
+		{"sp_unbalanced", "SUB $16,RSP"},
+		{"source_call", "CALL unknown(SB)"},
+		{"raw_call", "WORD $0xd63f0100"},
+		{"unknown_word", "WORD $0xffffffff"},
+		{"unknown_data", "DWORD $0"},
+		{"reserved_r18", "WORD $0x0e043c12"},
+		{"reserved_g", "WORD $0x0e043c1c"},
+		{"dead_escape", "B live\ndead:\nMOVD R20,holder(SB)\nlive:"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := strings.Replace(base, "MOVD R0,ret+0(FP)", tc.body+"\nMOVD R0,ret+0(FP)", 1)
+			source += "GLOBL holder(SB),16,$8\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			arm64LargeFrameCheckAPIs(t, source, pkg, nil, true, false)
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		edit func(*FuncSig)
+	}{
+		{"fallback", func(sig *FuncSig) { sig.Frame = FrameLayout{} }},
+		{"wrong_identity", func(sig *FuncSig) { sig.Name = "different" }},
+		{"wrong_slot_width", func(sig *FuncSig) { sig.Frame.Results[0].Type = I32 }},
+		{"wrong_slot_offset", func(sig *FuncSig) { sig.Frame.Results[0].Offset = 8 }},
+		{"wrong_field", func(sig *FuncSig) { sig.Frame.Results[0].Field = 0 }},
+		{"wrong_result", func(sig *FuncSig) { sig.Frame.Results[0].Index = 1 }},
+		{"register_contract", func(sig *FuncSig) { sig.ARM64GoRegisterABI = &ARM64GoRegisterABI{} }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			arm64LargeFrameCheckAPIs(t, base, pkg, func(sigs map[string]FuncSig) {
+				sig := sigs["largeframe.LargeR20"]
+				tc.edit(&sig)
+				sigs["largeframe.LargeR20"] = sig
+			}, true, false)
+		})
+	}
+}
diff --git a/arm64_large_frame_runtime_test.go b/arm64_large_frame_runtime_test.go
new file mode 100644
index 000000000..4ac2e1798
--- /dev/null
+++ b/arm64_large_frame_runtime_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64LargeFrameStructureFamilyAPIsAndObjects(t *testing.T) {
+	source, pkg, cases := arm64PrivateStructureFixture(t)
+	source = strings.ReplaceAll(source, "$120-16", "$496-16")
+	source = strings.ReplaceAll(source, "ADD $16,RSP,R9", "ADD $16,R20,R9")
+	source = strings.ReplaceAll(source, "ADD $16,RSP,R10", "ADD $16,R20,R10")
+	requireARM64GoAssemblerResult(t, source, true)
+	arm64LargeFrameCheckAPIs(t, source, pkg, nil, false, true)
+	t.Logf("%d complete structure arrangements/counts/lanes/writeback consumers of the same Go R20 producer", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64LargeFrameStructureFamily(t *testing.T) {
+	source, pkg, cases := arm64PrivateStructureFixture(t)
+	source = strings.ReplaceAll(source, "$120-16", "$496-16")
+	source = strings.ReplaceAll(source, "ADD $16,RSP,R9", "ADD $16,R20,R9")
+	source = strings.ReplaceAll(source, "ADD $16,RSP,R10", "ADD $16,R20,R10")
+	arm64RunPrivateStructureFixture(t, source, pkg, cases)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64LargeFrameMemoryFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, pkg, cases := arm64LargeFrameMemoryFixture(t)
+	var declarations, checks, cDeclarations, cChecks strings.Builder
+	for _, tc := range cases {
+		fmt.Fprintf(&declarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const unsigned char *,unsigned char *);\n", tc.name)
+		floating := 0
+		if tc.floating {
+			floating = 1
+		}
+		fmt.Fprintf(&checks, "check(%s,%d,%d,%d,%d)\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+		fmt.Fprintf(&cChecks, "if (check(%s,%d,%d,%d,%d)) return 1;\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module largeframe\n\ngo 1.20\n",
+		"main.go": arm64RawPrivateFrameOracleGo + declarations.String() +
+			"func main() {\n" + checks.String() + "}\n",
+		"oracle_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=2", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go R20 numerical family: %v\n%s", err, output)
+	}
+	llvmCtx := llvm.NewContext()
+	result, err := translateGoModuleInContext(llvmCtx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if err != nil {
+		llvmCtx.Dispose()
+		t.Fatal(err)
+	}
+	ir := result.Module.String()
+	result.Module.Dispose()
+	llvmCtx.Dispose()
+	cSource := arm64RawPrivateFrameOracleC + cDeclarations.String() +
+		"int main(void) {\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "large_frame_memory", triple, ir, cSource, runner)
+	t.Logf("actual Go + LLVM22/C independent reference: %d scalar/pair variants x 256 patterns x 5 unaligned offsets, complete input/output canaries", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64LargeFrameScalarEntry(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := arm64LargeFrameScalarSource(496)
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module largeframe\n\ngo 1.20\n",
+		"main.go": `package main
+
+func LargeR20() uint64
+
+func main() {
+	for i := 0; i < 64; i++ {
+		if got := LargeR20(); got != 0x123456789abcdef {
+			panic(got)
+		}
+	}
+}
+
+`,
+		"oracle_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=2", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go scalar R20 entry oracle: %v\n%s", err, output)
+	}
+	ir := arm64LargeFrameScalarIRs(t, source, triple)[0]
+	ir = strings.ReplaceAll(ir, "@largeframe.LargeR20", "@LargeR20")
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "large_frame_scalar", triple, ir, `#include <stdint.h>
+extern uint64_t LargeR20(void);
+int main(void) {
+	for (int i = 0; i < 64; i++) {
+		if (LargeR20() != UINT64_C(0x123456789abcdef)) return 1;
+	}
+	return 0;
+}
+`, runner)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64CheckedR20SoftwareValues(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, declarations, goChecks, cDeclarations, cChecks strings.Builder
+	for index, frame := range []int{496, 224, 8, 0, -8} {
+		flags, size := 4, frame
+		if frame == -8 {
+			flags, size = 516, 0
+		}
+		for variant, body := range []string{
+			"MOVD $7,R20",
+			"MOVD arg+0(FP),R20",
+			"MOVD arg+0(FP),R8\nADD $7,R8,R20",
+		} {
+			name := fmt.Sprintf("value_%d_%d", index, variant)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),%d,$%d-16\n%s\nMOVD R20,ret+8(FP)\nRET\n", name, flags, size, body)
+			fmt.Fprintf(&declarations, "func %s(uint64) uint64\n", name)
+			fmt.Fprintf(&cDeclarations, "extern uint64_t %s(uint64_t);\n", name)
+			want := []string{"7", "value", "value+7"}[variant]
+			fmt.Fprintf(&goChecks, "if got := %s(value); got != %s { panic(got) }\n", name, want)
+			fmt.Fprintf(&cChecks, "if (%s(value) != %s) return 1;\n", name, want)
+		}
+	}
+	pkg := mustGoPackage(t, "largeframe", "package main\n"+declarations.String())
+	dir := t.TempDir()
+	goDriver := "package main\n" + declarations.String() + `
+func main() {
+	for i := uint64(0); i < 256; i++ {
+		value := i*0x1020304050607081 ^ 0xcafebabef00dcafe
+` + goChecks.String() + "\n}\n}\n"
+	for name, body := range map[string]string{
+		"go.mod":  "module largeframe\n\ngo 1.20\n",
+		"main.go": goDriver, "oracle_arm64.s": source.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=2", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go known R20 values: %v\n%s", err, output)
+	}
+	llvmCtx := llvm.NewContext()
+	result, err := translateGoModuleInContext(llvmCtx, pkg, []byte(source.String()), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if err != nil {
+		llvmCtx.Dispose()
+		t.Fatal(err)
+	}
+	ir := result.Module.String()
+	result.Module.Dispose()
+	llvmCtx.Dispose()
+	cDriver := "#include <stdint.h>\n" + cDeclarations.String() + `
+int main(void) {
+	for (uint64_t i = 0; i < 256; i++) {
+		uint64_t value = i*UINT64_C(0x1020304050607081) ^ UINT64_C(0xcafebabef00dcafe);
+` + cChecks.String() + "\n}\nreturn 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "known_r20_values", triple, ir, cDriver, runner)
+	t.Log("actual Go + LLVM22/C: 5 frame modes x 3 literal/FP-load/FP-arithmetic values x 256 full-width patterns")
+}
diff --git a/arm64_linux_syscall_effects_go127_test.go b/arm64_linux_syscall_effects_go127_test.go
new file mode 100644
index 000000000..fe70002f2
--- /dev/null
+++ b/arm64_linux_syscall_effects_go127_test.go
@@ -0,0 +1,418 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These are independent original-kernel oracles, not a source capability or a
+// sleep-borrow certificate. Pointer-free syscalls isolate GP/NZCV from memory.
+type arm64LinuxSyscallEffectCase struct {
+	name        string
+	number      int
+	registers   []int
+	left, right uint64
+	flags       bool
+}
+
+func arm64LinuxSyscallEffectHasOriginalMarker(output, name string) bool {
+	marker := "ORIGINAL_KERNEL_AXIS_PASS " + name + " values="
+	return strings.Count(output, marker) == 1
+}
+
+func TestARM64LinuxSyscallEffectsOriginalMarkerBoundaries(t *testing.T) {
+	marker := func(name string) string {
+		return "original_test.go:40: ORIGINAL_KERNEL_AXIS_PASS " + name + " values=[7 1 0 0 0]\n"
+	}
+
+	var complete strings.Builder
+	for _, test := range arm64LinuxSyscallEffectCases() {
+		complete.WriteString(marker(test.name))
+	}
+	for _, test := range arm64LinuxSyscallEffectCases() {
+		t.Run("complete_"+test.name, func(t *testing.T) {
+			if !arm64LinuxSyscallEffectHasOriginalMarker(complete.String(), test.name) {
+				t.Fatalf("exact original marker lost among complete axes: %s", test.name)
+			}
+		})
+	}
+
+	for _, name := range []string{"nzcv_getpid_negative", "nzcv_close_invalid_negative"} {
+		t.Run("prefix_only_"+name, func(t *testing.T) {
+			if arm64LinuxSyscallEffectHasOriginalMarker(marker(name+"_overflow"), name) {
+				t.Fatalf("prefix-only marker impersonates exact original axis: %s", name)
+			}
+		})
+	}
+
+	const name = "nzcv_getpid_negative"
+	for _, test := range []struct {
+		name, output string
+	}{
+		{"wrong_name", marker("nzcv_close_invalid_negative")},
+		{"missing", "--- PASS: TestOriginalLinuxSyscallEffects\n"},
+		{"duplicate", marker(name) + marker(name)},
+		{"wrong_value_boundary", "ORIGINAL_KERNEL_AXIS_PASS " + name + " values_suffix=[7]\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if arm64LinuxSyscallEffectHasOriginalMarker(test.output, name) {
+				t.Fatalf("invalid original marker accepted: %s", test.name)
+			}
+		})
+	}
+}
+
+func arm64LinuxSyscallEffectCases() []arm64LinuxSyscallEffectCase {
+	var registers []int
+	for register := 1; register <= 27; register++ {
+		if register != 18 { // Never replace the platform register or Go g/FP/LR.
+			registers = append(registers, register)
+		}
+	}
+	var cases []arm64LinuxSyscallEffectCase
+	for _, syscall := range []struct {
+		name   string
+		number int
+	}{{"getpid", 172}, {"close_invalid", 57}} {
+		cases = append(cases, arm64LinuxSyscallEffectCase{
+			name: "gp_" + syscall.name, number: syscall.number, registers: registers,
+		})
+		for _, comparison := range []struct {
+			name        string
+			left, right uint64
+		}{
+			{"equal", 7, 7},
+			{"negative", 0, 1},
+			{"positive_overflow", 0x8000000000000000, 1},
+			{"negative_overflow", 0x7fffffffffffffff, ^uint64(0)},
+		} {
+			cases = append(cases, arm64LinuxSyscallEffectCase{
+				name: "nzcv_" + syscall.name + "_" + comparison.name, number: syscall.number,
+				flags: true, left: comparison.left, right: comparison.right,
+			})
+		}
+	}
+	return cases
+}
+
+func (test arm64LinuxSyscallEffectCase) resultCount() int {
+	if test.flags {
+		return 5 // Raw R0 and independent N/Z/C/V observations.
+	}
+	return 1 + len(test.registers)
+}
+
+func (test arm64LinuxSyscallEffectCase) fields() []string {
+	fields := make([]string, test.resultCount())
+	for index := range fields {
+		fields[index] = fmt.Sprintf("r%d", index)
+	}
+	return fields
+}
+
+func (test arm64LinuxSyscallEffectCase) assembly() string {
+	var source strings.Builder
+	// Numeric NOSPLIT|NOFRAME: no automatic Go saved-frame cells to borrow.
+	fmt.Fprintf(&source, "TEXT ·%s(SB),516,$0-%d\n", test.name, 8+8*test.resultCount())
+	if test.flags {
+		for register := 1; register <= 5; register++ {
+			fmt.Fprintf(&source, "\tMOVD $0, R%d\n", register)
+		}
+		fmt.Fprintf(&source, "\tMOVD $0x%x, R6\n\tMOVD $0x%x, R7\n", test.left, test.right)
+	} else {
+		// Single-16-bit literals and small scaled stores do not need Go's R27
+		// scratch expansion; the original complete object/runtime still checks it.
+		for _, register := range test.registers {
+			if register != 8 {
+				fmt.Fprintf(&source, "\tMOVD $0x%x, R%d\n", 0x5a00+register, register)
+			}
+		}
+	}
+	if test.number == 57 {
+		source.WriteString("\tMOVD $-1, R0\n")
+	} else {
+		source.WriteString("\tMOVD input+0(FP), R0\n")
+	}
+	fmt.Fprintf(&source, "\tMOVD $%d, R8\n", test.number)
+	if test.flags {
+		source.WriteString("\tCMP R7, R6\n")
+	}
+	source.WriteString("\tSVC $0\n")
+	if test.flags {
+		// No intervening flag-changing arithmetic can hide the kernel state.
+		source.WriteString("\tCSET MI, R2\n\tCSET EQ, R3\n\tCSET CS, R4\n\tCSET VS, R5\n")
+	}
+	source.WriteString("\tMOVD R0, r0+8(FP)\n")
+	registers := test.registers
+	if test.flags {
+		registers = []int{2, 3, 4, 5}
+	}
+	for index, register := range registers {
+		fmt.Fprintf(&source, "\tMOVD R%d, r%d+%d(FP)\n", register, index+1, 16+8*index)
+	}
+	source.WriteString("\tRET\n\n")
+	return source.String()
+}
+
+func (test arm64LinuxSyscallEffectCase) numericalExpected() []uint64 {
+	if test.flags {
+		// Independent numerical SUB equations, not translator flag helpers.
+		difference := test.left - test.right
+		values := []bool{difference>>63 != 0, difference == 0, test.left >= test.right,
+			(test.left^test.right)&(test.left^difference)&(uint64(1)<<63) != 0}
+		result := make([]uint64, len(values))
+		for index, value := range values {
+			if value {
+				result[index] = 1
+			}
+		}
+		return result
+	}
+	result := make([]uint64, len(test.registers))
+	for index, register := range test.registers {
+		result[index] = uint64(0x5a00 + register)
+		if register == 8 {
+			result[index] = uint64(test.number)
+		}
+	}
+	return result
+}
+
+func arm64LinuxSyscallEffectFixture(t *testing.T) (directory, packagePath, declarations, assembly string) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath = "example.invalid/kerneloracle"
+	var goSource, asmSource, original strings.Builder
+	goSource.WriteString("package kerneloracle\n\n")
+	original.WriteString("package kerneloracle\nimport (\"os\"; \"syscall\"; \"testing\")\nfunc TestOriginalLinuxSyscallEffects(t *testing.T) {\n")
+	for _, test := range arm64LinuxSyscallEffectCases() {
+		fields := strings.Join(test.fields(), ",")
+		fmt.Fprintf(&goSource, "func %s(input uint64) (%s uint64)\n", test.name, fields)
+		fmt.Fprintf(&goSource, "func invoke_%s(input uint64) (%s uint64) { return %s(input) }\n", test.name, fields, test.name)
+		asmSource.WriteString(test.assembly())
+		fmt.Fprintf(&original, "t.Run(%q,func(t *testing.T) { %s := %s(0x45); got := []uint64{%s}\n", test.name, fields, test.name, fields)
+		if test.number == 172 {
+			original.WriteString("if got[0] == 0 || got[0] != uint64(os.Getpid()) { t.Fatal(\"original getpid is not the actual process PID\", got[0],os.Getpid()) }\n")
+		} else {
+			original.WriteString("if got[0] != ^(uint64(syscall.EBADF)-1) { t.Fatal(\"original close(-1) must return raw -EBADF\",got[0]) }\n")
+		}
+		for index, value := range test.numericalExpected() {
+			fmt.Fprintf(&original, "if got[%d] != 0x%x { t.Fatal(\"original GP/NZCV axis %d\",got[%d],uint64(0x%x)) }\n", index+1, value, index+1, index+1, value)
+		}
+		fmt.Fprintf(&original, "t.Logf(%q,got)\n})\n", "ORIGINAL_KERNEL_AXIS_PASS "+test.name+" values=%x")
+	}
+	original.WriteString("}\n")
+	for name, data := range map[string]string{
+		"go.mod": "module " + packagePath + "\ngo 1.20\n", "decl.go": goSource.String(),
+		"original_arm64.s": asmSource.String(), "original_test.go": original.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath, goSource.String(), asmSource.String()
+}
+
+func arm64LinuxSyscallEffectOriginalObjects(t *testing.T, directory, packagePath string) {
+	t.Helper()
+	archive, object, builtins := arm64ByteCarrierOriginal(t, directory, packagePath)
+	members, err := gostaticstorage.ObserveARM64AssemblyArchive(archive, builtins, "linux/arm64", []string{"original_arm64.s"})
+	if err != nil || len(members) != 3 {
+		t.Fatalf("ORIGINAL_OBJECT_PRECONDITION: complete archive: %v", err)
+	}
+	texts, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, "linux/arm64")
+	cases := arm64LinuxSyscallEffectCases()
+	if err != nil || len(texts) != len(cases) || len(members[2].Texts) != len(cases) {
+		t.Fatalf("ORIGINAL_OBJECT_PRECONDITION: complete TEXT inventory: %v", err)
+	}
+	for index, test := range cases {
+		text, prior := texts[index], members[2].Texts[index]
+		if text.Name != packagePath+"."+test.name || text.ABI != 0 || text.Name != prior.Name ||
+			!bytes.Equal(text.Code, prior.Code) || len(text.Relocations) != 0 || len(prior.Relocations) != 0 ||
+			len(text.Positions) == 0 || len(prior.Positions) == 0 || len(text.Code)%4 != 0 {
+			t.Fatalf("ORIGINAL_OBJECT_PRECONDITION: complete standalone/archive join differs: %s", test.name)
+		}
+		count := 0
+		for pc := 0; pc < len(text.Code); pc += 4 {
+			if binary.LittleEndian.Uint32(text.Code[pc:]) == 0xd4000001 {
+				count++
+			}
+		}
+		if count != 1 {
+			t.Fatalf("ORIGINAL_OBJECT_PRECONDITION: %s has %d actual SVC0 words", test.name, count)
+		}
+		t.Logf("ORIGINAL_KERNEL_OBJECT name=%s bytes=%d codeSHA256=%x SVC0=%d", test.name, len(text.Code), sha256.Sum256(text.Code), count)
+	}
+}
+
+func TestARM64LinuxSyscallEffectsOriginalObjects(t *testing.T) {
+	directory, packagePath, _, assembly := arm64LinuxSyscallEffectFixture(t)
+	file, err := Parse(ArchARM64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, function := range file.Funcs {
+		if function.FrameSize != 0 || arm64SourceGoFrame(function).present {
+			t.Fatal("kernel oracle is not a zero-frame independent control")
+		}
+	}
+	arm64LinuxSyscallEffectOriginalObjects(t, directory, packagePath)
+}
+
+func TestARM64LinuxSyscallEffectsIndependentAxes(t *testing.T) {
+	cases := arm64LinuxSyscallEffectCases()
+	if len(cases) != 10 {
+		t.Fatal("kernel oracle lost a GP or NZCV axis")
+	}
+	wanted := [][]uint64{{0, 1, 1, 0}, {1, 0, 0, 0}, {0, 0, 1, 1}, {1, 0, 0, 1}}
+	for group := 0; group < 2; group++ {
+		gp := cases[group*5]
+		if gp.flags || len(gp.registers) != 26 || gp.registers[25] != 27 {
+			t.Fatal("GP oracle omitted a numerical register, including R27 scratch")
+		}
+		for _, register := range gp.registers {
+			if register < 1 || register > 27 || register == 18 {
+				t.Fatal("GP oracle changed a reserved platform/Go frame identity")
+			}
+		}
+		for index, expected := range wanted {
+			actual := cases[group*5+index+1].numericalExpected()
+			if !reflect.DeepEqual(actual, expected) {
+				t.Fatalf("independent numerical CMP equation differs: got=%v want=%v", actual, expected)
+			}
+		}
+	}
+}
+
+// Cross-object success is separate from the required actual Linux kernel run.
+func TestARM64LinuxSyscallEffectsDefaultTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	directory, packagePath, declarations, assembly := arm64LinuxSyscallEffectFixture(t)
+	arm64LinuxSyscallEffectOriginalObjects(t, directory, packagePath)
+	pkg := mustGoPackage(t, packagePath, declarations)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := arm64LinuxSyscallEffectTranslate(t, api, pkg, assembly)
+			if err != nil {
+				t.Fatal("default syscall target-object consumer", err)
+			}
+			for _, optimization := range []int{0, 2} {
+				t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+					arm64LinuxSyscallEffectCompileObject(t, llc, ir, optimization)
+				})
+			}
+		})
+	}
+}
+
+// This object-only oracle is owned by the independent syscall class. It does
+// not depend on, observe, or authorize a framed sleep source/consumer role.
+func arm64LinuxSyscallEffectCompileObject(t *testing.T, llc, ir string, optimization int) {
+	t.Helper()
+	if optimization != 0 && optimization != 2 {
+		t.Fatal("syscall object optimization must be exactly LLVM22 O0 or O2")
+	}
+	directory := t.TempDir()
+	input, output := filepath.Join(directory, "kernel_effects.ll"), filepath.Join(directory, "kernel_effects.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, release := runtimeOracleStageContext(t)
+	defer release()
+	command := exec.CommandContext(ctx, llc, fmt.Sprintf("-O=%d", optimization),
+		"-mtriple=aarch64-unknown-linux-gnu", "-filetype=obj", input, "-o", output)
+	raw, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("required LLVM22 Linux syscall object: %v\n%s", err, raw)
+	}
+	info, err := os.Stat(output)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("LLVM22 produced no actual syscall object: %v", err)
+	}
+}
+
+func arm64LinuxSyscallEffectTranslate(t *testing.T, api string, pkg GoPackage, assembly string) (string, error) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	file, err := Parse(ArchARM64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym(pkg.Path)
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolve, Sigs: signatures}
+	switch api {
+	case "text":
+		return Translate(file, options)
+	case "module":
+		module, err := TranslateModuleInContext(context, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			return module.String(), err
+		}
+		return "", err
+	case "Go":
+		translated, err := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+			GOOS: "linux", GOARCH: "arm64", TargetTriple: options.TargetTriple, ResolveSym: resolve,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+			return translated.Module.String(), err
+		}
+		return "", err
+	default:
+		t.Fatalf("unknown syscall oracle API %q", api)
+		return "", nil
+	}
+}
+
+func arm64LinuxSyscallEffectRuntimeChecks(packagePath string, test arm64LinuxSyscallEffectCase) (string, string) {
+	var shim, driver strings.Builder
+	count := test.resultCount()
+	types := make([]string, count)
+	for index := range types {
+		types[index] = "i64"
+	}
+	aggregate := "{ " + strings.Join(types, ", ") + " }"
+	// LLVM aggregate calls stay internal. C sees only an explicit output pointer.
+	fmt.Fprintf(&shim, "\ndefine void @kernel_check(ptr %%out, i64 %%input) {\n  %%result = call %s %s(i64 %%input)\n", aggregate, llvmGlobal(packagePath+"."+test.name))
+	for index := 0; index < count; index++ {
+		fmt.Fprintf(&shim, "  %%v%d = extractvalue %s %%result, %d\n  %%p%d = getelementptr i64, ptr %%out, i64 %d\n  store i64 %%v%d, ptr %%p%d, align 8\n", index, aggregate, index, index, index, index, index)
+	}
+	shim.WriteString("  ret void\n}\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <unistd.h>\n#include <errno.h>\nint32_t cliteErrno(void) { return errno; }\nextern void kernel_check(uint64_t *, uint64_t);\nint main(void) {\n")
+	fmt.Fprintf(&driver, "uint64_t out[%d] = {0}; kernel_check(out, UINT64_C(0x45));\n", count)
+	if test.number == 172 {
+		driver.WriteString("if (!out[0] || out[0] != (uint64_t)getpid()) { fprintf(stderr,\"actual process PID mismatch\\n\"); return 1; }\n")
+	} else {
+		driver.WriteString("if (out[0] != (uint64_t)-(int64_t)EBADF) { fprintf(stderr,\"raw -EBADF mismatch\\n\"); return 1; }\n")
+	}
+	for index, value := range test.numericalExpected() {
+		fmt.Fprintf(&driver, "if (out[%d] != UINT64_C(0x%x)) { fprintf(stderr,\"GP/NZCV axis %d got=%%llx expected=%x\\n\",(unsigned long long)out[%d]); return 1; }\n", index+1, value, index+1, value, index+1)
+	}
+	fmt.Fprintf(&driver, "puts(\"LLVM_KERNEL_AXIS_PASS %s\"); return 0;\n}\n", test.name)
+	return shim.String(), driver.String()
+}
diff --git a/arm64_linux_syscall_effects_runtime_linux_test.go b/arm64_linux_syscall_effects_runtime_linux_test.go
new file mode 100644
index 000000000..5c6fe3385
--- /dev/null
+++ b/arm64_linux_syscall_effects_runtime_linux_test.go
@@ -0,0 +1,66 @@
+//go:build go1.27 && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64LinuxSyscallGPNZCV(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	if triple != "aarch64-unknown-linux-gnu" {
+		t.Fatal("kernel oracle requires actual Linux ARM64 execution")
+	}
+	directory, packagePath, declarations, assembly := arm64LinuxSyscallEffectFixture(t)
+	arm64LinuxSyscallEffectOriginalObjects(t, directory, packagePath)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	arguments := []string{"test", "-p=1", "-mod=readonly", "-run=^TestOriginalLinuxSyscallEffects$", "-count=1", "-v"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(arguments, "-exec="+quoted)
+	}
+	ctx, release := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, request.GoBinary, append(arguments, ".")...)
+	command.Dir, command.Env = directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	release()
+	if err != nil || !strings.Contains(string(output), "--- PASS: TestOriginalLinuxSyscallEffects") {
+		t.Fatalf("ORIGINAL_KERNEL_PRECONDITION: %v\n%s", err, output)
+	}
+	for _, test := range arm64LinuxSyscallEffectCases() {
+		if !arm64LinuxSyscallEffectHasOriginalMarker(string(output), test.name) {
+			t.Fatalf("ORIGINAL_KERNEL_PRECONDITION: complete GP/NZCV axis absent: %s\n%s", test.name, output)
+		}
+	}
+	t.Logf("ORIGINAL_KERNEL_OUTPUT_BEGIN\n%sORIGINAL_KERNEL_OUTPUT_END", output)
+	// Original processes have different PIDs. Each checks its own true PID;
+	// only numerical canaries and independently calculated flags are compared.
+	pkg := mustGoPackage(t, packagePath, declarations)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := arm64LinuxSyscallEffectTranslate(t, api, pkg, assembly)
+			if err != nil {
+				t.Fatalf("SYSCALL_EFFECT_CONSUMER_RED after actual original kernel P: %v", err)
+			}
+			for _, optimization := range []int{0, 2} {
+				t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+					for _, test := range arm64LinuxSyscallEffectCases() {
+						t.Run(test.name, func(t *testing.T) {
+							shim, driver := arm64LinuxSyscallEffectRuntimeChecks(packagePath, test)
+							compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "kernel_effects", triple,
+								ir+shim, driver, runner, optimization)
+							// Compilation/linking alone never establishes this marker.
+							t.Logf("LLVM_KERNEL_AXIS_PASS %s %s O%d", test.name, api, optimization)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_local_control.go b/arm64_local_control.go
new file mode 100644
index 000000000..26b8dd60d
--- /dev/null
+++ b/arm64_local_control.go
@@ -0,0 +1,1007 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Local code addresses stay opaque LLVM blockaddresses. A reaching-definition proof,
+// not an address comparison, distinguishes local control flow from native calls.
+// Memory provenance is retained only for exactly identified owned frame cells.
+// Values are immutable after publication. Clones share exact set roots;
+// transforms replace roots instead of mutating a reaching definition.
+type arm64ControlState struct {
+	targetTriple string // one exact translator target, never inferred from state
+	regs         map[Reg]arm64ControlValue
+	memory       map[string]arm64ControlValue
+	escaped      arm64ControlValue
+	unexposedSP  bool                  // original/normalized source and fresh-entry proof, not FP
+	privateStore *arm64PrivateDataSpan // only the instruction currently being transferred
+}
+
+type arm64LocalControlPlan struct {
+	before      map[[2]int]arm64ControlValue
+	stackBefore map[[2]int]arm64ControlValue
+	linkBefore  map[[2]int]arm64ControlValue
+	reachable   []bool
+	outer       string
+	autoFrame   bool
+}
+
+type arm64GoFrame struct {
+	present      bool
+	restoresLink bool
+}
+
+// Go obj7 marks only source ABL instructions nonleaf, before expanding raw
+// AWORD instructions. A decoded WORD BL must not invent a Go LR/FP prologue.
+func arm64SourceGoFrame(fn Func) arm64GoFrame {
+	noFrame, leaf := fn.FrameSize == -8, true
+	for _, ins := range fn.Instrs {
+		op := arm64ControlOp(ins)
+		if (op == "BL" || op == "CALL") && !ins.arm64RawLocalCall {
+			leaf = false
+		}
+		if op != OpTEXT {
+			continue
+		}
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) != 3 {
+			continue
+		}
+		if flags, ok := parseImmExpr(strings.TrimSpace(parts[1])); ok {
+			noFrame = noFrame || flags&512 != 0 // objabi.NOFRAME
+		} else {
+			for _, flag := range strings.Split(parts[1], "|") {
+				noFrame = noFrame || strings.TrimSpace(flag) == "NOFRAME"
+			}
+		}
+	}
+	present := !noFrame && (!leaf || fn.FrameSize > 0)
+	return arm64GoFrame{present: present, restoresLink: present && !leaf}
+}
+
+func arm64ControlExternal() arm64ControlValue { return arm64ControlFromMap(map[string]bool{"": true}) }
+
+func arm64ControlRead(values map[Reg]arm64ControlValue, reg Reg) arm64ControlValue {
+	reg = arm64ControlBase(reg)
+	value := values[reg]
+	// F, V lanes and SVE Z views share physical storage. Provenance cannot
+	// disappear merely because the next typed read uses another view. Retain
+	// all alias witnesses conservatively; this is not a partial-write proof.
+	root := arm64MachineRegister(reg)
+	if strings.HasPrefix(root, "V") {
+		for alias, witness := range values {
+			if arm64MachineRegister(alias) == root {
+				value = arm64ControlUnion(value, witness)
+			}
+		}
+	}
+	if value == nil {
+		return arm64ControlExternal()
+	}
+	return value
+}
+
+func (state *arm64ControlState) clone() *arm64ControlState {
+	next := &arm64ControlState{
+		targetTriple: state.targetTriple,
+		regs:         make(map[Reg]arm64ControlValue),
+		memory:       make(map[string]arm64ControlValue),
+		escaped:      state.escaped,
+		unexposedSP:  state.unexposedSP,
+	}
+	for reg, value := range state.regs {
+		next.regs[reg] = value
+	}
+	for key, value := range state.memory {
+		next.memory[key] = value
+	}
+	return next
+}
+
+func (state *arm64ControlState) merge(other *arm64ControlState) bool {
+	changed := false
+	var operations arm64ControlMergeOperations
+	if state.unexposedSP && !other.unexposedSP {
+		state.unexposedSP, changed = false, true
+	}
+	escaped := operations.union(state.escaped, state.escaped, other.escaped)
+	if escaped.changed {
+		state.escaped, changed = escaped.value, true
+	}
+	for reg, value := range other.regs {
+		merged := operations.union(state.regs[reg], arm64ControlRead(state.regs, reg), value)
+		if merged.changed {
+			state.regs[reg], changed = merged.value, true
+		}
+	}
+	for reg, value := range state.regs {
+		if other.regs[reg] == nil {
+			merged := operations.union(value, value, arm64ControlExternal())
+			if merged.changed {
+				state.regs[reg], changed = merged.value, true
+			}
+		}
+	}
+	for key, value := range other.memory {
+		old := state.memory[key]
+		if old == nil {
+			old = arm64ControlExternal()
+		}
+		merged := operations.union(state.memory[key], old, value)
+		if merged.changed {
+			state.memory[key], changed = merged.value, true
+		}
+	}
+	for key, value := range state.memory {
+		if other.memory[key] == nil {
+			merged := operations.union(value, value, arm64ControlExternal())
+			if merged.changed {
+				state.memory[key], changed = merged.value, true
+			}
+		}
+	}
+	return changed
+}
+
+func arm64ControlBase(reg Reg) Reg {
+	if reg == Reg("RSP") {
+		return SP
+	}
+	return reg
+}
+
+func arm64ControlOffset(value arm64ControlValue, off int64) arm64ControlValue {
+	if off != 0 {
+		for _, token := range arm64ControlKeys(value) {
+			if strings.HasPrefix(token, "label:") || token == "code-derived:" {
+				// A native-PC transform is not a pure escaped code pointer.
+				// Retain this fact even when a CFG join already has unknown data.
+				return arm64ControlFromMap(map[string]bool{"": true, "code-derived:": true})
+			}
+		}
+	}
+	if arm64ControlCount(value) != 1 {
+		return arm64ControlExternal()
+	}
+	for _, token := range arm64ControlKeys(value) {
+		if strings.HasPrefix(token, "fpa:") {
+			if off == 0 {
+				return value
+			}
+			// FP-address allocas are per scalar slot, unlike the contiguous
+			// SP backing frame. Adding bytes cannot prove the adjacent slot.
+			return arm64ControlExternal()
+		}
+		if !strings.HasPrefix(token, "sp:") && !strings.HasPrefix(token, "fp:") {
+			return arm64ControlExternal()
+		}
+		base, err := strconv.ParseInt(token[3:], 10, 64)
+		if err != nil || (off > 0 && base > int64(1<<63-1)-off) || (off < 0 && base < int64(-1<<63)-off) {
+			return arm64ControlExternal()
+		}
+		return arm64ControlFromMap(map[string]bool{token[:3] + strconv.FormatInt(base+off, 10): true})
+	}
+	return arm64ControlExternal()
+}
+
+func (state *arm64ControlState) memoryKey(op Operand, post bool) string {
+	if op.Kind == OpFP || op.Kind == OpFPAddr {
+		return "fp:" + strconv.FormatInt(op.FPOffset, 10)
+	}
+	if op.Kind != OpMem || op.Mem.Index != "" || op.Mem.OffRaw != "" {
+		return ""
+	}
+	off := op.Mem.Off
+	if post {
+		off = 0
+	}
+	value := arm64ControlOffset(arm64ControlRead(state.regs, arm64ControlBase(op.Mem.Base)), off)
+	if arm64ControlCount(value) == 1 {
+		for _, token := range arm64ControlKeys(value) {
+			if strings.HasPrefix(token, "fpa:") {
+				return "fp:" + token[4:]
+			}
+			return token
+		}
+	}
+	return ""
+}
+
+func (state *arm64ControlState) source(op Operand, post bool) arm64ControlValue {
+	if op.Kind == OpReg {
+		return arm64ControlRead(state.regs, arm64ControlBase(op.Reg))
+	}
+	if op.Kind == OpFPAddr {
+		return arm64ControlFromMap(map[string]bool{"fpa:" + strconv.FormatInt(op.FPOffset, 10): true})
+	}
+	if key := state.memoryKey(op, post); key != "" && state.memory[key] != nil {
+		if state.unexposedSP && strings.HasPrefix(key, "sp:") && arm64ControlEscapedOnlyCode(state.escaped) {
+			return state.memory[key]
+		}
+		return arm64ControlUnion(state.memory[key], arm64ControlLabels(state.escaped))
+	}
+	if op.Kind == OpMem || op.Kind == OpFP || op.Kind == OpSym {
+		return arm64ControlUnion(arm64ControlExternal(), state.escaped)
+	}
+	return arm64ControlExternal()
+}
+
+func (state *arm64ControlState) write(op Operand, value arm64ControlValue, post bool) {
+	if op.Kind == OpReg && op.Reg != ZR {
+		state.regs[arm64ControlBase(op.Reg)] = value
+	} else if key := state.memoryKey(op, post); key != "" {
+		// Any nonidentical cell may overlap (including through unknown aliases).
+		// Preserve a tainted local address rather than silently reclassify a
+		// partially overwritten pointer as an external native address.
+		state.invalidateOverlappingControlCells(key, 8)
+		state.memory[key] = value
+	} else if op.Kind == OpMem || op.Kind == OpFP || op.Kind == OpSym {
+		state.invalidateUnknownStore(op, value)
+	} else if op.Kind == OpRegList {
+		for _, reg := range op.RegList {
+			state.write(Operand{Kind: OpReg, Reg: reg}, value, false)
+		}
+	}
+}
+
+func (state *arm64ControlState) invalidateUnknownStore(destination Operand, value arm64ControlValue) {
+	state.escaped = arm64ControlUnion(state.escaped, arm64ControlAddressTaint(value))
+	// The whole-function proof excludes escaping this allocation's address.
+	// Locally read affine aliases remain explicit SP tokens below; an incoming
+	// pointer or SB global therefore cannot name its SP
+	// cells. Explicit SP-relative indexing remains potentially overlapping even
+	// when the exact displacement is unknown; it must not borrow this exception.
+	preserveSP := state.unexposedSP && arm64ControlEscapedOnlyCode(state.escaped)
+	if destination.Kind == OpMem {
+		for _, reg := range []Reg{destination.Mem.Base, destination.Mem.Index} {
+			base := arm64ControlBase(reg)
+			if state.privateStore == nil {
+				preserveSP = preserveSP && base != SP
+			}
+			for _, token := range arm64ControlKeys(arm64ControlRead(state.regs, base)) {
+				if token == "code-derived:" || state.privateStore == nil && strings.HasPrefix(token, "sp:") {
+					preserveSP = false
+				}
+			}
+		}
+	}
+	for key, old := range state.memory {
+		if state.privateStore != nil && strings.HasPrefix(key, "sp:") {
+			start, err := strconv.ParseInt(key[3:], 10, 64)
+			if err == nil && start >= 0 && start <= int64(1<<63-1)-8 {
+				if start+8 <= state.privateStore.low || start >= state.privateStore.end {
+					if preserveSP {
+						continue
+					}
+				} else {
+					state.memory[key] = arm64ControlUnion(arm64ControlUnion(old, value), arm64ControlExternal())
+					continue
+				}
+			}
+		}
+		if preserveSP && strings.HasPrefix(key, "sp:") {
+			continue
+		}
+		state.memory[key] = arm64ControlUnion(old, arm64ControlExternal())
+	}
+}
+
+func arm64ControlEscapedOnlyCode(value arm64ControlValue) bool {
+	for _, token := range arm64ControlKeys(value) {
+		if !strings.HasPrefix(token, "label:") {
+			return false
+		}
+	}
+	return true
+}
+
+func (state *arm64ControlState) invalidateOverlappingControlCells(key string, width int64) {
+	if len(key) < 4 {
+		return
+	}
+	off, err := strconv.ParseInt(key[3:], 10, 64)
+	if err != nil {
+		return
+	}
+	for other, value := range state.memory {
+		if len(other) < 4 || other[:3] != key[:3] {
+			continue
+		}
+		start, err := strconv.ParseInt(other[3:], 10, 64)
+		if err != nil {
+			continue
+		}
+		// Unsigned distances avoid signed overflow at either int64 boundary.
+		overlaps := (start <= off && uint64(off)-uint64(start) < 8) ||
+			(start > off && uint64(start)-uint64(off) < uint64(width))
+		if overlaps {
+			state.memory[other] = arm64ControlUnion(value, arm64ControlExternal())
+		}
+	}
+}
+
+func arm64ControlElement(op Operand, offset int64) Operand {
+	if op.Kind == OpFP {
+		op.FPOffset += offset
+	} else if op.Kind == OpMem {
+		op.Mem.Off += offset
+	}
+	return op
+}
+
+func arm64ControlOp(ins Instr) Op {
+	op := strings.ToUpper(string(ins.Op))
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		op = op[:dot]
+	}
+	return Op(op)
+}
+
+func arm64ControlDecode(ins Instr) Instr {
+	if ins.Op == OpWORD {
+		if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+			if form, ok := decodeARM64RawDCZVA(uint32(ins.Args[0].Imm)); ok {
+				decoded := arm64DCZVAInstruction(form)
+				decoded.Raw = ins.Raw
+				return decoded
+			}
+		}
+		if decoded, err := decodeARM64RawWordInstruction(ins); err == nil {
+			return arm64HardwareReturnAsBranch(decoded)
+		}
+	}
+	return ins
+}
+
+// A hardware RET word has no Go-generated frame epilogue. Its branch effect
+// must not be confused with the source-level RET pseudo instruction.
+func arm64HardwareReturnAsBranch(ins Instr) Instr {
+	if ins.Op != OpRET {
+		return ins
+	}
+	target, ok := arm64RegisterReturnTarget(ins, false)
+	if !ok {
+		return ins
+	}
+	if target.Kind == OpReg {
+		target = Operand{Kind: OpMem, Mem: MemRef{Base: target.Reg}}
+	}
+	ins.Op, ins.Args = "B", []Operand{target}
+	return ins
+}
+
+func (c *arm64Ctx) prepareLocalControl() error {
+	if c.nanosleepRequired && c.nanosleepInput == nil {
+		return fmt.Errorf("%w: Linux nanosleep needs a complete initialized private input", ErrProbeNeedsContext)
+	}
+	plan := &arm64LocalControlPlan{
+		before:      make(map[[2]int]arm64ControlValue),
+		stackBefore: make(map[[2]int]arm64ControlValue),
+		linkBefore:  make(map[[2]int]arm64ControlValue),
+	}
+	plan.autoFrame = c.sourceGoFrame.present
+	indices := make(map[string]int, len(c.blocks))
+	for index, block := range c.blocks {
+		indices[block.name] = index
+	}
+	// The caller link has a distinguished abstract return destination. Its
+	// actual value comes from llvm.returnaddress, never a fake blockaddress.
+	plan.outer = "__arm64_caller_return"
+	for indices[plan.outer] != 0 || c.blocks[0].name == plan.outer {
+		plan.outer += "_"
+	}
+	if precise := c.rawZeroContextControlPlan(plan.outer); precise != nil {
+		c.localControl = precise
+		return nil
+	}
+	entry := &arm64ControlState{
+		targetTriple: c.targetTriple,
+		regs: map[Reg]arm64ControlValue{
+			SP:         arm64ControlFromMap(map[string]bool{"sp:0": true}),
+			Reg("R30"): arm64ControlFromMap(map[string]bool{"label:" + plan.outer: true}),
+		},
+		memory:      make(map[string]arm64ControlValue),
+		unexposedSP: c.unexposedCallFrame,
+	}
+	if c.sourceGoFrame.present {
+		entry.memory["sp:0"] = entry.regs[Reg("R30")]
+	}
+	if c.sourceFrameR20 {
+		entry.regs["R20"] = arm64ControlFromMap(map[string]bool{"sp:0": true})
+	}
+	for _, reg := range c.sig.ArgRegs {
+		entry.regs[reg] = arm64ControlExternal()
+	}
+	before := make([]*arm64ControlState, len(c.blocks))
+	before[0] = entry
+	queue, queued := []int{0}, make([]bool, len(c.blocks))
+	queued[0] = true
+	propagate := func(index int, state *arm64ControlState) {
+		if index < 0 || index >= len(before) {
+			return
+		}
+		changed := false
+		if before[index] == nil {
+			before[index], changed = state.clone(), true
+		} else {
+			changed = before[index].merge(state)
+		}
+		if changed && !queued[index] {
+			queue, queued[index] = append(queue, index), true
+		}
+	}
+	for next := 0; next < len(queue); next++ {
+		bi := queue[next]
+		queued[bi] = false
+		state := before[bi].clone()
+		terminated := false
+		for ii, original := range c.blocks[bi].instrs {
+			ins := arm64ControlDecode(original)
+			op := arm64ControlOp(ins)
+			post := strings.HasSuffix(string(ins.Op), ".P")
+			if op == "SVC" {
+				if _, err := parseARM64SyscallForm(c.targetTriple, ins); err != nil {
+					return err
+				}
+				if err := c.requireSyscallCallerFrameDisjointAt(state, ins, [2]int{bi, ii}); err != nil {
+					return err
+				}
+			}
+			if op == "B" || op == "JMP" || op == OpRET {
+				plan.stackBefore[[2]int{bi, ii}] = arm64ControlRead(state.regs, SP)
+				link := arm64ControlRead(state.regs, Reg("R30"))
+				if op == OpRET && c.sourceGoFrame.restoresLink {
+					link = state.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP}}, false)
+				}
+				plan.linkBefore[[2]int{bi, ii}] = link
+			}
+			if op == "BL" || op == "BLR" || op == "CALL" {
+				if len(ins.Args) != 1 || bi+1 >= len(c.blocks) {
+					continue // The ordinary grammar diagnoses malformed calls.
+				}
+				if ins.Args[0].Kind == OpReg || (ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Base != PC) {
+					value := state.branchValue(ins.Args[0])
+					plan.before[[2]int{bi, ii}] = value
+					state.regs[Reg("R30")] = arm64ControlFromMap(map[string]bool{"label:" + c.blocks[bi+1].name: true})
+					for _, token := range arm64ControlKeys(value) {
+						if strings.HasPrefix(token, "label:") {
+							if target, ok := indices[token[6:]]; ok {
+								propagate(target, state)
+							}
+						} else {
+							nativeState := state.clone()
+							c.invalidateControlCallResults(nativeState, Operand{})
+							propagate(bi+1, nativeState)
+						}
+					}
+					terminated = true
+					break
+				}
+				state.regs[Reg("R30")] = arm64ControlFromMap(map[string]bool{"label:" + c.blocks[bi+1].name: true})
+				if arm64IsLocalBranchLink(ins) {
+					if name, ok := arm64BranchTarget(ins.Args[0]); ok {
+						if target, ok := indices[name]; ok {
+							propagate(target, state)
+						}
+					}
+				} else {
+					c.invalidateControlCallResults(state, ins.Args[0])
+					propagate(bi+1, state)
+				}
+				terminated = true
+				break
+			}
+			if op == "B" || op == "JMP" {
+				if len(ins.Args) == 1 {
+					if ins.Args[0].Kind == OpReg || ins.Args[0].Kind == OpMem {
+						value := state.branchValue(ins.Args[0])
+						plan.before[[2]int{bi, ii}] = value
+						for _, token := range arm64ControlKeys(value) {
+							if strings.HasPrefix(token, "label:") {
+								if target, ok := indices[token[6:]]; ok {
+									propagate(target, state)
+								}
+							}
+						}
+					} else if name, ok := arm64BranchTarget(ins.Args[0]); ok {
+						if target, ok := indices[name]; ok {
+							propagate(target, state)
+						}
+					}
+				}
+				terminated = true
+				break
+			}
+			if op == OpRET {
+				if target, register := arm64RegisterReturnTarget(ins, plan.autoFrame); register {
+					value := state.branchValue(target)
+					plan.before[[2]int{bi, ii}] = value
+					for _, token := range arm64ControlKeys(value) {
+						if strings.HasPrefix(token, "label:") {
+							if target, ok := indices[token[6:]]; ok {
+								propagate(target, state)
+							}
+						}
+					}
+				}
+				terminated = true
+				break
+			}
+			if arm64IsConditionalBranch(op) {
+				if len(ins.Args) != 0 {
+					if name, ok := arm64BranchTarget(ins.Args[len(ins.Args)-1]); ok {
+						if target, ok := indices[name]; ok {
+							propagate(target, state)
+						}
+					}
+				}
+				propagate(bi+1, state)
+				terminated = true
+				break
+			}
+			if c.unexposedCallFrame {
+				if span, bounded := c.privateDataStores[[2]int{bi, ii}]; bounded {
+					state.privateStore = &span
+				}
+			}
+			if !state.transferStructureMemory(original) {
+				state.transfer(ins, op, post, c.rawDataGlobals)
+			}
+			state.privateStore = nil
+		}
+		if !terminated {
+			propagate(bi+1, state)
+		}
+	}
+	plan.reachable = make([]bool, len(before))
+	for index, state := range before {
+		plan.reachable[index] = state != nil
+	}
+	c.localControl = plan
+	return nil
+}
+
+// Eliding a scheduler hook does not make the intervening syscall memory-neutral.
+// The emitted syscall bridge transports GP arguments, not the virtual SP root.
+// Preserve an automatic frame's saved caller LR only under the existing complete
+// fresh/non-escaping source proof and with no reaching frame/code-derived input.
+// R8 and R16 cover both number-register alternatives in lowerSyscall. This is a
+// disjointness guard, not a contract for arbitrary native exception effects or
+// an assertion that the syscall's result/NZCV mapping is complete.
+func (c *arm64Ctx) requireSyscallCallerFrameDisjoint(state *arm64ControlState, ins Instr) error {
+	return c.requireSyscallCallerFrameDisjointAt(state, ins, [2]int{c.currentBlock, c.currentInstruction})
+}
+
+func (c *arm64Ctx) requireSyscallCallerFrameDisjointAt(state *arm64ControlState, ins Instr, point [2]int) error {
+	if !c.sourceGoFrame.present {
+		return nil
+	}
+	if input, present := c.nanosleepInputAt(point); present {
+		address := arm64ControlRead(state.regs, "R0")
+		expected := arm64ControlFromMap(map[string]bool{fmt.Sprintf("sp:%d", input.span.low): true})
+		if c.unexposedCallFrame && state.unexposedSP && arm64ControlEscapedOnlyCode(state.escaped) &&
+			arm64ControlEqual(address, expected) {
+			return nil // exact read-only span; never an unknown-store exemption
+		}
+	}
+	exposed := state.escaped
+	for _, reg := range []Reg{"R0", "R1", "R2", "R3", "R4", "R5", "R8", "R16"} {
+		exposed = arm64ControlUnion(exposed, arm64ControlAddressTaint(arm64ControlRead(state.regs, reg)))
+	}
+	if !c.unexposedCallFrame || !state.unexposedSP || !arm64ControlEscapedOnlyCode(exposed) {
+		return fmt.Errorf("%w: ARM64 syscall has no disjoint saved caller-frame memory proof: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	return nil
+}
+
+// A dead source terminator has neither an unknown native target nor a caller
+// return. Retain its grammar validation, then terminate its LLVM block without
+// fabricating execution. Other instructions in the block are still lowered.
+func (c *arm64Ctx) lowerProvenUnreachableControl(bi int) bool {
+	if c.localControl == nil || bi < 0 || bi >= len(c.localControl.reachable) || c.localControl.reachable[bi] {
+		return false
+	}
+	c.b.WriteString("  unreachable\n")
+	return true
+}
+
+// The implicit Go frame is separate from explicit source-level SP arithmetic.
+// Go's RET epilogue pops a constant implicit frame; it does not repair a manual
+// SP delta. LLVM also restores its native frame on return, so synthesizing an
+// LLVM return is valid only when every reaching path restored the virtual SP.
+func (c *arm64Ctx) requireCallerSPRestored(bi int, ins Instr) error {
+	if c.localControl == nil {
+		return fmt.Errorf("%w: ARM64 caller return has no SP reaching-definition proof: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	value := c.localControl.stackBefore[[2]int{bi, c.currentInstruction}]
+	if arm64ControlCount(value) != 1 || !arm64ControlHas(value, "sp:0") {
+		return fmt.Errorf("%w: ARM64 caller return requires restored entry SP on every reaching path: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	return nil
+}
+
+func (c *arm64Ctx) requireCallerLinkRestored(bi int, ins Instr) error {
+	if c.localControl == nil {
+		return fmt.Errorf("%w: ARM64 caller return has no LR reaching-definition proof: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	value := c.localControl.linkBefore[[2]int{bi, c.currentInstruction}]
+	if arm64ControlCount(value) != 1 || !arm64ControlHas(value, "label:"+c.localControl.outer) {
+		return fmt.Errorf("%w: ARM64 caller return requires the caller LR on every reaching path: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	return nil
+}
+
+func (state *arm64ControlState) branchValue(op Operand) arm64ControlValue {
+	reg := op.Reg
+	if op.Kind == OpMem {
+		reg = op.Mem.Base
+		// Branch register encoding 31 reads XZR, never the memory-address SP.
+		if reg == SP || reg == Reg("RSP") {
+			return arm64ControlExternal()
+		}
+	}
+	return arm64ControlRead(state.regs, reg)
+}
+
+func arm64RegisterReturnTarget(ins Instr, hasGoFrame bool) (Operand, bool) {
+	if len(ins.Args) == 0 {
+		return Operand{Kind: OpReg, Reg: Reg("R30")}, !hasGoFrame
+	}
+	if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm {
+		return Operand{Kind: OpReg, Reg: Reg("R30")}, !hasGoFrame
+	}
+	if len(ins.Args) != 1 || (ins.Args[0].Kind != OpReg && ins.Args[0].Kind != OpMem) {
+		return Operand{}, false
+	}
+	target := ins.Args[0]
+	reg := target.Reg
+	if target.Kind == OpMem {
+		reg = target.Mem.Base
+		target.Mem.Off, target.Mem.OffRaw, target.Mem.Index = 0, "", ""
+	}
+	if reg == SP || reg == Reg("RSP") {
+		target = Operand{Kind: OpReg, Reg: ZR}
+	}
+	return target, !hasGoFrame || reg != Reg("R30")
+}
+
+func arm64IsConditionalBranch(op Op) bool {
+	switch op {
+	case "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT", "BHS", "BLS", "BMI", "BPL", "BVS", "BVC", "BCC", "BCS", "CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ":
+		return true
+	}
+	return false
+}
+
+func (state *arm64ControlState) transfer(ins Instr, op Op, post bool, data map[string]string) {
+	if immediate, handled, err := parseARM64GPImmediateForm(op, ins); handled && err == nil && immediate.scratch {
+		state.regs["R27"] = arm64ControlExternal()
+	}
+	if state.transferStructureMemory(ins) {
+		return
+	}
+	if op == "SVC" {
+		// Retain input PC taint for new results. Only the target's real
+		// outputs lose their old continuation; Linux does not write R1.
+		result := arm64ControlExternal()
+		for _, reg := range []Reg{"R0", "R1", "R2", "R3", "R4", "R5", "R8", "R16"} {
+			result = arm64ControlUnion(result, arm64ControlLabels(arm64ControlRead(state.regs, reg)))
+		}
+		form, err := parseARM64SyscallForm(state.targetTriple, ins)
+		writes := uint32(3) // Unknown contexts cannot invent preservation.
+		if err == nil {
+			writes = form.gpWrites
+		}
+		for register := 0; register < 31; register++ {
+			if writes&(1<<uint(register)) != 0 {
+				state.regs[Reg(fmt.Sprintf("R%d", register))] = result
+			}
+		}
+		return
+	}
+	if len(ins.Args) == 0 {
+		return
+	}
+	if form, handled, err := parseARM64CacheForm(op, ins); handled && err == nil && form.operation == "ZVA" {
+		// Neither address nor GP/NZCV state is written. The granule size and
+		// downward alignment are architectural runtime values, so no owned
+		// continuation cell can remain a known saved LR/FP pointer contents.
+		for key, value := range state.memory {
+			state.memory[key] = arm64ControlUnion(value, arm64ControlExternal())
+		}
+		return
+	}
+	if op == OpWORD {
+		writes, known := uint32(0), false
+		stores := true
+		if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+			word := uint32(ins.Args[0].Imm)
+			if effects, ok := arm64RawContinuationEffectsForWord(word); ok {
+				writes, stores, known = effects.gpWrites, effects.stores, true
+			} else if effects, ok := arm64RawSVEEffects(word); ok {
+				writes, stores, known = effects.gpWrites, effects.stores, true
+			} else {
+				writes, known = arm64RawPoolGPWrites(word)
+			}
+		}
+		for reg, value := range state.regs {
+			index, gp := arm64StackIndex(reg)
+			if gp && (!known || writes&(1<<uint(index)) != 0) {
+				state.regs[reg] = arm64ControlUnion(value, arm64ControlExternal())
+			}
+		}
+		if stores {
+			for key, value := range state.memory {
+				state.memory[key] = arm64ControlUnion(value, arm64ControlExternal())
+			}
+		}
+		return
+	}
+	if form, handled, err := parseARM64AtomicPairForm(op, ins); handled && err == nil {
+		state.transferAtomicPair(form)
+		return
+	}
+	if state.transferScalarAtomicStore(ins, op) {
+		return
+	}
+	if state.transferTypedMemory(ins) {
+		return
+	}
+	if inputs, destination, valid := arm64ScalarMultiplyInputs(op, ins); valid {
+		value := arm64ControlExternal()
+		for _, input := range inputs {
+			value = arm64ControlUnion(value, arm64ControlLabels(state.source(input, false)))
+		}
+		if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+			value = arm64ControlWithToken(value, "code-derived:") // Multiplication is not a pure PC copy.
+		}
+		state.write(destination, value, false)
+		return
+	}
+	if op == "ADR" && len(ins.Args) == 2 {
+		if target, ok := arm64BranchTarget(ins.Args[0]); ok && data[target] == "" {
+			state.write(ins.Args[1], arm64ControlFromMap(map[string]bool{"label:" + target: true}), false)
+			return
+		}
+	}
+	if form, handled, err := parseARM64RegisterAddressForm(op, ins); handled && err == nil {
+		if form.usesScratch {
+			state.regs[Reg("R27")] = arm64ControlExternal()
+		}
+		value := state.source(Operand{Kind: OpReg, Reg: form.base}, false)
+		if form.offset != 0 {
+			value = arm64ControlUnion(arm64ControlOffset(value, form.offset), arm64ControlLabels(value))
+		}
+		state.write(ins.Args[1], value, false)
+		return
+	}
+	if state.transferGPRegisterMove(ins) {
+		return
+	}
+	if op == "MOVD" && len(ins.Args) == 2 && !(ins.Args[0].Kind == OpImm && ins.Args[0].ImmIsFloat) {
+		value := state.source(ins.Args[0], post)
+		state.write(ins.Args[1], value, post)
+	} else if (op == "LDP" || op == "STP") && len(ins.Args) == 2 {
+		memory, pair := ins.Args[0], ins.Args[1]
+		if op == "STP" {
+			pair, memory = ins.Args[0], ins.Args[1]
+		}
+		if pair.Kind != OpRegList || len(pair.RegList) != 2 {
+			return // The typed operand grammar rejects the malformed pair.
+		}
+		if post && memory.Kind == OpMem {
+			memory.Mem.Off = 0
+		}
+		var values [2]arm64ControlValue
+		for index, reg := range pair.RegList {
+			source := Operand{Kind: OpReg, Reg: reg}
+			if op == "LDP" {
+				source = arm64ControlElement(memory, int64(index)*8)
+			}
+			values[index] = state.source(source, false)
+		}
+		for index, reg := range pair.RegList {
+			destination := arm64ControlElement(memory, int64(index)*8)
+			if op == "LDP" {
+				destination = Operand{Kind: OpReg, Reg: reg}
+			}
+			state.write(destination, values[index], false)
+		}
+	} else if (op == "ADD" || op == "SUB") && len(ins.Args) >= 2 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		src, dst := ins.Args[1], ins.Args[len(ins.Args)-1]
+		off := ins.Args[0].Imm
+		if op == "SUB" {
+			if off == int64(-1<<63) {
+				state.write(dst, arm64ControlExternal(), false)
+				return
+			}
+			off = -off
+		}
+		value := state.source(src, false)
+		if off != 0 {
+			value = arm64ControlUnion(arm64ControlOffset(value, off), arm64ControlLabels(value))
+		}
+		state.write(dst, value, false)
+	} else if state.transferGPData(ins) {
+		return
+	} else {
+		switch op {
+		case "CMP", "CMPW", "CMN", "CMNW", "TST", "TSTW", "CCMP", "CCMPW", "CCMN", "CCMNW", "PCDATA", "FUNCDATA":
+			return
+		}
+		// Unmodeled transforms of code addresses are tainted, not native
+		// addresses. This deliberately fails closed even if a bit trick could
+		// happen to reconstitute the original blockaddress at runtime.
+		value := arm64ControlExternal()
+		for _, arg := range ins.Args {
+			value = arm64ControlUnion(value, arm64ControlLabels(state.source(arg, post)))
+			for _, reg := range arg.RegList {
+				value = arm64ControlUnion(value, arm64ControlLabels(arm64ControlRead(state.regs, reg)))
+			}
+		}
+		destination := ins.Args[len(ins.Args)-1]
+		if destination.Kind == OpReg && arm64ControlCount(value) > 1 {
+			for _, token := range arm64ControlKeys(value) {
+				if strings.HasPrefix(token, "label:") {
+					value = arm64ControlWithToken(value, "code-derived:")
+					break
+				}
+			}
+		}
+		if key := state.memoryKey(destination, post); key != "" {
+			state.invalidateOverlappingControlCells(key, 64)
+			value = arm64ControlUnion(value, arm64ControlLabels(state.memory[key]))
+		}
+		state.write(destination, value, post)
+	}
+	if post || strings.HasSuffix(string(ins.Op), ".W") {
+		for _, operand := range ins.Args {
+			if operand.Kind == OpMem {
+				base := arm64ControlBase(operand.Mem.Base)
+				state.regs[base] = arm64ControlOffset(arm64ControlRead(state.regs, base), operand.Mem.Off)
+			}
+		}
+	}
+}
+
+func (c *arm64Ctx) invalidateControlCallResults(state *arm64ControlState, operand Operand) {
+	name := c.resolve(strings.TrimSuffix(operand.Sym, "(SB)"))
+	if operand.Kind == OpSym && strings.HasSuffix(operand.Sym, "(SB)") && arm64ElidesSchedulerHook(name) {
+		return
+	}
+	sig, known := c.sigs[name]
+	possibleCode := arm64ControlLabels(state.escaped)
+	returnValue := arm64ControlUnion(arm64ControlExternal(), possibleCode)
+	mayWriteFrame := !known || arm64ControlCount(state.escaped) != 0
+	internal := strings.HasSuffix(strings.TrimSuffix(operand.Sym, "(SB)"), "<ABIInternal>")
+	inputs, transport := arm64ControlCallInputs(state, sig, internal)
+	callTransportKnown := known && operand.Kind == OpSym && transport
+	mayWriteFrame = mayWriteFrame || !callTransportKnown
+	for _, value := range inputs {
+		state.escaped = arm64ControlUnion(state.escaped, arm64ControlAddressTaint(value))
+		returnValue = arm64ControlUnion(returnValue, arm64ControlLabels(value))
+		for _, token := range arm64ControlKeys(value) {
+			if strings.HasPrefix(token, "sp:") || strings.HasPrefix(token, "fp:") || strings.HasPrefix(token, "fpa:") {
+				mayWriteFrame = true
+			}
+		}
+	}
+	for _, typ := range sig.Args {
+		mayWriteFrame = mayWriteFrame || arm64CallTypeMayContainPointer(typ)
+	}
+	// The typed LLVM call transports only the inputs above, not virtual GP
+	// allocas or the automatic R30 continuation blockaddress. This distinction
+	// requires the whole-function fresh/non-escaping SP proof. Unknown ABI,
+	// hidden context and exposed frames retain the conservative all-GP model.
+	// Actual transported/escaped source PC taint remains in returnValue; old
+	// GP witnesses are still retained below, without caller-save preservation.
+	privateInputs := callTransportKnown && c.sourceGoFrame.present && c.unexposedCallFrame && state.unexposedSP &&
+		(arm64ControlCount(state.escaped) == 0 || arm64ControlEscapedOnlyCode(state.escaped))
+	if !privateInputs {
+		for _, value := range state.regs {
+			returnValue = arm64ControlUnion(returnValue, arm64ControlLabels(value))
+		}
+	}
+	for index := 0; index < 31; index++ {
+		reg := Reg(fmt.Sprintf("R%d", index))
+		if reg != Reg("R30") {
+			state.regs[reg] = arm64ControlUnion(arm64ControlRead(state.regs, reg), returnValue)
+		}
+	}
+	if mayWriteFrame {
+		// FP slots can alias an incoming pointer and must still be invalidated.
+		// Only this invocation's fresh, unexposed SP object is disjoint from
+		// declared call values. Actual frame-address arguments, prior escape,
+		// unknown calls and unproved source/raw forms retain the old clobber.
+		// A conservative callee result may carry the caller's code address.
+		// Storing that value does not reveal this fresh allocation's address.
+		// Only the separately proven entry/source state can distinguish this
+		// case; legacy/default states keep the original any-escape clobber.
+		unexposed := arm64ControlCount(state.escaped) == 0 || state.unexposedSP && arm64ControlEscapedOnlyCode(state.escaped)
+		preserveSP := callTransportKnown && c.sourceGoFrame.present && c.unexposedCallFrame && unexposed
+		for key, value := range state.memory {
+			if preserveSP && strings.HasPrefix(key, "sp:") {
+				continue
+			}
+			state.memory[key] = arm64ControlUnion(value, returnValue)
+		}
+	}
+	if !known {
+		return
+	}
+	arm64ControlWriteCallResults(state, sig, internal, returnValue)
+}
+
+func arm64ControlWriteCallResults(state *arm64ControlState, sig FuncSig, internal bool, value arm64ControlValue) {
+	if internal && sig.ARM64GoRegisterABI != nil {
+		for _, result := range sig.ARM64GoRegisterABI.Results {
+			state.regs[result.Register] = value
+		}
+		return
+	}
+	if !internal && len(sig.ArgRegs) == 0 && len(sig.Frame.Results) != 0 {
+		for _, result := range sig.Frame.Results {
+			if result.Offset > 1<<63-1-8 {
+				continue // The ordinary ABI0 result lowerer rejects this offset.
+			}
+			key := state.memoryKey(Operand{Kind: OpMem, Mem: MemRef{Base: SP, Off: result.Offset + 8}}, false)
+			if key != "" {
+				written := value
+				if arm64MachineScalarWidth(result.Type) < 64 {
+					// Partial results cannot erase code bits in an overlapping
+					// cell which a later full-width read could observe.
+					old := arm64ControlCallFrameRead(state, result.Offset+8, 64)
+					written = arm64ControlUnion(written, arm64ControlLabels(old))
+				}
+				state.memory[key] = written
+			}
+		}
+		return
+	}
+	if sig.Ret == Void {
+		return
+	}
+	fields, aggregate := parseLiteralStructFields(sig.Ret)
+	if !aggregate {
+		fields = []LLVMType{sig.Ret}
+	}
+	// Match storeABIRegisterResult, including floating results and mixed
+	// aggregate GP/FP banks. A floating value can carry source PC bits.
+	var cursor arm64ABIRegisterCursor
+	for _, field := range fields {
+		reg, err := cursor.next(field)
+		if err != nil {
+			return // The ordinary typed result lowerer rejects this shape.
+		}
+		state.regs[reg] = value
+	}
+}
+
+func (c *arm64Ctx) localControlTargets(bi int) ([]string, error) {
+	if c.localControl == nil {
+		return nil, nil
+	}
+	value := c.localControl.before[[2]int{bi, c.currentInstruction}]
+	var targets []string
+	external := false
+	for _, token := range arm64ControlKeys(value) {
+		if strings.HasPrefix(token, "label:") {
+			targets = append(targets, token[6:])
+		} else {
+			external = true
+		}
+	}
+	if len(targets) != 0 && external {
+		return nil, fmt.Errorf("%w: ARM64 register branch has mixed local-code and external/unknown reaching definitions", ErrProbeNeedsContext)
+	}
+	if len(targets) > 1 && arm64ControlHas(value, "label:"+c.localControl.outer) {
+		return nil, fmt.Errorf("%w: ARM64 register branch mixes a native caller link with local blockaddresses", ErrProbeNeedsContext)
+	}
+	sort.Strings(targets)
+	return targets, nil
+}
diff --git a/arm64_local_control_guard_test.go b/arm64_local_control_guard_test.go
new file mode 100644
index 000000000..0706a7a41
--- /dev/null
+++ b/arm64_local_control_guard_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestARM64LocalControlRejectsEscapedCodeInKnownCell(t *testing.T) {
+	const source = `TEXT escapedCell(SB),$48-0
+MOVD $0,24(RSP)
+ADR target,R1
+MOVD R1,(R0)
+MOVD 24(RSP),R2
+B (R2)
+target:
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"escapedCell": {Name: "escapedCell", Ret: Void},
+	}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("known cell can alias escaped local code; must fail closed: %v", err)
+	}
+}
+
+func TestARM64LocalControlRejectsUnprovedCallEffects(t *testing.T) {
+	for name, tc := range map[string]struct {
+		body   string
+		callee FuncSig
+	}{
+		"native_register_clobber": {body: `ADR target,R20
+MOVD fn+0(FP),R9
+CALL R9
+B (R20)`},
+		"native_register_result": {body: `ADR target,R0
+MOVD fn+0(FP),R9
+BL (R9)
+B (R1)`},
+		"native_caller_link": {body: `BL R30
+B (R30)`},
+		"unknown_direct_clobber": {body: `ADR target,R20
+BL external(SB)
+B (R20)`},
+		"unknown_direct_result": {body: `BL external(SB)
+B (R0)`},
+		"unknown_direct_frame": {body: `ADR target,R1
+MOVD R1,24(RSP)
+BL external(SB)
+MOVD 24(RSP),R2
+B (R2)`},
+		"typed_direct_clobber": {body: `ADR target,R20
+BL external(SB)
+B (R20)`, callee: FuncSig{Name: "external", Ret: Void}},
+		"typed_direct_result": {body: `BL external(SB)
+B (R0)`, callee: FuncSig{Name: "external", Ret: I64}},
+		"integer_frame_address": {body: `ADR target,R1
+MOVD R1,24(RSP)
+ADD $24,RSP,R0
+BL external(SB)
+MOVD 24(RSP),R2
+B (R2)`, callee: FuncSig{Name: "external", Args: []LLVMType{I64}, ArgRegs: []Reg{"R0"}, Ret: Void}},
+		"code_argument_escape": {body: `MOVD $0,24(RSP)
+ADR target,R0
+BL external(SB)
+MOVD (R9),R2
+B (R2)`, callee: FuncSig{Name: "external", Args: []LLVMType{I64}, ArgRegs: []Reg{"R0"}, Ret: Void}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := "TEXT callEffects(SB),$48-8\n" + tc.body + "\ntarget:\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]FuncSig{"callEffects": {
+				Name: "callEffects", Args: []LLVMType{I64}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+			}}
+			if tc.callee.Name != "" {
+				sigs["external"] = tc.callee
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: sigs})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved native/callee control effects must fail closed: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_local_control_ret_go127_test.go b/arm64_local_control_ret_go127_test.go
new file mode 100644
index 000000000..8a2c3bc64
--- /dev/null
+++ b/arm64_local_control_ret_go127_test.go
@@ -0,0 +1,62 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Preserve the current Go pseudo-RET fixture independently of the stable
+// hardware RET program. Legacy Go accepts these spellings but rewrites the
+// target to R30; the untagged selected-encoder witness tests that difference.
+func TestCrossLinuxRuntimeMatrixARM64CurrentGoRETRegisterAliases(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·ReturnAlias(SB),516,$0-16
+MOVD a+0(FP),R0
+MOVD R30,R19
+CALL helper
+ADD $2,R0
+MOVD R0,ret+8(FP)
+RET R19
+helper:
+ADD $5,R0
+MOVD R30,R20
+RET 8(R20)
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	runARM64LocalRegisterGoOracle(t, source, `package main
+func ReturnAlias(uint64) uint64
+func main() {
+    for _, x := range []uint64{0, 1, 123, 0x8000000000000000, ^uint64(0)} {
+        if got := ReturnAlias(x); got != x+7 {
+            println(got)
+            panic("current Go pseudo-RET alias mismatch")
+        }
+    }
+}
+`, len(runner) != 0)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs:       map[string]FuncSig{"ReturnAlias": arm64LocalRegisterBranchSig("ReturnAlias")},
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+extern uint64_t ReturnAlias(uint64_t);
+int main(void) {
+    const uint64_t inputs[] = {0, 1, 123, UINT64_C(0x8000000000000000), UINT64_MAX};
+    const volatile uint64_t canary = UINT64_C(0x8718369423719654);
+    for (unsigned i = 0; i < 5; i++) {
+        if (ReturnAlias(inputs[i]) != inputs[i]+7) return 1;
+    }
+    return canary != UINT64_C(0x8718369423719654);
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "current_go_ret_alias", triple, ir, main, runner)
+}
diff --git a/arm64_local_control_runtime_test.go b/arm64_local_control_runtime_test.go
new file mode 100644
index 000000000..99193578f
--- /dev/null
+++ b/arm64_local_control_runtime_test.go
@@ -0,0 +1,337 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64LocalControlConformance(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	type fixture struct {
+		name, flags, frame, body string
+		mul, add                 uint64
+	}
+	fixtures := []fixture{
+		{"callerLink", "4", "0", `
+CMP $0,R30
+CSET NE,R0
+MOVD R0,ret+8(FP)
+RET
+`, 0, 1},
+		{"multiTarget", "4", "0", `
+ADR helperA,R9
+TBZ $0,R0,invoke
+ADR helperB,R9
+invoke:
+CALL R9
+ADD $2,R0
+MOVD R0,ret+8(FP)
+RET
+helperA:
+ADD $5,R0
+B (R30)
+helperB:
+ADD $5,R0
+B (R30)
+`, 1, 7},
+		{"multiContinuation", "4", "0", `
+BL helper
+BL helper
+ADD $2,R0
+MOVD R0,ret+8(FP)
+RET
+helper:
+ADD $5,R0
+B (R30)
+`, 1, 12},
+		{"named", "4", "0", `
+BL helper
+resume:
+ADD $2,R0
+MOVD R0,ret+8(FP)
+RET
+helper:
+ADD $5,R0
+B resume
+`, 1, 7},
+		{"savedRegister", "4", "0", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+MOVD R30,R20
+ADD $2,R0
+BL inner
+ADD $4,R0
+MOVD R20,R30
+JMP (LR)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 16},
+		{"savedStackAlias", "4", "48", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+ADD $24,RSP,R10
+MOVD R30,(R10)
+BL inner
+MOVD (R10),R30
+ADD $4,R0
+B (R30)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 14},
+		{"savedStackPair", "4", "48", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+STP (R30,R0),24(RSP)
+BL inner
+LDP 24(RSP),(R20,R21)
+MOVD R20,R30
+ADD $4,R0
+B (LR)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 14},
+		{"savedFPParam", "4", "0", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+MOVD R30,a+0(FP)
+BL inner
+MOVD a+0(FP),R30
+ADD $4,R0
+B (R30)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 14},
+		{"savedFPParamAlias", "4", "0", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+MOVD $a+0(FP),R10
+MOVD R30,(R10)
+BL inner
+MOVD (R10),R30
+ADD $4,R0
+B (R30)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 14},
+		{"savedFPResult", "4", "0", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+MOVD R30,ret+8(FP)
+BL inner
+MOVD ret+8(FP),R30
+ADD $4,R0
+B (R30)
+inner:
+ADD $3,R0
+B (R30)
+`, 1, 14},
+		{"abiAnchor", "4", "48", `
+BL outer
+ADD $7,R0
+MOVD R0,ret+8(FP)
+RET
+outer:
+MOVD R30,24(RSP)
+MOVD R0,8(RSP)
+BL ·localAnchor(SB)
+MOVD 16(RSP),R0
+MOVD 24(RSP),R30
+ADD $4,R0
+B (R30)
+`, 3, 20},
+		{"noFrameRET", "516", "0", `
+MOVD R30,R19
+BL helper
+ADD $2,R0
+MOVD R0,ret+8(FP)
+MOVD R19,R30
+RET
+helper:
+ADD $5,R0
+RET
+`, 1, 7},
+		{"noFrameHardwareRETAlias", "516", "0", `
+MOVD R30,R19
+CALL helper
+ADD $2,R0
+MOVD R0,ret+8(FP)
+WORD $0xd65f0260
+helper:
+ADD $5,R0
+MOVD R30,R20
+WORD $0xd65f0280
+`, 1, 7},
+		{"rawBLRBR", "516", "0", `
+MOVD R30,R19
+ADR helper,R9
+WORD $0xd63f0120
+ADD $2,R0
+MOVD R0,ret+8(FP)
+MOVD R19,R30
+RET
+helper:
+ADD $5,R0
+WORD $0xd61f03c0
+`, 1, 7},
+		{"rawRET", "516", "0", `
+MOVD R30,R19
+BL helper
+ADD $2,R0
+MOVD R0,ret+8(FP)
+MOVD R19,R30
+RET
+helper:
+ADD $5,R0
+WORD $0xd65f03c0
+`, 1, 7},
+	}
+	for _, op := range []string{"BL", "CALL"} {
+		for _, operand := range []string{"R9", "(R9)", "R30", "(R30)"} {
+			reg := strings.Trim(operand, "()")
+			name := fmt.Sprintf("registerCall%d", len(fixtures))
+			body := fmt.Sprintf(`ADR helper,%s
+%s %s
+ADD $2,R0
+MOVD R0,ret+8(FP)
+RET
+helper:
+ADD $5,R0
+B (R30)`, reg, op, operand)
+			fixtures = append(fixtures, fixture{name, "4", "0", body, 1, 7})
+		}
+	}
+	for _, op := range []string{"B", "JMP"} {
+		body := fmt.Sprintf(`ADR finish,R9
+%s (R9)
+MOVD $999,R0
+finish:
+ADD $13,R0
+MOVD R0,ret+8(FP)
+RET`, op)
+		fixtures = append(fixtures, fixture{"jump" + op, "4", "0", body, 1, 13})
+	}
+	var source, goDecl, goChecks, cDecl, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, tc := range fixtures {
+		name := "localControl" + tc.name
+		fmt.Fprintf(&source, "TEXT ·%s(SB),%s,$%s-16\nMOVD a+0(FP),R0\n%s\n", name, tc.flags, tc.frame, tc.body)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&goChecks, `for _, x := range []uint64{0,1,123,0x8000000000000000,0xffffffffffffffff} {
+	want := x*%d+%d
+	if got := %s(x); got != want {
+		println("%s",got,want)
+		panic("local control mismatch")
+	}
+}
+`, tc.mul, tc.add, name, name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&cChecks, `for (unsigned i=0; i<sizeof(inputs)/sizeof(inputs[0]); i++) {
+	uint64_t x=inputs[i], want=x*%d+%d, got=%s(x);
+	if (got!=want) {
+		fprintf(stderr,"%s got=%%llx want=%%llx\n",(unsigned long long)got,(unsigned long long)want);
+		return 1;
+	}
+}
+`, tc.mul, tc.add, name, name)
+	}
+	source.WriteString(`TEXT ·localAnchor(SB),4,$0-16
+MOVD a+0(FP),R0
+MOVD R0,R1
+ADD R0,R0
+ADD R1,R0
+ADD $9,R0
+MOVD R0,ret+8(FP)
+RET
+`)
+	goDecl.WriteString("func localAnchor(uint64) uint64\n")
+	sigs["localAnchor"] = arm64LocalRegisterBranchSig("localAnchor")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") }, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "callbr") {
+		t.Fatal("local code pointers must use real LLVM control-flow edges")
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){ uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "local_control", triple, ir, main, runner)
+	t.Logf("%d local-call/return fixtures × 5 independent unsigned inputs passed native Go and LLVM 22", len(fixtures))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SelectedGoRETRegisterIdentity(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	probe := arm64ImmediateOriginalGoBytes(t, "TEXT retRegisterProbe(SB),516,$0-0\nRET R19\n", "linux")
+	if len(probe) < 4 {
+		t.Fatal("actual Go return-register object is absent")
+	}
+	word := binary.LittleEndian.Uint32(probe)
+	if word & ^uint32(31<<5) != 0xd65f0000 {
+		t.Fatalf("actual Go emitted an unknown RET encoding: %#08x", word)
+	}
+	register := (word >> 5) & 31
+	want := 1
+	if register == 19 {
+		want = 2
+	} else if register != 30 {
+		t.Fatalf("actual Go RET R19 targets unexpected register R%d", register)
+	}
+	// Both continuations are safe, so the legacy encoder's ignored operand is
+	// measured without running a program that would loop forever. This is an
+	// actual selected-Go observation, not an LLVM or native-caller permission.
+	const source = `TEXT ·ReturnTarget(SB),516,$0-8
+MOVD R30,R20
+ADR operandTarget,R19
+MOVD $1,R0
+MOVD R0,ret+0(FP)
+RET R19
+operandTarget:
+MOVD $2,R0
+MOVD R0,ret+0(FP)
+MOVD R20,R30
+RET
+`
+	main := fmt.Sprintf(`package main
+func ReturnTarget() uint64
+func main() {
+    for i := 0; i < 5; i++ {
+        if got := ReturnTarget(); got != %d {
+            println(got)
+            panic("selected Go RET register differs from its real object")
+        }
+    }
+}
+`, want)
+	runARM64LocalRegisterGoOracle(t, source, main, len(runner) != 0, "1.20")
+	t.Logf("actual Go RET R19 encodes R%d and its safe runtime witness returned %d; this does not claim legacy/current source equivalence", register, want)
+}
diff --git a/arm64_local_register_branch_test.go b/arm64_local_register_branch_test.go
new file mode 100644
index 000000000..806dad329
--- /dev/null
+++ b/arm64_local_register_branch_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func arm64LocalRegisterBranchSig(name string) FuncSig {
+	return FuncSig{Name: name, Args: []LLVMType{I64}, Ret: I64, Frame: FrameLayout{
+		Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+		Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+	}}
+}
+
+func TestARM64RegisterControlCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	forms := 0
+	for _, op := range []string{"B", "JMP", "BL", "CALL", "RET"} {
+		operands := []string{"(R0)", "0(R(1))", "(LR)", "(R30)", "(g)", "(R18_PLATFORM)", "(ZR)", "(RSP)"}
+		if op == "BL" || op == "CALL" || op == "RET" {
+			operands = append(operands, "R0", "R(1)", "LR", "R30", "g", "R18_PLATFORM", "ZR")
+		}
+		if op == "RET" {
+			operands = append(operands, "8(R0)", "(R0)(R1)", "RSP", "$1")
+		}
+		for _, operand := range operands {
+			for _, marker := range []string{"", "*"} {
+				if strings.HasPrefix(operand, "$") && marker != "" {
+					continue // '*' accepts register/memory operands, not immediates.
+				}
+				name := fmt.Sprintf("registerForm%d", forms)
+				forms++
+				prefix, suffix := "", "RET\n"
+				if op == "B" || op == "JMP" || op == "BL" || op == "CALL" || op == "RET" {
+					target, err := parseOperandForArch(ArchARM64, operand)
+					if err != nil {
+						t.Fatal(err)
+					}
+					reg := target.Reg
+					if target.Kind == OpMem {
+						reg = target.Mem.Base
+					}
+					if op == "RET" && target.Kind == OpImm {
+						reg = Reg("R30")
+					}
+					if reg != ZR && reg != SP && reg != Reg("RSP") {
+						spelling := string(reg)
+						if reg == Reg("R28") {
+							spelling = "g"
+						}
+						if reg == Reg("R18") {
+							spelling = "R18_PLATFORM"
+						}
+						prefix = fmt.Sprintf("MOVD R30,R19\nADR localTarget,%s\n", spelling)
+						if op == "BL" || op == "CALL" {
+							suffix = "MOVD R19,R30\nRET\nlocalTarget:\nB (R30)\n"
+						} else {
+							suffix = "localTarget:\nMOVD R19,R30\nRET\n"
+						}
+					} else if op == "BL" || op == "CALL" {
+						suffix = "B (ZR)\n"
+					} else {
+						suffix = ""
+					}
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),516,$0-0\n%s%s %s%s\n%s", name, prefix, op, marker, operand, suffix)
+				sigs[name] = FuncSig{Name: name, Ret: Void}
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "callbr") {
+				t.Fatal("opaque blockaddress must not escape through asm-goto labels")
+			}
+			compileLLVMToObject(t, llc, triple, "register-control.ll", "register-control.o", ir)
+		})
+	}
+	t.Logf("Go assembler and LLVM 22 accepted %d register/alias/indirect-marker forms on four targets", forms)
+}
+
+func TestARM64RegisterControlRejectsGoInvalidForms(t *testing.T) {
+	var instructions []string
+	for _, op := range []string{"B", "JMP", "BL", "CALL", "RET"} {
+		operands := []string{"V0", "(V0)", "R0, R1"}
+		if op != "RET" {
+			operands = append(operands, "8(R0)", "(R0)(R1)", "$1", "RSP")
+		}
+		for _, operand := range operands {
+			instructions = append(instructions, op+" "+operand)
+		}
+		instructions = append(instructions, op+".P (R0)", op+".W (R0)")
+	}
+	instructions = append(instructions, "B R0", "JMP R0", "RET *$1")
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT badRegisterControl(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"badRegisterControl": {Name: "badRegisterControl", Ret: Void}}})
+			if err == nil {
+				t.Fatalf("accepted Go-rejected %q", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64LocalControlRejectsUnprovedAddressProvenance(t *testing.T) {
+	for name, body := range map[string]string{
+		"mixed_join":          "ADR target, R1\nCBZ R0, jump\nMOVD R0, R1\njump:\nB (R1)",
+		"mixed_caller_local":  "MOVD R30,R1\nCBZ R0,jump\nADR target,R1\njump:\nB (R1)",
+		"arithmetic":          "ADR target, R1\nADD $4, R1\nB (R1)",
+		"bit_transform":       "ADR target, R1\nEOR R0, R1\nB (R1)",
+		"partial_frame_write": "ADR target, R1\nMOVD R1, 24(RSP)\nMOVB R0, 27(RSP)\nMOVD 24(RSP), R2\nB (R2)",
+		"escaped_memory":      "ADR target, R1\nMOVD R1, (R0)\nMOVD (R0), R2\nB (R2)",
+		"unproved_pair_load":  "ADR target, R1\nMOVD R1, 24(RSP)\nLDPW 24(RSP), (R2,R3)\nB (R2)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := "TEXT provenance(SB),$48-0\n" + body + "\ntarget:\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"provenance": {Name: "provenance", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved address did not fail closed: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64LocalControlRejectsCrossAllocaFPAlias(t *testing.T) {
+	const source = `TEXT fpAlias(SB),$48-16
+MOVD $a+0(FP),R10
+ADR target,R1
+MOVD R1,8(R10)
+MOVD b+8(FP),R2
+B (R2)
+target:
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"fpAlias": {
+		Name: "fpAlias", Args: []LLVMType{I64, I64}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I64, Index: 0, Field: -1},
+			{Offset: 8, Type: I64, Index: 1, Field: -1},
+		}},
+	}}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("FP scalar allocations are independent; cross-slot pointer must fail closed: %v", err)
+	}
+}
+
+func runARM64LocalRegisterGoOracle(t *testing.T, source, main string, cross bool, minimumVersions ...string) {
+	t.Helper()
+	// These first-party fixtures also exercise the Go 1.20 compatibility lane.
+	// A caller needing newer language semantics must request them explicitly.
+	minimum := "1.20"
+	if len(minimumVersions) > 1 {
+		t.Fatal("native Go oracle requires at most one module Go minimum")
+	}
+	if len(minimumVersions) == 1 {
+		minimum = minimumVersions[0]
+	}
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module localregisteroracle\n\ngo " + minimum + "\n",
+		"main.go": main, "oracle_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run", "-p=2", "."}
+	env := append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0")
+	if cross {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+		env = append(env, "GOOS=linux")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir, cmd.Env = dir, env
+	if out, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("native Go local register-branch oracle: %v\n%s", err, out)
+	}
+	t.Log("native Go local register-branch oracle passed")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64LocalRegisterReturn(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"BL", "CALL"} {
+		name := "localRegister" + op
+		fmt.Fprintf(&source, "TEXT ·%s(SB),$0-16\nMOVD a+0(FP), R0\n%s helper\nADD $2, R0\nMOVD R0, ret+8(FP)\nRET\nhelper:\nADD $5, R0\nB (R30)\n", name, op)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&goChecks, "if got := %s(123); got != 130 { println(got); panic(\"local-return mismatch\") }\n", name)
+		fmt.Fprintf(&cChecks, "if (%s(123) != 130) { fprintf(stderr, \"%s local-return mismatch\\n\"); return 1; }\n", name, name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main() {\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") }, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void) {\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "local_register_return", triple, ir, main, runner)
+}
diff --git a/arm64_lower_acquire_release_complete_test.go b/arm64_lower_acquire_release_complete_test.go
new file mode 100644
index 000000000..29a17b84a
--- /dev/null
+++ b/arm64_lower_acquire_release_complete_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64AcquireReleaseCompleteFormats(t *testing.T) {
+	const source = `TEXT acquireReleaseComplete(SB),$0-0
+	LDARB (R6), R7
+	LDARH (R6), R7
+	LDARW (R6), R7
+	LDAR (R6), R7
+	STLRB R5, (R6)
+	STLRH R5, (R6)
+	STLRW R5, (R6)
+	STLR R5, (R6)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"acquireReleaseComplete": {Name: "acquireReleaseComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"load atomic i8", "load atomic i16", "load atomic i32", "load atomic i64",
+		"store atomic i8", "store atomic i16", "store atomic i32", "store atomic i64", " acquire", " release",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 acquire/release lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-acquire-release.ll", "arm64-acquire-release.o", ll)
+}
+
+func TestTranslateARM64AcquireReleaseRejectsOffsetMemory(t *testing.T) {
+	for _, instruction := range []string{"LDARH 2(R1), R2", "STLRH R0, 2(R1)"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 acquire/release optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_add_flags.go b/arm64_lower_add_flags.go
new file mode 100644
index 000000000..bc49d3906
--- /dev/null
+++ b/arm64_lower_add_flags.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64AddFlags(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ADDS" && op != "ADDSW" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
+	}
+	word := op == "ADDSW"
+	if !arm64AddFlagsSourceValid(ins.Args[0], word) {
+		return true, false, fmt.Errorf("arm64 %s invalid first operand: %q", op, ins.Raw)
+	}
+
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg || !isARM64GeneralOrZeroReg(destination.Reg) {
+		return true, false, fmt.Errorf("arm64 %s destination must be a general register: %q", op, ins.Raw)
+	}
+	leftOperand := destination
+	if len(ins.Args) == 3 {
+		leftOperand = ins.Args[1]
+		leftGeneral := leftOperand.Kind == OpReg && isARM64GeneralOrZeroReg(leftOperand.Reg)
+		leftStack := leftOperand.Kind == OpReg && (leftOperand.Reg == SP || leftOperand.Reg == Reg("RSP"))
+		if !leftGeneral && !leftStack {
+			return true, false, fmt.Errorf("arm64 %s second operand must be a general or stack register: %q", op, ins.Raw)
+		}
+		if leftStack && ins.Args[0].Kind == OpRegShift &&
+			(ins.Args[0].ShiftOp != ShiftLeft || ins.Args[0].ShiftAmount > 4) {
+			return true, false, fmt.Errorf("arm64 %s with RSP accepts only a left-shifted register by 0..4: %q", op, ins.Raw)
+		}
+	}
+
+	if word {
+		right, err := c.eval32(ins.Args[0])
+		if err != nil {
+			return true, false, err
+		}
+		left, err := c.eval32(leftOperand)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", result, left, right)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		if err := c.storeReg(destination.Reg, "%"+wide); err != nil {
+			return true, false, err
+		}
+		c.setFlagsAdd32(left, right, "%"+result)
+		return true, false, nil
+	}
+
+	right, err := c.eval64(ins.Args[0], false)
+	if err != nil {
+		return true, false, err
+	}
+	left, err := c.eval64(leftOperand, false)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", result, left, right)
+	if err := c.storeReg(destination.Reg, "%"+result); err != nil {
+		return true, false, err
+	}
+	c.setFlagsAdd(left, right, "%"+result)
+	return true, false, nil
+}
+
+func arm64AddFlagsSourceValid(operand Operand, word bool) bool {
+	switch operand.Kind {
+	case OpImm:
+		return operand.ImmRaw == ""
+	case OpReg:
+		return isARM64GeneralOrZeroReg(operand.Reg)
+	case OpRegShift:
+		if !isARM64GeneralOrZeroReg(operand.Reg) || operand.ShiftReg != "" {
+			return false
+		}
+		switch operand.ShiftOp {
+		case ShiftLeft, ShiftRight, ShiftArith:
+		default:
+			return false
+		}
+		limit := int64(63)
+		if word {
+			limit = 31
+		}
+		return operand.ShiftAmount >= 0 && operand.ShiftAmount <= limit
+	case OpRegExtend:
+		if !isARM64GeneralOrZeroReg(operand.Reg) || operand.ShiftReg != "" {
+			return false
+		}
+		switch operand.Ext {
+		case ExtendUXTB, ExtendUXTH, ExtendUXTW, ExtendUXTX,
+			ExtendSXTB, ExtendSXTH, ExtendSXTW, ExtendSXTX:
+		default:
+			return false
+		}
+		return (operand.ShiftOp == "" || operand.ShiftOp == ShiftLeft) && operand.ShiftAmount >= 0 && operand.ShiftAmount <= 4
+	default:
+		return false
+	}
+}
diff --git a/arm64_lower_add_flags_test.go b/arm64_lower_add_flags_test.go
new file mode 100644
index 000000000..adf951f58
--- /dev/null
+++ b/arm64_lower_add_flags_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64AddFlagsCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT addFlagsForms(SB), $0-0
+	ADDS R0, R1
+	ADDS R2, R3, R4
+	ADDS $4095, R5, R6
+	ADDS R7>>8, R8, R9
+	ADDS R10.UXTX<<4, R11, R12
+	ADDS $1, RSP, R13
+	ADDS R1<<1, RSP, R4
+	ADDS R2<<4, RSP, R5
+	ADDSW R14, R15
+	ADDSW R16, R17, R19
+	ADDSW $(3525<<12), R20, R21
+	ADDSW R22->7, R23, R24
+	ADDSW R25.SXTX<<1, R29, R26
+	ADDSW $1, RSP, R27
+	ADDSW R3<<4, RSP, R6
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"addFlagsForms": {Name: "addFlagsForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"add i64", "add i32", "icmp ult i64", "icmp ult i32", "icmp slt i64", "icmp slt i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("add-with-flags lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-add-flags.ll", "arm64-add-flags.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64AddFlagsRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"ADDS R0",
+		"ADDS R0, R1, R2, R3",
+		"ADDS (R0), R1",
+		"ADDS R0, R1, RSP",
+		"ADDS R0>>64, R1, R2",
+		"ADDS R0>>1, RSP, R2",
+		"ADDS R0->1, RSP, R2",
+		"ADDS R0<<5, RSP, R2",
+		"ADDSW R0<<32, R1, R2",
+		"ADDSW R0>>1, RSP, R2",
+		"ADDSW R0.UXTB<<5, R1, R2",
+		"ADDSW.P R0, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badAddFlags(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badAddFlags": {Name: "badAddFlags", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ADDS optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64AddFlagsRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT addFlagsRuntime(SB), $0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	ADDS R0, R1, R3
+	MOVD R3, 0(R2)
+	CSET MI, R4
+	MOVD R4, 8(R2)
+	CSET EQ, R4
+	MOVD R4, 16(R2)
+	CSET CS, R4
+	MOVD R4, 24(R2)
+	CSET VS, R4
+	MOVD R4, 32(R2)
+	ADDSW R0, R1, R3
+	MOVD R3, 40(R2)
+	CSET MI, R4
+	MOVD R4, 48(R2)
+	CSET EQ, R4
+	MOVD R4, 56(R2)
+	CSET CS, R4
+	MOVD R4, 64(R2)
+	CSET VS, R4
+	MOVD R4, 72(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"addFlagsRuntime": {
+				Name: "addFlagsRuntime", Args: []LLVMType{I64, I64, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void addFlagsRuntime(uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  const uint64_t a = UINT64_C(0x8000000000000001);
+  const uint64_t b = UINT64_C(0x8000000000000002);
+  uint64_t got[10] = {0};
+  addFlagsRuntime(a, b, got);
+  const uint64_t r = a + b;
+  const uint32_t aw = (uint32_t)a, bw = (uint32_t)b, rw = aw + bw;
+  const uint64_t want[10] = {
+    r, r >> 63, r == 0, r < a, ((~(a ^ b) & (a ^ r)) >> 63),
+    rw, rw >> 31, rw == 0, rw < aw, ((~(aw ^ bw) & (aw ^ rw)) >> 31),
+  };
+  for (int i = 0; i < 10; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_add_flags", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_addsub_carry.go b/arm64_lower_addsub_carry.go
new file mode 100644
index 000000000..6ddbd60cb
--- /dev/null
+++ b/arm64_lower_addsub_carry.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+func (c *arm64Ctx) lowerARM64AddSubCarry(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64CarryForm(op, ins)
+	if !handled || form.negate {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if err := c.requireARM64Flags(arm64FlagC, string(op)); err != nil {
+		return true, false, err
+	}
+	if form.word {
+		return c.lowerARM64AddSubCarry32(op, ins, form.left, form.destination, form.subtract, form.setFlags)
+	}
+	return c.lowerARM64AddSubCarry64(op, ins, form.left, form.destination, form.subtract, form.setFlags)
+}
+
+func arm64AddSubCarryRegisterOrZero(operand Operand, allowImmediateZero bool) bool {
+	if operand.Kind == OpReg {
+		return isARM64GeneralOrZeroReg(operand.Reg)
+	}
+	return allowImmediateZero && operand.Kind == OpImm && operand.Imm == 0 && operand.ImmRaw == ""
+}
+
+func (c *arm64Ctx) lowerARM64AddSubCarry32(op Op, ins Instr, leftOperand, destination Operand, subtract, setFlags bool) (bool, bool, error) {
+	right, err := c.eval32(ins.Args[0])
+	if err != nil {
+		return true, false, err
+	}
+	left, err := c.eval32(leftOperand)
+	if err != nil {
+		return true, false, err
+	}
+	carryFlag := c.newTmp()
+	c.recordMachineRegister(Reg(c.flagsCSlot), 1, false)
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", carryFlag, c.flagsCSlot)
+	carryOrBorrow := "%" + carryFlag
+	if subtract {
+		borrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", borrow, carryFlag)
+		carryOrBorrow = "%" + borrow
+	}
+	amount := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i32\n", amount, carryOrBorrow)
+	intermediate := c.newTmp()
+	result := c.newTmp()
+	if subtract {
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %s\n", intermediate, left, right)
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, %%%s\n", result, intermediate, amount)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", intermediate, left, right)
+		fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %%%s\n", result, intermediate, amount)
+	}
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+	if err := c.storeReg(destination.Reg, "%"+wide); err != nil {
+		return true, false, err
+	}
+	if !setFlags {
+		return true, false, nil
+	}
+	if subtract {
+		borrow0 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %s, %s\n", borrow0, left, right)
+		borrow1 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %%%s, %%%s\n", borrow1, intermediate, amount)
+		borrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", borrow, borrow0, borrow1)
+		noBorrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", noBorrow, borrow)
+		c.setFlagsSub32WithCarry(left, right, "%"+result, "%"+noBorrow)
+	} else {
+		carry0 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %%%s, %s\n", carry0, intermediate, left)
+		carry1 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %%%s, %%%s\n", carry1, result, intermediate)
+		carry := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", carry, carry0, carry1)
+		c.setFlagsAdd32WithCarry(left, right, "%"+result, "%"+carry)
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64AddSubCarry64(op Op, ins Instr, leftOperand, destination Operand, subtract, setFlags bool) (bool, bool, error) {
+	right, err := c.eval64(ins.Args[0], false)
+	if err != nil {
+		return true, false, err
+	}
+	left, err := c.eval64(leftOperand, false)
+	if err != nil {
+		return true, false, err
+	}
+	carryFlag := c.newTmp()
+	c.recordMachineRegister(Reg(c.flagsCSlot), 1, false)
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", carryFlag, c.flagsCSlot)
+	carryOrBorrow := "%" + carryFlag
+	if subtract {
+		borrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", borrow, carryFlag)
+		carryOrBorrow = "%" + borrow
+	}
+	amount := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i64\n", amount, carryOrBorrow)
+	intermediate := c.newTmp()
+	result := c.newTmp()
+	if subtract {
+		fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %s\n", intermediate, left, right)
+		fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, %%%s\n", result, intermediate, amount)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", intermediate, left, right)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", result, intermediate, amount)
+	}
+	if err := c.storeReg(destination.Reg, "%"+result); err != nil {
+		return true, false, err
+	}
+	if !setFlags {
+		return true, false, nil
+	}
+	if subtract {
+		borrow0 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %s, %s\n", borrow0, left, right)
+		borrow1 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %%%s\n", borrow1, intermediate, amount)
+		borrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", borrow, borrow0, borrow1)
+		noBorrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", noBorrow, borrow)
+		c.setFlagsSubWithCarry(left, right, "%"+result, "%"+noBorrow)
+	} else {
+		carry0 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %s\n", carry0, intermediate, left)
+		carry1 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %%%s\n", carry1, result, intermediate)
+		carry := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", carry, carry0, carry1)
+		c.setFlagsAddWithCarry(left, right, "%"+result, "%"+carry)
+	}
+	return true, false, nil
+}
diff --git a/arm64_lower_addsub_carry_test.go b/arm64_lower_addsub_carry_test.go
new file mode 100644
index 000000000..a2a8e7a52
--- /dev/null
+++ b/arm64_lower_addsub_carry_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64AddSubCarryCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT addSubCarryComplete(SB),$0-0\n\tCMP R0, R0\n")
+	for _, op := range []string{"ADC", "ADCW", "ADCS", "ADCSW", "SBC", "SBCW", "SBCS", "SBCSW"} {
+		source.WriteString("\t" + op + " R1, R2\n")
+		source.WriteString("\t" + op + " R3, R4, R5\n")
+		source.WriteString("\t" + op + " ZR, R6, R7\n")
+		source.WriteString("\t" + op + " $0, R8\n")
+		source.WriteString("\t" + op + " R9, ZR, ZR\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64AddSubCarryCompleteFormats(t *testing.T) {
+	source := arm64AddSubCarryCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"addSubCarryComplete": {Name: "addSubCarryComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"add i64", "add i32", "sub i64", "sub i32",
+		"zext i32", "icmp ult i64", "icmp ult i32",
+		"icmp slt i64", "icmp slt i32",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 add/sub-with-carry lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-addsub-carry.ll", "arm64-addsub-carry.o", ll)
+}
+
+func TestTranslateARM64AddSubCarryRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"ADCW R0",
+		"ADCW R0, R1, R2, R3",
+		"ADCW (R0), R1",
+		"ADCW R0<<1, R1, R2",
+		"ADCW R0, RSP, R2",
+		"ADCW R0, R1, RSP",
+		"ADCW $1, R1",
+		"ADCSW.P R0, R1",
+		"SBCW R0, 8(R1), R2",
+		"SBCSW R0.UXTW, R1, R2",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 ADC/SBC optab", instruction)
+		}
+	}
+}
+
+func TestARM64AddSubCarryRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT addSubCarryRuntime(SB),$0-8
+	MOVD out+0(FP), R10
+	MOVD $0xffffffff, R0
+	MOVD $0, R1
+	CMP R1, R1
+	ADCSW R1, R0, R2
+	MOVD R2, 0(R10)
+	CSET CS, R3
+	MOVD R3, 8(R10)
+	CSET EQ, R3
+	MOVD R3, 16(R10)
+	CSET MI, R3
+	MOVD R3, 24(R10)
+	CSET VS, R3
+	MOVD R3, 32(R10)
+	CMP $1, R1
+	SBCSW R1, R1, R2
+	MOVD R2, 40(R10)
+	CSET CS, R3
+	MOVD R3, 48(R10)
+	CSET EQ, R3
+	MOVD R3, 56(R10)
+	CSET MI, R3
+	MOVD R3, 64(R10)
+	CSET VS, R3
+	MOVD R3, 72(R10)
+	MOVD $0x7fffffff, R0
+	CMP R1, R1
+	ADCSW R1, R0, R2
+	MOVD R2, 80(R10)
+	CSET CS, R3
+	MOVD R3, 88(R10)
+	CSET EQ, R3
+	MOVD R3, 96(R10)
+	CSET MI, R3
+	MOVD R3, 104(R10)
+	CSET VS, R3
+	MOVD R3, 112(R10)
+	MOVD $0x80000000, R0
+	CMP $1, R1
+	SBCSW R1, R0, R2
+	MOVD R2, 120(R10)
+	CSET CS, R3
+	MOVD R3, 128(R10)
+	CSET EQ, R3
+	MOVD R3, 136(R10)
+	CSET MI, R3
+	MOVD R3, 144(R10)
+	CSET VS, R3
+	MOVD R3, 152(R10)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"addSubCarryRuntime": {
+				Name: "addSubCarryRuntime", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void addSubCarryRuntime(uint64_t *);
+int main(void) {
+  uint64_t got[20] = {0};
+  addSubCarryRuntime(got);
+  const uint64_t want[20] = {
+    0, 1, 1, 0, 0,
+    UINT64_C(0xffffffff), 0, 0, 1, 0,
+    UINT64_C(0x80000000), 0, 0, 1, 1,
+    UINT64_C(0x7fffffff), 1, 0, 0, 1,
+  };
+  for (int i = 0; i < 20; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_addsub_carry", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_aes.go b/arm64_lower_aes.go
new file mode 100644
index 000000000..cd62a8878
--- /dev/null
+++ b/arm64_lower_aes.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawAES struct {
+	op          Op
+	source      int
+	destination int
+}
+
+func decodeARM64RawAES(word uint32) (arm64RawAES, bool) {
+	var op Op
+	switch word & 0xfffffc00 {
+	case 0x4e284800:
+		op = "AESE"
+	case 0x4e285800:
+		op = "AESD"
+	case 0x4e286800:
+		op = "AESMC"
+	case 0x4e287800:
+		op = "AESIMC"
+	default:
+		return arm64RawAES{}, false
+	}
+	return arm64RawAES{
+		op:          op,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawAES(form arm64RawAES) error {
+	reg := func(index int) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.B16", index))}
+	}
+	ins := Instr{
+		Op:   form.op,
+		Raw:  "decoded ARM64 WORD as " + string(form.op),
+		Args: []Operand{reg(form.source), reg(form.destination)},
+	}
+	ok, _, err := c.lowerARM64AES(form.op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return err
+}
+
+func (c *arm64Ctx) lowerARM64AES(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "AESE", "AESD", "AESMC", "AESIMC":
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects two bare V registers or two V.B16 registers with no suffix: %q", op, ins.Raw)
+	}
+
+	bare := false
+	arranged := false
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s expects two vector registers: %q", op, ins.Raw)
+		}
+		if _, valid := arm64ParseVReg(arg.Reg); !valid {
+			return true, false, fmt.Errorf("arm64 %s expects two vector registers: %q", op, ins.Raw)
+		}
+		if strings.Contains(string(arg.Reg), ".") {
+			arrangement, valid := parseARM64VectorArrangement(arg.Reg)
+			if !valid || arrangement != (arm64VectorArrangement{elementBits: 8, lanes: 16}) {
+				return true, false, fmt.Errorf("arm64 %s expects V.B16 operands: %q", op, ins.Raw)
+			}
+			arranged = true
+		} else {
+			bare = true
+		}
+	}
+	if bare && arranged {
+		return true, false, fmt.Errorf("arm64 %s cannot mix bare and arranged vector registers: %q", op, ins.Raw)
+	}
+
+	source, err := c.loadVReg(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	var result string
+	if op == "AESE" || op == "AESD" {
+		destination, err := c.loadVReg(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.aarch64.crypto.%s(<16 x i8> %s, <16 x i8> %s)\n", value, strings.ToLower(string(op)), destination, source)
+		result = "%" + value
+	} else {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.aarch64.crypto.%s(<16 x i8> %s)\n", value, strings.ToLower(string(op)), source)
+		result = "%" + value
+	}
+	return true, false, c.storeVReg(ins.Args[1].Reg, result)
+}
diff --git a/arm64_lower_aes_test.go b/arm64_lower_aes_test.go
new file mode 100644
index 000000000..a9ac264f1
--- /dev/null
+++ b/arm64_lower_aes_test.go
@@ -0,0 +1,276 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64AESNamedForms = `
+TEXT aesnamedforms(SB),$0-0
+	AESE V0, V1
+	AESD V2, V3
+	AESMC V4, V5
+	AESIMC V6, V7
+	AESE V8.B16, V9.B16
+	AESD V10.B16, V11.B16
+	AESMC V12.B16, V13.B16
+	AESIMC V14.B16, V15.B16
+	RET
+`
+
+const arm64AESRawForms = `
+TEXT aesrawforms(SB),$0-0
+	WORD $0x4e284bfd // AESE V31.B16, V29.B16
+	WORD $0x4e285ad3 // AESD V22.B16, V19.B16
+	WORD $0x4e2869dc // AESMC V14.B16, V28.B16
+	WORD $0x4e28799b // AESIMC V12.B16, V27.B16
+	RET
+`
+
+func TestTranslateARM64AESCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64AESNamedForms, true)
+	requireARM64GoAssemblerResult(t, arm64AESRawForms, true)
+	for name, source := range map[string]string{
+		"named": arm64AESNamedForms,
+		"raw":   arm64AESRawForms,
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin",
+				"aarch64-unknown-linux-gnu",
+				"aarch64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					function := "aesnamedforms"
+					if name == "raw" {
+						function = "aesrawforms"
+					}
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs: map[string]FuncSig{
+							function: {Name: function, Ret: Void},
+						},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{
+						"@llvm.aarch64.crypto.aese",
+						"@llvm.aarch64.crypto.aesd",
+						"@llvm.aarch64.crypto.aesmc",
+						"@llvm.aarch64.crypto.aesimc",
+						`"target-features"="+aes"`,
+					} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 AES lowering for %s omitted %q:\n%s", triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-aes.ll", "arm64-aes.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64AESRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"AESD V1.B8, V2.B8",
+		"AESE V1.D2, V2.D2",
+		"AESIMC V1.S4, V2.S4",
+		"AESE V1.B16, V2.B8",
+		"AESMC V1.B16, V2",
+		"AESE V1.B16, V2.B16, V3.B16",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badaes(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badaes": {Name: "badaes", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's AES optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64RawAESDecoderCoversRegistersAndRejectsAdjacentEncodings(t *testing.T) {
+	bases := map[string]uint32{
+		"AESE":   0x4e284800,
+		"AESD":   0x4e285800,
+		"AESMC":  0x4e286800,
+		"AESIMC": 0x4e287800,
+	}
+	for op, base := range bases {
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 32; destination++ {
+				word := base | uint32(source<<5) | uint32(destination)
+				form, ok := decodeARM64RawAES(word)
+				if !ok || form.op != Op(op) || form.source != source || form.destination != destination {
+					t.Fatalf("decode %#08x = %#v, %v; want %s V%d, V%d", word, form, ok, op, source, destination)
+				}
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x0e284800, // invalid Q/opcode prefix
+		0x4e284c00, // adjacent opcode field
+		0x4e285400, // adjacent opcode field
+		0x4e287c00, // adjacent opcode field
+	} {
+		if form, ok := decodeARM64RawAES(word); ok {
+			t.Fatalf("AES decoder accepted adjacent encoding %#08x as %#v", word, form)
+		}
+	}
+}
+
+func TestARM64AESRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host; the complete-form test independently compiles every target")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT aessemantics(SB),$0-24
+	MOVD state+0(FP), R0
+	MOVD key+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V2.B16]
+	VLD1 (R0), [V3.B16]
+	VLD1 (R0), [V4.B16]
+	VLD1 (R0), [V5.B16]
+	VLD1 (R1), [V1.B16]
+	AESE V1.B16, V2.B16
+	AESD V1.B16, V3.B16
+	AESMC V4.B16, V4.B16
+	AESIMC V5.B16, V5.B16
+	VST1.P [V2.B16], 16(R2)
+	VST1.P [V3.B16], 16(R2)
+	VST1.P [V4.B16], 16(R2)
+	VST1.P [V5.B16], 16(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"aessemantics": {
+				Name: "aessemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void aessemantics(const uint8_t *, const uint8_t *, uint8_t *);
+
+static const uint8_t sbox[256] = {
+0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
+0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
+0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
+0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
+0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
+0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
+0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
+0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
+0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
+0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
+0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
+0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
+0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
+0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
+0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
+0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16};
+static const uint8_t invsbox[256] = {
+0x52,0x09,0x6a,0xd5,0x30,0x36,0xa5,0x38,0xbf,0x40,0xa3,0x9e,0x81,0xf3,0xd7,0xfb,
+0x7c,0xe3,0x39,0x82,0x9b,0x2f,0xff,0x87,0x34,0x8e,0x43,0x44,0xc4,0xde,0xe9,0xcb,
+0x54,0x7b,0x94,0x32,0xa6,0xc2,0x23,0x3d,0xee,0x4c,0x95,0x0b,0x42,0xfa,0xc3,0x4e,
+0x08,0x2e,0xa1,0x66,0x28,0xd9,0x24,0xb2,0x76,0x5b,0xa2,0x49,0x6d,0x8b,0xd1,0x25,
+0x72,0xf8,0xf6,0x64,0x86,0x68,0x98,0x16,0xd4,0xa4,0x5c,0xcc,0x5d,0x65,0xb6,0x92,
+0x6c,0x70,0x48,0x50,0xfd,0xed,0xb9,0xda,0x5e,0x15,0x46,0x57,0xa7,0x8d,0x9d,0x84,
+0x90,0xd8,0xab,0x00,0x8c,0xbc,0xd3,0x0a,0xf7,0xe4,0x58,0x05,0xb8,0xb3,0x45,0x06,
+0xd0,0x2c,0x1e,0x8f,0xca,0x3f,0x0f,0x02,0xc1,0xaf,0xbd,0x03,0x01,0x13,0x8a,0x6b,
+0x3a,0x91,0x11,0x41,0x4f,0x67,0xdc,0xea,0x97,0xf2,0xcf,0xce,0xf0,0xb4,0xe6,0x73,
+0x96,0xac,0x74,0x22,0xe7,0xad,0x35,0x85,0xe2,0xf9,0x37,0xe8,0x1c,0x75,0xdf,0x6e,
+0x47,0xf1,0x1a,0x71,0x1d,0x29,0xc5,0x89,0x6f,0xb7,0x62,0x0e,0xaa,0x18,0xbe,0x1b,
+0xfc,0x56,0x3e,0x4b,0xc6,0xd2,0x79,0x20,0x9a,0xdb,0xc0,0xfe,0x78,0xcd,0x5a,0xf4,
+0x1f,0xdd,0xa8,0x33,0x88,0x07,0xc7,0x31,0xb1,0x12,0x10,0x59,0x27,0x80,0xec,0x5f,
+0x60,0x51,0x7f,0xa9,0x19,0xb5,0x4a,0x0d,0x2d,0xe5,0x7a,0x9f,0x93,0xc9,0x9c,0xef,
+0xa0,0xe0,0x3b,0x4d,0xae,0x2a,0xf5,0xb0,0xc8,0xeb,0xbb,0x3c,0x83,0x53,0x99,0x61,
+0x17,0x2b,0x04,0x7e,0xba,0x77,0xd6,0x26,0xe1,0x69,0x14,0x63,0x55,0x21,0x0c,0x7d};
+static uint8_t xtime(uint8_t x) { return (uint8_t)((x << 1) ^ ((x >> 7) * 0x1b)); }
+static uint8_t mul(uint8_t a, uint8_t b) {
+  uint8_t r = 0;
+  while (b) { if (b & 1) r ^= a; a = xtime(a); b >>= 1; }
+  return r;
+}
+static void shift_sub(uint8_t out[16], const uint8_t in[16], const uint8_t box[256], int inverse) {
+  for (int c = 0; c < 4; c++) for (int r = 0; r < 4; r++) {
+    int source_column = inverse ? (c - r + 4) & 3 : (c + r) & 3;
+    out[4*c+r] = box[in[4*source_column+r]];
+  }
+}
+static void mix(uint8_t out[16], const uint8_t in[16], int inverse) {
+  for (int c = 0; c < 4; c++) {
+    const uint8_t *x = in + 4*c; uint8_t *y = out + 4*c;
+    if (!inverse) {
+      y[0]=mul(x[0],2)^mul(x[1],3)^x[2]^x[3];
+      y[1]=x[0]^mul(x[1],2)^mul(x[2],3)^x[3];
+      y[2]=x[0]^x[1]^mul(x[2],2)^mul(x[3],3);
+      y[3]=mul(x[0],3)^x[1]^x[2]^mul(x[3],2);
+    } else {
+      y[0]=mul(x[0],14)^mul(x[1],11)^mul(x[2],13)^mul(x[3],9);
+      y[1]=mul(x[0],9)^mul(x[1],14)^mul(x[2],11)^mul(x[3],13);
+      y[2]=mul(x[0],13)^mul(x[1],9)^mul(x[2],14)^mul(x[3],11);
+      y[3]=mul(x[0],11)^mul(x[1],13)^mul(x[2],9)^mul(x[3],14);
+    }
+  }
+}
+int main(void) {
+  const uint8_t state[16] = {0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff};
+  const uint8_t key[16] = {0x0f,0x0e,0x0d,0x0c,0x0b,0x0a,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00};
+  uint8_t got[64], xored[16], want[64];
+  for (int i = 0; i < 16; i++) xored[i] = state[i] ^ key[i];
+  shift_sub(want, xored, sbox, 0);
+  shift_sub(want+16, xored, invsbox, 1);
+  mix(want+32, state, 0);
+  mix(want+48, state, 1);
+  aessemantics(state, key, got);
+  for (int i = 0; i < 64; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_aes", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_arith.go b/arm64_lower_arith.go
index 6a49bc9c7..d252eeae7 100644
--- a/arm64_lower_arith.go
+++ b/arm64_lower_arith.go
@@ -6,6 +6,57 @@ import (
 )
 
 func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if form, handled, err := parseARM64FPControl(op, ins); handled {
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64FPControl(form)
+	}
+	if form, handled, err := parseARM64NZCVForm(op, ins); handled {
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64NZCV(form)
+	}
+	if ok, terminated, err := c.lowerARM64GPImmediate(op, ins); ok {
+		return ok, terminated, err
+	}
+	if _, handled, err := parseARM64GPDataForm(op, ins); handled && err != nil {
+		return true, false, err
+	}
+	if form, handled, err := parseARM64NamedBitfield(op, ins); handled {
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerRawBitfield(form)
+	}
+	if ok, terminated, err := c.lowerARM64DivideRemainder(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerNegate(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarMultiply(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64BitReverse(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64CountLeading(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64InvertedLogical(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64BitClear(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64AddFlags(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64AddSubCarry(op, ins); ok {
+		return ok, terminated, err
+	}
 	switch op {
 	case "MRS_TPIDR_R0":
 		// Pseudo-op used in runtime tls stubs.
@@ -15,32 +66,64 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 
 	case "MRS":
 		// MRS <sysreg>, Rn
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpIdent || ins.Args[1].Kind != OpReg {
+		if ins.Op != "MRS" || len(ins.Args) != 2 || ins.Args[0].Kind != OpIdent || ins.Args[1].Kind != OpReg ||
+			!isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
 			return true, false, fmt.Errorf("arm64 MRS expects ident, reg: %q", ins.Raw)
 		}
-		sysreg := arm64CanonicalSysReg(ins.Args[0].Ident)
-		dst := ins.Args[1].Reg
-		if v, ok := arm64CompileSafeMRSValue(sysreg); ok {
-			return true, false, c.storeReg(dst, v)
+		sysreg, err := arm64CheckedSystemRegister(ins.Args[0].Ident, true)
+		if err != nil {
+			return true, false, err
 		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 asm sideeffect %q, %q()\n", t, "mrs $0, "+sysreg, "=r,~{memory}")
-		return true, false, c.storeReg(dst, "%"+t)
+		dst := ins.Args[1].Reg
+		spec, known := arm64GoSystemRegisters[ins.Args[0].Ident]
+		value := c.emitARM64SystemRegisterRead(sysreg, spec.encoding, known, dst)
+		return true, false, c.storeReg(dst, value)
 
 	case "MSR":
 		// MSR src, <sysreg>
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpIdent {
 			return true, false, fmt.Errorf("arm64 MSR expects src, ident: %q", ins.Raw)
 		}
-		sysreg := arm64CanonicalSysReg(ins.Args[1].Ident)
+		name := ins.Args[1].Ident
+		sysreg := arm64CanonicalSysReg(name)
 		switch ins.Args[0].Kind {
 		case OpImm:
 			imm := ins.Args[0].Imm
-			// Route immediates through a GPR so both ordinary sysregs and aliases
-			// (e.g. DIT) compile on LLVM's inline asm parser.
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %d)\n", "msr "+sysreg+", $0", "r,~{memory}", imm)
+			field := ""
+			switch strings.ToUpper(name) {
+			case "SPSEL":
+				field = "SPSel"
+			case "DAIFSET":
+				field = "DAIFSet"
+			case "DAIFCLR":
+				field = "DAIFClr"
+			case "DIT":
+				field = "DIT"
+			}
+			if imm == 0 && field != "DAIFSet" && field != "DAIFClr" {
+				// Go encodes $0 as the zero register for system-register
+				// writes, including SPSel and DIT, not as a PSTATE immediate.
+				if field != "" {
+					sysreg = field
+				} else if _, err := arm64CheckedSystemRegister(name, false); err != nil {
+					return true, false, err
+				}
+				fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", "msr "+sysreg+", xzr", "~{memory}")
+				return true, false, nil
+			}
+			if field == "" || imm < 1 || imm > 15 {
+				return true, false, fmt.Errorf("arm64 MSR immediate is not a Go PSTATE field form: %q", ins.Raw)
+			}
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", fmt.Sprintf("msr %s, #%d", field, imm), "~{memory}")
 			return true, false, nil
 		case OpReg:
+			if strings.EqualFold(name, "DAIFSet") || strings.EqualFold(name, "DAIFClr") {
+				return true, false, fmt.Errorf("arm64 MSR register source is not a Go PSTATE field form: %q", ins.Raw)
+			}
+			sysreg, err := arm64CheckedSystemRegister(name, false)
+			if err != nil {
+				return true, false, err
+			}
 			v, err := c.loadReg(ins.Args[0].Reg)
 			if err != nil {
 				return true, false, err
@@ -57,6 +140,9 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		return true, false, c.lowerBitfield(op, ins)
 
 	case "ADD", "SUB", "ADDS":
+		if handled, dynamicErr := c.lowerDynamicStack(ins); handled {
+			return true, false, dynamicErr
+		}
 		if len(ins.Args) != 2 && len(ins.Args) != 3 {
 			return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
 		}
@@ -103,72 +189,6 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		}
 		return true, false, nil
 
-	case "ADC", "ADCS", "SBC", "SBCS":
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
-		}
-		var a, bval string
-		var dst Reg
-		if len(ins.Args) == 2 {
-			a, err = c.eval64(ins.Args[0], false)
-			if err != nil {
-				return true, false, err
-			}
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 %s dst must be reg: %q", op, ins.Raw)
-			}
-			dst = ins.Args[1].Reg
-			bval, err = c.loadReg(dst)
-			if err != nil {
-				return true, false, err
-			}
-		} else {
-			a, err = c.eval64(ins.Args[0], false)
-			if err != nil {
-				return true, false, err
-			}
-			bval, err = c.eval64(ins.Args[1], false)
-			if err != nil {
-				return true, false, err
-			}
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 %s dst must be reg: %q", op, ins.Raw)
-			}
-			dst = ins.Args[2].Reg
-		}
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", cf, c.flagsCSlot)
-		cin := c.newTmp()
-		if op == "SBC" || op == "SBCS" {
-			ncf := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", ncf, cf)
-			fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", cin, ncf)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", cin, cf)
-		}
-		t0 := c.newTmp()
-		if op == "SBC" || op == "SBCS" {
-			fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %s\n", t0, bval, a)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", t0, bval, a)
-		}
-		t := c.newTmp()
-		if op == "SBC" || op == "SBCS" {
-			fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, %%%s\n", t, t0, cin)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", t, t0, cin)
-		}
-		if err := c.storeReg(dst, "%"+t); err != nil {
-			return true, false, err
-		}
-		if op == "ADCS" {
-			c.setFlagsAdd(bval, a, "%"+t)
-		}
-		if op == "SBCS" {
-			c.setFlagsSub(bval, a, "%"+t)
-		}
-		return true, false, nil
-
 	case "ADDW":
 		if len(ins.Args) != 2 && len(ins.Args) != 3 {
 			return true, false, fmt.Errorf("arm64 ADDW expects 2 or 3 operands: %q", ins.Raw)
@@ -484,78 +504,6 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, res)
 		return true, false, c.storeReg(dst, "%"+z)
 
-	case "BIC":
-		// BIC src, src2, dst => dst = src2 & ~src
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 BIC expects 2 or 3 operands: %q", ins.Raw)
-		}
-		src, err := c.eval64(ins.Args[0], false)
-		if err != nil {
-			return true, false, err
-		}
-		var src2 string
-		var dst Reg
-		if len(ins.Args) == 2 {
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 BIC 2-operand form expects reg dst: %q", ins.Raw)
-			}
-			dst = ins.Args[1].Reg
-			src2, err = c.loadReg(dst)
-		} else {
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 BIC 3-operand form expects reg dst: %q", ins.Raw)
-			}
-			dst = ins.Args[2].Reg
-			src2, err = c.eval64(ins.Args[1], false)
-		}
-		if err != nil {
-			return true, false, err
-		}
-		nt := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i64 %s, -1\n", nt, src)
-		at := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %%%s\n", at, src2, nt)
-		return true, false, c.storeReg(dst, "%"+at)
-
-	case "BICW":
-		// BICW src, src2, dst => dst = src2 & ~src (32-bit, zero-extended)
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 BICW expects 2 or 3 operands: %q", ins.Raw)
-		}
-		src, err := c.eval64(ins.Args[0], false)
-		if err != nil {
-			return true, false, err
-		}
-		var src2 string
-		var dst Reg
-		if len(ins.Args) == 2 {
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 BICW 2-operand form expects reg dst: %q", ins.Raw)
-			}
-			dst = ins.Args[1].Reg
-			src2, err = c.loadReg(dst)
-		} else {
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 BICW 3-operand form expects reg dst: %q", ins.Raw)
-			}
-			dst = ins.Args[2].Reg
-			src2, err = c.eval64(ins.Args[1], false)
-		}
-		if err != nil {
-			return true, false, err
-		}
-		sw := c.newTmp()
-		s2w := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", sw, src)
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", s2w, src2)
-		nt := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = xor i32 %%%s, -1\n", nt, sw)
-		at := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %%%s\n", at, s2w, nt)
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, at)
-		return true, false, c.storeReg(dst, "%"+z)
-
 	case "MVN":
 		// MVN src, dst => dst = ~src
 		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
@@ -587,18 +535,29 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		return true, false, c.storeReg(ins.Args[1].Reg, "%"+z)
 
 	case "CRC32B", "CRC32H", "CRC32W", "CRC32X", "CRC32CB", "CRC32CH", "CRC32CW", "CRC32CX":
-		// CRC32{B,H,W,X} srcReg, dstReg
-		// CRC32C{B,H,W,X} srcReg, dstReg
-		// Semantics: dst = crc32(dst, src)
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 %s expects reg, reg: %q", op, ins.Raw)
+		// CRC32{C}{B,H,W,X} src, crc, dst, with the two-operand form
+		// taking the incoming CRC from dst.
+		if strings.ToUpper(string(ins.Op)) != string(op) {
+			return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+		}
+		if len(ins.Args) != 2 && len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s expects 2 or 3 registers: %q", op, ins.Raw)
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind != OpReg || !isARM64GeneralOrZeroReg(operand.Reg) {
+				return true, false, fmt.Errorf("arm64 %s operands must be general registers: %q", op, ins.Raw)
+			}
 		}
 		src64, err := c.loadReg(ins.Args[0].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		dstReg := ins.Args[1].Reg
-		crc64, err := c.loadReg(dstReg)
+		dstReg := ins.Args[len(ins.Args)-1].Reg
+		crcReg := dstReg
+		if len(ins.Args) == 3 {
+			crcReg = ins.Args[1].Reg
+		}
+		crc64, err := c.loadReg(crcReg)
 		if err != nil {
 			return true, false, err
 		}
@@ -695,12 +654,39 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		return true, false, nil
 
 	case "CCMP", "CCMPW", "CCMN", "CCMNW":
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpIdent || ins.Args[3].Kind != OpImm {
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 ||
+			ins.Args[3].Kind != OpImm || ins.Args[3].ImmRaw != "" {
 			return true, false, fmt.Errorf("arm64 %s expects condition, lhs, rhs, $nzcv: %q", op, ins.Raw)
 		}
+		condition := ""
+		switch ins.Args[0].Kind {
+		case OpIdent:
+			condition = ins.Args[0].Ident
+		case OpReg:
+			// AL is also a register spelling in the Plan 9 parser, but in
+			// this operand position Go's optab classifies it as C_COND.
+			condition = string(ins.Args[0].Reg)
+		default:
+			return true, false, fmt.Errorf("arm64 %s first operand must be a condition: %q", op, ins.Raw)
+		}
 		if ins.Args[3].Imm < 0 || ins.Args[3].Imm > 15 {
 			return true, false, fmt.Errorf("arm64 %s NZCV immediate is outside 0..15: %q", op, ins.Raw)
 		}
+		if ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+			return true, false, fmt.Errorf("arm64 %s lhs must be a general register: %q", op, ins.Raw)
+		}
+		switch ins.Args[2].Kind {
+		case OpReg:
+			if !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+				return true, false, fmt.Errorf("arm64 %s rhs must be a general register: %q", op, ins.Raw)
+			}
+		case OpImm:
+			if ins.Args[2].ImmRaw != "" || ins.Args[2].Imm < 0 || ins.Args[2].Imm > 31 {
+				return true, false, fmt.Errorf("arm64 %s rhs immediate is outside 0..31: %q", op, ins.Raw)
+			}
+		default:
+			return true, false, fmt.Errorf("arm64 %s rhs must be a register or immediate: %q", op, ins.Raw)
+		}
 		word := op == "CCMPW" || op == "CCMNW"
 		add := op == "CCMN" || op == "CCMNW"
 		var lhs, rhs string
@@ -719,11 +705,32 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		if err != nil {
 			return true, false, err
 		}
-		return true, false, c.setConditionalCompareFlags(ins.Args[0].Ident, lhs, rhs, ins.Args[3].Imm, word, add)
+		return true, false, c.setConditionalCompareFlags(condition, lhs, rhs, ins.Args[3].Imm, word, add)
 
-	case "CMN":
+	case "CMN", "CMNW":
+		if strings.ToUpper(string(ins.Op)) != string(op) {
+			return true, false, fmt.Errorf("arm64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+		}
 		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm64 CMN expects 2 operands: %q", ins.Raw)
+			return true, false, fmt.Errorf("arm64 %s expects 2 operands: %q", op, ins.Raw)
+		}
+		word := op == "CMNW"
+		if err := validateARM64CompareNegativeOperands(ins.Args[0], ins.Args[1], word); err != nil {
+			return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+		}
+		if word {
+			src, err := c.eval32(ins.Args[0])
+			if err != nil {
+				return true, false, err
+			}
+			dst, err := c.eval32(ins.Args[1])
+			if err != nil {
+				return true, false, err
+			}
+			result := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", result, dst, src)
+			c.setFlagsAdd32(dst, src, "%"+result)
+			return true, false, nil
 		}
 		src, err := c.eval64(ins.Args[0], false)
 		if err != nil {
@@ -752,8 +759,8 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		return true, false, c.storeReg(ins.Args[1].Reg, "%"+t)
 
 	case "MULW":
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 MULW expects 2 or 3 operands: %q", ins.Raw)
+		if _, _, valid := arm64ScalarMultiplyInputs(op, ins); !valid {
+			return true, false, fmt.Errorf("arm64 MULW expects two or three C_ZREG operands: %q", ins.Raw)
 		}
 		a, err := c.eval32(ins.Args[0])
 		if err != nil {
@@ -785,8 +792,8 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 
 	case "MUL":
 		// MUL a, dst or MUL a, b, dst
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 MUL expects 2 or 3 operands: %q", ins.Raw)
+		if _, _, valid := arm64ScalarMultiplyInputs(op, ins); !valid {
+			return true, false, fmt.Errorf("arm64 MUL expects two or three C_ZREG operands: %q", ins.Raw)
 		}
 		var a, bval string
 		var dst Reg
@@ -821,85 +828,6 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", t, bval, a)
 		return true, false, c.storeReg(dst, "%"+t)
 
-	case "UMULH":
-		// UMULH a, b, dst -> high 64 bits of unsigned 128-bit product.
-		if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 UMULH expects a, b, dstReg: %q", ins.Raw)
-		}
-		a, err := c.eval64(ins.Args[0], false)
-		if err != nil {
-			return true, false, err
-		}
-		bv, err := c.eval64(ins.Args[1], false)
-		if err != nil {
-			return true, false, err
-		}
-		za := c.newTmp()
-		zb := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", za, a)
-		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", zb, bv)
-		m := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", m, za, zb)
-		sh := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", sh, m)
-		hi := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", hi, sh)
-		return true, false, c.storeReg(ins.Args[2].Reg, "%"+hi)
-
-	case "MADDW", "MSUBW":
-		if len(ins.Args) != 4 || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 %s expects a, b, c, dstReg: %q", op, ins.Raw)
-		}
-		a, err := c.eval32(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		bv, err := c.eval32(ins.Args[1])
-		if err != nil {
-			return true, false, err
-		}
-		cv, err := c.eval32(ins.Args[2])
-		if err != nil {
-			return true, false, err
-		}
-		product := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, a, bv)
-		result := c.newTmp()
-		if op == "MADDW" {
-			fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %s\n", result, product, cv)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %%%s\n", result, cv, product)
-		}
-		wide := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
-		return true, false, c.storeReg(ins.Args[3].Reg, "%"+wide)
-
-	case "MADD", "MSUB":
-		if len(ins.Args) != 4 || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 %s expects a, b, c, dstReg: %q", op, ins.Raw)
-		}
-		a, err := c.eval64(ins.Args[0], false)
-		if err != nil {
-			return true, false, err
-		}
-		bv, err := c.eval64(ins.Args[1], false)
-		if err != nil {
-			return true, false, err
-		}
-		cv, err := c.eval64(ins.Args[2], false)
-		if err != nil {
-			return true, false, err
-		}
-		m := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", m, a, bv)
-		t := c.newTmp()
-		if op == "MADD" {
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %s\n", t, m, cv)
-		} else {
-			fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %%%s\n", t, cv, m)
-		}
-		return true, false, c.storeReg(ins.Args[3].Reg, "%"+t)
-
 	case "LSL", "LSR":
 		// LSL/LSR $imm|reg, srcReg, dstReg
 		if len(ins.Args) != 2 && len(ins.Args) != 3 {
@@ -1079,73 +1007,68 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, %s\n", t, src, shv)
 		return true, false, c.storeReg(dstReg, "%"+t)
 
-	case "UDIV":
-		if len(ins.Args) != 2 && len(ins.Args) != 3 {
-			return true, false, fmt.Errorf("arm64 UDIV expects 2 or 3 operands: %q", ins.Raw)
+	case "EXTR", "EXTRW":
+		// Plan 9: EXTR $shift, lo, hi, dst. Arm's encoded Rn is the
+		// third operand (hi); Rm is the second (lo). Extract from hi:lo.
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 ||
+			ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+			return true, false, fmt.Errorf("arm64 %s expects $shift, lo, hi, dstReg: %q", op, ins.Raw)
 		}
-		var a, bval string
-		var dst Reg
-		if len(ins.Args) == 2 {
-			a, err = c.eval64(ins.Args[0], false)
-			if err != nil {
-				return true, false, err
-			}
-			if ins.Args[1].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 UDIV expects src, dstReg: %q", ins.Raw)
+		for _, operand := range ins.Args[1:] {
+			if operand.Kind != OpReg || !isARM64GeneralOrZeroReg(operand.Reg) {
+				return true, false, fmt.Errorf("arm64 %s operands must be general registers: %q", op, ins.Raw)
 			}
-			dst = ins.Args[1].Reg
-			bval, err = c.loadReg(dst)
-			if err != nil {
-				return true, false, err
-			}
-		} else {
-			a, err = c.eval64(ins.Args[0], false)
+		}
+		width := int64(64)
+		if op == "EXTRW" {
+			width = 32
+		}
+		shift := ins.Args[0].Imm
+		if shift < 0 || shift >= width {
+			return true, false, fmt.Errorf("arm64 %s shift must be in [0,%d): %q", op, width, ins.Raw)
+		}
+		if op == "EXTRW" {
+			lo, err := c.eval32(ins.Args[1])
 			if err != nil {
 				return true, false, err
 			}
-			bval, err = c.eval64(ins.Args[1], false)
+			hi, err := c.eval32(ins.Args[2])
 			if err != nil {
 				return true, false, err
 			}
-			if ins.Args[2].Kind != OpReg {
-				return true, false, fmt.Errorf("arm64 UDIV expects src, src2, dstReg: %q", ins.Raw)
-			}
-			dst = ins.Args[2].Reg
-		}
-		nonzero := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %s, 0\n", nonzero, a)
-		div := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = udiv i64 %s, %s\n", div, bval, a)
-		out := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 0\n", out, nonzero, div)
-		return true, false, c.storeReg(dst, "%"+out)
-
-	case "EXTR":
-		// EXTR shift, hi, lo, dst
-		if len(ins.Args) != 4 || ins.Args[3].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 EXTR expects shift, hi, lo, dstReg: %q", ins.Raw)
-		}
-		var sh int64
-		if ins.Args[0].Kind == OpImm {
-			sh = ins.Args[0].Imm & 63
-		} else {
-			return true, false, fmt.Errorf("arm64 EXTR expects immediate shift: %q", ins.Raw)
-		}
-		hi, err := c.eval64(ins.Args[1], false)
+			result := lo
+			if shift != 0 {
+				loPart := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, %d\n", loPart, lo, shift)
+				hiPart := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = shl i32 %s, %d\n", hiPart, hi, width-shift)
+				combined := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", combined, loPart, hiPart)
+				result = "%" + combined
+			}
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, result)
+			return true, false, c.storeReg(ins.Args[3].Reg, "%"+wide)
+		}
+		lo, err := c.eval64(ins.Args[1], false)
 		if err != nil {
 			return true, false, err
 		}
-		lo, err := c.eval64(ins.Args[2], false)
+		hi, err := c.eval64(ins.Args[2], false)
 		if err != nil {
 			return true, false, err
 		}
-		loPart := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", loPart, lo, sh)
-		hiPart := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", hiPart, hi, (64-sh)&63)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", t, loPart, hiPart)
-		return true, false, c.storeReg(ins.Args[3].Reg, "%"+t)
+		result := lo
+		if shift != 0 {
+			loPart := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", loPart, lo, shift)
+			hiPart := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", hiPart, hi, width-shift)
+			combined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", combined, loPart, hiPart)
+			result = "%" + combined
+		}
+		return true, false, c.storeReg(ins.Args[3].Reg, result)
 
 	case "RORW":
 		// RORW shift, dstReg  or  RORW shift, srcReg, dstReg
@@ -1262,30 +1185,6 @@ func (c *arm64Ctx) lowerArith(op Op, ins Instr) (ok bool, terminated bool, err e
 		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", out, right, left)
 		return true, false, c.storeReg(dstReg, "%"+out)
 
-	case "RBIT":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 RBIT expects reg, reg: %q", ins.Raw)
-		}
-		src, err := c.loadReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.bitreverse.i64(i64 %s)\n", t, src)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+t)
-
-	case "CLZ":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 CLZ expects reg, reg: %q", ins.Raw)
-		}
-		src, err := c.loadReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.ctlz.i64(i64 %s, i1 false)\n", t, src)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+t)
-
 	case "REV":
 		// REV src, dst (bswap)
 		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
@@ -1383,14 +1282,24 @@ func (c *arm64Ctx) lowerBitfield(op Op, ins Instr) error {
 		return fmt.Errorf("arm64 %s invalid range lsb=%d width=%d for %d-bit form: %q", op, lsb, width, bits, ins.Raw)
 	}
 
-	src64, err := c.loadReg(ins.Args[1].Reg)
-	if err != nil {
-		return err
+	// Only insert forms preserve destination bits. Extracts consume their
+	// selected source field without reading the old destination value.
+	sourceBits := lsb + width
+	insert := strings.HasPrefix(string(op), "BFI") || strings.HasPrefix(string(op), "BFXIL")
+	if strings.HasPrefix(string(op), "BFI") || strings.HasPrefix(string(op), "UBFIZ") || strings.HasPrefix(string(op), "SBFIZ") {
+		sourceBits = width
 	}
-	dst64, err := c.loadReg(ins.Args[3].Reg)
+	src64, err := c.loadRegisterWidth(ins.Args[1].Reg, int(sourceBits))
 	if err != nil {
 		return err
 	}
+	dst64 := "0"
+	if insert {
+		dst64, err = c.loadRegisterWidth(ins.Args[3].Reg, int(bits))
+		if err != nil {
+			return err
+		}
+	}
 	typeName := "i64"
 	src, dst := src64, dst64
 	if bits == 32 {
@@ -1519,23 +1428,8 @@ func arm64IntConstant(typeName string, value uint64) int64 {
 }
 
 func arm64CanonicalSysReg(name string) string {
-	switch name {
-	case "DIT":
-		// LLVM inline-asm parser on current toolchains does not accept the DIT
-		// alias directly; use its canonical system-register encoding name.
-		return "S3_3_C4_C2_5"
-	default:
-		return name
-	}
-}
-
-func arm64CompileSafeMRSValue(sysreg string) (string, bool) {
-	switch sysreg {
-	case "ID_AA64ISAR0_EL1", "ID_AA64PFR0_EL1", "ID_AA64ZFR0_EL1", "MIDR_EL1":
-		// LLVM 19's inline-asm parser lags behind newer arm64 feature register names.
-		// For compile-only corpus coverage, return a conservative zero value.
-		return "0", true
-	default:
-		return "", false
+	if spec, ok := arm64GoSystemRegisters[name]; ok {
+		return arm64EncodedSystemRegisterName(spec.encoding)
 	}
+	return name
 }
diff --git a/arm64_lower_atomic.go b/arm64_lower_atomic.go
index a2992a1d7..a16649f54 100644
--- a/arm64_lower_atomic.go
+++ b/arm64_lower_atomic.go
@@ -1,20 +1,200 @@
 package plan9asm
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64AtomicRMWForm struct {
+	typeName  LLVMType
+	operation string
+	ordering  string
+	invert    bool
+}
+
+type arm64AtomicCASForm struct {
+	typeName     LLVMType
+	successOrder string
+	failureOrder string
+}
+
+type arm64ExclusiveForm struct {
+	typeName     LLVMType
+	isLoad       bool
+	successOrder string
+	failureOrder string
+}
+
+func parseARM64ExclusiveOpcode(op Op) (arm64ExclusiveForm, bool) {
+	name := strings.ToUpper(string(op))
+	form := arm64ExclusiveForm{failureOrder: "monotonic"}
+	prefix := ""
+	switch {
+	case strings.HasPrefix(name, "LDAXR"):
+		prefix, form.isLoad, form.successOrder = "LDAXR", true, "acquire"
+	case strings.HasPrefix(name, "LDXR"):
+		prefix, form.isLoad, form.successOrder = "LDXR", true, "monotonic"
+	case strings.HasPrefix(name, "STLXR"):
+		prefix, form.successOrder = "STLXR", "release"
+	case strings.HasPrefix(name, "STXR"):
+		prefix, form.successOrder = "STXR", "monotonic"
+	default:
+		return arm64ExclusiveForm{}, false
+	}
+	switch strings.TrimPrefix(name, prefix) {
+	case "":
+		form.typeName = I64
+	case "B":
+		form.typeName = I8
+	case "H":
+		form.typeName = I16
+	case "W":
+		form.typeName = I32
+	default:
+		return arm64ExclusiveForm{}, false
+	}
+	return form, true
+}
+
+func parseARM64AtomicCASOpcode(op Op) (arm64AtomicCASForm, bool) {
+	name := strings.ToUpper(string(op))
+	if !strings.HasPrefix(name, "CAS") || strings.HasPrefix(name, "CASP") || len(name) < 4 {
+		return arm64AtomicCASForm{}, false
+	}
+	tail := strings.TrimPrefix(name, "CAS")
+	typeName := LLVMType("")
+	width := tail[len(tail)-1]
+	switch width {
+	case 'B':
+		typeName = I8
+	case 'H':
+		typeName = I16
+	case 'W':
+		typeName = I32
+	case 'D':
+		typeName = I64
+	default:
+		return arm64AtomicCASForm{}, false
+	}
+	order := tail[:len(tail)-1]
+	form := arm64AtomicCASForm{typeName: typeName}
+	switch order {
+	case "":
+		form.successOrder, form.failureOrder = "monotonic", "monotonic"
+	case "A":
+		if width == 'B' || width == 'H' {
+			return arm64AtomicCASForm{}, false
+		}
+		form.successOrder, form.failureOrder = "acquire", "acquire"
+	case "L":
+		if width == 'B' || width == 'H' {
+			return arm64AtomicCASForm{}, false
+		}
+		form.successOrder, form.failureOrder = "release", "monotonic"
+	case "AL":
+		form.successOrder, form.failureOrder = "acq_rel", "acquire"
+	default:
+		return arm64AtomicCASForm{}, false
+	}
+	return form, true
+}
+
+func parseARM64AtomicRMWOpcode(op Op) (arm64AtomicRMWForm, bool) {
+	name := strings.ToUpper(string(op))
+	operation := ""
+	invert := false
+	prefix := ""
+	for _, candidate := range []struct {
+		prefix    string
+		operation string
+		invert    bool
+	}{
+		{"LDADD", "add", false},
+		{"LDCLR", "and", true},
+		{"LDEOR", "xor", false},
+		{"LDOR", "or", false},
+		{"SWP", "xchg", false},
+	} {
+		if strings.HasPrefix(name, candidate.prefix) {
+			prefix, operation, invert = candidate.prefix, candidate.operation, candidate.invert
+			break
+		}
+	}
+	if prefix == "" {
+		return arm64AtomicRMWForm{}, false
+	}
+	tail := strings.TrimPrefix(name, prefix)
+	if len(tail) < 1 {
+		return arm64AtomicRMWForm{}, false
+	}
+	typeName := LLVMType("")
+	switch tail[len(tail)-1] {
+	case 'B':
+		typeName = I8
+	case 'H':
+		typeName = I16
+	case 'W':
+		typeName = I32
+	case 'D':
+		typeName = I64
+	default:
+		return arm64AtomicRMWForm{}, false
+	}
+	ordering := ""
+	switch tail[:len(tail)-1] {
+	case "":
+		ordering = "monotonic"
+	case "A":
+		ordering = "acquire"
+	case "L":
+		ordering = "release"
+	case "AL":
+		ordering = "acq_rel"
+	default:
+		return arm64AtomicRMWForm{}, false
+	}
+	return arm64AtomicRMWForm{typeName: typeName, operation: operation, ordering: ordering, invert: invert}, true
+}
 
 func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerAtomicPair(op, ins); ok {
+		return ok, terminated, err
+	}
+	if form, matched := parseARM64AtomicRMWOpcode(op); matched {
+		return true, false, c.lowerAtomicRMWFamily(form, ins)
+	}
+	if form, matched := parseARM64AtomicCASOpcode(op); matched {
+		return true, false, c.lowerAtomicCASFamily(form, ins)
+	}
+	if form, matched := parseARM64ExclusiveOpcode(op); matched {
+		return true, false, c.lowerExclusiveFamily(form, ins)
+	}
 	switch op {
-	case "LDARW", "LDARB", "LDAR", "LDAXRW", "LDAXRB", "LDAXR":
+	case "CLREX":
+		if arm64AtomicOpcodeHasSuffix(ins.Op) || len(ins.Args) > 1 || len(ins.Args) == 1 && ins.Args[0].Kind != OpImm {
+			return true, false, fmt.Errorf("arm64 CLREX expects no operand or one immediate: %q", ins.Raw)
+		}
+		// LLVM IR has no exposed exclusive-monitor primitive. The ARM64
+		// backend models LDXR/STXR reservations explicitly, so clearing the
+		// validity bit implements both Go assembler forms exactly. The
+		// optional architectural immediate is only an implementation hint.
+		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.exclusiveValidSlot)
+		return true, false, nil
+
+	case "LDARW", "LDARH", "LDARB", "LDAR", "LDAXRW", "LDAXRB", "LDAXR":
 		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg {
 			return true, false, fmt.Errorf("arm64 %s expects mem, reg: %q", op, ins.Raw)
 		}
+		if !arm64AtomicZeroOffsetMemory(ins.Args[0].Mem) {
+			return true, false, fmt.Errorf("arm64 %s memory must be a zero-offset general-register, RSP, or ZR address: %q", op, ins.Raw)
+		}
 		ty, align := arm64AtomicLoadStoreType(op)
 		ptr, err := c.atomicMemPtr(ins.Args[0].Mem)
 		if err != nil {
 			return true, false, err
 		}
 		ld := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load atomic %s, ptr %s seq_cst, align %d\n", ld, ty, ptr, align)
+		fmt.Fprintf(c.b, "  %%%s = load atomic %s, ptr %s acquire, align %d\n", ld, ty, ptr, align)
 		v, err := c.atomicExtendToI64("%"+ld, ty)
 		if err != nil {
 			return true, false, err
@@ -31,10 +211,13 @@ func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err
 		}
 		return true, false, c.storeReg(ins.Args[1].Reg, v)
 
-	case "STLRW", "STLRB", "STLR":
+	case "STLRW", "STLRH", "STLRB", "STLR":
 		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpMem {
 			return true, false, fmt.Errorf("arm64 %s expects reg, mem: %q", op, ins.Raw)
 		}
+		if !arm64AtomicZeroOffsetMemory(ins.Args[1].Mem) {
+			return true, false, fmt.Errorf("arm64 %s memory must be a zero-offset general-register, RSP, or ZR address: %q", op, ins.Raw)
+		}
 		ty, align := arm64AtomicLoadStoreType(op)
 		src, err := c.loadReg(ins.Args[0].Reg)
 		if err != nil {
@@ -48,7 +231,7 @@ func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err
 		if err != nil {
 			return true, false, err
 		}
-		fmt.Fprintf(c.b, "  store atomic %s %s, ptr %s seq_cst, align %d\n", ty, v, ptr, align)
+		fmt.Fprintf(c.b, "  store atomic %s %s, ptr %s release, align %d\n", ty, v, ptr, align)
 		return true, false, nil
 
 	case "STLXRW", "STLXRB", "STLXR":
@@ -149,7 +332,11 @@ func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err
 		}
 		return true, false, c.storeReg(ins.Args[2].Reg, old64)
 
-	case "LDADDALW", "LDADDALD", "LDORALB", "LDORALW", "LDORALD", "LDCLRALB", "LDCLRALW", "LDCLRALD":
+	case "LDADDALW", "LDADDALD", "LDORALB", "LDORALW", "LDORALD", "LDCLRALB", "LDCLRALW", "LDCLRALD",
+		"LDEORB", "LDEORH", "LDEORW", "LDEORD",
+		"LDEORAB", "LDEORAH", "LDEORAW", "LDEORAD",
+		"LDEORLB", "LDEORLH", "LDEORLW", "LDEORLD",
+		"LDEORALB", "LDEORALH", "LDEORALW", "LDEORALD":
 		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpMem || ins.Args[2].Kind != OpReg {
 			return true, false, fmt.Errorf("arm64 %s expects srcReg, mem, dstReg: %q", op, ins.Raw)
 		}
@@ -177,6 +364,11 @@ func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err
 			rmwo = "add"
 		case "LDORALB", "LDORALW", "LDORALD":
 			rmwo = "or"
+		case "LDEORB", "LDEORH", "LDEORW", "LDEORD",
+			"LDEORAB", "LDEORAH", "LDEORAW", "LDEORAD",
+			"LDEORLB", "LDEORLH", "LDEORLW", "LDEORLD",
+			"LDEORALB", "LDEORALH", "LDEORALW", "LDEORALD":
+			rmwo = "xor"
 		case "LDCLRALB", "LDCLRALW", "LDCLRALD":
 			rmwo = "and"
 			// LDCLR updates memory as: mem = mem & ~src.
@@ -238,6 +430,194 @@ func (c *arm64Ctx) lowerAtomic(op Op, ins Instr) (ok bool, terminated bool, err
 	return false, false, nil
 }
 
+func (c *arm64Ctx) lowerAtomicRMWFamily(form arm64AtomicRMWForm, ins Instr) error {
+	if arm64AtomicOpcodeHasSuffix(ins.Op) || len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[0].Reg) ||
+		ins.Args[1].Kind != OpMem ||
+		ins.Args[2].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+		return fmt.Errorf("arm64 %s expects source register, zero-offset register memory, destination register: %q", ins.Op, ins.Raw)
+	}
+	mem := ins.Args[1].Mem
+	if mem.Sym != "" || mem.Segment != "" || mem.Index != "" || mem.Off != 0 || mem.OffRaw != "" ||
+		(mem.Base != Reg("RSP") && !isARM64GeneralOrZeroReg(mem.Base)) {
+		return fmt.Errorf("arm64 %s memory must be exactly (R0-R30), (RSP), or (ZR): %q", ins.Op, ins.Raw)
+	}
+	source64, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	source, err := c.atomicTruncFromI64(source64, form.typeName)
+	if err != nil {
+		return err
+	}
+	argument := source
+	if form.invert {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, form.typeName, source)
+		argument = "%" + inverted
+	}
+	pointer, err := c.atomicMemPtr(mem)
+	if err != nil {
+		return err
+	}
+	old := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = atomicrmw %s ptr %s, %s %s %s\n", old, form.operation, pointer, form.typeName, argument, form.ordering)
+	old64, err := c.atomicExtendToI64("%"+old, form.typeName)
+	if err != nil {
+		return err
+	}
+	return c.storeReg(ins.Args[2].Reg, old64)
+}
+
+func (c *arm64Ctx) lowerAtomicCASFamily(form arm64AtomicCASForm, ins Instr) error {
+	if arm64AtomicOpcodeHasSuffix(ins.Op) || len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[0].Reg) ||
+		ins.Args[1].Kind != OpMem ||
+		ins.Args[2].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+		return fmt.Errorf("arm64 %s expects expected register, zero-offset register memory, new-value register: %q", ins.Op, ins.Raw)
+	}
+	mem := ins.Args[1].Mem
+	if mem.Sym != "" || mem.Segment != "" || mem.Index != "" || mem.Off != 0 || mem.OffRaw != "" ||
+		(mem.Base != Reg("RSP") && !isARM64GeneralOrZeroReg(mem.Base)) {
+		return fmt.Errorf("arm64 %s memory must be exactly (R0-R30), (RSP), or (ZR): %q", ins.Op, ins.Raw)
+	}
+	expected64, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	expected, err := c.atomicTruncFromI64(expected64, form.typeName)
+	if err != nil {
+		return err
+	}
+	new64, err := c.loadReg(ins.Args[2].Reg)
+	if err != nil {
+		return err
+	}
+	newValue, err := c.atomicTruncFromI64(new64, form.typeName)
+	if err != nil {
+		return err
+	}
+	pointer, err := c.atomicMemPtr(mem)
+	if err != nil {
+		return err
+	}
+	align, err := arm64AtomicTypeSize(form.typeName)
+	if err != nil {
+		return err
+	}
+	changed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, %s %s, %s %s %s %s, align %d\n",
+		changed, pointer, form.typeName, expected, form.typeName, newValue, form.successOrder, form.failureOrder, align)
+	old := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 0\n", old, form.typeName, changed)
+	old64, err := c.atomicExtendToI64("%"+old, form.typeName)
+	if err != nil {
+		return err
+	}
+	return c.storeReg(ins.Args[0].Reg, old64)
+}
+
+func (c *arm64Ctx) lowerExclusiveFamily(form arm64ExclusiveForm, ins Instr) error {
+	wantArgs := 3
+	if form.isLoad {
+		wantArgs = 2
+	}
+	if arm64AtomicOpcodeHasSuffix(ins.Op) || len(ins.Args) != wantArgs {
+		return fmt.Errorf("arm64 %s has invalid exclusive load/store operands: %q", ins.Op, ins.Raw)
+	}
+	memoryIndex := 1
+	if form.isLoad {
+		memoryIndex = 0
+	}
+	if ins.Args[memoryIndex].Kind != OpMem {
+		return fmt.Errorf("arm64 %s requires a zero-offset register memory operand: %q", ins.Op, ins.Raw)
+	}
+	mem := ins.Args[memoryIndex].Mem
+	if mem.Sym != "" || mem.Segment != "" || mem.Index != "" || mem.Off != 0 || mem.OffRaw != "" ||
+		(mem.Base != Reg("RSP") && !isARM64GeneralOrZeroReg(mem.Base)) {
+		return fmt.Errorf("arm64 %s memory must be exactly (R0-R30), (RSP), or (ZR): %q", ins.Op, ins.Raw)
+	}
+	pointer, err := c.atomicMemPtr(mem)
+	if err != nil {
+		return err
+	}
+	size, err := arm64AtomicTypeSize(form.typeName)
+	if err != nil {
+		return err
+	}
+	if form.isLoad {
+		if ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+			return fmt.Errorf("arm64 %s destination must be a general register or ZR: %q", ins.Op, ins.Raw)
+		}
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load atomic %s, ptr %s %s, align %d\n", loaded, form.typeName, pointer, form.successOrder, size)
+		value64, err := c.atomicExtendToI64("%"+loaded, form.typeName)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i1 true, ptr %s\n", c.exclusiveValidSlot)
+		fmt.Fprintf(c.b, "  store ptr %s, ptr %s\n", pointer, c.exclusivePtrSlot)
+		fmt.Fprintf(c.b, "  store i8 %d, ptr %s\n", size, c.exclusiveSizeSlot)
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", value64, c.exclusiveValueSlot)
+		return c.storeReg(ins.Args[1].Reg, value64)
+	}
+	if ins.Args[0].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[0].Reg) ||
+		ins.Args[2].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+		return fmt.Errorf("arm64 %s source and status must be general registers or ZR: %q", ins.Op, ins.Raw)
+	}
+	source64, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	newValue, err := c.atomicTruncFromI64(source64, form.typeName)
+	if err != nil {
+		return err
+	}
+	loadedValid := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", loadedValid, c.exclusiveValidSlot)
+	loadedPointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load ptr, ptr %s\n", loadedPointer, c.exclusivePtrSlot)
+	pointerMatches := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq ptr %%%s, %s\n", pointerMatches, loadedPointer, pointer)
+	loadedSize := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s\n", loadedSize, c.exclusiveSizeSlot)
+	sizeMatches := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i8 %%%s, %d\n", sizeMatches, loadedSize, size)
+	validPointer := c.newTmp()
+	canTry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", validPointer, loadedValid, pointerMatches)
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", canTry, validPointer, sizeMatches)
+	id := c.newTmp()
+	tryLabel := arm64LLVMBlockName("stxr_try_" + id)
+	failLabel := arm64LLVMBlockName("stxr_fail_" + id)
+	mergeLabel := arm64LLVMBlockName("stxr_merge_" + id)
+	fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n", canTry, tryLabel, failLabel)
+	fmt.Fprintf(c.b, "\n%s:\n", tryLabel)
+	expected64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", expected64, c.exclusiveValueSlot)
+	expected, err := c.atomicTruncFromI64("%"+expected64, form.typeName)
+	if err != nil {
+		return err
+	}
+	changed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, %s %s, %s %s %s %s, align %d\n",
+		changed, pointer, form.typeName, expected, form.typeName, newValue, form.successOrder, form.failureOrder, size)
+	succeeded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 1\n", succeeded, form.typeName, changed)
+	failed := c.newTmp()
+	tryStatus := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", failed, succeeded)
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", tryStatus, failed)
+	fmt.Fprintf(c.b, "  br label %%%s\n", mergeLabel)
+	fmt.Fprintf(c.b, "\n%s:\n", failLabel)
+	fmt.Fprintf(c.b, "  br label %%%s\n", mergeLabel)
+	fmt.Fprintf(c.b, "\n%s:\n", mergeLabel)
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = phi i64 [ %%%s, %%%s ], [ 1, %%%s ]\n", status, tryStatus, tryLabel, failLabel)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.exclusiveValidSlot)
+	return c.storeReg(ins.Args[2].Reg, "%"+status)
+}
+
 func (c *arm64Ctx) atomicMemPtr(mem MemRef) (string, error) {
 	addr, _, _, err := c.addrI64(mem, false)
 	if err != nil {
@@ -248,10 +628,17 @@ func (c *arm64Ctx) atomicMemPtr(mem MemRef) (string, error) {
 	return "%" + pt, nil
 }
 
+func arm64AtomicZeroOffsetMemory(mem MemRef) bool {
+	return mem.Sym == "" && mem.Segment == "" && mem.Index == "" && mem.Off == 0 && mem.OffRaw == "" &&
+		(mem.Base == Reg("RSP") || isARM64GeneralOrZeroReg(mem.Base))
+}
+
 func arm64AtomicLoadStoreType(op Op) (LLVMType, int) {
 	switch op {
 	case "LDARB", "STLRB":
 		return I8, 1
+	case "LDARH", "STLRH":
+		return I16, 2
 	case "LDARW", "LDAXRW", "STLRW":
 		return I32, 4
 	default:
@@ -271,12 +658,20 @@ func arm64AtomicStoreExclusiveType(op Op) (LLVMType, int) {
 }
 
 func arm64AtomicRMWType(op Op) (LLVMType, error) {
+	if form, ok := parseARM64AtomicRMWOpcode(op); ok {
+		return form.typeName, nil
+	}
 	switch op {
-	case "SWPALB", "LDORALB", "LDCLRALB":
+	case "SWPALB", "LDORALB", "LDCLRALB",
+		"LDEORB", "LDEORAB", "LDEORLB", "LDEORALB":
 		return I8, nil
-	case "SWPALW", "LDADDALW", "LDORALW", "LDCLRALW":
+	case "LDEORH", "LDEORAH", "LDEORLH", "LDEORALH":
+		return I16, nil
+	case "SWPALW", "LDADDALW", "LDORALW", "LDCLRALW",
+		"LDEORW", "LDEORAW", "LDEORLW", "LDEORALW":
 		return I32, nil
-	case "SWPALD", "LDADDALD", "LDORALD", "LDCLRALD":
+	case "SWPALD", "LDADDALD", "LDORALD", "LDCLRALD",
+		"LDEORD", "LDEORAD", "LDEORLD", "LDEORALD":
 		return I64, nil
 	default:
 		return "", fmt.Errorf("arm64: unsupported atomic rmw op %s", op)
@@ -287,6 +682,8 @@ func arm64AtomicTypeSize(ty LLVMType) (int, error) {
 	switch ty {
 	case I8:
 		return 1, nil
+	case I16:
+		return 2, nil
 	case I32:
 		return 4, nil
 	case I64:
diff --git a/arm64_lower_atomic_cas_complete_test.go b/arm64_lower_atomic_cas_complete_test.go
new file mode 100644
index 000000000..6f8884d4e
--- /dev/null
+++ b/arm64_lower_atomic_cas_complete_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64AtomicCASCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT atomicCASComplete(SB),$0-0\n")
+	for _, width := range []string{"B", "H", "W", "D"} {
+		orders := []string{"", "AL"}
+		if width == "W" || width == "D" {
+			orders = []string{"", "A", "L", "AL"}
+		}
+		for _, order := range orders {
+			opcode := "CAS" + order + width
+			source.WriteString("\t" + opcode + " R5, (R6), R7\n")
+			source.WriteString("\t" + opcode + " ZR, (RSP), ZR\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64AtomicCASCompleteFormats(t *testing.T) {
+	source := arm64AtomicCASCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"atomicCASComplete": {Name: "atomicCASComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"cmpxchg ptr", " i8 ", " i16 ", " i32 ", " i64 ",
+		" monotonic monotonic", " acquire acquire", " release monotonic", " acq_rel acquire",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 complete CAS lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-cas-complete.ll", "arm64-cas-complete.o", ll)
+}
+
+func TestTranslateARM64AtomicCASRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"CASD R0, 8(R1), R2", "CASW R0, (R1)", "CASQ R0, (R1), R2"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 LSE CAS optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_atomic_eor_test.go b/arm64_lower_atomic_eor_test.go
new file mode 100644
index 000000000..d1a8d39e8
--- /dev/null
+++ b/arm64_lower_atomic_eor_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64LDEORCompleteFamily(t *testing.T) {
+	c, b := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.ldeor", Ret: Void}, nil)
+	for _, register := range []Reg{"R0", "R1", "R2"} {
+		if err := c.storeReg(register, "1"); err != nil {
+			t.Fatal(err)
+		}
+	}
+	mem := arm64MemOp("R1", 0)
+	ops := []Op{
+		"LDEORB", "LDEORH", "LDEORW", "LDEORD",
+		"LDEORAB", "LDEORAH", "LDEORAW", "LDEORAD",
+		"LDEORLB", "LDEORLH", "LDEORLW", "LDEORLD",
+		"LDEORALB", "LDEORALH", "LDEORALW", "LDEORALD",
+	}
+	for _, op := range ops {
+		instruction := Instr{Op: op, Args: []Operand{arm64RegOp("R0"), mem, arm64RegOp("R2")}, Raw: string(op) + " R0, (R1), R2"}
+		ok, terminated, err := c.lowerAtomic(op, instruction)
+		if err != nil || !ok || terminated {
+			t.Fatalf("lowerAtomic(%s) = (%v, %v, %v)", op, ok, terminated, err)
+		}
+	}
+	out := b.String()
+	if got := strings.Count(out, "atomicrmw xor"); got != len(ops) {
+		t.Fatalf("atomicrmw xor count = %d, want %d\n%s", got, len(ops), out)
+	}
+	for _, ty := range []string{"i8", "i16", "i32", "i64"} {
+		if !strings.Contains(out, "atomicrmw xor ptr") || !strings.Contains(out, ", "+ty+" ") {
+			t.Fatalf("missing %s LDEOR lowering:\n%s", ty, out)
+		}
+	}
+}
+
+func TestARM64LDEORRejectsInvalidForms(t *testing.T) {
+	c, _ := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.ldeor.invalid", Ret: Void}, nil)
+	for _, instruction := range []Instr{
+		{Op: "LDEORALW", Args: []Operand{arm64RegOp("R0"), arm64MemOp("R1", 0)}, Raw: "LDEORALW R0, (R1)"},
+		{Op: "LDEORALW", Args: []Operand{arm64RegOp("R0"), arm64RegOp("R1"), arm64RegOp("R2")}, Raw: "LDEORALW R0, R1, R2"},
+	} {
+		ok, _, err := c.lowerAtomic(instruction.Op, instruction)
+		if !ok || err == nil {
+			t.Fatalf("lowerAtomic(%q) = (%v, %v), want handled error", instruction.Raw, ok, err)
+		}
+	}
+}
diff --git a/arm64_lower_atomic_pair.go b/arm64_lower_atomic_pair.go
new file mode 100644
index 000000000..3cf4a63d7
--- /dev/null
+++ b/arm64_lower_atomic_pair.go
@@ -0,0 +1,334 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerAtomicPair(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64AtomicPairForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	ptr, err := c.atomicMemPtr(form.memory)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	typeName, align := "i64", 8
+	if form.spec.bits == 64 {
+		typeName, align = "i128", 16
+	}
+
+	switch form.spec.kind {
+	case arm64AtomicPairCAS:
+		return true, false, c.lowerAtomicPairCompareExchange(form.expected, form.data, form.spec.bits, ptr, "seq_cst", "seq_cst")
+	case arm64AtomicPairLoad:
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load atomic %s, ptr %s seq_cst, align %d\n", loaded, typeName, ptr, align)
+		if err := c.storeAtomicPairValue(form.data, form.spec.bits, "%"+loaded); err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  store i1 true, ptr %s\n", c.exclusiveValidSlot)
+		fmt.Fprintf(c.b, "  store ptr %s, ptr %s\n", ptr, c.exclusivePtrSlot)
+		fmt.Fprintf(c.b, "  store i8 %d, ptr %s\n", align, c.exclusiveSizeSlot)
+		reserved, err := c.atomicPairValueAsI128("%"+loaded, typeName)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  store i128 %s, ptr %s\n", reserved, c.exclusiveValueSlot)
+		return true, false, nil
+	case arm64AtomicPairStore:
+		newValue, err := c.loadAtomicPairValue(form.data, form.spec.bits)
+		if err != nil {
+			return true, false, err
+		}
+		status, err := c.lowerAtomicPairExclusiveStore(typeName, align, ptr, newValue)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeReg(form.status, status)
+	default:
+		return true, false, fmt.Errorf("arm64 %s has an unrecognized paired atomic grammar", op)
+	}
+}
+
+func (c *arm64Ctx) lowerAtomicPairCompareExchange(expectedRegs, newRegs []Reg, elemBits int, ptr, successOrder, failureOrder string) error {
+	typeName := "i64"
+	align := 8
+	if elemBits == 64 {
+		typeName = "i128"
+		align = 16
+	} else if elemBits != 32 {
+		return fmt.Errorf("arm64: invalid CASP element width %d", elemBits)
+	}
+	expected, err := c.loadAtomicPairValue(expectedRegs, elemBits)
+	if err != nil {
+		return err
+	}
+	newValue, err := c.loadAtomicPairValue(newRegs, elemBits)
+	if err != nil {
+		return err
+	}
+	cx := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, %s %s, %s %s %s %s, align %d\n",
+		cx, ptr, typeName, expected, typeName, newValue, successOrder, failureOrder, align)
+	old := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 0\n", old, typeName, cx)
+	return c.storeAtomicPairValue(expectedRegs, elemBits, "%"+old)
+}
+
+func arm64AtomicOpcodeHasSuffix(op Op) bool {
+	return strings.Contains(string(op), ".")
+}
+
+func arm64AtomicRegisterPair(op Operand) bool {
+	return op.Kind == OpRegList && len(op.RegList) == 2
+}
+
+func arm64AtomicDataRegister(reg Reg) bool {
+	s := strings.ToUpper(string(reg))
+	if s == "ZR" || s == "RSP" {
+		return true
+	}
+	if !strings.HasPrefix(s, "R") {
+		return false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "R"))
+	return err == nil && n >= 0 && n <= 30
+}
+
+func arm64AtomicNumberedRegister(reg Reg) (int, bool) {
+	s := strings.ToUpper(string(reg))
+	if !strings.HasPrefix(s, "R") || s == "RSP" {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "R"))
+	return n, err == nil && n >= 0 && n <= 30
+}
+
+func validateARM64CASPRegisterPair(role string, regs []Reg) error {
+	if len(regs) != 2 || !arm64AtomicDataRegister(regs[0]) || !arm64AtomicDataRegister(regs[1]) {
+		return fmt.Errorf("%s must be a pair of general-purpose registers", role)
+	}
+	first, ok := arm64AtomicNumberedRegister(regs[0])
+	if !ok || first&1 != 0 {
+		return fmt.Errorf("%s register pair must start from an even numbered register", role)
+	}
+	wantSecond := Reg(fmt.Sprintf("R%d", first+1))
+	if first == 30 {
+		wantSecond = ZR
+	}
+	if regs[1] != wantSecond {
+		return fmt.Errorf("%s register pair must be contiguous", role)
+	}
+	return nil
+}
+
+func validateARM64ExclusiveLoadPair(regs []Reg) error {
+	if len(regs) != 2 || !arm64AtomicDataRegister(regs[0]) || !arm64AtomicDataRegister(regs[1]) {
+		return fmt.Errorf("destination must be a pair of general-purpose registers")
+	}
+	if regs[0] == regs[1] {
+		return fmt.Errorf("destination register pair has constrained unpredictable behavior")
+	}
+	return nil
+}
+
+func validateARM64ExclusiveStorePair(regs []Reg, base Reg, status Reg) error {
+	if len(regs) != 2 || !arm64AtomicDataRegister(regs[0]) || !arm64AtomicDataRegister(regs[1]) {
+		return fmt.Errorf("source must be a pair of general-purpose registers")
+	}
+	if !arm64AtomicStatusRegister(status) {
+		return fmt.Errorf("status must be a general-purpose register or ZR")
+	}
+	if status == regs[0] || status == regs[1] || (base != Reg("RSP") && status == base) {
+		return fmt.Errorf("status register overlap has constrained unpredictable behavior")
+	}
+	return nil
+}
+
+func arm64AtomicStatusRegister(reg Reg) bool {
+	if reg == ZR {
+		return true
+	}
+	_, ok := arm64AtomicNumberedRegister(reg)
+	return ok
+}
+
+// Raw CASP uses the same address grammar without a named instruction form.
+func (c *arm64Ctx) atomicPairMemPtr(mem MemRef, allowNamedSP bool) (string, error) {
+	if err := validateARM64AtomicPairMemory(mem, allowNamedSP); err != nil {
+		return "", err
+	}
+	return c.atomicMemPtr(mem)
+}
+
+func validateARM64AtomicPairMemory(mem MemRef, allowNamedSP bool) error {
+	if mem.Sym != "" || mem.Segment != "" || mem.Index != "" || mem.Off != 0 {
+		return fmt.Errorf("paired atomic memory must have zero displacement and no index")
+	}
+	if mem.OffRaw != "" {
+		if !allowNamedSP || mem.Base != SP {
+			return fmt.Errorf("named SP memory is only accepted by CASP")
+		}
+	} else if mem.Base == SP {
+		return fmt.Errorf("plain SP is a pseudo-register; use RSP for register-relative memory")
+	}
+	if mem.Base != SP && mem.Base != Reg("RSP") && mem.Base != ZR {
+		if _, ok := arm64AtomicNumberedRegister(mem.Base); !ok {
+			return fmt.Errorf("paired atomic memory base must be R0-R30, RSP, or ZR")
+		}
+	}
+	return nil
+}
+
+func (c *arm64Ctx) loadAtomicPairDataReg(reg Reg) (string, error) {
+	if reg == ZR || reg == Reg("RSP") {
+		return "0", nil
+	}
+	return c.loadReg(reg)
+}
+
+func (c *arm64Ctx) storeAtomicPairDataReg(reg Reg, value string) error {
+	if reg == ZR || reg == Reg("RSP") {
+		return nil
+	}
+	return c.storeReg(reg, value)
+}
+
+func (c *arm64Ctx) loadAtomicPairValue(regs []Reg, elemBits int) (string, error) {
+	low64, err := c.loadAtomicPairDataReg(regs[0])
+	if err != nil {
+		return "", err
+	}
+	high64, err := c.loadAtomicPairDataReg(regs[1])
+	if err != nil {
+		return "", err
+	}
+	if elemBits == 32 {
+		low32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low32, low64)
+		low := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", low, low32)
+		high32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", high32, high64)
+		high := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", high, high32)
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", shifted, high)
+		joined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", joined, low, shifted)
+		return "%" + joined, nil
+	}
+	if elemBits != 64 {
+		return "", fmt.Errorf("arm64: invalid atomic pair element width %d", elemBits)
+	}
+	low := c.newTmp()
+	msg := "  %%%s = zext i64 %s to i128\n"
+	fmt.Fprintf(c.b, msg, low, low64)
+	high := c.newTmp()
+	fmt.Fprintf(c.b, msg, high, high64)
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl i128 %%%s, 64\n", shifted, high)
+	joined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = or i128 %%%s, %%%s\n", joined, low, shifted)
+	return "%" + joined, nil
+}
+
+func (c *arm64Ctx) storeAtomicPairValue(regs []Reg, elemBits int, value string) error {
+	if elemBits == 32 {
+		low32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low32, value)
+		low64 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", low64, low32)
+		highShift := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", highShift, value)
+		high32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", high32, highShift)
+		high64 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", high64, high32)
+		if err := c.storeAtomicPairDataReg(regs[0], "%"+low64); err != nil {
+			return err
+		}
+		return c.storeAtomicPairDataReg(regs[1], "%"+high64)
+	}
+	if elemBits != 64 {
+		return fmt.Errorf("arm64: invalid atomic pair element width %d", elemBits)
+	}
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %s to i64\n", low, value)
+	highShift := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i128 %s, 64\n", highShift, value)
+	high := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", high, highShift)
+	if err := c.storeAtomicPairDataReg(regs[0], "%"+low); err != nil {
+		return err
+	}
+	return c.storeAtomicPairDataReg(regs[1], "%"+high)
+}
+
+func (c *arm64Ctx) atomicPairValueAsI128(value, typeName string) (string, error) {
+	if typeName == "i128" {
+		return value, nil
+	}
+	if typeName != "i64" {
+		return "", fmt.Errorf("arm64: invalid paired atomic value type %s", typeName)
+	}
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", extended, value)
+	return "%" + extended, nil
+}
+
+func (c *arm64Ctx) lowerAtomicPairExclusiveStore(typeName string, align int, ptr, newValue string) (string, error) {
+	loadedValid := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", loadedValid, c.exclusiveValidSlot)
+	loadedPtr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load ptr, ptr %s\n", loadedPtr, c.exclusivePtrSlot)
+	ptrMatch := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq ptr %%%s, %s\n", ptrMatch, loadedPtr, ptr)
+	loadedSize := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s\n", loadedSize, c.exclusiveSizeSlot)
+	sizeMatch := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i8 %%%s, %d\n", sizeMatch, loadedSize, align)
+	precondition := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", precondition, loadedValid, ptrMatch)
+	canTry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", canTry, precondition, sizeMatch)
+
+	id := c.newTmp()
+	tryLabel := arm64LLVMBlockName("stxp_try_" + id)
+	failLabel := arm64LLVMBlockName("stxp_fail_" + id)
+	mergeLabel := arm64LLVMBlockName("stxp_merge_" + id)
+	fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n", canTry, tryLabel, failLabel)
+
+	fmt.Fprintf(c.b, "\n%s:\n", tryLabel)
+	expected128 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i128, ptr %s\n", expected128, c.exclusiveValueSlot)
+	expected := "%" + expected128
+	if typeName == "i64" {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", truncated, expected128)
+		expected = "%" + truncated
+	} else if typeName != "i128" {
+		return "", fmt.Errorf("arm64: invalid paired atomic store type %s", typeName)
+	}
+	cx := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = cmpxchg ptr %s, %s %s, %s %s seq_cst seq_cst, align %d\n", cx, ptr, typeName, expected, typeName, newValue, align)
+	succeeded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue {%s, i1} %%%s, 1\n", succeeded, typeName, cx)
+	failed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", failed, succeeded)
+	tryStatus := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", tryStatus, failed)
+	fmt.Fprintf(c.b, "  br label %%%s\n", mergeLabel)
+
+	fmt.Fprintf(c.b, "\n%s:\n", failLabel)
+	fmt.Fprintf(c.b, "  br label %%%s\n", mergeLabel)
+
+	fmt.Fprintf(c.b, "\n%s:\n", mergeLabel)
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = phi i64 [ %%%s, %%%s ], [ 1, %%%s ]\n", status, tryStatus, tryLabel, failLabel)
+	fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.exclusiveValidSlot)
+	return "%" + status, nil
+}
diff --git a/arm64_lower_atomic_rmw_complete_test.go b/arm64_lower_atomic_rmw_complete_test.go
new file mode 100644
index 000000000..b0005baea
--- /dev/null
+++ b/arm64_lower_atomic_rmw_complete_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64AtomicRMWCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT atomicRMWComplete(SB),$0-0\n")
+	for _, family := range []string{"SWP", "LDADD", "LDCLR", "LDOR", "LDEOR"} {
+		for _, order := range []string{"", "A", "L", "AL"} {
+			for _, width := range []string{"B", "H", "W", "D"} {
+				opcode := family + order + width
+				source.WriteString("\t" + opcode + " R5, (R6), R7\n")
+				source.WriteString("\t" + opcode + " R5, (RSP), ZR\n")
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64AtomicRMWCompleteFormats(t *testing.T) {
+	source := arm64AtomicRMWCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"atomicRMWComplete": {Name: "atomicRMWComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"atomicrmw xchg", "atomicrmw add", "atomicrmw and", "atomicrmw or", "atomicrmw xor",
+		" i8 ", " i16 ", " i32 ", " i64 ", " monotonic", " acquire", " release", " acq_rel",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 complete atomic RMW lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-atomic-rmw-complete.ll", "arm64-atomic-rmw-complete.o", ll)
+}
+
+func TestTranslateARM64AtomicRMWRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"SWPD R0, 8(R1), R2", "LDADDW R0, (R1)", "LDCLRQ R0, (R1), R2"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 LSE atomic RMW optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_barrier.go b/arm64_lower_barrier.go
new file mode 100644
index 000000000..362625b91
--- /dev/null
+++ b/arm64_lower_barrier.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64Barrier implements Go's ADMB optab row, the ADSB/AISB aliases
+// installed from it, and the operand-free ASB row.
+func (c *arm64Ctx) lowerARM64Barrier(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "SB":
+		if strings.ToUpper(string(ins.Op)) != "SB" || len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 SB accepts no operands or suffix: %q", ins.Raw)
+		}
+		// Preserve Go's actual SB encoding even when the LLVM baseline does
+		// not enable its mnemonic. HINT #7 is a different instruction, not a
+		// feature fallback. The source decides whether SB may execute.
+		c.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q()\n", ".inst 0xd50330ff", "~{memory}")
+		return true, false, nil
+	case "DMB", "DSB", "ISB":
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 1 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 %s expects exactly one constant operand with no suffix: %q", op, ins.Raw)
+	}
+	encoded := uint64(ins.Args[0].Imm) & 0xf
+	// Preserve the architectural operation instead of substituting a weaker
+	// generic LLVM fence. The memory clobber also prevents compiler reordering
+	// across DMB/DSB and is conservative for ISB.
+	c.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q()\n", strings.ToLower(string(op))+fmt.Sprintf(" #%d", encoded), "~{memory}")
+	return true, false, nil
+}
diff --git a/arm64_lower_barrier_test.go b/arm64_lower_barrier_test.go
new file mode 100644
index 000000000..2ed4ec66f
--- /dev/null
+++ b/arm64_lower_barrier_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const arm64BarrierForms = `
+TEXT barrierforms(SB),$0-0
+	DMB $0
+	DMB $1
+	DMB $15
+	DMB $255
+	DMB $-1
+	DSB $0
+	DSB $7
+	DSB $15
+	DSB $255
+	DSB $-1
+	ISB $0
+	ISB $1
+	ISB $15
+	ISB $255
+	ISB $-1
+	SB
+	RET
+`
+
+func TestTranslateARM64BarrierCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64BarrierForms, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64BarrierForms)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"barrierforms": {Name: "barrierforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "dmb #0"`,
+				`asm sideeffect "dmb #1"`,
+				`asm sideeffect "dmb #15"`,
+				`asm sideeffect "dsb #0"`,
+				`asm sideeffect "dsb #7"`,
+				`asm sideeffect "dsb #15"`,
+				`asm sideeffect "isb #0"`,
+				`asm sideeffect "isb #1"`,
+				`asm sideeffect "isb #15"`,
+				`asm sideeffect ".inst 0xd50330ff"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 barrier lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			// Go masks C_VCON values to the low four encoded bits.
+			if got := strings.Count(ll, `asm sideeffect "dmb #15"`); got != 3 {
+				t.Fatalf("DMB low-four-bit lowering count = %d, want 3:\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-barriers.ll", "arm64-barriers.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64BarrierRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"DMB",
+		"DSB R0",
+		"ISB $1, $2",
+		"DMB.P $1",
+		"SB $1",
+		"SB.P",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's barrier forms", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_bit_clear.go b/arm64_lower_bit_clear.go
new file mode 100644
index 000000000..ce6d25477
--- /dev/null
+++ b/arm64_lower_bit_clear.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64BitClear(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	word := op == "BICW" || op == "BICSW"
+	setFlags := op == "BICS" || op == "BICSW"
+	if !word && !setFlags && op != "BIC" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
+	}
+	if !arm64BitClearSourceValid(ins.Args[0], word) {
+		return true, false, fmt.Errorf("arm64 %s invalid first operand: %q", op, ins.Raw)
+	}
+
+	destinationIndex := len(ins.Args) - 1
+	destination := ins.Args[destinationIndex]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s destination must be a register: %q", op, ins.Raw)
+	}
+	destinationGeneral := isARM64GeneralOrZeroReg(destination.Reg)
+	destinationStack := destination.Reg == SP || destination.Reg == Reg("RSP")
+	if !destinationGeneral && !(len(ins.Args) == 3 && !setFlags && ins.Args[0].Kind == OpImm && destinationStack) {
+		return true, false, fmt.Errorf("arm64 %s invalid destination register: %q", op, ins.Raw)
+	}
+
+	leftOperand := destination
+	if len(ins.Args) == 3 {
+		leftOperand = ins.Args[1]
+		if leftOperand.Kind != OpReg || !isARM64GeneralOrZeroReg(leftOperand.Reg) {
+			return true, false, fmt.Errorf("arm64 %s second operand must be a general register: %q", op, ins.Raw)
+		}
+	}
+
+	if word {
+		right, err := c.eval32(ins.Args[0])
+		if err != nil {
+			return true, false, err
+		}
+		left, err := c.eval32(leftOperand)
+		if err != nil {
+			return true, false, err
+		}
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i32 %s, -1\n", inverted, right)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, %%%s\n", result, left, inverted)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		if err := c.storeReg(destination.Reg, "%"+wide); err != nil {
+			return true, false, err
+		}
+		if setFlags {
+			c.setFlagsLogic32("%" + result)
+		}
+		return true, false, nil
+	}
+
+	right, err := c.eval64(ins.Args[0], false)
+	if err != nil {
+		return true, false, err
+	}
+	left, err := c.eval64(leftOperand, false)
+	if err != nil {
+		return true, false, err
+	}
+	inverted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor i64 %s, -1\n", inverted, right)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i64 %s, %%%s\n", result, left, inverted)
+	if err := c.storeReg(destination.Reg, "%"+result); err != nil {
+		return true, false, err
+	}
+	if setFlags {
+		c.setFlagsLogic("%" + result)
+	}
+	return true, false, nil
+}
+
+func arm64BitClearSourceValid(operand Operand, word bool) bool {
+	switch operand.Kind {
+	case OpImm:
+		return operand.ImmRaw == ""
+	case OpReg:
+		return isARM64GeneralOrZeroReg(operand.Reg)
+	case OpRegShift:
+		if !isARM64GeneralOrZeroReg(operand.Reg) || operand.ShiftReg != "" {
+			return false
+		}
+		switch operand.ShiftOp {
+		case ShiftLeft, ShiftRight, ShiftArith, ShiftRotate:
+		default:
+			return false
+		}
+		limit := int64(63)
+		if word {
+			limit = 31
+		}
+		return operand.ShiftAmount >= 0 && operand.ShiftAmount <= limit
+	default:
+		return false
+	}
+}
diff --git a/arm64_lower_bit_clear_test.go b/arm64_lower_bit_clear_test.go
new file mode 100644
index 000000000..5c8e88910
--- /dev/null
+++ b/arm64_lower_bit_clear_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64BitClearCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT bitClearForms(SB), $0-0
+	MOVD RSP, R18_PLATFORM
+	BIC R0, R1
+	BIC R2, R3, R4
+	BIC R5>>7, R6, R7
+	BIC $255, R8, R9
+	BIC $255, R9, RSP
+	BICW R10, R11
+	BICW R12->3, R13, R14
+	BICW $255, R15, R16
+	BICS R17, R19
+	BICS R20->12, R21, R22
+	BICS $255, R23, R24
+	BICSW R24, R25
+	BICSW R26@>15, R27, R29
+	BICSW $255, R30, R0
+	MOVD R18_PLATFORM, RSP
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"bitClearForms": {Name: "bitClearForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"xor i64", "and i64", "xor i32", "and i32", "icmp slt i64", "icmp slt i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("bit-clear lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-bit-clear.ll", "arm64-bit-clear.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64BitClearRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"BIC R0",
+		"BIC R0, R1, R2, R3",
+		"BIC (R0), R1",
+		"BIC R0.UXTB, R1",
+		"BIC RSP, R1",
+		"BICW R0<<32, R1",
+		"BICS R0, RSP",
+		"BICSW.P R0, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badBitClear(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badBitClear": {Name: "badBitClear", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's BIC optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64BitClearRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT bitClearRuntime(SB), $0-24
+	MOVD mask+0(FP), R0
+	MOVD value+8(FP), R1
+	MOVD out+16(FP), R2
+	BIC R0, R1, R3
+	MOVD R3, 0(R2)
+	BICS R0, R1, R3
+	MOVD R3, 8(R2)
+	CSET MI, R4
+	MOVD R4, 16(R2)
+	CSET EQ, R4
+	MOVD R4, 24(R2)
+	CSET CS, R4
+	MOVD R4, 32(R2)
+	CSET VS, R4
+	MOVD R4, 40(R2)
+	BICSW R0, R1, R3
+	MOVD R3, 48(R2)
+	CSET MI, R4
+	MOVD R4, 56(R2)
+	CSET EQ, R4
+	MOVD R4, 64(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"bitClearRuntime": {
+				Name: "bitClearRuntime", Args: []LLVMType{I64, I64, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void bitClearRuntime(uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  const uint64_t mask = UINT64_C(0x00ff00ff00ff00ff);
+  const uint64_t value = UINT64_C(0xf0f00000f0f00000);
+  uint64_t got[9] = {0};
+  bitClearRuntime(mask, value, got);
+  const uint64_t result = value & ~mask;
+  const uint32_t word = (uint32_t)value & ~(uint32_t)mask;
+  const uint64_t want[9] = {result, result, result >> 63, result == 0, 0, 0, word, word >> 31, word == 0};
+  for (int i = 0; i < 9; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_bit_clear", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_bit_reverse.go b/arm64_lower_bit_reverse.go
new file mode 100644
index 000000000..a0c3ce8ae
--- /dev/null
+++ b/arm64_lower_bit_reverse.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64BitReverse(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "RBIT" && op != "RBITW" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg ||
+		!isARM64GeneralOrZeroReg(ins.Args[0].Reg) || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 %s expects general register, general register: %q", op, ins.Raw)
+	}
+
+	if op == "RBITW" {
+		source, err := c.eval32(ins.Args[0])
+		if err != nil {
+			return true, false, err
+		}
+		reversed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.bitreverse.i32(i32 %s)\n", reversed, source)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, reversed)
+		return true, false, c.storeReg(ins.Args[1].Reg, "%"+wide)
+	}
+
+	source, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	reversed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.bitreverse.i64(i64 %s)\n", reversed, source)
+	return true, false, c.storeReg(ins.Args[1].Reg, "%"+reversed)
+}
diff --git a/arm64_lower_bit_reverse_test.go b/arm64_lower_bit_reverse_test.go
new file mode 100644
index 000000000..93021bdcc
--- /dev/null
+++ b/arm64_lower_bit_reverse_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64BitReverseCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT bitReverseForms(SB), $0-0
+	RBIT R0, R1
+	RBITW R2, R3
+	RBIT ZR, ZR
+	RBITW ZR, ZR
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"bitReverseForms": {Name: "bitReverseForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"@llvm.bitreverse.i64", "@llvm.bitreverse.i32", "zext i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("bit-reverse lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-bit-reverse.ll", "arm64-bit-reverse.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64BitReverseRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"RBIT R0",
+		"RBIT $1, R0",
+		"RBIT R0, R1, R2",
+		"RBIT R0, (R1)",
+		"RBIT RSP, R0",
+		"RBIT V0, R0",
+		"RBITW.P R0, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badBitReverse(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badBitReverse": {Name: "badBitReverse", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's RBIT optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64BitReverseRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT bitReverseRuntime(SB), $0-16
+	MOVD value+0(FP), R0
+	MOVD out+8(FP), R1
+	RBIT R0, R2
+	MOVD R2, 0(R1)
+	RBITW R0, R2
+	MOVD R2, 8(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"bitReverseRuntime": {
+				Name: "bitReverseRuntime", Args: []LLVMType{I64, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void bitReverseRuntime(uint64_t, uint64_t *);
+static uint64_t reverse64(uint64_t value, int bits) {
+  uint64_t result = 0;
+  for (int i = 0; i < bits; i++) result = (result << 1) | ((value >> i) & 1);
+  return result;
+}
+int main(void) {
+  const uint64_t value = UINT64_C(0x0123456789abcdef);
+  uint64_t got[2] = {0, 0};
+  bitReverseRuntime(value, got);
+  return got[0] != reverse64(value, 64) || got[1] != reverse64((uint32_t)value, 32);
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_bit_reverse", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_branch.go b/arm64_lower_branch.go
index f70731927..126de7052 100644
--- a/arm64_lower_branch.go
+++ b/arm64_lower_branch.go
@@ -5,22 +5,10 @@ import (
 	"strings"
 )
 
-func (c *arm64Ctx) resolveBranchTarget(bi int, op Operand) (string, bool) {
-	if tgt, ok := arm64BranchTarget(op); ok {
-		return tgt, true
-	}
-	// Plan9's n(PC) is instruction-relative. Our lowering is block-based, so
-	// use a conservative target to keep translation total.
-	if op.Kind == OpMem && op.Mem.Base == PC {
-		if op.Mem.Off <= 0 {
-			return c.blocks[bi].name, true
-		}
-		if bi+1 < len(c.blocks) {
-			return c.blocks[bi+1].name, true
-		}
-		return c.blocks[bi].name, true
-	}
-	return "", false
+func (c *arm64Ctx) resolveBranchTarget(_ int, op Operand) (string, bool) {
+	// Named n(PC) operands must have been normalized to exact source labels.
+	// A block index cannot recover their instruction-relative destination.
+	return arm64BranchTarget(op)
 }
 
 func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emitCondBr arm64EmitCondBr) (ok bool, terminated bool, err error) {
@@ -29,21 +17,36 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 		if len(ins.Args) != 1 {
 			return true, false, fmt.Errorf("arm64 %s expects 1 operand: %q", op, ins.Raw)
 		}
-		if ins.Args[0].Kind == OpReg {
-			addr, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "blr $0", "r,~{memory}", addr)
-			return true, false, nil
+		if strings.Contains(strings.ToUpper(string(ins.Op)), ".") {
+			return true, false, fmt.Errorf("arm64 %s does not accept a suffix: %q", op, ins.Raw)
 		}
-		if ins.Args[0].Kind == OpMem {
-			addr, _, _, err := c.addrI64(ins.Args[0].Mem, false)
-			if err != nil {
+		if arm64IsLocalBranchLink(ins) {
+			target, targetOK := c.resolveBranchTarget(bi, ins.Args[0])
+			if !targetOK {
+				return true, false, fmt.Errorf("arm64 %s invalid local target: %q", op, ins.Raw)
+			}
+			knownTarget := false
+			for _, block := range c.blocks {
+				if block.name == target {
+					knownTarget = true
+					break
+				}
+			}
+			if !knownTarget {
+				return true, false, fmt.Errorf("arm64 %s undefined local target %q: %q", op, target, ins.Raw)
+			}
+			if bi+1 >= len(c.blocks) {
+				return true, false, fmt.Errorf("arm64 %s local target has no continuation block: %q", op, ins.Raw)
+			}
+			if err := c.storeLocalLink(c.blocks[bi+1].name); err != nil {
 				return true, false, err
 			}
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "blr $0", "r,~{memory}", addr)
-			return true, false, nil
+			emitBr(target)
+			return true, true, nil
+		}
+		if ins.Args[0].Kind == OpReg || ins.Args[0].Kind == OpMem {
+			term, err := c.lowerRegisterControl(bi, op, ins)
+			return true, term, err
 		}
 		if ins.Args[0].Kind != OpSym || !strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
 			return true, false, fmt.Errorf("arm64 %s expects symbol(SB)|reg|mem: %q", op, ins.Raw)
@@ -51,40 +54,41 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 		if err := c.callSym(ins.Args[0]); err != nil {
 			return true, false, err
 		}
+		if bi+1 < len(c.blocks) {
+			if err := c.storeLocalLink(c.blocks[bi+1].name); err != nil {
+				return true, false, err
+			}
+		}
 		return true, false, nil
 
 	case "B", "JMP":
 		if len(ins.Args) != 1 {
 			return true, false, fmt.Errorf("arm64 B expects 1 operand: %q", ins.Raw)
 		}
-		if ins.Args[0].Kind == OpReg {
-			addr, err := c.loadReg(ins.Args[0].Reg)
-			if err != nil {
+		if strings.Contains(string(ins.Op), ".") {
+			return true, false, fmt.Errorf("arm64 %s does not accept a suffix: %q", op, ins.Raw)
+		}
+		if ins.Args[0].Kind == OpReg || ins.Args[0].Kind == OpMem {
+			term, err := c.lowerRegisterControl(bi, op, ins)
+			return true, term, err
+		}
+		if ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
+			if c.lowerProvenUnreachableControl(bi) {
+				return true, true, nil
+			}
+			if c.sourceGoFrame.present {
+				return true, false, fmt.Errorf("%w: ARM64 symbol branch has no implicit Go frame epilogue: %q", ErrProbeNeedsContext, ins.Raw)
+			}
+			if err := c.requireCallerSPRestored(bi, ins); err != nil {
 				return true, false, err
 			}
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "br $0", "r,~{memory}", addr)
-			c.lowerRetZero()
-			return true, true, nil
-		}
-		if ins.Args[0].Kind == OpMem {
-			addr, _, _, err := c.addrI64(ins.Args[0].Mem, false)
-			if err != nil {
+			if err := c.requireCallerLinkRestored(bi, ins); err != nil {
 				return true, false, err
 			}
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "br $0", "r,~{memory}", addr)
-			c.lowerRetZero()
-			return true, true, nil
-		}
-		if ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
 			return true, true, c.tailCallAndRet(ins.Args[0])
 		}
 		tgt, ok := arm64BranchTarget(ins.Args[0])
 		if !ok {
-			// Legacy loop form in runtime stubs: B 0(PC)
-			if ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Base == PC {
-				emitBr(c.blocks[bi].name)
-				return true, true, nil
-			}
 			return true, false, fmt.Errorf("arm64 B invalid target: %q", ins.Raw)
 		}
 		emitBr(tgt)
@@ -95,15 +99,6 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 			return true, false, fmt.Errorf("arm64 %s expects label: %q", op, ins.Raw)
 		}
 		tgt, ok := arm64BranchTarget(ins.Args[0])
-		if !ok {
-			if ins.Args[0].Kind == OpMem && ins.Args[0].Mem.Base == PC {
-				// Relative PC branch in generated stubs; best-effort: use fallthrough.
-				if bi+1 < len(c.blocks) {
-					tgt = c.blocks[bi+1].name
-					ok = true
-				}
-			}
-		}
 		if !ok {
 			return true, false, fmt.Errorf("arm64 %s invalid target: %q", op, ins.Raw)
 		}
@@ -179,7 +174,7 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 		if fall == "" {
 			return true, false, fmt.Errorf("arm64 %s needs fallthrough block: %q", op, ins.Raw)
 		}
-		fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n", t, arm64LLVMBlockName(tgt), arm64LLVMBlockName(fall))
+		c.emitPredicateBranch("%"+t, tgt, fall)
 		return true, true, nil
 
 	case "TBZ", "TBNZ":
@@ -187,6 +182,9 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 			return true, false, fmt.Errorf("arm64 %s expects $bit, reg, label: %q", op, ins.Raw)
 		}
 		bit := ins.Args[0].Imm
+		if bit < 0 || bit > 63 {
+			return true, false, fmt.Errorf("arm64 %s bit index must be in [0, 63]: %q", op, ins.Raw)
+		}
 		rv, err := c.loadReg(ins.Args[1].Reg)
 		if err != nil {
 			return true, false, err
@@ -212,7 +210,7 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 		if fall == "" {
 			return true, false, fmt.Errorf("arm64 %s needs fallthrough block: %q", op, ins.Raw)
 		}
-		fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n", condT, arm64LLVMBlockName(tgt), arm64LLVMBlockName(fall))
+		c.emitPredicateBranch("%"+condT, tgt, fall)
 		return true, true, nil
 
 	case "CBZW", "CBNZW":
@@ -242,7 +240,7 @@ func (c *arm64Ctx) lowerBranch(bi int, op Op, ins Instr, emitBr arm64EmitBr, emi
 		if fall == "" {
 			return true, false, fmt.Errorf("arm64 %s needs fallthrough block: %q", op, ins.Raw)
 		}
-		fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n", t, arm64LLVMBlockName(tgt), arm64LLVMBlockName(fall))
+		c.emitPredicateBranch("%"+t, tgt, fall)
 		return true, true, nil
 	}
 	return false, false, nil
@@ -289,6 +287,105 @@ func (c *arm64Ctx) structArgFromSequentialRegs(aggTy LLVMType, regCursor *int) (
 	return agg, nil
 }
 
+func (c *arm64Ctx) abi0CallStackPtr(off int64) (string, error) {
+	sp, err := c.loadReg(SP)
+	if err != nil {
+		return "", fmt.Errorf("ABI0 call stack: %w", err)
+	}
+	// Go's arm64 ABI0 outgoing call frame reserves the first pointer-sized
+	// slot for the saved link register. Callee FP offset zero is therefore
+	// caller RSP+8, as emitted by the Go compiler before ABI0 wrapper calls.
+	const linkSlotSize = int64(8)
+	next := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", next, sp, off+linkSlotSize)
+	addr := "%" + next
+	ptr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", ptr, addr)
+	return "%" + ptr, nil
+}
+
+func (c *arm64Ctx) abi0CallArgs(callee string, sig FuncSig) ([]string, error) {
+	slotsByArg := make([][]FrameSlot, len(sig.Args))
+	for _, slot := range sig.Frame.Params {
+		if slot.Index < 0 || slot.Index >= len(sig.Args) {
+			return nil, fmt.Errorf("arm64 call %q: ABI0 parameter at +%d has invalid argument index %d", callee, slot.Offset, slot.Index)
+		}
+		slotsByArg[slot.Index] = append(slotsByArg[slot.Index], slot)
+	}
+	args := make([]string, 0, len(sig.Args))
+	for argIndex, argType := range sig.Args {
+		slots := slotsByArg[argIndex]
+		if len(slots) == 0 {
+			return nil, fmt.Errorf("arm64 call %q: ABI0 argument %d has no frame slot", callee, argIndex)
+		}
+		if len(slots) == 1 && len(frameSlotFields(slots[0])) == 0 {
+			if slots[0].Type != argType {
+				return nil, fmt.Errorf("arm64 call %q: ABI0 argument %d frame type %s does not match %s", callee, argIndex, slots[0].Type, argType)
+			}
+			ptr, err := c.abi0CallStackPtr(slots[0].Offset)
+			if err != nil {
+				return nil, err
+			}
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", value, argType, ptr)
+			args = append(args, fmt.Sprintf("%s %%%s", argType, value))
+			continue
+		}
+		aggregate := "undef"
+		for _, slot := range slots {
+			if len(frameSlotFields(slot)) == 0 {
+				return nil, fmt.Errorf("arm64 call %q: ABI0 aggregate argument %d has a scalar frame slot", callee, argIndex)
+			}
+			ptr, err := c.abi0CallStackPtr(slot.Offset)
+			if err != nil {
+				return nil, err
+			}
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 1\n", value, slot.Type, ptr)
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %%%s%s\n", inserted, argType, aggregate, slot.Type, value, frameSlotExtractSuffix(slot))
+			aggregate = "%" + inserted
+		}
+		args = append(args, fmt.Sprintf("%s %s", argType, aggregate))
+	}
+	return args, nil
+}
+
+func (c *arm64Ctx) storeABI0CallResult(callee string, sig FuncSig, result string) error {
+	if len(sig.Frame.Results) == 0 {
+		return fmt.Errorf("arm64 call %q: ABI0 result %s has no frame slot", callee, sig.Ret)
+	}
+	fields, aggregate := parseLiteralStructFields(sig.Ret)
+	for _, slot := range sig.Frame.Results {
+		value := result
+		if aggregate {
+			if slot.Index < 0 || slot.Index >= len(fields) || fields[slot.Index] != slot.Type {
+				return fmt.Errorf("arm64 call %q: ABI0 result slot %d does not match %s", callee, slot.Index, sig.Ret)
+			}
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, sig.Ret, result, slot.Index)
+			value = "%" + extracted
+		} else if slot.Index != 0 || slot.Type != sig.Ret {
+			return fmt.Errorf("arm64 call %q: ABI0 scalar result frame does not match %s", callee, sig.Ret)
+		}
+		ptr, err := c.abi0CallStackPtr(slot.Offset)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store %s %s, ptr %s, align 1\n", slot.Type, value, ptr)
+	}
+	return nil
+}
+
+// This finite lowering contract is not a general native-call effect proof.
+// LLGo's syscall bridge elides these scheduler hooks entirely. Its source BL
+// still produces the Go continuation/prologue, but no emitted call can observe
+// the virtual frame or change its GP/FP contents. Control and availability
+// analysis must use the same boundary as callSym, not an unknown native call.
+func arm64ElidesSchedulerHook(callee string) bool {
+	return callee == "runtime.entersyscall" || callee == "runtime.exitsyscall"
+}
+
 func (c *arm64Ctx) callSym(symOp Operand) error {
 	if symOp.Kind != OpSym {
 		return fmt.Errorf("arm64 call expects sym operand, got %s", symOp.String())
@@ -297,95 +394,83 @@ func (c *arm64Ctx) callSym(symOp Operand) error {
 	if !strings.HasSuffix(s, "(SB)") {
 		return fmt.Errorf("arm64 call expects (SB) symbol, got %q", s)
 	}
+	internalABI := strings.HasSuffix(strings.TrimSuffix(s, "(SB)"), "<ABIInternal>")
 	s = strings.TrimSuffix(s, "(SB)")
 	callee := c.resolve(s)
 	// Syscall stubs invoke runtime entersyscall/exitsyscall around SVC.
 	// llgo runtime does not require these scheduler hooks at this layer.
-	if callee == "runtime.entersyscall" || callee == "runtime.exitsyscall" {
+	if arm64ElidesSchedulerHook(callee) {
 		return nil
 	}
 	csig, ok := c.sigs[callee]
+	if csig.ARM64ClosureABI != nil {
+		return arm64GoABIContext("call %q requires a matching typed closure carrier", callee)
+	}
 	if !ok {
 		// Default for external runtime helpers not discovered in this asm file.
 		csig = FuncSig{Name: callee, Ret: Void}
 	}
-	callee = funcSigSymbol(callee, csig)
-	args := make([]string, 0, len(csig.Args))
-	regCursor := 0
-	for i := 0; i < len(csig.Args); i++ {
-		argTy := csig.Args[i]
-		if len(csig.ArgRegs) == 0 {
-			if fields, ok := parseLiteralStructFields(argTy); ok && literalFieldsAllScalar(fields) {
-				agg, err := c.structArgFromSequentialRegs(argTy, &regCursor)
-				if err != nil {
-					return fmt.Errorf("arm64 call %q: %w", callee, err)
-				}
-				args = append(args, fmt.Sprintf("%s %s", argTy, agg))
-				continue
+	if internalABI {
+		if csig.ARM64GoRegisterABI != nil {
+			if err := arm64ValidateGoRegisterABI(csig); err != nil {
+				return err
 			}
+		} else if len(csig.ArgRegs) == 0 || len(csig.ArgRegs) != len(csig.Args) {
+			return fmt.Errorf("%w: ARM64 ABIInternal call %q requires an explicit complete register-entry contract", ErrProbeNeedsContext, callee)
 		}
-
-		r := Reg("")
-		if len(csig.ArgRegs) > 0 {
-			r = Reg(fmt.Sprintf("R%d", i))
-			if i < len(csig.ArgRegs) {
-				r = csig.ArgRegs[i]
-			}
-		} else {
-			r = Reg(fmt.Sprintf("R%d", regCursor))
-			regCursor++
+	}
+	callee = funcSigSymbol(callee, csig)
+	stackABI := !internalABI && len(csig.ArgRegs) == 0 && len(csig.Frame.Params) != 0
+	var args []string
+	if internalABI && csig.ARM64GoRegisterABI != nil {
+		var err error
+		args, err = c.goABIRegisterCallArgs(csig)
+		if err != nil {
+			return err
 		}
-		v, err := c.loadReg(r)
+	} else if stackABI {
+		var err error
+		args, err = c.abi0CallArgs(callee, csig)
 		if err != nil {
 			return err
 		}
-		val, err := c.castI64RegToArg(v, argTy)
+	} else {
+		var err error
+		args, err = c.abiRegisterCallArgs(callee, csig)
 		if err != nil {
-			return fmt.Errorf("arm64 call %q unsupported arg type %s", callee, argTy)
+			return err
 		}
-		args = append(args, fmt.Sprintf("%s %s", argTy, val))
 	}
 	if csig.Ret == Void {
 		fmt.Fprintf(c.b, "  call void %s(%s)\n", llvmGlobal(callee), strings.Join(args, ", "))
+		if internalABI {
+			c.recordMachineCall(csig.ARM64GoRegisterABI, s)
+		} else {
+			c.recordMachineCall(nil, s)
+		}
 		return nil
 	}
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = call %s %s(%s)\n", t, csig.Ret, llvmGlobal(callee), strings.Join(args, ", "))
-	switch csig.Ret {
-	case I64:
-		return c.storeReg(Reg("R0"), "%"+t)
-	case I32, I16, I8, I1:
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext %s %%%s to i64\n", z, csig.Ret, t)
-		return c.storeReg(Reg("R0"), "%"+z)
-	case Ptr:
-		p := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", p, t)
-		return c.storeReg(Reg("R0"), "%"+p)
-	default:
-		fields, ok := parseLiteralStructFields(csig.Ret)
-		if !ok || !literalFieldsAllScalar(fields) {
-			return fmt.Errorf("arm64 call %q unsupported return type %s", callee, csig.Ret)
+	if internalABI && csig.ARM64GoRegisterABI != nil {
+		if err := c.storeGoABIRegisterResult(csig, "%"+t); err != nil {
+			return err
 		}
-		for i, fieldTy := range fields {
-			if i >= 8 {
-				return fmt.Errorf("arm64 call %q has %d scalar return fields, maximum is 8", callee, len(fields))
-			}
-			extracted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", extracted, csig.Ret, t, i)
-			value, scalar, err := arm64ValueAsI64(c, fieldTy, "%"+extracted)
-			if err != nil {
-				return err
-			}
-			if !scalar {
-				return fmt.Errorf("arm64 call %q unsupported return field type %s", callee, fieldTy)
-			}
-			if err := c.storeReg(Reg(fmt.Sprintf("R%d", i)), value); err != nil {
-				return err
-			}
+		c.recordMachineCall(csig.ARM64GoRegisterABI, s)
+		return nil
+	}
+	if !internalABI && len(csig.ArgRegs) == 0 && len(csig.Frame.Results) != 0 {
+		if err := c.storeABI0CallResult(callee, csig, "%"+t); err != nil {
+			return err
 		}
+		c.recordMachineCall(nil, s)
 		return nil
 	}
+	if err := c.storeABIRegisterResult(callee, csig.Ret, "%"+t); err != nil {
+		return err
+	}
+	c.recordMachineCall(nil, s)
+	return nil
 }
 
 func (c *arm64Ctx) tailCallAndRet(symOp Operand) error {
@@ -396,96 +481,69 @@ func (c *arm64Ctx) tailCallAndRet(symOp Operand) error {
 	if !strings.HasSuffix(s, "(SB)") {
 		return fmt.Errorf("arm64 tailcall expects (SB) symbol, got %q", s)
 	}
+	internalABI := strings.HasSuffix(strings.TrimSuffix(s, "(SB)"), "<ABIInternal>")
 	s = strings.TrimSuffix(s, "(SB)")
 	callee := c.resolve(s)
 	csig, ok := c.sigs[callee]
+	if csig.ARM64ClosureABI != nil {
+		return arm64GoABIContext("tail call %q requires a matching typed closure carrier", callee)
+	}
+	if err := arm64ValidatePrivateTailTransport(symOp.Sym, csig, ok); err != nil {
+		return err
+	}
 	if !ok {
 		// Cross-package trampoline (e.g. sync/atomic -> internal/runtime/atomic).
 		// If we don't have an explicit signature, fall back to caller signature.
 		csig = c.sig
 		csig.Name = callee
+		csig.ARM64GoRegisterABI = nil
 	}
-	callee = funcSigSymbol(callee, csig)
-
-	args := make([]string, 0, len(csig.Args))
-	regCursor := 0
-	for i := 0; i < len(csig.Args); i++ {
-		// If ArgRegs is empty, default to register-based passing (ABIInternal-ish)
-		// because most intra-asm tailcalls depend on explicit register setup.
-		//
-		// Exception: for tailcalls to Go functions with an identical signature,
-		// use the current function's LLVM args. This matches stdlib patterns like
-		// "B ·fooGeneric(SB)" that happen before any register shuffling and are
-		// stack-ABI tailcalls in the original asm.
-		useLLVMArgs := false
-		if len(csig.ArgRegs) == 0 && len(csig.Args) == len(c.sig.Args) && csig.Ret == c.sig.Ret {
-			same := true
-			for j := 0; j < len(csig.Args); j++ {
-				if csig.Args[j] != c.sig.Args[j] {
-					same = false
-					break
-				}
-			}
-			useLLVMArgs = same
-		}
-		if useLLVMArgs {
-			if i >= len(c.sig.Args) {
-				return fmt.Errorf("arm64 tailcall %q: need %d args, caller has %d", callee, len(csig.Args), len(c.sig.Args))
-			}
-			fromTy := c.sig.Args[i]
-			fromVal := fmt.Sprintf("%%arg%d", i)
-			toTy := csig.Args[i]
-			if fromTy == toTy {
-				args = append(args, fmt.Sprintf("%s %s", toTy, fromVal))
-				continue
-			}
-			t := c.newTmp()
-			switch {
-			case fromTy == I64 && (toTy == I1 || toTy == I8 || toTy == I16 || toTy == I32):
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to %s\n", t, fromVal, toTy)
-				args = append(args, fmt.Sprintf("%s %%%s", toTy, t))
-			case (fromTy == I1 || fromTy == I8 || fromTy == I16 || fromTy == I32) && toTy == I64:
-				fmt.Fprintf(c.b, "  %%%s = zext %s %s to i64\n", t, fromTy, fromVal)
-				args = append(args, "i64 %"+t)
-			case fromTy == I64 && toTy == Ptr:
-				fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", t, fromVal)
-				args = append(args, "ptr %"+t)
-			case fromTy == Ptr && toTy == I64:
-				fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", t, fromVal)
-				args = append(args, "i64 %"+t)
-			default:
-				return fmt.Errorf("arm64 tailcall %q: unsupported arg cast %s -> %s", callee, fromTy, toTy)
+	if c.goRegisterEntry && !internalABI && len(csig.ArgRegs) == 0 {
+		return arm64GoABIContext("register entry tail to %q needs an explicit target register or cross-ABI frame contract", callee)
+	}
+	if internalABI {
+		if csig.ARM64GoRegisterABI != nil {
+			if err := arm64ValidateGoRegisterABI(csig); err != nil {
+				return err
 			}
-			continue
+		} else if len(csig.ArgRegs) == 0 || len(csig.ArgRegs) != len(csig.Args) {
+			return fmt.Errorf("%w: ARM64 ABIInternal tail call %q requires an explicit complete register-entry contract", ErrProbeNeedsContext, callee)
 		}
+	}
+	callee = funcSigSymbol(callee, csig)
 
-		if len(csig.ArgRegs) == 0 {
-			if fields, ok := parseLiteralStructFields(csig.Args[i]); ok && literalFieldsAllScalar(fields) {
-				agg, err := c.structArgFromSequentialRegs(csig.Args[i], &regCursor)
-				if err != nil {
-					return fmt.Errorf("arm64 tailcall %q: %w", callee, err)
-				}
-				args = append(args, fmt.Sprintf("%s %s", csig.Args[i], agg))
-				continue
+	useLLVMArgs := !c.goRegisterEntry && !internalABI && len(csig.ArgRegs) == 0 && len(csig.Args) == len(c.sig.Args) && csig.Ret == c.sig.Ret
+	if useLLVMArgs {
+		for i := range csig.Args {
+			if csig.Args[i] != c.sig.Args[i] {
+				useLLVMArgs = false
+				break
 			}
 		}
-
-		r := Reg("")
-		if i < len(csig.ArgRegs) {
-			r = csig.ArgRegs[i]
-		} else {
-			r = Reg(fmt.Sprintf("R%d", regCursor))
-			regCursor++
+	}
+	args := make([]string, 0, len(csig.Args))
+	if useLLVMArgs {
+		for i, typ := range csig.Args {
+			args = append(args, fmt.Sprintf("%s %%arg%d", typ, i))
 		}
-		v, err := c.loadReg(r)
+	} else if internalABI && csig.ARM64GoRegisterABI != nil {
+		var err error
+		args, err = c.goABIRegisterCallArgs(csig)
 		if err != nil {
 			return err
 		}
-		val, err := c.castI64RegToArg(v, csig.Args[i])
+	} else if !internalABI && len(csig.ArgRegs) == 0 && len(csig.Frame.Params) != 0 {
+		var err error
+		args, err = c.abi0CallArgs(callee, csig)
+		if err != nil {
+			return fmt.Errorf("arm64 tailcall: %w", err)
+		}
+	} else {
+		var err error
+		args, err = c.abiRegisterCallArgs(callee, csig)
 		if err != nil {
-			return fmt.Errorf("arm64 tailcall unsupported arg type %q", csig.Args[i])
+			return fmt.Errorf("arm64 tailcall: %w", err)
 		}
-		args = append(args, fmt.Sprintf("%s %s", csig.Args[i], val))
 	}
 
 	if csig.Ret == Void {
@@ -512,7 +570,23 @@ func (c *arm64Ctx) tailCallAndRet(symOp Operand) error {
 		return nil
 	}
 	if csig.Ret != c.sig.Ret {
-		return fmt.Errorf("arm64 tailcall return mismatch: caller %s callee %s", c.sig.Ret, csig.Ret)
+		conv := c.newTmp()
+		calleeBits, calleeInteger := armIntegerTypeWidth(csig.Ret)
+		callerBits, callerInteger := armIntegerTypeWidth(c.sig.Ret)
+		switch {
+		case calleeInteger && callerInteger && calleeBits > callerBits:
+			fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", conv, csig.Ret, call, c.sig.Ret)
+		case calleeInteger && callerInteger && calleeBits < callerBits:
+			fmt.Fprintf(c.b, "  %%%s = zext %s %%%s to %s\n", conv, csig.Ret, call, c.sig.Ret)
+		case csig.Ret == Ptr && c.sig.Ret == I64:
+			fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", conv, call)
+		case csig.Ret == I64 && c.sig.Ret == Ptr:
+			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", conv, call)
+		default:
+			return fmt.Errorf("arm64 tailcall return mismatch: caller %s callee %s", c.sig.Ret, csig.Ret)
+		}
+		fmt.Fprintf(c.b, "  ret %s %%%s\n", c.sig.Ret, conv)
+		return nil
 	}
 	fmt.Fprintf(c.b, "  ret %s %%%s\n", c.sig.Ret, call)
 	return nil
diff --git a/arm64_lower_branch_link_test.go b/arm64_lower_branch_link_test.go
new file mode 100644
index 000000000..a50ad8384
--- /dev/null
+++ b/arm64_lower_branch_link_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64BranchLinkCompleteGoAssemblerForms(t *testing.T) {
+	const source = `
+TEXT branchLinkForms(SB),$0-0
+	BL local
+resume:
+	BL 1(PC)
+afterPC:
+	ADR indirectLocal, R3
+	BL R3
+	ADR indirectLocal, R4
+	BL (R4)
+	BL global(SB)
+	ADR indirectLocal, R5
+	CALL R5
+	ADR indirectLocal, R6
+	CALL (R6)
+	CALL global(SB)
+	B done
+local:
+	MOVD R30, R0
+	B resume
+indirectLocal:
+	B (R30)
+done:
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"branchLinkForms": {Name: "branchLinkForms", Ret: Void},
+					"global":          {Name: "global", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "blockaddress(@branchLinkForms, %bb_resume)") ||
+				!strings.Contains(ll, "store i64 %") || !strings.Contains(ll, "ptr %reg_R30") {
+				t.Fatalf("local BL did not materialize its continuation in R30:\n%s", ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm64-branch-link-"+target.name+".ll", "arm64-branch-link-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64BranchLinkRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"BL 8(R1)",
+		"BL RSP",
+		"BL V0",
+		"BL $1",
+		"BL.P R1",
+		"CALL 8(R1)",
+		"BL target, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badBranchLink(SB),$0-0\n\t" + instruction + "\ntarget:\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badBranchLink": {Name: "badBranchLink", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 BL table", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_cache_maintenance.go b/arm64_lower_cache_maintenance.go
new file mode 100644
index 000000000..668664faa
--- /dev/null
+++ b/arm64_lower_cache_maintenance.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64CacheOperation string
+
+type arm64SystemFields struct {
+	op1 uint8
+	cm  uint8
+	op2 uint8
+}
+
+// arm64CacheOperations mirrors exactly the cn=7 entries in Go's ARM64
+// sysInstFields table. DC is a SYS alias whose second operand is mandatory for
+// every operation currently accepted by Go.
+var arm64CacheOperations = map[arm64CacheOperation]arm64SystemFields{
+	"IVAC":    {0, 6, 1},
+	"ISW":     {0, 6, 2},
+	"CSW":     {0, 10, 2},
+	"CISW":    {0, 14, 2},
+	"ZVA":     {3, 4, 1},
+	"CVAC":    {3, 10, 1},
+	"CVAU":    {3, 11, 1},
+	"CIVAC":   {3, 14, 1},
+	"IGVAC":   {0, 6, 3},
+	"IGSW":    {0, 6, 4},
+	"IGDVAC":  {0, 6, 5},
+	"IGDSW":   {0, 6, 6},
+	"CGSW":    {0, 10, 4},
+	"CGDSW":   {0, 10, 6},
+	"CIGSW":   {0, 14, 4},
+	"CIGDSW":  {0, 14, 6},
+	"GVA":     {3, 4, 3},
+	"GZVA":    {3, 4, 4},
+	"CGVAC":   {3, 10, 3},
+	"CGDVAC":  {3, 10, 5},
+	"CGVAP":   {3, 12, 3},
+	"CGDVAP":  {3, 12, 5},
+	"CGVADP":  {3, 13, 3},
+	"CGDVADP": {3, 13, 5},
+	"CIGVAC":  {3, 14, 3},
+	"CIGDVAC": {3, 14, 5},
+	"CVAP":    {3, 12, 1},
+	"CVADP":   {3, 13, 1},
+}
+
+type arm64CacheForm struct {
+	operation arm64CacheOperation
+	fields    arm64SystemFields
+	address   Reg
+}
+
+func parseARM64CacheForm(op Op, ins Instr) (form arm64CacheForm, handled bool, err error) {
+	if op != "DC" {
+		return form, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != "DC" || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpIdent || ins.Args[1].Kind != OpReg ||
+		!isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return form, true, fmt.Errorf("arm64 DC expects a Go cache-operation name and one R/ZR operand, with no suffix: %q", ins.Raw)
+	}
+	form.operation = arm64CacheOperation(strings.ToUpper(strings.TrimSpace(ins.Args[0].Ident)))
+	var exists bool
+	form.fields, exists = arm64CacheOperations[form.operation]
+	if !exists {
+		return form, true, fmt.Errorf("arm64 DC operation %q is outside Go's sysInstFields table: %q", form.operation, ins.Raw)
+	}
+	form.address = ins.Args[1].Reg
+	return form, true, nil
+}
+
+// Match the complete SYS alias encoding, not just its cache-operation field.
+// The named and raw ZVA forms consume the same Go-derived metadata.
+func decodeARM64RawDCZVA(word uint32) (arm64CacheForm, bool) {
+	fields := arm64CacheOperations["ZVA"]
+	encoding := uint32(0xd5080000) | uint32(fields.op1)<<16 | 7<<12 |
+		uint32(fields.cm)<<8 | uint32(fields.op2)<<5
+	if word & ^uint32(31) != encoding {
+		return arm64CacheForm{}, false
+	}
+	address := Reg(fmt.Sprintf("R%d", word&31))
+	if word&31 == 31 {
+		address = ZR
+	}
+	return arm64CacheForm{operation: "ZVA", fields: fields, address: address}, true
+}
+
+func arm64DCZVAInstruction(form arm64CacheForm) Instr {
+	return Instr{Op: "DC", Args: []Operand{
+		{Kind: OpIdent, Ident: string(form.operation)}, {Kind: OpReg, Reg: form.address},
+	}}
+}
+
+func (c *arm64Ctx) lowerARM64CacheMaintenance(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64CacheForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	return true, false, c.lowerARM64CacheForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64CacheForm(form arm64CacheForm) error {
+	if form.operation == "ZVA" {
+		if err := c.requireDCZVANoPrivateAddressSources(); err != nil {
+			return err
+		}
+	}
+
+	prefix := fmt.Sprintf("sys #%d, c7, c%d, #%d", form.fields.op1, form.fields.cm, form.fields.op2)
+	emit := func(format string, args ...any) { fmt.Fprintf(c.b, format, args...) }
+	if form.operation == "ZVA" && form.address != "R18" && form.address != "R28" {
+		emit = c.emitMachineStoreNativeIR
+	}
+	if form.address == ZR {
+		emit("  call void asm sideeffect %q, %q()\n", prefix+", xzr", "~{memory}")
+		return nil
+	}
+	value, err := c.loadReg(form.address)
+	if err != nil {
+		return err
+	}
+	emit("  call void asm sideeffect %q, %q(i64 %s)\n", prefix+", $0", "r,~{memory}", value)
+	return nil
+}
+
+// ZVA stores to a hardware-sized, downward-aligned granule. Virtual frame
+// allocas cannot stand in for that physical extent. Until a stronger memory
+// contract exists, scan the complete source/decoded CFG (even dead blocks),
+// rejecting known syntactic sources of private frame/code/materialized-data
+// addresses. This is bounded source proof, not a complete native-layout model.
+// This does not promise that an external address has permission or is mapped:
+// the real SYS instruction retains DZP, translation and hardware fault behavior.
+func (c *arm64Ctx) requireDCZVANoPrivateAddressSources() error {
+	return validateARM64DCZVAAddressSources(c.sourceGoFrame, c.frameSize, c.blocks, c.sourceData)
+}
+
+func validateARM64DCZVASource(fn Func, data []DataStmt) error {
+	for _, original := range fn.Instrs {
+		ins := arm64ControlDecode(original)
+		form, handled, err := parseARM64CacheForm(arm64ControlOp(ins), ins)
+		if handled && err == nil && form.operation == "ZVA" {
+			return validateARM64DCZVAAddressSources(arm64SourceGoFrame(fn), fn.FrameSize, arm64SplitBlocks(fn), data)
+		}
+	}
+	return nil
+}
+
+func validateARM64DCZVAAddressSources(frame arm64GoFrame, frameSize int64, blocks []arm64Block, data []DataStmt) error {
+	context := func(source string) error {
+		return fmt.Errorf("%w: ARM64 DC ZVA needs a physical extent contract for private frame/code/materialized-data address sources at %q", ErrProbeNeedsContext, source)
+	}
+	if frame.present || frameSize > 0 {
+		return context("TEXT frame")
+	}
+	for _, datum := range data {
+		if datum.Addr != "" {
+			// SB loads can obtain a materialized object's address indirectly
+			// through DATA relocations, without any address-of operand in this
+			// function. Retain the complete file provenance in both gates;
+			// neither pointee extent nor down-aligned neighbours are proved.
+			return context(fmt.Sprintf("DATA %s+%d(SB)/%d,$%s", datum.Sym, datum.Off, datum.Width, datum.Addr))
+		}
+	}
+	for _, block := range blocks {
+		for _, original := range block.instrs {
+			ins := arm64ControlDecode(original)
+			op := arm64ControlOp(ins)
+			switch op {
+			case "CALL", "BL", "BLR", "ADR", "ADRP", OpWORD, "DWORD", arm64RawDataOp:
+				return context(original.Raw)
+			}
+			for _, operand := range ins.Args {
+				if operand.Kind == OpFP || operand.Kind == OpFPAddr {
+					return context(original.Raw)
+				}
+				registers := []Reg{operand.Reg, operand.Mem.Base, operand.Mem.Index, operand.ShiftReg}
+				registers = append(registers, operand.RegList...)
+				if operand.Kind == OpSym {
+					symbol := strings.TrimSpace(operand.Sym)
+					if strings.HasPrefix(symbol, "$") && strings.Contains(symbol, "(SB)") {
+						// A separately laid-out LLVM object's down-aligned zero
+						// granule and neighbours lack a native-layout proof.
+						// Ordinary SB reads/writes do not take this address.
+						return context(original.Raw)
+					}
+					if memory, ok := parseMem(strings.TrimPrefix(symbol, "$")); ok {
+						registers = append(registers, memory.Base, memory.Index)
+					}
+				}
+				for _, reg := range registers {
+					if reg == SP || reg == "RSP" || reg == PC ||
+						(reg == "R30" && op != OpRET && op != "B" && op != "JMP") {
+						return context(original.Raw)
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
diff --git a/arm64_lower_cache_maintenance_test.go b/arm64_lower_cache_maintenance_test.go
new file mode 100644
index 000000000..6359f7c77
--- /dev/null
+++ b/arm64_lower_cache_maintenance_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const arm64CacheMaintenanceForms = `
+TEXT cachemaintenanceforms(SB),$0-0
+	DC IVAC, R0
+	DC ISW, R1
+	DC CSW, R2
+	DC CISW, R3
+	DC ZVA, R4
+	DC CVAC, R5
+	DC CVAU, R6
+	DC CIVAC, R7
+	DC IGVAC, R8
+	DC IGSW, R9
+	DC IGDVAC, R10
+	DC IGDSW, R11
+	DC CGSW, R12
+	DC CGDSW, R13
+	DC CIGSW, R14
+	DC CIGDSW, R15
+	DC GVA, R16
+	DC GZVA, R17
+	DC CGVAC, ZR
+	DC CGDVAC, R19
+	DC CGVAP, R20
+	DC CGDVAP, R21
+	DC CGVADP, R22
+	DC CGDVADP, R23
+	DC CIGVAC, R24
+	DC CIGDVAC, R25
+	DC CVAP, R26
+	DC CVADP, R27
+	RET
+`
+
+func TestTranslateARM64CacheMaintenanceCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64CacheMaintenanceForms, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64CacheMaintenanceForms)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"cachemaintenanceforms": {Name: "cachemaintenanceforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, `asm sideeffect "sys #`); got != 28 {
+				t.Fatalf("ARM64 DC lowering emitted %d system operations, want 28:\n%s", got, ll)
+			}
+			for _, want := range []string{
+				`asm sideeffect "sys #0, c7, c6, #1, $0"`,   // IVAC
+				`asm sideeffect "sys #3, c7, c4, #1, $0"`,   // ZVA
+				`asm sideeffect "sys #3, c7, c14, #1, $0"`,  // CIVAC
+				`asm sideeffect "sys #3, c7, c10, #3, xzr"`, // CGVAC ZR
+				`asm sideeffect "sys #3, c7, c13, #1, $0"`,  // CVADP
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 DC lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-cache-maintenance.ll", "arm64-cache-maintenance.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64CacheMaintenanceRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"DC PLDL1KEEP",
+		"DC VMALLE1IS",
+		"DC VAE1IS, R0",
+		"DC IVAC",
+		"DC ZVA, SP",
+		"DC ZVA, R0, R1",
+		"DC.P ZVA, R0",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's DC forms", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_call_abi0_test.go b/arm64_lower_call_abi0_test.go
new file mode 100644
index 000000000..7038fc435
--- /dev/null
+++ b/arm64_lower_call_abi0_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64ABI0CallUsesOutgoingStackFrameRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT ·arm64ABI0Callee(SB), $0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	EOR R1, R0
+	MOVD c+16(FP), R1
+	EOR R1, R0
+	MOVD R0, ret+24(FP)
+	RET
+
+TEXT ·arm64ABI0Caller(SB), $40-32
+	MOVD a+0(FP), R10
+	ADD $1, R10
+	MOVD R10, 8(RSP)
+	MOVD b+8(FP), R10
+	ADD $2, R10
+	MOVD R10, 16(RSP)
+	MOVD c+16(FP), R10
+	ADD $4, R10
+	MOVD R10, 24(RSP)
+	BL ·arm64ABI0Callee(SB)
+	MOVD 32(RSP), R0
+	MOVD R0, ret+24(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	frame := FrameLayout{
+		Params: []FrameSlot{
+			{Offset: 0, Type: I64, Index: 0, Field: -1, Name: "a"},
+			{Offset: 8, Type: I64, Index: 1, Field: -1, Name: "b"},
+			{Offset: 16, Type: I64, Index: 2, Field: -1, Name: "c"},
+		},
+		Results: []FrameSlot{{Offset: 24, Type: I64, Index: 0, Field: -1, Name: "ret"}},
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		ResolveSym:   resolve,
+		Sigs: map[string]FuncSig{
+			"arm64ABI0Callee": {Name: "arm64ABI0Callee", Args: []LLVMType{I64, I64, I64}, Ret: I64, Frame: frame},
+			"arm64ABI0Caller": {Name: "arm64ABI0Caller", Args: []LLVMType{I64, I64, I64}, Ret: I64, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern uint64_t arm64ABI0Caller(uint64_t a, uint64_t b, uint64_t c);
+int main(void) {
+  uint64_t got = arm64ABI0Caller(10, 20, 30);
+  uint64_t want = (10 + 1) ^ (20 + 2) ^ (30 + 4);
+  return got == want ? 0 : 1;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_abi0_call", triple, ll, mainC, nil)
+}
+
+func TestARM64ABI0FramedStackTailRequiresNativeStackContract(t *testing.T) {
+	source := arm64StackTailOriginalSource()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	args := make([]LLVMType, 17)
+	params := make([]FrameSlot, 17)
+	for index := range args {
+		args[index] = I64
+		params[index] = FrameSlot{Offset: int64(index * 8), Type: I64, Index: index, Field: -1}
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			_, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64", ResolveSym: resolve,
+				Sigs: map[string]FuncSig{
+					"arm64ABI0StackTail":  {Name: "arm64ABI0StackTail", Ret: I64},
+					"arm64ABI0TailTarget": {Name: "arm64ABI0TailTarget", Args: args, Ret: I64, Frame: FrameLayout{Params: params}},
+				},
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "symbol branch has no implicit Go frame epilogue") {
+				t.Fatalf("framed JMP must not synthesize a Go epilogue: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64ABIInternalCallUsesIndependentRegisterBanks(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT ·arm64ABIRegisterForward(SB), $0-0
+	BL ·arm64ABIRegisterCallee(SB)
+	RET
+
+TEXT ·arm64ABIFloatForward(SB), $0-0
+	BL ·arm64ABIFloatCallee(SB)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	args := []LLVMType{I64, LLVMType("float"), LLVMType("double"), I64}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		ResolveSym:   resolve,
+		Sigs: map[string]FuncSig{
+			"arm64ABIRegisterForward": {Name: "arm64ABIRegisterForward", Args: args, Ret: I64},
+			"arm64ABIRegisterCallee":  {Name: "arm64ABIRegisterCallee", Args: args, Ret: I64},
+			"arm64ABIFloatForward":    {Name: "arm64ABIFloatForward", Args: []LLVMType{LLVMType("float")}, Ret: LLVMType("float")},
+			"arm64ABIFloatCallee":     {Name: "arm64ABIFloatCallee", Args: []LLVMType{LLVMType("float")}, Ret: LLVMType("float")},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+extern uint64_t arm64ABIRegisterForward(uint64_t first, float single, double dbl, uint64_t second);
+extern float arm64ABIFloatForward(float value);
+uint64_t arm64ABIRegisterCallee(uint64_t first, float single, double dbl, uint64_t second) {
+  uint32_t single_bits;
+  uint64_t double_bits;
+  memcpy(&single_bits, &single, sizeof(single_bits));
+  memcpy(&double_bits, &dbl, sizeof(double_bits));
+  return first ^ single_bits ^ double_bits ^ second;
+}
+float arm64ABIFloatCallee(float value) { return value * 2.0f; }
+int main(void) {
+  const uint64_t first = UINT64_C(0x123456789abcdef0);
+  const uint64_t second = UINT64_C(0xfedcba9876543210);
+  const float single = -13.25f;
+  const double dbl = 91.5;
+  uint32_t single_bits;
+  uint64_t double_bits;
+  memcpy(&single_bits, &single, sizeof(single_bits));
+  memcpy(&double_bits, &dbl, sizeof(double_bits));
+  uint64_t want = first ^ single_bits ^ double_bits ^ second;
+  if (arm64ABIRegisterForward(first, single, dbl, second) != want) return 1;
+  if (arm64ABIFloatForward(1.25f) != 2.5f) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_abi_register_call", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_clrex_test.go b/arm64_lower_clrex_test.go
new file mode 100644
index 000000000..4b778a12f
--- /dev/null
+++ b/arm64_lower_clrex_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64CLREXCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 accepts CLREX with no operand or with one C_VCON immediate.
+	// The encoder uses the low four immediate bits, so values outside 0..15
+	// remain valid spellings even though the immediate does not affect our
+	// exclusive-monitor model.
+	source := `
+TEXT clrexforms(SB),NOSPLIT,$0-0
+	CLREX
+	CLREX $0
+	CLREX $15
+	CLREX $255
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"clrexforms": {Name: "clrexforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			// One initialization plus one clear for every CLREX instruction.
+			if got := strings.Count(ll, "store i1 false, ptr %exclusive_valid"); got != 5 {
+				t.Fatalf("exclusive monitor clear count = %d, want 5\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "clrex-"+target.name+".ll", "clrex-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64CLREXRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"CLREX R0",
+		"CLREX $1, $2",
+		"CLREX.Z",
+	} {
+		file, err := Parse(ArchARM64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's CLREX forms", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_compare_negative.go b/arm64_lower_compare_negative.go
new file mode 100644
index 000000000..d5ef60d34
--- /dev/null
+++ b/arm64_lower_compare_negative.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+func validateARM64CompareNegativeOperands(source, destination Operand, word bool) error {
+	if destination.Kind != OpReg || !(isARM64GeneralOrZeroReg(destination.Reg) || destination.Reg == SP || destination.Reg == Reg("RSP")) {
+		return fmt.Errorf("destination is outside Go 1.27's C_ZREG/C_RSP classes")
+	}
+	switch source.Kind {
+	case OpImm:
+		return nil
+	case OpReg:
+		if !isARM64GeneralOrZeroReg(source.Reg) {
+			return fmt.Errorf("register source is outside Go 1.27's C_ZREG class")
+		}
+		return nil
+	case OpRegShift:
+		if !isARM64GeneralOrZeroReg(source.Reg) || source.ShiftReg != "" {
+			return fmt.Errorf("shifted source is outside Go 1.27's C_SHIFT class")
+		}
+		if source.ShiftOp != ShiftLeft && source.ShiftOp != ShiftRight && source.ShiftOp != ShiftArith {
+			return fmt.Errorf("shift operator %q is outside Go 1.27's C_SHIFT class", source.ShiftOp)
+		}
+		maximum := int64(63)
+		if word {
+			maximum = 31
+		}
+		if source.ShiftAmount < 0 || source.ShiftAmount > maximum {
+			return fmt.Errorf("shift amount %d is outside 0..%d", source.ShiftAmount, maximum)
+		}
+		return nil
+	case OpRegExtend:
+		if !isARM64GeneralOrZeroReg(source.Reg) || source.ShiftReg != "" || source.ShiftAmount < 0 || source.ShiftAmount > 4 {
+			return fmt.Errorf("extended source is outside Go 1.27's C_EXTREG class")
+		}
+		switch source.Ext {
+		case ExtendUXTB, ExtendUXTH, ExtendUXTW, ExtendSXTB, ExtendSXTH, ExtendSXTW:
+			return nil
+		case ExtendUXTX, ExtendSXTX:
+			if !word {
+				return nil
+			}
+		}
+		return fmt.Errorf("extension %q is invalid for the %d-bit form", source.Ext, map[bool]int{true: 32, false: 64}[word])
+	default:
+		return fmt.Errorf("source is outside Go 1.27's immediate/C_ZREG/C_SHIFT/C_EXTREG classes")
+	}
+}
diff --git a/arm64_lower_compare_negative_test.go b/arm64_lower_compare_negative_test.go
new file mode 100644
index 000000000..72a6278eb
--- /dev/null
+++ b/arm64_lower_compare_negative_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64CompareNegativeCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT compareNegativeForms(SB), $0-0
+	CMNW R21.UXTB<<4, R15
+	CMN R0.UXTW<<4, R16
+	CMNW R13>>8, R9
+	CMN R6->17, R3
+	CMNW $(2<<12), R5
+	CMN $(8<<12), R12
+	CMN R6->0, R3
+	CMN R6, R3
+	CMNW R30, R5
+	CMNW $2, R5
+	CMN ZR, R3
+	CMN R1.SXTX<<2, R10
+	CMNW R1.SXTB, R9
+	CMN R1<<3, RSP
+	CMNW $0x3fffffc0, R2
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"compareNegativeForms": {Name: "compareNegativeForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"add i64", "add i32", "icmp ult i32", "icmp slt i32"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("CMN/CMNW lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-cmn.ll", "arm64-cmn.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64CompareNegativeRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"CMN R0",
+		"CMNW R0, R1, R2",
+		"CMN (R0), R1",
+		"CMNW R0@>1, R1",
+		"CMN R0.UXTB<<5, R1",
+		"CMNW.P R0, R1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT badCompareNegative(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badCompareNegative": {Name: "badCompareNegative", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's CMN/CMNW optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64CompareNegativeRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT compareNegativeRuntime(SB), $0-16
+	MOVD value+0(FP), R0
+	MOVD $0, R1
+	CMNW $1, R0
+	BNE notWordMinusOne
+	ORR $1, R1
+notWordMinusOne:
+	CMN $1, R0
+	BNE done
+	ORR $2, R1
+done:
+	MOVD R1, ret+8(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"compareNegativeRuntime": {
+				Name: "compareNegativeRuntime", Args: []LLVMType{I64}, Ret: I64,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern uint64_t compareNegativeRuntime(uint64_t);
+int main(void) {
+  if (compareNegativeRuntime(UINT64_C(0xffffffffffffffff)) != 3) return 1;
+  if (compareNegativeRuntime(UINT64_C(0x00000000ffffffff)) != 1) return 2;
+  if (compareNegativeRuntime(7) != 0) return 3;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_cmn", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_conditional_compare_complete_test.go b/arm64_lower_conditional_compare_complete_test.go
new file mode 100644
index 000000000..1939f50aa
--- /dev/null
+++ b/arm64_lower_conditional_compare_complete_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64ConditionalCompareCompleteFormats(t *testing.T) {
+	const source = `TEXT conditionalCompareComplete(SB),$0-0
+	CMP R0, R0
+	CCMN MI, ZR, R1, $4
+	CCMN PL, R2, $6, $1
+	CCMNW AL, R3, $20, $11
+	CCMNW EQ, R4, R5, $6
+	CCMP LT, R6, R7, $7
+	CCMP LE, R8, $19, $3
+	CCMPW HS, R9, R10, $0
+	CCMPW VS, R11, $15, $7
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"conditionalCompareComplete": {Name: "conditionalCompareComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"add i64", "add i32", "sub i64", "sub i32", "select i1 true"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 conditional compare lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-conditional-compare.ll", "arm64-conditional-compare.o", ll)
+}
+
+func TestTranslateARM64ConditionalCompareRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"CCMN BAD, R0, R1, $0",
+		"CCMN AL, RSP, R1, $0",
+		"CCMN AL, R0, (R1), $0",
+		"CCMN.P AL, R0, R1, $0",
+		"CCMPW AL, R0, R1",
+	} {
+		source := "TEXT bad(SB),$0-0\n\tCMP R0, R0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 conditional-compare optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_count_bits.go b/arm64_lower_count_bits.go
new file mode 100644
index 000000000..52fc80aca
--- /dev/null
+++ b/arm64_lower_count_bits.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64VectorCountBitsOps = map[Op]struct{}{
+	"VCNT": {},
+	"VCLS": {},
+	"VCLZ": {},
+}
+
+func (c *arm64Ctx) lowerARM64VectorCountBits(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, ok := arm64VectorCountBitsOps[op]; !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects two same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	validArrangement := sourceArrangement.elementBits == 8 && (sourceArrangement.lanes == 8 || sourceArrangement.lanes == 16)
+	if op != "VCNT" {
+		validArrangement = (sourceArrangement.elementBits == 8 || sourceArrangement.elementBits == 16 || sourceArrangement.elementBits == 32) &&
+			(sourceArrangement.lanes*sourceArrangement.elementBits == 64 || sourceArrangement.lanes*sourceArrangement.elementBits == 128)
+	}
+	if !sourceOK || !destinationOK || sourceArrangement != destinationArrangement || !validArrangement {
+		return true, false, fmt.Errorf("arm64 %s requires matching Go assembler vector arrangements: %q", op, ins.Raw)
+	}
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if op == "VCNT" {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <%d x i8> @llvm.ctpop.v%di8(<%d x i8> %s)\n", result, sourceArrangement.lanes, sourceArrangement.lanes, sourceArrangement.lanes, source)
+		return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, "%"+result)
+	}
+
+	vectorType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	countSource := source
+	if op == "VCLS" {
+		sign := c.newTmp()
+		normalized := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ashr %s %s, %s\n", sign, vectorType, source, arm64VectorIntegerSplat(sourceArrangement, int64(sourceArrangement.elementBits-1)))
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %%%s\n", normalized, vectorType, source, sign)
+		countSource = "%" + normalized
+	}
+	count := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.ctlz.v%di%d(%s %s, i1 false)\n",
+		count, vectorType, sourceArrangement.lanes, sourceArrangement.elementBits, vectorType, countSource)
+	result := "%" + count
+	if op == "VCLS" {
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %s\n", adjusted, vectorType, count, arm64VectorIntegerSplat(sourceArrangement, 1))
+		result = "%" + adjusted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, result)
+}
diff --git a/arm64_lower_count_bits_test.go b/arm64_lower_count_bits_test.go
new file mode 100644
index 000000000..e2f777bda
--- /dev/null
+++ b/arm64_lower_count_bits_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorCountBitsCompleteGoAssemblerForms(t *testing.T) {
+	source := `TEXT ·vectorCountBitsForms(SB), $0-0
+	VCNT V0.B8, V1.B8
+	VCNT V0.B16, V1.B16
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorCountBitsForms": {Name: "vectorCountBitsForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-count-bits.ll", "arm64-vector-count-bits.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorCountBitsRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VCNT V0.H4, V1.H4",
+		"VCNT V0.B8, V1.B16",
+		"VCNT V0.B16, V1.B8",
+		"VCNT V0.B8, V1.B8, V2.B8",
+		"VCNT.P V0.B16, V1.B16",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorCountBits(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorCountBits": {Name: "badVectorCountBits", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VCNT forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_count_leading.go b/arm64_lower_count_leading.go
new file mode 100644
index 000000000..baf34f81f
--- /dev/null
+++ b/arm64_lower_count_leading.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64CountLeading(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	signed := op == "CLS" || op == "CLSW"
+	word := op == "CLZW" || op == "CLSW"
+	if !signed && !word && op != "CLZ" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg ||
+		!isARM64GeneralOrZeroReg(ins.Args[0].Reg) || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 %s expects general register, general register: %q", op, ins.Raw)
+	}
+
+	if word {
+		source, err := c.eval32(ins.Args[0])
+		if err != nil {
+			return true, false, err
+		}
+		value := source
+		if signed {
+			sign := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = ashr i32 %s, 31\n", sign, source)
+			normalized := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor i32 %s, %%%s\n", normalized, source, sign)
+			value = "%" + normalized
+		}
+		count := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.ctlz.i32(i32 %s, i1 false)\n", count, value)
+		result := "%" + count
+		if signed {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sub i32 %s, 1\n", adjusted, result)
+			result = "%" + adjusted
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, result)
+		return true, false, c.storeReg(ins.Args[1].Reg, "%"+wide)
+	}
+
+	source, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	value := source
+	if signed {
+		sign := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, 63\n", sign, source)
+		normalized := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor i64 %s, %%%s\n", normalized, source, sign)
+		value = "%" + normalized
+	}
+	count := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.ctlz.i64(i64 %s, i1 false)\n", count, value)
+	result := "%" + count
+	if signed {
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub i64 %s, 1\n", adjusted, result)
+		result = "%" + adjusted
+	}
+	return true, false, c.storeReg(ins.Args[1].Reg, result)
+}
diff --git a/arm64_lower_count_leading_test.go b/arm64_lower_count_leading_test.go
new file mode 100644
index 000000000..1114e8616
--- /dev/null
+++ b/arm64_lower_count_leading_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64CountLeadingCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT countLeadingForms(SB), $0-0
+	CLZ R0, R1
+	CLZW R2, R3
+	CLS R4, R5
+	CLSW R6, R7
+	CLZ ZR, ZR
+	CLZW ZR, ZR
+	CLS ZR, ZR
+	CLSW ZR, ZR
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"countLeadingForms": {Name: "countLeadingForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"@llvm.ctlz.i64", "@llvm.ctlz.i32", "ashr i64", "ashr i32", "sub i64", "sub i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("count-leading lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-count-leading.ll", "arm64-count-leading.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64CountLeadingRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"CLZ R0",
+		"CLZW $1, R0",
+		"CLS R0, R1, R2",
+		"CLSW R0, (R1)",
+		"CLZ RSP, R0",
+		"CLS V0, R0",
+		"CLZW.P R0, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badCountLeading(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badCountLeading": {Name: "badCountLeading", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's count-leading optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64CountLeadingRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT countLeadingRuntime(SB), $0-16
+	MOVD value+0(FP), R0
+	MOVD out+8(FP), R1
+	CLZ R0, R2
+	MOVD R2, 0(R1)
+	CLZW R0, R2
+	MOVD R2, 8(R1)
+	CLS R0, R2
+	MOVD R2, 16(R1)
+	CLSW R0, R2
+	MOVD R2, 24(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"countLeadingRuntime": {
+				Name: "countLeadingRuntime", Args: []LLVMType{I64, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void countLeadingRuntime(uint64_t, uint64_t *);
+static uint64_t clz64(uint64_t value) { return value ? __builtin_clzll(value) : 64; }
+static uint64_t clz32(uint32_t value) { return value ? __builtin_clz(value) : 32; }
+int main(void) {
+  const uint64_t value = UINT64_C(0xf123456789abcdef);
+  const uint32_t word = (uint32_t)value;
+  uint64_t got[4] = {0, 0, 0, 0};
+  countLeadingRuntime(value, got);
+  const uint64_t sign64 = (uint64_t)((int64_t)value >> 63);
+  const uint32_t sign32 = (uint32_t)((int32_t)word >> 31);
+  const uint64_t want[4] = {clz64(value), clz32(word), clz64(value ^ sign64) - 1, clz32(word ^ sign32) - 1};
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_count_leading", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_crc_complete_test.go b/arm64_lower_crc_complete_test.go
new file mode 100644
index 000000000..55ded5e63
--- /dev/null
+++ b/arm64_lower_crc_complete_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64CRCCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT crcComplete(SB),$0-0\n")
+	for _, op := range []string{"CRC32B", "CRC32H", "CRC32W", "CRC32X", "CRC32CB", "CRC32CH", "CRC32CW", "CRC32CX"} {
+		source.WriteString("\t" + op + " R1, R2\n")
+		source.WriteString("\t" + op + " R3, R4, R5\n")
+		source.WriteString("\t" + op + " ZR, R6, R7\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64CRCCompleteFormats(t *testing.T) {
+	source := arm64CRCCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"crcComplete": {Name: "crcComplete", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, intrinsic := range []string{
+		"llvm.aarch64.crc32b", "llvm.aarch64.crc32h", "llvm.aarch64.crc32w", "llvm.aarch64.crc32x",
+		"llvm.aarch64.crc32cb", "llvm.aarch64.crc32ch", "llvm.aarch64.crc32cw", "llvm.aarch64.crc32cx",
+	} {
+		if !strings.Contains(ll, intrinsic) {
+			t.Fatalf("ARM64 CRC lowering omitted %q:\n%s", intrinsic, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-crc-complete.ll", "arm64-crc-complete.o", ll)
+}
+
+func TestTranslateARM64CRCRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"CRC32B R0",
+		"CRC32H R0, R1, R2, R3",
+		"CRC32W (R0), R1",
+		"CRC32X R0, RSP, R2",
+		"CRC32CB R0<<1, R1, R2",
+		"CRC32CH R0, R1, RSP",
+		"CRC32CW.P R0, R1",
+		"CRC32CX $0, R1, R2",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 CRC optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_cterm.go b/arm64_lower_cterm.go
new file mode 100644
index 000000000..a24e74f63
--- /dev/null
+++ b/arm64_lower_cterm.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64CTERMOps = map[Op]bool{
+	"CTERMEQ":  true,
+	"CTERMEQW": true,
+	"CTERMNE":  true,
+	"CTERMNEW": true,
+}
+
+func (c *arm64Ctx) lowerARM64CTERM(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if !arm64CTERMOps[op] {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg ||
+		!isARM64GeneralOrZeroReg(ins.Args[0].Reg) || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) || ins.Args[0].Reg == SP || ins.Args[0].Reg == Reg("RSP") || ins.Args[1].Reg == SP || ins.Args[1].Reg == Reg("RSP") {
+		return true, false, fmt.Errorf("arm64 %s requires two R0..R30 or ZR operands: %q", op, ins.Raw)
+	}
+	first, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadReg(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	typeName := "i64"
+	if strings.HasSuffix(string(op), "W") {
+		typeName = "i32"
+		first32 := c.newTmp()
+		second32 := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", first32, first)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", second32, second)
+		first = "%" + first32
+		second = "%" + second32
+	}
+	mnemonic := strings.ToLower(strings.TrimSuffix(string(op), "W"))
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, \"r,r\"(%s %s, %s %s)\n", mnemonic+" $0, $1", typeName, first, typeName, second)
+	return true, false, nil
+}
diff --git a/arm64_lower_cterm_test.go b/arm64_lower_cterm_test.go
new file mode 100644
index 000000000..cc4f55713
--- /dev/null
+++ b/arm64_lower_cterm_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64CTERMCompleteGo127Family(t *testing.T) {
+	source := `TEXT ctermforms(SB),$0-0
+	CTERMEQ R3, R4
+	CTERMEQ ZR, R25
+	CTERMEQW R5, ZR
+	CTERMNE R6, R7
+	CTERMNE ZR, ZR
+	CTERMNEW R8, R9
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"ctermforms": {Name: "ctermforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				`asm sideeffect "ctermeq $0, $1"`,
+				`asm sideeffect "ctermne $0, $1"`,
+				"trunc i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s CTERM lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-cterm.ll", "arm64-cterm.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64CTERMRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"CTERMEQ R3",
+		"CTERMEQ R3, R4, R5",
+		"CTERMEQ RSP, R4",
+		"CTERMEQ R3, RSP",
+		"CTERMEQ $1, R4",
+		"CTERMEQ R3, 8(R4)",
+		"CTERMEQ.Z R3, R4",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badcterm(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badcterm": {Name: "badcterm", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's CTERM forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_data.go b/arm64_lower_data.go
index ee8491ec0..5562ec568 100644
--- a/arm64_lower_data.go
+++ b/arm64_lower_data.go
@@ -2,47 +2,44 @@ package plan9asm
 
 import (
 	"fmt"
-	"strings"
 )
 
 func (c *arm64Ctx) lowerData(op Op, postInc bool, ins Instr) (ok bool, terminated bool, err error) {
+	if err := arm64ScalarMoveOperandClassError(op, ins); err != nil {
+		return true, false, err
+	}
+	if ok, terminated, err := c.lowerARM64RegisterAddress(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarMemory(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarMemoryWriteback(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64SymbolScalarMove(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarExtend(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64IntegerPair(op, ins); ok {
+		return ok, terminated, err
+	}
 	switch op {
-	case "MOVKW":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 MOVKW expects $imm16[<<16], dstReg: %q", ins.Raw)
-		}
-		if ins.Args[0].Imm < 0 || uint64(ins.Args[0].Imm) > uint64(^uint32(0)) {
-			return true, false, fmt.Errorf("arm64 MOVKW immediate is outside 32 bits: %q", ins.Raw)
-		}
-		imm := uint32(ins.Args[0].Imm)
-		var keepMask uint32
-		switch {
-		case imm <= 0xffff:
-			keepMask = 0xffff0000
-		case imm&0xffff == 0:
-			keepMask = 0x0000ffff
-		default:
-			return true, false, fmt.Errorf("arm64 MOVKW immediate is not an imm16 or imm16<<16: %q", ins.Raw)
-		}
-		old, err := c.loadReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		old32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", old32, old)
-		kept := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %d\n", kept, old32, keepMask)
-		merged := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %d\n", merged, kept, imm)
-		wide := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, merged)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+wide)
+	case "MOVK", "MOVKW", "MOVN", "MOVNW", "MOVZ", "MOVZW":
+		return true, false, c.lowerARM64MoveWide(op, ins)
 
 	case "MOVD":
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("arm64 MOVD expects 2 operands: %q", ins.Raw)
 		}
 		src, dst := ins.Args[0], ins.Args[1]
+		if src.Kind == OpReg && dst.Kind == OpReg &&
+			(isARM64GeneralOrZeroReg(src.Reg) || src.Reg == SP || src.Reg == "RSP") &&
+			(isARM64GeneralOrZeroReg(dst.Reg) || dst.Reg == SP || dst.Reg == "RSP") {
+			return true, false, c.lowerMachineRegisterCopy(src.Reg, dst.Reg)
+		}
 		v, err := c.eval64(src, postInc)
 		if err != nil {
 			return true, false, err
@@ -51,11 +48,9 @@ func (c *arm64Ctx) lowerData(op Op, postInc bool, ins Instr) (ok bool, terminate
 		case OpReg:
 			return true, false, c.storeReg(dst.Reg, v)
 		case OpMem:
-			return true, false, c.storeMem(dst.Mem, 64, false, v)
+			return true, false, c.storeMem(dst.Mem, 64, postInc, v)
 		case OpFP:
 			return true, false, c.storeFPResult64(dst.FPOffset, v)
-		case OpSym:
-			return true, false, nil
 		default:
 			return true, false, nil
 		}
@@ -70,178 +65,48 @@ func (c *arm64Ctx) lowerData(op Op, postInc bool, ins Instr) (ok bool, terminate
 		signed := op == "MOVB" || op == "MOVH" || op == "MOVW"
 		return true, false, c.lowerNarrowMove(op, ins, bits, signed, postInc)
 
-	case "LDP":
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 2 {
-			return true, false, fmt.Errorf("arm64 LDP expects src, (reg,reg): %q", ins.Raw)
-		}
-		var v0, v1 string
-		if ins.Args[0].Kind == OpMem {
-			mem := ins.Args[0].Mem
-			addr, base, inc, err := c.addrI64(mem, postInc)
-			if err != nil {
-				return true, false, err
-			}
-			p0t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", p0t, addr)
-			v0t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %%%s\n", v0t, p0t)
-			v0 = "%" + v0t
-			addr2t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %s, 8\n", addr2t, addr)
-			p1t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", p1t, addr2t)
-			v1t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %%%s\n", v1t, p1t)
-			v1 = "%" + v1t
-			if err := c.storeReg(ins.Args[1].RegList[0], v0); err != nil {
-				return true, false, err
-			}
-			if err := c.storeReg(ins.Args[1].RegList[1], v1); err != nil {
-				return true, false, err
-			}
-			if err := c.updatePostInc(base, inc); err != nil {
-				return true, false, err
-			}
-			return true, false, nil
-		}
-		if ins.Args[0].Kind == OpFP {
-			val, err := c.eval64(ins.Args[0], false)
-			if err != nil {
-				return true, false, err
-			}
-			if err := c.storeReg(ins.Args[1].RegList[0], val); err != nil {
-				return true, false, err
-			}
-			if err := c.storeReg(ins.Args[1].RegList[1], "0"); err != nil {
-				return true, false, err
-			}
-			return true, false, nil
-		}
-		if ins.Args[0].Kind == OpSym {
-			p, err := c.ptrFromSB(ins.Args[0].Sym)
-			if err != nil {
-				return true, false, err
-			}
-			v0t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", v0t, p)
-			p1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 8\n", p1, p)
-			v1t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %%%s\n", v1t, p1)
-			if err := c.storeReg(ins.Args[1].RegList[0], "%"+v0t); err != nil {
-				return true, false, err
-			}
-			if err := c.storeReg(ins.Args[1].RegList[1], "%"+v1t); err != nil {
-				return true, false, err
-			}
-			return true, false, nil
-		}
-		return true, false, fmt.Errorf("arm64 LDP unsupported src: %q", ins.Raw)
-
-	case "LDPW":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 2 {
-			return true, false, fmt.Errorf("arm64 LDPW expects mem, (reg,reg): %q", ins.Raw)
-		}
-		mem := ins.Args[0].Mem
-		addr, base, inc, err := c.addrI64(mem, postInc)
-		if err != nil {
-			return true, false, err
-		}
-		p0t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", p0t, addr)
-		v0t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %%%s\n", v0t, p0t)
-		z0t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z0t, v0t)
-		addr2t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %s, 4\n", addr2t, addr)
-		p1t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", p1t, addr2t)
-		v1t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %%%s\n", v1t, p1t)
-		z1t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z1t, v1t)
-		if err := c.storeReg(ins.Args[1].RegList[0], "%"+z0t); err != nil {
-			return true, false, err
-		}
-		if err := c.storeReg(ins.Args[1].RegList[1], "%"+z1t); err != nil {
-			return true, false, err
-		}
-		if err := c.updatePostInc(base, inc); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
-
-	case "STPW":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpRegList || len(ins.Args[0].RegList) != 2 || ins.Args[1].Kind != OpMem {
-			return true, false, fmt.Errorf("arm64 STPW expects (reg,reg), mem: %q", ins.Raw)
-		}
-		mem := ins.Args[1].Mem
-		addr, base, inc, err := c.addrI64(mem, postInc)
-		if err != nil {
-			return true, false, err
-		}
-		v0, err := c.loadReg(ins.Args[0].RegList[0])
-		if err != nil {
-			return true, false, err
-		}
-		t0 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t0, v0)
-		p0t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", p0t, addr)
-		fmt.Fprintf(c.b, "  store i32 %%%s, ptr %%%s\n", t0, p0t)
-
-		addr2t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %s, 4\n", addr2t, addr)
-		v1, err := c.loadReg(ins.Args[0].RegList[1])
-		if err != nil {
-			return true, false, err
-		}
-		t1 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t1, v1)
-		p1t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", p1t, addr2t)
-		fmt.Fprintf(c.b, "  store i32 %%%s, ptr %%%s\n", t1, p1t)
-		if err := c.updatePostInc(base, inc); err != nil {
-			return true, false, err
+	case "MOVBW", "MOVHW":
+		bits := 8
+		if op == "MOVHW" {
+			bits = 16
 		}
-		return true, false, nil
+		return true, false, c.lowerSignedNarrowLoadToWord(op, ins, bits, postInc)
+	}
+	return false, false, nil
+}
 
-	case "STP":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpRegList || len(ins.Args[0].RegList) != 2 || ins.Args[1].Kind != OpMem {
-			return true, false, fmt.Errorf("arm64 STP expects (reg,reg), mem: %q", ins.Raw)
-		}
-		mem := ins.Args[1].Mem
-		addr, base, inc, err := c.addrI64(mem, postInc)
-		if err != nil {
-			return true, false, err
-		}
-		v0, err := c.loadReg(ins.Args[0].RegList[0])
-		if err != nil {
-			return true, false, err
-		}
-		p0t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", p0t, addr)
-		fmt.Fprintf(c.b, "  store i64 %s, ptr %%%s\n", v0, p0t)
+func (c *arm64Ctx) lowerARM64MoveWide(op Op, ins Instr) error {
+	form, handled, err := parseARM64NamedMoveWide(op, ins)
+	if err != nil {
+		return err
+	}
+	if !handled {
+		return fmt.Errorf("arm64: unknown move-wide operation %s", op)
+	}
+	return c.lowerRawMoveWide(form)
+}
 
-		addr2t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = add i64 %s, 8\n", addr2t, addr)
-		v1, err := c.loadReg(ins.Args[0].RegList[1])
-		if err != nil {
-			return true, false, err
-		}
-		p1t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", p1t, addr2t)
-		fmt.Fprintf(c.b, "  store i64 %s, ptr %%%s\n", v1, p1t)
-		if err := c.updatePostInc(base, inc); err != nil {
-			return true, false, err
-		}
-		return true, false, nil
+func (c *arm64Ctx) lowerSignedNarrowLoadToWord(op Op, ins Instr, bits int, postInc bool) error {
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return fmt.Errorf("arm64 %s expects memory, C_ZREG: %q", op, ins.Raw)
 	}
-	return false, false, nil
+	value, err := c.loadMem(ins.Args[0].Mem, bits, postInc)
+	if err != nil {
+		return err
+	}
+	narrow := c.newTmp()
+	signed := c.newTmp()
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, value, bits)
+	fmt.Fprintf(c.b, "  %%%s = sext i%d %%%s to i32\n", signed, bits, narrow)
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, signed)
+	return c.storeReg(ins.Args[1].Reg, "%"+wide)
 }
 
 func (c *arm64Ctx) lowerNarrowMove(op Op, ins Instr, bits int, signed, postInc bool) error {
+	if handled, _, err := c.lowerARM64SymbolScalarMove(op, ins); handled {
+		return err
+	}
 	if len(ins.Args) != 2 {
 		return fmt.Errorf("arm64 %s expects 2 operands: %q", op, ins.Raw)
 	}
@@ -251,19 +116,8 @@ func (c *arm64Ctx) lowerNarrowMove(op Op, ins Instr, bits int, signed, postInc b
 	switch src.Kind {
 	case OpMem:
 		value, err = c.loadMem(src.Mem, bits, postInc)
-	case OpSym:
-		if strings.HasPrefix(strings.TrimSpace(src.Sym), "$") {
-			return fmt.Errorf("arm64 %s does not accept an address source: %q", op, ins.Raw)
-		}
-		var ptr string
-		ptr, err = c.ptrFromSB(src.Sym)
-		if err == nil {
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s\n", t, bits, ptr)
-			z := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i64\n", z, bits, t)
-			value = "%" + z
-		}
+	case OpReg:
+		value, err = c.loadRegisterWidth(src.Reg, bits)
 	default:
 		value, err = c.eval64(src, false)
 	}
@@ -280,15 +134,6 @@ func (c *arm64Ctx) lowerNarrowMove(op Op, ins Instr, bits int, signed, postInc b
 		return c.storeReg(dst.Reg, value)
 	case OpMem:
 		return c.storeMem(dst.Mem, bits, postInc, value)
-	case OpSym:
-		ptr, err := c.ptrFromSB(dst.Sym)
-		if err != nil {
-			return err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", t, value, bits)
-		fmt.Fprintf(c.b, "  store i%d %%%s, ptr %s\n", bits, t, ptr)
-		return nil
 	case OpFP:
 		value = c.arm64ExtendNarrow(value, bits, signed)
 		return c.storeFPResult64(dst.FPOffset, value)
diff --git a/arm64_lower_divide_remainder.go b/arm64_lower_divide_remainder.go
new file mode 100644
index 000000000..2420c68d3
--- /dev/null
+++ b/arm64_lower_divide_remainder.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import "fmt"
+
+func (c *arm64Ctx) lowerARM64DivideRemainder(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64DivideRemainderForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	width := 64
+	if form.word {
+		width = 32
+	}
+	divisor, err := c.loadRegisterWidth(form.divisor.Reg, width)
+	if err != nil {
+		return true, false, err
+	}
+	dividend, err := c.loadRegisterWidth(form.dividend.Reg, width)
+	if err != nil {
+		return true, false, err
+	}
+
+	typeName := "i64"
+	minimum := "-9223372036854775808"
+	if form.word {
+		typeName = "i32"
+		minimum = "-2147483648"
+		truncatedDivisor := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncatedDivisor, divisor)
+		divisor = "%" + truncatedDivisor
+		truncatedDividend := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncatedDividend, dividend)
+		dividend = "%" + truncatedDividend
+	}
+
+	isZero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", isZero, typeName, divisor)
+	unsafeDivisor := "%" + isZero
+	if form.signed {
+		isMinimum := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %s\n", isMinimum, typeName, dividend, minimum)
+		isMinusOne := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, -1\n", isMinusOne, typeName, divisor)
+		isOverflow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", isOverflow, isMinimum, isMinusOne)
+		unsafe := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", unsafe, isZero, isOverflow)
+		unsafeDivisor = "%" + unsafe
+	}
+
+	safeDivisor := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s 1, %s %s\n", safeDivisor, unsafeDivisor, typeName, typeName, divisor)
+	computed := c.newTmp()
+	llvmOp := "udiv"
+	if form.signed {
+		llvmOp = "sdiv"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", computed, llvmOp, typeName, dividend, safeDivisor)
+	result := "%" + computed
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s 0, %s %s\n", selected, isZero, typeName, typeName, result)
+	result = "%" + selected
+	if form.word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, result)
+		result = "%" + wide
+	}
+	if !form.remainder {
+		return true, false, c.storeReg(form.destination.Reg, result)
+	}
+	if err := c.storeReg("R27", result); err != nil {
+		return true, false, err
+	}
+	// Go's second machine instruction observes the DIV write when either
+	// source is R27. Capture neither source from its pre-DIV LLVM value.
+	divisor, err = c.loadRegisterWidth(form.divisor.Reg, width)
+	if err != nil {
+		return true, false, err
+	}
+	dividend, err = c.loadRegisterWidth(form.dividend.Reg, width)
+	if err != nil {
+		return true, false, err
+	}
+	if form.word {
+		for _, value := range []*string{&divisor, &dividend, &result} {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, *value)
+			*value = "%" + narrow
+		}
+	}
+	product, difference := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, typeName, result, divisor)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %s, %%%s\n", difference, typeName, dividend, product)
+	result = "%" + difference
+	if form.word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, result)
+		result = "%" + wide
+	}
+	return true, false, c.storeReg(form.destination.Reg, result)
+}
diff --git a/arm64_lower_divide_remainder_test.go b/arm64_lower_divide_remainder_test.go
new file mode 100644
index 000000000..6825fbd27
--- /dev/null
+++ b/arm64_lower_divide_remainder_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64DivideRemainderForms = `
+TEXT divideremainderforms(SB),$0-0
+	SDIV R0, R1
+	SDIV R2, R3, R4
+	SDIVW R5, R6
+	SDIVW R7, R8, R9
+	UDIV R10, R11
+	UDIV R12, R13, R14
+	UDIVW R15, R16
+	UDIVW R17, R19, R20
+	REM R21, R22
+	REM R23, R24, R25
+	REMW R26, R27
+	REMW R10, R11, R12
+	UREM R0, R1
+	UREM R2, R3, R4
+	UREMW R5, R6
+	UREMW R7, R8, ZR
+	RET
+`
+
+func TestTranslateARM64DivideRemainderCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64DivideRemainderForms, true)
+	file, err := Parse(ArchARM64, arm64DivideRemainderForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"divideremainderforms": {Name: "divideremainderforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Go REM lowers to division through R27 and wrapping multiply-
+			// subtract. Architectural srem/urem loses that observable state.
+			for _, want := range []string{"sdiv i64", "sdiv i32", "udiv i64", "udiv i32", "mul i64", "mul i32", "sub i64", "sub i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("divide/remainder family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-divide-remainder.ll", "arm64-divide-remainder.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64DivideRemainderRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"SDIV R0",
+		"SDIV R0, R1, R2, R3",
+		"SDIV $2, R0",
+		"UDIV (R0), R1",
+		"REM R0, RSP",
+		"UREMW.P R0, R1",
+	} {
+		source := "TEXT baddivideremainder(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+			Sigs: map[string]FuncSig{"baddivideremainder": {Name: "baddivideremainder", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's divide/remainder optab", instruction)
+		}
+	}
+}
+
+func TestARM64DivideRemainderRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT divideremainder(SB),$0-16
+	MOVD input+0(FP), R10
+	MOVD output+8(FP), R11
+	MOVD 0(R10), R0
+	MOVD 8(R10), R1
+	MOVD 16(R10), R2
+	MOVD 24(R10), R3
+	MOVD 32(R10), R4
+	MOVD 40(R10), R5
+	MOVD 48(R10), R23
+	SDIV R1, R0, R6
+	SDIVW R1, R0, R7
+	UDIV R3, R2, R8
+	UDIVW R3, R2, R9
+	REM R1, R0, R12
+	REMW R1, R0, R13
+	UREM R3, R2, R14
+	UREMW R3, R2, R15
+	SDIV ZR, R0, R16
+	UDIV ZR, R2, R17
+	REM ZR, R0, R19
+	UREM ZR, R2, R20
+	SDIV R5, R4, R21
+	SDIVW R5, R23, R22
+	MOVD R6, 0(R11)
+	MOVD R7, 8(R11)
+	MOVD R8, 16(R11)
+	MOVD R9, 24(R11)
+	MOVD R12, 32(R11)
+	MOVD R13, 40(R11)
+	MOVD R14, 48(R11)
+	MOVD R15, 56(R11)
+	MOVD R16, 64(R11)
+	MOVD R17, 72(R11)
+	MOVD R19, 80(R11)
+	MOVD R20, 88(R11)
+	MOVD R21, 96(R11)
+	MOVD R22, 104(R11)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"divideremainder": {
+			Name: "divideremainder", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void divideremainder(const uint64_t *, uint64_t *);
+int main(void) {
+  const uint64_t input[7] = {
+    (uint64_t)-9, 2, 9, 2,
+    UINT64_C(0x8000000000000000), UINT64_MAX, UINT64_C(0x80000000)
+  };
+  const uint64_t want[14] = {
+    (uint64_t)-4, UINT32_C(0xfffffffc), 4, 4,
+    UINT64_MAX, UINT32_MAX, 1, 1,
+    0, 0, (uint64_t)-9, 9,
+    UINT64_C(0x8000000000000000), UINT32_C(0x80000000)
+  };
+  uint64_t got[14] = {0};
+  divideremainder(input, got);
+  for (int i = 0; i < 14; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_divide_remainder", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_duplicate.go b/arm64_lower_duplicate.go
new file mode 100644
index 000000000..739cf020f
--- /dev/null
+++ b/arm64_lower_duplicate.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64VectorDuplicate implements all three AVDUP rows in Go's ARM64
+// optab: vector lane to arranged vector, vector lane to scalar V register, and
+// integer register to arranged vector.
+func (c *arm64Ctx) lowerARM64VectorDuplicate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VDUP" {
+		return false, false, nil
+	}
+	form, err := parseARM64VectorTransfer(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	defer c.recordMachineVectorTransfer(form)()
+	if strings.ToUpper(string(ins.Op)) != "VDUP" || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 VDUP expects a vector lane or R/ZR source and a vector destination, with no suffix: %q", ins.Raw)
+	}
+
+	src, dst := ins.Args[0].Reg, ins.Args[1].Reg
+	dstArrangement, arrangedDst := parseARM64VectorArrangement(dst)
+	if arrangedDst && !arm64VDUPArrangementAllowed(dstArrangement) {
+		return true, false, fmt.Errorf("arm64 VDUP destination arrangement is outside Go's optab: %q", ins.Raw)
+	}
+
+	if !form.sourceGP {
+		lane := form.sourceLane
+		if arrangedDst {
+			// Go's case 79 encoder intentionally derives the source element width
+			// from the destination arrangement, not from the source's spelling.
+			// Match that behavior even for accepted mixed-suffix forms.
+			if lane >= 128/dstArrangement.elementBits {
+				return true, false, fmt.Errorf("arm64 VDUP source lane is out of range for destination arrangement: %q", ins.Raw)
+			}
+			element, err := c.arm64VDUPExtractLane(src, dstArrangement.elementBits, lane)
+			if err != nil {
+				return true, false, err
+			}
+			vector := c.arm64VDUPSplat(dstArrangement, element)
+			return true, false, c.storeARM64VectorInteger(dst, dstArrangement, vector)
+		}
+
+		if strings.Contains(string(dst), ".") {
+			return true, false, fmt.Errorf("arm64 VDUP destination arrangement is outside Go's optab: %q", ins.Raw)
+		}
+		if _, valid := arm64ParseVReg(dst); !valid {
+			return true, false, fmt.Errorf("arm64 VDUP lane destination must be a bare V register: %q", ins.Raw)
+		}
+		bits := form.bits
+		element, err := c.arm64VDUPExtractLane(src, bits, lane)
+		if err != nil {
+			return true, false, err
+		}
+		physicalLanes := 128 / bits
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n", inserted, physicalLanes, bits, bits, element)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, physicalLanes, bits, inserted)
+		return true, false, c.storeVReg(dst, "%"+bytes)
+	}
+
+	if !arrangedDst || !isARM64GeneralOrZeroReg(src) {
+		return true, false, fmt.Errorf("arm64 VDUP expects a vector lane or R/ZR source and a valid arranged vector destination: %q", ins.Raw)
+	}
+	return true, false, c.lowerARM64GPVectorDuplicate(src, dst, dstArrangement)
+}
+
+// Go's AVMOV and AVDUP register-to-arranged-vector forms share case 82.
+// Consume exactly one element and clear the inactive upper half for Q=0.
+func (c *arm64Ctx) lowerARM64GPVectorDuplicate(src, dst Reg, arrangement arm64VectorArrangement) error {
+	value, err := c.loadRegisterWidth(src, arrangement.elementBits)
+	if err != nil {
+		return err
+	}
+	if arrangement.elementBits < 64 {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, value, arrangement.elementBits)
+		value = "%" + truncated
+	}
+	vector := c.arm64VDUPSplat(arrangement, value)
+	return c.storeARM64VectorInteger(dst, arrangement, vector)
+}
+
+func arm64VDUPArrangementAllowed(arrangement arm64VectorArrangement) bool {
+	return (arrangement.elementBits == 8 && (arrangement.lanes == 8 || arrangement.lanes == 16)) ||
+		(arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8)) ||
+		(arrangement.elementBits == 32 && (arrangement.lanes == 2 || arrangement.lanes == 4)) ||
+		(arrangement.elementBits == 64 && arrangement.lanes == 2)
+}
+
+func (c *arm64Ctx) arm64VDUPExtractLane(src Reg, bits, lane int) (string, error) {
+	bytes, err := c.loadVReg(src)
+	if err != nil {
+		return "", err
+	}
+	lanes := 128 / bits
+	typed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x i%d>\n", typed, bytes, lanes, bits)
+	element := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %%%s, i32 %d\n", element, lanes, bits, typed, lane)
+	return "%" + element, nil
+}
+
+func (c *arm64Ctx) arm64VDUPSplat(arrangement arm64VectorArrangement, element string) string {
+	seed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> poison, i%d %s, i32 0\n", seed, arrangement.lanes, arrangement.elementBits, arrangement.elementBits, element)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %%%s, <%d x i%d> poison, <%d x i32> zeroinitializer\n",
+		result, arrangement.lanes, arrangement.elementBits, seed, arrangement.lanes, arrangement.elementBits, arrangement.lanes)
+	return "%" + result
+}
diff --git a/arm64_lower_duplicate_test.go b/arm64_lower_duplicate_test.go
new file mode 100644
index 000000000..233585866
--- /dev/null
+++ b/arm64_lower_duplicate_test.go
@@ -0,0 +1,165 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64VectorDuplicateForms = `
+TEXT vectorduplicateforms(SB),$0-0
+	VDUP V0.B[15], V1.B8
+	VDUP V0.B[15], V2.B16
+	VDUP V0.H[7], V3.H4
+	VDUP V0.H[7], V4.H8
+	VDUP V0.S[3], V5.S2
+	VDUP V0.S[3], V6.S4
+	VDUP V0.D[1], V7.D2
+	VDUP V0.B[15], V8
+	VDUP V0.H[7], V9
+	VDUP V0.S[3], V10
+	VDUP V0.D[1], V11
+	VDUP R1, V12.B8
+	VDUP R2, V13.B16
+	VDUP R3, V14.H4
+	VDUP R4, V15.H8
+	VDUP R5, V16.S2
+	VDUP R6, V17.S4
+	VDUP R7, V18.D2
+	// Go's case-79 encoder takes the source width from the arranged
+	// destination, so these mixed source suffixes are intentionally accepted.
+	VDUP V0.B[0], V19.D2
+	VDUP V0.D[1], V20.B16
+	VDUP ZR, V21.S4
+	RET
+`
+
+func TestTranslateARM64VectorDuplicateCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64VectorDuplicateForms, true)
+	file, err := Parse(ArchARM64, arm64VectorDuplicateForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"vectorduplicateforms": {Name: "vectorduplicateforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"extractelement", "shufflevector", "insertelement"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 VDUP lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-duplicate.ll", "arm64-vector-duplicate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorDuplicateRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VDUP V0.B[16], V1.B16",
+		"VDUP V0.B[0], V1.D1",
+		"VDUP V0.S4, V1.S4",
+		"VDUP R1, V2",
+		"VDUP R1, V2.D1",
+		"VDUP R1, V2.S4, V3.S4",
+		"VDUP.P R1, V2.S4",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectorduplicate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorduplicate": {Name: "badvectorduplicate", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VDUP table", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorDuplicateRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorduplicate(SB),$0-8
+	MOVD out+0(FP), R0
+	VMOVQ $0x0706050403020100, $0x0f0e0d0c0b0a0908, V1
+	VDUP V1.B[13], V2.B16
+	VMOV V2.D[0], R1
+	VMOV V2.D[1], R2
+	MOVD R1, 0(R0)
+	MOVD R2, 8(R0)
+	VDUP V1.S[2], V3
+	VMOV V3.D[0], R3
+	VMOV V3.D[1], R4
+	MOVD R3, 16(R0)
+	MOVD R4, 24(R0)
+	MOVD $0x123456789abcdef0, R5
+	VDUP R5, V4.H4
+	VMOV V4.D[0], R6
+	VMOV V4.D[1], R7
+	MOVD R6, 32(R0)
+	MOVD R7, 40(R0)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorduplicate": {
+				Name: "vectorduplicate", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorduplicate(uint64_t *);
+int main(void) {
+  uint64_t got[6] = {0};
+  vectorduplicate(got);
+  if (got[0] != UINT64_C(0x0d0d0d0d0d0d0d0d) || got[1] != UINT64_C(0x0d0d0d0d0d0d0d0d)) return 1;
+  if (got[2] != UINT64_C(0x000000000b0a0908) || got[3] != 0) return 2;
+  if (got[4] != UINT64_C(0xdef0def0def0def0) || got[5] != 0) return 3;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_duplicate", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_exception.go b/arm64_lower_exception.go
new file mode 100644
index 000000000..4d7127820
--- /dev/null
+++ b/arm64_lower_exception.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawException struct {
+	mnemonic  string
+	immediate uint16
+}
+
+func decodeARM64RawException(word uint32) (arm64RawException, bool) {
+	base := word &^ (0xffff << 5)
+	mnemonic := ""
+	switch base {
+	case 0xd4000002:
+		mnemonic = "hvc"
+	case 0xd4000003:
+		mnemonic = "smc"
+	case 0xd4200000:
+		mnemonic = "brk"
+	default:
+		return arm64RawException{}, false
+	}
+	return arm64RawException{mnemonic: mnemonic, immediate: uint16(word >> 5)}, true
+}
+
+func (c *arm64Ctx) emitARM64Exception(mnemonic string, immediate uint16) {
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", fmt.Sprintf("%s #%d", mnemonic, immediate), "~{memory}")
+}
+
+func (c *arm64Ctx) lowerRawException(form arm64RawException) error {
+	c.emitARM64Exception(form.mnemonic, form.immediate)
+	return nil
+}
+
+func (c *arm64Ctx) lowerARM64Exception(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "HLT", "HVC", "SMC", "DCPS1", "DCPS2", "DCPS3":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) > 1 {
+			return true, false, fmt.Errorf("arm64 %s accepts no operand or one constant operand, with no suffix: %q", op, ins.Raw)
+		}
+		var immediate uint16
+		if len(ins.Args) == 1 {
+			if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+				return true, false, fmt.Errorf("arm64 %s operand must be a constant: %q", op, ins.Raw)
+			}
+			immediate = uint16(ins.Args[0].Imm)
+		}
+		mnemonic := strings.ToLower(string(op))
+		c.emitARM64Exception(mnemonic, immediate)
+		if op == "HLT" || strings.HasPrefix(string(op), "DCPS") {
+			c.b.WriteString("  unreachable\n")
+			return true, true, nil
+		}
+		return true, false, nil
+	case "BRK":
+		if strings.ToUpper(string(ins.Op)) != "BRK" || len(ins.Args) > 1 {
+			return true, false, fmt.Errorf("arm64 BRK accepts no operand or one constant operand, with no suffix: %q", ins.Raw)
+		}
+		var immediate uint64
+		if len(ins.Args) == 1 {
+			if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+				return true, false, fmt.Errorf("arm64 BRK operand must be a constant: %q", ins.Raw)
+			}
+			immediate = uint64(ins.Args[0].Imm) & 0xffff
+		}
+		// A debugger or signal handler may resume after BRK, so keep the
+		// following source instructions reachable.
+		c.emitARM64Exception("brk", uint16(immediate))
+		return true, false, nil
+	case "DRPS", "ERET":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 %s takes no operands or suffix: %q", op, ins.Raw)
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", strings.ToLower(string(op)), "~{memory}")
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	case "UNDEF":
+		if strings.ToUpper(string(ins.Op)) != "UNDEF" || len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 UNDEF takes no operands or suffix: %q", ins.Raw)
+		}
+		c.emitARM64Exception("udf", ins.arm64RawUndefinedImmediate)
+		c.b.WriteString("  unreachable\n")
+		return true, true, nil
+	default:
+		return false, false, nil
+	}
+}
diff --git a/arm64_lower_exception_test.go b/arm64_lower_exception_test.go
new file mode 100644
index 000000000..9a1b2df46
--- /dev/null
+++ b/arm64_lower_exception_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+const arm64ExceptionForms = `
+TEXT exceptionforms(SB),$0-0
+	BRK
+	BRK $0
+	BRK $65535
+	BRK $65536
+	BRK $-1
+	RET
+
+TEXT undefinedform(SB),$0-0
+	UNDEF
+`
+
+func TestTranslateARM64ExceptionCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64ExceptionForms, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64ExceptionForms)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"exceptionforms": {Name: "exceptionforms", Ret: Void},
+					"undefinedform":  {Name: "undefinedform", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, `asm sideeffect "brk #0"`); got != 3 {
+				t.Fatalf("ARM64 BRK zero-immediate count = %d, want 3:\n%s", got, ll)
+			}
+			if got := strings.Count(ll, `asm sideeffect "brk #65535"`); got != 2 {
+				t.Fatalf("ARM64 BRK max-immediate count = %d, want 2:\n%s", got, ll)
+			}
+			if !strings.Contains(ll, `asm sideeffect "udf #0"`) || !strings.Contains(ll, "unreachable") {
+				t.Fatalf("ARM64 UNDEF did not lower to a terminating undefined instruction:\n%s", ll)
+			}
+			// BRK is resumable under a debugger, so exceptionforms must retain RET.
+			start := strings.Index(ll, "define void @exceptionforms()")
+			end := strings.Index(ll[start:], "define void @undefinedform()")
+			if start < 0 || end < 0 || !strings.Contains(ll[start:start+end], "ret void") {
+				t.Fatalf("ARM64 BRK incorrectly terminated the resumable function:\n%s", ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-exception.ll", "arm64-exception.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64ExceptionRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"BRK R0",
+		"BRK $1, $2",
+		"BRK.P $1",
+		"UNDEF $0",
+		"UNDEF.P",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's BRK/UNDEF forms", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64PrivilegedExceptionCompleteGoAssemblerForms(t *testing.T) {
+	const source = `TEXT privilegedforms(SB),$0-0
+	HVC
+	HVC $61428
+	SMC
+	SMC $37977
+	RET
+
+TEXT dcps1zero(SB),$0-0
+	DCPS1
+
+TEXT dcps1imm(SB),$0-0
+	DCPS1 $11378
+
+TEXT dcps2zero(SB),$0-0
+	DCPS2
+
+TEXT dcps2imm(SB),$0-0
+	DCPS2 $10699
+
+TEXT dcps3zero(SB),$0-0
+	DCPS3
+
+TEXT dcps3imm(SB),$0-0
+	DCPS3 $24415
+
+TEXT haltzero(SB),$0-0
+	HLT
+
+TEXT haltimm(SB),$0-0
+	HLT $65509
+
+TEXT drpsform(SB),$0-0
+	DRPS
+
+TEXT eretform(SB),$0-0
+	ERET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"privilegedforms": {Name: "privilegedforms", Ret: Void},
+			"dcps1zero":       {Name: "dcps1zero", Ret: Void},
+			"dcps1imm":        {Name: "dcps1imm", Ret: Void},
+			"dcps2zero":       {Name: "dcps2zero", Ret: Void},
+			"dcps2imm":        {Name: "dcps2imm", Ret: Void},
+			"dcps3zero":       {Name: "dcps3zero", Ret: Void},
+			"dcps3imm":        {Name: "dcps3imm", Ret: Void},
+			"haltzero":        {Name: "haltzero", Ret: Void},
+			"haltimm":         {Name: "haltimm", Ret: Void},
+			"drpsform":        {Name: "drpsform", Ret: Void},
+			"eretform":        {Name: "eretform", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`asm sideeffect "hvc #0"`,
+		`asm sideeffect "hvc #61428"`,
+		`asm sideeffect "smc #0"`,
+		`asm sideeffect "smc #37977"`,
+		`asm sideeffect "dcps1 #0"`,
+		`asm sideeffect "dcps1 #11378"`,
+		`asm sideeffect "dcps2 #0"`,
+		`asm sideeffect "dcps2 #10699"`,
+		`asm sideeffect "dcps3 #0"`,
+		`asm sideeffect "dcps3 #24415"`,
+		`asm sideeffect "hlt #0"`,
+		`asm sideeffect "hlt #65509"`,
+		`asm sideeffect "drps"`,
+		`asm sideeffect "eret"`,
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 exception lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-privileged-exception.ll", "arm64-privileged-exception.o", ll)
+}
+
+func TestTranslateARM64RawSMC(t *testing.T) {
+	const source = `TEXT rawsmc(SB),$0-0
+	WORD $0xd4000003
+	UNDEF
+`
+	// This checks encoding/object lowering, not a monitor's machine-state
+	// preservation contract or unprivileged runtime execution.
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"rawsmc": {Name: "rawsmc", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, `asm sideeffect "smc #0"`) {
+		t.Fatalf("ARM64 raw SMC lowering omitted the instruction:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-raw-smc.ll", "arm64-raw-smc.o", ll)
+}
+
+func TestTranslateARM64RawSMCReturnRequiresMonitorContract(t *testing.T) {
+	const source = "TEXT rawsmc(SB),4,$0-0\nWORD $0xd4000003\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"rawsmc": {Name: "rawsmc", Ret: Void}},
+	}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unknown monitor continuation must require context, got %v", err)
+	}
+}
+
+func TestTranslateARM64RejectsUnexpandedExceptionMacros(t *testing.T) {
+	for _, instruction := range []string{
+		"BREAK",
+		"#UNDEF",
+		"SAVE_R19_TO_R28(32)",
+		"RESTORE_R19_TO_R28(32)",
+		"SAVE_F8_TO_F15(112)",
+		"RESTORE_F8_TO_F15(112)",
+		"P256ADDINLINE",
+		"P256MULBY2INLINE",
+		"STY",
+		"MOV",
+	} {
+		file, err := Parse(ArchARM64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate silently accepted unexpanded macro %q", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_exclusive_complete_test.go b/arm64_lower_exclusive_complete_test.go
new file mode 100644
index 000000000..718b028ce
--- /dev/null
+++ b/arm64_lower_exclusive_complete_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64ExclusiveCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT exclusiveComplete(SB),$0-0\n")
+	for _, prefix := range []string{"LDXR", "LDAXR"} {
+		for _, width := range []string{"B", "H", "W", ""} {
+			source.WriteString("\t" + prefix + width + " (R6), R7\n")
+		}
+	}
+	for _, prefix := range []string{"STXR", "STLXR"} {
+		for _, width := range []string{"B", "H", "W", ""} {
+			source.WriteString("\t" + prefix + width + " R5, (R6), R7\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64ExclusiveCompleteFormats(t *testing.T) {
+	source := arm64ExclusiveCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"exclusiveComplete": {Name: "exclusiveComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"load atomic i8", "load atomic i16", "load atomic i32", "load atomic i64",
+		" monotonic", " acquire", "cmpxchg ptr", " release monotonic",
+		"store i1 true, ptr %exclusive_valid", "store i1 false, ptr %exclusive_valid",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 exclusive lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-exclusive-complete.ll", "arm64-exclusive-complete.o", ll)
+}
+
+func TestTranslateARM64ExclusiveRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"LDXR 8(R1), R2", "STXRH R0, (R1)", "LDXRQ (R1), R2"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 exclusive optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_extend.go b/arm64_lower_extend.go
new file mode 100644
index 000000000..7dc3e38bb
--- /dev/null
+++ b/arm64_lower_extend.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import "fmt"
+
+type arm64ScalarExtendSpec struct {
+	sourceBits      int
+	signed          bool
+	wordDestination bool
+}
+
+var arm64ScalarExtendSpecs = map[Op]arm64ScalarExtendSpec{
+	"SXTB":  {sourceBits: 8, signed: true},
+	"SXTBW": {sourceBits: 8, signed: true, wordDestination: true},
+	"SXTH":  {sourceBits: 16, signed: true},
+	"SXTHW": {sourceBits: 16, signed: true, wordDestination: true},
+	"SXTW":  {sourceBits: 32, signed: true},
+	"UXTB":  {sourceBits: 8},
+	"UXTBW": {sourceBits: 8, wordDestination: true},
+	"UXTH":  {sourceBits: 16},
+	"UXTHW": {sourceBits: 16, wordDestination: true},
+	"UXTW":  {sourceBits: 32},
+}
+
+func (c *arm64Ctx) lowerARM64ScalarExtend(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64ScalarExtendSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if _, _, err := parseARM64GPDataForm(op, ins); err != nil {
+		return true, false, err
+	}
+	source, err := c.loadRegisterWidth(ins.Args[0].Reg, spec.sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, source, spec.sourceBits)
+	destinationBits := 64
+	if spec.wordDestination {
+		destinationBits = 32
+	}
+	extended := c.newTmp()
+	extension := "zext"
+	if spec.signed {
+		extension = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s i%d %%%s to i%d\n", extended, extension, spec.sourceBits, narrow, destinationBits)
+	value := "%" + extended
+	if spec.wordDestination {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, value)
+		value = "%" + wide
+	}
+	return true, false, c.storeReg(ins.Args[1].Reg, value)
+}
diff --git a/arm64_lower_extend_test.go b/arm64_lower_extend_test.go
new file mode 100644
index 000000000..4f0bbc131
--- /dev/null
+++ b/arm64_lower_extend_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64ScalarExtendCompleteGoAssemblerForms(t *testing.T) {
+	src := `TEXT ·scalarExtendForms(SB), $0-0
+	SXTB R0, R1
+	SXTBW R0, R1
+	SXTH R0, R1
+	SXTHW R0, R1
+	SXTW R0, R1
+	UXTB R0, R1
+	UXTBW R0, R1
+	UXTH R0, R1
+	UXTHW R0, R1
+	UXTW R0, R1
+	RET
+`
+	requireARM64GoAssemblerResult(t, src, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"scalarExtendForms": {Name: "scalarExtendForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-scalar-extend.ll", "arm64-scalar-extend.o", ll)
+	}
+}
+
+func TestTranslateARM64ScalarExtendRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"SXTH $1, R1",
+		"SXTH R0, 0(R1)",
+		"SXTH 0(R0), R1",
+		"SXTWW R0, R1",
+		"UXTWW R0, R1",
+		"SXTB.P R0, R1",
+		"UXTB F0, R1",
+		"SXTH R0, F1",
+		"UXTW RSP, R1",
+		"SXTW R0, RSP",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT ·badScalarExtend(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, src, false)
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badScalarExtend": {Name: "badScalarExtend", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar extend optab", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_extract.go b/arm64_lower_extract.go
new file mode 100644
index 000000000..b4eff9f35
--- /dev/null
+++ b/arm64_lower_extract.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorExtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VEXT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != "VEXT" || len(ins.Args) != 4 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 VEXT expects $offset, Vm.B8/B16, Vn.B8/B16, Vd.B8/B16: %q", ins.Raw)
+	}
+
+	var arrangement arm64VectorArrangement
+	for index, operand := range ins.Args[1:] {
+		if operand.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 VEXT accepts only arranged vector registers: %q", ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(operand.Reg)
+		if !valid || parsed.elementBits != 8 || parsed.lanes != 8 && parsed.lanes != 16 {
+			return true, false, fmt.Errorf("arm64 VEXT arrangement must be B8 or B16: %q", ins.Raw)
+		}
+		if index == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 VEXT arrangements must match: %q", ins.Raw)
+		}
+	}
+	offset := int(ins.Args[0].Imm)
+	if offset < 0 || offset >= arrangement.lanes {
+		return true, false, fmt.Errorf("arm64 VEXT offset must be in [0,%d): %q", arrangement.lanes, ins.Raw)
+	}
+
+	// Go's Plan 9 order is $offset, Vm, Vn, Vd. EXT concatenates Vn:Vm
+	// and selects one vector starting at the byte offset.
+	m, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	n, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  ; arm64 vector extract\n")
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> <", result, arrangement.lanes, n, arrangement.lanes, m, arrangement.lanes)
+	for lane := 0; lane < arrangement.lanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", offset+lane)
+	}
+	c.b.WriteString(">\n")
+	return true, false, c.storeARM64VectorInteger(ins.Args[3].Reg, arrangement, "%"+result)
+}
diff --git a/arm64_lower_extract_general_test.go b/arm64_lower_extract_general_test.go
new file mode 100644
index 000000000..406f921ba
--- /dev/null
+++ b/arm64_lower_extract_general_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64GeneralExtractCompleteFormats(t *testing.T) {
+	const source = `TEXT extractComplete(SB),$0-0
+	EXTR $0, R1, R2, R3
+	EXTR $63, R4, R5, R6
+	EXTR $17, ZR, R7, R8
+	EXTRW $0, R9, R10, R11
+	EXTRW $31, R12, R13, R14
+	EXTRW $7, R15, ZR, ZR
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"extractComplete": {Name: "extractComplete", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"lshr i64", "shl i64", "or i64", "lshr i32", "shl i32", "or i32", "zext i32"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 EXTR lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-extract-complete.ll", "arm64-extract-complete.o", ll)
+}
+
+func TestTranslateARM64GeneralExtractRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"EXTR R0, R1, R2, R3",
+		"EXTR $64, R1, R2, R3",
+		"EXTR $1, RSP, R2, R3",
+		"EXTR $1, R1, R2, RSP",
+		"EXTR.P $1, R1, R2, R3",
+		"EXTRW $32, R1, R2, R3",
+		"EXTRW $1, (R1), R2, R3",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 EXTR optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_extract_test.go b/arm64_lower_extract_test.go
new file mode 100644
index 000000000..ee4c5970b
--- /dev/null
+++ b/arm64_lower_extract_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorExtractCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT vectorextractforms(SB),$0-0\n")
+	for _, form := range []struct {
+		arrangement string
+		maximum     int
+	}{
+		{arrangement: "B8", maximum: 7},
+		{arrangement: "B16", maximum: 15},
+	} {
+		for _, immediate := range []int{0, 1, form.maximum} {
+			fmt.Fprintf(&source, "\tVEXT $%d, V30.%s, V31.%s, V29.%s\n", immediate, form.arrangement, form.arrangement, form.arrangement)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"vectorextractforms": {Name: "vectorextractforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "shufflevector") {
+				t.Fatalf("ARM64 VEXT lowering for %s omitted shuffle semantics:\n%s", triple, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-extract.ll", "arm64-vector-extract.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorExtractRejectsInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VEXT $8, V0.B8, V1.B8, V2.B8",
+		"VEXT $16, V0.B16, V1.B16, V2.B16",
+		"VEXT $-1, V0.B16, V1.B16, V2.B16",
+		"VEXT $4, V0.B8, V1.B16, V2.B16",
+		"VEXT $4, V0.H8, V1.H8, V2.H8",
+		"VEXT V0.B16, V1.B16, V2.B16",
+		"VEXT.P $4, V0.B16, V1.B16, V2.B16",
+	} {
+		source := "TEXT badvectorextract(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"badvectorextract": {Name: "badvectorextract", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted invalid VEXT form %q", instruction)
+		}
+	}
+}
+
+func TestARM64VectorExtractRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorextract(SB),$0-24
+	MOVD left+0(FP), R0
+	MOVD right+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VEXT $5, V1.B16, V0.B16, V2.B16
+	VST1.P [V2.B16], 16(R2)
+	VEXT $3, V1.B8, V0.B8, V3.B8
+	VST1 [V3.B16], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"vectorextract": {
+			Name: "vectorextract", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorextract(const uint8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  uint8_t left[16], right[16], got[32];
+  for (int i = 0; i < 16; i++) { left[i] = (uint8_t)i; right[i] = (uint8_t)(16+i); got[i] = got[16+i] = 0xff; }
+  vectorextract(left, right, got);
+  for (int i = 0; i < 16; i++) if (got[i] != (uint8_t)(i+5)) return i+1;
+	for (int i = 0; i < 8; i++) {
+	  int lane = i + 3;
+	  uint8_t want = lane < 8 ? left[lane] : right[lane-8];
+	  if (got[16+i] != want) return i+21;
+	}
+  for (int i = 8; i < 16; i++) if (got[16+i] != 0) return i+41;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_extract", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_float_binary.go b/arm64_lower_float_binary.go
new file mode 100644
index 000000000..8ec3de7a7
--- /dev/null
+++ b/arm64_lower_float_binary.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func arm64ScalarFloatBinaryKind(op Op) (kind string, bits int, ok bool) {
+	bits = 32
+	if strings.HasSuffix(string(op), "D") {
+		bits = 64
+	}
+	switch op {
+	case "FMAXS", "FMAXD":
+		return "maximum", bits, true
+	case "FMINS", "FMIND":
+		return "minimum", bits, true
+	case "FMAXNMS", "FMAXNMD":
+		return "maxnum", bits, true
+	case "FMINNMS", "FMINNMD":
+		return "minnum", bits, true
+	default:
+		return "", 0, false
+	}
+}
+
+func (c *arm64Ctx) loadARM64ScalarFloatReg(reg Reg, bits int) (string, error) {
+	encoded, err := c.loadRegisterWidth(reg, bits)
+	if err != nil {
+		return "", err
+	}
+	switch bits {
+	case 64:
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", value, encoded)
+		return "%" + value, nil
+	case 32:
+		narrow := c.newTmp()
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, encoded)
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", value, narrow)
+		return "%" + value, nil
+	case 16:
+		narrow := c.newTmp()
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i16\n", narrow, encoded)
+		fmt.Fprintf(c.b, "  %%%s = bitcast i16 %%%s to half\n", value, narrow)
+		return "%" + value, nil
+	default:
+		return "", fmt.Errorf("arm64 unsupported scalar float width %d", bits)
+	}
+}
+
+func (c *arm64Ctx) storeARM64ScalarFloatReg(reg Reg, bits int, value string) error {
+	switch bits {
+	case 64:
+		encoded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", encoded, value)
+		return c.storeReg(reg, "%"+encoded)
+	case 32:
+		encoded := c.newTmp()
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", encoded, value)
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, encoded)
+		return c.storeReg(reg, "%"+wide)
+	case 16:
+		encoded := c.newTmp()
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast half %s to i16\n", encoded, value)
+		fmt.Fprintf(c.b, "  %%%s = zext i16 %%%s to i64\n", wide, encoded)
+		return c.storeReg(reg, "%"+wide)
+	default:
+		return fmt.Errorf("arm64 unsupported scalar float width %d", bits)
+	}
+}
+
+func (c *arm64Ctx) lowerARM64ScalarFloatBinary(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if form, known, err := parseARM64ScalarBinary(op, ins); known {
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64ScalarBinary(form)
+	}
+	if form, matched, err := parseARM64ScalarMinMax(op, ins); matched {
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64ScalarMinMax(form)
+	}
+	kind, bits, handled := arm64ScalarFloatBinaryKind(op)
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 2 && len(ins.Args) != 3) {
+		return true, false, fmt.Errorf("arm64 %s expects Fsrc,Fdst or Fsrc1,Fsrc2,Fdst and no suffix: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg || !isARM64FReg(arg.Reg) {
+			return true, false, fmt.Errorf("arm64 %s accepts only F registers: %q", op, ins.Raw)
+		}
+	}
+	rhs, err := c.loadARM64ScalarFloatReg(ins.Args[0].Reg, bits)
+	if err != nil {
+		return true, false, err
+	}
+	lhs, err := c.loadARM64ScalarFloatReg(ins.Args[1].Reg, bits)
+	if err != nil {
+		return true, false, err
+	}
+	dst := ins.Args[len(ins.Args)-1].Reg
+	return true, false, c.lowerARM64ScalarFloatBinaryValues(kind, bits, lhs, rhs, dst)
+}
+
+func (c *arm64Ctx) lowerARM64ScalarFloatBinaryValues(
+	kind string,
+	bits int,
+	lhs string,
+	rhs string,
+	destination Reg,
+) error {
+	floatType, suffix, ok := arm64ScalarFloatType(bits)
+	if !ok {
+		return fmt.Errorf("arm64 unsupported scalar float width %d", bits)
+	}
+	result := c.newTmp()
+	switch kind {
+	case "fabd", "fmulx":
+		family := "neon"
+		if kind == "fabd" {
+			family = "sisd"
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.%s.%s.%s(%s %s, %s %s)\n",
+			result, floatType, family, kind, suffix, floatType, lhs, floatType, rhs)
+	default:
+		return fmt.Errorf("arm64 scalar binary kind %q requires its typed native form", kind)
+	}
+	return c.storeARM64ScalarFloatReg(destination, bits, "%"+result)
+}
diff --git a/arm64_lower_float_compare.go b/arm64_lower_float_compare.go
new file mode 100644
index 000000000..037d3a51c
--- /dev/null
+++ b/arm64_lower_float_compare.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func arm64FloatComparePredicate(op Op) (string, bool) {
+	predicates := map[Op]string{
+		"VFCMEQ": "oeq",
+		"VFCMGE": "oge",
+		"VFCMGT": "ogt",
+		"VFCMLE": "ole",
+		"VFCMLT": "olt",
+		"VFACGE": "oge",
+		"VFACGT": "ogt",
+	}
+	predicate, ok := predicates[op]
+	return predicate, ok
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VFCMEQ" && op != "VFCMGE" && op != "VFCMGT" && op != "VFCMLE" && op != "VFCMLT" {
+		return false, false, nil
+	}
+	predicate, _ := arm64FloatComparePredicate(op)
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects register compare or $(0.0) compare form and no suffix: %q", op, ins.Raw)
+	}
+
+	zeroForm := ins.Args[0].Kind == OpImm
+	if zeroForm {
+		if ins.Args[0].Imm != 0 || ins.Args[0].ImmRaw != "" || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s immediate compare requires exactly $(0.0), Vsrc.<T>, Vdst.<T>: %q", op, ins.Raw)
+		}
+	} else {
+		if op == "VFCMLE" || op == "VFCMLT" || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s register compare form is absent from Go 1.27's optab: %q", op, ins.Raw)
+		}
+	}
+
+	sourceIndex := 1
+	if !zeroForm {
+		sourceIndex = 0
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[sourceIndex].Reg)
+	if !valid || !((arrangement.elementBits == 32 && (arrangement.lanes == 2 || arrangement.lanes == 4)) ||
+		(arrangement.elementBits == 64 && arrangement.lanes == 2)) {
+		return true, false, fmt.Errorf("arm64 %s accepts only S2, S4, or D2 arrangements: %q", op, ins.Raw)
+	}
+	start := 1
+	if !zeroForm {
+		start = 0
+	}
+	for i := start; i < len(ins.Args); i++ {
+		parsed, ok := parseARM64VectorArrangement(ins.Args[i].Reg)
+		if !ok || parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	return true, false, c.lowerARM64VectorFloatCompareValues(
+		predicate,
+		false,
+		arrangement,
+		ins.Args[1].Reg,
+		ins.Args[0].Reg,
+		zeroForm,
+		ins.Args[2].Reg,
+	)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatCompareValues(
+	predicate string,
+	absolute bool,
+	arrangement arm64VectorArrangement,
+	leftReg Reg,
+	rightReg Reg,
+	zero bool,
+	destination Reg,
+) error {
+	left, err := c.loadARM64VectorFloat(leftReg, arrangement)
+	if err != nil {
+		return err
+	}
+	right := "zeroinitializer"
+	if !zero {
+		right, err = c.loadARM64VectorFloat(rightReg, arrangement)
+		if err != nil {
+			return err
+		}
+	}
+	floatType := arm64RawFloatType(arrangement.elementBits)
+	vectorType := fmt.Sprintf("<%d x %s>", arrangement.lanes, floatType)
+	if absolute {
+		leftAbs := c.newTmp()
+		rightAbs := c.newTmp()
+		intrinsic := fmt.Sprintf("@llvm.fabs.v%df%d", arrangement.lanes, arrangement.elementBits)
+		fmt.Fprintf(c.b, "  %%%s = call %s %s(%s %s)\n", leftAbs, vectorType, intrinsic, vectorType, left)
+		fmt.Fprintf(c.b, "  %%%s = call %s %s(%s %s)\n", rightAbs, vectorType, intrinsic, vectorType, right)
+		left = "%" + leftAbs
+		right = "%" + rightAbs
+	}
+	compared := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fcmp %s %s %s, %s\n", compared, predicate, vectorType, left, right)
+	allBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %%%s to <%d x i%d>\n", allBits, arrangement.lanes, compared, arrangement.lanes, arrangement.elementBits)
+	return c.storeARM64VectorInteger(destination, arrangement, "%"+allBits)
+}
diff --git a/arm64_lower_float_conditional_compare.go b/arm64_lower_float_conditional_compare.go
new file mode 100644
index 000000000..2b5174b31
--- /dev/null
+++ b/arm64_lower_float_conditional_compare.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ConditionalCompareForm struct {
+	arm64ScalarCompareForm
+	condition string
+	nzcv      uint8
+}
+
+// Go asm7 case 57 inherits one C_COND,FREG,FREG,VCON row across four
+// names. Half precision belongs only to the independently decoded WORD role.
+var arm64ConditionalCompareOps = map[Op]arm64ScalarCompareForm{
+	"FCCMPS":  {bits: 32},
+	"FCCMPD":  {bits: 64},
+	"FCCMPES": {bits: 32, signaling: true},
+	"FCCMPED": {bits: 64, signaling: true},
+}
+
+func parseARM64ConditionalCompare(op Op, ins Instr) (arm64ConditionalCompareForm, bool, error) {
+	scalar, known := arm64ConditionalCompareOps[op]
+	if !known {
+		return arm64ConditionalCompareForm{}, false, nil
+	}
+	invalid := func() (arm64ConditionalCompareForm, bool, error) {
+		return arm64ConditionalCompareForm{}, true, fmt.Errorf("arm64 %s expects condition, Fsrc, Fdst, $NZCV(0..15) and no suffix: %q", op, ins.Raw)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return invalid()
+	}
+	condition, valid := arm64FloatConditionalCompareCondition(ins.Args[0])
+	if !valid || ins.Args[1].Kind != OpReg || !isARM64FReg(ins.Args[1].Reg) ||
+		ins.Args[2].Kind != OpReg || !isARM64FReg(ins.Args[2].Reg) ||
+		ins.Args[3].Kind != OpImm || ins.Args[3].ImmRaw != "" || ins.Args[3].ImmIsFloat ||
+		ins.Args[3].Imm < 0 || ins.Args[3].Imm > 15 {
+		return invalid()
+	}
+	if _, err := arm64ConditionFlags(condition); err != nil {
+		return invalid()
+	}
+	scalar.left, scalar.right = ins.Args[2].Reg, ins.Args[1].Reg
+	return arm64ConditionalCompareForm{scalar, condition, uint8(ins.Args[3].Imm)}, true, nil
+}
+
+func (c *arm64Ctx) lowerARM64FloatConditionalCompare(op Op, ins Instr) (bool, bool, error) {
+	form, known, err := parseARM64ConditionalCompare(op, ins)
+	if !known || err != nil {
+		return known, false, err
+	}
+	return true, false, c.lowerARM64ConditionalCompare(form)
+}
+
+func (c *arm64Ctx) lowerARM64ConditionalCompare(form arm64ConditionalCompareForm) error {
+	if err := requireARM64ScalarCompareTarget("arm64", c.targetTriple); err != nil {
+		return err
+	}
+	// Consume only the source-defined condition bits. Never borrow entry NZCV.
+	predicate, err := c.condValue(form.condition)
+	if err != nil {
+		return err
+	}
+	left, err := c.loadARM64ScalarFloatReg(form.left, form.bits)
+	if err != nil {
+		return err
+	}
+	right, err := c.loadARM64ScalarFloatReg(form.right, form.bits)
+	if err != nil {
+		return err
+	}
+	typeName, _, valid := arm64ScalarFloatType(form.bits)
+	if !valid {
+		return fmt.Errorf("arm64 unsupported conditional float width %d", form.bits)
+	}
+	modifier := map[int]string{16: "h", 32: "s", 64: "d"}[form.bits]
+	opcode := "fccmp"
+	if form.signaling {
+		opcode = "fccmpe"
+	}
+	condition, flags := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i32\n", condition, predicate)
+	// DDI0602: the condition gates FPCompare itself, including FPCR/FPSR and
+	// exception delivery. A pure fcmp followed by select is not equivalent.
+	// Seed a private native NE predicate from the proved virtual condition and
+	// capture the resulting NZCV in this indivisible block. No SIMD bytes change.
+	assembly := fmt.Sprintf("cmp ${3:w}, #0\\0A%s ${1:%s}, ${2:%s}, #%d, ne\\0Amrs $0, nzcv", opcode, modifier, modifier, form.nzcv)
+	c.emitMachineNeutralNativeIR("  %%%s = call i64 asm sideeffect \"%s\", \"=r,w,w,r,~{cc},~{memory}\"(%s %s, %s %s, i32 %%%s)\n", flags, assembly, typeName, left, typeName, right, condition)
+	c.storeARM64NativeCompareFlags("%" + flags)
+	return nil
+}
+
+func arm64FloatConditionalCompareCondition(operand Operand) (string, bool) {
+	if operand.Kind == OpIdent {
+		return operand.Ident, true
+	}
+	// AL is also an x86 byte-register spelling in the shared source parser.
+	if operand.Kind == OpReg && strings.EqualFold(string(operand.Reg), "AL") {
+		return "AL", true
+	}
+	return "", false
+}
diff --git a/arm64_lower_float_conditional_compare_test.go b/arm64_lower_float_conditional_compare_test.go
new file mode 100644
index 000000000..5e1024e44
--- /dev/null
+++ b/arm64_lower_float_conditional_compare_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64FloatConditionalCompareCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT floatConditionalCompareForms(SB), $0-0
+	CMP R0, R0
+	FCCMPS LE, F17, F12, $14
+	FCCMPD HI, F11, F15, $15
+	FCCMPES EQ, F1, F2, $0
+	FCCMPED NE, F3, F4, $9
+	FCCMPS AL, F31, F5, $5
+	FCCMPD AL, F0, F9, $0
+	FCCMPES AL, F7, F14, $1
+	FCCMPED AL, F0, F14, $11
+	FCCMPS NV, F6, F8, $3
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"floatConditionalCompareForms": {Name: "floatConditionalCompareForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fccmp ${1:s}", "fccmpe ${1:s}", "fccmp ${1:d}", "fccmpe ${1:d}", "asm sideeffect"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("floating conditional compare lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-float-conditional-compare.ll", "arm64-float-conditional-compare.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64FloatConditionalCompareRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"FCCMPD EQ, F0, F1",
+		"FCCMPD BAD, F0, F1, $0",
+		"FCCMPD EQ, R0, F1, $0",
+		"FCCMPD EQ, F0, R1, $0",
+		"FCCMPD EQ, F0, F1, $16",
+		"FCCMPD EQ, F0, F1, R0",
+		"FCCMPD.P EQ, F0, F1, $0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badFloatConditionalCompare(SB), $0-0\n\tCMP R0, R0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badFloatConditionalCompare": {Name: "badFloatConditionalCompare", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's FCCMP optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64FloatConditionalCompareRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT floatConditionalCompareRuntime(SB), $0-24
+	FMOVD a+0(FP), F0
+	FMOVD b+8(FP), F1
+	MOVD out+16(FP), R2
+	CMP R0, R0
+	FCCMPD EQ, F0, F1, $0
+	CSET MI, R3
+	MOVD R3, 0(R2)
+	CSET EQ, R3
+	MOVD R3, 8(R2)
+	CSET CS, R3
+	MOVD R3, 16(R2)
+	CSET VS, R3
+	MOVD R3, 24(R2)
+	CMP R0, R0
+	FCCMPED NE, F0, F1, $10
+	CSET MI, R3
+	MOVD R3, 32(R2)
+	CSET EQ, R3
+	MOVD R3, 40(R2)
+	CSET CS, R3
+	MOVD R3, 48(R2)
+	CSET VS, R3
+	MOVD R3, 56(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"floatConditionalCompareRuntime": {
+				Name: "floatConditionalCompareRuntime", Args: []LLVMType{"double", "double", Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: "double", Index: 0, Field: -1},
+					{Offset: 8, Type: "double", Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void floatConditionalCompareRuntime(double, double, uint64_t *);
+int main(void) {
+  uint64_t got[8] = {0};
+  floatConditionalCompareRuntime(2.0, 1.0, got);
+  const uint64_t want[8] = {1, 0, 0, 0, 1, 0, 1, 0};
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_float_conditional_compare", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_float_minmax_across.go b/arm64_lower_float_minmax_across.go
new file mode 100644
index 000000000..810fc6b23
--- /dev/null
+++ b/arm64_lower_float_minmax_across.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64VectorFloatMinMaxAcrossOps = map[Op]string{
+	"VFMAXV":   "maximum",
+	"VFMINV":   "minimum",
+	"VFMAXNMV": "maxnum",
+	"VFMINNMV": "minnum",
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatMinMaxAcross(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	operation, handled := arm64VectorFloatMinMaxAcrossOps[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects Vsrc.S4, Vdst and no suffix: %q", op, ins.Raw)
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationIndex, destinationValid := arm64ParseVReg(ins.Args[1].Reg)
+	if !valid || arrangement != (arm64VectorArrangement{elementBits: 32, lanes: 4}) ||
+		!destinationValid || strings.Contains(string(ins.Args[1].Reg), ".") {
+		return true, false, fmt.Errorf("arm64 %s requires an S4 source and bare V destination: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64FloatMinMaxAcrossValues(
+		operation,
+		arrangement,
+		ins.Args[0].Reg,
+		Reg(fmt.Sprintf("F%d", destinationIndex)),
+	)
+}
+
+func (c *arm64Ctx) lowerARM64FloatMinMaxAcrossValues(
+	operation string,
+	arrangement arm64VectorArrangement,
+	sourceReg Reg,
+	destination Reg,
+) error {
+	source, err := c.loadARM64VectorFloat(sourceReg, arrangement)
+	if err != nil {
+		return err
+	}
+	floatType := arm64RawFloatType(arrangement.elementBits)
+	first := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 0\n", first, arrangement.lanes, floatType, source)
+	result := "%" + first
+	for lane := 1; lane < arrangement.lanes; lane++ {
+		element := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", element, arrangement.lanes, floatType, source, lane)
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.f%d(%s %s, %s %%%s)\n",
+			combined, floatType, operation, arrangement.elementBits, floatType, result, floatType, element)
+		result = "%" + combined
+	}
+	return c.storeARM64ScalarFloatReg(destination, arrangement.elementBits, result)
+}
diff --git a/arm64_lower_float_minmax_across_test.go b/arm64_lower_float_minmax_across_test.go
new file mode 100644
index 000000000..77dd55ee3
--- /dev/null
+++ b/arm64_lower_float_minmax_across_test.go
@@ -0,0 +1,295 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawFloatMinMaxAcrossEncodingTest struct {
+	base      uint32
+	operation string
+	bits      int
+	lanes     int
+}
+
+var arm64RawFloatMinMaxAcrossEncodingTests = []arm64RawFloatMinMaxAcrossEncodingTest{
+	{0x0e30c800, "maxnum", 16, 4},
+	{0x4e30c800, "maxnum", 16, 8},
+	{0x6e30c800, "maxnum", 32, 4},
+	{0x0eb0c800, "minnum", 16, 4},
+	{0x4eb0c800, "minnum", 16, 8},
+	{0x6eb0c800, "minnum", 32, 4},
+	{0x0e30f800, "maximum", 16, 4},
+	{0x4e30f800, "maximum", 16, 8},
+	{0x6e30f800, "maximum", 32, 4},
+	{0x0eb0f800, "minimum", 16, 4},
+	{0x4eb0f800, "minimum", 16, 8},
+	{0x6eb0f800, "minimum", 32, 4},
+}
+
+func TestARM64RawFloatMinMaxAcrossDecoderCompleteArchitectureFamily(t *testing.T) {
+	count := 0
+	for _, encoding := range arm64RawFloatMinMaxAcrossEncodingTests {
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 32; destination++ {
+				word := encoding.base | uint32(source)<<5 | uint32(destination)
+				form, ok := decodeARM64RawFloatMinMaxAcross(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				if form.operation != encoding.operation ||
+					form.arrangement != (arm64VectorArrangement{elementBits: encoding.bits, lanes: encoding.lanes}) ||
+					form.source != source || form.destination != destination {
+					t.Fatalf("decode %#08x = %+v", word, form)
+				}
+				count++
+			}
+		}
+	}
+	if count != 12288 {
+		t.Fatalf("covered %d floating min/max-across encodings, want 12288", count)
+	}
+}
+
+func TestTranslateARM64RawFloatMinMaxAcrossCompleteArchitectureFamily(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatminmaxacrossarchitecturefamily(SB),$0-0\n")
+	for _, encoding := range arm64RawFloatMinMaxAcrossEncodingTests {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encoding.base|2<<5|1)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawfloatminmaxacrossarchitecturefamily": {Name: "rawfloatminmaxacrossarchitecturefamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"@llvm.maximum.f16", "@llvm.minimum.f16", "@llvm.maxnum.f16", "@llvm.minnum.f16",
+				"@llvm.maximum.f32", "@llvm.minimum.f32", "@llvm.maxnum.f32", "@llvm.minnum.f32",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw float min/max-across IR omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-minmax-across.ll", "arm64-raw-float-minmax-across.o", ir)
+		})
+	}
+}
+
+const arm64VectorFloatMinMaxAcrossForms = `
+TEXT vectorfloatminmaxacrossforms(SB),$0-0
+	VFMAXV V0.S4, V1
+	VFMINV V2.S4, V3
+	VFMAXNMV V4.S4, V5
+	VFMINNMV V6.S4, V7
+	RET
+`
+
+func TestTranslateARM64VectorFloatMinMaxAcrossCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64VectorFloatMinMaxAcrossForms, true)
+	file, err := Parse(ArchARM64, arm64VectorFloatMinMaxAcrossForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectorfloatminmaxacrossforms": {Name: "vectorfloatminmaxacrossforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{"@llvm.maximum.f32", "@llvm.minimum.f32", "@llvm.maxnum.f32", "@llvm.minnum.f32"} {
+				if !strings.Contains(ir, intrinsic) {
+					t.Fatalf("ARM64 float min/max-across omitted %s:\n%s", intrinsic, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-float-minmax-across.ll", "arm64-vector-float-minmax-across.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64VectorFloatMinMaxAcrossRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VFMAXV V0.S2, V1",
+		"VFMINV V0.D2, V1",
+		"VFMAXNMV V0.H8, V1",
+		"VFMINNMV V0.S4, V1.D2",
+		"VFMAXV V0.S4",
+		"VFMINV.P V0.S4, V1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectorfloatminmaxacross(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+				Sigs: map[string]FuncSig{"badvectorfloatminmaxacross": {Name: "badvectorfloatminmaxacross", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's float min/max-across forms", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorFloatMinMaxAcrossRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorfloatminmaxacross(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	VFMAXV V0.S4, V1
+	VFMINV V0.S4, V2
+	VFMAXNMV V0.S4, V3
+	VFMINNMV V0.S4, V4
+	FMOVS F1, 0(R1)
+	FMOVS F2, 4(R1)
+	FMOVS F3, 8(R1)
+	FMOVS F4, 12(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorfloatminmaxacross": {
+				Name: "vectorfloatminmaxacross", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+extern void vectorfloatminmaxacross(const float *, float *);
+int main(void) {
+  const float input[4] = {-2.0f, 7.0f, 3.0f, 1.0f};
+  const float want[4] = {7.0f, -2.0f, 7.0f, -2.0f};
+  float got[4] = {0};
+  vectorfloatminmaxacross(input, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_float_minmax_across", triple, ir, mainC, nil)
+}
+
+func TestARM64RawFloatMinMaxAcrossHalfRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatminmaxacrosshalf(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.H8]
+	WORD $0x4e30c801 // FMAXNMV H1, V0.8H
+	WORD $0x4eb0c802 // FMINNMV H2, V0.8H
+	WORD $0x4e30f803 // FMAXV H3, V0.8H
+	WORD $0x4eb0f804 // FMINV H4, V0.8H
+	VST1.P [V1.H8, V2.H8, V3.H8, V4.H8], 64(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawfloatminmaxacrosshalf": {
+				Name: "rawfloatminmaxacrosshalf", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatminmaxacrosshalf(const uint16_t *, uint16_t *);
+int main(void) {
+  const uint16_t input[8] = {0xc000,0x4700,0x4200,0x3c00,0xbc00,0x4400,0x4000,0x0000};
+  uint16_t got[32] = {0};
+  rawfloatminmaxacrosshalf(input, got);
+  if (got[0] != 0x4700 || got[8] != 0xc000 || got[16] != 0x4700 || got[24] != 0xc000) return 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_minmax_across_half", triple, ir, mainC, nil)
+}
+
+func TestARM64RawFloatMinMaxAcrossUsesNamedFamily(t *testing.T) {
+	const source = `
+TEXT rawfloatminmaxacross(SB),$0-0
+	WORD $0x6e30f800
+	WORD $0x6eb0f800
+	WORD $0x6e30c800
+	WORD $0x6eb0c800
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawfloatminmaxacross": {Name: "rawfloatminmaxacross", Ret: Void}},
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/arm64_lower_float_narrow.go b/arm64_lower_float_narrow.go
new file mode 100644
index 000000000..62a8a0499
--- /dev/null
+++ b/arm64_lower_float_narrow.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawVectorFloatNarrow struct {
+	sourceBits  int
+	upper       bool
+	source      int
+	destination int
+}
+
+func decodeARM64RawVectorFloatNarrow(word uint32) (arm64RawVectorFloatNarrow, bool) {
+	if word&0xbfbffc00 != 0x0e216800 {
+		return arm64RawVectorFloatNarrow{}, false
+	}
+	sourceBits := 32
+	if word&(1<<22) != 0 {
+		sourceBits = 64
+	}
+	return arm64RawVectorFloatNarrow{
+		sourceBits:  sourceBits,
+		upper:       word&(1<<30) != 0,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawVectorFloatNarrow(form arm64RawVectorFloatNarrow) error {
+	return c.lowerARM64VectorFloatNarrowForm(form.sourceBits, form.upper,
+		Reg(fmt.Sprintf("V%d", form.source)), Reg(fmt.Sprintf("V%d", form.destination)))
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VFCVTN" && op != "VFCVTN2" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects Vsrc.S4/D2 and the corresponding narrow destination and no suffix: %q", op, ins.Raw)
+	}
+	source, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destination, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	wantDestinationLanes := source.lanes
+	if op == "VFCVTN2" {
+		wantDestinationLanes *= 2
+	}
+	validSource := sourceOK && ((source.elementBits == 32 && source.lanes == 4) || (source.elementBits == 64 && source.lanes == 2))
+	if !validSource || !destinationOK || destination != (arm64VectorArrangement{elementBits: source.elementBits / 2, lanes: wantDestinationLanes}) {
+		return true, false, fmt.Errorf("arm64 %s operand arrangements are outside Go 1.27's narrowing optab: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64VectorFloatNarrowForm(source.elementBits, op == "VFCVTN2", ins.Args[0].Reg, ins.Args[1].Reg)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatNarrowForm(sourceBits int, upper bool, sourceReg, destinationReg Reg) error {
+	destinationBits := sourceBits / 2
+	sourceLanes := 128 / sourceBits
+	sourceArrangement := arm64VectorArrangement{elementBits: sourceBits, lanes: sourceLanes}
+	source, err := c.loadARM64VectorFloat(sourceReg, sourceArrangement)
+	if err != nil {
+		return err
+	}
+	sourceType, destinationType := "float", "half"
+	if sourceBits == 64 {
+		sourceType, destinationType = "double", "float"
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fptrunc <%d x %s> %s to <%d x %s>\n",
+		converted, sourceLanes, sourceType, source, sourceLanes, destinationType)
+	if !upper {
+		return c.storeARM64VectorFloat(destinationReg,
+			arm64VectorArrangement{elementBits: destinationBits, lanes: sourceLanes}, "%"+converted)
+	}
+
+	destinationArrangement := arm64VectorArrangement{elementBits: destinationBits, lanes: sourceLanes * 2}
+	result, err := c.loadARM64VectorFloat(destinationReg, destinationArrangement)
+	if err != nil {
+		return err
+	}
+	for lane := 0; lane < sourceLanes; lane++ {
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %%%s, i32 %d\n", element, sourceLanes, destinationType, converted, lane)
+		updated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n",
+			updated, sourceLanes*2, destinationType, result, destinationType, element, sourceLanes+lane)
+		result = "%" + updated
+	}
+	return c.storeARM64VectorFloat(destinationReg, destinationArrangement, result)
+}
diff --git a/arm64_lower_float_narrow_test.go b/arm64_lower_float_narrow_test.go
new file mode 100644
index 000000000..1af2fcb1a
--- /dev/null
+++ b/arm64_lower_float_narrow_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorFloatNarrowCompleteGoAssemblerForms(t *testing.T) {
+	const source = `
+TEXT vectorfloatnarrowforms(SB),$0-0
+	VFCVTN V2.S4, V3.H4
+	VFCVTN2 V4.S4, V5.H8
+	VFCVTN V0.D2, V31.S2
+	VFCVTN2 V30.D2, V1.S4
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectorfloatnarrowforms": {Name: "vectorfloatnarrowforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fptrunc <4 x float>", "fptrunc <2 x double>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("ARM64 VFCVTN family omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-float-narrow.ll", "arm64-vector-float-narrow.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64RawVectorFloatNarrowCompleteBaseFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawvectorfloatnarrowforms(SB),$0-0\n")
+	for _, size := range []uint32{0, 1 << 22} { // 4S -> 4H and 2D -> 2S.
+		for _, upper := range []uint32{0, 1 << 30} { // FCVTN and FCVTN2.
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", uint32(0x0e216800)|size|upper|30<<5|29)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawvectorfloatnarrowforms": {Name: "rawvectorfloatnarrowforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fptrunc <4 x float>", "fptrunc <2 x double>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw floating narrow omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-vector-float-narrow.ll", "arm64-raw-vector-float-narrow.o", ir)
+		})
+	}
+}
+
+func TestARM64RawVectorFloatNarrowDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e216800, // FCVTXN, not FCVTN.
+		0x0ea16800, // Unallocated size.
+		0x0e217800, // FCVTL, not FCVTN.
+		0x0e216c00, // Adjacent opcode.
+	} {
+		if _, ok := decodeARM64RawVectorFloatNarrow(word); ok {
+			t.Fatalf("floating narrow decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func TestTranslateARM64VectorFloatNarrowRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VFCVTN V0.D2",
+		"VFCVTN V0.D2, V1.S4",
+		"VFCVTN2 V0.D2, V1.S2",
+		"VFCVTN V0.S2, V1.H4",
+		"VFCVTN2 V0.S4, V1.S4",
+		"VFCVTN.P V0.D2, V1.S2",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT badvectorfloatnarrow(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+				Sigs: map[string]FuncSig{"badvectorfloatnarrow": {Name: "badvectorfloatnarrow", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VFCVTN/VFCVTN2 optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64RawVectorFloatNarrowRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawvectorfloatnarrow(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	ADD $16, R1, R2
+	VLD1 (R0), [V1.S4]
+	VLD1 (R2), [V2.H8]
+	WORD $0x0e216820 // FCVTN V0.4H, V1.4S
+	VST1 [V0.H8], (R1)
+	WORD $0x4e216822 // FCVTN2 V2.8H, V1.4S
+	VST1 [V2.H8], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawvectorfloatnarrow": {
+				Name: "rawvectorfloatnarrow", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawvectorfloatnarrow(const float *, uint16_t *);
+int main(void) {
+  const float input[4] = {1.0f, -2.0f, 0.5f, 65504.0f};
+  const uint16_t want[16] = {
+    0x3c00,0xc000,0x3800,0x7bff, 0,0,0,0,
+    1,2,3,4, 0x3c00,0xc000,0x3800,0x7bff,
+  };
+  uint16_t got[16] = {0,0,0,0,0,0,0,0, 1,2,3,4,5,6,7,8};
+  rawvectorfloatnarrow(input, got);
+  for (int i = 0; i < 16; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_vector_float_narrow", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_float_pair.go b/arm64_lower_float_pair.go
new file mode 100644
index 000000000..265095dd2
--- /dev/null
+++ b/arm64_lower_float_pair.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// lowerARM64FloatPair implements the single floating-point register-pair
+// family described by Go 1.27's arm64 optab: FLDPS/FLDPD/FLDPQ and
+// FSTPS/FSTPD/FSTPQ, including ordinary, pre-indexed, and post-indexed memory.
+func (c *arm64Ctx) lowerARM64FloatPair(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	elementBytes := map[Op]int{
+		"FLDPS": 4, "FSTPS": 4,
+		"FLDPD": 8, "FSTPD": 8,
+		"FLDPQ": 16, "FSTPQ": 16,
+	}[op]
+	if elementBytes == 0 {
+		return false, false, nil
+	}
+
+	rawOp := strings.ToUpper(string(ins.Op))
+	preIndex, postIndex := false, false
+	switch rawOp {
+	case string(op):
+	case string(op) + ".W":
+		preIndex = true
+	case string(op) + ".P":
+		postIndex = true
+	default:
+		return true, false, fmt.Errorf("arm64 %s accepts only .P or .W memory suffixes: %q", op, ins.Raw)
+	}
+
+	load := strings.HasPrefix(string(op), "FLDP")
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects exactly 2 operands: %q", op, ins.Raw)
+	}
+	memory, pair := ins.Args[0], ins.Args[1]
+	if !load {
+		pair, memory = ins.Args[0], ins.Args[1]
+	}
+	if pair.Kind != OpRegList || len(pair.RegList) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects a pair of floating-point registers: %q", op, ins.Raw)
+	}
+	for _, reg := range pair.RegList {
+		if _, valid := arm64ParseFReg(reg); !valid {
+			return true, false, fmt.Errorf("arm64 %s expects a pair of floating-point registers: %q", op, ins.Raw)
+		}
+	}
+	if load && pair.RegList[0] == pair.RegList[1] {
+		return true, false, fmt.Errorf("arm64 %s destination pair has constrained unpredictable behavior: %q", op, ins.Raw)
+	}
+
+	ptr, base, increment, update, err := c.arm64FloatPairMemoryPointer(memory, elementBytes, preIndex, postIndex)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	for index, reg := range pair.RegList {
+		elementPtr := ptr
+		if index != 0 {
+			next := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 %d\n", next, ptr, elementBytes)
+			elementPtr = "%" + next
+		}
+		if load {
+			if err := c.loadARM64FloatPairElement(reg, elementPtr, elementBytes); err != nil {
+				return true, false, err
+			}
+		} else if err := c.storeARM64FloatPairElement(reg, elementPtr, elementBytes); err != nil {
+			return true, false, err
+		}
+	}
+	if update {
+		if err := c.updatePostInc(base, increment); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) arm64FloatPairMemoryPointer(op Operand, elementBytes int, preIndex, postIndex bool) (ptr string, base Reg, increment int64, update bool, err error) {
+	if preIndex && postIndex {
+		return "", "", 0, false, fmt.Errorf("memory operand cannot be both pre- and post-indexed")
+	}
+	if op.Kind == OpSym {
+		if preIndex || postIndex {
+			return "", "", 0, false, fmt.Errorf("symbol operand cannot be pre- or post-indexed")
+		}
+		ptr, err := c.ptrFromSB(op.Sym)
+		return ptr, "", 0, false, err
+	}
+	if op.Kind != OpMem {
+		return "", "", 0, false, fmt.Errorf("expected a memory operand")
+	}
+	if op.Mem.Index != "" {
+		return "", "", 0, false, fmt.Errorf("register-indexed memory is absent from the Go 1.27 floating pair optab")
+	}
+	if !isARM64FloatPairMemoryBase(op.Mem.Base) {
+		return "", "", 0, false, fmt.Errorf("memory base must be R0-R30, RSP, SP, or ZR")
+	}
+	if preIndex || postIndex {
+		limit := int64(64*elementBytes - elementBytes)
+		if op.Mem.Off < -int64(64*elementBytes) || op.Mem.Off > limit || op.Mem.Off%int64(elementBytes) != 0 {
+			return "", "", 0, false, fmt.Errorf("pre/post-index offset %d must be aligned to %d and in [%d,%d]", op.Mem.Off, elementBytes, -64*elementBytes, limit)
+		}
+	}
+	addr, base, increment, err := c.addrI64(op.Mem, postIndex)
+	if err != nil {
+		return "", "", 0, false, err
+	}
+	if preIndex {
+		if err := c.storeReg(base, addr); err != nil {
+			return "", "", 0, false, err
+		}
+	}
+	name := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", name, addr)
+	return "%" + name, base, increment, postIndex, nil
+}
+
+func isARM64FloatPairMemoryBase(reg Reg) bool {
+	if reg == SP || reg == Reg("RSP") || reg == ZR {
+		return true
+	}
+	s := strings.ToUpper(strings.TrimSpace(string(reg)))
+	if !strings.HasPrefix(s, "R") {
+		return false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "R"))
+	return err == nil && n >= 0 && n <= 30
+}
+
+func (c *arm64Ctx) loadARM64FloatPairElement(reg Reg, ptr string, elementBytes int) error {
+	if elementBytes == 16 {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %s, align 1\n", value, ptr)
+		return c.storeVReg(reg, "%"+value)
+	}
+	bits := elementBytes * 8
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", value, bits, ptr)
+	value64 := "%" + value
+	if bits != 64 {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i64\n", wide, bits, value)
+		value64 = "%" + wide
+	}
+	return c.storeReg(reg, value64)
+}
+
+func (c *arm64Ctx) storeARM64FloatPairElement(reg Reg, ptr string, elementBytes int) error {
+	if elementBytes == 16 {
+		value, err := c.loadVReg(reg)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", value, ptr)
+		return nil
+	}
+	value, err := c.loadReg(reg)
+	if err != nil {
+		return err
+	}
+	bits := elementBytes * 8
+	if bits == 64 {
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", value, ptr)
+		return nil
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, value, bits)
+	fmt.Fprintf(c.b, "  store i%d %%%s, ptr %s, align 1\n", bits, narrow, ptr)
+	return nil
+}
diff --git a/arm64_lower_float_pair_test.go b/arm64_lower_float_pair_test.go
new file mode 100644
index 000000000..aed77a015
--- /dev/null
+++ b/arm64_lower_float_pair_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64FloatPairLoadStoreCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 defines one six-op family: FLDPS/FLDPD/FLDPQ and
+	// FSTPS/FSTPD/FSTPQ. Each precision accepts register- or SP-relative
+	// memory, pre/post indexing, and SB symbols. Cover every shape here rather
+	// than teaching the translator only the FSTPQ form first seen in Wago.
+	const source = `
+TEXT floatPairForms(SB),$0-0
+	FLDPS (R0), (F0, F1)
+	FSTPS (F0, F1), 4(R0)
+	FLDPS.P 8(R1), (F2, F3)
+	FSTPS.W (F2, F3), -8(R1)
+	FLDPS pairData(SB), (F4, F5)
+	FSTPS (F4, F5), pairData+8(SB)
+	FLDPD -16(R2), (F6, F7)
+	FSTPD (F6, F7), (R2)
+	FLDPD.P 16(R3), (F8, F9)
+	FSTPD.W (F8, F9), -16(R3)
+	FLDPD pairData(SB), (F10, F11)
+	FSTPD (F10, F11), pairData+16(SB)
+	FLDPQ -32(R4), (F12, F13)
+	FSTPQ (F12, F13), (R4)
+	FLDPQ.P 32(R5), (F14, F15)
+	FSTPQ.W (F14, F15), -32(R5)
+	FLDPQ pairData(SB), (F16, F17)
+	FSTPQ (F16, F17), pairData+32(SB)
+	FLDPQ (RSP), (F30, F31)
+	FSTPQ (F30, F31), 64(RSP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"floatPairForms": {Name: "floatPairForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"load i32", "store i32", "load i64", "store i64", "load <16 x i8>", "store <16 x i8>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s did not lower %q:\n%s", target.name, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm64-float-pair-"+target.name+".ll", "arm64-float-pair-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64FloatPairLoadStoreRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"FLDPQ (R0), (R1, R2)",
+		"FSTPQ (R1, R2), (R0)",
+		"FLDPD (R0), (F2, F2)",
+		"FLDPS (R0)(R1), (F0, F1)",
+		"FSTPS (F0, F1), (R0)(R1)",
+		"FLDPQ.P pairData(SB), (F0, F1)",
+		"FSTPQ.W (F0, F1), pairData(SB)",
+		"FLDPQ.X (R0), (F0, F1)",
+		"FSTPD (F0), (R0)",
+		"FLDPS (R0)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badFloatPair(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badFloatPair": {Name: "badFloatPair", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 floating pair table", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64FloatPairLoadStoreRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT floatPairRoundTrip(SB),$0-0
+	FLDPS.P 8(R0), (F0, F1)
+	FSTPS.P (F0, F1), 8(R1)
+	FLDPD.W -16(R2), (F2, F3)
+	FSTPD.W (F2, F3), 16(R3)
+	FLDPQ (R4), (F4, F5)
+	FSTPQ (F4, F5), (R5)
+	MOVD R0, 0(R6)
+	MOVD R1, 8(R6)
+	MOVD R2, 16(R6)
+	MOVD R3, 24(R6)
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+		{Offset: 40, Type: Ptr, Index: 5, Field: -1},
+		{Offset: 48, Type: Ptr, Index: 6, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"floatPairRoundTrip": {Name: "floatPairRoundTrip", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <string.h>
+extern void floatPairRoundTrip(const uint32_t *, uint32_t *, const uint64_t *, uint64_t *, const unsigned char *, unsigned char *, uintptr_t *);
+int main(void) {
+  const uint32_t s[2] = {0x11223344u, 0xaabbccddu}; uint32_t so[2] = {0};
+	const uint64_t dbuf[4] = {0, 0, 0x0102030405060708ull, 0x8877665544332211ull}; uint64_t doutbuf[4] = {0};
+  const unsigned char q[32] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}; unsigned char qout[32] = {0};
+  uintptr_t advanced[4] = {0};
+	floatPairRoundTrip(s, so, dbuf + 4, doutbuf, q, qout, advanced);
+  if (memcmp(s, so, sizeof(s)) != 0) return 1;
+	if (memcmp(dbuf + 2, doutbuf + 2, 2 * sizeof(uint64_t)) != 0) return 2;
+  if (memcmp(q, qout, sizeof(q)) != 0) return 3;
+  if (advanced[0] != (uintptr_t)(s + 2) || advanced[1] != (uintptr_t)(so + 2)) return 4;
+	if (advanced[2] != (uintptr_t)(dbuf + 2) || advanced[3] != (uintptr_t)(doutbuf + 2)) return 5;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_float_pair", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_float_scalar_compare.go b/arm64_lower_float_scalar_compare.go
new file mode 100644
index 000000000..3cd7e69cc
--- /dev/null
+++ b/arm64_lower_float_scalar_compare.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ScalarCompareForm struct {
+	bits        int
+	signaling   bool
+	left, right Reg // Empty right means the architecture's immediate zero.
+}
+
+func parseARM64ScalarCompare(op Op, ins Instr) (arm64ScalarCompareForm, bool, error) {
+	switch op {
+	case "FCMPS", "FCMPD", "FCMPES", "FCMPED":
+	default:
+		return arm64ScalarCompareForm{}, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[1].Kind != OpReg || !isARM64FReg(ins.Args[1].Reg) ||
+		!arm64ScalarFloatCompareSource(ins.Args[0]) {
+		return arm64ScalarCompareForm{}, true, fmt.Errorf("arm64 %s expects Fsrc or $(0.0), Fdst and no suffix: %q", op, ins.Raw)
+	}
+
+	bits := 64
+	if op == "FCMPS" || op == "FCMPES" {
+		bits = 32
+	}
+	form := arm64ScalarCompareForm{bits: bits, signaling: op == "FCMPES" || op == "FCMPED", left: ins.Args[1].Reg}
+	if ins.Args[0].Kind == OpReg {
+		form.right = ins.Args[0].Reg
+	}
+	return form, true, nil
+}
+
+func (c *arm64Ctx) lowerARM64ScalarFloatCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, matched, err := parseARM64ScalarCompare(op, ins)
+	if !matched || err != nil {
+		return matched, false, err
+	}
+	right := ""
+	if form.right != "" {
+		right, err = c.loadARM64ScalarFloatReg(form.right, form.bits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	left, err := c.loadARM64ScalarFloatReg(form.left, form.bits)
+	if err != nil {
+		return true, false, err
+	}
+	c.emitARM64ScalarFloatCompare(form.bits, form.signaling, left, right)
+	return true, false, nil
+}
+
+func arm64ScalarFloatCompareSource(operand Operand) bool {
+	if operand.Kind == OpReg {
+		return isARM64FReg(operand.Reg)
+	}
+	// Go's C_FCON optab class accepts any floating constant here even though
+	// AArch64's FCMP-immediate encoding always compares against zero. Preserve
+	// that assembler behavior instead of treating the source spelling as the
+	// value encoded by the instruction.
+	return operand.Kind == OpImm && operand.ImmRaw == "" && operand.ImmIsFloat
+}
+
+// DDI0602 FCMP/FCMPE differ for quiet NaNs and both consume FPCR and update
+// FPSR even when NZCV is dead. Execute the exact operation, capturing NZCV in
+// the same asm block. The memory barrier orders existing native MRS/MSR;
+// it grants no memory, source-layout or machine-entry permission. All virtual
+// source reads were recorded by loadARM64ScalarFloatReg, and no SIMD bits change.
+// An empty right operand represents the architecture's immediate-zero form.
+func (c *arm64Ctx) emitARM64ScalarFloatCompare(bits int, signaling bool, left, right string) {
+	opcode := "fcmp"
+	if signaling {
+		opcode = "fcmpe"
+	}
+	typeName, modifier := "double", "d"
+	if bits == 32 {
+		typeName, modifier = "float", "s"
+	} else if bits == 16 {
+		typeName, modifier = "half", "h"
+	}
+	assembly := fmt.Sprintf("%s ${1:%s}, #0.0\\0Amrs $0, nzcv", opcode, modifier)
+	constraints := "=r,w,~{cc},~{memory}"
+	arguments := typeName + " " + left
+	if right != "" {
+		assembly = fmt.Sprintf("%s ${1:%s}, ${2:%s}\\0Amrs $0, nzcv", opcode, modifier, modifier)
+		constraints = "=r,w,w,~{cc},~{memory}"
+		arguments += ", " + typeName + " " + right
+	}
+	nzcv := c.newTmp()
+	// Assembly already contains an LLVM newline escape rather than a literal
+	// newline: do not quote it through %q a second time.
+	c.emitMachineNeutralNativeIR("  %%%s = call i64 asm sideeffect \"%s\", %q(%s)\n", nzcv, assembly, constraints, arguments)
+	c.storeARM64NativeCompareFlags("%" + nzcv)
+}
+
+func (c *arm64Ctx) storeARM64NativeCompareFlags(nzcv string) {
+	c.flagsWritten = true
+	for index, slot := range []string{c.flagsVSlot, c.flagsCSlot, c.flagsZSlot, c.flagsNSlot} {
+		shifted, flag := c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, %d\n", shifted, nzcv, 28+index)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i1\n", flag, shifted)
+		c.storeFlag(slot, "%"+flag)
+	}
+}
diff --git a/arm64_lower_float_scalar_compare_test.go b/arm64_lower_float_scalar_compare_test.go
new file mode 100644
index 000000000..eee56f414
--- /dev/null
+++ b/arm64_lower_float_scalar_compare_test.go
@@ -0,0 +1,165 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64ScalarFloatCompareForms = `
+TEXT scalarfloatcompareforms(SB),$0-0
+	FCMPS F3, F17
+	FCMPS $(1.0), F8
+	FCMPD F11, F27
+	FCMPD $(0.0), F25
+	FCMPES F16, F30
+	FCMPES $(0.0), F29
+	FCMPED F13, F10
+	FCMPED $(0.0), F25
+	RET
+`
+
+func TestTranslateARM64ScalarFloatCompareCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64ScalarFloatCompareForms, true)
+	file, err := Parse(ArchARM64, arm64ScalarFloatCompareForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	foundFloatImmediate := false
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == "FCMPS" && len(ins.Args) == 2 && ins.Args[0].Kind == OpImm {
+			foundFloatImmediate = ins.Args[0].ImmIsFloat
+		}
+	}
+	if !foundFloatImmediate {
+		t.Fatal("FCMP floating immediate was not preserved as C_FCON")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"scalarfloatcompareforms": {Name: "scalarfloatcompareforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`asm sideeffect "fcmp ${1:s}`, `asm sideeffect "fcmpe ${1:s}`, `asm sideeffect "fcmp ${1:d}`, `asm sideeffect "fcmpe ${1:d}`} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("scalar floating compare lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-scalar-float-compare.ll", "arm64-scalar-float-compare.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatCompareRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"FCMPS F0",
+		"FCMPS R0, F1",
+		"FCMPS F0, R1",
+		"FCMPS $1, F1",
+		"FCMPS $(1), F1",
+		"FCMPD F0, F1, F2",
+		"FCMPED.P F0, F1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badscalarfloatcompare(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badscalarfloatcompare": {Name: "badscalarfloatcompare", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's FCMP forms", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64ScalarFloatCompareRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT scalarfloatcompare(SB),$0-16
+	FMOVS a+0(FP), F0
+	FMOVS b+4(FP), F1
+	MOVD out+8(FP), R2
+	FCMPS F0, F1
+	CSET MI, R3
+	MOVD R3, 0(R2)
+	CSET EQ, R3
+	MOVD R3, 8(R2)
+	CSET CS, R3
+	MOVD R3, 16(R2)
+	CSET VS, R3
+	MOVD R3, 24(R2)
+	FCMPES $(0.0), F1
+	CSET MI, R3
+	MOVD R3, 32(R2)
+	CSET EQ, R3
+	MOVD R3, 40(R2)
+	CSET CS, R3
+	MOVD R3, 48(R2)
+	CSET VS, R3
+	MOVD R3, 56(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"scalarfloatcompare": {
+				Name: "scalarfloatcompare", Args: []LLVMType{"float", "float", Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: "float", Index: 0, Field: -1},
+					{Offset: 4, Type: "float", Index: 1, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void scalarfloatcompare(float, float, uint64_t *);
+int main(void) {
+  uint64_t got[8] = {0};
+  scalarfloatcompare(2.0f, 1.0f, got);
+  const uint64_t want[8] = {1,0,0,0, 0,0,1,0};
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_scalar_float_compare", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_float_scalar_unary_test.go b/arm64_lower_float_scalar_unary_test.go
new file mode 100644
index 000000000..da1fddb61
--- /dev/null
+++ b/arm64_lower_float_scalar_unary_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64ScalarFloatUnaryCompleteGoAssemblerForms(t *testing.T) {
+	ops := []string{
+		"FABSS", "FABSD", "FNEGS", "FNEGD", "FSQRTS", "FSQRTD",
+		"FRINTNS", "FRINTND", "FRINTPS", "FRINTPD", "FRINTMS", "FRINTMD",
+		"FRINTZS", "FRINTZD", "FRINTAS", "FRINTAD", "FRINTXS", "FRINTXD",
+		"FRINTIS", "FRINTID",
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·scalarfloatunaryforms(SB), $0-0\n")
+	for _, op := range ops {
+		source.WriteString("\t" + op + " F0, F31\n")
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"scalarfloatunaryforms": {Name: "scalarfloatunaryforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-scalar-float-unary.ll", "arm64-scalar-float-unary.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatUnaryRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"FNEGD F0",
+		"FNEGS F0, F1, F2",
+		"FABSS R0, F1",
+		"FRINTND F0, R1",
+		"FRINTAS.P F0, F1",
+	} {
+		source := "TEXT ·bad(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's scalar floating unary table", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_float_select_test.go b/arm64_lower_float_select_test.go
new file mode 100644
index 000000000..ae349370d
--- /dev/null
+++ b/arm64_lower_float_select_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64FloatConditionalSelectCompleteGoAssemblerForms(t *testing.T) {
+	conditions := []string{"EQ", "NE", "HS", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "NV"}
+	var source strings.Builder
+	source.WriteString("TEXT floatconditionalselectforms(SB),$0-0\n\tCMP R0, R1\n")
+	for _, op := range []string{"FCSELS", "FCSELD"} {
+		for _, condition := range conditions {
+			source.WriteString("\t" + op + " " + condition + ", F0, F1, F31\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"floatconditionalselectforms": {Name: "floatconditionalselectforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"select i1", "float", "double"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("floating conditional-select family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-float-conditional-select.ll", "arm64-float-conditional-select.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64FloatConditionalSelectRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"FCSELS EQ, F0, F1",
+		"FCSELD EQ, F0, F1, F2, F3",
+		"FCSELS BAD, F0, F1, F2",
+		"FCSELS EQ, R0, F1, F2",
+		"FCSELD EQ, F0, (R1), F2",
+		"FCSELS.P EQ, F0, F1, F2",
+	} {
+		source := "TEXT badfloatconditionalselect(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+			Sigs: map[string]FuncSig{"badfloatconditionalselect": {Name: "badfloatconditionalselect", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's FCSEL optab", instruction)
+		}
+	}
+}
+
+func TestARM64FloatConditionalSelectRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT floatconditionalselect(SB),$0-24
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	MOVD flag+16(FP), R2
+	FMOVS 0(R0), F0
+	FMOVS 4(R0), F1
+	FMOVD 8(R0), F2
+	FMOVD 16(R0), F3
+	CMP $0, R2
+	FCSELS GT, F0, F1, F4
+	FCSELD LE, F2, F3, F5
+	FMOVS F4, 0(R1)
+	FMOVD F5, 8(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"floatconditionalselect": {
+			Name: "floatconditionalselect", Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+struct input { float a, b; double c, d; };
+struct output { float s; uint32_t pad; double d; };
+extern void floatconditionalselect(const struct input *, struct output *, uint64_t);
+int main(void) {
+  const struct input input = {1.25f, -2.5f, 3.75, -4.5};
+  struct output positive = {0}, zero = {0};
+  floatconditionalselect(&input, &positive, 1);
+  floatconditionalselect(&input, &zero, 0);
+  if (positive.s != input.a || positive.d != input.d) return 1;
+  if (zero.s != input.b || zero.d != input.c) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_float_conditional_select", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_float_vector.go b/arm64_lower_float_vector.go
new file mode 100644
index 000000000..4cda1fca7
--- /dev/null
+++ b/arm64_lower_float_vector.go
@@ -0,0 +1,841 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64VectorArrangement struct {
+	elementBits int
+	lanes       int
+}
+
+func parseARM64VectorArrangement(reg Reg) (arm64VectorArrangement, bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(reg)))
+	dot := strings.IndexByte(s, '.')
+	if dot < 2 || dot+2 >= len(s) {
+		return arm64VectorArrangement{}, false
+	}
+	if _, ok := arm64ParseVReg(reg); !ok {
+		return arm64VectorArrangement{}, false
+	}
+	kind := s[dot+1]
+	lanes, err := strconv.Atoi(s[dot+2:])
+	if err != nil {
+		return arm64VectorArrangement{}, false
+	}
+	elementBits := 0
+	switch kind {
+	case 'B':
+		elementBits = 8
+	case 'H':
+		elementBits = 16
+	case 'S':
+		elementBits = 32
+	case 'D':
+		elementBits = 64
+	default:
+		return arm64VectorArrangement{}, false
+	}
+	if lanes*elementBits != 64 && lanes*elementBits != 128 {
+		return arm64VectorArrangement{}, false
+	}
+	return arm64VectorArrangement{elementBits: elementBits, lanes: lanes}, true
+}
+
+func (c *arm64Ctx) loadARM64VectorFloat(reg Reg, arrangement arm64VectorArrangement) (string, error) {
+	bytesValue, err := c.loadVReg(reg)
+	if err != nil {
+		return "", err
+	}
+	physicalLanes := 128 / arrangement.elementBits
+	floatType := "float"
+	if arrangement.elementBits == 16 {
+		floatType = "half"
+	} else if arrangement.elementBits == 64 {
+		floatType = "double"
+	}
+	all := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", all, bytesValue, physicalLanes, floatType)
+	if arrangement.lanes == physicalLanes {
+		return "%" + all, nil
+	}
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> <", low, physicalLanes, floatType, all, physicalLanes, floatType, arrangement.lanes)
+	for i := 0; i < arrangement.lanes; i++ {
+		if i != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", i)
+	}
+	c.b.WriteString(">\n")
+	return "%" + low, nil
+}
+
+func (c *arm64Ctx) storeARM64VectorFloat(reg Reg, arrangement arm64VectorArrangement, value string) error {
+	floatType := "float"
+	if arrangement.elementBits == 16 {
+		floatType = "half"
+	} else if arrangement.elementBits == 64 {
+		floatType = "double"
+	}
+	activeBytes := arrangement.lanes * arrangement.elementBits / 8
+	if activeBytes == 16 {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %s to <16 x i8>\n", out, arrangement.lanes, floatType, value)
+		return c.storeVReg(reg, "%"+out)
+	}
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %s to i64\n", low, arrangement.lanes, floatType, value)
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %%%s, i32 0\n", wide, low)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, wide)
+	return c.storeVReg(reg, "%"+out)
+}
+
+func (c *arm64Ctx) loadARM64VectorInteger(reg Reg, arrangement arm64VectorArrangement) (string, error) {
+	bytesValue, err := c.loadVReg(reg)
+	if err != nil {
+		return "", err
+	}
+	physicalLanes := 128 / arrangement.elementBits
+	all := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x i%d>\n", all, bytesValue, physicalLanes, arrangement.elementBits)
+	if arrangement.lanes == physicalLanes {
+		return "%" + all, nil
+	}
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %%%s, <%d x i%d> poison, <%d x i32> <", low, physicalLanes, arrangement.elementBits, all, physicalLanes, arrangement.elementBits, arrangement.lanes)
+	for i := 0; i < arrangement.lanes; i++ {
+		if i != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", i)
+	}
+	c.b.WriteString(">\n")
+	return "%" + low, nil
+}
+
+func (c *arm64Ctx) storeARM64VectorInteger(reg Reg, arrangement arm64VectorArrangement, value string) error {
+	activeBytes := arrangement.lanes * arrangement.elementBits / 8
+	if activeBytes == 16 {
+		out := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to <16 x i8>\n", out, arrangement.lanes, arrangement.elementBits, value)
+		return c.storeVReg(reg, "%"+out)
+	}
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %s to i64\n", low, arrangement.lanes, arrangement.elementBits, value)
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %%%s, i32 0\n", wide, low)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, wide)
+	return c.storeVReg(reg, "%"+out)
+}
+
+func (c *arm64Ctx) lowerARM64VectorIntegerAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VADD" && op != "VSUB" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 2 && len(ins.Args) != 3) {
+		return true, false, fmt.Errorf("arm64 %s expects two bare V registers or three same-arrangement vector registers: %q", op, ins.Raw)
+	}
+
+	arranged := strings.Contains(string(ins.Args[0].Reg), ".")
+	if arranged {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s arranged form requires three operands: %q", op, ins.Raw)
+		}
+		allowed := func(a arm64VectorArrangement) bool {
+			return (a.elementBits == 8 && (a.lanes == 8 || a.lanes == 16)) ||
+				(a.elementBits == 16 && (a.lanes == 4 || a.lanes == 8)) ||
+				(a.elementBits == 32 && (a.lanes == 2 || a.lanes == 4)) ||
+				(a.elementBits == 64 && a.lanes == 2)
+		}
+		var arrangement arm64VectorArrangement
+		for i, arg := range ins.Args {
+			if arg.Kind != OpReg {
+				return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+			}
+			parsed, valid := parseARM64VectorArrangement(arg.Reg)
+			if !valid || !allowed(parsed) {
+				return true, false, fmt.Errorf("arm64 %s has an invalid vector arrangement: %q", op, ins.Raw)
+			}
+			if i == 0 {
+				arrangement = parsed
+			} else if parsed != arrangement {
+				return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+			}
+		}
+		source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		base, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		operation := "add"
+		if op == "VSUB" {
+			operation = "sub"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %s, %s\n", result, operation, arrangement.lanes, arrangement.elementBits, base, source)
+		return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+	}
+
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg || strings.Contains(string(arg.Reg), ".") {
+			return true, false, fmt.Errorf("arm64 %s scalar SIMD form requires bare V registers: %q", op, ins.Raw)
+		}
+		if _, valid := arm64ParseVReg(arg.Reg); !valid {
+			return true, false, fmt.Errorf("arm64 %s scalar SIMD form requires bare V registers: %q", op, ins.Raw)
+		}
+	}
+	sourceBytes, err := c.loadVReg(ins.Args[0].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	baseIndex := 1
+	destinationIndex := 1
+	if len(ins.Args) == 3 {
+		destinationIndex = 2
+	}
+	baseBytes, err := c.loadVReg(ins.Args[baseIndex].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	sourceWords := c.newTmp()
+	baseWords := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", sourceWords, sourceBytes)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", baseWords, baseBytes)
+	sourceLow := c.newTmp()
+	baseLow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", sourceLow, sourceWords)
+	fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", baseLow, baseWords)
+	resultLow := c.newTmp()
+	operation := "add"
+	if op == "VSUB" {
+		operation = "sub"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s i64 %%%s, %%%s\n", resultLow, operation, baseLow, sourceLow)
+	resultWords := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %%%s, i32 0\n", resultWords, resultLow)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, resultWords)
+	return true, false, c.storeVReg(ins.Args[destinationIndex].Reg, "%"+out)
+}
+
+func (c *arm64Ctx) lowerARM64AddAcross(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "VADDV":
+		// handled below
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 VADDV expects arranged vector source and bare V destination: %q", ins.Raw)
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	if !valid || !((arrangement.elementBits == 8 && (arrangement.lanes == 8 || arrangement.lanes == 16)) ||
+		(arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8)) ||
+		(arrangement.elementBits == 32 && arrangement.lanes == 4)) {
+		return true, false, fmt.Errorf("arm64 VADDV accepts only B8, B16, H4, H8, or S4 source: %q", ins.Raw)
+	}
+	if strings.Contains(string(ins.Args[1].Reg), ".") {
+		return true, false, fmt.Errorf("arm64 VADDV destination must be a bare V register: %q", ins.Raw)
+	}
+	if _, ok := arm64ParseVReg(ins.Args[1].Reg); !ok {
+		return true, false, fmt.Errorf("arm64 VADDV destination must be a bare V register: %q", ins.Raw)
+	}
+
+	lanes, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	sum := "0"
+	for lane := 0; lane < arrangement.lanes; lane++ {
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", element, arrangement.lanes, arrangement.elementBits, lanes, lane)
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i%d %s, %%%s\n", added, arrangement.elementBits, sum, element)
+		sum = "%" + added
+	}
+	physicalLanes := 128 / arrangement.elementBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n", result, physicalLanes, arrangement.elementBits, arrangement.elementBits, sum)
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", out, physicalLanes, arrangement.elementBits, result)
+	return true, false, c.storeVReg(ins.Args[1].Reg, "%"+out)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatArithmetic(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	return c.lowerARM64VectorFloatArithmeticForm(op, ins, false)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatArithmeticForm(op Op, ins Instr, allowRawHalf bool) (ok bool, terminated bool, err error) {
+	type operationSpec struct {
+		operation string
+		pairwise  bool
+	}
+	specs := map[Op]operationSpec{
+		"VFADD":    {operation: "add"},
+		"VFSUB":    {operation: "sub"},
+		"VFMUL":    {operation: "mul"},
+		"VFDIV":    {operation: "div"},
+		"VFMAX":    {operation: "maximum"},
+		"VFMAXNM":  {operation: "maxnum"},
+		"VFMIN":    {operation: "minimum"},
+		"VFMINNM":  {operation: "minnum"},
+		"VFABD":    {operation: "fabd"},
+		"VFMULX":   {operation: "fmulx"},
+		"VFADDP":   {operation: "add", pairwise: true},
+		"VFMAXP":   {operation: "maximum", pairwise: true},
+		"VFMAXNMP": {operation: "maxnum", pairwise: true},
+		"VFMINP":   {operation: "minimum", pairwise: true},
+		"VFMINNMP": {operation: "minnum", pairwise: true},
+	}
+	spec, handled := specs[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || !((allowRawHalf && parsed.elementBits == 16 && (parsed.lanes == 4 || parsed.lanes == 8)) ||
+			(parsed.elementBits == 32 && (parsed.lanes == 2 || parsed.lanes == 4)) ||
+			(parsed.elementBits == 64 && parsed.lanes == 2)) {
+			return true, false, fmt.Errorf("arm64 %s has an unsupported vector arrangement: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	first, err := c.loadARM64VectorFloat(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorFloat(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	floatType, intrinsicSuffix, _ := arm64ScalarFloatType(arrangement.elementBits)
+	result := ""
+	if !spec.pairwise {
+		computed := c.newTmp()
+		switch spec.operation {
+		case "add", "sub", "mul", "div":
+			fmt.Fprintf(c.b, "  %%%s = f%s <%d x %s> %s, %s\n", computed, spec.operation, arrangement.lanes, floatType, second, first)
+		case "fabd", "fmulx":
+			fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.aarch64.neon.%s.v%d%s(<%d x %s> %s, <%d x %s> %s)\n",
+				computed, arrangement.lanes, floatType, spec.operation, arrangement.lanes, intrinsicSuffix,
+				arrangement.lanes, floatType, second, arrangement.lanes, floatType, first)
+		default:
+			fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.%s.v%d%s(<%d x %s> %s, <%d x %s> %s)\n",
+				computed, arrangement.lanes, floatType, spec.operation, arrangement.lanes, intrinsicSuffix,
+				arrangement.lanes, floatType, second, arrangement.lanes, floatType, first)
+		}
+		result = "%" + computed
+	} else {
+		result = "poison"
+		half := arrangement.lanes / 2
+		for lane := 0; lane < arrangement.lanes; lane++ {
+			source := second
+			if lane >= half {
+				source = first
+			}
+			pair := (lane % half) * 2
+			left := c.newTmp()
+			right := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", left, arrangement.lanes, floatType, source, pair)
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", right, arrangement.lanes, floatType, source, pair+1)
+			combined := c.newTmp()
+			if spec.operation == "add" {
+				fmt.Fprintf(c.b, "  %%%s = fadd %s %%%s, %%%s\n", combined, floatType, left, right)
+			} else {
+				fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %%%s, %s %%%s)\n", combined, floatType, spec.operation, intrinsicSuffix, floatType, left, floatType, right)
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n", inserted, arrangement.lanes, floatType, result, floatType, combined, lane)
+			result = "%" + inserted
+		}
+	}
+	return true, false, c.storeARM64VectorFloat(ins.Args[2].Reg, arrangement, result)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatUnary(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	operations := map[Op]string{
+		"VFABS":   "fabs",
+		"VFNEG":   "neg",
+		"VFSQRT":  "sqrt",
+		"VFRINTN": "roundeven",
+		"VFRINTP": "ceil",
+		"VFRINTM": "floor",
+		"VFRINTZ": "trunc",
+		"VFCVTZS": "fptosi.sat",
+		"VFCVTZU": "fptoui.sat",
+		"VFCVTNS": "fptosi.roundeven.sat",
+		"VFCVTNU": "fptoui.roundeven.sat",
+		"VFCVTMS": "fptosi.floor.sat",
+		"VFCVTMU": "fptoui.floor.sat",
+		"VFCVTAS": "fptosi.round.sat",
+		"VFCVTAU": "fptoui.round.sat",
+		"VFCVTPS": "fptosi.ceil.sat",
+		"VFCVTPU": "fptoui.ceil.sat",
+		"VSCVTF":  "sitofp",
+		"VUCVTF":  "uitofp",
+	}
+	operation, handled := operations[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects two same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceValid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationValid := parseARM64VectorArrangement(ins.Args[1].Reg)
+	if !sourceValid || !destinationValid || sourceArrangement != destinationArrangement ||
+		!((sourceArrangement.elementBits == 32 && (sourceArrangement.lanes == 2 || sourceArrangement.lanes == 4)) ||
+			(sourceArrangement.elementBits == 64 && sourceArrangement.lanes == 2)) {
+		return true, false, fmt.Errorf("arm64 %s requires matching S2, S4, or D2 arrangements: %q", op, ins.Raw)
+	}
+	arrangement := sourceArrangement
+	floatType := "float"
+	floatSuffix := "f32"
+	if arrangement.elementBits == 64 {
+		floatType, floatSuffix = "double", "f64"
+	}
+	vectorFloatSuffix := fmt.Sprintf("v%d%s", arrangement.lanes, floatSuffix)
+	vectorIntegerSuffix := fmt.Sprintf("v%di%d", arrangement.lanes, arrangement.elementBits)
+
+	switch operation {
+	case "sitofp", "uitofp":
+		source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %s to <%d x %s>\n", converted, operation, arrangement.lanes, arrangement.elementBits, source, arrangement.lanes, floatType)
+		return true, false, c.storeARM64VectorFloat(ins.Args[1].Reg, arrangement, "%"+converted)
+	case "fptosi.sat", "fptoui.sat",
+		"fptosi.roundeven.sat", "fptoui.roundeven.sat",
+		"fptosi.floor.sat", "fptoui.floor.sat",
+		"fptosi.round.sat", "fptoui.round.sat",
+		"fptosi.ceil.sat", "fptoui.ceil.sat":
+		source, err := c.loadARM64VectorFloat(ins.Args[0].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		roundingIntrinsic := ""
+		switch {
+		case strings.Contains(operation, ".roundeven."):
+			roundingIntrinsic = "roundeven"
+		case strings.Contains(operation, ".floor."):
+			roundingIntrinsic = "floor"
+		case strings.Contains(operation, ".round."):
+			roundingIntrinsic = "round"
+		case strings.Contains(operation, ".ceil."):
+			roundingIntrinsic = "ceil"
+		}
+		if roundingIntrinsic != "" {
+			rounded := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.%s.%s(<%d x %s> %s)\n",
+				rounded, arrangement.lanes, floatType, roundingIntrinsic, vectorFloatSuffix,
+				arrangement.lanes, floatType, source)
+			source = "%" + rounded
+		}
+		conversionIntrinsic := "fptosi.sat"
+		if strings.HasPrefix(operation, "fptoui") {
+			conversionIntrinsic = "fptoui.sat"
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <%d x i%d> @llvm.%s.%s.%s(<%d x %s> %s)\n",
+			converted, arrangement.lanes, arrangement.elementBits, conversionIntrinsic, vectorIntegerSuffix, vectorFloatSuffix,
+			arrangement.lanes, floatType, source)
+		return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, arrangement, "%"+converted)
+	default:
+		source, err := c.loadARM64VectorFloat(ins.Args[0].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		if operation == "neg" {
+			fmt.Fprintf(c.b, "  %%%s = fneg <%d x %s> %s\n", result, arrangement.lanes, floatType, source)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.%s.%s(<%d x %s> %s)\n", result, arrangement.lanes, floatType, operation, vectorFloatSuffix, arrangement.lanes, floatType, source)
+		}
+		return true, false, c.storeARM64VectorFloat(ins.Args[1].Reg, arrangement, "%"+result)
+	}
+}
+
+func (c *arm64Ctx) lowerARM64VectorShiftRight(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, handled := arm64VectorShiftRightSpecs[op]
+	if !handled {
+		return false, false, nil
+	}
+	form, err := parseARM64VectorShift(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	sourceArrangement, destinationArrangement, scalar := form.arrangement, form.arrangement, form.scalar
+	source, err := c.loadARM64VectorInteger(ins.Args[1].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	if scalar {
+		extracted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i64> %s, i32 0\n", extracted, source)
+		source = "%" + extracted
+		vectorType = "i64"
+	}
+	shiftValue := func(amount int64) string {
+		if scalar {
+			return fmt.Sprintf("%d", amount)
+		}
+		return arm64VectorIntegerSplat(sourceArrangement, amount)
+	}
+	zero := "zeroinitializer"
+	if scalar {
+		zero = "0"
+	}
+	emitShift := func(value string, amount int64, signed bool) string {
+		if amount >= int64(sourceArrangement.elementBits) && !signed {
+			return zero
+		}
+		if amount >= int64(sourceArrangement.elementBits) {
+			amount = int64(sourceArrangement.elementBits - 1) // ASR by the element width is the replicated sign bit.
+		}
+		result := c.newTmp()
+		operation := "lshr"
+		if signed {
+			operation = "ashr"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, operation, vectorType, value, shiftValue(amount))
+		return "%" + result
+	}
+	result := emitShift(source, ins.Args[0].Imm, spec.signed)
+	if spec.rounding {
+		roundingBit := emitShift(source, ins.Args[0].Imm-1, false)
+		maskedBit := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", maskedBit, vectorType, roundingBit, shiftValue(1))
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %%%s\n", rounded, vectorType, result, maskedBit)
+		result = "%" + rounded
+	}
+	if spec.accumulate {
+		destination, err := c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		if scalar {
+			extracted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i64> %s, i32 0\n", extracted, destination)
+			destination = "%" + extracted
+		}
+		accumulated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", accumulated, vectorType, destination, result)
+		result = "%" + accumulated
+	}
+	if scalar {
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i64> zeroinitializer, i64 %s, i32 0\n", inserted, result)
+		result = "%" + inserted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, sourceArrangement, result)
+}
+
+func (c *arm64Ctx) lowerARM64VectorIntegerCompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	predicates := map[Op]string{
+		"VCMEQ": "eq",
+		"VCMGE": "sge",
+		"VCMGT": "sgt",
+		"VCMLE": "sle",
+		"VCMLT": "slt",
+		"VCMHI": "ugt",
+		"VCMHS": "uge",
+	}
+	predicate, handled := predicates[op]
+	testBits := op == "VCMTST"
+	if !handled && !testBits {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects register compare or $0 compare form and no suffix: %q", op, ins.Raw)
+	}
+	zeroForm := ins.Args[0].Kind == OpImm
+	if testBits && (zeroForm || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg) {
+		return true, false, fmt.Errorf("arm64 VCMTST requires three vector registers: %q", ins.Raw)
+	}
+	if zeroForm {
+		if op == "VCMHI" || op == "VCMHS" || ins.Args[0].Imm != 0 || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s immediate compare requires exactly $0, Vsrc.<T>, Vdst.<T>: %q", op, ins.Raw)
+		}
+	} else {
+		if op == "VCMLE" || op == "VCMLT" || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s register compare form is absent from Go 1.27's optab: %q", op, ins.Raw)
+		}
+	}
+
+	sourceIndex := 1
+	if !zeroForm {
+		sourceIndex = 0
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[sourceIndex].Reg)
+	allowed := func(a arm64VectorArrangement) bool {
+		return (a.elementBits == 8 && (a.lanes == 8 || a.lanes == 16)) ||
+			(a.elementBits == 16 && (a.lanes == 4 || a.lanes == 8)) ||
+			(a.elementBits == 32 && (a.lanes == 2 || a.lanes == 4)) ||
+			(a.elementBits == 64 && a.lanes == 2)
+	}
+	if !valid || !allowed(arrangement) {
+		return true, false, fmt.Errorf("arm64 %s has invalid vector arrangement: %q", op, ins.Raw)
+	}
+	start := 1
+	if !zeroForm {
+		start = 0
+	}
+	for i := start; i < len(ins.Args); i++ {
+		parsed, ok := parseARM64VectorArrangement(ins.Args[i].Reg)
+		if !ok || parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	left, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	right := "zeroinitializer"
+	if !zeroForm {
+		right, err = c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	compared := c.newTmp()
+	if testBits {
+		vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+		masked := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", masked, vectorType, left, right)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %%%s, zeroinitializer\n", compared, vectorType, masked)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", compared, predicate, arrangement.lanes, arrangement.elementBits, left, right)
+	}
+	allBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %%%s to <%d x i%d>\n", allBits, arrangement.lanes, compared, arrangement.lanes, arrangement.elementBits)
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+allBits)
+}
+
+func (c *arm64Ctx) lowerARM64VectorLogical(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	handled := false
+	for _, candidate := range []Op{"VAND", "VORR", "VEOR", "VBIC", "VORN", "VBSL", "VBIT", "VBIF", "VNOT"} {
+		if op == candidate {
+			handled = true
+			break
+		}
+	}
+	if !handled {
+		return false, false, nil
+	}
+	if op == "VNOT" {
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 VNOT expects source and destination B8/B16 vector registers and no suffix: %q", ins.Raw)
+		}
+		source, sourceValid := parseARM64VectorArrangement(ins.Args[0].Reg)
+		destination, destinationValid := parseARM64VectorArrangement(ins.Args[1].Reg)
+		if !sourceValid || !destinationValid || source != destination || source.elementBits != 8 || (source.lanes != 8 && source.lanes != 16) {
+			return true, false, fmt.Errorf("arm64 VNOT accepts matching B8 or B16 arrangements: %q", ins.Raw)
+		}
+		value, err := c.loadARM64VectorInteger(ins.Args[0].Reg, source)
+		if err != nil {
+			return true, false, err
+		}
+		vectorType := fmt.Sprintf("<%d x i8>", source.lanes)
+		ones := "<" + strings.TrimSuffix(strings.Repeat("i8 -1, ", source.lanes), ", ") + ">"
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", result, vectorType, value, ones)
+		return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destination, "%"+result)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three matching B8/B16 vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits != 8 || (parsed.lanes != 8 && parsed.lanes != 16) {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8 or B16 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i8>", arrangement.lanes)
+	result := ""
+	emitBinary := func(operation, left, right string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", name, operation, vectorType, left, right)
+		return "%" + name
+	}
+	emitNot := func(value string) string {
+		return emitBinary("xor", value, "<"+strings.TrimSuffix(strings.Repeat("i8 -1, ", arrangement.lanes), ", ")+">")
+	}
+	switch op {
+	case "VAND":
+		result = emitBinary("and", second, first)
+	case "VORR":
+		result = emitBinary("or", second, first)
+	case "VEOR":
+		result = emitBinary("xor", second, first)
+	case "VBIC":
+		result = emitBinary("and", second, emitNot(first))
+	case "VORN":
+		result = emitBinary("or", second, emitNot(first))
+	case "VBSL", "VBIT", "VBIF":
+		old, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		var mask, whenTrue, whenFalse string
+		switch op {
+		case "VBSL":
+			mask, whenTrue, whenFalse = old, second, first
+		case "VBIT":
+			mask, whenTrue, whenFalse = first, second, old
+		case "VBIF":
+			mask, whenTrue, whenFalse = first, old, second
+		}
+		selected := emitBinary("and", mask, whenTrue)
+		unselected := emitBinary("and", emitNot(mask), whenFalse)
+		result = emitBinary("or", selected, unselected)
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, result)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatWiden(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VFCVTL" && op != "VFCVTL2" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects Vsrc.S%d, Vdst.D2 and no suffix: %q", op, map[bool]int{false: 2, true: 4}[op == "VFCVTL2"], ins.Raw)
+	}
+	sourceArrangement, sourceValid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationValid := parseARM64VectorArrangement(ins.Args[1].Reg)
+	wantSourceLanes := 2
+	if op == "VFCVTL2" {
+		wantSourceLanes = 4
+	}
+	if !sourceValid || sourceArrangement.elementBits != 32 || sourceArrangement.lanes != wantSourceLanes ||
+		!destinationValid || destinationArrangement.elementBits != 64 || destinationArrangement.lanes != 2 {
+		return true, false, fmt.Errorf("arm64 %s operand arrangements are outside Go 1.27's widening optab: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64VectorFloatWidenForm(32, op == "VFCVTL2", ins.Args[0].Reg, ins.Args[1].Reg)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatWidenForm(sourceBits int, upper bool, sourceReg, destinationReg Reg) error {
+	sourceBytes, err := c.loadVReg(sourceReg)
+	if err != nil {
+		return err
+	}
+	physicalLanes := 128 / sourceBits
+	selectedLanes := physicalLanes / 2
+	sourceType, destinationType := "half", "float"
+	if sourceBits == 32 {
+		sourceType, destinationType = "float", "double"
+	}
+	all := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", all, sourceBytes, physicalLanes, sourceType)
+	firstLane := 0
+	if upper {
+		firstLane = selectedLanes
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> <",
+		selected, physicalLanes, sourceType, all, physicalLanes, sourceType, selectedLanes)
+	for lane := 0; lane < selectedLanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", firstLane+lane)
+	}
+	c.b.WriteString(">\n")
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fpext <%d x %s> %%%s to <%d x %s>\n",
+		converted, selectedLanes, sourceType, selected, selectedLanes, destinationType)
+	return c.storeARM64VectorFloat(destinationReg,
+		arm64VectorArrangement{elementBits: sourceBits * 2, lanes: selectedLanes}, "%"+converted)
+}
+
+func (c *arm64Ctx) lowerARM64VectorFMA(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VFMLA" && op != "VFMLS" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, ok := parseARM64VectorArrangement(arg.Reg)
+		if !ok || !((parsed.elementBits == 32 && (parsed.lanes == 2 || parsed.lanes == 4)) || (parsed.elementBits == 64 && parsed.lanes == 2)) {
+			return true, false, fmt.Errorf("arm64 %s accepts only S2, S4, or D2 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	first, err := c.loadARM64VectorFloat(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorFloat(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	addend, err := c.loadARM64VectorFloat(ins.Args[2].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	floatType := "float"
+	if arrangement.elementBits == 64 {
+		floatType = "double"
+	}
+	if op == "VFMLS" {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg <%d x %s> %s\n", negated, arrangement.lanes, floatType, first)
+		first = "%" + negated
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.fma.v%d%s(<%d x %s> %s, <%d x %s> %s, <%d x %s> %s)\n",
+		result, arrangement.lanes, floatType, arrangement.lanes, map[int]string{32: "f32", 64: "f64"}[arrangement.elementBits],
+		arrangement.lanes, floatType, first, arrangement.lanes, floatType, second, arrangement.lanes, floatType, addend)
+	return true, false, c.storeARM64VectorFloat(ins.Args[2].Reg, arrangement, "%"+result)
+}
diff --git a/arm64_lower_float_vector_test.go b/arm64_lower_float_vector_test.go
new file mode 100644
index 000000000..8b77f403f
--- /dev/null
+++ b/arm64_lower_float_vector_test.go
@@ -0,0 +1,701 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorFMACompleteGoAssemblerForms(t *testing.T) {
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, `
+TEXT vectorfmaforms(SB),NOSPLIT,$0-0
+	VFMLA V0.S2, V1.S2, V2.S2
+	VFMLA V3.S4, V4.S4, V5.S4
+	VFMLA V6.D2, V7.D2, V8.D2
+	VFMLS V9.S2, V10.S2, V11.S2
+	VFMLS V12.S4, V13.S4, V14.S4
+	VFMLS V15.D2, V16.D2, V31.D2
+	RET
+`)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorfmaforms": {Name: "vectorfmaforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, want := range []string{"@llvm.fma.v2f32", "@llvm.fma.v4f32", "@llvm.fma.v2f64"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("ARM64 vector FMA for %s omitted %s:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-fma.ll", "arm64-vector-fma.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorFMARejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VFMLA V0.S2, V1.S2",
+		"VFMLS V0.S2, V1.S2, V2.S2, V3.S2",
+		"VFMLA V0.D2, V1.D2, V2.S2",
+		"VFMLA V0.S2, V1.S4, V2.S2",
+		"VFMLS V0.B16, V1.B16, V2.B16",
+		"VFMLS V0.H8, V1.H8, V2.H8",
+		"VFMLA V0.S[0], V1.S2, V2.S2",
+		"VFMLA.P V0.S4, V1.S4, V2.S4",
+	} {
+		file, err := Parse(ArchARM64, "TEXT badvectorfma(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badvectorfma": {Name: "badvectorfma", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's VFMLA/VFMLS optab", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64VectorIntegerAddSubCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT vectorintegeraddsubforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VADD", "VSUB"} {
+		for i, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V" + string(rune('2'+i)) + "." + arrangement + "\n")
+		}
+		src.WriteString("\t" + op + " V12, V30\n")
+		src.WriteString("\t" + op + " V12, V20, V31\n")
+	}
+	src.WriteString("\tRET\n")
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorintegeraddsubforms": {Name: "vectorintegeraddsubforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-add-sub.ll", "arm64-vector-integer-add-sub.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerAddSubRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VADD V0.B8, V1.B8",
+		"VSUB V0.B8, V1.B8, V2.B8, V3.B8",
+		"VADD V0.B8, V1.B16, V2.B8",
+		"VSUB V0.D1, V1.D1, V2.D1",
+		"VADD V0.F4, V1.F4, V2.F4",
+		"VSUB V0.S[0], V1.S2, V2.S2",
+		"VADD V0, V1, V2, V3",
+		"VSUB V0.S4, V1, V2.S4",
+		"VADD.P V0.S4, V1.S4, V2.S4",
+	} {
+		file, err := Parse(ArchARM64, "TEXT badvectorintegeraddsub(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badvectorintegeraddsub": {Name: "badvectorintegeraddsub", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's VADD/VSUB optab", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64AddAcrossCompleteGoAssemblerForms(t *testing.T) {
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, `
+TEXT addacrossforms(SB),NOSPLIT,$0-0
+	VADDV V0.B8, V1
+	VADDV V2.B16, V3
+	VADDV V4.H4, V5
+	VADDV V6.H8, V7
+	VADDV V30.S4, V31
+	RET
+`)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"addacrossforms": {Name: "addacrossforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-add-across.ll", "arm64-add-across.o", ll)
+	}
+}
+
+func TestTranslateARM64AddAcrossRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VADDV V0.B8",
+		"VADDV V0.B8, V1, V2",
+		"VADDV V0.S2, V1",
+		"VADDV V0.D2, V1",
+		"VADDV V0.B16, V1.B16",
+		"VADDV V0, V1",
+		"VADDV.P V0.S4, V1",
+	} {
+		file, err := Parse(ArchARM64, "TEXT badaddacross(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badaddacross": {Name: "badaddacross", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's VADDV optab", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64VectorFloatArithmeticCompleteGoAssemblerForms(t *testing.T) {
+	ops := []string{
+		"VFADD", "VFSUB", "VFMUL", "VFDIV",
+		"VFMAX", "VFMAXNM", "VFMIN", "VFMINNM",
+		"VFADDP", "VFMAXP", "VFMAXNMP", "VFMINP", "VFMINNMP",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT vectorfloatarithmeticforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range ops {
+		for _, arrangement := range []string{"S2", "S4", "D2"} {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorfloatarithmeticforms": {Name: "vectorfloatarithmeticforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-float-arithmetic.ll", "arm64-vector-float-arithmetic.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorFloatArithmeticRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, op := range []string{
+		"VFADD", "VFSUB", "VFMUL", "VFDIV",
+		"VFMAX", "VFMAXNM", "VFMIN", "VFMINNM",
+		"VFADDP", "VFMAXP", "VFMAXNMP", "VFMINP", "VFMINNMP",
+	} {
+		for _, operands := range []string{
+			"V0.S4, V1.S4",
+			"V0.H4, V1.H4, V2.H4",
+			"V0.S2, V1.S4, V2.S2",
+			"V0.S[0], V1.S2, V2.S2",
+		} {
+			instruction := op + " " + operands
+			file, err := Parse(ArchARM64, "TEXT badvectorfloatarithmetic(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorfloatarithmetic": {Name: "badvectorfloatarithmetic", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector floating arithmetic optab", instruction)
+			}
+		}
+	}
+}
+
+func TestTranslateARM64VectorFloatUnaryCompleteGoAssemblerForms(t *testing.T) {
+	ops := []string{
+		"VFABS", "VFNEG", "VFSQRT",
+		"VFRINTN", "VFRINTP", "VFRINTM", "VFRINTZ",
+		"VFCVTZS", "VFCVTZU", "VSCVTF", "VUCVTF",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT vectorfloatunaryforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range ops {
+		for _, arrangement := range []string{"S2", "S4", "D2"} {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorfloatunaryforms": {Name: "vectorfloatunaryforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-float-unary.ll", "arm64-vector-float-unary.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorFloatUnaryRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, op := range []string{
+		"VFABS", "VFNEG", "VFSQRT",
+		"VFRINTN", "VFRINTP", "VFRINTM", "VFRINTZ",
+		"VFCVTZS", "VFCVTZU", "VSCVTF", "VUCVTF",
+	} {
+		for _, operands := range []string{
+			"V0.S4",
+			"V0.H4, V1.H4",
+			"V0.S2, V1.S4",
+			"V0.S[0], V1.S2",
+		} {
+			instruction := op + " " + operands
+			file, err := Parse(ArchARM64, "TEXT badvectorfloatunary(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorfloatunary": {Name: "badvectorfloatunary", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector floating unary optab", instruction)
+			}
+		}
+	}
+}
+
+func TestTranslateARM64VectorShiftRightCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT vectorshiftrightforms(SB),$0-0\n")
+	for _, form := range []struct {
+		arrangement string
+		width       string
+	}{
+		{arrangement: "B8", width: "8"},
+		{arrangement: "B16", width: "8"},
+		{arrangement: "H4", width: "16"},
+		{arrangement: "H8", width: "16"},
+		{arrangement: "S2", width: "32"},
+		{arrangement: "S4", width: "32"},
+		{arrangement: "D2", width: "64"},
+	} {
+		for _, op := range []string{"VUSHR", "VSSHR", "VSRSHR", "VUSRA"} {
+			src.WriteString("\t" + op + " $1, V0." + form.arrangement + ", V1." + form.arrangement + "\n")
+			src.WriteString("\t" + op + " $" + form.width + ", V30." + form.arrangement + ", V31." + form.arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, src.String(), true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorshiftrightforms": {Name: "vectorshiftrightforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-signed-shift-right.ll", "arm64-vector-signed-shift-right.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorShiftRightRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VSSHR V0.S4, V1.S4",
+		"VSSHR $0, V0.S4, V1.S4",
+		"VSSHR $33, V0.S4, V1.S4",
+		"VUSHR $0, V0.B8, V1.B8",
+		"VSRSHR $65, V0.D2, V1.D2",
+		"VUSRA $17, V0.H8, V1.H8",
+		"VSSHR $9, V0.B16, V1.B16",
+		"VSSHR $1, V0.S2, V1.S4",
+		"VSSHR $1, V0.D1, V1.D1",
+		"VSSHR.P $1, V0.S4, V1.S4",
+	} {
+		source := "TEXT badvectorshiftright(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badvectorshiftright": {Name: "badvectorshiftright", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's vector shift-right optab", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64VectorIntegerCompareCompleteGoAssemblerForms(t *testing.T) {
+	arrangements := []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"}
+	var src strings.Builder
+	src.WriteString("TEXT vectorintegercompareforms(SB),$0-0\n")
+	for _, op := range []string{"VCMEQ", "VCMGE", "VCMGT", "VCMHI", "VCMHS"} {
+		for _, arrangement := range arrangements {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	for _, arrangement := range arrangements {
+		src.WriteString("\tVCMTST V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+	}
+	for _, op := range []string{"VCMEQ", "VCMGE", "VCMGT", "VCMLE", "VCMLT"} {
+		for _, arrangement := range arrangements {
+			src.WriteString("\t" + op + " $0, V30." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, src.String(), true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorintegercompareforms": {Name: "vectorintegercompareforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-compare.ll", "arm64-vector-integer-compare.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerCompareRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VCMEQ V0, V1, V2",
+		"VCMEQ V0.S4, V1.S4",
+		"VCMGE V0.S2, V1.S4, V2.S2",
+		"VCMGT V0.D1, V1.D1, V2.D1",
+		"VCMLE V0.S4, V1.S4, V2.S4",
+		"VCMLT V0.S4, V1.S4, V2.S4",
+		"VCMEQ $1, V0.S4, V1.S4",
+		"VCMGT $-1, V0.S4, V1.S4",
+		"VCMHI $0, V0.S4, V1.S4",
+		"VCMHS V0.S4, V1.S4",
+		"VCMLE $0, V0.S2, V1.S4",
+		"VCMLT.P $0, V0.S4, V1.S4",
+		"VCMTST V0.S4, V1.S4",
+		"VCMTST V0.S2, V1.S4, V2.S2",
+		"VCMTST $0, V0.S4, V1.S4",
+	} {
+		source := "TEXT badvectorintegercompare(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badvectorintegercompare": {Name: "badvectorintegercompare", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's vector integer compare optab", instruction)
+		}
+	}
+}
+
+func TestARM64VectorTestBitsRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectortestbits(SB),$0-24
+	MOVD first+0(FP), R0
+	MOVD second+8(FP), R1
+	MOVD output+16(FP), R2
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VCMTST V0.B16, V1.B16, V2.B16
+	VCMTST V0.H8, V1.H8, V3.H8
+	VCMTST V0.S4, V1.S4, V4.S4
+	VCMTST V0.D2, V1.D2, V5.D2
+	VST1 [V2.B16, V3.B16, V4.B16, V5.B16], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"vectortestbits": {
+			Name: "vectortestbits", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void vectortestbits(const uint8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  const uint8_t first[16]  = {1,2,4,8, 1,2,4,8, 1,2,4,8, 1,2,4,8};
+  const uint8_t second[16] = {1,1,1,1, 2,2,2,2, 4,4,4,4, 8,8,8,8};
+  uint8_t got[64] = {0};
+  uint8_t want[64] = {0};
+  vectortestbits(first, second, got);
+  for (int lane = 0; lane < 16; lane++) want[lane] = (first[lane] & second[lane]) ? 255 : 0;
+  for (int width = 2; width <= 8; width *= 2) {
+    int block = width == 2 ? 16 : width == 4 ? 32 : 48;
+    for (int lane = 0; lane < 16 / width; lane++) {
+      int nonzero = 0;
+      for (int byte = 0; byte < width; byte++) nonzero |= first[lane * width + byte] & second[lane * width + byte];
+      memset(want + block + lane * width, nonzero ? 255 : 0, width);
+    }
+  }
+  for (int i = 0; i < 64; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_test_bits", triple, ir, mainC, nil)
+}
+
+func TestTranslateARM64VectorLogicalCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT vectorlogicalforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VAND", "VORR", "VEOR", "VBIC", "VORN", "VBSL", "VBIT", "VBIF"} {
+		for _, arrangement := range []string{"B8", "B16"} {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorlogicalforms": {Name: "vectorlogicalforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-logical.ll", "arm64-vector-logical.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorLogicalRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, op := range []string{"VAND", "VORR", "VEOR", "VBIC", "VORN", "VBSL", "VBIT", "VBIF"} {
+		for _, operands := range []string{
+			"V0.B16, V1.B16",
+			"V0.H8, V1.H8, V2.H8",
+			"V0.B8, V1.B16, V2.B8",
+			"V0, V1, V2",
+		} {
+			instruction := op + " " + operands
+			file, err := Parse(ArchARM64, "TEXT badvectorlogical(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorlogical": {Name: "badvectorlogical", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector logical optab", instruction)
+			}
+		}
+	}
+}
+
+func TestTranslateARM64VectorFloatWidenCompleteGoAssemblerForms(t *testing.T) {
+	const source = `
+TEXT vectorfloatwidenforms(SB),$0-0
+	VFCVTL V0.S2, V31.D2
+	VFCVTL2 V30.S4, V1.D2
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"vectorfloatwidenforms": {Name: "vectorfloatwidenforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(ll, "fpext <2 x float>") {
+			t.Fatalf("ARM64 VFCVTL family omitted vector fpext:\n%s", ll)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-float-widen.ll", "arm64-vector-float-widen.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorFloatWidenRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VFCVTL V0.S2",
+		"VFCVTL V0.S4, V1.D2",
+		"VFCVTL2 V0.S2, V1.D2",
+		"VFCVTL V0.H4, V1.S4",
+		"VFCVTL2 V0.S4, V1.S4",
+		"VFCVTL.P V0.S2, V1.D2",
+	} {
+		file, err := Parse(ArchARM64, "TEXT badvectorfloatwiden(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"badvectorfloatwiden": {Name: "badvectorfloatwiden", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's VFCVTL/VFCVTL2 optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_float_widen_raw.go b/arm64_lower_float_widen_raw.go
new file mode 100644
index 000000000..c2443d313
--- /dev/null
+++ b/arm64_lower_float_widen_raw.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawVectorFloatWiden struct {
+	sourceBits  int
+	upper       bool
+	source      int
+	destination int
+}
+
+func decodeARM64RawVectorFloatWiden(word uint32) (arm64RawVectorFloatWiden, bool) {
+	if word&0xbfbffc00 != 0x0e217800 {
+		return arm64RawVectorFloatWiden{}, false
+	}
+	sourceBits := 16
+	if word&(1<<22) != 0 {
+		sourceBits = 32
+	}
+	return arm64RawVectorFloatWiden{
+		sourceBits:  sourceBits,
+		upper:       word&(1<<30) != 0,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawVectorFloatWiden(form arm64RawVectorFloatWiden) error {
+	return c.lowerARM64VectorFloatWidenForm(form.sourceBits, form.upper,
+		Reg(fmt.Sprintf("V%d", form.source)), Reg(fmt.Sprintf("V%d", form.destination)))
+}
diff --git a/arm64_lower_float_widen_raw_test.go b/arm64_lower_float_widen_raw_test.go
new file mode 100644
index 000000000..a8cf14880
--- /dev/null
+++ b/arm64_lower_float_widen_raw_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawVectorFloatWidenCompleteBaseFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawvectorfloatwidenforms(SB),$0-0\n")
+	for _, size := range []uint32{0, 1 << 22} { // 4H -> 4S and 2S -> 2D.
+		for _, upper := range []uint32{0, 1 << 30} { // FCVTL and FCVTL2.
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", uint32(0x0e217800)|size|upper|30<<5|29)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawvectorfloatwidenforms": {Name: "rawvectorfloatwidenforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fpext <4 x half>", "fpext <2 x float>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw floating widen omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-vector-float-widen.ll", "arm64-raw-vector-float-widen.o", ir)
+		})
+	}
+}
+
+func TestARM64RawVectorFloatWidenDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e217800, // U bit is unallocated for FCVTL.
+		0x0ea17800, // Unallocated size.
+		0x0e216800, // FCVTN, not FCVTL.
+		0x0e217c00, // Adjacent opcode.
+	} {
+		if _, ok := decodeARM64RawVectorFloatWiden(word); ok {
+			t.Fatalf("floating widen decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawVectorFloatWidenRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawvectorfloatwiden(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	ADD $16, R1, R2
+	VLD1 (R0), [V1.H8]
+	WORD $0x0e217822 // FCVTL V1.4H, V2.4S
+	VST1 [V2.S4], (R1)
+	WORD $0x4e217823 // FCVTL2 V1.8H, V3.4S
+	VST1 [V3.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawvectorfloatwiden": {
+				Name: "rawvectorfloatwiden", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawvectorfloatwiden(const uint16_t *, uint32_t *);
+int main(void) {
+  const uint16_t input[8] = {0x3c00,0xc000,0x3800,0x7bff, 0x8000,0x7c00,0xfc00,0x3400};
+  const uint32_t want[8] = {0x3f800000,0xc0000000,0x3f000000,0x477fe000, 0x80000000,0x7f800000,0xff800000,0x3e800000};
+  uint32_t got[8] = {0};
+  rawvectorfloatwiden(input, got);
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_vector_float_widen", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_fma_test.go b/arm64_lower_fma_test.go
new file mode 100644
index 000000000..1916f813c
--- /dev/null
+++ b/arm64_lower_fma_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64FusedMultiplyAddCompleteGoAssemblerForms(t *testing.T) {
+	const source = `TEXT fusedmultiplyaddforms(SB),NOSPLIT,$0-0
+	FMADDS F0, F1, F2, F3
+	FMADDD F4, F5, F6, F7
+	FMSUBS F8, F9, F10, F11
+	FMSUBD F12, F13, F14, F15
+	FNMADDS F16, F17, F18, F19
+	FNMADDD F20, F21, F22, F23
+	FNMSUBS F24, F25, F26, F27
+	FNMSUBD F28, F29, F30, F31
+	RET
+`
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"fusedmultiplyaddforms": {Name: "fusedmultiplyaddforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm64-fused-multiply-add-"+target.name+".ll", "arm64-fused-multiply-add-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64FusedMultiplyAddRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"FMADDS F0, F1, F2",
+		"FMADDD F0, F1, F2, F3, F4",
+		"FMSUBS 8(R0), F1, F2, F3",
+		"FMSUBD F0, R1, F2, F3",
+		"FNMADDS F0, F1, V2, F3",
+		"FNMADDD F0, F1, F2, R3",
+		"FNMSUBS.P F0, F1, F2, F3",
+		"FNMSUBD F32, F1, F2, F3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 fused multiply-add table", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_fmov.go b/arm64_lower_fmov.go
new file mode 100644
index 000000000..9b1657254
--- /dev/null
+++ b/arm64_lower_fmov.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// lowerScalarFloatMove implements the full Go 1.27 FMOVS/FMOVD shape family:
+// floating constants, F<->F, general/zero-register<->F, and F<->memory for
+// stack, symbol, immediate-offset, register-offset, post-index, and pre-index
+// addresses.
+func (c *arm64Ctx) lowerScalarFloatMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	bits := 64
+	switch op {
+	case "FMOVB":
+		bits = 8
+	case "FMOVH":
+		bits = 16
+	case "FMOVS":
+		bits = 32
+	}
+	rawOp := strings.ToUpper(string(ins.Op))
+	postIndex := false
+	preIndex := false
+	switch rawOp {
+	case string(op):
+	case string(op) + ".P":
+		postIndex = true
+	case string(op) + ".W":
+		preIndex = true
+	default:
+		return true, false, fmt.Errorf("arm64 %s accepts only .P or .W memory suffixes: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects exactly 2 operands: %q", op, ins.Raw)
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	srcF := src.Kind == OpReg && isARM64FReg(src.Reg)
+	dstF := dst.Kind == OpReg && isARM64FReg(dst.Reg)
+	srcGP := src.Kind == OpReg && isARM64GeneralOrZeroReg(src.Reg)
+	dstGP := dst.Kind == OpReg && isARM64GeneralOrZeroReg(dst.Reg)
+	srcMem := isARM64ScalarFloatMemory(src)
+	dstMem := isARM64ScalarFloatMemory(dst)
+
+	valid := false
+	switch {
+	case src.Kind == OpImm:
+		valid = dstF
+	case srcF:
+		valid = dstF || dstGP || dstMem
+	case srcGP:
+		valid = dstF
+	case srcMem:
+		valid = dstF
+	}
+	if !valid {
+		return true, false, fmt.Errorf("arm64 %s operands are absent from the Go 1.27 optab: %q", op, ins.Raw)
+	}
+
+	indexedMemory := Operand{}
+	if src.Kind == OpMem {
+		indexedMemory = src
+	} else if dst.Kind == OpMem {
+		indexedMemory = dst
+	}
+	if postIndex || preIndex {
+		if indexedMemory.Kind != OpMem || indexedMemory.Mem.Index != "" {
+			return true, false, fmt.Errorf("arm64 %s .P/.W requires one immediate-offset register memory operand: %q", op, ins.Raw)
+		}
+	}
+	if op == "FMOVS" || op == "FMOVD" {
+		memory := src
+		if dstMem {
+			memory = dst
+		}
+		if memory.Kind == OpSym && sourceSymbolOffsetNeedsContext(memory.Sym) {
+			return true, false, fmt.Errorf("%w: arm64 %s symbol displacement requires generated assembler constants: %q", ErrProbeNeedsContext, op, ins.Raw)
+		}
+	}
+
+	var value string
+	switch {
+	case src.Kind == OpImm:
+		value, err = arm64FloatImmediateBits(src, bits)
+	case srcF || srcGP:
+		value, err = c.loadRegisterWidth(src.Reg, bits)
+	case srcMem:
+		value, err = c.loadScalarFloatMemory(src, bits, postIndex, preIndex)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	value = c.normalizeScalarFloatBits(value, bits)
+
+	switch {
+	case dstF || dstGP:
+		err = c.storeReg(dst.Reg, value)
+	case dstMem:
+		err = c.storeScalarFloatMemory(dst, bits, postIndex, preIndex, value)
+	}
+	return true, false, err
+}
+
+func isARM64FReg(r Reg) bool {
+	_, ok := arm64ParseFReg(r)
+	return ok
+}
+
+func isARM64GeneralOrZeroReg(r Reg) bool {
+	if r == ZR {
+		return true
+	}
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "R") {
+		return false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "R"))
+	return err == nil && n >= 0 && n <= 30
+}
+
+func isARM64ScalarFloatMemory(op Operand) bool {
+	switch op.Kind {
+	case OpFP, OpMem, OpSym:
+		return op.Kind != OpSym || !strings.HasPrefix(strings.TrimSpace(op.Sym), "$")
+	default:
+		return false
+	}
+}
+
+func arm64FloatImmediateBits(op Operand, bits int) (string, error) {
+	if op.ImmRaw != "" {
+		return "", fmt.Errorf("arm64: unresolved floating immediate %s", op.String())
+	}
+	if op.Imm == 0 {
+		return "0", nil
+	}
+	value := math.Float64frombits(uint64(op.Imm))
+	if bits == 32 {
+		return strconv.FormatUint(uint64(math.Float32bits(float32(value))), 10), nil
+	}
+	return strconv.FormatUint(uint64(op.Imm), 10), nil
+}
+
+func (c *arm64Ctx) normalizeScalarFloatBits(value string, bits int) string {
+	if bits == 64 {
+		return value
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, value, bits)
+	wide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i64\n", wide, bits, narrow)
+	return "%" + wide
+}
+
+func (c *arm64Ctx) loadScalarFloatMemory(op Operand, bits int, postIndex, preIndex bool) (string, error) {
+	switch op.Kind {
+	case OpFP:
+		return c.evalFPValue64(op)
+	case OpSym:
+		ptr, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return "", err
+		}
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", loaded, bits, ptr)
+		if bits == 64 {
+			return "%" + loaded, nil
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i64\n", wide, bits, loaded)
+		return "%" + wide, nil
+	case OpMem:
+		value, err := c.loadMem(op.Mem, bits, postIndex)
+		if err != nil {
+			return "", err
+		}
+		if preIndex {
+			if err := c.updatePostInc(op.Mem.Base, op.Mem.Off); err != nil {
+				return "", err
+			}
+		}
+		return value, nil
+	default:
+		return "", fmt.Errorf("arm64: unsupported scalar floating load %s", op.String())
+	}
+}
+
+func (c *arm64Ctx) storeScalarFloatMemory(op Operand, bits int, postIndex, preIndex bool, value string) error {
+	switch op.Kind {
+	case OpFP:
+		return c.storeFPResult64(op.FPOffset, value)
+	case OpSym:
+		ptr, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return err
+		}
+		if bits == 64 {
+			fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", value, ptr)
+			return nil
+		}
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, value, bits)
+		fmt.Fprintf(c.b, "  store i%d %%%s, ptr %s, align 1\n", bits, narrow, ptr)
+		return nil
+	case OpMem:
+		if err := c.storeMem(op.Mem, bits, postIndex, value); err != nil {
+			return err
+		}
+		if preIndex {
+			return c.updatePostInc(op.Mem.Base, op.Mem.Off)
+		}
+		return nil
+	default:
+		return fmt.Errorf("arm64: unsupported scalar floating store %s", op.String())
+	}
+}
diff --git a/arm64_lower_fmovq.go b/arm64_lower_fmovq.go
new file mode 100644
index 000000000..6e0aa3fde
--- /dev/null
+++ b/arm64_lower_fmovq.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import "fmt"
+
+// loadFMOVQFrame reconstructs the 16 contiguous bytes addressed by off(FP)
+// from the scalar LLVM fields used to model Go parameters and results.
+func (c *arm64Ctx) loadFMOVQFrame(off int64) (string, error) {
+	packed, err := c.loadFPFrameBits(off, 16)
+	if err != nil {
+		return "", err
+	}
+	vector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i128 %s to <16 x i8>\n", vector, packed)
+	return "%" + vector, nil
+}
+
+// storeFMOVQFrame splits a vector into the scalar LLVM frame slots that cover
+// the 16 contiguous bytes addressed by off(FP).
+func (c *arm64Ctx) storeFMOVQFrame(off int64, value string) error {
+	packed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to i128\n", packed, value)
+	return c.storeFPFrameBits(off, 16, "%"+packed)
+}
diff --git a/arm64_lower_fmovq_frame_test.go b/arm64_lower_fmovq_frame_test.go
new file mode 100644
index 000000000..1baa028dd
--- /dev/null
+++ b/arm64_lower_fmovq_frame_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64FMOVQCompleteFPFrameForms(t *testing.T) {
+	tests := []struct {
+		name   string
+		source string
+		sig    FuncSig
+		loads  int
+		stores int
+	}{
+		{
+			name: "two uint64 lanes",
+			source: `TEXT fmovqwords(SB),$0-32
+	FMOVQ value+0(FP), F0
+	FMOVQ F0, ret+16(FP)
+	RET
+`,
+			sig: FuncSig{
+				Name: "fmovqwords", Args: []LLVMType{"[2 x i64]"}, Ret: LLVMType("{ i64, i64 }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: 0, Fields: []int{0}},
+						{Offset: 8, Type: I64, Index: 0, Field: 1, Fields: []int{1}},
+					},
+					Results: []FrameSlot{
+						{Offset: 16, Type: I64, Index: 0, Field: -1},
+						{Offset: 24, Type: I64, Index: 1, Field: -1},
+					},
+				},
+			},
+			loads: 2, stores: 2,
+		},
+		{
+			name: "four float32 lanes",
+			source: `TEXT fmovqfloats(SB),$0-32
+	FMOVQ value+0(FP), F1
+	FMOVQ F1, ret+16(FP)
+	RET
+`,
+			sig: FuncSig{
+				Name: "fmovqfloats", Args: []LLVMType{"[4 x float]"}, Ret: LLVMType("{ float, float, float, float }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: LLVMType("float"), Index: 0, Field: 0, Fields: []int{0}},
+						{Offset: 4, Type: LLVMType("float"), Index: 0, Field: 1, Fields: []int{1}},
+						{Offset: 8, Type: LLVMType("float"), Index: 0, Field: 2, Fields: []int{2}},
+						{Offset: 12, Type: LLVMType("float"), Index: 0, Field: 3, Fields: []int{3}},
+					},
+					Results: []FrameSlot{
+						{Offset: 16, Type: LLVMType("float"), Index: 0, Field: -1},
+						{Offset: 20, Type: LLVMType("float"), Index: 1, Field: -1},
+						{Offset: 24, Type: LLVMType("float"), Index: 2, Field: -1},
+						{Offset: 28, Type: LLVMType("float"), Index: 3, Field: -1},
+					},
+				},
+			},
+			loads: 4, stores: 4,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, test.source, true)
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{test.sig.Name: test.sig},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ir, "extractvalue"); got < test.loads {
+				t.Fatalf("FMOVQ frame load emitted %d extractvalue operations, want at least %d:\n%s", got, test.loads, ir)
+			}
+			if got := strings.Count(ir, "store "); got < test.stores {
+				t.Fatalf("FMOVQ frame store emitted %d stores, want at least %d:\n%s", got, test.stores, ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-fmovq-frame.ll", "arm64-fmovq-frame.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_fpops.go b/arm64_lower_fpops.go
index 485d41a85..2434f7474 100644
--- a/arm64_lower_fpops.go
+++ b/arm64_lower_fpops.go
@@ -7,252 +7,204 @@ import (
 	"strings"
 )
 
-func (c *arm64Ctx) lowerFP(op Op, ins Instr) (ok bool, terminated bool, err error) {
-	switch op {
-	case "FMOVD":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm64 FMOVD expects 2 operands: %q", ins.Raw)
-		}
-		bits, err := c.evalFMOVDBits(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		switch ins.Args[1].Kind {
-		case OpReg:
-			return true, false, c.storeReg(ins.Args[1].Reg, bits)
-		case OpFP:
-			return true, false, c.storeFPResult64(ins.Args[1].FPOffset, bits)
-		default:
-			return true, false, fmt.Errorf("arm64 FMOVD unsupported dst: %q", ins.Raw)
-		}
+func (c *arm64Ctx) lowerARM64ScalarFloatUnary(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	operations := map[Op]string{
+		"FABSS": "fabs", "FABSD": "fabs",
+		"FNEGS": "neg", "FNEGD": "neg",
+		"FSQRTS": "sqrt", "FSQRTD": "sqrt",
+		"FRINTNS": "roundeven", "FRINTND": "roundeven",
+		"FRINTPS": "ceil", "FRINTPD": "ceil",
+		"FRINTMS": "floor", "FRINTMD": "floor",
+		"FRINTZS": "trunc", "FRINTZD": "trunc",
+		"FRINTAS": "round", "FRINTAD": "round",
+		"FRINTXS": "rint", "FRINTXD": "rint",
+		"FRINTIS": "nearbyint", "FRINTID": "nearbyint",
+	}
+	operation, handled := operations[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || !isARM64FReg(ins.Args[0].Reg) ||
+		ins.Args[1].Kind != OpReg || !isARM64FReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 %s expects Fsrc, Fdst and no suffix: %q", op, ins.Raw)
+	}
+	bits := 64
+	floatType := "double"
+	intrinsicSuffix := "f64"
+	if strings.HasSuffix(string(op), "S") {
+		bits = 32
+		floatType = "float"
+		intrinsicSuffix = "f32"
+	}
+	source, err := c.loadARM64ScalarFloatReg(ins.Args[0].Reg, bits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if operation == "neg" {
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", result, floatType, source)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %s)\n", result, floatType, operation, intrinsicSuffix, floatType, source)
+	}
+	return true, false, c.storeARM64ScalarFloatReg(ins.Args[1].Reg, bits, "%"+result)
+}
 
-	case "FCMPD":
-		// FCMPD src, dst => compare dst ? src (same operand order convention as CMP/SUB).
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm64 FCMPD expects 2 operands: %q", ins.Raw)
-		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		dst, err := c.evalF64(ins.Args[1])
+func (c *arm64Ctx) lowerFP(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if form, matched, err := parseARM64ScalarConversion(op, ins); matched {
 		if err != nil {
 			return true, false, err
 		}
-		eq := c.newTmp()
-		lt := c.newTmp()
-		gt := c.newTmp()
-		uno := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fcmp oeq double %s, %s\n", eq, dst, src)
-		fmt.Fprintf(c.b, "  %%%s = fcmp olt double %s, %s\n", lt, dst, src)
-		fmt.Fprintf(c.b, "  %%%s = fcmp ogt double %s, %s\n", gt, dst, src)
-		fmt.Fprintf(c.b, "  %%%s = fcmp uno double %s, %s\n", uno, dst, src)
-		// AArch64 FCMP flags model:
-		// - unordered: N=0 Z=0 C=1 V=1
-		// - lt: N=1 Z=0 C=0 V=0
-		// - eq: N=0 Z=1 C=1 V=0
-		// - gt: N=0 Z=0 C=1 V=0
-		c01 := c.newTmp()
-		cf := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", c01, gt, eq)
-		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %%%s\n", cf, c01, uno)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", lt, c.flagsNSlot)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", eq, c.flagsZSlot)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", cf, c.flagsCSlot)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", uno, c.flagsVSlot)
-		c.flagsWritten = true
-		return true, false, nil
+		return true, false, c.lowerARM64ScalarConversion(form)
+	}
+	if ok, terminated, err := c.lowerARM64ScalarFloatCompare(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64FloatConditionalCompare(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarFloatBinary(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64ScalarFloatUnary(op, ins); ok {
+		return ok, terminated, err
+	}
+	switch op {
+	case "FMOVB", "FMOVH", "FMOVS", "FMOVD":
+		return c.lowerScalarFloatMove(op, ins)
 
-	case "FCSELD":
-		// FCSELD cond, a, b, dst
-		if len(ins.Args) != 4 || ins.Args[0].Kind != OpIdent {
-			return true, false, fmt.Errorf("arm64 FCSELD expects cond, a, b, dst: %q", ins.Raw)
-		}
-		a, err := c.evalF64(ins.Args[1])
+	case "FCVTSD", "FCVTDS", "FCVTSH", "FCVTHS", "FCVTDH", "FCVTHD":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+			ins.Args[0].Kind != OpReg || !isARM64FReg(ins.Args[0].Reg) ||
+			ins.Args[1].Kind != OpReg || !isARM64FReg(ins.Args[1].Reg) {
+			return true, false, fmt.Errorf("arm64 %s expects Fsrc, Fdst and no suffix: %q", op, ins.Raw)
+		}
+		conversionWidths := map[Op][2]int{
+			"FCVTSD": {32, 64},
+			"FCVTDS": {64, 32},
+			"FCVTSH": {32, 16},
+			"FCVTHS": {16, 32},
+			"FCVTDH": {64, 16},
+			"FCVTHD": {16, 64},
+		}
+		sourceBits := conversionWidths[op][0]
+		destinationBits := conversionWidths[op][1]
+		source, err := c.loadARM64ScalarFloatReg(ins.Args[0].Reg, sourceBits)
 		if err != nil {
 			return true, false, err
 		}
-		bv, err := c.evalF64(ins.Args[2])
-		if err != nil {
-			return true, false, err
-		}
-		cv, err := c.condValue(ins.Args[0].Ident)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = select i1 %s, double %s, double %s\n", t, cv, a, bv)
-		return true, false, c.storeF64(ins.Args[3], "%"+t)
-
-	case "FADDD", "FSUBD", "FMULD", "FDIVD", "FMAXD", "FMIND":
-		var src, dst string
-		var dstOp Operand
-		switch len(ins.Args) {
-		case 2:
-			src, err = c.evalF64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			dst, err = c.evalF64(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			dstOp = ins.Args[1]
-		case 3:
-			src, err = c.evalF64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			dst, err = c.evalF64(ins.Args[1])
-			if err != nil {
-				return true, false, err
+		converted := c.newTmp()
+		llvmFloatType := func(bits int) string {
+			switch bits {
+			case 16:
+				return "half"
+			case 32:
+				return "float"
+			default:
+				return "double"
 			}
-			dstOp = ins.Args[2]
-		default:
-			return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
 		}
-		t := c.newTmp()
-		switch op {
-		case "FADDD":
-			fmt.Fprintf(c.b, "  %%%s = fadd double %s, %s\n", t, dst, src)
-		case "FSUBD":
-			fmt.Fprintf(c.b, "  %%%s = fsub double %s, %s\n", t, dst, src)
-		case "FMULD":
-			fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", t, dst, src)
-		case "FDIVD":
-			fmt.Fprintf(c.b, "  %%%s = fdiv double %s, %s\n", t, dst, src)
-		case "FMAXD":
-			fmt.Fprintf(c.b, "  %%%s = call double @llvm.maxnum.f64(double %s, double %s)\n", t, dst, src)
-		case "FMIND":
-			fmt.Fprintf(c.b, "  %%%s = call double @llvm.minnum.f64(double %s, double %s)\n", t, dst, src)
+		sourceType := llvmFloatType(sourceBits)
+		destinationType := llvmFloatType(destinationBits)
+		if sourceBits < destinationBits {
+			fmt.Fprintf(c.b, "  %%%s = fpext %s %s to %s\n", converted, sourceType, source, destinationType)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = fptrunc %s %s to %s\n", converted, sourceType, source, destinationType)
 		}
-		return true, false, c.storeF64(dstOp, "%"+t)
+		return true, false, c.storeARM64ScalarFloatReg(ins.Args[1].Reg, destinationBits, "%"+converted)
 
-	case "FMADDD", "FMSUBD", "FNMSUBD":
-		// {FMA,FMSUB,FNMSUB}D a, b, c, dst
-		if len(ins.Args) != 4 {
-			return true, false, fmt.Errorf("arm64 %s expects 4 operands: %q", op, ins.Raw)
+	case "FCSELS", "FCSELD":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+			return true, false, fmt.Errorf("arm64 %s expects condition, Fsrc, Fsrc, Fdst and no suffix: %q", op, ins.Raw)
 		}
-		a, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.evalF64(ins.Args[1])
-		if err != nil {
-			return true, false, err
+		condition, conditionOK := arm64ConditionOperand(ins.Args[0])
+		if !conditionOK {
+			return true, false, fmt.Errorf("arm64 %s expects a condition operand: %q", op, ins.Raw)
 		}
-		cv, err := c.evalF64(ins.Args[2])
-		if err != nil {
-			return true, false, err
-		}
-		m := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", m, a, cv)
-		t := c.newTmp()
-		switch op {
-		case "FMADDD":
-			// b + a*c
-			fmt.Fprintf(c.b, "  %%%s = fadd double %s, %%%s\n", t, b, m)
-		case "FMSUBD":
-			// b - a*c
-			fmt.Fprintf(c.b, "  %%%s = fsub double %s, %%%s\n", t, b, m)
-		case "FNMSUBD":
-			// a*c - b
-			fmt.Fprintf(c.b, "  %%%s = fsub double %%%s, %s\n", t, m, b)
-		}
-		return true, false, c.storeF64(ins.Args[3], "%"+t)
-
-	case "FNMULD":
-		// FNMULD src, dst (or src1, src2, dst): dst = -(dst*src) or -(src2*src1).
-		var src, dst string
-		var dstOp Operand
-		switch len(ins.Args) {
-		case 2:
-			src, err = c.evalF64(ins.Args[0])
-			if err != nil {
-				return true, false, err
+		for _, operand := range ins.Args[1:] {
+			if operand.Kind != OpReg || !isARM64FReg(operand.Reg) {
+				return true, false, fmt.Errorf("arm64 %s accepts only scalar floating registers: %q", op, ins.Raw)
 			}
-			dst, err = c.evalF64(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			dstOp = ins.Args[1]
-		case 3:
-			src, err = c.evalF64(ins.Args[0])
-			if err != nil {
-				return true, false, err
-			}
-			dst, err = c.evalF64(ins.Args[1])
-			if err != nil {
-				return true, false, err
-			}
-			dstOp = ins.Args[2]
-		default:
-			return true, false, fmt.Errorf("arm64 FNMULD expects 2 or 3 operands: %q", ins.Raw)
 		}
-		m := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fmul double %s, %s\n", m, dst, src)
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fneg double %%%s\n", t, m)
-		return true, false, c.storeF64(dstOp, "%"+t)
+		bits := 32
+		if op == "FCSELD" {
+			bits = 64
+		}
+		return true, false, c.lowerARM64FloatSelectValues(
+			bits,
+			condition,
+			ins.Args[1].Reg,
+			ins.Args[2].Reg,
+			ins.Args[3].Reg,
+		)
 
-	case "FABSD":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm64 FABSD expects 2 operands: %q", ins.Raw)
-		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call double @llvm.fabs.f64(double %s)\n", t, src)
-		return true, false, c.storeF64(ins.Args[1], "%"+t)
+	case "FMADDS", "FMADDD", "FMSUBS", "FMSUBD",
+		"FNMADDS", "FNMADDD", "FNMSUBS", "FNMSUBD":
+		return c.lowerFusedMultiplyAdd(op, ins)
+	}
+	return false, false, nil
+}
 
-	case "FRINTZD", "FRINTMD", "FRINTPD":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm64 %s expects 2 operands: %q", op, ins.Raw)
+func (c *arm64Ctx) lowerFusedMultiplyAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects four F-register operands and no suffixes: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s expects four F-register operands: %q", op, ins.Raw)
 		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
+		if _, ok := arm64ParseFReg(arg.Reg); !ok {
+			return true, false, fmt.Errorf("arm64 %s expects four F-register operands: %q", op, ins.Raw)
 		}
-		t := c.newTmp()
-		switch op {
-		case "FRINTZD":
-			fmt.Fprintf(c.b, "  %%%s = call double @llvm.trunc.f64(double %s)\n", t, src)
-		case "FRINTMD":
-			fmt.Fprintf(c.b, "  %%%s = call double @llvm.floor.f64(double %s)\n", t, src)
-		case "FRINTPD":
-			fmt.Fprintf(c.b, "  %%%s = call double @llvm.ceil.f64(double %s)\n", t, src)
-		}
-		return true, false, c.storeF64(ins.Args[1], "%"+t)
+	}
 
-	case "FCVTZSD":
-		// FCVTZSD src, dstReg
-		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 FCVTZSD expects src, dstReg: %q", ins.Raw)
-		}
-		src, err := c.evalF64(ins.Args[0])
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = fptosi double %s to i64\n", t, src)
-		return true, false, c.storeReg(ins.Args[1].Reg, "%"+t)
+	floatType := "double"
+	intrinsic := "@llvm.fma.f64"
+	eval := c.evalF64
+	store := c.storeF64
+	if strings.HasSuffix(string(op), "S") {
+		floatType = "float"
+		intrinsic = "@llvm.fma.f32"
+		eval = c.evalF32
+		store = c.storeF32
+	}
 
-	case "SCVTFD":
-		// SCVTFD srcReg, dst
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 SCVTFD expects srcReg, dst: %q", ins.Raw)
-		}
-		src, err := c.loadReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = sitofp i64 %s to double\n", t, src)
-		return true, false, c.storeF64(ins.Args[1], "%"+t)
+	// Go's Plan 9 order is Fm, Fa, Fn, Fd. The architectural operations are:
+	//   FMADD:   Fn*Fm + Fa       FMSUB:  Fa - Fn*Fm
+	//   FNMADD: -(Fn*Fm + Fa)     FNMSUB: Fn*Fm - Fa
+	fm, err := eval(ins.Args[0])
+	if err != nil {
+		return true, false, err
 	}
-	return false, false, nil
+	fa, err := eval(ins.Args[1])
+	if err != nil {
+		return true, false, err
+	}
+	fn, err := eval(ins.Args[2])
+	if err != nil {
+		return true, false, err
+	}
+
+	if strings.HasPrefix(string(op), "FMSUB") {
+		negFM := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negFM, floatType, fm)
+		fm = "%" + negFM
+	} else if strings.HasPrefix(string(op), "FNMSUB") {
+		negFA := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negFA, floatType, fa)
+		fa = "%" + negFA
+	}
+
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s %s(%s %s, %s %s, %s %s)\n",
+		result, floatType, intrinsic, floatType, fm, floatType, fn, floatType, fa)
+	value := "%" + result
+	if strings.HasPrefix(string(op), "FNMADD") {
+		negResult := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negResult, floatType, value)
+		value = "%" + negResult
+	}
+	return true, false, store(ins.Args[3], value)
 }
 
 func (c *arm64Ctx) evalFMOVDBits(op Operand) (string, error) {
@@ -295,16 +247,9 @@ func (c *arm64Ctx) evalF64(op Operand) (string, error) {
 		if !ok {
 			return "", fmt.Errorf("arm64: unsupported FP param slot: %s", op.String())
 		}
-		idx := slot.Index
-		if idx < 0 || idx >= len(c.sig.Args) {
-			return "", fmt.Errorf("arm64: FP slot %s invalid arg index %d", op.String(), idx)
-		}
-		arg := fmt.Sprintf("%%arg%d", idx)
-		if slot.Field >= 0 {
-			aggTy := c.sig.Args[idx]
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, aggTy, arg, slot.Field)
-			arg = "%" + t
+		arg, err := c.loadFPParameter(slot)
+		if err != nil {
+			return "", err
 		}
 		switch slot.Type {
 		case LLVMType("double"):
@@ -337,6 +282,21 @@ func (c *arm64Ctx) evalF64(op Operand) (string, error) {
 	}
 }
 
+func (c *arm64Ctx) evalF32(op Operand) (string, error) {
+	if op.Kind != OpReg {
+		return "", fmt.Errorf("arm64: unsupported f32 operand %s", op.String())
+	}
+	v64, err := c.loadRegisterWidth(op.Reg, 32)
+	if err != nil {
+		return "", err
+	}
+	v32 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", v32, v64)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", value, v32)
+	return "%" + value, nil
+}
+
 func (c *arm64Ctx) storeF64(dst Operand, v string) error {
 	switch dst.Kind {
 	case OpReg:
@@ -352,6 +312,17 @@ func (c *arm64Ctx) storeF64(dst Operand, v string) error {
 	}
 }
 
+func (c *arm64Ctx) storeF32(dst Operand, v string) error {
+	if dst.Kind != OpReg {
+		return fmt.Errorf("arm64: unsupported f32 dst operand %s", dst.String())
+	}
+	bits32 := c.newTmp()
+	bits64 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits32, v)
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", bits64, bits32)
+	return c.storeReg(dst.Reg, "%"+bits64)
+}
+
 func arm64ParseDollarFloat(sym string) (float64, bool) {
 	if !strings.HasPrefix(sym, "$") {
 		return 0, false
diff --git a/arm64_lower_halving_add.go b/arm64_lower_halving_add.go
new file mode 100644
index 000000000..c7f236236
--- /dev/null
+++ b/arm64_lower_halving_add.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64HalvingAddSubSpec struct {
+	signed   bool
+	rounding bool
+	subtract bool
+}
+
+func (c *arm64Ctx) lowerARM64VectorHalvingAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, handled := map[Op]arm64HalvingAddSubSpec{
+		"VSHADD":  {signed: true},
+		"VSRHADD": {signed: true, rounding: true},
+		"VUHADD":  {},
+		"VURHADD": {rounding: true},
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits == 64 && parsed.lanes != 2 {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8/B16/H4/H8/S2/S4/D2 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.lowerARM64VectorHalvingAddSubForm(spec, arrangement, first, second, ins.Args[2].Reg)
+}
+
+func (c *arm64Ctx) lowerARM64VectorHalvingAddSubForm(
+	spec arm64HalvingAddSubSpec,
+	arrangement arm64VectorArrangement,
+	first string,
+	second string,
+	destination Reg,
+) error {
+	narrowType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	wideArrangement := arm64VectorArrangement{elementBits: arrangement.elementBits * 2, lanes: arrangement.lanes}
+	wideType := fmt.Sprintf("<%d x i%d>", wideArrangement.lanes, wideArrangement.elementBits)
+	extension := "zext"
+	shift := "lshr"
+	if spec.signed {
+		extension = "sext"
+		shift = "ashr"
+	}
+	wideFirst := c.newTmp()
+	wideSecond := c.newTmp()
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideFirst, extension, narrowType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideSecond, extension, narrowType, second, wideType)
+	operation := "add"
+	if spec.subtract {
+		operation = "sub"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %%%s\n", combined, operation, wideType, wideFirst, wideSecond)
+	shiftSource := "%" + combined
+	if spec.rounding {
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", rounded, wideType, shiftSource, arm64VectorIntegerSplat(wideArrangement, 1))
+		shiftSource = "%" + rounded
+	}
+	halved := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", halved, shift, wideType, shiftSource, arm64VectorIntegerSplat(wideArrangement, 1))
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, halved, narrowType)
+	return c.storeARM64VectorInteger(destination, arrangement, "%"+result)
+}
diff --git a/arm64_lower_halving_add_test.go b/arm64_lower_halving_add_test.go
new file mode 100644
index 000000000..174cd56f3
--- /dev/null
+++ b/arm64_lower_halving_add_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorHalvingAddCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorHalvingAddForms(SB), $0-0\n")
+	for _, op := range []string{"VSHADD", "VSRHADD", "VUHADD", "VURHADD"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorHalvingAddForms": {Name: "vectorHalvingAddForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"sext <", "zext <", "ashr <", "lshr <", "trunc <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s halving-add IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-halving-add.ll", "arm64-vector-halving-add.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorHalvingAddRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSHADD V0.B8, V1.B8",
+		"VSRHADD V0.B8, V1.B16, V2.B8",
+		"VUHADD V0.D1, V1.D1, V2.D1",
+		"VURHADD V0.S4, V1.S4, V2.S2",
+		"VURHADD.P V0.H8, V1.H8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorHalvingAdd(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorHalvingAdd": {Name: "badVectorHalvingAdd", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector halving-add forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_hint.go b/arm64_lower_hint.go
new file mode 100644
index 000000000..527c4b3d3
--- /dev/null
+++ b/arm64_lower_hint.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64Hint(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	pointerAuthHints := map[Op]uint8{
+		"PACIASP":   25,
+		"PACIBSP":   27,
+		"AUTIASP":   29,
+		"AUTIBSP":   31,
+		"AUTIA1716": 12,
+		"AUTIB1716": 14,
+	}
+	_, pointerAuthHint := pointerAuthHints[op]
+	if op != "HINT" && op != "YIELD" && op != "WFE" && op != "WFI" && op != "SEV" && op != "SEVL" && op != "NOP" && op != "NOOP" && op != "BTI" && !pointerAuthHint {
+		return false, false, nil
+	}
+	if pointerAuthHint {
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 %s takes no operands or suffix: %q", op, ins.Raw)
+		}
+		c.emitARM64Hint(pointerAuthHints[op])
+		return true, false, nil
+	}
+	if op == "BTI" {
+		if strings.ToUpper(string(ins.Op)) != "BTI" || len(ins.Args) != 1 || ins.Args[0].Kind != OpIdent {
+			return true, false, fmt.Errorf("arm64 BTI expects C, J, or JC and no suffix: %q", ins.Raw)
+		}
+		immediate, valid := map[string]uint8{"C": 34, "J": 36, "JC": 38}[strings.ToUpper(ins.Args[0].Ident)]
+		if !valid {
+			return true, false, fmt.Errorf("arm64 BTI target type must be C, J, or JC: %q", ins.Raw)
+		}
+		c.emitARM64Hint(immediate)
+		return true, false, nil
+	}
+	if op == "NOOP" {
+		if strings.ToUpper(string(ins.Op)) != "NOOP" || len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 NOOP takes no operands or suffix: %q", ins.Raw)
+		}
+		c.emitARM64Hint(0)
+		return true, false, nil
+	}
+	if op == "NOP" {
+		if strings.ToUpper(string(ins.Op)) != "NOP" || len(ins.Args) > 1 {
+			return true, false, fmt.Errorf("arm64 NOP accepts no operand or one C_LCON/R/ZR/V operand, with no suffix: %q", ins.Raw)
+		}
+		if len(ins.Args) == 1 {
+			operand := ins.Args[0]
+			valid := operand.Kind == OpImm && operand.ImmRaw == "" && arm64GoLCON(operand.Imm)
+			if operand.Kind == OpReg {
+				_, vector := arm64ParseVReg(operand.Reg)
+				valid = isARM64GeneralOrZeroReg(operand.Reg) || vector
+			}
+			if !valid {
+				return true, false, fmt.Errorf("arm64 NOP operand is outside Go's C_LCON/C_ZREG/C_VREG rows: %q", ins.Raw)
+			}
+		}
+		// Go's NOP pseudo-instruction intentionally emits no machine code.
+		return true, false, nil
+	}
+	rawOp := strings.ToUpper(string(ins.Op))
+	if op == "HINT" {
+		if rawOp != "HINT" || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+			return true, false, fmt.Errorf("arm64 HINT takes one resolved integer constant and no suffix: %q", ins.Raw)
+		}
+		c.emitARM64Hint(uint8(ins.Args[0].Imm & 0x7f))
+		return true, false, nil
+	}
+	if rawOp != string(op) || len(ins.Args) != 0 {
+		return true, false, fmt.Errorf("arm64 %s takes no operands or suffix: %q", op, ins.Raw)
+	}
+	mnemonics := map[Op]string{
+		"YIELD": "yield",
+		"WFE":   "wfe",
+		"WFI":   "wfi",
+		"SEV":   "sev",
+		"SEVL":  "sevl",
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, \"\"()\n", mnemonics[op])
+	return true, false, nil
+}
+
+func decodeARM64RawHint(word uint32) (uint8, bool) {
+	const immediateMask = uint32(0x7f << 5)
+	if word&^immediateMask != 0xd503201f {
+		return 0, false
+	}
+	return uint8(word >> 5 & 0x7f), true
+}
+
+func (c *arm64Ctx) emitARM64Hint(immediate uint8) {
+	fmt.Fprintf(c.b, "  call void asm sideeffect \"hint #%d\", \"\"()\n", immediate&0x7f)
+}
+
+// arm64GoLCON reports whether conclass(v, 64) can satisfy Go's C_LCON
+// operand row. Only C_VCON falls outside that row; all earlier constant
+// classes are compatible with it.
+func arm64GoLCON(value int64) bool {
+	if value == 0 || arm64GoAddConstant(value) || arm64GoMoveConstant(value) ||
+		arm64GoMoveConstant(^value) || arm64GoBitConstant(uint64(value)) ||
+		(value >= 0 && value <= 0xffffff) {
+		return true
+	}
+	return uint64(value) == uint64(uint32(value)) || value == int64(int32(value))
+}
+
+func arm64GoAddConstant(value int64) bool {
+	if value < 0 {
+		return false
+	}
+	if value&0xfff == 0 {
+		value >>= 12
+	}
+	return value <= 0xfff
+}
+
+func arm64GoMoveConstant(value int64) bool {
+	bits := uint64(value)
+	for shift := uint(0); shift < 64; shift += 16 {
+		if bits&^(uint64(0xffff)<<shift) == 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func arm64GoBitConstant(value uint64) bool {
+	if value == ^uint64(0) || value == 0 {
+		return false
+	}
+	switch {
+	case value != value>>32|value<<32:
+	case value != value>>16|value<<48:
+		value = uint64(int64(int32(value)))
+	case value != value>>8|value<<56:
+		value = uint64(int64(int16(value)))
+	case value != value>>4|value<<60:
+		value = uint64(int64(int8(value)))
+	default:
+		return true
+	}
+	return arm64SequenceOfOnes(value) || arm64SequenceOfOnes(^value)
+}
+
+func arm64SequenceOfOnes(value uint64) bool {
+	next := value + (value & -value)
+	return (next-1)&next == 0
+}
diff --git a/arm64_lower_hint_test.go b/arm64_lower_hint_test.go
new file mode 100644
index 000000000..9008b2d8a
--- /dev/null
+++ b/arm64_lower_hint_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64YieldCompleteGoAssemblerForms(t *testing.T) {
+	source := "TEXT yieldform(SB),$0-0\n\tYIELD\n\tRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"yieldform": {Name: "yieldform", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, `asm sideeffect "yield"`) {
+				t.Fatalf("ARM64 YIELD was silently discarded for %s:\n%s", triple, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-yield.ll", "arm64-yield.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64HintFamilyCompleteGoAssemblerForms(t *testing.T) {
+	source := `
+TEXT hintforms(SB),$0-0
+	HINT $0
+	HINT $6
+	HINT $127
+	HINT $128
+	HINT $-1
+	HINT $0x1122334455667788
+	YIELD
+	WFE
+	WFI
+	SEV
+	SEVL
+	WORD $0xd503203f
+	WORD $0xd503205f
+	WORD $0xd503207f
+	WORD $0xd503209f
+	WORD $0xd50320bf
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"hintforms": {Name: "hintforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"hint #0"`, `"hint #6"`, `"hint #127"`, `"yield"`, `"wfe"`, `"wfi"`, `"sev"`, `"sevl"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 hint family omitted %s for %s:\n%s", want, triple, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-hints.ll", "arm64-hints.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64HintRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{"HINT", "HINT R0", "HINT $1, $2", "HINT.P $1", "WFE $0", "WFI R0", "SEV $1", "SEVL.P"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's hint forms", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64YieldRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{"YIELD $0", "YIELD R0", "YIELD.P"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's YIELD forms", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64NOPMatchesGoAssemblerForms(t *testing.T) {
+	source := `
+TEXT nopform(SB),$0-0
+	NOP
+	NOP $0
+	NOP $4294967295
+	NOP $4294967296
+	NOP R0
+	NOP ZR
+	NOP V0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"nopform": {Name: "nopform", Ret: Void}},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	for _, instruction := range []string{
+		"NOP $0x1122334455667788",
+		"NOP F0",
+		"NOP RSP",
+		"NOP R0, R1",
+		"NOP.P",
+	} {
+		badSource := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, badSource, false)
+		badFile, err := Parse(ArchARM64, badSource)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(badFile, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's NOP forms", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_ic.go b/arm64_lower_ic.go
new file mode 100644
index 000000000..a3db62966
--- /dev/null
+++ b/arm64_lower_ic.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+import "fmt"
+
+func decodeARM64RawICIVAU(word uint32) (Reg, bool) {
+	if word&0xffffffe0 != 0xd50b7520 {
+		return "", false
+	}
+	if word&31 == 31 {
+		return ZR, true
+	}
+	return Reg(fmt.Sprintf("R%d", word&31)), true
+}
+
+func (c *arm64Ctx) lowerRawICIVAU(reg Reg) error {
+	if reg == ZR {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", "ic ivau, xzr", "~{memory}")
+		return nil
+	}
+	value, err := c.loadReg(reg)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "ic ivau, $0", "r,~{memory}", value)
+	return nil
+}
diff --git a/arm64_lower_ic_test.go b/arm64_lower_ic_test.go
new file mode 100644
index 000000000..fc89ae503
--- /dev/null
+++ b/arm64_lower_ic_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawICIVAU(t *testing.T) {
+	const source = `TEXT icivau(SB),$0-0
+	WORD $0xd50b7520
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"icivau": {Name: "icivau", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, `asm sideeffect "ic ivau, $0"`) {
+		t.Fatalf("raw IC IVAU was not lowered:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-ic.ll", "arm64-ic.o", ll)
+}
diff --git a/arm64_lower_immediate_shift_right_test.go b/arm64_lower_immediate_shift_right_test.go
new file mode 100644
index 000000000..d59202b2c
--- /dev/null
+++ b/arm64_lower_immediate_shift_right_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64ImmediateShiftRight(base uint32, elementBits, shift int, fullVector bool, source, destination int) uint32 {
+	encodedImmediate := uint32(2*elementBits - shift)
+	word := base | encodedImmediate<<16 | uint32(source)<<5 | uint32(destination)
+	if fullVector {
+		word |= 1 << 30
+	}
+	return word
+}
+
+func TestTranslateARM64RawImmediateShiftRightCompleteArchitectureFamily(t *testing.T) {
+	families := []struct {
+		name string
+		base uint32
+	}{
+		{name: "VSSHR", base: 0x0f000400},
+		{name: "VSSRA", base: 0x0f001400},
+		{name: "VSRSHR", base: 0x0f002400},
+		{name: "VSRSRA", base: 0x0f003400},
+		{name: "VUSHR", base: 0x2f000400},
+		{name: "VUSRA", base: 0x2f001400},
+		{name: "VURSHR", base: 0x2f002400},
+		{name: "VURSRA", base: 0x2f003400},
+	}
+	type form struct {
+		elementBits int
+		fullVector  bool
+	}
+	forms := []form{
+		{elementBits: 8}, {elementBits: 8, fullVector: true},
+		{elementBits: 16}, {elementBits: 16, fullVector: true},
+		{elementBits: 32}, {elementBits: 32, fullVector: true},
+		{elementBits: 64, fullVector: true},
+	}
+	arrangementName := func(form form) string {
+		lanes := 64 / form.elementBits
+		if form.fullVector {
+			lanes *= 2
+		}
+		letter := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[form.elementBits]
+		return fmt.Sprintf("%s%d", letter, lanes)
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT ·immediateShiftRightArchitectureForms(SB), $0-0\n")
+	for _, family := range families {
+		for _, form := range forms {
+			for _, shift := range []int{1, form.elementBits} {
+				word := encodeARM64ImmediateShiftRight(family.base, form.elementBits, shift, form.fullVector, 29, 28)
+				decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+				if err != nil {
+					t.Fatalf("decode %s %d-bit Q=%v shift=%d: %v", family.name, form.elementBits, form.fullVector, shift, err)
+				}
+				wantSource := Reg("V29." + arrangementName(form))
+				wantDestination := Reg("V28." + arrangementName(form))
+				if decoded.Op != Op(family.name) || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != int64(shift) ||
+					decoded.Args[1].Reg != wantSource || decoded.Args[2].Reg != wantDestination {
+					t.Fatalf("decoded %s %d-bit Q=%v shift=%d %#08x as %#v", family.name, form.elementBits, form.fullVector, shift, word, decoded)
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s %d-bit Q=%v shift=%d\n", word, family.name, form.elementBits, form.fullVector, shift)
+			}
+		}
+		for _, shift := range []int{1, 64} {
+			scalarBase := family.base | 0x50000000
+			word := encodeARM64ImmediateShiftRight(scalarBase, 64, shift, false, 29, 28)
+			decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			if err != nil {
+				t.Fatalf("decode scalar %s shift=%d: %v", family.name, shift, err)
+			}
+			if decoded.Op != Op(family.name) || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != int64(shift) || decoded.Args[1].Reg != "V29" || decoded.Args[2].Reg != "V28" {
+				t.Fatalf("decoded scalar %s shift=%d %#08x as %#v", family.name, shift, word, decoded)
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x // scalar %s D shift=%d\n", word, family.name, shift)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"immediateShiftRightArchitectureForms": {Name: "immediateShiftRightArchitectureForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, line := range strings.Split(ll, "\n") {
+				if !strings.Contains(line, " = ashr ") && !strings.Contains(line, " = lshr ") {
+					continue
+				}
+				if strings.Contains(line, "ashr i64") || strings.Contains(line, "lshr i64") {
+					if strings.HasSuffix(line, ", 64") {
+						t.Fatalf("%s emitted undefined scalar width-sized shift: %s", triple, line)
+					}
+				}
+				for _, bits := range []int{8, 16, 32, 64} {
+					if strings.Contains(line, fmt.Sprintf("x i%d>", bits)) && strings.Contains(line, fmt.Sprintf("i%d %d", bits, bits)) {
+						t.Fatalf("%s emitted undefined vector width-sized shift: %s", triple, line)
+					}
+				}
+			}
+			for _, operation := range []string{"ashr", "lshr", "add"} {
+				if !strings.Contains(ll, " = "+operation+" ") {
+					t.Fatalf("%s omitted %s semantics:\n%s", triple, operation, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-immediate-shift-right.ll", "arm64-immediate-shift-right.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64ImmediateShiftRightRejectsInvalidArchitectureForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VURSHR V0.S4, V1.S4",
+		"VURSRA $0, V0.S4, V1.S4",
+		"VSSRA $33, V0.S4, V1.S4",
+		"VSRSRA $1, V0.S2, V1.S4",
+		"VURSHR $1, V0.D1, V1.D1",
+		"VURSRA.P $1, V0.S4, V1.S4",
+	} {
+		file, err := Parse(ArchARM64, "TEXT ·badImmediateShift(SB), $0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs:         map[string]FuncSig{"badImmediateShift": {Name: "badImmediateShift", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted invalid ARM64 immediate shift-right form %q", instruction)
+		}
+	}
+}
+
+func TestARM64ImmediateShiftRightRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	families := []uint32{
+		0x0f000400, // SSHR
+		0x0f001400, // SSRA
+		0x0f002400, // SRSHR
+		0x0f003400, // SRSRA
+		0x2f000400, // USHR
+		0x2f001400, // USRA
+		0x2f002400, // URSHR
+		0x2f003400, // URSRA
+	}
+	var source strings.Builder
+	source.WriteString("TEXT immediateShiftRightSemantics(SB),$0-24\n")
+	source.WriteString("\tMOVD in+0(FP), R0\n\tMOVD initial+8(FP), R1\n\tMOVD out+16(FP), R2\n")
+	source.WriteString("\tVLD1 (R0), [V0.B16]\n")
+	source.WriteString("\tVLD1.P 64(R1), [V8.B16, V9.B16, V10.B16, V11.B16]\n")
+	source.WriteString("\tVLD1 (R1), [V12.B16, V13.B16, V14.B16, V15.B16]\n")
+	for i, base := range families {
+		word := encodeARM64ImmediateShiftRight(base, 8, 4, true, 0, 8+i)
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tVST1.P [V8.B16, V9.B16, V10.B16, V11.B16], 64(R2)\n")
+	source.WriteString("\tVST1 [V12.B16, V13.B16, V14.B16, V15.B16], (R2)\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"immediateShiftRightSemantics": {
+			Name: "immediateShiftRightSemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void immediateShiftRightSemantics(const uint8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  uint8_t in[16], initial[128], got[128] = {0};
+  for (int i = 0; i < 16; i++) in[i] = (uint8_t)(i * 29u + 3u);
+  for (int i = 0; i < 128; i++) initial[i] = (uint8_t)(i * 7u + 5u);
+  immediateShiftRightSemantics(in, initial, got);
+  for (int i = 0; i < 16; i++) {
+    const int16_t sx = (int8_t)in[i];
+    const uint16_t ux = in[i];
+    const int16_t signed_shift = sx >> 4;
+    const int16_t signed_round = signed_shift + ((sx >> 3) & 1);
+    const uint16_t unsigned_shift = ux >> 4;
+    const uint16_t unsigned_round = unsigned_shift + ((ux >> 3) & 1);
+    const uint8_t want[8] = {
+      (uint8_t)signed_shift,
+      (uint8_t)(initial[1*16+i] + signed_shift),
+      (uint8_t)signed_round,
+      (uint8_t)(initial[3*16+i] + signed_round),
+      (uint8_t)unsigned_shift,
+      (uint8_t)(initial[5*16+i] + unsigned_shift),
+      (uint8_t)unsigned_round,
+      (uint8_t)(initial[7*16+i] + unsigned_round),
+    };
+    for (int op = 0; op < 8; op++) if (got[op*16+i] != want[op]) return op*16+i+1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_immediate_shift_right", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_integer_abs_neg.go b/arm64_lower_integer_abs_neg.go
new file mode 100644
index 000000000..9b897e2dc
--- /dev/null
+++ b/arm64_lower_integer_abs_neg.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorIntegerAbsNeg(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	saturating, handled := map[Op]bool{
+		"VABS": false, "VNEG": false,
+		"VSQABS": true, "VSQNEG": true,
+	}[op]
+	if !handled && op != "VABS" && op != "VNEG" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects two same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	validArrangement := sourceArrangement.elementBits != 64 || sourceArrangement.lanes == 2
+	if !sourceOK || !destinationOK || sourceArrangement != destinationArrangement || !validArrangement {
+		return true, false, fmt.Errorf("arm64 %s requires matching B8, B16, H4, H8, S2, S4, or D2 arrangements: %q", op, ins.Raw)
+	}
+
+	arrangement := sourceArrangement
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	negated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s zeroinitializer, %s\n", negated, vectorType, source)
+	result := "%" + negated
+	if op == "VABS" || op == "VSQABS" {
+		negative := c.newTmp()
+		absolute := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, zeroinitializer\n", negative, vectorType, source)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %s\n",
+			absolute, arrangement.lanes, negative, vectorType, negated, vectorType, source)
+		result = "%" + absolute
+	}
+	if saturating {
+		// In two's complement, zero and the signed minimum are the only values
+		// equal to their own negation. Excluding zero identifies saturation; a
+		// logical shift of the minimum produces the signed maximum.
+		equalNegation := c.newTmp()
+		nonzero := c.newTmp()
+		overflow := c.newTmp()
+		saturated := c.newTmp()
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %%%s\n", equalNegation, vectorType, source, negated)
+		fmt.Fprintf(c.b, "  %%%s = icmp ne %s %s, zeroinitializer\n", nonzero, vectorType, source)
+		fmt.Fprintf(c.b, "  %%%s = and <%d x i1> %%%s, %%%s\n", overflow, arrangement.lanes, equalNegation, nonzero)
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %%%s, %s\n", saturated, vectorType, negated, arm64VectorIntegerSplat(arrangement, 1))
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %s\n",
+			selected, arrangement.lanes, overflow, vectorType, saturated, vectorType, result)
+		result = "%" + selected
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, arrangement, result)
+}
+
+func arm64VectorIntegerSplat(arrangement arm64VectorArrangement, value int64) string {
+	parts := make([]string, arrangement.lanes)
+	for i := range parts {
+		parts[i] = fmt.Sprintf("i%d %d", arrangement.elementBits, value)
+	}
+	return "<" + strings.Join(parts, ", ") + ">"
+}
diff --git a/arm64_lower_integer_abs_neg_test.go b/arm64_lower_integer_abs_neg_test.go
new file mode 100644
index 000000000..35373369f
--- /dev/null
+++ b/arm64_lower_integer_abs_neg_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorIntegerAbsNegCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorIntegerAbsNegForms(SB), $0-0\n")
+	for _, op := range []string{"VABS", "VNEG", "VSQABS", "VSQNEG"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorIntegerAbsNegForms": {Name: "vectorIntegerAbsNegForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"sub <", "icmp slt <", "icmp eq <", "select <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s integer abs/neg IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-abs-neg.ll", "arm64-vector-integer-abs-neg.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerAbsNegRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VABS V0.B8",
+		"VNEG V0.B8, V1.B16",
+		"VSQABS V0.D1, V1.D1",
+		"VSQNEG V0.B16, V1.B16, V2.B16",
+		"VABS.P V0.S4, V1.S4",
+		"VABS F0, F1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorIntegerAbsNeg(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorIntegerAbsNeg": {Name: "badVectorIntegerAbsNeg", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector integer abs/neg forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_integer_add_long_across.go b/arm64_lower_integer_add_long_across.go
new file mode 100644
index 000000000..7fe9f7d92
--- /dev/null
+++ b/arm64_lower_integer_add_long_across.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorAddLongAcross(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic := ""
+	switch op {
+	case "VSADDLV":
+		intrinsic = "saddlv"
+	case "VUADDLV":
+		intrinsic = "uaddlv"
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects an arranged vector source and bare V destination: %q", op, ins.Raw)
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	if !valid || !((arrangement.elementBits == 8 && (arrangement.lanes == 8 || arrangement.lanes == 16)) ||
+		(arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8)) ||
+		(arrangement.elementBits == 32 && arrangement.lanes == 4)) {
+		return true, false, fmt.Errorf("arm64 %s accepts only B8, B16, H4, H8, or S4 source: %q", op, ins.Raw)
+	}
+	if strings.Contains(string(ins.Args[1].Reg), ".") {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+	if _, valid := arm64ParseVReg(ins.Args[1].Reg); !valid {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	resultBits := arrangement.elementBits * 2
+	intrinsicResultBits := resultBits
+	if intrinsicResultBits < 32 {
+		// LLVM 22 cannot legalize an i16 result from the AArch64 across-lane
+		// intrinsic. The instruction writes an H register, but the intrinsic
+		// must return i32; only its low 16 bits are architecturally defined.
+		intrinsicResultBits = 32
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.aarch64.neon.%s.i%d.v%di%d(<%d x i%d> %s)\n",
+		result, intrinsicResultBits, intrinsic, intrinsicResultBits, arrangement.lanes, arrangement.elementBits,
+		arrangement.lanes, arrangement.elementBits, source)
+	resultValue := "%" + result
+	if intrinsicResultBits != resultBits {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i%d %s to i%d\n",
+			truncated, intrinsicResultBits, resultValue, resultBits)
+		resultValue = "%" + truncated
+	}
+	return true, false, c.storeARM64ScalarToVReg(ins.Args[1].Reg, resultBits, resultValue)
+}
diff --git a/arm64_lower_integer_add_long_across_test.go b/arm64_lower_integer_add_long_across_test.go
new file mode 100644
index 000000000..abfebc4fa
--- /dev/null
+++ b/arm64_lower_integer_add_long_across_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64AddLongAcrossCompleteTypedFamily(t *testing.T) {
+	arrangements := []struct {
+		name string
+		size uint32
+		wide bool
+	}{
+		{"B8", 0, false},
+		{"B16", 0, true},
+		{"H4", 1, false},
+		{"H8", 1, true},
+		{"S4", 2, true},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT addLongAcrossForms(SB),$0-0\n")
+	for _, family := range []struct {
+		op   Op
+		base uint32
+	}{
+		{op: "VSADDLV", base: 0x0e303800},
+		{op: "VUADDLV", base: 0x2e303800},
+	} {
+		for _, arrangement := range arrangements {
+			word := family.base | arrangement.size<<22 | 18<<5 | 1
+			if arrangement.wide {
+				word |= 1 << 30
+			}
+			decoded, err := decodeARM64RawWordInstruction(Instr{
+				Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+			})
+			if err != nil || decoded.Op != family.op || len(decoded.Args) != 2 ||
+				decoded.Args[0].Reg != Reg("V18."+arrangement.name) || decoded.Args[1].Reg != "V1" {
+				t.Fatalf("decode %#08x: %+v, %v", word, decoded, err)
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"addLongAcrossForms": {Name: "addLongAcrossForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"@llvm.aarch64.neon.saddlv", "@llvm.aarch64.neon.uaddlv"} {
+				if !strings.Contains(ir, name) {
+					t.Fatalf("missing %s in generated IR:\n%s", name, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-add-long-across.ll", "arm64-add-long-across.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64NamedUADDLVAllGoForms(t *testing.T) {
+	const source = `TEXT namedUADDLV(SB),$0-0
+	VUADDLV V2.B8, V1
+	VUADDLV V2.B16, V1
+	VUADDLV V2.H4, V1
+	VUADDLV V2.H8, V1
+	VUADDLV V2.S4, V1
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs:         map[string]FuncSig{"namedUADDLV": {Name: "namedUADDLV", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, suffix := range []string{"i32.v8i8", "i32.v16i8", "i32.v4i16", "i32.v8i16", "i64.v4i32"} {
+		if !strings.Contains(ir, "@llvm.aarch64.neon.uaddlv."+suffix) {
+			t.Fatalf("missing typed VUADDLV form %s:\n%s", suffix, ir)
+		}
+	}
+}
+
+func TestARM64RawAddLongAcrossGoAV1RuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT rawSignedAddLongAcross(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V18.S4]
+	WORD $0x4eb03a41 // SADDLV D1, V18.4S
+	VMOV V1.D[0], R2
+	MOVD R2, (R1)
+	RET
+TEXT rawUnsignedAddLongAcross(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V18.S4]
+	WORD $0x6eb03a41 // UADDLV D1, V18.4S
+	VMOV V1.D[0], R2
+	MOVD R2, (R1)
+	RET
+TEXT signedByteAddLongAcross(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V18.B8]
+	WORD $0x0e303a41 // SADDLV H1, V18.8B
+	VMOV V1.D[0], R2
+	MOVD R2, (R1)
+	RET
+TEXT unsignedByteAddLongAcross(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V18.B16]
+	VUADDLV V18.B16, V1
+	VMOV V1.D[0], R2
+	MOVD R2, (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{}
+	for _, name := range []string{
+		"rawSignedAddLongAcross", "rawUnsignedAddLongAcross",
+		"signedByteAddLongAcross", "unsignedByteAddLongAcross",
+	} {
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawSignedAddLongAcross(const int32_t *, int64_t *);
+extern void rawUnsignedAddLongAcross(const uint32_t *, uint64_t *);
+extern void signedByteAddLongAcross(const int8_t *, uint64_t *);
+extern void unsignedByteAddLongAcross(const uint8_t *, uint64_t *);
+int main(void) {
+  const int32_t signedInput[4] = {2147483647, 2147483647, 2, -2};
+  const uint32_t unsignedInput[4] = {4294967295u, 4294967295u, 2, 1};
+  const int8_t signedBytes[8] = {100, 100, 100, 100, 100, 100, 100, 100};
+  const uint8_t unsignedBytes[16] = {200, 200, 200, 200, 200, 200, 200, 200,
+                                      200, 200, 200, 200, 200, 200, 200, 200};
+  int64_t signedResult = 0;
+  uint64_t unsignedResult = 0;
+  uint64_t signedByteResult = 0;
+  uint64_t unsignedByteResult = 0;
+  rawSignedAddLongAcross(signedInput, &signedResult);
+  rawUnsignedAddLongAcross(unsignedInput, &unsignedResult);
+  signedByteAddLongAcross(signedBytes, &signedByteResult);
+  unsignedByteAddLongAcross(unsignedBytes, &unsignedByteResult);
+  if (signedResult != 4294967294LL) return 1;
+  if (unsignedResult != 8589934593ULL) return 2;
+  if (signedByteResult != 800) return 3;
+  if (unsignedByteResult != 3200) return 4;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_add_long_across", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_integer_minmax.go b/arm64_lower_integer_minmax.go
new file mode 100644
index 000000000..156890f74
--- /dev/null
+++ b/arm64_lower_integer_minmax.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorIntegerMinMax(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	type operationSpec struct {
+		predicate string
+		pairwise  bool
+	}
+	specs := map[Op]operationSpec{
+		"VSMAX":  {predicate: "sgt"},
+		"VSMIN":  {predicate: "slt"},
+		"VUMAX":  {predicate: "ugt"},
+		"VUMIN":  {predicate: "ult"},
+		"VSMAXP": {predicate: "sgt", pairwise: true},
+		"VSMINP": {predicate: "slt", pairwise: true},
+		"VUMAXP": {predicate: "ugt", pairwise: true},
+		"VUMINP": {predicate: "ult", pairwise: true},
+	}
+	spec, handled := specs[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits == 64 {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8, B16, H4, H8, S2, or S4 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := ""
+	if !spec.pairwise {
+		condition := c.newTmp()
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x i%d> %s, %s\n", condition, spec.predicate, arrangement.lanes, arrangement.elementBits, first, second)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x i%d> %s, <%d x i%d> %s\n",
+			selected, arrangement.lanes, condition, arrangement.lanes, arrangement.elementBits, first, arrangement.lanes, arrangement.elementBits, second)
+		result = "%" + selected
+	} else {
+		result = "poison"
+		half := arrangement.lanes / 2
+		for lane := 0; lane < arrangement.lanes; lane++ {
+			source := second
+			if lane >= half {
+				source = first
+			}
+			pair := (lane % half) * 2
+			left := c.newTmp()
+			right := c.newTmp()
+			condition := c.newTmp()
+			selected := c.newTmp()
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", left, arrangement.lanes, arrangement.elementBits, source, pair)
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", right, arrangement.lanes, arrangement.elementBits, source, pair+1)
+			fmt.Fprintf(c.b, "  %%%s = icmp %s i%d %%%s, %%%s\n", condition, spec.predicate, arrangement.elementBits, left, right)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %%%s, i%d %%%s\n", selected, condition, arrangement.elementBits, left, arrangement.elementBits, right)
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n", inserted, arrangement.lanes, arrangement.elementBits, result, arrangement.elementBits, selected, lane)
+			result = "%" + inserted
+		}
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, result)
+}
diff --git a/arm64_lower_integer_minmax_across.go b/arm64_lower_integer_minmax_across.go
new file mode 100644
index 000000000..1b88a783e
--- /dev/null
+++ b/arm64_lower_integer_minmax_across.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorIntegerMinMaxAcross(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	predicate, handled := map[Op]string{
+		"VSMAXV": "sgt",
+		"VSMINV": "slt",
+		"VUMAXV": "ugt",
+		"VUMINV": "ult",
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects an arranged vector source, bare V destination, and no suffix: %q", op, ins.Raw)
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[0].Reg)
+	if !valid || !((arrangement.elementBits == 8 && (arrangement.lanes == 8 || arrangement.lanes == 16)) ||
+		(arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8)) ||
+		(arrangement.elementBits == 32 && arrangement.lanes == 4)) {
+		return true, false, fmt.Errorf("arm64 %s accepts only B8, B16, H4, H8, or S4 source: %q", op, ins.Raw)
+	}
+	if strings.Contains(string(ins.Args[1].Reg), ".") {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+	if _, valid := arm64ParseVReg(ins.Args[1].Reg); !valid {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 0\n", result, arrangement.lanes, arrangement.elementBits, source)
+	current := "%" + result
+	for lane := 1; lane < arrangement.lanes; lane++ {
+		element := c.newTmp()
+		condition := c.newTmp()
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", element, arrangement.lanes, arrangement.elementBits, source, lane)
+		fmt.Fprintf(c.b, "  %%%s = icmp %s i%d %s, %%%s\n", condition, predicate, arrangement.elementBits, current, element)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d %s, i%d %%%s\n", selected, condition, arrangement.elementBits, current, arrangement.elementBits, element)
+		current = "%" + selected
+	}
+	physicalLanes := 128 / arrangement.elementBits
+	vector := c.newTmp()
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %s, i32 0\n",
+		vector, physicalLanes, arrangement.elementBits, arrangement.elementBits, current)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", out, physicalLanes, arrangement.elementBits, vector)
+	return true, false, c.storeVReg(ins.Args[1].Reg, "%"+out)
+}
diff --git a/arm64_lower_integer_minmax_across_test.go b/arm64_lower_integer_minmax_across_test.go
new file mode 100644
index 000000000..d8ed09392
--- /dev/null
+++ b/arm64_lower_integer_minmax_across_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorIntegerMinMaxAcrossCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorIntegerMinMaxAcrossForms(SB), $0-0\n")
+	for _, op := range []string{"VSMAXV", "VSMINV", "VUMAXV", "VUMINV"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S4"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V31\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorIntegerMinMaxAcrossForms": {Name: "vectorIntegerMinMaxAcrossForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"icmp sgt i", "icmp slt i", "icmp ugt i", "icmp ult i", "select i1"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s integer min/max-across IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-minmax-across.ll", "arm64-vector-integer-minmax-across.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerMinMaxAcrossRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSMAXV V0.B8",
+		"VSMINV V0.S2, V1",
+		"VUMAXV V0.D2, V1",
+		"VUMINV V0.H8, V1.H8",
+		"VUMINV.P V0.S4, V1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorIntegerMinMaxAcross(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorIntegerMinMaxAcross": {Name: "badVectorIntegerMinMaxAcross", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector integer min/max-across forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_integer_minmax_test.go b/arm64_lower_integer_minmax_test.go
new file mode 100644
index 000000000..a547f6a30
--- /dev/null
+++ b/arm64_lower_integer_minmax_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorIntegerMinMaxCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorintegerminmaxforms(SB), $0-0\n")
+	for _, op := range []string{"VSMAX", "VSMIN", "VUMAX", "VUMIN", "VSMAXP", "VSMINP", "VUMAXP", "VUMINP"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs:         map[string]FuncSig{"vectorintegerminmaxforms": {Name: "vectorintegerminmaxforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-integer-minmax.ll", "arm64-vector-integer-minmax.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorIntegerMinMaxRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VUMAX V0.D2, V1.D2, V2.D2",
+		"VSMIN V0.S2, V1.S4, V2.S2",
+		"VUMAXP V0.H8, V1.H8",
+		"VSMAX.P V0.B16, V1.B16, V2.B16",
+		"VUMIN R0, V1.S4, V2.S4",
+	} {
+		source := "TEXT ·bad(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's vector integer min/max table", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_integer_multiply.go b/arm64_lower_integer_multiply.go
new file mode 100644
index 000000000..2a5451882
--- /dev/null
+++ b/arm64_lower_integer_multiply.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorIntegerMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	accumulate, handled := map[Op]string{
+		"VMUL": "",
+		"VMLA": "add",
+		"VMLS": "sub",
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits == 64 {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8/B16/H4/H8/S2/S4 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, vectorType, second, first)
+	result := "%" + product
+	if accumulate != "" {
+		accumulator, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", combined, accumulate, vectorType, accumulator, product)
+		result = "%" + combined
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, result)
+}
diff --git a/arm64_lower_integer_multiply_test.go b/arm64_lower_integer_multiply_test.go
new file mode 100644
index 000000000..bf9498326
--- /dev/null
+++ b/arm64_lower_integer_multiply_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorIntegerMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorIntegerMultiplyForms(SB), $0-0\n")
+	for _, op := range []string{"VMUL", "VMLA", "VMLS"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorIntegerMultiplyForms": {Name: "vectorIntegerMultiplyForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"mul <", "add <", "sub <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s integer-multiply IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-multiply.ll", "arm64-vector-integer-multiply.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerMultiplyRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMUL V0.B8, V1.B8",
+		"VMLA V0.B8, V1.B16, V2.B8",
+		"VMLS V0.D2, V1.D2, V2.D2",
+		"VMUL V0.S4, V1.S4, V2.S2",
+		"VMUL.P V0.H8, V1.H8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorIntegerMultiply(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorIntegerMultiply": {Name: "badVectorIntegerMultiply", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector integer multiply forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_integer_narrow.go b/arm64_lower_integer_narrow.go
new file mode 100644
index 000000000..0b84986a3
--- /dev/null
+++ b/arm64_lower_integer_narrow.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorIntegerNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	kind, handled := map[Op]string{
+		"VXTN": "truncate", "VXTN2": "truncate",
+		"VSQXTN": "signed", "VSQXTN2": "signed",
+		"VSQXTUN": "signed-to-unsigned", "VSQXTUN2": "signed-to-unsigned",
+		"VUQXTN": "unsigned", "VUQXTN2": "unsigned",
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects a wide vector source, narrow vector destination, and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	highHalf := strings.HasSuffix(string(op), "2")
+	wantDestinationLanes := sourceArrangement.lanes
+	if highHalf {
+		wantDestinationLanes *= 2
+	}
+	if !sourceOK || !destinationOK ||
+		sourceArrangement.lanes*sourceArrangement.elementBits != 128 ||
+		sourceArrangement.elementBits != destinationArrangement.elementBits*2 ||
+		destinationArrangement.lanes != wantDestinationLanes {
+		return true, false, fmt.Errorf("arm64 %s requires H8->B8/S4->H4/D2->S2 (or the doubled *2 destination): %q", op, ins.Raw)
+	}
+
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	sourceType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	destinationType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, destinationArrangement.elementBits)
+	clamped := source
+	switch kind {
+	case "signed":
+		minimum := -(int64(1) << (destinationArrangement.elementBits - 1))
+		maximum := (int64(1) << (destinationArrangement.elementBits - 1)) - 1
+		clamped = c.clampARM64VectorInteger(sourceType, sourceArrangement, source, "slt", minimum, "sgt", maximum)
+	case "signed-to-unsigned":
+		maximum := (int64(1) << destinationArrangement.elementBits) - 1
+		clamped = c.clampARM64VectorInteger(sourceType, sourceArrangement, source, "slt", 0, "sgt", maximum)
+	case "unsigned":
+		maximum := (int64(1) << destinationArrangement.elementBits) - 1
+		above := c.newTmp()
+		selected := c.newTmp()
+		upper := arm64VectorIntegerSplat(sourceArrangement, maximum)
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %s, %s\n", above, sourceType, source, upper)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n",
+			selected, sourceArrangement.lanes, above, sourceType, upper, sourceType, source)
+		clamped = "%" + selected
+	}
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", narrowed, sourceType, clamped, destinationType)
+	if !highHalf {
+		return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, "%"+narrowed)
+	}
+
+	// The *2 forms preserve the low half of the destination and insert the
+	// newly narrowed lanes into its high half.
+	result, err := c.loadARM64VectorInteger(ins.Args[1].Reg, destinationArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	fullDestinationType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, destinationArrangement.elementBits)
+	for lane := 0; lane < sourceArrangement.lanes; lane++ {
+		element := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", element, destinationType, narrowed, lane)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n",
+			inserted, fullDestinationType, result, destinationArrangement.elementBits, element, sourceArrangement.lanes+lane)
+		result = "%" + inserted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, result)
+}
+
+func (c *arm64Ctx) clampARM64VectorInteger(vectorType string, arrangement arm64VectorArrangement, source, lowerPredicate string, lower int64, upperPredicate string, upper int64) string {
+	lowerValue := arm64VectorIntegerSplat(arrangement, lower)
+	below := c.newTmp()
+	lowerClamped := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %s, %s\n", below, lowerPredicate, vectorType, source, lowerValue)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n",
+		lowerClamped, arrangement.lanes, below, vectorType, lowerValue, vectorType, source)
+	upperValue := arm64VectorIntegerSplat(arrangement, upper)
+	above := c.newTmp()
+	upperClamped := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %%%s, %s\n", above, upperPredicate, vectorType, lowerClamped, upperValue)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %%%s\n",
+		upperClamped, arrangement.lanes, above, vectorType, upperValue, vectorType, lowerClamped)
+	return "%" + upperClamped
+}
diff --git a/arm64_lower_integer_narrow_test.go b/arm64_lower_integer_narrow_test.go
new file mode 100644
index 000000000..36229d011
--- /dev/null
+++ b/arm64_lower_integer_narrow_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorIntegerNarrowCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorIntegerNarrowForms(SB), $0-0\n")
+	for _, op := range []string{"VXTN", "VSQXTN", "VSQXTUN", "VUQXTN"} {
+		source.WriteString("\t" + op + " V0.H8, V1.B8\n")
+		source.WriteString("\t" + op + " V2.S4, V3.H4\n")
+		source.WriteString("\t" + op + " V4.D2, V5.S2\n")
+		source.WriteString("\t" + op + "2 V6.H8, V7.B16\n")
+		source.WriteString("\t" + op + "2 V8.S4, V9.H8\n")
+		source.WriteString("\t" + op + "2 V10.D2, V11.S4\n")
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorIntegerNarrowForms": {Name: "vectorIntegerNarrowForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"trunc <", "icmp slt <", "icmp sgt <", "icmp ugt <", "insertelement <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s integer narrow IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-integer-narrow.ll", "arm64-vector-integer-narrow.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorIntegerNarrowRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VXTN V0.B8, V1.B8",
+		"VXTN2 V0.H8, V1.B8",
+		"VSQXTN V0.H8, V1.B16",
+		"VSQXTUN2 V0.S4, V1.S4",
+		"VUQXTN V0.D2, V1.H4",
+		"VUQXTN.P V0.H8, V1.B8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorIntegerNarrow(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorIntegerNarrow": {Name: "badVectorIntegerNarrow", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector integer narrowing forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_integer_pair.go b/arm64_lower_integer_pair.go
new file mode 100644
index 000000000..605d5ba87
--- /dev/null
+++ b/arm64_lower_integer_pair.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64IntegerPairSpec struct {
+	elementBytes int
+	load         bool
+	signed       bool
+}
+
+var arm64IntegerPairSpecs = map[Op]arm64IntegerPairSpec{
+	"LDP":   {elementBytes: 8, load: true},
+	"LDPW":  {elementBytes: 4, load: true},
+	"LDPSW": {elementBytes: 4, load: true, signed: true},
+	"STP":   {elementBytes: 8},
+	"STPW":  {elementBytes: 4},
+}
+
+func (c *arm64Ctx) lowerARM64IntegerPair(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, recognized := arm64IntegerPairSpecs[op]
+	if !recognized {
+		return false, false, nil
+	}
+	rawOp := strings.ToUpper(string(ins.Op))
+	preIndex, postIndex := false, false
+	switch rawOp {
+	case string(op):
+	case string(op) + ".W":
+		preIndex = true
+	case string(op) + ".P":
+		postIndex = true
+	default:
+		return true, false, fmt.Errorf("arm64 %s accepts only .W or .P memory suffixes: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects exactly 2 operands: %q", op, ins.Raw)
+	}
+	load := spec.load
+	memory, pair := ins.Args[0], ins.Args[1]
+	if !load {
+		pair, memory = ins.Args[0], ins.Args[1]
+	}
+	if pair.Kind != OpRegList || len(pair.RegList) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects a pair of general registers: %q", op, ins.Raw)
+	}
+	for _, reg := range pair.RegList {
+		if !isARM64GeneralOrZeroReg(reg) {
+			return true, false, fmt.Errorf("arm64 %s expects a pair of general registers: %q", op, ins.Raw)
+		}
+	}
+	if load && pair.RegList[0] == pair.RegList[1] {
+		return true, false, fmt.Errorf("arm64 %s requires distinct destination registers: %q", op, ins.Raw)
+	}
+	elementBytes := spec.elementBytes
+	if memory.Kind == OpFP {
+		if preIndex || postIndex {
+			return true, false, fmt.Errorf("arm64 %s does not support this FP-relative pair form: %q", op, ins.Raw)
+		}
+		if _, err := c.fpFrameParts(memory.FPOffset, int64(elementBytes*2)); err != nil {
+			return true, false, err
+		}
+		for index, reg := range pair.RegList {
+			off := memory.FPOffset + int64(index*elementBytes)
+			if load {
+				value, err := c.loadFPFrameBits(off, int64(elementBytes))
+				if err != nil {
+					return true, false, err
+				}
+				if spec.signed {
+					value = c.arm64ExtendNarrow(value, 32, true)
+				}
+				if err := c.storeReg(reg, value); err != nil {
+					return true, false, err
+				}
+			} else {
+				value, err := c.loadReg(reg)
+				if err != nil {
+					return true, false, err
+				}
+				if err := c.storeFPFrameBits(off, int64(elementBytes), value); err != nil {
+					return true, false, err
+				}
+			}
+		}
+		return true, false, nil
+	}
+	ptr, base, increment, update, err := c.arm64IntegerPairPointer(memory, preIndex, postIndex)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	for index, reg := range pair.RegList {
+		elementPtr := ptr
+		if index != 0 {
+			next := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 %d\n", next, ptr, elementBytes)
+			elementPtr = "%" + next
+		}
+		if load {
+			if err := c.loadARM64IntegerPairElement(reg, elementPtr, elementBytes, spec.signed); err != nil {
+				return true, false, err
+			}
+		} else if err := c.storeARM64IntegerPairElement(reg, elementPtr, elementBytes); err != nil {
+			return true, false, err
+		}
+	}
+	if update {
+		if err := c.updatePostInc(base, increment); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) arm64IntegerPairPointer(operand Operand, preIndex, postIndex bool) (ptr string, base Reg, increment int64, update bool, err error) {
+	if operand.Kind == OpSym {
+		if preIndex || postIndex {
+			return "", "", 0, false, fmt.Errorf("symbol operand cannot be pre- or post-indexed")
+		}
+		ptr, err := c.ptrFromSB(operand.Sym)
+		return ptr, "", 0, false, err
+	}
+	if operand.Kind != OpMem {
+		return "", "", 0, false, fmt.Errorf("expected a memory operand")
+	}
+	if operand.Mem.Index != "" {
+		return "", "", 0, false, fmt.Errorf("register-indexed memory is absent from the Go 1.27 integer-pair optab")
+	}
+	if !isARM64FloatPairMemoryBase(operand.Mem.Base) {
+		return "", "", 0, false, fmt.Errorf("memory base must be R0-R30, RSP, SP, or ZR")
+	}
+	addr, base, increment, err := c.addrI64(operand.Mem, postIndex)
+	if err != nil {
+		return "", "", 0, false, err
+	}
+	if preIndex {
+		if err := c.storeReg(base, addr); err != nil {
+			return "", "", 0, false, err
+		}
+	}
+	name := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", name, addr)
+	return "%" + name, base, increment, postIndex, nil
+}
+
+func (c *arm64Ctx) loadARM64IntegerPairElement(reg Reg, ptr string, elementBytes int, signed bool) error {
+	bits := elementBytes * 8
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", value, bits, ptr)
+	result := "%" + value
+	if bits == 32 {
+		wide := c.newTmp()
+		extension := "zext"
+		if signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s i32 %%%s to i64\n", wide, extension, value)
+		result = "%" + wide
+	}
+	return c.storeReg(reg, result)
+}
+
+func (c *arm64Ctx) storeARM64IntegerPairElement(reg Reg, ptr string, elementBytes int) error {
+	value, err := c.loadReg(reg)
+	if err != nil {
+		return err
+	}
+	bits := elementBytes * 8
+	if bits == 64 {
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", value, ptr)
+		return nil
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, value)
+	fmt.Fprintf(c.b, "  store i32 %%%s, ptr %s, align 1\n", narrow, ptr)
+	return nil
+}
diff --git a/arm64_lower_integer_pair_test.go b/arm64_lower_integer_pair_test.go
new file mode 100644
index 000000000..2900b2e0e
--- /dev/null
+++ b/arm64_lower_integer_pair_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64IntegerPairCompleteFormats(t *testing.T) {
+	const source = `TEXT integerPairComplete(SB),$0-0
+	LDP (R0), (R1, R2)
+	LDP.W 16(R3), (R4, R5)
+	LDP.P -16(R6), (R7, R8)
+	LDP pairData(SB), (R9, R10)
+	LDPW (R11), (R12, R13)
+	LDPW.W 8(R14), (R15, R16)
+	LDPW.P -8(R17), (R19, R20)
+	LDPW pairData+8(SB), (R20, R21)
+	LDPSW (R22), (R23, R24)
+	LDPSW.W 8(R25), (R26, R27)
+	LDPSW.P -8(R20), (R21, R22)
+	LDPSW pairData+16(SB), (R1, R2)
+	STP (R3, R4), (R5)
+	STP.W (R6, R7), 16(R8)
+	STP.P (R9, R10), -16(R11)
+	STP (R12, R13), pairData+24(SB)
+	STPW (R14, R15), (R16)
+	STPW.W (R17, R19), 8(R20)
+	STPW.P (R20, R21), -8(R22)
+	STPW (R23, R24), pairData+40(SB)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"integerPairComplete": {Name: "integerPairComplete", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"load i64", "load i32", "sext i32", "zext i32",
+		"store i64", "store i32", "getelementptr i8", "pairData",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 integer-pair lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-integer-pair.ll", "arm64-integer-pair.o", ll)
+}
+
+func TestTranslateARM64IntegerPairRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"LDP (R0), R1",
+		"LDP (R0)(R1), (R2, R3)",
+		"LDP.W pairData(SB), (R1, R2)",
+		"LDPSW (R0), (R1, V2)",
+		"STP (R0), (R1)",
+		"STPW (R0, R1), (R2)(R3)",
+		"STPW.P (R0, R1), pairData(SB)",
+		"STP.X (R0, R1), (R2)",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 integer-pair optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_integer_pairwise.go b/arm64_lower_integer_pairwise.go
new file mode 100644
index 000000000..1499dd741
--- /dev/null
+++ b/arm64_lower_integer_pairwise.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27's VADDP optab has seven three-register vector arrangements. Arm's
+// scalar ADDP Dd,Vn.2D has no named Go spelling and appears only in WORD.
+var arm64PairwiseAddArrangements = map[arm64VectorArrangement]bool{
+	{elementBits: 8, lanes: 8}:  true,
+	{elementBits: 8, lanes: 16}: true,
+	{elementBits: 16, lanes: 4}: true,
+	{elementBits: 16, lanes: 8}: true,
+	{elementBits: 32, lanes: 2}: true,
+	{elementBits: 32, lanes: 4}: true,
+	{elementBits: 64, lanes: 2}: true,
+}
+
+type arm64RawScalarADDP struct {
+	source      int
+	destination int
+}
+
+func decodeARM64RawScalarADDP(word uint32) (arm64RawScalarADDP, bool) {
+	if word&0xfffffc00 != 0x5ef1b800 {
+		return arm64RawScalarADDP{}, false
+	}
+	return arm64RawScalarADDP{source: int(word>>5) & 31, destination: int(word & 31)}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarADDP(form arm64RawScalarADDP) error {
+	arrangement := arm64VectorArrangement{elementBits: 64, lanes: 2}
+	source, err := c.loadARM64VectorInteger(Reg(fmt.Sprintf("V%d.D2", form.source)), arrangement)
+	if err != nil {
+		return err
+	}
+	first := c.newTmp()
+	second := c.newTmp()
+	sum := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %s, i32 0\n", first, source)
+	fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %s, i32 1\n", second, source)
+	fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", sum, first, second)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i64> poison, i64 %%%s, i32 0\n", result, sum)
+	return c.storeRawARM64VectorResult(form.destination, arm64VectorArrangement{elementBits: 64, lanes: 1}, "%"+result, true)
+}
+
+func (c *arm64Ctx) lowerARM64VectorADDP(ins Instr) error {
+	if len(ins.Args) != 3 {
+		return fmt.Errorf("arm64 VADDP expects three same-arrangement vector registers: %q", ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for index, operand := range ins.Args {
+		if operand.Kind != OpReg {
+			return fmt.Errorf("arm64 VADDP expects vector registers: %q", ins.Raw)
+		}
+		parsed, ok := parseARM64VectorArrangement(operand.Reg)
+		if !ok || !arm64PairwiseAddArrangements[parsed] {
+			return fmt.Errorf("arm64 VADDP has invalid arrangement: %q", ins.Raw)
+		}
+		if index == 0 {
+			arrangement = parsed
+		} else if arrangement != parsed {
+			return fmt.Errorf("arm64 VADDP arrangements must match: %q", ins.Raw)
+		}
+	}
+
+	// Go syntax is Vm,Vn,Vd. Architecturally the low result lanes come from
+	// adjacent pairs of Vn, followed by pairs of Vm.
+	m, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	n, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	lanes := arrangement.lanes
+	even := make([]int, 0, lanes)
+	odd := make([]int, 0, lanes)
+	for source := 0; source < 2; source++ {
+		for pair := 0; pair < lanes/2; pair++ {
+			even = append(even, source*lanes+2*pair)
+			odd = append(odd, source*lanes+2*pair+1)
+		}
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", lanes, arrangement.elementBits)
+	left := c.newTmp()
+	right := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s %s, %s\n", left, vectorType, n, vectorType, m, arm64IntegerShuffleMask(even))
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s %s, %s\n", right, vectorType, n, vectorType, m, arm64IntegerShuffleMask(odd))
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", result, vectorType, left, right)
+	return c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+}
+
+func arm64IntegerShuffleMask(indices []int) string {
+	mask := fmt.Sprintf("<%d x i32> <", len(indices))
+	for index, lane := range indices {
+		if index != 0 {
+			mask += ", "
+		}
+		mask += fmt.Sprintf("i32 %d", lane)
+	}
+	return mask + ">"
+}
diff --git a/arm64_lower_integer_pairwise_test.go b/arm64_lower_integer_pairwise_test.go
new file mode 100644
index 000000000..6dfab784a
--- /dev/null
+++ b/arm64_lower_integer_pairwise_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var arm64VADDPArrangements = []struct {
+	name        string
+	elementBits int
+	lanes       int
+}{
+	{"B8", 8, 8}, {"B16", 8, 16},
+	{"H4", 16, 4}, {"H8", 16, 8},
+	{"S2", 32, 2}, {"S4", 32, 4},
+	{"D2", 64, 2},
+}
+
+func TestARM64VADDPCompleteGoFormsAndRawScalar(t *testing.T) {
+	file, sigs, _ := arm64VADDPProgram(t, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "vaddp.ll", "vaddp.o", ir)
+		})
+	}
+}
+
+func TestARM64VADDPRejectsGoInvalidForms(t *testing.T) {
+	for _, line := range []string{
+		"VADDP V1.D1, V2.D1, V0.D1",
+		"VADDP V1.H4, V2.H8, V0.H4",
+		"VADDP V1.S2, V2.S2, V0.D2",
+		"VADDP V1.D2, V0",
+	} {
+		source := "TEXT invalidpair(SB),4,$0-0\n" + line + "\nRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		_, err = Translate(file, Options{
+			Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"invalidpair": {Name: "invalidpair", Ret: Void}},
+		})
+		if err == nil {
+			t.Errorf("translator accepted Go-rejected form %q", line)
+		}
+	}
+}
+
+func TestARM64RawScalarADDPDecoderRegisterSpace(t *testing.T) {
+	for source := 0; source < 32; source++ {
+		for destination := 0; destination < 32; destination++ {
+			word := uint32(0x5ef1b800 | source<<5 | destination)
+			decoded, ok := decodeARM64RawScalarADDP(word)
+			if !ok || decoded.source != source || decoded.destination != destination {
+				t.Errorf("%#08x decoded as %+v, %v", word, decoded, ok)
+			}
+		}
+	}
+	for bit := uint(10); bit < 32; bit++ {
+		word := uint32(0x5ef1b800) ^ (1 << bit)
+		if decoded, ok := decodeARM64RawScalarADDP(word); ok {
+			t.Errorf("accepted mutated fixed bit %d in %#08x as %+v", bit, word, decoded)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64VADDP(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("ARM64 native execution or required Linux cross-runtime matrix")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compiler := []string{findLLVM22Tool("clang")}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runner []string
+	if cross {
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		triple = "aarch64-unknown-linux-gnu"
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	for _, withScalar := range []bool{false, true} {
+		name := "vector"
+		if withScalar {
+			name = "scalar"
+		}
+		t.Run(name, func(t *testing.T) {
+			file, sigs, oracle := arm64VADDPProgram(t, withScalar)
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "vaddp", triple, ir, oracle, runner)
+		})
+	}
+}
+
+func arm64VADDPProgram(t *testing.T, withScalar bool) (*File, map[string]FuncSig, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, shape := range arm64VADDPArrangements {
+		name := fmt.Sprintf("pairwise%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", name)
+		fmt.Fprint(&source, "MOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n")
+		fmt.Fprint(&source, "VLD1 (R0),[V1.B16]\nVLD1 (R1),[V2.B16]\n")
+		fmt.Fprintf(&source, "VADDP V1.%s,V2.%s,V0.%s\n", shape.name, shape.name, shape.name)
+		fmt.Fprint(&source, "VST1 [V0.B16],(R2)\nRET\n")
+		fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", name)
+		fmt.Fprintf(&checks, "    if (check(%s,%d,%d,0,0)) return %d;\n", name, shape.elementBits, shape.lanes, index+1)
+		sigs[name] = arm64PairwiseSig(name)
+
+		aliasName := fmt.Sprintf("pairwiseAlias%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", aliasName)
+		fmt.Fprint(&source, "MOVD a+0(FP),R0\nMOVD out+16(FP),R2\n")
+		fmt.Fprint(&source, "VLD1 (R0),[V0.B16]\n")
+		fmt.Fprintf(&source, "VADDP V0.%s,V0.%s,V0.%s\n", shape.name, shape.name, shape.name)
+		fmt.Fprint(&source, "VST1 [V0.B16],(R2)\nRET\n")
+		fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", aliasName)
+		fmt.Fprintf(&checks, "    if (check(%s,%d,%d,0,1)) return %d;\n", aliasName, shape.elementBits, shape.lanes, index+9)
+		sigs[aliasName] = arm64PairwiseSig(aliasName)
+	}
+	if withScalar {
+		const scalarName = "pairwiseScalar"
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", scalarName)
+		fmt.Fprint(&source, "MOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n")
+		fmt.Fprint(&source, "VLD1 (R0),[V1.B16]\nWORD $0x5ef1b820\nVST1 [V0.B16],(R2)\nRET\n")
+		fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", scalarName)
+		fmt.Fprintf(&checks, "    if (check(%s,64,1,1,0)) return 16;\n", scalarName)
+		sigs[scalarName] = arm64PairwiseSig(scalarName)
+
+		const aliasName = "pairwiseScalarAlias"
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\n", aliasName)
+		fmt.Fprint(&source, "MOVD a+0(FP),R0\nMOVD out+16(FP),R2\n")
+		fmt.Fprint(&source, "VLD1 (R0),[V0.B16]\nWORD $0x5ef1b800\nVST1 [V0.B16],(R2)\nRET\n")
+		fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", aliasName)
+		fmt.Fprintf(&checks, "    if (check(%s,64,1,1,1)) return 17;\n", aliasName)
+		sigs[aliasName] = arm64PairwiseSig(aliasName)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := arm64VADDPOracleC + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	return file, sigs, oracle
+}
+
+func arm64PairwiseSig(name string) FuncSig {
+	return FuncSig{
+		Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}},
+	}
+}
+
+const arm64VADDPOracleC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static uint64_t lane(const uint8_t *value, int bits, int index) {
+    uint64_t result = 0;
+    memcpy(&result, value + index * bits / 8, bits / 8);
+    return result;
+}
+
+static int check(void (*fn)(const void *,const void *,void *), int bits, int lanes, int scalar, int alias) {
+    uint8_t a[16], b[16], got[16], want[16];
+    uint32_t seed = 0x734291bcU;
+    for (int trial = 0; trial < 256; trial++) {
+        for (int byte = 0; byte < 16; byte++) {
+            seed = seed * 1664525U + 1013904223U;
+            a[byte] = seed >> 24;
+            seed = seed * 1664525U + 1013904223U;
+            b[byte] = seed >> 16;
+        }
+        memset(want, 0, 16);
+        if (scalar) {
+            uint64_t result = lane(a,64,0) + lane(a,64,1);
+            memcpy(want, &result, 8);
+        } else {
+            for (int index = 0; index < lanes; index++) {
+                const uint8_t *source = index < lanes / 2 && !alias ? b : a;
+                int sourceIndex = (index % (lanes / 2)) * 2;
+                uint64_t result = lane(source,bits,sourceIndex) + lane(source,bits,sourceIndex+1);
+                memcpy(want + index * bits / 8, &result, bits / 8);
+            }
+        }
+        memset(got, 0xa5, 16);
+        fn(a,b,got);
+        if (memcmp(got,want,16)) {
+            fprintf(stderr,"VADDP mismatch bits=%d lanes=%d scalar=%d alias=%d trial=%d\n",bits,lanes,scalar,alias,trial);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/arm64_lower_inverted_logical.go b/arm64_lower_inverted_logical.go
new file mode 100644
index 000000000..8f48c6d1f
--- /dev/null
+++ b/arm64_lower_inverted_logical.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64InvertedLogical(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	word := op == "ORNW" || op == "EONW"
+	exclusive := op == "EON" || op == "EONW"
+	if !word && !exclusive && op != "ORN" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects 2 or 3 operands: %q", op, ins.Raw)
+	}
+	if !arm64BitClearSourceValid(ins.Args[0], word) {
+		return true, false, fmt.Errorf("arm64 %s invalid first operand: %q", op, ins.Raw)
+	}
+
+	destination := ins.Args[len(ins.Args)-1]
+	if destination.Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s destination must be a register: %q", op, ins.Raw)
+	}
+	destinationGeneral := isARM64GeneralOrZeroReg(destination.Reg)
+	destinationStack := destination.Reg == SP || destination.Reg == Reg("RSP")
+	if !destinationGeneral && !(len(ins.Args) == 3 && ins.Args[0].Kind == OpImm && destinationStack) {
+		return true, false, fmt.Errorf("arm64 %s invalid destination register: %q", op, ins.Raw)
+	}
+
+	leftOperand := destination
+	if len(ins.Args) == 3 {
+		leftOperand = ins.Args[1]
+		if leftOperand.Kind != OpReg || !isARM64GeneralOrZeroReg(leftOperand.Reg) {
+			return true, false, fmt.Errorf("arm64 %s second operand must be a general register: %q", op, ins.Raw)
+		}
+	}
+
+	typeName := "i64"
+	right, err := c.eval64(ins.Args[0], false)
+	if word {
+		typeName = "i32"
+		right, err = c.eval32(ins.Args[0])
+	}
+	if err != nil {
+		return true, false, err
+	}
+	left, err := c.eval64(leftOperand, false)
+	if word {
+		left, err = c.eval32(leftOperand)
+	}
+	if err != nil {
+		return true, false, err
+	}
+
+	inverted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s %s, -1\n", inverted, typeName, right)
+	llvmOp := "or"
+	if exclusive {
+		llvmOp = "xor"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, llvmOp, typeName, left, inverted)
+	value := "%" + result
+	if word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, value)
+		value = "%" + wide
+	}
+	return true, false, c.storeReg(destination.Reg, value)
+}
diff --git a/arm64_lower_inverted_logical_test.go b/arm64_lower_inverted_logical_test.go
new file mode 100644
index 000000000..7cf76ad7f
--- /dev/null
+++ b/arm64_lower_inverted_logical_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64InvertedLogicalForms = `
+TEXT invertedlogicalforms(SB),$0-0
+	MOVD RSP, R18_PLATFORM
+	ORN R0, R1
+	ORN R2, R3, R4
+	ORN R5>>7, R6, R7
+	ORN $255, R8, R9
+	ORN $255, R9, RSP
+	ORNW R10, R11
+	ORNW R12->3, R13, R14
+	ORNW $255, R15, R16
+	EON R17, R19
+	EON R20<<12, R21, R22
+	EON $255, R23, R24
+	EONW R24, R25
+	EONW R26@>15, R27, R29
+	EONW $255, R30, R0
+	MOVD R18_PLATFORM, RSP
+	RET
+`
+
+func TestTranslateARM64InvertedLogicalCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64InvertedLogicalForms, true)
+	file, err := Parse(ArchARM64, arm64InvertedLogicalForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"invertedlogicalforms": {Name: "invertedlogicalforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"xor i64", "or i64", "xor i32", "or i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("inverted-logical family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-inverted-logical.ll", "arm64-inverted-logical.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64InvertedLogicalRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"ORN R0",
+		"ORN R0, R1, R2, R3",
+		"ORN (R0), R1",
+		"ORN R0.UXTB, R1",
+		"ORN RSP, R1",
+		"ORNW R0<<32, R1",
+		"EON R0, RSP",
+		"EONW.P R0, R1",
+	} {
+		source := "TEXT badinvertedlogical(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+			Sigs: map[string]FuncSig{"badinvertedlogical": {Name: "badinvertedlogical", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's inverted-logical optab", instruction)
+		}
+	}
+}
+
+func TestARM64InvertedLogicalRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT invertedlogical(SB),$0-24
+	MOVD first+0(FP), R0
+	MOVD second+8(FP), R1
+	MOVD output+16(FP), R2
+	ORN R0, R1, R3
+	EON R0, R1, R4
+	ORNW R0, R1, R5
+	EONW R0, R1, R6
+	ORN R0>>8, R1, R7
+	EONW $255, R1, R8
+	MOVD R3, 0(R2)
+	MOVD R4, 8(R2)
+	MOVD R5, 16(R2)
+	MOVD R6, 24(R2)
+	MOVD R7, 32(R2)
+	MOVD R8, 40(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"invertedlogical": {
+			Name: "invertedlogical", Args: []LLVMType{I64, I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void invertedlogical(uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  const uint64_t first = UINT64_C(0x00ff00ff8000000f);
+  const uint64_t second = UINT64_C(0xf000aaa055aa1234);
+  uint64_t got[6] = {0};
+  invertedlogical(first, second, got);
+  const uint64_t want[6] = {
+    second | ~first,
+    second ^ ~first,
+    (uint32_t)second | ~(uint32_t)first,
+    (uint32_t)second ^ ~(uint32_t)first,
+    second | ~(first >> 8),
+    (uint32_t)second ^ ~(uint32_t)255
+  };
+  for (int i = 0; i < 6; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_inverted_logical", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_move.go b/arm64_lower_move.go
new file mode 100644
index 000000000..a67a8d403
--- /dev/null
+++ b/arm64_lower_move.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64VectorMove follows the six AVMOV rows in Go's ARM64 optab.
+// A vector register's lane, scalar and arrangement spellings are distinct
+// operand classes: parsing their common V-number must not imply a full copy.
+func (c *arm64Ctx) lowerARM64VectorMove(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VMOV" {
+		return false, false, nil
+	}
+	form, err := parseARM64VectorTransfer(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	defer c.recordMachineVectorTransfer(form)()
+	if strings.ToUpper(string(ins.Op)) != "VMOV" || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 VMOV expects two registers and no opcode suffix: %q", ins.Raw)
+	}
+	src, dst := ins.Args[0].Reg, ins.Args[1].Reg
+	_, sourceVector := arm64ParseVReg(src)
+	_, destinationVector := arm64ParseVReg(dst)
+	sourceKind, sourceLane, sourceElement := arm64ParseVRegLane(src)
+	destinationKind, destinationLane, destinationElement := arm64ParseVRegLane(dst)
+	sourceElement = sourceElement && sourceVector
+	destinationElement = destinationElement && destinationVector
+	bits := func(kind byte) int {
+		return map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[kind]
+	}
+
+	if sourceElement {
+		elementBits := bits(sourceKind)
+		if destinationElement {
+			// Go case 92: INS copies one equally sized lane, preserving all
+			// other destination bits. Extract before loading/writing aliases.
+			if sourceKind != destinationKind {
+				return true, false, fmt.Errorf("arm64 VMOV lane element sizes must match: %q", ins.Raw)
+			}
+			element, err := c.arm64VDUPExtractLane(src, elementBits, sourceLane)
+			if err != nil {
+				return true, false, err
+			}
+			return true, false, c.arm64InsertVectorLane(dst, elementBits, destinationLane, element)
+		}
+		if isARM64GeneralOrZeroReg(dst) {
+			// Go case 73: UMOV zero extends B/H/S to the GP register.
+			element, err := c.arm64VDUPExtractLane(src, elementBits, sourceLane)
+			if err != nil {
+				return true, false, err
+			}
+			if elementBits < 64 {
+				extended := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", extended, elementBits, element)
+				element = "%" + extended
+			}
+			return true, false, c.storeReg(dst, element)
+		}
+		if destinationVector && !strings.Contains(string(dst), ".") {
+			// Go case 80 shares the scalar lane-copy encoding with VDUP.
+			// It writes the selected element to the low lane and zeros the
+			// remainder, rather than duplicating or copying the whole source.
+			return c.lowerARM64VectorDuplicate("VDUP", Instr{Op: "VDUP", Args: ins.Args, Raw: ins.Raw})
+		}
+		return true, false, fmt.Errorf("arm64 VMOV lane source requires R/ZR, a bare V register or a matching lane: %q", ins.Raw)
+	}
+
+	if isARM64GeneralOrZeroReg(src) {
+		if destinationElement {
+			// Go case 78: INS consumes the low GP element, preserving the
+			// complete remainder of the 128-bit destination register.
+			elementBits := bits(destinationKind)
+			value, err := c.loadRegisterWidth(src, elementBits)
+			if err != nil {
+				return true, false, err
+			}
+			if elementBits < 64 {
+				truncated := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, value, elementBits)
+				value = "%" + truncated
+			}
+			return true, false, c.arm64InsertVectorLane(dst, elementBits, destinationLane, value)
+		}
+		arrangement, valid := parseARM64VectorArrangement(dst)
+		if !destinationVector || !valid || !arm64VDUPArrangementAllowed(arrangement) {
+			return true, false, fmt.Errorf("arm64 VMOV GP source requires a valid arranged vector or lane destination: %q", ins.Raw)
+		}
+		// Go case 82 is identical to VDUP's GP-to-arrangement form.
+		return true, false, c.lowerARM64GPVectorDuplicate(src, dst, arrangement)
+	}
+
+	// Go case 83 is the ORR byte-vector alias, only B8 and B16. Q=0
+	// clears the high 64 bits; a full load/store would wrongly preserve them.
+	sourceArrangement, sourceArranged := parseARM64VectorArrangement(src)
+	destinationArrangement, destinationArranged := parseARM64VectorArrangement(dst)
+	if !sourceVector || !destinationVector || !sourceArranged || !destinationArranged ||
+		sourceArrangement != destinationArrangement || sourceArrangement.elementBits != 8 ||
+		(sourceArrangement.lanes != 8 && sourceArrangement.lanes != 16) {
+		return true, false, fmt.Errorf("arm64 VMOV vector copy requires matching B8 or B16 arrangements: %q", ins.Raw)
+	}
+	value, err := c.loadARM64VectorInteger(src, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.storeARM64VectorInteger(dst, destinationArrangement, value)
+}
+
+func (c *arm64Ctx) arm64InsertVectorLane(dst Reg, bits, lane int, element string) error {
+	value, err := c.loadARM64VectorInteger(dst, arm64VectorArrangement{elementBits: bits, lanes: 128 / bits})
+	if err != nil {
+		return err
+	}
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n", inserted, 128/bits, bits, value, bits, element, lane)
+	return c.storeARM64VectorInteger(dst, arm64VectorArrangement{elementBits: bits, lanes: 128 / bits}, "%"+inserted)
+}
diff --git a/arm64_lower_move_test.go b/arm64_lower_move_test.go
new file mode 100644
index 000000000..1ed528269
--- /dev/null
+++ b/arm64_lower_move_test.go
@@ -0,0 +1,343 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64VMOVCase struct {
+	instruction                        string
+	shape                              string
+	bytes, sourceLane, destinationLane int
+	alias, zero                        bool
+}
+
+// Go 1.27 asm7.go has six AVMOV rows, cases 73/78/80/82/83/92.
+// Case 92 preserves every other destination lane, including self aliases.
+func arm64VMOVCases() []arm64VMOVCase {
+	var cases []arm64VMOVCase
+	for _, element := range []struct {
+		kind  string
+		bytes int
+	}{{"B", 1}, {"H", 2}, {"S", 4}, {"D", 8}} {
+		lanes := 16 / element.bytes
+		for source := 0; source < lanes; source++ {
+			for destination := 0; destination < lanes; destination++ {
+				cases = append(cases, arm64VMOVCase{instruction: fmt.Sprintf("VMOV V0.%s[%d],V1.%s[%d]", element.kind, source, element.kind, destination), shape: "lane", bytes: element.bytes, sourceLane: source, destinationLane: destination})
+			}
+			cases = append(cases,
+				arm64VMOVCase{instruction: fmt.Sprintf("VMOV V0.%s[%d],V0.%s[%d]", element.kind, source, element.kind, lanes-1-source), shape: "lane", bytes: element.bytes, sourceLane: source, destinationLane: lanes - 1 - source, alias: true},
+				arm64VMOVCase{instruction: fmt.Sprintf("VMOV V0.%s[%d],V1", element.kind, source), shape: "scalar", bytes: element.bytes, sourceLane: source},
+				arm64VMOVCase{instruction: fmt.Sprintf("VMOV V0.%s[%d],R4", element.kind, source), shape: "extract", bytes: element.bytes, sourceLane: source},
+				arm64VMOVCase{instruction: fmt.Sprintf("VMOV R3,V1.%s[%d]", element.kind, source), shape: "insert", bytes: element.bytes, destinationLane: source},
+				arm64VMOVCase{instruction: fmt.Sprintf("VMOV ZR,V1.%s[%d]", element.kind, source), shape: "insert", bytes: element.bytes, destinationLane: source, zero: true},
+			)
+		}
+	}
+	for _, arrangement := range []struct {
+		name         string
+		bytes, lanes int
+	}{{"B8", 1, 8}, {"B16", 1, 16}, {"H4", 2, 4}, {"H8", 2, 8}, {"S2", 4, 2}, {"S4", 4, 4}, {"D2", 8, 2}} {
+		for _, zero := range []bool{false, true} {
+			reg := "R3"
+			if zero {
+				reg = "ZR"
+			}
+			cases = append(cases, arm64VMOVCase{instruction: "VMOV " + reg + ",V1." + arrangement.name, shape: "duplicate", bytes: arrangement.bytes, destinationLane: arrangement.lanes, zero: zero})
+		}
+	}
+	for _, lanes := range []int{8, 16} {
+		cases = append(cases, arm64VMOVCase{instruction: fmt.Sprintf("VMOV V0.B%d,V1.B%d", lanes, lanes), shape: "copy", bytes: lanes})
+	}
+	return cases
+}
+
+func arm64VMOVSource(cases []arm64VMOVCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·vmovfamily(SB),$0-32\nMOVD src+0(FP),R0\nMOVD dst+8(FP),R1\nMOVD out+16(FP),R2\nMOVD value+24(FP),R3\n")
+	for _, tc := range cases {
+		source.WriteString("VLD1 (R0),[V0.B16]\nVLD1 (R1),[V1.B16]\n" + tc.instruction + "\n")
+		if tc.shape == "extract" {
+			source.WriteString("MOVD R4,(R2)\nMOVD ZR,8(R2)\nADD $16,R2\n")
+		} else {
+			reg := "V1"
+			if tc.alias {
+				reg = "V0"
+			}
+			source.WriteString("VST1.P [" + reg + ".B16],16(R2)\n")
+		}
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func arm64VMOVExpected(cases []arm64VMOVCase, src, dst []byte, value uint64) []byte {
+	out := make([]byte, 16*len(cases))
+	var scalar [8]byte
+	binary.LittleEndian.PutUint64(scalar[:], value)
+	for i, tc := range cases {
+		part := out[16*i : 16*i+16]
+		base := dst
+		if tc.alias {
+			base = src
+		}
+		switch tc.shape {
+		case "lane":
+			copy(part, base)
+			copy(part[tc.destinationLane*tc.bytes:], src[tc.sourceLane*tc.bytes:(tc.sourceLane+1)*tc.bytes])
+		case "scalar", "extract":
+			copy(part, src[tc.sourceLane*tc.bytes:(tc.sourceLane+1)*tc.bytes])
+		case "insert":
+			copy(part, base)
+			bytes := scalar[:tc.bytes]
+			if tc.zero {
+				bytes = make([]byte, tc.bytes)
+			}
+			copy(part[tc.destinationLane*tc.bytes:], bytes)
+		case "duplicate":
+			if !tc.zero {
+				for lane := 0; lane < tc.destinationLane; lane++ {
+					copy(part[lane*tc.bytes:], scalar[:tc.bytes])
+				}
+			}
+		case "copy":
+			copy(part, src[:tc.bytes])
+		}
+	}
+	return out
+}
+
+func arm64VMOVInputs(iteration int) ([]byte, []byte, uint64) {
+	src, dst := make([]byte, 16), make([]byte, 16)
+	for i := range src {
+		src[i] = byte(i*29 + iteration*71 + 13)
+		dst[i] = byte(i*37 + iteration*11 + 193)
+	}
+	return src, dst, 0xfedcba9876543210 ^ uint64(iteration)*0x1717171717171717
+}
+
+func arm64VMOVIR(t *testing.T, triple string, cases []arm64VMOVCase) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "vmovoracle", "package main\nfunc vmovfamily(src,dst,out *byte,value uint64)\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	result, err := translateGoModuleInContext(ctx, pkg, []byte(arm64VMOVSource(cases)), GoModuleOptions{FileName: "move_arm64.s", GOOS: "linux", GOARCH: "arm64", TargetTriple: triple, ResolveSym: testResolveSym("vmovoracle")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer result.Module.Dispose()
+	return result.Module.String()
+}
+
+func TestARM64VMOVCompleteGoFormatsObjects(t *testing.T) {
+	cases := arm64VMOVCases()
+	t.Logf("%d cases cover all six Go AVMOV optab rows and all lane indices", len(cases))
+	requireARM64GoAssemblerResult(t, arm64VMOVSource(cases), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "vmov.ll", "vmov.o", arm64VMOVIR(t, triple, cases))
+		})
+	}
+}
+
+func TestARM64VMOVRejectsNonGoFormats(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOV V0.S[1],V1.H[0]", "VMOV V0.B[16],V1.B[0]",
+		"VMOV V0.H[0],V1.H[8]", "VMOV R0,V1.S[4]",
+		"VMOV V0.D[2],R0", "VMOV V0.Q[0],V1.Q[0]",
+		"VMOV V0,V1", "VMOV V0,R0", "VMOV R0,V1",
+		// Retain the two old helper fixtures as actual Go-rejected negatives.
+		"VMOV V1,V3", "VMOV V2,R0",
+		"VMOV V0.S4,V1.S4", "VMOV V0.B8,V1.B16",
+		"VMOV V0.S[1],V1.S4", "VMOV V0.B16,V1.B[0]",
+		"VMOV V0.B16,R0", "VMOV RSP,V1.D[0]",
+		"VMOV V0.D[0],RSP", "VMOV.P V0.B[0],V1.B[0]",
+		"VMOV V0.S[0],V1.S[0],V2.S[0]", "VMOV (R0),V1.B16",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badmove(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: testResolveSym("vmovoracle"), Sigs: map[string]FuncSig{"vmovoracle.badmove": {Name: "vmovoracle.badmove", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted non-Go VMOV form %q", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VMOVAllTranslationAPIs(t *testing.T) {
+	cases := []arm64VMOVCase{
+		{instruction: "VMOV V0.S[2],V1.S[0]"},
+		{instruction: "VMOV V0.H[7],R4", shape: "extract"},
+		{instruction: "VMOV R3,V1.D[1]"},
+		{instruction: "VMOV V0.B[15],V1"},
+		{instruction: "VMOV R3,V1.S4"},
+		{instruction: "VMOV V0.B8,V1.B8"},
+	}
+	source := arm64VMOVSource(cases)
+	pkg := mustGoPackage(t, "vmovoracle", "package main\nfunc vmovfamily(src,dst,out *byte,value uint64)\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			goModule, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{FileName: "move_arm64.s", GOOS: "linux", GOARCH: "arm64", TargetTriple: triple, ResolveSym: testResolveSym("vmovoracle")})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer goModule.Module.Dispose()
+			compileLLVMToObject(t, llc, triple, "go-module.ll", "go-module.o", goModule.Module.String())
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: testResolveSym("vmovoracle"), Sigs: goModule.Signatures}
+			text, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "text.ll", "text.o", text)
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, triple, "module.ll", "module.o", module.String())
+		})
+	}
+}
+
+func TestARM64VMOVNativeGoRuntime(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("native Go VMOV oracle requires ARM64 or the required Linux/QEMU counterpart")
+	}
+	cases := arm64VMOVCases()
+	var main strings.Builder
+	main.WriteString(`package main
+
+import (
+    "bytes"
+    "encoding/hex"
+    "fmt"
+)
+
+func vmovfamily(src, dst, out *byte, value uint64)
+
+func main() {
+`)
+	for iteration := 0; iteration < 4; iteration++ {
+		src, dst, value := arm64VMOVInputs(iteration)
+		fmt.Fprintf(&main, `{
+    src, _ := hex.DecodeString(%q)
+    dst, _ := hex.DecodeString(%q)
+    want, _ := hex.DecodeString(%q)
+    got := make([]byte, len(want))
+    vmovfamily(&src[0], &dst[0], &got[0], %d)
+    if !bytes.Equal(got, want) {
+        for i := range want {
+            if got[i] != want[i] {
+                panic(fmt.Sprintf("iteration %d case %%d byte %%d got %%02x want %%02x",
+                    i/16, i%%16, got[i], want[i]))
+            }
+        }
+    }
+}
+`, hex.EncodeToString(src), hex.EncodeToString(dst), hex.EncodeToString(arm64VMOVExpected(cases, src, dst, value)), value, iteration)
+	}
+	main.WriteString("}\n")
+	dir := t.TempDir()
+	for name, data := range map[string]string{"go.mod": "module vmovoracle\n\ngo 1.20\n", "main.go": main.String(), "move_arm64.s": arm64VMOVSource(cases)} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run", "."}
+	if cross {
+		if _, err := exec.LookPath("qemu-aarch64"); err != nil {
+			t.Fatal(err)
+		}
+		args = []string{"run", "-exec=qemu-aarch64", "."}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0")
+	if out, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("original Go VMOV runtime: %v\n%s", err, out)
+	}
+}
+
+func TestARM64VMOVLLVMRuntime(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("LLVM VMOV execution requires ARM64; required Linux ARM64 counterpart executes the same full matrix")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	cases := arm64VMOVCases()
+	var main strings.Builder
+	symbol := "vmovoracle.vmovfamily"
+	if runtime.GOOS == "darwin" {
+		symbol = "_" + symbol
+	}
+	fmt.Fprintf(&main, `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+extern void vmovfamily(const uint8_t*, const uint8_t*, uint8_t*, uint64_t) __asm__(%q);
+
+int main(void) {
+`, symbol)
+	for iteration := 0; iteration < 4; iteration++ {
+		src, dst, value := arm64VMOVInputs(iteration)
+		for _, array := range []struct {
+			name  string
+			bytes []byte
+		}{{"src", src}, {"dst", dst}, {"want", arm64VMOVExpected(cases, src, dst, value)}} {
+			if array.name == "src" {
+				main.WriteString("{\n")
+			}
+			fmt.Fprintf(&main, "const uint8_t %s[]={", array.name)
+			for _, b := range array.bytes {
+				fmt.Fprintf(&main, "%d,", b)
+			}
+			main.WriteString("};\n")
+		}
+		fmt.Fprintf(&main, `uint8_t got[sizeof(want)] = {0};
+    vmovfamily(src, dst, got, UINT64_C(%d));
+    for (unsigned i = 0; i < sizeof(want); i++) {
+        if (got[i] != want[i]) {
+            fprintf(stderr, "iteration %d case %%u byte %%u got %%02x want %%02x\n",
+                i/16, i%%16, got[i], want[i]);
+            return 1;
+        }
+    }
+}
+`, value, iteration)
+	}
+	main.WriteString("    return 0;\n}\n")
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vmov", triple, arm64VMOVIR(t, triple, cases), main.String(), nil)
+}
diff --git a/arm64_lower_movk_complete_test.go b/arm64_lower_movk_complete_test.go
new file mode 100644
index 000000000..86b202940
--- /dev/null
+++ b/arm64_lower_movk_complete_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64MOVKCompleteFormats(t *testing.T) {
+	const source = `TEXT movkComplete(SB),$0-0
+	MOVK $1, R1
+	MOVK $(1<<12), R0
+	MOVK $(2<<16), R2
+	MOVK $(3<<32), R3
+	MOVK $(4<<48), R4
+	MOVK $5, ZR
+	MOVKW $6, R5
+	MOVKW $(7<<16), R6
+	MOVKW $8, ZR
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"movkComplete": {Name: "movkComplete", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"and i64", "or i64", "and i32", "or i32", "zext i32"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 MOVK lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-movk-complete.ll", "arm64-movk-complete.o", ll)
+}
+
+func TestTranslateARM64MOVKRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVK $0, R0",
+		"MOVK $0x10001, R0",
+		"MOVK $1, RSP",
+		"MOVK $1, 8(R0)",
+		"MOVK.P $1, R0",
+		"MOVKW $(1<<32), R0",
+		"MOVKW $-1, R0",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 MOVK optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_mrs_test.go b/arm64_lower_mrs_test.go
new file mode 100644
index 000000000..8f7a114e8
--- /dev/null
+++ b/arm64_lower_mrs_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var arm64FeatureRegisters = []struct {
+	name string
+	word uint32
+}{
+	{"MIDR_EL1", 0xd5380000},
+	{"ID_AA64PFR0_EL1", 0xd5380400},
+	{"ID_AA64ISAR0_EL1", 0xd5380600},
+	{"ID_AA64ISAR1_EL1", 0xd5380620},
+	{"ID_AA64ZFR0_EL1", 0xd5380480},
+}
+
+func arm64MRSFeatureFixture(t *testing.T, raw, cfg bool) (*File, map[string]FuncSig) {
+	t.Helper()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, register := range arm64FeatureRegisters {
+		name := fmt.Sprintf("read_feature_%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-8\n", name)
+		if cfg {
+			source.WriteString("B read\nread:\n")
+		}
+		if raw {
+			fmt.Fprintf(&source, "WORD $%#08x\n", register.word)
+		} else {
+			fmt.Fprintf(&source, "MRS %s, R0\n", register.name)
+		}
+		source.WriteString("MOVD R0, ret+0(FP)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{
+			Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+		}}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, sigs
+}
+
+func translateARM64MRSModule(t *testing.T, file *File, options Options) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod, err := TranslateModuleInContext(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer mod.Dispose()
+	return mod.String()
+}
+
+func TestARM64MRSFeatureReadsAreNotCompileOnlyConstants(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, form := range []struct {
+		name     string
+		raw, cfg bool
+	}{
+		{"text_linear", false, false},
+		{"text_cfg", false, true},
+		{"raw_linear", true, false},
+		{"raw_cfg", true, true},
+	} {
+		file, sigs := arm64MRSFeatureFixture(t, form.raw, form.cfg)
+		for _, triple := range []string{
+			"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+		} {
+			for _, module := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/module=%v", form.name, triple, module), func(t *testing.T) {
+					options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs}
+					var ir string
+					if module {
+						ir = translateARM64MRSModule(t, file, options)
+					} else {
+						var err error
+						ir, err = Translate(file, options)
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+					for _, register := range arm64FeatureRegisters {
+						physical := arm64EncodedSystemRegisterName(uint16((register.word >> 5) & 0x7fff))
+						want := `asm sideeffect "mrs $0, ` + physical + `"`
+						if !strings.Contains(ir, want) {
+							t.Errorf("missing real, observable %s read; constants are not assembly semantics", register.name)
+						}
+					}
+					if !t.Failed() {
+						compileLLVMToObject(t, llc, triple, "mrs.ll", "mrs.o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64MRSCompleteGoSystemRegisterTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src", "cmd", "internal", "obj", "arm64", "sysRegEnc.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{"([A-Za-z0-9_]+)", REG_\w+, (0x[0-9a-f]+), ([^}]+)\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) == 0 {
+		t.Fatal("Go system register table was not enumerated")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT system_registers(SB),$0-0\n")
+	var native []string
+	var expected []uint32
+	reads, writes := 0, 0
+	for _, row := range rows {
+		encoding, err := strconv.ParseUint(row[2], 0, 32)
+		if err != nil {
+			t.Fatal(err)
+		}
+		spec, ok := arm64GoSystemRegisters[row[1]]
+		if !ok || spec.encoding != uint16((encoding>>5)&0x7fff) ||
+			spec.readable != strings.Contains(row[3], "SR_READ") ||
+			spec.writable != strings.Contains(row[3], "SR_WRITE") {
+			t.Fatalf("typed register metadata disagrees with Go: %s", row[0])
+		}
+		if spec.readable {
+			if row[1] == "NZCV" {
+				// Other system-register callouts above do not supply source
+				// NZCV. Seed this exact modeled read without granting entry flags.
+				source.WriteString("CMP R0,R0\n")
+			}
+			fmt.Fprintf(&source, "MRS %s, R0\n", row[1])
+			native = append(native, "mrs x0, "+arm64CanonicalSysReg(row[1]))
+			expected = append(expected, 0xd5300000|uint32(encoding))
+			reads++
+		}
+		if spec.writable {
+			fmt.Fprintf(&source, "MSR R0, %s\n", row[1])
+			native = append(native, "msr "+arm64CanonicalSysReg(row[1])+", x0")
+			expected = append(expected, 0xd5100000|uint32(encoding))
+			writes++
+		}
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	actual := assembleARM64LLVMWords(t, native, "")
+	for index, word := range expected {
+		if actual[index] != word {
+			t.Errorf("%s: LLVM word %#08x, want Go word %#08x", native[index], actual[index], word)
+		}
+	}
+	t.Logf("Go system-register table: names=%d readable=%d writable=%d", len(rows), reads, writes)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"system_registers": {Name: "system_registers", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			// NZCV is the modeled flag state; RNDR/RNDRRS use observable
+			// intrinsics that also define NZCV. Every other read is native MRS.
+			if count := strings.Count(ir, `asm sideeffect "mrs $0, `); count != reads-3 {
+				t.Fatalf("real reads=%d, Go-readable registers=%d", count, reads)
+			}
+			for _, intrinsic := range []string{"rndr", "rndrrs"} {
+				want := "call { i64, i1 } @llvm.aarch64." + intrinsic + "()"
+				if count := strings.Count(ir, want); count != 1 {
+					t.Fatalf("%s native RNG reads=%d, want 1", intrinsic, count)
+				}
+			}
+			if count := strings.Count(ir, `asm sideeffect "msr `); count != writes-1 {
+				t.Fatalf("real writes=%d, Go-writable registers=%d", count, writes)
+			}
+			compileLLVMToObject(t, llc, triple, "mrs-table.ll", "mrs-table.o", ir)
+		})
+	}
+}
+
+func TestARM64MRSMSRRejectGoRegisterAccessViolations(t *testing.T) {
+	for _, instruction := range []string{
+		"MRS OSLAR_EL1, R0", "MSR R0, MIDR_EL1", "MSR $0, MIDR_EL1",
+	} {
+		for _, cfg := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/cfg=%v", instruction, cfg), func(t *testing.T) {
+				source := "TEXT bad_access(SB),$0-0\n"
+				if cfg {
+					source += "B access\naccess:\n"
+				}
+				source += instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"bad_access": {Name: "bad_access", Ret: Void}},
+				}
+				_, err = Translate(file, options)
+				if err == nil || !strings.Contains(err.Error(), "is not") {
+					t.Fatalf("Go-rejected access became successful translation: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_lower_msr_test.go b/arm64_lower_msr_test.go
new file mode 100644
index 000000000..6858851cc
--- /dev/null
+++ b/arm64_lower_msr_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64MSRCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·systemRegisterForms(SB), $0-0\n")
+	for _, field := range []string{"SPSel", "DAIFSet", "DAIFClr", "DIT"} {
+		first := 0
+		if field == "DAIFSet" || field == "DAIFClr" {
+			// Go parses $0 as ZR, which is not an immediate PSTATE form
+			// for these special operands.
+			first = 1
+		}
+		for immediate := first; immediate < 16; immediate++ {
+			fmt.Fprintf(&source, "\tMSR $%d, %s\n", immediate, field)
+		}
+	}
+	source.WriteString("\tMSR $0, CPACR_EL1\n")
+	source.WriteString("\tMSR R0, DAIF\n")
+	source.WriteString("\tMRS DAIF, R1\n")
+	source.WriteString("\tRET\n")
+
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"systemRegisterForms": {Name: "systemRegisterForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"msr SPSel, xzr",
+				"msr SPSel, #1",
+				"msr DAIFSet, #2",
+				"msr DAIFClr, #15",
+				"msr DIT, xzr",
+				"msr DIT, #1",
+				`"target-features"="+dit"`,
+				"msr S3_0_C1_C0_2, xzr",
+				"msr S3_3_C4_C2_1, $0",
+				"mrs $0, S3_3_C4_C2_1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 MSR lowering omitted %q", want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-msr.ll", "arm64-msr.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64MSRRejectsImmediateOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"MSR $-1, DAIFSet",
+		"MSR $0, DAIFSet",
+		"MSR $0, DAIFClr",
+		"MSR $16, DAIFClr",
+		"MSR $16, SPSel",
+		"MSR $16, DIT",
+		"MSR $1, CPACR_EL1",
+		"MSR R0, DAIFSet",
+	} {
+		source := "TEXT ·badMSR(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"badMSR": {Name: "badMSR", Ret: Void},
+			},
+		})
+		if err == nil {
+			t.Fatalf("accepted %s outside Go's MSR immediate format", instruction)
+		}
+	}
+}
+
+func TestARM64MSRPStateEncodingMatchesGoAssembler(t *testing.T) {
+	// Go 1.27's -S listing supplies these words independently of the LLVM
+	// encoder. These privileged instructions cannot run in a user-mode test.
+	for _, tc := range []struct {
+		goForm   string
+		llvmForm string
+		word     uint32
+	}{
+		{"MSR $0, SPSel", "msr SPSel, xzr", 0xd518421f},
+		{"MSR $1, SPSel", "msr SPSel, #1", 0xd50041bf},
+		{"MSR $2, DAIFSet", "msr DAIFSet, #2", 0xd50342df},
+		{"MSR $15, DAIFClr", "msr DAIFClr, #15", 0xd5034fff},
+		{"MSR $0, DIT", "msr DIT, xzr", 0xd51b42bf},
+		{"MSR $1, DIT", "msr DIT, #1", 0xd503415f},
+		{"MSR $0, CPACR_EL1", "msr CPACR_EL1, xzr", 0xd518105f},
+	} {
+		source := "TEXT ·msrOracle(SB), $0-0\n\t" + tc.goForm + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		words := assembleARM64LLVMWords(t, []string{tc.llvmForm}, "+dit")
+		if words[0] != tc.word {
+			t.Fatalf("%s: LLVM encoded %#08x, Go encoded %#08x", tc.goForm, words[0], tc.word)
+		}
+	}
+}
diff --git a/arm64_lower_multiply_accumulate.go b/arm64_lower_multiply_accumulate.go
new file mode 100644
index 000000000..2e31e77fb
--- /dev/null
+++ b/arm64_lower_multiply_accumulate.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import "fmt"
+
+type arm64MultiplyAccumulateSpec struct {
+	word, long, signed, subtract bool
+}
+
+// The complete Go AMADD row: four C_ZREG operands in Rm, Ra, Rn, Rd order.
+var arm64MultiplyAccumulateOps = map[Op]arm64MultiplyAccumulateSpec{
+	"MADD":   {},
+	"MSUB":   {subtract: true},
+	"MADDW":  {word: true},
+	"MSUBW":  {word: true, subtract: true},
+	"SMADDL": {long: true, signed: true},
+	"SMSUBL": {long: true, signed: true, subtract: true},
+	"UMADDL": {long: true},
+	"UMSUBL": {long: true, subtract: true},
+}
+
+func (c *arm64Ctx) lowerARM64MultiplyAccumulate(spec arm64MultiplyAccumulateSpec, ins Instr) error {
+	// Read all inputs before writing Rd: it may alias any source. In Go
+	// syntax the middle source is the addend, not the second multiplicand.
+	if spec.long {
+		return c.lowerARM64MultiplyAddLong(spec.signed, spec.subtract,
+			ins.Args[0], ins.Args[2], ins.Args[1], ins.Args[3].Reg)
+	}
+	evaluate := func(operand Operand) (string, error) {
+		if spec.word {
+			return c.eval32(operand)
+		}
+		return c.eval64(operand, false)
+	}
+	m, err := evaluate(ins.Args[0])
+	if err != nil {
+		return err
+	}
+	a, err := evaluate(ins.Args[1])
+	if err != nil {
+		return err
+	}
+	n, err := evaluate(ins.Args[2])
+	if err != nil {
+		return err
+	}
+	width := "i64"
+	if spec.word {
+		width = "i32"
+	}
+	operation := "add"
+	if spec.subtract {
+		operation = "sub"
+	}
+	product, result := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, width, m, n)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, operation, width, a, product)
+	if spec.word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		result = wide
+	}
+	return c.storeReg(ins.Args[3].Reg, "%"+result)
+}
diff --git a/arm64_lower_multiply_accumulate_test.go b/arm64_lower_multiply_accumulate_test.go
new file mode 100644
index 000000000..b07931afa
--- /dev/null
+++ b/arm64_lower_multiply_accumulate_test.go
@@ -0,0 +1,273 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent of the lowering table: Go's AMADD encoder row uses Rm, Ra, Rn,
+// Rd, while architectural assembly uses Rd, Rn, Rm, Ra.
+var arm64MultiplyAccumulateTestOps = []string{
+	"MADD", "MSUB", "MADDW", "MSUBW", "SMADDL", "SMSUBL", "UMADDL", "UMSUBL",
+}
+
+var arm64MultiplyAccumulateInputs = [][3]uint64{
+	{2, 3, 11}, {0, 1, 7}, {^uint64(0), 2, 3},
+	{0xffffffff80000003, 0x8000000000000005, 0x1020304050607080},
+	{0x80000000, 0xffffffff, ^uint64(0)}, {1 << 63, 1 << 63, 1 << 63},
+}
+
+func arm64MultiplyAccumulateSource(t *testing.T) string {
+	t.Helper()
+	var named, machine, results []string
+	for _, op := range arm64MultiplyAccumulateTestOps {
+		for shape := 0; shape < 8; shape++ {
+			registers := []int{0, 1, 2, 4}
+			if shape >= 1 && shape <= 3 {
+				registers[3] = shape - 1 // Each destination/source alias.
+			} else if shape >= 4 && shape <= 6 {
+				registers[shape-4] = 31 // Each zero source, including the addend.
+			} else if shape == 7 {
+				registers[3] = 31
+			}
+			goReg := func(n int) string {
+				if n == 31 {
+					return "ZR"
+				}
+				return fmt.Sprintf("R%d", n)
+			}
+			machineReg := func(n, width int) string {
+				prefix := "x"
+				if width == 32 {
+					prefix = "w"
+				}
+				if n == 31 {
+					return prefix + "zr"
+				}
+				return fmt.Sprintf("%s%d", prefix, n)
+			}
+			width, resultWidth := 64, 64
+			if strings.HasSuffix(op, "W") || strings.HasSuffix(op, "L") {
+				width = 32
+			}
+			if strings.HasSuffix(op, "W") {
+				resultWidth = 32
+			}
+			machine = append(machine, fmt.Sprintf("%s %s, %s, %s, %s", strings.ToLower(strings.TrimSuffix(op, "W")),
+				machineReg(registers[3], resultWidth), machineReg(registers[1], width),
+				machineReg(registers[0], width), machineReg(registers[2], resultWidth)))
+			named = append(named, fmt.Sprintf("%s %s,%s,%s,%s", op, goReg(registers[0]),
+				goReg(registers[2]), goReg(registers[1]), goReg(registers[3])))
+			result := registers[3]
+			if result == 31 {
+				result = 0 // Writing ZR must not change the input.
+			}
+			results = append(results, goReg(result))
+		}
+	}
+	// One assembler process for the whole independent-axis matrix.
+	words := assembleARM64LLVMWords(t, machine, "")
+	var source strings.Builder
+	source.WriteString("TEXT multiplyAccumulate(SB),$0-32\nMOVD out+24(FP),R3\n")
+	for i, instruction := range named {
+		for kind, form := range []string{instruction, fmt.Sprintf("WORD $%#08x", words[i])} {
+			source.WriteString("MOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD add+16(FP),R2\n")
+			fmt.Fprintf(&source, "%s\nMOVD %s,%d(R3)\n", form, results[i], (i*2+kind)*8)
+		}
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func arm64MultiplyAccumulateExpected(input [3]uint64) []uint64 {
+	var result []uint64
+	for _, op := range arm64MultiplyAccumulateTestOps {
+		for shape := 0; shape < 8; shape++ {
+			operands := input
+			if shape >= 4 && shape <= 6 {
+				operands[shape-4] = 0
+			}
+			a, b, add := operands[0], operands[1], operands[2]
+			if strings.HasPrefix(op, "S") {
+				a, b = uint64(int64(int32(a))), uint64(int64(int32(b)))
+			} else if strings.HasPrefix(op, "U") {
+				a, b = uint64(uint32(a)), uint64(uint32(b))
+			}
+			want := add + a*b
+			if strings.Contains(op, "SUB") {
+				want = add - a*b
+			}
+			if strings.HasSuffix(op, "W") {
+				want = uint64(uint32(want))
+			}
+			if shape == 7 {
+				want = input[0]
+			}
+			result = append(result, want, want)
+		}
+	}
+	return result
+}
+
+func arm64MultiplyAccumulateIR(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	source := arm64MultiplyAccumulateSource(t)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"multiplyAccumulate": {
+			Name: "multiplyAccumulate", Args: []LLVMType{I64, I64, I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var main strings.Builder
+	main.WriteString(`#include <stdint.h>
+#include <stdio.h>
+extern void multiplyAccumulate(uint64_t, uint64_t, uint64_t, uint64_t*);
+int main(void) {
+`)
+	for i, input := range arm64MultiplyAccumulateInputs {
+		want := arm64MultiplyAccumulateExpected(input)
+		fmt.Fprintf(&main, "{ uint64_t got[%d] = {0};\nmultiplyAccumulate(%dULL,%dULL,%dULL,got);\n", len(want), input[0], input[1], input[2])
+		main.WriteString("const uint64_t want[] = {\n")
+		for _, value := range want {
+			fmt.Fprintf(&main, "%dULL,\n", value)
+		}
+		fmt.Fprintf(&main, `};
+  for (unsigned j = 0; j < %d; j++) {
+    if (got[j] != want[j]) {
+      fprintf(stderr, "multiply input=%d case=%%u actual=%%llx expected=%%llx\n",
+              j, (unsigned long long)got[j], (unsigned long long)want[j]);
+      return 1;
+    }
+  }
+}
+`, len(want), i)
+	}
+	main.WriteString("return 0;\n}\n")
+	return ir, main.String()
+}
+
+func TestARM64MultiplyAccumulateLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64MultiplyAccumulateIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "multiply.ll", "multiply.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "multiply", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func TestARM64MultiplyAccumulateNativeGo(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("native Go oracle runs on arm64 or required Linux/QEMU")
+	}
+	source := strings.Replace(arm64MultiplyAccumulateSource(t), "TEXT multiplyAccumulate", "TEXT ·multiplyAccumulate", 1)
+	var main strings.Builder
+	main.WriteString(`package main
+func multiplyAccumulate(a, b, add uint64, out *uint64)
+func main() {
+`)
+	for i, input := range arm64MultiplyAccumulateInputs {
+		want := arm64MultiplyAccumulateExpected(input)
+		fmt.Fprintf(&main, "{ var got [%d]uint64\nmultiplyAccumulate(%d,%d,%d,&got[0])\nwant := [...]uint64{", len(want), input[0], input[1], input[2])
+		for _, value := range want {
+			fmt.Fprintf(&main, "%d,", value)
+		}
+		fmt.Fprintf(&main, `}
+  for j := range want {
+    if got[j] != want[j] {
+      println(%d, j, got[j], want[j])
+      panic("multiply mismatch")
+    }
+  }
+}
+`, i)
+	}
+	main.WriteString("}\n")
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module multiplyoracle\n\ngo 1.20\n",
+		"main.go": main.String(), "multiply_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run", "."}
+	if cross {
+		if _, err := exec.LookPath("qemu-aarch64"); err != nil {
+			t.Fatal(err)
+		}
+		args = []string{"run", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.Command("go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("Go multiply oracle: %v\n%s", err, out)
+	}
+}
+
+func TestARM64MultiplyAccumulateRejectsNonGoForms(t *testing.T) {
+	if len(arm64MultiplyAccumulateOps) != len(arm64MultiplyAccumulateTestOps) {
+		t.Fatal("multiply-accumulate grammar differs from the complete Go AMADD family")
+	}
+	for _, op := range arm64MultiplyAccumulateTestOps {
+		if _, ok := arm64MultiplyAccumulateOps[Op(op)]; !ok {
+			t.Fatalf("missing Go AMADD family member %s", op)
+		}
+		forms := []string{
+			op + " R0,R1,R2", op + " R0,R1,R2,R3,R4", op + ".P R0,R1,R2,R3",
+			op + " $1,R1,R2,R3", op + " R0,(R1),R2,R3", op + " R0,R1,F2,R3",
+		}
+		for position := 0; position < 4; position++ {
+			operands := []string{"R0", "R1", "R2", "R3"}
+			operands[position] = "RSP"
+			forms = append(forms, op+" "+strings.Join(operands, ","))
+		}
+		for _, instruction := range forms {
+			t.Run(instruction, func(t *testing.T) {
+				source := "TEXT bad(SB),$0-0\n" + instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+				})
+				if err == nil {
+					t.Fatalf("accepted form rejected by Go: %s", instruction)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_lower_negate.go b/arm64_lower_negate.go
new file mode 100644
index 000000000..0bff79ab9
--- /dev/null
+++ b/arm64_lower_negate.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerNegate implements the complete Go 1.27 NEG and negate-with-carry
+// families: NEG/NEGW/NEGS/NEGSW and NGC/NGCW/NGCS/NGCSW.
+func (c *arm64Ctx) lowerNegate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	rawOp := strings.ToUpper(string(op))
+	baseOp := rawOp
+	if dot := strings.IndexByte(baseOp, '.'); dot >= 0 {
+		baseOp = baseOp[:dot]
+	}
+	word, setFlags, withCarry, recognized := arm64NegateProperties(baseOp)
+	if !recognized {
+		return false, false, nil
+	}
+	originalOp := rawOp
+	if ins.Op != "" {
+		originalOp = strings.ToUpper(string(ins.Op))
+	}
+	if originalOp != baseOp {
+		return true, false, fmt.Errorf("arm64 %s does not accept instruction suffixes: %q", baseOp, ins.Raw)
+	}
+
+	if withCarry {
+		return c.lowerNegateWithCarry(baseOp, ins)
+	}
+	if len(ins.Args) != 1 && len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects source[, destination]: %q", baseOp, ins.Raw)
+	}
+	source := ins.Args[0]
+	destination := source
+	if len(ins.Args) == 2 {
+		destination = ins.Args[1]
+	}
+	if err := validateARM64NegateSource(source, word); err != nil {
+		return true, false, fmt.Errorf("arm64 %s source: %w: %q", baseOp, err, ins.Raw)
+	}
+	if destination.Kind != OpReg || !isARM64GeneralOrZeroReg(destination.Reg) {
+		return true, false, fmt.Errorf("arm64 %s destination is outside Go 1.27's C_ZREG class: %q", baseOp, ins.Raw)
+	}
+
+	if word {
+		sourceValue, err := c.eval32(source)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub i32 0, %s\n", result, sourceValue)
+		if setFlags {
+			c.setFlagsSub32("0", sourceValue, "%"+result)
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		return true, false, c.storeReg(destination.Reg, "%"+wide)
+	}
+	sourceValue, err := c.eval64(source, false)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub i64 0, %s\n", result, sourceValue)
+	if setFlags {
+		c.setFlagsSub("0", sourceValue, "%"+result)
+	}
+	return true, false, c.storeReg(destination.Reg, "%"+result)
+}
+
+func arm64NegateProperties(op string) (word, setFlags, withCarry, ok bool) {
+	switch op {
+	case "NEG":
+		return false, false, false, true
+	case "NEGW":
+		return true, false, false, true
+	case "NEGS":
+		return false, true, false, true
+	case "NEGSW":
+		return true, true, false, true
+	case "NGC":
+		return false, false, true, true
+	case "NGCW":
+		return true, false, true, true
+	case "NGCS":
+		return false, true, true, true
+	case "NGCSW":
+		return true, true, true, true
+	default:
+		return false, false, false, false
+	}
+}
+
+func validateARM64NegateSource(source Operand, word bool) error {
+	switch source.Kind {
+	case OpReg:
+		if !isARM64GeneralOrZeroReg(source.Reg) {
+			return fmt.Errorf("operand is outside Go 1.27's C_ZREG class")
+		}
+		return nil
+	case OpRegShift:
+		if !isARM64GeneralOrZeroReg(source.Reg) || source.ShiftReg != "" {
+			return fmt.Errorf("operand is outside Go 1.27's C_SHIFT class")
+		}
+		if source.ShiftOp != ShiftLeft && source.ShiftOp != ShiftRight && source.ShiftOp != ShiftArith {
+			return fmt.Errorf("unsupported shift operator %q", source.ShiftOp)
+		}
+		maximum := int64(63)
+		if word {
+			maximum = 31
+		}
+		if source.ShiftAmount < 0 || source.ShiftAmount > maximum {
+			return fmt.Errorf("shift amount %d is outside 0..%d", source.ShiftAmount, maximum)
+		}
+		return nil
+	default:
+		return fmt.Errorf("operand is outside Go 1.27's C_ZREG/C_SHIFT classes")
+	}
+}
+
+func (c *arm64Ctx) lowerNegateWithCarry(op string, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64CarryForm(Op(op), ins)
+	if !handled || !form.negate {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if err := c.requireARM64Flags(arm64FlagC, op); err != nil {
+		return true, false, err
+	}
+	typeName := LLVMType(I64)
+	wideType := LLVMType("i128")
+	if form.word {
+		typeName = I32
+		wideType = I64
+	}
+	var source string
+	if form.word {
+		source, err = c.eval32(ins.Args[0])
+	} else {
+		source, err = c.eval64(ins.Args[0], false)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	wideSource := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", wideSource, typeName, source, wideType)
+	carry := c.newTmp()
+	borrow := c.newTmp()
+	wideBorrow := c.newTmp()
+	c.recordMachineRegister(Reg(c.flagsCSlot), 1, false)
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", carry, c.flagsCSlot)
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", borrow, carry)
+	fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to %s\n", wideBorrow, borrow, wideType)
+	subtrahend := c.newTmp()
+	wideResult := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", subtrahend, wideType, wideSource, wideBorrow)
+	fmt.Fprintf(c.b, "  %%%s = sub %s 0, %%%s\n", wideResult, wideType, subtrahend)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, wideResult, typeName)
+	resultValue := "%" + result
+	if form.setFlags {
+		c.setNegateWithCarryFlags(typeName, wideType, source, resultValue, "%"+subtrahend)
+	}
+	stored := resultValue
+	if form.word {
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, resultValue)
+		stored = "%" + wide
+	}
+	return true, false, c.storeReg(form.destination.Reg, stored)
+}
+
+func (c *arm64Ctx) setNegateWithCarryFlags(typeName, wideType LLVMType, source, result, wideSubtrahend string) {
+	c.flagsWritten = true
+	zero := c.newTmp()
+	negative := c.newTmp()
+	carry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, 0\n", zero, typeName, result)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %s, 0\n", negative, typeName, result)
+	fmt.Fprintf(c.b, "  %%%s = icmp uge %s 0, %s\n", carry, wideType, wideSubtrahend)
+	xorOperands := c.newTmp()
+	xorResult := c.newTmp()
+	overflowBits := c.newTmp()
+	overflow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = xor %s 0, %s\n", xorOperands, typeName, source)
+	fmt.Fprintf(c.b, "  %%%s = xor %s 0, %s\n", xorResult, typeName, result)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", overflowBits, typeName, xorOperands, xorResult)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, 0\n", overflow, typeName, overflowBits)
+	c.storeFlag(c.flagsNSlot, "%"+negative)
+	c.storeFlag(c.flagsZSlot, "%"+zero)
+	c.storeFlag(c.flagsCSlot, "%"+carry)
+	c.storeFlag(c.flagsVSlot, "%"+overflow)
+}
diff --git a/arm64_lower_negate_test.go b/arm64_lower_negate_test.go
new file mode 100644
index 000000000..c163488b4
--- /dev/null
+++ b/arm64_lower_negate_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64NegateCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT negateforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"NEG", "NEGW", "NEGS", "NEGSW"} {
+		source.WriteString("\t" + op + " R1, R2\n")
+		source.WriteString("\t" + op + " R2\n")
+		source.WriteString("\t" + op + " R3<<1, R4\n")
+		source.WriteString("\t" + op + " R5>>1, R6\n")
+		source.WriteString("\t" + op + " R7->1, R8\n")
+	}
+	for _, op := range []string{"NGC", "NGCW", "NGCS", "NGCSW"} {
+		source.WriteString("\t" + op + " R9, R10\n")
+	}
+	source.WriteString("\tRET\n")
+
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"negateforms": {Name: "negateforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm64-negate-"+target.name+".ll", "arm64-negate-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64NegateRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"NEG $1, R0",
+		"NEG 0(R1), R0",
+		"NEG RSP, R0",
+		"NEG R0, RSP",
+		"NEG R0, R1, R2",
+		"NEG R1<<64, R2",
+		"NEGW R1<<32, R2",
+		"NEGS R1@>2, R2",
+		"NGC R1",
+		"NGC R1<<1, R2",
+		"NGCS RSP, R2",
+		"NGCSW R1, RSP",
+		"NGC.P R1, R2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT bad(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 NEG/NGC tables", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64NegateRuntimeSemantics(t *testing.T) {
+	crossLinux := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !crossLinux {
+		t.Skip("runtime execution test only runs on an arm64 host")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compiler := []string{}
+	var runPrefix []string
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	if crossLinux {
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		runPrefix = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+		triple = "aarch64-unknown-linux-gnu"
+	} else {
+		_, clang, ok := findLlcAndClang(t)
+		if !ok {
+			t.Fatal("clang not found")
+		}
+		compiler = []string{clang}
+	}
+
+	const source = `
+TEXT negatesemantics(SB),NOSPLIT,$0-8
+	MOVD out+0(FP), R20
+	MOVD $5, R0
+	NEGS R0, R1
+	CSET CS, R2
+	CSET MI, R3
+	NGCS R0, R4
+	MOVD R1, 0(R20)
+	MOVD R2, 8(R20)
+	MOVD R3, 16(R20)
+	MOVD R4, 24(R20)
+	NEGS ZR, R5
+	NGC R0, R6
+	MOVD R6, 32(R20)
+	MOVD $0x80000000, R7
+	NEGSW R7, R8
+	CSET VS, R9
+	MOVD R8, 40(R20)
+	MOVD R9, 48(R20)
+	NGCW R0, R10
+	MOVD R10, 56(R20)
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"negatesemantics": {
+				Name: "negatesemantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void negatesemantics(uint64_t *);
+int main(void) {
+  uint64_t got[8] = {0};
+  const uint64_t want[8] = {
+    UINT64_MAX-4, 0, 1, UINT64_MAX-5,
+    UINT64_MAX-4, 0x80000000ULL, 1, 0xfffffffaULL
+  };
+  negatesemantics(got);
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i+1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "arm64_negate", triple, ll, mainC, runPrefix)
+}
diff --git a/arm64_lower_pc_relative.go b/arm64_lower_pc_relative.go
new file mode 100644
index 000000000..279840c8c
--- /dev/null
+++ b/arm64_lower_pc_relative.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerPCRelativeAddress(bi int, op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "ADR", "ADRP":
+	default:
+		return false, false, nil
+	}
+	if strings.Contains(strings.ToUpper(string(ins.Op)), ".") {
+		return true, false, fmt.Errorf("arm64 %s does not accept a suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 %s expects label|n(PC), general register: %q", op, ins.Raw)
+	}
+
+	target, targetOK := c.resolveBranchTarget(bi, ins.Args[0])
+	if !targetOK || (ins.Args[0].Kind != OpIdent && ins.Args[0].Kind != OpSym &&
+		(ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != PC)) {
+		return true, false, fmt.Errorf("arm64 %s expects label|n(PC), general register: %q", op, ins.Raw)
+	}
+	if ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
+		return true, false, fmt.Errorf("arm64 %s expects a local label or n(PC): %q", op, ins.Raw)
+	}
+	knownTarget := false
+	for _, block := range c.blocks {
+		if block.name == target {
+			knownTarget = true
+			break
+		}
+	}
+	if !knownTarget {
+		return true, false, fmt.Errorf("arm64 %s undefined local target %q: %q", op, target, ins.Raw)
+	}
+
+	address := c.newTmp()
+	if global, ok := c.rawDataGlobals[target]; ok {
+		pointer := llvmGlobal(global)
+		if offset := c.rawDataOffsets[target]; offset != 0 {
+			pointer = fmt.Sprintf("getelementptr (i8, ptr %s, i64 %d)", pointer, offset)
+		}
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", address, pointer)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr blockaddress(%s, %%%s) to i64\n", address, llvmGlobal(c.sig.Name), arm64LLVMBlockName(target))
+	}
+	value := "%" + address
+	if op == "ADRP" {
+		page := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, -4096\n", page, value)
+		value = "%" + page
+	}
+	return true, false, c.storeReg(ins.Args[1].Reg, value)
+}
diff --git a/arm64_lower_pc_relative_test.go b/arm64_lower_pc_relative_test.go
new file mode 100644
index 000000000..2c2c05737
--- /dev/null
+++ b/arm64_lower_pc_relative_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64PCRelativeAddressCompleteGoAssemblerForms(t *testing.T) {
+	const source = `
+TEXT pcRelativeAddressForms(SB),$0-0
+	MOVD R30, R19
+	ADR target, R0
+	ADRP target, R1
+	ADR -2(PC), R2
+	ADR 2(PC), R3
+	ADRP -2(PC), R29
+	ADRP 2(PC), R30
+	ADR target, ZR
+	ADRP target, ZR
+target:
+	MOVD R19, R30
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{name: "darwin-arm64", triple: "arm64-apple-darwin"},
+		{name: "linux-arm64", triple: "aarch64-unknown-linux-gnu"},
+		{name: "windows-arm64", triple: "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"pcRelativeAddressForms": {Name: "pcRelativeAddressForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, "blockaddress("); got != 8 {
+				t.Fatalf("emitted %d block addresses, want 8:\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm64-pc-relative-"+target.name+".ll", "arm64-pc-relative-"+target.name+".o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64PCRelativeAddressRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"ADR R1, R2",
+		"ADR $1, R2",
+		"ADR target, RSP",
+		"ADR target, V0",
+		"ADR target",
+		"ADR target, R1, R2",
+		"ADRP 0(R1), R2",
+		"ADRP.P target, R2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badPCRelativeAddress(SB),$0-0\n\t" + instruction + "\ntarget:\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badPCRelativeAddress": {Name: "badPCRelativeAddress", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 ADR/ADRP table", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_permute.go b/arm64_lower_permute.go
new file mode 100644
index 000000000..26fcff886
--- /dev/null
+++ b/arm64_lower_permute.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorPermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "VZIP1", "VZIP2", "VUZP1", "VUZP2", "VTRN1", "VTRN2":
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers: %q", op, ins.Raw)
+	}
+	allowed := func(a arm64VectorArrangement) bool {
+		return (a.elementBits == 8 && (a.lanes == 8 || a.lanes == 16)) ||
+			(a.elementBits == 16 && (a.lanes == 4 || a.lanes == 8)) ||
+			(a.elementBits == 32 && (a.lanes == 2 || a.lanes == 4)) ||
+			(a.elementBits == 64 && a.lanes == 2)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || !allowed(parsed) {
+			return true, false, fmt.Errorf("arm64 %s has an invalid vector arrangement: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	// Go's Plan 9 order is Vm, Vn, Vd, while the architectural operation is
+	// written Vd, Vn, Vm. Keep Vn as LLVM's first shuffle input so the masks
+	// below follow the ARM lane descriptions directly.
+	m, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	n, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	mask := arm64VectorPermuteMask(string(op), arrangement.lanes)
+	if len(mask) != arrangement.lanes {
+		return true, false, fmt.Errorf("arm64 %s could not construct a vector shuffle mask: %q", op, ins.Raw)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  ; arm64 vector permute %s\n", op)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> %s, <%d x i32> <", result, arrangement.lanes, arrangement.elementBits, n, arrangement.lanes, arrangement.elementBits, m, arrangement.lanes)
+	for i, lane := range mask {
+		if i != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", lane)
+	}
+	c.b.WriteString(">\n")
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+}
+
+func arm64VectorPermuteMask(op string, lanes int) []int {
+	mask := make([]int, 0, lanes)
+	switch op {
+	case "VZIP1", "VZIP2":
+		start := 0
+		if op == "VZIP2" {
+			start = lanes / 2
+		}
+		for lane := start; lane < start+lanes/2; lane++ {
+			mask = append(mask, lane, lanes+lane)
+		}
+	case "VUZP1", "VUZP2":
+		start := 0
+		if op == "VUZP2" {
+			start = 1
+		}
+		for lane := start; lane < lanes; lane += 2 {
+			mask = append(mask, lane)
+		}
+		for lane := start; lane < lanes; lane += 2 {
+			mask = append(mask, lanes+lane)
+		}
+	case "VTRN1", "VTRN2":
+		start := 0
+		if op == "VTRN2" {
+			start = 1
+		}
+		for lane := start; lane < lanes; lane += 2 {
+			mask = append(mask, lane, lanes+lane)
+		}
+	}
+	return mask
+}
diff --git a/arm64_lower_permute_test.go b/arm64_lower_permute_test.go
new file mode 100644
index 000000000..84fda3cc0
--- /dev/null
+++ b/arm64_lower_permute_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorPermuteCompleteGoAssemblerForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT ·vectorpermuteforms(SB), $0-0\n")
+	for _, op := range []string{"VZIP1", "VZIP2", "VUZP1", "VUZP2", "VTRN1", "VTRN2"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			src.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V2." + arrangement + "\n")
+		}
+	}
+	src.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, src.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorpermuteforms": {Name: "vectorpermuteforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		// The 42 operations each emit one result shuffle. The three 64-bit
+		// arrangements also narrow both inputs, adding 36 shuffles.
+		if got := strings.Count(ll, "shufflevector"); got != 78 {
+			t.Fatalf("%s emitted %d vector shuffles, want 78:\n%s", triple, got, ll)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-permute.ll", "arm64-vector-permute.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorPermuteRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VZIP1 V0.B8, V1.B8",
+		"VUZP2 V0.B8, V1.B16, V2.B8",
+		"VTRN1 V0.D1, V1.D1, V2.D1",
+		"VTRN2 V0.S4, V1.S4, V2.S4, V3.S4",
+		"VZIP2 V0, V1, V2",
+		"VUZP1.P V0.B16, V1.B16, V2.B16",
+	} {
+		t.Run(strings.Fields(instruction)[0]+"-"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT ·badvectorpermute(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, src, false)
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badvectorpermute": {Name: "badvectorpermute", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector permute optab", instruction)
+			}
+		})
+	}
+}
+
+func requireARM64GoAssemblerResult(t *testing.T, src string, wantSuccess bool) {
+	requireARM64GoAssemblerResultWithExperiment(t, src, wantSuccess, "")
+}
+
+func requireARM64SVEGoAssemblerResult(t *testing.T, src string, wantSuccess bool) {
+	requireARM64GoAssemblerResultWithExperiment(t, src, wantSuccess, "simd")
+}
+
+func requireARM64GoAssemblerResultWithExperiment(t *testing.T, src string, wantSuccess bool, experiment string) {
+	t.Helper()
+	// These fixtures are derived from the Go 1.27 assembler tables. Older Go
+	// compatibility lanes must still parse, translate, and compile them through
+	// LLVM 22, but their own assembler cannot serve as the 1.27 form oracle.
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return
+	}
+	goAssemblerOracleOutput(t, "arm64", src, experiment, wantSuccess)
+}
+
+func goToolchainAtLeast(version string, wantMajor, wantMinor int) bool {
+	start := strings.Index(version, "go")
+	if start < 0 {
+		return false
+	}
+	parts := strings.SplitN(version[start+2:], ".", 3)
+	if len(parts) < 2 {
+		return false
+	}
+	major, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return false
+	}
+	minorText := parts[1]
+	end := 0
+	for end < len(minorText) && minorText[end] >= '0' && minorText[end] <= '9' {
+		end++
+	}
+	if end == 0 {
+		return false
+	}
+	minor, err := strconv.Atoi(minorText[:end])
+	if err != nil {
+		return false
+	}
+	return major > wantMajor || major == wantMajor && minor >= wantMinor
+}
+
+func TestGoToolchainAtLeast(t *testing.T) {
+	tests := []struct {
+		version string
+		want    bool
+	}{
+		{version: "go1.26.9", want: false},
+		{version: "go1.27", want: true},
+		{version: "go1.27rc1", want: true},
+		{version: "go1.28.0", want: true},
+		{version: "devel go1.28-abcdef", want: true},
+		{version: "devel", want: false},
+	}
+	for _, test := range tests {
+		if got := goToolchainAtLeast(test.version, 1, 27); got != test.want {
+			t.Errorf("goToolchainAtLeast(%q, 1, 27) = %v, want %v", test.version, got, test.want)
+		}
+	}
+}
diff --git a/arm64_lower_pointer_auth_hint_test.go b/arm64_lower_pointer_auth_hint_test.go
new file mode 100644
index 000000000..d1c44fcea
--- /dev/null
+++ b/arm64_lower_pointer_auth_hint_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64PointerAuthHintCompleteForms(t *testing.T) {
+	const source = `TEXT pointerAuthHints(SB),$0-0
+	BTI C
+	BTI J
+	BTI JC
+	PACIASP
+	PACIBSP
+	AUTIASP
+	AUTIBSP
+	AUTIA1716
+	AUTIB1716
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"pointerAuthHints": {Name: "pointerAuthHints", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, immediate := range []string{"hint #34", "hint #36", "hint #38", "hint #25", "hint #27", "hint #29", "hint #31", "hint #12", "hint #14"} {
+		if !strings.Contains(ll, immediate) {
+			t.Fatalf("ARM64 pointer-auth hint lowering omitted %q:\n%s", immediate, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-pointer-auth-hints.ll", "arm64-pointer-auth-hints.o", ll)
+}
+
+func TestTranslateARM64PointerAuthHintRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"BTI",
+		"BTI BAD",
+		"BTI C, J",
+		"BTI.P C",
+		"PACIASP R0",
+		"AUTIA1716.P",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 pointer-auth hint optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_polynomial_multiply.go b/arm64_lower_polynomial_multiply.go
new file mode 100644
index 000000000..3fa40eff2
--- /dev/null
+++ b/arm64_lower_polynomial_multiply.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64PolynomialMultiply implements the complete AVPMULL optab row.
+// Go accepts the low/high halves of B8/B16 -> H8 and D1/D2 -> Q1. LLVM's
+// AArch64 intrinsics preserve carry-less (GF(2)) multiplication semantics.
+func (c *arm64Ctx) lowerARM64PolynomialMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VPMULL" && op != "VPMULL2" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects two polynomial vector sources and one widened destination, with no suffix: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+	}
+
+	firstArrangement, firstOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	secondArrangement, secondOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	if !firstOK || !secondOK || firstArrangement != secondArrangement {
+		return true, false, fmt.Errorf("arm64 %s requires matching B8/B16 or D1/D2 source arrangements: %q", op, ins.Raw)
+	}
+	highHalf := op == "VPMULL2"
+
+	switch {
+	case arm64VectorRegHasExactArrangement(ins.Args[2].Reg, "H8"):
+		wantLanes := 8
+		if highHalf {
+			wantLanes = 16
+		}
+		if firstArrangement.elementBits != 8 || firstArrangement.lanes != wantLanes {
+			return true, false, fmt.Errorf("arm64 %s H8 result requires B%d sources: %q", op, wantLanes, ins.Raw)
+		}
+		first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, firstArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, secondArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		if highHalf {
+			destination := arm64VectorArrangement{elementBits: 16, lanes: 8}
+			first = c.selectARM64VectorHighHalf(firstArrangement, destination.lanes, first)
+			second = c.selectARM64VectorHighHalf(secondArrangement, destination.lanes, second)
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <8 x i16> @llvm.aarch64.neon.pmull.v8i16(<8 x i8> %s, <8 x i8> %s)\n", result, first, second)
+		return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arm64VectorArrangement{elementBits: 16, lanes: 8}, "%"+result)
+
+	case arm64VectorRegHasExactArrangement(ins.Args[2].Reg, "Q1"):
+		wantLanes := 1
+		if highHalf {
+			wantLanes = 2
+		}
+		if firstArrangement.elementBits != 64 || firstArrangement.lanes != wantLanes {
+			return true, false, fmt.Errorf("arm64 %s Q1 result requires D%d sources: %q", op, wantLanes, ins.Raw)
+		}
+		first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, firstArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, secondArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		lane := 0
+		if highHalf {
+			lane = 1
+		}
+		firstScalar := c.newTmp()
+		secondScalar := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", firstScalar, firstArrangement.lanes, first, lane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i64> %s, i32 %d\n", secondScalar, secondArrangement.lanes, second, lane)
+		fmt.Fprintf(c.b, "  %%%s = call <16 x i8> @llvm.aarch64.neon.pmull64(i64 %%%s, i64 %%%s)\n", result, firstScalar, secondScalar)
+		return true, false, c.storeVReg(ins.Args[2].Reg, "%"+result)
+
+	default:
+		return true, false, fmt.Errorf("arm64 %s destination must be H8 or Q1: %q", op, ins.Raw)
+	}
+}
+
+func arm64VectorRegHasExactArrangement(reg Reg, arrangement string) bool {
+	if _, ok := arm64ParseVReg(reg); !ok {
+		return false
+	}
+	s := strings.ToUpper(strings.TrimSpace(string(reg)))
+	return strings.HasSuffix(s, "."+arrangement)
+}
diff --git a/arm64_lower_polynomial_multiply_test.go b/arm64_lower_polynomial_multiply_test.go
new file mode 100644
index 000000000..461be2f30
--- /dev/null
+++ b/arm64_lower_polynomial_multiply_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64PolynomialMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	const source = `TEXT ·polynomialMultiplyForms(SB), $0-0
+	VPMULL V0.B8, V1.B8, V2.H8
+	VPMULL2 V3.B16, V4.B16, V5.H8
+	VPMULL V6.D1, V7.D1, V8.Q1
+	VPMULL2 V9.D2, V10.D2, V11.Q1
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"polynomialMultiplyForms": {Name: "polynomialMultiplyForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{
+			"llvm.aarch64.neon.pmull.v8i16",
+			"llvm.aarch64.neon.pmull64",
+		} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s polynomial-multiply IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		if !strings.Contains(ll, `"target-features"="+aes"`) {
+			t.Fatalf("%s polynomial-multiply function omitted +aes:\n%s", triple, ll)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-polynomial-multiply.ll", "arm64-polynomial-multiply.o", ll)
+	}
+}
+
+func TestTranslateARM64PolynomialMultiplyRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VPMULL V0.B16, V1.B16, V2.H8",
+		"VPMULL2 V0.B8, V1.B8, V2.H8",
+		"VPMULL V0.H4, V1.H4, V2.S4",
+		"VPMULL V0.S2, V1.S2, V2.D2",
+		"VPMULL V0.D2, V1.D2, V2.Q1",
+		"VPMULL V0.D1, V1.D1, V2.D2",
+		"VPMULL.P V0.B8, V1.B8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badPolynomialMultiply(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badPolynomialMultiply": {Name: "badPolynomialMultiply", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go's VPMULL/VPMULL2 optab", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_prefetch.go b/arm64_lower_prefetch.go
new file mode 100644
index 000000000..261c6d736
--- /dev/null
+++ b/arm64_lower_prefetch.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64PrefetchOperation string
+
+// arm64PrefetchOperations mirrors Go's prfopfield table.
+var arm64PrefetchOperations = map[arm64PrefetchOperation]uint8{
+	"PLDL1KEEP": 0,
+	"PLDL1STRM": 1,
+	"PLDL2KEEP": 2,
+	"PLDL2STRM": 3,
+	"PLDL3KEEP": 4,
+	"PLDL3STRM": 5,
+	"PLIL1KEEP": 8,
+	"PLIL1STRM": 9,
+	"PLIL2KEEP": 10,
+	"PLIL2STRM": 11,
+	"PLIL3KEEP": 12,
+	"PLIL3STRM": 13,
+	"PSTL1KEEP": 16,
+	"PSTL1STRM": 17,
+	"PSTL2KEEP": 18,
+	"PSTL2STRM": 19,
+	"PSTL3KEEP": 20,
+	"PSTL3STRM": 21,
+}
+
+func (c *arm64Ctx) lowerARM64Prefetch(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op == "RPRFM" {
+		return c.lowerARM64RangePrefetch(ins)
+	}
+	if op != "PRFM" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != "PRFM" || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 PRFM expects unsigned-scaled memory and a prefetch operation, with no suffix: %q", ins.Raw)
+	}
+	memory := ins.Args[0].Mem
+	validBase := isARM64GeneralOrZeroReg(memory.Base) || memory.Base == SP || memory.Base == Reg("RSP")
+	if !validBase || memory.Sym != "" || memory.Index != "" || memory.OffRaw != "" || !arm64PRFMOffsetAccepted(memory.Off) {
+		return true, false, fmt.Errorf("arm64 PRFM address is outside Go's C_UOREG32K class: %q", ins.Raw)
+	}
+
+	var hint uint8
+	switch operation := ins.Args[1]; operation.Kind {
+	case OpIdent:
+		name := arm64PrefetchOperation(strings.ToUpper(strings.TrimSpace(operation.Ident)))
+		value, exists := arm64PrefetchOperations[name]
+		if !exists {
+			return true, false, fmt.Errorf("arm64 PRFM operation %q is outside Go's prfopfield table: %q", name, ins.Raw)
+		}
+		hint = value
+	case OpImm:
+		if operation.ImmRaw != "" || operation.Imm < 0 || operation.Imm > 31 {
+			return true, false, fmt.Errorf("arm64 PRFM numeric operation must be in [0,31]: %q", ins.Raw)
+		}
+		hint = uint8(operation.Imm)
+	default:
+		return true, false, fmt.Errorf("arm64 PRFM operation must be a Go prfop name or $0..$31: %q", ins.Raw)
+	}
+
+	baseReg := memory.Base
+	if baseReg == ZR {
+		// Register number 31 in an AArch64 memory operand denotes SP. Go's
+		// parser accepts ZR here and its encoder consequently emits SP.
+		baseReg = SP
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return true, false, err
+	}
+	// Go's case-91 encoder shifts directly and therefore discards the low
+	// three offset bits without issuing offsetshift's usual odd-offset error.
+	encodedOffset := memory.Off &^ 7
+	assembly := fmt.Sprintf("prfm #%d, [$0, #%d]", hint, encodedOffset)
+	c.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q(i64 %s)\n", assembly, "r,~{memory}", base)
+	return true, false, nil
+}
+
+var arm64RangePrefetchOperations = map[string]uint8{
+	"PLDKEEP": 0,
+	"PSTKEEP": 1,
+	"PLDSTRM": 4,
+	"PSTSTRM": 5,
+}
+
+func (c *arm64Ctx) lowerARM64RangePrefetch(ins Instr) (ok bool, terminated bool, err error) {
+	if strings.ToUpper(string(ins.Op)) != "RPRFM" || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 RPRFM expects (Rn), Rm, operation without a suffix: %q", ins.Raw)
+	}
+	memory := ins.Args[0].Mem
+	base, baseOK := arm64SVEAddressReg(Operand{Kind: OpReg, Reg: memory.Base}, true)
+	rangeRegister, rangeOK := arm64SVEAddressReg(ins.Args[1], false)
+	if !baseOK || !rangeOK || memory.Sym != "" || memory.Off != 0 || memory.OffRaw != "" || memory.Index != "" {
+		return true, false, fmt.Errorf("arm64 RPRFM requires an unoffset R0..R30/RSP base and R0..R30 range register: %q", ins.Raw)
+	}
+	var hint uint8
+	switch operation := ins.Args[2]; operation.Kind {
+	case OpIdent:
+		var exists bool
+		hint, exists = arm64RangePrefetchOperations[strings.ToUpper(strings.TrimSpace(operation.Ident))]
+		if !exists {
+			return true, false, fmt.Errorf("arm64 RPRFM operation must be PLDKEEP, PSTKEEP, PLDSTRM, or PSTSTRM: %q", ins.Raw)
+		}
+	case OpImm:
+		if operation.ImmRaw != "" || operation.ImmIsFloat || operation.Imm < 0 || operation.Imm > 63 {
+			return true, false, fmt.Errorf("arm64 RPRFM numeric operation must be in [0,63]: %q", ins.Raw)
+		}
+		hint = uint8(operation.Imm)
+	default:
+		return true, false, fmt.Errorf("arm64 RPRFM operation must be a range-prefetch name or $0..$63: %q", ins.Raw)
+	}
+	baseValue, err := c.loadReg(base)
+	if err != nil {
+		return true, false, err
+	}
+	rangeValue, err := c.loadReg(rangeRegister)
+	if err != nil {
+		return true, false, err
+	}
+	assembly := fmt.Sprintf("rprfm #%d, $1, [$0]", hint)
+	c.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q(i64 %s, i64 %s)\n", assembly, "r,r,~{memory}", baseValue, rangeValue)
+	return true, false, nil
+}
+
+// arm64PRFMOffsetAccepted mirrors autoclass/oregclass plus cmp(C_UOREG32K,
+// class) in Go's ARM64 backend. Some smaller compatible address classes admit
+// offsets that are not multiples of eight; case 91 then truncates their low
+// three bits.
+func arm64PRFMOffsetAccepted(offset int64) bool {
+	switch {
+	case offset < 0:
+		return false
+	case offset <= 255:
+		return true
+	case offset <= 504:
+		return offset%8 == 0
+	case offset <= 1008:
+		return offset%16 == 0
+	case offset <= 32760:
+		return offset%8 == 0
+	default:
+		return false
+	}
+}
diff --git a/arm64_lower_prefetch_test.go b/arm64_lower_prefetch_test.go
new file mode 100644
index 000000000..32e99358d
--- /dev/null
+++ b/arm64_lower_prefetch_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const arm64PrefetchForms = `
+TEXT prefetchforms(SB),$0-0
+	PRFM (R0), PLDL1KEEP
+	PRFM 8(R1), PLDL1STRM
+	PRFM 16(R2), PLDL2KEEP
+	PRFM 24(R3), PLDL2STRM
+	PRFM 32(R4), PLDL3KEEP
+	PRFM 40(R5), PLDL3STRM
+	PRFM 48(R6), PLIL1KEEP
+	PRFM 56(R7), PLIL1STRM
+	PRFM 64(R8), PLIL2KEEP
+	PRFM 72(R9), PLIL2STRM
+	PRFM 80(R10), PLIL3KEEP
+	PRFM 88(R11), PLIL3STRM
+	PRFM 96(R12), PSTL1KEEP
+	PRFM 104(R13), PSTL1STRM
+	PRFM 112(R14), PSTL2KEEP
+	PRFM 120(R15), PSTL2STRM
+	PRFM 128(R16), PSTL3KEEP
+	PRFM 136(R17), PSTL3STRM
+	PRFM (RSP), $0
+	// Go accepts ZR in this address position; encoding register 31 means SP.
+	PRFM (ZR), $1
+	// Go accepts every non-negative C_UOREG32K offset and the PRFM encoder
+	// discards its low three bits rather than diagnosing offsets admitted by a
+	// smaller compatible class.
+	PRFM 1(R20), $31
+	PRFM 8(R21), $30
+	PRFM 4088(R22), PLDL1KEEP
+	PRFM 8184(R23), PLDL1KEEP
+	PRFM 16376(R24), PLDL1KEEP
+	PRFM 32760(R19), PLDL1KEEP
+	RET
+`
+
+func TestTranslateARM64PrefetchCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64PrefetchForms, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64PrefetchForms)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"prefetchforms": {Name: "prefetchforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, `asm sideeffect "prfm #`); got != 26 {
+				t.Fatalf("ARM64 PRFM lowering emitted %d prefetch operations, want 26:\n%s", got, ll)
+			}
+			for _, want := range []string{
+				`asm sideeffect "prfm #0, [$0, #0]"`,
+				`asm sideeffect "prfm #13, [$0, #88]"`,
+				`asm sideeffect "prfm #21, [$0, #136]"`,
+				`asm sideeffect "prfm #31, [$0, #0]"`,
+				`asm sideeffect "prfm #30, [$0, #8]"`,
+				`asm sideeffect "prfm #0, [$0, #4088]"`,
+				`asm sideeffect "prfm #0, [$0, #32760]"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 PRFM lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-prefetch.ll", "arm64-prefetch.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64PrefetchRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"PRFM -8(R0), PLDL1KEEP",
+		"PRFM 257(R0), PLDL1KEEP",
+		"PRFM 505(R0), PLDL1KEEP",
+		"PRFM 4097(R0), PLDL1KEEP",
+		"PRFM 8191(R0), PLDL1KEEP",
+		"PRFM 16381(R0), PLDL1KEEP",
+		"PRFM 32761(R0), PLDL1KEEP",
+		"PRFM 32768(R0), PLDL1KEEP",
+		"PRFM (R0), PLDKEEP",
+		"PRFM (R0), $32",
+		"PRFM R0, PLDL1KEEP",
+		"PRFM (R0)",
+		"PRFM.P (R0), PLDL1KEEP",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's PRFM forms", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_range_prefetch_test.go b/arm64_lower_range_prefetch_test.go
new file mode 100644
index 000000000..c6fa5f9c9
--- /dev/null
+++ b/arm64_lower_range_prefetch_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RangePrefetchCompleteGo127Family(t *testing.T) {
+	source := `TEXT range_prefetch_forms(SB),$0-0
+	RPRFM (R0), R30, PLDKEEP
+	RPRFM (R1), R2, PSTKEEP
+	RPRFM (R2), R3, PLDSTRM
+	RPRFM (RSP), R4, PSTSTRM
+	RPRFM (R5), R6, $0
+	RPRFM (R7), R8, $63
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"range_prefetch_forms": {Name: "range_prefetch_forms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "rprfm #0, $1, [$0]"`,
+				`asm sideeffect "rprfm #5, $1, [$0]"`,
+				`asm sideeffect "rprfm #63, $1, [$0]"`,
+				`"r,r,~{memory}"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ARM64 range-prefetch lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-range-prefetch.ll", "arm64-range-prefetch.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RangePrefetchRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"RPRFM 8(R1), R2, PLDKEEP",
+		"RPRFM (R1)(R2), R3, PLDKEEP",
+		"RPRFM (R1), RZR, PLDKEEP",
+		"RPRFM (R1), R2, PLDL1KEEP",
+		"RPRFM (R1), R2, $-1",
+		"RPRFM (R1), R2, $64",
+		"RPRFM.Z (R1), R2, PLDKEEP",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badrangeprefetch(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badrangeprefetch": {Name: "badrangeprefetch", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's RPRFM forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_rounding_variable_shift_test.go b/arm64_lower_rounding_variable_shift_test.go
new file mode 100644
index 000000000..bc586b136
--- /dev/null
+++ b/arm64_lower_rounding_variable_shift_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64VariableShift(base uint32, elementBits int, fullVector bool, shifts, value, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	word := base | size<<22 | uint32(shifts)<<16 | uint32(value)<<5 | uint32(destination)
+	if fullVector {
+		word |= 1 << 30
+	}
+	return word
+}
+
+func TestTranslateARM64RawVariableShiftCompleteArchitectureFamily(t *testing.T) {
+	families := []struct {
+		name string
+		base uint32
+	}{
+		{name: "VSSHL", base: 0x0e204400},
+		{name: "VSRSHL", base: 0x0e205400},
+		{name: "VUSHL", base: 0x2e204400},
+		{name: "VURSHL", base: 0x2e205400},
+	}
+	type form struct {
+		elementBits int
+		fullVector  bool
+	}
+	forms := []form{
+		{elementBits: 8}, {elementBits: 8, fullVector: true},
+		{elementBits: 16}, {elementBits: 16, fullVector: true},
+		{elementBits: 32}, {elementBits: 32, fullVector: true},
+		{elementBits: 64, fullVector: true},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT ·variableShiftArchitectureForms(SB), $0-0\n")
+	for _, family := range families {
+		for _, form := range forms {
+			word := encodeARM64VariableShift(family.base, form.elementBits, form.fullVector, 30, 29, 28)
+			decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			if err != nil {
+				t.Fatalf("decode %s %d-bit Q=%v: %v", family.name, form.elementBits, form.fullVector, err)
+			}
+			if decoded.Op != Op(family.name) || len(decoded.Args) != 3 ||
+				!strings.HasPrefix(string(decoded.Args[0].Reg), "V30.") ||
+				!strings.HasPrefix(string(decoded.Args[1].Reg), "V29.") ||
+				!strings.HasPrefix(string(decoded.Args[2].Reg), "V28.") {
+				t.Fatalf("decoded %s %d-bit Q=%v %#08x as %#v; want reversed Vm=V30, Vn=V29, Vd=V28", family.name, form.elementBits, form.fullVector, word, decoded)
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s %d-bit Q=%v\n", word, family.name, form.elementBits, form.fullVector)
+		}
+		// The architecture has one additional scalar D form. It shares the
+		// size=3 encoding but has Q=0 and decodes to bare V registers.
+		scalarBase := family.base | 0x50000000
+		word := encodeARM64VariableShift(scalarBase, 64, false, 30, 29, 28)
+		decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+		if err != nil {
+			t.Fatalf("decode scalar %s: %v", family.name, err)
+		}
+		if decoded.Op != Op(family.name) || len(decoded.Args) != 3 || decoded.Args[0].Reg != "V30" || decoded.Args[1].Reg != "V29" || decoded.Args[2].Reg != "V28" {
+			t.Fatalf("decoded scalar %s %#08x as %#v; want V30, V29, V28", family.name, word, decoded)
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x // scalar %s D\n", word, family.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"variableShiftArchitectureForms": {Name: "variableShiftArchitectureForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{"sshl", "srshl", "ushl", "urshl"} {
+				calls := 0
+				for _, line := range strings.Split(ll, "\n") {
+					if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.aarch64.neon."+intrinsic+".") {
+						calls++
+					}
+				}
+				if calls != 8 {
+					t.Fatalf("%s emitted %d %s calls, want all 7 vector and 1 scalar forms:\n%s", triple, calls, intrinsic, ll)
+				}
+				if !strings.Contains(ll, "@llvm.aarch64.neon."+intrinsic+".i64") || !strings.Contains(ll, "@llvm.aarch64.neon."+intrinsic+".v16i8") {
+					t.Fatalf("%s omitted scalar or vector %s intrinsic:\n%s", triple, intrinsic, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-variable-shift.ll", "arm64-variable-shift.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VariableShiftRejectsInvalidArchitectureForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VSRSHL V0.B8, V1.B8",
+		"VURSHL V0.B8, V1.B16, V2.B8",
+		"VSRSHL V0.D1, V1.D1, V2.D1",
+		"VURSHL V0, V1.D2, V2.D2",
+		"VSRSHL.P V0.H8, V1.H8, V2.H8",
+	} {
+		file, err := Parse(ArchARM64, "TEXT ·badVariableShift(SB), $0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs:         map[string]FuncSig{"badVariableShift": {Name: "badVariableShift", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted invalid ARM64 variable-shift form %q", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_saturating_arithmetic.go b/arm64_lower_saturating_arithmetic.go
new file mode 100644
index 000000000..b503dfa31
--- /dev/null
+++ b/arm64_lower_saturating_arithmetic.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorSaturatingArithmetic(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, handled := map[Op]string{
+		"VSQADD": "sadd.sat",
+		"VUQADD": "uadd.sat",
+		"VSQSUB": "ssub.sat",
+		"VUQSUB": "usub.sat",
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits == 64 && parsed.lanes != 2 {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8/B16/H4/H8/S2/S4/D2 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	base, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.v%di%d(%s %s, %s %s)\n",
+		result, vectorType, intrinsic, arrangement.lanes, arrangement.elementBits, vectorType, base, vectorType, source)
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+}
diff --git a/arm64_lower_saturating_arithmetic_test.go b/arm64_lower_saturating_arithmetic_test.go
new file mode 100644
index 000000000..9089daf00
--- /dev/null
+++ b/arm64_lower_saturating_arithmetic_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorSaturatingArithmeticCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorSaturatingArithmeticForms(SB), $0-0\n")
+	for _, op := range []string{"VSQADD", "VUQADD", "VSQSUB", "VUQSUB"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorSaturatingArithmeticForms": {Name: "vectorSaturatingArithmeticForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"@llvm.sadd.sat.", "@llvm.uadd.sat.", "@llvm.ssub.sat.", "@llvm.usub.sat."} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s saturating arithmetic IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-saturating-arithmetic.ll", "arm64-vector-saturating-arithmetic.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorSaturatingArithmeticRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSQADD V0.B8, V1.B8",
+		"VUQADD V0.B8, V1.B16, V2.B8",
+		"VSQSUB V0.D1, V1.D1, V2.D1",
+		"VUQSUB V0.S4, V1.S4, V2.S2",
+		"VSQADD.P V0.H8, V1.H8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorSaturatingArithmetic(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorSaturatingArithmetic": {Name: "badVectorSaturatingArithmetic", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector saturating arithmetic forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_saturating_shift.go b/arm64_lower_saturating_shift.go
new file mode 100644
index 000000000..c3dfdba24
--- /dev/null
+++ b/arm64_lower_saturating_shift.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorSaturatingShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, handled := map[Op]string{"VSQSHL": "sqshl", "VUQSHL": "uqshl"}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects $shift|Vshifts.T, Vvalue.T, Vdst.T with no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for index, operand := range ins.Args[1:] {
+		if operand.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s value and destination must be vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(operand.Reg)
+		if !valid || !arm64SaturatingShiftArrangement(parsed) {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8/B16/H4/H8/S2/S4/D2 arrangements: %q", op, ins.Raw)
+		}
+		if index == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	shifts := ""
+	switch shiftOperand := ins.Args[0]; shiftOperand.Kind {
+	case OpImm:
+		if shiftOperand.ImmRaw != "" || shiftOperand.Imm < 0 || shiftOperand.Imm >= int64(arrangement.elementBits) {
+			return true, false, fmt.Errorf("arm64 %s immediate shift must be in [0,%d): %q", op, arrangement.elementBits, ins.Raw)
+		}
+		var constant strings.Builder
+		constant.WriteString("<")
+		for lane := 0; lane < arrangement.lanes; lane++ {
+			if lane != 0 {
+				constant.WriteString(", ")
+			}
+			fmt.Fprintf(&constant, "i%d %d", arrangement.elementBits, shiftOperand.Imm)
+		}
+		constant.WriteString(">")
+		shifts = constant.String()
+	case OpReg:
+		shiftArrangement, valid := parseARM64VectorArrangement(shiftOperand.Reg)
+		if !valid || shiftArrangement != arrangement {
+			return true, false, fmt.Errorf("arm64 %s shift-count arrangement must match: %q", op, ins.Raw)
+		}
+		shifts, err = c.loadARM64VectorInteger(shiftOperand.Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+	default:
+		return true, false, fmt.Errorf("arm64 %s first operand must be an immediate or vector register: %q", op, ins.Raw)
+	}
+	value, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%di%d(%s %s, %s %s)\n",
+		result, vectorType, intrinsic, arrangement.lanes, arrangement.elementBits, vectorType, value, vectorType, shifts)
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+}
+
+func arm64SaturatingShiftArrangement(arrangement arm64VectorArrangement) bool {
+	switch {
+	case arrangement.elementBits == 8 && (arrangement.lanes == 8 || arrangement.lanes == 16):
+	case arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8):
+	case arrangement.elementBits == 32 && (arrangement.lanes == 2 || arrangement.lanes == 4):
+	case arrangement.elementBits == 64 && arrangement.lanes == 2:
+	default:
+		return false
+	}
+	return true
+}
diff --git a/arm64_lower_saturating_shift_narrow.go b/arm64_lower_saturating_shift_narrow.go
new file mode 100644
index 000000000..e1958671d
--- /dev/null
+++ b/arm64_lower_saturating_shift_narrow.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SaturatingShiftNarrowSpec struct {
+	signedSource        bool
+	unsignedDestination bool
+	rounding            bool
+}
+
+var arm64SaturatingShiftNarrowSpecs = map[Op]arm64SaturatingShiftNarrowSpec{
+	"VSQSHRN":    {signedSource: true},
+	"VSQSHRN2":   {signedSource: true},
+	"VSQRSHRN":   {signedSource: true, rounding: true},
+	"VSQRSHRN2":  {signedSource: true, rounding: true},
+	"VSQSHRUN":   {signedSource: true, unsignedDestination: true},
+	"VSQSHRUN2":  {signedSource: true, unsignedDestination: true},
+	"VSQRSHRUN":  {signedSource: true, unsignedDestination: true, rounding: true},
+	"VSQRSHRUN2": {signedSource: true, unsignedDestination: true, rounding: true},
+	"VUQSHRN":    {},
+	"VUQSHRN2":   {},
+	"VUQRSHRN":   {rounding: true},
+	"VUQRSHRN2":  {rounding: true},
+}
+
+type arm64RawSaturatingShiftNarrow struct {
+	op                     Op
+	spec                   arm64SaturatingShiftNarrowSpec
+	scalar                 bool
+	highHalf               bool
+	sourceArrangement      arm64VectorArrangement
+	destinationArrangement arm64VectorArrangement
+	shift                  int
+	source                 int
+	destination            int
+}
+
+func decodeARM64RawSaturatingShiftNarrow(word uint32) (arm64RawSaturatingShiftNarrow, bool) {
+	type encoding struct {
+		op       Op
+		scalar   bool
+		highHalf bool
+	}
+	encodings := map[uint32]encoding{
+		0x0f009400: {op: "VSQSHRN"},
+		0x4f009400: {op: "VSQSHRN2", highHalf: true},
+		0x5f009400: {op: "VSQSHRN", scalar: true},
+		0x0f009c00: {op: "VSQRSHRN"},
+		0x4f009c00: {op: "VSQRSHRN2", highHalf: true},
+		0x5f009c00: {op: "VSQRSHRN", scalar: true},
+		0x2f008400: {op: "VSQSHRUN"},
+		0x6f008400: {op: "VSQSHRUN2", highHalf: true},
+		0x7f008400: {op: "VSQSHRUN", scalar: true},
+		0x2f008c00: {op: "VSQRSHRUN"},
+		0x6f008c00: {op: "VSQRSHRUN2", highHalf: true},
+		0x7f008c00: {op: "VSQRSHRUN", scalar: true},
+		0x2f009400: {op: "VUQSHRN"},
+		0x6f009400: {op: "VUQSHRN2", highHalf: true},
+		0x7f009400: {op: "VUQSHRN", scalar: true},
+		0x2f009c00: {op: "VUQRSHRN"},
+		0x6f009c00: {op: "VUQRSHRN2", highHalf: true},
+		0x7f009c00: {op: "VUQRSHRN", scalar: true},
+	}
+	decoded, ok := encodings[word&0xff80fc00]
+	if !ok {
+		return arm64RawSaturatingShiftNarrow{}, false
+	}
+	encodedImmediate := int(word>>16) & 0x7f
+	destinationBits := 0
+	switch {
+	case encodedImmediate >= 32 && encodedImmediate < 64:
+		destinationBits = 32
+	case encodedImmediate >= 16:
+		destinationBits = 16
+	case encodedImmediate >= 8:
+		destinationBits = 8
+	default:
+		return arm64RawSaturatingShiftNarrow{}, false
+	}
+	shift := 2*destinationBits - encodedImmediate
+	if shift < 1 || shift > destinationBits {
+		return arm64RawSaturatingShiftNarrow{}, false
+	}
+	sourceLanes := 128 / (destinationBits * 2)
+	destinationLanes := sourceLanes
+	if decoded.scalar {
+		sourceLanes = 1
+		destinationLanes = 1
+	} else if decoded.highHalf {
+		destinationLanes *= 2
+	}
+	return arm64RawSaturatingShiftNarrow{
+		op:                     decoded.op,
+		spec:                   arm64SaturatingShiftNarrowSpecs[decoded.op],
+		scalar:                 decoded.scalar,
+		highHalf:               decoded.highHalf,
+		sourceArrangement:      arm64VectorArrangement{elementBits: destinationBits * 2, lanes: sourceLanes},
+		destinationArrangement: arm64VectorArrangement{elementBits: destinationBits, lanes: destinationLanes},
+		shift:                  shift,
+		source:                 int(word>>5) & 31,
+		destination:            int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSaturatingShiftNarrow(form arm64RawSaturatingShiftNarrow) error {
+	return c.lowerARM64SaturatingShiftNarrowForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64VectorSaturatingShiftNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, handled := arm64SaturatingShiftNarrowSpecs[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects immediate, wide vector source, narrow vector destination, and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	highHalf := strings.HasSuffix(string(op), "2")
+	wantDestinationLanes := sourceArrangement.lanes
+	if highHalf {
+		wantDestinationLanes *= 2
+	}
+	shift := ins.Args[0].Imm
+	if !sourceOK || !destinationOK || sourceArrangement.lanes*sourceArrangement.elementBits != 128 ||
+		sourceArrangement.elementBits != destinationArrangement.elementBits*2 ||
+		destinationArrangement.lanes != wantDestinationLanes || shift < 1 || shift > int64(destinationArrangement.elementBits) {
+		return true, false, fmt.Errorf("arm64 %s requires $1..$N with H8->B8/S4->H4/D2->S2 (or the doubled *2 destination): %q", op, ins.Raw)
+	}
+	source, _ := arm64ParseVReg(ins.Args[1].Reg)
+	destination, _ := arm64ParseVReg(ins.Args[2].Reg)
+	form := arm64RawSaturatingShiftNarrow{
+		op: op, spec: spec, highHalf: highHalf,
+		sourceArrangement: sourceArrangement, destinationArrangement: destinationArrangement,
+		shift: int(shift), source: source, destination: destination,
+	}
+	return true, false, c.lowerARM64SaturatingShiftNarrowForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SaturatingShiftNarrowForm(form arm64RawSaturatingShiftNarrow) error {
+	source, err := c.loadRawARM64VectorOperand(form.source, form.sourceArrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	sourceType := fmt.Sprintf("<%d x i%d>", form.sourceArrangement.lanes, form.sourceArrangement.elementBits)
+	shiftValue := arm64VectorIntegerSplat(form.sourceArrangement, int64(form.shift))
+	shifted := c.newTmp()
+	operation := "lshr"
+	if form.spec.signedSource {
+		operation = "ashr"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", shifted, operation, sourceType, source, shiftValue)
+	shiftedValue := "%" + shifted
+	if form.spec.rounding {
+		roundingShift := c.newTmp()
+		roundingBit := c.newTmp()
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", roundingShift, sourceType, source,
+			arm64VectorIntegerSplat(form.sourceArrangement, int64(form.shift-1)))
+		fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", roundingBit, sourceType, roundingShift,
+			arm64VectorIntegerSplat(form.sourceArrangement, 1))
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %%%s\n", rounded, sourceType, shiftedValue, roundingBit)
+		shiftedValue = "%" + rounded
+	}
+
+	clamped := shiftedValue
+	destinationBits := form.destinationArrangement.elementBits
+	switch {
+	case form.spec.signedSource && form.spec.unsignedDestination:
+		maximum := (int64(1) << destinationBits) - 1
+		clamped = c.clampARM64VectorInteger(sourceType, form.sourceArrangement, shiftedValue, "slt", 0, "sgt", maximum)
+	case form.spec.signedSource:
+		minimum := -(int64(1) << (destinationBits - 1))
+		maximum := (int64(1) << (destinationBits - 1)) - 1
+		clamped = c.clampARM64VectorInteger(sourceType, form.sourceArrangement, shiftedValue, "slt", minimum, "sgt", maximum)
+	default:
+		maximum := (int64(1) << destinationBits) - 1
+		above := c.newTmp()
+		selected := c.newTmp()
+		upper := arm64VectorIntegerSplat(form.sourceArrangement, maximum)
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %s, %s\n", above, sourceType, shiftedValue, upper)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %s\n",
+			selected, form.sourceArrangement.lanes, above, sourceType, upper, sourceType, shiftedValue)
+		clamped = "%" + selected
+	}
+
+	narrowType := fmt.Sprintf("<%d x i%d>", form.sourceArrangement.lanes, destinationBits)
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", narrowed, sourceType, clamped, narrowType)
+	result := "%" + narrowed
+	if form.highHalf {
+		destination, err := c.loadRawARM64VectorOperand(form.destination, form.destinationArrangement, 0, false)
+		if err != nil {
+			return err
+		}
+		fullDestinationType := fmt.Sprintf("<%d x i%d>", form.destinationArrangement.lanes, destinationBits)
+		for lane := 0; lane < form.sourceArrangement.lanes; lane++ {
+			element := c.newTmp()
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %d\n", element, narrowType, result, lane)
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n",
+				inserted, fullDestinationType, destination, destinationBits, element, form.sourceArrangement.lanes+lane)
+			destination = "%" + inserted
+		}
+		result = destination
+	}
+	return c.storeRawARM64VectorResult(form.destination, form.destinationArrangement, result, form.scalar)
+}
diff --git a/arm64_lower_saturating_shift_narrow_test.go b/arm64_lower_saturating_shift_narrow_test.go
new file mode 100644
index 000000000..2cec53ae4
--- /dev/null
+++ b/arm64_lower_saturating_shift_narrow_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64SaturatingShiftNarrow(base uint32, destinationBits, shift int, highHalf bool, source, destination int) uint32 {
+	encodedImmediate := uint32(2*destinationBits - shift)
+	word := base | encodedImmediate<<16 | uint32(source)<<5 | uint32(destination)
+	if highHalf {
+		word |= 1 << 30
+	}
+	return word
+}
+
+func TestTranslateARM64RawSaturatingShiftNarrowCompleteArchitectureFamily(t *testing.T) {
+	type family struct {
+		name       string
+		vectorBase uint32
+		scalarBase uint32
+	}
+	families := []family{
+		{name: "VSQSHRN", vectorBase: 0x0f009400, scalarBase: 0x5f009400},
+		{name: "VSQRSHRN", vectorBase: 0x0f009c00, scalarBase: 0x5f009c00},
+		{name: "VSQSHRUN", vectorBase: 0x2f008400, scalarBase: 0x7f008400},
+		{name: "VSQRSHRUN", vectorBase: 0x2f008c00, scalarBase: 0x7f008c00},
+		{name: "VUQSHRN", vectorBase: 0x2f009400, scalarBase: 0x7f009400},
+		{name: "VUQRSHRN", vectorBase: 0x2f009c00, scalarBase: 0x7f009c00},
+	}
+	letter := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}
+	var source strings.Builder
+	source.WriteString("TEXT saturatingShiftNarrowArchitectureForms(SB),$0-0\n")
+	for _, family := range families {
+		for _, destinationBits := range []int{8, 16, 32} {
+			for _, highHalf := range []bool{false, true} {
+				for _, shift := range []int{1, destinationBits} {
+					word := encodeARM64SaturatingShiftNarrow(family.vectorBase, destinationBits, shift, highHalf, 29, 28)
+					decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+					if err != nil {
+						t.Fatalf("decode %s destination=%d high=%v shift=%d: %v", family.name, destinationBits, highHalf, shift, err)
+					}
+					wantName := family.name
+					if highHalf {
+						wantName += "2"
+					}
+					wantSource := Reg(fmt.Sprintf("V29.%s%d", letter[destinationBits*2], 128/(destinationBits*2)))
+					wantDestinationLanes := 64 / destinationBits
+					if highHalf {
+						wantDestinationLanes *= 2
+					}
+					wantDestination := Reg(fmt.Sprintf("V28.%s%d", letter[destinationBits], wantDestinationLanes))
+					if decoded.Op != Op(wantName) || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != int64(shift) ||
+						decoded.Args[1].Reg != wantSource || decoded.Args[2].Reg != wantDestination {
+						t.Fatalf("decoded %s destination=%d high=%v shift=%d %#08x as %#v", family.name, destinationBits, highHalf, shift, word, decoded)
+					}
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+			for _, shift := range []int{1, destinationBits} {
+				word := encodeARM64SaturatingShiftNarrow(family.scalarBase, destinationBits, shift, false, 29, 28)
+				decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+				if err != nil {
+					t.Fatalf("decode scalar %s destination=%d shift=%d: %v", family.name, destinationBits, shift, err)
+				}
+				if decoded.Op != Op(family.name) || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != int64(shift) ||
+					decoded.Args[1].Reg != "V29" || decoded.Args[2].Reg != "V28" {
+					t.Fatalf("decoded scalar %s destination=%d shift=%d %#08x as %#v", family.name, destinationBits, shift, word, decoded)
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"saturatingShiftNarrowArchitectureForms": {Name: "saturatingShiftNarrowArchitectureForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"ashr", "lshr", "icmp", "select", "trunc", "insertelement"} {
+				if !strings.Contains(ll, " = "+operation+" ") {
+					t.Fatalf("%s omitted %s semantics:\n%s", triple, operation, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-saturating-shift-narrow.ll", "arm64-saturating-shift-narrow.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSaturatingShiftNarrowDecoderCoversEveryImmediate(t *testing.T) {
+	families := []struct {
+		vectorBase uint32
+		scalarBase uint32
+	}{
+		{0x0f009400, 0x5f009400},
+		{0x0f009c00, 0x5f009c00},
+		{0x2f008400, 0x7f008400},
+		{0x2f008c00, 0x7f008c00},
+		{0x2f009400, 0x7f009400},
+		{0x2f009c00, 0x7f009c00},
+	}
+	for _, family := range families {
+		for _, destinationBits := range []int{8, 16, 32} {
+			for shift := 1; shift <= destinationBits; shift++ {
+				for _, form := range []struct {
+					base     uint32
+					highHalf bool
+					scalar   bool
+				}{
+					{base: family.vectorBase},
+					{base: family.vectorBase, highHalf: true},
+					{base: family.scalarBase, scalar: true},
+				} {
+					word := encodeARM64SaturatingShiftNarrow(form.base, destinationBits, shift, form.highHalf, 31, 30)
+					decoded, ok := decodeARM64RawSaturatingShiftNarrow(word)
+					if !ok || decoded.shift != shift || decoded.source != 31 || decoded.destination != 30 ||
+						decoded.scalar != form.scalar || decoded.highHalf != form.highHalf ||
+						decoded.sourceArrangement.elementBits != destinationBits*2 || decoded.destinationArrangement.elementBits != destinationBits {
+						t.Fatalf("decode base=%#08x destination=%d shift=%d high=%v scalar=%v: form=%#v ok=%v",
+							form.base, destinationBits, shift, form.highHalf, form.scalar, decoded, ok)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SaturatingShiftNarrowRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	families := []uint32{0x0f009400, 0x0f009c00, 0x2f008400, 0x2f008c00, 0x2f009400, 0x2f009c00}
+	var source strings.Builder
+	source.WriteString("TEXT saturatingShiftNarrowSemantics(SB),$0-24\n")
+	source.WriteString("\tMOVD in+0(FP), R0\n\tMOVD initial+8(FP), R1\n\tMOVD out+16(FP), R2\n")
+	for _, base := range families {
+		for _, highHalf := range []bool{false, true} {
+			source.WriteString("\tVLD1 (R0), [V0.H8]\n\tVLD1 (R1), [V1.B16]\n")
+			word := encodeARM64SaturatingShiftNarrow(base, 8, 1, highHalf, 0, 1)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			source.WriteString("\tVST1.P [V1.B16], 16(R2)\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"saturatingShiftNarrowSemantics": {
+			Name: "saturatingShiftNarrowSemantics", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void saturatingShiftNarrowSemantics(const int16_t *, const uint8_t *, uint8_t *);
+static int16_t signed_clamp(int32_t value) {
+  if (value < INT8_MIN) return INT8_MIN;
+  if (value > INT8_MAX) return INT8_MAX;
+  return value;
+}
+static uint16_t unsigned_clamp(int32_t value) {
+  if (value < 0) return 0;
+  if (value > UINT8_MAX) return UINT8_MAX;
+  return value;
+}
+int main(void) {
+  const int16_t in[8] = {INT16_MIN, -1001, -255, -1, 0, 255, 1001, INT16_MAX};
+  uint8_t initial[16], got[12*16] = {0};
+  for (int i = 0; i < 16; i++) initial[i] = (uint8_t)(i * 13u + 7u);
+  saturatingShiftNarrowSemantics(in, initial, got);
+  for (int family = 0; family < 6; family++) {
+    for (int high = 0; high < 2; high++) {
+      const int output = (family * 2 + high) * 16;
+      for (int lane = 0; lane < 16; lane++) {
+        uint8_t want;
+        if (high && lane < 8) {
+          want = initial[lane];
+        } else if (!high && lane >= 8) {
+          want = 0;
+        } else {
+          const int input_lane = high ? lane - 8 : lane;
+          const int32_t signed_value = in[input_lane];
+          const uint32_t unsigned_value = (uint16_t)in[input_lane];
+          const int rounding = family == 1 || family == 3 || family == 5;
+          if (family < 2) {
+            int32_t shifted = signed_value >> 1;
+            if (rounding) shifted += signed_value & 1;
+            want = (uint8_t)(int8_t)signed_clamp(shifted);
+          } else if (family < 4) {
+            int32_t shifted = signed_value >> 1;
+            if (rounding) shifted += signed_value & 1;
+            want = (uint8_t)unsigned_clamp(shifted);
+          } else {
+            uint32_t shifted = unsigned_value >> 1;
+            if (rounding) shifted += unsigned_value & 1;
+            want = (uint8_t)(shifted > UINT8_MAX ? UINT8_MAX : shifted);
+          }
+        }
+        if (got[output+lane] != want) return output + lane + 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_saturating_shift_narrow", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_saturating_shift_test.go b/arm64_lower_saturating_shift_test.go
new file mode 100644
index 000000000..20c094122
--- /dev/null
+++ b/arm64_lower_saturating_shift_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func arm64SaturatingShiftCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT saturatingShiftComplete(SB),$0-0\n")
+	for _, op := range []string{"VSQSHL", "VUQSHL"} {
+		for _, arrangement := range []struct {
+			name     string
+			maxShift int
+		}{{"B8", 7}, {"B16", 7}, {"H4", 15}, {"H8", 15}, {"S2", 31}, {"S4", 31}, {"D2", 63}} {
+			source.WriteString("\t" + op + " $" + strconv.Itoa(arrangement.maxShift) + ", V1." + arrangement.name + ", V2." + arrangement.name + "\n")
+			source.WriteString("\t" + op + " V3." + arrangement.name + ", V4." + arrangement.name + ", V5." + arrangement.name + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SaturatingShiftCompleteFormats(t *testing.T) {
+	source := arm64SaturatingShiftCompleteForms()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"saturatingShiftComplete": {Name: "saturatingShiftComplete", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, intrinsic := range []string{"llvm.aarch64.neon.sqshl", "llvm.aarch64.neon.uqshl"} {
+		if !strings.Contains(ll, intrinsic) {
+			t.Fatalf("ARM64 saturating shift lowering omitted %q:\n%s", intrinsic, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-saturating-shift.ll", "arm64-saturating-shift.o", ll)
+}
+
+func TestTranslateARM64SaturatingShiftRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VSQSHL $8, V0.B8, V1.B8",
+		"VSQSHL V0.B8, V1.B16, V2.B8",
+		"VUQSHL $1, V0.D1, V1.D1",
+		"VUQSHL R0, V1.S4, V2.S4",
+		"VUQSHL.P V0.S4, V1.S4, V2.S4",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 saturating-shift optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_scalar_cvtf_test.go b/arm64_lower_scalar_cvtf_test.go
new file mode 100644
index 000000000..4f8192fde
--- /dev/null
+++ b/arm64_lower_scalar_cvtf_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64ScalarVectorCVTFForms = `
+TEXT scalarvectorcvtf(SB),$0-0
+	WORD $0x5e61db5b // SCVTFDD F26, F27
+	WORD $0x7e61db8e // UCVTFDD F28, F14
+	WORD $0x5e21dbc6 // SCVTFSS F30, F6
+	WORD $0x7e21d8d7 // UCVTFSS F6, F23
+	RET
+`
+
+func TestARM64RawScalarVectorCVTFCompleteForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64ScalarVectorCVTFForms, true)
+	file, err := Parse(ArchARM64, arm64ScalarVectorCVTFForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"scalarvectorcvtf": {Name: "scalarvectorcvtf", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"scvtf ${0:d}, ${1:d}", "ucvtf ${0:d}, ${1:d}", "scvtf ${0:s}, ${1:s}", "ucvtf ${0:s}, ${1:s}"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("missing %q in %s:\n%s", want, triple, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-scalar-cvtf.ll", "arm64-scalar-cvtf.o", ll)
+		})
+	}
+}
+
+func TestARM64RawScalarVectorCVTFRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT scalarvectorcvtf(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	FMOVD (R0), F0
+	WORD $0x5e61d801 // SCVTFDD F0, F1
+	WORD $0x7e61d802 // UCVTFDD F0, F2
+	FMOVD F1, (R1)
+	FMOVD F2, 8(R1)
+	FMOVS 8(R0), F3
+	WORD $0x5e21d864 // SCVTFSS F3, F4
+	WORD $0x7e21d865 // UCVTFSS F3, F5
+	FMOVS F4, 16(R1)
+	FMOVS F5, 20(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"scalarvectorcvtf": {
+			Name: "scalarvectorcvtf", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+struct Input { uint64_t d; uint32_t s; };
+struct Output { double signed64, unsigned64; float signed32, unsigned32; };
+extern void scalarvectorcvtf(const struct Input *, struct Output *);
+int main(void) {
+  struct Input input = {UINT64_MAX, UINT32_MAX};
+  struct Output got = {0};
+  scalarvectorcvtf(&input, &got);
+  if (got.signed64 != -1.0 || got.unsigned64 != (double)UINT64_MAX) return 1;
+  if (got.signed32 != -1.0f || got.unsigned32 != (float)UINT32_MAX) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_scalar_vector_cvtf", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_scalar_float_integer_test.go b/arm64_lower_scalar_float_integer_test.go
new file mode 100644
index 000000000..11d5eb82b
--- /dev/null
+++ b/arm64_lower_scalar_float_integer_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64ScalarFloatToIntegerForms = `
+TEXT scalarfloattointegerforms(SB),$0-0
+	FCVTZSD F0, R0
+	FCVTZSDW F1, R1
+	FCVTZSS F2, R2
+	FCVTZSSW F3, R3
+	FCVTZUD F4, R4
+	FCVTZUDW F5, R5
+	FCVTZUS F6, R6
+	FCVTZUSW F7, ZR
+	RET
+`
+
+func TestTranslateARM64ScalarFloatToIntegerCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64ScalarFloatToIntegerForms, true)
+	file, err := Parse(ArchARM64, arm64ScalarFloatToIntegerForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"scalarfloattointegerforms": {Name: "scalarfloattointegerforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"fcvtzs ${0:x}, ${1:d}", "fcvtzs ${0:w}, ${1:d}",
+				"fcvtzs ${0:x}, ${1:s}", "fcvtzs ${0:w}, ${1:s}",
+				"fcvtzu ${0:x}, ${1:d}", "fcvtzu ${0:w}, ${1:d}",
+				"fcvtzu ${0:x}, ${1:s}", "fcvtzu ${0:w}, ${1:s}",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("scalar float-to-integer lowering for %s omitted %s:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "scalar-float-to-integer.ll", "scalar-float-to-integer.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatToIntegerRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"FCVTZSS F0",
+		"FCVTZSS F0, R1, R2",
+		"FCVTZSS R0, R1",
+		"FCVTZSS F0, F1",
+		"FCVTZSS F0, RSP",
+		"FCVTZUSW.P F0, R1",
+	} {
+		source := "TEXT badscalarfloattointeger(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+			Sigs: map[string]FuncSig{"badscalarfloattointeger": {Name: "badscalarfloattointeger", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's scalar float-to-integer family", instruction)
+		}
+	}
+}
+
+func TestARM64ScalarFloatToIntegerRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT scalarfloattointeger(SB),$0-24
+	MOVD singles+0(FP), R0
+	MOVD doubles+8(FP), R1
+	MOVD output+16(FP), R2
+	FMOVS 0(R0), F0
+	FMOVS 4(R0), F1
+	FMOVD 0(R1), F2
+	FMOVD 8(R1), F3
+	FCVTZSS F0, R3
+	FCVTZSSW F1, R4
+	FCVTZUS F1, R5
+	FCVTZUSW F0, R6
+	FCVTZSD F2, R7
+	FCVTZSDW F3, R8
+	FCVTZUD F3, R9
+	FCVTZUDW F2, R10
+	MOVD R3, 0(R2)
+	MOVD R4, 8(R2)
+	MOVD R5, 16(R2)
+	MOVD R6, 24(R2)
+	MOVD R7, 32(R2)
+	MOVD R8, 40(R2)
+	MOVD R9, 48(R2)
+	MOVD R10, 56(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"scalarfloattointeger": {
+			Name: "scalarfloattointeger", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void scalarfloattointeger(const float *, const double *, uint64_t *);
+int main(void) {
+  const float singles[2] = {7.75f, -3.75f};
+  const double doubles[2] = {-9.5, 11.5};
+  uint64_t got[8] = {0};
+  const uint64_t want[8] = {7, UINT32_MAX - 2, 0, 7, UINT64_MAX - 8, 11, 11, 0};
+  scalarfloattointeger(singles, doubles, got);
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_scalar_float_to_integer", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_scalar_memory.go b/arm64_lower_scalar_memory.go
new file mode 100644
index 000000000..a1a901d26
--- /dev/null
+++ b/arm64_lower_scalar_memory.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import "fmt"
+
+func (c *arm64Ctx) lowerARM64ScalarMemory(op Op, ins Instr) (bool, bool, error) {
+	f, handled, err := parseARM64ScalarMemoryForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	// Capture the complete effective address before R27 is overwritten. In
+	// Go's expanded transfer both the original base and the transfer data can
+	// spell R27, but their reads occur on opposite sides of materialization.
+	ptr, base, increment := "", Reg(""), int64(0)
+	scratch := "undef"
+	if f.memory.Kind == OpMem {
+		mem := f.memory.Mem
+		if f.pre {
+			if err := c.updatePostInc(mem.Base, mem.Off); err != nil {
+				return true, false, err
+			}
+			mem.Off = 0
+		}
+		if f.scratch && f.scratchKnown && f.scratchAddress {
+			value, err := c.loadReg(f.scratchBase)
+			if err != nil {
+				return true, false, err
+			}
+			t := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", t, value, f.scratchOffset)
+			scratch = "%" + t
+		}
+		address, addressBase, inc, err := c.addrI64(mem, f.post)
+		if err != nil {
+			return true, false, err
+		}
+		base, increment = addressBase, inc
+		t := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", t, address)
+		ptr = "%" + t
+	} else if f.memory.Kind == OpSym {
+		ptr, err = c.ptrFromSB(f.memory.Sym)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if f.scratch {
+		if f.scratchKnown && !f.scratchAddress {
+			scratch = c.imm64(f.scratchOffset)
+		}
+		if err := c.storeReg("R27", scratch); err != nil {
+			return true, false, err
+		}
+		if !f.scratchKnown {
+			c.recordMachineUnavailable("R27")
+		}
+	}
+	if f.store {
+		value, err := c.loadRegisterWidth(f.data, f.bits)
+		if err != nil {
+			return true, false, err
+		}
+		if f.memory.Kind == OpFP {
+			err = c.storeFPFrameBits(f.memory.FPOffset, int64(f.bits/8), value)
+		} else {
+			if f.bits != 64 {
+				t := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", t, value, f.bits)
+				value = "%" + t
+			}
+			fmt.Fprintf(c.b, "  store i%d %s, ptr %s, align 1\n", f.bits, value, ptr)
+		}
+		if err != nil {
+			return true, false, err
+		}
+	} else {
+		var value string
+		if f.memory.Kind == OpFP {
+			value, err = c.loadFPFrameBits(f.memory.FPOffset, int64(f.bits/8))
+		} else {
+			t := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", t, f.bits, ptr)
+			value = "%" + t
+			if f.bits != 64 {
+				t := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", t, f.bits, value)
+				value = "%" + t
+			}
+		}
+		if err != nil {
+			return true, false, err
+		}
+		if f.bits != 64 {
+			value = c.arm64ExtendNarrow(value, f.bits, f.signed)
+		}
+		if err := c.storeReg(f.data, value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, c.updatePostInc(base, increment)
+}
diff --git a/arm64_lower_scalar_multiply.go b/arm64_lower_scalar_multiply.go
new file mode 100644
index 000000000..03b5aed10
--- /dev/null
+++ b/arm64_lower_scalar_multiply.go
@@ -0,0 +1,210 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64ScalarMultiply implements the complete scalar multiply rows shared
+// by Go 1.27's AMUL and AMADD optabs. In particular, the two-operand AMUL-row
+// form uses the destination as the second multiplicand.
+func (c *arm64Ctx) lowerARM64ScalarMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if spec, found := arm64MultiplyAccumulateOps[op]; found {
+		if strings.ToUpper(string(ins.Op)) != string(op) {
+			return true, false, fmt.Errorf("arm64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+		}
+		if len(ins.Args) != 4 {
+			return true, false, fmt.Errorf("arm64 %s expects four C_ZREG operands: %q", op, ins.Raw)
+		}
+		for _, operand := range ins.Args {
+			if !arm64ScalarMultiplyRegister(operand) {
+				return true, false, fmt.Errorf("arm64 %s expects four C_ZREG operands: %q", op, ins.Raw)
+			}
+		}
+		return true, false, c.lowerARM64MultiplyAccumulate(spec, ins)
+	}
+	switch op {
+	case "MNEG", "MNEGW", "SMULL", "UMULL", "SMNEGL", "UMNEGL", "SMULH", "UMULH":
+		if strings.ToUpper(string(ins.Op)) != string(op) {
+			return true, false, fmt.Errorf("arm64 %s does not accept instruction suffixes: %q", op, ins.Raw)
+		}
+		first, second, destination, err := c.arm64ScalarMultiplyOperands(op, ins)
+		if err != nil {
+			return true, false, err
+		}
+		switch op {
+		case "MNEG", "MNEGW":
+			return true, false, c.lowerARM64MultiplyNegate(op == "MNEGW", first, second, destination)
+		case "SMULL", "UMULL", "SMNEGL", "UMNEGL":
+			signed := op == "SMULL" || op == "SMNEGL"
+			negate := op == "SMNEGL" || op == "UMNEGL"
+			return true, false, c.lowerARM64MultiplyLong(signed, negate, first, second, destination)
+		case "SMULH", "UMULH":
+			return true, false, c.lowerARM64MultiplyHigh(op == "SMULH", first, second, destination)
+		}
+
+	}
+	return false, false, nil
+}
+
+func (c *arm64Ctx) arm64ScalarMultiplyOperands(op Op, ins Instr) (Operand, Operand, Reg, error) {
+	inputs, destination, valid := arm64ScalarMultiplyInputs(op, ins)
+	if !valid || len(inputs) != 2 {
+		return Operand{}, Operand{}, "", fmt.Errorf("arm64 %s expects two or three C_ZREG operands: %q", op, ins.Raw)
+	}
+	return inputs[0], inputs[1], destination.Reg, nil
+}
+
+// The complete Go AMUL and AMADD C_ZREG rows. Only the two-operand
+// shorthand reads Rd; three/four-operand forms overwrite it unless an
+// explicit source aliases Rd. Continuation analysis consumes this same
+// grammar, rather than reading every operand of a write-only destination.
+func arm64ScalarMultiplyInputs(op Op, ins Instr) ([]Operand, Operand, bool) {
+	count := 0
+	if _, found := arm64MultiplyAccumulateOps[op]; found {
+		count = 4
+	} else {
+		switch op {
+		case "MUL", "MULW", "MNEG", "MNEGW", "SMULL", "UMULL", "SMNEGL", "UMNEGL", "SMULH", "UMULH":
+			if len(ins.Args) == 2 || len(ins.Args) == 3 {
+				count = len(ins.Args)
+			}
+		}
+	}
+	if count == 0 || len(ins.Args) != count || strings.ToUpper(string(ins.Op)) != string(op) {
+		return nil, Operand{}, false
+	}
+	for _, operand := range ins.Args {
+		if !arm64ScalarMultiplyRegister(operand) {
+			return nil, Operand{}, false
+		}
+	}
+	inputs := ins.Args[:count-1]
+	if count == 2 {
+		inputs = ins.Args // The destination is the implicit second multiplicand.
+	}
+	return inputs, ins.Args[count-1], true
+}
+
+func arm64ScalarMultiplyRegister(operand Operand) bool {
+	return operand.Kind == OpReg && isARM64GeneralOrZeroReg(operand.Reg)
+}
+
+func (c *arm64Ctx) lowerARM64MultiplyNegate(word bool, first, second Operand, destination Reg) error {
+	if word {
+		a, err := c.eval32(first)
+		if err != nil {
+			return err
+		}
+		b, err := c.eval32(second)
+		if err != nil {
+			return err
+		}
+		product := c.newTmp()
+		result := c.newTmp()
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, a, b)
+		fmt.Fprintf(c.b, "  %%%s = sub i32 0, %%%s\n", result, product)
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+		return c.storeReg(destination, "%"+wide)
+	}
+	a, err := c.eval64(first, false)
+	if err != nil {
+		return err
+	}
+	b, err := c.eval64(second, false)
+	if err != nil {
+		return err
+	}
+	product := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", product, a, b)
+	fmt.Fprintf(c.b, "  %%%s = sub i64 0, %%%s\n", result, product)
+	return c.storeReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64MultiplyLong(signed, negate bool, first, second Operand, destination Reg) error {
+	a, err := c.eval32(first)
+	if err != nil {
+		return err
+	}
+	b, err := c.eval32(second)
+	if err != nil {
+		return err
+	}
+	extension := "zext"
+	if signed {
+		extension = "sext"
+	}
+	wideA := c.newTmp()
+	wideB := c.newTmp()
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s to i64\n", wideA, extension, a)
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s to i64\n", wideB, extension, b)
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", product, wideA, wideB)
+	value := "%" + product
+	if negate {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub i64 0, %s\n", result, value)
+		value = "%" + result
+	}
+	return c.storeReg(destination, value)
+}
+
+func (c *arm64Ctx) lowerARM64MultiplyHigh(signed bool, first, second Operand, destination Reg) error {
+	a, err := c.eval64(first, false)
+	if err != nil {
+		return err
+	}
+	b, err := c.eval64(second, false)
+	if err != nil {
+		return err
+	}
+	extension := "zext"
+	if signed {
+		extension = "sext"
+	}
+	wideA := c.newTmp()
+	wideB := c.newTmp()
+	product := c.newTmp()
+	high := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i64 %s to i128\n", wideA, extension, a)
+	fmt.Fprintf(c.b, "  %%%s = %s i64 %s to i128\n", wideB, extension, b)
+	fmt.Fprintf(c.b, "  %%%s = mul i128 %%%s, %%%s\n", product, wideA, wideB)
+	fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", high, product)
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", result, high)
+	return c.storeReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64MultiplyAddLong(signed, subtract bool, first, second, addend Operand, destination Reg) error {
+	a, err := c.eval32(first)
+	if err != nil {
+		return err
+	}
+	b, err := c.eval32(second)
+	if err != nil {
+		return err
+	}
+	cv, err := c.eval64(addend, false)
+	if err != nil {
+		return err
+	}
+	extension := "zext"
+	if signed {
+		extension = "sext"
+	}
+	wideA := c.newTmp()
+	wideB := c.newTmp()
+	product := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s to i64\n", wideA, extension, a)
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s to i64\n", wideB, extension, b)
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", product, wideA, wideB)
+	if subtract {
+		fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %%%s\n", result, cv, product)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", result, cv, product)
+	}
+	return c.storeReg(destination, "%"+result)
+}
diff --git a/arm64_lower_scalar_multiply_test.go b/arm64_lower_scalar_multiply_test.go
new file mode 100644
index 000000000..1fcd5f566
--- /dev/null
+++ b/arm64_lower_scalar_multiply_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64ScalarMultiplyCompleteGo127Forms(t *testing.T) {
+	const source = `TEXT scalarMultiplyForms(SB), $0-0
+	MNEG R0, R1
+	MNEG R0, R1, R2
+	MNEGW R3, R4
+	MNEGW R3, R4, R5
+	SMULL R6, R7
+	SMULL R6, R7, R8
+	UMULL R9, R10
+	UMULL R9, R10, R11
+	SMNEGL R12, R13
+	SMNEGL R12, R13, R14
+	UMNEGL R15, R16
+	UMNEGL R15, R16, R17
+	SMULH R17, R19
+	SMULH R17, R19, R20
+	UMULH R21, R22
+	UMULH R21, R22, R23
+	SMADDL R0, R1, R2, R3
+	SMSUBL R4, R5, R6, R7
+	UMADDL R8, R9, R10, R11
+	UMSUBL R12, R13, R14, R15
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"scalarMultiplyForms": {Name: "scalarMultiplyForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"sext i32", "zext i32", "sext i64", "zext i64", "mul i128", "lshr i128", "sub i64", "add i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("scalar multiply lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-scalar-multiply.ll", "arm64-scalar-multiply.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64ScalarMultiplyRejectsFormsOutsideGo127Optab(t *testing.T) {
+	for _, instruction := range []string{
+		"UMULL R0",
+		"UMULL $1, R0",
+		"SMULL R0, R1, R2, R3",
+		"SMULH R0, (R1)",
+		"UMULH.P R0, R1, R2",
+		"SMADDL R0, R1, R2",
+		"UMSUBL R0, R1, R2, (R3)",
+		"MNEG R0",
+		"MNEGW $1, R0",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT badScalarMultiply(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badScalarMultiply": {Name: "badScalarMultiply", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's scalar multiply optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64ScalarMultiplyRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT scalarMultiplyRuntime(SB), $0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD add+16(FP), R2
+	MOVD out+24(FP), R3
+	UMULL R0, R1, R4
+	MOVD R4, 0(R3)
+	SMULL R0, R1, R4
+	MOVD R4, 8(R3)
+	UMNEGL R0, R1, R4
+	MOVD R4, 16(R3)
+	SMNEGL R0, R1, R4
+	MOVD R4, 24(R3)
+	UMULH R0, R1, R4
+	MOVD R4, 32(R3)
+	SMULH R0, R1, R4
+	MOVD R4, 40(R3)
+	UMADDL R0, R2, R1, R4
+	MOVD R4, 48(R3)
+	UMSUBL R0, R2, R1, R4
+	MOVD R4, 56(R3)
+	SMADDL R0, R2, R1, R4
+	MOVD R4, 64(R3)
+	SMSUBL R0, R2, R1, R4
+	MOVD R4, 72(R3)
+	MNEG R0, R1, R4
+	MOVD R4, 80(R3)
+	MNEGW R0, R1, R4
+	MOVD R4, 88(R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"scalarMultiplyRuntime": {
+				Name: "scalarMultiplyRuntime", Args: []LLVMType{I64, I64, I64, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: I64, Index: 0, Field: -1},
+					{Offset: 8, Type: I64, Index: 1, Field: -1},
+					{Offset: 16, Type: I64, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void scalarMultiplyRuntime(uint64_t, uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  const uint64_t a = UINT64_C(0xffffffff80000003);
+  const uint64_t b = UINT64_C(0x8000000000000005);
+  const uint64_t add = UINT64_C(0x1020304050607080);
+  uint64_t got[12] = {0};
+  scalarMultiplyRuntime(a, b, add, got);
+  const uint64_t up = (uint64_t)(uint32_t)a * (uint64_t)(uint32_t)b;
+  const int64_t sp = (int64_t)(int32_t)a * (int64_t)(int32_t)b;
+  const unsigned __int128 uw = (unsigned __int128)a * (unsigned __int128)b;
+  const __int128 sw = (__int128)(int64_t)a * (__int128)(int64_t)b;
+  const uint64_t want[12] = {
+    up, (uint64_t)sp, 0-up, 0-(uint64_t)sp,
+    (uint64_t)(uw >> 64), (uint64_t)((unsigned __int128)sw >> 64),
+    add+up, add-up, add+(uint64_t)sp, add-(uint64_t)sp,
+    0-(a*b), (uint64_t)(uint32_t)(0-((uint32_t)a*(uint32_t)b)),
+  };
+  for (int i = 0; i < 12; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_scalar_multiply", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_sha.go b/arm64_lower_sha.go
new file mode 100644
index 000000000..de16c96cb
--- /dev/null
+++ b/arm64_lower_sha.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var (
+	arm64SHA32Arrangement = arm64VectorArrangement{elementBits: 32, lanes: 4}
+	arm64SHA64Arrangement = arm64VectorArrangement{elementBits: 64, lanes: 2}
+)
+
+func (c *arm64Ctx) lowerARM64SHA(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "SHA1C", "SHA1P", "SHA1M":
+		if err := validateARM64SHAHashForm(op, ins, arm64SHA32Arrangement); err != nil {
+			return true, false, err
+		}
+		schedule, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arm64SHA32Arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		hashVector, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arm64SHA32Arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		hash := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %s, i32 0\n", hash, hashVector)
+		destination, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arm64SHA32Arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <4 x i32> @llvm.aarch64.crypto.%s(<4 x i32> %s, i32 %%%s, <4 x i32> %s)\n", result, strings.ToLower(string(op)), destination, hash, schedule)
+		return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arm64SHA32Arrangement, "%"+result)
+
+	case "SHA1H":
+		if err := validateARM64SHABareRegisters(op, ins, 2); err != nil {
+			return true, false, err
+		}
+		sourceVector, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arm64SHA32Arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		source := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %s, i32 0\n", source, sourceVector)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.aarch64.crypto.sha1h(i32 %%%s)\n", result, source)
+		return true, false, c.storeARM64SHA1Scalar(ins.Args[1].Reg, "%"+result)
+
+	case "SHA1SU0", "SHA256SU1":
+		if err := validateARM64SHAArrangedRegisters(op, ins, 3, arm64SHA32Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector3(op, ins, arm64SHA32Arrangement)
+
+	case "SHA1SU1", "SHA256SU0":
+		if err := validateARM64SHAArrangedRegisters(op, ins, 2, arm64SHA32Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector2(op, ins, arm64SHA32Arrangement)
+
+	case "SHA256H", "SHA256H2":
+		if err := validateARM64SHAHashForm(op, ins, arm64SHA32Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector3(op, ins, arm64SHA32Arrangement)
+
+	case "SHA512H", "SHA512H2":
+		if err := validateARM64SHAHashForm(op, ins, arm64SHA64Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector3(op, ins, arm64SHA64Arrangement)
+
+	case "SHA512SU0":
+		if err := validateARM64SHAArrangedRegisters(op, ins, 2, arm64SHA64Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector2(op, ins, arm64SHA64Arrangement)
+
+	case "SHA512SU1":
+		if err := validateARM64SHAArrangedRegisters(op, ins, 3, arm64SHA64Arrangement); err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SHAVector3(op, ins, arm64SHA64Arrangement)
+	}
+	return false, false, nil
+}
+
+func validateARM64SHAHashForm(op Op, ins Instr, arrangement arm64VectorArrangement) error {
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return fmt.Errorf("arm64 %s expects an optional-arrangement source and two bare V registers with no suffix: %q", op, ins.Raw)
+	}
+	if !arm64SHARegisterMatches(ins.Args[0], arrangement, true) || !arm64SHARegisterMatches(ins.Args[1], arrangement, false) || !arm64SHARegisterMatches(ins.Args[2], arrangement, false) {
+		return fmt.Errorf("arm64 %s operands do not match Go's assembler table: %q", op, ins.Raw)
+	}
+	return nil
+}
+
+func validateARM64SHABareRegisters(op Op, ins Instr, count int) error {
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != count {
+		return fmt.Errorf("arm64 %s expects %d bare V registers with no suffix: %q", op, count, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if !arm64SHARegisterMatches(arg, arm64VectorArrangement{}, false) {
+			return fmt.Errorf("arm64 %s expects only bare V registers: %q", op, ins.Raw)
+		}
+	}
+	return nil
+}
+
+func validateARM64SHAArrangedRegisters(op Op, ins Instr, count int, arrangement arm64VectorArrangement) error {
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != count {
+		return fmt.Errorf("arm64 %s expects %d same-arrangement V registers with no suffix: %q", op, count, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if !arm64SHARegisterMatches(arg, arrangement, true) || !strings.Contains(string(arg.Reg), ".") {
+			return fmt.Errorf("arm64 %s operands do not match Go's assembler table: %q", op, ins.Raw)
+		}
+	}
+	return nil
+}
+
+func arm64SHARegisterMatches(arg Operand, arrangement arm64VectorArrangement, allowArrangement bool) bool {
+	if arg.Kind != OpReg {
+		return false
+	}
+	if _, ok := arm64ParseVReg(arg.Reg); !ok {
+		return false
+	}
+	hasArrangement := strings.Contains(string(arg.Reg), ".")
+	if !hasArrangement {
+		return true
+	}
+	if !allowArrangement {
+		return false
+	}
+	got, ok := parseARM64VectorArrangement(arg.Reg)
+	return ok && got == arrangement
+}
+
+func (c *arm64Ctx) lowerARM64SHAVector2(op Op, ins Instr, arrangement arm64VectorArrangement) error {
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	destination, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.crypto.%s(%s %s, %s %s)\n", result, vectorType, strings.ToLower(string(op)), vectorType, destination, vectorType, source)
+	return c.storeARM64VectorInteger(ins.Args[1].Reg, arrangement, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SHAVector3(op Op, ins Instr, arrangement arm64VectorArrangement) error {
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	destination, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arrangement)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.crypto.%s(%s %s, %s %s, %s %s)\n", result, vectorType, strings.ToLower(string(op)), vectorType, destination, vectorType, second, vectorType, first)
+	return c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, "%"+result)
+}
+
+func (c *arm64Ctx) storeARM64SHA1Scalar(reg Reg, value string) error {
+	vector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> zeroinitializer, i32 %s, i32 0\n", vector, value)
+	return c.storeARM64VectorInteger(reg, arm64SHA32Arrangement, "%"+vector)
+}
diff --git a/arm64_lower_sha3.go b/arm64_lower_sha3.go
new file mode 100644
index 000000000..19a6045cb
--- /dev/null
+++ b/arm64_lower_sha3.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SHA3(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "VEOR3", "VBCAX":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+			return true, false, fmt.Errorf("arm64 %s expects four V.B16 operands with no suffix: %q", op, ins.Raw)
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind != OpReg || string(arg.Reg) != strings.Split(string(arg.Reg), ".")[0]+".B16" {
+				return true, false, fmt.Errorf("arm64 %s expects four V.B16 operands: %q", op, ins.Raw)
+			}
+			arrangement, valid := parseARM64VectorArrangement(arg.Reg)
+			if !valid || arrangement.elementBits != 8 || arrangement.lanes != 16 {
+				return true, false, fmt.Errorf("arm64 %s expects four V.B16 operands: %q", op, ins.Raw)
+			}
+		}
+		a, err := c.loadVReg(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		m, err := c.loadVReg(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		n, err := c.loadVReg(ins.Args[2].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		var result string
+		if op == "VEOR3" {
+			first := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", first, a, m)
+			second := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %%%s, %s\n", second, first, n)
+			result = "%" + second
+		} else {
+			// BCAX Vd, Vn, Vm, Va computes Vn XOR (Vm AND NOT Va).
+			complement := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %s\n", complement, a, arm64VectorI8Splat(-1))
+			cleared := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and <16 x i8> %s, %%%s\n", cleared, m, complement)
+			combined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor <16 x i8> %s, %%%s\n", combined, n, cleared)
+			result = "%" + combined
+		}
+		return true, false, c.storeVReg(ins.Args[3].Reg, result)
+
+	case "VRAX1":
+		if err := validateARM64SHA3D2Registers(op, ins, 3); err != nil {
+			return true, false, err
+		}
+		m, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2})
+		if err != nil {
+			return true, false, err
+		}
+		n, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2})
+		if err != nil {
+			return true, false, err
+		}
+		left := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl <2 x i64> %s, <i64 1, i64 1>\n", left, m)
+		right := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr <2 x i64> %s, <i64 63, i64 63>\n", right, m)
+		rotated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or <2 x i64> %%%s, %%%s\n", rotated, left, right)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %%%s\n", result, n, rotated)
+		return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2}, "%"+result)
+
+	case "VXAR":
+		if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 || ins.Args[0].Kind != OpImm {
+			return true, false, fmt.Errorf("arm64 VXAR expects $0..$63 and three V.D2 operands with no suffix: %q", ins.Raw)
+		}
+		if ins.Args[0].Imm < 0 || ins.Args[0].Imm > 63 {
+			return true, false, fmt.Errorf("arm64 VXAR immediate is outside 0..63: %q", ins.Raw)
+		}
+		registerInstruction := ins
+		registerInstruction.Args = ins.Args[1:]
+		if err := validateARM64SHA3D2Registers(op, registerInstruction, 3); err != nil {
+			return true, false, err
+		}
+		m, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2})
+		if err != nil {
+			return true, false, err
+		}
+		n, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2})
+		if err != nil {
+			return true, false, err
+		}
+		xored := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %s\n", xored, m, n)
+		result := "%" + xored
+		if ins.Args[0].Imm != 0 {
+			shift := ins.Args[0].Imm
+			right := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr <2 x i64> %%%s, <i64 %d, i64 %d>\n", right, xored, shift, shift)
+			left := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shl <2 x i64> %%%s, <i64 %d, i64 %d>\n", left, xored, 64-shift, 64-shift)
+			rotated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = or <2 x i64> %%%s, %%%s\n", rotated, right, left)
+			result = "%" + rotated
+		}
+		return true, false, c.storeARM64VectorInteger(ins.Args[3].Reg, arm64VectorArrangement{elementBits: 64, lanes: 2}, result)
+	}
+	return false, false, nil
+}
+
+func validateARM64SHA3D2Registers(op Op, ins Instr, count int) error {
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != count {
+		return fmt.Errorf("arm64 %s expects %d V.D2 operands with no suffix: %q", op, count, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return fmt.Errorf("arm64 %s expects only V.D2 operands: %q", op, ins.Raw)
+		}
+		arrangement, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || arrangement.elementBits != 64 || arrangement.lanes != 2 {
+			return fmt.Errorf("arm64 %s expects only V.D2 operands: %q", op, ins.Raw)
+		}
+	}
+	return nil
+}
+
+func arm64VectorI8Splat(value int) string {
+	values := make([]string, 16)
+	for i := range values {
+		values[i] = fmt.Sprintf("i8 %d", value)
+	}
+	return "<" + strings.Join(values, ", ") + ">"
+}
diff --git a/arm64_lower_sha3_test.go b/arm64_lower_sha3_test.go
new file mode 100644
index 000000000..79d00cac1
--- /dev/null
+++ b/arm64_lower_sha3_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64SHA3Forms = `
+TEXT sha3forms(SB),$0-0
+	VEOR3 V0.B16, V1.B16, V2.B16, V3.B16
+	VBCAX V4.B16, V5.B16, V6.B16, V7.B16
+	VRAX1 V8.D2, V9.D2, V10.D2
+	VXAR $0, V11.D2, V12.D2, V13.D2
+	VXAR $63, V14.D2, V15.D2, V16.D2
+	RET
+`
+
+func TestTranslateARM64SHA3CompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64SHA3Forms, true)
+	file, err := Parse(ArchARM64, arm64SHA3Forms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"sha3forms": {Name: "sha3forms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"xor <16 x i8>", "and <16 x i8>", "shl <2 x i64>", "lshr <2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 SHA3 lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sha3.ll", "arm64-sha3.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SHA3RejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VEOR3 V0.B8, V1.B8, V2.B8, V3.B8",
+		"VEOR3 V0.B16, V1.B16, V2.B16",
+		"VBCAX V0.D2, V1.D2, V2.D2, V3.D2",
+		"VRAX1 V0.B16, V1.B16, V2.B16",
+		"VXAR $64, V0.D2, V1.D2, V2.D2",
+		"VXAR $1, V0.S4, V1.S4, V2.S4",
+		"VXAR.P $1, V0.D2, V1.D2, V2.D2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsha3(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badsha3": {Name: "badsha3", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SHA3 optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64SHA3RuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT sha3semantics(SB),$0-8
+	MOVD out+0(FP), R0
+	VMOVQ $0x0123456789abcdef, $0xfedcba9876543210, V1
+	VMOVQ $0x1111222233334444, $0xaaaabbbbccccdddd, V2
+	VMOVQ $0x0f0f0f0f0f0f0f0f, $0x5555555555555555, V3
+	VEOR3 V1.B16, V2.B16, V3.B16, V4.B16
+	VBCAX V1.B16, V2.B16, V3.B16, V5.B16
+	VRAX1 V1.D2, V2.D2, V6.D2
+	VXAR $13, V1.D2, V2.D2, V7.D2
+	VMOV V4.D[0], R1
+	VMOV V4.D[1], R2
+	VMOV V5.D[0], R3
+	VMOV V5.D[1], R4
+	VMOV V6.D[0], R5
+	VMOV V6.D[1], R6
+	VMOV V7.D[0], R7
+	VMOV V7.D[1], R8
+	MOVD R1, 0(R0)
+	MOVD R2, 8(R0)
+	MOVD R3, 16(R0)
+	MOVD R4, 24(R0)
+	MOVD R5, 32(R0)
+	MOVD R6, 40(R0)
+	MOVD R7, 48(R0)
+	MOVD R8, 56(R0)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"sha3semantics": {
+				Name: "sha3semantics", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void sha3semantics(uint64_t *);
+static uint64_t rotl1(uint64_t x) { return (x << 1) | (x >> 63); }
+static uint64_t rotr13(uint64_t x) { return (x >> 13) | (x << 51); }
+int main(void) {
+  uint64_t got[8] = {0};
+  const uint64_t a[2] = {UINT64_C(0x0123456789abcdef), UINT64_C(0xfedcba9876543210)};
+  const uint64_t m[2] = {UINT64_C(0x1111222233334444), UINT64_C(0xaaaabbbbccccdddd)};
+  const uint64_t n[2] = {UINT64_C(0x0f0f0f0f0f0f0f0f), UINT64_C(0x5555555555555555)};
+  sha3semantics(got);
+  for (int i = 0; i < 2; i++) {
+    if (got[i] != (a[i] ^ m[i] ^ n[i])) return 1;
+    if (got[2+i] != (n[i] ^ (m[i] & ~a[i]))) return 2;
+    if (got[4+i] != (m[i] ^ rotl1(a[i]))) return 3;
+    if (got[6+i] != rotr13(a[i] ^ m[i])) return 4;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_sha3", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_sha_test.go b/arm64_lower_sha_test.go
new file mode 100644
index 000000000..6d2781853
--- /dev/null
+++ b/arm64_lower_sha_test.go
@@ -0,0 +1,251 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64SHAForms = `
+TEXT shaforms(SB),$0-0
+	SHA1C V0, V1, V2
+	SHA1C V3.S4, V4, V5
+	SHA1P V6, V7, V8
+	SHA1P V9.S4, V10, V11
+	SHA1M V12, V13, V14
+	SHA1M V15.S4, V16, V17
+	SHA1H V18, V19
+	SHA1SU0 V20.S4, V21.S4, V22.S4
+	SHA1SU1 V23.S4, V24.S4
+	SHA256H V25, V26, V27
+	SHA256H V28.S4, V29, V30
+	SHA256H2 V0, V1, V2
+	SHA256H2 V3.S4, V4, V5
+	SHA256SU0 V6.S4, V7.S4
+	SHA256SU1 V8.S4, V9.S4, V10.S4
+	SHA512H V11, V12, V13
+	SHA512H V14.D2, V15, V16
+	SHA512H2 V17, V18, V19
+	SHA512H2 V20.D2, V21, V22
+	SHA512SU0 V23.D2, V24.D2
+	SHA512SU1 V25.D2, V26.D2, V27.D2
+	RET
+`
+
+func TestTranslateARM64SHACompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64SHAForms, true)
+	file, err := Parse(ArchARM64, arm64SHAForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"shaforms": {Name: "shaforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"@llvm.aarch64.crypto.sha1c",
+				"@llvm.aarch64.crypto.sha1p",
+				"@llvm.aarch64.crypto.sha1m",
+				"@llvm.aarch64.crypto.sha1h",
+				"@llvm.aarch64.crypto.sha1su0",
+				"@llvm.aarch64.crypto.sha1su1",
+				"@llvm.aarch64.crypto.sha256h",
+				"@llvm.aarch64.crypto.sha256h2",
+				"@llvm.aarch64.crypto.sha256su0",
+				"@llvm.aarch64.crypto.sha256su1",
+				"@llvm.aarch64.crypto.sha512h",
+				"@llvm.aarch64.crypto.sha512h2",
+				"@llvm.aarch64.crypto.sha512su0",
+				"@llvm.aarch64.crypto.sha512su1",
+				`"target-features"="+sha2,+sha3"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 SHA lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sha.ll", "arm64-sha.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SHARejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"SHA1C V0.B16, V1, V2",
+		"SHA1C V0.S4, V1.S4, V2",
+		"SHA1C V0.S4, V1, V2.S4",
+		"SHA1H V0.S4, V1",
+		"SHA1SU0 V0.S4, V1.S4, V2.D2",
+		"SHA1SU1 V0.B16, V1.B16",
+		"SHA256H V0.D2, V1, V2",
+		"SHA256SU0 V0.S4, V1",
+		"SHA256SU1 V0.S4, V1.D2, V2.S4",
+		"SHA512H V0.S4, V1, V2",
+		"SHA512SU0 V0.D2, V1.S4",
+		"SHA512SU1 V0.D2, V1.D2, V2.S4",
+		"SHA1C.P V0.S4, V1, V2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsha(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badsha": {Name: "badsha", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SHA optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64SHARuntimeOperandOrderAndResults(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT shasemantics(SB),$0-16
+	MOVD out+0(FP), R1
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA1C V0.S4, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA1P V0.S4, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA1M V0.S4, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16]
+	SHA1H V0, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA1SU0 V0.S4, V1.S4, V2.S4
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA1SU1 V0.S4, V2.S4
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA256H V0.S4, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA256H2 V0.S4, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA256SU0 V0.S4, V2.S4
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA256SU1 V0.S4, V1.S4, V2.S4
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA512H V0.D2, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA512H2 V0.D2, V1, V2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA512SU0 V0.D2, V2.D2
+	VST1.P [V2.B16], 16(R1)
+	MOVD in+8(FP), R0
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16]
+	SHA512SU1 V0.D2, V1.D2, V2.D2
+	VST1 [V2.B16], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"shasemantics": {
+				Name: "shasemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void shasemantics(uint8_t *, const uint8_t *);
+
+static void oracle(uint8_t *out, const uint8_t *in) {
+  uint8_t *o = out;
+  __asm__ volatile(
+    ".arch armv8.4-a+sha3\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha1c q2, s1, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha1p q2, s1, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha1m q2, s1, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldr q0, [%1]\n\tsha1h s2, s0\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha1su0 v2.4s, v1.4s, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha1su1 v2.4s, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha256h q2, q1, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha256h2 q2, q1, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha256su0 v2.4s, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha256su1 v2.4s, v1.4s, v0.4s\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha512h q2, q1, v0.2d\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha512h2 q2, q1, v0.2d\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha512su0 v2.2d, v0.2d\n\tstr q2, [%0], #16\n\t"
+    "ldp q0, q1, [%1]\n\tldr q2, [%1, #32]\n\tsha512su1 v2.2d, v1.2d, v0.2d\n\tstr q2, [%0]"
+    : "+r"(o) : "r"(in) : "v0", "v1", "v2", "memory");
+}
+
+int main(void) {
+  uint8_t in[48];
+  uint8_t got[14 * 16] = {0};
+  uint8_t want[14 * 16] = {0};
+  for (unsigned i = 0; i < sizeof(in); ++i) in[i] = (uint8_t)(i * 37u + 11u);
+  shasemantics(got, in);
+  oracle(want, in);
+  return memcmp(got, want, sizeof(got)) != 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_sha", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_shift_insert.go b/arm64_lower_shift_insert.go
new file mode 100644
index 000000000..53bc4880b
--- /dev/null
+++ b/arm64_lower_shift_insert.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorShiftInsert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VSRI" && op != "VSLI" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects $shift, Vsrc.<T>, Vdst.<T> and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	allowed := func(a arm64VectorArrangement) bool {
+		return (a.elementBits == 8 && (a.lanes == 8 || a.lanes == 16)) ||
+			(a.elementBits == 16 && (a.lanes == 4 || a.lanes == 8)) ||
+			(a.elementBits == 32 && (a.lanes == 2 || a.lanes == 4)) ||
+			(a.elementBits == 64 && a.lanes == 2)
+	}
+	if !sourceOK || !destinationOK || sourceArrangement != destinationArrangement || !allowed(sourceArrangement) {
+		return true, false, fmt.Errorf("arm64 %s requires matching B8/B16/H4/H8/S2/S4/D2 arrangements: %q", op, ins.Raw)
+	}
+	shift := ins.Args[0].Imm
+	if op == "VSRI" {
+		if shift < 1 || shift > int64(sourceArrangement.elementBits) {
+			return true, false, fmt.Errorf("arm64 VSRI shift must be in [1,%d]: %q", sourceArrangement.elementBits, ins.Raw)
+		}
+	} else if shift < 0 || shift >= int64(sourceArrangement.elementBits) {
+		return true, false, fmt.Errorf("arm64 VSLI shift must be in [0,%d]: %q", sourceArrangement.elementBits-1, ins.Raw)
+	}
+	source, err := c.loadARM64VectorInteger(ins.Args[1].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	destination, err := c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	result := source
+	if op == "VSRI" {
+		if shift == int64(sourceArrangement.elementBits) {
+			result = destination
+		} else {
+			lowBits := int64(sourceArrangement.elementBits) - shift
+			high := c.newTmp()
+			preserved := c.newTmp()
+			inserted := c.newTmp()
+			combined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", high, vectorType, destination, arm64VectorIntegerSplat(sourceArrangement, lowBits))
+			fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, %s\n", preserved, vectorType, high, arm64VectorIntegerSplat(sourceArrangement, lowBits))
+			fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", inserted, vectorType, source, arm64VectorIntegerSplat(sourceArrangement, shift))
+			fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", combined, vectorType, preserved, inserted)
+			result = "%" + combined
+		}
+	} else if shift > 0 {
+		preserved := c.newTmp()
+		inserted := c.newTmp()
+		combined := c.newTmp()
+		lowMask := int64((uint64(1) << uint(shift)) - 1)
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", preserved, vectorType, destination, arm64VectorIntegerSplat(sourceArrangement, lowMask))
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, %s\n", inserted, vectorType, source, arm64VectorIntegerSplat(sourceArrangement, shift))
+		fmt.Fprintf(c.b, "  %%%s = or %s %%%s, %%%s\n", combined, vectorType, preserved, inserted)
+		result = "%" + combined
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, result)
+}
diff --git a/arm64_lower_shift_insert_test.go b/arm64_lower_shift_insert_test.go
new file mode 100644
index 000000000..569657436
--- /dev/null
+++ b/arm64_lower_shift_insert_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorShiftInsertCompleteGoAssemblerForms(t *testing.T) {
+	forms := []struct {
+		arrangement string
+		bits        int
+	}{{"B8", 8}, {"B16", 8}, {"H4", 16}, {"H8", 16}, {"S2", 32}, {"S4", 32}, {"D2", 64}}
+	var source strings.Builder
+	source.WriteString("TEXT vectorshiftinsertforms(SB),$0-0\n")
+	for _, form := range forms {
+		for _, shift := range []int{1, form.bits} {
+			fmt.Fprintf(&source, "\tVSRI $%d, V0.%s, V1.%s\n", shift, form.arrangement, form.arrangement)
+		}
+		for _, shift := range []int{0, form.bits - 1} {
+			fmt.Fprintf(&source, "\tVSLI $%d, V2.%s, V3.%s\n", shift, form.arrangement, form.arrangement)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectorshiftinsertforms": {Name: "vectorshiftinsertforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"lshr <", "shl <", "and <", "or <"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 vector shift-insert lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-shift-insert.ll", "arm64-vector-shift-insert.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorShiftInsertRejectsInvalidForms(t *testing.T) {
+	for _, tc := range []struct {
+		instruction string
+		goAccepts   bool
+	}{
+		{"VSRI $0, V0.S4, V1.S4", false},
+		{"VSRI $33, V0.S4, V1.S4", false},
+		// Go 1.27 accepts this and encodes it as a different element width.
+		// Retain the architectural range check instead of copying that bug.
+		{"VSLI $-1, V0.S4, V1.S4", true},
+		{"VSLI $32, V0.S4, V1.S4", false},
+		{"VSRI $1, V0.S2, V1.S4", false},
+		{"VSLI $1, V0.D1, V1.D1", false},
+		{"VSRI.P $1, V0.S4, V1.S4", false},
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(tc.instruction), func(t *testing.T) {
+			source := "TEXT badvectorshiftinsert(SB),$0-0\n\t" + tc.instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, tc.goAccepts)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+				Sigs: map[string]FuncSig{"badvectorshiftinsert": {Name: "badvectorshiftinsert", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted invalid vector shift-insert form %q", tc.instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorShiftInsertRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorshiftinsert(SB),$0-24
+	MOVD src+0(FP), R0
+	MOVD dst+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	VSRI $20, V0.S4, V1.S4
+	VST1.P [V1.S4], 16(R2)
+	VLD1 (R1), [V1.S4]
+	VSLI $7, V0.S4, V1.S4
+	VST1 [V1.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorshiftinsert": {
+				Name: "vectorshiftinsert", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorshiftinsert(const uint32_t *, const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t src[4] = {0x12345678u, 0xffffffffu, 0x80000000u, 1u};
+  const uint32_t dst[4] = {0xabcdef01u, 0x01234567u, 0xffffffffu, 0u};
+  uint32_t got[8] = {0};
+  vectorshiftinsert(src, dst, got);
+  for (int i = 0; i < 4; i++) {
+    uint32_t sri = (dst[i] & 0xfffff000u) | (src[i] >> 20);
+    uint32_t sli = (dst[i] & 0x0000007fu) | (src[i] << 7);
+    if (got[i] != sri) return i + 1;
+    if (got[4+i] != sli) return i + 11;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_shift_insert", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_shift_left.go b/arm64_lower_shift_left.go
new file mode 100644
index 000000000..2122b0e29
--- /dev/null
+++ b/arm64_lower_shift_left.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import "fmt"
+
+// lowerARM64VectorShiftLeft implements Go's complete AVSHL immediate optab
+// row for all seven accepted 64- and 128-bit vector arrangements.
+func (c *arm64Ctx) lowerARM64VectorShiftLeft(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VSHL" {
+		return false, false, nil
+	}
+	form, err := parseARM64VectorShift(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	sourceArrangement, shift := form.arrangement, form.shift
+	source, err := c.loadARM64VectorInteger(ins.Args[1].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl <%d x i%d> %s, %s\n", result, sourceArrangement.lanes, sourceArrangement.elementBits, source, arm64VectorIntegerSplat(sourceArrangement, shift))
+	return true, false, c.storeARM64VectorInteger(form.destination, sourceArrangement, "%"+result)
+}
diff --git a/arm64_lower_shift_left_test.go b/arm64_lower_shift_left_test.go
new file mode 100644
index 000000000..583a75146
--- /dev/null
+++ b/arm64_lower_shift_left_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorShiftLeftCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT vectorshiftleftforms(SB),$0-0\n")
+	for _, form := range []struct {
+		arrangement string
+		maxShift    int
+	}{
+		{"B8", 7}, {"B16", 7}, {"H4", 15}, {"H8", 15},
+		{"S2", 31}, {"S4", 31}, {"D2", 63},
+	} {
+		source.WriteString("\tVSHL $0, V0." + form.arrangement + ", V1." + form.arrangement + "\n")
+		source.WriteString("\tVSHL $" + strconv.Itoa(form.maxShift) + ", V2." + form.arrangement + ", V3." + form.arrangement + "\n")
+	}
+	source.WriteString("\tRET\n")
+	forms := source.String()
+	requireARM64GoAssemblerResult(t, forms, true)
+	file, err := Parse(ArchARM64, forms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"vectorshiftleftforms": {Name: "vectorshiftleftforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "shl <") {
+				t.Fatalf("ARM64 VSHL lowering for %s omitted vector shift:\n%s", triple, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-shift-left.ll", "arm64-vector-shift-left.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorShiftLeftRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSHL $8, V0.B16, V1.B16",
+		"VSHL $16, V0.H8, V1.H8",
+		"VSHL $32, V0.S4, V1.S4",
+		"VSHL $64, V0.D2, V1.D2",
+		"VSHL $1, V0.S2, V1.S4",
+		"VSHL $1, V0.D1, V1.D1",
+		"VSHL V0.S4, V1.S4",
+		"VSHL.P $1, V0.S4, V1.S4",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectorshiftleft(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorshiftleft": {Name: "badvectorshiftleft", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VSHL optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorShiftLeftRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorshiftleft(SB),$0-8
+	MOVD out+0(FP), R0
+	VMOVQ $0x0000000200000001, $0x8000000040000000, V1
+	VSHL $1, V1.S4, V2.S4
+	VSHL $31, V1.S4, V3.S4
+	VMOV V2.D[0], R1
+	VMOV V2.D[1], R2
+	VMOV V3.D[0], R3
+	VMOV V3.D[1], R4
+	MOVD R1, 0(R0)
+	MOVD R2, 8(R0)
+	MOVD R3, 16(R0)
+	MOVD R4, 24(R0)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorshiftleft": {
+				Name: "vectorshiftleft", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorshiftleft(uint64_t *);
+int main(void) {
+  uint64_t got[4] = {0};
+  vectorshiftleft(got);
+  if (got[0] != UINT64_C(0x0000000400000002) || got[1] != UINT64_C(0x0000000080000000)) return 1;
+  if (got[2] != UINT64_C(0x0000000080000000) || got[3] != 0) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_shift_left", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_shift_narrow.go b/arm64_lower_shift_narrow.go
new file mode 100644
index 000000000..0539aa003
--- /dev/null
+++ b/arm64_lower_shift_narrow.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorShiftNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VSHRN" && op != "VSHRN2" && op != "VRSHRN" && op != "VRSHRN2" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects immediate, wide vector source, narrow vector destination, and no suffix: %q", op, ins.Raw)
+	}
+
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	highHalf := op == "VSHRN2" || op == "VRSHRN2"
+	rounding := op == "VRSHRN" || op == "VRSHRN2"
+	wantDestinationLanes := sourceArrangement.lanes
+	if highHalf {
+		wantDestinationLanes *= 2
+	}
+	shift := ins.Args[0].Imm
+	if !sourceOK || !destinationOK ||
+		sourceArrangement.lanes*sourceArrangement.elementBits != 128 ||
+		sourceArrangement.elementBits != destinationArrangement.elementBits*2 ||
+		destinationArrangement.lanes != wantDestinationLanes ||
+		shift < 1 || shift > int64(destinationArrangement.elementBits) {
+		return true, false, fmt.Errorf("arm64 %s requires $1..$N with H8->B8/S4->H4/D2->S2 (or the doubled *2 destination): %q", op, ins.Raw)
+	}
+
+	source, err := c.loadARM64VectorInteger(ins.Args[1].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	sourceType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	shifted := c.newTmp()
+	shiftValue := arm64VectorIntegerSplat(sourceArrangement, shift)
+	if rounding {
+		// RSHRN rounds the signed source before narrowing. The addition is
+		// intentionally wrapping at the source width, matching the ARM
+		// instruction's two's-complement operation for non-saturating forms.
+		bias := arm64VectorIntegerSplat(sourceArrangement, int64(1)<<(shift-1))
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", rounded, sourceType, source, bias)
+		fmt.Fprintf(c.b, "  %%%s = ashr %s %%%s, %s\n", shifted, sourceType, rounded, shiftValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shifted, sourceType, source, shiftValue)
+	}
+	destinationType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, destinationArrangement.elementBits)
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", narrowed, sourceType, shifted, destinationType)
+	if !highHalf {
+		return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, "%"+narrowed)
+	}
+
+	// VSHRN2 preserves the existing low half and inserts the narrowed values
+	// into the high half of the destination vector.
+	result, err := c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	fullDestinationType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, destinationArrangement.elementBits)
+	for lane := 0; lane < sourceArrangement.lanes; lane++ {
+		element := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", element, destinationType, narrowed, lane)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n",
+			inserted, fullDestinationType, result, destinationArrangement.elementBits, element, sourceArrangement.lanes+lane)
+		result = "%" + inserted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, result)
+}
diff --git a/arm64_lower_shift_narrow_test.go b/arm64_lower_shift_narrow_test.go
new file mode 100644
index 000000000..966b9c047
--- /dev/null
+++ b/arm64_lower_shift_narrow_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorShiftNarrowCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 exposes exactly H8->B8, S4->H4, and D2->S2 for VSHRN;
+	// VSHRN2 writes the same narrowed lanes into the high half. Exercise both
+	// endpoints of every legal immediate interval: 1..8, 1..16, and 1..32.
+	const source = `TEXT ·vectorShiftNarrowForms(SB), $0-0
+	VSHRN $1, V1.H8, V0.B8
+	VSHRN $8, V31.H8, V30.B8
+	VSHRN $1, V2.S4, V3.H4
+	VSHRN $16, V30.S4, V29.H4
+	VSHRN $1, V4.D2, V5.S2
+	VSHRN $32, V29.D2, V28.S2
+	VSHRN2 $1, V6.H8, V7.B16
+	VSHRN2 $8, V28.H8, V27.B16
+	VSHRN2 $1, V8.S4, V9.H8
+	VSHRN2 $16, V27.S4, V26.H8
+	VSHRN2 $1, V10.D2, V11.S4
+	VSHRN2 $32, V26.D2, V25.S4
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorShiftNarrowForms": {Name: "vectorShiftNarrowForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"lshr <", "trunc <", "insertelement <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s VSHRN IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-shift-narrow.ll", "arm64-vector-shift-narrow.o", ll)
+	}
+}
+
+func TestTranslateARM64VectorShiftNarrowRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSHRN $0, V0.H8, V1.B8",
+		"VSHRN $9, V0.H8, V1.B8",
+		"VSHRN $17, V0.S4, V1.H4",
+		"VSHRN $33, V0.D2, V1.S2",
+		"VSHRN V0.H8, V1.B8",
+		"VSHRN $1, V0.B16, V1.B8",
+		"VSHRN2 $1, V0.H8, V1.B8",
+		"VSHRN.P $1, V0.H8, V1.B8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT ·badVectorShiftNarrow(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorShiftNarrow": {Name: "badVectorShiftNarrow", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VSHRN tables", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_signed_lane.go b/arm64_lower_signed_lane.go
new file mode 100644
index 000000000..db32de639
--- /dev/null
+++ b/arm64_lower_signed_lane.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import "fmt"
+
+// ARM64's SMOV family extracts a signed vector lane into a general register.
+// The 32-bit destination form accepts byte and halfword lanes; the 64-bit
+// destination form also accepts word lanes. A W-register write clears the
+// upper half of the physical X register after sign-extending within 32 bits.
+func (c *arm64Ctx) lowerARM64SignedLaneExtract(op Op, ins Instr) (bool, bool, error) {
+	wide := false
+	switch op {
+	case "SMOV":
+		wide = true
+	case "SMOVW":
+	default:
+		return false, false, nil
+	}
+
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects a vector lane and general register: %q", op, ins.Raw)
+	}
+	source, destination := ins.Args[0].Reg, ins.Args[1].Reg
+	if _, ok := arm64ParseVReg(source); !ok || !isARM64GeneralOrZeroReg(destination) {
+		return true, false, fmt.Errorf("arm64 %s requires a vector lane and general register: %q", op, ins.Raw)
+	}
+	kind, lane, ok := arm64ParseVRegLane(source)
+	if !ok {
+		return true, false, fmt.Errorf("arm64 %s requires a valid vector lane: %q", op, ins.Raw)
+	}
+	bits := 0
+	lanes := 0
+	switch kind {
+	case 'B':
+		bits, lanes = 8, 16
+	case 'H':
+		bits, lanes = 16, 8
+	case 'S':
+		if wide {
+			bits, lanes = 32, 4
+		}
+	}
+	if bits == 0 {
+		return true, false, fmt.Errorf("arm64 %s has an invalid lane width: %q", op, ins.Raw)
+	}
+
+	vector, err := c.loadVReg(source)
+	if err != nil {
+		return true, false, err
+	}
+	lanesValue := vector
+	if bits != 8 {
+		bitcast := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x i%d>\n", bitcast, vector, lanes, bits)
+		lanesValue = "%" + bitcast
+	}
+	extracted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", extracted, lanes, bits, lanesValue, lane)
+
+	value := "%" + extracted
+	if wide {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext i%d %s to i64\n", extended, bits, value)
+		value = "%" + extended
+	} else {
+		signedWord := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext i%d %s to i32\n", signedWord, bits, value)
+		clearedUpper := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", clearedUpper, signedWord)
+		value = "%" + clearedUpper
+	}
+	return true, false, c.storeReg(destination, value)
+}
diff --git a/arm64_lower_structure.go b/arm64_lower_structure.go
new file mode 100644
index 000000000..8e2beedb2
--- /dev/null
+++ b/arm64_lower_structure.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"fmt"
+)
+
+var arm64StructureLoadStoreCounts = map[Op]int{
+	"VLD1":  1,
+	"VLD2":  2,
+	"VLD3":  3,
+	"VLD4":  4,
+	"VLD1R": 1,
+	"VLD2R": 2,
+	"VLD3R": 3,
+	"VLD4R": 4,
+	"VST1":  1,
+	"VST2":  2,
+	"VST3":  3,
+	"VST4":  4,
+}
+
+func (c *arm64Ctx) lowerARM64StructureLoadStore(op Op, postInc bool, ins Instr) (ok bool, terminated bool, err error) {
+	_, dispatched := arm64StructureLoadStoreCounts[op]
+	_, sourceFamily := arm64StructureLoadStoreCounts[arm64ControlOp(ins)]
+	if !dispatched {
+		if sourceFamily {
+			return true, false, fmt.Errorf("arm64 structure opcode dispatch %s disagrees with source %s: %q", op, ins.Op, ins.Raw)
+		}
+		return false, false, nil
+	}
+
+	expected := op
+	if postInc {
+		expected += ".P"
+	}
+	if ins.Op == "" {
+		// Legacy helpers supply the opcode separately. Normalize a local
+		// value copy; the original instruction and operands remain intact.
+		ins.Op = expected
+	} else if ins.Op != expected {
+		return true, false, fmt.Errorf("arm64 structure dispatch %s disagrees with source %s: %q", expected, ins.Op, ins.Raw)
+	}
+
+	form, handled, err := parseARM64StructureMemory(ins)
+	if !handled {
+		return false, false, nil
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if postInc != form.post {
+		return true, false, fmt.Errorf("arm64 %s inconsistent post-index dispatch: %q", op, ins.Raw)
+	}
+	if form.lane >= 0 {
+		return true, false, c.lowerStructureLane(form)
+	}
+	registers, arrangement := form.registers, form.arrangement
+	registerCount := len(registers)
+	addr, increment, err := c.structureAddress(form)
+	if err != nil {
+		return true, false, err
+	}
+	if form.replicate {
+		for registerIndex, reg := range registers {
+			elementOffset := int64(registerIndex * arrangement.elementBits / 8)
+			element, err := c.arm64LoadStructureElement(addr, elementOffset, arrangement.elementBits)
+			if err != nil {
+				return true, false, err
+			}
+			value := c.arm64VDUPSplat(arrangement, element)
+			if err := c.storeARM64VectorInteger(reg, arrangement, value); err != nil {
+				return true, false, err
+			}
+		}
+	} else if op == "VLD1" || op == "VST1" {
+		if err := c.lowerContiguousStructureTransfer(form, addr); err != nil {
+			return true, false, err
+		}
+	} else if form.load {
+		for registerIndex, reg := range registers {
+			value := "poison"
+			for lane := 0; lane < arrangement.lanes; lane++ {
+				elementOffset := arm64StructureElementOffset(form.op, arrangement, registerCount, registerIndex, lane)
+				element, err := c.arm64LoadStructureElement(addr, elementOffset, arrangement.elementBits)
+				if err != nil {
+					return true, false, err
+				}
+				inserted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n",
+					inserted, arrangement.lanes, arrangement.elementBits, value, arrangement.elementBits, element, lane)
+				value = "%" + inserted
+			}
+			if err := c.storeARM64VectorInteger(reg, arrangement, value); err != nil {
+				return true, false, err
+			}
+		}
+	} else {
+		values := make([]string, registerCount)
+		for i, reg := range registers {
+			values[i], err = c.loadARM64VectorInteger(reg, arrangement)
+			if err != nil {
+				return true, false, err
+			}
+		}
+		for lane := 0; lane < arrangement.lanes; lane++ {
+			for registerIndex := range registers {
+				element := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", element, arrangement.lanes, arrangement.elementBits, values[registerIndex], lane)
+				elementOffset := arm64StructureElementOffset(form.op, arrangement, registerCount, registerIndex, lane)
+				if err := c.arm64StoreStructureElement(addr, elementOffset, arrangement.elementBits, "%"+element); err != nil {
+					return true, false, err
+				}
+			}
+		}
+	}
+	if postInc {
+		if err := c.arm64UpdatePostIncrement(form.memory.Mem.Base, increment); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+// LD/ST1 concatenate whole registers, unlike LD/ST2-4's interleaved lanes.
+// Keep each register's exact 8/16-byte access and unaligned address contract.
+func (c *arm64Ctx) lowerContiguousStructureTransfer(form arm64StructureMemoryForm, addr string) error {
+	arrangement := form.arrangement
+	values := make([]string, len(form.registers))
+	if !form.load {
+		for i, reg := range form.registers {
+			value, err := c.loadARM64VectorInteger(reg, arrangement)
+			if err != nil {
+				return err
+			}
+			values[i] = value
+		}
+	}
+	for i, reg := range form.registers {
+		address := addr
+		if i != 0 {
+			added := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", added, addr, i*arrangement.lanes*arrangement.elementBits/8)
+			address = "%" + added
+		}
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+		if form.load {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load <%d x i%d>, ptr %%%s, align 1\n", value, arrangement.lanes, arrangement.elementBits, pointer)
+			if err := c.storeARM64VectorInteger(reg, arrangement, "%"+value); err != nil {
+				return err
+			}
+		} else {
+			fmt.Fprintf(c.b, "  store <%d x i%d> %s, ptr %%%s, align 1\n", arrangement.lanes, arrangement.elementBits, values[i], pointer)
+		}
+	}
+	return nil
+}
+
+func arm64StructureElementOffset(op Op, arrangement arm64VectorArrangement, registerCount, registerIndex, lane int) int64 {
+	elementBytes := arrangement.elementBits / 8
+	if op == "VLD1" || op == "VST1" {
+		return int64(registerIndex*arrangement.lanes*elementBytes + lane*elementBytes)
+	}
+	return int64((lane*registerCount + registerIndex) * elementBytes)
+}
+
+func arm64VectorArrangementName(arrangement arm64VectorArrangement) string {
+	kind := "B"
+	switch arrangement.elementBits {
+	case 16:
+		kind = "H"
+	case 32:
+		kind = "S"
+	case 64:
+		kind = "D"
+	}
+	return fmt.Sprintf("%s%d", kind, arrangement.lanes)
+}
+
+func (c *arm64Ctx) arm64UpdatePostIncrement(base Reg, increment string) error {
+	if increment == "" {
+		return nil
+	}
+	baseValue, err := c.loadReg(base)
+	if err != nil {
+		return err
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", updated, baseValue, increment)
+	return c.storeReg(base, "%"+updated)
+}
+
+func (c *arm64Ctx) arm64LoadStructureElement(addr string, offset int64, bits int) (string, error) {
+	elementAddr := addr
+	if offset != 0 {
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", added, addr, offset)
+		elementAddr = "%" + added
+	}
+	pointer := c.newTmp()
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, elementAddr)
+	fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %%%s, align 1\n", value, bits, pointer)
+	return "%" + value, nil
+}
+
+func (c *arm64Ctx) arm64StoreStructureElement(addr string, offset int64, bits int, value string) error {
+	elementAddr := addr
+	if offset != 0 {
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", added, addr, offset)
+		elementAddr = "%" + added
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, elementAddr)
+	fmt.Fprintf(c.b, "  store i%d %s, ptr %%%s, align 1\n", bits, value, pointer)
+	return nil
+}
diff --git a/arm64_lower_structure_lane_test.go b/arm64_lower_structure_lane_test.go
new file mode 100644
index 000000000..b8701c7c1
--- /dev/null
+++ b/arm64_lower_structure_lane_test.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import "testing"
+
+func TestTranslateARM64StructureStoreLaneForms(t *testing.T) {
+	const source = `TEXT structurestorelanes(SB),$0-0
+	VST1.P V0.B[0], 1(R0)
+	VST1.P V1.H[3], 2(R0)
+	VST1.P V2.S[1], 4(R0)
+	VST1.P V3.D[0], 8(R0)
+	VST1 V4.B[15], (R0)
+	VST1 V5.H[7], (R0)
+	VST1 V6.S[3], (R0)
+	VST1 V7.D[1], (R0)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"structurestorelanes": {Name: "structurestorelanes", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-structure-store-lanes.ll", "arm64-structure-store-lanes.o", ll)
+		})
+	}
+}
diff --git a/arm64_lower_structure_replicate_test.go b/arm64_lower_structure_replicate_test.go
new file mode 100644
index 000000000..56765e72a
--- /dev/null
+++ b/arm64_lower_structure_replicate_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64StructureReplicateLoadCompleteGoAssemblerForms(t *testing.T) {
+	arrangements := []string{"B8", "B16", "H4", "H8", "S2", "S4", "D1", "D2"}
+	var source strings.Builder
+	source.WriteString("TEXT structurereplicateloadforms(SB),$0-0\n")
+	for count := 1; count <= 4; count++ {
+		op := fmt.Sprintf("VLD%dR", count)
+		for _, arrangement := range arrangements {
+			regs := arm64TestVectorList(28, count, arrangement)
+			elementBytes := map[byte]int{'B': 1, 'H': 2, 'S': 4, 'D': 8}[arrangement[0]]
+			fmt.Fprintf(&source, "\t%s (R0), %s\n", op, regs)
+			fmt.Fprintf(&source, "\t%s.P %d(R0), %s\n", op, count*elementBytes, regs)
+			fmt.Fprintf(&source, "\t%s.P (R0)(R1), %s\n", op, regs)
+		}
+		// Go classifies every one-through-four-register list as C_LIST. The
+		// opcode still determines how many registers hardware writes. Only an
+		// explicit nonzero post-index immediate triggers an exact-count check.
+		for writtenCount := 1; writtenCount <= 4; writtenCount++ {
+			regs := arm64TestVectorList(24, writtenCount, "S4")
+			fmt.Fprintf(&source, "\t%s (R0), %s\n", op, regs)
+			fmt.Fprintf(&source, "\t%s.P (R0), %s\n", op, regs)
+			fmt.Fprintf(&source, "\t%s.P (R0)(R1), %s\n", op, regs)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"structurereplicateloadforms": {Name: "structurereplicateloadforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"load i8", "load i16", "load i32", "load i64", "shufflevector"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 VLDnR lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-structure-replicate-load.ll", "arm64-structure-replicate-load.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64StructureReplicateLoadRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VLD2R (R0), [V0.S4, V2.S4]",
+		"VLD2R.P 4(R0), [V0.S4]",
+		"VLD3R (R0), [V0.H8, V1.S4, V2.H8]",
+		"VLD4R.P 8(R0), [V0.S4, V1.S4, V2.S4, V3.S4]",
+		"VLD1R.Z (R0), [V0.B16]",
+		"VLD1R 1(R0), [V0.B16]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badstructurereplicateload(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badstructurereplicateload": {Name: "badstructurereplicateload", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VLDnR optab", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64StructureReplicateLoadRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT structurereplicateload(SB),$0-0
+	VLD4R.P 16(R0), [V0.S4, V1.S4, V2.S4, V3.S4]
+	VST1.P [V0.S4, V1.S4, V2.S4, V3.S4], 64(R1)
+	MOVD R0, 0(R2)
+	MOVD R1, 8(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"structurereplicateload": {
+				Name: "structurereplicateload", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <stddef.h>
+extern void structurereplicateload(const uint32_t *, uint32_t *, uintptr_t *);
+int main(void) {
+  const uint32_t input[4] = {11, 22, 33, 44};
+  uint32_t output[16] = {0};
+  uintptr_t advanced[2] = {0};
+  structurereplicateload(input, output, advanced);
+  for (int group = 0; group < 4; group++)
+    for (int lane = 0; lane < 4; lane++)
+      if (output[group*4+lane] != input[group]) return 1 + group*4 + lane;
+  if (advanced[0] != (uintptr_t)(input+4)) return 30;
+  if (advanced[1] != (uintptr_t)(output+16)) return 31;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_structure_replicate_load", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_structure_test.go b/arm64_lower_structure_test.go
new file mode 100644
index 000000000..e9aba70a7
--- /dev/null
+++ b/arm64_lower_structure_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64StructureLoadStoreCompleteGoAssemblerForms(t *testing.T) {
+	arrangements := []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"}
+	var source strings.Builder
+	source.WriteString("TEXT ·structureloadstoreforms(SB), $0-0\n")
+	for count := 1; count <= 4; count++ {
+		loadOp := fmt.Sprintf("VLD%d", count)
+		storeOp := fmt.Sprintf("VST%d", count)
+		for _, arrangement := range arrangements {
+			regs := arm64TestVectorList(0, count, arrangement)
+			fmt.Fprintf(&source, "\t%s (R0), %s\n", loadOp, regs)
+			fmt.Fprintf(&source, "\t%s %s, (R0)\n", storeOp, regs)
+		}
+		bytes := count * 16
+		regs := arm64TestVectorList(28, count, "D2")
+		fmt.Fprintf(&source, "\t%s.P %d(R0), %s\n", loadOp, bytes, regs)
+		fmt.Fprintf(&source, "\t%s.P %s, %d(R0)\n", storeOp, regs, bytes)
+		regs = arm64TestVectorList(28, count, "B8")
+		fmt.Fprintf(&source, "\t%s.P (R0)(R1), %s\n", loadOp, regs)
+		fmt.Fprintf(&source, "\t%s.P %s, (R0)(R1)\n", storeOp, regs)
+	}
+	for count := 2; count <= 4; count++ {
+		regs := arm64TestVectorList(8, count, "S4")
+		fmt.Fprintf(&source, "\tVLD1 (R0), %s\n", regs)
+		fmt.Fprintf(&source, "\tVST1 %s, (R0)\n", regs)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs:         map[string]FuncSig{"structureloadstoreforms": {Name: "structureloadstoreforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-structure-load-store.ll", "arm64-structure-load-store.o", ll)
+		})
+	}
+}
+
+func TestARM64StructureLoadStoreRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	source := `
+TEXT structureroundtrip(SB), $0-0
+	VLD3.P 48(R0), [V0.S4, V1.S4, V2.S4]
+	VST1.P [V0.S4, V1.S4, V2.S4], 48(R1)
+	VLD1.P 48(R2), [V3.S4, V4.S4, V5.S4]
+	VST3.P [V3.S4, V4.S4, V5.S4], 48(R3)
+	MOVD R0, 0(R4)
+	MOVD R1, 8(R4)
+	MOVD R2, 16(R4)
+	MOVD R3, 24(R4)
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+	}}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"structureroundtrip": {Name: "structureroundtrip", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: frame},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := `
+#include <stdint.h>
+extern void structureroundtrip(const int32_t *, int32_t *, const int32_t *, int32_t *, uintptr_t *);
+int main(void) {
+  const int32_t interleaved[12] = {10,20,30, 11,21,31, 12,22,32, 13,23,33};
+  const int32_t separated[12] = {10,11,12,13, 20,21,22,23, 30,31,32,33};
+  int32_t got_separated[12] = {0}, got_interleaved[12] = {0};
+  uintptr_t advanced[4] = {0};
+  structureroundtrip(interleaved, got_separated, separated, got_interleaved, advanced);
+  for (int i = 0; i < 12; i++) {
+    if (got_separated[i] != separated[i]) return 10+i;
+    if (got_interleaved[i] != interleaved[i]) return 30+i;
+  }
+  if (advanced[0] != (uintptr_t)(interleaved+12)) return 51;
+  if (advanced[1] != (uintptr_t)(got_separated+12)) return 52;
+  if (advanced[2] != (uintptr_t)(separated+12)) return 53;
+  if (advanced[3] != (uintptr_t)(got_interleaved+12)) return 54;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_structure_load_store", triple, ll, mainC, nil)
+}
+
+func TestTranslateARM64StructureLoadStoreRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VLD2 (R0), [V0.S4, V2.S4]",
+		"VST3 [V0.B16, V1.H8, V2.B16], (R0)",
+		"VLD3.P 32(R0), [V0.S4, V1.S4, V2.S4]",
+		"VST4.Z [V0.B16, V1.B16, V2.B16, V3.B16], (R0)",
+	} {
+		source := "TEXT ·bad(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's structure load/store table", instruction)
+		}
+	}
+}
+
+func arm64TestVectorList(start, count int, arrangement string) string {
+	regs := make([]string, count)
+	for i := range regs {
+		regs[i] = fmt.Sprintf("V%d.%s", (start+i)%32, arrangement)
+	}
+	return "[" + strings.Join(regs, ", ") + "]"
+}
diff --git a/arm64_lower_sve_absolute_difference.go b/arm64_lower_sve_absolute_difference.go
new file mode 100644
index 000000000..b4fc34cd3
--- /dev/null
+++ b/arm64_lower_sve_absolute_difference.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEAbsoluteDifferenceKind uint8
+
+const (
+	arm64SVEAbsoluteAccumulate arm64SVEAbsoluteDifferenceKind = iota
+	arm64SVEAbsoluteDifference
+	arm64SVEAbsoluteLongAccumulate
+	arm64SVEAbsoluteLongDifference
+	arm64SVEAbsolutePairAccumulate
+)
+
+type arm64SVEAbsoluteDifferenceSpec struct {
+	intrinsic string
+	kind      arm64SVEAbsoluteDifferenceKind
+}
+
+var arm64SVEAbsoluteDifferenceSpecs = map[Op]arm64SVEAbsoluteDifferenceSpec{
+	"ZSABA":   {intrinsic: "saba", kind: arm64SVEAbsoluteAccumulate},
+	"ZUABA":   {intrinsic: "uaba", kind: arm64SVEAbsoluteAccumulate},
+	"ZSABD":   {intrinsic: "sabd", kind: arm64SVEAbsoluteDifference},
+	"ZUABD":   {intrinsic: "uabd", kind: arm64SVEAbsoluteDifference},
+	"ZSABALB": {intrinsic: "sabalb", kind: arm64SVEAbsoluteLongAccumulate},
+	"ZSABALT": {intrinsic: "sabalt", kind: arm64SVEAbsoluteLongAccumulate},
+	"ZUABALB": {intrinsic: "uabalb", kind: arm64SVEAbsoluteLongAccumulate},
+	"ZUABALT": {intrinsic: "uabalt", kind: arm64SVEAbsoluteLongAccumulate},
+	"ZSABDLB": {intrinsic: "sabdlb", kind: arm64SVEAbsoluteLongDifference},
+	"ZSABDLT": {intrinsic: "sabdlt", kind: arm64SVEAbsoluteLongDifference},
+	"ZUABDLB": {intrinsic: "uabdlb", kind: arm64SVEAbsoluteLongDifference},
+	"ZUABDLT": {intrinsic: "uabdlt", kind: arm64SVEAbsoluteLongDifference},
+	"ZSADALP": {intrinsic: "sadalp", kind: arm64SVEAbsolutePairAccumulate},
+	"ZUADALP": {intrinsic: "uadalp", kind: arm64SVEAbsolutePairAccumulate},
+}
+
+type arm64SVEAbsoluteDifferenceForm struct {
+	elementBits int
+	sourceBits  int
+	first       int
+	second      int
+	predicate   int
+	destination int
+}
+
+func (c *arm64Ctx) lowerARM64SVEAbsoluteDifference(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEAbsoluteDifferenceSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form, err := arm64ParseSVEAbsoluteDifferenceForm(op, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.lowerARM64SVEAbsoluteDifferenceForm(spec, form)
+}
+
+func arm64ParseSVEAbsoluteDifferenceForm(op Op, spec arm64SVEAbsoluteDifferenceSpec, ins Instr) (arm64SVEAbsoluteDifferenceForm, error) {
+	form := arm64SVEAbsoluteDifferenceForm{}
+	switch spec.kind {
+	case arm64SVEAbsoluteDifference:
+		if len(ins.Args) != 4 {
+			return form, fmt.Errorf("arm64 %s expects Zm.T, Zdn.T, Pg/M, Zdn.T: %q", op, ins.Raw)
+		}
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+			return form, fmt.Errorf("arm64 %s requires matching-width destructive data and P0..P7/M: %q", op, ins.Raw)
+		}
+		return arm64SVEAbsoluteDifferenceForm{elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}, nil
+	case arm64SVEAbsolutePairAccumulate:
+		if len(ins.Args) != 3 {
+			return form, fmt.Errorf("arm64 %s expects Zn.Tb, Pg/M, Zda.T: %q", op, ins.Raw)
+		}
+		first, sourceBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !firstOK || !predicateOK || !destinationOK || sourceBits == 64 || destinationBits != 2*sourceBits {
+			return form, fmt.Errorf("arm64 %s requires a B/H/S source, P0..P7/M, and H/S/D accumulator: %q", op, ins.Raw)
+		}
+		return arm64SVEAbsoluteDifferenceForm{elementBits: destinationBits, sourceBits: sourceBits, first: first, predicate: predicate, destination: destination}, nil
+	default:
+		if len(ins.Args) != 3 {
+			return form, fmt.Errorf("arm64 %s expects three scalable vector operands: %q", op, ins.Raw)
+		}
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != firstBits {
+			return form, fmt.Errorf("arm64 %s requires matching source widths: %q", op, ins.Raw)
+		}
+		if spec.kind == arm64SVEAbsoluteAccumulate {
+			if firstBits != destinationBits {
+				return form, fmt.Errorf("arm64 %s requires matching B/H/S/D sources and accumulator: %q", op, ins.Raw)
+			}
+			return arm64SVEAbsoluteDifferenceForm{elementBits: firstBits, first: first, second: second, destination: destination}, nil
+		}
+		if firstBits == 64 || destinationBits != 2*firstBits {
+			return form, fmt.Errorf("arm64 %s requires B/H/S sources widened to H/S/D: %q", op, ins.Raw)
+		}
+		return arm64SVEAbsoluteDifferenceForm{elementBits: destinationBits, sourceBits: firstBits, first: first, second: second, destination: destination}, nil
+	}
+}
+
+func (c *arm64Ctx) lowerARM64SVEAbsoluteDifferenceForm(spec arm64SVEAbsoluteDifferenceSpec, form arm64SVEAbsoluteDifferenceForm) error {
+	if spec.kind == arm64SVEAbsoluteDifference {
+		first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+		if err != nil {
+			return err
+		}
+		second, _, err := c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		lanes := 128 / form.elementBits
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, first, vectorType, second)
+		return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+	}
+	if spec.kind == arm64SVEAbsoluteAccumulate {
+		accumulator, vectorType, err := c.loadZRegElements(form.destination, form.elementBits)
+		if err != nil {
+			return err
+		}
+		first, _, err := c.loadZRegElements(form.first, form.elementBits)
+		if err != nil {
+			return err
+		}
+		second, _, err := c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+		lanes := 128 / form.elementBits
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, form.elementBits, vectorType, accumulator, vectorType, first, vectorType, second)
+		return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+	}
+	sourceType, _, err := arm64SVEVectorType(form.sourceBits)
+	if err != nil {
+		return err
+	}
+	destinationType, destinationLanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	first, _, err := c.loadZRegElements(form.first, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	accumulator := ""
+	if spec.kind == arm64SVEAbsoluteLongAccumulate || spec.kind == arm64SVEAbsolutePairAccumulate {
+		accumulator, _, err = c.loadZRegElements(form.destination, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	result := c.newTmp()
+	switch spec.kind {
+	case arm64SVEAbsoluteLongAccumulate:
+		second, _, err := c.loadZRegElements(form.second, form.sourceBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, form.elementBits, destinationType, accumulator, sourceType, first, sourceType, second)
+	case arm64SVEAbsoluteLongDifference:
+		second, _, err := c.loadZRegElements(form.second, form.sourceBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, form.elementBits, sourceType, first, sourceType, second)
+	case arm64SVEAbsolutePairAccumulate:
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, form.elementBits, predicateType, predicate, destinationType, accumulator, sourceType, first)
+	default:
+		return fmt.Errorf("unknown ARM64 SVE absolute-difference kind %d", spec.kind)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_absolute_difference_test.go b/arm64_lower_sve_absolute_difference_test.go
new file mode 100644
index 000000000..f74247133
--- /dev/null
+++ b/arm64_lower_sve_absolute_difference_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEAbsoluteDifferenceCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveabsdiffforms(SB),$0-0\n")
+	for _, op := range []string{"ZSABA", "ZUABA"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+		}
+	}
+	for _, op := range []string{"ZSABD", "ZUABD"} {
+		for predicate, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z4." + width + ", Z5." + width + ", P" + string(rune('0'+predicate)) + ".M, Z5." + width + "\n")
+		}
+	}
+	for _, op := range []string{"ZSABALB", "ZSABALT", "ZUABALB", "ZUABALT", "ZSABDLB", "ZSABDLT", "ZUABDLB", "ZUABDLT"} {
+		for _, narrowWidth := range []string{"B", "H", "S"} {
+			wideWidth := map[string]string{"B": "H", "H": "S", "S": "D"}[narrowWidth]
+			source.WriteString("\t" + op + " Z6." + narrowWidth + ", Z7." + narrowWidth + ", Z8." + wideWidth + "\n")
+		}
+	}
+	for _, op := range []string{"ZSADALP", "ZUADALP"} {
+		for predicate, narrowWidth := range []string{"B", "H", "S"} {
+			wideWidth := map[string]string{"B": "H", "H": "S", "S": "D"}[narrowWidth]
+			source.WriteString("\t" + op + " Z9." + narrowWidth + ", P" + string(rune('4'+predicate)) + ".M, Z10." + wideWidth + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEAbsoluteDifferenceCompleteGo127Family(t *testing.T) {
+	source := arm64SVEAbsoluteDifferenceCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveabsdiffforms": {Name: "sveabsdiffforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.saba.nxv16i8",
+				"@llvm.aarch64.sve.uaba.nxv2i64",
+				"@llvm.aarch64.sve.sabd.nxv8i16",
+				"@llvm.aarch64.sve.uabd.nxv4i32",
+				"@llvm.aarch64.sve.sabalb.nxv8i16",
+				"@llvm.aarch64.sve.uabalt.nxv2i64",
+				"@llvm.aarch64.sve.sabdlt.nxv4i32",
+				"@llvm.aarch64.sve.uabdlb.nxv8i16",
+				"@llvm.aarch64.sve.sadalp.nxv8i16",
+				"@llvm.aarch64.sve.uadalp.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE absolute-difference lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-absolute-difference.ll", "arm64-sve-absolute-difference.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEAbsoluteDifferenceRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSABA Z1.B, Z2.H, Z3.B",
+		"ZUABA Z1.S, Z2.S, Z3.D",
+		"ZSABD Z1.B, Z2.B, P0, Z2.B",
+		"ZUABD Z1.H, Z2.H, P8.M, Z2.H",
+		"ZSABD Z1.S, Z2.S, P0.M, Z3.S",
+		"ZSABALB Z1.B, Z2.H, Z3.H",
+		"ZUABALT Z1.S, Z2.S, Z3.S",
+		"ZSABDLB Z1.D, Z2.D, Z3.D",
+		"ZUABDLT Z1.H, Z2.H, Z3.H",
+		"ZSADALP Z1.B, P0, Z2.H",
+		"ZUADALP Z1.H, P0.M, Z2.H",
+		"ZSABA.Z Z1.B, Z2.B, Z3.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveabsdiff(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveabsdiff": {Name: "badsveabsdiff", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE absolute-difference forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_add.go b/arm64_lower_sve_add.go
new file mode 100644
index 000000000..e668de811
--- /dev/null
+++ b/arm64_lower_sve_add.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64SVEAddMode uint8
+
+const (
+	arm64SVEAddUnpredicated arm64SVEAddMode = iota
+	arm64SVEAddPredicated
+	arm64SVEAddImmediate
+)
+
+type arm64RawSVEAdd struct {
+	mode        arm64SVEAddMode
+	elementBits int
+	first       int
+	second      int
+	predicate   int
+	immediate   int
+	destination int
+}
+
+func decodeARM64RawSVEAdd(word uint32) (arm64RawSVEAdd, bool) {
+	form := arm64RawSVEAdd{elementBits: 8 << (int(word>>22) & 3)}
+	switch {
+	case word&0xff3fe000 == 0x04000000:
+		form.mode = arm64SVEAddPredicated
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xff20fc00 == 0x04200000:
+		form.mode = arm64SVEAddUnpredicated
+		form.destination = int(word) & 31
+		form.first = int(word>>5) & 31
+		form.second = int(word>>16) & 31
+	case word&0xff3fc000 == 0x2520c000:
+		form.mode = arm64SVEAddImmediate
+		form.destination = int(word) & 31
+		form.first = form.destination
+		shift := 0
+		if word&(1<<13) != 0 {
+			shift = 8
+		}
+		if form.elementBits == 8 && shift != 0 {
+			return arm64RawSVEAdd{}, false
+		}
+		form.immediate = (int(word>>5) & 255) << shift
+	default:
+		return arm64RawSVEAdd{}, false
+	}
+	return form, true
+}
+
+func arm64ParseSVEPredicateMerge(operand Operand) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || parts[1] != "M" || !strings.HasPrefix(parts[0], "P") {
+		return 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(parts[0], "P"))
+	return index, err == nil && index >= 0 && index < 8
+}
+
+func arm64SVEAddImmediateRepresentable(elementBits int, immediate int64) bool {
+	if immediate >= 0 && immediate <= 255 {
+		return true
+	}
+	if elementBits == 8 || immediate%256 != 0 {
+		return false
+	}
+	unshifted := immediate / 256
+	return unshifted >= 0 && unshifted <= 255
+}
+
+func (c *arm64Ctx) lowerARM64SVEAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZADD" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 ZADD does not accept an instruction suffix: %q", ins.Raw)
+	}
+
+	form := arm64RawSVEAdd{}
+	if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm {
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if ins.Args[0].ImmRaw != "" || !firstOK || !destinationOK || first != destination || firstBits != destinationBits || !arm64SVEAddImmediateRepresentable(firstBits, ins.Args[0].Imm) {
+			return true, false, fmt.Errorf("arm64 ZADD immediate expects $imm, Zdn.T, Zdn.T with identical destructive registers: %q", ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddImmediate, elementBits: firstBits, first: first, destination: destination, immediate: int(ins.Args[0].Imm)}
+	} else if len(ins.Args) == 3 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZADD vector expects Zm.T, Zn.T, Zd.T with one element width: %q", ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddUnpredicated, elementBits: firstBits, first: first, second: second, destination: destination}
+	} else if len(ins.Args) == 4 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+			return true, false, fmt.Errorf("arm64 ZADD predicated expects Zm.T, Zdn.T, Pg.M, Zdn.T with identical destructive registers: %q", ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddPredicated, elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}
+	} else {
+		return true, false, fmt.Errorf("arm64 ZADD expects a Go 1.27 SVE vector, predicated, or immediate form: %q", ins.Raw)
+	}
+	return true, false, c.lowerRawSVEAdd(form)
+}
+
+func (c *arm64Ctx) lowerRawSVEAdd(form arm64RawSVEAdd) error {
+	first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	second := fmt.Sprintf("splat (i%d %d)", form.elementBits, form.immediate)
+	if form.mode != arm64SVEAddImmediate {
+		second, _, err = c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	added := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", added, vectorType, first, second)
+	result := "%" + added
+	if form.mode == arm64SVEAddPredicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, result, vectorType, first)
+		result = "%" + selected
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, result)
+}
diff --git a/arm64_lower_sve_add_reduction.go b/arm64_lower_sve_add_reduction.go
new file mode 100644
index 000000000..5387589aa
--- /dev/null
+++ b/arm64_lower_sve_add_reduction.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEAddReductionKind uint8
+
+const (
+	arm64SVEFloatAddAccumulate arm64SVEAddReductionKind = iota
+	arm64SVEFloatAddReduce
+	arm64SVEFloatAddQuadReduce
+	arm64SVESignedAddReduce
+	arm64SVEUnsignedAddReduce
+)
+
+type arm64SVEAddReductionSpec struct {
+	kind        arm64SVEAddReductionKind
+	elementBits int
+}
+
+var arm64SVEAddReductionSpecs = map[Op]arm64SVEAddReductionSpec{
+	"ZFADDAD": {kind: arm64SVEFloatAddAccumulate, elementBits: 64},
+	"ZFADDAH": {kind: arm64SVEFloatAddAccumulate, elementBits: 16},
+	"ZFADDAS": {kind: arm64SVEFloatAddAccumulate, elementBits: 32},
+	"ZFADDQV": {kind: arm64SVEFloatAddQuadReduce},
+	"ZFADDVD": {kind: arm64SVEFloatAddReduce, elementBits: 64},
+	"ZFADDVH": {kind: arm64SVEFloatAddReduce, elementBits: 16},
+	"ZFADDVS": {kind: arm64SVEFloatAddReduce, elementBits: 32},
+	"ZSADDVD": {kind: arm64SVESignedAddReduce},
+	"ZUADDVD": {kind: arm64SVEUnsignedAddReduce},
+}
+
+type arm64SVEAddReductionForm struct {
+	elementBits int
+	source      int
+	predicate   int
+	destination int
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddReduction(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEAddReductionSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form, err := arm64ParseSVEAddReductionForm(op, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.lowerARM64SVEAddReductionForm(spec, form, ins.Args[len(ins.Args)-1].Reg)
+}
+
+func arm64ParseSVEAddReductionForm(op Op, spec arm64SVEAddReductionSpec, ins Instr) (arm64SVEAddReductionForm, error) {
+	form := arm64SVEAddReductionForm{}
+	if spec.kind == arm64SVEFloatAddAccumulate {
+		if len(ins.Args) != 4 || ins.Args[1].Kind != OpReg || ins.Args[3].Kind != OpReg {
+			return form, fmt.Errorf("arm64 %s expects Zm.T, Vdn, Pg, Vdn: %q", op, ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+		initial, initialOK := arm64ParseVReg(ins.Args[1].Reg)
+		predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[2])
+		destination, destinationOK := arm64ParseVReg(ins.Args[3].Reg)
+		if !sourceOK || !initialOK || !predicateOK || predicate > 7 || !destinationOK || initial != destination || strings.Contains(string(ins.Args[1].Reg), ".") || strings.Contains(string(ins.Args[3].Reg), ".") {
+			return form, fmt.Errorf("arm64 %s requires an H/S/D source, bare P0..P7, and one destructive bare V register: %q", op, ins.Raw)
+		}
+		return arm64SVEAddReductionForm{elementBits: arm64SVEFloatReductionElementBits(spec.elementBits, sourceBits), source: source, predicate: predicate, destination: destination}, nil
+	}
+	if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
+		return form, fmt.Errorf("arm64 %s expects Zn.T, Pg, Vd: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[1])
+	destination, destinationOK := arm64ParseVReg(ins.Args[2].Reg)
+	if !predicateOK || predicate > 7 || !destinationOK {
+		return form, fmt.Errorf("arm64 %s requires a bare P0..P7 and SIMD destination: %q", op, ins.Raw)
+	}
+	switch spec.kind {
+	case arm64SVEFloatAddReduce, arm64SVEFloatAddQuadReduce:
+		source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+		if !sourceOK {
+			return form, fmt.Errorf("arm64 %s source must use H, S, or D elements: %q", op, ins.Raw)
+		}
+		if spec.kind == arm64SVEFloatAddReduce {
+			if strings.Contains(string(ins.Args[2].Reg), ".") {
+				return form, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+			}
+			sourceBits = arm64SVEFloatReductionElementBits(spec.elementBits, sourceBits)
+		} else {
+			arrangement, arrangementOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+			if !arrangementOK || arrangement.elementBits != sourceBits || arrangement.lanes*arrangement.elementBits != 128 {
+				return form, fmt.Errorf("arm64 %s destination must be a full-width SIMD vector matching its source elements: %q", op, ins.Raw)
+			}
+		}
+		return arm64SVEAddReductionForm{elementBits: sourceBits, source: source, predicate: predicate, destination: destination}, nil
+	case arm64SVESignedAddReduce, arm64SVEUnsignedAddReduce:
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+		if !sourceOK || (spec.kind == arm64SVESignedAddReduce && sourceBits == 64) || strings.Contains(string(ins.Args[2].Reg), ".") {
+			return form, fmt.Errorf("arm64 %s source/destination widths are outside its Go 1.27 form: %q", op, ins.Raw)
+		}
+		return arm64SVEAddReductionForm{elementBits: sourceBits, source: source, predicate: predicate, destination: destination}, nil
+	default:
+		return form, fmt.Errorf("arm64 %s has an unknown SVE add reduction form", op)
+	}
+}
+
+func arm64SVEFloatReductionElementBits(opcodeBits, sourceBits int) int {
+	opcodeSize := map[int]int{16: 1, 32: 2, 64: 3}[opcodeBits]
+	sourceSize := map[int]int{16: 1, 32: 2, 64: 3}[sourceBits]
+	return 8 << (opcodeSize | sourceSize)
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddReductionForm(spec arm64SVEAddReductionSpec, form arm64SVEAddReductionForm, destination Reg) error {
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	if spec.kind == arm64SVESignedAddReduce || spec.kind == arm64SVEUnsignedAddReduce {
+		source, vectorType, err := c.loadZRegElements(form.source, form.elementBits)
+		if err != nil {
+			return err
+		}
+		lanes := 128 / form.elementBits
+		intrinsic := map[arm64SVEAddReductionKind]string{arm64SVESignedAddReduce: "saddv", arm64SVEUnsignedAddReduce: "uaddv"}[spec.kind]
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, source)
+		return c.storeARM64ScalarToVReg(destination, 64, "%"+result)
+	}
+	source, vectorType, err := c.loadRawSVEFloatVector(form.source, form.elementBits)
+	if err != nil {
+		return err
+	}
+	scalarType, _, lanes, err := arm64SVEFloatType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	mangle := fmt.Sprintf("nxv%d%s", lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits])
+	result := c.newTmp()
+	switch spec.kind {
+	case arm64SVEFloatAddAccumulate:
+		initialBytes, err := c.loadVReg(destination)
+		if err != nil {
+			return err
+		}
+		initialVector := c.newTmp()
+		initial := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", initialVector, initialBytes, lanes, scalarType)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %%%s, i32 0\n", initial, lanes, scalarType, initialVector)
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fadda.%s(%s %s, %s %%%s, %s %s)\n", result, scalarType, mangle, predicateType, predicate, scalarType, initial, vectorType, source)
+		return c.storeARM64SVEFloatScalarToVReg(destination, form.elementBits, "%"+result)
+	case arm64SVEFloatAddReduce:
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.faddv.%s(%s %s, %s %s)\n", result, scalarType, mangle, predicateType, predicate, vectorType, source)
+		return c.storeARM64SVEFloatScalarToVReg(destination, form.elementBits, "%"+result)
+	case arm64SVEFloatAddQuadReduce:
+		fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.aarch64.sve.faddqv.v%d%s.%s(%s %s, %s %s)\n", result, lanes, scalarType, lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits], mangle, predicateType, predicate, vectorType, source)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <16 x i8>\n", bytes, lanes, scalarType, result)
+		return c.storeVReg(destination, "%"+bytes)
+	default:
+		return fmt.Errorf("unknown ARM64 SVE add reduction kind %d", spec.kind)
+	}
+}
+
+func (c *arm64Ctx) storeARM64SVEFloatScalarToVReg(destination Reg, elementBits int, value string) error {
+	scalarType, _, lanes, err := arm64SVEFloatType(elementBits)
+	if err != nil {
+		return err
+	}
+	fixed := c.newTmp()
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> zeroinitializer, %s %s, i32 0\n", fixed, lanes, scalarType, scalarType, value)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <16 x i8>\n", bytes, lanes, scalarType, fixed)
+	return c.storeVReg(destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_add_reduction_test.go b/arm64_lower_sve_add_reduction_test.go
new file mode 100644
index 000000000..a2942faa5
--- /dev/null
+++ b/arm64_lower_sve_add_reduction_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEAddReductionCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveaddreduceforms(SB),$0-0\n")
+	for _, opcodeWidth := range []string{"H", "S", "D"} {
+		for predicate, sourceWidth := range []string{"H", "S", "D"} {
+			// The generated FADDA/FADDV encoders use a generic H/S/D source.
+			// As with the integer reductions, Go ORs its size bits into the
+			// mnemonic's fixed bits, so every 3x3 combination is legal.
+			source.WriteString("\tZFADDA" + opcodeWidth + " Z1." + sourceWidth + ", V2, P" + string(rune('0'+predicate)) + ", V2\n")
+			source.WriteString("\tZFADDV" + opcodeWidth + " Z3." + sourceWidth + ", P" + string(rune('3'+predicate)) + ", V4\n")
+		}
+	}
+	for predicate, width := range []string{"H", "S", "D"} {
+		arrangement := map[string]string{"H": "H8", "S": "S4", "D": "D2"}[width]
+		source.WriteString("\tZFADDQV Z5." + width + ", P" + string(rune('0'+predicate)) + ", V6." + arrangement + "\n")
+	}
+	for predicate, width := range []string{"B", "H", "S"} {
+		source.WriteString("\tZSADDVD Z7." + width + ", P" + string(rune('4'+predicate)) + ", V8\n")
+	}
+	for predicate, width := range []string{"B", "H", "S", "D"} {
+		source.WriteString("\tZUADDVD Z9." + width + ", P" + string(rune('0'+predicate)) + ", V10\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEAddReductionCompleteGo127Family(t *testing.T) {
+	source := arm64SVEAddReductionCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveaddreduceforms": {Name: "sveaddreduceforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.fadda.nxv8f16",
+				"@llvm.aarch64.sve.fadda.nxv4f32",
+				"@llvm.aarch64.sve.fadda.nxv2f64",
+				"@llvm.aarch64.sve.faddv.nxv8f16",
+				"@llvm.aarch64.sve.faddqv.v4f32.nxv4f32",
+				"@llvm.aarch64.sve.saddv.nxv16i8",
+				"@llvm.aarch64.sve.uaddv.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE add reduction lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-add-reduction.ll", "arm64-sve-add-reduction.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEAddReductionRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFADDAH Z1.H, V2, P0, V3",
+		"ZFADDAS Z1.B, V2, P0, V2",
+		"ZFADDAD Z1.D, V2, P0.M, V2",
+		"ZFADDVH Z1.B, P0, V2",
+		"ZFADDVS Z1.S, P0.M, V2",
+		"ZFADDVD Z1.D, P0, V2.D2",
+		"ZFADDQV Z1.S, P0, V2.H8",
+		"ZFADDQV Z1.D, P0, V2",
+		"ZSADDVD Z1.D, P0, V2",
+		"ZSADDVD Z1.S, P0.M, V2",
+		"ZUADDVD Z1.Q, P0, V2",
+		"ZUADDVD.Z Z1.D, P0, V2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveaddreduce(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveaddreduce": {Name: "badsveaddreduce", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE add reduction forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_add_sub.go b/arm64_lower_sve_add_sub.go
new file mode 100644
index 000000000..f0b4902a0
--- /dev/null
+++ b/arm64_lower_sve_add_sub.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEAddSubSpec struct {
+	intrinsic    string
+	reverse      bool
+	unpredicated uint32
+	predicated   uint32
+	immediate    uint32
+}
+
+var arm64SVEAddSubSpecs = map[Op]arm64SVEAddSubSpec{
+	"ZSUB":    {unpredicated: 0x04200400, predicated: 0x04010000, immediate: 0x2521c000},
+	"ZSUBR":   {reverse: true, predicated: 0x04030000, immediate: 0x2523c000},
+	"ZSQADD":  {intrinsic: "aarch64.sve.sqadd.x", unpredicated: 0x04201000, predicated: 0x44188000, immediate: 0x2524c000},
+	"ZSQSUB":  {intrinsic: "aarch64.sve.sqsub.x", unpredicated: 0x04201800, predicated: 0x441a8000, immediate: 0x2526c000},
+	"ZSQSUBR": {intrinsic: "aarch64.sve.sqsub.x", reverse: true, predicated: 0x441e8000},
+	"ZUQADD":  {intrinsic: "aarch64.sve.uqadd.x", unpredicated: 0x04201400, predicated: 0x44198000, immediate: 0x2525c000},
+	"ZUQSUB":  {intrinsic: "aarch64.sve.uqsub.x", unpredicated: 0x04201c00, predicated: 0x441b8000, immediate: 0x2527c000},
+	"ZUQSUBR": {intrinsic: "aarch64.sve.uqsub.x", reverse: true, predicated: 0x441f8000},
+}
+
+// Go's complete SUB and saturating ADD/SUB families share ADD's three field
+// layouts. Zero encoding values denote absent forms, both here and in the
+// named validator. Normalization retains ADD's reserved-immediate checks.
+func decodeARM64RawSVEAddSub(word uint32) (Op, arm64RawSVEAdd, bool) {
+	for op, spec := range arm64SVEAddSubSpecs {
+		for _, row := range [...]struct{ bits, mask, add uint32 }{
+			{spec.unpredicated, 0xff20fc00, 0x04200000},
+			{spec.predicated, 0xff3fe000, 0x04000000},
+			{spec.immediate, 0xff3fc000, 0x2520c000},
+		} {
+			if row.bits != 0 && word&row.mask == row.bits {
+				form, ok := decodeARM64RawSVEAdd(word ^ row.bits ^ row.add)
+				return op, form, ok
+			}
+		}
+	}
+	return "", arm64RawSVEAdd{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEAddSubSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+
+	form := arm64RawSVEAdd{}
+	switch {
+	case len(ins.Args) == 3 && ins.Args[0].Kind == OpImm:
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if spec.immediate == 0 || ins.Args[0].ImmRaw != "" || !firstOK || !destinationOK || first != destination || firstBits != destinationBits || !arm64SVEAddImmediateRepresentable(firstBits, ins.Args[0].Imm) {
+			return true, false, fmt.Errorf("arm64 %s does not accept this immediate form: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddImmediate, elementBits: firstBits, first: first, destination: destination, immediate: int(ins.Args[0].Imm)}
+	case len(ins.Args) == 3:
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if spec.unpredicated == 0 || !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s does not accept this unpredicated vector form: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddUnpredicated, elementBits: firstBits, first: first, second: second, destination: destination}
+	case len(ins.Args) == 4:
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if spec.predicated == 0 || !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+			return true, false, fmt.Errorf("arm64 %s does not accept this predicated destructive form: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEAdd{mode: arm64SVEAddPredicated, elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}
+	default:
+		return true, false, fmt.Errorf("arm64 %s expects one of its Go 1.27 SVE forms: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerRawSVEAddSub(spec, form)
+}
+
+func (c *arm64Ctx) lowerRawSVEAddSub(spec arm64SVEAddSubSpec, form arm64RawSVEAdd) error {
+	first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	// Unlike the vector form, SQADD/SQSUB's immediate is unsigned. A byte or
+	// halfword immediate with its sign bit set cannot use the signed binary
+	// intrinsic: widen first, then clamp before truncation. This path is never
+	// needed for S/D, whose encodable immediates fit their signed range.
+	if form.mode == arm64SVEAddImmediate && uint64(form.immediate) >= uint64(1)<<(form.elementBits-1) &&
+		(spec.intrinsic == "aarch64.sve.sqadd.x" || spec.intrinsic == "aarch64.sve.sqsub.x") {
+		return c.lowerSVESignedSaturationImmediate(spec, form, first, vectorType)
+	}
+	second := fmt.Sprintf("splat (i%d %d)", form.elementBits, form.immediate)
+	if form.mode != arm64SVEAddImmediate {
+		second, _, err = c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	left, right := first, second
+	if spec.reverse {
+		left, right = right, left
+	}
+	calculated := c.newTmp()
+	if spec.intrinsic == "" {
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", calculated, vectorType, left, right)
+	} else {
+		lanes := 128 / form.elementBits
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.nxv%di%d(%s %s, %s %s)\n", calculated, vectorType, spec.intrinsic, lanes, form.elementBits, vectorType, left, vectorType, right)
+	}
+	result := "%" + calculated
+	if form.mode == arm64SVEAddPredicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, result, vectorType, first)
+		result = "%" + selected
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, result)
+}
+
+func (c *arm64Ctx) lowerSVESignedSaturationImmediate(spec arm64SVEAddSubSpec, form arm64RawSVEAdd, first, vectorType string) error {
+	lanes, wideBits := 128/form.elementBits, form.elementBits*2
+	wideType := fmt.Sprintf("<vscale x %d x i%d>", lanes, wideBits)
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	op, comparison := "add", "sgt"
+	bound := int64(1)<<(form.elementBits-1) - 1
+	if spec.intrinsic == "aarch64.sve.sqsub.x" {
+		op, comparison = "sub", "slt"
+		bound = -(int64(1) << (form.elementBits - 1))
+	}
+	widened, calculated, outside, clamped, result := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", widened, vectorType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, splat (i%d %d)\n", calculated, op, wideType, widened, wideBits, form.immediate)
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %%%s, splat (i%d %d)\n", outside, comparison, wideType, calculated, wideBits, bound)
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s splat (i%d %d), %s %%%s\n", clamped, predicateType, outside, wideType, wideBits, bound, wideType, calculated)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", result, wideType, clamped, vectorType)
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_add_sub_test.go b/arm64_lower_sve_add_sub_test.go
new file mode 100644
index 000000000..5872fd97c
--- /dev/null
+++ b/arm64_lower_sve_add_sub_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64SVEAddSubFormSpec struct {
+	op           string
+	unpredicated bool
+	predicated   bool
+	immediate    bool
+}
+
+var arm64SVEAddSubCompleteFamily = []arm64SVEAddSubFormSpec{
+	{op: "ZSUB", unpredicated: true, predicated: true, immediate: true},
+	{op: "ZSUBR", predicated: true, immediate: true},
+	{op: "ZSQADD", unpredicated: true, predicated: true, immediate: true},
+	{op: "ZSQSUB", unpredicated: true, predicated: true, immediate: true},
+	{op: "ZSQSUBR", predicated: true},
+	{op: "ZUQADD", unpredicated: true, predicated: true, immediate: true},
+	{op: "ZUQSUB", unpredicated: true, predicated: true, immediate: true},
+	{op: "ZUQSUBR", predicated: true},
+}
+
+func arm64SVEAddSubForms(function string, specs []arm64SVEAddSubFormSpec) string {
+	var source strings.Builder
+	source.WriteString("TEXT " + function + "(SB),$0-0\n")
+	for _, spec := range specs {
+		for widthIndex, width := range []string{"B", "H", "S", "D"} {
+			if spec.unpredicated {
+				source.WriteString("\t" + spec.op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+			}
+			if spec.predicated {
+				source.WriteString("\t" + spec.op + " Z4." + width + ", Z5." + width + ", P" + string(rune('0'+widthIndex)) + ".M, Z5." + width + "\n")
+			}
+			if spec.immediate {
+				immediate := "255"
+				if width != "B" {
+					immediate = "65280"
+				}
+				source.WriteString("\t" + spec.op + " $" + immediate + ", Z6." + width + ", Z6." + width + "\n")
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEAddSubCompleteGo127Family(t *testing.T) {
+	for _, spec := range arm64SVEAddSubCompleteFamily {
+		spec := spec
+		t.Run(spec.op, func(t *testing.T) {
+			function := "sve" + strings.ToLower(spec.op)
+			source := arm64SVEAddSubForms(function, []arm64SVEAddSubFormSpec{spec})
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs:         map[string]FuncSig{function: {Name: function, Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					wants := []string{}
+					if spec.op == "ZSUB" || spec.op == "ZSUBR" {
+						wants = append(wants, " sub <vscale x ")
+					} else {
+						wants = append(wants, "@llvm."+arm64SVEAddSubSpecs[Op(spec.op)].intrinsic+".nxv")
+					}
+					if spec.predicated {
+						wants = append(wants, " select <vscale x ")
+					}
+					for _, want := range wants {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("%s SVE add/sub family omitted %q:\n%s", triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-add-sub.ll", "arm64-sve-add-sub.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64RawSVESubtractCompleteFamily(t *testing.T) {
+	// Go 1.27 has unpredicated, predicated, and immediate SUB, and the
+	// predicated and immediate reverse-SUB forms. lightning emits 0x04230404.
+	var source strings.Builder
+	source.WriteString("TEXT rawSVESubtract(SB),$0-0\n")
+	for size := uint32(0); size < 4; size++ {
+		words := []uint32{
+			0x04200400 | size<<22 | 3<<16 | 0<<5 | 4,
+			0x04010000 | size<<22 | 3<<5 | 1<<10 | 4,
+			0x2521c000 | size<<22 | 32<<5 | 4,
+			0x04030000 | size<<22 | 3<<5 | 1<<10 | 4,
+			0x2523c000 | size<<22 | 32<<5 | 4,
+		}
+		for _, word := range words {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVESubtract": {Name: "rawSVESubtract", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				" sub <vscale x ",
+				" select <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw SVE subtract IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-subtract.ll", "arm64-raw-sve-subtract.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVESubtractBoundaries(t *testing.T) {
+	op, form, ok := decodeARM64RawSVEAddSub(0x04230404)
+	if !ok || op != "ZSUB" || form.mode != arm64SVEAddUnpredicated ||
+		form.elementBits != 8 || form.first != 0 || form.second != 3 || form.destination != 4 {
+		t.Fatalf("decode lightning SUB = %s %+v, %v", op, form, ok)
+	}
+	for _, word := range []uint32{
+		0x2521c000 | 1<<13, // shifted B immediate is reserved
+		0x04200c00,         // adjacent unpredicated opcode
+		0x04020000,         // adjacent predicated opcode
+	} {
+		if op, form, ok := decodeARM64RawSVEAddSub(word); ok {
+			t.Errorf("decoded reserved SUB %#08x as %s %+v", word, op, form)
+		}
+	}
+}
+
+func TestTranslateARM64SVEAddSubRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSUBR Z1.S, Z2.S, Z3.S",
+		"ZSQSUBR $1, Z2.H, Z2.H",
+		"ZUQSUBR Z1.D, Z2.D, Z3.D",
+		"ZSUB Z1.S, Z2.S, P0.M, Z3.S",
+		"ZSQADD Z1.B, Z2.H, Z3.B",
+		"ZUQSUB Z1.S, Z2.S, P0.Z, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveaddsub(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"badsveaddsub": {Name: "badsveaddsub", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE add/sub family", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_add_test.go b/arm64_lower_sve_add_test.go
new file mode 100644
index 000000000..f710d2bdc
--- /dev/null
+++ b/arm64_lower_sve_add_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEAddUnpredicated(elementBits, second, first, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04200000 | size<<22 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEAddPredicated(elementBits, second, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04000000 | size<<22 | uint32(second)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVEAddImmediate(elementBits, immediate, shift, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x2520c000 | size<<22 | uint32(immediate)<<5 | uint32(shift/8)<<13 | uint32(destination)
+}
+
+func TestTranslateARM64SVEAddCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT sveaddnamed(SB),$0-0
+	ZADD Z31.B, Z0.B, Z1.B
+	ZADD Z30.H, Z2.H, Z3.H
+	ZADD Z29.S, Z4.S, Z5.S
+	ZADD Z28.D, Z6.D, Z7.D
+	ZADD Z27.B, Z8.B, P0.M, Z8.B
+	ZADD Z26.H, Z9.H, P1.M, Z9.H
+	ZADD Z25.S, Z10.S, P2.M, Z10.S
+	ZADD Z24.D, Z11.D, P7.M, Z11.D
+	ZADD $255, Z12.B, Z12.B
+	ZADD $65280, Z13.H, Z13.H
+	ZADD $65280, Z14.S, Z14.S
+	ZADD $65280, Z15.D, Z15.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT sveaddraw(SB),$0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEAddUnpredicated(elementBits, 2, 3, 4))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEAddPredicated(elementBits, 5, 6, 7))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEAddImmediate(elementBits, 255, 0, 8))
+		if elementBits != 8 {
+			fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEAddImmediate(elementBits, 255, 8, 9))
+		}
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sveadd" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs:         map[string]FuncSig{function: {Name: function, Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve"`, " add <vscale x ", " select <vscale x ", "@llvm.aarch64.sve.convert.from.svbool"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE ADD lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-add.ll", "arm64-sve-add.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEAddDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for second := 0; second < 32; second++ {
+			for first := 0; first < 32; first++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEAddUnpredicated(elementBits, second, first, destination)
+					got, ok := decodeARM64RawSVEAdd(word)
+					if !ok || got.mode != arm64SVEAddUnpredicated || got.elementBits != elementBits || got.second != second || got.first != first || got.destination != destination {
+						t.Fatalf("decoded unpredicated SVE ADD %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for second := 0; second < 32; second++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEAddPredicated(elementBits, second, predicate, destination)
+					got, ok := decodeARM64RawSVEAdd(word)
+					if !ok || got.mode != arm64SVEAddPredicated || got.elementBits != elementBits || got.second != second || got.predicate != predicate || got.first != destination || got.destination != destination {
+						t.Fatalf("decoded predicated SVE ADD %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for _, shift := range []int{0, 8} {
+			if elementBits == 8 && shift == 8 {
+				continue
+			}
+			for immediate := 0; immediate <= 255; immediate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEAddImmediate(elementBits, immediate, shift, destination)
+					got, ok := decodeARM64RawSVEAdd(word)
+					if !ok || got.mode != arm64SVEAddImmediate || got.elementBits != elementBits || got.immediate != immediate<<shift || got.first != destination || got.destination != destination {
+						t.Fatalf("decoded immediate SVE ADD %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVEAddRejectsReservedAdjacentAndNonDestructivePredicatedForms(t *testing.T) {
+	if _, ok := decodeARM64RawSVEAdd(encodeARM64RawSVEAddImmediate(8, 1, 8, 0)); ok {
+		t.Fatal("SVE ADD decoder accepted reserved shifted byte immediate")
+	}
+	for _, word := range []uint32{0x04010000, 0x04200400, 0x2521c000} {
+		if _, ok := decodeARM64RawSVEAdd(word); ok {
+			t.Fatalf("SVE ADD decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsveadd(SB),$0-0
+	ZADD Z1.S, Z2.S, P0.M, Z3.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveadd": {Name: "badsveadd", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted a predicated SVE ADD whose destructive operands differ")
+	}
+}
diff --git a/arm64_lower_sve_address.go b/arm64_lower_sve_address.go
new file mode 100644
index 000000000..9badee776
--- /dev/null
+++ b/arm64_lower_sve_address.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64RawSVEAddress struct {
+	op          Op
+	immediate   int
+	source      int
+	destination int
+}
+
+func decodeARM64RawSVEAddress(word uint32) (arm64RawSVEAddress, bool) {
+	form := arm64RawSVEAddress{}
+	switch {
+	case word&0xffe0f800 == 0x04205000:
+		form.op = "ADDVL"
+	case word&0xffe0f800 == 0x04605000:
+		form.op = "ADDPL"
+	case word&0xfffff800 == 0x04bf5000:
+		form.op = "RDVL"
+	default:
+		return arm64RawSVEAddress{}, false
+	}
+	immediate := int(word>>5) & 63
+	if immediate&32 != 0 {
+		immediate -= 64
+	}
+	form.immediate = immediate
+	form.source = int(word>>16) & 31
+	form.destination = int(word) & 31
+	if form.op == "RDVL" && form.destination == 31 {
+		return arm64RawSVEAddress{}, false
+	}
+	return form, true
+}
+
+func arm64SVEAddressReg(operand Operand, allowSP bool) (Reg, bool) {
+	if operand.Kind != OpReg {
+		return "", false
+	}
+	s := strings.ToUpper(string(operand.Reg))
+	if operand.Reg == SP || s == "RSP" {
+		return SP, allowSP
+	}
+	if !strings.HasPrefix(s, "R") {
+		return "", false
+	}
+	index, err := strconv.Atoi(s[1:])
+	if err != nil || index < 0 || index > 30 {
+		return "", false
+	}
+	return Reg(fmt.Sprintf("R%d", index)), true
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddress(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ADDVL" && op != "ADDPL" && op != "RDVL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) < 2 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].Imm < -32 || ins.Args[0].Imm > 31 {
+		return true, false, fmt.Errorf("arm64 %s expects a signed 6-bit immediate and no suffix: %q", op, ins.Raw)
+	}
+	immediate := ins.Args[0].Imm
+	var source, destination Reg
+	if op == "RDVL" {
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("arm64 RDVL expects $imm, Rdst: %q", ins.Raw)
+		}
+		var valid bool
+		destination, valid = arm64SVEAddressReg(ins.Args[1], false)
+		if !valid {
+			return true, false, fmt.Errorf("arm64 RDVL destination must be R0..R30: %q", ins.Raw)
+		}
+	} else {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s expects $imm, Rsrc|RSP, Rdst|RSP: %q", op, ins.Raw)
+		}
+		var sourceValid, destinationValid bool
+		source, sourceValid = arm64SVEAddressReg(ins.Args[1], true)
+		destination, destinationValid = arm64SVEAddressReg(ins.Args[2], true)
+		if !sourceValid || !destinationValid {
+			return true, false, fmt.Errorf("arm64 %s source and destination must be R0..R30 or RSP: %q", op, ins.Raw)
+		}
+	}
+
+	vscale := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.vscale.i64()\n", vscale)
+	bytesPerVScale := int64(16)
+	if op == "ADDPL" {
+		bytesPerVScale = 2
+	}
+	scaled := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", scaled, vscale, immediate*bytesPerVScale)
+	value := "%" + scaled
+	if op != "RDVL" {
+		base, err := c.loadReg(source)
+		if err != nil {
+			return true, false, err
+		}
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", added, base, value)
+		value = "%" + added
+	}
+	return true, false, c.storeReg(destination, value)
+}
+
+func (c *arm64Ctx) lowerRawSVEAddress(form arm64RawSVEAddress) error {
+	reg := func(index int, spAllowed bool) Operand {
+		if index == 31 && spAllowed {
+			return Operand{Kind: OpReg, Reg: SP}
+		}
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", index))}
+	}
+	args := []Operand{{Kind: OpImm, Imm: int64(form.immediate)}}
+	if form.op == "RDVL" {
+		args = append(args, reg(form.destination, false))
+	} else {
+		args = append(args, reg(form.source, true), reg(form.destination, true))
+	}
+	ins := Instr{Op: form.op, Raw: fmt.Sprintf("decoded ARM64 WORD as %s", form.op), Args: args}
+	ok, _, err := c.lowerARM64SVEAddress(form.op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return err
+}
diff --git a/arm64_lower_sve_address_generation.go b/arm64_lower_sve_address_generation.go
new file mode 100644
index 000000000..df9d73f25
--- /dev/null
+++ b/arm64_lower_sve_address_generation.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEAddressGenerationSpec struct {
+	elementBits int
+	extension   ExtendOp
+}
+
+var arm64SVEAddressGenerationForms = [...]arm64SVEAddressGenerationSpec{
+	{elementBits: 64, extension: ExtendSXTW},
+	{elementBits: 64, extension: ExtendUXTW},
+	{elementBits: 32},
+	{elementBits: 64},
+}
+
+func decodeARM64RawSVEAddressGeneration(word uint32) (Instr, bool) {
+	if word&0xff20f000 != 0x0420a000 {
+		return Instr{}, false
+	}
+	spec := arm64SVEAddressGenerationForms[word>>22&3]
+	width := byte('D')
+	if spec.elementBits == 32 {
+		width = 'S'
+	}
+	reg := func(number uint32) Reg {
+		return Reg(fmt.Sprintf("Z%d.%c", number, width))
+	}
+	return Instr{Op: "ZADR", Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpMem, Mem: MemRef{Base: reg(word >> 5 & 31), Index: reg(word >> 16 & 31),
+			IndexExt: spec.extension, Scale: 1 << (word >> 10 & 3)}},
+		{Kind: OpReg, Reg: reg(word & 31)},
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddressGeneration(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZADR" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 ZADR expects one complete Go 1.27 memory-vector form without a suffix: %q", ins.Raw)
+	}
+	memory := ins.Args[0].Mem
+	if memory.Sym != "" || memory.Off != 0 || memory.OffRaw != "" || memory.Base == "" || memory.Index == "" {
+		return true, false, fmt.Errorf("arm64 ZADR requires scalable-vector base and index registers: %q", ins.Raw)
+	}
+	shift, shiftOK := map[int64]int{1: 0, 2: 1, 4: 2, 8: 3}[memory.Scale]
+	if !shiftOK {
+		return true, false, fmt.Errorf("arm64 ZADR shift amount must be 0..3: %q", ins.Raw)
+	}
+	base, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base})
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !baseOK || !indexOK || !destinationOK {
+		return true, false, fmt.Errorf("arm64 ZADR operands must be scalable-vector element registers: %q", ins.Raw)
+	}
+	extended := memory.IndexExt == ExtendSXTW || memory.IndexExt == ExtendUXTW
+	valid := false
+	for _, spec := range arm64SVEAddressGenerationForms {
+		if baseBits == spec.elementBits && memory.IndexExt == spec.extension {
+			valid = true
+			break
+		}
+	}
+	if !valid || baseBits != indexBits || indexBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 ZADR requires matching S/D operands, with UXTW/SXTW only for D elements: %q", ins.Raw)
+	}
+	baseValue, vectorType, err := c.loadZRegElements(base, baseBits)
+	if err != nil {
+		return true, false, err
+	}
+	indexValue, _, err := c.loadZRegElements(index, indexBits)
+	if err != nil {
+		return true, false, err
+	}
+	if extended {
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc <vscale x 2 x i64> %s to <vscale x 2 x i32>\n", truncated, indexValue)
+		extendedValue := c.newTmp()
+		extension := "zext"
+		if memory.IndexExt == ExtendSXTW {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <vscale x 2 x i32> %%%s to <vscale x 2 x i64>\n", extendedValue, extension, truncated)
+		indexValue = "%" + extendedValue
+	}
+	if shift != 0 {
+		scaled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl %s %s, splat (i%d %d)\n", scaled, vectorType, indexValue, baseBits, shift)
+		indexValue = "%" + scaled
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", result, vectorType, baseValue, indexValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_address_generation_test.go b/arm64_lower_sve_address_generation_test.go
new file mode 100644
index 000000000..bfdff865c
--- /dev/null
+++ b/arm64_lower_sve_address_generation_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEAddressGenerationCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveaddressgenerationforms(SB),$0-0\n")
+	for _, width := range []string{"S", "D"} {
+		for amount := 0; amount <= 3; amount++ {
+			fmt.Fprintf(&source, "\tZADR (Z1.%s<<%d)(Z2.%s), Z3.%s\n", width, amount, width, width)
+		}
+	}
+	for _, extension := range []string{"SXTW", "UXTW"} {
+		for amount := 0; amount <= 3; amount++ {
+			fmt.Fprintf(&source, "\tZADR (Z4.D.%s<<%d)(Z5.D), Z6.D\n", extension, amount)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveaddressgenerationforms": {Name: "sveaddressgenerationforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				" shl <vscale x 4 x i32>",
+				" shl <vscale x 2 x i64>",
+				" sext <vscale x 2 x i32>",
+				" zext <vscale x 2 x i32>",
+				" add <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE address-generation lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-address-generation.ll", "arm64-sve-address-generation.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEAddressGenerationRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZADR (Z1.H)(Z2.H), Z3.H",
+		"ZADR (Z1.S)(Z2.D), Z3.D",
+		"ZADR (Z1.S)(Z2.S), Z3.D",
+		"ZADR (Z1.S<<4)(Z2.S), Z3.S",
+		"ZADR (Z1.S.SXTW<<2)(Z2.S), Z3.S",
+		"ZADR (Z1.D.UXTW<<2)(Z2.S), Z3.D",
+		"ZADR.Z (Z1.S)(Z2.S), Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveaddressgeneration(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveaddressgeneration": {Name: "badsveaddressgeneration", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZADR forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_address_test.go b/arm64_lower_sve_address_test.go
new file mode 100644
index 000000000..f162769c0
--- /dev/null
+++ b/arm64_lower_sve_address_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEAddress(op Op, immediate, source, destination int) uint32 {
+	base := uint32(0x04205000)
+	switch op {
+	case "ADDPL":
+		base = 0x04605000
+	case "RDVL":
+		base = 0x04bf5000
+		source = 31
+	}
+	return base | uint32(immediate&63)<<5 | uint32(source)<<16 | uint32(destination)
+}
+
+func TestTranslateARM64SVEAddressCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT sveaddressnamed(SB),$0-0
+	MOVD RSP,R25
+	ADDVL $-32, R0, R1
+	ADDVL $31, RSP, RSP
+	ADDPL $-32, R2, R3
+	ADDPL $31, RSP, R4
+	RDVL $-32, R5
+	RDVL $31, R6
+	MOVD R25,RSP
+	RET
+`
+	var raw strings.Builder
+	raw.WriteString("TEXT sveaddressraw(SB),$0-0\n")
+	for _, op := range []Op{"ADDVL", "ADDPL", "RDVL"} {
+		for immediate := -32; immediate <= 31; immediate++ {
+			fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEAddress(op, immediate, 2, 3))
+		}
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sveaddress" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs:         map[string]FuncSig{function: {Name: function, Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ll, `"target-features"="+sve"`) || !strings.Contains(ll, "call i64 @llvm.vscale.i64()") {
+						t.Fatalf("ARM64 SVE address lowering for %s/%s lacks SVE feature or runtime vector length:\n%s", name, triple, ll)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-address.ll", "arm64-sve-address.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEAddressDecoderCoversSignedImmediateDomain(t *testing.T) {
+	for _, op := range []Op{"ADDVL", "ADDPL", "RDVL"} {
+		for immediate := -32; immediate <= 31; immediate++ {
+			word := encodeARM64RawSVEAddress(op, immediate, 29, 30)
+			got, ok := decodeARM64RawSVEAddress(word)
+			if !ok {
+				t.Fatalf("decoder rejected %s immediate %d word %#08x", op, immediate, word)
+			}
+			if got.op != op || got.immediate != immediate || got.destination != 30 || (op != "RDVL" && got.source != 29) {
+				t.Fatalf("decoded word %#08x as %+v, want op=%s immediate=%d source=29 destination=30", word, got, op, immediate)
+			}
+		}
+	}
+}
+
+func TestARM64SVEAddressUsesRuntimeVectorAndPredicateLengths(t *testing.T) {
+	const source = `
+TEXT sveaddressscale(SB),$0-0
+	ADDVL $-3, R1, R2
+	ADDPL $5, R3, R4
+	RDVL $7, R5
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"sveaddressscale": {Name: "sveaddressscale", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, scale := range []string{"mul i64", "-48", "10", "112"} { // vscale * (imm * 16/2).
+		if !strings.Contains(ll, scale) {
+			t.Fatalf("SVE runtime length scaling omitted %q:\n%s", scale, ll)
+		}
+	}
+}
+
+func TestARM64RawSVEAddressDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARM64RawSVEAddress("RDVL", 1, 0, 31), // RDVL cannot target SP/ZR.
+		0x04204000, // neighboring SVE class.
+	} {
+		if _, ok := decodeARM64RawSVEAddress(word); ok {
+			t.Fatalf("SVE address decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_sve_aes_mix.go b/arm64_lower_sve_aes_mix.go
new file mode 100644
index 000000000..7e4c726c1
--- /dev/null
+++ b/arm64_lower_sve_aes_mix.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEAESMixIntrinsics = map[Op]string{
+	"ZAESIMC": "aesimc",
+	"ZAESMC":  "aesmc",
+}
+
+func (c *arm64Ctx) lowerARM64SVEAESMix(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEAESMixIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Zdn.B, Zdn.B without a suffix: %q", op, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !firstOK || !destinationOK || firstBits != 8 || destinationBits != 8 || first != destination {
+		return true, false, fmt.Errorf("arm64 %s requires the same B-element source/destination register: %q", op, ins.Raw)
+	}
+	value, vectorType, err := c.loadZRegElements(destination, 8)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s)\n", result, vectorType, intrinsic, vectorType, value)
+	return true, false, c.storeZRegElements(destination, 8, "%"+result)
+}
diff --git a/arm64_lower_sve_aes_mix_test.go b/arm64_lower_sve_aes_mix_test.go
new file mode 100644
index 000000000..70456f341
--- /dev/null
+++ b/arm64_lower_sve_aes_mix_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEAESMixCompleteGo127Family(t *testing.T) {
+	source := "TEXT sveaesmixforms(SB),$0-0\n\tZAESIMC Z3.B, Z3.B\n\tZAESMC Z4.B, Z4.B\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveaesmixforms": {Name: "sveaesmixforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve2-aes"`, "@llvm.aarch64.sve.aesimc", "@llvm.aarch64.sve.aesmc"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE AES MixColumns lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-aes-mix.ll", "arm64-sve-aes-mix.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEAESMixRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZAESIMC Z1.H, Z1.H",
+		"ZAESMC Z1.B, Z2.B",
+		"ZAESIMC Z1.B",
+		"ZAESMC.Z Z1.B, Z1.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveaesmix(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveaesmix": {Name: "badsveaesmix", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE AES MixColumns forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_aes_round.go b/arm64_lower_sve_aes_round.go
new file mode 100644
index 000000000..79f42591f
--- /dev/null
+++ b/arm64_lower_sve_aes_round.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var arm64SVEAESRoundIntrinsics = map[Op]string{
+	"ZAESD":    "aesd",
+	"ZAESDIMC": "aesdimc",
+	"ZAESE":    "aese",
+	"ZAESEMC":  "aesemc",
+}
+
+func arm64SVEAESRoundIsMulti(ins Instr) bool {
+	return len(ins.Args) == 3 && ins.Args[1].Kind == OpRegList
+}
+
+func arm64ParseSVEAESRoundKey(operand Operand) (register, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	dot := strings.IndexByte(name, '.')
+	open := strings.IndexByte(name, '[')
+	if dot <= 1 || open <= dot+1 || name[dot:open] != ".Q" || !strings.HasPrefix(name, "Z") || !strings.HasSuffix(name, "]") {
+		return 0, 0, false
+	}
+	register, registerErr := strconv.Atoi(name[1:dot])
+	lane, laneErr := strconv.Atoi(name[open+1 : len(name)-1])
+	return register, lane, registerErr == nil && laneErr == nil && register >= 0 && register <= 31 && lane >= 0 && lane <= 3
+}
+
+func arm64ParseSVEAESRoundGroup(operand Operand) ([]int, bool) {
+	if operand.Kind != OpRegList || !operand.RegListRange || len(operand.RegList) != 2 && len(operand.RegList) != 4 {
+		return nil, false
+	}
+	registers := make([]int, len(operand.RegList))
+	for i, register := range operand.RegList {
+		index, bits, ok := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: register})
+		if !ok || bits != 8 || i > 0 && index != registers[0]+i {
+			return nil, false
+		}
+		registers[i] = index
+	}
+	return registers, registers[0]%len(registers) == 0
+}
+
+func (c *arm64Ctx) lowerARM64SVEAESRound(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEAESRoundIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one of the Go 1.27 single- or multi-vector AES forms without a suffix: %q", op, ins.Raw)
+	}
+	if source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0]); sourceOK {
+		firstDestination, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		secondDestination, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if op != "ZAESD" && op != "ZAESE" || sourceBits != 8 || !firstOK || !secondOK || firstBits != 8 || secondBits != 8 || firstDestination != secondDestination {
+			return true, false, fmt.Errorf("arm64 %s single-vector form requires Zm.B, Zdn.B, Zdn.B: %q", op, ins.Raw)
+		}
+		oldDestination, vectorType, err := c.loadZRegElements(firstDestination, 8)
+		if err != nil {
+			return true, false, err
+		}
+		sourceValue, _, err := c.loadZRegElements(source, 8)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, %s %s)\n", result, vectorType, intrinsic, vectorType, oldDestination, vectorType, sourceValue)
+		return true, false, c.storeZRegElements(firstDestination, 8, "%"+result)
+	}
+	key, lane, keyOK := arm64ParseSVEAESRoundKey(ins.Args[0])
+	firstGroup, firstGroupOK := arm64ParseSVEAESRoundGroup(ins.Args[1])
+	secondGroup, secondGroupOK := arm64ParseSVEAESRoundGroup(ins.Args[2])
+	if !keyOK || !firstGroupOK || !secondGroupOK || len(firstGroup) != len(secondGroup) {
+		return true, false, fmt.Errorf("arm64 %s multi-vector form requires a Q[0..3] key and matching aligned B ranges of two or four registers: %q", op, ins.Raw)
+	}
+	for i := range firstGroup {
+		if firstGroup[i] != secondGroup[i] {
+			return true, false, fmt.Errorf("arm64 %s multi-vector source/destination ranges must match: %q", op, ins.Raw)
+		}
+	}
+	values := make([]string, len(firstGroup))
+	vectorType := ""
+	for i, register := range firstGroup {
+		values[i], vectorType, err = c.loadZRegElements(register, 8)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	keyValue, _, err := c.loadZRegElements(key, 8)
+	if err != nil {
+		return true, false, err
+	}
+	types := make([]string, len(values))
+	arguments := make([]string, 0, len(values)+2)
+	for i, value := range values {
+		types[i] = vectorType
+		arguments = append(arguments, vectorType+" "+value)
+	}
+	arguments = append(arguments, vectorType+" "+keyValue, fmt.Sprintf("i32 %d", lane))
+	aggregateType := "{ " + strings.Join(types, ", ") + " }"
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.x%d(%s)\n", result, aggregateType, intrinsic, len(values), strings.Join(arguments, ", "))
+	for i, register := range firstGroup {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, aggregateType, result, i)
+		if err := c.storeZRegElements(register, 8, "%"+value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
diff --git a/arm64_lower_sve_aes_round_test.go b/arm64_lower_sve_aes_round_test.go
new file mode 100644
index 000000000..f464ea3bc
--- /dev/null
+++ b/arm64_lower_sve_aes_round_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEAESRoundCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT sveaessingle(SB),$0-0
+	ZAESD Z1.B, Z2.B, Z2.B
+	ZAESE Z3.B, Z4.B, Z4.B
+	RET
+TEXT sveaesmulti(SB),$0-0
+	ZAESD Z5.Q[0], [Z6.B-Z7.B], [Z6.B-Z7.B]
+	ZAESD Z31.Q[3], [Z28.B-Z31.B], [Z28.B-Z31.B]
+	ZAESDIMC Z8.Q[1], [Z10.B-Z11.B], [Z10.B-Z11.B]
+	ZAESDIMC Z9.Q[2], [Z24.B-Z27.B], [Z24.B-Z27.B]
+	ZAESE Z10.Q[3], [Z12.B-Z13.B], [Z12.B-Z13.B]
+	ZAESE Z11.Q[0], [Z20.B-Z23.B], [Z20.B-Z23.B]
+	ZAESEMC Z12.Q[2], [Z14.B-Z15.B], [Z14.B-Z15.B]
+	ZAESEMC Z13.Q[1], [Z16.B-Z19.B], [Z16.B-Z19.B]
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"sveaessingle": {Name: "sveaessingle", Ret: Void},
+		"sveaesmulti":  {Name: "sveaesmulti", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve2-aes"`,
+				`"target-features"="+sve,+sve-aes2"`,
+				"@llvm.aarch64.sve.aesd(",
+				"@llvm.aarch64.sve.aese(",
+				"@llvm.aarch64.sve.aesd.lane.x2",
+				"@llvm.aarch64.sve.aesd.lane.x4",
+				"@llvm.aarch64.sve.aesdimc.lane.x2",
+				"@llvm.aarch64.sve.aesdimc.lane.x4",
+				"@llvm.aarch64.sve.aese.lane.x2",
+				"@llvm.aarch64.sve.aese.lane.x4",
+				"@llvm.aarch64.sve.aesemc.lane.x2",
+				"@llvm.aarch64.sve.aesemc.lane.x4",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE AES round lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-aes-round.ll", "arm64-sve-aes-round.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEAESRoundRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZAESD Z1.B, Z2.B, Z3.B",
+		"ZAESE Z1.H, Z2.H, Z2.H",
+		"ZAESDIMC Z1.B, Z2.B, Z2.B",
+		"ZAESD Z1.Q[4], [Z2.B-Z3.B], [Z2.B-Z3.B]",
+		"ZAESE Z1.Q[0], [Z1.B-Z2.B], [Z1.B-Z2.B]",
+		"ZAESDIMC Z1.Q[0], [Z4.B-Z6.B], [Z4.B-Z6.B]",
+		"ZAESEMC Z1.Q[0], [Z4.B-Z5.B], [Z6.B-Z7.B]",
+		"ZAESD Z1.Q[0], [Z4.B, Z5.B], [Z4.B, Z5.B]",
+		"ZAESE.Z Z1.B, Z2.B, Z2.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "[", "", "]", "").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveaesround(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveaesround": {Name: "badsveaesround", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE AES round forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_bfdot.go b/arm64_lower_sve_bfdot.go
new file mode 100644
index 000000000..8c4dff42a
--- /dev/null
+++ b/arm64_lower_sve_bfdot.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEBFDOTForm struct {
+	first       int
+	second      int
+	destination int
+	lane        int
+	indexed     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFDOT(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZBFDOT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZBFDOT expects one complete Go 1.27 form without a suffix: %q", ins.Raw)
+	}
+	form := arm64SVEBFDOTForm{}
+	if first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0]); firstOK {
+		if firstBits != 16 {
+			return true, false, fmt.Errorf("arm64 ZBFDOT vector source must use H elements: %q", ins.Raw)
+		}
+		form.first = first
+	} else {
+		first, firstBits, lane, firstOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !firstOK || firstBits != 16 || first > 7 || lane > 3 {
+			return true, false, fmt.Errorf("arm64 ZBFDOT indexed source must use Z0..Z7.H[0..3]: %q", ins.Raw)
+		}
+		form.first = first
+		form.lane = lane
+		form.indexed = true
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || secondBits != 16 || !destinationOK || destinationBits != 32 {
+		return true, false, fmt.Errorf("arm64 ZBFDOT operands must use H source elements and an S accumulator: %q", ins.Raw)
+	}
+	form.second = second
+	form.destination = destination
+	return true, false, c.lowerARM64SVEBFDOTForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFDOTForm(form arm64SVEBFDOTForm) error {
+	accumulator, accumulatorType, err := c.loadRawSVEFloatVector(form.destination, 32)
+	if err != nil {
+		return err
+	}
+	loadBFloat := func(register int) (string, error) {
+		integer, integerType, err := c.loadZRegElements(register, 16)
+		if err != nil {
+			return "", err
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 8 x bfloat>\n", converted, integerType, integer)
+		return "%" + converted, nil
+	}
+	second, err := loadBFloat(form.second)
+	if err != nil {
+		return err
+	}
+	first, err := loadBFloat(form.first)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x float> @llvm.aarch64.sve.bfdot.lane.v2(<vscale x 4 x float> %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, i32 %d)\n", result, accumulator, second, first, form.lane)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x float> @llvm.aarch64.sve.bfdot(<vscale x 4 x float> %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s)\n", result, accumulator, second, first)
+	}
+	return c.storeRawSVEFloatVector(form.destination, 32, "%"+result, accumulatorType)
+}
diff --git a/arm64_lower_sve_bfdot_test.go b/arm64_lower_sve_bfdot_test.go
new file mode 100644
index 000000000..9039315f2
--- /dev/null
+++ b/arm64_lower_sve_bfdot_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEBFDOTCompleteGo127Family(t *testing.T) {
+	source := "TEXT svebfdotforms(SB),$0-0\n" +
+		"\tZBFDOT Z1.H, Z2.H, Z3.S\n" +
+		"\tZBFDOT Z0.H[0], Z2.H, Z3.S\n" +
+		"\tZBFDOT Z7.H[3], Z2.H, Z3.S\n" +
+		"\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svebfdotforms": {Name: "svebfdotforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+bf16,+sve\"",
+				"@llvm.aarch64.sve.bfdot(",
+				"@llvm.aarch64.sve.bfdot.lane.v2(",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE BFDOT lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-bfdot.ll", "arm64-sve-bfdot.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEBFDOTRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBFDOT Z1.B, Z2.B, Z3.S",
+		"ZBFDOT Z1.H, Z2.H, Z3.H",
+		"ZBFDOT Z1.H[0], Z2.S, Z3.S",
+		"ZBFDOT Z8.H[0], Z2.H, Z3.S",
+		"ZBFDOT Z7.H[4], Z2.H, Z3.S",
+		"ZBFDOT Z1.H, Z2.H",
+		"ZBFDOT.Z Z1.H, Z2.H, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvebfdot(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvebfdot": {Name: "badsvebfdot", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE BFDOT forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_bfloat_arithmetic.go b/arm64_lower_sve_bfloat_arithmetic.go
new file mode 100644
index 000000000..da4521d15
--- /dev/null
+++ b/arm64_lower_sve_bfloat_arithmetic.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEBFloatArithmeticSpec struct {
+	intrinsic    string
+	unpredicated bool
+	indexed      bool
+	scale        bool
+}
+
+var arm64SVEBFloatArithmeticSpecs = map[Op]arm64SVEBFloatArithmeticSpec{
+	"ZBFADD":   {intrinsic: "fadd", unpredicated: true},
+	"ZBFSUB":   {intrinsic: "fsub", unpredicated: true},
+	"ZBFMUL":   {intrinsic: "fmul", unpredicated: true, indexed: true},
+	"ZBFMAX":   {intrinsic: "fmax"},
+	"ZBFMAXNM": {intrinsic: "fmaxnm"},
+	"ZBFMIN":   {intrinsic: "fmin"},
+	"ZBFMINNM": {intrinsic: "fminnm"},
+	"ZBFSCALE": {intrinsic: "fscale", scale: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatArithmetic(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEBFloatArithmeticSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) == 4 {
+		return c.lowerARM64SVEBFloatArithmeticPredicated(op, spec, ins)
+	}
+	if len(ins.Args) == 3 && spec.unpredicated {
+		return c.lowerARM64SVEBFloatArithmeticUnpredicated(op, spec, ins)
+	}
+	return true, false, fmt.Errorf("arm64 %s operands are outside its complete Go 1.27 BF16 arithmetic forms: %q", op, ins.Raw)
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatArithmeticPredicated(op Op, spec arm64SVEBFloatArithmeticSpec, ins Instr) (bool, bool, error) {
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != 16 || firstBits != 16 || destinationBits != 16 || destination != first {
+		return true, false, fmt.Errorf("arm64 %s requires destructive H operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	firstValue, err := c.loadARM64SVEBFloatVector(first)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, 16)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if spec.scale {
+		secondValue, secondType, err := c.loadZRegElements(second, 16)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x bfloat> @llvm.aarch64.sve.fscale.nxv8bf16(%s %s, <vscale x 8 x bfloat> %s, %s %s)\n", result, predicateType, predicateValue, firstValue, secondType, secondValue)
+	} else {
+		secondValue, err := c.loadARM64SVEBFloatVector(second)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.nxv8bf16(%s %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s)\n", result, spec.intrinsic, predicateType, predicateValue, firstValue, secondValue)
+	}
+	return true, false, c.storeARM64SVEBFloatVector(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatArithmeticUnpredicated(op Op, spec arm64SVEBFloatArithmeticSpec, ins Instr) (bool, bool, error) {
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !firstOK || !destinationOK || firstBits != 16 || destinationBits != 16 {
+		return true, false, fmt.Errorf("arm64 %s requires H vector operands: %q", op, ins.Raw)
+	}
+	firstValue, err := c.loadARM64SVEBFloatVector(first)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0]); secondOK {
+		if secondBits != 16 {
+			return true, false, fmt.Errorf("arm64 %s requires H vector operands: %q", op, ins.Raw)
+		}
+		secondValue, err := c.loadARM64SVEBFloatVector(second)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <vscale x 8 x bfloat> %s, %s\n", result, spec.intrinsic, firstValue, secondValue)
+	} else {
+		second, secondBits, lane, secondOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !spec.indexed || !secondOK || secondBits != 16 || second > 7 || lane > 7 {
+			return true, false, fmt.Errorf("arm64 %s indexed source must use Z0..Z7.H[0..7]: %q", op, ins.Raw)
+		}
+		secondValue, err := c.loadARM64SVEBFloatVector(second)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmul.lane.nxv8bf16(<vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, i32 %d)\n", result, firstValue, secondValue, lane)
+	}
+	return true, false, c.storeARM64SVEBFloatVector(destination, "%"+result)
+}
+
+func emitARM64SVEBFloatArithmeticDeclarations(b *strings.Builder) {
+	for _, intrinsic := range []string{"fadd", "fsub", "fmul", "fmax", "fmaxnm", "fmin", "fminnm"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.nxv8bf16(<vscale x 8 x i1>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fmul.lane.nxv8bf16(<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fscale.nxv8bf16(<vscale x 8 x i1>, <vscale x 8 x bfloat>, <vscale x 8 x i16>)\n")
+}
diff --git a/arm64_lower_sve_bfloat_arithmetic_test.go b/arm64_lower_sve_bfloat_arithmetic_test.go
new file mode 100644
index 000000000..5b12b5ac4
--- /dev/null
+++ b/arm64_lower_sve_bfloat_arithmetic_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEBFloatArithmeticCompleteGo127Family(t *testing.T) {
+	const source = `TEXT svebfloatarithmetic(SB),$0-0
+	ZBFADD Z0.H, Z1.H, P0.M, Z1.H
+	ZBFADD Z2.H, Z3.H, Z4.H
+	ZBFSUB Z5.H, Z6.H, P7.M, Z6.H
+	ZBFSUB Z7.H, Z8.H, Z9.H
+	ZBFMUL Z10.H, Z11.H, P1.M, Z11.H
+	ZBFMUL Z12.H, Z13.H, Z14.H
+	ZBFMUL Z0.H[0], Z15.H, Z16.H
+	ZBFMUL Z7.H[7], Z17.H, Z18.H
+	ZBFMAX Z19.H, Z20.H, P2.M, Z20.H
+	ZBFMAXNM Z21.H, Z22.H, P3.M, Z22.H
+	ZBFMIN Z23.H, Z24.H, P4.M, Z24.H
+	ZBFMINNM Z25.H, Z26.H, P5.M, Z26.H
+	ZBFSCALE Z27.H, Z28.H, P6.M, Z28.H
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svebfloatarithmetic": {Name: "svebfloatarithmetic", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve-b16b16,+sve-bfscale"`,
+				"= fadd <vscale x 8 x bfloat>",
+				"= fsub <vscale x 8 x bfloat>",
+				"= fmul <vscale x 8 x bfloat>",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fadd.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fsub.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmul.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmul.lane.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmax.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmaxnm.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmin.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fminnm.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fscale.nxv8bf16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s BF16 arithmetic lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-bfloat-arithmetic.ll", "arm64-sve-bfloat-arithmetic.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEBFloatArithmeticInfersIndependentFeatures(t *testing.T) {
+	classes := []struct {
+		name, instruction, features string
+	}{
+		{name: "b16b16", instruction: "ZBFADD Z0.H, Z1.H, Z2.H", features: "+sve,+sve-b16b16"},
+		{name: "bfscale", instruction: "ZBFSCALE Z0.H, Z1.H, P0.M, Z1.H", features: "+sve,+sve-bfscale"},
+	}
+	for _, class := range classes {
+		t.Run(class.name, func(t *testing.T) {
+			source := "TEXT onebfloatfeature(SB),$0-0\n\t" + class.instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"onebfloatfeature": {Name: "onebfloatfeature", Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := `"target-features"="` + class.features + `"`
+					if !strings.Contains(ll, want) {
+						t.Fatalf("%s feature inference omitted %q for %s:\n%s", triple, want, class.instruction, ll)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-bfloat-feature.ll", "arm64-sve-bfloat-feature.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEBFloatArithmeticRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBFADD Z0.S, Z1.S, Z2.S",
+		"ZBFADD Z0.H, Z1.H, P8.M, Z1.H",
+		"ZBFSUB Z0.H, Z1.H, P0.M, Z2.H",
+		"ZBFMUL Z0.H, Z1.H, P0.Z, Z1.H",
+		"ZBFMUL Z8.H[0], Z1.H, Z2.H",
+		"ZBFMUL Z7.H[8], Z1.H, Z2.H",
+		"ZBFMAX Z0.H, Z1.H, Z2.H",
+		"ZBFSCALE Z0.H, Z1.H, Z2.H",
+		"ZBFMINNM.Z Z0.H, Z1.H, P0.M, Z1.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvebfloatarithmetic(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvebfloatarithmetic": {Name: "badsvebfloatarithmetic", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's BF16 arithmetic forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_bfloat_mla.go b/arm64_lower_sve_bfloat_mla.go
new file mode 100644
index 000000000..35725e448
--- /dev/null
+++ b/arm64_lower_sve_bfloat_mla.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEBFloatMLASpec struct {
+	intrinsic     string
+	laneIntrinsic string
+	widening      bool
+	subtractLong  bool
+}
+
+var arm64SVEBFloatMLASpecs = map[Op]arm64SVEBFloatMLASpec{
+	"ZBFMLA":   {intrinsic: "fmla", laneIntrinsic: "fmla.lane"},
+	"ZBFMLS":   {intrinsic: "fmls", laneIntrinsic: "fmls.lane"},
+	"ZBFMLALB": {intrinsic: "bfmlalb", laneIntrinsic: "bfmlalb.lane.v2", widening: true},
+	"ZBFMLALT": {intrinsic: "bfmlalt", laneIntrinsic: "bfmlalt.lane.v2", widening: true},
+	"ZBFMLSLB": {intrinsic: "bfmlslb", laneIntrinsic: "bfmlslb.lane", widening: true, subtractLong: true},
+	"ZBFMLSLT": {intrinsic: "bfmlslt", laneIntrinsic: "bfmlslt.lane", widening: true, subtractLong: true},
+}
+
+type arm64SVEBFloatMLAForm struct {
+	spec                          arm64SVEBFloatMLASpec
+	first, second, destination    int
+	predicate, lane               int
+	predicated, indexed, widening bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatMLA(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEBFloatMLASpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEBFloatMLAForm{spec: spec, widening: spec.widening}
+	if len(ins.Args) == 4 && !spec.widening {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != 16 || firstBits != 16 || destinationBits != 16 {
+			return true, false, fmt.Errorf("arm64 %s requires H sources, H accumulator, and P0..P7/M: %q", op, ins.Raw)
+		}
+		form.first, form.second, form.destination = first, second, destination
+		form.predicate, form.predicated = predicate, true
+		return true, false, c.lowerARM64SVEBFloatMLAForm(form)
+	}
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s operands are outside its complete Go 1.27 BF16 MLA forms: %q", op, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	wantDestinationBits := 16
+	if spec.widening {
+		wantDestinationBits = 32
+	}
+	if !firstOK || !destinationOK || firstBits != 16 || destinationBits != wantDestinationBits {
+		return true, false, fmt.Errorf("arm64 %s source/destination widths are outside its Go 1.27 forms: %q", op, ins.Raw)
+	}
+	form.first, form.destination = first, destination
+	if second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0]); secondOK {
+		if !spec.widening || secondBits != 16 {
+			return true, false, fmt.Errorf("arm64 %s has no unpredicated non-indexed same-width form: %q", op, ins.Raw)
+		}
+		form.second = second
+	} else {
+		second, secondBits, lane, secondOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !secondOK || secondBits != 16 || second > 7 || lane > 7 {
+			return true, false, fmt.Errorf("arm64 %s indexed source must use Z0..Z7.H[0..7]: %q", op, ins.Raw)
+		}
+		form.second, form.lane, form.indexed = second, lane, true
+	}
+	return true, false, c.lowerARM64SVEBFloatMLAForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatMLAForm(form arm64SVEBFloatMLAForm) error {
+	firstValue, err := c.loadARM64SVEBFloatVector(form.first)
+	if err != nil {
+		return err
+	}
+	secondValue, err := c.loadARM64SVEBFloatVector(form.second)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.widening {
+		accumulator, accumulatorType, err := c.loadRawSVEFloatVector(form.destination, 32)
+		if err != nil {
+			return err
+		}
+		if form.indexed {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, i32 %d)\n", result, accumulatorType, form.spec.laneIntrinsic, accumulatorType, accumulator, firstValue, secondValue, form.lane)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s)\n", result, accumulatorType, form.spec.intrinsic, accumulatorType, accumulator, firstValue, secondValue)
+		}
+		return c.storeRawSVEFloatVector(form.destination, 32, "%"+result, accumulatorType)
+	}
+	accumulator, err := c.loadARM64SVEBFloatVector(form.destination)
+	if err != nil {
+		return err
+	}
+	if form.predicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, 16)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.nxv8bf16(%s %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s)\n", result, form.spec.intrinsic, predicateType, predicate, accumulator, firstValue, secondValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.nxv8bf16(<vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, <vscale x 8 x bfloat> %s, i32 %d)\n", result, form.spec.laneIntrinsic, accumulator, firstValue, secondValue, form.lane)
+	}
+	return c.storeARM64SVEBFloatVector(form.destination, "%"+result)
+}
+
+func emitARM64SVEBFloatMLADeclarations(b *strings.Builder) {
+	for _, intrinsic := range []string{"fmla", "fmls"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.nxv8bf16(<vscale x 8 x i1>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 8 x bfloat> @llvm.aarch64.sve.%s.lane.nxv8bf16(<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>, i32 immarg)\n", intrinsic)
+	}
+	for _, spec := range []arm64SVEBFloatMLASpec{
+		arm64SVEBFloatMLASpecs["ZBFMLALB"], arm64SVEBFloatMLASpecs["ZBFMLALT"],
+		arm64SVEBFloatMLASpecs["ZBFMLSLB"], arm64SVEBFloatMLASpecs["ZBFMLSLT"],
+	} {
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.%s(<vscale x 4 x float>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n", spec.intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.%s(<vscale x 4 x float>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>, i32 immarg)\n", spec.laneIntrinsic)
+	}
+}
diff --git a/arm64_lower_sve_bfloat_mla_test.go b/arm64_lower_sve_bfloat_mla_test.go
new file mode 100644
index 000000000..9b469669f
--- /dev/null
+++ b/arm64_lower_sve_bfloat_mla_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEBFloatMLACompleteGo127Family(t *testing.T) {
+	const source = `TEXT svebfloatmla(SB),$0-0
+	ZBFMLA Z0.H, Z1.H, P0.M, Z2.H
+	ZBFMLA Z0.H[0], Z3.H, Z4.H
+	ZBFMLS Z5.H, Z6.H, P7.M, Z7.H
+	ZBFMLS Z7.H[7], Z8.H, Z9.H
+	ZBFMLALB Z10.H, Z11.H, Z12.S
+	ZBFMLALB Z0.H[0], Z13.H, Z14.S
+	ZBFMLALT Z15.H, Z16.H, Z17.S
+	ZBFMLALT Z7.H[7], Z18.H, Z19.S
+	ZBFMLSLB Z20.H, Z21.H, Z22.S
+	ZBFMLSLB Z0.H[0], Z23.H, Z24.S
+	ZBFMLSLT Z25.H, Z26.H, Z27.S
+	ZBFMLSLT Z7.H[7], Z28.H, Z29.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svebfloatmla": {Name: "svebfloatmla", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+bf16,+sve,+sve-b16b16,+sve2p1"`,
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmla.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmla.lane.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmls.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fmls.lane.nxv8bf16",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlalb(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlalb.lane.v2(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlalt(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlalt.lane.v2(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlslb(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlslb.lane(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlslt(",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.bfmlslt.lane(",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s BF16 MLA lowering omitted actual call %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-bfloat-mla.ll", "arm64-sve-bfloat-mla.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEBFloatMLAInfersIndependentFeatures(t *testing.T) {
+	classes := []struct {
+		name, instruction, features string
+	}{
+		{name: "non-widening", instruction: "ZBFMLA Z0.H, Z1.H, P0.M, Z2.H", features: "+sve,+sve-b16b16"},
+		{name: "widening-add", instruction: "ZBFMLALB Z0.H, Z1.H, Z2.S", features: "+bf16,+sve"},
+		{name: "widening-subtract", instruction: "ZBFMLSLB Z0.H, Z1.H, Z2.S", features: "+bf16,+sve,+sve2p1"},
+	}
+	for _, class := range classes {
+		t.Run(class.name, func(t *testing.T) {
+			source := "TEXT onebfloatmlafeature(SB),$0-0\n\t" + class.instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"onebfloatmlafeature": {Name: "onebfloatmlafeature", Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := `"target-features"="` + class.features + `"`
+					if !strings.Contains(ll, want) {
+						t.Fatalf("%s feature inference omitted %q for %s:\n%s", triple, want, class.instruction, ll)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-bfloat-mla-feature.ll", "arm64-sve-bfloat-mla-feature.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEBFloatMLARejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBFMLA Z0.S, Z1.S, P0.M, Z2.S",
+		"ZBFMLA Z0.H, Z1.H, P8.M, Z2.H",
+		"ZBFMLS Z0.H, Z1.H, P0.Z, Z2.H",
+		"ZBFMLA Z0.H, Z1.H, Z2.H",
+		"ZBFMLA Z8.H[0], Z1.H, Z2.H",
+		"ZBFMLS Z7.H[8], Z1.H, Z2.H",
+		"ZBFMLALB Z0.H, Z1.H, Z2.H",
+		"ZBFMLALT Z0.S, Z1.S, Z2.S",
+		"ZBFMLSLB Z0.H, Z1.H, P0.M, Z2.S",
+		"ZBFMLSLT.Z Z0.H, Z1.H, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvebfloatmla(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvebfloatmla": {Name: "badsvebfloatmla", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's BF16 MLA forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_bit_permute.go b/arm64_lower_sve_bit_permute.go
new file mode 100644
index 000000000..4bce26d04
--- /dev/null
+++ b/arm64_lower_sve_bit_permute.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEBitPermuteIntrinsics = map[Op]string{
+	"ZBDEP": "bdep.x",
+	"ZBEXT": "bext.x",
+	"ZBGRP": "bgrp.x",
+}
+
+func (c *arm64Ctx) lowerARM64SVEBitPermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEBitPermuteIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zn.T, Zd.T without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || firstBits != secondBits || destinationBits != firstBits {
+		return true, false, fmt.Errorf("arm64 %s requires matching B/H/S/D operands: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, vectorType, intrinsic, lanes, firstBits, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_bit_permute_test.go b/arm64_lower_sve_bit_permute_test.go
new file mode 100644
index 000000000..5cc3978bb
--- /dev/null
+++ b/arm64_lower_sve_bit_permute_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEBitPermuteCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svebitpermuteforms(SB),$0-0\n")
+	for _, op := range []string{"ZBDEP", "ZBEXT", "ZBGRP"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEBitPermuteCompleteGo127Family(t *testing.T) {
+	source := arm64SVEBitPermuteCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svebitpermuteforms": {Name: "svebitpermuteforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve-bitperm,+sve2"`,
+				"@llvm.aarch64.sve.bdep.x.nxv16i8",
+				"@llvm.aarch64.sve.bext.x.nxv8i16",
+				"@llvm.aarch64.sve.bgrp.x.nxv4i32",
+				"@llvm.aarch64.sve.bdep.x.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE bit-permute lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-bit-permute.ll", "arm64-sve-bit-permute.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEBitPermuteRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBDEP Z1.B, Z2.H, Z3.B",
+		"ZBEXT Z1.S, Z2.S, Z3.D",
+		"ZBGRP Z1.Q, Z2.Q, Z3.Q",
+		"ZBDEP Z1.D, Z2.D",
+		"ZBEXT.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvebitpermute(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvebitpermute": {Name: "badsvebitpermute", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE bit-permute forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_carry_long.go b/arm64_lower_sve_carry_long.go
new file mode 100644
index 000000000..44401d832
--- /dev/null
+++ b/arm64_lower_sve_carry_long.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVECarryLongIntrinsics = map[Op]string{
+	"ZADCLB": "adclb",
+	"ZADCLT": "adclt",
+	"ZSBCLB": "sbclb",
+	"ZSBCLT": "sbclt",
+}
+
+func (c *arm64Ctx) lowerARM64SVECarryLong(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVECarryLongIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.S|D, Zn.S|D, Zda.S|D without a suffix: %q", op, ins.Raw)
+	}
+	third, thirdBits, thirdOK := arm64ParseSVEZElementReg(ins.Args[0])
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	accumulator, accumulatorBits, accumulatorOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !thirdOK || !secondOK || !accumulatorOK || (accumulatorBits != 32 && accumulatorBits != 64) || secondBits != accumulatorBits || thirdBits != accumulatorBits {
+		return true, false, fmt.Errorf("arm64 %s requires matching S/D operands: %q", op, ins.Raw)
+	}
+	accumulatorValue, vectorType, err := c.loadZRegElements(accumulator, accumulatorBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, accumulatorBits)
+	if err != nil {
+		return true, false, err
+	}
+	thirdValue, _, err := c.loadZRegElements(third, accumulatorBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / accumulatorBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, accumulatorBits, vectorType, accumulatorValue, vectorType, secondValue, vectorType, thirdValue)
+	return true, false, c.storeZRegElements(accumulator, accumulatorBits, "%"+result)
+}
diff --git a/arm64_lower_sve_carry_long_test.go b/arm64_lower_sve_carry_long_test.go
new file mode 100644
index 000000000..8c1fadc36
--- /dev/null
+++ b/arm64_lower_sve_carry_long_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVECarryLongCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svecarrylongforms(SB),$0-0\n")
+	for _, op := range []string{"ZADCLB", "ZADCLT", "ZSBCLB", "ZSBCLT"} {
+		for _, width := range []string{"S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVECarryLongCompleteGo127Family(t *testing.T) {
+	source := arm64SVECarryLongCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecarrylongforms": {Name: "svecarrylongforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.adclb.nxv4i32",
+				"@llvm.aarch64.sve.adclt.nxv2i64",
+				"@llvm.aarch64.sve.sbclb.nxv4i32",
+				"@llvm.aarch64.sve.sbclt.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE carry-long lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-carry-long.ll", "arm64-sve-carry-long.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVECarryLongRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZADCLB Z1.B, Z2.B, Z3.B",
+		"ZADCLT Z1.H, Z2.H, Z3.H",
+		"ZSBCLB Z1.S, Z2.D, Z3.S",
+		"ZSBCLT Z1.D, Z2.D",
+		"ZADCLB.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecarrylong(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecarrylong": {Name: "badsvecarrylong", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE carry-long forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_cdot.go b/arm64_lower_sve_cdot.go
new file mode 100644
index 000000000..88ca8427b
--- /dev/null
+++ b/arm64_lower_sve_cdot.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVECDOTForm struct {
+	first, second, destination  int
+	sourceBits, destinationBits int
+	rotation                    int
+	lane                        int
+	indexed                     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVECDOT(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZCDOT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 ZCDOT expects $0|$90|$180|$270 and one complete Go 1.27 vector or indexed form: %q", ins.Raw)
+	}
+	rotation := int(ins.Args[0].Imm)
+	if rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270 {
+		return true, false, fmt.Errorf("arm64 ZCDOT rotation must be $0, $90, $180, or $270: %q", ins.Raw)
+	}
+	form := arm64SVECDOTForm{rotation: rotation}
+	if first, sourceBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1]); firstOK {
+		form.first, form.sourceBits = first, sourceBits
+	} else {
+		first, sourceBits, lane, firstOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[1])
+		if !firstOK {
+			return true, false, fmt.Errorf("arm64 ZCDOT requires a B/H vector or indexed source: %q", ins.Raw)
+		}
+		form.first, form.sourceBits, form.lane, form.indexed = first, sourceBits, lane, true
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	validWidths := (form.sourceBits == 8 && destinationBits == 32) || (form.sourceBits == 16 && destinationBits == 64)
+	if !secondOK || !destinationOK || secondBits != form.sourceBits || !validWidths {
+		return true, false, fmt.Errorf("arm64 ZCDOT requires B sources with an S accumulator or H sources with a D accumulator: %q", ins.Raw)
+	}
+	if form.indexed {
+		maxRegister, maxLane := 7, 3
+		if form.sourceBits == 16 {
+			maxRegister, maxLane = 15, 1
+		}
+		if form.first > maxRegister || form.lane > maxLane {
+			return true, false, fmt.Errorf("arm64 ZCDOT indexed source exceeds its register or lane range: %q", ins.Raw)
+		}
+	}
+	form.second, form.destination, form.destinationBits = second, destination, destinationBits
+	return true, false, c.lowerARM64SVECDOTForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVECDOTForm(form arm64SVECDOTForm) error {
+	accumulator, accumulatorType, err := c.loadZRegElements(form.destination, form.destinationBits)
+	if err != nil {
+		return err
+	}
+	first, sourceType, err := c.loadZRegElements(form.first, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	second, _, err := c.loadZRegElements(form.second, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / form.destinationBits
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.cdot.lane.nxv%di%d(%s %s, %s %s, %s %s, i32 %d, i32 %d)\n", result, accumulatorType, lanes, form.destinationBits, accumulatorType, accumulator, sourceType, second, sourceType, first, form.lane, form.rotation)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.cdot.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n", result, accumulatorType, lanes, form.destinationBits, accumulatorType, accumulator, sourceType, second, sourceType, first, form.rotation)
+	}
+	return c.storeZRegElements(form.destination, form.destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_cdot_test.go b/arm64_lower_sve_cdot_test.go
new file mode 100644
index 000000000..3f02a5890
--- /dev/null
+++ b/arm64_lower_sve_cdot_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVECDOTCompleteGo127Family(t *testing.T) {
+	const source = `TEXT svecdot(SB),$0-0
+	ZCDOT $0, Z8.B, Z9.B, Z10.S
+	ZCDOT $90, Z11.H, Z12.H, Z13.D
+	ZCDOT $180, Z14.B, Z15.B, Z16.S
+	ZCDOT $270, Z17.H, Z18.H, Z19.D
+	ZCDOT $0, Z0.B[0], Z20.B, Z21.S
+	ZCDOT $270, Z7.B[3], Z22.B, Z23.S
+	ZCDOT $90, Z0.H[0], Z24.H, Z25.D
+	ZCDOT $180, Z15.H[1], Z26.H, Z27.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecdot": {Name: "svecdot", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.cdot.nxv4i32",
+				"@llvm.aarch64.sve.cdot.nxv2i64",
+				"@llvm.aarch64.sve.cdot.lane.nxv4i32",
+				"@llvm.aarch64.sve.cdot.lane.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZCDOT lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-cdot.ll", "arm64-sve-cdot.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVECDOTRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCDOT $1, Z1.B, Z2.B, Z3.S",
+		"ZCDOT $90, Z1.B, Z2.H, Z3.S",
+		"ZCDOT $90, Z1.H, Z2.H, Z3.S",
+		"ZCDOT $90, Z8.B[0], Z2.B, Z3.S",
+		"ZCDOT $90, Z7.B[4], Z2.B, Z3.S",
+		"ZCDOT $90, Z16.H[0], Z2.H, Z3.D",
+		"ZCDOT $90, Z15.H[2], Z2.H, Z3.D",
+		"ZCDOT.Z $270, Z1.H, Z2.H, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecdot(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecdot": {Name: "badsvecdot", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZCDOT forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_character_match.go b/arm64_lower_sve_character_match.go
new file mode 100644
index 000000000..0c1431aa2
--- /dev/null
+++ b/arm64_lower_sve_character_match.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVECharacterMatchIntrinsics = map[Op]string{
+	"ZMATCH":  "match",
+	"ZNMATCH": "nmatch",
+}
+
+// decodeARM64RawSVECharacterMatch mirrors Go 1.27's ZMATCH/ZNMATCH B/H
+// encoder rows. Only the two element sizes and the predicate/register fields
+// vary; the remaining bits must match the architecture encoding exactly.
+func decodeARM64RawSVECharacterMatch(word uint32) (Instr, bool) {
+	const (
+		base        = uint32(0x45208000)
+		operandBits = uint32(0x005f1fff)
+		negativeBit = uint32(1 << 4)
+		halfwordBit = uint32(1 << 22)
+	)
+	if word&^operandBits != base {
+		return Instr{}, false
+	}
+
+	op := Op("ZMATCH")
+	if word&negativeBit != 0 {
+		op = "ZNMATCH"
+	}
+	element := "B"
+	if word&halfwordBit != 0 {
+		element = "H"
+	}
+	second := int(word>>16) & 31
+	first := int(word>>5) & 31
+	governing := int(word>>10) & 7
+	destination := int(word) & 15
+	args := []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", second, element))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", first, element))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", governing))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", destination, element))},
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVECharacterMatch(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVECharacterMatchIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.B|H, Zn.B|H, Pg/Z, Pd.B|H without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	governing, governingOK := arm64ParseSVEPredicateMode(ins.Args[2], "Z", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[3])
+	if !secondOK || !firstOK || !governingOK || !destinationOK || (firstBits != 8 && firstBits != 16) || secondBits != firstBits || destinationBits != firstBits {
+		return true, false, fmt.Errorf("arm64 %s requires matching B/H vectors and result predicate under P0..P7/Z: %q", op, ins.Raw)
+	}
+	governingValue, predicateType, err := c.loadPRegElements(governing, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, predicateType, intrinsic, lanes, firstBits, predicateType, governingValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storePRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_character_match_test.go b/arm64_lower_sve_character_match_test.go
new file mode 100644
index 000000000..b784fe838
--- /dev/null
+++ b/arm64_lower_sve_character_match_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVECharacterMatchCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svecharactermatch(SB),$0-0\n")
+	for opIndex, op := range []string{"ZMATCH", "ZNMATCH"} {
+		for widthIndex, width := range []string{"B", "H"} {
+			fmt.Fprintf(&source, "\t%s Z%d.%s, Z%d.%s, P%d.Z, P%d.%s\n", op, opIndex*2+widthIndex, width, opIndex*2+widthIndex+1, width, opIndex+widthIndex, opIndex*2+widthIndex+8, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecharactermatch": {Name: "svecharactermatch", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.match.nxv16i8",
+				"@llvm.aarch64.sve.match.nxv8i16",
+				"@llvm.aarch64.sve.nmatch.nxv16i8",
+				"@llvm.aarch64.sve.nmatch.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE character-match lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-character-match.ll", "arm64-sve-character-match.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVECharacterMatchCompleteFamily(t *testing.T) {
+	// Go 1.27's ZMATCH/ZNMATCH rows permit B/H elements, P0..P7 as the
+	// governing predicate, and all P destinations. The first encoding is
+	// independently checked against LLVM MC and occurs in lightning.
+	const observedMatch = uint32(0x45218402)
+	var source strings.Builder
+	source.WriteString("TEXT rawSVECharacterMatch(SB),$0-0\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", observedMatch)
+	for _, notMatch := range []bool{false, true} {
+		for _, halfword := range []bool{false, true} {
+			word := uint32(0x45208000) | 30<<16 | 31<<5 | 7<<10 | 15
+			if notMatch {
+				word |= 1 << 4
+			}
+			if halfword {
+				word |= 1 << 22
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVECharacterMatch": {Name: "rawSVECharacterMatch", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.match.nxv16i8",
+				"@llvm.aarch64.sve.match.nxv8i16",
+				"@llvm.aarch64.sve.nmatch.nxv16i8",
+				"@llvm.aarch64.sve.nmatch.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw SVE character-match IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-character-match.ll", "arm64-raw-sve-character-match.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVECharacterMatchBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		word uint32
+		op   Op
+		args []Reg
+	}{
+		{
+			name: "lightning-match-byte",
+			word: 0x45218402,
+			op:   "ZMATCH",
+			args: []Reg{"Z1.B", "Z0.B", "P1.Z", "P2.B"},
+		},
+		{
+			name: "nmatch-halfword-high-registers",
+			word: 0x457e9fff,
+			op:   "ZNMATCH",
+			args: []Reg{"Z30.H", "Z31.H", "P7.Z", "P15.H"},
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ins, ok := decodeARM64RawSVECharacterMatch(test.word)
+			if !ok || ins.Op != test.op || len(ins.Args) != len(test.args) {
+				t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+			}
+			for index, want := range test.args {
+				if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+					t.Errorf("operand %d = %+v, want %s", index, ins.Args[index], want)
+				}
+			}
+		})
+	}
+	for _, word := range []uint32{
+		0x45208000 ^ (1 << 15), // fixed one bit
+		0x45208000 | (1 << 13), // reserved bit
+		0x45208000 | (1 << 23), // adjacent instruction class
+	} {
+		if ins, ok := decodeARM64RawSVECharacterMatch(word); ok {
+			t.Errorf("decoded reserved encoding %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVECharacterMatchRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZMATCH Z1.S, Z2.S, P0.Z, P1.S",
+		"ZNMATCH Z1.D, Z2.D, P0.Z, P1.D",
+		"ZMATCH Z1.B, Z2.H, P0.Z, P1.B",
+		"ZNMATCH Z1.H, Z2.H, P8.Z, P1.H",
+		"ZMATCH Z1.B, Z2.B, P0.M, P1.B",
+		"ZNMATCH Z1.H, Z2.H, P0.Z, P1.B",
+		"ZMATCH.Z Z1.B, Z2.B, P0.Z, P1.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecharactermatch(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecharactermatch": {Name: "badsvecharactermatch", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's character-match forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_clamp.go b/arm64_lower_sve_clamp.go
new file mode 100644
index 000000000..214637964
--- /dev/null
+++ b/arm64_lower_sve_clamp.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEClampKind uint8
+
+const (
+	arm64SVEClampInteger arm64SVEClampKind = iota
+	arm64SVEClampFloat
+	arm64SVEClampBFloat
+)
+
+type arm64SVEClampSpec struct {
+	intrinsic string
+	kind      arm64SVEClampKind
+}
+
+var arm64SVEClampSpecs = map[Op]arm64SVEClampSpec{
+	"ZSCLAMP":  {intrinsic: "sclamp", kind: arm64SVEClampInteger},
+	"ZUCLAMP":  {intrinsic: "uclamp", kind: arm64SVEClampInteger},
+	"ZFCLAMP":  {intrinsic: "fclamp", kind: arm64SVEClampFloat},
+	"ZBFCLAMP": {intrinsic: "fclamp", kind: arm64SVEClampBFloat},
+}
+
+func (c *arm64Ctx) lowerARM64SVEClamp(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEClampSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zn.T, Zd.T without a suffix: %q", op, ins.Raw)
+	}
+	maximum, maximumBits, maximumOK := arm64ParseSVEZElementReg(ins.Args[0])
+	minimum, minimumBits, minimumOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !maximumOK || !minimumOK || !destinationOK || maximumBits != destinationBits || minimumBits != destinationBits || !arm64SVEClampWidthOK(spec.kind, destinationBits) {
+		return true, false, fmt.Errorf("arm64 %s has invalid or mismatched element widths: %q", op, ins.Raw)
+	}
+
+	switch spec.kind {
+	case arm64SVEClampInteger:
+		return true, false, c.lowerARM64SVEIntegerClamp(spec, destinationBits, destination, minimum, maximum)
+	case arm64SVEClampFloat:
+		return true, false, c.lowerARM64SVEFloatClamp(spec, destinationBits, destination, minimum, maximum)
+	case arm64SVEClampBFloat:
+		return true, false, c.lowerARM64SVEBFloatClamp(spec, destination, minimum, maximum)
+	default:
+		return true, false, fmt.Errorf("arm64 %s has an unknown clamp kind", op)
+	}
+}
+
+func arm64SVEClampWidthOK(kind arm64SVEClampKind, bits int) bool {
+	switch kind {
+	case arm64SVEClampInteger:
+		return bits == 8 || bits == 16 || bits == 32 || bits == 64
+	case arm64SVEClampFloat:
+		return bits == 16 || bits == 32 || bits == 64
+	case arm64SVEClampBFloat:
+		return bits == 16
+	default:
+		return false
+	}
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerClamp(spec arm64SVEClampSpec, bits, destination, minimum, maximum int) error {
+	value, vectorType, err := c.loadZRegElements(destination, bits)
+	if err != nil {
+		return err
+	}
+	minimumValue, _, err := c.loadZRegElements(minimum, bits)
+	if err != nil {
+		return err
+	}
+	maximumValue, _, err := c.loadZRegElements(maximum, bits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / bits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, bits, vectorType, value, vectorType, minimumValue, vectorType, maximumValue)
+	return c.storeZRegElements(destination, bits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatClamp(spec arm64SVEClampSpec, bits, destination, minimum, maximum int) error {
+	value, vectorType, err := c.loadRawSVEFloatVector(destination, bits)
+	if err != nil {
+		return err
+	}
+	minimumValue, _, err := c.loadRawSVEFloatVector(minimum, bits)
+	if err != nil {
+		return err
+	}
+	maximumValue, _, err := c.loadRawSVEFloatVector(maximum, bits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / bits
+	suffix := map[int]string{16: "f16", 32: "f32", 64: "f64"}[bits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, suffix, vectorType, value, vectorType, minimumValue, vectorType, maximumValue)
+	return c.storeRawSVEFloatVector(destination, bits, "%"+result, vectorType)
+}
+
+func (c *arm64Ctx) lowerARM64SVEBFloatClamp(spec arm64SVEClampSpec, destination, minimum, maximum int) error {
+	integerType := "<vscale x 8 x i16>"
+	vectorType := "<vscale x 8 x bfloat>"
+	values := make([]string, 3)
+	for i, reg := range []int{destination, minimum, maximum} {
+		integerValue, _, err := c.loadZRegElements(reg, 16)
+		if err != nil {
+			return err
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", converted, integerType, integerValue, vectorType)
+		values[i] = "%" + converted
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv8bf16(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, vectorType, values[0], vectorType, values[1], vectorType, values[2])
+	integerResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", integerResult, vectorType, result, integerType)
+	return c.storeZRegElements(destination, 16, "%"+integerResult)
+}
diff --git a/arm64_lower_sve_clamp_test.go b/arm64_lower_sve_clamp_test.go
new file mode 100644
index 000000000..45880d9db
--- /dev/null
+++ b/arm64_lower_sve_clamp_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEClampCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveclampforms(SB),$0-0\n")
+	for _, op := range []string{"ZSCLAMP", "ZUCLAMP"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+		}
+	}
+	for _, width := range []string{"H", "S", "D"} {
+		source.WriteString("\tZFCLAMP Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+	}
+	source.WriteString("\tZBFCLAMP Z1.H, Z2.H, Z3.H\n")
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEClampCompleteGo127Family(t *testing.T) {
+	source := arm64SVEClampCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveclampforms": {Name: "sveclampforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve-b16b16,+sve2p1"`,
+				"@llvm.aarch64.sve.sclamp.nxv16i8",
+				"@llvm.aarch64.sve.uclamp.nxv2i64",
+				"@llvm.aarch64.sve.fclamp.nxv8f16",
+				"@llvm.aarch64.sve.fclamp.nxv4f32",
+				"@llvm.aarch64.sve.fclamp.nxv2f64",
+				"@llvm.aarch64.sve.fclamp.nxv8bf16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE clamp lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-clamp.ll", "arm64-sve-clamp.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEClampRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSCLAMP Z1.B, Z2.H, Z3.B",
+		"ZUCLAMP Z1.Q, Z2.Q, Z3.Q",
+		"ZFCLAMP Z1.B, Z2.B, Z3.B",
+		"ZBFCLAMP Z1.S, Z2.S, Z3.S",
+		"ZFCLAMP Z1.S, Z2.S",
+		"ZSCLAMP.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveclamp(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveclamp": {Name: "badsveclamp", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE clamp forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_clast.go b/arm64_lower_sve_clast.go
new file mode 100644
index 000000000..3e9ef7a7c
--- /dev/null
+++ b/arm64_lower_sve_clast.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVECLastDestination uint8
+
+const (
+	arm64SVECLastGeneric arm64SVECLastDestination = iota
+	arm64SVECLastGPR
+	arm64SVECLastVReg
+)
+
+type arm64SVECLastSpec struct {
+	intrinsic   string
+	baseSize    int
+	destination arm64SVECLastDestination
+}
+
+var arm64SVECLastSpecs = map[Op]arm64SVECLastSpec{
+	"ZCLASTA":  {intrinsic: "clasta", destination: arm64SVECLastGeneric},
+	"ZCLASTAW": {intrinsic: "clasta", destination: arm64SVECLastGPR},
+	"ZCLASTAB": {intrinsic: "clasta", destination: arm64SVECLastVReg},
+	"ZCLASTAH": {intrinsic: "clasta", baseSize: 1, destination: arm64SVECLastVReg},
+	"ZCLASTAS": {intrinsic: "clasta", baseSize: 2, destination: arm64SVECLastVReg},
+	"ZCLASTAD": {intrinsic: "clasta", baseSize: 3, destination: arm64SVECLastVReg},
+	"ZCLASTB":  {intrinsic: "clastb", destination: arm64SVECLastGeneric},
+	"ZCLASTBW": {intrinsic: "clastb", destination: arm64SVECLastGPR},
+	"ZCLASTBB": {intrinsic: "clastb", destination: arm64SVECLastVReg},
+	"ZCLASTBH": {intrinsic: "clastb", baseSize: 1, destination: arm64SVECLastVReg},
+	"ZCLASTBS": {intrinsic: "clastb", baseSize: 2, destination: arm64SVECLastVReg},
+	"ZCLASTBD": {intrinsic: "clastb", baseSize: 3, destination: arm64SVECLastVReg},
+}
+
+func (c *arm64Ctx) lowerARM64SVECLast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVECLastSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects source, old destination, Pg, destination without a suffix: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[2], 7)
+	if !sourceOK || !predicateOK {
+		return true, false, fmt.Errorf("arm64 %s requires a Z source and P0..P7: %q", op, ins.Raw)
+	}
+	sourceSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[sourceBits]
+
+	destinationKind := spec.destination
+	oldVector, oldBits, oldVectorOK := arm64ParseSVEZElementReg(ins.Args[1])
+	newVector, newBits, newVectorOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if destinationKind == arm64SVECLastGeneric && oldVectorOK && newVectorOK {
+		if oldVector != newVector {
+			return true, false, fmt.Errorf("arm64 %s vector destination must be destructive: %q", op, ins.Raw)
+		}
+		elementBits := 8 << (sourceSize |
+			map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[oldBits] |
+			map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[newBits])
+		return true, false, c.lowerARM64SVECLastVector(spec.intrinsic, source, predicate, oldVector, elementBits)
+	}
+	if destinationKind == arm64SVECLastGeneric {
+		destinationKind = arm64SVECLastGPR
+		spec.baseSize = 3
+	}
+	elementBits := 8 << (spec.baseSize | sourceSize)
+	if destinationKind == arm64SVECLastGPR {
+		if !arm64SVEIndexScalarRegister(ins.Args[1]) || !arm64SVEIndexScalarRegister(ins.Args[3]) || ins.Args[1].Reg != ins.Args[3].Reg {
+			return true, false, fmt.Errorf("arm64 %s GP destination must be the same R0..R30 or ZR operand twice: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerARM64SVECLastScalar(spec.intrinsic, source, predicate, ins.Args[1].Reg, elementBits, false)
+	}
+	oldDestination, oldOK := arm64SVEInsertVRegister(ins.Args[1])
+	newDestination, newOK := arm64SVEInsertVRegister(ins.Args[3])
+	if !oldOK || !newOK || oldDestination != newDestination {
+		return true, false, fmt.Errorf("arm64 %s SIMD destination must be the same V0..V31 operand twice: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVECLastScalar(spec.intrinsic, source, predicate, oldDestination, elementBits, true)
+}
+
+func (c *arm64Ctx) lowerARM64SVECLastVector(intrinsic string, source, predicate, destination, elementBits int) error {
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return err
+	}
+	oldValue, vectorType, err := c.loadZRegElements(destination, elementBits)
+	if err != nil {
+		return err
+	}
+	sourceValue, _, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, intrinsic, lanes, elementBits, predicateType, predicateValue, vectorType, oldValue, vectorType, sourceValue)
+	return c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVECLastScalar(intrinsic string, source, predicate int, destination Reg, elementBits int, vectorDestination bool) error {
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return err
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return err
+	}
+	var oldValue string
+	if vectorDestination {
+		oldValue, err = c.arm64SVEInsertVectorScalar(destination, elementBits)
+	} else {
+		oldValue, err = c.loadReg(destination)
+		if err == nil && elementBits != 64 && oldValue != "0" {
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, oldValue, elementBits)
+			oldValue = "%" + truncated
+		}
+	}
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.aarch64.sve.%s.n.nxv%di%d(%s %s, i%d %s, %s %s)\n",
+		result, elementBits, intrinsic, lanes, elementBits, predicateType, predicateValue, elementBits, oldValue, vectorType, sourceValue)
+	if vectorDestination {
+		return c.storeARM64ScalarToVReg(destination, elementBits, "%"+result)
+	}
+	value := "%" + result
+	if elementBits != 64 {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", extended, elementBits, value)
+		value = "%" + extended
+	}
+	return c.storeReg(destination, value)
+}
diff --git a/arm64_lower_sve_clast_test.go b/arm64_lower_sve_clast_test.go
new file mode 100644
index 000000000..246e4fb16
--- /dev/null
+++ b/arm64_lower_sve_clast_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVECLastCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveclastforms(SB),$0-0\n")
+	for _, selector := range []string{"A", "B"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\tZCLAST%s Z1.%s, Z2.%s, P0, Z2.%s\n", selector, width, width, width)
+			fmt.Fprintf(&source, "\tZCLAST%s Z3.%s, R4, P1, R4\n", selector, width)
+			fmt.Fprintf(&source, "\tZCLAST%sW Z5.%s, R6, P2, R6\n", selector, width)
+			fmt.Fprintf(&source, "\tZCLAST%sB Z7.%s, V8, P3, V8\n", selector, width)
+			fmt.Fprintf(&source, "\tZCLAST%sH Z9.%s, V10, P4, V10\n", selector, width)
+			fmt.Fprintf(&source, "\tZCLAST%sS Z11.%s, V12, P5, V12\n", selector, width)
+			fmt.Fprintf(&source, "\tZCLAST%sD Z13.%s, V14, P7, V14\n", selector, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVECLastCompleteGo127Family(t *testing.T) {
+	source := arm64SVECLastCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveclastforms": {Name: "sveclastforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.clasta.nxv16i8",
+				"@llvm.aarch64.sve.clasta.n.nxv8i16",
+				"@llvm.aarch64.sve.clastb.nxv4i32",
+				"@llvm.aarch64.sve.clastb.n.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE CLAST lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-clast.ll", "arm64-sve-clast.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVECLastRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCLASTA Z0.D, Z1.D, P0, Z2.D",
+		"ZCLASTB Z0.D, R1, P0, R2",
+		"ZCLASTAW Z0.S, V1, P0, V1",
+		"ZCLASTBW Z0.S, RSP, P0, RSP",
+		"ZCLASTAB Z0.B, R1, P0, R1",
+		"ZCLASTBH Z0.H, V1, P8, V1",
+		"ZCLASTAS Z0.S, V1, P0.M, V1",
+		"ZCLASTBD Z0.Q, V1, P0, V1",
+		"ZCLASTA.Z Z0.D, R1, P0, R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveclast(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveclast": {Name: "badsveclast", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE CLAST forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_compact.go b/arm64_lower_sve_compact.go
new file mode 100644
index 000000000..f7b62e625
--- /dev/null
+++ b/arm64_lower_sve_compact.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func decodeARM64RawSVECompact(word uint32) (Instr, bool) {
+	// The B/H (SVE2.2) and S/D (SVE) rows differ only in size[23:22].
+	if word&0xff3fe000 != 0x05218000 {
+		return Instr{}, false
+	}
+	width := "BHSD"[word>>22&3]
+	return Instr{Op: "ZCOMPACT", Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", word>>10&7))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))},
+	}}, true
+}
+
+func arm64SVECompactNeedsSVE2P2(ins Instr) bool {
+	if len(ins.Args) != 3 {
+		return false
+	}
+	_, bits, ok := arm64ParseSVEZElementReg(ins.Args[0])
+	return ok && bits <= 16
+}
+
+func (c *arm64Ctx) lowerARM64SVECompact(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZCOMPACT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZCOMPACT expects Zn.T, Pg, Zd.T without a suffix: %q", ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !predicateOK || !destinationOK || sourceBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 ZCOMPACT requires matching B/H/S/D vectors and P0..P7: %q", ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.compact.nxv%di%d(%s %s, %s %s)\n",
+		result, vectorType, lanes, sourceBits, predicateType, predicateValue, vectorType, sourceValue)
+	return true, false, c.storeZRegElements(destination, sourceBits, "%"+result)
+}
diff --git a/arm64_lower_sve_compact_test.go b/arm64_lower_sve_compact_test.go
new file mode 100644
index 000000000..451d243ba
--- /dev/null
+++ b/arm64_lower_sve_compact_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVECompactCompleteGo127Family(t *testing.T) {
+	source := "TEXT svecompactforms(SB),$0-0\n" +
+		"\tZCOMPACT Z0.B, P0, Z4.B\n" +
+		"\tZCOMPACT Z1.H, P1, Z5.H\n" +
+		"\tZCOMPACT Z2.S, P2, Z6.S\n" +
+		"\tZCOMPACT Z3.D, P7, Z7.D\n" +
+		"\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecompactforms": {Name: "svecompactforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2p2\"",
+				"@llvm.aarch64.sve.compact.nxv16i8",
+				"@llvm.aarch64.sve.compact.nxv8i16",
+				"@llvm.aarch64.sve.compact.nxv4i32",
+				"@llvm.aarch64.sve.compact.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE COMPACT lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-compact.ll", "arm64-sve-compact.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVECompactRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCOMPACT Z0.B, P0, Z1.H",
+		"ZCOMPACT Z0.H, P0, Z1.B",
+		"ZCOMPACT Z0.S, P8, Z1.S",
+		"ZCOMPACT Z0.D, P0.M, Z1.D",
+		"ZCOMPACT Z0.Q, P0, Z1.Q",
+		"ZCOMPACT.Z Z0.D, P0, Z1.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecompact(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecompact": {Name: "badsvecompact", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE COMPACT forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_compare.go b/arm64_lower_sve_compare.go
new file mode 100644
index 000000000..20c82264c
--- /dev/null
+++ b/arm64_lower_sve_compare.go
@@ -0,0 +1,338 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVECompareSpec struct {
+	predicate   string
+	floating    bool
+	absolute    bool
+	allowReg    bool
+	allowImm    bool
+	unsignedImm bool
+	wideOnly    bool
+	rawBase     uint32
+	rawImmBase  uint32
+}
+
+var arm64SVECompareSpecs = map[Op]arm64SVECompareSpec{
+	"ZCMPEQ": {predicate: "eq", allowReg: true, allowImm: true},
+	"ZCMPGE": {predicate: "sge", allowReg: true, allowImm: true},
+	"ZCMPGT": {predicate: "sgt", allowReg: true, allowImm: true},
+	"ZCMPHI": {predicate: "ugt", allowReg: true, allowImm: true, unsignedImm: true},
+	"ZCMPHS": {predicate: "uge", allowReg: true, allowImm: true, unsignedImm: true},
+	"ZCMPLE": {predicate: "sle", allowReg: true, allowImm: true, wideOnly: true},
+	"ZCMPLO": {predicate: "ult", allowReg: true, allowImm: true, unsignedImm: true, wideOnly: true},
+	"ZCMPLS": {predicate: "ule", allowReg: true, allowImm: true, unsignedImm: true, wideOnly: true},
+	"ZCMPLT": {predicate: "slt", allowReg: true, allowImm: true, wideOnly: true},
+	"ZCMPNE": {predicate: "ne", allowReg: true, allowImm: true},
+	"ZFACGE": {predicate: "oge", floating: true, absolute: true, allowReg: true, rawBase: 0x6500c010},
+	"ZFACGT": {predicate: "ogt", floating: true, absolute: true, allowReg: true, rawBase: 0x6500e010},
+	"ZFCMEQ": {predicate: "oeq", floating: true, allowReg: true, allowImm: true, rawBase: 0x65006000, rawImmBase: 0x65122000},
+	"ZFCMGE": {predicate: "oge", floating: true, allowReg: true, allowImm: true, rawBase: 0x65004000, rawImmBase: 0x65102000},
+	"ZFCMGT": {predicate: "ogt", floating: true, allowReg: true, allowImm: true, rawBase: 0x65004010, rawImmBase: 0x65102010},
+	"ZFCMLE": {predicate: "ole", floating: true, allowImm: true, rawImmBase: 0x65112010},
+	"ZFCMLT": {predicate: "olt", floating: true, allowImm: true, rawImmBase: 0x65112000},
+	"ZFCMNE": {predicate: "une", floating: true, allowReg: true, allowImm: true, rawBase: 0x65006010, rawImmBase: 0x65132000},
+	"ZFCMUO": {predicate: "uno", floating: true, allowReg: true, rawBase: 0x6500c000},
+}
+
+func decodeARM64RawSVEFloatCompare(word uint32) (Instr, bool) {
+	size := word >> 22 & 3
+	if size == 0 {
+		return Instr{}, false
+	}
+	for op, spec := range arm64SVECompareSpecs {
+		if !spec.floating {
+			continue
+		}
+		regular := spec.allowReg && word&^uint32(0x00df1fef) == spec.rawBase
+		immediate := spec.allowImm && word&^uint32(0x00c01fef) == spec.rawImmBase
+		if !regular && !immediate {
+			continue
+		}
+		width := "BHSD"[size]
+		second := Operand{Kind: OpImm, ImmIsFloat: true}
+		if regular {
+			second = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>16&31, width))}
+		}
+		return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+			second,
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", word>>10&7))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%c", word&15, width))},
+		}}, true
+	}
+	return Instr{}, false
+}
+
+// decodeARM64RawSVEIntegerCompare covers every Go 1.27 integer compare row.
+// LE/LO/LS/LT have only immediate and wide-vector forms; the other six also
+// have ordinary same-width vector forms.
+func decodeARM64RawSVEIntegerCompare(word uint32) (Instr, bool) {
+	const (
+		wideBits        = uint32(0x00df1fef)
+		unsignedImmBits = uint32(0x00dfdfef)
+	)
+	forms := [...]struct {
+		op          Op
+		wideBase    uint32
+		regularBase uint32
+		immBase     uint32
+		unsigned    bool
+		regular     bool
+	}{
+		{"ZCMPEQ", 0x24002000, 0x2400a000, 0x25008000, false, true},
+		{"ZCMPGE", 0x24004000, 0x24008000, 0x25000000, false, true},
+		{"ZCMPGT", 0x24004010, 0x24008010, 0x25000010, false, true},
+		{"ZCMPHI", 0x2400c010, 0x24000010, 0x24200010, true, true},
+		{"ZCMPHS", 0x2400c000, 0x24000000, 0x24200000, true, true},
+		{"ZCMPLE", 0x24006010, 0, 0x25002010, false, false},
+		{"ZCMPLO", 0x2400e000, 0, 0x24202000, true, false},
+		{"ZCMPLS", 0x2400e010, 0, 0x24202010, true, false},
+		{"ZCMPLT", 0x24006000, 0, 0x25002000, false, false},
+		{"ZCMPNE", 0x24002010, 0x2400a010, 0x25008010, false, true},
+	}
+	for _, form := range forms {
+		immediateBits := wideBits
+		if form.unsigned {
+			immediateBits = unsignedImmBits
+		}
+		wide := word&^wideBits == form.wideBase
+		regular := form.regular && word&^wideBits == form.regularBase
+		immediate := word&^immediateBits == form.immBase
+		if !wide && !regular && !immediate {
+			continue
+		}
+		size := int(word>>22) & 3
+		if wide && size == 3 {
+			return Instr{}, false
+		}
+		width := [...]string{"B", "H", "S", "D"}[size]
+		first := int(word>>5) & 31
+		governing := int(word>>10) & 7
+		destination := int(word) & 15
+		args := make([]Operand, 0, 4)
+		if wide {
+			second := int(word>>16) & 31
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.D", second))})
+		} else if regular {
+			second := int(word>>16) & 31
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", second, width))})
+		} else {
+			value := int64(word >> 16 & 31)
+			if form.unsigned {
+				value = int64(word >> 14 & 127)
+			} else if value >= 16 {
+				value -= 32
+			}
+			args = append(args, Operand{Kind: OpImm, Imm: value})
+		}
+		args = append(args,
+			Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", first, width))},
+			Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", governing))},
+			Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", destination, width))},
+		)
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func arm64ParseSVEPredicateMode(operand Operand, mode string, maximum int) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || parts[1] != mode || !strings.HasPrefix(parts[0], "P") {
+		return 0, false
+	}
+	var index int
+	if _, err := fmt.Sscanf(parts[0], "P%d", &index); err != nil || index < 0 || index > maximum {
+		return 0, false
+	}
+	return index, true
+}
+
+func arm64ParseSVEPredicateBare(operand Operand, maximum int) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if strings.Contains(text, ".") || !strings.HasPrefix(text, "P") {
+		return 0, false
+	}
+	var index int
+	if _, err := fmt.Sscanf(text, "P%d", &index); err != nil || index < 0 || index > maximum {
+		return 0, false
+	}
+	return index, true
+}
+
+func arm64ParseSVEPredicateElement(operand Operand) (index, elementBits int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || !strings.HasPrefix(parts[0], "P") {
+		return 0, 0, false
+	}
+	if _, err := fmt.Sscanf(parts[0], "P%d", &index); err != nil || index < 0 || index > 15 {
+		return 0, 0, false
+	}
+	elementBits, ok = map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[parts[1]]
+	return index, elementBits, ok
+}
+
+type arm64SVECompareForm struct {
+	op           Op
+	elementBits  int
+	first        int
+	second       int
+	predicate    int
+	destination  int
+	immediate    int64
+	hasImmediate bool
+	wide         bool
+}
+
+func (c *arm64Ctx) lowerARM64SVECompare(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVECompareSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects one of its four-operand Go 1.27 SVE compare forms: %q", op, ins.Raw)
+	}
+	parseElement := arm64ParseSVEZElementReg
+	if spec.floating {
+		parseElement = arm64SVEFloatElementReg
+	}
+	first, firstBits, firstOK := parseElement(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "Z", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[3])
+	if !firstOK || !predicateOK || !destinationOK || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s compare data, governing predicate, and result widths do not match: %q", op, ins.Raw)
+	}
+	form := arm64SVECompareForm{op: op, elementBits: firstBits, first: first, predicate: predicate, destination: destination}
+	if ins.Args[0].Kind == OpImm {
+		if !spec.allowImm || ins.Args[0].ImmRaw != "" {
+			return true, false, fmt.Errorf("arm64 %s does not accept this immediate compare form: %q", op, ins.Raw)
+		}
+		if spec.floating {
+			if !ins.Args[0].ImmIsFloat || uint64(ins.Args[0].Imm) != 0 {
+				return true, false, fmt.Errorf("arm64 %s floating immediate must be $(0.0): %q", op, ins.Raw)
+			}
+		} else if ins.Args[0].ImmIsFloat || (!spec.unsignedImm && (ins.Args[0].Imm < -16 || ins.Args[0].Imm > 15)) || (spec.unsignedImm && (ins.Args[0].Imm < 0 || ins.Args[0].Imm > 127)) {
+			return true, false, fmt.Errorf("arm64 %s integer immediate is outside its Go 1.27 range: %q", op, ins.Raw)
+		}
+		form.hasImmediate = true
+		form.immediate = ins.Args[0].Imm
+	} else {
+		if !spec.allowReg {
+			return true, false, fmt.Errorf("arm64 %s does not accept a vector compare source: %q", op, ins.Raw)
+		}
+		second, secondBits, secondOK := parseElement(ins.Args[0])
+		if !secondOK {
+			return true, false, fmt.Errorf("arm64 %s compare source is not a valid scalable vector: %q", op, ins.Raw)
+		}
+		if spec.wideOnly && (firstBits == 64 || secondBits != 64) {
+			return true, false, fmt.Errorf("arm64 %s only accepts a .D source over B/H/S vectors: %q", op, ins.Raw)
+		}
+		if secondBits == firstBits {
+			form.second = second
+		} else if !spec.floating && secondBits == 64 && firstBits < 64 {
+			form.second = second
+			form.wide = true
+		} else {
+			return true, false, fmt.Errorf("arm64 %s compare vector widths do not match a regular or wide form: %q", op, ins.Raw)
+		}
+	}
+	return true, false, c.lowerARM64SVECompareForm(spec, form)
+}
+
+func (c *arm64Ctx) lowerARM64SVECompareForm(spec arm64SVECompareSpec, form arm64SVECompareForm) error {
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	if form.wide {
+		first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+		if err != nil {
+			return err
+		}
+		second, wideType, err := c.loadZRegElements(form.second, 64)
+		if err != nil {
+			return err
+		}
+		intrinsic := strings.ToLower(strings.TrimPrefix(string(form.op), "Z"))
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.wide.nxv%di%d(%s %s, %s %s, %s %s)\n", result, predicateType, intrinsic, 128/form.elementBits, form.elementBits, predicateType, predicate, vectorType, first, wideType, second)
+		return c.storePRegElements(form.destination, form.elementBits, "%"+result)
+	}
+
+	var first, second, vectorType string
+	if spec.floating {
+		first, vectorType, err = c.loadRawSVEFloatVector(form.first, form.elementBits)
+		if err != nil {
+			return err
+		}
+		if form.hasImmediate {
+			second = "zeroinitializer"
+		} else {
+			second, _, err = c.loadRawSVEFloatVector(form.second, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+		if spec.absolute {
+			first, err = c.arm64SVEFloatAbsolute(first, form.elementBits)
+			if err != nil {
+				return err
+			}
+			second, err = c.arm64SVEFloatAbsolute(second, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+	} else {
+		first, vectorType, err = c.loadZRegElements(form.first, form.elementBits)
+		if err != nil {
+			return err
+		}
+		if form.hasImmediate {
+			second = fmt.Sprintf("splat (i%d %d)", form.elementBits, form.immediate)
+		} else {
+			second, _, err = c.loadZRegElements(form.second, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	compared := c.newTmp()
+	operation := "icmp"
+	if spec.floating {
+		operation = "fcmp"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s %s, %s\n", compared, operation, spec.predicate, vectorType, first, second)
+	active := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", active, predicateType, compared, predicate)
+	return c.storePRegElements(form.destination, form.elementBits, "%"+active)
+}
+
+func (c *arm64Ctx) arm64SVEFloatAbsolute(value string, elementBits int) (string, error) {
+	integerType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return "", err
+	}
+	floatingType := fmt.Sprintf("<vscale x %d x %s>", lanes, map[int]string{16: "half", 32: "float", 64: "double"}[elementBits])
+	bits := c.newTmp()
+	cleared := c.newTmp()
+	result := c.newTmp()
+	mask := uint64(1)<<(elementBits-1) - 1
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", bits, floatingType, value, integerType)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, splat (i%d %d)\n", cleared, integerType, bits, elementBits, mask)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", result, integerType, cleared, floatingType)
+	return "%" + result, nil
+}
diff --git a/arm64_lower_sve_compare_test.go b/arm64_lower_sve_compare_test.go
new file mode 100644
index 000000000..b75844b0a
--- /dev/null
+++ b/arm64_lower_sve_compare_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVECompareCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svecompareforms(SB),$0-0\n")
+	for _, op := range []string{"ZCMPEQ", "ZCMPGE", "ZCMPGT", "ZCMPHI", "ZCMPHS", "ZCMPNE"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", P" + predicate + ".Z, P12." + width + "\n")
+		}
+		for index, width := range []string{"B", "H", "S"} {
+			predicate := string(rune('4' + index))
+			source.WriteString("\t" + op + " Z3.D, Z4." + width + ", P" + predicate + ".Z, P13." + width + "\n")
+		}
+		for index, width := range []string{"B", "H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			immediate := "-16"
+			if op == "ZCMPHI" || op == "ZCMPHS" {
+				immediate = "127"
+			}
+			source.WriteString("\t" + op + " $" + immediate + ", Z5." + width + ", P" + predicate + ".Z, P14." + width + "\n")
+		}
+	}
+	for _, op := range []string{"ZCMPLE", "ZCMPLO", "ZCMPLS", "ZCMPLT"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			if width != "D" {
+				source.WriteString("\t" + op + " Z3.D, Z4." + width + ", P" + predicate + ".Z, P13." + width + "\n")
+			}
+			immediate := "-16"
+			if op == "ZCMPLO" || op == "ZCMPLS" {
+				immediate = "127"
+			}
+			source.WriteString("\t" + op + " $" + immediate + ", Z5." + width + ", P" + predicate + ".Z, P14." + width + "\n")
+		}
+	}
+	for _, op := range []string{"ZFACGE", "ZFACGT", "ZFCMEQ", "ZFCMGE", "ZFCMGT", "ZFCMNE", "ZFCMUO"} {
+		for index, width := range []string{"H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			source.WriteString("\t" + op + " Z6." + width + ", Z7." + width + ", P" + predicate + ".Z, P15." + width + "\n")
+		}
+	}
+	for _, op := range []string{"ZFCMEQ", "ZFCMGE", "ZFCMGT", "ZFCMLE", "ZFCMLT", "ZFCMNE"} {
+		for index, width := range []string{"H", "S", "D"} {
+			predicate := string(rune('4' + index))
+			source.WriteString("\t" + op + " $(0.0), Z8." + width + ", P" + predicate + ".Z, P11." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVECompareCompleteGo127Family(t *testing.T) {
+	source := arm64SVECompareCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecompareforms": {Name: "svecompareforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, " icmp ", " fcmp ", "@llvm.aarch64.sve.cmpeq.wide.nxv", "@llvm.aarch64.sve.cmplo.wide.nxv", "@llvm.aarch64.sve.convert.to.svbool"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE compare lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-compare.ll", "arm64-sve-compare.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEReverseCompareCompleteFamily(t *testing.T) {
+	forms := []struct {
+		wideBase uint32
+		immBase  uint32
+		imm      uint32
+	}{
+		{0x24006010, 0x25002010, 16}, // LE: -16
+		{0x2400e000, 0x24202000, 127},
+		{0x2400e010, 0x24202010, 127},
+		{0x24006000, 0x25002000, 16}, // LT: -16
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEReverseCompare(SB),$0-0\n")
+	source.WriteString("\tWORD $0x24282403\n") // lightning: CMPLO P3.B, P1/Z, Z0.B, #32
+	for _, form := range forms {
+		for size := uint32(0); size < 4; size++ {
+			var immediate uint32
+			if form.immBase&0x00200000 != 0 {
+				immediate = form.imm << 14
+			} else {
+				immediate = form.imm << 16
+			}
+			word := form.immBase | size<<22 | immediate | 1<<10 | 2<<5 | 3
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			if size < 3 {
+				word = form.wideBase | size<<22 | 4<<16 | 1<<10 | 2<<5 | 3
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEReverseCompare": {Name: "rawSVEReverseCompare", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.cmple.wide.nxv",
+				"@llvm.aarch64.sve.cmplo.wide.nxv",
+				"@llvm.aarch64.sve.cmpls.wide.nxv",
+				"@llvm.aarch64.sve.cmplt.wide.nxv",
+				" icmp sle ", " icmp slt ", " icmp ule ", " icmp ult ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw reverse compare IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-reverse-compare.ll", "arm64-raw-sve-reverse-compare.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEIntegerCompareCompleteFamily(t *testing.T) {
+	// Six ordinary integer comparisons have regular-vector, wide-vector,
+	// and immediate rows in Go 1.27. gocc emits CMPNE 0x2400a031;
+	// lightning emits CMPHS immediate 0x24380483.
+	forms := []struct {
+		wideBase    uint32
+		regularBase uint32
+		immBase     uint32
+		unsigned    bool
+	}{
+		{0x24002000, 0x2400a000, 0x25008000, false},
+		{0x24004000, 0x24008000, 0x25000000, false},
+		{0x24004010, 0x24008010, 0x25000010, false},
+		{0x2400c010, 0x24000010, 0x24200010, true},
+		{0x2400c000, 0x24000000, 0x24200000, true},
+		{0x24002010, 0x2400a010, 0x25008010, false},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEIntegerCompare(SB),$0-0\n")
+	source.WriteString("\tWORD $0x2400a031\n")
+	source.WriteString("\tWORD $0x24380483\n")
+	for _, form := range forms {
+		for size := uint32(0); size < 4; size++ {
+			registers := size<<22 | 4<<16 | 1<<10 | 2<<5 | 3
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", form.regularBase|registers)
+			if size < 3 {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", form.wideBase|registers)
+			}
+			immediate := uint32(16 << 16) // signed -16
+			if form.unsigned {
+				immediate = 127 << 14
+			}
+			word := form.immBase | size<<22 | immediate | 1<<10 | 2<<5 | 3
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEIntegerCompare": {Name: "rawSVEIntegerCompare", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.cmpeq.wide.nxv",
+				"@llvm.aarch64.sve.cmpne.wide.nxv",
+				" icmp eq ", " icmp ne ", " icmp uge ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw integer compare IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-integer-compare.ll", "arm64-raw-sve-integer-compare.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEIntegerCompareBoundaries(t *testing.T) {
+	observed, ok := decodeARM64RawSVEIntegerCompare(0x24282403)
+	if !ok || observed.Op != "ZCMPLO" || len(observed.Args) != 4 {
+		t.Fatalf("decode lightning CMPLO = %+v, %v", observed, ok)
+	}
+	if observed.Args[0].Kind != OpImm || observed.Args[0].Imm != 32 ||
+		observed.Args[1].Reg != "Z0.B" || observed.Args[2].Reg != "P1.Z" ||
+		observed.Args[3].Reg != "P3.B" {
+		t.Fatalf("lightning CMPLO operands = %+v", observed.Args)
+	}
+	for _, test := range []struct {
+		word uint32
+		op   Op
+		args []Reg
+		imm  int64
+	}{
+		{0x2400a031, "ZCMPNE", []Reg{"Z0.B", "Z1.B", "P0.Z", "P1.B"}, 0},
+		{0x24380483, "ZCMPHS", []Reg{"", "Z4.B", "P1.Z", "P3.B"}, 96},
+	} {
+		ins, ok := decodeARM64RawSVEIntegerCompare(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != 4 {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		for index, want := range test.args {
+			if want == "" {
+				if ins.Args[index].Kind != OpImm || ins.Args[index].Imm != test.imm {
+					t.Errorf("%#08x operand %d = %+v, want immediate %d", test.word, index, ins.Args[index], test.imm)
+				}
+			} else if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+				t.Errorf("%#08x operand %d = %+v, want %s", test.word, index, ins.Args[index], want)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x2400e000 | 3<<22, // wide D form is rejected by Go
+		0x24282403 ^ (1 << 25),
+	} {
+		if ins, ok := decodeARM64RawSVEIntegerCompare(word); ok {
+			t.Errorf("decoded invalid reverse compare %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVECompareRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCMPEQ Z1.B, Z2.H, P0.Z, P1.H",
+		"ZCMPGE $16, Z2.S, P0.Z, P1.S",
+		"ZCMPHI $-1, Z2.S, P0.Z, P1.S",
+		"ZCMPLO Z1.B, Z2.B, P0.Z, P1.B",
+		"ZCMPLT $16, Z2.S, P0.Z, P1.S",
+		"ZCMPLS $-1, Z2.S, P0.Z, P1.S",
+		"ZCMPNE Z1.S, Z2.S, P8.Z, P1.S",
+		"ZFCMEQ Z1.B, Z2.B, P0.Z, P1.B",
+		"ZFCMGT $(1.0), Z2.D, P0.Z, P1.D",
+		"ZFACGE Z1.S, Z2.S, P0.M, P1.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecompare(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecompare": {Name: "badsvecompare", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE compare forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_complex_add.go b/arm64_lower_sve_complex_add.go
new file mode 100644
index 000000000..a62669529
--- /dev/null
+++ b/arm64_lower_sve_complex_add.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEComplexAddIntrinsics = map[Op]string{
+	"ZCADD":   "cadd.x",
+	"ZSQCADD": "sqcadd.x",
+}
+
+func (c *arm64Ctx) lowerARM64SVEComplexAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEComplexAddIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects $90|$270, Zm.T, Zdn.T, Zdn.T without a suffix: %q", op, ins.Raw)
+	}
+	rotation := ins.Args[0].Imm
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	repeatedDestination, repeatedBits, repeatedOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if (rotation != 90 && rotation != 270) || !secondOK || !destinationOK || !repeatedOK || secondBits != destinationBits || repeatedBits != destinationBits || repeatedDestination != destination {
+		return true, false, fmt.Errorf("arm64 %s requires rotation $90/$270 and matching destructive B/H/S/D operands: %q", op, ins.Raw)
+	}
+	destinationValue, vectorType, err := c.loadZRegElements(destination, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / destinationBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, intrinsic, lanes, destinationBits, vectorType, destinationValue, vectorType, secondValue, rotation)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_complex_add_test.go b/arm64_lower_sve_complex_add_test.go
new file mode 100644
index 000000000..517933036
--- /dev/null
+++ b/arm64_lower_sve_complex_add_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEComplexAddCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svecomplexadd(SB),$0-0\n")
+	for opIndex, op := range []string{"ZCADD", "ZSQCADD"} {
+		for widthIndex, width := range []string{"B", "H", "S", "D"} {
+			for rotationIndex, rotation := range []int{90, 270} {
+				destination := opIndex*8 + widthIndex*2 + rotationIndex
+				fmt.Fprintf(&source, "\t%s $%d, Z%d.%s, Z%d.%s, Z%d.%s\n", op, rotation, (destination+1)%32, width, destination, width, destination, width)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecomplexadd": {Name: "svecomplexadd", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.cadd.x.nxv16i8",
+				"@llvm.aarch64.sve.cadd.x.nxv2i64",
+				"@llvm.aarch64.sve.sqcadd.x.nxv8i16",
+				"@llvm.aarch64.sve.sqcadd.x.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE complex-add lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-complex-add.ll", "arm64-sve-complex-add.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEComplexAddRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCADD $0, Z1.B, Z2.B, Z2.B",
+		"ZCADD $180, Z1.H, Z2.H, Z2.H",
+		"ZSQCADD $91, Z1.S, Z2.S, Z2.S",
+		"ZSQCADD $270, Z1.D, Z2.S, Z2.S",
+		"ZCADD $90, Z1.S, Z2.S, Z3.S",
+		"ZSQCADD.Z $270, Z1.D, Z2.D, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecomplexadd(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecomplexadd": {Name: "badsvecomplexadd", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's complex-add forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_complex_multiply_accumulate.go b/arm64_lower_sve_complex_multiply_accumulate.go
new file mode 100644
index 000000000..05b91d7ae
--- /dev/null
+++ b/arm64_lower_sve_complex_multiply_accumulate.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEComplexMultiplyAccumulateIntrinsics = map[Op]string{
+	"ZCMLA":      "cmla",
+	"ZSQRDCMLAH": "sqrdcmlah",
+}
+
+type arm64SVEComplexMultiplyAccumulateForm struct {
+	intrinsic    string
+	elementBits  int
+	multiplier   int
+	multiplicand int
+	lane         int
+	rotation     int
+	destination  int
+	indexed      bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEComplexMultiplyAccumulate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEComplexMultiplyAccumulateIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 form without a suffix: %q", op, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 %s rotation must be 0, 90, 180, or 270: %q", op, ins.Raw)
+	}
+	rotation := int(ins.Args[0].Imm)
+	if rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270 {
+		return true, false, fmt.Errorf("arm64 %s rotation must be 0, 90, 180, or 270: %q", op, ins.Raw)
+	}
+	form := arm64SVEComplexMultiplyAccumulateForm{intrinsic: intrinsic, rotation: rotation}
+	if multiplier, multiplierBits, lane, indexed := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[1]); indexed {
+		multiplicand, multiplicandBits, multiplicandOK := arm64ParseSVEZElementReg(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		maximumVector, vectorOK := map[int]int{16: 7, 32: 15}[multiplierBits]
+		maximumLane, laneOK := map[int]int{16: 3, 32: 1}[multiplierBits]
+		if !multiplicandOK || !destinationOK || !vectorOK || !laneOK || multiplier > maximumVector || lane > maximumLane || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s indexed operands must use an encodable H/S complex lane: %q", op, ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.lane = lane
+		form.destination = destination
+		form.indexed = true
+	} else {
+		multiplier, multiplierBits, multiplierOK := arm64ParseSVEZElementReg(ins.Args[1])
+		multiplicand, multiplicandBits, multiplicandOK := arm64ParseSVEZElementReg(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !multiplierOK || !multiplicandOK || !destinationOK || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s vector operands must use one B/H/S/D width: %q", op, ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.destination = destination
+	}
+	return true, false, c.lowerARM64SVEComplexMultiplyAccumulateForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEComplexMultiplyAccumulateForm(form arm64SVEComplexMultiplyAccumulateForm) error {
+	accumulator, vectorType, err := c.loadZRegElements(form.destination, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplicand, _, err := c.loadZRegElements(form.multiplicand, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplier, _, err := c.loadZRegElements(form.multiplier, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.x.nxv%di%d(%s %s, %s %s, %s %s, i32 %d, i32 %d)\n",
+			result, vectorType, form.intrinsic, lanes, form.elementBits, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier, form.lane, form.rotation)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n",
+			result, vectorType, form.intrinsic, lanes, form.elementBits, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier, form.rotation)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_complex_multiply_accumulate_test.go b/arm64_lower_sve_complex_multiply_accumulate_test.go
new file mode 100644
index 000000000..681480b41
--- /dev/null
+++ b/arm64_lower_sve_complex_multiply_accumulate_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEComplexMultiplyAccumulateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svecomplexmultiplyaccumulateforms(SB),$0-0\n")
+	for _, op := range []string{"ZCMLA", "ZSQRDCMLAH"} {
+		for _, rotation := range []int{0, 90, 180, 270} {
+			for _, width := range []string{"B", "H", "S", "D"} {
+				fmt.Fprintf(&source, "\t%s $%d, Z31.%s, Z2.%s, Z3.%s\n", op, rotation, width, width, width)
+			}
+			fmt.Fprintf(&source, "\t%s $%d, Z7.H[3], Z4.H, Z5.H\n", op, rotation)
+			fmt.Fprintf(&source, "\t%s $%d, Z15.S[1], Z6.S, Z7.S\n", op, rotation)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecomplexmultiplyaccumulateforms": {Name: "svecomplexmultiplyaccumulateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.cmla.x.nxv16i8",
+				"@llvm.aarch64.sve.cmla.lane.x.nxv8i16",
+				"@llvm.aarch64.sve.sqrdcmlah.x.nxv2i64",
+				"@llvm.aarch64.sve.sqrdcmlah.lane.x.nxv4i32",
+				"i32 0",
+				"i32 270",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE complex multiply-accumulate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-complex-multiply-accumulate.ll", "arm64-sve-complex-multiply-accumulate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEComplexMultiplyAccumulateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCMLA $45, Z1.S, Z2.S, Z3.S",
+		"ZSQRDCMLAH $0, Z1.H, Z2.S, Z3.S",
+		"ZCMLA $0, Z8.H[0], Z2.H, Z3.H",
+		"ZSQRDCMLAH $0, Z7.H[4], Z2.H, Z3.H",
+		"ZCMLA $0, Z16.S[0], Z2.S, Z3.S",
+		"ZSQRDCMLAH $0, Z15.S[2], Z2.S, Z3.S",
+		"ZCMLA $0, Z1.D[0], Z2.D, Z3.D",
+		"ZSQRDCMLAH.Z $0, Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecomplexmultiplyaccumulate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecomplexmultiplyaccumulate": {Name: "badsvecomplexmultiplyaccumulate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE complex multiply-accumulate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_convert.go b/arm64_lower_sve_convert.go
new file mode 100644
index 000000000..95a2ebeef
--- /dev/null
+++ b/arm64_lower_sve_convert.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEConvertKind uint8
+
+const (
+	arm64SVEConvertFloat arm64SVEConvertKind = iota
+	arm64SVEConvertFloatToSigned
+	arm64SVEConvertFloatToUnsigned
+	arm64SVEConvertSignedToFloat
+	arm64SVEConvertUnsignedToFloat
+)
+
+type arm64SVEConvertSpec struct {
+	kind                 arm64SVEConvertKind
+	intrinsic            string
+	zeroIntrinsic        string
+	zeroKeepsDestination bool
+	allowed              map[[2]int]bool
+}
+
+var (
+	arm64SVEConvertDifferentFloatWidths = arm64SVEWidthPairs(
+		[2]int{16, 32}, [2]int{16, 64}, [2]int{32, 16}, [2]int{32, 64}, [2]int{64, 16}, [2]int{64, 32},
+	)
+	arm64SVEConvertFloatToIntWidths = arm64SVEWidthPairs(
+		[2]int{16, 16}, [2]int{16, 32}, [2]int{16, 64}, [2]int{32, 32}, [2]int{32, 64}, [2]int{64, 32}, [2]int{64, 64},
+	)
+	arm64SVEConvertIntToFloatWidths = arm64SVEWidthPairs(
+		[2]int{16, 16}, [2]int{32, 16}, [2]int{32, 32}, [2]int{32, 64}, [2]int{64, 16}, [2]int{64, 32}, [2]int{64, 64},
+	)
+	arm64SVEConvertSpecs = map[Op]arm64SVEConvertSpec{
+		"ZFCVT":   {kind: arm64SVEConvertFloat, allowed: arm64SVEConvertDifferentFloatWidths},
+		"ZFCVTZS": {kind: arm64SVEConvertFloatToSigned, allowed: arm64SVEConvertFloatToIntWidths},
+		"ZFCVTZU": {kind: arm64SVEConvertFloatToUnsigned, allowed: arm64SVEConvertFloatToIntWidths},
+		"ZSCVTF":  {kind: arm64SVEConvertSignedToFloat, allowed: arm64SVEConvertIntToFloatWidths},
+		"ZUCVTF":  {kind: arm64SVEConvertUnsignedToFloat, allowed: arm64SVEConvertIntToFloatWidths},
+		"ZFCVTLT": {kind: arm64SVEConvertFloat, intrinsic: "fcvtlt", allowed: arm64SVEWidthPairs(
+			[2]int{16, 32}, [2]int{32, 64},
+		)},
+		"ZFCVTX": {kind: arm64SVEConvertFloat, intrinsic: "fcvtx", allowed: arm64SVEWidthPairs(
+			[2]int{64, 32},
+		)},
+		"ZFCVTXNT": {kind: arm64SVEConvertFloat, intrinsic: "fcvtxnt", zeroIntrinsic: "fcvtxnt.z", zeroKeepsDestination: true, allowed: arm64SVEWidthPairs(
+			[2]int{64, 32},
+		)},
+	}
+)
+
+func arm64SVEWidthPairs(pairs ...[2]int) map[[2]int]bool {
+	result := make(map[[2]int]bool, len(pairs))
+	for _, pair := range pairs {
+		result[pair] = true
+	}
+	return result
+}
+
+func (c *arm64Ctx) lowerARM64SVEConvert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEConvertSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.T, P0..P7/M|Z, Zd.T without a suffix: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !destinationOK || !spec.allowed[[2]int{sourceBits, destinationBits}] {
+		return true, false, fmt.Errorf("arm64 %s does not accept the requested source/destination widths: %q", op, ins.Raw)
+	}
+	predicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+	zeroing := false
+	if !mergeOK {
+		predicate, zeroing = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+		if !zeroing {
+			return true, false, fmt.Errorf("arm64 %s requires P0..P7/M or P0..P7/Z: %q", op, ins.Raw)
+		}
+	}
+
+	sourceValue, sourceType, err := c.loadARM64SVEConvertVector(source, sourceBits, spec.kind == arm64SVEConvertFloat || spec.kind == arm64SVEConvertFloatToSigned || spec.kind == arm64SVEConvertFloatToUnsigned)
+	if err != nil {
+		return true, false, err
+	}
+	destinationFloat := spec.kind == arm64SVEConvertFloat || spec.kind == arm64SVEConvertSignedToFloat || spec.kind == arm64SVEConvertUnsignedToFloat
+	merge := "zeroinitializer"
+	destinationType, err := arm64SVEConvertVectorType(destinationBits, destinationFloat)
+	if err != nil {
+		return true, false, err
+	}
+	if !zeroing || spec.zeroKeepsDestination {
+		merge, _, err = c.loadARM64SVEConvertVector(destination, destinationBits, destinationFloat)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	predicateBits := sourceBits
+	if destinationBits > predicateBits {
+		predicateBits = destinationBits
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, predicateBits)
+	if err != nil {
+		return true, false, err
+	}
+	name := arm64SVEConvertIntrinsicName(spec, sourceBits, destinationBits, zeroing)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, %s %s, %s %s)\n",
+		result, destinationType, name, destinationType, merge, predicateType, predicateValue, sourceType, sourceValue)
+	if destinationFloat {
+		return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, destinationType)
+	}
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
+
+func arm64SVEConvertVectorType(elementBits int, floating bool) (string, error) {
+	if floating {
+		_, vectorType, _, err := arm64SVEFloatType(elementBits)
+		return vectorType, err
+	}
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	return vectorType, err
+}
+
+func (c *arm64Ctx) loadARM64SVEConvertVector(register, elementBits int, floating bool) (string, string, error) {
+	if floating {
+		return c.loadRawSVEFloatVector(register, elementBits)
+	}
+	return c.loadZRegElements(register, elementBits)
+}
+
+func arm64SVEConvertIntrinsicName(spec arm64SVEConvertSpec, sourceBits, destinationBits int, zeroing bool) string {
+	floatCode := map[int]string{16: "f16", 32: "f32", 64: "f64"}
+	intCode := map[int]string{16: "i16", 32: "i32", 64: "i64"}
+	if spec.intrinsic != "" {
+		intrinsic := spec.intrinsic
+		if zeroing && spec.zeroIntrinsic != "" {
+			intrinsic = spec.zeroIntrinsic
+		}
+		return intrinsic + "." + floatCode[destinationBits] + floatCode[sourceBits]
+	}
+	switch spec.kind {
+	case arm64SVEConvertFloat:
+		return "fcvt." + floatCode[destinationBits] + floatCode[sourceBits]
+	case arm64SVEConvertFloatToSigned:
+		return "fcvtzs." + intCode[destinationBits] + floatCode[sourceBits]
+	case arm64SVEConvertFloatToUnsigned:
+		return "fcvtzu." + intCode[destinationBits] + floatCode[sourceBits]
+	case arm64SVEConvertSignedToFloat:
+		return "scvtf." + floatCode[destinationBits] + intCode[sourceBits]
+	default:
+		return "ucvtf." + floatCode[destinationBits] + intCode[sourceBits]
+	}
+}
+
+func emitARM64SVEConvertDeclarations(b *strings.Builder) {
+	for _, op := range []Op{"ZFCVT", "ZFCVTZS", "ZFCVTZU", "ZSCVTF", "ZUCVTF", "ZFCVTLT", "ZFCVTX", "ZFCVTXNT"} {
+		spec := arm64SVEConvertSpecs[op]
+		for _, sourceBits := range []int{16, 32, 64} {
+			for _, destinationBits := range []int{16, 32, 64} {
+				if !spec.allowed[[2]int{sourceBits, destinationBits}] {
+					continue
+				}
+				sourceFloat := spec.kind == arm64SVEConvertFloat || spec.kind == arm64SVEConvertFloatToSigned || spec.kind == arm64SVEConvertFloatToUnsigned
+				destinationFloat := spec.kind == arm64SVEConvertFloat || spec.kind == arm64SVEConvertSignedToFloat || spec.kind == arm64SVEConvertUnsignedToFloat
+				sourceType, _ := arm64SVEConvertVectorType(sourceBits, sourceFloat)
+				destinationType, _ := arm64SVEConvertVectorType(destinationBits, destinationFloat)
+				predicateBits := sourceBits
+				if destinationBits > predicateBits {
+					predicateBits = destinationBits
+				}
+				_, predicateLanes, _ := arm64SVEVectorType(predicateBits)
+				predicateType := fmt.Sprintf("<vscale x %d x i1>", predicateLanes)
+				names := []string{arm64SVEConvertIntrinsicName(spec, sourceBits, destinationBits, false)}
+				if spec.zeroIntrinsic != "" {
+					names = append(names, arm64SVEConvertIntrinsicName(spec, sourceBits, destinationBits, true))
+				}
+				for _, name := range names {
+					fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s(%s, %s, %s)\n",
+						destinationType, name, destinationType, predicateType, sourceType)
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_lower_sve_convert_test.go b/arm64_lower_sve_convert_test.go
new file mode 100644
index 000000000..6084d366f
--- /dev/null
+++ b/arm64_lower_sve_convert_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEConvertCompleteForms() string {
+	forms := map[string][][2]string{
+		"ZFCVT": {
+			{"H", "S"}, {"H", "D"}, {"S", "H"}, {"S", "D"}, {"D", "H"}, {"D", "S"},
+		},
+		"ZFCVTZS": {
+			{"H", "H"}, {"H", "S"}, {"H", "D"}, {"S", "S"}, {"S", "D"}, {"D", "S"}, {"D", "D"},
+		},
+		"ZFCVTZU": {
+			{"H", "H"}, {"H", "S"}, {"H", "D"}, {"S", "S"}, {"S", "D"}, {"D", "S"}, {"D", "D"},
+		},
+		"ZSCVTF": {
+			{"H", "H"}, {"S", "H"}, {"S", "S"}, {"S", "D"}, {"D", "H"}, {"D", "S"}, {"D", "D"},
+		},
+		"ZUCVTF": {
+			{"H", "H"}, {"S", "H"}, {"S", "S"}, {"S", "D"}, {"D", "H"}, {"D", "S"}, {"D", "D"},
+		},
+		"ZFCVTLT":  {{"H", "S"}, {"S", "D"}},
+		"ZFCVTX":   {{"D", "S"}},
+		"ZFCVTXNT": {{"D", "S"}},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT sveconvertforms(SB),$0-0\n")
+	register := 0
+	for _, op := range []string{"ZFCVT", "ZFCVTZS", "ZFCVTZU", "ZSCVTF", "ZUCVTF", "ZFCVTLT", "ZFCVTX", "ZFCVTXNT"} {
+		for _, widths := range forms[op] {
+			for _, mode := range []string{"M", "Z"} {
+				fmt.Fprintf(&source, "\t%s Z%d.%s, P7.%s, Z%d.%s\n", op, register%32, widths[0], mode, (register+1)%32, widths[1])
+				register += 2
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEConvertCompleteGo127Family(t *testing.T) {
+	source := arm64SVEConvertCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveconvertforms": {Name: "sveconvertforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2p2\"",
+				"@llvm.aarch64.sve.fcvt.f16f32",
+				"@llvm.aarch64.sve.fcvt.f64f16",
+				"@llvm.aarch64.sve.fcvtzs.i32f64",
+				"@llvm.aarch64.sve.fcvtzu.i64f16",
+				"@llvm.aarch64.sve.scvtf.f16i64",
+				"@llvm.aarch64.sve.ucvtf.f64i32",
+				"@llvm.aarch64.sve.fcvtlt.f32f16",
+				"@llvm.aarch64.sve.fcvtx.f32f64",
+				"@llvm.aarch64.sve.fcvtxnt.f32f64",
+				"@llvm.aarch64.sve.fcvtxnt.z.f32f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE conversion lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-convert.ll", "arm64-sve-convert.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEConvertRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFCVT Z0.H, P0.M, Z1.H",
+		"ZFCVT Z0.S, P0.M, Z1.S",
+		"ZFCVT Z0.D, P0.M, Z1.D",
+		"ZFCVTZS Z0.D, P0.M, Z1.H",
+		"ZFCVTZU Z0.S, P0.M, Z1.H",
+		"ZSCVTF Z0.H, P0.M, Z1.S",
+		"ZUCVTF Z0.H, P0.M, Z1.D",
+		"ZFCVTLT Z0.D, P0.M, Z1.S",
+		"ZFCVTX Z0.S, P0.M, Z1.H",
+		"ZFCVTXNT Z0.S, P0.M, Z1.D",
+		"ZFCVT Z0.H, P8.M, Z1.S",
+		"ZFCVT Z0.H, P0, Z1.S",
+		"ZFCVT.Z Z0.H, P0.M, Z1.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveconvert(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveconvert": {Name: "badsveconvert", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE conversion forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_copy.go b/arm64_lower_sve_copy.go
new file mode 100644
index 000000000..edc84875a
--- /dev/null
+++ b/arm64_lower_sve_copy.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVECopyVectorBaseSize = map[Op]int{
+	"ZCPYB": 0,
+	"ZCPYH": 1,
+	"ZCPYS": 2,
+	"ZCPYD": 3,
+}
+
+func decodeARM64RawSVECopy(word uint32) (Instr, bool) {
+	size := word >> 22 & 3
+	width := "BHSD"[size]
+	op, mode := Op("ZCPY"), "M"
+	predicate := word >> 10 & 7
+	var source Operand
+	switch {
+	case word&0xff308000 == 0x05100000:
+		shifted := word&(1<<13) != 0
+		// Arm marks size:sh == 001 undefined, despite Go accepting a shifted
+		// byte immediate spelling. Never decode that reserved machine word.
+		if size == 0 && shifted {
+			return Instr{}, false
+		}
+		value := int64(int8(word >> 5))
+		if shifted {
+			value <<= 8
+		}
+		source = Operand{Kind: OpImm, Imm: value}
+		predicate = word >> 16 & 15
+		if word&(1<<14) == 0 {
+			mode = "Z"
+		}
+	case word&0xff3fe000 == 0x0528a000:
+		source = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", word>>5&31))}
+		if word>>5&31 == 31 {
+			source.Reg = Reg("RSP")
+		}
+		if size != 3 {
+			op = "ZCPYW"
+		}
+	case word&0xff3fe000 == 0x05208000:
+		op = Op("ZCPY" + string(width))
+		source = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d", word>>5&31))}
+	default:
+		return Instr{}, false
+	}
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		source,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", predicate, mode))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))},
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVECopy(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	vectorBaseSize, vectorForm := arm64SVECopyVectorBaseSize[op]
+	if op != "ZCPY" && op != "ZCPYW" && !vectorForm {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects scalar, predicate mode, Z.B/H/S/D without a suffix: %q", op, ins.Raw)
+	}
+
+	destination, writtenBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s destination must be Z0..Z31.B/H/S/D: %q", op, ins.Raw)
+	}
+	writtenSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[writtenBits]
+	elementBits := writtenBits
+	predicateLimit := 7
+	mode := "M"
+	var scalar string
+
+	switch {
+	case op == "ZCPY" && ins.Args[0].Kind == OpImm:
+		if !arm64SVECopyImmediate(ins.Args[0]) {
+			return true, false, fmt.Errorf("arm64 ZCPY immediate must be signed 8-bit, optionally shifted left 8: %q", ins.Raw)
+		}
+		predicateLimit = 15
+		if _, ok := arm64ParseSVEPredicateMode(ins.Args[1], "M", predicateLimit); !ok {
+			mode = "Z"
+		}
+		scalar = arm64SVECopyImmediateValue(ins.Args[0].Imm, elementBits)
+	case op == "ZCPY" || op == "ZCPYW":
+		if !arm64SVECopyGeneralRegister(ins.Args[0]) {
+			return true, false, fmt.Errorf("arm64 %s source must be R0..R30 or RSP: %q", op, ins.Raw)
+		}
+		baseSize := 3
+		if op == "ZCPYW" {
+			baseSize = 0
+		}
+		elementBits = 8 << (baseSize | writtenSize)
+		scalar, err = c.loadReg(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		scalar = c.arm64SVECopyTruncate(scalar, elementBits)
+	case vectorForm:
+		register, registerOK := arm64SVEInsertVRegister(ins.Args[0])
+		if !registerOK {
+			return true, false, fmt.Errorf("arm64 %s source must be a bare V0..V31 register: %q", op, ins.Raw)
+		}
+		elementBits = 8 << (vectorBaseSize | writtenSize)
+		scalar, err = c.arm64SVEInsertVectorScalar(register, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], mode, predicateLimit)
+	if !predicateOK {
+		return true, false, fmt.Errorf("arm64 %s predicate must be P0..P%d.%s: %q", op, predicateLimit, mode, ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	inserted := c.newTmp()
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %s, i64 0\n", inserted, vectorType, elementBits, scalar)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, lanes)
+	merge := "zeroinitializer"
+	if mode == "M" {
+		merge, _, err = c.loadZRegElements(destination, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n",
+		result, predicateType, predicateValue, vectorType, splat, vectorType, merge)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func arm64SVECopyImmediate(operand Operand) bool {
+	if operand.Kind != OpImm || operand.ImmRaw != "" {
+		return false
+	}
+	value := operand.Imm
+	if value >= -128 && value <= 127 {
+		return true
+	}
+	return value%256 == 0 && value/256 >= -128 && value/256 <= 127
+}
+
+func arm64SVECopyImmediateValue(value int64, elementBits int) string {
+	mask := uint64(1)<<elementBits - 1
+	return fmt.Sprintf("%d", uint64(value)&mask)
+}
+
+func arm64SVECopyGeneralRegister(operand Operand) bool {
+	if operand.Kind != OpReg {
+		return false
+	}
+	return operand.Reg == SP || operand.Reg == Reg("RSP") ||
+		(isARM64GeneralOrZeroReg(operand.Reg) && operand.Reg != ZR)
+}
+
+func (c *arm64Ctx) arm64SVECopyTruncate(value string, elementBits int) string {
+	if elementBits == 64 {
+		return value
+	}
+	truncated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, value, elementBits)
+	return "%" + truncated
+}
diff --git a/arm64_lower_sve_copy_test.go b/arm64_lower_sve_copy_test.go
new file mode 100644
index 000000000..b594bb6f3
--- /dev/null
+++ b/arm64_lower_sve_copy_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVECopyCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svecopyforms(SB),$0-0\n")
+	register := 0
+	for _, mode := range []string{"M", "Z"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			for _, immediate := range []int{-128, 127, -32768, 32512} {
+				fmt.Fprintf(&source, "\tZCPY $%d, P15.%s, Z%d.%s\n", immediate, mode, register%32, width)
+				register++
+			}
+		}
+	}
+	for _, op := range []string{"ZCPY", "ZCPYW"} {
+		for widthIndex, width := range []string{"B", "H", "S", "D"} {
+			sourceReg := "R20"
+			if widthIndex%2 != 0 {
+				sourceReg = "RSP"
+			}
+			fmt.Fprintf(&source, "\t%s %s, P7.M, Z%d.%s\n", op, sourceReg, register%32, width)
+			register++
+		}
+	}
+	for _, op := range []string{"ZCPYB", "ZCPYH", "ZCPYS", "ZCPYD"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s V%d, P7.M, Z%d.%s\n", op, register%32, register%32, width)
+			register++
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVECopyCompleteGo127Family(t *testing.T) {
+	source := arm64SVECopyCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svecopyforms": {Name: "svecopyforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"insertelement <vscale x 16 x i8>",
+				"insertelement <vscale x 8 x i16>",
+				"insertelement <vscale x 4 x i32>",
+				"insertelement <vscale x 2 x i64>",
+				"select <vscale x 16 x i1>",
+				"select <vscale x 8 x i1>",
+				"select <vscale x 4 x i1>",
+				"select <vscale x 2 x i1>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE CPY lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-copy.ll", "arm64-sve-copy.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVECopyRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZCPY $-33024, P0.M, Z0.B",
+		"ZCPY $-129, P0.M, Z0.B",
+		"ZCPY $128, P0.M, Z0.B",
+		"ZCPY $32768, P0.M, Z0.B",
+		"ZCPY $1, P0, Z0.B",
+		"ZCPY $1, P16.M, Z0.B",
+		"ZCPY $1, P0.M, Z0.Q",
+		"ZCPY R0, P8.M, Z0.D",
+		"ZCPY ZR, P0.M, Z0.D",
+		"ZCPYW ZR, P0.M, Z0.S",
+		"ZCPYB V0, P8.M, Z0.B",
+		"ZCPYB R0, P0.M, Z0.B",
+		"ZCPYD V0, P0.Z, Z0.D",
+		"ZCPY.Z $1, P0.M, Z0.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvecopy(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvecopy": {Name: "badsvecopy", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE CPY forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_count.go b/arm64_lower_sve_count.go
new file mode 100644
index 000000000..53dbea5db
--- /dev/null
+++ b/arm64_lower_sve_count.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawSVECnt struct {
+	op          Op
+	elementBits int
+	destination int
+	pattern     int
+	multiplier  int
+	operation   string
+	vector      bool
+}
+
+type arm64NamedSVECnt struct {
+	elementBits int
+	destination Reg
+}
+
+// Named counts retain the existing single-GP-destination form. Pattern and
+// multiplier operands belong to the independently decoded WORD forms.
+func parseARM64SVECnt(op Op, ins Instr) (form arm64NamedSVECnt, handled bool, err error) {
+	switch op {
+	case "CNTB":
+		form.elementBits = 8
+	case "CNTH":
+		form.elementBits = 16
+	case "CNTW":
+		form.elementBits = 32
+	case "CNTD":
+		form.elementBits = 64
+	default:
+		return form, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 1 ||
+		ins.Args[0].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[0].Reg) || ins.Args[0].Reg == ZR {
+		return form, true, fmt.Errorf("arm64 %s expects one general destination register: %q", op, ins.Raw)
+	}
+	form.destination = ins.Args[0].Reg
+	return form, true, nil
+}
+
+func decodeARM64RawSVECnt(word uint32) (arm64RawSVECnt, bool) {
+	const variable = uint32(3<<22 | 15<<16 | 31<<5 | 31)
+	operation := ""
+	prefix := "CNT"
+	vector := false
+	switch word &^ variable {
+	case 0x0420e000:
+	case 0x0430e000:
+		prefix, operation = "INC", "add"
+	case 0x0430e400:
+		prefix, operation = "DEC", "sub"
+	case 0x0430c000:
+		prefix, operation, vector = "INC", "add", true
+	case 0x0430c400:
+		prefix, operation, vector = "DEC", "sub", true
+	default:
+		return arm64RawSVECnt{}, false
+	}
+	size := word >> 22 & 3
+	if vector && size == 0 {
+		return arm64RawSVECnt{}, false
+	}
+	return arm64RawSVECnt{
+		op: Op(prefix + string("BHWD"[size])), elementBits: 8 << size,
+		destination: int(word & 31), pattern: int(word >> 5 & 31),
+		multiplier: int(word>>16&15) + 1, operation: operation, vector: vector,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSVECnt(form arm64RawSVECnt) error {
+	if form.vector {
+		value := c.arm64SVEElementCountValue(form.elementBits, form.pattern, form.multiplier)
+		if form.elementBits != 64 {
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, value, form.elementBits)
+			value = "%" + truncated
+		}
+		previous, vectorType, err := c.loadZRegElements(form.destination, form.elementBits)
+		if err != nil {
+			return err
+		}
+		inserted, splat, result := c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %s, i64 0\n", inserted, vectorType, form.elementBits, value)
+		fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, 128/form.elementBits)
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, form.operation, vectorType, previous, splat)
+		return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+	}
+	reg := Reg(fmt.Sprintf("R%d", form.destination))
+	if form.destination == 31 {
+		reg = ZR
+	}
+	return c.lowerARM64SVEElementCount(reg, form.elementBits, form.pattern, form.multiplier, form.operation)
+}
+
+// CNT/INC/DEC share predicate-pattern counts and the encoded 1..16 multiplier.
+// LLVM's count intrinsics implement POW2, fixed VL, MUL3/MUL4, ALL and unknown
+// pattern values (which architecturally select zero elements).
+func (c *arm64Ctx) arm64SVEElementCountValue(bits, pattern, multiplier int) string {
+	count := c.newTmp()
+	suffix := map[int]string{8: "b", 16: "h", 32: "w", 64: "d"}[bits]
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.cnt%s(i32 %d)\n", count, suffix, pattern)
+	value := "%" + count
+	if multiplier != 1 {
+		scaled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %d\n", scaled, value, multiplier)
+		value = "%" + scaled
+	}
+	return value
+}
+
+func (c *arm64Ctx) lowerARM64SVEElementCount(reg Reg, bits, pattern, multiplier int, operation string) error {
+	value := c.arm64SVEElementCountValue(bits, pattern, multiplier)
+	if operation != "" {
+		previous, err := c.loadReg(reg)
+		if err != nil {
+			return err
+		}
+		updated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %s\n", updated, operation, previous, value)
+		value = "%" + updated
+	}
+	return c.storeReg(reg, value)
+}
+
+func (c *arm64Ctx) lowerARM64SVECnt(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARM64SVECnt(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	return true, false, c.lowerARM64SVEElementCount(form.destination, form.elementBits, 31, 1, "")
+}
diff --git a/arm64_lower_sve_divide.go b/arm64_lower_sve_divide.go
new file mode 100644
index 000000000..17afefc0c
--- /dev/null
+++ b/arm64_lower_sve_divide.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEDivideIntrinsics = map[Op]string{
+	"ZSDIV":  "sdiv",
+	"ZSDIVR": "sdivr",
+	"ZUDIV":  "udiv",
+	"ZUDIVR": "udivr",
+}
+
+func (c *arm64Ctx) lowerARM64SVEDivide(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEDivideIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.S|D, Zdn.S|D, P0..P7/M, Zdn.S|D without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || (firstBits != 32 && firstBits != 64) || secondBits != firstBits || destinationBits != firstBits || destination != first {
+		return true, false, fmt.Errorf("arm64 %s requires matching-width destructive S/D operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_divide_test.go b/arm64_lower_sve_divide_test.go
new file mode 100644
index 000000000..42f56e765
--- /dev/null
+++ b/arm64_lower_sve_divide_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEDivideCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svedivideforms(SB),$0-0\n")
+	for _, op := range []string{"ZSDIV", "ZSDIVR", "ZUDIV", "ZUDIVR"} {
+		for predicate, width := range []string{"S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", P" + string(rune('0'+predicate)) + ".M, Z2." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEDivideCompleteGo127Family(t *testing.T) {
+	source := arm64SVEDivideCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svedivideforms": {Name: "svedivideforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.sdiv.nxv4i32",
+				"@llvm.aarch64.sve.sdivr.nxv2i64",
+				"@llvm.aarch64.sve.udiv.nxv4i32",
+				"@llvm.aarch64.sve.udivr.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE divide lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-divide.ll", "arm64-sve-divide.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEDivideRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSDIV Z1.B, Z2.B, P0.M, Z2.B",
+		"ZUDIV Z1.H, Z2.H, P0.M, Z2.H",
+		"ZSDIVR Z1.S, Z2.D, P0.M, Z2.D",
+		"ZUDIVR Z1.D, Z2.D, P0, Z2.D",
+		"ZSDIV Z1.S, Z2.S, P8.M, Z2.S",
+		"ZUDIV Z1.S, Z2.S, P0.M, Z3.S",
+		"ZSDIV.Z Z1.S, Z2.S, P0.M, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvedivide(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvedivide": {Name: "badsvedivide", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE divide forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_dup_general.go b/arm64_lower_sve_dup_general.go
new file mode 100644
index 000000000..8382e3b17
--- /dev/null
+++ b/arm64_lower_sve_dup_general.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEDupGeneral struct {
+	elementBits int
+	source      int
+	destination int
+}
+
+// decodeARM64RawSVEDupGeneral covers the complete SVE DUP (general) encoding:
+// DUP Zd.T, Rn, where T is B/H/S/D and R31 denotes SP (not ZR).
+func decodeARM64RawSVEDupGeneral(word uint32) (arm64RawSVEDupGeneral, bool) {
+	if word&0xff3ffc00 != 0x05203800 {
+		return arm64RawSVEDupGeneral{}, false
+	}
+	return arm64RawSVEDupGeneral{
+		elementBits: 8 << (int(word>>22) & 3),
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSVEDupGeneral(form arm64RawSVEDupGeneral) error {
+	reg := Reg(fmt.Sprintf("R%d", form.source))
+	if form.source == 31 {
+		reg = SP
+	}
+	source, err := c.loadReg(reg)
+	if err != nil {
+		return err
+	}
+	if form.elementBits != 64 {
+		narrowed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrowed, source, form.elementBits)
+		source = "%" + narrowed
+	}
+	lanes := 128 / form.elementBits
+	vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, form.elementBits)
+	inserted := c.newTmp()
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %s, i64 0\n", inserted, vectorType, form.elementBits, source)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, lanes)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <vscale x 16 x i8>\n", bytes, vectorType, splat)
+	return c.storeZReg(form.destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_dup_general_test.go b/arm64_lower_sve_dup_general_test.go
new file mode 100644
index 000000000..5e3081014
--- /dev/null
+++ b/arm64_lower_sve_dup_general_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEDupGeneral(elementBits, source, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x05203800 | size<<22 | uint32(source)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64RawSVEDupGeneralCompleteArchitecturalForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveDupGeneralRaw(SB), $0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawSVEDupGeneral(elementBits, 15, elementBits/8))
+	}
+	source.WriteString("\tRET\n")
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveDupGeneralRaw": {Name: "sveDupGeneralRaw", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, "<vscale x 16 x i8>", "insertelement <vscale", "shufflevector <vscale"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s SVE DUP general IR omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-dup-general.ll", "arm64-sve-dup-general.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEDupGeneralDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 32; destination++ {
+				word := encodeARM64RawSVEDupGeneral(elementBits, source, destination)
+				got, ok := decodeARM64RawSVEDupGeneral(word)
+				if !ok || got.elementBits != elementBits || got.source != source || got.destination != destination {
+					t.Fatalf("decoded SVE DUP general %#08x as %+v, ok=%v", word, got, ok)
+				}
+				count++
+			}
+		}
+	}
+	if count != 4*32*32 {
+		t.Fatalf("covered %d SVE DUP general encodings, want %d", count, 4*32*32)
+	}
+}
+
+func TestARM64RawSVEDupGeneralDecoderRejectsAdjacentEncoding(t *testing.T) {
+	for _, word := range []uint32{0x05203c00, 0x05203000} {
+		if _, ok := decodeARM64RawSVEDupGeneral(word); ok {
+			t.Fatalf("SVE DUP general decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_sve_dup_immediate.go b/arm64_lower_sve_dup_immediate.go
new file mode 100644
index 000000000..05f5cc842
--- /dev/null
+++ b/arm64_lower_sve_dup_immediate.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64RawSVEDupImmediate struct {
+	elementBits int
+	immediate   int
+	destination int
+}
+
+type arm64RawSVEDupElement struct {
+	elementBits int
+	lane        int
+	source      int
+	destination int
+}
+
+func decodeARM64RawSVEDupElement(word uint32) (arm64RawSVEDupElement, bool) {
+	if word&0xff20fc00 != 0x05202000 {
+		return arm64RawSVEDupElement{}, false
+	}
+	imm5 := int(word>>16) & 31
+	if imm5 == 0 {
+		return arm64RawSVEDupElement{}, false
+	}
+	size := 0
+	for imm5&(1<<size) == 0 {
+		size++
+	}
+	if size > 4 {
+		return arm64RawSVEDupElement{}, false
+	}
+	form := arm64RawSVEDupElement{
+		elementBits: 8 << size,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}
+	// imm2:tsz describes an element in the first 512 bits, not just the
+	// minimum 128-bit vector. The two upper index bits are shared by all widths.
+	form.lane = (int(word>>22&3)<<5 | imm5) >> (size + 1)
+	return form, true
+}
+
+func decodeARM64RawSVEDupImmediate(word uint32) (arm64RawSVEDupImmediate, bool) {
+	if word&0xff3fc000 != 0x2538c000 {
+		return arm64RawSVEDupImmediate{}, false
+	}
+	elementBits := 8 << (int(word>>22) & 3)
+	shift := 0
+	if word&(1<<13) != 0 {
+		shift = 8
+	}
+	// The byte element has no room for an LSL #8 immediate. LLVM and the Arm
+	// architecture reject this encoding even though Go 1.27's generated
+	// encoder does not correlate the shift bit with the element size.
+	if elementBits == 8 && shift != 0 {
+		return arm64RawSVEDupImmediate{}, false
+	}
+	immediate := int(int8(word >> 5))
+	immediate <<= shift
+	return arm64RawSVEDupImmediate{
+		elementBits: elementBits,
+		immediate:   immediate,
+		destination: int(word) & 31,
+	}, true
+}
+
+func arm64ParseSVEZElementReg(operand Operand) (index, elementBits int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || !strings.HasPrefix(parts[0], "Z") {
+		return 0, 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(parts[0], "Z"))
+	if err != nil || index < 0 || index > 31 {
+		return 0, 0, false
+	}
+	elementBits, ok = map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[parts[1]]
+	return index, elementBits, ok
+}
+
+func arm64SVEDupImmediateRepresentable(elementBits int, immediate int64) bool {
+	if immediate >= -128 && immediate <= 127 {
+		return true
+	}
+	if elementBits == 8 || immediate%256 != 0 {
+		return false
+	}
+	unshifted := immediate / 256
+	return unshifted >= -128 && unshifted <= 127
+}
+
+func arm64ParseSVEDupElementReg(operand Operand) (index, elementBits, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	dot := strings.IndexByte(name, '.')
+	open := strings.IndexByte(name, '[')
+	if dot <= 1 || open <= dot+1 || !strings.HasSuffix(name, "]") || !strings.HasPrefix(name, "Z") {
+		return 0, 0, 0, false
+	}
+	index, err := strconv.Atoi(name[1:dot])
+	if err != nil || index < 0 || index > 31 {
+		return 0, 0, 0, false
+	}
+	elementBits, ok = map[string]int{"B": 8, "H": 16, "S": 32, "D": 64, "Q": 128}[name[dot+1:open]]
+	lane, err = strconv.Atoi(name[open+1 : len(name)-1])
+	if err != nil || !ok || lane < 0 || lane >= 512/elementBits {
+		return 0, 0, 0, false
+	}
+	return index, elementBits, lane, true
+}
+
+func arm64ParseSVEDupDestination(operand Operand, allowQ bool) (index, elementBits int, ok bool) {
+	if index, elementBits, ok = arm64ParseSVEZElementReg(operand); ok {
+		return index, elementBits, true
+	}
+	if !allowQ || operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if !strings.HasPrefix(name, "Z") || !strings.HasSuffix(name, ".Q") {
+		return 0, 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(name, "Z"), ".Q"))
+	return index, 128, err == nil && index >= 0 && index <= 31
+}
+
+func arm64ParseSVEDupGeneralSource(operand Operand) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if name == "SP" || name == "RSP" {
+		return 31, true
+	}
+	if !strings.HasPrefix(name, "R") {
+		return 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(name, "R"))
+	return index, err == nil && index >= 0 && index <= 30
+}
+
+func (c *arm64Ctx) lowerARM64SVEDupImmediate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZDUP" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 ZDUP expects one of Go 1.27's general, indexed-element, or immediate forms: %q", ins.Raw)
+	}
+	if source, validSource := arm64ParseSVEDupGeneralSource(ins.Args[0]); validSource {
+		destination, elementBits, validDestination := arm64ParseSVEDupDestination(ins.Args[1], false)
+		if !validDestination {
+			return true, false, fmt.Errorf("arm64 ZDUP general expects Rn|RSP, Zd.B|H|S|D: %q", ins.Raw)
+		}
+		return true, false, c.lowerRawSVEDupGeneral(arm64RawSVEDupGeneral{elementBits: elementBits, source: source, destination: destination})
+	}
+	if source, elementBits, lane, validSource := arm64ParseSVEDupElementReg(ins.Args[0]); validSource {
+		destination, destinationBits, validDestination := arm64ParseSVEDupDestination(ins.Args[1], true)
+		if !validDestination || elementBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZDUP element expects Zn.T[index], Zd.T with matching B/H/S/D/Q: %q", ins.Raw)
+		}
+		return true, false, c.lowerRawSVEDupElement(arm64RawSVEDupElement{elementBits: elementBits, lane: lane, source: source, destination: destination})
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 ZDUP expects one of Go 1.27's general, indexed-element, or immediate forms: %q", ins.Raw)
+	}
+	destination, elementBits, valid := arm64ParseSVEZElementReg(ins.Args[1])
+	if !valid || !arm64SVEDupImmediateRepresentable(elementBits, ins.Args[0].Imm) {
+		return true, false, fmt.Errorf("arm64 ZDUP immediate is outside Go 1.27's SVE form: %q", ins.Raw)
+	}
+	return true, false, c.lowerRawSVEDupImmediate(arm64RawSVEDupImmediate{
+		elementBits: elementBits,
+		immediate:   int(ins.Args[0].Imm),
+		destination: destination,
+	})
+}
+
+func (c *arm64Ctx) lowerRawSVEDupElement(form arm64RawSVEDupElement) error {
+	source, err := c.loadZReg(form.source)
+	if err != nil {
+		return err
+	}
+	if form.elementBits == 128 {
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.aarch64.sve.dupq.lane.nxv16i8(<vscale x 16 x i8> %s, i64 %d)\n", result, source, form.lane)
+		return c.storeZReg(form.destination, "%"+result)
+	}
+	lanes := 128 / form.elementBits
+	vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, form.elementBits)
+	typedSource := source
+	if form.elementBits != 8 {
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 16 x i8> %s to %s\n", converted, source, vectorType)
+		typedSource = "%" + converted
+	}
+	element := c.newTmp()
+	inserted := c.newTmp()
+	splat := c.newTmp()
+	index := fmt.Sprint(form.lane)
+	valid := ""
+	if form.lane >= lanes {
+		// The architecture returns zero beyond the current VL. An unchecked
+		// extractelement would instead create LLVM poison. Clamp the extraction
+		// itself, then select zero, so both evaluated operands remain defined.
+		vscale, length, inRange, safeIndex := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.vscale.i64()\n", vscale)
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", length, vscale, lanes)
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt i64 %%%s, %d\n", inRange, length, form.lane)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %d, i64 0\n", safeIndex, inRange, form.lane)
+		index, valid = "%"+safeIndex, "%"+inRange
+	}
+	fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i64 %s\n", element, vectorType, typedSource, index)
+	if valid != "" {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i%d %%%s, i%d 0\n", selected, valid, form.elementBits, element, form.elementBits)
+		element = selected
+	}
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %%%s, i64 0\n", inserted, vectorType, form.elementBits, element)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, lanes)
+	result := "%" + splat
+	if form.elementBits != 8 {
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 16 x i8>\n", bytes, vectorType, result)
+		result = "%" + bytes
+	}
+	return c.storeZReg(form.destination, result)
+}
+
+func (c *arm64Ctx) lowerRawSVEDupImmediate(form arm64RawSVEDupImmediate) error {
+	lanes := 128 / form.elementBits
+	vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, form.elementBits)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s splat (i%d %d) to <vscale x 16 x i8>\n",
+		bytes, vectorType, form.elementBits, form.immediate)
+	return c.storeZReg(form.destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_dupm.go b/arm64_lower_sve_dupm.go
new file mode 100644
index 000000000..a2f6a239e
--- /dev/null
+++ b/arm64_lower_sve_dupm.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEDupM(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZDUPM" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 ZDUPM expects a resolved logical bitmask immediate and Zd.B|H|S|D without a suffix: %q", ins.Raw)
+	}
+	destination, elementBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	immediate := uint64(ins.Args[0].Imm)
+	if !destinationOK || !arm64SVELogicalImmediateRepresentable(elementBits, immediate) {
+		return true, false, fmt.Errorf("arm64 ZDUPM immediate is not a Go logical bitmask for the destination width: %q", ins.Raw)
+	}
+	immediate &= arm64SVEMaskForBits(elementBits)
+	value := fmt.Sprintf("splat (i%d %d)", elementBits, immediate)
+	return true, false, c.storeZRegElements(destination, elementBits, value)
+}
diff --git a/arm64_lower_sve_dupm_test.go b/arm64_lower_sve_dupm_test.go
new file mode 100644
index 000000000..be39604b7
--- /dev/null
+++ b/arm64_lower_sve_dupm_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEDupMCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svedupm(SB),$0-0\n")
+	for index, form := range []struct {
+		width     string
+		immediate string
+	}{{"B", "0x55"}, {"H", "0xff00"}, {"S", "0xffff0000"}, {"D", "-4294967296"}} {
+		fmt.Fprintf(&source, "\tZDUPM $%s, Z%d.%s\n", form.immediate, index+16, form.width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svedupm": {Name: "svedupm", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"<vscale x 16 x i8>",
+				"<vscale x 8 x i16>",
+				"<vscale x 4 x i32>",
+				"<vscale x 2 x i64>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZDUPM lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-dupm.ll", "arm64-sve-dupm.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEDupMRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZDUPM $0, Z1.B",
+		"ZDUPM $255, Z1.B",
+		"ZDUPM $5, Z1.B",
+		"ZDUPM $65535, Z1.H",
+		"ZDUPM $1, Z1.Q",
+		"ZDUPM Z1.D, Z2.D",
+		"ZDUPM.Z $7, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvedupm(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvedupm": {Name: "badsvedupm", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZDUPM forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_dupq.go b/arm64_lower_sve_dupq.go
new file mode 100644
index 000000000..a0f68e4ad
--- /dev/null
+++ b/arm64_lower_sve_dupq.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEDupQ(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZDUPQ" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 ZDUPQ expects Zn.B|H|S|D[index], Zd.B|H|S|D without a suffix: %q", ins.Raw)
+	}
+	source, elementBits, lane, sourceOK := arm64ParseSVEDupElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEDupDestination(ins.Args[1], false)
+	if !sourceOK || !destinationOK || elementBits == 128 || elementBits != destinationBits || lane >= 128/elementBits {
+		return true, false, fmt.Errorf("arm64 ZDUPQ requires matching B/H/S/D widths and an index within one 128-bit segment: %q", ins.Raw)
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.dupq.lane.nxv%di%d(%s %s, i64 %d)\n", result, vectorType, lanes, elementBits, vectorType, sourceValue, lane)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_dupq_test.go b/arm64_lower_sve_dupq_test.go
new file mode 100644
index 000000000..d7ca8e04b
--- /dev/null
+++ b/arm64_lower_sve_dupq_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEDupQCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svedupq(SB),$0-0\n")
+	for widthIndex, form := range []struct {
+		width string
+		max   int
+	}{{"B", 15}, {"H", 7}, {"S", 3}, {"D", 1}} {
+		for laneIndex, lane := range []int{0, form.max} {
+			destination := widthIndex*2 + laneIndex
+			fmt.Fprintf(&source, "\tZDUPQ Z%d.%s[%d], Z%d.%s\n", destination+16, form.width, lane, destination, form.width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svedupq": {Name: "svedupq", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.dupq.lane.nxv16i8",
+				"@llvm.aarch64.sve.dupq.lane.nxv8i16",
+				"@llvm.aarch64.sve.dupq.lane.nxv4i32",
+				"@llvm.aarch64.sve.dupq.lane.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZDUPQ lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-dupq.ll", "arm64-sve-dupq.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEDupQRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZDUPQ Z1.B[16], Z2.B",
+		"ZDUPQ Z1.H[8], Z2.H",
+		"ZDUPQ Z1.S[4], Z2.S",
+		"ZDUPQ Z1.D[2], Z2.D",
+		"ZDUPQ Z1.H[2], Z2.S",
+		"ZDUPQ Z1.Q[0], Z2.Q",
+		"ZDUPQ.Z Z1.D[1], Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvedupq(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvedupq": {Name: "badsvedupq", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZDUPQ forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_dupw.go b/arm64_lower_sve_dupw.go
new file mode 100644
index 000000000..c3d3ad368
--- /dev/null
+++ b/arm64_lower_sve_dupw.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEDupW(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZDUPW" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 ZDUPW expects Rn|RSP, Zd.B|H|S|D without a suffix: %q", ins.Raw)
+	}
+	source, sourceOK := arm64ParseSVEDupGeneralSource(ins.Args[0])
+	destination, elementBits, destinationOK := arm64ParseSVEDupDestination(ins.Args[1], false)
+	if !sourceOK || !destinationOK {
+		return true, false, fmt.Errorf("arm64 ZDUPW requires R0..R30 or RSP and a B/H/S/D destination: %q", ins.Raw)
+	}
+	return true, false, c.lowerRawSVEDupGeneral(arm64RawSVEDupGeneral{elementBits: elementBits, source: source, destination: destination})
+}
diff --git a/arm64_lower_sve_dupw_test.go b/arm64_lower_sve_dupw_test.go
new file mode 100644
index 000000000..8f8423445
--- /dev/null
+++ b/arm64_lower_sve_dupw_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEDupWCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svedupw(SB),$0-0\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		sourceReg := fmt.Sprintf("R%d", index+4)
+		if width == "D" {
+			sourceReg = "RSP"
+		}
+		fmt.Fprintf(&source, "\tZDUPW %s, Z%d.%s\n", sourceReg, index+16, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svedupw": {Name: "svedupw", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"shufflevector <vscale x 16 x i8>",
+				"shufflevector <vscale x 8 x i16>",
+				"shufflevector <vscale x 4 x i32>",
+				"shufflevector <vscale x 2 x i64>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZDUPW lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-dupw.ll", "arm64-sve-dupw.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEDupWRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZDUPW ZR, Z1.B",
+		"ZDUPW R31, Z1.H",
+		"ZDUPW R1, Z32.S",
+		"ZDUPW R1, Z2.Q",
+		"ZDUPW Z1.S, Z2.S",
+		"ZDUPW.Z R1, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvedupw(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvedupw": {Name: "badsvedupw", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZDUPW forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_eor.go b/arm64_lower_sve_eor.go
new file mode 100644
index 000000000..8e06c6e12
--- /dev/null
+++ b/arm64_lower_sve_eor.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+)
+
+type arm64SVEEORMode uint8
+
+const (
+	arm64SVEEORUnpredicated arm64SVEEORMode = iota
+	arm64SVEEORPredicated
+	arm64SVEEORImmediate
+)
+
+type arm64RawSVEEOR struct {
+	op          Op
+	mode        arm64SVEEORMode
+	elementBits int
+	first       int
+	second      int
+	predicate   int
+	immediate   uint64
+	destination int
+}
+
+func decodeARM64SVELogicalImmediate(imm13 int) (elementBits int, immediate uint64, ok bool) {
+	n := (imm13 >> 12) & 1
+	immr := (imm13 >> 6) & 63
+	imms := imm13 & 63
+	lengthSource := n<<6 | (^imms & 63)
+	length := bits.Len(uint(lengthSource)) - 1
+	if length < 1 {
+		return 0, 0, false
+	}
+	esize := 1 << length
+	levels := esize - 1
+	s := imms & levels
+	if s == levels {
+		return 0, 0, false
+	}
+	r := immr & levels
+	ones := s + 1
+	pattern := (uint64(1) << ones) - 1
+	mask := ^uint64(0)
+	if esize < 64 {
+		mask = (uint64(1) << esize) - 1
+	}
+	pattern = ((pattern >> r) | (pattern << (esize - r))) & mask
+	elementBits = esize
+	if elementBits < 8 {
+		elementBits = 8
+	}
+	for offset := esize; offset < elementBits; offset += esize {
+		immediate |= pattern << offset
+	}
+	immediate |= pattern
+	return elementBits, immediate, true
+}
+
+func decodeARM64RawSVEEOR(word uint32) (arm64RawSVEEOR, bool) {
+	form := arm64RawSVEEOR{}
+	switch {
+	case word&0xffe0fc00 == 0x04203000:
+		form.op = "ZAND"
+		form.mode = arm64SVEEORUnpredicated
+		form.elementBits = 64
+		form.second = int(word>>16) & 31
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xffe0fc00 == 0x04603000:
+		form.op = "ZORR"
+		form.mode = arm64SVEEORUnpredicated
+		form.elementBits = 64
+		form.second = int(word>>16) & 31
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xffe0fc00 == 0x04a03000:
+		form.op = "ZEOR"
+		form.mode = arm64SVEEORUnpredicated
+		form.elementBits = 64
+		form.second = int(word>>16) & 31
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xffe0fc00 == 0x04e03000:
+		form.op = "ZBIC"
+		form.mode = arm64SVEEORUnpredicated
+		form.elementBits = 64
+		form.second = int(word>>16) & 31
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xff3fe000 == 0x04180000:
+		form.op = "ZORR"
+		form.mode = arm64SVEEORPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xff3fe000 == 0x04190000:
+		form.op = "ZEOR"
+		form.mode = arm64SVEEORPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xff3fe000 == 0x041a0000:
+		form.op = "ZAND"
+		form.mode = arm64SVEEORPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xff3fe000 == 0x041b0000:
+		form.op = "ZBIC"
+		form.mode = arm64SVEEORPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xfffc0000 == 0x05000000:
+		form.op = "ZORR"
+		form.mode = arm64SVEEORImmediate
+		var ok bool
+		form.elementBits, form.immediate, ok = decodeARM64SVELogicalImmediate(int(word>>5) & 0x1fff)
+		if !ok {
+			return arm64RawSVEEOR{}, false
+		}
+		form.destination = int(word) & 31
+		form.first = form.destination
+	case word&0xfffc0000 == 0x05400000:
+		form.op = "ZEOR"
+		form.mode = arm64SVEEORImmediate
+		var ok bool
+		form.elementBits, form.immediate, ok = decodeARM64SVELogicalImmediate(int(word>>5) & 0x1fff)
+		if !ok {
+			return arm64RawSVEEOR{}, false
+		}
+		form.destination = int(word) & 31
+		form.first = form.destination
+	case word&0xfffc0000 == 0x05800000:
+		form.op = "ZAND"
+		form.mode = arm64SVEEORImmediate
+		var ok bool
+		form.elementBits, form.immediate, ok = decodeARM64SVELogicalImmediate(int(word>>5) & 0x1fff)
+		if !ok {
+			return arm64RawSVEEOR{}, false
+		}
+		form.destination = int(word) & 31
+		form.first = form.destination
+	default:
+		return arm64RawSVEEOR{}, false
+	}
+	return form, true
+}
+
+func arm64SVEMaskForBits(elementBits int) uint64 {
+	if elementBits == 64 {
+		return ^uint64(0)
+	}
+	return (uint64(1) << elementBits) - 1
+}
+
+func arm64SVEReplicateImmediate(value uint64, fromBits, toBits int) uint64 {
+	value &= arm64SVEMaskForBits(fromBits)
+	result := uint64(0)
+	for offset := 0; offset < toBits; offset += fromBits {
+		result |= value << offset
+	}
+	return result & arm64SVEMaskForBits(toBits)
+}
+
+func arm64SVELogicalImmediateRepresentable(elementBits int, value uint64) bool {
+	value &= arm64SVEMaskForBits(elementBits)
+	if value == 0 || value == arm64SVEMaskForBits(elementBits) {
+		return false
+	}
+	for imm13 := 0; imm13 < 1<<13; imm13++ {
+		encodedBits, encodedValue, ok := decodeARM64SVELogicalImmediate(imm13)
+		if ok && encodedBits <= elementBits && arm64SVEReplicateImmediate(encodedValue, encodedBits, elementBits) == value {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *arm64Ctx) lowerARM64SVEEOR(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZAND" && op != "ZBIC" && op != "ZEOR" && op != "ZORR" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form := arm64RawSVEEOR{}
+	if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm {
+		if op == "ZBIC" {
+			return true, false, fmt.Errorf("arm64 ZBIC has no immediate form in Go 1.27: %q", ins.Raw)
+		}
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		immediate := uint64(ins.Args[0].Imm)
+		if ins.Args[0].ImmRaw != "" || !firstOK || !destinationOK || first != destination || firstBits != destinationBits || !arm64SVELogicalImmediateRepresentable(firstBits, immediate) {
+			return true, false, fmt.Errorf("arm64 %s immediate expects a Go logical bitmask and identical Zdn.T operands: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEEOR{op: op, mode: arm64SVEEORImmediate, elementBits: firstBits, first: first, immediate: immediate & arm64SVEMaskForBits(firstBits), destination: destination}
+	} else if len(ins.Args) == 3 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != 64 || firstBits != 64 || destinationBits != 64 {
+			return true, false, fmt.Errorf("arm64 %s unpredicated form requires three .D vectors: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEEOR{op: op, mode: arm64SVEEORUnpredicated, elementBits: 64, first: first, second: second, destination: destination}
+	} else if len(ins.Args) == 4 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+			return true, false, fmt.Errorf("arm64 %s predicated form requires one width and identical destructive operands: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEEOR{op: op, mode: arm64SVEEORPredicated, elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}
+	} else {
+		return true, false, fmt.Errorf("arm64 %s expects a Go 1.27 SVE logical form: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerRawSVEEOR(form)
+}
+
+func (c *arm64Ctx) lowerRawSVEEOR(form arm64RawSVEEOR) error {
+	first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	second := fmt.Sprintf("splat (i%d %d)", form.elementBits, form.immediate)
+	if form.mode != arm64SVEEORImmediate {
+		second, _, err = c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	llvmOp := "xor"
+	if form.op == "ZAND" || form.op == "ZBIC" {
+		llvmOp = "and"
+	} else if form.op == "ZORR" {
+		llvmOp = "or"
+	}
+	if form.op == "ZBIC" {
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, splat (i%d -1)\n", inverted, vectorType, second, form.elementBits)
+		second = "%" + inverted
+	}
+	calculated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", calculated, llvmOp, vectorType, first, second)
+	result := "%" + calculated
+	if form.mode == arm64SVEEORPredicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, result, vectorType, first)
+		result = "%" + selected
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, result)
+}
diff --git a/arm64_lower_sve_eor_interleave.go b/arm64_lower_sve_eor_interleave.go
new file mode 100644
index 000000000..45317ff5f
--- /dev/null
+++ b/arm64_lower_sve_eor_interleave.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEEORInterleaveIntrinsics = map[Op]string{
+	"ZEORBT": "eorbt",
+	"ZEORTB": "eortb",
+}
+
+func (c *arm64Ctx) lowerARM64SVEEORInterleave(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEEORInterleaveIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zn.T, Zd.T without a suffix: %q", op, ins.Raw)
+	}
+	third, thirdBits, thirdOK := arm64ParseSVEZElementReg(ins.Args[0])
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !thirdOK || !secondOK || !destinationOK || thirdBits != secondBits || secondBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s operands must use one matching B/H/S/D width: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(destination, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	thirdValue, _, err := c.loadZRegElements(third, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / destinationBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, destinationBits, vectorType, firstValue, vectorType, secondValue, vectorType, thirdValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_eor_interleave_test.go b/arm64_lower_sve_eor_interleave_test.go
new file mode 100644
index 000000000..4d5c5c8f4
--- /dev/null
+++ b/arm64_lower_sve_eor_interleave_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEEORInterleaveCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveeorinterleaveforms(SB),$0-0\n")
+	for _, op := range []string{"ZEORBT", "ZEORTB"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveeorinterleaveforms": {Name: "sveeorinterleaveforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.eorbt.nxv16i8", "@llvm.aarch64.sve.eortb.nxv2i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE EORBT/EORTB lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-eor-interleave.ll", "arm64-sve-eor-interleave.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEEORInterleaveRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZEORBT Z1.B, Z2.H, Z3.B",
+		"ZEORTB Z1.Q, Z2.Q, Z3.Q",
+		"ZEORBT Z1.S, Z2.S",
+		"ZEORTB.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveeorinterleave(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveeorinterleave": {Name: "badsveeorinterleave", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE EORBT/EORTB forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_eor_test.go b/arm64_lower_sve_eor_test.go
new file mode 100644
index 000000000..84471dcd4
--- /dev/null
+++ b/arm64_lower_sve_eor_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEEORUnpredicated(second, first, destination int) uint32 {
+	return 0x04a03000 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEEORPredicated(elementBits, second, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04190000 | size<<22 | uint32(second)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVEEORImmediateBits(imm13, destination int) uint32 {
+	return 0x05400000 | uint32(imm13)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVEEORCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT sveeornamed(SB),$0-0
+	ZEOR Z31.D, Z30.D, Z29.D
+	ZEOR Z28.B, Z0.B, P0.M, Z0.B
+	ZEOR Z27.H, Z1.H, P1.M, Z1.H
+	ZEOR Z26.S, Z2.S, P2.M, Z2.S
+	ZEOR Z25.D, Z3.D, P7.M, Z3.D
+	ZEOR $0x55, Z4.B, Z4.B
+	ZEOR $0xff00, Z5.H, Z5.H
+	ZEOR $0xffff0000, Z6.S, Z6.S
+	ZEOR $0xffffffff00000000, Z7.D, Z7.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT sveeorraw(SB),$0-0\n")
+	fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEEORUnpredicated(1, 2, 3))
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEEORPredicated(elementBits, 4, 5, 6))
+	}
+	for _, imm13 := range []int{0x03c, 0x227, 0x40f, 0x181f} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEEORImmediateBits(imm13, 7))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sveeor" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve"`, " xor <vscale x ", " select <vscale x "} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE EOR lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-eor.ll", "arm64-sve-eor.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEEORDecoderCoversEveryEncodingField(t *testing.T) {
+	for second := 0; second < 32; second++ {
+		for first := 0; first < 32; first++ {
+			for destination := 0; destination < 32; destination++ {
+				word := encodeARM64RawSVEEORUnpredicated(second, first, destination)
+				got, ok := decodeARM64RawSVEEOR(word)
+				if !ok || got.mode != arm64SVEEORUnpredicated || got.elementBits != 64 || got.second != second || got.first != first || got.destination != destination {
+					t.Fatalf("decoded unpredicated SVE EOR %#08x as %+v, ok=%v", word, got, ok)
+				}
+			}
+		}
+	}
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for second := 0; second < 32; second++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEEORPredicated(elementBits, second, predicate, destination)
+					got, ok := decodeARM64RawSVEEOR(word)
+					if !ok || got.mode != arm64SVEEORPredicated || got.elementBits != elementBits || got.second != second || got.first != destination || got.predicate != predicate || got.destination != destination {
+						t.Fatalf("decoded predicated SVE EOR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+	validImmediateEncodings := 0
+	for imm13 := 0; imm13 < 1<<13; imm13++ {
+		for destination := 0; destination < 32; destination++ {
+			word := encodeARM64RawSVEEORImmediateBits(imm13, destination)
+			got, ok := decodeARM64RawSVEEOR(word)
+			if !ok {
+				continue
+			}
+			if got.mode != arm64SVEEORImmediate || got.destination != destination || got.first != destination || got.immediate == 0 {
+				t.Fatalf("decoded immediate SVE EOR %#08x as %+v", word, got)
+			}
+			validImmediateEncodings++
+		}
+	}
+	if validImmediateEncodings != 7680*32 {
+		t.Fatalf("decoded %d valid SVE logical-immediate fields, want %d", validImmediateEncodings, 7680*32)
+	}
+}
+
+func TestARM64SVEEORLogicalImmediateKnownValuesAndInvalidForms(t *testing.T) {
+	for _, test := range []struct {
+		imm13, bits int
+		value       uint64
+	}{
+		{0x03c, 8, 0x55},
+		{0x227, 16, 0xff00},
+		{0x40f, 32, 0xffff0000},
+		{0x181f, 64, 0xffffffff00000000},
+	} {
+		got, ok := decodeARM64RawSVEEOR(encodeARM64RawSVEEORImmediateBits(test.imm13, 9))
+		if !ok || got.elementBits != test.bits || got.immediate != test.value {
+			t.Fatalf("logical immediate %#x decoded as %+v, ok=%v; want bits=%d value=%#x", test.imm13, got, ok, test.bits, test.value)
+		}
+	}
+	for _, word := range []uint32{0x04a03400, 0x041c0000, encodeARM64RawSVEEORImmediateBits(0x3f, 0)} {
+		if _, ok := decodeARM64RawSVEEOR(word); ok {
+			t.Fatalf("SVE EOR decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsveeor(SB),$0-0
+	ZEOR Z1.S, Z2.S, P0.M, Z3.S
+	ZEOR $0, Z4.D, Z4.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveeor": {Name: "badsveeor", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted invalid SVE EOR forms")
+	}
+}
diff --git a/arm64_lower_sve_expand.go b/arm64_lower_sve_expand.go
new file mode 100644
index 000000000..7501a2e23
--- /dev/null
+++ b/arm64_lower_sve_expand.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEExpand(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZEXPAND" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZEXPAND expects Zn.B|H|S|D, Pg, Zd.B|H|S|D without a suffix: %q", ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !predicateOK || !destinationOK || sourceBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 ZEXPAND requires matching B/H/S/D vectors and a bare P0..P7 predicate: %q", ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / sourceBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.expand.nxv%di%d(%s %s, %s %s)\n", result, vectorType, lanes, sourceBits, predicateType, predicateValue, vectorType, sourceValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_expand_test.go b/arm64_lower_sve_expand_test.go
new file mode 100644
index 000000000..93fce556e
--- /dev/null
+++ b/arm64_lower_sve_expand_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEExpandCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveexpand(SB),$0-0\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZEXPAND Z%d.%s, P%d, Z%d.%s\n", index+1, width, index, index+8, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveexpand": {Name: "sveexpand", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p2"`,
+				"@llvm.aarch64.sve.expand.nxv16i8",
+				"@llvm.aarch64.sve.expand.nxv8i16",
+				"@llvm.aarch64.sve.expand.nxv4i32",
+				"@llvm.aarch64.sve.expand.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE expand lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-expand.ll", "arm64-sve-expand.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEExpandRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZEXPAND Z1.B, P8, Z2.B",
+		"ZEXPAND Z1.H, P0.M, Z2.H",
+		"ZEXPAND Z1.S, P0.Z, Z2.S",
+		"ZEXPAND Z1.S, P0, Z2.D",
+		"ZEXPAND Z1.Q, P0, Z2.Q",
+		"ZEXPAND.Z Z1.D, P0, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveexpand(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveexpand": {Name: "badsveexpand", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE expand forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_ext.go b/arm64_lower_sve_ext.go
new file mode 100644
index 000000000..c864c1a62
--- /dev/null
+++ b/arm64_lower_sve_ext.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEEXT(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZEXT" && op != "ZEXTQ" {
+		return false, false, nil
+	}
+	if op == "ZEXTQ" {
+		return c.lowerARM64SVEEXTQ(ins)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) < 3 || len(ins.Args) > 4 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 255 {
+		return true, false, fmt.Errorf("arm64 ZEXT expects an unsigned 8-bit immediate and one Go 1.27 vector form: %q", ins.Raw)
+	}
+	immediate := ins.Args[0].Imm
+	var first, second, destination int
+	if len(ins.Args) == 4 {
+		var firstOK, secondOK, destinationOK bool
+		second, secondOK = arm64ParseSVEByteReg(ins.Args[1])
+		first, firstOK = arm64ParseSVEByteReg(ins.Args[2])
+		destination, destinationOK = arm64ParseSVEByteReg(ins.Args[3])
+		if !firstOK || !secondOK || !destinationOK || first != destination {
+			return true, false, fmt.Errorf("arm64 ZEXT destructive form requires $imm, Zm.B, Zdn.B, Zdn.B: %q", ins.Raw)
+		}
+	} else {
+		if ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 2 {
+			return true, false, fmt.Errorf("arm64 ZEXT list form requires exactly two consecutive byte vectors: %q", ins.Raw)
+		}
+		var firstOK, secondOK, destinationOK bool
+		first, firstOK = arm64ParseSVEByteReg(Operand{Kind: OpReg, Reg: ins.Args[1].RegList[0]})
+		second, secondOK = arm64ParseSVEByteReg(Operand{Kind: OpReg, Reg: ins.Args[1].RegList[1]})
+		destination, destinationOK = arm64ParseSVEByteReg(ins.Args[2])
+		if !firstOK || !secondOK || !destinationOK || first == 31 || second != first+1 {
+			return true, false, fmt.Errorf("arm64 ZEXT list form requires [Zn.B, Z(n+1).B], Zd.B: %q", ins.Raw)
+		}
+	}
+	firstValue, err := c.loadZReg(first)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, err := c.loadZReg(second)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.aarch64.sve.ext.nxv16i8(<vscale x 16 x i8> %s, <vscale x 16 x i8> %s, i32 %d)\n",
+		result, firstValue, secondValue, immediate)
+	return true, false, c.storeZReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEEXTQ(ins Instr) (ok bool, terminated bool, err error) {
+	if strings.ToUpper(string(ins.Op)) != "ZEXTQ" || len(ins.Args) != 4 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 15 {
+		return true, false, fmt.Errorf("arm64 ZEXTQ expects $imm4, Zm.B, Zdn.B, Zdn.B without a suffix: %q", ins.Raw)
+	}
+	second, secondOK := arm64ParseSVEByteReg(ins.Args[1])
+	first, firstOK := arm64ParseSVEByteReg(ins.Args[2])
+	destination, destinationOK := arm64ParseSVEByteReg(ins.Args[3])
+	if !firstOK || !secondOK || !destinationOK || first != destination {
+		return true, false, fmt.Errorf("arm64 ZEXTQ requires matching destructive byte-vector operands: %q", ins.Raw)
+	}
+	firstValue, err := c.loadZReg(first)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, err := c.loadZReg(second)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.aarch64.sve.extq.nxv16i8(<vscale x 16 x i8> %s, <vscale x 16 x i8> %s, i32 %d)\n",
+		result, firstValue, secondValue, ins.Args[0].Imm)
+	return true, false, c.storeZReg(destination, "%"+result)
+}
+
+func arm64ParseSVEByteReg(operand Operand) (int, bool) {
+	index, bits, ok := arm64ParseSVEZElementReg(operand)
+	return index, ok && bits == 8
+}
diff --git a/arm64_lower_sve_ext_test.go b/arm64_lower_sve_ext_test.go
new file mode 100644
index 000000000..aed1b367b
--- /dev/null
+++ b/arm64_lower_sve_ext_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEEXTCompleteGo127Family(t *testing.T) {
+	source := "TEXT sveextforms(SB),$0-0\n" +
+		"\tZEXT $0, Z2.B, Z1.B, Z1.B\n" +
+		"\tZEXT $255, Z4.B, Z3.B, Z3.B\n" +
+		"\tZEXT $6, [Z5.B, Z6.B], Z7.B\n" +
+		"\tZEXT $255, [Z30.B, Z31.B], Z8.B\n" +
+		"\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveextforms": {Name: "sveextforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.ext.nxv16i8",
+				"i32 0)",
+				"i32 255)",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE EXT lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-ext.ll", "arm64-sve-ext.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEEXTRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZEXT $-1, Z1.B, Z0.B, Z0.B",
+		"ZEXT $256, Z1.B, Z0.B, Z0.B",
+		"ZEXT $1, Z1.B, Z0.B, Z2.B",
+		"ZEXT $1, Z1.H, Z0.H, Z0.H",
+		"ZEXT $1, [Z1.B], Z0.B",
+		"ZEXT $1, [Z1.B, Z3.B], Z0.B",
+		"ZEXT $1, [Z31.B, Z0.B], Z0.B",
+		"ZEXT.Z $1, Z1.B, Z0.B, Z0.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveext(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveext": {Name: "badsveext", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE EXT forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEEXTQCompleteGo127Family(t *testing.T) {
+	source := "TEXT sveextqforms(SB),$0-0\n" +
+		"\tZEXTQ $0, Z2.B, Z1.B, Z1.B\n" +
+		"\tZEXTQ $15, Z4.B, Z3.B, Z3.B\n" +
+		"\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveextqforms": {Name: "sveextqforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2p1\"",
+				"@llvm.aarch64.sve.extq.nxv16i8",
+				"i32 0)",
+				"i32 15)",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE EXTQ lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-extq.ll", "arm64-sve-extq.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEEXTQRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZEXTQ $-1, Z1.B, Z0.B, Z0.B",
+		"ZEXTQ $16, Z1.B, Z0.B, Z0.B",
+		"ZEXTQ $1, Z1.B, Z0.B, Z2.B",
+		"ZEXTQ $1, Z1.H, Z0.H, Z0.H",
+		"ZEXTQ $1, [Z1.B, Z2.B], Z0.B",
+		"ZEXTQ.Z $1, Z1.B, Z0.B, Z0.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveextq(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveextq": {Name: "badsveextq", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE EXTQ forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_fdot.go b/arm64_lower_sve_fdot.go
new file mode 100644
index 000000000..9574fabb3
--- /dev/null
+++ b/arm64_lower_sve_fdot.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFDOTForm struct {
+	first, second, destination  int
+	sourceBits, destinationBits int
+	lane                        int
+	indexed                     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEFDOT(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFDOT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZFDOT expects one complete Go 1.27 vector or indexed form without a suffix: %q", ins.Raw)
+	}
+	form := arm64SVEFDOTForm{}
+	if first, sourceBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0]); firstOK {
+		form.first, form.sourceBits = first, sourceBits
+	} else {
+		first, sourceBits, lane, firstOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !firstOK || first > 7 {
+			return true, false, fmt.Errorf("arm64 ZFDOT indexed source must use Z0..Z7: %q", ins.Raw)
+		}
+		form.first, form.sourceBits, form.lane, form.indexed = first, sourceBits, lane, true
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	validWidths := (form.sourceBits == 8 && (destinationBits == 16 || destinationBits == 32)) || (form.sourceBits == 16 && destinationBits == 32)
+	if !secondOK || !destinationOK || secondBits != form.sourceBits || !validWidths {
+		return true, false, fmt.Errorf("arm64 ZFDOT requires B sources with an H/S accumulator or H sources with an S accumulator: %q", ins.Raw)
+	}
+	if form.indexed {
+		maxLane := 3
+		if form.sourceBits == 8 && destinationBits == 16 {
+			maxLane = 7
+		}
+		if form.lane > maxLane {
+			return true, false, fmt.Errorf("arm64 ZFDOT lane is outside the selected dot-product group range: %q", ins.Raw)
+		}
+	}
+	form.second, form.destination, form.destinationBits = second, destination, destinationBits
+	return true, false, c.lowerARM64SVEFDOTForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFDOTForm(form arm64SVEFDOTForm) error {
+	accumulator, accumulatorType, err := c.loadRawSVEFloatVector(form.destination, form.destinationBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.sourceBits == 8 {
+		first, err := c.loadZReg(form.first)
+		if err != nil {
+			return err
+		}
+		second, err := c.loadZReg(form.second)
+		if err != nil {
+			return err
+		}
+		lanes := 128 / form.destinationBits
+		mangle := map[int]string{16: "f16", 32: "f32"}[form.destinationBits]
+		if form.indexed {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fp8.fdot.lane.nxv%d%s(%s %s, <vscale x 16 x i8> %s, <vscale x 16 x i8> %s, i32 %d)\n", result, accumulatorType, lanes, mangle, accumulatorType, accumulator, second, first, form.lane)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fp8.fdot.nxv%d%s(%s %s, <vscale x 16 x i8> %s, <vscale x 16 x i8> %s)\n", result, accumulatorType, lanes, mangle, accumulatorType, accumulator, second, first)
+		}
+	} else {
+		first, _, err := c.loadRawSVEFloatVector(form.first, 16)
+		if err != nil {
+			return err
+		}
+		second, _, err := c.loadRawSVEFloatVector(form.second, 16)
+		if err != nil {
+			return err
+		}
+		if form.indexed {
+			fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x float> @llvm.aarch64.sve.fdot.lane.x2.nxv4f32(<vscale x 4 x float> %s, <vscale x 8 x half> %s, <vscale x 8 x half> %s, i32 %d)\n", result, accumulator, second, first, form.lane)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x float> @llvm.aarch64.sve.fdot.x2.nxv4f32(<vscale x 4 x float> %s, <vscale x 8 x half> %s, <vscale x 8 x half> %s)\n", result, accumulator, second, first)
+		}
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.destinationBits, "%"+result, accumulatorType)
+}
+
+func arm64SVEFDOTFeatureClass(ins Instr) (sourceBits, destinationBits int, ok bool) {
+	if len(ins.Args) != 3 {
+		return 0, 0, false
+	}
+	_, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	if !sourceOK {
+		_, sourceBits, _, sourceOK = arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+	}
+	_, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	return sourceBits, destinationBits, sourceOK && destinationOK
+}
diff --git a/arm64_lower_sve_fdot_test.go b/arm64_lower_sve_fdot_test.go
new file mode 100644
index 000000000..9f80b4b24
--- /dev/null
+++ b/arm64_lower_sve_fdot_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFDOTCompleteGo127Family(t *testing.T) {
+	const source = `TEXT svefdot(SB),$0-0
+	ZFDOT Z8.B, Z9.B, Z10.H
+	ZFDOT Z11.B, Z12.B, Z13.S
+	ZFDOT Z14.H, Z15.H, Z16.S
+	ZFDOT Z0.B[0], Z17.B, Z18.H
+	ZFDOT Z7.B[7], Z19.B, Z20.H
+	ZFDOT Z0.B[0], Z21.B, Z22.S
+	ZFDOT Z7.B[3], Z23.B, Z24.S
+	ZFDOT Z0.H[0], Z25.H, Z26.S
+	ZFDOT Z7.H[3], Z27.H, Z28.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefdot": {Name: "svefdot", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+f16f32dot,+fp8,+ssve-fp8dot2,+ssve-fp8dot4,+sve,+sve2,+sve2p1,+sve2p2"`,
+				"@llvm.aarch64.sve.fp8.fdot.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fdot.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fdot.lane.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fdot.lane.nxv4f32",
+				"@llvm.aarch64.sve.fdot.x2.nxv4f32",
+				"@llvm.aarch64.sve.fdot.lane.x2.nxv4f32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZFDOT lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-fdot.ll", "arm64-sve-fdot.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFDOTRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFDOT Z1.S, Z2.S, Z3.D",
+		"ZFDOT Z1.B, Z2.H, Z3.S",
+		"ZFDOT Z8.B[0], Z2.B, Z3.H",
+		"ZFDOT Z7.B[8], Z2.B, Z3.H",
+		"ZFDOT Z7.B[4], Z2.B, Z3.S",
+		"ZFDOT Z7.H[4], Z2.H, Z3.S",
+		"ZFDOT Z7.H[3], Z2.H, Z3.H",
+		"ZFDOT.Z Z1.B, Z2.B, Z3.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefdot(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefdot": {Name: "badsvefdot", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZFDOT forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_first_fault_memory.go b/arm64_lower_sve_first_fault_memory.go
new file mode 100644
index 000000000..675923914
--- /dev/null
+++ b/arm64_lower_sve_first_fault_memory.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFirstFaultMemorySpec struct {
+	memoryBits int
+	signed     bool
+}
+
+// arm64SVEFirstFaultMemorySpecs covers every Go 1.27 LDFF1 spelling,
+// including its widening unsigned and sign-extending variants.
+var arm64SVEFirstFaultMemorySpecs = map[Op]arm64SVEFirstFaultMemorySpec{
+	"ZLDFF1B":  {memoryBits: 8},
+	"ZLDFF1H":  {memoryBits: 16},
+	"ZLDFF1W":  {memoryBits: 32},
+	"ZLDFF1D":  {memoryBits: 64},
+	"ZLDFF1SB": {memoryBits: 8, signed: true},
+	"ZLDFF1SH": {memoryBits: 16, signed: true},
+	"ZLDFF1SW": {memoryBits: 32, signed: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEFirstFaultMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFirstFaultMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s expects memory, predicate, vector-list operands: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	vectors, elementBits, vectorsOK := arm64ParseSVEConsecutiveVectorList(ins.Args[2])
+	if !predicateOK || !vectorsOK || len(vectors) != 1 || elementBits < spec.memoryBits || spec.signed && elementBits == spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s has predicate or destination widths outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+
+	memory := ins.Args[0].Mem
+	if _, _, vectorOffset := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorOffset {
+		return c.lowerARM64SVEFirstFaultVectorOffset(op, spec, memory, predicate, vectors[0], elementBits, ins)
+	}
+	if _, _, vectorBase := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base}); vectorBase {
+		return c.lowerARM64SVEFirstFaultVectorBase(op, spec, memory, predicate, vectors[0], elementBits, ins)
+	}
+	return c.lowerARM64SVEFirstFaultContiguous(op, spec, memory, predicate, vectors[0], elementBits, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFirstFaultContiguous(op Op, spec arm64SVEFirstFaultMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	address, err := c.arm64SVERegisterOffsetAddress(memory, int64(spec.memoryBits/8))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldff1.nxv%di%d(%s %s, ptr %%%s)\n",
+		loaded, loadedType, lanes, spec.memoryBits, predicateType, predicateValue, pointer)
+	return c.finishARM64SVEFirstFaultLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFirstFaultVectorOffset(op Op, spec arm64SVEFirstFaultMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s vector-offset form does not accept a displacement: %q", op, ins.Raw)
+	}
+	baseReg, baseOK := arm64SVEPhysicalMemoryBase(memory.Base)
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	byteScale := int64(spec.memoryBits / 8)
+	if !baseOK || !indexOK || indexBits != elementBits || (elementBits != 32 && elementBits != 64) || (memory.Scale != 1 && memory.Scale != byteScale) {
+		return true, false, fmt.Errorf("arm64 %s vector offset has widths or scale outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+
+	extension := ""
+	switch memory.IndexExt {
+	case "":
+		if indexBits != 64 {
+			return true, false, fmt.Errorf("arm64 %s unextended vector offset requires Zm.D: %q", op, ins.Raw)
+		}
+	case ExtendUXTW:
+		extension = "uxtw"
+	case ExtendSXTW:
+		extension = "sxtw"
+	default:
+		return true, false, fmt.Errorf("arm64 %s vector offset only accepts UXTW or SXTW: %q", op, ins.Raw)
+	}
+
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return true, false, err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, base)
+	indexValue, indexType, err := c.loadZRegElements(index, indexBits)
+	if err != nil {
+		return true, false, err
+	}
+	// Go accepts Zm.D.UXTW/SXTW. LLVM models the UXTW/SXTW gather intrinsics
+	// with 32-bit lanes, so explicitly extend the low word of each D lane and
+	// use the equivalent D-offset intrinsic.
+	if extension != "" && indexBits == 64 {
+		narrowType := "<vscale x 2 x i32>"
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", narrow, indexType, indexValue, narrowType)
+		extended := c.newTmp()
+		opcode := "zext"
+		if extension == "sxtw" {
+			opcode = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %%%s to %s\n", extended, opcode, narrowType, narrow, indexType)
+		indexValue = "%" + extended
+		extension = ""
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	suffix := ""
+	if extension != "" {
+		suffix = "." + extension
+	}
+	if byteScale > 1 && memory.Scale == byteScale {
+		suffix += ".index"
+	}
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldff1.gather%s.nxv%di%d(%s %s, ptr %%%s, %s %s)\n",
+		loaded, loadedType, suffix, lanes, spec.memoryBits, predicateType, predicateValue, pointer, indexType, indexValue)
+	return c.finishARM64SVEFirstFaultLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFirstFaultVectorBase(op Op, spec arm64SVEFirstFaultMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	base, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base})
+	alignment := int64(spec.memoryBits / 8)
+	maximum := int64(31) * alignment
+	if !baseOK || baseBits != elementBits || (elementBits != 32 && elementBits != 64) || memory.Index != "" || memory.IndexExt != "" || memory.Sym != "" || memory.Segment != "" || memory.OffRaw != "" || memory.Off < 0 || memory.Off > maximum || memory.Off%alignment != 0 {
+		return true, false, fmt.Errorf("arm64 %s vector-base offset must match the destination width, be aligned to %d, and be in [0,%d]: %q", op, alignment, maximum, ins.Raw)
+	}
+	baseValue, baseType, err := c.loadZRegElements(base, baseBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldff1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s %s, %s %s, i64 %d)\n",
+		loaded, loadedType, lanes, spec.memoryBits, lanes, elementBits, predicateType, predicateValue, baseType, baseValue, memory.Off)
+	return c.finishARM64SVEFirstFaultLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) finishARM64SVEFirstFaultLoad(spec arm64SVEFirstFaultMemorySpec, destination, elementBits int, loadedType, loaded string) (ok bool, terminated bool, err error) {
+	value := loaded
+	if spec.memoryBits < elementBits {
+		vectorType, _, err := arm64SVEVectorType(elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		extended := c.newTmp()
+		extension := "zext"
+		if spec.signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, loadedType, value, vectorType)
+		value = "%" + extended
+	}
+	return true, false, c.storeZRegElements(destination, elementBits, value)
+}
diff --git a/arm64_lower_sve_first_fault_memory_test.go b/arm64_lower_sve_first_fault_memory_test.go
new file mode 100644
index 000000000..bf906fa74
--- /dev/null
+++ b/arm64_lower_sve_first_fault_memory_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64SVEFirstFaultMemoryCompleteGo127Forms() string {
+	return `TEXT svefirstfaultmemoryforms(SB),$0-0
+	ZLDFF1B (R7)(RSP), P4.Z, [Z13.B]
+	ZLDFF1B (R6)(R14), P4.Z, [Z13.H]
+	ZLDFF1B (R5)(R27), P3.Z, [Z6.S]
+	ZLDFF1B (R2)(R3), P2.Z, [Z24.D]
+	ZLDFF1B (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1B (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1B (Z5.D.SXTW)(R12), P2.Z, [Z11.D]
+	ZLDFF1B (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLDFF1B (Z9.S.SXTW)(R8), P5.Z, [Z10.S]
+	ZLDFF1B (Z7.S), P4.Z, [Z13.S]
+	ZLDFF1B 31(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1H (R7<<1)(R14), P4.Z, [Z13.H]
+	ZLDFF1H (R6<<1)(R14), P4.Z, [Z13.S]
+	ZLDFF1H (R5<<1)(R27), P3.Z, [Z6.D]
+	ZLDFF1H (Z10.D)(RSP), P3.Z, [Z15.D]
+	ZLDFF1H (Z23.D<<1)(R24), P1.Z, [Z22.D]
+	ZLDFF1H (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1H (Z5.D.SXTW<<1)(R12), P2.Z, [Z11.D]
+	ZLDFF1H (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLDFF1H (Z4.S.UXTW<<1)(R3), P3.Z, [Z4.S]
+	ZLDFF1H (Z9.S.SXTW<<1)(R8), P5.Z, [Z10.S]
+	ZLDFF1H (Z7.S), P4.Z, [Z13.S]
+	ZLDFF1H 62(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1W (R7<<2)(R14), P4.Z, [Z13.S]
+	ZLDFF1W (R6<<2)(R14), P4.Z, [Z13.D]
+	ZLDFF1W (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1W (Z23.D<<2)(R24), P1.Z, [Z22.D]
+	ZLDFF1W (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1W (Z5.D.SXTW<<2)(R12), P2.Z, [Z11.D]
+	ZLDFF1W (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLDFF1W (Z4.S.UXTW<<2)(R3), P3.Z, [Z4.S]
+	ZLDFF1W (Z9.S.SXTW<<2)(R8), P5.Z, [Z10.S]
+	ZLDFF1W (Z7.S), P4.Z, [Z13.S]
+	ZLDFF1W 124(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1D (R7<<3)(R14), P4.Z, [Z13.D]
+	ZLDFF1D (R6<<3)(R14), P4.Z, [Z13.D]
+	ZLDFF1D (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1D (Z23.D<<3)(R24), P1.Z, [Z22.D]
+	ZLDFF1D (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1D (Z5.D.SXTW<<3)(R12), P2.Z, [Z11.D]
+	ZLDFF1D (Z7.D), P4.Z, [Z13.D]
+	ZLDFF1D 248(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1SB (R7)(R14), P4.Z, [Z13.H]
+	ZLDFF1SB (R6)(R14), P4.Z, [Z13.S]
+	ZLDFF1SB (R5)(R27), P3.Z, [Z6.D]
+	ZLDFF1SB (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1SB (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1SB (Z5.D.SXTW)(R12), P2.Z, [Z11.D]
+	ZLDFF1SB (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLDFF1SB (Z9.S.SXTW)(R8), P5.Z, [Z10.S]
+	ZLDFF1SB (Z7.S), P4.Z, [Z13.S]
+	ZLDFF1SB 31(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1SH (R7<<1)(R14), P4.Z, [Z13.S]
+	ZLDFF1SH (R6<<1)(R14), P4.Z, [Z13.D]
+	ZLDFF1SH (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1SH (Z23.D<<1)(R24), P1.Z, [Z22.D]
+	ZLDFF1SH (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1SH (Z5.D.SXTW<<1)(R12), P2.Z, [Z11.D]
+	ZLDFF1SH (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLDFF1SH (Z4.S.UXTW<<1)(R3), P3.Z, [Z4.S]
+	ZLDFF1SH (Z9.S.SXTW<<1)(R8), P5.Z, [Z10.S]
+	ZLDFF1SH (Z7.S), P4.Z, [Z13.S]
+	ZLDFF1SH 62(Z7.D), P4.Z, [Z13.D]
+
+	ZLDFF1SW (R7<<2)(R14), P4.Z, [Z13.D]
+	ZLDFF1SW (R6<<2)(R14), P4.Z, [Z13.D]
+	ZLDFF1SW (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLDFF1SW (Z23.D<<2)(R24), P1.Z, [Z22.D]
+	ZLDFF1SW (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLDFF1SW (Z5.D.SXTW<<2)(R12), P2.Z, [Z11.D]
+	ZLDFF1SW (Z7.D), P4.Z, [Z13.D]
+	ZLDFF1SW 124(Z7.D), P4.Z, [Z13.D]
+	RET
+`
+}
+
+func TestTranslateARM64SVEFirstFaultMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEFirstFaultMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"svefirstfaultmemoryforms": {Name: "svefirstfaultmemoryforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			ll := module.String()
+			function := module.NamedFunction("svefirstfaultmemoryforms")
+			if function.IsNil() || function.FirstBasicBlock().IsNil() {
+				t.Fatal("complete first-fault memory function disappeared")
+			}
+			calls := make(map[string]int)
+			for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+				for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+					if ins.InstructionOpcode() == llvm.Call {
+						calls[ins.CalledValue().Name()]++
+					}
+				}
+			}
+			// Independently count the fixture's 68 existing source operations
+			// and the three official S-lane scaled-UXTW rows added above.
+			wantKinds := map[string]int{
+				"": 18, "gather.": 16, "gather.index.": 10,
+				"gather.uxtw.": 5, "gather.uxtw.index.": 3,
+				"gather.sxtw.": 2, "gather.sxtw.index.": 3,
+				"gather.scalar.offset.": 14,
+			}
+			kinds := make(map[string]int)
+			for name, count := range calls {
+				const prefix = "llvm.aarch64.sve.ldff1."
+				if !strings.HasPrefix(name, prefix) {
+					continue
+				}
+				suffix := strings.TrimPrefix(name, prefix)
+				at := strings.Index(suffix, "nxv")
+				if at < 0 {
+					t.Fatal("first-fault call lost its scalable vector type", name)
+				}
+				kind := suffix[:at]
+				if _, known := wantKinds[kind]; !known {
+					t.Fatal("unexpected first-fault memory call", name)
+				}
+				kinds[kind] += count
+			}
+			for kind, count := range wantKinds {
+				if kinds[kind] != count {
+					t.Errorf("first-fault %q: got %d actual calls, want %d", kind, kinds[kind], count)
+				}
+			}
+			for name, count := range map[string]int{
+				"llvm.aarch64.sve.ldff1.gather.uxtw.index.nxv4i16": 2,
+				"llvm.aarch64.sve.ldff1.gather.uxtw.index.nxv4i32": 1,
+			} {
+				if calls[name] != count {
+					t.Errorf("%s: got %d actual calls, want %d", name, calls[name], count)
+				}
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.ldff1.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.index.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.uxtw.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.uxtw.index.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.sxtw.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.sxtw.index.nxv",
+				"@llvm.aarch64.sve.ldff1.gather.scalar.offset.",
+				" sext <vscale x ",
+				" zext <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE first-fault memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-first-fault-memory.ll", "arm64-sve-first-fault-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFirstFaultMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLDFF1B (R6)(R14), P8.Z, [Z13.B]",
+		"ZLDFF1H (R6)(R14), P4.Z, [Z13.H]",
+		"ZLDFF1W (R6<<1)(R14), P4.Z, [Z13.S]",
+		"ZLDFF1D (R6<<2)(R14), P4.Z, [Z13.D]",
+		"ZLDFF1SB (R6)(R14), P4.Z, [Z13.B]",
+		"ZLDFF1SH (R6<<1)(R14), P4.Z, [Z13.H]",
+		"ZLDFF1SW (R6<<2)(R14), P4.Z, [Z13.S]",
+		"ZLDFF1B (Z4.S)(R3), P3.Z, [Z4.S]",
+		"ZLDFF1H (Z4.S.UXTW<<2)(R3), P3.Z, [Z4.S]",
+		"ZLDFF1W (Z4.D.UXTW<<1)(R3), P3.Z, [Z4.D]",
+		"ZLDFF1D (Z4.S.UXTW<<3)(R3), P3.Z, [Z4.D]",
+		"ZLDFF1B -1(Z7.S), P4.Z, [Z13.S]",
+		"ZLDFF1H 3(Z7.S), P4.Z, [Z13.S]",
+		"ZLDFF1W 128(Z7.S), P4.Z, [Z13.S]",
+		"ZLDFF1D 256(Z7.D), P4.Z, [Z13.D]",
+		"ZLDFF1W 12(Z7.D), P4.Z, [Z13.S]",
+		"ZLDFF1B (R6)(R14), P4.Z, [Z13.B-Z14.B]",
+		"ZLDFF1B.Z (R6)(R14), P4.Z, [Z13.B]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefirstfaultmemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefirstfaultmemory": {Name: "badsvefirstfaultmemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's first-fault memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_add_sub.go b/arm64_lower_sve_float_add_sub.go
new file mode 100644
index 000000000..4bb31185c
--- /dev/null
+++ b/arm64_lower_sve_float_add_sub.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type arm64SVEFloatAddSubSpec struct {
+	operation    string
+	reverse      bool
+	unpredicated bool
+}
+
+var arm64SVEFloatAddSubSpecs = map[Op]arm64SVEFloatAddSubSpec{
+	"ZFADD":  {operation: "fadd", unpredicated: true},
+	"ZFSUB":  {operation: "fsub", unpredicated: true},
+	"ZFSUBR": {operation: "fsub", reverse: true},
+}
+
+type arm64SVEFloatAddSubForm struct {
+	elementBits  int
+	first        int
+	second       int
+	predicate    int
+	destination  int
+	immediate    float64
+	hasImmediate bool
+	predicated   bool
+}
+
+func arm64SVEFloatElementReg(operand Operand) (index, elementBits int, ok bool) {
+	index, elementBits, ok = arm64ParseSVEZElementReg(operand)
+	return index, elementBits, ok && elementBits >= 16
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFloatAddSubSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+
+	form := arm64SVEFloatAddSubForm{}
+	if len(ins.Args) == 3 {
+		second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+		if !spec.unpredicated || !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s does not accept this unpredicated floating vector form: %q", op, ins.Raw)
+		}
+		form = arm64SVEFloatAddSubForm{elementBits: firstBits, first: first, second: second, destination: destination}
+	} else if len(ins.Args) == 4 {
+		first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+		if !firstOK || !predicateOK || !destinationOK || first != destination || firstBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s requires identical predicated destructive floating registers: %q", op, ins.Raw)
+		}
+		form = arm64SVEFloatAddSubForm{elementBits: firstBits, first: first, predicate: predicate, destination: destination, predicated: true}
+		if ins.Args[0].Kind == OpImm {
+			if ins.Args[0].ImmRaw != "" || !ins.Args[0].ImmIsFloat {
+				return true, false, fmt.Errorf("arm64 %s immediate requires $(0.5) or $(1.0): %q", op, ins.Raw)
+			}
+			form.immediate = math.Float64frombits(uint64(ins.Args[0].Imm))
+			constants := arm64SVEFloatArithmeticSpecs[op].constants
+			if form.immediate != constants[0] && form.immediate != constants[1] {
+				return true, false, fmt.Errorf("arm64 %s immediate requires $(0.5) or $(1.0): %q", op, ins.Raw)
+			}
+			form.hasImmediate = true
+		} else {
+			second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+			if !secondOK || secondBits != firstBits {
+				return true, false, fmt.Errorf("arm64 %s predicated source must match the destination element width: %q", op, ins.Raw)
+			}
+			form.second = second
+		}
+	} else {
+		return true, false, fmt.Errorf("arm64 %s expects one of its Go 1.27 SVE floating forms: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEFloatAddSubForm(spec, form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatAddSubForm(spec arm64SVEFloatAddSubSpec, form arm64SVEFloatAddSubForm) error {
+	first, vectorType, err := c.loadRawSVEFloatVector(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	second := ""
+	if form.hasImmediate {
+		integerType, lanes, err := arm64SVEVectorType(form.elementBits)
+		if err != nil {
+			return err
+		}
+		var bits uint64
+		switch form.elementBits {
+		case 16:
+			bits = uint64(arm64Float16Bits(form.immediate))
+		case 32:
+			bits = uint64(math.Float32bits(float32(form.immediate)))
+		case 64:
+			bits = math.Float64bits(form.immediate)
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s splat (i%d %d) to <vscale x %d x %s>\n", converted, integerType, form.elementBits, bits, lanes, map[int]string{16: "half", 32: "float", 64: "double"}[form.elementBits])
+		second = "%" + converted
+	} else {
+		second, _, err = c.loadRawSVEFloatVector(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	left, right := first, second
+	if spec.reverse {
+		left, right = right, left
+	}
+	calculated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", calculated, spec.operation, vectorType, left, right)
+	result := "%" + calculated
+	if form.predicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, result, vectorType, first)
+		result = "%" + selected
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, result, vectorType)
+}
diff --git a/arm64_lower_sve_float_add_sub_test.go b/arm64_lower_sve_float_add_sub_test.go
new file mode 100644
index 000000000..288054d88
--- /dev/null
+++ b/arm64_lower_sve_float_add_sub_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEFloatAddSubForms(op string) string {
+	var source strings.Builder
+	function := "sve" + strings.ToLower(op) + "forms"
+	source.WriteString("TEXT " + function + "(SB),$0-0\n")
+	for index, width := range []string{"H", "S", "D"} {
+		predicate := string(rune('0' + index))
+		if op != "ZFSUBR" {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + width + "\n")
+		}
+		source.WriteString("\t" + op + " Z4." + width + ", Z5." + width + ", P" + predicate + ".M, Z5." + width + "\n")
+		for _, immediate := range []string{"0.5", "1.0"} {
+			source.WriteString("\t" + op + " $(" + immediate + "), Z6." + width + ", P" + predicate + ".M, Z6." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEFloatAddSubCompleteGo127Family(t *testing.T) {
+	for _, op := range []string{"ZFADD", "ZFSUB", "ZFSUBR"} {
+		t.Run(op, func(t *testing.T) {
+			source := arm64SVEFloatAddSubForms(op)
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sve" + strings.ToLower(op) + "forms"
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					operation := "fadd"
+					if op != "ZFADD" {
+						operation = "fsub"
+					}
+					for _, want := range []string{`"target-features"="+sve"`, " " + operation + " <vscale x ", " select <vscale x ", "bitcast <vscale x"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("%s SVE float add/sub lowering for %s omitted %q:\n%s", triple, op, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-float-add-sub.ll", "arm64-sve-float-add-sub.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatAddSubRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFADD Z1.B, Z2.B, Z3.B",
+		"ZFSUBR Z1.S, Z2.S, Z3.S",
+		"ZFSUB Z1.S, Z2.D, Z3.S",
+		"ZFADD Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFSUB $(2.0), Z1.D, P0.M, Z1.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloataddsub(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloataddsub": {Name: "badsvefloataddsub", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating add/sub forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_complex_add.go b/arm64_lower_sve_float_complex_add.go
new file mode 100644
index 000000000..fdeab7d0d
--- /dev/null
+++ b/arm64_lower_sve_float_complex_add.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEFloatComplexAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFCADD" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 5 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 ZFCADD expects $90|$270, Zm.H|S|D, Zdn.H|S|D, P0..P7/M, Zdn.H|S|D without a suffix: %q", ins.Raw)
+	}
+	rotation := ins.Args[0].Imm
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[1])
+	first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[2])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[3], "M", 7)
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[4])
+	if (rotation != 90 && rotation != 270) || !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || destinationBits != firstBits || destination != first {
+		return true, false, fmt.Errorf("arm64 ZFCADD requires rotation $90/$270, matching destructive H/S/D operands, and P0..P7/M: %q", ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadRawSVEFloatVector(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadRawSVEFloatVector(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, err := arm64SVEFloatType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[firstBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fcadd.nxv%d%s(%s %s, %s %s, %s %s, i32 %d)\n", result, vectorType, lanes, mangle, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue, rotation)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n", selected, predicateType, predicateValue, vectorType, result, vectorType, firstValue)
+	return true, false, c.storeRawSVEFloatVector(destination, firstBits, "%"+selected, vectorType)
+}
diff --git a/arm64_lower_sve_float_complex_add_test.go b/arm64_lower_sve_float_complex_add_test.go
new file mode 100644
index 000000000..b99e3f73c
--- /dev/null
+++ b/arm64_lower_sve_float_complex_add_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatComplexAddCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatcomplexadd(SB),$0-0\n")
+	for widthIndex, width := range []string{"H", "S", "D"} {
+		for rotationIndex, rotation := range []int{90, 270} {
+			destination := widthIndex*2 + rotationIndex
+			fmt.Fprintf(&source, "\tZFCADD $%d, Z%d.%s, Z%d.%s, P%d.M, Z%d.%s\n", rotation, destination+16, width, destination, width, destination+2, destination, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatcomplexadd": {Name: "svefloatcomplexadd", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.fcadd.nxv8f16",
+				"@llvm.aarch64.sve.fcadd.nxv4f32",
+				"@llvm.aarch64.sve.fcadd.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating complex-add lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-complex-add.ll", "arm64-sve-float-complex-add.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatComplexAddRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFCADD $0, Z1.H, Z2.H, P0.M, Z2.H",
+		"ZFCADD $180, Z1.S, Z2.S, P0.M, Z2.S",
+		"ZFCADD $90, Z1.B, Z2.B, P0.M, Z2.B",
+		"ZFCADD $90, Z1.S, Z2.D, P0.M, Z2.D",
+		"ZFCADD $270, Z1.D, Z2.D, P8.M, Z2.D",
+		"ZFCADD $270, Z1.D, Z2.D, P0.Z, Z2.D",
+		"ZFCADD $270, Z1.D, Z2.D, P0.M, Z3.D",
+		"ZFCADD.Z $270, Z1.D, Z2.D, P0.M, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatcomplexadd(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatcomplexadd": {Name: "badsvefloatcomplexadd", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating complex-add forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_complex_multiply_accumulate.go b/arm64_lower_sve_float_complex_multiply_accumulate.go
new file mode 100644
index 000000000..2e034ecf9
--- /dev/null
+++ b/arm64_lower_sve_float_complex_multiply_accumulate.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFloatComplexMultiplyAccumulateForm struct {
+	elementBits  int
+	multiplier   int
+	multiplicand int
+	predicate    int
+	lane         int
+	rotation     int
+	destination  int
+	indexed      bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatComplexMultiplyAccumulate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFCMLA" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 4 && len(ins.Args) != 5) {
+		return true, false, fmt.Errorf("arm64 ZFCMLA expects one complete Go 1.27 form without a suffix: %q", ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+		return true, false, fmt.Errorf("arm64 ZFCMLA rotation must be 0, 90, 180, or 270: %q", ins.Raw)
+	}
+	rotation := int(ins.Args[0].Imm)
+	if rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270 {
+		return true, false, fmt.Errorf("arm64 ZFCMLA rotation must be 0, 90, 180, or 270: %q", ins.Raw)
+	}
+	form := arm64SVEFloatComplexMultiplyAccumulateForm{rotation: rotation}
+	if len(ins.Args) == 5 {
+		multiplier, multiplierBits, multiplierOK := arm64SVEFloatElementReg(ins.Args[1])
+		multiplicand, multiplicandBits, multiplicandOK := arm64SVEFloatElementReg(ins.Args[2])
+		predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[3], "M", 7)
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[4])
+		if !multiplierOK || !multiplicandOK || !predicateOK || !destinationOK || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZFCMLA predicated operands must use one H/S/D width and P0..P7.M: %q", ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.predicate = predicate
+		form.destination = destination
+	} else {
+		multiplier, multiplierBits, lane, multiplierOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[1])
+		multiplicand, multiplicandBits, multiplicandOK := arm64SVEFloatElementReg(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+		maximumVector, vectorOK := map[int]int{16: 7, 32: 15}[multiplierBits]
+		maximumLane, laneOK := map[int]int{16: 3, 32: 1}[multiplierBits]
+		if !multiplierOK || !multiplicandOK || !destinationOK || !vectorOK || !laneOK || multiplier > maximumVector || lane > maximumLane || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZFCMLA indexed operands must use an encodable H/S complex lane: %q", ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.lane = lane
+		form.destination = destination
+		form.indexed = true
+	}
+	return true, false, c.lowerARM64SVEFloatComplexMultiplyAccumulateForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatComplexMultiplyAccumulateForm(form arm64SVEFloatComplexMultiplyAccumulateForm) error {
+	accumulator, vectorType, err := c.loadRawSVEFloatVector(form.destination, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplicand, _, err := c.loadRawSVEFloatVector(form.multiplicand, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplier, _, err := c.loadRawSVEFloatVector(form.multiplier, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, _, lanes, _ := arm64SVEFloatType(form.elementBits)
+	code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits]
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fcmla.lane.nxv%d%s(%s %s, %s %s, %s %s, i32 %d, i32 %d)\n",
+			result, vectorType, lanes, code, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier, form.lane, form.rotation)
+	} else {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fcmla.nxv%d%s(%s %s, %s %s, %s %s, %s %s, i32 %d)\n",
+			result, vectorType, lanes, code, predicateType, predicate, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier, form.rotation)
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_complex_multiply_accumulate_test.go b/arm64_lower_sve_float_complex_multiply_accumulate_test.go
new file mode 100644
index 000000000..3dc339b12
--- /dev/null
+++ b/arm64_lower_sve_float_complex_multiply_accumulate_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatComplexMultiplyAccumulateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatcomplexmultiplyaccumulateforms(SB),$0-0\n")
+	for _, rotation := range []int{0, 90, 180, 270} {
+		for _, width := range []string{"H", "S", "D"} {
+			fmt.Fprintf(&source, "\tZFCMLA $%d, Z31.%s, Z2.%s, P7.M, Z3.%s\n", rotation, width, width, width)
+		}
+		fmt.Fprintf(&source, "\tZFCMLA $%d, Z7.H[3], Z4.H, Z5.H\n", rotation)
+		fmt.Fprintf(&source, "\tZFCMLA $%d, Z15.S[1], Z6.S, Z7.S\n", rotation)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatcomplexmultiplyaccumulateforms": {Name: "svefloatcomplexmultiplyaccumulateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.fcmla.nxv8f16",
+				"@llvm.aarch64.sve.fcmla.nxv2f64",
+				"@llvm.aarch64.sve.fcmla.lane.nxv8f16",
+				"@llvm.aarch64.sve.fcmla.lane.nxv4f32",
+				"i32 0",
+				"i32 270",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating complex multiply-accumulate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-complex-multiply-accumulate.ll", "arm64-sve-float-complex-multiply-accumulate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatComplexMultiplyAccumulateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFCMLA $45, Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFCMLA $0, Z1.B, Z2.B, P0.M, Z3.B",
+		"ZFCMLA $0, Z1.H, Z2.S, P0.M, Z3.S",
+		"ZFCMLA $0, Z1.S, Z2.S, P8.M, Z3.S",
+		"ZFCMLA $0, Z8.H[0], Z2.H, Z3.H",
+		"ZFCMLA $0, Z7.H[4], Z2.H, Z3.H",
+		"ZFCMLA $0, Z16.S[0], Z2.S, Z3.S",
+		"ZFCMLA $0, Z15.S[2], Z2.S, Z3.S",
+		"ZFCMLA $0, Z1.D[0], Z2.D, Z3.D",
+		"ZFCMLA.Z $0, Z1.S, Z2.S, P0.M, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatcomplexmultiplyaccumulate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatcomplexmultiplyaccumulate": {Name: "badsvefloatcomplexmultiplyaccumulate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZFCMLA forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_divide_scale.go b/arm64_lower_sve_float_divide_scale.go
new file mode 100644
index 000000000..4d99689b5
--- /dev/null
+++ b/arm64_lower_sve_float_divide_scale.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFloatDivideScaleSpec struct {
+	intrinsic     string
+	integerSecond bool
+	rawBase       uint32
+}
+
+var arm64SVEFloatDivideScaleSpecs = map[Op]arm64SVEFloatDivideScaleSpec{
+	"ZFDIV":   {intrinsic: "fdiv", rawBase: 0x650d8000},
+	"ZFDIVR":  {intrinsic: "fdivr", rawBase: 0x650c8000},
+	"ZFSCALE": {intrinsic: "fscale", integerSecond: true, rawBase: 0x65098000},
+}
+
+var arm64SVEFloatDivideScaleRawOps = func() map[uint32]Op {
+	ops := make(map[uint32]Op, len(arm64SVEFloatDivideScaleSpecs))
+	for op, spec := range arm64SVEFloatDivideScaleSpecs {
+		ops[spec.rawBase] = op
+	}
+	return ops
+}()
+
+func decodeARM64RawSVEFloatDivideScale(word uint32) (Instr, bool) {
+	op, ok := arm64SVEFloatDivideScaleRawOps[word&0xff3fe000]
+	size := word >> 22 & 3
+	if !ok || size == 0 {
+		return Instr{}, false
+	}
+	register := func(number uint32) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", number, "BHSD"[size]))}
+	}
+	destination := register(word & 31)
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		register(word >> 5 & 31), destination,
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>10&7))}, destination,
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatDivideScale(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, supported := arm64SVEFloatDivideScaleSpecs[op]
+	if !supported {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.H|S|D, Zdn.H|S|D, P0..P7/M, Zdn.H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || destinationBits != firstBits || destination != first {
+		return true, false, fmt.Errorf("arm64 %s requires matching-width destructive H/S/D operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadRawSVEFloatVector(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, err := arm64SVEFloatType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[firstBits]
+	result := c.newTmp()
+	if spec.integerSecond {
+		secondValue, integerType, err := c.loadZRegElements(second, secondBits)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fscale.nxv%d%s(%s %s, %s %s, %s %s)\n", result, vectorType, lanes, mangle, predicateType, predicateValue, vectorType, firstValue, integerType, secondValue)
+	} else {
+		secondValue, _, err := c.loadRawSVEFloatVector(second, secondBits)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, mangle, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n", selected, predicateType, predicateValue, vectorType, result, vectorType, firstValue)
+	return true, false, c.storeRawSVEFloatVector(destination, firstBits, "%"+selected, vectorType)
+}
diff --git a/arm64_lower_sve_float_divide_scale_test.go b/arm64_lower_sve_float_divide_scale_test.go
new file mode 100644
index 000000000..bd0caa82c
--- /dev/null
+++ b/arm64_lower_sve_float_divide_scale_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatDivideScaleCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatdividescale(SB),$0-0\n")
+	for index, width := range []string{"H", "S", "D"} {
+		for opIndex, op := range []string{"ZFDIV", "ZFDIVR", "ZFSCALE"} {
+			destination := index*3 + opIndex
+			predicate := []int{0, 4, 7}[opIndex]
+			fmt.Fprintf(&source, "\t%s Z%d.%s, Z%d.%s, P%d.M, Z%d.%s\n", op, destination+16, width, destination, width, predicate, destination, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatdividescale": {Name: "svefloatdividescale", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.fdiv.nxv8f16",
+				"@llvm.aarch64.sve.fdiv.nxv4f32",
+				"@llvm.aarch64.sve.fdiv.nxv2f64",
+				"@llvm.aarch64.sve.fdivr.nxv8f16",
+				"@llvm.aarch64.sve.fscale.nxv8f16",
+				"@llvm.aarch64.sve.fscale.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating divide/scale lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-divide-scale.ll", "arm64-sve-float-divide-scale.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatDivideScaleRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFDIV Z1.B, Z2.B, P0.M, Z2.B",
+		"ZFDIV Z1.S, Z2.S, P8.M, Z2.S",
+		"ZFDIV Z1.S, Z2.S, P0.Z, Z2.S",
+		"ZFDIV Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFDIVR Z1.H, Z2.S, P0.M, Z2.S",
+		"ZFSCALE Z1.D, Z2.D, P0, Z2.D",
+		"ZFSCALE.Z Z1.D, Z2.D, P0.M, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatdividescale(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatdividescale": {Name: "badsvefloatdividescale", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating divide/scale forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_exponent.go b/arm64_lower_sve_float_exponent.go
new file mode 100644
index 000000000..0dfaf389f
--- /dev/null
+++ b/arm64_lower_sve_float_exponent.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEFloatExponent(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFEXPA" && op != "ZFLOGB" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept a mnemonic suffix: %q", op, ins.Raw)
+	}
+	if op == "ZFEXPA" {
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("arm64 ZFEXPA expects Zn.H|S|D, Zd.H|S|D: %q", ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[1])
+		if !sourceOK || !destinationOK || sourceBits == 8 || sourceBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZFEXPA requires matching H/S/D source and destination widths: %q", ins.Raw)
+		}
+		sourceValue, integerType, err := c.loadZRegElements(source, sourceBits)
+		if err != nil {
+			return true, false, err
+		}
+		_, floatingType, lanes, err := arm64SVEFloatType(sourceBits)
+		if err != nil {
+			return true, false, err
+		}
+		mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[sourceBits]
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fexpa.x.nxv%d%s(%s %s)\n", result, floatingType, lanes, mangle, integerType, sourceValue)
+		return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, floatingType)
+	}
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZFLOGB expects Zn.H|S|D, Pg/M|Z, Zd.H|S|D: %q", ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+	mergePredicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+	zeroPredicate, zeroOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || (!mergeOK && !zeroOK) || !destinationOK || sourceBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 ZFLOGB requires matching H/S/D operands and P0..P7/M|Z: %q", ins.Raw)
+	}
+	predicate := mergePredicate
+	if zeroOK {
+		predicate = zeroPredicate
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, floatingType, err := c.loadRawSVEFloatVector(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	passthrough := "zeroinitializer"
+	integerType, lanes, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	if mergeOK {
+		passthrough, _, err = c.loadZRegElements(destination, destinationBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[sourceBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.flogb.nxv%d%s(%s %s, %s %s, %s %s)\n", result, integerType, lanes, mangle, integerType, passthrough, predicateType, predicateValue, floatingType, sourceValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_float_exponent_test.go b/arm64_lower_sve_float_exponent_test.go
new file mode 100644
index 000000000..3e14bf65d
--- /dev/null
+++ b/arm64_lower_sve_float_exponent_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatExponentCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatexponent(SB),$0-0\n")
+	for index, width := range []string{"H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZFEXPA Z%d.%s, Z%d.%s\n", index, width, index+4, width)
+		fmt.Fprintf(&source, "\tZFLOGB Z%d.%s, P%d.M, Z%d.%s\n", index+8, width, index, index+12, width)
+		fmt.Fprintf(&source, "\tZFLOGB Z%d.%s, P%d.Z, Z%d.%s\n", index+16, width, index+3, index+20, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatexponent": {Name: "svefloatexponent", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.fexpa.x.nxv8f16",
+				"@llvm.aarch64.sve.fexpa.x.nxv4f32",
+				"@llvm.aarch64.sve.fexpa.x.nxv2f64",
+				"@llvm.aarch64.sve.flogb.nxv8f16",
+				"@llvm.aarch64.sve.flogb.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating exponent lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-exponent.ll", "arm64-sve-float-exponent.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatExponentRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFEXPA Z1.B, Z2.B",
+		"ZFEXPA Z1.S, Z2.D",
+		"ZFLOGB Z1.B, P0.M, Z2.B",
+		"ZFLOGB Z1.S, P8.M, Z2.S",
+		"ZFLOGB Z1.S, P0, Z2.S",
+		"ZFLOGB Z1.S, P0.Z, Z2.D",
+		"ZFEXPA.Z Z1.D, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatexponent(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatexponent": {Name: "badsvefloatexponent", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating exponent forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_immediate.go b/arm64_lower_sve_float_immediate.go
new file mode 100644
index 000000000..7ea3c55a6
--- /dev/null
+++ b/arm64_lower_sve_float_immediate.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEFloatImmediate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFCPY" && op != "ZFDUP" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept a mnemonic suffix: %q", op, ins.Raw)
+	}
+	wantArgs := 2
+	if op == "ZFCPY" {
+		wantArgs = 3
+	}
+	if len(ins.Args) != wantArgs || !arm64SVEFloatImmediateRepresentable(ins.Args[0]) {
+		return true, false, fmt.Errorf("arm64 %s requires an encodable floating immediate and its complete Go 1.27 operand form: %q", op, ins.Raw)
+	}
+	destinationOperand := ins.Args[wantArgs-1]
+	destination, elementBits, destinationOK := arm64SVEFloatElementReg(destinationOperand)
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s destination must use H, S, or D elements: %q", op, ins.Raw)
+	}
+	value := math.Float64frombits(uint64(ins.Args[0].Imm))
+	splat, err := c.arm64SVEFloatSplat(value, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, vectorType, _, err := arm64SVEFloatType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	if op == "ZFDUP" {
+		return true, false, c.storeRawSVEFloatVector(destination, elementBits, splat, vectorType)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 15)
+	if !predicateOK {
+		return true, false, fmt.Errorf("arm64 ZFCPY requires P0..P15/M: %q", ins.Raw)
+	}
+	oldDestination, _, err := c.loadRawSVEFloatVector(destination, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicateValue, vectorType, splat, vectorType, oldDestination)
+	return true, false, c.storeRawSVEFloatVector(destination, elementBits, "%"+selected, vectorType)
+}
+
+// arm64SVEFloatImmediateRepresentable mirrors Go's chipfloat7 acceptance
+// check: one sign bit, a 3-bit exponent, and four fractional bits expanded to
+// an exact binary64 value. That is the full 256-value immediate domain shared
+// by ZFCPY and ZFDUP.
+func arm64SVEFloatImmediateRepresentable(operand Operand) bool {
+	if operand.Kind != OpImm || operand.ImmRaw != "" || !operand.ImmIsFloat {
+		return false
+	}
+	bits := math.Float64bits(math.Float64frombits(uint64(operand.Imm)))
+	low := uint32(bits)
+	high := uint32(bits >> 32)
+	if low != 0 || high&0xffff != 0 {
+		return false
+	}
+	exponent := high & 0x7fc00000
+	return exponent == 0x40000000 || exponent == 0x3fc00000
+}
diff --git a/arm64_lower_sve_float_immediate_test.go b/arm64_lower_sve_float_immediate_test.go
new file mode 100644
index 000000000..f330e3872
--- /dev/null
+++ b/arm64_lower_sve_float_immediate_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestARM64SVEFloatImmediateCompleteEncodingDomain(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatimmediatedomain(SB),$0-0\n")
+	count := 0
+	for _, sign := range []float64{1, -1} {
+		for exponent := -3; exponent <= 4; exponent++ {
+			for numerator := 16; numerator <= 31; numerator++ {
+				value := math.Ldexp(sign*float64(numerator)/16, exponent)
+				operand := Operand{Kind: OpImm, Imm: int64(math.Float64bits(value)), ImmIsFloat: true}
+				if !arm64SVEFloatImmediateRepresentable(operand) {
+					t.Fatalf("representable ARM floating immediate rejected: %g", value)
+				}
+				literal := strconv.FormatFloat(value, 'g', -1, 64)
+				if !strings.ContainsAny(literal, ".eE") {
+					literal += ".0"
+				}
+				fmt.Fprintf(&source, "\tZFDUP $(%s), Z0.%s\n", literal, []string{"H", "S", "D"}[count%3])
+				count++
+			}
+		}
+	}
+	if count != 256 {
+		t.Fatalf("floating immediate domain has %d values, want 256", count)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	for _, value := range []float64{0, 0.1, math.Inf(1), math.Inf(-1), math.NaN()} {
+		operand := Operand{Kind: OpImm, Imm: int64(math.Float64bits(value)), ImmIsFloat: true}
+		if arm64SVEFloatImmediateRepresentable(operand) {
+			t.Fatalf("non-encodable ARM floating immediate accepted: %g", value)
+		}
+	}
+}
+
+func TestTranslateARM64SVEFloatImmediateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatimmediate(SB),$0-0\n")
+	values := []string{"1.0", "-1.0", "0.5"}
+	for index, width := range []string{"H", "S", "D"} {
+		predicate := []int{0, 8, 15}[index]
+		fmt.Fprintf(&source, "\tZFCPY $(%s), P%d.M, Z%d.%s\n", values[index], predicate, index+4, width)
+		fmt.Fprintf(&source, "\tZFDUP $(%s), Z%d.%s\n", values[index], index+8, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatimmediate": {Name: "svefloatimmediate", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"<vscale x 8 x half>",
+				"<vscale x 4 x float>",
+				"<vscale x 2 x double>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating immediate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-immediate.ll", "arm64-sve-float-immediate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatImmediateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFCPY $(1.0), P0.M, Z1.B",
+		"ZFCPY $(1.0), P16.M, Z1.S",
+		"ZFCPY $(1.0), P0.Z, Z1.S",
+		"ZFCPY $(0.0), P0.M, Z1.S",
+		"ZFDUP $(1.0), Z1.B",
+		"ZFDUP $(0.0), Z1.S",
+		"ZFDUP.Z $(1.0), Z1.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatimmediate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatimmediate": {Name: "badsvefloatimmediate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating immediate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_minmax.go b/arm64_lower_sve_float_minmax.go
new file mode 100644
index 000000000..14f63c758
--- /dev/null
+++ b/arm64_lower_sve_float_minmax.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type arm64SVEFloatMinMaxKind uint8
+
+const (
+	arm64SVEFloatMinMaxDirect arm64SVEFloatMinMaxKind = iota
+	arm64SVEFloatMinMaxPairwise
+	arm64SVEFloatMinMaxReduce
+	arm64SVEFloatMinMaxQuadReduce
+)
+
+type arm64SVEFloatMinMaxSpec struct {
+	intrinsic   string
+	kind        arm64SVEFloatMinMaxKind
+	elementBits int
+}
+
+var arm64SVEFloatMinMaxSpecs = map[Op]arm64SVEFloatMinMaxSpec{
+	"ZFMAX":     {intrinsic: "fmax", kind: arm64SVEFloatMinMaxDirect},
+	"ZFMAXP":    {intrinsic: "fmaxp", kind: arm64SVEFloatMinMaxPairwise},
+	"ZFMAXQV":   {intrinsic: "fmaxqv", kind: arm64SVEFloatMinMaxQuadReduce},
+	"ZFMAXVH":   {intrinsic: "fmaxv", kind: arm64SVEFloatMinMaxReduce, elementBits: 16},
+	"ZFMAXVS":   {intrinsic: "fmaxv", kind: arm64SVEFloatMinMaxReduce, elementBits: 32},
+	"ZFMAXVD":   {intrinsic: "fmaxv", kind: arm64SVEFloatMinMaxReduce, elementBits: 64},
+	"ZFMIN":     {intrinsic: "fmin", kind: arm64SVEFloatMinMaxDirect},
+	"ZFMINP":    {intrinsic: "fminp", kind: arm64SVEFloatMinMaxPairwise},
+	"ZFMINQV":   {intrinsic: "fminqv", kind: arm64SVEFloatMinMaxQuadReduce},
+	"ZFMINVH":   {intrinsic: "fminv", kind: arm64SVEFloatMinMaxReduce, elementBits: 16},
+	"ZFMINVS":   {intrinsic: "fminv", kind: arm64SVEFloatMinMaxReduce, elementBits: 32},
+	"ZFMINVD":   {intrinsic: "fminv", kind: arm64SVEFloatMinMaxReduce, elementBits: 64},
+	"ZFMAXNM":   {intrinsic: "fmaxnm", kind: arm64SVEFloatMinMaxDirect},
+	"ZFMAXNMP":  {intrinsic: "fmaxnmp", kind: arm64SVEFloatMinMaxPairwise},
+	"ZFMAXNMQV": {intrinsic: "fmaxnmqv", kind: arm64SVEFloatMinMaxQuadReduce},
+	"ZFMAXNMVH": {intrinsic: "fmaxnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 16},
+	"ZFMAXNMVS": {intrinsic: "fmaxnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 32},
+	"ZFMAXNMVD": {intrinsic: "fmaxnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 64},
+	"ZFMINNM":   {intrinsic: "fminnm", kind: arm64SVEFloatMinMaxDirect},
+	"ZFMINNMP":  {intrinsic: "fminnmp", kind: arm64SVEFloatMinMaxPairwise},
+	"ZFMINNMQV": {intrinsic: "fminnmqv", kind: arm64SVEFloatMinMaxQuadReduce},
+	"ZFMINNMVH": {intrinsic: "fminnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 16},
+	"ZFMINNMVS": {intrinsic: "fminnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 32},
+	"ZFMINNMVD": {intrinsic: "fminnmv", kind: arm64SVEFloatMinMaxReduce, elementBits: 64},
+}
+
+type arm64SVEFloatMinMaxForm struct {
+	elementBits  int
+	first        int
+	second       int
+	predicate    int
+	destination  int
+	immediate    float64
+	hasImmediate bool
+}
+
+// Four orthogonal opcode choices (min/max and numeric/propagating NaNs)
+// share the same direct, immediate, pairwise and quad-reduction fields.
+// Ordinary reductions already use decodeARM64RawSVEFloatMinMaxReduction.
+func decodeARM64RawSVEFloatMinMax(word uint32) (Instr, bool) {
+	size := word >> 22 & 3
+	if size == 0 {
+		return Instr{}, false
+	}
+	op := [...]Op{"ZFMAXNM", "ZFMINNM", "ZFMAX", "ZFMIN"}[word>>16&3]
+	width := "BHSD"[size]
+	source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))}
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))}
+	predicate := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>10&7))}
+	args := []Operand{source, destination, predicate, destination}
+	switch word & 0xff3ce000 {
+	case 0x65048000:
+	case 0x651c8000:
+		if word&0x3c0 != 0 {
+			return Instr{}, false
+		}
+		args[0] = Operand{Kind: OpImm, ImmIsFloat: true, Imm: int64(math.Float64bits(float64(word >> 5 & 1)))}
+	case 0x64148000:
+		op += "P"
+	case 0x6414a000:
+		op += "QV"
+		args = []Operand{
+			source,
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", word>>10&7))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%c%d", word&31, width, 16>>size))},
+		}
+	default:
+		return Instr{}, false
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMinMax(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFloatMinMaxSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+
+	switch spec.kind {
+	case arm64SVEFloatMinMaxDirect, arm64SVEFloatMinMaxPairwise:
+		form, err := arm64ParseSVEFloatMinMaxDirectForm(op, spec, ins)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SVEFloatMinMaxDirectForm(spec, form)
+	case arm64SVEFloatMinMaxReduce, arm64SVEFloatMinMaxQuadReduce:
+		form, err := arm64ParseSVEFloatMinMaxReductionForm(op, spec, ins)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SVEFloatMinMaxReductionForm(spec, form, ins.Args[2].Reg)
+	default:
+		return true, false, fmt.Errorf("arm64 %s has an unknown SVE floating min/max form", op)
+	}
+}
+
+func arm64ParseSVEFloatMinMaxDirectForm(op Op, spec arm64SVEFloatMinMaxSpec, ins Instr) (arm64SVEFloatMinMaxForm, error) {
+	form := arm64SVEFloatMinMaxForm{}
+	if len(ins.Args) != 4 {
+		return form, fmt.Errorf("arm64 %s expects its four-operand predicated Go 1.27 form: %q", op, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+	if !firstOK || !predicateOK || !destinationOK || first != destination || firstBits != destinationBits {
+		return form, fmt.Errorf("arm64 %s requires matching-width destructive registers and P0..P7/M: %q", op, ins.Raw)
+	}
+	form = arm64SVEFloatMinMaxForm{elementBits: firstBits, first: first, predicate: predicate, destination: destination}
+	if ins.Args[0].Kind == OpImm {
+		if spec.kind != arm64SVEFloatMinMaxDirect || ins.Args[0].ImmRaw != "" || !ins.Args[0].ImmIsFloat {
+			return form, fmt.Errorf("arm64 %s does not accept this floating immediate: %q", op, ins.Raw)
+		}
+		form.immediate = math.Float64frombits(uint64(ins.Args[0].Imm))
+		if form.immediate != 0 && form.immediate != 1 {
+			return form, fmt.Errorf("arm64 %s immediate must be $(0.0) or $(1.0): %q", op, ins.Raw)
+		}
+		form.hasImmediate = true
+		return form, nil
+	}
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+	if !secondOK || secondBits != firstBits {
+		return form, fmt.Errorf("arm64 %s vector operands must have identical H, S, or D widths: %q", op, ins.Raw)
+	}
+	form.second = second
+	return form, nil
+}
+
+func arm64ParseSVEFloatMinMaxReductionForm(op Op, spec arm64SVEFloatMinMaxSpec, ins Instr) (arm64SVEFloatMinMaxForm, error) {
+	form := arm64SVEFloatMinMaxForm{}
+	if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
+		return form, fmt.Errorf("arm64 %s expects Zn.T, Pg, Vd%s: %q", op, map[bool]string{true: ".T", false: ""}[spec.kind == arm64SVEFloatMinMaxQuadReduce], ins.Raw)
+	}
+	first, elementBits, firstOK := arm64SVEFloatElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[1])
+	destination, destinationOK := arm64ParseVReg(ins.Args[2].Reg)
+	if !firstOK || !predicateOK || predicate > 7 || !destinationOK {
+		return form, fmt.Errorf("arm64 %s requires an H/S/D scalable source, bare P0..P7, and SIMD destination: %q", op, ins.Raw)
+	}
+	if spec.kind == arm64SVEFloatMinMaxReduce {
+		if strings.Contains(string(ins.Args[2].Reg), ".") {
+			return form, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+		}
+		opcodeSize := map[int]int{16: 1, 32: 2, 64: 3}[spec.elementBits]
+		sourceSize := map[int]int{16: 1, 32: 2, 64: 3}[elementBits]
+		elementBits = 8 << (opcodeSize | sourceSize)
+	} else {
+		arrangement, arrangementOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+		if !arrangementOK || arrangement.elementBits != elementBits || arrangement.lanes*arrangement.elementBits != 128 {
+			return form, fmt.Errorf("arm64 %s destination must be a full-width SIMD vector matching its source elements: %q", op, ins.Raw)
+		}
+	}
+	form = arm64SVEFloatMinMaxForm{elementBits: elementBits, first: first, predicate: predicate, destination: destination}
+	return form, nil
+}
+
+func arm64SVEFloatType(elementBits int) (scalar, vector string, lanes int, err error) {
+	lanes = 128 / elementBits
+	scalar, ok := map[int]string{16: "half", 32: "float", 64: "double"}[elementBits]
+	if !ok {
+		return "", "", 0, fmt.Errorf("unsupported ARM64 SVE floating element width %d", elementBits)
+	}
+	return scalar, fmt.Sprintf("<vscale x %d x %s>", lanes, scalar), lanes, nil
+}
+
+func (c *arm64Ctx) arm64SVEFloatSplat(value float64, elementBits int) (string, error) {
+	integerType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return "", err
+	}
+	_, vectorType, _, err := arm64SVEFloatType(elementBits)
+	if err != nil {
+		return "", err
+	}
+	var bits uint64
+	switch elementBits {
+	case 16:
+		bits = uint64(arm64Float16Bits(value))
+	case 32:
+		bits = uint64(math.Float32bits(float32(value)))
+	case 64:
+		bits = math.Float64bits(value)
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s splat (i%d %d) to %s\n", converted, integerType, elementBits, bits, vectorType)
+	return "%" + converted, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMinMaxDirectForm(spec arm64SVEFloatMinMaxSpec, form arm64SVEFloatMinMaxForm) error {
+	first, vectorType, err := c.loadRawSVEFloatVector(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	second := ""
+	if form.hasImmediate {
+		second, err = c.arm64SVEFloatSplat(form.immediate, form.elementBits)
+	} else {
+		second, _, err = c.loadRawSVEFloatVector(form.second, form.elementBits)
+	}
+	if err != nil {
+		return err
+	}
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, _, lanes, err := arm64SVEFloatType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	calculated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s, %s %s)\n", calculated, vectorType, spec.intrinsic, lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits], predicateType, predicate, vectorType, first, vectorType, second)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n", selected, predicateType, predicate, vectorType, calculated, vectorType, first)
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, "%"+selected, vectorType)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMinMaxReductionForm(spec arm64SVEFloatMinMaxSpec, form arm64SVEFloatMinMaxForm, destination Reg) error {
+	source, vectorType, err := c.loadRawSVEFloatVector(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	scalarType, _, lanes, err := arm64SVEFloatType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	mangle := fmt.Sprintf("nxv%d%s", lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits])
+	result := c.newTmp()
+	if spec.kind == arm64SVEFloatMinMaxReduce {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.%s(%s %s, %s %s)\n", result, scalarType, spec.intrinsic, mangle, predicateType, predicate, vectorType, source)
+		fixed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> zeroinitializer, %s %%%s, i32 0\n", fixed, lanes, scalarType, scalarType, result)
+		result = fixed
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.aarch64.sve.%s.v%d%s.%s(%s %s, %s %s)\n", result, lanes, scalarType, spec.intrinsic, lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits], mangle, predicateType, predicate, vectorType, source)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %%%s to <16 x i8>\n", bytes, lanes, scalarType, result)
+	return c.storeVReg(destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_float_minmax_test.go b/arm64_lower_sve_float_minmax_test.go
new file mode 100644
index 000000000..9c32cc842
--- /dev/null
+++ b/arm64_lower_sve_float_minmax_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEFloatMinMaxCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatminmaxforms(SB),$0-0\n")
+	for _, base := range []string{"ZFMAX", "ZFMIN", "ZFMAXNM", "ZFMINNM"} {
+		for index, width := range []string{"H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			source.WriteString("\t" + base + " Z1." + width + ", Z2." + width + ", P" + predicate + ".M, Z2." + width + "\n")
+			for _, immediate := range []string{"0.0", "1.0"} {
+				source.WriteString("\t" + base + " $(" + immediate + "), Z3." + width + ", P" + predicate + ".M, Z3." + width + "\n")
+			}
+			source.WriteString("\t" + base + "P Z4." + width + ", Z5." + width + ", P" + predicate + ".M, Z5." + width + "\n")
+			for _, opcodeWidth := range []string{"H", "S", "D"} {
+				source.WriteString("\t" + base + "V" + opcodeWidth + " Z6." + width + ", P" + predicate + ", V7\n")
+			}
+			arrangement := map[string]string{"H": "H8", "S": "S4", "D": "D2"}[width]
+			source.WriteString("\t" + base + "QV Z8." + width + ", P" + predicate + ", V9." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEFloatMinMaxCompleteGo127Family(t *testing.T) {
+	source := arm64SVEFloatMinMaxCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatminmaxforms": {Name: "svefloatminmaxforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2,+sve2p1"`, "@llvm.aarch64.sve.fmax.nxv", "@llvm.aarch64.sve.fminnmp.nxv", "@llvm.aarch64.sve.fmaxnmv.nxv", "@llvm.aarch64.sve.fminqv."} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating min/max lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-minmax.ll", "arm64-sve-float-minmax.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatMinMaxRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMAX $(0.5), Z1.S, P0.M, Z1.S",
+		"ZFMIN Z1.B, Z2.B, P0.M, Z2.B",
+		"ZFMAXNM Z1.S, Z2.D, P0.M, Z2.D",
+		"ZFMINNM Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFMAXP Z1.S, Z2.S, P0.Z, Z2.S",
+		"ZFMINVH Z1.S, P8, V2",
+		"ZFMAXNMVS Z1.S, P0, V2.S4",
+		"ZFMINNMQV Z1.S, P0, V2.H8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatminmax(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatminmax": {Name: "badsvefloatminmax", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating min/max forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_multiply.go b/arm64_lower_sve_float_multiply.go
new file mode 100644
index 000000000..ba3764387
--- /dev/null
+++ b/arm64_lower_sve_float_multiply.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type arm64SVEFloatMultiplyForm struct {
+	elementBits  int
+	first        int
+	second       int
+	predicate    int
+	laneVector   int
+	lane         int
+	destination  int
+	immediate    float64
+	hasImmediate bool
+	hasLane      bool
+	predicated   bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFMUL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 3 && len(ins.Args) != 4) {
+		return true, false, fmt.Errorf("arm64 ZFMUL expects one complete Go 1.27 floating form without a suffix: %q", ins.Raw)
+	}
+	form := arm64SVEFloatMultiplyForm{}
+	if len(ins.Args) == 4 {
+		first, elementBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+		if !firstOK || !predicateOK || !destinationOK || first != destination || elementBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZFMUL predicated form requires matching destructive H/S/D operands and P0..P7.M: %q", ins.Raw)
+		}
+		form = arm64SVEFloatMultiplyForm{elementBits: elementBits, first: first, predicate: predicate, destination: destination, predicated: true}
+		if ins.Args[0].Kind == OpImm {
+			if ins.Args[0].ImmRaw != "" || !ins.Args[0].ImmIsFloat {
+				return true, false, fmt.Errorf("arm64 ZFMUL immediate requires $(0.5) or $(2.0): %q", ins.Raw)
+			}
+			form.immediate = math.Float64frombits(uint64(ins.Args[0].Imm))
+			constants := arm64SVEFloatArithmeticSpecs[op].constants
+			if form.immediate != constants[0] && form.immediate != constants[1] {
+				return true, false, fmt.Errorf("arm64 ZFMUL immediate requires $(0.5) or $(2.0): %q", ins.Raw)
+			}
+			form.hasImmediate = true
+		} else {
+			second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+			if !secondOK || secondBits != elementBits {
+				return true, false, fmt.Errorf("arm64 ZFMUL predicated source must match the destination width: %q", ins.Raw)
+			}
+			form.second = second
+		}
+	} else {
+		first, elementBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+		if !firstOK || !destinationOK || elementBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 ZFMUL unpredicated operands must use one H/S/D width: %q", ins.Raw)
+		}
+		form = arm64SVEFloatMultiplyForm{elementBits: elementBits, first: first, destination: destination}
+		if laneVector, laneBits, lane, laneOK := arm64ParseSVEZIndexedElementReg(ins.Args[0]); laneOK {
+			if laneBits != elementBits {
+				return true, false, fmt.Errorf("arm64 ZFMUL lane width must match the other operands: %q", ins.Raw)
+			}
+			form.laneVector, form.lane, form.hasLane = laneVector, lane, true
+		} else {
+			second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+			if !secondOK || secondBits != elementBits {
+				return true, false, fmt.Errorf("arm64 ZFMUL vector sources must use one H/S/D width: %q", ins.Raw)
+			}
+			form.second = second
+		}
+	}
+	return true, false, c.lowerARM64SVEFloatMultiplyForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMultiplyForm(form arm64SVEFloatMultiplyForm) error {
+	first, vectorType, err := c.loadRawSVEFloatVector(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.hasLane {
+		laneVector, _, err := c.loadRawSVEFloatVector(form.laneVector, form.elementBits)
+		if err != nil {
+			return err
+		}
+		_, _, lanes, _ := arm64SVEFloatType(form.elementBits)
+		code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits]
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fmul.lane.nxv%d%s(%s %s, %s %s, i32 %d)\n",
+			result, vectorType, lanes, code, vectorType, first, vectorType, laneVector, form.lane)
+	} else {
+		second := ""
+		if form.hasImmediate {
+			second, err = c.arm64SVEFloatSplat(form.immediate, form.elementBits)
+		} else {
+			second, _, err = c.loadRawSVEFloatVector(form.second, form.elementBits)
+		}
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = fmul %s %s, %s\n", result, vectorType, first, second)
+	}
+	value := "%" + result
+	if form.predicated {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, value, vectorType, first)
+		value = "%" + selected
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, value, vectorType)
+}
diff --git a/arm64_lower_sve_float_multiply_accumulate.go b/arm64_lower_sve_float_multiply_accumulate.go
new file mode 100644
index 000000000..9dac4404a
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_accumulate.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFloatMultiplyAccumulateSpec struct {
+	intrinsic string
+	indexed   bool
+}
+
+var arm64SVEFloatMultiplyAccumulateSpecs = map[Op]arm64SVEFloatMultiplyAccumulateSpec{
+	"ZFMLA":  {intrinsic: "fmla", indexed: true},
+	"ZFMLS":  {intrinsic: "fmls", indexed: true},
+	"ZFMAD":  {intrinsic: "fmad"},
+	"ZFMSB":  {intrinsic: "fmsb"},
+	"ZFNMLA": {intrinsic: "fnmla"},
+	"ZFNMLS": {intrinsic: "fnmls"},
+	"ZFNMAD": {intrinsic: "fnmad"},
+	"ZFNMSB": {intrinsic: "fnmsb"},
+}
+
+type arm64SVEFloatMultiplyAccumulateForm struct {
+	intrinsic    string
+	elementBits  int
+	multiplier   int
+	multiplicand int
+	predicate    int
+	lane         int
+	destination  int
+	indexed      bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMultiplyAccumulate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFloatMultiplyAccumulateSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 && (len(ins.Args) != 3 || !spec.indexed) {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 floating multiply-accumulate form without a suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEFloatMultiplyAccumulateForm{intrinsic: spec.intrinsic}
+	if len(ins.Args) == 4 {
+		multiplier, multiplierBits, multiplierOK := arm64SVEFloatElementReg(ins.Args[0])
+		multiplicand, multiplicandBits, multiplicandOK := arm64SVEFloatElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+		if !multiplierOK || !multiplicandOK || !predicateOK || !destinationOK || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s predicated operands must use one H/S/D width and P0..P7.M: %q", op, ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.predicate = predicate
+		form.destination = destination
+	} else {
+		multiplier, multiplierBits, lane, multiplierOK := arm64ParseSVEZIndexedElementReg(ins.Args[0])
+		multiplicand, multiplicandBits, multiplicandOK := arm64SVEFloatElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+		if !multiplierOK || !multiplicandOK || !destinationOK || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s indexed operands must use one H/S/D width and an encodable lane: %q", op, ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.multiplier = multiplier
+		form.multiplicand = multiplicand
+		form.lane = lane
+		form.destination = destination
+		form.indexed = true
+	}
+	return true, false, c.lowerARM64SVEFloatMultiplyAccumulateForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatMultiplyAccumulateForm(form arm64SVEFloatMultiplyAccumulateForm) error {
+	accumulator, vectorType, err := c.loadRawSVEFloatVector(form.destination, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplicand, _, err := c.loadRawSVEFloatVector(form.multiplicand, form.elementBits)
+	if err != nil {
+		return err
+	}
+	multiplier, _, err := c.loadRawSVEFloatVector(form.multiplier, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, _, lanes, _ := arm64SVEFloatType(form.elementBits)
+	code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits]
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%d%s(%s %s, %s %s, %s %s, i32 %d)\n",
+			result, vectorType, form.intrinsic, lanes, code, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier, form.lane)
+	} else {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s, %s %s, %s %s)\n",
+			result, vectorType, form.intrinsic, lanes, code, predicateType, predicate, vectorType, accumulator, vectorType, multiplicand, vectorType, multiplier)
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_multiply_accumulate_test.go b/arm64_lower_sve_float_multiply_accumulate_test.go
new file mode 100644
index 000000000..032d1a521
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_accumulate_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatMultiplyAccumulateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatmultiplyaccumulateforms(SB),$0-0\n")
+	for _, op := range []string{
+		"ZFMLA", "ZFMLS", "ZFMAD", "ZFMSB",
+		"ZFNMLA", "ZFNMLS", "ZFNMAD", "ZFNMSB",
+	} {
+		for index, width := range []string{"H", "S", "D"} {
+			maximumVector := []int{7, 7, 15}[index]
+			maximumLane := []int{7, 3, 1}[index]
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z3.%s\n", op, width, width, index, width)
+			if op == "ZFMLA" || op == "ZFMLS" {
+				fmt.Fprintf(&source, "\t%s Z%d.%s[%d], Z4.%s, Z5.%s\n", op, maximumVector, width, maximumLane, width, width)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatmultiplyaccumulateforms": {Name: "svefloatmultiplyaccumulateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.fmla.nxv8f16",
+				"@llvm.aarch64.sve.fmla.lane.nxv4f32",
+				"@llvm.aarch64.sve.fmls.nxv2f64",
+				"@llvm.aarch64.sve.fmls.lane.nxv8f16",
+				"@llvm.aarch64.sve.fmsb.nxv4f32",
+				"@llvm.aarch64.sve.fnmsb.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating multiply-accumulate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-multiply-accumulate.ll", "arm64-sve-float-multiply-accumulate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatMultiplyAccumulateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMLA Z1.B, Z2.B, P0.M, Z3.B",
+		"ZFMLS Z1.H, Z2.S, P0.M, Z3.S",
+		"ZFMLA Z1.H, Z2.H, P0, Z3.H",
+		"ZFMLS Z1.S, Z2.S, P8.M, Z3.S",
+		"ZFMLA Z8.H[0], Z2.H, Z3.H",
+		"ZFMLS Z7.H[8], Z2.H, Z3.H",
+		"ZFMLA Z7.S[3], Z2.D, Z3.D",
+		"ZFMLS.Z Z1.S, Z2.S, P0.M, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatmultiplyaccumulate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatmultiplyaccumulate": {Name: "badsvefloatmultiplyaccumulate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating multiply-accumulate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_multiply_addend_test.go b/arm64_lower_sve_float_multiply_addend_test.go
new file mode 100644
index 000000000..eabe80512
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_addend_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatMultiplyAddendCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatmultiplyaddendforms(SB),$0-0\n")
+	for _, op := range []string{"ZFMAD", "ZFMSB", "ZFNMAD", "ZFNMSB"} {
+		for index, width := range []string{"H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z3.%s\n", op, width, width, index, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatmultiplyaddendforms": {Name: "svefloatmultiplyaddendforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.fmad.nxv8f16",
+				"@llvm.aarch64.sve.fmsb.nxv4f32",
+				"@llvm.aarch64.sve.fnmad.nxv2f64",
+				"@llvm.aarch64.sve.fnmsb.nxv8f16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating multiply-addend lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-multiply-addend.ll", "arm64-sve-float-multiply-addend.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatMultiplyAddendRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMAD Z1.B, Z2.B, P0.M, Z3.B",
+		"ZFMSB Z1.H, Z2.S, P0.M, Z3.S",
+		"ZFNMAD Z1.H, Z2.H, P0, Z3.H",
+		"ZFNMSB Z1.S, Z2.S, P8.M, Z3.S",
+		"ZFMAD Z7.H[0], Z2.H, Z3.H",
+		"ZFMSB.Z Z1.S, Z2.S, P0.M, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatmultiplyaddend(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatmultiplyaddend": {Name: "badsvefloatmultiplyaddend", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating multiply-addend forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_multiply_extended.go b/arm64_lower_sve_float_multiply_extended.go
new file mode 100644
index 000000000..251b39dd9
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_extended.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEFloatMultiplyExtended(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFMULX" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 ZFMULX expects one complete Go 1.27 predicated form without a suffix: %q", ins.Raw)
+	}
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+		return true, false, fmt.Errorf("arm64 ZFMULX requires matching destructive H/S/D operands and P0..P7.M: %q", ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadRawSVEFloatVector(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadRawSVEFloatVector(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, _ := arm64SVEFloatType(firstBits)
+	code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[firstBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fmulx.nxv%d%s(%s %s, %s %s, %s %s)\n",
+		result, vectorType, lanes, code, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeRawSVEFloatVector(destination, firstBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_multiply_extended_test.go b/arm64_lower_sve_float_multiply_extended_test.go
new file mode 100644
index 000000000..fe537f730
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_extended_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatMultiplyExtendedCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatmultiplyextendedforms(SB),$0-0\n")
+	for index, width := range []string{"H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZFMULX Z1.%s, Z2.%s, P%d.M, Z2.%s\n", width, width, index, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatmultiplyextendedforms": {Name: "svefloatmultiplyextendedforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.fmulx.nxv8f16",
+				"@llvm.aarch64.sve.fmulx.nxv4f32",
+				"@llvm.aarch64.sve.fmulx.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating multiply-extended lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-multiply-extended.ll", "arm64-sve-float-multiply-extended.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatMultiplyExtendedRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMULX Z1.B, Z2.B, P0.M, Z2.B",
+		"ZFMULX Z1.H, Z2.S, P0.M, Z2.S",
+		"ZFMULX Z1.S, Z2.S, P0, Z2.S",
+		"ZFMULX Z1.S, Z2.S, P8.M, Z2.S",
+		"ZFMULX Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFMULX Z1.S, Z2.S, Z3.S",
+		"ZFMULX.Z Z1.S, Z2.S, P0.M, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatmultiplyextended(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatmultiplyextended": {Name: "badsvefloatmultiplyextended", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZFMULX forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_multiply_test.go b/arm64_lower_sve_float_multiply_test.go
new file mode 100644
index 000000000..c85e26079
--- /dev/null
+++ b/arm64_lower_sve_float_multiply_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatMultiplyCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatmultiplyforms(SB),$0-0\n")
+	for index, width := range []string{"H", "S", "D"} {
+		maximumVector := []int{7, 7, 15}[index]
+		maximumLane := []int{7, 3, 1}[index]
+		fmt.Fprintf(&source, "\tZFMUL Z1.%s, Z2.%s, P%d.M, Z2.%s\n", width, width, index, width)
+		fmt.Fprintf(&source, "\tZFMUL Z3.%s, Z4.%s, Z5.%s\n", width, width, width)
+		fmt.Fprintf(&source, "\tZFMUL Z%d.%s[%d], Z6.%s, Z7.%s\n", maximumVector, width, maximumLane, width, width)
+		for _, immediate := range []string{"0.5", "2.0"} {
+			fmt.Fprintf(&source, "\tZFMUL $(%s), Z8.%s, P%d.M, Z8.%s\n", immediate, width, index, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatmultiplyforms": {Name: "svefloatmultiplyforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				" fmul <vscale x ",
+				"@llvm.aarch64.sve.fmul.lane.nxv8f16",
+				"@llvm.aarch64.sve.fmul.lane.nxv4f32",
+				"@llvm.aarch64.sve.fmul.lane.nxv2f64",
+				" select <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating multiply lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-multiply.ll", "arm64-sve-float-multiply.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatMultiplyRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMUL Z1.B, Z2.B, Z3.B",
+		"ZFMUL Z1.H, Z2.S, Z3.S",
+		"ZFMUL Z8.H[0], Z2.H, Z3.H",
+		"ZFMUL Z7.H[8], Z2.H, Z3.H",
+		"ZFMUL $(1.0), Z1.S, P0.M, Z1.S",
+		"ZFMUL Z1.S, Z2.S, P0, Z2.S",
+		"ZFMUL Z1.S, Z2.S, P8.M, Z2.S",
+		"ZFMUL Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFMUL.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatmultiply(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatmultiply": {Name: "badsvefloatmultiply", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating multiply forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_narrow_conversion.go b/arm64_lower_sve_float_narrow_conversion.go
new file mode 100644
index 000000000..09fc86442
--- /dev/null
+++ b/arm64_lower_sve_float_narrow_conversion.go
@@ -0,0 +1,235 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFP8WidenSpec struct {
+	intrinsic string
+	bfloat    bool
+}
+
+var arm64SVEFP8WidenSpecs = map[Op]arm64SVEFP8WidenSpec{
+	"ZBF1CVT":   {intrinsic: "cvt1", bfloat: true},
+	"ZBF1CVTLT": {intrinsic: "cvtlt1", bfloat: true},
+	"ZBF2CVT":   {intrinsic: "cvt2", bfloat: true},
+	"ZBF2CVTLT": {intrinsic: "cvtlt2", bfloat: true},
+	"ZF1CVT":    {intrinsic: "cvt1"},
+	"ZF1CVTLT":  {intrinsic: "cvtlt1"},
+	"ZF2CVT":    {intrinsic: "cvt2"},
+	"ZF2CVTLT":  {intrinsic: "cvtlt2"},
+}
+
+func arm64SVEFloatNarrowConversionOp(op Op) bool {
+	if _, ok := arm64SVEFP8WidenSpecs[op]; ok {
+		return true
+	}
+	switch op {
+	case "ZBFCVT", "ZBFCVTN", "ZBFCVTNT", "ZFCVTN", "ZFCVTNB", "ZFCVTNT":
+		return true
+	}
+	return false
+}
+
+func arm64SVEFloatNarrowConversionUsesFP8(op Op, ins Instr) bool {
+	if _, ok := arm64SVEFP8WidenSpecs[op]; ok {
+		return true
+	}
+	switch op {
+	case "ZBFCVTN", "ZFCVTN", "ZFCVTNB":
+		return true
+	case "ZFCVTNT":
+		return len(ins.Args) == 2 && ins.Args[0].Kind == OpRegList
+	}
+	return false
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatNarrowConversion(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if !arm64SVEFloatNarrowConversionOp(op) {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if spec, ok := arm64SVEFP8WidenSpecs[op]; ok {
+		return c.lowerARM64SVEFP8Widen(op, spec, ins)
+	}
+	if len(ins.Args) == 2 && ins.Args[0].Kind == OpRegList {
+		return c.lowerARM64SVEFP8NarrowPair(op, ins)
+	}
+	return c.lowerARM64SVEFloatNarrowPredicated(op, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFP8Widen(op Op, spec arm64SVEFP8WidenSpec, ins Instr) (bool, bool, error) {
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.B, Zd.H: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !sourceOK || !destinationOK || sourceBits != 8 || destinationBits != 16 {
+		return true, false, fmt.Errorf("arm64 %s requires an FP8 B source and H destination: %q", op, ins.Raw)
+	}
+	sourceValue, err := c.loadZReg(source)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType := "<vscale x 8 x half>"
+	suffix := "f16"
+	if spec.bfloat {
+		destinationType, suffix = "<vscale x 8 x bfloat>", "bf16"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fp8.%s.nxv8%s(<vscale x 16 x i8> %s)\n", result, destinationType, spec.intrinsic, suffix, sourceValue)
+	if spec.bfloat {
+		return true, false, c.storeARM64SVEBFloatVector(destination, "%"+result)
+	}
+	return true, false, c.storeRawSVEFloatVector(destination, 16, "%"+result, destinationType)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatNarrowPredicated(op Op, ins Instr) (bool, bool, error) {
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.S|D, P0..P7/M|Z, Zd.H|S: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	predicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+	zeroing := false
+	if !mergeOK {
+		predicate, zeroing = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	}
+	validWidths := sourceBits == 32 && destinationBits == 16
+	if op == "ZFCVTNT" {
+		validWidths = validWidths || sourceBits == 64 && destinationBits == 32
+	}
+	if !sourceOK || !destinationOK || (!mergeOK && !zeroing) || !validWidths || (op != "ZBFCVT" && op != "ZBFCVTNT" && op != "ZFCVTNT") {
+		return true, false, fmt.Errorf("arm64 %s operands are outside its complete Go 1.27 predicated narrowing forms: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadRawSVEFloatVector(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType := map[int]string{16: "<vscale x 8 x half>", 32: "<vscale x 4 x float>"}[destinationBits]
+	mergeValue := "zeroinitializer"
+	intrinsic := "fcvt.f16f32"
+	bfloat := op == "ZBFCVT" || op == "ZBFCVTNT"
+	if bfloat {
+		destinationType = "<vscale x 8 x bfloat>"
+		intrinsic = "fcvt.bf16f32.v2"
+	}
+	keepDestination := mergeOK || op == "ZBFCVTNT" || op == "ZFCVTNT"
+	if keepDestination {
+		if bfloat {
+			mergeValue, err = c.loadARM64SVEBFloatVector(destination)
+		} else {
+			mergeValue, _, err = c.loadRawSVEFloatVector(destination, destinationBits)
+		}
+		if err != nil {
+			return true, false, err
+		}
+	}
+	if op == "ZBFCVTNT" {
+		intrinsic = "fcvtnt.bf16f32.v2"
+		if zeroing {
+			intrinsic = "fcvtnt.z.bf16f32"
+		}
+	} else if op == "ZFCVTNT" {
+		intrinsic = map[[2]int]string{{32, 16}: "fcvtnt.f16f32", {64, 32}: "fcvtnt.f32f64"}[[2]int{sourceBits, destinationBits}]
+		if zeroing {
+			intrinsic = strings.Replace(intrinsic, "fcvtnt.", "fcvtnt.z.", 1)
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, %s %s, %s %s)\n", result, destinationType, intrinsic, destinationType, mergeValue, predicateType, predicateValue, sourceType, sourceValue)
+	if bfloat {
+		return true, false, c.storeARM64SVEBFloatVector(destination, "%"+result)
+	}
+	return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, destinationType)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFP8NarrowPair(op Op, ins Instr) (bool, bool, error) {
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects one x2 range and one B destination: %q", op, ins.Raw)
+	}
+	first, second, sourceBits, sourceOK := arm64ParseSVEEvenVectorPair(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	wantBits := 16
+	if op == "ZFCVTNB" || op == "ZFCVTNT" {
+		wantBits = 32
+	}
+	if !sourceOK || !destinationOK || sourceBits != wantBits || destinationBits != 8 || (op != "ZBFCVTN" && op != "ZFCVTN" && op != "ZFCVTNB" && op != "ZFCVTNT") {
+		return true, false, fmt.Errorf("arm64 %s requires its exact even/odd x2 floating range and B destination: %q", op, ins.Raw)
+	}
+	var firstValue, secondValue, sourceType string
+	var err error
+	if op == "ZBFCVTN" {
+		firstValue, err = c.loadARM64SVEBFloatVector(first)
+		if err == nil {
+			secondValue, err = c.loadARM64SVEBFloatVector(second)
+		}
+		sourceType = "<vscale x 8 x bfloat>"
+	} else {
+		firstValue, sourceType, err = c.loadRawSVEFloatVector(first, sourceBits)
+		if err == nil {
+			secondValue, _, err = c.loadRawSVEFloatVector(second, sourceBits)
+		}
+	}
+	if err != nil {
+		return true, false, err
+	}
+	intrinsic := map[Op]string{
+		"ZBFCVTN": "cvtn.nxv8bf16",
+		"ZFCVTN":  "cvtn.nxv8f16",
+		"ZFCVTNB": "cvtnb.nxv4f32",
+		"ZFCVTNT": "cvtnt.nxv4f32",
+	}[op]
+	result := c.newTmp()
+	if op == "ZFCVTNT" {
+		oldDestination, err := c.loadZReg(destination)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.%s(<vscale x 16 x i8> %s, %s %s, %s %s)\n", result, intrinsic, oldDestination, sourceType, firstValue, sourceType, secondValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.%s(%s %s, %s %s)\n", result, intrinsic, sourceType, firstValue, sourceType, secondValue)
+	}
+	return true, false, c.storeZReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) loadARM64SVEBFloatVector(register int) (string, error) {
+	integer, integerType, err := c.loadZRegElements(register, 16)
+	if err != nil {
+		return "", err
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 8 x bfloat>\n", converted, integerType, integer)
+	return "%" + converted, nil
+}
+
+func (c *arm64Ctx) storeARM64SVEBFloatVector(register int, value string) error {
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 8 x bfloat> %s to <vscale x 8 x i16>\n", converted, value)
+	return c.storeZRegElements(register, 16, "%"+converted)
+}
+
+func emitARM64SVEFloatNarrowConversionDeclarations(b *strings.Builder) {
+	for _, intrinsic := range []string{"cvt1", "cvtlt1", "cvt2", "cvtlt2"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x half> @llvm.aarch64.sve.fp8.%s.nxv8f16(<vscale x 16 x i8>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fp8.%s.nxv8bf16(<vscale x 16 x i8>)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvt.bf16f32.v2(<vscale x 8 x bfloat>, <vscale x 4 x i1>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvtnt.bf16f32.v2(<vscale x 8 x bfloat>, <vscale x 4 x i1>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvtnt.z.bf16f32(<vscale x 8 x bfloat>, <vscale x 4 x i1>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 8 x half> @llvm.aarch64.sve.fcvtnt.f16f32(<vscale x 8 x half>, <vscale x 4 x i1>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 8 x half> @llvm.aarch64.sve.fcvtnt.z.f16f32(<vscale x 8 x half>, <vscale x 4 x i1>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fcvtnt.f32f64(<vscale x 4 x float>, <vscale x 2 x i1>, <vscale x 2 x double>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fcvtnt.z.f32f64(<vscale x 4 x float>, <vscale x 2 x i1>, <vscale x 2 x double>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtn.nxv8bf16(<vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtn.nxv8f16(<vscale x 8 x half>, <vscale x 8 x half>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtnb.nxv4f32(<vscale x 4 x float>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtnt.nxv4f32(<vscale x 16 x i8>, <vscale x 4 x float>, <vscale x 4 x float>)\n")
+}
diff --git a/arm64_lower_sve_float_narrow_conversion_test.go b/arm64_lower_sve_float_narrow_conversion_test.go
new file mode 100644
index 000000000..95cfa3287
--- /dev/null
+++ b/arm64_lower_sve_float_narrow_conversion_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatNarrowConversionCompleteGo127Family(t *testing.T) {
+	const source = `TEXT svefloatnarrowcvt(SB),$0-0
+	ZBF1CVT Z0.B, Z1.H
+	ZBF1CVTLT Z2.B, Z3.H
+	ZBF2CVT Z4.B, Z5.H
+	ZBF2CVTLT Z6.B, Z7.H
+	ZF1CVT Z8.B, Z9.H
+	ZF1CVTLT Z10.B, Z11.H
+	ZF2CVT Z12.B, Z13.H
+	ZF2CVTLT Z14.B, Z15.H
+	ZBFCVT Z16.S, P0.M, Z17.H
+	ZBFCVT Z18.S, P7.Z, Z19.H
+	ZBFCVTNT Z20.S, P1.M, Z21.H
+	ZBFCVTNT Z22.S, P6.Z, Z23.H
+	ZBFCVTN [Z0.H-Z1.H], Z24.B
+	ZFCVTNT Z2.S, P2.M, Z3.H
+	ZFCVTNT Z4.S, P5.Z, Z5.H
+	ZFCVTNT Z6.D, P3.M, Z7.S
+	ZFCVTNT Z8.D, P4.Z, Z9.S
+	ZFCVTN [Z10.H-Z11.H], Z25.B
+	ZFCVTNB [Z12.S-Z13.S], Z26.B
+	ZFCVTNT [Z30.S-Z31.S], Z27.B
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatnarrowcvt": {Name: "svefloatnarrowcvt", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+bf16,+fp8,+sve,+sve2,+sve2p2"`,
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fp8.cvt1.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fp8.cvtlt1.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fp8.cvt2.nxv8bf16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fp8.cvtlt2.nxv8bf16",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fp8.cvt1.nxv8f16",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fp8.cvtlt1.nxv8f16",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fp8.cvt2.nxv8f16",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fp8.cvtlt2.nxv8f16",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvt.bf16f32.v2",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvtnt.bf16f32.v2",
+				"= call <vscale x 8 x bfloat> @llvm.aarch64.sve.fcvtnt.z.bf16f32",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fcvtnt.f16f32",
+				"= call <vscale x 8 x half> @llvm.aarch64.sve.fcvtnt.z.f16f32",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.fcvtnt.f32f64",
+				"= call <vscale x 4 x float> @llvm.aarch64.sve.fcvtnt.z.f32f64",
+				"= call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtn.nxv8bf16",
+				"= call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtn.nxv8f16",
+				"= call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtnb.nxv4f32",
+				"= call <vscale x 16 x i8> @llvm.aarch64.sve.fp8.cvtnt.nxv4f32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s floating narrowing conversion lowering omitted actual call %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-narrow-conversion.ll", "arm64-sve-float-narrow-conversion.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatNarrowConversionRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBF1CVT Z0.H, Z1.H",
+		"ZBF1CVTLT Z0.B, Z1.S",
+		"ZF2CVT Z0.B, Z1.D",
+		"ZBFCVT Z0.S, P8.M, Z1.H",
+		"ZBFCVTNT Z0.D, P0.M, Z1.S",
+		"ZFCVTNT Z0.H, P0.Z, Z1.B",
+		"ZBFCVTN [Z1.H-Z2.H], Z3.B",
+		"ZFCVTN [Z2.H, Z3.H], Z4.B",
+		"ZFCVTNB [Z2.H-Z3.H], Z4.B",
+		"ZFCVTNT [Z2.S-Z3.S], Z4.H",
+		"ZF1CVT.Z Z0.B, Z1.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatnarrowcvt(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatnarrowcvt": {Name: "badsvefloatnarrowcvt", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating narrowing conversion forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatNarrowConversionInfersEachFeatureClass(t *testing.T) {
+	classes := []struct {
+		name     string
+		source   string
+		features string
+	}{
+		{name: "fp8-to-bf16", source: "ZBF1CVT Z0.B, Z1.H", features: "+fp8,+sve,+sve2,+sve2p2"},
+		{name: "bf16-predicated", source: "ZBFCVTNT Z0.S, P0.M, Z1.H", features: "+bf16,+sve"},
+		{name: "sve2-merging-top-narrow", source: "ZFCVTNT Z0.D, P0.M, Z1.S", features: "+sve,+sve2"},
+		{name: "sve2p2-zeroing-top-narrow", source: "ZFCVTNT Z0.D, P0.Z, Z1.S", features: "+sve,+sve2,+sve2p2"},
+		{name: "bf16-to-fp8", source: "ZBFCVTN [Z0.H-Z1.H], Z2.B", features: "+fp8,+sve,+sve2,+sve2p2"},
+	}
+	for _, class := range classes {
+		t.Run(class.name, func(t *testing.T) {
+			source := "TEXT onefeatureclass(SB),$0-0\n\t" + class.source + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"onefeatureclass": {Name: "onefeatureclass", Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := `"target-features"="` + class.features + `"`
+					if !strings.Contains(ll, want) {
+						t.Fatalf("%s feature inference omitted %q for %s:\n%s", triple, want, class.source, ll)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-float-narrow-feature.ll", "arm64-sve-float-narrow-feature.o", ll)
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_negative_multiply_accumulate_test.go b/arm64_lower_sve_float_negative_multiply_accumulate_test.go
new file mode 100644
index 000000000..f309eedc4
--- /dev/null
+++ b/arm64_lower_sve_float_negative_multiply_accumulate_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatNegativeMultiplyAccumulateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatnegativemultiplyaccumulateforms(SB),$0-0\n")
+	for _, op := range []string{"ZFNMLA", "ZFNMLS"} {
+		for index, width := range []string{"H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z3.%s\n", op, width, width, index, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatnegativemultiplyaccumulateforms": {Name: "svefloatnegativemultiplyaccumulateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.fnmla.nxv8f16",
+				"@llvm.aarch64.sve.fnmla.nxv4f32",
+				"@llvm.aarch64.sve.fnmls.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating negative multiply-accumulate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-negative-multiply-accumulate.ll", "arm64-sve-float-negative-multiply-accumulate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatNegativeMultiplyAccumulateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFNMLA Z1.B, Z2.B, P0.M, Z3.B",
+		"ZFNMLS Z1.H, Z2.S, P0.M, Z3.S",
+		"ZFNMLA Z1.H, Z2.H, P0, Z3.H",
+		"ZFNMLS Z1.S, Z2.S, P8.M, Z3.S",
+		"ZFNMLA Z7.H[0], Z2.H, Z3.H",
+		"ZFNMLS.Z Z1.S, Z2.S, P0.M, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatnegativemultiplyaccumulate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatnegativemultiplyaccumulate": {Name: "badsvefloatnegativemultiplyaccumulate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating negative multiply-accumulate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_predicated_pairwise.go b/arm64_lower_sve_float_predicated_pairwise.go
new file mode 100644
index 000000000..c40950fa6
--- /dev/null
+++ b/arm64_lower_sve_float_predicated_pairwise.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEFloatPredicatedPairwiseSpec struct {
+	intrinsic string
+	sve2      bool
+	faminmax  bool
+}
+
+var arm64SVEFloatPredicatedPairwiseSpecs = map[Op]arm64SVEFloatPredicatedPairwiseSpec{
+	"ZFABD":  {intrinsic: "fabd"},
+	"ZFADDP": {intrinsic: "faddp", sve2: true},
+	"ZFAMAX": {intrinsic: "famax", sve2: true, faminmax: true},
+	"ZFAMIN": {intrinsic: "famin", sve2: true, faminmax: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatPredicatedPairwise(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFloatPredicatedPairwiseSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.H|S|D, Zdn.H|S|D, Pg/M, Zdn.H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	repeatedDestination, repeatedBits, repeatedOK := arm64SVEFloatElementReg(ins.Args[3])
+	if !secondOK || !destinationOK || !predicateOK || !repeatedOK || secondBits != destinationBits || repeatedBits != destinationBits || repeatedDestination != destination {
+		return true, false, fmt.Errorf("arm64 %s requires matching destructive H/S/D operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	destinationValue, vectorType, err := c.loadRawSVEFloatVector(destination, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadRawSVEFloatVector(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, err := arm64SVEFloatType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[destinationBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, mangle, predicateType, predicateValue, vectorType, destinationValue, vectorType, secondValue)
+	return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_predicated_pairwise_test.go b/arm64_lower_sve_float_predicated_pairwise_test.go
new file mode 100644
index 000000000..f64bea6d6
--- /dev/null
+++ b/arm64_lower_sve_float_predicated_pairwise_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatPredicatedPairwiseCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatpredicatedpairwise(SB),$0-0\n")
+	for opIndex, op := range []string{"ZFABD", "ZFADDP", "ZFAMAX", "ZFAMIN"} {
+		for widthIndex, width := range []string{"H", "S", "D"} {
+			destination := opIndex*3 + widthIndex
+			fmt.Fprintf(&source, "\t%s Z%d.%s, Z%d.%s, P%d.M, Z%d.%s\n", op, (destination+1)%32, width, destination, width, (opIndex+widthIndex)%8, destination, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatpredicatedpairwise": {Name: "svefloatpredicatedpairwise", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+faminmax,+sve,+sve2"`,
+				"@llvm.aarch64.sve.fabd.nxv8f16",
+				"@llvm.aarch64.sve.faddp.nxv4f32",
+				"@llvm.aarch64.sve.famax.nxv2f64",
+				"@llvm.aarch64.sve.famin.nxv8f16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicated floating pairwise lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-predicated-pairwise.ll", "arm64-sve-float-predicated-pairwise.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatPredicatedPairwiseRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFABD Z1.B, Z2.B, P0.M, Z2.B",
+		"ZFADDP Z1.H, Z2.S, P0.M, Z2.S",
+		"ZFAMAX Z1.S, Z2.S, P8.M, Z2.S",
+		"ZFAMIN Z1.D, Z2.D, P0.Z, Z2.D",
+		"ZFABD Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFADDP.Z Z1.D, Z2.D, P0.M, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatpredicatedpairwise(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatpredicatedpairwise": {Name: "badsvefloatpredicatedpairwise", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's predicated floating pairwise forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_reciprocal_step.go b/arm64_lower_sve_float_reciprocal_step.go
new file mode 100644
index 000000000..0f98db875
--- /dev/null
+++ b/arm64_lower_sve_float_reciprocal_step.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEFloatReciprocalStepIntrinsics = map[Op]string{
+	"ZFRECPS":  "frecps.x",
+	"ZFRSQRTS": "frsqrts.x",
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatReciprocalStep(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEFloatReciprocalStepIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.H|S|D, Zn.H|S|D, Zd.H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64SVEFloatElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64SVEFloatElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s requires three matching H/S/D scalable floating-vector operands: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadRawSVEFloatVector(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadRawSVEFloatVector(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, err := arm64SVEFloatType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	mangle := map[int]string{16: "f16", 32: "f32", 64: "f64"}[firstBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%d%s(%s %s, %s %s)\n", result, vectorType, intrinsic, lanes, mangle, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_reciprocal_step_test.go b/arm64_lower_sve_float_reciprocal_step_test.go
new file mode 100644
index 000000000..1799e21e0
--- /dev/null
+++ b/arm64_lower_sve_float_reciprocal_step_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatReciprocalStepCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatreciprocalstep(SB),$0-0\n")
+	for opIndex, op := range []string{"ZFRECPS", "ZFRSQRTS"} {
+		for widthIndex, width := range []string{"H", "S", "D"} {
+			reg := opIndex*3 + widthIndex
+			fmt.Fprintf(&source, "\t%s Z%d.%s, Z%d.%s, Z%d.%s\n", op, reg, width, reg+1, width, reg+2, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatreciprocalstep": {Name: "svefloatreciprocalstep", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.frecps.x.nxv8f16",
+				"@llvm.aarch64.sve.frecps.x.nxv4f32",
+				"@llvm.aarch64.sve.frsqrts.x.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating reciprocal-step lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-reciprocal-step.ll", "arm64-sve-float-reciprocal-step.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatReciprocalStepRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFRECPS Z1.B, Z2.B, Z3.B",
+		"ZFRECPS Z1.H, Z2.S, Z3.S",
+		"ZFRSQRTS Z1.S, Z2.S, Z3.D",
+		"ZFRSQRTS Z1.Q, Z2.Q, Z3.Q",
+		"ZFRECPS Z1.S, Z2.S",
+		"ZFRSQRTS.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatreciprocalstep(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatreciprocalstep": {Name: "badsvefloatreciprocalstep", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's floating reciprocal-step forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_trig_multiply.go b/arm64_lower_sve_float_trig_multiply.go
new file mode 100644
index 000000000..3119e729b
--- /dev/null
+++ b/arm64_lower_sve_float_trig_multiply.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEFloatTrigIntrinsics = map[Op]string{
+	"ZFTSMUL": "ftsmul",
+	"ZFTSSEL": "ftssel",
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatTrigMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEFloatTrigIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 vector form without a suffix: %q", op, ins.Raw)
+	}
+	control, controlBits, controlOK := arm64SVEFloatElementReg(ins.Args[0])
+	source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	if !controlOK || !sourceOK || !destinationOK || controlBits != sourceBits || sourceBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s operands must use one H/S/D width: %q", op, ins.Raw)
+	}
+	sourceValue, floatVectorType, err := c.loadRawSVEFloatVector(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	controlValue, integerVectorType, err := c.loadZRegElements(control, controlBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, _ := arm64SVEFloatType(sourceBits)
+	code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[sourceBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x.nxv%d%s(%s %s, %s %s)\n",
+		result, floatVectorType, intrinsic, lanes, code, floatVectorType, sourceValue, integerVectorType, controlValue)
+	return true, false, c.storeRawSVEFloatVector(destination, sourceBits, "%"+result, floatVectorType)
+}
diff --git a/arm64_lower_sve_float_trig_multiply_add.go b/arm64_lower_sve_float_trig_multiply_add.go
new file mode 100644
index 000000000..23bb60c1f
--- /dev/null
+++ b/arm64_lower_sve_float_trig_multiply_add.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEFloatTrigMultiplyAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZFTMAD" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 ZFTMAD expects one complete Go 1.27 vector form without a suffix: %q", ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat || ins.Args[0].Imm < 0 || ins.Args[0].Imm > 7 {
+		return true, false, fmt.Errorf("arm64 ZFTMAD immediate must be an unsigned 3-bit integer: %q", ins.Raw)
+	}
+	multiplier, multiplierBits, multiplierOK := arm64SVEFloatElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	repeated, repeatedBits, repeatedOK := arm64SVEFloatElementReg(ins.Args[3])
+	if !multiplierOK || !destinationOK || !repeatedOK || multiplierBits != destinationBits || destinationBits != repeatedBits || destination != repeated {
+		return true, false, fmt.Errorf("arm64 ZFTMAD requires matching destructive H/S/D operands: %q", ins.Raw)
+	}
+	destinationValue, vectorType, err := c.loadRawSVEFloatVector(destination, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	multiplierValue, _, err := c.loadRawSVEFloatVector(multiplier, multiplierBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, _, lanes, _ := arm64SVEFloatType(destinationBits)
+	code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[destinationBits]
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ftmad.x.nxv%d%s(%s %s, %s %s, i32 %d)\n",
+		result, vectorType, lanes, code, vectorType, destinationValue, vectorType, multiplierValue, ins.Args[0].Imm)
+	return true, false, c.storeRawSVEFloatVector(destination, destinationBits, "%"+result, vectorType)
+}
diff --git a/arm64_lower_sve_float_trig_multiply_add_test.go b/arm64_lower_sve_float_trig_multiply_add_test.go
new file mode 100644
index 000000000..eeed53dca
--- /dev/null
+++ b/arm64_lower_sve_float_trig_multiply_add_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatTrigMultiplyAddCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloattrigmultiplyaddforms(SB),$0-0\n")
+	for _, width := range []string{"H", "S", "D"} {
+		for _, immediate := range []int{0, 7} {
+			fmt.Fprintf(&source, "\tZFTMAD $%d, Z1.%s, Z2.%s, Z2.%s\n", immediate, width, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloattrigmultiplyaddforms": {Name: "svefloattrigmultiplyaddforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.ftmad.x.nxv8f16",
+				"@llvm.aarch64.sve.ftmad.x.nxv4f32",
+				"@llvm.aarch64.sve.ftmad.x.nxv2f64",
+				"i32 0",
+				"i32 7",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating trigonometric multiply-add lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-trig-multiply-add.ll", "arm64-sve-float-trig-multiply-add.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatTrigMultiplyAddRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFTMAD $-1, Z1.S, Z2.S, Z2.S",
+		"ZFTMAD $8, Z1.S, Z2.S, Z2.S",
+		"ZFTMAD $0, Z1.B, Z2.B, Z2.B",
+		"ZFTMAD $0, Z1.H, Z2.S, Z2.S",
+		"ZFTMAD $0, Z1.S, Z2.S, Z3.S",
+		"ZFTMAD.Z $0, Z1.S, Z2.S, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloattrigmultiplyadd(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloattrigmultiplyadd": {Name: "badsvefloattrigmultiplyadd", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZFTMAD forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_trig_multiply_test.go b/arm64_lower_sve_float_trig_multiply_test.go
new file mode 100644
index 000000000..dcee942a0
--- /dev/null
+++ b/arm64_lower_sve_float_trig_multiply_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEFloatTrigMultiplyCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svefloattrigmultiplyforms(SB),$0-0\n")
+	for _, op := range []string{"ZFTSMUL", "ZFTSSEL"} {
+		for _, width := range []string{"H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloattrigmultiplyforms": {Name: "svefloattrigmultiplyforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.ftsmul.x.nxv8f16",
+				"@llvm.aarch64.sve.ftsmul.x.nxv4f32",
+				"@llvm.aarch64.sve.ftsmul.x.nxv2f64",
+				"@llvm.aarch64.sve.ftssel.x.nxv8f16",
+				"@llvm.aarch64.sve.ftssel.x.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating trigonometric multiply lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-trig-multiply.ll", "arm64-sve-float-trig-multiply.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatTrigMultiplyRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFTSMUL Z1.B, Z2.B, Z3.B",
+		"ZFTSMUL Z1.H, Z2.S, Z3.S",
+		"ZFTSMUL Z1.S, Z2.S, Z3.D",
+		"ZFTSMUL Z1.S, Z2.S, P0.M, Z3.S",
+		"ZFTSMUL.Z Z1.S, Z2.S, Z3.S",
+		"ZFTSSEL Z1.B, Z2.B, Z3.B",
+		"ZFTSSEL Z1.H, Z2.S, Z3.S",
+		"ZFTSSEL.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloattrigmultiply(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloattrigmultiply": {Name: "badsvefloattrigmultiply", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZFTSMUL forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_float_unary.go b/arm64_lower_sve_float_unary.go
new file mode 100644
index 000000000..41f0cfa3c
--- /dev/null
+++ b/arm64_lower_sve_float_unary.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+type arm64SVEFloatUnarySpec struct {
+	intrinsic   string
+	unpred      bool
+	sdOnly      bool
+	integerBits int
+	fptoint     bool
+	rawBase     uint32
+	rawZeroBase uint32
+}
+
+var arm64SVEFloatUnarySpecs = map[Op]arm64SVEFloatUnarySpec{
+	"ZFABS":     {intrinsic: "fabs", rawBase: 0x041ca000, rawZeroBase: 0x040ca000},
+	"ZFNEG":     {intrinsic: "fneg", rawBase: 0x041da000, rawZeroBase: 0x040da000},
+	"ZFRECPE":   {intrinsic: "frecpe.x", unpred: true, rawBase: 0x650e3000},
+	"ZFRECPX":   {intrinsic: "frecpx", rawBase: 0x650ca000, rawZeroBase: 0x641b8000},
+	"ZFRINT32X": {intrinsic: "rint", sdOnly: true, integerBits: 32, fptoint: true, rawBase: 0x6511a000, rawZeroBase: 0x641ca000},
+	"ZFRINT32Z": {intrinsic: "trunc", sdOnly: true, integerBits: 32, fptoint: true, rawBase: 0x6510a000, rawZeroBase: 0x641c8000},
+	"ZFRINT64X": {intrinsic: "rint", sdOnly: true, integerBits: 64, fptoint: true, rawBase: 0x6515a000, rawZeroBase: 0x641da000},
+	"ZFRINT64Z": {intrinsic: "trunc", sdOnly: true, integerBits: 64, fptoint: true, rawBase: 0x6514a000, rawZeroBase: 0x641d8000},
+	"ZFRINTA":   {intrinsic: "frinta", rawBase: 0x6504a000, rawZeroBase: 0x64198000},
+	"ZFRINTI":   {intrinsic: "frinti", rawBase: 0x6507a000, rawZeroBase: 0x6419e000},
+	"ZFRINTM":   {intrinsic: "frintm", rawBase: 0x6502a000, rawZeroBase: 0x6418c000},
+	"ZFRINTN":   {intrinsic: "frintn", rawBase: 0x6500a000, rawZeroBase: 0x64188000},
+	"ZFRINTP":   {intrinsic: "frintp", rawBase: 0x6501a000, rawZeroBase: 0x6418a000},
+	"ZFRINTX":   {intrinsic: "frintx", rawBase: 0x6506a000, rawZeroBase: 0x6419c000},
+	"ZFRINTZ":   {intrinsic: "frintz", rawBase: 0x6503a000, rawZeroBase: 0x6418e000},
+	"ZFRSQRTE":  {intrinsic: "frsqrte.x", unpred: true, rawBase: 0x650f3000},
+	"ZFSQRT":    {intrinsic: "fsqrt", rawBase: 0x650da000, rawZeroBase: 0x641ba000},
+}
+
+// The opcode bases and operand fields are the complete Go 1.27 unary family.
+// Named and raw forms share one spec, including predication and sized rounding.
+func decodeARM64RawSVEFloatUnary(word uint32) (Instr, bool) {
+	size := word >> 22 & 3
+	for op, spec := range arm64SVEFloatUnarySpecs {
+		if !spec.sdOnly && size == 0 {
+			continue
+		}
+		mask, zeroMask := uint32(0x00c01fff), uint32(0x00c01fff)
+		if spec.unpred {
+			mask = 0x00c003ff
+		} else if spec.sdOnly {
+			// Go's SzSD1718 and SzSD1415 put the S/D selector in
+			// different positions for merging and zeroing encodings.
+			mask, zeroMask = 0x00021fff, 0x00005fff
+		}
+		zero := !spec.unpred && word&^zeroMask == spec.rawZeroBase
+		if !zero && word&^mask != spec.rawBase {
+			continue
+		}
+		width := "BHSD"[size]
+		if spec.sdOnly {
+			shift := uint(17)
+			if zero {
+				shift = 14
+			}
+			width = "SD"[word>>shift&1]
+		}
+		args := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))}}
+		if !spec.unpred {
+			mode := "M"
+			if zero {
+				mode = "Z"
+			}
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", word>>10&7, mode))})
+		}
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))})
+		return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+type arm64SVEFloatUnaryForm struct {
+	elementBits int
+	source      int
+	predicate   int
+	destination int
+	zeroing     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatUnary(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEFloatUnarySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEFloatUnaryForm{}
+	if spec.unpred {
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("arm64 %s expects Zn.T, Zd.T: %q", op, ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[1])
+		if !sourceOK || !destinationOK || sourceBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s requires matching H, S, or D vector widths: %q", op, ins.Raw)
+		}
+		form = arm64SVEFloatUnaryForm{elementBits: sourceBits, source: source, destination: destination}
+	} else {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s expects Zn.T, Pg/M|Z, Zd.T: %q", op, ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64SVEFloatElementReg(ins.Args[0])
+		destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+		predicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+		if !mergeOK {
+			predicate, form.zeroing = 0, true
+			var zeroOK bool
+			predicate, zeroOK = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+			if !zeroOK {
+				return true, false, fmt.Errorf("arm64 %s requires P0..P7/M or P0..P7/Z: %q", op, ins.Raw)
+			}
+		}
+		if !sourceOK || !destinationOK || sourceBits != destinationBits || (spec.sdOnly && sourceBits == 16) {
+			return true, false, fmt.Errorf("arm64 %s vector widths do not match its Go 1.27 form: %q", op, ins.Raw)
+		}
+		form.elementBits = sourceBits
+		form.source = source
+		form.predicate = predicate
+		form.destination = destination
+	}
+	return true, false, c.lowerARM64SVEFloatUnaryForm(spec, form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFloatUnaryForm(spec arm64SVEFloatUnarySpec, form arm64SVEFloatUnaryForm) error {
+	source, vectorType, err := c.loadRawSVEFloatVector(form.source, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, _, lanes, err := arm64SVEFloatType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	mangle := fmt.Sprintf("nxv%d%s", lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[form.elementBits])
+	if spec.integerBits != 0 {
+		calculated, err := c.lowerARM64SVEFRIntSized(spec, source, vectorType, mangle, lanes, form.elementBits)
+		if err != nil {
+			return err
+		}
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		inactive := "zeroinitializer"
+		if !form.zeroing {
+			inactive, _, err = c.loadRawSVEFloatVector(form.destination, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, calculated, vectorType, inactive)
+		return c.storeRawSVEFloatVector(form.destination, form.elementBits, "%"+selected, vectorType)
+	}
+	result := c.newTmp()
+	if spec.unpred {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.%s(%s %s)\n", result, vectorType, spec.intrinsic, mangle, vectorType, source)
+	} else {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		merge := source
+		if !form.zeroing {
+			merge, _, err = c.loadRawSVEFloatVector(form.destination, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.%s(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, mangle, vectorType, merge, predicateType, predicate, vectorType, source)
+		if form.zeroing {
+			integerType, _, err := arm64SVEVectorType(form.elementBits)
+			if err != nil {
+				return err
+			}
+			bits := c.newTmp()
+			mask := c.newTmp()
+			zeroed := c.newTmp()
+			converted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", bits, vectorType, result, integerType)
+			fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", mask, predicateType, predicate, integerType)
+			fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", zeroed, integerType, bits, mask)
+			fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to %s\n", converted, integerType, zeroed, vectorType)
+			result = converted
+		}
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.elementBits, "%"+result, vectorType)
+}
+
+func (c *arm64Ctx) lowerARM64SVEFRIntSized(spec arm64SVEFloatUnarySpec, source, vectorType, mangle string, lanes, elementBits int) (string, error) {
+	rounded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %s)\n", rounded, vectorType, spec.intrinsic, mangle, vectorType, source)
+	integerType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.integerBits)
+	integers := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fptosi.sat.nxv%di%d.%s(%s %%%s)\n", integers, integerType, lanes, spec.integerBits, mangle, vectorType, rounded)
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sitofp %s %%%s to %s\n", converted, integerType, integers, vectorType)
+	minimum := -math.Ldexp(1, spec.integerBits-1)
+	upper := math.Ldexp(1, spec.integerBits-1)
+	minimumVector, err := c.arm64SVEFloatSplat(minimum, elementBits)
+	if err != nil {
+		return "", err
+	}
+	upperVector, err := c.arm64SVEFloatSplat(upper, elementBits)
+	if err != nil {
+		return "", err
+	}
+	geMinimum := c.newTmp()
+	belowUpper := c.newTmp()
+	valid := c.newTmp()
+	fixed := c.newTmp()
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	fmt.Fprintf(c.b, "  %%%s = fcmp oge %s %%%s, %s\n", geMinimum, vectorType, rounded, minimumVector)
+	fmt.Fprintf(c.b, "  %%%s = fcmp olt %s %%%s, %s\n", belowUpper, vectorType, rounded, upperVector)
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", valid, predicateType, geMinimum, belowUpper)
+	fmt.Fprintf(c.b, "  %%%s = select %s %%%s, %s %%%s, %s %s\n", fixed, predicateType, valid, vectorType, converted, vectorType, minimumVector)
+	return "%" + fixed, nil
+}
diff --git a/arm64_lower_sve_float_unary_test.go b/arm64_lower_sve_float_unary_test.go
new file mode 100644
index 000000000..dc5ec225f
--- /dev/null
+++ b/arm64_lower_sve_float_unary_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEFloatUnaryCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svefloatunaryforms(SB),$0-0\n")
+	for _, op := range []string{"ZFABS", "ZFNEG", "ZFRECPX", "ZFRINTA", "ZFRINTI", "ZFRINTM", "ZFRINTN", "ZFRINTP", "ZFRINTX", "ZFRINTZ", "ZFSQRT"} {
+		for index, width := range []string{"H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			for _, mode := range []string{"M", "Z"} {
+				source.WriteString("\t" + op + " Z1." + width + ", P" + predicate + "." + mode + ", Z2." + width + "\n")
+			}
+		}
+	}
+	for _, op := range []string{"ZFRINT32X", "ZFRINT32Z", "ZFRINT64X", "ZFRINT64Z"} {
+		for index, width := range []string{"S", "D"} {
+			predicate := string(rune('0' + index))
+			for _, mode := range []string{"M", "Z"} {
+				source.WriteString("\t" + op + " Z3." + width + ", P" + predicate + "." + mode + ", Z4." + width + "\n")
+			}
+		}
+	}
+	for _, op := range []string{"ZFRECPE", "ZFRSQRTE"} {
+		for _, width := range []string{"H", "S", "D"} {
+			source.WriteString("\t" + op + " Z5." + width + ", Z6." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEFloatUnaryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEFloatUnaryCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svefloatunaryforms": {Name: "svefloatunaryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+fptoint,+sve"`, "@llvm.aarch64.sve.fabs.nxv", "@llvm.fptosi.sat.nxv2i64.nxv2f64", "@llvm.aarch64.sve.frecpe.x.nxv", "@llvm.aarch64.sve.frsqrte.x.nxv", "@llvm.aarch64.sve.fsqrt.nxv"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE floating unary lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float-unary.ll", "arm64-sve-float-unary.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEFloatUnaryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFABS Z1.B, P0.M, Z2.B",
+		"ZFNEG Z1.S, P0, Z2.S",
+		"ZFSQRT Z1.S, P8.M, Z2.S",
+		"ZFRECPX Z1.S, P0.M, Z2.D",
+		"ZFRINT32X Z1.H, P0.M, Z2.H",
+		"ZFRINT64Z Z1.S, P0.M, Z2.D",
+		"ZFRECPE Z1.S, P0.M, Z2.S",
+		"ZFRSQRTE Z1.S, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefloatunary(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefloatunary": {Name: "badsvefloatunary", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE floating unary forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_halving_add_sub.go b/arm64_lower_sve_halving_add_sub.go
new file mode 100644
index 000000000..65b235c58
--- /dev/null
+++ b/arm64_lower_sve_halving_add_sub.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEHalvingAddSubIntrinsics = map[Op]string{
+	"ZSHADD":  "shadd",
+	"ZSRHADD": "srhadd",
+	"ZUHADD":  "uhadd",
+	"ZURHADD": "urhadd",
+	"ZSHSUB":  "shsub",
+	"ZSHSUBR": "shsubr",
+	"ZUHSUB":  "uhsub",
+	"ZUHSUBR": "uhsubr",
+}
+
+func (c *arm64Ctx) lowerARM64SVEHalvingAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEHalvingAddSubIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zdn.T, P0..P7/M, Zdn.T without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+		return true, false, fmt.Errorf("arm64 %s requires matching-width destructive data operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_halving_add_sub_test.go b/arm64_lower_sve_halving_add_sub_test.go
new file mode 100644
index 000000000..ea0ab16e1
--- /dev/null
+++ b/arm64_lower_sve_halving_add_sub_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEHalvingAddSubCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svehalvingaddsubforms(SB),$0-0\n")
+	for _, op := range []string{"ZSHADD", "ZSRHADD", "ZUHADD", "ZURHADD", "ZSHSUB", "ZSHSUBR", "ZUHSUB", "ZUHSUBR"} {
+		for predicate, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", P" + string(rune('0'+predicate)) + ".M, Z2." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEHalvingAddSubCompleteGo127Family(t *testing.T) {
+	source := arm64SVEHalvingAddSubCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svehalvingaddsubforms": {Name: "svehalvingaddsubforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.shadd.nxv16i8",
+				"@llvm.aarch64.sve.srhadd.nxv8i16",
+				"@llvm.aarch64.sve.uhadd.nxv4i32",
+				"@llvm.aarch64.sve.urhadd.nxv2i64",
+				"@llvm.aarch64.sve.shsub.nxv16i8",
+				"@llvm.aarch64.sve.shsubr.nxv8i16",
+				"@llvm.aarch64.sve.uhsub.nxv4i32",
+				"@llvm.aarch64.sve.uhsubr.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE halving add/sub lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-halving-add-sub.ll", "arm64-sve-halving-add-sub.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEHalvingAddSubRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSHADD Z1.B, Z2.H, P0.M, Z2.H",
+		"ZSRHADD Z1.S, Z2.S, P0, Z2.S",
+		"ZUHADD Z1.D, Z2.D, P8.M, Z2.D",
+		"ZURHADD Z1.H, Z2.H, P0.M, Z3.H",
+		"ZSHSUB Z1.Q, Z2.Q, P0.M, Z2.Q",
+		"ZSHSUBR Z1.S, Z2.H, P0.M, Z2.H",
+		"ZUHSUB Z1.S, Z2.S, P0.Z, Z2.S",
+		"ZUHSUBR.Z Z1.D, Z2.D, P0.M, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvehalvingaddsub(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvehalvingaddsub": {Name: "badsvehalvingaddsub", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE halving add/sub forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_histogram.go b/arm64_lower_sve_histogram.go
new file mode 100644
index 000000000..4806c1a05
--- /dev/null
+++ b/arm64_lower_sve_histogram.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEHistogramOps = map[Op]struct{}{
+	"ZHISTCNT": {},
+	"ZHISTSEG": {},
+}
+
+func (c *arm64Ctx) lowerARM64SVEHistogram(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, ok := arm64SVEHistogramOps[op]; !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept a mnemonic suffix: %q", op, ins.Raw)
+	}
+	if op == "ZHISTSEG" {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 ZHISTSEG expects Zm.B, Zn.B, Zd.B: %q", ins.Raw)
+		}
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != 8 || firstBits != 8 || destinationBits != 8 {
+			return true, false, fmt.Errorf("arm64 ZHISTSEG requires three B scalable-vector operands: %q", ins.Raw)
+		}
+		firstValue, vectorType, err := c.loadZRegElements(first, 8)
+		if err != nil {
+			return true, false, err
+		}
+		secondValue, _, err := c.loadZRegElements(second, 8)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.histseg.nxv16i8(%s %s, %s %s)\n", result, vectorType, vectorType, firstValue, vectorType, secondValue)
+		return true, false, c.storeZRegElements(destination, 8, "%"+result)
+	}
+	if len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 ZHISTCNT expects Zm.S|D, Zn.S|D, Pg/Z, Zd.S|D: %q", ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "Z", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || (firstBits != 32 && firstBits != 64) || secondBits != firstBits || destinationBits != firstBits {
+		return true, false, fmt.Errorf("arm64 ZHISTCNT requires matching S/D vectors under P0..P7/Z: %q", ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.histcnt.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_histogram_test.go b/arm64_lower_sve_histogram_test.go
new file mode 100644
index 000000000..683d36713
--- /dev/null
+++ b/arm64_lower_sve_histogram_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEHistogramCompleteGo127Family(t *testing.T) {
+	source := `
+TEXT svehistogram(SB),$0-0
+	ZHISTCNT Z1.S, Z2.S, P0.Z, Z3.S
+	ZHISTCNT Z4.D, Z5.D, P7.Z, Z6.D
+	ZHISTSEG Z7.B, Z8.B, Z9.B
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svehistogram": {Name: "svehistogram", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.histcnt.nxv4i32",
+				"@llvm.aarch64.sve.histcnt.nxv2i64",
+				"@llvm.aarch64.sve.histseg.nxv16i8",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE histogram lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-histogram.ll", "arm64-sve-histogram.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEHistogramRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZHISTCNT Z1.B, Z2.B, P0.Z, Z3.B",
+		"ZHISTCNT Z1.H, Z2.H, P0.Z, Z3.H",
+		"ZHISTCNT Z1.S, Z2.D, P0.Z, Z3.S",
+		"ZHISTCNT Z1.S, Z2.S, P8.Z, Z3.S",
+		"ZHISTCNT Z1.S, Z2.S, P0.M, Z3.S",
+		"ZHISTSEG Z1.H, Z2.H, Z3.H",
+		"ZHISTSEG Z1.B, Z2.B, Z3.H",
+		"ZHISTSEG.Z Z1.B, Z2.B, Z3.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvehistogram(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvehistogram": {Name: "badsvehistogram", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's histogram forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_index.go b/arm64_lower_sve_index.go
new file mode 100644
index 000000000..757cadd09
--- /dev/null
+++ b/arm64_lower_sve_index.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The two operand-class bits describe the complete INDEX family independently
+// of element size: immediate/immediate, register/immediate, immediate/register,
+// and register/register. Unlike Go's ZINDEX spelling, raw register forms do not
+// force D elements; select ZINDEXW for their B/H/S encodings.
+func decodeARM64RawSVEIndex(word uint32) (Instr, bool) {
+	const operands = uint32(3<<22 | 31<<16 | 3<<10 | 31<<5 | 31)
+	if word&^operands != 0x04204000 {
+		return Instr{}, false
+	}
+	scalar := func(value uint32, register bool) Operand {
+		if !register {
+			return Operand{Kind: OpImm, Imm: int64(int32(value<<27) >> 27)}
+		}
+		if value == 31 {
+			return Operand{Kind: OpReg, Reg: ZR}
+		}
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", value))}
+	}
+	size := word >> 22 & 3
+	form := word >> 10 & 3
+	op := Op("ZINDEX")
+	if form != 0 && size != 3 {
+		op = "ZINDEXW"
+	}
+	return Instr{Op: op, Raw: fmt.Sprintf("decoded ARM64 WORD %#08x as %s", word, op), Args: []Operand{
+		scalar(word>>16&31, form&2 != 0),
+		scalar(word>>5&31, form&1 != 0),
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, "BHSD"[size]))},
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEIndex(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZINDEX" && op != "ZINDEXW" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects step, start, Zd.B/H/S/D without a suffix: %q", op, ins.Raw)
+	}
+	destination, writtenBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s destination must be Z0..Z31.B/H/S/D: %q", op, ins.Raw)
+	}
+	stepIsReg := arm64SVEIndexScalarRegister(ins.Args[0])
+	startIsReg := arm64SVEIndexScalarRegister(ins.Args[1])
+	stepIsImm := arm64SVEIndexImmediate(ins.Args[0])
+	startIsImm := arm64SVEIndexImmediate(ins.Args[1])
+	if !stepIsReg && !stepIsImm || !startIsReg && !startIsImm || op == "ZINDEXW" && stepIsImm && startIsImm {
+		return true, false, fmt.Errorf("arm64 %s operands do not match its Go 1.27 scalar/immediate forms: %q", op, ins.Raw)
+	}
+
+	// Go's ZINDEX register encodings carry fixed D size bits. The generated
+	// assembler accepts B/H/S spellings too, but ORs their size field with D;
+	// preserve the resulting machine semantics rather than the written suffix.
+	elementBits := writtenBits
+	if op == "ZINDEX" && (stepIsReg || startIsReg) {
+		elementBits = 64
+	}
+	step, err := c.arm64SVEIndexScalar(ins.Args[0], elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	start, err := c.arm64SVEIndexScalar(ins.Args[1], elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.index.nxv%di%d(i%d %s, i%d %s)\n",
+		result, vectorType, lanes, elementBits, elementBits, start, elementBits, step)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func arm64SVEIndexScalarRegister(operand Operand) bool {
+	return operand.Kind == OpReg && isARM64GeneralOrZeroReg(operand.Reg)
+}
+
+func arm64SVEIndexImmediate(operand Operand) bool {
+	return operand.Kind == OpImm && operand.ImmRaw == "" && operand.Imm >= -16 && operand.Imm <= 15
+}
+
+func (c *arm64Ctx) arm64SVEIndexScalar(operand Operand, elementBits int) (string, error) {
+	if arm64SVEIndexImmediate(operand) {
+		return fmt.Sprintf("%d", operand.Imm), nil
+	}
+	if !arm64SVEIndexScalarRegister(operand) {
+		return "", fmt.Errorf("arm64 SVE INDEX scalar must be R0..R30, ZR, or a signed 5-bit immediate")
+	}
+	value, err := c.loadReg(operand.Reg)
+	if err != nil {
+		return "", err
+	}
+	if elementBits == 64 || value == "0" {
+		return value, nil
+	}
+	truncated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, value, elementBits)
+	return "%" + truncated, nil
+}
diff --git a/arm64_lower_sve_index_test.go b/arm64_lower_sve_index_test.go
new file mode 100644
index 000000000..5eb90fa62
--- /dev/null
+++ b/arm64_lower_sve_index_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEIndexCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveindexforms(SB),$0-0\n")
+	for _, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZINDEX R1, R2, Z3.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEX ZR, $15, Z4.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEX $-16, R5, Z6.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEX $1, $11, Z7.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEXW R8, R9, Z10.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEXW ZR, $-16, Z11.%s\n", width)
+		fmt.Fprintf(&source, "\tZINDEXW $15, R12, Z13.%s\n", width)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEIndexCompleteGo127Family(t *testing.T) {
+	source := arm64SVEIndexCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveindexforms": {Name: "sveindexforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.index.nxv16i8",
+				"@llvm.aarch64.sve.index.nxv8i16",
+				"@llvm.aarch64.sve.index.nxv4i32",
+				"@llvm.aarch64.sve.index.nxv2i64",
+				"@llvm.aarch64.sve.index.nxv4i32(i32 11, i32 1)",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE INDEX lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			// Go's ZINDEX scalar forms always set the D size bits, even when
+			// their accepted destination spelling carries B/H/S.
+			if got := strings.Count(ll, "@llvm.aarch64.sve.index.nxv2i64"); got < 13 {
+				t.Fatalf("%s ZINDEX scalar forms did not preserve Go's forced-D encoding: got %d i64 references\n%s", triple, got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-index.ll", "arm64-sve-index.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEIndexRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZINDEXW $1, $2, Z0.S",
+		"ZINDEX $-17, R0, Z0.D",
+		"ZINDEX $16, R0, Z0.D",
+		"ZINDEX RSP, R0, Z0.D",
+		"ZINDEX R0, RSP, Z0.D",
+		"ZINDEX R0, R1, Z0",
+		"ZINDEX R0, R1, Z0.Q",
+		"ZINDEX R0, R1, V0.D",
+		"ZINDEX.Z R0, R1, Z0.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveindex(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			// The malformed NEON destination panics in Go's SVE classifier.
+			// Keep its translator regression, but do not call that crash a
+			// successful Go form rejection. The actual tool defect is observed
+			// independently by TestGoAssemblerKnownMalformedInputDefects.
+			if instruction != "ZINDEX R0, R1, V0.D" {
+				requireARM64SVEGoAssemblerResult(t, source, false)
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveindex": {Name: "badsveindex", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE INDEX forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_insert.go b/arm64_lower_sve_insert.go
new file mode 100644
index 000000000..f340b787e
--- /dev/null
+++ b/arm64_lower_sve_insert.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var arm64SVEInsertBaseSize = map[Op]int{
+	"ZINSR":  3,
+	"ZINSRW": 0,
+	"ZINSRB": 0,
+	"ZINSRH": 1,
+	"ZINSRS": 2,
+	"ZINSRD": 3,
+}
+
+func (c *arm64Ctx) lowerARM64SVEInsert(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	baseSize, ok := arm64SVEInsertBaseSize[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects scalar, Zdn.B/H/S/D without a suffix: %q", op, ins.Raw)
+	}
+	destination, writtenBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s destination must be Z0..Z31.B/H/S/D: %q", op, ins.Raw)
+	}
+	writtenSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[writtenBits]
+	elementBits := 8 << (baseSize | writtenSize)
+
+	var scalar string
+	if op == "ZINSR" || op == "ZINSRW" {
+		if !arm64SVEIndexScalarRegister(ins.Args[0]) {
+			return true, false, fmt.Errorf("arm64 %s source must be R0..R30 or ZR: %q", op, ins.Raw)
+		}
+		scalar, err = c.loadReg(ins.Args[0].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		if elementBits != 64 && scalar != "0" {
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", truncated, scalar, elementBits)
+			scalar = "%" + truncated
+		}
+	} else {
+		vectorRegister, vectorOK := arm64SVEInsertVRegister(ins.Args[0])
+		if !vectorOK {
+			return true, false, fmt.Errorf("arm64 %s source must be a bare V0..V31 register: %q", op, ins.Raw)
+		}
+		scalar, err = c.arm64SVEInsertVectorScalar(vectorRegister, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+
+	oldVector, vectorType, err := c.loadZRegElements(destination, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.insr.nxv%di%d(%s %s, i%d %s)\n",
+		result, vectorType, lanes, elementBits, vectorType, oldVector, elementBits, scalar)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func arm64SVEInsertVRegister(operand Operand) (Reg, bool) {
+	if operand.Kind != OpReg {
+		return "", false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if !strings.HasPrefix(text, "V") || strings.ContainsAny(text, ".[") {
+		return "", false
+	}
+	index, err := strconv.Atoi(text[1:])
+	return Reg(text), err == nil && index >= 0 && index <= 31
+}
+
+func (c *arm64Ctx) arm64SVEInsertVectorScalar(register Reg, elementBits int) (string, error) {
+	bytes, err := c.loadVReg(register)
+	if err != nil {
+		return "", err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", 128/elementBits, elementBits)
+	vector := bytes
+	if elementBits != 8 {
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", converted, bytes, vectorType)
+		vector = "%" + converted
+	}
+	scalar := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i64 0\n", scalar, vectorType, vector)
+	return "%" + scalar, nil
+}
diff --git a/arm64_lower_sve_insert_test.go b/arm64_lower_sve_insert_test.go
new file mode 100644
index 000000000..436eaa1ee
--- /dev/null
+++ b/arm64_lower_sve_insert_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEInsertCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveinsertforms(SB),$0-0\n")
+	for _, spec := range []struct {
+		op     string
+		source string
+	}{
+		{op: "ZINSR", source: "ZR"},
+		{op: "ZINSRW", source: "R25"},
+		{op: "ZINSRB", source: "V25"},
+		{op: "ZINSRH", source: "V7"},
+		{op: "ZINSRS", source: "V14"},
+		{op: "ZINSRD", source: "V2"},
+	} {
+		for vector, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s %s, Z%d.%s\n", spec.op, spec.source, vector+1, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEInsertCompleteGo127Family(t *testing.T) {
+	source := arm64SVEInsertCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveinsertforms": {Name: "sveinsertforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.insr.nxv16i8",
+				"@llvm.aarch64.sve.insr.nxv8i16",
+				"@llvm.aarch64.sve.insr.nxv4i32",
+				"@llvm.aarch64.sve.insr.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE INSR lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-insert.ll", "arm64-sve-insert.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEInsertRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZINSR V0, Z0.D",
+		"ZINSRW V0, Z0.S",
+		"ZINSRB R0, Z0.B",
+		"ZINSRH R0, Z0.H",
+		"ZINSRS R0, Z0.S",
+		"ZINSRD R0, Z0.D",
+		"ZINSR RSP, Z0.D",
+		"ZINSR R0, Z0",
+		"ZINSRB V0, Z0.Q",
+		"ZINSR.Z R0, Z0.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveinsert(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveinsert": {Name: "badsveinsert", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE INSR forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_integer_dot.go b/arm64_lower_sve_integer_dot.go
new file mode 100644
index 000000000..b46fbad63
--- /dev/null
+++ b/arm64_lower_sve_integer_dot.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEIntegerDotSpec struct {
+	intrinsic   string
+	mixed       bool
+	indexedOnly bool
+	rawBases    [4][2]uint32 // B->H, H->S, B->S, H->D; vector and indexed.
+}
+
+var arm64SVEIntegerDotSpecs = map[Op]arm64SVEIntegerDotSpec{
+	"ZSDOT": {intrinsic: "sdot", rawBases: [4][2]uint32{
+		{0x44400000, 0x44200000}, {0x4400c800, 0x4480c800},
+		{0x44800000, 0x44a00000}, {0x44c00000, 0x44e00000},
+	}},
+	"ZUDOT": {intrinsic: "udot", rawBases: [4][2]uint32{
+		{0x44400400, 0x44200400}, {0x4400cc00, 0x4480cc00},
+		{0x44800400, 0x44a00400}, {0x44c00400, 0x44e00400},
+	}},
+	"ZSUDOT": {intrinsic: "sudot", mixed: true, indexedOnly: true,
+		rawBases: [4][2]uint32{2: {0, 0x44a01c00}}},
+	"ZUSDOT": {intrinsic: "usdot", mixed: true,
+		rawBases: [4][2]uint32{2: {0x44807800, 0x44a01800}}},
+}
+
+type arm64SVEIntegerDotWidths struct {
+	source, destination        int
+	maximumVector, maximumLane int
+	feature                    string
+}
+
+var arm64SVEIntegerDotWidthForms = [...]arm64SVEIntegerDotWidths{
+	{8, 16, 7, 7, "+sve2p3"},
+	{16, 32, 7, 3, "+sve2p1"},
+	{8, 32, 7, 3, ""},
+	{16, 64, 15, 1, ""},
+}
+
+type arm64SVEIntegerDotForm struct {
+	intrinsic       string
+	sourceBits      int
+	destinationBits int
+	first           int
+	second          int
+	destination     int
+	lane            int
+	indexed         bool
+}
+
+func arm64SVEIntegerDotFeature(ins Instr) string {
+	if len(ins.Args) != 3 {
+		return ""
+	}
+	_, sourceBits, ok := arm64ParseSVEZElementReg(ins.Args[0])
+	if !ok {
+		_, sourceBits, _, ok = arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+	}
+	_, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !ok || !destinationOK {
+		return ""
+	}
+	for _, widths := range arm64SVEIntegerDotWidthForms {
+		if widths.source == sourceBits && widths.destination == destinationBits {
+			return widths.feature
+		}
+	}
+	return ""
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerDot(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEIntegerDotSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 integer-dot form without a suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEIntegerDotForm{intrinsic: spec.intrinsic}
+	if first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0]); firstOK {
+		form.first = first
+		form.sourceBits = firstBits
+	} else {
+		first, firstBits, lane, firstOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !firstOK {
+			return true, false, fmt.Errorf("arm64 %s first source must be a B/H vector or indexed vector: %q", op, ins.Raw)
+		}
+		form.first = first
+		form.sourceBits = firstBits
+		form.lane = lane
+		form.indexed = true
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || secondBits != form.sourceBits || !destinationOK || !arm64SVEIntegerDotWidthOK(spec, form.sourceBits, destinationBits) || spec.indexedOnly && !form.indexed {
+		return true, false, fmt.Errorf("arm64 %s has an invalid source/destination width or indexing mode: %q", op, ins.Raw)
+	}
+	if form.indexed {
+		maximumVector, maximumLane := arm64SVEIntegerDotIndexedLimits(form.sourceBits, destinationBits)
+		if maximumVector < 0 || form.first > maximumVector || form.lane > maximumLane {
+			return true, false, fmt.Errorf("arm64 %s indexed source is outside the Go 1.27 register/lane range: %q", op, ins.Raw)
+		}
+	}
+	form.second = second
+	form.destination = destination
+	form.destinationBits = destinationBits
+	return true, false, c.lowerARM64SVEIntegerDotForm(form)
+}
+
+func arm64SVEIntegerDotWidthOK(spec arm64SVEIntegerDotSpec, sourceBits, destinationBits int) bool {
+	if spec.mixed {
+		return sourceBits == 8 && destinationBits == 32
+	}
+	for _, widths := range arm64SVEIntegerDotWidthForms {
+		if widths.source == sourceBits && widths.destination == destinationBits {
+			return true
+		}
+	}
+	return false
+}
+
+func arm64SVEIntegerDotIndexedLimits(sourceBits, destinationBits int) (maximumVector, maximumLane int) {
+	for _, widths := range arm64SVEIntegerDotWidthForms {
+		if widths.source == sourceBits && widths.destination == destinationBits {
+			return widths.maximumVector, widths.maximumLane
+		}
+	}
+	return -1, -1
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerDotForm(form arm64SVEIntegerDotForm) error {
+	accumulator, destinationType, err := c.loadZRegElements(form.destination, form.destinationBits)
+	if err != nil {
+		return err
+	}
+	second, sourceType, err := c.loadZRegElements(form.second, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	first, _, err := c.loadZRegElements(form.first, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	if form.destinationBits == 16 {
+		result := c.newTmp()
+		assembly := form.intrinsic + " $0.h, $2.b, $3.b"
+		if form.indexed {
+			assembly += fmt.Sprintf("[%d]", form.lane)
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, %s %s)\n", result, destinationType, assembly, "=&w,0,w,w", destinationType, accumulator, sourceType, second, sourceType, first)
+		return c.storeZRegElements(form.destination, form.destinationBits, "%"+result)
+	}
+	lanes := 128 / form.destinationBits
+	intrinsic := form.intrinsic
+	if form.indexed {
+		intrinsic += ".lane"
+	}
+	if form.destinationBits == form.sourceBits*2 {
+		intrinsic += ".x2"
+	}
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n", result, destinationType, intrinsic, lanes, form.destinationBits, destinationType, accumulator, sourceType, second, sourceType, first, form.lane)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, intrinsic, lanes, form.destinationBits, destinationType, accumulator, sourceType, second, sourceType, first)
+	}
+	return c.storeZRegElements(form.destination, form.destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_integer_dot_test.go b/arm64_lower_sve_integer_dot_test.go
new file mode 100644
index 000000000..ec9770aff
--- /dev/null
+++ b/arm64_lower_sve_integer_dot_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEIntegerDotCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveintegerdotforms(SB),$0-0\n")
+	for _, op := range []string{"ZSDOT", "ZUDOT"} {
+		for _, widths := range [][2]string{{"B", "H"}, {"H", "S"}, {"B", "S"}, {"H", "D"}} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, widths[0], widths[0], widths[1])
+		}
+		for _, form := range []struct {
+			source, destination string
+			vector, lane        int
+		}{{"B", "H", 7, 7}, {"H", "S", 7, 3}, {"B", "S", 7, 3}, {"H", "D", 15, 1}} {
+			fmt.Fprintf(&source, "\t%s Z%d.%s[%d], Z2.%s, Z3.%s\n", op, form.vector, form.source, form.lane, form.source, form.destination)
+		}
+	}
+	source.WriteString("\tZUSDOT Z1.B, Z2.B, Z3.S\n")
+	source.WriteString("\tZUSDOT Z7.B[3], Z2.B, Z3.S\n")
+	source.WriteString("\tZSUDOT Z7.B[3], Z2.B, Z3.S\n")
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveintegerdotforms": {Name: "sveintegerdotforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+i8mm,+sve,+sve2,+sve2p1,+sve2p3"`,
+				`asm sideeffect "sdot $0.h, $2.b, $3.b"`,
+				`asm sideeffect "udot $0.h, $2.b, $3.b[7]"`,
+				"@llvm.aarch64.sve.sdot.nxv2i64",
+				"@llvm.aarch64.sve.udot.lane.x2.nxv4i32",
+				"@llvm.aarch64.sve.usdot.nxv4i32",
+				"@llvm.aarch64.sve.sudot.lane.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE integer dot lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-integer-dot.ll", "arm64-sve-integer-dot.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEIntegerDotRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSDOT Z1.B, Z2.H, Z3.S",
+		"ZUDOT Z1.B, Z2.B, Z3.D",
+		"ZSDOT Z8.B[0], Z2.B, Z3.S",
+		"ZUDOT Z7.B[4], Z2.B, Z3.S",
+		"ZSDOT Z16.H[0], Z2.H, Z3.D",
+		"ZUDOT Z15.H[2], Z2.H, Z3.D",
+		"ZSUDOT Z1.B, Z2.B, Z3.S",
+		"ZUSDOT Z1.H, Z2.H, Z3.S",
+		"ZSDOT.Z Z1.B, Z2.B, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveintegerdot(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveintegerdot": {Name: "badsveintegerdot", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE integer dot forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_integer_reduction.go b/arm64_lower_sve_integer_reduction.go
new file mode 100644
index 000000000..2d50f2d35
--- /dev/null
+++ b/arm64_lower_sve_integer_reduction.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEIntegerReductionSpec struct {
+	intrinsic   string
+	elementBits int
+	quad        bool
+	rawBase     uint32
+}
+
+var arm64SVEIntegerReductionSpecs = map[Op]arm64SVEIntegerReductionSpec{
+	"ZADDQV": {intrinsic: "addqv", quad: true, rawBase: 0x04052000},
+	"ZANDQV": {intrinsic: "andqv", quad: true, rawBase: 0x041e2000},
+	"ZANDVB": {intrinsic: "andv", elementBits: 8, rawBase: 0x041a2000},
+	"ZANDVH": {intrinsic: "andv", elementBits: 16, rawBase: 0x045a2000},
+	"ZANDVS": {intrinsic: "andv", elementBits: 32, rawBase: 0x049a2000},
+	"ZANDVD": {intrinsic: "andv", elementBits: 64, rawBase: 0x04da2000},
+	"ZEORQV": {intrinsic: "eorqv", quad: true, rawBase: 0x041d2000},
+	"ZEORVB": {intrinsic: "eorv", elementBits: 8, rawBase: 0x04192000},
+	"ZEORVH": {intrinsic: "eorv", elementBits: 16, rawBase: 0x04592000},
+	"ZEORVS": {intrinsic: "eorv", elementBits: 32, rawBase: 0x04992000},
+	"ZEORVD": {intrinsic: "eorv", elementBits: 64, rawBase: 0x04d92000},
+	"ZORQV":  {intrinsic: "orqv", quad: true, rawBase: 0x041c2000},
+	"ZORVB":  {intrinsic: "orv", elementBits: 8, rawBase: 0x04182000},
+	"ZORVH":  {intrinsic: "orv", elementBits: 16, rawBase: 0x04582000},
+	"ZORVS":  {intrinsic: "orv", elementBits: 32, rawBase: 0x04982000},
+	"ZORVD":  {intrinsic: "orv", elementBits: 64, rawBase: 0x04d82000},
+}
+
+var arm64RawSVEIntegerReductionOps = func() map[uint32]Op {
+	ops := make(map[uint32]Op)
+	for op, spec := range arm64SVEIntegerReductionSpecs {
+		ops[spec.rawBase] = op
+		if spec.quad {
+			for size := uint32(1); size < 4; size++ {
+				ops[spec.rawBase|size<<22] = op
+			}
+		}
+	}
+	return ops
+}()
+
+func decodeARM64RawSVEIntegerReduction(word uint32) (Instr, bool) {
+	op, ok := arm64RawSVEIntegerReductionOps[word&0xffffe000]
+	if !ok {
+		return Instr{}, false
+	}
+	size := word >> 22 & 3
+	width := "BHSD"[size]
+	destination := fmt.Sprintf("V%d", word&31)
+	if arm64SVEIntegerReductionSpecs[op].quad {
+		destination += fmt.Sprintf(".%c%d", width, 16>>size)
+	}
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", word>>10&7))},
+		{Kind: OpReg, Reg: Reg(destination)},
+	}}, true
+}
+
+type arm64SVEIntegerReductionForm struct {
+	elementBits int
+	source      int
+	predicate   int
+	destination int
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerReduction(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEIntegerReductionSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form, err := arm64ParseSVEIntegerReductionForm(op, spec, ins)
+	if err != nil {
+		return true, false, err
+	}
+	return true, false, c.lowerARM64SVEIntegerReductionForm(spec, form, ins.Args[2].Reg)
+}
+
+func arm64ParseSVEIntegerReductionForm(op Op, spec arm64SVEIntegerReductionSpec, ins Instr) (arm64SVEIntegerReductionForm, error) {
+	form := arm64SVEIntegerReductionForm{}
+	if len(ins.Args) != 3 {
+		return form, fmt.Errorf("arm64 %s expects Zn.T, Pg, Vd%s: %q", op, map[bool]string{true: ".T", false: ""}[spec.quad], ins.Raw)
+	}
+	source, elementBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[1])
+	destination, destinationOK := arm64ParseVReg(ins.Args[2].Reg)
+	if !sourceOK || !predicateOK || predicate > 7 || !destinationOK || ins.Args[2].Kind != OpReg {
+		return form, fmt.Errorf("arm64 %s requires a scalable source, bare predicate, and SIMD destination: %q", op, ins.Raw)
+	}
+	if !spec.quad {
+		if strings.Contains(string(ins.Args[2].Reg), ".") {
+			return form, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+		}
+		// Go's generic Zn.T encoder ORs the operand size bits into the
+		// mnemonic's fixed size bits, rather than requiring them to match.
+		opcodeSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[spec.elementBits]
+		sourceSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+		elementBits = 8 << (opcodeSize | sourceSize)
+	} else {
+		arrangement, arrangementOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+		if !arrangementOK || arrangement.elementBits != elementBits || arrangement.lanes*arrangement.elementBits != 128 {
+			return form, fmt.Errorf("arm64 %s destination must be a full-width SIMD vector matching its source elements: %q", op, ins.Raw)
+		}
+	}
+	return arm64SVEIntegerReductionForm{elementBits: elementBits, source: source, predicate: predicate, destination: destination}, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerReductionForm(spec arm64SVEIntegerReductionSpec, form arm64SVEIntegerReductionForm, destination Reg) error {
+	source, vectorType, err := c.loadZRegElements(form.source, form.elementBits)
+	if err != nil {
+		return err
+	}
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / form.elementBits
+	result := c.newTmp()
+	if !spec.quad {
+		fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, form.elementBits, spec.intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, source)
+		return c.storeARM64ScalarToVReg(destination, form.elementBits, "%"+result)
+	}
+	fmt.Fprintf(c.b, "  %%%s = call <%d x i%d> @llvm.aarch64.sve.%s.v%di%d.nxv%di%d(%s %s, %s %s)\n", result, lanes, form.elementBits, spec.intrinsic, lanes, form.elementBits, lanes, form.elementBits, predicateType, predicate, vectorType, source)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, lanes, form.elementBits, result)
+	return c.storeVReg(destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_integer_reduction_test.go b/arm64_lower_sve_integer_reduction_test.go
new file mode 100644
index 000000000..bb472d0d2
--- /dev/null
+++ b/arm64_lower_sve_integer_reduction_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEIntegerReductionCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveintreduceforms(SB),$0-0\n")
+	for _, base := range []string{"ZANDV", "ZEORV", "ZORV"} {
+		for predicate, sourceWidth := range []string{"B", "H", "S", "D"} {
+			// Go's generated reduction rows use a generic Zn.T operand for each
+			// VB/VH/VS/VD spelling. Cover the full 4x4 encoder matrix; the
+			// effective hardware width is the bitwise union of both size fields.
+			for _, opcodeWidth := range []string{"B", "H", "S", "D"} {
+				source.WriteString("\t" + base + opcodeWidth + " Z1." + sourceWidth + ", P" + string(rune('0'+predicate)) + ", V2\n")
+			}
+		}
+	}
+	for _, op := range []string{"ZADDQV", "ZANDQV", "ZEORQV", "ZORQV"} {
+		for predicate, width := range []string{"B", "H", "S", "D"} {
+			arrangement := map[string]string{"B": "B16", "H": "H8", "S": "S4", "D": "D2"}[width]
+			source.WriteString("\t" + op + " Z3." + width + ", P" + string(rune('4'+predicate)) + ", V5." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEIntegerReductionCompleteGo127Family(t *testing.T) {
+	source := arm64SVEIntegerReductionCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveintreduceforms": {Name: "sveintreduceforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.andv.nxv16i8",
+				"@llvm.aarch64.sve.eorv.nxv8i16",
+				"@llvm.aarch64.sve.orv.nxv4i32",
+				"@llvm.aarch64.sve.addqv.v2i64.nxv2i64",
+				"@llvm.aarch64.sve.andqv.v16i8.nxv16i8",
+				"@llvm.aarch64.sve.eorqv.v8i16.nxv8i16",
+				"@llvm.aarch64.sve.orqv.v4i32.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE integer reduction lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-integer-reduction.ll", "arm64-sve-integer-reduction.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEIntegerReductionRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZANDVB Z1.H, P0.M, V2",
+		"ZEORVH Z1.H, P8, V2",
+		"ZORVS Z1.S, P0, V2.S4",
+		"ZADDQV Z1.S, P0, V2.H8",
+		"ZANDQV Z1.H, P0, V2",
+		"ZEORQV Z1.D, P0.M, V2.D2",
+		"ZORQV Z1.Q, P0, V2.B16",
+		"ZADDQV.Z Z1.B, P0, V2.B16",
+		"ZANDVB Z1.B, P0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveintreduce(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveintreduce": {Name: "badsveintreduce", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE integer reduction forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_integer_unary.go b/arm64_lower_sve_integer_unary.go
new file mode 100644
index 000000000..b1f6e3259
--- /dev/null
+++ b/arm64_lower_sve_integer_unary.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEIntegerUnarySpec struct {
+	intrinsic string
+	unpred    bool
+	minBits   int
+	maxBits   int
+	sve2      bool
+	rawMerge  uint32
+	rawZero   uint32
+}
+
+var arm64SVEIntegerUnarySpecs = map[Op]arm64SVEIntegerUnarySpec{
+	"ZABS":     {intrinsic: "abs", minBits: 8, rawMerge: 0x0416a000, rawZero: 0x0406a000},
+	"ZCLS":     {intrinsic: "cls", minBits: 8, rawMerge: 0x0418a000, rawZero: 0x0408a000},
+	"ZCLZ":     {intrinsic: "clz", minBits: 8, rawMerge: 0x0419a000, rawZero: 0x0409a000},
+	"ZCNOT":    {intrinsic: "cnot", minBits: 8, sve2: true, rawMerge: 0x041ba000, rawZero: 0x040ba000},
+	"ZCNT":     {intrinsic: "cnt", minBits: 8, rawMerge: 0x041aa000, rawZero: 0x040aa000},
+	"ZNEG":     {intrinsic: "neg", minBits: 8, rawMerge: 0x0417a000, rawZero: 0x0407a000},
+	"ZNOT":     {intrinsic: "not", minBits: 8, rawMerge: 0x041ea000, rawZero: 0x040ea000},
+	"ZRBIT":    {intrinsic: "rbit", minBits: 8, sve2: true, rawMerge: 0x05278000, rawZero: 0x0527a000},
+	"ZREV":     {intrinsic: "vector.reverse", unpred: true, minBits: 8, rawMerge: 0x05383800},
+	"ZREVB":    {intrinsic: "revb", minBits: 16, sve2: true, rawMerge: 0x05248000, rawZero: 0x0524a000},
+	"ZREVH":    {intrinsic: "revh", minBits: 32, sve2: true, rawMerge: 0x05258000, rawZero: 0x0525a000},
+	"ZREVW":    {intrinsic: "revw", minBits: 64, sve2: true, rawMerge: 0x05268000, rawZero: 0x0526a000},
+	"ZSQABS":   {intrinsic: "sqabs", minBits: 8, sve2: true, rawMerge: 0x4408a000, rawZero: 0x440aa000},
+	"ZSQNEG":   {intrinsic: "sqneg", minBits: 8, sve2: true, rawMerge: 0x4409a000, rawZero: 0x440ba000},
+	"ZSXTB":    {intrinsic: "sxtb", minBits: 16, rawMerge: 0x0410a000, rawZero: 0x0400a000},
+	"ZSXTH":    {intrinsic: "sxth", minBits: 32, rawMerge: 0x0412a000, rawZero: 0x0402a000},
+	"ZSXTW":    {intrinsic: "sxtw", minBits: 64, rawMerge: 0x0414a000, rawZero: 0x0404a000},
+	"ZUXTB":    {intrinsic: "uxtb", minBits: 16, rawMerge: 0x0411a000, rawZero: 0x0401a000},
+	"ZUXTH":    {intrinsic: "uxth", minBits: 32, rawMerge: 0x0413a000, rawZero: 0x0403a000},
+	"ZUXTW":    {intrinsic: "uxtw", minBits: 64, rawMerge: 0x0415a000, rawZero: 0x0405a000},
+	"ZURECPE":  {intrinsic: "urecpe", minBits: 32, maxBits: 32, sve2: true, rawMerge: 0x4400a000, rawZero: 0x4402a000},
+	"ZURSQRTE": {intrinsic: "ursqrte", minBits: 32, maxBits: 32, sve2: true, rawMerge: 0x4401a000, rawZero: 0x4403a000},
+}
+
+type arm64SVEIntegerUnaryForm struct {
+	elementBits int
+	source      int
+	predicate   int
+	destination int
+	zeroing     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerUnary(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEIntegerUnarySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEIntegerUnaryForm{}
+	if spec.unpred {
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("arm64 %s expects Zn.T, Zd.T: %q", op, ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+		if !sourceOK || !destinationOK || sourceBits != destinationBits || sourceBits < spec.minBits || (spec.maxBits != 0 && sourceBits > spec.maxBits) {
+			return true, false, fmt.Errorf("arm64 %s vector widths do not match its Go 1.27 form: %q", op, ins.Raw)
+		}
+		form = arm64SVEIntegerUnaryForm{elementBits: sourceBits, source: source, destination: destination}
+	} else {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s expects Zn.T, Pg/M|Z, Zd.T: %q", op, ins.Raw)
+		}
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		predicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+		if !mergeOK {
+			form.zeroing = true
+			var zeroOK bool
+			predicate, zeroOK = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+			if !zeroOK {
+				return true, false, fmt.Errorf("arm64 %s requires P0..P7/M or P0..P7/Z: %q", op, ins.Raw)
+			}
+		}
+		if !sourceOK || !destinationOK || sourceBits != destinationBits || sourceBits < spec.minBits || (spec.maxBits != 0 && sourceBits > spec.maxBits) {
+			return true, false, fmt.Errorf("arm64 %s vector widths do not match its Go 1.27 form: %q", op, ins.Raw)
+		}
+		form.elementBits = sourceBits
+		form.source = source
+		form.predicate = predicate
+		form.destination = destination
+	}
+	return true, false, c.lowerARM64SVEIntegerUnaryForm(spec, form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEIntegerUnaryForm(spec arm64SVEIntegerUnarySpec, form arm64SVEIntegerUnaryForm) error {
+	source, vectorType, err := c.loadZRegElements(form.source, form.elementBits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / form.elementBits
+	result := c.newTmp()
+	if spec.unpred {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.nxv%di%d(%s %s)\n", result, vectorType, spec.intrinsic, lanes, form.elementBits, vectorType, source)
+	} else {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		merge := source
+		if !form.zeroing {
+			merge, _, err = c.loadZRegElements(form.destination, form.elementBits)
+			if err != nil {
+				return err
+			}
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, form.elementBits, vectorType, merge, predicateType, predicate, vectorType, source)
+		if form.zeroing {
+			mask := c.newTmp()
+			zeroed := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", mask, predicateType, predicate, vectorType)
+			fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %%%s\n", zeroed, vectorType, result, mask)
+			result = zeroed
+		}
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_integer_unary_test.go b/arm64_lower_sve_integer_unary_test.go
new file mode 100644
index 000000000..b5af52475
--- /dev/null
+++ b/arm64_lower_sve_integer_unary_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEIntegerUnaryCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveintegerunaryforms(SB),$0-0\n")
+	for _, op := range []string{"ZABS", "ZCLS", "ZCLZ", "ZCNOT", "ZCNT", "ZNEG", "ZNOT", "ZRBIT", "ZSQABS", "ZSQNEG"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			for _, mode := range []string{"M", "Z"} {
+				source.WriteString("\t" + op + " Z1." + width + ", P" + predicate + "." + mode + ", Z2." + width + "\n")
+			}
+		}
+	}
+	for _, spec := range []struct {
+		op     string
+		widths []string
+	}{
+		{"ZREVB", []string{"H", "S", "D"}},
+		{"ZREVH", []string{"S", "D"}},
+		{"ZREVW", []string{"D"}},
+		{"ZSXTB", []string{"H", "S", "D"}},
+		{"ZUXTB", []string{"H", "S", "D"}},
+		{"ZSXTH", []string{"S", "D"}},
+		{"ZUXTH", []string{"S", "D"}},
+		{"ZSXTW", []string{"D"}},
+		{"ZUXTW", []string{"D"}},
+		{"ZURECPE", []string{"S"}},
+		{"ZURSQRTE", []string{"S"}},
+	} {
+		for index, width := range spec.widths {
+			predicate := string(rune('0' + index))
+			for _, mode := range []string{"M", "Z"} {
+				source.WriteString("\t" + spec.op + " Z3." + width + ", P" + predicate + "." + mode + ", Z4." + width + "\n")
+			}
+		}
+	}
+	for _, width := range []string{"B", "H", "S", "D"} {
+		source.WriteString("\tZREV Z5." + width + ", Z6." + width + "\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEIntegerUnaryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEIntegerUnaryCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveintegerunaryforms": {Name: "sveintegerunaryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.abs.nxv", "@llvm.aarch64.sve.cnt.nxv", "@llvm.aarch64.sve.rbit.nxv", "@llvm.aarch64.sve.sqabs.nxv", "@llvm.aarch64.sve.sxtb.nxv", "@llvm.aarch64.sve.urecpe.nxv", "@llvm.vector.reverse.nxv"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE integer unary lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-integer-unary.ll", "arm64-sve-integer-unary.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEIntegerUnaryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZABS Z1.S, P0, Z2.S",
+		"ZCNT Z1.S, P8.M, Z2.S",
+		"ZNEG Z1.S, P0.M, Z2.D",
+		"ZREVB Z1.B, P0.M, Z2.B",
+		"ZREVH Z1.H, P0.M, Z2.H",
+		"ZREVW Z1.S, P0.M, Z2.S",
+		"ZSXTB Z1.B, P0.M, Z2.B",
+		"ZUXTH Z1.H, P0.M, Z2.H",
+		"ZSXTW Z1.S, P0.M, Z2.S",
+		"ZURECPE Z1.H, P0.M, Z2.H",
+		"ZURSQRTE Z1.D, P0.M, Z2.D",
+		"ZREV Z1.S, P0.M, Z2.S",
+		"ZREV Z1.S, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveintegerunary(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveintegerunary": {Name: "badsveintegerunary", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE integer unary forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_last.go b/arm64_lower_sve_last.go
new file mode 100644
index 000000000..36f7cec1d
--- /dev/null
+++ b/arm64_lower_sve_last.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVELastSpec struct {
+	intrinsic string
+	baseSize  int
+	vectorDst bool
+}
+
+var arm64SVELastSpecs = map[Op]arm64SVELastSpec{
+	"ZLASTA":  {intrinsic: "lasta", baseSize: 3},
+	"ZLASTAW": {intrinsic: "lasta"},
+	"ZLASTAB": {intrinsic: "lasta", vectorDst: true},
+	"ZLASTAH": {intrinsic: "lasta", baseSize: 1, vectorDst: true},
+	"ZLASTAS": {intrinsic: "lasta", baseSize: 2, vectorDst: true},
+	"ZLASTAD": {intrinsic: "lasta", baseSize: 3, vectorDst: true},
+	"ZLASTB":  {intrinsic: "lastb", baseSize: 3},
+	"ZLASTBW": {intrinsic: "lastb"},
+	"ZLASTBB": {intrinsic: "lastb", vectorDst: true},
+	"ZLASTBH": {intrinsic: "lastb", baseSize: 1, vectorDst: true},
+	"ZLASTBS": {intrinsic: "lastb", baseSize: 2, vectorDst: true},
+	"ZLASTBD": {intrinsic: "lastb", baseSize: 3, vectorDst: true},
+}
+
+// decodeARM64RawSVELast canonicalizes all Go 1.27 LASTA/LASTB aliases into
+// four opcode classes. Size bits select B/H/S/D; the named lowering preserves
+// the scalar or vector destination semantics of each class.
+func decodeARM64RawSVELast(word uint32) (Instr, bool) {
+	const variableBits = uint32(0x00c01fff)
+	forms := [...]struct {
+		op        Op
+		base      uint32
+		vectorDst bool
+	}{
+		{"ZLASTAW", 0x0520a000, false},
+		{"ZLASTAB", 0x05228000, true},
+		{"ZLASTBW", 0x0521a000, false},
+		{"ZLASTBB", 0x05238000, true},
+	}
+	for _, form := range forms {
+		if word&^variableBits != form.base {
+			continue
+		}
+		width := [...]string{"B", "H", "S", "D"}[word>>22&3]
+		source := int(word>>5) & 31
+		predicate := int(word>>10) & 7
+		destination := int(word) & 31
+		register := Reg(fmt.Sprintf("R%d", destination))
+		if form.vectorDst {
+			register = Reg(fmt.Sprintf("V%d", destination))
+		} else if destination == 31 {
+			register = ZR
+		}
+		args := []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", source, width))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", predicate))},
+			{Kind: OpReg, Reg: register},
+		}
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVELast(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVELastSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.B/H/S/D, Pg, scalar destination without a suffix: %q", op, ins.Raw)
+	}
+	source, writtenBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	if !sourceOK || !predicateOK {
+		return true, false, fmt.Errorf("arm64 %s requires a Z source and P0..P7: %q", op, ins.Raw)
+	}
+	writtenSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[writtenBits]
+	elementBits := 8 << (spec.baseSize | writtenSize)
+
+	var destination Reg
+	if spec.vectorDst {
+		var destinationOK bool
+		destination, destinationOK = arm64SVEInsertVRegister(ins.Args[2])
+		if !destinationOK {
+			return true, false, fmt.Errorf("arm64 %s destination must be a bare V0..V31 register: %q", op, ins.Raw)
+		}
+	} else {
+		if !arm64SVEIndexScalarRegister(ins.Args[2]) {
+			return true, false, fmt.Errorf("arm64 %s destination must be R0..R30 or ZR: %q", op, ins.Raw)
+		}
+		destination = ins.Args[2].Reg
+	}
+
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorValue, vectorType, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n",
+		result, elementBits, spec.intrinsic, lanes, elementBits, predicateType, predicateValue, vectorType, vectorValue)
+	if spec.vectorDst {
+		return true, false, c.storeARM64ScalarToVReg(destination, elementBits, "%"+result)
+	}
+	value := "%" + result
+	if elementBits != 64 {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %s to i64\n", extended, elementBits, value)
+		value = "%" + extended
+	}
+	return true, false, c.storeReg(destination, value)
+}
+
+func (c *arm64Ctx) storeARM64ScalarToVReg(register Reg, elementBits int, value string) error {
+	vectorType := fmt.Sprintf("<%d x i%d>", 128/elementBits, elementBits)
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s zeroinitializer, i%d %s, i64 0\n", inserted, vectorType, elementBits, value)
+	bytes := "%" + inserted
+	if elementBits != 8 {
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", converted, vectorType, inserted)
+		bytes = "%" + converted
+	}
+	return c.storeVReg(register, bytes)
+}
diff --git a/arm64_lower_sve_last_test.go b/arm64_lower_sve_last_test.go
new file mode 100644
index 000000000..4bc94b2eb
--- /dev/null
+++ b/arm64_lower_sve_last_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVELastCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svelastforms(SB),$0-0\n")
+	for _, selector := range []string{"A", "B"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\tZLAST%s Z1.%s, P0, R2\n", selector, width)
+			fmt.Fprintf(&source, "\tZLAST%sW Z3.%s, P1, R4\n", selector, width)
+			fmt.Fprintf(&source, "\tZLAST%sB Z5.%s, P2, V6\n", selector, width)
+			fmt.Fprintf(&source, "\tZLAST%sH Z7.%s, P3, V8\n", selector, width)
+			fmt.Fprintf(&source, "\tZLAST%sS Z9.%s, P4, V10\n", selector, width)
+			fmt.Fprintf(&source, "\tZLAST%sD Z11.%s, P7, V12\n", selector, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVELastCompleteGo127Family(t *testing.T) {
+	source := arm64SVELastCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svelastforms": {Name: "svelastforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.lasta.nxv16i8",
+				"@llvm.aarch64.sve.lasta.nxv8i16",
+				"@llvm.aarch64.sve.lastb.nxv4i32",
+				"@llvm.aarch64.sve.lastb.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE LAST lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-last.ll", "arm64-sve-last.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVELastCompleteFamily(t *testing.T) {
+	// The twelve Go 1.27 LAST[A/B] mnemonic rows collapse to four raw
+	// opcode classes (scalar/vector destination for A/B) and four sizes.
+	// gocc emits LASTA W8, P0, Z1.B at 0x0520a028.
+	bases := []uint32{0x0520a000, 0x05228000, 0x0521a000, 0x05238000}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVELast(SB),$0-0\n")
+	for _, base := range bases {
+		for size := uint32(0); size < 4; size++ {
+			word := base | size<<22 | 1<<5 | 8
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVELast": {Name: "rawSVELast", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.lasta.nxv16i8",
+				"@llvm.aarch64.sve.lasta.nxv8i16",
+				"@llvm.aarch64.sve.lastb.nxv4i32",
+				"@llvm.aarch64.sve.lastb.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw LAST IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-last.ll", "arm64-raw-sve-last.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVELastBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word uint32
+		op   Op
+		args []Reg
+	}{
+		{0x0520a028, "ZLASTAW", []Reg{"Z1.B", "P0", "R8"}},
+		{0x05e28028, "ZLASTAB", []Reg{"Z1.D", "P0", "V8"}},
+		{0x0521a028, "ZLASTBW", []Reg{"Z1.B", "P0", "R8"}},
+	} {
+		ins, ok := decodeARM64RawSVELast(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != len(test.args) {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		for index, want := range test.args {
+			if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+				t.Errorf("%#08x operand %d = %+v, want %s", test.word, index, ins.Args[index], want)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x0520a028 | (1 << 14),
+		0x0520a028 ^ (1 << 21),
+	} {
+		if ins, ok := decodeARM64RawSVELast(word); ok {
+			t.Errorf("decoded reserved LAST %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVELastRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLASTA Z0.D, P8, R0",
+		"ZLASTB Z0.D, P0.M, R0",
+		"ZLASTAW Z0.S, P0, V0",
+		"ZLASTBW Z0.S, P0, RSP",
+		"ZLASTAB Z0.B, P0, R0",
+		"ZLASTBH Z0.H, P0, R0",
+		"ZLASTAS Z0.S, P0, R0",
+		"ZLASTBD Z0.D, P0, R0",
+		"ZLASTA Z0.Q, P0, R0",
+		"ZLASTA.Z Z0.D, P0, R0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvelast(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvelast": {Name: "badsvelast", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE LAST forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_logical_family_test.go b/arm64_lower_sve_logical_family_test.go
new file mode 100644
index 000000000..a1a7c66f4
--- /dev/null
+++ b/arm64_lower_sve_logical_family_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVELogicalCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveLogicalFamily(SB), $0-0\n")
+	for _, op := range []string{"ZAND", "ZBIC", "ZEOR", "ZORR"} {
+		source.WriteString("\t" + op + " Z1.D, Z2.D, Z3.D\n")
+		for i, arrangement := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z4.%s, Z5.%s, P%d.M, Z5.%s\n", op, arrangement, arrangement, i, arrangement)
+		}
+		if op != "ZBIC" {
+			source.WriteString("\t" + op + " $0x55, Z6.B, Z6.B\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveLogicalFamily": {Name: "sveLogicalFamily", Ret: Void}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, want := range []string{" and <vscale x ", " or <vscale x ", " xor <vscale x ", " select <vscale x "} {
+			if !strings.Contains(ir, want) {
+				t.Fatalf("%s SVE logical family IR omitted %q:\n%s", triple, want, ir)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-sve-logical-family.ll", "arm64-sve-logical-family.o", ir)
+	}
+}
+
+func TestARM64RawSVELogicalDecoderDistinguishesCompleteFamily(t *testing.T) {
+	for _, test := range []struct {
+		op                                  Op
+		unpredicated, predicated, immediate uint32
+		hasImmediate                        bool
+	}{
+		{"ZAND", 0x04203000, 0x041a0000, 0x05800000, true},
+		{"ZBIC", 0x04e03000, 0x041b0000, 0, false},
+		{"ZEOR", 0x04a03000, 0x04190000, 0x05400000, true},
+		{"ZORR", 0x04603000, 0x04180000, 0x05000000, true},
+	} {
+		for _, word := range []uint32{test.unpredicated | 1<<16 | 2<<5 | 3, test.predicated | 2<<22 | 4<<5 | 5<<10 | 6} {
+			form, ok := decodeARM64RawSVEEOR(word)
+			if !ok || form.op != test.op {
+				t.Fatalf("decoded %s word %#08x as %+v, ok=%v", test.op, word, form, ok)
+			}
+		}
+		if test.hasImmediate {
+			form, ok := decodeARM64RawSVEEOR(test.immediate | 0x03c<<5 | 7)
+			if !ok || form.op != test.op || form.mode != arm64SVEEORImmediate {
+				t.Fatalf("decoded %s immediate as %+v, ok=%v", test.op, form, ok)
+			}
+		}
+	}
+}
diff --git a/arm64_lower_sve_lsr.go b/arm64_lower_sve_lsr.go
new file mode 100644
index 000000000..880a57455
--- /dev/null
+++ b/arm64_lower_sve_lsr.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVELSRMode uint8
+
+const (
+	arm64SVELSRWidePredicated arm64SVELSRMode = iota
+	arm64SVELSRWideUnpredicated
+	arm64SVELSRVectorPredicated
+	arm64SVELSRImmediatePredicated
+	arm64SVELSRImmediateUnpredicated
+)
+
+type arm64RawSVELSR struct {
+	op          Op
+	mode        arm64SVELSRMode
+	elementBits int
+	shifts      int
+	source      int
+	predicate   int
+	shift       int
+	destination int
+}
+
+type arm64SVEShiftSpec struct {
+	intrinsic string
+	right     bool
+}
+
+var arm64SVEShiftSpecs = map[Op]arm64SVEShiftSpec{
+	"ZASR": {intrinsic: "asr", right: true},
+	"ZLSL": {intrinsic: "lsl"},
+	"ZLSR": {intrinsic: "lsr", right: true},
+}
+
+func decodeARM64SVEShiftImmediate(word uint32, lowBit int) (elementBits, shift int, ok bool) {
+	encoded := 0
+	if lowBit == 5 {
+		encoded = int(word>>5)&7 | (int(word>>8)&3)<<3 | (int(word>>22)&3)<<5
+	} else {
+		encoded = int(word>>16)&7 | (int(word>>19)&3)<<3 | (int(word>>22)&3)<<5
+	}
+	switch {
+	case encoded >= 64:
+		elementBits = 64
+	case encoded >= 32:
+		elementBits = 32
+	case encoded >= 16:
+		elementBits = 16
+	case encoded >= 8:
+		elementBits = 8
+	default:
+		return 0, 0, false
+	}
+	shift = 2*elementBits - encoded
+	return elementBits, shift, shift >= 1 && shift <= elementBits
+}
+
+// All five Go 1.27 forms of ASR, LSL, and LSR share register fields. Keep
+// the operation and form axes separate so raw WORDs use the named lowerer.
+var arm64SVEShiftWidePredicatedBases = map[uint32]Op{
+	0x04188000: "ZASR",
+	0x041b8000: "ZLSL",
+	0x04198000: "ZLSR",
+}
+
+var arm64SVEShiftWideUnpredicatedBases = map[uint32]Op{
+	0x04208000: "ZASR",
+	0x04208c00: "ZLSL",
+	0x04208400: "ZLSR",
+}
+
+var arm64SVEShiftVectorPredicatedBases = map[uint32]Op{
+	0x04108000: "ZASR",
+	0x04138000: "ZLSL",
+	0x04118000: "ZLSR",
+}
+
+var arm64SVEShiftImmediatePredicatedBases = map[uint32]Op{
+	0x04008000: "ZASR",
+	0x04038000: "ZLSL",
+	0x04018000: "ZLSR",
+}
+
+var arm64SVEShiftImmediateUnpredicatedBases = map[uint32]Op{
+	0x04209000: "ZASR",
+	0x04209c00: "ZLSL",
+	0x04209400: "ZLSR",
+}
+
+func decodeARM64RawSVEShift(word uint32) (arm64RawSVELSR, bool) {
+	form := arm64RawSVELSR{}
+	if op, ok := arm64SVEShiftWidePredicatedBases[word&0xff3fe000]; ok {
+		form.op = op
+		form.mode = arm64SVELSRWidePredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		if form.elementBits == 64 {
+			return arm64RawSVELSR{}, false
+		}
+		form.shifts = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+		form.destination = int(word) & 31
+		form.source = form.destination
+	} else if op, ok := arm64SVEShiftWideUnpredicatedBases[word&0xff20fc00]; ok {
+		form.op = op
+		form.mode = arm64SVELSRWideUnpredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		if form.elementBits == 64 {
+			return arm64RawSVELSR{}, false
+		}
+		form.shifts = int(word>>16) & 31
+		form.source = int(word>>5) & 31
+		form.destination = int(word) & 31
+	} else if op, ok := arm64SVEShiftVectorPredicatedBases[word&0xff3fe000]; ok {
+		form.op = op
+		form.mode = arm64SVELSRVectorPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.shifts = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+		form.destination = int(word) & 31
+		form.source = form.destination
+	} else if op, ok := arm64SVEShiftImmediatePredicatedBases[word&0xff3fe000]; ok {
+		form.op = op
+		form.mode = arm64SVELSRImmediatePredicated
+		var ok bool
+		form.elementBits, form.shift, ok = decodeARM64SVEShiftImmediate(word, 5)
+		if !ok {
+			return arm64RawSVELSR{}, false
+		}
+		if op == "ZLSL" {
+			form.shift = form.elementBits - form.shift
+		}
+		form.predicate = int(word>>10) & 7
+		form.destination = int(word) & 31
+		form.source = form.destination
+	} else if op, ok := arm64SVEShiftImmediateUnpredicatedBases[word&0xff20fc00]; ok {
+		form.op = op
+		form.mode = arm64SVELSRImmediateUnpredicated
+		var ok bool
+		form.elementBits, form.shift, ok = decodeARM64SVEShiftImmediate(word, 16)
+		if !ok {
+			return arm64RawSVELSR{}, false
+		}
+		if op == "ZLSL" {
+			form.shift = form.elementBits - form.shift
+		}
+		form.source = int(word>>5) & 31
+		form.destination = int(word) & 31
+	} else {
+		return arm64RawSVELSR{}, false
+	}
+	return form, true
+}
+
+func decodeARM64RawSVELSR(word uint32) (arm64RawSVELSR, bool) {
+	form, ok := decodeARM64RawSVEShift(word)
+	return form, ok && form.op == "ZLSR"
+}
+
+func (c *arm64Ctx) lowerARM64SVELSR(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEShiftSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+
+	form := arm64RawSVELSR{op: op}
+	if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm {
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		shift := ins.Args[0].Imm
+		minimum := int64(0)
+		if spec.right {
+			minimum = 1
+		}
+		if ins.Args[0].ImmRaw != "" || !sourceOK || !destinationOK || sourceBits != destinationBits || shift < minimum || shift >= int64(sourceBits) {
+			return true, false, fmt.Errorf("arm64 %s immediate is outside Go 1.27's element-width range: %q", op, ins.Raw)
+		}
+		form = arm64RawSVELSR{op: op, mode: arm64SVELSRImmediateUnpredicated, elementBits: sourceBits, source: source, shift: int(shift), destination: destination}
+	} else if len(ins.Args) == 4 && ins.Args[0].Kind == OpImm {
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		shift := ins.Args[0].Imm
+		minimum := int64(0)
+		if spec.right {
+			minimum = 1
+		}
+		if ins.Args[0].ImmRaw != "" || !sourceOK || !predicateOK || !destinationOK || source != destination || sourceBits != destinationBits || shift < minimum || shift >= int64(sourceBits) {
+			return true, false, fmt.Errorf("arm64 %s predicated immediate is outside Go 1.27's destructive element-width form: %q", op, ins.Raw)
+		}
+		form = arm64RawSVELSR{op: op, mode: arm64SVELSRImmediatePredicated, elementBits: sourceBits, source: source, predicate: predicate, shift: int(shift), destination: destination}
+	} else if len(ins.Args) == 3 {
+		shifts, shiftBits, shiftsOK := arm64ParseSVEZElementReg(ins.Args[0])
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !shiftsOK || !sourceOK || !destinationOK || shiftBits != 64 || sourceBits == 64 || sourceBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s unpredicated wide form expects Zm.D, Zn.B|H|S, Zd.B|H|S: %q", op, ins.Raw)
+		}
+		form = arm64RawSVELSR{op: op, mode: arm64SVELSRWideUnpredicated, elementBits: sourceBits, shifts: shifts, source: source, destination: destination}
+	} else if len(ins.Args) == 4 {
+		shifts, shiftBits, shiftsOK := arm64ParseSVEZElementReg(ins.Args[0])
+		source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !shiftsOK || !sourceOK || !predicateOK || !destinationOK || source != destination || sourceBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s predicated form requires identical destructive source and destination: %q", op, ins.Raw)
+		}
+		mode := arm64SVELSRVectorPredicated
+		if shiftBits == 64 && sourceBits != 64 {
+			mode = arm64SVELSRWidePredicated
+		} else if shiftBits != sourceBits {
+			return true, false, fmt.Errorf("arm64 %s shift register width is incompatible with data elements: %q", op, ins.Raw)
+		}
+		form = arm64RawSVELSR{op: op, mode: mode, elementBits: sourceBits, shifts: shifts, source: source, predicate: predicate, destination: destination}
+	} else {
+		return true, false, fmt.Errorf("arm64 %s expects one of its five Go 1.27 SVE forms: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerRawSVELSR(form)
+}
+
+func (c *arm64Ctx) lowerRawSVELSR(form arm64RawSVELSR) error {
+	spec, ok := arm64SVEShiftSpecs[form.op]
+	if !ok {
+		return fmt.Errorf("unsupported ARM64 SVE shift operation %s", form.op)
+	}
+	source, vectorType, err := c.loadZRegElements(form.source, form.elementBits)
+	if err != nil {
+		return err
+	}
+	var predicate, predicateType string
+	if form.mode == arm64SVELSRWidePredicated || form.mode == arm64SVELSRVectorPredicated || form.mode == arm64SVELSRImmediatePredicated {
+		predicate, predicateType, err = c.loadPRegElements(form.predicate, form.elementBits)
+	} else {
+		predicate, predicateType, err = c.allTruePRegElements(form.elementBits)
+	}
+	if err != nil {
+		return err
+	}
+
+	intrinsic := "llvm.aarch64.sve." + spec.intrinsic
+	shiftType := vectorType
+	shiftValue := fmt.Sprintf("splat (i%d %d)", form.elementBits, form.shift)
+	if form.mode == arm64SVELSRWidePredicated || form.mode == arm64SVELSRWideUnpredicated {
+		intrinsic += ".wide"
+		shiftType = "<vscale x 2 x i64>"
+		shiftValue, _, err = c.loadZRegElements(form.shifts, 64)
+	} else if form.mode == arm64SVELSRVectorPredicated {
+		shiftValue, _, err = c.loadZRegElements(form.shifts, form.elementBits)
+	}
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @%s.nxv%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, source, shiftType, shiftValue)
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_lsr_test.go b/arm64_lower_sve_lsr_test.go
new file mode 100644
index 000000000..ceada9022
--- /dev/null
+++ b/arm64_lower_sve_lsr_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64SVEShiftImmediateBits(elementBits, shift, lowBit int) uint32 {
+	encoded := 2*elementBits - shift
+	if lowBit == 5 {
+		return uint32(encoded&7)<<5 | uint32((encoded>>3)&3)<<8 | uint32((encoded>>5)&3)<<22
+	}
+	return uint32(encoded&7)<<16 | uint32((encoded>>3)&3)<<19 | uint32((encoded>>5)&3)<<22
+}
+
+func encodeARM64RawSVELSRWidePredicated(elementBits, shifts, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2}[elementBits]
+	return 0x04198000 | size<<22 | uint32(shifts)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVELSRWideUnpredicated(elementBits, shifts, source, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2}[elementBits]
+	return 0x04208400 | size<<22 | uint32(shifts)<<16 | uint32(source)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVELSRVectorPredicated(elementBits, shifts, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04118000 | size<<22 | uint32(shifts)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVELSRImmediatePredicated(elementBits, shift, predicate, destination int) uint32 {
+	return 0x04018000 | encodeARM64SVEShiftImmediateBits(elementBits, shift, 5) | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVELSRImmediateUnpredicated(elementBits, shift, source, destination int) uint32 {
+	return 0x04209400 | encodeARM64SVEShiftImmediateBits(elementBits, shift, 16) | uint32(source)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVELSRCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT svelsrnamed(SB),$0-0
+	ZLSR Z1.D, Z2.B, P0.M, Z2.B
+	ZLSR Z3.D, Z4.H, P1.M, Z4.H
+	ZLSR Z5.D, Z6.S, P2.M, Z6.S
+	ZLSR Z7.D, Z8.B, Z9.B
+	ZLSR Z10.D, Z11.H, Z12.H
+	ZLSR Z13.D, Z14.S, Z15.S
+	ZLSR Z16.B, Z17.B, P3.M, Z17.B
+	ZLSR Z18.H, Z19.H, P4.M, Z19.H
+	ZLSR Z20.S, Z21.S, P5.M, Z21.S
+	ZLSR Z22.D, Z23.D, P6.M, Z23.D
+	ZLSR $7, Z24.B, P7.M, Z24.B
+	ZLSR $15, Z25.H, P0.M, Z25.H
+	ZLSR $31, Z26.S, P1.M, Z26.S
+	ZLSR $63, Z27.D, P2.M, Z27.D
+	ZLSR $1, Z28.B, Z29.B
+	ZLSR $15, Z28.H, Z29.H
+	ZLSR $31, Z28.S, Z29.S
+	ZLSR $63, Z28.D, Z29.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svelsrraw(SB),$0-0\n")
+	for _, elementBits := range []int{8, 16, 32} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVELSRWidePredicated(elementBits, 1, 2, 3))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVELSRWideUnpredicated(elementBits, 4, 5, 6))
+	}
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVELSRVectorPredicated(elementBits, 7, 3, 8))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVELSRImmediatePredicated(elementBits, elementBits, 4, 9))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVELSRImmediateUnpredicated(elementBits, elementBits/2, 10, 11))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svelsr" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve"`, "@llvm.aarch64.sve.lsr.nxv", "@llvm.aarch64.sve.lsr.wide.nxv", "@llvm.aarch64.sve.ptrue"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE LSR lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-lsr.ll", "arm64-sve-lsr.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVELSRDecoderCoversEveryGo127EncodingField(t *testing.T) {
+	for _, elementBits := range []int{8, 16, 32} {
+		for shifts := 0; shifts < 32; shifts++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVELSRWidePredicated(elementBits, shifts, predicate, destination)
+					got, ok := decodeARM64RawSVELSR(word)
+					if !ok || got.mode != arm64SVELSRWidePredicated || got.elementBits != elementBits || got.shifts != shifts || got.predicate != predicate || got.source != destination || got.destination != destination {
+						t.Fatalf("decoded wide predicated SVE LSR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for shifts := 0; shifts < 32; shifts++ {
+			for source := 0; source < 32; source++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVELSRWideUnpredicated(elementBits, shifts, source, destination)
+					got, ok := decodeARM64RawSVELSR(word)
+					if !ok || got.mode != arm64SVELSRWideUnpredicated || got.elementBits != elementBits || got.shifts != shifts || got.source != source || got.destination != destination {
+						t.Fatalf("decoded wide unpredicated SVE LSR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for shifts := 0; shifts < 32; shifts++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVELSRVectorPredicated(elementBits, shifts, predicate, destination)
+					got, ok := decodeARM64RawSVELSR(word)
+					if !ok || got.mode != arm64SVELSRVectorPredicated || got.elementBits != elementBits || got.shifts != shifts || got.predicate != predicate || got.source != destination || got.destination != destination {
+						t.Fatalf("decoded vector predicated SVE LSR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for shift := 1; shift <= elementBits; shift++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVELSRImmediatePredicated(elementBits, shift, predicate, destination)
+					got, ok := decodeARM64RawSVELSR(word)
+					if !ok || got.mode != arm64SVELSRImmediatePredicated || got.elementBits != elementBits || got.shift != shift || got.predicate != predicate || got.source != destination || got.destination != destination {
+						t.Fatalf("decoded immediate predicated SVE LSR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for shift := 1; shift <= elementBits; shift++ {
+			for source := 0; source < 32; source++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVELSRImmediateUnpredicated(elementBits, shift, source, destination)
+					got, ok := decodeARM64RawSVELSR(word)
+					if !ok || got.mode != arm64SVELSRImmediateUnpredicated || got.elementBits != elementBits || got.shift != shift || got.source != source || got.destination != destination {
+						t.Fatalf("decoded immediate unpredicated SVE LSR %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVELSRRejectsReservedAdjacentAndMismatchedDestructiveForms(t *testing.T) {
+	for _, word := range []uint32{0x04d98400, 0x04208000, 0x04108000, 0x04008000, 0x04209000} {
+		if _, ok := decodeARM64RawSVELSR(word); ok {
+			t.Fatalf("SVE LSR decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsvelsr(SB),$0-0
+	ZLSR $7, Z1.S, P0.M, Z2.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvelsr": {Name: "badsvelsr", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted mismatched destructive SVE LSR operands")
+	}
+
+	// The Arm encoding permits shifting by the complete element width, and the
+	// raw decoder above covers it. Go 1.27's encodeShiftTriple currently rejects
+	// that named boundary with v >= elemBits, so the named translator must match
+	// the Go oracle instead of claiming a source form Go cannot assemble.
+	const goRejectedBoundary = `
+TEXT badsvelsrboundary(SB),$0-0
+	ZLSR $32, Z1.S, Z2.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, goRejectedBoundary, false)
+	file, err = Parse(ArchARM64, goRejectedBoundary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvelsrboundary": {Name: "badsvelsrboundary", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted named SVE LSR element-width boundary rejected by Go 1.27")
+	}
+}
diff --git a/arm64_lower_sve_luti.go b/arm64_lower_sve_luti.go
new file mode 100644
index 000000000..971183b5b
--- /dev/null
+++ b/arm64_lower_sve_luti.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64SVELUTIForm struct {
+	op                       Op
+	index, lane, destination int
+	tables                   []int
+	elementBits              int
+}
+
+func arm64ParseSVERawIndexedReg(operand Operand) (register, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	open := strings.IndexByte(name, '[')
+	if !strings.HasPrefix(name, "Z") || open <= 1 || !strings.HasSuffix(name, "]") || strings.Contains(name[:open], ".") {
+		return 0, 0, false
+	}
+	register, registerErr := strconv.Atoi(name[1:open])
+	lane, laneErr := strconv.Atoi(name[open+1 : len(name)-1])
+	return register, lane, registerErr == nil && laneErr == nil && register >= 0 && register <= 31 && lane >= 0
+}
+
+func (c *arm64Ctx) lowerARM64SVELUTI(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZLUTI2" && op != "ZLUTI4" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[1].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s expects Zm[index], [Zn.B|H] or [Zn1.H, Zn2.H], Zd.B|H without a suffix: %q", op, ins.Raw)
+	}
+	index, lane, indexOK := arm64ParseSVERawIndexedReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !indexOK || !destinationOK || destinationBits != 8 && destinationBits != 16 {
+		return true, false, fmt.Errorf("arm64 %s requires a raw indexed Z register and a B/H destination: %q", op, ins.Raw)
+	}
+	tableOperands := ins.Args[1].RegList
+	if len(tableOperands) != 1 && len(tableOperands) != 2 {
+		return true, false, fmt.Errorf("arm64 %s requires exactly one table, or two H tables for ZLUTI4: %q", op, ins.Raw)
+	}
+	tables := make([]int, len(tableOperands))
+	for tableIndex, tableOperand := range tableOperands {
+		table, tableBits, tableOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: tableOperand})
+		if !tableOK || tableBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s table and destination widths must match: %q", op, ins.Raw)
+		}
+		tables[tableIndex] = table
+	}
+	if len(tables) == 2 && tables[1] != (tables[0]+1)%32 {
+		return true, false, fmt.Errorf("arm64 ZLUTI4 table pair must be consecutive, including Z31-to-Z0 wrapping, as required by Go 1.27: %q", ins.Raw)
+	}
+	maxLane := -1
+	switch {
+	case op == "ZLUTI2" && len(tables) == 1 && destinationBits == 8:
+		maxLane = 3
+	case op == "ZLUTI2" && len(tables) == 1 && destinationBits == 16:
+		maxLane = 7
+	case op == "ZLUTI4" && len(tables) == 1 && destinationBits == 8:
+		maxLane = 1
+	case op == "ZLUTI4" && len(tables) == 1 && destinationBits == 16:
+		maxLane = 3
+	case op == "ZLUTI4" && len(tables) == 2 && destinationBits == 16:
+		maxLane = 3
+	}
+	if maxLane < 0 || lane > maxLane {
+		return true, false, fmt.Errorf("arm64 %s table count, width, or lane is outside the complete Go 1.27 forms: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVELUTIForm(arm64SVELUTIForm{
+		op: op, index: index, lane: lane, tables: tables, destination: destination, elementBits: destinationBits,
+	})
+}
+
+func (c *arm64Ctx) lowerARM64SVELUTIForm(form arm64SVELUTIForm) error {
+	index, indexType, err := c.loadZRegElements(form.index, 8)
+	if err != nil {
+		return err
+	}
+	tableValues := make([]string, len(form.tables))
+	vectorType := ""
+	for tableIndex, table := range form.tables {
+		tableValue, tableType, err := c.loadZRegElements(table, form.elementBits)
+		if err != nil {
+			return err
+		}
+		tableValues[tableIndex], vectorType = tableValue, tableType
+	}
+	lanes := 128 / form.elementBits
+	intrinsic := strings.ToLower(strings.TrimPrefix(string(form.op), "Z")) + ".lane"
+	result := c.newTmp()
+	if len(tableValues) == 1 {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, intrinsic, lanes, form.elementBits, vectorType, tableValues[0], indexType, index, form.lane)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x2.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n", result, vectorType, intrinsic, lanes, form.elementBits, vectorType, tableValues[0], vectorType, tableValues[1], indexType, index, form.lane)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_luti_test.go b/arm64_lower_sve_luti_test.go
new file mode 100644
index 000000000..e3d43acbc
--- /dev/null
+++ b/arm64_lower_sve_luti_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVELUTICompleteGo127Family(t *testing.T) {
+	const source = `TEXT sveluti(SB),$0-0
+	ZLUTI2 Z31[0], [Z0.B], Z1.B
+	ZLUTI2 Z6[3], [Z23.B], Z13.B
+	ZLUTI2 Z0[7], [Z31.H], Z30.H
+	ZLUTI4 Z31[1], [Z2.B], Z10.B
+	ZLUTI4 Z6[3], [Z23.H], Z13.H
+	ZLUTI4 Z30[3], [Z31.H, Z0.H], Z13.H
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveluti": {Name: "sveluti", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+lut,+sve,+sve2"`,
+				"@llvm.aarch64.sve.luti2.lane.nxv16i8",
+				"@llvm.aarch64.sve.luti2.lane.nxv8i16",
+				"@llvm.aarch64.sve.luti4.lane.nxv16i8",
+				"@llvm.aarch64.sve.luti4.lane.nxv8i16",
+				"@llvm.aarch64.sve.luti4.lane.x2.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s ZLUTI lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-luti.ll", "arm64-sve-luti.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVELUTIRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLUTI2 Z1[4], [Z2.B], Z3.B",
+		"ZLUTI2 Z1[8], [Z2.H], Z3.H",
+		"ZLUTI2 Z1[1], [Z2.S], Z3.S",
+		"ZLUTI2 Z1[1], [Z2.B], Z3.H",
+		"ZLUTI4 Z1[2], [Z2.B], Z3.B",
+		"ZLUTI4 Z1[4], [Z2.H], Z3.H",
+		"ZLUTI4 Z1[4], [Z2.H, Z3.H], Z4.H",
+		"ZLUTI4 Z1[1], [Z2.B, Z3.B], Z4.B",
+		"ZLUTI4 Z1[1], [Z2.H, Z4.H], Z5.H",
+		"ZLUTI4 Z1[1], [Z2.H, Z3.H, Z4.H], Z5.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveluti(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveluti": {Name: "badsveluti", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ZLUTI2/ZLUTI4 forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_mad_msb_test.go b/arm64_lower_sve_mad_msb_test.go
new file mode 100644
index 000000000..8ccc5c80e
--- /dev/null
+++ b/arm64_lower_sve_mad_msb_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMADMSBCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemadmsbforms(SB),$0-0\n")
+	for _, op := range []string{"ZMAD", "ZMSB"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z3.%s\n", op, width, width, index, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemadmsbforms": {Name: "svemadmsbforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.mad.nxv16i8",
+				"@llvm.aarch64.sve.mad.nxv2i64",
+				"@llvm.aarch64.sve.msb.nxv16i8",
+				"@llvm.aarch64.sve.msb.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE MAD/MSB lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-mad-msb.ll", "arm64-sve-mad-msb.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMADMSBRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZMAD Z1.B, Z2.H, P0.M, Z3.H",
+		"ZMSB Z1.S, Z2.S, P0, Z3.S",
+		"ZMAD Z1.D, Z2.D, P8.M, Z3.D",
+		"ZMSB Z1.S, Z2.S, P0.Z, Z3.S",
+		"ZMAD Z1.S, Z2.S, P0.M",
+		"ZMSB.Z Z1.S, Z2.S, P0.M, Z3.S",
+		"ZMAD Z7.H[0], Z2.H, Z3.H",
+		"ZMSB Z15.D[1], Z2.D, Z3.D",
+		"ZMAD Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemadmsb(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemadmsb": {Name: "badsvemadmsb", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE MAD/MSB forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_matrix_multiply.go b/arm64_lower_sve_matrix_multiply.go
new file mode 100644
index 000000000..99a068487
--- /dev/null
+++ b/arm64_lower_sve_matrix_multiply.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEIntegerMatrixMultiplyIntrinsics = map[Op]string{
+	"ZSMMLA":  "smmla",
+	"ZUMMLA":  "ummla",
+	"ZUSMMLA": "usmmla",
+}
+
+func (c *arm64Ctx) lowerARM64SVEMatrixMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, integer := arm64SVEIntegerMatrixMultiplyIntrinsics[op]; !integer && op != "ZBFMMLA" && op != "ZFMMLA" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects its complete Go 1.27 three-vector form without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || !arm64SVEMatrixMultiplyWidthOK(op, firstBits, destinationBits) {
+		return true, false, fmt.Errorf("arm64 %s has invalid or mismatched Go 1.27 matrix element widths: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEMatrixMultiplyForm(op, firstBits, destinationBits, first, second, destination)
+}
+
+func arm64SVEMatrixMultiplyWidthOK(op Op, sourceBits, destinationBits int) bool {
+	switch op {
+	case "ZSMMLA", "ZUMMLA", "ZUSMMLA":
+		return sourceBits == 8 && destinationBits == 32
+	case "ZBFMMLA":
+		return sourceBits == 16 && (destinationBits == 16 || destinationBits == 32)
+	case "ZFMMLA":
+		return (sourceBits == 8 && (destinationBits == 16 || destinationBits == 32)) ||
+			(sourceBits == 16 && (destinationBits == 16 || destinationBits == 32)) ||
+			(sourceBits == 32 && destinationBits == 32) ||
+			(sourceBits == 64 && destinationBits == 64)
+	default:
+		return false
+	}
+}
+
+func (c *arm64Ctx) lowerARM64SVEMatrixMultiplyForm(op Op, sourceBits, destinationBits, firstReg, secondReg, destinationReg int) error {
+	if intrinsic, integer := arm64SVEIntegerMatrixMultiplyIntrinsics[op]; integer {
+		accumulator, destinationType, err := c.loadZRegElements(destinationReg, 32)
+		if err != nil {
+			return err
+		}
+		first, sourceType, err := c.loadZRegElements(firstReg, 8)
+		if err != nil {
+			return err
+		}
+		second, _, err := c.loadZRegElements(secondReg, 8)
+		if err != nil {
+			return err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv4i32(%s %s, %s %s, %s %s)\n", result, destinationType, intrinsic, destinationType, accumulator, sourceType, first, sourceType, second)
+		return c.storeZRegElements(destinationReg, 32, "%"+result)
+	}
+
+	destinationScalar := map[int]string{16: "half", 32: "float", 64: "double"}[destinationBits]
+	sourceScalar := map[int]string{16: "half", 32: "float", 64: "double"}[sourceBits]
+	if op == "ZBFMMLA" {
+		sourceScalar = "bfloat"
+		if destinationBits == 16 {
+			destinationScalar = "bfloat"
+		}
+	}
+	accumulator, destinationType, err := c.loadARM64SVEMatrixFloatVector(destinationReg, destinationBits, destinationScalar)
+	if err != nil {
+		return err
+	}
+	first, sourceType, err := c.loadARM64SVEMatrixFloatVector(firstReg, sourceBits, sourceScalar)
+	if err != nil {
+		return err
+	}
+	second, _, err := c.loadARM64SVEMatrixFloatVector(secondReg, sourceBits, sourceScalar)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if op == "ZBFMMLA" && destinationBits == 16 {
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, %s %s)\n", result, destinationType, "bfmmla $0.h, $2.h, $3.h", "=&w,0,w,w", destinationType, accumulator, sourceType, first, sourceType, second)
+		return c.storeARM64SVEMatrixFloatVector(destinationReg, destinationBits, destinationType, "%"+result)
+	}
+	if op == "ZFMMLA" && (sourceBits == 8 || sourceBits == 16 && destinationBits == 16) {
+		sourceSuffix := map[int]string{8: "b", 16: "h"}[sourceBits]
+		destinationSuffix := map[int]string{16: "h", 32: "s"}[destinationBits]
+		assembly := fmt.Sprintf("fmmla $0.%s, $2.%s, $3.%s", destinationSuffix, sourceSuffix, sourceSuffix)
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, %s %s)\n", result, destinationType, assembly, "=&w,0,w,w", destinationType, accumulator, sourceType, first, sourceType, second)
+		return c.storeARM64SVEMatrixFloatVector(destinationReg, destinationBits, destinationType, "%"+result)
+	}
+	intrinsic := arm64SVEMatrixFloatIntrinsic(op, sourceBits, destinationBits)
+	fmt.Fprintf(c.b, "  %%%s = call %s @%s(%s %s, %s %s, %s %s)\n", result, destinationType, intrinsic, destinationType, accumulator, sourceType, first, sourceType, second)
+	return c.storeARM64SVEMatrixFloatVector(destinationReg, destinationBits, destinationType, "%"+result)
+}
+
+func arm64SVEMatrixFloatIntrinsic(op Op, sourceBits, destinationBits int) string {
+	if op == "ZBFMMLA" {
+		return "llvm.aarch64.sve.bfmmla"
+	}
+	suffix := map[int]string{16: "f16", 32: "f32", 64: "f64"}[destinationBits]
+	lanes := 128 / destinationBits
+	name := fmt.Sprintf("llvm.aarch64.sve.fmmla.nxv%d%s", lanes, suffix)
+	if sourceBits != destinationBits {
+		name += ".nxv8f16"
+	}
+	return name
+}
+
+func (c *arm64Ctx) loadARM64SVEMatrixFloatVector(reg, bits int, scalar string) (value, vectorType string, err error) {
+	integer, integerType, err := c.loadZRegElements(reg, bits)
+	if err != nil {
+		return "", "", err
+	}
+	lanes := 128 / bits
+	if bits == 8 {
+		return integer, integerType, nil
+	}
+	vectorType = fmt.Sprintf("<vscale x %d x %s>", lanes, scalar)
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", converted, integerType, integer, vectorType)
+	return "%" + converted, vectorType, nil
+}
+
+func (c *arm64Ctx) storeARM64SVEMatrixFloatVector(reg, bits int, vectorType, value string) error {
+	integerType, _, err := arm64SVEVectorType(bits)
+	if err != nil {
+		return err
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", converted, vectorType, value, integerType)
+	return c.storeZRegElements(reg, bits, "%"+converted)
+}
+
+func arm64SVEMatrixMultiplyFeatures(op Op, ins Instr) []string {
+	if len(ins.Args) != 3 {
+		return nil
+	}
+	_, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	_, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !destinationOK || !arm64SVEMatrixMultiplyWidthOK(op, sourceBits, destinationBits) {
+		return nil
+	}
+	switch op {
+	case "ZSMMLA", "ZUMMLA", "ZUSMMLA":
+		return []string{"+sve", "+i8mm"}
+	case "ZBFMMLA":
+		if destinationBits == 16 {
+			return []string{"+sve", "+sve-b16mm"}
+		}
+		return []string{"+sve", "+bf16"}
+	case "ZFMMLA":
+		switch {
+		case sourceBits == 8 && destinationBits == 16:
+			return []string{"+sve", "+sve2", "+fp8", "+f8f16mm"}
+		case sourceBits == 8 && destinationBits == 32:
+			return []string{"+sve", "+sve2", "+fp8", "+f8f32mm"}
+		case sourceBits == 16 && destinationBits == 16:
+			return []string{"+sve", "+sve2p2", "+f16mm"}
+		case sourceBits == 16 && destinationBits == 32:
+			return []string{"+sve", "+sve-f16f32mm"}
+		case sourceBits == 32:
+			return []string{"+sve", "+f32mm"}
+		case sourceBits == 64:
+			return []string{"+sve", "+f64mm"}
+		}
+	}
+	return nil
+}
diff --git a/arm64_lower_sve_matrix_multiply_test.go b/arm64_lower_sve_matrix_multiply_test.go
new file mode 100644
index 000000000..ce2aec832
--- /dev/null
+++ b/arm64_lower_sve_matrix_multiply_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMatrixMultiplyCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT svematrixint(SB),$0-0
+	ZSMMLA Z1.B, Z2.B, Z3.S
+	ZUMMLA Z4.B, Z5.B, Z6.S
+	ZUSMMLA Z7.B, Z8.B, Z9.S
+	RET
+TEXT svematrixbfloat(SB),$0-0
+	ZBFMMLA Z10.H, Z11.H, Z12.H
+	ZBFMMLA Z13.H, Z14.H, Z15.S
+	RET
+TEXT svematrixfloat(SB),$0-0
+	ZFMMLA Z16.B, Z17.B, Z18.H
+	ZFMMLA Z19.B, Z20.B, Z21.S
+	ZFMMLA Z22.H, Z23.H, Z24.H
+	ZFMMLA Z25.H, Z26.H, Z27.S
+	ZFMMLA Z28.S, Z29.S, Z30.S
+	ZFMMLA Z31.D, Z0.D, Z1.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"svematrixint":    {Name: "svematrixint", Ret: Void},
+		"svematrixbfloat": {Name: "svematrixbfloat", Ret: Void},
+		"svematrixfloat":  {Name: "svematrixfloat", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+i8mm,+sve"`,
+				`"target-features"="+bf16,+sve,+sve-b16mm"`,
+				`"target-features"="+f16mm,+f32mm,+f64mm,+f8f16mm,+f8f32mm,+fp8,+sve,+sve-f16f32mm,+sve2,+sve2p2"`,
+				"@llvm.aarch64.sve.smmla.",
+				"@llvm.aarch64.sve.bfmmla",
+				`asm sideeffect "bfmmla $0.h, $2.h, $3.h"`,
+				`asm sideeffect "fmmla $0.h, $2.b, $3.b"`,
+				`asm sideeffect "fmmla $0.s, $2.b, $3.b"`,
+				`asm sideeffect "fmmla $0.h, $2.h, $3.h"`,
+				"@llvm.aarch64.sve.fmmla.nxv4f32.nxv8f16",
+				"@llvm.aarch64.sve.fmmla.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE matrix-multiply lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-matrix-multiply.ll", "arm64-sve-matrix-multiply.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMatrixMultiplyRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSMMLA Z1.H, Z2.H, Z3.S",
+		"ZUMMLA Z1.B, Z2.B, Z3.H",
+		"ZUSMMLA Z1.B, Z2.S, Z3.S",
+		"ZBFMMLA Z1.S, Z2.S, Z3.S",
+		"ZBFMMLA Z1.H, Z2.H, Z3.D",
+		"ZFMMLA Z1.B, Z2.B, Z3.D",
+		"ZFMMLA Z1.S, Z2.S, Z3.D",
+		"ZFMMLA.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvematrixmultiply(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvematrixmultiply": {Name: "badsvematrixmultiply", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE matrix-multiply forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_minmax.go b/arm64_lower_sve_minmax.go
new file mode 100644
index 000000000..cfc1ff8bc
--- /dev/null
+++ b/arm64_lower_sve_minmax.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEMinMaxKind uint8
+
+const (
+	arm64SVEMinMaxDirect arm64SVEMinMaxKind = iota
+	arm64SVEMinMaxPairwise
+	arm64SVEMinMaxReduce
+	arm64SVEMinMaxQuadReduce
+)
+
+type arm64SVEMinMaxSpec struct {
+	intrinsic   string
+	kind        arm64SVEMinMaxKind
+	elementBits int
+	unsignedImm bool
+}
+
+var arm64SVEMinMaxSpecs = map[Op]arm64SVEMinMaxSpec{
+	"ZSMAX":   {intrinsic: "smax", kind: arm64SVEMinMaxDirect},
+	"ZSMAXP":  {intrinsic: "smaxp", kind: arm64SVEMinMaxPairwise},
+	"ZSMAXQV": {intrinsic: "smaxqv", kind: arm64SVEMinMaxQuadReduce},
+	"ZSMAXVB": {intrinsic: "smaxv", kind: arm64SVEMinMaxReduce, elementBits: 8},
+	"ZSMAXVH": {intrinsic: "smaxv", kind: arm64SVEMinMaxReduce, elementBits: 16},
+	"ZSMAXVS": {intrinsic: "smaxv", kind: arm64SVEMinMaxReduce, elementBits: 32},
+	"ZSMAXVD": {intrinsic: "smaxv", kind: arm64SVEMinMaxReduce, elementBits: 64},
+	"ZSMIN":   {intrinsic: "smin", kind: arm64SVEMinMaxDirect},
+	"ZSMINP":  {intrinsic: "sminp", kind: arm64SVEMinMaxPairwise},
+	"ZSMINQV": {intrinsic: "sminqv", kind: arm64SVEMinMaxQuadReduce},
+	"ZSMINVB": {intrinsic: "sminv", kind: arm64SVEMinMaxReduce, elementBits: 8},
+	"ZSMINVH": {intrinsic: "sminv", kind: arm64SVEMinMaxReduce, elementBits: 16},
+	"ZSMINVS": {intrinsic: "sminv", kind: arm64SVEMinMaxReduce, elementBits: 32},
+	"ZSMINVD": {intrinsic: "sminv", kind: arm64SVEMinMaxReduce, elementBits: 64},
+	"ZUMAX":   {intrinsic: "umax", kind: arm64SVEMinMaxDirect, unsignedImm: true},
+	"ZUMAXP":  {intrinsic: "umaxp", kind: arm64SVEMinMaxPairwise},
+	"ZUMAXQV": {intrinsic: "umaxqv", kind: arm64SVEMinMaxQuadReduce},
+	"ZUMAXVB": {intrinsic: "umaxv", kind: arm64SVEMinMaxReduce, elementBits: 8},
+	"ZUMAXVH": {intrinsic: "umaxv", kind: arm64SVEMinMaxReduce, elementBits: 16},
+	"ZUMAXVS": {intrinsic: "umaxv", kind: arm64SVEMinMaxReduce, elementBits: 32},
+	"ZUMAXVD": {intrinsic: "umaxv", kind: arm64SVEMinMaxReduce, elementBits: 64},
+	"ZUMIN":   {intrinsic: "umin", kind: arm64SVEMinMaxDirect, unsignedImm: true},
+	"ZUMINP":  {intrinsic: "uminp", kind: arm64SVEMinMaxPairwise},
+	"ZUMINQV": {intrinsic: "uminqv", kind: arm64SVEMinMaxQuadReduce},
+	"ZUMINVB": {intrinsic: "uminv", kind: arm64SVEMinMaxReduce, elementBits: 8},
+	"ZUMINVH": {intrinsic: "uminv", kind: arm64SVEMinMaxReduce, elementBits: 16},
+	"ZUMINVS": {intrinsic: "uminv", kind: arm64SVEMinMaxReduce, elementBits: 32},
+	"ZUMINVD": {intrinsic: "uminv", kind: arm64SVEMinMaxReduce, elementBits: 64},
+}
+
+type arm64SVEMinMaxForm struct {
+	elementBits  int
+	first        int
+	second       int
+	predicate    int
+	destination  int
+	immediate    int64
+	hasImmediate bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEMinMax(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEMinMaxSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+
+	switch spec.kind {
+	case arm64SVEMinMaxDirect, arm64SVEMinMaxPairwise:
+		form, err := arm64ParseSVEMinMaxDirectForm(op, spec, ins)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SVEMinMaxDirectForm(spec, form)
+	case arm64SVEMinMaxReduce, arm64SVEMinMaxQuadReduce:
+		form, err := arm64ParseSVEMinMaxReductionForm(op, spec, ins)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.lowerARM64SVEMinMaxReductionForm(spec, form, ins.Args[2].Reg)
+	default:
+		return true, false, fmt.Errorf("arm64 %s has an unknown SVE min/max form", op)
+	}
+}
+
+func arm64ParseSVEMinMaxDirectForm(op Op, spec arm64SVEMinMaxSpec, ins Instr) (arm64SVEMinMaxForm, error) {
+	form := arm64SVEMinMaxForm{}
+	if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm {
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		immediate := ins.Args[0].Imm
+		validImmediate := spec.kind == arm64SVEMinMaxDirect && ins.Args[0].ImmRaw == "" && !ins.Args[0].ImmIsFloat
+		if spec.unsignedImm {
+			validImmediate = validImmediate && immediate >= 0 && immediate <= 255
+		} else {
+			validImmediate = validImmediate && immediate >= -128 && immediate <= 127
+		}
+		if !validImmediate || !firstOK || !destinationOK || first != destination || firstBits != destinationBits {
+			return form, fmt.Errorf("arm64 %s does not accept this destructive immediate form: %q", op, ins.Raw)
+		}
+		form = arm64SVEMinMaxForm{elementBits: firstBits, first: first, destination: destination, immediate: immediate, hasImmediate: true}
+		return form, nil
+	}
+	if len(ins.Args) != 4 {
+		return form, fmt.Errorf("arm64 %s expects its Go 1.27 predicated%s form: %q", op, map[bool]string{true: " pairwise", false: ""}[spec.kind == arm64SVEMinMaxPairwise], ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+		return form, fmt.Errorf("arm64 %s requires matching-width destructive registers and P0..P7/M: %q", op, ins.Raw)
+	}
+	form = arm64SVEMinMaxForm{elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}
+	return form, nil
+}
+
+func arm64ParseSVEMinMaxReductionForm(op Op, spec arm64SVEMinMaxSpec, ins Instr) (arm64SVEMinMaxForm, error) {
+	form := arm64SVEMinMaxForm{}
+	if len(ins.Args) != 3 {
+		return form, fmt.Errorf("arm64 %s expects Zn.T, Pg, Vd%s: %q", op, map[bool]string{true: ".T", false: ""}[spec.kind == arm64SVEMinMaxQuadReduce], ins.Raw)
+	}
+	first, elementBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0])
+	predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[1])
+	destination, destinationOK := arm64ParseVReg(ins.Args[2].Reg)
+	if !firstOK || !predicateOK || predicate > 7 || !destinationOK || ins.Args[2].Kind != OpReg {
+		return form, fmt.Errorf("arm64 %s requires a scalable source, bare predicate, and SIMD destination: %q", op, ins.Raw)
+	}
+	if spec.kind == arm64SVEMinMaxReduce {
+		if strings.Contains(string(ins.Args[2].Reg), ".") {
+			return form, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+		}
+		// The Go table gives every VB/VH/VS/VD spelling a generic Zn.T
+		// operand. Its encoder ORs the operand size bits into the mnemonic's
+		// fixed size bits, so the effective hardware width is their bitwise
+		// union rather than requiring the two suffixes to match.
+		opcodeSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[spec.elementBits]
+		sourceSize := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+		elementBits = 8 << (opcodeSize | sourceSize)
+	} else {
+		arrangement, arrangementOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+		if !arrangementOK || arrangement.elementBits != elementBits || arrangement.lanes*arrangement.elementBits != 128 {
+			return form, fmt.Errorf("arm64 %s destination must be a full-width SIMD vector matching its source elements: %q", op, ins.Raw)
+		}
+	}
+	form = arm64SVEMinMaxForm{elementBits: elementBits, first: first, predicate: predicate, destination: destination}
+	return form, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEMinMaxDirectForm(spec arm64SVEMinMaxSpec, form arm64SVEMinMaxForm) error {
+	first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	var predicate, predicateType string
+	if form.hasImmediate {
+		predicate, predicateType, err = c.allTruePRegElements(form.elementBits)
+	} else {
+		predicate, predicateType, err = c.loadPRegElements(form.predicate, form.elementBits)
+	}
+	if err != nil {
+		return err
+	}
+	second := fmt.Sprintf("splat (i%d %d)", form.elementBits, form.immediate)
+	if !form.hasImmediate {
+		second, _, err = c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+	}
+	lanes := 128 / form.elementBits
+	calculated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", calculated, vectorType, spec.intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, first, vectorType, second)
+	result := "%" + calculated
+	if !form.hasImmediate {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicate, vectorType, result, vectorType, first)
+		result = "%" + selected
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEMinMaxReductionForm(spec arm64SVEMinMaxSpec, form arm64SVEMinMaxForm, destination Reg) error {
+	source, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / form.elementBits
+	result := c.newTmp()
+	if spec.kind == arm64SVEMinMaxReduce {
+		fmt.Fprintf(c.b, "  %%%s = call i%d @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, form.elementBits, spec.intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, source)
+		fixed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %%%s, i32 0\n", fixed, lanes, form.elementBits, form.elementBits, result)
+		result = fixed
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <%d x i%d> @llvm.aarch64.sve.%s.v%di%d.nxv%di%d(%s %s, %s %s)\n", result, lanes, form.elementBits, spec.intrinsic, lanes, form.elementBits, lanes, form.elementBits, predicateType, predicate, vectorType, source)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, lanes, form.elementBits, result)
+	return c.storeVReg(destination, "%"+bytes)
+}
diff --git a/arm64_lower_sve_minmax_test.go b/arm64_lower_sve_minmax_test.go
new file mode 100644
index 000000000..35d52a0ab
--- /dev/null
+++ b/arm64_lower_sve_minmax_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEMinMaxCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveminmaxforms(SB),$0-0\n")
+	for _, base := range []string{"ZSMAX", "ZSMIN", "ZUMAX", "ZUMIN"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			predicate := string(rune('0' + index))
+			source.WriteString("\t" + base + " Z1." + width + ", Z2." + width + ", P" + predicate + ".M, Z2." + width + "\n")
+			immediate := "-128"
+			if strings.HasPrefix(base, "ZU") {
+				immediate = "255"
+			}
+			source.WriteString("\t" + base + " $" + immediate + ", Z3." + width + ", Z3." + width + "\n")
+			source.WriteString("\t" + base + "P Z4." + width + ", Z5." + width + ", P" + predicate + ".M, Z5." + width + "\n")
+			// Go's generated reduction rows use a generic Zn.T operand for each
+			// VB/VH/VS/VD spelling. All 4x4 spelling/source-width combinations
+			// are therefore accepted; the encoded width is the bitwise union of
+			// the mnemonic's fixed size and the operand size.
+			for _, opcodeWidth := range []string{"B", "H", "S", "D"} {
+				source.WriteString("\t" + base + "V" + opcodeWidth + " Z6." + width + ", P" + predicate + ", V7\n")
+			}
+			arrangement := map[string]string{"B": "B16", "H": "H8", "S": "S4", "D": "D2"}[width]
+			source.WriteString("\t" + base + "QV Z8." + width + ", P" + predicate + ", V9." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEMinMaxCompleteGo127Family(t *testing.T) {
+	source := arm64SVEMinMaxCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveminmaxforms": {Name: "sveminmaxforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2,+sve2p1"`, "@llvm.aarch64.sve.smax.nxv", "@llvm.aarch64.sve.sminp.nxv", "@llvm.aarch64.sve.umaxv.nxv", "@llvm.aarch64.sve.uminqv."} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE min/max lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-minmax.ll", "arm64-sve-minmax.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMinMaxRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSMAX $128, Z1.S, Z1.S",
+		"ZUMAX $-1, Z1.S, Z1.S",
+		"ZSMIN Z1.S, Z2.S, P0.M, Z3.S",
+		"ZUMIN $1, Z1.S, Z2.S",
+		"ZSMAXVB Z1.H, P0.M, V2",
+		"ZSMAXVB Z1.H, P8, V2",
+		"ZSMAXVB Z1.H, P0, V2.H8",
+		"ZUMAXQV Z1.S, P0, V2.H8",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveminmax(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveminmax": {Name: "badsveminmax", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE min/max forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_mixed_saturating_add.go b/arm64_lower_sve_mixed_saturating_add.go
new file mode 100644
index 000000000..4515a222d
--- /dev/null
+++ b/arm64_lower_sve_mixed_saturating_add.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEMixedSaturatingAdd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic := ""
+	switch op {
+	case "ZSUQADD":
+		intrinsic = "suqadd"
+	case "ZUSQADD":
+		intrinsic = "usqadd"
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.B|H|S|D, Zdn.B|H|S|D, P0..P7/M, Zdn.B|H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || destinationBits != firstBits || destination != first {
+		return true, false, fmt.Errorf("arm64 %s requires matching-width destructive B/H/S/D operands and P0..P7/M: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, secondBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n", selected, predicateType, predicateValue, vectorType, result, vectorType, firstValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+selected)
+}
diff --git a/arm64_lower_sve_mixed_saturating_add_test.go b/arm64_lower_sve_mixed_saturating_add_test.go
new file mode 100644
index 000000000..61f3a1e78
--- /dev/null
+++ b/arm64_lower_sve_mixed_saturating_add_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMixedSaturatingAddCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemixedsatadd(SB),$0-0\n")
+	for opIndex, op := range []string{"ZSUQADD", "ZUSQADD"} {
+		for widthIndex, width := range []string{"B", "H", "S", "D"} {
+			destination := opIndex*4 + widthIndex
+			fmt.Fprintf(&source, "\t%s Z%d.%s, Z%d.%s, P%d.M, Z%d.%s\n", op, destination+16, width, destination, width, widthIndex*2, destination, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemixedsatadd": {Name: "svemixedsatadd", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.suqadd.nxv16i8",
+				"@llvm.aarch64.sve.suqadd.nxv2i64",
+				"@llvm.aarch64.sve.usqadd.nxv16i8",
+				"@llvm.aarch64.sve.usqadd.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE mixed saturating add lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-mixed-saturating-add.ll", "arm64-sve-mixed-saturating-add.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMixedSaturatingAddRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSUQADD Z1.B, Z2.H, P0.M, Z2.H",
+		"ZSUQADD Z1.S, Z2.S, P8.M, Z2.S",
+		"ZSUQADD Z1.S, Z2.S, P0.Z, Z2.S",
+		"ZUSQADD Z1.D, Z2.D, P0.M, Z3.D",
+		"ZUSQADD Z1.S, Z2.S, Z3.S",
+		"ZUSQADD.Z Z1.D, Z2.D, P0.M, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemixedsatadd(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemixedsatadd": {Name: "badsvemixedsatadd", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's mixed saturating add forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_movprfx.go b/arm64_lower_sve_movprfx.go
new file mode 100644
index 000000000..ed25123ef
--- /dev/null
+++ b/arm64_lower_sve_movprfx.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// decodeARM64RawSVEMOVPRFX covers Go 1.27's bare-vector and predicated
+// B/H/S/D M/Z MOVPRFX rows with their exact fixed-bit masks.
+func decodeARM64RawSVEMOVPRFX(word uint32) (Instr, bool) {
+	const (
+		bareBits       = uint32(0x000003ff)
+		predicatedBits = uint32(0x00c11fff)
+	)
+	var args []Operand
+	switch {
+	case word&^bareBits == 0x0420bc00:
+		args = []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d", word>>5&31))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d", word&31))},
+		}
+	case word&^predicatedBits == 0x04102000:
+		width := [...]string{"B", "H", "S", "D"}[word>>22&3]
+		mode := "Z"
+		if word&(1<<16) != 0 {
+			mode = "M"
+		}
+		args = []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", word>>5&31, width))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", word>>10&7, mode))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", word&31, width))},
+		}
+	default:
+		return Instr{}, false
+	}
+	return Instr{Op: "ZMOVPRFX", Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEMOVPRFX(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZMOVPRFX" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 ZMOVPRFX does not accept an instruction suffix: %q", ins.Raw)
+	}
+	if len(ins.Args) == 2 {
+		source, sourceOK := arm64ParseSVEBareZReg(ins.Args[0])
+		destination, destinationOK := arm64ParseSVEBareZReg(ins.Args[1])
+		if !sourceOK || !destinationOK {
+			return true, false, fmt.Errorf("arm64 ZMOVPRFX two-operand form requires bare Z registers: %q", ins.Raw)
+		}
+		value, err := c.loadZReg(source)
+		if err != nil {
+			return true, false, err
+		}
+		return true, false, c.storeZReg(destination, value)
+	}
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZMOVPRFX expects Zn, Zd or Zn.T, Pg.M/Z, Zd.T: %q", ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	predicate, merge := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+	if !merge {
+		predicate, _ = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	}
+	_, zero := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	if !sourceOK || !destinationOK || sourceBits != destinationBits || !merge && !zero {
+		return true, false, fmt.Errorf("arm64 ZMOVPRFX predicated form requires matching vectors and P0..P7.M/Z: %q", ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	fallback := "zeroinitializer"
+	if merge {
+		fallback, _, err = c.loadZRegElements(destination, sourceBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n",
+		result, predicateType, predicateValue, vectorType, sourceValue, vectorType, fallback)
+	return true, false, c.storeZRegElements(destination, sourceBits, "%"+result)
+}
diff --git a/arm64_lower_sve_movprfx_test.go b/arm64_lower_sve_movprfx_test.go
new file mode 100644
index 000000000..afa7cdaf2
--- /dev/null
+++ b/arm64_lower_sve_movprfx_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMOVPRFXCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemovprfxforms(SB),$0-0\n\tZMOVPRFX Z0, Z1\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZMOVPRFX Z%d.%s, P%d.M, Z%d.%s\n", index+2, width, index, index+6, width)
+		fmt.Fprintf(&source, "\tZMOVPRFX Z%d.%s, P%d.Z, Z%d.%s\n", index+10, width, index+4, index+14, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemovprfxforms": {Name: "svemovprfxforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"select <vscale x 16 x i1>",
+				"select <vscale x 8 x i1>",
+				"select <vscale x 4 x i1>",
+				"select <vscale x 2 x i1>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE MOVPRFX lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-movprfx.ll", "arm64-sve-movprfx.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEMOVPRFXCompleteFamily(t *testing.T) {
+	// Go 1.27 has one bare-register and B/H/S/D predicated M/Z rows.
+	// gocc emits the bare-register word 0x0420bc61.
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEMOVPRFX(SB),$0-0\n")
+	source.WriteString("\tWORD $0x0420bc61\n")
+	for size := uint32(0); size < 4; size++ {
+		for _, merging := range []bool{false, true} {
+			word := uint32(0x04102000) | size<<22 | 3<<5 | 2<<10 | 1
+			if merging {
+				word |= 1 << 16
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEMOVPRFX": {Name: "rawSVEMOVPRFX", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"select <vscale x 16 x i1>",
+				"select <vscale x 8 x i1>",
+				"select <vscale x 4 x i1>",
+				"select <vscale x 2 x i1>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw MOVPRFX IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-movprfx.ll", "arm64-raw-sve-movprfx.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEMOVPRFXBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word uint32
+		args []Reg
+	}{
+		{0x0420bc61, []Reg{"Z3", "Z1"}},
+		{0x04102861, []Reg{"Z3.B", "P2.Z", "Z1.B"}},
+		{0x04112861, []Reg{"Z3.B", "P2.M", "Z1.B"}},
+	} {
+		ins, ok := decodeARM64RawSVEMOVPRFX(test.word)
+		if !ok || ins.Op != "ZMOVPRFX" || len(ins.Args) != len(test.args) {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		for index, want := range test.args {
+			if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+				t.Errorf("%#08x operand %d = %+v, want %s", test.word, index, ins.Args[index], want)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x0420bc61 ^ (1 << 10), // adjacent bare-vector opcode
+		0x04102861 ^ (1 << 13), // adjacent predicated opcode
+	} {
+		if ins, ok := decodeARM64RawSVEMOVPRFX(word); ok {
+			t.Errorf("decoded reserved MOVPRFX %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEMOVPRFXRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZMOVPRFX Z0.B, P0.M, Z1.H",
+		"ZMOVPRFX Z0.H, P0.Z, Z1.S",
+		"ZMOVPRFX Z0.D, P8.M, Z1.D",
+		"ZMOVPRFX Z0.D, P0, Z1.D",
+		"ZMOVPRFX Z0.B, Z1.B",
+		"ZMOVPRFX Z0, P0.M, Z1",
+		"ZMOVPRFX.Z Z0, Z1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemovprfx(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemovprfx": {Name: "badsvemovprfx", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE MOVPRFX forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_mul_high.go b/arm64_lower_sve_mul_high.go
new file mode 100644
index 000000000..b1d73a4f1
--- /dev/null
+++ b/arm64_lower_sve_mul_high.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEMultiplyHighSpec struct {
+	intrinsic       string
+	predicatedRaw   uint32
+	unpredicatedRaw uint32
+}
+
+var arm64SVEMultiplyHighIntrinsics = map[Op]arm64SVEMultiplyHighSpec{
+	"ZSMULH": {intrinsic: "smulh", predicatedRaw: 0x04120000, unpredicatedRaw: 0x04206800},
+	"ZUMULH": {intrinsic: "umulh", predicatedRaw: 0x04130000, unpredicatedRaw: 0x04206c00},
+}
+
+var arm64SVEMultiplyHighPredicatedRaw, arm64SVEMultiplyHighUnpredicatedRaw = arm64SVEMultiplyHighRawTables()
+
+func arm64SVEMultiplyHighRawTables() (map[uint32]Op, map[uint32]Op) {
+	predicated, unpredicated := make(map[uint32]Op), make(map[uint32]Op)
+	for op, spec := range arm64SVEMultiplyHighIntrinsics {
+		predicated[spec.predicatedRaw], unpredicated[spec.unpredicatedRaw] = op, op
+	}
+	return predicated, unpredicated
+}
+
+func decodeARM64RawSVEMultiplyHigh(word uint32) (Instr, bool) {
+	op, predicated := arm64SVEMultiplyHighPredicatedRaw[word&0xff3fe000]
+	first, second := word>>5&31, word>>16&31
+	if predicated {
+		first, second = word&31, first
+	} else {
+		var ok bool
+		op, ok = arm64SVEMultiplyHighUnpredicatedRaw[word&0xff20fc00]
+		if !ok {
+			return Instr{}, false
+		}
+	}
+	width := "BHSD"[word>>22&3]
+	reg := func(number uint32) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", number, width))}
+	}
+	args := []Operand{reg(second), reg(first)}
+	if predicated {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>10&7))})
+	}
+	args = append(args, reg(word&31))
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func arm64SVEMultiplyHighNeedsSVE2(ins Instr) bool {
+	return len(ins.Args) == 3
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiplyHigh(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEMultiplyHighIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 3 && len(ins.Args) != 4) {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 vector form without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !secondOK || !firstOK || secondBits != firstBits {
+		return true, false, fmt.Errorf("arm64 %s sources must use one B/H/S/D width: %q", op, ins.Raw)
+	}
+	destinationIndex := 2
+	predicate := 0
+	predicated := len(ins.Args) == 4
+	if predicated {
+		var predicateOK bool
+		predicate, predicateOK = arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+		if !predicateOK {
+			return true, false, fmt.Errorf("arm64 %s predicated form requires P0..P7.M: %q", op, ins.Raw)
+		}
+		destinationIndex = 3
+	}
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[destinationIndex])
+	if !destinationOK || destinationBits != firstBits || (predicated && destination != first) {
+		return true, false, fmt.Errorf("arm64 %s destination width and destructive operands do not match: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	intrinsic := spec.intrinsic
+	var predicateValue, predicateType string
+	if predicated {
+		predicateValue, predicateType, err = c.loadPRegElements(predicate, firstBits)
+	} else {
+		predicateValue, predicateType, err = c.allTruePRegElements(firstBits)
+		intrinsic += ".u"
+	}
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, intrinsic, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_mul_high_test.go b/arm64_lower_sve_mul_high_test.go
new file mode 100644
index 000000000..89fd0a0b5
--- /dev/null
+++ b/arm64_lower_sve_mul_high_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMultiplyHighCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemulhighforms(SB),$0-0\n")
+	for _, op := range []string{"ZSMULH", "ZUMULH"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z2.%s\n", op, width, width, index, width)
+			fmt.Fprintf(&source, "\t%s Z3.%s, Z4.%s, Z5.%s\n", op, width, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemulhighforms": {Name: "svemulhighforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.smulh.nxv",
+				"@llvm.aarch64.sve.smulh.u.nxv",
+				"@llvm.aarch64.sve.umulh.nxv",
+				"@llvm.aarch64.sve.umulh.u.nxv",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE multiply-high lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-mul-high.ll", "arm64-sve-mul-high.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiplyHighRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSMULH Z1.S, Z2.S, P0, Z2.S",
+		"ZUMULH Z1.S, Z2.S, P8.M, Z2.S",
+		"ZSMULH Z1.S, Z2.S, P0.M, Z3.S",
+		"ZUMULH Z1.H, Z2.S, Z3.S",
+		"ZSMULH Z1.S, Z2.S",
+		"ZUMULH.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemulhigh(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemulhigh": {Name: "badsvemulhigh", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE multiply-high forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_multi_narrow.go b/arm64_lower_sve_multi_narrow.go
new file mode 100644
index 000000000..6de6fa289
--- /dev/null
+++ b/arm64_lower_sve_multi_narrow.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEMultiNarrowSpec struct {
+	intrinsic      string
+	shifted        bool
+	signedInput    bool
+	unsignedOutput bool
+}
+
+var arm64SVEMultiNarrowSpecs = map[Op]arm64SVEMultiNarrowSpec{
+	"ZSQCVTN":   {intrinsic: "sqcvtn"},
+	"ZSQCVTUN":  {intrinsic: "sqcvtun"},
+	"ZUQCVTN":   {intrinsic: "uqcvtn"},
+	"ZSQRSHRN":  {intrinsic: "sqrshrn", shifted: true, signedInput: true},
+	"ZSQRSHRUN": {intrinsic: "sqrshrun", shifted: true, signedInput: true, unsignedOutput: true},
+	"ZUQRSHRN":  {intrinsic: "uqrshrn", shifted: true, unsignedOutput: true},
+}
+
+func arm64ParseSVEEvenVectorPair(operand Operand) (first, second, elementBits int, ok bool) {
+	if operand.Kind != OpRegList || !operand.RegListRange || len(operand.RegList) != 2 {
+		return 0, 0, 0, false
+	}
+	first, elementBits, firstOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: operand.RegList[0]})
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: operand.RegList[1]})
+	return first, second, elementBits, firstOK && secondOK && secondBits == elementBits && first%2 == 0 && second == first+1
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEMultiNarrowSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	wantArgs := 2
+	if spec.shifted {
+		wantArgs = 3
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != wantArgs {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 even/odd x2 range narrowing form without a suffix: %q", op, ins.Raw)
+	}
+	sourceOperand := 0
+	shift := int64(0)
+	if spec.shifted {
+		if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+			return true, false, fmt.Errorf("arm64 %s requires a concrete shift immediate: %q", op, ins.Raw)
+		}
+		shift, sourceOperand = ins.Args[0].Imm, 1
+	}
+	first, second, sourceBits, sourceOK := arm64ParseSVEEvenVectorPair(ins.Args[sourceOperand])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[sourceOperand+1])
+	validWidths := sourceBits == 32 && destinationBits == 16
+	if spec.shifted {
+		validWidths = sourceBits == 16 && destinationBits == 8 || sourceBits == 32 && destinationBits == 16
+		if shift < 1 || shift > int64(destinationBits) {
+			validWidths = false
+		}
+	}
+	if !sourceOK || !destinationOK || !validWidths {
+		return true, false, fmt.Errorf("arm64 %s requires an even/odd S-to-H pair, or a legal H-to-B shift pair: %q", op, ins.Raw)
+	}
+	firstValue, sourceType, err := c.loadZRegElements(first, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, _, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if spec.shifted && destinationBits == 8 {
+		result = c.lowerARM64SVEMultiShiftNarrowBytes(spec, firstValue, secondValue, shift)
+	} else if spec.shifted {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x2.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, destinationType, spec.intrinsic, 128/sourceBits, sourceBits, sourceType, firstValue, sourceType, secondValue, shift)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x2.nxv4i32(%s %s, %s %s)\n", result, destinationType, spec.intrinsic, sourceType, firstValue, sourceType, secondValue)
+	}
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiShiftNarrowBytes(spec arm64SVEMultiNarrowSpec, first, second string, shift int64) string {
+	narrowed := make([]string, 2)
+	for index, source := range []string{first, second} {
+		wide := c.newTmp()
+		extension := "zext"
+		shiftOp := "lshr"
+		if spec.signedInput {
+			extension, shiftOp = "sext", "ashr"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <vscale x 8 x i16> %s to <vscale x 8 x i32>\n", wide, extension, source)
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add <vscale x 8 x i32> %%%s, splat (i32 %d)\n", rounded, wide, int64(1)<<(shift-1))
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s <vscale x 8 x i32> %%%s, splat (i32 %d)\n", shifted, shiftOp, rounded, shift)
+
+		minimum, maximum := int64(-128), int64(127)
+		comparisonPrefix := "s"
+		if spec.unsignedOutput {
+			minimum, maximum = 0, 255
+			if !spec.signedInput {
+				comparisonPrefix = "u"
+			}
+		}
+		clampedLow := shifted
+		if minimum != 0 || spec.signedInput {
+			below := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp %slt <vscale x 8 x i32> %%%s, splat (i32 %d)\n", below, comparisonPrefix, shifted, minimum)
+			clampedLow = c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select <vscale x 8 x i1> %%%s, <vscale x 8 x i32> splat (i32 %d), <vscale x 8 x i32> %%%s\n", clampedLow, below, minimum, shifted)
+		}
+		above := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp %sgt <vscale x 8 x i32> %%%s, splat (i32 %d)\n", above, comparisonPrefix, clampedLow, maximum)
+		clamped := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <vscale x 8 x i1> %%%s, <vscale x 8 x i32> splat (i32 %d), <vscale x 8 x i32> %%%s\n", clamped, above, maximum, clampedLow)
+		narrowed[index] = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc <vscale x 8 x i32> %%%s to <vscale x 8 x i8>\n", narrowed[index], clamped)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i8> @llvm.vector.interleave2.nxv16i8(<vscale x 8 x i8> %%%s, <vscale x 8 x i8> %%%s)\n", result, narrowed[0], narrowed[1])
+	return result
+}
diff --git a/arm64_lower_sve_multi_narrow_test.go b/arm64_lower_sve_multi_narrow_test.go
new file mode 100644
index 000000000..b1be471ce
--- /dev/null
+++ b/arm64_lower_sve_multi_narrow_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMultiNarrowCompleteGo127Family(t *testing.T) {
+	const source = `TEXT svemultinarrow(SB),$0-0
+	ZSQCVTN [Z0.S-Z1.S], Z2.H
+	ZSQCVTUN [Z14.S-Z15.S], Z16.H
+	ZUQCVTN [Z30.S-Z31.S], Z0.H
+	ZSQRSHRN $1, [Z0.H-Z1.H], Z2.B
+	ZSQRSHRN $8, [Z30.H-Z31.H], Z3.B
+	ZSQRSHRN $1, [Z2.S-Z3.S], Z4.H
+	ZSQRSHRN $16, [Z28.S-Z29.S], Z5.H
+	ZSQRSHRUN $1, [Z4.H-Z5.H], Z6.B
+	ZSQRSHRUN $8, [Z26.H-Z27.H], Z7.B
+	ZSQRSHRUN $1, [Z6.S-Z7.S], Z8.H
+	ZSQRSHRUN $16, [Z24.S-Z25.S], Z9.H
+	ZUQRSHRN $1, [Z8.H-Z9.H], Z10.B
+	ZUQRSHRN $8, [Z22.H-Z23.H], Z11.B
+	ZUQRSHRN $1, [Z10.S-Z11.S], Z12.H
+	ZUQRSHRN $16, [Z20.S-Z21.S], Z13.H
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemultinarrow": {Name: "svemultinarrow", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.sqcvtn.x2.nxv4i32",
+				"@llvm.aarch64.sve.sqcvtun.x2.nxv4i32",
+				"@llvm.aarch64.sve.uqcvtn.x2.nxv4i32",
+				"@llvm.aarch64.sve.sqrshrn.x2.nxv4i32",
+				"@llvm.aarch64.sve.sqrshrun.x2.nxv4i32",
+				"@llvm.aarch64.sve.uqrshrn.x2.nxv4i32",
+				"sext <vscale x 8 x i16>",
+				"zext <vscale x 8 x i16>",
+				"icmp slt <vscale x 8 x i32>",
+				"icmp ugt <vscale x 8 x i32>",
+				"@llvm.vector.interleave2.nxv16i8",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s multi-vector narrow lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-multi-narrow.ll", "arm64-sve-multi-narrow.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiNarrowRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQCVTN [Z1.S-Z2.S], Z3.H",
+		"ZSQCVTUN [Z2.S, Z3.S], Z4.H",
+		"ZUQCVTN [Z2.H-Z3.H], Z4.B",
+		"ZSQRSHRN $0, [Z2.H-Z3.H], Z4.B",
+		"ZSQRSHRN $9, [Z2.H-Z3.H], Z4.B",
+		"ZSQRSHRUN $17, [Z2.S-Z3.S], Z4.H",
+		"ZUQRSHRN $1, [Z2.D-Z3.D], Z4.S",
+		"ZUQRSHRN $1, [Z2.H-Z5.H], Z6.B",
+		"ZUQRSHRN.Z $1, [Z2.H-Z3.H], Z4.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemultinarrow(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemultinarrow": {Name: "badsvemultinarrow", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's multi-vector narrowing forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_multiply.go b/arm64_lower_sve_multiply.go
new file mode 100644
index 000000000..706c6e7bc
--- /dev/null
+++ b/arm64_lower_sve_multiply.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64SVEMultiplyMode uint8
+
+const (
+	arm64SVEMultiplyPredicated arm64SVEMultiplyMode = iota
+	arm64SVEMultiplyUnpredicated
+	arm64SVEMultiplyLane
+	arm64SVEMultiplyImmediate
+)
+
+type arm64RawSVEMultiply struct {
+	mode        arm64SVEMultiplyMode
+	elementBits int
+	first       int
+	second      int
+	predicate   int
+	laneVector  int
+	lane        int
+	immediate   int
+	destination int
+}
+
+func decodeARM64RawSVEMultiply(word uint32) (arm64RawSVEMultiply, bool) {
+	form := arm64RawSVEMultiply{}
+	switch {
+	case word&0xff3fe000 == 0x04100000:
+		form.mode = arm64SVEMultiplyPredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.second = int(word>>5) & 31
+		form.predicate = int(word>>10) & 7
+	case word&0xff20fc00 == 0x04206000:
+		form.mode = arm64SVEMultiplyUnpredicated
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = int(word>>5) & 31
+		form.second = int(word>>16) & 31
+	case word&0xffa0fc00 == 0x4420f800:
+		form.mode = arm64SVEMultiplyLane
+		form.elementBits = 16
+		form.laneVector = int(word>>16) & 7
+		form.lane = int(word>>19)&3 | (int(word>>22)&1)<<2
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xffe0fc00 == 0x44a0f800:
+		form.mode = arm64SVEMultiplyLane
+		form.elementBits = 32
+		form.laneVector = int(word>>16) & 7
+		form.lane = int(word>>19) & 3
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xffe0fc00 == 0x44e0f800:
+		form.mode = arm64SVEMultiplyLane
+		form.elementBits = 64
+		form.laneVector = int(word>>16) & 15
+		form.lane = int(word>>20) & 1
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+	case word&0xff3fe000 == 0x2530c000:
+		form.mode = arm64SVEMultiplyImmediate
+		form.elementBits = 8 << (int(word>>22) & 3)
+		form.destination = int(word) & 31
+		form.first = form.destination
+		form.immediate = int(int8(word >> 5))
+	default:
+		return arm64RawSVEMultiply{}, false
+	}
+	return form, true
+}
+
+func arm64ParseSVEZIndexedElementReg(operand Operand) (index, elementBits, lane int, ok bool) {
+	index, elementBits, lane, ok = arm64ParseSVEZIndexedElementRegUnbounded(operand)
+	if !ok {
+		return 0, 0, 0, false
+	}
+	maxVector, vectorOK := map[int]int{16: 7, 32: 7, 64: 15}[elementBits]
+	maxLane, laneOK := map[int]int{16: 7, 32: 3, 64: 1}[elementBits]
+	return index, elementBits, lane, vectorOK && laneOK && index <= maxVector && lane <= maxLane
+}
+
+func arm64ParseSVEZIndexedElementRegUnbounded(operand Operand) (index, elementBits, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	dot := strings.IndexByte(name, '.')
+	open := strings.IndexByte(name, '[')
+	if dot <= 1 || open <= dot+1 || !strings.HasSuffix(name, "]") || !strings.HasPrefix(name, "Z") {
+		return 0, 0, 0, false
+	}
+	index, err := strconv.Atoi(name[1:dot])
+	if err != nil {
+		return 0, 0, 0, false
+	}
+	elementBits, bitsOK := map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[name[dot+1:open]]
+	lane, err = strconv.Atoi(name[open+1 : len(name)-1])
+	if err != nil || !bitsOK {
+		return 0, 0, 0, false
+	}
+	return index, elementBits, lane, index >= 0 && index <= 31 && lane >= 0
+}
+
+func arm64SVEMultiplyNeedsSVE2(ins Instr) bool {
+	return len(ins.Args) == 3 && len(ins.Args) > 0 && ins.Args[0].Kind != OpImm
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZMUL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 ZMUL does not accept an instruction suffix: %q", ins.Raw)
+	}
+
+	form := arm64RawSVEMultiply{}
+	if len(ins.Args) == 4 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+			return true, false, fmt.Errorf("arm64 ZMUL predicated expects Zm.T, Zdn.T, Pg.M, Zdn.T with identical destructive operands: %q", ins.Raw)
+		}
+		form = arm64RawSVEMultiply{mode: arm64SVEMultiplyPredicated, elementBits: firstBits, first: first, second: second, predicate: predicate, destination: destination}
+	} else if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm {
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		immediate := ins.Args[0].Imm
+		if ins.Args[0].ImmRaw != "" || !firstOK || !destinationOK || first != destination || firstBits != destinationBits || immediate < -128 || immediate > 127 {
+			return true, false, fmt.Errorf("arm64 ZMUL immediate expects a signed 8-bit value and identical Zdn.T operands: %q", ins.Raw)
+		}
+		form = arm64RawSVEMultiply{mode: arm64SVEMultiplyImmediate, elementBits: firstBits, first: first, immediate: int(immediate), destination: destination}
+	} else if len(ins.Args) == 3 {
+		if laneVector, laneBits, lane, laneOK := arm64ParseSVEZIndexedElementReg(ins.Args[0]); laneOK {
+			first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+			destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+			if !firstOK || !destinationOK || laneBits != firstBits || firstBits != destinationBits {
+				return true, false, fmt.Errorf("arm64 ZMUL lane operands must share H, S, or D width: %q", ins.Raw)
+			}
+			form = arm64RawSVEMultiply{mode: arm64SVEMultiplyLane, elementBits: firstBits, first: first, laneVector: laneVector, lane: lane, destination: destination}
+		} else {
+			second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+			first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+			destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+			if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+				return true, false, fmt.Errorf("arm64 ZMUL vector operands must share one element width: %q", ins.Raw)
+			}
+			form = arm64RawSVEMultiply{mode: arm64SVEMultiplyUnpredicated, elementBits: firstBits, first: first, second: second, destination: destination}
+		}
+	} else {
+		return true, false, fmt.Errorf("arm64 ZMUL expects one of the six Go 1.27 SVE forms: %q", ins.Raw)
+	}
+	return true, false, c.lowerRawSVEMultiply(form)
+}
+
+func (c *arm64Ctx) lowerRawSVEMultiply(form arm64RawSVEMultiply) error {
+	first, vectorType, err := c.loadZRegElements(form.first, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	switch form.mode {
+	case arm64SVEMultiplyPredicated:
+		second, _, err := c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.mul.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, lanes, form.elementBits, predicateType, predicate, vectorType, first, vectorType, second)
+	case arm64SVEMultiplyUnpredicated:
+		second, _, err := c.loadZRegElements(form.second, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", result, vectorType, first, second)
+	case arm64SVEMultiplyLane:
+		laneVector, _, err := c.loadZRegElements(form.laneVector, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.mul.lane.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, lanes, form.elementBits, vectorType, first, vectorType, laneVector, form.lane)
+	case arm64SVEMultiplyImmediate:
+		fmt.Fprintf(c.b, "  %%%s = mul %s %s, splat (i%d %d)\n", result, vectorType, first, form.elementBits, form.immediate)
+	default:
+		return fmt.Errorf("unknown ARM64 SVE MUL mode %d", form.mode)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_multiply_accumulate.go b/arm64_lower_sve_multiply_accumulate.go
new file mode 100644
index 000000000..15b6ad433
--- /dev/null
+++ b/arm64_lower_sve_multiply_accumulate.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEMultiplyAccumulateSpec struct {
+	intrinsic          string
+	predicatedRaw      uint32
+	indexedRaw         [3]uint32
+	destructiveProduct bool
+}
+
+var arm64SVEMultiplyAccumulateSpecs = map[Op]arm64SVEMultiplyAccumulateSpec{
+	"ZMLA": {intrinsic: "mla", predicatedRaw: 0x04004000, indexedRaw: [3]uint32{0x44200800, 0x44a00800, 0x44e00800}},
+	"ZMLS": {intrinsic: "mls", predicatedRaw: 0x04006000, indexedRaw: [3]uint32{0x44200c00, 0x44a00c00, 0x44e00c00}},
+	"ZMAD": {intrinsic: "mad", predicatedRaw: 0x0400c000, destructiveProduct: true},
+	"ZMSB": {intrinsic: "msb", predicatedRaw: 0x0400e000, destructiveProduct: true},
+}
+
+type arm64SVEMultiplyAccumulateForm struct {
+	intrinsic    string
+	elementBits  int
+	secondSource int
+	firstSource  int
+	predicate    int
+	lane         int
+	destination  int
+	indexed      bool
+}
+
+func arm64SVEMultiplyAccumulateNeedsSVE2(ins Instr) bool {
+	return len(ins.Args) == 3
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiplyAccumulate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEMultiplyAccumulateSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 3 && len(ins.Args) != 4) {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 multiply-accumulate form without a suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) == 3 && spec.indexedRaw[0] == 0 {
+		return true, false, fmt.Errorf("arm64 %s requires its predicated four-operand form: %q", op, ins.Raw)
+	}
+	form := arm64SVEMultiplyAccumulateForm{intrinsic: spec.intrinsic}
+	if len(ins.Args) == 4 {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+		if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s predicated operands must use one B/H/S/D width and P0..P7.M: %q", op, ins.Raw)
+		}
+		form.elementBits = secondBits
+		form.secondSource = second
+		form.firstSource = first
+		form.predicate = predicate
+		form.destination = destination
+	} else {
+		multiplier, multiplierBits, lane, multiplierOK := arm64ParseSVEZIndexedElementReg(ins.Args[0])
+		multiplicand, multiplicandBits, multiplicandOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !multiplierOK || !multiplicandOK || !destinationOK || multiplierBits != multiplicandBits || multiplicandBits != destinationBits {
+			return true, false, fmt.Errorf("arm64 %s indexed operands must use one H/S/D width and an encodable lane: %q", op, ins.Raw)
+		}
+		form.elementBits = multiplierBits
+		form.secondSource = multiplier
+		form.firstSource = multiplicand
+		form.lane = lane
+		form.destination = destination
+		form.indexed = true
+	}
+	return true, false, c.lowerARM64SVEMultiplyAccumulateForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiplyAccumulateForm(form arm64SVEMultiplyAccumulateForm) error {
+	// MLA/MLS accumulate into the old destination. MAD/MSB multiply the
+	// old destination and first source, then add/subtract from the second.
+	destination, vectorType, err := c.loadZRegElements(form.destination, form.elementBits)
+	if err != nil {
+		return err
+	}
+	first, _, err := c.loadZRegElements(form.firstSource, form.elementBits)
+	if err != nil {
+		return err
+	}
+	second, _, err := c.loadZRegElements(form.secondSource, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n",
+			result, vectorType, form.intrinsic, lanes, form.elementBits, vectorType, destination, vectorType, first, vectorType, second, form.lane)
+	} else {
+		predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s, %s %s)\n",
+			result, vectorType, form.intrinsic, lanes, form.elementBits, predicateType, predicate, vectorType, destination, vectorType, first, vectorType, second)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_multiply_accumulate_long.go b/arm64_lower_sve_multiply_accumulate_long.go
new file mode 100644
index 000000000..e18d1579b
--- /dev/null
+++ b/arm64_lower_sve_multiply_accumulate_long.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawSVEMultiplyAccumulateLong struct {
+	op          Op
+	mode        arm64SVEUMULLBMode
+	sourceBits  int
+	first       int
+	second      int
+	laneVector  int
+	lane        int
+	destination int
+}
+
+var arm64SVEMultiplyAccumulateLongIntrinsics = map[Op]string{
+	"ZSMLALB": "smlalb",
+	"ZSMLALT": "smlalt",
+	"ZUMLALB": "umlalb",
+	"ZUMLALT": "umlalt",
+	"ZSMLSLB": "smlslb",
+	"ZSMLSLT": "smlslt",
+	"ZUMLSLB": "umlslb",
+	"ZUMLSLT": "umlslt",
+}
+
+var arm64SVEMultiplyAccumulateLongOpsBySelector = [...]Op{
+	"ZSMLALB", "ZSMLALT", "ZUMLALB", "ZUMLALT",
+	"ZSMLSLB", "ZSMLSLT", "ZUMLSLB", "ZUMLSLT",
+}
+
+// decodeARM64RawSVEMultiplyAccumulateLong covers all SVE2 signed/unsigned
+// multiply-add/subtract-long bottom/top vector and indexed forms emitted by the
+// Go 1.27 ARM64 assembler.
+func decodeARM64RawSVEMultiplyAccumulateLong(word uint32) (arm64RawSVEMultiplyAccumulateLong, bool) {
+	form := arm64RawSVEMultiplyAccumulateLong{}
+	switch {
+	case word&0xff20e000 == 0x44004000:
+		size := int(word>>22) & 3
+		if size == 0 {
+			return arm64RawSVEMultiplyAccumulateLong{}, false
+		}
+		form.mode = arm64SVEUMULLBVector
+		form.sourceBits = 4 << size
+		form.second = int(word>>16) & 31
+		form.op = arm64SVEMultiplyAccumulateLongOpsBySelector[int(word>>10)&7]
+	case word&0xffe0c000 == 0x44a08000:
+		form.mode = arm64SVEUMULLBLane
+		form.sourceBits = 16
+		form.laneVector = int(word>>16) & 7
+		form.lane = int(word>>11)&1 | (int(word>>19)&3)<<1
+		selector := int(word>>10)&1 | (int(word>>12)&3)<<1
+		form.op = arm64SVEMultiplyAccumulateLongOpsBySelector[selector]
+	case word&0xffe0c000 == 0x44e08000:
+		form.mode = arm64SVEUMULLBLane
+		form.sourceBits = 32
+		form.laneVector = int(word>>16) & 15
+		form.lane = int(word>>11)&1 | (int(word>>20)&1)<<1
+		selector := int(word>>10)&1 | (int(word>>12)&3)<<1
+		form.op = arm64SVEMultiplyAccumulateLongOpsBySelector[selector]
+	default:
+		return arm64RawSVEMultiplyAccumulateLong{}, false
+	}
+	form.first = int(word>>5) & 31
+	form.destination = int(word) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiplyAccumulateLong(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, ok := arm64SVEMultiplyAccumulateLongIntrinsics[op]; !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one of the five Go 1.27 SVE2 forms: %q", op, ins.Raw)
+	}
+	form := arm64RawSVEMultiplyAccumulateLong{op: op}
+	if laneVector, laneBits, lane, laneOK := arm64ParseSVEUMULLBIndexedReg(ins.Args[0]); laneOK {
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !firstOK || !destinationOK || firstBits != laneBits || destinationBits != 2*laneBits {
+			return true, false, fmt.Errorf("arm64 %s indexed operands must widen H to S or S to D: %q", op, ins.Raw)
+		}
+		form.mode = arm64SVEUMULLBLane
+		form.sourceBits = firstBits
+		form.first = first
+		form.laneVector = laneVector
+		form.lane = lane
+		form.destination = destination
+	} else {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits == 64 || destinationBits != 2*firstBits {
+			return true, false, fmt.Errorf("arm64 %s vector operands must widen B/H/S to H/S/D: %q", op, ins.Raw)
+		}
+		form.mode = arm64SVEUMULLBVector
+		form.sourceBits = firstBits
+		form.first = first
+		form.second = second
+		form.destination = destination
+	}
+	return true, false, c.lowerRawSVEMultiplyAccumulateLong(form)
+}
+
+func (c *arm64Ctx) lowerRawSVEMultiplyAccumulateLong(form arm64RawSVEMultiplyAccumulateLong) error {
+	intrinsic, ok := arm64SVEMultiplyAccumulateLongIntrinsics[form.op]
+	if !ok {
+		return fmt.Errorf("unsupported ARM64 SVE2 multiply-accumulate-long operation %s", form.op)
+	}
+	destinationBits := form.sourceBits * 2
+	accumulator, destinationType, err := c.loadZRegElements(form.destination, destinationBits)
+	if err != nil {
+		return err
+	}
+	first, sourceType, err := c.loadZRegElements(form.first, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	secondIndex := form.second
+	if form.mode == arm64SVEUMULLBLane {
+		secondIndex = form.laneVector
+	}
+	second, _, err := c.loadZRegElements(secondIndex, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	_, destinationLanes, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.mode == arm64SVEUMULLBVector {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, intrinsic, destinationLanes, destinationBits, destinationType, accumulator, sourceType, first, sourceType, second)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n", result, destinationType, intrinsic, destinationLanes, destinationBits, destinationType, accumulator, sourceType, first, sourceType, second, form.lane)
+	}
+	return c.storeZRegElements(form.destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_multiply_accumulate_long_test.go b/arm64_lower_sve_multiply_accumulate_long_test.go
new file mode 100644
index 000000000..f94c81dcd
--- /dev/null
+++ b/arm64_lower_sve_multiply_accumulate_long_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVEMultiplyAccumulateLongOps = []Op{
+	"ZSMLALB", "ZSMLALT", "ZUMLALB", "ZUMLALT",
+	"ZSMLSLB", "ZSMLSLT", "ZUMLSLB", "ZUMLSLT",
+}
+
+func encodeARM64RawSVEMultiplyAccumulateLongVector(op Op, sourceBits, second, first, destination int) uint32 {
+	selector := arm64SVEMultiplyAccumulateLongSelector(op)
+	size := map[int]uint32{8: 1, 16: 2, 32: 3}[sourceBits]
+	return 0x44004000 | size<<22 | uint32(second)<<16 | uint32(selector)<<10 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEMultiplyAccumulateLongLane(op Op, sourceBits, laneVector, lane, first, destination int) uint32 {
+	selector := arm64SVEMultiplyAccumulateLongSelector(op)
+	opBits := uint32(selector&1)<<10 | uint32(selector&6)<<11
+	if sourceBits == 16 {
+		return 0x44a08000 | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<19 | opBits | uint32(first)<<5 | uint32(destination)
+	}
+	return 0x44e08000 | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<20 | opBits | uint32(first)<<5 | uint32(destination)
+}
+
+func arm64SVEMultiplyAccumulateLongSelector(op Op) int {
+	for selector, candidate := range arm64SVEMultiplyAccumulateLongOps {
+		if op == candidate {
+			return selector
+		}
+	}
+	panic("unknown SVE multiply-accumulate-long op " + op)
+}
+
+func TestTranslateARM64RawSVEUMLALBReportedEncoding(t *testing.T) {
+	const source = "TEXT sveumlalbreported(SB),$0-0\n\tWORD $0x44d24a20\n\tRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"sveumlalbreported": {Name: "sveumlalbreported", Ret: Void}}}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestTranslateARM64SVEMultiplyAccumulateLongCompleteGo127Forms(t *testing.T) {
+	var named strings.Builder
+	named.WriteString("TEXT svemlalnamed(SB),$0-0\n")
+	for _, op := range arm64SVEMultiplyAccumulateLongOps {
+		fmt.Fprintf(&named, "\t%s Z2.B, Z1.B, Z0.H\n", op)
+		fmt.Fprintf(&named, "\t%s Z4.H, Z3.H, Z0.S\n", op)
+		fmt.Fprintf(&named, "\t%s Z6.S, Z5.S, Z0.D\n", op)
+		fmt.Fprintf(&named, "\t%s Z7.H[7], Z8.H, Z0.S\n", op)
+		fmt.Fprintf(&named, "\t%s Z15.S[3], Z9.S, Z0.D\n", op)
+	}
+	named.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, named.String(), true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svemlalraw(SB),$0-0\n")
+	for _, op := range arm64SVEMultiplyAccumulateLongOps {
+		for _, sourceBits := range []int{8, 16, 32} {
+			fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyAccumulateLongVector(op, sourceBits, 2, 1, 0))
+		}
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyAccumulateLongLane(op, 16, 7, 7, 8, 0))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyAccumulateLongLane(op, 32, 15, 3, 9, 0))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for name, source := range map[string]string{"named": named.String(), "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svemlal" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.smlalb", "@llvm.aarch64.sve.umlalt", "@llvm.aarch64.sve.smlslt", "@llvm.aarch64.sve.umlslb.lane"} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("SVE2 multiply-accumulate-long lowering omitted %q:\n%s", want, ir)
+						}
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-mlal.ll", "arm64-sve-mlal.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEMultiplyAccumulateLongDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, op := range arm64SVEMultiplyAccumulateLongOps {
+		for _, sourceBits := range []int{8, 16, 32} {
+			for second := 0; second < 32; second++ {
+				for first := 0; first < 32; first++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVEMultiplyAccumulateLongVector(op, sourceBits, second, first, destination)
+						got, ok := decodeARM64RawSVEMultiplyAccumulateLong(word)
+						if !ok || got.op != op || got.mode != arm64SVEUMULLBVector || got.sourceBits != sourceBits || got.second != second || got.first != first || got.destination != destination {
+							t.Fatalf("decoded vector %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+		for _, domain := range []struct{ bits, vectors, lanes int }{{16, 8, 8}, {32, 16, 4}} {
+			for laneVector := 0; laneVector < domain.vectors; laneVector++ {
+				for lane := 0; lane < domain.lanes; lane++ {
+					for first := 0; first < 32; first++ {
+						for destination := 0; destination < 32; destination++ {
+							word := encodeARM64RawSVEMultiplyAccumulateLongLane(op, domain.bits, laneVector, lane, first, destination)
+							got, ok := decodeARM64RawSVEMultiplyAccumulateLong(word)
+							if !ok || got.op != op || got.mode != arm64SVEUMULLBLane || got.sourceBits != domain.bits || got.laneVector != laneVector || got.lane != lane || got.first != first || got.destination != destination {
+								t.Fatalf("decoded lane %#08x as %+v, ok=%v", word, got, ok)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVEMultiplyAccumulateLongRejectsReservedAndInvalidForms(t *testing.T) {
+	for _, word := range []uint32{0x44004000, 0x44006000, 0x44a0c000, 0x44e0c000} {
+		if _, ok := decodeARM64RawSVEMultiplyAccumulateLong(word); ok {
+			t.Fatalf("decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = "TEXT badsvemlal(SB),$0-0\n\tZUMLALB Z1.B[0], Z2.B, Z3.H\n\tZUMLALB Z1.S, Z2.S, Z3.S\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+}
diff --git a/arm64_lower_sve_multiply_accumulate_test.go b/arm64_lower_sve_multiply_accumulate_test.go
new file mode 100644
index 000000000..bafbe4fba
--- /dev/null
+++ b/arm64_lower_sve_multiply_accumulate_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMultiplyAccumulateCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemultiplyaccumulateforms(SB),$0-0\n")
+	for _, op := range []string{"ZMLA", "ZMLS"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z3.%s\n", op, width, width, index, width)
+		}
+		for index, width := range []string{"H", "S", "D"} {
+			maximumVector := []int{7, 7, 15}[index]
+			maximumLane := []int{7, 3, 1}[index]
+			fmt.Fprintf(&source, "\t%s Z%d.%s[%d], Z4.%s, Z5.%s\n", op, maximumVector, width, maximumLane, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemultiplyaccumulateforms": {Name: "svemultiplyaccumulateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.mla.nxv16i8",
+				"@llvm.aarch64.sve.mla.lane.nxv8i16",
+				"@llvm.aarch64.sve.mls.nxv2i64",
+				"@llvm.aarch64.sve.mls.lane.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE multiply-accumulate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-multiply-accumulate.ll", "arm64-sve-multiply-accumulate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiplyAccumulateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZMLA Z1.B, Z2.H, P0.M, Z3.H",
+		"ZMLS Z1.S, Z2.S, P0, Z3.S",
+		"ZMLA Z1.D, Z2.D, P8.M, Z3.D",
+		"ZMLS Z1.B[0], Z2.B, Z3.B",
+		"ZMLA Z8.H[0], Z2.H, Z3.H",
+		"ZMLS Z7.H[8], Z2.H, Z3.H",
+		"ZMLA Z7.S[3], Z2.D, Z3.D",
+		"ZMLS.Z Z1.S, Z2.S, P0.M, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemultiplyaccumulate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemultiplyaccumulate": {Name: "badsvemultiplyaccumulate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE multiply-accumulate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_multiply_add_tail.go b/arm64_lower_sve_multiply_add_tail.go
new file mode 100644
index 000000000..73ec82ace
--- /dev/null
+++ b/arm64_lower_sve_multiply_add_tail.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEMultiplyAddTailOps = map[Op]string{
+	"ZMADPT": "madpt",
+	"ZMLAPT": "mlapt",
+}
+
+func (c *arm64Ctx) lowerARM64SVEMultiplyAddTail(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	mnemonic, ok := arm64SVEMultiplyAddTailOps[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three D-width vector operands without a suffix: %q", op, ins.Raw)
+	}
+	firstSource, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0])
+	secondSource, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !firstOK || !secondOK || !destinationOK || firstBits != 64 || secondBits != 64 || destinationBits != 64 {
+		return true, false, fmt.Errorf("arm64 %s requires three D-width scalable-vector operands: %q", op, ins.Raw)
+	}
+	destinationValue, vectorType, err := c.loadZRegElements(destination, 64)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(secondSource, 64)
+	if err != nil {
+		return true, false, err
+	}
+	firstValue, _, err := c.loadZRegElements(firstSource, 64)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	assembly := mnemonic + " $0.d, $2.d, $3.d"
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, %s %s)\n", result, vectorType, assembly, "=&w,0,w,w", vectorType, destinationValue, vectorType, secondValue, vectorType, firstValue)
+	return true, false, c.storeZRegElements(destination, 64, "%"+result)
+}
diff --git a/arm64_lower_sve_multiply_add_tail_test.go b/arm64_lower_sve_multiply_add_tail_test.go
new file mode 100644
index 000000000..b345809e3
--- /dev/null
+++ b/arm64_lower_sve_multiply_add_tail_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEMultiplyAddTailCompleteGo127Family(t *testing.T) {
+	source := `
+TEXT svemultiplyaddtail(SB),$0-0
+	ZMADPT Z7.D, Z6.D, Z23.D
+	ZMLAPT Z8.D, Z9.D, Z24.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemultiplyaddtail": {Name: "svemultiplyaddtail", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+cpa,+sve"`,
+				`asm sideeffect "madpt $0.d, $2.d, $3.d", "=&w,0,w,w"`,
+				`asm sideeffect "mlapt $0.d, $2.d, $3.d", "=&w,0,w,w"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE multiply-add-tail lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-multiply-add-tail.ll", "arm64-sve-multiply-add-tail.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiplyAddTailRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZMADPT Z1.S, Z2.S, Z3.S",
+		"ZMADPT Z1.D, Z2.S, Z3.D",
+		"ZMLAPT Z1.H, Z2.H, Z3.H",
+		"ZMLAPT Z1.D, Z2.D",
+		"ZMADPT.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemultiplyaddtail(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemultiplyaddtail": {Name: "badsvemultiplyaddtail", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's multiply-add-tail forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_multiply_long_extra_test.go b/arm64_lower_sve_multiply_long_extra_test.go
new file mode 100644
index 000000000..cbc281f44
--- /dev/null
+++ b/arm64_lower_sve_multiply_long_extra_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEMultiplyLongVector(op Op, sourceBits, second, first, destination int) uint32 {
+	spec := arm64SVEMultiplyLongSpecs[op]
+	size := map[int]uint32{8: 1, 16: 2, 32: 3}[sourceBits]
+	return spec.vectorBase | size<<22 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEMultiplyLongLane(op Op, sourceBits, laneVector, lane, first, destination int) uint32 {
+	spec := arm64SVEMultiplyLongSpecs[op]
+	if sourceBits == 16 {
+		return spec.laneHBase | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<19 | uint32(first)<<5 | uint32(destination)
+	}
+	return spec.laneSBase | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<20 | uint32(first)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVEMultiplyLongExtraCompleteGo127Family(t *testing.T) {
+	regular := []string{
+		"ZSMULLB", "ZSMULLT", "ZUMULLT",
+		"ZSQDMULLB", "ZSQDMULLT",
+		"ZSQDMLALB", "ZSQDMLALT",
+		"ZSQDMLSLB", "ZSQDMLSLT",
+	}
+	bottomTop := []string{"ZSQDMLALBT", "ZSQDMLSLBT"}
+	widths := []struct {
+		source, destination string
+	}{{"B", "H"}, {"H", "S"}, {"S", "D"}}
+
+	var source strings.Builder
+	source.WriteString("TEXT svemultiplylongextra(SB),$0-0\n")
+	for _, op := range regular {
+		for _, width := range widths {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width.source, width.source, width.destination)
+		}
+		fmt.Fprintf(&source, "\t%s Z7.H[7], Z4.H, Z5.S\n", op)
+		fmt.Fprintf(&source, "\t%s Z15.S[3], Z6.S, Z7.D\n", op)
+	}
+	for _, op := range bottomTop {
+		for _, width := range widths {
+			fmt.Fprintf(&source, "\t%s Z8.%s, Z9.%s, Z10.%s\n", op, width.source, width.source, width.destination)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemultiplylongextra": {Name: "svemultiplylongextra", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.smullb.",
+				"@llvm.aarch64.sve.umullt.lane.",
+				"@llvm.aarch64.sve.sqdmullt.",
+				"@llvm.aarch64.sve.sqdmlalb.lane.",
+				"@llvm.aarch64.sve.sqdmlslbt.",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE multiply-long lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-multiply-long-extra.ll", "arm64-sve-multiply-long-extra.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiplyLongExtraRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSMULLB Z1.D, Z2.D, Z3.Q",
+		"ZSMULLT Z8.H[0], Z1.H, Z2.S",
+		"ZUMULLT Z1.H, Z2.H, Z3.D",
+		"ZSQDMULLB Z1.B[0], Z2.B, Z3.H",
+		"ZSQDMLALBT Z1.H[0], Z2.H, Z3.S",
+		"ZSQDMLSLBT Z1.B, Z2.B, Z3.S",
+		"ZSQDMLALT.Z Z1.B, Z2.B, Z3.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvemultiplylongextra(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemultiplylongextra": {Name: "badsvemultiplylongextra", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE multiply-long forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEMultiplyLongRawEncodings(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svemultiplylongraw(SB),$0-0\n")
+	for _, op := range arm64SVEMultiplyLongOps {
+		spec := arm64SVEMultiplyLongSpecs[op]
+		for _, sourceBits := range []int{8, 16, 32} {
+			word := encodeARM64RawSVEMultiplyLongVector(op, sourceBits, 1, 2, 3)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			got, ok := decodeARM64RawSVEUMULLB(word)
+			if !ok || got.op != op || got.mode != arm64SVEUMULLBVector || got.sourceBits != sourceBits || got.second != 1 || got.first != 2 || got.destination != 3 {
+				t.Fatalf("decoded vector %s %#08x as %+v, ok=%v", op, word, got, ok)
+			}
+		}
+		if spec.laneHBase == 0 {
+			continue
+		}
+		for _, domain := range []struct {
+			bits, vector, lane int
+		}{{16, 7, 7}, {32, 15, 3}} {
+			word := encodeARM64RawSVEMultiplyLongLane(op, domain.bits, domain.vector, domain.lane, 4, 5)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			got, ok := decodeARM64RawSVEUMULLB(word)
+			if !ok || got.op != op || got.mode != arm64SVEUMULLBLane || got.sourceBits != domain.bits || got.laneVector != domain.vector || got.lane != domain.lane || got.first != 4 || got.destination != 5 {
+				t.Fatalf("decoded indexed %s %#08x as %+v, ok=%v", op, word, got, ok)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svemultiplylongraw": {Name: "svemultiplylongraw", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-multiply-long-raw.ll", "arm64-sve-multiply-long-raw.o", ll)
+		})
+	}
+}
diff --git a/arm64_lower_sve_multiply_test.go b/arm64_lower_sve_multiply_test.go
new file mode 100644
index 000000000..fc5b4ae30
--- /dev/null
+++ b/arm64_lower_sve_multiply_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEMultiplyPredicated(elementBits, second, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04100000 | size<<22 | uint32(second)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func encodeARM64RawSVEMultiplyUnpredicated(elementBits, second, first, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x04206000 | size<<22 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEMultiplyLane(elementBits, laneVector, lane, first, destination int) uint32 {
+	word := uint32(0x44e0f800)
+	switch elementBits {
+	case 16:
+		word = 0x4420f800 | uint32(laneVector)<<16 | uint32(lane&3)<<19 | uint32(lane>>2)<<22
+	case 32:
+		word = 0x44a0f800 | uint32(laneVector)<<16 | uint32(lane)<<19
+	case 64:
+		word |= uint32(laneVector)<<16 | uint32(lane)<<20
+	}
+	return word | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEMultiplyImmediate(elementBits, immediate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x2530c000 | size<<22 | uint32(uint8(int8(immediate)))<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVEMultiplyCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT svemulnamed(SB),$0-0
+	ZMUL Z31.B, Z0.B, P0.M, Z0.B
+	ZMUL Z30.H, Z1.H, P1.M, Z1.H
+	ZMUL Z29.S, Z2.S, P2.M, Z2.S
+	ZMUL Z28.D, Z3.D, P7.M, Z3.D
+	ZMUL Z27.B, Z4.B, Z5.B
+	ZMUL Z26.H, Z6.H, Z7.H
+	ZMUL Z25.S, Z8.S, Z9.S
+	ZMUL Z24.D, Z10.D, Z11.D
+	ZMUL Z7.H[7], Z12.H, Z13.H
+	ZMUL Z6.S[3], Z14.S, Z15.S
+	ZMUL Z15.D[1], Z16.D, Z17.D
+	ZMUL $-128, Z18.B, Z18.B
+	ZMUL $127, Z19.H, Z19.H
+	ZMUL $-1, Z20.S, Z20.S
+	ZMUL $0, Z21.D, Z21.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svemulraw(SB),$0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyPredicated(elementBits, 1, 2, 3))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyUnpredicated(elementBits, 4, 5, 6))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyImmediate(elementBits, -128+elementBits, 7))
+	}
+	for _, form := range []struct{ bits, vector, lane int }{{16, 7, 7}, {32, 7, 3}, {64, 15, 1}} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEMultiplyLane(form.bits, form.vector, form.lane, 8, 9))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svemul" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.mul.nxv", "@llvm.aarch64.sve.mul.lane.nxv", " mul <vscale x "} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE MUL lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-multiply.ll", "arm64-sve-multiply.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEMultiplyDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for second := 0; second < 32; second++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEMultiplyPredicated(elementBits, second, predicate, destination)
+					got, ok := decodeARM64RawSVEMultiply(word)
+					if !ok || got.mode != arm64SVEMultiplyPredicated || got.elementBits != elementBits || got.second != second || got.first != destination || got.predicate != predicate || got.destination != destination {
+						t.Fatalf("decoded predicated SVE MUL %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for second := 0; second < 32; second++ {
+			for first := 0; first < 32; first++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEMultiplyUnpredicated(elementBits, second, first, destination)
+					got, ok := decodeARM64RawSVEMultiply(word)
+					if !ok || got.mode != arm64SVEMultiplyUnpredicated || got.elementBits != elementBits || got.second != second || got.first != first || got.destination != destination {
+						t.Fatalf("decoded unpredicated SVE MUL %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+		for immediate := -128; immediate <= 127; immediate++ {
+			for destination := 0; destination < 32; destination++ {
+				word := encodeARM64RawSVEMultiplyImmediate(elementBits, immediate, destination)
+				got, ok := decodeARM64RawSVEMultiply(word)
+				if !ok || got.mode != arm64SVEMultiplyImmediate || got.elementBits != elementBits || got.immediate != immediate || got.first != destination || got.destination != destination {
+					t.Fatalf("decoded immediate SVE MUL %#08x as %+v, ok=%v", word, got, ok)
+				}
+			}
+		}
+	}
+	for _, domain := range []struct{ bits, vectors, lanes int }{{16, 8, 8}, {32, 8, 4}, {64, 16, 2}} {
+		for laneVector := 0; laneVector < domain.vectors; laneVector++ {
+			for lane := 0; lane < domain.lanes; lane++ {
+				for first := 0; first < 32; first++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVEMultiplyLane(domain.bits, laneVector, lane, first, destination)
+						got, ok := decodeARM64RawSVEMultiply(word)
+						if !ok || got.mode != arm64SVEMultiplyLane || got.elementBits != domain.bits || got.laneVector != laneVector || got.lane != lane || got.first != first || got.destination != destination {
+							t.Fatalf("decoded lane SVE MUL %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVEMultiplyRejectsAdjacentAndInvalidForms(t *testing.T) {
+	for _, word := range []uint32{0x04110000, 0x04206400, 0x2531c000, 0x4420fc00} {
+		if _, ok := decodeARM64RawSVEMultiply(word); ok {
+			t.Fatalf("SVE MUL decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsvemul(SB),$0-0
+	ZMUL Z1.S, Z2.S, P0.M, Z3.S
+	ZMUL Z8.H[0], Z2.H, Z3.H
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvemul": {Name: "badsvemul", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted invalid SVE MUL forms")
+	}
+}
diff --git a/arm64_lower_sve_non_faulting_memory.go b/arm64_lower_sve_non_faulting_memory.go
new file mode 100644
index 000000000..5db3d9211
--- /dev/null
+++ b/arm64_lower_sve_non_faulting_memory.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVENonFaultingMemorySpec struct {
+	memoryBits int
+	signed     bool
+}
+
+// arm64SVENonFaultingMemorySpecs covers all 16 Go 1.27 LDNF1 encoder forms:
+// natural-width and widening unsigned loads plus the widening signed forms.
+var arm64SVENonFaultingMemorySpecs = map[Op]arm64SVENonFaultingMemorySpec{
+	"ZLDNF1B":  {memoryBits: 8},
+	"ZLDNF1H":  {memoryBits: 16},
+	"ZLDNF1W":  {memoryBits: 32},
+	"ZLDNF1D":  {memoryBits: 64},
+	"ZLDNF1SB": {memoryBits: 8, signed: true},
+	"ZLDNF1SH": {memoryBits: 16, signed: true},
+	"ZLDNF1SW": {memoryBits: 32, signed: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVENonFaultingMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVENonFaultingMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s expects memory, predicate, vector-list operands: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	vectors, elementBits, vectorsOK := arm64ParseSVEConsecutiveVectorList(ins.Args[2])
+	if !predicateOK || !vectorsOK || len(vectors) != 1 || elementBits < spec.memoryBits || spec.signed && elementBits == spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s has predicate or destination widths outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVEVLAddress(ins.Args[0].Mem, -8, 7, int64(16*spec.memoryBits/elementBits))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldnf1.nxv%di%d(%s %s, ptr %%%s)\n",
+		loaded, loadedType, lanes, spec.memoryBits, predicateType, predicateValue, pointer)
+	value := "%" + loaded
+	if spec.memoryBits < elementBits {
+		vectorType, _, err := arm64SVEVectorType(elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		extended := c.newTmp()
+		extension := "zext"
+		if spec.signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, loadedType, value, vectorType)
+		value = "%" + extended
+	}
+	return true, false, c.storeZRegElements(vectors[0], elementBits, value)
+}
diff --git a/arm64_lower_sve_non_faulting_memory_test.go b/arm64_lower_sve_non_faulting_memory_test.go
new file mode 100644
index 000000000..58bd08914
--- /dev/null
+++ b/arm64_lower_sve_non_faulting_memory_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVENonFaultingMemoryCompleteGo127Forms() string {
+	return `TEXT svenonfaultingmemoryforms(SB),$0-0
+	ZLDNF1B (-VL*8)(R14), P4.Z, [Z13.B]
+	ZLDNF1B (VL*7)(RSP), P3.Z, [Z12.H]
+	ZLDNF1B (VL*0)(R4), P2.Z, [Z11.S]
+	ZLDNF1B (-VL*2)(R5), P1.Z, [Z10.D]
+	ZLDNF1H (VL*7)(R14), P4.Z, [Z13.H]
+	ZLDNF1H (-VL*8)(RSP), P3.Z, [Z12.S]
+	ZLDNF1H (VL*0)(R4), P2.Z, [Z11.D]
+	ZLDNF1W (-VL*8)(R14), P4.Z, [Z13.S]
+	ZLDNF1W (VL*7)(RSP), P3.Z, [Z12.D]
+	ZLDNF1D (-VL*8)(R14), P4.Z, [Z13.D]
+	ZLDNF1SB (VL*7)(RSP), P3.Z, [Z12.H]
+	ZLDNF1SB (VL*0)(R4), P2.Z, [Z11.S]
+	ZLDNF1SB (-VL*2)(R5), P1.Z, [Z10.D]
+	ZLDNF1SH (VL*7)(R14), P4.Z, [Z13.S]
+	ZLDNF1SH (-VL*8)(RSP), P3.Z, [Z12.D]
+	ZLDNF1SW (VL*0)(R4), P2.Z, [Z11.D]
+	RET
+`
+}
+
+func TestTranslateARM64SVENonFaultingMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVENonFaultingMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svenonfaultingmemoryforms": {Name: "svenonfaultingmemoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.ldnf1.nxv16i8",
+				"@llvm.aarch64.sve.ldnf1.nxv8i16",
+				"@llvm.aarch64.sve.ldnf1.nxv4i32",
+				"@llvm.aarch64.sve.ldnf1.nxv2i64",
+				" sext <vscale x ",
+				" zext <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE non-faulting memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-non-faulting-memory.ll", "arm64-sve-non-faulting-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVENonFaultingMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLDNF1B (R14), P8.Z, [Z13.B]",
+		"ZLDNF1B (R14), P4, [Z13.B]",
+		"ZLDNF1B (R14), P4.Z, [Z13.B, Z14.B]",
+		"ZLDNF1H (R14), P4.Z, [Z13.B]",
+		"ZLDNF1W (R14), P4.Z, [Z13.H]",
+		"ZLDNF1D (R14), P4.Z, [Z13.S]",
+		"ZLDNF1SB (R14), P4.Z, [Z13.B]",
+		"ZLDNF1SH (R14), P4.Z, [Z13.H]",
+		"ZLDNF1SW (R14), P4.Z, [Z13.S]",
+		"ZLDNF1B (R6)(R14), P4.Z, [Z13.B]",
+		"ZLDNF1B (-VL*9)(R14), P4.Z, [Z13.B]",
+		"ZLDNF1B (VL*8)(R14), P4.Z, [Z13.B]",
+		"ZLDNF1B 6(R14), P4.Z, [Z13.B]",
+		"ZLDNF1B.Z (R14), P4.Z, [Z13.B]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvenonfaultingmemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvenonfaultingmemory": {Name: "badsvenonfaultingmemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's non-faulting memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_non_temporal_memory.go b/arm64_lower_sve_non_temporal_memory.go
new file mode 100644
index 000000000..f303e55bd
--- /dev/null
+++ b/arm64_lower_sve_non_temporal_memory.go
@@ -0,0 +1,320 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVENonTemporalMemorySpec struct {
+	load       bool
+	memoryBits int
+	signed     bool
+}
+
+// arm64SVENonTemporalMemorySpecs covers every Go 1.27 LDNT1/STNT1 spelling:
+// the ordinary B/H/W/D operations and the sign-extending gather loads.
+var arm64SVENonTemporalMemorySpecs = map[Op]arm64SVENonTemporalMemorySpec{
+	"ZLDNT1B":  {load: true, memoryBits: 8},
+	"ZLDNT1H":  {load: true, memoryBits: 16},
+	"ZLDNT1W":  {load: true, memoryBits: 32},
+	"ZLDNT1D":  {load: true, memoryBits: 64},
+	"ZLDNT1SB": {load: true, memoryBits: 8, signed: true},
+	"ZLDNT1SH": {load: true, memoryBits: 16, signed: true},
+	"ZLDNT1SW": {load: true, memoryBits: 32, signed: true},
+	"ZSTNT1B":  {memoryBits: 8},
+	"ZSTNT1H":  {memoryBits: 16},
+	"ZSTNT1W":  {memoryBits: 32},
+	"ZSTNT1D":  {memoryBits: 64},
+}
+
+func arm64SVENonTemporalMemoryNeedsSVE2P1(ins Instr) bool {
+	if len(ins.Args) != 3 || ins.Args[1].Kind != OpReg {
+		return false
+	}
+	return strings.HasPrefix(strings.ToUpper(strings.TrimSpace(string(ins.Args[1].Reg))), "PN")
+}
+
+func (c *arm64Ctx) lowerARM64SVENonTemporalMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVENonTemporalMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects its three-operand Go 1.27 form: %q", op, ins.Raw)
+	}
+	if spec.load {
+		return c.lowerARM64SVENonTemporalLoad(op, spec, ins)
+	}
+	return c.lowerARM64SVENonTemporalStore(op, spec, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVENonTemporalLoad(op Op, spec arm64SVENonTemporalMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s requires memory, predicate, vector-list operands: %q", op, ins.Raw)
+	}
+	vectors, elementBits, vectorsOK := arm64ParseSVEConsecutiveVectorList(ins.Args[2])
+	if !vectorsOK {
+		return true, false, fmt.Errorf("arm64 %s requires a consecutive, uniformly arranged Z register list: %q", op, ins.Raw)
+	}
+	if predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7); predicateOK {
+		if len(vectors) != 1 {
+			return true, false, fmt.Errorf("arm64 %s ordinary predicate form requires one destination vector: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVENonTemporalSingleLoad(op, spec, ins.Args[0].Mem, predicate, vectors[0], elementBits, ins)
+	}
+	predicate, predicateOK := arm64ParseSVENonTemporalPN(ins.Args[1], true)
+	if !predicateOK || spec.signed || (len(vectors) != 2 && len(vectors) != 4) || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s PN/Z form requires PN8..PN15.Z and two or four same-width destination vectors: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(ins.Args[0].Mem, spec.memoryBits, len(vectors))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	counter, err := c.loadPNReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	aggregateType := arm64SVEAggregateType(vectorType, len(vectors))
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldnt1.pn.x%d.nxv%di%d(target(\"aarch64.svcount\") %s, ptr %%%s)\n",
+		result, aggregateType, len(vectors), 128/elementBits, elementBits, counter, pointer)
+	for i, vector := range vectors {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, aggregateType, result, i)
+		if err := c.storeZRegElements(vector, elementBits, "%"+value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVENonTemporalSingleLoad(op Op, spec arm64SVENonTemporalMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	if vectorBase, vectorBaseBits, vectorBaseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorBaseOK {
+		if vectorBaseBits != elementBits || elementBits < spec.memoryBits || (elementBits != 32 && elementBits != 64) || !arm64SVENonTemporalVectorBaseAddressOK(memory) {
+			return true, false, fmt.Errorf("arm64 %s vector-base form has widths or address operands outside its Go 1.27 table: %q", op, ins.Raw)
+		}
+		bases, baseType, err := c.loadZRegElements(vectorBase, vectorBaseBits)
+		if err != nil {
+			return true, false, err
+		}
+		offset, err := c.loadReg(memory.Base)
+		if err != nil {
+			return true, false, err
+		}
+		loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldnt1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s %s, %s %s, i64 %s)\n",
+			loaded, loadedType, lanes, spec.memoryBits, lanes, elementBits, predicateType, predicateValue, baseType, bases, offset)
+		value := "%" + loaded
+		if spec.memoryBits < elementBits {
+			extended := c.newTmp()
+			extension := "zext"
+			if spec.signed {
+				extension = "sext"
+			}
+			vectorType, _, _ := arm64SVEVectorType(elementBits)
+			fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, loadedType, value, vectorType)
+			value = "%" + extended
+		}
+		return true, false, c.storeZRegElements(destination, elementBits, value)
+	}
+	if spec.signed || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s contiguous form requires its natural %d-bit arrangement: %q", op, spec.memoryBits, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(memory, spec.memoryBits, 1)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	vectorType, _, _ := arm64SVEVectorType(elementBits)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ldnt1.nxv%di%d(%s %s, ptr %%%s)\n",
+		result, vectorType, lanes, elementBits, predicateType, predicateValue, pointer)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVENonTemporalStore(op Op, spec arm64SVENonTemporalMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpRegList || ins.Args[2].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s requires vector-list, predicate, memory operands: %q", op, ins.Raw)
+	}
+	vectors, elementBits, vectorsOK := arm64ParseSVEConsecutiveVectorList(ins.Args[0])
+	if !vectorsOK {
+		return true, false, fmt.Errorf("arm64 %s requires a consecutive, uniformly arranged Z register list: %q", op, ins.Raw)
+	}
+	if predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7); predicateOK {
+		if len(vectors) != 1 {
+			return true, false, fmt.Errorf("arm64 %s ordinary predicate form requires one source vector: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVENonTemporalSingleStore(op, spec, ins.Args[2].Mem, predicate, vectors[0], elementBits, ins)
+	}
+	predicate, predicateOK := arm64ParseSVENonTemporalPN(ins.Args[1], false)
+	if !predicateOK || (len(vectors) != 2 && len(vectors) != 4) || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s PN form requires PN8..PN15 and two or four same-width source vectors: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(ins.Args[2].Mem, spec.memoryBits, len(vectors))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	counter, err := c.loadPNReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	values := make([]string, 0, len(vectors))
+	for _, vector := range vectors {
+		value, _, err := c.loadZRegElements(vector, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		values = append(values, fmt.Sprintf("%s %s", vectorType, value))
+	}
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.stnt1.pn.x%d.nxv%di%d(%s, target(\"aarch64.svcount\") %s, ptr %%%s)\n",
+		len(vectors), 128/elementBits, elementBits, strings.Join(values, ", "), counter, pointer)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVENonTemporalSingleStore(op Op, spec arm64SVENonTemporalMemorySpec, memory MemRef, predicate, source, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if elementBits < spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s source arrangement is narrower than its memory element: %q", op, ins.Raw)
+	}
+	value, vectorType, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	if vectorBase, vectorBaseBits, vectorBaseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorBaseOK {
+		if vectorBaseBits != elementBits || (elementBits != 32 && elementBits != 64) || !arm64SVENonTemporalVectorBaseAddressOK(memory) {
+			return true, false, fmt.Errorf("arm64 %s vector-base form has widths or address operands outside its Go 1.27 table: %q", op, ins.Raw)
+		}
+		bases, baseType, err := c.loadZRegElements(vectorBase, vectorBaseBits)
+		if err != nil {
+			return true, false, err
+		}
+		offset, err := c.loadReg(memory.Base)
+		if err != nil {
+			return true, false, err
+		}
+		storedType := vectorType
+		stored := value
+		if spec.memoryBits < elementBits {
+			storedType = fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+			truncated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", truncated, vectorType, value, storedType)
+			stored = "%" + truncated
+		}
+		fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.stnt1.scatter.scalar.offset.nxv%di%d.nxv%di%d(%s %s, %s %s, %s %s, i64 %s)\n",
+			lanes, spec.memoryBits, lanes, elementBits, storedType, stored, predicateType, predicateValue, baseType, bases, offset)
+		return true, false, nil
+	}
+	if elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s contiguous form requires its natural %d-bit arrangement: %q", op, spec.memoryBits, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(memory, spec.memoryBits, 1)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.stnt1.nxv%di%d(%s %s, %s %s, ptr %%%s)\n",
+		lanes, elementBits, vectorType, value, predicateType, predicateValue, pointer)
+	return true, false, nil
+}
+
+func arm64ParseSVEConsecutiveVectorList(operand Operand) (vectors []int, elementBits int, ok bool) {
+	if operand.Kind != OpRegList || len(operand.RegList) == 0 {
+		return nil, 0, false
+	}
+	vectors = make([]int, len(operand.RegList))
+	for i, register := range operand.RegList {
+		vector, bits, valid := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: register})
+		if !valid || i > 0 && (bits != elementBits || vector != vectors[i-1]+1) {
+			return nil, 0, false
+		}
+		vectors[i] = vector
+		elementBits = bits
+	}
+	return vectors, elementBits, true
+}
+
+func arm64ParseSVENonTemporalPN(operand Operand, zeroing bool) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	wantSuffix := ""
+	if zeroing {
+		wantSuffix = ".Z"
+	}
+	if !strings.HasSuffix(text, wantSuffix) {
+		return 0, false
+	}
+	name := strings.TrimSuffix(text, wantSuffix)
+	if strings.Contains(name, ".") || !strings.HasPrefix(name, "PN") {
+		return 0, false
+	}
+	var index int
+	if _, err := fmt.Sscanf(name, "PN%d", &index); err != nil || index < 8 || index > 15 {
+		return 0, false
+	}
+	return index, true
+}
+
+func arm64SVENonTemporalVectorBaseAddressOK(memory MemRef) bool {
+	return memory.Sym == "" && memory.Segment == "" && memory.Off == 0 && memory.OffRaw == "" && memory.IndexExt == "" && memory.Scale == 1 &&
+		isARM64GeneralOrZeroReg(memory.Base) && memory.Base != SP && memory.Base != Reg("RSP")
+}
+
+func (c *arm64Ctx) arm64SVENonTemporalContiguousAddress(memory MemRef, elementBits, vectorCount int) (string, error) {
+	if memory.Index != "" {
+		if _, _, vectorIndex := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorIndex {
+			return "", fmt.Errorf("contiguous form does not accept a scalable-vector base")
+		}
+		return c.arm64SVERegisterOffsetAddress(memory, int64(elementBits/8))
+	}
+	minimum, maximum := int64(-8), int64(7)
+	if vectorCount == 2 {
+		minimum, maximum = -16, 14
+	} else if vectorCount == 3 {
+		minimum, maximum = -24, 21
+	} else if vectorCount == 4 {
+		minimum, maximum = -32, 28
+	} else if vectorCount != 1 {
+		return "", fmt.Errorf("contiguous form requires one, two, three, or four vectors")
+	}
+	if memory.OffRaw != "" {
+		multiplier, parsed := parseVectorLengthScaleExpr(memory.OffRaw)
+		if !parsed || multiplier%int64(vectorCount) != 0 {
+			return "", fmt.Errorf("MUL VL immediate must be a multiple of %d", vectorCount)
+		}
+	}
+	return c.arm64SVEVLAddress(memory, minimum, maximum, 16)
+}
+
+func arm64SVEAggregateType(vectorType string, count int) string {
+	values := make([]string, count)
+	for i := range values {
+		values[i] = vectorType
+	}
+	return "{ " + strings.Join(values, ", ") + " }"
+}
diff --git a/arm64_lower_sve_non_temporal_memory_test.go b/arm64_lower_sve_non_temporal_memory_test.go
new file mode 100644
index 000000000..59b88ddea
--- /dev/null
+++ b/arm64_lower_sve_non_temporal_memory_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVENonTemporalMemoryCompleteGo127Forms() string {
+	return `TEXT svenontemporalmemoryforms(SB),$0-0
+	ZLDNT1B (R6)(R14), P4.Z, [Z13.B]
+	ZLDNT1B (R6)(Z7.S), P4.Z, [Z13.S]
+	ZLDNT1B (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1B (-VL*2)(R14), P4.Z, [Z13.B]
+	ZLDNT1B (R5)(R27), PN12.Z, [Z6.B-Z7.B]
+	ZLDNT1B (R2)(R3), PN10.Z, [Z24.B-Z27.B]
+	ZLDNT1B (-VL*6)(R3), PN10.Z, [Z24.B-Z25.B]
+	ZLDNT1B (VL*4)(RSP), PN10.Z, [Z16.B-Z19.B]
+	ZLDNT1H (R6<<1)(R14), P4.Z, [Z13.H]
+	ZLDNT1H (R6)(Z7.S), P4.Z, [Z13.S]
+	ZLDNT1H (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1H (-VL*2)(R14), P4.Z, [Z13.H]
+	ZLDNT1H (R5<<1)(R27), PN12.Z, [Z6.H-Z7.H]
+	ZLDNT1H (R2<<1)(R3), PN10.Z, [Z24.H-Z27.H]
+	ZLDNT1H (-VL*6)(R3), PN10.Z, [Z24.H-Z25.H]
+	ZLDNT1H (VL*4)(RSP), PN10.Z, [Z16.H-Z19.H]
+	ZLDNT1W (R6<<2)(R14), P4.Z, [Z13.S]
+	ZLDNT1W (R6)(Z7.S), P4.Z, [Z13.S]
+	ZLDNT1W (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1W (-VL*2)(R14), P4.Z, [Z13.S]
+	ZLDNT1W (R5<<2)(R27), PN12.Z, [Z6.S-Z7.S]
+	ZLDNT1W (R2<<2)(R3), PN10.Z, [Z24.S-Z27.S]
+	ZLDNT1W (-VL*6)(R3), PN10.Z, [Z24.S-Z25.S]
+	ZLDNT1W (VL*4)(RSP), PN10.Z, [Z16.S-Z19.S]
+	ZLDNT1D (R6<<3)(R14), P4.Z, [Z13.D]
+	ZLDNT1D (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1D (-VL*2)(R14), P4.Z, [Z13.D]
+	ZLDNT1D (-VL*8)(R14), P4.Z, [Z12.D]
+	ZLDNT1D (VL*7)(R14), P4.Z, [Z11.D]
+	ZLDNT1D (R5<<3)(R27), PN12.Z, [Z6.D-Z7.D]
+	ZLDNT1D (R2<<3)(R3), PN10.Z, [Z24.D-Z27.D]
+	ZLDNT1D (-VL*6)(R3), PN10.Z, [Z24.D-Z25.D]
+	ZLDNT1D (-VL*16)(R3), PN10.Z, [Z20.D-Z21.D]
+	ZLDNT1D (VL*14)(R3), PN10.Z, [Z18.D-Z19.D]
+	ZLDNT1D (VL*4)(RSP), PN10.Z, [Z16.D-Z19.D]
+	ZLDNT1D (-VL*32)(RSP), PN10.Z, [Z8.D-Z11.D]
+	ZLDNT1D (VL*28)(RSP), PN10.Z, [Z12.D-Z15.D]
+	ZLDNT1SB (R6)(Z7.S), P4.Z, [Z13.S]
+	ZLDNT1SB (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1SH (R6)(Z7.S), P4.Z, [Z13.S]
+	ZLDNT1SH (R6)(Z7.D), P4.Z, [Z13.D]
+	ZLDNT1SW (R6)(Z7.D), P4.Z, [Z13.D]
+	ZSTNT1B [Z8.B], P3, (R6)(RSP)
+	ZSTNT1B [Z8.S], P3, (R6)(Z15.S)
+	ZSTNT1B [Z8.D], P3, (R6)(Z15.D)
+	ZSTNT1B [Z8.B], P3, (-VL*2)(RSP)
+	ZSTNT1B [Z14.B-Z15.B], PN12, (R20)(R17)
+	ZSTNT1B [Z4.B-Z7.B], PN12, (R12)(RSP)
+	ZSTNT1B [Z14.B-Z15.B], PN12, (-VL*4)(R17)
+	ZSTNT1B [Z4.B-Z7.B], PN12, (VL*4)(RSP)
+	ZSTNT1H [Z8.H], P3, (R6<<1)(RSP)
+	ZSTNT1H [Z8.S], P3, (R6)(Z15.S)
+	ZSTNT1H [Z8.D], P3, (R6)(Z15.D)
+	ZSTNT1H [Z8.H], P3, (-VL*2)(RSP)
+	ZSTNT1H [Z14.H-Z15.H], PN12, (R20<<1)(R17)
+	ZSTNT1H [Z4.H-Z7.H], PN12, (R12<<1)(RSP)
+	ZSTNT1H [Z14.H-Z15.H], PN12, (-VL*4)(R17)
+	ZSTNT1H [Z4.H-Z7.H], PN12, (VL*4)(RSP)
+	ZSTNT1W [Z8.S], P3, (R6<<2)(RSP)
+	ZSTNT1W [Z8.S], P3, (R6)(Z15.S)
+	ZSTNT1W [Z8.D], P3, (R6)(Z15.D)
+	ZSTNT1W [Z8.S], P3, (-VL*2)(RSP)
+	ZSTNT1W [Z14.S-Z15.S], PN12, (R20<<2)(R17)
+	ZSTNT1W [Z4.S-Z7.S], PN12, (R12<<2)(RSP)
+	ZSTNT1W [Z14.S-Z15.S], PN12, (-VL*4)(R17)
+	ZSTNT1W [Z4.S-Z7.S], PN12, (VL*4)(RSP)
+	ZSTNT1D [Z8.D], P3, (R6<<3)(RSP)
+	ZSTNT1D [Z8.D], P3, (R6)(Z15.D)
+	ZSTNT1D [Z8.D], P3, (-VL*2)(RSP)
+	ZSTNT1D [Z8.D], P3, (-VL*8)(RSP)
+	ZSTNT1D [Z8.D], P3, (VL*7)(RSP)
+	ZSTNT1D [Z14.D-Z15.D], PN12, (R20<<3)(R17)
+	ZSTNT1D [Z4.D-Z7.D], PN12, (R12<<3)(RSP)
+	ZSTNT1D [Z14.D-Z15.D], PN12, (-VL*4)(R17)
+	ZSTNT1D [Z14.D-Z15.D], PN12, (-VL*16)(R17)
+	ZSTNT1D [Z14.D-Z15.D], PN12, (VL*14)(R17)
+	ZSTNT1D [Z4.D-Z7.D], PN12, (VL*4)(RSP)
+	ZSTNT1D [Z4.D-Z7.D], PN12, (-VL*32)(RSP)
+	ZSTNT1D [Z4.D-Z7.D], PN12, (VL*28)(RSP)
+	RET
+`
+}
+
+func TestTranslateARM64SVENonTemporalMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVENonTemporalMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svenontemporalmemoryforms": {Name: "svenontemporalmemoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.ldnt1.nxv",
+				"@llvm.aarch64.sve.ldnt1.gather.scalar.offset.",
+				"@llvm.aarch64.sve.ldnt1.pn.x2.",
+				"@llvm.aarch64.sve.ldnt1.pn.x4.",
+				"@llvm.aarch64.sve.stnt1.nxv",
+				"@llvm.aarch64.sve.stnt1.scatter.scalar.offset.",
+				"@llvm.aarch64.sve.stnt1.pn.x2.",
+				"@llvm.aarch64.sve.stnt1.pn.x4.",
+				" sext <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE non-temporal memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-non-temporal-memory.ll", "arm64-sve-non-temporal-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVENonTemporalMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLDNT1B (R6)(R14), P8.Z, [Z13.B]",
+		"ZLDNT1D (R6<<2)(R14), P4.Z, [Z13.D]",
+		"ZLDNT1SB (R6)(Z7.S), P4.Z, [Z13.D]",
+		"ZLDNT1W (R5<<2)(R27), PN7.Z, [Z6.S-Z7.S]",
+		"ZLDNT1W (R5<<2)(R27), PN12.Z, [Z6.S-Z8.S]",
+		"ZSTNT1H [Z8.H], P8, (R6<<1)(RSP)",
+		"ZSTNT1W [Z14.S-Z16.S], PN12, (R20<<2)(R17)",
+		"ZSTNT1D [Z8.D], P3, (R6<<2)(RSP)",
+		"ZSTNT1B [Z8.H], P3, (-VL*2)(RSP)",
+		"ZLDNT1D (-VL*9)(R14), P4.Z, [Z13.D]",
+		"ZLDNT1D (VL*3)(R3), PN10.Z, [Z24.D-Z25.D]",
+		"ZLDNT1D (VL*2)(RSP), PN10.Z, [Z16.D-Z19.D]",
+		"ZSTNT1D [Z8.D], P3, (VL*8)(RSP)",
+		"ZSTNT1D [Z14.D-Z15.D], PN12, (VL*16)(R17)",
+		"ZSTNT1D [Z4.D-Z7.D], PN12, (VL*32)(RSP)",
+		"ZSTNT1D.Z [Z8.D], P3, (-VL*2)(RSP)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvenontemporalmemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvenontemporalmemory": {Name: "badsvenontemporalmemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's non-temporal memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_optional_crypto.go b/arm64_lower_sve_optional_crypto.go
new file mode 100644
index 000000000..e09eb08fd
--- /dev/null
+++ b/arm64_lower_sve_optional_crypto.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEOptionalCryptoSpec struct {
+	intrinsic   string
+	elementBits int
+	destructive bool
+	feature     string
+}
+
+var arm64SVEOptionalCryptoSpecs = map[Op]arm64SVEOptionalCryptoSpec{
+	"ZRAX1":    {intrinsic: "rax1", elementBits: 64, feature: "+sve2-sha3"},
+	"ZSM4E":    {intrinsic: "sm4e", elementBits: 32, destructive: true, feature: "+sve2-sm4"},
+	"ZSM4EKEY": {intrinsic: "sm4ekey", elementBits: 32, feature: "+sve2-sm4"},
+}
+
+func (c *arm64Ctx) lowerARM64SVEOptionalCrypto(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEOptionalCryptoSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three vector operands without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || secondBits != spec.elementBits || firstBits != spec.elementBits || destinationBits != spec.elementBits || spec.destructive && first != destination {
+		return true, false, fmt.Errorf("arm64 %s requires matching %d-bit vectors%s: %q", op, spec.elementBits, map[bool]string{true: " with repeated source/destination", false: ""}[spec.destructive], ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, spec.elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, spec.elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s(%s %s, %s %s)\n", result, vectorType, spec.intrinsic, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, spec.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_optional_crypto_test.go b/arm64_lower_sve_optional_crypto_test.go
new file mode 100644
index 000000000..ae9b4362d
--- /dev/null
+++ b/arm64_lower_sve_optional_crypto_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEOptionalCryptoCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT sveoptionalcrypto(SB),$0-0
+	ZRAX1 Z1.D, Z2.D, Z3.D
+	ZSM4E Z4.S, Z5.S, Z5.S
+	ZSM4EKEY Z6.S, Z7.S, Z8.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveoptionalcrypto": {Name: "sveoptionalcrypto", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve2-sha3,+sve2-sm4"`, "@llvm.aarch64.sve.rax1", "@llvm.aarch64.sve.sm4e", "@llvm.aarch64.sve.sm4ekey"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE optional crypto lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-optional-crypto.ll", "arm64-sve-optional-crypto.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEOptionalCryptoRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZRAX1 Z1.S, Z2.S, Z3.S",
+		"ZRAX1 Z1.D, Z2.D",
+		"ZSM4E Z1.S, Z2.S, Z3.S",
+		"ZSM4E Z1.D, Z2.D, Z2.D",
+		"ZSM4EKEY Z1.S, Z2.S, Z3.D",
+		"ZSM4EKEY.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveoptionalcrypto(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveoptionalcrypto": {Name: "badsveoptionalcrypto", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE optional crypto forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_ordinary_memory.go b/arm64_lower_sve_ordinary_memory.go
new file mode 100644
index 000000000..acab85dce
--- /dev/null
+++ b/arm64_lower_sve_ordinary_memory.go
@@ -0,0 +1,525 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64SVEOrdinaryMemorySpec struct {
+	load       bool
+	memoryBits int
+	signed     bool
+	qOnly      bool
+}
+
+// arm64SVEOrdinaryMemorySpecs covers the complete Go 1.27 LD1/ST1 family:
+// ordinary and widening loads, truncating stores, Q-granule forms, and the
+// SVE2.1 two-/four-vector PN forms.
+var arm64SVEOrdinaryMemorySpecs = map[Op]arm64SVEOrdinaryMemorySpec{
+	"ZLD1B":  {load: true, memoryBits: 8},
+	"ZLD1H":  {load: true, memoryBits: 16},
+	"ZLD1W":  {load: true, memoryBits: 32},
+	"ZLD1D":  {load: true, memoryBits: 64},
+	"ZLD1Q":  {load: true, memoryBits: 128, qOnly: true},
+	"ZLD1SB": {load: true, memoryBits: 8, signed: true},
+	"ZLD1SH": {load: true, memoryBits: 16, signed: true},
+	"ZLD1SW": {load: true, memoryBits: 32, signed: true},
+	"ZST1B":  {memoryBits: 8},
+	"ZST1H":  {memoryBits: 16},
+	"ZST1W":  {memoryBits: 32},
+	"ZST1D":  {memoryBits: 64},
+	"ZST1Q":  {memoryBits: 128, qOnly: true},
+}
+
+func arm64SVEOrdinaryMemoryNeedsSVE2P1(ins Instr) bool {
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && strings.HasPrefix(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), "PN") {
+			return true
+		}
+		if operand.Kind == OpRegList {
+			for _, register := range operand.RegList {
+				if strings.HasSuffix(strings.ToUpper(strings.TrimSpace(string(register))), ".Q") {
+					return true
+				}
+			}
+		}
+	}
+	op := Op(strings.ToUpper(string(ins.Op)))
+	return op == "ZLD1Q" || op == "ZST1Q"
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEOrdinaryMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects its three-operand Go 1.27 form: %q", op, ins.Raw)
+	}
+	if spec.load {
+		return c.lowerARM64SVEOrdinaryLoad(op, spec, ins)
+	}
+	return c.lowerARM64SVEOrdinaryStore(op, spec, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryLoad(op Op, spec arm64SVEOrdinaryMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s requires memory, predicate, vector-list operands: %q", op, ins.Raw)
+	}
+	vectors, elementBits, vectorsOK := arm64ParseSVEOrdinaryVectorList(ins.Args[2])
+	if !vectorsOK {
+		return true, false, fmt.Errorf("arm64 %s requires a consecutive, uniformly arranged Z register list: %q", op, ins.Raw)
+	}
+	if predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7); predicateOK {
+		if len(vectors) != 1 {
+			return true, false, fmt.Errorf("arm64 %s ordinary predicate form requires one destination vector: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVEOrdinarySingleLoad(op, spec, ins.Args[0].Mem, predicate, vectors[0], elementBits, ins)
+	}
+	predicate, predicateOK := arm64ParseSVENonTemporalPN(ins.Args[1], true)
+	if !predicateOK || spec.signed || spec.qOnly || (len(vectors) != 2 && len(vectors) != 4) || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s PN/Z form requires PN8..PN15.Z and two or four natural-width destination vectors: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(ins.Args[0].Mem, spec.memoryBits, len(vectors))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	counter, err := c.loadPNReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	aggregateType := arm64SVEAggregateType(vectorType, len(vectors))
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1.pn.x%d.nxv%di%d(target(\"aarch64.svcount\") %s, ptr %%%s)\n",
+		result, aggregateType, len(vectors), 128/elementBits, elementBits, counter, pointer)
+	for i, vector := range vectors {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, aggregateType, result, i)
+		if err := c.storeZRegElements(vector, elementBits, "%"+value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinarySingleLoad(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if spec.qOnly {
+		return c.lowerARM64SVEOrdinaryQGatherLoad(op, memory, predicate, destination, elementBits, ins)
+	}
+	if elementBits == 128 {
+		if spec.signed || (spec.memoryBits != 32 && spec.memoryBits != 64) {
+			return true, false, fmt.Errorf("arm64 %s Q arrangement is outside its Go 1.27 table: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVEOrdinaryQContiguousLoad(op, spec, memory, predicate, destination, ins)
+	}
+	if elementBits < spec.memoryBits || spec.signed && elementBits == spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s destination width is outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+	if _, _, vectorOffset := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorOffset {
+		return c.lowerARM64SVEOrdinaryVectorOffsetLoad(op, spec, memory, predicate, destination, elementBits, ins)
+	}
+	if _, _, vectorBase := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base}); vectorBase {
+		return c.lowerARM64SVEOrdinaryVectorBaseLoad(op, spec, memory, predicate, destination, elementBits, ins)
+	}
+	address, err := c.arm64SVEOrdinaryContiguousAddress(memory, spec.memoryBits, elementBits)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1.nxv%di%d(%s %s, ptr %%%s)\n",
+		loaded, loadedType, lanes, spec.memoryBits, predicateType, predicateValue, pointer)
+	return c.finishARM64SVEOrdinaryLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryVectorOffsetLoad(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	pointer, indexValue, indexType, suffix, err := c.arm64SVEOrdinaryVectorOffset(op, memory, elementBits, spec.memoryBits, ins)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1.gather%s.nxv%di%d(%s %s, ptr %s, %s %s)\n",
+		loaded, loadedType, suffix, lanes, spec.memoryBits, predicateType, predicateValue, pointer, indexType, indexValue)
+	return c.finishARM64SVEOrdinaryLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryVectorBaseLoad(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	baseValue, baseType, err := c.arm64SVEOrdinaryVectorBase(op, memory, elementBits, spec.memoryBits, ins)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	loadedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, spec.memoryBits)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s %s, %s %s, i64 %d)\n",
+		loaded, loadedType, lanes, spec.memoryBits, lanes, elementBits, predicateType, predicateValue, baseType, baseValue, memory.Off)
+	return c.finishARM64SVEOrdinaryLoad(spec, destination, elementBits, loadedType, "%"+loaded)
+}
+
+func (c *arm64Ctx) finishARM64SVEOrdinaryLoad(spec arm64SVEOrdinaryMemorySpec, destination, elementBits int, loadedType, loaded string) (ok bool, terminated bool, err error) {
+	value := loaded
+	if spec.memoryBits < elementBits {
+		vectorType, _, err := arm64SVEVectorType(elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		extended := c.newTmp()
+		extension := "zext"
+		if spec.signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", extended, extension, loadedType, value, vectorType)
+		value = "%" + extended
+	}
+	return true, false, c.storeZRegElements(destination, elementBits, value)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryStore(op Op, spec arm64SVEOrdinaryMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpRegList || ins.Args[2].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s requires vector-list, predicate, memory operands: %q", op, ins.Raw)
+	}
+	vectors, elementBits, vectorsOK := arm64ParseSVEOrdinaryVectorList(ins.Args[0])
+	if !vectorsOK {
+		return true, false, fmt.Errorf("arm64 %s requires a consecutive, uniformly arranged Z register list: %q", op, ins.Raw)
+	}
+	if predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7); predicateOK {
+		if len(vectors) != 1 {
+			return true, false, fmt.Errorf("arm64 %s ordinary predicate form requires one source vector: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVEOrdinarySingleStore(op, spec, ins.Args[2].Mem, predicate, vectors[0], elementBits, ins)
+	}
+	predicate, predicateOK := arm64ParseSVENonTemporalPN(ins.Args[1], false)
+	if !predicateOK || spec.qOnly || (len(vectors) != 2 && len(vectors) != 4) || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s PN form requires PN8..PN15 and two or four natural-width source vectors: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVENonTemporalContiguousAddress(ins.Args[2].Mem, spec.memoryBits, len(vectors))
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	counter, err := c.loadPNReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	values := make([]string, 0, len(vectors))
+	for _, vector := range vectors {
+		value, _, err := c.loadZRegElements(vector, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		values = append(values, fmt.Sprintf("%s %s", vectorType, value))
+	}
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st1.pn.x%d.nxv%di%d(%s, target(\"aarch64.svcount\") %s, ptr %%%s)\n",
+		len(vectors), 128/elementBits, elementBits, strings.Join(values, ", "), counter, pointer)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinarySingleStore(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, source, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if spec.qOnly {
+		return c.lowerARM64SVEOrdinaryQScatterStore(op, memory, predicate, source, elementBits, ins)
+	}
+	if elementBits == 128 {
+		if spec.memoryBits != 32 && spec.memoryBits != 64 {
+			return true, false, fmt.Errorf("arm64 %s Q arrangement is outside its Go 1.27 table: %q", op, ins.Raw)
+		}
+		return c.lowerARM64SVEOrdinaryQContiguousStore(op, spec, memory, predicate, source, ins)
+	}
+	if elementBits < spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s source arrangement is narrower than its memory element: %q", op, ins.Raw)
+	}
+	value, vectorType, err := c.loadZRegElements(source, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	storedType, stored := arm64SVETruncateStoreValue(c, value, vectorType, lanes, spec.memoryBits, elementBits)
+	if _, _, vectorOffset := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorOffset {
+		pointer, indexValue, indexType, suffix, err := c.arm64SVEOrdinaryVectorOffset(op, memory, elementBits, spec.memoryBits, ins)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st1.scatter%s.nxv%di%d(%s %s, %s %s, ptr %s, %s %s)\n",
+			suffix, lanes, spec.memoryBits, storedType, stored, predicateType, predicateValue, pointer, indexType, indexValue)
+		return true, false, nil
+	}
+	if _, _, vectorBase := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base}); vectorBase {
+		baseValue, baseType, err := c.arm64SVEOrdinaryVectorBase(op, memory, elementBits, spec.memoryBits, ins)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st1.scatter.scalar.offset.nxv%di%d.nxv%di%d(%s %s, %s %s, %s %s, i64 %d)\n",
+			lanes, spec.memoryBits, lanes, elementBits, storedType, stored, predicateType, predicateValue, baseType, baseValue, memory.Off)
+		return true, false, nil
+	}
+	address, err := c.arm64SVEOrdinaryContiguousAddress(memory, spec.memoryBits, elementBits)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st1.nxv%di%d(%s %s, %s %s, ptr %%%s)\n",
+		lanes, spec.memoryBits, storedType, stored, predicateType, predicateValue, pointer)
+	return true, false, nil
+}
+
+func arm64SVETruncateStoreValue(c *arm64Ctx, value, vectorType string, lanes, memoryBits, elementBits int) (storedType, stored string) {
+	storedType, stored = vectorType, value
+	if memoryBits < elementBits {
+		storedType = fmt.Sprintf("<vscale x %d x i%d>", lanes, memoryBits)
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", truncated, vectorType, value, storedType)
+		stored = "%" + truncated
+	}
+	return storedType, stored
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryQContiguousLoad(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, destination int, ins Instr) (ok bool, terminated bool, err error) {
+	address, err := c.arm64SVEOrdinaryContiguousAddress(memory, spec.memoryBits, 128)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	predicateValue, err := c.loadARM64SVEQPredicate(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, lanes, _ := arm64SVEVectorType(spec.memoryBits)
+	intrinsic := map[int]string{32: "ld1uwq", 64: "ld1udq"}[spec.memoryBits]
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(<vscale x 1 x i1> %s, ptr %%%s)\n",
+		loaded, vectorType, intrinsic, lanes, spec.memoryBits, predicateValue, pointer)
+	return true, false, c.storeZRegElements(destination, spec.memoryBits, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryQContiguousStore(op Op, spec arm64SVEOrdinaryMemorySpec, memory MemRef, predicate, source int, ins Instr) (ok bool, terminated bool, err error) {
+	address, err := c.arm64SVEOrdinaryContiguousAddress(memory, spec.memoryBits, 128)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	value, vectorType, err := c.loadZRegElements(source, spec.memoryBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, err := c.loadARM64SVEQPredicate(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / spec.memoryBits
+	intrinsic := map[int]string{32: "st1wq", 64: "st1dq"}[spec.memoryBits]
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.%s.nxv%di%d(%s %s, <vscale x 1 x i1> %s, ptr %%%s)\n",
+		intrinsic, lanes, spec.memoryBits, vectorType, value, predicateValue, pointer)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryQGatherLoad(op Op, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if elementBits != 128 || memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" || memory.IndexExt != "" || memory.Scale != 1 {
+		return true, false, fmt.Errorf("arm64 %s requires vector D bases, a scalar register offset, and a Q destination: %q", op, ins.Raw)
+	}
+	bases, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	if !baseOK || baseBits != 64 || !isARM64GeneralOrZeroReg(memory.Base) || memory.Base == ZR || memory.Base == SP || memory.Base == Reg("RSP") {
+		return true, false, fmt.Errorf("arm64 %s requires Zn.D bases and R0..R30 offset: %q", op, ins.Raw)
+	}
+	offset, err := c.loadReg(memory.Base)
+	if err != nil {
+		return true, false, err
+	}
+	return c.emitARM64SVEOrdinaryQGatherLoad(bases, predicate, destination, offset)
+}
+
+func (c *arm64Ctx) emitARM64SVEOrdinaryQGatherLoad(bases, predicate, destination int, offset string) (bool, bool, error) {
+	baseValue, baseType, err := c.loadZRegElements(bases, 64)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, err := c.loadARM64SVEQPredicate(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1q.gather.scalar.offset.nxv2i64.nxv2i64(<vscale x 1 x i1> %s, %s %s, i64 %s)\n",
+		loaded, baseType, predicateValue, baseType, baseValue, offset)
+	return true, false, c.storeZRegElements(destination, 64, "%"+loaded)
+}
+
+func (c *arm64Ctx) lowerARM64SVEOrdinaryQScatterStore(op Op, memory MemRef, predicate, source, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if elementBits != 128 || memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" || memory.IndexExt != "" || memory.Scale != 1 {
+		return true, false, fmt.Errorf("arm64 %s requires a Q source, vector D bases, and a scalar register offset: %q", op, ins.Raw)
+	}
+	bases, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	if !baseOK || baseBits != 64 || !isARM64GeneralOrZeroReg(memory.Base) || memory.Base == ZR || memory.Base == SP || memory.Base == Reg("RSP") {
+		return true, false, fmt.Errorf("arm64 %s requires Zn.D bases and R0..R30 offset: %q", op, ins.Raw)
+	}
+	baseValue, baseType, err := c.loadZRegElements(bases, 64)
+	if err != nil {
+		return true, false, err
+	}
+	offset, err := c.loadReg(memory.Base)
+	if err != nil {
+		return true, false, err
+	}
+	value, vectorType, err := c.loadZRegElements(source, 64)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, err := c.loadARM64SVEQPredicate(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st1q.scatter.scalar.offset.nxv2i64.nxv2i64(%s %s, <vscale x 1 x i1> %s, %s %s, i64 %s)\n",
+		vectorType, value, predicateValue, baseType, baseValue, offset)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) loadARM64SVEQPredicate(predicate int) (string, error) {
+	value, err := c.loadPReg(predicate)
+	if err != nil {
+		return "", err
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1> %s)\n", converted, value)
+	return "%" + converted, nil
+}
+
+func (c *arm64Ctx) arm64SVEOrdinaryContiguousAddress(memory MemRef, memoryBits, elementBits int) (string, error) {
+	if memory.Index != "" {
+		if _, _, vectorIndex := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index}); vectorIndex {
+			return "", fmt.Errorf("contiguous form does not accept a scalable-vector index")
+		}
+		return c.arm64SVERegisterOffsetAddress(memory, int64(memoryBits/8))
+	}
+	// MUL VL counts the vector's in-memory footprint, not its register
+	// footprint. Widening loads and truncating stores transfer fewer bytes.
+	return c.arm64SVEVLAddress(memory, -8, 7, int64(16*memoryBits/elementBits))
+}
+
+func (c *arm64Ctx) arm64SVEOrdinaryVectorOffset(op Op, memory MemRef, elementBits, memoryBits int, ins Instr) (pointer, indexValue, indexType, suffix string, err error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" {
+		return "", "", "", "", fmt.Errorf("arm64 %s vector-offset form does not accept a displacement: %q", op, ins.Raw)
+	}
+	baseReg, baseOK := arm64SVEPhysicalMemoryBase(memory.Base)
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	byteScale := int64(memoryBits / 8)
+	if !baseOK || !indexOK || indexBits != elementBits || (elementBits != 32 && elementBits != 64) || (memory.Scale != 1 && memory.Scale != byteScale) {
+		return "", "", "", "", fmt.Errorf("arm64 %s vector offset has widths or scale outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+	extension := ""
+	switch memory.IndexExt {
+	case "":
+		if indexBits != 64 {
+			return "", "", "", "", fmt.Errorf("arm64 %s unextended vector offset requires Zm.D: %q", op, ins.Raw)
+		}
+	case ExtendUXTW:
+		extension = "uxtw"
+	case ExtendSXTW:
+		extension = "sxtw"
+	default:
+		return "", "", "", "", fmt.Errorf("arm64 %s vector offset only accepts UXTW or SXTW: %q", op, ins.Raw)
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return "", "", "", "", err
+	}
+	pointerName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointerName, base)
+	indexValue, indexType, err = c.loadZRegElements(index, indexBits)
+	if err != nil {
+		return "", "", "", "", err
+	}
+	if extension != "" && indexBits == 64 {
+		narrowType := "<vscale x 2 x i32>"
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %s to %s\n", narrow, indexType, indexValue, narrowType)
+		extended := c.newTmp()
+		opcode := "zext"
+		if extension == "sxtw" {
+			opcode = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %%%s to %s\n", extended, opcode, narrowType, narrow, indexType)
+		indexValue = "%" + extended
+		extension = ""
+	}
+	if extension != "" {
+		suffix = "." + extension
+	}
+	if byteScale > 1 && memory.Scale == byteScale {
+		suffix += ".index"
+	}
+	return "%" + pointerName, indexValue, indexType, suffix, nil
+}
+
+func (c *arm64Ctx) arm64SVEOrdinaryVectorBase(op Op, memory MemRef, elementBits, memoryBits int, ins Instr) (baseValue, baseType string, err error) {
+	base, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base})
+	alignment := int64(memoryBits / 8)
+	maximum := int64(31) * alignment
+	if !baseOK || baseBits != elementBits || (elementBits != 32 && elementBits != 64) || memory.Index != "" || memory.IndexExt != "" || memory.Sym != "" || memory.Segment != "" || memory.OffRaw != "" || memory.Off < 0 || memory.Off > maximum || memory.Off%alignment != 0 {
+		return "", "", fmt.Errorf("arm64 %s vector-base offset must match the data width, be aligned to %d, and be in [0,%d]: %q", op, alignment, maximum, ins.Raw)
+	}
+	return c.loadZRegElements(base, baseBits)
+}
+
+func arm64ParseSVEOrdinaryVectorList(operand Operand) (vectors []int, elementBits int, ok bool) {
+	if operand.Kind != OpRegList || len(operand.RegList) == 0 {
+		return nil, 0, false
+	}
+	vectors = make([]int, len(operand.RegList))
+	for i, register := range operand.RegList {
+		vector, bits, valid := arm64ParseSVEOrdinaryZReg(register)
+		if !valid || i > 0 && (bits != elementBits || vector != vectors[i-1]+1) {
+			return nil, 0, false
+		}
+		vectors[i] = vector
+		elementBits = bits
+	}
+	return vectors, elementBits, true
+}
+
+func arm64ParseSVEOrdinaryZReg(register Reg) (index, elementBits int, ok bool) {
+	if index, elementBits, ok = arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: register}); ok {
+		return index, elementBits, true
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(register))), ".")
+	if len(parts) != 2 || parts[1] != "Q" || !strings.HasPrefix(parts[0], "Z") {
+		return 0, 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(parts[0], "Z"))
+	if err != nil || index < 0 || index > 31 {
+		return 0, 0, false
+	}
+	return index, 128, true
+}
diff --git a/arm64_lower_sve_ordinary_memory_test.go b/arm64_lower_sve_ordinary_memory_test.go
new file mode 100644
index 000000000..dd4308bbf
--- /dev/null
+++ b/arm64_lower_sve_ordinary_memory_test.go
@@ -0,0 +1,419 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64SVEOrdinaryMemoryCompleteGo127Forms() string {
+	return `TEXT sveordinarymemoryforms(SB),$0-0
+	ZLD1B (R6)(R14), P4.Z, [Z13.B]
+	ZLD1B (R7)(RSP), P3.Z, [Z12.H]
+	ZLD1B (R5)(R27), P2.Z, [Z6.S]
+	ZLD1B (R2)(R3), P1.Z, [Z24.D]
+	ZLD1B (-VL*8)(R14), P4.Z, [Z13.B]
+	ZLD1B (VL*7)(R14), P4.Z, [Z13.H]
+	ZLD1B (-VL*2)(R14), P4.Z, [Z13.S]
+	ZLD1B (VL*3)(R14), P4.Z, [Z13.D]
+	ZLD1B (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1B (Z6.D.SXTW)(R14), P4.Z, [Z13.D]
+	ZLD1B (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLD1B (Z7.S), P4.Z, [Z13.S]
+	ZLD1B 31(Z7.D), P4.Z, [Z13.D]
+	ZLD1B (R5)(R27), PN12.Z, [Z6.B-Z7.B]
+	ZLD1B (R2)(R3), PN10.Z, [Z24.B-Z27.B]
+	ZLD1B (-VL*16)(R3), PN10.Z, [Z24.B-Z25.B]
+	ZLD1B (VL*28)(RSP), PN10.Z, [Z16.B-Z19.B]
+
+	ZLD1H (R6<<1)(R14), P4.Z, [Z13.H]
+	ZLD1H (R7<<1)(RSP), P3.Z, [Z12.S]
+	ZLD1H (R5<<1)(R27), P2.Z, [Z6.D]
+	ZLD1H (-VL*8)(R14), P4.Z, [Z13.H]
+	ZLD1H (VL*7)(R14), P4.Z, [Z13.S]
+	ZLD1H (-VL*2)(R14), P4.Z, [Z13.D]
+	ZLD1H (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1H (Z23.D<<1)(R24), P1.Z, [Z22.D]
+	ZLD1H (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLD1H (Z5.D.SXTW<<1)(R12), P2.Z, [Z11.D]
+	ZLD1H (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLD1H (Z9.S.SXTW<<1)(R8), P5.Z, [Z10.S]
+	ZLD1H (Z7.S), P4.Z, [Z13.S]
+	ZLD1H 62(Z7.D), P4.Z, [Z13.D]
+	ZLD1H (R5<<1)(R27), PN12.Z, [Z6.H-Z7.H]
+	ZLD1H (R2<<1)(R3), PN10.Z, [Z24.H-Z27.H]
+	ZLD1H (-VL*16)(R3), PN10.Z, [Z24.H-Z25.H]
+	ZLD1H (VL*28)(RSP), PN10.Z, [Z16.H-Z19.H]
+
+	ZLD1W (R6<<2)(R14), P4.Z, [Z13.S]
+	ZLD1W (R7<<2)(RSP), P3.Z, [Z12.D]
+	ZLD1W (R5<<2)(R27), P2.Z, [Z6.Q]
+	ZLD1W (-VL*8)(R14), P4.Z, [Z13.S]
+	ZLD1W (VL*7)(R14), P4.Z, [Z13.D]
+	ZLD1W (-VL*2)(R14), P4.Z, [Z13.Q]
+	ZLD1W (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1W (Z23.D<<2)(R24), P1.Z, [Z22.D]
+	ZLD1W (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLD1W (Z5.D.SXTW<<2)(R12), P2.Z, [Z11.D]
+	ZLD1W (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLD1W (Z9.S.SXTW<<2)(R8), P5.Z, [Z10.S]
+	ZLD1W (Z7.S), P4.Z, [Z13.S]
+	ZLD1W 124(Z7.D), P4.Z, [Z13.D]
+	ZLD1W (R5<<2)(R27), PN12.Z, [Z6.S-Z7.S]
+	ZLD1W (R2<<2)(R3), PN10.Z, [Z24.S-Z27.S]
+	ZLD1W (-VL*16)(R3), PN10.Z, [Z24.S-Z25.S]
+	ZLD1W (VL*28)(RSP), PN10.Z, [Z16.S-Z19.S]
+
+	ZLD1D (R6<<3)(R14), P4.Z, [Z13.D]
+	ZLD1D (R7<<3)(RSP), P3.Z, [Z12.Q]
+	ZLD1D (-VL*8)(R14), P4.Z, [Z13.D]
+	ZLD1D (VL*7)(R14), P4.Z, [Z13.Q]
+	ZLD1D (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1D (Z23.D<<3)(R24), P1.Z, [Z22.D]
+	ZLD1D (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLD1D (Z5.D.SXTW<<3)(R12), P2.Z, [Z11.D]
+	ZLD1D 248(Z7.D), P4.Z, [Z13.D]
+	ZLD1D (R5<<3)(R27), PN12.Z, [Z6.D-Z7.D]
+	ZLD1D (R2<<3)(R3), PN10.Z, [Z24.D-Z27.D]
+	ZLD1D (-VL*16)(R3), PN10.Z, [Z24.D-Z25.D]
+	ZLD1D (VL*28)(RSP), PN10.Z, [Z16.D-Z19.D]
+
+	ZLD1SB (R6)(R14), P4.Z, [Z13.H]
+	ZLD1SB (R7)(RSP), P3.Z, [Z12.S]
+	ZLD1SB (R5)(R27), P2.Z, [Z6.D]
+	ZLD1SB (-VL*8)(R14), P4.Z, [Z13.H]
+	ZLD1SB (VL*7)(R14), P4.Z, [Z13.S]
+	ZLD1SB (-VL*2)(R14), P4.Z, [Z13.D]
+	ZLD1SB (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1SB (Z6.D.SXTW)(R14), P4.Z, [Z13.D]
+	ZLD1SB (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLD1SB (Z7.S), P4.Z, [Z13.S]
+	ZLD1SB 31(Z7.D), P4.Z, [Z13.D]
+
+	ZLD1SH (R6<<1)(R14), P4.Z, [Z13.S]
+	ZLD1SH (R7<<1)(RSP), P3.Z, [Z12.D]
+	ZLD1SH (-VL*8)(R14), P4.Z, [Z13.S]
+	ZLD1SH (VL*7)(R14), P4.Z, [Z13.D]
+	ZLD1SH (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1SH (Z23.D<<1)(R24), P1.Z, [Z22.D]
+	ZLD1SH (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLD1SH (Z5.D.SXTW<<1)(R12), P2.Z, [Z11.D]
+	ZLD1SH (Z4.S.UXTW)(R3), P3.Z, [Z4.S]
+	ZLD1SH (Z9.S.SXTW<<1)(R8), P5.Z, [Z10.S]
+	ZLD1SH (Z7.S), P4.Z, [Z13.S]
+	ZLD1SH 62(Z7.D), P4.Z, [Z13.D]
+
+	ZLD1SW (R6<<2)(R14), P4.Z, [Z13.D]
+	ZLD1SW (-VL*8)(R14), P4.Z, [Z13.D]
+	ZLD1SW (Z10.D)(R19), P3.Z, [Z15.D]
+	ZLD1SW (Z23.D<<2)(R24), P1.Z, [Z22.D]
+	ZLD1SW (Z6.D.UXTW)(R14), P4.Z, [Z13.D]
+	ZLD1SW (Z5.D.SXTW<<2)(R12), P2.Z, [Z11.D]
+	ZLD1SW 124(Z7.D), P4.Z, [Z13.D]
+
+	ZLD1Q (R6)(Z7.D), P4.Z, [Z13.Q]
+
+	ZST1B [Z7.B], P4, (R21)(R7)
+	ZST1B [Z8.H], P3, (R6)(RSP)
+	ZST1B [Z9.S], P2, (R5)(R4)
+	ZST1B [Z10.D], P1, (R3)(R2)
+	ZST1B [Z6.D], P4, (Z21.D.UXTW)(R7)
+	ZST1B [Z5.D], P3, (Z20.D.SXTW)(R8)
+	ZST1B [Z4.S], P2, (Z19.S.UXTW)(R9)
+	ZST1B [Z8.S], P3, (Z15.S)
+	ZST1B [Z8.D], P3, 31(Z15.D)
+	ZST1B [Z7.B], P4, (-VL*8)(R7)
+	ZST1B [Z8.H], P3, (VL*7)(RSP)
+	ZST1B [Z9.S], P2, (-VL*3)(R7)
+	ZST1B [Z10.D], P1, (VL*4)(R7)
+	ZST1B [Z14.B-Z15.B], PN12, (R20)(R17)
+	ZST1B [Z4.B-Z7.B], PN12, (R12)(RSP)
+	ZST1B [Z14.B-Z15.B], PN12, (-VL*16)(R17)
+	ZST1B [Z4.B-Z7.B], PN12, (VL*28)(RSP)
+
+	ZST1H [Z7.H], P4, (R21<<1)(R7)
+	ZST1H [Z8.S], P3, (R6<<1)(RSP)
+	ZST1H [Z9.D], P2, (R5<<1)(R4)
+	ZST1H [Z6.D], P4, (Z21.D)(R7)
+	ZST1H [Z5.D], P3, (Z20.D<<1)(R8)
+	ZST1H [Z4.D], P2, (Z19.D.UXTW)(R9)
+	ZST1H [Z3.D], P1, (Z18.D.SXTW<<1)(R10)
+	ZST1H [Z2.S], P0, (Z17.S.UXTW)(R11)
+	ZST1H [Z1.S], P7, (Z16.S.SXTW<<1)(R12)
+	ZST1H [Z8.S], P3, (Z15.S)
+	ZST1H [Z8.D], P3, 62(Z15.D)
+	ZST1H [Z7.H], P4, (-VL*8)(R7)
+	ZST1H [Z8.S], P3, (VL*7)(RSP)
+	ZST1H [Z9.D], P2, (-VL*3)(R7)
+	ZST1H [Z14.H-Z15.H], PN12, (R20<<1)(R17)
+	ZST1H [Z4.H-Z7.H], PN12, (R12<<1)(RSP)
+	ZST1H [Z14.H-Z15.H], PN12, (-VL*16)(R17)
+	ZST1H [Z4.H-Z7.H], PN12, (VL*28)(RSP)
+
+	ZST1W [Z7.S], P4, (R21<<2)(R7)
+	ZST1W [Z8.D], P3, (R6<<2)(RSP)
+	ZST1W [Z9.Q], P2, (R5<<2)(R4)
+	ZST1W [Z6.D], P4, (Z21.D)(R7)
+	ZST1W [Z5.D], P3, (Z20.D<<2)(R8)
+	ZST1W [Z4.D], P2, (Z19.D.UXTW)(R9)
+	ZST1W [Z3.D], P1, (Z18.D.SXTW<<2)(R10)
+	ZST1W [Z2.S], P0, (Z17.S.UXTW)(R11)
+	ZST1W [Z1.S], P7, (Z16.S.SXTW<<2)(R12)
+	ZST1W [Z8.S], P3, (Z15.S)
+	ZST1W [Z8.D], P3, 124(Z15.D)
+	ZST1W [Z7.S], P4, (-VL*8)(R7)
+	ZST1W [Z8.D], P3, (VL*7)(RSP)
+	ZST1W [Z9.Q], P2, (-VL*3)(R7)
+	ZST1W [Z14.S-Z15.S], PN12, (R20<<2)(R17)
+	ZST1W [Z4.S-Z7.S], PN12, (R12<<2)(RSP)
+	ZST1W [Z14.S-Z15.S], PN12, (-VL*16)(R17)
+	ZST1W [Z4.S-Z7.S], PN12, (VL*28)(RSP)
+
+	ZST1D [Z7.D], P4, (R21<<3)(R7)
+	ZST1D [Z8.Q], P3, (R6<<3)(RSP)
+	ZST1D [Z6.D], P4, (Z21.D)(R7)
+	ZST1D [Z5.D], P3, (Z20.D<<3)(R8)
+	ZST1D [Z4.D], P2, (Z19.D.UXTW)(R9)
+	ZST1D [Z3.D], P1, (Z18.D.SXTW<<3)(R10)
+	ZST1D [Z8.D], P3, (Z15.D)
+	ZST1D [Z7.D], P4, (-VL*8)(R7)
+	ZST1D [Z8.Q], P3, (VL*7)(RSP)
+	ZST1D [Z14.D-Z15.D], PN12, (R20<<3)(R17)
+	ZST1D [Z4.D-Z7.D], PN12, (R12<<3)(RSP)
+	ZST1D [Z14.D-Z15.D], PN12, (-VL*16)(R17)
+	ZST1D [Z4.D-Z7.D], PN12, (VL*28)(RSP)
+
+	ZST1Q [Z8.Q], P3, (R6)(Z15.D)
+	RET
+`
+}
+
+func TestTranslateARM64SVEOrdinaryMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEOrdinaryMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveordinarymemoryforms": {Name: "sveordinarymemoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.ld1.nxv",
+				"@llvm.aarch64.sve.ld1.gather.nxv",
+				"@llvm.aarch64.sve.ld1.gather.index.nxv",
+				"@llvm.aarch64.sve.ld1.gather.uxtw.nxv",
+				"@llvm.aarch64.sve.ld1.gather.sxtw.index.nxv",
+				"@llvm.aarch64.sve.ld1.gather.scalar.offset.",
+				"@llvm.aarch64.sve.ld1.pn.x2.",
+				"@llvm.aarch64.sve.ld1.pn.x4.",
+				"@llvm.aarch64.sve.ld1udq.",
+				"@llvm.aarch64.sve.ld1uwq.",
+				"@llvm.aarch64.sve.ld1q.gather.scalar.offset.",
+				"@llvm.aarch64.sve.st1.nxv",
+				"@llvm.aarch64.sve.st1.scatter.nxv",
+				"@llvm.aarch64.sve.st1.scatter.index.nxv",
+				"@llvm.aarch64.sve.st1.scatter.uxtw.nxv",
+				"@llvm.aarch64.sve.st1.scatter.sxtw.index.nxv",
+				"@llvm.aarch64.sve.st1.scatter.scalar.offset.",
+				"@llvm.aarch64.sve.st1.pn.x2.",
+				"@llvm.aarch64.sve.st1.pn.x4.",
+				"@llvm.aarch64.sve.st1dq.",
+				"@llvm.aarch64.sve.st1wq.",
+				"@llvm.aarch64.sve.st1q.scatter.scalar.offset.",
+				" sext <vscale x ",
+				" zext <vscale x ",
+				" trunc <vscale x ",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE ordinary memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-ordinary-memory.ll", "arm64-sve-ordinary-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEContiguousByteMemoryCompleteFamily(t *testing.T) {
+	// The ordinary LD1B/ST1B scalar-base forms span B/H/S/D arrangements,
+	// register offsets, and signed MUL VL immediates. lightning uses the
+	// first observed load; gocc uses both observed stores.
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEContiguousByteMemory(SB),$0-0\n")
+	for _, observed := range []uint32{0xa400a400, 0xe42b4040, 0xe4084040} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", observed)
+	}
+	for size := uint32(0); size < 4; size++ {
+		registers := uint32(11<<16 | 1<<10 | 2<<5 | 3)
+		for _, base := range []uint32{0xa4004000, 0xe4004000} {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|size<<21|registers)
+		}
+		for _, base := range []uint32{0xa400a000, 0xe400e000} {
+			for _, offset := range []uint32{0, 7, 8} {
+				word := base | size<<21 | offset<<16 | 1<<10 | 2<<5 | 3
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEContiguousByteMemory": {Name: "rawSVEContiguousByteMemory", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			ll := module.String()
+			if !strings.Contains(ll, `"target-features"="+sve"`) {
+				t.Fatal("raw byte memory lost its required SVE feature")
+			}
+			// Count real call instructions, not declarations in the prelude.
+			// The raw fixture owns four loads/stores per arrangement plus its
+			// three observed words: one B load, one B store and one H store.
+			wantCalls := map[string]int{
+				"llvm.aarch64.sve.ld1.nxv16i8": 5,
+				"llvm.aarch64.sve.ld1.nxv8i8":  4,
+				"llvm.aarch64.sve.ld1.nxv4i8":  4,
+				"llvm.aarch64.sve.ld1.nxv2i8":  4,
+				"llvm.aarch64.sve.st1.nxv16i8": 5,
+				"llvm.aarch64.sve.st1.nxv8i8":  5,
+				"llvm.aarch64.sve.st1.nxv4i8":  4,
+				"llvm.aarch64.sve.st1.nxv2i8":  4,
+			}
+			calls := make(map[string]int)
+			function := module.NamedFunction("rawSVEContiguousByteMemory")
+			if function.IsNil() || function.FirstBasicBlock().IsNil() {
+				t.Fatal("complete raw byte memory function disappeared")
+			}
+			for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+				for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+					if ins.InstructionOpcode() == llvm.Call {
+						calls[ins.CalledValue().Name()]++
+					}
+				}
+			}
+			for name, count := range wantCalls {
+				if calls[name] != count {
+					t.Errorf("%s: got %d actual calls, want %d", name, calls[name], count)
+				}
+			}
+			if strings.Contains(ll, "@llvm.masked.load.") {
+				t.Error("ordinary SVE byte loads retained an unused generic masked-load declaration")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-byte-memory.ll", "arm64-raw-sve-byte-memory.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEContiguousByteMemoryBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word      uint32
+		op        Op
+		base      Reg
+		index     Reg
+		offsetRaw string
+		vector    Reg
+	}{
+		{0xa400a400, "ZLD1B", "R0", "", "", "Z0.B"},
+		{0xe42b4040, "ZST1B", "R11", "R2", "", "Z0.H"},
+		{0xe4084040, "ZST1B", "R8", "R2", "", "Z0.B"},
+		{0xa408a443, "ZLD1B", "R2", "", "-VL*8", "Z3.B"},
+	} {
+		ins, ok := decodeARM64RawSVEContiguousMemory(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != 3 {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		memoryIndex, vectorIndex := 0, 2
+		if test.op == "ZST1B" {
+			memoryIndex, vectorIndex = 2, 0
+		}
+		memory := ins.Args[memoryIndex].Mem
+		if memory.Base != test.base || memory.Index != test.index || memory.OffRaw != test.offsetRaw {
+			t.Errorf("%#08x memory = %+v", test.word, memory)
+		}
+		if ins.Args[vectorIndex].Kind != OpRegList || ins.Args[vectorIndex].RegList[0] != test.vector {
+			t.Errorf("%#08x vector = %+v", test.word, ins.Args[vectorIndex])
+		}
+	}
+	for _, word := range []uint32{
+		0xa400a400 | (1 << 14),
+		0xe42b4040 | (1 << 13),
+	} {
+		if ins, ok := decodeARM64RawSVEContiguousMemory(word); ok {
+			t.Errorf("decoded reserved byte memory %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEOrdinaryMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLD1B (R6)(R14), P8.Z, [Z13.B]",
+		"ZLD1H (R6)(R14), P4.Z, [Z13.H]",
+		"ZLD1W (R6<<1)(R14), P4.Z, [Z13.S]",
+		"ZLD1D (R6<<2)(R14), P4.Z, [Z13.D]",
+		"ZLD1SB (R6)(R14), P4.Z, [Z13.B]",
+		"ZLD1SH (R6<<1)(R14), P4.Z, [Z13.H]",
+		"ZLD1SW (R6<<2)(R14), P4.Z, [Z13.S]",
+		"ZLD1B (Z4.S)(R3), P3.Z, [Z4.S]",
+		"ZLD1H (Z4.S.UXTW<<2)(R3), P3.Z, [Z4.S]",
+		"ZLD1W 128(Z7.S), P4.Z, [Z13.S]",
+		"ZLD1D (VL*8)(R14), P4.Z, [Z13.D]",
+		"ZLD1D (VL*3)(R3), PN10.Z, [Z24.D-Z25.D]",
+		"ZLD1D (VL*2)(RSP), PN10.Z, [Z16.D-Z19.D]",
+		"ZLD1Q (R6)(Z7.S), P4.Z, [Z13.Q]",
+		"ZST1B [Z8.B], P8, (R6)(RSP)",
+		"ZST1H [Z8.B], P3, (R6<<1)(RSP)",
+		"ZST1W [Z8.H], P3, (R6<<2)(RSP)",
+		"ZST1D [Z8.S], P3, (R6<<3)(RSP)",
+		"ZST1H [Z8.S], P3, 3(Z15.S)",
+		"ZST1D [Z8.D], P3, 256(Z15.D)",
+		"ZST1D [Z8.D], P3, (VL*8)(RSP)",
+		"ZST1D [Z14.D-Z16.D], PN12, (R20<<3)(R17)",
+		"ZST1D [Z14.D-Z15.D], PN12, (VL*3)(R17)",
+		"ZST1Q [Z8.D], P3, (R6)(Z15.D)",
+		"ZLD1B.Z (R6)(R14), P4.Z, [Z13.B]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveordinarymemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveordinarymemory": {Name: "badsveordinarymemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ordinary SVE memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_pairwise_tail.go b/arm64_lower_sve_pairwise_tail.go
new file mode 100644
index 000000000..4648469f2
--- /dev/null
+++ b/arm64_lower_sve_pairwise_tail.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVETailOps = map[Op]string{
+	"ZADDPT": "addpt",
+	"ZSUBPT": "subpt",
+}
+
+func (c *arm64Ctx) lowerARM64SVEPairwiseTail(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op == "ZADDP" {
+		return c.lowerARM64SVEAddPairwise(ins)
+	}
+	intrinsic, ok := arm64SVETailOps[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || (len(ins.Args) != 3 && len(ins.Args) != 4) {
+		return true, false, fmt.Errorf("arm64 %s expects one of its two D-width Go 1.27 forms without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !secondOK || !firstOK || secondBits != 64 || firstBits != 64 {
+		return true, false, fmt.Errorf("arm64 %s requires D-width vector operands: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, 64)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, 64)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if len(ins.Args) == 3 {
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !destinationOK || destinationBits != 64 {
+			return true, false, fmt.Errorf("arm64 %s unpredicated form requires a D-width destination: %q", op, ins.Raw)
+		}
+		assembly := intrinsic + " $0.d, $1.d, $2.d"
+		fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s)\n", result, vectorType, assembly, "=w,w,w", vectorType, firstValue, vectorType, secondValue)
+		return true, false, c.storeZRegElements(destination, 64, "%"+result)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !predicateOK || !destinationOK || destinationBits != 64 || destination != first {
+		return true, false, fmt.Errorf("arm64 %s predicated form requires Pg/M and a repeated D-width destination: %q", op, ins.Raw)
+	}
+	predicateValue, err := c.loadPReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	assembly := intrinsic + " $0.d, $3/m, $0.d, $2.d"
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, %s %s, <vscale x 16 x i1> %s)\n", result, vectorType, assembly, "=&w,0,w,@3Upl", vectorType, firstValue, vectorType, secondValue, predicateValue)
+	return true, false, c.storeZRegElements(destination, 64, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEAddPairwise(ins Instr) (ok bool, terminated bool, err error) {
+	if strings.ToUpper(string(ins.Op)) != "ZADDP" || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 ZADDP expects Zm.T, Zdn.T, Pg/M, Zdn.T without a suffix: %q", ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !firstOK || !predicateOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits || first != destination {
+		return true, false, fmt.Errorf("arm64 ZADDP requires matching element widths and a repeated destructive destination: %q", ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / firstBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.addp.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, lanes, firstBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_pairwise_tail_test.go b/arm64_lower_sve_pairwise_tail_test.go
new file mode 100644
index 000000000..226252b64
--- /dev/null
+++ b/arm64_lower_sve_pairwise_tail_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEPairwiseTailCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT svepairwise(SB),$0-0
+	ZADDP Z1.B, Z2.B, P0.M, Z2.B
+	ZADDP Z3.H, Z4.H, P1.M, Z4.H
+	ZADDP Z5.S, Z6.S, P2.M, Z6.S
+	ZADDP Z7.D, Z8.D, P3.M, Z8.D
+	RET
+TEXT svetail(SB),$0-0
+	ZADDPT Z9.D, Z10.D, P4.M, Z10.D
+	ZADDPT Z11.D, Z12.D, Z13.D
+	ZSUBPT Z14.D, Z15.D, P5.M, Z15.D
+	ZSUBPT Z16.D, Z17.D, Z18.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"svepairwise": {Name: "svepairwise", Ret: Void},
+		"svetail":     {Name: "svetail", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				`"target-features"="+cpa,+sve"`,
+				"@llvm.aarch64.sve.addp.nxv16i8",
+				`asm sideeffect "addpt $0.d, $3/m, $0.d, $2.d"`,
+				`asm sideeffect "addpt $0.d, $1.d, $2.d"`,
+				`asm sideeffect "subpt $0.d, $3/m, $0.d, $2.d"`,
+				`asm sideeffect "subpt $0.d, $1.d, $2.d"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE pairwise/tail lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-pairwise-tail.ll", "arm64-sve-pairwise-tail.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPairwiseTailRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZADDP Z1.B, Z2.B, P0.M, Z3.B",
+		"ZADDP Z1.B, Z2.H, P0.M, Z2.H",
+		"ZADDP Z1.B, Z2.B, P0.Z, Z2.B",
+		"ZADDPT Z1.S, Z2.S, Z3.S",
+		"ZADDPT Z1.D, Z2.D, P0.M, Z3.D",
+		"ZSUBPT Z1.D, Z2.D, P0.Z, Z2.D",
+		"ZSUBPT.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepairwisetail(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepairwisetail": {Name: "badsvepairwisetail", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE pairwise/tail forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_permute.go b/arm64_lower_sve_permute.go
new file mode 100644
index 000000000..a5316798a
--- /dev/null
+++ b/arm64_lower_sve_permute.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64RawSVEPermute struct {
+	op          Op
+	elementBits int
+	quad        bool
+	first       int
+	second      int
+	destination int
+}
+
+var arm64SVEPermuteIntrinsics = map[Op]string{
+	"ZZIP1":  "zip1",
+	"ZZIP2":  "zip2",
+	"ZUZP1":  "uzp1",
+	"ZUZP2":  "uzp2",
+	"ZTRN1":  "trn1",
+	"ZTRN2":  "trn2",
+	"ZZIPQ1": "zipq1",
+	"ZZIPQ2": "zipq2",
+	"ZUZPQ1": "uzpq1",
+	"ZUZPQ2": "uzpq2",
+}
+
+var arm64SVEPermuteOpsByIndex = [...]Op{"ZZIP1", "ZZIP2", "ZUZP1", "ZUZP2", "ZTRN1", "ZTRN2"}
+var arm64SVEQPermuteOpsByIndex = [...]Op{"ZZIPQ1", "ZZIPQ2", "ZUZPQ1", "ZUZPQ2"}
+
+func arm64SVEIsQPermuteOp(op Op) bool {
+	for _, candidate := range arm64SVEQPermuteOpsByIndex {
+		if op == candidate {
+			return true
+		}
+	}
+	return false
+}
+
+// decodeARM64RawSVEPermute covers the complete ZIP1/2, UZP1/2 and TRN1/2
+// family, including the F64MM 128-bit element forms exposed by Go 1.27.
+func decodeARM64RawSVEPermute(word uint32) (arm64RawSVEPermute, bool) {
+	form := arm64RawSVEPermute{
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+		destination: int(word) & 31,
+	}
+	selector := int(word>>10) & 7
+	switch {
+	case word&0xff20e000 == 0x05206000:
+		if selector > 5 {
+			return arm64RawSVEPermute{}, false
+		}
+		form.op = arm64SVEPermuteOpsByIndex[selector]
+		form.elementBits = 8 << (int(word>>22) & 3)
+	case word&0xffe0e000 == 0x05a00000:
+		if selector == 4 || selector == 5 {
+			return arm64RawSVEPermute{}, false
+		}
+		if selector >= 6 {
+			selector -= 2
+		}
+		form.op = arm64SVEPermuteOpsByIndex[selector]
+		form.elementBits = 128
+		form.quad = true
+	default:
+		return arm64RawSVEPermute{}, false
+	}
+	return form, true
+}
+
+func arm64ParseSVEPermuteReg(operand Operand) (index, elementBits int, ok bool) {
+	if index, elementBits, ok := arm64ParseSVEZElementReg(operand); ok {
+		return index, elementBits, true
+	}
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || parts[1] != "Q" || !strings.HasPrefix(parts[0], "Z") {
+		return 0, 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(parts[0], "Z"))
+	return index, 128, err == nil && index >= 0 && index < 32
+}
+
+func arm64SVEPermuteNeedsF64MM(ins Instr) bool {
+	if len(ins.Args) != 3 {
+		return false
+	}
+	_, bits, ok := arm64ParseSVEPermuteReg(ins.Args[2])
+	return ok && bits == 128
+}
+
+func (c *arm64Ctx) lowerARM64SVEPermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, ok := arm64SVEPermuteIntrinsics[op]; !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zn.T, Zd.T for T=B/H/S/D/Q: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEPermuteReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEPermuteReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEPermuteReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s operands must use one matching B/H/S/D/Q element width: %q", op, ins.Raw)
+	}
+	if arm64SVEIsQPermuteOp(op) && destinationBits == 128 {
+		return true, false, fmt.Errorf("arm64 %s only accepts B/H/S/D element widths: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerRawSVEPermute(arm64RawSVEPermute{
+		op:          op,
+		elementBits: firstBits,
+		quad:        firstBits == 128,
+		first:       first,
+		second:      second,
+		destination: destination,
+	})
+}
+
+func (c *arm64Ctx) lowerRawSVEPermute(form arm64RawSVEPermute) error {
+	intrinsic, ok := arm64SVEPermuteIntrinsics[form.op]
+	if !ok {
+		return fmt.Errorf("unsupported ARM64 SVE permute operation %s", form.op)
+	}
+	representationBits := form.elementBits
+	if form.quad {
+		representationBits = 64
+		intrinsic += "q"
+	}
+	first, vectorType, err := c.loadZRegElements(form.first, representationBits)
+	if err != nil {
+		return err
+	}
+	second, _, err := c.loadZRegElements(form.second, representationBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(representationBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, vectorType, intrinsic, lanes, representationBits, vectorType, first, vectorType, second)
+	return c.storeZRegElements(form.destination, representationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_permute_test.go b/arm64_lower_sve_permute_test.go
new file mode 100644
index 000000000..719ea4fc4
--- /dev/null
+++ b/arm64_lower_sve_permute_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVEPermuteOps = []Op{"ZZIP1", "ZZIP2", "ZUZP1", "ZUZP2", "ZTRN1", "ZTRN2"}
+
+func encodeARM64RawSVEPermute(op Op, elementBits, second, first, destination int) uint32 {
+	selector := 0
+	for index, candidate := range arm64SVEPermuteOps {
+		if op == candidate {
+			selector = index
+			break
+		}
+	}
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x05206000 | size<<22 | uint32(selector)<<10 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEPermuteQ(op Op, second, first, destination int) uint32 {
+	selector := 0
+	for index, candidate := range arm64SVEPermuteOps {
+		if op == candidate {
+			selector = index
+			if selector >= 4 {
+				selector += 2
+			}
+			break
+		}
+	}
+	return 0x05a00000 | uint32(selector)<<10 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64RawSVEPermuteReportedEncoding(t *testing.T) {
+	const source = "TEXT svetrn2reported(SB),$0-0\n\tWORD $0x05e47490\n\tRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"svetrn2reported": {Name: "svetrn2reported", Ret: Void}}}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestTranslateARM64SVEPermuteCompleteGo127Forms(t *testing.T) {
+	var named strings.Builder
+	named.WriteString("TEXT svepermutednamed(SB),$0-0\n")
+	for _, op := range arm64SVEPermuteOps {
+		fmt.Fprintf(&named, "\t%s Z2.B, Z1.B, Z0.B\n", op)
+		fmt.Fprintf(&named, "\t%s Z4.H, Z3.H, Z0.H\n", op)
+		fmt.Fprintf(&named, "\t%s Z6.S, Z5.S, Z0.S\n", op)
+		fmt.Fprintf(&named, "\t%s Z8.D, Z7.D, Z0.D\n", op)
+		fmt.Fprintf(&named, "\t%s Z10.Q, Z9.Q, Z0.Q\n", op)
+	}
+	named.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, named.String(), true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svepermutedraw(SB),$0-0\n")
+	for _, op := range arm64SVEPermuteOps {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEPermute(op, elementBits, 2, 1, 0))
+		}
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEPermuteQ(op, 10, 9, 0))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for name, source := range map[string]string{"named": named.String(), "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svepermuted" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+f64mm,+sve"`, "@llvm.aarch64.sve.zip1.nxv", "@llvm.aarch64.sve.uzp2.nxv", "@llvm.aarch64.sve.trn2.nxv", "@llvm.aarch64.sve.trn1q.nxv2i64"} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("SVE permute lowering omitted %q:\n%s", want, ir)
+						}
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-permute.ll", "arm64-sve-permute.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEPermuteDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, op := range arm64SVEPermuteOps {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			for second := 0; second < 32; second++ {
+				for first := 0; first < 32; first++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVEPermute(op, elementBits, second, first, destination)
+						got, ok := decodeARM64RawSVEPermute(word)
+						if !ok || got.op != op || got.elementBits != elementBits || got.quad || got.second != second || got.first != first || got.destination != destination {
+							t.Fatalf("decoded SVE permute %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+		for second := 0; second < 32; second++ {
+			for first := 0; first < 32; first++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEPermuteQ(op, second, first, destination)
+					got, ok := decodeARM64RawSVEPermute(word)
+					if !ok || got.op != op || !got.quad || got.elementBits != 128 || got.second != second || got.first != first || got.destination != destination {
+						t.Fatalf("decoded SVE Q permute %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVEPermuteRejectsAdjacentAndInvalidForms(t *testing.T) {
+	for _, word := range []uint32{
+		0x05206000 | 6<<10,
+		0x05206000 | 7<<10,
+		0x05a00000 | 4<<10,
+		0x05a00000 | 5<<10,
+	} {
+		if _, ok := decodeARM64RawSVEPermute(word); ok {
+			t.Fatalf("SVE permute decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = "TEXT badsvepermute(SB),$0-0\n\tZTRN2 Z1.B, Z2.H, Z3.B\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+}
diff --git a/arm64_lower_sve_pmov.go b/arm64_lower_sve_pmov.go
new file mode 100644
index 000000000..9847e125f
--- /dev/null
+++ b/arm64_lower_sve_pmov.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func arm64ParseSVEPMOVIndexedZReg(operand Operand, elementBits int) (index, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	open := strings.IndexByte(text, '[')
+	if open <= 1 || !strings.HasPrefix(text, "Z") || !strings.HasSuffix(text, "]") || strings.Contains(text[:open], ".") {
+		return 0, 0, false
+	}
+	index, indexErr := strconv.Atoi(text[1:open])
+	lane, laneErr := strconv.Atoi(text[open+1 : len(text)-1])
+	maximumLane, widthOK := map[int]int{16: 1, 32: 3, 64: 7}[elementBits]
+	return index, lane, indexErr == nil && laneErr == nil && widthOK && index >= 0 && index <= 31 && lane >= 0 && lane <= maximumLane
+}
+
+func (c *arm64Ctx) lowerARM64SVEPMOV(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZPMOV" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 ZPMOV expects its two-operand Go 1.27 form without a suffix: %q", ins.Raw)
+	}
+
+	if predicate, elementBits, predicateOK := arm64ParseSVEPredicateElement(ins.Args[0]); predicateOK {
+		if elementBits == 8 {
+			vector, vectorOK := arm64ParseSVEBareZReg(ins.Args[1])
+			if !vectorOK {
+				return true, false, fmt.Errorf("arm64 ZPMOV Pn.B source requires a bare Z destination: %q", ins.Raw)
+			}
+			return true, false, c.lowerARM64SVEPMOVToVector(predicate, vector, elementBits, 0)
+		}
+		vector, lane, vectorOK := arm64ParseSVEPMOVIndexedZReg(ins.Args[1], elementBits)
+		if !vectorOK {
+			return true, false, fmt.Errorf("arm64 ZPMOV Pn.%s source requires a valid indexed Z destination: %q", arm64SVEElementLetter(elementBits), ins.Raw)
+		}
+		return true, false, c.lowerARM64SVEPMOVToVector(predicate, vector, elementBits, lane)
+	}
+
+	if predicate, elementBits, predicateOK := arm64ParseSVEPredicateElement(ins.Args[1]); predicateOK {
+		if elementBits == 8 {
+			vector, vectorOK := arm64ParseSVEBareZReg(ins.Args[0])
+			if !vectorOK {
+				return true, false, fmt.Errorf("arm64 ZPMOV Pn.B destination requires a bare Z source: %q", ins.Raw)
+			}
+			return true, false, c.lowerARM64SVEPMOVToPredicate(vector, predicate, elementBits, 0)
+		}
+		vector, lane, vectorOK := arm64ParseSVEPMOVIndexedZReg(ins.Args[0], elementBits)
+		if !vectorOK {
+			return true, false, fmt.Errorf("arm64 ZPMOV Pn.%s destination requires a valid indexed Z source: %q", arm64SVEElementLetter(elementBits), ins.Raw)
+		}
+		return true, false, c.lowerARM64SVEPMOVToPredicate(vector, predicate, elementBits, lane)
+	}
+
+	return true, false, fmt.Errorf("arm64 ZPMOV requires one P0..P15.B/H/S/D operand and one matching Go Z operand: %q", ins.Raw)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPMOVToVector(predicate, vector, elementBits, lane int) error {
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return err
+	}
+	vectorType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if lane == 0 {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmov.to.vector.lane.zeroing.nxv%di%d(%s %s)\n", result, vectorType, lanes, elementBits, predicateType, predicateValue)
+	} else {
+		oldVector, _, err := c.loadZRegElements(vector, elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmov.to.vector.lane.merging.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, lanes, elementBits, vectorType, oldVector, predicateType, predicateValue, lane)
+	}
+	return c.storeZRegElements(vector, elementBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPMOVToPredicate(vector, predicate, elementBits, lane int) error {
+	vectorValue, vectorType, err := c.loadZRegElements(vector, elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	result := c.newTmp()
+	if lane == 0 {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmov.to.pred.lane.zero.nxv%di%d(%s %s)\n", result, predicateType, lanes, elementBits, vectorType, vectorValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmov.to.pred.lane.nxv%di%d(%s %s, i32 %d)\n", result, predicateType, lanes, elementBits, vectorType, vectorValue, lane)
+	}
+	return c.storePRegElements(predicate, elementBits, "%"+result)
+}
+
+func arm64SVEElementLetter(elementBits int) string {
+	return map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[elementBits]
+}
diff --git a/arm64_lower_sve_pmov_test.go b/arm64_lower_sve_pmov_test.go
new file mode 100644
index 000000000..7bf5888f9
--- /dev/null
+++ b/arm64_lower_sve_pmov_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPMOVCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepmovforms(SB),$0-0\n")
+	source.WriteString("\tZPMOV P0.B, Z0\n")
+	source.WriteString("\tZPMOV Z1, P1.B\n")
+	for _, spec := range []struct {
+		letter    string
+		maxLane   int
+		predicate int
+		vector    int
+	}{
+		{letter: "H", maxLane: 1, predicate: 2, vector: 2},
+		{letter: "S", maxLane: 3, predicate: 3, vector: 3},
+		{letter: "D", maxLane: 7, predicate: 4, vector: 4},
+	} {
+		for lane := 0; lane <= spec.maxLane; lane++ {
+			fmt.Fprintf(&source, "\tZPMOV P%d.%s, Z%d[%d]\n", spec.predicate, spec.letter, spec.vector, lane)
+			fmt.Fprintf(&source, "\tZPMOV Z%d[%d], P%d.%s\n", spec.vector+1, lane, spec.predicate+1, spec.letter)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestParseARM64SVEPMOVIndexedRegisters(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT parsepmov(SB),$0-0\n\tZPMOV P3.S, Z25[2]\n\tZPMOV Z27[1], P13.S\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, operand := range []Operand{file.Funcs[0].Instrs[1].Args[1], file.Funcs[0].Instrs[2].Args[0]} {
+		if operand.Kind != OpReg {
+			t.Fatalf("indexed Z register parsed as kind %v: %+v", operand.Kind, operand)
+		}
+	}
+}
+
+func TestTranslateARM64SVEPMOVCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPMOVCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepmovforms": {Name: "svepmovforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.pmov.to.pred.lane.zero.nxv16i8",
+				"@llvm.aarch64.sve.pmov.to.pred.lane.nxv8i16",
+				"@llvm.aarch64.sve.pmov.to.vector.lane.zeroing.nxv4i32",
+				"@llvm.aarch64.sve.pmov.to.vector.lane.merging.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE PMOV lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-pmov.ll", "arm64-sve-pmov.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPMOVRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZPMOV P0.B, Z0[0]",
+		"ZPMOV P0.H, Z0",
+		"ZPMOV P0.H, Z0[2]",
+		"ZPMOV P0.S, Z0[4]",
+		"ZPMOV P0.D, Z0[8]",
+		"ZPMOV Z0[2], P0.H",
+		"ZPMOV Z0[4], P0.S",
+		"ZPMOV Z0[8], P0.D",
+		"ZPMOV P16.B, Z0",
+		"ZPMOV Z32, P0.B",
+		"ZPMOV.Z P0.B, Z0",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepmov(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepmov": {Name: "badsvepmov", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE PMOV forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_pmul.go b/arm64_lower_sve_pmul.go
new file mode 100644
index 000000000..31f3d661e
--- /dev/null
+++ b/arm64_lower_sve_pmul.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64SVEPMUL(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZPMUL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZPMUL expects Zm.B, Zn.B, Zd.B without a suffix: %q", ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK || secondBits != 8 || firstBits != 8 || destinationBits != 8 {
+		return true, false, fmt.Errorf("arm64 ZPMUL requires B-element vectors: %q", ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, 8)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, 8)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmul.nxv16i8(%s %s, %s %s)\n", result, vectorType, vectorType, firstValue, vectorType, secondValue)
+	return true, false, c.storeZRegElements(destination, 8, "%"+result)
+}
diff --git a/arm64_lower_sve_pmul_test.go b/arm64_lower_sve_pmul_test.go
new file mode 100644
index 000000000..17f3ea94b
--- /dev/null
+++ b/arm64_lower_sve_pmul_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEPMULCompleteGo127Family(t *testing.T) {
+	source := "TEXT svepmulforms(SB),$0-0\n\tZPMUL Z1.B, Z2.B, Z3.B\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepmulforms": {Name: "svepmulforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.pmul.nxv16i8"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE PMUL lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-pmul.ll", "arm64-sve-pmul.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPMULRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZPMUL Z1.H, Z2.H, Z3.H",
+		"ZPMUL Z1.B, Z2.H, Z3.B",
+		"ZPMUL Z1.B, Z2.B",
+		"ZPMUL.Z Z1.B, Z2.B, Z3.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepmul(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepmul": {Name: "badsvepmul", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE PMUL forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_pmull.go b/arm64_lower_sve_pmull.go
new file mode 100644
index 000000000..fb01ad11f
--- /dev/null
+++ b/arm64_lower_sve_pmull.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEPMULLIntrinsics = map[Op]string{
+	"ZPMULLB": "pmullb.pair",
+	"ZPMULLT": "pmullt.pair",
+}
+
+func arm64SVEPMULLNeedsSVE2AES(ins Instr) bool {
+	if len(ins.Args) != 3 {
+		return false
+	}
+	_, ok := arm64ParseSVEZQReg(ins.Args[2])
+	return ok
+}
+
+func (c *arm64Ctx) lowerARM64SVEPMULL(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEPMULLIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.B, Zn.B, Zd.H; Zm.S, Zn.S, Zd.D; or Zm.D, Zn.D, Zd.Q without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !secondOK || !firstOK || secondBits != firstBits || firstBits != 8 && firstBits != 32 && firstBits != 64 {
+		return true, false, fmt.Errorf("arm64 %s requires matching B, S, or D source vectors: %q", op, ins.Raw)
+	}
+	destinationRepresentationBits := firstBits * 2
+	destination := 0
+	if firstBits == 64 {
+		var destinationOK bool
+		destination, destinationOK = arm64ParseSVEZQReg(ins.Args[2])
+		if !destinationOK {
+			return true, false, fmt.Errorf("arm64 %s D sources require a Q destination: %q", op, ins.Raw)
+		}
+		destinationRepresentationBits = 64
+	} else {
+		var destinationBits int
+		var destinationOK bool
+		destination, destinationBits, destinationOK = arm64ParseSVEZElementReg(ins.Args[2])
+		if !destinationOK || destinationBits != destinationRepresentationBits {
+			return true, false, fmt.Errorf("arm64 %s must widen B to H or S to D: %q", op, ins.Raw)
+		}
+	}
+	firstValue, sourceType, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, sourceLanes, err := arm64SVEVectorType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, sourceType, intrinsic, sourceLanes, firstBits, sourceType, firstValue, sourceType, secondValue)
+	resultValue := "%" + result
+	if firstBits != 64 {
+		destinationType, _, err := arm64SVEVectorType(destinationRepresentationBits)
+		if err != nil {
+			return true, false, err
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", converted, sourceType, resultValue, destinationType)
+		resultValue = "%" + converted
+	}
+	return true, false, c.storeZRegElements(destination, destinationRepresentationBits, resultValue)
+}
diff --git a/arm64_lower_sve_pmull_pair.go b/arm64_lower_sve_pmull_pair.go
new file mode 100644
index 000000000..8e3260999
--- /dev/null
+++ b/arm64_lower_sve_pmull_pair.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func arm64ParseSVEQPair(operand Operand) (first, second int, ok bool) {
+	if operand.Kind != OpRegList || !operand.RegListRange || len(operand.RegList) != 2 {
+		return 0, 0, false
+	}
+	first, firstOK := arm64ParseSVEZQReg(Operand{Kind: OpReg, Reg: operand.RegList[0]})
+	second, secondOK := arm64ParseSVEZQReg(Operand{Kind: OpReg, Reg: operand.RegList[1]})
+	return first, second, firstOK && secondOK && first%2 == 0 && second == first+1
+}
+
+func (c *arm64Ctx) lowerARM64SVEPMULLPair(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZPMULL" && op != "ZPMLAL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.D, Zn.D, [Zd.Q-Zd+1.Q] without a suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	firstDestination, secondDestination, destinationOK := arm64ParseSVEQPair(ins.Args[2])
+	if !secondOK || !firstOK || secondBits != 64 || firstBits != 64 || !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s requires D sources and an even-odd consecutive Q destination pair: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, 64)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, 64)
+	if err != nil {
+		return true, false, err
+	}
+	aggregateType := fmt.Sprintf("{ %s, %s }", vectorType, vectorType)
+	result := c.newTmp()
+	if op == "ZPMULL" {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmull.pair.x2(%s %s, %s %s)\n", result, aggregateType, vectorType, firstValue, vectorType, secondValue)
+	} else {
+		firstAccumulator, _, err := c.loadZRegElements(firstDestination, 64)
+		if err != nil {
+			return true, false, err
+		}
+		secondAccumulator, _, err := c.loadZRegElements(secondDestination, 64)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pmlal.pair.x2(%s %s, %s %s, %s %s, %s %s)\n", result, aggregateType, vectorType, firstAccumulator, vectorType, secondAccumulator, vectorType, firstValue, vectorType, secondValue)
+	}
+	firstResult := c.newTmp()
+	secondResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", firstResult, aggregateType, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", secondResult, aggregateType, result)
+	if err := c.storeZRegElements(firstDestination, 64, "%"+firstResult); err != nil {
+		return true, false, err
+	}
+	return true, false, c.storeZRegElements(secondDestination, 64, "%"+secondResult)
+}
diff --git a/arm64_lower_sve_pmull_pair_test.go b/arm64_lower_sve_pmull_pair_test.go
new file mode 100644
index 000000000..3d6085ff9
--- /dev/null
+++ b/arm64_lower_sve_pmull_pair_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEPMULLPairCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT svepmullpair(SB),$0-0
+	ZPMULL Z1.D, Z2.D, [Z4.Q-Z5.Q]
+	ZPMULL Z30.D, Z31.D, [Z30.Q-Z31.Q]
+	RET
+TEXT svepmlalpair(SB),$0-0
+	ZPMLAL Z6.D, Z7.D, [Z8.Q-Z9.Q]
+	ZPMLAL Z28.D, Z29.D, [Z30.Q-Z31.Q]
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"svepmullpair": {Name: "svepmullpair", Ret: Void},
+		"svepmlalpair": {Name: "svepmlalpair", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve-aes2"`,
+				"@llvm.aarch64.sve.pmull.pair.x2",
+				"@llvm.aarch64.sve.pmlal.pair.x2",
+				"extractvalue { <vscale x 2 x i64>, <vscale x 2 x i64> }",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE PMULL/PMLAL pair lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-pmull-pair.ll", "arm64-sve-pmull-pair.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPMULLPairRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZPMULL Z1.S, Z2.S, [Z4.Q-Z5.Q]",
+		"ZPMULL Z1.D, Z2.D, [Z5.Q-Z6.Q]",
+		"ZPMULL Z1.D, Z2.D, [Z4.Q-Z7.Q]",
+		"ZPMULL Z1.D, Z2.D, [Z4.Q, Z5.Q]",
+		"ZPMLAL Z1.D, Z2.D, [Z4.D-Z5.D]",
+		"ZPMLAL Z1.D, Z2.D",
+		"ZPMLAL.Z Z1.D, Z2.D, [Z4.Q-Z5.Q]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "[", "", "]", "").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepmullpair(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepmullpair": {Name: "badsvepmullpair", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE PMULL/PMLAL pair forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_pmull_test.go b/arm64_lower_sve_pmull_test.go
new file mode 100644
index 000000000..7b1d0b25b
--- /dev/null
+++ b/arm64_lower_sve_pmull_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEPMULLBottomTopCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT svepmulllow(SB),$0-0
+	ZPMULLB Z1.B, Z2.B, Z3.H
+	ZPMULLB Z4.S, Z5.S, Z6.D
+	ZPMULLT Z7.B, Z8.B, Z9.H
+	ZPMULLT Z10.S, Z11.S, Z12.D
+	RET
+TEXT svepmullq(SB),$0-0
+	ZPMULLB Z13.D, Z14.D, Z15.Q
+	ZPMULLT Z16.D, Z17.D, Z18.Q
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"svepmulllow": {Name: "svepmulllow", Ret: Void},
+		"svepmullq":   {Name: "svepmullq", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				`"target-features"="+sve,+sve2,+sve2-aes"`,
+				"@llvm.aarch64.sve.pmullb.pair.nxv16i8",
+				"@llvm.aarch64.sve.pmullb.pair.nxv4i32",
+				"@llvm.aarch64.sve.pmullb.pair.nxv2i64",
+				"@llvm.aarch64.sve.pmullt.pair.nxv16i8",
+				"@llvm.aarch64.sve.pmullt.pair.nxv4i32",
+				"@llvm.aarch64.sve.pmullt.pair.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE PMULLB/T lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-pmull.ll", "arm64-sve-pmull.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPMULLBottomTopRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZPMULLB Z1.H, Z2.H, Z3.S",
+		"ZPMULLB Z1.B, Z2.B, Z3.D",
+		"ZPMULLB Z1.D, Z2.D, Z3.D",
+		"ZPMULLT Z1.Q, Z2.Q, Z3.Q",
+		"ZPMULLT Z1.S, Z2.S",
+		"ZPMULLB.Z Z1.B, Z2.B, Z3.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepmull(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepmull": {Name: "badsvepmull", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE PMULLB/T forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_break.go b/arm64_lower_sve_predicate_break.go
new file mode 100644
index 000000000..42234dd23
--- /dev/null
+++ b/arm64_lower_sve_predicate_break.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateBreakKind uint8
+
+const (
+	arm64SVEPredicateBreakSimple arm64SVEPredicateBreakKind = iota
+	arm64SVEPredicateBreakNext
+	arm64SVEPredicateBreakPair
+)
+
+type arm64SVEPredicateBreakSpec struct {
+	intrinsic  string
+	kind       arm64SVEPredicateBreakKind
+	allowMerge bool
+	flags      bool
+}
+
+var arm64SVEPredicateBreakSpecs = map[Op]arm64SVEPredicateBreakSpec{
+	"PBRKA":   {intrinsic: "brka", kind: arm64SVEPredicateBreakSimple, allowMerge: true},
+	"PBRKAS":  {intrinsic: "brka.z", kind: arm64SVEPredicateBreakSimple, flags: true},
+	"PBRKB":   {intrinsic: "brkb", kind: arm64SVEPredicateBreakSimple, allowMerge: true},
+	"PBRKBS":  {intrinsic: "brkb.z", kind: arm64SVEPredicateBreakSimple, flags: true},
+	"PBRKN":   {intrinsic: "brkn.z", kind: arm64SVEPredicateBreakNext},
+	"PBRKNS":  {intrinsic: "brkn.z", kind: arm64SVEPredicateBreakNext, flags: true},
+	"PBRKPA":  {intrinsic: "brkpa.z", kind: arm64SVEPredicateBreakPair},
+	"PBRKPAS": {intrinsic: "brkpa.z", kind: arm64SVEPredicateBreakPair, flags: true},
+	"PBRKPB":  {intrinsic: "brkpb.z", kind: arm64SVEPredicateBreakPair},
+	"PBRKPBS": {intrinsic: "brkpb.z", kind: arm64SVEPredicateBreakPair, flags: true},
+}
+
+// decodeARM64RawSVEPredicateBreak covers all ten predicate-break encoding
+// rows in Go 1.27. The raw operand fields are shared across the simple,
+// next, and pair forms; only the simple forms permit a merging Pg mode.
+func decodeARM64RawSVEPredicateBreak(word uint32) (Instr, bool) {
+	const (
+		predicateBits = uint32(0x00003def)
+		modeBit       = uint32(1 << 4)
+		pairBits      = uint32(0x000f0000)
+	)
+	forms := [...]struct {
+		op        Op
+		base      uint32
+		kind      arm64SVEPredicateBreakKind
+		allowMode bool
+	}{
+		{"PBRKA", 0x25104000, arm64SVEPredicateBreakSimple, true},
+		{"PBRKAS", 0x25504000, arm64SVEPredicateBreakSimple, false},
+		{"PBRKB", 0x25904000, arm64SVEPredicateBreakSimple, true},
+		{"PBRKBS", 0x25d04000, arm64SVEPredicateBreakSimple, false},
+		{"PBRKN", 0x25184000, arm64SVEPredicateBreakNext, false},
+		{"PBRKNS", 0x25584000, arm64SVEPredicateBreakNext, false},
+		{"PBRKPA", 0x2500c000, arm64SVEPredicateBreakPair, false},
+		{"PBRKPAS", 0x2540c000, arm64SVEPredicateBreakPair, false},
+		{"PBRKPB", 0x2500c010, arm64SVEPredicateBreakPair, false},
+		{"PBRKPBS", 0x2540c010, arm64SVEPredicateBreakPair, false},
+	}
+	for _, form := range forms {
+		variableBits := predicateBits
+		if form.allowMode {
+			variableBits |= modeBit
+		}
+		if form.kind == arm64SVEPredicateBreakPair {
+			variableBits |= pairBits
+		}
+		if word&^variableBits != form.base {
+			continue
+		}
+		first := int(word>>5) & 15
+		governing := int(word>>10) & 15
+		destination := int(word) & 15
+		predicate := func(number int) Operand {
+			return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.B", number))}
+		}
+		governingMode := "Z"
+		if form.allowMode && word&modeBit != 0 {
+			governingMode = "M"
+		}
+		governingOperand := Operand{
+			Kind: OpReg,
+			Reg:  Reg(fmt.Sprintf("P%d.%s", governing, governingMode)),
+		}
+		args := []Operand{predicate(first)}
+		if form.kind == arm64SVEPredicateBreakPair {
+			second := int(word>>16) & 15
+			args = []Operand{predicate(second), predicate(first)}
+		} else if form.kind == arm64SVEPredicateBreakNext {
+			args = []Operand{predicate(destination), predicate(first)}
+		}
+		args = append(args, governingOperand, predicate(destination))
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateBreak(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicateBreakSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	wantArgs := 3
+	if spec.kind != arm64SVEPredicateBreakSimple {
+		wantArgs = 4
+	}
+	if len(ins.Args) != wantArgs {
+		return true, false, fmt.Errorf("arm64 %s expects its %d-operand Go 1.27 predicate-break form: %q", op, wantArgs, ins.Raw)
+	}
+
+	first, firstBits, firstOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	if !firstOK || firstBits != 8 {
+		return true, false, fmt.Errorf("arm64 %s first predicate must be P0..P15.B: %q", op, ins.Raw)
+	}
+	if spec.kind == arm64SVEPredicateBreakSimple {
+		governing, merging := arm64ParseSVEPredicateMode(ins.Args[1], "M", 15)
+		if merging && !spec.allowMerge {
+			return true, false, fmt.Errorf("arm64 %s only accepts a zeroing governing predicate: %q", op, ins.Raw)
+		}
+		if !merging {
+			var zeroing bool
+			governing, zeroing = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 15)
+			if !zeroing {
+				return true, false, fmt.Errorf("arm64 %s governing predicate must be P0..P15/M or P0..P15/Z: %q", op, ins.Raw)
+			}
+		}
+		destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[2])
+		if !destinationOK || destinationBits != 8 {
+			return true, false, fmt.Errorf("arm64 %s destination predicate must be P0..P15.B: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerARM64SVEPredicateBreakSimple(spec, first, governing, destination, merging)
+	}
+
+	second, secondBits, secondOK := arm64ParseSVEPredicateElement(ins.Args[1])
+	governing, governingOK := arm64ParseSVEPredicateMode(ins.Args[2], "Z", 15)
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[3])
+	if !secondOK || secondBits != 8 || !governingOK || !destinationOK || destinationBits != 8 {
+		return true, false, fmt.Errorf("arm64 %s only accepts .B predicates and P0..P15/Z: %q", op, ins.Raw)
+	}
+	if spec.kind == arm64SVEPredicateBreakNext && first != destination {
+		return true, false, fmt.Errorf("arm64 %s requires the first and destination predicates to be identical: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEPredicateBreakThreeSource(spec, first, second, governing, destination)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateBreakSimple(spec arm64SVEPredicateBreakSpec, source, governing, destination int, merging bool) error {
+	sourceValue, predicateType, err := c.loadPRegElements(source, 8)
+	if err != nil {
+		return err
+	}
+	governingValue, _, err := c.loadPRegElements(governing, 8)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if merging {
+		destinationValue, _, err := c.loadPRegElements(destination, 8)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv16i1(%s %s, %s %s, %s %s)\n", result, predicateType, spec.intrinsic, predicateType, destinationValue, predicateType, governingValue, predicateType, sourceValue)
+	} else {
+		intrinsic := spec.intrinsic
+		if spec.allowMerge {
+			intrinsic += ".z"
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv16i1(%s %s, %s %s)\n", result, predicateType, intrinsic, predicateType, governingValue, predicateType, sourceValue)
+	}
+	if err := c.storePRegElements(destination, 8, "%"+result); err != nil {
+		return err
+	}
+	if spec.flags {
+		c.setSVEPredicateFlags(governingValue, "%"+result, predicateType, 16)
+	}
+	return nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateBreakThreeSource(spec arm64SVEPredicateBreakSpec, first, second, governing, destination int) error {
+	firstValue, predicateType, err := c.loadPRegElements(first, 8)
+	if err != nil {
+		return err
+	}
+	secondValue, _, err := c.loadPRegElements(second, 8)
+	if err != nil {
+		return err
+	}
+	governingValue, _, err := c.loadPRegElements(governing, 8)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if spec.kind == arm64SVEPredicateBreakNext {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv16i1(%s %s, %s %s, %s %s)\n", result, predicateType, spec.intrinsic, predicateType, firstValue, predicateType, governingValue, predicateType, secondValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv16i1(%s %s, %s %s, %s %s)\n", result, predicateType, spec.intrinsic, predicateType, governingValue, predicateType, secondValue, predicateType, firstValue)
+	}
+	if err := c.storePRegElements(destination, 8, "%"+result); err != nil {
+		return err
+	}
+	if spec.flags {
+		c.setSVEPredicateFlags(governingValue, "%"+result, predicateType, 16)
+	}
+	return nil
+}
diff --git a/arm64_lower_sve_predicate_break_test.go b/arm64_lower_sve_predicate_break_test.go
new file mode 100644
index 000000000..8d2ccbd63
--- /dev/null
+++ b/arm64_lower_sve_predicate_break_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateBreakCompleteForms() string {
+	return `TEXT svepredicatebreakforms(SB),$0-0
+	PBRKA P15.B, P14.M, P13.B
+	PBRKA P12.B, P11.Z, P10.B
+	PBRKAS P9.B, P8.Z, P7.B
+	PBRKB P6.B, P5.M, P4.B
+	PBRKB P3.B, P2.Z, P1.B
+	PBRKBS P0.B, P15.Z, P14.B
+	PBRKN P13.B, P12.B, P11.Z, P13.B
+	PBRKNS P10.B, P9.B, P8.Z, P10.B
+	PBRKPA P7.B, P6.B, P5.Z, P4.B
+	PBRKPAS P3.B, P2.B, P1.Z, P0.B
+	PBRKPB P15.B, P14.B, P13.Z, P12.B
+	PBRKPBS P11.B, P10.B, P9.Z, P8.B
+	RET
+`
+}
+
+func TestTranslateARM64SVEPredicateBreakCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateBreakCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatebreakforms": {Name: "svepredicatebreakforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.brka.nxv16i1",
+				"@llvm.aarch64.sve.brka.z.nxv16i1",
+				"@llvm.aarch64.sve.brkb.nxv16i1",
+				"@llvm.aarch64.sve.brkb.z.nxv16i1",
+				"@llvm.aarch64.sve.brkn.z.nxv16i1",
+				"@llvm.aarch64.sve.brkpa.z.nxv16i1",
+				"@llvm.aarch64.sve.brkpb.z.nxv16i1",
+				"@llvm.aarch64.sve.ptest.any.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate break lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-break.ll", "arm64-sve-predicate-break.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEPredicateBreakCompleteFamily(t *testing.T) {
+	// The first word occurs in lightning. The remaining words exercise every
+	// row in Go 1.27's predicate-break instruction family, including M/Z.
+	words := []uint32{
+		0x25104000 | 2<<5 | 1<<10 | 3,
+		0x25104000 | 2<<5 | 1<<10 | 3 | 1<<4,
+		0x25504000 | 2<<5 | 1<<10 | 3,
+		0x25904443,
+		0x25904000 | 2<<5 | 1<<10 | 3 | 1<<4,
+		0x25d04000 | 2<<5 | 1<<10 | 3,
+		0x25184000 | 2<<5 | 1<<10 | 3,
+		0x25584000 | 2<<5 | 1<<10 | 3,
+		0x2500c000 | 4<<16 | 2<<5 | 1<<10 | 3,
+		0x2540c000 | 4<<16 | 2<<5 | 1<<10 | 3,
+		0x2500c010 | 4<<16 | 2<<5 | 1<<10 | 3,
+		0x2540c010 | 4<<16 | 2<<5 | 1<<10 | 3,
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEPredicateBreak(SB),$0-0\n")
+	for _, word := range words {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEPredicateBreak": {Name: "rawSVEPredicateBreak", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.brka.nxv16i1",
+				"@llvm.aarch64.sve.brka.z.nxv16i1",
+				"@llvm.aarch64.sve.brkb.nxv16i1",
+				"@llvm.aarch64.sve.brkb.z.nxv16i1",
+				"@llvm.aarch64.sve.brkn.z.nxv16i1",
+				"@llvm.aarch64.sve.brkpa.z.nxv16i1",
+				"@llvm.aarch64.sve.brkpb.z.nxv16i1",
+				"@llvm.aarch64.sve.ptest.any.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw predicate-break IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-predicate-break.ll", "arm64-raw-sve-predicate-break.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEPredicateBreakBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word uint32
+		op   Op
+		args []Reg
+	}{
+		{
+			word: 0x25904443, // lightning: BRKB P3.B, P1/Z, P2.B
+			op:   "PBRKB",
+			args: []Reg{"P2.B", "P1.Z", "P3.B"},
+		},
+		{
+			word: 0x25107dff, // BRKA with high predicates and merging
+			op:   "PBRKA",
+			args: []Reg{"P15.B", "P15.M", "P15.B"},
+		},
+		{
+			word: 0x250ffdef, // BRKPA with high first and second predicates
+			op:   "PBRKPA",
+			args: []Reg{"P15.B", "P15.B", "P15.Z", "P15.B"},
+		},
+	} {
+		ins, ok := decodeARM64RawSVEPredicateBreak(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != len(test.args) {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		for index, want := range test.args {
+			if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+				t.Errorf("%#08x operand %d = %+v, want %s", test.word, index, ins.Args[index], want)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x25904443 | (1 << 9),  // reserved register bit
+		0x25904443 ^ (1 << 20), // adjacent encoding class
+		0x25d04443 | (1 << 4),  // flag-setting form has no merge mode
+	} {
+		if ins, ok := decodeARM64RawSVEPredicateBreak(word); ok {
+			t.Errorf("decoded reserved encoding %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEPredicateBreakRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PBRKA P1.H, P2.M, P3.B",
+		"PBRKAS P1.B, P2.M, P3.B",
+		"PBRKN P1.B, P2.B, P3.Z, P4.B",
+		"PBRKPA P1.B, P2.B, P3.M, P4.B",
+		"PBRKPB P1.B, P2.B, P16.Z, P4.B",
+		"PBRKPBS P1.B, P2.B, P3.Z",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatebreak(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatebreak": {Name: "badsvepredicatebreak", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate break forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_counter.go b/arm64_lower_sve_predicate_counter.go
new file mode 100644
index 000000000..a1749912f
--- /dev/null
+++ b/arm64_lower_sve_predicate_counter.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEPredicateCounterOps = map[Op]struct{}{
+	"PPTRUE": {},
+	"PCNTP":  {},
+	"PPEXT":  {},
+}
+
+// PCNTP has both ordinary predicate and SVE2.1 predicate-as-counter forms.
+// The latter adds one VLx2/VLx4 selector, not a governing predicate register.
+func decodeARM64RawSVEPredicateCount(word uint32) (Instr, bool) {
+	ordinary := word&^uint32(0x00c03dff) == 0x25208000
+	counter := word&^uint32(0x00c005ff) == 0x25208200
+	if !ordinary && !counter {
+		return Instr{}, false
+	}
+	width := "BHSD"[word>>22&3]
+	destination := Reg(fmt.Sprintf("R%d", word&31))
+	if word&31 == 31 {
+		destination = ZR
+	}
+	args := []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%c", word>>5&15, width))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", word>>10&15))},
+		{Kind: OpReg, Reg: destination},
+	}
+	if counter {
+		args[0] = Operand{Kind: OpIdent, Ident: fmt.Sprintf("VLX%d", 2<<uint(word>>10&1))}
+		args[1] = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("PN%d.%c", word>>5&15, width))}
+	}
+	return Instr{Op: "PCNTP", Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func arm64SVEPredicateCounterNeedsSVE2P1(op Op, ins Instr) bool {
+	if op == "PPTRUE" || op == "PPEXT" {
+		return true
+	}
+	return op == "PCNTP" && len(ins.Args) == 3 && ins.Args[1].Kind == OpReg && strings.HasPrefix(strings.ToUpper(string(ins.Args[1].Reg)), "PN")
+}
+
+func arm64ParseSVEPredicateCounterElement(operand Operand) (index, elementBits int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(operand.Reg))), ".")
+	if len(parts) != 2 || !strings.HasPrefix(parts[0], "PN") {
+		return 0, 0, false
+	}
+	if _, err := fmt.Sscanf(parts[0], "PN%d", &index); err != nil || index < 0 || index > 15 {
+		return 0, 0, false
+	}
+	elementBits, ok = map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[parts[1]]
+	return index, elementBits, ok
+}
+
+func arm64ParseSVEPredicateCounterIndexed(operand Operand) (index, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	open := strings.IndexByte(text, '[')
+	if open < 0 || !strings.HasSuffix(text, "]") || !strings.HasPrefix(text, "PN") {
+		return 0, 0, false
+	}
+	if _, err := fmt.Sscanf(text[:open], "PN%d", &index); err != nil || index < 8 || index > 15 {
+		return 0, 0, false
+	}
+	if _, err := fmt.Sscanf(text[open:], "[%d]", &lane); err != nil || lane < 0 || lane > 3 {
+		return 0, 0, false
+	}
+	return index, lane, true
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateCounter(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if _, ok := arm64SVEPredicateCounterOps[op]; !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if op == "PCNTP" {
+		return c.lowerARM64SVEPredicateCount(ins)
+	}
+	if op == "PPEXT" {
+		return c.lowerARM64SVEPredicateExtract(ins)
+	}
+	if len(ins.Args) != 1 {
+		return true, false, fmt.Errorf("arm64 PPTRUE expects PNd.T: %q", ins.Raw)
+	}
+	destination, elementBits, destinationOK := arm64ParseSVEPredicateCounterElement(ins.Args[0])
+	if !destinationOK || destination < 8 {
+		return true, false, fmt.Errorf("arm64 PPTRUE only accepts PN8..PN15.B/H/S/D: %q", ins.Raw)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call target(\"aarch64.svcount\") @llvm.aarch64.sve.ptrue.c%d()\n", result, elementBits)
+	return true, false, c.storePNReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateExtract(ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 PPEXT expects PNn[index], Pd.T or PNn[index], [Pd1.T, Pd2.T]: %q", ins.Raw)
+	}
+	counter, lane, counterOK := arm64ParseSVEPredicateCounterIndexed(ins.Args[0])
+	if !counterOK {
+		return true, false, fmt.Errorf("arm64 PPEXT source must be PN8..PN15[0..3]: %q", ins.Raw)
+	}
+	counterValue, err := c.loadPNReg(counter)
+	if err != nil {
+		return true, false, err
+	}
+	if ins.Args[1].Kind == OpReg {
+		destination, elementBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[1])
+		if !destinationOK {
+			return true, false, fmt.Errorf("arm64 PPEXT destination must be P0..P15.B/H/S/D: %q", ins.Raw)
+		}
+		lanes := 128 / elementBits
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pext.nxv%di1(target(\"aarch64.svcount\") %s, i32 %d)\n", result, predicateType, lanes, counterValue, lane)
+		return true, false, c.storePRegElements(destination, elementBits, "%"+result)
+	}
+	if ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 2 || lane > 1 {
+		return true, false, fmt.Errorf("arm64 PPEXT pair form requires lane 0..1 and exactly two predicate destinations: %q", ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEPredicateElement(Operand{Kind: OpReg, Reg: ins.Args[1].RegList[0]})
+	second, secondBits, secondOK := arm64ParseSVEPredicateElement(Operand{Kind: OpReg, Reg: ins.Args[1].RegList[1]})
+	if !firstOK || !secondOK || firstBits != secondBits || second != first+1 {
+		return true, false, fmt.Errorf("arm64 PPEXT pair destinations must be two consecutive predicates with matching arrangements: %q", ins.Raw)
+	}
+	lanes := 128 / firstBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	aggregateType := fmt.Sprintf("{ %s, %s }", predicateType, predicateType)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pext.x2.nxv%di1(target(\"aarch64.svcount\") %s, i32 %d)\n", result, aggregateType, lanes, counterValue, lane)
+	firstValue := c.newTmp()
+	secondValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", firstValue, aggregateType, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", secondValue, aggregateType, result)
+	if err := c.storePRegElements(first, firstBits, "%"+firstValue); err != nil {
+		return true, false, err
+	}
+	return true, false, c.storePRegElements(second, secondBits, "%"+secondValue)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateCount(ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+		return true, false, fmt.Errorf("arm64 PCNTP expects Pn.T, Pg, Xd or VLx2|VLx4, PNn.T, Xd: %q", ins.Raw)
+	}
+	if tested, elementBits, testedOK := arm64ParseSVEPredicateElement(ins.Args[0]); testedOK {
+		governing, governingOK := arm64ParseSVEPredicateBare(ins.Args[1], 15)
+		if !governingOK {
+			return true, false, fmt.Errorf("arm64 PCNTP ordinary predicate form requires a bare P0..P15 governing predicate: %q", ins.Raw)
+		}
+		governingValue, predicateType, err := c.loadPRegElements(governing, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		testedValue, _, err := c.loadPRegElements(tested, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := 128 / elementBits
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.cntp.nxv%di1(%s %s, %s %s)\n", result, lanes, predicateType, governingValue, predicateType, testedValue)
+		return true, false, c.storeReg(ins.Args[2].Reg, "%"+result)
+	}
+
+	multiplier := 0
+	if ins.Args[0].Kind == OpIdent {
+		switch strings.ToUpper(ins.Args[0].Ident) {
+		case "VLX2":
+			multiplier = 2
+		case "VLX4":
+			multiplier = 4
+		}
+	}
+	counter, elementBits, counterOK := arm64ParseSVEPredicateCounterElement(ins.Args[1])
+	if multiplier == 0 || !counterOK {
+		return true, false, fmt.Errorf("arm64 PCNTP predicate-as-counter form requires VLx2|VLx4 and PN0..PN15.B/H/S/D: %q", ins.Raw)
+	}
+	counterValue, err := c.loadPNReg(counter)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.cntp.c%d(target(\"aarch64.svcount\") %s, i32 %d)\n", result, elementBits, counterValue, multiplier)
+	return true, false, c.storeReg(ins.Args[2].Reg, "%"+result)
+}
diff --git a/arm64_lower_sve_predicate_counter_test.go b/arm64_lower_sve_predicate_counter_test.go
new file mode 100644
index 000000000..413ebb06c
--- /dev/null
+++ b/arm64_lower_sve_predicate_counter_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateCounterCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatecountertrueforms(SB),$0-0\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tPPTRUE PN%d.%s\n", 8+index, width)
+		fmt.Fprintf(&source, "\tPCNTP P%d.%s, P%d, R%d\n", 15-index, width, 11-index, index)
+		fmt.Fprintf(&source, "\tPCNTP VLx2, PN%d.%s, R%d\n", index, width, 4+index)
+		fmt.Fprintf(&source, "\tPCNTP VLx4, PN%d.%s, R%d\n", 12+index, width, 8+index)
+		fmt.Fprintf(&source, "\tPPEXT PN%d[%d], P%d.%s\n", 8+index, index, index, width)
+		fmt.Fprintf(&source, "\tPPEXT PN%d[%d], [P%d.%s, P%d.%s]\n", 12+index, index%2, 2*index, width, 2*index+1, width)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicateCounterCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateCounterCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatecountertrueforms": {Name: "svepredicatecountertrueforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.ptrue.c8",
+				"@llvm.aarch64.sve.ptrue.c16",
+				"@llvm.aarch64.sve.ptrue.c32",
+				"@llvm.aarch64.sve.ptrue.c64",
+				"@llvm.aarch64.sve.cntp.nxv16i1",
+				"@llvm.aarch64.sve.cntp.nxv2i1",
+				"@llvm.aarch64.sve.cntp.c8",
+				"@llvm.aarch64.sve.cntp.c64",
+				"@llvm.aarch64.sve.pext.nxv16i1",
+				"@llvm.aarch64.sve.pext.nxv2i1",
+				"@llvm.aarch64.sve.pext.x2.nxv8i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate-as-counter true lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-counter.ll", "arm64-sve-predicate-counter.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateCounterRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PPTRUE P8.B",
+		"PPTRUE PN7.B",
+		"PPTRUE PN16.B",
+		"PPTRUE PN8.Q",
+		"PPTRUE PN8.B, PN9.B",
+		"PCNTP P1.B, P2.Z, R3",
+		"PCNTP VLx3, PN8.B, R3",
+		"PCNTP VLx2, PN16.B, R3",
+		"PCNTP VLx2, PN8.Q, R3",
+		"PCNTP VLx2, PN8.B, R31",
+		"PPEXT PN7[0], P1.B",
+		"PPEXT PN8[4], P1.B",
+		"PPEXT PN8[2], [P1.B, P2.B]",
+		"PPEXT PN8[0], [P1.B, P3.B]",
+		"PPEXT PN8[0], [P1.B, P2.H]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatecounter(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatecounter": {Name: "badsvepredicatecounter", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's predicate-as-counter true forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_incdec.go b/arm64_lower_sve_predicate_incdec.go
new file mode 100644
index 000000000..2a094044d
--- /dev/null
+++ b/arm64_lower_sve_predicate_incdec.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateIncDecSpec struct {
+	increment  bool
+	saturating bool
+	unsigned   bool
+	word       bool
+	splitWord  bool
+}
+
+var arm64SVEPredicateIncDecSpecs = map[Op]arm64SVEPredicateIncDecSpec{
+	"PDECP":    {},
+	"PINCP":    {increment: true},
+	"PSQDECP":  {saturating: true},
+	"PSQDECPW": {saturating: true, word: true, splitWord: true},
+	"PSQINCP":  {increment: true, saturating: true},
+	"PSQINCPW": {increment: true, saturating: true, word: true, splitWord: true},
+	"PUQDECP":  {saturating: true, unsigned: true},
+	"PUQDECPW": {saturating: true, unsigned: true, word: true},
+	"PUQINCP":  {increment: true, saturating: true, unsigned: true},
+	"PUQINCPW": {increment: true, saturating: true, unsigned: true, word: true},
+}
+
+// decodeARM64RawSVEPredicateIncDec covers the ten Go 1.27 predicate
+// increment/decrement rows. Their only variable fields are element size,
+// predicate register, and destination scalar register.
+func decodeARM64RawSVEPredicateIncDec(word uint32) (Instr, bool) {
+	const variableBits = uint32(0x00c001ff)
+	forms := [...]struct {
+		op   Op
+		base uint32
+	}{
+		{"PDECP", 0x252d8800},
+		{"PINCP", 0x252c8800},
+		{"PSQDECP", 0x252a8c00},
+		{"PSQDECPW", 0x252a8800},
+		{"PSQINCP", 0x25288c00},
+		{"PSQINCPW", 0x25288800},
+		{"PUQDECP", 0x252b8c00},
+		{"PUQDECPW", 0x252b8800},
+		{"PUQINCP", 0x25298c00},
+		{"PUQINCPW", 0x25298800},
+	}
+	for _, form := range forms {
+		if word&^variableBits != form.base {
+			continue
+		}
+		width := [...]string{"B", "H", "S", "D"}[word>>22&3]
+		predicate := Operand{
+			Kind: OpReg,
+			Reg:  Reg(fmt.Sprintf("P%d.%s", word>>5&15, width)),
+		}
+		register := Reg(fmt.Sprintf("R%d", word&31))
+		if word&31 == 31 {
+			register = "ZR"
+		}
+		scalar := Operand{Kind: OpReg, Reg: register}
+		args := []Operand{predicate, scalar}
+		if arm64SVEPredicateIncDecSpecs[form.op].splitWord {
+			args = []Operand{scalar, predicate, scalar}
+		}
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateIncDec(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicateIncDecSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	predicateOperand := 0
+	registerOperand := 1
+	if spec.splitWord {
+		if len(ins.Args) != 3 {
+			return true, false, fmt.Errorf("arm64 %s expects Wdn, Pm.T, Xdn: %q", op, ins.Raw)
+		}
+		predicateOperand = 1
+		registerOperand = 2
+		if ins.Args[0].Kind != OpReg || ins.Args[2].Kind != OpReg || ins.Args[0].Reg != ins.Args[2].Reg {
+			return true, false, fmt.Errorf("arm64 %s requires matching Wdn and Xdn registers: %q", op, ins.Raw)
+		}
+	} else if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Pm.T, Xdn: %q", op, ins.Raw)
+	}
+	predicate, elementBits, predicateOK := arm64ParseSVEPredicateElement(ins.Args[predicateOperand])
+	register, registerOK := arm64SVEIncDecRegister(ins.Args[registerOperand])
+	if !predicateOK || !registerOK {
+		return true, false, fmt.Errorf("arm64 %s requires P0..P15.B/H/S/D and a general register or ZR: %q", op, ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	scalar, err := c.loadReg(register)
+	if err != nil {
+		return true, false, err
+	}
+	if !spec.saturating {
+		governing, _, err := c.allTruePRegElements(elementBits)
+		if err != nil {
+			return true, false, err
+		}
+		lanes := 128 / elementBits
+		count := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.cntp.nxv%di1(%s %s, %s %s)\n", count, lanes, predicateType, governing, predicateType, predicateValue)
+		result := c.newTmp()
+		operation := "sub"
+		if spec.increment {
+			operation = "add"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s i64 %s, %%%s\n", result, operation, scalar, count)
+		return true, false, c.storeReg(register, "%"+result)
+	}
+	scalarType := "i64"
+	width := 64
+	if spec.word {
+		width = 32
+		scalarType = "i32"
+		truncated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", truncated, scalar)
+		scalar = "%" + truncated
+	}
+	intrinsic := "sqdec"
+	if spec.unsigned {
+		intrinsic = "uqdec"
+	}
+	if spec.increment {
+		intrinsic = strings.Replace(intrinsic, "dec", "inc", 1)
+	}
+	lanes := 128 / elementBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%sp.n%d.nxv%di1(%s %s, %s %s)\n", result, scalarType, intrinsic, width, lanes, scalarType, scalar, predicateType, predicateValue)
+	value := "%" + result
+	if spec.word {
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", extended, value)
+		value = "%" + extended
+	}
+	return true, false, c.storeReg(register, value)
+}
+
+func arm64SVEIncDecRegister(operand Operand) (Reg, bool) {
+	if operand.Kind != OpReg || !isARM64GeneralOrZeroReg(operand.Reg) {
+		return "", false
+	}
+	return operand.Reg, true
+}
diff --git a/arm64_lower_sve_predicate_incdec_test.go b/arm64_lower_sve_predicate_incdec_test.go
new file mode 100644
index 000000000..067bbb889
--- /dev/null
+++ b/arm64_lower_sve_predicate_incdec_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateIncDecCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicateincdecforms(SB),$0-0\n")
+	for widthIndex, width := range []string{"B", "H", "S", "D"} {
+		predicate := 1 + widthIndex
+		register := 5 + widthIndex
+		fmt.Fprintf(&source, "\tPDECP P%d.%s, R%d\n", predicate, width, register)
+		fmt.Fprintf(&source, "\tPINCP P%d.%s, R%d\n", predicate, width, register)
+		for _, op := range []string{"PSQDECP", "PSQINCP", "PUQDECP", "PUQINCP"} {
+			fmt.Fprintf(&source, "\t%s P%d.%s, R%d\n", op, predicate, width, register)
+		}
+		for _, op := range []string{"PSQDECPW", "PSQINCPW"} {
+			fmt.Fprintf(&source, "\t%s R%d, P%d.%s, R%d\n", op, register, predicate, width, register)
+		}
+		for _, op := range []string{"PUQDECPW", "PUQINCPW"} {
+			fmt.Fprintf(&source, "\t%s P%d.%s, R%d\n", op, predicate, width, register)
+		}
+	}
+	source.WriteString("\tPDECP P14.S, ZR\n\tPSQDECP P14.S, ZR\n\tPUQINCPW P14.S, ZR\n\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicateIncDecCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateIncDecCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicateincdecforms": {Name: "svepredicateincdecforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.cntp.nxv16i1",
+				"@llvm.aarch64.sve.cntp.nxv2i1",
+				"@llvm.aarch64.sve.sqdecp.n64.nxv8i1",
+				"@llvm.aarch64.sve.sqincp.n32.nxv4i1",
+				"@llvm.aarch64.sve.uqdecp.n64.nxv2i1",
+				"@llvm.aarch64.sve.uqincp.n32.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate inc/dec lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-incdec.ll", "arm64-sve-predicate-incdec.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEPredicateIncDecCompleteFamily(t *testing.T) {
+	// Go 1.27 supplies ten predicate inc/dec rows with B/H/S/D widths.
+	// lightning emits the PINCP B form at 0x252c8862.
+	forms := []uint32{
+		0x252d8800, 0x252c8800,
+		0x252a8c00, 0x252a8800,
+		0x25288c00, 0x25288800,
+		0x252b8c00, 0x252b8800,
+		0x25298c00, 0x25298800,
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEPredicateIncDec(SB),$0-0\n")
+	for _, base := range forms {
+		for size := uint32(0); size < 4; size++ {
+			word := base | size<<22 | 3<<5 | 2
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEPredicateIncDec": {Name: "rawSVEPredicateIncDec", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.cntp.nxv16i1",
+				"@llvm.aarch64.sve.cntp.nxv2i1",
+				"@llvm.aarch64.sve.sqdecp.n64.nxv8i1",
+				"@llvm.aarch64.sve.sqincp.n32.nxv4i1",
+				"@llvm.aarch64.sve.uqdecp.n64.nxv2i1",
+				"@llvm.aarch64.sve.uqincp.n32.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw predicate inc/dec IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-predicate-incdec.ll", "arm64-raw-sve-predicate-incdec.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEPredicateIncDecBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word uint32
+		op   Op
+		args []Reg
+	}{
+		{0x252c8862, "PINCP", []Reg{"P3.B", "R2"}},
+		{0x25ed89ff, "PDECP", []Reg{"P15.D", "ZR"}},
+		{0x25e88862, "PSQINCPW", []Reg{"R2", "P3.D", "R2"}},
+	} {
+		ins, ok := decodeARM64RawSVEPredicateIncDec(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != len(test.args) {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		for index, want := range test.args {
+			if ins.Args[index].Kind != OpReg || ins.Args[index].Reg != want {
+				t.Errorf("%#08x operand %d = %+v, want %s", test.word, index, ins.Args[index], want)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x252c8862 | (1 << 9),
+		0x252c8862 | (1 << 10),
+		0x252c8862 ^ (1 << 15),
+	} {
+		if ins, ok := decodeARM64RawSVEPredicateIncDec(word); ok {
+			t.Errorf("decoded reserved encoding %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEPredicateIncDecRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PDECP P1.Q, R2",
+		"PINCP P1.B, RSP",
+		"PSQDECPW R1, P2.B, R3",
+		"PUQINCPW R1, P2.B, R1",
+		"PSQINCP P1.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicateincdec(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicateincdec": {Name: "badsvepredicateincdec", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate inc/dec forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_iterate.go b/arm64_lower_sve_predicate_iterate.go
new file mode 100644
index 000000000..11968e827
--- /dev/null
+++ b/arm64_lower_sve_predicate_iterate.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateIterateSpec struct {
+	intrinsic string
+	byteOnly  bool
+}
+
+var arm64SVEPredicateIterateSpecs = map[Op]arm64SVEPredicateIterateSpec{
+	"PPFIRST": {intrinsic: "pfirst", byteOnly: true},
+	"PPNEXT":  {intrinsic: "pnext"},
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateIterate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicateIterateSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Pdn.T, Pg, Pdn.T: %q", op, ins.Raw)
+	}
+	current, currentBits, currentOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	governing, governingOK := arm64ParseSVEPredicateBare(ins.Args[1], 15)
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[2])
+	if !currentOK || !governingOK || !destinationOK || current != destination || currentBits != destinationBits || (spec.byteOnly && currentBits != 8) {
+		return true, false, fmt.Errorf("arm64 %s operands do not match its Go 1.27 read-modify-write predicate form: %q", op, ins.Raw)
+	}
+	governingValue, predicateType, err := c.loadPRegElements(governing, currentBits)
+	if err != nil {
+		return true, false, err
+	}
+	currentValue, _, err := c.loadPRegElements(current, currentBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / currentBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di1(%s %s, %s %s)\n", result, predicateType, spec.intrinsic, lanes, predicateType, governingValue, predicateType, currentValue)
+	if err := c.storePRegElements(destination, currentBits, "%"+result); err != nil {
+		return true, false, err
+	}
+	c.setSVEPredicateFlags(governingValue, "%"+result, predicateType, lanes)
+	return true, false, nil
+}
diff --git a/arm64_lower_sve_predicate_iterate_test.go b/arm64_lower_sve_predicate_iterate_test.go
new file mode 100644
index 000000000..361dd3db7
--- /dev/null
+++ b/arm64_lower_sve_predicate_iterate_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateIterateCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicateiterateforms(SB),$0-0\n")
+	source.WriteString("\tPPFIRST P15.B, P14, P15.B\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tPPNEXT P%d.%s, P%d, P%d.%s\n", 13-index, width, 9-index, 13-index, width)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicateIterateCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateIterateCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicateiterateforms": {Name: "svepredicateiterateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.pfirst.nxv16i1",
+				"@llvm.aarch64.sve.pnext.nxv16i1",
+				"@llvm.aarch64.sve.pnext.nxv8i1",
+				"@llvm.aarch64.sve.pnext.nxv4i1",
+				"@llvm.aarch64.sve.pnext.nxv2i1",
+				"@llvm.aarch64.sve.ptest.any.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate iterate lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-iterate.ll", "arm64-sve-predicate-iterate.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateIterateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PPFIRST P1.H, P2, P1.H",
+		"PPFIRST P1.B, P2.Z, P1.B",
+		"PPFIRST P1.B, P2, P3.B",
+		"PPNEXT P1.B, P2.Z, P1.B",
+		"PPNEXT P1.B, P2, P3.B",
+		"PPNEXT P1.B, P2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicateiterate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicateiterate": {Name: "badsvepredicateiterate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate iterate forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_logical.go b/arm64_lower_sve_predicate_logical.go
new file mode 100644
index 000000000..d39fb76d9
--- /dev/null
+++ b/arm64_lower_sve_predicate_logical.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateLogicalSpec struct {
+	operation string
+	flags     bool
+}
+
+var arm64SVEPredicateLogicalSpecs = map[Op]arm64SVEPredicateLogicalSpec{
+	"PAND":   {operation: "and"},
+	"PANDS":  {operation: "and", flags: true},
+	"PBIC":   {operation: "bic"},
+	"PBICS":  {operation: "bic", flags: true},
+	"PEOR":   {operation: "xor"},
+	"PEORS":  {operation: "xor", flags: true},
+	"PNAND":  {operation: "nand"},
+	"PNANDS": {operation: "nand", flags: true},
+	"PNOR":   {operation: "nor"},
+	"PNORS":  {operation: "nor", flags: true},
+	"PORN":   {operation: "orn"},
+	"PORNS":  {operation: "orn", flags: true},
+	"PORR":   {operation: "or"},
+	"PORRS":  {operation: "or", flags: true},
+	"PSEL":   {operation: "select"},
+}
+
+// Logical and select rows share Pm/Pn/Pg/Pd fields and .B elements. Logical
+// forms zero inactive lanes; PSEL chooses its first operand for those lanes.
+func decodeARM64RawSVEPredicateLogical(word uint32) (Instr, bool) {
+	const variableBits = uint32(0x000f3def)
+	forms := [...]struct {
+		op   Op
+		base uint32
+	}{
+		{"PAND", 0x25004000}, {"PANDS", 0x25404000},
+		{"PBIC", 0x25004010}, {"PBICS", 0x25404010},
+		{"PEOR", 0x25004200}, {"PEORS", 0x25404200},
+		{"PNAND", 0x25804210}, {"PNANDS", 0x25c04210},
+		{"PNOR", 0x25804200}, {"PNORS", 0x25c04200},
+		{"PORN", 0x25804010}, {"PORNS", 0x25c04010},
+		{"PORR", 0x25804000}, {"PORRS", 0x25c04000},
+		{"PSEL", 0x25004210},
+	}
+	for _, form := range forms {
+		if word&^variableBits != form.base {
+			continue
+		}
+		predicate := func(number uint32) Operand {
+			return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.B", number))}
+		}
+		args := []Operand{
+			predicate(word >> 16 & 15),
+			predicate(word >> 5 & 15),
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", word>>10&15))},
+			predicate(word & 15),
+		}
+		if form.op == "PSEL" {
+			args[2].Reg = Reg(fmt.Sprintf("P%d", word>>10&15))
+		}
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateLogical(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicateLogicalSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	governingSyntax := "Pg/Z"
+	if spec.operation == "select" {
+		governingSyntax = "Pg"
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Pm.B, Pn.B, %s, Pd.B: %q", op, governingSyntax, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	second, secondBits, secondOK := arm64ParseSVEPredicateElement(ins.Args[1])
+	governing, governingOK := arm64ParseSVEPredicateMode(ins.Args[2], "Z", 15)
+	if spec.operation == "select" {
+		governing, governingOK = arm64ParseSVEPredicateBare(ins.Args[2], 15)
+	}
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[3])
+	if !firstOK || !secondOK || !governingOK || !destinationOK || firstBits != 8 || secondBits != 8 || destinationBits != 8 {
+		return true, false, fmt.Errorf("arm64 %s only accepts the Go 1.27 Pm.B, Pn.B, %s, Pd.B form: %q", op, governingSyntax, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEPredicateLogicalForm(spec, first, second, governing, destination)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateLogicalForm(spec arm64SVEPredicateLogicalSpec, first, second, governing, destination int) error {
+	firstValue, predicateType, err := c.loadPRegElements(first, 8)
+	if err != nil {
+		return err
+	}
+	secondValue, _, err := c.loadPRegElements(second, 8)
+	if err != nil {
+		return err
+	}
+	governingValue, _, err := c.loadPRegElements(governing, 8)
+	if err != nil {
+		return err
+	}
+
+	result := c.newTmp()
+	switch spec.operation {
+	case "select":
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", result, predicateType, governingValue, predicateType, secondValue, predicateType, firstValue)
+		return c.storePReg(destination, "%"+result)
+	case "and", "xor", "or":
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, spec.operation, predicateType, secondValue, firstValue)
+	case "bic", "orn":
+		inverted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, splat (i1 true)\n", inverted, predicateType, firstValue)
+		operation := "and"
+		if spec.operation == "orn" {
+			operation = "or"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, operation, predicateType, secondValue, inverted)
+	case "nand", "nor":
+		combined := c.newTmp()
+		operation := "and"
+		if spec.operation == "nor" {
+			operation = "or"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", combined, operation, predicateType, secondValue, firstValue)
+		fmt.Fprintf(c.b, "  %%%s = xor %s %%%s, splat (i1 true)\n", result, predicateType, combined)
+	default:
+		return fmt.Errorf("unsupported ARM64 SVE predicate logical operation %q", spec.operation)
+	}
+
+	active := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and %s %%%s, %s\n", active, predicateType, result, governingValue)
+	if err := c.storePRegElements(destination, 8, "%"+active); err != nil {
+		return err
+	}
+	if !spec.flags {
+		return nil
+	}
+	c.setSVEPredicateFlags(governingValue, "%"+active, predicateType, 16)
+	return nil
+}
diff --git a/arm64_lower_sve_predicate_logical_test.go b/arm64_lower_sve_predicate_logical_test.go
new file mode 100644
index 000000000..62fe5ad41
--- /dev/null
+++ b/arm64_lower_sve_predicate_logical_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateLogicalCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatelogicalforms(SB),$0-0\n")
+	for index, op := range []string{"PAND", "PANDS", "PBIC", "PBICS", "PEOR", "PEORS", "PNAND", "PNANDS", "PNOR", "PNORS", "PORN", "PORNS", "PORR", "PORRS"} {
+		predicate := index % 16
+		source.WriteString(fmt.Sprintf("\t%s P15.B, P14.B, P%d.Z, P13.B\n", op, predicate))
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicateLogicalCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateLogicalCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatelogicalforms": {Name: "svepredicatelogicalforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, "@llvm.aarch64.sve.ptest.any.nxv", "@llvm.aarch64.sve.ptest.first.nxv", "@llvm.aarch64.sve.ptest.last.nxv"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate logical lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-logical.ll", "arm64-sve-predicate-logical.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEPredicateLogicalCompleteFamily(t *testing.T) {
+	// All fourteen Go 1.27 rows share the same four predicate register
+	// fields. The ORRS word occurs in lightning.
+	bases := []uint32{
+		0x25004000, 0x25404000,
+		0x25004010, 0x25404010,
+		0x25004200, 0x25404200,
+		0x25804210, 0x25c04210,
+		0x25804200, 0x25c04200,
+		0x25804010, 0x25c04010,
+		0x25804000, 0x25c04000,
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEPredicateLogical(SB),$0-0\n")
+	for _, base := range bases {
+		word := base | 3<<16 | 1<<10 | 2<<5 | 2
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEPredicateLogical": {Name: "rawSVEPredicateLogical", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.ptest.any.nxv",
+				"@llvm.aarch64.sve.ptest.first.nxv",
+				"@llvm.aarch64.sve.ptest.last.nxv",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw predicate logical IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-predicate-logical.ll", "arm64-raw-sve-predicate-logical.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEPredicateLogicalBoundaries(t *testing.T) {
+	observed, ok := decodeARM64RawSVEPredicateLogical(0x25c34442)
+	if !ok || observed.Op != "PORRS" || len(observed.Args) != 4 {
+		t.Fatalf("decode lightning ORRS = %+v, %v", observed, ok)
+	}
+	for index, want := range []Reg{"P3.B", "P2.B", "P1.Z", "P2.B"} {
+		if observed.Args[index].Kind != OpReg || observed.Args[index].Reg != want {
+			t.Errorf("lightning ORRS operand %d = %+v, want %s", index, observed.Args[index], want)
+		}
+	}
+	for _, word := range []uint32{
+		0x25c34442 | (1 << 20),
+		0x25c34442 ^ (1 << 14),
+	} {
+		if ins, ok := decodeARM64RawSVEPredicateLogical(word); ok {
+			t.Errorf("decoded invalid predicate logical %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEPredicateLogicalRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PAND P1.B, P2.H, P0.Z, P3.B",
+		"PBIC P1.B, P2.B, P0.M, P3.B",
+		"PEOR P1.B, P2.B, P16.Z, P3.B",
+		"PNAND P1.B, P2.B, P0.Z, P3.H",
+		"PORR P1, P2.B, P0.Z, P3.B",
+		"PORRS P1.B, P2.B, P0.Z",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatelogical(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatelogical": {Name: "badsvepredicatelogical", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate logical forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_memory.go b/arm64_lower_sve_predicate_memory.go
new file mode 100644
index 000000000..193193a16
--- /dev/null
+++ b/arm64_lower_sve_predicate_memory.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEPredicateMemoryOps = map[Op]int{
+	"PLDR":  0,
+	"PSTR":  0,
+	"PPRFB": 8,
+	"PPRFH": 16,
+	"PPRFW": 32,
+	"PPRFD": 64,
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	elementBits, ok := arm64SVEPredicateMemoryOps[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if op == "PLDR" || op == "PSTR" {
+		return c.lowerARM64SVEPredicateLoadStore(op, ins)
+	}
+	return c.lowerARM64SVEPredicatePrefetch(op, elementBits, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateLoadStore(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects its two-operand Go 1.27 form: %q", op, ins.Raw)
+	}
+	memoryOperand := 0
+	predicateOperand := 1
+	if op == "PSTR" {
+		predicateOperand, memoryOperand = memoryOperand, predicateOperand
+	}
+	if ins.Args[memoryOperand].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s requires a MUL VL memory operand: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[predicateOperand], 15)
+	if !predicateOK {
+		return true, false, fmt.Errorf("arm64 %s predicate must be P0..P15 without an arrangement: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVEVLAddress(ins.Args[memoryOperand].Mem, -256, 255, 2)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	if op == "PLDR" {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load <vscale x 16 x i1>, ptr %%%s, align 1\n", value, pointer)
+		return true, false, c.storePReg(predicate, "%"+value)
+	}
+	value, err := c.loadPReg(predicate)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  store <vscale x 16 x i1> %s, ptr %%%s, align 1\n", value, pointer)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicatePrefetch(op Op, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 3 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s expects memory, Pg, prfop: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	hint, hintOK := arm64SVEPrefetchHint(ins.Args[2])
+	if !predicateOK || !hintOK {
+		return true, false, fmt.Errorf("arm64 %s requires P0..P7 and an SVE data prefetch operation: %q", op, ins.Raw)
+	}
+	memory := ins.Args[0].Mem
+	var address string
+	if memory.Index != "" {
+		address, err = c.arm64SVERegisterOffsetAddress(memory, int64(elementBits/8))
+	} else {
+		address, err = c.arm64SVEVLAddress(memory, -32, 31, 16)
+	}
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	lanes := 128 / elementBits
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.prf.nxv%di1(%s %s, ptr %%%s, i32 %d)\n", lanes, predicateType, predicateValue, pointer, hint)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) arm64SVEVLAddress(memory MemRef, minimum, maximum, bytesPerVScale int64) (string, error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Index != "" || memory.Off != 0 {
+		return "", fmt.Errorf("address is not a scalar base plus MUL VL immediate")
+	}
+	baseReg, ok := arm64SVEPhysicalMemoryBase(memory.Base)
+	if !ok {
+		return "", fmt.Errorf("address base must be R0..R30, RSP, or ZR")
+	}
+	multiplier := int64(0)
+	if memory.OffRaw != "" {
+		var parsed bool
+		multiplier, parsed = parseVectorLengthScaleExpr(memory.OffRaw)
+		if !parsed {
+			return "", fmt.Errorf("address displacement must be VL*imm")
+		}
+	}
+	if multiplier < minimum || multiplier > maximum {
+		return "", fmt.Errorf("MUL VL immediate %d is outside [%d,%d]", multiplier, minimum, maximum)
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return "", err
+	}
+	if multiplier == 0 {
+		return base, nil
+	}
+	vscale := c.newTmp()
+	offset := c.newTmp()
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.vscale.i64()\n", vscale)
+	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", offset, vscale, multiplier*bytesPerVScale)
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", address, base, offset)
+	return "%" + address, nil
+}
+
+func (c *arm64Ctx) arm64SVERegisterOffsetAddress(memory MemRef, expectedScale int64) (string, error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" || memory.IndexExt != "" || memory.Scale != expectedScale {
+		return "", fmt.Errorf("register-offset address requires its exact LSL element scale")
+	}
+	baseReg := memory.Base
+	indexReg := memory.Index
+	// PPRFB's unshifted Go syntax is (Xm)(Xn|RSP); the generic Plan 9
+	// memory parser records the first parenthesis as Base, so restore the
+	// architectural base/index order here. Shifted H/W/D forms are normalized
+	// by parseMem into the architectural order.
+	if expectedScale == 1 {
+		baseReg, indexReg = indexReg, baseReg
+	}
+	baseReg, baseOK := arm64SVEPhysicalMemoryBase(baseReg)
+	if !baseOK || !isARM64GeneralOrZeroReg(indexReg) || indexReg == ZR {
+		return "", fmt.Errorf("register-offset address requires R0..R30 index and scalar base")
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return "", err
+	}
+	index, err := c.loadReg(indexReg)
+	if err != nil {
+		return "", err
+	}
+	scaled := index
+	if expectedScale != 1 {
+		shifted := c.newTmp()
+		shift := map[int64]int64{2: 1, 4: 2, 8: 3, 16: 4}[expectedScale]
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, %d\n", shifted, index, shift)
+		scaled = "%" + shifted
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", address, base, scaled)
+	return "%" + address, nil
+}
+
+func arm64SVEPhysicalMemoryBase(register Reg) (Reg, bool) {
+	if register == Reg("RSP") || register == ZR {
+		return SP, true
+	}
+	if isARM64GeneralOrZeroReg(register) && register != ZR {
+		return register, true
+	}
+	return "", false
+}
+
+func arm64SVEPrefetchHint(operand Operand) (int, bool) {
+	if operand.Kind != OpIdent {
+		return 0, false
+	}
+	encoded, ok := arm64PrefetchOperations[arm64PrefetchOperation(strings.ToUpper(strings.TrimSpace(operand.Ident)))]
+	if !ok || encoded >= 8 && encoded <= 13 {
+		return 0, false
+	}
+	if encoded >= 16 {
+		encoded -= 8
+	}
+	return int(encoded), true
+}
diff --git a/arm64_lower_sve_predicate_memory_test.go b/arm64_lower_sve_predicate_memory_test.go
new file mode 100644
index 000000000..590f29cfd
--- /dev/null
+++ b/arm64_lower_sve_predicate_memory_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicateMemoryCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatememoryforms(SB),$0-0\n")
+	source.WriteString("\tPLDR (-VL*256)(R0), P0\n")
+	source.WriteString("\tPLDR (VL*255)(RSP), P15\n")
+	source.WriteString("\tPSTR P14, (-VL*256)(R1)\n")
+	source.WriteString("\tPSTR P1, (VL*255)(RSP)\n")
+	hints := []string{
+		"PLDL1KEEP", "PLDL1STRM", "PLDL2KEEP", "PLDL2STRM", "PLDL3KEEP", "PLDL3STRM",
+		"PSTL1KEEP", "PSTL1STRM", "PSTL2KEEP", "PSTL2STRM", "PSTL3KEEP", "PSTL3STRM",
+	}
+	for index, hint := range hints {
+		fmt.Fprintf(&source, "\tPPRFB (VL*%d)(R2), P%d, %s\n", index%32, index%8, hint)
+	}
+	source.WriteString("\tPPRFB (R8)(RSP), P3, PSTL3KEEP\n")
+	source.WriteString("\tPPRFH (R8<<1)(RSP), P3, PSTL3KEEP\n")
+	source.WriteString("\tPPRFW (R8<<2)(RSP), P3, PSTL3KEEP\n")
+	source.WriteString("\tPPRFD (R8<<3)(RSP), P3, PSTL3KEEP\n")
+	source.WriteString("\tPPRFB (-VL*32)(R3), P0, PLDL1KEEP\n")
+	source.WriteString("\tPPRFH (VL*31)(R4), P1, PLDL1STRM\n")
+	source.WriteString("\tPPRFW (-VL*32)(R5), P2, PSTL1KEEP\n")
+	source.WriteString("\tPPRFD (VL*31)(R6), P7, PSTL3STRM\n")
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestParseARM64SVEPredicateMemoryRetainsAddressSemantics(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT parsepredmem(SB),$0-0\n\tPLDR (-VL*2)(RSP), P5\n\tPPRFD (R8<<3)(RSP), P3, PSTL3KEEP\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	loadMemory := file.Funcs[0].Instrs[1].Args[0].Mem
+	if loadMemory.Base != Reg("RSP") || loadMemory.OffRaw != "-VL*2" {
+		t.Fatalf("PLDR address parsed as %+v, want RSP plus -VL*2", loadMemory)
+	}
+	prefetchMemory := file.Funcs[0].Instrs[2].Args[0].Mem
+	if prefetchMemory.Base != Reg("RSP") || prefetchMemory.Index != Reg("R8") || prefetchMemory.Scale != 8 {
+		t.Fatalf("PPRFD address parsed as %+v, want RSP plus R8<<3", prefetchMemory)
+	}
+}
+
+func TestTranslateARM64SVEPredicateMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateMemoryCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatememoryforms": {Name: "svepredicatememoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"load <vscale x 16 x i1>",
+				"store <vscale x 16 x i1>",
+				"@llvm.aarch64.sve.prf.nxv16i1",
+				"@llvm.aarch64.sve.prf.nxv8i1",
+				"@llvm.aarch64.sve.prf.nxv4i1",
+				"@llvm.aarch64.sve.prf.nxv2i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-memory.ll", "arm64-sve-predicate-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PLDR (-VL*257)(R0), P1",
+		"PSTR P1, (VL*256)(R0)",
+		"PLDR (VL*1)(R0), P1.B",
+		"PPRFB (-VL*33)(R0), P1, PLDL1KEEP",
+		"PPRFD (VL*32)(R0), P1, PLDL1KEEP",
+		"PPRFH (R8<<2)(RSP), P1, PLDL1KEEP",
+		"PPRFW (R8)(RSP), P1, PLDL1KEEP",
+		"PPRFD (R8<<3)(RSP), P8, PLDL1KEEP",
+		"PPRFB (VL*1)(R0), P1, PLIL1KEEP",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatememory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatememory": {Name: "badsvepredicatememory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_permute.go b/arm64_lower_sve_predicate_permute.go
new file mode 100644
index 000000000..4da4e05d3
--- /dev/null
+++ b/arm64_lower_sve_predicate_permute.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicatePermuteSpec struct {
+	intrinsic string
+	inputs    int
+	unpack    bool
+	rawBase   uint32
+}
+
+var arm64SVEPredicatePermuteSpecs = map[Op]arm64SVEPredicatePermuteSpec{
+	"PREV":     {intrinsic: "rev", inputs: 1, rawBase: 0x05344000},
+	"PTRN1":    {intrinsic: "trn1", inputs: 2, rawBase: 0x05205000},
+	"PTRN2":    {intrinsic: "trn2", inputs: 2, rawBase: 0x05205400},
+	"PUZP1":    {intrinsic: "uzp1", inputs: 2, rawBase: 0x05204800},
+	"PUZP2":    {intrinsic: "uzp2", inputs: 2, rawBase: 0x05204c00},
+	"PZIP1":    {intrinsic: "zip1", inputs: 2, rawBase: 0x05204000},
+	"PZIP2":    {intrinsic: "zip2", inputs: 2, rawBase: 0x05204400},
+	"PPUNPKHI": {intrinsic: "punpkhi", inputs: 1, unpack: true, rawBase: 0x05314000},
+	"PPUNPKLO": {intrinsic: "punpklo", inputs: 1, unpack: true, rawBase: 0x05304000},
+}
+
+func decodeARM64RawSVEPredicatePermute(word uint32) (Instr, bool) {
+	for op, spec := range arm64SVEPredicatePermuteSpecs {
+		variableBits := uint32(0x000001ef) // Pn[8:5], Pd[3:0]; bit 4/9 are fixed.
+		if !spec.unpack {
+			variableBits |= 0x00c00000
+		}
+		if spec.inputs == 2 {
+			variableBits |= 0x000f0000
+		}
+		if word&^variableBits != spec.rawBase {
+			continue
+		}
+		width := "BHSD"[word>>22&3]
+		operand := func(number uint32, arrangement byte) Operand {
+			return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%c", number, arrangement))}
+		}
+		args := []Operand{operand(word>>5&15, width), operand(word&15, width)}
+		if spec.unpack {
+			args = []Operand{operand(word>>5&15, 'B'), operand(word&15, 'H')}
+		} else if spec.inputs == 2 {
+			args = append([]Operand{operand(word>>16&15, width)}, args...)
+		}
+		return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicatePermute(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicatePermuteSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != spec.inputs+1 {
+		return true, false, fmt.Errorf("arm64 %s expects %d source predicate(s) and one destination: %q", op, spec.inputs, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	if !firstOK {
+		return true, false, fmt.Errorf("arm64 %s first source is not a Go 1.27 predicate arrangement: %q", op, ins.Raw)
+	}
+	if spec.unpack {
+		destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[1])
+		if firstBits != 8 || !destinationOK || destinationBits != 16 {
+			return true, false, fmt.Errorf("arm64 %s only accepts Pn.B, Pd.H: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerARM64SVEPredicateUnpack(spec, first, destination)
+	}
+	if spec.inputs == 1 {
+		destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[1])
+		if !destinationOK || destinationBits != firstBits {
+			return true, false, fmt.Errorf("arm64 %s source and destination arrangements must match: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerARM64SVEPredicateReverse(first, destination, firstBits)
+	}
+
+	second, secondBits, secondOK := arm64ParseSVEPredicateElement(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[2])
+	if !secondOK || !destinationOK || firstBits != secondBits || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s predicate arrangements must all match: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEPredicatePermuteBinary(spec, first, second, destination, firstBits)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateReverse(source, destination, elementBits int) error {
+	sourceValue, err := c.loadPReg(source)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if elementBits == 8 {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.vector.reverse.nxv16i1(<vscale x 16 x i1> %s)\n", result, sourceValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.rev.b%d(<vscale x 16 x i1> %s)\n", result, elementBits, sourceValue)
+	}
+	return c.storePReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicatePermuteBinary(spec arm64SVEPredicatePermuteSpec, plan9First, plan9Second, destination, elementBits int) error {
+	firstValue, err := c.loadPReg(plan9Second)
+	if err != nil {
+		return err
+	}
+	secondValue, err := c.loadPReg(plan9First)
+	if err != nil {
+		return err
+	}
+	intrinsic := spec.intrinsic + ".nxv16i1"
+	if elementBits != 8 {
+		intrinsic = fmt.Sprintf("%s.b%d", spec.intrinsic, elementBits)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.%s(<vscale x 16 x i1> %s, <vscale x 16 x i1> %s)\n", result, intrinsic, firstValue, secondValue)
+	return c.storePReg(destination, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateUnpack(spec arm64SVEPredicatePermuteSpec, source, destination int) error {
+	sourceValue, err := c.loadPReg(source)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 8 x i1> @llvm.aarch64.sve.%s.nxv16i1(<vscale x 16 x i1> %s)\n", result, spec.intrinsic, sourceValue)
+	return c.storePRegElements(destination, 16, "%"+result)
+}
diff --git a/arm64_lower_sve_predicate_permute_test.go b/arm64_lower_sve_predicate_permute_test.go
new file mode 100644
index 000000000..40d62c970
--- /dev/null
+++ b/arm64_lower_sve_predicate_permute_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicatePermuteCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatepermuteforms(SB),$0-0\n")
+	for _, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tPREV P15.%s, P14.%s\n", width, width)
+		for _, op := range []string{"PTRN1", "PTRN2", "PUZP1", "PUZP2", "PZIP1", "PZIP2"} {
+			fmt.Fprintf(&source, "\t%s P13.%s, P12.%s, P11.%s\n", op, width, width, width)
+		}
+	}
+	source.WriteString("\tPPUNPKHI P10.B, P9.H\n")
+	source.WriteString("\tPPUNPKLO P8.B, P7.H\n")
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicatePermuteCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicatePermuteCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatepermuteforms": {Name: "svepredicatepermuteforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.vector.reverse.nxv16i1",
+				"@llvm.aarch64.sve.rev.b16",
+				"@llvm.aarch64.sve.trn1.nxv16i1",
+				"@llvm.aarch64.sve.trn2.b64",
+				"@llvm.aarch64.sve.uzp1.b32",
+				"@llvm.aarch64.sve.zip2.b16",
+				"@llvm.aarch64.sve.punpkhi.nxv16i1",
+				"@llvm.aarch64.sve.punpklo.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate permute lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-permute.ll", "arm64-sve-predicate-permute.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicatePermuteRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PREV P1.B, P2.H",
+		"PTRN1 P1.B, P2.H, P3.B",
+		"PUZP2 P1.B, P2.B, P16.B",
+		"PZIP1 P1.B, P2.B",
+		"PPUNPKHI P1.H, P2.H",
+		"PPUNPKLO P1.B, P2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatepermute(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatepermute": {Name: "badsvepredicatepermute", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate permute forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_position.go b/arm64_lower_sve_predicate_position.go
new file mode 100644
index 000000000..2acb9c478
--- /dev/null
+++ b/arm64_lower_sve_predicate_position.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEPredicatePositionIntrinsics = map[Op]string{
+	"PFIRSTP": "firstp",
+	"PLASTP":  "lastp",
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicatePosition(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEPredicatePositionIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Pn.T, Pg, Xd: %q", op, ins.Raw)
+	}
+	tested, elementBits, testedOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	governing, governingOK := arm64ParseSVEPredicateBare(ins.Args[1], 15)
+	if !testedOK || !governingOK || ins.Args[2].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[2].Reg) {
+		return true, false, fmt.Errorf("arm64 %s operands do not match its Go 1.27 predicate-position form: %q", op, ins.Raw)
+	}
+	governingValue, predicateType, err := c.loadPRegElements(governing, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	testedValue, _, err := c.loadPRegElements(tested, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.%s.nxv%di1(%s %s, %s %s)\n", result, intrinsic, lanes, predicateType, governingValue, predicateType, testedValue)
+	return true, false, c.storeReg(ins.Args[2].Reg, "%"+result)
+}
diff --git a/arm64_lower_sve_predicate_position_test.go b/arm64_lower_sve_predicate_position_test.go
new file mode 100644
index 000000000..9a7c4f513
--- /dev/null
+++ b/arm64_lower_sve_predicate_position_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEPredicatePositionCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatepositionforms(SB),$0-0\n")
+	for index, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tPFIRSTP P%d.%s, P%d, R%d\n", 15-index, width, 11-index, index)
+		fmt.Fprintf(&source, "\tPLASTP P%d.%s, P%d, R%d\n", 7-index, width, 3-index, 4+index)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicatePositionCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicatePositionCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatepositionforms": {Name: "svepredicatepositionforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p2"`,
+				"@llvm.aarch64.sve.firstp.nxv16i1",
+				"@llvm.aarch64.sve.firstp.nxv8i1",
+				"@llvm.aarch64.sve.lastp.nxv4i1",
+				"@llvm.aarch64.sve.lastp.nxv2i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate position lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-position.ll", "arm64-sve-predicate-position.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicatePositionRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PFIRSTP P1.Q, P2, R3",
+		"PFIRSTP P1.B, P2.Z, R3",
+		"PFIRSTP P16.B, P2, R3",
+		"PLASTP P1.B, P16, R3",
+		"PLASTP P1.B, P2, R31",
+		"PLASTP P1.B, P2",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicateposition(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicateposition": {Name: "badsvepredicateposition", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate position forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_select_test.go b/arm64_lower_sve_predicate_select_test.go
new file mode 100644
index 000000000..2d2392fa7
--- /dev/null
+++ b/arm64_lower_sve_predicate_select_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEPredicateSelectCompleteFields(t *testing.T) {
+	var lines []string
+	for field := 0; field < 4; field++ {
+		for register := 0; register < 16; register++ {
+			registers := [4]int{15, 14, 13, 12}
+			registers[field] = register
+			lines = append(lines, fmt.Sprintf("sel p%d.b, p%d, p%d.b, p%d.b", registers[0], registers[1], registers[2], registers[3]))
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawpsel(SB),$0-0\n")
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		registers := [4]int{15, 14, 13, 12}
+		registers[i/16] = i % 16
+		got, ok := decodeARM64RawSVEPredicateLogical(word)
+		if !ok || got.Op != "PSEL" ||
+			got.Args[0].Reg != Reg(fmt.Sprintf("P%d.B", registers[3])) ||
+			got.Args[1].Reg != Reg(fmt.Sprintf("P%d.B", registers[2])) ||
+			got.Args[2].Reg != Reg(fmt.Sprintf("P%d", registers[1])) ||
+			got.Args[3].Reg != Reg(fmt.Sprintf("P%d.B", registers[0])) {
+			t.Errorf("%s: wrong decoded operands: %+v, %v", lines[i], got, ok)
+		}
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawpsel": {Name: "rawpsel", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawpsel.ll", "rawpsel.o", ir)
+		})
+	}
+	for _, word := range []uint32{0x25404210, 0x25004010, 0x25804210} {
+		if got, ok := decodeARM64RawSVEPredicateLogical(word); ok && got.Op == "PSEL" {
+			t.Errorf("neighboring opcode %#08x decoded as PSEL", word)
+		}
+	}
+}
+
+func TestTranslateARM64SVEPredicateSelectCompleteGo127Family(t *testing.T) {
+	const source = "TEXT svepredicateselectforms(SB),$0-0\n\tPSEL P15.B, P14.B, P13, P12.B\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicateselectforms": {Name: "svepredicateselectforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, "select <vscale x 16 x i1>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate select lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-select.ll", "arm64-sve-predicate-select.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateSelectRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PSEL P1.H, P2.H, P3, P4.H",
+		"PSEL P1.B, P2.B, P3.Z, P4.B",
+		"PSEL P1.B, P2.B, P16, P4.B",
+		"PSEL P1.B, P2.B, P3, P4.H",
+		"PSEL P1.B, P2.B, P3",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicateselect(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicateselect": {Name: "badsvepredicateselect", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate select forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_state.go b/arm64_lower_sve_predicate_state.go
new file mode 100644
index 000000000..1d3b65c9c
--- /dev/null
+++ b/arm64_lower_sve_predicate_state.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateStateKind uint8
+
+const (
+	arm64SVEPredicateFalse arm64SVEPredicateStateKind = iota
+	arm64SVEPredicateTest
+	arm64SVEPredicateReadFFR
+	arm64SVEPredicateReadFFRFlags
+	arm64SVEPredicateWriteFFR
+	arm64SVEPredicateSetFFR
+)
+
+var arm64SVEPredicateStateSpecs = map[Op]arm64SVEPredicateStateKind{
+	"PPFALSE": arm64SVEPredicateFalse,
+	"PPTEST":  arm64SVEPredicateTest,
+	"PRDFFR":  arm64SVEPredicateReadFFR,
+	"PRDFFRS": arm64SVEPredicateReadFFRFlags,
+	"PWRFFR":  arm64SVEPredicateWriteFFR,
+	"SETFFR":  arm64SVEPredicateSetFFR,
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateState(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	kind, ok := arm64SVEPredicateStateSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	switch kind {
+	case arm64SVEPredicateFalse:
+		if len(ins.Args) != 1 {
+			return true, false, fmt.Errorf("arm64 PPFALSE expects Pd.B: %q", ins.Raw)
+		}
+		destination, elementBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[0])
+		if !destinationOK || elementBits != 8 {
+			return true, false, fmt.Errorf("arm64 PPFALSE only accepts P0..P15.B: %q", ins.Raw)
+		}
+		return true, false, c.storePReg(destination, "zeroinitializer")
+	case arm64SVEPredicateTest:
+		if len(ins.Args) != 2 {
+			return true, false, fmt.Errorf("arm64 PPTEST expects Pn.B, Pg: %q", ins.Raw)
+		}
+		tested, elementBits, testedOK := arm64ParseSVEPredicateElement(ins.Args[0])
+		governing, governingOK := arm64ParseSVEPredicateBare(ins.Args[1], 15)
+		if !testedOK || elementBits != 8 || !governingOK {
+			return true, false, fmt.Errorf("arm64 PPTEST only accepts P0..P15.B, P0..P15: %q", ins.Raw)
+		}
+		testedValue, predicateType, err := c.loadPRegElements(tested, 8)
+		if err != nil {
+			return true, false, err
+		}
+		governingValue, _, err := c.loadPRegElements(governing, 8)
+		if err != nil {
+			return true, false, err
+		}
+		c.setSVEPredicateFlags(governingValue, testedValue, predicateType, 16)
+		return true, false, nil
+	case arm64SVEPredicateReadFFR, arm64SVEPredicateReadFFRFlags:
+		return c.lowerARM64SVEReadFFR(kind, ins)
+	case arm64SVEPredicateWriteFFR:
+		if len(ins.Args) != 1 {
+			return true, false, fmt.Errorf("arm64 PWRFFR expects Pn.B: %q", ins.Raw)
+		}
+		source, elementBits, sourceOK := arm64ParseSVEPredicateElement(ins.Args[0])
+		if !sourceOK || elementBits != 8 {
+			return true, false, fmt.Errorf("arm64 PWRFFR only accepts P0..P15.B: %q", ins.Raw)
+		}
+		value, err := c.loadPReg(source)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.wrffr(<vscale x 16 x i1> %s)\n", value)
+		return true, false, nil
+	case arm64SVEPredicateSetFFR:
+		if len(ins.Args) != 0 {
+			return true, false, fmt.Errorf("arm64 SETFFR does not accept operands: %q", ins.Raw)
+		}
+		fmt.Fprintln(c.b, "  call void @llvm.aarch64.sve.setffr()")
+		return true, false, nil
+	default:
+		return true, false, fmt.Errorf("unsupported ARM64 SVE predicate state kind %d", kind)
+	}
+}
+
+func (c *arm64Ctx) lowerARM64SVEReadFFR(kind arm64SVEPredicateStateKind, ins Instr) (ok bool, terminated bool, err error) {
+	var destination int
+	var value string
+	if len(ins.Args) == 1 && kind == arm64SVEPredicateReadFFR {
+		var elementBits int
+		var destinationOK bool
+		destination, elementBits, destinationOK = arm64ParseSVEPredicateElement(ins.Args[0])
+		if !destinationOK || elementBits != 8 {
+			return true, false, fmt.Errorf("arm64 PRDFFR unpredicated form expects Pd.B: %q", ins.Raw)
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.rdffr()\n", result)
+		value = "%" + result
+	} else if len(ins.Args) == 2 {
+		governing, governingOK := arm64ParseSVEPredicateMode(ins.Args[0], "Z", 15)
+		var elementBits int
+		var destinationOK bool
+		destination, elementBits, destinationOK = arm64ParseSVEPredicateElement(ins.Args[1])
+		if !governingOK || !destinationOK || elementBits != 8 {
+			return true, false, fmt.Errorf("arm64 %s predicated form expects Pg.Z, Pd.B: %q", ins.Op, ins.Raw)
+		}
+		governingValue, err := c.loadPReg(governing)
+		if err != nil {
+			return true, false, err
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.rdffr.z(<vscale x 16 x i1> %s)\n", result, governingValue)
+		value = "%" + result
+		if kind == arm64SVEPredicateReadFFRFlags {
+			c.setSVEPredicateFlags(governingValue, value, "<vscale x 16 x i1>", 16)
+		}
+	} else {
+		return true, false, fmt.Errorf("arm64 %s expects its Go 1.27 FFR read form: %q", ins.Op, ins.Raw)
+	}
+	if err := c.storePReg(destination, value); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
diff --git a/arm64_lower_sve_predicate_state_test.go b/arm64_lower_sve_predicate_state_test.go
new file mode 100644
index 000000000..94f844467
--- /dev/null
+++ b/arm64_lower_sve_predicate_state_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEPredicateStateCompleteGo127Family(t *testing.T) {
+	const source = "TEXT svepredicatestateforms(SB),$0-0\n\tPPFALSE P15.B\n\tPPTEST P14.B, P13\n\tPRDFFR P14.Z, P0.B\n\tPRDFFR P13.B\n\tPRDFFRS P12.Z, P1.B\n\tPWRFFR P11.B\n\tSETFFR\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatestateforms": {Name: "svepredicatestateforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"store <vscale x 16 x i1> zeroinitializer",
+				"@llvm.aarch64.sve.ptest.any.nxv16i1",
+				"@llvm.aarch64.sve.ptest.first.nxv16i1",
+				"@llvm.aarch64.sve.ptest.last.nxv16i1",
+				"@llvm.aarch64.sve.rdffr()",
+				"@llvm.aarch64.sve.rdffr.z(",
+				"@llvm.aarch64.sve.wrffr(",
+				"@llvm.aarch64.sve.setffr()",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate state lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-state.ll", "arm64-sve-predicate-state.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateStateRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PPFALSE P1.H",
+		"PPFALSE P16.B",
+		"PPTEST P1.H, P2",
+		"PPTEST P1.B, P2.Z",
+		"PPTEST P1.B, P16",
+		"PPTEST P1.B",
+		"PRDFFR P1.H",
+		"PRDFFR P1.M, P2.B",
+		"PRDFFRS P1.B",
+		"PWRFFR P1.H",
+		"SETFFR R1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatestate(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatestate": {Name: "badsvepredicatestate", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate state forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_predicate_while.go b/arm64_lower_sve_predicate_while.go
new file mode 100644
index 000000000..51deaa65c
--- /dev/null
+++ b/arm64_lower_sve_predicate_while.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEPredicateWhileSpec struct {
+	condition string
+	word      bool
+	pointer   bool
+}
+
+var arm64SVEPredicateWhileSpecs = map[Op]arm64SVEPredicateWhileSpec{
+	"PWHILEGE":  {condition: "whilege"},
+	"PWHILEGT":  {condition: "whilegt"},
+	"PWHILEHI":  {condition: "whilehi"},
+	"PWHILEHS":  {condition: "whilehs"},
+	"PWHILELE":  {condition: "whilele"},
+	"PWHILELO":  {condition: "whilelo"},
+	"PWHILELS":  {condition: "whilels"},
+	"PWHILELT":  {condition: "whilelt"},
+	"PWHILEGEW": {condition: "whilege", word: true},
+	"PWHILEGTW": {condition: "whilegt", word: true},
+	"PWHILEHIW": {condition: "whilehi", word: true},
+	"PWHILEHSW": {condition: "whilehs", word: true},
+	"PWHILELEW": {condition: "whilele", word: true},
+	"PWHILELOW": {condition: "whilelo", word: true},
+	"PWHILELSW": {condition: "whilels", word: true},
+	"PWHILELTW": {condition: "whilelt", word: true},
+	"PWHILERW":  {condition: "whilerw", pointer: true},
+	"PWHILEWR":  {condition: "whilewr", pointer: true},
+}
+
+func arm64SVEPredicateWhileNeedsSVE2P1(ins Instr) bool {
+	return len(ins.Args) >= 3 && (ins.Args[len(ins.Args)-1].Kind == OpRegList || ins.Args[0].Kind == OpIdent)
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateWhile(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEPredicateWhileSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if spec.pointer {
+		return c.lowerARM64SVEPredicateWhilePointer(spec, ins)
+	}
+	if spec.word {
+		return c.lowerARM64SVEPredicateWhileSingle(spec, ins)
+	}
+	if len(ins.Args) == 4 && ins.Args[0].Kind == OpIdent {
+		return c.lowerARM64SVEPredicateWhileCounter(spec, ins)
+	}
+	if len(ins.Args) == 3 && ins.Args[2].Kind == OpRegList {
+		return c.lowerARM64SVEPredicateWhilePair(spec, ins)
+	}
+	return c.lowerARM64SVEPredicateWhileSingle(spec, ins)
+}
+
+func arm64SVEWhileScalarRegister(operand Operand, allowZero bool) (Reg, bool) {
+	if operand.Kind != OpReg || !isARM64GeneralOrZeroReg(operand.Reg) {
+		return "", false
+	}
+	if !allowZero && operand.Reg == ZR {
+		return "", false
+	}
+	return operand.Reg, true
+}
+
+func (c *arm64Ctx) loadARM64SVEWhileScalars(firstOperand, secondOperand Operand, word, allowZero bool) (first, second, scalarType string, err error) {
+	plan9First, firstOK := arm64SVEWhileScalarRegister(firstOperand, allowZero)
+	plan9Second, secondOK := arm64SVEWhileScalarRegister(secondOperand, allowZero)
+	if !firstOK || !secondOK {
+		return "", "", "", fmt.Errorf("predicate while operands must be valid general registers")
+	}
+	first64, err := c.loadReg(plan9Second)
+	if err != nil {
+		return "", "", "", err
+	}
+	second64, err := c.loadReg(plan9First)
+	if err != nil {
+		return "", "", "", err
+	}
+	if !word {
+		return first64, second64, "i64", nil
+	}
+	firstTmp := c.newTmp()
+	secondTmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", firstTmp, first64)
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", secondTmp, second64)
+	return "%" + firstTmp, "%" + secondTmp, "i32", nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateWhileSingle(spec arm64SVEPredicateWhileSpec, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 predicate while expects Rm, Rn, Pd.T: %q", ins.Raw)
+	}
+	destination, elementBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[2])
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 predicate while destination must be P0..P15.B/H/S/D: %q", ins.Raw)
+	}
+	first, second, scalarType, err := c.loadARM64SVEWhileScalars(ins.Args[0], ins.Args[1], spec.word, true)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 predicate while scalar form: %w: %q", err, ins.Raw)
+	}
+	lanes := 128 / elementBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di1.%s(%s %s, %s %s)\n", result, predicateType, spec.condition, lanes, scalarType, scalarType, first, scalarType, second)
+	if err := c.storePRegElements(destination, elementBits, "%"+result); err != nil {
+		return true, false, err
+	}
+	governing, _, err := c.allTruePRegElements(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	c.setSVEPredicateFlags(governing, "%"+result, predicateType, lanes)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateWhilePair(spec arm64SVEPredicateWhileSpec, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 3 || ins.Args[2].Kind != OpRegList || len(ins.Args[2].RegList) != 2 {
+		return true, false, fmt.Errorf("arm64 predicate while pair form expects Xm, Xn, [Pd1.T, Pd2.T]: %q", ins.Raw)
+	}
+	firstDestination, firstBits, firstOK := arm64ParseSVEPredicateElement(Operand{Kind: OpReg, Reg: ins.Args[2].RegList[0]})
+	secondDestination, secondBits, secondOK := arm64ParseSVEPredicateElement(Operand{Kind: OpReg, Reg: ins.Args[2].RegList[1]})
+	if !firstOK || !secondOK || firstBits != secondBits || firstDestination%2 != 0 || secondDestination != firstDestination+1 {
+		return true, false, fmt.Errorf("arm64 predicate while pair requires an even/odd consecutive predicate pair with matching arrangements: %q", ins.Raw)
+	}
+	first, second, _, err := c.loadARM64SVEWhileScalars(ins.Args[0], ins.Args[1], false, false)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 predicate while pair scalar form: %w: %q", err, ins.Raw)
+	}
+	lanes := 128 / firstBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	aggregateType := fmt.Sprintf("{ %s, %s }", predicateType, predicateType)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.x2.nxv%di1(i64 %s, i64 %s)\n", result, aggregateType, spec.condition, lanes, first, second)
+	firstValue := c.newTmp()
+	secondValue := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 0\n", firstValue, aggregateType, result)
+	fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, 1\n", secondValue, aggregateType, result)
+	if err := c.storePRegElements(firstDestination, firstBits, "%"+firstValue); err != nil {
+		return true, false, err
+	}
+	if err := c.storePRegElements(secondDestination, secondBits, "%"+secondValue); err != nil {
+		return true, false, err
+	}
+	governing, _, err := c.allTruePRegElements(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	c.setSVEPredicateSequenceFlags(governing, []string{"%" + firstValue, "%" + secondValue}, predicateType, lanes)
+	return true, false, nil
+}
+
+func arm64SVEWhileMultiplier(operand Operand) int {
+	if operand.Kind != OpIdent {
+		return 0
+	}
+	switch strings.ToUpper(operand.Ident) {
+	case "VLX2":
+		return 2
+	case "VLX4":
+		return 4
+	default:
+		return 0
+	}
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateWhileCounter(spec arm64SVEPredicateWhileSpec, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 predicate while counter form expects VLx2|VLx4, Xm, Xn, PNd.T: %q", ins.Raw)
+	}
+	multiplier := arm64SVEWhileMultiplier(ins.Args[0])
+	destination, elementBits, destinationOK := arm64ParseSVEPredicateCounterElement(ins.Args[3])
+	if multiplier == 0 || !destinationOK || destination < 8 {
+		return true, false, fmt.Errorf("arm64 predicate while counter requires VLx2|VLx4 and PN8..PN15.B/H/S/D: %q", ins.Raw)
+	}
+	first, second, _, err := c.loadARM64SVEWhileScalars(ins.Args[1], ins.Args[2], false, false)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 predicate while counter scalar form: %w: %q", err, ins.Raw)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call target(\"aarch64.svcount\") @llvm.aarch64.sve.%s.c%d(i64 %s, i64 %s, i32 %d)\n", result, spec.condition, elementBits, first, second, multiplier)
+	if err := c.storePNReg(destination, "%"+result); err != nil {
+		return true, false, err
+	}
+	lanes := 128 / elementBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	pieces := make([]string, 0, multiplier)
+	for lane := 0; lane < multiplier; lane++ {
+		piece := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.pext.nxv%di1(target(\"aarch64.svcount\") %%%s, i32 %d)\n", piece, predicateType, lanes, result, lane)
+		pieces = append(pieces, "%"+piece)
+	}
+	governing, _, err := c.allTruePRegElements(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	c.setSVEPredicateSequenceFlags(governing, pieces, predicateType, lanes)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEPredicateWhilePointer(spec arm64SVEPredicateWhileSpec, ins Instr) (ok bool, terminated bool, err error) {
+	if len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Xm, Xn, Pd.T: %q", ins.Op, ins.Raw)
+	}
+	destination, elementBits, destinationOK := arm64ParseSVEPredicateElement(ins.Args[2])
+	if !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s destination must be P0..P15.B/H/S/D: %q", ins.Op, ins.Raw)
+	}
+	first, second, _, err := c.loadARM64SVEWhileScalars(ins.Args[0], ins.Args[1], false, false)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s scalar form: %w: %q", ins.Op, err, ins.Raw)
+	}
+	firstPointer := c.newTmp()
+	secondPointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", firstPointer, first)
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", secondPointer, second)
+	lanes := 128 / elementBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	letter := strings.ToLower(map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[elementBits])
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.%s.nxv%di1.p0(ptr %%%s, ptr %%%s)\n", result, predicateType, spec.condition, letter, lanes, firstPointer, secondPointer)
+	if err := c.storePRegElements(destination, elementBits, "%"+result); err != nil {
+		return true, false, err
+	}
+	governing, _, err := c.allTruePRegElements(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	c.setSVEPredicateFlags(governing, "%"+result, predicateType, lanes)
+	return true, false, nil
+}
diff --git a/arm64_lower_sve_predicate_while_test.go b/arm64_lower_sve_predicate_while_test.go
new file mode 100644
index 000000000..f40db16f0
--- /dev/null
+++ b/arm64_lower_sve_predicate_while_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVEPredicateWhileConditions = []string{"GE", "GT", "HI", "HS", "LE", "LO", "LS", "LT"}
+
+func arm64SVEPredicateWhileCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svepredicatewhileforms(SB),$0-0\n")
+	for conditionIndex, condition := range arm64SVEPredicateWhileConditions {
+		for widthIndex, width := range []string{"B", "H", "S", "D"} {
+			destination := (conditionIndex + widthIndex) % 15
+			pairDestination := 2 * ((conditionIndex + widthIndex) % 8)
+			fmt.Fprintf(&source, "\tPWHILE%s R1, R2, P%d.%s\n", condition, destination, width)
+			fmt.Fprintf(&source, "\tPWHILE%s R3, R4, [P%d.%s, P%d.%s]\n", condition, pairDestination, width, pairDestination+1, width)
+			fmt.Fprintf(&source, "\tPWHILE%s VLx2, R5, R6, PN%d.%s\n", condition, 8+(conditionIndex+widthIndex)%8, width)
+			fmt.Fprintf(&source, "\tPWHILE%s VLx4, R7, R8, PN%d.%s\n", condition, 8+(conditionIndex+widthIndex+1)%8, width)
+			fmt.Fprintf(&source, "\tPWHILE%sW R9, R10, P%d.%s\n", condition, destination, width)
+		}
+	}
+	for _, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tPWHILERW R11, R12, P13.%s\n", width)
+		fmt.Fprintf(&source, "\tPWHILEWR R13, R14, P15.%s\n", width)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEPredicateWhileCompleteGo127Family(t *testing.T) {
+	source := arm64SVEPredicateWhileCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svepredicatewhileforms": {Name: "svepredicatewhileforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2,+sve2p1"`,
+				"@llvm.aarch64.sve.whilege.nxv16i1.i64",
+				"@llvm.aarch64.sve.whilelt.nxv2i1.i32",
+				"@llvm.aarch64.sve.whilehi.x2.nxv4i1",
+				"@llvm.aarch64.sve.whilels.c64",
+				"@llvm.aarch64.sve.whilerw.b.nxv16i1.p0",
+				"@llvm.aarch64.sve.whilewr.d.nxv2i1.p0",
+				"@llvm.aarch64.sve.ptest.any.nxv16i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE predicate while lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-predicate-while.ll", "arm64-sve-predicate-while.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEPredicateWhileRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"PWHILELT R1, R2, P3.Q",
+		"PWHILEGE R1, R2, [P3.B, P4.H]",
+		"PWHILEGE R1, R2, [P3.B, P4.B]",
+		"PWHILEHI R1, R2, [P3.B, P5.B]",
+		"PWHILELO VLx3, R1, R2, PN8.B",
+		"PWHILELS VLx2, R1, R2, PN7.B",
+		"PWHILELTW R1, R2",
+		"PWHILERW R1, R2, P3.Q",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvepredicatewhile(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvepredicatewhile": {Name: "badsvepredicatewhile", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE predicate while forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_q_permute_test.go b/arm64_lower_sve_q_permute_test.go
new file mode 100644
index 000000000..c7883ba94
--- /dev/null
+++ b/arm64_lower_sve_q_permute_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEQPermuteCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveqpermuteforms(SB),$0-0\n")
+	for _, op := range []string{"ZZIPQ1", "ZZIPQ2", "ZUZPQ1", "ZUZPQ2"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveqpermuteforms": {Name: "sveqpermuteforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2p1"`, "@llvm.aarch64.sve.zipq1.nxv16i8", "@llvm.aarch64.sve.uzpq2.nxv2i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE Q permute lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-q-permute.ll", "arm64-sve-q-permute.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEQPermuteRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZZIPQ1 Z1.B, Z2.H, Z3.B",
+		"ZZIPQ2 Z1.Q, Z2.Q, Z3.Q",
+		"ZUZPQ1 Z1.S, Z2.S",
+		"ZUZPQ2.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveqpermute(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveqpermute": {Name: "badsveqpermute", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE Q permute forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_replicate_memory.go b/arm64_lower_sve_replicate_memory.go
new file mode 100644
index 000000000..d1c20468e
--- /dev/null
+++ b/arm64_lower_sve_replicate_memory.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEReplicateMemorySpec struct {
+	memoryBits int
+	signed     bool
+	blockBytes int
+}
+
+// arm64SVEReplicateMemorySpecs covers all 32 Go 1.27 replicate-load encoder
+// forms: scalar LD1R, sign-extending LD1RS, and block LD1RO/LD1RQ.
+var arm64SVEReplicateMemorySpecs = map[Op]arm64SVEReplicateMemorySpec{
+	"ZLD1RB":  {memoryBits: 8},
+	"ZLD1RH":  {memoryBits: 16},
+	"ZLD1RW":  {memoryBits: 32},
+	"ZLD1RD":  {memoryBits: 64},
+	"ZLD1RSB": {memoryBits: 8, signed: true},
+	"ZLD1RSH": {memoryBits: 16, signed: true},
+	"ZLD1RSW": {memoryBits: 32, signed: true},
+	"ZLD1ROB": {memoryBits: 8, blockBytes: 32},
+	"ZLD1ROH": {memoryBits: 16, blockBytes: 32},
+	"ZLD1ROW": {memoryBits: 32, blockBytes: 32},
+	"ZLD1ROD": {memoryBits: 64, blockBytes: 32},
+	"ZLD1RQB": {memoryBits: 8, blockBytes: 16},
+	"ZLD1RQH": {memoryBits: 16, blockBytes: 16},
+	"ZLD1RQW": {memoryBits: 32, blockBytes: 16},
+	"ZLD1RQD": {memoryBits: 64, blockBytes: 16},
+}
+
+// decodeARM64RawSVEReplicateScalar covers every scalar immediate-address
+// LD1R/LD1RS row in the Go 1.27 ARM64 encoder table. The decoded operands
+// use the same typed path as the corresponding Plan 9 mnemonics.
+func decodeARM64RawSVEReplicateScalar(word uint32) (Instr, bool) {
+	const fields = uint32(0x003f1fff) // imm6, Pg, Xn, Zt
+	forms := [...]struct {
+		op          Op
+		base        uint32
+		arrangement string
+		memoryBytes int64
+	}{
+		{"ZLD1RB", 0x84408000, "B", 1},
+		{"ZLD1RB", 0x8440a000, "H", 1},
+		{"ZLD1RB", 0x8440c000, "S", 1},
+		{"ZLD1RB", 0x8440e000, "D", 1},
+		{"ZLD1RH", 0x84c0a000, "H", 2},
+		{"ZLD1RH", 0x84c0c000, "S", 2},
+		{"ZLD1RH", 0x84c0e000, "D", 2},
+		{"ZLD1RW", 0x8540c000, "S", 4},
+		{"ZLD1RW", 0x8540e000, "D", 4},
+		{"ZLD1RD", 0x85c0e000, "D", 8},
+		{"ZLD1RSB", 0x85c0a000, "S", 1},
+		{"ZLD1RSB", 0x85c0c000, "H", 1},
+		{"ZLD1RSB", 0x85c08000, "D", 1},
+		{"ZLD1RSH", 0x8540a000, "S", 2},
+		{"ZLD1RSH", 0x85408000, "D", 2},
+		{"ZLD1RSW", 0x84c08000, "D", 4},
+	}
+	for _, form := range forms {
+		if word&^fields != form.base {
+			continue
+		}
+		baseNumber := int(word>>5) & 31
+		base := Reg(fmt.Sprintf("R%d", baseNumber))
+		if baseNumber == 31 {
+			base = SP
+		}
+		memory := MemRef{
+			Base: base,
+			Off:  int64(word>>16&63) * form.memoryBytes,
+		}
+		predicate := int(word>>10) & 7
+		vector := int(word) & 31
+		return Instr{
+			Op: form.op,
+			Args: []Operand{
+				{Kind: OpMem, Mem: memory},
+				{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", predicate))},
+				{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.%s", vector, form.arrangement))}},
+			},
+			Raw: fmt.Sprintf("WORD $%#08x", word),
+		}, true
+	}
+	return Instr{}, false
+}
+
+// decodeARM64RawSVEReplicateBlock covers all sixteen Go 1.27 LD1RO/LD1RQ
+// register-offset and signed-immediate encoding rows. The decoded operands
+// are passed through the same typed lowering as the corresponding mnemonics.
+func decodeARM64RawSVEReplicateBlock(word uint32) (Instr, bool) {
+	const (
+		registerBits  = uint32(0x001f1fff)
+		immediateBits = uint32(0x000f1fff)
+	)
+	forms := [...]struct {
+		op         Op
+		register   uint32
+		immediate  uint32
+		element    string
+		elementB   int64
+		blockBytes int64
+	}{
+		{"ZLD1ROB", 0xa4200000, 0xa4202000, "B", 1, 32},
+		{"ZLD1ROH", 0xa4a00000, 0xa4a02000, "H", 2, 32},
+		{"ZLD1ROW", 0xa5200000, 0xa5202000, "S", 4, 32},
+		{"ZLD1ROD", 0xa5a00000, 0xa5a02000, "D", 8, 32},
+		{"ZLD1RQB", 0xa4000000, 0xa4002000, "B", 1, 16},
+		{"ZLD1RQH", 0xa4800000, 0xa4802000, "H", 2, 16},
+		{"ZLD1RQW", 0xa5000000, 0xa5002000, "S", 4, 16},
+		{"ZLD1RQD", 0xa5800000, 0xa5802000, "D", 8, 16},
+	}
+	for _, form := range forms {
+		registerOffset := word&^registerBits == form.register
+		immediateOffset := word&^immediateBits == form.immediate
+		if !registerOffset && !immediateOffset {
+			continue
+		}
+		baseNumber := int(word>>5) & 31
+		base := Reg(fmt.Sprintf("R%d", baseNumber))
+		if baseNumber == 31 {
+			base = SP
+		}
+		memory := MemRef{Base: base}
+		if registerOffset {
+			indexNumber := int(word>>16) & 31
+			index := Reg(fmt.Sprintf("R%d", indexNumber))
+			if indexNumber == 31 {
+				index = ZR
+			}
+			memory.Index = index
+			memory.Scale = form.elementB
+			if form.elementB == 1 {
+				memory.Base, memory.Index = memory.Index, memory.Base
+			}
+		} else {
+			immediate := int64(word >> 16 & 15)
+			if immediate >= 8 {
+				immediate -= 16
+			}
+			memory.Off = immediate * form.blockBytes
+		}
+		predicate := int(word>>10) & 7
+		vector := int(word) & 31
+		args := []Operand{
+			{Kind: OpMem, Mem: memory},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", predicate))},
+			{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.%s", vector, form.element))}},
+		}
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
+
+func (c *arm64Ctx) lowerARM64SVEReplicateMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEReplicateMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s expects memory, predicate, vector-list operands: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	vectors, elementBits, vectorsOK := arm64ParseSVEConsecutiveVectorList(ins.Args[2])
+	widthOK := elementBits >= spec.memoryBits && (!spec.signed || elementBits > spec.memoryBits)
+	if spec.blockBytes != 0 {
+		widthOK = elementBits == spec.memoryBits
+	}
+	if !predicateOK || !vectorsOK || len(vectors) != 1 || !widthOK {
+		return true, false, fmt.Errorf("arm64 %s has predicate or destination widths outside its Go 1.27 table: %q", op, ins.Raw)
+	}
+	if spec.blockBytes != 0 {
+		return c.lowerARM64SVEReplicateBlockLoad(op, spec, ins.Args[0].Mem, predicate, vectors[0], elementBits, ins)
+	}
+	return c.lowerARM64SVEReplicateScalarLoad(op, spec, ins.Args[0].Mem, predicate, vectors[0], elementBits, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEReplicateScalarLoad(op Op, spec arm64SVEReplicateMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	memoryBytes := int64(spec.memoryBits / 8)
+	address, err := c.arm64SVEScalarByteOffsetAddress(memory, 0, 63*memoryBytes, memoryBytes)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %%%s\n", loaded, spec.memoryBits, pointer)
+	scalar := "%" + loaded
+	if spec.memoryBits < elementBits {
+		extended := c.newTmp()
+		extension := "zext"
+		if spec.signed {
+			extension = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s i%d %s to i%d\n", extended, extension, spec.memoryBits, scalar, elementBits)
+		scalar = "%" + extended
+	}
+	vectorType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %s, i64 0\n", inserted, vectorType, elementBits, scalar)
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, lanes)
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s zeroinitializer\n", result, predicateType, predicateValue, vectorType, splat, vectorType)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEReplicateBlockLoad(op Op, spec arm64SVEReplicateMemorySpec, memory MemRef, predicate, destination, elementBits int, ins Instr) (ok bool, terminated bool, err error) {
+	var address string
+	var addressErr error
+	if memory.Index != "" {
+		address, addressErr = c.arm64SVERegisterOffsetAddress(memory, int64(spec.memoryBits/8))
+	} else {
+		address, addressErr = c.arm64SVEScalarByteOffsetAddress(memory, -8*int64(spec.blockBytes), 7*int64(spec.blockBytes), int64(spec.blockBytes))
+	}
+	if addressErr != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, addressErr, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	kind := "rq"
+	if spec.blockBytes == 32 {
+		kind = "ro"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld1%s.nxv%di%d(%s %s, ptr %%%s)\n",
+		result, vectorType, kind, lanes, elementBits, predicateType, predicateValue, pointer)
+	return true, false, c.storeZRegElements(destination, elementBits, "%"+result)
+}
+
+func (c *arm64Ctx) arm64SVEScalarByteOffsetAddress(memory MemRef, minimum, maximum, alignment int64) (string, error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Index != "" || memory.IndexExt != "" || memory.OffRaw != "" || memory.Off < minimum || memory.Off > maximum || memory.Off%alignment != 0 {
+		return "", fmt.Errorf("scalar byte offset must be aligned to %d and in [%d,%d]", alignment, minimum, maximum)
+	}
+	baseReg, ok := arm64SVEPhysicalMemoryBase(memory.Base)
+	if !ok {
+		return "", fmt.Errorf("address base must be R0..R30, RSP, or ZR")
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return "", err
+	}
+	if memory.Off == 0 {
+		return base, nil
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", address, base, memory.Off)
+	return "%" + address, nil
+}
diff --git a/arm64_lower_sve_replicate_memory_test.go b/arm64_lower_sve_replicate_memory_test.go
new file mode 100644
index 000000000..7478542e9
--- /dev/null
+++ b/arm64_lower_sve_replicate_memory_test.go
@@ -0,0 +1,373 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEReplicateMemoryCompleteGo127Forms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svereplicatememoryforms(SB),$0-0\n")
+	for _, spec := range []struct {
+		op           string
+		arrangements []string
+		maxOffset    int
+	}{
+		{op: "ZLD1RB", arrangements: []string{"B", "H", "S", "D"}, maxOffset: 63},
+		{op: "ZLD1RH", arrangements: []string{"H", "S", "D"}, maxOffset: 126},
+		{op: "ZLD1RW", arrangements: []string{"S", "D"}, maxOffset: 252},
+		{op: "ZLD1RD", arrangements: []string{"D"}, maxOffset: 504},
+		{op: "ZLD1RSB", arrangements: []string{"H", "S", "D"}, maxOffset: 63},
+		{op: "ZLD1RSH", arrangements: []string{"S", "D"}, maxOffset: 126},
+		{op: "ZLD1RSW", arrangements: []string{"D"}, maxOffset: 252},
+	} {
+		for i, arrangement := range spec.arrangements {
+			offset := 0
+			if i == len(spec.arrangements)-1 {
+				offset = spec.maxOffset
+			}
+			fmt.Fprintf(&source, "\t%s %d(R14), P4.Z, [Z13.%s]\n", spec.op, offset, arrangement)
+		}
+	}
+	for _, kind := range []string{"O", "Q"} {
+		blockBytes := 32
+		if kind == "Q" {
+			blockBytes = 16
+		}
+		for _, width := range []struct {
+			name        string
+			arrangement string
+			shift       int
+		}{
+			{name: "B", arrangement: "B"},
+			{name: "H", arrangement: "H", shift: 1},
+			{name: "W", arrangement: "S", shift: 2},
+			{name: "D", arrangement: "D", shift: 3},
+		} {
+			op := "ZLD1R" + kind + width.name
+			index := "R6"
+			if width.shift != 0 {
+				index = fmt.Sprintf("R6<<%d", width.shift)
+			}
+			fmt.Fprintf(&source, "\t%s (%s)(R14), P4.Z, [Z13.%s]\n", op, index, width.arrangement)
+			fmt.Fprintf(&source, "\t%s %d(R14), P4.Z, [Z13.%s]\n", op, -8*blockBytes, width.arrangement)
+		}
+	}
+	// Cover both ends of each signed immediate range.
+	source.WriteString("\tZLD1ROB 224(R14), P4.Z, [Z13.B]\n")
+	source.WriteString("\tZLD1RQB 112(R14), P4.Z, [Z13.B]\n")
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEReplicateMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEReplicateMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svereplicatememoryforms": {Name: "svereplicatememoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+f64mm,+sve"`,
+				"@llvm.aarch64.sve.ld1ro.nxv16i8",
+				"@llvm.aarch64.sve.ld1ro.nxv8i16",
+				"@llvm.aarch64.sve.ld1ro.nxv4i32",
+				"@llvm.aarch64.sve.ld1ro.nxv2i64",
+				"@llvm.aarch64.sve.ld1rq.nxv16i8",
+				"@llvm.aarch64.sve.ld1rq.nxv8i16",
+				"@llvm.aarch64.sve.ld1rq.nxv4i32",
+				"@llvm.aarch64.sve.ld1rq.nxv2i64",
+				"shufflevector <vscale x ",
+				"select <vscale x ",
+				" sext i",
+				" zext i",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE replicate memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-replicate-memory.ll", "arm64-sve-replicate-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEReplicateBlockCompleteFamily(t *testing.T) {
+	// The RO and RQ families each have B/H/W/D and register/immediate
+	// addressing rows. lightning emits RQB at 0xa40024e1.
+	forms := []struct {
+		regBase    uint32
+		immBase    uint32
+		blockBytes int
+	}{
+		{0xa4200000, 0xa4202000, 32},
+		{0xa4a00000, 0xa4a02000, 32},
+		{0xa5200000, 0xa5202000, 32},
+		{0xa5a00000, 0xa5a02000, 32},
+		{0xa4000000, 0xa4002000, 16},
+		{0xa4800000, 0xa4802000, 16},
+		{0xa5000000, 0xa5002000, 16},
+		{0xa5800000, 0xa5802000, 16},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEReplicateBlock(SB),$0-0\n")
+	source.WriteString("\tWORD $0xa40024e1\n")
+	for _, form := range forms {
+		registers := uint32(6<<16 | 4<<10 | 14<<5 | 13)
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", form.regBase|registers)
+		for _, offset := range []uint32{0, 7, 8} {
+			word := form.immBase | offset<<16 | 4<<10 | 14<<5 | 13
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEReplicateBlock": {Name: "rawSVEReplicateBlock", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+f64mm,+sve"`,
+				"@llvm.aarch64.sve.ld1ro.nxv16i8",
+				"@llvm.aarch64.sve.ld1ro.nxv2i64",
+				"@llvm.aarch64.sve.ld1rq.nxv16i8",
+				"@llvm.aarch64.sve.ld1rq.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw replicate block IR omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-replicate-block.ll", "arm64-raw-sve-replicate-block.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEReplicateScalarCompleteFamily(t *testing.T) {
+	// These are all sixteen immediate-address scalar replicate-load rows in
+	// Go 1.27's ARM64 instruction table, including the go-highway LD1RW word.
+	forms := []uint32{
+		0x84408000, 0x8440a000, 0x8440c000, 0x8440e000, // LD1RB
+		0x84c0a000, 0x84c0c000, 0x84c0e000, // LD1RH
+		0x8540c000, 0x8540e000, // LD1RW
+		0x85c0e000,                         // LD1RD
+		0x85c0a000, 0x85c0c000, 0x85c08000, // LD1RSB
+		0x8540a000, 0x85408000, // LD1RSH
+		0x84c08000, // LD1RSW
+	}
+	for _, base := range forms {
+		t.Run(fmt.Sprintf("encoding-%#08x", base), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT scalar(SB),$0-0\n\tWORD $%#08x\n\tRET\n", base|5<<10|14<<5|13)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"scalar": {Name: "scalar", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, `"target-features"="+sve"`) {
+				t.Fatal("raw scalar replicate load omitted SVE target feature")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "scalar.ll", "scalar.o", ll)
+		})
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEReplicateScalar(SB),$0-0\n")
+	source.WriteString("\tWORD $0x8540c0c0\n")
+	for _, base := range forms {
+		for _, offset := range []uint32{0, 63} {
+			word := base | offset<<16 | 5<<10 | 14<<5 | 13
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEReplicateScalar": {Name: "rawSVEReplicateScalar", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"shufflevector <vscale x ", "select <vscale x ", " sext i", " zext i"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s raw scalar replicate lowering omitted %q", triple, want)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-replicate-scalar.ll", "arm64-raw-sve-replicate-scalar.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEReplicateScalarBoundaries(t *testing.T) {
+	tests := []struct {
+		word        uint32
+		op          Op
+		base        Reg
+		arrangement Reg
+		offset      int64
+	}{
+		{0x8540c0c0, "ZLD1RW", "R6", "Z0.S", 0},
+		{0x8540c000 | 63<<16 | 7<<10 | 31<<5 | 31, "ZLD1RW", SP, "Z31.S", 252},
+		{0x85c0e000 | 63<<16 | 7<<10 | 31<<5 | 31, "ZLD1RD", SP, "Z31.D", 504},
+		{0x84408000 | 63<<16 | 7<<10 | 31<<5 | 31, "ZLD1RB", SP, "Z31.B", 63},
+		{0x84c08000 | 63<<16 | 7<<10 | 31<<5 | 31, "ZLD1RSW", SP, "Z31.D", 252},
+	}
+	for _, test := range tests {
+		ins, ok := decodeARM64RawSVEReplicateScalar(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != 3 {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		predicate := Reg(fmt.Sprintf("P%d.Z", test.word>>10&7))
+		if ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != test.base ||
+			ins.Args[0].Mem.Off != test.offset || ins.Args[1].Reg != predicate ||
+			ins.Args[2].RegList[0] != test.arrangement {
+			t.Errorf("decoded %#08x operands = %+v", test.word, ins.Args)
+		}
+	}
+	for _, word := range []uint32{
+		0x8540c0c0 | 1<<25,
+		0x8540c0c0 | 1<<27,
+		0x8540c0c0 | 1<<29,
+	} {
+		if ins, ok := decodeARM64RawSVEReplicateScalar(word); ok {
+			t.Errorf("decoded reserved scalar replicate load %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestDecodeARM64RawSVEReplicateBlockBoundaries(t *testing.T) {
+	observed, ok := decodeARM64RawSVEReplicateBlock(0xa40024e1)
+	if !ok || observed.Op != "ZLD1RQB" || len(observed.Args) != 3 {
+		t.Fatalf("decode lightning LD1RQB = %+v, %v", observed, ok)
+	}
+	if observed.Args[0].Kind != OpMem || observed.Args[0].Mem.Base != "R7" ||
+		observed.Args[0].Mem.Off != 0 || observed.Args[1].Reg != "P1.Z" ||
+		observed.Args[2].RegList[0] != "Z1.B" {
+		t.Fatalf("lightning LD1RQB operands = %+v", observed.Args)
+	}
+	for _, test := range []struct {
+		word  uint32
+		op    Op
+		base  Reg
+		index Reg
+		scale int64
+		off   int64
+	}{
+		{0xa4200000 | 6<<16 | 4<<10 | 14<<5 | 13, "ZLD1ROB", "R6", "R14", 1, 0},
+		{0xa4800000 | 6<<16 | 4<<10 | 14<<5 | 13, "ZLD1RQH", "R14", "R6", 2, 0},
+		{0xa5802000 | 8<<16 | 4<<10 | 14<<5 | 13, "ZLD1RQD", "R14", "", 0, -128},
+	} {
+		ins, ok := decodeARM64RawSVEReplicateBlock(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		memory := ins.Args[0].Mem
+		if memory.Base != test.base || memory.Index != test.index ||
+			memory.Scale != test.scale || memory.Off != test.off {
+			t.Errorf("%#08x memory = %+v", test.word, memory)
+		}
+	}
+	for _, word := range []uint32{
+		0xa40024e1 | (1 << 14),
+		0xa40024e1 | (1 << 20),
+	} {
+		if ins, ok := decodeARM64RawSVEReplicateBlock(word); ok {
+			t.Errorf("decoded reserved replicate load %#08x as %+v", word, ins)
+		}
+	}
+}
+
+func TestTranslateARM64SVEReplicateMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLD1RB (R14), P8.Z, [Z13.B]",
+		"ZLD1RB (R14), P4, [Z13.B]",
+		"ZLD1RB (R14), P4.Z, [Z13.B, Z14.B]",
+		"ZLD1RH (R14), P4.Z, [Z13.B]",
+		"ZLD1RW (R14), P4.Z, [Z13.H]",
+		"ZLD1RD (R14), P4.Z, [Z13.S]",
+		"ZLD1RSB (R14), P4.Z, [Z13.B]",
+		"ZLD1RSH (R14), P4.Z, [Z13.H]",
+		"ZLD1RSW (R14), P4.Z, [Z13.S]",
+		"ZLD1RB 64(R14), P4.Z, [Z13.B]",
+		"ZLD1RH 127(R14), P4.Z, [Z13.H]",
+		"ZLD1RW 254(R14), P4.Z, [Z13.S]",
+		"ZLD1RD 512(R14), P4.Z, [Z13.D]",
+		"ZLD1ROB -288(R14), P4.Z, [Z13.B]",
+		"ZLD1ROB 256(R14), P4.Z, [Z13.B]",
+		"ZLD1ROB 16(R14), P4.Z, [Z13.B]",
+		"ZLD1RQB -144(R14), P4.Z, [Z13.B]",
+		"ZLD1RQB 128(R14), P4.Z, [Z13.B]",
+		"ZLD1RQB 8(R14), P4.Z, [Z13.B]",
+		"ZLD1ROH (R6)(R14), P4.Z, [Z13.H]",
+		"ZLD1RQD (R6<<2)(R14), P4.Z, [Z13.D]",
+		"ZLD1ROB.Z (R6)(R14), P4.Z, [Z13.B]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvereplicatememory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvereplicatememory": {Name: "badsvereplicatememory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's replicate memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_revd.go b/arm64_lower_sve_revd.go
new file mode 100644
index 000000000..156ed1bfb
--- /dev/null
+++ b/arm64_lower_sve_revd.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func decodeARM64RawSVERevd(word uint32) (Instr, bool) {
+	mode := "M"
+	switch word & 0xffffe000 {
+	case 0x052e8000:
+	case 0x052ea000:
+		mode = "Z"
+	default:
+		return Instr{}, false
+	}
+	return Instr{Op: "ZREVD", Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.Q", word>>5&31))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", word>>10&7, mode))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.Q", word&31))},
+	}}, true
+}
+
+func arm64ParseSVEZQReg(operand Operand) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if !strings.HasPrefix(name, "Z") || !strings.HasSuffix(name, ".Q") {
+		return 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(name, "Z"), ".Q"))
+	return index, err == nil && index >= 0 && index <= 31
+}
+
+func arm64SVERevdNeedsSVE2P2(ins Instr) bool {
+	return len(ins.Args) == 3 && func() bool {
+		_, ok := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+		return ok
+	}()
+}
+
+func (c *arm64Ctx) lowerARM64SVERevd(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZREVD" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 ZREVD expects Zn.Q, Pg/M|Z, Zd.Q without a suffix: %q", ins.Raw)
+	}
+	source, sourceOK := arm64ParseSVEZQReg(ins.Args[0])
+	destination, destinationOK := arm64ParseSVEZQReg(ins.Args[2])
+	predicate, mergeOK := arm64ParseSVEPredicateMode(ins.Args[1], "M", 7)
+	zeroing := false
+	if !mergeOK {
+		predicate, zeroing = arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	}
+	if !sourceOK || !destinationOK || !mergeOK && !zeroing {
+		return true, false, fmt.Errorf("arm64 ZREVD requires Q vectors and P0..P7/M or P0..P7/Z: %q", ins.Raw)
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, 64)
+	if err != nil {
+		return true, false, err
+	}
+	mergeValue := "zeroinitializer"
+	if !zeroing {
+		mergeValue, _, err = c.loadZRegElements(destination, 64)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, 64)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.revd.nxv2i64(%s %s, %s %s, %s %s)\n", result, vectorType, vectorType, mergeValue, predicateType, predicateValue, vectorType, sourceValue)
+	return true, false, c.storeZRegElements(destination, 64, "%"+result)
+}
diff --git a/arm64_lower_sve_revd_test.go b/arm64_lower_sve_revd_test.go
new file mode 100644
index 000000000..3c28bbfd0
--- /dev/null
+++ b/arm64_lower_sve_revd_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVERevdCompleteGo127Family(t *testing.T) {
+	source := "TEXT sverevdforms(SB),$0-0\n\tZREVD Z1.Q, P0.M, Z2.Q\n\tZREVD Z3.Q, P7.Z, Z4.Q\n\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sverevdforms": {Name: "sverevdforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2p1,+sve2p2"`, "@llvm.aarch64.sve.revd.nxv2i64", "zeroinitializer"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE REVD lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-revd.ll", "arm64-sve-revd.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVERevdRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZREVD Z1.D, P0.M, Z2.D",
+		"ZREVD Z1.Q, P0, Z2.Q",
+		"ZREVD Z1.Q, P8.M, Z2.Q",
+		"ZREVD Z1.Q, P0.M",
+		"ZREVD.Z Z1.Q, P0.M, Z2.Q",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsverevd(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsverevd": {Name: "badsverevd", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE REVD forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_rounding_shift_test.go b/arm64_lower_sve_rounding_shift_test.go
new file mode 100644
index 000000000..bdcec07ea
--- /dev/null
+++ b/arm64_lower_sve_rounding_shift_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+var arm64SVERoundingShiftOps = []string{
+	"ZSQRSHL", "ZSQRSHLR", "ZSQSHLR",
+	"ZUQRSHL", "ZUQRSHLR", "ZUQSHLR",
+	"ZSRSHL", "ZSRSHLR", "ZURSHL", "ZURSHLR",
+}
+
+func arm64SVERoundingShiftCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveroundingshiftforms(SB),$0-0\n")
+	for _, op := range arm64SVERoundingShiftOps {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", P0.M, Z2." + width + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVERoundingShiftCompleteGo127Family(t *testing.T) {
+	source := arm64SVERoundingShiftCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveroundingshiftforms": {Name: "sveroundingshiftforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.sqrshl.nxv",
+				"@llvm.aarch64.sve.uqrshl.nxv",
+				"@llvm.aarch64.sve.sqshl.nxv",
+				"@llvm.aarch64.sve.uqshl.nxv",
+				"@llvm.aarch64.sve.srshl.nxv",
+				"@llvm.aarch64.sve.urshl.nxv",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE rounding-shift lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-rounding-shift.ll", "arm64-sve-rounding-shift.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVERoundingShiftRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQRSHL Z1.B, Z2.H, P0.M, Z2.H",
+		"ZSQRSHLR Z1.S, Z2.S, P0.M, Z3.S",
+		"ZSQSHLR $1, Z2.S, P0.M, Z2.S",
+		"ZUQRSHL Z1.D, Z2.D, P8.M, Z2.D",
+		"ZSRSHL Z1.S, Z2.S, P0, Z2.S",
+		"ZURSHLR.Z Z1.S, Z2.S, P0.M, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "$", "imm").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveroundingshift(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveroundingshift": {Name: "badsveroundingshift", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE rounding-shift forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_saturating_multiply_high.go b/arm64_lower_sve_saturating_multiply_high.go
new file mode 100644
index 000000000..feef42927
--- /dev/null
+++ b/arm64_lower_sve_saturating_multiply_high.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVESaturatingMultiplyHighIntrinsics = map[Op]string{
+	"ZSQDMULH":  "sqdmulh",
+	"ZSQRDMULH": "sqrdmulh",
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingMultiplyHigh(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVESaturatingMultiplyHighIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 vector form without a suffix: %q", op, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !firstOK || !destinationOK || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s source and destination widths must match: %q", op, ins.Raw)
+	}
+	second, secondBits, lane, indexed := arm64ParseSVEZIndexedElementReg(ins.Args[0])
+	if !indexed {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		if !secondOK || secondBits != firstBits {
+			return true, false, fmt.Errorf("arm64 %s vector operands must use one B/H/S/D width: %q", op, ins.Raw)
+		}
+		return true, false, c.lowerARM64SVESaturatingMultiplyHighForm(intrinsic, firstBits, first, second, 0, destination, false)
+	}
+	if secondBits != firstBits {
+		return true, false, fmt.Errorf("arm64 %s indexed operands must use one H/S/D width and an encodable lane: %q", op, ins.Raw)
+	}
+	return true, false, c.lowerARM64SVESaturatingMultiplyHighForm(intrinsic, firstBits, first, second, lane, destination, true)
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingMultiplyHighForm(intrinsic string, elementBits, first, second, lane, destination int, indexed bool) error {
+	firstValue, vectorType, err := c.loadZRegElements(first, elementBits)
+	if err != nil {
+		return err
+	}
+	secondValue, _, err := c.loadZRegElements(second, elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, i32 %d)\n",
+			result, vectorType, intrinsic, lanes, elementBits, vectorType, firstValue, vectorType, secondValue, lane)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n",
+			result, vectorType, intrinsic, lanes, elementBits, vectorType, firstValue, vectorType, secondValue)
+	}
+	return c.storeZRegElements(destination, elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_saturating_multiply_high_test.go b/arm64_lower_sve_saturating_multiply_high_test.go
new file mode 100644
index 000000000..7bcd1f79d
--- /dev/null
+++ b/arm64_lower_sve_saturating_multiply_high_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVESaturatingMultiplyHighCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svesaturatingmultiplyhighforms(SB),$0-0\n")
+	for _, op := range []string{"ZSQDMULH", "ZSQRDMULH"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width, width, width)
+		}
+		for index, width := range []string{"H", "S", "D"} {
+			maximumVector := []int{7, 7, 15}[index]
+			maximumLane := []int{7, 3, 1}[index]
+			fmt.Fprintf(&source, "\t%s Z%d.%s[%d], Z4.%s, Z5.%s\n", op, maximumVector, width, maximumLane, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svesaturatingmultiplyhighforms": {Name: "svesaturatingmultiplyhighforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.sqdmulh.nxv16i8",
+				"@llvm.aarch64.sve.sqdmulh.lane.nxv8i16",
+				"@llvm.aarch64.sve.sqrdmulh.nxv2i64",
+				"@llvm.aarch64.sve.sqrdmulh.lane.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE saturating multiply-high lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-saturating-multiply-high.ll", "arm64-sve-saturating-multiply-high.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingMultiplyHighRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQDMULH Z1.B, Z2.H, Z3.H",
+		"ZSQRDMULH Z1.B[0], Z2.B, Z3.B",
+		"ZSQDMULH Z8.H[0], Z2.H, Z3.H",
+		"ZSQRDMULH Z7.H[8], Z2.H, Z3.H",
+		"ZSQDMULH Z7.S[3], Z2.D, Z3.D",
+		"ZSQRDMULH.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingmultiplyhigh(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingmultiplyhigh": {Name: "badsvesaturatingmultiplyhigh", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE saturating multiply-high forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_saturating_narrow.go b/arm64_lower_sve_saturating_narrow.go
new file mode 100644
index 000000000..bbda778fb
--- /dev/null
+++ b/arm64_lower_sve_saturating_narrow.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVESaturatingNarrowSpec struct {
+	intrinsic string
+	top       bool
+}
+
+var arm64SVESaturatingNarrowSpecs = map[Op]arm64SVESaturatingNarrowSpec{
+	"ZSQXTNB":  {intrinsic: "sqxtnb"},
+	"ZSQXTNT":  {intrinsic: "sqxtnt", top: true},
+	"ZSQXTUNB": {intrinsic: "sqxtunb"},
+	"ZSQXTUNT": {intrinsic: "sqxtunt", top: true},
+	"ZUQXTNB":  {intrinsic: "uqxtnb"},
+	"ZUQXTNT":  {intrinsic: "uqxtnt", top: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVESaturatingNarrowSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.H|S|D, Zd.B|H|S without a suffix: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !sourceOK || !destinationOK || (sourceBits != 16 && sourceBits != 32 && sourceBits != 64) || destinationBits*2 != sourceBits {
+		return true, false, fmt.Errorf("arm64 %s requires an H-to-B, S-to-H, or D-to-S narrowing pair: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, _, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	args := fmt.Sprintf("%s %s", sourceType, sourceValue)
+	if spec.top {
+		merged, _, err := c.loadZRegElements(destination, destinationBits)
+		if err != nil {
+			return true, false, err
+		}
+		args = fmt.Sprintf("%s %s, %s", destinationType, merged, args)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s)\n", result, destinationType, spec.intrinsic, 128/sourceBits, sourceBits, args)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_saturating_narrow_test.go b/arm64_lower_sve_saturating_narrow_test.go
new file mode 100644
index 000000000..b8f9abc03
--- /dev/null
+++ b/arm64_lower_sve_saturating_narrow_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVESaturatingNarrowCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svesaturatingnarrowforms(SB),$0-0\n")
+	for _, op := range []string{"ZSQXTNB", "ZSQXTNT", "ZSQXTUNB", "ZSQXTUNT", "ZUQXTNB", "ZUQXTNT"} {
+		for _, widths := range [][2]string{{"H", "B"}, {"S", "H"}, {"D", "S"}} {
+			source.WriteString("\t" + op + " Z1." + widths[0] + ", Z2." + widths[1] + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVESaturatingNarrowCompleteGo127Family(t *testing.T) {
+	source := arm64SVESaturatingNarrowCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svesaturatingnarrowforms": {Name: "svesaturatingnarrowforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.sqxtnb.nxv8i16",
+				"@llvm.aarch64.sve.sqxtnt.nxv4i32",
+				"@llvm.aarch64.sve.sqxtunb.nxv2i64",
+				"@llvm.aarch64.sve.sqxtunt.nxv8i16",
+				"@llvm.aarch64.sve.uqxtnb.nxv4i32",
+				"@llvm.aarch64.sve.uqxtnt.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE saturating-narrow lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-saturating-narrow.ll", "arm64-sve-saturating-narrow.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingNarrowRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQXTNB Z1.B, Z2.B",
+		"ZSQXTNT Z1.H, Z2.H",
+		"ZSQXTUNB Z1.S, Z2.B",
+		"ZSQXTUNT Z1.D, Z2.H",
+		"ZUQXTNB Z1.Q, Z2.D",
+		"ZUQXTNT Z1.D",
+		"ZSQXTNB.Z Z1.H, Z2.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingnarrow(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingnarrow": {Name: "badsvesaturatingnarrow", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE saturating-narrow forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_saturating_rounding_multiply_accumulate_high.go b/arm64_lower_sve_saturating_rounding_multiply_accumulate_high.go
new file mode 100644
index 000000000..49e8d208e
--- /dev/null
+++ b/arm64_lower_sve_saturating_rounding_multiply_accumulate_high.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVESaturatingRoundingMultiplyAccumulateHighIntrinsics = map[Op]string{
+	"ZSQRDMLAH": "sqrdmlah",
+	"ZSQRDMLSH": "sqrdmlsh",
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingRoundingMultiplyAccumulateHigh(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVESaturatingRoundingMultiplyAccumulateHighIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 vector form without a suffix: %q", op, ins.Raw)
+	}
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !firstOK || !destinationOK || firstBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s source and accumulator widths must match: %q", op, ins.Raw)
+	}
+	second, secondBits, lane, indexed := arm64ParseSVEZIndexedElementReg(ins.Args[0])
+	if !indexed {
+		var secondOK bool
+		second, secondBits, secondOK = arm64ParseSVEZElementReg(ins.Args[0])
+		if !secondOK || secondBits != firstBits {
+			return true, false, fmt.Errorf("arm64 %s vector operands must use one B/H/S/D width: %q", op, ins.Raw)
+		}
+	} else if secondBits != firstBits {
+		return true, false, fmt.Errorf("arm64 %s indexed operands must use one H/S/D width and an encodable lane: %q", op, ins.Raw)
+	}
+	accumulator, vectorType, err := c.loadZRegElements(destination, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	firstValue, _, err := c.loadZRegElements(first, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(firstBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	if indexed {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n",
+			result, vectorType, intrinsic, lanes, firstBits, vectorType, accumulator, vectorType, firstValue, vectorType, secondValue, lane)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n",
+			result, vectorType, intrinsic, lanes, firstBits, vectorType, accumulator, vectorType, firstValue, vectorType, secondValue)
+	}
+	return true, false, c.storeZRegElements(destination, firstBits, "%"+result)
+}
diff --git a/arm64_lower_sve_saturating_rounding_multiply_accumulate_high_test.go b/arm64_lower_sve_saturating_rounding_multiply_accumulate_high_test.go
new file mode 100644
index 000000000..205517f3a
--- /dev/null
+++ b/arm64_lower_sve_saturating_rounding_multiply_accumulate_high_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVESaturatingRoundingMultiplyAccumulateHighCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svesaturatingroundingmultiplyaccumulatehighforms(SB),$0-0\n")
+	for _, op := range []string{"ZSQRDMLAH", "ZSQRDMLSH"} {
+		for _, width := range []string{"B", "H", "S", "D"} {
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, Z3.%s\n", op, width, width, width)
+		}
+		for index, width := range []string{"H", "S", "D"} {
+			maximumVector := []int{7, 7, 15}[index]
+			maximumLane := []int{7, 3, 1}[index]
+			fmt.Fprintf(&source, "\t%s Z%d.%s[%d], Z4.%s, Z5.%s\n", op, maximumVector, width, maximumLane, width, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svesaturatingroundingmultiplyaccumulatehighforms": {Name: "svesaturatingroundingmultiplyaccumulatehighforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.sqrdmlah.nxv16i8",
+				"@llvm.aarch64.sve.sqrdmlah.lane.nxv8i16",
+				"@llvm.aarch64.sve.sqrdmlsh.nxv2i64",
+				"@llvm.aarch64.sve.sqrdmlsh.lane.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE saturating rounding multiply-accumulate-high lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-saturating-rounding-multiply-accumulate-high.ll", "arm64-sve-saturating-rounding-multiply-accumulate-high.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingRoundingMultiplyAccumulateHighRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQRDMLAH Z1.B, Z2.H, Z3.H",
+		"ZSQRDMLSH Z1.B[0], Z2.B, Z3.B",
+		"ZSQRDMLAH Z8.H[0], Z2.H, Z3.H",
+		"ZSQRDMLSH Z7.H[8], Z2.H, Z3.H",
+		"ZSQRDMLAH Z7.S[3], Z2.D, Z3.D",
+		"ZSQRDMLSH.Z Z1.S, Z2.S, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingroundingmultiplyaccumulatehigh(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingroundingmultiplyaccumulatehigh": {Name: "badsvesaturatingroundingmultiplyaccumulatehigh", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE saturating rounding multiply-accumulate-high forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_saturating_shift.go b/arm64_lower_sve_saturating_shift.go
new file mode 100644
index 000000000..34780765b
--- /dev/null
+++ b/arm64_lower_sve_saturating_shift.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEVariableShiftSpec struct {
+	intrinsic string
+	immediate bool
+	reverse   bool
+}
+
+var arm64SVEVariableShiftSpecs = map[Op]arm64SVEVariableShiftSpec{
+	"ZSQSHL":   {intrinsic: "sqshl", immediate: true},
+	"ZUQSHL":   {intrinsic: "uqshl", immediate: true},
+	"ZSQRSHL":  {intrinsic: "sqrshl"},
+	"ZSQRSHLR": {intrinsic: "sqrshl", reverse: true},
+	"ZSQSHLR":  {intrinsic: "sqshl", reverse: true},
+	"ZUQRSHL":  {intrinsic: "uqrshl"},
+	"ZUQRSHLR": {intrinsic: "uqrshl", reverse: true},
+	"ZUQSHLR":  {intrinsic: "uqshl", reverse: true},
+	"ZSRSHL":   {intrinsic: "srshl"},
+	"ZSRSHLR":  {intrinsic: "srshl", reverse: true},
+	"ZURSHL":   {intrinsic: "urshl"},
+	"ZURSHLR":  {intrinsic: "urshl", reverse: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEVariableShiftSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects shift, Zdn.T, P0..P7.M, Zdn.T without a suffix: %q", op, ins.Raw)
+	}
+	data, elementBits, dataOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[2], "M", 7)
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !dataOK || !predicateOK || !destinationOK || data != destination || elementBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s requires matching destructive data operands and P0..P7.M: %q", op, ins.Raw)
+	}
+	dataValue, vectorType, err := c.loadZRegElements(data, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	shiftValue := ""
+	if ins.Args[0].Kind == OpImm {
+		if !spec.immediate || ins.Args[0].ImmRaw != "" || ins.Args[0].Imm < 0 || ins.Args[0].Imm >= int64(elementBits) {
+			return true, false, fmt.Errorf("arm64 %s immediate must be in 0..%d: %q", op, elementBits-1, ins.Raw)
+		}
+		shiftValue = fmt.Sprintf("splat (i%d %d)", elementBits, ins.Args[0].Imm)
+	} else {
+		shifts, shiftBits, shiftsOK := arm64ParseSVEZElementReg(ins.Args[0])
+		if !shiftsOK || shiftBits != elementBits {
+			return true, false, fmt.Errorf("arm64 %s shift vector must match the B/H/S/D data width: %q", op, ins.Raw)
+		}
+		shiftValue, _, err = c.loadZRegElements(shifts, elementBits)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	firstValue, secondValue := dataValue, shiftValue
+	if spec.reverse {
+		firstValue, secondValue = shiftValue, dataValue
+	}
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, spec.intrinsic, lanes, elementBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	resultValue := "%" + result
+	if spec.reverse {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", selected, predicateType, predicateValue, vectorType, resultValue, vectorType, dataValue)
+		resultValue = "%" + selected
+	}
+	return true, false, c.storeZRegElements(destination, elementBits, resultValue)
+}
diff --git a/arm64_lower_sve_saturating_shift_narrow.go b/arm64_lower_sve_saturating_shift_narrow.go
new file mode 100644
index 000000000..c03a8e2cf
--- /dev/null
+++ b/arm64_lower_sve_saturating_shift_narrow.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVESaturatingShiftNarrowSpec struct {
+	intrinsic string
+	top       bool
+}
+
+var arm64SVESaturatingShiftNarrowSpecs = map[Op]arm64SVESaturatingShiftNarrowSpec{
+	"ZSQSHRNB":   {intrinsic: "sqshrnb"},
+	"ZSQSHRNT":   {intrinsic: "sqshrnt", top: true},
+	"ZSQRSHRNB":  {intrinsic: "sqrshrnb"},
+	"ZSQRSHRNT":  {intrinsic: "sqrshrnt", top: true},
+	"ZSQSHRUNB":  {intrinsic: "sqshrunb"},
+	"ZSQSHRUNT":  {intrinsic: "sqshrunt", top: true},
+	"ZSQRSHRUNB": {intrinsic: "sqrshrunb"},
+	"ZSQRSHRUNT": {intrinsic: "sqrshrunt", top: true},
+	"ZUQSHRNB":   {intrinsic: "uqshrnb"},
+	"ZUQSHRNT":   {intrinsic: "uqshrnt", top: true},
+	"ZUQRSHRNB":  {intrinsic: "uqrshrnb"},
+	"ZUQRSHRNT":  {intrinsic: "uqrshrnt", top: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVESaturatingShiftNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVESaturatingShiftNarrowSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects $shift, Zn.H|S|D, Zd.B|H|S without a suffix: %q", op, ins.Raw)
+	}
+	shift := ins.Args[0].Imm
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !destinationOK || (sourceBits != 16 && sourceBits != 32 && sourceBits != 64) || destinationBits*2 != sourceBits || shift < 1 || shift > int64(destinationBits) {
+		return true, false, fmt.Errorf("arm64 %s requires matching H-to-B, S-to-H, or D-to-S operands and shift $1..$destinationBits: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, _, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	args := fmt.Sprintf("%s %s, i32 %d", sourceType, sourceValue, shift)
+	if spec.top {
+		merged, _, err := c.loadZRegElements(destination, destinationBits)
+		if err != nil {
+			return true, false, err
+		}
+		args = fmt.Sprintf("%s %s, %s", destinationType, merged, args)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s)\n", result, destinationType, spec.intrinsic, 128/sourceBits, sourceBits, args)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_saturating_shift_narrow_test.go b/arm64_lower_sve_saturating_shift_narrow_test.go
new file mode 100644
index 000000000..c6d06fda5
--- /dev/null
+++ b/arm64_lower_sve_saturating_shift_narrow_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVESaturatingShiftNarrowOps = []string{
+	"ZSQSHRNB", "ZSQSHRNT", "ZSQRSHRNB", "ZSQRSHRNT",
+	"ZSQSHRUNB", "ZSQSHRUNT", "ZSQRSHRUNB", "ZSQRSHRUNT",
+	"ZUQSHRNB", "ZUQSHRNT", "ZUQRSHRNB", "ZUQRSHRNT",
+}
+
+func arm64SVESaturatingShiftNarrowCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svesaturatingshiftnarrowforms(SB),$0-0\n")
+	for _, op := range arm64SVESaturatingShiftNarrowOps {
+		for _, form := range []struct {
+			source, destination string
+			max                 int
+		}{{"H", "B", 8}, {"S", "H", 16}, {"D", "S", 32}} {
+			for _, shift := range []int{1, form.max} {
+				fmt.Fprintf(&source, "\t%s $%d, Z1.%s, Z2.%s\n", op, shift, form.source, form.destination)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVESaturatingShiftNarrowCompleteGo127Family(t *testing.T) {
+	source := arm64SVESaturatingShiftNarrowCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svesaturatingshiftnarrowforms": {Name: "svesaturatingshiftnarrowforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{
+				"sqshrnb", "sqshrnt", "sqrshrnb", "sqrshrnt",
+				"sqshrunb", "sqshrunt", "sqrshrunb", "sqrshrunt",
+				"uqshrnb", "uqshrnt", "uqrshrnb", "uqrshrnt",
+			} {
+				if want := "@llvm.aarch64.sve." + intrinsic + ".nxv"; !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE saturating-shift-narrow lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			if want := `"target-features"="+sve,+sve2"`; !strings.Contains(ll, want) {
+				t.Fatalf("%s SVE saturating-shift-narrow lowering omitted %q:\n%s", triple, want, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-saturating-shift-narrow.ll", "arm64-sve-saturating-shift-narrow.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingShiftNarrowRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQSHRNB $0, Z1.H, Z2.B",
+		"ZSQRSHRNT $1, Z1.S, Z2.B",
+		"ZSQSHRUNB $1, Z1.Q, Z2.D",
+		"ZSQRSHRUNT $1, Z1.D",
+		"ZUQSHRNB.Z $1, Z1.H, Z2.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "$", "imm").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingshiftnarrow(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingshiftnarrow": {Name: "badsvesaturatingshiftnarrow", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE saturating-shift-narrow forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingShiftNarrowRejectsGoAcceptedUnencodableShifts(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQSHRNT $9, Z1.H, Z2.B",
+		"ZSQRSHRUNB $17, Z1.S, Z2.H",
+		"ZUQRSHRNT $33, Z1.D, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "$", "imm").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingshiftnarrowrange(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingshiftnarrowrange": {Name: "badsvesaturatingshiftnarrowrange", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted Go-assembler form %q that LLVM 22 cannot encode", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_saturating_shift_test.go b/arm64_lower_sve_saturating_shift_test.go
new file mode 100644
index 000000000..c800aa323
--- /dev/null
+++ b/arm64_lower_sve_saturating_shift_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVESaturatingShiftCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svesaturatingshiftforms(SB),$0-0\n")
+	for _, op := range []string{"ZSQSHL", "ZUQSHL"} {
+		for index, width := range []string{"B", "H", "S", "D"} {
+			maximum := []int{7, 15, 31, 63}[index]
+			fmt.Fprintf(&source, "\t%s Z1.%s, Z2.%s, P%d.M, Z2.%s\n", op, width, width, index, width)
+			fmt.Fprintf(&source, "\t%s $0, Z3.%s, P%d.M, Z3.%s\n", op, width, index, width)
+			fmt.Fprintf(&source, "\t%s $%d, Z4.%s, P%d.M, Z4.%s\n", op, maximum, width, index, width)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svesaturatingshiftforms": {Name: "svesaturatingshiftforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve,+sve2\"",
+				"@llvm.aarch64.sve.sqshl.nxv",
+				"@llvm.aarch64.sve.uqshl.nxv",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE saturating-shift lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-saturating-shift.ll", "arm64-sve-saturating-shift.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESaturatingShiftRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSQSHL $-1, Z1.B, P0.M, Z1.B",
+		"ZUQSHL $8, Z1.B, P0.M, Z1.B",
+		"ZSQSHL $16, Z1.H, P0.M, Z1.H",
+		"ZUQSHL Z1.S, Z2.H, P0.M, Z2.H",
+		"ZSQSHL Z1.S, Z2.S, P0, Z2.S",
+		"ZUQSHL Z1.S, Z2.S, P8.M, Z2.S",
+		"ZSQSHL Z1.S, Z2.S, P0.M, Z3.S",
+		"ZUQSHL.Z Z1.S, Z2.S, P0.M, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesaturatingshift(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesaturatingshift": {Name: "badsvesaturatingshift", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE saturating-shift forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_select.go b/arm64_lower_sve_select.go
new file mode 100644
index 000000000..b54f7da79
--- /dev/null
+++ b/arm64_lower_sve_select.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64RawSVESelect struct {
+	elementBits int
+	falseValue  int
+	trueValue   int
+	predicate   int
+	destination int
+}
+
+func decodeARM64RawSVESelect(word uint32) (arm64RawSVESelect, bool) {
+	if word&0xff20c000 != 0x0520c000 {
+		return arm64RawSVESelect{}, false
+	}
+	return arm64RawSVESelect{
+		elementBits: 8 << (int(word>>22) & 3),
+		falseValue:  int(word>>16) & 31,
+		trueValue:   int(word>>5) & 31,
+		predicate:   int(word>>10) & 15,
+		destination: int(word) & 31,
+	}, true
+}
+
+func arm64ParseSVEPredicate(operand Operand) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if strings.Contains(name, ".") || !strings.HasPrefix(name, "P") {
+		return 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(name, "P"))
+	return index, err == nil && index >= 0 && index < 16
+}
+
+func (c *arm64Ctx) lowerARM64SVESelect(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZSEL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 ZSEL expects Zm.T, Zn.T, Pv, Zd.T: %q", ins.Raw)
+	}
+	falseValue, falseBits, falseOK := arm64ParseSVEZElementReg(ins.Args[0])
+	trueValue, trueBits, trueOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicate(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !falseOK || !trueOK || !predicateOK || !destinationOK || falseBits != trueBits || trueBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 ZSEL operands must share one element width and use a bare P0..P15 predicate: %q", ins.Raw)
+	}
+	return true, false, c.lowerRawSVESelect(arm64RawSVESelect{
+		elementBits: falseBits,
+		falseValue:  falseValue,
+		trueValue:   trueValue,
+		predicate:   predicate,
+		destination: destination,
+	})
+}
+
+func (c *arm64Ctx) lowerRawSVESelect(form arm64RawSVESelect) error {
+	falseValue, vectorType, err := c.loadZRegElements(form.falseValue, form.elementBits)
+	if err != nil {
+		return err
+	}
+	trueValue, _, err := c.loadZRegElements(form.trueValue, form.elementBits)
+	if err != nil {
+		return err
+	}
+	predicate, predicateType, err := c.loadPRegElements(form.predicate, form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %s, %s %s\n", result, predicateType, predicate, vectorType, trueValue, vectorType, falseValue)
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_select_test.go b/arm64_lower_sve_select_test.go
new file mode 100644
index 000000000..f946a2eb2
--- /dev/null
+++ b/arm64_lower_sve_select_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVESelect(elementBits, falseValue, trueValue, predicate, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x0520c000 | size<<22 | uint32(falseValue)<<16 | uint32(trueValue)<<5 | uint32(predicate)<<10 | uint32(destination)
+}
+
+func TestTranslateARM64SVESelectCompleteGo127Form(t *testing.T) {
+	const named = `
+TEXT sveselnamed(SB),$0-0
+	ZSEL Z31.B, Z30.B, P0, Z29.B
+	ZSEL Z28.H, Z27.H, P5, Z26.H
+	ZSEL Z25.S, Z24.S, P10, Z23.S
+	ZSEL Z22.D, Z21.D, P15, Z20.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT sveselraw(SB),$0-0\n")
+	for i, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVESelect(elementBits, i, i+4, i*5, i+8))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svesel" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve"`, " select <vscale x 16 x i1>", " select <vscale x 8 x i1>", " select <vscale x 4 x i1>", " select <vscale x 2 x i1>"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE SEL lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-select.ll", "arm64-sve-select.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVESelectDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for falseValue := 0; falseValue < 32; falseValue++ {
+			for trueValue := 0; trueValue < 32; trueValue++ {
+				for predicate := 0; predicate < 16; predicate++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVESelect(elementBits, falseValue, trueValue, predicate, destination)
+						got, ok := decodeARM64RawSVESelect(word)
+						if !ok || got.elementBits != elementBits || got.falseValue != falseValue || got.trueValue != trueValue || got.predicate != predicate || got.destination != destination {
+							t.Fatalf("decoded SVE SEL %#08x as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 4*32*32*16*32 {
+		t.Fatalf("covered %d SVE SEL encodings, want %d", count, 4*32*32*16*32)
+	}
+}
+
+func TestARM64SVESelectRejectsAdjacentAndPredicateSuffix(t *testing.T) {
+	for _, word := range []uint32{0x05208000, 0x0520a000, 0x05204000} {
+		if _, ok := decodeARM64RawSVESelect(word); ok {
+			t.Fatalf("SVE SEL decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsvesel(SB),$0-0
+	ZSEL Z1.S, Z2.S, P3.M, Z4.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesel": {Name: "badsvesel", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted SVE SEL merge predicate syntax")
+	}
+}
diff --git a/arm64_lower_sve_shift_extra.go b/arm64_lower_sve_shift_extra.go
new file mode 100644
index 000000000..ad93df33a
--- /dev/null
+++ b/arm64_lower_sve_shift_extra.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEImmediateShiftSpec struct {
+	intrinsic  string
+	predicated bool
+	minimum    int64
+	sve2       bool
+	rawBase    uint32
+}
+
+var arm64SVEImmediateShiftSpecs = map[Op]arm64SVEImmediateShiftSpec{
+	"ZASRD":   {intrinsic: "asrd", predicated: true, minimum: 1, rawBase: 0x04048000},
+	"ZSLI":    {intrinsic: "sli", sve2: true, rawBase: 0x4500f400},
+	"ZSQSHLU": {intrinsic: "sqshlu", predicated: true, sve2: true, rawBase: 0x040f8000},
+	"ZSRI":    {intrinsic: "sri", minimum: 1, sve2: true, rawBase: 0x4500f000},
+	"ZSRSHR":  {intrinsic: "srshr", predicated: true, minimum: 1, sve2: true, rawBase: 0x040c8000},
+	"ZSRSRA":  {intrinsic: "srsra", minimum: 1, sve2: true, rawBase: 0x4500e800},
+	"ZSSRA":   {intrinsic: "ssra", minimum: 1, sve2: true, rawBase: 0x4500e000},
+	"ZURSHR":  {intrinsic: "urshr", predicated: true, minimum: 1, sve2: true, rawBase: 0x040d8000},
+	"ZURSRA":  {intrinsic: "ursra", minimum: 1, sve2: true, rawBase: 0x4500ec00},
+	"ZUSRA":   {intrinsic: "usra", minimum: 1, sve2: true, rawBase: 0x4500e400},
+}
+
+type arm64SVEReverseShiftSpec struct {
+	intrinsic string
+	rawBase   uint32
+}
+
+var arm64SVEReverseShiftIntrinsics = map[Op]arm64SVEReverseShiftSpec{
+	"ZASRR": {intrinsic: "asr", rawBase: 0x04148000},
+	"ZLSLR": {intrinsic: "lsl", rawBase: 0x04178000},
+	"ZLSRR": {intrinsic: "lsr", rawBase: 0x04158000},
+}
+
+func (c *arm64Ctx) lowerARM64SVEExtraShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if spec, ok := arm64SVEImmediateShiftSpecs[op]; ok {
+		return c.lowerARM64SVEExtraImmediateShift(op, ins, spec)
+	}
+	spec, ok := arm64SVEReverseShiftIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zm.T, Zdn.T, Pg/M, Zdn.T without a suffix: %q", op, ins.Raw)
+	}
+	data, dataBits, dataOK := arm64ParseSVEZElementReg(ins.Args[0])
+	oldDestination, oldBits, oldOK := arm64ParseSVEZElementReg(ins.Args[1])
+	predicate, predicateOK := arm64ParseSVEPredicateMerge(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !dataOK || !oldOK || !predicateOK || !destinationOK || dataBits != oldBits || oldBits != destinationBits || oldDestination != destination {
+		return true, false, fmt.Errorf("arm64 %s requires matching vectors and a repeated destructive destination: %q", op, ins.Raw)
+	}
+	dataValue, vectorType, err := c.loadZRegElements(data, dataBits)
+	if err != nil {
+		return true, false, err
+	}
+	oldValue, _, err := c.loadZRegElements(destination, dataBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, dataBits)
+	if err != nil {
+		return true, false, err
+	}
+	allTrue, _, err := c.allTruePRegElements(dataBits)
+	if err != nil {
+		return true, false, err
+	}
+	_, lanes, _ := arm64SVEVectorType(dataBits)
+	active := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", active, vectorType, spec.intrinsic, lanes, dataBits, predicateType, allTrue, vectorType, dataValue, vectorType, oldValue)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select %s %s, %s %%%s, %s %s\n", result, predicateType, predicateValue, vectorType, active, vectorType, oldValue)
+	return true, false, c.storeZRegElements(destination, dataBits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerARM64SVEExtraImmediateShift(op Op, ins Instr, spec arm64SVEImmediateShiftSpec) (ok bool, terminated bool, err error) {
+	wantArgs := 3
+	if spec.predicated {
+		wantArgs = 4
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != wantArgs || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects its Go 1.27 immediate form without a suffix: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destinationIndex := wantArgs - 1
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[destinationIndex])
+	shift := ins.Args[0].Imm
+	if !sourceOK || !destinationOK || sourceBits != destinationBits || shift < spec.minimum || shift >= int64(sourceBits) {
+		return true, false, fmt.Errorf("arm64 %s immediate is outside Go 1.27's element-width range: %q", op, ins.Raw)
+	}
+	predicate := 0
+	if spec.predicated {
+		var predicateOK bool
+		predicate, predicateOK = arm64ParseSVEPredicateMerge(ins.Args[2])
+		if !predicateOK || source != destination {
+			return true, false, fmt.Errorf("arm64 %s requires a repeated destructive destination and Pg/M: %q", op, ins.Raw)
+		}
+	}
+	return true, false, c.lowerARM64SVEExtraImmediateShiftForm(spec, sourceBits, source, destination, predicate, shift)
+}
+
+func (c *arm64Ctx) lowerARM64SVEExtraImmediateShiftForm(spec arm64SVEImmediateShiftSpec, sourceBits, source, destination, predicate int, shift int64) error {
+	var predicateValue, predicateType string
+	var err error
+	if spec.predicated {
+		predicateValue, predicateType, err = c.loadPRegElements(predicate, sourceBits)
+		if err != nil {
+			return err
+		}
+	}
+	sourceValue, vectorType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, _ := arm64SVEVectorType(sourceBits)
+	result := c.newTmp()
+	if spec.predicated {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, spec.intrinsic, lanes, sourceBits, predicateType, predicateValue, vectorType, sourceValue, shift)
+	} else {
+		oldDestination, _, err := c.loadZRegElements(destination, sourceBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, spec.intrinsic, lanes, sourceBits, vectorType, oldDestination, vectorType, sourceValue, shift)
+	}
+	return c.storeZRegElements(destination, sourceBits, "%"+result)
+}
diff --git a/arm64_lower_sve_shift_extra_test.go b/arm64_lower_sve_shift_extra_test.go
new file mode 100644
index 000000000..20d2cabf0
--- /dev/null
+++ b/arm64_lower_sve_shift_extra_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEExtraShiftCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveextrashiftbase(SB),$0-0\n")
+	for _, suffix := range []string{"B", "H", "S", "D"} {
+		bits := map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[suffix]
+		fmt.Fprintf(&source, "\tZASRD $%d, Z1.%s, P0.M, Z1.%s\n", bits-1, suffix, suffix)
+		for _, op := range []string{"ZASRR", "ZLSLR", "ZLSRR"} {
+			fmt.Fprintf(&source, "\t%s Z2.%s, Z3.%s, P1.M, Z3.%s\n", op, suffix, suffix, suffix)
+		}
+	}
+	source.WriteString("\tRET\nTEXT sveextrashiftsve2(SB),$0-0\n")
+	for _, suffix := range []string{"B", "H", "S", "D"} {
+		bits := map[string]int{"B": 8, "H": 16, "S": 32, "D": 64}[suffix]
+		for _, op := range []string{"ZSLI", "ZSQSHLU"} {
+			if op == "ZSQSHLU" {
+				fmt.Fprintf(&source, "\t%s $%d, Z4.%s, P2.M, Z4.%s\n", op, bits-1, suffix, suffix)
+			} else {
+				fmt.Fprintf(&source, "\t%s $%d, Z4.%s, Z5.%s\n", op, bits-1, suffix, suffix)
+			}
+		}
+		for _, op := range []string{"ZSRI", "ZSRSRA", "ZSSRA", "ZURSRA", "ZUSRA"} {
+			fmt.Fprintf(&source, "\t%s $%d, Z6.%s, Z7.%s\n", op, bits-1, suffix, suffix)
+		}
+		for _, op := range []string{"ZSRSHR", "ZURSHR"} {
+			fmt.Fprintf(&source, "\t%s $%d, Z8.%s, P3.M, Z8.%s\n", op, bits-1, suffix, suffix)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"sveextrashiftbase": {Name: "sveextrashiftbase", Ret: Void},
+		"sveextrashiftsve2": {Name: "sveextrashiftsve2", Ret: Void},
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, `"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.asrd.", "@llvm.aarch64.sve.sli.", "@llvm.aarch64.sve.ursra."} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE extra shift lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-extra-shift.ll", "arm64-sve-extra-shift.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEExtraShiftRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZASRD $0, Z1.B, P0.M, Z1.B",
+		"ZASRD $8, Z1.B, P0.M, Z1.B",
+		"ZASRD $9, Z1.B, P0.M, Z1.B",
+		"ZASRR Z1.B, Z2.B, P0.M, Z3.B",
+		"ZSLI $8, Z1.B, Z2.B",
+		"ZSRI $0, Z1.B, Z2.B",
+		"ZSRI $8, Z1.B, Z2.B",
+		"ZURSHR $64, Z1.D, P0.M, Z1.D",
+		"ZSQSHLU $8, Z1.B, P0.M, Z1.B",
+		"ZSRSHR $1, Z1.H, P0.M, Z2.H",
+		"ZURSRA $1, Z1.H, Z2.S",
+		"ZUSRA.Z $1, Z1.B, Z2.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveextrashift(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveextrashift": {Name: "badsveextrashift", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE shift forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_shift_family_test.go b/arm64_lower_sve_shift_family_test.go
new file mode 100644
index 000000000..f38173ad1
--- /dev/null
+++ b/arm64_lower_sve_shift_family_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEShiftNamedForms(op string) string {
+	var source strings.Builder
+	function := "sve" + strings.ToLower(op) + "forms"
+	source.WriteString("TEXT " + function + "(SB),$0-0\n")
+	for index, width := range []string{"B", "H", "S"} {
+		predicate := string(rune('0' + index))
+		source.WriteString("\t" + op + " Z1.D, Z2." + width + ", P" + predicate + ".M, Z2." + width + "\n")
+		source.WriteString("\t" + op + " Z3.D, Z4." + width + ", Z5." + width + "\n")
+	}
+	for index, width := range []string{"B", "H", "S", "D"} {
+		predicate := string(rune('4' + index))
+		maximum := map[string]string{"B": "7", "H": "15", "S": "31", "D": "63"}[width]
+		minimum := "1"
+		if op == "ZLSL" {
+			minimum = "0"
+		}
+		source.WriteString("\t" + op + " Z6." + width + ", Z7." + width + ", P" + predicate + ".M, Z7." + width + "\n")
+		source.WriteString("\t" + op + " $" + maximum + ", Z8." + width + ", P" + predicate + ".M, Z8." + width + "\n")
+		source.WriteString("\t" + op + " $" + minimum + ", Z9." + width + ", Z10." + width + "\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEShiftCompleteASRLSLGo127Forms(t *testing.T) {
+	for _, op := range []string{"ZASR", "ZLSL"} {
+		t.Run(op, func(t *testing.T) {
+			source := arm64SVEShiftNamedForms(op)
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sve" + strings.ToLower(op) + "forms"
+			intrinsic := strings.ToLower(strings.TrimPrefix(op, "Z"))
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve"`, "@llvm.aarch64.sve." + intrinsic + ".nxv", "@llvm.aarch64.sve." + intrinsic + ".wide.nxv", "@llvm.aarch64.sve.ptrue"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("%s SVE shift lowering for %s omitted %q:\n%s", triple, op, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-shift.ll", "arm64-sve-shift.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEShiftRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZASR $0, Z1.S, Z2.S",
+		"ZLSL $32, Z1.S, Z2.S",
+		"ZASR Z1.H, Z2.H, Z3.H",
+		"ZLSL Z1.S, Z2.H, P0.M, Z2.H",
+		"ZASR $1, Z1.S, P0.M, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveshift(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveshift": {Name: "badsveshift", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE shift forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_shift_long.go b/arm64_lower_sve_shift_long.go
new file mode 100644
index 000000000..c4c50ad5a
--- /dev/null
+++ b/arm64_lower_sve_shift_long.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEShiftLongIntrinsics = map[Op]string{
+	"ZSSHLLB": "sshllb",
+	"ZSSHLLT": "sshllt",
+	"ZUSHLLB": "ushllb",
+	"ZUSHLLT": "ushllt",
+}
+
+func (c *arm64Ctx) lowerARM64SVEShiftLong(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEShiftLongIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects $shift, Zn.B|H|S, Zd.H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	shift := ins.Args[0].Imm
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !destinationOK || sourceBits == 64 || destinationBits != sourceBits*2 || shift < 0 || shift >= int64(sourceBits) {
+		return true, false, fmt.Errorf("arm64 %s requires B-to-H, H-to-S, or S-to-D operands and shift $0..$sourceBits-1: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, destinationLanes, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, i32 %d)\n", result, destinationType, intrinsic, destinationLanes, destinationBits, sourceType, sourceValue, shift)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_shift_long_test.go b/arm64_lower_sve_shift_long_test.go
new file mode 100644
index 000000000..92b4730cf
--- /dev/null
+++ b/arm64_lower_sve_shift_long_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEShiftLongCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveshiftlong(SB),$0-0\n")
+	widths := []struct {
+		source      string
+		destination string
+		maxShift    int
+	}{
+		{source: "B", destination: "H", maxShift: 7},
+		{source: "H", destination: "S", maxShift: 15},
+		{source: "S", destination: "D", maxShift: 31},
+	}
+	for opIndex, op := range []string{"ZSSHLLB", "ZSSHLLT", "ZUSHLLB", "ZUSHLLT"} {
+		for widthIndex, width := range widths {
+			for boundaryIndex, shift := range []int{0, width.maxShift} {
+				reg := (opIndex*6 + widthIndex*2 + boundaryIndex) % 32
+				fmt.Fprintf(&source, "\t%s $%d, Z%d.%s, Z%d.%s\n", op, shift, reg, width.source, (reg+1)%32, width.destination)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveshiftlong": {Name: "sveshiftlong", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.sshllb.nxv8i16",
+				"@llvm.aarch64.sve.sshllt.nxv4i32",
+				"@llvm.aarch64.sve.ushllb.nxv2i64",
+				"@llvm.aarch64.sve.ushllt.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE shift-long lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-shift-long.ll", "arm64-sve-shift-long.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEShiftLongRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSSHLLB $8, Z1.B, Z2.H",
+		"ZSSHLLT $16, Z1.H, Z2.S",
+		"ZUSHLLB $32, Z1.S, Z2.D",
+		"ZUSHLLT $-1, Z1.B, Z2.H",
+		"ZSSHLLB $0, Z1.B, Z2.S",
+		"ZUSHLLT $0, Z1.D, Z2.D",
+		"ZSSHLLB.Z $0, Z1.B, Z2.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveshiftlong(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveshiftlong": {Name: "badsveshiftlong", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE shift-long forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_shift_narrow.go b/arm64_lower_sve_shift_narrow.go
new file mode 100644
index 000000000..e3706addb
--- /dev/null
+++ b/arm64_lower_sve_shift_narrow.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEShiftNarrowSpec struct {
+	intrinsic string
+	top       bool
+}
+
+var arm64SVEShiftNarrowSpecs = map[Op]arm64SVEShiftNarrowSpec{
+	"ZSHRNB":  {intrinsic: "shrnb"},
+	"ZSHRNT":  {intrinsic: "shrnt", top: true},
+	"ZRSHRNB": {intrinsic: "rshrnb"},
+	"ZRSHRNT": {intrinsic: "rshrnt", top: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEShiftNarrow(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEShiftNarrowSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects $shift, Zn.H|S|D, Zd.B|H|S without a suffix: %q", op, ins.Raw)
+	}
+	shift := ins.Args[0].Imm
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !sourceOK || !destinationOK || (sourceBits != 16 && sourceBits != 32 && sourceBits != 64) || destinationBits*2 != sourceBits || shift < 1 || shift > int64(destinationBits) {
+		return true, false, fmt.Errorf("arm64 %s requires matching H-to-B, S-to-H, or D-to-S operands and shift $1..$destinationBits: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, _, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	args := fmt.Sprintf("%s %s, i32 %d", sourceType, sourceValue, shift)
+	if spec.top {
+		merged, _, err := c.loadZRegElements(destination, destinationBits)
+		if err != nil {
+			return true, false, err
+		}
+		args = fmt.Sprintf("%s %s, %s", destinationType, merged, args)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s)\n", result, destinationType, spec.intrinsic, 128/sourceBits, sourceBits, args)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_shift_narrow_test.go b/arm64_lower_sve_shift_narrow_test.go
new file mode 100644
index 000000000..fd5058bed
--- /dev/null
+++ b/arm64_lower_sve_shift_narrow_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEShiftNarrowCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveshiftnarrowforms(SB),$0-0\n")
+	for _, op := range []string{"ZSHRNB", "ZSHRNT", "ZRSHRNB", "ZRSHRNT"} {
+		for _, form := range []struct {
+			source, destination string
+			max                 int
+		}{{"H", "B", 8}, {"S", "H", 16}, {"D", "S", 32}} {
+			for _, shift := range []int{1, form.max} {
+				fmt.Fprintf(&source, "\t%s $%d, Z1.%s, Z2.%s\n", op, shift, form.source, form.destination)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEShiftNarrowCompleteGo127Family(t *testing.T) {
+	source := arm64SVEShiftNarrowCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveshiftnarrowforms": {Name: "sveshiftnarrowforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.shrnb.nxv8i16",
+				"@llvm.aarch64.sve.shrnt.nxv4i32",
+				"@llvm.aarch64.sve.rshrnb.nxv2i64",
+				"@llvm.aarch64.sve.rshrnt.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE shift-narrow lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-shift-narrow.ll", "arm64-sve-shift-narrow.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEShiftNarrowRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSHRNB $0, Z1.H, Z2.B",
+		"ZSHRNB $1, Z1.S, Z2.B",
+		"ZRSHRNT $1, Z1.Q, Z2.D",
+		"ZSHRNB $1, Z1.H",
+		"ZRSHRNT.Z $1, Z1.D, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "$", "imm").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveshiftnarrow(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveshiftnarrow": {Name: "badsveshiftnarrow", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE shift-narrow forms", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64SVEShiftNarrowRejectsGoAcceptedUnencodableShifts(t *testing.T) {
+	// Go 1.27's shared tsz operand accepts shifts up to sourceBits-1 here,
+	// although the architecture and LLVM narrowing intrinsics allow only
+	// $1..$destinationBits. Reject these before they can crash LLVM selection.
+	for _, instruction := range []string{
+		"ZSHRNT $9, Z1.H, Z2.B",
+		"ZRSHRNB $17, Z1.S, Z2.H",
+		"ZRSHRNT $33, Z1.D, Z2.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_", "$", "imm").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveshiftnarrowrange(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveshiftnarrowrange": {Name: "badsveshiftnarrowrange", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted Go-assembler form %q that LLVM 22 cannot encode", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_splice.go b/arm64_lower_sve_splice.go
new file mode 100644
index 000000000..17dae4353
--- /dev/null
+++ b/arm64_lower_sve_splice.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func decodeARM64RawSVESplice(word uint32) (Instr, bool) {
+	base := word & 0xff3fe000
+	if base != 0x052c8000 && base != 0x052d8000 {
+		return Instr{}, false
+	}
+	width := "BHSD"[word>>22&3]
+	vector := func(index uint32) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", index&31, width))}
+	}
+	destination, source := vector(word), vector(word>>5)
+	predicate := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", word>>10&7))}
+	args := []Operand{source, destination, predicate, destination}
+	if base == 0x052d8000 {
+		list := Operand{Kind: OpRegList, RegList: []Reg{source.Reg, vector((word >> 5 & 31) + 1).Reg}}
+		args = []Operand{list, predicate, destination}
+	}
+	return Instr{Op: "ZSPLICE", Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func (c *arm64Ctx) lowerARM64RawSVESplice(ins Instr) error {
+	var first, second, predicate, destination, width int
+	if len(ins.Args) == 3 {
+		// The architecture wraps Z31's second register to Z0, unlike the
+		// named Go grammar. Both paths share the same semantic form lowerer.
+		first, width, _ = arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[0].RegList[0]})
+		second = (first + 1) % 32
+		predicate, _ = arm64ParseSVEPredicateBare(ins.Args[1], 7)
+		destination, _, _ = arm64ParseSVEZElementReg(ins.Args[2])
+	} else {
+		second, width, _ = arm64ParseSVEZElementReg(ins.Args[0])
+		destination, _, _ = arm64ParseSVEZElementReg(ins.Args[1])
+		first = destination
+		predicate, _ = arm64ParseSVEPredicateBare(ins.Args[2], 7)
+	}
+	return c.lowerARM64SVESpliceForm(first, second, predicate, destination, width)
+}
+
+func (c *arm64Ctx) lowerARM64SVESplice(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZSPLICE" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) < 3 || len(ins.Args) > 4 {
+		return true, false, fmt.Errorf("arm64 ZSPLICE expects one Go 1.27 vector form without a suffix: %q", ins.Raw)
+	}
+
+	var first, second, predicate, destination, elementBits int
+	if len(ins.Args) == 4 {
+		var firstOK, secondOK, predicateOK, destinationOK bool
+		second, elementBits, secondOK = arm64ParseSVEZElementReg(ins.Args[0])
+		first, _, firstOK = arm64ParseSVEZElementReg(ins.Args[1])
+		predicate, predicateOK = arm64ParseSVEPredicateBare(ins.Args[2], 15)
+		destination, _, destinationOK = arm64ParseSVEZElementReg(ins.Args[3])
+		_, firstBits, _ := arm64ParseSVEZElementReg(ins.Args[1])
+		_, destinationBits, _ := arm64ParseSVEZElementReg(ins.Args[3])
+		if !firstOK || !secondOK || !predicateOK || !destinationOK ||
+			firstBits != elementBits || destinationBits != elementBits || first != destination {
+			return true, false, fmt.Errorf("arm64 ZSPLICE destructive form requires Zm.T, Zdn.T, P0..P15, Zdn.T with one B/H/S/D width: %q", ins.Raw)
+		}
+	} else {
+		if ins.Args[0].Kind != OpRegList || len(ins.Args[0].RegList) != 2 {
+			return true, false, fmt.Errorf("arm64 ZSPLICE list form requires exactly two consecutive vectors: %q", ins.Raw)
+		}
+		var firstOK, secondOK, predicateOK, destinationOK bool
+		first, elementBits, firstOK = arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[0].RegList[0]})
+		second, _, secondOK = arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[0].RegList[1]})
+		predicate, predicateOK = arm64ParseSVEPredicateBare(ins.Args[1], 15)
+		destination, _, destinationOK = arm64ParseSVEZElementReg(ins.Args[2])
+		_, secondBits, _ := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[0].RegList[1]})
+		_, destinationBits, _ := arm64ParseSVEZElementReg(ins.Args[2])
+		if !firstOK || !secondOK || !predicateOK || !destinationOK || first == 31 || second != first+1 ||
+			secondBits != elementBits || destinationBits != elementBits {
+			return true, false, fmt.Errorf("arm64 ZSPLICE list form requires [Zn.T, Z(n+1).T], P0..P15, Zd.T with one B/H/S/D width: %q", ins.Raw)
+		}
+	}
+
+	return true, false, c.lowerARM64SVESpliceForm(first, second, predicate, destination, elementBits)
+}
+
+func (c *arm64Ctx) lowerARM64SVESpliceForm(first, second, predicate, destination, elementBits int) error {
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, elementBits)
+	if err != nil {
+		return err
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, elementBits)
+	if err != nil {
+		return err
+	}
+	secondValue, _, err := c.loadZRegElements(second, elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.splice.nxv%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, lanes, elementBits, predicateType, predicateValue, vectorType, firstValue, vectorType, secondValue)
+	return c.storeZRegElements(destination, elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_splice_test.go b/arm64_lower_sve_splice_test.go
new file mode 100644
index 000000000..0c0092439
--- /dev/null
+++ b/arm64_lower_sve_splice_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVESpliceCompleteGo127Family(t *testing.T) {
+	source := "TEXT svespliceforms(SB),$0-0\n" +
+		"\tZSPLICE Z2.B, Z1.B, P0, Z1.B\n" +
+		"\tZSPLICE Z4.H, Z3.H, P1, Z3.H\n" +
+		"\tZSPLICE Z6.S, Z5.S, P2, Z5.S\n" +
+		"\tZSPLICE Z8.D, Z7.D, P15, Z7.D\n" +
+		"\tZSPLICE [Z9.B, Z10.B], P0, Z11.B\n" +
+		"\tZSPLICE [Z12.H, Z13.H], P1, Z14.H\n" +
+		"\tZSPLICE [Z15.S, Z16.S], P2, Z17.S\n" +
+		"\tZSPLICE [Z30.D, Z31.D], P7, Z18.D\n" +
+		"\tRET\n"
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svespliceforms": {Name: "svespliceforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"\"target-features\"=\"+sve\"",
+				"@llvm.aarch64.sve.splice.nxv16i8",
+				"@llvm.aarch64.sve.splice.nxv8i16",
+				"@llvm.aarch64.sve.splice.nxv4i32",
+				"@llvm.aarch64.sve.splice.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE SPLICE lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-splice.ll", "arm64-sve-splice.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVESpliceRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSPLICE Z2.B, Z1.B, P0, Z3.B",
+		"ZSPLICE Z2.B, Z1.H, P0, Z1.H",
+		"ZSPLICE Z2.B, Z1.B, P16, Z1.B",
+		"ZSPLICE Z2.B, Z1.B, P0.M, Z1.B",
+		"ZSPLICE [Z1.B], P0, Z3.B",
+		"ZSPLICE [Z1.B, Z3.B], P0, Z4.B",
+		"ZSPLICE [Z31.B, Z0.B], P0, Z4.B",
+		"ZSPLICE [Z1.B, Z2.H], P0, Z4.B",
+		"ZSPLICE [Z1.B, Z2.B], P0, Z4.H",
+		"ZSPLICE.Z Z2.B, Z1.B, P0, Z1.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvesplice(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvesplice": {Name: "badsvesplice", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE SPLICE forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_structured_memory.go b/arm64_lower_sve_structured_memory.go
new file mode 100644
index 000000000..c98743414
--- /dev/null
+++ b/arm64_lower_sve_structured_memory.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEStructuredMemorySpec struct {
+	load        bool
+	vectorCount int
+	memoryBits  int
+	q           bool
+}
+
+// arm64SVEStructuredMemorySpecs covers every Go 1.27 LD2/3/4 and ST2/3/4
+// structured SVE spelling, including the SVE2.1 Q-granule forms.
+var arm64SVEStructuredMemorySpecs = map[Op]arm64SVEStructuredMemorySpec{
+	"ZLD2B": {load: true, vectorCount: 2, memoryBits: 8},
+	"ZLD2H": {load: true, vectorCount: 2, memoryBits: 16},
+	"ZLD2W": {load: true, vectorCount: 2, memoryBits: 32},
+	"ZLD2D": {load: true, vectorCount: 2, memoryBits: 64},
+	"ZLD2Q": {load: true, vectorCount: 2, memoryBits: 128, q: true},
+	"ZLD3B": {load: true, vectorCount: 3, memoryBits: 8},
+	"ZLD3H": {load: true, vectorCount: 3, memoryBits: 16},
+	"ZLD3W": {load: true, vectorCount: 3, memoryBits: 32},
+	"ZLD3D": {load: true, vectorCount: 3, memoryBits: 64},
+	"ZLD3Q": {load: true, vectorCount: 3, memoryBits: 128, q: true},
+	"ZLD4B": {load: true, vectorCount: 4, memoryBits: 8},
+	"ZLD4H": {load: true, vectorCount: 4, memoryBits: 16},
+	"ZLD4W": {load: true, vectorCount: 4, memoryBits: 32},
+	"ZLD4D": {load: true, vectorCount: 4, memoryBits: 64},
+	"ZLD4Q": {load: true, vectorCount: 4, memoryBits: 128, q: true},
+	"ZST2B": {vectorCount: 2, memoryBits: 8},
+	"ZST2H": {vectorCount: 2, memoryBits: 16},
+	"ZST2W": {vectorCount: 2, memoryBits: 32},
+	"ZST2D": {vectorCount: 2, memoryBits: 64},
+	"ZST2Q": {vectorCount: 2, memoryBits: 128, q: true},
+	"ZST3B": {vectorCount: 3, memoryBits: 8},
+	"ZST3H": {vectorCount: 3, memoryBits: 16},
+	"ZST3W": {vectorCount: 3, memoryBits: 32},
+	"ZST3D": {vectorCount: 3, memoryBits: 64},
+	"ZST3Q": {vectorCount: 3, memoryBits: 128, q: true},
+	"ZST4B": {vectorCount: 4, memoryBits: 8},
+	"ZST4H": {vectorCount: 4, memoryBits: 16},
+	"ZST4W": {vectorCount: 4, memoryBits: 32},
+	"ZST4D": {vectorCount: 4, memoryBits: 64},
+	"ZST4Q": {vectorCount: 4, memoryBits: 128, q: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEStructuredMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEStructuredMemorySpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects its three-operand Go 1.27 form: %q", op, ins.Raw)
+	}
+	if spec.load {
+		return c.lowerARM64SVEStructuredLoad(op, spec, ins)
+	}
+	return c.lowerARM64SVEStructuredStore(op, spec, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEStructuredLoad(op Op, spec arm64SVEStructuredMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpMem || ins.Args[2].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 %s requires memory, Pn.Z, and vector-list operands: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+	vectors, elementBits, vectorsOK := arm64ParseSVEStructuredVectorList(ins.Args[2], spec.vectorCount)
+	if !predicateOK || !vectorsOK || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s requires P0..P7.Z and %d consecutive natural-width destination vectors: %q", op, spec.vectorCount, ins.Raw)
+	}
+	address, err := c.arm64SVEStructuredAddress(ins.Args[0].Mem, spec)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	valueBits := spec.memoryBits
+	if spec.q {
+		valueBits = 64
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, valueBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(valueBits)
+	if err != nil {
+		return true, false, err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	aggregateType := arm64SVEAggregateType(vectorType, spec.vectorCount)
+	result := c.newTmp()
+	q := ""
+	if spec.q {
+		q = "q"
+	}
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ld%d%s.sret.nxv%di%d(%s %s, ptr %%%s)\n",
+		result, aggregateType, spec.vectorCount, q, 128/valueBits, valueBits, predicateType, predicateValue, pointer)
+	for i, vector := range vectors {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %%%s, %d\n", value, aggregateType, result, i)
+		if err := c.storeZRegElements(vector, valueBits, "%"+value); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEStructuredStore(op Op, spec arm64SVEStructuredMemorySpec, ins Instr) (ok bool, terminated bool, err error) {
+	if ins.Args[0].Kind != OpRegList || ins.Args[2].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s requires vector-list, Pn, and memory operands: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	vectors, elementBits, vectorsOK := arm64ParseSVEStructuredVectorList(ins.Args[0], spec.vectorCount)
+	if !predicateOK || !vectorsOK || elementBits != spec.memoryBits {
+		return true, false, fmt.Errorf("arm64 %s requires %d consecutive natural-width source vectors and P0..P7: %q", op, spec.vectorCount, ins.Raw)
+	}
+	address, err := c.arm64SVEStructuredAddress(ins.Args[2].Mem, spec)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	valueBits := spec.memoryBits
+	if spec.q {
+		valueBits = 64
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, valueBits)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType, _, err := arm64SVEVectorType(valueBits)
+	if err != nil {
+		return true, false, err
+	}
+	values := make([]string, len(vectors))
+	for i, vector := range vectors {
+		value, _, err := c.loadZRegElements(vector, valueBits)
+		if err != nil {
+			return true, false, err
+		}
+		values[i] = fmt.Sprintf("%s %s", vectorType, value)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	q := ""
+	if spec.q {
+		q = "q"
+	}
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.st%d%s.nxv%di%d(%s, %s %s, ptr %%%s)\n",
+		spec.vectorCount, q, 128/valueBits, valueBits, strings.Join(values, ", "), predicateType, predicateValue, pointer)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) arm64SVEStructuredAddress(memory MemRef, spec arm64SVEStructuredMemorySpec) (string, error) {
+	if memory.Index != "" {
+		return c.arm64SVERegisterOffsetAddress(memory, int64(spec.memoryBits/8))
+	}
+	return c.arm64SVENonTemporalContiguousAddress(memory, spec.memoryBits, spec.vectorCount)
+}
+
+func arm64ParseSVEStructuredVectorList(operand Operand, count int) (vectors []int, elementBits int, ok bool) {
+	if operand.Kind != OpRegList || len(operand.RegList) != count {
+		return nil, 0, false
+	}
+	vectors = make([]int, len(operand.RegList))
+	for i, register := range operand.RegList {
+		vector, bits, valid := arm64ParseSVEOrdinaryZReg(register)
+		if !valid || i > 0 && (bits != elementBits || vector != (vectors[i-1]+1)%32) {
+			return nil, 0, false
+		}
+		vectors[i] = vector
+		elementBits = bits
+	}
+	return vectors, elementBits, true
+}
diff --git a/arm64_lower_sve_structured_memory_test.go b/arm64_lower_sve_structured_memory_test.go
new file mode 100644
index 000000000..c95b550e5
--- /dev/null
+++ b/arm64_lower_sve_structured_memory_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEStructuredMemoryCompleteGo127Forms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svestructuredmemoryforms(SB),$0-0\n")
+	for _, count := range []int{2, 3, 4} {
+		for _, width := range []struct {
+			name        string
+			arrangement string
+			shift       int
+		}{
+			{name: "B", arrangement: "B"},
+			{name: "H", arrangement: "H", shift: 1},
+			{name: "W", arrangement: "S", shift: 2},
+			{name: "D", arrangement: "D", shift: 3},
+			{name: "Q", arrangement: "Q", shift: 4},
+		} {
+			registers := make([]string, count)
+			for i := range registers {
+				registers[i] = fmt.Sprintf("Z%d.%s", 12+i, width.arrangement)
+			}
+			list := "[" + strings.Join(registers, ", ") + "]"
+			index := "R6"
+			if width.shift != 0 {
+				index = fmt.Sprintf("R6<<%d", width.shift)
+			}
+			load := fmt.Sprintf("ZLD%d%s", count, width.name)
+			store := fmt.Sprintf("ZST%d%s", count, width.name)
+			fmt.Fprintf(&source, "\t%s (%s)(R14), P4.Z, %s\n", load, index, list)
+			fmt.Fprintf(&source, "\t%s (-VL*%d)(R14), P4.Z, %s\n", load, count, list)
+			fmt.Fprintf(&source, "\t%s %s, P4, (%s)(R14)\n", store, list, index)
+			fmt.Fprintf(&source, "\t%s %s, P4, (VL*%d)(R14)\n", store, list, count)
+		}
+	}
+	// The hardware encoding wraps consecutive Z lists modulo 32.
+	source.WriteString("\tZLD2B (R6)(R14), P4.Z, [Z31.B, Z0.B]\n")
+	source.WriteString("\tZST3H [Z31.H, Z0.H, Z1.H], P4, (R6<<1)(R14)\n")
+	source.WriteString("\tZLD4D (-VL*4)(R14), P4.Z, [Z30.D, Z31.D, Z0.D, Z1.D]\n")
+	// Exercise every architectural MUL VL boundary, not only representative values.
+	source.WriteString("\tZLD2B (-VL*16)(R14), P4.Z, [Z12.B, Z13.B]\n")
+	source.WriteString("\tZST2B [Z12.B, Z13.B], P4, (VL*14)(R14)\n")
+	source.WriteString("\tZLD3B (-VL*24)(R14), P4.Z, [Z12.B, Z13.B, Z14.B]\n")
+	source.WriteString("\tZST3B [Z12.B, Z13.B, Z14.B], P4, (VL*21)(R14)\n")
+	source.WriteString("\tZLD4B (-VL*32)(R14), P4.Z, [Z12.B, Z13.B, Z14.B, Z15.B]\n")
+	source.WriteString("\tZST4B [Z12.B, Z13.B, Z14.B, Z15.B], P4, (VL*28)(R14)\n")
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEStructuredMemoryCompleteGo127Family(t *testing.T) {
+	source := arm64SVEStructuredMemoryCompleteGo127Forms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svestructuredmemoryforms": {Name: "svestructuredmemoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2p1"`,
+				"@llvm.aarch64.sve.ld2.sret.",
+				"@llvm.aarch64.sve.ld3.sret.",
+				"@llvm.aarch64.sve.ld4.sret.",
+				"@llvm.aarch64.sve.st2.",
+				"@llvm.aarch64.sve.st3.",
+				"@llvm.aarch64.sve.st4.",
+				"@llvm.aarch64.sve.ld2q.sret.",
+				"@llvm.aarch64.sve.ld3q.sret.",
+				"@llvm.aarch64.sve.ld4q.sret.",
+				"@llvm.aarch64.sve.st2q.",
+				"@llvm.aarch64.sve.st3q.",
+				"@llvm.aarch64.sve.st4q.",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE structured memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-structured-memory.ll", "arm64-sve-structured-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEStructuredMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLD2B (R6)(R14), P8.Z, [Z12.B, Z13.B]",
+		"ZLD2B (R6)(R14), P4, [Z12.B, Z13.B]",
+		"ZST2B [Z12.B, Z13.B], P4.Z, (R6)(R14)",
+		"ZLD2H (R6)(R14), P4.Z, [Z12.H, Z13.H]",
+		"ZLD3W (R6<<1)(R14), P4.Z, [Z12.S, Z13.S, Z14.S]",
+		"ZST4Q [Z12.Q, Z13.Q, Z14.Q, Z15.Q], P4, (R6<<3)(R14)",
+		"ZLD2B (R6)(R14), P4.Z, [Z12.B]",
+		"ZLD3B (R6)(R14), P4.Z, [Z12.B, Z14.B, Z15.B]",
+		"ZST4H [Z12.H, Z13.H, Z14.S, Z15.H], P4, (R6<<1)(R14)",
+		"ZLD2B (-VL*18)(R14), P4.Z, [Z12.B, Z13.B]",
+		"ZST2B [Z12.B, Z13.B], P4, (VL*16)(R14)",
+		"ZLD3B (-VL*27)(R14), P4.Z, [Z12.B, Z13.B, Z14.B]",
+		"ZST3B [Z12.B, Z13.B, Z14.B], P4, (VL*24)(R14)",
+		"ZLD4B (-VL*36)(R14), P4.Z, [Z12.B, Z13.B, Z14.B, Z15.B]",
+		"ZST4B [Z12.B, Z13.B, Z14.B, Z15.B], P4, (VL*32)(R14)",
+		"ZLD2B (VL*3)(R14), P4.Z, [Z12.B, Z13.B]",
+		"ZLD3B (VL*4)(R14), P4.Z, [Z12.B, Z13.B, Z14.B]",
+		"ZLD4B (VL*6)(R14), P4.Z, [Z12.B, Z13.B, Z14.B, Z15.B]",
+		"ZLD2B.Z (R6)(R14), P4.Z, [Z12.B, Z13.B]",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvestructuredmemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvestructuredmemory": {Name: "badsvestructuredmemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's structured memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_table.go b/arm64_lower_sve_table.go
new file mode 100644
index 000000000..05a40539a
--- /dev/null
+++ b/arm64_lower_sve_table.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawSVETable struct {
+	elementBits int
+	tableCount  int
+	index       int
+	firstTable  int
+	destination int
+}
+
+func decodeARM64RawSVETable(word uint32) (arm64RawSVETable, bool) {
+	tableCount := 0
+	switch word & 0xff20fc00 {
+	case 0x05203000:
+		tableCount = 1
+	case 0x05202800:
+		tableCount = 2
+	default:
+		return arm64RawSVETable{}, false
+	}
+	return arm64RawSVETable{
+		elementBits: 8 << (int(word>>22) & 3),
+		tableCount:  tableCount,
+		index:       int(word>>16) & 31,
+		firstTable:  int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func arm64SVETableNeedsSVE2(ins Instr) bool {
+	return len(ins.Args) == 3 && ins.Args[1].Kind == OpRegList && len(ins.Args[1].RegList) == 2
+}
+
+func (c *arm64Ctx) lowerARM64SVETable(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZTBL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[1].Kind != OpRegList {
+		return true, false, fmt.Errorf("arm64 ZTBL expects Zm.T, [Zn.T] or [Zn.T, Zn+1.T], Zd.T: %q", ins.Raw)
+	}
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	tables := ins.Args[1].RegList
+	if !indexOK || !destinationOK || indexBits != destinationBits || (len(tables) != 1 && len(tables) != 2) {
+		return true, false, fmt.Errorf("arm64 ZTBL requires one width and one or two table registers: %q", ins.Raw)
+	}
+	firstTable, tableBits, tableOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: tables[0]})
+	if !tableOK || tableBits != indexBits {
+		return true, false, fmt.Errorf("arm64 ZTBL table width must match its index and destination: %q", ins.Raw)
+	}
+	if len(tables) == 2 {
+		secondTable, secondBits, secondOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: tables[1]})
+		if !secondOK || secondBits != tableBits || firstTable == 31 || secondTable != firstTable+1 {
+			return true, false, fmt.Errorf("arm64 named ZTBL pair must be consecutive without wrapping, as required by Go 1.27: %q", ins.Raw)
+		}
+	}
+	return true, false, c.lowerRawSVETable(arm64RawSVETable{
+		elementBits: indexBits,
+		tableCount:  len(tables),
+		index:       index,
+		firstTable:  firstTable,
+		destination: destination,
+	})
+}
+
+func (c *arm64Ctx) lowerRawSVETable(form arm64RawSVETable) error {
+	index, vectorType, err := c.loadZRegElements(form.index, form.elementBits)
+	if err != nil {
+		return err
+	}
+	firstTable, _, err := c.loadZRegElements(form.firstTable, form.elementBits)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.tableCount == 1 {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.tbl.nxv%di%d(%s %s, %s %s)\n", result, vectorType, lanes, form.elementBits, vectorType, firstTable, vectorType, index)
+	} else {
+		secondTable, _, err := c.loadZRegElements((form.firstTable+1)%32, form.elementBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.tbl2.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, lanes, form.elementBits, vectorType, firstTable, vectorType, secondTable, vectorType, index)
+	}
+	return c.storeZRegElements(form.destination, form.elementBits, "%"+result)
+}
diff --git a/arm64_lower_sve_table_extension.go b/arm64_lower_sve_table_extension.go
new file mode 100644
index 000000000..b35a2d4e3
--- /dev/null
+++ b/arm64_lower_sve_table_extension.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVETableExtensionIntrinsics = map[Op]string{
+	"ZTBLQ": "tblq",
+	"ZTBX":  "tbx",
+	"ZTBXQ": "tbxq",
+}
+
+func (c *arm64Ctx) lowerARM64SVETableExtension(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVETableExtensionIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 table form without a suffix: %q", op, ins.Raw)
+	}
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	var table, tableBits int
+	var tableOK bool
+	if op == "ZTBLQ" {
+		if ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 1 {
+			return true, false, fmt.Errorf("arm64 ZTBLQ requires exactly one table register list element: %q", ins.Raw)
+		}
+		table, tableBits, tableOK = arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[1].RegList[0]})
+	} else {
+		table, tableBits, tableOK = arm64ParseSVEZElementReg(ins.Args[1])
+	}
+	if !indexOK || !tableOK || !destinationOK || indexBits != tableBits || tableBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s operands must use one matching B/H/S/D width: %q", op, ins.Raw)
+	}
+	indexValue, vectorType, err := c.loadZRegElements(index, indexBits)
+	if err != nil {
+		return true, false, err
+	}
+	tableValue, _, err := c.loadZRegElements(table, tableBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / destinationBits
+	result := c.newTmp()
+	if op == "ZTBLQ" {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, vectorType, intrinsic, lanes, destinationBits, vectorType, tableValue, vectorType, indexValue)
+	} else {
+		old, _, err := c.loadZRegElements(destination, destinationBits)
+		if err != nil {
+			return true, false, err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, vectorType, intrinsic, lanes, destinationBits, vectorType, old, vectorType, tableValue, vectorType, indexValue)
+	}
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_table_extension_test.go b/arm64_lower_sve_table_extension_test.go
new file mode 100644
index 000000000..a154b8a19
--- /dev/null
+++ b/arm64_lower_sve_table_extension_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVETableExtensionCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svetableextensionforms(SB),$0-0\n")
+	for _, width := range []string{"B", "H", "S", "D"} {
+		fmt.Fprintf(&source, "\tZTBLQ Z1.%s, [Z2.%s], Z3.%s\n", width, width, width)
+		fmt.Fprintf(&source, "\tZTBX Z1.%s, Z2.%s, Z3.%s\n", width, width, width)
+		fmt.Fprintf(&source, "\tZTBXQ Z1.%s, Z2.%s, Z3.%s\n", width, width, width)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svetableextensionforms": {Name: "svetableextensionforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve,+sve2,+sve2p1"`, "@llvm.aarch64.sve.tblq.nxv16i8", "@llvm.aarch64.sve.tbx.nxv4i32", "@llvm.aarch64.sve.tbxq.nxv2i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE table extension lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-table-extension.ll", "arm64-sve-table-extension.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVETableExtensionRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZTBLQ Z1.B, [Z2.B, Z3.B], Z4.B",
+		"ZTBLQ Z1.B, [Z2.H], Z3.B",
+		"ZTBX Z1.B, Z2.H, Z3.B",
+		"ZTBXQ Z1.Q, Z2.Q, Z3.Q",
+		"ZTBXQ.Z Z1.D, Z2.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvetableextension(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvetableextension": {Name: "badsvetableextension", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE table extension forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_table_test.go b/arm64_lower_sve_table_test.go
new file mode 100644
index 000000000..0a7a5d04a
--- /dev/null
+++ b/arm64_lower_sve_table_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVETable(elementBits, tableCount, index, firstTable, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	base := uint32(0x05203000)
+	if tableCount == 2 {
+		base = 0x05202800
+	}
+	return base | size<<22 | uint32(index)<<16 | uint32(firstTable)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVETableCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT svetblnamed(SB),$0-0
+	ZTBL Z31.B, [Z0.B], Z1.B
+	ZTBL Z30.H, [Z2.H], Z3.H
+	ZTBL Z29.S, [Z4.S], Z5.S
+	ZTBL Z28.D, [Z6.D], Z7.D
+	ZTBL Z27.B, [Z8.B, Z9.B], Z10.B
+	ZTBL Z26.H, [Z11.H, Z12.H], Z13.H
+	ZTBL Z25.S, [Z14.S, Z15.S], Z16.S
+	ZTBL Z24.D, [Z30.D, Z31.D], Z17.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svetblraw(SB),$0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVETable(elementBits, 1, 1, 2, 3))
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVETable(elementBits, 2, 4, 31, 5))
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svetbl" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.tbl.nxv", "@llvm.aarch64.sve.tbl2.nxv"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE TBL lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-table.ll", "arm64-sve-table.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVETableDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, tableCount := range []int{1, 2} {
+			for index := 0; index < 32; index++ {
+				for firstTable := 0; firstTable < 32; firstTable++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVETable(elementBits, tableCount, index, firstTable, destination)
+						got, ok := decodeARM64RawSVETable(word)
+						if !ok || got.elementBits != elementBits || got.tableCount != tableCount || got.index != index || got.firstTable != firstTable || got.destination != destination {
+							t.Fatalf("decoded SVE TBL %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVETableRejectsAdjacentAndGoRejectsWrappingNamedPair(t *testing.T) {
+	for _, word := range []uint32{0x05202c00, 0x05202000, 0x05203800} {
+		if _, ok := decodeARM64RawSVETable(word); ok {
+			t.Fatalf("SVE TBL decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsvetbl(SB),$0-0
+	ZTBL Z0.B, [Z31.B, Z0.B], Z1.B
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvetbl": {Name: "badsvetbl", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted the wrapping named SVE TBL pair rejected by Go 1.27")
+	}
+
+	// The machine encoding and LLVM accept the architectural Z31,Z0 wrap even
+	// though Go's named reglist encoder rejects it.
+	if got, ok := decodeARM64RawSVETable(encodeARM64RawSVETable(8, 2, 0, 31, 1)); !ok || got.firstTable != 31 {
+		t.Fatalf("raw SVE TBL pair wrap was not preserved: %+v, ok=%v", got, ok)
+	}
+}
diff --git a/arm64_lower_sve_ternary_bitwise.go b/arm64_lower_sve_ternary_bitwise.go
new file mode 100644
index 000000000..de9e496e9
--- /dev/null
+++ b/arm64_lower_sve_ternary_bitwise.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVETernaryBitwiseSpec struct {
+	intrinsic string
+	rawBase   uint32
+}
+
+var arm64SVETernaryBitwiseSpecs = map[Op]arm64SVETernaryBitwiseSpec{
+	"ZBCAX":  {"bcax", 0x04603800},
+	"ZBSL":   {"bsl", 0x04203c00},
+	"ZBSL1N": {"bsl1n", 0x04603c00},
+	"ZBSL2N": {"bsl2n", 0x04a03c00},
+	"ZEOR3":  {"eor3", 0x04203800},
+	"ZNBSL":  {"nbsl", 0x04e03c00},
+}
+
+var arm64RawSVETernaryBitwiseOps = func() map[uint32]Op {
+	ops := make(map[uint32]Op)
+	for op, spec := range arm64SVETernaryBitwiseSpecs {
+		ops[spec.rawBase] = op
+	}
+	return ops
+}()
+
+func decodeARM64RawSVETernaryBitwise(word uint32) (Instr, bool) {
+	op, ok := arm64RawSVETernaryBitwiseOps[word&0xffe0fc00]
+	if !ok {
+		return Instr{}, false
+	}
+	vector := func(index uint32) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.D", index&31))}
+	}
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		vector(word >> 5), vector(word >> 16), vector(word), vector(word),
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64SVETernaryBitwise(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVETernaryBitwiseSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 {
+		return true, false, fmt.Errorf("arm64 %s expects Zk.D, Zm.D, Zdn.D, Zdn.D without a suffix: %q", op, ins.Raw)
+	}
+	third, thirdBits, thirdOK := arm64ParseSVEZElementReg(ins.Args[0])
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[2])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !thirdOK || !secondOK || !firstOK || !destinationOK || thirdBits != 64 || secondBits != 64 || firstBits != 64 || destinationBits != 64 || first != destination {
+		return true, false, fmt.Errorf("arm64 %s requires D-width operands and one destructive destination: %q", op, ins.Raw)
+	}
+	firstValue, vectorType, err := c.loadZRegElements(first, 64)
+	if err != nil {
+		return true, false, err
+	}
+	secondValue, _, err := c.loadZRegElements(second, 64)
+	if err != nil {
+		return true, false, err
+	}
+	thirdValue, _, err := c.loadZRegElements(third, 64)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv2i64(%s %s, %s %s, %s %s)\n", result, vectorType, spec.intrinsic, vectorType, firstValue, vectorType, secondValue, vectorType, thirdValue)
+	return true, false, c.storeZRegElements(destination, 64, "%"+result)
+}
diff --git a/arm64_lower_sve_ternary_bitwise_test.go b/arm64_lower_sve_ternary_bitwise_test.go
new file mode 100644
index 000000000..9b7179868
--- /dev/null
+++ b/arm64_lower_sve_ternary_bitwise_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVETernaryBitwiseCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveternarybitwiseforms(SB),$0-0\n")
+	for _, op := range []string{"ZBCAX", "ZBSL", "ZBSL1N", "ZBSL2N", "ZEOR3", "ZNBSL"} {
+		source.WriteString("\t" + op + " Z1.D, Z2.D, Z3.D, Z3.D\n")
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVETernaryBitwiseCompleteGo127Family(t *testing.T) {
+	source := arm64SVETernaryBitwiseCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveternarybitwiseforms": {Name: "sveternarybitwiseforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.bcax.nxv2i64",
+				"@llvm.aarch64.sve.bsl.nxv2i64",
+				"@llvm.aarch64.sve.bsl1n.nxv2i64",
+				"@llvm.aarch64.sve.bsl2n.nxv2i64",
+				"@llvm.aarch64.sve.eor3.nxv2i64",
+				"@llvm.aarch64.sve.nbsl.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE ternary-bitwise lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-ternary-bitwise.ll", "arm64-sve-ternary-bitwise.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVETernaryBitwiseRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZBCAX Z1.S, Z2.S, Z3.S, Z3.S",
+		"ZBSL Z1.D, Z2.S, Z3.D, Z3.D",
+		"ZBSL1N Z1.D, Z2.D, Z3.D, Z4.D",
+		"ZBSL2N Z1.D, Z2.D, Z3.D",
+		"ZEOR3 Z1.Q, Z2.Q, Z3.Q, Z3.Q",
+		"ZNBSL.Z Z1.D, Z2.D, Z3.D, Z3.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveternarybitwise(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveternarybitwise": {Name: "badsveternarybitwise", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE ternary-bitwise forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_umullb.go b/arm64_lower_sve_umullb.go
new file mode 100644
index 000000000..1d84ce158
--- /dev/null
+++ b/arm64_lower_sve_umullb.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type arm64SVEUMULLBMode uint8
+
+const (
+	arm64SVEUMULLBVector arm64SVEUMULLBMode = iota
+	arm64SVEUMULLBLane
+)
+
+type arm64RawSVEUMULLB struct {
+	op          Op
+	mode        arm64SVEUMULLBMode
+	sourceBits  int
+	first       int
+	second      int
+	laneVector  int
+	lane        int
+	destination int
+}
+
+type arm64SVEMultiplyLongSpec struct {
+	intrinsic  string
+	accumulate bool
+	vectorBase uint32
+	laneHBase  uint32
+	laneSBase  uint32
+}
+
+var arm64SVEMultiplyLongSpecs = map[Op]arm64SVEMultiplyLongSpec{
+	"ZSMULLB":    {intrinsic: "smullb", vectorBase: 0x45007000, laneHBase: 0x44a0c000, laneSBase: 0x44e0c000},
+	"ZSMULLT":    {intrinsic: "smullt", vectorBase: 0x45007400, laneHBase: 0x44a0c400, laneSBase: 0x44e0c400},
+	"ZUMULLB":    {intrinsic: "umullb", vectorBase: 0x45007800, laneHBase: 0x44a0d000, laneSBase: 0x44e0d000},
+	"ZUMULLT":    {intrinsic: "umullt", vectorBase: 0x45007c00, laneHBase: 0x44a0d400, laneSBase: 0x44e0d400},
+	"ZSQDMULLB":  {intrinsic: "sqdmullb", vectorBase: 0x45006000, laneHBase: 0x44a0e000, laneSBase: 0x44e0e000},
+	"ZSQDMULLT":  {intrinsic: "sqdmullt", vectorBase: 0x45006400, laneHBase: 0x44a0e400, laneSBase: 0x44e0e400},
+	"ZSQDMLALB":  {intrinsic: "sqdmlalb", accumulate: true, vectorBase: 0x44006000, laneHBase: 0x44a02000, laneSBase: 0x44e02000},
+	"ZSQDMLALT":  {intrinsic: "sqdmlalt", accumulate: true, vectorBase: 0x44006400, laneHBase: 0x44a02400, laneSBase: 0x44e02400},
+	"ZSQDMLALBT": {intrinsic: "sqdmlalbt", accumulate: true, vectorBase: 0x44000800},
+	"ZSQDMLSLB":  {intrinsic: "sqdmlslb", accumulate: true, vectorBase: 0x44006800, laneHBase: 0x44a03000, laneSBase: 0x44e03000},
+	"ZSQDMLSLT":  {intrinsic: "sqdmlslt", accumulate: true, vectorBase: 0x44006c00, laneHBase: 0x44a03400, laneSBase: 0x44e03400},
+	"ZSQDMLSLBT": {intrinsic: "sqdmlslbt", accumulate: true, vectorBase: 0x44000c00},
+}
+
+var arm64SVEMultiplyLongOps = [...]Op{
+	"ZSMULLB", "ZSMULLT", "ZUMULLB", "ZUMULLT",
+	"ZSQDMULLB", "ZSQDMULLT",
+	"ZSQDMLALB", "ZSQDMLALT", "ZSQDMLALBT",
+	"ZSQDMLSLB", "ZSQDMLSLT", "ZSQDMLSLBT",
+}
+
+func decodeARM64RawSVEUMULLB(word uint32) (arm64RawSVEUMULLB, bool) {
+	for _, op := range arm64SVEMultiplyLongOps {
+		spec := arm64SVEMultiplyLongSpecs[op]
+		form := arm64RawSVEUMULLB{op: op}
+		switch {
+		case word&0xff20fc00 == spec.vectorBase:
+			size := int(word>>22) & 3
+			if size == 0 {
+				continue
+			}
+			form.mode = arm64SVEUMULLBVector
+			form.sourceBits = 4 << size
+			form.second = int(word>>16) & 31
+		case spec.laneHBase != 0 && word&0xffe0f400 == spec.laneHBase:
+			form.mode = arm64SVEUMULLBLane
+			form.sourceBits = 16
+			form.laneVector = int(word>>16) & 7
+			form.lane = int(word>>11)&1 | (int(word>>19)&3)<<1
+		case spec.laneSBase != 0 && word&0xffe0f400 == spec.laneSBase:
+			form.mode = arm64SVEUMULLBLane
+			form.sourceBits = 32
+			form.laneVector = int(word>>16) & 15
+			form.lane = int(word>>11)&1 | (int(word>>20)&1)<<1
+		default:
+			continue
+		}
+		form.first = int(word>>5) & 31
+		form.destination = int(word) & 31
+		return form, true
+	}
+	return arm64RawSVEUMULLB{}, false
+}
+
+func arm64ParseSVEUMULLBIndexedReg(operand Operand) (index, elementBits, lane int, ok bool) {
+	if operand.Kind != OpReg {
+		return 0, 0, 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	dot := strings.IndexByte(name, '.')
+	open := strings.IndexByte(name, '[')
+	if dot <= 1 || open <= dot+1 || !strings.HasSuffix(name, "]") || !strings.HasPrefix(name, "Z") {
+		return 0, 0, 0, false
+	}
+	index, err := strconv.Atoi(name[1:dot])
+	if err != nil {
+		return 0, 0, 0, false
+	}
+	elementBits, bitsOK := map[string]int{"H": 16, "S": 32}[name[dot+1:open]]
+	lane, err = strconv.Atoi(name[open+1 : len(name)-1])
+	if err != nil || !bitsOK {
+		return 0, 0, 0, false
+	}
+	maxVector := map[int]int{16: 7, 32: 15}[elementBits]
+	maxLane := map[int]int{16: 7, 32: 3}[elementBits]
+	return index, elementBits, lane, index >= 0 && index <= maxVector && lane >= 0 && lane <= maxLane
+}
+
+func (c *arm64Ctx) lowerARM64SVEUMULLB(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEMultiplyLongSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one of its Go 1.27 SVE2 multiply-long forms: %q", op, ins.Raw)
+	}
+	form := arm64RawSVEUMULLB{op: op}
+	if laneVector, laneBits, lane, laneOK := arm64ParseSVEUMULLBIndexedReg(ins.Args[0]); laneOK {
+		if spec.laneHBase == 0 {
+			return true, false, fmt.Errorf("arm64 %s has no indexed Go 1.27 form: %q", op, ins.Raw)
+		}
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !firstOK || !destinationOK || firstBits != laneBits || destinationBits != 2*laneBits {
+			return true, false, fmt.Errorf("arm64 %s indexed operands must widen H to S or S to D: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEUMULLB{op: op, mode: arm64SVEUMULLBLane, sourceBits: firstBits, first: first, laneVector: laneVector, lane: lane, destination: destination}
+	} else {
+		second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+		first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+		destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+		if !secondOK || !firstOK || !destinationOK || secondBits != firstBits || firstBits == 64 || destinationBits != 2*firstBits {
+			return true, false, fmt.Errorf("arm64 %s vector operands must widen B/H/S to H/S/D: %q", op, ins.Raw)
+		}
+		form = arm64RawSVEUMULLB{op: op, mode: arm64SVEUMULLBVector, sourceBits: firstBits, first: first, second: second, destination: destination}
+	}
+	return true, false, c.lowerRawSVEUMULLB(form)
+}
+
+func (c *arm64Ctx) lowerRawSVEUMULLB(form arm64RawSVEUMULLB) error {
+	spec, ok := arm64SVEMultiplyLongSpecs[form.op]
+	if !ok {
+		return fmt.Errorf("unsupported ARM64 SVE2 multiply-long operation %s", form.op)
+	}
+	first, sourceType, err := c.loadZRegElements(form.first, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	secondIndex := form.second
+	if form.mode == arm64SVEUMULLBLane {
+		secondIndex = form.laneVector
+	}
+	second, _, err := c.loadZRegElements(secondIndex, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	destinationBits := form.sourceBits * 2
+	destinationType, destinationLanes, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return err
+	}
+	var accumulator string
+	if spec.accumulate {
+		accumulator, _, err = c.loadZRegElements(form.destination, destinationBits)
+		if err != nil {
+			return err
+		}
+	}
+	result := c.newTmp()
+	if spec.accumulate {
+		if form.mode == arm64SVEUMULLBVector {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, destinationBits, destinationType, accumulator, sourceType, first, sourceType, second)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, %s %s, i32 %d)\n", result, destinationType, spec.intrinsic, destinationLanes, destinationBits, destinationType, accumulator, sourceType, first, sourceType, second, form.lane)
+		}
+	} else if form.mode == arm64SVEUMULLBVector {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, destinationBits, sourceType, first, sourceType, second)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, destinationType, spec.intrinsic, destinationLanes, destinationBits, sourceType, first, sourceType, second, form.lane)
+	}
+	return c.storeZRegElements(form.destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_umullb_test.go b/arm64_lower_sve_umullb_test.go
new file mode 100644
index 000000000..87d134deb
--- /dev/null
+++ b/arm64_lower_sve_umullb_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEUMULLBVector(sourceBits, second, first, destination int) uint32 {
+	size := map[int]uint32{8: 1, 16: 2, 32: 3}[sourceBits]
+	return 0x45007800 | size<<22 | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+}
+
+func encodeARM64RawSVEUMULLBLane(sourceBits, laneVector, lane, first, destination int) uint32 {
+	base := uint32(0x44a0d000)
+	if sourceBits == 16 {
+		return base | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<19 | uint32(first)<<5 | uint32(destination)
+	}
+	return 0x44e0d000 | uint32(laneVector)<<16 | uint32(lane&1)<<11 | uint32(lane>>1)<<20 | uint32(first)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64SVEUMULLBCompleteGo127Forms(t *testing.T) {
+	const named = `
+TEXT sveumullbnamed(SB),$0-0
+	ZUMULLB Z31.B, Z30.B, Z29.H
+	ZUMULLB Z28.H, Z27.H, Z26.S
+	ZUMULLB Z25.S, Z24.S, Z23.D
+	ZUMULLB Z7.H[7], Z22.H, Z21.S
+	ZUMULLB Z15.S[3], Z20.S, Z19.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT sveumullbraw(SB),$0-0\n")
+	for _, sourceBits := range []int{8, 16, 32} {
+		fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEUMULLBVector(sourceBits, 1, 2, 3))
+	}
+	fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEUMULLBLane(16, 7, 7, 4, 5))
+	fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEUMULLBLane(32, 15, 3, 6, 7))
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "sveumullb" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{function: {Name: function, Ret: Void}}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"="+sve,+sve2"`, "@llvm.aarch64.sve.umullb.nxv", "@llvm.aarch64.sve.umullb.lane.nxv"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE UMULLB lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-umullb.ll", "arm64-sve-umullb.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawSVEUMULLBDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, sourceBits := range []int{8, 16, 32} {
+		for second := 0; second < 32; second++ {
+			for first := 0; first < 32; first++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEUMULLBVector(sourceBits, second, first, destination)
+					got, ok := decodeARM64RawSVEUMULLB(word)
+					if !ok || got.mode != arm64SVEUMULLBVector || got.sourceBits != sourceBits || got.second != second || got.first != first || got.destination != destination {
+						t.Fatalf("decoded vector SVE UMULLB %#08x as %+v, ok=%v", word, got, ok)
+					}
+				}
+			}
+		}
+	}
+	for _, domain := range []struct{ bits, vectors, lanes int }{{16, 8, 8}, {32, 16, 4}} {
+		for laneVector := 0; laneVector < domain.vectors; laneVector++ {
+			for lane := 0; lane < domain.lanes; lane++ {
+				for first := 0; first < 32; first++ {
+					for destination := 0; destination < 32; destination++ {
+						word := encodeARM64RawSVEUMULLBLane(domain.bits, laneVector, lane, first, destination)
+						got, ok := decodeARM64RawSVEUMULLB(word)
+						if !ok || got.mode != arm64SVEUMULLBLane || got.sourceBits != domain.bits || got.laneVector != laneVector || got.lane != lane || got.first != first || got.destination != destination {
+							t.Fatalf("decoded lane SVE UMULLB %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64SVEUMULLBRejectsReservedAndAdjacentForms(t *testing.T) {
+	for _, word := range []uint32{0x45007800, 0x45007c00, 0x44a0f000, 0x44e0f000} {
+		if _, ok := decodeARM64RawSVEUMULLB(word); ok {
+			t.Fatalf("SVE UMULLB decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+	const invalid = `
+TEXT badsveumullb(SB),$0-0
+	ZUMULLB Z8.H[0], Z1.H, Z2.S
+	ZUMULLB Z1.S, Z2.S, Z3.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, invalid, false)
+	file, err := Parse(ArchARM64, invalid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveumullb": {Name: "badsveumullb", Ret: Void}}}); err == nil {
+		t.Fatal("translator accepted invalid SVE UMULLB forms")
+	}
+}
diff --git a/arm64_lower_sve_unpack.go b/arm64_lower_sve_unpack.go
new file mode 100644
index 000000000..6326be407
--- /dev/null
+++ b/arm64_lower_sve_unpack.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEUnpackIntrinsics = map[Op]string{
+	"ZSUNPKHI": "sunpkhi",
+	"ZSUNPKLO": "sunpklo",
+	"ZUUNPKHI": "uunpkhi",
+	"ZUUNPKLO": "uunpklo",
+}
+
+func (c *arm64Ctx) lowerARM64SVEUnpack(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, ok := arm64SVEUnpackIntrinsics[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Zn.B|H|S, Zd.H|S|D without a suffix: %q", op, ins.Raw)
+	}
+	source, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !sourceOK || !destinationOK || (sourceBits != 8 && sourceBits != 16 && sourceBits != 32) || destinationBits != sourceBits*2 {
+		return true, false, fmt.Errorf("arm64 %s requires a B-to-H, H-to-S, or S-to-D widening pair: %q", op, ins.Raw)
+	}
+	sourceValue, sourceType, err := c.loadZRegElements(source, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationType, _, err := arm64SVEVectorType(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	destinationLanes := 128 / destinationBits
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s)\n", result, destinationType, intrinsic, destinationLanes, destinationBits, sourceType, sourceValue)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_unpack_test.go b/arm64_lower_sve_unpack_test.go
new file mode 100644
index 000000000..b4c1a929d
--- /dev/null
+++ b/arm64_lower_sve_unpack_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEUnpackCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT sveunpackforms(SB),$0-0\n")
+	for _, op := range []string{"ZSUNPKHI", "ZSUNPKLO", "ZUUNPKHI", "ZUUNPKLO"} {
+		for _, widths := range [][2]string{{"B", "H"}, {"H", "S"}, {"S", "D"}} {
+			source.WriteString("\t" + op + " Z1." + widths[0] + ", Z2." + widths[1] + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEUnpackCompleteGo127Family(t *testing.T) {
+	source := arm64SVEUnpackCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveunpackforms": {Name: "sveunpackforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.sunpkhi.nxv8i16",
+				"@llvm.aarch64.sve.sunpklo.nxv4i32",
+				"@llvm.aarch64.sve.uunpkhi.nxv2i64",
+				"@llvm.aarch64.sve.uunpklo.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE unpack lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-unpack.ll", "arm64-sve-unpack.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEUnpackRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSUNPKHI Z1.B, Z2.B",
+		"ZSUNPKLO Z1.S, Z2.S",
+		"ZUUNPKHI Z1.H, Z2.D",
+		"ZUUNPKLO Z1.D, Z2.Q",
+		"ZSUNPKHI Z1.B",
+		"ZUUNPKLO.Z Z1.S, Z2.D",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsveunpack(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsveunpack": {Name: "badsveunpack", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE unpack forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_vector_predicate_incdec.go b/arm64_lower_sve_vector_predicate_incdec.go
new file mode 100644
index 000000000..4f4af5773
--- /dev/null
+++ b/arm64_lower_sve_vector_predicate_incdec.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEVectorPredicateIncDecSpec struct {
+	intrinsic  string
+	increment  bool
+	saturating bool
+}
+
+var arm64SVEVectorPredicateIncDecSpecs = map[Op]arm64SVEVectorPredicateIncDecSpec{
+	"ZDECP":   {},
+	"ZINCP":   {increment: true},
+	"ZSQDECP": {intrinsic: "sqdecp", saturating: true},
+	"ZSQINCP": {intrinsic: "sqincp", increment: true, saturating: true},
+	"ZUQDECP": {intrinsic: "uqdecp", saturating: true},
+	"ZUQINCP": {intrinsic: "uqincp", increment: true, saturating: true},
+}
+
+func (c *arm64Ctx) lowerARM64SVEVectorPredicateIncDec(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEVectorPredicateIncDecSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects Pm.H/S/D, Zdn.H/S/D without a suffix: %q", op, ins.Raw)
+	}
+	predicate, predicateBits, predicateOK := arm64ParseSVEPredicateElement(ins.Args[0])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[1])
+	if !predicateOK || !destinationOK || predicateBits == 8 || predicateBits != destinationBits {
+		return true, false, fmt.Errorf("arm64 %s requires matching H/S/D predicate and vector arrangements: %q", op, ins.Raw)
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, predicateBits)
+	if err != nil {
+		return true, false, err
+	}
+	value, vectorType, err := c.loadZRegElements(destination, destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / destinationBits
+	result := c.newTmp()
+	if spec.saturating {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, vectorType, spec.intrinsic, lanes, destinationBits, vectorType, value, predicateType, predicateValue)
+		return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+	}
+	governing, _, err := c.allTruePRegElements(destinationBits)
+	if err != nil {
+		return true, false, err
+	}
+	count := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.aarch64.sve.cntp.nxv%di1(%s %s, %s %s)\n", count, lanes, predicateType, governing, predicateType, predicateValue)
+	countValue := "%" + count
+	if destinationBits != 64 {
+		narrowed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrowed, countValue, destinationBits)
+		countValue = "%" + narrowed
+	}
+	inserted := c.newTmp()
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement %s poison, i%d %s, i64 0\n", inserted, vectorType, destinationBits, countValue)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %%%s, %s poison, <vscale x %d x i32> zeroinitializer\n", splat, vectorType, inserted, vectorType, lanes)
+	operation := "sub"
+	if spec.increment {
+		operation = "add"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, operation, vectorType, value, splat)
+	return true, false, c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_vector_predicate_incdec_test.go b/arm64_lower_sve_vector_predicate_incdec_test.go
new file mode 100644
index 000000000..e3e60030d
--- /dev/null
+++ b/arm64_lower_sve_vector_predicate_incdec_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEVectorPredicateIncDecCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svevectorpredicateincdec(SB),$0-0\n")
+	for opIndex, op := range []string{"ZDECP", "ZINCP", "ZSQDECP", "ZSQINCP", "ZUQDECP", "ZUQINCP"} {
+		for widthIndex, suffix := range []string{"H", "S", "D"} {
+			reg := (opIndex*3 + widthIndex) % 32
+			fmt.Fprintf(&source, "\t%s P%d.%s, Z%d.%s\n", op, (opIndex+widthIndex)%16, suffix, reg, suffix)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svevectorpredicateincdec": {Name: "svevectorpredicateincdec", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"sub <vscale x 8 x i16>", "add <vscale x 2 x i64>",
+				"@llvm.aarch64.sve.sqdecp.nxv8i16",
+				"@llvm.aarch64.sve.sqincp.nxv8i16",
+				"@llvm.aarch64.sve.uqdecp.nxv4i32",
+				"@llvm.aarch64.sve.uqincp.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE vector predicate inc/dec lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-vector-predicate-incdec.ll", "arm64-sve-vector-predicate-incdec.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEVectorPredicateIncDecRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZDECP P0.B, Z1.B",
+		"ZDECP P0.B, Z1.H",
+		"ZINCP P0, Z1.B",
+		"ZSQDECP P16.B, Z1.B",
+		"ZSQINCP P0.Q, Z1.Q",
+		"ZUQDECP P0.B, R1",
+		"ZUQINCP.Z P0.B, Z1.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvevectorpredicateincdec(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvevectorpredicateincdec": {Name: "badsvevectorpredicateincdec", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector predicate inc/dec forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_vector_prefetch.go b/arm64_lower_sve_vector_prefetch.go
new file mode 100644
index 000000000..d415ac0d3
--- /dev/null
+++ b/arm64_lower_sve_vector_prefetch.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+var arm64SVEVectorPrefetchBits = map[Op]int{
+	"ZPRFB": 8,
+	"ZPRFH": 16,
+	"ZPRFW": 32,
+	"ZPRFD": 64,
+}
+
+func (c *arm64Ctx) lowerARM64SVEVectorPrefetch(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	elementBits, ok := arm64SVEVectorPrefetchBits[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s expects memory, Pg, prfop: %q", op, ins.Raw)
+	}
+	predicate, predicateOK := arm64ParseSVEPredicateBare(ins.Args[1], 7)
+	hint, hintOK := arm64SVEPrefetchHint(ins.Args[2])
+	if !predicateOK || !hintOK {
+		return true, false, fmt.Errorf("arm64 %s requires P0..P7 and an SVE data prefetch operation: %q", op, ins.Raw)
+	}
+	memory := ins.Args[0].Mem
+	if memory.Index != "" {
+		return c.lowerARM64SVEVectorPrefetchScalarBase(op, elementBits, predicate, hint, memory, ins)
+	}
+	return c.lowerARM64SVEVectorPrefetchVectorBase(op, elementBits, predicate, hint, memory, ins)
+}
+
+func (c *arm64Ctx) lowerARM64SVEVectorPrefetchScalarBase(op Op, elementBits, predicate, hint int, memory MemRef, ins Instr) (ok bool, terminated bool, err error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.Off != 0 || memory.OffRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s scalar-base vector-offset address has an invalid displacement: %q", op, ins.Raw)
+	}
+	baseReg, baseOK := arm64SVEPhysicalMemoryBase(memory.Base)
+	index, indexBits, indexOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Index})
+	expectedScale := int64(elementBits / 8)
+	if !baseOK || !indexOK || (indexBits != 32 && indexBits != 64) || memory.Scale != expectedScale {
+		return true, false, fmt.Errorf("arm64 %s vector offset requires Zm.S/D and exact element shift: %q", op, ins.Raw)
+	}
+	extension := ""
+	if memory.IndexExt == "" {
+		if indexBits != 64 {
+			return true, false, fmt.Errorf("arm64 %s unextended vector offset requires Zm.D: %q", op, ins.Raw)
+		}
+	} else if memory.IndexExt == ExtendUXTW {
+		extension = "uxtw."
+	} else if memory.IndexExt == ExtendSXTW {
+		extension = "sxtw."
+	} else {
+		return true, false, fmt.Errorf("arm64 %s vector offset only accepts UXTW or SXTW: %q", op, ins.Raw)
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return true, false, err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, base)
+	indexValue, vectorType, err := c.loadZRegElements(index, indexBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, indexBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / indexBits
+	letter := strings.ToLower(strings.TrimPrefix(string(op), "ZPRF"))
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.prf%s.gather.%sindex.nxv%di%d(%s %s, ptr %%%s, %s %s, i32 %d)\n",
+		letter, extension, lanes, indexBits, predicateType, predicateValue, pointer, vectorType, indexValue, hint)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64SVEVectorPrefetchVectorBase(op Op, elementBits, predicate, hint int, memory MemRef, ins Instr) (ok bool, terminated bool, err error) {
+	if memory.Sym != "" || memory.Segment != "" || memory.OffRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s vector-base address only accepts an unsigned byte offset: %q", op, ins.Raw)
+	}
+	base, baseBits, baseOK := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: memory.Base})
+	alignment := int64(elementBits / 8)
+	maximum := int64(31) * alignment
+	if !baseOK || (baseBits != 32 && baseBits != 64) || memory.Off < 0 || memory.Off > maximum || memory.Off%alignment != 0 {
+		return true, false, fmt.Errorf("arm64 %s vector-base offset must be aligned to %d and in [0,%d]: %q", op, alignment, maximum, ins.Raw)
+	}
+	baseValue, vectorType, err := c.loadZRegElements(base, baseBits)
+	if err != nil {
+		return true, false, err
+	}
+	predicateValue, predicateType, err := c.loadPRegElements(predicate, baseBits)
+	if err != nil {
+		return true, false, err
+	}
+	lanes := 128 / baseBits
+	letter := strings.ToLower(strings.TrimPrefix(string(op), "ZPRF"))
+	fmt.Fprintf(c.b, "  call void @llvm.aarch64.sve.prf%s.gather.scalar.offset.nxv%di%d(%s %s, %s %s, i64 %d, i32 %d)\n",
+		letter, lanes, baseBits, predicateType, predicateValue, vectorType, baseValue, memory.Off, hint)
+	return true, false, nil
+}
diff --git a/arm64_lower_sve_vector_prefetch_test.go b/arm64_lower_sve_vector_prefetch_test.go
new file mode 100644
index 000000000..10cbd31d2
--- /dev/null
+++ b/arm64_lower_sve_vector_prefetch_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEVectorPrefetchCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svevectorprefetchforms(SB),$0-0\n")
+	for _, spec := range []struct {
+		op      string
+		shift   int
+		maximum int
+	}{
+		{op: "ZPRFB", shift: 0, maximum: 31},
+		{op: "ZPRFH", shift: 1, maximum: 62},
+		{op: "ZPRFW", shift: 2, maximum: 124},
+		{op: "ZPRFD", shift: 3, maximum: 248},
+	} {
+		shift := ""
+		if spec.shift != 0 {
+			shift = fmt.Sprintf("<<%d", spec.shift)
+		}
+		fmt.Fprintf(&source, "\t%s (Z8.D%s)(RSP), P0, PLDL1KEEP\n", spec.op, shift)
+		for _, extension := range []string{"UXTW", "SXTW"} {
+			fmt.Fprintf(&source, "\t%s (Z6.D.%s%s)(R14), P1, PLDL1STRM\n", spec.op, extension, shift)
+			fmt.Fprintf(&source, "\t%s (Z7.S.%s%s)(R15), P2, PSTL1KEEP\n", spec.op, extension, shift)
+		}
+		fmt.Fprintf(&source, "\t%s (Z10.S), P3, PSTL2KEEP\n", spec.op)
+		fmt.Fprintf(&source, "\t%s %d(Z10.S), P4, PSTL2STRM\n", spec.op, spec.maximum)
+		fmt.Fprintf(&source, "\t%s (Z11.D), P5, PSTL3KEEP\n", spec.op)
+		fmt.Fprintf(&source, "\t%s %d(Z11.D), P7, PSTL3STRM\n", spec.op, spec.maximum)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestParseARM64SVEVectorPrefetchRetainsAddressSemantics(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT parsezprf(SB),$0-0\n\tZPRFB (Z6.S.SXTW)(R14), P2, PLDL1STRM\n\tZPRFD (Z8.D<<3)(RSP), P3, PSTL3KEEP\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	first := file.Funcs[0].Instrs[1].Args[0].Mem
+	if first.Base != Reg("R14") || first.Index != Reg("Z6.S") || first.IndexExt != ExtendSXTW || first.Scale != 1 {
+		t.Fatalf("extended Z prefetch address parsed as %+v", first)
+	}
+	second := file.Funcs[0].Instrs[2].Args[0].Mem
+	if second.Base != Reg("RSP") || second.Index != Reg("Z8.D") || second.IndexExt != "" || second.Scale != 8 {
+		t.Fatalf("shifted Z prefetch address parsed as %+v", second)
+	}
+}
+
+func TestTranslateARM64SVEVectorPrefetchCompleteGo127Family(t *testing.T) {
+	source := arm64SVEVectorPrefetchCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svevectorprefetchforms": {Name: "svevectorprefetchforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.prfb.gather.index.nxv2i64",
+				"@llvm.aarch64.sve.prfh.gather.uxtw.index.nxv4i32",
+				"@llvm.aarch64.sve.prfw.gather.sxtw.index.nxv2i64",
+				"@llvm.aarch64.sve.prfd.gather.scalar.offset.nxv2i64",
+				"@llvm.aarch64.sve.prfd.gather.scalar.offset.nxv4i32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE vector prefetch lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-vector-prefetch.ll", "arm64-sve-vector-prefetch.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEVectorPrefetchRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZPRFB (Z1.D<<1)(R0), P0, PLDL1KEEP",
+		"ZPRFH (Z1.D)(R0), P0, PLDL1KEEP",
+		"ZPRFW (Z1.S.SXTW<<1)(R0), P0, PLDL1KEEP",
+		"ZPRFD (Z1.H.SXTW<<3)(R0), P0, PLDL1KEEP",
+		"ZPRFB 32(Z1.S), P0, PLDL1KEEP",
+		"ZPRFH 3(Z1.D), P0, PLDL1KEEP",
+		"ZPRFW 128(Z1.S), P0, PLDL1KEEP",
+		"ZPRFD 256(Z1.D), P0, PLDL1KEEP",
+		"ZPRFD 8(Z1.D), P8, PLDL1KEEP",
+		"ZPRFD 8(Z1.D), P0, PLIL1KEEP",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvevectorprefetch(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvevectorprefetch": {Name: "badsvevectorprefetch", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE vector prefetch forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_whole_vector_memory.go b/arm64_lower_sve_whole_vector_memory.go
new file mode 100644
index 000000000..959655a09
--- /dev/null
+++ b/arm64_lower_sve_whole_vector_memory.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var arm64SVEWholeVectorMemoryOps = map[Op]bool{
+	"ZLDR": true,
+	"ZSTR": false,
+}
+
+func (c *arm64Ctx) lowerARM64SVEWholeVectorMemory(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	load, ok := arm64SVEWholeVectorMemoryOps[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s expects its two-operand Go 1.27 form: %q", op, ins.Raw)
+	}
+	memoryOperand := 0
+	vectorOperand := 1
+	if !load {
+		vectorOperand, memoryOperand = memoryOperand, vectorOperand
+	}
+	vector, vectorOK := arm64ParseSVEBareZReg(ins.Args[vectorOperand])
+	if !vectorOK || ins.Args[memoryOperand].Kind != OpMem {
+		return true, false, fmt.Errorf("arm64 %s requires a MUL VL address and bare Z0..Z31: %q", op, ins.Raw)
+	}
+	address, err := c.arm64SVEVLAddress(ins.Args[memoryOperand].Mem, -256, 255, 16)
+	if err != nil {
+		return true, false, fmt.Errorf("arm64 %s: %w: %q", op, err, ins.Raw)
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	if load {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load <vscale x 16 x i8>, ptr %%%s, align 1\n", value, pointer)
+		return true, false, c.storeZReg(vector, "%"+value)
+	}
+	value, err := c.loadZReg(vector)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  store <vscale x 16 x i8> %s, ptr %%%s, align 1\n", value, pointer)
+	return true, false, nil
+}
+
+func arm64ParseSVEBareZReg(operand Operand) (int, bool) {
+	if operand.Kind != OpReg {
+		return 0, false
+	}
+	name := strings.ToUpper(strings.TrimSpace(string(operand.Reg)))
+	if strings.Contains(name, ".") || !strings.HasPrefix(name, "Z") {
+		return 0, false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(name, "Z"))
+	return index, err == nil && index >= 0 && index <= 31
+}
diff --git a/arm64_lower_sve_whole_vector_memory_test.go b/arm64_lower_sve_whole_vector_memory_test.go
new file mode 100644
index 000000000..4510b604f
--- /dev/null
+++ b/arm64_lower_sve_whole_vector_memory_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEWholeVectorMemoryCompleteGo127Family(t *testing.T) {
+	const source = `
+TEXT svewholevectormemoryforms(SB),$0-0
+	ZLDR (-VL*256)(R0), Z0
+	ZLDR (VL*255)(RSP), Z31
+	ZSTR Z30, (-VL*256)(R1)
+	ZSTR Z1, (VL*255)(ZR)
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svewholevectormemoryforms": {Name: "svewholevectormemoryforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+sve"`, "load <vscale x 16 x i8>", "store <vscale x 16 x i8>", "@llvm.vscale.i64()"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE whole-vector memory lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-whole-vector-memory.ll", "arm64-sve-whole-vector-memory.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEWholeVectorMemoryRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZLDR (-VL*257)(R0), Z1",
+		"ZLDR (VL*256)(R0), Z1",
+		"ZLDR (VL*1)(R0), Z1.B",
+		"ZSTR Z1.B, (VL*1)(R0)",
+		"ZSTR Z32, (VL*1)(R0)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvewholevectormemory(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvewholevectormemory": {Name: "badsvewholevectormemory", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE whole-vector memory forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_widening_add_sub.go b/arm64_lower_sve_widening_add_sub.go
new file mode 100644
index 000000000..b2a68ae62
--- /dev/null
+++ b/arm64_lower_sve_widening_add_sub.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEWideningAddSubKind uint8
+
+const (
+	arm64SVEAddSubLong arm64SVEWideningAddSubKind = iota
+	arm64SVEAddSubWide
+	arm64SVEAddSubNarrowBottom
+	arm64SVEAddSubNarrowTop
+)
+
+type arm64SVEWideningAddSubSpec struct {
+	intrinsic string
+	kind      arm64SVEWideningAddSubKind
+	rawBase   uint32
+}
+
+var arm64SVEWideningAddSubSpecs = map[Op]arm64SVEWideningAddSubSpec{
+	"ZADDHNB":  {intrinsic: "addhnb", kind: arm64SVEAddSubNarrowBottom},
+	"ZADDHNT":  {intrinsic: "addhnt", kind: arm64SVEAddSubNarrowTop},
+	"ZRADDHNB": {intrinsic: "raddhnb", kind: arm64SVEAddSubNarrowBottom},
+	"ZRADDHNT": {intrinsic: "raddhnt", kind: arm64SVEAddSubNarrowTop},
+	"ZSADDLB":  {intrinsic: "saddlb", kind: arm64SVEAddSubLong},
+	"ZSADDLBT": {intrinsic: "saddlbt", kind: arm64SVEAddSubLong},
+	"ZSADDLT":  {intrinsic: "saddlt", kind: arm64SVEAddSubLong},
+	"ZSADDWB":  {intrinsic: "saddwb", kind: arm64SVEAddSubWide, rawBase: 0x45004000},
+	"ZSADDWT":  {intrinsic: "saddwt", kind: arm64SVEAddSubWide, rawBase: 0x45004400},
+	"ZSSUBLB":  {intrinsic: "ssublb", kind: arm64SVEAddSubLong},
+	"ZSSUBLBT": {intrinsic: "ssublbt", kind: arm64SVEAddSubLong},
+	"ZSSUBLT":  {intrinsic: "ssublt", kind: arm64SVEAddSubLong},
+	"ZSSUBLTB": {intrinsic: "ssubltb", kind: arm64SVEAddSubLong},
+	"ZSSUBWB":  {intrinsic: "ssubwb", kind: arm64SVEAddSubWide, rawBase: 0x45005000},
+	"ZSSUBWT":  {intrinsic: "ssubwt", kind: arm64SVEAddSubWide, rawBase: 0x45005400},
+	"ZSUBHNB":  {intrinsic: "subhnb", kind: arm64SVEAddSubNarrowBottom},
+	"ZSUBHNT":  {intrinsic: "subhnt", kind: arm64SVEAddSubNarrowTop},
+	"ZRSUBHNB": {intrinsic: "rsubhnb", kind: arm64SVEAddSubNarrowBottom},
+	"ZRSUBHNT": {intrinsic: "rsubhnt", kind: arm64SVEAddSubNarrowTop},
+	"ZUADDLB":  {intrinsic: "uaddlb", kind: arm64SVEAddSubLong},
+	"ZUADDLT":  {intrinsic: "uaddlt", kind: arm64SVEAddSubLong},
+	"ZUADDWB":  {intrinsic: "uaddwb", kind: arm64SVEAddSubWide, rawBase: 0x45004800},
+	"ZUADDWT":  {intrinsic: "uaddwt", kind: arm64SVEAddSubWide, rawBase: 0x45004c00},
+	"ZUSUBLB":  {intrinsic: "usublb", kind: arm64SVEAddSubLong},
+	"ZUSUBLT":  {intrinsic: "usublt", kind: arm64SVEAddSubLong},
+	"ZUSUBWB":  {intrinsic: "usubwb", kind: arm64SVEAddSubWide, rawBase: 0x45005800},
+	"ZUSUBWT":  {intrinsic: "usubwt", kind: arm64SVEAddSubWide, rawBase: 0x45005c00},
+}
+
+var arm64SVEAddSubWideRawOps = func() map[uint32]Op {
+	rows := make(map[uint32]Op)
+	for op, spec := range arm64SVEWideningAddSubSpecs {
+		if spec.kind == arm64SVEAddSubWide && spec.rawBase != 0 {
+			rows[spec.rawBase] = op
+		}
+	}
+	return rows
+}()
+
+func decodeARM64RawSVEAddSubWide(word uint32) (Instr, bool) {
+	op, ok := arm64SVEAddSubWideRawOps[word&0xff20fc00]
+	size := word >> 22 & 3
+	if !ok || size == 0 {
+		return Instr{}, false
+	}
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>16&31, "BHSD"[size-1]))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, "BHSD"[size]))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, "BHSD"[size]))},
+	}}, true
+}
+
+type arm64SVEWideningAddSubForm struct {
+	sourceBits      int
+	destinationBits int
+	first           int
+	second          int
+	destination     int
+}
+
+func (c *arm64Ctx) lowerARM64SVEWideningAddSub(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEWideningAddSubSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects its three-register Go 1.27 SVE2 form without suffix: %q", op, ins.Raw)
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[0])
+	first, firstBits, firstOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	if !secondOK || !firstOK || !destinationOK {
+		return true, false, fmt.Errorf("arm64 %s requires three scalable vector element registers: %q", op, ins.Raw)
+	}
+	form := arm64SVEWideningAddSubForm{first: first, second: second, destination: destination, destinationBits: destinationBits}
+	switch spec.kind {
+	case arm64SVEAddSubLong:
+		if secondBits != firstBits || firstBits == 64 || destinationBits != 2*firstBits {
+			return true, false, fmt.Errorf("arm64 %s requires matching B/H/S sources widened to H/S/D: %q", op, ins.Raw)
+		}
+		form.sourceBits = firstBits
+	case arm64SVEAddSubWide:
+		if secondBits == 64 || firstBits != 2*secondBits || destinationBits != firstBits {
+			return true, false, fmt.Errorf("arm64 %s requires a narrow B/H/S source plus matching H/S/D wide source and destination: %q", op, ins.Raw)
+		}
+		form.sourceBits = secondBits
+	case arm64SVEAddSubNarrowBottom, arm64SVEAddSubNarrowTop:
+		if secondBits != firstBits || firstBits == 8 || destinationBits*2 != firstBits {
+			return true, false, fmt.Errorf("arm64 %s requires matching H/S/D sources narrowed to B/H/S: %q", op, ins.Raw)
+		}
+		form.sourceBits = firstBits
+	default:
+		return true, false, fmt.Errorf("arm64 %s has an unknown widening/narrowing form", op)
+	}
+	return true, false, c.lowerARM64SVEWideningAddSubForm(spec, form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEWideningAddSubForm(spec arm64SVEWideningAddSubSpec, form arm64SVEWideningAddSubForm) error {
+	first, firstType, err := c.loadZRegElements(form.first, map[arm64SVEWideningAddSubKind]int{arm64SVEAddSubLong: form.sourceBits, arm64SVEAddSubWide: form.destinationBits, arm64SVEAddSubNarrowBottom: form.sourceBits, arm64SVEAddSubNarrowTop: form.sourceBits}[spec.kind])
+	if err != nil {
+		return err
+	}
+	second, secondType, err := c.loadZRegElements(form.second, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	destinationType, destinationLanes, err := arm64SVEVectorType(form.destinationBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if spec.kind == arm64SVEAddSubNarrowTop {
+		merged, _, err := c.loadZRegElements(form.destination, form.destinationBits)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s, %s %s)\n", result, destinationType, spec.intrinsic, 128/form.sourceBits, form.sourceBits, destinationType, merged, firstType, first, secondType, second)
+	} else if spec.kind == arm64SVEAddSubNarrowBottom {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, destinationType, spec.intrinsic, 128/form.sourceBits, form.sourceBits, firstType, first, secondType, second)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv%di%d(%s %s, %s %s)\n", result, destinationType, spec.intrinsic, destinationLanes, form.destinationBits, firstType, first, secondType, second)
+	}
+	return c.storeZRegElements(form.destination, form.destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_widening_add_sub_test.go b/arm64_lower_sve_widening_add_sub_test.go
new file mode 100644
index 000000000..e3ac49fed
--- /dev/null
+++ b/arm64_lower_sve_widening_add_sub_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64SVEWideningAddSubCompleteForms() string {
+	var source strings.Builder
+	source.WriteString("TEXT svewidenaddsubforms(SB),$0-0\n")
+	for _, op := range []string{
+		"ZSADDLB", "ZSADDLBT", "ZSADDLT",
+		"ZSSUBLB", "ZSSUBLBT", "ZSSUBLT", "ZSSUBLTB",
+		"ZUADDLB", "ZUADDLT", "ZUSUBLB", "ZUSUBLT",
+	} {
+		for _, width := range []string{"B", "H", "S"} {
+			destinationWidth := map[string]string{"B": "H", "H": "S", "S": "D"}[width]
+			source.WriteString("\t" + op + " Z1." + width + ", Z2." + width + ", Z3." + destinationWidth + "\n")
+		}
+	}
+	for _, op := range []string{
+		"ZSADDWB", "ZSADDWT", "ZSSUBWB", "ZSSUBWT",
+		"ZUADDWB", "ZUADDWT", "ZUSUBWB", "ZUSUBWT",
+	} {
+		for _, narrowWidth := range []string{"B", "H", "S"} {
+			wideWidth := map[string]string{"B": "H", "H": "S", "S": "D"}[narrowWidth]
+			source.WriteString("\t" + op + " Z4." + narrowWidth + ", Z5." + wideWidth + ", Z6." + wideWidth + "\n")
+		}
+	}
+	for _, op := range []string{
+		"ZADDHNB", "ZADDHNT", "ZRADDHNB", "ZRADDHNT",
+		"ZSUBHNB", "ZSUBHNT", "ZRSUBHNB", "ZRSUBHNT",
+	} {
+		for _, wideWidth := range []string{"H", "S", "D"} {
+			narrowWidth := map[string]string{"H": "B", "S": "H", "D": "S"}[wideWidth]
+			source.WriteString("\t" + op + " Z7." + wideWidth + ", Z8." + wideWidth + ", Z9." + narrowWidth + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64SVEWideningAddSubCompleteGo127Family(t *testing.T) {
+	source := arm64SVEWideningAddSubCompleteForms()
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svewidenaddsubforms": {Name: "svewidenaddsubforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.saddlb.nxv8i16",
+				"@llvm.aarch64.sve.saddlbt.nxv4i32",
+				"@llvm.aarch64.sve.ssubltb.nxv2i64",
+				"@llvm.aarch64.sve.uaddlt.nxv8i16",
+				"@llvm.aarch64.sve.usublt.nxv2i64",
+				"@llvm.aarch64.sve.saddwb.nxv8i16",
+				"@llvm.aarch64.sve.usubwt.nxv2i64",
+				"@llvm.aarch64.sve.addhnb.nxv8i16",
+				"@llvm.aarch64.sve.raddhnt.nxv4i32",
+				"@llvm.aarch64.sve.rsubhnb.nxv2i64",
+				"@llvm.aarch64.sve.subhnt.nxv8i16",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE widening/narrowing add/sub lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-widening-add-sub.ll", "arm64-sve-widening-add-sub.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEWideningAddSubRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZSADDLB Z1.B, Z2.H, Z3.H",
+		"ZSADDLT Z1.B, Z2.B, Z3.S",
+		"ZUADDLB Z1.D, Z2.D, Z3.D",
+		"ZSSUBLBT Z1.H, Z2.H, Z3.H",
+		"ZSSUBLTB Z1.S, Z2.H, Z3.D",
+		"ZSADDWB Z1.B, Z2.B, Z3.H",
+		"ZUADDWT Z1.S, Z2.S, Z3.D",
+		"ZSSUBWB Z1.D, Z2.D, Z3.D",
+		"ZUSUBWT Z1.H, Z2.S, Z3.H",
+		"ZADDHNB Z1.B, Z2.B, Z3.B",
+		"ZRADDHNT Z1.S, Z2.S, Z3.S",
+		"ZSUBHNB Z1.D, Z2.S, Z3.S",
+		"ZRSUBHNT Z1.D, Z2.D, Z3.H",
+		"ZSADDLB.Z Z1.B, Z2.B, Z3.H",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvewidenaddsub(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvewidenaddsub": {Name: "badsvewidenaddsub", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SVE widening/narrowing add/sub forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_widening_float_mla.go b/arm64_lower_sve_widening_float_mla.go
new file mode 100644
index 000000000..3f633b28c
--- /dev/null
+++ b/arm64_lower_sve_widening_float_mla.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64SVEWideningFloatMLASpec struct {
+	intrinsic string
+	fp16      bool
+	fp8ToHalf bool
+	fp8ToWord bool
+}
+
+var arm64SVEWideningFloatMLASpecs = map[Op]arm64SVEWideningFloatMLASpec{
+	"ZFMLALB":   {intrinsic: "fmlalb", fp16: true, fp8ToHalf: true},
+	"ZFMLALT":   {intrinsic: "fmlalt", fp16: true, fp8ToHalf: true},
+	"ZFMLSLB":   {intrinsic: "fmlslb", fp16: true},
+	"ZFMLSLT":   {intrinsic: "fmlslt", fp16: true},
+	"ZFMLALLBB": {intrinsic: "fmlallbb", fp8ToWord: true},
+	"ZFMLALLBT": {intrinsic: "fmlallbt", fp8ToWord: true},
+	"ZFMLALLTB": {intrinsic: "fmlalltb", fp8ToWord: true},
+	"ZFMLALLTT": {intrinsic: "fmlalltt", fp8ToWord: true},
+}
+
+type arm64SVEWideningFloatMLAForm struct {
+	intrinsic                   string
+	first, second, destination  int
+	sourceBits, destinationBits int
+	lane                        int
+	indexed                     bool
+}
+
+func (c *arm64Ctx) lowerARM64SVEWideningFloatMLA(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, ok := arm64SVEWideningFloatMLASpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects one complete Go 1.27 vector or indexed widening floating multiply-accumulate form without a suffix: %q", op, ins.Raw)
+	}
+	form := arm64SVEWideningFloatMLAForm{intrinsic: spec.intrinsic}
+	if first, sourceBits, firstOK := arm64ParseSVEZElementReg(ins.Args[0]); firstOK {
+		form.first, form.sourceBits = first, sourceBits
+	} else {
+		first, sourceBits, lane, firstOK := arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+		if !firstOK || first > 7 {
+			return true, false, fmt.Errorf("arm64 %s indexed source must use Z0..Z7: %q", op, ins.Raw)
+		}
+		form.first, form.sourceBits, form.lane, form.indexed = first, sourceBits, lane, true
+	}
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64SVEFloatElementReg(ins.Args[2])
+	validWidth := form.sourceBits == 16 && destinationBits == 32 && spec.fp16 ||
+		form.sourceBits == 8 && destinationBits == 16 && spec.fp8ToHalf ||
+		form.sourceBits == 8 && destinationBits == 32 && spec.fp8ToWord
+	if !secondOK || !destinationOK || secondBits != form.sourceBits || !validWidth {
+		return true, false, fmt.Errorf("arm64 %s source/destination widths are outside its complete Go 1.27 forms: %q", op, ins.Raw)
+	}
+	if form.indexed {
+		maxLane := map[int]int{8: 15, 16: 7}[form.sourceBits]
+		if form.lane > maxLane {
+			return true, false, fmt.Errorf("arm64 %s indexed lane exceeds the Go 1.27 range for its source width: %q", op, ins.Raw)
+		}
+	}
+	form.second, form.destination, form.destinationBits = second, destination, destinationBits
+	return true, false, c.lowerARM64SVEWideningFloatMLAForm(form)
+}
+
+func (c *arm64Ctx) lowerARM64SVEWideningFloatMLAForm(form arm64SVEWideningFloatMLAForm) error {
+	accumulator, accumulatorType, err := c.loadRawSVEFloatVector(form.destination, form.destinationBits)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	lanes := 128 / form.destinationBits
+	mangle := map[int]string{16: "f16", 32: "f32"}[form.destinationBits]
+	if form.sourceBits == 8 {
+		first, err := c.loadZReg(form.first)
+		if err != nil {
+			return err
+		}
+		second, err := c.loadZReg(form.second)
+		if err != nil {
+			return err
+		}
+		if form.indexed {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fp8.%s.lane.nxv%d%s(%s %s, <vscale x 16 x i8> %s, <vscale x 16 x i8> %s, i32 %d)\n", result, accumulatorType, form.intrinsic, lanes, mangle, accumulatorType, accumulator, second, first, form.lane)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.fp8.%s.nxv%d%s(%s %s, <vscale x 16 x i8> %s, <vscale x 16 x i8> %s)\n", result, accumulatorType, form.intrinsic, lanes, mangle, accumulatorType, accumulator, second, first)
+		}
+	} else {
+		first, sourceType, err := c.loadRawSVEFloatVector(form.first, 16)
+		if err != nil {
+			return err
+		}
+		second, _, err := c.loadRawSVEFloatVector(form.second, 16)
+		if err != nil {
+			return err
+		}
+		if form.indexed {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.lane.nxv4f32(%s %s, %s %s, %s %s, i32 %d)\n", result, accumulatorType, form.intrinsic, accumulatorType, accumulator, sourceType, second, sourceType, first, form.lane)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.%s.nxv4f32(%s %s, %s %s, %s %s)\n", result, accumulatorType, form.intrinsic, accumulatorType, accumulator, sourceType, second, sourceType, first)
+		}
+	}
+	return c.storeRawSVEFloatVector(form.destination, form.destinationBits, "%"+result, accumulatorType)
+}
+
+func arm64SVEWideningFloatMLAFeatureClass(ins Instr) (sourceBits int, ok bool) {
+	if len(ins.Args) != 3 {
+		return 0, false
+	}
+	_, sourceBits, sourceOK := arm64ParseSVEZElementReg(ins.Args[0])
+	if !sourceOK {
+		_, sourceBits, _, sourceOK = arm64ParseSVEZIndexedElementRegUnbounded(ins.Args[0])
+	}
+	return sourceBits, sourceOK
+}
diff --git a/arm64_lower_sve_widening_float_mla_test.go b/arm64_lower_sve_widening_float_mla_test.go
new file mode 100644
index 000000000..efe3c4fe5
--- /dev/null
+++ b/arm64_lower_sve_widening_float_mla_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEWideningFloatMLACompleteGo127Family(t *testing.T) {
+	const source = `TEXT svefmlhalf(SB),$0-0
+	ZFMLALB Z0.H, Z1.H, Z2.S
+	ZFMLALB Z7.H[7], Z3.H, Z4.S
+	ZFMLALT Z5.H, Z6.H, Z7.S
+	ZFMLALT Z0.H[0], Z8.H, Z9.S
+	ZFMLSLB Z10.H, Z11.H, Z12.S
+	ZFMLSLB Z7.H[7], Z13.H, Z14.S
+	ZFMLSLT Z15.H, Z16.H, Z17.S
+	ZFMLSLT Z0.H[0], Z18.H, Z19.S
+	RET
+TEXT svefmlfp8(SB),$0-0
+	ZFMLALB Z20.B, Z21.B, Z22.H
+	ZFMLALB Z7.B[15], Z23.B, Z24.H
+	ZFMLALT Z25.B, Z26.B, Z27.H
+	ZFMLALT Z0.B[0], Z28.B, Z29.H
+	ZFMLALLBB Z1.B, Z2.B, Z3.S
+	ZFMLALLBB Z7.B[15], Z4.B, Z5.S
+	ZFMLALLBT Z6.B, Z7.B, Z8.S
+	ZFMLALLBT Z0.B[0], Z9.B, Z10.S
+	ZFMLALLTB Z11.B, Z12.B, Z13.S
+	ZFMLALLTB Z7.B[15], Z14.B, Z15.S
+	ZFMLALLTT Z16.B, Z17.B, Z18.S
+	ZFMLALLTT Z0.B[0], Z19.B, Z20.S
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{
+				"svefmlhalf": {Name: "svefmlhalf", Ret: Void},
+				"svefmlfp8":  {Name: "svefmlfp8", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				`"target-features"="+fp8,+ssve-fp8fma,+sve,+sve2,+sve2p2"`,
+				"@llvm.aarch64.sve.fmlalb.nxv4f32",
+				"@llvm.aarch64.sve.fmlalb.lane.nxv4f32",
+				"@llvm.aarch64.sve.fmlalt.nxv4f32",
+				"@llvm.aarch64.sve.fmlalt.lane.nxv4f32",
+				"@llvm.aarch64.sve.fmlslb.nxv4f32",
+				"@llvm.aarch64.sve.fmlslb.lane.nxv4f32",
+				"@llvm.aarch64.sve.fmlslt.nxv4f32",
+				"@llvm.aarch64.sve.fmlslt.lane.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlalb.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fmlalb.lane.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fmlalt.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fmlalt.lane.nxv8f16",
+				"@llvm.aarch64.sve.fp8.fmlallbb.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlallbb.lane.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlallbt.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlallbt.lane.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlalltb.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlalltb.lane.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlalltt.nxv4f32",
+				"@llvm.aarch64.sve.fp8.fmlalltt.lane.nxv4f32",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s widening floating MLA lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-widening-fml.ll", "arm64-sve-widening-fml.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEWideningFloatMLARejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZFMLALB Z8.H[0], Z2.H, Z3.S",
+		"ZFMLALT Z7.H[8], Z2.H, Z3.S",
+		"ZFMLSLB Z1.B, Z2.B, Z3.H",
+		"ZFMLSLT Z1.H, Z2.H, Z3.H",
+		"ZFMLALB Z8.B[0], Z2.B, Z3.H",
+		"ZFMLALT Z7.B[16], Z2.B, Z3.H",
+		"ZFMLALLBB Z8.B[0], Z2.B, Z3.S",
+		"ZFMLALLBT Z7.B[16], Z2.B, Z3.S",
+		"ZFMLALLTB Z1.B, Z2.H, Z3.S",
+		"ZFMLALLTT Z1.B, Z2.B, Z3.H",
+		"ZFMLALB.Z Z1.H, Z2.H, Z3.S",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvefml(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvefml": {Name: "badsvefml", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's widening floating MLA forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sve_xar.go b/arm64_lower_sve_xar.go
new file mode 100644
index 000000000..d9bc8f3d2
--- /dev/null
+++ b/arm64_lower_sve_xar.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+)
+
+func decodeARM64RawSVEXAR(word uint32) (Instr, bool) {
+	if word&0xff20fc00 != 0x04203400 {
+		return Instr{}, false
+	}
+	encoded := int(word>>16&31 | word>>17&96)
+	if encoded < 8 { // tsize=0000 is unallocated.
+		return Instr{}, false
+	}
+	size := bits.Len(uint(encoded)) - 4
+	elementBits := 8 << size
+	width := "BHSD"[size]
+	destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))}
+	return Instr{Op: "ZXAR", Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpImm, Imm: int64(2*elementBits - encoded)},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+		destination, destination,
+	}}, true
+}
+
+func (c *arm64Ctx) lowerARM64RawSVEXAR(ins Instr) error {
+	second, width, _ := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, _, _ := arm64ParseSVEZElementReg(ins.Args[2])
+	return c.lowerARM64SVEXARForm(destination, second, width, ins.Args[0].Imm)
+}
+
+func (c *arm64Ctx) lowerARM64SVEXAR(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "ZXAR" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 ZXAR expects $shift, Zm.T, Zdn.T, Zdn.T without a suffix: %q", ins.Raw)
+	}
+	shift := ins.Args[0].Imm
+	second, secondBits, secondOK := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, destinationBits, destinationOK := arm64ParseSVEZElementReg(ins.Args[2])
+	repeatedDestination, repeatedBits, repeatedOK := arm64ParseSVEZElementReg(ins.Args[3])
+	if !secondOK || !destinationOK || !repeatedOK || secondBits != destinationBits || repeatedBits != destinationBits || repeatedDestination != destination || shift < 1 || shift >= int64(destinationBits) {
+		return true, false, fmt.Errorf("arm64 ZXAR requires matching destructive B/H/S/D operands and shift $1..$elementBits-1: %q", ins.Raw)
+	}
+	return true, false, c.lowerARM64SVEXARForm(destination, second, destinationBits, shift)
+}
+
+func (c *arm64Ctx) lowerARM64SVEXARForm(destination, second, destinationBits int, shift int64) error {
+	destinationValue, vectorType, err := c.loadZRegElements(destination, destinationBits)
+	if err != nil {
+		return err
+	}
+	secondValue, _, err := c.loadZRegElements(second, destinationBits)
+	if err != nil {
+		return err
+	}
+	lanes := 128 / destinationBits
+	result := c.newTmp()
+	if shift == int64(destinationBits) {
+		// Architectural WORD encodings include a full-width rotation. Go's
+		// named encoder rejects this spelling; preserve that frontend boundary.
+		fmt.Fprintf(c.b, "  %%%s = xor %s %s, %s\n", result, vectorType, destinationValue, secondValue)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.xar.nxv%di%d(%s %s, %s %s, i32 %d)\n", result, vectorType, lanes, destinationBits, vectorType, destinationValue, vectorType, secondValue, shift)
+	}
+	return c.storeZRegElements(destination, destinationBits, "%"+result)
+}
diff --git a/arm64_lower_sve_xar_test.go b/arm64_lower_sve_xar_test.go
new file mode 100644
index 000000000..85077ab05
--- /dev/null
+++ b/arm64_lower_sve_xar_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SVEXARCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT svexar(SB),$0-0\n")
+	for widthIndex, width := range []struct {
+		suffix string
+		bits   int
+	}{{"B", 8}, {"H", 16}, {"S", 32}, {"D", 64}} {
+		for boundaryIndex, shift := range []int{1, width.bits - 1} {
+			destination := widthIndex*2 + boundaryIndex
+			fmt.Fprintf(&source, "\tZXAR $%d, Z%d.%s, Z%d.%s, Z%d.%s\n", shift, destination+1, width.suffix, destination, width.suffix, destination, width.suffix)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"svexar": {Name: "svexar", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve,+sve2"`,
+				"@llvm.aarch64.sve.xar.nxv16i8",
+				"@llvm.aarch64.sve.xar.nxv8i16",
+				"@llvm.aarch64.sve.xar.nxv4i32",
+				"@llvm.aarch64.sve.xar.nxv2i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("%s SVE XAR lowering omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-xar.ll", "arm64-sve-xar.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SVEXARRejectsFormsOutsideGo127Table(t *testing.T) {
+	for _, instruction := range []string{
+		"ZXAR $0, Z1.B, Z2.B, Z2.B",
+		"ZXAR $8, Z1.B, Z2.B, Z2.B",
+		"ZXAR $16, Z1.H, Z2.H, Z2.H",
+		"ZXAR $32, Z1.S, Z2.S, Z2.S",
+		"ZXAR $64, Z1.D, Z2.D, Z2.D",
+		"ZXAR $1, Z1.H, Z2.S, Z2.S",
+		"ZXAR $1, Z1.D, Z2.D, Z3.D",
+		"ZXAR.Z $1, Z1.B, Z2.B, Z2.B",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ".", "_", ",", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badsvexar(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64SVEGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badsvexar": {Name: "badsvexar", Ret: Void}}}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's XAR forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_sys.go b/arm64_lower_sys.go
new file mode 100644
index 000000000..f2df4e7b7
--- /dev/null
+++ b/arm64_lower_sys.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+const arm64SYSArgumentMask int64 = 7<<16 | 15<<12 | 15<<8 | 7<<5
+
+type arm64SYSFields struct {
+	op1 uint8
+	cn  uint8
+	cm  uint8
+	op2 uint8
+}
+
+func decodeARM64SYSArgument(arg int64) (arm64SYSFields, bool) {
+	if arg < 0 || arg&^arm64SYSArgumentMask != 0 {
+		return arm64SYSFields{}, false
+	}
+	return arm64SYSFields{
+		op1: uint8(arg >> 16 & 7),
+		cn:  uint8(arg >> 12 & 15),
+		cm:  uint8(arg >> 8 & 15),
+		op2: uint8(arg >> 5 & 7),
+	}, true
+}
+
+func (f arm64SYSFields) operandString() string {
+	return fmt.Sprintf("#%d, c%d, c%d, #%d", f.op1, f.cn, f.cm, f.op2)
+}
+
+func (c *arm64Ctx) lowerARM64SYS(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "SYS" && op != "SYSL" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) == 0 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 %s expects a resolved system-argument constant: %q", op, ins.Raw)
+	}
+	fields, valid := decodeARM64SYSArgument(ins.Args[0].Imm)
+	if !valid {
+		return true, false, fmt.Errorf("arm64 %s system argument is outside Go's SYSARG4 encoding: %q", op, ins.Raw)
+	}
+
+	if op == "SYS" {
+		if len(ins.Args) == 1 {
+			asm := "sys " + fields.operandString() + ", xzr"
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", asm, "~{memory}")
+			return true, false, nil
+		}
+		if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+			return true, false, fmt.Errorf("arm64 SYS expects a system argument and optional R/ZR operand: %q", ins.Raw)
+		}
+		if ins.Args[1].Reg == ZR {
+			asm := "sys " + fields.operandString() + ", xzr"
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", asm, "~{memory}")
+			return true, false, nil
+		}
+		value, err := c.loadReg(ins.Args[1].Reg)
+		if err != nil {
+			return true, false, err
+		}
+		asm := "sys " + fields.operandString() + ", $0"
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", asm, "r,~{memory}", value)
+		return true, false, nil
+	}
+
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 SYSL expects a system argument and one R/ZR destination: %q", ins.Raw)
+	}
+	result := c.newTmp()
+	asm := "sysl $0, " + fields.operandString()
+	fmt.Fprintf(c.b, "  %%%s = call i64 asm sideeffect %q, %q()\n", result, asm, "=r,~{memory}")
+	if ins.Args[1].Reg != ZR {
+		if err := c.storeReg(ins.Args[1].Reg, "%"+result); err != nil {
+			return true, false, err
+		}
+	}
+	return true, false, nil
+}
diff --git a/arm64_lower_sys_test.go b/arm64_lower_sys_test.go
new file mode 100644
index 000000000..7ae7b0fc4
--- /dev/null
+++ b/arm64_lower_sys_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64SYSCompleteGoAssemblerForms(t *testing.T) {
+	const source = `TEXT sysforms(SB),$0-0
+	SYS $0
+	SYS $0x37520, R3
+	SYS $0x7ffe0, ZR
+	SYSL $0, R12
+	SYSL $0x7ffe0, ZR
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"sysforms": {Name: "sysforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "sys #0, c0, c0, #0, xzr"`,
+				`asm sideeffect "sys #3, c7, c5, #1, $0"`,
+				`asm sideeffect "sys #7, c15, c15, #7, xzr"`,
+				`asm sideeffect "sysl $0, #0, c0, c0, #0"`,
+				`asm sideeffect "sysl $0, #7, c15, c15, #7"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 SYS/SYSL lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sys.ll", "arm64-sys.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64SYSRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"SYS $1",
+		"SYS $0x80000",
+		"SYS $0, R1, R2",
+		"SYS R1",
+		"SYS.P $0",
+		"SYSL $0",
+		"SYSL $0, $1",
+		"SYSL $0, R1, R2",
+		"SYSL.P $0, R1",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's SYS/SYSL forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_syscall.go b/arm64_lower_syscall.go
index 3c0d58f17..5d8ae4564 100644
--- a/arm64_lower_syscall.go
+++ b/arm64_lower_syscall.go
@@ -5,25 +5,22 @@ import "fmt"
 func (c *arm64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err error) {
 	switch op {
 	case "SVC":
-		if len(ins.Args) > 1 || (len(ins.Args) == 1 && ins.Args[0].Kind != OpImm) {
-			return true, false, fmt.Errorf("arm64 SVC expects optional immediate operand: %q", ins.Raw)
-		}
-
-		darwinMode := false
-		if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].Imm == 0x80 {
-			darwinMode = true
+		form, err := parseARM64SyscallForm(c.targetTriple, ins)
+		if err != nil {
+			return true, false, err
 		}
-
-		numReg := Reg("R8")
-		if _, ok := c.regSlot[numReg]; !ok {
-			// Darwin syscall asm passes trap number via R16.
-			numReg = Reg("R16")
+		input, borrowed := c.nanosleepInputAt([2]int{c.currentBlock, c.currentInstruction})
+		if c.nanosleepInput != nil && (!borrowed || input.form != form) {
+			return true, false, fmt.Errorf("%w: changed Linux nanosleep input/emission", ErrProbeNeedsContext)
 		}
-		num, err := c.loadReg(numReg)
+		num, err := c.loadReg(form.number)
 		if err != nil {
 			return true, false, err
 		}
 		loadArg := func(r Reg) (string, error) {
+			if borrowed && r != "R0" && r != "R1" {
+				return "0", nil // these registers are not nanosleep operand roles
+			}
 			if _, ok := c.regSlot[r]; !ok {
 				return "0", nil
 			}
@@ -56,15 +53,15 @@ func (c *arm64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err
 		}
 
 		r := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i64 @syscall(i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s)\n", r, num, a1, a2, a3, a4, a5, a6)
+		c.emitARM64SyscallIR(form, "  %%%s = call i64 @syscall(i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s, i64 %s)\n", r, num, a1, a2, a3, a4, a5, a6)
 		isErr := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %%%s, -1\n", isErr, r)
 		errno32 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = call i32 @cliteErrno()\n", errno32)
+		c.emitARM64SyscallIR(form, "  %%%s = call i32 @cliteErrno()\n", errno32)
 		errno64 := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", errno64, errno32)
 
-		if darwinMode {
+		if form.os == arm64SyscallDarwinCarry {
 			// Darwin syscall asm checks carry flag (BCC) after SVC:
 			// - C=0 success, R0=r1
 			// - C=1 error,   R0=errno
@@ -73,18 +70,14 @@ func (c *arm64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err
 			if err := c.storeReg(Reg("R0"), "%"+r0); err != nil {
 				return true, false, err
 			}
-			if err := c.storeReg(Reg("R1"), "0"); err != nil {
-				return true, false, err
-			}
-			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsNSlot)
-			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsZSlot)
-			fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", isErr, c.flagsCSlot)
-			fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsVSlot)
-			c.flagsWritten = true
+			c.recordMachineUnavailable("R1")
+			c.invalidateARM64Flags(form.flagsUnavailable)
+			c.storeFlag(c.flagsCSlot, "%"+isErr)
 			return true, false, nil
 		}
 
-		// Default path (Linux-like): return -errno on failure in R0.
+		// Linux's normal return writes R0 only. Other GP and existing NZCV
+		// values remain intact; SVC never supplies an uninitialized flag.
 		negErr := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = sub i64 0, %%%s\n", negErr, errno64)
 		r0 := c.newTmp()
@@ -92,15 +85,6 @@ func (c *arm64Ctx) lowerSyscall(op Op, ins Instr) (ok bool, terminated bool, err
 		if err := c.storeReg(Reg("R0"), "%"+r0); err != nil {
 			return true, false, err
 		}
-		// libc syscall has a single return value; keep R1 zero.
-		if err := c.storeReg(Reg("R1"), "0"); err != nil {
-			return true, false, err
-		}
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsNSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsZSlot)
-		fmt.Fprintf(c.b, "  store i1 %%%s, ptr %s\n", isErr, c.flagsCSlot)
-		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.flagsVSlot)
-		c.flagsWritten = true
 		return true, false, nil
 	}
 	return false, false, nil
diff --git a/arm64_lower_table_lookup.go b/arm64_lower_table_lookup.go
new file mode 100644
index 000000000..21facb090
--- /dev/null
+++ b/arm64_lower_table_lookup.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorTableLookup(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VTBL" && op != "VTBX" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpRegList || ins.Args[2].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects Vindex.B8/B16, [Vtable...], Vdest.B8/B16 and no suffix: %q", op, ins.Raw)
+	}
+	indexArrangement, indexOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	byteVector := func(a arm64VectorArrangement) bool {
+		return a.elementBits == 8 && (a.lanes == 8 || a.lanes == 16)
+	}
+	if !indexOK || !destinationOK || indexArrangement != destinationArrangement || !byteVector(indexArrangement) {
+		return true, false, fmt.Errorf("arm64 %s requires matching B8 or B16 index and destination arrangements: %q", op, ins.Raw)
+	}
+	tables := ins.Args[1].RegList
+	if len(tables) < 1 || len(tables) > 4 {
+		return true, false, fmt.Errorf("arm64 %s requires one through four table registers: %q", op, ins.Raw)
+	}
+	firstTableArrangement, firstArrangementOK := parseARM64VectorArrangement(tables[0])
+	firstTable, firstTableOK := arm64ParseVReg(tables[0])
+	if !firstArrangementOK || !firstTableOK {
+		return true, false, fmt.Errorf("arm64 %s requires arranged table registers: %q", op, ins.Raw)
+	}
+	for i, table := range tables {
+		arrangement, arrangementOK := parseARM64VectorArrangement(table)
+		register, registerOK := arm64ParseVReg(table)
+		if !arrangementOK || arrangement != firstTableArrangement || !registerOK || register != (firstTable+i)%32 {
+			return true, false, fmt.Errorf("arm64 %s requires consecutive table registers with a consistent arrangement: %q", op, ins.Raw)
+		}
+	}
+
+	index, err := c.loadARM64VectorInteger(ins.Args[0].Reg, indexArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	tableBytes := len(tables) * 16
+	tableType := fmt.Sprintf("<%d x i8>", tableBytes)
+	tableVector := "poison"
+	for tableIndex := range tables {
+		register := Reg(fmt.Sprintf("V%d.B16", (firstTable+tableIndex)%32))
+		loaded, err := c.loadARM64VectorInteger(register, arm64VectorArrangement{elementBits: 8, lanes: 16})
+		if err != nil {
+			return true, false, err
+		}
+		for lane := 0; lane < 16; lane++ {
+			element := c.newTmp()
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i8> %s, i32 %d\n", element, loaded, lane)
+			fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i8 %%%s, i32 %d\n", inserted, tableType, tableVector, element, tableIndex*16+lane)
+			tableVector = "%" + inserted
+		}
+	}
+	result := "zeroinitializer"
+	destination := ""
+	if op == "VTBX" {
+		destination, err = c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	for lane := 0; lane < indexArrangement.lanes; lane++ {
+		indexByte := c.newTmp()
+		index32 := c.newTmp()
+		inRange := c.newTmp()
+		safeIndex := c.newTmp()
+		lookup := c.newTmp()
+		selected := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", indexByte, indexArrangement.lanes, index, lane)
+		fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i32\n", index32, indexByte)
+		fmt.Fprintf(c.b, "  %%%s = icmp ult i32 %%%s, %d\n", inRange, index32, tableBytes)
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %%%s, i32 0\n", safeIndex, inRange, index32)
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %s, i32 %%%s\n", lookup, tableType, tableVector, safeIndex)
+		fallback := "0"
+		if op == "VTBX" {
+			old := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i8> %s, i32 %d\n", old, destinationArrangement.lanes, destination, lane)
+			fallback = "%" + old
+		}
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i8 %%%s, i8 %s\n", selected, inRange, lookup, fallback)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i8> %s, i8 %%%s, i32 %d\n", inserted, destinationArrangement.lanes, result, selected, lane)
+		result = "%" + inserted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, result)
+}
diff --git a/arm64_lower_table_lookup_test.go b/arm64_lower_table_lookup_test.go
new file mode 100644
index 000000000..1a76ad631
--- /dev/null
+++ b/arm64_lower_table_lookup_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorTableLookupCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT vectortablelookupforms(SB),$0-0\n")
+	for _, op := range []string{"VTBL", "VTBX"} {
+		for _, arrangement := range []string{"B8", "B16"} {
+			for _, tableArrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D1", "D2"} {
+				for count := 1; count <= 4; count++ {
+					fmt.Fprintf(&source, "\t%s V8.%s, %s, V9.%s\n", op, arrangement, arm64TestVectorList(30, count, tableArrangement), arrangement)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectortablelookupforms": {Name: "vectortablelookupforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"icmp ult i32", "extractelement", "insertelement", "select i1"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 vector table lookup lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-table-lookup.ll", "arm64-vector-table-lookup.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorTableLookupRejectsInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VTBL V0.B16, [V1.B16, V3.B16], V4.B16",
+		"VTBL V0.B16, [V1.B8, V2.H8], V4.B16",
+		"VTBX V0.B8, [V1.B16], V4.B16",
+		"VTBL V0.H8, [V1.B16], V4.H8",
+		"VTBL V0.B16, [V1.B16, V2.B16, V3.B16, V4.B16, V5.B16], V6.B16",
+		"VTBL.P V0.B16, [V1.B16], V4.B16",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectortablelookup(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+				Sigs: map[string]FuncSig{"badvectortablelookup": {Name: "badvectortablelookup", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted invalid vector table lookup form %q", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorTableLookupRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectortablelookup(SB),$0-32
+	MOVD table+0(FP), R0
+	MOVD indices+8(FP), R1
+	MOVD initial+16(FP), R2
+	MOVD out+24(FP), R3
+	VLD1 (R0), [V0.B16, V1.B16, V2.B16, V3.B16]
+	VLD1 (R1), [V4.B16]
+	VTBL V4.B16, [V0.B16, V1.B16, V2.B16, V3.B16], V5.B16
+	VST1.P [V5.B16], 16(R3)
+	VLD1 (R2), [V6.B16]
+	VTBX V4.B16, [V0.B16, V1.B16, V2.B16, V3.B16], V6.B16
+	VST1 [V6.B16], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"vectortablelookup": {
+				Name: "vectortablelookup", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectortablelookup(const uint8_t *, const uint8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  uint8_t table[64], initial[16], got[32] = {0};
+  const uint8_t indices[16] = {0,15,16,31,32,47,48,63,64,255,7,23,39,55,62,1};
+  for (int i = 0; i < 64; i++) table[i] = (uint8_t)(10+i);
+  for (int i = 0; i < 16; i++) initial[i] = (uint8_t)(200+i);
+  vectortablelookup(table, indices, initial, got);
+  for (int i = 0; i < 16; i++) {
+    uint8_t tbl = indices[i] < 64 ? table[indices[i]] : 0;
+    uint8_t tbx = indices[i] < 64 ? table[indices[i]] : initial[i];
+    if (got[i] != tbl) return i + 1;
+    if (got[16+i] != tbx) return i + 21;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_table_lookup", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_tlbi.go b/arm64_lower_tlbi.go
new file mode 100644
index 000000000..c40ad4688
--- /dev/null
+++ b/arm64_lower_tlbi.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+type arm64TLBIOperation struct {
+	arm64SystemFields
+	hasOperand bool
+}
+
+type arm64RawTLBI struct {
+	operation string
+	register  Reg
+}
+
+func decodeARM64RawTLBI(word uint32) (arm64RawTLBI, bool) {
+	if word&0xffe0001f != 0xd500001f || (word>>12)&15 != 8 {
+		return arm64RawTLBI{}, false
+	}
+	op1 := uint8((word >> 16) & 7)
+	cm := uint8((word >> 8) & 15)
+	op2 := uint8((word >> 5) & 7)
+	register := ZR
+	if word&31 != 31 {
+		register = Reg(fmt.Sprintf("R%d", word&31))
+	}
+	for name, operation := range arm64TLBIOperations {
+		if operation.op1 == op1 && operation.cm == cm && operation.op2 == op2 {
+			if !operation.hasOperand && register != ZR {
+				return arm64RawTLBI{}, false
+			}
+			return arm64RawTLBI{operation: name, register: register}, true
+		}
+	}
+	return arm64RawTLBI{}, false
+}
+
+// arm64TLBIOperations is the TLBI portion of Go's ARM64 sysInstFields table.
+// Keeping the table explicit prevents an arbitrary SYS encoding from being
+// accepted under a TLBI alias.
+var arm64TLBIOperations = map[string]arm64TLBIOperation{
+	"VMALLE1IS": {arm64SystemFields{0, 3, 0}, false}, "VAE1IS": {arm64SystemFields{0, 3, 1}, true},
+	"ASIDE1IS": {arm64SystemFields{0, 3, 2}, true}, "VAAE1IS": {arm64SystemFields{0, 3, 3}, true},
+	"VALE1IS": {arm64SystemFields{0, 3, 5}, true}, "VAALE1IS": {arm64SystemFields{0, 3, 7}, true},
+	"VMALLE1": {arm64SystemFields{0, 7, 0}, false}, "VAE1": {arm64SystemFields{0, 7, 1}, true},
+	"ASIDE1": {arm64SystemFields{0, 7, 2}, true}, "VAAE1": {arm64SystemFields{0, 7, 3}, true},
+	"VALE1": {arm64SystemFields{0, 7, 5}, true}, "VAALE1": {arm64SystemFields{0, 7, 7}, true},
+	"IPAS2E1IS": {arm64SystemFields{4, 0, 1}, true}, "IPAS2LE1IS": {arm64SystemFields{4, 0, 5}, true},
+	"ALLE2IS": {arm64SystemFields{4, 3, 0}, false}, "VAE2IS": {arm64SystemFields{4, 3, 1}, true},
+	"ALLE1IS": {arm64SystemFields{4, 3, 4}, false}, "VALE2IS": {arm64SystemFields{4, 3, 5}, true},
+	"VMALLS12E1IS": {arm64SystemFields{4, 3, 6}, false}, "IPAS2E1": {arm64SystemFields{4, 4, 1}, true},
+	"IPAS2LE1": {arm64SystemFields{4, 4, 5}, true}, "ALLE2": {arm64SystemFields{4, 7, 0}, false},
+	"VAE2": {arm64SystemFields{4, 7, 1}, true}, "ALLE1": {arm64SystemFields{4, 7, 4}, false},
+	"VALE2": {arm64SystemFields{4, 7, 5}, true}, "VMALLS12E1": {arm64SystemFields{4, 7, 6}, false},
+	"ALLE3IS": {arm64SystemFields{6, 3, 0}, false}, "VAE3IS": {arm64SystemFields{6, 3, 1}, true},
+	"VALE3IS": {arm64SystemFields{6, 3, 5}, true}, "ALLE3": {arm64SystemFields{6, 7, 0}, false},
+	"VAE3": {arm64SystemFields{6, 7, 1}, true}, "VALE3": {arm64SystemFields{6, 7, 5}, true},
+	"VMALLE1OS": {arm64SystemFields{0, 1, 0}, false}, "VAE1OS": {arm64SystemFields{0, 1, 1}, true},
+	"ASIDE1OS": {arm64SystemFields{0, 1, 2}, true}, "VAAE1OS": {arm64SystemFields{0, 1, 3}, true},
+	"VALE1OS": {arm64SystemFields{0, 1, 5}, true}, "VAALE1OS": {arm64SystemFields{0, 1, 7}, true},
+	"RVAE1IS": {arm64SystemFields{0, 2, 1}, true}, "RVAAE1IS": {arm64SystemFields{0, 2, 3}, true},
+	"RVALE1IS": {arm64SystemFields{0, 2, 5}, true}, "RVAALE1IS": {arm64SystemFields{0, 2, 7}, true},
+	"RVAE1OS": {arm64SystemFields{0, 5, 1}, true}, "RVAAE1OS": {arm64SystemFields{0, 5, 3}, true},
+	"RVALE1OS": {arm64SystemFields{0, 5, 5}, true}, "RVAALE1OS": {arm64SystemFields{0, 5, 7}, true},
+	"RVAE1": {arm64SystemFields{0, 6, 1}, true}, "RVAAE1": {arm64SystemFields{0, 6, 3}, true},
+	"RVALE1": {arm64SystemFields{0, 6, 5}, true}, "RVAALE1": {arm64SystemFields{0, 6, 7}, true},
+	"RIPAS2E1IS": {arm64SystemFields{4, 0, 2}, true}, "RIPAS2LE1IS": {arm64SystemFields{4, 0, 6}, true},
+	"ALLE2OS": {arm64SystemFields{4, 1, 0}, false}, "VAE2OS": {arm64SystemFields{4, 1, 1}, true},
+	"ALLE1OS": {arm64SystemFields{4, 1, 4}, false}, "VALE2OS": {arm64SystemFields{4, 1, 5}, true},
+	"VMALLS12E1OS": {arm64SystemFields{4, 1, 6}, false}, "RVAE2IS": {arm64SystemFields{4, 2, 1}, true},
+	"RVALE2IS": {arm64SystemFields{4, 2, 5}, true}, "IPAS2E1OS": {arm64SystemFields{4, 4, 0}, true},
+	"RIPAS2E1": {arm64SystemFields{4, 4, 2}, true}, "RIPAS2E1OS": {arm64SystemFields{4, 4, 3}, true},
+	"IPAS2LE1OS": {arm64SystemFields{4, 4, 4}, true}, "RIPAS2LE1": {arm64SystemFields{4, 4, 6}, true},
+	"RIPAS2LE1OS": {arm64SystemFields{4, 4, 7}, true}, "RVAE2OS": {arm64SystemFields{4, 5, 1}, true},
+	"RVALE2OS": {arm64SystemFields{4, 5, 5}, true}, "RVAE2": {arm64SystemFields{4, 6, 1}, true},
+	"RVALE2": {arm64SystemFields{4, 6, 5}, true}, "ALLE3OS": {arm64SystemFields{6, 1, 0}, false},
+	"VAE3OS": {arm64SystemFields{6, 1, 1}, true}, "VALE3OS": {arm64SystemFields{6, 1, 5}, true},
+	"RVAE3IS": {arm64SystemFields{6, 2, 1}, true}, "RVALE3IS": {arm64SystemFields{6, 2, 5}, true},
+	"RVAE3OS": {arm64SystemFields{6, 5, 1}, true}, "RVALE3OS": {arm64SystemFields{6, 5, 5}, true},
+	"RVAE3": {arm64SystemFields{6, 6, 1}, true}, "RVALE3": {arm64SystemFields{6, 6, 5}, true},
+}
+
+func arm64TLBIOperationNames() []string {
+	names := make([]string, 0, len(arm64TLBIOperations))
+	for name := range arm64TLBIOperations {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+func (c *arm64Ctx) lowerARM64TLBI(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "TLBI" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != "TLBI" || len(ins.Args) < 1 || len(ins.Args) > 2 || ins.Args[0].Kind != OpIdent {
+		return true, false, fmt.Errorf("arm64 TLBI expects a Go operation and optional R/ZR operand, with no suffix: %q", ins.Raw)
+	}
+	operation, exists := arm64TLBIOperations[strings.ToUpper(ins.Args[0].Ident)]
+	if !exists {
+		return true, false, fmt.Errorf("arm64 TLBI operation %q is outside Go's sysInstFields table: %q", ins.Args[0].Ident, ins.Raw)
+	}
+	if operation.hasOperand != (len(ins.Args) == 2) {
+		return true, false, fmt.Errorf("arm64 TLBI operation %q operand form is invalid: %q", ins.Args[0].Ident, ins.Raw)
+	}
+	prefix := fmt.Sprintf("sys #%d, c8, c%d, #%d", operation.op1, operation.cm, operation.op2)
+	if !operation.hasOperand {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", prefix, "~{memory}")
+		return true, false, nil
+	}
+	if ins.Args[1].Kind != OpReg || !isARM64GeneralOrZeroReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm64 TLBI operation %q expects an R/ZR operand: %q", ins.Args[0].Ident, ins.Raw)
+	}
+	if ins.Args[1].Reg == ZR {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", prefix+", xzr", "~{memory}")
+		return true, false, nil
+	}
+	value, err := c.loadReg(ins.Args[1].Reg)
+	if err != nil {
+		return true, false, err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", prefix+", $0", "r,~{memory}", value)
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerRawTLBI(form arm64RawTLBI) error {
+	operation := arm64TLBIOperations[form.operation]
+	prefix := fmt.Sprintf("sys #%d, c8, c%d, #%d", operation.op1, operation.cm, operation.op2)
+	if !operation.hasOperand {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", prefix, "~{memory}")
+		return nil
+	}
+	if form.register == ZR {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", prefix+", xzr", "~{memory}")
+		return nil
+	}
+	value, err := c.loadReg(form.register)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", prefix+", $0", "r,~{memory}", value)
+	return nil
+}
diff --git a/arm64_lower_tlbi_test.go b/arm64_lower_tlbi_test.go
new file mode 100644
index 000000000..d69c56fc7
--- /dev/null
+++ b/arm64_lower_tlbi_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64TLBICompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT tlbiforms(SB),$0-0\n")
+	names := arm64TLBIOperationNames()
+	for _, name := range names {
+		operation := arm64TLBIOperations[name]
+		if operation.hasOperand {
+			fmt.Fprintf(&source, "\tTLBI %s, R0\n", name)
+		} else {
+			fmt.Fprintf(&source, "\tTLBI %s\n", name)
+		}
+	}
+	source.WriteString("\tRET\n")
+	asm := source.String()
+	requireARM64GoAssemblerResult(t, asm, true)
+	file, err := Parse(ArchARM64, asm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"tlbiforms": {Name: "tlbiforms", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := strings.Count(ll, `asm sideeffect "sys #`), len(names); got != want {
+		t.Fatalf("TLBI lowering emitted %d system operations, want %d:\n%s", got, want, ll)
+	}
+	for _, want := range []string{
+		`asm sideeffect "sys #0, c8, c3, #0"`,
+		`asm sideeffect "sys #0, c8, c3, #1, $0"`,
+		`asm sideeffect "sys #6, c8, c7, #5, $0"`,
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("TLBI lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-tlbi.ll", "arm64-tlbi.o", ll)
+}
+
+func TestTranslateARM64TLBIRejectsInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"TLBI PLDL1KEEP",
+		"TLBI VMALLE1IS, R0",
+		"TLBI VAE1IS",
+		"TLBI VAE1IS, SP",
+		"TLBI.P VMALLE1IS",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted invalid TLBI form %q", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64RawTLBIForms(t *testing.T) {
+	const source = `TEXT rawtlbi(SB),$0-0
+	WORD $0xd50883a1
+	WORD $0xd5088341
+	WORD $0xd5088741
+	WORD $0xd508871f
+	WORD $0xd508831f
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"rawtlbi": {Name: "rawtlbi", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := strings.Count(ll, `asm sideeffect "sys #`); got != 5 {
+		t.Fatalf("raw TLBI lowering emitted %d system operations, want 5:\n%s", got, ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-raw-tlbi.ll", "arm64-raw-tlbi.o", ll)
+}
+
+func TestARM64TLBIOperationTableIsStable(t *testing.T) {
+	names := arm64TLBIOperationNames()
+	if len(names) != 78 {
+		t.Fatalf("TLBI operation table has %d entries, want 78", len(names))
+	}
+	if !sort.StringsAreSorted(names) {
+		t.Fatal("TLBI operation names are not sorted")
+	}
+}
diff --git a/arm64_lower_variable_shift.go b/arm64_lower_variable_shift.go
new file mode 100644
index 000000000..aa743a9bb
--- /dev/null
+++ b/arm64_lower_variable_shift.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64VectorVariableShift implements the complete AdvSIMD signed-count
+// variable-shift family. The first Go-syntax operand supplies signed per-lane
+// shift counts; the second is the value to shift. VSRSHL/VURSHL round right
+// shifts, while VSSHL/VUSHL do not.
+func (c *arm64Ctx) lowerARM64VectorVariableShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	intrinsic, handled := map[Op]string{
+		"VSSHL": "sshl", "VSRSHL": "srshl",
+		"VUSHL": "ushl", "VURSHL": "urshl",
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects Vshifts.T, Vvalue.T, Vdst.T with no suffix: %q", op, ins.Raw)
+	}
+	scalar := true
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg || strings.Contains(string(arg.Reg), ".") {
+			scalar = false
+			break
+		}
+		if _, ok := arm64ParseVReg(arg.Reg); !ok {
+			scalar = false
+			break
+		}
+	}
+	arrangement := arm64VectorArrangement{elementBits: 64, lanes: 1}
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		if scalar {
+			continue
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || !arm64VDUPArrangementAllowed(parsed) {
+			return true, false, fmt.Errorf("arm64 %s accepts a bare scalar D form or B8/B16/H4/H8/S2/S4/D2 vector arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	shifts, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	value, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if scalar {
+		scalarShifts := c.newTmp()
+		scalarValue := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i64> %s, i32 0\n", scalarShifts, shifts)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i64> %s, i32 0\n", scalarValue, value)
+		shifts = "%" + scalarShifts
+		value = "%" + scalarValue
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	typeName := fmt.Sprintf("v%di%d", arrangement.lanes, arrangement.elementBits)
+	if scalar {
+		vectorType = "i64"
+		typeName = "i64"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.%s(%s %s, %s %s)\n", result, vectorType, intrinsic, typeName, vectorType, value, vectorType, shifts)
+	storedResult := "%" + result
+	if scalar {
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i64> zeroinitializer, i64 %%%s, i32 0\n", inserted, result)
+		storedResult = "%" + inserted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, storedResult)
+}
diff --git a/arm64_lower_variable_shift_test.go b/arm64_lower_variable_shift_test.go
new file mode 100644
index 000000000..407080f50
--- /dev/null
+++ b/arm64_lower_variable_shift_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorVariableShiftCompleteGoAssemblerForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorVariableShiftForms(SB), $0-0\n")
+	for _, op := range []string{"VSSHL", "VUSHL"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			source.WriteString("\t" + op + " V0." + arrangement + ", V1." + arrangement + ", V31." + arrangement + "\n")
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"vectorVariableShiftForms": {Name: "vectorVariableShiftForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"llvm.aarch64.neon.sshl", "llvm.aarch64.neon.ushl"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s variable-shift IR omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-variable-shift.ll", "arm64-vector-variable-shift.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64VectorVariableShiftRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VSSHL V0.B8, V1.B8",
+		"VUSHL V0.B8, V1.B16, V2.B8",
+		"VSSHL V0.D1, V1.D1, V2.D1",
+		"VUSHL V0.S4, V1.S4, V2.S2",
+		"VSSHL.P V0.H8, V1.H8, V2.H8",
+	} {
+		source := "TEXT ·badVectorVariableShift(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64", Sigs: map[string]FuncSig{"badVectorVariableShift": {Name: "badVectorVariableShift", Ret: Void}}}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's VSSHL/VUSHL row", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_vec.go b/arm64_lower_vec.go
index d4c803f37..b2d57133a 100644
--- a/arm64_lower_vec.go
+++ b/arm64_lower_vec.go
@@ -6,6 +6,24 @@ import (
 	"strings"
 )
 
+// Go's registerExtension reads one scanner.Int, then ParseInt(base 10, 16).
+// Whitespace is lexical; signs, expressions, nondecimal literals and unresolved
+// names are not lane indices. Instruction families still enforce their own
+// suffix/destination-selected physical bounds after this shared token check.
+func arm64ParseLaneDecimalToken(source string) (int, bool) {
+	text := strings.TrimSpace(source)
+	if text == "" {
+		return 0, false
+	}
+	for i := range text {
+		if text[i] < '0' || text[i] > '9' {
+			return 0, false
+		}
+	}
+	index, err := strconv.ParseInt(text, 10, 16)
+	return int(index), err == nil
+}
+
 func arm64ParseVRegLane(r Reg) (kind byte, lane int, ok bool) {
 	s := strings.ToUpper(strings.TrimSpace(string(r)))
 	dot := strings.IndexByte(s, '.')
@@ -17,8 +35,8 @@ func arm64ParseVRegLane(r Reg) (kind byte, lane int, ok bool) {
 		return 0, 0, false
 	}
 	k := rest[0]
-	n, err := strconv.Atoi(rest[2 : len(rest)-1])
-	if err != nil {
+	n, valid := arm64ParseLaneDecimalToken(rest[2 : len(rest)-1])
+	if !valid {
 		return 0, 0, false
 	}
 	max := -1
@@ -43,6 +61,149 @@ func arm64ParseVRegLane(r Reg) (kind byte, lane int, ok bool) {
 // Vector/NEON lowering for a small subset used by stdlib asm.
 // We model V0..V31 as <16 x i8>.
 func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated bool, err error) {
+	// Validate source/dispatcher agreement before any other vector helper
+	// can emit IR for a conflicting opcode.
+	if ok, terminated, err := c.lowerARM64StructureLoadStore(op, postInc, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorMove(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64SignedLaneExtract(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64WideningAddSubtract(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorAbsDiff(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatImmediate(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorConstant(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorDuplicate(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64SHA3(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64AES(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64SHA(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64FloatPair(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorBitReverse(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorCountBits(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorReverse(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorTableLookup(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64PolynomialMultiply(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorWideningMultiply(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatNarrow(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatWiden(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorLogical(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerCompare(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerMinMax(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerMinMaxAcross(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorAddLongAcross(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerAbsNeg(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerNarrow(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorSaturatingShiftNarrow(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorShiftNarrow(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorShiftLeft(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorVariableShift(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorSaturatingShift(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorShiftRight(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorShiftInsert(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatUnary(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatMinMaxAcross(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatArithmetic(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFloatCompare(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorHalvingAdd(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorSaturatingArithmetic(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerMultiply(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64AddAcross(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorIntegerAddSub(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorFMA(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorExtract(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64VectorPermute(op, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARM64WideningShift(op, ins); ok {
+		return ok, terminated, err
+	}
 	switch op {
 	case "FMOVQ":
 		if len(ins.Args) != 2 {
@@ -50,11 +211,31 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 		}
 		src, dst := ins.Args[0], ins.Args[1]
 		preInc := strings.Contains(strings.ToUpper(string(ins.Op)), ".W")
+		memory, data := src, dst
+		if dst.Kind == OpSym {
+			memory, data = dst, src
+		}
+		if string(ins.Op) == "FMOVQ" && memory.Kind == OpSym && data.Kind == OpReg &&
+			!strings.HasPrefix(strings.TrimSpace(memory.Sym), "$") {
+			if _, valid := arm64ParseFReg(data.Reg); valid && sourceSymbolOffsetNeedsContext(memory.Sym) {
+				return true, false, fmt.Errorf("%w: arm64 FMOVQ symbol displacement requires generated assembler constants: %q", ErrProbeNeedsContext, ins.Raw)
+			}
+		}
 		switch {
-		case (src.Kind == OpMem || src.Kind == OpSym) && dst.Kind == OpReg:
+		case (src.Kind == OpFP || src.Kind == OpMem || src.Kind == OpSym) && dst.Kind == OpReg:
 			if _, ok := arm64ParseFReg(dst.Reg); !ok {
 				return true, false, fmt.Errorf("arm64 FMOVQ expects an F register destination: %q", ins.Raw)
 			}
+			if src.Kind == OpFP {
+				if preInc || postInc {
+					return true, false, fmt.Errorf("arm64 FMOVQ .P/.W requires register memory: %q", ins.Raw)
+				}
+				value, err := c.loadFMOVQFrame(src.FPOffset)
+				if err != nil {
+					return true, false, err
+				}
+				return true, false, c.storeVReg(dst.Reg, value)
+			}
 			ptr, base, inc, update, err := c.arm64VectorMemoryPointer(src, preInc, postInc)
 			if err != nil {
 				return true, false, err
@@ -70,7 +251,7 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 				}
 			}
 			return true, false, nil
-		case src.Kind == OpReg && (dst.Kind == OpMem || dst.Kind == OpSym):
+		case src.Kind == OpReg && (dst.Kind == OpFP || dst.Kind == OpMem || dst.Kind == OpSym):
 			if _, ok := arm64ParseFReg(src.Reg); !ok {
 				return true, false, fmt.Errorf("arm64 FMOVQ expects an F register source: %q", ins.Raw)
 			}
@@ -78,6 +259,12 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 			if err != nil {
 				return true, false, err
 			}
+			if dst.Kind == OpFP {
+				if preInc || postInc {
+					return true, false, fmt.Errorf("arm64 FMOVQ .P/.W requires register memory: %q", ins.Raw)
+				}
+				return true, false, c.storeFMOVQFrame(dst.FPOffset, value)
+			}
 			ptr, base, inc, update, err := c.arm64VectorMemoryPointer(dst, preInc, postInc)
 			if err != nil {
 				return true, false, err
@@ -93,75 +280,6 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 			return true, false, fmt.Errorf("arm64 FMOVQ expects memory and F register operands: %q", ins.Raw)
 		}
 
-	case "FSTPQ":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpRegList || len(ins.Args[0].RegList) != 2 || (ins.Args[1].Kind != OpMem && ins.Args[1].Kind != OpSym) {
-			return true, false, fmt.Errorf("arm64 FSTPQ expects (Freg,Freg), mem: %q", ins.Raw)
-		}
-		for _, f := range ins.Args[0].RegList {
-			if _, ok := arm64ParseFReg(f); !ok {
-				return true, false, fmt.Errorf("arm64 FSTPQ expects FP register pair: %q", ins.Raw)
-			}
-		}
-		preInc := strings.Contains(strings.ToUpper(string(ins.Op)), ".W")
-		ptr, base, inc, update, err := c.arm64VectorMemoryPointer(ins.Args[1], preInc, postInc)
-		if err != nil {
-			return true, false, err
-		}
-		for i, f := range ins.Args[0].RegList {
-			value, err := c.loadVReg(f)
-			if err != nil {
-				return true, false, err
-			}
-			storePtr := ptr
-			if i != 0 {
-				next := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i64 16\n", next, ptr)
-				storePtr = "%" + next
-			}
-			fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %s, align 1\n", value, storePtr)
-		}
-		if update {
-			if err := c.updatePostInc(base, inc); err != nil {
-				return true, false, err
-			}
-		}
-		return true, false, nil
-
-	case "FLDPQ":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpRegList || len(ins.Args[1].RegList) != 2 {
-			return true, false, fmt.Errorf("arm64 FLDPQ expects mem, (Freg,Freg): %q", ins.Raw)
-		}
-		mem := ins.Args[0].Mem
-		addr, base, inc, err := c.addrI64(mem, postInc)
-		if err != nil {
-			return true, false, err
-		}
-		for i, f := range ins.Args[1].RegList {
-			idx, ok := arm64ParseFReg(f)
-			if !ok {
-				return true, false, fmt.Errorf("arm64 FLDPQ expects FP register pair: %q", ins.Raw)
-			}
-			loadAddr := addr
-			if i != 0 {
-				next := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add i64 %s, 16\n", next, addr)
-				loadAddr = "%" + next
-			}
-			ptr := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", ptr, loadAddr)
-			value := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %%%s, align 1\n", value, ptr)
-			if err := c.storeVReg(Reg(fmt.Sprintf("V%d", idx)), "%"+value); err != nil {
-				return true, false, err
-			}
-		}
-		if postInc {
-			if err := c.updatePostInc(base, inc); err != nil {
-				return true, false, err
-			}
-		}
-		return true, false, nil
-
 	case "VMOVI":
 		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
 			return true, false, fmt.Errorf("arm64 VMOVI expects $imm, Vreg.B8/B16: %q", ins.Raw)
@@ -189,163 +307,6 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 		}
 		return true, false, c.storeVReg(ins.Args[1].Reg, "<"+strings.Join(elems, ", ")+">")
 
-	case "AESE", "AESD", "AESMC", "AESIMC",
-		"SHA1C", "SHA1H", "SHA1M", "SHA1P", "SHA1SU0", "SHA1SU1",
-		"SHA256H", "SHA256H2", "SHA256SU0", "SHA256SU1",
-		"SHA512H", "SHA512H2", "SHA512SU0", "SHA512SU1",
-		"VEOR3", "VBCAX", "VRAX1", "VXAR",
-		"VPMULL", "VPMULL2",
-		"VREV32", "VREV64", "VSHL", "VSRI", "VTBL", "VZIP1", "VZIP2", "VEXT", "VUSHR",
-		"VLD1R", "VLD4R", "VDUP":
-		// Keep translation permissive for crypto/NEON ops not yet modeled.
-		return true, false, nil
-
-	case "VMOV":
-		// Patterns used by stdlib:
-		// - VMOV Rn, Vm.B16      (broadcast low byte)
-		// - VMOV Vm.D[0], Rn     (extract low 64-bit)
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 VMOV expects reg, reg: %q", ins.Raw)
-		}
-		src, dst := ins.Args[0].Reg, ins.Args[1].Reg
-
-		if idx, ok := arm64ParseVReg(dst); ok {
-			_ = idx
-			// GPR -> V (broadcast).
-			if _, ok2 := arm64ParseVReg(src); ok2 {
-				// V -> V copy.
-				v, err := c.loadVReg(src)
-				if err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeVReg(dst, v)
-			}
-			if k, lane, laneOK := arm64ParseVRegLane(dst); laneOK {
-				// GPR -> V lane insert.
-				rv, err := c.loadReg(src)
-				if err != nil {
-					return true, false, err
-				}
-				v, err := c.loadVReg(dst)
-				if err != nil {
-					return true, false, err
-				}
-				switch k {
-				case 'D':
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, v)
-					insv := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %s, i32 %d\n", insv, bc, rv, lane)
-					out := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, insv)
-					return true, false, c.storeVReg(dst, "%"+out)
-				case 'S':
-					w := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", w, rv)
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bc, v)
-					insv := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %%%s, i32 %d\n", insv, bc, w, lane)
-					out := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, insv)
-					return true, false, c.storeVReg(dst, "%"+out)
-				case 'H':
-					h := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i16\n", h, rv)
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", bc, v)
-					insv := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i16> %%%s, i16 %%%s, i32 %d\n", insv, bc, h, lane)
-					out := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", out, insv)
-					return true, false, c.storeVReg(dst, "%"+out)
-				case 'B':
-					b := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", b, rv)
-					insv := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = insertelement <16 x i8> %s, i8 %%%s, i32 %d\n", insv, v, b, lane)
-					return true, false, c.storeVReg(dst, "%"+insv)
-				}
-			}
-			rv, err := c.loadReg(src)
-			if err != nil {
-				return true, false, err
-			}
-			ds := strings.ToUpper(string(dst))
-			switch {
-			case strings.Contains(ds, ".S4"):
-				b := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", b, rv)
-				v, err := c.broadcastI32ToV16("%" + b)
-				if err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeVReg(dst, v)
-			default:
-				b := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", b, rv)
-				v, err := c.broadcastI8ToV16("%" + b)
-				if err != nil {
-					return true, false, err
-				}
-				return true, false, c.storeVReg(dst, v)
-			}
-		}
-
-		// V -> GPR (lane extract).
-		if _, ok := arm64ParseVReg(src); ok {
-			if k, lane, laneOK := arm64ParseVRegLane(src); laneOK {
-				v, err := c.loadVReg(src)
-				if err != nil {
-					return true, false, err
-				}
-				switch k {
-				case 'D':
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, v)
-					e := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 %d\n", e, bc, lane)
-					return true, false, c.storeReg(dst, "%"+e)
-				case 'S':
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bc, v)
-					e := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %%%s, i32 %d\n", e, bc, lane)
-					z := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", z, e)
-					return true, false, c.storeReg(dst, "%"+z)
-				case 'H':
-					bc := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", bc, v)
-					e := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = extractelement <8 x i16> %%%s, i32 %d\n", e, bc, lane)
-					z := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = zext i16 %%%s to i64\n", z, e)
-					return true, false, c.storeReg(dst, "%"+z)
-				case 'B':
-					e := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i8> %s, i32 %d\n", e, v, lane)
-					z := c.newTmp()
-					fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i64\n", z, e)
-					return true, false, c.storeReg(dst, "%"+z)
-				}
-			}
-			// VMOV Vn, Rm: use low 64-bit lane by default.
-			if !strings.Contains(strings.ToUpper(string(src)), ".") {
-				v, err := c.loadVReg(src)
-				if err != nil {
-					return true, false, err
-				}
-				bc := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, v)
-				e := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", e, bc)
-				return true, false, c.storeReg(dst, "%"+e)
-			}
-			return true, false, fmt.Errorf("arm64 VMOV unsupported vreg lane: %q", ins.Raw)
-		}
-		return true, false, fmt.Errorf("arm64 VMOV unsupported: %q", ins.Raw)
-
 	case "VEOR":
 		// VEOR Va, Vb, Vd
 		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
@@ -380,167 +341,6 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 		fmt.Fprintf(c.b, "  %%%s = or <16 x i8> %s, %s\n", t, a, b)
 		return true, false, c.storeVReg(ins.Args[2].Reg, "%"+t)
 
-	case "VLD1":
-		// VLD1 lane form: VLD1(.P) mem, Vn.{B,H,S,D}[lane]
-		if len(ins.Args) == 2 && ins.Args[0].Kind == OpMem && ins.Args[1].Kind == OpReg {
-			k, lane, ok := arm64ParseVRegLane(ins.Args[1].Reg)
-			if !ok {
-				return true, false, fmt.Errorf("arm64 VLD1 expects mem, lane or [v,...]: %q", ins.Raw)
-			}
-			mem := ins.Args[0].Mem
-			addr, base, inc, err := c.addrI64(mem, postInc)
-			if err != nil {
-				return true, false, err
-			}
-			v, err := c.loadVReg(ins.Args[1].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			width := int64(1)
-			switch k {
-			case 'D':
-				width = 8
-			case 'S':
-				width = 4
-			case 'H':
-				width = 2
-			}
-			if postInc && inc == 0 {
-				inc = width
-			}
-			pt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pt, addr)
-			switch k {
-			case 'D':
-				e := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i64, ptr %%%s, align 1\n", e, pt)
-				bc := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bc, v)
-				insv := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %%%s, i32 %d\n", insv, bc, e, lane)
-				out := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, insv)
-				if err := c.storeVReg(ins.Args[1].Reg, "%"+out); err != nil {
-					return true, false, err
-				}
-			case 'S':
-				e := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i32, ptr %%%s, align 1\n", e, pt)
-				bc := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", bc, v)
-				insv := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %%%s, i32 %d\n", insv, bc, e, lane)
-				out := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, insv)
-				if err := c.storeVReg(ins.Args[1].Reg, "%"+out); err != nil {
-					return true, false, err
-				}
-			case 'H':
-				e := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i16, ptr %%%s, align 1\n", e, pt)
-				bc := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <8 x i16>\n", bc, v)
-				insv := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <8 x i16> %%%s, i16 %%%s, i32 %d\n", insv, bc, e, lane)
-				out := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %%%s to <16 x i8>\n", out, insv)
-				if err := c.storeVReg(ins.Args[1].Reg, "%"+out); err != nil {
-					return true, false, err
-				}
-			case 'B':
-				e := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = load i8, ptr %%%s, align 1\n", e, pt)
-				insv := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = insertelement <16 x i8> %s, i8 %%%s, i32 %d\n", insv, v, e, lane)
-				if err := c.storeVReg(ins.Args[1].Reg, "%"+insv); err != nil {
-					return true, false, err
-				}
-			}
-			if postInc {
-				if err := c.updatePostInc(base, inc); err != nil {
-					return true, false, err
-				}
-			}
-			return true, false, nil
-		}
-
-		// VLD1.P (R0), [V1.B16, V2.B16] (or 4-reg form for D2 lists)
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpRegList {
-			return true, false, fmt.Errorf("arm64 VLD1 expects mem, lane or [v,...]: %q", ins.Raw)
-		}
-		if n := len(ins.Args[1].RegList); n != 1 && n != 2 && n != 3 && n != 4 {
-			return true, false, fmt.Errorf("arm64 VLD1 unsupported reglist len=%d: %q", n, ins.Raw)
-		}
-		mem := ins.Args[0].Mem
-		addr, base, inc, err := c.addrI64(mem, false)
-		if err != nil {
-			return true, false, err
-		}
-		// Plan9 VLD1.P increments by loaded size even when mem.Off == 0.
-		if postInc && inc == 0 {
-			inc = int64(16 * len(ins.Args[1].RegList))
-		}
-
-		for i, r := range ins.Args[1].RegList {
-			ai := addr
-			if i != 0 {
-				at := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", at, addr, 16*i)
-				ai = "%" + at
-			}
-			pt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pt, ai)
-			vt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load <16 x i8>, ptr %%%s, align 1\n", vt, pt)
-			if err := c.storeVReg(r, "%"+vt); err != nil {
-				return true, false, err
-			}
-		}
-		if postInc {
-			if err := c.updatePostInc(base, inc); err != nil {
-				return true, false, err
-			}
-		}
-		return true, false, nil
-
-	case "VST1":
-		// VST1.P [Vn...], mem
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpRegList || ins.Args[1].Kind != OpMem {
-			return true, false, fmt.Errorf("arm64 VST1 expects [v,...], mem: %q", ins.Raw)
-		}
-		if n := len(ins.Args[0].RegList); n != 1 && n != 2 && n != 3 && n != 4 {
-			return true, false, fmt.Errorf("arm64 VST1 unsupported reglist len=%d: %q", n, ins.Raw)
-		}
-		mem := ins.Args[1].Mem
-		addr, base, inc, err := c.addrI64(mem, false)
-		if err != nil {
-			return true, false, err
-		}
-		if postInc && inc == 0 {
-			inc = int64(16 * len(ins.Args[0].RegList))
-		}
-		for i, r := range ins.Args[0].RegList {
-			ai := addr
-			if i != 0 {
-				at := c.newTmp()
-				fmt.Fprintf(c.b, "  %%%s = add i64 %s, %d\n", at, addr, 16*i)
-				ai = "%" + at
-			}
-			v, err := c.loadVReg(r)
-			if err != nil {
-				return true, false, err
-			}
-			pt := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pt, ai)
-			fmt.Fprintf(c.b, "  store <16 x i8> %s, ptr %%%s, align 1\n", v, pt)
-		}
-		if postInc {
-			if err := c.updatePostInc(base, inc); err != nil {
-				return true, false, err
-			}
-		}
-		return true, false, nil
-
 	case "VCMEQ":
 		// VCMEQ Va.B16, Vb.B16, Vd.B16 (or D2 lane-wide compare)
 		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
@@ -603,110 +403,7 @@ func (c *arm64Ctx) lowerVec(op Op, postInc bool, ins Instr) (ok bool, terminated
 		return true, false, c.storeVReg(ins.Args[2].Reg, "%"+t)
 
 	case "VADDP":
-		// Pairwise add:
-		// - .B16: outputs 16 bytes: 8 from src0 pairs, 8 from src1 pairs.
-		// - .D2: outputs 2x i64: sum of each source's two lanes.
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 VADDP expects reg, reg, reg: %q", ins.Raw)
-		}
-		s0 := strings.ToUpper(string(ins.Args[0].Reg))
-		s1 := strings.ToUpper(string(ins.Args[1].Reg))
-		if strings.Contains(s0, ".D2") || strings.Contains(s1, ".D2") {
-			a, err := c.loadVReg(ins.Args[0].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			b, err := c.loadVReg(ins.Args[1].Reg)
-			if err != nil {
-				return true, false, err
-			}
-			ab := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", ab, a)
-			bb := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", bb, b)
-			a0 := c.newTmp()
-			a1 := c.newTmp()
-			b0 := c.newTmp()
-			b1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", a0, ab)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 1\n", a1, ab)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 0\n", b0, bb)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i32 1\n", b1, bb)
-			as := c.newTmp()
-			bs := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", as, a0, a1)
-			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", bs, b0, b1)
-			v0 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> undef, i64 %%%s, i32 0\n", v0, as)
-			v1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %%%s, i32 1\n", v1, v0, bs)
-			out := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", out, v1)
-			return true, false, c.storeVReg(ins.Args[2].Reg, "%"+out)
-		}
-
-		// Default B16.
-		a, err := c.loadVReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		b, err := c.loadVReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		cur := "undef"
-		for i := 0; i < 16; i++ {
-			var src string
-			var off int
-			if i < 8 {
-				// Go/Plan9 asm operand order for VADDP matches sources, but stdlib
-				// code expects the low 64 bits to correspond to the first loaded
-				// 16-byte lane. Empirically this matches taking the second operand
-				// for the low half.
-				src = b
-				off = i * 2
-			} else {
-				src = a
-				off = (i - 8) * 2
-			}
-			e0 := c.newTmp()
-			e1 := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i8> %s, i32 %d\n", e0, src, off)
-			fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i8> %s, i32 %d\n", e1, src, off+1)
-			sum := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i8 %%%s, %%%s\n", sum, e0, e1)
-			insv := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = insertelement <16 x i8> %s, i8 %%%s, i32 %d\n", insv, cur, sum, i)
-			cur = "%" + insv
-		}
-		return true, false, c.storeVReg(ins.Args[2].Reg, cur)
-
-	case "VUADDLV":
-		// VUADDLV Vn.B16, Vd
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm64 VUADDLV expects reg, reg: %q", ins.Raw)
-		}
-		v, err := c.loadVReg(ins.Args[0].Reg)
-		if err != nil {
-			return true, false, err
-		}
-		z := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = zext <16 x i8> %s to <16 x i64>\n", z, v)
-		sum := "0"
-		for i := 0; i < 16; i++ {
-			e := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i64> %%%s, i32 %d\n", e, z, i)
-			a := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", a, sum, e)
-			sum = "%" + a
-		}
-		vec := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> undef, i64 %s, i32 0\n", vec, sum)
-		vec2 := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 0, i32 1\n", vec2, vec)
-		bc := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bc, vec2)
-		return true, false, c.storeVReg(ins.Args[1].Reg, "%"+bc)
+		return true, false, c.lowerARM64VectorADDP(ins)
 
 	case "VADD":
 		// VADD Vs, Vd (2-operand accumulate in D[0]) or VADD Va, Vb, Vd (S4 vector add).
diff --git a/arm64_lower_vector_abs_diff.go b/arm64_lower_vector_abs_diff.go
new file mode 100644
index 000000000..0fa9ff579
--- /dev/null
+++ b/arm64_lower_vector_abs_diff.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64VectorAbsDiff lowers the complete Advanced SIMD absolute-
+// difference family decoded from WORD forms. Go 1.27 has no named NEON optab
+// row for these instructions; x/arch prints the V-prefixed aliases.
+func (c *arm64Ctx) lowerARM64VectorAbsDiff(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerARM64VectorAbsDiffLong(op, ins); ok {
+		return ok, terminated, err
+	}
+	type operationSpec struct {
+		signed     bool
+		accumulate bool
+	}
+	spec, handled := map[Op]operationSpec{
+		"VSABD": {signed: true},
+		"VUABD": {},
+		"VSABA": {signed: true, accumulate: true},
+		"VUABA": {accumulate: true},
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects three same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	var arrangement arm64VectorArrangement
+	for i, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+		parsed, valid := parseARM64VectorArrangement(arg.Reg)
+		if !valid || parsed.elementBits > 32 || (parsed.elementBits == 8 && parsed.lanes != 8 && parsed.lanes != 16) ||
+			(parsed.elementBits == 16 && parsed.lanes != 4 && parsed.lanes != 8) ||
+			(parsed.elementBits == 32 && parsed.lanes != 2 && parsed.lanes != 4) {
+			return true, false, fmt.Errorf("arm64 %s accepts only B8/B16/H4/H8/S2/S4 arrangements: %q", op, ins.Raw)
+		}
+		if i == 0 {
+			arrangement = parsed
+		} else if parsed != arrangement {
+			return true, false, fmt.Errorf("arm64 %s arrangements must match: %q", op, ins.Raw)
+		}
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, arrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	result := ""
+	if spec.signed {
+		wideBits := arrangement.elementBits * 2
+		wideType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, wideBits)
+		wideFirst := c.newTmp()
+		wideSecond := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", wideFirst, vectorType, first, wideType)
+		fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", wideSecond, vectorType, second, wideType)
+		condition := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp sgt %s %%%s, %%%s\n", condition, wideType, wideFirst, wideSecond)
+		firstDifference := c.newTmp()
+		secondDifference := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %%%s\n", firstDifference, wideType, wideFirst, wideSecond)
+		fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %%%s\n", secondDifference, wideType, wideSecond, wideFirst)
+		wideResult := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %%%s\n", wideResult, arrangement.lanes, condition, wideType, firstDifference, wideType, secondDifference)
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", narrow, wideType, wideResult, vectorType)
+		result = "%" + narrow
+	} else {
+		condition := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp ugt %s %s, %s\n", condition, vectorType, first, second)
+		firstDifference := c.newTmp()
+		secondDifference := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", firstDifference, vectorType, first, second)
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, %s\n", secondDifference, vectorType, second, first)
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %%%s\n", selected, arrangement.lanes, condition, vectorType, firstDifference, vectorType, secondDifference)
+		result = "%" + selected
+	}
+	if spec.accumulate {
+		accumulator, err := c.loadARM64VectorInteger(ins.Args[2].Reg, arrangement)
+		if err != nil {
+			return true, false, err
+		}
+		accumulated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", accumulated, vectorType, accumulator, result)
+		result = "%" + accumulated
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, arrangement, result)
+}
+
+func (c *arm64Ctx) lowerARM64VectorAbsDiffLong(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	type operationSpec struct {
+		signed     bool
+		accumulate bool
+	}
+	spec, handled := map[Op]operationSpec{
+		"VSABDL":  {signed: true},
+		"VSABDL2": {signed: true},
+		"VUABDL":  {},
+		"VUABDL2": {},
+		"VSABAL":  {signed: true, accumulate: true},
+		"VSABAL2": {signed: true, accumulate: true},
+		"VUABAL":  {accumulate: true},
+		"VUABAL2": {accumulate: true},
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects two source and one destination vector register, with no suffix: %q", op, ins.Raw)
+	}
+	if ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+	}
+	firstArrangement, firstOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	secondArrangement, secondOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	if !firstOK || !secondOK || !destinationOK || firstArrangement != secondArrangement {
+		return true, false, fmt.Errorf("arm64 %s requires matching source arrangements: %q", op, ins.Raw)
+	}
+	highHalf := strings.HasSuffix(string(op), "2")
+	wantSourceLanes := destinationArrangement.lanes
+	if highHalf {
+		wantSourceLanes *= 2
+	}
+	if firstArrangement.lanes != wantSourceLanes || destinationArrangement.elementBits != 2*firstArrangement.elementBits ||
+		destinationArrangement.lanes*destinationArrangement.elementBits != 128 || firstArrangement.elementBits > 32 {
+		return true, false, fmt.Errorf("arm64 %s requires B/H/S sources widened to H/S/D: %q", op, ins.Raw)
+	}
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, firstArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, secondArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if highHalf {
+		first = c.selectARM64VectorHighHalf(firstArrangement, destinationArrangement.lanes, first)
+		second = c.selectARM64VectorHighHalf(secondArrangement, destinationArrangement.lanes, second)
+	}
+	sourceType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, firstArrangement.elementBits)
+	destinationType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, destinationArrangement.elementBits)
+	wideFirst, wideSecond := c.newTmp(), c.newTmp()
+	extension := "zext"
+	if spec.signed {
+		extension = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideFirst, extension, sourceType, first, destinationType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideSecond, extension, sourceType, second, destinationType)
+	condition := c.newTmp()
+	compare := "icmp ugt"
+	if spec.signed {
+		compare = "icmp sgt"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %%%s\n", condition, compare, destinationType, wideFirst, wideSecond)
+	firstDifference, secondDifference, result := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %%%s\n", firstDifference, destinationType, wideFirst, wideSecond)
+	fmt.Fprintf(c.b, "  %%%s = sub %s %%%s, %%%s\n", secondDifference, destinationType, wideSecond, wideFirst)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %%%s, %s %%%s\n", result, destinationArrangement.lanes, condition, destinationType, firstDifference, destinationType, secondDifference)
+	value := "%" + result
+	if spec.accumulate {
+		accumulator, err := c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		accumulated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", accumulated, destinationType, accumulator, value)
+		value = "%" + accumulated
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, value)
+}
diff --git a/arm64_lower_vector_abs_diff_test.go b/arm64_lower_vector_abs_diff_test.go
new file mode 100644
index 000000000..aefadb851
--- /dev/null
+++ b/arm64_lower_vector_abs_diff_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawVectorAbsoluteDifferenceCompleteArchitecturalFormats(t *testing.T) {
+	ops := []struct {
+		name  string
+		bases []uint32
+	}{
+		{"sabd", []uint32{0x0e207400, 0x4e207400, 0x0e607400, 0x4e607400, 0x0ea07400, 0x4ea07400}},
+		{"uabd", []uint32{0x2e207400, 0x6e207400, 0x2e607400, 0x6e607400, 0x2ea07400, 0x6ea07400}},
+		{"saba", []uint32{0x0e207c00, 0x4e207c00, 0x0e607c00, 0x4e607c00, 0x0ea07c00, 0x4ea07c00}},
+		{"uaba", []uint32{0x2e207c00, 0x6e207c00, 0x2e607c00, 0x6e607c00, 0x2ea07c00, 0x6ea07c00}},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT vectorabsolutedifferenceforms(SB),$0-0\n")
+	for _, op := range ops {
+		for _, base := range op.bases {
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", base|29<<16|30<<5|28, op.name)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectorabsolutedifferenceforms": {Name: "vectorabsolutedifferenceforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"sext <", "icmp sgt <", "icmp ugt <", "add <"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("absolute-difference family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-absolute-difference.ll", "arm64-vector-absolute-difference.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64RawVectorAbsoluteDifferenceLongForms(t *testing.T) {
+	const source = `TEXT vectorabsoluteDifferenceLong(SB),$0-0
+	WORD $0x2e217004 // UABDL V4.8H, V0.8B, V1.8B
+	WORD $0x6e217005 // UABDL2 V5.8H, V0.16B, V1.16B
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"vectorabsoluteDifferenceLong": {Name: "vectorabsoluteDifferenceLong", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "zext <8 x i8>") || !strings.Contains(ir, "icmp ugt <8 x i16>") {
+		t.Fatalf("unsigned absolute-difference-long lowering omitted widened compare:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-vector-absolute-difference-long.ll", "arm64-vector-absolute-difference-long.o", ir)
+}
+
+func TestARM64RawVectorAbsoluteDifferenceRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorabsolutedifference(SB),$0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD accumulator+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VLD1 (R2), [V2.B16]
+	VLD1 (R2), [V5.B16]
+	WORD $0x4e217403 // SABD V3.16B, V0.16B, V1.16B
+	WORD $0x6e217404 // UABD V4.16B, V0.16B, V1.16B
+	WORD $0x4e217c02 // SABA V2.16B, V0.16B, V1.16B
+	WORD $0x6e217c05 // UABA V5.16B, V0.16B, V1.16B
+	VST1.P [V3.B16], 16(R3)
+	VST1.P [V4.B16], 16(R3)
+	VST1.P [V2.B16], 16(R3)
+	VST1.P [V5.B16], 16(R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"vectorabsolutedifference": {
+			Name: "vectorabsolutedifference", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorabsolutedifference(const int8_t *, const int8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  const int8_t a[16] = {127,-128,12,-20,0,1,-1,64,-64,100,-100,5,-5,30,-30,42};
+  const int8_t b[16] = {-128,127,-12,20,0,-1,1,-64,64,-100,100,-5,5,-30,30,-42};
+  const uint8_t accumulator[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
+  uint8_t got[64] = {0};
+  vectorabsolutedifference(a, b, accumulator, got);
+  for (int i = 0; i < 16; i++) {
+    int signed_diff = (int)a[i] - (int)b[i];
+    if (signed_diff < 0) signed_diff = -signed_diff;
+    int unsigned_diff = (int)(uint8_t)a[i] - (int)(uint8_t)b[i];
+    if (unsigned_diff < 0) unsigned_diff = -unsigned_diff;
+    if (got[i] != (uint8_t)signed_diff) return i + 1;
+    if (got[16+i] != (uint8_t)unsigned_diff) return i + 17;
+    if (got[32+i] != (uint8_t)(accumulator[i] + signed_diff)) return i + 33;
+    if (got[48+i] != (uint8_t)(accumulator[i] + unsigned_diff)) return i + 49;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_absolute_difference", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_vector_bit_reverse.go b/arm64_lower_vector_bit_reverse.go
new file mode 100644
index 000000000..9584577cb
--- /dev/null
+++ b/arm64_lower_vector_bit_reverse.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorBitReverse(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "VRBIT" {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != "VRBIT" || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 VRBIT expects Vm.B8/B16, Vd.B8/B16: %q", ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	if !sourceOK || !destinationOK || sourceArrangement != destinationArrangement ||
+		sourceArrangement.elementBits != 8 || sourceArrangement.lanes != 8 && sourceArrangement.lanes != 16 {
+		return true, false, fmt.Errorf("arm64 VRBIT requires matching B8 or B16 arrangements: %q", ins.Raw)
+	}
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x i8> @llvm.bitreverse.v%di8(<%d x i8> %s)\n",
+		result, sourceArrangement.lanes, sourceArrangement.lanes, sourceArrangement.lanes, source)
+	return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, "%"+result)
+}
diff --git a/arm64_lower_vector_bit_reverse_test.go b/arm64_lower_vector_bit_reverse_test.go
new file mode 100644
index 000000000..df8f06a8d
--- /dev/null
+++ b/arm64_lower_vector_bit_reverse_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorBitReverseCompleteFormats(t *testing.T) {
+	const source = `TEXT vectorBitReverse(SB),$0-0
+	VRBIT V0.B8, V1.B8
+	VRBIT V2.B16, V3.B16
+	VRBIT V4.B16, V4.B16
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"vectorBitReverse": {Name: "vectorBitReverse", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"@llvm.bitreverse.v8i8", "@llvm.bitreverse.v16i8"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 VRBIT lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-vector-bit-reverse.ll", "arm64-vector-bit-reverse.o", ll)
+}
+
+func TestTranslateARM64VectorBitReverseRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"VRBIT V0.H4, V1.H4",
+		"VRBIT V0.B8, V1.B16",
+		"VRBIT V0, V1",
+		"VRBIT R0, V1.B8",
+		"VRBIT.P V0.B8, V1.B8",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: arm64LinuxGNUTriple,
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM64 VRBIT optab", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_vector_constant.go b/arm64_lower_vector_constant.go
new file mode 100644
index 000000000..8e76f6485
--- /dev/null
+++ b/arm64_lower_vector_constant.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARM64VectorConstant implements the complete Go assembler family for
+// materializing 32-, 64-, and 128-bit constants in a vector register:
+//
+//	VMOVS $lo32, Vd
+//	VMOVD $lo64, Vd
+//	VMOVQ $lo64, $hi64, Vd
+func (c *arm64Ctx) lowerARM64VectorConstant(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	var bits int
+	switch op {
+	case "VMOVS":
+		bits = 32
+	case "VMOVD":
+		bits = 64
+	case "VMOVQ":
+		bits = 128
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an instruction suffix: %q", op, ins.Raw)
+	}
+	wantArgs := 2
+	if bits == 128 {
+		wantArgs = 3
+	}
+	if len(ins.Args) != wantArgs {
+		return true, false, fmt.Errorf("arm64 %s expects %d operands: %q", op, wantArgs, ins.Raw)
+	}
+	for i := 0; i < wantArgs-1; i++ {
+		if ins.Args[i].Kind != OpImm {
+			return true, false, fmt.Errorf("arm64 %s operand %d must be an immediate: %q", op, i+1, ins.Raw)
+		}
+	}
+	dst := ins.Args[wantArgs-1]
+	if dst.Kind != OpReg || strings.Contains(string(dst.Reg), ".") {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+	if _, valid := arm64ParseVReg(dst.Reg); !valid {
+		return true, false, fmt.Errorf("arm64 %s destination must be a bare V register: %q", op, ins.Raw)
+	}
+
+	var vector, vectorType string
+	switch bits {
+	case 32:
+		vectorType = "<4 x i32>"
+		vector = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> zeroinitializer, i32 %d, i32 0\n", vector, uint32(ins.Args[0].Imm))
+	case 64:
+		vectorType = "<2 x i64>"
+		vector = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %d, i32 0\n", vector, uint64(ins.Args[0].Imm))
+	case 128:
+		vectorType = "<2 x i64>"
+		low := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> zeroinitializer, i64 %d, i32 0\n", low, uint64(ins.Args[0].Imm))
+		vector = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %d, i32 1\n", vector, low, uint64(ins.Args[1].Imm))
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %%%s to <16 x i8>\n", bytes, vectorType, vector)
+	return true, false, c.storeVReg(dst.Reg, "%"+bytes)
+}
diff --git a/arm64_lower_vector_constant_test.go b/arm64_lower_vector_constant_test.go
new file mode 100644
index 000000000..b314b99b6
--- /dev/null
+++ b/arm64_lower_vector_constant_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64VectorConstantForms = `
+TEXT vectorconstantforms(SB),$0-0
+	VMOVS $0x80402010, V1
+	VMOVD $0x7040201008040201, V2
+	VMOVQ $0x7040201008040201, $0x3040201008040201, V3
+	RET
+`
+
+func TestTranslateARM64VectorConstantCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64VectorConstantForms, true)
+	file, err := Parse(ArchARM64, arm64VectorConstantForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"vectorconstantforms": {Name: "vectorconstantforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"insertelement <4 x i32> zeroinitializer", "insertelement <2 x i64> zeroinitializer", "bitcast <2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 vector constant lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-constants.ll", "arm64-vector-constants.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorConstantRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOVS V0, V1",
+		"VMOVS $1, V1.S4",
+		"VMOVS $1, $2, V1",
+		"VMOVD $1",
+		"VMOVD $1, R1",
+		"VMOVQ $1, V1",
+		"VMOVQ $1, $2, V1, V2",
+		"VMOVQ.P $1, $2, V1",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectorconstant(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			// Go dereferences a missing third operand for this malformed
+			// arity. It is a translator input-safety regression, not a Go
+			// rejection certificate; the separate defect test retains its
+			// original source and observes the actual assembler outcome.
+			if instruction != "VMOVQ $1, V1" {
+				requireARM64GoAssemblerResult(t, source, false)
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorconstant": {Name: "badvectorconstant", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VMOVS/VMOVD/VMOVQ table", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorConstantRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorconstants(SB),$0-8
+	MOVD out+0(FP), R0
+	VMOVS $0x80402010, V1
+	VMOV V1.S[0], R1
+	MOVW R1, 0(R0)
+	VMOVD $0x7040201008040201, V2
+	VMOV V2.D[0], R2
+	VMOV V2.D[1], R3
+	MOVD R2, 8(R0)
+	MOVD R3, 16(R0)
+	VMOVQ $0x7040201008040201, $0x3040201008040201, V4
+	VMOV V4.D[0], R4
+	VMOV V4.D[1], R5
+	MOVD R4, 24(R0)
+	MOVD R5, 32(R0)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorconstants": {
+				Name: "vectorconstants", Args: []LLVMType{Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+struct values { uint32_t s; uint32_t pad; uint64_t d; uint64_t dzero; uint64_t qlo; uint64_t qhi; };
+extern void vectorconstants(struct values *);
+int main(void) {
+  struct values got = {0};
+  vectorconstants(&got);
+  if (got.s != UINT32_C(0x80402010)) return 1;
+  if (got.d != UINT64_C(0x7040201008040201) || got.dzero != 0) return 2;
+  if (got.qlo != UINT64_C(0x7040201008040201)) return 3;
+  if (got.qhi != UINT64_C(0x3040201008040201)) return 4;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_constants", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_vector_count_leading_test.go b/arm64_lower_vector_count_leading_test.go
new file mode 100644
index 000000000..44644ee2c
--- /dev/null
+++ b/arm64_lower_vector_count_leading_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64VectorCountLeadingForms = `
+TEXT vectorcountleadingforms(SB),$0-0
+	VCLS V0.B8, V1.B8
+	VCLS V2.B16, V3.B16
+	VCLS V4.H4, V5.H4
+	VCLS V6.H8, V7.H8
+	VCLS V8.S2, V9.S2
+	VCLS V10.S4, V11.S4
+	VCLZ V12.B8, V13.B8
+	VCLZ V14.B16, V15.B16
+	VCLZ V16.H4, V17.H4
+	VCLZ V18.H8, V19.H8
+	VCLZ V20.S2, V21.S2
+	VCLZ V22.S4, V23.S4
+	RET
+`
+
+func TestTranslateARM64VectorCountLeadingCompleteGoAssemblerForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64VectorCountLeadingForms, true)
+	file, err := Parse(ArchARM64, arm64VectorCountLeadingForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"vectorcountleadingforms": {Name: "vectorcountleadingforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, " = call <"); got != 12 {
+				t.Fatalf("ARM64 VCLS/VCLZ emitted %d vector ctlz calls, want 12:\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-count-leading.ll", "arm64-vector-count-leading.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorCountLeadingRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VCLS V0.D1, V1.D1",
+		"VCLS V0.D2, V1.D2",
+		"VCLZ V0.D1, V1.D1",
+		"VCLZ V0.D2, V1.D2",
+		"VCLS V0.B8, V1.B16",
+		"VCLZ V0.H4, V1.H8",
+		"VCLS V0.B8, V1.B8, V2.B8",
+		"VCLZ.P V0.S4, V1.S4",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(instruction), func(t *testing.T) {
+			source := "TEXT badvectorcountleading(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"badvectorcountleading": {Name: "badvectorcountleading", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VCLS/VCLZ forms", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorCountLeadingRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorcountleading(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.B16]
+	VCLZ V0.B16, V1.B16
+	VCLS V0.B16, V2.B16
+	VST1 [V1.B16, V2.B16], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorcountleading": {
+				Name: "vectorcountleading", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorcountleading(const uint8_t *, uint8_t *);
+int main(void) {
+  const uint8_t input[16] = {0x00,0x01,0x02,0x03,0x7f,0x80,0xff,0xfe,0xf0,0x10,0x08,0x04,0xc0,0x40,0xaa,0x55};
+  const uint8_t want[32] = {
+    8,7,6,6,1,0,0,0,0,3,4,5,0,1,0,1,
+    7,6,5,5,0,0,7,6,3,2,3,4,1,0,0,0
+  };
+  uint8_t got[32] = {0};
+  vectorcountleading(input, got);
+  for (int i = 0; i < 32; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_count_leading", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_vector_float_immediate.go b/arm64_lower_vector_float_immediate.go
new file mode 100644
index 000000000..2b3ed0f0d
--- /dev/null
+++ b/arm64_lower_vector_float_immediate.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// lowerARM64VectorFloatImmediate handles the Advanced SIMD floating-point
+// modified-immediate form. x/arch prints this raw encoding as FMOV $f, Vd.T;
+// Go's named optab has no VFMOV spelling, so keep the decoder spelling and
+// lower it directly to the repeated IEEE value (with inactive lanes zero).
+func (c *arm64Ctx) lowerARM64VectorFloatImmediate(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	if op != "FMOV" || len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[1].Kind != OpReg {
+		return false, false, nil
+	}
+	if !ins.Args[0].ImmIsFloat || ins.Args[0].ImmRaw != "" {
+		return true, false, fmt.Errorf("arm64 FMOV vector immediate requires a resolved floating constant: %q", ins.Raw)
+	}
+	arrangement, valid := parseARM64VectorArrangement(ins.Args[1].Reg)
+	if !valid || !((arrangement.elementBits == 16 && (arrangement.lanes == 4 || arrangement.lanes == 8)) ||
+		(arrangement.elementBits == 32 && (arrangement.lanes == 2 || arrangement.lanes == 4)) ||
+		(arrangement.elementBits == 64 && arrangement.lanes == 2)) {
+		return true, false, fmt.Errorf("arm64 FMOV vector immediate requires H4/H8, S2/S4, or D2 destination: %q", ins.Raw)
+	}
+	value := math.Float64frombits(uint64(ins.Args[0].Imm))
+	laneValue := math.Float64bits(value)
+	if arrangement.elementBits == 16 {
+		laneValue = uint64(arm64Float16Bits(value))
+	} else if arrangement.elementBits == 32 {
+		laneValue = uint64(math.Float32bits(float32(value)))
+	}
+	if err := c.lowerARM64VectorFloatImmediateBits(arrangement, laneValue, ins.Args[1].Reg); err != nil {
+		return true, false, err
+	}
+	return true, false, nil
+}
+
+func (c *arm64Ctx) lowerARM64VectorFloatImmediateBits(
+	arrangement arm64VectorArrangement,
+	laneValue uint64,
+	destination Reg,
+) error {
+	physicalLanes := 128 / arrangement.elementBits
+	values := make([]string, physicalLanes)
+	for i := range values {
+		if i >= arrangement.lanes {
+			values[i] = "0"
+			continue
+		}
+		values[i] = fmt.Sprintf("%d", laneValue)
+	}
+	elements := make([]string, len(values))
+	for i, element := range values {
+		elements[i] = fmt.Sprintf("i%d %s", arrangement.elementBits, element)
+	}
+	vector := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x i%d>", physicalLanes, arrangement.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s <%s> to <16 x i8>\n", vector, vectorType, strings.Join(elements, ", "))
+	return c.storeVReg(destination, "%"+vector)
+}
+
+// arm64Float16Bits converts the ordinary floating-point constant used by the
+// parser into IEEE binary16 bits for the H-form modified immediate.
+func arm64Float16Bits(value float64) uint16 {
+	bits := math.Float32bits(float32(value))
+	sign := uint16((bits >> 16) & 0x8000)
+	exponent := int((bits >> 23) & 0xff)
+	fraction := bits & 0x7fffff
+	if exponent == 0xff {
+		if fraction == 0 {
+			return sign | 0x7c00
+		}
+		return sign | 0x7e00
+	}
+	exponent -= 127
+	if exponent < -24 {
+		return sign
+	}
+	if exponent < -14 {
+		shift := uint(-exponent - 14)
+		mantissa := (fraction | 0x800000) >> (shift + 1)
+		if (fraction|0x800000)&(1<<shift) != 0 {
+			mantissa++
+		}
+		return sign | uint16(mantissa)
+	}
+	if exponent > 15 {
+		return sign | 0x7c00
+	}
+	halfExponent := uint16(exponent+15) << 10
+	mantissa := fraction >> 13
+	if fraction&0x1000 != 0 {
+		mantissa++
+		if mantissa == 0x400 {
+			return sign | halfExponent + 0x400
+		}
+	}
+	return sign | halfExponent | uint16(mantissa)
+}
diff --git a/arm64_lower_vector_reverse.go b/arm64_lower_vector_reverse.go
new file mode 100644
index 000000000..83da34f9e
--- /dev/null
+++ b/arm64_lower_vector_reverse.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorReverse(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	groupBytes, handled := map[Op]int{
+		"VREV16": 2,
+		"VREV32": 4,
+		"VREV64": 8,
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects two same-arrangement vector registers and no suffix: %q", op, ins.Raw)
+	}
+	sourceArrangement, sourceOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	if !sourceOK || !destinationOK || sourceArrangement != destinationArrangement {
+		return true, false, fmt.Errorf("arm64 %s expects matching vector arrangements: %q", op, ins.Raw)
+	}
+	elementBytes := sourceArrangement.elementBits / 8
+	if elementBytes == 0 || elementBytes >= groupBytes {
+		return true, false, fmt.Errorf("arm64 %s requires elements narrower than its %d-bit reversal groups: %q", op, groupBytes*8, ins.Raw)
+	}
+	source, err := c.loadARM64VectorInteger(ins.Args[0].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", sourceArrangement.lanes, sourceArrangement.elementBits)
+	groupElements := groupBytes / elementBytes
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s poison, <%d x i32> <", result, vectorType, source, vectorType, sourceArrangement.lanes)
+	for lane := 0; lane < sourceArrangement.lanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		groupStart := lane / groupElements * groupElements
+		reversedLane := groupStart + groupElements - 1 - lane%groupElements
+		fmt.Fprintf(c.b, "i32 %d", reversedLane)
+	}
+	c.b.WriteString(">\n")
+	return true, false, c.storeARM64VectorInteger(ins.Args[1].Reg, destinationArrangement, "%"+result)
+}
diff --git a/arm64_lower_vector_reverse_test.go b/arm64_lower_vector_reverse_test.go
new file mode 100644
index 000000000..7f35af2bf
--- /dev/null
+++ b/arm64_lower_vector_reverse_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64VectorReverseForms = `
+TEXT vectorreverseforms(SB),$0-0
+	VREV16 V0.B8, V1.B8
+	VREV16 V2.B16, V3.B16
+	VREV32 V4.B8, V5.B8
+	VREV32 V6.B16, V7.B16
+	VREV32 V8.H4, V9.H4
+	VREV32 V10.H8, V11.H8
+	VREV64 V12.B8, V13.B8
+	VREV64 V14.B16, V15.B16
+	VREV64 V16.H4, V17.H4
+	VREV64 V18.H8, V19.H8
+	VREV64 V20.S2, V21.S2
+	VREV64 V22.S4, V23.S4
+	RET
+`
+
+func TestTranslateARM64VectorReverseCompleteArchitecturalForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64VectorReverseForms, true)
+	file, err := Parse(ArchARM64, arm64VectorReverseForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"vectorreverseforms": {Name: "vectorreverseforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			// The twelve reverse operations plus six low-half extraction shuffles
+			// for the 64-bit arrangements must all survive LLVM normalization.
+			if got := strings.Count(ll, "shufflevector"); got != 18 {
+				t.Fatalf("ARM64 vector reverse emitted %d shuffles, want 18:\n%s", got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vector-reverse.ll", "arm64-vector-reverse.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64VectorReverseRejectsInvalidForms(t *testing.T) {
+	for _, tc := range []struct {
+		instruction string
+		goAccepts   bool
+	}{
+		{"VREV16 V0.H4, V1.H4", false},
+		{"VREV32 V0.S2, V1.S2", false},
+		// Go 1.27 accepts these reserved size=3 encodings; LLVM 22 and the ARM
+		// architecture reject them, so the translator must not mirror that bug.
+		{"VREV32 V0.D2, V1.D2", true},
+		{"VREV64 V0.D2, V1.D2", true},
+		{"VREV64 V0.B8, V1.B16", false},
+		{"VREV64.P V0.S4, V1.S4", false},
+	} {
+		t.Run(strings.NewReplacer(" ", "_", ",", "", ".", "_").Replace(tc.instruction), func(t *testing.T) {
+			source := "TEXT badvectorreverse(SB),$0-0\n\t" + tc.instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, tc.goAccepts)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu", Goarch: "arm64",
+				Sigs: map[string]FuncSig{"badvectorreverse": {Name: "badvectorreverse", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted invalid vector reverse form %q", tc.instruction)
+			}
+		})
+	}
+}
+
+func TestARM64VectorReverseRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT vectorreverse(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.B16]
+	VREV16 V0.B16, V1.B16
+	VREV32 V0.B16, V2.B16
+	VREV64 V0.B16, V3.B16
+	VST1 [V1.B16, V2.B16, V3.B16], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"vectorreverse": {
+				Name: "vectorreverse", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void vectorreverse(const uint8_t *, uint8_t *);
+int main(void) {
+  const uint8_t input[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+  const uint8_t want[48] = {
+    1,0,3,2,5,4,7,6,9,8,11,10,13,12,15,14,
+    3,2,1,0,7,6,5,4,11,10,9,8,15,14,13,12,
+    7,6,5,4,3,2,1,0,15,14,13,12,11,10,9,8
+  };
+  uint8_t got[48] = {0};
+  vectorreverse(input, got);
+  for (int i = 0; i < 48; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_vector_reverse", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_widening_add.go b/arm64_lower_widening_add.go
new file mode 100644
index 000000000..8b2ee5889
--- /dev/null
+++ b/arm64_lower_widening_add.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64WideningAddSubtractSpec struct {
+	signed   bool
+	subtract bool
+	wide     bool
+	highHalf bool
+}
+
+var arm64WideningAddSubtractOps = map[Op]arm64WideningAddSubtractSpec{
+	"VSADDL":  {signed: true},
+	"VSADDL2": {signed: true, highHalf: true},
+	"VSADDW":  {signed: true, wide: true},
+	"VSADDW2": {signed: true, wide: true, highHalf: true},
+	"VSSUBL":  {signed: true, subtract: true},
+	"VSSUBL2": {signed: true, subtract: true, highHalf: true},
+	"VSSUBW":  {signed: true, subtract: true, wide: true},
+	"VSSUBW2": {signed: true, subtract: true, wide: true, highHalf: true},
+	"VUADDL":  {},
+	"VUADDL2": {highHalf: true},
+	"VUADDW":  {wide: true},
+	"VUADDW2": {wide: true, highHalf: true},
+	"VUSUBL":  {subtract: true},
+	"VUSUBL2": {subtract: true, highHalf: true},
+	"VUSUBW":  {subtract: true, wide: true},
+	"VUSUBW2": {subtract: true, wide: true, highHalf: true},
+}
+
+// lowerARM64WideningAddSubtract implements the complete AdvSIMD
+// three-different add/subtract-long and add/subtract-wide family. Go 1.27 has
+// named forms for VUADDW/VUADDW2; the remaining architectural forms enter
+// through WORD decoding from external assembly.
+func (c *arm64Ctx) lowerARM64WideningAddSubtract(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	spec, handled := arm64WideningAddSubtractOps[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects two sources, one wide destination, and no suffix: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+	}
+
+	firstArrangement, firstOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	secondArrangement, secondOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	wantNarrowLanes := destinationArrangement.lanes
+	if spec.highHalf {
+		wantNarrowLanes *= 2
+	}
+	valid := firstOK && secondOK && destinationOK &&
+		destinationArrangement.lanes*destinationArrangement.elementBits == 128 &&
+		destinationArrangement.elementBits >= 16 && destinationArrangement.elementBits <= 64 &&
+		firstArrangement.elementBits*2 == destinationArrangement.elementBits &&
+		firstArrangement.lanes == wantNarrowLanes
+	if spec.wide {
+		valid = valid && secondArrangement == destinationArrangement
+	} else {
+		valid = valid && secondArrangement == firstArrangement
+	}
+	if !valid {
+		return true, false, fmt.Errorf("arm64 %s arrangements do not form an 8->16, 16->32, or 32->64 widening row: %q", op, ins.Raw)
+	}
+
+	first, err := c.loadARM64VectorInteger(ins.Args[0].Reg, firstArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if spec.highHalf {
+		first = c.selectARM64VectorHighHalf(firstArrangement, destinationArrangement.lanes, first)
+	}
+	narrowType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, firstArrangement.elementBits)
+	wideType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, destinationArrangement.elementBits)
+	extension := "zext"
+	if spec.signed {
+		extension = "sext"
+	}
+	wideFirst := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideFirst, extension, narrowType, first, wideType)
+
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, secondArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if !spec.wide {
+		if spec.highHalf {
+			second = c.selectARM64VectorHighHalf(secondArrangement, destinationArrangement.lanes, second)
+		}
+		wideSecond := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideSecond, extension, narrowType, second, wideType)
+		second = "%" + wideSecond
+	}
+
+	operation := "add"
+	left, right := "%"+wideFirst, second
+	if spec.subtract {
+		operation = "sub"
+		// Go syntax reverses the architectural Vn/Vm sources. Both SUBL and
+		// SUBW therefore compute the second source minus the widened first.
+		left, right = second, "%"+wideFirst
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", result, operation, wideType, left, right)
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, "%"+result)
+}
diff --git a/arm64_lower_widening_add_sub_test.go b/arm64_lower_widening_add_sub_test.go
new file mode 100644
index 000000000..97176d163
--- /dev/null
+++ b/arm64_lower_widening_add_sub_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64VectorWideningAddSubtract(base uint32, elementBits, narrow, wide, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2}[elementBits]
+	return base | size<<22 | uint32(narrow)<<16 | uint32(wide)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64RawWideningAddSubtractCompleteArchitectureFamily(t *testing.T) {
+	// These are the complete AdvSIMD three-different add/subtract-long and
+	// add/subtract-wide rows in x/arch's ARM64 architecture table.
+	families := []struct {
+		name string
+		base uint32
+	}{
+		{name: "VSADDL", base: 0x0e200000},
+		{name: "VSADDL2", base: 0x4e200000},
+		{name: "VSADDW", base: 0x0e201000},
+		{name: "VSADDW2", base: 0x4e201000},
+		{name: "VSSUBL", base: 0x0e202000},
+		{name: "VSSUBL2", base: 0x4e202000},
+		{name: "VSSUBW", base: 0x0e203000},
+		{name: "VSSUBW2", base: 0x4e203000},
+		{name: "VUADDL", base: 0x2e200000},
+		{name: "VUADDL2", base: 0x6e200000},
+		{name: "VUADDW", base: 0x2e201000},
+		{name: "VUADDW2", base: 0x6e201000},
+		{name: "VUSUBL", base: 0x2e202000},
+		{name: "VUSUBL2", base: 0x6e202000},
+		{name: "VUSUBW", base: 0x2e203000},
+		{name: "VUSUBW2", base: 0x6e203000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT ·wideningAddSubtractForms(SB), $0-0\n")
+	for _, family := range families {
+		for _, elementBits := range []int{8, 16, 32} {
+			word := encodeARM64VectorWideningAddSubtract(family.base, elementBits, 30, 29, 28)
+			decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			if err != nil {
+				t.Fatalf("decode %s %d-bit: %v", family.name, elementBits, err)
+			}
+			if decoded.Op != Op(family.name) || len(decoded.Args) != 3 ||
+				!strings.HasPrefix(string(decoded.Args[0].Reg), "V30.") ||
+				!strings.HasPrefix(string(decoded.Args[1].Reg), "V29.") ||
+				!strings.HasPrefix(string(decoded.Args[2].Reg), "V28.") {
+				t.Fatalf("decoded %s %d-bit %#08x as %#v; want reversed Vm=V30, Vn=V29, Vd=V28", family.name, elementBits, word, decoded)
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s %d-bit\n", word, family.name, elementBits)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"wideningAddSubtractForms": {Name: "wideningAddSubtractForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for operation, want := range map[string]int{
+				" = zext <":          36,
+				" = sext <":          36,
+				" = add <":           24,
+				" = sub <":           24,
+				" = shufflevector <": 72,
+			} {
+				if got := strings.Count(ll, operation); got != want {
+					t.Fatalf("%s emitted %d occurrences of %q, want %d:\n%s", triple, got, operation, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-widening-add-sub.ll", "arm64-widening-add-sub.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64WideningAddSubtractRejectsInvalidArrangements(t *testing.T) {
+	for _, instruction := range []string{
+		"VUADDL V0.B16, V1.B16, V2.H8",
+		"VUADDL2 V0.B8, V1.B8, V2.H8",
+		"VSADDL V0.B8, V1.H4, V2.H8",
+		"VSSUBL V0.H4, V1.H4, V2.S2",
+		"VUSUBW V0.B16, V1.H8, V2.H8",
+		"VUSUBW2 V0.B8, V1.H8, V2.H8",
+		"VSADDW V0.B8, V1.H8, V2.S4",
+		"VSSUBW V0.B8, V1.H8",
+		"VSSUBW.P V0.B8, V1.H8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT ·badWidening(SB), $0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs:         map[string]FuncSig{"badWidening": {Name: "badWidening", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted invalid ARM64 widening add/subtract form %q", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_widening_add_test.go b/arm64_lower_widening_add_test.go
new file mode 100644
index 000000000..430c0bf9e
--- /dev/null
+++ b/arm64_lower_widening_add_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64UnsignedWideningAddCompleteGoAssemblerForms(t *testing.T) {
+	type form struct{ narrow, wide string }
+	var source strings.Builder
+	source.WriteString("TEXT ·unsignedWideningAddForms(SB), $0-0\n")
+	for _, family := range []struct {
+		op    string
+		forms []form
+	}{
+		{op: "VUADDW", forms: []form{{"B8", "H8"}, {"H4", "S4"}, {"S2", "D2"}}},
+		{op: "VUADDW2", forms: []form{{"B16", "H8"}, {"H8", "S4"}, {"S4", "D2"}}},
+	} {
+		for _, form := range family.forms {
+			fmt.Fprintf(&source, "\t%s V0.%s, V1.%s, V2.%s\n", family.op, form.narrow, form.wide, form.wide)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"unsignedWideningAddForms": {Name: "unsignedWideningAddForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		if got := strings.Count(ll, " = zext <"); got != 6 {
+			t.Fatalf("%s emitted %d widening extensions, want 6:\n%s", triple, got, ll)
+		}
+		if got := strings.Count(ll, " = add <"); got != 6 {
+			t.Fatalf("%s emitted %d vector additions, want 6:\n%s", triple, got, ll)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-unsigned-widening-add.ll", "arm64-unsigned-widening-add.o", ll)
+	}
+}
+
+func TestTranslateARM64UnsignedWideningAddRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VUADDW V0.B16, V1.H8, V2.H8",
+		"VUADDW2 V0.B8, V1.H8, V2.H8",
+		"VUADDW V0.B8, V1.H8, V2.S4",
+		"VUADDW V0.H4, V1.D2, V2.D2",
+		"VUADDW V0.B8, V1.H8",
+		"VUADDW.P V0.B8, V1.H8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badUnsignedWideningAdd(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badUnsignedWideningAdd": {Name: "badUnsignedWideningAdd", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's VUADDW family", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_widening_multiply.go b/arm64_lower_widening_multiply.go
new file mode 100644
index 000000000..e12f708cb
--- /dev/null
+++ b/arm64_lower_widening_multiply.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64VectorWideningMultiply(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	type operationSpec struct {
+		signed     bool
+		accumulate string
+		highHalf   bool
+	}
+	spec, handled := map[Op]operationSpec{
+		"VSMULL": {signed: true}, "VSMULL2": {signed: true, highHalf: true},
+		"VSMLAL": {signed: true, accumulate: "add"}, "VSMLAL2": {signed: true, accumulate: "add", highHalf: true},
+		"VSMLSL": {signed: true, accumulate: "sub"}, "VSMLSL2": {signed: true, accumulate: "sub", highHalf: true},
+		"VUMULL": {}, "VUMULL2": {highHalf: true},
+		"VUMLAL": {accumulate: "add"}, "VUMLAL2": {accumulate: "add", highHalf: true},
+		"VUMLSL": {accumulate: "sub"}, "VUMLSL2": {accumulate: "sub", highHalf: true},
+	}[op]
+	if !handled {
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 3 {
+		return true, false, fmt.Errorf("arm64 %s expects two narrow sources, one wide destination, and no suffix: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			return true, false, fmt.Errorf("arm64 %s accepts only vector registers: %q", op, ins.Raw)
+		}
+	}
+	firstArrangement, firstOK := parseARM64VectorArrangement(ins.Args[0].Reg)
+	laneKind, lane, laneForm := arm64ParseVRegLane(ins.Args[0].Reg)
+	secondArrangement, secondOK := parseARM64VectorArrangement(ins.Args[1].Reg)
+	destinationArrangement, destinationOK := parseARM64VectorArrangement(ins.Args[2].Reg)
+	wantSourceLanes := destinationArrangement.lanes
+	if spec.highHalf {
+		wantSourceLanes *= 2
+	}
+	if laneForm {
+		sourceBits := 0
+		switch laneKind {
+		case 'H':
+			sourceBits = 16
+		case 'S':
+			sourceBits = 32
+		}
+		laneRegister, laneRegisterOK := arm64ParseVReg(ins.Args[0].Reg)
+		physicalLanes := 0
+		if sourceBits != 0 {
+			physicalLanes = 128 / sourceBits
+		}
+		firstArrangement = arm64VectorArrangement{elementBits: sourceBits, lanes: destinationArrangement.lanes}
+		firstOK = sourceBits != 0 && lane >= 0 && lane < physicalLanes && laneRegisterOK &&
+			(sourceBits != 16 || laneRegister <= 15)
+	}
+	if !firstOK || !secondOK || !destinationOK ||
+		firstArrangement.elementBits != secondArrangement.elementBits ||
+		firstArrangement.elementBits*2 != destinationArrangement.elementBits ||
+		secondArrangement.lanes != wantSourceLanes ||
+		(!laneForm && firstArrangement != secondArrangement) ||
+		destinationArrangement.lanes*destinationArrangement.elementBits != 128 {
+		return true, false, fmt.Errorf("arm64 %s arrangements do not form a B->H, H->S, or S->D widening multiply row: %q", op, ins.Raw)
+	}
+	var first string
+	if laneForm {
+		physical := arm64VectorArrangement{elementBits: firstArrangement.elementBits, lanes: 128 / firstArrangement.elementBits}
+		loaded, err := c.loadARM64VectorInteger(ins.Args[0].Reg, physical)
+		if err != nil {
+			return true, false, err
+		}
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n", element, physical.lanes, physical.elementBits, loaded, lane)
+		first = "poison"
+		for index := 0; index < destinationArrangement.lanes; index++ {
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %%%s, i32 %d\n",
+				inserted, destinationArrangement.lanes, firstArrangement.elementBits, first,
+				firstArrangement.elementBits, element, index)
+			first = "%" + inserted
+		}
+	} else {
+		var err error
+		first, err = c.loadARM64VectorInteger(ins.Args[0].Reg, firstArrangement)
+		if err != nil {
+			return true, false, err
+		}
+	}
+	second, err := c.loadARM64VectorInteger(ins.Args[1].Reg, secondArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if spec.highHalf {
+		if !laneForm {
+			first = c.selectARM64VectorHighHalf(firstArrangement, destinationArrangement.lanes, first)
+		}
+		second = c.selectARM64VectorHighHalf(secondArrangement, destinationArrangement.lanes, second)
+	}
+	narrowType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, firstArrangement.elementBits)
+	wideType := fmt.Sprintf("<%d x i%d>", destinationArrangement.lanes, destinationArrangement.elementBits)
+	extension := "zext"
+	if spec.signed {
+		extension = "sext"
+	}
+	wideFirst := c.newTmp()
+	wideSecond := c.newTmp()
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideFirst, extension, narrowType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s to %s\n", wideSecond, extension, narrowType, second, wideType)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", product, wideType, wideFirst, wideSecond)
+	result := "%" + product
+	if spec.accumulate != "" {
+		accumulator, err := c.loadARM64VectorInteger(ins.Args[2].Reg, destinationArrangement)
+		if err != nil {
+			return true, false, err
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", combined, spec.accumulate, wideType, accumulator, product)
+		result = "%" + combined
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[2].Reg, destinationArrangement, result)
+}
+
+func (c *arm64Ctx) selectARM64VectorHighHalf(arrangement arm64VectorArrangement, resultLanes int, value string) string {
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> poison, <%d x i32> <",
+		selected, arrangement.lanes, arrangement.elementBits, value, arrangement.lanes, arrangement.elementBits, resultLanes)
+	for lane := 0; lane < resultLanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", resultLanes+lane)
+	}
+	c.b.WriteString(">\n")
+	return "%" + selected
+}
diff --git a/arm64_lower_widening_multiply_test.go b/arm64_lower_widening_multiply_test.go
new file mode 100644
index 000000000..a18a48850
--- /dev/null
+++ b/arm64_lower_widening_multiply_test.go
@@ -0,0 +1,263 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64VectorWideningMultiplyCompleteGoAssemblerForms(t *testing.T) {
+	type form struct{ narrow, wide string }
+	lowForms := []form{{"B8", "H8"}, {"H4", "S4"}, {"S2", "D2"}}
+	highForms := []form{{"B16", "H8"}, {"H8", "S4"}, {"S4", "D2"}}
+	var source strings.Builder
+	source.WriteString("TEXT ·vectorWideningMultiplyForms(SB), $0-0\n")
+	for _, op := range []string{"VSMULL", "VSMLAL", "VSMLSL", "VUMULL", "VUMLAL", "VUMLSL"} {
+		for _, form := range lowForms {
+			fmt.Fprintf(&source, "\t%s V0.%s, V1.%s, V31.%s\n", op, form.narrow, form.narrow, form.wide)
+		}
+		for _, form := range highForms {
+			fmt.Fprintf(&source, "\t%s2 V2.%s, V3.%s, V30.%s\n", op, form.narrow, form.narrow, form.wide)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"vectorWideningMultiplyForms": {Name: "vectorWideningMultiplyForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"sext <", "zext <", "mul <", "add <", "sub <", "shufflevector <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s widening-multiply IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-vector-widening-multiply.ll", "arm64-vector-widening-multiply.o", ll)
+	}
+}
+
+func TestTranslateARM64RawWideningMultiplyByElementCompleteArchitecturalForms(t *testing.T) {
+	type operation struct {
+		name string
+		base uint32
+	}
+	operations := []operation{
+		{"SMLAL", 0x0f002000}, {"SMLAL2", 0x4f002000},
+		{"SMLSL", 0x0f006000}, {"SMLSL2", 0x4f006000},
+		{"SMULL", 0x0f00a000}, {"SMULL2", 0x4f00a000},
+		{"UMLAL", 0x2f002000}, {"UMLAL2", 0x6f002000},
+		{"UMLSL", 0x2f006000}, {"UMLSL2", 0x6f006000},
+		{"UMULL", 0x2f00a000}, {"UMULL2", 0x6f00a000},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawwideningmultiplyelementforms(SB),$0-0\n")
+	for _, operation := range operations {
+		for _, size := range []int{1, 2} {
+			laneCount := 8
+			laneRegister := 15
+			if size == 2 {
+				laneCount = 4
+				laneRegister = 31
+			}
+			for lane := 0; lane < laneCount; lane++ {
+				word := encodeARM64RawWideningMultiplyByElement(operation.base, size, lane, 30, laneRegister, 29)
+				if strings.HasPrefix(operation.name, "UMULL") {
+					form, ok := decodeARM64RawUMULL(word)
+					if !ok || !form.byElement || form.element != lane || form.first != 30 || form.second != laneRegister || form.destReg != 29 {
+						t.Fatalf("decode UMULL by-element %#08x = %#v, %v; want lane=%d first=30 second=%d destination=29", word, form, ok, lane, laneRegister)
+					}
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s size=%d lane=%d\n", word, operation.name, size, lane)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawwideningmultiplyelementforms": {Name: "rawwideningmultiplyelementforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"extractelement <8 x i16>", "extractelement <4 x i32>", "sext <", "zext <", "mul <", "add <", "sub <"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw widening-multiply by-element family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-widening-multiply-element.ll", "arm64-raw-widening-multiply-element.o", ir)
+		})
+	}
+}
+
+func encodeARM64RawWideningMultiplyByElement(base uint32, size, lane, sourceReg, laneReg, destinationReg int) uint32 {
+	word := base | uint32(size)<<22 | uint32(sourceReg)<<5 | uint32(destinationReg)
+	if size == 1 {
+		word |= uint32(laneReg&15) << 16
+		word |= uint32(lane&1) << 20
+		word |= uint32((lane>>1)&1) << 21
+		word |= uint32((lane>>2)&1) << 11
+		return word
+	}
+	word |= uint32(laneReg&15) << 16
+	word |= uint32((laneReg>>4)&1) << 20
+	word |= uint32(lane&1) << 21
+	word |= uint32((lane>>1)&1) << 11
+	return word
+}
+
+func TestARM64RawWideningMultiplyByElementRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	words := []uint32{
+		encodeARM64RawWideningMultiplyByElement(0x0f002000, 1, 0, 0, 1, 2), // SMLAL H4.
+		encodeARM64RawWideningMultiplyByElement(0x4f002000, 1, 7, 0, 1, 2), // SMLAL2 H8.
+		encodeARM64RawWideningMultiplyByElement(0x2f006000, 2, 3, 0, 1, 2), // UMLSL S2.
+		encodeARM64RawWideningMultiplyByElement(0x6f00a000, 2, 2, 0, 1, 2), // UMULL2 S4.
+	}
+	source := fmt.Sprintf(`
+TEXT rawwideningmultiplyelement(SB),$0-32
+	MOVD source+0(FP), R0
+	MOVD elements+8(FP), R1
+	MOVD accumulator+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VLD1 (R2), [V2.B16]
+	WORD $%#08x
+	VST1 [V2.B16], (R3)
+	ADD $16, R3
+	VLD1 (R2), [V2.B16]
+	WORD $%#08x
+	VST1 [V2.B16], (R3)
+	ADD $16, R3
+	VLD1 (R2), [V2.B16]
+	WORD $%#08x
+	VST1 [V2.B16], (R3)
+	ADD $16, R3
+	VLD1 (R2), [V2.B16]
+	WORD $%#08x
+	VST1 [V2.B16], (R3)
+	RET
+`, words[0], words[1], words[2], words[3])
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawwideningmultiplyelement": {
+			Name: "rawwideningmultiplyelement", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void rawwideningmultiplyelement(const void *, const void *, const void *, void *);
+int main(void) {
+  const uint16_t source_h[8] = {0xffff,2,0xfffd,4,0xfffb,6,0xfff9,8};
+  const uint16_t element_h[8] = {3,4,5,6,7,8,9,0xfff6};
+  const uint32_t accumulator_s[4] = {10,20,30,40};
+  uint8_t got[64] = {0};
+  uint8_t want[64] = {0};
+  rawwideningmultiplyelement(source_h, element_h, accumulator_s, got);
+  int32_t *want_s0 = (int32_t *)(want + 0);
+  int32_t *want_s1 = (int32_t *)(want + 16);
+  for (int i = 0; i < 4; i++) {
+    want_s0[i] = (int32_t)accumulator_s[i] + (int16_t)source_h[i] * (int16_t)element_h[0];
+    want_s1[i] = (int32_t)accumulator_s[i] + (int16_t)source_h[i + 4] * (int16_t)element_h[7];
+  }
+  const uint32_t *source_s = (const uint32_t *)source_h;
+  const uint32_t *element_s = (const uint32_t *)element_h;
+  const uint64_t *accumulator_d = (const uint64_t *)accumulator_s;
+  uint64_t *want_d0 = (uint64_t *)(want + 32);
+  uint64_t *want_d1 = (uint64_t *)(want + 48);
+  for (int i = 0; i < 2; i++) {
+    want_d0[i] = accumulator_d[i] - (uint64_t)source_s[i] * element_s[3];
+    want_d1[i] = (uint64_t)source_s[i + 2] * element_s[2];
+  }
+  for (int i = 0; i < 64; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_widening_multiply_element", triple, ir, mainC, nil)
+}
+
+func TestTranslateARM64VectorWideningMultiplyRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VUMULL V0.B16, V1.B16, V2.H8",
+		"VUMULL2 V0.B8, V1.B8, V2.H8",
+		"VUMLAL V0.H4, V1.H4, V2.H4",
+		"VUMLSL V0.H8, V1.H8, V2.S4",
+		"VSMULL V0.D1, V1.D1, V2.D2",
+		"VSMLAL V0.S2, V1.S2, V2.S2",
+		"VSMLSL2 V0.B8, V1.B8, V2.H8",
+		"VUMULL.P V0.B8, V1.B8, V2.H8",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT ·badVectorWideningMultiply(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badVectorWideningMultiply": {Name: "badVectorWideningMultiply", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's vector widening-multiply forms", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_widening_shift.go b/arm64_lower_widening_shift.go
new file mode 100644
index 000000000..adee3cd0f
--- /dev/null
+++ b/arm64_lower_widening_shift.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *arm64Ctx) lowerARM64WideningShift(op Op, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "VSHLL", "VSHLL2", "VUSHLL", "VUSHLL2", "VSSHLL", "VSSHLL2", "VUXTL", "VUXTL2", "VSXTL", "VSXTL2":
+	default:
+		return false, false, nil
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) {
+		return true, false, fmt.Errorf("arm64 %s does not accept an opcode suffix: %q", op, ins.Raw)
+	}
+	isExtendAlias := strings.Contains(string(op), "XTL")
+	wantArgs := 3
+	if isExtendAlias {
+		wantArgs = 2
+	}
+	if len(ins.Args) != wantArgs {
+		return true, false, fmt.Errorf("arm64 %s expects %d operands: %q", op, wantArgs, ins.Raw)
+	}
+	shift := int64(0)
+	sourceIndex := 0
+	if !isExtendAlias {
+		if ins.Args[0].Kind != OpImm {
+			return true, false, fmt.Errorf("arm64 %s expects an immediate shift: %q", op, ins.Raw)
+		}
+		shift = ins.Args[0].Imm
+		sourceIndex = 1
+	}
+	if ins.Args[sourceIndex].Kind != OpReg || ins.Args[sourceIndex+1].Kind != OpReg {
+		return true, false, fmt.Errorf("arm64 %s expects vector register source and destination: %q", op, ins.Raw)
+	}
+	sourceArrangement, valid := parseARM64VectorArrangement(ins.Args[sourceIndex].Reg)
+	if !valid {
+		return true, false, fmt.Errorf("arm64 %s has an invalid source arrangement: %q", op, ins.Raw)
+	}
+	destinationArrangement, valid := parseARM64VectorArrangement(ins.Args[sourceIndex+1].Reg)
+	if !valid {
+		return true, false, fmt.Errorf("arm64 %s has an invalid destination arrangement: %q", op, ins.Raw)
+	}
+	highHalf := strings.HasSuffix(string(op), "2")
+	wantSourceLanes := destinationArrangement.lanes
+	if highHalf {
+		wantSourceLanes *= 2
+	}
+	if sourceArrangement.lanes != wantSourceLanes ||
+		destinationArrangement.elementBits != sourceArrangement.elementBits*2 ||
+		destinationArrangement.lanes*destinationArrangement.elementBits != 128 {
+		return true, false, fmt.Errorf("arm64 %s source and destination arrangements do not form a widening pair: %q", op, ins.Raw)
+	}
+	maxShift := int64(sourceArrangement.elementBits - 1)
+	// LLVM/Clang also emits the GNU SHLL alias. Unlike the Go V{S,U}SHLL
+	// spellings, its fixed-width long form permits the full source width.
+	if op == "VSHLL" || op == "VSHLL2" {
+		maxShift++
+	}
+	if shift < 0 || shift > maxShift {
+		return true, false, fmt.Errorf("arm64 %s shift must be in [0,%d]: %q", op, maxShift, ins.Raw)
+	}
+
+	source, err := c.loadARM64VectorInteger(ins.Args[sourceIndex].Reg, sourceArrangement)
+	if err != nil {
+		return true, false, err
+	}
+	if highHalf {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %s, <%d x i%d> poison, <%d x i32> <", selected, sourceArrangement.lanes, sourceArrangement.elementBits, source, sourceArrangement.lanes, sourceArrangement.elementBits, destinationArrangement.lanes)
+		for i := 0; i < destinationArrangement.lanes; i++ {
+			if i != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", destinationArrangement.lanes+i)
+		}
+		c.b.WriteString(">\n")
+		source = "%" + selected
+	}
+
+	extended := c.newTmp()
+	extension := "zext"
+	if strings.HasPrefix(string(op), "VSS") || strings.HasPrefix(string(op), "VSX") {
+		extension = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %s to <%d x i%d>\n", extended, extension, destinationArrangement.lanes, sourceArrangement.elementBits, source, destinationArrangement.lanes, destinationArrangement.elementBits)
+	result := "%" + extended
+	if !isExtendAlias {
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl <%d x i%d> %s, <", shifted, destinationArrangement.lanes, destinationArrangement.elementBits, result)
+		for i := 0; i < destinationArrangement.lanes; i++ {
+			if i != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i%d %d", destinationArrangement.elementBits, shift)
+		}
+		c.b.WriteString(">\n")
+		result = "%" + shifted
+	}
+	return true, false, c.storeARM64VectorInteger(ins.Args[sourceIndex+1].Reg, destinationArrangement, result)
+}
diff --git a/arm64_lower_widening_shift_test.go b/arm64_lower_widening_shift_test.go
new file mode 100644
index 000000000..798bef59c
--- /dev/null
+++ b/arm64_lower_widening_shift_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64WideningShiftCompleteGoAssemblerForms(t *testing.T) {
+	type form struct {
+		source      string
+		destination string
+		maxShift    int
+	}
+	low := []form{{"B8", "H8", 7}, {"H4", "S4", 15}, {"S2", "D2", 31}}
+	high := []form{{"B16", "H8", 7}, {"H8", "S4", 15}, {"S4", "D2", 31}}
+	var src strings.Builder
+	src.WriteString("TEXT ·wideningforms(SB), $0-0\n")
+	for _, signed := range []bool{false, true} {
+		prefix := "VU"
+		if signed {
+			prefix = "VS"
+		}
+		for _, variant := range []struct {
+			suffix string
+			forms  []form
+		}{{"", low}, {"2", high}} {
+			for _, form := range variant.forms {
+				for _, shift := range []int{0, form.maxShift} {
+					fmt.Fprintf(&src, "\t%sSHLL%s $%d, V0.%s, V1.%s\n", prefix, variant.suffix, shift, form.source, form.destination)
+				}
+				fmt.Fprintf(&src, "\t%sXTL%s V0.%s, V1.%s\n", prefix, variant.suffix, form.source, form.destination)
+			}
+		}
+	}
+	src.WriteString("\tRET\n")
+	if currentGoMinorAtLeast(27) {
+		requireARM64GoAssemblerResult(t, src.String(), true)
+	}
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"wideningforms": {Name: "wideningforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for operation, want := range map[string]int{"zext <": 18, "sext <": 18, "shl <": 24} {
+			if got := strings.Count(ll, operation); got != want {
+				t.Fatalf("%s emitted %d %q operations, want %d:\n%s", triple, got, operation, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-widening-shift.ll", "arm64-widening-shift.o", ll)
+	}
+}
+
+func TestTranslateARM64WideningShiftRejectsFormsOutsideGoAssemblerTable(t *testing.T) {
+	for _, instruction := range []string{
+		"VUSHLL $8, V0.B8, V1.H8",
+		"VSSHLL $-1, V0.H4, V1.S4",
+		"VUSHLL2 $0, V0.B8, V1.H8",
+		"VSSHLL2 $0, V0.B16, V1.S4",
+		"VUXTL V0.B16, V1.H8",
+		"VSXTL2 V0.H4, V1.S4",
+		"VUXTL $0, V0.B8, V1.H8",
+		"VSSHLL.P $0, V0.B8, V1.H8",
+	} {
+		t.Run(strings.Fields(instruction)[0]+"-"+strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT ·badwidening(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			if currentGoMinorAtLeast(27) {
+				requireARM64GoAssemblerResult(t, src, false)
+			}
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs: map[string]FuncSig{
+					"badwidening": {Name: "badwidening", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's widening optab", instruction)
+			}
+		})
+	}
+}
+
+func currentGoMinorAtLeast(want int) bool {
+	version := runtime.Version()
+	start := strings.Index(version, "go1.")
+	if start < 0 {
+		return false
+	}
+	minor := version[start+len("go1."):]
+	if end := strings.IndexFunc(minor, func(r rune) bool { return r < '0' || r > '9' }); end >= 0 {
+		minor = minor[:end]
+	}
+	got, err := strconv.Atoi(minor)
+	return err == nil && got >= want
+}
diff --git a/arm64_lower_word.go b/arm64_lower_word.go
index fc79f7dfc..6a3cc8066 100644
--- a/arm64_lower_word.go
+++ b/arm64_lower_word.go
@@ -2,15 +2,117 @@ package plan9asm
 
 import "fmt"
 
-// lowerRawWord models the small set of flag-writing instructions emitted as
-// raw encodings by generated Go assembly. Unknown WORD values remain ignored,
-// matching the translator's existing permissive behavior for embedded opcodes.
+// lowerRawWord models raw encodings only when their register and flag effects
+// are known. Silently emitting nothing for an unknown machine instruction
+// would report success while changing program semantics.
 func (c *arm64Ctx) lowerRawWord(ins Instr) error {
-	if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+	word, err := arm64RawWordValue(ins)
+	if err != nil {
+		return err
+	}
+	if family, _, ok := decodeARM64RawFloatFamily(word); ok {
+		return family.lower(c, word)
+	}
+	if form, ok := decodeARM64RawException(word); ok {
+		return c.lowerRawException(form)
+	}
+	if form, ok := decodeARM64RawTLBI(word); ok {
+		return c.lowerRawTLBI(form)
+	}
+	if family, _, ok := decodeARM64RawStateFamily(word); ok {
+		return family.lower(c, word)
+	}
+	if family, decoded, ok := decodeARM64RawSVEFamily(word); ok {
+		return family.lower(c, decoded)
+	}
+	for _, family := range arm64RawSVEVectorFamilies {
+		if family.matches(word) {
+			return family.lower(c, word)
+		}
+	}
+	if _, reservedLoad := arm64RawSVEUnsignedLoadRows[word&0xffe0e000]; reservedLoad {
+		return fmt.Errorf("reserved ARM64 SVE load encoding %#08x: %q", word, ins.Raw)
+	}
+	if form, ok := decodeARM64RawSVELD1B(word); ok {
+		return c.lowerRawSVELD1B(form)
+	}
+	if form, ok := decodeARM64RawSystemRegister(word); ok {
+		return c.lowerRawSystemRegister(form)
+	}
+	if immediate, ok := decodeARM64RawHint(word); ok {
+		c.emitARM64Hint(immediate)
 		return nil
 	}
-
-	word := uint32(ins.Args[0].Imm)
+	if family, _, ok := decodeARM64RawVectorFamily(word); ok {
+		return family.lower(c, word)
+	}
+	if form, ok := decodeARM64RawStructureLane(word); ok {
+		return c.lowerRawStructureLane(form)
+	}
+	if form, ok := decodeARM64RawLDnR(word); ok {
+		return c.lowerRawLDnR(form)
+	}
+	if form, ok := decodeARM64RawMoveWide(word); ok {
+		return c.lowerRawMoveWide(form)
+	}
+	if form, ok := decodeARM64RawSVEAddress(word); ok {
+		return c.lowerRawSVEAddress(form)
+	}
+	if form, ok := decodeARM64RawSVECnt(word); ok {
+		return c.lowerRawSVECnt(form)
+	}
+	if form, ok := decodeARM64RawBitfield(word); ok {
+		return c.lowerRawBitfield(form)
+	}
+	if form, ok := decodeARM64RawSVEPTrue(word); ok {
+		return c.lowerRawSVEPTrue(form)
+	}
+	if form, ok := decodeARM64RawSVELDST1D(word); ok {
+		return c.lowerRawSVELDST1D(form)
+	}
+	if form, ok := decodeARM64RawSVELDST1W(word); ok {
+		return c.lowerRawSVELDST1W(form)
+	}
+	if reduction, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+		return c.lowerARM64SVEAddReductionForm(
+			reduction.spec,
+			reduction.form,
+			reduction.destination,
+		)
+	}
+	if form, ok := decodeARM64RawSVEFloat(word); ok {
+		return c.lowerRawSVEFloat(form)
+	}
+	if form, ok := decodeARM64RawSVELoadStore(word); ok {
+		return c.lowerRawSVELoadStore(form)
+	}
+	if form, ok := decodeARM64RawSVEDupImmediate(word); ok {
+		return c.lowerRawSVEDupImmediate(form)
+	}
+	if form, ok := decodeARM64RawSVEDupGeneral(word); ok {
+		return c.lowerRawSVEDupGeneral(form)
+	}
+	if form, ok := decodeARM64RawSVEDupElement(word); ok {
+		return c.lowerRawSVEDupElement(form)
+	}
+	if form, ok := decodeARM64RawSVEAdd(word); ok {
+		return c.lowerRawSVEAdd(form)
+	}
+	if op, form, ok := decodeARM64RawSVEAddSub(word); ok {
+		return c.lowerRawSVEAddSub(arm64SVEAddSubSpecs[op], form)
+	}
+	if form, ok := decodeARM64RawSVEShift(word); ok {
+		return c.lowerRawSVELSR(form)
+	}
+	if form, ok := decodeARM64RawSVESelect(word); ok {
+		return c.lowerRawSVESelect(form)
+	}
+	if form, ok := decodeARM64RawSVEEOR(word); ok {
+		return c.lowerRawSVEEOR(form)
+	}
+	if form, ok := decodeARM64RawSVEPermute(word); ok {
+		return c.lowerRawSVEPermute(form)
+	}
 	switch {
 	case word == 0xea00001f: // TST X0, X0 (ANDS XZR, X0, X0)
 		value, err := c.loadReg("R0")
@@ -49,5 +151,5 @@ func (c *arm64Ctx) lowerRawWord(ins Instr) error {
 		return nil
 	}
 
-	return nil
+	return fmt.Errorf("unsupported ARM64 WORD encoding %#08x: %q", word, ins.Raw)
 }
diff --git a/arm64_lower_word_add_high_narrow.go b/arm64_lower_word_add_high_narrow.go
new file mode 100644
index 000000000..d910da0fb
--- /dev/null
+++ b/arm64_lower_word_add_high_narrow.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawAddHighNarrow struct {
+	subtract               bool
+	rounded                bool
+	highHalf               bool
+	sourceArrangement      arm64VectorArrangement
+	destinationArrangement arm64VectorArrangement
+	first                  int
+	second                 int
+	destination            int
+}
+
+func decodeARM64RawAddHighNarrow(word uint32) (arm64RawAddHighNarrow, bool) {
+	const (
+		registerBits = uint32(0x001f03ff)
+		sizeBits     = uint32(0x00c00000)
+	)
+	base := word &^ (registerBits | sizeBits)
+	if base != 0x0e204000 && base != 0x4e204000 &&
+		base != 0x2e204000 && base != 0x6e204000 &&
+		base != 0x0e206000 && base != 0x4e206000 &&
+		base != 0x2e206000 && base != 0x6e206000 {
+		return arm64RawAddHighNarrow{}, false
+	}
+
+	size := int(word>>22) & 3
+	if size == 3 {
+		return arm64RawAddHighNarrow{}, false
+	}
+	sourceBits := 16 << size
+	sourceLanes := 128 / sourceBits
+	highHalf := word&(1<<30) != 0
+	destinationLanes := sourceLanes
+	if highHalf {
+		destinationLanes *= 2
+	}
+
+	return arm64RawAddHighNarrow{
+		subtract:               word&(1<<13) != 0,
+		rounded:                word&(1<<29) != 0,
+		highHalf:               highHalf,
+		sourceArrangement:      arm64VectorArrangement{elementBits: sourceBits, lanes: sourceLanes},
+		destinationArrangement: arm64VectorArrangement{elementBits: sourceBits / 2, lanes: destinationLanes},
+		first:                  int(word>>5) & 31,
+		second:                 int(word>>16) & 31,
+		destination:            int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawAddHighNarrow(form arm64RawAddHighNarrow) error {
+	firstReg := Reg(fmt.Sprintf("V%d", form.first))
+	secondReg := Reg(fmt.Sprintf("V%d", form.second))
+	destinationReg := Reg(fmt.Sprintf("V%d", form.destination))
+
+	first, err := c.loadARM64VectorInteger(firstReg, form.sourceArrangement)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARM64VectorInteger(secondReg, form.sourceArrangement)
+	if err != nil {
+		return err
+	}
+
+	sourceType := fmt.Sprintf("<%d x i%d>", form.sourceArrangement.lanes, form.sourceArrangement.elementBits)
+	operation := "add"
+	if form.subtract {
+		operation = "sub"
+	}
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", combined, operation, sourceType, first, second)
+	value := "%" + combined
+	if form.rounded {
+		rounded := c.newTmp()
+		rounding := int64(1) << (form.destinationArrangement.elementBits - 1)
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n",
+			rounded, sourceType, value, arm64VectorIntegerSplat(form.sourceArrangement, rounding))
+		value = "%" + rounded
+	}
+
+	shifted := c.newTmp()
+	shift := arm64VectorIntegerSplat(form.sourceArrangement, int64(form.destinationArrangement.elementBits))
+	fmt.Fprintf(c.b, "  %%%s = lshr %s %s, %s\n", shifted, sourceType, value, shift)
+	narrowType := fmt.Sprintf("<%d x i%d>", form.sourceArrangement.lanes, form.destinationArrangement.elementBits)
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", narrowed, sourceType, shifted, narrowType)
+	if !form.highHalf {
+		return c.storeARM64VectorInteger(destinationReg, form.destinationArrangement, "%"+narrowed)
+	}
+
+	result, err := c.loadARM64VectorInteger(destinationReg, form.destinationArrangement)
+	if err != nil {
+		return err
+	}
+	fullDestinationType := fmt.Sprintf("<%d x i%d>",
+		form.destinationArrangement.lanes,
+		form.destinationArrangement.elementBits,
+	)
+	for lane := 0; lane < form.sourceArrangement.lanes; lane++ {
+		element := c.newTmp()
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", element, narrowType, narrowed, lane)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s %s, i%d %%%s, i32 %d\n",
+			inserted,
+			fullDestinationType,
+			result,
+			form.destinationArrangement.elementBits,
+			element,
+			form.sourceArrangement.lanes+lane,
+		)
+		result = "%" + inserted
+	}
+	return c.storeARM64VectorInteger(destinationReg, form.destinationArrangement, result)
+}
diff --git a/arm64_lower_word_add_high_narrow_test.go b/arm64_lower_word_add_high_narrow_test.go
new file mode 100644
index 000000000..7bf35d899
--- /dev/null
+++ b/arm64_lower_word_add_high_narrow_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawAddHighNarrow(base uint32, size, first, second, destination int) uint32 {
+	return base |
+		uint32(size)<<22 |
+		uint32(second)<<16 |
+		uint32(first)<<5 |
+		uint32(destination)
+}
+
+func TestTranslateARM64RawAddHighNarrowCompleteArchitectureFamily(t *testing.T) {
+	families := []struct {
+		name string
+		base uint32
+	}{
+		{"ADDHN", 0x0e204000},
+		{"ADDHN2", 0x4e204000},
+		{"RADDHN", 0x2e204000},
+		{"RADDHN2", 0x6e204000},
+		{"SUBHN", 0x0e206000},
+		{"SUBHN2", 0x4e206000},
+		{"RSUBHN", 0x2e206000},
+		{"RSUBHN2", 0x6e206000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT addHighNarrowArchitectureForms(SB),$0-0\n")
+	for _, family := range families {
+		for size := 0; size < 3; size++ {
+			for _, registers := range [][3]int{{0, 1, 2}, {31, 30, 29}} {
+				word := encodeARM64RawAddHighNarrow(
+					family.base,
+					size,
+					registers[0],
+					registers[1],
+					registers[2],
+				)
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s size=%d\n", word, family.name, size)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"addHighNarrowArchitectureForms": {
+						Name: "addHighNarrowArchitectureForms",
+						Ret:  Void,
+					},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{" add <", " sub <", "lshr <", "trunc <", "insertelement <"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw add-high-narrow IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-add-high-narrow.ll", "arm64-add-high-narrow.o", ir)
+		})
+	}
+}
+
+func TestARM64RawAddHighNarrowDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0ee04000, // Reserved size=3.
+		0x0e205000, // Different opcode in the same Advanced SIMD group.
+		0x0e204400, // Different opcode in the same Advanced SIMD group.
+		0x0e204000 | 1<<31,
+	} {
+		if form, ok := decodeARM64RawAddHighNarrow(word); ok {
+			t.Fatalf("decoder accepted adjacent/reserved encoding %#08x as %#v", word, form)
+		}
+	}
+}
diff --git a/arm64_lower_word_bfloat_convert.go b/arm64_lower_word_bfloat_convert.go
new file mode 100644
index 000000000..530856f37
--- /dev/null
+++ b/arm64_lower_word_bfloat_convert.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawBFloatConvert struct {
+	vector      bool
+	high        bool
+	source      int
+	destination int
+}
+
+var arm64RawBFloatConvertSpecs = map[uint32]struct {
+	vector bool
+	high   bool
+}{
+	0x1e634000: {},
+	0x0ea16800: {vector: true},
+	0x4ea16800: {vector: true, high: true},
+}
+
+func decodeARM64RawBFloatConvert(word uint32) (arm64RawBFloatConvert, bool) {
+	const registers = uint32(31<<5 | 31)
+	spec, ok := arm64RawBFloatConvertSpecs[word&^registers]
+	if !ok {
+		return arm64RawBFloatConvert{}, false
+	}
+	return arm64RawBFloatConvert{
+		vector:      spec.vector,
+		high:        spec.high,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawBFloatConvert(form arm64RawBFloatConvert) error {
+	if !form.vector {
+		source, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.source)), 32)
+		if err != nil {
+			return err
+		}
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fptrunc float %s to bfloat\n", converted, source)
+		bits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast bfloat %%%s to i16\n", bits, converted)
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i16 %%%s to i64\n", wide, bits)
+		return c.storeReg(Reg(fmt.Sprintf("F%d", form.destination)), "%"+wide)
+	}
+
+	source, err := c.loadVReg(Reg(fmt.Sprintf("V%d", form.source)))
+	if err != nil {
+		return err
+	}
+	floats := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x float>\n", floats, source)
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fptrunc <4 x float> %%%s to <4 x bfloat>\n", converted, floats)
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x bfloat> %%%s to i64\n", bits, converted)
+
+	lanes := "zeroinitializer"
+	destination := Reg(fmt.Sprintf("V%d", form.destination))
+	if form.high {
+		original, err := c.loadVReg(destination)
+		if err != nil {
+			return err
+		}
+		existing := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", existing, original)
+		lanes = "%" + existing
+	}
+	lane := 0
+	if form.high {
+		lane = 1
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %s, i64 %%%s, i64 %d\n", updated, lanes, bits, lane)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, updated)
+	return c.storeVReg(destination, "%"+bytes)
+}
diff --git a/arm64_lower_word_bfloat_convert_test.go b/arm64_lower_word_bfloat_convert_test.go
new file mode 100644
index 000000000..1bffa6f34
--- /dev/null
+++ b/arm64_lower_word_bfloat_convert_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawBFloatConvertDecoderCompleteArchitectureFamily(t *testing.T) {
+	formats := []struct {
+		base   uint32
+		vector bool
+		high   bool
+	}{
+		{base: 0x1e634000},
+		{base: 0x0ea16800, vector: true},
+		{base: 0x4ea16800, vector: true, high: true},
+	}
+
+	count := 0
+	for _, format := range formats {
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 32; destination++ {
+				word := format.base | uint32(source)<<5 | uint32(destination)
+				form, ok := decodeARM64RawBFloatConvert(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				if form.vector != format.vector || form.high != format.high ||
+					form.source != source || form.destination != destination {
+					t.Fatalf("decode %#08x = %+v", word, form)
+				}
+				count++
+			}
+		}
+	}
+	if count != 3072 {
+		t.Fatalf("covered %d BFCVT/BFCVTN encodings, want 3072", count)
+	}
+}
+
+func TestTranslateARM64RawBFloatConvertCompleteArchitectureFamily(t *testing.T) {
+	formats := []struct {
+		name string
+		base uint32
+	}{
+		{name: "BFCVT H0, S1", base: 0x1e634000},
+		{name: "BFCVTN V2.4H, V3.4S", base: 0x0ea16800},
+		{name: "BFCVTN2 V4.8H, V5.4S", base: 0x4ea16800},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawBFloatConvertFamily(SB),$0-0\n")
+	for index, format := range formats {
+		word := format.base | uint32(index*2+1)<<5 | uint32(index*2)
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", word, format.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawBFloatConvertFamily": {Name: "rawBFloatConvertFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"fptrunc float", "to bfloat",
+				"fptrunc <4 x float>", "to <4 x bfloat>",
+				"insertelement <2 x i64>", "i64 1",
+				`"target-features"="+bf16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw BFCVT/BFCVTN IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-bfloat-convert.ll", "arm64-raw-bfloat-convert.o", ir)
+		})
+	}
+}
+
+func TestARM64RawBFloatConvertDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1e234000, // Different scalar floating type.
+		0x2ea16800, // Reserved vector Q/op combination.
+		0x0e216800, // Different vector conversion opcode.
+		0x45218400, // SVE BFCVT.
+	} {
+		if _, ok := decodeARM64RawBFloatConvert(word); ok {
+			t.Fatalf("BFCVT/BFCVTN decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_bfloat_dot.go b/arm64_lower_word_bfloat_dot.go
new file mode 100644
index 000000000..9749761fb
--- /dev/null
+++ b/arm64_lower_word_bfloat_dot.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import "fmt"
+
+// arm64RawBFloatDot covers the two Advanced SIMD BFDOT encodings: vector and
+// by-element. Both accept 64- and 128-bit arrangements. The indexed form
+// selects one of four BF16 pairs from any source V register.
+type arm64RawBFloatDot struct {
+	indexed     bool
+	lane        int
+	lanes       int
+	destination int
+	left        int
+	right       int
+}
+
+func decodeARM64RawBFloatDot(word uint32) (arm64RawBFloatDot, bool) {
+	form := arm64RawBFloatDot{lane: 0}
+	switch {
+	case word&0xbfe0fc00 == 0x2e40fc00: // BFDOT (vector).
+	case word&0xbfc0f400 == 0x0f40f000: // BFDOT (by element).
+		form.indexed = true
+		form.lane = int(word>>21)&1 | int(word>>10)&2
+	default:
+		return arm64RawBFloatDot{}, false
+	}
+	form.lanes = 2
+	if word&(1<<30) != 0 {
+		form.lanes = 4
+	}
+	form.destination = int(word) & 31
+	form.left = int(word>>5) & 31
+	form.right = int(word>>16) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawBFloatDot(form arm64RawBFloatDot) error {
+	accumulatorArrangement := arm64VectorArrangement{elementBits: 32, lanes: form.lanes}
+	inputArrangement := arm64VectorArrangement{elementBits: 16, lanes: form.lanes * 2}
+	accumulatorReg := Reg(fmt.Sprintf("V%d", form.destination))
+
+	accumulator, err := c.loadARM64VectorFloat(accumulatorReg, accumulatorArrangement)
+	if err != nil {
+		return err
+	}
+	left, err := c.loadARM64VectorInteger(Reg(fmt.Sprintf("V%d", form.left)), inputArrangement)
+	if err != nil {
+		return err
+	}
+	leftBFloat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x bfloat>\n",
+		leftBFloat, inputArrangement.lanes, left, inputArrangement.lanes)
+
+	rightArrangement := inputArrangement
+	if form.indexed {
+		rightArrangement.lanes = 8
+	}
+	right, err := c.loadARM64VectorInteger(Reg(fmt.Sprintf("V%d", form.right)), rightArrangement)
+	if err != nil {
+		return err
+	}
+	rightBFloat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i16> %s to <%d x bfloat>\n",
+		rightBFloat, rightArrangement.lanes, right, rightArrangement.lanes)
+	rightValue := "%" + rightBFloat
+	if form.indexed {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x bfloat> %s, <8 x bfloat> poison, <%d x i32> <",
+			selected, rightValue, inputArrangement.lanes)
+		for i := 0; i < inputArrangement.lanes; i++ {
+			if i != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", form.lane*2+i%2)
+		}
+		c.b.WriteString(">\n")
+		rightValue = "%" + selected
+	}
+
+	result := c.newTmp()
+	fmt.Fprintf(c.b,
+		"  %%%s = call <%d x float> @llvm.aarch64.neon.bfdot.v%df32.v%dbf16(<%d x float> %s, <%d x bfloat> %%%s, <%d x bfloat> %s)\n",
+		result, form.lanes, form.lanes, inputArrangement.lanes,
+		form.lanes, accumulator, inputArrangement.lanes, leftBFloat,
+		inputArrangement.lanes, rightValue)
+	return c.storeARM64VectorFloat(accumulatorReg, accumulatorArrangement, "%"+result)
+}
diff --git a/arm64_lower_word_bfloat_dot_test.go b/arm64_lower_word_bfloat_dot_test.go
new file mode 100644
index 000000000..4d5268f05
--- /dev/null
+++ b/arm64_lower_word_bfloat_dot_test.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawBFloatDotReportedWord(t *testing.T) {
+	const source = `TEXT bfloatDot(SB), $0-0
+	WORD $0x2e40fc00 // BFDOT V0.2S, V0.4H, V0.4H
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"bfloatDot": {Name: "bfloatDot", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawBFloatDotCompleteFormats(t *testing.T) {
+	// LLVM 22's AArch64 encoder has vector and indexed-element BFDOT forms.
+	// Both use Q=0/1; the indexed form has four pair positions and 32 Rm values.
+	formats := []struct {
+		base    uint32
+		indexed bool
+	}{
+		{base: 0x2e40fc00},
+		{base: 0x0f40f000, indexed: true},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT bfloatDotForms(SB), $0-0\n")
+	for _, format := range formats {
+		for _, q := range []uint32{0, 1 << 30} {
+			lanes := 1
+			if format.indexed {
+				lanes = 4
+			}
+			for lane := 0; lane < lanes; lane++ {
+				for _, reg := range []uint32{0, 15, 31} {
+					word := format.base | q | reg<<16 | reg<<5 | reg
+					if format.indexed {
+						word |= uint32(lane&1)<<21 | uint32(lane&2)<<10
+					}
+					form, ok := decodeARM64RawBFloatDot(word)
+					if !ok || form.indexed != format.indexed || form.lane != lane ||
+						form.destination != int(reg) || form.left != int(reg) || form.right != int(reg) {
+						t.Fatalf("decode %#08x = %+v, valid=%v", word, form, ok)
+					}
+					wantLanes := 2
+					if q != 0 {
+						wantLanes = 4
+					}
+					if form.lanes != wantLanes {
+						t.Fatalf("decode %#08x has %d lanes, want %d", word, form.lanes, wantLanes)
+					}
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	// Each five-bit register field is independent, including V31.
+	for _, format := range formats {
+		for register := uint32(0); register < 32; register++ {
+			for field, shift := range []uint{0, 5, 16} {
+				word := format.base | 1<<30
+				word |= register << shift
+				form, ok := decodeARM64RawBFloatDot(word)
+				if !ok {
+					t.Fatalf("decoder rejected register field %d in %#08x", field, word)
+				}
+				got := []int{form.destination, form.left, form.right}[field]
+				if got != int(register) {
+					t.Fatalf("register field %d in %#08x decoded as %d", field, word, got)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bfloatDotForms": {Name: "bfloatDotForms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+bf16"`,
+				"@llvm.aarch64.neon.bfdot.v2f32.v4bf16",
+				"@llvm.aarch64.neon.bfdot.v4f32.v8bf16",
+				"shufflevector <8 x bfloat>",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s BFDOT lowering omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-bfloat-dot.ll", "arm64-raw-bfloat-dot.o", ir)
+		})
+	}
+}
+
+func TestARM64RawBFloatDotRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e40f800, // Distinct BF16 opcode.
+		0x0f40e000, // Distinct indexed opcode.
+		0x0f40f400, // Reserved bit 10.
+		0x0f00f000, // Different size field.
+	} {
+		if form, ok := decodeARM64RawBFloatDot(word); ok {
+			t.Fatalf("accepted adjacent encoding %#08x as %+v", word, form)
+		}
+	}
+}
+
+func TestARM64RawBFloatDotNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("native execution requires Darwin arm64")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := arm64RawBFloatDotRuntimeIR(t, triple)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_bfloat_dot", triple, ir, arm64RawBFloatDotOracleC, nil)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawBFloatDot(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("BF16 execution belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64RawBFloatDotRuntimeIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc"}, "arm64_raw_bfloat_dot", triple, ir,
+		arm64RawBFloatDotOracleC,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func arm64RawBFloatDotRuntimeIR(t *testing.T, triple string) string {
+	t.Helper()
+	const source = `TEXT bfloatDotRuntime(SB), $0-32
+	MOVD accumulator+0(FP), R0
+	MOVD lhs+8(FP), R1
+	MOVD rhs+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.H8]
+	VLD1 (R2), [V2.H8]
+	WORD $0x6e42fc20 // BFDOT V0.4S, V1.8H, V2.8H
+	VST1 [V0.S4], (R3)
+	VLD1 (R0), [V0.S4]
+	WORD $0x4f42f820 // BFDOT V0.4S, V1.8H, V2.2H[2]
+	ADD $16, R3
+	VST1 [V0.S4], (R3)
+	VLD1 (R0), [V0.S4]
+	WORD $0x2e42fc20 // BFDOT V0.2S, V1.4H, V2.4H
+	ADD $16, R3
+	VST1 [V0.S4], (R3)
+	VLD1 (R0), [V0.S4]
+	WORD $0x0f42f820 // BFDOT V0.2S, V1.4H, V2.2H[2]
+	ADD $16, R3
+	VST1 [V0.S4], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"bfloatDotRuntime": {
+				Name: "bfloatDotRuntime", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+const arm64RawBFloatDotOracleC = `
+#include <stdint.h>
+extern void bfloatDotRuntime(const float *, const uint16_t *, const uint16_t *, float *);
+int main(void) {
+    const float accumulator[4] = {10, 20, 30, 40};
+    const uint16_t lhs[8] = {0x3f80, 0x4000, 0x4040, 0x4080, 0x40a0, 0x40c0, 0x40e0, 0x4100};
+    const uint16_t rhs[8] = {0x4100, 0x40e0, 0x40c0, 0x40a0, 0x4080, 0x4040, 0x4000, 0x3f80};
+    const float want[16] = {
+        32, 58, 68, 62,
+        20, 44, 68, 92,
+        32, 58, 0, 0,
+        20, 44, 0, 0,
+    };
+    float got[16] = {0};
+    bfloatDotRuntime(accumulator, lhs, rhs, got);
+    for (int i = 0; i < 16; i++) if (got[i] != want[i]) return i + 1;
+    return 0;
+}
+`
diff --git a/arm64_lower_word_bfloat_matrix.go b/arm64_lower_word_bfloat_matrix.go
new file mode 100644
index 000000000..ff5cbcdc8
--- /dev/null
+++ b/arm64_lower_word_bfloat_matrix.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import "fmt"
+
+// arm64RawBFloatMatrix is the 128-bit Advanced SIMD BFMMLA encoding. LLVM's
+// architecture intrinsic retains BF16 matrix ordering and rounding semantics.
+type arm64RawBFloatMatrix struct {
+	destination int
+	left        int
+	right       int
+}
+
+func decodeARM64RawBFloatMatrix(word uint32) (arm64RawBFloatMatrix, bool) {
+	const registers = uint32(31<<16 | 31<<5 | 31)
+	if word&^registers != 0x6e40ec00 {
+		return arm64RawBFloatMatrix{}, false
+	}
+	return arm64RawBFloatMatrix{
+		destination: int(word) & 31,
+		left:        int(word>>5) & 31,
+		right:       int(word>>16) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawBFloatMatrix(form arm64RawBFloatMatrix) error {
+	accumulatorReg := Reg(fmt.Sprintf("V%d", form.destination))
+	accumulatorArrangement := arm64VectorArrangement{elementBits: 32, lanes: 4}
+	inputArrangement := arm64VectorArrangement{elementBits: 16, lanes: 8}
+
+	accumulator, err := c.loadARM64VectorFloat(accumulatorReg, accumulatorArrangement)
+	if err != nil {
+		return err
+	}
+	loadBFloat := func(register int) (string, error) {
+		integer, err := c.loadARM64VectorInteger(
+			Reg(fmt.Sprintf("V%d", register)), inputArrangement)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <8 x i16> %s to <8 x bfloat>\n", value, integer)
+		return "%" + value, nil
+	}
+	left, err := loadBFloat(form.left)
+	if err != nil {
+		return err
+	}
+	right, err := loadBFloat(form.right)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b,
+		"  %%%s = call <4 x float> @llvm.aarch64.neon.bfmmla(<4 x float> %s, <8 x bfloat> %s, <8 x bfloat> %s)\n",
+		result, accumulator, left, right)
+	return c.storeARM64VectorFloat(accumulatorReg, accumulatorArrangement, "%"+result)
+}
diff --git a/arm64_lower_word_bfloat_matrix_test.go b/arm64_lower_word_bfloat_matrix_test.go
new file mode 100644
index 000000000..6d2a9787b
--- /dev/null
+++ b/arm64_lower_word_bfloat_matrix_test.go
@@ -0,0 +1,186 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawBFloatMatrixReportedWord(t *testing.T) {
+	const source = `TEXT bfloatMatrix(SB), $0-0
+	WORD $0x6e40ec00 // BFMMLA V0.4S, V0.8H, V0.8H
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"bfloatMatrix": {Name: "bfloatMatrix", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawBFloatMatrixCompleteFormat(t *testing.T) {
+	// LLVM 22 accepts one 128-bit Advanced SIMD BFMMLA encoding, with three
+	// independent five-bit register fields. The 64-bit arrangement is absent.
+	const base = uint32(0x6e40ec00)
+	for _, shift := range []uint{0, 5, 16} {
+		for register := uint32(0); register < 32; register++ {
+			word := base | register<<shift
+			form, ok := decodeARM64RawBFloatMatrix(word)
+			if !ok {
+				t.Fatalf("decoder rejected %#08x", word)
+			}
+			got := map[uint]int{0: form.destination, 5: form.left, 16: form.right}[shift]
+			if got != int(register) {
+				t.Fatalf("register in %#08x decoded as %d", word, got)
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT bfloatMatrixForms(SB), $0-0\n")
+	for _, registers := range [][3]uint32{{0, 0, 0}, {31, 30, 29}, {1, 2, 3}} {
+		word := base | registers[0] | registers[1]<<5 | registers[2]<<16
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"bfloatMatrixForms": {Name: "bfloatMatrixForms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+bf16"`, "@llvm.aarch64.neon.bfmmla("} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s BFMMLA lowering omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-bfloat-matrix.ll", "arm64-raw-bfloat-matrix.o", ir)
+		})
+	}
+}
+
+func TestARM64RawBFloatMatrixRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e40ec00, // BFMMLA has no Q=0 form.
+		0x6e40e800, // Distinct adjacent opcode.
+		0x6e00ec00, // Distinct size field.
+	} {
+		if form, ok := decodeARM64RawBFloatMatrix(word); ok {
+			t.Fatalf("accepted adjacent encoding %#08x as %+v", word, form)
+		}
+	}
+}
+
+func TestARM64RawBFloatMatrixNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("native execution requires Darwin arm64")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := arm64RawBFloatMatrixRuntimeIR(t, triple)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_bfloat_matrix", triple, ir, arm64RawBFloatMatrixOracleC, nil)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawBFloatMatrix(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("BF16 execution belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64RawBFloatMatrixRuntimeIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc"}, "arm64_raw_bfloat_matrix", triple, ir,
+		arm64RawBFloatMatrixOracleC,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func arm64RawBFloatMatrixRuntimeIR(t *testing.T, triple string) string {
+	t.Helper()
+	const source = `TEXT bfloatMatrixRuntime(SB), $0-32
+	MOVD accumulator+0(FP), R0
+	MOVD lhs+8(FP), R1
+	MOVD rhs+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.H8]
+	VLD1 (R2), [V2.H8]
+	WORD $0x6e42ec20 // BFMMLA V0.4S, V1.8H, V2.8H
+	VST1 [V0.S4], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"bfloatMatrixRuntime": {
+				Name: "bfloatMatrixRuntime", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+const arm64RawBFloatMatrixOracleC = `
+#include <stdint.h>
+extern void bfloatMatrixRuntime(const float *, const uint16_t *, const uint16_t *, float *);
+int main(void) {
+    const float accumulator[4] = {10, 20, 30, 40};
+    const uint16_t lhs[8] = {0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80};
+    const uint16_t rhs[8] = {0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80, 0x3f80};
+    const float want[4] = {14, 24, 34, 44};
+    float got[4] = {0};
+    bfloatMatrixRuntime(accumulator, lhs, rhs, got);
+    for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+    return 0;
+}
+`
diff --git a/arm64_lower_word_bitfield.go b/arm64_lower_word_bitfield.go
new file mode 100644
index 000000000..374ba6afe
--- /dev/null
+++ b/arm64_lower_word_bitfield.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawBitfield struct {
+	op          Op
+	width       int
+	immr        int
+	imms        int
+	source      int
+	destination int
+}
+
+func decodeARM64RawBitfield(word uint32) (arm64RawBitfield, bool) {
+	if word&0x1f800000 != 0x13000000 {
+		return arm64RawBitfield{}, false
+	}
+	var op Op
+	switch (word >> 29) & 3 {
+	case 0:
+		op = "SBFM"
+	case 1:
+		op = "BFM"
+	case 2:
+		op = "UBFM"
+	default:
+		return arm64RawBitfield{}, false
+	}
+	width := 32
+	n := word&(1<<22) != 0
+	if word&(1<<31) != 0 {
+		width = 64
+		if !n {
+			return arm64RawBitfield{}, false
+		}
+	} else if n {
+		return arm64RawBitfield{}, false
+	}
+	immr := int(word>>16) & 63
+	imms := int(word>>10) & 63
+	if width == 32 && (immr >= 32 || imms >= 32) {
+		return arm64RawBitfield{}, false
+	}
+	return arm64RawBitfield{
+		op:          op,
+		width:       width,
+		immr:        immr,
+		imms:        imms,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+// Physical bitfield encodings share these effects regardless of the alias
+// chosen by a disassembler. BFM reads the retained destination bits; SBFM and
+// UBFM overwrite it. W writes also define the X register's zero-extended half.
+// Register 31 is the zero register in this grammar, never the stack pointer.
+func (form arm64RawBitfield) gpEffects() (reads, writes uint32) {
+	if form.source != 31 {
+		reads |= 1 << uint(form.source)
+	}
+	if form.destination != 31 {
+		writes |= 1 << uint(form.destination)
+		if form.op == "BFM" {
+			reads |= writes
+		}
+	}
+	return reads, writes
+}
+
+func (c *arm64Ctx) lowerRawBitfield(form arm64RawBitfield) error {
+	// Rd=31 is WZR/XZR for bitfield instructions, so the result is discarded.
+	if form.destination == 31 {
+		return nil
+	}
+	source := Reg(fmt.Sprintf("R%d", form.source))
+	if form.source == 31 {
+		source = ZR
+	}
+	destination := Reg(fmt.Sprintf("R%d", form.destination))
+	var alias Op
+	var lsb, width int
+	if form.imms >= form.immr {
+		lsb = form.immr
+		width = form.imms - form.immr + 1
+		switch form.op {
+		case "SBFM":
+			alias = "SBFX"
+		case "BFM":
+			alias = "BFXIL"
+		case "UBFM":
+			alias = "UBFX"
+		}
+	} else {
+		lsb = form.width - form.immr
+		width = form.imms + 1
+		switch form.op {
+		case "SBFM":
+			alias = "SBFIZ"
+		case "BFM":
+			alias = "BFI"
+		case "UBFM":
+			alias = "UBFIZ"
+		}
+	}
+	if form.width == 32 {
+		alias += "W"
+	}
+	ins := Instr{
+		Op:  alias,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s alias %s", form.op, alias),
+		Args: []Operand{
+			{Kind: OpImm, Imm: int64(lsb)},
+			{Kind: OpReg, Reg: source},
+			{Kind: OpImm, Imm: int64(width)},
+			{Kind: OpReg, Reg: destination},
+		},
+	}
+	return c.lowerBitfield(alias, ins)
+}
diff --git a/arm64_lower_word_bitfield_test.go b/arm64_lower_word_bitfield_test.go
new file mode 100644
index 000000000..78b332ab8
--- /dev/null
+++ b/arm64_lower_word_bitfield_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawBitfield(opc uint32, width, immr, imms, source, destination int) uint32 {
+	word := uint32(0x13000000) | opc<<29 | uint32(immr)<<16 | uint32(imms)<<10 | uint32(source)<<5 | uint32(destination)
+	if width == 64 {
+		word |= 1<<31 | 1<<22
+	}
+	return word
+}
+
+func TestTranslateARM64RawBitfieldCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawbitfieldforms(SB),$0-0\n")
+	for _, opc := range []uint32{0, 1, 2} { // SBFM, BFM, UBFM.
+		for _, width := range []int{32, 64} {
+			for _, immediates := range [][2]int{{0, 0}, {0, width - 1}, {width - 1, 0}, {width - 1, width - 1}, {3, 17}, {width - 3, 11}} {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawBitfield(opc, width, immediates[0], immediates[1], 1, 2))
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawbitfieldforms": {Name: "rawbitfieldforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-bitfield.ll", "arm64-raw-bitfield.o", ll)
+		})
+	}
+}
+
+func TestARM64RawBitfieldDecoderCoversEntireImmediateDomain(t *testing.T) {
+	operations := []Op{"SBFM", "BFM", "UBFM"}
+	for opc, operation := range operations {
+		for _, width := range []int{32, 64} {
+			for immr := 0; immr < width; immr++ {
+				for imms := 0; imms < width; imms++ {
+					word := encodeARM64RawBitfield(uint32(opc), width, immr, imms, 29, 30)
+					got, ok := decodeARM64RawBitfield(word)
+					if !ok {
+						t.Fatalf("decoder rejected %s width=%d immr=%d imms=%d", operation, width, immr, imms)
+					}
+					if got.op != operation || got.width != width || got.immr != immr || got.imms != imms || got.source != 29 || got.destination != 30 {
+						t.Fatalf("decoded word %#08x as %+v", word, got)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawBitfieldRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawbitfield(SB),$0-24\n\tMOVD out+0(FP), R0\n\tMOVD input+8(FP), R1\n\tMOVD initial+16(FP), R2\n")
+	words := []uint32{
+		encodeARM64RawBitfield(2, 64, 61, 60, 1, 3), // LSL #3.
+		encodeARM64RawBitfield(2, 64, 8, 63, 1, 4),  // LSR #8.
+		encodeARM64RawBitfield(2, 64, 8, 15, 1, 5),  // UBFX #8, #8.
+		encodeARM64RawBitfield(2, 64, 56, 7, 1, 6),  // UBFIZ #8, #8.
+		encodeARM64RawBitfield(0, 64, 8, 63, 1, 7),  // ASR #8.
+		encodeARM64RawBitfield(0, 64, 32, 39, 1, 8), // SBFX #32, #8.
+	}
+	for _, word := range words {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tMOVD R2, R9\n\tMOVD R2, R10\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawBitfield(1, 64, 0, 7, 1, 9))   // BFXIL #0, #8.
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawBitfield(1, 64, 56, 7, 1, 10)) // BFI #8, #8.
+	for i, reg := range []int{3, 4, 5, 6, 7, 8, 9, 10} {
+		fmt.Fprintf(&source, "\tMOVD R%d, %d(R0)\n", reg, i*8)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawbitfield": {
+			Name: "rawbitfield", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawbitfield(uint64_t *, uint64_t, uint64_t);
+int main(void) {
+  uint64_t got[8] = {0};
+  rawbitfield(got, UINT64_C(0xfedcba9876543210), UINT64_C(0x1111222233334444));
+  const uint64_t want[8] = {
+    UINT64_C(0xf6e5d4c3b2a19080), UINT64_C(0x00fedcba98765432), UINT64_C(0x32), UINT64_C(0x1000),
+    UINT64_C(0xfffedcba98765432), UINT64_C(0xffffffffffffff98), UINT64_C(0x1111222233334410), UINT64_C(0x1111222233331044),
+  };
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_bitfield", triple, ll, mainC, nil)
+}
+
+func TestARM64RawBitfieldDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARM64RawBitfield(3, 64, 0, 0, 0, 0), // reserved opc.
+		encodeARM64RawBitfield(2, 32, 32, 0, 0, 0),
+		encodeARM64RawBitfield(2, 32, 0, 32, 0, 0),
+		0x12000000, // logical immediate.
+	} {
+		if _, ok := decodeARM64RawBitfield(word); ok {
+			t.Fatalf("bitfield decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_casp.go b/arm64_lower_word_casp.go
new file mode 100644
index 000000000..5eb1de204
--- /dev/null
+++ b/arm64_lower_word_casp.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawCASP struct {
+	elementBits int
+	acquire     bool
+	release     bool
+	expected    int
+	newValue    int
+	base        int
+}
+
+func decodeARM64RawCASP(word uint32) (arm64RawCASP, bool) {
+	const variable = uint32(1<<30 | 1<<22 | 1<<15 | 0x1e<<16 | 31<<5 | 0x1e)
+	if word&^variable != 0x08207c00 {
+		return arm64RawCASP{}, false
+	}
+	elementBits := 32
+	if word&(1<<30) != 0 {
+		elementBits = 64
+	}
+	return arm64RawCASP{
+		elementBits: elementBits,
+		acquire:     word&(1<<22) != 0,
+		release:     word&(1<<15) != 0,
+		expected:    int(word>>16) & 31,
+		newValue:    int(word) & 31,
+		base:        int(word>>5) & 31,
+	}, true
+}
+
+func arm64RawCASPRegisterPair(first int) []Reg {
+	second := Reg(fmt.Sprintf("R%d", first+1))
+	if first == 30 {
+		second = ZR
+	}
+	return []Reg{Reg(fmt.Sprintf("R%d", first)), second}
+}
+
+func (c *arm64Ctx) lowerRawCASP(form arm64RawCASP) error {
+	base := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		base = Reg("RSP")
+	}
+	ptr, err := c.atomicPairMemPtr(MemRef{Base: base}, false)
+	if err != nil {
+		return err
+	}
+	successOrder, failureOrder := "monotonic", "monotonic"
+	if form.acquire && form.release {
+		successOrder, failureOrder = "acq_rel", "acquire"
+	} else if form.acquire {
+		successOrder, failureOrder = "acquire", "acquire"
+	} else if form.release {
+		successOrder = "release"
+	}
+	return c.lowerAtomicPairCompareExchange(
+		arm64RawCASPRegisterPair(form.expected),
+		arm64RawCASPRegisterPair(form.newValue),
+		form.elementBits, ptr, successOrder, failureOrder,
+	)
+}
diff --git a/arm64_lower_word_casp_test.go b/arm64_lower_word_casp_test.go
new file mode 100644
index 000000000..73d5b2a9a
--- /dev/null
+++ b/arm64_lower_word_casp_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64EncodeRawCASP(bits int, acquire, release bool, expected, newValue, base int) uint32 {
+	word := uint32(0x08207c00)
+	if bits == 64 {
+		word |= 1 << 30
+	}
+	if acquire {
+		word |= 1 << 22
+	}
+	if release {
+		word |= 1 << 15
+	}
+	return word | uint32(expected)<<16 | uint32(base)<<5 | uint32(newValue)
+}
+
+func TestTranslateARM64RawCASPCompleteArchitecturalFormats(t *testing.T) {
+	var source strings.Builder
+	// The complete pair bank includes an expected pair beginning at LR.
+	// R26 is untouched by every form below; use real source to restore LR.
+	source.WriteString("TEXT rawcaspforms(SB),$0-0\nMOVD R30,R26\n")
+	for _, bits := range []int{32, 64} {
+		for _, order := range []struct{ acquire, release bool }{
+			{}, {acquire: true}, {release: true}, {acquire: true, release: true},
+		} {
+			for _, registers := range []struct{ expected, newValue, base int }{{0, 2, 4}, {30, 28, 31}} {
+				word := arm64EncodeRawCASP(bits, order.acquire, order.release, registers.expected, registers.newValue, registers.base)
+				decoded, ok := decodeARM64RawCASP(word)
+				if !ok || decoded.elementBits != bits || decoded.acquire != order.acquire || decoded.release != order.release ||
+					decoded.expected != registers.expected || decoded.newValue != registers.newValue || decoded.base != registers.base {
+					t.Fatalf("decode CASP word %#08x = %+v, ok=%v", word, decoded, ok)
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tMOVD R26,R30\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawcaspforms": {Name: "rawcaspforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, ordering := range []string{"monotonic monotonic", "acquire acquire", "release monotonic", "acq_rel acquire"} {
+				if !strings.Contains(ir, ordering) {
+					t.Fatalf("raw CASP lowering for %s omitted %q:\n%s", triple, ordering, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-casp.ll", "arm64-raw-casp.o", ir)
+		})
+	}
+}
+
+func TestARM64RawCASPDecoderRejectsAdjacentAndInvalidPairs(t *testing.T) {
+	for _, word := range []uint32{
+		0x08217c02, // odd expected-pair start.
+		0x08207c01, // odd new-value-pair start.
+		0x08207800, // adjacent opcode bits.
+		0x88207c00, // single-register CAS instruction class.
+	} {
+		if _, ok := decodeARM64RawCASP(word); ok {
+			t.Fatalf("CASP decoder accepted adjacent/invalid encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawCASPRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawcaspl(SB),$0-32
+	MOVD memory+0(FP), R4
+	MOVD expected+8(FP), R5
+	MOVD desired+16(FP), R6
+	MOVD observed+24(FP), R7
+	MOVD 0(R5), R0
+	MOVD 8(R5), R1
+	MOVD 0(R6), R2
+	MOVD 8(R6), R3
+	WORD $0x4820fc82 // CASPL X0, X1, X2, X3, [X4]
+	MOVD R0, 0(R7)
+	MOVD R1, 8(R7)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawcaspl": {
+				Name: "rawcaspl", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawcaspl(uint64_t *, const uint64_t *, const uint64_t *, uint64_t *);
+int main(void) {
+  _Alignas(16) uint64_t memory[2] = {11,22};
+  const uint64_t success_expected[2] = {11,22};
+  const uint64_t failure_expected[2] = {10,22};
+  const uint64_t desired[2] = {33,44};
+  uint64_t observed[2] = {0,0};
+  rawcaspl(memory, success_expected, desired, observed);
+  if (memory[0] != 33 || memory[1] != 44 || observed[0] != 11 || observed[1] != 22) return 1;
+  memory[0] = 11; memory[1] = 22; observed[0] = 0; observed[1] = 0;
+  rawcaspl(memory, failure_expected, desired, observed);
+  if (memory[0] != 11 || memory[1] != 22 || observed[0] != 11 || observed[1] != 22) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_casp", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_cmgt.go b/arm64_lower_word_cmgt.go
new file mode 100644
index 000000000..2bac4c616
--- /dev/null
+++ b/arm64_lower_word_cmgt.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawIntegerCompare struct {
+	predicate   string
+	testBits    bool
+	scalar      bool
+	zero        bool
+	arrangement arm64VectorArrangement
+	destination int
+	first       int
+	second      int
+}
+
+type arm64RawIntegerCompareEncoding struct {
+	mask      uint32
+	value     uint32
+	predicate string
+	zero      bool
+	testBits  bool
+	scalar    bool
+}
+
+var arm64RawIntegerCompareEncodings = [...]arm64RawIntegerCompareEncoding{
+	{0xff20fc00, 0x7e208c00, "eq", false, false, true},
+	{0xbf20fc00, 0x2e208c00, "eq", false, false, false},
+	{0xff20fc00, 0x5e203c00, "sge", false, false, true},
+	{0xbf20fc00, 0x0e203c00, "sge", false, false, false},
+	{0xff20fc00, 0x5e203400, "sgt", false, false, true},
+	{0xbf20fc00, 0x0e203400, "sgt", false, false, false},
+	{0xff20fc00, 0x7e203400, "ugt", false, false, true},
+	{0xbf20fc00, 0x2e203400, "ugt", false, false, false},
+	{0xff20fc00, 0x7e203c00, "uge", false, false, true},
+	{0xbf20fc00, 0x2e203c00, "uge", false, false, false},
+	{0xff20fc00, 0x5e208c00, "ne", false, true, true},
+	{0xbf20fc00, 0x0e208c00, "ne", false, true, false},
+	{0xff3ffc00, 0x5e209800, "eq", true, false, true},
+	{0xbf3ffc00, 0x0e209800, "eq", true, false, false},
+	{0xff3ffc00, 0x7e208800, "sge", true, false, true},
+	{0xbf3ffc00, 0x2e208800, "sge", true, false, false},
+	{0xff3ffc00, 0x5e208800, "sgt", true, false, true},
+	{0xbf3ffc00, 0x0e208800, "sgt", true, false, false},
+	{0xff3ffc00, 0x7e209800, "sle", true, false, true},
+	{0xbf3ffc00, 0x2e209800, "sle", true, false, false},
+	{0xff3ffc00, 0x5e20a800, "slt", true, false, true},
+	{0xbf3ffc00, 0x0e20a800, "slt", true, false, false},
+}
+
+func decodeARM64RawIntegerCompare(word uint32) (arm64RawIntegerCompare, bool) {
+
+	var decoded arm64RawIntegerCompareEncoding
+	matched := false
+	for _, candidate := range arm64RawIntegerCompareEncodings {
+		if word&candidate.mask == candidate.value {
+			decoded = candidate
+			matched = true
+			break
+		}
+	}
+	if !matched {
+		return arm64RawIntegerCompare{}, false
+	}
+
+	bits := 64
+	lanes := 1
+	if !decoded.scalar {
+		size := int(word>>22) & 3
+		vectorBits := 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if size == 3 && vectorBits != 128 {
+			return arm64RawIntegerCompare{}, false
+		}
+		bits = 8 << size
+		lanes = vectorBits / bits
+	}
+	form := arm64RawIntegerCompare{
+		predicate:   decoded.predicate,
+		testBits:    decoded.testBits,
+		scalar:      decoded.scalar,
+		zero:        decoded.zero,
+		arrangement: arm64VectorArrangement{elementBits: bits, lanes: lanes},
+		destination: int(word & 31),
+		first:       int(word>>5) & 31,
+	}
+	if !decoded.zero {
+		form.second = int(word>>16) & 31
+	}
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawIntegerCompare(form arm64RawIntegerCompare) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	second := "zeroinitializer"
+	if !form.zero {
+		second, err = c.loadRawARM64VectorOperand(form.second, form.arrangement, 0, form.scalar)
+		if err != nil {
+			return err
+		}
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", form.arrangement.lanes, form.arrangement.elementBits)
+	if form.testBits {
+		anded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and %s %s, %s\n", anded, vectorType, first, second)
+		first = "%" + anded
+		second = "zeroinitializer"
+	}
+	compared := c.newTmp()
+	allBits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %s, %s\n", compared, form.predicate, vectorType, first, second)
+	fmt.Fprintf(c.b, "  %%%s = sext <%d x i1> %%%s to %s\n", allBits, form.arrangement.lanes, compared, vectorType)
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, "%"+allBits, form.scalar)
+}
diff --git a/arm64_lower_word_cmgt_test.go b/arm64_lower_word_cmgt_test.go
new file mode 100644
index 000000000..56c4e6475
--- /dev/null
+++ b/arm64_lower_word_cmgt_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawIntegerCompareCompleteAdvancedSIMDFamily(t *testing.T) {
+	forms := []struct {
+		name       string
+		vectorBase uint32
+		scalarBase uint32
+		predicate  string
+		zero       bool
+		testBits   bool
+	}{
+		{"CMEQ register", 0x2e208c00, 0x7e208c00, "eq", false, false},
+		{"CMGE register", 0x0e203c00, 0x5e203c00, "sge", false, false},
+		{"CMGT register", 0x0e203400, 0x5e203400, "sgt", false, false},
+		{"CMHI register", 0x2e203400, 0x7e203400, "ugt", false, false},
+		{"CMHS register", 0x2e203c00, 0x7e203c00, "uge", false, false},
+		{"CMTST register", 0x0e208c00, 0x5e208c00, "ne", false, true},
+		{"CMEQ zero", 0x0e209800, 0x5e209800, "eq", true, false},
+		{"CMGE zero", 0x2e208800, 0x7e208800, "sge", true, false},
+		{"CMGT zero", 0x0e208800, 0x5e208800, "sgt", true, false},
+		{"CMLE zero", 0x2e209800, 0x7e209800, "sle", true, false},
+		{"CMLT zero", 0x0e20a800, 0x5e20a800, "slt", true, false},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawIntegerCompareFamily(SB),$0-0\n")
+	for _, form := range forms {
+		for size := 0; size < 4; size++ {
+			for q := 0; q < 2; q++ {
+				if size == 3 && q == 0 {
+					continue
+				}
+				word := form.vectorBase | uint32(size)<<22 | uint32(q)<<30 | 1<<5
+				if !form.zero {
+					word |= 2 << 16
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s size=%d q=%d\n", word, form.name, size, q)
+			}
+		}
+		word := form.scalarBase | 1<<5
+		if !form.zero {
+			word |= 2 << 16
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s scalar D\n", word, form.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawIntegerCompareFamily": {Name: "rawIntegerCompareFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, predicate := range []string{"eq", "sge", "sgt", "ugt", "uge", "ne", "sle", "slt"} {
+				if !strings.Contains(ir, "icmp "+predicate+" ") {
+					t.Fatalf("raw integer compare IR omitted %q:\n%s", predicate, ir)
+				}
+			}
+			if !strings.Contains(ir, " and ") {
+				t.Fatalf("raw CMTST lowering omitted bitwise and:\n%s", ir)
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-integer-compare.ll", "arm64-raw-integer-compare.o", ir)
+		})
+	}
+}
+
+// CMGT has register and compare-with-zero encodings. Each has all seven legal
+// vector arrangements plus the scalar D form.
+const arm64RawCMGTForms = `
+TEXT rawcmgtforms(SB),$0-0
+	WORD $0x0e223420 // CMGT V0.8B, V1.8B, V2.8B
+	WORD $0x4e223420 // CMGT V0.16B, V1.16B, V2.16B
+	WORD $0x0e623420 // CMGT V0.4H, V1.4H, V2.4H
+	WORD $0x4e623420 // CMGT V0.8H, V1.8H, V2.8H
+	WORD $0x0ea23420 // CMGT V0.2S, V1.2S, V2.2S
+	WORD $0x4ea23420 // CMGT V0.4S, V1.4S, V2.4S
+	WORD $0x4ee23420 // CMGT V0.2D, V1.2D, V2.2D
+	WORD $0x5ee23420 // CMGT D0, D1, D2
+	WORD $0x0e208820 // CMGT V0.8B, V1.8B, #0
+	WORD $0x4e208820 // CMGT V0.16B, V1.16B, #0
+	WORD $0x0e608820 // CMGT V0.4H, V1.4H, #0
+	WORD $0x4e608820 // CMGT V0.8H, V1.8H, #0
+	WORD $0x0ea08820 // CMGT V0.2S, V1.2S, #0
+	WORD $0x4ea08820 // CMGT V0.4S, V1.4S, #0
+	WORD $0x4ee08820 // CMGT V0.2D, V1.2D, #0
+	WORD $0x5ee08820 // CMGT D0, D1, #0
+	RET
+`
+
+func TestTranslateARM64RawCMGTCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawCMGTForms, true)
+	file, err := Parse(ArchARM64, arm64RawCMGTForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawcmgtforms": {Name: "rawcmgtforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"icmp sgt <8 x i8>", "icmp sgt <16 x i8>",
+				"icmp sgt <4 x i16>", "icmp sgt <8 x i16>",
+				"icmp sgt <2 x i32>", "icmp sgt <4 x i32>",
+				"icmp sgt <2 x i64>", "icmp sgt <1 x i64>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw CMGT lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-cmgt.ll", "arm64-raw-cmgt.o", ll)
+		})
+	}
+}
+
+func TestARM64RawCMGTRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawcmgt(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V4.S4]
+	VLD1 (R1), [V2.S4]
+	WORD $0x4ea23488 // CMGT V8.4S, V4.4S, V2.4S
+	VST1 [V8.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawcmgt": {
+				Name: "rawcmgt", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawcmgt(const int32_t *, const int32_t *, uint32_t *);
+int main(void) {
+  const int32_t a[4] = {INT32_MIN, -1, 0, INT32_MAX};
+  const int32_t b[4] = {INT32_MAX, -2, 0, INT32_MIN};
+  const uint32_t want[4] = {0, 0xffffffffu, 0, 0xffffffffu};
+  uint32_t got[4] = {0};
+  rawcmgt(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_cmgt", triple, ll, mainC, nil)
+}
+
+func TestARM64RawIntegerCompareDecoderRejectsAdjacentEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawIntegerCompare(0x6e202c20); ok {
+		t.Fatal("integer compare decoder claimed adjacent vector opcode")
+	}
+}
diff --git a/arm64_lower_word_cvtf.go b/arm64_lower_word_cvtf.go
new file mode 100644
index 000000000..0ac24a917
--- /dev/null
+++ b/arm64_lower_word_cvtf.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawCVTF struct {
+	unsigned    bool
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+func decodeARM64RawCVTF(word uint32) (arm64RawCVTF, bool) {
+	if word&0x9fbffc00 != 0x0e21d800 {
+		return arm64RawCVTF{}, false
+	}
+	bits := 32
+	if word&(1<<22) != 0 {
+		bits = 64
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if bits == 64 && vectorBits == 64 {
+		return arm64RawCVTF{}, false
+	}
+	return arm64RawCVTF{
+		unsigned:    word&(1<<29) != 0,
+		arrangement: arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits},
+		source:      int(word>>5) & 31,
+		destination: int(word & 31),
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawCVTF(form arm64RawCVTF) error {
+	op := Op("VSCVTF")
+	if form.unsigned {
+		op = "VUCVTF"
+	}
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	ins := Instr{
+		Op:  op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", op),
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.source, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorFloatUnary(op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_cvtf_test.go b/arm64_lower_word_cvtf_test.go
new file mode 100644
index 000000000..21a34fede
--- /dev/null
+++ b/arm64_lower_word_cvtf_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawCVTFForms = `
+TEXT rawcvtfforms(SB),$0-0
+	WORD $0x0e21d820 // SCVTF V0.2S, V1.2S
+	WORD $0x4e21d862 // SCVTF V2.4S, V3.4S
+	WORD $0x4e61d8a4 // SCVTF V4.2D, V5.2D
+	WORD $0x2e21d8e6 // UCVTF V6.2S, V7.2S
+	WORD $0x6e21d928 // UCVTF V8.4S, V9.4S
+	WORD $0x6e61d96a // UCVTF V10.2D, V11.2D
+	RET
+`
+
+func TestTranslateARM64RawCVTFCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawCVTFForms, true)
+	file, err := Parse(ArchARM64, arm64RawCVTFForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawcvtfforms": {Name: "rawcvtfforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"sitofp <2 x i32>", "sitofp <4 x i32>", "sitofp <2 x i64>", "uitofp <2 x i32>", "uitofp <4 x i32>", "uitofp <2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SCVTF/UCVTF lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-cvtf.ll", "arm64-raw-cvtf.o", ll)
+		})
+	}
+}
+
+func TestARM64RawCVTFRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawcvtf(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x4e21d801 // SCVTF V1.4S, V0.4S
+	WORD $0x6e21d802 // UCVTF V2.4S, V0.4S
+	VST1 [V1.S4, V2.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawcvtf": {
+				Name: "rawcvtf", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawcvtf(const uint32_t *, float *);
+int main(void) {
+  const uint32_t input[4] = {UINT32_MAX, 0x80000000u, 0u, INT32_MAX};
+  float got[8] = {0};
+  rawcvtf(input, got);
+  for (int i = 0; i < 4; i++) {
+    if (got[i] != (float)(int32_t)input[i]) return i + 1;
+    if (got[4+i] != (float)input[i]) return i + 11;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_cvtf", triple, ll, mainC, nil)
+}
+
+func TestARM64RawCVTFDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{0x4ea1b9ac, 0x0e61d800} { // FCVTZS and reserved D1.
+		if _, ok := decodeARM64RawCVTF(word); ok {
+			t.Fatalf("SCVTF/UCVTF decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_dot_product.go b/arm64_lower_word_dot_product.go
new file mode 100644
index 000000000..d0712bc52
--- /dev/null
+++ b/arm64_lower_word_dot_product.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawDotProduct struct {
+	leftSigned  bool
+	rightSigned bool
+	indexed     bool
+	lane        int
+	lanes       int
+	destination int
+	left        int
+	right       int
+}
+
+func decodeARM64RawDotProduct(word uint32) (arm64RawDotProduct, bool) {
+	form := arm64RawDotProduct{lane: -1}
+	switch word & 0xbfe0fc00 {
+	case 0x0e809400: // SDOT (vector).
+		form.leftSigned, form.rightSigned = true, true
+	case 0x2e809400: // UDOT (vector).
+	case 0x0e809c00: // USDOT (vector).
+		form.rightSigned = true
+	default:
+		switch word & 0xbfc0f400 {
+		case 0x0f80e000: // SDOT (by element).
+			form.leftSigned, form.rightSigned = true, true
+		case 0x2f80e000: // UDOT (by element).
+		case 0x0f80f000: // USDOT (by element).
+			form.rightSigned = true
+		case 0x0f00f000: // SUDOT (by element).
+			form.leftSigned = true
+		default:
+			return arm64RawDotProduct{}, false
+		}
+		form.indexed = true
+		form.lane = int(word>>21)&1 | int(word>>10)&2
+	}
+
+	form.lanes = 2
+	if word&(1<<30) != 0 {
+		form.lanes = 4
+	}
+	form.destination = int(word) & 31
+	form.left = int(word>>5) & 31
+	form.right = int(word>>16) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawDotProduct(form arm64RawDotProduct) error {
+	byteLanes := form.lanes * 4
+	inputArrangement := arm64VectorArrangement{elementBits: 8, lanes: byteLanes}
+	accumulatorArrangement := arm64VectorArrangement{elementBits: 32, lanes: form.lanes}
+	left, err := c.loadARM64VectorInteger(
+		Reg(fmt.Sprintf("V%d.%s", form.left, arm64VectorArrangementName(inputArrangement))),
+		inputArrangement,
+	)
+	if err != nil {
+		return err
+	}
+
+	var right string
+	if form.indexed {
+		physical := arm64VectorArrangement{elementBits: 8, lanes: 16}
+		loaded, err := c.loadARM64VectorInteger(
+			Reg(fmt.Sprintf("V%d.%s", form.right, arm64VectorArrangementName(physical))),
+			physical,
+		)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> poison, <%d x i32> <", selected, loaded, byteLanes)
+		for i := 0; i < byteLanes; i++ {
+			if i != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", form.lane*4+i%4)
+		}
+		c.b.WriteString(">\n")
+		right = "%" + selected
+	} else {
+		right, err = c.loadARM64VectorInteger(
+			Reg(fmt.Sprintf("V%d.%s", form.right, arm64VectorArrangementName(inputArrangement))),
+			inputArrangement,
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	wideType := fmt.Sprintf("<%d x i32>", byteLanes)
+	widen := func(value string, signed bool) string {
+		result := c.newTmp()
+		op := "zext"
+		if signed {
+			op = "sext"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s <%d x i8> %s to %s\n", result, op, byteLanes, value, wideType)
+		return "%" + result
+	}
+	wideLeft := widen(left, form.leftSigned)
+	wideRight := widen(right, form.rightSigned)
+	products := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", products, wideType, wideLeft, wideRight)
+
+	accumulatorReg := Reg(fmt.Sprintf("V%d.%s", form.destination, arm64VectorArrangementName(accumulatorArrangement)))
+	result, err := c.loadARM64VectorInteger(accumulatorReg, accumulatorArrangement)
+	if err != nil {
+		return err
+	}
+	for lane := 0; lane < form.lanes; lane++ {
+		accumulated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i32> %s, i32 %d\n", accumulated, form.lanes, result, lane)
+		value := "%" + accumulated
+		for element := 0; element < 4; element++ {
+			product := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 %d\n", product, wideType, products, lane*4+element)
+			sum := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %%%s\n", sum, value, product)
+			value = "%" + sum
+		}
+		updated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i32> %s, i32 %s, i32 %d\n", updated, form.lanes, result, value, lane)
+		result = "%" + updated
+	}
+	return c.storeARM64VectorInteger(accumulatorReg, accumulatorArrangement, result)
+}
diff --git a/arm64_lower_word_dot_product_test.go b/arm64_lower_word_dot_product_test.go
new file mode 100644
index 000000000..3478ba403
--- /dev/null
+++ b/arm64_lower_word_dot_product_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawDotProductCompleteArchitecturalFormats(t *testing.T) {
+	vectorBases := []uint32{
+		0x0e809400, // SDOT.
+		0x2e809400, // UDOT.
+		0x0e809c00, // USDOT.
+	}
+	indexedBases := []uint32{
+		0x0f80e000, // SDOT (by element).
+		0x2f80e000, // UDOT (by element).
+		0x0f80f000, // USDOT (by element).
+		0x0f00f000, // SUDOT (by element; no vector form exists).
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawdotproductforms(SB),$0-0\n")
+	for _, base := range vectorBases {
+		for _, q := range []uint32{0, 1 << 30} {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|q|31<<16|30<<5|29)
+		}
+	}
+	for _, base := range indexedBases {
+		for _, q := range []uint32{0, 1 << 30} {
+			for lane := uint32(0); lane < 4; lane++ {
+				laneBits := (lane&1)<<21 | (lane&2)<<10
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", base|q|laneBits|31<<16|30<<5|29)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawdotproductforms": {Name: "rawdotproductforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"sext <", "zext <", "mul <", "add i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw dot-product lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-dot-product.ll", "arm64-raw-dot-product.o", ir)
+		})
+	}
+}
+
+func TestARM64RawDotProductDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0ea09400, // Reserved size bit in SDOT (vector).
+		0x2e809c00, // Unallocated U bit in USDOT (vector).
+		0x2f00f000, // Unallocated U bit in SUDOT (by element).
+		0x0f40e000, // Unallocated size in SDOT (by element).
+		0x0fc0e000, // Unallocated size in SDOT (by element).
+		0x0f80e400, // Reserved bit 10 in SDOT (by element).
+	} {
+		if _, ok := decodeARM64RawDotProduct(word); ok {
+			t.Fatalf("dot-product decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawDotProductRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawdotproduct(SB),$0-32
+	MOVD accumulator+0(FP), R0
+	MOVD lhs+8(FP), R1
+	MOVD rhs+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R1), [V1.B16]
+	VLD1 (R2), [V2.B16]
+	VLD1 (R0), [V3.S4]
+	WORD $0x4e829423 // SDOT V3.4S, V1.16B, V2.16B
+	VST1 [V3.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V4.S4]
+	WORD $0x6e829424 // UDOT V4.4S, V1.16B, V2.16B
+	VST1 [V4.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V5.S4]
+	WORD $0x4e829c25 // USDOT V5.4S, V1.16B, V2.16B
+	VST1 [V5.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V6.S4]
+	WORD $0x4f82e826 // SDOT V6.4S, V1.16B, V2.4B[2]
+	VST1 [V6.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V7.S4]
+	WORD $0x6f82e827 // UDOT V7.4S, V1.16B, V2.4B[2]
+	VST1 [V7.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V8.S4]
+	WORD $0x4f82f828 // USDOT V8.4S, V1.16B, V2.4B[2]
+	VST1 [V8.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V9.S4]
+	WORD $0x4f02f829 // SUDOT V9.4S, V1.16B, V2.4B[2]
+	VST1 [V9.S4], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawdotproduct": {
+				Name: "rawdotproduct", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawdotproduct(const int32_t *, const int8_t *, const int8_t *, int32_t *);
+int main(void) {
+  const int32_t accumulator[4] = {10, 20, 30, 40};
+  const int8_t lhs[16] = {-1,2,-3,4, -1,2,-3,4, -1,2,-3,4, -1,2,-3,4};
+  const int8_t rhs[16] = {1,2,3,4, 9,10,11,12, 5,-6,7,-8, 13,14,15,16};
+	  const int32_t want[28] = {
+	    20,46,-40,74, 1044,5166,4568,7242, 1044,5166,3032,7242,
+	    -60,-50,-40,-30, 4548,4558,4568,4578, 3012,3022,3032,3042,
+    1476,1486,1496,1506,
+  };
+  int32_t got[28] = {0};
+  rawdotproduct(accumulator, lhs, rhs, got);
+  for (int i = 0; i < 28; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_dot_product", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_dup_element.go b/arm64_lower_word_dup_element.go
new file mode 100644
index 000000000..c0d424a4d
--- /dev/null
+++ b/arm64_lower_word_dup_element.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+type arm64RawDUPElement struct {
+	arrangement arm64VectorArrangement
+	element     int
+	source      int
+	destination int
+}
+
+func decodeARM64RawDUPElement(word uint32) (arm64RawDUPElement, bool) {
+	if word&0xbfe0fc00 != 0x0e000400 {
+		return arm64RawDUPElement{}, false
+	}
+	imm5 := int(word>>16) & 31
+	bits := 0
+	element := 0
+	switch {
+	case imm5&1 != 0:
+		bits, element = 8, imm5>>1
+	case imm5&2 != 0:
+		bits, element = 16, imm5>>2
+	case imm5&4 != 0:
+		bits, element = 32, imm5>>3
+	case imm5&8 != 0:
+		bits, element = 64, imm5>>4
+	default:
+		return arm64RawDUPElement{}, false
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if bits == 64 && vectorBits == 64 {
+		return arm64RawDUPElement{}, false
+	}
+	return arm64RawDUPElement{
+		arrangement: arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits},
+		element:     element,
+		source:      int(word>>5) & 31,
+		destination: int(word & 31),
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawDUPElement(form arm64RawDUPElement) error {
+	value, err := c.loadRawARM64VectorOperand(form.source, form.arrangement, form.element, true)
+	if err != nil {
+		return err
+	}
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, value, false)
+}
diff --git a/arm64_lower_word_dup_element_test.go b/arm64_lower_word_dup_element_test.go
new file mode 100644
index 000000000..9656972e3
--- /dev/null
+++ b/arm64_lower_word_dup_element_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawDUPElementForTest(bits, element, source, destination int, q bool) uint32 {
+	position := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[bits]
+	imm5 := element<<(position+1) | 1<<position
+	word := uint32(0x0e000400 | imm5<<16 | source<<5 | destination)
+	if q {
+		word |= 1 << 30
+	}
+	return word
+}
+
+func TestTranslateARM64RawDUPElementCompleteAdvancedSIMDFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawdupelementforms(SB),$0-0\n")
+	for _, form := range []struct {
+		bits    int
+		element int
+		q       bool
+	}{{8, 15, false}, {8, 15, true}, {16, 7, false}, {16, 7, true}, {32, 3, false}, {32, 3, true}, {64, 1, true}} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawDUPElementForTest(form.bits, form.element, 1, 16, form.q))
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawdupelementforms": {Name: "rawdupelementforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"extractelement", "shufflevector", "<8 x i8>", "<16 x i8>", "<4 x i16>", "<8 x i16>", "<2 x i32>", "<4 x i32>", "<2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw DUP-element lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-dup-element.ll", "arm64-raw-dup-element.o", ll)
+		})
+	}
+}
+
+func TestARM64RawDUPElementDecoderCoversEveryLane(t *testing.T) {
+	for _, bits := range []int{8, 16, 32, 64} {
+		for element := 0; element < 128/bits; element++ {
+			for _, q := range []bool{false, true} {
+				if bits == 64 && !q {
+					continue
+				}
+				word := encodeARM64RawDUPElementForTest(bits, element, 7, 23, q)
+				form, ok := decodeARM64RawDUPElement(word)
+				if !ok || form.arrangement.elementBits != bits || form.element != element || form.source != 7 || form.destination != 23 {
+					t.Fatalf("decode DUP element bits=%d lane=%d q=%v: form=%#v ok=%v", bits, element, q, form, ok)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawDUPElementRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawdupelement(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V1.S4]
+	WORD $0x4e040430 // DUP V16.4S, V1.S[0]
+	VST1 [V16.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawdupelement": {
+				Name: "rawdupelement", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawdupelement(const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t input[4] = {0x12345678u, 2, 3, 4};
+  uint32_t got[4] = {0};
+  rawdupelement(input, got);
+  for (int i = 0; i < 4; i++) if (got[i] != input[0]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_dup_element", triple, ll, mainC, nil)
+}
+
+func TestARM64RawDUPElementDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x4e040c20, // DUP from W register.
+		0x5e040420, // Scalar DUP from vector element.
+		encodeARM64RawDUPElementForTest(64, 0, 1, 0, false), // Reserved D1 vector form.
+	} {
+		t.Run(fmt.Sprintf("%08x", word), func(t *testing.T) {
+			if _, ok := decodeARM64RawDUPElement(word); ok {
+				t.Fatalf("DUP-element decoder claimed adjacent/reserved encoding %#08x", word)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_word_faddp.go b/arm64_lower_word_faddp.go
new file mode 100644
index 000000000..0cd7d4945
--- /dev/null
+++ b/arm64_lower_word_faddp.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFADDP struct {
+	scalar      bool
+	arrangement arm64VectorArrangement
+	first       int
+	second      int
+	destination int
+}
+
+func decodeARM64RawFADDP(word uint32) (arm64RawFADDP, bool) {
+	const vectorRegisters = uint32(31 | 31<<5 | 31<<16)
+	var vectorArrangement arm64VectorArrangement
+	switch word &^ vectorRegisters {
+	case 0x2e401400:
+		vectorArrangement = arm64VectorArrangement{elementBits: 16, lanes: 4}
+	case 0x6e401400:
+		vectorArrangement = arm64VectorArrangement{elementBits: 16, lanes: 8}
+	case 0x2e20d400:
+		vectorArrangement = arm64VectorArrangement{elementBits: 32, lanes: 2}
+	case 0x6e20d400:
+		vectorArrangement = arm64VectorArrangement{elementBits: 32, lanes: 4}
+	case 0x6e60d400:
+		vectorArrangement = arm64VectorArrangement{elementBits: 64, lanes: 2}
+	}
+	if vectorArrangement.elementBits != 0 {
+		return arm64RawFADDP{
+			arrangement: vectorArrangement,
+			first:       int(word>>5) & 31,
+			second:      int(word>>16) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+
+	const scalarRegisters = uint32(31 | 31<<5)
+	scalarBits := 0
+	switch word &^ scalarRegisters {
+	case 0x5e30d800:
+		scalarBits = 16
+	case 0x7e30d800:
+		scalarBits = 32
+	case 0x7e70d800:
+		scalarBits = 64
+	}
+	if scalarBits != 0 {
+		return arm64RawFADDP{
+			scalar:      true,
+			arrangement: arm64VectorArrangement{elementBits: scalarBits, lanes: 2},
+			first:       int(word>>5) & 31,
+			second:      -1,
+			destination: int(word) & 31,
+		}, true
+	}
+	return arm64RawFADDP{}, false
+}
+
+func arm64RawFloatType(bits int) string {
+	switch bits {
+	case 16:
+		return "half"
+	case 32:
+		return "float"
+	case 64:
+		return "double"
+	default:
+		panic(fmt.Sprintf("unsupported ARM64 floating width %d", bits))
+	}
+}
+
+func (c *arm64Ctx) lowerRawFADDP(form arm64RawFADDP) error {
+	firstReg := Reg(fmt.Sprintf("V%d", form.first))
+	first, err := c.loadARM64VectorFloat(firstReg, form.arrangement)
+	if err != nil {
+		return err
+	}
+	floatType := arm64RawFloatType(form.arrangement.elementBits)
+	if form.scalar {
+		left := c.newTmp()
+		right := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x %s> %s, i32 0\n", left, floatType, first)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x %s> %s, i32 1\n", right, floatType, first)
+		fmt.Fprintf(c.b, "  %%%s = fadd %s %%%s, %%%s\n", result, floatType, left, right)
+		return c.storeARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), form.arrangement.elementBits, "%"+result)
+	}
+
+	second, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.second)), form.arrangement)
+	if err != nil {
+		return err
+	}
+	result := "poison"
+	half := form.arrangement.lanes / 2
+	for lane := 0; lane < form.arrangement.lanes; lane++ {
+		source := first
+		if lane >= half {
+			source = second
+		}
+		pair := (lane % half) * 2
+		left := c.newTmp()
+		right := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", left, form.arrangement.lanes, floatType, source, pair)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", right, form.arrangement.lanes, floatType, source, pair+1)
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fadd %s %%%s, %%%s\n", combined, floatType, left, right)
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n",
+			inserted, form.arrangement.lanes, floatType, result, floatType, combined, lane)
+		result = "%" + inserted
+	}
+	return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), form.arrangement, result)
+}
diff --git a/arm64_lower_word_faddp_test.go b/arm64_lower_word_faddp_test.go
new file mode 100644
index 000000000..9024860ea
--- /dev/null
+++ b/arm64_lower_word_faddp_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawFADDPCompleteArchitecturalFormats(t *testing.T) {
+	vectorBases := []uint32{
+		0x2e401400, // FADDP Vd.4H, Vn.4H, Vm.4H.
+		0x6e401400, // FADDP Vd.8H, Vn.8H, Vm.8H.
+		0x2e20d400, // FADDP Vd.2S, Vn.2S, Vm.2S.
+		0x6e20d400, // FADDP Vd.4S, Vn.4S, Vm.4S.
+		0x6e60d400, // FADDP Vd.2D, Vn.2D, Vm.2D.
+	}
+	scalarBases := []uint32{
+		0x5e30d800, // FADDP Hd, Vn.2H.
+		0x7e30d800, // FADDP Sd, Vn.2S.
+		0x7e70d800, // FADDP Dd, Vn.2D.
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfaddpforms(SB),$0-0\n")
+	for _, base := range vectorBases {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", base|29<<16|30<<5|28)
+	}
+	for _, base := range scalarBases {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", base|30<<5|29)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfaddpforms": {Name: "rawfaddpforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-faddp.ll", "arm64-raw-faddp.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFADDPDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e60d400, // reserved D1 vector arrangement.
+		0x2e20f400, // FMAXP vector instruction.
+		0x7e30f800, // FMAXP scalar instruction.
+		0x2e401800, // adjacent opcode bits in the FP16 vector encoding.
+		0x5e70d800, // reserved scalar FP16 size combination.
+	} {
+		if _, ok := decodeARM64RawFADDP(word); ok {
+			t.Fatalf("FADDP decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawFADDPRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfaddp(SB),$0-32
+	MOVD halfs+0(FP), R0
+	MOVD singles+8(FP), R1
+	MOVD doubles+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1.P 16(R0), [V0.H8]
+	VLD1 (R0), [V1.H8]
+	WORD $0x2e411402 // FADDP V2.4H, V0.4H, V1.4H
+	WORD $0x6e411403 // FADDP V3.8H, V0.8H, V1.8H
+	WORD $0x5e30d804 // FADDP H4, V0.2H
+	VST1.P [V2.H4], 8(R3)
+	VST1.P [V3.H8], 16(R3)
+	VST1.P [V4.H4], 8(R3)
+	VLD1.P 16(R1), [V5.S4]
+	VLD1 (R1), [V6.S4]
+	WORD $0x2e26d4a7 // FADDP V7.2S, V5.2S, V6.2S
+	WORD $0x6e26d4a8 // FADDP V8.4S, V5.4S, V6.4S
+	WORD $0x7e30d8a9 // FADDP S9, V5.2S
+	VST1.P [V7.S2], 8(R3)
+	VST1.P [V8.S4], 16(R3)
+	VST1.P [V9.S2], 8(R3)
+	VLD1.P 16(R2), [V10.D2]
+	VLD1 (R2), [V11.D2]
+	WORD $0x6e6bd54c // FADDP V12.2D, V10.2D, V11.2D
+	WORD $0x7e70d94d // FADDP D13, V10.2D
+	VST1.P [V12.D2], 16(R3)
+	VST1 [V13.D2], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawfaddp": {
+				Name: "rawfaddp", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfaddp(const uint16_t *, const float *, const double *, void *);
+int main(void) {
+  const uint16_t halfs[16] = {
+    0x3c00,0x3c00,0x4000,0x4000,0x4200,0x4200,0x4400,0x4400,
+    0x4500,0x4500,0x4600,0x4600,0x4700,0x4700,0x4800,0x4800
+  };
+  const float singles[8] = {1,2,3,4,10,20,30,40};
+  const double doubles[4] = {1,2,10,20};
+  _Alignas(16) unsigned char output[96] = {0};
+  rawfaddp(halfs, singles, doubles, output);
+  const uint16_t want_h4[4] = {0x4000,0x4400,0x4900,0x4a00};
+  const uint16_t want_h8[8] = {0x4000,0x4400,0x4600,0x4800,0x4900,0x4a00,0x4b00,0x4c00};
+  for (int i = 0; i < 4; i++) if (((uint16_t *)(output + 0))[i] != want_h4[i]) return 1 + i;
+  for (int i = 0; i < 8; i++) if (((uint16_t *)(output + 8))[i] != want_h8[i]) return 10 + i;
+  if (((uint16_t *)(output + 24))[0] != 0x4000) return 20;
+  if (((float *)(output + 32))[0] != 3 || ((float *)(output + 32))[1] != 30) return 21;
+  const float want_s4[4] = {3,7,30,70};
+  for (int i = 0; i < 4; i++) if (((float *)(output + 40))[i] != want_s4[i]) return 22 + i;
+  if (((float *)(output + 56))[0] != 3) return 30;
+  if (((double *)(output + 64))[0] != 3 || ((double *)(output + 64))[1] != 30) return 31;
+  if (((double *)(output + 80))[0] != 3) return 32;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_faddp", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_fcvt_round_test.go b/arm64_lower_word_fcvt_round_test.go
new file mode 100644
index 000000000..f469b6bcc
--- /dev/null
+++ b/arm64_lower_word_fcvt_round_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawFloatToIntegerRoundingCompleteBaseFormats(t *testing.T) {
+	// The base A64 Advanced SIMD family has five rounding modes, signed and
+	// unsigned results, and S2/S4/D2 arrangements. H4/H8 belong to the
+	// optional FP16 extension and are deliberately outside this base matrix.
+	bases := []uint32{
+		0x0e21a800, // FCVTNS
+		0x0e21b800, // FCVTMS
+		0x0e21c800, // FCVTAS
+		0x0ea1a800, // FCVTPS
+		0x0ea1b800, // FCVTZS
+	}
+	modifiers := []uint32{0, 1 << 30, 1<<30 | 1<<22} // S2, S4, D2.
+	var source strings.Builder
+	source.WriteString("TEXT rawfcvtroundforms(SB),$0-0\n")
+	for _, base := range bases {
+		for _, unsigned := range []uint32{0, 1 << 29} {
+			for _, modifier := range modifiers {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", base|unsigned|modifier|30<<5|29)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawfcvtroundforms": {Name: "rawfcvtroundforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{
+				"@llvm.roundeven.", "@llvm.floor.", "@llvm.round.", "@llvm.ceil.",
+				"@llvm.fptosi.sat.", "@llvm.fptoui.sat.",
+			} {
+				if !strings.Contains(ll, intrinsic) {
+					t.Fatalf("raw FCVT rounding family omitted %s for %s:\n%s", intrinsic, triple, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fcvt-round.ll", "arm64-raw-fcvt-round.o", ll)
+		})
+	}
+}
+
+func TestARM64RawFloatToIntegerRoundingRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfcvtround(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x4e21a801 // FCVTNS V0.4S, V1.4S
+	WORD $0x6e21a802 // FCVTNU V0.4S, V2.4S
+	WORD $0x4e21b803 // FCVTMS V0.4S, V3.4S
+	WORD $0x6e21b804 // FCVTMU V0.4S, V4.4S
+	WORD $0x4e21c805 // FCVTAS V0.4S, V5.4S
+	WORD $0x6e21c806 // FCVTAU V0.4S, V6.4S
+	WORD $0x4ea1a807 // FCVTPS V0.4S, V7.4S
+	WORD $0x6ea1a808 // FCVTPU V0.4S, V8.4S
+	WORD $0x4ea1b809 // FCVTZS V0.4S, V9.4S
+	WORD $0x6ea1b80a // FCVTZU V0.4S, V10.4S
+	VST1 [V1.S4, V2.S4, V3.S4, V4.S4], (R1)
+	ADD $64, R1
+	VST1 [V5.S4, V6.S4, V7.S4, V8.S4], (R1)
+	ADD $64, R1
+	VST1 [V9.S4, V10.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfcvtround": {
+			Name: "rawfcvtround", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfcvtround(const float *, uint32_t *);
+int main(void) {
+  const float input[4] = {1.5f, 2.5f, -1.5f, -2.5f};
+  const int32_t want[40] = {
+    2,2,-2,-2, 2,2,0,0,
+    1,2,-2,-3, 1,2,0,0,
+    2,3,-2,-3, 2,3,0,0,
+    2,3,-1,-2, 2,3,0,0,
+    1,2,-1,-2, 1,2,0,0,
+  };
+  uint32_t got[40] = {0};
+  rawfcvtround(input, got);
+  for (int i = 0; i < 40; i++) {
+    if ((int32_t)got[i] != want[i]) return i + 1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fcvt_round", triple, ll, mainC, nil)
+}
diff --git a/arm64_lower_word_fcvtz.go b/arm64_lower_word_fcvtz.go
new file mode 100644
index 000000000..dff88dd8a
--- /dev/null
+++ b/arm64_lower_word_fcvtz.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFCVTZ struct {
+	unsigned    bool
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+func decodeARM64RawFCVTZ(word uint32) (arm64RawFCVTZ, bool) {
+	masked := word & 0xbfbffc00 // Ignore Q, size, Rn, and Rd.
+	if masked != 0x0ea1b800 && masked != 0x2ea1b800 {
+		return arm64RawFCVTZ{}, false
+	}
+	elementBits := 32
+	if word&(1<<22) != 0 {
+		elementBits = 64
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if elementBits == 64 && vectorBits == 64 {
+		return arm64RawFCVTZ{}, false
+	}
+	return arm64RawFCVTZ{
+		unsigned:    word&(1<<29) != 0,
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFCVTZ(form arm64RawFCVTZ) error {
+	op := Op("VFCVTZS")
+	if form.unsigned {
+		op = "VFCVTZU"
+	}
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	ins := Instr{
+		Op:  op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", op),
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.source, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorFloatUnary(op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_fcvtz_test.go b/arm64_lower_word_fcvtz_test.go
new file mode 100644
index 000000000..b94bc7543
--- /dev/null
+++ b/arm64_lower_word_fcvtz_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawFCVTZForms = `
+TEXT rawfcvtzforms(SB),$0-0
+	WORD $0x0ea1b820 // FCVTZS V1.S2, V0.S2
+	WORD $0x4ea1b862 // FCVTZS V3.S4, V2.S4
+	WORD $0x4ee1b8a4 // FCVTZS V5.D2, V4.D2
+	WORD $0x2ea1b8e6 // FCVTZU V7.S2, V6.S2
+	WORD $0x6ea1b928 // FCVTZU V9.S4, V8.S4
+	WORD $0x6ee1b96a // FCVTZU V11.D2, V10.D2
+	RET
+`
+
+func TestTranslateARM64RawFCVTZCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawFCVTZForms, true)
+	file, err := Parse(ArchARM64, arm64RawFCVTZForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawfcvtzforms": {Name: "rawfcvtzforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"@llvm.fptosi.sat.v2i32.v2f32", "@llvm.fptosi.sat.v4i32.v4f32", "@llvm.fptosi.sat.v2i64.v2f64",
+				"@llvm.fptoui.sat.v2i32.v2f32", "@llvm.fptoui.sat.v4i32.v4f32", "@llvm.fptoui.sat.v2i64.v2f64",
+			} {
+				found := false
+				for _, line := range strings.Split(ll, "\n") {
+					if strings.Contains(line, " = call ") && strings.Contains(line, want) {
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Fatalf("ARM64 raw FCVTZS/FCVTZU lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fcvtz.ll", "arm64-raw-fcvtz.o", ll)
+		})
+	}
+}
+
+func TestARM64RawFCVTZRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfcvtz(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x4ea1b801 // FCVTZS V0.4S, V1.4S
+	WORD $0x6ea1b802 // FCVTZU V0.4S, V2.4S
+	VST1 [V1.S4, V2.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfcvtz": {
+			Name: "rawfcvtz", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawfcvtz(const float *, uint32_t *);
+int main(void) {
+  const float in[4] = {-1.75f, 1.75f, 1.0e30f, -1.0e30f};
+  const int32_t signed_want[4] = {-1, 1, INT32_MAX, INT32_MIN};
+  const uint32_t unsigned_want[4] = {0, 1, UINT32_MAX, 0};
+  uint32_t got[8] = {0};
+  rawfcvtz(in, got);
+  for (int i = 0; i < 4; i++) {
+    if ((int32_t)got[i] != signed_want[i]) return i + 1;
+    if (got[4+i] != unsigned_want[i]) return i + 11;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fcvtz", triple, ll, mainC, nil)
+}
+
+func TestARM64RawFCVTZDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{0x4e21d800, 0x1e38c000, 0x0ee1b800} { // SCVTF, scalar FCVTZS, reserved D1.
+		if _, ok := decodeARM64RawFCVTZ(word); ok {
+			t.Fatalf("FCVTZS/FCVTZU decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_fixed_int_to_float.go b/arm64_lower_word_fixed_int_to_float.go
new file mode 100644
index 000000000..2c8eb70a8
--- /dev/null
+++ b/arm64_lower_word_fixed_int_to_float.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+// SCVTF and UCVTF have three distinct fixed-point encodings: a general
+// register to scalar float, an Advanced SIMD scalar, and an Advanced SIMD
+// vector. The unscaled forms use different opcodes and remain separate.
+type arm64RawFixedIntToFloat struct {
+	unsigned       bool
+	scalar         bool
+	vectorSource   bool
+	integerBits    int
+	fractionalBits int
+	vectorBits     int
+	source         int
+	destination    int
+}
+
+func decodeARM64RawFixedIntToFloat(word uint32) (arm64RawFixedIntToFloat, bool) {
+	const (
+		gpVariable = uint32(1<<31 | 1<<22 | 1<<16 | 63<<10 | 31<<5 | 31)
+		gpBase     = uint32(0x1e020000)
+	)
+	if word&^gpVariable == gpBase {
+		integerBits := 32
+		if word&(1<<31) != 0 {
+			integerBits = 64
+		}
+		fractionalBits := 64 - int(word>>10&63)
+		if fractionalBits > integerBits {
+			return arm64RawFixedIntToFloat{}, false
+		}
+		floatBits := 32
+		if word&(1<<22) != 0 {
+			floatBits = 64
+		}
+		return arm64RawFixedIntToFloat{
+			unsigned:       word&(1<<16) != 0,
+			scalar:         true,
+			integerBits:    integerBits,
+			fractionalBits: fractionalBits,
+			vectorBits:     floatBits,
+			source:         int(word>>5) & 31,
+			destination:    int(word) & 31,
+		}, true
+	}
+
+	maskedScalar := word & 0xff80fc00
+	maskedVector := word & 0xbf80fc00
+	scalar := maskedScalar == 0x5f00e400 || maskedScalar == 0x7f00e400
+	vector := maskedVector == 0x0f00e400 || maskedVector == 0x2f00e400
+	if !scalar && !vector {
+		return arm64RawFixedIntToFloat{}, false
+	}
+
+	immh := int(word>>19) & 15
+	integerBits := 0
+	switch {
+	case immh >= 8:
+		integerBits = 64
+	case immh >= 4:
+		integerBits = 32
+	default:
+		return arm64RawFixedIntToFloat{}, false
+	}
+	vectorBits := integerBits
+	if vector {
+		vectorBits = 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if integerBits == 64 && vectorBits == 64 {
+			return arm64RawFixedIntToFloat{}, false
+		}
+	}
+	fractionalBits := 2*integerBits - int(word>>16&127)
+	if fractionalBits < 1 || fractionalBits > integerBits {
+		return arm64RawFixedIntToFloat{}, false
+	}
+	return arm64RawFixedIntToFloat{
+		unsigned:       word&(1<<29) != 0,
+		scalar:         scalar,
+		vectorSource:   true,
+		integerBits:    integerBits,
+		fractionalBits: fractionalBits,
+		vectorBits:     vectorBits,
+		source:         int(word>>5) & 31,
+		destination:    int(word) & 31,
+	}, true
+}
+
+func arm64FixedIntToFloatScale(bits int) string {
+	return strconv.FormatFloat(math.Ldexp(1, -bits), 'e', 17, 64)
+}
+
+func (c *arm64Ctx) lowerRawFixedIntToFloat(form arm64RawFixedIntToFloat) error {
+	conversion := "sitofp"
+	if form.unsigned {
+		conversion = "uitofp"
+	}
+	floatType := "float"
+	floatBits := form.integerBits
+	if form.scalar {
+		floatBits = form.vectorBits
+	}
+	if floatBits == 64 {
+		floatType = "double"
+	}
+	scale := arm64FixedIntToFloatScale(form.fractionalBits)
+	sourceReg := Reg(fmt.Sprintf("R%d", form.source))
+	if form.vectorSource {
+		sourceReg = Reg(fmt.Sprintf("F%d", form.source))
+	} else if form.source == 31 {
+		sourceReg = ZR
+	}
+	destinationReg := Reg(fmt.Sprintf("F%d", form.destination))
+
+	if form.scalar {
+		source, err := c.loadReg(sourceReg)
+		if err != nil {
+			return err
+		}
+		if form.integerBits == 32 {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, source)
+			source = "%" + narrow
+		}
+		converted := c.newTmp()
+		scaled := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i%d %s to %s\n", converted, conversion, form.integerBits, source, floatType)
+		fmt.Fprintf(c.b, "  %%%s = fmul %s %%%s, %s\n", scaled, floatType, converted, scale)
+		return c.storeARM64ScalarFloatReg(destinationReg, form.vectorBits, "%"+scaled)
+	}
+
+	arrangement := arm64VectorArrangement{
+		elementBits: form.integerBits,
+		lanes:       form.vectorBits / form.integerBits,
+	}
+	vectorSource := Reg(fmt.Sprintf("V%d", form.source))
+	vectorDestination := Reg(fmt.Sprintf("V%d", form.destination))
+	source, err := c.loadARM64VectorInteger(vectorSource, arrangement)
+	if err != nil {
+		return err
+	}
+	converted := c.newTmp()
+	scaled := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %s to <%d x %s>\n",
+		converted, conversion, arrangement.lanes, form.integerBits, source, arrangement.lanes, floatType)
+	fmt.Fprintf(c.b, "  %%%s = fmul <%d x %s> %%%s, <", scaled, arrangement.lanes, floatType, converted)
+	for lane := 0; lane < arrangement.lanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "%s %s", floatType, scale)
+	}
+	c.b.WriteString(">\n")
+	return c.storeARM64VectorFloat(vectorDestination, arrangement, "%"+scaled)
+}
diff --git a/arm64_lower_word_fixed_int_to_float_test.go b/arm64_lower_word_fixed_int_to_float_test.go
new file mode 100644
index 000000000..8b6fa506f
--- /dev/null
+++ b/arm64_lower_word_fixed_int_to_float_test.go
@@ -0,0 +1,261 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64RawFixedIntToFloatDecoderCompleteFamily(t *testing.T) {
+	check := func(word uint32, want arm64RawFixedIntToFloat) {
+		t.Helper()
+		var code [4]byte
+		binary.LittleEndian.PutUint32(code[:], word)
+		if _, err := arm64asm.Decode(code[:]); err != nil {
+			t.Fatalf("Go's architecture decoder rejected %#08x: %v", word, err)
+		}
+		got, ok := decodeARM64RawFixedIntToFloat(word)
+		if !ok || got != want {
+			t.Fatalf("decode %#08x = %+v, %v; want %+v", word, got, ok, want)
+		}
+	}
+	for _, unsigned := range []bool{false, true} {
+		for _, integerBits := range []int{32, 64} {
+			for _, floatBits := range []int{32, 64} {
+				for _, fractionalBits := range []int{1, integerBits / 2, integerBits} {
+					for _, register := range []int{0, 31} {
+						word := uint32(0x1e020000 | (64-fractionalBits)<<10 | register<<5 | register)
+						if integerBits == 64 {
+							word |= 1 << 31
+						}
+						if floatBits == 64 {
+							word |= 1 << 22
+						}
+						if unsigned {
+							word |= 1 << 16
+						}
+						check(word, arm64RawFixedIntToFloat{
+							unsigned: unsigned, scalar: true, integerBits: integerBits,
+							fractionalBits: fractionalBits, vectorBits: floatBits,
+							source: register, destination: register,
+						})
+					}
+				}
+			}
+		}
+	}
+	for _, unsigned := range []bool{false, true} {
+		for _, integerBits := range []int{32, 64} {
+			for _, fractionalBits := range []int{1, integerBits / 2, integerBits} {
+				for _, register := range []int{0, 31} {
+					shift := uint32(2*integerBits-fractionalBits) << 16
+					word := uint32(0x5f00e400|register<<5|register) | shift
+					if unsigned {
+						word |= 1 << 29
+					}
+					check(word, arm64RawFixedIntToFloat{
+						unsigned: unsigned, scalar: true, vectorSource: true,
+						integerBits: integerBits, fractionalBits: fractionalBits,
+						vectorBits: integerBits, source: register, destination: register,
+					})
+				}
+			}
+		}
+	}
+	for _, unsigned := range []bool{false, true} {
+		for _, arrangement := range []struct{ integerBits, vectorBits int }{
+			{32, 64}, {32, 128}, {64, 128},
+		} {
+			for _, fractionalBits := range []int{1, arrangement.integerBits / 2, arrangement.integerBits} {
+				for _, register := range []int{0, 31} {
+					shift := uint32(2*arrangement.integerBits-fractionalBits) << 16
+					word := uint32(0x0f00e400|register<<5|register) | shift
+					if unsigned {
+						word |= 1 << 29
+					}
+					if arrangement.vectorBits == 128 {
+						word |= 1 << 30
+					}
+					check(word, arm64RawFixedIntToFloat{
+						unsigned: unsigned, vectorSource: true,
+						integerBits: arrangement.integerBits, fractionalBits: fractionalBits,
+						vectorBits: arrangement.vectorBits, source: register, destination: register,
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawFixedIntToFloatDecoderRejectsOtherForms(t *testing.T) {
+	for _, word := range []uint32{
+		0x1e220000, // Unscaled scalar SCVTF.
+		0x4e21d800, // Unscaled vector SCVTF.
+		0x5e21d800, // Unscaled Advanced SIMD scalar SCVTF.
+		0x1e027c00, // W-source fractional width exceeds 32 bits.
+		0x0f00e400, // Missing element-width indicator.
+		0x0f40e400, // A 64-bit vector cannot hold one 64-bit lane.
+		0x4f00e000, // Adjacent vector opcode.
+	} {
+		if _, ok := decodeARM64RawFixedIntToFloat(word); ok {
+			t.Fatalf("decoder accepted invalid/adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func TestTranslateARM64RawFixedIntToFloatGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawFixedIntToFloat(SB),$0-0
+	WORD $0x1e43fc00 // UCVTF D0, W0, #1
+	WORD $0x4f28e631 // SCVTF V17.4S, V17.4S, #24
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawFixedIntToFloat": {Name: "rawFixedIntToFloat", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"uitofp i32", "sitofp <4 x i32>", "fmul double", "fmul <4 x float>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("fixed-point conversion omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fixed-int-to-float.ll", "arm64-raw-fixed-int-to-float.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFixedIntToFloatRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawFixedRuntime(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x4f28e401 // SCVTF V1.4S, V0.4S, #24
+	WORD $0x6f28e402 // UCVTF V2.4S, V0.4S, #24
+	VST1 [V1.S4, V2.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawFixedRuntime": {
+			Name: "rawFixedRuntime", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawFixedRuntime(const uint32_t *, float *);
+int main(void) {
+  const uint32_t input[4] = {0x01000000u, 0xff000000u, 0, 0x00800000u};
+  float got[8] = {0};
+  rawFixedRuntime(input, got);
+  const float signed_want[4] = {1.0f, -1.0f, 0.0f, 0.5f};
+  const float unsigned_want[4] = {1.0f, 255.0f, 0.0f, 0.5f};
+  for (int i = 0; i < 4; i++) {
+    if (got[i] != signed_want[i]) return i + 1;
+    if (got[4+i] != unsigned_want[i]) return i + 11;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fixed_cvtf", triple, ir, mainC, nil)
+}
+
+func TestARM64RawFixedIntToFloatAllModesCompile(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawFixedAllModes(SB),$0-0\n")
+	for _, form := range []struct {
+		name string
+		word uint32
+	}{
+		{"signed GPR S/W", 0x1e02fc20},
+		{"unsigned GPR S/W", 0x1e03fc20},
+		{"signed GPR S/X", 0x9e02fc20},
+		{"unsigned GPR S/X", 0x9e03a1c0},
+		{"signed GPR D/W", 0x1e42fc20},
+		{"unsigned GPR D/W", 0x1e43fc20},
+		{"signed GPR D/X", 0x9e42fc20},
+		{"unsigned GPR D/X", 0x9e43fc20},
+		{"signed scalar S", 0x5f28e420},
+		{"unsigned scalar D", 0x7f40e420},
+		{"signed vector 2S", 0x0f28e420},
+		{"unsigned vector 4S", 0x6f28e420},
+		{"signed vector 2D", 0x4f40e420},
+	} {
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", form.word, form.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawFixedAllModes": {Name: "rawFixedAllModes", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fixed-all-modes.ll", "arm64-raw-fixed-all-modes.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_float_abs_neg.go b/arm64_lower_word_float_abs_neg.go
new file mode 100644
index 000000000..e4f682be1
--- /dev/null
+++ b/arm64_lower_word_float_abs_neg.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFloatAbsNeg struct {
+	negate      bool
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+// decodeARM64RawFloatAbsNeg recognizes the FP16 Advanced SIMD forms that Go's
+// named VFABS/VFNEG optab cannot express. S2/S4/D2 WORD encodings are decoded
+// by x/arch and flow through the complete named-form lowerer.
+func decodeARM64RawFloatAbsNeg(word uint32) (arm64RawFloatAbsNeg, bool) {
+	const registers = uint32(31 | 31<<5)
+	key := word &^ registers
+	negate := false
+	switch key {
+	case 0x0ef8f800, 0x4ef8f800:
+	case 0x2ef8f800, 0x6ef8f800:
+		negate = true
+	default:
+		return arm64RawFloatAbsNeg{}, false
+	}
+	lanes := 4
+	if word&(1<<30) != 0 {
+		lanes = 8
+	}
+	return arm64RawFloatAbsNeg{
+		negate:      negate,
+		arrangement: arm64VectorArrangement{elementBits: 16, lanes: lanes},
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFloatAbsNeg(form arm64RawFloatAbsNeg) error {
+	source, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.source)), form.arrangement)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x half>", form.arrangement.lanes)
+	if form.negate {
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", result, vectorType, source)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fabs.v%df16(%s %s)\n", result, vectorType, form.arrangement.lanes, vectorType, source)
+	}
+	return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_float_abs_neg_test.go b/arm64_lower_word_float_abs_neg_test.go
new file mode 100644
index 000000000..71c56b6c6
--- /dev/null
+++ b/arm64_lower_word_float_abs_neg_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawFloatAbsNegForms = `
+TEXT rawfloatabsnegforms(SB),$0-0
+	WORD $0x0ef8f820 // FABS V0.4H, V1.4H
+	WORD $0x4ef8f820 // FABS V0.8H, V1.8H
+	WORD $0x0ea0f820 // FABS V0.2S, V1.2S
+	WORD $0x4ea0f820 // FABS V0.4S, V1.4S
+	WORD $0x4ee0f820 // FABS V0.2D, V1.2D
+	WORD $0x2ef8f820 // FNEG V0.4H, V1.4H
+	WORD $0x6ef8f820 // FNEG V0.8H, V1.8H
+	WORD $0x2ea0f820 // FNEG V0.2S, V1.2S
+	WORD $0x6ea0f820 // FNEG V0.4S, V1.4S
+	WORD $0x6ee0f820 // FNEG V0.2D, V1.2D
+	RET
+`
+
+func TestTranslateARM64RawFloatAbsNegCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawFloatAbsNegForms, true)
+	file, err := Parse(ArchARM64, arm64RawFloatAbsNegForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfloatabsnegforms": {Name: "rawfloatabsnegforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"@llvm.fabs.v4f16", "@llvm.fabs.v8f16", "fneg <4 x half>", "fneg <8 x half>", "@llvm.fabs.v2f32", "@llvm.fabs.v4f32", "@llvm.fabs.v2f64", "fneg <2 x float>", "fneg <4 x float>", "fneg <2 x double>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw float abs/neg for %s omitted %s:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "raw-float-abs-neg.ll", "raw-float-abs-neg.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFloatAbsNegRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatabsneg(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.H8]
+	WORD $0x4ef8f801 // FABS V1.8H, V0.8H
+	WORD $0x6ef8f802 // FNEG V2.8H, V0.8H
+	VST1.P [V1.H8], 16(R1)
+	VST1 [V2.H8], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawfloatabsneg": {
+			Name: "rawfloatabsneg", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatabsneg(const uint16_t *, uint16_t *);
+int main(void) {
+  const uint16_t input[8] = {0xbc00,0x4000,0xc200,0x4400,0xc500,0x4600,0xc700,0x4800};
+  uint16_t got[16] = {0};
+  rawfloatabsneg(input, got);
+  for (int i = 0; i < 8; i++) {
+    if (got[i] != (input[i] & 0x7fff)) return i + 1;
+    if (got[8+i] != (input[i] ^ 0x8000)) return i + 9;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_abs_neg", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_float_binary.go b/arm64_lower_word_float_binary.go
new file mode 100644
index 000000000..25e0d84ad
--- /dev/null
+++ b/arm64_lower_word_float_binary.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFloatBinary struct {
+	op          Op
+	arrangement arm64VectorArrangement
+	first       int
+	second      int
+	destination int
+}
+
+func decodeARM64RawFloatBinary(word uint32) (arm64RawFloatBinary, bool) {
+	const registers = uint32(31 | 31<<5 | 31<<16)
+	halfForms := map[uint32]Op{
+		0x0e401400: "VFADD", 0x4e401400: "VFADD",
+		0x0ec01400: "VFSUB", 0x4ec01400: "VFSUB",
+		0x2e401c00: "VFMUL", 0x6e401c00: "VFMUL",
+		0x2e403c00: "VFDIV", 0x6e403c00: "VFDIV",
+		0x0e403400: "VFMAX", 0x4e403400: "VFMAX",
+		0x0ec03400: "VFMIN", 0x4ec03400: "VFMIN",
+		0x0e400400: "VFMAXNM", 0x4e400400: "VFMAXNM",
+		0x0ec00400: "VFMINNM", 0x4ec00400: "VFMINNM",
+		0x2ec01400: "VFABD", 0x6ec01400: "VFABD",
+		0x0e401c00: "VFMULX", 0x4e401c00: "VFMULX",
+	}
+	if op, ok := halfForms[word&^registers]; ok {
+		lanes := 4
+		if word&(1<<30) != 0 {
+			lanes = 8
+		}
+		return arm64RawFloatBinary{
+			op:          op,
+			arrangement: arm64VectorArrangement{elementBits: 16, lanes: lanes},
+			first:       int(word>>5) & 31,
+			second:      int(word>>16) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+
+	var op Op
+	switch word & 0xbfa0fc00 { // Ignore Q, size, Rm, Rn, and Rd.
+	case 0x0e20d400:
+		op = "VFADD"
+	case 0x0ea0d400:
+		op = "VFSUB"
+	case 0x2e20dc00:
+		op = "VFMUL"
+	case 0x2e20fc00:
+		op = "VFDIV"
+	case 0x0e20f400:
+		op = "VFMAX"
+	case 0x0ea0f400:
+		op = "VFMIN"
+	case 0x0e20c400:
+		op = "VFMAXNM"
+	case 0x0ea0c400:
+		op = "VFMINNM"
+	case 0x2ea0d400:
+		op = "VFABD"
+	case 0x0e20dc00:
+		op = "VFMULX"
+	default:
+		return arm64RawFloatBinary{}, false
+	}
+
+	elementBits := 32
+	if word&(1<<22) != 0 {
+		elementBits = 64
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	// The 64-bit scalar-sized D1 combination is reserved for this vector class.
+	if elementBits == 64 && vectorBits == 64 {
+		return arm64RawFloatBinary{}, false
+	}
+
+	return arm64RawFloatBinary{
+		op:          op,
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFloatBinary(form arm64RawFloatBinary) error {
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	ins := Instr{
+		Op:  form.op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", form.op),
+		Args: []Operand{
+			// Plan 9 vector arithmetic lists Vm, Vn, Vd; the architectural
+			// encoding stores Vn in Rn and Vm in Rm.
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.second, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.first, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorFloatArithmeticForm(form.op, ins, true)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_float_binary_test.go b/arm64_lower_word_float_binary_test.go
new file mode 100644
index 000000000..8db2bfd86
--- /dev/null
+++ b/arm64_lower_word_float_binary_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawFloatBinaryCompleteAdvancedSIMDFormats(t *testing.T) {
+	bases := []uint32{
+		0x0e20d400, 0x0ea0d400, 0x2e20dc00, 0x2e20fc00,
+		0x0e20f400, 0x0ea0f400, 0x0e20c400, 0x0ea0c400,
+		0x2ea0d400, // FABD.
+		0x0e20dc00, // FMULX.
+	}
+	halfBases := []uint32{
+		0x0e401400, 0x0ec01400, 0x2e401c00, 0x2e403c00,
+		0x0e403400, 0x0ec03400, 0x0e400400, 0x0ec00400,
+		0x2ec01400, // FABD.
+		0x0e401c00, // FMULX.
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatbinaryforms(SB),$0-0\n")
+	for _, base := range halfBases {
+		for _, modifier := range []uint32{0, 1 << 30} { // H4, H8.
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|modifier|2<<16|1<<5)
+		}
+	}
+	for _, base := range bases {
+		for _, modifier := range []uint32{0, 1 << 30, 1<<30 | 1<<22} { // S2, S4, D2.
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|modifier|2<<16|1<<5)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfloatbinaryforms": {Name: "rawfloatbinaryforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"fadd <4 x half>", "fadd <8 x half>",
+				"fsub <4 x half>", "fsub <8 x half>",
+				"fmul <4 x half>", "fmul <8 x half>",
+				"fdiv <4 x half>", "fdiv <8 x half>",
+				"@llvm.maximum.v4f16", "@llvm.maximum.v8f16",
+				"@llvm.minimum.v4f16", "@llvm.minimum.v8f16",
+				"@llvm.maxnum.v4f16", "@llvm.maxnum.v8f16",
+				"@llvm.minnum.v4f16", "@llvm.minnum.v8f16",
+				"@llvm.aarch64.neon.fabd.v4f16", "@llvm.aarch64.neon.fabd.v8f16",
+				"@llvm.aarch64.neon.fabd.v2f32", "@llvm.aarch64.neon.fabd.v4f32", "@llvm.aarch64.neon.fabd.v2f64",
+				"@llvm.aarch64.neon.fmulx.v4f16", "@llvm.aarch64.neon.fmulx.v8f16",
+				"@llvm.aarch64.neon.fmulx.v2f32", "@llvm.aarch64.neon.fmulx.v4f32", "@llvm.aarch64.neon.fmulx.v2f64",
+				"fadd <", "fsub <", "fmul <", "fdiv <",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw float binary lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-binary.ll", "arm64-raw-float-binary.o", ll)
+		})
+	}
+}
+
+func TestARM64RawFloatBinaryRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatbinary(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4e21d402 // FADD   V2.4S, V0.4S, V1.4S
+	WORD $0x4ea1d403 // FSUB   V3.4S, V0.4S, V1.4S
+	WORD $0x6e21dc04 // FMUL   V4.4S, V0.4S, V1.4S
+	WORD $0x6e21fc05 // FDIV   V5.4S, V0.4S, V1.4S
+	WORD $0x4e21f406 // FMAX   V6.4S, V0.4S, V1.4S
+	WORD $0x4ea1f407 // FMIN   V7.4S, V0.4S, V1.4S
+	WORD $0x4e21c408 // FMAXNM V8.4S, V0.4S, V1.4S
+	WORD $0x4ea1c409 // FMINNM V9.4S, V0.4S, V1.4S
+	VST1.P [V2.S4, V3.S4, V4.S4, V5.S4], 64(R2)
+	VST1 [V6.S4, V7.S4, V8.S4, V9.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawfloatbinary": {
+				Name: "rawfloatbinary", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatbinary(const float *, const float *, float *);
+int main(void) {
+  const float a[4] = {8.0f, -6.0f, 1.5f, -4.0f};
+  const float b[4] = {2.0f, 3.0f, -2.0f, 4.0f};
+  float got[32] = {0};
+  rawfloatbinary(a, b, got);
+  for (int i = 0; i < 4; i++) {
+    const float want[8] = {a[i]+b[i], a[i]-b[i], a[i]*b[i], a[i]/b[i], a[i]>b[i]?a[i]:b[i], a[i]<b[i]?a[i]:b[i], a[i]>b[i]?a[i]:b[i], a[i]<b[i]?a[i]:b[i]};
+    for (int op = 0; op < 8; op++) if (got[op*4+i] != want[op]) return op*4+i+1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_binary", triple, ll, mainC, nil)
+}
+
+func TestARM64RawFloatBinaryDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{0x2e20d400, 0x1e22d420, 0x0e60d400} { // FADDP, scalar FADD, reserved D1.
+		if _, ok := decodeARM64RawFloatBinary(word); ok {
+			t.Fatalf("float-binary decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_float_compare.go b/arm64_lower_word_float_compare.go
new file mode 100644
index 000000000..bebe5d334
--- /dev/null
+++ b/arm64_lower_word_float_compare.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFloatCompare struct {
+	op          Op
+	zero        bool
+	absolute    bool
+	arrangement arm64VectorArrangement
+	first       int
+	second      int
+	destination int
+}
+
+type arm64RawFloatCompareEncoding struct {
+	base        uint32
+	op          Op
+	absolute    bool
+	arrangement arm64VectorArrangement
+}
+
+var arm64RawFloatCompareBinaryEncodings = []arm64RawFloatCompareEncoding{
+	{0x0e402400, "VFCMEQ", false, arm64VectorArrangement{16, 4}},
+	{0x4e402400, "VFCMEQ", false, arm64VectorArrangement{16, 8}},
+	{0x0e20e400, "VFCMEQ", false, arm64VectorArrangement{32, 2}},
+	{0x4e20e400, "VFCMEQ", false, arm64VectorArrangement{32, 4}},
+	{0x4e60e400, "VFCMEQ", false, arm64VectorArrangement{64, 2}},
+
+	{0x2e402400, "VFCMGE", false, arm64VectorArrangement{16, 4}},
+	{0x6e402400, "VFCMGE", false, arm64VectorArrangement{16, 8}},
+	{0x2e20e400, "VFCMGE", false, arm64VectorArrangement{32, 2}},
+	{0x6e20e400, "VFCMGE", false, arm64VectorArrangement{32, 4}},
+	{0x6e60e400, "VFCMGE", false, arm64VectorArrangement{64, 2}},
+
+	{0x2ec02400, "VFCMGT", false, arm64VectorArrangement{16, 4}},
+	{0x6ec02400, "VFCMGT", false, arm64VectorArrangement{16, 8}},
+	{0x2ea0e400, "VFCMGT", false, arm64VectorArrangement{32, 2}},
+	{0x6ea0e400, "VFCMGT", false, arm64VectorArrangement{32, 4}},
+	{0x6ee0e400, "VFCMGT", false, arm64VectorArrangement{64, 2}},
+
+	{0x2e402c00, "VFACGE", true, arm64VectorArrangement{16, 4}},
+	{0x6e402c00, "VFACGE", true, arm64VectorArrangement{16, 8}},
+	{0x2e20ec00, "VFACGE", true, arm64VectorArrangement{32, 2}},
+	{0x6e20ec00, "VFACGE", true, arm64VectorArrangement{32, 4}},
+	{0x6e60ec00, "VFACGE", true, arm64VectorArrangement{64, 2}},
+
+	{0x2ec02c00, "VFACGT", true, arm64VectorArrangement{16, 4}},
+	{0x6ec02c00, "VFACGT", true, arm64VectorArrangement{16, 8}},
+	{0x2ea0ec00, "VFACGT", true, arm64VectorArrangement{32, 2}},
+	{0x6ea0ec00, "VFACGT", true, arm64VectorArrangement{32, 4}},
+	{0x6ee0ec00, "VFACGT", true, arm64VectorArrangement{64, 2}},
+}
+
+var arm64RawFloatCompareZeroEncodings = []arm64RawFloatCompareEncoding{
+	{0x0ef8d800, "VFCMEQ", false, arm64VectorArrangement{16, 4}},
+	{0x4ef8d800, "VFCMEQ", false, arm64VectorArrangement{16, 8}},
+	{0x0ea0d800, "VFCMEQ", false, arm64VectorArrangement{32, 2}},
+	{0x4ea0d800, "VFCMEQ", false, arm64VectorArrangement{32, 4}},
+	{0x4ee0d800, "VFCMEQ", false, arm64VectorArrangement{64, 2}},
+
+	{0x2ef8c800, "VFCMGE", false, arm64VectorArrangement{16, 4}},
+	{0x6ef8c800, "VFCMGE", false, arm64VectorArrangement{16, 8}},
+	{0x2ea0c800, "VFCMGE", false, arm64VectorArrangement{32, 2}},
+	{0x6ea0c800, "VFCMGE", false, arm64VectorArrangement{32, 4}},
+	{0x6ee0c800, "VFCMGE", false, arm64VectorArrangement{64, 2}},
+
+	{0x0ef8c800, "VFCMGT", false, arm64VectorArrangement{16, 4}},
+	{0x4ef8c800, "VFCMGT", false, arm64VectorArrangement{16, 8}},
+	{0x0ea0c800, "VFCMGT", false, arm64VectorArrangement{32, 2}},
+	{0x4ea0c800, "VFCMGT", false, arm64VectorArrangement{32, 4}},
+	{0x4ee0c800, "VFCMGT", false, arm64VectorArrangement{64, 2}},
+
+	{0x2ef8d800, "VFCMLE", false, arm64VectorArrangement{16, 4}},
+	{0x6ef8d800, "VFCMLE", false, arm64VectorArrangement{16, 8}},
+	{0x2ea0d800, "VFCMLE", false, arm64VectorArrangement{32, 2}},
+	{0x6ea0d800, "VFCMLE", false, arm64VectorArrangement{32, 4}},
+	{0x6ee0d800, "VFCMLE", false, arm64VectorArrangement{64, 2}},
+
+	{0x0ef8e800, "VFCMLT", false, arm64VectorArrangement{16, 4}},
+	{0x4ef8e800, "VFCMLT", false, arm64VectorArrangement{16, 8}},
+	{0x0ea0e800, "VFCMLT", false, arm64VectorArrangement{32, 2}},
+	{0x4ea0e800, "VFCMLT", false, arm64VectorArrangement{32, 4}},
+	{0x4ee0e800, "VFCMLT", false, arm64VectorArrangement{64, 2}},
+}
+
+func decodeARM64RawFloatCompare(word uint32) (arm64RawFloatCompare, bool) {
+	const binaryRegisters = uint32(31 | 31<<5 | 31<<16)
+	for _, encoding := range arm64RawFloatCompareBinaryEncodings {
+		if word&^binaryRegisters == encoding.base {
+			return arm64RawFloatCompare{
+				op:          encoding.op,
+				absolute:    encoding.absolute,
+				arrangement: encoding.arrangement,
+				first:       int(word>>5) & 31,
+				second:      int(word>>16) & 31,
+				destination: int(word) & 31,
+			}, true
+		}
+	}
+
+	const zeroRegisters = uint32(31 | 31<<5)
+	for _, encoding := range arm64RawFloatCompareZeroEncodings {
+		if word&^zeroRegisters == encoding.base {
+			return arm64RawFloatCompare{
+				op:          encoding.op,
+				zero:        true,
+				arrangement: encoding.arrangement,
+				first:       int(word>>5) & 31,
+				destination: int(word) & 31,
+			}, true
+		}
+	}
+	return arm64RawFloatCompare{}, false
+}
+
+func (c *arm64Ctx) lowerRawFloatCompare(form arm64RawFloatCompare) error {
+	predicate, ok := arm64FloatComparePredicate(form.op)
+	if !ok {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return c.lowerARM64VectorFloatCompareValues(
+		predicate,
+		form.absolute,
+		form.arrangement,
+		Reg(fmt.Sprintf("V%d", form.first)),
+		Reg(fmt.Sprintf("V%d", form.second)),
+		form.zero,
+		Reg(fmt.Sprintf("V%d", form.destination)),
+	)
+}
diff --git a/arm64_lower_word_float_compare_test.go b/arm64_lower_word_float_compare_test.go
new file mode 100644
index 000000000..11d872240
--- /dev/null
+++ b/arm64_lower_word_float_compare_test.go
@@ -0,0 +1,340 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawFloatCompareEncodingTest struct {
+	base     uint32
+	op       Op
+	bits     int
+	lanes    int
+	zero     bool
+	absolute bool
+}
+
+var arm64RawFloatCompareEncodingTests = []arm64RawFloatCompareEncodingTest{
+	{0x0e402400, "VFCMEQ", 16, 4, false, false}, {0x4e402400, "VFCMEQ", 16, 8, false, false},
+	{0x0e20e400, "VFCMEQ", 32, 2, false, false}, {0x4e20e400, "VFCMEQ", 32, 4, false, false}, {0x4e60e400, "VFCMEQ", 64, 2, false, false},
+	{0x2e402400, "VFCMGE", 16, 4, false, false}, {0x6e402400, "VFCMGE", 16, 8, false, false},
+	{0x2e20e400, "VFCMGE", 32, 2, false, false}, {0x6e20e400, "VFCMGE", 32, 4, false, false}, {0x6e60e400, "VFCMGE", 64, 2, false, false},
+	{0x2ec02400, "VFCMGT", 16, 4, false, false}, {0x6ec02400, "VFCMGT", 16, 8, false, false},
+	{0x2ea0e400, "VFCMGT", 32, 2, false, false}, {0x6ea0e400, "VFCMGT", 32, 4, false, false}, {0x6ee0e400, "VFCMGT", 64, 2, false, false},
+	{0x2e402c00, "VFACGE", 16, 4, false, true}, {0x6e402c00, "VFACGE", 16, 8, false, true},
+	{0x2e20ec00, "VFACGE", 32, 2, false, true}, {0x6e20ec00, "VFACGE", 32, 4, false, true}, {0x6e60ec00, "VFACGE", 64, 2, false, true},
+	{0x2ec02c00, "VFACGT", 16, 4, false, true}, {0x6ec02c00, "VFACGT", 16, 8, false, true},
+	{0x2ea0ec00, "VFACGT", 32, 2, false, true}, {0x6ea0ec00, "VFACGT", 32, 4, false, true}, {0x6ee0ec00, "VFACGT", 64, 2, false, true},
+
+	{0x0ef8d800, "VFCMEQ", 16, 4, true, false}, {0x4ef8d800, "VFCMEQ", 16, 8, true, false},
+	{0x0ea0d800, "VFCMEQ", 32, 2, true, false}, {0x4ea0d800, "VFCMEQ", 32, 4, true, false}, {0x4ee0d800, "VFCMEQ", 64, 2, true, false},
+	{0x2ef8c800, "VFCMGE", 16, 4, true, false}, {0x6ef8c800, "VFCMGE", 16, 8, true, false},
+	{0x2ea0c800, "VFCMGE", 32, 2, true, false}, {0x6ea0c800, "VFCMGE", 32, 4, true, false}, {0x6ee0c800, "VFCMGE", 64, 2, true, false},
+	{0x0ef8c800, "VFCMGT", 16, 4, true, false}, {0x4ef8c800, "VFCMGT", 16, 8, true, false},
+	{0x0ea0c800, "VFCMGT", 32, 2, true, false}, {0x4ea0c800, "VFCMGT", 32, 4, true, false}, {0x4ee0c800, "VFCMGT", 64, 2, true, false},
+	{0x2ef8d800, "VFCMLE", 16, 4, true, false}, {0x6ef8d800, "VFCMLE", 16, 8, true, false},
+	{0x2ea0d800, "VFCMLE", 32, 2, true, false}, {0x6ea0d800, "VFCMLE", 32, 4, true, false}, {0x6ee0d800, "VFCMLE", 64, 2, true, false},
+	{0x0ef8e800, "VFCMLT", 16, 4, true, false}, {0x4ef8e800, "VFCMLT", 16, 8, true, false},
+	{0x0ea0e800, "VFCMLT", 32, 2, true, false}, {0x4ea0e800, "VFCMLT", 32, 4, true, false}, {0x4ee0e800, "VFCMLT", 64, 2, true, false},
+}
+
+func TestARM64RawFloatCompareDecoderCompleteArchitectureFamily(t *testing.T) {
+	count := 0
+	for _, encoding := range arm64RawFloatCompareEncodingTests {
+		secondLimit := 32
+		if encoding.zero {
+			secondLimit = 1
+		}
+		for first := 0; first < 32; first++ {
+			for second := 0; second < secondLimit; second++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encoding.base | uint32(first)<<5 | uint32(destination)
+					if !encoding.zero {
+						word |= uint32(second) << 16
+					}
+					form, ok := decodeARM64RawFloatCompare(word)
+					if !ok {
+						t.Fatalf("decoder rejected %#08x", word)
+					}
+					if form.op != encoding.op || form.zero != encoding.zero || form.absolute != encoding.absolute ||
+						form.arrangement != (arm64VectorArrangement{elementBits: encoding.bits, lanes: encoding.lanes}) ||
+						form.first != first || form.destination != destination ||
+						(!encoding.zero && form.second != second) {
+						t.Fatalf("decode %#08x = %+v", word, form)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 844800 {
+		t.Fatalf("covered %d vector floating-compare encodings, want 844800", count)
+	}
+}
+
+func TestTranslateARM64RawFloatCompareCompleteArchitectureFamily(t *testing.T) {
+	const source = `
+TEXT rawFloatCompareArchitectureFamily(SB),$0-0
+	WORD $0x0e422420 // FCMEQ V0.4H, V1.4H, V2.4H
+	WORD $0x6ec32405 // FCMGT V5.8H, V0.8H, V3.8H
+	WORD $0x6e422c20 // FACGE V0.8H, V1.8H, V2.8H
+	WORD $0x6ea2ec20 // FACGT V0.4S, V1.4S, V2.4S
+	WORD $0x6ee2ec20 // FACGT V0.2D, V1.2D, V2.2D
+	WORD $0x4ef8d820 // FCMEQ V0.8H, V1.8H, #0.0
+	WORD $0x6ef8c820 // FCMGE V0.8H, V1.8H, #0.0
+	WORD $0x4ef8c820 // FCMGT V0.8H, V1.8H, #0.0
+	WORD $0x6ef8d820 // FCMLE V0.8H, V1.8H, #0.0
+	WORD $0x4ef8e820 // FCMLT V0.8H, V1.8H, #0.0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawFloatCompareArchitectureFamily": {Name: "rawFloatCompareArchitectureFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"fcmp oeq <4 x half>", "fcmp ogt <8 x half>",
+				"@llvm.fabs.v8f16", "@llvm.fabs.v4f32", "@llvm.fabs.v2f64",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw vector floating-compare IR omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-compare-family.ll", "arm64-raw-float-compare-family.o", ir)
+		})
+	}
+}
+
+func arm64FloatCompareCompleteSource(raw bool) string {
+	arrangements := []struct {
+		name     string
+		modifier uint32
+	}{
+		{name: "S2"},
+		{name: "S4", modifier: 1 << 30},
+		{name: "D2", modifier: 1<<30 | 1<<22},
+	}
+	var source strings.Builder
+	if raw {
+		source.WriteString("TEXT rawfloatcompareforms(SB),$0-0\n")
+		for _, base := range []uint32{0x0e20e400, 0x2e20e400, 0x2ea0e400} { // FCMEQ, FCMGE, FCMGT.
+			for _, arrangement := range arrangements {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", base|arrangement.modifier|1<<16|2<<5|3)
+			}
+		}
+		for _, base := range []uint32{0x0ea0d800, 0x2ea0c800, 0x0ea0c800, 0x2ea0d800, 0x0ea0e800} { // FCMEQ/GE/GT/LE/LT zero.
+			for _, arrangement := range arrangements {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", base|arrangement.modifier|2<<5|3)
+			}
+		}
+	} else {
+		source.WriteString("TEXT floatcompareforms(SB),$0-0\n")
+		for _, op := range []string{"VFCMEQ", "VFCMGE", "VFCMGT"} {
+			for _, arrangement := range arrangements {
+				fmt.Fprintf(&source, "\t%s V1.%s, V2.%s, V3.%s\n", op, arrangement.name, arrangement.name, arrangement.name)
+			}
+		}
+		for _, op := range []string{"VFCMEQ", "VFCMGE", "VFCMGT", "VFCMLE", "VFCMLT"} {
+			for _, arrangement := range arrangements {
+				fmt.Fprintf(&source, "\t%s $(0.0), V2.%s, V3.%s\n", op, arrangement.name, arrangement.name)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestTranslateARM64FloatCompareCompleteGo127Formats(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		name := "named"
+		function := "floatcompareforms"
+		if raw {
+			name = "raw"
+			function = "rawfloatcompareforms"
+		}
+		t.Run(name, func(t *testing.T) {
+			source := arm64FloatCompareCompleteSource(raw)
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs:         map[string]FuncSig{function: {Name: function, Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if got := strings.Count(ll, "fcmp o"); got != 24 {
+						t.Fatalf("ARM64 %s float-compare lowering for %s emitted %d compares, want 24:\n%s", name, triple, got, ll)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-"+name+"-float-compare.ll", "arm64-"+name+"-float-compare.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64RawFloatCompareRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatcompare(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4e21e402 // FCMEQ V2.4S, V0.4S, V1.4S
+	WORD $0x6e21e403 // FCMGE V3.4S, V0.4S, V1.4S
+	WORD $0x6ea1e404 // FCMGT V4.4S, V0.4S, V1.4S
+	WORD $0x4ea0d805 // FCMEQ V5.4S, V0.4S, #0.0
+	WORD $0x6ea0c806 // FCMGE V6.4S, V0.4S, #0.0
+	WORD $0x4ea0c807 // FCMGT V7.4S, V0.4S, #0.0
+	WORD $0x6ea0d808 // FCMLE V8.4S, V0.4S, #0.0
+	WORD $0x4ea0e809 // FCMLT V9.4S, V0.4S, #0.0
+	VST1.P [V2.S4, V3.S4, V4.S4, V5.S4], 64(R2)
+	VST1 [V6.S4, V7.S4, V8.S4, V9.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfloatcompare": {
+			Name: "rawfloatcompare", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatcompare(const float *, const float *, uint32_t *);
+int main(void) {
+  const float a[4] = {-2.0f, 0.0f, 3.0f, 4.0f};
+  const float b[4] = {-2.0f, 1.0f, 2.0f, 5.0f};
+  const unsigned truth[8][4] = {
+    {1,0,0,0}, {1,0,1,0}, {0,0,1,0}, {0,1,0,0},
+    {0,1,1,1}, {0,0,1,1}, {1,1,0,0}, {1,0,0,0},
+  };
+  uint32_t got[32] = {0};
+  rawfloatcompare(a, b, got);
+  for (int op = 0; op < 8; op++) for (int lane = 0; lane < 4; lane++)
+    if (got[op*4+lane] != (truth[op][lane] ? UINT32_MAX : 0)) return op*4+lane+1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_compare", triple, ll, mainC, nil)
+}
+
+func TestARM64RawFloatCompareHalfAndAbsoluteRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatcomparehalf(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.H8]
+	VLD1 (R1), [V1.H8]
+	WORD $0x6ec12402 // FCMGT V2.8H, V0.8H, V1.8H
+	WORD $0x6e412c03 // FACGE V3.8H, V0.8H, V1.8H
+	VST1 [V2.H8, V3.H8], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfloatcomparehalf": {
+			Name: "rawfloatcomparehalf", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatcomparehalf(const uint16_t *, const uint16_t *, uint16_t *);
+int main(void) {
+  const uint16_t a[8] = {0xc000,0x0000,0x4200,0x4400,0xb800,0x7c00,0x8000,0x3c00};
+  const uint16_t b[8] = {0xbc00,0x3c00,0x4000,0x4500,0x3400,0xfc00,0x0000,0xc000};
+  const unsigned truth[2][8] = {
+    {0,0,1,0,0,1,0,1},
+    {1,0,1,0,1,1,1,0},
+  };
+  uint16_t got[16] = {0};
+  rawfloatcomparehalf(a, b, got);
+  for (int op = 0; op < 2; op++) for (int lane = 0; lane < 8; lane++)
+    if (got[op*8+lane] != (truth[op][lane] ? UINT16_MAX : 0)) return op*8+lane+1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_compare_half", triple, ll, mainC, nil)
+}
+
+func TestARM64RawFloatCompareDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{0x2e20d400, 0x1e21e400, 0x0e60e400, 0x0ee0d800} { // FADDP, scalar compare, binary D1, zero D1.
+		if _, ok := decodeARM64RawFloatCompare(word); ok {
+			t.Fatalf("float-compare decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_float_conditional_compare.go b/arm64_lower_word_float_conditional_compare.go
new file mode 100644
index 000000000..d7515d2f1
--- /dev/null
+++ b/arm64_lower_word_float_conditional_compare.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "fmt"
+
+func decodeARM64RawConditionalCompare(word uint32) (arm64ConditionalCompareForm, bool) {
+	const variable = uint32(31<<5 | 31<<16 | 3<<22 | 15<<12 | 1<<4 | 15)
+	if word & ^variable != 0x1e200400 {
+		return arm64ConditionalCompareForm{}, false
+	}
+	bits := 0
+	switch word >> 22 & 3 {
+	case 0:
+		bits = 32
+	case 1:
+		bits = 64
+	case 3:
+		bits = 16
+	default:
+		return arm64ConditionalCompareForm{}, false
+	}
+	conditions := [...]string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "NV"}
+	return arm64ConditionalCompareForm{
+		arm64ScalarCompareForm: arm64ScalarCompareForm{
+			bits: bits, signaling: word&(1<<4) != 0,
+			left:  Reg(fmt.Sprintf("F%d", word>>5&31)),
+			right: Reg(fmt.Sprintf("F%d", word>>16&31)),
+		},
+		condition: conditions[word>>12&15],
+		nzcv:      uint8(word & 15),
+	}, true
+}
diff --git a/arm64_lower_word_float_gp_move.go b/arm64_lower_word_float_gp_move.go
new file mode 100644
index 000000000..b66709904
--- /dev/null
+++ b/arm64_lower_word_float_gp_move.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFloatGPMove struct {
+	bits     int
+	toFloat  bool
+	upper    bool
+	floatReg int
+	gpReg    int
+}
+
+var arm64RawFloatGPMoveSpecs = map[uint32]struct {
+	bits    int
+	toFloat bool
+	upper   bool
+}{
+	0x1ee70000: {bits: 16, toFloat: true},
+	0x1ee60000: {bits: 16},
+	0x1e270000: {bits: 32, toFloat: true},
+	0x1e260000: {bits: 32},
+	0x9e670000: {bits: 64, toFloat: true},
+	0x9e660000: {bits: 64},
+	0x9eaf0000: {bits: 64, toFloat: true, upper: true},
+	0x9eae0000: {bits: 64, upper: true},
+}
+
+func decodeARM64RawFloatGPMove(word uint32) (arm64RawFloatGPMove, bool) {
+	const registers = uint32(31<<5 | 31)
+	spec, ok := arm64RawFloatGPMoveSpecs[word&^registers]
+	if !ok {
+		return arm64RawFloatGPMove{}, false
+	}
+
+	source := int(word>>5) & 31
+	destination := int(word) & 31
+	floatReg, gpReg := destination, source
+	if !spec.toFloat {
+		floatReg, gpReg = source, destination
+	}
+	return arm64RawFloatGPMove{
+		bits:     spec.bits,
+		toFloat:  spec.toFloat,
+		upper:    spec.upper,
+		floatReg: floatReg,
+		gpReg:    gpReg,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFloatGPMove(form arm64RawFloatGPMove) error {
+	floatReg := Reg(fmt.Sprintf("F%d", form.floatReg))
+	gpReg := ZR
+	if form.gpReg != 31 {
+		gpReg = Reg(fmt.Sprintf("R%d", form.gpReg))
+	}
+
+	if form.upper {
+		return c.lowerRawFloatGPUpperMove(floatReg, gpReg, form.toFloat)
+	}
+	if form.toFloat {
+		value, err := c.loadReg(gpReg)
+		if err != nil {
+			return err
+		}
+		return c.storeReg(floatReg, c.normalizeScalarFloatBits(value, form.bits))
+	}
+	value, err := c.loadReg(floatReg)
+	if err != nil {
+		return err
+	}
+	return c.storeReg(gpReg, c.normalizeScalarFloatBits(value, form.bits))
+}
+
+func (c *arm64Ctx) lowerRawFloatGPUpperMove(floatReg, gpReg Reg, toFloat bool) error {
+	vector, err := c.loadVReg(floatReg)
+	if err != nil {
+		return err
+	}
+	lanes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", lanes, vector)
+	if !toFloat {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x i64> %%%s, i64 1\n", value, lanes)
+		return c.storeReg(gpReg, "%"+value)
+	}
+
+	value, err := c.loadReg(gpReg)
+	if err != nil {
+		return err
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <2 x i64> %%%s, i64 %s, i64 1\n", updated, lanes, value)
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %%%s to <16 x i8>\n", bytes, updated)
+	return c.storeVReg(floatReg, "%"+bytes)
+}
diff --git a/arm64_lower_word_float_gp_move_test.go b/arm64_lower_word_float_gp_move_test.go
new file mode 100644
index 000000000..21d6a1aab
--- /dev/null
+++ b/arm64_lower_word_float_gp_move_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawFloatGPMoveDecoderCompleteRegisterFamily(t *testing.T) {
+	formats := []struct {
+		base    uint32
+		bits    int
+		toFloat bool
+		upper   bool
+	}{
+		{base: 0x1ee70000, bits: 16, toFloat: true},
+		{base: 0x1ee60000, bits: 16, toFloat: false},
+		{base: 0x1e270000, bits: 32, toFloat: true},
+		{base: 0x1e260000, bits: 32, toFloat: false},
+		{base: 0x9e670000, bits: 64, toFloat: true},
+		{base: 0x9e660000, bits: 64, toFloat: false},
+		{base: 0x9eaf0000, bits: 64, toFloat: true, upper: true},
+		{base: 0x9eae0000, bits: 64, toFloat: false, upper: true},
+	}
+
+	count := 0
+	for _, format := range formats {
+		for source := 0; source < 32; source++ {
+			for destination := 0; destination < 32; destination++ {
+				word := format.base | uint32(source)<<5 | uint32(destination)
+				form, ok := decodeARM64RawFloatGPMove(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				wantFP, wantGP := destination, source
+				if !format.toFloat {
+					wantFP, wantGP = source, destination
+				}
+				if form.bits != format.bits || form.toFloat != format.toFloat ||
+					form.upper != format.upper || form.floatReg != wantFP || form.gpReg != wantGP {
+					t.Fatalf("decode %#08x = %+v", word, form)
+				}
+				count++
+			}
+		}
+	}
+	if count != 8192 {
+		t.Fatalf("covered %d floating/GP move encodings, want 8192", count)
+	}
+}
+
+func TestTranslateARM64RawFloatGPMoveCompleteRegisterFamily(t *testing.T) {
+	formats := []struct {
+		name string
+		base uint32
+	}{
+		{name: "FMOV H0, W30", base: 0x1ee70000},
+		{name: "FMOV W29, H1", base: 0x1ee60000},
+		{name: "FMOV S2, W30", base: 0x1e270000},
+		{name: "FMOV W29, S3", base: 0x1e260000},
+		{name: "FMOV D4, X30", base: 0x9e670000},
+		{name: "FMOV X29, D5", base: 0x9e660000},
+		{name: "FMOV V6.D[1], X30", base: 0x9eaf0000},
+		{name: "FMOV X29, V7.D[1]", base: 0x9eae0000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawFloatGPMoveFamily(SB),$0-0\n")
+	for index, format := range formats {
+		registers := uint32(30<<5 | index)
+		if index%2 == 1 {
+			registers = uint32(index<<5 | 29)
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", format.base|registers, format.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawFloatGPMoveFamily": {Name: "rawFloatGPMoveFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"trunc i64", "to i16", "to i32",
+				"extractelement <2 x i64>", "i64 1",
+				"insertelement <2 x i64>",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw floating/GP move IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-gp-move.ll", "arm64-raw-float-gp-move.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFloatGPMoveRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatgpmove(SB),$0-24
+	MOVD low+0(FP), R0
+	MOVD high+8(FP), R1
+	MOVD out+16(FP), R2
+	WORD $0x9e670000 // FMOV D0, X0
+	WORD $0x9eaf0020 // FMOV V0.D[1], X1
+	WORD $0x9e660004 // FMOV X4, D0
+	WORD $0x9eae0003 // FMOV X3, V0.D[1]
+	WORD $0x1ee70001 // FMOV H1, W0
+	WORD $0x1ee60025 // FMOV W5, H1
+	WORD $0x1e270002 // FMOV S2, W0
+	WORD $0x1e260046 // FMOV W6, S2
+	MOVD R4, 0(R2)
+	MOVD R3, 8(R2)
+	MOVD R5, 16(R2)
+	MOVD R6, 24(R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfloatgpmove": {
+			Name: "rawfloatgpmove", Args: []LLVMType{I64, I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatgpmove(uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  const uint64_t low = 0x8877665544332211ULL;
+  const uint64_t high = 0xffeeddccbbaa0099ULL;
+  uint64_t got[4] = {0};
+  rawfloatgpmove(low, high, got);
+  if (got[0] != low) return 1;
+  if (got[1] != high) return 2;
+  if (got[2] != (low & 0xffff)) return 3;
+  if (got[3] != (low & 0xffffffff)) return 4;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_gp_move", triple, ir, mainC, nil)
+}
+
+func TestARM64RawFloatGPMoveDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ee50000, // Adjacent unallocated opcode.
+		0x9ee70000, // Invalid X-to-half combination.
+		0x1e670000, // Invalid W-to-double combination.
+		0x1ee01000, // Scalar floating immediate.
+	} {
+		if _, ok := decodeARM64RawFloatGPMove(word); ok {
+			t.Fatalf("floating/GP move decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_float_immediate.go b/arm64_lower_word_float_immediate.go
new file mode 100644
index 000000000..17323e3b5
--- /dev/null
+++ b/arm64_lower_word_float_immediate.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+)
+
+type arm64RawFloatImmediate struct {
+	arrangement arm64VectorArrangement
+	laneValue   uint64
+	destination int
+}
+
+var arm64RawFloatImmediateArrangements = map[uint32]arm64VectorArrangement{
+	0x0f00fc00: {elementBits: 16, lanes: 4},
+	0x4f00fc00: {elementBits: 16, lanes: 8},
+	0x0f00f400: {elementBits: 32, lanes: 2},
+	0x4f00f400: {elementBits: 32, lanes: 4},
+	0x6f00f400: {elementBits: 64, lanes: 2},
+}
+
+func decodeARM64RawFloatImmediate(word uint32) (arm64RawFloatImmediate, bool) {
+	const variable = uint32(7<<16 | 31<<5 | 31)
+	arrangement, ok := arm64RawFloatImmediateArrangements[word&^variable]
+	if !ok {
+		return arm64RawFloatImmediate{}, false
+	}
+	immediate := byte(((word >> 16) & 7 << 5) | ((word >> 5) & 31))
+	value := arm64ExpandedFloatImmediate(immediate)
+	laneValue := math.Float64bits(value)
+	switch arrangement.elementBits {
+	case 16:
+		laneValue = uint64(arm64Float16Bits(value))
+	case 32:
+		laneValue = uint64(math.Float32bits(float32(value)))
+	}
+	return arm64RawFloatImmediate{
+		arrangement: arrangement,
+		laneValue:   laneValue,
+		destination: int(word) & 31,
+	}, true
+}
+
+func arm64ExpandedFloatImmediate(immediate byte) float64 {
+	sign := 1.0
+	if immediate&0x80 != 0 {
+		sign = -1
+	}
+	exponent := (1-int(immediate>>6&1))*4 + int(immediate>>4&3) - 3
+	significand := float64(16+int(immediate&15)) / 16
+	return sign * math.Ldexp(significand, exponent)
+}
+
+func (c *arm64Ctx) lowerRawFloatImmediate(form arm64RawFloatImmediate) error {
+	return c.lowerARM64VectorFloatImmediateBits(
+		form.arrangement,
+		form.laneValue,
+		Reg(fmt.Sprintf("V%d", form.destination)),
+	)
+}
diff --git a/arm64_lower_word_float_immediate_test.go b/arm64_lower_word_float_immediate_test.go
new file mode 100644
index 000000000..338ff79c1
--- /dev/null
+++ b/arm64_lower_word_float_immediate_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawFloatImmediateCompleteArchitecturalFormats(t *testing.T) {
+	const source = `
+TEXT rawFloatImmediateFormats(SB),$0-0
+	WORD $0x0f03fe00 // FMOV V0.4H, #1.0
+	WORD $0x4f03fe01 // FMOV V1.8H, #1.0
+	WORD $0x0f03f602 // FMOV V2.2S, #1.0
+	WORD $0x4f03f603 // FMOV V3.4S, #1.0
+	WORD $0x6f03f604 // FMOV V4.2D, #1.0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawFloatImmediateFormats": {Name: "rawFloatImmediateFormats", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"<8 x i16>", "<4 x i32>", "<2 x i64>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw float immediate IR omitted %q:\n%s", want, ir)
+				}
+			}
+			if !strings.Contains(ir, `"target-features"="+fullfp16"`) {
+				t.Fatalf("raw half float immediate omitted +fullfp16:\n%s", ir)
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-immediate.ll", "arm64-raw-float-immediate.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFloatImmediateDecoderCoversEveryImmediate(t *testing.T) {
+	forms := []struct {
+		base        uint32
+		arrangement arm64VectorArrangement
+	}{
+		{0x0f00fc00, arm64VectorArrangement{elementBits: 16, lanes: 4}},
+		{0x4f00fc00, arm64VectorArrangement{elementBits: 16, lanes: 8}},
+		{0x0f00f400, arm64VectorArrangement{elementBits: 32, lanes: 2}},
+		{0x4f00f400, arm64VectorArrangement{elementBits: 32, lanes: 4}},
+		{0x6f00f400, arm64VectorArrangement{elementBits: 64, lanes: 2}},
+	}
+	for _, form := range forms {
+		for immediate := 0; immediate < 256; immediate++ {
+			word := form.base |
+				uint32(immediate>>5)<<16 |
+				uint32(immediate&31)<<5 |
+				31
+			decoded, ok := decodeARM64RawFloatImmediate(word)
+			if !ok || decoded.arrangement != form.arrangement || decoded.destination != 31 {
+				t.Fatalf("decode %#08x = %#v, %v", word, decoded, ok)
+			}
+			value := arm64ExpandedFloatImmediate(byte(immediate))
+			want := math.Float64bits(value)
+			switch form.arrangement.elementBits {
+			case 16:
+				want = uint64(arm64Float16Bits(value))
+			case 32:
+				want = uint64(math.Float32bits(float32(value)))
+			}
+			if decoded.laneValue != want {
+				t.Fatalf("decode %#08x lane value = %#x, want %#x", word, decoded.laneValue, want)
+			}
+		}
+	}
+}
+
+func TestARM64RawFloatImmediateDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2f03f600, // Reserved D1 encoding.
+		0x0f03e400, // MOVI neighbor.
+		0x0f03f000, // Different modified-immediate cmode.
+	} {
+		if form, ok := decodeARM64RawFloatImmediate(word); ok {
+			t.Fatalf("decoder accepted adjacent/reserved encoding %#08x as %#v", word, form)
+		}
+	}
+}
diff --git a/arm64_lower_word_float_minmax_across.go b/arm64_lower_word_float_minmax_across.go
new file mode 100644
index 000000000..593185ba4
--- /dev/null
+++ b/arm64_lower_word_float_minmax_across.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFloatMinMaxAcross struct {
+	operation   string
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+var arm64RawFloatMinMaxAcrossSpecs = map[uint32]struct {
+	operation   string
+	arrangement arm64VectorArrangement
+}{
+	0x0e30c800: {"maxnum", arm64VectorArrangement{16, 4}},
+	0x4e30c800: {"maxnum", arm64VectorArrangement{16, 8}},
+	0x6e30c800: {"maxnum", arm64VectorArrangement{32, 4}},
+	0x0eb0c800: {"minnum", arm64VectorArrangement{16, 4}},
+	0x4eb0c800: {"minnum", arm64VectorArrangement{16, 8}},
+	0x6eb0c800: {"minnum", arm64VectorArrangement{32, 4}},
+	0x0e30f800: {"maximum", arm64VectorArrangement{16, 4}},
+	0x4e30f800: {"maximum", arm64VectorArrangement{16, 8}},
+	0x6e30f800: {"maximum", arm64VectorArrangement{32, 4}},
+	0x0eb0f800: {"minimum", arm64VectorArrangement{16, 4}},
+	0x4eb0f800: {"minimum", arm64VectorArrangement{16, 8}},
+	0x6eb0f800: {"minimum", arm64VectorArrangement{32, 4}},
+}
+
+func decodeARM64RawFloatMinMaxAcross(word uint32) (arm64RawFloatMinMaxAcross, bool) {
+	const registers = uint32(31 | 31<<5)
+	spec, ok := arm64RawFloatMinMaxAcrossSpecs[word&^registers]
+	if !ok {
+		return arm64RawFloatMinMaxAcross{}, false
+	}
+	return arm64RawFloatMinMaxAcross{
+		operation:   spec.operation,
+		arrangement: spec.arrangement,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFloatMinMaxAcross(form arm64RawFloatMinMaxAcross) error {
+	return c.lowerARM64FloatMinMaxAcrossValues(
+		form.operation,
+		form.arrangement,
+		Reg(fmt.Sprintf("V%d", form.source)),
+		Reg(fmt.Sprintf("F%d", form.destination)),
+	)
+}
diff --git a/arm64_lower_word_float_multiply_element.go b/arm64_lower_word_float_multiply_element.go
new file mode 100644
index 000000000..c7cb6101c
--- /dev/null
+++ b/arm64_lower_word_float_multiply_element.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFMULByElement struct {
+	vector      bool
+	extended    bool
+	arrangement arm64VectorArrangement
+	lane        int
+	elementReg  int
+	sourceReg   int
+	destination int
+}
+
+func decodeARM64RawFMULByElement(word uint32) (arm64RawFMULByElement, bool) {
+	scalarHalf := word&0xdfc0f400 == 0x5f009000
+	vectorHalf := word&0x9fc0f400 == 0x0f009000
+	scalar := scalarHalf || word&0xdf80f400 == 0x5f809000
+	vector := vectorHalf || word&0x9f80f400 == 0x0f809000
+	if !scalar && !vector {
+		return arm64RawFMULByElement{}, false
+	}
+
+	elementBits := 16
+	if !scalarHalf && !vectorHalf {
+		elementBits = 32
+	}
+	if elementBits == 32 && word&(1<<22) != 0 {
+		elementBits = 64
+	}
+	// The L bit is part of the lane index for S elements, but is reserved for
+	// D elements. The vector encoding also reserves its 64-bit D1 combination.
+	if elementBits == 64 && word&(1<<21) != 0 {
+		return arm64RawFMULByElement{}, false
+	}
+	vectorBits := elementBits
+	if vector {
+		vectorBits = 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if elementBits == 64 && vectorBits == 64 {
+			return arm64RawFMULByElement{}, false
+		}
+	}
+	lane := int(word>>11) & 1
+	if elementBits == 16 {
+		lane = lane<<2 | (int(word>>21)&1)<<1 | int(word>>20)&1
+	} else if elementBits == 32 {
+		lane = lane<<1 | int(word>>21)&1
+	}
+	elementReg := int(word>>16) & 31
+	if elementBits == 16 {
+		elementReg &= 15
+	}
+	return arm64RawFMULByElement{
+		vector:      vector,
+		extended:    word&(1<<29) != 0,
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+		lane:        lane,
+		elementReg:  elementReg,
+		sourceReg:   int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFMULByElement(form arm64RawFMULByElement) error {
+	bits := form.arrangement.elementBits
+	floatType := "float"
+	if bits == 16 {
+		floatType = "half"
+	} else if bits == 64 {
+		floatType = "double"
+	}
+	elementBytes, err := c.loadVReg(Reg(fmt.Sprintf("V%d", form.elementReg)))
+	if err != nil {
+		return err
+	}
+	physicalLanes := 128 / bits
+	typedElements := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", typedElements, elementBytes, physicalLanes, floatType)
+	element := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %%%s, i32 %d\n", element, physicalLanes, floatType, typedElements, form.lane)
+
+	if !form.vector {
+		sourceReg := Reg(fmt.Sprintf("F%d", form.sourceReg))
+		destinationReg := Reg(fmt.Sprintf("F%d", form.destination))
+		source, err := c.loadARM64ScalarFloatReg(sourceReg, bits)
+		if err != nil {
+			return err
+		}
+		result := c.newTmp()
+		if form.extended {
+			suffix := fmt.Sprintf("f%d", bits)
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.fmulx.%s(%s %s, %s %%%s)\n",
+				result, floatType, suffix, floatType, source, floatType, element)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = fmul %s %s, %%%s\n", result, floatType, source, element)
+		}
+		return c.storeARM64ScalarFloatReg(destinationReg, bits, "%"+result)
+	}
+
+	arrangementName := arm64VectorArrangementName(form.arrangement)
+	sourceReg := Reg(fmt.Sprintf("V%d.%s", form.sourceReg, arrangementName))
+	destinationReg := Reg(fmt.Sprintf("V%d.%s", form.destination, arrangementName))
+	source, err := c.loadARM64VectorFloat(sourceReg, form.arrangement)
+	if err != nil {
+		return err
+	}
+	seed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> poison, %s %%%s, i32 0\n", seed, form.arrangement.lanes, floatType, floatType, element)
+	splat := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> zeroinitializer\n",
+		splat, form.arrangement.lanes, floatType, seed, form.arrangement.lanes, floatType, form.arrangement.lanes)
+	result := c.newTmp()
+	if form.extended {
+		fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.aarch64.neon.fmulx.v%df%d(<%d x %s> %s, <%d x %s> %%%s)\n",
+			result, form.arrangement.lanes, floatType, form.arrangement.lanes, bits,
+			form.arrangement.lanes, floatType, source, form.arrangement.lanes, floatType, splat)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = fmul <%d x %s> %s, %%%s\n", result, form.arrangement.lanes, floatType, source, splat)
+	}
+	return c.storeARM64VectorFloat(destinationReg, form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_float_multiply_element_test.go b/arm64_lower_word_float_multiply_element_test.go
new file mode 100644
index 000000000..9573a8b5d
--- /dev/null
+++ b/arm64_lower_word_float_multiply_element_test.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64EncodeRawFMULByElement(vector bool, bits, vectorBits, lane, rm, rn, rd int) uint32 {
+	base := uint32(0x5f009000)
+	if vector {
+		base = 0x0f009000
+		if vectorBits == 128 {
+			base |= 1 << 30
+		}
+	}
+	if bits >= 32 {
+		base |= 1 << 23
+	}
+	if bits == 16 {
+		base |= uint32(lane&1) << 20
+		base |= uint32((lane>>1)&1) << 21
+		base |= uint32((lane>>2)&1) << 11
+		rm &= 15
+	} else if bits == 64 {
+		base |= 1 << 22
+		base |= uint32(lane&1) << 11
+	} else {
+		base |= uint32(lane&1) << 21
+		base |= uint32((lane>>1)&1) << 11
+	}
+	return base | uint32(rm)<<16 | uint32(rn)<<5 | uint32(rd)
+}
+
+func TestTranslateARM64RawFMULByElementCompleteArchitecturalFormats(t *testing.T) {
+	type format struct {
+		vector     bool
+		bits       int
+		vectorBits int
+		lanes      int
+	}
+	formats := []format{
+		{vector: false, bits: 16, vectorBits: 16, lanes: 8},
+		{vector: false, bits: 32, vectorBits: 32, lanes: 4},
+		{vector: false, bits: 64, vectorBits: 64, lanes: 2},
+		{vector: true, bits: 16, vectorBits: 64, lanes: 8},
+		{vector: true, bits: 16, vectorBits: 128, lanes: 8},
+		{vector: true, bits: 32, vectorBits: 64, lanes: 4},
+		{vector: true, bits: 32, vectorBits: 128, lanes: 4},
+		{vector: true, bits: 64, vectorBits: 128, lanes: 2},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfmulbyelementforms(SB),$0-0\n")
+	for _, form := range formats {
+		for lane := 0; lane < form.lanes; lane++ {
+			lastElementRegister := 31
+			if form.bits == 16 {
+				lastElementRegister = 15
+			}
+			for _, rm := range []int{0, lastElementRegister} {
+				for _, extended := range []bool{false, true} {
+					word := arm64EncodeRawFMULByElement(form.vector, form.bits, form.vectorBits, lane, rm, 30, 29)
+					if extended {
+						word |= 1 << 29
+					}
+					decoded, ok := decodeARM64RawFMULByElement(word)
+					if !ok || decoded.vector != form.vector || decoded.extended != extended ||
+						decoded.arrangement.elementBits != form.bits || decoded.arrangement.lanes != form.vectorBits/form.bits ||
+						decoded.lane != lane || decoded.elementReg != rm || decoded.sourceReg != 30 || decoded.destination != 29 {
+						t.Fatalf("decode FMUL/FMULX element %#08x = %#v, %v", word, decoded, ok)
+					}
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfmulbyelementforms": {Name: "rawfmulbyelementforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got, want := strings.Count(ir, "fmul "), 80; got != want {
+				t.Fatalf("raw FMUL-by-element emitted %d multiplies, want %d:\n%s", got, want, ir)
+			}
+			gotFMULXCalls := 0
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.aarch64.neon.fmulx.") {
+					gotFMULXCalls++
+				}
+			}
+			if got, want := gotFMULXCalls, 80; got != want {
+				t.Fatalf("raw FMULX-by-element emitted %d intrinsic calls, want %d:\n%s", got, want, ir)
+			}
+			if !strings.Contains(ir, "+fullfp16") {
+				t.Fatalf("raw half-precision FMUL-by-element for %s omitted +fullfp16:\n%s", triple, ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fmul-by-element.ll", "arm64-raw-fmul-by-element.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFMULByElementDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0fc09000, // reserved vector D1
+		0x4fe09000, // reserved D2 with L=1
+		0x0f801000, // FMLA by element
+	} {
+		if _, ok := decodeARM64RawFMULByElement(word); ok {
+			t.Fatalf("FMUL-by-element decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawFMULByElementRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfmulbyelement(SB),$0-24
+	MOVD input+0(FP), R0
+	MOVD factors+8(FP), R1
+	MOVD output+16(FP), R2
+	VLD1 (R0), [V1.S4]
+	VLD1 (R1), [V0.S4]
+	WORD $0x4f809021 // FMUL V1.4S, V1.4S, V0.S[0]
+	VST1 [V1.S4], (R2)
+	RET
+
+TEXT rawfmulbyelementhalf(SB),$0-24
+	MOVD input+0(FP), R0
+	MOVD factors+8(FP), R1
+	MOVD output+16(FP), R2
+	VLD1 (R0), [V1.H8]
+	VLD1 (R1), [V0.H8]
+	WORD $0x4f309821 // FMUL V1.8H, V1.8H, V0.H[7]
+	VST1 [V1.H8], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawfmulbyelement": {
+				Name: "rawfmulbyelement", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+			"rawfmulbyelementhalf": {
+				Name: "rawfmulbyelementhalf", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+extern void rawfmulbyelement(const float *, const float *, float *);
+extern void rawfmulbyelementhalf(const _Float16 *, const _Float16 *, _Float16 *);
+int main(void) {
+  const float input[4] = {1.5f, -2.0f, 3.25f, -4.5f};
+  const float factors[4] = {2.0f, 7.0f, 11.0f, 13.0f};
+  float got[4] = {0};
+  rawfmulbyelement(input, factors, got);
+  for (int i = 0; i < 4; i++) if (got[i] != input[i] * factors[0]) return i + 1;
+  const _Float16 input_h[8] = {1,2,3,4,5,6,7,8};
+  const _Float16 factors_h[8] = {2,3,4,5,6,7,8,9};
+  _Float16 got_h[8] = {0};
+  rawfmulbyelementhalf(input_h, factors_h, got_h);
+  for (int i = 0; i < 8; i++) if (got_h[i] != input_h[i] * factors_h[7]) return i + 5;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fmul_by_element", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_float_multiply_long.go b/arm64_lower_word_float_multiply_long.go
new file mode 100644
index 000000000..3d3c2c58c
--- /dev/null
+++ b/arm64_lower_word_float_multiply_long.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import "fmt"
+
+// arm64RawFloatMultiplyLong describes the complete Advanced SIMD FP16FML
+// FMLAL/FMLAL2/FMLSL/FMLSL2 family. The inputs are half-precision values and
+// the accumulator/result is single precision.
+type arm64RawFloatMultiplyLong struct {
+	subtract    bool
+	highHalf    bool
+	byElement   bool
+	lanes       int
+	lane        int
+	second      int
+	first       int
+	destination int
+}
+
+func decodeARM64RawFloatMultiplyLong(word uint32) (arm64RawFloatMultiplyLong, bool) {
+	form := arm64RawFloatMultiplyLong{
+		lanes:       2,
+		lane:        -1,
+		second:      int(word>>16) & 31,
+		first:       int(word>>5) & 31,
+		destination: int(word) & 31,
+	}
+	if word&(1<<30) != 0 {
+		form.lanes = 4
+	}
+
+	// Vector encodings vary Q and the three five-bit register fields.
+	switch word & 0xbfe0fc00 {
+	case 0x0e20ec00: // FMLAL.
+		return form, true
+	case 0x2e20cc00: // FMLAL2.
+		form.highHalf = true
+		return form, true
+	case 0x0ea0ec00: // FMLSL.
+		form.subtract = true
+		return form, true
+	case 0x2ea0cc00: // FMLSL2.
+		form.subtract, form.highHalf = true, true
+		return form, true
+	}
+
+	// By-element encodings limit Rm to V0..V15 and encode lane H:L:M in
+	// bits 11, 21, and 20. Q selects a two- or four-lane result.
+	form.byElement = true
+	form.second &= 15
+	form.lane = int(word>>11)&1<<2 | int(word>>21)&1<<1 | int(word>>20)&1
+	switch word & 0xbfc0f400 {
+	case 0x0f800000: // FMLAL by element.
+		return form, true
+	case 0x2f808000: // FMLAL2 by element.
+		form.highHalf = true
+		return form, true
+	case 0x0f804000: // FMLSL by element.
+		form.subtract = true
+		return form, true
+	case 0x2f80c000: // FMLSL2 by element.
+		form.subtract, form.highHalf = true, true
+		return form, true
+	default:
+		return arm64RawFloatMultiplyLong{}, false
+	}
+}
+
+func (c *arm64Ctx) lowerRawFloatMultiplyLong(form arm64RawFloatMultiplyLong) error {
+	halfArrangement := arm64VectorArrangement{elementBits: 16, lanes: 8}
+	floatArrangement := arm64VectorArrangement{elementBits: 32, lanes: form.lanes}
+	first, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.first)), halfArrangement)
+	if err != nil {
+		return err
+	}
+
+	selectHalf := func(value string) string {
+		selected := c.newTmp()
+		offset := 0
+		if form.highHalf {
+			offset = form.lanes
+		}
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <8 x half> %s, <8 x half> poison, <%d x i32> <", selected, value, form.lanes)
+		for lane := 0; lane < form.lanes; lane++ {
+			if lane != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", offset+lane)
+		}
+		c.b.WriteString(">\n")
+		return "%" + selected
+	}
+	first = selectHalf(first)
+
+	var second string
+	if form.byElement {
+		all, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.second)), halfArrangement)
+		if err != nil {
+			return err
+		}
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <8 x half> %s, i32 %d\n", element, all, form.lane)
+		seed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x half> poison, half %%%s, i32 0\n", seed, form.lanes, element)
+		splat := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x half> %%%s, <%d x half> poison, <%d x i32> zeroinitializer\n",
+			splat, form.lanes, seed, form.lanes, form.lanes)
+		second = "%" + splat
+	} else {
+		all, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.second)), halfArrangement)
+		if err != nil {
+			return err
+		}
+		second = selectHalf(all)
+	}
+
+	vectorHalfType := fmt.Sprintf("<%d x half>", form.lanes)
+	vectorFloatType := fmt.Sprintf("<%d x float>", form.lanes)
+	wideFirst := c.newTmp()
+	wideSecond := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = fpext %s %s to %s\n", wideFirst, vectorHalfType, first, vectorFloatType)
+	fmt.Fprintf(c.b, "  %%%s = fpext %s %s to %s\n", wideSecond, vectorHalfType, second, vectorFloatType)
+	firstOperand := "%" + wideFirst
+	if form.subtract {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negated, vectorFloatType, firstOperand)
+		firstOperand = "%" + negated
+	}
+	accumulator, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), floatArrangement)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fma.v%df32(%s %s, %s %%%s, %s %s)\n",
+		result, vectorFloatType, form.lanes,
+		vectorFloatType, firstOperand, vectorFloatType, wideSecond, vectorFloatType, accumulator)
+	return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), floatArrangement, "%"+result)
+}
diff --git a/arm64_lower_word_float_multiply_long_test.go b/arm64_lower_word_float_multiply_long_test.go
new file mode 100644
index 000000000..926c5238e
--- /dev/null
+++ b/arm64_lower_word_float_multiply_long_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawFloatMultiplyLongTestOperation struct {
+	name        string
+	vectorBase  uint32
+	elementBase uint32
+	subtract    bool
+	highHalf    bool
+}
+
+var arm64RawFloatMultiplyLongTestOperations = []arm64RawFloatMultiplyLongTestOperation{
+	{name: "FMLAL", vectorBase: 0x0e20ec00, elementBase: 0x0f800000},
+	{name: "FMLAL2", vectorBase: 0x2e20cc00, elementBase: 0x2f808000, highHalf: true},
+	{name: "FMLSL", vectorBase: 0x0ea0ec00, elementBase: 0x0f804000, subtract: true},
+	{name: "FMLSL2", vectorBase: 0x2ea0cc00, elementBase: 0x2f80c000, subtract: true, highHalf: true},
+}
+
+func encodeARM64RawFloatMultiplyLongVector(base uint32, lanes, second, first, destination int) uint32 {
+	word := base | uint32(second)<<16 | uint32(first)<<5 | uint32(destination)
+	if lanes == 4 {
+		word |= 1 << 30
+	}
+	return word
+}
+
+func encodeARM64RawFloatMultiplyLongElement(base uint32, lanes, lane, element, first, destination int) uint32 {
+	word := base | uint32(element&15)<<16 | uint32(first)<<5 | uint32(destination)
+	if lanes == 4 {
+		word |= 1 << 30
+	}
+	word |= uint32(lane&1) << 20
+	word |= uint32((lane>>1)&1) << 21
+	word |= uint32((lane>>2)&1) << 11
+	return word
+}
+
+func TestTranslateARM64RawFloatMultiplyLongCompleteArchitecturalFamily(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatmultiplylongforms(SB),$0-0\n")
+	for _, operation := range arm64RawFloatMultiplyLongTestOperations {
+		for _, lanes := range []int{2, 4} {
+			word := encodeARM64RawFloatMultiplyLongVector(operation.vectorBase, lanes, 31, 30, 29)
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s vector %dS\n", word, operation.name, lanes)
+			for lane := 0; lane < 8; lane++ {
+				word = encodeARM64RawFloatMultiplyLongElement(operation.elementBase, lanes, lane, 15, 28, 27)
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s element %dS lane %d\n", word, operation.name, lanes, lane)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfloatmultiplylongforms": {Name: "rawfloatmultiplylongforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"fpext <2 x half>", "fpext <4 x half>", "@llvm.fma.v2f32", "@llvm.fma.v4f32", "extractelement <8 x half>", "shufflevector", "+fp16fml"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw floating multiply-long family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-float-multiply-long.ll", "arm64-raw-float-multiply-long.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFloatMultiplyLongDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, operation := range arm64RawFloatMultiplyLongTestOperations {
+		for _, lanes := range []int{2, 4} {
+			for destination := 0; destination < 32; destination++ {
+				word := encodeARM64RawFloatMultiplyLongVector(operation.vectorBase, lanes, 31-destination, destination, destination)
+				got, ok := decodeARM64RawFloatMultiplyLong(word)
+				if !ok || got.byElement || got.lanes != lanes || got.first != destination || got.second != 31-destination || got.destination != destination || got.subtract != operation.subtract || got.highHalf != operation.highHalf {
+					t.Fatalf("decode %s vector %#08x = %#v, %v", operation.name, word, got, ok)
+				}
+			}
+			for lane := 0; lane < 8; lane++ {
+				for element := 0; element < 16; element++ {
+					word := encodeARM64RawFloatMultiplyLongElement(operation.elementBase, lanes, lane, element, 31-element, element)
+					got, ok := decodeARM64RawFloatMultiplyLong(word)
+					if !ok || !got.byElement || got.lanes != lanes || got.lane != lane || got.first != 31-element || got.second != element || got.destination != element || got.subtract != operation.subtract || got.highHalf != operation.highHalf {
+						t.Fatalf("decode %s element %#08x = %#v, %v", operation.name, word, got, ok)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawFloatMultiplyLongDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0e20e800, 0x0e20f000, 0x2e20ec00,
+		0x0f800400, 0x0f801000, 0x2f800000,
+	} {
+		if _, ok := decodeARM64RawFloatMultiplyLong(word); ok {
+			t.Fatalf("floating multiply-long decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawFloatMultiplyLongRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	words := []uint32{
+		encodeARM64RawFloatMultiplyLongVector(0x0e20ec00, 4, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongVector(0x2e20cc00, 4, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongVector(0x0ea0ec00, 4, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongVector(0x2ea0cc00, 4, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongElement(0x0f800000, 4, 7, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongElement(0x2f808000, 4, 3, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongElement(0x0f804000, 4, 1, 2, 1, 0),
+		encodeARM64RawFloatMultiplyLongElement(0x2f80c000, 4, 6, 2, 1, 0),
+	}
+	var source strings.Builder
+	source.WriteString(`TEXT rawfloatmultiplylong(SB),$0-32
+	MOVD source+0(FP), R0
+	MOVD elements+8(FP), R1
+	MOVD accumulator+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V1.H8]
+	VLD1 (R1), [V2.H8]
+`)
+	for _, word := range words {
+		source.WriteString("\tVLD1 (R2), [V0.S4]\n")
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		source.WriteString("\tVST1 [V0.S4], (R3)\n\tADD $16, R3\n")
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawfloatmultiplylong": {
+			Name: "rawfloatmultiplylong", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawfloatmultiplylong(const _Float16 *, const _Float16 *, const float *, float *);
+int main(void) {
+  const _Float16 source[8] = {1,2,3,4,5,6,7,8};
+  const _Float16 elements[8] = {10,20,30,40,50,60,70,80};
+  const float accumulator[4] = {1000,2000,3000,4000};
+  float got[32] = {0};
+  float want[32] = {0};
+  rawfloatmultiplylong(source, elements, accumulator, got);
+  for (int i = 0; i < 4; i++) {
+    want[0*4+i] = accumulator[i] + (float)source[i] * (float)elements[i];
+    want[1*4+i] = accumulator[i] + (float)source[i+4] * (float)elements[i+4];
+    want[2*4+i] = accumulator[i] - (float)source[i] * (float)elements[i];
+    want[3*4+i] = accumulator[i] - (float)source[i+4] * (float)elements[i+4];
+    want[4*4+i] = accumulator[i] + (float)source[i] * (float)elements[7];
+    want[5*4+i] = accumulator[i] + (float)source[i+4] * (float)elements[3];
+    want[6*4+i] = accumulator[i] - (float)source[i] * (float)elements[1];
+    want[7*4+i] = accumulator[i] - (float)source[i+4] * (float)elements[6];
+  }
+  for (int i = 0; i < 32; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_multiply_long", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_float_pairwise_minmax.go b/arm64_lower_word_float_pairwise_minmax.go
new file mode 100644
index 000000000..267bfd607
--- /dev/null
+++ b/arm64_lower_word_float_pairwise_minmax.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RawFloatPairwiseMinMax struct {
+	operation   string
+	scalar      bool
+	arrangement arm64VectorArrangement
+	first       int
+	second      int
+	destination int
+}
+
+func arm64LLVMShuffleMask(indices []int) string {
+	values := make([]string, len(indices))
+	for i, index := range indices {
+		values[i] = fmt.Sprintf("i32 %d", index)
+	}
+	return fmt.Sprintf("<%d x i32> <%s>", len(indices), strings.Join(values, ", "))
+}
+
+func decodeARM64RawFloatPairwiseMinMax(word uint32) (arm64RawFloatPairwiseMinMax, bool) {
+	const vectorRegisters = uint32(31 | 31<<5 | 31<<16)
+	vectorForms := map[uint32]struct {
+		operation string
+		bits      int
+		lanes     int
+	}{
+		0x2e403400: {"maximum", 16, 4}, 0x6e403400: {"maximum", 16, 8},
+		0x2e20f400: {"maximum", 32, 2}, 0x6e20f400: {"maximum", 32, 4}, 0x6e60f400: {"maximum", 64, 2},
+		0x2ec03400: {"minimum", 16, 4}, 0x6ec03400: {"minimum", 16, 8},
+		0x2ea0f400: {"minimum", 32, 2}, 0x6ea0f400: {"minimum", 32, 4}, 0x6ee0f400: {"minimum", 64, 2},
+		0x2e400400: {"maxnum", 16, 4}, 0x6e400400: {"maxnum", 16, 8},
+		0x2e20c400: {"maxnum", 32, 2}, 0x6e20c400: {"maxnum", 32, 4}, 0x6e60c400: {"maxnum", 64, 2},
+		0x2ec00400: {"minnum", 16, 4}, 0x6ec00400: {"minnum", 16, 8},
+		0x2ea0c400: {"minnum", 32, 2}, 0x6ea0c400: {"minnum", 32, 4}, 0x6ee0c400: {"minnum", 64, 2},
+	}
+	if form, ok := vectorForms[word&^vectorRegisters]; ok {
+		return arm64RawFloatPairwiseMinMax{
+			operation: form.operation,
+			arrangement: arm64VectorArrangement{
+				elementBits: form.bits,
+				lanes:       form.lanes,
+			},
+			first:       int(word>>5) & 31,
+			second:      int(word>>16) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+
+	const scalarRegisters = uint32(31 | 31<<5)
+	scalarForms := map[uint32]struct {
+		operation string
+		bits      int
+	}{
+		0x5e30f800: {"maximum", 16}, 0x7e30f800: {"maximum", 32}, 0x7e70f800: {"maximum", 64},
+		0x5eb0f800: {"minimum", 16}, 0x7eb0f800: {"minimum", 32}, 0x7ef0f800: {"minimum", 64},
+		0x5e30c800: {"maxnum", 16}, 0x7e30c800: {"maxnum", 32}, 0x7e70c800: {"maxnum", 64},
+		0x5eb0c800: {"minnum", 16}, 0x7eb0c800: {"minnum", 32}, 0x7ef0c800: {"minnum", 64},
+	}
+	if form, ok := scalarForms[word&^scalarRegisters]; ok {
+		return arm64RawFloatPairwiseMinMax{
+			operation:   form.operation,
+			scalar:      true,
+			arrangement: arm64VectorArrangement{elementBits: form.bits, lanes: 2},
+			first:       int(word>>5) & 31,
+			second:      -1,
+			destination: int(word) & 31,
+		}, true
+	}
+	return arm64RawFloatPairwiseMinMax{}, false
+}
+
+func (c *arm64Ctx) lowerRawFloatPairwiseMinMax(form arm64RawFloatPairwiseMinMax) error {
+	first, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.first)), form.arrangement)
+	if err != nil {
+		return err
+	}
+	floatType := arm64RawFloatType(form.arrangement.elementBits)
+	intrinsicSuffix := fmt.Sprintf("f%d", form.arrangement.elementBits)
+	if form.scalar {
+		left := c.newTmp()
+		right := c.newTmp()
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x %s> %s, i32 0\n", left, floatType, first)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <2 x %s> %s, i32 1\n", right, floatType, first)
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.%s(%s %%%s, %s %%%s)\n",
+			result, floatType, form.operation, intrinsicSuffix, floatType, left, floatType, right)
+		return c.storeARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), form.arrangement.elementBits, "%"+result)
+	}
+
+	second, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.second)), form.arrangement)
+	if err != nil {
+		return err
+	}
+	lanes := form.arrangement.lanes
+	leftMask := make([]int, 0, lanes)
+	rightMask := make([]int, 0, lanes)
+	for source := 0; source < 2; source++ {
+		base := source * lanes
+		for lane := 0; lane < lanes/2; lane++ {
+			leftMask = append(leftMask, base+lane*2)
+			rightMask = append(rightMask, base+lane*2+1)
+		}
+	}
+	left := c.newTmp()
+	right := c.newTmp()
+	vectorType := fmt.Sprintf("<%d x %s>", lanes, floatType)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s %s, %s\n", left, vectorType, first, vectorType, second, arm64LLVMShuffleMask(leftMask))
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s %s, %s\n", right, vectorType, first, vectorType, second, arm64LLVMShuffleMask(rightMask))
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.v%d%s(%s %%%s, %s %%%s)\n",
+		result, vectorType, form.operation, lanes, intrinsicSuffix, vectorType, left, vectorType, right)
+	return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_float_pairwise_minmax_test.go b/arm64_lower_word_float_pairwise_minmax_test.go
new file mode 100644
index 000000000..1e032fe76
--- /dev/null
+++ b/arm64_lower_word_float_pairwise_minmax_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawFloatPairwiseMinMaxCompleteArchitecturalFormats(t *testing.T) {
+	ops := []struct {
+		name        string
+		vectorBases []uint32
+		scalarBases []uint32
+		intrinsic   string
+	}{
+		{"fmaxp", []uint32{0x2e403400, 0x6e403400, 0x2e20f400, 0x6e20f400, 0x6e60f400}, []uint32{0x5e30f800, 0x7e30f800, 0x7e70f800}, "maximum"},
+		{"fminp", []uint32{0x2ec03400, 0x6ec03400, 0x2ea0f400, 0x6ea0f400, 0x6ee0f400}, []uint32{0x5eb0f800, 0x7eb0f800, 0x7ef0f800}, "minimum"},
+		{"fmaxnmp", []uint32{0x2e400400, 0x6e400400, 0x2e20c400, 0x6e20c400, 0x6e60c400}, []uint32{0x5e30c800, 0x7e30c800, 0x7e70c800}, "maxnum"},
+		{"fminnmp", []uint32{0x2ec00400, 0x6ec00400, 0x2ea0c400, 0x6ea0c400, 0x6ee0c400}, []uint32{0x5eb0c800, 0x7eb0c800, 0x7ef0c800}, "minnum"},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatpairwiseminmaxforms(SB),$0-0\n")
+	for _, op := range ops {
+		for _, base := range op.vectorBases {
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s vector\n", base|29<<16|30<<5|28, op.name)
+		}
+		for _, base := range op.scalarBases {
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s scalar\n", base|30<<5|29, op.name)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfloatpairwiseminmaxforms": {Name: "rawfloatpairwiseminmaxforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range ops {
+				for _, suffix := range []string{"f16", "f32", "f64", "v4f16", "v8f16", "v2f32", "v4f32", "v2f64"} {
+					want := "@llvm." + op.intrinsic + "." + suffix
+					if !strings.Contains(ir, want) {
+						t.Fatalf("raw %s for %s omitted %s:\n%s", op.name, triple, want, ir)
+					}
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "raw-float-pairwise-minmax.ll", "raw-float-pairwise-minmax.o", ir)
+		})
+	}
+}
+
+func TestARM64RawFloatPairwiseMinMaxDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e60f400, // reserved D1 vector arrangement
+		0x2e20d400, // FADDP
+		0x7e30d800, // scalar FADDP
+		0x2e403800, // adjacent FP16 opcode bits
+		0x5e70f800, // reserved scalar FP16 size combination
+	} {
+		if _, ok := decodeARM64RawFloatPairwiseMinMax(word); ok {
+			t.Fatalf("pairwise min/max decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawFloatPairwiseMinMaxRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfloatpairwiseminmax(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x6e20f401 // FMAXP V1.4S, V0.4S, V0.4S
+	WORD $0x6ea0f402 // FMINP V2.4S, V0.4S, V0.4S
+	WORD $0x6e20c403 // FMAXNMP V3.4S, V0.4S, V0.4S
+	WORD $0x6ea0c404 // FMINNMP V4.4S, V0.4S, V0.4S
+	WORD $0x7e30f805 // FMAXP S5, V0.2S
+	WORD $0x7eb0f806 // FMINP S6, V0.2S
+	VST1.P [V1.S4], 16(R1)
+	VST1.P [V2.S4], 16(R1)
+	VST1.P [V3.S4], 16(R1)
+	VST1.P [V4.S4], 16(R1)
+	FMOVS F5, 0(R1)
+	FMOVS F6, 4(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawfloatpairwiseminmax": {
+			Name: "rawfloatpairwiseminmax", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+extern void rawfloatpairwiseminmax(const float *, float *);
+int main(void) {
+  const float input[4] = {-2, 7, 3, 1};
+  const float want[18] = {
+    7,3,7,3, -2,1,-2,1, 7,3,7,3, -2,1,-2,1, 7,-2
+  };
+  float got[18] = {0};
+  rawfloatpairwiseminmax(input, got);
+  for (int i = 0; i < 18; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_float_pairwise_minmax", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_float_round.go b/arm64_lower_word_float_round.go
new file mode 100644
index 000000000..8500df9b9
--- /dev/null
+++ b/arm64_lower_word_float_round.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawVectorFloatRound struct {
+	operation   string
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+func decodeARM64RawVectorFloatRound(word uint32) (arm64RawVectorFloatRound, bool) {
+	operation := ""
+	switch word & 0xbfbffc00 {
+	case 0x2e218800:
+		operation = "round"
+	case 0x2e219800:
+		operation = "rint"
+	case 0x2ea19800:
+		operation = "nearbyint"
+	default:
+		return arm64RawVectorFloatRound{}, false
+	}
+	elementBits := 32
+	if word&(1<<22) != 0 {
+		elementBits = 64
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if elementBits == 64 && vectorBits == 64 {
+		return arm64RawVectorFloatRound{}, false
+	}
+	return arm64RawVectorFloatRound{
+		operation:   operation,
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawVectorFloatRound(form arm64RawVectorFloatRound) error {
+	arrangementName := arm64VectorArrangementName(form.arrangement)
+	sourceReg := Reg(fmt.Sprintf("V%d.%s", form.source, arrangementName))
+	destinationReg := Reg(fmt.Sprintf("V%d.%s", form.destination, arrangementName))
+	source, err := c.loadARM64VectorFloat(sourceReg, form.arrangement)
+	if err != nil {
+		return err
+	}
+	floatType := "float"
+	suffix := fmt.Sprintf("v%df32", form.arrangement.lanes)
+	if form.arrangement.elementBits == 64 {
+		floatType = "double"
+		suffix = fmt.Sprintf("v%df64", form.arrangement.lanes)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.%s.%s(<%d x %s> %s)\n",
+		result, form.arrangement.lanes, floatType, form.operation, suffix,
+		form.arrangement.lanes, floatType, source)
+	return c.storeARM64VectorFloat(destinationReg, form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_float_round_test.go b/arm64_lower_word_float_round_test.go
new file mode 100644
index 000000000..540f8dc05
--- /dev/null
+++ b/arm64_lower_word_float_round_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawVectorFloatRoundCompleteArchitecturalFormats(t *testing.T) {
+	bases := []uint32{0x2e218800, 0x2e219800, 0x2ea19800} // FRINTA, FRINTX, FRINTI.
+	modifiers := []uint32{0, 1 << 30, 1<<30 | 1<<22}      // S2, S4, D2.
+	var source strings.Builder
+	source.WriteString("TEXT rawvectorfloatroundforms(SB),$0-0\n")
+	for _, base := range bases {
+		for _, modifier := range modifiers {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|modifier|30<<5|29)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawvectorfloatroundforms": {Name: "rawvectorfloatroundforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, intrinsic := range []string{"@llvm.round.", "@llvm.rint.", "@llvm.nearbyint."} {
+				if !strings.Contains(ir, intrinsic) {
+					t.Fatalf("raw vector floating round omitted %s:\n%s", intrinsic, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-vector-float-round.ll", "arm64-raw-vector-float-round.o", ir)
+		})
+	}
+}
+
+func TestARM64RawVectorFloatRoundDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e618800, // reserved FRINTA D1
+		0x2e218000, // FRINTN
+		0x2e219000, // FRINTP
+		0x2e219800 | 1<<10,
+	} {
+		if _, ok := decodeARM64RawVectorFloatRound(word); ok {
+			t.Fatalf("vector floating round decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawVectorFloatRoundRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawvectorfloatround(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	WORD $0x6e218801 // FRINTA V0.S4, V1.S4
+	WORD $0x6e219802 // FRINTX V0.S4, V2.S4
+	WORD $0x6ea19803 // FRINTI V0.S4, V3.S4
+	VST1 [V1.S4, V2.S4, V3.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawvectorfloatround": {
+				Name: "rawvectorfloatround", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+extern void rawvectorfloatround(const float *, float *);
+int main(void) {
+  const float input[4] = {1.5f, 2.5f, -1.5f, -2.5f};
+  const float want[12] = {2,3,-2,-3, 2,2,-2,-2, 2,2,-2,-2};
+  float got[12] = {0};
+  rawvectorfloatround(input, got);
+  for (int i = 0; i < 12; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_vector_float_round", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_fmla.go b/arm64_lower_word_fmla.go
new file mode 100644
index 000000000..00ca857b5
--- /dev/null
+++ b/arm64_lower_word_fmla.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFMLA struct {
+	subtract    bool
+	indexed     bool
+	scalar      bool
+	arrangement arm64VectorArrangement
+	lane        int
+	elementReg  int
+	sourceReg   int
+	destination int
+}
+
+type arm64RawFMLAIndexedFormat struct {
+	base        uint32
+	subtract    bool
+	scalar      bool
+	elementBits int
+	vectorBits  int
+}
+
+var arm64RawFMLAIndexedFormats = [...]arm64RawFMLAIndexedFormat{
+	{base: 0x5f001000, scalar: true, elementBits: 16, vectorBits: 16},
+	{base: 0x5f005000, subtract: true, scalar: true, elementBits: 16, vectorBits: 16},
+	{base: 0x5f801000, scalar: true, elementBits: 32, vectorBits: 32},
+	{base: 0x5f805000, subtract: true, scalar: true, elementBits: 32, vectorBits: 32},
+	{base: 0x5fc01000, scalar: true, elementBits: 64, vectorBits: 64},
+	{base: 0x5fc05000, subtract: true, scalar: true, elementBits: 64, vectorBits: 64},
+	{base: 0x0f001000, elementBits: 16, vectorBits: 64},
+	{base: 0x0f005000, subtract: true, elementBits: 16, vectorBits: 64},
+	{base: 0x4f001000, elementBits: 16, vectorBits: 128},
+	{base: 0x4f005000, subtract: true, elementBits: 16, vectorBits: 128},
+	{base: 0x0f801000, elementBits: 32, vectorBits: 64},
+	{base: 0x0f805000, subtract: true, elementBits: 32, vectorBits: 64},
+	{base: 0x4f801000, elementBits: 32, vectorBits: 128},
+	{base: 0x4f805000, subtract: true, elementBits: 32, vectorBits: 128},
+	{base: 0x4fc01000, elementBits: 64, vectorBits: 128},
+	{base: 0x4fc05000, subtract: true, elementBits: 64, vectorBits: 128},
+}
+
+func decodeARM64RawFMLA(word uint32) (arm64RawFMLA, bool) {
+	const vectorRegisters = uint32(31 | 31<<5 | 31<<16)
+	form := arm64RawFMLA{}
+	switch word &^ vectorRegisters {
+	case 0x0e400c00:
+		form.arrangement = arm64VectorArrangement{elementBits: 16, lanes: 4}
+	case 0x4e400c00:
+		form.arrangement = arm64VectorArrangement{elementBits: 16, lanes: 8}
+	case 0x0e20cc00:
+		form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: 2}
+	case 0x4e20cc00:
+		form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: 4}
+	case 0x4e60cc00:
+		form.arrangement = arm64VectorArrangement{elementBits: 64, lanes: 2}
+	case 0x0ec00c00:
+		form.subtract, form.arrangement = true, arm64VectorArrangement{elementBits: 16, lanes: 4}
+	case 0x4ec00c00:
+		form.subtract, form.arrangement = true, arm64VectorArrangement{elementBits: 16, lanes: 8}
+	case 0x0ea0cc00:
+		form.subtract, form.arrangement = true, arm64VectorArrangement{elementBits: 32, lanes: 2}
+	case 0x4ea0cc00:
+		form.subtract, form.arrangement = true, arm64VectorArrangement{elementBits: 32, lanes: 4}
+	case 0x4ee0cc00:
+		form.subtract, form.arrangement = true, arm64VectorArrangement{elementBits: 64, lanes: 2}
+	}
+	if form.arrangement.elementBits != 0 {
+		form.elementReg = int(word>>16) & 31
+		form.sourceReg = int(word>>5) & 31
+		form.destination = int(word) & 31
+		form.lane = -1
+		return form, true
+	}
+
+	for _, format := range arm64RawFMLAIndexedFormats {
+		variable := uint32(31 | 31<<5 | 31<<16 | 1<<11)
+		if format.elementBits == 16 {
+			variable = uint32(31 | 31<<5 | 15<<16 | 1<<20 | 1<<21 | 1<<11)
+		} else if format.elementBits == 32 {
+			variable |= 1 << 21
+		}
+		if word&^variable != format.base {
+			continue
+		}
+		lane := int(word>>11) & 1
+		elementReg := int(word>>16) & 31
+		if format.elementBits == 16 {
+			lane = lane<<2 | (int(word>>21)&1)<<1 | int(word>>20)&1
+			elementReg &= 15
+		} else if format.elementBits == 32 {
+			lane = lane<<1 | int(word>>21)&1
+		}
+		return arm64RawFMLA{
+			subtract:    format.subtract,
+			indexed:     true,
+			scalar:      format.scalar,
+			arrangement: arm64VectorArrangement{elementBits: format.elementBits, lanes: format.vectorBits / format.elementBits},
+			lane:        lane,
+			elementReg:  elementReg,
+			sourceReg:   int(word>>5) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+	return arm64RawFMLA{}, false
+}
+
+func (c *arm64Ctx) lowerRawFMLA(form arm64RawFMLA) error {
+	bits := form.arrangement.elementBits
+	floatType := arm64RawFloatType(bits)
+	sourceReg := Reg(fmt.Sprintf("V%d", form.sourceReg))
+	destinationReg := Reg(fmt.Sprintf("V%d", form.destination))
+	var source, accumulator string
+	var err error
+	if form.scalar {
+		source, err = c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.sourceReg)), bits)
+		if err == nil {
+			accumulator, err = c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), bits)
+		}
+	} else {
+		source, err = c.loadARM64VectorFloat(sourceReg, form.arrangement)
+		if err == nil {
+			accumulator, err = c.loadARM64VectorFloat(destinationReg, form.arrangement)
+		}
+	}
+	if err != nil {
+		return err
+	}
+
+	multiplier := ""
+	if form.indexed {
+		elementBytes, err := c.loadVReg(Reg(fmt.Sprintf("V%d", form.elementReg)))
+		if err != nil {
+			return err
+		}
+		physicalLanes := 128 / bits
+		typedElements := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <%d x %s>\n", typedElements, elementBytes, physicalLanes, floatType)
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %%%s, i32 %d\n", element, physicalLanes, floatType, typedElements, form.lane)
+		multiplier = "%" + element
+		if !form.scalar {
+			seed := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> poison, %s %s, i32 0\n",
+				seed, form.arrangement.lanes, floatType, floatType, multiplier)
+			splat := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> zeroinitializer\n",
+				splat, form.arrangement.lanes, floatType, seed, form.arrangement.lanes, floatType, form.arrangement.lanes)
+			multiplier = "%" + splat
+		}
+	} else {
+		multiplier, err = c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.elementReg)), form.arrangement)
+		if err != nil {
+			return err
+		}
+	}
+
+	if form.subtract {
+		negated := c.newTmp()
+		if form.scalar {
+			fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", negated, floatType, source)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = fneg <%d x %s> %s\n", negated, form.arrangement.lanes, floatType, source)
+		}
+		source = "%" + negated
+	}
+	result := c.newTmp()
+	if form.scalar {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fma.f%d(%s %s, %s %s, %s %s)\n",
+			result, floatType, bits, floatType, source, floatType, multiplier, floatType, accumulator)
+		return c.storeARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), bits, "%"+result)
+	}
+	vectorType := fmt.Sprintf("<%d x %s>", form.arrangement.lanes, floatType)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fma.v%df%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, form.arrangement.lanes, bits,
+		vectorType, source, vectorType, multiplier, vectorType, accumulator)
+	return c.storeARM64VectorFloat(destinationReg, form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_fmla_test.go b/arm64_lower_word_fmla_test.go
new file mode 100644
index 000000000..aa267040e
--- /dev/null
+++ b/arm64_lower_word_fmla_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64EncodeRawFMLAByElement(subtract, scalar bool, bits, vectorBits, lane, rm, rn, rd int) uint32 {
+	base := uint32(0x0f001000)
+	if scalar {
+		base = 0x5f001000
+	} else if vectorBits == 128 {
+		base |= 1 << 30
+	}
+	if subtract {
+		base |= 1 << 14
+	}
+	switch bits {
+	case 16:
+		base |= uint32(lane&1) << 20
+		base |= uint32((lane>>1)&1) << 21
+		base |= uint32((lane>>2)&1) << 11
+	case 32:
+		base |= 1 << 23
+		base |= uint32(lane&1) << 21
+		base |= uint32((lane>>1)&1) << 11
+	case 64:
+		base |= 3 << 22
+		base |= uint32(lane&1) << 11
+	default:
+		panic(fmt.Sprintf("unsupported FMLA element width %d", bits))
+	}
+	return base | uint32(rm)<<16 | uint32(rn)<<5 | uint32(rd)
+}
+
+func TestARM64RawFMLADecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0e60cc00, // reserved FMLA D1 vector arrangement.
+		0x0ee0cc00, // reserved FMLS D1 vector arrangement.
+		0x0fc01000, // reserved indexed FMLA D1 arrangement.
+		0x0fc05000, // reserved indexed FMLS D1 arrangement.
+		0x4fe01000, // indexed D form with reserved L bit.
+		0x4fe05000, // indexed D subtract form with reserved L bit.
+		0x0f809000, // FMUL by element.
+		0x0e400800, // adjacent same-vector opcode.
+	} {
+		if _, ok := decodeARM64RawFMLA(word); ok {
+			t.Fatalf("FMLA/FMLS decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawFMLARuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	indexedAdd := arm64EncodeRawFMLAByElement(false, false, 16, 128, 7, 2, 1, 4)
+	indexedSubtract := arm64EncodeRawFMLAByElement(true, false, 16, 128, 6, 2, 1, 5)
+	scalarAdd := arm64EncodeRawFMLAByElement(false, true, 16, 16, 3, 2, 7, 6)
+	source := fmt.Sprintf(`
+TEXT rawfmla(SB),$0-32
+	MOVD accumulator+0(FP), R0
+	MOVD multiplicand+8(FP), R1
+	MOVD multiplier+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V0.H8]
+	VLD1 (R0), [V3.H8]
+	VLD1 (R0), [V4.H8]
+	VLD1 (R0), [V5.H8]
+	VLD1 (R0), [V6.H8]
+	VLD1 (R1), [V1.H8]
+	VLD1 (R1), [V7.H8]
+	VLD1 (R2), [V2.H8]
+	WORD $0x4e420c20 // FMLA V0.8H, V1.8H, V2.8H
+	WORD $0x4ec20c23 // FMLS V3.8H, V1.8H, V2.8H
+	WORD $%#08x // FMLA V4.8H, V1.8H, V2.H[7]
+	WORD $%#08x // FMLS V5.8H, V1.8H, V2.H[6]
+	WORD $%#08x // FMLA H6, H7, V2.H[3]
+	VST1.P [V0.H8], 16(R3)
+	VST1.P [V3.H8], 16(R3)
+	VST1.P [V4.H8], 16(R3)
+	VST1.P [V5.H8], 16(R3)
+	VST1 [V6.H8], (R3)
+	RET
+`, indexedAdd, indexedSubtract, scalarAdd)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawfmla": {
+				Name: "rawfmla", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+typedef _Float16 f16;
+extern void rawfmla(const f16 *, const f16 *, const f16 *, f16 *);
+int main(void) {
+  const f16 accumulator[8] = {1,1,1,1,1,1,1,1};
+  const f16 multiplicand[8] = {1,2,3,4,5,6,7,8};
+  const f16 multiplier[8] = {2,3,4,5,6,7,8,9};
+  const f16 same_add[8] = {3,7,13,21,31,43,57,73};
+  const f16 same_sub[8] = {-1,-5,-11,-19,-29,-41,-55,-71};
+  const f16 indexed_add[8] = {10,19,28,37,46,55,64,73};
+  const f16 indexed_sub[8] = {-7,-15,-23,-31,-39,-47,-55,-63};
+  f16 got[40] = {0};
+  rawfmla(accumulator, multiplicand, multiplier, got);
+  for (int lane = 0; lane < 8; lane++) {
+    if (got[lane] != same_add[lane]) return 1 + lane;
+    if (got[8 + lane] != same_sub[lane]) return 10 + lane;
+    if (got[16 + lane] != indexed_add[lane]) return 20 + lane;
+    if (got[24 + lane] != indexed_sub[lane]) return 30 + lane;
+  }
+  if (got[32] != 6) return 40;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fmla", triple, ir, mainC, nil)
+}
+
+func TestTranslateARM64RawFMLACompleteArchitecturalFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawfmlaforms(SB),$0-0\n")
+	for _, base := range []uint32{
+		0x0e400c00, 0x4e400c00, 0x0e20cc00, 0x4e20cc00, 0x4e60cc00, // FMLA H4/H8/S2/S4/D2.
+		0x0ec00c00, 0x4ec00c00, 0x0ea0cc00, 0x4ea0cc00, 0x4ee0cc00, // FMLS H4/H8/S2/S4/D2.
+	} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", base|29<<16|30<<5|28)
+	}
+	type indexedFormat struct {
+		scalar     bool
+		bits       int
+		vectorBits int
+		lanes      int
+		maxRm      int
+	}
+	formats := []indexedFormat{
+		{scalar: true, bits: 16, vectorBits: 16, lanes: 8, maxRm: 15},
+		{scalar: true, bits: 32, vectorBits: 32, lanes: 4, maxRm: 31},
+		{scalar: true, bits: 64, vectorBits: 64, lanes: 2, maxRm: 31},
+		{bits: 16, vectorBits: 64, lanes: 8, maxRm: 15},
+		{bits: 16, vectorBits: 128, lanes: 8, maxRm: 15},
+		{bits: 32, vectorBits: 64, lanes: 4, maxRm: 31},
+		{bits: 32, vectorBits: 128, lanes: 4, maxRm: 31},
+		{bits: 64, vectorBits: 128, lanes: 2, maxRm: 31},
+	}
+	for _, subtract := range []bool{false, true} {
+		for _, form := range formats {
+			for lane := 0; lane < form.lanes; lane++ {
+				for _, rm := range []int{0, form.maxRm} {
+					word := arm64EncodeRawFMLAByElement(subtract, form.scalar, form.bits, form.vectorBits, lane, rm, 30, 29)
+					decoded, ok := decodeARM64RawFMLA(word)
+					if !ok || !decoded.indexed || decoded.subtract != subtract || decoded.scalar != form.scalar ||
+						decoded.arrangement != (arm64VectorArrangement{elementBits: form.bits, lanes: form.vectorBits / form.bits}) ||
+						decoded.lane != lane || decoded.elementReg != rm || decoded.sourceReg != 30 || decoded.destination != 29 {
+						t.Fatalf("decode FMLA/FMLS indexed word %#08x = %+v, ok=%v", word, decoded, ok)
+					}
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawfmlaforms": {Name: "rawfmlaforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fmla.ll", "arm64-raw-fmla.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_fmov_test.go b/arm64_lower_word_fmov_test.go
new file mode 100644
index 000000000..3ce9d4a54
--- /dev/null
+++ b/arm64_lower_word_fmov_test.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawVectorFMOVImmediate = `TEXT vfmovraw(SB),$0-0
+	WORD $0x4f00f785 // FMOV V5.S4, #7.00
+	RET
+`
+
+func TestTranslateARM64RawVectorFMOVImmediate(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawVectorFMOVImmediate, true)
+	file, err := Parse(ArchARM64, arm64RawVectorFMOVImmediate)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"vfmovraw": {Name: "vfmovraw", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vfmov.ll", "arm64-vfmov.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_fsqrt.go b/arm64_lower_word_fsqrt.go
new file mode 100644
index 000000000..44ba3f75d
--- /dev/null
+++ b/arm64_lower_word_fsqrt.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawFSQRT struct {
+	arrangement arm64VectorArrangement
+	source      int
+	destination int
+}
+
+func decodeARM64RawFSQRT(word uint32) (arm64RawFSQRT, bool) {
+	const registers = uint32(31 | 31<<5)
+	if key := word &^ registers; key == 0x2ef9f800 || key == 0x6ef9f800 {
+		lanes := 4
+		if word&(1<<30) != 0 {
+			lanes = 8
+		}
+		return arm64RawFSQRT{
+			arrangement: arm64VectorArrangement{elementBits: 16, lanes: lanes},
+			source:      int(word>>5) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+	if word&0xbfbffc00 != 0x2ea1f800 { // Ignore Q, size, Rn, and Rd.
+		return arm64RawFSQRT{}, false
+	}
+	elementBits := 32
+	if word&(1<<22) != 0 {
+		elementBits = 64
+	}
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if elementBits == 64 && vectorBits == 64 {
+		return arm64RawFSQRT{}, false
+	}
+	return arm64RawFSQRT{
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawFSQRT(form arm64RawFSQRT) error {
+	if form.arrangement.elementBits == 16 {
+		source, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.source)), form.arrangement)
+		if err != nil {
+			return err
+		}
+		result := c.newTmp()
+		vectorType := fmt.Sprintf("<%d x half>", form.arrangement.lanes)
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.sqrt.v%df16(%s %s)\n", result, vectorType, form.arrangement.lanes, vectorType, source)
+		return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), form.arrangement, "%"+result)
+	}
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	ins := Instr{
+		Op:  "VFSQRT",
+		Raw: "decoded ARM64 WORD as VFSQRT",
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.source, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorFloatUnary("VFSQRT", ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw VFSQRT decoder reached no semantic lowerer")
+	}
+	return err
+}
diff --git a/arm64_lower_word_fsqrt_test.go b/arm64_lower_word_fsqrt_test.go
new file mode 100644
index 000000000..c49543fb0
--- /dev/null
+++ b/arm64_lower_word_fsqrt_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawFSQRTForms = `
+TEXT rawfsqrtforms(SB),$0-0
+	WORD $0x2ef9f820 // FSQRT V1.H4, V0.H4
+	WORD $0x6ef9f820 // FSQRT V1.H8, V0.H8
+	WORD $0x2ea1f820 // FSQRT V1.S2, V0.S2
+	WORD $0x6ea1f820 // FSQRT V1.S4, V0.S4
+	WORD $0x6ee1f820 // FSQRT V1.D2, V0.D2
+	RET
+`
+
+func TestTranslateARM64RawFSQRTCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawFSQRTForms, true)
+	file, err := Parse(ArchARM64, arm64RawFSQRTForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawfsqrtforms": {Name: "rawfsqrtforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := 0
+			for _, line := range strings.Split(ll, "\n") {
+				if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.sqrt.") {
+					got++
+				}
+			}
+			if got != 5 {
+				t.Fatalf("ARM64 raw FSQRT lowering for %s emitted %d sqrt operations, want 5:\n%s", triple, got, ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-fsqrt.ll", "arm64-raw-fsqrt.o", ll)
+		})
+	}
+}
+
+func TestARM64RawFSQRTRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawfsqrt(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V5.S4]
+	WORD $0x6ea1f8a5 // FSQRT V5.S4, V5.S4
+	VST1 [V5.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawfsqrt": {
+			Name: "rawfsqrt", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+extern void rawfsqrt(const float *, float *);
+int main(void) {
+  const float in[4] = {4.0f, 9.0f, 16.0f, 25.0f};
+  const float want[4] = {2.0f, 3.0f, 4.0f, 5.0f};
+  float got[4] = {0};
+  rawfsqrt(in, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_fsqrt", triple, ll, mainC, nil)
+}
+
+func TestARM64RawFSQRTDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{0x0ea1d800, 0x1e21c020, 0x2ee1f820} { // SCVTF, scalar FSQRT, reserved D1.
+		if _, ok := decodeARM64RawFSQRT(word); ok {
+			t.Fatalf("FSQRT decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_half_fma.go b/arm64_lower_word_half_fma.go
new file mode 100644
index 000000000..202cc3380
--- /dev/null
+++ b/arm64_lower_word_half_fma.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "fmt"
+
+// The named Go FMA forms cover S and D operands. Go source can also contain
+// raw half-precision encodings; each has four independent five-bit registers.
+type arm64RawHalfFMA struct {
+	op          string
+	destination int
+	first       int
+	addend      int
+	second      int
+}
+
+var arm64RawHalfFMABases = map[uint32]string{
+	0x1fc00000: "FMADD",
+	0x1fc08000: "FMSUB",
+	0x1fe00000: "FNMADD",
+	0x1fe08000: "FNMSUB",
+}
+
+func decodeARM64RawHalfFMA(word uint32) (arm64RawHalfFMA, bool) {
+	const registers = uint32(31 | 31<<5 | 31<<10 | 31<<16)
+	op, ok := arm64RawHalfFMABases[word&^registers]
+	if !ok {
+		return arm64RawHalfFMA{}, false
+	}
+	return arm64RawHalfFMA{
+		op:          op,
+		destination: int(word) & 31,
+		first:       int(word>>5) & 31,
+		addend:      int(word>>10) & 31,
+		second:      int(word>>16) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawHalfFMA(form arm64RawHalfFMA) error {
+	load := func(register int) (string, error) {
+		return c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", register)), 16)
+	}
+	first, err := load(form.first)
+	if err != nil {
+		return err
+	}
+	second, err := load(form.second)
+	if err != nil {
+		return err
+	}
+	addend, err := load(form.addend)
+	if err != nil {
+		return err
+	}
+
+	if form.op == "FMSUB" {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg half %s\n", negated, first)
+		first = "%" + negated
+	} else if form.op == "FNMSUB" {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg half %s\n", negated, addend)
+		addend = "%" + negated
+	}
+
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call half @llvm.fma.f16(half %s, half %s, half %s)\n",
+		result, first, second, addend)
+	value := "%" + result
+	if form.op == "FNMADD" {
+		negated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg half %s\n", negated, value)
+		value = "%" + negated
+	}
+	return c.storeARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), 16, value)
+}
diff --git a/arm64_lower_word_half_fma_test.go b/arm64_lower_word_half_fma_test.go
new file mode 100644
index 000000000..c198c29d2
--- /dev/null
+++ b/arm64_lower_word_half_fma_test.go
@@ -0,0 +1,199 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawHalfFMAReportedWord(t *testing.T) {
+	const source = `TEXT halfFMA(SB), $0-0
+	WORD $0x1fc10800 // FMADD H0, H0, H1, H2
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"halfFMA": {Name: "halfFMA", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawHalfFMACompleteFormats(t *testing.T) {
+	// Go's named FMA family has S/D formats. LLVM 22's A64 encoder also has
+	// four half-precision formats, each with four independent V0..V31 fields.
+	var source strings.Builder
+	source.WriteString("TEXT halfFMAForms(SB), $0-0\n")
+	for _, base := range []uint32{
+		0x1fc00000, // FMADD.
+		0x1fc08000, // FMSUB.
+		0x1fe00000, // FNMADD.
+		0x1fe08000, // FNMSUB.
+	} {
+		for field, shift := range []uint{0, 5, 10, 16} {
+			for register := uint32(0); register < 32; register++ {
+				word := base | register<<shift
+				form, ok := decodeARM64RawHalfFMA(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				got := []int{form.destination, form.first, form.addend, form.second}[field]
+				if got != int(register) {
+					t.Fatalf("field %d in %#08x decoded as %d", field, word, got)
+				}
+			}
+		}
+		word := base | 31<<16 | 30<<10 | 29<<5 | 28
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"halfFMAForms": {Name: "halfFMAForms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`"target-features"="+fullfp16"`, "@llvm.fma.f16", "fneg half"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("%s half FMA lowering omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-half-fma.ll", "arm64-raw-half-fma.o", ir)
+		})
+	}
+}
+
+func TestARM64RawHalfFMARejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1f000000, // FMADD single precision belongs to the named Go family.
+		0x1f400000, // FMADD double precision belongs to the named Go family.
+		0x1f800000, // Reserved floating-point source type.
+	} {
+		if form, ok := decodeARM64RawHalfFMA(word); ok {
+			t.Fatalf("accepted adjacent encoding %#08x as %+v", word, form)
+		}
+	}
+}
+
+func TestARM64RawHalfFMANativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("native execution requires Darwin arm64")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := arm64RawHalfFMARuntimeIR(t, triple)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_half_fma", triple, ir, arm64RawHalfFMAOracleC, nil)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawHalfFMA(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("FP16 execution belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64RawHalfFMARuntimeIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc"}, "arm64_raw_half_fma", triple, ir,
+		arm64RawHalfFMAOracleC,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func arm64RawHalfFMARuntimeIR(t *testing.T, triple string) string {
+	t.Helper()
+	const source = `TEXT halfFMARuntime(SB), $0-32
+	MOVD first+0(FP), R0
+	MOVD second+8(FP), R1
+	MOVD addend+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R0), [V1.H8]
+	VLD1 (R1), [V2.H8]
+	VLD1 (R2), [V4.H8]
+	WORD $0x1fc21020 // FMADD H0, H1, H2, H4
+	VST1 [V0.H8], (R3)
+	WORD $0x1fc29020 // FMSUB H0, H1, H2, H4
+	ADD $16, R3
+	VST1 [V0.H8], (R3)
+	WORD $0x1fe21020 // FNMADD H0, H1, H2, H4
+	ADD $16, R3
+	VST1 [V0.H8], (R3)
+	WORD $0x1fe29020 // FNMSUB H0, H1, H2, H4
+	ADD $16, R3
+	VST1 [V0.H8], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"halfFMARuntime": {
+				Name: "halfFMARuntime", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+const arm64RawHalfFMAOracleC = `
+#include <stdint.h>
+extern void halfFMARuntime(const uint16_t *, const uint16_t *, const uint16_t *, uint16_t *);
+int main(void) {
+    const uint16_t first[8] = {0x4000};
+    const uint16_t second[8] = {0x4200};
+    const uint16_t addend[8] = {0x4400};
+    const uint16_t want[4] = {0x4900, 0xc000, 0xc900, 0x4000};
+    uint16_t output[32] = {0};
+    halfFMARuntime(first, second, addend, output);
+    for (int i = 0; i < 4; i++) if (output[i * 8] != want[i]) return i + 1;
+    return 0;
+}
+`
diff --git a/arm64_lower_word_ldnr.go b/arm64_lower_word_ldnr.go
new file mode 100644
index 000000000..05a3243be
--- /dev/null
+++ b/arm64_lower_word_ldnr.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawLDnR struct {
+	count         int
+	post          bool
+	postRegister  int
+	base          int
+	firstRegister int
+	arrangement   arm64VectorArrangement
+}
+
+func decodeARM64RawLDnR(word uint32) (arm64RawLDnR, bool) {
+	// Advanced SIMD load single structure and replicate to all lanes. Q, the
+	// structure count bits, post-index bit/register, element size, base, and
+	// first destination register are all variable.
+	if word&0xbf40d000 != 0x0d40c000 {
+		return arm64RawLDnR{}, false
+	}
+	post := word&(1<<23) != 0
+	postRegister := int(word>>16) & 31
+	if !post && postRegister != 0 {
+		return arm64RawLDnR{}, false
+	}
+	count := 1 + (int(word>>21) & 1) + 2*(int(word>>13)&1)
+	elementBits := 8 << (int(word>>10) & 3)
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	return arm64RawLDnR{
+		count:         count,
+		post:          post,
+		postRegister:  postRegister,
+		base:          int(word>>5) & 31,
+		firstRegister: int(word & 31),
+		arrangement:   arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawLDnR(form arm64RawLDnR) error {
+	op := Op(fmt.Sprintf("VLD%dR", form.count))
+	rawOp := op
+	if form.post {
+		rawOp += ".P"
+	}
+	base := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		base = SP
+	}
+	memory := MemRef{Base: base}
+	if form.post {
+		if form.postRegister == 31 {
+			memory.Off = int64(form.count * form.arrangement.elementBits / 8)
+		} else {
+			memory.Index = Reg(fmt.Sprintf("R%d", form.postRegister))
+		}
+	}
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	registers := make([]Reg, form.count)
+	for i := range registers {
+		registers[i] = Reg(fmt.Sprintf("V%d.%s", (form.firstRegister+i)%32, arrangement))
+	}
+	ins := Instr{
+		Op:  rawOp,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", rawOp),
+		Args: []Operand{
+			{Kind: OpMem, Mem: memory},
+			{Kind: OpRegList, RegList: registers},
+		},
+	}
+	ok, _, err := c.lowerARM64StructureLoadStore(op, form.post, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", rawOp)
+	}
+	return err
+}
diff --git a/arm64_lower_word_ldnr_test.go b/arm64_lower_word_ldnr_test.go
new file mode 100644
index 000000000..3dc9fec90
--- /dev/null
+++ b/arm64_lower_word_ldnr_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawLDnRForTest(count, size int, q, post bool, rm, rn, rt int) uint32 {
+	word := uint32(0x0d40c000)
+	if q {
+		word |= 1 << 30
+	}
+	if post {
+		word |= 1 << 23
+	}
+	if count&1 == 0 {
+		word |= 1 << 21
+	}
+	if count >= 3 {
+		word |= 1 << 13
+	}
+	word |= uint32(size&3) << 10
+	word |= uint32(rm&31) << 16
+	word |= uint32(rn&31) << 5
+	word |= uint32(rt & 31)
+	return word
+}
+
+func TestTranslateARM64RawLDnRCompleteAdvancedSIMDFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawldnrforms(SB),$0-0\n")
+	for count := 1; count <= 4; count++ {
+		for size := 0; size <= 3; size++ {
+			for _, q := range []bool{false, true} {
+				for _, addressing := range []struct {
+					post bool
+					rm   int
+				}{{false, 0}, {true, 31}, {true, 2}} {
+					word := encodeARM64RawLDnRForTest(count, size, q, addressing.post, addressing.rm, 0, 28)
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawldnrforms": {Name: "rawldnrforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"load i8", "load i16", "load i32", "load i64", "shufflevector", "add i64"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw LDnR lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-ldnr.ll", "arm64-raw-ldnr.o", ll)
+		})
+	}
+}
+
+func TestARM64RawLDnRDecoderCoversEveryFormat(t *testing.T) {
+	for count := 1; count <= 4; count++ {
+		for size := 0; size <= 3; size++ {
+			for _, q := range []bool{false, true} {
+				for _, addressing := range []struct {
+					post bool
+					rm   int
+				}{{false, 0}, {true, 31}, {true, 17}} {
+					word := encodeARM64RawLDnRForTest(count, size, q, addressing.post, addressing.rm, 9, 30)
+					form, ok := decodeARM64RawLDnR(word)
+					if !ok || form.count != count || form.post != addressing.post || form.base != 9 || form.firstRegister != 30 || form.arrangement.elementBits != 8<<size {
+						t.Fatalf("decode LDnR count=%d size=%d q=%v post=%v rm=%d: form=%#v ok=%v", count, size, q, addressing.post, addressing.rm, form, ok)
+					}
+					wantLanes := 64 / (8 << size)
+					if q {
+						wantLanes *= 2
+					}
+					if form.arrangement.lanes != wantLanes || form.postRegister != addressing.rm {
+						t.Fatalf("decode LDnR arrangement/addressing mismatch: form=%#v", form)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawLDnRRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawldnr(SB),$0-24
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	MOVD advanced+16(FP), R2
+	WORD $0x4dffe804 // LD4R {V4.4S-V7.4S}, [R0], #16
+	VST1 [V4.S4, V5.S4, V6.S4, V7.S4], (R1)
+	MOVD R0, (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawldnr": {
+				Name: "rawldnr", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <stddef.h>
+extern void rawldnr(const uint32_t *, uint32_t *, uintptr_t *);
+int main(void) {
+  const uint32_t input[4] = {11, 22, 33, 44};
+  uint32_t output[16] = {0};
+  uintptr_t advanced = 0;
+  rawldnr(input, output, &advanced);
+  for (int reg = 0; reg < 4; reg++)
+    for (int lane = 0; lane < 4; lane++)
+      if (output[reg*4+lane] != input[reg]) return 1 + reg*4 + lane;
+  return advanced == (uintptr_t)(input+4) ? 0 : 30;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_ldnr", triple, ll, mainC, nil)
+}
+
+func TestARM64RawLDnRDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x4c407000, // LD1, not LD1R.
+		encodeARM64RawLDnRForTest(1, 0, true, false, 3, 0, 0), // Rm must be zero without post-indexing.
+	} {
+		t.Run(fmt.Sprintf("%08x", word), func(t *testing.T) {
+			if _, ok := decodeARM64RawLDnR(word); ok {
+				t.Fatalf("LDnR decoder claimed adjacent/reserved encoding %#08x", word)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_word_logical.go b/arm64_lower_word_logical.go
new file mode 100644
index 000000000..5c473b56a
--- /dev/null
+++ b/arm64_lower_word_logical.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawLogical struct {
+	op          Op
+	arrangement arm64VectorArrangement
+	first       int
+	second      int
+	destination int
+}
+
+func decodeARM64RawLogical(word uint32) (arm64RawLogical, bool) {
+	var op Op
+	switch word & 0xbfe0fc00 { // Ignore Q, Rm, Rn, and Rd.
+	case 0x0e201c00:
+		op = "VAND"
+	case 0x0e601c00:
+		op = "VBIC"
+	case 0x0ea01c00:
+		op = "VORR"
+	case 0x0ee01c00:
+		op = "VORN"
+	case 0x2e201c00:
+		op = "VEOR"
+	case 0x2e601c00:
+		op = "VBSL"
+	case 0x2ea01c00:
+		op = "VBIT"
+	case 0x2ee01c00:
+		op = "VBIF"
+	default:
+		return arm64RawLogical{}, false
+	}
+	lanes := 8
+	if word&(1<<30) != 0 {
+		lanes = 16
+	}
+	return arm64RawLogical{
+		op:          op,
+		arrangement: arm64VectorArrangement{elementBits: 8, lanes: lanes},
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawLogical(form arm64RawLogical) error {
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	ins := Instr{
+		Op:  form.op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", form.op),
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.second, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.first, arrangement))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorLogical(form.op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_logical_test.go b/arm64_lower_word_logical_test.go
new file mode 100644
index 000000000..2350e6eaa
--- /dev/null
+++ b/arm64_lower_word_logical_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawLogicalCompleteAdvancedSIMDFormats(t *testing.T) {
+	bases := []uint32{0x0e201c00, 0x0e601c00, 0x0ea01c00, 0x0ee01c00, 0x2e201c00, 0x2e601c00, 0x2ea01c00, 0x2ee01c00}
+	var source strings.Builder
+	source.WriteString("TEXT rawlogicalforms(SB),$0-0\n")
+	for _, base := range bases {
+		for _, q := range []uint32{0, 1 << 30} { // B8 and B16.
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", base|q|1<<16|2<<5|3)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawlogicalforms": {Name: "rawlogicalforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"and <", "or <", "xor <"} {
+				if !strings.Contains(ll, operation) {
+					t.Fatalf("ARM64 raw logical lowering for %s omitted %q:\n%s", triple, operation, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-logical.ll", "arm64-raw-logical.o", ll)
+		})
+	}
+}
+
+func TestARM64RawLogicalRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawlogical(SB),$0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD initial+16(FP), R2
+	MOVD out+24(FP), R3
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VLD1.P 64(R2), [V2.B16, V3.B16, V4.B16, V5.B16]
+	VLD1 (R2), [V6.B16, V7.B16, V8.B16, V9.B16]
+	WORD $0x4e211c02 // AND V2.16B, V0.16B, V1.16B
+	WORD $0x4e611c03 // BIC V3.16B, V0.16B, V1.16B
+	WORD $0x4ea11c04 // ORR V4.16B, V0.16B, V1.16B
+	WORD $0x4ee11c05 // ORN V5.16B, V0.16B, V1.16B
+	WORD $0x6e211c06 // EOR V6.16B, V0.16B, V1.16B
+	WORD $0x6e611c07 // BSL V7.16B, V0.16B, V1.16B
+	WORD $0x6ea11c08 // BIT V8.16B, V0.16B, V1.16B
+	WORD $0x6ee11c09 // BIF V9.16B, V0.16B, V1.16B
+	VST1.P [V2.B16, V3.B16, V4.B16, V5.B16], 64(R3)
+	VST1 [V6.B16, V7.B16, V8.B16, V9.B16], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawlogical": {
+			Name: "rawlogical", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawlogical(const uint8_t *, const uint8_t *, const uint8_t *, uint8_t *);
+int main(void) {
+  uint8_t a[16], b[16], initial[128], got[128] = {0};
+  for (int i = 0; i < 16; i++) { a[i] = i * 17u; b[i] = 255u - i * 11u; }
+  for (int i = 0; i < 128; i++) initial[i] = 0xa5u ^ i;
+  rawlogical(a, b, initial, got);
+  for (int i = 0; i < 16; i++) {
+    const uint8_t old_bsl = initial[5*16+i], old_bit = initial[6*16+i], old_bif = initial[7*16+i];
+    const uint8_t want[8] = {
+      a[i]&b[i], a[i]&~b[i], a[i]|b[i], a[i]|~b[i], a[i]^b[i],
+      (old_bsl&a[i])|(~old_bsl&b[i]),
+      (old_bit&~b[i])|(a[i]&b[i]),
+      (old_bif&b[i])|(a[i]&~b[i]),
+    };
+    for (int op = 0; op < 8; op++) if (got[op*16+i] != want[op]) return op*16+i+1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_logical", triple, ll, mainC, nil)
+}
+
+func TestARM64RawLogicalDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x0e201800, 0x0e205c00, 0x5e201c00} {
+		if _, ok := decodeARM64RawLogical(word); ok {
+			t.Fatalf("logical decoder accepted adjacent/scalar encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_matrix_multiply.go b/arm64_lower_word_matrix_multiply.go
new file mode 100644
index 000000000..47eac1e58
--- /dev/null
+++ b/arm64_lower_word_matrix_multiply.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawMatrixMultiply struct {
+	leftSigned  bool
+	rightSigned bool
+	destination int
+	left        int
+	right       int
+}
+
+func decodeARM64RawMatrixMultiply(word uint32) (arm64RawMatrixMultiply, bool) {
+	form := arm64RawMatrixMultiply{}
+	switch word & 0xffe0fc00 {
+	case 0x4e80a400: // SMMLA.
+		form.leftSigned, form.rightSigned = true, true
+	case 0x6e80a400: // UMMLA.
+	case 0x4e80ac00: // USMMLA.
+		form.rightSigned = true
+	default:
+		return arm64RawMatrixMultiply{}, false
+	}
+	form.destination = int(word) & 31
+	form.left = int(word>>5) & 31
+	form.right = int(word>>16) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawMatrixMultiply(form arm64RawMatrixMultiply) error {
+	inputArrangement := arm64VectorArrangement{elementBits: 8, lanes: 16}
+	accumulatorArrangement := arm64VectorArrangement{elementBits: 32, lanes: 4}
+	leftReg := Reg(fmt.Sprintf("V%d.B16", form.left))
+	rightReg := Reg(fmt.Sprintf("V%d.B16", form.right))
+	accumulatorReg := Reg(fmt.Sprintf("V%d.S4", form.destination))
+	left, err := c.loadARM64VectorInteger(leftReg, inputArrangement)
+	if err != nil {
+		return err
+	}
+	right, err := c.loadARM64VectorInteger(rightReg, inputArrangement)
+	if err != nil {
+		return err
+	}
+	result, err := c.loadARM64VectorInteger(accumulatorReg, accumulatorArrangement)
+	if err != nil {
+		return err
+	}
+
+	widen := func(value string, signed bool) string {
+		op := "zext"
+		if signed {
+			op = "sext"
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s <16 x i8> %s to <16 x i32>\n", wide, op, value)
+		return "%" + wide
+	}
+	wideLeft := widen(left, form.leftSigned)
+
+	for column := 0; column < 2; column++ {
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shufflevector <16 x i8> %s, <16 x i8> poison, <16 x i32> <", selected, right)
+		for lane := 0; lane < 16; lane++ {
+			if lane != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "i32 %d", 2*(lane%8)+column)
+		}
+		c.b.WriteString(">\n")
+		wideRight := widen("%"+selected, form.rightSigned)
+		products := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul <16 x i32> %s, %s\n", products, wideLeft, wideRight)
+
+		for row := 0; row < 2; row++ {
+			destinationLane := row*2 + column
+			accumulated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %s, i32 %d\n", accumulated, result, destinationLane)
+			value := "%" + accumulated
+			for k := 0; k < 8; k++ {
+				product := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i32> %%%s, i32 %d\n", product, products, row*8+k)
+				sum := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = add i32 %s, %%%s\n", sum, value, product)
+				value = "%" + sum
+			}
+			updated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %s, i32 %s, i32 %d\n", updated, result, value, destinationLane)
+			result = "%" + updated
+		}
+	}
+	return c.storeARM64VectorInteger(accumulatorReg, accumulatorArrangement, result)
+}
diff --git a/arm64_lower_word_matrix_multiply_test.go b/arm64_lower_word_matrix_multiply_test.go
new file mode 100644
index 000000000..e8c571074
--- /dev/null
+++ b/arm64_lower_word_matrix_multiply_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawMatrixMultiplyForms = `
+TEXT rawmatrixmultiplyforms(SB),$0-0
+	WORD $0x4e9fa7dd // SMMLA V29.4S, V30.16B, V31.16B
+	WORD $0x6e9fa7dd // UMMLA V29.4S, V30.16B, V31.16B
+	WORD $0x4e9fafdd // USMMLA V29.4S, V30.16B, V31.16B
+	RET
+`
+
+func TestTranslateARM64RawMatrixMultiplyCompleteArchitecturalFamily(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawMatrixMultiplyForms, true)
+	file, err := Parse(ArchARM64, arm64RawMatrixMultiplyForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawmatrixmultiplyforms": {Name: "rawmatrixmultiplyforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"sext <16 x i8>", "zext <16 x i8>", "mul <16 x i32>", "add i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw matrix-multiply family for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-matrix-multiply.ll", "arm64-raw-matrix-multiply.o", ir)
+		})
+	}
+}
+
+func TestARM64RawMatrixMultiplyDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0e80a400, // Q=0 is unallocated for matrix multiply.
+		0x4ea0a400, // Reserved bit 21.
+		0x4e80a000, // Adjacent opcode field.
+		0x4e80a800, // Adjacent opcode field.
+		0x6e80ac00, // Unallocated unsigned/mixed-sign combination.
+	} {
+		if _, ok := decodeARM64RawMatrixMultiply(word); ok {
+			t.Fatalf("matrix-multiply decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawMatrixMultiplyRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawmatrixmultiply(SB),$0-32
+	MOVD accumulator+0(FP), R0
+	MOVD lhs+8(FP), R1
+	MOVD rhs+16(FP), R2
+	MOVD output+24(FP), R3
+	VLD1 (R1), [V16.B16]
+	VLD1 (R2), [V18.B16]
+	VLD1 (R0), [V8.S4]
+	WORD $0x4e92a608 // SMMLA V8.4S, V16.16B, V18.16B
+	VST1 [V8.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V8.S4]
+	WORD $0x6e92a608 // UMMLA V8.4S, V16.16B, V18.16B
+	VST1 [V8.S4], (R3)
+	ADD $16, R3
+	VLD1 (R0), [V8.S4]
+	WORD $0x4e92ae08 // USMMLA V8.4S, V16.16B, V18.16B
+	VST1 [V8.S4], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{"rawmatrixmultiply": {
+			Name: "rawmatrixmultiply", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmatrixmultiply(const int32_t *, const uint8_t *, const uint8_t *, int32_t *);
+static void reference(int32_t *out, const int32_t *acc, const uint8_t *lhs, const uint8_t *rhs, int lhs_signed, int rhs_signed) {
+  for (int row = 0; row < 2; row++) for (int col = 0; col < 2; col++) {
+    int32_t sum = acc[row * 2 + col];
+    for (int k = 0; k < 8; k++) {
+      int32_t a = lhs_signed ? (int8_t)lhs[row * 8 + k] : lhs[row * 8 + k];
+      int32_t b = rhs_signed ? (int8_t)rhs[k * 2 + col] : rhs[k * 2 + col];
+      sum += a * b;
+    }
+    out[row * 2 + col] = sum;
+  }
+}
+int main(void) {
+  const int32_t accumulator[4] = {10, 20, 30, 40};
+  const uint8_t lhs[16] = {255,2,253,4,251,6,249,8, 247,10,245,12,243,14,241,16};
+  const uint8_t rhs[16] = {1,254,3,252,5,250,7,248,9,246,11,244,13,242,15,240};
+  int32_t got[12] = {0};
+  int32_t want[12] = {0};
+  rawmatrixmultiply(accumulator, lhs, rhs, got);
+  reference(want + 0, accumulator, lhs, rhs, 1, 1);
+  reference(want + 4, accumulator, lhs, rhs, 0, 0);
+  reference(want + 8, accumulator, lhs, rhs, 0, 1);
+  for (int i = 0; i < 12; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_matrix_multiply", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_mixed_saturating_add.go b/arm64_lower_word_mixed_saturating_add.go
new file mode 100644
index 000000000..430167909
--- /dev/null
+++ b/arm64_lower_word_mixed_saturating_add.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import "fmt"
+
+// ARM's USQADD and SUQADD use a two-register, destructive form. Retaining the
+// encoded element size matters for scalar WORD instructions: x/arch's Plan 9
+// spelling prints every scalar size as two bare V registers.
+type arm64RawMixedSaturatingAdd struct {
+	intrinsic   string
+	scalar      bool
+	elementBits int
+	lanes       int
+	source      int
+	destination int
+}
+
+func decodeARM64RawMixedSaturatingAdd(word uint32) (arm64RawMixedSaturatingAdd, bool) {
+	base := word &^ uint32(0x00c003ff) // Element size and both V registers.
+	form := arm64RawMixedSaturatingAdd{}
+	switch base {
+	case 0x0e203800, 0x4e203800:
+		form.intrinsic = "suqadd"
+	case 0x2e203800, 0x6e203800:
+		form.intrinsic = "usqadd"
+	case 0x5e203800:
+		form.intrinsic = "suqadd"
+		form.scalar = true
+	case 0x7e203800:
+		form.intrinsic = "usqadd"
+		form.scalar = true
+	default:
+		return arm64RawMixedSaturatingAdd{}, false
+	}
+	form.elementBits = 8 << ((word >> 22) & 3)
+	if !form.scalar {
+		vectorBits := 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if form.elementBits >= vectorBits {
+			return arm64RawMixedSaturatingAdd{}, false
+		}
+		form.lanes = vectorBits / form.elementBits
+	}
+	form.source = int(word>>5) & 31
+	form.destination = int(word) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawMixedSaturatingAdd(form arm64RawMixedSaturatingAdd) error {
+	sourceRegister := Reg(fmt.Sprintf("V%d", form.source))
+	destinationRegister := Reg(fmt.Sprintf("V%d", form.destination))
+	if form.scalar {
+		source, err := c.loadARM64RawScalarVectorElement(sourceRegister, form.elementBits)
+		if err != nil {
+			return err
+		}
+		destination, err := c.loadARM64RawScalarVectorElement(destinationRegister, form.elementBits)
+		if err != nil {
+			return err
+		}
+		// LLVM 22 cannot select the overloaded scalar i8/i16 intrinsic. Place
+		// the active lane in a zeroed vector instead. Other lanes cannot set
+		// saturation state, and only the active result lane is written back.
+		lanes := 64 / form.elementBits
+		if form.elementBits == 64 {
+			lanes = 2
+		}
+		typeName := fmt.Sprintf("<%d x i%d>", lanes, form.elementBits)
+		sourceVector := c.newTmp()
+		destinationVector := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s zeroinitializer, i%d %s, i32 0\n",
+			sourceVector, typeName, form.elementBits, source)
+		fmt.Fprintf(c.b, "  %%%s = insertelement %s zeroinitializer, i%d %s, i32 0\n",
+			destinationVector, typeName, form.elementBits, destination)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%di%d(%s %%%s, %s %%%s)\n",
+			result, typeName, form.intrinsic, lanes, form.elementBits,
+			typeName, destinationVector, typeName, sourceVector)
+		low := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 0\n", low, typeName, result)
+		return c.storeARM64ScalarToVReg(destinationRegister, form.elementBits, "%"+low)
+	}
+
+	arrangement := arm64VectorArrangement{elementBits: form.elementBits, lanes: form.lanes}
+	source, err := c.loadARM64VectorInteger(sourceRegister, arrangement)
+	if err != nil {
+		return err
+	}
+	destination, err := c.loadARM64VectorInteger(destinationRegister, arrangement)
+	if err != nil {
+		return err
+	}
+	typeName := fmt.Sprintf("<%d x i%d>", form.lanes, form.elementBits)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%di%d(%s %s, %s %s)\n",
+		result, typeName, form.intrinsic, form.lanes, form.elementBits,
+		typeName, destination, typeName, source)
+	return c.storeARM64VectorInteger(destinationRegister, arrangement, "%"+result)
+}
+
+func (c *arm64Ctx) loadARM64RawScalarVectorElement(reg Reg, bits int) (string, error) {
+	bytes, err := c.loadVReg(reg)
+	if err != nil {
+		return "", err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", 128/bits, bits)
+	values := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to %s\n", values, bytes, vectorType)
+	low := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement %s %%%s, i32 0\n", low, vectorType, values)
+	return "%" + low, nil
+}
diff --git a/arm64_lower_word_mixed_saturating_add_test.go b/arm64_lower_word_mixed_saturating_add_test.go
new file mode 100644
index 000000000..b395e25d5
--- /dev/null
+++ b/arm64_lower_word_mixed_saturating_add_test.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawMixedSaturatingAddCompleteFamily(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT mixedSaturatingAdd(SB),$0-0\n")
+	for _, family := range []struct {
+		op         Op
+		vectorBase uint32
+		scalarBase uint32
+	}{
+		{op: "VSUQADD", vectorBase: 0x0e203800, scalarBase: 0x5e203800},
+		{op: "VUSQADD", vectorBase: 0x2e203800, scalarBase: 0x7e203800},
+	} {
+		for size := 0; size < 4; size++ {
+			for _, wide := range []bool{false, true} {
+				if size == 3 && !wide {
+					continue // There is no one-lane vector D arrangement.
+				}
+				word := family.vectorBase | uint32(size)<<22 | 5<<5 | 2
+				if wide {
+					word |= 1 << 30
+				}
+				assertARM64MixedSaturatingAddWord(t, word, family.op)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+			word := family.scalarBase | uint32(size)<<22 | 5<<5 | 2
+			assertARM64MixedSaturatingAddWord(t, word, family.op)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"mixedSaturatingAdd": {Name: "mixedSaturatingAdd", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"@llvm.aarch64.neon.suqadd", "@llvm.aarch64.neon.usqadd"} {
+				if !strings.Contains(ir, name) {
+					t.Fatalf("missing %s in generated IR:\n%s", name, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-mixed-saturating-add.ll", "arm64-mixed-saturating-add.o", ir)
+		})
+	}
+}
+
+func assertARM64MixedSaturatingAddWord(t *testing.T, word uint32, want Op) {
+	t.Helper()
+	decoded, err := decodeARM64RawWordInstruction(Instr{
+		Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+	})
+	if err != nil {
+		t.Fatalf("decode %#08x: %v", word, err)
+	}
+	if decoded.Op != want || len(decoded.Args) != 2 {
+		t.Fatalf("decode %#08x: %+v, want %s with two registers", word, decoded, want)
+	}
+}
+
+func TestARM64RawMixedSaturatingAddDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2ee038a2, // No one-lane D vector form.
+		0x6e203ca2, // Adjacent opcode, not USQADD.
+		0x4e203ca2, // Adjacent opcode, not SUQADD.
+	} {
+		if form, ok := decodeARM64RawMixedSaturatingAdd(word); ok {
+			t.Fatalf("accepted invalid or adjacent encoding %#08x as %+v", word, form)
+		}
+	}
+}
+
+func TestARM64RawUSQADDReportedGoAV1RuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT rawusqadd(SB),$0-24
+	MOVD destination+0(FP), R0
+	MOVD source+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V2.B16]
+	VLD1 (R1), [V5.B16]
+	WORD $0x6e2038a2 // USQADD V2.16B, V5.16B
+	VST1 [V2.B16], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"rawusqadd": {
+				Name: "rawusqadd", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawusqadd(const uint8_t *, const int8_t *, uint8_t *);
+int main(void) {
+  const uint8_t destination[16] = {250, 2, 0, 255};
+  const int8_t source[16] = {10, -5, -1, 1};
+  uint8_t got[16] = {0};
+  const uint8_t want[16] = {255, 0, 0, 255};
+  rawusqadd(destination, source, got);
+  for (int i = 0; i < 16; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_usqadd", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_mla.go b/arm64_lower_word_mla.go
new file mode 100644
index 000000000..636ba98f2
--- /dev/null
+++ b/arm64_lower_word_mla.go
@@ -0,0 +1,17 @@
+package plan9asm
+
+func decodeARM64RawMLA(word uint32) (arm64RawMUL, bool) {
+	form := arm64RawMUL{element: -1}
+	switch {
+	case word&0xbf20fc00 == 0x0e209400: // vector, three same
+	case word&0xbf00f400 == 0x2f000000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawMUL{}, false
+	}
+	return decodeARM64MultiplyVectorOperands(word, form)
+}
+
+func (c *arm64Ctx) lowerRawMLA(form arm64RawMUL) error {
+	return c.lowerRawMultiplyAccumulate(form, "add")
+}
diff --git a/arm64_lower_word_mla_test.go b/arm64_lower_word_mla_test.go
new file mode 100644
index 000000000..458056c1b
--- /dev/null
+++ b/arm64_lower_word_mla_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawMLAForms = `
+TEXT rawmlaforms(SB),$0-0
+	WORD $0x0e229420 // MLA V0.8B, V1.8B, V2.8B
+	WORD $0x4e259483 // MLA V3.16B, V4.16B, V5.16B
+	WORD $0x0e6894e6 // MLA V6.4H, V7.4H, V8.4H
+	WORD $0x4e6b9549 // MLA V9.8H, V10.8H, V11.8H
+	WORD $0x0eae95ac // MLA V12.2S, V13.2S, V14.2S
+	WORD $0x4eb1960f // MLA V15.4S, V16.4S, V17.4S
+	WORD $0x2f740a72 // MLA V18.4H, V19.4H, V4.H[7]
+	WORD $0x6f750ab4 // MLA V20.8H, V21.8H, V5.H[7]
+	WORD $0x2fb80af6 // MLA V22.2S, V23.2S, V24.S[3]
+	WORD $0x6fbb0b59 // MLA V25.4S, V26.4S, V27.S[3]
+	RET
+`
+
+func TestTranslateARM64RawMLACompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawMLAForms, true)
+	file, err := Parse(ArchARM64, arm64RawMLAForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawmlaforms": {Name: "rawmlaforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"mul <8 x i8>", "mul <16 x i8>",
+				"mul <4 x i16>", "mul <8 x i16>",
+				"mul <2 x i32>", "mul <4 x i32>",
+				"add <8 x i8>", "add <4 x i32>",
+				"extractelement <8 x i16>", "extractelement <4 x i32>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw MLA lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-mla.ll", "arm64-raw-mla.o", ll)
+		})
+	}
+}
+
+func TestARM64RawMLARuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawmla(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD inout+16(FP), R2
+	VLD1 (R0), [V8.H8]
+	VLD1 (R1), [V7.H8]
+	VLD1 (R2), [V2.H8]
+	WORD $0x4e679502 // MLA V2.8H, V8.8H, V7.8H
+	VST1 [V2.H8], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawmla": {
+				Name: "rawmla", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmla(const uint16_t *, const uint16_t *, uint16_t *);
+int main(void) {
+  const uint16_t a[8] = {0,1,65535,32768,2,3,4,5};
+  const uint16_t b[8] = {7,65535,3,2,9,10,11,12};
+	const uint16_t initial[8] = {9,9,9,9,65000,65000,65000,65000};
+	uint16_t got[8];
+	for (int i = 0; i < 8; i++) got[i] = initial[i];
+  rawmla(a, b, got);
+  for (int i = 0; i < 8; i++) {
+	uint16_t want = (uint16_t)(initial[i] + (uint16_t)(a[i] * b[i]));
+	if (got[i] != want) return i + 1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_mla", triple, ll, mainC, nil)
+}
+
+func TestARM64RawMLADecoderRejectsAdjacentMLSEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawMLA(0x2e229420); ok {
+		t.Fatal("MLA decoder accepted adjacent MLS encoding")
+	}
+}
diff --git a/arm64_lower_word_mls.go b/arm64_lower_word_mls.go
new file mode 100644
index 000000000..48e2fbf72
--- /dev/null
+++ b/arm64_lower_word_mls.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "fmt"
+
+func decodeARM64RawMLS(word uint32) (arm64RawMUL, bool) {
+	form := arm64RawMUL{element: -1}
+	switch {
+	case word&0xbf20fc00 == 0x2e209400: // vector, three same
+	case word&0xbf00f400 == 0x2f004000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawMUL{}, false
+	}
+	return decodeARM64MultiplyVectorOperands(word, form)
+}
+
+func (c *arm64Ctx) lowerRawMLS(form arm64RawMUL) error {
+	return c.lowerRawMultiplyAccumulate(form, "sub")
+}
+
+func (c *arm64Ctx) lowerRawMultiplyAccumulate(form arm64RawMUL, operation string) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.arrangement, 0, false)
+	if err != nil {
+		return err
+	}
+	secondLane := 0
+	if form.byElement {
+		secondLane = form.element
+	}
+	second, err := c.loadRawARM64VectorOperand(form.second, form.arrangement, secondLane, form.byElement)
+	if err != nil {
+		return err
+	}
+	accumulator, err := c.loadRawARM64VectorOperand(form.destination, form.arrangement, 0, false)
+	if err != nil {
+		return err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", form.arrangement.lanes, form.arrangement.elementBits)
+	product := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, vectorType, first, second)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %s, %%%s\n", result, operation, vectorType, accumulator, product)
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, "%"+result, false)
+}
diff --git a/arm64_lower_word_mls_test.go b/arm64_lower_word_mls_test.go
new file mode 100644
index 000000000..74acd8e3a
--- /dev/null
+++ b/arm64_lower_word_mls_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawMLSForms = `
+TEXT rawmlsforms(SB),$0-0
+	WORD $0x2e229420 // MLS V0.8B, V1.8B, V2.8B
+	WORD $0x6e259483 // MLS V3.16B, V4.16B, V5.16B
+	WORD $0x2e6894e6 // MLS V6.4H, V7.4H, V8.4H
+	WORD $0x6e6b9549 // MLS V9.8H, V10.8H, V11.8H
+	WORD $0x2eae95ac // MLS V12.2S, V13.2S, V14.2S
+	WORD $0x6eb1960f // MLS V15.4S, V16.4S, V17.4S
+	WORD $0x2f744a72 // MLS V18.4H, V19.4H, V4.H[7]
+	WORD $0x6f754ab4 // MLS V20.8H, V21.8H, V5.H[7]
+	WORD $0x2fb84af6 // MLS V22.2S, V23.2S, V24.S[3]
+	WORD $0x6fbb4b59 // MLS V25.4S, V26.4S, V27.S[3]
+	RET
+`
+
+func TestTranslateARM64RawMLSCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawMLSForms, true)
+	file, err := Parse(ArchARM64, arm64RawMLSForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawmlsforms": {Name: "rawmlsforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"mul <8 x i8>", "mul <16 x i8>",
+				"mul <4 x i16>", "mul <8 x i16>",
+				"mul <2 x i32>", "mul <4 x i32>",
+				"sub <8 x i8>", "sub <4 x i32>",
+				"extractelement <8 x i16>", "extractelement <4 x i32>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw MLS lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-mls.ll", "arm64-raw-mls.o", ll)
+		})
+	}
+}
+
+func TestARM64RawMLSRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawmls(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD inout+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	VLD1 (R2), [V2.S4]
+	WORD $0x6ea19402 // MLS V2.4S, V0.4S, V1.4S
+	VST1 [V2.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawmls": {
+				Name: "rawmls", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmls(const uint32_t *, const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t a[4] = {0, 1, 0xffffffffu, 0x80000000u};
+  const uint32_t b[4] = {7, 0xffffffffu, 3, 2};
+  uint32_t got[4] = {9, 9, 9, 9};
+  const uint32_t want[4] = {9, 10, 12, 9};
+  rawmls(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_mls", triple, ll, mainC, nil)
+}
+
+func TestARM64RawMLSDecoderRejectsAdjacentMLAEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawMLS(0x0e229420); ok {
+		t.Fatal("MLS decoder accepted adjacent MLA encoding")
+	}
+}
diff --git a/arm64_lower_word_modified_immediate.go b/arm64_lower_word_modified_immediate.go
new file mode 100644
index 000000000..f4e4e4d5d
--- /dev/null
+++ b/arm64_lower_word_modified_immediate.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawModifiedImmediate struct {
+	op          Op
+	arrangement arm64VectorArrangement
+	immediate   byte
+	value       uint64
+	destination int
+}
+
+func decodeARM64RawModifiedImmediate(word uint32) (arm64RawModifiedImmediate, bool) {
+	// Advanced SIMD modified immediate. Keep the fixed class and o2 bit, while
+	// allowing Q, op, cmode, imm8, and Rd to be interpreted below.
+	if word&0x9ff80c00 != 0x0f000400 {
+		return arm64RawModifiedImmediate{}, false
+	}
+	opBit := word&(1<<29) != 0
+	cmode := int(word>>12) & 15
+	immediate := byte(((word >> 16) & 7 << 5) | ((word >> 5) & 31))
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+
+	form := arm64RawModifiedImmediate{op: "VMOVI", immediate: immediate, destination: int(word) & 31}
+	var value uint64
+	if cmode < 12 && cmode&1 != 0 {
+		// Odd cmodes are the ORR/BIC modified-immediate family. The same
+		// imm8/shift grammar applies to both Q widths and all S/H lanes.
+		if cmode < 8 {
+			form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: vectorBits / 32}
+			value = uint64(uint32(immediate) << uint((cmode-1)/2*8))
+		} else {
+			form.arrangement = arm64VectorArrangement{elementBits: 16, lanes: vectorBits / 16}
+			value = uint64(uint16(immediate) << uint((cmode-9)/2*8))
+		}
+		form.op = "VORR"
+		if opBit {
+			form.op = "VBIC"
+		}
+		form.value = value
+		return form, true
+	}
+	switch cmode {
+	case 0, 2, 4, 6:
+		form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: vectorBits / 32}
+		value = uint64(uint32(immediate) << uint(cmode/2*8))
+	case 8, 10:
+		form.arrangement = arm64VectorArrangement{elementBits: 16, lanes: vectorBits / 16}
+		value = uint64(uint16(immediate) << uint((cmode-8)/2*8))
+	case 12:
+		form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: vectorBits / 32}
+		value = uint64(uint32(immediate)<<8 | 0xff)
+	case 13:
+		form.arrangement = arm64VectorArrangement{elementBits: 32, lanes: vectorBits / 32}
+		value = uint64(uint32(immediate)<<16 | 0xffff)
+	case 14:
+		if !opBit {
+			form.arrangement = arm64VectorArrangement{elementBits: 8, lanes: vectorBits / 8}
+			value = uint64(immediate)
+			break
+		}
+		form.arrangement = arm64VectorArrangement{elementBits: 64, lanes: vectorBits / 64}
+		for bit := 0; bit < 8; bit++ {
+			if immediate&(1<<bit) != 0 {
+				value |= uint64(0xff) << (bit * 8)
+			}
+		}
+		form.value = value
+		return form, true
+	default:
+		// cmode 15 encodes floating-point immediates, a neighboring family.
+		return arm64RawModifiedImmediate{}, false
+	}
+
+	if opBit {
+		form.op = "VMVNI"
+		switch form.arrangement.elementBits {
+		case 16:
+			value = uint64(^uint16(value))
+		case 32:
+			value = uint64(^uint32(value))
+		default:
+			return arm64RawModifiedImmediate{}, false
+		}
+	}
+	form.value = value
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawModifiedImmediate(form arm64RawModifiedImmediate) error {
+	destination := Reg(fmt.Sprintf("V%d", form.destination))
+	if form.op == "VORR" || form.op == "VBIC" {
+		old, err := c.loadARM64VectorInteger(destination, form.arrangement)
+		if err != nil {
+			return err
+		}
+		operation := "or"
+		value := form.value
+		if form.op == "VBIC" {
+			operation = "and"
+			laneMask := (uint64(1) << uint(form.arrangement.elementBits)) - 1
+			value = ^value & laneMask
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %s, %s\n", result, operation,
+			form.arrangement.lanes, form.arrangement.elementBits, old,
+			arm64VectorIntegerSplat(form.arrangement, int64(value)))
+		return c.storeARM64VectorInteger(destination, form.arrangement, "%"+result)
+	}
+	value := arm64VectorIntegerSplat(form.arrangement, int64(form.value))
+	if err := c.storeARM64VectorInteger(destination, form.arrangement, value); err != nil {
+		return fmt.Errorf("lower ARM64 raw %s: %w", form.op, err)
+	}
+	return nil
+}
diff --git a/arm64_lower_word_modified_immediate_test.go b/arm64_lower_word_modified_immediate_test.go
new file mode 100644
index 000000000..9fb1a32ba
--- /dev/null
+++ b/arm64_lower_word_modified_immediate_test.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawModifiedImmediateTestForm struct {
+	op          Op
+	opBit       uint32
+	cmode       uint32
+	q           uint32
+	arrangement arm64VectorArrangement
+}
+
+func arm64RawMOVIMVNIForms() []arm64RawModifiedImmediateTestForm {
+	var forms []arm64RawModifiedImmediateTestForm
+	addQForms := func(op Op, opBit, cmode uint32, elementBits int) {
+		for _, q := range []uint32{0, 1} {
+			vectorBits := 64
+			if q != 0 {
+				vectorBits = 128
+			}
+			forms = append(forms, arm64RawModifiedImmediateTestForm{
+				op: op, opBit: opBit, cmode: cmode, q: q,
+				arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: vectorBits / elementBits},
+			})
+		}
+	}
+	for _, cmode := range []uint32{0, 2, 4, 6, 12, 13} { // S LSL and MSL forms.
+		addQForms("VMOVI", 0, cmode, 32)
+		addQForms("VMVNI", 1, cmode, 32)
+	}
+	for _, cmode := range []uint32{8, 10} { // H LSL forms.
+		addQForms("VMOVI", 0, cmode, 16)
+		addQForms("VMVNI", 1, cmode, 16)
+	}
+	addQForms("VMOVI", 0, 14, 8) // B replicated immediate.
+	forms = append(forms,
+		arm64RawModifiedImmediateTestForm{op: "VMOVI", opBit: 1, cmode: 14, q: 0, arrangement: arm64VectorArrangement{elementBits: 64, lanes: 1}},
+		arm64RawModifiedImmediateTestForm{op: "VMOVI", opBit: 1, cmode: 14, q: 1, arrangement: arm64VectorArrangement{elementBits: 64, lanes: 2}},
+	)
+	return forms
+}
+
+func arm64RawORRBICForms() []arm64RawModifiedImmediateTestForm {
+	var forms []arm64RawModifiedImmediateTestForm
+	for _, op := range []struct {
+		name  Op
+		opBit uint32
+	}{{"VORR", 0}, {"VBIC", 1}} {
+		for _, cmode := range []uint32{1, 3, 5, 7, 9, 11} {
+			bits := 32
+			if cmode >= 8 {
+				bits = 16
+			}
+			for _, q := range []uint32{0, 1} {
+				vectorBits := 64
+				if q != 0 {
+					vectorBits = 128
+				}
+				forms = append(forms, arm64RawModifiedImmediateTestForm{
+					op: op.name, opBit: op.opBit, cmode: cmode, q: q,
+					arrangement: arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits},
+				})
+			}
+		}
+	}
+	return forms
+}
+
+func encodeARM64RawModifiedImmediate(opBit, cmode, q uint32, immediate byte, destination int) uint32 {
+	return 0x0f000400 | q<<30 | opBit<<29 | uint32(immediate>>5)<<16 | cmode<<12 | uint32(immediate&31)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64RawMOVIMVNICompleteAdvancedSIMDFormats(t *testing.T) {
+	forms := arm64RawMOVIMVNIForms()
+	if len(forms) != 36 {
+		t.Fatalf("MOVI/MVNI format inventory has %d forms, want 36", len(forms))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawmodifiedimmediateforms(SB),$0-0\n")
+	for i, form := range forms {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawModifiedImmediate(form.opBit, form.cmode, form.q, 0x92, i%32))
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawmodifiedimmediateforms": {Name: "rawmodifiedimmediateforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-modified-immediate.ll", "arm64-raw-modified-immediate.o", ll)
+		})
+	}
+}
+
+func TestARM64RawMOVIMVNIDecoderCoversEveryImmediate(t *testing.T) {
+	for _, form := range arm64RawMOVIMVNIForms() {
+		for immediate := 0; immediate <= 255; immediate++ {
+			word := encodeARM64RawModifiedImmediate(form.opBit, form.cmode, form.q, byte(immediate), 17)
+			got, ok := decodeARM64RawModifiedImmediate(word)
+			if !ok {
+				t.Fatalf("decoder rejected %s cmode=%d Q=%d immediate=%#02x word=%#08x", form.op, form.cmode, form.q, immediate, word)
+			}
+			if got.op != form.op || got.arrangement != form.arrangement || got.destination != 17 {
+				t.Fatalf("decoded word %#08x as %+v, want op=%s arrangement=%+v destination=17", word, got, form.op, form.arrangement)
+			}
+		}
+	}
+}
+
+func TestTranslateARM64RawORRBICCompleteAdvancedSIMDFormats(t *testing.T) {
+	forms := arm64RawORRBICForms()
+	if len(forms) != 24 {
+		t.Fatalf("ORR/BIC immediate format inventory has %d forms, want 24", len(forms))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT raworrbicforms(SB),$0-0\n")
+	for i, form := range forms {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawModifiedImmediate(form.opBit, form.cmode, form.q, 0x92, i%32))
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"raworrbicforms": {Name: "raworrbicforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"and <2 x i32>", "or <2 x i32>", "and <8 x i16>", "or <8 x i16>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("missing %q in %s:\n%s", want, triple, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-orr-bic-immediate.ll", "arm64-orr-bic-immediate.o", ll)
+		})
+	}
+}
+
+func TestARM64RawORRBICDecoderCoversEveryImmediate(t *testing.T) {
+	for _, form := range arm64RawORRBICForms() {
+		for immediate := 0; immediate <= 255; immediate++ {
+			word := encodeARM64RawModifiedImmediate(form.opBit, form.cmode, form.q, byte(immediate), 17)
+			got, ok := decodeARM64RawModifiedImmediate(word)
+			if !ok || got.op != form.op || got.arrangement != form.arrangement || got.destination != 17 {
+				t.Fatalf("decoded %s cmode=%d Q=%d immediate=%#02x word=%#08x as %+v, ok=%v",
+					form.op, form.cmode, form.q, immediate, word, got, ok)
+			}
+		}
+	}
+}
+
+func TestARM64RawORRBICRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT raworrbic(SB),$0-8\n\tMOVD out+0(FP), R0\n")
+	for _, step := range []struct {
+		opBit, cmode, q uint32
+		immediate       byte
+		destination     int
+	}{
+		{0, 14, 1, 0x00, 0}, // Initialize V0 to zero.
+		{0, 14, 1, 0x0f, 1}, // Initialize V1 to 0x0f bytes.
+		{0, 3, 1, 0x55, 0},  // ORR 0x55 << 8 in every S lane.
+		{1, 3, 1, 0x11, 0},  // BIC 0x11 << 8, leaving 0x44.
+		{0, 9, 1, 0x80, 1},  // ORR 0x80 in every H lane.
+		{1, 9, 1, 0x08, 1},  // BIC 0x08, leaving 0x87.
+	} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawModifiedImmediate(step.opBit, step.cmode, step.q, step.immediate, step.destination))
+	}
+	source.WriteString("\tVST1 [V0.B16, V1.B16], (R0)\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"raworrbic": {
+			Name: "raworrbic", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void raworrbic(uint8_t *);
+int main(void) {
+  uint8_t got[32] = {0};
+  raworrbic(got);
+  for (int i = 0; i < 16; i++) {
+    if (got[i] != ((i & 3) == 1 ? 0x44 : 0)) return i + 1;
+    if (got[16+i] != ((i & 1) == 0 ? 0x87 : 0x0f)) return i + 17;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_orr_bic", triple, ll, mainC, nil)
+}
+
+func TestARM64RawMOVIMVNIRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	tests := []struct{ opBit, cmode, q uint32 }{
+		{0, 14, 1}, // MOVI B16.
+		{0, 10, 1}, // MOVI H8, LSL #8.
+		{0, 6, 1},  // MOVI S4, LSL #24.
+		{0, 12, 1}, // MOVI S4, MSL #8.
+		{0, 13, 1}, // MOVI S4, MSL #16.
+		{1, 10, 1}, // MVNI H8, LSL #8.
+		{1, 13, 1}, // MVNI S4, MSL #16.
+		{1, 14, 1}, // MOVI D2 byte mask.
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawmodifiedimmediate(SB),$0-8\n\tMOVD out+0(FP), R0\n")
+	for destination, test := range tests {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawModifiedImmediate(test.opBit, test.cmode, test.q, 0x12, destination))
+	}
+	source.WriteString("\tVST1.P [V0.B16, V1.B16, V2.B16, V3.B16], 64(R0)\n\tVST1 [V4.B16, V5.B16, V6.B16, V7.B16], (R0)\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawmodifiedimmediate": {
+			Name: "rawmodifiedimmediate", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmodifiedimmediate(uint8_t *);
+int main(void) {
+  uint8_t got[128] = {0};
+  rawmodifiedimmediate(got);
+  for (int i = 0; i < 16; i++) {
+    const uint8_t want[8] = {
+      0x12,
+      (i&1) ? 0x12 : 0x00,
+      (i&3) == 3 ? 0x12 : 0x00,
+      (i&3) == 0 ? 0xff : (i&3) == 1 ? 0x12 : 0x00,
+      (i&3) < 2 ? 0xff : (i&3) == 2 ? 0x12 : 0x00,
+      (i&1) ? 0xed : 0xff,
+      (i&3) < 2 ? 0x00 : (i&3) == 2 ? 0xed : 0xff,
+	      (0x12u & (1u << (i&7))) ? 0xff : 0x00,
+    };
+    for (int op = 0; op < 8; op++) if (got[op*16+i] != want[op]) return op*16+i+1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_modified_immediate", triple, ll, mainC, nil)
+}
+
+func TestARM64RawModifiedImmediateDecoderRejectsFloatingNeighbor(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARM64RawModifiedImmediate(0, 15, 1, 1, 0), // FMOV immediate.
+		encodeARM64RawModifiedImmediate(1, 15, 0, 1, 0), // Reserved encoding.
+	} {
+		if _, ok := decodeARM64RawModifiedImmediate(word); ok {
+			t.Fatalf("modified-immediate decoder accepted neighboring encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_move_wide.go b/arm64_lower_word_move_wide.go
new file mode 100644
index 000000000..d853243d7
--- /dev/null
+++ b/arm64_lower_word_move_wide.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawMoveWide struct {
+	op          Op
+	width       int
+	shift       int
+	immediate   uint16
+	destination int
+}
+
+func decodeARM64RawMoveWide(word uint32) (arm64RawMoveWide, bool) {
+	if word&0x1f800000 != 0x12800000 {
+		return arm64RawMoveWide{}, false
+	}
+	var op Op
+	switch (word >> 29) & 3 {
+	case 0:
+		op = "MOVN"
+	case 2:
+		op = "MOVZ"
+	case 3:
+		op = "MOVK"
+	default:
+		return arm64RawMoveWide{}, false
+	}
+	width := 32
+	if word&(1<<31) != 0 {
+		width = 64
+	}
+	halfword := int(word>>21) & 3
+	if width == 32 && halfword > 1 {
+		return arm64RawMoveWide{}, false
+	}
+	return arm64RawMoveWide{
+		op:          op,
+		width:       width,
+		shift:       halfword * 16,
+		immediate:   uint16(word >> 5),
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawMoveWide(form arm64RawMoveWide) error {
+	// Rd=31 denotes WZR/XZR for this encoding class.
+	if form.destination == 31 {
+		return nil
+	}
+	widthMask := uint64(0xffffffff)
+	if form.width == 64 {
+		widthMask = ^uint64(0)
+	}
+	field := uint64(form.immediate) << form.shift
+	reg := Reg(fmt.Sprintf("R%d", form.destination))
+	switch form.op {
+	case "MOVZ":
+		return c.storeReg(reg, fmt.Sprintf("%d", field))
+	case "MOVN":
+		return c.storeReg(reg, fmt.Sprintf("%d", (^field)&widthMask))
+	case "MOVK":
+		old, err := c.loadReg(reg)
+		if err != nil {
+			return err
+		}
+		if form.width == 32 {
+			narrow, kept, result, wide := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, old)
+			fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %d\n", kept, narrow, ^(uint32(0xffff) << form.shift))
+			fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %d\n", result, kept, uint32(field))
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", wide, result)
+			return c.storeReg(reg, "%"+wide)
+		}
+		preserveMask := widthMask & ^(uint64(0xffff) << form.shift)
+		preserved := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", preserved, old, preserveMask)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %d\n", result, preserved, field)
+		return c.storeReg(reg, "%"+result)
+	default:
+		return fmt.Errorf("unknown ARM64 raw move-wide operation %s", form.op)
+	}
+}
diff --git a/arm64_lower_word_move_wide_test.go b/arm64_lower_word_move_wide_test.go
new file mode 100644
index 000000000..66fe61669
--- /dev/null
+++ b/arm64_lower_word_move_wide_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawMoveWideTestForm struct {
+	op    Op
+	opc   uint32
+	width int
+	shift int
+}
+
+func arm64RawMoveWideForms() []arm64RawMoveWideTestForm {
+	var forms []arm64RawMoveWideTestForm
+	for _, operation := range []struct {
+		op  Op
+		opc uint32
+	}{{"MOVN", 0}, {"MOVZ", 2}, {"MOVK", 3}} {
+		for _, width := range []int{32, 64} {
+			maxShift := width - 16
+			for shift := 0; shift <= maxShift; shift += 16 {
+				forms = append(forms, arm64RawMoveWideTestForm{op: operation.op, opc: operation.opc, width: width, shift: shift})
+			}
+		}
+	}
+	return forms
+}
+
+func encodeARM64RawMoveWide(opc uint32, width, shift int, immediate uint16, destination int) uint32 {
+	word := uint32(0x12800000) | opc<<29 | uint32(shift/16)<<21 | uint32(immediate)<<5 | uint32(destination)
+	if width == 64 {
+		word |= 1 << 31
+	}
+	return word
+}
+
+func TestTranslateARM64RawMoveWideCompleteFormats(t *testing.T) {
+	forms := arm64RawMoveWideForms()
+	if len(forms) != 18 {
+		t.Fatalf("move-wide format inventory has %d forms, want 18", len(forms))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawmovewideforms(SB),$0-0\n")
+	for i, form := range forms {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawMoveWide(form.opc, form.width, form.shift, 0xa55a, i%31))
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawmovewideforms": {Name: "rawmovewideforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-move-wide.ll", "arm64-raw-move-wide.o", ll)
+		})
+	}
+}
+
+func TestARM64RawMoveWideDecoderCoversEveryImmediate(t *testing.T) {
+	for _, form := range arm64RawMoveWideForms() {
+		for immediate := 0; immediate <= 0xffff; immediate++ {
+			word := encodeARM64RawMoveWide(form.opc, form.width, form.shift, uint16(immediate), 17)
+			got, ok := decodeARM64RawMoveWide(word)
+			if !ok {
+				t.Fatalf("decoder rejected %s width=%d shift=%d immediate=%#04x", form.op, form.width, form.shift, immediate)
+			}
+			if got.op != form.op || got.width != form.width || got.shift != form.shift || got.immediate != uint16(immediate) || got.destination != 17 {
+				t.Fatalf("decoded word %#08x as %+v, want %+v immediate=%#04x destination=17", word, got, form, immediate)
+			}
+		}
+	}
+}
+
+func TestARM64RawMoveWideRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawmovewide(SB),$0-16\n\tMOVD out+0(FP), R0\n\tMOVD initial+8(FP), R1\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawMoveWide(2, 64, 32, 0x1234, 2)) // MOVZ X2, #0x1234, LSL #32.
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawMoveWide(0, 32, 16, 0x00ff, 3)) // MOVN W3, #0x00ff, LSL #16.
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawMoveWide(3, 64, 16, 0xabcd, 1)) // MOVK X1, #0xabcd, LSL #16.
+	source.WriteString("\tMOVD R2, 0(R0)\n\tMOVD R3, 8(R0)\n\tMOVD R1, 16(R0)\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawmovewide": {
+			Name: "rawmovewide", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmovewide(uint64_t *, uint64_t);
+int main(void) {
+  uint64_t got[3] = {0};
+  rawmovewide(got, UINT64_C(0x0123456789abcdef));
+  if (got[0] != UINT64_C(0x0000123400000000)) return 1;
+  if (got[1] != UINT64_C(0x00000000ff00ffff)) return 2;
+  if (got[2] != UINT64_C(0x01234567abcdcdef)) return 3;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_move_wide", triple, ll, mainC, nil)
+}
+
+func TestARM64RawMoveWideDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARM64RawMoveWide(1, 64, 0, 1, 0),  // reserved opc.
+		encodeARM64RawMoveWide(2, 32, 32, 1, 0), // reserved W shift.
+		0x12000000,                              // AND immediate.
+	} {
+		if _, ok := decodeARM64RawMoveWide(word); ok {
+			t.Fatalf("move-wide decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_mul.go b/arm64_lower_word_mul.go
new file mode 100644
index 000000000..c895fbe9a
--- /dev/null
+++ b/arm64_lower_word_mul.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawMUL struct {
+	byElement   bool
+	arrangement arm64VectorArrangement
+	destination int
+	first       int
+	second      int
+	element     int
+}
+
+func decodeARM64RawMUL(word uint32) (arm64RawMUL, bool) {
+	form := arm64RawMUL{element: -1}
+	switch {
+	case word&0xbf20fc00 == 0x0e209c00: // vector, three same
+	case word&0xbf00f400 == 0x0f008000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawMUL{}, false
+	}
+	return decodeARM64MultiplyVectorOperands(word, form)
+}
+
+func decodeARM64MultiplyVectorOperands(word uint32, form arm64RawMUL) (arm64RawMUL, bool) {
+	size := int(word>>22) & 3
+	if form.byElement {
+		if size != 1 && size != 2 {
+			return arm64RawMUL{}, false
+		}
+	} else if size > 2 {
+		return arm64RawMUL{}, false
+	}
+	bits := 8 << size
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	form.arrangement = arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits}
+	form.destination = int(word & 31)
+	form.first = int(word>>5) & 31
+	form.second = int(word>>16) & 31
+	if form.byElement {
+		element := decodeARM64MultiplyIndexedElement(word, bits)
+		form.second, form.element = element.register, element.lane
+	}
+	return form, true
+}
+
+type arm64MultiplyIndexedElement struct {
+	register int
+	lane     int
+}
+
+// All callers validate H/S size first. Arm DDI 0602 uses H:L:M for halfword
+// lane indices, H:L for word indices, and M:Rm for the word source register.
+func decodeARM64MultiplyIndexedElement(word uint32, bits int) arm64MultiplyIndexedElement {
+	h := int(word>>11) & 1
+	l := int(word>>21) & 1
+	m := int(word>>20) & 1
+	reg := int(word>>16) & 15
+	if bits == 16 {
+		return arm64MultiplyIndexedElement{register: reg, lane: h<<2 | l<<1 | m}
+	}
+	return arm64MultiplyIndexedElement{register: m<<4 | reg, lane: h<<1 | l}
+}
+
+func (c *arm64Ctx) lowerRawMUL(form arm64RawMUL) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.arrangement, 0, false)
+	if err != nil {
+		return err
+	}
+	secondLane := 0
+	if form.byElement {
+		secondLane = form.element
+	}
+	second, err := c.loadRawARM64VectorOperand(form.second, form.arrangement, secondLane, form.byElement)
+	if err != nil {
+		return err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", form.arrangement.lanes, form.arrangement.elementBits)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, vectorType, first, second)
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, "%"+product, false)
+}
diff --git a/arm64_lower_word_mul_test.go b/arm64_lower_word_mul_test.go
new file mode 100644
index 000000000..fccba3703
--- /dev/null
+++ b/arm64_lower_word_mul_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Integer MUL has six same-vector forms and four by-element forms in the
+// Advanced SIMD ISA. Go's VMUL mnemonic covers the former; raw WORD users can
+// encode both groups, so the raw decoder must cover the complete family.
+const arm64RawMULForms = `
+TEXT rawmulforms(SB),$0-0
+	WORD $0x0e229c20 // MUL V0.8B, V1.8B, V2.8B
+	WORD $0x4e259c83 // MUL V3.16B, V4.16B, V5.16B
+	WORD $0x0e689ce6 // MUL V6.4H, V7.4H, V8.4H
+	WORD $0x4e6b9d49 // MUL V9.8H, V10.8H, V11.8H
+	WORD $0x0eae9dac // MUL V12.2S, V13.2S, V14.2S
+	WORD $0x4eb19e0f // MUL V15.4S, V16.4S, V17.4S
+	WORD $0x0f748a72 // MUL V18.4H, V19.4H, V4.H[7]
+	WORD $0x4f758ab4 // MUL V20.8H, V21.8H, V5.H[7]
+	WORD $0x0fb88af6 // MUL V22.2S, V23.2S, V24.S[3]
+	WORD $0x4fbb8b59 // MUL V25.4S, V26.4S, V27.S[3]
+	RET
+`
+
+func TestTranslateARM64RawMULCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawMULForms, true)
+	file, err := Parse(ArchARM64, arm64RawMULForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawmulforms": {Name: "rawmulforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"mul <8 x i8>", "mul <16 x i8>",
+				"mul <4 x i16>", "mul <8 x i16>",
+				"mul <2 x i32>", "mul <4 x i32>",
+				"extractelement <8 x i16>", "extractelement <4 x i32>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw MUL lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-mul.ll", "arm64-raw-mul.o", ll)
+		})
+	}
+}
+
+func TestARM64RawMULRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawmul(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4ea19c02 // MUL V2.4S, V0.4S, V1.4S
+	VST1 [V2.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawmul": {
+				Name: "rawmul", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawmul(const uint32_t *, const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t a[4] = {0, 1, 0xffffffffu, 0x80000000u};
+  const uint32_t b[4] = {7, 0xffffffffu, 3, 2};
+  uint32_t got[4] = {0};
+  const uint32_t want[4] = {0, 0xffffffffu, 0xfffffffdu, 0};
+  rawmul(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_mul", triple, ll, mainC, nil)
+}
+
+func TestARM64RawMULDecoderRejectsAdjacentEncoding(t *testing.T) {
+	// PMUL shares much of the three-same encoding space but has polynomial,
+	// rather than integer, multiplication semantics.
+	if _, ok := decodeARM64RawMUL(0x2e229c20); ok {
+		t.Fatal("MUL decoder claimed adjacent PMUL encoding")
+	}
+}
diff --git a/arm64_lower_word_pairwise_add_long_test.go b/arm64_lower_word_pairwise_add_long_test.go
new file mode 100644
index 000000000..4bd73a337
--- /dev/null
+++ b/arm64_lower_word_pairwise_add_long_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawPairwiseAddLongCompleteArchitecturalFormats(t *testing.T) {
+	bases := []uint32{
+		0x0e202800, // SADDLP.
+		0x2e202800, // UADDLP.
+		0x0e206800, // SADALP.
+		0x2e206800, // UADALP.
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawpairwiseaddlongforms(SB),$0-0\n")
+	for _, base := range bases {
+		for size := uint32(0); size < 3; size++ {
+			for q := uint32(0); q < 2; q++ {
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", base|size<<22|q<<30|31<<5|30)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{
+					"rawpairwiseaddlongforms": {Name: "rawpairwiseaddlongforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-pairwise-add-long.ll", "arm64-raw-pairwise-add-long.o", ir)
+		})
+	}
+}
+
+func TestARM64RawPairwiseAddLongDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0ee02800, // SADDLP reserved 64-bit source elements.
+		0x2ee02800, // UADDLP reserved 64-bit source elements.
+		0x0ee06800, // SADALP reserved 64-bit source elements.
+		0x2ee06800, // UADALP reserved 64-bit source elements.
+		0x0e202c00, // adjacent opcode bits.
+		0x0e203800, // SADDV.
+	} {
+		if _, ok := decodeARM64RawPairwiseAddLong(word); ok {
+			t.Fatalf("pairwise-add-long decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawPairwiseAddLongRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawpairwiseaddlong(SB),$0-24
+	MOVD input+0(FP), R0
+	MOVD accumulator+8(FP), R1
+	MOVD output+16(FP), R2
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V4.H8]
+	VLD1 (R1), [V5.H8]
+	WORD $0x4e202801 // SADDLP V1.8H, V0.16B
+	WORD $0x6e202802 // UADDLP V2.8H, V0.16B
+	WORD $0x4e206804 // SADALP V4.8H, V0.16B
+	WORD $0x6e206805 // UADALP V5.8H, V0.16B
+	VST1.P [V1.H8], 16(R2)
+	VST1.P [V2.H8], 16(R2)
+	VST1.P [V4.H8], 16(R2)
+	VST1 [V5.H8], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawpairwiseaddlong": {
+				Name: "rawpairwiseaddlong", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawpairwiseaddlong(const uint8_t *, const int16_t *, int16_t *);
+int main(void) {
+  const uint8_t input[16] = {255,1,2,3,128,127,254,255,10,20,30,40,50,60,70,80};
+  const int16_t accumulator[8] = {100,100,100,100,100,100,100,100};
+  const int16_t signed_sum[8] = {0,5,-1,-3,30,70,110,150};
+  const int16_t unsigned_sum[8] = {256,5,255,509,30,70,110,150};
+  int16_t got[32] = {0};
+  rawpairwiseaddlong(input, accumulator, got);
+  for (int lane = 0; lane < 8; lane++) {
+    if (got[lane] != signed_sum[lane]) return 1 + lane;
+    if (got[8 + lane] != unsigned_sum[lane]) return 10 + lane;
+    if (got[16 + lane] != signed_sum[lane] + 100) return 20 + lane;
+    if (got[24 + lane] != unsigned_sum[lane] + 100) return 30 + lane;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_pairwise_add_long", triple, ir, mainC, nil)
+}
diff --git a/arm64_lower_word_rdma.go b/arm64_lower_word_rdma.go
new file mode 100644
index 000000000..f57aa0437
--- /dev/null
+++ b/arm64_lower_word_rdma.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawRDMASpec struct {
+	base      uint32
+	mask      uint32
+	intrinsic string
+	scalar    bool
+	byElement bool
+}
+
+// Go names the SVE ZSQRDMLAH/ZSQRDMLSH forms, but exposes all fixed-width
+// FEAT_RDM forms only through WORD. Arm DDI 0602 defines the same register,
+// size, and indexed-lane fields for both operations and all four shapes.
+var arm64RawRDMASpecs = [...]arm64RawRDMASpec{
+	{0x2e008400, 0xbf20fc00, "sqrdmlah", false, false},
+	{0x2e008c00, 0xbf20fc00, "sqrdmlsh", false, false},
+	{0x7e008400, 0xff20fc00, "sqrdmlah", true, false},
+	{0x7e008c00, 0xff20fc00, "sqrdmlsh", true, false},
+	{0x2f00d000, 0xbf00f400, "sqrdmlah", false, true},
+	{0x2f00f000, 0xbf00f400, "sqrdmlsh", false, true},
+	{0x7f00d000, 0xff00f400, "sqrdmlah", true, true},
+	{0x7f00f000, 0xff00f400, "sqrdmlsh", true, true},
+}
+
+type arm64RawRDMA struct {
+	arm64RawSQDMULH
+	intrinsic string
+}
+
+func decodeARM64RawRDMA(word uint32) (arm64RawRDMA, bool) {
+	for _, spec := range arm64RawRDMASpecs {
+		if word&spec.mask != spec.base {
+			continue
+		}
+		operands, ok := decodeARM64MultiplyHighOperands(word, arm64RawSQDMULH{
+			scalar: spec.scalar, byElement: spec.byElement, element: -1,
+		})
+		if ok {
+			return arm64RawRDMA{arm64RawSQDMULH: operands, intrinsic: spec.intrinsic}, true
+		}
+	}
+	return arm64RawRDMA{}, false
+}
+
+func (c *arm64Ctx) lowerRawRDMA(form arm64RawRDMA) error {
+	arrangement := form.arrangement
+	accumulator, err := c.loadRawARM64VectorOperand(form.destination, arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	first, err := c.loadRawARM64VectorOperand(form.first, arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	secondLane := 0
+	if form.byElement {
+		secondLane = form.element
+	}
+	second, err := c.loadRawARM64VectorOperand(form.second, arrangement, secondLane, form.scalar || form.byElement)
+	if err != nil {
+		return err
+	}
+	if form.scalar {
+		return c.lowerRawRDMAScalar(form, accumulator, first, second)
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%di%d(%s %s, %s %s, %s %s)\n",
+		result, vectorType, form.intrinsic, arrangement.lanes, arrangement.elementBits,
+		vectorType, accumulator, vectorType, first, vectorType, second)
+	return c.storeRawARM64VectorResult(form.destination, arrangement, "%"+result, form.scalar)
+}
+
+// LLVM 22 cannot legalize the overloaded intrinsic on i16/i32 scalar values.
+// Use a wider integer than 2*elementBits so the shifted accumulator, doubled
+// product, and rounding addition remain exact even at the saturation edges.
+func (c *arm64Ctx) lowerRawRDMAScalar(form arm64RawRDMA, accumulator, first, second string) error {
+	bits := form.arrangement.elementBits
+	wideBits := bits * 4
+	wideType := fmt.Sprintf("i%d", wideBits)
+	values := []string{accumulator, first, second}
+	for index, value := range values {
+		extracted := c.newTmp()
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", extracted, bits, value)
+		fmt.Fprintf(c.b, "  %%%s = sext i%d %%%s to %s\n", extended, bits, extracted, wideType)
+		values[index] = "%" + extended
+	}
+	shiftedAccumulator := c.newTmp()
+	product := c.newTmp()
+	doubled := c.newTmp()
+	combined := c.newTmp()
+	rounded := c.newTmp()
+	shifted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl %s %s, %d\n", shiftedAccumulator, wideType, values[0], bits)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %s, %s\n", product, wideType, values[1], values[2])
+	fmt.Fprintf(c.b, "  %%%s = shl %s %%%s, 1\n", doubled, wideType, product)
+	operation := "add"
+	if form.intrinsic == "sqrdmlsh" {
+		operation = "sub"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s, %%%s\n", combined, operation, wideType, shiftedAccumulator, doubled)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %d\n", rounded, wideType, combined, int64(1)<<(bits-1))
+	fmt.Fprintf(c.b, "  %%%s = ashr %s %%%s, %d\n", shifted, wideType, rounded, bits)
+
+	maximum := (int64(1) << (bits - 1)) - 1
+	minimum := -(int64(1) << (bits - 1))
+	above := c.newTmp()
+	below := c.newTmp()
+	clampedAbove := c.newTmp()
+	clamped := c.newTmp()
+	narrowed := c.newTmp()
+	inserted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt %s %%%s, %d\n", above, wideType, shifted, maximum)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt %s %%%s, %d\n", below, wideType, shifted, minimum)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %d, %s %%%s\n", clampedAbove, above, wideType, maximum, wideType, shifted)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %d, %s %%%s\n", clamped, below, wideType, minimum, wideType, clampedAbove)
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to i%d\n", narrowed, wideType, clamped, bits)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %%%s, i32 0\n", inserted, bits, bits, narrowed)
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, "%"+inserted, true)
+}
diff --git a/arm64_lower_word_rdma_test.go b/arm64_lower_word_rdma_test.go
new file mode 100644
index 000000000..1def66d0a
--- /dev/null
+++ b/arm64_lower_word_rdma_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RDMACase struct {
+	operation string
+	bits      int
+	lanes     int
+	scalar    bool
+	indexed   bool
+	index     int
+	line      string
+}
+
+func arm64RDMACases() []arm64RDMACase {
+	var cases []arm64RDMACase
+	for _, operation := range []string{"sqrdmlah", "sqrdmlsh"} {
+		for _, bits := range []int{16, 32} {
+			letter := "h"
+			if bits == 32 {
+				letter = "s"
+			}
+			for _, lanes := range []int{0, 64 / bits, 128 / bits} {
+				for _, indexed := range []bool{false, true} {
+					indexes := []int{-1}
+					if indexed {
+						indexes = indexes[:0]
+						for index := 0; index < 128/bits; index++ {
+							indexes = append(indexes, index)
+						}
+					}
+					for _, index := range indexes {
+						first := letter + "1"
+						second := letter + "2"
+						destination := letter + "0"
+						if lanes != 0 {
+							first = fmt.Sprintf("v1.%d%s", lanes, letter)
+							second = fmt.Sprintf("v2.%d%s", lanes, letter)
+							destination = fmt.Sprintf("v0.%d%s", lanes, letter)
+						}
+						if indexed {
+							second = fmt.Sprintf("v2.%s[%d]", letter, index)
+						}
+						cases = append(cases, arm64RDMACase{
+							operation: operation, bits: bits, lanes: lanes,
+							scalar: lanes == 0, indexed: indexed, index: index,
+							line: fmt.Sprintf("%s %s, %s, %s", operation, destination, first, second),
+						})
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func TestARM64RawRDMACompleteForms(t *testing.T) {
+	cases := arm64RDMACases()
+	if len(cases) != 84 {
+		t.Fatalf("got %d forms and indexed lanes, want 84", len(cases))
+	}
+	lines := make([]string, 0, len(cases))
+	for _, tc := range cases {
+		lines = append(lines, tc.line)
+	}
+	words := assembleARM64LLVMWords(t, lines, "+rdm")
+	for i, tc := range cases {
+		decoded, ok := decodeARM64RawRDMA(words[i])
+		lanes := tc.lanes
+		if tc.scalar {
+			lanes = 1
+		}
+		if !ok || decoded.intrinsic != tc.operation || decoded.arrangement.elementBits != tc.bits ||
+			decoded.arrangement.lanes != lanes || decoded.scalar != tc.scalar ||
+			decoded.byElement != tc.indexed || decoded.element != tc.index ||
+			decoded.destination != 0 || decoded.first != 1 || decoded.second != 2 {
+			t.Errorf("%s (%#08x): decoded %+v, %v", tc.line, words[i], decoded, ok)
+		}
+	}
+	for _, boundary := range []struct {
+		line                       string
+		destination, first, second int
+		index                      int
+	}{
+		{"sqrdmlah v31.8h, v31.8h, v15.h[0]", 31, 31, 15, 0},
+		{"sqrdmlsh v31.8h, v31.8h, v15.h[7]", 31, 31, 15, 7},
+		{"sqrdmlah v31.4s, v31.4s, v31.s[0]", 31, 31, 31, 0},
+		{"sqrdmlsh v31.4s, v31.4s, v31.s[3]", 31, 31, 31, 3},
+		{"sqrdmlah h31, h31, v15.h[7]", 31, 31, 15, 7},
+		{"sqrdmlsh s31, s31, v31.s[3]", 31, 31, 31, 3},
+	} {
+		word := assembleARM64LLVMWords(t, []string{boundary.line}, "+rdm")[0]
+		decoded, ok := decodeARM64RawRDMA(word)
+		if !ok || decoded.destination != boundary.destination || decoded.first != boundary.first ||
+			decoded.second != boundary.second || decoded.element != boundary.index {
+			t.Errorf("%s (%#08x): decoded %+v, %v", boundary.line, word, decoded, ok)
+		}
+		words = append(words, word)
+	}
+	words = append(words, 0x6e5f86d5) // independently discovered gmsm encoding
+	if decoded, ok := decodeARM64RawRDMA(0x6e5f86d5); !ok ||
+		decoded.destination != 21 || decoded.first != 22 || decoded.second != 31 ||
+		decoded.arrangement.elementBits != 16 || decoded.arrangement.lanes != 8 {
+		t.Fatalf("gmsm encoding decoded as %+v, %v", decoded, ok)
+	}
+
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for i, word := range words {
+		name := fmt.Sprintf("rdmaform%d", i)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for reg := 0; reg < 32; reg++ {
+			fmt.Fprintf(&source, "VLD1 (R0),[V%d.B16]\n", reg)
+		}
+		fmt.Fprintf(&source, "WORD $%#08x\nVST1 [V%d.B16],(R1)\nRET\n", word, word&31)
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, feature := range []string{"+rdm", "llvm.aarch64.neon.sqrdmlah", "llvm.aarch64.neon.sqrdmlsh"} {
+				if !strings.Contains(ir, feature) {
+					t.Fatalf("IR missing %q", feature)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "rdma.ll", "rdma.o", ir)
+		})
+	}
+}
+
+func TestARM64RawRDMARejectsReservedSizesAndInventedNames(t *testing.T) {
+	for _, spec := range arm64RawRDMASpecs {
+		for _, size := range []uint32{0, 3} {
+			word := spec.base&^(3<<22) | size<<22
+			if decoded, ok := decodeARM64RawRDMA(word); ok {
+				t.Errorf("accepted reserved encoding %#08x as %+v", word, decoded)
+			}
+		}
+	}
+	for _, line := range []string{
+		"SQRDMLAH V0.H4, V1.H4, V2.H4",
+		"SQRDMLSH V0.S4, V1.S4, V2.S4",
+	} {
+		requireARM64GoAssemblerResult(t, "TEXT rdmaInvalid(SB),4,$0-0\n"+line+"\nRET\n", false)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RDMA(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("ARM64 native execution or required Linux cross-runtime matrix")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compiler := []string{findLLVM22Tool("clang")}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runner []string
+	if cross {
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		triple = "aarch64-unknown-linux-gnu"
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	file, sigs, oracle := arm64RDMAOracleProgram(t)
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "rdma", triple, ir, oracle, runner)
+}
+
+func arm64RDMAOracleProgram(t *testing.T) (*File, map[string]FuncSig, string) {
+	t.Helper()
+	cases := arm64RDMACases()
+	lines := make([]string, len(cases))
+	for index, tc := range cases {
+		lines[index] = tc.line
+	}
+	words := assembleARM64LLVMWords(t, lines, "+rdm")
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, tc := range cases {
+		name := fmt.Sprintf("rdmaoracle%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+		fmt.Fprint(&source, "MOVD acc+0(FP),R0\nMOVD a+8(FP),R1\nMOVD b+16(FP),R2\nMOVD out+24(FP),R3\n")
+		fmt.Fprintf(&source, "VLD1 (R0),[V0.B16]\nVLD1 (R1),[V1.B16]\nVLD1 (R2),[V2.B16]\nWORD $%#08x\nVST1 [V0.B16],(R3)\nRET\n", words[index])
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}
+		fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+		lanes := tc.lanes
+		if tc.scalar {
+			lanes = 1
+		}
+		fmt.Fprintf(&checks, "    if (check(%s, %d, %d, %d, %d)) return %d;\n",
+			name, tc.bits, lanes, tc.index, map[bool]int{true: 1, false: 0}[tc.operation == "sqrdmlsh"], index+1)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := arm64RDMAOracleC + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	return file, sigs, oracle
+}
+
+// Independent translation of Arm DDI 0602's integer pseudocode. The i128
+// accumulator avoids overflow before the final signed saturation.
+const arm64RDMAOracleC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static int64_t lane(const uint8_t *p, int bits, int index) {
+    if (bits == 16) {
+        int16_t value;
+        memcpy(&value, p + index * 2, 2);
+        return value;
+    }
+    int32_t value;
+    memcpy(&value, p + index * 4, 4);
+    return value;
+}
+
+static int check(void (*fn)(const void *,const void *,const void *,void *),
+                 int bits, int lanes, int index, int subtract) {
+    uint8_t acc[16], a[16], b[16], got[16], want[16];
+    uint32_t seed = 0x98124ab3U;
+    for (unsigned trial = 0; trial < 256; trial++) {
+        for (int byte = 0; byte < 16; byte++) {
+            seed = seed * 1664525U + 1013904223U;
+            acc[byte] = seed >> 24;
+            seed = seed * 1664525U + 1013904223U;
+            a[byte] = seed >> 16;
+            b[byte] = seed >> 8;
+        }
+        if (trial == 0 || trial == 1) {
+            memset(acc, trial == 0 ? 0x7f : 0x80, 16);
+            memset(a, 0, 16);
+            memset(b, 0, 16);
+            for (int lane = 0; lane < 128 / bits; lane++) {
+                a[(lane + 1) * bits / 8 - 1] = 0x80;
+                b[(lane + 1) * bits / 8 - 1] = 0x80;
+            }
+        }
+        memset(want, 0, 16);
+        for (int position = 0; position < lanes; position++) {
+            int secondIndex = index < 0 ? position : index;
+            __int128 total = (__int128)lane(acc,bits,position) * (((__int128)1) << bits);
+            __int128 product = 2 * (__int128)lane(a,bits,position) * lane(b,bits,secondIndex);
+            total += subtract ? -product : product;
+            total = (total + (((__int128)1) << (bits - 1))) >> bits;
+            __int128 maximum = (((__int128)1) << (bits - 1)) - 1;
+            __int128 minimum = -maximum - 1;
+            if (total > maximum) total = maximum;
+            if (total < minimum) total = minimum;
+            uint32_t result = (uint32_t)total;
+            memcpy(want + position * bits / 8, &result, bits / 8);
+        }
+        memset(got, 0xa5, 16);
+        fn(acc, a, b, got);
+        if (memcmp(got, want, 16) != 0) {
+            fprintf(stderr, "RDMA mismatch bits=%d lanes=%d index=%d subtract=%d trial=%u\n",
+                    bits, lanes, index, subtract, trial);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/arm64_lower_word_reciprocal_estimate.go b/arm64_lower_word_reciprocal_estimate.go
new file mode 100644
index 000000000..f93cf670c
--- /dev/null
+++ b/arm64_lower_word_reciprocal_estimate.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawReciprocalEstimate struct {
+	intrinsic   string
+	scalar      bool
+	binary      bool
+	arrangement arm64VectorArrangement
+	source      int
+	second      int
+	destination int
+}
+
+func decodeARM64RawReciprocalEstimate(word uint32) (arm64RawReciprocalEstimate, bool) {
+	const registers = uint32(31 | 31<<5)
+	forms := map[uint32]struct {
+		intrinsic string
+		scalar    bool
+		bits      int
+		lanes     int
+	}{
+		0x5ef9d800: {"frecpe", true, 16, 1},
+		0x5ea1d800: {"frecpe", true, 32, 1},
+		0x5ee1d800: {"frecpe", true, 64, 1},
+		0x0ef9d800: {"frecpe", false, 16, 4},
+		0x4ef9d800: {"frecpe", false, 16, 8},
+		0x0ea1d800: {"frecpe", false, 32, 2},
+		0x4ea1d800: {"frecpe", false, 32, 4},
+		0x4ee1d800: {"frecpe", false, 64, 2},
+		0x5ef9f800: {"frecpx", true, 16, 1},
+		0x5ea1f800: {"frecpx", true, 32, 1},
+		0x5ee1f800: {"frecpx", true, 64, 1},
+		0x7ef9d800: {"frsqrte", true, 16, 1},
+		0x7ea1d800: {"frsqrte", true, 32, 1},
+		0x7ee1d800: {"frsqrte", true, 64, 1},
+		0x2ef9d800: {"frsqrte", false, 16, 4},
+		0x6ef9d800: {"frsqrte", false, 16, 8},
+		0x2ea1d800: {"frsqrte", false, 32, 2},
+		0x6ea1d800: {"frsqrte", false, 32, 4},
+		0x6ee1d800: {"frsqrte", false, 64, 2},
+	}
+	decoded, ok := forms[word&^registers]
+	if !ok {
+		const binaryRegisters = registers | 31<<16
+		binaryForms := map[uint32]struct {
+			intrinsic string
+			scalar    bool
+			bits      int
+			lanes     int
+		}{
+			0x5e403c00: {"frecps", true, 16, 1},
+			0x5e20fc00: {"frecps", true, 32, 1},
+			0x5e60fc00: {"frecps", true, 64, 1},
+			0x0e403c00: {"frecps", false, 16, 4},
+			0x4e403c00: {"frecps", false, 16, 8},
+			0x0e20fc00: {"frecps", false, 32, 2},
+			0x4e20fc00: {"frecps", false, 32, 4},
+			0x4e60fc00: {"frecps", false, 64, 2},
+			0x5ec03c00: {"frsqrts", true, 16, 1},
+			0x5ea0fc00: {"frsqrts", true, 32, 1},
+			0x5ee0fc00: {"frsqrts", true, 64, 1},
+			0x0ec03c00: {"frsqrts", false, 16, 4},
+			0x4ec03c00: {"frsqrts", false, 16, 8},
+			0x0ea0fc00: {"frsqrts", false, 32, 2},
+			0x4ea0fc00: {"frsqrts", false, 32, 4},
+			0x4ee0fc00: {"frsqrts", false, 64, 2},
+		}
+		decoded, ok := binaryForms[word&^binaryRegisters]
+		if !ok {
+			return arm64RawReciprocalEstimate{}, false
+		}
+		return arm64RawReciprocalEstimate{
+			intrinsic:   decoded.intrinsic,
+			scalar:      decoded.scalar,
+			binary:      true,
+			arrangement: arm64VectorArrangement{elementBits: decoded.bits, lanes: decoded.lanes},
+			source:      int(word>>5) & 31,
+			second:      int(word>>16) & 31,
+			destination: int(word) & 31,
+		}, true
+	}
+	return arm64RawReciprocalEstimate{
+		intrinsic:   decoded.intrinsic,
+		scalar:      decoded.scalar,
+		arrangement: arm64VectorArrangement{elementBits: decoded.bits, lanes: decoded.lanes},
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawReciprocalEstimate(form arm64RawReciprocalEstimate) error {
+	floatType, suffix, _ := arm64ScalarFloatType(form.arrangement.elementBits)
+	if form.scalar {
+		source, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.source)), form.arrangement.elementBits)
+		if err != nil {
+			return err
+		}
+		result := c.newTmp()
+		if form.binary {
+			second, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.second)), form.arrangement.elementBits)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.%s(%s %s, %s %s)\n",
+				result, floatType, form.intrinsic, suffix, floatType, source, floatType, second)
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.%s(%s %s)\n",
+				result, floatType, form.intrinsic, suffix, floatType, source)
+		}
+		return c.storeARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.destination)), form.arrangement.elementBits, "%"+result)
+	}
+
+	source, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.source)), form.arrangement)
+	if err != nil {
+		return err
+	}
+	vectorType := fmt.Sprintf("<%d x %s>", form.arrangement.lanes, floatType)
+	result := c.newTmp()
+	if form.binary {
+		second, err := c.loadARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.second)), form.arrangement)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%d%s(%s %s, %s %s)\n",
+			result, vectorType, form.intrinsic, form.arrangement.lanes, suffix, vectorType, source, vectorType, second)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.%s.v%d%s(%s %s)\n",
+			result, vectorType, form.intrinsic, form.arrangement.lanes, suffix, vectorType, source)
+	}
+	return c.storeARM64VectorFloat(Reg(fmt.Sprintf("V%d", form.destination)), form.arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_reciprocal_estimate_test.go b/arm64_lower_word_reciprocal_estimate_test.go
new file mode 100644
index 000000000..864b8229c
--- /dev/null
+++ b/arm64_lower_word_reciprocal_estimate_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawReciprocalCompleteArchitectureFamily(t *testing.T) {
+	forms := []struct {
+		name   string
+		base   uint32
+		binary bool
+	}{
+		{"FRECPE H", 0x5ef9d800, false},
+		{"FRECPE S", 0x5ea1d800, false},
+		{"FRECPE D", 0x5ee1d800, false},
+		{"FRECPE H4", 0x0ef9d800, false},
+		{"FRECPE H8", 0x4ef9d800, false},
+		{"FRECPE S2", 0x0ea1d800, false},
+		{"FRECPE S4", 0x4ea1d800, false},
+		{"FRECPE D2", 0x4ee1d800, false},
+		{"FRECPX H", 0x5ef9f800, false},
+		{"FRECPX S", 0x5ea1f800, false},
+		{"FRECPX D", 0x5ee1f800, false},
+		{"FRSQRTE H", 0x7ef9d800, false},
+		{"FRSQRTE S", 0x7ea1d800, false},
+		{"FRSQRTE D", 0x7ee1d800, false},
+		{"FRSQRTE H4", 0x2ef9d800, false},
+		{"FRSQRTE H8", 0x6ef9d800, false},
+		{"FRSQRTE S2", 0x2ea1d800, false},
+		{"FRSQRTE S4", 0x6ea1d800, false},
+		{"FRSQRTE D2", 0x6ee1d800, false},
+		{"FRECPS H", 0x5e403c00, true},
+		{"FRECPS S", 0x5e20fc00, true},
+		{"FRECPS D", 0x5e60fc00, true},
+		{"FRECPS H4", 0x0e403c00, true},
+		{"FRECPS H8", 0x4e403c00, true},
+		{"FRECPS S2", 0x0e20fc00, true},
+		{"FRECPS S4", 0x4e20fc00, true},
+		{"FRECPS D2", 0x4e60fc00, true},
+		{"FRSQRTS H", 0x5ec03c00, true},
+		{"FRSQRTS S", 0x5ea0fc00, true},
+		{"FRSQRTS D", 0x5ee0fc00, true},
+		{"FRSQRTS H4", 0x0ec03c00, true},
+		{"FRSQRTS H8", 0x4ec03c00, true},
+		{"FRSQRTS S2", 0x0ea0fc00, true},
+		{"FRSQRTS S4", 0x4ea0fc00, true},
+		{"FRSQRTS D2", 0x4ee0fc00, true},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT reciprocalEstimateArchitectureForms(SB),$0-0\n")
+	for _, form := range forms {
+		word := form.base | 31<<5 | 30
+		if form.binary {
+			word |= 29 << 16
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", word, form.name)
+	}
+	source.WriteString("\tRET\n")
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"reciprocalEstimateArchitectureForms": {
+						Name: "reciprocalEstimateArchitectureForms",
+						Ret:  Void,
+					},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"@llvm.aarch64.neon.frecpe.f16",
+				"@llvm.aarch64.neon.frecpe.f32",
+				"@llvm.aarch64.neon.frecpe.f64",
+				"@llvm.aarch64.neon.frecpe.v4f16",
+				"@llvm.aarch64.neon.frecpe.v8f16",
+				"@llvm.aarch64.neon.frecpe.v2f32",
+				"@llvm.aarch64.neon.frecpe.v4f32",
+				"@llvm.aarch64.neon.frecpe.v2f64",
+				"@llvm.aarch64.neon.frecpx.f16",
+				"@llvm.aarch64.neon.frecpx.f32",
+				"@llvm.aarch64.neon.frecpx.f64",
+				"@llvm.aarch64.neon.frsqrte.f16",
+				"@llvm.aarch64.neon.frsqrte.f32",
+				"@llvm.aarch64.neon.frsqrte.f64",
+				"@llvm.aarch64.neon.frsqrte.v4f16",
+				"@llvm.aarch64.neon.frsqrte.v8f16",
+				"@llvm.aarch64.neon.frsqrte.v2f32",
+				"@llvm.aarch64.neon.frsqrte.v4f32",
+				"@llvm.aarch64.neon.frsqrte.v2f64",
+				"@llvm.aarch64.neon.frecps.f16",
+				"@llvm.aarch64.neon.frecps.v8f16",
+				"@llvm.aarch64.neon.frecps.v4f32",
+				"@llvm.aarch64.neon.frecps.v2f64",
+				"@llvm.aarch64.neon.frsqrts.f16",
+				"@llvm.aarch64.neon.frsqrts.v8f16",
+				"@llvm.aarch64.neon.frsqrts.v4f32",
+				"@llvm.aarch64.neon.frsqrts.v2f64",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw reciprocal estimate IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-reciprocal-estimate.ll", "arm64-reciprocal-estimate.o", ir)
+		})
+	}
+}
+
+func TestARM64RawReciprocalEstimateDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x5ea1dc00, // FRECPS.
+		0x7ea1fc00, // FRSQRTS.
+		0x0ee1d800, // Reserved vector D1.
+		0x1ea1d800, // Scalar encoding with an invalid opcode class.
+	} {
+		if form, ok := decodeARM64RawReciprocalEstimate(word); ok {
+			t.Fatalf("decoder accepted adjacent/reserved encoding %#08x as %#v", word, form)
+		}
+	}
+}
diff --git a/arm64_lower_word_rndr.go b/arm64_lower_word_rndr.go
new file mode 100644
index 000000000..db988ffc8
--- /dev/null
+++ b/arm64_lower_word_rndr.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawRNDR struct {
+	reseed bool
+	reg    int
+}
+
+// RNDR and RNDRRS occupy the complete Rt x reseed space in the MRS system
+// register encoding. Handle them before generic MRS because both write NZCV.
+func decodeARM64RawRNDR(word uint32) (arm64RawRNDR, bool) {
+	if word&0xffffffc0 != 0xd53b2400 {
+		return arm64RawRNDR{}, false
+	}
+	return arm64RawRNDR{
+		reseed: word&0x20 != 0,
+		reg:    int(word & 31),
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawRNDR(form arm64RawRNDR) error {
+	if form.reg < 0 || form.reg > 31 {
+		return fmt.Errorf("arm64 invalid RNG destination %d", form.reg)
+	}
+	if !arm64ScalarConversionNativeTarget(c.targetTriple) {
+		return fmt.Errorf("%w: ARM64 RNG requires an explicit native little-endian AArch64 target", ErrProbeNeedsContext)
+	}
+	if flow := c.machineAvailability; flow != nil && !flow.flagsOnly && (form.reg == 18 || form.reg == 28) {
+		return arm64GoABIContext("RNG numerical output cannot replace a platform/g entry identity")
+	}
+	intrinsic := "rndr"
+	if form.reseed {
+		intrinsic = "rndrrs"
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call { i64, i1 } @llvm.aarch64.%s()\n", result, intrinsic)
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i1 } %%%s, 0\n", value, result)
+	failed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue { i64, i1 } %%%s, 1\n", failed, result)
+
+	// Arm sets NZCV to 0000 on success and 0100 on failure. The intrinsic's
+	// second result is the failure/Z bit, as emitted by LLVM's ACLE frontend.
+	c.flagsWritten = true
+	c.storeFlag(c.flagsNSlot, "false")
+	c.storeFlag(c.flagsZSlot, "%"+failed)
+	c.storeFlag(c.flagsCSlot, "false")
+	c.storeFlag(c.flagsVSlot, "false")
+	if form.reg == 31 {
+		return nil // XZR discards the value but not the status flags.
+	}
+	return c.storeReg(Reg(fmt.Sprintf("R%d", form.reg)), "%"+value)
+}
diff --git a/arm64_lower_word_rndr_test.go b/arm64_lower_word_rndr_test.go
new file mode 100644
index 000000000..473fcdaab
--- /dev/null
+++ b/arm64_lower_word_rndr_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawRNDRDecoderCompleteArchitectureFamily(t *testing.T) {
+	for _, form := range []struct {
+		base   uint32
+		reseed bool
+	}{
+		{base: 0xd53b2400},
+		{base: 0xd53b2420, reseed: true},
+	} {
+		for reg := 0; reg < 32; reg++ {
+			word := form.base | uint32(reg)
+			decoded, ok := decodeARM64RawRNDR(word)
+			if !ok || decoded.reseed != form.reseed || decoded.reg != reg {
+				t.Fatalf("decode %#08x = %+v, %v", word, decoded, ok)
+			}
+		}
+	}
+	// Every bit outside the register and reseed fields is fixed. In
+	// particular, adjacent system registers must keep generic MRS semantics.
+	for bit := uint(6); bit < 32; bit++ {
+		word := uint32(0xd53b2400) ^ (1 << bit)
+		if decoded, ok := decodeARM64RawRNDR(word); ok {
+			t.Fatalf("accepted mutated fixed bit %d in %#08x: %+v", bit, word, decoded)
+		}
+	}
+}
+
+func TestARM64RawRNDRCompleteRegisterAndStatusForms(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range []struct {
+		name string
+		base uint32
+	}{
+		{name: "rndr", base: 0xd53b2400},
+		{name: "rndrrs", base: 0xd53b2420},
+	} {
+		for reg := uint32(0); reg < 32; reg++ {
+			name := fmt.Sprintf("%s%d", form.name, reg)
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n", name)
+			// RNDR really writes its GP destination, including physical LR.
+			// Preserve the caller link in a distinct source register so every
+			// accepted form has a valid return, rather than inventing one.
+			savedLink := 25
+			if reg == 25 {
+				savedLink = 26
+			}
+			fmt.Fprintf(&source, "MOVD R30,R%d\n", savedLink)
+			fmt.Fprintf(&source, "WORD $%#08x\n", form.base|reg)
+			fmt.Fprintf(&source, "BEQ %sdone\n", name)
+			fmt.Fprintf(&source, "%sdone:\nMOVD R%d,R30\nRET\n", name, savedLink)
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         sigs,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"rndr", "rndrrs"} {
+				call := "call { i64, i1 } @llvm.aarch64." + name + "()"
+				if count := strings.Count(ir, call); count != 32 {
+					t.Errorf("%s has %d calls, want 32", call, count)
+				}
+			}
+			for _, want := range []string{
+				`"target-features"="+rand"`,
+				"extractvalue { i64, i1 }",
+				"store i1 false, ptr %flags_n",
+				"store i1 false, ptr %flags_c",
+				"store i1 false, ptr %flags_v",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Errorf("missing %q", want)
+				}
+			}
+			if t.Failed() {
+				return
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-rndr.ll", "arm64-rndr.o", ir)
+		})
+	}
+}
+
+func TestARM64RawRNDRLLVMAssemblerOracle(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc not found")
+	}
+	for _, fixture := range []struct{ source, encoding string }{
+		{"mrs x0, rndr", "[0x00,0x24,0x3b,0xd5]"},
+		{"mrs x31, rndr", "[0x1f,0x24,0x3b,0xd5]"},
+		{"mrs x0, rndrrs", "[0x20,0x24,0x3b,0xd5]"},
+		{"mrs x31, rndrrs", "[0x3f,0x24,0x3b,0xd5]"},
+	} {
+		cmd := exec.Command(mc, "-triple=aarch64", "-mattr=+rand", "-show-encoding")
+		cmd.Stdin = strings.NewReader(fixture.source + "\n")
+		output, err := cmd.CombinedOutput()
+		if err != nil || !strings.Contains(string(output), fixture.encoding) {
+			t.Fatalf("LLVM oracle %q: %v\n%s", fixture.source, err, output)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_fcvt.go b/arm64_lower_word_scalar_fcvt.go
new file mode 100644
index 000000000..3543fdcf3
--- /dev/null
+++ b/arm64_lower_word_scalar_fcvt.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import "fmt"
+
+type arm64FloatToIntegerRounding uint8
+
+const (
+	arm64FloatRoundNearestEven arm64FloatToIntegerRounding = iota
+	arm64FloatRoundTiesAway
+	arm64FloatRoundPlusInf
+	arm64FloatRoundMinusInf
+	arm64FloatRoundZero
+)
+
+type arm64RawScalarFCVTToInt struct {
+	rounding        arm64FloatToIntegerRounding
+	unsigned        bool
+	sourceBits      int
+	destinationBits int
+	source          int
+	destination     int
+}
+
+func decodeARM64RawScalarFCVTToInt(word uint32) (arm64RawScalarFCVTToInt, bool) {
+	normalized := word & 0x7f3ffc00 // Ignore sf, type, Rn, and Rd.
+	rounding := arm64FloatRoundZero
+	switch normalized &^ (1 << 16) {
+	case 0x1e200000:
+		rounding = arm64FloatRoundNearestEven
+	case 0x1e240000:
+		rounding = arm64FloatRoundTiesAway
+	case 0x1e280000:
+		rounding = arm64FloatRoundPlusInf
+	case 0x1e300000:
+		rounding = arm64FloatRoundMinusInf
+	case 0x1e380000:
+		rounding = arm64FloatRoundZero
+	default:
+		return arm64RawScalarFCVTToInt{}, false
+	}
+
+	sourceBits := 0
+	switch word >> 22 & 3 {
+	case 0:
+		sourceBits = 32
+	case 1:
+		sourceBits = 64
+	case 3:
+		sourceBits = 16
+	default:
+		return arm64RawScalarFCVTToInt{}, false
+	}
+	destinationBits := 32
+	if word&(1<<31) != 0 {
+		destinationBits = 64
+	}
+	return arm64RawScalarFCVTToInt{
+		rounding:        rounding,
+		unsigned:        word&(1<<16) != 0,
+		sourceBits:      sourceBits,
+		destinationBits: destinationBits,
+		source:          int(word>>5) & 31,
+		destination:     int(word) & 31,
+	}, true
+}
+
+func arm64ScalarFloatType(bits int) (typeName string, intrinsicSuffix string, ok bool) {
+	switch bits {
+	case 16:
+		return "half", "f16", true
+	case 32:
+		return "float", "f32", true
+	case 64:
+		return "double", "f64", true
+	default:
+		return "", "", false
+	}
+}
+
+func (c *arm64Ctx) lowerARM64ScalarFloatToInteger(
+	source Reg,
+	sourceBits int,
+	destination Reg,
+	destinationBits int,
+	unsigned bool,
+	rounding arm64FloatToIntegerRounding,
+) error {
+	return c.lowerARM64ScalarConversion(arm64ScalarConversionForm{
+		arm64ScalarConversionSpec: arm64ScalarConversionSpec{floatBits: sourceBits, integerBits: destinationBits, unsigned: unsigned},
+		source:                    source, destination: destination, rounding: rounding,
+	})
+}
+
+func (c *arm64Ctx) lowerRawScalarFCVTToInt(form arm64RawScalarFCVTToInt) error {
+	source := Reg(fmt.Sprintf("F%d", form.source))
+	destination := ZR
+	if form.destination != 31 {
+		destination = Reg(fmt.Sprintf("R%d", form.destination))
+	}
+	return c.lowerARM64ScalarFloatToInteger(
+		source,
+		form.sourceBits,
+		destination,
+		form.destinationBits,
+		form.unsigned,
+		form.rounding,
+	)
+}
diff --git a/arm64_lower_word_scalar_fcvt_test.go b/arm64_lower_word_scalar_fcvt_test.go
new file mode 100644
index 000000000..35ed12951
--- /dev/null
+++ b/arm64_lower_word_scalar_fcvt_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarFCVTToIntDecoderCompleteFamily(t *testing.T) {
+	bases := map[arm64FloatToIntegerRounding]uint32{
+		arm64FloatRoundNearestEven: 0x1e200000,
+		arm64FloatRoundTiesAway:    0x1e240000,
+		arm64FloatRoundPlusInf:     0x1e280000,
+		arm64FloatRoundMinusInf:    0x1e300000,
+		arm64FloatRoundZero:        0x1e380000,
+	}
+	for rounding, base := range bases {
+		for _, unsigned := range []bool{false, true} {
+			for _, source := range []struct {
+				code uint32
+				bits int
+			}{{0, 32}, {1, 64}, {3, 16}} {
+				for _, destinationBits := range []int{32, 64} {
+					word := base | source.code<<22 | 7<<5 | 11
+					if unsigned {
+						word |= 1 << 16
+					}
+					if destinationBits == 64 {
+						word |= 1 << 31
+					}
+					form, ok := decodeARM64RawScalarFCVTToInt(word)
+					if !ok {
+						t.Fatalf("decoder rejected scalar FCVT word %#08x", word)
+					}
+					if form.rounding != rounding || form.unsigned != unsigned ||
+						form.sourceBits != source.bits || form.destinationBits != destinationBits ||
+						form.source != 7 || form.destination != 11 {
+						t.Fatalf("decoder returned the wrong form for %#08x: %+v", word, form)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateARM64RawScalarFCVTToIntCompleteFamily(t *testing.T) {
+	const source = `TEXT rawscalarfcvt(SB),$0-0
+	WORD $0x1e200020 // FCVTNS S1, W0
+	WORD $0x9e610062 // FCVTNU D3, X2
+	WORD $0x1e240023 // FCVTAS S1, W3 (external corpus form)
+	WORD $0x9ee500a4 // FCVTAU H5, X4
+	WORD $0x9e2800e6 // FCVTPS S7, X6
+	WORD $0x1e690128 // FCVTPU D9, W8
+	WORD $0x9e70016a // FCVTMS D11, X10
+	WORD $0x1e3101ac // FCVTMU S13, W12
+	WORD $0x1ef801ee // FCVTZS H15, W14
+	WORD $0x9e790230 // FCVTZU D17, X16
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"arm64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawscalarfcvt": {Name: "rawscalarfcvt", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"fcvtns ${0:w}, ${1:s}", "fcvtau ${0:x}, ${1:h}",
+				"fcvtps ${0:x}, ${1:s}", "fcvtpu ${0:w}, ${1:d}",
+				"fcvtms ${0:x}, ${1:d}", "fcvtmu ${0:w}, ${1:s}",
+				"fcvtzs ${0:w}, ${1:h}", "fcvtzu ${0:x}, ${1:d}",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw scalar FCVT lowering omitted %q:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-fcvt.ll", "arm64-raw-scalar-fcvt.o", ll)
+		})
+	}
+}
+
+func TestARM64RawScalarFCVTToIntDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1e220020, // SCVTF S1, W0.
+		0x1e240420, // Fixed-point scale bits are not part of this family.
+		0x1ea40020, // Reserved floating source type.
+		0x5e21a820, // Advanced SIMD FCVTNS.
+	} {
+		if form, ok := decodeARM64RawScalarFCVTToInt(word); ok {
+			t.Fatalf("decoder accepted adjacent encoding %#08x as %+v", word, form)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_float_binary.go b/arm64_lower_word_scalar_float_binary.go
new file mode 100644
index 000000000..682fb8a1d
--- /dev/null
+++ b/arm64_lower_word_scalar_float_binary.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarFloatBinary struct {
+	kind        string
+	bits        int
+	first       int
+	second      int
+	destination int
+}
+
+var arm64RawScalarFloatBinarySpecs = map[uint32]struct {
+	kind string
+	bits int
+}{
+	0x1ee02800: {"add", 16},
+	0x1e202800: {"add", 32},
+	0x1e602800: {"add", 64},
+	0x1ee03800: {"sub", 16},
+	0x1e203800: {"sub", 32},
+	0x1e603800: {"sub", 64},
+	0x1ee00800: {"mul", 16},
+	0x1e200800: {"mul", 32},
+	0x1e600800: {"mul", 64},
+	0x1ee08800: {"nmul", 16},
+	0x1e208800: {"nmul", 32},
+	0x1e608800: {"nmul", 64},
+	0x1ee01800: {"div", 16},
+	0x1e201800: {"div", 32},
+	0x1e601800: {"div", 64},
+	0x1ee04800: {"maximum", 16},
+	0x1e204800: {"maximum", 32},
+	0x1e604800: {"maximum", 64},
+	0x1ee05800: {"minimum", 16},
+	0x1e205800: {"minimum", 32},
+	0x1e605800: {"minimum", 64},
+	0x1ee06800: {"maxnum", 16},
+	0x1e206800: {"maxnum", 32},
+	0x1e606800: {"maxnum", 64},
+	0x1ee07800: {"minnum", 16},
+	0x1e207800: {"minnum", 32},
+	0x1e607800: {"minnum", 64},
+	0x7ec01400: {"fabd", 16},
+	0x7ea0d400: {"fabd", 32},
+	0x7ee0d400: {"fabd", 64},
+	0x5e401c00: {"fmulx", 16},
+	0x5e20dc00: {"fmulx", 32},
+	0x5e60dc00: {"fmulx", 64},
+}
+
+func decodeARM64RawScalarFloatBinary(word uint32) (arm64RawScalarFloatBinary, bool) {
+	const registers = uint32(31 | 31<<5 | 31<<16)
+	spec, ok := arm64RawScalarFloatBinarySpecs[word&^registers]
+	if !ok {
+		return arm64RawScalarFloatBinary{}, false
+	}
+	return arm64RawScalarFloatBinary{
+		kind:        spec.kind,
+		bits:        spec.bits,
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarFloatBinary(form arm64RawScalarFloatBinary) error {
+	if opcode := arm64ScalarBinaryOpcode(form.kind); opcode != "" {
+		return c.lowerARM64ScalarBinary(arm64ScalarBinaryForm{
+			arm64ScalarBinarySpec{opcode, form.bits},
+			Reg(fmt.Sprintf("F%d", form.first)), Reg(fmt.Sprintf("F%d", form.second)), Reg(fmt.Sprintf("F%d", form.destination)),
+		})
+	}
+	if opcode := arm64ScalarMinMaxOpcode(form.kind); opcode != "" {
+		return c.lowerARM64ScalarMinMax(arm64ScalarMinMaxForm{
+			arm64ScalarMinMaxSpec{opcode, form.bits},
+			Reg(fmt.Sprintf("F%d", form.first)), Reg(fmt.Sprintf("F%d", form.second)),
+			Reg(fmt.Sprintf("F%d", form.destination)),
+		})
+	}
+	lhs, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.first)), form.bits)
+	if err != nil {
+		return err
+	}
+	rhs, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.second)), form.bits)
+	if err != nil {
+		return err
+	}
+	return c.lowerARM64ScalarFloatBinaryValues(
+		form.kind,
+		form.bits,
+		lhs,
+		rhs,
+		Reg(fmt.Sprintf("F%d", form.destination)),
+	)
+}
diff --git a/arm64_lower_word_scalar_float_binary_test.go b/arm64_lower_word_scalar_float_binary_test.go
new file mode 100644
index 000000000..28eaa8e31
--- /dev/null
+++ b/arm64_lower_word_scalar_float_binary_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawScalarFloatBinaryCompleteArchitectureFamily(t *testing.T) {
+	operations := []struct {
+		name   string
+		opcode uint32
+	}{
+		{"FADD", 0x2800},
+		{"FSUB", 0x3800},
+		{"FMUL", 0x0800},
+		{"FNMUL", 0x8800},
+		{"FDIV", 0x1800},
+		{"FMAX", 0x4800},
+		{"FMIN", 0x5800},
+		{"FMAXNM", 0x6800},
+		{"FMINNM", 0x7800},
+	}
+	widths := []struct {
+		name string
+		base uint32
+	}{
+		{"H", 0x1ee00000},
+		{"S", 0x1e200000},
+		{"D", 0x1e600000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawScalarFloatBinaryFamily(SB),$0-0\n")
+	for _, operation := range operations {
+		for _, width := range widths {
+			word := width.base | operation.opcode | 31<<16 | 30<<5 | 29
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s %s\n", word, operation.name, width.name)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawScalarFloatBinaryFamily": {Name: "rawScalarFloatBinaryFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "fadd ${0:h}`, `asm sideeffect "fadd ${0:s}`, `asm sideeffect "fadd ${0:d}`,
+				`asm sideeffect "fsub ${0:h}`, `asm sideeffect "fmul ${0:h}`, `asm sideeffect "fdiv ${0:h}`, `asm sideeffect "fnmul ${0:h}`,
+				`asm sideeffect "fmax ${0:h}`, `asm sideeffect "fmin ${0:h}`,
+				`asm sideeffect "fmaxnm ${0:h}`, `asm sideeffect "fminnm ${0:h}`,
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw scalar float binary IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-float-binary.ll", "arm64-raw-scalar-float-binary.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarFloatBinaryDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ea02800, // Reserved type=2 encoding.
+		0x1e202c00, // FADD with reserved opcode bits.
+		0x1e20c800, // FMADD, a different instruction class.
+		0x5e20d400, // Scalar FADDP, a different instruction class.
+	} {
+		if _, ok := decodeARM64RawScalarFloatBinary(word); ok {
+			t.Fatalf("scalar float-binary decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_float_compare.go b/arm64_lower_word_scalar_float_compare.go
new file mode 100644
index 000000000..5c00de9f3
--- /dev/null
+++ b/arm64_lower_word_scalar_float_compare.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarFloatCompare struct {
+	bits      int
+	signaling bool
+	zero      bool
+	first     int
+	second    int
+}
+
+func decodeARM64RawScalarFloatCompare(word uint32) (arm64RawScalarFloatCompare, bool) {
+	const (
+		firstRegister  = uint32(31 << 5)
+		secondRegister = uint32(31 << 16)
+		floatType      = uint32(3 << 22)
+		signalingBit   = uint32(1 << 4)
+		zeroBit        = uint32(1 << 3)
+		variableFields = firstRegister | secondRegister | floatType | signalingBit | zeroBit
+		compareBase    = uint32(0x1e202000)
+	)
+	if word&^variableFields != compareBase {
+		return arm64RawScalarFloatCompare{}, false
+	}
+
+	bits := 0
+	switch word >> 22 & 3 {
+	case 0:
+		bits = 32
+	case 1:
+		bits = 64
+	case 3:
+		bits = 16
+	default:
+		return arm64RawScalarFloatCompare{}, false
+	}
+	second := int(word>>16) & 31
+	zero := word&zeroBit != 0
+	if zero && second != 0 {
+		return arm64RawScalarFloatCompare{}, false
+	}
+	return arm64RawScalarFloatCompare{
+		bits:      bits,
+		signaling: word&signalingBit != 0,
+		zero:      zero,
+		first:     int(word>>5) & 31,
+		second:    second,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarFloatCompare(form arm64RawScalarFloatCompare) error {
+	_, _, ok := arm64ScalarFloatType(form.bits)
+	if !ok {
+		return fmt.Errorf("arm64 unsupported scalar float width %d", form.bits)
+	}
+	left, err := c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.first)), form.bits)
+	if err != nil {
+		return err
+	}
+	right := ""
+	if !form.zero {
+		right, err = c.loadARM64ScalarFloatReg(Reg(fmt.Sprintf("F%d", form.second)), form.bits)
+		if err != nil {
+			return err
+		}
+	}
+	c.emitARM64ScalarFloatCompare(form.bits, form.signaling, left, right)
+	return nil
+}
diff --git a/arm64_lower_word_scalar_float_compare_test.go b/arm64_lower_word_scalar_float_compare_test.go
new file mode 100644
index 000000000..4df3cf319
--- /dev/null
+++ b/arm64_lower_word_scalar_float_compare_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarFloatCompareDecoderCompleteArchitectureFamily(t *testing.T) {
+	widths := []struct {
+		bits int
+		base uint32
+	}{
+		{bits: 16, base: 0x1ee02000},
+		{bits: 32, base: 0x1e202000},
+		{bits: 64, base: 0x1e602000},
+	}
+
+	count := 0
+	for _, width := range widths {
+		for _, signaling := range []bool{false, true} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					word := width.base | uint32(second)<<16 | uint32(first)<<5
+					if signaling {
+						word |= 1 << 4
+					}
+					form, ok := decodeARM64RawScalarFloatCompare(word)
+					if !ok {
+						t.Fatalf("decoder rejected %#08x", word)
+					}
+					if form.bits != width.bits || form.signaling != signaling || form.zero ||
+						form.first != first || form.second != second {
+						t.Fatalf("decode %#08x = %+v", word, form)
+					}
+					count++
+				}
+			}
+
+			for first := 0; first < 32; first++ {
+				word := width.base | uint32(first)<<5 | 1<<3
+				if signaling {
+					word |= 1 << 4
+				}
+				form, ok := decodeARM64RawScalarFloatCompare(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				if form.bits != width.bits || form.signaling != signaling || !form.zero ||
+					form.first != first || form.second != 0 {
+					t.Fatalf("decode %#08x = %+v", word, form)
+				}
+				count++
+			}
+		}
+	}
+	if count != 6336 {
+		t.Fatalf("covered %d scalar float-compare encodings, want 6336", count)
+	}
+}
+
+func TestTranslateARM64RawScalarFloatCompareCompleteArchitectureFamily(t *testing.T) {
+	widths := []struct {
+		name string
+		base uint32
+	}{
+		{name: "H", base: 0x1ee02000},
+		{name: "S", base: 0x1e202000},
+		{name: "D", base: 0x1e602000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawScalarFloatCompareFamily(SB),$0-0\n")
+	for _, width := range widths {
+		for _, signaling := range []bool{false, true} {
+			name := "FCMP"
+			modifier := uint32(0)
+			if signaling {
+				name = "FCMPE"
+				modifier = 1 << 4
+			}
+			registerWord := width.base | modifier | 31<<16 | 30<<5
+			zeroWord := width.base | modifier | 1<<3 | 29<<5
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s %s30, %s31\n", registerWord, name, width.name, width.name)
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s %s29, #0.0\n", zeroWord, name, width.name)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawScalarFloatCompareFamily": {Name: "rawScalarFloatCompareFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "fcmp ${1:h}`, `asm sideeffect "fcmp ${1:s}`, `asm sideeffect "fcmp ${1:d}`,
+				`asm sideeffect "fcmpe ${1:h}`, `"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw scalar float-compare IR omitted %q:\n%s", want, ir)
+				}
+			}
+			if got := strings.Count(ir, `asm sideeffect "fcmp`); got != 12 {
+				t.Fatalf("raw scalar float-compare emitted %d native comparisons, want 12:\n%s", got, ir)
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-float-compare.ll", "arm64-raw-scalar-float-compare.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarFloatCompareDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ea02000, // Reserved type=2 encoding.
+		0x1e212048, // Immediate-zero form with a nonzero Rm field.
+		0x1e202001, // Reserved low result-register field.
+		0x1e202800, // FADD, a different instruction class.
+		0x5e20d400, // Scalar FADDP, a different instruction class.
+	} {
+		if _, ok := decodeARM64RawScalarFloatCompare(word); ok {
+			t.Fatalf("scalar float-compare decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_float_immediate.go b/arm64_lower_word_scalar_float_immediate.go
new file mode 100644
index 000000000..579c58ff5
--- /dev/null
+++ b/arm64_lower_word_scalar_float_immediate.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarFloatImmediate struct {
+	bits        int
+	value       float64
+	destination int
+}
+
+func decodeARM64RawScalarFloatImmediate(word uint32) (arm64RawScalarFloatImmediate, bool) {
+	const (
+		floatType      = uint32(3 << 22)
+		immediateField = uint32(255 << 13)
+		destination    = uint32(31)
+		variableFields = floatType | immediateField | destination
+		immediateBase  = uint32(0x1e201000)
+	)
+	if word&^variableFields != immediateBase {
+		return arm64RawScalarFloatImmediate{}, false
+	}
+
+	bits := 0
+	switch word >> 22 & 3 {
+	case 0:
+		bits = 32
+	case 1:
+		bits = 64
+	case 3:
+		bits = 16
+	default:
+		return arm64RawScalarFloatImmediate{}, false
+	}
+	immediate := byte(word >> 13)
+	return arm64RawScalarFloatImmediate{
+		bits:        bits,
+		value:       arm64ExpandedFloatImmediate(immediate),
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarFloatImmediate(form arm64RawScalarFloatImmediate) error {
+	destination := Reg(fmt.Sprintf("F%d", form.destination))
+	return c.storeARM64ScalarFloatReg(
+		destination,
+		form.bits,
+		formatLLVMFloat64Literal(form.value),
+	)
+}
diff --git a/arm64_lower_word_scalar_float_immediate_test.go b/arm64_lower_word_scalar_float_immediate_test.go
new file mode 100644
index 000000000..b2ada1533
--- /dev/null
+++ b/arm64_lower_word_scalar_float_immediate_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarFloatImmediateDecoderCoversEveryEncoding(t *testing.T) {
+	widths := []struct {
+		bits int
+		base uint32
+	}{
+		{bits: 16, base: 0x1ee01000},
+		{bits: 32, base: 0x1e201000},
+		{bits: 64, base: 0x1e601000},
+	}
+
+	count := 0
+	for _, width := range widths {
+		for immediate := 0; immediate < 256; immediate++ {
+			for destination := 0; destination < 32; destination++ {
+				word := width.base | uint32(immediate)<<13 | uint32(destination)
+				form, ok := decodeARM64RawScalarFloatImmediate(word)
+				if !ok {
+					t.Fatalf("decoder rejected %#08x", word)
+				}
+				wantValue := arm64ExpandedFloatImmediate(byte(immediate))
+				if form.bits != width.bits || form.value != wantValue || form.destination != destination {
+					t.Fatalf("decode %#08x = %+v, want bits=%d value=%v destination=%d", word, form, width.bits, wantValue, destination)
+				}
+				count++
+			}
+		}
+	}
+	if count != 24576 {
+		t.Fatalf("covered %d scalar float-immediate encodings, want 24576", count)
+	}
+}
+
+func TestTranslateARM64RawScalarFloatImmediateCompleteArchitectureFamily(t *testing.T) {
+	formats := []struct {
+		name string
+		base uint32
+	}{
+		{name: "H", base: 0x1ee01000},
+		{name: "S", base: 0x1e201000},
+		{name: "D", base: 0x1e601000},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawScalarFloatImmediateFamily(SB),$0-0\n")
+	for destination, format := range formats {
+		word := format.base | 0x70<<13 | uint32(destination)
+		fmt.Fprintf(&source, "\tWORD $%#08x // FMOV %s%d, #1.0\n", word, format.name, destination)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawScalarFloatImmediateFamily": {Name: "rawScalarFloatImmediateFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"bitcast half 0xH3C00", "bitcast float 1.000000e+00", "bitcast double 1.000000e+00",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw scalar float-immediate IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-float-immediate.ll", "arm64-raw-scalar-float-immediate.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarFloatImmediateValueBoundaries(t *testing.T) {
+	for _, immediate := range []byte{0x00, 0x0f, 0x70, 0x7f, 0x80, 0xff} {
+		word := uint32(0x1e201000) | uint32(immediate)<<13
+		form, ok := decodeARM64RawScalarFloatImmediate(word)
+		if !ok {
+			t.Fatalf("decoder rejected immediate %#02x", immediate)
+		}
+		if want := arm64ExpandedFloatImmediate(immediate); math.Float64bits(form.value) != math.Float64bits(want) {
+			t.Fatalf("immediate %#02x value = %v, want %v", immediate, form.value, want)
+		}
+	}
+}
+
+func TestARM64RawScalarFloatImmediateDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ea01000, // Reserved type=2 encoding.
+		0x1ee00000, // FMOV between half registers.
+		0x1e201800, // FDIV, a different instruction class.
+		0x0f03f600, // Vector FMOV immediate.
+	} {
+		if _, ok := decodeARM64RawScalarFloatImmediate(word); ok {
+			t.Fatalf("scalar float-immediate decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_float_select.go b/arm64_lower_word_scalar_float_select.go
new file mode 100644
index 000000000..0c0ddac65
--- /dev/null
+++ b/arm64_lower_word_scalar_float_select.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarFloatSelect struct {
+	bits        int
+	condition   int
+	first       int
+	second      int
+	destination int
+}
+
+var arm64RawScalarFloatSelectWidths = map[uint32]int{
+	0x1ee00c00: 16,
+	0x1e200c00: 32,
+	0x1e600c00: 64,
+}
+
+var arm64RawConditionNames = [...]string{
+	"EQ", "NE", "HS", "LO",
+	"MI", "PL", "VS", "VC",
+	"HI", "LS", "GE", "LT",
+	"GT", "LE", "AL", "NV",
+}
+
+func decodeARM64RawScalarFloatSelect(word uint32) (arm64RawScalarFloatSelect, bool) {
+	const operands = uint32(31 | 31<<5 | 15<<12 | 31<<16)
+	bits, ok := arm64RawScalarFloatSelectWidths[word&^operands]
+	if !ok {
+		return arm64RawScalarFloatSelect{}, false
+	}
+	return arm64RawScalarFloatSelect{
+		bits:        bits,
+		condition:   int(word>>12) & 15,
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarFloatSelect(form arm64RawScalarFloatSelect) error {
+	return c.lowerARM64FloatSelectValues(
+		form.bits,
+		arm64RawConditionNames[form.condition],
+		Reg(fmt.Sprintf("F%d", form.first)),
+		Reg(fmt.Sprintf("F%d", form.second)),
+		Reg(fmt.Sprintf("F%d", form.destination)),
+	)
+}
+
+func (c *arm64Ctx) lowerARM64FloatSelectValues(bits int, condition string, firstReg, secondReg, destination Reg) error {
+	first, err := c.loadARM64ScalarFloatReg(firstReg, bits)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARM64ScalarFloatReg(secondReg, bits)
+	if err != nil {
+		return err
+	}
+	predicate, err := c.condValue(condition)
+	if err != nil {
+		return err
+	}
+	typeName := "half"
+	if bits == 32 {
+		typeName = "float"
+	} else if bits == 64 {
+		typeName = "double"
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %s, %s %s\n", selected, predicate, typeName, first, typeName, second)
+	return c.storeARM64ScalarFloatReg(destination, bits, "%"+selected)
+}
diff --git a/arm64_lower_word_scalar_float_select_test.go b/arm64_lower_word_scalar_float_select_test.go
new file mode 100644
index 000000000..56158dcd1
--- /dev/null
+++ b/arm64_lower_word_scalar_float_select_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarFloatSelectDecoderCompleteArchitectureFamily(t *testing.T) {
+	formats := []struct {
+		base uint32
+		bits int
+	}{
+		{base: 0x1ee00c00, bits: 16},
+		{base: 0x1e200c00, bits: 32},
+		{base: 0x1e600c00, bits: 64},
+	}
+
+	count := 0
+	for _, format := range formats {
+		for condition := 0; condition < 16; condition++ {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						word := format.base |
+							uint32(second)<<16 |
+							uint32(condition)<<12 |
+							uint32(first)<<5 |
+							uint32(destination)
+						form, ok := decodeARM64RawScalarFloatSelect(word)
+						if !ok {
+							t.Fatalf("decoder rejected %#08x", word)
+						}
+						if form.bits != format.bits || form.condition != condition ||
+							form.first != first || form.second != second ||
+							form.destination != destination {
+							t.Fatalf("decode %#08x = %+v", word, form)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 1572864 {
+		t.Fatalf("covered %d scalar FCSEL encodings, want 1572864", count)
+	}
+}
+
+func TestTranslateARM64RawScalarFloatSelectCompleteArchitectureFamily(t *testing.T) {
+	const source = `
+TEXT rawScalarFloatSelectFamily(SB),$0-0
+	CMP R0, R1
+	WORD $0x1ee1dc02 // FCSEL H2, H0, H1, LE
+	WORD $0x1e24ac83 // FCSEL S3, S4, S4, GE
+	WORD $0x1e679ce5 // FCSEL D5, D7, D7, LS
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawScalarFloatSelectFamily": {Name: "rawScalarFloatSelectFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"select i1", " half ", " float ", " double ",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw scalar FCSEL IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-fcsel.ll", "arm64-raw-scalar-fcsel.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarFloatSelectRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawscalarfloatselect(SB),$0-32
+	MOVD first+0(FP), R0
+	MOVD second+8(FP), R1
+	MOVD chooseFirst+16(FP), R2
+	MOVD out+24(FP), R4
+	WORD $0x1ee70000 // FMOV H0, W0
+	WORD $0x1ee70021 // FMOV H1, W1
+	CMP $0, R2
+	WORD $0x1ee11c02 // FCSEL H2, H0, H1, NE
+	WORD $0x1ee60043 // FMOV W3, H2
+	MOVD R3, (R4)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawscalarfloatselect": {
+			Name: "rawscalarfloatselect", Args: []LLVMType{I64, I64, I64, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: I64, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawscalarfloatselect(uint64_t, uint64_t, uint64_t, uint64_t *);
+int main(void) {
+  uint64_t got = 0;
+  rawscalarfloatselect(0x3c00, 0xc000, 1, &got);
+  if (got != 0x3c00) return 1;
+  rawscalarfloatselect(0x3c00, 0xc000, 0, &got);
+  if (got != 0xc000) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_scalar_fcsel", triple, ir, mainC, nil)
+}
+
+func TestARM64RawScalarFloatSelectDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ea00c00, // Reserved scalar floating type.
+		0x1ee00800, // FCCMP scalar half-precision family.
+		0x1ee02000, // FCMP scalar half-precision family.
+		0x0e20cc00, // Advanced SIMD FMLA family.
+	} {
+		if _, ok := decodeARM64RawScalarFloatSelect(word); ok {
+			t.Fatalf("scalar FCSEL decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_half_unary.go b/arm64_lower_word_scalar_half_unary.go
new file mode 100644
index 000000000..47e1a4ea2
--- /dev/null
+++ b/arm64_lower_word_scalar_half_unary.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarHalfUnary struct {
+	operation   string
+	source      int
+	destination int
+}
+
+// Go 1.27 has named FABS/FNEG/FSQRT/FRINT scalar forms for S and D, but
+// no H optab forms. The full FP16 scalar unary encoding family therefore
+// reaches us as WORD directives.
+func decodeARM64RawScalarHalfUnary(word uint32) (arm64RawScalarHalfUnary, bool) {
+	const registers = uint32(31 | 31<<5)
+	operations := map[uint32]string{
+		0x1ee0c000: "fabs",
+		0x1ee14000: "neg",
+		0x1ee1c000: "sqrt",
+		0x1ee64000: "round",
+		0x1ee7c000: "nearbyint",
+		0x1ee54000: "floor",
+		0x1ee44000: "roundeven",
+		0x1ee4c000: "ceil",
+		0x1ee74000: "rint",
+		0x1ee5c000: "trunc",
+	}
+	operation, ok := operations[word&^registers]
+	if !ok {
+		return arm64RawScalarHalfUnary{}, false
+	}
+	return arm64RawScalarHalfUnary{
+		operation:   operation,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarHalfUnary(form arm64RawScalarHalfUnary) error {
+	sourceReg := Reg(fmt.Sprintf("F%d", form.source))
+	destinationReg := Reg(fmt.Sprintf("F%d", form.destination))
+	source, err := c.loadARM64ScalarFloatReg(sourceReg, 16)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.operation == "neg" {
+		fmt.Fprintf(c.b, "  %%%s = fneg half %s\n", result, source)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = call half @llvm.%s.f16(half %s)\n", result, form.operation, source)
+	}
+	return c.storeARM64ScalarFloatReg(destinationReg, 16, "%"+result)
+}
diff --git a/arm64_lower_word_scalar_half_unary_test.go b/arm64_lower_word_scalar_half_unary_test.go
new file mode 100644
index 000000000..506687879
--- /dev/null
+++ b/arm64_lower_word_scalar_half_unary_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarHalfUnaryCompleteFamily(t *testing.T) {
+	operations := []struct {
+		name       string
+		encoding   uint32
+		irFragment string
+	}{
+		{"FABS", 0x1ee0c000, "@llvm.fabs.f16"},
+		{"FNEG", 0x1ee14000, "fneg half"},
+		{"FSQRT", 0x1ee1c000, "@llvm.sqrt.f16"},
+		{"FRINTA", 0x1ee64000, "@llvm.round.f16"},
+		{"FRINTI", 0x1ee7c000, "@llvm.nearbyint.f16"},
+		{"FRINTM", 0x1ee54000, "@llvm.floor.f16"},
+		{"FRINTN", 0x1ee44000, "@llvm.roundeven.f16"},
+		{"FRINTP", 0x1ee4c000, "@llvm.ceil.f16"},
+		{"FRINTX", 0x1ee74000, "@llvm.rint.f16"},
+		{"FRINTZ", 0x1ee5c000, "@llvm.trunc.f16"},
+	}
+	for _, operation := range operations {
+		for sourceReg := 0; sourceReg < 32; sourceReg++ {
+			for destinationReg := 0; destinationReg < 32; destinationReg++ {
+				word := operation.encoding | uint32(sourceReg)<<5 | uint32(destinationReg)
+				form, ok := decodeARM64RawScalarHalfUnary(word)
+				if !ok || form.source != sourceReg || form.destination != destinationReg {
+					t.Fatalf("%s register fields not decoded for %#08x: %+v, ok=%v", operation.name, word, form, ok)
+				}
+			}
+		}
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawscalarhalfunary(SB),$0-0\n")
+	for _, operation := range operations {
+		word := operation.encoding | 31<<5 | 30
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s H31, H30\n", word, operation.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawscalarhalfunary": {Name: "rawscalarhalfunary", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range operations {
+				if !strings.Contains(ir, operation.irFragment) {
+					t.Fatalf("%s IR omitted %q:\n%s", operation.name, operation.irFragment, ir)
+				}
+			}
+			if !strings.Contains(ir, `"target-features"="+fullfp16"`) {
+				t.Fatalf("scalar half IR omitted +fullfp16:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-half-unary.ll", "arm64-raw-scalar-half-unary.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarHalfUnaryRuntime(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("native ARM64 runtime required")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawscalarhalfneg(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V1.H8]
+	WORD $0x1ee14020 // FNEG H1, H0
+	VST1 [V0.H8], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawscalarhalfneg": {
+			Name: "rawscalarhalfneg", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawscalarhalfneg(const uint16_t *, uint16_t *);
+int main(void) {
+  const uint16_t input[8] = {0x3c00};
+  uint16_t output[8] = {0};
+  rawscalarhalfneg(input, output);
+  return output[0] == 0xbc00 ? 0 : 1;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_scalar_half_neg", triple, ir, mainC, nil)
+}
+
+func TestARM64RawScalarHalfUnaryRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1e20c000, // Single-precision FABS belongs to the named Go family.
+		0x1e60c000, // Double-precision FABS belongs to the named Go family.
+		0x1ee24000, // Reserved scalar half unary opcode.
+		0x5ef9d800, // Scalar half FRECPE is a different instruction family.
+	} {
+		if _, ok := decodeARM64RawScalarHalfUnary(word); ok {
+			t.Fatalf("scalar half unary decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_int_to_float.go b/arm64_lower_word_scalar_int_to_float.go
new file mode 100644
index 000000000..0b3104542
--- /dev/null
+++ b/arm64_lower_word_scalar_int_to_float.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarIntToFloat struct {
+	floatBits   int
+	integerBits int
+	unsigned    bool
+	simdInteger bool
+	source      int
+	destination int
+}
+
+func decodeARM64RawScalarIntToFloat(word uint32) (arm64RawScalarIntToFloat, bool) {
+	// Scalar SIMD integer carriers have the same width as their floating
+	// destination. Half uses a distinct encoding, not the GP type field.
+	floatBits := 0
+	switch word &^ uint32(1<<29|31<<5|31) {
+	case 0x5e79d800:
+		floatBits = 16
+	case 0x5e21d800:
+		floatBits = 32
+	case 0x5e61d800:
+		floatBits = 64
+	}
+	if floatBits != 0 {
+		return arm64RawScalarIntToFloat{
+			floatBits: floatBits, integerBits: floatBits, unsigned: word&(1<<29) != 0,
+			simdInteger: true, source: int(word>>5) & 31, destination: int(word) & 31,
+		}, true
+	}
+
+	const (
+		integerWidth   = uint32(1 << 31)
+		floatType      = uint32(3 << 22)
+		unsignedBit    = uint32(1 << 16)
+		source         = uint32(31 << 5)
+		destination    = uint32(31)
+		variableFields = integerWidth | floatType | unsignedBit | source | destination
+		conversionBase = uint32(0x1e220000)
+	)
+	if word&^variableFields != conversionBase {
+		return arm64RawScalarIntToFloat{}, false
+	}
+
+	floatBits = 0
+	switch word >> 22 & 3 {
+	case 0:
+		floatBits = 32
+	case 1:
+		floatBits = 64
+	case 3:
+		floatBits = 16
+	default:
+		return arm64RawScalarIntToFloat{}, false
+	}
+	integerBits := 32
+	if word&integerWidth != 0 {
+		integerBits = 64
+	}
+	return arm64RawScalarIntToFloat{
+		floatBits:   floatBits,
+		integerBits: integerBits,
+		unsigned:    word&unsignedBit != 0,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarIntToFloat(form arm64RawScalarIntToFloat) error {
+	source := ZR
+	if form.simdInteger {
+		source = Reg(fmt.Sprintf("F%d", form.source))
+	} else if form.source != 31 {
+		source = Reg(fmt.Sprintf("R%d", form.source))
+	}
+	return c.lowerARM64ScalarConversion(arm64ScalarConversionForm{
+		arm64ScalarConversionSpec: arm64ScalarConversionSpec{
+			floatBits: form.floatBits, integerBits: form.integerBits, toFloat: true, unsigned: form.unsigned,
+			simdInteger: form.simdInteger,
+		},
+		source: source, destination: Reg(fmt.Sprintf("F%d", form.destination)),
+	})
+}
diff --git a/arm64_lower_word_scalar_int_to_float_test.go b/arm64_lower_word_scalar_int_to_float_test.go
new file mode 100644
index 000000000..a349db7f1
--- /dev/null
+++ b/arm64_lower_word_scalar_int_to_float_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarIntToFloatDecoderCompleteGPRRegisterFamily(t *testing.T) {
+	floatWidths := []struct {
+		bits     int
+		typeBits uint32
+	}{
+		{bits: 16, typeBits: 3},
+		{bits: 32, typeBits: 0},
+		{bits: 64, typeBits: 1},
+	}
+
+	count := 0
+	for _, floatWidth := range floatWidths {
+		for _, integerBits := range []int{32, 64} {
+			for _, unsigned := range []bool{false, true} {
+				for source := 0; source < 32; source++ {
+					for destination := 0; destination < 32; destination++ {
+						word := uint32(0x1e220000) |
+							floatWidth.typeBits<<22 |
+							uint32(source)<<5 |
+							uint32(destination)
+						if integerBits == 64 {
+							word |= 1 << 31
+						}
+						if unsigned {
+							word |= 1 << 16
+						}
+						form, ok := decodeARM64RawScalarIntToFloat(word)
+						if !ok {
+							t.Fatalf("decoder rejected %#08x", word)
+						}
+						if form.floatBits != floatWidth.bits || form.integerBits != integerBits ||
+							form.unsigned != unsigned || form.simdInteger || form.source != source || form.destination != destination {
+							t.Fatalf("decode %#08x = %+v", word, form)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 12288 {
+		t.Fatalf("covered %d scalar integer-to-float encodings, want 12288", count)
+	}
+}
+
+func TestARM64RawScalarIntToFloatCompleteSIMDRegisterFamily(t *testing.T) {
+	var lines []string
+	var wants []arm64RawScalarIntToFloat
+	for _, unsigned := range []bool{false, true} {
+		name := "scvtf"
+		if unsigned {
+			name = "ucvtf"
+		}
+		for _, width := range []struct {
+			bits int
+			name string
+		}{{16, "h"}, {32, "s"}, {64, "d"}} {
+			for source := 0; source < 32; source++ {
+				for destination := 0; destination < 32; destination++ {
+					lines = append(lines, fmt.Sprintf("%s %s%d, %s%d", name, width.name, destination, width.name, source))
+					wants = append(wants, arm64RawScalarIntToFloat{
+						floatBits: width.bits, integerBits: width.bits, unsigned: unsigned,
+						source: source, destination: destination,
+					})
+				}
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, lines, "+fullfp16")
+	var source strings.Builder
+	source.WriteString("TEXT scalarSIMDWords(SB),4,$0-0\n")
+	for _, word := range words {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	for index, word := range words {
+		got, ok := decodeARM64RawScalarIntToFloat(word)
+		want := wants[index]
+		if !ok || !got.simdInteger || got.floatBits != want.floatBits || got.integerBits != want.integerBits ||
+			got.unsigned != want.unsigned || got.source != want.source || got.destination != want.destination {
+			t.Fatalf("LLVM/Go %s (%#08x): decoded %+v, accepted=%v, want %+v", lines[index], word, got, ok, want)
+		}
+		_, effects, registered := decodeARM64RawFloatFamily(word)
+		if !registered || effects.gpReads != 0 || effects.gpWrites != 0 {
+			t.Fatalf("SIMD operand became a GP role for %s: %+v, registered=%v", lines[index], effects, registered)
+		}
+	}
+	if len(words) != 6144 {
+		t.Fatalf("checked %d SIMD scalar words, want 6144", len(words))
+	}
+}
+
+func TestTranslateARM64RawScalarIntToFloatCompleteGPRRegisterFamily(t *testing.T) {
+	floatWidths := []struct {
+		name     string
+		typeBits uint32
+	}{
+		{name: "H", typeBits: 3},
+		{name: "S", typeBits: 0},
+		{name: "D", typeBits: 1},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawScalarIntToFloatFamily(SB),$0-0\n")
+	destination := 0
+	for _, floatWidth := range floatWidths {
+		for _, integerBits := range []int{32, 64} {
+			for _, unsigned := range []bool{false, true} {
+				name := "SCVTF"
+				sourceRegister := "W30"
+				word := uint32(0x1e220000) |
+					floatWidth.typeBits<<22 |
+					uint32(30)<<5 |
+					uint32(destination)
+				if integerBits == 64 {
+					word |= 1 << 31
+					sourceRegister = "X30"
+				}
+				if unsigned {
+					name = "UCVTF"
+					word |= 1 << 16
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s %s%d, %s\n", word, name, floatWidth.name, destination, sourceRegister)
+				destination++
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawScalarIntToFloatFamily": {Name: "rawScalarIntToFloatFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"scvtf ${0:h}, ${1:w}", "scvtf ${0:s}, ${1:x}",
+				"ucvtf ${0:d}, ${1:w}", "ucvtf ${0:h}, ${1:x}",
+				`"target-features"="+fullfp16"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw scalar integer-to-float IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-int-to-float.ll", "arm64-raw-scalar-int-to-float.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarIntToFloatDecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x1ea20000, // Reserved floating type=2 encoding.
+		0x1e02fc20, // Fixed-point SCVTF, a separate encoding family.
+		0x1e200000, // FCVTNS, the opposite conversion direction.
+		0x4e21d800, // Advanced SIMD SCVTF.
+	} {
+		if _, ok := decodeARM64RawScalarIntToFloat(word); ok {
+			t.Fatalf("scalar integer-to-float decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_scalar_vector_fcvtz.go b/arm64_lower_word_scalar_vector_fcvtz.go
new file mode 100644
index 000000000..a40fa9218
--- /dev/null
+++ b/arm64_lower_word_scalar_vector_fcvtz.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawScalarVectorFCVTZ struct {
+	unsigned    bool
+	bits        int
+	source      int
+	destination int
+}
+
+// The scalar Advanced SIMD FCVTZS/FCVTZU forms convert floating-point bits
+// to integer bits in an F/V register. They are distinct from both the vector
+// forms and Go's named scalar conversions to a general-purpose register.
+func decodeARM64RawScalarVectorFCVTZ(word uint32) (arm64RawScalarVectorFCVTZ, bool) {
+	const registers = uint32(31 | 31<<5)
+	forms := map[uint32]struct {
+		unsigned bool
+		bits     int
+	}{
+		0x5ef9b800: {false, 16},
+		0x5ea1b800: {false, 32},
+		0x5ee1b800: {false, 64},
+		0x7ef9b800: {true, 16},
+		0x7ea1b800: {true, 32},
+		0x7ee1b800: {true, 64},
+	}
+	form, ok := forms[word&^registers]
+	if !ok {
+		return arm64RawScalarVectorFCVTZ{}, false
+	}
+	return arm64RawScalarVectorFCVTZ{
+		unsigned:    form.unsigned,
+		bits:        form.bits,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawScalarVectorFCVTZ(form arm64RawScalarVectorFCVTZ) error {
+	return c.lowerARM64ScalarConversion(arm64ScalarConversionForm{
+		arm64ScalarConversionSpec: arm64ScalarConversionSpec{
+			floatBits: form.bits, integerBits: form.bits, unsigned: form.unsigned, simdInteger: true,
+		},
+		source: Reg(fmt.Sprintf("F%d", form.source)), destination: Reg(fmt.Sprintf("F%d", form.destination)),
+		rounding: arm64FloatRoundZero,
+	})
+}
diff --git a/arm64_lower_word_scalar_vector_fcvtz_test.go b/arm64_lower_word_scalar_vector_fcvtz_test.go
new file mode 100644
index 000000000..6289529d6
--- /dev/null
+++ b/arm64_lower_word_scalar_vector_fcvtz_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarVectorFCVTZCompleteFamily(t *testing.T) {
+	forms := []struct {
+		name       string
+		encoding   uint32
+		irFragment string
+	}{
+		{"FCVTZS H", 0x5ef9b800, "fcvtzs ${0:h}, ${1:h}"},
+		{"FCVTZS S", 0x5ea1b800, "fcvtzs ${0:s}, ${1:s}"},
+		{"FCVTZS D", 0x5ee1b800, "fcvtzs ${0:d}, ${1:d}"},
+		{"FCVTZU H", 0x7ef9b800, "fcvtzu ${0:h}, ${1:h}"},
+		{"FCVTZU S", 0x7ea1b800, "fcvtzu ${0:s}, ${1:s}"},
+		{"FCVTZU D", 0x7ee1b800, "fcvtzu ${0:d}, ${1:d}"},
+	}
+	for _, form := range forms {
+		for sourceReg := 0; sourceReg < 32; sourceReg++ {
+			for destinationReg := 0; destinationReg < 32; destinationReg++ {
+				word := form.encoding | uint32(sourceReg)<<5 | uint32(destinationReg)
+				decoded, ok := decodeARM64RawScalarVectorFCVTZ(word)
+				if !ok || decoded.source != sourceReg || decoded.destination != destinationReg {
+					t.Fatalf("%s register fields not decoded for %#08x: %+v, ok=%v", form.name, word, decoded, ok)
+				}
+			}
+		}
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawscalarvectorfcvtz(SB),$0-0\n")
+	for _, form := range forms {
+		word := form.encoding | 31<<5 | 30
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s F31, F30\n", word, form.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawscalarvectorfcvtz": {Name: "rawscalarvectorfcvtz", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, form := range forms {
+				if !strings.Contains(ir, form.irFragment) {
+					t.Fatalf("%s IR omitted %q", form.name, form.irFragment)
+				}
+			}
+			if !strings.Contains(ir, `"target-features"="+fullfp16"`) {
+				t.Fatal("scalar half conversion IR omitted +fullfp16")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-scalar-vector-fcvtz.ll", "arm64-raw-scalar-vector-fcvtz.o", ir)
+		})
+	}
+}
+
+func TestARM64RawScalarVectorFCVTZRuntime(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("native ARM64 runtime required")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawscalarvectorfcvtzruntime(SB),$0-16
+	MOVD input+0(FP), R0
+	MOVD output+8(FP), R1
+	VLD1 (R0), [V1.S4]
+	WORD $0x5ea1b820 // FCVTZS S1, S0
+	VST1 [V0.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawscalarvectorfcvtzruntime": {
+			Name: "rawscalarvectorfcvtzruntime", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawscalarvectorfcvtzruntime(const float *, uint32_t *);
+int main(void) {
+  const float input[4] = {3.75f};
+  uint32_t output[4] = {0};
+  rawscalarvectorfcvtzruntime(input, output);
+  return output[0] == 3 ? 0 : 1;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_scalar_vector_fcvtz", triple, ir, mainC, nil)
+}
+
+func TestARM64RawScalarVectorFCVTZRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x4ea1b800, // Four-lane vector FCVTZS, not scalar.
+		0x1e380000, // FCVTZS to a general-purpose register.
+		0x5ea1d800, // Scalar FRECPE, not a conversion.
+		0x5ee9b800, // Reserved size/opcode combination.
+	} {
+		if _, ok := decodeARM64RawScalarVectorFCVTZ(word); ok {
+			t.Fatalf("scalar vector FCVTZ decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sha3.go b/arm64_lower_word_sha3.go
new file mode 100644
index 000000000..b35295dd0
--- /dev/null
+++ b/arm64_lower_word_sha3.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSHA3Kind uint8
+
+const (
+	arm64RawSHA3EOR3 arm64RawSHA3Kind = iota
+	arm64RawSHA3BCAX
+	arm64RawSHA3RAX1
+	arm64RawSHA3XAR
+)
+
+type arm64RawSHA3 struct {
+	kind        arm64RawSHA3Kind
+	destination int
+	first       int
+	second      int
+	third       int
+	rotate      int
+}
+
+func decodeARM64RawSHA3(word uint32) (arm64RawSHA3, bool) {
+	const (
+		destination = uint32(31)
+		first       = uint32(31 << 5)
+		third       = uint32(31 << 10)
+		rotate      = uint32(63 << 10)
+		second      = uint32(31 << 16)
+	)
+
+	form := arm64RawSHA3{
+		destination: int(word) & 31,
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+	}
+	switch word &^ (destination | first | third | second) {
+	case 0xce000000:
+		form.kind = arm64RawSHA3EOR3
+		form.third = int(word>>10) & 31
+		return form, true
+	case 0xce200000:
+		form.kind = arm64RawSHA3BCAX
+		form.third = int(word>>10) & 31
+		return form, true
+	}
+	if word&^(destination|first|second) == 0xce608c00 {
+		form.kind = arm64RawSHA3RAX1
+		return form, true
+	}
+	if word&^(destination|first|rotate|second) == 0xce800000 {
+		form.kind = arm64RawSHA3XAR
+		form.rotate = int(word>>10) & 63
+		return form, true
+	}
+	return arm64RawSHA3{}, false
+}
+
+func (c *arm64Ctx) lowerRawSHA3(form arm64RawSHA3) error {
+	first, err := c.loadARM64RawSHA3Vector(form.first)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARM64RawSHA3Vector(form.second)
+	if err != nil {
+		return err
+	}
+
+	result := ""
+	switch form.kind {
+	case arm64RawSHA3EOR3, arm64RawSHA3BCAX:
+		third, err := c.loadARM64RawSHA3Vector(form.third)
+		if err != nil {
+			return err
+		}
+		combined := c.newTmp()
+		if form.kind == arm64RawSHA3EOR3 {
+			fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %s\n", combined, second, third)
+		} else {
+			inverted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, <i64 -1, i64 -1>\n", inverted, third)
+			fmt.Fprintf(c.b, "  %%%s = and <2 x i64> %s, %%%s\n", combined, second, inverted)
+		}
+		resultName := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %%%s\n", resultName, first, combined)
+		result = "%" + resultName
+	case arm64RawSHA3RAX1:
+		rotated := c.rotateARM64RawSHA3VectorRight(second, 1)
+		resultName := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %s\n", resultName, first, rotated)
+		result = "%" + resultName
+	case arm64RawSHA3XAR:
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = xor <2 x i64> %s, %s\n", combined, first, second)
+		result = c.rotateARM64RawSHA3VectorRight("%"+combined, form.rotate)
+	default:
+		return fmt.Errorf("arm64 unsupported raw SHA3 kind %d", form.kind)
+	}
+
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <2 x i64> %s to <16 x i8>\n", bytes, result)
+	return c.storeVReg(Reg(fmt.Sprintf("V%d", form.destination)), "%"+bytes)
+}
+
+func (c *arm64Ctx) loadARM64RawSHA3Vector(register int) (string, error) {
+	value, err := c.loadVReg(Reg(fmt.Sprintf("V%d", register)))
+	if err != nil {
+		return "", err
+	}
+	lanes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <2 x i64>\n", lanes, value)
+	return "%" + lanes, nil
+}
+
+func (c *arm64Ctx) rotateARM64RawSHA3VectorRight(value string, amount int) string {
+	if amount == 0 {
+		return value
+	}
+	right := c.newTmp()
+	left := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr <2 x i64> %s, <i64 %d, i64 %d>\n", right, value, amount, amount)
+	fmt.Fprintf(c.b, "  %%%s = shl <2 x i64> %s, <i64 %d, i64 %d>\n", left, value, 64-amount, 64-amount)
+	fmt.Fprintf(c.b, "  %%%s = or <2 x i64> %%%s, %%%s\n", result, right, left)
+	return "%" + result
+}
diff --git a/arm64_lower_word_sha3_test.go b/arm64_lower_word_sha3_test.go
new file mode 100644
index 000000000..002f7333a
--- /dev/null
+++ b/arm64_lower_word_sha3_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSHA3DecoderCompleteArchitectureFamily(t *testing.T) {
+	count := 0
+	for _, base := range []uint32{0xce000000, 0xce200000} {
+		for destination := 0; destination < 32; destination++ {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for third := 0; third < 32; third++ {
+						word := base |
+							uint32(destination) |
+							uint32(first)<<5 |
+							uint32(third)<<10 |
+							uint32(second)<<16
+						form, ok := decodeARM64RawSHA3(word)
+						if !ok || form.destination != destination || form.first != first ||
+							form.second != second || form.third != third {
+							t.Fatalf("decode %#08x = %+v, %v", word, form, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+
+	for destination := 0; destination < 32; destination++ {
+		for first := 0; first < 32; first++ {
+			for second := 0; second < 32; second++ {
+				word := uint32(0xce608c00) |
+					uint32(destination) |
+					uint32(first)<<5 |
+					uint32(second)<<16
+				form, ok := decodeARM64RawSHA3(word)
+				if !ok || form.kind != arm64RawSHA3RAX1 || form.destination != destination ||
+					form.first != first || form.second != second {
+					t.Fatalf("decode %#08x = %+v, %v", word, form, ok)
+				}
+				count++
+			}
+		}
+	}
+
+	for rotate := 0; rotate < 64; rotate++ {
+		for destination := 0; destination < 32; destination++ {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					word := uint32(0xce800000) |
+						uint32(destination) |
+						uint32(first)<<5 |
+						uint32(rotate)<<10 |
+						uint32(second)<<16
+					form, ok := decodeARM64RawSHA3(word)
+					if !ok || form.kind != arm64RawSHA3XAR || form.rotate != rotate ||
+						form.destination != destination || form.first != first || form.second != second {
+						t.Fatalf("decode %#08x = %+v, %v", word, form, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 4227072 {
+		t.Fatalf("covered %d SHA3 encodings, want 4227072", count)
+	}
+}
+
+func TestTranslateARM64RawSHA3CompleteArchitectureFamily(t *testing.T) {
+	const source = `
+TEXT rawSHA3Family(SB),$0-0
+	WORD $0xce1e0922 // EOR3 V2.16B, V9.16B, V30.16B, V2.16B
+	WORD $0xce261ca4 // BCAX V4.16B, V5.16B, V6.16B, V7.16B
+	WORD $0xce6a8d28 // RAX1 V8.2D, V9.2D, V10.2D
+	WORD $0xce8d458b // XAR V11.2D, V12.2D, V13.2D, #17
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSHA3Family": {Name: "rawSHA3Family", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"xor <2 x i64>", "and <2 x i64>",
+				"lshr <2 x i64>", "shl <2 x i64>",
+				`"target-features"="+sha3"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw SHA3 IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sha3.ll", "arm64-raw-sha3.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSHA3RuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawsha3(SB),$0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD c+16(FP), R2
+	MOVD out+24(FP), R3
+	VLD1 (R0), [V0.D2]
+	VLD1 (R1), [V1.D2]
+	VLD1 (R2), [V2.D2]
+	WORD $0xce010803 // EOR3 V3.16B, V0.16B, V1.16B, V2.16B
+	WORD $0xce210804 // BCAX V4.16B, V0.16B, V1.16B, V2.16B
+	WORD $0xce618c05 // RAX1 V5.2D, V0.2D, V1.2D
+	WORD $0xce814406 // XAR V6.2D, V0.2D, V1.2D, #17
+	VST1.P [V3.D2], 16(R3)
+	VST1.P [V4.D2], 16(R3)
+	VST1.P [V5.D2], 16(R3)
+	VST1 [V6.D2], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawsha3": {
+			Name: "rawsha3", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawsha3(const uint64_t *, const uint64_t *, const uint64_t *, uint64_t *);
+static uint64_t ror(uint64_t value, unsigned amount) {
+  return (value >> amount) | (value << (64 - amount));
+}
+int main(void) {
+  const uint64_t a[2] = {0x0123456789abcdefULL, 0xfedcba9876543210ULL};
+  const uint64_t b[2] = {0x1111222233334444ULL, 0x5555666677778888ULL};
+  const uint64_t c[2] = {0xff00ff00aa55aa55ULL, 0x0f0ff0f05a5aa5a5ULL};
+  uint64_t got[8] = {0};
+  rawsha3(a, b, c, got);
+  for (int lane = 0; lane < 2; lane++) {
+    if (got[lane] != (a[lane] ^ b[lane] ^ c[lane])) return 1 + lane;
+    if (got[2 + lane] != (a[lane] ^ (b[lane] & ~c[lane]))) return 3 + lane;
+    if (got[4 + lane] != (a[lane] ^ ror(b[lane], 1))) return 5 + lane;
+    if (got[6 + lane] != ror(a[lane] ^ b[lane], 17)) return 7 + lane;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_sha3", triple, ir, mainC, nil)
+}
+
+func TestARM64RawSHA3DecoderRejectsAdjacentAndReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0xce400000, // Reserved four-register opcode.
+		0xce608800, // RAX1 with reserved fixed bits.
+		0xcec00000, // Different immediate opcode.
+		0x4e201c00, // Advanced SIMD EOR.
+	} {
+		if _, ok := decodeARM64RawSHA3(word); ok {
+			t.Fatalf("SHA3 decoder accepted adjacent/reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_shll_test.go b/arm64_lower_word_shll_test.go
new file mode 100644
index 000000000..836e8ac20
--- /dev/null
+++ b/arm64_lower_word_shll_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSHLLForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = `TEXT rawshll(SB),$0-0
+	WORD $0x2e213ad5 // SHLL V21.8H, V22.8B, #8
+	WORD $0x6e213ad5 // SHLL2 V21.8H, V22.16B, #8
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: arm64LinuxGNUTriple,
+		Sigs:         map[string]FuncSig{"rawshll": {Name: "rawshll", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count := strings.Count(ir, "shl <"); count != 2 {
+		t.Fatalf("SHLL lowering emitted %d vector shifts, want 2:\n%s", count, ir)
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-shll.ll", "arm64-shll.o", ir)
+}
+
+func TestARM64RawSHLLDecoderForms(t *testing.T) {
+	for _, test := range []struct {
+		word uint32
+		op   string
+		src  string
+		dst  string
+	}{
+		{word: 0x2e213ad5, op: "VSHLL", src: "V22.B8", dst: "V21.H8"},
+		{word: 0x6e213ad5, op: "VSHLL2", src: "V22.B16", dst: "V21.H8"},
+	} {
+		decoded, err := decodeARM64RawWordInstruction(Instr{
+			Op:   OpWORD,
+			Args: []Operand{{Kind: OpImm, Imm: int64(test.word)}},
+		})
+		if err != nil {
+			t.Fatalf("decode %#x: %v", test.word, err)
+		}
+		if decoded.Op != Op(test.op) || decoded.Args[1].Reg != Reg(test.src) || decoded.Args[2].Reg != Reg(test.dst) {
+			t.Fatalf("decode %#x = %#v, want %s %s -> %s", test.word, decoded, test.op, test.src, test.dst)
+		}
+	}
+}
diff --git a/arm64_lower_word_shsub_test.go b/arm64_lower_word_shsub_test.go
new file mode 100644
index 000000000..3b78a40d2
--- /dev/null
+++ b/arm64_lower_word_shsub_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawSHSUBForms = `
+TEXT rawshsubforms(SB),$0-0
+	WORD $0x0e222420 // SHSUB V0.8B, V1.8B, V2.8B
+	WORD $0x4e252483 // SHSUB V3.16B, V4.16B, V5.16B
+	WORD $0x0e6824e6 // SHSUB V6.4H, V7.4H, V8.4H
+	WORD $0x4e6b2549 // SHSUB V9.8H, V10.8H, V11.8H
+	WORD $0x0eae25ac // SHSUB V12.2S, V13.2S, V14.2S
+	WORD $0x4eb1260f // SHSUB V15.4S, V16.4S, V17.4S
+	RET
+`
+
+func TestTranslateARM64RawSHSUBCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSHSUBForms, true)
+	file, err := Parse(ArchARM64, arm64RawSHSUBForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawshsubforms": {Name: "rawshsubforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"sub <8 x i16>", "sub <16 x i16>",
+				"sub <4 x i32>", "sub <8 x i32>",
+				"sub <2 x i64>", "sub <4 x i64>", "ashr <",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SHSUB lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-shsub.ll", "arm64-raw-shsub.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSHSUBRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawshsub(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4ea12402 // SHSUB V2.4S, V0.4S, V1.4S
+	VST1 [V2.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawshsub": {
+				Name: "rawshsub", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawshsub(const int32_t *, const int32_t *, int32_t *);
+int main(void) {
+  const int32_t a[4] = {INT32_MIN, INT32_MAX, -3, 4};
+  const int32_t b[4] = {INT32_MAX, INT32_MIN, 4, -3};
+  const int32_t want[4] = {INT32_MIN, INT32_MAX, -4, 3};
+  int32_t got[4] = {0};
+  rawshsub(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_shsub", triple, ll, mainC, nil)
+}
+
+func TestARM64RawSHSUBAndUHSUBDecodeAsOneTypedFamily(t *testing.T) {
+	signed, ok := decodeARM64RawHalvingAddSub(0x0e222420)
+	if !ok || !signed.spec.signed || !signed.spec.subtract {
+		t.Fatalf("SHSUB decode = %#v, %v", signed, ok)
+	}
+	unsigned, ok := decodeARM64RawHalvingAddSub(0x2e222420)
+	if !ok || unsigned.spec.signed || !unsigned.spec.subtract {
+		t.Fatalf("UHSUB decode = %#v, %v", unsigned, ok)
+	}
+}
diff --git a/arm64_lower_word_sm3.go b/arm64_lower_word_sm3.go
new file mode 100644
index 000000000..d55890f28
--- /dev/null
+++ b/arm64_lower_word_sm3.go
@@ -0,0 +1,165 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSM3Kind uint8
+
+const (
+	arm64SM3PARTW1 arm64RawSM3Kind = iota
+	arm64SM3PARTW2
+	arm64SM3SS1
+	arm64SM3TT1A
+	arm64SM3TT1B
+	arm64SM3TT2A
+	arm64SM3TT2B
+)
+
+type arm64RawSM3Spec struct {
+	kind          arm64RawSM3Kind
+	base, mask    uint32
+	indexed       bool
+	fourRegisters bool
+}
+
+// Arm DDI 0602, 2025-03, SM3PARTW1 through SM3TT2B: every form uses
+// 128-bit SIMD registers, never GP register 30 or SP/ZR register 31. Go 1.27
+// has no named NEON SM3 opcode; its WORD encoder emits the literal bits.
+// The fixed-bit masks exclude adjacent SM4, SHA3 and reserved encodings.
+var arm64RawSM3Specs = [...]arm64RawSM3Spec{
+	{kind: arm64SM3PARTW1, base: 0xce60c000, mask: 0xffe0fc00},
+	{kind: arm64SM3PARTW2, base: 0xce60c400, mask: 0xffe0fc00},
+	{kind: arm64SM3SS1, base: 0xce400000, mask: 0xffe08000, fourRegisters: true},
+	{kind: arm64SM3TT1A, base: 0xce408000, mask: 0xffe0cc00, indexed: true},
+	{kind: arm64SM3TT1B, base: 0xce408400, mask: 0xffe0cc00, indexed: true},
+	{kind: arm64SM3TT2A, base: 0xce408800, mask: 0xffe0cc00, indexed: true},
+	{kind: arm64SM3TT2B, base: 0xce408c00, mask: 0xffe0cc00, indexed: true},
+}
+
+type arm64RawSM3 struct {
+	spec                       arm64RawSM3Spec
+	destination, first, second int
+	third, lane                int
+}
+
+func decodeARM64RawSM3(word uint32) (arm64RawSM3, bool) {
+	for _, spec := range arm64RawSM3Specs {
+		if word&spec.mask != spec.base {
+			continue
+		}
+		form := arm64RawSM3{
+			spec: spec, destination: int(word & 31),
+			first: int(word>>5) & 31, second: int(word>>16) & 31,
+		}
+		if spec.fourRegisters {
+			form.third = int(word>>10) & 31
+		}
+		if spec.indexed {
+			form.lane = int(word>>12) & 3
+		}
+		return form, true
+	}
+	return arm64RawSM3{}, false
+}
+
+// Use ordinary modulo-2^32 LLVM arithmetic, not a host SM3 assumption. The
+// semantic oracle separately executes the original raw WORD with Go/QEMU.
+// Read every input before writing the destination, including destructive d
+// and all source/destination aliases. NZCV, GP and memory are unaffected.
+func (c *arm64Ctx) lowerRawSM3(form arm64RawSM3) error {
+	arrangement := arm64VectorArrangement{elementBits: 32, lanes: 4}
+	reg := func(index int) Reg { return Reg(fmt.Sprintf("V%d.S4", index)) }
+	load := func(index int) ([4]string, error) {
+		var lanes [4]string
+		vector, err := c.loadARM64VectorInteger(reg(index), arrangement)
+		if err != nil {
+			return lanes, err
+		}
+		for lane := range lanes {
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <4 x i32> %s, i32 %d\n", name, vector, lane)
+			lanes[lane] = "%" + name
+		}
+		return lanes, nil
+	}
+	n, err := load(form.first)
+	if err != nil {
+		return err
+	}
+	m, err := load(form.second)
+	if err != nil {
+		return err
+	}
+	var d, a [4]string
+	if form.spec.fourRegisters {
+		a, err = load(form.third)
+	} else {
+		d, err = load(form.destination)
+	}
+	if err != nil {
+		return err
+	}
+
+	binary := func(op, left, right string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %s\n", name, op, left, right)
+		return "%" + name
+	}
+	rotate := func(value string, amount int) string {
+		return binary("or", binary("shl", value, fmt.Sprint(amount)),
+			binary("lshr", value, fmt.Sprint(32-amount)))
+	}
+	xor3 := func(first, second, third string) string {
+		return binary("xor", binary("xor", first, second), third)
+	}
+	p1 := func(value string) string {
+		return xor3(value, rotate(value, 15), rotate(value, 23))
+	}
+	var result [4]string
+	switch form.spec.kind {
+	case arm64SM3PARTW1:
+		for lane := 0; lane < 3; lane++ {
+			result[lane] = p1(xor3(d[lane], n[lane], rotate(m[lane+1], 15)))
+		}
+		// The fourth word depends on the already permuted first result word.
+		result[3] = p1(xor3(d[3], n[3], rotate(result[0], 15)))
+	case arm64SM3PARTW2:
+		var temporary [4]string
+		for lane := range result {
+			temporary[lane] = binary("xor", n[lane], rotate(m[lane], 7))
+			result[lane] = binary("xor", d[lane], temporary[lane])
+		}
+		result[3] = binary("xor", result[3], p1(rotate(temporary[0], 15)))
+	case arm64SM3SS1:
+		sum := binary("add", binary("add", rotate(n[3], 12), m[3]), a[3])
+		result = [4]string{"0", "0", "0", rotate(sum, 7)}
+	case arm64SM3TT1A, arm64SM3TT1B, arm64SM3TT2A, arm64SM3TT2B:
+		boolean := xor3(d[3], d[2], d[1])
+		if form.spec.kind == arm64SM3TT1B {
+			boolean = binary("or", binary("or", binary("and", d[3], d[1]),
+				binary("and", d[3], d[2])), binary("and", d[1], d[2]))
+		} else if form.spec.kind == arm64SM3TT2B {
+			boolean = binary("or", binary("and", d[3], d[2]),
+				binary("and", binary("xor", d[3], "-1"), d[1]))
+		}
+		ss := n[3]
+		rotation := 19
+		if form.spec.kind == arm64SM3TT1A || form.spec.kind == arm64SM3TT1B {
+			ss = binary("xor", ss, rotate(d[3], 12))
+			rotation = 9
+		}
+		tt := binary("add", binary("add", binary("add", boolean, d[0]), ss), m[form.lane])
+		if rotation == 19 {
+			tt = xor3(tt, rotate(tt, 9), rotate(tt, 17))
+		}
+		result = [4]string{d[1], rotate(d[2], rotation), d[3], tt}
+	default:
+		return fmt.Errorf("arm64 unsupported raw SM3 operation %d", form.spec.kind)
+	}
+	vector := "zeroinitializer"
+	for lane, value := range result {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %s, i32 %s, i32 %d\n", name, vector, value, lane)
+		vector = "%" + name
+	}
+	return c.storeARM64VectorInteger(reg(form.destination), arrangement, vector)
+}
diff --git a/arm64_lower_word_sm3_test.go b/arm64_lower_word_sm3_test.go
new file mode 100644
index 000000000..cc6a371cb
--- /dev/null
+++ b/arm64_lower_word_sm3_test.go
@@ -0,0 +1,297 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Arm DDI 0602/LLVM MC rows, not derived from the production spec.
+var arm64SM3OracleRows = []struct {
+	name       string
+	base, mask uint32
+	registers  int
+	lanes      int
+}{
+	{name: "sm3partw1", base: 0xce60c000, mask: 0xffe0fc00, registers: 3, lanes: 1},
+	{name: "sm3partw2", base: 0xce60c400, mask: 0xffe0fc00, registers: 3, lanes: 1},
+	{name: "sm3ss1", base: 0xce400000, mask: 0xffe08000, registers: 4, lanes: 1},
+	{name: "sm3tt1a", base: 0xce408000, mask: 0xffe0cc00, registers: 3, lanes: 4},
+	{name: "sm3tt1b", base: 0xce408400, mask: 0xffe0cc00, registers: 3, lanes: 4},
+	{name: "sm3tt2a", base: 0xce408800, mask: 0xffe0cc00, registers: 3, lanes: 4},
+	{name: "sm3tt2b", base: 0xce408c00, mask: 0xffe0cc00, registers: 3, lanes: 4},
+}
+
+type arm64SM3OracleCase struct {
+	name, native string
+	word         uint32
+	kind         int
+	d, n, m, a   int
+	lane         int
+}
+
+func arm64SM3Case(kind, d, n, m, a, lane int) arm64SM3OracleCase {
+	row := arm64SM3OracleRows[kind]
+	word := row.base | uint32(d) | uint32(n)<<5 | uint32(m)<<16
+	native := fmt.Sprintf("%s v%d.4s, v%d.4s, v%d.4s", row.name, d, n, m)
+	if row.registers == 4 {
+		word |= uint32(a) << 10
+		native += fmt.Sprintf(", v%d.4s", a)
+	} else if row.lanes == 4 {
+		word |= uint32(lane) << 12
+		native = fmt.Sprintf("%s v%d.4s, v%d.4s, v%d.s[%d]", row.name, d, n, m, lane)
+	}
+	return arm64SM3OracleCase{
+		word: word, native: native, kind: kind, d: d, n: n, m: m, a: a, lane: lane,
+	}
+}
+
+func arm64SM3AliasCases() []arm64SM3OracleCase {
+	triples := [][4]int{{0, 0, 0}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {0, 1, 2}}
+	// Every set partition of the four encoded SS1 registers, including all
+	// three destination aliases, both source pairs and all-equal registers.
+	quadruples := [][4]int{
+		{0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 0}, {0, 0, 1, 1}, {0, 0, 1, 2},
+		{0, 1, 0, 0}, {0, 1, 0, 1}, {0, 1, 0, 2}, {0, 1, 1, 0}, {0, 1, 1, 1},
+		{0, 1, 1, 2}, {0, 1, 2, 0}, {0, 1, 2, 1}, {0, 1, 2, 2}, {0, 1, 2, 3},
+	}
+	var cases []arm64SM3OracleCase
+	for kind, row := range arm64SM3OracleRows {
+		aliases := triples
+		if row.registers == 4 {
+			aliases = quadruples
+		}
+		for lane := 0; lane < row.lanes; lane++ {
+			for _, alias := range aliases {
+				offset := len(cases) % 32
+				tc := arm64SM3Case(kind, (offset+alias[0])%32, (offset+alias[1])%32,
+					(offset+alias[2])%32, (offset+alias[3])%32, lane)
+				tc.name = fmt.Sprintf("sm3case%d", len(cases))
+				cases = append(cases, tc)
+			}
+		}
+	}
+	return cases
+}
+
+func TestARM64RawSM3CompleteEncodingSpace(t *testing.T) {
+	if len(arm64RawSM3Specs) != 7 {
+		t.Fatal("SM3 family is not the complete seven Arm operations")
+	}
+	count := 0
+	for kind, row := range arm64SM3OracleRows {
+		extraCount := row.lanes
+		if row.registers == 4 {
+			extraCount = 32
+		}
+		for d := 0; d < 32; d++ {
+			for n := 0; n < 32; n++ {
+				for m := 0; m < 32; m++ {
+					for extra := 0; extra < extraCount; extra++ {
+						a, lane := 0, 0
+						if row.registers == 4 {
+							a = extra
+						} else if row.lanes == 4 {
+							lane = extra
+						}
+						word := row.base | uint32(d) | uint32(n)<<5 | uint32(m)<<16
+						if row.registers == 4 {
+							word |= uint32(a) << 10
+						} else if row.lanes == 4 {
+							word |= uint32(lane) << 12
+						}
+						form, ok := decodeARM64RawSM3(word)
+						if !ok || int(form.spec.kind) != kind || form.destination != d || form.first != n ||
+							form.second != m || form.third != a || form.lane != lane {
+							t.Fatalf("%s %#08x: %+v, %v", row.name, word, form, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 1638400 {
+		t.Fatalf("checked %d encodings, want 1638400", count)
+	}
+	for _, row := range arm64SM3OracleRows {
+		for bit := uint(0); bit < 32; bit++ {
+			if row.mask&(1<<bit) == 0 {
+				continue
+			}
+			word := row.base ^ (1 << bit)
+			expected := -1
+			for kind, candidate := range arm64SM3OracleRows {
+				if word&candidate.mask == candidate.base {
+					expected = kind // A legitimate sibling is not a reserved encoding.
+				}
+			}
+			form, ok := decodeARM64RawSM3(word)
+			if ok != (expected >= 0) || ok && int(form.spec.kind) != expected {
+				t.Fatalf("mutated fixed bit %d in %#08x: %+v, %v; expected kind %d", bit, word, form, ok, expected)
+			}
+		}
+	}
+	for _, word := range []uint32{0xce60c800, 0xcec08400, 0xce608c00, 0xce000000, 0xce40c000, 0xce608000} {
+		if _, ok := decodeARM64RawSM3(word); ok {
+			t.Fatalf("SM3 decoder captured adjacent or reserved encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawSM3LLVMEncodingAndOperandAxes(t *testing.T) {
+	cases := arm64SM3AliasCases()
+	for kind, row := range arm64SM3OracleRows {
+		for lane := 0; lane < row.lanes; lane++ {
+			for register := 0; register < 32; register++ {
+				cases = append(cases, arm64SM3Case(kind, register, (register+1)%32,
+					(register+2)%32, (register+3)%32, lane))
+			}
+		}
+	}
+	lines := make([]string, len(cases))
+	for index, tc := range cases {
+		lines[index] = tc.native
+	}
+	words := assembleARM64LLVMWords(t, lines, "+sm4")
+	for index, word := range words {
+		if word != cases[index].word {
+			t.Fatalf("LLVM22 %q: word %#08x, want Arm encoding %#08x", lines[index], word, cases[index].word)
+		}
+		effects, known := arm64RawContinuationEffectsForWord(word)
+		if !known || effects != (arm64RawContinuationEffects{}) {
+			t.Fatalf("SM3 has GP/SP or memory effects: %#08x %+v %v", word, effects, known)
+		}
+	}
+}
+
+func TestARM64RawSM3GoFrontendNamespace(t *testing.T) {
+	for _, file := range []string{"anames.go", "asm7.go"} {
+		body, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "arm64", file))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Contains(string(body), "SM3PARTW1") || strings.Contains(string(body), "SM3TT1A") {
+			t.Fatal("Go added named SM3 forms; audit its full encoder before retaining a WORD-only contract")
+		}
+	}
+	for _, row := range arm64SM3OracleRows {
+		instruction := strings.ToUpper(row.name) + " V0.S4,V1.S4,V2.S4"
+		if row.registers == 4 {
+			instruction += ",V3.S4"
+		} else if row.lanes == 4 {
+			instruction = strings.ToUpper(row.name) + " V0.S4,V1.S4,V2.S[0]"
+		}
+		requireARM64GoAssemblerResult(t, "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", false)
+	}
+}
+
+func TestARM64RawSM3AliasesLanesAndLLVM22Objects(t *testing.T) {
+	cases := arm64SM3AliasCases()
+	if len(cases) != 105 {
+		t.Fatalf("generated %d alias/lane cases, want 105", len(cases))
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, tc := range cases {
+		source.WriteString(arm64SM3Fixture(tc.name, tc.word))
+		sigs[tc.name] = arm64SM3Signature(tc.name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "@llvm.aarch64.crypto.sm3") {
+				t.Fatal("portable SM3 arithmetic acquired a host-feature-gated intrinsic")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-sm3-aliases.ll", "raw-sm3-aliases.o", ir)
+		})
+	}
+}
+
+func arm64SM3Signature(name string) FuncSig {
+	return FuncSig{
+		Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}},
+	}
+}
+
+func arm64SM3Fixture(name string, word uint32) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+	for register := 0; register < 32; register++ {
+		fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.S4]\n", register)
+	}
+	// Independent 64-bit input words seed arithmetic NZCV states. The vector
+	// operation must preserve every flag, not only one conditional sentinel.
+	source.WriteString("MOVD -512(R0),R2\nMOVD -504(R0),R3\nADDS R3,R2,R2\n")
+	fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	for register := 0; register < 32; register++ {
+		fmt.Fprintf(&source, "VST1.P [V%d.S4],16(R1)\n", register)
+	}
+	source.WriteString("CSET MI,R2\nCSET EQ,R3\nORR R3<<1,R2,R2\n")
+	source.WriteString("CSET CS,R3\nORR R3<<2,R2,R2\nCSET VS,R3\nORR R3<<3,R2,R2\n")
+	source.WriteString("MOVD R2,(R1)\nRET\n")
+	return source.String()
+}
+
+func TestARM64RawSM3FixtureObservesEveryNZCVFlag(t *testing.T) {
+	source := arm64SM3Fixture("sm3flags", 0xce63c004)
+	for _, instruction := range []string{"CSET MI,R2", "CSET EQ,R3", "CSET CS,R3", "CSET VS,R3"} {
+		if !strings.Contains(source, instruction) {
+			t.Errorf("runtime fixture does not observe %s", instruction)
+		}
+	}
+}
+
+func TestARM64RawSM3OriginalAndCompleteFamily(t *testing.T) {
+	words := []uint32{
+		0xce63c004,             // Original gmsm SM3PARTW1.
+		0xce66c4e4,             // Original gmsm SM3PARTW2.
+		0xce4b2505,             // Original gmsm SM3SS1.
+		0xce4a80a8, 0xce4ab4a8, // SM3TT1A / SM3TT1B, lanes 0 / 3.
+		0xce4088a9, 0xce40bca9, // SM3TT2A / SM3TT2B, lanes 0 / 3.
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, word := range words {
+		name := fmt.Sprintf("sm3original%d", index)
+		source.WriteString(arm64SM3Fixture(name, word))
+		sigs[name] = arm64SM3Signature(name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target, "raw-sm3.ll", "raw-sm3.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sm4.go b/arm64_lower_word_sm4.go
new file mode 100644
index 000000000..181196df4
--- /dev/null
+++ b/arm64_lower_word_sm4.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSM4Spec struct {
+	base        uint32
+	mask        uint32
+	intrinsic   string
+	destructive bool
+}
+
+// Arm DDI 0602: the Advanced SIMD SM4 family has only 128-bit, four-word
+// register forms. Unlike SVE ZSM4E/ZSM4EKEY, Go exposes these through WORD.
+// Keep decoding, implicit inputs, liveness and declarations on one spec.
+var arm64RawSM4Specs = [...]arm64RawSM4Spec{
+	{base: 0xcec08400, mask: 0xfffffc00, intrinsic: "sm4e", destructive: true},
+	{base: 0xce60c800, mask: 0xffe0fc00, intrinsic: "sm4ekey"},
+}
+
+type arm64RawSM4 struct {
+	spec                       arm64RawSM4Spec
+	first, second, destination int
+}
+
+func decodeARM64RawSM4(word uint32) (arm64RawSM4, bool) {
+	for _, spec := range arm64RawSM4Specs {
+		if word&spec.mask != spec.base {
+			continue
+		}
+		form := arm64RawSM4{
+			spec: spec, destination: int(word & 31),
+			first: int(word>>5) & 31, second: int(word>>16) & 31,
+		}
+		if spec.destructive {
+			form.second = form.first
+			form.first = form.destination
+		}
+		return form, true
+	}
+	return arm64RawSM4{}, false
+}
+
+func (c *arm64Ctx) lowerRawSM4(form arm64RawSM4) error {
+	arrangement := arm64VectorArrangement{elementBits: 32, lanes: 4}
+	reg := func(index int) Reg { return Reg(fmt.Sprintf("V%d.S4", index)) }
+	first, err := c.loadARM64VectorInteger(reg(form.first), arrangement)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARM64VectorInteger(reg(form.second), arrangement)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x i32> @llvm.aarch64.crypto.%s(<4 x i32> %s, <4 x i32> %s)\n",
+		result, form.spec.intrinsic, first, second)
+	return c.storeARM64VectorInteger(reg(form.destination), arrangement, "%"+result)
+}
diff --git a/arm64_lower_word_sm4_test.go b/arm64_lower_word_sm4_test.go
new file mode 100644
index 000000000..dee7eb491
--- /dev/null
+++ b/arm64_lower_word_sm4_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSM4DecoderCompleteRegisterSpace(t *testing.T) {
+	count := 0
+	for d := 0; d < 32; d++ {
+		for n := 0; n < 32; n++ {
+			word := uint32(0xcec08400 | n<<5 | d)
+			form, ok := decodeARM64RawSM4(word)
+			if !ok || form.spec.intrinsic != "sm4e" || form.first != d || form.second != n || form.destination != d {
+				t.Fatalf("SM4E %#08x decoded as %+v, %v", word, form, ok)
+			}
+			count++
+			for m := 0; m < 32; m++ {
+				word := uint32(0xce60c800 | m<<16 | n<<5 | d)
+				form, ok := decodeARM64RawSM4(word)
+				if !ok || form.spec.intrinsic != "sm4ekey" || form.first != n || form.second != m || form.destination != d {
+					t.Fatalf("SM4EKEY %#08x decoded as %+v, %v", word, form, ok)
+				}
+				count++
+			}
+		}
+	}
+	if count != 33792 {
+		t.Fatalf("tested %d encodings, want 33792", count)
+	}
+	// Every non-register bit is fixed, including the fixed .4S arrangement.
+	for _, spec := range arm64RawSM4Specs {
+		for bit := uint(0); bit < 32; bit++ {
+			if spec.mask&(1<<bit) == 0 {
+				continue
+			}
+			word := spec.base ^ (1 << bit)
+			if form, ok := decodeARM64RawSM4(word); ok {
+				t.Fatalf("accepted mutated fixed bit %d in %#08x: %+v", bit, word, form)
+			}
+		}
+	}
+}
+
+func TestARM64RawSM4LLVMAssemblerOracle(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc not found")
+	}
+	for _, tc := range []struct{ instruction, encoding string }{
+		{"sm4e v2.4s, v15.4s", "[0xe2,0x85,0xc0,0xce]"},
+		{"sm4ekey v11.4s, v11.4s, v19.4s", "[0x6b,0xc9,0x73,0xce]"},
+		{"sm4e v31.4s, v31.4s", "[0xff,0x87,0xc0,0xce]"},
+		{"sm4ekey v31.4s, v0.4s, v31.4s", "[0x1f,0xc8,0x7f,0xce]"},
+	} {
+		cmd := exec.Command(mc, "-triple=aarch64", "-mattr=+sm4", "-show-encoding")
+		cmd.Stdin = strings.NewReader(tc.instruction + "\n")
+		output, err := cmd.CombinedOutput()
+		if err != nil || !strings.Contains(string(output), tc.encoding) {
+			t.Fatalf("LLVM oracle %q: %v\n%s", tc.instruction, err, output)
+		}
+	}
+}
+
+func TestARM64RawSM4CompleteForms(t *testing.T) {
+	// NEON SM4 is WORD-only in Go; ZSM4E/ZSM4EKEY are separate SVE forms.
+	// Include the independent LLVM MC fixtures and the discovering library.
+	words := []uint32{0xce73c96b, 0xcec085e2, 0xce60c928, 0xcec08560, 0xcec08660, 0xcec08408}
+	for r := uint32(0); r < 32; r++ {
+		words = append(words, 0xcec08400|r<<5|r)
+		words = append(words, 0xce60c800|r<<16|((r+1)%32)<<5|((r+2)%32))
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, word := range words {
+		name := fmt.Sprintf("sm4form%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for r := 0; r < 32; r++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.S4]\n", r)
+		}
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		// Keep each instruction's result live so llc must select its encoding.
+		fmt.Fprintf(&source, "VST1 [V%d.S4],(R1)\nRET\n", word&31)
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: triple,
+				Sigs: sigs,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, expected := range []string{
+				"call <4 x i32> @llvm.aarch64.crypto.sm4e(",
+				"call <4 x i32> @llvm.aarch64.crypto.sm4ekey(",
+				`"target-features"="+sm4"`,
+			} {
+				if !strings.Contains(ir, expected) {
+					t.Fatalf("missing %q", expected)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "sm4.ll", "sm4.o", ir)
+		})
+	}
+}
+
+func TestARM64SM4RejectsInventedNamedNEONForms(t *testing.T) {
+	for _, instruction := range []string{
+		"SM4E V1.S4, V2.S4", "VSM4E V1.S4, V2.S4",
+		"SM4EKEY V1.S4, V2.S4, V3.S4", "VSM4EKEY V1.S4, V2.S4, V3.S4",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT invalidsm4(SB),4,$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{
+				Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"invalidsm4": {Name: "invalidsm4", Ret: Void}},
+			})
+			if err == nil {
+				t.Fatalf("accepted Go-rejected form %q", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_word_sme_mopa.go b/arm64_lower_word_sme_mopa.go
new file mode 100644
index 000000000..9f2528bc8
--- /dev/null
+++ b/arm64_lower_word_sme_mopa.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSMEOuterProduct struct {
+	op         string
+	tile       int
+	first      int
+	second     int
+	firstPred  int
+	secondPred int
+	sourceBits int
+}
+
+// These ZA.S and ZA.D forms share one register grammar. The fixed encodings come from
+// LLVM 22's AArch64 SME assembler; only tile, Z, and governing P fields vary.
+var arm64RawSMEOuterProductBases = map[uint32]struct {
+	op         string
+	sourceBits int
+}{
+	0x80800000: {"fmopa", 32},
+	0x80c00000: {"fmopa", 64},
+	0x81800000: {"bfmopa", 16},
+	0xa0800000: {"smopa", 8},
+	0xa0a00000: {"sumopa", 8},
+	0xa1a00000: {"umopa", 8},
+}
+
+func decodeARM64RawSMEOuterProduct(word uint32) (arm64RawSMEOuterProduct, bool) {
+	const variableFields = uint32(0x001fffe3)
+	spec, ok := arm64RawSMEOuterProductBases[word&^variableFields]
+	if !ok {
+		return arm64RawSMEOuterProduct{}, false
+	}
+	return arm64RawSMEOuterProduct{
+		op:         spec.op,
+		tile:       int(word) & 3,
+		first:      int(word>>5) & 31,
+		second:     int(word>>16) & 31,
+		firstPred:  int(word>>10) & 7,
+		secondPred: int(word>>13) & 7,
+		sourceBits: spec.sourceBits,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSMEOuterProduct(form arm64RawSMEOuterProduct) error {
+	firstPred, _, err := c.loadPRegElements(form.firstPred, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	secondPred, _, err := c.loadPRegElements(form.secondPred, form.sourceBits)
+	if err != nil {
+		return err
+	}
+	firstType := "<vscale x 16 x i8>"
+	firstValue := ""
+	secondValue := ""
+	if form.sourceBits == 8 {
+		firstValue, err = c.loadZReg(form.first)
+		if err != nil {
+			return err
+		}
+		secondValue, err = c.loadZReg(form.second)
+		if err != nil {
+			return err
+		}
+	} else if form.sourceBits == 16 {
+		firstValue, firstType, err = c.loadZRegElements(form.first, 16)
+		if err != nil {
+			return err
+		}
+		secondValue, _, err = c.loadZRegElements(form.second, 16)
+		if err != nil {
+			return err
+		}
+	} else {
+		firstValue, firstType, err = c.loadRawSVEFloatVector(form.first, form.sourceBits)
+		if err != nil {
+			return err
+		}
+		secondValue, _, err = c.loadRawSVEFloatVector(form.second, form.sourceBits)
+		if err != nil {
+			return err
+		}
+	}
+	width := "b"
+	outputWidth := "s"
+	if form.sourceBits == 16 {
+		width = "h"
+	} else if form.sourceBits == 32 {
+		width = "s"
+	} else if form.sourceBits == 64 {
+		width = "d"
+		outputWidth = "d"
+	}
+	assembly := fmt.Sprintf("%s za%d.%s, $0/m, $1/m, $2.%s, $3.%s",
+		form.op, form.tile, outputWidth, width, width)
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", 128/form.sourceBits)
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s %s, %s %s, %s %s, %s %s)\n",
+		assembly, "@3Upl,@3Upl,w,w,~{memory}",
+		predicateType, firstPred, predicateType, secondPred,
+		firstType, firstValue, firstType, secondValue)
+	return nil
+}
+
+type arm64RawSMETileRead struct {
+	bits        int
+	destination int
+	predicate   int
+	row         int
+	tile        int
+	index       int
+	vertical    bool
+}
+
+func decodeARM64RawSMETileRead(word uint32) (arm64RawSMETileRead, bool) {
+	const variableFields = uint32(0x00c0fdff)
+	if word&^variableFields != 0xc0020000 {
+		return arm64RawSMETileRead{}, false
+	}
+	return decodeARM64RawSMETileFields(word, false), true
+}
+
+func decodeARM64RawSMETileWrite(word uint32) (arm64RawSMETileRead, bool) {
+	const variableFields = uint32(0x00c0ffef)
+	if word&^variableFields != 0xc0000000 {
+		return arm64RawSMETileRead{}, false
+	}
+	return decodeARM64RawSMETileFields(word, true), true
+}
+
+func decodeARM64RawSMETileFields(word uint32, write bool) arm64RawSMETileRead {
+	bits := 8 << (word >> 22 & 3)
+	indexBits := 0
+	for count := 128 / bits; count > 1; count >>= 1 {
+		indexBits++
+	}
+	indexMask := (1 << indexBits) - 1
+	indexAndTile := int(word>>5) & 15
+	vector := int(word) & 31
+	if write {
+		indexAndTile = int(word) & 15
+		vector = int(word>>5) & 31
+	}
+	return arm64RawSMETileRead{
+		bits:        int(bits),
+		destination: vector,
+		predicate:   int(word>>10) & 7,
+		row:         12 + int(word>>13&3),
+		tile:        indexAndTile >> indexBits,
+		index:       indexAndTile & indexMask,
+		vertical:    word&(1<<15) != 0,
+	}
+}
+
+func (c *arm64Ctx) lowerRawSMETileRead(form arm64RawSMETileRead) error {
+	old, vectorType, err := c.loadZRegElements(form.destination, form.bits)
+	if err != nil {
+		return err
+	}
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	row, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.row)))
+	if err != nil {
+		return err
+	}
+	width := map[int]string{8: "b", 16: "h", 32: "s", 64: "d"}[form.bits]
+	direction := "h"
+	if form.vertical {
+		direction = "v"
+	}
+	assembly := fmt.Sprintf("mov w12, ${3:w}; mov $0.%s, $2/m, za%d%s.%s[w12, %d]",
+		width, form.tile, direction, width, form.index)
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s, <vscale x 16 x i1> %s, i64 %s)\n",
+		result, vectorType, assembly, "=w,0,@3Upl,r,~{memory},~{x12}",
+		vectorType, old, predicate, row)
+	return c.storeZRegElements(form.destination, form.bits, "%"+result)
+}
+
+func (c *arm64Ctx) lowerRawSMETileWrite(form arm64RawSMETileRead) error {
+	vector, vectorType, err := c.loadZRegElements(form.destination, form.bits)
+	if err != nil {
+		return err
+	}
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	row, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.row)))
+	if err != nil {
+		return err
+	}
+	width := map[int]string{8: "b", 16: "h", 32: "s", 64: "d"}[form.bits]
+	direction := "h"
+	if form.vertical {
+		direction = "v"
+	}
+	assembly := fmt.Sprintf("mov w12, ${2:w}; mov za%d%s.%s[w12, %d], $0/m, $1.%s",
+		form.tile, direction, width, form.index, width)
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(<vscale x 16 x i1> %s, %s %s, i64 %s)\n",
+		assembly, "@3Upl,w,r,~{memory},~{x12}", predicate, vectorType, vector, row)
+	return nil
+}
diff --git a/arm64_lower_word_sme_mopa_test.go b/arm64_lower_word_sme_mopa_test.go
new file mode 100644
index 000000000..4697edbda
--- /dev/null
+++ b/arm64_lower_word_sme_mopa_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSMEOuterProductAndTileRegisterFields(t *testing.T) {
+	if form, ok := decodeARM64RawSMEOuterProduct(0x80800020); !ok ||
+		form.op != "fmopa" || form.first != 1 || form.second != 0 ||
+		form.firstPred != 0 || form.secondPred != 0 || form.sourceBits != 32 {
+		t.Fatalf("FMOPA ZA0.S with Z1/Z0 decode = %+v, %v", form, ok)
+	}
+	if form, ok := decodeARM64RawSMEOuterProduct(0x80c30002); !ok || form.tile != 2 || form.second != 3 || form.sourceBits != 64 {
+		t.Fatalf("FMOPA ZA2.D decode = %+v, %v", form, ok)
+	}
+	if form, ok := decodeARM64RawSMETileWrite(0xc0808200); !ok ||
+		form.destination != 16 || form.row != 12 || form.index != 0 || form.tile != 0 || !form.vertical {
+		t.Fatalf("ZA vertical write from Z16 decode = %+v, %v", form, ok)
+	}
+	if form, ok := decodeARM64RawSMETileWrite(0xc080e063); !ok ||
+		form.destination != 3 || form.row != 15 || form.index != 3 || form.tile != 0 || !form.vertical {
+		t.Fatalf("ZA vertical write index 3 from Z3 decode = %+v, %v", form, ok)
+	}
+}
+
+func TestTranslateARM64RawSMEOuterProductGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSMEOuterProduct(SB),$0-0
+	MOVD $0, R12
+	WORD $0xd503477f // SMSTART
+	WORD $0x2598e3e0 // PTRUE P0.S
+	WORD $0xc00800ff // ZERO {ZA}
+	WORD $0x80800020 // FMOPA ZA0.S, P0/M, P0/M, Z1.S, Z0.S
+	WORD $0x80810000 // FMOPA ZA0.S, P0/M, P0/M, Z0.S, Z1.S
+	WORD $0xc0820000 // MOV Z0.S, P0/M, ZA0H.S[W12, 0]
+	WORD $0x80c10000 // FMOPA ZA0.D, P0/M, P0/M, Z0.D, Z1.D
+	WORD $0x81810000 // BFMOPA ZA0.S, P0/M, P0/M, Z0.H, Z1.H
+	WORD $0xa0810000 // SMOPA ZA0.S, P0/M, P0/M, Z0.B, Z1.B
+	WORD $0xa0a10000 // SUMOPA ZA0.S, P0/M, P0/M, Z0.B, Z1.B
+	WORD $0xa1a10000 // UMOPA ZA0.S, P0/M, P0/M, Z0.B, Z1.B
+	WORD $0xc080e000 // MOV ZA0V.S[W15, 0], P0/M, Z0.S
+	WORD $0xd503467f // SMSTOP
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSMEOuterProduct": {Name: "rawSMEOuterProduct", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "fmopa`, `asm sideeffect "bfmopa`,
+				`asm sideeffect "smopa`, `asm sideeffect "sumopa`,
+				`asm sideeffect "umopa`, `za0h.s`, `za0v.s`, `+sme-f64f64`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("SME outer-product lowering omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sme-mopa.ll", "arm64-raw-sme-mopa.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sme_tile_memory.go b/arm64_lower_word_sme_tile_memory.go
new file mode 100644
index 000000000..9ca5edafd
--- /dev/null
+++ b/arm64_lower_word_sme_tile_memory.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSMETileMemory struct {
+	bits      int
+	tile      int
+	index     int
+	row       int
+	predicate int
+	base      int
+	offset    int
+	vertical  bool
+	store     bool
+}
+
+// SME ZA tile LD1/ST1 share one four-width grammar. The low four bits encode
+// tile number and slice index together; their split depends on element width.
+// Bit 4 is reserved and must not be mistaken for part of the tile field.
+func decodeARM64RawSMETileMemory(word uint32) (arm64RawSMETileMemory, bool) {
+	const variableFields = uint32(0x00ffffef)
+	if word&^variableFields != 0xe0000000 {
+		return arm64RawSMETileMemory{}, false
+	}
+	size := int(word>>22) & 3
+	indexBits := 4 - size
+	indexAndTile := int(word) & 15
+	return arm64RawSMETileMemory{
+		bits:      8 << size,
+		tile:      indexAndTile >> indexBits,
+		index:     indexAndTile & ((1 << indexBits) - 1),
+		row:       12 + int(word>>13&3),
+		predicate: int(word>>10) & 7,
+		base:      int(word>>5) & 31,
+		offset:    int(word>>16) & 31,
+		vertical:  word&(1<<15) != 0,
+		store:     word&(1<<21) != 0,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSMETileMemory(form arm64RawSMETileMemory) error {
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		baseReg = SP
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	row, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.row)))
+	if err != nil {
+		return err
+	}
+
+	width := map[int]string{8: "b", 16: "h", 32: "w", 64: "d"}[form.bits]
+	tileWidth := map[int]string{8: "b", 16: "h", 32: "s", 64: "d"}[form.bits]
+	direction := "h"
+	if form.vertical {
+		direction = "v"
+	}
+	mnemonic := "ld1" + width
+	predicateMode := "/z"
+	if form.store {
+		mnemonic = "st1" + width
+		predicateMode = ""
+	}
+	assembly := fmt.Sprintf("%s {za%d%s.%s[w12, %d]}, $0%s, [$1]",
+		mnemonic, form.tile, direction, tileWidth, form.index, predicateMode)
+	if form.offset == 31 {
+		assembly = "mov w12, ${2:w}; " + assembly
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(<vscale x 16 x i1> %s, i64 %s, i64 %s)\n",
+			assembly, "@3Upl,r,r,~{memory},~{x12}", predicate, base, row)
+		return nil
+	}
+
+	offset, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.offset)))
+	if err != nil {
+		return err
+	}
+	address := "[$1, $2]"
+	if form.bits != 8 {
+		shift := map[int]int{16: 1, 32: 2, 64: 3}[form.bits]
+		address = fmt.Sprintf("[$1, $2, lsl #%d]", shift)
+	}
+	assembly = fmt.Sprintf("%s {za%d%s.%s[w12, %d]}, $0%s, %s",
+		mnemonic, form.tile, direction, tileWidth, form.index, predicateMode, address)
+	assembly = "mov w12, ${3:w}; " + assembly
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(<vscale x 16 x i1> %s, i64 %s, i64 %s, i64 %s)\n",
+		assembly, "@3Upl,r,r,r,~{memory},~{x12}", predicate, base, offset, row)
+	return nil
+}
diff --git a/arm64_lower_word_sme_tile_memory_test.go b/arm64_lower_word_sme_tile_memory_test.go
new file mode 100644
index 000000000..d05d0d845
--- /dev/null
+++ b/arm64_lower_word_sme_tile_memory_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSMETileMemoryCompleteLLVM22EncodingFields(t *testing.T) {
+	// LLVM 22's SME assembler emitted these words. Together they cover both
+	// memory directions, all widths, H/V tiles, SP, register offsets, and
+	// maximum tile/slice/predicate/row fields.
+	cases := []struct {
+		word      uint32
+		bits      int
+		tile      int
+		index     int
+		row       int
+		predicate int
+		base      int
+		offset    int
+		vertical  bool
+		store     bool
+	}{
+		{0xe01f0020, 8, 0, 0, 12, 0, 1, 31, false, false},
+		{0xe002ffef, 8, 0, 15, 15, 7, 31, 2, true, false},
+		{0xe0452c8f, 16, 1, 7, 13, 3, 4, 5, false, false},
+		{0xe087d8cf, 32, 3, 3, 14, 6, 6, 7, true, false},
+		{0xe0c97d0f, 64, 7, 1, 15, 7, 8, 9, false, false},
+		{0xe03f0020, 8, 0, 0, 12, 0, 1, 31, false, true},
+		{0xe022ffef, 8, 0, 15, 15, 7, 31, 2, true, true},
+		{0xe0652c8f, 16, 1, 7, 13, 3, 4, 5, false, true},
+		{0xe0a7d8cf, 32, 3, 3, 14, 6, 6, 7, true, true},
+		{0xe0e97d0f, 64, 7, 1, 15, 7, 8, 9, false, true},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawSMETileMemoryForms(SB),$0-0\n")
+	for _, want := range cases {
+		got, ok := decodeARM64RawSMETileMemory(want.word)
+		if !ok || got.bits != want.bits || got.tile != want.tile ||
+			got.index != want.index || got.row != want.row ||
+			got.predicate != want.predicate || got.base != want.base ||
+			got.offset != want.offset || got.vertical != want.vertical ||
+			got.store != want.store {
+			t.Fatalf("SME tile memory word %#08x decoded as %+v, ok=%v", want.word, got, ok)
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", want.word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSMETileMemoryForms": {Name: "rawSMETileMemoryForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sme-tile-memory-forms.ll", "arm64-raw-sme-tile-memory-forms.o", ir)
+		})
+	}
+
+	if _, ok := decodeARM64RawSMETileMemory(0xe01f0030); ok {
+		t.Fatal("accepted SME tile memory encoding with reserved bit 4")
+	}
+}
+
+func TestTranslateARM64RawSMETileMemoryGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSMETileMemory(SB),$0-0
+	MOVD $0, R12
+	WORD $0xd503477f // SMSTART
+	WORD $0x2518e3e0 // PTRUE P0.B
+	WORD $0xe01f0020 // LD1B {ZA0H.B[W12, 0]}, P0/Z, [X1]
+	WORD $0xe03f0000 // ST1B {ZA0H.B[W12, 0]}, P0, [X0]
+	WORD $0xd503467f // SMSTOP
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSMETileMemory": {Name: "rawSMETileMemory", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sme-tile-memory.ll", "arm64-raw-sme-tile-memory.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_smov_test.go b/arm64_lower_word_smov_test.go
new file mode 100644
index 000000000..b873a0dad
--- /dev/null
+++ b/arm64_lower_word_smov_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSignedLaneExtractReportedWord(t *testing.T) {
+	const source = `TEXT signedLane(SB), $0-0
+	WORD $0x4e042c00 // SMOV V0.S[0], R0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"signedLane": {Name: "signedLane", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawSignedLaneExtractCompleteArchitecturalFormats(t *testing.T) {
+	// x/arch/arm64asm/inst.json has two SMOV encodings: Wd accepts B/H
+	// lanes, while Xd accepts B/H/S lanes. Go's named assembler has no SMOV
+	// spelling, but WORD in Go source can encode every one of these forms.
+	var source strings.Builder
+	source.WriteString("TEXT signedLanes(SB), $0-0\n")
+	for _, form := range []struct {
+		wide      bool
+		kind      byte
+		lanes     int
+		elemBytes int
+	}{
+		{false, 'B', 16, 1},
+		{false, 'H', 8, 2},
+		{true, 'B', 16, 1},
+		{true, 'H', 8, 2},
+		{true, 'S', 4, 4},
+	} {
+		base := uint32(0x0e002c00)
+		if form.wide {
+			base = 0x4e002c00
+		}
+		for lane := 0; lane < form.lanes; lane++ {
+			for _, src := range []int{0, 17, 31} {
+				dst := (lane*11 + src) % 31
+				imm5 := lane*form.elemBytes*2 + form.elemBytes
+				word := base | uint32(imm5)<<16 | uint32(src)<<5 | uint32(dst)
+				// The complete destination bank includes LR. Preserve it in
+				// actual source around each form, using a distinct GP register.
+				saved := 25
+				if dst == saved {
+					saved = 26
+				}
+				fmt.Fprintf(&source, "MOVD R30,R%d\n", saved)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				fmt.Fprintf(&source, "MOVD R%d,R30\n", saved)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"signedLanes": {Name: "signedLanes", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"sext i8", "sext i16", "sext i32", "zext i32",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %q in signed lane extraction:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-smov.ll", "arm64-raw-smov.o", ir)
+		})
+	}
+}
+
+func TestARM64SignedLaneExtractRejectsInvalidFormats(t *testing.T) {
+	for _, instruction := range []string{
+		"SMOV V0.D[0], R0",
+		"SMOVW V0.S[0], R0",
+		"SMOV V0.S[4], R0",
+		"SMOVW V0.H[8], R0",
+		"SMOV R0, V0.S[0]",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT signedLane(SB), $0-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{
+					"signedLane": {Name: "signedLane", Ret: Void},
+				},
+			})
+			if err == nil {
+				t.Fatal("accepted invalid signed lane extract")
+			}
+		})
+	}
+}
+
+func TestARM64RawSignedLaneExtractRejectsReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0e002c00, // No element-size bit.
+		0x0e042c00, // A 32-bit destination cannot extract an S lane.
+		0x4e082c00, // SMOV has no D-lane encoding.
+		0x4e102c00, // Nor a wider element-size encoding.
+	} {
+		ins := Instr{
+			Op:   "WORD",
+			Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+			Raw:  fmt.Sprintf("WORD $%#08x", word),
+		}
+		decoded, err := decodeARM64RawWordInstruction(ins)
+		if err == nil && (decoded.Op == "SMOV" || decoded.Op == "SMOVW") {
+			t.Fatalf("reserved encoding %#08x decoded as %s", word, decoded.Op)
+		}
+	}
+}
+
+func TestARM64SignedLaneExtractNativeRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("native execution requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := arm64SignedLaneExtractRuntimeIR(t, triple)
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_smov", triple, ir, arm64SignedLaneExtractOracleC, nil)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SignedLaneExtract(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("signed lane extraction belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64SignedLaneExtractRuntimeIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc"}, "arm64_raw_smov", triple, ir,
+		arm64SignedLaneExtractOracleC,
+		[]string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func arm64SignedLaneExtractRuntimeIR(t *testing.T, triple string) string {
+	t.Helper()
+	const source = `TEXT signedLanes(SB), $0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V0.B16]
+	WORD $0x0e012c02 // SMOVW V0.B[0], R2
+	WORD $0x0e0e2c03 // SMOVW V0.H[3], R3
+	WORD $0x4e1f2c04 // SMOV V0.B[15], R4
+	WORD $0x4e0e2c05 // SMOV V0.H[3], R5
+	WORD $0x4e142c06 // SMOV V0.S[2], R6
+	MOVD R2, 0(R1)
+	MOVD R3, 8(R1)
+	MOVD R4, 16(R1)
+	MOVD R5, 24(R1)
+	MOVD R6, 32(R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: triple,
+		Sigs: map[string]FuncSig{
+			"signedLanes": {
+				Name: "signedLanes", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+const arm64SignedLaneExtractOracleC = `
+#include <stdint.h>
+extern void signedLanes(const uint8_t input[16], uint64_t output[5]);
+int main(void) {
+    const uint8_t input[16] = {
+        0x80, 0, 0, 0, 0, 0, 0, 0x80,
+        0, 0, 0, 0x80, 0, 0, 0, 0xff
+    };
+    uint64_t output[5] = {0};
+    signedLanes(input, output);
+    if (output[0] != UINT64_C(0x00000000ffffff80)) return 1;
+    if (output[1] != UINT64_C(0x00000000ffff8000)) return 2;
+    if (output[2] != UINT64_MAX) return 3;
+    if (output[3] != UINT64_C(0xffffffffffff8000)) return 4;
+    if (output[4] != UINT64_C(0xffffffff80000000)) return 5;
+    return 0;
+}
+`
diff --git a/arm64_lower_word_sqdmulh.go b/arm64_lower_word_sqdmulh.go
new file mode 100644
index 000000000..f5751524f
--- /dev/null
+++ b/arm64_lower_word_sqdmulh.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import "fmt"
+
+// arm64RawSQDMULH describes every Advanced SIMD SQDMULH encoding. Go 1.27
+// exposes only the SVE ZSQDMULH mnemonic, so ecosystem code that needs the
+// fixed-width instruction still carries these encodings in WORD directives.
+type arm64RawSQDMULH struct {
+	scalar      bool
+	byElement   bool
+	arrangement arm64VectorArrangement
+	destination int
+	first       int
+	second      int
+	element     int
+}
+
+func decodeARM64RawSQDMULH(word uint32) (arm64RawSQDMULH, bool) {
+	form := arm64RawSQDMULH{element: -1}
+	switch {
+	case word&0xff20fc00 == 0x5e20b400: // scalar, three same
+		form.scalar = true
+	case word&0xbf20fc00 == 0x0e20b400: // vector, three same
+	case word&0xff00f400 == 0x5f00c000: // scalar, by element
+		form.scalar = true
+		form.byElement = true
+	case word&0xbf00f400 == 0x0f00c000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawSQDMULH{}, false
+	}
+	return decodeARM64MultiplyHighOperands(word, form)
+}
+
+// All fixed-width saturating multiply-high forms share these size, register
+// and indexed-lane fields. H is the high index bit, not the low one; M is
+// either the low H-lane index bit or the high S-source register bit.
+func decodeARM64MultiplyHighOperands(word uint32, form arm64RawSQDMULH) (arm64RawSQDMULH, bool) {
+	size := int(word>>22) & 3
+	if size != 1 && size != 2 {
+		return arm64RawSQDMULH{}, false
+	}
+	bits := 8 << size
+	lanes := 1
+	if !form.scalar {
+		vectorBits := 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		lanes = vectorBits / bits
+	}
+	form.arrangement = arm64VectorArrangement{elementBits: bits, lanes: lanes}
+	form.destination = int(word & 31)
+	form.first = int(word>>5) & 31
+	form.second = int(word>>16) & 31
+	if form.byElement {
+		element := decodeARM64MultiplyIndexedElement(word, bits)
+		form.second, form.element = element.register, element.lane
+	}
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSQDMULH(form arm64RawSQDMULH) error {
+	return c.lowerRawSaturatingDoublingMultiplyHigh(form, false)
+}
+
+func (c *arm64Ctx) lowerRawSaturatingDoublingMultiplyHigh(form arm64RawSQDMULH, rounding bool) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	secondLane := 0
+	if form.byElement {
+		secondLane = form.element
+	}
+	second, err := c.loadRawARM64VectorOperand(form.second, form.arrangement, secondLane, form.scalar || form.byElement)
+	if err != nil {
+		return err
+	}
+
+	narrow := form.arrangement
+	wide := arm64VectorArrangement{elementBits: narrow.elementBits * 2, lanes: narrow.lanes}
+	narrowType := fmt.Sprintf("<%d x i%d>", narrow.lanes, narrow.elementBits)
+	wideType := fmt.Sprintf("<%d x i%d>", wide.lanes, wide.elementBits)
+	wideFirst := c.newTmp()
+	wideSecond := c.newTmp()
+	product := c.newTmp()
+	productValue := ""
+	shifted := c.newTmp()
+	truncated := c.newTmp()
+	firstMinimum := c.newTmp()
+	secondMinimum := c.newTmp()
+	overflow := c.newTmp()
+	result := c.newTmp()
+	minimum := -(int64(1) << (narrow.elementBits - 1))
+	maximum := (int64(1) << (narrow.elementBits - 1)) - 1
+
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", wideFirst, narrowType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = sext %s %s to %s\n", wideSecond, narrowType, second, wideType)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", product, wideType, wideFirst, wideSecond)
+	productValue = "%" + product
+	if rounding {
+		rounded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %s\n", rounded, wideType, productValue, arm64VectorIntegerSplat(wide, int64(1)<<(narrow.elementBits-2)))
+		productValue = "%" + rounded
+	}
+	fmt.Fprintf(c.b, "  %%%s = ashr %s %s, %s\n", shifted, wideType, productValue, arm64VectorIntegerSplat(wide, int64(narrow.elementBits-1)))
+	fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", truncated, wideType, shifted, narrowType)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %s\n", firstMinimum, narrowType, first, arm64VectorIntegerSplat(narrow, minimum))
+	fmt.Fprintf(c.b, "  %%%s = icmp eq %s %s, %s\n", secondMinimum, narrowType, second, arm64VectorIntegerSplat(narrow, minimum))
+	fmt.Fprintf(c.b, "  %%%s = and <%d x i1> %%%s, %%%s\n", overflow, narrow.lanes, firstMinimum, secondMinimum)
+	fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, %s %s, %s %%%s\n",
+		result, narrow.lanes, overflow, narrowType, arm64VectorIntegerSplat(narrow, maximum), narrowType, truncated)
+	return c.storeRawARM64VectorResult(form.destination, narrow, "%"+result, form.scalar)
+}
+
+func (c *arm64Ctx) loadRawARM64VectorOperand(index int, arrangement arm64VectorArrangement, lane int, scalarOrLane bool) (string, error) {
+	reg := Reg(fmt.Sprintf("V%d", index))
+	if !scalarOrLane {
+		return c.loadARM64VectorInteger(Reg(fmt.Sprintf("V%d.%s", index, arm64VectorArrangementName(arrangement))), arrangement)
+	}
+	element, err := c.arm64VDUPExtractLane(reg, arrangement.elementBits, lane)
+	if err != nil {
+		return "", err
+	}
+	if arrangement.lanes == 1 {
+		seed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <1 x i%d> poison, i%d %s, i32 0\n", seed, arrangement.elementBits, arrangement.elementBits, element)
+		return "%" + seed, nil
+	}
+	return c.arm64VDUPSplat(arrangement, element), nil
+}
+
+func (c *arm64Ctx) storeRawARM64VectorResult(index int, arrangement arm64VectorArrangement, value string, scalar bool) error {
+	reg := Reg(fmt.Sprintf("V%d", index))
+	if !scalar {
+		return c.storeARM64VectorInteger(Reg(fmt.Sprintf("V%d.%s", index, arm64VectorArrangementName(arrangement))), arrangement, value)
+	}
+	element := c.newTmp()
+	physicalLanes := 128 / arrangement.elementBits
+	inserted := c.newTmp()
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <1 x i%d> %s, i32 0\n", element, arrangement.elementBits, value)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %%%s, i32 0\n",
+		inserted, physicalLanes, arrangement.elementBits, arrangement.elementBits, element)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n", bytes, physicalLanes, arrangement.elementBits, inserted)
+	return c.storeVReg(reg, "%"+bytes)
+}
diff --git a/arm64_lower_word_sqdmulh_test.go b/arm64_lower_word_sqdmulh_test.go
new file mode 100644
index 000000000..81e28a980
--- /dev/null
+++ b/arm64_lower_word_sqdmulh_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These encodings cover every Advanced SIMD SQDMULH format documented by
+// LLVM 22's AArch64 assembler: scalar, vector, scalar-by-element, and
+// vector-by-element, for every legal H/S arrangement and Q width.
+const arm64RawSQDMULHForms = `
+TEXT rawsqdmulhforms(SB),$0-0
+	WORD $0x5e62b420 // SQDMULH H0, H1, H2
+	WORD $0x5ea5b483 // SQDMULH S3, S4, S5
+	WORD $0x0e68b4e6 // SQDMULH V6.4H, V7.4H, V8.4H
+	WORD $0x4e6bb549 // SQDMULH V9.8H, V10.8H, V11.8H
+	WORD $0x0eaeb5ac // SQDMULH V12.2S, V13.2S, V14.2S
+	WORD $0x4eb1b60f // SQDMULH V15.4S, V16.4S, V17.4S
+	WORD $0x5f74ca72 // SQDMULH H18, H19, V4.H[7]
+	WORD $0x5fb7cad5 // SQDMULH S21, S22, V23.S[3]
+	WORD $0x0f7acb38 // SQDMULH V24.4H, V25.4H, V10.H[7]
+	WORD $0x4f7dcb9b // SQDMULH V27.8H, V28.8H, V13.H[7]
+	WORD $0x0fa1c81e // SQDMULH V30.2S, V0.2S, V1.S[3]
+	WORD $0x4fa4c862 // SQDMULH V2.4S, V3.4S, V4.S[3]
+	RET
+`
+
+func TestTranslateARM64RawSQDMULHCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSQDMULHForms, true)
+	file, err := Parse(ArchARM64, arm64RawSQDMULHForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawsqdmulhforms": {Name: "rawsqdmulhforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"mul <4 x i32>", "mul <8 x i32>",
+				"mul <2 x i64>", "mul <4 x i64>",
+				"ashr <4 x i32>", "ashr <8 x i32>",
+				"ashr <2 x i64>", "ashr <4 x i64>",
+				"select <", "i16 32767", "i32 2147483647",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SQDMULH lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sqdmulh.ll", "arm64-raw-sqdmulh.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSQDMULHRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawsqdmulh(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4ea1b402 // SQDMULH V2.4S, V0.4S, V1.4S
+	VST1 [V2.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawsqdmulh": {
+				Name: "rawsqdmulh", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawsqdmulh(const int32_t *, const int32_t *, int32_t *);
+int main(void) {
+  const int32_t a[4] = {INT32_MIN, INT32_MIN, 1073741824, -1073741824};
+  const int32_t b[4] = {INT32_MIN, INT32_MAX, 1073741824, 1073741824};
+  int32_t got[4] = {0};
+  rawsqdmulh(a, b, got);
+  const int32_t want[4] = {INT32_MAX, -2147483647, 536870912, -536870912};
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_sqdmulh", triple, ll, mainC, nil)
+}
+
+func TestARM64RawSQDMULHDecoderRejectsAdjacentEncodings(t *testing.T) {
+	// SQRDMULH has different rounding semantics and must not be captured by the
+	// SQDMULH masks merely because the register fields are identical.
+	const word = uint32(0x6ea1b402)
+	if _, ok := decodeARM64RawSQDMULH(word); ok {
+		t.Fatal("SQDMULH decoder accepted adjacent SQRDMULH encoding")
+	}
+}
diff --git a/arm64_lower_word_sqrdmulh.go b/arm64_lower_word_sqrdmulh.go
new file mode 100644
index 000000000..db8420f0d
--- /dev/null
+++ b/arm64_lower_word_sqrdmulh.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+// decodeARM64RawSQRDMULH covers every fixed-width Advanced SIMD SQRDMULH
+// encoding. Go 1.27 names only the SVE form, ZSQRDMULH, so fixed-width users
+// carry these instructions as WORD directives.
+func decodeARM64RawSQRDMULH(word uint32) (arm64RawSQDMULH, bool) {
+	form := arm64RawSQDMULH{element: -1}
+	switch {
+	case word&0xff20fc00 == 0x7e20b400: // scalar, three same
+		form.scalar = true
+	case word&0xbf20fc00 == 0x2e20b400: // vector, three same
+	case word&0xff00f400 == 0x5f00d000: // scalar, by element
+		form.scalar = true
+		form.byElement = true
+	case word&0xbf00f400 == 0x0f00d000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawSQDMULH{}, false
+	}
+
+	return decodeARM64MultiplyHighOperands(word, form)
+}
+
+func (c *arm64Ctx) lowerRawSQRDMULH(form arm64RawSQDMULH) error {
+	return c.lowerRawSaturatingDoublingMultiplyHigh(form, true)
+}
diff --git a/arm64_lower_word_sqrdmulh_test.go b/arm64_lower_word_sqrdmulh_test.go
new file mode 100644
index 000000000..7bc80a31d
--- /dev/null
+++ b/arm64_lower_word_sqrdmulh_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// LLVM 22's AArch64 assembler was used to enumerate every fixed-width
+// Advanced SIMD SQRDMULH form: scalar, vector, scalar-by-element, and
+// vector-by-element, for every legal H/S arrangement and Q width.
+const arm64RawSQRDMULHForms = `
+TEXT rawsqrdmulhforms(SB),$0-0
+	WORD $0x7e62b420 // SQRDMULH H0, H1, H2
+	WORD $0x7ea5b483 // SQRDMULH S3, S4, S5
+	WORD $0x2e68b4e6 // SQRDMULH V6.4H, V7.4H, V8.4H
+	WORD $0x6e6bb549 // SQRDMULH V9.8H, V10.8H, V11.8H
+	WORD $0x2eaeb5ac // SQRDMULH V12.2S, V13.2S, V14.2S
+	WORD $0x6eb1b60f // SQRDMULH V15.4S, V16.4S, V17.4S
+	WORD $0x5f74da72 // SQRDMULH H18, H19, V4.H[7]
+	WORD $0x5fb7dad5 // SQRDMULH S21, S22, V23.S[3]
+	WORD $0x0f7adb38 // SQRDMULH V24.4H, V25.4H, V10.H[7]
+	WORD $0x4f7ddb9b // SQRDMULH V27.8H, V28.8H, V13.H[7]
+	WORD $0x0fa1d81e // SQRDMULH V30.2S, V0.2S, V1.S[3]
+	WORD $0x4fa4d862 // SQRDMULH V2.4S, V3.4S, V4.S[3]
+	RET
+`
+
+func TestTranslateARM64RawSQRDMULHCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSQRDMULHForms, true)
+	file, err := Parse(ArchARM64, arm64RawSQRDMULHForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawsqrdmulhforms": {Name: "rawsqrdmulhforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"mul <4 x i32>", "mul <8 x i32>",
+				"mul <2 x i64>", "mul <4 x i64>",
+				"add <4 x i32>", "add <8 x i32>",
+				"add <2 x i64>", "add <4 x i64>",
+				"ashr <", "select <", "i16 32767", "i32 2147483647",
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("ARM64 raw SQRDMULH lowering for %s omitted %q:\n%s", triple, want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sqrdmulh.ll", "arm64-raw-sqrdmulh.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSQRDMULHDecoderDoesNotCaptureSQDMULH(t *testing.T) {
+	if _, ok := decodeARM64RawSQRDMULH(0x4ea1b402); ok {
+		t.Fatal("SQRDMULH decoder accepted adjacent SQDMULH encoding")
+	}
+}
diff --git a/arm64_lower_word_sqshlu.go b/arm64_lower_word_sqshlu.go
new file mode 100644
index 000000000..63c7ca67d
--- /dev/null
+++ b/arm64_lower_word_sqshlu.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27 has no named fixed-width VSQSHLU optab row, but WORD accepts the
+// architectural scalar and vector encodings. Keep this decoder raw-only so a
+// named spelling rejected by Go is not incorrectly advertised as supported.
+type arm64RawSQSHLU struct {
+	scalar      bool
+	arrangement arm64VectorArrangement
+	shift       int
+	source      int
+	destination int
+}
+
+func decodeARM64RawSQSHLU(word uint32) (arm64RawSQSHLU, bool) {
+	scalar := false
+	switch {
+	case word&0xff80fc00 == 0x7f006400:
+		scalar = true
+	case word&0xbf80fc00 == 0x2f006400:
+	default:
+		return arm64RawSQSHLU{}, false
+	}
+
+	encodedImmediate := int(word>>16) & 0x7f
+	elementBits := 0
+	switch {
+	case encodedImmediate >= 64:
+		elementBits = 64
+	case encodedImmediate >= 32:
+		elementBits = 32
+	case encodedImmediate >= 16:
+		elementBits = 16
+	case encodedImmediate >= 8:
+		elementBits = 8
+	default:
+		return arm64RawSQSHLU{}, false
+	}
+	shift := encodedImmediate - elementBits
+	if shift < 0 || shift >= elementBits {
+		return arm64RawSQSHLU{}, false
+	}
+
+	lanes := 1
+	if !scalar {
+		vectorBits := 64
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if vectorBits < elementBits*2 {
+			return arm64RawSQSHLU{}, false
+		}
+		lanes = vectorBits / elementBits
+	}
+	return arm64RawSQSHLU{
+		scalar:      scalar,
+		arrangement: arm64VectorArrangement{elementBits: elementBits, lanes: lanes},
+		shift:       shift,
+		source:      int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSQSHLU(form arm64RawSQSHLU) error {
+	if form.scalar {
+		// LLVM 22 cannot legalize the scalar SQSHLU intrinsic reliably.
+		// Compare the original input against UMAX >> shift before selecting
+		// a wrapped shift result or the saturation value.
+		bits := form.arrangement.elementBits
+		value, err := c.arm64VDUPExtractLane(Reg(fmt.Sprintf("V%d", form.source)), bits, 0)
+		if err != nil {
+			return err
+		}
+		negative := c.newTmp()
+		shifted := c.newTmp()
+		result := c.newTmp()
+		packed := c.newTmp()
+		bytes := c.newTmp()
+		lanes := 128 / bits
+		fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %s, 0\n", negative, bits, value)
+		fmt.Fprintf(c.b, "  %%%s = shl i%d %s, %d\n", shifted, bits, value, form.shift)
+		positive := "%" + shifted
+		if form.shift > 0 {
+			limit := (^uint64(0) >> (64 - bits)) >> form.shift
+			overflow := c.newTmp()
+			saturated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp ugt i%d %s, %d\n", overflow, bits, value, limit)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d -1, i%d %%%s\n",
+				saturated, overflow, bits, bits, shifted)
+			positive = "%" + saturated
+		}
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i%d 0, i%d %s\n",
+			result, negative, bits, bits, positive)
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> zeroinitializer, i%d %%%s, i32 0\n",
+			packed, lanes, bits, bits, result)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to <16 x i8>\n",
+			bytes, lanes, bits, packed)
+		return c.storeVReg(Reg(fmt.Sprintf("V%d", form.destination)), "%"+bytes)
+	}
+
+	value, err := c.loadRawARM64VectorOperand(form.source, form.arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	arrangement := form.arrangement
+	vectorType := fmt.Sprintf("<%d x i%d>", arrangement.lanes, arrangement.elementBits)
+	shift := arm64VectorIntegerSplat(arrangement, int64(form.shift))
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.neon.sqshlu.v%di%d(%s %s, %s %s)\n",
+		result, vectorType, arrangement.lanes, arrangement.elementBits,
+		vectorType, value, vectorType, shift)
+	return c.storeRawARM64VectorResult(form.destination, arrangement, "%"+result, form.scalar)
+}
diff --git a/arm64_lower_word_sqshlu_test.go b/arm64_lower_word_sqshlu_test.go
new file mode 100644
index 000000000..f77ded751
--- /dev/null
+++ b/arm64_lower_word_sqshlu_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func encodeARM64SQSHLU(scalar, wide bool, elementBits, shift, source, destination int) uint32 {
+	base := uint32(0x2f006400)
+	if scalar {
+		base = 0x7f006400
+	} else if wide {
+		base |= 1 << 30
+	}
+	return base | uint32(elementBits+shift)<<16 | uint32(source)<<5 | uint32(destination)
+}
+
+func TestARM64RawSQSHLUDecoderCoversEveryImmediate(t *testing.T) {
+	for _, scalar := range []bool{false, true} {
+		for _, wide := range []bool{false, true} {
+			if scalar && wide {
+				continue
+			}
+			for _, elementBits := range []int{8, 16, 32, 64} {
+				if !scalar && !wide && elementBits == 64 {
+					continue
+				}
+				for shift := 0; shift < elementBits; shift++ {
+					word := encodeARM64SQSHLU(scalar, wide, elementBits, shift, 31, 30)
+					form, ok := decodeARM64RawSQSHLU(word)
+					if !ok || form.scalar != scalar || form.arrangement.elementBits != elementBits ||
+						form.shift != shift || form.source != 31 || form.destination != 30 {
+						t.Fatalf("decode %#08x = %+v, %v", word, form, ok)
+					}
+				}
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x2f006400, // immh=0
+		0x2f406400, // D1 is not a vector arrangement
+		0x2f007400, // opcode neighbor
+		0x7f806400, // outside the seven-bit encoded immediate
+	} {
+		if _, ok := decodeARM64RawSQSHLU(word); ok {
+			t.Fatalf("invalid or adjacent SQSHLU word accepted: %#08x", word)
+		}
+	}
+}
+
+func TestARM64SQSHLUNamedSpellingRemainsOutsideGoOptab(t *testing.T) {
+	const source = "TEXT named(SB),$0-0\n\tVSQSHLU $1, V0.B16, V1.B16\n\tRET\n"
+	requireARM64GoAssemblerResult(t, source, false)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"named": {Name: "named", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted named VSQSHLU, which Go 1.27 rejects")
+	}
+}
+
+func TestARM64RawSQSHLURuntimeSemantics(t *testing.T) {
+	crossLinux := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !crossLinux {
+		t.Skip("runtime execution requires an ARM64 host or the Linux cross-runtime job")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler := []string{findLLVM22Tool("clang")}
+	var runner []string
+	if crossLinux {
+		triple = arm64LinuxGNUTriple
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+		for _, required := range []string{compiler[0], runner[0]} {
+			if _, err := exec.LookPath(required); err != nil {
+				t.Fatalf("required cross-runtime tool %s: %v", required, err)
+			}
+		}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT sqshluRuntime(SB),$0-16\n")
+	source.WriteString("\tMOVD input+0(FP), R0\n\tMOVD output+8(FP), R1\n")
+	source.WriteString("\tVLD1 (R0), [V0.B16]\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64SQSHLU(false, true, 8, 2, 0, 1))
+	source.WriteString("\tVST1.P [V1.B16], 16(R1)\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64SQSHLU(false, false, 8, 2, 0, 1))
+	source.WriteString("\tVST1.P [V1.B16], 16(R1)\n")
+	fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64SQSHLU(true, false, 64, 1, 0, 1))
+	source.WriteString("\tVST1 [V1.B16], (R1)\n\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"sqshluRuntime": {
+			Name: "sqshluRuntime", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void sqshluRuntime(const int8_t *, uint8_t *);
+int main(void) {
+  const int8_t input[16] = {-128, -64, -1, 0, 1, 31, 63, -128,
+                            -127, -2, 2, 32, 64, 100, 126, 127};
+  uint8_t got[48] = {0};
+  sqshluRuntime(input, got);
+  for (int i = 0; i < 16; i++) {
+    int value = (int)input[i] * 4;
+    const uint8_t want = value < 0 ? 0 : value > 255 ? 255 : (uint8_t)value;
+    if (got[i] != want) return i + 1;
+    if (got[16+i] != (i < 8 ? want : 0)) return 17 + i;
+  }
+  for (int i = 32; i < 40; i++) {
+    if (got[i] != 0) return i + 1;
+  }
+  const int8_t positive[16] = {-128, -64, -1, 0, 1, 31, 63, 127};
+  uint8_t positiveGot[48] = {0};
+  sqshluRuntime(positive, positiveGot);
+  uint64_t scalar = 0;
+  for (int i = 0; i < 8; i++) {
+    scalar |= (uint64_t)(uint8_t)positive[i] << (8 * i);
+  }
+  scalar <<= 1;
+  for (int i = 0; i < 8; i++) {
+    if (positiveGot[32+i] != (uint8_t)(scalar >> (8 * i))) return i + 49;
+  }
+  for (int i = 40; i < 48; i++) {
+    if (positiveGot[i] != 0) return i + 17;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "arm64_sqshlu", triple, ir, mainC, runner)
+}
+
+func TestARM64RawSQSHLUCompleteScalarAndVectorForms(t *testing.T) {
+	type sqshluForm struct {
+		word   uint32
+		scalar bool
+	}
+	var source strings.Builder
+	var forms []sqshluForm
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, scalar := range []bool{false, true} {
+			for _, wide := range []bool{false, true} {
+				if scalar && wide || !scalar && !wide && elementBits == 64 {
+					continue
+				}
+				for _, shift := range []int{0, elementBits - 1} {
+					word := encodeARM64SQSHLU(scalar, wide, elementBits, shift, 29, 28)
+					decoded, err := decodeARM64RawWordInstruction(Instr{
+						Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+					})
+					if err != nil || decoded.Op != "VSQSHLU" {
+						t.Fatalf("decode SQSHLU scalar=%v wide=%v bits=%d shift=%d word=%#08x: %#v, %v",
+							scalar, wide, elementBits, shift, word, decoded, err)
+					}
+					name := fmt.Sprintf("sqshluForm%d", len(forms))
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n\tWORD $%#08x\n\tRET\n", name, word)
+					forms = append(forms, sqshluForm{word: word, scalar: scalar})
+				}
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-unknown-freebsd",
+	} {
+		for index, form := range forms {
+			t.Run(fmt.Sprintf("%s/form-%02d", triple, index), func(t *testing.T) {
+				formSource := fmt.Sprintf("TEXT sqshluForm(SB),$0-0\n\tWORD $%#08x\n\tRET\n", form.word)
+				file, err := Parse(ArchARM64, formSource)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{
+					Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"sqshluForm": {Name: "sqshluForm", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				wantCalls := 1
+				if form.scalar {
+					wantCalls = 0
+					if !strings.Contains(ir, " = icmp slt i") || !strings.Contains(ir, " = shl i") {
+						t.Fatal("scalar SQSHLU is missing signed clamp or shift")
+					}
+				}
+				// Count this family's intrinsic, not the independent caller
+				// continuation capture introduced by checked CFG translation.
+				got := 0
+				for _, line := range strings.Split(ir, "\n") {
+					if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.aarch64.neon.sqshlu.") {
+						got++
+					}
+				}
+				if got != wantCalls {
+					t.Fatalf("got %d SQSHLU calls, want %d", got, wantCalls)
+				}
+				compileLLVMToObject(t, llc, triple, "arm64-sqshlu.ll", "arm64-sqshlu.o", ir)
+			})
+		}
+	}
+}
diff --git a/arm64_lower_word_sshr.go b/arm64_lower_word_sshr.go
new file mode 100644
index 000000000..b4b0eacb0
--- /dev/null
+++ b/arm64_lower_word_sshr.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSSHR struct {
+	scalar      bool
+	arrangement arm64VectorArrangement
+	shift       int
+	source      int
+	destination int
+}
+
+func decodeARM64RawSSHR(word uint32) (arm64RawSSHR, bool) {
+	form := arm64RawSSHR{}
+	switch {
+	case word&0xff80fc00 == 0x5f000400:
+		form.scalar = true
+	case word&0xbf80fc00 == 0x0f000400:
+	default:
+		return arm64RawSSHR{}, false
+	}
+	encodedImmediate := int(word>>16) & 0x7f
+	bits := 0
+	switch {
+	case encodedImmediate >= 64:
+		bits = 64
+	case encodedImmediate >= 32:
+		bits = 32
+	case encodedImmediate >= 16:
+		bits = 16
+	case encodedImmediate >= 8:
+		bits = 8
+	default:
+		return arm64RawSSHR{}, false
+	}
+	shift := 2*bits - encodedImmediate
+	if shift < 1 || shift > bits || form.scalar && bits != 64 {
+		return arm64RawSSHR{}, false
+	}
+	vectorBits := 64
+	if form.scalar {
+		form.arrangement = arm64VectorArrangement{elementBits: 64, lanes: 1}
+	} else {
+		if word&(1<<30) != 0 {
+			vectorBits = 128
+		}
+		if bits == 64 && vectorBits != 128 {
+			return arm64RawSSHR{}, false
+		}
+		form.arrangement = arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits}
+	}
+	form.shift = shift
+	form.source = int(word>>5) & 31
+	form.destination = int(word & 31)
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSSHR(form arm64RawSSHR) error {
+	source, err := c.loadRawARM64VectorOperand(form.source, form.arrangement, 0, form.scalar)
+	if err != nil {
+		return err
+	}
+	vectorType := fmt.Sprintf("<%d x i%d>", form.arrangement.lanes, form.arrangement.elementBits)
+	result := c.newTmp()
+	shift := form.shift
+	if shift == form.arrangement.elementBits {
+		// LLVM shifts by the element width are poison. AArch64 SSHR by the
+		// element width instead replicates the sign bit, which is equivalent to
+		// an arithmetic shift by width-1.
+		shift--
+	}
+	fmt.Fprintf(c.b, "  %%%s = ashr %s %s, %s\n", result, vectorType, source, arm64VectorIntegerSplat(form.arrangement, int64(shift)))
+	return c.storeRawARM64VectorResult(form.destination, form.arrangement, "%"+result, form.scalar)
+}
diff --git a/arm64_lower_word_sshr_test.go b/arm64_lower_word_sshr_test.go
new file mode 100644
index 000000000..c8b1f5b39
--- /dev/null
+++ b/arm64_lower_word_sshr_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawSSHRForms = `
+TEXT rawsshrforms(SB),$0-0
+	WORD $0x0f0f0420 // SSHR V0.8B, V1.8B, #1
+	WORD $0x4f080462 // SSHR V2.16B, V3.16B, #8
+	WORD $0x0f1f04a4 // SSHR V4.4H, V5.4H, #1
+	WORD $0x4f1004e6 // SSHR V6.8H, V7.8H, #16
+	WORD $0x0f3f0528 // SSHR V8.2S, V9.2S, #1
+	WORD $0x4f20056a // SSHR V10.4S, V11.4S, #32
+	WORD $0x4f4005ac // SSHR V12.2D, V13.2D, #64
+	WORD $0x5f7f05ee // SSHR D14, D15, #1
+	RET
+`
+
+func TestTranslateARM64RawSSHRCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSSHRForms, true)
+	file, err := Parse(ArchARM64, arm64RawSSHRForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawsshrforms": {Name: "rawsshrforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"ashr <8 x i8>", "ashr <16 x i8>",
+				"ashr <4 x i16>", "ashr <8 x i16>",
+				"ashr <2 x i32>", "ashr <4 x i32>",
+				"ashr <2 x i64>", "ashr i64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SSHR lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sshr.ll", "arm64-raw-sshr.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSSHRDecoderCoversEveryImmediate(t *testing.T) {
+	for _, bits := range []int{8, 16, 32, 64} {
+		for shift := 1; shift <= bits; shift++ {
+			encodedImmediate := uint32(2*bits - shift)
+			word := uint32(0x0f000400) | encodedImmediate<<16
+			if bits == 64 {
+				word |= 1 << 30
+			}
+			form, ok := decodeARM64RawSSHR(word)
+			if !ok || form.arrangement.elementBits != bits || form.shift != shift {
+				t.Fatalf("decode SSHR bits=%d shift=%d: form=%#v ok=%v", bits, shift, form, ok)
+			}
+		}
+	}
+}
+
+func TestARM64RawSSHRRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawsshr(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V30.S4]
+	WORD $0x4f2107de // SSHR V30.4S, V30.4S, #31
+	VST1 [V30.S4], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawsshr": {
+				Name: "rawsshr", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawsshr(const int32_t *, int32_t *);
+int main(void) {
+  const int32_t in[4] = {INT32_MIN, -1, 0, INT32_MAX};
+  const int32_t want[4] = {-1, -1, 0, 0};
+  int32_t got[4] = {0};
+  rawsshr(in, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_sshr", triple, ll, mainC, nil)
+}
+
+func TestARM64RawSSHRDecoderRejectsAdjacentUSHR(t *testing.T) {
+	if _, ok := decodeARM64RawSSHR(0x2f0f0420); ok {
+		t.Fatal("SSHR decoder claimed adjacent USHR encoding")
+	}
+}
diff --git a/arm64_lower_word_streaming_mode.go b/arm64_lower_word_streaming_mode.go
new file mode 100644
index 000000000..d641f63da
--- /dev/null
+++ b/arm64_lower_word_streaming_mode.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "fmt"
+
+type arm64StreamingState uint8
+
+const (
+	arm64StreamingStateBoth arm64StreamingState = iota
+	arm64StreamingStateSM
+	arm64StreamingStateZA
+)
+
+type arm64RawStreamingModeControl struct {
+	enable bool
+	state  arm64StreamingState
+}
+
+var arm64RawStreamingModeControlForms = map[uint32]arm64RawStreamingModeControl{
+	0xd503477f: {enable: true, state: arm64StreamingStateBoth},
+	0xd503437f: {enable: true, state: arm64StreamingStateSM},
+	0xd503457f: {enable: true, state: arm64StreamingStateZA},
+	0xd503467f: {state: arm64StreamingStateBoth},
+	0xd503427f: {state: arm64StreamingStateSM},
+	0xd503447f: {state: arm64StreamingStateZA},
+}
+
+func decodeARM64RawStreamingModeControl(word uint32) (arm64RawStreamingModeControl, bool) {
+	form, ok := arm64RawStreamingModeControlForms[word]
+	return form, ok
+}
+
+func (c *arm64Ctx) lowerRawStreamingModeControl(form arm64RawStreamingModeControl) error {
+	mnemonic := "smstop"
+	if form.enable {
+		mnemonic = "smstart"
+	}
+	switch form.state {
+	case arm64StreamingStateBoth:
+	case arm64StreamingStateSM:
+		mnemonic += " sm"
+	case arm64StreamingStateZA:
+		mnemonic += " za"
+	default:
+		return fmt.Errorf("arm64 unsupported streaming state %d", form.state)
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", mnemonic, "~{memory}")
+	return nil
+}
diff --git a/arm64_lower_word_streaming_mode_test.go b/arm64_lower_word_streaming_mode_test.go
new file mode 100644
index 000000000..21f950b58
--- /dev/null
+++ b/arm64_lower_word_streaming_mode_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64RawStreamingModeControlDecoderCompleteArchitectureFamily(t *testing.T) {
+	tests := []struct {
+		word   uint32
+		enable bool
+		state  arm64StreamingState
+	}{
+		{word: 0xd503477f, enable: true, state: arm64StreamingStateBoth},
+		{word: 0xd503437f, enable: true, state: arm64StreamingStateSM},
+		{word: 0xd503457f, enable: true, state: arm64StreamingStateZA},
+		{word: 0xd503467f, state: arm64StreamingStateBoth},
+		{word: 0xd503427f, state: arm64StreamingStateSM},
+		{word: 0xd503447f, state: arm64StreamingStateZA},
+	}
+
+	for _, test := range tests {
+		form, ok := decodeARM64RawStreamingModeControl(test.word)
+		if !ok {
+			t.Fatalf("decoder rejected %#08x", test.word)
+		}
+		if form.enable != test.enable || form.state != test.state {
+			t.Fatalf("decode %#08x = %+v", test.word, form)
+		}
+	}
+}
+
+func TestTranslateARM64RawStreamingModeControlCompleteArchitectureFamily(t *testing.T) {
+	const source = `
+TEXT rawStreamingModeControl(SB),$0-0
+	WORD $0xd503477f // SMSTART
+	WORD $0xd503437f // SMSTART SM
+	WORD $0xd503457f // SMSTART ZA
+	WORD $0xd503467f // SMSTOP
+	WORD $0xd503427f // SMSTOP SM
+	WORD $0xd503447f // SMSTOP ZA
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawStreamingModeControl": {Name: "rawStreamingModeControl", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "smstart"`,
+				`asm sideeffect "smstart sm"`,
+				`asm sideeffect "smstart za"`,
+				`asm sideeffect "smstop"`,
+				`asm sideeffect "smstop sm"`,
+				`asm sideeffect "smstop za"`,
+				`"target-features"="+sme"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw streaming-mode control IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-streaming-mode.ll", "arm64-raw-streaming-mode.o", ir)
+		})
+	}
+}
+
+func TestARM64RawStreamingModeControlDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0xd503407f, // CFINV.
+		0xd503417f, // XAFLAG.
+		0xd503487f, // AXFLAG.
+		0xd503457e, // Reserved Rt field.
+	} {
+		if _, ok := decodeARM64RawStreamingModeControl(word); ok {
+			t.Fatalf("streaming-mode decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_structure_lane.go b/arm64_lower_word_structure_lane.go
new file mode 100644
index 000000000..e94ae74de
--- /dev/null
+++ b/arm64_lower_word_structure_lane.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import "fmt"
+
+// arm64RawStructureLane describes the Advanced SIMD load/store single
+// structure encodings. These are the LD1/ST1 through LD4/ST4 forms that move
+// one selected lane in each consecutive vector register, rather than the
+// whole-register structure forms accepted by Go's named VLDn/VSTn syntax.
+type arm64RawStructureLane struct {
+	load          bool
+	count         int
+	elementBits   int
+	lane          int
+	firstRegister int
+	base          int
+	post          bool
+	postRegister  int // 31 selects the architecture-defined fixed increment.
+}
+
+func decodeARM64RawStructureLane(word uint32) (arm64RawStructureLane, bool) {
+	// Advanced SIMD load/store single structure. Q, L, R, opcode, S, size,
+	// Rm, Rn, and Rt are decoded below. Bit 23 distinguishes no-offset from
+	// post-indexed forms. In the no-offset form Rm is reserved and must be zero.
+	if word&0xbf000000 != 0x0d000000 {
+		return arm64RawStructureLane{}, false
+	}
+	post := word&(1<<23) != 0
+	postRegister := int(word>>16) & 31
+	if !post && postRegister != 0 {
+		return arm64RawStructureLane{}, false
+	}
+
+	q := int(word>>30) & 1
+	s := int(word>>12) & 1
+	size := int(word>>10) & 3
+	opcode := int(word>>13) & 7
+	count := 1 + (int(word>>21) & 1) + 2*(opcode&1)
+
+	elementBits := 0
+	lane := 0
+	switch opcode >> 1 {
+	case 0: // B: index = UInt(Q:S:size)
+		elementBits = 8
+		lane = q<<3 | s<<2 | size
+	case 1: // H: index = UInt(Q:S:size<1>), size<0> is reserved.
+		if size&1 != 0 {
+			return arm64RawStructureLane{}, false
+		}
+		elementBits = 16
+		lane = q<<2 | s<<1 | size>>1
+	case 2: // S uses size=00; D uses S=0,size=01.
+		if size == 0 {
+			elementBits = 32
+			lane = q<<1 | s
+		} else if size == 1 && s == 0 {
+			elementBits = 64
+			lane = q
+		} else {
+			return arm64RawStructureLane{}, false
+		}
+	default:
+		// opcode<2:1> == 11 is the load-and-replicate family.
+		return arm64RawStructureLane{}, false
+	}
+
+	return arm64RawStructureLane{
+		load:          word&(1<<22) != 0,
+		count:         count,
+		elementBits:   elementBits,
+		lane:          lane,
+		firstRegister: int(word) & 31,
+		base:          int(word>>5) & 31,
+		post:          post,
+		postRegister:  postRegister,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawStructureLane(form arm64RawStructureLane) error {
+	return c.lowerStructureLane(form.memoryForm())
+}
+
+func (c *arm64Ctx) lowerStructureLane(form arm64StructureMemoryForm) error {
+	addr, increment, err := c.structureAddress(form)
+	if err != nil {
+		return err
+	}
+	arrangement := form.arrangement
+	elementBits := arrangement.elementBits
+	elementBytes := elementBits / 8
+
+	for registerOffset, reg := range form.registers {
+		offset := int64(registerOffset * elementBytes)
+		if form.load {
+			element, err := c.arm64LoadStructureElement(addr, offset, elementBits)
+			if err != nil {
+				return err
+			}
+			vector, err := c.loadARM64VectorInteger(reg, arrangement)
+			if err != nil {
+				return err
+			}
+			inserted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> %s, i%d %s, i32 %d\n",
+				inserted, arrangement.lanes, elementBits, vector,
+				elementBits, element, form.lane)
+			if err := c.storeARM64VectorInteger(reg, arrangement, "%"+inserted); err != nil {
+				return err
+			}
+			continue
+		}
+
+		vector, err := c.loadARM64VectorInteger(reg, arrangement)
+		if err != nil {
+			return err
+		}
+		element := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x i%d> %s, i32 %d\n",
+			element, arrangement.lanes, elementBits, vector, form.lane)
+		if err := c.arm64StoreStructureElement(addr, offset, elementBits, "%"+element); err != nil {
+			return err
+		}
+	}
+
+	if !form.post {
+		return nil
+	}
+	return c.arm64UpdatePostIncrement(form.memory.Mem.Base, increment)
+}
diff --git a/arm64_lower_word_sve_add_pairwise_long.go b/arm64_lower_word_sve_add_pairwise_long.go
new file mode 100644
index 000000000..880a7cd85
--- /dev/null
+++ b/arm64_lower_word_sve_add_pairwise_long.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import "fmt"
+
+// SVE SADALP/UADALP widen adjacent source lanes and accumulate into the
+// predicated destination. Size chooses B-to-H, H-to-S, or S-to-D.
+func decodeARM64RawSVEAddPairwiseLong(word uint32) (Instr, bool) {
+	if word&0xff3ee000 != 0x4404a000 {
+		return Instr{}, false
+	}
+	width := int(word>>22) & 3
+	if width == 0 {
+		return Instr{}, false
+	}
+	op := Op("ZSADALP")
+	if word&(1<<16) != 0 {
+		op = "ZUADALP"
+	}
+	arrangements := [...]string{"", "B", "H", "S", "D"}
+	source := Reg(fmt.Sprintf("Z%d.%s", word>>5&31, arrangements[width]))
+	predicate := Reg(fmt.Sprintf("P%d.M", word>>10&7))
+	destination := Reg(fmt.Sprintf("Z%d.%s", word&31, arrangements[width+1]))
+	return Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: source},
+			{Kind: OpReg, Reg: predicate},
+			{Kind: OpReg, Reg: destination},
+		},
+		Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_add_pairwise_long_test.go b/arm64_lower_word_sve_add_pairwise_long_test.go
new file mode 100644
index 000000000..9c58cda4d
--- /dev/null
+++ b/arm64_lower_word_sve_add_pairwise_long_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEAddPairwiseLongCompleteFamily(t *testing.T) {
+	operations := []struct {
+		name      string
+		unsigned  uint32
+		intrinsic string
+	}{
+		{"SADALP", 0, "sadalp"},
+		{"UADALP", 1, "uadalp"},
+	}
+	widths := []struct {
+		name   string
+		bits   uint32
+		suffix string
+	}{
+		{"B-to-H", 1, "nxv8i16"},
+		{"H-to-S", 2, "nxv4i32"},
+		{"S-to-D", 3, "nxv2i64"},
+	}
+
+	for _, operation := range operations {
+		for _, width := range widths {
+			t.Run(operation.name+"/"+width.name, func(t *testing.T) {
+				word := uint32(0x4404a000) | width.bits<<22 | operation.unsigned<<16 | 8<<5
+				source := fmt.Sprintf("TEXT sveAddPairRaw(SB),$0-0\n\tWORD $%#08x\n\tRET\n", word)
+				requireARM64SVEGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range []string{
+					"aarch64-apple-darwin",
+					"aarch64-unknown-linux-gnu",
+					"aarch64-pc-windows-msvc",
+				} {
+					t.Run(triple, func(t *testing.T) {
+						ir, err := Translate(file, Options{
+							TargetTriple: triple,
+							Goarch:       "arm64",
+							Sigs: map[string]FuncSig{
+								"sveAddPairRaw": {Name: "sveAddPairRaw", Ret: Void},
+							},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, want := range []string{
+							"@llvm.aarch64.sve." + operation.intrinsic + "." + width.suffix,
+							`"target-features"="+sve,+sve2"`,
+						} {
+							if !strings.Contains(ir, want) {
+								t.Fatalf("omitted %q:\n%s", want, ir)
+							}
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM 22 llc not found")
+						}
+						compileLLVMToObject(t, llc, triple, "arm64-sve-add-pair-raw.ll", "arm64-sve-add-pair-raw.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeARM64RawSVEAddPairwiseLongRegistersAndBoundaries(t *testing.T) {
+	for _, base := range []uint32{
+		0x4444a000, 0x4484a000, 0x44c4a000,
+		0x4445a000, 0x4485a000, 0x44c5a000,
+	} {
+		word := base | 23<<5 | 5<<10 | 17
+		decoded, ok := decodeARM64RawSVEAddPairwiseLong(word)
+		if !ok {
+			t.Fatalf("failed to decode %#08x", word)
+		}
+		if !strings.HasPrefix(string(decoded.Args[0].Reg), "Z23.") || decoded.Args[1].Reg != "P5.M" || !strings.HasPrefix(string(decoded.Args[2].Reg), "Z17.") {
+			t.Fatalf("wrong register fields for %#08x: %+v", word, decoded.Args)
+		}
+	}
+
+	for _, word := range []uint32{
+		0x4404a000, // Byte-width destination is reserved.
+		0x4444e000, // Adjacent encoding with bit 14 set.
+		0x4446a000, // Adjacent opcode with bit 17 set.
+	} {
+		if decoded, ok := decodeARM64RawSVEAddPairwiseLong(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_contiguous_memory.go b/arm64_lower_word_sve_contiguous_memory.go
new file mode 100644
index 000000000..e16cd6b23
--- /dev/null
+++ b/arm64_lower_word_sve_contiguous_memory.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import "fmt"
+
+// decodeARM64RawSVEContiguousMemory covers the single-vector, scalar-base
+// LD1B/ST1B and LD1H/ST1H grammar: signed MUL VL or scaled register offset,
+// with every legal destination arrangement. It reuses the typed Go 1.27
+// ordinary-memory lowerer for load extension and store truncation semantics.
+func decodeARM64RawSVEContiguousMemory(word uint32) (Instr, bool) {
+	const (
+		registerBits  = uint32(0x007f1fff)
+		immediateBits = uint32(0x006f1fff)
+	)
+	forms := [...]struct {
+		op           Op
+		register     uint32
+		immediate    uint32
+		load         bool
+		elementBytes int64
+		minimumWidth int
+	}{
+		{"ZLD1B", 0xa4004000, 0xa400a000, true, 1, 0},
+		{"ZST1B", 0xe4004000, 0xe400e000, false, 1, 0},
+		{"ZLD1H", 0xa4804000, 0xa480a000, true, 2, 1},
+		{"ZST1H", 0xe4804000, 0xe480e000, false, 2, 1},
+	}
+	for _, form := range forms {
+		registerOffset := word&^registerBits == form.register
+		immediateOffset := word&^immediateBits == form.immediate
+		if !registerOffset && !immediateOffset {
+			continue
+		}
+		widthIndex := int(word>>21) & 3
+		if widthIndex < form.minimumWidth {
+			continue
+		}
+		baseNumber := int(word>>5) & 31
+		base := Reg(fmt.Sprintf("R%d", baseNumber))
+		if baseNumber == 31 {
+			base = SP
+		}
+		memory := MemRef{Base: base}
+		if registerOffset {
+			indexNumber := int(word>>16) & 31
+			index := Reg(fmt.Sprintf("R%d", indexNumber))
+			if indexNumber == 31 {
+				index = ZR
+			}
+			if form.elementBytes == 1 {
+				// The unshifted Plan 9 memory spelling puts Xm first.
+				memory.Base = index
+				memory.Index = base
+				memory.Scale = 1
+			} else {
+				memory.Index = index
+				memory.Scale = form.elementBytes
+			}
+		} else {
+			immediate := int(word>>16) & 15
+			if immediate >= 8 {
+				immediate -= 16
+			}
+			if immediate != 0 {
+				if immediate < 0 {
+					memory.OffRaw = fmt.Sprintf("-VL*%d", -immediate)
+				} else {
+					memory.OffRaw = fmt.Sprintf("VL*%d", immediate)
+				}
+			}
+		}
+		width := [...]string{"B", "H", "S", "D"}[widthIndex]
+		vector := int(word) & 31
+		predicate := int(word>>10) & 7
+		list := Operand{
+			Kind:    OpRegList,
+			RegList: []Reg{Reg(fmt.Sprintf("Z%d.%s", vector, width))},
+		}
+		address := Operand{Kind: OpMem, Mem: memory}
+		mode := ""
+		if form.load {
+			mode = ".Z"
+		}
+		governing := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d%s", predicate, mode))}
+		args := []Operand{list, governing, address}
+		if form.load {
+			args = []Operand{address, governing, list}
+		}
+		return Instr{Op: form.op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
diff --git a/arm64_lower_word_sve_convert.go b/arm64_lower_word_sve_convert.go
new file mode 100644
index 000000000..90d06c387
--- /dev/null
+++ b/arm64_lower_word_sve_convert.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEConvertEncoding struct {
+	op              Op
+	sourceBits      int
+	destinationBits int
+	zero            bool
+}
+
+// Go 1.27's predicated ZFCVT, ZFCVTZS, ZFCVTZU, ZSCVTF, and ZUCVTF
+// encoder rows. The register fields share one typed conversion grammar;
+// the fixed words enumerate only architecture-defined width/mode pairs.
+var arm64RawSVEConvertEncodings = map[uint32]arm64RawSVEConvertEncoding{
+	// ZFCVT
+	0x65c8a000: {"ZFCVT", 64, 16, false},
+	0x65caa000: {"ZFCVT", 64, 32, false},
+	0x64da8000: {"ZFCVT", 64, 16, true},
+	0x64dac000: {"ZFCVT", 64, 32, true},
+	0x65c9a000: {"ZFCVT", 16, 64, false},
+	0x6589a000: {"ZFCVT", 16, 32, false},
+	0x64daa000: {"ZFCVT", 16, 64, true},
+	0x649aa000: {"ZFCVT", 16, 32, true},
+	0x65cba000: {"ZFCVT", 32, 64, false},
+	0x6588a000: {"ZFCVT", 32, 16, false},
+	0x64dae000: {"ZFCVT", 32, 64, true},
+	0x649a8000: {"ZFCVT", 32, 16, true},
+
+	// ZFCVTZS
+	0x65dea000: {"ZFCVTZS", 64, 64, false},
+	0x65d8a000: {"ZFCVTZS", 64, 32, false},
+	0x64dfc000: {"ZFCVTZS", 64, 64, true},
+	0x64de8000: {"ZFCVTZS", 64, 32, true},
+	0x655ea000: {"ZFCVTZS", 16, 64, false},
+	0x655aa000: {"ZFCVTZS", 16, 16, false},
+	0x655ca000: {"ZFCVTZS", 16, 32, false},
+	0x645fc000: {"ZFCVTZS", 16, 64, true},
+	0x645ec000: {"ZFCVTZS", 16, 16, true},
+	0x645f8000: {"ZFCVTZS", 16, 32, true},
+	0x65dca000: {"ZFCVTZS", 32, 64, false},
+	0x659ca000: {"ZFCVTZS", 32, 32, false},
+	0x64df8000: {"ZFCVTZS", 32, 64, true},
+	0x649f8000: {"ZFCVTZS", 32, 32, true},
+
+	// ZFCVTZU
+	0x65dfa000: {"ZFCVTZU", 64, 64, false},
+	0x65d9a000: {"ZFCVTZU", 64, 32, false},
+	0x64dfe000: {"ZFCVTZU", 64, 64, true},
+	0x64dea000: {"ZFCVTZU", 64, 32, true},
+	0x655fa000: {"ZFCVTZU", 16, 64, false},
+	0x655ba000: {"ZFCVTZU", 16, 16, false},
+	0x655da000: {"ZFCVTZU", 16, 32, false},
+	0x645fe000: {"ZFCVTZU", 16, 64, true},
+	0x645ee000: {"ZFCVTZU", 16, 16, true},
+	0x645fa000: {"ZFCVTZU", 16, 32, true},
+	0x65dda000: {"ZFCVTZU", 32, 64, false},
+	0x659da000: {"ZFCVTZU", 32, 32, false},
+	0x64dfa000: {"ZFCVTZU", 32, 64, true},
+	0x649fa000: {"ZFCVTZU", 32, 32, true},
+
+	// ZSCVTF
+	0x65d6a000: {"ZSCVTF", 64, 64, false},
+	0x6556a000: {"ZSCVTF", 64, 16, false},
+	0x65d4a000: {"ZSCVTF", 64, 32, false},
+	0x64ddc000: {"ZSCVTF", 64, 64, true},
+	0x645dc000: {"ZSCVTF", 64, 16, true},
+	0x64dd8000: {"ZSCVTF", 64, 32, true},
+	0x6552a000: {"ZSCVTF", 16, 16, false},
+	0x645cc000: {"ZSCVTF", 16, 16, true},
+	0x65d0a000: {"ZSCVTF", 32, 64, false},
+	0x6554a000: {"ZSCVTF", 32, 16, false},
+	0x6594a000: {"ZSCVTF", 32, 32, false},
+	0x64dc8000: {"ZSCVTF", 32, 64, true},
+	0x645d8000: {"ZSCVTF", 32, 16, true},
+	0x649d8000: {"ZSCVTF", 32, 32, true},
+
+	// ZUCVTF
+	0x65d7a000: {"ZUCVTF", 64, 64, false},
+	0x6557a000: {"ZUCVTF", 64, 16, false},
+	0x65d5a000: {"ZUCVTF", 64, 32, false},
+	0x64dde000: {"ZUCVTF", 64, 64, true},
+	0x645de000: {"ZUCVTF", 64, 16, true},
+	0x64dda000: {"ZUCVTF", 64, 32, true},
+	0x6553a000: {"ZUCVTF", 16, 16, false},
+	0x645ce000: {"ZUCVTF", 16, 16, true},
+	0x65d1a000: {"ZUCVTF", 32, 64, false},
+	0x6555a000: {"ZUCVTF", 32, 16, false},
+	0x6595a000: {"ZUCVTF", 32, 32, false},
+	0x64dca000: {"ZUCVTF", 32, 64, true},
+	0x645da000: {"ZUCVTF", 32, 16, true},
+	0x649da000: {"ZUCVTF", 32, 32, true},
+}
+
+func decodeARM64RawSVEConvert(word uint32) (Instr, bool) {
+	const registerFields = uint32(0x1fff)
+	spec, ok := arm64RawSVEConvertEncodings[word&^registerFields]
+	if !ok {
+		return Instr{}, false
+	}
+	width := map[int]string{16: "H", 32: "S", 64: "D"}
+	mode := "M"
+	if spec.zero {
+		mode = "Z"
+	}
+	source := int(word>>5) & 31
+	predicate := int(word>>10) & 7
+	destination := int(word) & 31
+	return Instr{
+		Op: spec.op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", source, width[spec.sourceBits]))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", predicate, mode))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", destination, width[spec.destinationBits]))},
+		},
+		Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_convert_test.go b/arm64_lower_word_sve_convert_test.go
new file mode 100644
index 000000000..e5df7d0a0
--- /dev/null
+++ b/arm64_lower_word_sve_convert_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEConvertGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSVEConvert(SB),$0-0
+	WORD $0x6589a400 // FCVT Z0.S, P1/M, Z0.H
+	WORD $0x659ca3ff // FCVTZS Z31.S, P0/M, Z31.S
+	WORD $0x65bea308 // FMSB Z8.S, P0/M, Z24.S, Z30.S
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEConvert": {Name: "rawSVEConvert", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			var conversionCalls []string
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, "call ") && strings.Contains(line, "@llvm.aarch64.sve.fcvt") {
+					conversionCalls = append(conversionCalls, line)
+				}
+			}
+			if len(conversionCalls) != 2 {
+				t.Fatalf("want two SVE conversion calls, got %v", conversionCalls)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-convert.ll", "arm64-raw-sve-convert.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_count_test.go b/arm64_lower_word_sve_count_test.go
new file mode 100644
index 000000000..4b5699462
--- /dev/null
+++ b/arm64_lower_word_sve_count_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawSVECntForms = `TEXT svecntwords(SB),$0-0
+	WORD $0x0420e3ea // CNTB X10
+	WORD $0x0460e3ea // CNTH X10
+	WORD $0x04a0e3ea // CNTW X10
+	WORD $0x04e0e3ea // CNTD X10
+	RET
+`
+
+func TestTranslateARM64RawSVECntForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSVECntForms, true)
+	file, err := Parse(ArchARM64, arm64RawSVECntForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"svecntwords": {Name: "svecntwords", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-count.ll", "arm64-sve-count.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_dup_immediate_test.go b/arm64_lower_word_sve_dup_immediate_test.go
new file mode 100644
index 000000000..bbef9525b
--- /dev/null
+++ b/arm64_lower_word_sve_dup_immediate_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVEDupImmediate(elementBits, immediate, shift, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x2538c000 | size<<22 | uint32(uint8(int8(immediate)))<<5 | uint32(shift/8)<<13 | uint32(destination)
+}
+
+func TestTranslateARM64SVEDupImmediateCompleteGo127Form(t *testing.T) {
+	const named = `
+TEXT svedupnamed(SB),$0-0
+	ZDUP R0, Z14.B
+	ZDUP R1, Z15.H
+	ZDUP R2, Z16.S
+	ZDUP RSP, Z17.D
+	ZDUP Z0.B[0], Z18.B
+	ZDUP Z1.B[15], Z19.B
+	ZDUP Z2.H[0], Z20.H
+	ZDUP Z3.H[7], Z21.H
+	ZDUP Z4.S[0], Z22.S
+	ZDUP Z5.S[3], Z23.S
+	ZDUP Z6.D[0], Z24.D
+	ZDUP Z7.D[1], Z25.D
+	ZDUP Z8.Q[0], Z26.Q
+	ZDUP Z9.Q[1], Z27.Q
+	ZDUP $-128, Z0.B
+	ZDUP $127, Z1.B
+	ZDUP $-128, Z2.H
+	ZDUP $127, Z3.H
+	ZDUP $-32768, Z4.H
+	ZDUP $32512, Z5.H
+	ZDUP $-128, Z6.S
+	ZDUP $127, Z7.S
+	ZDUP $-32768, Z8.S
+	ZDUP $32512, Z9.S
+	ZDUP $-128, Z10.D
+	ZDUP $127, Z11.D
+	ZDUP $-32768, Z12.D
+	ZDUP $32512, Z13.D
+	RET
+`
+	requireARM64SVEGoAssemblerResult(t, named, true)
+
+	var raw strings.Builder
+	raw.WriteString("TEXT svedupraw(SB),$0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, shift := range []int{0, 8} {
+			if elementBits == 8 && shift == 8 {
+				continue
+			}
+			for _, immediate := range []int{-128, 0, 127} {
+				fmt.Fprintf(&raw, "\tWORD $%#08x\n", encodeARM64RawSVEDupImmediate(elementBits, immediate, shift, (elementBits+shift+immediate)&31))
+			}
+		}
+	}
+	raw.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, raw.String(), true)
+
+	for name, source := range map[string]string{"named": named, "raw": raw.String()} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := "svedup" + name
+			for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					ll, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs:         map[string]FuncSig{function: {Name: function, Ret: Void}},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{`"target-features"=`, "+sve", "<vscale x 16 x i8>", "splat (i"} {
+						if !strings.Contains(ll, want) {
+							t.Fatalf("ARM64 SVE DUP immediate lowering for %s/%s omitted %q:\n%s", name, triple, want, ll)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-dup-immediate.ll", "arm64-sve-dup-immediate.o", ll)
+				})
+			}
+		})
+	}
+}
+
+func encodeARM64RawSVEDupElement(elementBits, lane, source, destination int) uint32 {
+	if elementBits == 128 {
+		return 0x05202000 | 16<<16 | uint32(lane)<<22 | uint32(source)<<5 | uint32(destination)
+	}
+	size := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	imm5 := lane<<(size+1) | 1<<size
+	return 0x05202000 | uint32(imm5&31)<<16 | uint32(imm5>>5)<<22 | uint32(source)<<5 | uint32(destination)
+}
+
+func TestARM64RawSVEDupElementDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, domain := range []struct {
+		bits, lanes int
+	}{{8, 64}, {16, 32}, {32, 16}, {64, 8}, {128, 4}} {
+		for lane := 0; lane < domain.lanes; lane++ {
+			for source := 0; source < 32; source++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEDupElement(domain.bits, lane, source, destination)
+					got, ok := decodeARM64RawSVEDupElement(word)
+					if !ok || got.elementBits != domain.bits || got.lane != lane || got.source != source || got.destination != destination {
+						t.Fatalf("decoded SVE DUP element %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != (64+32+16+8+4)*32*32 {
+		t.Fatalf("covered %d SVE DUP element encodings", count)
+	}
+}
+
+func TestARM64RawSVEDupElementRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x05202000, 0x05602000, 0x05a02000, 0x05e02000, 0x05202400} {
+		if _, ok := decodeARM64RawSVEDupElement(word); ok {
+			t.Fatalf("SVE DUP element decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func TestARM64RawSVEDupImmediateDecoderCoversArchitecturalDomain(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, shift := range []int{0, 8} {
+			if elementBits == 8 && shift == 8 {
+				continue
+			}
+			for immediate := -128; immediate <= 127; immediate++ {
+				for destination := 0; destination < 32; destination++ {
+					word := encodeARM64RawSVEDupImmediate(elementBits, immediate, shift, destination)
+					got, ok := decodeARM64RawSVEDupImmediate(word)
+					wantImmediate := immediate << shift
+					if !ok || got.elementBits != elementBits || got.immediate != wantImmediate || got.destination != destination {
+						t.Fatalf("decoded SVE DUP immediate word %#08x as %+v, ok=%v; want bits=%d immediate=%d destination=%d", word, got, ok, elementBits, wantImmediate, destination)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 7*256*32 {
+		t.Fatalf("covered %d SVE DUP immediate encodings, want %d", count, 7*256*32)
+	}
+}
+
+func TestARM64RawSVEDupImmediateDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARM64RawSVEDupImmediate(8, 1, 8, 0), // The shifted byte form is reserved.
+		0x25388000, // Neighboring SVE broadcast class.
+		0x2539c000, // Neighboring SVE instruction class.
+	} {
+		if _, ok := decodeARM64RawSVEDupImmediate(word); ok {
+			t.Fatalf("SVE DUP immediate decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_dupm.go b/arm64_lower_word_sve_dupm.go
new file mode 100644
index 000000000..38e99e598
--- /dev/null
+++ b/arm64_lower_word_sve_dupm.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import "fmt"
+
+// ZDUPM shares the thirteen-bit logical-immediate grammar with SVE bitwise
+// instructions. The element width is encoded by the immediate itself.
+func decodeARM64RawSVEDupM(word uint32) (Instr, bool) {
+	if word&0xfffc0000 != 0x05c00000 {
+		return Instr{}, false
+	}
+	elementBits, immediate, ok := decodeARM64SVELogicalImmediate(int(word>>5) & 0x1fff)
+	if !ok {
+		return Instr{}, false
+	}
+	width := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[elementBits]
+	destination := word & 31
+	return Instr{
+		Op: "ZDUPM",
+		Args: []Operand{
+			{Kind: OpImm, Imm: int64(immediate)},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", destination, width))},
+		},
+		Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_dupm_test.go b/arm64_lower_word_sve_dupm_test.go
new file mode 100644
index 000000000..5f3696bdc
--- /dev/null
+++ b/arm64_lower_word_sve_dupm_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64RawSVEDupMDecoderCoversLogicalImmediateAndDestination(t *testing.T) {
+	for immediateBits := 0; immediateBits < 1<<13; immediateBits++ {
+		width, immediate, valid := decodeARM64SVELogicalImmediate(immediateBits)
+		for destination := 0; destination < 32; destination++ {
+			word := uint32(0x05c00000 | immediateBits<<5 | destination)
+			got, ok := decodeARM64RawSVEDupM(word)
+			if ok != valid {
+				t.Fatalf("ZDUPM %#08x validity = %v, want %v", word, ok, valid)
+			}
+			if !valid {
+				continue
+			}
+			reg, bits, regOK := arm64ParseSVEZElementReg(got.Args[1])
+			if !regOK || reg != destination || bits != width || uint64(got.Args[0].Imm) != immediate {
+				t.Fatalf("ZDUPM %#08x decoded as %+v", word, got)
+			}
+		}
+	}
+}
+
+func TestTranslateARM64RawSVEDupMGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSVEDupM(SB),$0-0
+	WORD $0x05c02840 // MOV Z0.S, #0x38000000
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEDupM": {Name: "rawSVEDupM", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-dupm.ll", "arm64-raw-sve-dupm.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_extra_shift.go b/arm64_lower_word_sve_extra_shift.go
new file mode 100644
index 000000000..131070925
--- /dev/null
+++ b/arm64_lower_word_sve_extra_shift.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "fmt"
+
+// Derive the raw lookup tables from the same family specs used by named
+// validation and lowering. Immediate and reverse-vector operands share the
+// predicated mask, but use different interpretations of bits 9:5.
+var arm64SVEExtraShiftPredicated, arm64SVEExtraShiftUnpredicated = arm64SVEExtraShiftRawTables()
+
+func arm64SVEExtraShiftRawTables() (map[uint32]Op, map[uint32]Op) {
+	predicated, unpredicated := make(map[uint32]Op), make(map[uint32]Op)
+	for op, spec := range arm64SVEImmediateShiftSpecs {
+		if spec.predicated {
+			predicated[spec.rawBase] = op
+		} else {
+			unpredicated[spec.rawBase] = op
+		}
+	}
+	for op, spec := range arm64SVEReverseShiftIntrinsics {
+		predicated[spec.rawBase] = op
+	}
+	return predicated, unpredicated
+}
+
+func decodeARM64RawSVEExtraShift(word uint32) (Instr, bool) {
+	op, predicated := arm64SVEExtraShiftPredicated[word&0xff3fe000]
+	lowBit := 5
+	if !predicated {
+		var ok bool
+		op, ok = arm64SVEExtraShiftUnpredicated[word&0xff20fc00]
+		if !ok {
+			return Instr{}, false
+		}
+		lowBit = 16
+	}
+	_, reverse := arm64SVEReverseShiftIntrinsics[op]
+	elementBits, shift, valid := decodeARM64SVEShiftImmediate(word, lowBit)
+	if reverse {
+		elementBits = 8 << (word >> 22 & 3)
+	} else if !valid {
+		return Instr{}, false
+	} else if arm64SVEImmediateShiftSpecs[op].minimum == 0 {
+		shift = elementBits - shift
+	}
+	width := map[int]byte{8: 'B', 16: 'H', 32: 'S', 64: 'D'}[elementBits]
+	reg := func(number uint32) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", number, width))}
+	}
+	destination := reg(word & 31)
+	first := Operand{Kind: OpImm, Imm: int64(shift)}
+	if reverse {
+		first = reg(word >> 5 & 31)
+	}
+	args := []Operand{first}
+	if predicated {
+		args = append(args, destination, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>10&7))})
+	} else {
+		args = append(args, reg(word>>5&31))
+	}
+	args = append(args, destination)
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
+
+func (c *arm64Ctx) lowerARM64RawSVEExtraShift(ins Instr) error {
+	spec, immediate := arm64SVEImmediateShiftSpecs[ins.Op]
+	if !immediate {
+		_, _, err := c.lowerARM64SVEExtraShift(ins.Op, ins)
+		return err
+	}
+	source, bits, _ := arm64ParseSVEZElementReg(ins.Args[1])
+	destination, _, _ := arm64ParseSVEZElementReg(ins.Args[len(ins.Args)-1])
+	predicate := 0
+	if spec.predicated {
+		predicate, _ = arm64ParseSVEPredicateMerge(ins.Args[2])
+	}
+	// Arm WORD encodings allow right shifts by the full element width;
+	// Go's named immediate grammar intentionally retains its tighter bound.
+	return c.lowerARM64SVEExtraImmediateShiftForm(spec, bits, source, destination, predicate, ins.Args[0].Imm)
+}
diff --git a/arm64_lower_word_sve_float.go b/arm64_lower_word_sve_float.go
new file mode 100644
index 000000000..7c186c53d
--- /dev/null
+++ b/arm64_lower_word_sve_float.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEFloatKind uint8
+
+const (
+	arm64RawSVEFloatAdd arm64RawSVEFloatKind = iota
+	arm64RawSVEFloatSub
+	arm64RawSVEFloatMul
+	arm64RawSVEFloatFADDV
+	arm64RawSVEFloatFADDA
+	arm64RawSVEFloatSubReverse
+)
+
+type arm64RawSVEFloat struct {
+	kind         arm64RawSVEFloatKind
+	elementBits  int
+	destination  int
+	first        int
+	second       int
+	predicate    int
+	predicated   bool
+	immediate    float64
+	hasImmediate bool
+	lane         int
+	hasLane      bool
+}
+
+func (c *arm64Ctx) loadRawSVEFloatVector(index, elementBits int) (string, string, error) {
+	bytes, err := c.loadZReg(index)
+	if err != nil {
+		return "", "", err
+	}
+	floatingType := map[int]string{16: "half", 32: "float", 64: "double"}[elementBits]
+	if floatingType == "" {
+		return "", "", fmt.Errorf("unsupported ARM64 SVE floating element width %d", elementBits)
+	}
+	vectorType := fmt.Sprintf("<vscale x %d x %s>", 128/elementBits, floatingType)
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 16 x i8> %s to %s\n", converted, bytes, vectorType)
+	return "%" + converted, vectorType, nil
+}
+
+func (c *arm64Ctx) storeRawSVEFloatVector(index, elementBits int, value string, vectorType string) error {
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 16 x i8>\n", bytes, vectorType, value)
+	return c.storeZReg(index, "%"+bytes)
+}
+
+// decodeARM64RawSVEFloat covers the scalar-vector SVE floating arithmetic
+// encodings emitted by Go's generated assembly. The destructive predicated
+// forms keep Zd as their first operand. FMA has its own complete decoder;
+// never let a relaxed arithmetic mask consume a neighboring opcode family.
+func decodeARM64RawSVEFloat(word uint32) (arm64RawSVEFloat, bool) {
+	if form, ok := decodeARM64RawSVEFloatArithmetic(word); ok {
+		return form, true
+	}
+	form := arm64RawSVEFloat{elementBits: 8 << (int(word>>22) & 3)}
+	if form.elementBits == 8 {
+		return arm64RawSVEFloat{}, false
+	}
+	switch {
+	case word&0xff20e000 == 0x65002000:
+		form.destination = int(word) & 31
+		form.predicate = int(word>>10) & 7
+		if word&0x001f0000 == 0 {
+			form.kind = arm64RawSVEFloatFADDV
+			form.first = int(word>>5) & 31
+		} else if word&0x001f0000 == 0x00180000 {
+			form.kind = arm64RawSVEFloatFADDA
+			form.first = int(word>>5) & 31
+		} else {
+			return arm64RawSVEFloat{}, false
+		}
+	default:
+		return arm64RawSVEFloat{}, false
+	}
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSVEFloat(form arm64RawSVEFloat) error {
+	// Raw bytes and named syntax must share semantics, including predicate
+	// merging, exact reduction order, and scalar destination lane clearing.
+	if form.kind == arm64RawSVEFloatFADDV || form.kind == arm64RawSVEFloatFADDA {
+		kind := arm64SVEFloatAddReduce
+		if form.kind == arm64RawSVEFloatFADDA {
+			kind = arm64SVEFloatAddAccumulate
+		}
+		return c.lowerARM64SVEAddReductionForm(
+			arm64SVEAddReductionSpec{kind: kind, elementBits: form.elementBits},
+			arm64SVEAddReductionForm{elementBits: form.elementBits, source: form.first,
+				predicate: form.predicate, destination: form.destination},
+			Reg(fmt.Sprintf("V%d", form.destination)))
+	}
+
+	first, second := form.first, form.second
+	if form.predicated {
+		first, second = form.destination, form.first
+	}
+	if form.kind == arm64RawSVEFloatMul {
+		return c.lowerARM64SVEFloatMultiplyForm(arm64SVEFloatMultiplyForm{
+			elementBits: form.elementBits, first: first, second: second,
+			predicate: form.predicate, destination: form.destination, predicated: form.predicated,
+			immediate: form.immediate, hasImmediate: form.hasImmediate,
+			laneVector: second, lane: form.lane, hasLane: form.hasLane,
+		})
+	}
+	op := Op("ZFADD")
+	if form.kind == arm64RawSVEFloatSub {
+		op = "ZFSUB"
+	} else if form.kind == arm64RawSVEFloatSubReverse {
+		op = "ZFSUBR"
+	}
+	return c.lowerARM64SVEFloatAddSubForm(arm64SVEFloatAddSubSpecs[op], arm64SVEFloatAddSubForm{
+		elementBits: form.elementBits, first: first, second: second,
+		predicate: form.predicate, destination: form.destination, predicated: form.predicated,
+		immediate: form.immediate, hasImmediate: form.hasImmediate,
+	})
+}
diff --git a/arm64_lower_word_sve_float_arithmetic.go b/arm64_lower_word_sve_float_arithmetic.go
new file mode 100644
index 000000000..9ae18f508
--- /dev/null
+++ b/arm64_lower_word_sve_float_arithmetic.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+type arm64SVEFloatArithmeticSpec struct {
+	kind       arm64RawSVEFloatKind
+	vector     uint32
+	predicated uint32
+	immediate  uint32
+	constants  [2]float64
+	indexed    [3]uint32
+}
+
+// All named arithmetic forms and raw encodings use the same immediate
+// choices. Raw normalization feeds the existing typed semantic forms.
+var arm64SVEFloatArithmeticSpecs = map[Op]arm64SVEFloatArithmeticSpec{
+	"ZFADD": {kind: arm64RawSVEFloatAdd, vector: 0x65000000, predicated: 0x65008000,
+		immediate: 0x65188000, constants: [2]float64{0.5, 1}},
+	"ZFSUB": {kind: arm64RawSVEFloatSub, vector: 0x65000400, predicated: 0x65018000,
+		immediate: 0x65198000, constants: [2]float64{0.5, 1}},
+	"ZFSUBR": {kind: arm64RawSVEFloatSubReverse, predicated: 0x65038000,
+		immediate: 0x651b8000, constants: [2]float64{0.5, 1}},
+	"ZFMUL": {kind: arm64RawSVEFloatMul, vector: 0x65000800, predicated: 0x65028000,
+		immediate: 0x651a8000, constants: [2]float64{0.5, 2}, indexed: [3]uint32{0x64202000, 0x64a02000, 0x64e02000}},
+}
+
+type arm64SVEFloatArithmeticRawTables struct {
+	vector, predicated, immediate map[uint32]arm64SVEFloatArithmeticSpec
+	indexed                       map[uint32]int
+}
+
+var arm64SVEFloatArithmeticRaw = func() arm64SVEFloatArithmeticRawTables {
+	tables := arm64SVEFloatArithmeticRawTables{
+		vector: make(map[uint32]arm64SVEFloatArithmeticSpec), predicated: make(map[uint32]arm64SVEFloatArithmeticSpec),
+		immediate: make(map[uint32]arm64SVEFloatArithmeticSpec), indexed: make(map[uint32]int),
+	}
+	for _, spec := range arm64SVEFloatArithmeticSpecs {
+		if spec.vector != 0 {
+			tables.vector[spec.vector] = spec
+		}
+		tables.predicated[spec.predicated], tables.immediate[spec.immediate] = spec, spec
+		for size, base := range spec.indexed {
+			if base != 0 {
+				tables.indexed[base] = size + 1
+			}
+		}
+	}
+	return tables
+}()
+
+func decodeARM64RawSVEFloatArithmetic(word uint32) (arm64RawSVEFloat, bool) {
+	form := arm64RawSVEFloat{elementBits: 8 << (word >> 22 & 3), destination: int(word & 31)}
+	if spec, ok := arm64SVEFloatArithmeticRaw.vector[word&0xff20fc00]; ok {
+		form.kind = spec.kind
+		form.first, form.second = int(word>>5&31), int(word>>16&31)
+	} else if spec, ok := arm64SVEFloatArithmeticRaw.predicated[word&0xff3fe000]; ok {
+		form.kind, form.predicated = spec.kind, true
+		form.first, form.predicate = int(word>>5&31), int(word>>10&7)
+	} else if spec, ok := arm64SVEFloatArithmeticRaw.immediate[word&0xff3fe3c0]; ok {
+		form.kind, form.predicated, form.hasImmediate = spec.kind, true, true
+		form.first, form.predicate = form.destination, int(word>>10&7)
+		form.immediate = spec.constants[word>>5&1]
+	} else {
+		size, ok := arm64SVEFloatArithmeticRaw.indexed[word&0xffe0fc00]
+		if !ok {
+			size, ok = arm64SVEFloatArithmeticRaw.indexed[word&0xffa0fc00]
+			if !ok || size != 1 {
+				return arm64RawSVEFloat{}, false
+			}
+		}
+		form.kind, form.hasLane, form.elementBits = arm64RawSVEFloatMul, true, 8<<size
+		form.first, form.second, form.lane = int(word>>5&31), int(word>>16&7), int(word>>19&3)
+		if size == 1 {
+			form.lane |= int(word >> 20 & 4)
+		} else if size == 3 {
+			form.second, form.lane = int(word>>16&15), int(word>>20&1)
+		}
+	}
+	return form, form.elementBits >= 16
+}
diff --git a/arm64_lower_word_sve_float_immediate.go b/arm64_lower_word_sve_float_immediate.go
new file mode 100644
index 000000000..73a990dac
--- /dev/null
+++ b/arm64_lower_word_sve_float_immediate.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+)
+
+// Go 1.27's ZFDUP/ZFCPY rows share an 8-bit floating immediate and H/S/D
+// elements. ZFCPY adds P0..P15/M. LLVM's FMOV spellings are aliases.
+func decodeARM64RawSVEFloatImmediate(word uint32) (Instr, bool) {
+	op := Op("ZFDUP")
+	switch {
+	case word&0xff3fe000 == 0x2539c000:
+	case word&0xff30e000 == 0x0510c000:
+		op = "ZFCPY"
+	default:
+		return Instr{}, false
+	}
+	width := map[uint32]string{1: "H", 2: "S", 3: "D"}[word>>22&3]
+	if width == "" {
+		return Instr{}, false
+	}
+	immediate := byte(word >> 5)
+	value := arm64ExpandedFloatImmediate(immediate)
+	destination := int(word) & 31
+	args := []Operand{{Kind: OpImm, Imm: int64(math.Float64bits(value)), ImmIsFloat: true}}
+	if op == "ZFCPY" {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>16&15))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", destination, width))})
+	return Instr{
+		Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_float_immediate_test.go b/arm64_lower_word_sve_float_immediate_test.go
new file mode 100644
index 000000000..b97e5b453
--- /dev/null
+++ b/arm64_lower_word_sve_float_immediate_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEFloatImmediateGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSVEFloatImmediate(SB),$0-0
+	WORD $0x2579cc00 // FMOV Z0.H, #0.5
+	WORD $0x25b9cc1b // FMOV Z27.S, #0.5
+	WORD $0x25f9ce1f // FMOV Z31.D, #1.0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEFloatImmediate": {Name: "rawSVEFloatImmediate", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"<vscale x 8 x half>", "<vscale x 4 x float>", "<vscale x 2 x double>"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("SVE FMOV immediate omitted %q:\n%s", want, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-fmov.ll", "arm64-raw-sve-fmov.o", ir)
+		})
+	}
+}
+
+func arm64SVEFloatImmediateTestValue(imm int) float64 {
+	value := math.Ldexp(float64(16+(imm&15)), ((imm>>4&7)^4)-7)
+	if imm&128 != 0 {
+		value = -value
+	}
+	return value
+}
+
+func arm64SVEFloatImmediateAssembly(size, dst, predicate, imm int) string {
+	if predicate < 0 {
+		return fmt.Sprintf("fmov z%d.%c, #%g", dst, "bhsd"[size], arm64SVEFloatImmediateTestValue(imm))
+	}
+	return fmt.Sprintf("fmov z%d.%c, p%d/m, #%g", dst, "bhsd"[size], predicate, arm64SVEFloatImmediateTestValue(imm))
+}
+
+func TestARM64RawSVEFloatImmediateOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for size := 1; size < 4; size++ {
+		for _, predicated := range []bool{false, true} {
+			limits := [3]int{32, 1, 256}
+			if predicated {
+				limits[1] = 16
+			}
+			for field, limit := range limits {
+				for value := 0; value < limit; value++ {
+					fields := [3]int{31, 15, 255}
+					fields[field] = value
+					dst, pred, imm := fields[0], fields[1], fields[2]
+					want := Instr{Op: "ZFDUP", Args: []Operand{{Kind: OpImm, ImmIsFloat: true, Imm: int64(math.Float64bits(arm64SVEFloatImmediateTestValue(imm)))}}}
+					if predicated {
+						want.Op = "ZFCPY"
+						want.Args = append(want.Args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", pred))})
+					} else {
+						pred = -1
+					}
+					want.Args = append(want.Args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", dst, "BHSD"[size]))})
+					wants = append(wants, want)
+					lines = append(lines, arm64SVEFloatImmediateAssembly(size, dst, pred, imm))
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVEFloatImmediate(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: %#08x = %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+		if got, ok := decodeARM64RawSVEFloatImmediate(word &^ (3 << 22)); ok {
+			t.Errorf("reserved byte-width encoding decoded as %+v", got)
+		}
+	}
+	for _, word := range []uint32{0x0593ee1b, 0x05934e1b, 0x25b9ec00, 0x25b8cc00} {
+		if got, ok := decodeARM64RawSVEFloatImmediate(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
+
+func TestARM64RawSVEFloatCopyCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, width := range []string{"h", "s", "d"} {
+		for _, predicate := range []int{0, 7, 8, 15} {
+			for _, value := range []float64{-31.0, -0.125, 1.0, 31.0} {
+				lines = append(lines, fmt.Sprintf("fmov z31.%s, p%d/m, #%g", width, predicate, value))
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatcopy(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawfloatcopy": {Name: "rawfloatcopy", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawfloatcopy.ll", "rawfloatcopy.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_float_minmax_reduce.go b/arm64_lower_word_sve_float_minmax_reduce.go
new file mode 100644
index 000000000..457bd6a5f
--- /dev/null
+++ b/arm64_lower_word_sve_float_minmax_reduce.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEFloatMinMaxReduction struct {
+	spec        arm64SVEFloatMinMaxSpec
+	form        arm64SVEFloatMinMaxForm
+	destination Reg
+}
+
+// SVE's four predicated floating min/max reductions share one encoding
+// grammar. The opcode nibble chooses max/min and NaN behavior; size chooses
+// H/S/D; the remaining variable fields are Zd, Zn, and Pg.
+func decodeARM64RawSVEFloatMinMaxReduction(word uint32) (arm64RawSVEFloatMinMaxReduction, bool) {
+	if word&0xff30e000 != 0x65002000 {
+		return arm64RawSVEFloatMinMaxReduction{}, false
+	}
+
+	size := int(word>>22) & 3
+	opcode := int(word>>16) & 15
+	if size == 0 || opcode < 4 || opcode > 7 {
+		return arm64RawSVEFloatMinMaxReduction{}, false
+	}
+
+	operations := [...]string{"ZFMAXNMV", "ZFMINNMV", "ZFMAXV", "ZFMINV"}
+	suffixes := [...]string{"", "H", "S", "D"}
+	op := Op(operations[opcode-4] + suffixes[size])
+	spec, ok := arm64SVEFloatMinMaxSpecs[op]
+	if !ok {
+		return arm64RawSVEFloatMinMaxReduction{}, false
+	}
+
+	destination := int(word) & 31
+	return arm64RawSVEFloatMinMaxReduction{
+		spec: spec,
+		form: arm64SVEFloatMinMaxForm{
+			elementBits: 8 << size,
+			first:       int(word>>5) & 31,
+			predicate:   int(word>>10) & 7,
+			destination: destination,
+		},
+		destination: Reg(fmt.Sprintf("V%d", destination)),
+	}, true
+}
diff --git a/arm64_lower_word_sve_float_minmax_reduce_test.go b/arm64_lower_word_sve_float_minmax_reduce_test.go
new file mode 100644
index 000000000..9796749f3
--- /dev/null
+++ b/arm64_lower_word_sve_float_minmax_reduce_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEFloatMinMaxReductionCompleteFamily(t *testing.T) {
+	forms := []struct {
+		name      string
+		word      uint32
+		intrinsic string
+		suffix    string
+	}{
+		{"FMAXNMV H", 0x65442000, "fmaxnmv", "nxv8f16"},
+		{"FMINNMV H", 0x65452000, "fminnmv", "nxv8f16"},
+		{"FMAXV H", 0x65462000, "fmaxv", "nxv8f16"},
+		{"FMINV H", 0x65472000, "fminv", "nxv8f16"},
+		{"FMAXNMV S", 0x65842000, "fmaxnmv", "nxv4f32"},
+		{"FMINNMV S", 0x65852000, "fminnmv", "nxv4f32"},
+		{"FMAXV S", 0x65862000, "fmaxv", "nxv4f32"},
+		{"FMINV S", 0x65872000, "fminv", "nxv4f32"},
+		{"FMAXNMV D", 0x65c42000, "fmaxnmv", "nxv2f64"},
+		{"FMINNMV D", 0x65c52000, "fminnmv", "nxv2f64"},
+		{"FMAXV D", 0x65c62000, "fmaxv", "nxv2f64"},
+		{"FMINV D", 0x65c72000, "fminv", "nxv2f64"},
+	}
+
+	for _, form := range forms {
+		t.Run(form.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT sveFloatMinMaxRaw(SB),$0-0\n")
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", form.word, form.name)
+			source.WriteString("\tRET\n")
+			requireARM64SVEGoAssemblerResult(t, source.String(), true)
+
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin",
+				"aarch64-unknown-linux-gnu",
+				"aarch64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs: map[string]FuncSig{
+							"sveFloatMinMaxRaw": {Name: "sveFloatMinMaxRaw", Ret: Void},
+						},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := "@llvm.aarch64.sve." + form.intrinsic + "." + form.suffix
+					for _, want := range []string{want, `"target-features"="+sve"`} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("omitted %q:\n%s", want, ir)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-float-minmax-raw.ll", "arm64-sve-float-minmax-raw.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEFloatMinMaxReductionRegistersAndBoundaries(t *testing.T) {
+	// The opcode and width are fixed by the SVE grammar; Zd, Zn, and Pg
+	// remain independently variable across the complete family.
+	for _, base := range []uint32{
+		0x65442000, 0x65452000, 0x65462000, 0x65472000,
+		0x65842000, 0x65852000, 0x65862000, 0x65872000,
+		0x65c42000, 0x65c52000, 0x65c62000, 0x65c72000,
+	} {
+		word := base | 17 | 23<<5 | 5<<10
+		reduction, ok := decodeARM64RawSVEFloatMinMaxReduction(word)
+		if !ok {
+			t.Fatalf("failed to decode %#08x", word)
+		}
+		if reduction.form.destination != 17 || reduction.form.first != 23 || reduction.form.predicate != 5 {
+			t.Fatalf("wrong register fields for %#08x: %+v", word, reduction.form)
+		}
+		if reduction.destination != "V17" {
+			t.Fatalf("wrong scalar destination for %#08x: %s", word, reduction.destination)
+		}
+	}
+
+	for _, word := range []uint32{
+		0x65042000, // Reserved byte-width variant.
+		0x65832000, // Adjacent opcode before the family.
+		0x65882000, // Adjacent opcode after the family.
+		0x65870000, // Reduction encoding requires bit 13.
+		0x6587a000, // Adjacent encoding with bit 15 set.
+	} {
+		if _, ok := decodeARM64RawSVEFloatMinMaxReduction(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_float_multiply_accumulate.go b/arm64_lower_word_sve_float_multiply_accumulate.go
new file mode 100644
index 000000000..26537bca1
--- /dev/null
+++ b/arm64_lower_word_sve_float_multiply_accumulate.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27 exposes all eight predicated fused floating-point multiply forms
+// with the same register fields. The first two source operands have a different
+// field order for the accumulating (MLA/MLS) and destructive (MAD/MSB) forms.
+var arm64RawSVEFloatMultiplyAccumulateBases = map[uint32]Op{
+	0x65208000: "ZFMAD",
+	0x65200000: "ZFMLA",
+	0x65202000: "ZFMLS",
+	0x6520a000: "ZFMSB",
+	0x6520c000: "ZFNMAD",
+	0x65204000: "ZFNMLA",
+	0x65206000: "ZFNMLS",
+	0x6520e000: "ZFNMSB",
+}
+
+func decodeARM64RawSVEFloatMultiplyAccumulate(word uint32) (Instr, bool) {
+	const variableFields = uint32(0x00df1fff)
+	op, ok := arm64RawSVEFloatMultiplyAccumulateBases[word&^variableFields]
+	if !ok {
+		return Instr{}, false
+	}
+	width := map[uint32]string{1: "H", 2: "S", 3: "D"}[word>>22&3]
+	if width == "" {
+		return Instr{}, false
+	}
+	first := word >> 16 & 31
+	second := word >> 5 & 31
+	switch op {
+	case "ZFMAD", "ZFMSB", "ZFNMAD", "ZFNMSB":
+		first, second = second, first
+	}
+	predicate := word >> 10 & 7
+	destination := word & 31
+	return Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", first, width))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", second, width))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", predicate))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", destination, width))},
+		},
+		Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_float_multiply_accumulate_test.go b/arm64_lower_word_sve_float_multiply_accumulate_test.go
new file mode 100644
index 000000000..6ebf60759
--- /dev/null
+++ b/arm64_lower_word_sve_float_multiply_accumulate_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEFloatMultiplyAccumulateCompleteGo127Encodings(t *testing.T) {
+	if len(arm64RawSVEFloatMultiplyAccumulateBases) != 8 {
+		t.Fatalf("want eight Go 1.27 predicated fused operations, got %d", len(arm64RawSVEFloatMultiplyAccumulateBases))
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEFused(SB),$0-0\n")
+	for base, op := range arm64RawSVEFloatMultiplyAccumulateBases {
+		for size, width := range []string{"", "H", "S", "D"} {
+			word := base | uint32(size)<<22 | 30<<16 | 7<<10 | 24<<5 | 8
+			decoded, ok := decodeARM64RawSVEFloatMultiplyAccumulate(word)
+			if (size == 0 && ok) || (size != 0 && (!ok || decoded.Op != op)) {
+				t.Fatalf("%s width %q word %#08x decoded as %+v, ok=%v", op, width, word, decoded, ok)
+			}
+			if size == 0 {
+				continue
+			}
+			wantFirst, wantSecond := "Z30."+width, "Z24."+width
+			switch op {
+			case "ZFMAD", "ZFMSB", "ZFNMAD", "ZFNMSB":
+				wantFirst, wantSecond = wantSecond, wantFirst
+			}
+			if string(decoded.Args[0].Reg) != wantFirst ||
+				string(decoded.Args[1].Reg) != wantSecond ||
+				string(decoded.Args[2].Reg) != "P7.M" ||
+				string(decoded.Args[3].Reg) != "Z8."+width {
+				t.Fatalf("%s word %#08x operands decoded as %+v", op, word, decoded.Args)
+			}
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEFused": {Name: "rawSVEFused", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-fused.ll", "arm64-raw-sve-fused.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_float_reciprocal_step.go b/arm64_lower_word_sve_float_reciprocal_step.go
new file mode 100644
index 000000000..f6c58a0cb
--- /dev/null
+++ b/arm64_lower_word_sve_float_reciprocal_step.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import "fmt"
+
+// Go 1.27's ZFRECPS and ZFRSQRTS rows each have one H/S/D three-vector
+// format. Normalize raw WORD encodings to the same typed lowering as the
+// corresponding named instruction.
+var arm64RawSVEFloatReciprocalStep = map[uint32]Op{
+	0x65001800: "ZFRECPS",
+	0x65001c00: "ZFRSQRTS",
+}
+
+func decodeARM64RawSVEFloatReciprocalStep(word uint32) (Instr, bool) {
+	op, ok := arm64RawSVEFloatReciprocalStep[word&0xff20fc00]
+	if !ok {
+		return Instr{}, false
+	}
+	size := word >> 22 & 3
+	if size == 0 {
+		return Instr{}, false
+	}
+	width := " HSD"[size]
+	args := []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>16&31, width))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))},
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
diff --git a/arm64_lower_word_sve_float_reciprocal_step_test.go b/arm64_lower_word_sve_float_reciprocal_step_test.go
new file mode 100644
index 000000000..ccc0f4b93
--- /dev/null
+++ b/arm64_lower_word_sve_float_reciprocal_step_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEFloatReciprocalStepDiscoveryWord(t *testing.T) {
+	const source = `TEXT rawreciprocalstep(SB),$0-0
+	WORD $0x65851c83 // frsqrts z3.s, z4.s, z5.s
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"rawreciprocalstep": {Name: "rawreciprocalstep", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, "@llvm.aarch64.sve.frsqrts.x.nxv4f32") {
+		t.Fatalf("raw FRSQRTS did not use the typed reciprocal-step lowering:\n%s", ll)
+	}
+}
+
+func TestTranslateARM64RawSVEFloatReciprocalStepCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawreciprocalsteps(SB),$0-0\n")
+	for _, base := range []uint32{0x65001800, 0x65001c00} {
+		for size := uint32(1); size <= 3; size++ {
+			word := base | size<<22 | 5<<16 | 4<<5 | 3
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawreciprocalsteps": {Name: "rawreciprocalsteps", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"@llvm.aarch64.sve.frecps.x.nxv8f16",
+				"@llvm.aarch64.sve.frecps.x.nxv4f32",
+				"@llvm.aarch64.sve.frecps.x.nxv2f64",
+				"@llvm.aarch64.sve.frsqrts.x.nxv8f16",
+				"@llvm.aarch64.sve.frsqrts.x.nxv4f32",
+				"@llvm.aarch64.sve.frsqrts.x.nxv2f64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("raw reciprocal-step family omitted %q", want)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-reciprocal-step.ll", "arm64-raw-reciprocal-step.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEFloatReciprocalStepRejectsOtherForms(t *testing.T) {
+	for _, word := range []uint32{
+		0x65001800, // Byte lanes are not floating-point lanes.
+		0x65001c00,
+		0x65005800, // Pair variant does not belong to the Go table.
+		0x65009c00, // Predicated variant does not belong to the Go table.
+	} {
+		if decoded, ok := decodeARM64RawSVEFloatReciprocalStep(word); ok {
+			t.Fatalf("out-of-table reciprocal-step WORD %#08x decoded as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_float_test.go b/arm64_lower_word_sve_float_test.go
new file mode 100644
index 000000000..71975f7f2
--- /dev/null
+++ b/arm64_lower_word_sve_float_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawSVEFloatForms = `TEXT svefloatwords(SB),$0-0
+	WORD $0x65800020 // FADD Z0.S, Z1.S, Z0.S
+	WORD $0x65850484 // FSUB Z4.S, Z4.S, Z5.S
+	WORD $0x65810821 // FMUL Z1.S, Z1.S, Z1.S
+	WORD $0x65808080 // FADD Z0.S, P0/M, Z0.S, Z4.S
+	WORD $0x65a400a3 // FMLA Z3.S, P0/M, Z5.S, Z4.S
+	WORD $0x65a48203 // FMAD Z3.S, P0/M, Z16.S, Z4.S
+	WORD $0x65802063 // FADDV S3, P0, Z3.S
+	WORD $0x65982020 // FADDA S0, P0, S0, Z1.S
+	WORD $0x65400020 // FADD Z0.H, Z1.H, Z0.H
+	WORD $0x65c50484 // FSUB Z4.D, Z4.D, Z5.D
+	WORD $0x65c10821 // FMUL Z1.D, Z1.D, Z1.D
+	WORD $0x65c18480 // FSUB Z0.D, P1/M, Z0.D, Z4.D
+	WORD $0x65428861 // FMUL Z1.H, P2/M, Z1.H, Z3.H
+	WORD $0x65e400a3 // FMLA Z3.D, P0/M, Z5.D, Z4.D
+	WORD $0x65c02463 // FADDV D3, P1, Z3.D
+	WORD $0x65d82820 // FADDA D0, P2, D0, Z1.D
+	RET
+`
+
+func TestTranslateARM64RawSVEFloatForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSVEFloatForms, true)
+	file, err := Parse(ArchARM64, arm64RawSVEFloatForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"svefloatwords": {Name: "svefloatwords", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-float.ll", "arm64-sve-float.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_integer_add_reduce.go b/arm64_lower_word_sve_integer_add_reduce.go
new file mode 100644
index 000000000..488065f34
--- /dev/null
+++ b/arm64_lower_word_sve_integer_add_reduce.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEIntegerAddReduction struct {
+	spec        arm64SVEAddReductionSpec
+	form        arm64SVEAddReductionForm
+	destination Reg
+}
+
+// SADDV and UADDV share the predicated integer-add reduction encoding.
+// Signed D is reserved; unsigned D is valid. The remaining variable fields
+// are the scalar destination, predicate, and scalable source registers.
+func decodeARM64RawSVEIntegerAddReduction(word uint32) (arm64RawSVEIntegerAddReduction, bool) {
+	if word&0xff3ee000 != 0x04002000 {
+		return arm64RawSVEIntegerAddReduction{}, false
+	}
+
+	size := int(word>>22) & 3
+	unsigned := word&(1<<16) != 0
+	if size == 3 && !unsigned {
+		return arm64RawSVEIntegerAddReduction{}, false
+	}
+
+	kind := arm64SVESignedAddReduce
+	if unsigned {
+		kind = arm64SVEUnsignedAddReduce
+	}
+	destination := int(word) & 31
+	return arm64RawSVEIntegerAddReduction{
+		spec: arm64SVEAddReductionSpec{kind: kind},
+		form: arm64SVEAddReductionForm{
+			elementBits: 8 << size,
+			source:      int(word>>5) & 31,
+			predicate:   int(word>>10) & 7,
+			destination: destination,
+		},
+		destination: Reg(fmt.Sprintf("V%d", destination)),
+	}, true
+}
diff --git a/arm64_lower_word_sve_integer_add_reduce_test.go b/arm64_lower_word_sve_integer_add_reduce_test.go
new file mode 100644
index 000000000..352fc31ee
--- /dev/null
+++ b/arm64_lower_word_sve_integer_add_reduce_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEIntegerAddReductionCompleteFamily(t *testing.T) {
+	forms := []struct {
+		name      string
+		word      uint32
+		intrinsic string
+		suffix    string
+	}{
+		{"SADDV B", 0x04002000, "saddv", "nxv16i8"},
+		{"SADDV H", 0x04402000, "saddv", "nxv8i16"},
+		{"SADDV S", 0x04802000, "saddv", "nxv4i32"},
+		{"UADDV B", 0x04012000, "uaddv", "nxv16i8"},
+		{"UADDV H", 0x04412000, "uaddv", "nxv8i16"},
+		{"UADDV S", 0x04812000, "uaddv", "nxv4i32"},
+		{"UADDV D", 0x04c12000, "uaddv", "nxv2i64"},
+	}
+
+	for _, form := range forms {
+		t.Run(form.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT sveIntegerAddRaw(SB),$0-0\n")
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", form.word, form.name)
+			source.WriteString("\tRET\n")
+			requireARM64SVEGoAssemblerResult(t, source.String(), true)
+
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin",
+				"aarch64-unknown-linux-gnu",
+				"aarch64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs: map[string]FuncSig{
+							"sveIntegerAddRaw": {Name: "sveIntegerAddRaw", Ret: Void},
+						},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{
+						"@llvm.aarch64.sve." + form.intrinsic + "." + form.suffix,
+						`"target-features"="+sve"`,
+					} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("omitted %q:\n%s", want, ir)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-integer-add-raw.ll", "arm64-sve-integer-add-raw.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEIntegerAddReductionRegistersAndBoundaries(t *testing.T) {
+	for _, base := range []uint32{
+		0x04002000, 0x04402000, 0x04802000,
+		0x04012000, 0x04412000, 0x04812000, 0x04c12000,
+	} {
+		word := base | 17 | 23<<5 | 5<<10
+		if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 || !arm64RawPoolSVEIgnoresAddress(word, 17) {
+			t.Fatalf("%#08x: scalar vector result was mistaken for a GP write", word)
+		}
+		reduction, ok := decodeARM64RawSVEIntegerAddReduction(word)
+		if !ok {
+			t.Fatalf("failed to decode %#08x", word)
+		}
+		if reduction.form.destination != 17 || reduction.form.source != 23 || reduction.form.predicate != 5 {
+			t.Fatalf("wrong register fields for %#08x: %+v", word, reduction.form)
+		}
+		if reduction.destination != "V17" {
+			t.Fatalf("wrong scalar destination for %#08x: %s", word, reduction.destination)
+		}
+	}
+
+	for _, word := range []uint32{
+		0x04c02000, // Signed D has no encoding.
+		0x04022000, // Adjacent opcode after UADDV.
+		0x04000000, // Reduction encoding requires bit 13.
+		0x0400a000, // Adjacent encoding with bit 15 set.
+	} {
+		if _, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_integer_dot.go b/arm64_lower_word_sve_integer_dot.go
new file mode 100644
index 000000000..3d4cb9172
--- /dev/null
+++ b/arm64_lower_word_sve_integer_dot.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEIntegerDotRow struct {
+	op      Op
+	width   int
+	indexed bool
+}
+
+var arm64RawSVEIntegerDotRows, arm64RawSVEIntegerDotBytePairRows = arm64SVEIntegerDotRawTables()
+
+func arm64SVEIntegerDotRawTables() (ordinary, bytePairs map[uint32]arm64RawSVEIntegerDotRow) {
+	ordinary = make(map[uint32]arm64RawSVEIntegerDotRow)
+	bytePairs = make(map[uint32]arm64RawSVEIntegerDotRow)
+	for op, spec := range arm64SVEIntegerDotSpecs {
+		for width, bases := range spec.rawBases {
+			for indexed, base := range bases {
+				if base == 0 {
+					continue
+				}
+				row := arm64RawSVEIntegerDotRow{op, width, indexed != 0}
+				if width == 0 && row.indexed {
+					bytePairs[base] = row
+				} else {
+					ordinary[base] = row
+				}
+			}
+		}
+	}
+	return
+}
+
+func decodeARM64RawSVEIntegerDot(word uint32) (Instr, bool) {
+	row, ok := arm64RawSVEIntegerDotRows[word&0xffe0fc00]
+	if !ok {
+		row, ok = arm64RawSVEIntegerDotBytePairRows[word&0xffa0fc00]
+		if !ok {
+			return Instr{}, false
+		}
+	}
+	widths := arm64SVEIntegerDotWidthForms[row.width]
+	first, index := word>>16&31, ""
+	if row.indexed {
+		first &= uint32(widths.maximumVector)
+		lane := word >> 19 & 3
+		if widths.destination == 16 {
+			lane |= word >> 20 & 4
+		} else if widths.destination == 64 {
+			lane = word >> 20 & 1
+		}
+		index = fmt.Sprintf("[%d]", lane)
+	}
+	sourceWidth, destinationWidth := "B", "S"
+	if widths.source == 16 {
+		sourceWidth = "H"
+	}
+	if widths.destination == 16 {
+		destinationWidth = "H"
+	} else if widths.destination == 64 {
+		destinationWidth = "D"
+	}
+	return Instr{Op: row.op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s%s", first, sourceWidth, index))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", word>>5&31, sourceWidth))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", word&31, destinationWidth))},
+	}}, true
+}
diff --git a/arm64_lower_word_sve_integer_minmax.go b/arm64_lower_word_sve_integer_minmax.go
new file mode 100644
index 000000000..2a6fb8e1b
--- /dev/null
+++ b/arm64_lower_word_sve_integer_minmax.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import "fmt"
+
+// SVE signed/unsigned min/max share four opcodes and four element widths.
+// Go 1.27 exposes both the predicated register and destructive immediate
+// forms; decode either into the same typed named-instruction lowerer.
+func decodeARM64RawSVEIntegerMinMax(word uint32) (Instr, bool) {
+	predicated := word&0xff30e000 == 0x04000000
+	immediate := word&0xff3ce000 == 0x2528c000
+	if !predicated && !immediate {
+		return Instr{}, false
+	}
+
+	var opcode int
+	if predicated {
+		opcode = int(word>>16) & 15
+		if opcode < 8 || opcode > 11 {
+			return Instr{}, false
+		}
+		opcode -= 8
+	} else {
+		opcode = int(word>>16) & 3
+	}
+	operations := [...]Op{"ZSMAX", "ZUMAX", "ZSMIN", "ZUMIN"}
+	op := operations[opcode]
+	arrangements := [...]string{"B", "H", "S", "D"}
+	width := int(word>>22) & 3
+	destination := Reg(fmt.Sprintf("Z%d.%s", word&31, arrangements[width]))
+
+	var args []Operand
+	if predicated {
+		second := Reg(fmt.Sprintf("Z%d.%s", word>>5&31, arrangements[width]))
+		predicate := Reg(fmt.Sprintf("P%d.M", word>>10&7))
+		args = []Operand{
+			{Kind: OpReg, Reg: second},
+			{Kind: OpReg, Reg: destination},
+			{Kind: OpReg, Reg: predicate},
+			{Kind: OpReg, Reg: destination},
+		}
+	} else {
+		value := int64(uint8(word >> 5))
+		if opcode == 0 || opcode == 2 {
+			value = int64(int8(word >> 5))
+		}
+		args = []Operand{
+			{Kind: OpImm, Imm: value},
+			{Kind: OpReg, Reg: destination},
+			{Kind: OpReg, Reg: destination},
+		}
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
diff --git a/arm64_lower_word_sve_integer_minmax_reduce.go b/arm64_lower_word_sve_integer_minmax_reduce.go
new file mode 100644
index 000000000..fa2c23888
--- /dev/null
+++ b/arm64_lower_word_sve_integer_minmax_reduce.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "fmt"
+
+// SVE's four predicated integer min/max reductions share one encoding
+// grammar. The opcode chooses signedness and min/max; size chooses B/H/S/D.
+func decodeARM64RawSVEIntegerMinMaxReduction(word uint32) (Instr, bool) {
+	if word&0xff30e000 != 0x04002000 {
+		return Instr{}, false
+	}
+	opcode := int(word>>16) & 15
+	if opcode < 8 || opcode > 11 {
+		return Instr{}, false
+	}
+	width := int(word>>22) & 3
+	operations := [...]string{"ZSMAXV", "ZUMAXV", "ZSMINV", "ZUMINV"}
+	arrangements := [...]string{"B", "H", "S", "D"}
+	op := Op(operations[opcode-8] + arrangements[width])
+	source := Reg(fmt.Sprintf("Z%d.%s", word>>5&31, arrangements[width]))
+	predicate := Reg(fmt.Sprintf("P%d", word>>10&7))
+	destination := Reg(fmt.Sprintf("V%d", word&31))
+	return Instr{
+		Op: op,
+		Args: []Operand{
+			{Kind: OpReg, Reg: source},
+			{Kind: OpReg, Reg: predicate},
+			{Kind: OpReg, Reg: destination},
+		},
+		Raw: fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_integer_minmax_reduce_test.go b/arm64_lower_word_sve_integer_minmax_reduce_test.go
new file mode 100644
index 000000000..cb8449ee9
--- /dev/null
+++ b/arm64_lower_word_sve_integer_minmax_reduce_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEIntegerMinMaxReductionCompleteFamily(t *testing.T) {
+	operations := []struct {
+		name      string
+		opcode    uint32
+		intrinsic string
+	}{
+		{"SMAXV", 8, "smaxv"},
+		{"UMAXV", 9, "umaxv"},
+		{"SMINV", 10, "sminv"},
+		{"UMINV", 11, "uminv"},
+	}
+	widths := []struct {
+		name   string
+		bits   uint32
+		suffix string
+	}{
+		{"B", 0, "nxv16i8"},
+		{"H", 1, "nxv8i16"},
+		{"S", 2, "nxv4i32"},
+		{"D", 3, "nxv2i64"},
+	}
+	for _, operation := range operations {
+		for _, width := range widths {
+			t.Run(operation.name+"/"+width.name, func(t *testing.T) {
+				word := uint32(0x04002000) | width.bits<<22 | operation.opcode<<16 | 1<<5
+				source := fmt.Sprintf("TEXT sveMinMaxReduceRaw(SB),$0-0\n\tWORD $%#08x\n\tRET\n", word)
+				requireARM64SVEGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range []string{
+					"aarch64-apple-darwin",
+					"aarch64-unknown-linux-gnu",
+					"aarch64-pc-windows-msvc",
+				} {
+					t.Run(triple, func(t *testing.T) {
+						ir, err := Translate(file, Options{
+							TargetTriple: triple,
+							Goarch:       "arm64",
+							Sigs: map[string]FuncSig{
+								"sveMinMaxReduceRaw": {Name: "sveMinMaxReduceRaw", Ret: Void},
+							},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, want := range []string{
+							"@llvm.aarch64.sve." + operation.intrinsic + "." + width.suffix,
+							`"target-features"="+sve"`,
+						} {
+							if !strings.Contains(ir, want) {
+								t.Fatalf("omitted %q:\n%s", want, ir)
+							}
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM 22 llc not found")
+						}
+						compileLLVMToObject(t, llc, triple, "arm64-sve-minmax-reduce-raw.ll", "arm64-sve-minmax-reduce-raw.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeARM64RawSVEIntegerMinMaxReductionRegistersAndBoundaries(t *testing.T) {
+	for _, opcode := range []uint32{8, 9, 10, 11} {
+		for size := uint32(0); size < 4; size++ {
+			word := uint32(0x04002000) | size<<22 | opcode<<16 | 23<<5 | 5<<10 | 17
+			decoded, ok := decodeARM64RawSVEIntegerMinMaxReduction(word)
+			if !ok || len(decoded.Args) != 3 {
+				t.Fatalf("failed to decode %#08x: %+v", word, decoded)
+			}
+			if !strings.HasPrefix(string(decoded.Args[0].Reg), "Z23.") || decoded.Args[1].Reg != "P5" || decoded.Args[2].Reg != "V17" {
+				t.Fatalf("wrong register fields for %#08x: %+v", word, decoded.Args)
+			}
+		}
+	}
+
+	for _, word := range []uint32{
+		0x04072000, // Before the reduction opcode range.
+		0x040c2000, // After the reduction opcode range.
+		0x04080000, // Predicated vector SMAX, not a reduction.
+	} {
+		if decoded, ok := decodeARM64RawSVEIntegerMinMaxReduction(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_integer_minmax_test.go b/arm64_lower_word_sve_integer_minmax_test.go
new file mode 100644
index 000000000..d9217d782
--- /dev/null
+++ b/arm64_lower_word_sve_integer_minmax_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEIntegerMinMaxCompleteDirectFamily(t *testing.T) {
+	operations := []struct {
+		name      string
+		opcode    uint32
+		intrinsic string
+		immediate int64
+	}{
+		{"SMAX", 0, "smax", -128},
+		{"UMAX", 1, "umax", 255},
+		{"SMIN", 2, "smin", 127},
+		{"UMIN", 3, "umin", 0},
+	}
+	widths := []struct {
+		name   string
+		bits   uint32
+		suffix string
+	}{
+		{"B", 0, "nxv16i8"},
+		{"H", 1, "nxv8i16"},
+		{"S", 2, "nxv4i32"},
+		{"D", 3, "nxv2i64"},
+	}
+	for _, operation := range operations {
+		for _, width := range widths {
+			for _, encoding := range []string{"predicated", "immediate"} {
+				t.Run(operation.name+"/"+width.name+"/"+encoding, func(t *testing.T) {
+					word := uint32(0x04080000) | width.bits<<22 | operation.opcode<<16 | 8<<5
+					if encoding == "immediate" {
+						word = uint32(0x2528c000) | width.bits<<22 | operation.opcode<<16 | uint32(uint8(operation.immediate))<<5
+					}
+					source := fmt.Sprintf("TEXT sveMinMaxRaw(SB),$0-0\n\tWORD $%#08x\n\tRET\n", word)
+					requireARM64SVEGoAssemblerResult(t, source, true)
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, triple := range []string{
+						"aarch64-apple-darwin",
+						"aarch64-unknown-linux-gnu",
+						"aarch64-pc-windows-msvc",
+					} {
+						t.Run(triple, func(t *testing.T) {
+							ir, err := Translate(file, Options{
+								TargetTriple: triple,
+								Goarch:       "arm64",
+								Sigs: map[string]FuncSig{
+									"sveMinMaxRaw": {Name: "sveMinMaxRaw", Ret: Void},
+								},
+							})
+							if err != nil {
+								t.Fatal(err)
+							}
+							for _, want := range []string{
+								"@llvm.aarch64.sve." + operation.intrinsic + "." + width.suffix,
+								`"target-features"="+sve"`,
+							} {
+								if !strings.Contains(ir, want) {
+									t.Fatalf("omitted %q:\n%s", want, ir)
+								}
+							}
+							llc := findLLVM22Tool("llc")
+							if llc == "" {
+								t.Fatal("LLVM 22 llc not found")
+							}
+							compileLLVMToObject(t, llc, triple, "arm64-sve-minmax-raw.ll", "arm64-sve-minmax-raw.o", ir)
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestDecodeARM64RawSVEIntegerMinMaxRegistersAndBoundaries(t *testing.T) {
+	predicated, ok := decodeARM64RawSVEIntegerMinMax(0x04ca0100)
+	if !ok || predicated.Op != "ZSMIN" || len(predicated.Args) != 4 ||
+		predicated.Args[0].Reg != "Z8.D" || predicated.Args[1].Reg != "Z0.D" ||
+		predicated.Args[2].Reg != "P0.M" || predicated.Args[3].Reg != "Z0.D" {
+		t.Fatalf("wrong predicated SMIN decode: %+v, %v", predicated, ok)
+	}
+
+	for _, test := range []struct {
+		word uint32
+		op   Op
+		imm  int64
+	}{
+		{0x2528d000, "ZSMAX", -128},
+		{0x252acfe0, "ZSMIN", 127},
+		{0x2529dfe0, "ZUMAX", 255},
+		{0x252bc000, "ZUMIN", 0},
+	} {
+		decoded, ok := decodeARM64RawSVEIntegerMinMax(test.word)
+		if !ok || decoded.Op != test.op || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != test.imm {
+			t.Fatalf("wrong immediate min/max decode for %#08x: %+v, %v", test.word, decoded, ok)
+		}
+	}
+
+	for _, word := range []uint32{
+		0x04070100, // Before the predicated opcode range.
+		0x040c0100, // After the predicated opcode range.
+		0x2528e000, // Different immediate instruction class.
+	} {
+		if decoded, ok := decodeARM64RawSVEIntegerMinMax(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_integer_unary.go b/arm64_lower_word_sve_integer_unary.go
new file mode 100644
index 000000000..4c0b05b06
--- /dev/null
+++ b/arm64_lower_word_sve_integer_unary.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "fmt"
+
+func decodeARM64RawSVEIntegerUnary(word uint32) (Instr, bool) {
+	for op, spec := range arm64SVEIntegerUnarySpecs {
+		variableFields := uint32(0x00c01fff) // size, Pg, Zn, Zd
+		if spec.unpred {
+			variableFields = 0x00c003ff // size, Zn, Zd
+		}
+		base, mode := word&^variableFields, "M"
+		if base != spec.rawMerge {
+			if spec.rawZero == 0 || base != spec.rawZero {
+				continue
+			}
+			mode = "Z"
+		}
+		bits := 8 << (word >> 22 & 3)
+		if bits < spec.minBits || spec.maxBits != 0 && bits > spec.maxBits {
+			return Instr{}, false
+		}
+		width := "BHSD"[word>>22&3]
+		args := []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))}}
+		if !spec.unpred {
+			args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.%s", word>>10&7, mode))})
+		}
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))})
+		return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+	}
+	return Instr{}, false
+}
diff --git a/arm64_lower_word_sve_integer_unary_test.go b/arm64_lower_word_sve_integer_unary_test.go
new file mode 100644
index 000000000..ccd178170
--- /dev/null
+++ b/arm64_lower_word_sve_integer_unary_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEIntegerUnaryGo127PredicatedFamily(t *testing.T) {
+	forms := []struct {
+		op       Op
+		merge    uint32
+		zero     uint32
+		minWidth int
+	}{
+		{"ZABS", 0x0416a000, 0x0406a000, 8},
+		{"ZCLS", 0x0418a000, 0x0408a000, 8},
+		{"ZCLZ", 0x0419a000, 0x0409a000, 8},
+		{"ZCNOT", 0x041ba000, 0x040ba000, 8},
+		{"ZCNT", 0x041aa000, 0x040aa000, 8},
+		{"ZNEG", 0x0417a000, 0x0407a000, 8},
+		{"ZNOT", 0x041ea000, 0x040ea000, 8},
+		{"ZSXTB", 0x0410a000, 0x0400a000, 16},
+		{"ZSXTH", 0x0412a000, 0x0402a000, 32},
+		{"ZSXTW", 0x0414a000, 0x0404a000, 64},
+		{"ZUXTB", 0x0411a000, 0x0401a000, 16},
+		{"ZUXTH", 0x0413a000, 0x0403a000, 32},
+		{"ZUXTW", 0x0415a000, 0x0405a000, 64},
+	}
+	widthNames := [...]string{"B", "H", "S", "D"}
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEIntegerUnary(SB),$0-0\n")
+	for _, form := range forms {
+		for size, width := range widthNames {
+			if 8<<size < form.minWidth {
+				continue
+			}
+			for _, mode := range []struct {
+				name string
+				base uint32
+			}{
+				{"M", form.merge},
+				{"Z", form.zero},
+			} {
+				word := mode.base | uint32(size)<<22 | 6<<5 | 3<<10 | 9
+				fmt.Fprintf(&source, "\t%s Z6.%s, P3.%s, Z9.%s\n", form.op, width, mode.name, width)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEIntegerUnary": {Name: "rawSVEIntegerUnary", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, "@llvm.aarch64.sve.cnt.nxv2i64") {
+				t.Fatalf("raw CNT was not lowered with typed SVE semantics:\n%s", ll)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-integer-unary.ll", "arm64-raw-sve-integer-unary.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEIntegerUnaryRejectsReservedWidths(t *testing.T) {
+	for _, word := range []uint32{
+		0x0410a000,         // SXTB requires H/S/D elements.
+		0x0452a000,         // SXTH requires S/D elements.
+		0x0494a000,         // SXTW requires D elements.
+		0x04daa0c6 ^ 1<<13, // Adjacent unmodelled instruction space.
+	} {
+		if _, ok := decodeARM64RawSVEIntegerUnary(word); ok {
+			t.Fatalf("accepted reserved or adjacent unary encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_ld1b.go b/arm64_lower_word_sve_ld1b.go
new file mode 100644
index 000000000..3208af752
--- /dev/null
+++ b/arm64_lower_word_sve_ld1b.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVELD1B struct {
+	elementBits int
+	predicate   int
+	base        int
+	index       int
+	vector      int
+}
+
+func decodeARM64RawSVELD1B(word uint32) (arm64RawSVELD1B, bool) {
+	if word&0xff80e000 != 0xa4004000 {
+		return arm64RawSVELD1B{}, false
+	}
+	return arm64RawSVELD1B{
+		elementBits: 8 << ((word >> 21) & 3),
+		predicate:   int((word >> 10) & 7),
+		base:        int((word >> 5) & 31),
+		index:       int((word >> 16) & 31),
+		vector:      int(word & 31),
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSVELD1B(form arm64RawSVELD1B) error {
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	_, lanes, err := arm64SVEVectorType(form.elementBits)
+	if err != nil {
+		return err
+	}
+	narrowPredicate := predicate
+	if form.elementBits != 8 {
+		narrowPredicate = c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x %d x i1> @llvm.aarch64.sve.convert.from.svbool.nxv%di1(<vscale x 16 x i1> %s)\n", narrowPredicate, lanes, lanes, predicate)
+		narrowPredicate = "%" + narrowPredicate
+	}
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		baseReg = SP
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	index := ZR
+	if form.index != 31 {
+		index = Reg(fmt.Sprintf("R%d", form.index))
+	}
+	indexValue, err := c.loadReg(index)
+	if err != nil {
+		return err
+	}
+	address := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", address, base, indexValue)
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %%%s to ptr\n", pointer, address)
+	loaded := c.newTmp()
+	vectorType := fmt.Sprintf("<vscale x %d x i8>", lanes)
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.masked.load.nxv%di8.p0(ptr align 1 %%%s, %s %s, %s zeroinitializer)\n", loaded, vectorType, lanes, pointer, predicateType, narrowPredicate, vectorType)
+	value := "%" + loaded
+	if form.elementBits != 8 {
+		widenedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, form.elementBits)
+		widened := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", widened, vectorType, value, widenedType)
+		value = "%" + widened
+	}
+	if form.elementBits != 8 {
+		bytes := c.newTmp()
+		widenedType := fmt.Sprintf("<vscale x %d x i%d>", lanes, form.elementBits)
+		fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 16 x i8>\n", bytes, widenedType, value)
+		value = "%" + bytes
+	}
+	return c.storeZReg(form.vector, value)
+}
diff --git a/arm64_lower_word_sve_ld1b_test.go b/arm64_lower_word_sve_ld1b_test.go
new file mode 100644
index 000000000..11584c787
--- /dev/null
+++ b/arm64_lower_word_sve_ld1b_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVELD1BRegisterOffsetForms(t *testing.T) {
+	const source = `TEXT ld1bwords(SB),$0-0
+	WORD $0xa4024400
+	WORD $0xa42b4000
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"ld1bwords": {Name: "ld1bwords", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	loads := 0
+	for _, line := range strings.Split(ll, "\n") {
+		if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.aarch64.sve.ld1.nxv") {
+			loads++
+		}
+	}
+	if loads != 2 {
+		t.Fatalf("raw LD1B lowering omitted predicated zeroing loads:\n%s", ll)
+	}
+	if !strings.Contains(ll, `zext <vscale x 8 x i8>`) {
+		t.Fatalf("raw LD1B H arrangement was not zero-extended:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-ld1b.ll", "arm64-ld1b.o", ll)
+}
diff --git a/arm64_lower_word_sve_ldr_str.go b/arm64_lower_word_sve_ldr_str.go
new file mode 100644
index 000000000..e1544d4e7
--- /dev/null
+++ b/arm64_lower_word_sve_ldr_str.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVELoadStore struct {
+	load      bool
+	predicate bool
+	immediate int
+	base      int
+	vector    int
+}
+
+// decodeARM64RawSVELoadStore covers the complete unpredicated SVE LDR/STR
+// scalar-base formats for Z and P registers. The signed imm9 is measured in
+// vector bytes for Z registers and predicate bytes (VL/8) for P registers.
+func decodeARM64RawSVELoadStore(word uint32) (arm64RawSVELoadStore, bool) {
+	form := arm64RawSVELoadStore{}
+	switch word & 0xffc0e000 {
+	case 0x85804000:
+		form.load = true
+	case 0xe5804000:
+		form.load = false
+	case 0x85800000, 0xe5800000:
+		if word&16 != 0 { // Pt is four bits, unlike Zt.
+			return arm64RawSVELoadStore{}, false
+		}
+		form.predicate = true
+		form.load = word&(1<<30) == 0
+	default:
+		return arm64RawSVELoadStore{}, false
+	}
+	imm9 := int(word>>16&0x3f)<<3 | int(word>>10&7)
+	if imm9&0x100 != 0 {
+		imm9 -= 0x200
+	}
+	form.immediate = imm9
+	form.base = int(word>>5) & 31
+	form.vector = int(word) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSVELoadStore(form arm64RawSVELoadStore) error {
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		baseReg = Reg("RSP")
+	}
+	prefix, operation := "Z", "STR"
+	if form.predicate {
+		prefix = "P"
+	}
+	if form.load {
+		operation = "LDR"
+	}
+	register := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("%s%d", prefix, form.vector))}
+	displacement := fmt.Sprintf("VL*%d", form.immediate)
+	if form.immediate < 0 {
+		displacement = fmt.Sprintf("-VL*%d", -form.immediate)
+	}
+	memory := Operand{Kind: OpMem, Mem: MemRef{Base: baseReg, OffRaw: displacement}}
+	args := []Operand{register, memory}
+	if form.load {
+		args = []Operand{memory, register}
+	}
+	ins := Instr{Op: Op(prefix + operation), Args: args}
+	if form.predicate {
+		_, _, err := c.lowerARM64SVEPredicateLoadStore(ins.Op, ins)
+		return err
+	}
+	_, _, err := c.lowerARM64SVEWholeVectorMemory(ins.Op, ins)
+	return err
+}
diff --git a/arm64_lower_word_sve_ldr_str_test.go b/arm64_lower_word_sve_ldr_str_test.go
new file mode 100644
index 000000000..480e2c00d
--- /dev/null
+++ b/arm64_lower_word_sve_ldr_str_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVELoadStore(load bool, immediate, base, vector int) uint32 {
+	word := uint32(0xe5804000)
+	if load {
+		word = 0x85804000
+	}
+	imm9 := uint32(immediate) & 0x1ff
+	return word | (imm9>>3)<<16 | (imm9&7)<<10 | uint32(base)<<5 | uint32(vector)
+}
+
+func TestTranslateARM64RawSVELoadStoreCompleteFormat(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT sveLoadStoreRaw(SB), $0-0\n")
+	for _, form := range []struct {
+		load                    bool
+		immediate, base, vector int
+	}{{true, -256, 0, 0}, {true, 255, 31, 31}, {false, -256, 0, 0}, {false, 255, 31, 31}} {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawSVELoadStore(form.load, form.immediate, form.base, form.vector))
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"sveLoadStoreRaw": {Name: "sveLoadStoreRaw", Ret: Void}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, want := range []string{"load <vscale x 16 x i8>", "store <vscale x 16 x i8>", "call i64 @llvm.vscale.i64()", `"target-features"="+sve"`} {
+			if !strings.Contains(ir, want) {
+				t.Fatalf("%s SVE LDR/STR IR omitted %q:\n%s", triple, want, ir)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-sve-ldr-str.ll", "arm64-sve-ldr-str.o", ir)
+	}
+}
+
+func TestARM64RawSVELoadStoreDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, load := range []bool{false, true} {
+		for immediate := -256; immediate <= 255; immediate++ {
+			for base := 0; base < 32; base++ {
+				for vector := 0; vector < 32; vector++ {
+					word := encodeARM64RawSVELoadStore(load, immediate, base, vector)
+					got, ok := decodeARM64RawSVELoadStore(word)
+					if !ok || got.load != load || got.immediate != immediate || got.base != base || got.vector != vector {
+						t.Fatalf("decoded SVE LDR/STR %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 2*512*32*32 {
+		t.Fatalf("covered %d SVE LDR/STR encodings", count)
+	}
+}
+
+func TestARM64RawSVELoadStoreDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x85404000, 0xe5404000, 0x85806000} {
+		if _, ok := decodeARM64RawSVELoadStore(word); ok {
+			t.Fatalf("SVE LDR/STR decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_ldst1d.go b/arm64_lower_word_sve_ldst1d.go
new file mode 100644
index 000000000..808e972a9
--- /dev/null
+++ b/arm64_lower_word_sve_ldst1d.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVELDST1D struct {
+	load           bool
+	immediate      int
+	registerOffset bool
+	index          int
+	predicate      int
+	base           int
+	vector         int
+}
+
+// decodeARM64RawSVELDST1D recognizes the SVE contiguous, scalar-base,
+// signed-imm4 MUL VL forms of LD1D and ST1D. Other SVE addressing classes are
+// deliberately left for their own decoders so an adjacent encoding cannot be
+// silently assigned the wrong semantics.
+func decodeARM64RawSVELDST1D(word uint32) (arm64RawSVELDST1D, bool) {
+	form := arm64RawSVELDST1D{}
+	switch word & 0xffe0e000 {
+	case 0xa5e04000:
+		form.load = true
+		form.registerOffset = true
+	case 0xe5e04000:
+		form.registerOffset = true
+	}
+	if form.registerOffset {
+		form.index = int(word>>16) & 31
+		form.predicate = int(word>>10) & 7
+		form.base = int(word>>5) & 31
+		form.vector = int(word) & 31
+		return form, true
+	}
+	switch word & 0xfff0e000 {
+	case 0xa5e0a000:
+		form.load = true
+	case 0xe5e0e000:
+		form.load = false
+	default:
+		return arm64RawSVELDST1D{}, false
+	}
+	immediate := int(word>>16) & 15
+	if immediate&8 != 0 {
+		immediate -= 16
+	}
+	form.immediate = immediate
+	form.predicate = int(word>>10) & 7
+	form.base = int(word>>5) & 31
+	form.vector = int(word) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSVELDST1D(form arm64RawSVELDST1D) error {
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	narrowPredicate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 2 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv2i1(<vscale x 16 x i1> %s)\n", narrowPredicate, predicate)
+
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		baseReg = SP
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	address := base
+	if form.registerOffset {
+		indexReg := ZR
+		if form.index != 31 {
+			indexReg = Reg(fmt.Sprintf("R%d", form.index))
+		}
+		index, err := c.loadReg(indexReg)
+		if err != nil {
+			return err
+		}
+		scaled := c.newTmp()
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 3\n", scaled, index)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", adjusted, base, scaled)
+		address = "%" + adjusted
+	} else if form.immediate != 0 {
+		vscale := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.vscale.i64()\n", vscale)
+		offset := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", offset, vscale, form.immediate*16)
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", adjusted, base, offset)
+		address = "%" + adjusted
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+
+	if form.load {
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 2 x i64> @llvm.masked.load.nxv2i64.p0(ptr align 1 %%%s, <vscale x 2 x i1> %%%s, <vscale x 2 x i64> zeroinitializer)\n", loaded, pointer, narrowPredicate)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 2 x i64> %%%s to <vscale x 16 x i8>\n", bytes, loaded)
+		return c.storeZReg(form.vector, "%"+bytes)
+	}
+
+	bytes, err := c.loadZReg(form.vector)
+	if err != nil {
+		return err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 16 x i8> %s to <vscale x 2 x i64>\n", value, bytes)
+	fmt.Fprintf(c.b, "  call void @llvm.masked.store.nxv2i64.p0(<vscale x 2 x i64> %%%s, ptr align 1 %%%s, <vscale x 2 x i1> %%%s)\n", value, pointer, narrowPredicate)
+	return nil
+}
diff --git a/arm64_lower_word_sve_ldst1d_test.go b/arm64_lower_word_sve_ldst1d_test.go
new file mode 100644
index 000000000..a0339d290
--- /dev/null
+++ b/arm64_lower_word_sve_ldst1d_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARM64RawSVELDST1D(load bool, immediate, predicate, base, vector int) uint32 {
+	opcode := uint32(0xe5e0e000)
+	if load {
+		opcode = 0xa5e0a000
+	}
+	return opcode | uint32(immediate&15)<<16 | uint32(predicate)<<10 | uint32(base)<<5 | uint32(vector)
+}
+
+func TestTranslateARM64RawSVELDST1DScalarImmediateCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawldst1dforms(SB),$0-0\n")
+	for _, load := range []bool{true, false} {
+		for immediate := -8; immediate <= 7; immediate++ {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawSVELDST1D(load, immediate, (immediate+8)%8, 2, 3))
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawldst1dforms": {Name: "rawldst1dforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.convert.from.svbool.nxv2i1",
+				"call <vscale x 2 x i64> @llvm.aarch64.sve.ld1.nxv2i64",
+				"@llvm.masked.store.nxv2i64.p0", "call i64 @llvm.vscale.i64()",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SVE LD1D/ST1D lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-ldst1d.ll", "arm64-raw-sve-ldst1d.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSVELDST1DDecoderCoversAllEncodingFields(t *testing.T) {
+	for _, load := range []bool{true, false} {
+		for immediate := -8; immediate <= 7; immediate++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for base := 0; base < 32; base++ {
+					for vector := 0; vector < 32; vector++ {
+						word := encodeARM64RawSVELDST1D(load, immediate, predicate, base, vector)
+						got, ok := decodeARM64RawSVELDST1D(word)
+						if !ok || got.load != load || got.immediate != immediate || got.predicate != predicate || got.base != base || got.vector != vector {
+							t.Fatalf("decoded SVE LD1D/ST1D word %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawSVELDST1DDecoderRejectsAdjacentAddressingClasses(t *testing.T) {
+	for _, word := range []uint32{0xa5a04000, 0xc5e0c000, 0xe5a0c000} {
+		if _, ok := decodeARM64RawSVELDST1D(word); ok {
+			t.Fatalf("SVE LD1D/ST1D decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
+
+func encodeARM64RawSVELDST1DScalarRegister(load bool, index, predicate, base, vector int) uint32 {
+	opcode := uint32(0xe5e04000)
+	if load {
+		opcode = 0xa5e04000
+	}
+	return opcode | uint32(index)<<16 | uint32(predicate)<<10 | uint32(base)<<5 | uint32(vector)
+}
+
+func TestTranslateARM64RawSVELDST1DScalarRegisterCompleteFormat(t *testing.T) {
+	const source = `TEXT rawldst1dregister(SB),$0-0
+	WORD $0xa5ef40c1 // ld1d {z1.d}, p0/z, [x6,x15,lsl#3]
+	WORD $0xe5ef40c0 // st1d {z0.d}, p0, [x6,x15,lsl#3]
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: map[string]FuncSig{"rawldst1dregister": {Name: "rawldst1dregister", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"shl i64", "call <vscale x 2 x i64> @llvm.aarch64.sve.ld1.nxv2i64", "@llvm.masked.store.nxv2i64.p0", `"target-features"="+sve"`} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw SVE register-offset LD1D/ST1D lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-ldst1d-register.ll", "arm64-raw-sve-ldst1d-register.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSVELDST1DScalarRegisterDecoderCoversAllFields(t *testing.T) {
+	for _, load := range []bool{false, true} {
+		for index := 0; index < 32; index++ {
+			for predicate := 0; predicate < 8; predicate++ {
+				for base := 0; base < 32; base++ {
+					for vector := 0; vector < 32; vector++ {
+						word := encodeARM64RawSVELDST1DScalarRegister(load, index, predicate, base, vector)
+						got, ok := decodeARM64RawSVELDST1D(word)
+						if !ok || got.load != load || !got.registerOffset || got.index != index || got.predicate != predicate || got.base != base || got.vector != vector {
+							t.Fatalf("decoded register-offset SVE LD1D/ST1D %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_ldst1h_test.go b/arm64_lower_word_sve_ldst1h_test.go
new file mode 100644
index 000000000..ba5b3c3bf
--- /dev/null
+++ b/arm64_lower_word_sve_ldst1h_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEContiguousHalfwordMemoryCompleteFamily(t *testing.T) {
+	forms := []struct {
+		name      string
+		word      uint32
+		intrinsic string
+	}{
+		{"LD1H H immediate", 0xa4a0a000, "ld1.nxv8i16"},
+		{"LD1H S immediate", 0xa4c0a000, "ld1.nxv4i16"},
+		{"LD1H D immediate", 0xa4e0a000, "ld1.nxv2i16"},
+		{"LD1H H register", 0xa4a14000, "ld1.nxv8i16"},
+		{"LD1H S register", 0xa4c14000, "ld1.nxv4i16"},
+		{"LD1H D register", 0xa4e14000, "ld1.nxv2i16"},
+		{"ST1H H immediate", 0xe4a0e000, "st1.nxv8i16"},
+		{"ST1H S immediate", 0xe4c0e000, "st1.nxv4i16"},
+		{"ST1H D immediate", 0xe4e0e000, "st1.nxv2i16"},
+		{"ST1H H register", 0xe4a14000, "st1.nxv8i16"},
+		{"ST1H S register", 0xe4c14000, "st1.nxv4i16"},
+		{"ST1H D register", 0xe4e14000, "st1.nxv2i16"},
+	}
+
+	for _, form := range forms {
+		t.Run(form.name, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT sveHalfwordRaw(SB),$0-0\n")
+			fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", form.word, form.name)
+			source.WriteString("\tRET\n")
+			requireARM64SVEGoAssemblerResult(t, source.String(), true)
+
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin",
+				"aarch64-unknown-linux-gnu",
+				"aarch64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs: map[string]FuncSig{
+							"sveHalfwordRaw": {Name: "sveHalfwordRaw", Ret: Void},
+						},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{
+						"@llvm.aarch64.sve." + form.intrinsic,
+						`"target-features"="+sve"`,
+					} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("omitted %q:\n%s", want, ir)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-halfword-raw.ll", "arm64-sve-halfword-raw.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEContiguousHalfwordMemoryBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word      uint32
+		op        Op
+		base      Reg
+		index     Reg
+		scale     int64
+		offsetRaw string
+		vector    Reg
+	}{
+		{0xa4a0a008, "ZLD1H", "R0", "", 0, "", "Z8.H"},
+		{0xa4a8a008, "ZLD1H", "R0", "", 0, "-VL*8", "Z8.H"},
+		{0xa4a7a008, "ZLD1H", "R0", "", 0, "VL*7", "Z8.H"},
+		{0xa4a14008, "ZLD1H", "R0", "R1", 2, "", "Z8.H"},
+		{0xe4e14008, "ZST1H", "R0", "R1", 2, "", "Z8.D"},
+	} {
+		ins, ok := decodeARM64RawSVEContiguousMemory(test.word)
+		if !ok || ins.Op != test.op || len(ins.Args) != 3 {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, ins, ok)
+		}
+		memoryIndex, vectorIndex := 0, 2
+		if test.op == "ZST1H" {
+			memoryIndex, vectorIndex = 2, 0
+		}
+		memory := ins.Args[memoryIndex].Mem
+		if memory.Base != test.base || memory.Index != test.index || memory.Scale != test.scale || memory.OffRaw != test.offsetRaw {
+			t.Errorf("%#08x memory = %+v", test.word, memory)
+		}
+		if ins.Args[vectorIndex].Kind != OpRegList || ins.Args[vectorIndex].RegList[0] != test.vector {
+			t.Errorf("%#08x vector = %+v", test.word, ins.Args[vectorIndex])
+		}
+	}
+
+	for _, word := range []uint32{
+		0xa480a000, // This is LD1SW, not LD1H.
+		0xe480e000, // No byte-width ST1H variant.
+		0xa4a0a000 | 1<<14,
+	} {
+		if ins, ok := decodeARM64RawSVEContiguousMemory(word); ok {
+			t.Fatalf("decoded unrelated encoding %#08x as %+v", word, ins)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_ldst1w.go b/arm64_lower_word_sve_ldst1w.go
new file mode 100644
index 000000000..5b2a71c84
--- /dev/null
+++ b/arm64_lower_word_sve_ldst1w.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVELDST1W struct {
+	load           bool
+	immediate      int
+	registerOffset bool
+	index          int
+	predicate      int
+	base           int
+	vector         int
+}
+
+// decodeARM64RawSVELDST1W covers the SVE LD1W/ST1W scalar-base forms used by
+// generated Go assembly: predicated zero/merge load-store with either a
+// signed MUL VL immediate or a scalar register offset scaled by four bytes.
+func decodeARM64RawSVELDST1W(word uint32) (arm64RawSVELDST1W, bool) {
+	form := arm64RawSVELDST1W{}
+	switch word & 0xffe0e000 {
+	case 0xa5404000:
+		form.load = true
+		form.registerOffset = true
+	case 0xe5404000:
+		form.registerOffset = true
+	case 0xa540a000:
+		form.load = true
+	case 0xe540e000:
+	default:
+		return arm64RawSVELDST1W{}, false
+	}
+	form.predicate = int(word>>10) & 7
+	form.base = int(word>>5) & 31
+	form.vector = int(word) & 31
+	if form.registerOffset {
+		form.index = int(word>>16) & 31
+		return form, true
+	}
+	form.immediate = int(word>>16) & 15
+	if form.immediate&8 != 0 {
+		form.immediate -= 16
+	}
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawSVELDST1W(form arm64RawSVELDST1W) error {
+	predicate, err := c.loadPReg(form.predicate)
+	if err != nil {
+		return err
+	}
+	narrowPredicate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv4i1(<vscale x 16 x i1> %s)\n", narrowPredicate, predicate)
+
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	if form.base == 31 {
+		baseReg = SP
+	}
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	address := base
+	if form.registerOffset {
+		indexReg := ZR
+		if form.index != 31 {
+			indexReg = Reg(fmt.Sprintf("R%d", form.index))
+		}
+		index, err := c.loadReg(indexReg)
+		if err != nil {
+			return err
+		}
+		scaled := c.newTmp()
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 2\n", scaled, index)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", adjusted, base, scaled)
+		address = "%" + adjusted
+	} else if form.immediate != 0 {
+		vscale := c.newTmp()
+		offset := c.newTmp()
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i64 @llvm.vscale.i64()\n", vscale)
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %d\n", offset, vscale, form.immediate*16)
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", adjusted, base, offset)
+		address = "%" + adjusted
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n", pointer, address)
+	if form.load {
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 4 x i32> @llvm.masked.load.nxv4i32.p0(ptr align 1 %%%s, <vscale x 4 x i1> %%%s, <vscale x 4 x i32> zeroinitializer)\n", loaded, pointer, narrowPredicate)
+		bytes := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 4 x i32> %%%s to <vscale x 16 x i8>\n", bytes, loaded)
+		return c.storeZReg(form.vector, "%"+bytes)
+	}
+	bytes, err := c.loadZReg(form.vector)
+	if err != nil {
+		return err
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 16 x i8> %s to <vscale x 4 x i32>\n", value, bytes)
+	fmt.Fprintf(c.b, "  call void @llvm.masked.store.nxv4i32.p0(<vscale x 4 x i32> %%%s, ptr align 1 %%%s, <vscale x 4 x i1> %%%s)\n", value, pointer, narrowPredicate)
+	return nil
+}
diff --git a/arm64_lower_word_sve_ldst1w_test.go b/arm64_lower_word_sve_ldst1w_test.go
new file mode 100644
index 000000000..681d60d4b
--- /dev/null
+++ b/arm64_lower_word_sve_ldst1w_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawSVELDST1WForms = `TEXT sveldst1wwords(SB),$0-0
+	WORD $0xa54b4003 // LD1W {Z3.S}, P0/Z, [X0, X11, LSL #2]
+	WORD $0xa540a003 // LD1W {Z3.S}, P0/Z, [X0, #0, MUL VL]
+	WORD $0xe54b4003 // ST1W {Z3.S}, P0, [X0, X11, LSL #2]
+	WORD $0xe540e003 // ST1W {Z3.S}, P0, [X0, #0, MUL VL]
+	RET
+`
+
+func TestTranslateARM64RawSVELDST1WForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawSVELDST1WForms, true)
+	file, err := Parse(ArchARM64, arm64RawSVELDST1WForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"sveldst1wwords": {Name: "sveldst1wwords", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-sve-ldst1w.ll", "arm64-sve-ldst1w.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_multiply_accumulate.go b/arm64_lower_word_sve_multiply_accumulate.go
new file mode 100644
index 000000000..2e4d9db70
--- /dev/null
+++ b/arm64_lower_word_sve_multiply_accumulate.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEMultiplyAccumulateRow struct {
+	op   Op
+	size uint32
+}
+
+var arm64RawSVEMultiplyAccumulatePredicatedOps, arm64RawSVEMultiplyAccumulateIndexedRows = arm64SVEMultiplyAccumulateRawTables()
+
+func arm64SVEMultiplyAccumulateRawTables() (map[uint32]Op, map[uint32]arm64RawSVEMultiplyAccumulateRow) {
+	predicated := make(map[uint32]Op)
+	indexed := make(map[uint32]arm64RawSVEMultiplyAccumulateRow)
+	for op, spec := range arm64SVEMultiplyAccumulateSpecs {
+		predicated[spec.predicatedRaw] = op
+		for size, base := range spec.indexedRaw {
+			if base == 0 {
+				continue
+			}
+			indexed[base] = arm64RawSVEMultiplyAccumulateRow{op, uint32(size + 1)}
+		}
+	}
+	return predicated, indexed
+}
+
+func decodeARM64RawSVEMultiplyAccumulate(word uint32) (Instr, bool) {
+	op, predicated := arm64RawSVEMultiplyAccumulatePredicatedOps[word&0xff20e000]
+	size, multiplier, lane := word>>22&3, word>>16&31, ""
+	if !predicated {
+		// Halfword lane[2] replaces size[0]; word and doubleword retain
+		// their fixed size bits. Never let those forms alias the H decoder.
+		row, ok := arm64RawSVEMultiplyAccumulateIndexedRows[word&0xffe0fc00]
+		if !ok {
+			row, ok = arm64RawSVEMultiplyAccumulateIndexedRows[word&0xffa0fc00]
+			if !ok || row.size != 1 {
+				return Instr{}, false
+			}
+		}
+		op, size = row.op, row.size
+		index := word >> 19 & 3
+		multiplier &= 7
+		if size == 1 {
+			index |= word >> 20 & 4
+		} else if size == 3 {
+			multiplier = word >> 16 & 15
+			index = word >> 20 & 1
+		}
+		lane = fmt.Sprintf("[%d]", index)
+	}
+	width := "BHSD"[size]
+	args := []Operand{
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c%s", multiplier, width, lane))},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word>>5&31, width))},
+	}
+	if arm64SVEMultiplyAccumulateSpecs[op].destructiveProduct {
+		// MAD/MSB encode the addend in bits 9:5, unlike MLA/MLS's
+		// multiplicand. Normalize both encodings to Go's operand order.
+		args[0], args[1] = args[1], args[0]
+	}
+	if predicated {
+		args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", word>>10&7))})
+	}
+	args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", word&31, width))})
+	return Instr{Op: op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: args}, true
+}
diff --git a/arm64_lower_word_sve_ptest.go b/arm64_lower_word_sve_ptest.go
new file mode 100644
index 000000000..5ba920c06
--- /dev/null
+++ b/arm64_lower_word_sve_ptest.go
@@ -0,0 +1,18 @@
+package plan9asm
+
+import "fmt"
+
+// PTEST has one byte-granularity form; both predicate numbers are four-bit
+// fields. Route the raw encoding through the named flag-producing lowerer.
+func decodeARM64RawSVEPTest(word uint32) (Instr, bool) {
+	if word&0xffffc21f != 0x2550c000 {
+		return Instr{}, false
+	}
+	tested := Reg(fmt.Sprintf("P%d.B", word>>5&15))
+	governing := Reg(fmt.Sprintf("P%d", word>>10&15))
+	return Instr{
+		Op:   "PPTEST",
+		Args: []Operand{{Kind: OpReg, Reg: tested}, {Kind: OpReg, Reg: governing}},
+		Raw:  fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_ptest_test.go b/arm64_lower_word_sve_ptest_test.go
new file mode 100644
index 000000000..6494bc0f5
--- /dev/null
+++ b/arm64_lower_word_sve_ptest_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEPTestCompleteForm(t *testing.T) {
+	for _, registers := range []struct {
+		governing uint32
+		tested    uint32
+	}{
+		{0, 1},
+		{5, 7},
+		{15, 14},
+	} {
+		word := uint32(0x2550c000) | registers.governing<<10 | registers.tested<<5
+		t.Run(fmt.Sprintf("P%d_P%d", registers.governing, registers.tested), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT svePTestRaw(SB),$0-0\n\tWORD $%#08x\n\tRET\n", word)
+			requireARM64SVEGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin",
+				"aarch64-unknown-linux-gnu",
+				"aarch64-pc-windows-msvc",
+			} {
+				t.Run(triple, func(t *testing.T) {
+					ir, err := Translate(file, Options{
+						TargetTriple: triple,
+						Goarch:       "arm64",
+						Sigs: map[string]FuncSig{
+							"svePTestRaw": {Name: "svePTestRaw", Ret: Void},
+						},
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, want := range []string{
+						"@llvm.aarch64.sve.ptest.any.nxv16i1",
+						"@llvm.aarch64.sve.ptest.first.nxv16i1",
+						"@llvm.aarch64.sve.ptest.last.nxv16i1",
+						`"target-features"="+sve"`,
+					} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("omitted %q:\n%s", want, ir)
+						}
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, triple, "arm64-sve-ptest-raw.ll", "arm64-sve-ptest-raw.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEPTestPredicateFieldsAndBoundaries(t *testing.T) {
+	for governing := uint32(0); governing < 16; governing++ {
+		for tested := uint32(0); tested < 16; tested++ {
+			word := uint32(0x2550c000) | governing<<10 | tested<<5
+			decoded, ok := decodeARM64RawSVEPTest(word)
+			if !ok || decoded.Op != "PPTEST" || len(decoded.Args) != 2 {
+				t.Fatalf("failed to decode %#08x: %+v", word, decoded)
+			}
+			if decoded.Args[0].Reg != Reg(fmt.Sprintf("P%d.B", tested)) || decoded.Args[1].Reg != Reg(fmt.Sprintf("P%d", governing)) {
+				t.Fatalf("wrong predicate fields for %#08x: %+v", word, decoded.Args)
+			}
+		}
+	}
+	for _, word := range []uint32{
+		0x2550c001, // Reserved low bit.
+		0x2550c200, // Reserved bit between predicate fields.
+		0x25508000, // Adjacent instruction class.
+	} {
+		if decoded, ok := decodeARM64RawSVEPTest(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_ptrue.go b/arm64_lower_word_sve_ptrue.go
new file mode 100644
index 000000000..58d845b8c
--- /dev/null
+++ b/arm64_lower_word_sve_ptrue.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEPTrue struct {
+	elementBits int
+	pattern     int
+	destination int
+}
+
+func decodeARM64RawSVEPTrue(word uint32) (arm64RawSVEPTrue, bool) {
+	if word&0xff3ffc10 != 0x2518e000 {
+		return arm64RawSVEPTrue{}, false
+	}
+	pattern := int(word>>5) & 31
+	// Unknown pattern encodings architecturally produce an empty predicate;
+	// they are not undefined instructions (Arm PTRUE / DecodePredCount).
+	return arm64RawSVEPTrue{
+		elementBits: 8 << (int(word>>22) & 3),
+		pattern:     pattern,
+		destination: int(word) & 15,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawSVEPTrue(form arm64RawSVEPTrue) error {
+	lanes := 128 / form.elementBits
+	predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+	predicate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ptrue.nxv%di1(i32 %d)\n", predicate, predicateType, lanes, form.pattern)
+	value := "%" + predicate
+	if form.elementBits != 8 {
+		converted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.convert.to.svbool.nxv%di1(%s %s)\n",
+			converted, lanes, predicateType, value)
+		value = "%" + converted
+	}
+	return c.storePReg(form.destination, value)
+}
diff --git a/arm64_lower_word_sve_ptrue_test.go b/arm64_lower_word_sve_ptrue_test.go
new file mode 100644
index 000000000..369a14943
--- /dev/null
+++ b/arm64_lower_word_sve_ptrue_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVEPTruePatterns = []int{
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+}
+
+func encodeARM64RawSVEPTrue(elementBits, pattern, destination int) uint32 {
+	size := map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]
+	return 0x2518e000 | size<<22 | uint32(pattern)<<5 | uint32(destination)
+}
+
+func TestTranslateARM64RawSVEPTrueCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawptrueforms(SB),$0-0\n")
+	destination := 0
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, pattern := range arm64SVEPTruePatterns {
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", encodeARM64RawSVEPTrue(elementBits, pattern, destination%16))
+			destination++
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"rawptrueforms": {Name: "rawptrueforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`"target-features"="+sve"`,
+				"@llvm.aarch64.sve.ptrue.nxv16i1", "@llvm.aarch64.sve.ptrue.nxv8i1",
+				"@llvm.aarch64.sve.ptrue.nxv4i1", "@llvm.aarch64.sve.ptrue.nxv2i1",
+				"@llvm.aarch64.sve.convert.to.svbool.nxv2i1",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw PTRUE lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-ptrue.ll", "arm64-raw-sve-ptrue.o", ll)
+		})
+	}
+}
+
+func TestARM64RawSVEPTrueDecoderCoversArchitecturalDomain(t *testing.T) {
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, pattern := range arm64SVEPTruePatterns {
+			for destination := 0; destination < 16; destination++ {
+				word := encodeARM64RawSVEPTrue(elementBits, pattern, destination)
+				got, ok := decodeARM64RawSVEPTrue(word)
+				if !ok || got.elementBits != elementBits || got.pattern != pattern || got.destination != destination {
+					t.Fatalf("decoded PTRUE word %#08x as %+v, ok=%v", word, got, ok)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawSVEPTrueDecoderRejectsReservedAndAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2518e010, // PTRUES, which also updates flags.
+		0x2519e000, // Neighboring opcode, not a pattern field.
+		0x2518e400, // PFALSE.
+	} {
+		if _, ok := decodeARM64RawSVEPTrue(word); ok {
+			t.Fatalf("PTRUE decoder accepted reserved/adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_shift_test.go b/arm64_lower_word_sve_shift_test.go
new file mode 100644
index 000000000..4d2466c32
--- /dev/null
+++ b/arm64_lower_word_sve_shift_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEShiftCompleteGo127EncodingFamilies(t *testing.T) {
+	forms := []struct {
+		bases map[uint32]Op
+		mode  arm64SVELSRMode
+	}{
+		{arm64SVEShiftWidePredicatedBases, arm64SVELSRWidePredicated},
+		{arm64SVEShiftWideUnpredicatedBases, arm64SVELSRWideUnpredicated},
+		{arm64SVEShiftVectorPredicatedBases, arm64SVELSRVectorPredicated},
+		{arm64SVEShiftImmediatePredicatedBases, arm64SVELSRImmediatePredicated},
+		{arm64SVEShiftImmediateUnpredicatedBases, arm64SVELSRImmediateUnpredicated},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawSVEShiftForms(SB),$0-0\n")
+	for _, grammar := range forms {
+		if len(grammar.bases) != 3 {
+			t.Fatalf("SVE shift mode %d has %d operations, want ASR/LSL/LSR", grammar.mode, len(grammar.bases))
+		}
+		for base, op := range grammar.bases {
+			for _, width := range []int{8, 16, 32, 64} {
+				if (grammar.mode == arm64SVELSRWidePredicated || grammar.mode == arm64SVELSRWideUnpredicated) && width == 64 {
+					continue
+				}
+				word := base
+				if grammar.mode <= arm64SVELSRVectorPredicated {
+					word |= uint32(map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[width]) << 22
+				}
+				shift := width / 2
+				switch grammar.mode {
+				case arm64SVELSRWidePredicated, arm64SVELSRVectorPredicated:
+					word |= 24<<5 | 7<<10 | 8
+				case arm64SVELSRWideUnpredicated:
+					word |= 30<<16 | 24<<5 | 8
+				case arm64SVELSRImmediatePredicated, arm64SVELSRImmediateUnpredicated:
+					encodedShift := shift
+					if op == "ZLSL" {
+						encodedShift = width - shift
+					}
+					if grammar.mode == arm64SVELSRImmediatePredicated {
+						word |= encodeARM64SVEShiftImmediateBits(width, encodedShift, 5) | 7<<10 | 8
+					} else {
+						word |= encodeARM64SVEShiftImmediateBits(width, encodedShift, 16) | 24<<5 | 8
+					}
+				}
+				decoded, ok := decodeARM64RawSVEShift(word)
+				if !ok || decoded.op != op || decoded.mode != grammar.mode || decoded.elementBits != width || decoded.destination != 8 {
+					t.Fatalf("%s width %d mode %d word %#08x decoded as %+v, ok=%v", op, width, grammar.mode, word, decoded, ok)
+				}
+				if grammar.mode == arm64SVELSRImmediatePredicated || grammar.mode == arm64SVELSRImmediateUnpredicated {
+					if decoded.shift != shift {
+						t.Fatalf("%s word %#08x shift = %d, want %d", op, word, decoded.shift, shift)
+					}
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEShiftForms": {Name: "rawSVEShiftForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-shift-forms.ll", "arm64-raw-sve-shift-forms.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64RawSVEShiftGoHighwayRegression(t *testing.T) {
+	const source = `
+TEXT rawSVEShift(SB),$0-0
+	WORD $0x046d9c42 // LSL Z2.S, Z2.S, #13
+	WORD $0x04779d4a // LSL Z10.S, Z10.S, #23
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawSVEShift": {Name: "rawSVEShift", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-shift.ll", "arm64-raw-sve-shift.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_sve_signed_load.go b/arm64_lower_word_sve_signed_load.go
new file mode 100644
index 000000000..6bd7b9c08
--- /dev/null
+++ b/arm64_lower_word_sve_signed_load.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import "fmt"
+
+type arm64SVELoadAddress uint8
+
+const (
+	arm64SVELoadRegister arm64SVELoadAddress = iota
+	arm64SVELoadImmediate
+	arm64SVELoadVectorOffset
+	arm64SVELoadVectorBase
+)
+
+type arm64RawSVELoadRow struct {
+	op          Op
+	elementBits int
+	address     arm64SVELoadAddress
+	extension   ExtendOp
+	scale       int64
+}
+
+var arm64RawSVELoadRows = arm64SVESignedLoadRawTable()
+
+// LD1SB/SH/SW share the signed ordinary-load semantics. Expand only the
+// encoding axes here: widening element size, scalar/vector address, index
+// extension and scale. No opcode-specific lowering is needed.
+func arm64SVESignedLoadRawTable() map[uint32]arm64RawSVELoadRow {
+	rows := make(map[uint32]arm64RawSVELoadRow)
+	for op, spec := range arm64SVEOrdinaryMemorySpecs {
+		if !spec.load || !spec.signed {
+			continue
+		}
+		memorySize := uint32(0)
+		for 8<<memorySize < spec.memoryBits {
+			memorySize++
+		}
+		for elementSize := memorySize + 1; elementSize < 4; elementSize++ {
+			row := arm64RawSVELoadRow{op: op, elementBits: 8 << elementSize, scale: int64(spec.memoryBits / 8)}
+			base := uint32(0xa5804000) - memorySize<<23 + (3-elementSize)<<21
+			row.address = arm64SVELoadRegister
+			rows[base] = row
+			row.address = arm64SVELoadImmediate
+			rows[base+0x6000] = row
+			if elementSize < 2 {
+				continue
+			}
+			vectorBase := uint32(0x84208000) + memorySize<<23
+			if elementSize == 3 {
+				vectorBase |= 1 << 30
+			}
+			row.address = arm64SVELoadVectorBase
+			rows[vectorBase] = row
+			row.address = arm64SVELoadVectorOffset
+			for scale := uint32(0); scale < 2; scale++ {
+				if memorySize == 0 && scale != 0 {
+					continue
+				}
+				row.scale = 1 << (scale * memorySize)
+				if elementSize == 3 {
+					row.extension = ""
+					rows[0xc4408000+memorySize<<23+scale<<21] = row
+				}
+				for signed, extension := range []ExtendOp{ExtendUXTW, ExtendSXTW} {
+					row.extension = extension
+					base := uint32(0x84000000) + memorySize<<23 + uint32(signed)<<22 + scale<<21
+					if elementSize == 3 {
+						base |= 1 << 30
+					}
+					rows[base] = row
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func decodeARM64RawSVESignedLoad(word uint32) (Instr, bool) {
+	row, ok := arm64RawSVELoadRows[word&0xffe0e000]
+	if !ok {
+		return Instr{}, false
+	}
+	return decodeARM64RawSVELoadAddress(word, row)
+}
+
+// Both signed and unsigned loads normalize the same address grammar before
+// using the ordinary-memory semantic lowerer.
+func decodeARM64RawSVELoadAddress(word uint32, row arm64RawSVELoadRow) (Instr, bool) {
+	base, index := word>>5&31, word>>16&31
+	width := map[int]byte{8: 'B', 16: 'H', 32: 'S', 64: 'D', 128: 'Q'}[row.elementBits]
+	memory := MemRef{Base: Reg(fmt.Sprintf("R%d", base))}
+	if base == 31 {
+		memory.Base = "RSP"
+	}
+	switch row.address {
+	case arm64SVELoadRegister:
+		if index == 31 { // Xm excludes 31; this is not a zero-index alias.
+			return Instr{}, false
+		}
+		memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", index)), row.scale
+		if row.scale == 1 {
+			memory.Base, memory.Index = memory.Index, memory.Base
+		}
+	case arm64SVELoadImmediate:
+		if index&16 != 0 {
+			return Instr{}, false
+		}
+		offset := int(index)
+		if offset >= 8 {
+			offset -= 16
+		}
+		if offset < 0 {
+			memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+		} else if offset > 0 {
+			memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+		}
+	case arm64SVELoadVectorOffset:
+		memory.Index = Reg(fmt.Sprintf("Z%d.%c", index, width))
+		memory.IndexExt, memory.Scale = row.extension, row.scale
+	case arm64SVELoadVectorBase:
+		memory.Base = Reg(fmt.Sprintf("Z%d.%c", base, width))
+		memory.Off = int64(index) * row.scale
+	}
+	return Instr{Op: row.op, Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpMem, Mem: memory},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", word>>10&7))},
+		{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.%c", word&31, width))}},
+	}}, true
+}
diff --git a/arm64_lower_word_sve_structured_memory.go b/arm64_lower_word_sve_structured_memory.go
new file mode 100644
index 000000000..6a67f5a59
--- /dev/null
+++ b/arm64_lower_word_sve_structured_memory.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+)
+
+// The raw rows and the named grammar share count, element width and direction.
+// Q-granule rows use a different count field from the ordinary B/H/S/D rows.
+func (spec arm64SVEStructuredMemorySpec) rawBases() (register, immediate uint32) {
+	count := uint32(spec.vectorCount - 1)
+	if spec.q {
+		if spec.load {
+			return 0xa4208000 | count<<23, 0xa410e000 | count<<23
+		}
+		return 0xe4200000 | count<<22, 0xe4000000 | count<<22
+	}
+	size := uint32(bits.TrailingZeros(uint(spec.memoryBits)) - 3)
+	fields := count<<21 | size<<23
+	if spec.load {
+		return 0xa400c000 | fields, 0xa400e000 | fields
+	}
+	return 0xe4006000 | fields, 0xe410e000 | fields
+}
+
+var arm64RawSVEStructuredRegisters, arm64RawSVEStructuredImmediates = arm64SVEStructuredRawTables()
+
+func arm64SVEStructuredRawTables() (registers, immediates map[uint32]Op) {
+	registers = make(map[uint32]Op, len(arm64SVEStructuredMemorySpecs))
+	immediates = make(map[uint32]Op, len(arm64SVEStructuredMemorySpecs))
+	for op, spec := range arm64SVEStructuredMemorySpecs {
+		register, immediate := spec.rawBases()
+		registers[register] = op
+		immediates[immediate] = op
+	}
+	return
+}
+
+func decodeARM64RawSVEStructuredMemory(word uint32) (Instr, bool) {
+	op, registerOffset := arm64RawSVEStructuredRegisters[word&0xffe0e000]
+	if !registerOffset {
+		var ok bool
+		op, ok = arm64RawSVEStructuredImmediates[word&0xfff0e000]
+		if !ok {
+			return Instr{}, false
+		}
+	}
+	spec := arm64SVEStructuredMemorySpecs[op]
+	base := Reg(fmt.Sprintf("R%d", word>>5&31))
+	if word>>5&31 == 31 {
+		base = "RSP"
+	}
+	memory := MemRef{Base: base}
+	if registerOffset {
+		index := word >> 16 & 31
+		if index == 31 { // Rm=31 is not allocated in scalar-index forms.
+			return Instr{}, false
+		}
+		memory.Index = Reg(fmt.Sprintf("R%d", index))
+		memory.Scale = int64(spec.memoryBits / 8)
+		if spec.memoryBits == 8 {
+			// The unshifted Plan 9 spelling writes (Xm)(Xn|RSP).
+			memory.Base, memory.Index = memory.Index, memory.Base
+		}
+	} else {
+		offset := int(word >> 16 & 15)
+		if offset >= 8 {
+			offset -= 16
+		}
+		offset *= spec.vectorCount
+		if offset < 0 {
+			memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+		} else if offset > 0 {
+			memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+		}
+	}
+	width := map[int]string{8: "B", 16: "H", 32: "S", 64: "D", 128: "Q"}[spec.memoryBits]
+	list := Operand{Kind: OpRegList}
+	for i := 0; i < spec.vectorCount; i++ {
+		list.RegList = append(list.RegList, Reg(fmt.Sprintf("Z%d.%s", (int(word&31)+i)%32, width)))
+	}
+	mode := ""
+	if spec.load {
+		mode = ".Z"
+	}
+	predicate := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d%s", word>>10&7, mode))}
+	address := Operand{Kind: OpMem, Mem: memory}
+	args := []Operand{list, predicate, address}
+	if spec.load {
+		args = []Operand{address, predicate, list}
+	}
+	return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+}
diff --git a/arm64_lower_word_sve_unpack.go b/arm64_lower_word_sve_unpack.go
new file mode 100644
index 000000000..d09302f70
--- /dev/null
+++ b/arm64_lower_word_sve_unpack.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import "fmt"
+
+// The four SVE widening-unpack operations use one grammar. The size field
+// selects B-to-H, H-to-S, or S-to-D; opcode bits select sign and half.
+func decodeARM64RawSVEUnpack(word uint32) (Instr, bool) {
+	if word&0xff3cfc00 != 0x05303800 {
+		return Instr{}, false
+	}
+	width := int(word>>22) & 3
+	if width == 0 {
+		return Instr{}, false
+	}
+	opcode := int(word>>16) & 3
+	operations := [...]Op{"ZSUNPKLO", "ZSUNPKHI", "ZUUNPKLO", "ZUUNPKHI"}
+	arrangements := [...]string{"", "B", "H", "S", "D"}
+	source := Reg(fmt.Sprintf("Z%d.%s", word>>5&31, arrangements[width]))
+	destination := Reg(fmt.Sprintf("Z%d.%s", word&31, arrangements[width+1]))
+	return Instr{
+		Op:   operations[opcode],
+		Args: []Operand{{Kind: OpReg, Reg: source}, {Kind: OpReg, Reg: destination}},
+		Raw:  fmt.Sprintf("WORD $%#08x", word),
+	}, true
+}
diff --git a/arm64_lower_word_sve_unpack_test.go b/arm64_lower_word_sve_unpack_test.go
new file mode 100644
index 000000000..f6e0ae810
--- /dev/null
+++ b/arm64_lower_word_sve_unpack_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEUnpackCompleteFamily(t *testing.T) {
+	operations := []struct {
+		name      string
+		opcode    uint32
+		intrinsic string
+	}{
+		{"SUNPKLO", 0, "sunpklo"},
+		{"SUNPKHI", 1, "sunpkhi"},
+		{"UUNPKLO", 2, "uunpklo"},
+		{"UUNPKHI", 3, "uunpkhi"},
+	}
+	widths := []struct {
+		name   string
+		bits   uint32
+		suffix string
+	}{
+		{"B-to-H", 1, "nxv8i16"},
+		{"H-to-S", 2, "nxv4i32"},
+		{"S-to-D", 3, "nxv2i64"},
+	}
+
+	for _, operation := range operations {
+		for _, width := range widths {
+			t.Run(operation.name+"/"+width.name, func(t *testing.T) {
+				word := uint32(0x05303800) | width.bits<<22 | operation.opcode<<16 | 1<<5
+				source := fmt.Sprintf("TEXT sveUnpackRaw(SB),$0-0\n\tWORD $%#08x\n\tRET\n", word)
+				requireARM64SVEGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range []string{
+					"aarch64-apple-darwin",
+					"aarch64-unknown-linux-gnu",
+					"aarch64-pc-windows-msvc",
+				} {
+					t.Run(triple, func(t *testing.T) {
+						ir, err := Translate(file, Options{
+							TargetTriple: triple,
+							Goarch:       "arm64",
+							Sigs: map[string]FuncSig{
+								"sveUnpackRaw": {Name: "sveUnpackRaw", Ret: Void},
+							},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, want := range []string{
+							"@llvm.aarch64.sve." + operation.intrinsic + "." + width.suffix,
+							`"target-features"="+sve"`,
+						} {
+							if !strings.Contains(ir, want) {
+								t.Fatalf("omitted %q:\n%s", want, ir)
+							}
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM 22 llc not found")
+						}
+						compileLLVMToObject(t, llc, triple, "arm64-sve-unpack-raw.ll", "arm64-sve-unpack-raw.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestDecodeARM64RawSVEUnpackRegistersAndBoundaries(t *testing.T) {
+	for _, base := range []uint32{
+		0x05703800, 0x05b03800, 0x05f03800,
+		0x05713800, 0x05b13800, 0x05f13800,
+		0x05723800, 0x05b23800, 0x05f23800,
+		0x05733800, 0x05b33800, 0x05f33800,
+	} {
+		word := base | 23<<5 | 17
+		decoded, ok := decodeARM64RawSVEUnpack(word)
+		if !ok {
+			t.Fatalf("failed to decode %#08x", word)
+		}
+		if !strings.HasPrefix(string(decoded.Args[0].Reg), "Z23.") || !strings.HasPrefix(string(decoded.Args[1].Reg), "Z17.") {
+			t.Fatalf("wrong register fields for %#08x: %+v", word, decoded.Args)
+		}
+	}
+
+	for _, word := range []uint32{
+		0x05303800, // Byte-width destination is reserved.
+		0x05703c00, // Adjacent encoding with bit 10 set.
+		0x05707800, // Adjacent encoding with bit 14 set.
+	} {
+		if decoded, ok := decodeARM64RawSVEUnpack(word); ok {
+			t.Fatalf("accepted unrelated encoding %#08x as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_unsigned_load.go b/arm64_lower_word_sve_unsigned_load.go
new file mode 100644
index 000000000..255c52223
--- /dev/null
+++ b/arm64_lower_word_sve_unsigned_load.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import "fmt"
+
+var arm64RawSVEUnsignedLoadRows = arm64SVEUnsignedLoadRawTable()
+
+// Expand the ordinary load specification over the architectural address
+// axes. Q-granule and multi-vector PN encodings have separate field layouts.
+func arm64SVEUnsignedLoadRawTable() map[uint32]arm64RawSVELoadRow {
+	rows := make(map[uint32]arm64RawSVELoadRow)
+	for op, spec := range arm64SVEOrdinaryMemorySpecs {
+		if !spec.load || spec.signed || spec.qOnly {
+			continue
+		}
+		memorySize := uint32(0)
+		for 8<<memorySize < spec.memoryBits {
+			memorySize++
+		}
+		for elementSize := memorySize; elementSize < 4; elementSize++ {
+			row := arm64RawSVELoadRow{op: op, elementBits: 8 << elementSize, scale: int64(spec.memoryBits / 8)}
+			base := uint32(0xa4004000) + memorySize<<23 + elementSize<<21
+			row.address = arm64SVELoadRegister
+			rows[base] = row
+			row.address = arm64SVELoadImmediate
+			rows[base+0x6000] = row
+			if elementSize < 2 {
+				continue
+			}
+			vectorBase := uint32(0x8420c000) + memorySize<<23
+			if elementSize == 3 {
+				vectorBase |= 1 << 30
+			}
+			row.address = arm64SVELoadVectorBase
+			rows[vectorBase] = row
+			row.address = arm64SVELoadVectorOffset
+			for scale := uint32(0); scale < 2; scale++ {
+				if memorySize == 0 && scale != 0 {
+					continue
+				}
+				row.scale = 1 << (scale * memorySize)
+				if elementSize == 3 {
+					row.extension = ""
+					rows[0xc440c000+memorySize<<23+scale<<21] = row
+				}
+				for signed, extension := range []ExtendOp{ExtendUXTW, ExtendSXTW} {
+					row.extension = extension
+					base := uint32(0x84004000) + memorySize<<23 + uint32(signed)<<22 + scale<<21
+					if elementSize == 3 {
+						base |= 1 << 30
+					}
+					rows[base] = row
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func decodeARM64RawSVEUnsignedLoad(word uint32) (Instr, bool) {
+	if row, ok := arm64RawSVEUnsignedLoadRows[word&0xffe0e000]; ok {
+		return decodeARM64RawSVELoadAddress(word, row)
+	}
+	if decoded, ok := decodeARM64RawSVEPNLoad(word); ok {
+		return decoded, true
+	}
+	if word&0xffe0e000 == 0xc400a000 {
+		index := Reg(fmt.Sprintf("R%d", word>>16&31))
+		if word>>16&31 == 31 {
+			index = ZR
+		}
+		return Instr{Op: "ZLD1Q", Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+			{Kind: OpMem, Mem: MemRef{Base: index, Index: Reg(fmt.Sprintf("Z%d.D", word>>5&31)), Scale: 1}},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", word>>10&7))},
+			{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.Q", word&31))}},
+		}}, true
+	}
+	for memorySize := uint32(2); memorySize < 4; memorySize++ {
+		row := arm64RawSVELoadRow{
+			op: Op("ZLD1" + string("BHWD"[memorySize])), elementBits: 128, scale: 1 << memorySize,
+		}
+		base := uint32(0xa4008000) + memorySize<<23
+		if word&0xffe0e000 == base {
+			row.address = arm64SVELoadRegister
+			return decodeARM64RawSVELoadAddress(word, row)
+		}
+		if word&0xfff0e000 == base+0xfa000 {
+			row.address = arm64SVELoadImmediate
+			// Bit 20 is fixed, not the high bit of this signed imm4.
+			ins, ok := decodeARM64RawSVELoadAddress(word&^(1<<20), row)
+			ins.Raw = fmt.Sprintf("WORD $%#08x", word)
+			return ins, ok
+		}
+	}
+	return Instr{}, false
+}
+
+func decodeARM64RawSVEPNLoad(word uint32) (Instr, bool) {
+	register := word&0xffe00000 == 0xa0000000
+	immediate := word&0xfff00000 == 0xa0400000
+	if !register && !immediate {
+		return Instr{}, false
+	}
+	count := 2
+	if word&(1<<15) != 0 {
+		count = 4
+	}
+	destination := int(word & 31)
+	if destination%count != 0 {
+		return Instr{}, false
+	}
+	size := word >> 13 & 3
+	base, index := word>>5&31, word>>16&31
+	memory := MemRef{Base: Reg(fmt.Sprintf("R%d", base))}
+	if base == 31 {
+		memory.Base = "RSP"
+	}
+	if register && index != 31 {
+		memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", index)), 1<<size
+		if size == 0 {
+			memory.Base, memory.Index = memory.Index, memory.Base
+		}
+	} else if immediate {
+		offset := int(index)
+		if offset >= 8 {
+			offset -= 16
+		}
+		if offset < 0 {
+			memory.OffRaw = fmt.Sprintf("-VL*%d", -offset*count)
+		} else if offset > 0 {
+			memory.OffRaw = fmt.Sprintf("VL*%d", offset*count)
+		}
+	}
+	registers := make([]Reg, count)
+	for i := range registers {
+		registers[i] = Reg(fmt.Sprintf("Z%d.%c", destination+i, "BHSD"[size]))
+	}
+	return Instr{Op: Op("ZLD1" + string("BHWD"[size])), Raw: fmt.Sprintf("WORD $%#08x", word), Args: []Operand{
+		{Kind: OpMem, Mem: memory},
+		{Kind: OpReg, Reg: Reg(fmt.Sprintf("PN%d.Z", 8+(word>>10&7)))},
+		{Kind: OpRegList, RegList: registers},
+	}}, true
+}
+
+func (c *arm64Ctx) lowerRawSVEUnsignedLoad(ins Instr) error {
+	if ins.Op == "ZLD1Q" && ins.Args[0].Mem.Base == ZR {
+		bases, _, _ := arm64ParseSVEZElementReg(Operand{Kind: OpReg, Reg: ins.Args[0].Mem.Index})
+		predicate, _ := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7)
+		vectors, _, _ := arm64ParseSVEOrdinaryVectorList(ins.Args[2])
+		_, _, err := c.emitARM64SVEOrdinaryQGatherLoad(bases, predicate, vectors[0], "0")
+		return err
+	}
+	_, _, err := c.lowerARM64SVEOrdinaryMemory(ins.Op, ins)
+	return err
+}
diff --git a/arm64_lower_word_sve_while_test.go b/arm64_lower_word_sve_while_test.go
new file mode 100644
index 000000000..ce2f8df71
--- /dev/null
+++ b/arm64_lower_word_sve_while_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEWhileLTDiscoveryWord(t *testing.T) {
+	const source = `TEXT whileltword(SB),$0-0
+	WORD $0x25a217e1 // whilelt p1.s, xzr, x2
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"whileltword": {Name: "whileltword", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, "@llvm.aarch64.sve.whilelt.nxv4i1.i64") {
+		t.Fatalf("raw WHILELT did not use the typed predicate lowering:\n%s", ll)
+	}
+}
+
+func TestTranslateARM64RawSVEWhileCompleteGo127Family(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawpredicatewhileforms(SB),$0-0\n")
+	for _, spec := range arm64RawSVEWhileSpecs {
+		for size := uint32(0); size < 4; size++ {
+			operands := uint32(2<<16 | 9<<5)
+			for _, word := range []uint32{
+				spec.scalarX | size<<22 | operands | 1,
+				spec.scalarW | size<<22 | operands | 1,
+				spec.pair | size<<22 | operands | 10,
+				spec.counter | size<<22 | operands | 7,
+				spec.counter | size<<22 | operands | 1<<13 | 7,
+			} {
+				decoded, ok := decodeARM64RawSVEWhile(word)
+				if !ok || !strings.HasPrefix(string(decoded.Op), "PWHILE"+spec.condition) {
+					t.Fatalf("WORD %#08x did not decode as WHILE%s: %+v", word, spec.condition, decoded)
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawpredicatewhileforms": {Name: "rawpredicatewhileforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, spec := range arm64RawSVEWhileSpecs {
+				calls := 0
+				for _, line := range strings.Split(ll, "\n") {
+					if strings.Contains(line, " = call ") &&
+						strings.Contains(line, "@llvm.aarch64.sve.while"+strings.ToLower(spec.condition)+".") {
+						calls++
+					}
+				}
+				if calls != 20 {
+					t.Fatalf("WHILE%s emitted %d calls, want 20", spec.condition, calls)
+				}
+			}
+			for _, want := range []string{
+				"+sve2p1",
+				"@llvm.aarch64.sve.whilelt.nxv2i1.i32",
+				"@llvm.aarch64.sve.whilelt.x2.nxv4i1",
+				"@llvm.aarch64.sve.whilelt.c64",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("raw predicate family omitted %q", want)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-sve-while.ll", "arm64-raw-sve-while.o", ll)
+		})
+	}
+}
+
+func TestDecodeARM64RawSVEWhileRejectsOtherEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x25203010,         // WHILERW is a separate pointer comparison family.
+		0x25203410,         // WHILEWR is a separate pointer comparison family.
+		0x25201420 | 1<<15, // Reserved bit in the single-predicate form.
+		0x25205410 | 1<<15, // Reserved bit in the pair form.
+	} {
+		if decoded, ok := decodeARM64RawSVEWhile(word); ok {
+			t.Fatalf("reserved or foreign WORD %#08x decoded as %+v", word, decoded)
+		}
+	}
+}
diff --git a/arm64_lower_word_sve_whilelo.go b/arm64_lower_word_sve_whilelo.go
new file mode 100644
index 000000000..c2d320f75
--- /dev/null
+++ b/arm64_lower_word_sve_whilelo.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import "fmt"
+
+// These are the four Go 1.27 encoder rows for each SVE predicate WHILE
+// condition: scalar X, scalar W, predicate pair and SVE2.1 predicate counter.
+// The raw decoder feeds the same typed grammar and lowering as named PWHILE*
+// instructions instead of maintaining a second implementation of their flags.
+type arm64RawSVEWhileSpec struct {
+	condition string
+	scalarX   uint32
+	scalarW   uint32
+	pair      uint32
+	counter   uint32
+}
+
+var arm64RawSVEWhileSpecs = [...]arm64RawSVEWhileSpec{
+	{"GE", 0x25201000, 0x25200000, 0x25205010, 0x25204010},
+	{"GT", 0x25201010, 0x25200010, 0x25205011, 0x25204018},
+	{"HI", 0x25201810, 0x25200810, 0x25205811, 0x25204818},
+	{"HS", 0x25201800, 0x25200800, 0x25205810, 0x25204810},
+	{"LE", 0x25201410, 0x25200410, 0x25205411, 0x25204418},
+	{"LO", 0x25201c00, 0x25200c00, 0x25205c10, 0x25204c10},
+	{"LS", 0x25201c10, 0x25200c10, 0x25205c11, 0x25204c18},
+	{"LT", 0x25201400, 0x25200400, 0x25205410, 0x25204410},
+}
+
+func arm64RawSVEWhileGP(index uint32) Reg {
+	if index == 31 {
+		return ZR
+	}
+	return Reg(fmt.Sprintf("R%d", index))
+}
+
+func decodeARM64RawSVEWhile(word uint32) (Instr, bool) {
+	width := "BHSD"[word>>22&3]
+	// Go Plan 9 syntax lists Rm, Rn, then Pd. Raw AArch64 bits 5:9 encode
+	// Rn and bits 16:20 encode Rm, so this reversal is intentional.
+	args := []Operand{
+		{Kind: OpReg, Reg: arm64RawSVEWhileGP(word >> 16 & 31)},
+		{Kind: OpReg, Reg: arm64RawSVEWhileGP(word >> 5 & 31)},
+	}
+	for _, spec := range arm64RawSVEWhileSpecs {
+		op := Op("PWHILE" + spec.condition)
+		if word&0xff20fc10 == spec.scalarX || word&0xff20fc10 == spec.scalarW {
+			if word&0x00001000 == 0 {
+				op += "W"
+			}
+			args = append(args, Operand{
+				Kind: OpReg,
+				Reg:  Reg(fmt.Sprintf("P%d.%c", word&15, width)),
+			})
+			return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+		}
+		if word&0xff20fc11 == spec.pair {
+			predicate := word & 14
+			args = append(args, Operand{
+				Kind: OpRegList,
+				RegList: []Reg{
+					Reg(fmt.Sprintf("P%d.%c", predicate, width)),
+					Reg(fmt.Sprintf("P%d.%c", predicate+1, width)),
+				},
+			})
+			return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+		}
+		if word&0xff20dc18 == spec.counter {
+			multiplier := 2
+			if word&0x2000 != 0 {
+				multiplier = 4
+			}
+			args = append([]Operand{{Kind: OpIdent, Ident: fmt.Sprintf("VLX%d", multiplier)}}, args...)
+			args = append(args, Operand{
+				Kind: OpReg,
+				Reg:  Reg(fmt.Sprintf("PN%d.%c", 8+(word&7), width)),
+			})
+			return Instr{Op: op, Args: args, Raw: fmt.Sprintf("WORD $%#08x", word)}, true
+		}
+	}
+	return Instr{}, false
+}
diff --git a/arm64_lower_word_sve_whilelo_test.go b/arm64_lower_word_sve_whilelo_test.go
new file mode 100644
index 000000000..95e54a81e
--- /dev/null
+++ b/arm64_lower_word_sve_whilelo_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawSVEWhileLOForms(t *testing.T) {
+	const source = `TEXT whilelowords(SB),$0-0
+	WORD $0x25211d00
+	WORD $0x25611d00
+	WORD $0x25a11d00
+	WORD $0x25e11d00
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"whilelowords": {Name: "whilelowords", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := 0
+	for _, line := range strings.Split(ll, "\n") {
+		if strings.Contains(line, " = call ") && strings.Contains(line, "@llvm.aarch64.sve.whilelo.") {
+			got++
+		}
+	}
+	if want := 4; got != want {
+		t.Fatalf("raw WHILELO lowering emitted %d intrinsics, want %d:\n%s", got, want, ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-whilelo.ll", "arm64-whilelo.o", ll)
+}
diff --git a/arm64_lower_word_system_register.go b/arm64_lower_word_system_register.go
new file mode 100644
index 000000000..e587aaa5b
--- /dev/null
+++ b/arm64_lower_word_system_register.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSystemRegister struct {
+	read     bool
+	encoding uint16
+	reg      int
+}
+
+// decodeARM64RawSystemRegister covers the complete MRS/MSR (register) encoding
+// fields: both directions, every 15-bit architectural system-register value,
+// and every Xt value (including XZR).
+func decodeARM64RawSystemRegister(word uint32) (arm64RawSystemRegister, bool) {
+	fixed := word & 0xfff00000
+	if fixed != 0xd5300000 && fixed != 0xd5100000 {
+		return arm64RawSystemRegister{}, false
+	}
+	return arm64RawSystemRegister{
+		read:     fixed == 0xd5300000,
+		encoding: uint16((word >> 5) & 0x7fff),
+		reg:      int(word & 31),
+	}, true
+}
+
+func arm64EncodedSystemRegisterName(encoding uint16) string {
+	op0 := 2 + int((encoding>>14)&1)
+	op1 := int((encoding >> 11) & 7)
+	crn := int((encoding >> 7) & 15)
+	crm := int((encoding >> 3) & 15)
+	op2 := int(encoding & 7)
+	return fmt.Sprintf("S%d_%d_C%d_C%d_%d", op0, op1, crn, crm, op2)
+}
+
+func (c *arm64Ctx) lowerRawSystemRegister(form arm64RawSystemRegister) error {
+	if control, matched := arm64RawFPControl(form); matched {
+		return c.lowerARM64FPControl(control)
+	}
+	if form.encoding == arm64NZCVEncoding {
+		reg := ZR
+		if form.reg != 31 {
+			reg = Reg(fmt.Sprintf("R%d", form.reg))
+		}
+		return c.lowerARM64NZCV(arm64NZCVForm{read: form.read, reg: reg})
+	}
+	sysreg := arm64EncodedSystemRegisterName(form.encoding)
+	if form.read {
+		dst := ZR
+		if form.reg != 31 {
+			dst = Reg(fmt.Sprintf("R%d", form.reg))
+		}
+		value := c.emitARM64SystemRegisterRead(sysreg, form.encoding, true, dst)
+		if form.reg == 31 {
+			return nil
+		}
+		return c.storeReg(Reg(fmt.Sprintf("R%d", form.reg)), value)
+	}
+	value := "0"
+	if form.reg != 31 {
+		var err error
+		value, err = c.loadReg(Reg(fmt.Sprintf("R%d", form.reg)))
+		if err != nil {
+			return err
+		}
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 %s)\n", "msr "+sysreg+", $0", "r,~{memory}", value)
+	return nil
+}
diff --git a/arm64_lower_word_system_register_test.go b/arm64_lower_word_system_register_test.go
new file mode 100644
index 000000000..c51676ad9
--- /dev/null
+++ b/arm64_lower_word_system_register_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestDecodeARM64RawSystemRegisterCompleteEncodingFields(t *testing.T) {
+	for _, direction := range []struct {
+		base uint32
+		read bool
+	}{{0xd5100000, false}, {0xd5300000, true}} {
+		for encoding := 0; encoding <= 0x7fff; encoding++ {
+			for reg := 0; reg < 32; reg++ {
+				word := direction.base | uint32(encoding)<<5 | uint32(reg)
+				got, ok := decodeARM64RawSystemRegister(word)
+				if !ok || got.read != direction.read || got.encoding != uint16(encoding) || got.reg != reg {
+					t.Fatalf("decode %#08x = %#v, %v", word, got, ok)
+				}
+			}
+		}
+	}
+	for _, word := range []uint32{0xd5000000, 0xd5200000, 0xd5400000, 0xd4ffffff} {
+		if got, ok := decodeARM64RawSystemRegister(word); ok {
+			t.Fatalf("decodeARM64RawSystemRegister(%#08x) = %#v, true", word, got)
+		}
+	}
+	if got := arm64EncodedSystemRegisterName(0x5e82); got != "S3_3_C13_C0_2" {
+		t.Fatalf("TPIDR_EL0 encoding name = %q", got)
+	}
+}
+
+func TestTranslateARM64RawSystemRegisterFamilyLLVM22(t *testing.T) {
+	const source = `TEXT ·rawSystemRegisters(SB), $0-0
+	WORD $0xd53bd040
+	WORD $0xd51bd040
+	WORD $0xd53bd05f
+	WORD $0xd51bd05f
+	RET
+`
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"rawSystemRegisters": {Name: "rawSystemRegisters", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"mrs $0, S3_3_C13_C0_2", "msr S3_3_C13_C0_2, $0"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s raw system-register IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, fmt.Sprintf("arm64-raw-system-register-%s.ll", strings.ReplaceAll(triple, "-", "_")), "arm64-raw-system-register.o", ll)
+	}
+}
diff --git a/arm64_lower_word_table_lookup.go b/arm64_lower_word_table_lookup.go
new file mode 100644
index 000000000..efc74bafa
--- /dev/null
+++ b/arm64_lower_word_table_lookup.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawTableLookup struct {
+	extension   bool
+	lanes       int
+	tableCount  int
+	index       int
+	firstTable  int
+	destination int
+}
+
+func decodeARM64RawTableLookup(word uint32) (arm64RawTableLookup, bool) {
+	// Advanced SIMD TBL/TBX (vector). Q, len, op and the three register
+	// fields are variable; every remaining bit is architecturally fixed.
+	if word&0xbfe08c00 != 0x0e000000 {
+		return arm64RawTableLookup{}, false
+	}
+	lanes := 8
+	if word&(1<<30) != 0 {
+		lanes = 16
+	}
+	return arm64RawTableLookup{
+		extension:   word&(1<<12) != 0,
+		lanes:       lanes,
+		tableCount:  int(word>>13)&3 + 1,
+		index:       int(word>>16) & 31,
+		firstTable:  int(word>>5) & 31,
+		destination: int(word) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawTableLookup(form arm64RawTableLookup) error {
+	arrangement := fmt.Sprintf("B%d", form.lanes)
+	reg := func(index int) Reg {
+		return Reg(fmt.Sprintf("V%d.%s", index, arrangement))
+	}
+	tables := make([]Reg, form.tableCount)
+	for i := range tables {
+		// Table operands are always full 128-bit vectors, independently of Q.
+		tables[i] = Reg(fmt.Sprintf("V%d.B16", (form.firstTable+i)%32))
+	}
+	op := Op("VTBL")
+	if form.extension {
+		op = "VTBX"
+	}
+	ins := Instr{
+		Op:  op,
+		Raw: "decoded ARM64 WORD as " + string(op),
+		Args: []Operand{
+			{Kind: OpReg, Reg: reg(form.index)},
+			{Kind: OpRegList, RegList: tables},
+			{Kind: OpReg, Reg: reg(form.destination)},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorTableLookup(op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_table_lookup_test.go b/arm64_lower_word_table_lookup_test.go
new file mode 100644
index 000000000..9a4e4f3f1
--- /dev/null
+++ b/arm64_lower_word_table_lookup_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawTableLookupCompleteAdvancedSIMDFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawtablelookupforms(SB),$0-0\n")
+	for _, extension := range []bool{false, true} {
+		for _, lanes := range []int{8, 16} {
+			for tableCount := 1; tableCount <= 4; tableCount++ {
+				word := uint32(0x0e000000 | ((tableCount - 1) << 13) | (3 << 16) | (2 << 5) | 1)
+				if extension {
+					word |= 1 << 12
+				}
+				if lanes == 16 {
+					word |= 1 << 30
+				}
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawtablelookupforms": {Name: "rawtablelookupforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"<8 x i8>", "<16 x i8>", "<64 x i8>", "icmp ult i32"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw table lookup lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-table-lookup.ll", "arm64-raw-table-lookup.o", ll)
+		})
+	}
+}
+
+func TestARM64RawTableLookupDecoderCoversAllRegisterFields(t *testing.T) {
+	for _, extension := range []bool{false, true} {
+		for _, lanes := range []int{8, 16} {
+			for tableCount := 1; tableCount <= 4; tableCount++ {
+				for index := 0; index < 32; index++ {
+					for firstTable := 0; firstTable < 32; firstTable++ {
+						for destination := 0; destination < 32; destination++ {
+							word := uint32(0x0e000000 | ((tableCount - 1) << 13) | (index << 16) | (firstTable << 5) | destination)
+							if extension {
+								word |= 1 << 12
+							}
+							if lanes == 16 {
+								word |= 1 << 30
+							}
+							form, ok := decodeARM64RawTableLookup(word)
+							if !ok || form.extension != extension || form.lanes != lanes || form.tableCount != tableCount || form.index != index || form.firstTable != firstTable || form.destination != destination {
+								t.Fatalf("decode %#08x = %#v, %v", word, form, ok)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawTableLookupDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x2e030042,
+		0x0e038042,
+		0x0e030442,
+		0x0e030c42,
+	} {
+		if form, ok := decodeARM64RawTableLookup(word); ok {
+			t.Fatalf("table lookup decoder accepted adjacent encoding %#08x as %#v", word, form)
+		}
+	}
+}
diff --git a/arm64_lower_word_test.go b/arm64_lower_word_test.go
new file mode 100644
index 000000000..a1bb16ab6
--- /dev/null
+++ b/arm64_lower_word_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64KnownRawWordsHaveRealSemantics(t *testing.T) {
+	source := `
+TEXT rawwordforms(SB),$0-0
+	WORD $0xea00001f
+	WORD $0xf1000400
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"rawwordforms": {Name: "rawwordforms", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"icmp eq i64", "sub i64"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("known ARM64 WORD omitted %q semantics:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARM64UnknownRawEncodingFailsExplicitly(t *testing.T) {
+	// Go accepts arbitrary integer payloads in WORD directives. A reserved
+	// encoding must remain an explicit error rather than being swallowed by an
+	// over-broad decoder and reported as successfully translated.
+	source := "TEXT rawword(SB),$0-0\n\tWORD $0xffffffff\n\tRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"rawword": {Name: "rawword", Ret: Void}},
+	}); err == nil || !strings.Contains(err.Error(), "unsupported ARM64 WORD encoding") {
+		t.Fatalf("unknown ARM64 WORD did not fail explicitly: %v", err)
+	}
+}
+
+func TestTranslateARM64UnreferencedWordDataAfterReturn(t *testing.T) {
+	// Generated assembly may place a data word after the final RET. The
+	// payload is not an instruction and must not be decoded as one.
+	source := "TEXT deadword(SB),$0-0\n\tRET\n\tWORD $36473108\n\tWORD $0xffffffff\n"
+	requireARM64GoAssemblerResult(t, source, true)
+
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"deadword": {Name: "deadword", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, `c"\14\89,\02\FF\FF\FF\FF"`) {
+				t.Fatal("unreferenced ARM64 data words were not preserved")
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-dead-word.ll", "arm64-dead-word.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64LabeledWordDataAfterReturnRemainsData(t *testing.T) {
+	source := "TEXT labeledword(SB),$0-0\n\tRET\nworddata:\n\tWORD $36473108\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"labeledword": {Name: "labeledword", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, "labeledword.worddata.raw_data") {
+		t.Fatalf("labeled ARM64 data word was not preserved: %s", ll)
+	}
+}
+
+func TestTranslateARM64UnreferencedWordDataAfterJump(t *testing.T) {
+	for _, jump := range []string{"B", "JMP"} {
+		t.Run(jump, func(t *testing.T) {
+			source := "TEXT jumpword(SB),$0-0\n\t" + jump + " done\n" +
+				"\tWORD $34185040\n\tWORD $34192688\ndone:\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"jumpword": {Name: "jumpword", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ll, `[8 x i8] c"P\9F\09\02`) {
+				prefix := ll
+				if len(prefix) > 400 {
+					prefix = prefix[:400]
+				}
+				t.Fatalf("anonymous ARM64 WORD island was not preserved as data: %q", prefix)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-jump-word.ll", "arm64-jump-word.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64PCRelativeTargetAfterReturnIsNotData(t *testing.T) {
+	source := "TEXT targetword(SB),$0-0\n\tWORD $0x14000002\n\tRET\n\tWORD $36473108\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"targetword": {Name: "targetword", Ret: Void}},
+	}); err == nil || !strings.Contains(err.Error(), "unsupported ARM64 WORD encoding") {
+		t.Fatalf("PC-relative target after RET was misclassified as data: %v", err)
+	}
+}
+
+func TestTranslateARM64RawDirectiveRejectsMalformedOrPartialEncoding(t *testing.T) {
+	for _, instruction := range []string{"WORD", "WORD R0", "WORD $1, $2", "BYTE $0xd5"} {
+		file, err := Parse(ArchARM64, "TEXT bad(SB),$0-0\n\t"+instruction+"\n\tRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate silently accepted raw directive %q", instruction)
+		}
+	}
+}
diff --git a/arm64_lower_word_uabd_test.go b/arm64_lower_word_uabd_test.go
new file mode 100644
index 000000000..6890e4c97
--- /dev/null
+++ b/arm64_lower_word_uabd_test.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawVUABDForms = `TEXT vuabdwords(SB),$0-0
+	WORD $0x2E207400 // UABD V0.8B, V0.8B, V0.8B
+	WORD $0x6E30749D // UABD V29.16B, V4.16B, V16.16B
+	WORD $0x2E607400 // UABD V0.4H, V0.4H, V0.4H
+	WORD $0x2EA07400 // UABD V0.2S, V0.2S, V0.2S
+	WORD $0x6EA07400 // UABD V0.4S, V0.4S, V0.4S
+	RET
+`
+
+func TestTranslateARM64RawVUABDForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawVUABDForms, true)
+	file, err := Parse(ArchARM64, arm64RawVUABDForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"vuabdwords": {Name: "vuabdwords", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vuabd.ll", "arm64-vuabd.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_uadalp.go b/arm64_lower_word_uadalp.go
new file mode 100644
index 000000000..915fa734b
--- /dev/null
+++ b/arm64_lower_word_uadalp.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawPairwiseAddLong struct {
+	signed      bool
+	accumulate  bool
+	source      arm64VectorArrangement
+	destination arm64VectorArrangement
+	sourceReg   int
+	destReg     int
+}
+
+func decodeARM64RawPairwiseAddLong(word uint32) (arm64RawPairwiseAddLong, bool) {
+	form := arm64RawPairwiseAddLong{}
+	switch word & 0xbf3ffc00 {
+	case 0x0e202800: // SADDLP.
+		form.signed = true
+	case 0x2e202800: // UADDLP.
+	case 0x0e206800: // SADALP.
+		form.signed, form.accumulate = true, true
+	case 0x2e206800: // UADALP.
+		form.accumulate = true
+	default:
+		return arm64RawPairwiseAddLong{}, false
+	}
+	size := int(word>>22) & 3
+	if size > 2 {
+		return arm64RawPairwiseAddLong{}, false
+	}
+	sourceBits := 8 << size
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	sourceLanes := vectorBits / sourceBits
+	form.source = arm64VectorArrangement{elementBits: sourceBits, lanes: sourceLanes}
+	form.destination = arm64VectorArrangement{elementBits: sourceBits * 2, lanes: sourceLanes / 2}
+	form.sourceReg = int(word>>5) & 31
+	form.destReg = int(word & 31)
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawPairwiseAddLong(form arm64RawPairwiseAddLong) error {
+	source, err := c.loadRawARM64VectorOperand(form.sourceReg, form.source, 0, false)
+	if err != nil {
+		return err
+	}
+	sourceType := fmt.Sprintf("<%d x i%d>", form.source.lanes, form.source.elementBits)
+	pairType := fmt.Sprintf("<%d x i%d>", form.destination.lanes, form.source.elementBits)
+	destType := fmt.Sprintf("<%d x i%d>", form.destination.lanes, form.destination.elementBits)
+	even := c.newTmp()
+	odd := c.newTmp()
+	c.writeRawPairwiseAddLongShuffle(even, sourceType, source, pairType, form.destination.lanes, 0)
+	c.writeRawPairwiseAddLongShuffle(odd, sourceType, source, pairType, form.destination.lanes, 1)
+	wideEven := c.newTmp()
+	wideOdd := c.newTmp()
+	pairs := c.newTmp()
+	extension := "zext"
+	if form.signed {
+		extension = "sext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s to %s\n", wideEven, extension, pairType, even, destType)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s to %s\n", wideOdd, extension, pairType, odd, destType)
+	fmt.Fprintf(c.b, "  %%%s = add %s %%%s, %%%s\n", pairs, destType, wideEven, wideOdd)
+	result := "%" + pairs
+	if form.accumulate {
+		accumulator, err := c.loadRawARM64VectorOperand(form.destReg, form.destination, 0, false)
+		if err != nil {
+			return err
+		}
+		added := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add %s %s, %%%s\n", added, destType, accumulator, pairs)
+		result = "%" + added
+	}
+	return c.storeRawARM64VectorResult(form.destReg, form.destination, result, false)
+}
+
+func (c *arm64Ctx) writeRawPairwiseAddLongShuffle(name, sourceType, source, resultType string, lanes, parity int) {
+	fmt.Fprintf(c.b, "  %%%s = shufflevector %s %s, %s poison, <%d x i32> <", name, sourceType, source, sourceType, lanes)
+	for lane := 0; lane < lanes; lane++ {
+		if lane != 0 {
+			c.b.WriteString(", ")
+		}
+		fmt.Fprintf(c.b, "i32 %d", lane*2+parity)
+	}
+	c.b.WriteString(">\n")
+}
diff --git a/arm64_lower_word_uadalp_test.go b/arm64_lower_word_uadalp_test.go
new file mode 100644
index 000000000..dd50b6948
--- /dev/null
+++ b/arm64_lower_word_uadalp_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUADALPForms = `
+TEXT rawuadalpforms(SB),$0-0
+	WORD $0x2e206820 // UADALP V0.4H, V1.8B
+	WORD $0x6e206862 // UADALP V2.8H, V3.16B
+	WORD $0x2e6068a4 // UADALP V4.2S, V5.4H
+	WORD $0x6e6068e6 // UADALP V6.4S, V7.8H
+	WORD $0x2ea06928 // UADALP V8.1D, V9.2S
+	WORD $0x6ea0696a // UADALP V10.2D, V11.4S
+	RET
+`
+
+func TestTranslateARM64RawUADALPCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUADALPForms, true)
+	file, err := Parse(ArchARM64, arm64RawUADALPForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawuadalpforms": {Name: "rawuadalpforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"zext <4 x i8>", "zext <8 x i8>",
+				"zext <2 x i16>", "zext <4 x i16>",
+				"zext <1 x i32>", "zext <2 x i32>", "add <",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw UADALP lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-uadalp.ll", "arm64-raw-uadalp.o", ll)
+		})
+	}
+}
+
+func TestARM64RawUADALPRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawuadalp(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD inout+8(FP), R1
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V4.D2]
+	WORD $0x6ea06804 // UADALP V4.2D, V0.4S
+	VST1 [V4.D2], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawuadalp": {
+				Name: "rawuadalp", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawuadalp(const uint32_t *, uint64_t *);
+int main(void) {
+  const uint32_t in[4] = {0xffffffffu, 1, 2, 0xfffffffeu};
+  uint64_t got[2] = {7, 9};
+  const uint64_t want[2] = {UINT64_C(0x100000007), UINT64_C(0x100000009)};
+  rawuadalp(in, got);
+  for (int i = 0; i < 2; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_uadalp", triple, ll, mainC, nil)
+}
+
+func TestARM64RawUADALPDecoderRejectsAdjacentSADALPEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawUADALP(0x0e206820); ok {
+		t.Fatal("UADALP decoder claimed adjacent SADALP encoding")
+	}
+}
+
+// The historical instruction-specific probe is test-only. Production uses
+// the complete four-operation pairwise-long family and its shared effects.
+func decodeARM64RawUADALP(word uint32) (arm64RawPairwiseAddLong, bool) {
+	form, ok := decodeARM64RawPairwiseAddLong(word)
+	if !ok || form.signed || !form.accumulate {
+		return arm64RawPairwiseAddLong{}, false
+	}
+	return form, true
+}
diff --git a/arm64_lower_word_uhadd.go b/arm64_lower_word_uhadd.go
new file mode 100644
index 000000000..50ef81000
--- /dev/null
+++ b/arm64_lower_word_uhadd.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawHalvingAddSub struct {
+	spec        arm64HalvingAddSubSpec
+	arrangement arm64VectorArrangement
+	destination int
+	first       int
+	second      int
+}
+
+var arm64RawHalvingAddSubSpecs = map[uint32]arm64HalvingAddSubSpec{
+	0x0e200400: {signed: true},
+	0x2e200400: {},
+	0x0e201400: {signed: true, rounding: true},
+	0x2e201400: {rounding: true},
+	0x0e202400: {signed: true, subtract: true},
+	0x2e202400: {subtract: true},
+}
+
+func decodeARM64RawHalvingAddSub(word uint32) (arm64RawHalvingAddSub, bool) {
+	spec, ok := arm64RawHalvingAddSubSpecs[word&0xbf20fc00]
+	if !ok {
+		return arm64RawHalvingAddSub{}, false
+	}
+	size := int(word>>22) & 3
+	if size > 2 {
+		return arm64RawHalvingAddSub{}, false
+	}
+	bits := 8 << size
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	return arm64RawHalvingAddSub{
+		spec:        spec,
+		arrangement: arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits},
+		destination: int(word & 31),
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawHalvingAddSub(form arm64RawHalvingAddSub) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.arrangement, 0, false)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadRawARM64VectorOperand(form.second, form.arrangement, 0, false)
+	if err != nil {
+		return err
+	}
+	return c.lowerARM64VectorHalvingAddSubForm(
+		form.spec,
+		form.arrangement,
+		first,
+		second,
+		Reg(fmt.Sprintf("V%d", form.destination)),
+	)
+}
diff --git a/arm64_lower_word_uhadd_test.go b/arm64_lower_word_uhadd_test.go
new file mode 100644
index 000000000..bbe6cb901
--- /dev/null
+++ b/arm64_lower_word_uhadd_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUHADDForms = `
+TEXT rawuhaddforms(SB),$0-0
+	WORD $0x2e220420 // UHADD V0.8B, V1.8B, V2.8B
+	WORD $0x6e250483 // UHADD V3.16B, V4.16B, V5.16B
+	WORD $0x2e6804e6 // UHADD V6.4H, V7.4H, V8.4H
+	WORD $0x6e6b0549 // UHADD V9.8H, V10.8H, V11.8H
+	WORD $0x2eae05ac // UHADD V12.2S, V13.2S, V14.2S
+	WORD $0x6eb1060f // UHADD V15.4S, V16.4S, V17.4S
+	RET
+`
+
+func TestTranslateARM64RawUHADDCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUHADDForms, true)
+	file, err := Parse(ArchARM64, arm64RawUHADDForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawuhaddforms": {Name: "rawuhaddforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"lshr <8 x i16>", "lshr <16 x i16>",
+				"lshr <4 x i32>", "lshr <8 x i32>",
+				"lshr <2 x i64>", "lshr <4 x i64>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw UHADD lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-uhadd.ll", "arm64-raw-uhadd.o", ll)
+		})
+	}
+}
+
+func TestTranslateARM64RawHalvingAddSubCompleteAdvancedSIMDFamily(t *testing.T) {
+	families := []struct {
+		name string
+		base uint32
+	}{
+		{"SHADD", 0x0e200400},
+		{"UHADD", 0x2e200400},
+		{"SRHADD", 0x0e201400},
+		{"URHADD", 0x2e201400},
+		{"SHSUB", 0x0e202400},
+		{"UHSUB", 0x2e202400},
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawHalvingAddSubFamily(SB),$0-0\n")
+	for _, family := range families {
+		for size := 0; size < 3; size++ {
+			for q := 0; q < 2; q++ {
+				word := family.base | uint32(size)<<22 | uint32(q)<<30 | 31<<16 | 30<<5 | 29
+				fmt.Fprintf(&source, "\tWORD $%#08x // %s size=%d q=%d\n", word, family.name, size, q)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawHalvingAddSubFamily": {Name: "rawHalvingAddSubFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{" add <", " sub <", "sext <", "zext <", "ashr <", "lshr <", "trunc <"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw halving add/sub IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-halving-add-sub.ll", "arm64-raw-halving-add-sub.o", ir)
+		})
+	}
+}
+
+func TestARM64RawUHADDRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawuhadd(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x6ea10402 // UHADD V2.4S, V0.4S, V1.4S
+	VST1 [V2.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawuhadd": {
+				Name: "rawuhadd", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <limits.h>
+extern void rawuhadd(const uint32_t *, const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t a[4] = {UINT32_MAX, UINT32_MAX, 1, 4};
+  const uint32_t b[4] = {UINT32_MAX, 1, 2, 3};
+  const uint32_t want[4] = {UINT32_MAX, 2147483648u, 1, 3};
+  uint32_t got[4] = {0};
+  rawuhadd(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_uhadd", triple, ll, mainC, nil)
+}
+
+func TestARM64RawHalvingAddSubDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x0e203400, 0x2e203400, 0x6ee20420} { // Compare opcodes and reserved D2.
+		t.Run(fmt.Sprintf("%#08x", word), func(t *testing.T) {
+			if _, ok := decodeARM64RawHalvingAddSub(word); ok {
+				t.Fatalf("halving add/sub decoder claimed adjacent/reserved encoding %#08x", word)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_word_umlal.go b/arm64_lower_word_umlal.go
new file mode 100644
index 000000000..6bfcfc6ec
--- /dev/null
+++ b/arm64_lower_word_umlal.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawUMLAL struct {
+	highHalf    bool
+	source      arm64VectorArrangement
+	destination arm64VectorArrangement
+	destReg     int
+	first       int
+	second      int
+}
+
+func decodeARM64RawUMLAL(word uint32) (arm64RawUMLAL, bool) {
+	if word&0xbf20fc00 != 0x2e208000 {
+		return arm64RawUMLAL{}, false
+	}
+	size := int(word>>22) & 3
+	if size > 2 {
+		return arm64RawUMLAL{}, false
+	}
+	sourceBits := 8 << size
+	destinationLanes := 128 / (sourceBits * 2)
+	highHalf := word&(1<<30) != 0
+	sourceLanes := destinationLanes
+	if highHalf {
+		sourceLanes *= 2
+	}
+	return arm64RawUMLAL{
+		highHalf:    highHalf,
+		source:      arm64VectorArrangement{elementBits: sourceBits, lanes: sourceLanes},
+		destination: arm64VectorArrangement{elementBits: sourceBits * 2, lanes: destinationLanes},
+		destReg:     int(word & 31),
+		first:       int(word>>5) & 31,
+		second:      int(word>>16) & 31,
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawUMLAL(form arm64RawUMLAL) error {
+	op := Op("VUMLAL")
+	if form.highHalf {
+		op = "VUMLAL2"
+	}
+	sourceArrangement := arm64VectorArrangementName(form.source)
+	destinationArrangement := arm64VectorArrangementName(form.destination)
+	sourceReg := func(index int) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", index, sourceArrangement))}
+	}
+	ins := Instr{
+		Op:  op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", op),
+		Args: []Operand{
+			sourceReg(form.second),
+			sourceReg(form.first),
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destReg, destinationArrangement))},
+		},
+	}
+	ok, _, err := c.lowerARM64VectorWideningMultiply(op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_umlal_test.go b/arm64_lower_word_umlal_test.go
new file mode 100644
index 000000000..72032720f
--- /dev/null
+++ b/arm64_lower_word_umlal_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUMLALForms = `
+TEXT rawumlalforms(SB),$0-0
+	WORD $0x2e228020 // UMLAL  V0.8H, V1.8B, V2.8B
+	WORD $0x6e258083 // UMLAL2 V3.8H, V4.16B, V5.16B
+	WORD $0x2e6880e6 // UMLAL  V6.4S, V7.4H, V8.4H
+	WORD $0x6e6b8149 // UMLAL2 V9.4S, V10.8H, V11.8H
+	WORD $0x2eae81ac // UMLAL  V12.2D, V13.2S, V14.2S
+	WORD $0x6eb1820f // UMLAL2 V15.2D, V16.4S, V17.4S
+	RET
+`
+
+func TestTranslateARM64RawUMLALCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUMLALForms, true)
+	file, err := Parse(ArchARM64, arm64RawUMLALForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawumlalforms": {Name: "rawumlalforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"zext <8 x i8>", "zext <4 x i16>", "zext <2 x i32>",
+				"mul <8 x i16>", "mul <4 x i32>", "mul <2 x i64>", "add <",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw UMLAL lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-umlal.ll", "arm64-raw-umlal.o", ll)
+		})
+	}
+}
+
+func TestARM64RawUMLALRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawumlal(SB),$0-32
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD accumulator+16(FP), R2
+	MOVD out+24(FP), R3
+	VLD1 (R0), [V0.B16]
+	VLD1 (R1), [V1.B16]
+	VLD1 (R2), [V2.H8, V3.H8]
+	WORD $0x2e218002 // UMLAL  V2.8H, V0.8B, V1.8B
+	WORD $0x6e218003 // UMLAL2 V3.8H, V0.16B, V1.16B
+	VST1 [V2.H8, V3.H8], (R3)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawumlal": {
+				Name: "rawumlal", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawumlal(const uint8_t *, const uint8_t *, const uint16_t *, uint16_t *);
+int main(void) {
+  uint8_t a[16], b[16];
+  uint16_t accumulator[16], got[16] = {0};
+  for (int i = 0; i < 16; i++) {
+    a[i] = (uint8_t)(240+i);
+    b[i] = (uint8_t)(17-i);
+    accumulator[i] = (uint16_t)(65000+i);
+  }
+  rawumlal(a, b, accumulator, got);
+  for (int i = 0; i < 16; i++) {
+    uint16_t want = (uint16_t)(accumulator[i] + (uint16_t)a[i] * (uint16_t)b[i]);
+    if (got[i] != want) return i + 1;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_umlal", triple, ll, mainC, nil)
+}
+
+func TestARM64RawUMLALDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x0e228020, 0x2e22a020} { // SMLAL, UMLSL.
+		t.Run(fmt.Sprintf("%#08x", word), func(t *testing.T) {
+			if _, ok := decodeARM64RawUMLAL(word); ok {
+				t.Fatalf("UMLAL decoder claimed adjacent encoding %#08x", word)
+			}
+		})
+	}
+}
diff --git a/arm64_lower_word_umull.go b/arm64_lower_word_umull.go
new file mode 100644
index 000000000..5ac000fa5
--- /dev/null
+++ b/arm64_lower_word_umull.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawUMULL struct {
+	byElement   bool
+	highHalf    bool
+	source      arm64VectorArrangement
+	destination arm64VectorArrangement
+	destReg     int
+	first       int
+	second      int
+	element     int
+}
+
+func decodeARM64RawUMULL(word uint32) (arm64RawUMULL, bool) {
+	form := arm64RawUMULL{element: -1, highHalf: word&(1<<30) != 0}
+	switch {
+	case word&0xbf20fc00 == 0x2e20c000: // vector, three registers
+	case word&0xbf00f400 == 0x2f00a000: // vector, by element
+		form.byElement = true
+	default:
+		return arm64RawUMULL{}, false
+	}
+	size := int(word>>22) & 3
+	if size > 2 || form.byElement && size == 0 {
+		return arm64RawUMULL{}, false
+	}
+	sourceBits := 8 << size
+	destLanes := 128 / (sourceBits * 2)
+	sourceLanes := destLanes
+	if form.highHalf {
+		sourceLanes *= 2
+	}
+	form.source = arm64VectorArrangement{elementBits: sourceBits, lanes: sourceLanes}
+	form.destination = arm64VectorArrangement{elementBits: sourceBits * 2, lanes: destLanes}
+	form.destReg = int(word & 31)
+	form.first = int(word>>5) & 31
+	form.second = int(word>>16) & 31
+	if form.byElement {
+		form.second &= 15
+		l := int(word>>21) & 1
+		m := int(word>>20) & 1
+		h := int(word>>11) & 1
+		if sourceBits == 16 {
+			form.element = h<<2 | l<<1 | m
+		} else {
+			form.second |= m << 4
+			form.element = h<<1 | l
+		}
+	}
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawUMULL(form arm64RawUMULL) error {
+	first, err := c.loadRawARM64VectorOperand(form.first, form.source, 0, false)
+	if err != nil {
+		return err
+	}
+	if form.highHalf {
+		first = c.selectARM64VectorHighHalf(form.source, form.destination.lanes, first)
+	}
+	selected := arm64VectorArrangement{elementBits: form.source.elementBits, lanes: form.destination.lanes}
+	var second string
+	if form.byElement {
+		second, err = c.loadRawARM64VectorOperand(form.second, selected, form.element, true)
+	} else {
+		second, err = c.loadRawARM64VectorOperand(form.second, form.source, 0, false)
+		if err == nil && form.highHalf {
+			second = c.selectARM64VectorHighHalf(form.source, form.destination.lanes, second)
+		}
+	}
+	if err != nil {
+		return err
+	}
+	narrowType := fmt.Sprintf("<%d x i%d>", selected.lanes, selected.elementBits)
+	wideType := fmt.Sprintf("<%d x i%d>", form.destination.lanes, form.destination.elementBits)
+	wideFirst := c.newTmp()
+	wideSecond := c.newTmp()
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", wideFirst, narrowType, first, wideType)
+	fmt.Fprintf(c.b, "  %%%s = zext %s %s to %s\n", wideSecond, narrowType, second, wideType)
+	fmt.Fprintf(c.b, "  %%%s = mul %s %%%s, %%%s\n", product, wideType, wideFirst, wideSecond)
+	return c.storeRawARM64VectorResult(form.destReg, form.destination, "%"+product, false)
+}
diff --git a/arm64_lower_word_umull_test.go b/arm64_lower_word_umull_test.go
new file mode 100644
index 000000000..657f9ffcb
--- /dev/null
+++ b/arm64_lower_word_umull_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUMULLForms = `
+TEXT rawumullforms(SB),$0-0
+	WORD $0x2e22c020 // UMULL V0.8H, V1.8B, V2.8B
+	WORD $0x6e25c083 // UMULL2 V3.8H, V4.16B, V5.16B
+	WORD $0x2e68c0e6 // UMULL V6.4S, V7.4H, V8.4H
+	WORD $0x6e6bc149 // UMULL2 V9.4S, V10.8H, V11.8H
+	WORD $0x2eaec1ac // UMULL V12.2D, V13.2S, V14.2S
+	WORD $0x6eb1c20f // UMULL2 V15.2D, V16.4S, V17.4S
+	WORD $0x2f74aa72 // UMULL V18.4S, V19.4H, V4.H[7]
+	WORD $0x6f75aab4 // UMULL2 V20.4S, V21.8H, V5.H[7]
+	WORD $0x2fb8aaf6 // UMULL V22.2D, V23.2S, V24.S[3]
+	WORD $0x6fbbab59 // UMULL2 V25.2D, V26.4S, V27.S[3]
+	RET
+`
+
+func TestTranslateARM64RawUMULLCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUMULLForms, true)
+	file, err := Parse(ArchARM64, arm64RawUMULLForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawumullforms": {Name: "rawumullforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				"zext <8 x i8>", "zext <4 x i16>", "zext <2 x i32>",
+				"mul <8 x i16>", "mul <4 x i32>", "mul <2 x i64>",
+				"extractelement <8 x i16>", "extractelement <4 x i32>",
+			} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw UMULL lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-umull.ll", "arm64-raw-umull.o", ll)
+		})
+	}
+}
+
+func TestARM64RawUMULLRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawumull(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x2ea1c01e // UMULL V30.2D, V0.2S, V1.2S
+	WORD $0x6ea1c01f // UMULL2 V31.2D, V0.4S, V1.4S
+	VST1 [V30.D2, V31.D2], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawumull": {
+				Name: "rawumull", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawumull(const uint32_t *, const uint32_t *, uint64_t *);
+int main(void) {
+  const uint32_t a[4] = {0xffffffffu, 2, 3, 0x80000000u};
+  const uint32_t b[4] = {2, 0xffffffffu, 7, 2};
+  uint64_t got[4] = {0};
+  const uint64_t want[4] = {UINT64_C(0x1fffffffe), UINT64_C(0x1fffffffe), 21, UINT64_C(0x100000000)};
+  rawumull(a, b, got);
+  for (int i = 0; i < 4; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_umull", triple, ll, mainC, nil)
+}
+
+func TestARM64RawUMULLDecoderRejectsAdjacentSMULLEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawUMULL(0x0e22c020); ok {
+		t.Fatal("UMULL decoder claimed adjacent SMULL encoding")
+	}
+}
diff --git a/arm64_lower_word_ushll.go b/arm64_lower_word_ushll.go
new file mode 100644
index 000000000..fd46a3807
--- /dev/null
+++ b/arm64_lower_word_ushll.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawUSHLL struct {
+	highHalf               bool
+	shift                  int
+	sourceArrangement      arm64VectorArrangement
+	destinationArrangement arm64VectorArrangement
+	source                 int
+	destination            int
+}
+
+func decodeARM64RawUSHLL(word uint32) (arm64RawUSHLL, bool) {
+	if word&0xbf80fc00 != 0x2f00a400 {
+		return arm64RawUSHLL{}, false
+	}
+	encodedImmediate := int(word>>16) & 0x7f
+	bits := 0
+	switch {
+	case encodedImmediate >= 32 && encodedImmediate < 64:
+		bits = 32
+	case encodedImmediate >= 16:
+		bits = 16
+	case encodedImmediate >= 8:
+		bits = 8
+	default:
+		return arm64RawUSHLL{}, false
+	}
+	shift := encodedImmediate - bits
+	destinationLanes := 128 / (bits * 2)
+	highHalf := word&(1<<30) != 0
+	sourceLanes := destinationLanes
+	if highHalf {
+		sourceLanes *= 2
+	}
+	return arm64RawUSHLL{
+		highHalf:               highHalf,
+		shift:                  shift,
+		sourceArrangement:      arm64VectorArrangement{elementBits: bits, lanes: sourceLanes},
+		destinationArrangement: arm64VectorArrangement{elementBits: bits * 2, lanes: destinationLanes},
+		source:                 int(word>>5) & 31,
+		destination:            int(word & 31),
+	}, true
+}
+
+func (c *arm64Ctx) lowerRawUSHLL(form arm64RawUSHLL) error {
+	op := Op("VUSHLL")
+	if form.highHalf {
+		op = "VUSHLL2"
+	}
+	ins := Instr{
+		Op:  op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", op),
+		Args: []Operand{
+			{Kind: OpImm, Imm: int64(form.shift)},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.source, arm64VectorArrangementName(form.sourceArrangement)))},
+			{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", form.destination, arm64VectorArrangementName(form.destinationArrangement)))},
+		},
+	}
+	ok, _, err := c.lowerARM64WideningShift(op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_ushll_test.go b/arm64_lower_word_ushll_test.go
new file mode 100644
index 000000000..38747ec50
--- /dev/null
+++ b/arm64_lower_word_ushll_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUSHLLForms = `
+TEXT rawushllforms(SB),$0-0
+	WORD $0x2f08a420 // USHLL  V0.8H, V1.8B, #0
+	WORD $0x2f0fa462 // USHLL  V2.8H, V3.8B, #7
+	WORD $0x2f10a4a4 // USHLL  V4.4S, V5.4H, #0
+	WORD $0x2f1fa4e6 // USHLL  V6.4S, V7.4H, #15
+	WORD $0x2f20a528 // USHLL  V8.2D, V9.2S, #0
+	WORD $0x2f3fa56a // USHLL  V10.2D, V11.2S, #31
+	WORD $0x6f08a5ac // USHLL2 V12.8H, V13.16B, #0
+	WORD $0x6f0fa5ee // USHLL2 V14.8H, V15.16B, #7
+	WORD $0x6f10a630 // USHLL2 V16.4S, V17.8H, #0
+	WORD $0x6f1fa672 // USHLL2 V18.4S, V19.8H, #15
+	WORD $0x6f20a6b4 // USHLL2 V20.2D, V21.4S, #0
+	WORD $0x6f3fa6f6 // USHLL2 V22.2D, V23.4S, #31
+	RET
+`
+
+func TestTranslateARM64RawUSHLLCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUSHLLForms, true)
+	file, err := Parse(ArchARM64, arm64RawUSHLLForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawushllforms": {Name: "rawushllforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"zext <8 x i8>", "zext <4 x i16>", "zext <2 x i32>", "shl <8 x i16>", "shl <4 x i32>", "shl <2 x i64>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("ARM64 raw USHLL lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-ushll.ll", "arm64-raw-ushll.o", ll)
+		})
+	}
+}
+
+func TestARM64RawUSHLLDecoderCoversEveryImmediate(t *testing.T) {
+	for _, highHalf := range []bool{false, true} {
+		for _, bits := range []int{8, 16, 32} {
+			for shift := 0; shift < bits; shift++ {
+				word := uint32(0x2f00a400) | uint32(bits+shift)<<16
+				if highHalf {
+					word |= 1 << 30
+				}
+				form, ok := decodeARM64RawUSHLL(word)
+				if !ok || form.sourceArrangement.elementBits != bits || form.shift != shift || form.highHalf != highHalf {
+					t.Fatalf("decode USHLL high=%v bits=%d shift=%d: form=%#v ok=%v", highHalf, bits, shift, form, ok)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawUSHLLRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawushll(SB),$0-16
+	MOVD in+0(FP), R0
+	MOVD out+8(FP), R1
+	VLD1 (R0), [V11.S2]
+	WORD $0x2f38a57e // USHLL V30.2D, V11.2S, #24
+	VST1 [V30.D2], (R1)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawushll": {
+				Name: "rawushll", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawushll(const uint32_t *, uint64_t *);
+int main(void) {
+  const uint32_t in[2] = {0xffffffffu, 0x12345678u};
+  const uint64_t want[2] = {0x00ffffffff000000ull, 0x0012345678000000ull};
+  uint64_t got[2] = {0};
+  rawushll(in, got);
+  for (int i = 0; i < 2; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_ushll", triple, ll, mainC, nil)
+}
+
+func TestARM64RawUSHLLDecoderRejectsAdjacentSSHLL(t *testing.T) {
+	if _, ok := decodeARM64RawUSHLL(0x0f08a420); ok {
+		t.Fatal("USHLL decoder claimed adjacent SSHLL encoding")
+	}
+}
diff --git a/arm64_lower_word_usubl_test.go b/arm64_lower_word_usubl_test.go
new file mode 100644
index 000000000..80389dc5f
--- /dev/null
+++ b/arm64_lower_word_usubl_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawVUSUBLForms = `TEXT vusublwords(SB),$0-0
+	WORD $0x2E302094 // USUBL V20.8H, V4.8B, V16.8B
+	WORD $0x6E302098 // USUBL2 V24.8H, V4.16B, V16.16B
+	WORD $0x2E602000 // USUBL V0.4S, V0.4H, V0.4H
+	WORD $0x6E602000 // USUBL2 V0.4S, V0.8H, V0.8H
+	WORD $0x2EA02000 // USUBL V0.2D, V0.2S, V0.2S
+	WORD $0x6EA02000 // USUBL2 V0.2D, V0.4S, V0.4S
+	RET
+`
+
+func TestTranslateARM64RawVUSUBLForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawVUSUBLForms, true)
+	file, err := Parse(ArchARM64, arm64RawVUSUBLForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"vusublwords": {Name: "vusublwords", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vusubl.ll", "arm64-vusubl.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_uzp.go b/arm64_lower_word_uzp.go
new file mode 100644
index 000000000..2e9acdbe9
--- /dev/null
+++ b/arm64_lower_word_uzp.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawUZP struct {
+	op          Op
+	arrangement arm64VectorArrangement
+	destination int
+	first       int
+	second      int
+}
+
+func decodeARM64RawUZP(word uint32) (arm64RawUZP, bool) {
+	form := arm64RawUZP{}
+	switch word & 0xbf20fc00 {
+	case 0x0e001800:
+		form.op = "VUZP1"
+	case 0x0e005800:
+		form.op = "VUZP2"
+	default:
+		return arm64RawUZP{}, false
+	}
+	size := int(word>>22) & 3
+	vectorBits := 64
+	if word&(1<<30) != 0 {
+		vectorBits = 128
+	}
+	if size == 3 && vectorBits != 128 {
+		return arm64RawUZP{}, false
+	}
+	bits := 8 << size
+	form.arrangement = arm64VectorArrangement{elementBits: bits, lanes: vectorBits / bits}
+	form.destination = int(word & 31)
+	form.first = int(word>>5) & 31
+	form.second = int(word>>16) & 31
+	return form, true
+}
+
+func (c *arm64Ctx) lowerRawUZP(form arm64RawUZP) error {
+	arrangement := arm64VectorArrangementName(form.arrangement)
+	reg := func(index int) Operand {
+		return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("V%d.%s", index, arrangement))}
+	}
+	// The existing Plan 9 lowerer takes Vm, Vn, Vd; raw encoding fields are
+	// named according to the architectural Vd, Vn, Vm order.
+	ins := Instr{
+		Op:  form.op,
+		Raw: fmt.Sprintf("decoded ARM64 WORD as %s", form.op),
+		Args: []Operand{
+			reg(form.second),
+			reg(form.first),
+			reg(form.destination),
+		},
+	}
+	ok, _, err := c.lowerARM64VectorPermute(form.op, ins)
+	if !ok && err == nil {
+		return fmt.Errorf("arm64 raw %s decoder reached no semantic lowerer", form.op)
+	}
+	return err
+}
diff --git a/arm64_lower_word_uzp_test.go b/arm64_lower_word_uzp_test.go
new file mode 100644
index 000000000..33e15aeaf
--- /dev/null
+++ b/arm64_lower_word_uzp_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawUZPForms = `
+TEXT rawuzpforms(SB),$0-0
+	WORD $0x0e021820 // UZP1 V0.8B, V1.8B, V2.8B
+	WORD $0x4e051883 // UZP1 V3.16B, V4.16B, V5.16B
+	WORD $0x0e4818e6 // UZP1 V6.4H, V7.4H, V8.4H
+	WORD $0x4e4b1949 // UZP1 V9.8H, V10.8H, V11.8H
+	WORD $0x0e8e19ac // UZP1 V12.2S, V13.2S, V14.2S
+	WORD $0x4e911a0f // UZP1 V15.4S, V16.4S, V17.4S
+	WORD $0x4ed41a72 // UZP1 V18.2D, V19.2D, V20.2D
+	WORD $0x0e025820 // UZP2 V0.8B, V1.8B, V2.8B
+	WORD $0x4e055883 // UZP2 V3.16B, V4.16B, V5.16B
+	WORD $0x0e4858e6 // UZP2 V6.4H, V7.4H, V8.4H
+	WORD $0x4e4b5949 // UZP2 V9.8H, V10.8H, V11.8H
+	WORD $0x0e8e59ac // UZP2 V12.2S, V13.2S, V14.2S
+	WORD $0x4e915a0f // UZP2 V15.4S, V16.4S, V17.4S
+	WORD $0x4ed45a72 // UZP2 V18.2D, V19.2D, V20.2D
+	RET
+`
+
+func TestTranslateARM64RawUZPCompleteAdvancedSIMDFormats(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUZPForms, true)
+	file, err := Parse(ArchARM64, arm64RawUZPForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple, Goarch: "arm64",
+				Sigs: map[string]FuncSig{"rawuzpforms": {Name: "rawuzpforms", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ll, "shufflevector"); got < 14 {
+				t.Fatalf("raw UZP shuffle count = %d, want at least 14:\n%s", got, ll)
+			}
+			for _, want := range []string{"i32 0, i32 2", "i32 1, i32 3"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("raw UZP forms omitted %q mask:\n%s", want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-uzp.ll", "arm64-raw-uzp.o", ll)
+		})
+	}
+}
+
+func TestARM64RawUZPRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawuzp(SB),$0-24
+	MOVD n+0(FP), R0
+	MOVD m+8(FP), R1
+	MOVD out+16(FP), R2
+	VLD1 (R0), [V0.S4]
+	VLD1 (R1), [V1.S4]
+	WORD $0x4e811802 // UZP1 V2.4S, V0.4S, V1.4S
+	WORD $0x4e815803 // UZP2 V3.4S, V0.4S, V1.4S
+	VST1 [V2.S4, V3.S4], (R2)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple, Goarch: "arm64",
+		Sigs: map[string]FuncSig{
+			"rawuzp": {
+				Name: "rawuzp", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawuzp(const uint32_t *, const uint32_t *, uint32_t *);
+int main(void) {
+  const uint32_t n[4] = {0, 1, 2, 3};
+  const uint32_t m[4] = {10, 11, 12, 13};
+  const uint32_t want[8] = {0, 2, 10, 12, 1, 3, 11, 13};
+  uint32_t got[8] = {0};
+  rawuzp(n, m, got);
+  for (int i = 0; i < 8; i++) if (got[i] != want[i]) return i + 1;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_uzp", triple, ll, mainC, nil)
+}
+
+func TestARM64RawUZPDecoderRejectsAdjacentZIPEncoding(t *testing.T) {
+	if _, ok := decodeARM64RawUZP(0x4e813802); ok {
+		t.Fatal("UZP decoder claimed adjacent ZIP encoding")
+	}
+}
diff --git a/arm64_lower_word_vnot_test.go b/arm64_lower_word_vnot_test.go
new file mode 100644
index 000000000..6a6482991
--- /dev/null
+++ b/arm64_lower_word_vnot_test.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import "testing"
+
+const arm64RawVMVNForms = `TEXT vmvnraw(SB),$0-0
+	WORD $0x2E2058E5 // VMVN V7.B8, V5.B8
+	WORD $0x6E205A7E // VMVN V19.B16, V30.B16
+	RET
+`
+
+func TestTranslateARM64RawVMVNGoAliasForms(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawVMVNForms, true)
+	file, err := Parse(ArchARM64, arm64RawVMVNForms)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"vmvnraw": {Name: "vmvnraw", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-vnot.ll", "arm64-vnot.o", ir)
+		})
+	}
+}
diff --git a/arm64_lower_word_vrshrn_test.go b/arm64_lower_word_vrshrn_test.go
new file mode 100644
index 000000000..6698f3d25
--- /dev/null
+++ b/arm64_lower_word_vrshrn_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64RawVRSHRNCompleteAdvancedSIMDFormats(t *testing.T) {
+	// x/arch prints the architectural RSHRN/RSHRN2 encodings in Go syntax as
+	// VRSHRN/VRSHRN2. Go 1.27's assembler table exposes VSHRN/VSHRN2 (the
+	// non-rounding form), so these are deliberately exercised through WORD.
+	const source = `TEXT ·rawVRSHRNForms(SB), $0-0
+	WORD $0x0F0B8C01 // VRSHRN $5, V0.H8, V1.B8
+	WORD $0x0F118C44 // VRSHRN $15, V2.S4, V4.H4
+	WORD $0x0F218C57 // VRSHRN $31, V2.D2, V23.S2
+	WORD $0x4F088C63 // VRSHRN2 $8, V3.H8, V3.B16
+	WORD $0x4F148C85 // VRSHRN2 $12, V4.S4, V5.H8
+	WORD $0x4F2C8CA6 // VRSHRN2 $20, V5.D2, V6.S4
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			Sigs: map[string]FuncSig{
+				"rawVRSHRNForms": {Name: "rawVRSHRNForms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{"ashr <", "add <", "trunc <", "insertelement <"} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("%s VRSHRN IR omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		compileLLVMToObject(t, llc, triple, "arm64-raw-vrshrn.ll", "arm64-raw-vrshrn.o", ll)
+	}
+}
+
+func TestARM64RawVRSHRNDecoderCoversEveryGoNarrowingFormat(t *testing.T) {
+	// The raw decoder must retain all register fields and every immediate in
+	// the same H8->B8, S4->H4, and D2->S2 rows used by Go's AVSHRN optab.
+	for _, highHalf := range []bool{false, true} {
+		for _, destinationBits := range []int{8, 16, 32} {
+			for shift := 1; shift <= destinationBits; shift++ {
+				encodedImmediate := uint32(2*destinationBits - shift)
+				for source := 0; source < 32; source++ {
+					for destination := 0; destination < 32; destination++ {
+						word := uint32(0x0f008c00) | encodedImmediate<<16 | uint32(source<<5|destination)
+						if highHalf {
+							word |= 1 << 30
+						}
+						decoded, err := decodeARM64RawWordInstruction(Instr{
+							Op:   OpWORD,
+							Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+						})
+						if err != nil {
+							t.Fatalf("decode VRSHRN high=%v destinationBits=%d shift=%d source=%d destination=%d word=%#08x: %v", highHalf, destinationBits, shift, source, destination, word, err)
+						}
+						wantOp := Op("VRSHRN")
+						if highHalf {
+							wantOp = "VRSHRN2"
+						}
+						if decoded.Op != wantOp || len(decoded.Args) != 3 || decoded.Args[0].Kind != OpImm || decoded.Args[0].Imm != int64(shift) {
+							t.Fatalf("decode VRSHRN high=%v destinationBits=%d shift=%d source=%d destination=%d: %#v", highHalf, destinationBits, shift, source, destination, decoded)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_lower_word_za_zero.go b/arm64_lower_word_za_zero.go
new file mode 100644
index 000000000..e7f9a6643
--- /dev/null
+++ b/arm64_lower_word_za_zero.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func decodeARM64RawZAZero(word uint32) (uint8, bool) {
+	if word&^uint32(0xff) != 0xc0080000 {
+		return 0, false
+	}
+	return uint8(word), true
+}
+
+func (c *arm64Ctx) lowerRawZAZero(mask uint8) error {
+	tiles := make([]string, 0, 8)
+	for tile := 0; tile < 8; tile++ {
+		if mask&(1<<tile) != 0 {
+			tiles = append(tiles, fmt.Sprintf("za%d.d", tile))
+		}
+	}
+	mnemonic := "zero {" + strings.Join(tiles, ", ") + "}"
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q()\n", mnemonic, "~{memory}")
+	return nil
+}
diff --git a/arm64_lower_word_za_zero_test.go b/arm64_lower_word_za_zero_test.go
new file mode 100644
index 000000000..59633b61e
--- /dev/null
+++ b/arm64_lower_word_za_zero_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64RawZAZeroDecoderCompleteArchitectureFamily(t *testing.T) {
+	for mask := 0; mask < 256; mask++ {
+		word := uint32(0xc0080000 | mask)
+		got, ok := decodeARM64RawZAZero(word)
+		if !ok {
+			t.Fatalf("decoder rejected %#08x", word)
+		}
+		if got != uint8(mask) {
+			t.Fatalf("decode %#08x = %#02x, want %#02x", word, got, mask)
+		}
+	}
+}
+
+func TestTranslateARM64RawZAZeroCompleteArchitectureFamily(t *testing.T) {
+	const source = `
+TEXT rawZAZeroFamily(SB),$0-0
+	WORD $0xc0080000 // ZERO {}
+	WORD $0xc0080001 // ZERO {ZA0.D}
+	WORD $0xc0080055 // ZERO {ZA0.H}
+	WORD $0xc00800ff // ZERO {ZA}
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawZAZeroFamily": {Name: "rawZAZeroFamily", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{
+				`asm sideeffect "zero {}"`,
+				`asm sideeffect "zero {za0.d}"`,
+				`asm sideeffect "zero {za0.d, za2.d, za4.d, za6.d}"`,
+				`asm sideeffect "zero {za0.d, za1.d, za2.d, za3.d, za4.d, za5.d, za6.d, za7.d}"`,
+				`"target-features"="+sme"`,
+			} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw ZA ZERO IR omitted %q:\n%s", want, ir)
+				}
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-za-zero.ll", "arm64-raw-za-zero.o", ir)
+		})
+	}
+}
+
+func TestARM64RawZAZeroDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0xc0080100,
+		0xc0090001,
+		0xc0040001,
+		0xd5080001,
+	} {
+		if _, ok := decodeARM64RawZAZero(word); ok {
+			t.Fatalf("ZA ZERO decoder accepted adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm64_machine_availability.go b/arm64_machine_availability.go
new file mode 100644
index 000000000..0df7e646b
--- /dev/null
+++ b/arm64_machine_availability.go
@@ -0,0 +1,552 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Availability is distinct from the code-address/alias proof. Typed Go calls
+// transfer only declared argument/result leaves, not a hidden native machine
+// state. Record real lowering reads/writes instead of guessing opcode effects.
+type arm64MachineEffect struct {
+	register          string
+	copyFrom          string
+	width             int
+	vectorOffset      int
+	vectorSpan        bool
+	write             bool
+	call              *ARM64GoRegisterABI
+	opaque            bool
+	store             bool
+	source            string
+	unavailable       bool          // Original source encoding/layout did not supply these bits.
+	nzcv              arm64FlagMask // Virtual flag bank, not original Go GP scratch.
+	noScratchObserver bool          // Complete original and normalized same-file RET-only call source.
+}
+
+type arm64MachineBlock struct {
+	name       string
+	effects    []arm64MachineEffect
+	successors []string
+}
+
+type arm64MachineAvailability struct {
+	flagsOnly     bool // no machine-entry grant, GP effects or duplicate CFG
+	blocks        []arm64MachineBlock
+	current       int
+	suspended     int
+	skipReads     bool
+	source        string
+	entry         *ARM64GoRegisterABI
+	closure       *ARM64ClosureABI
+	entryError    error
+	sourceR20     bool
+	used          bool
+	nativeIR      map[int]arm64MachineNativeProof
+	sourceScratch bool
+}
+
+type arm64MachineNativeProof struct {
+	line    string
+	store   bool
+	syscall *arm64SyscallIRProof
+}
+
+// A validated lowerer can prove that one emitted native instruction has no
+// additional virtual GP/NZCV/data-store effects. Its actual typed operands are
+// still recorded by loadReg/storeReg. Bind the proof to the exact emitted IR
+// line; other callouts, including another callout in the same source
+// instruction, remain opaque. A compiler memory barrier is not a data store.
+func (c *arm64Ctx) emitMachineNeutralNativeIR(format string, args ...any) {
+	c.emitMachineNativeIR(false, format, args...)
+}
+
+// Store-native IR has a separate continuation memory proof. It is not a
+// neutral instruction: callers of this helper must validate the address
+// sources, and the matching control transfer must invalidate affected cells.
+func (c *arm64Ctx) emitMachineStoreNativeIR(format string, args ...any) {
+	c.emitMachineNativeIR(true, format, args...)
+}
+
+func (c *arm64Ctx) emitMachineNativeIR(store bool, format string, args ...any) {
+	start := c.b.Len()
+	fmt.Fprintf(c.b, format, args...)
+	if flow := c.machineAvailability; flow != nil {
+		if flow.nativeIR == nil {
+			flow.nativeIR = make(map[int]arm64MachineNativeProof)
+		}
+		flow.nativeIR[start] = arm64MachineNativeProof{line: c.b.String()[start:], store: store}
+	}
+}
+
+const arm64WholeScalableRegister = 1 << 20
+
+func newARM64MachineAvailability(c *arm64Ctx) *arm64MachineAvailability {
+	needed := c.goRegisterEntry || c.privateRegisterEntry || c.checkedR20Entry || c.checkedABI0Tail || c.nanosleepInput != nil
+	sourceScratch := false
+	for _, block := range c.blocks {
+		for _, instruction := range block.instrs {
+			ins := arm64ControlDecode(instruction)
+			if form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins); handled && err == nil && form.scratch && !form.scratchKnown {
+				sourceScratch = true
+			}
+			op := arm64ControlOp(ins)
+			if op == "SVC" {
+				// Even an object-only entry must not read a secondary result or
+				// flags explicitly unavailable from this typed bridge.
+				sourceScratch = true
+			}
+			if (op != "CALL" && op != "BL") || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			sym := strings.TrimSuffix(ins.Args[0].Sym, "(SB)")
+			if strings.HasSuffix(sym, "<ABIInternal>") && c.sigs[c.resolve(sym)].ARM64GoRegisterABI != nil {
+				needed = true
+			}
+		}
+	}
+	if !needed && !sourceScratch {
+		// The existing ordered flag CFG still needs exact known/unknown native
+		// callout observations. Do not build a second CFG or record unused GP
+		// and vector effects for these ordinary object-only functions.
+		return &arm64MachineAvailability{flagsOnly: true}
+	}
+	flow := &arm64MachineAvailability{blocks: make([]arm64MachineBlock, len(c.blocks)+1)}
+	flow.sourceScratch = sourceScratch
+	for i, block := range c.blocks {
+		flow.blocks[i].name = block.name
+	}
+	flow.blocks[len(c.blocks)].name = c.localControl.outer
+	if c.goRegisterEntry {
+		flow.entry, flow.used = c.sig.ARM64GoRegisterABI, true
+		flow.closure = c.sig.ARM64ClosureABI
+	} else if c.privateRegisterEntry || c.checkedR20Entry || c.checkedABI0Tail || c.nanosleepInput != nil {
+		// Explicit empty presence: only SP and the real caller LR are
+		// available at an ABI0 entry. FP loads define the data registers.
+		flow.entry, flow.used = &ARM64GoRegisterABI{}, true
+		flow.sourceR20 = c.sourceFrameR20
+		if len(c.sig.ArgRegs) != 0 {
+			// Retain custom ArgRegs' scalar len/type contract, rather than
+			// applying standard Go recursive ABIInternal assignment to it.
+			if len(c.sig.ArgRegs) != len(c.sig.Args) {
+				flow.entryError = arm64GoABIContext("custom private root entry has incomplete ArgRegs")
+			} else {
+				for i, reg := range c.sig.ArgRegs {
+					if arm64MachineScalarWidth(c.sig.Args[i]) == 0 {
+						flow.entryError = arm64GoABIContext("custom private root entry has unknown register width")
+					}
+					flow.entry.Params = append(flow.entry.Params, ARM64GoRegisterValue{Register: reg, Type: c.sig.Args[i]})
+				}
+			}
+		}
+	}
+	return flow
+}
+
+func (c *arm64Ctx) recordMachineUnavailable(reg Reg) {
+	if flow := c.machineAvailability; flow != nil && !flow.flagsOnly {
+		nzcv := c.arm64FlagSlotMask(string(reg))
+		width := 64
+		if nzcv != 0 {
+			width = 1
+		}
+		flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects,
+			arm64MachineEffect{register: arm64MachineRegister(reg), width: width, unavailable: true, nzcv: nzcv, source: flow.source})
+	}
+}
+
+func arm64MachineRegister(reg Reg) string {
+	if index, ok := arm64ParseFReg(reg); ok {
+		return fmt.Sprintf("V%d", index)
+	}
+	if index, ok := arm64ParseVReg(reg); ok {
+		return fmt.Sprintf("V%d", index)
+	}
+	if index, ok := arm64ParseZReg(reg); ok {
+		return fmt.Sprintf("V%d", index)
+	}
+	if reg == "RSP" {
+		return string(SP)
+	}
+	return string(reg)
+}
+
+func (c *arm64Ctx) recordMachineRegister(reg Reg, width int, write bool) {
+	flow := c.machineAvailability
+	if flow == nil || flow.flagsOnly || flow.suspended != 0 || reg == ZR || (!write && flow.skipReads) {
+		return
+	}
+	flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+		register: arm64MachineRegister(reg), width: width, write: write, nzcv: c.arm64FlagSlotMask(string(reg)), source: flow.source,
+	})
+}
+
+func (c *arm64Ctx) recordMachineCall(abi *ARM64GoRegisterABI, sourceSymbol string) {
+	// Neither an ordinary typed call result nor an unknown native call supplies
+	// caller NZCV. Scheduler no-op hooks never enter this call boundary.
+	c.invalidateARM64Flags(arm64FlagAll)
+	if flow := c.machineAvailability; flow != nil && !flow.flagsOnly {
+		if abi == nil {
+			flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+				opaque: true, source: flow.source,
+				noScratchObserver: c.sourceCallDoesNotObserveScratch(sourceSymbol),
+			})
+		} else {
+			flow.used = true
+			flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{call: abi, source: flow.source})
+		}
+	}
+}
+
+func (c *arm64Ctx) loadRegisterWidth(reg Reg, width int) (string, error) {
+	if width <= 0 {
+		return "", arm64GoABIContext("unrecognized typed register read width %d", width)
+	}
+	c.recordMachineRegister(reg, width, false)
+	if flow := c.machineAvailability; flow != nil {
+		flow.suspended++
+		defer func() { flow.suspended-- }()
+	}
+	return c.loadReg(reg)
+}
+
+func arm64MachineLeafWidth(slot ARM64GoRegisterValue) int {
+	return arm64MachineScalarWidth(slot.Type)
+}
+
+func arm64MachineScalarWidth(typ LLVMType) int {
+	switch typ {
+	case I1:
+		return 1
+	case I8:
+		return 8
+	case I16:
+		return 16
+	case I32, "float":
+		return 32
+	case I64, Ptr, "double":
+		return 64
+	default:
+		return 0
+	}
+}
+
+// A full-register move transports unspecified bits without making them
+// available to a typed caller. Its reaching low-bit guarantee is unchanged.
+// This hook is used only after the scalar move lowerer validates both operands.
+func (c *arm64Ctx) lowerMachineRegisterCopy(src, dst Reg) error {
+	if flow := c.machineAvailability; flow != nil && !flow.flagsOnly {
+		flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+			register: arm64MachineRegister(dst), copyFrom: arm64MachineRegister(src),
+			width: 64, source: flow.source,
+		})
+		flow.suspended++
+		defer func() { flow.suspended-- }()
+	}
+	value, err := c.loadReg(src)
+	if err != nil {
+		return err
+	}
+	return c.storeReg(dst, value)
+}
+
+// Only proven register XOR zero idioms need no input value. Their ordinary
+// typed lowerer still validates the complete operand grammar. Never infer this
+// for memory operands, or for unequal vector views/lanes.
+func arm64MachineZeroInputs(ins Instr) bool {
+	ins = arm64ControlDecode(ins)
+	if ins.Op != "EOR" && ins.Op != "EORW" && ins.Op != "VEOR" {
+		return false
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return false
+	}
+	return ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg && ins.Args[0].Reg == ins.Args[1].Reg
+}
+
+type arm64MachineState struct {
+	active  bool
+	values  map[string]int
+	vectors map[string]arm64MachineVectorDefinition
+}
+
+func arm64MachineBoundary(slots []ARM64GoRegisterValue) arm64MachineState {
+	state := arm64MachineState{active: true, values: map[string]int{string(SP): 64, "R30": 64}}
+	for _, slot := range slots {
+		state.values[arm64MachineRegister(slot.Register)] = arm64MachineLeafWidth(slot)
+	}
+	return state
+}
+
+func (state arm64MachineState) clone() arm64MachineState {
+	out := arm64MachineState{active: state.active, values: make(map[string]int, len(state.values))}
+	for reg, width := range state.values {
+		out.values[reg] = width
+	}
+	if state.vectors != nil {
+		out.vectors = make(map[string]arm64MachineVectorDefinition, len(state.vectors))
+		for reg, definition := range state.vectors {
+			out.vectors[reg] = definition
+		}
+	}
+	return out
+}
+
+// Join intersects the defined vector bits and takes the minimum GP prefix
+// width on every incoming active path. An unrestricted path adds no promise.
+func (state *arm64MachineState) merge(other arm64MachineState) bool {
+	if !other.active {
+		return false
+	}
+	if !state.active {
+		*state = other.clone()
+		return true
+	}
+	changed := false
+	for reg, width := range state.values {
+		if _, vector := arm64ParseVReg(Reg(reg)); vector {
+			before := state.vectorDefinition(reg)
+			next := other.vectorDefinition(reg)
+			next.low &= before.low
+			next.high &= before.high
+			next.scalable = next.scalable && before.scalable
+			if next != before {
+				state.setVectorDefinition(reg, next)
+				changed = true
+			}
+			continue
+		}
+		if next := other.values[reg]; next < width {
+			state.values[reg] = next
+			changed = true
+		}
+	}
+	return changed
+}
+
+func (flow *arm64MachineAvailability) validate() error {
+	if flow == nil {
+		return nil
+	}
+	if err := flow.validateSourceScratch(); err != nil {
+		return err
+	}
+	if !flow.used {
+		return nil
+	}
+	if flow.entryError != nil {
+		return flow.entryError
+	}
+	indices := make(map[string]int, len(flow.blocks))
+	for i, block := range flow.blocks {
+		indices[block.name] = i
+	}
+	entry := arm64MachineState{values: make(map[string]int)}
+	if flow.entry != nil {
+		entry = arm64MachineBoundary(flow.entry.Params)
+	}
+	if flow.closure != nil {
+		entry.values[string(flow.closure.ContextRegister)] = 64
+	}
+	if flow.sourceR20 {
+		entry.values["R20"] = 64
+	}
+	before := make([]*arm64MachineState, len(flow.blocks))
+	before[0] = &entry
+	queue, queued := []int{0}, make([]bool, len(flow.blocks))
+	queued[0] = true
+	for next := 0; next < len(queue); next++ {
+		index := queue[next]
+		queued[index] = false
+		state := before[index].clone()
+		block := flow.blocks[index]
+		for _, effect := range block.effects {
+			if effect.call != nil {
+				state = arm64MachineBoundary(effect.call.Results)
+				continue
+			}
+			if !state.active {
+				continue
+			}
+			if effect.unavailable {
+				state.values[effect.register] = 0
+				delete(state.vectors, effect.register)
+				continue
+			}
+			if effect.opaque {
+				return arm64GoABIContext("native/raw effects need a complete machine-state contract at %q", effect.source)
+			}
+			if effect.store {
+				// The source continuation analysis, not GP availability, owns
+				// memory/return-link provenance. This effect is explicit so a
+				// validated store cannot silently acquire a neutral proof.
+				continue
+			}
+			if effect.vectorSpan {
+				if err := state.applyVectorSpan(effect); err != nil {
+					return err
+				}
+				continue
+			}
+			if effect.copyFrom != "" {
+				width := state.values[effect.copyFrom]
+				if effect.copyFrom == string(ZR) {
+					width = 64
+				}
+				if width == 0 {
+					return arm64GoABIContext("%s copy has no supplied input at %q", effect.copyFrom, effect.source)
+				}
+				if effect.register != string(ZR) {
+					if width > effect.width {
+						width = effect.width
+					}
+					state.values[effect.register] = width
+					delete(state.vectors, effect.register)
+				}
+			} else if effect.write {
+				state.values[effect.register] = effect.width
+				delete(state.vectors, effect.register)
+			} else if state.values[effect.register] < effect.width {
+				return arm64GoABIContext("%s read (%d bits) is not supplied by entry, call results or a reaching write at %q", effect.register, effect.width, effect.source)
+			}
+		}
+		for _, target := range block.successors {
+			i, ok := indices[target]
+			if !ok {
+				return arm64GoABIContext("machine-state CFG has an unknown successor %q", target)
+			}
+			changed := before[i] == nil
+			if changed {
+				copy := state.clone()
+				before[i] = &copy
+			} else {
+				changed = before[i].merge(state)
+			}
+			if changed && !queued[i] {
+				queue, queued[i] = append(queue, i), true
+			}
+		}
+	}
+	return nil
+}
+
+// This independent may-unavailable analysis does not invent a typed entry
+// for an ordinary object-only probe. Only bits actually overwritten by an
+// unbound source expansion are unavailable; complete reaching writes restore
+// them, and joins retain every possible missing value. The ordinary typed ABI
+// must-defined analysis above still runs unchanged when its contract is active.
+func (flow *arm64MachineAvailability) validateSourceScratch() error {
+	if !flow.sourceScratch {
+		return nil
+	}
+	indices := make(map[string]int, len(flow.blocks))
+	for i, block := range flow.blocks {
+		indices[block.name] = i
+	}
+	before := make([]map[string]int, len(flow.blocks))
+	before[0] = make(map[string]int)
+	queue, queued := []int{0}, make([]bool, len(flow.blocks))
+	queued[0] = true
+	for next := 0; next < len(queue); next++ {
+		at := queue[next]
+		queued[at] = false
+		missing := make(map[string]int)
+		for reg, width := range before[at] {
+			missing[reg] = width
+		}
+		for _, effect := range flow.blocks[at].effects {
+			// These actual flag-slot effects remain inputs to ordered flag
+			// flow and must-defined analysis. They cannot create missing
+			// physical GP scratch for an unrelated native observation.
+			if effect.nzcv != 0 {
+				continue
+			}
+			switch {
+			case effect.unavailable:
+				width := effect.width
+				if width == 0 {
+					width = 64 // Historical unbound original Go GP scratch.
+				}
+				missing[effect.register] = width
+			case effect.call != nil:
+				// Arguments have already been read by the typed lowerer. The
+				// opaque callee does not make an unbound caller scratch known.
+				for _, result := range effect.call.Results {
+					delete(missing, arm64MachineRegister(result.Register))
+				}
+			case effect.opaque:
+				if len(missing) != 0 && !effect.noScratchObserver {
+					return arm64GoABIContext("native effects can observe an unbound original Go memory scratch at %q", effect.source)
+				}
+			case effect.copyFrom != "":
+				if missing[effect.copyFrom] != 0 {
+					missing[effect.register] = missing[effect.copyFrom]
+				} else {
+					delete(missing, effect.register)
+				}
+			case effect.write:
+				if effect.width >= missing[effect.register] {
+					delete(missing, effect.register)
+				}
+			case missing[effect.register] != 0:
+				return arm64GoABIContext("%s consumes an unbound original Go memory scratch at %q", effect.register, effect.source)
+			}
+		}
+		for _, target := range flow.blocks[at].successors {
+			index, ok := indices[target]
+			if !ok {
+				return arm64GoABIContext("source scratch CFG has an unknown successor %q", target)
+			}
+			changed := before[index] == nil
+			if changed {
+				before[index] = make(map[string]int)
+			}
+			for reg, width := range missing {
+				if before[index][reg] < width {
+					before[index][reg], changed = width, true
+				}
+			}
+			if changed && !queued[index] {
+				queue, queued[index] = append(queue, index), true
+			}
+		}
+	}
+	return nil
+}
+
+func (c *arm64Ctx) recordMachineOpaqueIR(start int, original Instr) {
+	flow := c.machineAvailability
+	if flow == nil {
+		return
+	}
+	ins := arm64ControlDecode(original)
+	op := arm64ControlOp(ins)
+	// Symbol calls are recorded at their typed boundary. Other external
+	// callouts (e.g. an unmodeled syscall/native helper) cannot inherit the
+	// source machine state just because their IR is a normal LLVM call.
+	symbolCall := (op == "CALL" || op == "BL" || op == "B" || op == "JMP" || op == OpRET) &&
+		len(ins.Args) == 1 && ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)")
+	offset := start
+	for _, line := range strings.SplitAfter(c.b.String()[start:], "\n") {
+		proof := flow.nativeIR[offset]
+		proven := proof.line == line && line != ""
+		if proof.syscall != nil {
+			proven = proven && proof.syscall.matches(c, original, offset) && proof.store
+		}
+		offset += len(line)
+		if proven {
+			if proof.store && !flow.flagsOnly {
+				flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects,
+					arm64MachineEffect{store: true, source: flow.source})
+			}
+			continue
+		}
+		if strings.Contains(line, " asm ") || (!symbolCall && strings.Contains(line, " call ") && !strings.Contains(line, "@llvm.")) {
+			c.invalidateARM64Flags(arm64FlagAll)
+			if !flow.flagsOnly {
+				flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{opaque: true, source: flow.source})
+			}
+			return
+		}
+	}
+}
diff --git a/arm64_machine_availability_test.go b/arm64_machine_availability_test.go
new file mode 100644
index 000000000..80fa75903
--- /dev/null
+++ b/arm64_machine_availability_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestARM64GoRegisterMachineLowBitsAndMerge(t *testing.T) {
+	for _, tc := range []struct {
+		name       string
+		read       int
+		leftWidth  int
+		rightWidth int
+		context    bool
+	}{
+		{"narrow_copy", 8, 8, 8, false},
+		{"copy_does_not_widen", 9, 8, 8, true},
+		{"mixed_paths_low_bits", 8, 64, 8, false},
+		{"mixed_paths_high_bits", 64, 64, 8, true},
+		{"all_paths_redefined", 64, 64, 64, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			leaf := func(reg Reg, typ LLVMType) ARM64GoRegisterValue {
+				return ARM64GoRegisterValue{Register: reg, Type: typ}
+			}
+			flow := &arm64MachineAvailability{
+				used: true, entry: &ARM64GoRegisterABI{Params: []ARM64GoRegisterValue{leaf("R0", I8)}},
+				blocks: []arm64MachineBlock{
+					{name: "entry", successors: []string{"left", "right"}},
+					{name: "left", successors: []string{"merge"}},
+					{name: "right", successors: []string{"merge"}},
+					{name: "merge", effects: []arm64MachineEffect{{register: "R9", width: tc.read}}},
+				},
+			}
+			for i, width := range []int{tc.leftWidth, tc.rightWidth} {
+				if width == 64 {
+					flow.blocks[i+1].effects = []arm64MachineEffect{{register: "R9", width: 64, write: true}}
+				} else {
+					flow.blocks[i+1].effects = []arm64MachineEffect{{register: "R9", copyFrom: "R0", width: 64}}
+				}
+			}
+			if err := flow.validate(); errors.Is(err, ErrProbeNeedsContext) != tc.context || (!tc.context && err != nil) {
+				t.Fatalf("width intersection context=%t: %v", tc.context, err)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		typ  LLVMType
+		bits int
+	}{
+		{I1, 1}, {I8, 8}, {I16, 16}, {I32, 32}, {I64, 64}, {Ptr, 64}, {"float", 32}, {"double", 64}, {"unknown", 0},
+	} {
+		if got := arm64MachineScalarWidth(tc.typ); got != tc.bits {
+			t.Errorf("%s: bits=%d, want %d", tc.typ, got, tc.bits)
+		}
+	}
+}
diff --git a/arm64_machine_vector_bits.go b/arm64_machine_vector_bits.go
new file mode 100644
index 000000000..dca92ef41
--- /dev/null
+++ b/arm64_machine_vector_bits.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+// A SIMD lane write preserves the other low 128 bits. Prefix widths alone
+// cannot describe its definedness: D[1] may be defined while D[0] is not.
+// Scalable upper bits remain separate from this finite architectural bank.
+type arm64MachineVectorDefinition struct {
+	low, high uint64
+	scalable  bool
+}
+
+func arm64MachineVectorMask(offset, width int) arm64MachineVectorDefinition {
+	var mask arm64MachineVectorDefinition
+	for bit := offset; bit < offset+width; bit++ {
+		if bit < 64 {
+			mask.low |= uint64(1) << uint(bit)
+		} else {
+			mask.high |= uint64(1) << uint(bit-64)
+		}
+	}
+	return mask
+}
+
+func (state arm64MachineState) vectorDefinition(reg string) arm64MachineVectorDefinition {
+	if definition, present := state.vectors[reg]; present {
+		return definition
+	}
+	width := state.values[reg]
+	if width > 128 {
+		return arm64MachineVectorDefinition{low: ^uint64(0), high: ^uint64(0), scalable: true}
+	}
+	return arm64MachineVectorMask(0, width)
+}
+
+func (state *arm64MachineState) setVectorDefinition(reg string, definition arm64MachineVectorDefinition) {
+	if state.vectors == nil {
+		state.vectors = make(map[string]arm64MachineVectorDefinition)
+	}
+	state.vectors[reg] = definition
+	width := 0
+	for width < 128 {
+		word, bit := definition.low, width
+		if width >= 64 {
+			word, bit = definition.high, width-64
+		}
+		if word&(uint64(1)<<uint(bit)) == 0 {
+			break
+		}
+		width++
+	}
+	if width == 128 && definition.scalable {
+		width = arm64WholeScalableRegister
+	}
+	state.values[reg] = width
+}
+
+func (state *arm64MachineState) applyVectorSpan(effect arm64MachineEffect) error {
+	if _, valid := arm64ParseVReg(Reg(effect.register)); !valid ||
+		effect.vectorOffset < 0 || effect.width <= 0 || effect.width > 128 || effect.vectorOffset > 128-effect.width {
+		return arm64GoABIContext("invalid SIMD defined-bit span at %q", effect.source)
+	}
+	if effect.copyFrom != "" {
+		if _, valid := arm64ParseVReg(Reg(effect.copyFrom)); !valid || !effect.write || effect.vectorOffset != 0 || effect.width != 128 {
+			return arm64GoABIContext("invalid complete SIMD defined-bit copy at %q", effect.source)
+		}
+		definition := state.vectorDefinition(effect.copyFrom)
+		definition.scalable = true // The architectural write clears scalable upper bits.
+		state.setVectorDefinition(effect.register, definition)
+		return nil
+	}
+	definition := state.vectorDefinition(effect.register)
+	mask := arm64MachineVectorMask(effect.vectorOffset, effect.width)
+	if effect.write {
+		definition.low |= mask.low
+		definition.high |= mask.high
+		// A NEON write clears the scalable upper part, but never initializes
+		// preserved, previously unknown bits inside the low 128-bit bank.
+		definition.scalable = true
+		state.setVectorDefinition(effect.register, definition)
+		return nil
+	}
+	if definition.low&mask.low != mask.low || definition.high&mask.high != mask.high {
+		return arm64GoABIContext("%s lane read [%d,%d) is not supplied by entry, call results or reaching writes at %q",
+			effect.register, effect.vectorOffset, effect.vectorOffset+effect.width, effect.source)
+	}
+	return nil
+}
+
+// Record the complete validated VMOV/VDUP form before emitting its virtual
+// assembly. Loading an old destination to preserve its untouched bytes is not
+// a semantic read of those bytes; later actual consumers still require them.
+func (c *arm64Ctx) recordMachineVectorTransfer(form arm64VectorTransferForm) func() {
+	flow := c.machineAvailability
+	if flow == nil || flow.flagsOnly || flow.suspended != 0 {
+		return func() {}
+	}
+	if form.sourceGP {
+		c.recordMachineRegister(form.source, form.bits, false)
+	} else {
+		width := form.bits
+		if form.copy {
+			width *= form.lanes
+		}
+		flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+			register: arm64MachineRegister(form.source), width: width,
+			vectorOffset: form.sourceLane * form.bits, vectorSpan: true, source: flow.source,
+		})
+	}
+	if form.destinationGP {
+		c.recordMachineRegister(form.destination, 64, true)
+	} else if form.preserve {
+		flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+			register: arm64MachineRegister(form.destination), width: form.bits, write: true,
+			vectorOffset: form.destinationLane * form.bits, vectorSpan: true, source: flow.source,
+		})
+	} else {
+		// Every non-preserving row writes its complete bank, with explicit
+		// upper zeroing for Q=0 and scalar-lane destination forms.
+		c.recordMachineRegister(form.destination, arm64WholeScalableRegister, true)
+	}
+	flow.suspended++
+	return func() { flow.suspended-- }
+}
diff --git a/arm64_mrs_runtime_test.go b/arm64_mrs_runtime_test.go
new file mode 100644
index 000000000..78cc1549f
--- /dev/null
+++ b/arm64_mrs_runtime_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64ConformanceMRSFeatureRegisters(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if !(runtime.GOOS == "linux" && runtime.GOARCH == "arm64") && !cross {
+		t.Skip("EL1 feature access requires Linux/arm64; required Linux cross-runtime CI executes this oracle")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compiler := []string{findLLVM22Tool("clang")}
+	var runner []string
+	if cross {
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	var main strings.Builder
+	main.WriteString(`#define _GNU_SOURCE
+#include <asm/hwcap.h>
+#include <sched.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/auxv.h>
+`)
+	for index, register := range arm64FeatureRegisters {
+		physical := arm64EncodedSystemRegisterName(uint16((register.word >> 5) & 0x7fff))
+		fmt.Fprintf(&main, `extern uint64_t read_feature_%[1]d(void);
+static uint64_t native_feature_%[1]d(void) {
+  uint64_t value;
+  __asm__ volatile("mrs %%0, %[2]s" : "=r"(value) :: "memory");
+  return value;
+}
+`, index, physical)
+	}
+	main.WriteString(`int main(void) {
+  if (!(getauxval(AT_HWCAP) & HWCAP_CPUID)) {
+    fputs("required kernel CPUID register access unavailable\n", stderr);
+    return 1;
+  }
+  cpu_set_t allowed, selected;
+  if (sched_getaffinity(0, sizeof(allowed), &allowed)) return 2;
+  CPU_ZERO(&selected);
+  for (int cpu = 0; cpu < CPU_SETSIZE; cpu++) {
+    if (CPU_ISSET(cpu, &allowed)) { CPU_SET(cpu, &selected); break; }
+  }
+  if (sched_setaffinity(0, sizeof(selected), &selected)) return 3;
+  if (((native_feature_0() >> 16) & 15) != 15) return 4;
+  for (int iteration = 0; iteration < 16; iteration++) {
+`)
+	for index, register := range arm64FeatureRegisters {
+		fmt.Fprintf(&main, `    if (read_feature_%[1]d() != native_feature_%[1]d()) {
+      fputs("translated %[2]s differs from native MRS\n", stderr);
+      return %[3]d;
+    }
+`, index, register.name, index+10)
+	}
+	main.WriteString("  }\n  return 0;\n}\n")
+	for _, raw := range []bool{false, true} {
+		for _, cfg := range []bool{false, true} {
+			file, sigs := arm64MRSFeatureFixture(t, raw, cfg)
+			for _, directModule := range []bool{false, true} {
+				t.Run(fmt.Sprintf("raw=%v/cfg=%v/module=%v", raw, cfg, directModule), func(t *testing.T) {
+					options := Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: sigs}
+					var ir string
+					if directModule {
+						ir = translateARM64MRSModule(t, file, options)
+					} else {
+						var err error
+						ir, err = Translate(file, options)
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "mrs_feature", options.TargetTriple, ir, main.String(), runner)
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_multiply_high_index_test.go b/arm64_multiply_high_index_test.go
new file mode 100644
index 000000000..bc1b6766a
--- /dev/null
+++ b/arm64_multiply_high_index_test.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Assemble all lines together with an independent encoder. Expected lane
+// numbers come from the source spelling, never from the decoder's bit formula.
+func assembleARM64LLVMWords(t *testing.T, lines []string, features string) []uint32 {
+	t.Helper()
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc not found")
+	}
+	cmd := exec.Command(mc, "-triple=aarch64", "-mattr="+features, "-show-encoding")
+	cmd.Stdin = strings.NewReader(strings.Join(lines, "\n") + "\n")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM MC oracle: %v\n%s", err, output)
+	}
+	encodings := regexp.MustCompile(`encoding: \[([^\]]+)\]`).FindAllStringSubmatch(string(output), -1)
+	if len(encodings) != len(lines) {
+		t.Fatalf("LLVM MC returned %d encodings for %d instructions: %s", len(encodings), len(lines), output)
+	}
+	words := make([]uint32, len(encodings))
+	for i, encoding := range encodings {
+		fields := strings.Split(encoding[1], ",")
+		if len(fields) != 4 {
+			t.Fatalf("not an A64 instruction: %q", encoding[0])
+		}
+		var bytes [4]byte
+		for j, field := range fields {
+			value, err := strconv.ParseUint(strings.TrimSpace(field), 0, 8)
+			if err != nil {
+				t.Fatal(err)
+			}
+			bytes[j] = byte(value)
+		}
+		words[i] = binary.LittleEndian.Uint32(bytes[:])
+	}
+	return words
+}
+
+type arm64MultiplyHighIndexCase struct {
+	line             string
+	bits, lanes      int
+	scalar, rounding bool
+	register, index  int
+	operation        int
+}
+
+func arm64MultiplyHighIndexCases() []arm64MultiplyHighIndexCase {
+	var cases []arm64MultiplyHighIndexCase
+	for operation, op := range []string{"sqdmulh", "sqrdmulh", "mul", "mla", "mls"} {
+		for _, bits := range []int{16, 32} {
+			element := "h"
+			reg := 15
+			if bits == 32 {
+				element, reg = "s", 31
+			}
+			for _, vectorBits := range []int{0, 64, 128} {
+				if vectorBits == 0 && operation >= 2 {
+					continue
+				}
+				lanes := vectorBits / bits
+				destination, first := element+"2", element+"0"
+				if vectorBits == 0 {
+					lanes = 1
+				} else {
+					destination = fmt.Sprintf("v2.%d%s", lanes, element)
+					first = fmt.Sprintf("v0.%d%s", lanes, element)
+				}
+				for index := 0; index < 128/bits; index++ {
+					cases = append(cases, arm64MultiplyHighIndexCase{
+						line: fmt.Sprintf("%s %s, %s, v%d.%s[%d]", op, destination, first, reg, element, index),
+						bits: bits, lanes: lanes, scalar: vectorBits == 0,
+						rounding: op == "sqrdmulh", register: reg, index: index,
+						operation: operation,
+					})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func TestARM64MultiplyHighIndexedLaneOrder(t *testing.T) {
+	cases := arm64MultiplyHighIndexCases()
+	var lines []string
+	for _, tc := range cases {
+		lines = append(lines, tc.line)
+	}
+	words := assembleARM64LLVMWords(t, lines, "+neon")
+	for i, tc := range cases {
+		form, ok := decodeARM64RawSQDMULH(words[i])
+		if tc.rounding {
+			form, ok = decodeARM64RawSQRDMULH(words[i])
+		}
+		if tc.operation >= 2 {
+			decode := []func(uint32) (arm64RawMUL, bool){decodeARM64RawMUL, decodeARM64RawMLA, decodeARM64RawMLS}[tc.operation-2]
+			multiply, found := decode(words[i])
+			ok = found
+			form = arm64RawSQDMULH{
+				arrangement: multiply.arrangement, destination: multiply.destination,
+				first: multiply.first, second: multiply.second, element: multiply.element,
+				byElement: multiply.byElement,
+			}
+		}
+		if !ok || !form.byElement || form.element != tc.index || form.second != tc.register || form.first != 0 || form.destination != 2 ||
+			form.scalar != tc.scalar || form.arrangement.elementBits != tc.bits || form.arrangement.lanes != tc.lanes {
+			t.Errorf("%s (%#08x): decoded %+v, %v", tc.line, words[i], form, ok)
+		}
+	}
+}
+
+func TestARM64ConformanceMultiplyHighIndexedLanes(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("ARM64 native execution or required Linux cross-runtime matrix")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compiler := []string{findLLVM22Tool("clang")}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runner []string
+	if cross {
+		compiler = []string{"aarch64-linux-gnu-gcc"}
+		triple = "aarch64-unknown-linux-gnu"
+		runner = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+	} else if compiler[0] == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	file, sigs, mainC := arm64MultiplyIndexProgram(t)
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "multiply_index", triple, ir, mainC, runner)
+}
+
+func TestARM64MultiplyIndexedObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	file, sigs, _ := arm64MultiplyIndexProgram(t)
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "multiply.ll", "multiply.o", ir)
+		})
+	}
+}
+
+func arm64MultiplyIndexProgram(t *testing.T) (*File, map[string]FuncSig, string) {
+	t.Helper()
+	cases := arm64MultiplyHighIndexCases()
+	if len(cases) != 144 {
+		t.Fatalf("generated %d indexed forms, want 144", len(cases))
+	}
+	var lines []string
+	for _, tc := range cases {
+		lines = append(lines, tc.line)
+	}
+	words := assembleARM64LLVMWords(t, lines, "+neon")
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for i, tc := range cases {
+		name := fmt.Sprintf("multiplyindex%d", i)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+		fmt.Fprintf(&source, "VLD1 (R0),[V0.B16]\nVLD1 (R0),[V2.B16]\nVLD1 (R1),[V%d.B16]\nWORD $%#08x\nVST1 [V2.B16],(R2)\nRET\n", tc.register, words[i])
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}},
+		}
+		fmt.Fprintf(&declarations, "extern void %s(const void *,const void *,void *);\n", name)
+		fmt.Fprintf(&checks, "    if (check(%s,%d,%d,%d,%d)) return %d;\n", name, tc.bits, tc.lanes, tc.index, tc.operation, i+1)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := arm64MultiplyHighIndexOracleC + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	return file, sigs, mainC
+}
+
+const arm64MultiplyHighIndexOracleC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static int64_t lane(const uint8_t *p, int bits, int index) {
+    if (bits == 16) {
+        int16_t value;
+        memcpy(&value, p + index * 2, 2);
+        return value;
+    }
+    int32_t value;
+    memcpy(&value, p + index * 4, 4);
+    return value;
+}
+
+static int check(void (*fn)(const void *,const void *,void *), int bits, int lanes, int index, int operation) {
+    uint8_t a[16], b[16], got[16], want[16];
+    uint32_t seed = 123;
+    for (unsigned trial = 0; trial < 256; trial++) {
+        for (unsigned byte = 0; byte < 16; byte++) {
+            seed = seed * 1664525U + 1013904223U;
+            a[byte] = seed >> 24;
+            b[byte] = seed >> 16;
+        }
+        // Include the saturating min*min case at every indexed position.
+        if (trial == 0) {
+            memset(a, 0, 16);
+            memset(b, 0, 16);
+            for (int i = 0; i < 128 / bits; i++) {
+                a[(i + 1) * bits / 8 - 1] = 128;
+                b[(i + 1) * bits / 8 - 1] = 128;
+            }
+        }
+        memset(want, 0, 16);
+        for (int i = 0; i < lanes; i++) {
+            int64_t product = lane(a,bits,i) * lane(b,bits,index);
+            int64_t value = product;
+            if (operation < 2) {
+                if (operation == 1) product += INT64_C(1) << (bits - 2);
+                value = product >> (bits - 1);
+                int64_t maximum = (INT64_C(1) << (bits - 1)) - 1;
+                if (value > maximum) value = maximum;
+            } else if (operation == 3) {
+                value = lane(a,bits,i) + product;
+            } else if (operation == 4) {
+                value = lane(a,bits,i) - product;
+            }
+            uint32_t result = (uint32_t)value;
+            memcpy(want + i * bits / 8, &result, bits / 8);
+        }
+        memset(got, 0xa5, 16);
+        fn(a,b,got);
+        if (memcmp(got, want, 16)) {
+            fprintf(stderr,"multiply index mismatch bits=%d lanes=%d index=%d operation=%d trial=%u\n",
+                    bits,lanes,index,operation,trial);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/arm64_named_gp_fields.go b/arm64_named_gp_fields.go
new file mode 100644
index 000000000..c4a3bef87
--- /dev/null
+++ b/arm64_named_gp_fields.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Named forms retain Go's source operand grammar before sharing the physical
+// decoder's numerical lowering. A WORD's decoder identity is not lent to them.
+func parseARM64NamedMoveWide(op Op, ins Instr) (form arm64RawMoveWide, handled bool, err error) {
+	switch op {
+	case "MOVK", "MOVKW", "MOVN", "MOVNW", "MOVZ", "MOVZW":
+	default:
+		return form, false, nil
+	}
+	invalid := func() (arm64RawMoveWide, bool, error) {
+		return form, true, fmt.Errorf("arm64 %s requires a nonzero shifted uint16 and C_ZREG: %q", op, ins.Raw)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat ||
+		ins.Args[0].Imm == 0 || !arm64ScalarMultiplyRegister(ins.Args[1]) {
+		return invalid()
+	}
+	form.op, form.width = Op(strings.TrimSuffix(string(op), "W")), 64
+	if strings.HasSuffix(string(op), "W") {
+		form.width = 32
+	}
+	value := uint64(ins.Args[0].Imm)
+	for shift := 0; shift < form.width; shift += 16 {
+		if value&^(uint64(0xffff)<<shift) == 0 {
+			form.shift, form.immediate = shift, uint16(value>>shift)
+			form.destination = arm64NamedFieldRegister(ins.Args[1].Reg)
+			return form, true, nil
+		}
+	}
+	return invalid()
+}
+
+func parseARM64NamedBitfield(op Op, ins Instr) (form arm64RawBitfield, handled bool, err error) {
+	switch op {
+	case "BFM", "BFMW", "SBFM", "SBFMW", "UBFM", "UBFMW":
+	default:
+		return form, false, nil
+	}
+	invalid := func() (arm64RawBitfield, bool, error) {
+		return form, true, fmt.Errorf("arm64 %s requires $immr, C_ZREG, $imms, C_ZREG: %q", op, ins.Raw)
+	}
+	if strings.ToUpper(string(ins.Op)) != string(op) || len(ins.Args) != 4 ||
+		!arm64ScalarMultiplyRegister(ins.Args[1]) || !arm64ScalarMultiplyRegister(ins.Args[3]) {
+		return invalid()
+	}
+	form.op, form.width = Op(strings.TrimSuffix(string(op), "W")), 64
+	if strings.HasSuffix(string(op), "W") {
+		form.width = 32
+	}
+	for _, index := range []int{0, 2} {
+		argument := ins.Args[index]
+		if argument.Kind != OpImm || argument.ImmRaw != "" || argument.ImmIsFloat ||
+			argument.Imm < 0 || argument.Imm >= int64(form.width) {
+			return invalid()
+		}
+	}
+	form.immr, form.imms = int(ins.Args[0].Imm), int(ins.Args[2].Imm)
+	form.source, form.destination = arm64NamedFieldRegister(ins.Args[1].Reg), arm64NamedFieldRegister(ins.Args[3].Reg)
+	return form, true, nil
+}
+
+// Call only after the complete C_ZREG check above; register 31 is ZR, not SP.
+func arm64NamedFieldRegister(reg Reg) int {
+	if reg == ZR {
+		return 31
+	}
+	number, _ := strconv.Atoi(strings.TrimPrefix(strings.ToUpper(strings.TrimSpace(string(reg))), "R"))
+	return number
+}
diff --git a/arm64_named_gp_fields_runtime_test.go b/arm64_named_gp_fields_runtime_test.go
new file mode 100644
index 000000000..3a895d721
--- /dev/null
+++ b/arm64_named_gp_fields_runtime_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// One whole original Go program and one C harness retain the complete family.
+// No instruction/shift starts a separate compiler, linker or execution process.
+func TestCrossLinuxRuntimeMatrixARM64NamedMoveWideAndBitfield(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	values := []uint64{0, 1, ^uint64(0), 0x0123456789abcdef,
+		0xfedcba9876543210, 1 << 63, 0xffffffff, 0xffffffff00000000}
+	rows := arm64NamedMoveBitfieldCases()
+	var source, declarations, goCalls, cDeclarations, cCalls, goExpected, cExpected strings.Builder
+	signatures := make(map[string]FuncSig)
+	for index, row := range rows {
+		name := fmt.Sprintf("Fields%d", index)
+		result := row.destination
+		if result == 31 {
+			result = 2
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVD input+0(FP),R1\nMOVD initial+8(FP),R2\n%s\nMOVD R%d,ret+16(FP)\nRET\n",
+			name, row.instruction(), result)
+		fmt.Fprintf(&declarations, "func %s(uint64,uint64) uint64\n", name)
+		fmt.Fprintf(&goCalls, "%s,\n", name)
+		fmt.Fprintf(&cDeclarations, "extern uint64_t %s(uint64_t,uint64_t);\n", name)
+		fmt.Fprintf(&cCalls, "%s,\n", name)
+		goExpected.WriteString("{")
+		cExpected.WriteString("{")
+		for _, input := range values {
+			for _, initial := range values {
+				// The independent bit selector from the RED numerical test is
+				// materialized before either original Go or LLVM executes.
+				want := row.value(input, initial)
+				fmt.Fprintf(&goExpected, "0x%x,", want)
+				fmt.Fprintf(&cExpected, "UINT64_C(0x%x),", want)
+			}
+		}
+		goExpected.WriteString("},\n")
+		cExpected.WriteString("},\n")
+		signatures[name] = FuncSig{Name: name, Args: []LLVMType{I64, I64}, Ret: I64, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+		}}
+	}
+	const goValues = `var values=[]uint64{0,1,^uint64(0),0x0123456789abcdef,0xfedcba9876543210,1<<63,0xffffffff,0xffffffff00000000}
+`
+	goMain := "package main\n" + declarations.String() + goValues +
+		"var calls=[]func(uint64,uint64)uint64{\n" + goCalls.String() + "}\n" +
+		"var expected=[][64]uint64{\n" + goExpected.String() + "}\n" + `
+func main(){ for n,call:=range calls { for i,a:=range values { for j,b:=range values {
+  if call(a,b)!=expected[n][8*i+j] { panic("original named move/bitfield mismatch") }
+} } } }
+`
+	runARM64GoInternalOracle(t, source.String(), goMain, len(runner) != 0)
+	cMain := "#include <stdint.h>\n#include <stdio.h>\n" + cDeclarations.String() +
+		"static uint64_t (*calls[])(uint64_t,uint64_t)={\n" + cCalls.String() + "};\n" +
+		"static const uint64_t expected[][64]={\n" + cExpected.String() + "};\n" + `
+int main(void) {
+  const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(1)<<63,UINT64_C(0xffffffff),UINT64_C(0xffffffff00000000)};
+  for(unsigned n=0;n<sizeof(calls)/sizeof(calls[0]);n++) {
+    for(unsigned i=0;i<8;i++) for(unsigned j=0;j<8;j++) {
+      uint64_t got=calls[n](values[i],values[j]);
+      if(got!=expected[n][8*i+j]) {
+        fprintf(stderr,"named move/bitfield case=%u input=%u initial=%u got=%016llx expected=%016llx\n",n,i,j,(unsigned long long)got,(unsigned long long)expected[n][8*i+j]);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "test/namedfields", "package namedfields\n"+declarations.String())
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			var ir string
+			options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: signatures, ResolveSym: resolve}
+			switch api {
+			case "text":
+				ir, err = Translate(file, options)
+			case "module":
+				var module llvm.Module
+				module, err = TranslateModuleInContext(context, file, options)
+				if !module.IsNil() {
+					ir = module.String()
+					module.Dispose()
+				}
+			case "GoModule":
+				var translated *GoModuleTranslation
+				translated, err = translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+				})
+				if translated != nil {
+					ir = translated.Module.String()
+					translated.Module.Dispose()
+				}
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []int{0, 2} {
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "named_fields", triple, ir, cMain, runner, level)
+			}
+		})
+	}
+	t.Logf("all %d named move/bitfield cases x64 input pairs: original Go plus three LLVM APIs, O0/O2", len(rows))
+}
diff --git a/arm64_named_gp_fields_test.go b/arm64_named_gp_fields_test.go
new file mode 100644
index 000000000..decd43f78
--- /dev/null
+++ b/arm64_named_gp_fields_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Go 1.20/1.21 Optab has four operand classes; Go 1.22 added a5
+// (the second destination). These two families have no second destination.
+// Normalize only that known, explicitly empty column, never arbitrary fields.
+func arm64NamedNormalizeGoRow(row string) (string, error) {
+	fields := strings.Split(strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(row), "{"), "}"), ",")
+	for index := range fields {
+		fields[index] = strings.TrimSpace(fields[index])
+	}
+	switch len(fields) {
+	case 10:
+	case 11:
+		if fields[5] != "C_NONE" {
+			return "", errors.New("unexpected ARM64 second-destination class")
+		}
+		fields = append(fields[:5], fields[6:]...)
+	default:
+		return "", errors.New("unknown ARM64 Optab layout")
+	}
+	return "{" + strings.Join(fields, ", ") + "}", nil
+}
+
+func TestARM64NamedMoveWideAndBitfieldCompleteGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, family := range []struct{ root, row string }{
+		{"AMOVK", `{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, 33, 4, 0, 0, 0}`},
+		{"ABFM", `{ABFM, C_VCON, C_ZREG, C_VCON, C_ZREG, 42, 4, 0, 0, 0}`},
+	} {
+		source := string(data)
+		rows := regexp.MustCompile(`(?m)^\s*(\{`+family.root+`,[^{}]*\})\s*,`).FindAllStringSubmatch(source, -1)
+		if len(rows) != 1 ||
+			len(regexp.MustCompile(`(?m)^\s*\{`+family.root+`,`).FindAllString(source, -1)) != 1 {
+			t.Fatal("complete Go operand row changed", family.root)
+		}
+		normalized, err := arm64NamedNormalizeGoRow(rows[0][1])
+		if err != nil || normalized != family.row {
+			t.Fatal("complete Go operand fields changed", family.root, normalized, err)
+		}
+		start := strings.Index(source, "case "+family.root+":")
+		if start < 0 {
+			t.Fatal("Go opcode-family registration absent", family.root)
+		}
+		block := source[start+len("case "+family.root+":"):]
+		if end := strings.Index(block, "\n\t\tcase "); end >= 0 {
+			block = block[:end]
+		}
+		want := map[string]bool{}
+		if family.root == "AMOVK" {
+			for _, name := range []string{"MOVKW", "MOVN", "MOVNW", "MOVZ", "MOVZW"} {
+				want[name] = true
+			}
+		} else {
+			for _, name := range []string{"BFMW", "SBFM", "SBFMW", "UBFM", "UBFMW"} {
+				want[name] = true
+			}
+		}
+		for _, match := range regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block, -1) {
+			if !want[match[1]] {
+				t.Fatal("new/unexpected Go family member needs a complete form", match[1])
+			}
+			delete(want, match[1])
+		}
+		if len(want) != 0 {
+			t.Fatal("Go family member disappeared", want)
+		}
+	}
+	for _, row := range []struct {
+		name, source string
+		valid        bool
+	}{
+		{"four-classes", `{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, 33, 4, 0, 0, 0}`, true},
+		{"five-classes", "{ AMOVK,\tC_VCON, C_NONE, C_NONE, C_ZREG, C_NONE,\n33,4,0,0,0 }", true},
+		{"new-destination", `{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, C_ZREG, 33, 4, 0, 0, 0}`, false},
+		{"unknown-layout", `{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, C_NONE, C_NONE, 33, 4, 0, 0, 0}`, false},
+		{"missing-column", `{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, 33, 4, 0, 0}`, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			normalized, err := arm64NamedNormalizeGoRow(row.source)
+			if row.valid {
+				if err != nil || normalized != "{AMOVK, C_VCON, C_NONE, C_NONE, C_ZREG, 33, 4, 0, 0, 0}" {
+					t.Fatal("known Go layout did not retain every field", normalized, err)
+				}
+			} else if err == nil {
+				t.Fatal("unknown Go operand-table layout accepted", normalized)
+			}
+		})
+	}
+}
+
+func TestARM64NamedMoveWideAndBitfieldMalformedForms(t *testing.T) {
+	var invalid []string
+	for _, op := range []string{"MOVZ", "MOVZW", "MOVN", "MOVNW"} {
+		invalid = append(invalid, op+" $0,R2", op+" $0x10001,R2", op+" $1,RSP",
+			op+" $1,(R2)", op+" $1.5,R2", op+".P $1,R2", op+" $1,$16,R2")
+		if strings.HasSuffix(op, "W") {
+			invalid = append(invalid, op+" $(1<<32),R2", op+" $-1,R2")
+		}
+	}
+	for _, op := range []string{"BFM", "BFMW", "SBFM", "SBFMW", "UBFM", "UBFMW"} {
+		bits := 64
+		if strings.HasSuffix(op, "W") {
+			bits = 32
+		}
+		invalid = append(invalid, fmt.Sprintf("%s $%d,R1,$0,R2", op, bits),
+			fmt.Sprintf("%s $0,R1,$%d,R2", op, bits), op+" $-1,R1,$0,R2",
+			op+" $0,RSP,$1,R2", op+" $0,R1,$1,RSP", op+" $0,F1,$1,R2",
+			op+" $0,R1,$1", op+" $1.5,R1,$1,R2", op+".P $0,R1,$1,R2")
+	}
+	for _, instruction := range invalid {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT invalid(SB),4,$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+				Sigs: map[string]FuncSig{"invalid": {Name: "invalid", Ret: Void}},
+			}); err == nil {
+				t.Fatal("invalid named form acquired lowering", instruction)
+			}
+		})
+	}
+}
+
+func TestARM64NamedMoveWideAndBitfieldGPInputRoles(t *testing.T) {
+	for _, op := range []Op{"MOVZ", "MOVZW", "MOVN", "MOVNW", "BFM", "BFMW", "SBFM", "SBFMW", "UBFM", "UBFMW"} {
+		t.Run(string(op), func(t *testing.T) {
+			instruction := fmt.Sprintf("%s $1,R9", op)
+			move := strings.HasPrefix(string(op), "MOV")
+			if !move {
+				instruction = fmt.Sprintf("%s $3,R4,$17,R9", op)
+			}
+			file, err := Parse(ArchARM64, "TEXT roles(SB),4,$0-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, handled, err := parseARM64GPDataForm(op, ins)
+			if !handled || err != nil || form.destination.Reg != "R9" {
+				t.Fatal("named form is absent from shared GP effects", handled, err)
+			}
+			readsOld := op == "BFM" || op == "BFMW"
+			wantInputs := 0
+			if !move {
+				wantInputs = 1
+				if readsOld {
+					wantInputs++
+				}
+			}
+			if len(form.inputs) != wantInputs || len(form.implicit) != 0 || form.scratch != nil {
+				t.Fatalf("wrong original operand dependencies: %+v", form)
+			}
+			for _, tainted := range []Reg{"R9", "R4"} {
+				state := &arm64RawPrivateFrameState{regs: arm64PrivateFrameAddresses{tainted: {}},
+					spills: make(map[int64]arm64PrivateFrameAddress)}
+				want := !(tainted == "R9" && readsOld || tainted == "R4" && !move)
+				if accepted := state.transfer(ins, ins, 64); accepted != want {
+					t.Fatalf("tainted %s: transfer=%t, want %t", tainted, accepted, want)
+				}
+				if want && tainted == "R9" {
+					if _, retained := state.regs["R9"]; retained {
+						t.Fatal("full overwrite retained a previous frame identity")
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_named_move_bitfield_test.go b/arm64_named_move_bitfield_test.go
new file mode 100644
index 000000000..a51e66685
--- /dev/null
+++ b/arm64_named_move_bitfield_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64NamedMoveBitfieldCase struct {
+	op                       Op
+	width, shift, immr, imms int
+	source, destination      int
+	form                     string
+}
+
+func arm64NamedMoveBitfieldCases() []arm64NamedMoveBitfieldCase {
+	var cases []arm64NamedMoveBitfieldCase
+	for _, width := range []int{32, 64} {
+		suffix := ""
+		if width == 32 {
+			suffix = "W"
+		}
+		for _, op := range []Op{"MOVZ", "MOVN"} {
+			for shift := 0; shift < width; shift += 16 {
+				for _, destination := range []int{2, 31} {
+					cases = append(cases, arm64NamedMoveBitfieldCase{
+						op: op + Op(suffix), width: width, shift: shift, destination: destination,
+					})
+				}
+			}
+		}
+		for _, op := range []Op{"BFM", "SBFM", "UBFM"} {
+			for _, immediate := range [][2]int{{0, 0}, {0, width - 1}, {width - 1, 0},
+				{width - 1, width - 1}, {3, 17}, {width - 3, 11}} {
+				for _, form := range []string{"distinct", "alias", "zero-source", "discard"} {
+					source, destination := 1, 2
+					switch form {
+					case "alias":
+						destination = source
+					case "zero-source":
+						source = 31
+					case "discard":
+						destination = 31
+					}
+					cases = append(cases, arm64NamedMoveBitfieldCase{
+						op: op + Op(suffix), width: width, immr: immediate[0], imms: immediate[1],
+						source: source, destination: destination, form: form,
+					})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func (row arm64NamedMoveBitfieldCase) instruction() string {
+	register := func(index int) string {
+		if index == 31 {
+			return "ZR"
+		}
+		return fmt.Sprintf("R%d", index)
+	}
+	if strings.HasPrefix(string(row.op), "MOV") {
+		// Go spells the already shifted field, not an extra shift operand.
+		return fmt.Sprintf("%s $%#x,%s", row.op, uint64(0xa55a)<<row.shift, register(row.destination))
+	}
+	// These are encoded immr/imms, not the aliases' lsb/width operands.
+	return fmt.Sprintf("%s $%d,%s,$%d,%s", row.op, row.immr, register(row.source), row.imms, register(row.destination))
+}
+
+func (row arm64NamedMoveBitfieldCase) word() uint32 {
+	if strings.HasPrefix(string(row.op), "MOV") {
+		base := uint32(0x12800000)
+		if strings.HasPrefix(string(row.op), "MOVZ") {
+			base = 0x52800000
+		}
+		if row.width == 64 {
+			base |= 1 << 31
+		}
+		return base | uint32(row.shift/16)<<21 | 0xa55a<<5 | uint32(row.destination)
+	}
+	base := uint32(0x13000000)
+	if strings.HasPrefix(string(row.op), "BFM") {
+		base = 0x33000000
+	} else if strings.HasPrefix(string(row.op), "UBFM") {
+		base = 0x53000000
+	}
+	if row.width == 64 {
+		base |= 1<<31 | 1<<22
+	}
+	return base | uint32(row.immr)<<16 | uint32(row.imms)<<10 | uint32(row.source)<<5 | uint32(row.destination)
+}
+
+func (row arm64NamedMoveBitfieldCase) value(input, initial uint64) uint64 {
+	if row.destination == 31 {
+		return initial
+	}
+	if strings.HasPrefix(string(row.op), "MOV") {
+		value := uint64(0xa55a) << row.shift
+		if strings.HasPrefix(string(row.op), "MOVN") {
+			value = ^value
+		}
+		if row.width == 32 {
+			value &= 0xffffffff
+		}
+		return value
+	}
+	if row.source == 31 {
+		input = 0
+	}
+	if row.destination == 1 {
+		initial = input
+	}
+	// Select each architectural output bit independently. This does not repeat
+	// the lowerer's BFI/BFXIL/SBFX aliases or its shift/mask implementation.
+	var result uint64
+	top := (row.imms - row.immr + row.width) % row.width
+	for bit := 0; bit < row.width; bit++ {
+		set := false
+		if bit > top {
+			switch {
+			case strings.HasPrefix(string(row.op), "BFM"):
+				set = initial>>bit&1 != 0
+			case strings.HasPrefix(string(row.op), "SBFM"):
+				set = input>>row.imms&1 != 0
+			}
+		} else {
+			selected := (bit + row.immr) % row.width
+			if selected <= row.imms {
+				set = input>>selected&1 != 0
+			} else if strings.HasPrefix(string(row.op), "BFM") {
+				set = initial>>bit&1 != 0
+			}
+		}
+		if set {
+			result |= uint64(1) << bit
+		}
+	}
+	return result
+}
+
+func TestARM64NamedMoveWideAndBitfieldGoEncoding(t *testing.T) {
+	rows := arm64NamedMoveBitfieldCases()
+	if len(rows) != 168 {
+		t.Fatalf("complete named move/bitfield axes = %d, want 168", len(rows))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT namedencoding(SB),4,$0-0\n")
+	for _, row := range rows {
+		source.WriteString(row.instruction() + "\n")
+	}
+	source.WriteString("RET\n")
+	actual := arm64ImmediateOriginalGoBytes(t, source.String(), "linux")
+	if len(actual) < 4*(len(rows)+1) {
+		t.Fatal("original Go named instruction bytes are incomplete")
+	}
+	for index, row := range rows {
+		if got := binary.LittleEndian.Uint32(actual[4*index:]); got != row.word() {
+			t.Fatalf("%s: original Go word = %08x, want %08x", row.instruction(), got, row.word())
+		}
+	}
+}
+
+func TestARM64NamedMoveWideAndBitfieldValuesThreeAPIs(t *testing.T) {
+	const input, initial = uint64(0x89abcdef76543210), uint64(0xfedcba9876543210)
+	var source, declarations strings.Builder
+	declarations.WriteString("package namedinteger\n")
+	signatures := map[string]FuncSig{}
+	rows := arm64NamedMoveBitfieldCases()
+	for index, row := range rows {
+		name := fmt.Sprintf("Named%d", index)
+		result := row.destination
+		if result == 31 {
+			result = 2 // ZR writes cannot change the full nonzero canary.
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVD $%#x,R1\nMOVD $%#x,R2\n%s\nMOVD R%d,ret+0(FP)\nRET\n",
+			name, input, initial, row.instruction(), result)
+		fmt.Fprintf(&declarations, "func %s() uint64\n", name)
+		signatures[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{
+			Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+		}}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "test/namedinteger", declarations.String())
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			var module llvm.Module
+			options := Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple, Sigs: signatures, ResolveSym: resolve}
+			switch api {
+			case "text":
+				var ir string
+				ir, err = Translate(file, options)
+				if err == nil {
+					module, err = parseIRModuleInContext(context, ir)
+				}
+			case "module":
+				module, err = TranslateModuleInContext(context, file, options)
+			case "GoModule":
+				var translated *GoModuleTranslation
+				translated, err = translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: arm64LinuxGNUTriple, ResolveSym: resolve,
+				})
+				if translated != nil {
+					module = translated.Module
+				}
+			}
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal("complete named family translation", err)
+			}
+			if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal(err)
+			}
+			passes := llvm.NewPassBuilderOptions()
+			defer passes.Dispose()
+			passes.SetVerifyEach(true)
+			if err := module.RunPasses("function(sroa,mem2reg,instcombine,simplifycfg)", llvm.TargetMachine{}, passes); err != nil {
+				t.Fatal(err)
+			}
+			for index, row := range rows {
+				fn := module.NamedFunction(fmt.Sprintf("Named%d", index))
+				if fn.IsNil() {
+					t.Fatal("missing named numerical fixture", index)
+				}
+				returns := 0
+				for block := fn.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+					for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+						if instruction.InstructionOpcode() != llvm.Ret {
+							continue
+						}
+						returns++
+						if instruction.OperandsCount() != 1 || instruction.Operand(0).IsAConstantInt().IsNil() ||
+							instruction.Operand(0).ZExtValue() != row.value(input, initial) {
+							t.Errorf("%s/%s: %s, want %016x", row.instruction(), row.form, instruction.String(), row.value(input, initial))
+						}
+					}
+				}
+				if returns != 1 {
+					t.Error("numerical fixture must have one return", index, returns)
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_named_pc_branch.go b/arm64_named_pc_branch.go
new file mode 100644
index 000000000..113828e30
--- /dev/null
+++ b/arm64_named_pc_branch.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func arm64NamedPCOperand(ins Instr) (int, bool) {
+	op := Op(strings.ToUpper(string(ins.Op)))
+	if dot := strings.IndexByte(string(op), '.'); dot >= 0 {
+		op = op[:dot]
+	}
+	index, count := 0, 1
+	switch op {
+	case "B", "JMP", "BL", "CALL", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT", "BHS", "BLS", "BMI", "BPL", "BVS", "BVC", "BCC", "BCS":
+	case "CBZ", "CBNZ", "CBZW", "CBNZW":
+		index, count = 1, 2
+	case "TBZ", "TBNZ":
+		index, count = 2, 3
+	case "ADR", "ADRP":
+		count = 2
+	default:
+		return 0, false
+	}
+	return index, len(ins.Args) == count && ins.Args[index].Kind == OpMem && ins.Args[index].Mem.Base == PC
+}
+
+// normalizeARM64NamedPCRelative resolves Go assembler n(PC) operands before
+// block splitting or raw-pool removal changes source instruction ordinals.
+// cmd/asm counts each Prog, including zero-width metadata, but not labels.
+func normalizeARM64NamedPCRelative(fn Func) (Func, error) {
+	linear := make([]int, 0, len(fn.Instrs))
+	known := make(map[string]bool)
+	for i, ins := range fn.Instrs {
+		if ins.Op == OpLABEL {
+			if len(ins.Args) == 1 && ins.Args[0].Kind == OpLabel {
+				known[ins.Args[0].Sym] = true
+			}
+		} else {
+			linear = append(linear, i)
+		}
+	}
+	labels := make(map[int]string)
+	replacements := make(map[int]Instr)
+	for ordinal, index := range linear {
+		ins := fn.Instrs[index]
+		argument, relative := arm64NamedPCOperand(ins)
+		if !relative {
+			continue
+		}
+		operand := ins.Args[argument]
+		if strings.Contains(string(ins.Op), ".") || operand.Mem.Index != "" {
+			return Func{}, fmt.Errorf("ARM64 invalid named PC-relative operand: %q", ins.Raw)
+		}
+		off := operand.Mem.Off
+		if off < -int64(ordinal) || off >= int64(len(linear)-ordinal) {
+			return Func{}, fmt.Errorf("ARM64 named PC-relative target %d(PC) is outside TEXT: %q", off, ins.Raw)
+		}
+		target := linear[ordinal+int(off)]
+		label, exists := labels[target]
+		if !exists {
+			label = fmt.Sprintf("__arm64_pc_target_%d", target)
+			for known[label] {
+				label += "_"
+			}
+			known[label] = true
+			labels[target] = label
+		}
+		ins.Args = append([]Operand(nil), ins.Args...)
+		ins.Args[argument] = Operand{Kind: OpIdent, Ident: label}
+		replacements[index] = ins
+	}
+	if len(replacements) == 0 {
+		return fn, nil
+	}
+	result := fn
+	result.Instrs = make([]Instr, 0, len(fn.Instrs)+len(labels))
+	for i, ins := range fn.Instrs {
+		if label, exists := labels[i]; exists {
+			result.Instrs = append(result.Instrs, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label}}, Raw: label + ":"})
+		}
+		if replacement, exists := replacements[i]; exists {
+			ins = replacement
+		}
+		result.Instrs = append(result.Instrs, ins)
+	}
+	return result, nil
+}
diff --git a/arm64_named_pc_branch_runtime_test.go b/arm64_named_pc_branch_runtime_test.go
new file mode 100644
index 000000000..a51c786ab
--- /dev/null
+++ b/arm64_named_pc_branch_runtime_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64NamedPCFamilyRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	conditions := map[string]string{
+		"B": "1", "JMP": "1", "BEQ": "a == b", "BNE": "a != b",
+		"BLO": "a < b", "BCC": "a < b", "BHS": "a >= b", "BCS": "a >= b",
+		"BHI": "a > b", "BLS": "a <= b", "BLT": "(int64_t)a < (int64_t)b",
+		"BGE": "(int64_t)a >= (int64_t)b", "BLE": "(int64_t)a <= (int64_t)b",
+		"BGT": "(int64_t)a > (int64_t)b", "BMI": "(a - b) >> 63",
+		"BPL": "!((a - b) >> 63)", "BVS": "((a ^ b) & (a ^ (a - b))) >> 63",
+		"BVC": "!(((a ^ b) & (a ^ (a - b))) >> 63)",
+		"CBZ": "a == 0", "CBNZ": "a != 0", "CBZW": "(uint32_t)a == 0", "CBNZW": "(uint32_t)a != 0",
+	}
+	for _, op := range arm64NamedPCBranchOps {
+		if op == "BL" || op == "CALL" {
+			continue
+		}
+		bits := []int{3}
+		if op == "TBZ" || op == "TBNZ" {
+			bits = []int{0, 31, 32, 63}
+		}
+		for _, bit := range bits {
+			name := fmt.Sprintf("named_%s_%d", strings.ToLower(op), bit)
+			instruction := arm64NamedPCBranchInstruction(op, "3(PC)")
+			condition := conditions[op]
+			if op == "TBZ" || op == "TBNZ" {
+				instruction = fmt.Sprintf("%s $%d, R0, 3(PC)", op, bit)
+				condition = fmt.Sprintf("((a >> %d) & 1) %s 0", bit, map[string]string{"TBZ": "==", "TBNZ": "!="}[op])
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP), R0\nMOVD b+8(FP), R1\nMOVD $0, R2\nCMP R1, R0\n%s\nADD $1, R2\nADD $2, R2\nMOVD R2, ret+16(FP)\nRET\n", name, instruction)
+			sigs[name] = arm64NamedPCBranchSig(name)
+			fmt.Fprintf(&declarations, "extern uint64_t %s(uint64_t, uint64_t);\n", name)
+			fmt.Fprintf(&checks, "    if (%s(a, b) != ((%s) ? 0 : 3)) { fprintf(stderr, \"%s a=%%llx b=%%llx failed\\n\", (unsigned long long)a, (unsigned long long)b); return 1; }\n", name, condition, name)
+		}
+	}
+	source.WriteString(`TEXT named_backward(SB),$0-24
+	MOVD a+0(FP), R0
+	MOVD $0, R2
+again:
+	ADD $1, R2
+	SUBS $1, R0
+	BNE -2(PC)
+	MOVD R2, ret+16(FP)
+	RET
+`)
+	sigs["named_backward"] = arm64NamedPCBranchSig("named_backward")
+	for _, op := range []string{"BL", "CALL"} {
+		name := "named_" + strings.ToLower(op)
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP), R0\n%s 4(PC)\n%s_resume:\nADD $2, R0\nMOVD R0, ret+16(FP)\nRET\nADD $5, R0\nB %s_resume\n", name, op, name, name)
+		sigs[name] = arm64NamedPCBranchSig(name)
+		fmt.Fprintf(&declarations, "extern uint64_t %s(uint64_t, uint64_t);\n", name)
+		fmt.Fprintf(&checks, "    if (%s(a, b) != a + 7) { fprintf(stderr, \"%s local continuation failed\\n\"); return 2; }\n", name, name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+` + declarations.String() + `extern uint64_t named_backward(uint64_t, uint64_t);
+int main(void) {
+	const uint64_t values[] = {0, 1, UINT64_MAX, UINT64_C(0x80000000), UINT64_C(0x100000000),
+		UINT64_C(0x8000000000000000), UINT64_C(0x7fffffffffffffff), UINT64_C(0x0123456789abcdef)};
+	for (unsigned i = 0; i < sizeof values / sizeof values[0]; i++) {
+		for (unsigned j = 0; j < sizeof values / sizeof values[0]; j++) {
+			uint64_t a = values[i], b = values[j];
+` + checks.String() + `		}
+	}
+	for (uint64_t n = 1; n < 10; n++) if (named_backward(n, 0) != n) return 3;
+	return 0;
+}
+`
+	return ir, main
+}
+
+func TestCrossLinuxRuntimeMatrixARM64NamedPCBranchFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	ir, main := arm64NamedPCFamilyRuntime(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "named_pc_family", triple, ir, main, runner)
+}
diff --git a/arm64_named_pc_branch_test.go b/arm64_named_pc_branch_test.go
new file mode 100644
index 000000000..65ff03efc
--- /dev/null
+++ b/arm64_named_pc_branch_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64NamedPCBranchRegression(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT pcBitSkip(SB),$0-16
+	MOVD value+0(FP), R0
+	MOVD $0, R1
+	TBZ $3, R0, 3(PC)
+	ADD $1, R1
+	ADD $2, R1
+	MOVD R1, ret+8(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{
+		Name: "pcBitSkip", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		},
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t pcBitSkip(uint64_t);
+int main(void) {
+	for (uint64_t value = 0; value < 16; value++) {
+		uint64_t want = value & 8 ? 3 : 0;
+		uint64_t got = pcBitSkip(value);
+		if (got != want) {
+			fprintf(stderr, "TBZ 3(PC) value=%llu got=%llu want=%llu\n",
+				(unsigned long long)value, (unsigned long long)got, (unsigned long long)want);
+			return 1;
+		}
+	}
+	return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "named_pc_branch", triple, ir, main, runner)
+}
+
+var arm64NamedPCBranchOps = []string{
+	"B", "JMP", "BL", "CALL", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT",
+	"BHS", "BLS", "BMI", "BPL", "BVS", "BVC", "BCC", "BCS", "CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ",
+}
+
+func arm64NamedPCBranchInstruction(op, target string) string {
+	switch op {
+	case "CBZ", "CBNZ", "CBZW", "CBNZW":
+		return op + " R0, " + target
+	case "TBZ", "TBNZ":
+		return op + " $3, R0, " + target
+	case "ADR", "ADRP":
+		return op + " " + target + ", R3"
+	default:
+		return op + " " + target
+	}
+}
+
+func arm64NamedPCBranchSig(name string) FuncSig {
+	return FuncSig{
+		Name: name, Args: []LLVMType{I64, I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+		},
+	}
+}
+
+func TestARM64NamedPCBranchCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, op := range append(append([]string(nil), arm64NamedPCBranchOps...), "ADR", "ADRP") {
+		for _, off := range []int{0, 1, 3, -1} {
+			t.Run(fmt.Sprintf("%s/%d", op, off), func(t *testing.T) {
+				source := "TEXT pcForms(SB),$0-24\nMOVD value+0(FP), R0\nMOVD $0, R1\nCMP $0, R0\n" +
+					arm64NamedPCBranchInstruction(op, fmt.Sprintf("%d(PC)", off)) + "\nADD $1, R1\nADD $2, R1\nMOVD R1, ret+16(FP)\nRET\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := arm64NamedPCBranchSig("pcForms")
+				for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc"} {
+					ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, triple, "named-pc.ll", "named-pc.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64NamedPCBranchRejectsUnresolvedTargets(t *testing.T) {
+	// Out-of-TEXT targets exercise plan9asm's own input-safety boundary.
+	// Stock Go panics after its range diagnostic for every fixture below;
+	// TestGoAssemblerKnownMalformedInputDefects records those tool defects
+	// separately, without granting them ordinary Go rejection evidence.
+	for _, op := range arm64NamedPCBranchOps {
+		for _, target := range []string{"999(PC)", "-999(PC)", "9223372036854775807(PC)", "-9223372036854775808(PC)"} {
+			t.Run(op+"/"+target, func(t *testing.T) {
+				source := "TEXT pcInvalid(SB),$0-24\n" + arm64NamedPCBranchInstruction(op, target) + "\nRET\n"
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := arm64NamedPCBranchSig("pcInvalid")
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}})
+				if err == nil || !strings.Contains(err.Error(), "outside TEXT") {
+					t.Fatalf("%s %s was not rejected precisely: %v", op, target, err)
+				}
+			})
+		}
+	}
+	for _, op := range []string{"TBZ", "TBNZ"} {
+		for _, bit := range []int{-1, 64} {
+			source := fmt.Sprintf("TEXT pcInvalid(SB),$0-24\n%s $%d, R0, 1(PC)\nRET\n", op, bit)
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := arm64NamedPCBranchSig("pcInvalid")
+			if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}}); err == nil {
+				t.Fatalf("%s accepted invalid bit %d", op, bit)
+			}
+		}
+	}
+}
+
+func TestARM64NamedPCNormalizationKeepsInstructionOrdinals(t *testing.T) {
+	const source = `TEXT pcOrdinals(SB),$0-0
+	MOVD $0, R0
+	B 3(PC)
+__arm64_pc_target_7:
+	PCDATA $0, $0
+	MOVD $0x123456789abcdef, R0
+	done:
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, err := normalizeARM64NamedPCRelative(file.Funcs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	var target string
+	for _, ins := range fn.Instrs {
+		if ins.Op == "B" {
+			target = ins.Args[0].Ident
+		}
+	}
+	for i, ins := range fn.Instrs {
+		if ins.Op == OpLABEL && ins.Args[0].Sym == target {
+			if target == "__arm64_pc_target_7" {
+				t.Fatal("relative target collided with an existing source label")
+			}
+			if i+1 >= len(fn.Instrs) || fn.Instrs[i+1].Op != OpRET {
+				t.Fatalf("3(PC) did not target RET across metadata/expanded MOVD: %+v", fn.Instrs)
+			}
+			return
+		}
+	}
+	t.Fatal("exact relative target label missing")
+}
diff --git a/arm64_named_sve_count_test.go b/arm64_named_sve_count_test.go
new file mode 100644
index 000000000..445ce2e5e
--- /dev/null
+++ b/arm64_named_sve_count_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Go's assembler accepts these physical encodings through WORD. Named CNT
+// is the existing one-GP-destination source form, not a new Go syntax claim.
+var arm64NamedSVECountCases = []struct {
+	op   Op
+	word uint32
+}{
+	{"CNTB", 0x0420e3e0}, {"CNTH", 0x0460e3e0},
+	{"CNTW", 0x04a0e3e0}, {"CNTD", 0x04e0e3e0},
+}
+
+func TestARM64NamedSVECountFeatureForms(t *testing.T) {
+	for _, row := range arm64NamedSVECountCases {
+		for register := 0; register <= 30; register++ {
+			instruction := Instr{Op: row.op, Args: []Operand{{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", register))}}}
+			if got := inferFuncTargetFeatures(ArchARM64, Func{Instrs: []Instr{instruction}}); got != "+sve" {
+				t.Errorf("%s R%d: features %q, want +sve", row.op, register, got)
+			}
+		}
+		for _, instruction := range []Instr{
+			{Op: row.op},
+			{Op: row.op, Args: []Operand{{Kind: OpImm, Imm: 0}}},
+			{Op: row.op, Args: []Operand{{Kind: OpMem}}},
+			{Op: row.op, Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpReg, Reg: "R1"}}},
+			{Op: Op(string(row.op) + ".S"), Args: []Operand{{Kind: OpReg, Reg: "R0"}}},
+		} {
+			if got := inferFuncTargetFeatures(ArchARM64, Func{Instrs: []Instr{instruction}}); got != "" {
+				t.Errorf("malformed count %+v supplied features %q", instruction, got)
+			}
+		}
+		for _, register := range []Reg{ZR, SP, "RSP", "R31", "R32", "W0", "F0", "V0.B16", "Z0.B"} {
+			instruction := Instr{Op: row.op, Args: []Operand{{Kind: OpReg, Reg: register}}}
+			if got := inferFuncTargetFeatures(ArchARM64, Func{Instrs: []Instr{instruction}}); got != "" {
+				t.Errorf("%s %s supplied features %q", row.op, register, got)
+			}
+		}
+	}
+}
+
+func arm64SVECountFeaturesFromIR(t *testing.T, ir string) map[string]bool {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	features := make(map[string]bool)
+	for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+		if function.FirstBasicBlock().IsNil() {
+			continue
+		}
+		for _, attribute := range function.GetFunctionAttributes() {
+			if attribute.IsString() && attribute.GetStringKind() == "target-features" {
+				for _, feature := range strings.Split(attribute.GetStringValue(), ",") {
+					features[feature] = true
+				}
+			}
+		}
+	}
+	return features
+}
+
+func TestARM64NamedSVECountLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, row := range arm64NamedSVECountCases {
+		original := fmt.Sprintf("TEXT original(SB),$0-0\nWORD $%#08x\nRET\n", row.word)
+		requireARM64GoAssemblerResult(t, original, true)
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(string(row.op)+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, triple, targetBackendCase{
+						arch: ArchARM64, goarch: "arm64", result: true,
+						body: string(row.op) + " R0\nMOVD R0, ret+0(FP)\nRET",
+					})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !arm64SVECountFeaturesFromIR(t, ir)["+sve"] {
+						t.Fatal("actual count caller lacks required +sve")
+					}
+					compileLLVMToObject(t, llc, triple, "count.ll", "count.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64SVECountCustomAttributes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, row := range arm64NamedSVECountCases {
+		for _, body := range []string{string(row.op) + " R0", fmt.Sprintf("WORD $%#08x", row.word)} {
+			for _, attrs := range []string{"nounwind", `nounwind "target-features"="+neon"`} {
+				for _, api := range []string{"text", "module"} {
+					t.Run(body+"/"+attrs+"/"+api, func(t *testing.T) {
+						ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", targetBackendCase{
+							arch: ArchARM64, goarch: "arm64", result: true, attrs: attrs,
+							body: body + "\nMOVD R0, ret+0(FP)\nRET",
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						features := arm64SVECountFeaturesFromIR(t, ir)
+						if !features["+sve"] || !strings.Contains(ir, "nounwind") ||
+							strings.Contains(attrs, "+neon") && !features["+neon"] {
+							t.Fatalf("required or custom attributes lost: %v", features)
+						}
+						compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "count.ll", "count.o", ir)
+					})
+				}
+			}
+			for _, api := range []string{"text", "module"} {
+				t.Run(body+"/disabled/"+api, func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", targetBackendCase{
+						arch: ArchARM64, goarch: "arm64", attrs: `nounwind "target-features"="+neon,-sve"`,
+						body: body + "\nRET",
+					})
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("explicit -sve was overridden: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64NamedSVECountRejectsInvalidForms(t *testing.T) {
+	for _, row := range arm64NamedSVECountCases {
+		for _, operands := range []string{"", "R0,R1", "$1", "(R0)", "ZR", "RSP", "R31", "F0", "V0.B16", "Z0.B"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(string(row.op)+"/"+operands+"/"+api, func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", targetBackendCase{
+						arch: ArchARM64, goarch: "arm64", body: string(row.op) + " " + operands + "\nRET",
+					})
+					if err == nil || ir != "" {
+						t.Fatalf("invalid count form succeeded: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_nanosleep_emission_test.go b/arm64_nanosleep_emission_test.go
new file mode 100644
index 000000000..5bfd4d21e
--- /dev/null
+++ b/arm64_nanosleep_emission_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func arm64NanosleepEmittedProof(t *testing.T) (*arm64Ctx, int, Instr) {
+	t.Helper()
+	c := arm64NanosleepProofContext(t)
+	c.emitEntryAllocasAndArgInit()
+	c.machineAvailability = newARM64MachineAvailability(c)
+	if err := c.lowerBlocks(); err != nil {
+		t.Fatal("actual nanosleep lowering prerequisite", err)
+	}
+	if err := c.machineAvailability.validate(); err != nil {
+		t.Fatal("complete numerical/byte-defined input prerequisite", err)
+	}
+	count, start := 0, -1
+	var original Instr
+	for offset, native := range c.machineAvailability.nativeIR {
+		if native.syscall == nil {
+			continue
+		}
+		count++
+		if strings.Contains(native.line, "call i64 @syscall(") {
+			start, original = offset, native.syscall.source
+			c.currentBlock, c.currentInstruction = native.syscall.block, native.syscall.instruction
+			c.machineAvailability.current = c.currentBlock
+		}
+	}
+	if count != 2 || start < 0 {
+		t.Fatal("actual syscall/errno pair lost its distinct source-bound effects")
+	}
+	c.machineAvailability.blocks[c.currentBlock].effects = nil
+	return c, start, original
+}
+
+func TestARM64NanosleepEmittedBorrowIsExactAndNotNeutral(t *testing.T) {
+	for _, change := range []struct {
+		name  string
+		apply func(*arm64Ctx, int)
+	}{
+		{"unaltered", func(*arm64Ctx, int) {}},
+		{"copied-input", func(c *arm64Ctx, _ int) {
+			copy := *c.nanosleepInput
+			c.nanosleepInput = &copy
+		}},
+		{"lost-original", func(c *arm64Ctx, _ int) { c.nanosleepOriginal = nil }},
+		{"copied-emission", func(c *arm64Ctx, start int) {
+			native := c.machineAvailability.nativeIR[start]
+			copy := *native.syscall
+			native.syscall = &copy
+			c.machineAvailability.nativeIR[start] = native
+		}},
+		{"source-changed", func(c *arm64Ctx, _ int) { c.normalizedSource.Instrs[1].Raw += " changed" }},
+		{"target-changed", func(c *arm64Ctx, _ int) { c.targetTriple = "aarch64-unknown-linux-musl" }},
+		{"operand-line-changed", func(c *arm64Ctx, start int) {
+			native := c.machineAvailability.nativeIR[start]
+			native.line = strings.Replace(native.line, "i64 0, i64 0, i64 0, i64 0)", "i64 1, i64 0, i64 0, i64 0)", 1)
+			c.machineAvailability.nativeIR[start] = native
+		}},
+		{"erased-memory-effect", func(c *arm64Ctx, start int) {
+			native := c.machineAvailability.nativeIR[start]
+			native.store = false
+			c.machineAvailability.nativeIR[start] = native
+		}},
+		{"foreign-call", func(c *arm64Ctx, _ int) {
+			c.b.WriteString("  %foreign = call i64 @syscall(i64 101, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0)\n")
+		}},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			c, start, original := arm64NanosleepEmittedProof(t)
+			change.apply(c, start)
+			c.recordMachineOpaqueIR(start, original)
+			stores, opaque := 0, 0
+			for _, effect := range c.machineAvailability.blocks[c.currentBlock].effects {
+				if effect.store {
+					stores++
+				}
+				if effect.opaque {
+					opaque++
+				}
+			}
+			if change.name == "unaltered" {
+				if stores != 2 || opaque != 0 {
+					t.Fatalf("typed syscall bridge erased real effects: stores=%d opaque=%d", stores, opaque)
+				}
+			} else if opaque == 0 {
+				t.Fatal("stale/copied/changed borrow was accepted as an actual emission")
+			}
+		})
+	}
+}
diff --git a/arm64_nanosleep_input.go b/arm64_nanosleep_input.go
new file mode 100644
index 000000000..43bd27cc1
--- /dev/null
+++ b/arm64_nanosleep_input.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// The Linux A64 nanosleep request is two native int64 fields. With R1=NULL
+// the kernel copies these 16 input bytes and never writes a user remainder,
+// including on interruption. This does not grant an arbitrary syscall, native
+// entry, output buffer, return/NZCV observation or a caller-frame address.
+// See Linux v6.12 include/uapi/linux/time_types.h and kernel/time/hrtimer.c.
+const arm64NanosleepRequestBytes = int64(16)
+
+type arm64NanosleepInput struct {
+	form arm64SyscallForm
+	span arm64PrivateDataSpan
+}
+
+type arm64NanosleepInputProof struct {
+	identity *arm64NanosleepInputProof
+	owner    *arm64Ctx
+	source   Func
+	sig      FuncSig
+	target   string
+	inputs   map[[2]int]arm64NanosleepInput
+	sealed   map[[2]int]arm64NanosleepInput
+	required bool // a diagnostic obligation, never a permission
+}
+
+func arm64NanosleepCloneSource(fn Func) Func {
+	fn.Instrs = append([]Instr(nil), fn.Instrs...)
+	for i := range fn.Instrs {
+		fn.Instrs[i].Args = append([]Operand(nil), fn.Instrs[i].Args...)
+		for j := range fn.Instrs[i].Args {
+			fn.Instrs[i].Args[j].RegList = append([]Reg(nil), fn.Instrs[i].Args[j].RegList...)
+		}
+	}
+	return fn
+}
+
+func arm64NanosleepCloneSignature(sig FuncSig) FuncSig {
+	sig.Args = append([]LLVMType(nil), sig.Args...)
+	sig.ArgRegs = append([]Reg(nil), sig.ArgRegs...)
+	sig.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+	sig.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+	for i := range sig.Frame.Params {
+		sig.Frame.Params[i].Fields = append([]int(nil), sig.Frame.Params[i].Fields...)
+	}
+	for i := range sig.Frame.Results {
+		sig.Frame.Results[i].Fields = append([]int(nil), sig.Frame.Results[i].Fields...)
+	}
+	return sig
+}
+
+func (proof *arm64NanosleepInputProof) matchesSource(fn Func, sig FuncSig, target string) bool {
+	return proof != nil && proof.identity == proof && proof.target == target &&
+		reflect.DeepEqual(proof.source, fn) && reflect.DeepEqual(proof.sig, sig) &&
+		reflect.DeepEqual(proof.inputs, proof.sealed)
+}
+
+// Reuse the existing bounded private-data CFG interpreter, store grammar,
+// disjunctive joins and convergence budget. The collector is not a certificate:
+// publication occurs only after every original component closes successfully.
+func arm64NanosleepInputForSource(fn Func, transport *arm64PrivateFrameTransport, target string) (*arm64NanosleepInputProof, bool) {
+	hasTrap, required := false, false
+	for _, original := range fn.Instrs {
+		ins := arm64ControlDecode(original)
+		hasTrap = hasTrap || arm64ControlOp(ins) == "SVC"
+		if form, known := parseARM64GPRegisterMove(ins); known &&
+			ins.Args[1].Reg == "R8" && form.source.Kind == OpImm && form.source.Imm == 101 {
+			// An exact literal declaration creates only a denial obligation.
+			// It cannot publish a certificate, restore undefined inputs or
+			// bypass the complete CFG, declaration and kernel target checks.
+			required = true
+		}
+	}
+	required = required && hasTrap
+	if transport == nil || !arm64SourceGoFrame(fn).present || fn.FrameSize < 0 ||
+		strings.HasSuffix(fn.Sym, "<ABIInternal>") || transport.entry.Ret != Void ||
+		transport.entry.ARM64GoRegisterABI != nil || transport.entry.ARM64ClosureABI != nil ||
+		len(transport.entry.ArgRegs) != 0 || len(transport.entry.Frame.Results) != 0 ||
+		fn.arm64PrivateSourceAdded != 0 || fn.arm64PrivateCallSource != nil {
+		return nil, required
+	}
+	for _, typ := range transport.entry.Args {
+		if typ != I1 && typ != I8 && typ != I16 && typ != I32 && typ != I64 {
+			return nil, required
+		}
+	}
+	for _, original := range fn.Instrs {
+		op := arm64ControlOp(arm64ControlDecode(original))
+		if op == "CALL" || op == "BL" || op == "BLR" {
+			return nil, required
+		}
+	}
+	if !hasTrap {
+		return nil, false
+	}
+	proof := &arm64NanosleepInputProof{source: arm64NanosleepCloneSource(fn),
+		sig: arm64NanosleepCloneSignature(transport.entry), target: target,
+		inputs: make(map[[2]int]arm64NanosleepInput), required: required}
+	query := *transport // value-only query; no caller/source or resource owner
+	query.nanosleep = proof
+	if _, err := arm64PrivateDataProofDetails(fn, &query); err != nil || len(proof.inputs) == 0 {
+		return nil, proof.required
+	}
+	proof.identity = proof
+	proof.sealed = make(map[[2]int]arm64NanosleepInput, len(proof.inputs))
+	for point, input := range proof.inputs {
+		proof.sealed[point] = input
+	}
+	return proof, proof.required
+}
+
+func arm64NanosleepExactNumber(value arm64PrivateDataValue, number uint64) bool {
+	return !value.frame && value.interval.low == number && value.interval.high == number
+}
+
+// An unsealed collector and a sealed replay use the same operand roles. The
+// sealed replay may not modify its inventory or acquire a new initialized span.
+func (proof *arm64NanosleepInputProof) consume(state *arm64PrivateDataState, fn Func, point [2]int, ins Instr) bool {
+	if proof == nil || !reflect.DeepEqual(proof.source, fn) {
+		return false
+	}
+	if proof.identity == nil && arm64NanosleepExactNumber(state.value("R8"), 101) {
+		proof.required = true
+	}
+	form, err := parseARM64SyscallForm(proof.target, ins)
+	if err != nil || form.os != arm64SyscallLinux || form.number != "R8" || form.trap != 0 ||
+		len(ins.Args) == 1 && ins.Args[0].Imm != 0 ||
+		!arm64NanosleepExactNumber(state.value("R8"), 101) ||
+		!arm64NanosleepExactNumber(state.value("R1"), 0) {
+		return false
+	}
+	address := state.value("R0")
+	if !address.frame || address.mixed || address.interval.low != address.interval.high ||
+		address.interval.low < 8 || fn.FrameSize > arm64MaxLocalStackSpan ||
+		address.interval.high > uint64(fn.FrameSize+8-arm64NanosleepRequestBytes) {
+		return false
+	}
+	input := arm64NanosleepInput{form: form, span: arm64PrivateDataSpan{
+		low: int64(address.interval.low), end: int64(address.interval.low) + arm64NanosleepRequestBytes}}
+	if proof.identity == nil {
+		for offset := input.span.low; offset < input.span.end; offset++ {
+			if !state.initialized[offset] {
+				return false
+			}
+		}
+		if previous, present := proof.inputs[point]; present && previous != input {
+			return false
+		}
+		proof.inputs[point] = input
+	} else if proof.identity != proof || proof.inputs[point] != input {
+		return false
+	}
+	// Linux normal return overwrites only R0. Do not wash R1, other GP aliases,
+	// global escaped addresses, continuation cells or the NZCV bank clean.
+	state.assign("R0", arm64PrivateDataUnknown)
+	return true
+}
+
+func arm64NanosleepNumericalInstruction(ins Instr) bool {
+	op := arm64ControlOp(ins)
+	if op == OpTEXT || op == OpLABEL || op == "NOP" || op == "CMP" || op == "CMPW" {
+		return true
+	}
+	if _, known := arm64PrivateDataMemory(ins); known {
+		return true
+	}
+	if _, known := parseARM64GPRegisterMove(ins); known {
+		return true
+	}
+	if _, handled, err := parseARM64GPDataForm(op, ins); handled {
+		return err == nil
+	}
+	if _, handled, err := parseARM64GPImmediateForm(op, ins); handled {
+		return err == nil
+	}
+	if _, handled, err := parseARM64RegisterAddressForm(op, ins); handled {
+		return err == nil
+	}
+	// FP reads use the existing exact numerical declaration and lowerer. This
+	// does not authorize a memory pointer, symbol or hidden native state.
+	if op == "MOVD" || op == "MOVW" || op == "MOVWU" || op == "MOVH" || op == "MOVHU" || op == "MOVB" || op == "MOVBU" {
+		return len(ins.Args) == 2 && ins.Args[0].Kind == OpFP && ins.Args[1].Kind == OpReg
+	}
+	return false
+}
+
+func (c *arm64Ctx) nanosleepInputAt(point [2]int) (arm64NanosleepInput, bool) {
+	proof, original := c.nanosleepInput, c.nanosleepOriginal
+	if proof == nil || proof.owner != c || !proof.matchesSource(c.normalizedSource, c.sig, c.targetTriple) ||
+		original == nil || original.owner != c || !original.matchesSource(c.nanosleepOriginalSource, c.sig, c.targetTriple) {
+		return arm64NanosleepInput{}, false
+	}
+	input, present := proof.inputs[point]
+	if !present || !reflect.DeepEqual(c.blocks, arm64SplitBlocks(c.normalizedSource)) {
+		return arm64NanosleepInput{}, false
+	}
+	return input, true
+}
diff --git a/arm64_nanosleep_input_family_test.go b/arm64_nanosleep_input_family_test.go
new file mode 100644
index 000000000..6b3544edd
--- /dev/null
+++ b/arm64_nanosleep_input_family_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64NanosleepWithStores(stores string) string {
+	source := strings.Replace(arm64NanosleepInputSource, "\tMOVD R3,8(RSP)\n", "", 1)
+	source = strings.Replace(source, "\tMOVD R5,16(RSP)\n", "", 1)
+	return strings.Replace(source, "\tADD $8,RSP,R0\n", stores+"\tADD $8,RSP,R0\n", 1)
+}
+
+func arm64NanosleepByteStores(omitted int) string {
+	var stores strings.Builder
+	for offset := 0; offset < int(arm64NanosleepRequestBytes); offset++ {
+		if offset != omitted {
+			fmt.Fprintf(&stores, "\tMOVB ZR,%d(RSP)\n", 8+offset)
+		}
+	}
+	return stores.String()
+}
+
+func TestARM64NanosleepInitializedEnvelopeFamily(t *testing.T) {
+	stores := map[string]string{
+		"bytes": arm64NanosleepByteStores(-1),
+		"halfwords": "MOVH ZR,8(RSP)\nMOVH ZR,10(RSP)\nMOVH ZR,12(RSP)\nMOVH ZR,14(RSP)\n" +
+			"MOVH ZR,16(RSP)\nMOVH ZR,18(RSP)\nMOVH ZR,20(RSP)\nMOVH ZR,22(RSP)\n",
+		"words":              "MOVW ZR,8(RSP)\nMOVW ZR,12(RSP)\nMOVW ZR,16(RSP)\nMOVW ZR,20(RSP)\n",
+		"doublewords":        "MOVD R3,8(RSP)\nMOVD R5,16(RSP)\n",
+		"word-pairs":         "STPW (R3,R5),8(RSP)\nSTPW (R3,R5),16(RSP)\n",
+		"doubleword-pair":    "STP (R3,R5),8(RSP)\n",
+		"literal-zero-alias": "MOVD $0,8(RSP)\nMOVD $0,16(RSP)\n",
+		"derived-address":    "ADD $8,RSP,R17\nSTP (R3,R5),(R17)\n",
+		"indexed-address": "ADD $8,RSP,R17\nMOVD $0,R19\nMOVD R3,(R17)(R19)\n" +
+			"MOVD $8,R19\nMOVD R5,(R17)(R19)\n",
+		"post-writeback": "ADD $8,RSP,R17\nMOVD.P R3,8(R17)\nMOVD.P R5,8(R17)\n",
+		"pre-writeback":  "ADD $8,RSP,R17\nMOVD.W R3,0(R17)\nMOVD.W R5,8(R17)\n",
+		"complete-predecessors": "CBZ R3,other\nSTP (R3,R5),8(RSP)\nJMP joined\n" +
+			"other:\nMOVD R3,8(RSP)\nMOVD R5,16(RSP)\njoined:\n",
+	}
+	for name, stores := range stores {
+		t.Run(name, func(t *testing.T) {
+			source := arm64NanosleepWithStores(stores)
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if _, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source); err != nil {
+						t.Fatal("complete initialized envelope lost its existing typed store grammar", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NanosleepEveryMissingByteRemainsContext(t *testing.T) {
+	for omitted := 0; omitted < int(arm64NanosleepRequestBytes); omitted++ {
+		t.Run(fmt.Sprintf("byte-%02d", omitted), func(t *testing.T) {
+			source := arm64NanosleepWithStores(arm64NanosleepByteStores(omitted))
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if _, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("uninitialized byte %d acquired a kernel input role: %v", omitted, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NanosleepUndefinedOrEscapedInitializerRemainsContext(t *testing.T) {
+	for name, stores := range map[string]string{
+		"undefined-GP":        "MOVD R6,8(RSP)\nMOVD R6,16(RSP)\n",
+		"undefined-vector":    "FMOVQ F0,8(RSP)\n",
+		"external-load":       "MOVD (R6),R3\nSTP (R3,R5),8(RSP)\n",
+		"caller-link-value":   "MOVD R30,8(RSP)\nMOVD R5,16(RSP)\n",
+		"caller-frame-value":  "MOVD R29,8(RSP)\nMOVD R5,16(RSP)\n",
+		"missing-predecessor": "CBZ R3,joined\nSTP (R3,R5),8(RSP)\njoined:\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := arm64NanosleepWithStores(stores)
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if _, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unbound/native initializer acquired a byte-defined kernel contract: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func arm64NanosleepProofContext(t *testing.T) *arm64Ctx {
+	t.Helper()
+	requireARM64GoAssemblerResult(t, arm64NanosleepInputSource, true)
+	file, err := Parse(ArchARM64, arm64NanosleepInputSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "example.invalid/sleepinput", "package sleepinput\nfunc sleep(usec uint32)\n")
+	resolve := testResolveSym(pkg.Types.Path())
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var output strings.Builder
+	c := newARM64CtxWithTarget(&output, file.Funcs[0], sigs[resolve(file.Funcs[0].Sym)], resolve, sigs,
+		"aarch64-unknown-linux-gnu", false)
+	if err := c.prepareLocalControl(); err != nil {
+		t.Fatal("complete original-source CFG prerequisite", err)
+	}
+	return c
+}
+
+func TestARM64NanosleepInputProofExactIdentity(t *testing.T) {
+	for _, change := range []struct {
+		name  string
+		apply func(*arm64Ctx, [2]int) *arm64Ctx
+	}{
+		{"unaltered", func(c *arm64Ctx, _ [2]int) *arm64Ctx { return c }},
+		{"context-copy", func(c *arm64Ctx, _ [2]int) *arm64Ctx { copy := *c; return &copy }},
+		{"proof-copy", func(c *arm64Ctx, _ [2]int) *arm64Ctx {
+			copy := *c.nanosleepInput
+			c.nanosleepInput = &copy
+			return c
+		}},
+		{"wrong-owner", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.nanosleepInput.owner = nil; return c }},
+		{"target", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.targetTriple = "aarch64-unknown-linux-musl"; return c }},
+		{"signature", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.sig.Args[0] = I64; return c }},
+		{"frame-declaration", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.sig.Frame.Params[0].Offset = 8; return c }},
+		{"current-source", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.normalizedSource.Instrs[1].Raw += " changed"; return c }},
+		{"original-source", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.nanosleepOriginalSource.Instrs[1].Raw += " changed"; return c }},
+		{"original-proof", func(c *arm64Ctx, _ [2]int) *arm64Ctx { c.nanosleepOriginal = nil; return c }},
+		{"changed-CFG", func(c *arm64Ctx, point [2]int) *arm64Ctx {
+			c.blocks[point[0]].instrs[point[1]].Args = []Operand{{Kind: OpImm, Imm: 1}}
+			return c
+		}},
+		{"span", func(c *arm64Ctx, point [2]int) *arm64Ctx {
+			input := c.nanosleepInput.inputs[point]
+			input.span.low--
+			c.nanosleepInput.inputs[point] = input
+			return c
+		}},
+		{"descriptor", func(c *arm64Ctx, point [2]int) *arm64Ctx {
+			input := c.nanosleepInput.inputs[point]
+			input.form.number = "R16"
+			c.nanosleepInput.inputs[point] = input
+			return c
+		}},
+		{"ordinal", func(c *arm64Ctx, point [2]int) *arm64Ctx {
+			c.nanosleepInput.inputs[[2]int{point[0], point[1] + 1}] = c.nanosleepInput.inputs[point]
+			delete(c.nanosleepInput.inputs, point)
+			return c
+		}},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			c := arm64NanosleepProofContext(t)
+			if c.nanosleepInput == nil || len(c.nanosleepInput.inputs) != 1 {
+				t.Fatal("actual initialized source did not create a unique input point")
+			}
+			var point [2]int
+			for point = range c.nanosleepInput.inputs {
+			}
+			c = change.apply(c, point)
+			_, valid := c.nanosleepInputAt(point)
+			if valid != (change.name == "unaltered") {
+				t.Fatal("copied/changed source, owner, frame or point acquired an exact kernel input certificate")
+			}
+		})
+	}
+}
+
+func TestARM64NanosleepSealedReplayRequiresOriginalDeclaration(t *testing.T) {
+	for _, change := range []struct {
+		name  string
+		apply func(*FuncSig)
+	}{
+		{"original", func(*FuncSig) {}},
+		{"wider-input", func(sig *FuncSig) { sig.Args[0] = I64 }},
+		{"changed-frame-input", func(sig *FuncSig) { sig.Frame.Params[0].Offset = 8 }},
+		{"new-result", func(sig *FuncSig) { sig.Ret = I64 }},
+		{"different-declaration", func(sig *FuncSig) { sig.Name += ".other" }},
+		{"register-entry", func(sig *FuncSig) { sig.ArgRegs = []Reg{"R3"} }},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			c := arm64NanosleepProofContext(t)
+			sig := arm64NanosleepCloneSignature(c.sig)
+			change.apply(&sig)
+			transport := &arm64PrivateFrameTransport{
+				entry: sig, resolve: c.resolve, sigs: c.sigs, nanosleep: c.nanosleepInput,
+			}
+			_, err := arm64PrivateDataProofDetails(c.normalizedSource, transport)
+			if (err == nil) != (change.name == "original") {
+				t.Fatalf("a sealed memory input was replayed with another declaration: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_nanosleep_input_test.go b/arm64_nanosleep_input_test.go
new file mode 100644
index 000000000..575283fdf
--- /dev/null
+++ b/arm64_nanosleep_input_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Independent ordinary ABI0 source, not a runtime-name or SDK permission.
+const arm64NanosleepInputSource = `TEXT ·sleep(SB),4,$24-4
+	MOVWU usec+0(FP),R3
+	MOVD R3,R5
+	MOVW $1000000,R4
+	UDIV R4,R3
+	MOVD R3,8(RSP)
+	MUL R3,R4
+	SUB R4,R5
+	MOVW $1000,R4
+	MUL R4,R5
+	MOVD R5,16(RSP)
+	ADD $8,RSP,R0
+	MOVD $0,R1
+	MOVD $101,R8
+	SVC
+	RET
+`
+
+func arm64NanosleepInputAPI(t *testing.T, api, triple, source string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "example.invalid/sleepinput", "package sleepinput\nfunc sleep(usec uint32)\n")
+	return arm64NanosleepPackageAPI(t, api, triple, source, pkg)
+}
+
+func arm64NanosleepPackageAPI(t *testing.T, api, triple, source string, pkg GoPackage) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := testResolveSym(pkg.Types.Path())
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs, AnnotateSource: true}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	switch api {
+	case "text":
+		return Translate(file, options)
+	case "module":
+		module, err := TranslateModuleInContext(context, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			return module.String(), err
+		}
+		return "", err
+	case "Go":
+		bound, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+			GOOS: "linux", GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+		})
+		if bound != nil && !bound.Module.IsNil() {
+			defer bound.Module.Dispose()
+			return bound.Module.String(), err
+		}
+		return "", err
+	default:
+		t.Fatalf("unknown nanosleep API %q", api)
+		return "", nil
+	}
+}
+
+func TestARM64NanosleepInputCompleteSource(t *testing.T) {
+	for _, spelling := range []string{"SVC", "SVC $0"} {
+		source := strings.Replace(arm64NanosleepInputSource, "\tSVC\n", "\t"+spelling+"\n", 1)
+		requireARM64GoAssemblerResult(t, source, true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api+"/"+spelling, func(t *testing.T) {
+				ir, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source)
+				if err != nil {
+					t.Fatal("complete initialized private nanosleep input", err)
+				}
+				if strings.Count(ir, "call i64 @syscall(") != 1 || !strings.Contains(ir, "%local_stack = alloca [") {
+					t.Fatal("accepted source lost its actual syscall or fresh private allocation")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64NanosleepTypedInputCertificate(t *testing.T) {
+	file, err := Parse(ArchARM64, arm64NanosleepInputSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "example.invalid/sleepinput", "package sleepinput\nfunc sleep(usec uint32)\n")
+	resolve := testResolveSym(pkg.Types.Path())
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	sig := sigs[resolve(fn.Sym)]
+	collector := &arm64NanosleepInputProof{
+		source: arm64NanosleepCloneSource(fn), sig: arm64NanosleepCloneSignature(sig),
+		target: "aarch64-unknown-linux-gnu", inputs: make(map[[2]int]arm64NanosleepInput),
+	}
+	transport := &arm64PrivateFrameTransport{entry: sig, resolve: resolve, sigs: sigs, nanosleep: collector}
+	if _, err := arm64PrivateDataProofDetails(fn, transport); err != nil {
+		t.Fatal("complete original-source collector failed", err)
+	}
+	transport.nanosleep = nil
+	proof, required := arm64NanosleepInputForSource(fn, transport, collector.target)
+	if proof == nil || !required || !proof.matchesSource(fn, sig, collector.target) {
+		t.Fatal("complete CFG did not publish its exact input certificate")
+	}
+}
+
+func TestARM64NanosleepInputUnprovedMemoryRemainsContext(t *testing.T) {
+	for _, change := range []struct{ name, old, replacement string }{
+		{"unknown-number", "$101,R8", "$113,R8"},
+		{"dynamic-number", "$101,R8", "R3,R8"},
+		{"late-number", "\tSVC\n", "\tMOVD $57,R8\n\tSVC\n"},
+		{"wrong-number-register", "$101,R8", "$101,R16"},
+		{"trap-80", "\tSVC\n", "\tSVC $0x80\n"},
+		{"trap-high-alias", "\tSVC\n", "\tSVC $65536\n"},
+		{"nonnull-rem", "$0,R1", "$1,R1"},
+		{"private-rem", "$0,R1", "R0,R1"},
+		{"unbound-rem", "\tMOVD $0,R1\n", ""},
+		{"unbound-input", "\tADD $8,RSP,R0\n", ""},
+		{"saved-link-read", "$8,RSP,R0", "$0,RSP,R0"},
+		{"saved-fp-read", "$8,RSP,R0", "$-8,RSP,R0"},
+		{"out-of-bounds", "$8,RSP,R0", "$24,RSP,R0"},
+		{"missing-sec", "\tMOVD R3,8(RSP)\n", ""},
+		{"missing-nsec", "\tMOVD R5,16(RSP)\n", ""},
+		{"partial-sec", "MOVD R3,8(RSP)", "MOVW R3,8(RSP)"},
+		{"late-store", "\tMOVD R5,16(RSP)\n", "\tSVC\n\tMOVD R5,16(RSP)\n"},
+		{"saved-link-write", "MOVD R3,8(RSP)", "MOVD R3,0(RSP)"},
+		{"saved-fp-write", "MOVD R3,8(RSP)", "MOVD R3,-8(RSP)"},
+		{"escaped-pointer", "\tMOVD $101,R8\n", "\tMOVD R0,16(RSP)\n\tMOVD $101,R8\n"},
+		{"result-observation", "\tRET\n", "\tMOVD R0,R2\n\tRET\n"},
+		{"flag-observation", "\tRET\n", "\tCSET CS,R2\n\tRET\n"},
+		{"join-missing-store", "\tMOVD R5,16(RSP)\n", "\tCBZ R3,skip\n\tMOVD R5,16(RSP)\nskip:\n"},
+		{"join-number", "\tMOVD $101,R8\n", "\tCBZ R3,other\n\tMOVD $101,R8\n\tJMP trap\nother:\n\tMOVD $113,R8\ntrap:\n"},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			source := strings.Replace(arm64NanosleepInputSource, change.old, change.replacement, 1)
+			if source == arm64NanosleepInputSource {
+				t.Fatal("mutation did not change actual source")
+			}
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					_, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unproved syscall memory/continuation acquired permission: %v", err)
+					}
+				})
+			}
+		})
+	}
+	for _, triple := range []string{"", "aarch64-apple-darwin", "aarch64-pc-windows-msvc", "aarch64-unknown-freebsd"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api+"/target/"+triple, func(t *testing.T) {
+				if _, err := arm64NanosleepInputAPI(t, api, triple, arm64NanosleepInputSource); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("foreign/unknown target acquired Linux private read: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_nanosleep_runtime_go127_test.go b/arm64_nanosleep_runtime_go127_test.go
new file mode 100644
index 000000000..1b4199892
--- /dev/null
+++ b/arm64_nanosleep_runtime_go127_test.go
@@ -0,0 +1,123 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Independent original Go/ASM/kernel fixture. No observer below can publish an
+// initializer, source capability, native entry or syscall input certificate.
+func arm64NanosleepRuntimeFixture(t *testing.T) (directory, packagePath, declarations string) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	packagePath = "example.invalid/sleepinput"
+	declarations = "package sleepinput\nfunc sleep(usec uint32)\n"
+	const original = `package sleepinput
+import (
+    "fmt"
+    "os"
+    "os/signal"
+    "runtime"
+    "syscall"
+    "testing"
+    "time"
+)
+func TestOriginalNanosleepInput(t *testing.T) {
+    for _, usec := range []uint32{0,1,2000} {
+        start := time.Now()
+        sleep(usec)
+        if elapsed := time.Since(start); elapsed < 0 || elapsed > 2*time.Second {
+            t.Fatal("original kernel sleep failed to return",usec,elapsed)
+        }
+        t.Logf("ORIGINAL_NANOSLEEP_KERNEL_PASS usec=%d",usec)
+    }
+    runtime.LockOSThread()
+    defer runtime.UnlockOSThread()
+    signals := make(chan os.Signal,1)
+    signal.Notify(signals,syscall.SIGUSR1)
+    defer signal.Stop(signals)
+    thread := syscall.Gettid()
+    stop := make(chan struct{})
+    done := make(chan error,1)
+    go func() {
+        ticker := time.NewTicker(2*time.Millisecond)
+        defer ticker.Stop()
+        for attempt:=0;attempt<250;attempt++ {
+            select {
+            case <-stop:
+                done <- nil
+                return
+            case <-ticker.C:
+            }
+            if err := syscall.Tgkill(os.Getpid(),thread,syscall.SIGUSR1); err!=nil {
+                done <- err
+                return
+            }
+        }
+        done <- fmt.Errorf("bounded exact-thread interrupt sender exhausted")
+    }()
+    start := time.Now()
+    sleep(1000000)
+    elapsed := time.Since(start)
+    close(stop)
+    if err := <-done; err != nil { t.Fatal(err) }
+    if elapsed < 0 || elapsed > 500*time.Millisecond {
+        t.Fatal("original NULL-rem interrupted continuation did not return",elapsed)
+    }
+    select {
+    case <-signals:
+    case <-time.After(time.Second):
+        t.Fatal("real thread-directed interrupt was not observed")
+    }
+    t.Log("ORIGINAL_NANOSLEEP_KERNEL_PASS interrupted-null-rem")
+}
+`
+	for name, data := range map[string]string{
+		"go.mod": "module " + packagePath + "\ngo 1.20\n", "decl.go": declarations,
+		"original_arm64.s": arm64NanosleepInputSource, "original_test.go": original,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return directory, packagePath, declarations
+}
+
+func arm64NanosleepRuntimeOriginalObjects(t *testing.T, directory, packagePath string) {
+	t.Helper()
+	archive, object, builtins := arm64ByteCarrierOriginal(t, directory, packagePath)
+	members, err := gostaticstorage.ObserveARM64AssemblyArchive(archive, builtins, "linux/arm64", []string{"original_arm64.s"})
+	if err != nil || len(members) != 3 {
+		t.Fatalf("original complete archive precondition: %v", err)
+	}
+	texts, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, "linux/arm64")
+	if err != nil || len(texts) != 1 || len(members[2].Texts) != 1 {
+		t.Fatalf("original standalone/archive TEXT inventory: %v", err)
+	}
+	text, packed := texts[0], members[2].Texts[0]
+	const originalCodeSHA = "360f9c85948651b364c9e030e319821df2196aa63fe118e57a856ee2faa4d9ed"
+	if text.Name != packagePath+".sleep" || packed.Name != text.Name || text.ABI != 0 || packed.ABI != 0 ||
+		len(text.Relocations) != 0 || len(packed.Relocations) != 0 || len(text.Positions) == 0 ||
+		len(packed.Positions) == 0 || !bytes.Equal(text.Code, packed.Code) || len(text.Code) != 96 ||
+		fmt.Sprintf("%x", sha256.Sum256(text.Code)) != originalCodeSHA {
+		t.Fatal("first-party original body is not the exact SDK same-shape 96-byte kernel input")
+	}
+	t.Logf("ORIGINAL_NANOSLEEP_OBJECT archiveSHA256=%x objectSHA256=%x codeSHA256=%x bytes=%d",
+		sha256.Sum256(archive), sha256.Sum256(object), sha256.Sum256(text.Code), len(text.Code))
+}
+
+func TestARM64NanosleepRuntimeOriginalObjectShape(t *testing.T) {
+	directory, packagePath, _ := arm64NanosleepRuntimeFixture(t)
+	arm64NanosleepRuntimeOriginalObjects(t, directory, packagePath)
+}
diff --git a/arm64_nanosleep_runtime_linux_test.go b/arm64_nanosleep_runtime_linux_test.go
new file mode 100644
index 000000000..049449907
--- /dev/null
+++ b/arm64_nanosleep_runtime_linux_test.go
@@ -0,0 +1,194 @@
+//go:build go1.27 && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64NanosleepPrivateInput(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	if triple != "aarch64-unknown-linux-gnu" {
+		t.Fatal("nanosleep requires the actual Linux/ARM64 kernel counterpart")
+	}
+	directory, packagePath, _ := arm64NanosleepRuntimeFixture(t)
+	arm64NanosleepRuntimeOriginalObjects(t, directory, packagePath)
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	arguments := []string{"test", "-p=1", "-mod=readonly", "-run=^TestOriginalNanosleepInput$", "-count=1", "-v"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(arguments, "-exec="+quoted)
+	}
+	ctx, release := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, request.GoBinary, append(arguments, ".")...)
+	command.Dir, command.Env = directory, request.Environment
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	release()
+	if err != nil || !strings.Contains(string(output), "--- PASS: TestOriginalNanosleepInput") {
+		t.Fatalf("ORIGINAL_NANOSLEEP_KERNEL_PRECONDITION: %v\n%s", err, output)
+	}
+	for _, axis := range []string{"usec=0", "usec=1", "usec=2000", "interrupted-null-rem"} {
+		if strings.Count(string(output), "ORIGINAL_NANOSLEEP_KERNEL_PASS "+axis+"\n") != 1 {
+			t.Fatalf("missing/ambiguous actual original kernel axis %q\n%s", axis, output)
+		}
+	}
+	t.Logf("ORIGINAL_NANOSLEEP_KERNEL_OUTPUT_BEGIN\n%sORIGINAL_NANOSLEEP_KERNEL_OUTPUT_END", output)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := arm64NanosleepInputAPI(t, api, triple, arm64NanosleepInputSource)
+			if err != nil {
+				t.Fatal("actual original kernel P did not grant the source consumer", err)
+			}
+			for _, optimization := range []int{0, 2} {
+				t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "nanosleep_input", triple,
+						ir, arm64NanosleepRuntimeDriver, runner, optimization)
+					t.Logf("LLVM_NANOSLEEP_KERNEL_PASS %s O%d values=5x2 kernel=3 interrupted-null-rem=1", api, optimization)
+				})
+			}
+		})
+	}
+}
+
+// Interception checks the actual translated arguments against an independent
+// uint32 equation, including both field widths and NULL rem. It then invokes
+// the real A64 SVC for short sleeps and EINTR, checks the input bytes are
+// unchanged, and maps the raw kernel return to libc's errno contract. The source
+// has a void return: neither this driver nor its proof authorizes observing R0
+// or native NZCV in the translated assembly.
+const arm64NanosleepRuntimeDriver = `#define _GNU_SOURCE
+#include <errno.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <time.h>
+#include <unistd.h>
+
+extern void translated_sleep(uint32_t) __asm__("\"example.invalid/sleepinput.sleep\"");
+struct request { int64_t seconds, nanoseconds; };
+_Static_assert(sizeof(struct request)==16,"actual A64 kernel timespec width");
+static uint32_t expected;
+static int mode, forced_error, calls;
+static int start_fd=-1;
+static volatile sig_atomic_t interrupted;
+
+static void interrupt_handler(int signo) { if(signo==SIGUSR1) interrupted=1; }
+
+static long original_kernel(const struct request *request) {
+    register long number __asm__("x8")=101;
+    register long input __asm__("x0")=(long)request;
+    register long rem __asm__("x1")=0;
+    __asm__ volatile("svc #0" : "+r"(input), "+r"(rem), "+r"(number) : : "memory", "cc");
+    return input;
+}
+
+long syscall(long number,...) {
+    va_list arguments;
+    va_start(arguments,number);
+    const struct request *request=(const struct request *)va_arg(arguments,long);
+    long rem=va_arg(arguments,long);
+    long unused[4];
+    for(unsigned i=0;i<4;i++) unused[i]=va_arg(arguments,long);
+    va_end(arguments);
+    if(number!=101 || !request || rem || unused[0] || unused[1] || unused[2] || unused[3]) abort();
+    struct request before;
+    memcpy(&before,request,sizeof(before));
+    uint64_t seconds=(uint64_t)expected/UINT64_C(1000000);
+    uint64_t nanoseconds=((uint64_t)expected-seconds*UINT64_C(1000000))*UINT64_C(1000);
+    if(before.seconds!=(int64_t)seconds || before.nanoseconds!=(int64_t)nanoseconds) abort();
+    calls++;
+    if(!mode) {
+        errno=EINTR;
+        return forced_error ? -1 : 0;
+    }
+    if(mode==2) {
+        const char ready='R';
+        if(start_fd<0 || write(start_fd,&ready,1)!=1) abort();
+    }
+    long raw=original_kernel(request);
+    if(memcmp(&before,request,sizeof(before))) abort();
+    if((mode==1 && raw!=0) || (mode==2 && (raw!=-EINTR || !interrupted))) abort();
+    if(raw<0 && raw>=-4095) { errno=(int)-raw; return -1; }
+    return raw;
+}
+
+int cliteErrno(void) { return errno; }
+
+int main(void) {
+    const uint32_t values[]={0,1,999999,1000000,UINT32_MAX};
+    for(unsigned error=0;error<2;error++) {
+        forced_error=(int)error;
+        for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+            expected=values[i];
+            translated_sleep(expected);
+        }
+    }
+    mode=1;
+    const uint32_t short_values[]={0,1,2000};
+    for(unsigned i=0;i<sizeof(short_values)/sizeof(short_values[0]);i++) {
+        expected=short_values[i];
+        translated_sleep(expected);
+    }
+    struct sigaction action;
+    memset(&action,0,sizeof(action));
+    action.sa_handler=interrupt_handler;
+    if(sigemptyset(&action.sa_mask) || sigaction(SIGUSR1,&action,0)) return 1;
+    int ready[2], done[2];
+    if(pipe(ready) || pipe(done)) return 2;
+    pid_t parent=getpid();
+    if(gettid()!=parent) return 3;
+    pid_t child=fork();
+    if(child<0) return 2;
+    if(child==0) {
+        close(ready[1]);
+        close(done[1]);
+        char token;
+        if(read(ready[0],&token,1)!=1 || token!='R') _exit(1);
+        struct pollfd complete={.fd=done[0],.events=POLLIN};
+        for(unsigned attempt=0;attempt<250;attempt++) {
+            // A parent that failed/aborted is no longer this signal owner.
+            if(getppid()!=parent || tgkill(parent,parent,SIGUSR1)) _exit(2);
+            int result=poll(&complete,1,2);
+            if(result<0) _exit(3);
+            if(result>0) {
+                if(complete.revents!=POLLIN || read(done[0],&token,1)!=1 || token!='D') _exit(4);
+                close(ready[0]);
+                close(done[0]);
+                _exit(0);
+            }
+        }
+        _exit(5);
+    }
+    close(ready[0]);
+    close(done[0]);
+    start_fd=ready[1];
+    mode=2;
+    expected=1000000;
+    translated_sleep(expected);
+    const char complete='D';
+    if(write(done[1],&complete,1)!=1) return 4;
+    int status;
+    pid_t joined;
+    do {
+        joined=waitpid(child,&status,0);
+    } while(joined<0 && errno==EINTR);
+    if(joined!=child || !WIFEXITED(status) || WEXITSTATUS(status)!=0) return 5;
+    close(ready[1]);
+    close(done[1]);
+    if(calls!=14 || !interrupted) return 4;
+    puts("ACTUAL_NANOSLEEP_INPUT_KERNEL_COMPLETE values=10 kernel=3 EINTR=1 NULLrem=1");
+    return 0;
+}
+`
diff --git a/arm64_nanosleep_sdk_go127_test.go b/arm64_nanosleep_sdk_go127_test.go
new file mode 100644
index 000000000..aaab3230d
--- /dev/null
+++ b/arm64_nanosleep_sdk_go127_test.go
@@ -0,0 +1,213 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This is an independent full original SDK/archive observation, not a source,
+// ABI or memory token. Success here never certifies the whole SDK file's IR.
+func TestARM64NanosleepSDKOriginalObjectAndBody(t *testing.T) {
+	selection := arm64ABI0RegionCommand(t, "linux", ".", "list", "-json", "-compiled", "-export", "runtime")
+	var selected goAMD64FrameSelection
+	decoder := json.NewDecoder(bytes.NewReader(selection))
+	if err := decoder.Decode(&selected); err != nil {
+		t.Fatal(err)
+	}
+	var extra any
+	if decoder.Decode(&extra) != io.EOF || selected.ImportPath != "runtime" || selected.Export == "" {
+		t.Fatal("actual complete runtime selection is missing or ambiguous")
+	}
+	const sourceName = "sys_linux_arm64.s"
+	present := false
+	for _, name := range selected.SFiles {
+		present = present || name == sourceName
+	}
+	if !present {
+		t.Fatal("actual Linux/ARM64 Go selection omitted the original SDK source")
+	}
+	sourcePath := filepath.Join(selected.Dir, sourceName)
+	data, err := os.ReadFile(sourcePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchARM64, string(data))
+	if err != nil {
+		t.Fatal("complete original SDK source", err)
+	}
+	var original strings.Builder
+	count := 0
+	for _, function := range file.Funcs {
+		if function.Sym == "runtime·usleep" {
+			count++
+			for _, instruction := range function.Instrs {
+				original.WriteString(instruction.Raw + "\n")
+			}
+		}
+	}
+	if count != 1 {
+		t.Fatal("original SDK usleep TEXT membership differs")
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtins, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Runtime's compiler member is not an ordinary user-package observer role.
+	// Do not broaden that observer: let the actual Go archive tool enumerate
+	// every member and extract only this original assembler object. The bytes
+	// still supply observation only, not a source capability or an ABI grant.
+	inventory := arm64ABI0RegionCommand(t, "linux", ".", "tool", "pack", "t", selected.Export)
+	memberName := strings.TrimSuffix(sourceName, ".s") + ".o"
+	if len(memberName) > 16 {
+		memberName = memberName[:16] // Go's actual ar member-name field.
+	}
+	members := strings.Fields(string(inventory))
+	seen := make(map[string]bool)
+	for _, name := range members {
+		if seen[name] {
+			t.Fatal("ambiguous actual Go archive member inventory")
+		}
+		seen[name] = true
+	}
+	if len(members) < 3 || !seen[memberName] {
+		t.Fatal("actual original assembler member absent")
+	}
+	object := arm64ABI0RegionCommand(t, "linux", ".", "tool", "pack", "p", selected.Export, memberName)
+	if _, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, "linux/arm64"); !errors.Is(err, gostaticstorage.ErrContext) {
+		t.Fatal("an ordinary observer must not acquire SDK object authority", err)
+	}
+	objectPath := filepath.Join(t.TempDir(), "original.o")
+	if err := os.WriteFile(objectPath, object, 0600); err != nil {
+		t.Fatal(err)
+	}
+	// Stock Go, not an ordinary-role parser with erased flags, reads this SDK
+	// object. Keep its complete symbol inventory and every selected body byte.
+	symbols := arm64ABI0RegionCommand(t, "linux", ".", "tool", "nm", "-size", objectPath)
+	count = 0
+	for _, line := range strings.Split(strings.TrimSpace(string(symbols)), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 4 && fields[3] == "runtime.usleep" {
+			count++
+			if fields[1] != "96" || fields[2] != "T" {
+				t.Fatal("original ASM symbol extent/type differs")
+			}
+		}
+	}
+	if count != 1 {
+		t.Fatal("ambiguous original ASM membership; a compiler wrapper is not the body")
+	}
+	disassembly := arm64ABI0RegionCommand(t, "linux", ".", "tool", "objdump", "-s", "^runtime\\.usleep$", objectPath)
+	word := regexp.MustCompile(`^\s+\S+:\d+\s+(0x[0-9a-f]+)\s+([0-9a-f]{8})\s+.+$`)
+	var code []byte
+	var start uint64
+	header := false
+	for _, line := range strings.Split(strings.TrimSpace(string(disassembly)), "\n") {
+		if strings.HasPrefix(line, "TEXT runtime.usleep(SB) ") && !header {
+			header = true
+			continue
+		}
+		match := word.FindStringSubmatch(line)
+		if !header || match == nil || strings.Contains(line, "R_") {
+			t.Fatalf("unknown/relocated original Go body record %q", line)
+		}
+		pc, err := strconv.ParseUint(match[1][2:], 16, 64)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(code) == 0 {
+			start = pc
+		}
+		if pc != start+uint64(len(code)) || len(code) >= 96 {
+			t.Fatal("original body PCs have a hole, overlap or excess extent")
+		}
+		value, err := strconv.ParseUint(match[2], 16, 32)
+		if err != nil {
+			t.Fatal(err)
+		}
+		code = binary.LittleEndian.AppendUint32(code, uint32(value))
+	}
+	const originalCodeSHA = "360f9c85948651b364c9e030e319821df2196aa63fe118e57a856ee2faa4d9ed"
+	if len(code) != 96 || fmt.Sprintf("%x", sha256.Sum256(code)) != originalCodeSHA {
+		t.Fatal("complete original Go private timespec/SVC0 body bytes differ")
+	}
+	t.Logf("SDK_ORIGINAL_BODY sourceSHA256=%x archiveSHA256=%x member=%s objectSHA256=%x codeSHA256=%x bytes=%d",
+		sha256.Sum256(data), sha256.Sum256(archive), memberName, sha256.Sum256(object), sha256.Sum256(code), len(code))
+	declarationPath := filepath.Join(selected.Dir, "stubs2.go")
+	declarationBytes, err := os.ReadFile(declarationPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	declarations, err := parser.ParseFile(fset, declarationPath, declarationBytes, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declaration bytes.Buffer
+	for _, node := range declarations.Decls {
+		if function, ok := node.(*ast.FuncDecl); ok && function.Name.Name == "usleep" && function.Body == nil {
+			if err := format.Node(&declaration, fset, function); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if declaration.Len() == 0 {
+		t.Fatal("actual ordinary SDK declaration absent")
+	}
+	pkg := mustGoPackage(t, "runtime", "package runtime\n"+declaration.String()+"\n")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			if _, err := arm64NanosleepPackageAPI(t, api, "aarch64-unknown-linux-gnu", original.String(), pkg); err != nil {
+				t.Fatal("exact original SDK usleep body (not a whole-file pass)", err)
+			}
+		})
+	}
+}
+
+func TestARM64NanosleepInputLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, spelling := range []string{"SVC", "SVC $0"} {
+		source := strings.Replace(arm64NanosleepInputSource, "\tSVC\n", "\t"+spelling+"\n", 1)
+		requireARM64GoAssemblerResult(t, source, true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api+"/"+spelling, func(t *testing.T) {
+				ir, err := arm64NanosleepInputAPI(t, api, "aarch64-unknown-linux-gnu", source)
+				if err != nil {
+					t.Fatal("source-bound Linux input object", err)
+				}
+				for _, optimization := range []int{0, 2} {
+					t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+						// This shared helper only executes LLVM22 and checks the
+						// resulting ELF. It cannot mint a source/kernel proof.
+						arm64LinuxSyscallEffectCompileObject(t, llc, ir, optimization)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_native_scratch_abi_identity_test.go b/arm64_native_scratch_abi_identity_test.go
new file mode 100644
index 000000000..33826af61
--- /dev/null
+++ b/arm64_native_scratch_abi_identity_test.go
@@ -0,0 +1,14 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64NativeScratchActualABIRoleIdentity(t *testing.T) {
+	_, pkg, _, _, source := arm64ScratchActualBoundSource(t, "linux", "aarch64-unknown-linux-gnu")
+	t.Logf("actual selected ABI definitions: %+v", source.abis)
+	for _, name := range []string{"Scratch", "Value"} {
+		symbol := pkg.Path + "." + name
+		if source.abis[symbol] != "ABI0" {
+			t.Errorf("actual source ABI definition lost exact symbol %q: %q", symbol, source.abis[symbol])
+		}
+	}
+}
diff --git a/arm64_native_scratch_bitfield_test.go b/arm64_native_scratch_bitfield_test.go
new file mode 100644
index 000000000..810ed7991
--- /dev/null
+++ b/arm64_native_scratch_bitfield_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64NativeScratchBitfieldGoEncodingRows(t *testing.T) {
+	// Independent source witnesses follow Go's obj7 cases 42, 43 and 45,
+	// plus the immediate shifts encoded as bitfields by case 8. The expected
+	// effects come from each source operation, not the translator decoder.
+	type witness struct {
+		name, instruction string
+		merge             bool
+	}
+	var witnesses []witness
+	for _, op := range []string{"SBFM", "BFM", "UBFM"} {
+		for _, suffix := range []string{"", "W"} {
+			witnesses = append(witnesses, witness{
+				op + suffix, op + suffix + " $1,R1,$17,R4", op == "BFM",
+			})
+		}
+	}
+	for _, op := range []string{"BFI", "BFXIL", "SBFIZ", "SBFX", "UBFIZ", "UBFX"} {
+		for _, suffix := range []string{"", "W"} {
+			witnesses = append(witnesses, witness{
+				op + suffix, op + suffix + " $3,R1,$7,R4", op == "BFI" || op == "BFXIL",
+			})
+		}
+	}
+	for _, op := range []string{
+		"SXTB", "SXTBW", "SXTH", "SXTHW", "SXTW",
+		"UXTB", "UXTBW", "UXTH", "UXTHW", "UXTW",
+		"MOVB", "MOVH", "MOVW", "MOVBU", "MOVHU", "MOVWU",
+	} {
+		witnesses = append(witnesses, witness{op, op + " R1,R4", false})
+	}
+	for _, op := range []string{"ASR", "LSL", "LSR"} {
+		for _, suffix := range []string{"", "W"} {
+			witnesses = append(witnesses, witness{op + suffix, op + suffix + " $3,R1,R4", false})
+		}
+	}
+	var assembly strings.Builder
+	for _, witness := range witnesses {
+		fmt.Fprintf(&assembly, "TEXT %s(SB),516,$0-0\n%s\nRET\n", witness.name, witness.instruction)
+	}
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "bitfields_arm64.s"), filepath.Join(directory, "original.o")
+	if err := os.WriteFile(input, []byte(assembly.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", object, input)
+	if err != nil {
+		t.Fatalf("original Go bitfield family: %v\n%s", err, listing)
+	}
+	disassembly, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "objdump", object)
+	if err != nil {
+		t.Fatalf("actual original Go bitfield object: %v\n%s", err, disassembly)
+	}
+	bodies, err := arm64ScratchObjectBodies(disassembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, witness := range witnesses {
+		t.Run(witness.name, func(t *testing.T) {
+			body, present := bodies[witness.name]
+			if !present || len(body.code) < 2 || body.code[1] != 0xd65f03c0 || len(body.relocs) != 0 {
+				t.Fatal("original Go bitfield instruction/return identity missing")
+			}
+			var bytes [4]byte
+			binary.LittleEndian.PutUint32(bytes[:], body.code[0])
+			instruction, err := arm64asm.Decode(bytes[:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			reads := uint64(1 << 1)
+			if witness.merge {
+				reads |= 1 << 4
+			}
+			want := arm64ScratchInputEffect{reads: reads, writes: 1 << 4}
+			got, valid := arm64ScratchNativeInputEffect(instruction, false)
+			if !valid || got != want {
+				t.Fatalf("Go encoding %08x %v: native bitfield effect=%+v registered=%v, want %+v",
+					body.code[0], instruction, got, valid, want)
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchBitfieldCompleteEffectDomain(t *testing.T) {
+	// The encoding constructor is the independent fixture used by the original
+	// raw-bitfield tests. This exhaustive metadata test is not a Go object or
+	// runtime certificate for each synthetic word; actual Go rows are above.
+	for opc := uint32(0); opc < 3; opc++ {
+		for _, width := range []int{32, 64} {
+			for immr := 0; immr < width; immr++ {
+				for imms := 0; imms < width; imms++ {
+					for _, registers := range [][2]int{
+						{1, 4}, {4, 4}, {27, 1}, {1, 27}, {31, 4},
+						{1, 31}, {31, 31}, {30, 4}, {1, 30},
+					} {
+						word := encodeARM64RawBitfield(opc, width, immr, imms, registers[0], registers[1])
+						var bytes [4]byte
+						binary.LittleEndian.PutUint32(bytes[:], word)
+						instruction, err := arm64asm.Decode(bytes[:])
+						if err != nil {
+							t.Fatalf("valid physical bitfield %08x: %v", word, err)
+						}
+						var reads, writes uint64
+						if registers[0] != 31 {
+							reads = 1 << uint(registers[0])
+						}
+						if registers[1] != 31 {
+							writes = 1 << uint(registers[1])
+							if opc == 1 {
+								reads |= writes
+							}
+						}
+						got, valid := arm64ScratchNativeInputEffect(instruction, false)
+						if (reads|writes)&(1<<30) != 0 {
+							if valid {
+								t.Fatalf("native LR numerical effect admitted: %08x", word)
+							}
+						} else if !valid || got != (arm64ScratchInputEffect{reads: reads, writes: writes}) {
+							t.Fatalf("bitfield %08x input effect=%+v valid=%v", word, got, valid)
+						}
+						r27, valid := arm64ScratchNativeEffect(instruction)
+						wantR27 := arm64ScratchEffect{reads: reads&(1<<27) != 0, defines: writes&(1<<27) != 0}
+						if !valid || r27 != wantR27 {
+							t.Fatalf("bitfield %08x R27 effect=%+v valid=%v", word, r27, valid)
+						}
+						gp, known := arm64RawPoolGPWrites(word)
+						if !known || gp != uint32(writes) || !arm64RawPoolInstructionPreservesNZCV(instruction) {
+							t.Fatalf("bitfield %08x disagrees with GP/NZCV consumers", word)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_native_scratch_call_results_test.go b/arm64_native_scratch_call_results_test.go
new file mode 100644
index 000000000..48479442a
--- /dev/null
+++ b/arm64_native_scratch_call_results_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Native/source closure must supply every outgoing input byte and prove
+// actual callee result writes. A declaration alone supplies neither fact.
+func TestARM64NativeScratchSamePackageCallResults(t *testing.T) {
+	for _, test := range []struct {
+		name, leaf, before, after string
+		context                   bool
+	}{
+		{"complete-result", "ADD $3,R1\nMOVD R1,ret+8(FP)", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", false},
+		{"both-paths-result", "CBZ R1,other\nMOVD R1,ret+8(FP)\nB done\nother:\nMOVD $7,R2\nMOVD R2,ret+8(FP)\ndone:", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", false},
+		{"missing-result", "ADD $3,R1", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", true},
+		{"partial-result", "MOVW R1,ret+8(FP)", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", true},
+		{"one-path-result", "CBZ R1,done\nMOVD R1,ret+8(FP)\ndone:", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", true},
+		{"missing-input", "MOVD R1,ret+8(FP)", "", "MOVD 16(RSP),R2", true},
+		{"partial-input", "MOVD R1,ret+8(FP)", "MOVW R1,8(RSP)", "MOVD 16(RSP),R2", true},
+		{"unbound-postcall-register", "MOVD R1,ret+8(FP)", "MOVD R1,8(RSP)", "MOVD R1,R2", true},
+		{"stale-postcall-local", "MOVD R1,ret+8(FP)", "MOVD R1,8(RSP)\nMOVD R1,24(RSP)", "MOVD 24(RSP),R2", true},
+		{"native-entry-register", "MOVD R6,ret+8(FP)", "MOVD R1,8(RSP)", "MOVD 16(RSP),R2", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			value := "TEXT ·Value(SB),4,$32-16\nMOVD n+0(FP),R1\n" + test.before +
+				"\nCALL ·Leaf(SB)\n" + test.after + "\nMOVD R2,ret+8(FP)\nRET\n"
+			leaf := "TEXT ·Leaf(SB),4,$0-16\nMOVD n+0(FP),R1\n" + test.leaf + "\nRET\n"
+			assembly := arm64ScratchSelectedSource[:strings.Index(arm64ScratchSelectedSource, "TEXT ·Value")] + value + leaf
+			_, pkg, file, options, source := arm64ScratchActualBoundSourceWithPackage(t,
+				"linux", "aarch64-unknown-linux-gnu", assembly, "example.invalid/scratchfixture", "func Leaf(n uint64) uint64\n")
+			_, closed := source.closed[pkg.Path+".Value"]
+			t.Logf("actual complete source/native call closure=%v; expected Context=%v", closed, test.context)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ScratchSourceAPIWithAssembly(t, pkg, file, options, api, assembly)
+					if test.context {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("unproved native input/result acquired scratch admission: %v", err)
+						}
+						return
+					}
+					if err != nil {
+						t.Fatalf("actual complete native/source tuple did not close: %v", err)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "closed.ll", "closed.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSamePackageCallByteWidths(t *testing.T) {
+	for _, test := range []struct{ typ, store, load string }{
+		{"uint8", "MOVB", "MOVBU"},
+		{"uint16", "MOVH", "MOVHU"},
+		{"uint32", "MOVW", "MOVWU"},
+		{"uint64", "MOVD", "MOVD"},
+	} {
+		t.Run(test.typ, func(t *testing.T) {
+			body := fmt.Sprintf(`TEXT ·Value(SB),4,$24-16
+MOVD n+0(FP),R1
+MOVD R1,8(RSP)
+CALL ·Leaf(SB)
+%s 16(RSP),R2
+MOVD R2,ret+8(FP)
+RET
+TEXT ·Leaf(SB),4,$0-16
+MOVD n+0(FP),R1
+%s R1,ret+8(FP)
+RET
+`, test.load, test.store)
+			assembly := arm64ScratchSelectedSource[:strings.Index(arm64ScratchSelectedSource, "TEXT ·Value")] + body
+			_, pkg, file, options, _ := arm64ScratchActualBoundSourceWithPackage(t,
+				"linux", "aarch64-unknown-linux-gnu", assembly, "example.invalid/scratchfixture",
+				"func Leaf(n uint64) "+test.typ+"\n")
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ScratchSourceAPIWithAssembly(t, pkg, file, options, api, assembly)
+					if err != nil {
+						t.Fatal(err)
+					}
+					llc := findLLVM22Tool("llc")
+					if llc == "" {
+						t.Fatal("LLVM 22 llc not found")
+					}
+					compileLLVMToObject(t, llc, options.TargetTriple, "closed.ll", "closed.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_effect_family_test.go b/arm64_native_scratch_effect_family_test.go
new file mode 100644
index 000000000..5dba4850e
--- /dev/null
+++ b/arm64_native_scratch_effect_family_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64NativeScratchScalarSourceEffects(t *testing.T) {
+	for _, test := range []struct{ name, body string }{
+		{"word_move", "MOVW R1,R4\nMOVD R4,R1"},
+		{"word_shift", "MOVW R1,R4\nLSLW $2,R4,R4\nMOVD R4,R1"},
+		{"unaligned_word_store", "MOVD R1,R8\nMOVW R1,R4\nMOVW R4,1(R8)\nMOVD R4,R1"},
+		{"branch_join", `MOVD R1,R8
+MOVW R1,R4
+SUBW $1,R4,R4
+CMPW $60,R4
+BLT oneByte
+CMPW $256,R4
+BLT twoBytes
+threeBytes:
+MOVD $0xf4,R2
+MOVB R2,0(R8)
+MOVW R4,1(R8)
+ADD $3,R8,R8
+B done
+twoBytes:
+MOVD $0xf0,R2
+MOVB R2,0(R8)
+MOVB R4,1(R8)
+ADD $2,R8,R8
+B done
+oneByte:
+LSLW $2,R4,R4
+MOVB R4,0(R8)
+ADD $1,R8,R8
+done:
+MOVD R8,R1`},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(arm64ScratchSelectedSource, "ADD $3,R1", test.body, 1)
+			ctx, pkg, _, _, source := arm64ScratchActualBoundSourceWithAssembly(
+				t, "linux", "aarch64-unknown-linux-gnu", assembly)
+			symbol := pkg.Path + ".Value"
+			layout, err := source.actualCalleeSignature(ctx, symbol, symbol)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, body := range source.native[symbol] {
+				t.Logf("actual native admission generated=%v r27=%v local=%v inputs=%v",
+					source.originalObjectGenerated(body.source), arm64ScratchNativeDoesNotAccess(body),
+					arm64ScratchSourceLocalInputs(source.functions[symbol], layout),
+					arm64ScratchSamePackageInputs(source.functions[symbol], layout, body))
+				for at, word := range body.code {
+					if word == 0 {
+						continue
+					}
+					var bytes [4]byte
+					binary.LittleEndian.PutUint32(bytes[:], word)
+					instruction, err := arm64asm.Decode(bytes[:])
+					effect, valid := arm64ScratchNativeInputEffect(instruction, true)
+					t.Logf("word=%d encoding=%08x instruction=%v decode=%v effect=%+v registered=%v",
+						at, word, instruction, err, effect, valid)
+				}
+			}
+			// Only input/R27 closure is asserted here. These native source
+			// observations supply no pointee extent or runtime execution proof.
+			if _, closed := source.closed[symbol]; !closed {
+				t.Fatal("Go-accepted scalar source effects failed actual native input closure")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_origin.go b/arm64_native_scratch_origin.go
new file mode 100644
index 000000000..38fea42e2
--- /dev/null
+++ b/arm64_native_scratch_origin.go
@@ -0,0 +1,294 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// These facts concern only dependence on incoming physical R27. They neither
+// carry a pointer value nor describe an initialized/native memory region.
+type arm64ScratchEffect struct {
+	reads, defines, call bool
+}
+
+func arm64ScratchArgumentReads(argument arm64asm.Arg) (bool, bool) {
+	switch argument := argument.(type) {
+	case nil, arm64asm.Imm, arm64asm.Imm64, arm64asm.ImmShift, arm64asm.Cond, arm64asm.PCRel:
+		return false, true
+	case arm64asm.Reg:
+		return argument == arm64asm.X27 || argument == arm64asm.W27, true
+	case arm64asm.RegSP:
+		return arm64asm.Reg(argument) == arm64asm.X27 || arm64asm.Reg(argument) == arm64asm.W27, true
+	case arm64asm.RegExtshiftAmount:
+		// x/arch keeps the register private; its validated typed printer's
+		// first field is exactly one register, not an arbitrary instruction.
+		name, _, _ := strings.Cut(argument.String(), ",")
+		return name == "X27" || name == "W27", true
+	case arm64asm.MemImmediate:
+		if argument.Mode == arm64asm.AddrPostReg {
+			return false, false // The private post-register field has no shared effect row here.
+		}
+		return arm64asm.Reg(argument.Base) == arm64asm.X27, true
+	case arm64asm.MemExtend:
+		return arm64asm.Reg(argument.Base) == arm64asm.X27 || argument.Index == arm64asm.X27 || argument.Index == arm64asm.W27, true
+	default:
+		return false, false
+	}
+}
+
+func arm64ScratchNativeEffect(instruction arm64asm.Inst) (arm64ScratchEffect, bool) {
+	const scratch = uint32(1 << 27)
+	word := instruction.Enc
+	if form, valid := decodeARM64RawNZCV(word); valid {
+		reads, writes := form.gpEffects()
+		return arm64ScratchEffect{reads: reads&scratch != 0, defines: writes&scratch != 0}, true
+	}
+	if form, valid := decodeARM64RawScalarRegister(word); valid {
+		reads, writes, _ := form.gpEffects()
+		return arm64ScratchEffect{reads: reads&scratch != 0, defines: writes&scratch != 0}, true
+	}
+	if form, valid := decodeARM64RawBitfield(word); valid {
+		reads, writes := form.gpEffects()
+		return arm64ScratchEffect{reads: reads&scratch != 0, defines: writes&scratch != 0}, true
+	}
+	switch instruction.Op {
+	case arm64asm.RET:
+		return arm64ScratchEffect{}, word == 0xd65f03c0
+	case arm64asm.BL:
+		return arm64ScratchEffect{call: true}, word == 0x94000000
+	case arm64asm.B, arm64asm.CBZ, arm64asm.CBNZ, arm64asm.TBZ, arm64asm.TBNZ:
+		var effect arm64ScratchEffect
+		for _, argument := range instruction.Args {
+			reads, valid := arm64ScratchArgumentReads(argument)
+			if !valid {
+				return arm64ScratchEffect{}, false
+			}
+			effect.reads = effect.reads || reads
+		}
+		return effect, true
+	case arm64asm.BR, arm64asm.BLR, arm64asm.SVC, arm64asm.HVC, arm64asm.SMC,
+		arm64asm.ERET, arm64asm.MSR, arm64asm.MRS:
+		return arm64ScratchEffect{}, false
+	}
+	// The registered raw families already bind their complete operand/bank
+	// effects. This observation adds no permission to lower any such opcode.
+	if effect, known := arm64RawContinuationEffectsForWord(word); known {
+		return arm64ScratchEffect{reads: effect.gpReads&scratch != 0, defines: effect.gpWrites&scratch != 0}, true
+	}
+	writes, known := arm64RawPoolGPWrites(word)
+	if !known {
+		return arm64ScratchEffect{}, false
+	}
+	destinations := 0
+	switch {
+	case word&0x1c000000 == 0x10000000, word&0x0e000000 == 0x0a000000, word&0x0e000000 == 0x0e000000:
+		destinations = 1
+		switch instruction.Op {
+		case arm64asm.CMP, arm64asm.CMN, arm64asm.TST, arm64asm.CCMP, arm64asm.CCMN:
+			destinations = 0
+		}
+	case arm64RawPoolReadOnlyLoad(instruction.Op):
+		destinations = 1
+		if instruction.Op == arm64asm.LDP || instruction.Op == arm64asm.LDNP || instruction.Op == arm64asm.LDPSW {
+			destinations = 2
+		}
+	}
+	effect := arm64ScratchEffect{defines: writes&scratch != 0}
+	for index, argument := range instruction.Args {
+		reads, valid := arm64ScratchArgumentReads(argument)
+		if !valid {
+			return arm64ScratchEffect{}, false
+		}
+		if index < destinations {
+			if _, direct := argument.(arm64asm.Reg); direct {
+				reads = false
+			}
+			if _, direct := argument.(arm64asm.RegSP); direct {
+				reads = false
+			}
+		}
+		effect.reads = effect.reads || reads
+	}
+	// Wide immediate insertion and bitfield insertion are read-modify-write,
+	// including W forms. A W overwrite otherwise defines the whole X alias
+	// through architectural zero extension, not a declaration/padding guess.
+	switch instruction.Op {
+	case arm64asm.MOVK, arm64asm.BFM, arm64asm.BFI, arm64asm.BFXIL:
+		effect.reads = effect.reads || effect.defines
+	}
+	return effect, true
+}
+
+func arm64ScratchNativeRelocations(body arm64ScratchNativeBody) bool {
+	occupied := make(map[int]bool)
+	calls := 0
+	for _, relocation := range body.relocs {
+		at := relocation.at
+		if at < 0 || at >= len(body.code) || relocation.target == "" || occupied[at] {
+			return false
+		}
+		occupied[at] = true
+		if relocation.kind == "R_CALLARM64" {
+			if relocation.width != 4 || relocation.addend != 0 || body.code[at] != 0x94000000 ||
+				calls >= len(body.calls) || body.calls[calls] != relocation.target {
+				return false
+			}
+			calls++
+			continue
+		}
+		if relocation.width != 8 || at+1 >= len(body.code) || occupied[at+1] || body.code[at]&0x9f000000 != 0x90000000 {
+			return false
+		}
+		occupied[at+1] = true
+		first, second := body.code[at], body.code[at+1]
+		if relocation.kind == "R_ADDRARM64" {
+			if second&0xffc00000 != 0x91000000 || first&31 != second>>5&31 || first&31 != second&31 {
+				return false
+			}
+			continue
+		}
+		sizes := map[string]uint32{"R_ARM64_PCREL_LDST8": 0, "R_ARM64_PCREL_LDST16": 1,
+			"R_ARM64_PCREL_LDST32": 2, "R_ARM64_PCREL_LDST64": 3}
+		size, known := sizes[relocation.kind]
+		if !known || second&0x3f000000 != 0x39000000 || second>>30 != size || first&31 != second>>5&31 {
+			return false
+		}
+	}
+	return calls == len(body.calls)
+}
+
+// All native observations share the actual instruction/relocation CFG. This
+// constructs edges only; it cannot supply a register, address or entry fact.
+func arm64ScratchNativeGraph(body arm64ScratchNativeBody) ([]arm64asm.Inst, [][]int, bool) {
+	code := body.code
+	for len(code) != 0 && code[len(code)-1] == 0 {
+		code = code[:len(code)-1]
+	}
+	if len(code) == 0 || len(code) > 65536 || !arm64ScratchNativeRelocations(body) {
+		return nil, nil, false
+	}
+	instructions := make([]arm64asm.Inst, len(code))
+	edges := make([][]int, len(code))
+	returned, calls := false, 0
+	for ordinal, word := range code {
+		var bytes [4]byte
+		binary.LittleEndian.PutUint32(bytes[:], word)
+		instruction, err := arm64asm.Decode(bytes[:])
+		effect, valid := arm64ScratchNativeEffect(instruction)
+		if err != nil || !valid {
+			return nil, nil, false
+		}
+		instructions[ordinal] = instruction
+		if effect.call {
+			calls++
+		}
+		if instruction.Op == arm64asm.RET {
+			returned = true
+			continue
+		}
+		branch := instruction.Op == arm64asm.B || instruction.Op == arm64asm.CBZ || instruction.Op == arm64asm.CBNZ ||
+			instruction.Op == arm64asm.TBZ || instruction.Op == arm64asm.TBNZ
+		if branch {
+			targets := 0
+			for _, argument := range instruction.Args {
+				if relative, ok := argument.(arm64asm.PCRel); ok {
+					destination := int64(ordinal)*4 + int64(relative)
+					if destination < 0 || destination%4 != 0 || destination/4 >= int64(len(code)) {
+						return nil, nil, false
+					}
+					edges[ordinal] = append(edges[ordinal], int(destination/4))
+					targets++
+				}
+			}
+			if targets != 1 {
+				return nil, nil, false
+			}
+		}
+		if word&0xfc000000 != 0x14000000 {
+			if ordinal+1 == len(code) {
+				return nil, nil, false // Actual native fallthrough is not an implicit RET.
+			}
+			edges[ordinal] = append(edges[ordinal], ordinal+1)
+		}
+	}
+	if !returned || calls != len(body.calls) {
+		return nil, nil, false
+	}
+	return instructions, edges, true
+}
+
+type arm64ScratchInputEffect struct {
+	reads, writes uint64
+	call          bool
+}
+
+// Inputs are intersected at every join. The first native entry receives only
+// its independently proved seed; disconnected components start fully unknown.
+// There are at most 35 changing GP/NZCV facts and two successors per word.
+func arm64ScratchNativeAvailable(effects []arm64ScratchInputEffect, edges [][]int, seed uint64) bool {
+	seen, defined := make([]bool, len(effects)), make([]uint64, len(effects))
+	steps := 0
+	for entry := range effects {
+		if seen[entry] {
+			continue
+		}
+		seen[entry] = true
+		if entry == 0 {
+			defined[entry] = seed
+		}
+		queue := []int{entry}
+		for len(queue) != 0 {
+			at := queue[0]
+			queue = queue[1:]
+			steps++
+			if steps > len(effects)*72 {
+				return false
+			}
+			if effects[at].reads & ^defined[at] != 0 {
+				return false
+			}
+			out := defined[at] | effects[at].writes
+			if effects[at].call {
+				out = 0
+			}
+			for _, next := range edges[at] {
+				value := out
+				if seen[next] {
+					value = defined[next] & out
+				}
+				if !seen[next] || value != defined[next] {
+					seen[next], defined[next] = true, value
+					queue = append(queue, next)
+				}
+			}
+		}
+	}
+	return true
+}
+
+// A must-defined CFG proves that no component, including dead source, reads
+// incoming R27. Calls independently close their transitive bodies and kill
+// this fact at the caller. Nothing about a callee's resulting address escapes.
+func arm64ScratchNativeDoesNotAccess(body arm64ScratchNativeBody) bool {
+	instructions, edges, valid := arm64ScratchNativeGraph(body)
+	if !valid {
+		return false
+	}
+	effects := make([]arm64ScratchInputEffect, len(instructions))
+	for index, instruction := range instructions {
+		effect, valid := arm64ScratchNativeEffect(instruction)
+		if !valid {
+			return false
+		}
+		effects[index].call = effect.call
+		if effect.reads {
+			effects[index].reads = 1 << 27
+		}
+		if effect.defines {
+			effects[index].writes = 1 << 27
+		}
+	}
+	return arm64ScratchNativeAvailable(effects, edges, 0)
+}
diff --git a/arm64_native_scratch_origin_test.go b/arm64_native_scratch_origin_test.go
new file mode 100644
index 000000000..f7a055f77
--- /dev/null
+++ b/arm64_native_scratch_origin_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64NativeScratchOriginActualGoCFG(t *testing.T) {
+	fixtures := []struct {
+		name, body string
+		closed     bool
+	}{
+		{"full_x_definition", "MOVD $1,R27\nMOVD R27,R0", true},
+		{"full_w_zero_extension", "MOVW $1,R27\nMOVD R27,R0", true},
+		{"implicit_sb_scratch", "MOVBU ·cell(SB),R0", true},
+		{"entry_read", "MOVD R27,R0", false},
+		{"one_branch_lacks_definition", "CBZ R0,join\nMOVD $1,R27\njoin:\nMOVD R27,R1", false},
+		{"both_branches_define", "CBZ R0,other\nMOVD $1,R27\nB join\nother:\nMOVD $2,R27\njoin:\nMOVD R27,R1", true},
+		{"partial_movk", "MOVK $1,R27\nMOVD R27,R0", false},
+		{"defined_movk", "MOVD $1,R27\nMOVK $2,R27\nMOVD R27,R0", true},
+		{"call_kills_scratch_origin", "MOVD $1,R27\nCALL leaf(SB)\nMOVD R27,R0", false},
+		{"redefine_after_call", "CALL leaf(SB)\nMOVD $1,R27\nMOVD R27,R0", true},
+		{"dead_component_entry_read", "RET\nMOVD R27,R0", false},
+		{"loop_with_dominating_definition", "MOVD $1,R27\nloop:\nADD $1,R27\nCBNZ R0,loop\nMOVD R27,R1", true},
+		{"only_backedge_defines", "loop:\nMOVD R27,R1\nMOVD $1,R27\nCBNZ R0,loop", false},
+		{"branch_enters_before_definition", "CBZ R0,read\nMOVD $1,R27\nread:\nMOVD R27,R1", false},
+		{"unsupported_indirect_entry", "MOVD $1,R27\nJMP (R1)", false},
+		{"unsupported_system_transfer", "SVC $0", false},
+	}
+	var source strings.Builder
+	for _, fixture := range fixtures {
+		fmt.Fprintf(&source, "TEXT %s(SB),516,$0-0\n%s\nRET\n", fixture.name, fixture.body)
+	}
+	source.WriteString("TEXT leaf(SB),516,$0-0\nRET\nDATA ·cell(SB)/8,$1\nGLOBL ·cell(SB),8,$8\n")
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "origin_arm64.s"), filepath.Join(directory, "original.o")
+	if err := os.WriteFile(input, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-p", "example.invalid/origin", "-o", object, input)
+	if err != nil {
+		t.Fatalf("unchanged original Go source: %v\n%s", err, listing)
+	}
+	disassembly, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "objdump", object)
+	if err != nil {
+		t.Fatalf("actual native object decoder: %v\n%s", err, disassembly)
+	}
+	t.Logf("actual selected SDK assembly listing:\n%s\nfull native object/relocations:\n%s", listing, disassembly)
+	bodies, err := arm64ScratchObjectBodies(disassembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fixture := range fixtures {
+		t.Run(fixture.name, func(t *testing.T) {
+			body, present := bodies[fixture.name]
+			if !present {
+				t.Fatal("missing complete native object body")
+			}
+			if got := arm64ScratchNativeDoesNotAccess(body); got != fixture.closed {
+				t.Fatalf("actual native scratch incoming-origin closure=%v, want %v", got, fixture.closed)
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSourceSnapshotDoesNotAliasData(t *testing.T) {
+	file := &File{Arch: ArchARM64, Data: []DataStmt{{Sym: "·cell", Payload: []byte{1, 2, 3}}}}
+	snapshot := arm64ScratchFileSnapshot(file)
+	file.Data[0].Payload[1] = 9
+	if snapshot.Data[0].Payload[1] != 2 {
+		t.Fatal("a mutable public DATA payload changed the sealed original source")
+	}
+}
+
+func TestARM64NativeScratchRelocationAndNativeCFGMutations(t *testing.T) {
+	// Explicitly synthetic native byte/relocation mutations, not a claim that
+	// stock Go emitted these malformed bodies. Actual original object producer
+	// coverage above supplies the unchanged input/relocation reference.
+	valid := arm64ScratchNativeBody{
+		code:   []uint32{0x9000001b, 0x39400360, 0xd65f03c0},
+		relocs: []arm64ScratchNativeRelocation{{0, 8, "R_ARM64_PCREL_LDST8", "pkg.cell", 0}},
+	}
+	if !arm64ScratchNativeDoesNotAccess(valid) {
+		t.Fatal("complete native ADRP+LDRB origin control rejected")
+	}
+	for _, test := range []struct {
+		name string
+		edit func(*arm64ScratchNativeBody)
+	}{
+		{"unknown-relocation", func(body *arm64ScratchNativeBody) { body.relocs[0].kind = "R_UNKNOWN" }},
+		{"wrong-relocation-width", func(body *arm64ScratchNativeBody) { body.relocs[0].width = 4 }},
+		{"wrong-tuple-width", func(body *arm64ScratchNativeBody) { body.relocs[0].kind = "R_ARM64_PCREL_LDST64" }},
+		{"overlapping-relocation", func(body *arm64ScratchNativeBody) { body.relocs = append(body.relocs, body.relocs[0]) }},
+		{"wrong-address-base", func(body *arm64ScratchNativeBody) { body.code[1] = 0x39400340 }},
+		{"call-without-relocation", func(body *arm64ScratchNativeBody) { body.code[0] = 0x94000000; body.relocs = nil }},
+		{"call-target-addend", func(body *arm64ScratchNativeBody) {
+			body.code = []uint32{0x94000000, 0xd65f03c0}
+			body.calls = []string{"pkg.leaf"}
+			body.relocs = []arm64ScratchNativeRelocation{{0, 4, "R_CALLARM64", "pkg.leaf", 4}}
+		}},
+		{"branch-outside-body", func(body *arm64ScratchNativeBody) { body.code[0] = 0x14000005 }},
+		{"unknown-word", func(body *arm64ScratchNativeBody) { body.code[0] = 0xffffffff }},
+		{"unknown-return-register", func(body *arm64ScratchNativeBody) { body.code[2] = 0xd65f0020 }},
+		{"missing-real-return", func(body *arm64ScratchNativeBody) { body.code[2] = 0xd503201f }},
+		{"work-budget", func(body *arm64ScratchNativeBody) {
+			body.code = make([]uint32, 65537)
+			for i := range body.code {
+				body.code[i] = 0xd503201f
+			}
+			body.code[len(body.code)-1] = 0xd65f03c0
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			changed := valid
+			changed.code = append([]uint32(nil), valid.code...)
+			changed.relocs = append([]arm64ScratchNativeRelocation(nil), valid.relocs...)
+			test.edit(&changed)
+			if arm64ScratchNativeDoesNotAccess(changed) {
+				t.Fatal("malformed native component acquired an incoming-scratch summary")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_package_prefix_test.go b/arm64_native_scratch_package_prefix_test.go
new file mode 100644
index 000000000..851ac0cd5
--- /dev/null
+++ b/arm64_native_scratch_package_prefix_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64NativeScratchActualPackageSymbolNamespaces(t *testing.T) {
+	llc, _, _ := findLlcAndClang(t)
+	for _, packagePath := range []string{
+		"example.invalid/plain",
+		"example.invalid/with.dot",
+		"gopkg.in/scratch.v3",
+		"example.invalid/deep.with.dot/plain",
+		"example.invalid/plain/deep.with.dot",
+	} {
+		t.Run(packagePath, func(t *testing.T) {
+			_, pkg, file, options, source := arm64ScratchActualBoundSourceWithPackage(t,
+				"linux", "aarch64-unknown-linux-gnu", arm64ScratchSelectedSource, packagePath)
+			for _, name := range []string{"Scratch", "Value"} {
+				logical := pkg.Path + "." + name
+				if source.abis[logical] != "ABI0" || len(source.native[logical]) < 2 {
+					t.Fatalf("actual package ABI and all original native bodies lost logical identity %q: ABI=%q bodies=%d",
+						logical, source.abis[logical], len(source.native[logical]))
+				}
+			}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ScratchSourceAPI(t, pkg, file, options, api)
+					if err != nil {
+						t.Fatalf("actual stock-Go accepted package symbol identity prevented %s: %v", api, err)
+					}
+					compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "scratch.ll", "scratch.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchPackagePrefixMetadataIsNotAdmission(t *testing.T) {
+	source := &GoARM64ScratchSource{
+		packages: map[string]arm64ScratchPackage{
+			"example.invalid/with.dot": {},
+		},
+	}
+	for _, test := range []struct{ native, logical string }{
+		{"example.invalid/with%2edot.Value", "example.invalid/with.dot.Value"},
+		{"example.invalid/with%2edot.Value%2eOther", "example.invalid/with.dot.Value%2eOther"},
+		{"example.invalid/with%2edot.Value<1>", "example.invalid/with.dot.Value<1>"},
+		{"example.invalid/with%2Edot.Value", "example.invalid/with%2Edot.Value"},
+		{"example.invalid/with%2edotish.Value", "example.invalid/with%2edotish.Value"},
+		{"unknown/pkg%2edot.Value", "unknown/pkg%2edot.Value"},
+		{`"".Value`, `"".Value`},
+	} {
+		t.Run(test.native, func(t *testing.T) {
+			if actual := source.originalObjectCallTarget(test.native); actual != test.logical {
+				t.Fatalf("native package projection = %q, want %q", actual, test.logical)
+			}
+			if len(source.closed) != 0 || len(source.abis) != 0 || len(source.native) != 0 || source.ready {
+				t.Fatal("symbol metadata alone acquired a source, ABI, body or callee fact")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_runtime_test.go b/arm64_native_scratch_runtime_test.go
new file mode 100644
index 000000000..247c07dc7
--- /dev/null
+++ b/arm64_native_scratch_runtime_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64NativeScratchClosedCall(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	goos := runtime.GOOS
+	if len(runner) != 0 {
+		goos = "linux"
+	}
+	for _, operation := range []string{"add", "W27-full-overwrite", "initialized-local-pair", "transitive-call-result"} {
+		t.Run(operation, func(t *testing.T) {
+			assembly := arm64ScratchSelectedSource
+			goExpected, cExpected := "n+3", "n+3"
+			extraDeclarations := ""
+			switch operation {
+			case "W27-full-overwrite":
+				assembly = strings.Replace(assembly, "ADD $3,R1", "MOVD $-1,R27\nMOVWU R1,R27\nMOVD R27,R1", 1)
+				goExpected, cExpected = "uint64(uint32(n))", "(uint64_t)(uint32_t)n"
+			case "initialized-local-pair":
+				assembly = strings.Replace(assembly, "TEXT ·Value(SB),4,$0-16", "TEXT ·Value(SB),4,$32-16", 1)
+				assembly = strings.Replace(assembly, "ADD $3,R1",
+					"MOVD $7,R2\nSTP (R1,R2),16(RSP)\nLDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", 1)
+				goExpected, cExpected = "n+7", "n+7"
+			case "transitive-call-result":
+				assembly = strings.Replace(assembly, "TEXT ·Value(SB),4,$0-16", "TEXT ·Value(SB),4,$24-16", 1)
+				assembly = strings.Replace(assembly, "ADD $3,R1", "MOVD R1,8(RSP)\nCALL ·Leaf(SB)\nMOVD 16(RSP),R1", 1)
+				assembly += "TEXT ·Leaf(SB),4,$0-16\nMOVD n+0(FP),R1\nADD $3,R1\nMOVD R1,ret+8(FP)\nRET\n"
+				extraDeclarations = "func Leaf(n uint64) uint64\n"
+			}
+			_, _, file, options, source := arm64ScratchActualBoundSourceWithPackage(t,
+				goos, triple, assembly, "example.invalid/scratchfixture", extraDeclarations)
+			// The actual selected ordinary package and unchanged ASM execute via
+			// their compiler-produced ABI0 wrappers. This is not a handwritten
+			// native entry or a replacement for a downloaded library function.
+			directory := filepath.Join(source.request.Directory, "caller")
+			if err := os.Mkdir(directory, 0700); err != nil {
+				t.Fatal(err)
+			}
+			main := fmt.Sprintf(`package main
+import "example.invalid/scratchfixture"
+func main() {
+    canary := [3]uint64{0xabc,0xbad,0xdef}
+    samples := 0
+    for i := uint64(0); i < 1024; i++ {
+        n := i*0x9e3779b97f4a7c15 ^ (i<<32)
+        canary[1] = scratchfixture.Scratch(n)
+        if canary[1] != %s || canary[0] != 0xabc || canary[2] != 0xdef {
+            panic("original whole-call numeric/upper-alias/canary mismatch")
+        }
+        samples++
+    }
+    if samples != 1024 { panic("original sample denominator changed") }
+}
+`, goExpected)
+			if err := os.WriteFile(filepath.Join(directory, "main.go"), []byte(main), 0600); err != nil {
+				t.Fatal(err)
+			}
+			args := []string{"run", "-p=2"}
+			if len(runner) != 0 {
+				args = append(args, "-exec=qemu-aarch64")
+			}
+			args = append(args, "./caller")
+			ctx, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(ctx, source.request.GoBinary, args...)
+			command.Dir, command.Env = source.request.Directory, source.request.Environment
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			cancel()
+			if err != nil {
+				t.Fatalf("unchanged actual selected Go whole-call oracle: %v\n%s", err, output)
+			}
+			t.Logf("actual original Go %s: 1024 mathematical/full-X27/canary observations; retained output:\n%s", operation, output)
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mainC := fmt.Sprintf(`#include <stdint.h>
+extern uint64_t Scratch(uint64_t);
+int main(void) {
+    uint64_t canary[3] = {0xabc,0xbad,0xdef};
+    unsigned samples = 0;
+    for (uint64_t i = 0; i < 1024; i++) {
+        uint64_t n = i*UINT64_C(0x9e3779b97f4a7c15) ^ (i<<32);
+        canary[1] = Scratch(n);
+        if (canary[1] != %s || canary[0] != 0xabc || canary[2] != 0xdef) return 1;
+        samples++;
+    }
+    return samples == 1024 ? 0 : 2;
+}
+`, cExpected)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					arm64ScratchCompileRuntimeLevel(t, llc, triple, compiler, runner, level, ir, mainC)
+				})
+			}
+		})
+	}
+}
+
+func arm64ScratchCompileRuntimeLevel(t *testing.T, llc, triple string, compiler, runner []string, level, ir, main string) {
+	t.Helper()
+	if level != "-O0" && level != "-O2" || len(compiler) == 0 {
+		t.Fatal("missing actual compiler or unknown optimization level")
+	}
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "scratch.ll"), filepath.Join(directory, "scratch.o")
+	caller, executable := filepath.Join(directory, "caller.c"), filepath.Join(directory, "caller")
+	for name, data := range map[string]string{input: ir, caller: main} {
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", object)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("LLVM22 %s object: %v\n%s", level, err, output)
+	}
+	args := append([]string(nil), compiler[1:]...)
+	args = append(args, object, caller, level, "-o", executable)
+	ctx, cancel = runtimeOracleStageContext(t)
+	command = exec.CommandContext(ctx, compiler[0], args...)
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual %s compiler/link: %v\n%s", level, err, output)
+	}
+	args = runtimeOracleGuestArguments(t, runner, executable)
+	ctx, cancel = runtimeOracleStageContext(t)
+	command = exec.CommandContext(ctx, args[0], args[1:]...)
+	output, err = runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual %s whole-call numerical/canary run: %v\n%s", level, err, output)
+	}
+	t.Logf("LLVM22 %s: 1024 mathematical/full-X27/canary observations", level)
+}
diff --git a/arm64_native_scratch_samepkg_inputs.go b/arm64_native_scratch_samepkg_inputs.go
new file mode 100644
index 000000000..b487a84ba
--- /dev/null
+++ b/arm64_native_scratch_samepkg_inputs.go
@@ -0,0 +1,380 @@
+package plan9asm
+
+import (
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// This admission check is used only for a factory-captured same-package ABI0
+// callee on the new scratch-call path. It is not an ordinary ABI0 permission,
+// memory extent, caller frame, initialized pointee or physical SP certificate.
+// Architectural frame operations are kept separate from numerical GP facts.
+func arm64ScratchSamePackageInputs(function Func, signature FuncSig, body arm64ScratchNativeBody) bool {
+	return arm64ScratchSamePackageInputsWithCalls(function, signature, body, nil)
+}
+
+func arm64ScratchSamePackageInputsWithCalls(function Func, signature FuncSig, body arm64ScratchNativeBody, calls map[string]FuncSig) bool {
+	if !arm64ScratchSourceInputs(function, signature, calls, false) {
+		return false
+	}
+	instructions, edges, valid := arm64ScratchNativeGraph(body)
+	if !valid {
+		return false
+	}
+	neutral := make(map[int]bool)
+	frame := arm64SourceGoFrame(function)
+	if frame.present {
+		autosize := arm64SourceFrameAutosize(function.FrameSize)
+		if autosize < 16 || autosize > 240 || autosize%16 != 0 || len(instructions) < 6 ||
+			body.code[0] != 0xf8000ffe|uint32((-autosize)&511)<<12 ||
+			body.code[1] != 0xf81f83fd || body.code[2] != 0xd10023fd {
+			return false
+		}
+		for index := 0; index < 3; index++ {
+			neutral[index] = true
+		}
+		for index, instruction := range instructions {
+			if instruction.Op != arm64asm.RET {
+				continue
+			}
+			if index < 5 {
+				return false
+			}
+			restore := body.code[index-2 : index]
+			if frame.restoresLink {
+				if !arm64ScratchGeneratedRestore(restore, autosize) {
+					return false
+				}
+			} else if !arm64ScratchGeneratedLeafRestore(restore, autosize) {
+				return false
+			}
+			neutral[index-2], neutral[index-1] = true, true
+		}
+		// No branch may enter the middle of a generated frame operation.
+		for from, successors := range edges {
+			for _, to := range successors {
+				if neutral[to] && (to < 3 || neutral[to-1]) && from != to-1 {
+					return false
+				}
+			}
+		}
+	}
+	effects := make([]arm64ScratchInputEffect, len(instructions))
+	for index, instruction := range instructions {
+		if neutral[index] {
+			continue
+		}
+		if instruction.Op == arm64asm.BL {
+			// Every original target is separately closed by the factory. No
+			// data register, flag or address escapes that call into the caller.
+			effects[index].call = true
+			continue
+		}
+		effect, valid := arm64ScratchNativeInputEffect(instruction, true)
+		if !valid {
+			return false
+		}
+		effects[index] = effect
+	}
+	return arm64ScratchNativeAvailable(effects, edges, 0)
+}
+
+// These are the two actual obj7 leaf epilogues. One restores BP before SP;
+// the older producer restores SP then computes BP from that restored SP.
+// Neither architectural frame operation creates a numerical register fact.
+func arm64ScratchGeneratedLeafRestore(code []uint32, autosize int64) bool {
+	if len(code) != 2 || autosize < 16 || autosize > 240 || autosize%16 != 0 {
+		return false
+	}
+	return code[0] == 0x910003fd|uint32(autosize-8)<<10 &&
+		code[1] == 0x910003ff|uint32(autosize)<<10 ||
+		code[0] == 0x910003ff|uint32(autosize)<<10 && code[1] == 0xd10023fd
+}
+
+type arm64ScratchLocalBytes [4]uint64
+
+type arm64ScratchSourceBytes struct {
+	local, results arm64ScratchLocalBytes
+}
+
+func (bytes *arm64ScratchLocalBytes) transfer(offset, width int64, write bool) bool {
+	if offset < 0 || width <= 0 || width > 16 || offset > 256-width {
+		return false
+	}
+	for cursor := offset; cursor < offset+width; cursor++ {
+		word, bit := cursor/64, uint(cursor%64)
+		if write {
+			bytes[word] |= 1 << bit
+		} else if bytes[word]&(1<<bit) == 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ScratchReservedInput(reg Reg) bool {
+	return arm64StackReg(reg) || reg == "R29" || reg == "R30"
+}
+
+// Exact source-local bytes start undefined. This is an observation, not an
+// allocation: no slot is invented and no logical address becomes native. The
+// lowerer's existing frame/ABI/native-pointer guards must still accept it.
+func arm64ScratchSourceLocalInputs(function Func, signature FuncSig) bool {
+	return arm64ScratchSourceInputs(function, signature, nil, false)
+}
+
+// Call contracts come only from the factory's recursively closed original
+// source and matching assembler/archive bodies. They supply exact initialized
+// result bytes, never GP/NZCV outputs or permission to retain other locals.
+func arm64ScratchSourceInputs(function Func, signature FuncSig, calls map[string]FuncSig, requireResults bool) bool {
+	if function.FrameSize < 0 || function.FrameSize > 224 || function.ArgSize < 0 || function.ArgSize > 256 ||
+		len(function.Instrs) == 0 || len(function.Instrs) > 65536 {
+		return false
+	}
+	blocks := arm64SplitBlocks(function)
+	indices := make(map[string]int, len(blocks))
+	for index, block := range blocks {
+		if _, duplicate := indices[block.name]; duplicate {
+			return false
+		}
+		indices[block.name] = index
+	}
+	before, seen := make([]arm64ScratchSourceBytes, len(blocks)), make([]bool, len(blocks))
+	steps := 0
+	for entry := range blocks {
+		if seen[entry] {
+			continue
+		}
+		seen[entry] = true
+		queue := []int{entry}
+		for len(queue) != 0 {
+			at := queue[0]
+			queue = queue[1:]
+			state := before[at]
+			steps++
+			if steps > len(function.Instrs)*512 {
+				return false
+			}
+			for _, original := range blocks[at].instrs {
+				instruction := arm64ControlDecode(original)
+				op := arm64ControlOp(instruction)
+				if op == OpWORD || op == "DWORD" || op == arm64RawDataOp || original.arm64Encoded {
+					return false
+				}
+				for _, operand := range instruction.Args {
+					registers := []Reg{operand.Reg, operand.ShiftReg, operand.Mem.Index}
+					registers = append(registers, operand.RegList...)
+					for _, register := range registers {
+						if arm64ScratchReservedInput(register) {
+							return false
+						}
+					}
+					if operand.Kind == OpFPAddr || operand.Mem.Base == "R29" || operand.Mem.Base == "R30" {
+						return false
+					}
+					if operand.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+						if memory, parsed := parseMem(strings.TrimSpace(strings.TrimPrefix(operand.Sym, "$"))); parsed &&
+							(arm64ScratchReservedInput(memory.Base) || arm64ScratchReservedInput(memory.Index)) {
+							return false
+						}
+					}
+				}
+				if op == "CALL" || op == "BL" {
+					if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpSym ||
+						!strings.HasSuffix(instruction.Args[0].Sym, "(SB)") {
+						return false
+					}
+					target := strings.ReplaceAll(strings.TrimSuffix(instruction.Args[0].Sym, "(SB)"), "·", ".")
+					callee, closed := calls[target]
+					if !closed || !arm64ScratchCallLayout(callee) ||
+						!arm64ScratchCallSlots(&state.local, callee.Frame.Params, function.FrameSize, false) {
+						return false
+					}
+					state = arm64ScratchSourceBytes{}
+					if !arm64ScratchCallSlots(&state.local, callee.Frame.Results, function.FrameSize, true) {
+						return false
+					}
+					continue
+				}
+				if op == OpRET && requireResults {
+					for _, slot := range signature.Frame.Results {
+						width := int64((arm64MachineScalarWidth(slot.Type) + 7) / 8)
+						if !state.results.transfer(slot.Offset, width, false) {
+							return false
+						}
+					}
+				}
+				memory, width, store, registered := arm64ScratchSourceMemory(instruction)
+				for _, operand := range instruction.Args {
+					if operand.Kind == OpMem && arm64StackReg(operand.Mem.Base) {
+						exact := operand.Mem
+						exact.Base = SP // The registered grammar canonicalizes RSP's address-bank alias.
+						if !registered || memory.Kind != OpMem || memory.Mem != exact || function.FrameSize == 0 ||
+							operand.Mem.Index != "" || operand.Mem.Sym != "" || operand.Mem.OffRaw != "" ||
+							operand.Mem.Off < 8 || operand.Mem.Off > function.FrameSize+8-width ||
+							!state.local.transfer(operand.Mem.Off, width, store) {
+							return false
+						}
+					}
+				}
+				if registered && memory.Kind == OpFP && !store && !arm64ScratchParameterRange(signature, memory.FPOffset, width) {
+					return false
+				}
+				if registered && memory.Kind == OpFP && store && requireResults {
+					if !arm64ScratchSlotRange(signature.Frame.Results, memory.FPOffset, width) ||
+						!state.results.transfer(memory.FPOffset, width, true) {
+						return false
+					}
+				}
+				if registered && store && memory.Kind != OpFP && !(memory.Kind == OpMem && arm64StackReg(memory.Mem.Base)) {
+					// A potentially aliased write cannot preserve local byte facts.
+					state = arm64ScratchSourceBytes{}
+				}
+			}
+			successors, valid := arm64ScratchSourceSuccessors(blocks, indices, at)
+			if !valid {
+				return false
+			}
+			for _, next := range successors {
+				value := state
+				if seen[next] {
+					for word := range value.local {
+						value.local[word] &= before[next].local[word]
+						value.results[word] &= before[next].results[word]
+					}
+				}
+				if !seen[next] || value != before[next] {
+					seen[next], before[next] = true, value
+					queue = append(queue, next)
+				}
+			}
+		}
+	}
+	return true
+}
+
+func arm64ScratchParameterRange(signature FuncSig, offset, width int64) bool {
+	return arm64ScratchSlotRange(signature.Frame.Params, offset, width)
+}
+
+func arm64ScratchSlotRange(slots []FrameSlot, offset, width int64) bool {
+	if offset < 0 || width <= 0 || width > 16 || offset > 256-width {
+		return false
+	}
+	for at := offset; at < offset+width; at++ {
+		matches := 0
+		for _, slot := range slots {
+			bits := arm64MachineScalarWidth(slot.Type)
+			if bits != 0 && slot.Offset >= 0 && slot.Offset <= 256-int64((bits+7)/8) &&
+				at >= slot.Offset && at < slot.Offset+int64((bits+7)/8) {
+				matches++
+			}
+		}
+		if matches != 1 {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ScratchNumericCallLayout(signature FuncSig) bool {
+	if !arm64ScratchCallLayout(signature) {
+		return false
+	}
+	for _, argument := range signature.Args {
+		if argument == Ptr {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ScratchCallLayout(signature FuncSig) bool {
+	integer := func(typ LLVMType) bool {
+		return typ == I1 || typ == I8 || typ == I16 || typ == I32 || typ == I64
+	}
+	if len(signature.Args) != len(signature.Frame.Params) || len(signature.ArgRegs) != 0 ||
+		signature.ARM64GoRegisterABI != nil || signature.ARM64ClosureABI != nil {
+		return false
+	}
+	for _, argument := range signature.Args {
+		if !integer(argument) && argument != Ptr {
+			return false
+		}
+	}
+	return signature.Ret == Void && len(signature.Frame.Results) == 0 ||
+		integer(signature.Ret) && len(signature.Frame.Results) == 1 && signature.Frame.Results[0].Type == signature.Ret
+}
+
+func arm64ScratchCallSlots(bytes *arm64ScratchLocalBytes, slots []FrameSlot, frame int64, write bool) bool {
+	for _, slot := range slots {
+		width := int64((arm64MachineScalarWidth(slot.Type) + 7) / 8)
+		if slot.Offset < 0 || width == 0 || slot.Offset > frame-width ||
+			!bytes.transfer(8+slot.Offset, width, write) {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64ScratchSourceMemory(instruction Instr) (Operand, int64, bool, bool) {
+	op := arm64ControlOp(instruction)
+	if form, handled, err := parseARM64ScalarMemoryForm(op, instruction); handled {
+		return form.memory, int64(form.bits / 8), form.store, err == nil && !form.pre && !form.post
+	}
+	if pair, handled := arm64IntegerPairSpecs[op]; handled && len(instruction.Args) == 2 && instruction.Op == op {
+		memory, registers := instruction.Args[0], instruction.Args[1]
+		if !pair.load {
+			memory, registers = registers, memory
+		}
+		if registers.Kind == OpRegList && len(registers.RegList) == 2 &&
+			isARM64GeneralOrZeroReg(registers.RegList[0]) && isARM64GeneralOrZeroReg(registers.RegList[1]) &&
+			(!pair.load || registers.RegList[0] != registers.RegList[1]) {
+			if memory.Kind == OpMem && arm64StackReg(memory.Mem.Base) {
+				// Match the scalar grammar's address-bank canonicalization.
+				// This changes no offset, width, indexing or byte-definedness.
+				memory.Mem.Base = SP
+			}
+			return memory, int64(pair.elementBytes * 2), !pair.load, true
+		}
+	}
+	return Operand{}, 0, false, false
+}
+
+func arm64ScratchSourceSuccessors(blocks []arm64Block, labels map[string]int, at int) ([]int, bool) {
+	block := blocks[at]
+	if len(block.instrs) == 0 {
+		// Consecutive source labels retain separate CFG identities, but
+		// execute no effects. Preserve the incoming byte facts along their
+		// real fallthrough edge; a final empty block still has no exit proof.
+		if at+1 < len(blocks) {
+			return []int{at + 1}, true
+		}
+		return nil, false
+	}
+	last := arm64ControlDecode(block.instrs[len(block.instrs)-1])
+	op := arm64ControlOp(last)
+	if op == OpRET {
+		return nil, len(last.Args) == 0
+	}
+	var successors []int
+	if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+		if len(last.Args) == 0 {
+			return nil, false
+		}
+		name, valid := arm64BranchTarget(last.Args[len(last.Args)-1])
+		next, present := labels[name]
+		if !valid || !present {
+			return nil, false
+		}
+		successors = append(successors, next)
+		if op == "B" || op == "JMP" {
+			return successors, true
+		}
+	}
+	if at+1 == len(blocks) {
+		return nil, false
+	}
+	return append(successors, at+1), true
+}
diff --git a/arm64_native_scratch_samepkg_inputs_test.go b/arm64_native_scratch_samepkg_inputs_test.go
new file mode 100644
index 000000000..6f2bdc464
--- /dev/null
+++ b/arm64_native_scratch_samepkg_inputs_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are actual selected same-package sources and stock Go objects, not
+// rewritten diagnostic strings or an SDK-role unit fixture. The new scratch
+// observation must not admit undeclared incoming GP or NZCV state.
+func TestARM64NativeScratchSamePackageInputsRemainContext(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		frame      string
+		context    bool
+	}{
+		{"incoming-r6", "MOVD R6,R1", "0", true},
+		{"incoming-closure-r26", "MOVD R26,R1", "0", true},
+		{"incoming-nzcv", "B use\nCMP R1,R1\nuse:\nCSEL EQ,R1,R1,R1", "0", true},
+		{"incoming-sp-data", "MOVD RSP,R1", "0", true},
+		{"incoming-lr-data", "MOVD R30,R1", "0", true},
+		{"incoming-bp-data", "MOVD R29,R1", "0", true},
+		{"zero-frame-native-stack-load", "MOVD 8(RSP),R1", "0", true},
+		{"uninitialized-local-stack-load", "MOVD 16(RSP),R1", "32", true},
+		{"partial-local-stack-load", "MOVW R1,16(RSP)\nMOVD 16(RSP),R1", "32", true},
+		{"one-path-local-stack-load", "CBZ R1,use\nMOVD R1,16(RSP)\nuse:\nMOVD 16(RSP),R1", "32", true},
+		{"ordinary-fp-param-control", "ADD $3,R1", "0", false},
+		{"initialized-local-control", "MOVD R1,16(RSP)\nMOVD 16(RSP),R1", "32", false},
+		{"initialized-local-pair-control", "MOVD $7,R2\nSTP (R1,R2),16(RSP)\nLDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", false},
+		{"initialized-local-word-pair-control", "MOVD $7,R2\nSTPW (R1,R2),16(RSP)\nLDPW 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", false},
+		{"initialized-local-signed-pair-control", "MOVD $-7,R2\nSTPW (R1,R2),16(RSP)\nLDPSW 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", false},
+		{"initialized-local-zero-pair-control", "STP (R1,ZR),16(RSP)\nLDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", false},
+		{"uninitialized-local-pair", "LDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", true},
+		{"partial-local-pair", "STPW (R1,R1),16(RSP)\nLDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", true},
+		{"one-path-local-pair", "CBZ R1,use\nSTP (R1,R1),16(RSP)\nuse:\nLDP 16(RSP),(R3,R4)\nADD R4,R3\nMOVD R3,R1", "32", true},
+		{"initialized-local-alias-control", "MOVD R1,16(RSP)\nfirst: next: MOVD 16(RSP),R1", "32", false},
+		{"uninitialized-local-alias", "first: next: MOVD 16(RSP),R1", "32", true},
+		{"partial-local-alias", "MOVW R1,16(RSP)\nfirst: next: MOVD 16(RSP),R1", "32", true},
+		{"one-path-local-alias", "CBZ R1,first\nMOVD R1,16(RSP)\nfirst: next: MOVD 16(RSP),R1", "32", true},
+		{"bitfield-unknown-source", "SXTB R6,R1", "0", true},
+		{"bitfield-undefined-merge", "BFI $3,R1,$7,R4\nMOVD R4,R1", "0", true},
+		{"bitfield-defined-merge", "MOVD $1,R4\nBFI $3,R1,$7,R4\nMOVD R4,R1", "0", false},
+		{"bitfield-flags-retained", "CMP $1,R1\nSXTB R1,R4\nCSEL EQ,R1,R4,R1", "0", false},
+		{"bitfield-no-incoming-flags", "SXTB R1,R4\nCSEL EQ,R1,R4,R1", "0", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(arm64ScratchSelectedSource, "ADD $3,R1", test.body, 1)
+			assembly = strings.Replace(assembly, "TEXT ·Value(SB),4,$0-16", "TEXT ·Value(SB),4,$"+test.frame+"-16", 1)
+			ctx, pkg, file, options, source := arm64ScratchActualBoundSourceWithAssembly(t,
+				"linux", "aarch64-unknown-linux-gnu", assembly)
+			layout, layoutErr := source.actualCalleeSignature(ctx, pkg.Path+".Value", "Value")
+			if layoutErr != nil {
+				t.Fatal(layoutErr)
+			}
+			for _, body := range source.native[pkg.Path+".Value"] {
+				t.Logf("actual original body source=%q words=%08x relocations=%+v", body.source, body.code, body.relocs)
+				if !test.context {
+					_, physical := source.originalObjectSource(body.source)
+					t.Logf("actual admission stages: ABI=%s generated=%v captured=%v R27=%v local-bytes=%v machine-inputs=%v",
+						source.abis[pkg.Path+".Value"], source.originalObjectGenerated(body.source), physical,
+						arm64ScratchNativeDoesNotAccess(body), arm64ScratchSourceLocalInputs(source.functions[pkg.Path+".Value"], layout),
+						arm64ScratchSamePackageInputs(source.functions[pkg.Path+".Value"], layout, body))
+				}
+			}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					var err error
+					if api != "GoModule" {
+						_, err = arm64ScratchSourceAPI(t, pkg, file, options, api)
+					} else {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						translation, failure := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+							GOARCH: options.Goarch, TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym,
+							ManualSig: func(name string) (FuncSig, bool) {
+								signature, present := options.Sigs[name]
+								return signature, present
+							},
+						})
+						if translation != nil && !translation.Module.IsNil() {
+							translation.Module.Dispose()
+						}
+						err = failure
+					}
+					if test.context && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("actual same-package undeclared machine input acquired scratch-call admission through %s: %v", api, err)
+					}
+					if !test.context && err != nil {
+						t.Fatalf("actual ordinary FP/initialized-local control through %s: %v", api, err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_sdk_inputs.go b/arm64_native_scratch_sdk_inputs.go
new file mode 100644
index 000000000..d06d09439
--- /dev/null
+++ b/arm64_native_scratch_sdk_inputs.go
@@ -0,0 +1,230 @@
+package plan9asm
+
+import (
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// This is a separate SDK opaque-body admission contract. An explicit ABI0
+// wrapper supplies only its actual integer/pointer tuple. It does not supply
+// closure, g, platform registers, native SP addresses, NZCV or FP/SIMD inputs.
+// The body may define ordinary registers itself, but no resulting value is
+// transferred to the translator or the caller by this observation.
+func arm64ScratchSDKTuple(function Func, signature FuncSig) (uint64, bool) {
+	if function.FrameSize != 0 || len(function.Instrs) == 0 ||
+		signature.Ret != Void || len(signature.Args) == 0 || len(signature.Args) > 8 ||
+		len(signature.Frame.Results) != 0 || len(signature.Frame.Params) != len(signature.Args) ||
+		len(signature.ArgRegs) != 0 || signature.ARM64GoRegisterABI != nil || signature.ARM64ClosureABI != nil {
+		return 0, false
+	}
+	_, text := splitOpcode(function.Instrs[0].Raw)
+	parts := strings.Split(text, ",")
+	if len(parts) != 3 || !strings.Contains(parts[2], "-") || function.ArgSize != int64(len(signature.Args))*8 {
+		return 0, false
+	}
+	for index, argument := range signature.Args {
+		slot := signature.Frame.Params[index]
+		if argument != I64 && argument != Ptr || slot.Type != argument || slot.Index != index || slot.Offset != int64(index)*8 {
+			return 0, false
+		}
+	}
+	return uint64(1)<<uint(len(signature.Args)) - 1, true
+}
+
+// NZCV uses its architectural nibble ordering. Conditional selection and
+// branches read only their actual condition bits; CBZ/CBNZ and TBZ/TBNZ read
+// GP operands rather than NZCV. No unknown flag writer can preserve a fact.
+func arm64ScratchConditionInputs(condition arm64asm.Cond) (uint64, bool) {
+	var bits uint64
+	switch condition.String() {
+	case "EQ", "NE":
+		bits = 4
+	case "CS", "CC":
+		bits = 2
+	case "MI", "PL":
+		bits = 8
+	case "VS", "VC":
+		bits = 1
+	case "HI", "LS":
+		bits = 6
+	case "GE", "LT":
+		bits = 9
+	case "GT", "LE":
+		bits = 13
+	case "AL":
+	default:
+		return 0, false
+	}
+	return bits << 31, true
+}
+
+func arm64ScratchSDKArgumentInputs(argument arm64asm.Arg) (uint64, bool) {
+	switch argument := argument.(type) {
+	case nil, arm64asm.Imm, arm64asm.Imm64, arm64asm.ImmShift, arm64asm.PCRel:
+		return 0, true
+	case arm64asm.Cond:
+		return arm64ScratchConditionInputs(argument)
+	case arm64asm.Reg:
+		if argument == arm64asm.WZR || argument == arm64asm.XZR {
+			return 0, true
+		}
+		index, valid := arm64RawPoolGP(argument)
+		return uint64(1) << uint(index), valid && index != 30
+	case arm64asm.RegSP:
+		if arm64asm.Reg(argument) == arm64asm.SP || arm64asm.Reg(argument) == arm64asm.WSP {
+			return 0, false
+		}
+		return arm64ScratchSDKArgumentInputs(arm64asm.Reg(argument))
+	case arm64asm.RegExtshiftAmount:
+		// The typed decoder validates the shift/extension. Its private register
+		// is printed first; only exact GP names are accepted, not F/V aliases.
+		name, _, _ := strings.Cut(argument.String(), ",")
+		for index := 0; index < 30; index++ {
+			if name == arm64asm.Reg(int(arm64asm.X0)+index).String() ||
+				name == arm64asm.Reg(int(arm64asm.W0)+index).String() {
+				return uint64(1) << uint(index), true
+			}
+		}
+		return 0, false
+	case arm64asm.MemImmediate:
+		if argument.Mode == arm64asm.AddrPostReg {
+			return 0, false
+		}
+		return arm64ScratchSDKArgumentInputs(argument.Base)
+	case arm64asm.MemExtend:
+		base, baseValid := arm64ScratchSDKArgumentInputs(argument.Base)
+		index, indexValid := arm64ScratchSDKArgumentInputs(argument.Index)
+		return base | index, baseValid && indexValid
+	default:
+		return 0, false
+	}
+}
+
+func arm64ScratchSDKNativeEffect(instruction arm64asm.Inst) (arm64ScratchInputEffect, bool) {
+	return arm64ScratchNativeInputEffect(instruction, false)
+}
+
+func arm64ScratchNativeInputEffect(instruction arm64asm.Inst, sourceStack bool) (arm64ScratchInputEffect, bool) {
+	if form, valid := decodeARM64RawNZCV(instruction.Enc); valid {
+		reads, writes := form.gpEffects()
+		if (reads|writes)&(1<<30) != 0 || writes&((1<<18)|(1<<28)) != 0 {
+			return arm64ScratchInputEffect{}, false // No LR or platform/g output contract.
+		}
+		effect := arm64ScratchInputEffect{reads: uint64(reads), writes: uint64(writes)}
+		if !form.read {
+			effect.writes |= 15 << 31
+		} else if form.reg != ZR {
+			effect.reads |= 15 << 31
+		}
+		return effect, true
+	}
+	if form, valid := decodeARM64RawScalarRegister(instruction.Enc); valid {
+		reads, writes, stack := form.gpEffects()
+		if stack || (reads|writes)&(1<<30) != 0 {
+			return arm64ScratchInputEffect{}, false // No numerical SP/LR contract.
+		}
+		effect := arm64ScratchInputEffect{reads: uint64(reads), writes: uint64(writes)}
+		if form.flags {
+			effect.writes |= 15 << 31
+		}
+		return effect, true
+	}
+	if form, valid := decodeARM64RawBitfield(instruction.Enc); valid {
+		reads, writes := form.gpEffects()
+		if (reads|writes)&(1<<30) != 0 {
+			return arm64ScratchInputEffect{}, false // No native LR data contract.
+		}
+		return arm64ScratchInputEffect{reads: uint64(reads), writes: uint64(writes)}, true
+	}
+	if instruction.Op == arm64asm.RET {
+		return arm64ScratchInputEffect{}, instruction.Enc == 0xd65f03c0
+	}
+	// A native SDK call needs a separate same-call register/tuple transfer
+	// proof. The R27 transitive summary alone does not supply such an entry.
+	if instruction.Op == arm64asm.BL {
+		return arm64ScratchInputEffect{}, false
+	}
+	if _, valid := arm64ScratchNativeEffect(instruction); !valid {
+		return arm64ScratchInputEffect{}, false
+	}
+	writes, known := arm64RawPoolGPWrites(instruction.Enc)
+	if !known {
+		return arm64ScratchInputEffect{}, false
+	}
+	effect := arm64ScratchInputEffect{writes: uint64(writes)}
+	destinations := 0
+	word := instruction.Enc
+	switch {
+	case word&0x1c000000 == 0x10000000, word&0x0e000000 == 0x0a000000, word&0x0e000000 == 0x0e000000:
+		destinations = 1
+		switch instruction.Op {
+		case arm64asm.CMP, arm64asm.CMN, arm64asm.TST, arm64asm.CCMP, arm64asm.CCMN:
+			destinations = 0
+		}
+	case arm64RawPoolReadOnlyLoad(instruction.Op):
+		destinations = 1
+		if instruction.Op == arm64asm.LDP || instruction.Op == arm64asm.LDNP || instruction.Op == arm64asm.LDPSW {
+			destinations = 2
+		}
+	}
+	for index, argument := range instruction.Args {
+		reads, valid := arm64ScratchSDKArgumentInputs(argument)
+		if sourceStack {
+			if memory, stack := argument.(arm64asm.MemImmediate); stack && arm64asm.Reg(memory.Base) == arm64asm.SP {
+				// Exact source-local load/store roles were independently checked.
+				// SP is never supplied as a numerical GP fact. Generated frame
+				// operations are matched separately before reaching this path.
+				reads, valid = 0, memory.Mode == arm64asm.AddrOffset
+			}
+		}
+		if !valid {
+			return arm64ScratchInputEffect{}, false
+		}
+		if index < destinations {
+			if _, direct := argument.(arm64asm.Reg); direct {
+				reads = 0
+			}
+			if _, direct := argument.(arm64asm.RegSP); direct {
+				reads = 0
+			}
+		}
+		effect.reads |= reads
+	}
+	switch instruction.Op {
+	case arm64asm.MOVK, arm64asm.BFM, arm64asm.BFI, arm64asm.BFXIL:
+		effect.reads |= uint64(writes)
+	}
+	switch instruction.Op {
+	case arm64asm.ADC, arm64asm.SBC, arm64asm.NGC:
+		effect.reads |= 2 << 31
+	case arm64asm.ADCS, arm64asm.SBCS, arm64asm.NGCS:
+		effect.reads |= 2 << 31
+		effect.writes |= 15 << 31
+	case arm64asm.CMP, arm64asm.CMN, arm64asm.TST, arm64asm.ADDS, arm64asm.SUBS,
+		arm64asm.ANDS, arm64asm.BICS, arm64asm.NEGS, arm64asm.CCMP, arm64asm.CCMN:
+		effect.writes |= 15 << 31
+	case arm64asm.B, arm64asm.CBZ, arm64asm.CBNZ, arm64asm.TBZ, arm64asm.TBNZ, arm64asm.ADRP:
+	default:
+		if !arm64RawPoolInstructionPreservesNZCV(instruction) {
+			return arm64ScratchInputEffect{}, false
+		}
+	}
+	return effect, true
+}
+
+func arm64ScratchSDKBodyInputs(body arm64ScratchNativeBody, seed uint64) bool {
+	instructions, edges, valid := arm64ScratchNativeGraph(body)
+	if !valid {
+		return false
+	}
+	effects := make([]arm64ScratchInputEffect, len(instructions))
+	for index, instruction := range instructions {
+		effect, valid := arm64ScratchSDKNativeEffect(instruction)
+		if !valid {
+			return false
+		}
+		effects[index] = effect
+	}
+	return arm64ScratchNativeAvailable(effects, edges, seed)
+}
diff --git a/arm64_native_scratch_sdk_inputs_test.go b/arm64_native_scratch_sdk_inputs_test.go
new file mode 100644
index 000000000..cab96e585
--- /dev/null
+++ b/arm64_native_scratch_sdk_inputs_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64NativeScratchSDKHiddenEntryActualObject(t *testing.T) {
+	rootOutput, err := arm64MemoryAuditGoCommand(t, "linux", "env", "GOROOT")
+	if err != nil {
+		t.Fatal(err)
+	}
+	flags, err := os.ReadFile(filepath.Join(strings.TrimSpace(string(rootOutput)), "src", "cmd", "asm", "internal", "flags", "flags.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	runtimeFlags := []string(nil)
+	if bytes.Contains(flags, []byte(`flag.Bool("compiling-runtime"`)) {
+		// Original Go1.20 registers this explicit runtime producer role;
+		// current Go uses the actual package path instead. Inspect the selected
+		// SDK registration, not runtime.Version or a guessed epoch threshold.
+		runtimeFlags = append(runtimeFlags, "-compiling-runtime")
+	}
+	fixtures := []struct {
+		name, body string
+		closed     bool
+	}{
+		{"explicit-word", "MOVD R0,R1", true},
+		{"incoming-closure", "MOVD R26,R1", false},
+		{"incoming-g", "MOVD g,R1", false},
+		{"incoming-ordinary-gp", "MOVD R6,R1", false},
+		{"incoming-stack-address", "MOVD RSP,R1", false},
+		{"incoming-lr-data", "MOVD R30,R1", false},
+		{"incoming-nzcv-branch", "BEQ done\nMOVD R0,R1\ndone:", false},
+		{"incoming-nzcv-select", "CSEL EQ,R0,R0,R1", false},
+		{"incoming-carry", "ADC R0,R0,R1", false},
+		{"defined-nzcv", "CMP $1,R0\nCSEL EQ,R0,R0,R1", true},
+		{"transferred-nzcv", "MSR R0,NZCV\nMRS NZCV,R1\nCSET EQ,R2", true},
+		{"zero-nzcv", "MSR ZR,NZCV\nMRS NZCV,R1", true},
+		{"incoming-nzcv-read", "MRS NZCV,R1", false},
+		{"discarded-nzcv-read", "MRS NZCV,ZR", true},
+		{"unknown-nzcv-input", "MSR R6,NZCV\nMRS NZCV,R1", false},
+		{"one-branch-nzcv", "CBZ R0,join\nMSR R0,NZCV\njoin:\nMRS NZCV,R1", false},
+		{"defined-closure-as-data", "MOVD $1,R26\nMOVD R26,R1", true},
+		{"full-w-overwrite", "MOVWU R0,R26\nMOVD R26,R1", true},
+		{"partial-overwrite", "MOVK $1,R26\nMOVD R26,R1", false},
+		{"one-branch-undefined", "CBZ R0,join\nMOVD $1,R6\njoin:\nMOVD R6,R1", false},
+		{"both-branches-defined", "CBZ R0,other\nMOVD $1,R6\nB join\nother:\nMOVD $2,R6\njoin:\nMOVD R6,R1", true},
+		{"loop-dominating-definition", "MOVD $1,R6\nloop:\nADD $1,R6\nCBNZ R0,loop\nMOVD R6,R1", true},
+		{"loop-backedge-only", "loop:\nMOVD R6,R1\nMOVD $1,R6\nCBNZ R0,loop", false},
+		{"incoming-system-state", "MRS TPIDR_EL0,R1", false},
+	}
+	for _, fixture := range fixtures {
+		t.Run(fixture.name, func(t *testing.T) {
+			// Stock Go emits every original first-party body and its complete
+			// relocations. The SDK/package role below is a unit admission input,
+			// not an authenticated SDK, archive pair or factory-created token.
+			// ready stays false: this cannot bind or translate any program.
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			directory := filepath.Join(root, "src", "fixture")
+			if err := os.MkdirAll(directory, 0700); err != nil {
+				t.Fatal(err)
+			}
+			input := filepath.Join(directory, "inputs_arm64.s")
+			assembly := "TEXT ·Value<ABIInternal>(SB),516,$0-8\n" + fixture.body + "\nRET\n"
+			if err := os.WriteFile(input, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			object := filepath.Join(directory, "original.o")
+			arguments := append([]string{"tool", "asm", "-S", "-p", "runtime"}, runtimeFlags...)
+			arguments = append(arguments, "-o", object, input)
+			listing, err := arm64MemoryAuditGoCommand(t, "linux", arguments...)
+			if err != nil {
+				t.Fatalf("actual original Go object: %v\n%s", err, listing)
+			}
+			disassembly, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "objdump", object)
+			if err != nil {
+				t.Fatalf("actual original native bytes: %v\n%s", err, disassembly)
+			}
+			t.Logf("actual original listing:\n%s\nactual native body:\n%s", listing, disassembly)
+			bodies, err := arm64ScratchObjectBodies(disassembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			body, present := bodies["runtime.Value"]
+			if !present {
+				t.Fatal("original complete native body missing")
+			}
+			if filepath.FromSlash(strings.TrimPrefix(body.source, "gofile..")) != input {
+				t.Fatalf("actual native source position does not bind unchanged fixture: %q", body.source)
+			}
+			// This unit isolates machine-input admission, not object source-name
+			// transport. The raw SDK observation above remains unchanged. Old
+			// cmd/internal/src.FileSymPrefix is bound to this same physical file.
+			body.source = input
+			file, err := Parse(ArchARM64, assembly)
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatalf("whole source: %v", err)
+			}
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, filepath.Join(directory, "decl.go"), "package runtime\nfunc Value(n uint64)\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			typed, err := (&types.Config{Sizes: types.SizesFor("gc", "arm64")}).Check("runtime", fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			source := &GoARM64ScratchSource{
+				actual: GoPackage{Path: "example.invalid/caller"}, settings: map[string]string{"GOROOT": root},
+				inputs:    map[string][32]byte{input: sha256.Sum256([]byte(assembly))},
+				functions: map[string]Func{"runtime.Value": file.Funcs[0]},
+				native:    map[string][]arm64ScratchNativeBody{"runtime.Value": {body, body}},
+				packages:  map[string]arm64ScratchPackage{"runtime": {ImportPath: "runtime", Dir: directory, Standard: true, Goroot: true}},
+				typed:     map[string]GoPackage{"runtime": {Path: "runtime", Types: typed, Syntax: []*ast.File{syntax}}},
+				abis:      map[string]string{"runtime.Value": "ABIInternal"},
+			}
+			if physical, valid := source.originalObjectSource(body.source); !valid || physical != input {
+				t.Fatal("unit machine-input test lacks its captured physical source identity")
+			}
+			got, err := source.closedNativeCallee(context.Background(), "runtime.Value", make(map[string]bool), 0)
+			if err != nil || got != fixture.closed {
+				t.Fatalf("SDK unit admission over actual Go body=%v, want %v: %v", got, fixture.closed, err)
+			}
+			if source.ready {
+				t.Fatal("unit input manufactured a live source capability")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_shifted_zero_test.go b/arm64_native_scratch_shifted_zero_test.go
new file mode 100644
index 000000000..b3b743c00
--- /dev/null
+++ b/arm64_native_scratch_shifted_zero_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64NativeScratchShiftedZeroGoEncodingRows(t *testing.T) {
+	// Go's obj7 cases 3 and 27 independently supply the complete shifted
+	// arithmetic/logical and extended arithmetic source operand families.
+	// Expected zero-register effects do not depend on a mnemonic alias or
+	// on the translator's operand reader.
+	type witness struct {
+		name, instruction string
+		flags, comparison bool
+	}
+	var witnesses []witness
+	arithmetic := []struct {
+		op                string
+		flags, comparison bool
+	}{
+		{"ADD", false, false}, {"ADDS", true, false},
+		{"SUB", false, false}, {"SUBS", true, false},
+		{"CMP", true, true}, {"CMN", true, true},
+	}
+	appendRow := func(op, operand, name string, flags, comparison bool) {
+		instruction := op + " " + operand + ",R1"
+		if !comparison {
+			instruction += ",R4"
+		}
+		witnesses = append(witnesses, witness{name, instruction, flags, comparison})
+	}
+	for _, suffix := range []string{"", "W"} {
+		width := 64
+		if suffix == "W" {
+			width = 32
+		}
+		for _, operation := range arithmetic {
+			op := operation.op + suffix
+			for _, extension := range []string{"UXTB", "UXTH", "UXTW", "UXTX", "SXTB", "SXTH", "SXTW", "SXTX"} {
+				for shift := 0; shift <= 4; shift++ {
+					operand := fmt.Sprintf("ZR.%s<<%d", extension, shift)
+					appendRow(op, operand, fmt.Sprintf("%s_%s_%d", op, extension, shift),
+						operation.flags, operation.comparison)
+				}
+			}
+			for _, shift := range []string{"<<", ">>", "->"} {
+				for _, amount := range []int{0, 1, width - 1} {
+					operand := fmt.Sprintf("ZR%s%d", shift, amount)
+					appendRow(op, operand, fmt.Sprintf("%s_shift_%d", op, len(witnesses)),
+						operation.flags, operation.comparison)
+				}
+			}
+		}
+		for _, operation := range []struct {
+			op                string
+			flags, comparison bool
+		}{
+			{"AND", false, false}, {"BIC", false, false},
+			{"ORR", false, false}, {"ORN", false, false},
+			{"EOR", false, false}, {"EON", false, false},
+			{"ANDS", true, false}, {"BICS", true, false}, {"TST", true, true},
+		} {
+			op := operation.op + suffix
+			for _, shift := range []string{"<<", ">>", "->", "@>"} {
+				for _, amount := range []int{0, 1, width - 1} {
+					operand := fmt.Sprintf("ZR%s%d", shift, amount)
+					appendRow(op, operand, fmt.Sprintf("%s_shift_%d", op, len(witnesses)),
+						operation.flags, operation.comparison)
+				}
+			}
+		}
+	}
+	var assembly strings.Builder
+	for _, row := range witnesses {
+		fmt.Fprintf(&assembly, "TEXT %s(SB),516,$0-0\n%s\nRET\n", row.name, row.instruction)
+	}
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "shifted_zero_arm64.s"), filepath.Join(directory, "original.o")
+	if err := os.WriteFile(input, []byte(assembly.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", object, input)
+	if err != nil {
+		t.Fatalf("original Go shifted/extended operand families: %v\n%s", err, listing)
+	}
+	disassembly, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "objdump", object)
+	if err != nil {
+		t.Fatalf("original Go shifted/extended object: %v\n%s", err, disassembly)
+	}
+	bodies, err := arm64ScratchObjectBodies(disassembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range witnesses {
+		t.Run(row.name, func(t *testing.T) {
+			body, present := bodies[row.name]
+			if !present || len(body.code) < 2 || body.code[1] != 0xd65f03c0 || len(body.relocs) != 0 {
+				t.Fatal("original Go instruction/return identity missing")
+			}
+			var code [4]byte
+			binary.LittleEndian.PutUint32(code[:], body.code[0])
+			instruction, err := arm64asm.Decode(code[:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := arm64ScratchInputEffect{reads: 1 << 1}
+			if !row.comparison {
+				want.writes = 1 << 4
+			}
+			if row.flags {
+				want.writes |= 15 << 31
+			}
+			got, valid := arm64ScratchNativeInputEffect(instruction, false)
+			if !valid || got != want {
+				t.Fatalf("Go encoding %08x %v: shifted zero effect=%+v registered=%v, want %+v",
+					body.code[0], instruction, got, valid, want)
+			}
+			scratch, valid := arm64ScratchNativeEffect(instruction)
+			if !valid || scratch != (arm64ScratchEffect{}) {
+				t.Fatalf("shifted zero invented an incoming R27 effect: %+v valid=%v", scratch, valid)
+			}
+			gp, known := arm64RawPoolGPWrites(body.code[0])
+			if !known || gp != uint32(want.writes&0x7fffffff) ||
+				arm64RawPoolInstructionPreservesNZCV(instruction) != !row.flags {
+				t.Fatal("original scalar operand row disagrees with GP/NZCV consumers")
+			}
+			// Rm is field 20:16 in both Go encoding classes. Independently
+			// vary real GP, R27, LR and zero roles while retaining the actual
+			// source's operation/width/shift. This metadata control is not a
+			// new original-object or runtime certificate for the changed word.
+			for _, register := range []uint32{0, 1, 27, 30, 31} {
+				word := body.code[0]&^(31<<16) | register<<16
+				binary.LittleEndian.PutUint32(code[:], word)
+				changed, err := arm64asm.Decode(code[:])
+				if err != nil {
+					t.Fatal(err)
+				}
+				got, valid := arm64ScratchNativeInputEffect(changed, false)
+				if register == 30 {
+					if valid {
+						t.Fatal("shifted native LR acquired an input contract")
+					}
+					continue
+				}
+				control := want
+				if register != 31 {
+					control.reads |= 1 << register
+				}
+				if !valid || got != control {
+					t.Fatalf("shifted register %d effect=%+v valid=%v, want %+v", register, got, valid, control)
+				}
+				scratch, valid := arm64ScratchNativeEffect(changed)
+				if !valid || scratch != (arm64ScratchEffect{reads: register == 27}) {
+					t.Fatalf("shifted register %d R27 role differs: %+v valid=%v", register, scratch, valid)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchExtendedZeroSourceClosure(t *testing.T) {
+	for _, extension := range []string{"UXTB", "UXTH", "UXTW", "UXTX", "SXTB", "SXTH", "SXTW", "SXTX"} {
+		t.Run(extension, func(t *testing.T) {
+			operation := "ADD ZR." + extension + "<<1,R1,R1"
+			assembly := strings.Replace(arm64ScratchSelectedSource, "ADD $3,R1", operation, 1)
+			_, pkg, _, _, source := arm64ScratchActualBoundSourceWithAssembly(
+				t, "linux", "aarch64-unknown-linux-gnu", assembly)
+			// Closure is an actual original input/R27 observation, not a
+			// pointee bound, numerical result or external-runtime certificate.
+			if _, closed := source.closed[pkg.Path+".Value"]; !closed {
+				t.Fatal("Go-accepted zero extension failed actual native input closure")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_source_metadata.go b/arm64_native_scratch_source_metadata.go
new file mode 100644
index 000000000..2d2dddfd5
--- /dev/null
+++ b/arm64_native_scratch_source_metadata.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func (source *GoARM64ScratchSource) captureObjectSourceMetadata(root string) error {
+	filename := filepath.Join(root, "src", "cmd", "internal", "src", "pos.go")
+	data, err := source.read(filename)
+	if err != nil {
+		return err
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, data, 0)
+	if err != nil {
+		return err
+	}
+	count := 0
+	for _, declaration := range syntax.Decls {
+		group, valid := declaration.(*ast.GenDecl)
+		if !valid || group.Tok != token.CONST {
+			continue
+		}
+		for _, specification := range group.Specs {
+			value, valid := specification.(*ast.ValueSpec)
+			if !valid || len(value.Names) != 1 || value.Names[0].Name != "FileSymPrefix" {
+				continue
+			}
+			if len(value.Values) != 1 {
+				return arm64ScratchContext("unknown actual object source-symbol metadata")
+			}
+			literal, valid := value.Values[0].(*ast.BasicLit)
+			if !valid || literal.Kind != token.STRING {
+				return arm64ScratchContext("unknown actual object source-symbol prefix")
+			}
+			prefix, err := strconv.Unquote(literal.Value)
+			if err != nil || prefix != "gofile.." {
+				return arm64ScratchContext("unregistered actual object source-symbol prefix")
+			}
+			source.filePrefix = prefix
+			count++
+		}
+	}
+	if count != 1 {
+		return arm64ScratchContext("missing or ambiguous actual object source-symbol metadata")
+	}
+	flags, err := source.read(filepath.Join(root, "src", "cmd", "asm", "internal", "flags", "flags.go"))
+	if err != nil {
+		return err
+	}
+	// This actual registered old-assembler role is only passed for a selected
+	// SDK package. Stock export/archive equality still proves the original
+	// body's real producer role; neither this flag nor a prefix grants one.
+	source.compilingRuntime = bytes.Contains(flags, []byte(`flag.Bool("compiling-runtime"`))
+	return source.captureBuiltinObjectVersions(root)
+}
+
+// objfile's builtin relocation printer passes the builtin ABI value to
+// goobjName. Old SDK observations can therefore contain name<1>, unlike an
+// ordinary indexed symbol. Bind that metadata only to this actual SDK's
+// complete generated builtin table. This is not an ABI or callee admission.
+func (source *GoARM64ScratchSource) captureBuiltinObjectVersions(root string) error {
+	filename := filepath.Join(root, "src", "cmd", "internal", "goobj", "builtinlist.go")
+	data, err := source.read(filename)
+	if err != nil {
+		return err
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, data, 0)
+	if err != nil {
+		return err
+	}
+	versions := make(map[string]string)
+	count := 0
+	for _, declaration := range syntax.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.VAR {
+			continue
+		}
+		for _, specification := range group.Specs {
+			value, ok := specification.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || value.Names[0].Name != "builtins" || len(value.Values) != 1 {
+				continue
+			}
+			list, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok || len(list.Elts) == 0 || len(list.Elts) > 1024 {
+				return arm64ScratchContext("unknown actual object builtin metadata")
+			}
+			count++
+			for _, element := range list.Elts {
+				row, ok := element.(*ast.CompositeLit)
+				if !ok || len(row.Elts) != 2 {
+					return arm64ScratchContext("unknown actual object builtin row")
+				}
+				name, nameOK := row.Elts[0].(*ast.BasicLit)
+				abi, abiOK := row.Elts[1].(*ast.BasicLit)
+				if !nameOK || !abiOK || name.Kind != token.STRING || abi.Kind != token.INT || abi.Value != "0" && abi.Value != "1" {
+					return arm64ScratchContext("unknown actual object builtin ABI metadata")
+				}
+				symbol, err := strconv.Unquote(name.Value)
+				if err != nil || symbol == "" || strings.ContainsAny(symbol, "<>\r\n") {
+					return arm64ScratchContext("unknown actual object builtin name")
+				}
+				if abi.Value == "1" {
+					key := symbol + "<1>"
+					if _, duplicate := versions[key]; duplicate {
+						return arm64ScratchContext("ambiguous actual object builtin metadata")
+					}
+					versions[key] = symbol
+				}
+			}
+		}
+	}
+	if count != 1 || len(versions) == 0 {
+		return arm64ScratchContext("missing actual object builtin metadata")
+	}
+	source.builtinVersions = versions
+	return nil
+}
+
+func (source *GoARM64ScratchSource) originalObjectCallTarget(symbol string) string {
+	if canonical, captured := source.builtinVersions[symbol]; captured {
+		return canonical
+	}
+	for packagePath := range source.packages {
+		logical := arm64ScratchLogicalNativeSymbol(packagePath, symbol)
+		if logical != symbol {
+			return logical
+		}
+	}
+	return symbol
+}
+
+// Translate only the exact native prefix of an actually selected package.
+// Never percent-decode arbitrary function names, unknown packages or metadata.
+// Original source, ABI roles and complete native bodies are still independent.
+func arm64ScratchLogicalNativeSymbol(packagePath, symbol string) string {
+	prefix := gosym.PackagePrefix(packagePath) + "."
+	if strings.HasPrefix(symbol, prefix) {
+		return packagePath + "." + strings.TrimPrefix(symbol, prefix)
+	}
+	return symbol
+}
+
+// Normalize only the actual SDK's source metadata spelling. The result must
+// already be a captured canonical regular file with identical current bytes.
+// A relative spelling, logical/symlink alias or unrelated equal-byte file
+// cannot turn an object location into source authority.
+func (source *GoARM64ScratchSource) originalObjectSource(name string) (string, bool) {
+	if source.filePrefix != "" && strings.HasPrefix(name, source.filePrefix) {
+		name = strings.TrimPrefix(name, source.filePrefix)
+	}
+	name, valid := originalGoObjectSourcePath(name, source.settings["GOROOT"])
+	if !valid {
+		return "", false
+	}
+	physical, err := sourcepath.Resolve(name)
+	if err != nil || physical != name {
+		return "", false
+	}
+	digest, captured := source.inputs[name]
+	if !captured {
+		return "", false
+	}
+	data, err := goAMD64FrameRead(name)
+	return name, err == nil && sha256.Sum256(data) == digest
+}
+
+// This spelling is metadata only, never a wrapper/body admission. The actual
+// captured SDK prefix may decorate this marker in old object source records;
+// the exact bytes, ABI role and wrapper transport are checked independently.
+func (source *GoARM64ScratchSource) originalObjectGenerated(name string) bool {
+	if source.filePrefix != "" {
+		name = strings.TrimPrefix(name, source.filePrefix)
+	}
+	return name == "<autogenerated>"
+}
diff --git a/arm64_native_scratch_source_metadata_test.go b/arm64_native_scratch_source_metadata_test.go
new file mode 100644
index 000000000..59813ff5d
--- /dev/null
+++ b/arm64_native_scratch_source_metadata_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestARM64NativeScratchObjectSourceMetadataRequiresCapturedPhysicalInput(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(root, "src")
+	if err := os.Mkdir(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	input := filepath.Join(directory, "input.s")
+	data := []byte("TEXT ·Value(SB),516,$0-8\nRET\n")
+	if err := os.WriteFile(input, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	// Explicit metadata unit input, not a live factory or source permission.
+	source := &GoARM64ScratchSource{filePrefix: "gofile..", settings: map[string]string{"GOROOT": root},
+		inputs: map[string][32]byte{input: sha256.Sum256(data)}}
+	for _, name := range []string{
+		input, "gofile.." + input, filepath.ToSlash(input), "gofile.." + filepath.ToSlash(input),
+		"$GOROOT/src/input.s", "gofile..$GOROOT/src/input.s",
+	} {
+		if physical, valid := source.originalObjectSource(name); !valid || physical != input {
+			t.Fatalf("exact captured physical source metadata %q rejected: %q", name, physical)
+		}
+	}
+	foreign := filepath.Join(directory, "foreign.s")
+	if err := os.WriteFile(foreign, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(directory, "alias.s")
+	if err := os.Symlink(input, alias); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{
+		foreign, alias, "input.s", "gofile..input.s", "gofile..gofile.." + input,
+		filepath.Join(directory, "missing.s"), directory, "$GOROOT/../outside.s",
+		directory + "/../src/input.s", "unknown-prefix" + input,
+		"$GOROOT/src/../src/input.s", "$GOROOT/src/./input.s",
+		"$GOROOT//src/input.s", "gofile..$GOROOT/src/../src/input.s",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, valid := source.originalObjectSource(name); valid {
+				t.Fatal("uncaptured/relative/alias/escaping/nonregular metadata acquired a physical source identity")
+			}
+		})
+	}
+	if err := os.WriteFile(input, []byte("changed original bytes"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, valid := source.originalObjectSource("gofile.." + input); valid {
+		t.Fatal("metadata source bytes changed after capture")
+	}
+}
+
+func TestARM64NativeScratchBuiltinObjectVersionMetadataIsNotABIAdmission(t *testing.T) {
+	// This unit reads the actual selected SDK table. It deliberately has no
+	// live capture, source selection, native body or declaration permission.
+	source := &GoARM64ScratchSource{inputs: make(map[string][32]byte)}
+	root, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := source.captureBuiltinObjectVersions(root); err != nil {
+		t.Fatal(err)
+	}
+	if actual := source.originalObjectCallTarget("runtime.memmove<1>"); actual != "runtime.memmove" {
+		t.Fatalf("actual builtin ABI metadata was not preserved: %q", actual)
+	}
+	for _, symbol := range []string{
+		"runtime.memmove", "runtime.memmove<0>", "runtime.memmove<2>",
+		"runtime.memmove<ABIInternal>", "runtime.memmove<1>suffix", "runtime.memmove<01>",
+		"example.invalid/user.Value<1>", "runtime.unknown<1>",
+	} {
+		if actual := source.originalObjectCallTarget(symbol); actual != symbol {
+			t.Fatalf("uncaptured object version spelling %q acquired a canonical target %q", symbol, actual)
+		}
+	}
+	if source.ready || len(source.closed) != 0 || len(source.abis) != 0 {
+		t.Fatal("object metadata created an ABI/body admission")
+	}
+	source.builtinVersions = nil
+	if actual := source.originalObjectCallTarget("runtime.memmove<1>"); actual != "runtime.memmove<1>" {
+		t.Fatal("missing actual metadata was guessed")
+	}
+}
+
+func TestARM64NativeScratchGeneratedLeafFrameRestoreIsExact(t *testing.T) {
+	for _, autosize := range []int64{16, 32, 48, 240} {
+		for _, words := range [][]uint32{
+			{0x910003fd | uint32(autosize-8)<<10, 0x910003ff | uint32(autosize)<<10},
+			{0x910003ff | uint32(autosize)<<10, 0xd10023fd},
+		} {
+			if !arm64ScratchGeneratedLeafRestore(words, autosize) {
+				t.Fatalf("exact registered leaf restore %x frame=%d rejected", words, autosize)
+			}
+			for index := range words {
+				mutation := append([]uint32(nil), words...)
+				mutation[index] ^= 1
+				if arm64ScratchGeneratedLeafRestore(mutation, autosize) {
+					t.Fatalf("changed physical frame restore %x accepted", mutation)
+				}
+			}
+		}
+	}
+	for _, autosize := range []int64{-16, 0, 8, 24, 256} {
+		if arm64ScratchGeneratedLeafRestore([]uint32{0x910043ff, 0xd10023fd}, autosize) {
+			t.Fatalf("unbound physical frame %d accepted", autosize)
+		}
+	}
+}
diff --git a/arm64_native_scratch_source_ownership_test.go b/arm64_native_scratch_source_ownership_test.go
new file mode 100644
index 000000000..98e4f08ea
--- /dev/null
+++ b/arm64_native_scratch_source_ownership_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func arm64ScratchCaptureAliasedTemporary(t *testing.T, goos string) (context.Context, *GoARM64ScratchSource) {
+	t.Helper()
+	pkg, request := arm64ScratchActualSourceFixture(t, goos)
+	parentTemporary := t.TempDir()
+	physicalTemporary, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "request-temporary")
+	if err := os.Symlink(physicalTemporary, alias); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("TMPDIR", parentTemporary)
+	request.Environment = append(request.Environment,
+		"TMPDIR="+parentTemporary, "TMPDIR="+alias, "GOTMPDIR="+alias)
+	ctx, cancel := runtimeOracleStageContext(t)
+	t.Cleanup(cancel)
+	source, err := CaptureGoARM64ScratchSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if filepath.Dir(source.owned) != physicalTemporary {
+		t.Fatalf("factory artifacts are outside physical request TMPDIR: %q", source.owned)
+	}
+	if source.settings["TMPDIR"] != alias {
+		t.Fatal("canonical artifact identity changed the effective command environment")
+	}
+	if info, err := os.Lstat(source.owned); err != nil || !info.IsDir() || !os.SameFile(info, source.ownedInfo) {
+		t.Fatalf("canonical factory directory lost its created identity: %v", err)
+	}
+	return ctx, source
+}
+
+func TestARM64NativeScratchRequestTemporaryOwnership(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			ctx, source := arm64ScratchCaptureAliasedTemporary(t, goos)
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			owned := source.owned
+			parent := filepath.Dir(owned)
+			if err := source.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := os.Lstat(owned); !os.IsNotExist(err) {
+				t.Fatalf("Close retained factory artifacts: %v", err)
+			}
+			for _, name := range []string{parent, source.request.Directory, source.settings["TMPDIR"]} {
+				if _, err := os.Stat(name); err != nil {
+					t.Fatalf("Close removed caller-owned source/temporary input: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchOwnedIdentityRejectsRedirection(t *testing.T) {
+	for _, kind := range []string{"replacement directory", "symlink", "missing"} {
+		t.Run(kind, func(t *testing.T) {
+			ctx, source := arm64ScratchCaptureAliasedTemporary(t, "linux")
+			owned := source.owned
+			moved := filepath.Join(t.TempDir(), "original-artifacts")
+			if err := os.Rename(owned, moved); err != nil {
+				t.Fatal(err)
+			}
+			// Restore this fixture's original identity before its factory
+			// cleanup runs. Every replacement is inside our temporary root.
+			t.Cleanup(func() {
+				if err := os.RemoveAll(owned); err != nil {
+					t.Error(err)
+				}
+				if err := os.Rename(moved, owned); err != nil {
+					t.Error(err)
+				}
+			})
+			switch kind {
+			case "replacement directory":
+				if err := os.Mkdir(owned, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(owned, "other-owner"), []byte("retain me"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "symlink":
+				if err := os.Symlink(moved, owned); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) || source.ready {
+				t.Fatalf("changed owned identity retained observation: %v", err)
+			}
+			if err := source.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Close accepted an unowned replacement: %v", err)
+			}
+			if kind != "missing" {
+				if _, err := os.Lstat(owned); err != nil {
+					t.Fatalf("Close removed a replacement directory/link: %v", err)
+				}
+			}
+			if _, err := os.Stat(filepath.Join(moved, "symabis-1")); err != nil {
+				t.Fatalf("Close removed moved original artifacts: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_source_test.go b/arm64_native_scratch_source_test.go
new file mode 100644
index 000000000..e92d73d82
--- /dev/null
+++ b/arm64_native_scratch_source_test.go
@@ -0,0 +1,643 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+const arm64ScratchSelectedSource = `TEXT ·Scratch(SB),0,$32904-16
+MOVD n+0(FP),R1
+MOVD R1,8(RSP)
+CALL ·Value(SB)
+MOVD 16(RSP),R2
+MOVD R2,ret+8(FP)
+RET
+TEXT ·Value(SB),4,$0-16
+MOVD n+0(FP),R1
+ADD $3,R1
+MOVD R1,ret+8(FP)
+RET
+`
+
+func arm64ScratchActualSourceFixture(t *testing.T, goos string) (GoPackage, GoARM64ScratchCaptureRequest) {
+	return arm64ScratchActualSourceFixtureWithAssembly(t, goos, arm64ScratchSelectedSource)
+}
+
+func arm64ScratchActualSourceFixtureWithAssembly(t *testing.T, goos, assembly string) (GoPackage, GoARM64ScratchCaptureRequest) {
+	return arm64ScratchActualSourceFixtureWithPackage(t, goos, assembly, "example.invalid/scratchfixture")
+}
+
+func arm64ScratchActualSourceFixtureWithPackage(t *testing.T, goos, assembly, packagePath string, extraDeclarations ...string) (GoPackage, GoARM64ScratchCaptureRequest) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations := "package scratchfixture\nfunc Scratch(n uint64) uint64\nfunc Value(n uint64) uint64\n" + strings.Join(extraDeclarations, "\n")
+	for name, data := range map[string]string{
+		"go.mod":   "module " + packagePath + "\n\ngo 1.20\n",
+		"value.go": declarations, "value_arm64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filepath.Join(directory, "value.go"), declarations, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", "arm64")}).Check(
+		packagePath, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	environment := append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOEXPERIMENT=", "GOPACKAGESDRIVER=off")
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(os.Getenv(key)) {
+			environment = append(environment, key+"="+t.TempDir())
+		}
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}, GoARM64ScratchCaptureRequest{
+		GoBinary: binary, Directory: directory, AssemblyFile: "value_arm64.s", Target: goos + "/arm64", Environment: environment,
+	}
+}
+
+func arm64ScratchActualBoundSource(t *testing.T, goos, target string) (context.Context, GoPackage, *File, Options, *GoARM64ScratchSource) {
+	return arm64ScratchActualBoundSourceWithAssembly(t, goos, target, arm64ScratchSelectedSource)
+}
+
+func arm64ScratchActualBoundSourceWithAssembly(t *testing.T, goos, target, assembly string) (context.Context, GoPackage, *File, Options, *GoARM64ScratchSource) {
+	return arm64ScratchActualBoundSourceWithPackage(t, goos, target, assembly, "example.invalid/scratchfixture")
+}
+
+func arm64ScratchActualBoundSourceWithPackage(t *testing.T, goos, target, assembly, packagePath string, extraDeclarations ...string) (context.Context, GoPackage, *File, Options, *GoARM64ScratchSource) {
+	t.Helper()
+	pkg, request := arm64ScratchActualSourceFixtureWithPackage(t, goos, assembly, packagePath, extraDeclarations...)
+	ctx, cancel := runtimeOracleStageContext(t)
+	t.Cleanup(cancel)
+	source, err := CaptureGoARM64ScratchSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	file, err := Parse(ArchARM64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(strings.TrimSuffix(symbol, "(SB)"), "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options, err := source.BindScratchClosure(ctx, file, Options{
+		Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ctx, pkg, file, options, source
+}
+
+func TestARM64NativeScratchTransitiveAndPostCallOriginRemainContext(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+	}{
+		{"callee-entry-read", "MOVD R27,R1"},
+		{"callee-partial-definition", "MOVK $1,R27\nMOVD R27,R1"},
+		{"callee-one-branch", "CBZ R1,read\nMOVD $1,R27\nread:\nMOVD R27,R1"},
+		{"transitive-cycle", "CALL ·Value(SB)"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			assembly := strings.Replace(arm64ScratchSelectedSource, "ADD $3,R1", test.body, 1)
+			_, pkg, file, options, source := arm64ScratchActualBoundSourceWithAssembly(t, "linux", "aarch64-unknown-linux-gnu", assembly)
+			if _, closed := source.closed[pkg.Path+".Value"]; closed {
+				t.Fatal("unsafe native transitive component acquired a scratch-origin fact")
+			}
+			for _, api := range []string{"text", "module"} {
+				if _, err := arm64ScratchSourceAPI(t, pkg, file, options, api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("callee input/recursive origin escaped through %s: %v", api, err)
+				}
+			}
+		})
+	}
+	assembly := strings.Replace(arm64ScratchSelectedSource, "MOVD 16(RSP),R2", "MOVD R27,R2", 1)
+	_, pkg, file, options, _ := arm64ScratchActualBoundSourceWithAssembly(t, "linux", "aarch64-unknown-linux-gnu", assembly)
+	for _, api := range []string{"text", "module"} {
+		t.Run("caller-origin-killed/"+api, func(t *testing.T) {
+			if _, err := arm64ScratchSourceAPI(t, pkg, file, options, api); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("callee closure propagated its R27 address/value back to caller: %v", err)
+			}
+		})
+	}
+}
+
+func arm64ScratchSourceAPI(t *testing.T, pkg GoPackage, file *File, options Options, api string) (string, error) {
+	return arm64ScratchSourceAPIWithAssembly(t, pkg, file, options, api, arm64ScratchSelectedSource)
+}
+
+func arm64ScratchSourceAPIWithAssembly(t *testing.T, pkg GoPackage, file *File, options Options, api, assembly string) (string, error) {
+	t.Helper()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	var module llvm.Module
+	var err error
+	if api == "module" {
+		module, err = TranslateModuleInContext(ctx, file, options)
+	} else {
+		translation, translateErr := translateGoModuleInContext(ctx, pkg, []byte(assembly), GoModuleOptions{
+			GOARCH: options.Goarch, TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym,
+			ManualSig: func(name string) (FuncSig, bool) { signature, present := options.Sigs[name]; return signature, present },
+		})
+		err = translateErr
+		if translation != nil {
+			module = translation.Module
+		}
+	}
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return module.String(), nil
+}
+
+func TestARM64NativeScratchSourceThreeAPIActualObjects(t *testing.T) {
+	llc, _, _ := findLlcAndClang(t)
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"darwin", "arm64-apple-darwin"},
+		{"darwin", "arm64-apple-macosx"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			_, pkg, file, options, _ := arm64ScratchActualBoundSource(t, target.goos, target.triple)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ScratchSourceAPI(t, pkg, file, options, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "scratch.ll", "scratch.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSourceLabelAliases(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"darwin", "arm64-apple-darwin"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			for _, test := range []struct{ name, labels string }{
+				{"inline", "first: next:"},
+				{"internal_names", "reg_R0: anon_1:"},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					assembly := strings.Replace(arm64ScratchSelectedSource,
+						"ADD $3,R1", test.labels+" ADD $3,R1", 1)
+					_, pkg, file, options, source := arm64ScratchActualBoundSourceWithAssembly(
+						t, target.goos, target.triple, assembly)
+					// The factory assembled the unchanged source and captured both
+					// its native object and package archive. Empty source aliases
+					// must preserve fallthrough, not invent inputs or a return.
+					if _, closed := source.closed[pkg.Path+".Value"]; !closed {
+						t.Fatal("Go-accepted source label aliases broke native scratch closure")
+					}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := arm64ScratchSourceAPIWithAssembly(t, pkg, file, options, api, assembly)
+							if err != nil {
+								t.Fatal(err)
+							}
+							compileLLVMToObject(t, llc, target.triple, "aliases.ll", "aliases.o", ir)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchCanonicalCPPSourceIdentity(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"darwin", "arm64-apple-darwin"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			// The native producer and profile consumer must use the same CPP
+			// frontend. Keep exact source/file equality; do not erase Raw or
+			// relax the binding to compare only opcode/operand summaries.
+			original := strings.ReplaceAll(arm64ScratchSelectedSource, ",", ", ")
+			expanded, err := PreprocessAssemblySource(original, AssemblyPreprocessOptions{FileName: "value_arm64.s"})
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg, request := arm64ScratchActualSourceFixtureWithAssembly(t, target.goos, original)
+			ctx, cancel := runtimeOracleStageContext(t)
+			t.Cleanup(cancel)
+			source, err := CaptureGoARM64ScratchSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			file, err := Parse(ArchARM64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string {
+				return strings.TrimPrefix(strings.TrimSuffix(symbol, "(SB)"), "·")
+			}
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options, err := source.BindScratchClosure(ctx, file, Options{
+				Goarch: "arm64", TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs,
+			})
+			if err != nil {
+				t.Fatalf("unchanged original CPP selection: %v", err)
+			}
+			for _, api := range []string{"text", "module"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64ScratchSourceAPI(t, pkg, file, options, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "identity.ll", "identity.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchActualSDKBodyInputContract(t *testing.T) {
+	assembly := strings.Replace(arm64ScratchSelectedSource, "TEXT ·Value(SB),4,$0-16\nMOVD n+0(FP),R1\nADD $3,R1", `TEXT ·Value(SB),4,$40-16
+MOVD $0,R1
+MOVD R1,8(RSP)
+MOVD R1,16(RSP)
+MOVD R1,24(RSP)
+CALL runtime·memmove(SB)
+MOVD $11,R1`, 1)
+	pkg, request := arm64ScratchActualSourceFixtureWithAssembly(t, "linux", assembly)
+	filename := filepath.Join(request.Directory, "value.go")
+	declarations, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations = []byte(strings.Replace(string(declarations), "package scratchfixture\n", "package scratchfixture\nimport _ \"runtime\"\n", 1))
+	if err := os.WriteFile(filename, declarations, 0600); err != nil {
+		t.Fatal(err)
+	}
+	// The capture re-typechecks these actual complete selected files and the
+	// same-mode runtime export. Supplied ordinary function types cannot claim
+	// any SDK body, wrapper, hidden entry or source permission by themselves.
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, err := CaptureGoARM64ScratchSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	for index, body := range source.native["runtime.memmove"] {
+		t.Logf("actual SDK native member %d source=%s; complete original words=%08x; calls=%v; relocations=%+v",
+			index, body.source, body.code, body.calls, body.relocs)
+	}
+	if _, closed := source.closed["runtime.memmove"]; !closed {
+		t.Fatal("actual no-hidden-entry SDK body and actual ABI0 wrapper tuple did not close")
+	}
+	file, err := Parse(ArchARM64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(strings.TrimSuffix(symbol, "(SB)"), "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options, err := source.BindScratchClosure(ctx, file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc, _, _ := findLlcAndClang(t)
+	for _, api := range []string{"text", "module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			var ir string
+			var err error
+			if api == "GoModule" {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				result, translateErr := translateGoModuleInContext(context, pkg, []byte(assembly), GoModuleOptions{
+					GOARCH: options.Goarch, TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym,
+					ManualSig: func(name string) (FuncSig, bool) { signature, present := options.Sigs[name]; return signature, present },
+				})
+				err = translateErr
+				if result != nil && !result.Module.IsNil() {
+					defer result.Module.Dispose()
+					ir = result.Module.String()
+				}
+			} else {
+				ir, err = arm64ScratchSourceAPI(t, pkg, file, options, api)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, options.TargetTriple, "actual-sdk.ll", "actual-sdk.o", ir)
+		})
+	}
+}
+
+func TestARM64NativeScratchSourcePublicInputsCannotForge(t *testing.T) {
+	_, pkg, file, options, _ := arm64ScratchActualBoundSource(t, "linux", "aarch64-unknown-linux-gnu")
+	for _, mutation := range []string{"without-token", "JSON", "result-tuple", "callee-tuple", "target", "resolver", "whole-source", "KeepFunc"} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(mutation+"/"+api, func(t *testing.T) {
+				changed := options
+				changed.Sigs = make(map[string]FuncSig)
+				for name, signature := range options.Sigs {
+					changed.Sigs[name] = signature
+					if mutation == "without-token" {
+						signature.arm64NativeScratch = nil
+						changed.Sigs[name] = signature
+					}
+				}
+				input := arm64ScratchFileSnapshot(file)
+				switch mutation {
+				case "JSON":
+					data, err := json.Marshal(changed.Sigs)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := json.Unmarshal(data, &changed.Sigs); err != nil {
+						t.Fatal(err)
+					}
+				case "result-tuple", "callee-tuple":
+					name := "Scratch"
+					if mutation == "callee-tuple" {
+						name = "Value"
+					}
+					signature := changed.Sigs[name]
+					signature.Ret = I32
+					changed.Sigs[name] = signature
+				case "target":
+					changed.TargetTriple = "arm64-apple-darwin"
+				case "resolver":
+					changed.ResolveSym = func(name string) string { return "changed." + options.ResolveSym(name) }
+					renamed := make(map[string]FuncSig)
+					for name, signature := range changed.Sigs {
+						signature.Name = "changed." + name
+						renamed[signature.Name] = signature
+					}
+					changed.Sigs = renamed
+				case "whole-source":
+					input.Funcs[1].Instrs[2].Raw = "changed actual source"
+				case "KeepFunc":
+					input.Funcs = input.Funcs[:1]
+				}
+				if api == "GoModule" && (mutation == "whole-source" || mutation == "KeepFunc") {
+					// This API reparses its bytes, not the separately mutated File.
+					// Exercise its actual whole-source boundary explicitly below.
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					opt := GoModuleOptions{GOARCH: changed.Goarch, TargetTriple: changed.TargetTriple, ResolveSym: changed.ResolveSym,
+						ManualSig: func(name string) (FuncSig, bool) { signature, present := changed.Sigs[name]; return signature, present }}
+					source := arm64ScratchSelectedSource
+					if mutation == "whole-source" {
+						source = strings.Replace(source, "ADD $3", "ADD $4", 1)
+					} else {
+						opt.KeepFunc = func(symbol, _ string) bool { return symbol == "·Scratch" }
+					}
+					result, err := translateGoModuleInContext(ctx, pkg, []byte(source), opt)
+					if result != nil && !result.Module.IsNil() {
+						result.Module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("mutated whole selected source acquired a scratch certificate: %v", err)
+					}
+					return
+				}
+				_, err := arm64ScratchSourceAPI(t, pkg, input, changed, api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s acquired native scratch permission: %v", mutation, err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64NativeScratchBinderLLVMIdentityCannotCollapse(t *testing.T) {
+	ctx, _, file, options, source := arm64ScratchActualBoundSource(t, "linux", "aarch64-unknown-linux-gnu")
+	for _, resolved := range []string{"", "same"} {
+		t.Run("name="+resolved, func(t *testing.T) {
+			changed := options
+			changed.ResolveSym = func(string) string { return resolved }
+			signature := options.Sigs["Scratch"]
+			signature.Name = resolved
+			changed.Sigs = map[string]FuncSig{resolved: signature}
+			if _, err := source.BindScratchClosure(ctx, file, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("collapsed declaration namespace acquired a binding: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSourceLateInputMutationAndClose(t *testing.T) {
+	for _, input := range []string{"value.go", "value_arm64.s", "go.mod", "native-object", "new-selected-Go", "closed"} {
+		t.Run(input, func(t *testing.T) {
+			ctx, _, file, options, source := arm64ScratchActualBoundSource(t, "linux", "aarch64-unknown-linux-gnu")
+			if input == "closed" {
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				name := filepath.Join(source.request.Directory, input)
+				if input == "native-object" {
+					name = filepath.Join(source.owned, "original-0.o")
+				}
+				contents := "changed selected input"
+				if input == "new-selected-Go" {
+					name = filepath.Join(source.request.Directory, "new.go")
+					contents = "package scratchfixture\nconst NewlySelected = 1\n"
+				}
+				if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("late input mutation retained a live source token: %v", err)
+			}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("late input mutation produced LLVM output: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSourceCaptureRequiresActualRoles(t *testing.T) {
+	pkg, request := arm64ScratchActualSourceFixture(t, "linux")
+	for _, test := range []struct {
+		name string
+		ctx  context.Context
+		edit func(*GoPackage, *GoARM64ScratchCaptureRequest)
+	}{
+		{"unbounded", context.Background(), func(*GoPackage, *GoARM64ScratchCaptureRequest) {}},
+		{"foreign-package", nil, func(pkg *GoPackage, _ *GoARM64ScratchCaptureRequest) { pkg.Path = "foreign.invalid" }},
+		{"unselected-file", nil, func(_ *GoPackage, request *GoARM64ScratchCaptureRequest) { request.AssemblyFile = "other_arm64.s" }},
+		{"custom-driver", nil, func(_ *GoPackage, request *GoARM64ScratchCaptureRequest) {
+			request.Environment = append(request.Environment, "GOPACKAGESDRIVER=invented")
+		}},
+		{"unknown-target", nil, func(_ *GoPackage, request *GoARM64ScratchCaptureRequest) { request.Target = "linux/amd64" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			claimed, changed := pkg, request
+			test.edit(&claimed, &changed)
+			ctx := test.ctx
+			if ctx == nil {
+				var cancel context.CancelFunc
+				ctx, cancel = runtimeOracleStageContext(t)
+				defer cancel()
+			}
+			source, err := CaptureGoARM64ScratchSource(ctx, claimed, changed)
+			if source != nil {
+				defer source.Close()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal(fmt.Sprintf("actual input role %s acquired permission: %v", test.name, err))
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchOriginalSelectionFreshExportIdentity(t *testing.T) {
+	_, request := arm64ScratchActualSourceFixture(t, "linux")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	var identities [][]byte
+	for observation := 0; observation < 2; observation++ {
+		output, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary,
+			"list", "-deps", "-export", "-compiled", "-mod=readonly", "-json", ".")
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("actual stock Go selection observation %d:\n%s", observation, output)
+		identity, err := arm64ScratchSelectionIdentity(output)
+		if err != nil {
+			t.Fatal(err)
+		}
+		identities = append(identities, identity)
+	}
+	if string(identities[0]) != string(identities[1]) {
+		t.Fatal("actual original source/export identity changed across fresh export")
+	}
+}
+
+func TestARM64NativeScratchSelectionOnlyCacheStateIsTransient(t *testing.T) {
+	const observation = `{"Dir":"/source","ImportPath":"example.invalid/pkg","Export":"/export","BuildID":"actual","CompiledGoFiles":["value.go"],"Module":{"Path":"example.invalid/pkg","GoMod":"/source/go.mod","GoVersion":"1.20"},"ImportMap":{"other":"real/other"},"Stale":true,"StaleReason":"build ID mismatch","FutureField":{"Role":"original"}}`
+	expected, err := arm64ScratchSelectionIdentity([]byte(observation))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, field := range []string{"Stale", "StaleReason", "Dir", "ImportPath", "Export", "BuildID", "CompiledGoFiles", "Module", "ImportMap", "FutureField"} {
+		t.Run(field, func(t *testing.T) {
+			var record map[string]json.RawMessage
+			if err := json.Unmarshal([]byte(observation), &record); err != nil {
+				t.Fatal(err)
+			}
+			record[field] = json.RawMessage(`"changed"`)
+			changed, err := json.Marshal(record)
+			if err != nil {
+				t.Fatal(err)
+			}
+			actual, err := arm64ScratchSelectionIdentity(changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if equal := string(actual) == string(expected); equal != (field == "Stale" || field == "StaleReason") {
+				t.Fatalf("selection field %s identity equality=%v", field, equal)
+			}
+		})
+	}
+}
+
+func TestARM64NativeScratchSourceSharedBudgetIsObservationNotPermission(t *testing.T) {
+	name := filepath.Join(t.TempDir(), "input")
+	if err := os.WriteFile(name, []byte{1, 2}, 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name  string
+		bytes int64
+		count int
+	}{
+		{"bytes", 256<<20 - 1, 0},
+		{"count", 0, 8192},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := &GoARM64ScratchSource{inputs: make(map[string][32]byte), bytes: test.bytes}
+			for i := 0; i < test.count; i++ {
+				source.inputs[fmt.Sprint(i)] = [32]byte{}
+			}
+			if _, err := source.read(name); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("exhausted shared capture budget was ignored: %v", err)
+			}
+			if source.ready {
+				t.Fatal("resource ledger manufactured a source capability")
+			}
+		})
+	}
+}
diff --git a/arm64_native_scratch_tool_route.go b/arm64_native_scratch_tool_route.go
new file mode 100644
index 000000000..80495494b
--- /dev/null
+++ b/arm64_native_scratch_tool_route.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Only paths actually returned by the stock driver for its builtin tools or
+// selected exports use this route. Original source/SDK paths still go through
+// the strict physical-file reader. Retain both names so redirecting a cache
+// alias cannot substitute bytes during a later command or verification.
+func (source *GoARM64ScratchSource) readObservedCacheFile(name string) ([]byte, error) {
+	cache := source.settings["GOCACHE"]
+	if !filepath.IsAbs(name) || strings.ContainsAny(name, "\r\n") ||
+		!filepath.IsAbs(cache) || !goAssemblyPathWithinRoot(cache, name) {
+		return nil, arm64ScratchContext("unrecognized driver-generated cache input")
+	}
+	physicalCache, err := sourcepath.Resolve(cache)
+	if err != nil {
+		return nil, err
+	}
+	physical, err := sourcepath.Resolve(name)
+	if err != nil || !goAssemblyPathWithinRoot(physicalCache, physical) {
+		return nil, arm64ScratchContext("driver-generated input escaped its actual cache")
+	}
+	if previous, present := source.generatedPaths[name]; present && previous != physical {
+		return nil, arm64ScratchContext("driver-generated cache route changed")
+	}
+	data, err := source.read(physical)
+	if err != nil {
+		return nil, err
+	}
+	if source.generatedPaths == nil {
+		source.generatedPaths = make(map[string]string)
+	}
+	source.generatedPaths[name] = physical
+	return data, nil
+}
+
+func (source *GoARM64ScratchSource) readObservedTool(tool, name string) error {
+	if !filepath.IsAbs(name) || strings.ContainsAny(name, "\r\n") {
+		return arm64ScratchContext("unknown actual %s tool identity", tool)
+	}
+	executable := tool
+	if strings.HasSuffix(source.request.GoBinary, ".exe") {
+		executable += ".exe"
+	}
+	if name == filepath.Join(source.settings["GOTOOLDIR"], executable) {
+		_, err := source.read(name)
+		return err
+	}
+	// Go1.27's builtin-tool frontend builds these two tools for the host in
+	// GOCACHE even for cross targets. asm/compile must retain their SDK route.
+	if (tool != "objdump" && tool != "pack") || filepath.Base(name) != executable {
+		return arm64ScratchContext("unknown builtin %s tool origin", tool)
+	}
+	_, err := source.readObservedCacheFile(name)
+	return err
+}
+
+func (source *GoARM64ScratchSource) readObservedExport(pkg arm64ScratchPackage) ([]byte, error) {
+	// Older SDKs may still ship precompiled standard-library archives. Their
+	// exact selected SDK role remains physical, not an arbitrary export path.
+	if pkg.Standard && pkg.Goroot &&
+		goAssemblyPathWithinRoot(filepath.Join(source.settings["GOROOT"], "pkg"), pkg.Export) {
+		return source.read(pkg.Export)
+	}
+	return source.readObservedCacheFile(pkg.Export)
+}
+
+func (source *GoARM64ScratchSource) verifyGeneratedPaths() error {
+	for original, expected := range source.generatedPaths {
+		actual, err := sourcepath.Resolve(original)
+		if err != nil || actual != expected {
+			return arm64ScratchContext("driver-generated cache input was redirected")
+		}
+	}
+	return nil
+}
diff --git a/arm64_native_scratch_tool_route_test.go b/arm64_native_scratch_tool_route_test.go
new file mode 100644
index 000000000..c7efa690d
--- /dev/null
+++ b/arm64_native_scratch_tool_route_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestARM64NativeScratchActualAliasedBuiltinToolCache(t *testing.T) {
+	pkg, request := arm64ScratchActualSourceFixture(t, "linux")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	query, err := goasmcmd.Observe(ctx, request.Directory, os.Environ(),
+		request.GoBinary, "env", "GOCACHE")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cache, err := filepath.EvalSymlinks(strings.TrimSpace(string(query.Stdout)))
+	if err != nil || !filepath.IsAbs(cache) {
+		t.Fatalf("actual stock Go cache identity: %q %v", cache, err)
+	}
+	alias := filepath.Join(t.TempDir(), "actual-go-cache")
+	if err := os.Symlink(cache, alias); err != nil {
+		t.Fatal(err)
+	}
+	request.Environment = append(request.Environment, "GOCACHE="+alias)
+	observations := make(map[string]goasmcmd.Observation)
+	for _, tool := range []string{"asm", "compile", "objdump", "pack"} {
+		observed, err := goasmcmd.Observe(ctx, request.Directory, request.Environment,
+			request.GoBinary, "tool", "-n", tool)
+		if err != nil {
+			t.Fatalf("actual stock %s route: %v", tool, err)
+		}
+		observations[tool] = observed
+		encoded, err := json.Marshal(observed)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("SCRATCH_TOOL_CHILD %s", encoded)
+	}
+	source, err := CaptureGoARM64ScratchSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	for tool, observed := range observations {
+		original := strings.TrimSpace(string(observed.Stdout))
+		physical, err := filepath.EvalSymlinks(original)
+		if err != nil {
+			t.Fatal(err)
+		}
+		data, err := goAMD64FrameRead(physical)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if digest, present := source.inputs[physical]; !present || digest != sha256.Sum256(data) {
+			t.Fatalf("actual %s binary bytes were not retained at their physical route", tool)
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	// A later alias redirection must invalidate the observation, even though
+	// the previously sealed physical binaries and exports are still present.
+	if err := os.Remove(alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(t.TempDir(), alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) || source.ready {
+		t.Fatalf("redirected generated-input cache retained a native observation: %v", err)
+	}
+}
+
+func TestARM64NativeScratchToolRoutesRetainSourceBoundaries(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	cache, toolDir := filepath.Join(root, "cache"), filepath.Join(root, "sdk", "pkg", "tool", "host")
+	for _, directory := range []string{cache, toolDir, filepath.Join(root, "foreign")} {
+		if err := os.MkdirAll(directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, extension := range []string{"", ".exe"} {
+		for _, tool := range []string{"asm", "compile", "objdump", "pack"} {
+			name := tool + extension
+			for _, directory := range []string{toolDir, cache} {
+				if err := os.WriteFile(filepath.Join(directory, name), []byte("role control, not executable evidence"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			newSource := func() *GoARM64ScratchSource {
+				return &GoARM64ScratchSource{
+					request:  GoARM64ScratchCaptureRequest{GoBinary: filepath.Join(root, "sdk", "bin", "go"+extension)},
+					settings: map[string]string{"GOCACHE": cache, "GOTOOLDIR": toolDir},
+					inputs:   make(map[string][32]byte),
+				}
+			}
+			t.Run(name+"/SDK", func(t *testing.T) {
+				if err := newSource().readObservedTool(tool, filepath.Join(toolDir, name)); err != nil {
+					t.Fatal(err)
+				}
+			})
+			t.Run(name+"/cache", func(t *testing.T) {
+				err := newSource().readObservedTool(tool, filepath.Join(cache, name))
+				lazy := tool == "objdump" || tool == "pack"
+				if lazy && err != nil || !lazy && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("registered lazy-tool role=%t: %v", lazy, err)
+				}
+			})
+			for _, path := range []string{filepath.Join(root, "foreign", name), filepath.Join(cache, name+"-foreign"), name} {
+				if err := newSource().readObservedTool(tool, path); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("foreign tool route acquired an input role: %q %v", path, err)
+				}
+			}
+		}
+	}
+	foreign := filepath.Join(root, "foreign", "export")
+	if err := os.WriteFile(foreign, []byte("not an observed cache export"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	escape := filepath.Join(cache, "escaped-export")
+	if err := os.Symlink(foreign, escape); err != nil {
+		t.Fatal(err)
+	}
+	source := &GoARM64ScratchSource{settings: map[string]string{"GOCACHE": cache}, inputs: make(map[string][32]byte)}
+	if _, err := source.readObservedExport(arm64ScratchPackage{Export: escape}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("escaping cache export acquired a source role: %v", err)
+	}
+}
diff --git a/arm64_native_tail_contract_test.go b/arm64_native_tail_contract_test.go
new file mode 100644
index 000000000..fe1e90774
--- /dev/null
+++ b/arm64_native_tail_contract_test.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64NativeTailRejectsUnprovedABI(t *testing.T) {
+	for _, instruction := range []string{
+		"B (R9)", "JMP *0(R(9))", "RET R9", "RET 8(R9)",
+		"WORD $0xd61f0120", // BR X9: raw branches have no Go epilogue.
+		"WORD $0xd65f0120", // RET X9, not the caller's proved link.
+	} {
+		for _, frame := range []int{0, 32} {
+			t.Run(fmt.Sprintf("%s/frame_%d", instruction, frame), func(t *testing.T) {
+				flags := 4
+				if frame == 0 {
+					flags |= 512 // Go NOFRAME.
+				}
+				source := fmt.Sprintf("TEXT nativeTail(SB),%d,$%d-8\nMOVD fn+0(FP),R9\n%s\n", flags, frame, instruction)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+					"nativeTail": {
+						Name: "nativeTail", Args: []LLVMType{I64}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+					},
+				}})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unproved native tail target needs an ABI/frame/register contract: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64NativeTailRejectsMissingGoCallerEpilogue(t *testing.T) {
+	for _, instruction := range []string{
+		"B (R30)", "JMP (LR)", "WORD $0xd61f03c0", "WORD $0xd65f03c0",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			// Go creates a native frame for TEXT $32, but only its source
+			// RET pseudo instruction gets the automatic frame epilogue.
+			source := "TEXT framedCallerTail(SB),4,$32-0\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"framedCallerTail": {Name: "framedCallerTail", Ret: Void},
+			}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("caller-link proof alone cannot synthesize a missing Go epilogue: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64NativeTailZeroBranchesAreRealFaultingTerminators(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, instruction := range []string{
+		"B (ZR)", "JMP (RSP)", "RET ZR", "RET (RSP)",
+		"WORD $0xd61f03e0", // BR XZR.
+		"WORD $0xd65f03e0", // RET XZR.
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT zeroTail(SB),516,$0-0\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+			} {
+				ir, err := Translate(file, Options{
+					Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"zeroTail": {Name: "zeroTail", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, `asm sideeffect "br $0", "r,~{memory}"(i64 0)`+"\n  unreachable") {
+					t.Fatal("zero target must keep the real faulting branch with no synthetic return")
+				}
+				compileLLVMToObject(t, llc, triple, "zero-tail.ll", "zero-tail.o", ir)
+			}
+		})
+	}
+}
+
+func TestARM64RawBranchRegisterCompleteFields(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	forms := 0
+	for _, family := range []struct {
+		name string
+		word uint32
+	}{
+		{"BR", 0xd61f0000}, {"BLR", 0xd63f0000}, {"RET", 0xd65f0000},
+	} {
+		for index := 0; index < 32; index++ {
+			word := family.word | uint32(index)<<5
+			decoded, err := decodeARM64RawWordInstruction(Instr{
+				Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}},
+				Raw: fmt.Sprintf("WORD $%#x", word),
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			decoded = arm64HardwareReturnAsBranch(decoded)
+			if len(decoded.Args) != 1 {
+				t.Fatalf("%s X%d decoded without one target: %#v", family.name, index, decoded)
+			}
+			reg := decoded.Args[0].Reg
+			if decoded.Args[0].Kind == OpMem {
+				reg = decoded.Args[0].Mem.Base
+			}
+			want := Reg(fmt.Sprintf("R%d", index))
+			if index == 31 {
+				want = ZR
+			}
+			if reg != want {
+				t.Fatalf("%s field %d targets %s, want %s", family.name, index, reg, want)
+			}
+
+			name := fmt.Sprintf("rawBranch%d", forms)
+			forms++
+			sigs[name] = FuncSig{Name: name, Ret: Void}
+			fmt.Fprintf(&source, "TEXT %s(SB),516,$0-0\n", name)
+			if index == 31 {
+				fmt.Fprintf(&source, "WORD $%#x\n", word)
+				if family.name == "BLR" {
+					source.WriteString("B (ZR)\n")
+				}
+				continue // Real faulting terminator; not an executed success.
+			}
+			spelling := string(want)
+			if index == 18 {
+				spelling = "R18_PLATFORM"
+			}
+			if index == 28 {
+				spelling = "g"
+			}
+			save := "R19"
+			if index == 19 {
+				save = "R20"
+			}
+			fmt.Fprintf(&source, "MOVD R30,%s\nADR localTarget,%s\nWORD $%#x\n", save, spelling, word)
+			if family.name == "BLR" {
+				fmt.Fprintf(&source, "MOVD %s,R30\nRET\nlocalTarget:\nB (R30)\n", save)
+			} else {
+				fmt.Fprintf(&source, "localTarget:\nMOVD %s,R30\nRET\n", save)
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "raw-branch-register.ll", "raw-branch-register.o", ir)
+	}
+	t.Logf("All %d BR/BLR/RET register fields retain local/caller or zero-target context on four LLVM22 targets", forms)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64FramedSourceRET(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, instruction := range []string{"RET", "RET (R30)", "RET 8(R30)"} {
+		name := fmt.Sprintf("framedReturn%d", index)
+		fmt.Fprintf(&source, `TEXT ·%s(SB),4,$32-16
+MOVD a+0(FP),R0
+ADD $11,R0
+MOVD R0,ret+8(FP)
+%s
+`, name, instruction)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		println(got)
+		panic("framed RET mismatch")
+	}
+}
+`, name)
+		fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"framed RET mismatch\n");
+		return 1;
+	}
+}
+`, name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){ uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "framed_source_ret", triple, ir, main, runner)
+}
diff --git a/arm64_native_target_data_test.go b/arm64_native_target_data_test.go
new file mode 100644
index 000000000..073560e78
--- /dev/null
+++ b/arm64_native_target_data_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func arm64NativeTargetPoolSource(t *testing.T, payload []uint32) string {
+	t.Helper()
+	// Actual code loads eight data bytes, kills its pool address and returns.
+	// The data deliberately resembles every preflight family and invalid code.
+	words := assembleARM64LLVMWords(t, []string{
+		"adr x9,#16", "ldr x0,[x9]", "mov x9,xzr", "ret",
+	}, "")
+	var source strings.Builder
+	source.WriteString("TEXT comparison(SB),516,$0-0\n")
+	for _, word := range append(words, payload...) {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func TestARM64NativeTargetPreflightPreservesProvenPoolData(t *testing.T) {
+	payload := []uint32{
+		0x9e620000, 0x1e602000, 0x1e600400, 0x1e602800, 0x1e604800,
+		0xd53b4400, 0xd53b2400, 0x1eaf9499, 0xffffffff, 0x14000000,
+	}
+	source := arm64NativeTargetPoolSource(t, payload)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, blobs, err := prepareARM64RawPCRelative(file.Funcs[0])
+	if err != nil || len(blobs) != 1 || len(blobs[0].bytes) != 4*len(payload) {
+		t.Fatalf("independent existing pool proof lost the fixture: blobs=%v err=%v", blobs, err)
+	}
+	for _, target := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+		if err := validateARM64NativeTargets(file, Options{Goarch: "arm64", TargetTriple: target}); err != nil {
+			t.Errorf("data acquired an instruction/target requirement for %q: %v", target, err)
+		}
+	}
+	if !reflect.DeepEqual(file, original) {
+		t.Fatal("preflight changed the original source consumed by later proofs")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		for _, consumer := range arm64NZCVConsumerIRs(t, source, "package compare\nfunc comparison()\n", target) {
+			t.Run(target+"/"+consumer.name, func(t *testing.T) {
+				compileLLVMToObject(t, llc, target, "pool.ll", "pool.o", consumer.ir)
+			})
+		}
+	}
+}
+
+func TestARM64NativeTargetPreflightDataKeepsSourceAndNativeGates(t *testing.T) {
+	source := arm64NativeTargetPoolSource(t, []uint32{0x1eaf9499, 0xffffffff})
+	for _, instruction := range []string{
+		"SCVTFD R0,F0", "FCMPD F0,F0", "MRS FPCR,R0",
+		"FADDD F0,F0", "FMAXD F0,F0", "MRS RNDR,R0",
+	} {
+		withNative := strings.Replace(source, "$0-0\n", "$0-0\n"+instruction+"\n", 1)
+		requireARM64GoAssemblerResult(t, withNative, true)
+		file, err := Parse(ArchARM64, withNative)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := validateARM64NativeTargets(file, Options{}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("data damaged %s native-target requirement: %v", instruction, err)
+		}
+		if err := validateARM64NativeTargets(file, Options{TargetTriple: "aarch64-unknown-linux-gnu"}); err != nil {
+			t.Errorf("data damaged %s native-target acceptance: %v", instruction, err)
+		}
+	}
+	for _, changed := range []string{
+		strings.Replace(source, "WORD $0x1eaf9499", "WORD $0x11eaf9499", 1),
+		strings.Replace(source, "WORD $0x1eaf9499", "WORD $(missing_data)", 1),
+		strings.Replace(source, "WORD $0x1eaf9499", "WORD $(1.0)", 1),
+		// A pool address still live at return is not a closed data proof.
+		strings.Replace(source, "WORD $0xaa1f03e9", "WORD $0xd503201f", 1),
+	} {
+		if changed == source {
+			t.Fatal("negative fixture did not mutate the original source")
+		}
+		for _, api := range []string{"text", "module", "Go", "public-module"} {
+			present, err := arm64FPControlTargetAPI(t, api, changed, "aarch64-unknown-linux-gnu")
+			if present || err == nil {
+				t.Errorf("%s invalid/unproved data became successful translation: %v", api, err)
+			}
+		}
+	}
+}
+
+func TestARM64NativeTargetPreflightCannotHideExecutablePoolWords(t *testing.T) {
+	// A branch into the apparent pool makes it code. A dead component after
+	// RET followed by another RET is likewise not a proven literal island.
+	for _, prefix := range []string{"", "RET\n", "B code\ncode:\n"} {
+		for _, word := range []uint32{0x1e602000, 0x1eaf9499} {
+			source := fmt.Sprintf("TEXT comparison(SB),516,$0-0\n%sWORD $%#08x\nRET\n", prefix, word)
+			for _, api := range []string{"text", "module", "Go", "public-module"} {
+				present, err := arm64FPControlTargetAPI(t, api, source, "")
+				if present || err == nil || errors.Is(err, ErrProbeNeedsContext) != (word == 0x1e602000) {
+					t.Errorf("executable WORD lost its grammar/target gate: %s %s: %v", api, source, err)
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_native_target_preflight.go b/arm64_native_target_preflight.go
new file mode 100644
index 000000000..820cc58ce
--- /dev/null
+++ b/arm64_native_target_preflight.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import "errors"
+
+// A native-target requirement is deferred until every registered family's
+// source grammar has been checked. Otherwise a valid conversion can hide an
+// invalid compare or system-register transfer later in the same source file.
+// This changes error precedence only; it never supplies a native target or
+// any entry, memory, flag, source-encoder or continuation permission.
+func validateARM64NativeTargets(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	// Check the source class before any native-family matching, dead-code
+	// filtering or raw PC/data normalization can consume a truncated word.
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if instruction.Op == OpWORD {
+				if _, err := arm64RawWordValue(instruction); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	file = arm64NativeTargetCodeView(file)
+	var targetError error
+	for _, validate := range []func(*File, Options) error{
+		validateARM64ScalarConversionNativeTarget,
+		validateARM64ScalarCompareTarget,
+		validateARM64FPControlTarget,
+		validateARM64ScalarBinaryTarget,
+		validateARM64ScalarMinMaxTarget,
+		validateARM64RNDRTarget,
+	} {
+		if err := validate(file, options); err != nil {
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				return err
+			}
+			if targetError == nil {
+				targetError = err
+			}
+		}
+	}
+	if targetError != nil {
+		// Some native families do not themselves claim unrelated WORDs.
+		// Their target error still cannot hide a malformed instruction.
+		for _, function := range file.Funcs {
+			for _, instruction := range function.Instrs {
+				if err := arm64RawWordPreflightError(instruction); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+					return err
+				}
+			}
+		}
+	}
+	return targetError
+}
+
+// WORD's source constant class applies to code and data alike, but native
+// instruction grammars apply only to code. Reuse the lowerer's bounded raw
+// routine/pool proof, without a caller return-clobber permission, to mark
+// appended data. Unlike later emission, preflight must not classify a dead
+// source WORD as data merely because it follows RET.
+//
+// This is a private inspection copy, not the source consumed by translation.
+// If the proof cannot close, leave the original function intact. Do not
+// rewrite any branch or other instruction in this syntax-only view.
+func arm64NativeTargetCodeView(file *File) *File {
+	view := *file
+	view.Funcs = append([]Func(nil), file.Funcs...)
+	for index, function := range file.Funcs {
+		hasWord := false
+		for _, instruction := range function.Instrs {
+			if instruction.Op == OpWORD {
+				hasWord = true
+				break
+			}
+		}
+		if !hasWord {
+			continue
+		}
+		points := make([]arm64RawLayoutPoint, len(function.Instrs))
+		knownLabels := make(map[string]bool)
+		point := arm64RawLayoutPoint{}
+		for at, instruction := range function.Instrs {
+			points[at] = point
+			if instruction.Op == OpLABEL && len(instruction.Args) == 1 && instruction.Args[0].Kind == OpLabel {
+				knownLabels[instruction.Args[0].Sym] = true
+			}
+			width, known := arm64RawKnownSourceWidth(function, instruction)
+			if !known {
+				point.segment++
+				point.offset = 0
+			} else {
+				point.offset += width
+			}
+		}
+		data, _, _ := identifyARM64UnlabelledPool(function, points, knownLabels, 0)
+		if len(data) == 0 {
+			continue
+		}
+		view.Funcs[index].Instrs = append([]Instr(nil), function.Instrs...)
+		for at := range data {
+			view.Funcs[index].Instrs[at].Op = arm64RawDataOp
+		}
+	}
+	return &view
+}
diff --git a/arm64_native_target_preflight_test.go b/arm64_native_target_preflight_test.go
new file mode 100644
index 000000000..db82564fe
--- /dev/null
+++ b/arm64_native_target_preflight_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestARM64NativeTargetPreflightComposesFamilyErrors(t *testing.T) {
+	// Go independently rejects each malformed member. A different valid
+	// native family must not hide it behind a missing/foreign target error.
+	for _, pair := range [][2]string{
+		{"SCVTFD R0,F0", "FCMPD F0,R0"},
+		{"SCVTFD R0,F0", "MSR $1,FPCR"},
+		{"FCMPD F0,F0", "MSR $1,FPSR"},
+		{"FCMPD F0,F0", "WORD $0xffffffff"},
+		{"FCMPD F0,F0", "FADDD F0,R0"},
+		{"FADDD F0,F0", "MSR $1,FPCR"},
+		{"FADDD F0,F0", "FMAXD F0,R0"},
+		{"FMAXD F0,F0", "FADDD F0,R0"},
+		{"FMAXD F0,F0", "MSR R0,RNDR"},
+		{"MOVD RNDRRS,R0", "FMAXD F0,R0"},
+	} {
+		requireARM64GoAssemblerResult(t, "TEXT comparison(SB),4,$0-0\n"+pair[0]+"\nRET\n", true)
+		if pair[1] != "WORD $0xffffffff" {
+			requireARM64GoAssemblerResult(t, "TEXT comparison(SB),4,$0-0\n"+pair[1]+"\nRET\n", false)
+		}
+		for _, body := range []string{
+			pair[0] + "\n" + pair[1], pair[1] + "\n" + pair[0],
+			pair[0] + "\nRET\n" + pair[1],
+		} {
+			for _, target := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "aarch64-unknown-linux-gnu"} {
+				for _, api := range []string{"text", "module", "Go", "public-module"} {
+					t.Run(fmt.Sprintf("%s/%s/%s", api, target, body), func(t *testing.T) {
+						present, err := arm64FPControlTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\n"+body+"\nRET\n", target)
+						if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("cross-family malformed source hidden by target context: output=%t err=%v", present, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_needed.go b/arm64_needed.go
deleted file mode 100644
index 29da2fe5c..000000000
--- a/arm64_needed.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package plan9asm
-
-import "strings"
-
-// funcNeedsARM64CFG decides whether we need the (currently) ARM64-only CFG-based
-// translator. The linear prototype cannot handle labels/branches or opcode
-// suffixes like ".P".
-func funcNeedsARM64CFG(fn Func) bool {
-	for _, ins := range fn.Instrs {
-		if ins.Op == OpLABEL {
-			return true
-		}
-		rawOp := strings.ToUpper(string(ins.Op))
-		if strings.Contains(rawOp, ".") {
-			return true
-		}
-		op := rawOp
-		if dot := strings.IndexByte(op, '.'); dot >= 0 {
-			op = op[:dot]
-		}
-		switch Op(op) {
-		// Keep the linear path only for the tiny subset it can currently lower.
-		case OpTEXT, OpBYTE, OpMRS:
-			continue
-		case OpRET:
-			if len(ins.Args) != 0 {
-				return true
-			}
-			continue
-		case OpMOVD:
-			// Linear arm64 lowering only supports immediate/reg/FP value moves.
-			for _, a := range ins.Args {
-				switch a.Kind {
-				case OpImm, OpReg, OpFP:
-					// ok
-				default:
-					return true
-				}
-			}
-			continue
-		case "B", "JMP", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT",
-			"CBZ", "CBNZ", "TBZ", "TBNZ":
-			return true
-		default:
-			// Any other opcode is unsupported by linear arm64 lowering.
-			return true
-		}
-	}
-	return false
-}
-
-type arm64Flags struct {
-	kind  string // "cmp" or "res"
-	dst   string // i64 SSA or constant
-	src   string // i64 SSA or constant (for cmp)
-	width LLVMType
-}
diff --git a/arm64_new_opfamilies_test.go b/arm64_new_opfamilies_test.go
index 17f5228f6..06664a129 100644
--- a/arm64_new_opfamilies_test.go
+++ b/arm64_new_opfamilies_test.go
@@ -1,13 +1,455 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 )
 
+func TestTranslateARM64ScalarSquareRootFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 maps both scalar square-root opcodes to the AFCVTSD optab:
+	// exactly one F-register source and one F-register destination.
+	src := `
+TEXT scalarsquarerootforms(SB),NOSPLIT,$0-0
+	FSQRTS F0, F9
+	FSQRTD F14, F27
+	RET
+`
+	file, err := Parse(ArchARM64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"scalarsquarerootforms": {Name: "scalarsquarerootforms", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, intrinsic := range []string{"@llvm.sqrt.f32", "@llvm.sqrt.f64"} {
+		if !strings.Contains(ll, intrinsic) {
+			t.Fatalf("scalar square-root lowering omitted %s:\n%s", intrinsic, ll)
+		}
+	}
+}
+
+func TestTranslateARM64ScalarSquareRootFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"FSQRTS F0",
+		"FSQRTD F0, F1, F2",
+		"FSQRTS R0, F1",
+		"FSQRTD F0, R1",
+		"FSQRTS.P F0, F1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidscalarsquareroot(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"invalidscalarsquareroot": {Name: "invalidscalarsquareroot", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's AFCVTSD optab", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64ScalarPrecisionConversionCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 maps all six scalar precision conversions to AFCVTSD's single
+	// C_FREG -> C_FREG optab row; mnemonic letters specify source then result.
+	src := `
+TEXT scalarprecisionconversionforms(SB),$0-0
+	FCVTSD F0, F31
+	FCVTDS F30, F1
+	FCVTSH F2, F29
+	FCVTHS F28, F3
+	FCVTDH F4, F27
+	FCVTHD F26, F5
+	RET
+`
+	requireARM64GoAssemblerResult(t, src, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		file, err := Parse(ArchARM64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ll, err := Translate(file, Options{
+			TargetTriple: triple,
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"scalarprecisionconversionforms": {Name: "scalarprecisionconversionforms", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, want := range []string{
+			"fpext float", "fptrunc double",
+			"fptrunc float", "to half", "fpext half", "to float",
+			"fptrunc double", "to half", "fpext half", "to double",
+		} {
+			if !strings.Contains(ll, want) {
+				t.Fatalf("scalar precision conversion for %s omitted %q:\n%s", triple, want, ll)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "scalar-precision-conversion.ll", "scalar-precision-conversion.o", ll)
+	}
+}
+
+func TestTranslateARM64ScalarPrecisionConversionRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"FCVTSD F0",
+		"FCVTDS F0, F1, F2",
+		"FCVTSH F0",
+		"FCVTHS F0, F1, F2",
+		"FCVTDH R0, F1",
+		"FCVTHD F0, R1",
+		"FCVTSD R0, F1",
+		"FCVTDS F0, R1",
+		"FCVTSD.P F0, F1",
+	} {
+		src := "TEXT invalidscalarprecisionconversion(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+		file, err := Parse(ArchARM64, src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "aarch64-unknown-linux-gnu",
+			Goarch:       "arm64",
+			Sigs: map[string]FuncSig{
+				"invalidscalarprecisionconversion": {Name: "invalidscalarprecisionconversion", Ret: Void},
+			},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's scalar precision-conversion optab", instruction)
+		}
+	}
+}
+
+func TestTranslateARM64IntegerToScalarFloatFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 maps these eight opcodes to ASCVTFD's single C_ZREG->C_FREG
+	// row. The W spellings consume the low i32; the others consume i64.
+	src := `
+TEXT integerfloatforms(SB),NOSPLIT,$0-0
+	SCVTFD R0, F0
+	SCVTFS R1, F1
+	SCVTFWD R2, F2
+	SCVTFWS R3, F3
+	UCVTFD R4, F4
+	UCVTFS R5, F5
+	UCVTFWD R6, F6
+	UCVTFWS ZR, F7
+	RET
+`
+	file, err := Parse(ArchARM64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"integerfloatforms": {Name: "integerfloatforms", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"scvtf ${0:d}, ${1:x}", "scvtf ${0:s}, ${1:w}", "ucvtf ${0:d}, ${1:x}", "ucvtf ${0:s}, ${1:w}", "asm sideeffect"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 integer-to-float family IR omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{"darwin", "arm64-apple-macosx"},
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"integerfloatforms": {Name: "integerfloatforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "integer-float-forms.ll", "integer-float-forms.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64IntegerToScalarFloatFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"SCVTFS F0, F1",
+		"SCVTFD (R0), F1",
+		"SCVTFWS R0, R1",
+		"UCVTFS RSP, F0",
+		"UCVTFD R0, F1, F2",
+		"UCVTFWS.P R0, F1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT invalidintegerfloat(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"invalidintegerfloat": {Name: "invalidintegerfloat", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ASCVTFD optab family", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatBinaryFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// All eighteen opcodes share AFADDS's two C_FREG optab rows. Exercise both
+	// destructive two-register and explicit three-register forms for each one.
+	ops := []string{
+		"FADDS", "FADDD", "FSUBS", "FSUBD", "FMULS", "FMULD",
+		"FNMULS", "FNMULD", "FDIVS", "FDIVD",
+		"FMAXS", "FMAXD", "FMINS", "FMIND",
+		"FMAXNMS", "FMAXNMD", "FMINNMS", "FMINNMD",
+	}
+	var src strings.Builder
+	src.WriteString("TEXT scalarfloatbinaryforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range ops {
+		fmt.Fprintf(&src, "\t%s F0, F1\n", op)
+		fmt.Fprintf(&src, "\t%s F2, F3, F4\n", op)
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchARM64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"scalarfloatbinaryforms": {Name: "scalarfloatbinaryforms", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`asm sideeffect "fadd ${0:s}`, `asm sideeffect "fadd ${0:d}`, `asm sideeffect "fsub ${0:s}`,
+		`asm sideeffect "fmul ${0:s}`, `asm sideeffect "fnmul ${0:s}`, `asm sideeffect "fdiv ${0:s}`,
+		`asm sideeffect "fmax `, `asm sideeffect "fmin `, `asm sideeffect "fmaxnm `, `asm sideeffect "fminnm `,
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM64 scalar binary floating family IR omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		name   string
+		triple string
+	}{
+		{"darwin", "arm64-apple-macosx"},
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, src.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				TargetTriple: target.triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"scalarfloatbinaryforms": {Name: "scalarfloatbinaryforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target.triple, "scalar-float-binary-forms.ll", "scalar-float-binary-forms.o", ir)
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatBinaryFamilyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"FMULS F0",
+		"FMULD F0, F1, F2, F3",
+		"FMAXS R0, F1",
+		"FMIND F0, R1",
+		"FMAXNMS $1, F0",
+		"FMINNMD (R0), F1",
+		"FNMULS.P F0, F1",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT invalidfloatbinary(SB),NOSPLIT,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"invalidfloatbinary": {Name: "invalidfloatbinary", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's AFADDS optab family", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARM64ScalarFloatMoveFamilyCompleteGoAssemblerForms(t *testing.T) {
+	// Go 1.27 gives FMOVS and FMOVD the same complete shape family: floating
+	// constant, F<->F, R/ZR<->F, and F<->memory through stack, symbol,
+	// immediate-offset, register-offset, post-index, and pre-index addresses.
+	src := `
+TEXT scalarfloatmoveforms(SB),NOSPLIT,$0-32
+	FMOVS $(4.0), F0
+	FMOVS F0, F1
+	FMOVS R2, F2
+	FMOVS ZR, F3
+	FMOVS F2, R3
+	FMOVS F3, ZR
+	FMOVS (R4), F4
+	FMOVS F4, 4(R4)
+	FMOVS scalar(SB), F5
+	FMOVS F5, scalar(SB)
+	FMOVS input32+0(FP), F6
+	FMOVS F6, result32+16(FP)
+	FMOVS.P 4(R7), F7
+	FMOVS.P F7, 4(R7)
+	FMOVS.W 4(R8), F8
+	FMOVS.W F8, 4(R8)
+	FMOVS (R9)(R10), F9
+	FMOVS F9, (R9)(R10<<2)
+	FMOVD $(28.0), F10
+	FMOVD F10, F11
+	FMOVD R12, F12
+	FMOVD ZR, F13
+	FMOVD F12, R13
+	FMOVD F13, ZR
+	FMOVD (R14), F14
+	FMOVD F14, 8(R14)
+	FMOVD scalar(SB), F15
+	FMOVD F15, scalar(SB)
+	FMOVD input64+8(FP), F16
+	FMOVD F16, result64+24(FP)
+	FMOVD.P 8(R17), F17
+	FMOVD.P F17, 8(R17)
+	FMOVD.W 8(R18), F18
+	FMOVD.W F18, 8(R18)
+	FMOVD (R19)(R20), F19
+	FMOVD F19, (R19)(R20<<3)
+	RET
+`
+	file, err := Parse(ArchARM64, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		ResolveSym:   func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		Sigs: map[string]FuncSig{
+			"scalarfloatmoveforms": {
+				Name: "scalarfloatmoveforms",
+				Args: []LLVMType{LLVMType("float"), LLVMType("double")},
+				Ret:  LLVMType("{ float, double }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: LLVMType("float"), Index: 0, Field: -1},
+						{Offset: 8, Type: LLVMType("double"), Index: 1, Field: -1},
+					},
+					Results: []FrameSlot{
+						{Offset: 16, Type: LLVMType("float"), Index: 0, Field: -1},
+						{Offset: 24, Type: LLVMType("double"), Index: 1, Field: -1},
+					},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"load i32", "store i32", "load i64", "store i64", "bitcast float", "bitcast double"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("complete scalar float-move lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "scalar-float-moves.ll", "scalar-float-moves.o", ll)
+}
+
+func TestTranslateARM64ScalarFloatMoveFamilyRejectsFormsOutsideGoOptabs(t *testing.T) {
+	for _, instruction := range []string{
+		"FMOVS F0",
+		"FMOVD F0, F1, F2",
+		"FMOVS (R0), R1",
+		"FMOVD R0, (R1)",
+		"FMOVS $(1.0), R1",
+		"FMOVD.P F0, F1",
+		"FMOVS.Z F0, F1",
+		"FMOVS (R0)(R1<<3), F0",
+		"FMOVD F0, (R0)(R1<<2)",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			src := "TEXT invalidscalarfloatmove(SB),NOSPLIT,$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchARM64, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"invalidscalarfloatmove": {Name: "invalidscalarfloatmove", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q, which is absent from Go 1.27's FMOVS/FMOVD optabs", instruction)
+			}
+		})
+	}
+}
+
 func TestTranslateARM64BranchMinus(t *testing.T) {
 	src := `
 TEXT branchminus(SB),NOSPLIT,$0-0
diff --git a/arm64_nzcv_transport.go b/arm64_nzcv_transport.go
new file mode 100644
index 000000000..4ee81e5f0
--- /dev/null
+++ b/arm64_nzcv_transport.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Arm DDI0601 NZCV: only PSTATE.N/Z/C/V in bits 31:28 are transported.
+// The remaining read bits are zero and writes ignore them. This is the same
+// modeled flag bank used by integer/FP compares and conditional consumers,
+// never the incidental physical flags of LLVM's generated bookkeeping.
+const arm64NZCVEncoding = 0x5a10
+
+type arm64NZCVForm struct {
+	read bool
+	reg  Reg
+}
+
+func (form arm64NZCVForm) gpEffects() (reads, writes uint32) {
+	if form.reg == ZR {
+		return 0, 0
+	}
+	index, ok := arm64AtomicNumberedRegister(form.reg)
+	if !ok {
+		return 0, 0
+	}
+	if form.read {
+		return 0, 1 << uint(index)
+	}
+	return 1 << uint(index), 0
+}
+
+func parseARM64NZCVForm(op Op, ins Instr) (arm64NZCVForm, bool, error) {
+	if op != "MRS" && op != "MSR" {
+		return arm64NZCVForm{}, false, nil
+	}
+	matched := false
+	for _, argument := range ins.Args {
+		if argument.Kind == OpIdent && (strings.EqualFold(argument.Ident, "NZCV") || strings.EqualFold(argument.Ident, "S3_3_C4_C2_0")) {
+			// The physical assembler spelling is not a Go source alias. It
+			// must not bypass this source-state role via the generic fallback.
+			matched = true
+		}
+	}
+	if !matched {
+		return arm64NZCVForm{}, false, nil
+	}
+	bad := func() (arm64NZCVForm, bool, error) {
+		return arm64NZCVForm{}, true, fmt.Errorf("arm64 %s NZCV expects its system-register/GP pair without a suffix: %q", op, ins.Raw)
+	}
+	if ins.Op != op || len(ins.Args) != 2 {
+		return bad()
+	}
+	form := arm64NZCVForm{read: op == "MRS"}
+	system, data := ins.Args[0], ins.Args[1]
+	if !form.read {
+		system, data = data, system
+	}
+	if system.Kind != OpIdent || system.Ident != "NZCV" {
+		return bad()
+	}
+	if !form.read && data.Kind == OpImm && data.Imm == 0 && data.ImmRaw == "" && !data.ImmIsFloat {
+		// Go's C_ZCON is compatible with case36's C_ZREG, not the
+		// case37 PSTATE immediate encoding (which does not permit NZCV).
+		form.reg = ZR
+	} else if data.Kind == OpReg && isARM64GeneralOrZeroReg(data.Reg) {
+		form.reg = data.Reg
+	} else {
+		return bad()
+	}
+	return form, true, nil
+}
+
+func decodeARM64RawNZCV(word uint32) (arm64NZCVForm, bool) {
+	form, known := decodeARM64RawSystemRegister(word)
+	if !known || form.encoding != arm64NZCVEncoding {
+		return arm64NZCVForm{}, false
+	}
+	reg := ZR
+	if form.reg != 31 {
+		reg = Reg(fmt.Sprintf("R%d", form.reg))
+	}
+	return arm64NZCVForm{read: form.read, reg: reg}, true
+}
+
+func (c *arm64Ctx) lowerARM64NZCV(form arm64NZCVForm) error {
+	if !form.read {
+		value := "0"
+		if form.reg != ZR {
+			var err error
+			value, err = c.loadRegisterWidth(form.reg, 32)
+			if err != nil {
+				return err
+			}
+		}
+		c.storeARM64NativeCompareFlags(value)
+		return nil
+	}
+	if form.reg == ZR {
+		// An architectural NZCV read has no side effects. Discarding it
+		// neither consumes an undefined entry value nor defines flags.
+		return nil
+	}
+	if form.reg == "R18" || form.reg == "R28" {
+		return arm64GoABIContext("MRS NZCV numerical output has no platform/g machine-state contract for %s", form.reg)
+	}
+	if err := c.requireARM64Flags(arm64FlagAll, "MRS NZCV"); err != nil {
+		return err
+	}
+	value := "0"
+	for index, slot := range []string{c.flagsVSlot, c.flagsCSlot, c.flagsZSlot, c.flagsNSlot} {
+		c.recordMachineRegister(Reg(slot), 1, false)
+		flag, extended, shifted, merged := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", flag, slot)
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i64\n", extended, flag)
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, %d\n", shifted, extended, 28+index)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %s, %%%s\n", merged, value, shifted)
+		value = "%" + merged
+	}
+	return c.storeReg(form.reg, value)
+}
diff --git a/arm64_nzcv_transport_matrix_runtime_test.go b/arm64_nzcv_transport_matrix_runtime_test.go
new file mode 100644
index 000000000..e2442d90b
--- /dev/null
+++ b/arm64_nzcv_transport_matrix_runtime_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64NZCVTransportMatrix() (source, original, driver, declarations string) {
+	var assembly, goDeclarations, cDeclarations, goTable, cTable strings.Builder
+	forms := 0
+	for _, raw := range []bool{false, true} {
+		for reg := 0; reg < 32; reg++ {
+			if reg == 18 || reg == 28 || reg == 29 || reg == 30 {
+				continue // Platform/g/FP/LR syntax/effects do not grant a native pointer-entry role.
+			}
+			name := fmt.Sprintf("compareNZCV%d", forms)
+			forms++
+			fmt.Fprintf(&goDeclarations, "func %s(*uint64,*uint64)\n", name)
+			fmt.Fprintf(&cDeclarations, "extern void %s(uint64_t*,uint64_t*);\n", name)
+			fmt.Fprintf(&goTable, "{%s,%v},\n", name, reg == 31)
+			fmt.Fprintf(&cTable, "{%s,%d},\n", name, map[bool]int{true: 1, false: 0}[reg == 31])
+			// Keep each address, canary and temporary independent of the tested
+			// alias. This also covers every ordinary bank register, including
+			// R27, without relying on the Go assembler's implicit scratch value.
+			var safe []int
+			for _, candidate := range []int{19, 20, 21, 22, 23} {
+				if candidate != reg {
+					safe = append(safe, candidate)
+				}
+			}
+			in, out, tmp, canary := safe[0], safe[1], safe[2], safe[3]
+			fmt.Fprintf(&assembly, "TEXT %s(SB),516,$0-16\nMOVD in+0(FP),R%d\nMOVD out+8(FP),R%d\n", name, in, out)
+			fmt.Fprintf(&assembly, "MOVD $0x123456789abcdef0,R%d\n", canary)
+			if reg != 31 {
+				fmt.Fprintf(&assembly, "MOVD (R%d),R%d\n", in, reg)
+			}
+			fmt.Fprintln(&assembly, arm64NZCVInstruction(false, raw, reg))
+			fmt.Fprintln(&assembly, arm64NZCVInstruction(true, raw, reg))
+			// Reading into ZR discards only the GP result; NZCV is still live.
+			if reg == 31 {
+				fmt.Fprintf(&assembly, "MRS NZCV,R%d\nMOVD R%d,(R%d)\n", tmp, tmp, out)
+			} else {
+				fmt.Fprintf(&assembly, "MOVD R%d,(R%d)\n", reg, out)
+			}
+			for index, condition := range []string{"MI", "EQ", "CS", "VS"} {
+				fmt.Fprintf(&assembly, "CSET %s,R%d\nMOVD R%d,%d(R%d)\n", condition, tmp, tmp, 8*(index+1), out)
+			}
+			fmt.Fprintf(&assembly, "ADC ZR,ZR,R%d\nMOVD R%d,40(R%d)\n", tmp, tmp, out)
+			fmt.Fprintf(&assembly, "MOVD R%d,48(R%d)\n", canary, out)
+			assembly.WriteString("RET\n")
+		}
+	}
+	if forms != 56 {
+		panic("NZCV fixture must cover both spellings of all 28 admissible pointer-entry register roles")
+	}
+	original = `package main
+import "fmt"
+` + goDeclarations.String() + `
+func main() {
+ forms := []struct{ fn func(*uint64,*uint64); zero bool }{
+` + goTable.String() + `}
+ rows:=0
+ for form, f := range forms {
+  for flags:=uint64(0);flags<16;flags++ {
+   for _, padding:=range []uint64{0,0xffffffff0fffffff,0x1234567801234567,0x8000000000000000} {
+    input:=flags<<28|padding
+    var out [7]uint64
+    f.fn(&input,&out[0])
+    nibble:=flags
+    if f.zero { nibble=0 }
+    want:=[7]uint64{nibble<<28,nibble>>3&1,nibble>>2&1,nibble>>1&1,nibble&1,nibble>>1&1,0x123456789abcdef0}
+    if out!=want { panic(fmt.Sprintf("form=%d flags=%x pad=%x got=%x want=%x",form,flags,padding,out,want)) }
+    rows++
+   }
+  }
+ }
+ fmt.Printf("ARM64_COMPARE_ORIGINAL_PASS NZCV forms=%d rows=%d\n",len(forms),rows)
+}
+`
+	driver = `#include <stdint.h>
+#include <stdio.h>
+` + cDeclarations.String() + `
+int main(void) {
+ struct { void (*fn)(uint64_t*,uint64_t*); int zero; } forms[]={
+` + cTable.String() + `};
+ uint64_t pads[]={0,UINT64_C(0xffffffff0fffffff),UINT64_C(0x1234567801234567),UINT64_C(0x8000000000000000)};
+ for(unsigned form=0;form<sizeof(forms)/sizeof(forms[0]);form++) {
+  for(uint64_t flags=0;flags<16;flags++) {
+   for(unsigned p=0;p<4;p++) {
+    uint64_t input=(flags<<28)|pads[p], out[7]={0};
+    forms[form].fn(&input,out);
+    uint64_t n=forms[form].zero ? 0 : flags;
+    uint64_t want[]={n<<28,n>>3&1,n>>2&1,n>>1&1,n&1,n>>1&1,UINT64_C(0x123456789abcdef0)};
+    for(unsigned field=0;field<7;field++) {
+     if(out[field]!=want[field]) {
+      fprintf(stderr,"NZCV form=%u flags=%llx padding=%u field=%u got=%llx want=%llx\n",form,(unsigned long long)flags,p,field,(unsigned long long)out[field],(unsigned long long)want[field]);
+      return 1;
+     }
+    }
+   }
+  }
+ }
+ return 0;
+}
+`
+	return assembly.String(), original, driver, "package compare\n" + goDeclarations.String()
+}
+
+func arm64NZCVMatrixRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, original, driver, declarations := arm64NZCVTransportMatrix()
+	arm64ScalarCompareActualGo(t, source, original, goos, runner)
+	arm64NZCVRunConsumers(t, llc, compiler, "nzcv_matrix", triple, source, declarations, driver, runner)
+	t.Log("56 named/raw ordinary-GP/ZR alias forms × 16 NZCV states × 4 ignored-bit patterns = 3584 rows per executable")
+}
+
+func TestARM64NZCVCompleteStateNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU owner runs the same original-Go oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64NZCVMatrixRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_nzcv_transport_runtime_linux_test.go b/arm64_nzcv_transport_runtime_linux_test.go
new file mode 100644
index 000000000..e86ea9455
--- /dev/null
+++ b/arm64_nzcv_transport_runtime_linux_test.go
@@ -0,0 +1,20 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64NZCVTransport(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	compiler := []string{"aarch64-linux-gnu-gcc", "-no-pie"}
+	runner := []string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"}
+	arm64NZCVReadRuntime(t, "aarch64-unknown-linux-gnu", "linux", compiler, runner)
+	arm64NZCVMatrixRuntime(t, "aarch64-unknown-linux-gnu", "linux", compiler, runner)
+}
diff --git a/arm64_nzcv_transport_runtime_test.go b/arm64_nzcv_transport_runtime_test.go
new file mode 100644
index 000000000..971f63cdc
--- /dev/null
+++ b/arm64_nzcv_transport_runtime_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64NZCVConsumerIR struct{ name, ir string }
+
+// All consumers use signatures obtained from the same Go declarations as the
+// original executable. Dispose each module before moving to the next consumer.
+func arm64NZCVConsumerIRs(t *testing.T, source, declarations, triple string) []arm64NZCVConsumerIR {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "compare", declarations)
+	sizes := types.SizesFor("gc", "arm64")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+	text, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	public, err := TranslateModule(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	publicIR := public.String()
+	public.Dispose()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	direct := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBound := bound.Module.String()
+	bound.Module.Dispose()
+	return []arm64NZCVConsumerIR{
+		{"text", text}, {"public-module", publicIR},
+		{"in-context", direct}, {"typed-go", goBound},
+	}
+}
+
+func arm64NZCVRunConsumers(t *testing.T, llc string, compiler []string, name, triple, source, declarations, driver string, runner []string) {
+	t.Helper()
+	for _, consumer := range arm64NZCVConsumerIRs(t, source, declarations, triple) {
+		t.Run(consumer.name, func(t *testing.T) {
+			for _, variant := range []struct{ name, ir string }{{"none", consumer.ir}, {"O2", armFloatEffectOptimizedIR(t, consumer.ir)}} {
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, compiler, name, triple, variant.ir, driver, runner, level)
+					})
+				}
+			}
+		})
+	}
+}
+
+// Independent first-party counterexample: integer CMP sets source NZCV=0110.
+// MRS must read that source state, not whichever flags LLVM's own bookkeeping
+// last left in the physical processor.
+const arm64NZCVReadSource = `TEXT compareNZCV(SB),4,$0-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+MOVD (R0),R2
+CMP R2,R2
+MRS NZCV,R3
+MOVD R3,(R1)
+RET
+`
+
+func arm64NZCVReadRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	original := `package main
+import "fmt"
+func compareNZCV(*uint64,*uint64)
+func main() {
+ for _, input := range []uint64{0,1,0x8000000000000000,0xffffffffffffffff} {
+  var output uint64
+  compareNZCV(&input,&output)
+  if output != 0x60000000 { panic(fmt.Sprintf("original NZCV=%x",output)) }
+ }
+ fmt.Println("ARM64_COMPARE_ORIGINAL_PASS NZCV=0x60000000")
+}
+`
+	arm64ScalarCompareActualGo(t, arm64NZCVReadSource, original, goos, runner)
+	driver := `#include <stdint.h>
+#include <stdio.h>
+extern void compareNZCV(uint64_t*,uint64_t*);
+int main(void) {
+ uint64_t inputs[]={0,1,UINT64_C(0x8000000000000000),UINT64_MAX};
+ for(unsigned i=0;i<4;i++) {
+  uint64_t output=0;
+  compareNZCV(&inputs[i],&output);
+  if(output!=0x60000000) {
+   fprintf(stderr,"source NZCV input=%u got=%llx want=60000000\n",i,(unsigned long long)output);
+   return 1;
+  }
+ }
+ return 0;
+}
+`
+	declarations := "package compare\nfunc compareNZCV(*uint64,*uint64)\n"
+	arm64NZCVRunConsumers(t, llc, compiler, "nzcv_read", triple, arm64NZCVReadSource, declarations, driver, runner)
+}
+
+func TestARM64NZCVReadOriginalGoNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU owner runs the same original-Go oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64NZCVReadRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_nzcv_transport_test.go b/arm64_nzcv_transport_test.go
new file mode 100644
index 000000000..5b8aa680d
--- /dev/null
+++ b/arm64_nzcv_transport_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func arm64NZCVRegisterName(reg int) string {
+	switch reg {
+	case 18:
+		return "R18_PLATFORM"
+	case 28:
+		return "g"
+	case 31:
+		return "ZR"
+	default:
+		return fmt.Sprintf("R%d", reg)
+	}
+}
+
+func arm64NZCVInstruction(read, raw bool, reg int) string {
+	if raw {
+		word := uint32(0xd51b4200)
+		if read {
+			word = 0xd53b4200
+		}
+		return fmt.Sprintf("WORD $0x%08x", word|uint32(reg))
+	}
+	if read {
+		return "MRS NZCV," + arm64NZCVRegisterName(reg)
+	}
+	return "MSR " + arm64NZCVRegisterName(reg) + ",NZCV"
+}
+
+func TestARM64NZCVCompleteGoEncodingAndEffects(t *testing.T) {
+	// Go asm7 rows 35/36 and SysRegEnc's read/write NZCV entry are
+	// independently witnessed by original objects, including platform/g/ZR.
+	var source strings.Builder
+	for direction := 0; direction < 2; direction++ {
+		for reg := 0; reg < 32; reg++ {
+			fmt.Fprintf(&source, "TEXT nzcv%d_%d(SB),516,$0-0\n%s\nRET\n",
+				direction, reg, arm64NZCVInstruction(direction == 1, false, reg))
+		}
+	}
+	source.WriteString("TEXT zero(SB),516,$0-0\nMSR $0,NZCV\nRET\n")
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "nzcv_arm64.s"), filepath.Join(directory, "original.o")
+	if err := os.WriteFile(input, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", object, input)
+	if err != nil {
+		t.Fatalf("original Go NZCV grammar: %v\n%s", err, listing)
+	}
+	disassembly, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "objdump", object)
+	if err != nil {
+		t.Fatalf("original Go NZCV object: %v\n%s", err, disassembly)
+	}
+	bodies, err := arm64ScratchObjectBodies(disassembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for direction := 0; direction < 2; direction++ {
+		for reg := 0; reg < 32; reg++ {
+			name := fmt.Sprintf("nzcv%d_%d", direction, reg)
+			body, exists := bodies[name]
+			word := uint32(0xd51b4200) | uint32(direction)<<21 | uint32(reg)
+			if !exists || len(body.code) < 2 || body.code[0] != word || body.code[1] != 0xd65f03c0 || len(body.relocs) != 0 {
+				t.Fatalf("original Go exact %s encoding missing: %+v", name, body)
+			}
+			form, valid := decodeARM64RawNZCV(word)
+			if !valid || form.read != (direction == 1) {
+				t.Fatalf("typed form mismatch: %08x %+v", word, form)
+			}
+			var code [4]byte
+			binary.LittleEndian.PutUint32(code[:], word)
+			instruction, err := arm64asm.Decode(code[:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			var reads, writes uint32
+			if reg != 31 {
+				if direction == 1 {
+					writes = 1 << uint(reg)
+				} else {
+					reads = 1 << uint(reg)
+				}
+			}
+			if r, w := form.gpEffects(); r != reads || w != writes {
+				t.Fatalf("typed GP effects %s: read=%x write=%x", name, r, w)
+			}
+			if got, valid := arm64RawContinuationEffectsForWord(word); !valid || got != (arm64RawContinuationEffects{gpReads: reads, gpWrites: writes}) {
+				t.Fatalf("raw continuation invented an address/store permission: %s %+v %v", name, got, valid)
+			}
+			if got, valid := arm64RawPoolGPWrites(word); !valid || got != writes {
+				t.Fatalf("raw pool GP effects %s: %x %v", name, got, valid)
+			}
+			if arm64RawPoolInstructionPreservesNZCV(instruction) != (direction == 1) {
+				t.Fatalf("raw pool transferred NZCV incorrectly preserves prior comparison: %s", name)
+			}
+			scratch, valid := arm64ScratchNativeEffect(instruction)
+			if !valid || scratch.reads != (reads&(1<<27) != 0) || scratch.defines != (writes&(1<<27) != 0) || scratch.call {
+				t.Fatalf("scratch effect %s: %+v %v", name, scratch, valid)
+			}
+			effect, valid := arm64ScratchNativeInputEffect(instruction, false)
+			if reg == 30 || direction == 1 && (reg == 18 || reg == 28) {
+				if valid {
+					t.Fatal("NZCV transport supplied a new LR or platform/g output permission")
+				}
+				continue
+			}
+			want := arm64ScratchInputEffect{reads: uint64(reads), writes: uint64(writes)}
+			if direction == 0 {
+				want.writes |= 15 << 31
+			} else if reg != 31 {
+				want.reads |= 15 << 31
+			}
+			if !valid || effect != want {
+				t.Fatalf("whole-input effect %s: %+v %v, want %+v", name, effect, valid, want)
+			}
+		}
+	}
+	if body := bodies["zero"]; len(body.code) < 2 || body.code[0] != 0xd51b421f {
+		t.Fatal("Go $0 must be the ZR form, not immediate PSTATE grammar")
+	}
+	for _, word := range []uint32{0xd53b4220, 0xd51b4220, 0xd53b4400, 0xd51b4400, 0xd53bd040, 0xd51bd040, 0xd5000000} {
+		if _, valid := decodeARM64RawNZCV(word); valid {
+			t.Fatalf("neighbor system register acquired NZCV authority: %08x", word)
+		}
+	}
+	t.Log("65 original Go forms: all 32 Xt fields in both directions plus exact $0 alias")
+}
+
+func TestARM64NZCVRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"MRS NZCV,RSP", "MRS NZCV,F0", "MRS NZCV,V0", "MRS NZCV,(R0)",
+		"MRS NZCV,$0", "MRS NZCV", "MRS R0,NZCV", "MRS.W NZCV,R0", "MRS.P NZCV,R0",
+		"MSR RSP,NZCV", "MSR F0,NZCV", "MSR V0,NZCV", "MSR (R0),NZCV",
+		"MSR $1,NZCV", "MSR $-1,NZCV", "MSR $16,NZCV", "MSR NZCV,R0", "MSR.W R0,NZCV",
+		"MRS S3_3_C4_C2_0,R0", "MSR R0,S3_3_C4_C2_0",
+		"MRS NZCV,R31", "MSR R31,NZCV", "MRS NZCV,R0,R1", "MSR R0,NZCV,R1",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT bad(SB),516,$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}})
+			if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("invalid format must be rejected as syntax, not accepted or Context: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64NZCVTypedControlFlowAndBoundary(t *testing.T) {
+	for _, fixture := range []struct {
+		name, body string
+		closed     bool
+	}{
+		{"write-read", "MSR R0,NZCV\nMRS NZCV,R0", true},
+		{"zero-immediate", "MSR $0,NZCV\nMRS NZCV,R0", true},
+		{"raw-write-read", "WORD $0xd51b4200\nWORD $0xd53b4200", true},
+		{"compare-read", "CMP R0,R0\nMRS NZCV,R0", true},
+		{"discarded-read", "MRS NZCV,ZR", true},
+		{"discarded-raw-read", "WORD $0xd53b421f", true},
+		{"write-consumers", "MSR R0,NZCV\nCSET CS,R1\nADC R1,R0", true},
+		{"backwards", "B set\nread:\nMRS NZCV,R0\nRET\nset:\nMSR R0,NZCV\nB read", true},
+		{"both-branches", "CBZ R0,zero\nMSR R0,NZCV\nB read\nzero:\nMSR ZR,NZCV\nread:\nMRS NZCV,R0", true},
+		{"loop", "MSR R0,NZCV\nloop:\nMRS NZCV,R1\nCBNZ R0,loop\nMOVD R1,R0", true},
+		{"missing-entry", "MRS NZCV,R0", false},
+		{"missing-entry-raw", "WORD $0xd53b4200", false},
+		{"missing-gp", "MSR R9,NZCV\nMRS NZCV,R0", false},
+		{"missing-gp-raw", "WORD $0xd51b4209\nMRS NZCV,R0", false},
+		{"missing-platform-input", "MSR R18_PLATFORM,NZCV\nMRS NZCV,R0", false},
+		{"missing-g-input", "MSR g,NZCV\nMRS NZCV,R0", false},
+		{"missing-fp-input", "MSR R29,NZCV\nMRS NZCV,R0", false},
+		{"platform-output", "MSR R0,NZCV\nMRS NZCV,R18_PLATFORM", false},
+		{"g-output", "MSR R0,NZCV\nMRS NZCV,g", false},
+		{"platform-output-raw", "MSR R0,NZCV\nWORD $0xd53b4212", false},
+		{"g-output-raw", "MSR R0,NZCV\nWORD $0xd53b421c", false},
+		{"lr-output", "MSR R0,NZCV\nMRS NZCV,R30", false},
+		{"lr-output-raw", "MSR R0,NZCV\nWORD $0xd53b421e", false},
+		{"partial-join", "CBZ R0,read\nMSR R0,NZCV\nread:\nMRS NZCV,R0", false},
+		{"backedge-only", "loop:\nMRS NZCV,R1\nMSR R0,NZCV\nCBNZ R0,loop\nMOVD R1,R0", false},
+		{"discard-does-not-define", "MRS NZCV,ZR\nMRS NZCV,R0", false},
+		{"fp-control-between", "MSR R0,NZCV\nMRS FPCR,R1\nMRS NZCV,R0", true},
+		{"fp-control-raw-between", "MSR R0,NZCV\nWORD $0xd53b4401\nMRS NZCV,R0", true},
+		{"opaque-between", "MSR R0,NZCV\nMRS TPIDR_EL0,R1\nMRS NZCV,R0", false},
+		{"opaque-raw-between", "MSR R0,NZCV\nWORD $0xd53bd041\nMRS NZCV,R0", false},
+		{"closed-local-ret-preserves", "MSR R0,NZCV\nBL helper\nMRS NZCV,R0\nRET\nhelper:\nRET", true},
+		{"local-ret-does-not-supply-entry", "BL helper\nMRS NZCV,R0\nRET\nhelper:\nRET", false},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			source := arm64TypedNativeSource(fixture.body)
+			arm64TypedNativeGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				opt := arm64TypedNativeOptions(t, target)
+				_, textErr := Translate(file, opt)
+				public, publicErr := TranslateModule(file, opt)
+				if publicErr == nil {
+					public.Dispose()
+				}
+				ctx := llvm.NewContext()
+				module, moduleErr := TranslateModuleInContext(ctx, file, opt)
+				if moduleErr == nil {
+					module.Dispose()
+				}
+				pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\nfunc NativeEffects(uint64) uint64\n")
+				bound, goErr := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+				})
+				if bound != nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				for index, err := range []error{textErr, publicErr, moduleErr, goErr} {
+					if fixture.closed && err != nil || !fixture.closed && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s API%d closed=%v: %v", target, index, fixture.closed, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestARM64NZCVTypedAllAPIsAndObjects(t *testing.T) {
+	var body strings.Builder
+	for _, raw := range []bool{false, true} {
+		for reg := 0; reg < 32; reg++ {
+			if reg == 18 || reg == 28 || reg == 30 {
+				continue // These machine roles need separate entry/return contracts.
+			}
+			if reg != 31 {
+				fmt.Fprintf(&body, "MOVD $0xa0000000,R%d\n", reg)
+			}
+			fmt.Fprintln(&body, arm64NZCVInstruction(false, raw, reg))
+			fmt.Fprintln(&body, arm64NZCVInstruction(true, raw, reg))
+		}
+	}
+	body.WriteString("MRS NZCV,R0\n")
+	source := arm64TypedNativeSource(body.String())
+	arm64TypedNativeGoObject(t, source)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			opt := arm64TypedNativeOptions(t, target)
+			text, err := Translate(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			public, err := TranslateModule(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			publicIR := public.String()
+			public.Dispose()
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			moduleIR := module.String()
+			module.Dispose()
+			pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\nfunc NativeEffects(uint64) uint64\n")
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			goIR := bound.Module.String()
+			bound.Module.Dispose()
+			for api, ir := range []string{text, publicIR, moduleIR, goIR} {
+				if strings.Contains(ir, "mrs ") || strings.Contains(ir, "msr ") {
+					t.Fatal("NZCV transport must not observe incidental backend physical flags")
+				}
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("nzcv%d.ll", api), "nzcv.o", ir)
+			}
+		})
+	}
+}
diff --git a/arm64_official_directive_test.go b/arm64_official_directive_test.go
new file mode 100644
index 000000000..748fed058
--- /dev/null
+++ b/arm64_official_directive_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARM64OfficialNoopAndEnd(t *testing.T) {
+	const source = `TEXT officialNoopEnd(SB),$0-0
+	NOOP
+	RET
+	END
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"officialNoopEnd": {Name: "officialNoopEnd", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ll, "hint #0") {
+		t.Fatalf("ARM64 NOOP did not retain its architectural hint encoding:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "arm64-official-noop-end.ll", "arm64-official-noop-end.o", ll)
+}
diff --git a/arm64_opaque_preservation_boundary_test.go b/arm64_opaque_preservation_boundary_test.go
new file mode 100644
index 000000000..014b71af0
--- /dev/null
+++ b/arm64_opaque_preservation_boundary_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64OpaquePreservationUnclosedEffectBoundaries(t *testing.T) {
+	base := arm64OpaquePreservationCases()[3] // Full pair offsets are not a new permission.
+	pkg := mustGoPackage(t, "test/opaque", "package opaque\nfunc saveAlias(*uint64,*uint64)\nfunc Unknown()\n")
+	for _, tc := range []struct {
+		name, old, replacement string
+	}{
+		{"partial_save", "STP (R22,R21),0(RSP)", "MOVW R22,0(RSP)\nMOVD R21,8(RSP)"},
+		{"partial_cell_write", "MOVD $77,R22", "MOVD $0,R4\nMOVW R4,0(RSP)\nMOVD $77,R22"},
+		{"partial_restore", "LDP 0(RSP),(R22,R21)", "MOVWU 0(RSP),R22\nMOVD 8(RSP),R21"},
+		{"swapped_restore", "LDP 0(RSP),(R22,R21)", "LDP 0(RSP),(R21,R22)"},
+		{"missing_restore_branch", "LDP 0(RSP),(R22,R21)", "CBZ R4,skip_restore\nLDP 0(RSP),(R22,R21)\nskip_restore:"},
+		{"numeric_use", "MOVD $77,R22", "MOVD R22,(R1)\nMOVD $77,R22"},
+		{"address_use", "MOVD $77,R22", "MOVD (R22),R4\nMOVD $77,R22"},
+		{"source_pointer_escape", "MOVD $77,R22", "MOVD RSP,R4\nMOVD R4,(R1)\nMOVD $77,R22"},
+		{"unknown_call", "MOVD $77,R22", "CALL ·Unknown(SB)\nMOVD $77,R22"},
+		{"restore_cell_offset", "LDP 0(RSP),(R22,R21)", "LDP 8(RSP),(R22,R21)"},
+		{"restore_omitted", "LDP 0(RSP),(R22,R21)", "MOVD $1,R22\nMOVD $2,R21"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64OpaquePreservationSource(base, arm64OpaqueObservationBody(false))
+			if strings.Count(source, tc.old) != 1 {
+				t.Fatal("negative mutation does not uniquely match the fresh original source")
+			}
+			source = strings.Replace(source, tc.old, tc.replacement, 1)
+			arm64OpaqueOriginalObject(t, source)
+			for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				ctx := llvm.NewContext()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: triple,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if tr != nil && !tr.Module.IsNil() {
+					tr.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s: unclosed opaque identity must remain Context: %v", triple, err)
+				}
+				t.Logf("UNGRANTED_BOUNDARY target=%s error=%v", triple, err)
+			}
+		})
+	}
+	t.Log("no new identity checker is present: these observations retain current Context, often at the first save; they do not certify a future checker rejects later effects independently")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64OpaquePreservationDefinedControl(t *testing.T) {
+	llc, nativeTriple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg := mustGoPackage(t, "test/opaque", "package opaque\nfunc saveAlias(*byte,*byte)\n")
+	for _, tc := range arm64OpaquePreservationCases() {
+		if strings.HasSuffix(tc.name, "_branch") {
+			continue // Its separate original caller/CFG observation executes above.
+		}
+		t.Run(tc.name, func(t *testing.T) {
+			prep := "MOVD (R0),R22\nMOVD 8(R0),R21\nMOVD 16(R0),R20\nMOVD 24(R0),R19\n"
+			body := "MOVD $77,R22\nMOVD $88,R21\nMOVD $99,R20\nMOVD $111,R19\n"
+			source := arm64OpaquePreservationSource(tc, body)
+			source = strings.Replace(source, tc.save, prep+tc.save, 1)
+			source = strings.Replace(source, "RET\n", "MOVD R22,(R1)\nMOVD R21,8(R1)\nMOVD R20,16(R1)\nMOVD R19,24(R1)\nRET\n", 1)
+			arm64OpaqueOriginalObject(t, source)
+			main := `package main
+func saveAlias(*byte,*byte)
+func main() {
+  for offset:=1;offset<=5;offset++ {
+    for seed:=0;seed<31;seed++ {
+      var input [64]byte
+      var output [80]byte
+      for i:=range input { input[i]=byte(i*31+seed*17) }
+      for i:=range output { output[i]=byte(i*13+0x53) }
+      beforeIn,beforeOut:=input,output
+      saveAlias(&input[offset],&output[offset+9])
+      for i:=range input {
+        if input[i]!=beforeIn[i] { panic("original input byte changed") }
+      }
+      for i:=range output {
+        want:=beforeOut[i]
+        if i>=offset+9 && i<offset+41 { want=beforeIn[offset+i-(offset+9)] }
+        if output[i]!=want { panic("original full output/canary bytes differ") }
+      }
+    }
+  }
+}
+`
+			arm64OpaqueRunOriginalGo(t, source, main, len(runner) != 0)
+			for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				ctx := llvm.NewContext()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: triple,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				defer ctx.Dispose()
+				if tr != nil && !tr.Module.IsNil() {
+					defer tr.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir := tr.Module.String()
+				compileLLVMToObject(t, llc, triple, "opaque-defined-control.ll", "opaque-defined-control.o", ir)
+				if triple == nativeTriple {
+					c := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void saveAlias(const unsigned char *, unsigned char *);
+int main(void) {
+  for(int offset=1;offset<=5;offset++) {
+    for(int seed=0;seed<31;seed++) {
+      unsigned char input[64], output[80], beforeIn[64], beforeOut[80];
+      for(int i=0;i<64;i++) input[i]=(unsigned char)(i*31+seed*17);
+      for(int i=0;i<80;i++) output[i]=(unsigned char)(i*13+0x53);
+      memcpy(beforeIn,input,64); memcpy(beforeOut,output,80);
+      saveAlias(input+offset,output+offset+9);
+      if(memcmp(input,beforeIn,64)) return 1;
+      for(int i=0;i<80;i++) {
+        unsigned char want=beforeOut[i];
+        if(i>=offset+9 && i<offset+41) want=beforeIn[offset+i-(offset+9)];
+        if(output[i]!=want) { fprintf(stderr,"byte %d offset %d seed %d\n",i,offset,seed); return 2; }
+      }
+    }
+  }
+  return 0;
+}
+`
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("opaque-defined-%s", tc.name), nativeTriple, ir, c, runner)
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_opaque_preservation_observation_test.go b/arm64_opaque_preservation_observation_test.go
new file mode 100644
index 000000000..c3ff60ae2
--- /dev/null
+++ b/arm64_opaque_preservation_observation_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64OpaquePreservationCase struct {
+	name, save, restore string
+}
+
+func arm64OpaquePreservationCases() []arm64OpaquePreservationCase {
+	return []arm64OpaquePreservationCase{
+		{"scalar_offset", "SUB $32,RSP\nMOVD R22,0(RSP)\nMOVD R21,8(RSP)\nMOVD R20,16(RSP)\nMOVD R19,24(RSP)\n", "MOVD 24(RSP),R19\nMOVD 16(RSP),R20\nMOVD 8(RSP),R21\nMOVD 0(RSP),R22\nADD $32,RSP\n"},
+		{"scalar_pre_post", "MOVD.W R22,-32(RSP)\nMOVD R21,8(RSP)\nMOVD R20,16(RSP)\nMOVD R19,24(RSP)\n", "MOVD 24(RSP),R19\nMOVD 16(RSP),R20\nMOVD 8(RSP),R21\nMOVD.P 32(RSP),R22\n"},
+		{"scalar_post_pre", "SUB $64,RSP\nMOVD.P R22,32(RSP)\nMOVD R21,-24(RSP)\nMOVD R20,-16(RSP)\nMOVD R19,-8(RSP)\n", "MOVD -8(RSP),R19\nMOVD -16(RSP),R20\nMOVD -24(RSP),R21\nMOVD.W -32(RSP),R22\nADD $64,RSP\n"},
+		{"pair_offset", "SUB $32,RSP\nSTP (R22,R21),0(RSP)\nSTP (R20,R19),16(RSP)\n", "LDP 16(RSP),(R20,R19)\nLDP 0(RSP),(R22,R21)\nADD $32,RSP\n"},
+		{"pair_pre_post", "STP.W (R22,R21),-32(RSP)\nSTP (R20,R19),16(RSP)\n", "LDP 16(RSP),(R20,R19)\nLDP.P 32(RSP),(R22,R21)\n"},
+		{"pair_post_pre", "SUB $64,RSP\nSTP.P (R22,R21),32(RSP)\nSTP (R20,R19),-16(RSP)\n", "LDP -16(RSP),(R20,R19)\nLDP.W -32(RSP),(R22,R21)\nADD $64,RSP\n"},
+		{"raw_pair_pre_post", "WORD $0xa9be57f6\nWORD $0xa9014ff4\n", "WORD $0xa9414ff4\nWORD $0xa8c257f6\n"},
+		{"raw_pair_pre_post_branch", "WORD $0xa9be57f6\nWORD $0xa9014ff4\n", "WORD $0xa9414ff4\nWORD $0xa8c257f6\n"},
+	}
+}
+
+func arm64OpaquePreservationSource(tc arm64OpaquePreservationCase, body string) string {
+	return "TEXT ·saveAlias(SB),516,$0-16\nMOVD alias+0(FP),R0\nMOVD out+8(FP),R1\n" + tc.save + body + tc.restore + "RET\n"
+}
+
+func arm64OpaqueObservationBody(branch bool) string {
+	body := "MOVD $77,R22\nMOVD $88,R21\nMOVD $0,R20\nMOVD $99,R19\nMOVD (R0),R4\n"
+	if branch {
+		body += "CBZ R4,zero\nMOVD R4,(R1)\nB remaining\nzero:\nMOVD R4,(R1)\nremaining:\n"
+	} else {
+		body += "MOVD R4,(R1)\n"
+	}
+	return body + "MOVD 8(R0),R4\nMOVD R4,8(R1)\nMOVD 16(R0),R4\nMOVD R4,16(R1)\nMOVD 24(R0),R4\nMOVD R4,24(R1)\n"
+}
+
+func arm64OpaqueRunOriginalGo(t *testing.T, source, main string, cross bool) {
+	t.Helper()
+	formatted, err := format.Source([]byte(main))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("ACTUAL_FIRST_PARTY_MODULE go=1.20 sdk=%s main_sha256=%x asm_sha256=%x\nMAIN:\n%s", runtime.Version(), sha256.Sum256(formatted), sha256.Sum256([]byte(source)), formatted)
+	runARM64LocalRegisterGoOracle(t, source, string(formatted), cross)
+}
+
+// This helper invokes the selected SDK on both historical and current lanes.
+// It never borrows the current-table-only oracle's quiet old-SDK return.
+func arm64OpaqueOriginalObject(t *testing.T, source string) string {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err = filepath.EvalSymlinks(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := "go"
+	if runtime.GOOS == "windows" {
+		want += ".exe"
+	}
+	actual := filepath.Join(runtime.GOROOT(), "bin", want)
+	actual, err = filepath.EvalSymlinks(actual)
+	if err != nil || driver != actual {
+		t.Fatalf("selected driver does not match actual SDK: %s != %s: %v", driver, actual, err)
+	}
+	driverBytes, err := os.ReadFile(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-S", "-p", "main", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=", "GOOS=linux", "GOARCH=arm64")
+	output, commandErr := runtimeOracleCombinedOutput(ctx, command)
+	if err := goAssemblerOracleOutcome(asm, object, output, commandErr, ctx.Err(), true, "arm64"); err != nil {
+		t.Fatalf("%v\n%s\n%s", err, output, source)
+	}
+	objectBytes, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("ACTUAL_OBJECT sdk=%s driver=%s driver_sha256=%x source_sha256=%x object_sha256=%x bytes=%d\nSOURCE:\n%s\nLISTING:\n%s", runtime.Version(), driver, sha256.Sum256(driverBytes), sha256.Sum256([]byte(source)), sha256.Sum256(objectBytes), len(objectBytes), source, output)
+	return string(output)
+}
+
+func TestARM64OpaquePreservationOriginalObjectsAndCurrentContext(t *testing.T) {
+	pkg := mustGoPackage(t, "test/opaque", "package opaque\nfunc saveAlias(*uint64,*uint64)\n")
+	for _, tc := range arm64OpaquePreservationCases() {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64OpaquePreservationSource(tc, arm64OpaqueObservationBody(strings.HasSuffix(tc.name, "_branch")))
+			listing := arm64OpaqueOriginalObject(t, source)
+			if !strings.Contains(listing, "NOFRAME") || strings.Contains(listing, "MOVD.W\tR30,") {
+				t.Fatal("actual original object unexpectedly synthesized a native frame")
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatalf("complete original source parse: %v", err)
+			}
+			transport := &arm64PrivateFrameTransport{entry: arm64RawZeroFrameSig()}
+			t.Logf("SOURCE_ONLY_FRESH_FRAME_PROOF=%t (not a native caller no-alias certificate)", arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], transport))
+			for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				ctx := llvm.NewContext()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if tr != nil && !tr.Module.IsNil() {
+					tr.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "R22 read") {
+					t.Fatalf("%s: retain the actual unbound R22 source rejection: %v", target, err)
+				}
+				t.Logf("CURRENT_CONTEXT target=%s error=%v", target, err)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64OpaqueSaveSlotCallerObservation(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range arm64OpaquePreservationCases() {
+		t.Run(tc.name, func(t *testing.T) {
+			target := arm64OpaquePreservationSource(tc, arm64OpaqueObservationBody(strings.HasSuffix(tc.name, "_branch")))
+			// The caller knows its own actual SP. The leaf callee allocates
+			// exactly 32 or 64 bytes below that same SP. No guessed heap length,
+			// garbage pointer, invalid continuation or third-party code is used.
+			distance := 32
+			if strings.HasSuffix(tc.name, "post_pre") {
+				distance = 64
+			}
+			caller := fmt.Sprintf(`TEXT ·observe(SB),4,$160-16
+MOVD pattern+0(FP),R22
+ADD $3,R22,R21
+ADD $5,R22,R20
+ADD $7,R22,R19
+MOVD out+8(FP),R6
+SUB $%d,RSP,R0
+MOVD R0,8(RSP)
+MOVD R6,16(RSP)
+CALL ·saveAlias(SB)
+MOVD out+8(FP),R6
+MOVD R22,32(R6)
+MOVD R21,40(R6)
+MOVD R20,48(R6)
+MOVD R19,56(R6)
+RET
+`, distance)
+			arm64OpaqueOriginalObject(t, caller+target)
+			main := `package main
+func observe(uint64,*[8]uint64)
+func saveAlias(*uint64,*uint64)
+func main() {
+  for _, pattern := range []uint64{0,1,0x1122334455667788,0x8000000000000000,^uint64(0)} {
+    out := [10]uint64{0xa1a2a3a4a5a6a7a8,0,0,0,0,0,0,0,0,0xb1b2b3b4b5b6b7b8}
+    observe(pattern,(*[8]uint64)(unsafe.Pointer(&out[1])))
+    for i:=1;i<=8;i++ {
+      want := pattern + []uint64{0,3,5,7}[(i-1)&3]
+      if out[i]!=want { println(i,out[i],want); panic("original save bytes or opaque restore differ") }
+    }
+    if out[0]!=0xa1a2a3a4a5a6a7a8 || out[9]!=0xb1b2b3b4b5b6b7b8 {
+      panic("observable output memory canary mismatch")
+    }
+  }
+}
+`
+			main = strings.Replace(main, "package main\n", "package main\nimport \"unsafe\"\n", 1)
+			arm64OpaqueRunOriginalGo(t, caller+target, main, len(runner) != 0)
+			t.Log("ACTUAL_NATIVE_OBSERVATION: original caller supplies a pointer to the future callee save cell; saved incoming R22 bytes are observable")
+		})
+	}
+}
diff --git a/arm64_pcalign.go b/arm64_pcalign.go
new file mode 100644
index 000000000..6eea54e02
--- /dev/null
+++ b/arm64_pcalign.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import "fmt"
+
+// Go's obj.AlignmentPaddingLength defines both spellings. Alignment changes
+// native layout, but emits only NOPs, with no register, memory or flag effects.
+// Recognizing this grammar does not prove native PC offsets or code identity.
+func arm64PCAlignment(ins Instr) (alignment int64, handled bool, err error) {
+	base := arm64ControlOp(ins)
+	count := 1
+	switch base {
+	case "PCALIGN":
+	case "PCALIGNMAX":
+		count = 2
+	default:
+		return 0, false, nil
+	}
+	invalid := func() (int64, bool, error) {
+		return 0, true, fmt.Errorf("invalid ARM64 %s directive operands: %q", base, ins.Raw)
+	}
+	if ins.Op != base || len(ins.Args) != count {
+		return invalid()
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpImm || arg.ImmRaw != "" || arg.ImmIsFloat {
+			return invalid()
+		}
+	}
+	alignment = ins.Args[0].Imm
+	if alignment < 8 || alignment > 2048 || alignment&(alignment-1) != 0 {
+		return invalid()
+	}
+	if count == 2 && (ins.Args[1].Imm < 0 || ins.Args[1].Imm >= alignment) {
+		return invalid()
+	}
+	return alignment, true, nil
+}
+
+func arm64FunctionPCAlignment(fn Func) (int64, error) {
+	var alignment int64
+	for _, ins := range fn.Instrs {
+		value, _, err := arm64PCAlignment(ins)
+		if err != nil {
+			return 0, err
+		}
+		if value > alignment {
+			alignment = value
+		}
+	}
+	return alignment, nil
+}
diff --git a/arm64_pcalign_go127_test.go b/arm64_pcalign_go127_test.go
new file mode 100644
index 000000000..a4e4ab1ff
--- /dev/null
+++ b/arm64_pcalign_go127_test.go
@@ -0,0 +1,15 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+// PCALIGNMAX is newer than the oldest supported Go toolchain. Historical
+// lanes still test the translator's complete grammar in the untagged tests.
+func TestARM64PCAlignCurrentGoCompleteFormats(t *testing.T) {
+	for _, row := range arm64PCAlignTestForms() {
+		t.Run(row, func(t *testing.T) {
+			requireARM64GoABIInternalObject(t, arm64PCAlignTailSource(row))
+		})
+	}
+}
diff --git a/arm64_pcalign_test.go b/arm64_pcalign_test.go
new file mode 100644
index 000000000..3c221beb4
--- /dev/null
+++ b/arm64_pcalign_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func arm64PCAlignTestForms() []string {
+	var forms []string
+	for alignment := 8; alignment <= 2048; alignment *= 2 {
+		forms = append(forms, fmt.Sprintf("PCALIGN $%d", alignment))
+		for _, limit := range []int{0, alignment - 1} {
+			forms = append(forms, fmt.Sprintf("PCALIGNMAX $%d,$%d", alignment, limit))
+		}
+	}
+	return forms
+}
+
+func arm64PCAlignTailSource(row string) string {
+	source := arm64ClosedTailPointerSource("B")
+	source = strings.Replace(source, "B readbody", row+"\nB readbody", 1)
+	return strings.Replace(source, "MOVD (R0),R0", row+"\nMOVD (R0),R0", 1)
+}
+
+func TestARM64PCAlignClosedTailObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, row := range arm64PCAlignTestForms() {
+		for _, target := range []string{
+			"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-unknown-freebsd",
+			"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+		} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(row+"/"+target+"/"+api, func(t *testing.T) {
+					ir, err := arm64ClosedTailTranslate(t, arm64PCAlignTailSource(row), "func Read(*uint64) uint64", target, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					value := strings.Split(strings.Split(row, "$")[1], ",")[0]
+					alignment, err := strconv.Atoi(value)
+					if err != nil {
+						t.Fatal(err)
+					}
+					aligned := false
+					for _, line := range strings.Split(ir, "\n") {
+						if strings.HasPrefix(line, "define ") && strings.Contains(line, fmt.Sprintf(" align %d ", alignment)) {
+							aligned = true
+						}
+					}
+					if !aligned {
+						t.Fatal("source-required function alignment was lost")
+					}
+					compileLLVMToObject(t, llc, target, "aligned-tail.ll", "aligned-tail.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64PCAlignMalformedCompleteSource(t *testing.T) {
+	for _, row := range []string{
+		"PCALIGN", "PCALIGN $16,$1", "PCALIGN $0", "PCALIGN $4", "PCALIGN $24",
+		"PCALIGN $4096", "PCALIGN $-16", "PCALIGN $16.0", "PCALIGN $missing",
+		"PCALIGN R0", "PCALIGN 16(R0)", "PCALIGN.P $16",
+		"PCALIGNMAX", "PCALIGNMAX $16", "PCALIGNMAX $16,$1,$2",
+		"PCALIGNMAX $16,$16", "PCALIGNMAX $16,$-1", "PCALIGNMAX $24,$1",
+		"PCALIGNMAX $16,$1.0", "PCALIGNMAX $16,R0", "PCALIGNMAX R0,$1",
+		"PCALIGNMAX $16,$missing", "PCALIGNMAX.P $16,$7",
+	} {
+		for _, placement := range []string{"root", "helper", "dead"} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(row+"/"+placement+"/"+api, func(t *testing.T) {
+					source := arm64ClosedTailPointerSource("B")
+					switch placement {
+					case "root":
+						source = strings.Replace(source, "B readbody", row+"\nB readbody", 1)
+					case "helper":
+						source = strings.Replace(source, "MOVD (R0),R0", row+"\nMOVD (R0),R0", 1)
+					case "dead":
+						source += "dead:\n" + row + "\nRET\n"
+					}
+					if ir, err := arm64ClosedTailTranslate(t, source, "func Read(*uint64) uint64", arm64LinuxGNUTriple, api); err == nil || ir != "" {
+						t.Fatalf("malformed alignment acquired a source contract: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64PCAlignDoesNotAuthorizeNativeLayout(t *testing.T) {
+	for _, row := range []string{"PCALIGN $16", "PCALIGNMAX $16,$0", "PCALIGNMAX $16,$15"} {
+		for _, observer := range []string{
+			"TEXT ·Excluded(SB),516,$0-8\nWORD $0xd503201f\nRET\n",
+			"TEXT ·Excluded(SB),516,$0-8\nADR label,R0\nlabel:\nRET\n",
+			"TEXT ·Excluded(SB),516,$0-8\nB 1(PC)\nRET\n",
+			"TEXT ·Excluded(SB),516,$0-8\nMOVD $readbody<>(SB),R0\nRET\n",
+			"DATA saved<>+0(SB)/8,$readbody<>(SB)\nGLOBL saved<>(SB),8,$8\n",
+		} {
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(row+"/"+strings.Split(observer, "\n")[0]+"/"+api, func(t *testing.T) {
+					_, err := arm64ClosedTailTranslate(t, arm64PCAlignTailSource(row)+observer,
+						"func Read(*uint64) uint64\nfunc Excluded() uint64", arm64LinuxGNUTriple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("alignment authorized an observable native layout: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64PCAlignRetainsContinuationGuards(t *testing.T) {
+	for _, row := range []string{"PCALIGN $16", "PCALIGNMAX $32,$0", "PCALIGNMAX $32,$31"} {
+		t.Run(row, func(t *testing.T) {
+			// A data-only directive cannot initialize an otherwise unknown R9.
+			source := strings.Replace(arm64PCAlignTailSource(row), "MOVD (R0),R0", "MOVD R9,R0", 1)
+			for _, api := range []string{"text", "module", "GoModule"} {
+				if _, err := arm64ClosedTailTranslate(t, source, "func Read(*uint64) uint64", arm64LinuxGNUTriple, api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("alignment initialized a missing register: %v", err)
+				}
+			}
+
+			// CALL helpers deliberately retain their separate layout contract.
+			file, err := Parse(ArchARM64, arm64PrivateCallCFGCopySource+
+				"TEXT observer<>(SB),516,$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := CoalesceARM64PrivateRegisterHelpers(file); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("tail alignment permission leaked into a CALL continuation: %v", err)
+			}
+
+			file, err = Parse(ArchARM64, arm64PCAlignTailSource(row))
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observer, err := Parse(ArchARM64, "TEXT observer<>(SB),516,$0-0\nWORD $0xd503201f\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared.Funcs = append(prepared.Funcs, observer.Funcs...)
+			if _, err := CoalesceARM64PrivateRegisterHelpers(prepared); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("prepared aligned source bypassed its final whole-file audit: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_prelude_demand.go b/arm64_prelude_demand.go
new file mode 100644
index 000000000..9343bea10
--- /dev/null
+++ b/arm64_prelude_demand.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// This is an immutable compiler declaration catalog, not a source, SDK or
+// caller observation. Construct it once; each module selects its own used set.
+var arm64PreludeCatalog struct {
+	once         sync.Once
+	declarations map[string]string
+}
+
+func emitUsedARM64Prelude(b *strings.Builder) {
+	arm64PreludeCatalog.once.Do(func() {
+		var catalog strings.Builder
+		emitARM64Prelude(&catalog)
+		arm64PreludeCatalog.declarations = llvmPreludeDeclarations(catalog.String())
+	})
+	emitUsedLLVMPrelude(b, arm64PreludeCatalog.declarations)
+}
+
+// The input is the compiler's existing declaration emitter, not source IR.
+func llvmPreludeDeclarations(text string) map[string]string {
+	declarations := make(map[string]string)
+	for _, line := range strings.Split(text, "\n") {
+		if !strings.HasPrefix(line, "declare ") {
+			continue
+		}
+		start := strings.IndexByte(line, '@') + 1
+		end := strings.IndexByte(line[start:], '(') + start
+		declarations[line[start:end]] = line
+	}
+	return declarations
+}
+
+func emitUsedLLVMPrelude(b *strings.Builder, declarations map[string]string) {
+	var names []string
+	for name := range llvmTextGlobalNames(b.String()) {
+		if _, ok := declarations[name]; ok {
+			names = append(names, name)
+		}
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		b.WriteString(declarations[name])
+		b.WriteByte('\n')
+	}
+}
+
+// llvmTextGlobalNames scans generated LLVM text, not assembly opcodes. This
+// includes raw/named lowerers and new intrinsic families without maintaining a
+// second instruction registry. Comments and string constants are not uses.
+func llvmTextGlobalNames(text string) map[string]bool {
+	names := make(map[string]bool)
+	for i := 0; i < len(text); {
+		switch text[i] {
+		case ';':
+			for i < len(text) && text[i] != '\n' {
+				i++
+			}
+		case '"':
+			_, i = llvmTextQuotedName(text, i)
+		case '@':
+			i++
+			if i < len(text) && text[i] == '"' {
+				var name string
+				name, i = llvmTextQuotedName(text, i)
+				names[name] = true
+				continue
+			}
+			start := i
+			for i < len(text) && llvmTextNameByte(text[i]) {
+				i++
+			}
+			if i > start {
+				names[text[start:i]] = true
+			}
+		default:
+			i++
+		}
+	}
+	return names
+}
+
+func llvmTextNameByte(c byte) bool {
+	return c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' ||
+		c >= '0' && c <= '9' || c == '_' || c == '.' || c == '$' || c == '-'
+}
+
+func llvmTextQuotedName(text string, start int) (string, int) {
+	var name strings.Builder
+	for i := start + 1; i < len(text); i++ {
+		if text[i] == '"' {
+			return name.String(), i + 1
+		}
+		if text[i] == '\\' && i+2 < len(text) {
+			if value, err := strconv.ParseUint(text[i+1:i+3], 16, 8); err == nil {
+				name.WriteByte(byte(value))
+				i += 2
+				continue
+			}
+		}
+		name.WriteByte(text[i])
+	}
+	// Malformed generated IR is still rejected by the LLVM parser. This scan
+	// cannot turn an unterminated quoted identifier into a valid declaration.
+	return "", len(text)
+}
diff --git a/arm64_prelude_demand_test.go b/arm64_prelude_demand_test.go
new file mode 100644
index 000000000..a55559e29
--- /dev/null
+++ b/arm64_prelude_demand_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestLLVMTextGlobalNames(t *testing.T) {
+	const text = `; @not.a.use()
+@"global;name" = constant [14 x i8] c"@not.a.use()\00"
+define void @body() {
+  %x = call i32 @llvm.ctlz.i32(i32 7, i1 false)
+  %y = call i64 @"llvm.bitreverse\2Ei64"(i64 7)
+  call void @prefix.longer()
+  ret void ; @also.not.a.use
+}
+`
+	want := map[string]bool{
+		"global;name": true, "body": true, "llvm.ctlz.i32": true,
+		"llvm.bitreverse.i64": true, "prefix.longer": true,
+	}
+	if got := llvmTextGlobalNames(text); !reflect.DeepEqual(got, want) {
+		t.Fatalf("LLVM global names = %v, want %v", got, want)
+	}
+}
+
+func TestARM64PreludeContainsOnlyUsedDeclarations(t *testing.T) {
+	for _, row := range []struct {
+		name string
+		body string
+		want []string
+	}{
+		{
+			name: "scalar",
+			body: "MOVD $7, R0\nMOVD R0, ret+0(FP)\nRET",
+		},
+		{
+			name: "annotated-comment",
+			body: "MOVD $7, R0 // @llvm.bitreverse.i64( is only a comment\nMOVD R0, ret+0(FP)\nRET",
+		},
+		{
+			name: "scalar-intrinsics",
+			body: "MOVD $7, R0\nRBIT R0, R1\nCLZW R1, R0\nMOVD R0, ret+0(FP)\nRET",
+			want: []string{"llvm.bitreverse.i64", "llvm.ctlz.i32"},
+		},
+		{
+			name: "scalable-intrinsic",
+			body: "CNTB R0\nMOVD R0, ret+0(FP)\nRET",
+			want: []string{"llvm.aarch64.sve.cntb"},
+		},
+		{
+			name: "raw-scalable-intrinsic",
+			body: "WORD $0x0420e3ea\nMOVD R10, ret+0(FP)\nRET",
+			want: []string{"llvm.aarch64.sve.cntb"},
+		},
+	} {
+		// The current entry lowerer reads the incoming LR through this
+		// intrinsic even for an ordinary scalar leaf. It is an actual use,
+		// unlike the other 2,220 declarations formerly emitted unconditionally.
+		row.want = append(row.want, "llvm.returnaddress")
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", targetBackendCase{
+					arch: ArchARM64, goarch: "arm64", body: row.body, result: true,
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				var declarations []string
+				for _, line := range strings.Split(ir, "\n") {
+					if strings.HasPrefix(line, "declare ") {
+						declarations = append(declarations, line)
+					}
+				}
+				if len(declarations) != len(row.want) {
+					t.Fatalf("generated %d declarations, want only %d used declarations (IR: %d bytes)",
+						len(declarations), len(row.want), len(ir))
+				}
+				t.Logf("%d bytes of IR, %d used declarations", len(ir), len(declarations))
+				for _, name := range row.want {
+					found := false
+					for _, declaration := range declarations {
+						found = found || strings.Contains(declaration, "@"+name+"(")
+					}
+					if !found {
+						t.Errorf("missing used declaration %s", name)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestARM64DemandPreludeLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	row := targetBackendCase{
+		arch: ArchARM64, goarch: "arm64", result: true,
+		body: "CNTB R0\nRBIT R0, R1\nCLZW R1, R0\nMOVD R0, ret+0(FP)\nRET",
+	}
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, triple, row)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "demand.ll", "demand.o", ir)
+			})
+		}
+	}
+}
diff --git a/arm64_private_call_audit_test.go b/arm64_private_call_audit_test.go
new file mode 100644
index 000000000..406e3c5f9
--- /dev/null
+++ b/arm64_private_call_audit_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64PrivateCallCFGUnlinkedPreludeCannotHideNativeUse(t *testing.T) {
+	for _, prelude := range []string{"MOVD $copy<>(SB),R0\n", "WORD $0xd503201f\n"} {
+		t.Run(strings.TrimSpace(prelude), func(t *testing.T) {
+			file, err := Parse(ArchARM64, prelude+arm64PrivateCallCFGCopySource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(file.UnlinkedPrelude) == 0 {
+				t.Fatal("fixture did not retain its unbound native prelude")
+			}
+			if prepared, err := CoalesceARM64PrivateRegisterHelpers(file); prepared != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound prelude gained a private CALL continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateCallCFGLeafCannotCallOutOrWidenRegisterDomain(t *testing.T) {
+	for _, instruction := range []string{
+		"CALL R1", "BL R1", "BLR R1",
+		"VEOR V0.B16,V0.B16,V0.B16", "FMOVD R1,F0",
+	} {
+		for _, dead := range []bool{false, true} {
+			name := instruction
+			body := instruction + "\nRET\n"
+			if dead {
+				name += "/dead_component"
+				body = "RET\ndead:\n" + body
+			}
+			t.Run(name, func(t *testing.T) {
+				source := strings.Split(arm64PrivateCallCFGCopySource, "TEXT copy<>")[0] +
+					"TEXT copy<>(SB),516,$0-0\n" + body
+				// BLR is accepted by the parsed IR API, not Go's spelling table.
+				// Keep that distinction explicit while guarding both surfaces.
+				requireARM64GoAssemblerResult(t, source, !strings.HasPrefix(instruction, "BLR"))
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if prepared, err := CoalesceARM64PrivateRegisterHelpers(file); prepared != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("CALL data leaf gained a callout or unproved register domain: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PrivateCallCFGPreparedFileCannotRecoverRemovedNativeIdentity(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privatecopy", "package privatecopy\nfunc Copy(dst,src *[32]byte,n uint64)\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	for _, observer := range []struct{ name, source string }{
+		{"address", "TEXT observer<>(SB),516,$0-0\nMOVD $copy<>(SB),R0\nRET\n"},
+		{"offset_address", "TEXT observer<>(SB),516,$0-0\nMOVD $copy<>+4(SB),R0\nRET\n"},
+		{"native_call", "TEXT observer<>(SB),516,$0-0\nCALL copy<>(SB)\nRET\n"},
+		{"data", "DATA saved<>+0(SB)/8,$copy<>(SB)\nGLOBL saved<>(SB),8,$8\n"},
+		{"global", "GLOBL copy<>(SB),8,$8\n"},
+		{"redefined_helper", "TEXT copy<>(SB),516,$0-0\nRET\n"},
+		{"native_layout", "TEXT observer<>(SB),516,$0-0\nWORD $0xd503201f\nRET\n"},
+		{"prelude", "MOVD $copy<>(SB),R0\nTEXT observer<>(SB),516,$0-0\nRET\n"},
+	} {
+		for _, api := range []string{"coalesce", "Go_preparation", "text", "module"} {
+			t.Run(observer.name+"/"+api, func(t *testing.T) {
+				file, err := Parse(ArchARM64, arm64PrivateCallCFGCopySource)
+				if err != nil {
+					t.Fatal(err)
+				}
+				prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs, err := goSigsForAsmFile(pkg, prepared, resolve, "arm64", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				added, err := Parse(ArchARM64, observer.source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				prepared.Funcs = append(prepared.Funcs, added.Funcs...)
+				prepared.Data = append(prepared.Data, added.Data...)
+				prepared.Globl = append(prepared.Globl, added.Globl...)
+				prepared.UnlinkedPrelude = append(prepared.UnlinkedPrelude, added.UnlinkedPrelude...)
+				options := Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple, ResolveSym: resolve, Sigs: sigs}
+				switch api {
+				case "coalesce":
+					_, err = CoalesceARM64PrivateRegisterHelpers(prepared)
+				case "Go_preparation":
+					_, err = PrepareGoARM64ABI0TailContinuations(prepared, sigs, resolve)
+				case "text":
+					_, err = Translate(prepared, options)
+				case "module":
+					context := llvm.NewContext()
+					defer context.Dispose()
+					module, failure := TranslateModuleInContext(context, prepared, options)
+					if !module.IsNil() {
+						module.Dispose()
+					}
+					err = failure
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("edited complete file recovered removed helper native identity: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PrivateContinuationPreparedTailFileRetainsWholeAudit(t *testing.T) {
+	for _, family := range []string{"ABIInternal", "ABI0"} {
+		for _, observer := range []string{
+			"DATA saved<>+0(SB)/8,$HELPER(SB)\nGLOBL saved<>(SB),8,$8\n",
+			"TEXT observer<>(SB),516,$0-0\nMOVD $HELPER(SB),R0\nRET\n",
+			"TEXT HELPER(SB),516,$0-0\nRET\n",
+			"WORD $0xd503201f\nTEXT observer<>(SB),516,$0-0\nRET\n",
+		} {
+			t.Run(family+"/"+strings.Split(observer, "\n")[0], func(t *testing.T) {
+				resolve := func(symbol string) string { return strings.TrimPrefix(goTextSymbolForResolution(symbol), "·") }
+				var file *File
+				var sigs map[string]FuncSig
+				helper := "copy<>"
+				if family == "ABI0" {
+					_, file, sigs = arm64ABI0BoundFixture(t)
+					helper = "resultbody<>"
+				} else {
+					var err error
+					file, err = Parse(ArchARM64, "TEXT ·Copy<ABIInternal>(SB),516,$0-0\nB copy<>(SB)\nTEXT copy<>(SB),516,$0-0\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+				prepared, err := PrepareGoARM64ABI0TailContinuations(file, sigs, resolve)
+				if err != nil || len(prepared.Funcs) != 1 {
+					t.Fatalf("original complete tail fixture did not prepare: %v", err)
+				}
+				added, err := Parse(ArchARM64, strings.ReplaceAll(observer, "HELPER", helper))
+				if err != nil {
+					t.Fatal(err)
+				}
+				prepared.Funcs = append(prepared.Funcs, added.Funcs...)
+				prepared.Data = append(prepared.Data, added.Data...)
+				prepared.Globl = append(prepared.Globl, added.Globl...)
+				prepared.UnlinkedPrelude = append(prepared.UnlinkedPrelude, added.UnlinkedPrelude...)
+				if _, err := PrepareGoARM64ABI0TailContinuations(prepared, sigs, resolve); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("prepared tail recovered its removed helper native identity: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PrivateCallCFGCopyCannotBorrowPointerPermissionForCallerFrame(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privatecopy", "package privatecopy\nfunc Copy(dst,src *[32]byte,n uint64)\n")
+	for _, destination := range []string{
+		"MOVD RSP,R8", "ADD $7,RSP,R8", "MOVD $dst+0(FP),R8",
+	} {
+		t.Run(destination, func(t *testing.T) {
+			source := strings.Replace(arm64PrivateCallCFGCopySource, "MOVD dst+0(FP),R8", destination, 1)
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, target := range arm64TypedNativeTargets {
+				context := llvm.NewContext()
+				result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+				})
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				context.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s private caller-frame destination gained external-pointer permission: %v", target, err)
+				}
+			}
+		})
+	}
+}
diff --git a/arm64_private_call_cfg.go b/arm64_private_call_cfg.go
new file mode 100644
index 000000000..2e2110d45
--- /dev/null
+++ b/arm64_private_call_cfg.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import "reflect"
+
+// CALL helpers have no independently callable Go/LLVM signature. The original
+// source, audited helper bodies and exact cloned CFG stay sealed through final
+// lowering. Reusing a prepared Func after editing it cannot retain admission.
+type arm64PrivateCallSource struct {
+	original Func
+	helpers  []Func
+	prepared Func
+}
+
+func validateARM64PrivateCallSource(fn Func) error {
+	proof := fn.arm64PrivateCallSource
+	if proof == nil {
+		if fn.arm64PrivateRegisterEntry {
+			return arm64GoABIContext("private call root lost its complete source continuation")
+		}
+		return nil
+	}
+	if !fn.arm64PrivateRegisterEntry || len(proof.helpers) == 0 ||
+		!reflect.DeepEqual(arm64PrivateTailSnapshot(fn), proof.prepared) ||
+		proof.original.Sym != fn.Sym || proof.original.FrameSize != fn.FrameSize || proof.original.ArgSize != fn.ArgSize {
+		return arm64GoABIContext("private call root changed its sealed source continuation")
+	}
+	if proof.prepared.arm64PrivateUnexposedFrame != arm64CallFrameUnexposed(proof.original) {
+		return arm64GoABIContext("private call root changed its original frame-escape observation")
+	}
+	for _, helper := range proof.helpers {
+		if err := arm64PrivateRegisterLeaf(helper); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func arm64PrivateCallDataRegister(reg Reg) bool {
+	// R26 is ordinary explicitly initialized data here, not an implicit closure
+	// input. The independent root closure/availability proofs still apply.
+	// Floating/vector CALL continuations need their own initialized-input and
+	// runtime contracts. Do not inherit the independently tested tail domain.
+	return arm64PrivateDataGP(reg)
+}
+
+// CALL roots and their complete helpers independently reject every explicit
+// R27 operand. Registered immediate rows may therefore materialize a constant
+// in that unobserved scratch register. Reuse the exact ordered encoder grammar:
+// no guessed opcode mask, arbitrary implicit effect or faulting expansion is
+// admitted. Lowering and whole-root availability still record the real write.
+func arm64PrivateCallImmediateScratch(op Op, ins Instr, form arm64GPDataForm) bool {
+	immediate, handled, err := parseARM64GPImmediateForm(op, ins)
+	return handled && err == nil && immediate.scratch && !immediate.trailingUDF &&
+		form.scratch != nil && len(form.implicit) == 1 && form.implicit[0] == "R27"
+}
+
+// Check every original component, not only entry-reachable blocks. The bounded
+// CALL family admits a DAG, including multiple RETs and lexical backward edges
+// that do not form a cycle; recursion and loops need separate contracts.
+func arm64PrivateCallAcyclic(fn Func) error {
+	if len(fn.Instrs) > arm64PrivateRegisterExpansionBudget {
+		return arm64GoABIContext("private call helper exceeds its bounded source graph")
+	}
+	labels := make(map[string]int)
+	for i, ins := range fn.Instrs[1:] {
+		if ins.Op == OpLABEL {
+			labels[ins.Args[0].Sym] = i + 1
+		}
+	}
+	edges := make([][]int, len(fn.Instrs))
+	degree := make([]int, len(fn.Instrs))
+	for i, ins := range fn.Instrs[1:] {
+		index := i + 1
+		if ins.Op == OpRET {
+			continue
+		}
+		branch := ins.Op == "B" || ins.Op == "JMP" || arm64IsConditionalBranch(ins.Op)
+		if branch {
+			last := ins.Args[len(ins.Args)-1]
+			target, found := labels[last.Ident]
+			if !found {
+				return arm64GoABIContext("private call helper has an unbound branch target")
+			}
+			edges[index] = append(edges[index], target)
+			degree[target]++
+		}
+		if ins.Op != "B" && ins.Op != "JMP" {
+			if index+1 == len(fn.Instrs) {
+				return arm64GoABIContext("private call helper falls outside its original source")
+			}
+			edges[index] = append(edges[index], index+1)
+			degree[index+1]++
+		}
+	}
+	queue := make([]int, 0, len(fn.Instrs)-1)
+	for i := 1; i < len(degree); i++ {
+		if degree[i] == 0 {
+			queue = append(queue, i)
+		}
+	}
+	for next := 0; next < len(queue); next++ {
+		for _, target := range edges[queue[next]] {
+			degree[target]--
+			if degree[target] == 0 {
+				queue = append(queue, target)
+			}
+		}
+	}
+	if len(queue) != len(fn.Instrs)-1 {
+		return arm64GoABIContext("private call helper has an unproved cyclic source CFG")
+	}
+	return nil
+}
diff --git a/arm64_private_call_cfg_test.go b/arm64_private_call_cfg_test.go
new file mode 100644
index 000000000..729ced68c
--- /dev/null
+++ b/arm64_private_call_cfg_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64PrivateCallCFGCopySource = `TEXT ·Copy(SB),4,$0-24
+MOVD dst+0(FP),R8
+MOVD src+8(FP),R1
+MOVD n+16(FP),R3
+CMP $32,R3
+BLS bounded
+MOVD $32,R3
+bounded:
+CALL copy<>(SB)
+RET
+TEXT copy<>(SB),516,$0-0
+CBZ R3,copy0
+CMP $16,R3
+BLE copy16
+LDP (R1),(R21,R22)
+ADD R1,R3,R15
+LDP -16(R15),(R23,R24)
+STP (R21,R22),(R8)
+ADD R8,R3,R26
+STP (R23,R24),-16(R26)
+RET
+copy16:
+ADD R1,R3,R15
+ADD R8,R3,R26
+CMP $8,R3
+BLT copy7
+MOVD (R1),R21
+MOVD -8(R15),R22
+MOVD R21,(R8)
+MOVD R22,-8(R26)
+RET
+copy7:
+TBZ $2,R3,copy3
+MOVWU (R1),R21
+MOVWU -4(R15),R22
+MOVW R21,(R8)
+MOVW R22,-4(R26)
+RET
+copy3:
+TBZ $1,R3,copy1
+MOVHU (R1),R21
+MOVHU -2(R15),R22
+MOVH R21,(R8)
+MOVH R22,-2(R26)
+RET
+copy1:
+MOVBU (R1),R21
+MOVBU R21,(R8)
+copy0:
+RET
+`
+
+func TestARM64PrivateCallCFGSourcePreparation(t *testing.T) {
+	register := strings.Replace(arm64PrivateRegisterHelperSource("516,$0-0", "CALL mix<>(SB)"),
+		"ADC $0,R9,R20\nMUL R19,R20,R20\nRET", `CBZ R19,zero
+ADC $0,R9,R20
+MUL R19,R20,R20
+RET
+zero:
+MOVD $7,R20
+RET`, 1)
+	for _, test := range []struct {
+		name, source string
+	}{
+		{"register_multiple_returns", register},
+		{"lexical_backward_acyclic_edge", strings.Replace(register,
+			"CBZ R19,zero\nADC", "B forward\nbackward:\nRET\nforward:\nCBZ R19,backward\nADC", 1)},
+		{"typed_scalar_pair_copy", arm64PrivateCallCFGCopySource},
+		{"two_static_calls", strings.Replace(arm64PrivateCallCFGCopySource,
+			"CALL copy<>(SB)", "CALL copy<>(SB)\nCALL copy<>(SB)", 1)},
+		{"caller_label_collision", strings.Replace(arm64PrivateCallCFGCopySource,
+			"CALL copy<>(SB)", "__arm64_private_0:\ncopy0:\nCALL copy<>(SB)", 1)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, test.source, true)
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+			if err != nil {
+				t.Fatal("closed private call CFG did not preserve its source continuation:", err)
+			}
+			if prepared == file || len(prepared.Funcs) != 1 || !reflect.DeepEqual(file, original) {
+				t.Fatal("continuation preparation changed the original file or invented a callable helper")
+			}
+			repeated, err := CoalesceARM64PrivateRegisterHelpers(prepared)
+			if err != nil || !reflect.DeepEqual(prepared, repeated) {
+				t.Fatalf("repeated continuation preparation changed its source: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateCallCFGRejectsUnclosedSource(t *testing.T) {
+	for _, test := range []struct {
+		name, source string
+	}{
+		{"cycle", strings.Replace(arm64PrivateCallCFGCopySource, "copy0:\nRET", "copy0:\nB copy0", 1)},
+		{"dead_cycle", arm64PrivateCallCFGCopySource + "dead:\nB dead\n"},
+		{"unbound_target", strings.Replace(arm64PrivateCallCFGCopySource, "CBZ R3,copy0", "CBZ R3,missing", 1)},
+		{"hidden_stack", strings.Replace(arm64PrivateCallCFGCopySource, "LDP (R1)", "LDP (RSP)", 1)},
+		{"saved_link", strings.Replace(arm64PrivateCallCFGCopySource, "ADD R8,R3,R26", "ADD R8,R3,R30", 1)},
+		{"scratch", strings.Replace(arm64PrivateCallCFGCopySource, "ADD R8,R3,R26", "ADD R8,R3,R27", 1)},
+		{"faulting_expansion", strings.Replace(arm64PrivateCallCFGCopySource, "ADD R8,R3,R26", "CMP $1,ZR", 1)},
+		{"callout", strings.Replace(arm64PrivateCallCFGCopySource, "copy0:\nRET", "copy0:\nCALL foreign(SB)\nRET", 1)},
+		{"address_escape", arm64PrivateCallCFGCopySource + "TEXT observer<>(SB),516,$0\nMOVD $copy<>(SB),R0\nRET\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if result, err := CoalesceARM64PrivateRegisterHelpers(file); result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed source gained a private CALL continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateCallCFGPreparedSourceCannotBeChanged(t *testing.T) {
+	for _, mutation := range []string{"instruction", "argument", "frame", "symbol", "entry", "source_accounting"} {
+		t.Run(mutation, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64PrivateCallCFGCopySource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			root := &prepared.Funcs[0]
+			switch mutation {
+			case "instruction":
+				root.Instrs[1].Op = "MOVW"
+			case "argument":
+				root.Instrs[1].Args[1].Reg = "R30"
+			case "frame":
+				root.FrameSize++
+			case "symbol":
+				root.Sym = "another"
+			case "entry":
+				root.arm64PrivateRegisterEntry = false
+			case "source_accounting":
+				root.arm64PrivateSourceAdded--
+			}
+			if _, err := CoalesceARM64PrivateRegisterHelpers(prepared); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed prepared source kept its original admission: %v", err)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateCallCFGCopy(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg := mustGoPackage(t, "test/privatecopy", "package privatecopy\nfunc Copy(dst,src *[32]byte,n uint64)\n")
+	for _, calls := range []int{1, 2} {
+		source := arm64PrivateCallCFGCopySource
+		if calls == 2 {
+			source = strings.Replace(source, "CALL copy<>(SB)", "CALL copy<>(SB)\nCALL copy<>(SB)", 1)
+		}
+		t.Run(strconv.Itoa(calls)+"_calls", func(t *testing.T) {
+			goProgram := `package main
+import "unsafe"
+func Copy(dst,src *[32]byte,n uint64)
+func main() {
+    for _,d := range []int{0,1,7,16,32} {
+        for _,s := range []int{0,1,7,16,32} {
+            for _,n := range []uint64{0,1,2,3,4,7,8,15,16,17,23,31,32,33,64,^uint64(0)} {
+                var data,want [128]byte
+                for i := range data { data[i] = byte(i*37+d*11+s*7+int(n)); want[i] = data[i] }
+                q := n
+                if q > 32 { q = 32 }
+                for pass := 0; pass < REPEATS; pass++ {
+                    var snapshot [32]byte
+                    for i := uint64(0); i < q; i++ { snapshot[i] = want[s+int(i)] }
+                    for i := uint64(0); i < q; i++ { want[d+int(i)] = snapshot[i] }
+                }
+                Copy((*[32]byte)(unsafe.Pointer(&data[d])), (*[32]byte)(unsafe.Pointer(&data[s])), n)
+                if data != want { panic("original Go private CFG copy/full-canary mismatch") }
+            }
+        }
+    }
+    Copy(nil,nil,0)
+}
+`
+			goProgram = strings.ReplaceAll(goProgram, "REPEATS", strconv.Itoa(calls))
+			runARM64LocalRegisterGoOracle(t, source, goProgram, len(runner) != 0)
+			translate := func(target string) string {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer result.Module.Dispose()
+				if len(result.Signatures) != 1 || len(result.Functions) != 1 {
+					t.Fatal("private continuation acquired an independent function ABI")
+				}
+				return result.Module.String()
+			}
+			for _, target := range arm64TypedNativeTargets {
+				compileLLVMToObject(t, llc, target, "private-call-cfg.ll", "private-call-cfg.o", translate(target))
+			}
+			cProgram := `#include <stdint.h>
+#include <string.h>
+extern void Copy(void *,const void *,uint64_t);
+int main(void) {
+    const int offsets[] = {0,1,7,16,32};
+    const uint64_t sizes[] = {0,1,2,3,4,7,8,15,16,17,23,31,32,33,64,UINT64_MAX};
+    for (unsigned d=0; d<5; d++) for (unsigned s=0; s<5; s++) for (unsigned z=0; z<16; z++) {
+        unsigned char data[128],want[128];
+        uint64_t n=sizes[z],q=n>32?32:n;
+        for (unsigned i=0; i<128; i++) data[i]=want[i]=(unsigned char)(i*37+offsets[d]*11+offsets[s]*7+n);
+        for (int pass=0; pass<REPEATS; pass++) memmove(want+offsets[d],want+offsets[s],q);
+        Copy(data+offsets[d],data+offsets[s],n);
+        if (memcmp(data,want,128)) return 1;
+    }
+    Copy(0,0,0);
+    return 0;
+}
+`
+			cProgram = strings.ReplaceAll(cProgram, "REPEATS", strconv.Itoa(calls))
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private-call-cfg", triple, translate(triple), cProgram, runner)
+		})
+	}
+}
diff --git a/arm64_private_call_frame.go b/arm64_private_call_frame.go
new file mode 100644
index 000000000..892ac2187
--- /dev/null
+++ b/arm64_private_call_frame.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import "strings"
+
+// The virtual SP initialized by emitEntryAllocasAndArgInit points into a fresh
+// function-local LLVM allocation, not into the native caller's incoming stack.
+// A typed call transports only its declared values, never that virtual SP as an
+// implicit ABI0 frame. Incoming pointers therefore cannot name this allocation
+// unless the source first exposes its address. This bounded, whole-function
+// check also admits bounded affine temporaries used only by known local reads
+// and fully overwritten before calls/returns, before and after normalization.
+// Dead escapes and unknown effects still disable the complete source proof.
+// It does not establish ownership of incoming pointers or the separate FP slots.
+func arm64CallFrameUnexposed(fn Func) bool {
+	return arm64CallFrameUnexposedForTransport(fn, nil)
+}
+
+func arm64CallFrameUnexposedTyped(fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig) bool {
+	return arm64CallFrameUnexposedTypedTarget(fn, sig, resolve, sigs, "")
+}
+
+func arm64CallFrameUnexposedTypedTarget(fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, target string) bool {
+	if !arm64CallFrameFreshEntry(sig) || sig.ARM64ClosureABI != nil {
+		return false
+	}
+	if sig.ARM64GoRegisterABI != nil && arm64ValidateGoRegisterABI(sig) != nil {
+		return false
+	}
+	transport := &arm64PrivateFrameTransport{entry: sig, resolve: resolve, sigs: sigs}
+	proof, required := arm64NanosleepInputForSource(fn, transport, target)
+	if required && proof == nil {
+		return false
+	}
+	transport.nanosleep = proof
+	return arm64CallFrameUnexposedForTransport(fn, transport)
+}
+
+func arm64CallFrameUnexposedForTransport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	if !arm64SourceGoFrame(fn).present {
+		return arm64RawZeroFrameUnexposedForTransport(fn, transport)
+	}
+	if arm64HasRawFrameCode(fn) || arm64SourceFrameR20Required(fn) {
+		return arm64RawPrivateFrameUnexposedForTransport(fn, transport)
+	}
+	text, affine := false, false
+	for _, original := range fn.Instrs {
+		if original.Op == OpTEXT {
+			_, rest := splitOpcode(original.Raw)
+			parts := strings.Split(rest, ",")
+			if len(parts) < 2 || len(parts) > 3 || !strings.HasPrefix(strings.TrimSpace(parts[len(parts)-1]), "$") {
+				return false
+			}
+			frame, _, err := parseTEXTFrame(parts)
+			if err != nil || frame != fn.FrameSize {
+				return false
+			}
+			text = true
+		}
+		ins := arm64StackInstruction(arm64ControlDecode(original))
+		op := arm64ControlOp(ins)
+		switch op {
+		case OpWORD, "DWORD", arm64RawDataOp, "ADR", "ADRP", "BLR":
+			return false
+		case "CALL", "BL":
+			if len(ins.Args) != 1 {
+				return false
+			}
+			if ins.Args[0].Kind != OpSym && !(fn.arm64PrivateUnexposedFrame && ins.Args[0].Kind == OpIdent) {
+				return false
+			}
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpFPAddr {
+				return false
+			}
+			// An ordinary SP-relative load/store uses the private allocation
+			// without transporting its address as a scalar. An SP index or a
+			// register/shift/extension/list operand can expose that address.
+			registers := []Reg{operand.Reg, operand.ShiftReg, operand.Mem.Index}
+			registers = append(registers, operand.RegList...)
+			if operand.Kind == OpSym {
+				symbol := strings.TrimSpace(operand.Sym)
+				if strings.HasPrefix(symbol, "$") {
+					if strings.Contains(symbol, "(FP)") {
+						return false
+					}
+					if memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(symbol, "$"))); ok {
+						registers = append(registers, memory.Base, memory.Index)
+					}
+				}
+			}
+			for _, reg := range registers {
+				if arm64StackReg(reg) {
+					affine = true
+				}
+			}
+		}
+	}
+	return text && (!affine || arm64PrivateFrameReadProofForTransport(fn, transport))
+}
+
+// Entry transport is emitted after the fresh SP initialization. A custom
+// incoming SP assignment would replace that root; it cannot borrow this proof.
+// Standard Go register contracts assign only GP/FP banks, but retain a
+// conservative check here as well for a caller-supplied malformed contract.
+func arm64CallFrameFreshEntry(sig FuncSig) bool {
+	for _, reg := range sig.ArgRegs {
+		if arm64StackReg(reg) {
+			return false
+		}
+	}
+	if sig.ARM64GoRegisterABI != nil {
+		for _, param := range sig.ARM64GoRegisterABI.Params {
+			if arm64StackReg(param.Register) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Reuse the complete scalar/aggregate traversal. Its bounded register grammar
+// does not recognize every stack-ABI aggregate; an unrecognized type remains
+// possibly pointer-containing, rather than acquiring an invented noalias fact.
+func arm64CallTypeMayContainPointer(typ LLVMType) bool {
+	pointer := false
+	err := arm64GoABILeaves(typ, nil, func(leaf LLVMType, _ []int) error {
+		pointer = pointer || leaf == Ptr
+		return nil
+	})
+	return pointer || err != nil
+}
diff --git a/arm64_private_call_frame_test.go b/arm64_private_call_frame_test.go
new file mode 100644
index 000000000..3441fd1fd
--- /dev/null
+++ b/arm64_private_call_frame_test.go
@@ -0,0 +1,477 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64PrivateCallFrameAddressEscapeRemainsContext(t *testing.T) {
+	for _, tc := range []struct {
+		name, before, after, data string
+	}{
+		{name: "direct_sp", before: "MOVD RSP,R5"},
+		{name: "affine_sp", before: "MOVD RSP,R9\nADD $16,R9,R5"},
+		{name: "sp_address_expression", before: "MOVD $-32(RSP),R9"},
+		{name: "bit_transformed_sp", before: "MOVD RSP,R9\nEOR $8,R9,R5\nEOR $8,R5"},
+		{name: "caller_fp_escape", before: "MOVD RSP,R9\nMOVD R9,dst+0(FP)\nMOVD dst+0(FP),R5"},
+		{name: "fp_address", before: "MOVD $dst+0(FP),R5"},
+		{name: "global_escape", before: "MOVD RSP,R9\nMOVD R9,holder(SB)", data: "GLOBL holder(SB),NOPTR,$8\n"},
+		{name: "data_target_escape", before: "MOVD holder(SB),R10\nMOVD RSP,R9\nMOVD R9,(R10)", data: "DATA holder+0(SB)/8,$payload(SB)\nGLOBL holder(SB),NOPTR,$8\nGLOBL payload(SB),NOPTR,$8\n"},
+		{name: "heap_escape", before: "MOVD RSP,R9\nMOVD R9,(R5)"},
+		{name: "previous_call_holds_frame", before: "MOVD RSP,R9\nMOVD R9,8(RSP)\nCALL runtime·memmove(SB)\nMOVD dst+0(FP),R5\nMOVD src+8(FP),R6\nMOVD n+16(FP),R7"},
+		{name: "branch_merge", before: "CBZ R7,external\nMOVD RSP,R5\nexternal:"},
+		{name: "dead_escape", after: "MOVD RSP,R9\nMOVD R9,holder(SB)\nRET", data: "GLOBL holder(SB),NOPTR,$8\n"},
+		{name: "raw_sp_value", before: "WORD $0x910003e9\nMOVD R9,R5"},
+		{name: "raw_sp_dword", before: "DWORD $0xd503201f910003e9"},
+		{name: "unknown_raw", before: "WORD $0xd50330ff"},
+		{name: "native_indirect_call", before: "MOVD dst+0(FP),R9\nCALL (R9)"},
+		{name: "raw_indirect_call", before: "MOVD dst+0(FP),R9\nWORD $0xd63f0120"},
+		{name: "unknown_symbol", before: "CALL unknown(SB)"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := strings.Replace(arm64PrivateCallCopySource, "\tMOVD R5, 8(RSP)", tc.before+"\n\tMOVD R5, 8(RSP)", 1)
+			source += tc.after + "\n" + tc.data
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if tc.name != "unknown_symbol" && arm64CallFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("source-wide escape/unknown-form gate accepted this original function")
+			}
+			for _, target := range arm64TypedNativeTargets {
+				opt := arm64PrivateCallCopyOptions(target)
+				unsupported := tc.name == "unknown_raw" || tc.name == "raw_sp_dword"
+				if _, err := Translate(file, opt); err == nil || !unsupported && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Translate exposed/unproven frame accepted: %v", target, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if err == nil || !unsupported && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Module exposed/unproven frame accepted: %v", target, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, arm64PrivateCallPackage(t), []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+					ManualSig: func(name string) (FuncSig, bool) {
+						if name == "unknown" {
+							return FuncSig{}, false
+						}
+						return opt.Sigs[name], name == "runtime.memmove"
+					},
+				})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				// An undeclared target is also rejected by Go binding; it must
+				// never acquire a guessed type just to preserve the private LR.
+				if err == nil || tc.name != "unknown_symbol" && !unsupported && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Go-bound exposed/unproven frame accepted: %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PrivateCallFrameAggregatePointersInvalidateFP(t *testing.T) {
+	for _, typ := range []LLVMType{Ptr, "{ ptr, i64 }", "{ i64, { ptr, double } }", "{ ptr, i64, i64 }", "[1 x ptr]", "[2 x ptr]", "unrecognized"} {
+		t.Run(string(typ), func(t *testing.T) {
+			sig := FuncSig{Name: "callee", Args: []LLVMType{typ}, Ret: Void, Frame: FrameLayout{
+				Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+			}}
+			state := &arm64ControlState{
+				regs: map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R30": arm64ControlFromMap(map[string]bool{"label:continuation": true})},
+				memory: map[string]arm64ControlValue{
+					"sp:0": arm64ControlFromMap(map[string]bool{"label:outer": true}), "sp:8": arm64ControlFromMap(map[string]bool{"": true}), "fp:0": arm64ControlFromMap(map[string]bool{"fpa:0": true}),
+				},
+			}
+			for _, proof := range []bool{false, true} {
+				copy := state.clone()
+				ctx := &arm64Ctx{resolve: func(s string) string { return s }, sigs: map[string]FuncSig{"callee": sig},
+					unexposedCallFrame: proof, sourceGoFrame: arm64GoFrame{present: true},
+				}
+				ctx.invalidateControlCallResults(copy, Operand{Kind: OpSym, Sym: "callee(SB)"})
+				if !arm64ControlHas(copy.memory["fp:0"], "") || arm64ControlHas(copy.memory["sp:0"], "") == proof {
+					t.Fatalf("pointer-containing/unknown transport lost the separate SP/FP contract (proof=%t): %v", proof, copy.memory)
+				}
+			}
+		})
+	}
+}
+
+func arm64PrivateCallPackage(t *testing.T) GoPackage {
+	return arm64PrivateCallDeclarations(t, "func ABI0Copy(dst,src unsafe.Pointer,n uintptr)\n")
+}
+
+func arm64PrivateCallDeclarations(t *testing.T, declarations string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "declaration.go", "package copy\nimport \"unsafe\"\n"+declarations, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := types.Config{Importer: importer.Default(), Sizes: types.SizesFor("gc", "arm64")}
+	pkg, err := conf.Check("test/copy", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "test/copy", Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func TestARM64PrivateCallFrameProofIsZeroDefaultAndSPOnly(t *testing.T) {
+	for _, tc := range []struct {
+		name, argument, escaped     string
+		proof, known, frame, intact bool
+	}{
+		{name: "fresh", proof: true, known: true, frame: true, intact: true},
+		{name: "zero_default", known: true, frame: true},
+		{name: "missing_source_frame", proof: true, known: true},
+		{name: "unknown_callee", proof: true, frame: true},
+		{name: "sp_argument", proof: true, known: true, frame: true, argument: "sp:8"},
+		{name: "fp_argument", proof: true, known: true, frame: true, argument: "fp:0"},
+		{name: "fp_address_argument", proof: true, known: true, frame: true, argument: "fpa:0"},
+		{name: "code_argument", proof: true, known: true, frame: true, argument: "label:local"},
+		{name: "previous_escape", proof: true, known: true, frame: true, escaped: "sp:16"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			sig := FuncSig{Name: "callee", Args: []LLVMType{Ptr}, Ret: Void, Frame: FrameLayout{
+				Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+			}}
+			state := &arm64ControlState{
+				regs: map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R30": arm64ControlFromMap(map[string]bool{"label:continuation": true})},
+				memory: map[string]arm64ControlValue{
+					"sp:0": arm64ControlFromMap(map[string]bool{"label:outer": true}), "sp:8": arm64ControlFromMap(map[string]bool{tc.argument: true}),
+					"sp:16": arm64ControlFromMap(map[string]bool{"": true}), "fp:0": arm64ControlFromMap(map[string]bool{"label:local": true}),
+				},
+			}
+			if tc.escaped != "" {
+				state.escaped = arm64ControlFromMap(map[string]bool{tc.escaped: true})
+			}
+			ctx := &arm64Ctx{resolve: func(s string) string { return s }, sigs: map[string]FuncSig{},
+				unexposedCallFrame: tc.proof, sourceGoFrame: arm64GoFrame{present: tc.frame},
+			}
+			if tc.known {
+				ctx.sigs["callee"] = sig
+			}
+			ctx.invalidateControlCallResults(state, Operand{Kind: OpSym, Sym: "callee(SB)"})
+			if arm64ControlHas(state.memory["sp:0"], "") == tc.intact {
+				t.Errorf("SP preservation mismatch: %v", state.memory["sp:0"])
+			}
+			if !arm64ControlHas(state.memory["fp:0"], "") {
+				t.Error("a private-SP proof must never retain an FP content category across a pointer call")
+			}
+			if !arm64ControlHas(state.memory["sp:16"], "") || !arm64ControlHas(state.regs["R9"], "") {
+				t.Error("private-SP proof restored unknown memory or caller-save GP")
+			}
+		})
+	}
+	for _, source := range []string{
+		"TEXT ABI0Copy(SB),NOSPLIT|NOFRAME,$0-24\nCALL runtime·memmove(SB)\nRET\n",
+		"TEXT ABI0Copy(SB),NOSPLIT,$0-24\nRET\n",
+		"TEXT ABI0Copy(SB),NOSPLIT,$32-24\nMOVD $8(RSP),R9\nCALL runtime·memmove(SB)\nRET\n",
+	} {
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Errorf("unproved source frame accepted: %s", source)
+		}
+	}
+	file, err := Parse(ArchARM64, arm64PrivateCallCopySource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	if !arm64CallFrameUnexposed(fn) {
+		t.Fatal("original ordinary ABI0 call did not establish a fresh unexposed SP object")
+	}
+	for _, sig := range []FuncSig{
+		{Args: []LLVMType{Ptr}, ArgRegs: []Reg{SP}},
+		{Args: []LLVMType{Ptr}, ArgRegs: []Reg{"RSP"}},
+		{ARM64GoRegisterABI: &ARM64GoRegisterABI{Params: []ARM64GoRegisterValue{{Type: Ptr, Register: SP}}}},
+	} {
+		if arm64CallFrameFreshEntry(sig) || newARM64Ctx(new(strings.Builder), fn, sig, nil, nil, false).unexposedCallFrame {
+			t.Fatal("an incoming custom SP can overwrite the fresh root and must not borrow its disjointness")
+		}
+	}
+	fn.Instrs = fn.Instrs[1:]
+	if arm64CallFrameUnexposed(fn) {
+		t.Fatal("a caller-constructed function without an actual TEXT contract borrowed a private-frame proof")
+	}
+}
+
+type arm64PrivateComposite struct {
+	name, goType, prepare, callee string
+	argSize                       int
+	constantResult                bool
+}
+
+func arm64PrivateComposites() []arm64PrivateComposite {
+	return []arm64PrivateComposite{
+		{name: "scalar", goType: "unsafe.Pointer", prepare: "MOVD R5,8(RSP)", callee: "MOVD value+0(FP),R0\nMOVD $7,R1", argSize: 8, constantResult: true},
+		{name: "struct", goType: "struct{ P unsafe.Pointer; N uint64 }", prepare: "MOVD R5,8(RSP)\nMOVD R6,16(RSP)", callee: "MOVD value_P+0(FP),R0\nMOVD value_N+8(FP),R1", argSize: 16},
+		{name: "nested_struct", goType: "struct{ N uint64; X struct{ P unsafe.Pointer; F float64 } }", prepare: "MOVD R6,8(RSP)\nMOVD R5,16(RSP)\nMOVD $0,R7\nMOVD R7,24(RSP)", callee: "MOVD value_X_P+8(FP),R0\nMOVD value_N+0(FP),R1", argSize: 24},
+		{name: "slice", goType: "[]uint64", prepare: "MOVD R5,8(RSP)\nMOVD R6,16(RSP)\nMOVD R6,24(RSP)", callee: "MOVD value_base+0(FP),R0\nMOVD value_len+8(FP),R1", argSize: 24},
+		{name: "string", goType: "string", prepare: "MOVD R5,8(RSP)\nMOVD R6,16(RSP)", callee: "MOVD value_base+0(FP),R0\nMOVD value_len+8(FP),R1", argSize: 16},
+		{name: "one_array", goType: "[1]unsafe.Pointer", prepare: "MOVD R5,8(RSP)", callee: "MOVD value+0(FP),R0\nMOVD $7,R1", argSize: 8, constantResult: true},
+		{name: "two_array", goType: "[2]unsafe.Pointer", prepare: "MOVD R5,8(RSP)\nMOVD R5,16(RSP)", callee: "MOVD value+0(FP),R0\nMOVD $7,R1", argSize: 16, constantResult: true},
+	}
+}
+
+func arm64PrivateCompositeSource(tc arm64PrivateComposite) string {
+	return fmt.Sprintf("#include \"textflag.h\"\nTEXT ·Composite(SB),NOSPLIT,$32-16\nMOVD dst+0(FP),R5\nMOVD n+8(FP),R6\n%s\nCALL ·Touch(SB)\nRET\nTEXT ·Touch(SB),NOSPLIT,$0-%d\n%s\nMOVD R1,(R0)\nRET\n", tc.prepare, tc.argSize, tc.callee)
+}
+
+func TestARM64PrivateCallFrameDeclaredCompositeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tc := range arm64PrivateComposites() {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64PrivateCompositeSource(tc)
+			arm64PrivateCallGoObject(t, source)
+			pkg := arm64PrivateCallDeclarations(t, "func Composite(dst unsafe.Pointer,n uint64)\nfunc Touch(value "+tc.goType+")\n")
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				func() {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+					bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer bound.Module.Dispose()
+					opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: bound.Signatures, ResolveSym: resolve}
+					if _, err := Translate(file, opt); err != nil {
+						t.Fatal(err)
+					}
+					module, err := TranslateModuleInContext(ctx, file, opt)
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer module.Dispose()
+					compileLLVMToObject(t, llc, target, tc.name+".ll", tc.name+".o", module.String())
+				}()
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateCallComposites(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range arm64PrivateComposites() {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64PrivateCompositeSource(tc)
+			declarations := "func Composite(dst unsafe.Pointer,n uint64)\nfunc Touch(value " + tc.goType + ")\n"
+			want := "n"
+			if tc.constantResult {
+				want = "7"
+			}
+			// Headers are transported by the assembler, not dereferenced as
+			// Go slices/strings. Keep lengths small and every pointer real.
+			runARM64LocalRegisterGoOracle(t, source, "package main\nimport \"unsafe\"\n"+declarations+fmt.Sprintf(`func main() {
+ for _,n:=range []uint64{0,1,3,7,15} {
+  data:=[3]uint64{0x1122334455667788,0,0x8877665544332211}
+  Composite(unsafe.Pointer(&data[1]),n)
+  if data[0]!=0x1122334455667788 || data[1]!=%s || data[2]!=0x8877665544332211 { panic("composite call canary/value mismatch") }
+ }
+}
+`, want), len(runner) != 0)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			bound, err := translateGoModuleInContext(ctx, arm64PrivateCallDeclarations(t, declarations), []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: triple, ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer bound.Module.Dispose()
+			driver := fmt.Sprintf(`#include <stdint.h>
+extern void Composite(void *,uint64_t);
+int main(void) {
+ const uint64_t inputs[]={0,1,3,7,15};
+ for(int i=0;i<5;i++) {
+  uint64_t n=inputs[i],data[]={UINT64_C(0x1122334455667788),0,UINT64_C(0x8877665544332211)};
+  Composite(data+1,n);
+  if(data[0]!=UINT64_C(0x1122334455667788)||data[1]!=%s||data[2]!=UINT64_C(0x8877665544332211)) return 1;
+ }
+ return 0;
+}
+`, want)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_composite_"+tc.name, triple, bound.Module.String(), driver, runner)
+		})
+	}
+}
+
+// This is the unchanged ABI0Copy source from llgo's runtime memmove regression.
+const arm64PrivateCallCopySource = `#include "textflag.h"
+TEXT ABI0Copy(SB),NOSPLIT,$32-24
+	MOVD dst+0(FP), R5
+	MOVD src+8(FP), R6
+	MOVD n+16(FP), R7
+	MOVD R5, 8(RSP)
+	MOVD R6, 16(RSP)
+	MOVD R7, 24(RSP)
+	MOVD $1, R0
+	MOVD $2, R1
+	MOVD $3, R2
+	CALL runtime·memmove(SB)
+	RET
+`
+
+func arm64PrivateCallCopyOptions(target string) Options {
+	args := []LLVMType{Ptr, Ptr, I64}
+	frame := FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+		{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		{Offset: 16, Type: I64, Index: 2, Field: -1},
+	}}
+	return Options{
+		Goarch: "arm64", TargetTriple: target,
+		ResolveSym: func(symbol string) string {
+			return strings.ReplaceAll(goStripABISuffix(strings.TrimPrefix(symbol, "·")), "·", ".")
+		},
+		Sigs: map[string]FuncSig{
+			"ABI0Copy":        {Name: "ABI0Copy", Args: args, Ret: Void, Frame: frame},
+			"runtime.memmove": {Name: "memmove", Args: args, Ret: Void, Frame: frame},
+		},
+	}
+}
+
+func arm64PrivateCallGoObject(t *testing.T, source string) {
+	t.Helper()
+	if !strings.Contains(source, "\"textflag.h\"") {
+		source = "#include \"textflag.h\"\n" + source
+	}
+	dir := t.TempDir()
+	path := filepath.Join(dir, "source.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-p", "runtime", "-I", filepath.Join(testGOROOT(t), "pkg/include"), "-o", filepath.Join(dir, "source.o"), path)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go assembler rejected private-frame source: %v\n%s", err, out)
+	}
+}
+
+func TestARM64PrivateCallFrameIncomingPointerPreservesSavedLink(t *testing.T) {
+	arm64PrivateCallGoObject(t, arm64PrivateCallCopySource)
+	file, err := Parse(ArchARM64, arm64PrivateCallCopySource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := arm64PrivateCallPackage(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			opt := arm64PrivateCallCopyOptions(target)
+			ir, err := Translate(file, opt)
+			if err != nil {
+				t.Errorf("incoming Ptr cannot expose an otherwise unexposed private frame: %v", err)
+			} else {
+				base := regexp.MustCompile(`(%[A-Za-z0-9_]+) = getelementptr inbounds \[[0-9]+ x i8\], ptr %local_stack, i32 0, i64 [0-9]+`).FindStringSubmatch(ir)
+				if !strings.Contains(ir, "%local_stack = alloca [") || len(base) != 2 || !strings.Contains(ir, "ptrtoint ptr "+base[1]+" to i64") {
+					t.Error("the source SP must derive from a fresh backing allocation, not an incoming pointer")
+				}
+				compileLLVMToObject(t, llc, target, "private-copy.ll", "private-copy.o", ir)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Errorf("owned-context module: %v", err)
+			} else {
+				module.Dispose()
+			}
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(arm64PrivateCallCopySource), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+				ManualSig: func(name string) (FuncSig, bool) {
+					return opt.Sigs[name], name == "runtime.memmove"
+				},
+			})
+			if err != nil {
+				t.Errorf("declaration-backed module: %v", err)
+			} else {
+				bound.Module.Dispose()
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateCallCopy(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	// Only qualify the entry for Go's generated ABI0 declaration wrapper;
+	// preserve every original instruction, frame and runtime call target.
+	goSource := strings.Replace(arm64PrivateCallCopySource, "TEXT ABI0Copy(SB)", "TEXT ·ABI0Copy(SB)", 1)
+	runARM64LocalRegisterGoOracle(t, goSource, `package main
+import "unsafe"
+func ABI0Copy(dst,src unsafe.Pointer,n uintptr)
+func main() {
+ for _,dst:=range []int{0,1,9,17,31} { for _,src:=range []int{0,1,9,17,31} { for _,n:=range []int{0,1,2,3,8,17,32,33} {
+  var data, want [96]byte
+  for i:=range data { data[i]=byte(i*37+dst*7+src*11+n); want[i]=data[i] }
+  var snapshot [33]byte
+  for i:=0;i<n;i++ { snapshot[i]=data[src+i] }
+  for i:=0;i<n;i++ { want[dst+i]=snapshot[i] }
+  ABI0Copy(unsafe.Pointer(&data[dst]),unsafe.Pointer(&data[src]),uintptr(n))
+  if data!=want { panic("actual Go ABI0 memmove/canary mismatch") }
+ } } }
+}
+`, len(runner) != 0)
+	t.Log("actual Go ABI0 source memmove passed all 200 overlap/unaligned/full-canary vectors")
+	file, err := Parse(ArchARM64, arm64PrivateCallCopySource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, arm64PrivateCallCopyOptions(triple))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	const driver = `#include <stdint.h>
+extern void ABI0Copy(void *, const void *, uint64_t);
+int main(void) {
+ const int offsets[]={0,1,9,17,31}, sizes[]={0,1,2,3,8,17,32,33};
+ for(int d=0;d<5;d++) for(int s=0;s<5;s++) for(int z=0;z<8;z++) {
+  unsigned char data[96], want[96], snapshot[33];
+  int dst=offsets[d],src=offsets[s],n=sizes[z];
+  for(int i=0;i<96;i++) data[i]=want[i]=(unsigned char)(i*37+dst*7+src*11+n);
+  for(int i=0;i<n;i++) snapshot[i]=data[src+i];
+  for(int i=0;i<n;i++) want[dst+i]=snapshot[i];
+  ABI0Copy(data+dst,data+src,(uint64_t)n);
+  for(int i=0;i<96;i++) if(data[i]!=want[i]) return 1;
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_call_copy", triple, module.String(), driver, runner)
+}
diff --git a/arm64_private_call_immediate_test.go b/arm64_private_call_immediate_test.go
new file mode 100644
index 000000000..8efc0ba65
--- /dev/null
+++ b/arm64_private_call_immediate_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64PrivateCallImmediateCannotObserveHiddenScratch(t *testing.T) {
+	base := arm64PrivateCallImmediateSource([]arm64ImmediateOracleCase{{op: "ADDS", value: -1, left: "R0", dest: "R1"}})
+	for _, source := range []string{
+		strings.Replace(base, "CALL immediate0<>(SB)", "CALL immediate0<>(SB)\nMOVD R27,R20", 1),
+		strings.Replace(base, "ADDS $-1,R0,R1", "ADDS $-1,R0,R1\nMOVD R27,R20", 1),
+	} {
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := CoalesceARM64PrivateRegisterHelpers(file); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("registered scratch became observable hidden data: %v", err)
+		}
+	}
+}
+
+func arm64PrivateCallImmediateCases() []arm64ImmediateOracleCase {
+	var cases []arm64ImmediateOracleCase
+	for _, form := range arm64ImmediateOracleCases() {
+		if form.left == "R0" && (form.dest == "R1" || form.dest == "") {
+			cases = append(cases, form)
+		}
+	}
+	return cases
+}
+
+func arm64PrivateCallImmediateSource(cases []arm64ImmediateOracleCase) string {
+	var root, helpers strings.Builder
+	root.WriteString("TEXT ·DivideRem(SB),4,$0-16\nMOVD input+0(FP),R10\nMOVD output+8(FP),R11\n")
+	for index, form := range cases {
+		root.WriteString("MOVD 0(R10),R0\nMOVD 8(R10),R20\nMOVD 16(R10),R6\nMOVD 24(R10),R7\nMOVD $107,R1\nCMP R7,R6\n")
+		fmt.Fprintf(&root, "CALL immediate%d<>(SB)\n", index)
+		root.WriteString("MOVD R1,(R11)\nMOVD R20,8(R11)\n")
+		root.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET HS,R4\nCSET VS,R5\nLSL $1,R3\nLSL $2,R4\nLSL $3,R5\nORR R3,R2\nORR R4,R2\nORR R5,R2\n")
+		root.WriteString("MOVD R2,16(R11)\nADD $24,R11\n")
+		fmt.Fprintf(&helpers, "TEXT immediate%d<>(SB),516,$0-0\n%s\nRET\n", index, arm64ImmediateOracleInstruction(form))
+	}
+	return root.String() + "RET\n" + helpers.String()
+}
+
+func TestARM64PrivateCallImmediateCompleteSourcePreparation(t *testing.T) {
+	cases := arm64PrivateCallImmediateCases()
+	source := arm64PrivateCallImmediateSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, base := range []string{"ADD", "ADDS", "SUB", "SUBS", "CMP", "CMN", "AND", "ANDS", "BIC", "BICS", "ORR", "ORN", "EOR", "EON", "TST"} {
+		for _, suffix := range []string{"", "W"} {
+			opcode := base + suffix
+			t.Run(opcode, func(t *testing.T) {
+				var family []arm64ImmediateOracleCase
+				for _, form := range cases {
+					if form.op == opcode {
+						family = append(family, form)
+					}
+				}
+				file, err := Parse(ArchARM64, arm64PrivateCallImmediateSource(family))
+				if err != nil || len(family) != 14 {
+					t.Fatalf("incomplete immediate family: cases=%d error=%v", len(family), err)
+				}
+				prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+				if err != nil || len(prepared.Funcs) != 1 {
+					t.Fatalf("registered unobserved immediate scratch lost its source continuation: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateCallImmediateFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	cases := arm64PrivateCallImmediateCases()
+	source := arm64PrivateCallImmediateSource(cases)
+	// The middle output independently checks preserved R20 data, not R27.
+	// Explicit R27 observation remains forbidden across private CALL roots.
+	for index := range cases {
+		cases[index].scratch = false
+	}
+	goProgram, cProgram := arm64ImmediateOraclePrograms(cases)
+	runARM64LocalRegisterGoOracle(t, source, goProgram, len(runner) != 0, "1.20")
+	for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*3) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("private-immediate-%d", api), triple, ir, cProgram, runner)
+	}
+	t.Logf("30 CALL immediate opcodes: %d cases x8 boundaries, result/NZCV/preserved GP/full canaries", len(cases))
+}
diff --git a/arm64_private_callsite_state_test.go b/arm64_private_callsite_state_test.go
new file mode 100644
index 000000000..5823a02af
--- /dev/null
+++ b/arm64_private_callsite_state_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64PrivateDistinctCallsiteSource = `TEXT ·Run(SB),4,$0-8
+MOVD $1,R9
+CALL bump<>(SB)
+MOVD $42,R0
+CALL bump<>(SB)
+ADD R9,R0,R0
+MOVD R0,ret+0(FP)
+RET
+TEXT bump<>(SB),4,$0-0
+ADD $1,R9,R9
+RET
+`
+
+func TestARM64PrivateRegisterDistinctCallsiteState(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg := mustGoPackage(t, "test/privatecalls", "package privatecalls\nfunc Run() uint64\n")
+	for _, test := range []struct {
+		name, source string
+		want         uint64
+	}{
+		{"two_static_calls", arm64PrivateDistinctCallsiteSource, 45},
+		{"BL_alias", strings.ReplaceAll(arm64PrivateDistinctCallsiteSource, "CALL bump", "BL bump"), 45},
+		{"named_label_collision", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"MOVD $1,R9", "__arm64_private_0:\n__arm64_private_0_:\n__arm64_private_1:\nMOVD $1,R9", 1), 45},
+		{"no_frame_preserves_original_LR", strings.NewReplacer(
+			"TEXT ·Run(SB),4,$0-8", "TEXT ·Run(SB),516,$0-8\nMOVD R30,R22",
+			"MOVD R0,ret+0(FP)", "MOVD R22,R30\nMOVD R0,ret+0(FP)",
+		).Replace(arm64PrivateDistinctCallsiteSource), 45},
+		{"both_branches_define", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"MOVD $42,R0", "CBNZ R9,other\nMOVD $42,R0\nB join\nother:\nMOVD $42,R0\njoin:", 1), 45},
+		{"second_static_call_in_loop", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"MOVD $42,R0\nCALL bump<>(SB)",
+			"MOVD $42,R0\nMOVD $2,R8\nagain:\nCALL bump<>(SB)\nSUB $1,R8,R8\nCBNZ R8,again", 1), 46},
+		{"distinct_callsite_flags", strings.NewReplacer(
+			"MOVD $1,R9", "MOVD $1,R9\nADDS $0,R9,R9",
+			"MOVD $42,R0", "MOVD $42,R0\nSUBS $0,R0,R0",
+			"ADD $1,R9,R9", "ADC $0,R9,R9",
+		).Replace(arm64PrivateDistinctCallsiteSource), 44},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			runARM64LocalRegisterGoOracle(t, test.source, fmt.Sprintf(`package main
+func Run() uint64
+func main() { if Run() != %d { panic("original callsite state mismatch") } }
+`, test.want), len(runner) != 0)
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = CoalesceARM64PrivateRegisterHelpers(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+			} {
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(target+"/"+api, func(t *testing.T) {
+						ir := arm64PrivateCallsiteIR(t, pkg, file, test.source, api,
+							Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs})
+						compileLLVMToObject(t, llc, target, "callsite.ll", "callsite.o", ir)
+						if target == triple {
+							main := fmt.Sprintf("#include <stdint.h>\nextern uint64_t Run(void);\nint main(void) { return Run() == %d ? 0 : 1; }\n", test.want)
+							compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "callsite-state", target, ir, main, runner)
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func arm64PrivateCallsiteIR(t *testing.T, pkg GoPackage, file *File, source, api string, opt Options) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	var ir string
+	var err error
+	switch api {
+	case "text":
+		ir, err = Translate(file, opt)
+	case "module":
+		var module llvm.Module
+		module, err = TranslateModuleInContext(ctx, file, opt)
+		if !module.IsNil() {
+			defer module.Dispose()
+			ir = module.String()
+		}
+	case "GoModule":
+		var result *GoModuleTranslation
+		result, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: opt.Goarch, TargetTriple: opt.TargetTriple, ResolveSym: opt.ResolveSym,
+		})
+		if result != nil && !result.Module.IsNil() {
+			defer result.Module.Dispose()
+			ir = result.Module.String()
+		}
+	default:
+		t.Fatalf("unknown callsite API %q", api)
+	}
+	if err != nil {
+		t.Fatalf("%s/%s: a closed helper lost its per-call reaching write: %v", opt.TargetTriple, api, err)
+	}
+	return ir
+}
+
+func TestARM64PrivateRegisterCallsiteSourceExpansion(t *testing.T) {
+	const calls = 128
+	source := "TEXT ·Run(SB),4,$0-8\nMOVD $1,R9\n" +
+		strings.Repeat("CALL bump<>(SB)\n", calls) +
+		"MOVD R9,ret+0(FP)\nRET\nTEXT bump<>(SB),4,$0-0\nADD $1,R9,R9\nRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(file, original) || len(prepared.Funcs) != 1 {
+		t.Fatal("per-call source expansion mutated the original source")
+	}
+	fn := prepared.Funcs[0]
+	cloneLength := len(original.Funcs[1].Instrs) // LABEL + leaf body + B (R30).
+	if len(fn.Instrs) != len(original.Funcs[0].Instrs)+calls*cloneLength {
+		t.Fatal("source expansion did not grow exactly once per static call")
+	}
+	labels := make(map[string]bool)
+	for _, ins := range fn.Instrs {
+		if ins.Op != "CALL" {
+			continue
+		}
+		if len(ins.Args) != 1 || ins.Args[0].Kind != OpIdent || labels[ins.Args[0].Ident] {
+			t.Fatalf("static calls share an indirect return edge: %+v", ins)
+		}
+		labels[ins.Args[0].Ident] = true
+	}
+	if len(labels) != calls {
+		t.Fatal("source expansion dropped a static call")
+	}
+	again, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil || !reflect.DeepEqual(again, prepared) {
+		t.Fatalf("identical complete source did not prepare deterministically: %v", err)
+	}
+	idempotent, err := CoalesceARM64PrivateRegisterHelpers(prepared)
+	if err != nil || !reflect.DeepEqual(idempotent, prepared) {
+		t.Fatalf("repeated preparation duplicated helper bodies: %v", err)
+	}
+}
+
+func TestARM64PrivateRegisterCallsiteExpansionBudget(t *testing.T) {
+	// Pin the reviewed duplication budget, independently of its implementation.
+	const budget = 1 << 16
+	for _, test := range []struct {
+		name       string
+		leafLength int
+		calls      []int
+		wantError  bool
+	}{
+		{"exact_budget", budget / 32, []int{32}, false},
+		{"one_instruction_per_clone_over", budget/32 + 1, []int{32}, true},
+		{"combined_roots_over", budget / 32, []int{16, 17}, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			var source strings.Builder
+			for root, calls := range test.calls {
+				fmt.Fprintf(&source, "TEXT ·Run%d(SB),4,$0-8\nMOVD $1,R9\n", root)
+				source.WriteString(strings.Repeat("CALL bump<>(SB)\n", calls))
+				source.WriteString("MOVD R9,ret+0(FP)\nRET\n")
+			}
+			source.WriteString("TEXT bump<>(SB),4,$0-0\n")
+			source.WriteString(strings.Repeat("ADD $1,R9,R9\n", test.leafLength-2))
+			source.WriteString("RET\n")
+			goAssemblerOracleOutput(t, "arm64", source.String(), "", true)
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			original, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+			if !reflect.DeepEqual(file, original) {
+				t.Fatal("expansion budget mutated the authenticated original source")
+			}
+			if test.wantError {
+				if prepared != nil || !errors.Is(err, ErrProbeNeedsContext) ||
+					!strings.Contains(err.Error(), "expansion budget") {
+					t.Fatalf("unbounded source duplication did not fail closed: %v", err)
+				}
+			} else if err != nil || prepared == nil || len(prepared.Funcs) != len(test.calls) {
+				t.Fatalf("source at the exact duplication budget was rejected: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateRegisterCallsiteDoesNotSupplyUndefinedBits(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privatecalls", "package privatecalls\nfunc Run() uint64\n")
+	tests := []struct{ name, source, witness string }{
+		{"first_call_reads_missing", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"ADD $1,R9,R9", "ADD R0,R9,R9", 1), "R0"},
+		{"caller_missing_before_second", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"MOVD $42,R0\n", "", 1), "R0"},
+		{"one_branch_missing_before_second", strings.Replace(arm64PrivateDistinctCallsiteSource,
+			"MOVD $42,R0", "CBNZ R9,missing\nMOVD $42,R0\nmissing:", 1), "R0"},
+		{"same_static_loop_first_visit_missing", strings.NewReplacer(
+			"CALL bump<>(SB)\nMOVD $42,R0\nCALL bump<>(SB)",
+			"MOVD $2,R8\nagain:\nCALL bump<>(SB)\nMOVD $42,R0\nSUB $1,R8,R8\nCBNZ R8,again",
+			"ADD $1,R9,R9", "ADD R0,R9,R9",
+		).Replace(arm64PrivateDistinctCallsiteSource), "R0"},
+	}
+	for _, flag := range []struct {
+		name, instruction, condition string
+		missingMask                  uint8
+	}{
+		{"C", "ADC $0,R9,R9", "ADC", 0x2},
+		{"N", "CSEL MI,R9,R9,R9", "MI", 0x8},
+		{"Z", "CSEL EQ,R9,R9,R9", "EQ", 0x4},
+		{"V", "CSEL VS,R9,R9,R9", "VS", 0x1},
+	} {
+		// The second call has a real ADDS producer. Its flags cannot supply
+		// the first invocation of the same private helper on any CFG path.
+		source := strings.NewReplacer(
+			"MOVD $42,R0", "MOVD $42,R0\nADDS $1,R0,R0",
+			"ADD $1,R9,R9", flag.instruction,
+		).Replace(arm64PrivateDistinctCallsiteSource)
+		witness := fmt.Sprintf("arm64 condition %s has unknown NZCV bits %#x on a path to block ",
+			flag.condition, flag.missingMask)
+		tests = append(tests, struct{ name, source, witness string }{
+			"first_call_missing_flags_" + flag.name, source, witness,
+		})
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "arm64", test.source, "", true)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			translation, err := translateGoModuleInContext(ctx, pkg, []byte(test.source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+			})
+			if translation != nil && !translation.Module.IsNil() {
+				translation.Module.Dispose()
+				t.Fatal("undefined source register emitted a module")
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), test.witness) {
+				t.Fatalf("a callsite manufactured defined register bits or flags: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_private_continuation_file.go b/arm64_private_continuation_file.go
new file mode 100644
index 000000000..d5cefa5a0
--- /dev/null
+++ b/arm64_private_continuation_file.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "strings"
+
+// A prepared root seals its cloned instructions, not mutable siblings or DATA.
+// Reaudit the complete supplied file on every preparation/final API entry. All
+// three source-continuation families remove a native TEXT identity; none may
+// regain that identity through newly added source after its initial audit.
+func validateARM64PrivateContinuationFile(file *File) error {
+	removed := make(map[string]bool)
+	hasCallContinuation := false
+	add := func(helpers []Func) {
+		for _, helper := range helpers {
+			removed[helper.Sym] = true
+		}
+	}
+	for _, fn := range file.Funcs {
+		if proof := fn.arm64PrivateCallSource; proof != nil {
+			hasCallContinuation = true
+			add(proof.helpers)
+		}
+		if proof := fn.arm64PrivateTailSource; proof != nil {
+			add(proof.helpers)
+		}
+		if proof := fn.arm64ABI0TailSource; proof != nil {
+			add(proof.helpers)
+		}
+	}
+	if len(removed) == 0 {
+		return nil
+	}
+	if len(file.UnlinkedPrelude) != 0 {
+		return arm64GoABIContext("private continuation file has an unbound native prelude")
+	}
+	refersToRemoved := func(symbol string) bool {
+		base, _, ok := arm64PrivateSymbolRef(symbol)
+		return ok && removed[base]
+	}
+	for _, data := range file.Data {
+		if refersToRemoved(data.Sym) || refersToRemoved(data.Addr) {
+			return arm64GoABIContext("private continuation file recovers a removed helper through DATA")
+		}
+	}
+	for _, global := range file.Globl {
+		if refersToRemoved(global.Sym) {
+			return arm64GoABIContext("private continuation file recovers a removed helper through GLOBL")
+		}
+	}
+	for _, fn := range file.Funcs {
+		if removed[fn.Sym] {
+			return arm64GoABIContext("private continuation file redefines removed helper %q", fn.Sym)
+		}
+		for _, ins := range fn.Instrs {
+			// Tail-only files independently exclude native PC/raw/address
+			// observers below, so validated NOP padding has no data effect.
+			// CALL continuations retain their stricter layout contract.
+			if _, alignment, err := arm64PCAlignment(ins); alignment && (err != nil || hasCallContinuation) {
+				return arm64GoABIContext("private continuation file has unproved alignment at %q", ins.Raw)
+			}
+			switch ins.Op {
+			case OpWORD, "DWORD", "ADR", "ADRP":
+				return arm64GoABIContext("private continuation file observes native layout at %q", ins.Raw)
+			}
+			for _, arg := range ins.Args {
+				memory, hasMemory := arg.Mem, arg.Kind == OpMem
+				if arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$") {
+					memory, hasMemory = parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$")))
+				}
+				if hasMemory && (memory.Base == PC || refersToRemoved(memory.Sym)) {
+					return arm64GoABIContext("private continuation file has a native PC/removed-helper memory use at %q", ins.Raw)
+				}
+				if arg.Kind == OpSym && refersToRemoved(arg.Sym) {
+					return arm64GoABIContext("private continuation file recovers removed helper identity at %q", ins.Raw)
+				}
+			}
+		}
+	}
+	return nil
+}
diff --git a/arm64_private_data_access.go b/arm64_private_data_access.go
new file mode 100644
index 000000000..e5bdf1b0a
--- /dev/null
+++ b/arm64_private_data_access.go
@@ -0,0 +1,280 @@
+package plan9asm
+
+import (
+	"math"
+	"strings"
+)
+
+// Half-open envelope of every effective byte written by this instruction on
+// every reaching path. This is not an exemption for other stores in the function.
+type arm64PrivateDataSpan struct {
+	low, end int64
+}
+
+func arm64PrivateDataMemory(ins Instr) (arm64RawPrivateMemoryForm, bool) {
+	// Share Go's literal-zero alias with the scalar memory grammar. Nonzero,
+	// unresolved and floating immediates cannot be interpreted as ZR stores.
+	if len(ins.Args) == 2 && ins.Args[0].Kind == OpImm && ins.Args[0].Imm == 0 &&
+		ins.Args[0].ImmRaw == "" && !ins.Args[0].ImmIsFloat {
+		switch arm64ControlOp(ins) {
+		case "MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD":
+			ins.Args = append([]Operand(nil), ins.Args...)
+			ins.Args[0] = Operand{Kind: OpReg, Reg: ZR}
+		}
+	}
+	return arm64RawPrivateMemory(ins)
+}
+
+func (state *arm64PrivateDataState) memory(op Op, form arm64RawPrivateMemoryForm, frameSize int64) (*arm64PrivateDataSpan, bool) {
+	var address arm64PrivateDataValue
+	local := false
+	if form.memory.Kind == OpMem {
+		mem := form.memory.Mem
+		address = state.value(mem.Base)
+		index := state.value(mem.Index)
+		if mem.Index != "" && index.frame {
+			return nil, false
+		}
+		local = address.frame
+		if local {
+			if address.mixed || mem.OffRaw != "" || mem.Sym != "" || mem.IndexExt != "" || mem.Segment != "" {
+				return nil, false
+			}
+			offset := mem.Off
+			if form.post {
+				offset = 0
+			}
+			if offset == math.MinInt64 ||
+				offset < 0 && address.interval.low < uint64(-offset) ||
+				offset > 0 && address.interval.high > math.MaxUint64-uint64(offset) {
+				return nil, false
+			}
+			address.interval.low += uint64(offset)
+			address.interval.high += uint64(offset)
+			if mem.Index != "" {
+				scale := mem.Scale
+				if scale == 0 {
+					scale = 1
+				}
+				if scale < 1 || scale > 16 || index.interval.high > math.MaxUint64/uint64(scale) {
+					return nil, false
+				}
+				low, high := index.interval.low*uint64(scale), index.interval.high*uint64(scale)
+				if high > math.MaxUint64-address.interval.high {
+					return nil, false
+				}
+				address.interval.low += low
+				address.interval.high += high
+			}
+		}
+	}
+	width := form.elementBytes * int64(len(form.registers))
+	var span *arm64PrivateDataSpan
+	if local {
+		if width <= 0 || frameSize < 0 || frameSize > arm64MaxLocalStackSpan ||
+			address.interval.high > uint64(frameSize+8) || uint64(width) > uint64(frameSize+8)-address.interval.high {
+			return nil, false
+		}
+		if form.store {
+			if address.interval.low < 8 {
+				return nil, false // The saved caller link is not private data.
+			}
+			span = &arm64PrivateDataSpan{int64(address.interval.low), int64(address.interval.high) + width}
+		}
+	}
+	if form.scratch != nil {
+		f := *form.scratch
+		value := arm64PrivateDataUnknown
+		if f.scratchAddress && f.scratchBase != "" {
+			value = state.value(f.scratchBase)
+			if f.scratchKnown && !value.mixed && f.scratchOffset >= 0 &&
+				value.interval.high <= math.MaxUint64-uint64(f.scratchOffset) {
+				value.interval.low += uint64(f.scratchOffset)
+				value.interval.high += uint64(f.scratchOffset)
+			} else {
+				value.interval = arm64PoolUnknownInterval
+				value.mixed = value.frame
+			}
+		} else if f.scratchKnown {
+			value = arm64PrivateDataNumber(arm64PoolInterval{uint64(f.scratchOffset), uint64(f.scratchOffset)})
+		}
+		if !state.assign("R27", value) {
+			return nil, false
+		}
+	}
+	for index, reg := range form.registers {
+		if form.store {
+			if state.value(reg).frame {
+				return nil, false // Even a private spill would expose an address.
+			}
+			if local {
+				low := address.interval.low + uint64(index)*uint64(form.elementBytes)
+				high := address.interval.high + uint64(index+1)*uint64(form.elementBytes)
+				for cell := range state.cells {
+					if uint64(cell) < high && low < uint64(cell)+8 {
+						delete(state.cells, cell)
+					}
+				}
+				if form.gp && form.elementBytes == 8 && address.interval.low == address.interval.high {
+					state.cells[int64(low)] = state.value(reg).interval
+				}
+				if state.initialized != nil && address.interval.low == address.interval.high {
+					for offset := int64(low); offset < int64(high); offset++ {
+						state.initialized[offset] = true
+					}
+				}
+			}
+		} else if form.gp {
+			value := arm64PoolUnknownInterval
+			if local && form.elementBytes == 8 && address.interval.low == address.interval.high {
+				if stored, present := state.cells[int64(address.interval.low)+int64(index)*8]; present {
+					value = stored
+				}
+			}
+			signed := op == "MOVB" || op == "MOVH" || op == "MOVW" || op == "MOVBW" || op == "MOVHW" || op == "LDPSW"
+			value = arm64PrivateDataNarrow(value, form.elementBytes, signed)
+			if op == "MOVBW" || op == "MOVHW" {
+				value = arm64PoolMaskInterval(value, math.MaxUint32)
+			}
+			if !state.assign(reg, arm64PrivateDataNumber(value)) {
+				return nil, false
+			}
+		}
+	}
+	if (form.pre || form.post) && form.memory.Kind == OpMem {
+		mem := form.memory.Mem
+		value := state.value(mem.Base)
+		if value.frame {
+			if arm64StackReg(mem.Base) || value.mixed || mem.Off == math.MinInt64 ||
+				mem.Off < 0 && value.interval.low < uint64(-mem.Off) ||
+				mem.Off > 0 && uint64(mem.Off) > uint64(frameSize+8)-value.interval.high {
+				return nil, false
+			}
+			value.interval.low += uint64(mem.Off)
+			value.interval.high += uint64(mem.Off)
+			if !state.assign(mem.Base, value) {
+				return nil, false
+			}
+		} else {
+			state.assign(mem.Base, arm64PrivateDataUnknown)
+		}
+	}
+	return span, true
+}
+
+func (state *arm64PrivateDataState) transfer(ins Instr, at int, frameSize int64) (*arm64PrivateDataSpan, bool) {
+	op := arm64ControlOp(ins)
+	if state.initialized != nil && op != OpTEXT {
+		if !arm64NanosleepNumericalInstruction(ins) {
+			return nil, false
+		}
+		for _, operand := range ins.Args {
+			for _, reg := range []Reg{operand.Reg, operand.ShiftReg, operand.Mem.Base, operand.Mem.Index} {
+				if reg == "R29" || reg == "R30" {
+					return nil, false // native FP/LR is not a numerical initializer
+				}
+			}
+			for _, reg := range operand.RegList {
+				if reg == "R29" || reg == "R30" {
+					return nil, false
+				}
+			}
+			if operand.Kind == OpFPAddr || operand.Kind == OpSym ||
+				operand.Kind == OpMem && !state.value(operand.Mem.Base).frame {
+				return nil, false // no external/native backing or pointer escape
+			}
+		}
+	}
+	if immediate, handled, err := parseARM64GPImmediateForm(op, ins); handled {
+		if err != nil {
+			return nil, false
+		}
+		if immediate.scratch && !state.assign("R27", arm64PrivateDataNumber(arm64PoolInterval{immediate.value, immediate.value})) {
+			return nil, false
+		}
+	}
+	if op == OpTEXT || op == "NOP" {
+		return nil, true
+	}
+	if form, handled, err := parseARM64RegisterAddressForm(op, ins); handled {
+		if err != nil || form.usesScratch {
+			return nil, false
+		}
+		value := state.value(form.base)
+		if value.frame {
+			if value.mixed || form.offset == math.MinInt64 ||
+				form.offset < 0 && value.interval.low < uint64(-form.offset) ||
+				form.offset > 0 && uint64(form.offset) > uint64(frameSize+8)-value.interval.high {
+				return nil, false
+			}
+			value.interval.low += uint64(form.offset)
+			value.interval.high += uint64(form.offset)
+			value.origin = at
+		}
+		return nil, state.assign(form.destination, value)
+	}
+	if form, known := arm64PrivateDataMemory(ins); known {
+		return state.memory(op, form, frameSize)
+	}
+	if op == "CMP" || op == "CMPW" {
+		return nil, state.compare(ins)
+	}
+	if handled, valid := state.arithmetic(ins, at, frameSize); handled {
+		return nil, valid
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg && string(ins.Op) == string(op) {
+		dst, src := ins.Args[1].Reg, ins.Args[0]
+		if op == "MOVD" || op == "MOVB" || op == "MOVBU" || op == "MOVH" || op == "MOVHU" || op == "MOVW" || op == "MOVWU" {
+			if src.Kind == OpReg || src.Kind == OpImm {
+				value, valid := state.operand(src, 64)
+				if !valid || value.frame && op != "MOVD" {
+					return nil, false
+				}
+				if op != "MOVD" {
+					signed := src.Kind != OpImm && (op == "MOVB" || op == "MOVH" || op == "MOVW")
+					value.interval = arm64PrivateDataNarrow(value.interval, arm64RawPrivateScalarBytes(op), signed)
+				}
+				return nil, state.assign(dst, value)
+			}
+			if src.Kind == OpFP || src.Kind == OpSym && strings.HasSuffix(src.Sym, "(SB)") {
+				return nil, state.assign(dst, arm64PrivateDataUnknown)
+			}
+		}
+		if op == "MOVK" || op == "MOVKW" {
+			value := state.value(dst)
+			if value.frame {
+				return nil, false
+			}
+			return nil, state.assign(dst, arm64PrivateDataUnknown)
+		}
+	}
+	// The original may-frame transfer rejects unrecognized uses, address stores,
+	// SIMD transports and exception observers. Unknown numeric results lose all
+	// bounds, rather than retaining a previous mask/shift fact.
+	addresses := state.addresses()
+	if !addresses.transfer(ins, frameSize) {
+		return nil, false
+	}
+	state.comparison = arm64PrivateDataCompare{}
+	if form, handled, err := parseARM64GPDataForm(op, ins); handled {
+		if err != nil {
+			return nil, false
+		}
+		for _, reg := range arm64GPDataOutputRegisters(form) {
+			if form.scratch != nil && reg == "R27" && form.destination.Reg != "R27" {
+				continue
+			}
+			if !state.assign(reg, arm64PrivateDataUnknown) {
+				return nil, false
+			}
+		}
+		return nil, true
+	}
+	if len(ins.Args) != 0 {
+		dst := ins.Args[len(ins.Args)-1]
+		if dst.Kind == OpReg && isARM64GeneralOrZeroReg(dst.Reg) {
+			return nil, state.assign(dst.Reg, arm64PrivateDataUnknown)
+		}
+	}
+	return nil, true
+}
diff --git a/arm64_private_data_family_test.go b/arm64_private_data_family_test.go
new file mode 100644
index 000000000..984e11eb5
--- /dev/null
+++ b/arm64_private_data_family_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64PrivateDataCase struct {
+	name, store, load string
+	width, count      int
+	signed, floating  bool
+	zero              string
+	mode              string
+}
+
+func arm64PrivateDataCases() []arm64PrivateDataCase {
+	var cases []arm64PrivateDataCase
+	for _, shape := range []arm64PrivateDataCase{
+		{store: "MOVB", load: "MOVBU", width: 1, count: 1},
+		{store: "MOVBU", load: "MOVBU", width: 1, count: 1},
+		{store: "MOVH", load: "MOVHU", width: 2, count: 1},
+		{store: "MOVHU", load: "MOVHU", width: 2, count: 1},
+		{store: "MOVW", load: "MOVWU", width: 4, count: 1},
+		{store: "MOVWU", load: "MOVWU", width: 4, count: 1},
+		{store: "MOVD", load: "MOVD", width: 8, count: 1},
+		{store: "MOVB", load: "MOVB", width: 1, count: 1, signed: true},
+		{store: "MOVH", load: "MOVH", width: 2, count: 1, signed: true},
+		{store: "MOVW", load: "MOVW", width: 4, count: 1, signed: true},
+		{store: "FMOVS", load: "FMOVS", width: 4, count: 1, floating: true},
+		{store: "FMOVD", load: "FMOVD", width: 8, count: 1, floating: true},
+		{store: "FMOVQ", load: "FMOVQ", width: 16, count: 1, floating: true},
+		{store: "STPW", load: "LDPW", width: 4, count: 2},
+		{store: "STPW", load: "LDPSW", width: 4, count: 2, signed: true},
+		{store: "STP", load: "LDP", width: 8, count: 2},
+		{store: "FSTPS", load: "FLDPS", width: 4, count: 2, floating: true},
+		{store: "FSTPD", load: "FLDPD", width: 8, count: 2, floating: true},
+		{store: "FSTPQ", load: "FLDPQ", width: 16, count: 2, floating: true},
+	} {
+		modes := []string{"offset", "pre_post", "post_pre"}
+		if shape.count == 1 {
+			modes = append(modes, "unscaled")
+			if shape.width < 16 {
+				modes = append(modes, "indexed", "indexed_scaled")
+			}
+		}
+		for _, mode := range modes {
+			current := shape
+			current.mode = mode
+			current.name = fmt.Sprintf("Data%d", len(cases))
+			cases = append(cases, current)
+		}
+		if shape.count == 1 && !shape.floating && !shape.signed {
+			for _, zero := range []string{"ZR", "$0"} {
+				for _, mode := range []string{"offset", "pre_post", "post_pre", "indexed", "indexed_scaled"} {
+					current := shape
+					current.zero, current.mode = zero, mode
+					current.name = fmt.Sprintf("Data%d", len(cases))
+					cases = append(cases, current)
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func arm64PrivateDataFamilyFixture() (string, string, []arm64PrivateDataCase) {
+	cases := arm64PrivateDataCases()
+	var source, declarations strings.Builder
+	source.WriteString("#include \"textflag.h\"\n")
+	for _, tc := range cases {
+		fmt.Fprintf(&declarations, "func %s(src,dst *byte)\n", tc.name)
+		fmt.Fprintf(&source, `TEXT ·%s(SB),NOSPLIT,$128-16
+    CALL ·Noop(SB)
+    MOVD src+0(FP),R6
+    MOVD dst+8(FP),R7
+    ADD $32,RSP,R17
+`, tc.name)
+		input, output := "R4", "R9"
+		if tc.floating {
+			source.WriteString("    FMOVQ (R6),F0\n    FMOVQ 16(R6),F1\n")
+			input, output = "F0", "F2"
+		} else {
+			source.WriteString("    MOVD (R6),R4\n    MOVD 8(R6),R5\n")
+		}
+		if tc.zero != "" {
+			input = tc.zero
+		}
+		if tc.count == 2 {
+			input, output = "(R4,R5)", "(R9,R10)"
+			if tc.floating {
+				input, output = "(F0,F1)", "(F2,F3)"
+			}
+		}
+		storeOp, loadOp := tc.store, tc.load
+		storeAddress, loadAddress := "16(R17)", "16(R17)"
+		switch tc.mode {
+		case "pre_post":
+			storeOp, loadOp = tc.store+".W", tc.load+".P"
+			storeAddress, loadAddress = "16(R17)", "-16(R17)"
+		case "post_pre":
+			storeOp, loadOp = tc.store+".P", tc.load+".W"
+			storeAddress, loadAddress = "16(R17)", "-16(R17)"
+		case "unscaled":
+			storeAddress, loadAddress = "9(R17)", "9(R17)"
+		case "indexed":
+			source.WriteString("    MOVD $7,R11\n")
+			storeAddress, loadAddress = "(R17)(R11)", "(R17)(R11)"
+		case "indexed_scaled":
+			source.WriteString("    MOVD $7,R11\n")
+			shift := map[int]int{1: 0, 2: 1, 4: 2, 8: 3}[tc.width]
+			storeAddress = fmt.Sprintf("(R17)(R11<<%d)", shift)
+			loadAddress = storeAddress
+		}
+		fmt.Fprintf(&source, "    %s %s,%s\n    %s %s,%s\n", storeOp, input, storeAddress, loadOp, loadAddress, output)
+		if tc.floating {
+			outputOp := map[int]string{4: "FMOVS", 8: "FMOVD", 16: "FMOVQ"}[tc.width]
+			fmt.Fprintf(&source, "    %s F2,(R7)\n", outputOp)
+			if tc.count == 2 {
+				fmt.Fprintf(&source, "    %s F3,%d(R7)\n", outputOp, tc.width)
+			}
+		} else {
+			source.WriteString("    MOVD R9,(R7)\n")
+			if tc.count == 2 {
+				source.WriteString("    MOVD R10,8(R7)\n")
+			}
+		}
+		source.WriteString("    RET\n")
+	}
+	source.WriteString("TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0\n    RET\n")
+	return source.String(), declarations.String(), cases
+}
+
+func arm64PrivateDataExpected(tc arm64PrivateDataCase, input [32]byte) [32]byte {
+	var expected [32]byte
+	for index := range expected {
+		expected[index] = 0xa7
+	}
+	if tc.floating {
+		for index := 0; index < tc.count; index++ {
+			copy(expected[index*tc.width:(index+1)*tc.width], input[index*16:index*16+tc.width])
+		}
+		return expected
+	}
+	for index := 0; index < tc.count; index++ {
+		value := binary.LittleEndian.Uint64(input[index*8 : (index+1)*8])
+		if tc.width < 8 {
+			mask := uint64(1)<<uint(tc.width*8) - 1
+			value &= mask
+			if tc.signed && value&(uint64(1)<<uint(tc.width*8-1)) != 0 {
+				value |= ^mask
+			}
+		}
+		if tc.zero != "" {
+			value = 0
+		}
+		binary.LittleEndian.PutUint64(expected[index*8:(index+1)*8], value)
+	}
+	return expected
+}
+
+func TestARM64PrivateDataMemoryFamilyObjects(t *testing.T) {
+	source, declarations, cases := arm64PrivateDataFamilyFixture()
+	arm64PrivateDataBoundObjects(t, source, declarations, "private-data-family")
+	t.Logf("%d named scalar/pair GP/FP widths, sign, zero aliases and offset/pre/post/unscaled/indexed forms: actual Go + 3 APIs x 4 targets", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateDataMemoryFamily(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, declarations, cases := arm64PrivateDataFamilyFixture()
+	var goSource, cSource strings.Builder
+	goSource.WriteString("package main\n" + declarations + "func Noop()\nfunc main() {\n")
+	cSource.WriteString("#include <stdint.h>\n#include <string.h>\n")
+	for _, tc := range cases {
+		fmt.Fprintf(&cSource, "extern void %s(const uint8_t *,uint8_t *);\n", tc.name)
+	}
+	cSource.WriteString("int main(void) {\n")
+	// These are ordinary numeric data and output buffers. No physical caller
+	// stack or return address is inspected or modified by either oracle.
+	for pattern := 0; pattern < 3; pattern++ {
+		var input [32]byte
+		for index := range input {
+			input[index] = byte(index*71 + 0x8f + pattern*97)
+		}
+		for _, tc := range cases {
+			expected := arm64PrivateDataExpected(tc, input)
+			fmt.Fprintf(&goSource, `    {
+        input := %#v
+        expected := %#v
+        var output [48]byte
+        for i := range output { output[i] = 0xa7 }
+        %s(&input[0],&output[8])
+        for i := range output {
+            want := byte(0xa7)
+            if i>=8 && i<40 { want=expected[i-8] }
+            if output[i]!=want { panic(%q) }
+        }
+    }
+`, input, expected, tc.name, "private data family value/canary "+tc.name)
+			fmt.Fprintf(&cSource, `    {
+        const uint8_t input[] = {%s};
+        const uint8_t expected[] = {%s};
+        uint8_t output[48];
+        memset(output,0xa7,sizeof(output));
+        %s(input,output+8);
+        for(unsigned i=0;i<sizeof(output);i++) {
+            uint8_t want=(i>=8 && i<40)?expected[i-8]:UINT8_C(0xa7);
+            if(output[i]!=want) return %d;
+        }
+    }
+`, arm64PrivateDataCBytes(input[:]), arm64PrivateDataCBytes(expected[:]), tc.name, pattern+1)
+		}
+	}
+	goSource.WriteString("}\n")
+	cSource.WriteString("    return 0;\n}\n")
+	runARM64LocalRegisterGoOracle(t, source, goSource.String(), len(runner) != 0, "1.20")
+	ir := arm64PrivateIndexedModule(t, source, declarations, target)
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_data_family", target, ir, cSource.String(), runner)
+	t.Logf("actual Go and LLVM/C passed %d initialized numerical/full-canary cases", len(cases)*3)
+}
+
+func arm64PrivateDataCBytes(data []byte) string {
+	values := make([]string, len(data))
+	for index, value := range data {
+		values[index] = fmt.Sprintf("%d", value)
+	}
+	return strings.Join(values, ",")
+}
diff --git a/arm64_private_data_flow.go b/arm64_private_data_flow.go
new file mode 100644
index 000000000..e4c2830fc
--- /dev/null
+++ b/arm64_private_data_flow.go
@@ -0,0 +1,447 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+type arm64PrivateDataCompare struct {
+	left, right       arm64PrivateDataValue
+	leftReg, rightReg Reg
+	valid             bool
+}
+
+type arm64PrivateDataState struct {
+	regs        map[Reg]arm64PrivateDataValue
+	cells       map[int64]arm64PoolInterval
+	comparison  arm64PrivateDataCompare
+	initialized map[int64]bool // present only for the bounded syscall collector
+}
+
+func newARM64PrivateDataState() *arm64PrivateDataState {
+	return &arm64PrivateDataState{regs: make(map[Reg]arm64PrivateDataValue), cells: make(map[int64]arm64PoolInterval)}
+}
+
+func (state *arm64PrivateDataState) clone() *arm64PrivateDataState {
+	copy := newARM64PrivateDataState()
+	for reg, value := range state.regs {
+		copy.regs[reg] = value
+	}
+	for offset, value := range state.cells {
+		copy.cells[offset] = value
+	}
+	copy.comparison = state.comparison
+	if state.initialized != nil {
+		copy.initialized = make(map[int64]bool, len(state.initialized))
+		for offset := range state.initialized {
+			copy.initialized[offset] = true
+		}
+	}
+	return copy
+}
+
+func (state *arm64PrivateDataState) merge(other *arm64PrivateDataState, widen bool) bool {
+	old := state.clone()
+	registers := make(map[Reg]bool, len(state.regs)+len(other.regs))
+	for reg := range state.regs {
+		registers[reg] = true
+	}
+	for reg := range other.regs {
+		registers[reg] = true
+	}
+	for reg := range registers {
+		state.regs[reg] = arm64PrivateDataUnion(state.value(reg), other.value(reg), widen)
+	}
+	for offset, value := range state.cells {
+		incoming, present := other.cells[offset]
+		if !present {
+			delete(state.cells, offset)
+			continue
+		}
+		joined := arm64PrivateDataUnion(arm64PrivateDataNumber(value), arm64PrivateDataNumber(incoming), widen)
+		state.cells[offset] = joined.interval
+	}
+	if state.comparison != other.comparison {
+		state.comparison = arm64PrivateDataCompare{}
+	}
+	for offset := range state.initialized {
+		if !other.initialized[offset] {
+			delete(state.initialized, offset)
+		}
+	}
+	return !reflect.DeepEqual(old, state)
+}
+
+func (state *arm64PrivateDataState) addresses() arm64PrivateFrameAddresses {
+	addresses := make(arm64PrivateFrameAddresses)
+	for reg, value := range state.regs {
+		if value.frame {
+			addresses[reg] = arm64PrivateFrameAddress{
+				offset: int64(value.interval.low), exact: !value.mixed && value.interval.low == value.interval.high,
+			}
+		}
+	}
+	return addresses
+}
+
+func (state *arm64PrivateDataState) consume(ins Instr, transport *arm64PrivateFrameTransport, internal bool) bool {
+	addresses := state.addresses()
+	if transport == nil || !transport.consume(ins, addresses, internal) {
+		return false
+	}
+	if arm64ControlOp(ins) == OpRET {
+		return true
+	}
+	name := strings.TrimSuffix(ins.Args[0].Sym, "(SB)")
+	if transport.resolve != nil {
+		name = transport.resolve(name)
+	}
+	sig, present := transport.sigs[name]
+	if !present {
+		return false
+	}
+	result := &arm64ControlState{regs: make(map[Reg]arm64ControlValue), memory: make(map[string]arm64ControlValue)}
+	arm64ControlWriteCallResults(result, sig, strings.HasSuffix(ins.Args[0].Sym, "<ABIInternal>(SB)"), arm64ControlExternal())
+	for reg := range result.regs {
+		if isARM64GeneralOrZeroReg(reg) {
+			state.assign(reg, arm64PrivateDataUnknown)
+		}
+	}
+	// Typed callees cannot access an unescaped fresh private frame. Explicit
+	// ABI0 result transport still overwrites its complete/overlapping cells.
+	for key := range result.memory {
+		var offset int64
+		if len(key) < 4 || key[:3] != "sp:" {
+			continue
+		}
+		var err error
+		offset, err = strconv.ParseInt(key[3:], 10, 64)
+		if err != nil {
+			return false
+		}
+		for cell := range state.cells {
+			if offset < cell+8 && cell < offset+8 {
+				delete(state.cells, cell)
+			}
+		}
+	}
+	state.comparison = arm64PrivateDataCompare{}
+	return true
+}
+
+func (state *arm64PrivateDataState) compare(ins Instr) bool {
+	if string(ins.Op) != "CMP" && string(ins.Op) != "CMPW" || len(ins.Args) != 2 {
+		return false
+	}
+	width := uint(64)
+	if ins.Op == "CMPW" {
+		width = 32
+	}
+	right, ok := state.operand(ins.Args[0], width)
+	if !ok {
+		return false
+	}
+	left, ok := state.operand(ins.Args[1], width)
+	if !ok || left.frame != right.frame || left.frame && (left.mixed || right.mixed) {
+		return false
+	}
+	state.comparison = arm64PrivateDataCompare{left: left, right: right, valid: true}
+	if width == 32 {
+		// Signed word comparisons need a signed interval domain. Losing this
+		// optional narrowing cannot authorize an otherwise unbounded access.
+		state.comparison.valid = false
+	}
+	if ins.Args[1].Kind == OpReg {
+		state.comparison.leftReg = ins.Args[1].Reg
+	}
+	if ins.Args[0].Kind == OpReg {
+		state.comparison.rightReg = ins.Args[0].Reg
+	}
+	return true
+}
+
+func (state *arm64PrivateDataState) branch(op Op, taken bool) (*arm64PrivateDataState, bool) {
+	next := state.clone()
+	comparison := state.comparison
+	if !comparison.valid {
+		return next, true
+	}
+	for _, input := range []struct {
+		reg   Reg
+		value arm64PrivateDataValue
+	}{{comparison.leftReg, comparison.left}, {comparison.rightReg, comparison.right}} {
+		if input.reg != "" && state.value(input.reg) != input.value {
+			// A whole-CFG may-frame join can weaken a disjunct's register
+			// category without changing its old flag snapshot. Optional
+			// narrowing must not restore that stale exact address/value.
+			return next, true
+		}
+	}
+	// Signed comparisons of unknown integers and addresses do not acquire an
+	// unsigned range merely because their current extrema look convenient.
+	signed := op == "BGE" || op == "BLT" || op == "BGT" || op == "BLE"
+	if signed && (comparison.left.frame || comparison.left.interval.high > math.MaxInt64 || comparison.right.interval.high > math.MaxInt64) {
+		return next, true
+	}
+	relation := ""
+	switch op {
+	case "BHI", "BGT":
+		relation = ">"
+	case "BLS", "BLE":
+		relation = "<="
+	case "BHS", "BCS", "BGE":
+		relation = ">="
+	case "BLO", "BCC", "BLT":
+		relation = "<"
+	case "BEQ":
+		relation = "=="
+	case "BNE":
+		relation = "!="
+	default:
+		return next, true
+	}
+	if !taken {
+		relation = map[string]string{">": "<=", "<=": ">", ">=": "<", "<": ">=", "==": "!=", "!=": "=="}[relation]
+	}
+	left, right := comparison.left.interval, comparison.right.interval
+	if relation == "<" || relation == "<=" {
+		comparison.left, comparison.right = comparison.right, comparison.left
+		comparison.leftReg, comparison.rightReg = comparison.rightReg, comparison.leftReg
+		left, right = right, left
+		if relation == "<" {
+			relation = ">"
+		} else {
+			relation = ">="
+		}
+	}
+	switch relation {
+	case ">", ">=":
+		delta := uint64(0)
+		if relation == ">" {
+			delta = 1
+		}
+		if left.high < right.low || delta == 1 && left.high == right.low {
+			return nil, false
+		}
+		if right.low <= math.MaxUint64-delta && left.low < right.low+delta {
+			left.low = right.low + delta
+		}
+		if left.high >= delta && right.high > left.high-delta {
+			right.high = left.high - delta
+		}
+	case "==":
+		if left.low < right.low {
+			left.low = right.low
+		}
+		if left.high > right.high {
+			left.high = right.high
+		}
+		if left.low > left.high {
+			return nil, false
+		}
+		right = left
+	case "!=":
+		if left.low == left.high && right.low == right.high && left.low == right.low {
+			return nil, false
+		}
+	}
+	for _, item := range []struct {
+		reg   Reg
+		value arm64PrivateDataValue
+		bound arm64PoolInterval
+	}{{comparison.leftReg, comparison.left, left}, {comparison.rightReg, comparison.right, right}} {
+		if item.reg == "" || item.reg == ZR || arm64StackReg(item.reg) {
+			continue
+		}
+		value := item.value
+		if value.frame && value.stride != 0 {
+			residue := value.interval.low % value.stride
+			lowDelta := (residue + value.stride - item.bound.low%value.stride) % value.stride
+			if lowDelta > item.bound.high-item.bound.low {
+				return nil, false
+			}
+			item.bound.low += lowDelta
+			item.bound.high -= (item.bound.high%value.stride + value.stride - residue) % value.stride
+		}
+		value.interval = item.bound
+		next.regs[item.reg] = value
+	}
+	return next, true
+}
+
+// The small disjunctive prefix retains bounded shift/count correlations.
+// Afterwards numeric widening guarantees termination; private intervals are
+// never widened into an external category. The global work budget fails closed.
+func arm64PrivateDataProof(fn Func, transport *arm64PrivateFrameTransport) (map[[2]int]arm64PrivateDataSpan, bool) {
+	stores, err := arm64PrivateDataProofDetails(fn, transport)
+	return stores, err == nil
+}
+
+func arm64PrivateDataProofDetails(fn Func, transport *arm64PrivateFrameTransport) (map[[2]int]arm64PrivateDataSpan, error) {
+	if transport == nil || fn.FrameSize < 0 || fn.FrameSize > arm64MaxLocalStackSpan || arm64HasRawFrameCode(fn) {
+		return nil, fmt.Errorf("private data proof needs a bounded named source and explicit transport")
+	}
+	if proof := transport.nanosleep; proof != nil {
+		if !reflect.DeepEqual(proof.source, fn) || !reflect.DeepEqual(proof.sig, transport.entry) ||
+			proof.identity != nil && !proof.matchesSource(fn, transport.entry, proof.target) {
+			return nil, fmt.Errorf("private nanosleep replay has a changed source, declaration or certificate")
+		}
+	}
+	blocks := arm64SplitBlocks(fn)
+	indices := make(map[string]int, len(blocks))
+	for index, block := range blocks {
+		indices[block.name] = index
+	}
+	stores := make(map[[2]int]arm64PrivateDataSpan)
+	type work struct {
+		block int
+		state *arm64PrivateDataState
+	}
+	queue := []work{}
+	before := make([][]*arm64PrivateDataState, len(blocks))
+	compressed := make([]bool, len(blocks))
+	propagate := func(index int, state *arm64PrivateDataState) {
+		if index < 0 || index >= len(blocks) {
+			return
+		}
+		if compressed[index] {
+			if before[index][0].merge(state, true) {
+				queue = append(queue, work{index, before[index][0].clone()})
+			}
+			return
+		}
+		for _, old := range before[index] {
+			if reflect.DeepEqual(old, state) {
+				return
+			}
+		}
+		if len(before[index]) < 8 {
+			before[index] = append(before[index], state.clone())
+			queue = append(queue, work{index, state.clone()})
+			return
+		}
+		joined := before[index][0].clone()
+		for _, old := range before[index][1:] {
+			joined.merge(old, false)
+		}
+		joined.merge(state, false)
+		before[index], compressed[index] = []*arm64PrivateDataState{joined}, true
+		queue = append(queue, work{index, joined.clone()})
+	}
+	steps := 0
+	for seed := range blocks {
+		if len(before[seed]) != 0 || len(blocks[seed].instrs) == 0 {
+			// An unreferenced empty label has no effect to audit. Inventing
+			// an entry there would contaminate a reachable successor with
+			// unrelated unknown registers; nonempty dead source still runs.
+			continue
+		}
+		initial := newARM64PrivateDataState()
+		if transport.nanosleep != nil && transport.nanosleep.identity == nil {
+			initial.initialized = make(map[int64]bool)
+		}
+		propagate(seed, initial)
+		for len(queue) != 0 {
+			current := queue[0]
+			queue = queue[1:]
+			steps++
+			if steps > 16384 {
+				return nil, fmt.Errorf("private data CFG proof exhausted its convergence budget")
+			}
+			state := current.state
+			// Disjunction preserves numeric correlations, not an exemption for
+			// mixed address origins. Every predecessor participates in the
+			// may-frame category even before numeric states are compacted.
+			origins := before[current.block][0].clone()
+			for _, previous := range before[current.block][1:] {
+				origins.merge(previous, false)
+			}
+			for reg, value := range origins.regs {
+				if value.frame && value.mixed {
+					state.regs[reg] = value
+				}
+			}
+			terminated := false
+			for ii, ins := range blocks[current.block].instrs {
+				op := arm64ControlOp(ins)
+				if op == "SVC" && transport.nanosleep != nil {
+					// No native result/flags observation is authorized. This first
+					// contract ends in the ordinary source RET in the same block.
+					if ii+2 != len(blocks[current.block].instrs) ||
+						arm64ControlOp(blocks[current.block].instrs[ii+1]) != OpRET ||
+						len(blocks[current.block].instrs[ii+1].Args) != 0 ||
+						!transport.nanosleep.consume(state, fn, [2]int{current.block, ii}, ins) {
+						return nil, fmt.Errorf("private nanosleep input/terminal contract is unproved at %q", ins.Raw)
+					}
+					continue
+				}
+				if op == "ADR" || op == "ADRP" || op == OpWORD || op == "DWORD" || op == arm64RawDataOp || op == "BLR" {
+					return nil, fmt.Errorf("private data proof rejects native/raw address effects at %q", ins.Raw)
+				}
+				if op == "CALL" || op == "BL" || op == OpRET {
+					if !state.consume(ins, transport, strings.HasSuffix(fn.Sym, "<ABIInternal>")) {
+						return nil, fmt.Errorf("private data proof needs exact nonescaping transport at %q", ins.Raw)
+					}
+					if op != OpRET {
+						propagate(current.block+1, state)
+					}
+					terminated = true
+					break
+				}
+				if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+					if len(ins.Args) == 0 {
+						return nil, fmt.Errorf("private data proof rejects an empty branch")
+					}
+					name, known := arm64BranchTarget(ins.Args[len(ins.Args)-1])
+					target, local := indices[name]
+					if !known || !local {
+						return nil, fmt.Errorf("private data proof needs a source-local branch at %q", ins.Raw)
+					}
+					branch, possible := state.branch(op, true)
+					if possible {
+						propagate(target, branch)
+					}
+					if arm64IsConditionalBranch(op) {
+						branch, possible = state.branch(op, false)
+						if possible {
+							propagate(current.block+1, branch)
+						}
+					}
+					terminated = true
+					break
+				}
+				span, valid := state.transfer(ins, current.block*65536+ii, fn.FrameSize)
+				if !valid {
+					inputs := make(map[Reg]arm64PrivateDataValue)
+					for _, operand := range ins.Args {
+						for _, reg := range []Reg{operand.Reg, operand.Mem.Base, operand.Mem.Index} {
+							if reg != "" {
+								inputs[reg] = state.value(reg)
+							}
+						}
+					}
+					return nil, fmt.Errorf("private data extent/effects are unproved at %q (inputs %v)", ins.Raw, inputs)
+				}
+				if span != nil {
+					key := [2]int{current.block, ii}
+					if old, present := stores[key]; present {
+						if old.low < span.low {
+							span.low = old.low
+						}
+						if old.end > span.end {
+							span.end = old.end
+						}
+					}
+					stores[key] = *span
+				}
+			}
+			if !terminated {
+				propagate(current.block+1, state)
+			}
+		}
+	}
+	return stores, nil
+}
diff --git a/arm64_private_data_test.go b/arm64_private_data_test.go
new file mode 100644
index 000000000..f56462b51
--- /dev/null
+++ b/arm64_private_data_test.go
@@ -0,0 +1,321 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64PrivateDataBoundObjects(t *testing.T, source, declaration, name string) {
+	t.Helper()
+	arm64PrivateCallGoObject(t, source)
+	pkg := mustGoPackage(t, "test/indexed", "package indexed\n"+declaration+"\nfunc Noop()\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	for _, target := range arm64TypedNativeTargets {
+		func() {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+			})
+			if err != nil {
+				t.Fatalf("%s GoModule bounded data: %v", target, err)
+			}
+			defer bound.Module.Dispose()
+			compileLLVMToObject(t, llc, target, name+"-go.ll", name+"-go.o", bound.Module.String())
+			opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: bound.Signatures, ResolveSym: resolve}
+			ir, err := Translate(file, opt)
+			if err != nil {
+				t.Fatalf("%s Translate bounded data: %v", target, err)
+			}
+			compileLLVMToObject(t, llc, target, name+"-text.ll", name+"-text.o", ir)
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Fatalf("%s Module bounded data: %v", target, err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, target, name+"-module.ll", name+"-module.o", module.String())
+		}()
+	}
+}
+
+func arm64PrivateDataContext(t *testing.T, source string) {
+	t.Helper()
+	arm64PrivateCallGoObject(t, source)
+	pkg := mustGoPackage(t, "test/indexed", "package indexed\nfunc Indexed(dst *uint64,n uint64) uint64\nfunc Noop()\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(sym string) string { return strings.TrimPrefix(sym, "·") }
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range arm64TypedNativeTargets {
+		opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs, ResolveSym: resolve}
+		if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s Translate needs a private data/transport contract: %v", target, err)
+		}
+		ctx := llvm.NewContext()
+		module, err := TranslateModuleInContext(ctx, file, opt)
+		if err == nil {
+			module.Dispose()
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s Module needs a private data/transport contract: %v", target, err)
+		}
+		bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+		})
+		if err == nil {
+			bound.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s GoModule needs a private data/transport contract: %v", target, err)
+		}
+	}
+}
+
+func TestARM64PrivateDataSignedNarrowWordIndexRemainsContext(t *testing.T) {
+	for _, tc := range []struct {
+		store, native string
+		value, frame  int
+	}{
+		{"MOVB", "ldrsb w11,[x17]", 0x80, 512},
+		{"MOVH", "ldrsh w11,[x17]", 0x8000, 65552},
+	} {
+		t.Run(tc.store, func(t *testing.T) {
+			word := assembleARM64LLVMWords(t, []string{tc.native}, "")[0]
+			source := arm64PrivateIndexedSource("MOVB", "MOVBU", 0)
+			source = strings.Replace(source, "$80-24", fmt.Sprintf("$%d-24", tc.frame), 1)
+			source = strings.Replace(source, "MOVD $0x123456789abcde7e,R5", fmt.Sprintf("MOVD $%d,R5", tc.value), 1)
+			source = strings.Replace(source, "MOVB R5,0(R17)(R11<<0)", fmt.Sprintf("%s R5,(R17)\nWORD $%#08x\nMOVB R5,0(R17)(R11<<0)", tc.store, word), 1)
+			// MOVBW/MOVHW are decoded forms, not Go named instructions.
+			// The actual accepted WORD source still needs a raw-frame contract;
+			// this new named-data proof must not authorize it implicitly.
+			arm64PrivateDataContext(t, source)
+			decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			state := newARM64PrivateDataState()
+			state.regs["R17"] = arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{16, 16}}
+			form, ok := arm64PrivateDataMemory(decoded)
+			if !ok {
+				t.Fatalf("decoded signed word load lacks typed memory grammar: %+v", decoded)
+			}
+			if _, ok := state.memory(arm64ControlOp(decoded), form, int64(tc.frame)); !ok {
+				t.Fatal("bounded decoded load was rejected")
+			}
+			value := state.value("R11").interval
+			actual := uint64(uint32(int32(int16(tc.value))))
+			if tc.store == "MOVB" {
+				actual = uint64(uint32(int32(int8(tc.value))))
+			}
+			if actual < value.low || actual > value.high {
+				t.Fatalf("decoded signed word numeric bound excluded %#x: %v", actual, value)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateDataExtentAndEscapeNegatives(t *testing.T) {
+	base := arm64PrivateIndexedSource("MOVD", "MOVD", 3)
+	for _, tc := range []struct {
+		name, old, replacement string
+	}{
+		{"last_element_crosses_extent", "$80-24", "$64-24"},
+		{"unbounded_index", "AND $7,R11", "NOP"},
+		{"wider_mask", "AND $7,R11", "AND $255,R11"},
+		{"hardware_word_count_wrap", "AND $7,R11", "MOVW n+8(FP),R11\nMOVD $32,R12\nLSRW R12,R11"},
+		{"unknown_index_transform", "AND $7,R11", "AND $7,R11\nRBIT R11,R11"},
+		{"saved_lr_byte_overlap", "MOVD R5,0(R17)(R11<<3)", "MOVB R5,-9(R17)"},
+		{"writeback_leaves_allocation", "MOVD R5,0(R17)(R11<<3)", "MOVD.P R5,80(R17)"},
+		{"negative_writeback", "MOVD R5,0(R17)(R11<<3)", "MOVD.W R5,-24(R17)"},
+		{"private_argument", "MOVD R12,(R7)", "MOVD R17,R0\nCALL ·Consume(SB)\nMOVD R12,(R7)"},
+		{"private_fp_result", "MOVD R12,ret+16(FP)", "MOVD R17,ret+16(FP)"},
+		{"private_register_result", "MOVD R12,ret+16(FP)", "MOVD R17,R0"},
+		{"private_fp_param", "MOVD R12,(R7)", "MOVD R17,dst+0(FP)\nMOVD R12,(R7)"},
+		{"private_heap_store", "MOVD R12,(R7)", "MOVD R17,(R7)"},
+		{"private_global_store", "MOVD R12,(R7)", "MOVD R17,holder(SB)"},
+		{"private_fp_bank", "MOVD R12,(R7)", "FMOVD R17,F0\nMOVD R12,(R7)"},
+		{"private_vector_bank", "MOVD R12,(R7)", "VMOV R17,V0.D[0]\nMOVD R12,(R7)"},
+		{"different_offsets", "MOVD R5,0(R17)(R11<<3)", "CBZ R11,alternate\nB merged\nalternate:\nADD $24,RSP,R17\nmerged:\nMOVD R5,0(R17)(R11<<3)"},
+		{"mixed_external", "MOVD R5,0(R17)(R11<<3)", "CBZ R11,alternate\nB merged\nalternate:\nMOVD R7,R17\nmerged:\nMOVD R5,0(R17)(R11<<3)"},
+		{"derived_caller_pc_index", "AND $7,R11", "MOVD R30,R11\nAND $7,R11"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := strings.Replace(base, tc.old, tc.replacement, 1)
+			source += "\nGLOBL holder(SB),NOPTR,$8\n"
+			if tc.name == "private_argument" {
+				// Use the real zero-arg target's R0 result fallback transport
+				// rather than invent a third declaration for the unit fixture.
+				source = strings.Replace(source, "MOVD R17,R0\nCALL ·Consume(SB)", "MOVD R17,8(RSP)\nCALL ·Noop(SB)", 1)
+			}
+			arm64PrivateDataContext(t, source)
+		})
+	}
+}
+
+func TestARM64PrivateDataUnknownStoresPreserveOnlyDisjointCells(t *testing.T) {
+	for _, derived := range []bool{false, true} {
+		state := &arm64ControlState{
+			unexposedSP:  true,
+			privateStore: &arm64PrivateDataSpan{8, 24},
+			regs:         map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R17": arm64ControlFromMap(map[string]bool{"sp:8": true})},
+			memory: map[string]arm64ControlValue{
+				"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true}), "sp:8": arm64ControlExternal(), "sp:24": arm64ControlFromMap(map[string]bool{"label:untouched": true}), "fp:0": arm64ControlFromMap(map[string]bool{"label:fp": true}),
+			},
+		}
+		if derived {
+			state.regs["R11"] = arm64ControlFromMap(map[string]bool{"code-derived:": true})
+		}
+		state.invalidateUnknownStore(Operand{Kind: OpMem, Mem: MemRef{Base: "R17", Index: "R11"}}, arm64ControlFromMap(map[string]bool{"label:stored": true}))
+		if arm64ControlHas(state.memory["sp:0"], "") != derived || arm64ControlHas(state.memory["sp:24"], "") != derived {
+			t.Fatal("per-instruction data extent erased the caller/code-derived boundary")
+		}
+		if !arm64ControlHas(state.memory["sp:8"], "label:stored") || !arm64ControlHas(state.memory["sp:8"], "") || !arm64ControlHas(state.memory["fp:0"], "") {
+			t.Fatal("overlap/FP cells retained stale contents or lost stored code provenance")
+		}
+	}
+}
+
+func TestARM64PrivateDataAllMemoryWidthsRejectExtentCrossing(t *testing.T) {
+	for _, tc := range arm64PrivateDataCases() {
+		if tc.mode != "offset" || tc.zero != "" {
+			continue
+		}
+		t.Run(tc.store+"_"+tc.load, func(t *testing.T) {
+			input := "R5"
+			if tc.floating {
+				input = "F0"
+			}
+			if tc.count == 2 {
+				input = "(R5,R6)"
+				if tc.floating {
+					input = "(F0,F1)"
+				}
+			}
+			// The first element fits, but the scalar's last bytes or pair's
+			// second element do not. Pair offsets retain Go's natural scale.
+			offset := 72 - tc.width*tc.count + tc.width
+			source := arm64PrivateIndexedSource("MOVD", "MOVD", 3)
+			store := fmt.Sprintf("FMOVD R5,F0\nFMOVD R5,F1\n%s %s,%d(R17)", tc.store, input, offset)
+			source = strings.Replace(source, "MOVD R5,0(R17)(R11<<3)", store, 1)
+			arm64PrivateDataContext(t, source)
+		})
+	}
+}
+
+func TestARM64PrivateDataComparisonCannotEraseMixedOrigins(t *testing.T) {
+	source := arm64PrivateIndexedSource("MOVD", "MOVD", 3)
+	source = strings.Replace(source, "MOVD R5,0(R17)(R11<<3)", `ADD $64,RSP,R19
+CBZ R11,alternate
+CMP R17,R19
+B merged
+alternate:
+ADD $24,RSP,R17
+CMP R17,R19
+merged:
+BHI store
+B done
+store:
+MOVD R5,(R17)
+done:`, 1)
+	source = strings.Replace(source, "MOVD 0(R17)(R11<<3),R12", "MOVD (R17),R12", 1)
+	// Both predecessors set real flags, but a disjunctive comparison snapshot
+	// must not restore a usable address after the whole-CFG may-frame join
+	// marked R17 as mixed. This is an accepted source/object negative only.
+	arm64PrivateDataContext(t, source)
+	state := newARM64PrivateDataState()
+	left := arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{64, 64}, origin: 1}
+	right := arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{16, 16}, origin: 2}
+	state.regs["R19"] = left
+	state.regs["R17"] = arm64PrivateDataValue{frame: true, mixed: true, interval: arm64PoolUnknownInterval}
+	state.comparison = arm64PrivateDataCompare{left: left, right: right, leftReg: "R19", rightReg: "R17", valid: true}
+	branch, possible := state.branch("BHI", true)
+	if !possible || !branch.value("R17").mixed {
+		t.Fatal("a cached comparison restored an exact address after a may-frame join")
+	}
+}
+
+func TestARM64PrivateDataConvergenceBudgetFailsClosed(t *testing.T) {
+	source := strings.Replace(arm64PrivateIndexedSource("MOVB", "MOVBU", 0), "$80-24", "$1048576-24", 1)
+	source = strings.Replace(source, "MOVB R5,0(R17)(R11<<0)", `MOVD $1048560,R6
+ADD R6,R17,R6
+clear:
+MOVB.P ZR,1(R17)
+CMP R17,R6
+BHI clear
+MOVD $0,R17
+ADD $16,RSP,R17
+MOVB R5,(R17)`, 1)
+	arm64PrivateCallGoObject(t, source)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	transport := &arm64PrivateFrameTransport{
+		entry:   FuncSig{Ret: I64},
+		resolve: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		sigs:    map[string]FuncSig{"Noop": {Ret: Void}},
+	}
+	if _, err := arm64PrivateDataProofDetails(file.Funcs[0], transport); err == nil || !strings.Contains(err.Error(), "convergence budget") {
+		t.Fatalf("large byte loop must exhaust this bounded proof, not authorize stores: %v", err)
+	}
+	// The source is assembler-accepted, not executed: a bounded analysis
+	// failure remains Context at every final public consumer.
+	arm64PrivateDataContext(t, source)
+}
+
+func TestARM64PrivateDataNumericIntervalsContainMachineValues(t *testing.T) {
+	for _, width := range []uint{32, 64} {
+		for low := uint64(0); low < 32; low++ {
+			for high := low; high < 32; high++ {
+				for count := uint64(0); count < 128; count++ {
+					for _, left := range []bool{false, true} {
+						interval := arm64PrivateDataShift(arm64PoolInterval{low, high}, arm64PoolInterval{count, count + 3}, left, width)
+						for value := low; value <= high; value++ {
+							for shift := count; shift <= count+3; shift++ {
+								actual := value >> (shift % uint64(width))
+								if left {
+									actual = value << (shift % uint64(width))
+									if width == 32 {
+										actual &= math.MaxUint32
+									}
+								}
+								if actual < interval.low || actual > interval.high {
+									t.Fatalf("shift width=%d range=[%d,%d] count=%d actual=%d bound=%v", width, low, high, count, actual, interval)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, values := range [][2]uint64{{0, math.MaxUint64}, {17, 24}, {255, 257}, {math.MaxUint32 - 1, math.MaxUint32}, {math.MaxUint64 - 2, math.MaxUint64}} {
+		before := arm64PrivateDataNumber(arm64PoolInterval{values[0], values[0]})
+		after := arm64PrivateDataNumber(arm64PoolInterval{values[1], values[1]})
+		joined := arm64PrivateDataUnion(before, after, true)
+		if joined.interval.low > values[0] || joined.interval.high < values[1] {
+			t.Fatalf("widening excluded input: %v", joined)
+		}
+	}
+}
diff --git a/arm64_private_data_values.go b/arm64_private_data_values.go
new file mode 100644
index 000000000..6efca59ea
--- /dev/null
+++ b/arm64_private_data_values.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"math"
+	"math/bits"
+	"strings"
+)
+
+// Numeric bounds are not address provenance. A may-frame value retains that
+// category even when different origins or an external predecessor erase its
+// usable bounds. Only a complete overwrite removes the category.
+type arm64PrivateDataValue struct {
+	interval arm64PoolInterval
+	frame    bool
+	mixed    bool
+	origin   int
+	stride   uint64
+}
+
+func arm64PrivateDataNumber(interval arm64PoolInterval) arm64PrivateDataValue {
+	return arm64PrivateDataValue{interval: interval}
+}
+
+var arm64PrivateDataUnknown = arm64PrivateDataNumber(arm64PoolUnknownInterval)
+
+func arm64PrivateDataGCD(a, b uint64) uint64 {
+	for b != 0 {
+		a, b = b, a%b
+	}
+	return a
+}
+
+func arm64PrivateDataUnion(a, b arm64PrivateDataValue, widen bool) arm64PrivateDataValue {
+	if a == b {
+		return a
+	}
+	if a.frame && b.frame && !a.mixed && !b.mixed && a.interval.low == a.interval.high && a.interval == b.interval {
+		// Reconstructing the same fixed SP displacement on another path
+		// retains that address. It does not authorize different-offset joins.
+		a.origin = -2
+		return a
+	}
+	if a.frame != b.frame || a.frame && (a.mixed || b.mixed || a.origin != b.origin) {
+		return arm64PrivateDataValue{frame: true, mixed: true, interval: arm64PoolUnknownInterval}
+	}
+	result := a
+	if b.interval.low < result.interval.low {
+		result.interval.low = b.interval.low
+	}
+	if b.interval.high > result.interval.high {
+		result.interval.high = b.interval.high
+	}
+	if !a.frame {
+		if widen && result.interval.low < a.interval.low && result.interval.low > 64 {
+			result.interval.low = uint64(1) << uint(bits.Len64(result.interval.low)-1)
+		}
+		if widen && result.interval.high > a.interval.high && result.interval.high > 64 {
+			width := bits.Len64(result.interval.high - 1)
+			if width == 64 {
+				result.interval.high = math.MaxUint64
+			} else {
+				result.interval.high = uint64(1) << uint(width)
+			}
+		}
+		return result
+	}
+	delta := a.interval.low - b.interval.low
+	if a.interval.low < b.interval.low {
+		delta = b.interval.low - a.interval.low
+	}
+	result.stride = arm64PrivateDataGCD(arm64PrivateDataGCD(a.stride, b.stride), delta)
+	return result
+}
+
+func arm64PrivateDataShift(input, count arm64PoolInterval, left bool, width uint) arm64PoolInterval {
+	mask := uint64(math.MaxUint64)
+	if width == 32 {
+		mask = math.MaxUint32
+	}
+	input = arm64PoolMaskInterval(input, mask)
+	result := arm64PoolInterval{low: math.MaxUint64}
+	// The hardware masks a variable count. At most width distinct shifts
+	// suffice, including a wrapping count interval or an entirely unknown one.
+	for shift := uint64(0); shift < uint64(width); shift++ {
+		possible := count.high-count.low >= uint64(width)-1
+		if !possible {
+			for value := count.low; ; value++ {
+				possible = possible || value%uint64(width) == shift
+				if value == count.high {
+					break
+				}
+			}
+		}
+		if !possible {
+			continue
+		}
+		value := arm64PoolInterval{input.low >> shift, input.high >> shift}
+		if left {
+			if input.high > mask>>shift {
+				value = arm64PoolInterval{0, mask}
+			} else {
+				value = arm64PoolInterval{input.low << shift, input.high << shift}
+			}
+		}
+		if value.low < result.low {
+			result.low = value.low
+		}
+		if value.high > result.high {
+			result.high = value.high
+		}
+	}
+	return result
+}
+
+func arm64PrivateDataNarrow(input arm64PoolInterval, width int64, signed bool) arm64PoolInterval {
+	if width == 8 {
+		return input
+	}
+	mask := uint64(1) << uint(width*8)
+	input = arm64PoolMaskInterval(input, mask-1)
+	if !signed || input.high < mask/2 {
+		return input
+	}
+	if input.low < mask/2 {
+		return arm64PoolUnknownInterval // The signed extension crosses zero.
+	}
+	return arm64PoolInterval{input.low | ^(mask - 1), input.high | ^(mask - 1)}
+}
+
+func (state *arm64PrivateDataState) value(reg Reg) arm64PrivateDataValue {
+	if arm64StackReg(reg) {
+		return arm64PrivateDataValue{frame: true, origin: -1}
+	}
+	if reg == ZR {
+		return arm64PrivateDataNumber(arm64PoolInterval{})
+	}
+	if value, present := state.regs[reg]; present {
+		return value
+	}
+	return arm64PrivateDataUnknown
+}
+
+func (state *arm64PrivateDataState) assign(reg Reg, value arm64PrivateDataValue) bool {
+	if arm64StackReg(reg) || !isARM64GeneralOrZeroReg(reg) {
+		return false
+	}
+	if reg != ZR {
+		if state.comparison.leftReg == reg || state.comparison.rightReg == reg {
+			state.comparison = arm64PrivateDataCompare{}
+		}
+		state.regs[reg] = value
+	}
+	return true
+}
+
+func (state *arm64PrivateDataState) operand(operand Operand, width uint) (arm64PrivateDataValue, bool) {
+	var value arm64PrivateDataValue
+	switch operand.Kind {
+	case OpImm:
+		if operand.ImmRaw != "" || operand.ImmIsFloat {
+			return value, false
+		}
+		number := uint64(operand.Imm)
+		value = arm64PrivateDataNumber(arm64PoolInterval{number, number})
+	case OpReg:
+		if !arm64StackReg(operand.Reg) && !isARM64GeneralOrZeroReg(operand.Reg) {
+			return value, false
+		}
+		value = state.value(operand.Reg)
+	case OpRegShift:
+		if operand.ShiftReg != "" || operand.ShiftAmount < 0 || operand.ShiftAmount >= int64(width) ||
+			!isARM64GeneralOrZeroReg(operand.Reg) || operand.ShiftOp != "<<" && operand.ShiftOp != ">>" {
+			return value, false
+		}
+		value = state.value(operand.Reg)
+		if value.frame {
+			return value, false
+		}
+		shift := uint64(operand.ShiftAmount)
+		value.interval = arm64PrivateDataShift(value.interval, arm64PoolInterval{shift, shift}, operand.ShiftOp == "<<", width)
+	default:
+		return value, false
+	}
+	if width == 32 {
+		if value.frame {
+			return value, false
+		}
+		value.interval = arm64PoolMaskInterval(value.interval, math.MaxUint32)
+	}
+	return value, true
+}
+
+func (state *arm64PrivateDataState) arithmetic(ins Instr, at int, frameSize int64) (handled, valid bool) {
+	op := string(ins.Op)
+	width := uint(64)
+	base := op
+	if strings.HasSuffix(base, "W") {
+		width, base = 32, strings.TrimSuffix(base, "W")
+	}
+	switch base {
+	case "ADD", "SUB", "AND", "BIC", "ORR", "EOR", "MUL", "LSL", "LSR":
+	default:
+		return false, false
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 || ins.Args[len(ins.Args)-1].Kind != OpReg {
+		return true, false
+	}
+	first, ok := state.operand(ins.Args[0], width)
+	if !ok {
+		return true, false
+	}
+	second, ok := state.operand(ins.Args[1], width)
+	if !ok {
+		return true, false
+	}
+	result := arm64PrivateDataUnknown
+	if first.frame || second.frame {
+		if width != 64 || base != "ADD" && base != "SUB" || first.frame && second.frame || base == "SUB" && first.frame {
+			return true, false
+		}
+		address, number := second, first.interval
+		if first.frame {
+			address, number = first, second.interval
+		}
+		if address.mixed {
+			return true, false
+		}
+		var low, high uint64
+		if base == "SUB" {
+			if address.interval.low < number.high {
+				return true, false
+			}
+			low, high = address.interval.low-number.high, address.interval.high-number.low
+		} else {
+			if number.high > math.MaxUint64-address.interval.high {
+				return true, false
+			}
+			low, high = address.interval.low+number.low, address.interval.high+number.high
+		}
+		if high > uint64(frameSize)+8 {
+			return true, false
+		}
+		result = address
+		result.interval = arm64PoolInterval{low, high}
+		result.origin = at
+		if number.low != number.high {
+			result.stride = 1
+		}
+	} else {
+		left, right := second.interval, first.interval
+		mask := uint64(math.MaxUint64)
+		if width == 32 {
+			mask = math.MaxUint32
+		}
+		result.interval = arm64PoolInterval{0, mask}
+		switch base {
+		case "ADD":
+			if right.high <= mask-left.high {
+				result.interval = arm64PoolInterval{left.low + right.low, left.high + right.high}
+			}
+		case "SUB":
+			if left.low >= right.high {
+				result.interval = arm64PoolInterval{left.low - right.high, left.high - right.low}
+			}
+		case "MUL":
+			if left.low == left.high && right.low == right.high {
+				product := left.low * right.low & mask
+				result.interval = arm64PoolInterval{product, product}
+			} else if right.high == 0 || left.high <= mask/right.high {
+				result.interval = arm64PoolInterval{left.low * right.low, left.high * right.high}
+			}
+		case "LSL", "LSR":
+			result.interval = arm64PrivateDataShift(left, right, base == "LSL", width)
+		default:
+			lm, lp := arm64PoolIntervalBits(left)
+			rm, rp := arm64PoolIntervalBits(right)
+			if base == "BIC" {
+				rm, rp = ^rp&mask, ^rm&mask
+			}
+			switch base {
+			case "AND", "BIC":
+				result.interval = arm64PoolInterval{lm & rm, lp & rp}
+			case "ORR":
+				result.interval = arm64PoolInterval{lm | rm, lp | rp}
+			case "EOR":
+				result.interval = arm64PoolInterval{lm&^rp | rm&^lp, lp&^rm | rp&^lm}
+			}
+		}
+	}
+	return true, state.assign(ins.Args[len(ins.Args)-1].Reg, result)
+}
diff --git a/arm64_private_frame_contract_test.go b/arm64_private_frame_contract_test.go
new file mode 100644
index 000000000..ca2950217
--- /dev/null
+++ b/arm64_private_frame_contract_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64CallerFPAliasInvalidatesPointer(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	// aliasTarget's real Go frame is 48 bytes; its first FP pointer slot is
+	// at entry SP+56. The caller explicitly points p at that pointer slot.
+	// An aliased MOVD reconstructs p as the callee saved-LR address. A reload
+	// then changes LR to the real caller continuation plus four bytes. Native
+	// Go safely skips one witness instruction; synthesizing a normal return
+	// would therefore have different semantics. No fabricated link is used.
+	const target = `TEXT ·aliasTarget(SB),4,$32-8
+CALL ·aliasAnchor(SB)
+MOVD (RSP),R22
+MOVD p+0(FP),R9
+SUB $56,R9,R10
+MOVD R10,(R9)
+MOVD p+0(FP),R11
+ADD $4,R22,R12
+MOVD R12,(R11)
+RET
+`
+	const anchor = "TEXT ·aliasAnchor(SB),4,$0-0\nRET\n"
+	const caller = `TEXT ·aliasMeasure(SB),516,$0-8
+MOVD RSP,R19
+MOVD R30,R23
+MOVD R29,R24
+SUB $64,RSP
+ADD $8,RSP,R9
+MOVD R9,8(RSP)
+MOVD $7,R25
+BL ·aliasTarget(SB)
+MOVD $11,R25
+ADD $100,R25
+MOVD $0,R9
+MOVD R9,8(RSP)
+MOVD R19,RSP
+MOVD R24,R29
+MOVD R23,R30
+MOVD R25,ret+0(FP)
+RET
+`
+	requireARM64GoAssemblerResult(t, caller+target+anchor, true)
+	runARM64LocalRegisterGoOracle(t, caller+target+anchor, `package main
+func aliasMeasure() uint64
+func aliasTarget(*uint64)
+func aliasAnchor()
+func main() { if got:=aliasMeasure(); got!=107 { println(got); panic("caller FP alias witness mismatch") } }
+`, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/fpalias", "package fpalias\nfunc aliasTarget(*uint64)\nfunc aliasAnchor()\n")
+	for _, triple := range arm64TypedNativeTargets {
+		ctx := llvm.NewContext()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(target+anchor), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err == nil {
+			tr.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s: aliased FP mutation cannot retain the original typed Ptr category: %v", triple, err)
+		}
+	}
+	t.Log("actual native Go alias redirects caller continuation by one instruction; translation must retain Context")
+}
+
+func TestARM64PrivateFrameUnknownStoreRetainsMixedCodeUncertainty(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		value    arm64ControlValue
+		preserve bool
+	}{
+		{"ordinary_data", arm64ControlExternal(), true},
+		{"pure_code", arm64ControlFromMap(map[string]bool{"label:outer": true}), true},
+		{"conservative_callee_code", arm64ControlFromMap(map[string]bool{"label:outer": true, "": true}), true},
+		{"source_derived_code", arm64ControlFromMap(map[string]bool{"code-derived:": true, "": true}), false},
+		{"escaped_frame", arm64ControlFromMap(map[string]bool{"sp:8": true}), false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			caller := arm64ControlFromMap(map[string]bool{"label:outer": true})
+			state := &arm64ControlState{
+				unexposedSP: true,
+				regs:        map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R9": arm64ControlExternal()},
+				memory:      map[string]arm64ControlValue{"sp:0": caller, "fp:0": arm64ControlExternal()},
+			}
+			state.write(Operand{Kind: OpMem, Mem: MemRef{Base: "R9"}}, tc.value, false)
+			if intact := arm64ControlEqual(state.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP}}, false), caller); intact != tc.preserve {
+				t.Fatalf("filtered taint changed the original store uncertainty: preserve=%t, memory=%v, escaped=%v", intact, state.memory, state.escaped)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64TypedPrivateFramePointerStores(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		name, body, decl, goCallee, goChecks, reference, cCallee string
+	}{
+		{
+			name:      "incoming_pointer_store",
+			body:      "MOVD p+0(FP),R9\nMOVD a+8(FP),R10\nMOVD R10,(R9)\nCALL ·X(SB)",
+			goChecks:  "if data[0] != a { panic(\"typed data store mismatch\") }",
+			reference: "memcpy(want + start, &a, sizeof a);",
+		},
+		{
+			name:      "declared_pointer_callee",
+			body:      "MOVD p+0(FP),R9\nMOVD a+8(FP),R10\nMOVD R9,8(RSP)\nMOVD R10,16(RSP)\nCALL ·X(SB)\nMOVD p+0(FP),R9\nMOVD a+8(FP),R10\nMOVD R10,8(R9)",
+			decl:      "func X(*uint64,uint64)",
+			goCallee:  "func X(p *uint64,a uint64) { *p=a*7+9 }",
+			goChecks:  "if data[0] != a*7+9 || data[1]!=a { panic(\"typed pointer callee mismatch\") }",
+			reference: "uint64_t changed = a * 7 + 9;\nmemcpy(want + start, &changed, sizeof changed);\nmemcpy(want + start + 8, &a, sizeof a);",
+			cCallee:   "void X(void *p, uint64_t a) { uint64_t value = a * 7 + 9; memcpy(p, &value, sizeof value); }",
+		},
+		{
+			name: "narrow_postindexed",
+			body: "MOVD p+0(FP),R9\nMOVD a+8(FP),R10\nMOVH.P R10,2(R9)\nMOVW.P R10,4(R9)\nMOVD.P R10,8(R9)\nCALL ·X(SB)",
+			goChecks: `bytes:=(*[32]byte)(unsafe.Pointer(&data[0]))
+for j:=0;j<32;j++ {
+  var want byte
+  switch { case j<2: want=byte(a>>uint(j*8)); case j<6: want=byte(a>>uint((j-2)*8)); case j<14: want=byte(a>>uint((j-6)*8)) }
+  if bytes[j]!=want { panic("typed postindex bytes mismatch") }
+}`,
+			reference: `for (int j = 0; j < 14; j++) {
+  int source = j < 2 ? j : j < 6 ? j - 2 : j - 6;
+  want[start + j] = (unsigned char)(a >> (source * 8));
+}`,
+		},
+		{
+			name:      "dynamic_data_offset",
+			body:      "MOVD p+0(FP),R9\nMOVD a+8(FP),R10\nAND $3,R10,R11\nLSL $3,R11\nADD R11,R9,R9\nMOVD R10,(R9)\nCALL ·X(SB)",
+			goChecks:  "for j,v:=range data { var want uint64; if j==int(a&3) { want=a }; if v!=want { panic(\"typed offset mismatch\") } }",
+			reference: "memcpy(want + start + (a & 3) * 8, &a, sizeof a);",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if tc.decl == "" {
+				tc.decl, tc.goCallee = "func X()", "func X() {}"
+			}
+			if tc.cCallee == "" {
+				tc.cCallee = "void X(void) {}"
+			}
+			source := "TEXT ·Y(SB),4,$48-24\n" + tc.body + "\nMOVD a+8(FP),R10\nADD $13,R10\nMOVD R10,ret+16(FP)\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			imports := ""
+			if strings.Contains(tc.goChecks, "unsafe.") {
+				imports = "import \"unsafe\"\n"
+			}
+			goMain := fmt.Sprintf(`package main
+%s
+func Y(*uint64, uint64) uint64
+%s
+func main() {
+  for _, a := range []uint64{0, 1, 123, 0x8000000000000000, ^uint64(0)} {
+    var data [4]uint64
+    if Y(&data[0], a) != a+13 { panic("typed frame result mismatch") }
+    %s
+  }
+}
+`, imports, tc.goCallee, tc.goChecks)
+			runARM64LocalRegisterGoOracle(t, source, goMain, len(runner) != 0)
+			pkg := mustGoPackage(t, "test/privateframe", "package privateframe\nfunc Y(*uint64,uint64) uint64\n"+tc.decl+"\n")
+			// The source-wide fresh-SP proof protects only the private saved
+			// continuation. It does not make incoming data noalias or preserve
+			// FP contents. Confirm real calls and pointer writes against Go,
+			// then LLVM, rather than retaining a now-obsolete Context negative.
+			for _, target := range arm64TypedNativeTargets {
+				ctx := llvm.NewContext()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if err != nil {
+					ctx.Dispose()
+					t.Fatalf("%s: proven private frame with ordinary data stores: %v", target, err)
+				}
+				ir := tr.Module.String()
+				tr.Module.Dispose()
+				ctx.Dispose()
+				compileLLVMToObject(t, llc, target, tc.name+".ll", tc.name+".o", ir)
+			}
+
+			ctx := llvm.NewContext()
+			tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: triple,
+				ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+			})
+			if err != nil {
+				ctx.Dispose()
+				t.Fatal(err)
+			}
+			ir := tr.Module.String()
+			tr.Module.Dispose()
+			ctx.Dispose()
+			driver := fmt.Sprintf(`#include <stdint.h>
+#include <string.h>
+extern uint64_t Y(void *, uint64_t);
+%s
+int main(void) {
+  const uint64_t values[] = {0, 1, 123, UINT64_C(0x8000000000000000), UINT64_MAX};
+  const int offsets[] = {0, 1, 3, 9, 15};
+  for (unsigned v = 0; v < sizeof values / sizeof values[0]; v++) {
+    for (unsigned o = 0; o < sizeof offsets / sizeof offsets[0]; o++) {
+      uint64_t a = values[v];
+      int start = 16 + offsets[o];
+      unsigned char data[96], want[96];
+      memset(data, 0xa5, sizeof data);
+      memset(data + start, 0, 32);
+      memcpy(want, data, sizeof data);
+      %s
+      if (Y(data + start, a) != a + 13) return 1;
+      if (memcmp(data, want, sizeof data) != 0) return 2;
+    }
+  }
+  return 0;
+}
+`, tc.cCallee, tc.reference)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, tc.name, triple, ir, driver, runner)
+		})
+	}
+}
diff --git a/arm64_private_frame_read.go b/arm64_private_frame_read.go
new file mode 100644
index 000000000..4447d929c
--- /dev/null
+++ b/arm64_private_frame_read.go
@@ -0,0 +1,446 @@
+package plan9asm
+
+import "strings"
+
+// A local affine address is not an escape. Keep a separate may-frame lattice:
+// unlike continuation values, a mixed/different-offset join must never collapse
+// to an ordinary external pointer. Only a full known overwrite kills it.
+type arm64PrivateFrameAddress struct {
+	offset int64
+	exact  bool
+}
+
+type arm64PrivateFrameAddresses map[Reg]arm64PrivateFrameAddress
+
+func (state arm64PrivateFrameAddresses) clone() arm64PrivateFrameAddresses {
+	next := make(arm64PrivateFrameAddresses, len(state))
+	for reg, value := range state {
+		next[reg] = value
+	}
+	return next
+}
+
+func (state arm64PrivateFrameAddresses) merge(other arm64PrivateFrameAddresses) bool {
+	changed := false
+	for reg, incoming := range other {
+		old, present := state[reg]
+		if !present || old != incoming {
+			if !present || old.exact {
+				state[reg], changed = arm64PrivateFrameAddress{}, true
+			}
+		}
+	}
+	for reg, old := range state {
+		if _, present := other[reg]; !present && old.exact {
+			state[reg], changed = arm64PrivateFrameAddress{}, true
+		}
+	}
+	return changed
+}
+
+func (state arm64PrivateFrameAddresses) address(reg Reg) (arm64PrivateFrameAddress, bool) {
+	if arm64StackReg(reg) {
+		return arm64PrivateFrameAddress{exact: true}, true
+	}
+	value, present := state[reg]
+	return value, present
+}
+
+func (state arm64PrivateFrameAddresses) assign(reg Reg, value arm64PrivateFrameAddress, present bool) bool {
+	if arm64StackReg(reg) || !isARM64GeneralOrZeroReg(reg) {
+		return false
+	}
+	if reg != ZR {
+		if present {
+			state[reg] = value
+		} else {
+			delete(state, reg)
+		}
+	}
+	return true
+}
+
+func arm64PrivateFrameOffset(value arm64PrivateFrameAddress, off int64) (arm64PrivateFrameAddress, bool) {
+	if !value.exact || off > 0 && value.offset > int64(1<<63-1)-off || off < 0 && value.offset < int64(-1<<63)-off {
+		return arm64PrivateFrameAddress{}, false
+	}
+	return arm64PrivateFrameAddress{offset: value.offset + off, exact: true}, true
+}
+
+// Reuse source basic blocks and branch grammar. Calls with any live temporary
+// frame address are conservatively rejected: this source-only proof cannot
+// guess a callee's transport. Audited register-only helper rewrites are checked
+// before and after coalescing; they cannot form an address from an absent one.
+func arm64PrivateFrameReadProof(fn Func) bool {
+	return arm64PrivateFrameReadProofForTransport(fn, nil)
+}
+
+func arm64PrivateFrameReadProofForTransport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	if arm64PrivateFrameReadExactProof(fn, transport) {
+		return true
+	}
+	_, bounded := arm64PrivateDataProof(fn, transport)
+	return bounded
+}
+
+func arm64PrivateFrameReadExactProof(fn Func, transport *arm64PrivateFrameTransport) bool {
+	blocks := arm64SplitBlocks(fn)
+	indices := make(map[string]int, len(blocks))
+	for index, block := range blocks {
+		indices[block.name] = index
+	}
+	before := make([]arm64PrivateFrameAddresses, len(blocks))
+	queue := []int{}
+	queued := make([]bool, len(blocks))
+	propagate := func(index int, state arm64PrivateFrameAddresses) {
+		if index < 0 || index >= len(blocks) {
+			return
+		}
+		changed := false
+		if before[index] == nil {
+			before[index], changed = state.clone(), true
+		} else {
+			changed = before[index].merge(state)
+		}
+		if changed && !queued[index] {
+			queue, queued[index] = append(queue, index), true
+		}
+	}
+	// Check even dead source components; a dead escape cannot erase the original
+	// whole-source contract during later normalization/helper rewriting.
+	for seed := range blocks {
+		if before[seed] != nil {
+			continue
+		}
+		propagate(seed, arm64PrivateFrameAddresses{})
+		for next := 0; next < len(queue); next++ {
+			index := queue[next]
+			queued[index] = false
+			state := before[index].clone()
+			if transport != nil && !state.bounded(fn.FrameSize) {
+				return false
+			}
+			terminated := false
+			for ii, original := range blocks[index].instrs {
+				ins := arm64StackInstruction(original)
+				op := arm64ControlOp(ins)
+				if op == "SVC" && transport != nil && transport.nanosleep != nil &&
+					transport.nanosleep.matchesSource(fn, transport.entry, transport.nanosleep.target) {
+					input, present := transport.nanosleep.inputs[[2]int{index, ii}]
+					address, frame := state.address("R0")
+					if !present || !frame || !address.exact || address.offset != input.span.low {
+						return false
+					}
+					state.assign("R0", arm64PrivateFrameAddress{}, false)
+					continue
+				}
+				if op == "CALL" || op == "BL" || op == OpRET {
+					if len(state) != 0 {
+						if transport == nil || !transport.consume(ins, state, strings.HasSuffix(fn.Sym, "<ABIInternal>")) {
+							return false
+						}
+					}
+					if op != OpRET {
+						propagate(index+1, state)
+					}
+					terminated = true
+					break
+				}
+				if !state.transfer(ins, fn.FrameSize) {
+					return false
+				}
+				if transport != nil && !state.bounded(fn.FrameSize) {
+					return false
+				}
+				if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+					if len(ins.Args) != 0 {
+						if name, ok := arm64BranchTarget(ins.Args[len(ins.Args)-1]); ok {
+							if target, present := indices[name]; present {
+								propagate(target, state)
+							}
+						}
+					}
+					if arm64IsConditionalBranch(op) {
+						propagate(index+1, state)
+					}
+					terminated = true
+					break
+				}
+			}
+			if !terminated {
+				propagate(index+1, state)
+			}
+		}
+		queue = queue[:0]
+	}
+	return true
+}
+
+// The extended transport proof rejects forming a known out-of-allocation
+// temporary. Mixed joins retain may-frame taint: they cannot authorize a
+// memory access or result/argument transport, but an unused temporary need
+// not be zeroed solely for a terminator.
+func (state arm64PrivateFrameAddresses) bounded(frameSize int64) bool {
+	if frameSize < 0 || frameSize > int64(1<<63-1)-8 {
+		return len(state) == 0
+	}
+	for _, value := range state {
+		if value.exact && (value.offset < 0 || value.offset > frameSize+8) {
+			return false
+		}
+	}
+	return true
+}
+
+func (state arm64PrivateFrameAddresses) transfer(ins Instr, frameSize int64) bool {
+	op := arm64ControlOp(ins)
+	if immediate, handled, err := parseARM64GPImmediateForm(op, ins); handled {
+		if err != nil {
+			return false
+		}
+		if immediate.scratch && !state.assign("R27", arm64PrivateFrameAddress{}, false) {
+			return false
+		}
+	}
+	if form, handled, err := parseARM64ScalarMemoryForm(op, ins); handled {
+		return err == nil && state.scalarMemory(form, frameSize)
+	}
+	switch op {
+	case "SVC", "HVC", "SMC", "BRK", "HLT", "DCPS1", "DCPS2", "DCPS3", "DRPS", "ERET", "UNDEF":
+		// Exception/syscall transport is not an ordinary typed Go call. It
+		// must not observe a temporary through an implicit native GP input.
+		return false
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpMem {
+			continue
+		}
+		_, baseFrame := state.address(arg.Mem.Base)
+		_, indexFrame := state.address(arg.Mem.Index)
+		writeback := strings.HasSuffix(string(ins.Op), ".P") || strings.HasSuffix(string(ins.Op), ".W")
+		if indexFrame || baseFrame && (arg.Mem.Index != "" || writeback) {
+			return false
+		}
+	}
+	if form, handled, err := parseARM64RegisterAddressForm(op, ins); handled {
+		if err != nil || form.usesScratch {
+			return false
+		}
+		value, present := state.address(form.base)
+		if present {
+			var ok bool
+			value, ok = arm64PrivateFrameOffset(value, form.offset)
+			if !ok {
+				return false
+			}
+		}
+		return state.assign(form.destination, value, present)
+	}
+	if op == "MOVD" && string(ins.Op) == "MOVD" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		src := ins.Args[0]
+		if src.Kind == OpReg {
+			value, present := state.address(src.Reg)
+			return state.assign(ins.Args[1].Reg, value, present)
+		}
+		literal := src.Kind == OpImm && src.ImmRaw == ""
+		symbol := false
+		if src.Kind == OpSym && strings.HasSuffix(src.Sym, "(SB)") {
+			_, _, symbol = parseSBRef(strings.TrimPrefix(src.Sym, "$"))
+		}
+		if literal || symbol || src.Kind == OpFP {
+			return state.assign(ins.Args[1].Reg, arm64PrivateFrameAddress{}, false)
+		}
+	}
+	if (op == "ADD" || op == "SUB") && string(ins.Op) == string(op) && len(ins.Args) >= 2 && len(ins.Args) <= 3 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" && ins.Args[1].Kind == OpReg && ins.Args[len(ins.Args)-1].Kind == OpReg {
+		value, present := state.address(ins.Args[1].Reg)
+		if present {
+			off := ins.Args[0].Imm
+			if op == "SUB" {
+				if off == int64(-1<<63) {
+					return false
+				}
+				off = -off
+			}
+			var ok bool
+			value, ok = arm64PrivateFrameOffset(value, off)
+			if !ok {
+				return false
+			}
+			return state.assign(ins.Args[len(ins.Args)-1].Reg, value, true)
+		}
+	}
+	if len(ins.Args) == 2 && ins.Args[0].Kind == OpMem {
+		if width, outputs, ok := arm64PrivateFrameLoad(ins); ok {
+			memory := ins.Args[0].Mem
+			if _, indexedFrame := state.address(memory.Index); indexedFrame {
+				return false
+			}
+			value, frame := state.address(memory.Base)
+			if frame {
+				value, ok = arm64PrivateFrameOffset(value, memory.Off)
+				if !ok || memory.Index != "" || memory.OffRaw != "" || value.offset < 0 || frameSize < 0 || frameSize > int64(1<<63-1)-8 || value.offset > frameSize+8-width {
+					return false
+				}
+			}
+			for _, reg := range outputs {
+				if !state.assign(reg, arm64PrivateFrameAddress{}, false) {
+					return false
+				}
+			}
+			return true
+		}
+	}
+	if form, handled, err := parseARM64GPDataForm(op, ins); handled {
+		if err != nil {
+			return false
+		}
+		for _, reg := range arm64GPDataInputRegisters(form) {
+			if _, frame := state.address(reg); frame {
+				return false
+			}
+		}
+		for _, reg := range arm64GPDataOutputRegisters(form) {
+			if !state.assign(reg, arm64PrivateFrameAddress{}, false) {
+				return false
+			}
+		}
+		return true
+	}
+	// Unknown effects cannot wash a tainted register clean. Source-relative SP
+	// memory itself is not address transport and remains subject to the separate
+	// continuation-cell overlap proof; aliases/indexes do not get that exemption.
+	for _, arg := range ins.Args {
+		registers := []Reg{arg.Reg, arg.ShiftReg, arg.Mem.Index}
+		registers = append(registers, arg.RegList...)
+		if arg.Kind == OpMem && !arm64StackReg(arg.Mem.Base) {
+			registers = append(registers, arg.Mem.Base)
+		}
+		for _, reg := range registers {
+			if _, frame := state.address(reg); frame {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (state arm64PrivateFrameAddresses) scalarMemory(form arm64ScalarMemoryForm, frameSize int64) bool {
+	// Validate the old address before changing R27; the store's transfer
+	// operand is read after that change, including a base/data R27 overlap.
+	if form.memory.Kind == OpMem {
+		mem := form.memory.Mem
+		if _, indexed := state.address(mem.Index); indexed {
+			return false
+		}
+		value, frame := state.address(mem.Base)
+		if frame {
+			if mem.Index != "" || form.pre || form.post {
+				return false
+			}
+			if form.store {
+				// Preserve the source-relative SP exemption from the coarse
+				// proof: its stores still undergo continuation-cell checks.
+				// A derived GP address needs the separate per-instruction
+				// DATA extent and complete typed transport proof.
+				if !arm64StackReg(mem.Base) {
+					return false
+				}
+			} else {
+				var ok bool
+				value, ok = arm64PrivateFrameOffset(value, mem.Off)
+				if !ok || !value.exact || value.offset < 0 || frameSize < 0 ||
+					frameSize > int64(1<<63-1)-8 || value.offset > frameSize+8-int64(form.bits/8) {
+					return false
+				}
+			}
+		}
+	}
+	if form.scratch {
+		scratch, private := state.scalarMemoryScratch(form)
+		if !state.assign("R27", scratch, private) {
+			return false
+		}
+	}
+	if form.store {
+		_, private := state.address(form.data)
+		return !private
+	}
+	return state.assign(form.data, arm64PrivateFrameAddress{}, false)
+}
+
+func (state arm64PrivateFrameAddresses) scalarMemoryScratch(form arm64ScalarMemoryForm) (arm64PrivateFrameAddress, bool) {
+	if !form.scratchAddress || form.scratchBase == "" {
+		return arm64PrivateFrameAddress{}, false
+	}
+	value, frame := state.address(form.scratchBase)
+	if frame {
+		if form.scratchKnown {
+			if next, ok := arm64PrivateFrameOffset(value, form.scratchOffset); ok {
+				return next, true
+			}
+		}
+		return arm64PrivateFrameAddress{}, true // Preserve may-frame; lose bounds.
+	}
+	return value, false
+}
+
+// The accepted subset is read-only, non-writeback, with a literal displacement
+// and exact destination bank/width. Ordinary lowering still validates the full
+// Go operand grammar; no unrecognized operation is treated as a load or kill.
+func arm64PrivateFrameLoad(ins Instr) (int64, []Reg, bool) {
+	if strings.Contains(string(ins.Op), ".") || len(ins.Args) != 2 || ins.Args[0].Kind != OpMem {
+		return 0, nil, false
+	}
+	op, dst := ins.Op, ins.Args[1]
+	width := map[Op]int64{"MOVB": 1, "MOVBU": 1, "MOVH": 2, "MOVHU": 2, "MOVW": 4, "MOVWU": 4, "MOVD": 8}[op]
+	if width != 0 && dst.Kind == OpReg && isARM64GeneralOrZeroReg(dst.Reg) {
+		return width, []Reg{dst.Reg}, true
+	}
+	width = map[Op]int64{"FMOVS": 4, "FMOVD": 8, "FMOVQ": 16}[op]
+	if width != 0 && dst.Kind == OpReg {
+		if _, ok := arm64ParseFReg(dst.Reg); ok {
+			return width, nil, true
+		}
+	}
+	if op == "LDP" || op == "LDPW" || op == "LDPSW" {
+		if dst.Kind != OpRegList || len(dst.RegList) != 2 || dst.RegList[0] == dst.RegList[1] ||
+			!isARM64GeneralOrZeroReg(dst.RegList[0]) || !isARM64GeneralOrZeroReg(dst.RegList[1]) {
+			return 0, nil, false
+		}
+		width = 16
+		if op != "LDP" {
+			width = 8
+		}
+		return width, dst.RegList, true
+	}
+	width = map[Op]int64{"FLDPS": 8, "FLDPD": 16, "FLDPQ": 32}[op]
+	if width != 0 && dst.Kind == OpRegList && len(dst.RegList) == 2 {
+		_, first := arm64ParseFReg(dst.RegList[0])
+		_, second := arm64ParseFReg(dst.RegList[1])
+		if first && second && dst.RegList[0] != dst.RegList[1] {
+			return width, nil, true
+		}
+	}
+	if op == "VLD1" && dst.Kind == OpReg {
+		kind, _, ok := arm64ParseVRegLane(dst.Reg)
+		if ok {
+			return map[byte]int64{'B': 1, 'H': 2, 'S': 4, 'D': 8}[kind], nil, true
+		}
+	}
+	if op == "VLD1" && dst.Kind == OpRegList && len(dst.RegList) >= 1 && len(dst.RegList) <= 4 {
+		arrangement, ok := parseARM64VectorArrangement(dst.RegList[0])
+		first, firstOK := arm64ParseVReg(dst.RegList[0])
+		if !ok || !firstOK {
+			return 0, nil, false
+		}
+		for index, reg := range dst.RegList {
+			parsed, valid := parseARM64VectorArrangement(reg)
+			vector, vectorOK := arm64ParseVReg(reg)
+			if !valid || !vectorOK || parsed != arrangement || vector != (first+index)%32 {
+				return 0, nil, false
+			}
+		}
+		return int64(len(dst.RegList) * arrangement.lanes * arrangement.elementBits / 8), nil, true
+	}
+	return 0, nil, false
+}
diff --git a/arm64_private_frame_read_test.go b/arm64_private_frame_read_test.go
new file mode 100644
index 000000000..f93f8ff23
--- /dev/null
+++ b/arm64_private_frame_read_test.go
@@ -0,0 +1,322 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64PrivateFrameLocalAffineReadPreservesCallerLink(t *testing.T) {
+	for _, read := range []string{
+		"ADD $8,RSP,R9\nVLD1 (R9),[V0.B16,V1.B16]\nMOVD $0,R9",
+		"MOVD RSP,R9\nADD $8,R9\nMOVD R9,R10\nMOVD (R10),R11\nMOVD $0,R9\nMOVD $0,R10",
+		"MOVD $8(RSP),R9\nFMOVD (R9),F0\nMOVD $0,R9",
+		"CBZ R7,alternate\nADD $8,RSP,R9\nB joined\nalternate:\nMOVD $8(RSP),R9\njoined:\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+	} {
+		source := arm64PrivateFrameStoreSource(read + "\nMOVB R11,(R6)")
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Errorf("a bounded local read followed by a proven full overwrite escaped the fresh frame: %s", read)
+			continue
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		for index, target := range arm64TypedNativeTargets {
+			ir, err := Translate(file, arm64PrivateCallCopyOptions(target))
+			if err != nil {
+				t.Fatalf("%s local affine read: %v", target, err)
+			}
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("read-%d.ll", index), fmt.Sprintf("read-%d.o", index), ir)
+		}
+	}
+}
+
+func TestARM64PrivateFrameAffineLatticeRetainsMayFrameAtJoins(t *testing.T) {
+	for _, incoming := range []arm64PrivateFrameAddresses{
+		{}, {"R9": {offset: 16, exact: true}}, {"R9": {}},
+	} {
+		state := arm64PrivateFrameAddresses{"R9": {offset: 8, exact: true}}
+		if !state.merge(incoming) {
+			t.Fatal("mixed/different-offset join did not retain an unknown frame address")
+		}
+		if value, frame := state.address("R9"); !frame || value.exact {
+			t.Fatal("join erased frame taint or invented an exact displacement")
+		}
+		copy := state.clone()
+		if !copy.assign("R10", copy["R9"], true) {
+			t.Fatal("copy failed")
+		}
+		if value, frame := copy.address("R10"); !frame || value.exact {
+			t.Fatal("copy washed mixed frame taint")
+		}
+		if !copy.assign("R9", arm64PrivateFrameAddress{}, false) {
+			t.Fatal("known full overwrite failed")
+		}
+		if _, frame := copy.address("R9"); frame || len(state) != 1 {
+			t.Fatal("overwrite did not kill exactly its destination or clone changed the source")
+		}
+	}
+	state := arm64PrivateFrameAddresses{"R9": {offset: 8, exact: true}}
+	if state.merge(state.clone()) || state["R9"] != (arm64PrivateFrameAddress{offset: 8, exact: true}) {
+		t.Fatal("identical affine paths must keep their exact offset")
+	}
+}
+
+func TestARM64PrivateFrameLocalReadNativeEffectsCannotConsumeTemporaries(t *testing.T) {
+	for _, op := range []string{"SVC $0", "HVC $0", "SMC $0", "BRK $0", "HLT $0", "DCPS1 $0", "DCPS2 $0", "DCPS3 $0", "DRPS", "ERET", "UNDEF"} {
+		source := arm64PrivateFrameStoreSource("ADD $8,RSP,R0\n" + op + "\nMOVD $0,R0")
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("unmodelled native/exception transport borrowed a local-read proof: %s", op)
+		}
+	}
+}
+
+func TestARM64PrivateFrameLocalReadFamilyObjects(t *testing.T) {
+	loads := []string{}
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		loads = append(loads, op+" (R9),R11")
+	}
+	for _, op := range []string{"FMOVS", "FMOVD", "FMOVQ"} {
+		loads = append(loads, op+" (R9),F0")
+	}
+	for _, op := range []string{"LDP", "LDPW", "LDPSW"} {
+		loads = append(loads, op+" (R9),(R11,R12)")
+	}
+	for _, op := range []string{"FLDPS", "FLDPD", "FLDPQ"} {
+		loads = append(loads, op+" (R9),(F0,F1)")
+	}
+	for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D1", "D2"} {
+		registers := []string{}
+		for count := 0; count < 4; count++ {
+			registers = append(registers, fmt.Sprintf("V%d.%s", count, arrangement))
+			loads = append(loads, "VLD1 (R9),["+strings.Join(registers, ",")+"]")
+		}
+	}
+	for _, lane := range []struct {
+		kind  string
+		count int
+	}{{kind: "B", count: 16}, {kind: "H", count: 8}, {kind: "S", count: 4}, {kind: "D", count: 2}} {
+		for index := 0; index < lane.count; index++ {
+			loads = append(loads, fmt.Sprintf("VLD1 (R9),V0.%s[%d]", lane.kind, index))
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for index, load := range loads {
+		t.Run(load, func(t *testing.T) {
+			source := arm64PrivateFrameStoreSource("ADD $8,RSP,R9\n" + load + "\nMOVD $0,R9\nMOVB R11,(R6)")
+			source = strings.Replace(source, "$32-24", "$80-24", 1)
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !arm64CallFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("a known local read acquired frame-address escape")
+			}
+			for _, target := range arm64TypedNativeTargets {
+				ir, err := Translate(file, arm64PrivateCallCopyOptions(target))
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("load-%d.ll", index), fmt.Sprintf("load-%d.o", index), ir)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateFrameLocalReadEscapesAndUnknownEffectsRejected(t *testing.T) {
+	for _, effect := range []string{
+		"MOVD RSP,R9\nMOVD R9,holder(SB)\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD R9,R10\nMOVD R10,(R6)\nMOVD $0,R9\nMOVD $0,R10",
+		"MOVD RSP,R9\nMOVD R9,dst+0(FP)\nMOVD $0,R9",
+		"MOVD RSP,R9\nMOVD R9,32(RSP)\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nVLD1 (R9),[V0.B16]", // live at call
+		"ADD $8,RSP,R9\nVMOV R9,V0.D[0]\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nEOR $8,R9,R10\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nEOR R9,R9\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVK $1,R9\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD (R6)(R9),R9\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD (R9)(R7),R11\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nVLD1.P 16(R9),[V0.B16]\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD.W 8(R9),R11\nMOVD $0,R9",
+		"MOVD.P 8(RSP),R11\nMOVD.W -8(RSP),R11\nADD $8,RSP,R9\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+		"MOVD (RSP)(R7),R11\nADD $8,RSP,R9\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD R11,(R9)\nMOVD $0,R9",
+		"MOVD $-8(RSP),R9\nMOVD (R9),R11\nMOVD $0,R9",
+		"ADD $32,RSP,R9\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+		"CBZ R7,alternate\nADD $8,RSP,R9\nB joined\nalternate:\nMOVD R6,R9\njoined:\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+		"CBZ R7,alternate\nADD $8,RSP,R9\nB joined\nalternate:\nADD $16,RSP,R9\njoined:\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+		"CBZ R7,alternate\nADD $8,RSP,R9\nB joined\nalternate:\nADD $16,RSP,R9\njoined:\nMOVD R9,R10\nMOVD R10,holder(SB)\nMOVD $0,R9\nMOVD $0,R10",
+		"ADD $8,RSP,R9\nloop:\nADD $8,R9\nCBNZ R7,loop\nVLD1 (R9),[V0.B16]\nMOVD $0,R9",
+	} {
+		t.Run(effect, func(t *testing.T) {
+			source := arm64PrivateFrameStoreSource(effect) + "\nGLOBL holder(SB),NOPTR,$8\n"
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if arm64CallFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("unproved/escaped frame address obtained a no-escape proof")
+			}
+			for _, target := range arm64TypedNativeTargets {
+				_, err := Translate(file, arm64PrivateCallCopyOptions(target))
+				switch effect {
+				case "ADD $8,RSP,R9\nVLD1 (R9),[V0.B16]",
+					"ADD $8,RSP,R9\nMOVD.W 8(R9),R11\nMOVD $0,R9",
+					"ADD $8,RSP,R9\nMOVD R11,(R9)\nMOVD $0,R9":
+					// Preserve the original source-only negative above. The
+					// explicit typed LLVM call does not consume this unused GP
+					// address. Every certified store/read/writeback lies in
+					// private DATA, not sp0. This is object coverage, not an
+					// execution claim for this fixture's undefined R11 data;
+					// PrivateDataMemoryFamily supplies initialized numerical
+					// and full-canary runtime counterparts.
+					if err != nil {
+						t.Fatalf("%s typed bounded data/scratch: %v", target, err)
+					}
+					continue
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s unproved local frame use did not remain context-required: %v", target, err)
+				}
+			}
+		})
+	}
+	for _, effect := range []string{
+		"ADD $8,RSP,R9\nMOVD R9,R0\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD R9,8(RSP)\nMOVD $0,R9",
+	} {
+		source := strings.Replace(arm64PrivateCallCopySource, "\tCALL runtime·memmove(SB)", effect+"\nCALL runtime·memmove(SB)", 1)
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatal("a live/call-transport frame address crossed a real CALL")
+		}
+	}
+	for _, effect := range []string{"ADD $8,RSP,R9", "ADD $8,RSP,R9\nMOVD R9,R0\nMOVD $0,R9"} {
+		source := strings.Replace(arm64PrivateCallCopySource, "\tRET", effect+"\nRET", 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatal("a live/result-register frame address crossed RET")
+		}
+	}
+}
+
+func TestARM64PrivateFrameLocalReadSurvivesAuditedHelperCoalescing(t *testing.T) {
+	source := strings.Replace(arm64PrivateCallCopySource, "\tCALL runtime·memmove(SB)", "\tMOVD $1,R11\nCALL helper<>(SB)\nADD $8,RSP,R9\nVLD1 (R9),[V0.B16]\nMOVD $0,R9\nMOVB R11,(R6)", 1)
+	source += "TEXT helper<>(SB),NOSPLIT,$0\nADD $1,R11\nRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	coalesced, err := coalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !coalesced.Funcs[0].arm64PrivateUnexposedFrame || !arm64CallFrameUnexposed(coalesced.Funcs[0]) {
+		t.Fatal("audited helper rewriting lost the original affine-read/no-escape decision")
+	}
+	if _, err := Translate(coalesced, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateFrameLocalAffineRead(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := strings.Replace(arm64PrivateCallCopySource, "$32-24", "$80-24", 1)
+	source = strings.Replace(source, "\tRET", `
+	MOVD $0x0706050403020100,R10
+	MOVD R10,32(RSP)
+	MOVD $0x0f0e0d0c0b0a0908,R10
+	MOVD R10,40(RSP)
+	MOVD $0x1716151413121110,R10
+	MOVD R10,48(RSP)
+	MOVD $0x1f1e1d1c1b1a1918,R10
+	MOVD R10,56(RSP)
+	MOVD n+16(FP),R7
+	CBZ R7,alternate
+	MOVD RSP,R9
+	ADD $32,R9
+	B joined
+alternate:
+	MOVD $32(RSP),R9
+joined:
+	MOVD R9,R11
+	MOVD $0,R9
+	VLD1 (R11),[V0.B16,V1.B16]
+	MOVD $0,R11
+	MOVD dst+0(FP),R5
+	VST1 [V0.B16,V1.B16],(R5)
+	RET`, 1)
+	goSource := strings.Replace(source, "TEXT ABI0Copy(SB)", "TEXT ·ABI0Copy(SB)", 1)
+	runARM64LocalRegisterGoOracle(t, goSource, `package main
+import "unsafe"
+func ABI0Copy(dst,src unsafe.Pointer,n uintptr)
+func main() {
+ for _,dst:=range []int{0,1,9,17,31} { for _,src:=range []int{0,1,9,17,31} { for _,n:=range []int{0,1,2,3,8,17,32,33} {
+  var data, want [96]byte
+  for i:=range data { data[i]=byte(i*37+dst*7+src*11+n); want[i]=data[i] }
+  var snapshot [33]byte
+  for i:=0;i<n;i++ { snapshot[i]=want[src+i] }
+  for i:=0;i<n;i++ { want[dst+i]=snapshot[i] }
+  for i:=0;i<32;i++ { want[dst+i]=byte(i) }
+  ABI0Copy(unsafe.Pointer(&data[dst]),unsafe.Pointer(&data[src]),uintptr(n))
+  if data!=want { panic("actual Go affine local-read/frame/call/canary mismatch") }
+ } } }
+}
+`, len(runner) != 0)
+	t.Log("actual Go passed 200 local-read/call/overlap/unaligned/full-canary cases")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, arm64PrivateCallCopyOptions(triple))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	const driver = `#include <stdint.h>
+extern void ABI0Copy(void *, const void *, uint64_t);
+int main(void) {
+ const int offsets[]={0,1,9,17,31}, sizes[]={0,1,2,3,8,17,32,33};
+ for(int d=0;d<5;d++) for(int s=0;s<5;s++) for(int z=0;z<8;z++) {
+  unsigned char data[96], want[96], snapshot[33];
+  int dst=offsets[d],src=offsets[s],n=sizes[z];
+  for(int i=0;i<96;i++) data[i]=want[i]=(unsigned char)(i*37+dst*7+src*11+n);
+  for(int i=0;i<n;i++) snapshot[i]=want[src+i];
+  for(int i=0;i<n;i++) want[dst+i]=snapshot[i];
+  for(int i=0;i<32;i++) want[dst+i]=(unsigned char)i;
+  ABI0Copy(data+dst,data+src,(uint64_t)n);
+  for(int i=0;i<96;i++) if(data[i]!=want[i]) return 1;
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_frame_local_reads", triple, module.String(), driver, runner)
+}
diff --git a/arm64_private_frame_transport.go b/arm64_private_frame_transport.go
new file mode 100644
index 000000000..9c57d0d2d
--- /dev/null
+++ b/arm64_private_frame_transport.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+)
+
+// Absent by default. This is the same explicit typed transport consumed by
+// callSym/lowerRET, not a register preservation or pointer ownership promise.
+type arm64PrivateFrameTransport struct {
+	entry     FuncSig
+	resolve   func(string) string
+	sigs      map[string]FuncSig
+	nanosleep *arm64NanosleepInputProof
+}
+
+func (transport *arm64PrivateFrameTransport) consume(ins Instr, addresses arm64PrivateFrameAddresses, entryInternal bool) bool {
+	state := &arm64ControlState{
+		regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+		memory: make(map[string]arm64ControlValue),
+	}
+	for reg, address := range addresses {
+		offset := "unknown"
+		if address.exact {
+			offset = strconv.FormatInt(address.offset, 10)
+		}
+		state.regs[reg] = arm64ControlFromMap(map[string]bool{"sp:" + offset: true})
+	}
+	if arm64ControlOp(ins) == OpRET {
+		if len(ins.Args) != 0 {
+			return false // Native/symbol return transport remains unproved here.
+		}
+		sig := transport.entry
+		if sig.ARM64ClosureABI != nil || entryInternal && sig.ARM64GoRegisterABI == nil {
+			return false
+		}
+		// FP result stores already reject frame addresses in transfer. Include
+		// the register fallback as well, even when a source FP result is written.
+		sig.Frame = FrameLayout{}
+		result := &arm64ControlState{regs: make(map[Reg]arm64ControlValue), memory: make(map[string]arm64ControlValue)}
+		arm64ControlWriteCallResults(result, sig, entryInternal, arm64ControlExternal())
+		if sig.Ret != Void && len(result.regs) == 0 {
+			return false
+		}
+		for reg := range result.regs {
+			if _, frame := addresses.address(reg); frame {
+				return false
+			}
+		}
+		return true
+	}
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+		return false // Local register helpers and unknown/native calls stay strict.
+	}
+	symbol := strings.TrimSuffix(ins.Args[0].Sym, "(SB)")
+	name := symbol
+	if transport.resolve != nil {
+		name = transport.resolve(name)
+	}
+	sig, present := transport.sigs[name]
+	if !present {
+		return false
+	}
+	internal := strings.HasSuffix(symbol, "<ABIInternal>")
+	inputs, known := arm64ControlCallInputs(state, sig, internal)
+	if !known {
+		return false
+	}
+	for _, input := range inputs {
+		for _, token := range arm64ControlKeys(input) {
+			if strings.HasPrefix(token, "sp:") || strings.HasPrefix(token, "fp:") || strings.HasPrefix(token, "fpa:") {
+				return false
+			}
+		}
+	}
+	// A declared result overwrites only its actual GP/FP transport. Untouched
+	// scratch addresses remain private; ordinary source must redefine them
+	// before a caller-save use, independently of this non-escape proof.
+	arm64ControlWriteCallResults(state, sig, internal, arm64ControlExternal())
+	for reg := range addresses {
+		value := arm64ControlRead(state.regs, reg)
+		frame := false
+		for _, token := range arm64ControlKeys(value) {
+			frame = frame || strings.HasPrefix(token, "sp:")
+		}
+		if !frame {
+			delete(addresses, reg)
+		}
+	}
+	return true
+}
diff --git a/arm64_private_frame_transport_test.go b/arm64_private_frame_transport_test.go
new file mode 100644
index 000000000..406cb2f4e
--- /dev/null
+++ b/arm64_private_frame_transport_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64PrivateLiveScratchSource(call string) string {
+	source := arm64CallCopyLoopSource(call, "LDP (R6),(R2,R5)\nSTP (R2,R5),(R7)")
+	// This fresh-frame pointer is never an argument, stored address or result.
+	// The original Go caller-save value may be clobbered: no later instruction
+	// consumes it. Requiring a physical clear before CALL/RET is unnecessary.
+	return strings.Replace(source, "\t"+call+" runtime·memmove(SB)", "\tADD $32,RSP,R17\n\tMOVD (R17),R11\n\t"+call+" runtime·memmove(SB)", 1)
+}
+
+func TestARM64PrivateFrameTransportStillRejectsEscapes(t *testing.T) {
+	pkg := arm64PrivateCallDeclarations(t, "func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr\n")
+	callee := arm64CallInputMemmoveSig(t)
+	resolve := func(sym string) string {
+		return strings.ReplaceAll(goStripABISuffix(strings.TrimPrefix(sym, "·")), "·", ".")
+	}
+	for _, effect := range []string{
+		"MOVD R17,8(RSP)",
+		"MOVD R17,dst+0(FP)",
+		"MOVD R17,ret+24(FP)",
+		"MOVD R17,holder(SB)",
+		"MOVD R17,(R7)",
+		"FMOVD R17,F0",
+		"VMOV R17,V0.D[0]",
+		"CBZ R4,alternate\nB merged\nalternate:\nADD $40,RSP,R17\nmerged:\nMOVD (R17),R11",
+		"ADD $56,RSP,R17\nLDP (R17),(R10,R11)",
+	} {
+		t.Run(effect, func(t *testing.T) {
+			source := strings.Replace(arm64PrivateLiveScratchSource("CALL"), "\tCALL runtime·memmove(SB)", effect+"\n\tCALL runtime·memmove(SB)", 1)
+			source += "\nGLOBL holder(SB),NOPTR,$8\n"
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", "arm64")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes,
+				func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" })
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs, ResolveSym: resolve}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s escaped/unbounded private transport: %v", target, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s Module escaped/unbounded private transport: %v", target, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+					ManualSig: func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" },
+				})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s GoModule escaped/unbounded private transport: %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PrivateFrameTypedTerminatorTransports(t *testing.T) {
+	entry := FuncSig{Name: "Entry", Ret: Void}
+	resolve := func(sym string) string { return goStripABISuffix(sym) }
+	for _, tc := range []struct {
+		name    string
+		callee  FuncSig
+		symbol  string
+		present bool
+		want    bool
+	}{
+		{name: "explicit_zero_arguments", callee: FuncSig{Ret: Void}, symbol: "X", present: true, want: true},
+		{name: "missing_target", symbol: "X"},
+		{name: "unproved_internal", callee: FuncSig{Ret: Void}, symbol: "X<ABIInternal>", present: true},
+		{name: "private_custom_argument", callee: FuncSig{Ret: Void, Args: []LLVMType{Ptr}, ArgRegs: []Reg{"R17"}}, symbol: "X", present: true},
+		{name: "invalid_custom_argument", callee: FuncSig{Ret: Void, Args: []LLVMType{Ptr}, ArgRegs: []Reg{"R40"}}, symbol: "X", present: true},
+		{name: "incomplete_custom_arguments", callee: FuncSig{Ret: Void, Args: []LLVMType{Ptr, I64}, ArgRegs: []Reg{"R0"}}, symbol: "X", present: true},
+		{name: "hidden_carrier", callee: FuncSig{Ret: Void, ARM64ClosureABI: &ARM64ClosureABI{}}, symbol: "X", present: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			transport := arm64PrivateFrameTransport{entry: entry, resolve: resolve, sigs: make(map[string]FuncSig)}
+			if tc.present {
+				transport.sigs["X"] = tc.callee
+			}
+			state := arm64PrivateFrameAddresses{"R17": {offset: 32, exact: true}}
+			ins := Instr{Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: tc.symbol + "(SB)"}}}
+			if got := transport.consume(ins, state, false); got != tc.want {
+				t.Fatalf("typed terminator proof=%v, want %v", got, tc.want)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		name string
+		typ  LLVMType
+		reg  Reg
+		want bool
+	}{
+		{"unused_void", Void, "R17", true},
+		{"unused_scalar_scratch", I64, "R17", true},
+		{"private_integer_result", I64, "R0", false},
+		{"private_pointer_result", Ptr, "R0", false},
+		{"private_fp_result", "double", "F0", false},
+		{"mixed_private_integer_result", "{ double, i64 }", "R0", false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			transport := arm64PrivateFrameTransport{entry: FuncSig{Ret: tc.typ}}
+			state := arm64PrivateFrameAddresses{tc.reg: {offset: 32, exact: true}}
+			if got := transport.consume(Instr{Op: OpRET}, state, false); got != tc.want {
+				t.Fatalf("typed result proof=%v, want %v", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateUntransportedScratch(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, call := range []string{"CALL", "BL"} {
+		t.Run(call, func(t *testing.T) {
+			source := arm64PrivateLiveScratchSource(call)
+			runARM64LocalRegisterGoOracle(t, source, `package main
+import "unsafe"
+func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr
+func main() {
+    for _,n:=range []int{0,1,2,7,8,16,17,31,32,33,64,131} {
+        var src,dst,want [160]byte
+        for i:=range src { src[i]=byte(i*71+29); dst[i]=0xa7; want[i]=0xa7 }
+        copy(want[17:],src[5:5+n])
+        if CopyLoop(unsafe.Pointer(&dst[17]),unsafe.Pointer(&src[5]),uintptr(n))!=uintptr(n) || dst!=want {
+            panic("typed unused private scratch copy/canary mismatch")
+        }
+    }
+}
+`, len(runner) != 0, "1.20")
+			ir := arm64CallCopyLoopModule(t, source, triple)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_unused_"+call, triple, ir, `#include <stdint.h>
+#include <string.h>
+extern uint64_t CopyLoop(void *,const void *,uint64_t);
+void runtime_memmove(void *,const void *,uint64_t) __asm__("runtime.memmove");
+void runtime_memmove(void *d,const void *s,uint64_t n) { memmove(d,s,(size_t)n); }
+int main(void) {
+    const int sizes[]={0,1,2,7,8,16,17,31,32,33,64,131};
+    for(unsigned j=0;j<sizeof(sizes)/sizeof(sizes[0]);j++) {
+        int n=sizes[j];
+        unsigned char src[160],dst[160],want[160];
+        for(int i=0;i<160;i++) { src[i]=(unsigned char)(i*71+29); dst[i]=0xa7; want[i]=0xa7; }
+        memcpy(want+17,src+5,(size_t)n);
+        if(CopyLoop(dst+17,src+5,(uint64_t)n)!=(uint64_t)n || memcmp(dst,want,sizeof(dst))) return 1;
+    }
+    return 0;
+}
+`, runner)
+		})
+	}
+}
+
+func TestARM64PrivateFrameUntransportedScratchObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	pkg := arm64PrivateCallDeclarations(t, "func CopyLoop(dst,src unsafe.Pointer,n uintptr) uintptr\n")
+	callee := arm64CallInputMemmoveSig(t)
+	resolve := func(sym string) string {
+		return strings.ReplaceAll(goStripABISuffix(strings.TrimPrefix(sym, "·")), "·", ".")
+	}
+	for _, call := range []string{"CALL", "BL"} {
+		source := arm64PrivateLiveScratchSource(call)
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatal("uncontracted source-only proof admitted a live scratch")
+		}
+		sizes := types.SizesFor("gc", "arm64")
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes,
+			func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" })
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, target := range arm64TypedNativeTargets {
+			t.Run(call+"_"+target, func(t *testing.T) {
+				opt := Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs, ResolveSym: resolve}
+				text, err := Translate(file, opt)
+				if err != nil {
+					t.Fatalf("typed unused private scratch: %v", err)
+				}
+				compileLLVMToObject(t, llc, target, "text.ll", "text.o", text)
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer module.Dispose()
+				compileLLVMToObject(t, llc, target, "module.ll", "module.o", module.String())
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+					ManualSig: func(name string) (FuncSig, bool) { return callee, name == "runtime.memmove" },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer bound.Module.Dispose()
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("go-%s.ll", call), fmt.Sprintf("go-%s.o", call), bound.Module.String())
+			})
+		}
+	}
+}
diff --git a/arm64_private_helper_escape_test.go b/arm64_private_helper_escape_test.go
new file mode 100644
index 000000000..558b77b20
--- /dev/null
+++ b/arm64_private_helper_escape_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func requireARM64PrivateHelperContext(t *testing.T, source string, keep func(string, string) bool) {
+	t.Helper()
+	pkg := mustGoPackage(t, "test/review", "package review\nfunc Run(uint64) uint64\nfunc Escape()\n")
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		"aarch64-unknown-linux-musl",
+	} {
+		ctx := llvm.NewContext()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple,
+			ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") },
+			KeepFunc:   keep,
+		})
+		if tr != nil {
+			tr.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s lacks a complete private continuation contract: %v", triple, err)
+		}
+	}
+}
+
+func TestARM64PrivateHelperPlatform18NeedsContext(t *testing.T) {
+	base := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	for _, instruction := range []string{
+		"MOVD $42,R18_PLATFORM", "MOVW $42,R18_PLATFORM",
+		"MOVD R18_PLATFORM,R20", "ADD $1,R18_PLATFORM,R20",
+	} {
+		for _, site := range []string{"helper", "caller"} {
+			t.Run(site+"/"+instruction, func(t *testing.T) {
+				anchor := "ADC $0,R9,R20"
+				if site == "caller" {
+					anchor = "MOVD $291,R0"
+				}
+				source := strings.Replace(base, anchor, instruction+"\n"+anchor, 1)
+				requireARM64GoAssemblerResult(t, source, true)
+				requireARM64PrivateHelperContext(t, source, nil)
+			})
+		}
+	}
+	for _, instruction := range []string{
+		"MOVD (R18_PLATFORM),R3", "MOVD R3,(R18_PLATFORM)",
+		"MOVD $0(R18_PLATFORM),R3", "ADD R18_PLATFORM<<1,R3,R3",
+	} {
+		t.Run("caller-address-or-shift/"+instruction, func(t *testing.T) {
+			source := strings.Replace(base, "MOVD $291,R0", instruction+"\nMOVD $291,R0", 1)
+			requireARM64GoAssemblerResult(t, source, true)
+			requireARM64PrivateHelperContext(t, source, nil)
+		})
+	}
+	for _, name := range []string{"R18_PLATFORM", "R18", "W18"} {
+		reg, ok := parseReg(name)
+		if !ok || reg != "R18" || arm64PrivateDataGP(reg) {
+			t.Errorf("physical platform register %s lost its constraint: %q, %v", name, reg, ok)
+		}
+	}
+}
+
+func TestARM64PrivateHelperHidden26EntryIsNotGuessed(t *testing.T) {
+	source := strings.Replace(arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)"), "ADC $0,R9,R20", "MOVD R26,R20", 1)
+	requireARM64GoAssemblerResult(t, source, true)
+	requireARM64PrivateHelperContext(t, source, nil)
+}
+
+func TestARM64PrivateHelperEscapeSourceAudit(t *testing.T) {
+	base := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	for _, test := range []struct {
+		name, suffix string
+		goRejected   bool
+	}{
+		{"pc-escape", "TEXT ·Escape(SB),4,$0-0\nADR -3(PC),R0\nRET\n", false},
+		// Go diagnoses and then panics for this out-of-TEXT branch. Its
+		// separate defect observation is not a source-rejection proof.
+		{"pc-branch", "TEXT ·Escape(SB),4,$0-0\nB -3(PC)\n", true},
+		{"raw-layout", "TEXT ·Escape(SB),4,$0-0\nWORD $0x17ffffff\nRET\n", false},
+		{"raw-doubleword-layout", "TEXT ·Escape(SB),4,$0-0\nDWORD $0x17ffffff\nRET\n", false},
+		{"pc-alignment", "TEXT ·Escape(SB),4,$0-0\nPCALIGN $16\nRET\n", false},
+		{"local-code-address", "TEXT ·Escape(SB),4,$0-0\nADR done,R0\ndone:\nRET\n", false},
+		{"mem-sym-read", "TEXT ·Escape(SB),4,$0-0\nMOVD mix<>(SB)(R3),R0\nRET\n", false},
+		{"mem-sym-offset", "TEXT ·Escape(SB),4,$0-0\nMOVD mix<>+4(SB)(R3),R0\nRET\n", false},
+		{"mem-sym-write", "TEXT ·Escape(SB),4,$0-0\nMOVD R0,mix<>(SB)(R3)\nRET\n", false},
+		{"indexed-symbol-address", "TEXT ·Escape(SB),4,$0-0\nMOVD $mix<>(SB)(R3),R0\nRET\n", false},
+		{"symbol-address", "TEXT ·Escape(SB),4,$0-0\nMOVD $mix<>(SB),R0\nRET\n", false},
+		{"data-symbol-alias", "DATA mix<>+0(SB)/8,$0\n", false},
+		{"data-relocation", "DATA saved<>+0(SB)/8,$mix<>(SB)\nGLOBL saved<>(SB),8,$8\n", false},
+		// Go rejects the redeclared symbol, but a directly parsed File must
+		// still not invent a closed helper when it contains this collision.
+		{"globl-symbol-alias", "GLOBL mix<>(SB),8,$8\n", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := base + test.suffix
+			if test.name != "pc-branch" {
+				requireARM64GoAssemblerResult(t, source, !test.goRejected)
+			}
+			requireARM64PrivateHelperContext(t, source, func(text, _ string) bool {
+				return text == "·Run" || text == "mix<>"
+			})
+		})
+	}
+}
diff --git a/arm64_private_indexed_table_test.go b/arm64_private_indexed_table_test.go
new file mode 100644
index 000000000..c2d0660ca
--- /dev/null
+++ b/arm64_private_indexed_table_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64PrivateIndexedSource(store, load string, shift int) string {
+	return fmt.Sprintf(`#include "textflag.h"
+TEXT ·Indexed(SB),NOSPLIT,$80-24
+    CALL ·Noop(SB)
+    MOVD dst+0(FP),R7
+    MOVD n+8(FP),R11
+    AND $7,R11
+    ADD $16,RSP,R17
+    MOVD $0x123456789abcde7e,R5
+    %s R5,0(R17)(R11<<%d)
+    %s 0(R17)(R11<<%d),R12
+    MOVD R12,(R7)
+    MOVD R12,ret+16(FP)
+    RET
+TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0
+    RET
+`, store, shift, load, shift)
+}
+
+func TestARM64PrivateIndexedScalarDataObjects(t *testing.T) {
+	for _, tc := range []struct {
+		store, load string
+		shift       int
+	}{
+		{"MOVB", "MOVBU", 0}, {"MOVBU", "MOVBU", 0},
+		{"MOVH", "MOVHU", 1}, {"MOVHU", "MOVHU", 1},
+		{"MOVW", "MOVWU", 2}, {"MOVWU", "MOVWU", 2},
+		{"MOVD", "MOVD", 3},
+	} {
+		t.Run(tc.store, func(t *testing.T) {
+			source := arm64PrivateIndexedSource(tc.store, tc.load, tc.shift)
+			arm64PrivateDataBoundObjects(t, source, "func Indexed(dst *uint64,n uint64) uint64", tc.store)
+		})
+	}
+}
+
+const arm64PrivateCountedTableSource = `#include "textflag.h"
+TEXT ·CountedTable(SB),0,$32904-16
+    CALL ·Noop(SB)
+    MOVD n+0(FP),R14
+    MOVD $24,R5
+    MOVD $256,R6
+count:
+    MOVD $16384,R2
+    CMP R2,R6
+    BGE allocated
+    CMP R14,R6
+    BGE allocated
+    SUB $1,R5
+    LSL $1,R6
+    B count
+allocated:
+    ADD $128,RSP,R17
+    MOVD R17,R4
+    ADD R6<<1,R17,R6
+clear:
+    STP.P (ZR,ZR),64(R4)
+    STP (ZR,ZR),-48(R4)
+    STP (ZR,ZR),-32(R4)
+    STP (ZR,ZR),-16(R4)
+    CMP R4,R6
+    BHI clear
+    MOVD $0,R6
+    MOVD R5,64(RSP)
+    CALL ·Noop(SB)
+    MOVD 64(RSP),R5
+    MOVW n+0(FP),R11
+    MOVW $0xa7bd,R16
+    MULW R16,R11
+    LSRW R5,R11
+    MOVD $0x1234,R3
+    MOVH R3,0(R17)(R11<<1)
+    MOVW n+0(FP),R11
+    EORW $1,R11
+    MULW R16,R11
+    LSRW R5,R11
+    MOVHU 0(R17)(R11<<1),R12
+    MOVD R12,ret+8(FP)
+    RET
+TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0
+    RET
+`
+
+func TestARM64PrivateCountedTableExtentObjects(t *testing.T) {
+	arm64PrivateDataBoundObjects(t, arm64PrivateCountedTableSource, "func CountedTable(n uint64) uint64", "counted-table")
+}
+
+func arm64PrivateIndexedModule(t *testing.T, source, declaration, target string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "test/indexed", "package indexed\n"+declaration+"\nfunc Noop()\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: target,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer bound.Module.Dispose()
+	return bound.Module.String()
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateIndexedScalarData(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		store, load  string
+		shift, bytes int
+	}{
+		{"MOVB", "MOVBU", 0, 1}, {"MOVBU", "MOVBU", 0, 1},
+		{"MOVH", "MOVHU", 1, 2}, {"MOVHU", "MOVHU", 1, 2},
+		{"MOVW", "MOVWU", 2, 4}, {"MOVWU", "MOVWU", 2, 4},
+		{"MOVD", "MOVD", 3, 8},
+	} {
+		t.Run(tc.store, func(t *testing.T) {
+			source := arm64PrivateIndexedSource(tc.store, tc.load, tc.shift)
+			mask := ^uint64(0)
+			if tc.bytes < 8 {
+				mask = uint64(1)<<uint(tc.bytes*8) - 1
+			}
+			want := uint64(0x123456789abcde7e) & mask
+			goSource := fmt.Sprintf(`package main
+func Indexed(dst *uint64,n uint64) uint64
+func Noop()
+func main() {
+    for _,n := range []uint64{0,1,2,3,4,5,6,7,8,255,^uint64(0)} {
+        data := [3]uint64{0xa7a7a7a7a7a7a7a7,0,0xb8b8b8b8b8b8b8b8}
+        if Indexed(&data[1],n) != %#x || data != [3]uint64{0xa7a7a7a7a7a7a7a7,%#x,0xb8b8b8b8b8b8b8b8} {
+            panic("indexed scalar value/canary mismatch")
+        }
+    }
+}
+`, want, want)
+			runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+			ir := arm64PrivateIndexedModule(t, source, "func Indexed(dst *uint64,n uint64) uint64", target)
+			cSource := fmt.Sprintf(`#include <stdint.h>
+extern uint64_t Indexed(uint64_t *,uint64_t);
+int main(void) {
+    const uint64_t values[]={0,1,2,3,4,5,6,7,8,255,UINT64_MAX};
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint64_t data[]={UINT64_C(0xa7a7a7a7a7a7a7a7),0,UINT64_C(0xb8b8b8b8b8b8b8b8)};
+        if(Indexed(data+1,values[i])!=UINT64_C(%#x) || data[1]!=UINT64_C(%#x) ||
+            data[0]!=UINT64_C(0xa7a7a7a7a7a7a7a7) || data[2]!=UINT64_C(0xb8b8b8b8b8b8b8b8)) return 1;
+    }
+    return 0;
+}
+`, want, want)
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "indexed_scalar_"+tc.store, target, ir, cSource, runner)
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateCountedTable(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	runARM64LocalRegisterGoOracle(t, arm64PrivateCountedTableSource, `package main
+func CountedTable(n uint64) uint64
+func Noop()
+func main() {
+    for _,n := range []uint64{0,1,255,256,257,511,512,513,1024,4096,8192,16383,16384,65536,1<<63-1,^uint64(0)} {
+        size,shift:=uint64(256),uint(24)
+        for size<16384 && int64(size)<int64(n) { size*=2; shift-- }
+        first:=uint32(n)*0xa7bd>>shift
+        second:=(uint32(n)^1)*0xa7bd>>shift
+        want:=uint64(0)
+        if first==second { want=0x1234 }
+        if CountedTable(n)!=want { panic("counted clear/index/typed spill mismatch") }
+    }
+}
+`, len(runner) != 0, "1.20")
+	ir := arm64PrivateIndexedModule(t, arm64PrivateCountedTableSource, "func CountedTable(n uint64) uint64", target)
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "counted_private_table", target, ir, `#include <stdint.h>
+extern uint64_t CountedTable(uint64_t);
+int main(void) {
+    const uint64_t values[]={0,1,255,256,257,511,512,513,1024,4096,8192,16383,16384,65536,INT64_MAX,UINT64_MAX};
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint64_t n=values[i],size=256;
+        unsigned shift=24;
+        while(size<16384 && (int64_t)size<(int64_t)n) { size*=2; shift--; }
+        uint32_t first=((uint32_t)n*UINT32_C(0xa7bd))>>shift;
+        uint32_t second=(((uint32_t)n^UINT32_C(1))*UINT32_C(0xa7bd))>>shift;
+        if(CountedTable(n)!=(first==second?UINT64_C(0x1234):0)) return 1;
+    }
+    return 0;
+}
+`, runner)
+}
diff --git a/arm64_private_p256_register_go127_test.go b/arm64_private_p256_register_go127_test.go
new file mode 100644
index 000000000..a782f418b
--- /dev/null
+++ b/arm64_private_p256_register_go127_test.go
@@ -0,0 +1,348 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Use the current Go helper's complete body. The test's scalar-only ABI0
+// wrapper supplies each real register input and exposes all four outputs plus
+// an independent check that the helper preserves R0/R2. No pointer/frame
+// nonalias promise, library-name registry or scalar helper signature is used.
+func arm64PrivateP256Source(t *testing.T, helper string, inputCount int, outputs []Reg) string {
+	t.Helper()
+	path := filepath.Join(runtime.GOROOT(), "src", "crypto", "internal", "fips140", "nistec", "p256_asm_arm64.s")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	prefix := source[:strings.Index(source, "DATA p256const0<>")]
+	start := strings.Index(source, "TEXT "+helper+"<>(SB)")
+	if start < 0 {
+		t.Fatalf("current Go source has no helper %s", helper)
+	}
+	body := source[start:]
+	if end := strings.Index(body[1:], "\nTEXT "); end >= 0 {
+		body = body[:end+1]
+	}
+	// Mul is the final private helper but precedes more public TEXT bodies.
+	var wrapper strings.Builder
+	fmt.Fprintf(&wrapper, "TEXT ·Run(SB),4,$0-%d\n", (inputCount+5)*8)
+	for i := 0; i < inputCount; i++ {
+		fmt.Fprintf(&wrapper, "MOVD a%d+%d(FP),R%d\n", i, i*8, 19+i)
+	}
+	wrapper.WriteString("MOVD $0x00000000ffffffff,R15\nMOVD $0xffffffff00000001,R16\n")
+	wrapper.WriteString("MOVD $0x123456789abcdef0,R0\nMOVD $7,R2\n")
+	fmt.Fprintf(&wrapper, "CALL %s<>(SB)\n", helper)
+	for i, reg := range outputs {
+		fmt.Fprintf(&wrapper, "MOVD %s,r%d+%d(FP)\n", reg, i, (inputCount+i)*8)
+	}
+	wrapper.WriteString("MOVD $0x123456789abcdef0,R11\nEOR R11,R0\nSUB $7,R2\nORR R2,R0\n")
+	fmt.Fprintf(&wrapper, "MOVD R0,bad+%d(FP)\nRET\n", (inputCount+4)*8)
+	return prefix + wrapper.String() + body
+}
+
+func arm64P256Words(value *big.Int) [4]uint64 {
+	var out [4]uint64
+	n := new(big.Int).Set(value)
+	mask := new(big.Int).SetUint64(^uint64(0))
+	for i := range out {
+		out[i] = new(big.Int).And(n, mask).Uint64()
+		n.Rsh(n, 64)
+	}
+	return out
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateP256RegisterHelpers(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	p, ok := new(big.Int).SetString("ffffffff00000001000000000000000000000000ffffffffffffffffffffffff", 16)
+	if !ok {
+		t.Fatal("invalid independent P256 modulus")
+	}
+	rinv := new(big.Int).ModInverse(new(big.Int).Lsh(big.NewInt(1), 256), p)
+	for _, test := range []struct {
+		helper string
+		inputs int
+		output []Reg
+	}{
+		{"p256SqrInternal", 4, []Reg{"R23", "R24", "R25", "R26"}},
+		{"p256MulInternal", 8, []Reg{"R23", "R24", "R25", "R26"}},
+		{"p256SubInternal", 8, []Reg{"R19", "R20", "R21", "R22"}},
+	} {
+		t.Run(test.helper, func(t *testing.T) {
+			source := arm64PrivateP256Source(t, test.helper, test.inputs, test.output)
+			parameters := strings.TrimSuffix(strings.Repeat("uint64,", test.inputs), ",")
+			decl := fmt.Sprintf("func Run(%s)(uint64,uint64,uint64,uint64,uint64)\n", parameters)
+			var goRows, cRows strings.Builder
+			seed := uint64(0x123456789abcdef0)
+			for row := 0; row < 64; row++ {
+				x, y := new(big.Int), new(big.Int)
+				if row == 0 {
+					x.SetInt64(0)
+					y.SetInt64(0)
+				} else if row == 1 {
+					x.SetInt64(1)
+					y.SetInt64(1)
+				} else if row == 2 {
+					x.Sub(p, big.NewInt(1))
+					y.SetInt64(1)
+				} else if row == 3 {
+					x.SetInt64(1)
+					y.Sub(p, big.NewInt(1))
+				} else {
+					for limb := 0; limb < 4; limb++ {
+						seed = seed*6364136223846793005 + 1
+						x.Or(x, new(big.Int).Lsh(new(big.Int).SetUint64(seed), uint(limb*64)))
+						seed = seed*6364136223846793005 + 1
+						y.Or(y, new(big.Int).Lsh(new(big.Int).SetUint64(seed), uint(limb*64)))
+					}
+					x.Mod(x, p)
+					y.Mod(y, p)
+				}
+				want := new(big.Int)
+				switch test.helper {
+				case "p256SqrInternal":
+					want.Mul(x, x).Mul(want, rinv).Mod(want, p)
+				case "p256MulInternal":
+					want.Mul(x, y).Mul(want, rinv).Mod(want, p)
+				case "p256SubInternal":
+					want.Sub(y, x).Mod(want, p)
+				}
+				xw, yw, ww := arm64P256Words(x), arm64P256Words(y), arm64P256Words(want)
+				args := append([]uint64(nil), xw[:]...)
+				if test.inputs == 8 {
+					args = append(args, yw[:]...)
+				}
+				all := append(append([]uint64(nil), args...), ww[:]...)
+				goRows.WriteString("{")
+				cRows.WriteString("{")
+				for i, value := range all {
+					if i != 0 {
+						goRows.WriteString(",")
+						cRows.WriteString(",")
+					}
+					fmt.Fprintf(&goRows, "0x%x", value)
+					fmt.Fprintf(&cRows, "UINT64_C(0x%x)", value)
+				}
+				goRows.WriteString("},\n")
+				cRows.WriteString("},\n")
+			}
+			var args strings.Builder
+			for i := 0; i < test.inputs; i++ {
+				if i != 0 {
+					args.WriteString(",")
+				}
+				fmt.Fprintf(&args, "row[%d]", i)
+			}
+			runARM64LocalRegisterGoOracle(t, source, "package main\n"+decl+fmt.Sprintf(`func main() {
+  rows:=[][ %d ]uint64{
+%s}
+  for _,row:=range rows {
+    a,b,c,d,bad:=Run(%s)
+    if a!=row[%d] || b!=row[%d] || c!=row[%d] || d!=row[%d] || bad!=0 { panic("real private P256 register helper mismatch") }
+  }
+}
+`, test.inputs+4, goRows.String(), args.String(), test.inputs, test.inputs+1, test.inputs+2, test.inputs+3), len(runner) != 0)
+			pkg := mustGoPackage(t, "test/privatep256", "package privatep256\n"+decl)
+			translate := func(target string) string {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				if tr.Module.Context() != ctx {
+					t.Fatal("real P256 helper escaped its owned context")
+				}
+				ir := tr.Module.String()
+				if len(tr.Signatures) != 1 || len(tr.Functions) != 1 {
+					t.Fatal("private helper acquired a fake scalar/native entry")
+				}
+				return ir + arm64P256CheckIR(test.inputs)
+			}
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+				"aarch64-unknown-linux-musl",
+			} {
+				compileLLVMToObject(t, llc, target, "p256-private.ll", "p256-private.o", translate(target))
+			}
+			cParameters := strings.TrimSuffix(strings.Repeat("uint64_t,", test.inputs+4), ",")
+			for i := test.inputs; i < test.inputs+4; i++ {
+				fmt.Fprintf(&args, ",row[%d]", i)
+			}
+			main := fmt.Sprintf(`#include <stdint.h>
+extern uint64_t Check(%s);
+int main(void) {
+  uint64_t rows[][%d]={
+%s};
+  for (unsigned i=0;i<64;i++) {
+    uint64_t *row=rows[i];
+    if (Check(%s)!=0) return 1;
+  }
+  return 0;
+}
+`, cParameters, test.inputs+4, cRows.String(), args.String())
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "p256_private", triple, translate(triple), main, runner)
+		})
+	}
+}
+
+// A scalar C boundary is separate from the logical Go tuple return. Both the
+// original entry and this wrapper are typed LLVM calls; no Clang aggregate ABI
+// or private helper return convention is guessed.
+func arm64P256CheckIR(inputs int) string {
+	var ir strings.Builder
+	ir.WriteString("\ndefine i64 @Check(")
+	for i := 0; i < inputs+4; i++ {
+		if i != 0 {
+			ir.WriteString(", ")
+		}
+		fmt.Fprintf(&ir, "i64 %%a%d", i)
+	}
+	ir.WriteString(") {\nentry:\n  %r = call {i64,i64,i64,i64,i64} @Run(")
+	for i := 0; i < inputs; i++ {
+		if i != 0 {
+			ir.WriteString(", ")
+		}
+		fmt.Fprintf(&ir, "i64 %%a%d", i)
+	}
+	ir.WriteString(")\n")
+	for i := 0; i < 4; i++ {
+		fmt.Fprintf(&ir, "  %%v%d = extractvalue {i64,i64,i64,i64,i64} %%r, %d\n  %%bad%d = xor i64 %%v%d, %%a%d\n", i, i, i, i, inputs+i)
+	}
+	ir.WriteString("  %bad4 = extractvalue {i64,i64,i64,i64,i64} %r, 4\n  %b01 = or i64 %bad0, %bad1\n  %b23 = or i64 %bad2, %bad3\n  %b0123 = or i64 %b01, %b23\n  %all = or i64 %b0123, %bad4\n  ret i64 %all\n}\n")
+	return ir.String()
+}
+
+// The unchanged public Sqr body stores through its incoming result pointer.
+// The complete source has no way to expose this invocation's fresh virtual SP,
+// so those heap stores cannot alias its automatically saved caller link.
+func TestCrossLinuxRuntimeMatrixARM64PrivateP256PointerUnexposedFrame(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "crypto", "internal", "fips140", "nistec", "p256_asm_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	prefix := text[:strings.Index(text, "TEXT ")]
+	extract := func(header string) string {
+		start := strings.Index(text, header)
+		if start < 0 {
+			t.Fatalf("missing current Go source %q", header)
+		}
+		body := text[start:]
+		if end := strings.Index(body[1:], "\nTEXT "); end >= 0 {
+			body = body[:end+1]
+		}
+		return body
+	}
+	source := prefix + strings.Replace(extract("TEXT ·p256Sqr(SB)"), "TEXT ·p256Sqr(SB)", "TEXT ·Public(SB)", 1) + "\n" + extract("TEXT p256SqrInternal<>(SB)") + "\n"
+	runARM64LocalRegisterGoOracle(t, source, `package main
+import "math/big"
+func Public(*[4]uint64,*[4]uint64,int)
+func main() {
+  p,_:=new(big.Int).SetString("ffffffff00000001000000000000000000000000ffffffffffffffffffffffff",16)
+  rinv:=new(big.Int).ModInverse(new(big.Int).Lsh(big.NewInt(1),256),p)
+  seed:=uint64(0x123456789abcdef0)
+  mask:=new(big.Int).SetUint64(^uint64(0))
+  for i:=0;i<32;i++ {
+    x:=new(big.Int)
+    for limb:=0;limb<4;limb++ {
+      seed=seed*6364136223846793005+1
+      x.Or(x,new(big.Int).Lsh(new(big.Int).SetUint64(seed),uint(limb*64)))
+    }
+    x.Mod(x,p)
+    in:=new([4]uint64)
+    words:=new(big.Int).Set(x)
+    for limb:=range in { in[limb]=new(big.Int).And(words,mask).Uint64();words.Rsh(words,64) }
+    n:=i%4+1
+    out:=new([4]uint64)
+    Public(out,in,n)
+    for j:=0;j<n;j++ { x.Mul(x,x).Mul(x,rinv).Mod(x,p) }
+    for limb:=range out {
+      if out[limb]!=new(big.Int).And(x,mask).Uint64() { panic("real public P256 Sqr data oracle mismatch") }
+      x.Rsh(x,64)
+    }
+  }
+}
+`, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/privatep256", "package privatep256\nfunc Public(*[4]uint64,*[4]uint64,int)\n")
+	translate := func(target string) string {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err != nil {
+			t.Fatalf("%s: real public P256 Sqr's incoming pointer cannot expose fresh SP: %v", target, err)
+		}
+		defer tr.Module.Dispose()
+		return tr.Module.String()
+	}
+	for _, target := range append([]string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		"aarch64-unknown-linux-musl",
+	}, triple) {
+		ir := translate(target)
+		compileLLVMToObject(t, llc, target, "p256-public.ll", "p256-public.o", ir)
+		if target == triple {
+			p, ok := new(big.Int).SetString("ffffffff00000001000000000000000000000000ffffffffffffffffffffffff", 16)
+			if !ok {
+				t.Fatal("invalid independent P256 modulus")
+			}
+			rinv := new(big.Int).ModInverse(new(big.Int).Lsh(big.NewInt(1), 256), p)
+			var rows strings.Builder
+			seed := uint64(0x123456789abcdef0)
+			for i := 0; i < 32; i++ {
+				x := new(big.Int)
+				for limb := 0; limb < 4; limb++ {
+					seed = seed*6364136223846793005 + 1
+					x.Or(x, new(big.Int).Lsh(new(big.Int).SetUint64(seed), uint(limb*64)))
+				}
+				x.Mod(x, p)
+				input := arm64P256Words(x)
+				n := i%4 + 1
+				for j := 0; j < n; j++ {
+					x.Mul(x, x).Mul(x, rinv).Mod(x, p)
+				}
+				output := arm64P256Words(x)
+				rows.WriteString("{")
+				for _, value := range append(input[:], output[:]...) {
+					fmt.Fprintf(&rows, "UINT64_C(0x%x),", value)
+				}
+				fmt.Fprintf(&rows, "%d},\n", n)
+			}
+			main := fmt.Sprintf(`#include <stdint.h>
+extern void Public(uint64_t *,const uint64_t *,uint64_t);
+int main(void) {
+ uint64_t rows[32][9]={%s};
+ for(int i=0;i<32;i++) {
+  uint64_t *row=rows[i],out[6]={UINT64_C(0x123456789abcdef0),0,0,0,0,UINT64_C(0xfedcba9876543210)};
+  Public(out+1,row,row[8]);
+  if(out[0]!=UINT64_C(0x123456789abcdef0)||out[5]!=UINT64_C(0xfedcba9876543210)) return 1;
+  for(int j=0;j<4;j++) if(out[j+1]!=row[j+4]) return 2;
+ }
+ return 0;
+}
+`, rows.String())
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "p256_public", triple, ir, main, runner)
+		}
+	}
+}
diff --git a/arm64_private_register_helper.go b/arm64_private_register_helper.go
new file mode 100644
index 000000000..fbe01beb5
--- /dev/null
+++ b/arm64_private_register_helper.go
@@ -0,0 +1,353 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Limit added source instructions before allocating per-call continuations.
+// The later CFG convergence budgets cannot bound this Cartesian expansion.
+const arm64PrivateRegisterExpansionBudget = 1 << 16
+
+// This is a source continuation contract, not a guessed callable signature.
+// Only a closed, acyclic, zero-frame data leaf can share its caller's
+// typed machine state. Purity here restricts operand classes; real lowering still
+// validates every opcode/form and records actual register/flag effects. Native
+// callouts are rejected here; native effects are also rejected by the later
+// machine-availability proof.
+func arm64PrivateRegisterLeaf(fn Func) error {
+	if fn.FrameSize != 0 && fn.FrameSize != -8 || fn.ArgSize != 0 || arm64SourceGoFrame(fn).present {
+		return arm64GoABIContext("private helper %q has an unproved native frame", fn.Sym)
+	}
+	if len(fn.Instrs) < 2 || fn.Instrs[0].Op != OpTEXT {
+		return arm64GoABIContext("private helper %q has no complete source body", fn.Sym)
+	}
+	if !arm64SourceFrameFlagsKnown(fn) {
+		return arm64GoABIContext("private helper %q has unbound source frame flags", fn.Sym)
+	}
+	_, text := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(text, ",")
+	name, offset, valid := parseSBRef(strings.TrimSpace(parts[0]))
+	frame, args, err := parseTEXTFrame(parts)
+	if !valid || offset != 0 || name != fn.Sym || err != nil || frame != fn.FrameSize || args != fn.ArgSize {
+		return arm64GoABIContext("private helper %q changed its complete TEXT identity", fn.Sym)
+	}
+	if err := arm64PrivateContinuationBody(fn, arm64PrivateCallDataRegister, arm64PrivateCallImmediateScratch, false); err != nil {
+		return err
+	}
+	return arm64PrivateCallAcyclic(fn)
+}
+
+func arm64PrivateDataGP(reg Reg) bool {
+	if reg == ZR {
+		return true
+	}
+	// R18 is a physical platform register even after the source spelling
+	// R18_PLATFORM has been normalized. R27 is the Go assembler scratch
+	// register; R28/R29/R30 have hidden
+	// runtime/frame/link roles. No source-private data promise is made for them.
+	return isARM64GeneralOrZeroReg(reg) && !arm64PrivateReservedGP(reg) && reg != "R28" && reg != "R29" && reg != "R30"
+}
+
+func arm64PrivateReservedGP(reg Reg) bool {
+	if root, ok := parseReg(string(reg)); ok {
+		reg = root
+	}
+	return reg == "R18" || reg == "R27"
+}
+
+func arm64PrivateOperandMentionsReserved(arg Operand) bool {
+	if arm64PrivateReservedGP(arg.Reg) || arm64PrivateReservedGP(arg.ShiftReg) || arm64PrivateReservedGP(arg.Mem.Base) || arm64PrivateReservedGP(arg.Mem.Index) {
+		return true
+	}
+	for _, reg := range arg.RegList {
+		if arm64PrivateReservedGP(reg) {
+			return true
+		}
+	}
+	if arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$") {
+		address, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$")))
+		if ok && (arm64PrivateReservedGP(address.Base) || arm64PrivateReservedGP(address.Index)) {
+			return true
+		}
+	}
+	return false
+}
+
+func arm64PrivateSymbolRef(sym string) (string, int64, bool) {
+	return parseSBRef(strings.TrimPrefix(sym, "$"))
+}
+
+// CoalesceARM64PrivateRegisterHelpers folds closed ARM64 source continuations:
+// acyclic data leaves at CALL sites, and zero-frame data/CFG leaves at ABIInternal
+// tail sites. Tail roots still require their complete typed Go register ABI at
+// final lowering. Neither family infers a callable helper signature or grants
+// native-frame, hidden-register or pointer-ownership permissions.
+// Call this before filtering or splitting a file: an excluded sibling or DATA
+// initializer must not hide address-taking or alternate native helper uses.
+// Other architectures are returned unchanged. The input is not modified.
+func CoalesceARM64PrivateRegisterHelpers(file *File) (*File, error) {
+	if file == nil {
+		return nil, fmt.Errorf("nil assembly file")
+	}
+	return coalesceARM64PrivateRegisterHelpers(file)
+}
+
+// Run before KeepFunc: an excluded sibling or DATA initializer must not hide
+// address-taking or an alternate native use of a helper we fold into a root.
+func coalesceARM64PrivateRegisterHelpers(file *File) (*File, error) {
+	if file.Arch != ArchARM64 {
+		return file, nil
+	}
+	remaining := arm64PrivateRegisterExpansionBudget
+	// Public preparation and final preparation can run separately. Retain each
+	// root's actual earlier additions so appending another original root cannot
+	// reset the single checked allowance. This count authorizes no source effect.
+	for _, fn := range file.Funcs {
+		if err := validateARM64PrivateCallSource(fn); err != nil {
+			return nil, err
+		}
+		if fn.arm64PrivateSourceAdded < 0 || fn.arm64PrivateSourceAdded > remaining {
+			return nil, arm64GoABIContext("private source exceeds its cumulative expansion budget")
+		}
+		remaining -= fn.arm64PrivateSourceAdded
+	}
+	if err := validateARM64PrivateContinuationFile(file); err != nil {
+		return nil, err
+	}
+	prepared, err := coalesceARM64PrivateCallRegisterHelpers(file, &remaining)
+	if err != nil {
+		return nil, err
+	}
+	return coalesceARM64PrivateTailHelpers(prepared, &remaining)
+}
+
+func coalesceARM64PrivateCallRegisterHelpers(file *File, remaining *int) (*File, error) {
+	if file.Arch != ArchARM64 {
+		return file, nil
+	}
+	// Do not replace existing explicit FP/tail-entry contracts. This bounded
+	// continuation mechanism starts only at real source BL/CALL sites, then
+	// audits every other use of each such helper across the complete file.
+	called := map[string]bool{}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if (ins.Op == "CALL" || ins.Op == "BL") && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym {
+				base, _, ok := arm64PrivateSymbolRef(ins.Args[0].Sym)
+				if ok {
+					called[base] = true
+				}
+			}
+		}
+	}
+	helpers := map[string]Func{}
+	for _, fn := range file.Funcs {
+		if !strings.HasSuffix(fn.Sym, "<>") || !called[fn.Sym] {
+			continue
+		}
+		fp := false
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				fp = fp || arg.Kind == OpFP || arg.Kind == OpFPAddr
+			}
+		}
+		if fp || fn.ArgSize != 0 {
+			continue // Ordinary FP helpers retain their existing typed ABI path.
+		}
+		if _, duplicate := helpers[fn.Sym]; duplicate {
+			return nil, fmt.Errorf("duplicate ARM64 private TEXT %q", fn.Sym)
+		}
+		if err := arm64PrivateRegisterLeaf(fn); err != nil {
+			return nil, err
+		}
+		helpers[fn.Sym] = fn
+	}
+	if len(helpers) == 0 {
+		return file, nil
+	}
+	if len(file.UnlinkedPrelude) != 0 {
+		return nil, arm64GoABIContext("private call file has an unbound native prelude")
+	}
+	for _, data := range file.Data {
+		for _, symbol := range []string{data.Sym, data.Addr} {
+			base, _, _ := arm64PrivateSymbolRef(symbol)
+			if _, escaped := helpers[base]; escaped {
+				return nil, arm64GoABIContext("private helper %q escapes through DATA", base)
+			}
+		}
+	}
+	for _, global := range file.Globl {
+		base, _, _ := arm64PrivateSymbolRef(global.Sym)
+		if _, escaped := helpers[base]; escaped {
+			return nil, arm64GoABIContext("private helper %q has a GLOBL/native address use", base)
+		}
+	}
+	uses := map[string]int{}
+	roots := map[string]map[string]bool{}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			// Folding removes the helper's standalone native TEXT identity.
+			// A sibling excluded by KeepFunc must not hide an observation of
+			// that original byte layout or a raw branch into the helper.
+			_, alignment, _ := arm64PCAlignment(ins)
+			if ins.Op == OpWORD || ins.Op == "DWORD" || ins.Op == "ADR" || ins.Op == "ADRP" || alignment {
+				return nil, arm64GoABIContext("private helper file requires native byte-layout effects at %q", ins.Raw)
+			}
+			for ai, arg := range ins.Args {
+				memory, hasMemory := arg.Mem, arg.Kind == OpMem
+				if arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$") {
+					memory, hasMemory = parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$")))
+				}
+				if hasMemory && memory.Base == PC {
+					return nil, arm64GoABIContext("private helper file has a native PC use at %q", ins.Raw)
+				}
+				if hasMemory && memory.Sym != "" {
+					base, _, _ := arm64PrivateSymbolRef(memory.Sym)
+					if _, escaped := helpers[base]; escaped {
+						return nil, arm64GoABIContext("private helper %q has a native memory/address use at %q", base, ins.Raw)
+					}
+				}
+				if arg.Kind != OpSym {
+					continue
+				}
+				base, off, ok := arm64PrivateSymbolRef(arg.Sym)
+				if _, helper := helpers[base]; !ok || !helper {
+					continue
+				}
+				if (ins.Op != "CALL" && ins.Op != "BL") || ai != 0 || len(ins.Args) != 1 || off != 0 || strings.HasPrefix(arg.Sym, "$") {
+					return nil, arm64GoABIContext("private helper %q has a non-call/address use at %q", base, ins.Raw)
+				}
+				if roots[fn.Sym] == nil {
+					roots[fn.Sym] = map[string]bool{}
+				}
+				roots[fn.Sym][base] = true
+				uses[base]++
+			}
+		}
+	}
+	for helper := range helpers {
+		if uses[helper] == 0 {
+			return nil, arm64GoABIContext("private helper %q has no closed source caller", helper)
+		}
+	}
+	for name, helper := range helpers {
+		// LABEL and B (R30) replace TEXT and RET, so each continuation adds
+		// exactly the original leaf's length. Divide before multiplying to
+		// keep the file-wide preflight checked even for hostile source sizes.
+		if uses[name] > *remaining/len(helper.Instrs) {
+			return nil, arm64GoABIContext("private helper source exceeds its expansion budget of %d instructions", arm64PrivateRegisterExpansionBudget)
+		}
+		*remaining -= uses[name] * len(helper.Instrs)
+	}
+	result := *file
+	result.Funcs = make([]Func, 0, len(file.Funcs)-len(helpers))
+	for _, fn := range file.Funcs {
+		if _, helper := helpers[fn.Sym]; helper {
+			continue
+		}
+		if len(roots[fn.Sym]) == 0 {
+			result.Funcs = append(result.Funcs, fn)
+			continue
+		}
+		copyFn := fn
+		if len(fn.Instrs) == 0 {
+			return nil, arm64GoABIContext("private helper root %q has no source terminator", fn.Sym)
+		}
+		last := fn.Instrs[len(fn.Instrs)-1].Op
+		if last != OpRET && last != "B" && last != "JMP" {
+			return nil, arm64GoABIContext("private helper root %q has no source terminator", fn.Sym)
+		}
+		copyFn.Instrs = append([]Instr(nil), fn.Instrs...)
+		copyFn.arm64PrivateRegisterEntry = true
+		// Retain the pre-coalescing source proof. Only audited data-only
+		// helpers are appended below; their rewritten local calls must not
+		// erase the original real-symbol call's private-frame provenance.
+		copyFn.arm64PrivateUnexposedFrame = arm64CallFrameUnexposed(fn)
+		// Each static CALL needs its own helper continuation. Sharing a body
+		// also shares its indirect RET edges, falsely joining an earlier call's
+		// register state into a later caller continuation. The closed leaf has
+		// no observable address/PC or LR use, so cloning its source preserves
+		// the real CALL/LR transport without weakening must-defined joins.
+		type sourceContinuation struct {
+			label  string
+			helper Func
+		}
+		var continuations []sourceContinuation
+		occupied := map[string]bool{"entry": true, "ret": true}
+		for _, block := range arm64SplitBlocks(fn) {
+			occupied[arm64LLVMBlockName(block.name)] = true
+		}
+		fresh := func() string {
+			label := fmt.Sprintf("__arm64_private_%d", len(occupied))
+			for occupied[arm64LLVMBlockName(label)] {
+				label += "_"
+			}
+			occupied[arm64LLVMBlockName(label)] = true
+			return label
+		}
+		for i, ins := range copyFn.Instrs {
+			_, alignment, _ := arm64PCAlignment(ins)
+			if ins.Op == OpWORD || ins.Op == "ADR" || ins.Op == "ADRP" || alignment {
+				return nil, arm64GoABIContext("private helper root %q requires native byte-layout effects at %q", fn.Sym, ins.Raw)
+			}
+			for _, arg := range ins.Args {
+				if arm64PrivateOperandMentionsReserved(arg) {
+					return nil, arm64GoABIContext("private helper root %q observes unmodelled platform/scratch state at %q", fn.Sym, ins.Raw)
+				}
+			}
+			if (ins.Op == "CALL" || ins.Op == "BL") && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym {
+				name, _, _ := arm64PrivateSymbolRef(ins.Args[0].Sym)
+				if helper, present := helpers[name]; present {
+					label := fresh()
+					continuations = append(continuations, sourceContinuation{label: label, helper: helper})
+					copyFn.Instrs[i].Args = []Operand{{Kind: OpIdent, Ident: label}}
+				}
+			}
+		}
+		var err error
+		copyFn, err = normalizeARM64NamedPCRelative(copyFn)
+		if err != nil {
+			return nil, err
+		}
+		var helperSources []Func
+		for _, continuation := range continuations {
+			copyFn.Instrs = append(copyFn.Instrs, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: continuation.label}}})
+			helper := continuation.helper
+			helperSources = append(helperSources, arm64PrivateTailSnapshot(helper))
+			labels := make(map[string]string)
+			for _, ins := range helper.Instrs[1:] {
+				if ins.Op == OpLABEL {
+					labels[ins.Args[0].Sym] = fresh()
+				}
+			}
+			for _, ins := range helper.Instrs[1:] {
+				cloned := ins
+				switch {
+				case ins.Op == OpRET:
+					cloned = Instr{Op: "B", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: "R30"}}}, Raw: "B (R30)"}
+				case ins.Op == OpLABEL:
+					cloned.Args = []Operand{{Kind: OpLabel, Sym: labels[ins.Args[0].Sym]}}
+				case ins.Op == "B" || ins.Op == "JMP" || arm64IsConditionalBranch(ins.Op):
+					cloned.Args = append([]Operand(nil), ins.Args...)
+					last := len(cloned.Args) - 1
+					cloned.Args[last] = Operand{Kind: OpIdent, Ident: labels[ins.Args[last].Ident]}
+				}
+				copyFn.Instrs = append(copyFn.Instrs, cloned)
+			}
+			copyFn.arm64PrivateSourceAdded += len(helper.Instrs)
+		}
+		copyFn, err = normalizeARM64ScalarMemoryFrame(copyFn)
+		if err != nil {
+			return nil, err
+		}
+		copyFn.arm64PrivateCallSource = &arm64PrivateCallSource{
+			original: arm64PrivateTailSnapshot(fn), helpers: helperSources,
+			prepared: arm64PrivateTailSnapshot(copyFn),
+		}
+		result.Funcs = append(result.Funcs, copyFn)
+	}
+	return &result, nil
+}
diff --git a/arm64_private_register_helper_test.go b/arm64_private_register_helper_test.go
new file mode 100644
index 000000000..1c1de58e1
--- /dev/null
+++ b/arm64_private_register_helper_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64PrivateRegisterHelperSource(header, call string) string {
+	return `TEXT ·Run(SB),4,$0-16
+MOVD x+0(FP),R19
+MOVD $291,R0
+ADDS $1,R19,R9
+` + call + `
+EOR R0,R20
+MOVD R20,ret+8(FP)
+RET
+TEXT mix<>(SB),` + header + `
+ADC $0,R9,R20
+MUL R19,R20,R20
+RET
+`
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateRegisterHelper(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	pkg := mustGoPackage(t, "test/privategp", "package privategp\nfunc Run(uint64) uint64\n")
+	for _, test := range []struct {
+		name, header, call string
+		manual             bool
+		extra              uint64
+		rootFrame          int64
+		saveLink           bool
+		data26             string
+	}{
+		{name: "normal-leaf"},
+		{name: "default-flags", header: "0,$0-0", call: "BL mix<>(SB)"},
+		{name: "no-frame", header: "516,$0-0"},
+		{name: "negative-eight-no-frame", header: "4,$-8-0"},
+		{name: "two-call-sites", call: "CALL mix<>(SB)\nCALL mix<>(SB)"},
+		{name: "branch-call-sites", call: "CBNZ R19,other\nCALL mix<>(SB)\nB done\nother:\nCALL mix<>(SB)\ndone:"},
+		{name: "manual-scalar-is-not-source-ABI", manual: true},
+		{name: "two-different-helpers", call: "CALL mix<>(SB)\nCALL bump<>(SB)", extra: 5},
+		{name: "helper-label-collision", call: "__arm64_private_0:\nCALL mix<>(SB)"},
+		{name: "framed-root", rootFrame: 24},
+		{name: "no-frame-root-restores-real-lr", saveLink: true},
+		{name: "helper-initializes-data26", data26: "helper"},
+		{name: "caller-initializes-data26", data26: "caller"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if test.header == "" {
+				test.header = "4,$0-0"
+			}
+			if test.call == "" {
+				test.call = "CALL mix<>(SB)"
+			}
+			source := arm64PrivateRegisterHelperSource(test.header, test.call)
+			if test.data26 == "helper" {
+				source = strings.Replace(source, "ADC $0,R9,R20", "ADC $0,R9,R26\nMOVD R26,R20", 1)
+			}
+			if test.data26 == "caller" {
+				source = strings.Replace(source, "CALL mix<>(SB)", "MOVD R9,R26\nCALL mix<>(SB)", 1)
+				source = strings.Replace(source, "ADC $0,R9,R20", "ADC $0,R26,R20", 1)
+			}
+			if test.rootFrame != 0 {
+				source = strings.Replace(source, "TEXT ·Run(SB),4,$0-16", fmt.Sprintf("TEXT ·Run(SB),4,$%d-16", test.rootFrame), 1)
+			}
+			if test.saveLink {
+				source = strings.Replace(source, "TEXT ·Run(SB),4,$0-16", "TEXT ·Run(SB),516,$0-16\nMOVD R30,R22", 1)
+				source = strings.Replace(source, "EOR R0,R20", "MOVD R22,R30\nEOR R0,R20", 1)
+			}
+			if test.extra != 0 {
+				source += fmt.Sprintf("TEXT bump<>(SB),4,$0-0\nADD $%d,R20\nRET\n", test.extra)
+			}
+			carry := "if x==^uint64(0) { y++ }"
+			if test.manual {
+				source = strings.Replace(source, "ADC $0,R9,R20", "MOVD R9,R20", 1)
+				carry = ""
+			}
+			want := fmt.Sprintf("(x*y+%d)^291", test.extra)
+			runARM64LocalRegisterGoOracle(t, source, `package main
+func Run(uint64) uint64
+func main() {
+  for _,x:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    y:=x+1
+    `+carry+`
+    if Run(x)!=`+want+` { panic("private GP/NZCV continuation mismatch") }
+  }
+}
+`, len(runner) != 0)
+			inventedHelper := false
+			translate := func(target string) string {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				manual := func(name string) (FuncSig, bool) {
+					if test.manual && name == "mix<>" {
+						return FuncSig{Name: name, Ret: I64}, true
+					}
+					return FuncSig{}, false
+				}
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+					ManualSig:  manual,
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				if tr.Module.Context() != ctx {
+					t.Fatal("private GP continuation escaped its owned context")
+				}
+				ir := tr.Module.String()
+				_, invented := tr.Signatures["mix<>"]
+				inventedHelper = inventedHelper || invented || strings.Contains(ir, "@\"mix<>\"")
+				return ir
+			}
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+				"aarch64-unknown-linux-musl",
+			} {
+				compileLLVMToObject(t, llc, target, "private-gp.ll", "private-gp.o", translate(target))
+			}
+			cCarry := "if (x==UINT64_MAX) y++;"
+			if test.manual {
+				cCarry = ""
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_gp", triple, translate(triple), `#include <stdint.h>
+extern uint64_t Run(uint64_t);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) {
+    uint64_t x=inputs[i],y=x+1;
+    `+cCarry+`
+    if (Run(x)!=(`+want+`)) return 1;
+  }
+  return 0;
+}
+`, runner)
+			if inventedHelper {
+				t.Fatal("private continuation must not acquire a scalar function signature")
+			}
+		})
+	}
+}
+
+func TestARM64PrivateRegisterHelperNeedsCompleteContext(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privategp", "package privategp\nfunc Run(uint64) uint64\n")
+	base := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	for _, test := range []struct {
+		name, source string
+	}{
+		{"unknown-gp-input", strings.Replace(base, "ADC $0,R9,R20", "ADD R8,R9,R20", 1)},
+		{"unknown-flags-input", strings.Replace(base, "ADDS $1,R19,R9", "ADD $1,R19,R9", 1)},
+		{"helper-unknown-memory-base", strings.Replace(base, "ADC $0,R9,R20", "MOVD R0,(R8)\nADC $0,R9,R20", 1)},
+		{"helper-fp", strings.Replace(base, "ADC $0,R9,R20", "MOVD x+0(FP),R20", 1)},
+		{"helper-sp", strings.Replace(base, "ADC $0,R9,R20", "MOVD RSP,R20", 1)},
+		{"helper-lr", strings.Replace(base, "ADC $0,R9,R20", "MOVD R30,R20", 1)},
+		{"helper-frame", strings.Replace(base, "TEXT mix<>(SB),4,$0-0", "TEXT mix<>(SB),4,$8-0", 1)},
+		{"helper-call", strings.Replace(base, "ADC $0,R9,R20", "CALL foreign(SB)\nADC $0,R9,R20", 1)},
+		{"helper-raw", strings.Replace(base, "ADC $0,R9,R20", "WORD $0x91000414", 1)},
+		{"helper-system", strings.Replace(base, "ADC $0,R9,R20", "SVC $0", 1)},
+		{"helper-vector", strings.Replace(base, "ADC $0,R9,R20", "VEOR V0.B16,V0.B16,V0.B16\nADC $0,R9,R20", 1)},
+		{"helper-address-taken", strings.Replace(base, "CALL mix<>(SB)", "MOVD $mix<>(SB),R1\nCALL mix<>(SB)", 1)},
+		{"helper-offset-call", strings.Replace(base, "CALL mix<>(SB)", "CALL mix<>+4(SB)", 1)},
+		{"helper-tail-branch-use", strings.Replace(base, "CALL mix<>(SB)", "CALL mix<>(SB)\nB mix<>(SB)", 1)},
+		{"helper-tail-jump-use", strings.Replace(base, "CALL mix<>(SB)", "CALL mix<>(SB)\nJMP mix<>(SB)", 1)},
+		{"helper-foreign-entry-use", base + "TEXT Alternate(SB),4,$0-0\nB mix<>(SB)\n"},
+		{"helper-data-relocation", base + "DATA saved<>+0(SB)/8,$mix<>(SB)\nGLOBL saved<>(SB),8,$8\n"},
+		{"helper-unreferenced", strings.Replace(base, "CALL mix<>(SB)", "MOVD R9,R20", 1)},
+		{"caller-scratch-observable", strings.Replace(base, "MOVD $291,R0", "MOVD $291,R27\nMOVD R27,R0", 1)},
+		{"caller-unknown-liveout", strings.Replace(base, "EOR R0,R20", "EOR R8,R20", 1)},
+		{"callee-argument-frame", strings.Replace(base, "TEXT mix<>(SB),4,$0-0", "TEXT mix<>(SB),4,$0-8", 1)},
+		{"unknown-path-input", strings.Replace(base, "ADDS $1,R19,R9", "CBZ R19,skip\nADDS $1,R19,R9\nskip:", 1)},
+		{"helper-branch", strings.Replace(base, "ADC $0,R9,R20", "CBZ R19,done\nADC $0,R9,R20\ndone:", 1)},
+		{"root-no-frame-unknown-return-link", strings.Replace(strings.Replace(base, "TEXT ·Run(SB),4,$0-16", "TEXT ·Run(SB),516,$0-16", 1), "EOR R0,R20", "MOVD $8,R30\nEOR R0,R20", 1)},
+		{"root-no-source-terminator", strings.Replace(base, "RET\nTEXT mix<>", "TEXT mix<>", 1)},
+		{"root-opaque-call", strings.Replace(base, "CALL mix<>(SB)", "CALL foreign(SB)\nCALL mix<>(SB)", 1)},
+		{"root-raw", strings.Replace(base, "CALL mix<>(SB)", "WORD $0xd503201f\nCALL mix<>(SB)", 1)},
+		{"root-observes-code-layout", strings.Replace(base, "CALL mix<>(SB)", "ADR after,R7\nCALL mix<>(SB)\nafter:", 1)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, test.source, true)
+			for _, target := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+				"aarch64-unknown-linux-musl",
+			} {
+				ctx := llvm.NewContext()
+				tr, err := translateGoModuleInContext(ctx, pkg, []byte(test.source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target,
+					ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				})
+				if tr != nil {
+					tr.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s requires a complete native continuation contract, got %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PrivateRegisterHelperKeepFuncCannotHideEscape(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privategp", "package privategp\nfunc Run(uint64) uint64\nfunc Escape()\n")
+	source := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)") + `TEXT ·Escape(SB),4,$0-0
+MOVD $mix<>(SB),R0
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		KeepFunc:   func(text, _ string) bool { return text == "·Run" || text == "mix<>" },
+	})
+	if tr != nil {
+		tr.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("excluded sibling still takes the private helper address: %v", err)
+	}
+}
+
+func TestARM64PrivateRegisterHelperMultipleRoots(t *testing.T) {
+	pkg := mustGoPackage(t, "test/privategp", "package privategp\nfunc Run(uint64) uint64\nfunc Other(uint64) uint64\n")
+	source := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	caller := strings.Split(source, "TEXT mix<>")[0]
+	source += strings.ReplaceAll(caller, "·Run", "·Other")
+	tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	if len(tr.Functions) != 2 || len(tr.Signatures) != 2 {
+		t.Fatalf("closed source has two actual entries, not a guessed helper ABI: %s", fmt.Sprint(tr.Functions))
+	}
+}
diff --git a/arm64_private_source_api_test.go b/arm64_private_source_api_test.go
new file mode 100644
index 000000000..c8d5ddd0b
--- /dev/null
+++ b/arm64_private_source_api_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestARM64PrivateSourceAPINilAndOtherArchitectures(t *testing.T) {
+	if file, err := CoalesceARM64PrivateRegisterHelpers(nil); err == nil || file != nil {
+		t.Fatalf("nil source did not fail: file=%v error=%v", file, err)
+	}
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchWASM} {
+		file := &File{Arch: arch, Funcs: []Func{{Sym: "untouched"}}}
+		prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+		if err != nil || prepared != file {
+			t.Fatalf("non-ARM64 source changed: arch=%v error=%v", arch, err)
+		}
+	}
+}
+
+func TestARM64PrivateSourceAPIOriginalFileImmutable(t *testing.T) {
+	source := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := CoalesceARM64PrivateRegisterHelpers(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(file, original) || len(prepared.Funcs) != 1 || prepared == file {
+		t.Fatal("continuation preparation mutated its complete original source")
+	}
+	if !prepared.Funcs[0].arm64PrivateRegisterEntry {
+		t.Fatal("validated continuation lost its internal machine-state proof")
+	}
+	preparedAgain, err := CoalesceARM64PrivateRegisterHelpers(prepared)
+	if err != nil || !reflect.DeepEqual(preparedAgain, prepared) {
+		t.Fatalf("repeated preparation changed the closed source: %v", err)
+	}
+}
+
+func TestARM64PrivateSourceAPIKeepsContextRejections(t *testing.T) {
+	base := arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)")
+	for _, test := range []struct{ name, source string }{
+		{"native_frame_memory_helper", strings.Replace(base, "ADC $0,R9,R20", "MOVD (RSP),R20", 1)},
+		{"reserved_register", strings.Replace(base, "ADC $0,R9,R20", "MOVD R27,R20", 1)},
+		{"framed_helper", strings.Replace(base, "TEXT mix<>(SB),4,$0-0", "TEXT mix<>(SB),4,$16-0", 1)},
+		{"native_address", base + "TEXT ·Escape(SB),4,$0-0\nMOVD $mix<>(SB),R0\nRET\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original, err := Parse(ArchARM64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if prepared, err := CoalesceARM64PrivateRegisterHelpers(file); prepared != nil ||
+				!errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved source gained a continuation: file=%v error=%v", prepared, err)
+			}
+			if !reflect.DeepEqual(file, original) {
+				t.Fatal("failed source proof mutated its input")
+			}
+		})
+	}
+}
diff --git a/arm64_private_sp_helper_test.go b/arm64_private_sp_helper_test.go
new file mode 100644
index 000000000..3fe7bfd2e
--- /dev/null
+++ b/arm64_private_sp_helper_test.go
@@ -0,0 +1,262 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This first-party fragment retains the observed native RSP-relative buffer,
+// not a source rewrite which changes it into a positive virtual-SP offset.
+// Its clamped copies execute only initialized, bounded fixture buffers.
+func arm64PrivateSPHelperSource(bufferBytes ...int) string {
+	const root = `TEXT ·Buffer(SB),4,$32-24
+MOVD dst+0(FP),R2
+MOVD src+8(FP),R1
+MOVD n+16(FP),R3
+CMP $32,R3
+BLS bounded
+MOVD $32,R3
+bounded:
+MOVD RSP,R8
+SUB $32,R8
+STP (ZR,ZR),(R8)
+STP (ZR,ZR),16(R8)
+CALL copy<>(SB)
+MOVD R8,R1
+MOVD R2,R8
+MOVD $32,R3
+CALL copy<>(SB)
+RET
+`
+	_, helper, found := strings.Cut(arm64PrivateCallCFGCopySource, "TEXT copy<>(SB)")
+	if !found {
+		panic("first-party private copy fixture lost its complete helper")
+	}
+	caller := root
+	if len(bufferBytes) == 1 && bufferBytes[0] == 16 {
+		caller = strings.ReplaceAll(caller, "$32", "$16")
+		caller = strings.Replace(caller, "STP (ZR,ZR),16(R8)\n", "", 1)
+	} else if len(bufferBytes) > 1 || len(bufferBytes) == 1 && bufferBytes[0] != 32 {
+		panic("unregistered first-party buffer fixture span")
+	}
+	return caller + "TEXT copy<>(SB)" + helper
+}
+
+func TestARM64PrivateSPHelperOriginalGoObjects(t *testing.T) {
+	dir := t.TempDir()
+	for _, bufferBytes := range []int{16, 32} {
+		source := arm64PrivateSPHelperSource(bufferBytes)
+		path := filepath.Join(dir, fmt.Sprintf("private_sp_%d_arm64.s", bufferBytes))
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		for _, goos := range []string{"darwin", "linux", "windows"} {
+			t.Run(fmt.Sprintf("%d/%s", bufferBytes, goos), func(t *testing.T) {
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				object := filepath.Join(dir, fmt.Sprintf("%d-%s.o", bufferBytes, goos))
+				cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "main", "-o", object, path)
+				cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+				listing, err := runtimeOracleCombinedOutput(ctx, cmd)
+				if err != nil {
+					t.Fatalf("original framed source object: %v\n%s", err, listing)
+				}
+				// The actual Go frame saves LR at body SP and BP at body SP-8.
+				// Neither receipt says its automatic locals own the negative buffer.
+				text := string(listing)
+				if !strings.Contains(text, "TEXT\tmain.Buffer(SB)") && !strings.Contains(text, "TEXT\t\"\".Buffer(SB)") {
+					t.Fatalf("actual original object lost its Buffer symbol:\n%s", listing)
+				}
+				// Go 1.20 restores BP and LR as a pair; current Go uses a BP
+				// load followed by the post-index LR load. Both read BP at -8.
+				bpRestore := "MOVD\t-8(RSP), R29"
+				if !strings.Contains(text, bpRestore) {
+					bpRestore = "LDP\t-8(RSP), (R29, R30)"
+				}
+				for _, expected := range []string{fmt.Sprintf("MOVD.W\tR30, -%d(RSP)", bufferBytes+16), "MOVD\tR29, -8(RSP)", "MOVD\tRSP, R8", fmt.Sprintf("SUB\t$%d, R8", bufferBytes), "CALL\tcopy(SB)", bpRestore} {
+					if !strings.Contains(string(listing), expected) {
+						t.Fatalf("actual Go listing omitted %q:\n%s", expected, listing)
+					}
+				}
+				bytes, err := os.ReadFile(object)
+				if err != nil || len(bytes) == 0 {
+					t.Fatalf("missing actual object: %v", err)
+				}
+				t.Logf("selected SDK actual go tool asm: %s/arm64 source=%x object=%x bytes=%d BP-restore=%q", goos, sha256.Sum256([]byte(source)), sha256.Sum256(bytes), len(bytes), bpRestore)
+			})
+		}
+	}
+}
+
+func TestARM64PrivateSPHelperNeedsOriginalBacking(t *testing.T) {
+	source := arm64PrivateSPHelperSource()
+	pkg := mustGoPackage(t, "test/privatesp", "package privatesp\nfunc Buffer(dst, src *[32]byte, n uint64)\n")
+	context := llvm.NewContext()
+	defer context.Dispose()
+	result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+	})
+	if result != nil && !result.Module.IsNil() {
+		defer result.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || result != nil {
+		t.Fatalf("original negative-SP buffer acquired an unproved native frame contract: result=%v err=%v", result, err)
+	}
+	t.Logf("conservative translator rejection remains distinct from original Go ABI corruption: %v", err)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateSPHelperOriginalCanaries(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	const program = `package main
+
+import "unsafe"
+
+func Buffer(dst, src *[32]byte, n uint64)
+
+func main() {
+    for trial := 0; trial < 64; trial++ {
+        for _, off := range []int{0, 1, 7, 16, 32} {
+            for _, n := range []uint64{0, 1, 2, 3, 4, 7, 8, 15, 16, 17, 23, 31, 32, 33, 64, ^uint64(0)} {
+                var input, inputBefore, output, want [96]byte
+                for i := range input {
+                    input[i] = byte(trial*17 + i*37 + off)
+                    inputBefore[i] = input[i]
+                    output[i] = byte(i*19 + trial + 0xa5)
+                    want[i] = output[i]
+                }
+                q := n
+                if q > 32 { q = 32 }
+                for i := 0; i < 32; i++ {
+                    want[off+i] = 0
+                    if uint64(i) < q { want[off+i] = input[off+i] }
+                }
+                Buffer((*[32]byte)(unsafe.Pointer(&output[off])), (*[32]byte)(unsafe.Pointer(&input[off])), n)
+                if input != inputBefore { panic("original private SP helper changed input/full canary") }
+                if output != want { panic("original private SP helper mathematical/full canary mismatch") }
+            }
+        }
+    }
+}
+
+`
+	runARM64LocalRegisterGoOracle(t, arm64PrivateSPHelperSource(), program, len(runner) != 0)
+	t.Log(fmt.Sprintf("original Go only: %d initialized cases; all 96 input/output bytes observed; no LLVM/backing permission claim", 64*5*16))
+}
+
+// The observation trampoline owns its outgoing arguments and independently
+// restores the real Go caller LR/SP/BP. Buffer cannot overwrite the protected
+// cells above this trampoline's SP. Its damaged BP is observed, never used as
+// an address or exposed to the caller after the original BP is restored.
+func TestCrossLinuxRuntimeMatrixARM64PrivateSPHelperSavedBPObservation(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	const trampoline = `TEXT ·Measure(SB),516,$0-40
+MOVD dst+0(FP),R0
+MOVD src+8(FP),R1
+MOVD n+16(FP),R2
+SUB $64,RSP
+STP (R30,R29),48(RSP)
+MOVD R0,8(RSP)
+MOVD R1,16(RSP)
+MOVD R2,24(RSP)
+CALL ·Buffer(SB)
+MOVD R29,R0
+LDP 48(RSP),(R30,R29)
+MOVD R29,R1
+ADD $64,RSP
+MOVD R1,before+24(FP)
+MOVD R0,after+32(FP)
+RET
+`
+	const program = `package main
+
+import (
+    "encoding/binary"
+    "fmt"
+)
+
+func Buffer(dst, src *[32]byte, n uint64)
+func Measure(dst, src *[32]byte, n uint64) (before, after uint64)
+
+func main() {
+    for _, n := range []uint64{0, 1, 7, 16, 24, 25, 31, 32} {
+        var input, inputBefore, output, want [32]byte
+        for i := range input { input[i] = byte(0x41+i); inputBefore[i] = input[i] }
+        for i := uint64(0); i < n; i++ { want[i] = input[i] }
+        before, after := Measure(&output, &input, n)
+        expectedBP := binary.LittleEndian.Uint64(want[24:])
+        const positiveControl = false
+        if positiveControl {
+            if before != after { panic("disjoint positive-SP control changed the entry BP") }
+        } else {
+            if after != expectedBP { panic("original saved BP does not match the independent overwritten-byte reference") }
+            if before == after { panic("fixture did not expose original saved-BP corruption") }
+        }
+        if input != inputBefore || output != want { panic("original saved-BP observation changed source/output data") }
+        fmt.Printf("n=%d before=%016x after=%016x expectedData=%016x positiveControl=%t\n", n, before, after, expectedBP, positiveControl)
+    }
+}
+`
+	for _, bufferBytes := range []int{16, 32} {
+		t.Run(fmt.Sprint(bufferBytes), func(t *testing.T) {
+			bound := strings.ReplaceAll(program, "i < n", fmt.Sprintf("i < n && i < %d", bufferBytes))
+			bound = strings.ReplaceAll(bound, "want[24:]", fmt.Sprintf("want[%d:%d]", bufferBytes-8, bufferBytes))
+			for _, positiveControl := range []bool{false, true} {
+				name := "negativeSP"
+				if positiveControl {
+					name = "positiveSPControl"
+				}
+				t.Run(name, func(t *testing.T) {
+					source := arm64PrivateSPHelperSource(bufferBytes)
+					main := bound
+					if positiveControl {
+						// This separate first-party harness control is not an Aegis
+						// rewrite or a permission certificate for its negative buffer.
+						source = strings.Replace(source, fmt.Sprintf("SUB $%d,R8", bufferBytes), "ADD $8,R8", 1)
+						main = strings.Replace(main, "const positiveControl = false", "const positiveControl = true", 1)
+					}
+					runARM64PrivateSPGoObservation(t, trampoline+source, main, len(runner) != 0)
+				})
+			}
+		})
+	}
+}
+
+func runARM64PrivateSPGoObservation(t *testing.T, source, main string, cross bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module privatebpobservation\n\ngo 1.20\n",
+		"main.go": main, "oracle_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run", "-p=2", "."}
+	env := append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=")
+	if cross {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+		env = append(env, "GOOS=linux")
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir, cmd.Env = dir, env
+	output, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil {
+		t.Fatalf("safe original Go BP observation: %v\n%s", err, output)
+	}
+	if strings.Count(string(output), "positiveControl=") != 8 {
+		t.Fatalf("missing independent BP observation receipts: %q", output)
+	}
+	t.Logf("actual original Go observation: asm=%x Go=%x args=%q\n%s", sha256.Sum256([]byte(source)), sha256.Sum256([]byte(main)), args, output)
+}
diff --git a/arm64_private_store_frame_test.go b/arm64_private_store_frame_test.go
new file mode 100644
index 000000000..aeb4d3a8b
--- /dev/null
+++ b/arm64_private_store_frame_test.go
@@ -0,0 +1,356 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64PrivateFrameIncomingPointerStorePreservesCallerLink(t *testing.T) {
+	source := strings.Replace(arm64PrivateCallCopySource, "\tMOVD R5, 8(RSP)", "\tMOVD $90,R9\n\tMOVB R9,(R6)\n\tMOVD R5, 8(RSP)", 1)
+	arm64PrivateCallGoObject(t, source)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !arm64CallFrameUnexposed(file.Funcs[0]) {
+		t.Fatal("an ordinary incoming-pointer store exposed the private stack address")
+	}
+	_, err = Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple))
+	if err != nil {
+		t.Fatalf("unknown incoming-pointer store cannot overwrite this fresh unexposed saved caller link: %v", err)
+	}
+}
+
+func TestARM64PrivateFrameUnknownStoreProofIsSPOnly(t *testing.T) {
+	for _, tc := range []struct {
+		name, escaped, baseToken string
+		proof, intact            bool
+	}{
+		{name: "fresh", proof: true, intact: true},
+		{name: "fresh_code_escape", proof: true, escaped: "label:continuation", intact: true},
+		{name: "zero_default"},
+		{name: "legacy_code_escape", escaped: "label:continuation"},
+		{name: "sp_escape", proof: true, escaped: "sp:8"},
+		{name: "fp_escape", proof: true, escaped: "fp:0"},
+		{name: "fp_address_escape", proof: true, escaped: "fpa:0"},
+		{name: "unknown_escape", proof: true, escaped: "unknown-address"},
+		{name: "collapsed_frame_escape", proof: true},
+		{name: "sp_alias", proof: true, baseToken: "sp:0"},
+		{name: "sp_index_alias", proof: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			state := &arm64ControlState{
+				unexposedSP: tc.proof,
+				regs: map[Reg]arm64ControlValue{
+					SP: arm64ControlFromMap(map[string]bool{"sp:0": true}), "R6": arm64ControlFromMap(map[string]bool{tc.baseToken: true}),
+				},
+				memory: map[string]arm64ControlValue{
+					"sp:0": arm64ControlFromMap(map[string]bool{"label:caller": true}), "fp:0": arm64ControlFromMap(map[string]bool{"label:local": true}),
+				},
+			}
+			if tc.escaped != "" {
+				state.escaped = arm64ControlFromMap(map[string]bool{tc.escaped: true})
+			}
+			if tc.name == "collapsed_frame_escape" {
+				state.escaped = arm64ControlUnion(arm64ControlFromMap(map[string]bool{"sp:8": true}), arm64ControlFromMap(map[string]bool{"sp:16": true}))
+			}
+			if tc.name == "sp_index_alias" {
+				state.regs["R7"] = arm64ControlFromMap(map[string]bool{"sp:0": true})
+			}
+			// An indexed store has no exact cell even if its base is a known SP alias.
+			state.write(Operand{Kind: OpMem, Mem: MemRef{Base: "R6", Index: "R7"}}, arm64ControlExternal(), false)
+			if arm64ControlHas(state.memory["sp:0"], "") == tc.intact {
+				t.Errorf("private-SP preservation mismatch: %v", state.memory["sp:0"])
+			}
+			if !arm64ControlHas(state.memory["fp:0"], "") {
+				t.Fatal("incoming FP contents can alias this store and must remain clobbered")
+			}
+			value := state.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP}}, false)
+			if tc.intact && !arm64ControlEqual(value, arm64ControlFromMap(map[string]bool{"label:caller": true})) {
+				t.Errorf("unknown heap/code stores contaminated the proven private SP read: %v", value)
+			}
+			cloned := state.clone()
+			if cloned.unexposedSP != tc.proof {
+				t.Fatal("clone lost the source proof")
+			}
+			if tc.proof && (!cloned.merge(&arm64ControlState{}) || cloned.unexposedSP) {
+				t.Fatal("a CFG join must not upgrade an unproved incoming state")
+			}
+		})
+	}
+}
+
+func TestARM64PrivateFrameIncomingPointerAliasesAndConditionalStores(t *testing.T) {
+	for _, instructions := range []string{
+		"ADD $1,R6,R9\nMOVB R10,(R9)",
+		"CBZ R7,nostore\nMOVB R9,(R6)\nnostore:",
+		"MOVD R6,R9\nMOVB R10,(R9)(R7)",
+	} {
+		source := arm64PrivateFrameStoreSource(instructions)
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); err != nil {
+			t.Fatalf("ordinary pointer transform/conditional store exposed fresh SP: %v", err)
+		}
+	}
+}
+
+func TestARM64PrivateFrameUnknownSPIndexAndPartialStoresRemainRejected(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVB R9,7(RSP)", "MOVH R9,7(RSP)", "MOVW R9,7(RSP)",
+		"MOVD R9,(RSP)(R7)", "MOVD.P R9,8(RSP)", "MOVD.W R9,-8(RSP)",
+		"MOVD RSP,R9\nMOVB R10,(R9)(R7)",
+		"MOVD $8(RSP),R9\nMOVB R10,(R9)",
+	} {
+		source := arm64PrivateFrameStoreSource(instruction)
+		arm64PrivateCallGoObject(t, source)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if instruction == "MOVD $8(RSP),R9\nMOVB R10,(R9)" {
+			// Keep this exact byte source as a source-only negative. With
+			// typed call transport, its byte store is now proved wholly in
+			// private DATA [8,9), not the saved caller link. This is only
+			// object coverage: the original R10 is not initialized. The
+			// separate PrivateDataMemoryFamily runtime initializes data
+			// and checks complete output canaries for every scalar width.
+			if arm64CallFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("nil transport acquired a private data store proof")
+			}
+			if _, err := Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); err != nil {
+				t.Errorf("explicit typed private DATA byte: %v", err)
+			}
+			continue
+		}
+		if _, err := Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("explicit/moving/partial/escaped SP write must stay unproved: %q: %v", instruction, err)
+		}
+	}
+}
+
+func TestARM64PrivateFrameCoalescedCallRetainsOriginalSourceProof(t *testing.T) {
+	for _, escape := range []bool{false, true} {
+		source := strings.Replace(arm64PrivateCallCopySource, "\tCALL runtime·memmove(SB)", "\tMOVD $1,R9\n\tCALL helper<>(SB)\n\tMOVB R9,(R6)", 1)
+		if escape {
+			source = strings.Replace(source, "\tMOVD R5, 8(RSP)", "\tMOVD RSP,R10\n\tMOVD R10,(R6)\n\tMOVD R5, 8(RSP)", 1)
+		}
+		source += "TEXT helper<>(SB),NOSPLIT,$0\nADD $1,R9\nRET\n"
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		coalesced, err := coalesceARM64PrivateRegisterHelpers(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := coalesced.Funcs[0]
+		if fn.arm64PrivateUnexposedFrame == escape || arm64CallFrameUnexposed(fn) == escape {
+			t.Fatalf("coalescing erased the original source's escape=%v decision", escape)
+		}
+		_, err = Translate(coalesced, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple))
+		if escape && !errors.Is(err, ErrProbeNeedsContext) || !escape && err != nil {
+			t.Fatalf("coalesced heap store/RET source escape=%v: %v", escape, err)
+		}
+	}
+	file, err := Parse(ArchARM64, "TEXT local(SB),4,$16-0\nCALL label\nRET\nlabel:\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if arm64CallFrameUnexposed(file.Funcs[0]) {
+		t.Fatal("an unregistered source local call acquired a private helper proof")
+	}
+}
+
+const arm64PrivateFrameRepeatedStoreSource = `#include "textflag.h"
+TEXT ABI0Copy(SB),NOSPLIT,$32-24
+	MOVD dst+0(FP),R5
+	MOVD src+8(FP),R6
+	MOVD n+16(FP),R7
+	MOVD $90,R9
+	MOVB R9,(R6)
+	MOVD R5,8(RSP)
+	MOVD R6,16(RSP)
+	MOVD R7,24(RSP)
+	CALL runtime·memmove(SB)
+	MOVD dst+0(FP),R5
+	MOVD src+8(FP),R6
+	MOVD n+16(FP),R7
+	MOVD $165,R9
+	MOVB R9,1(R6)
+	MOVD R5,8(RSP)
+	MOVD R6,16(RSP)
+	MOVD R7,24(RSP)
+	CALL runtime·memmove(SB)
+	RET
+`
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateFrameRepeatedPointerStores(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	goSource := strings.Replace(arm64PrivateFrameRepeatedStoreSource, "TEXT ABI0Copy(SB)", "TEXT ·ABI0Copy(SB)", 1)
+	runARM64LocalRegisterGoOracle(t, goSource, `package main
+import "unsafe"
+func ABI0Copy(dst,src unsafe.Pointer,n uintptr)
+func main() {
+ for _,dst:=range []int{0,1,9,17,31} { for _,src:=range []int{0,1,9,17,31} { for _,n:=range []int{0,1,2,3,8,17,32,33} {
+  var data, want [96]byte
+  for i:=range data { data[i]=byte(i*37+dst*7+src*11+n); want[i]=data[i] }
+  for stage:=0;stage<2;stage++ {
+   want[src+stage]=[]byte{90,165}[stage]
+   var snapshot [33]byte
+   for i:=0;i<n;i++ { snapshot[i]=want[src+i] }
+   for i:=0;i<n;i++ { want[dst+i]=snapshot[i] }
+  }
+  ABI0Copy(unsafe.Pointer(&data[dst]),unsafe.Pointer(&data[src]),uintptr(n))
+  if data!=want { panic("actual Go private-frame repeated store/call/canary mismatch") }
+ } } }
+}
+`, len(runner) != 0)
+	t.Log("actual Go source passed 200 repeated-store/call overlap/unaligned/full-canary cases")
+	file, err := Parse(ArchARM64, arm64PrivateFrameRepeatedStoreSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, arm64PrivateCallCopyOptions(triple))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	const driver = `#include <stdint.h>
+extern void ABI0Copy(void *, const void *, uint64_t);
+int main(void) {
+ const int offsets[]={0,1,9,17,31}, sizes[]={0,1,2,3,8,17,32,33};
+ for(int d=0;d<5;d++) for(int s=0;s<5;s++) for(int z=0;z<8;z++) {
+  unsigned char data[96], want[96], snapshot[33];
+  int dst=offsets[d],src=offsets[s],n=sizes[z];
+  for(int i=0;i<96;i++) data[i]=want[i]=(unsigned char)(i*37+dst*7+src*11+n);
+  for(int stage=0;stage<2;stage++) {
+   want[src+stage]=(unsigned char)(stage==0 ? 90 : 165);
+   for(int i=0;i<n;i++) snapshot[i]=want[src+i];
+   for(int i=0;i<n;i++) want[dst+i]=snapshot[i];
+  }
+  ABI0Copy(data+dst,data+src,(uint64_t)n);
+  for(int i=0;i<96;i++) if(data[i]!=want[i]) return 1;
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_frame_repeated_stores", triple, module.String(), driver, runner)
+}
+
+func arm64PrivateFrameStoreForms() []string {
+	forms := []string{
+		"MOVB R9,(R6)", "MOVBU R9,(R6)", "MOVH R9,(R6)", "MOVHU R9,(R6)",
+		"MOVW R9,(R6)", "MOVWU R9,(R6)", "MOVD R9,(R6)",
+		"MOVD.P R9,8(R6)", "MOVD.W R9,8(R6)",
+		"FMOVS F0,(R6)", "FMOVD F0,(R6)",
+		"STP (R9,R10),(R6)", "STPW (R9,R10),(R6)",
+		"STP.P (R9,R10),16(R6)", "STP.W (R9,R10),16(R6)",
+		"FSTPS (F0,F1),(R6)", "FSTPD (F0,F1),(R6)", "FSTPQ (F0,F1),(R6)",
+		"FSTPQ.P (F0,F1),32(R6)", "FSTPQ.W (F0,F1),32(R6)",
+		"VST1 [V0.B16],(R6)", "VST1 [V0.H8,V1.H8],(R6)",
+		"VST1 [V0.S4,V1.S4,V2.S4],(R6)", "VST1 [V0.D2,V1.D2,V2.D2,V3.D2],(R6)",
+		"VST1.P [V0.B16],16(R6)",
+		"CASPW (R10,R11),(R6),(R12,R13)", "CASPD (R10,R11),(R6),(R12,R13)",
+	}
+	for _, width := range []string{"B", "H", "W", ""} {
+		forms = append(forms, "STLR"+width+" R9,(R6)")
+		for _, prefix := range []string{"STXR", "STLXR"} {
+			forms = append(forms, prefix+width+" R9,(R6),R10")
+		}
+	}
+	for _, op := range []string{"STXPW", "STXP", "STLXPW", "STLXP"} {
+		forms = append(forms, op+" (R9,R10),(R6),R11")
+	}
+	for _, order := range []string{"", "A", "L", "AL"} {
+		for _, width := range []string{"B", "H", "W", "D"} {
+			if order == "" || order == "AL" || width == "W" || width == "D" {
+				forms = append(forms, "CAS"+order+width+" R9,(R6),R10")
+			}
+			for _, op := range []string{"LDADD", "LDCLR", "LDEOR", "LDOR", "SWP"} {
+				forms = append(forms, op+order+width+" R9,(R6),R10")
+			}
+		}
+	}
+	return forms
+}
+
+func arm64PrivateFrameStoreSource(instruction string) string {
+	return strings.Replace(arm64PrivateCallCopySource, "\tMOVD R5, 8(RSP)", "\t"+instruction+"\n\tMOVD src+8(FP),R6\n\tMOVD R5, 8(RSP)", 1)
+}
+
+func TestARM64PrivateFrameAllNamedStoreFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for index, instruction := range arm64PrivateFrameStoreForms() {
+		t.Run(instruction, func(t *testing.T) {
+			source := arm64PrivateFrameStoreSource(instruction)
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				ir, err := Translate(file, arm64PrivateCallCopyOptions(target))
+				if err != nil {
+					t.Errorf("%s: store through incoming pointer cannot name the fresh private frame: %v", target, err)
+					continue
+				}
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("store-%d.ll", index), fmt.Sprintf("store-%d.o", index), ir)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateFramePhysicalSPStoresRemainRejected(t *testing.T) {
+	for _, instruction := range arm64PrivateFrameStoreForms() {
+		t.Run(instruction, func(t *testing.T) {
+			// Every width and conditional atomic store can overwrite saved LR.
+			// Being an actual physical-SP destination must defeat the exception.
+			source := arm64PrivateFrameStoreSource(strings.ReplaceAll(instruction, "R6", "RSP"))
+			arm64PrivateCallGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("a store to physical SP must not retain caller LR: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateFrameRepeatedCallAndPointerStorePreservesCallerLink(t *testing.T) {
+	source := strings.Replace(arm64PrivateCallCopySource, "\tRET", `
+	MOVD src+8(FP),R6
+	MOVB R0,(R6)
+	MOVD dst+0(FP),R5
+	MOVD n+16(FP),R7
+	MOVD R5,8(RSP)
+	MOVD R6,16(RSP)
+	MOVD R7,24(RSP)
+	CALL runtime·memmove(SB)
+	RET`, 1)
+	arm64PrivateCallGoObject(t, source)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !arm64CallFrameUnexposed(file.Funcs[0]) {
+		t.Fatal("ordinary incoming-pointer stores and repeated calls exposed the private stack address")
+	}
+	if _, err := Translate(file, arm64PrivateCallCopyOptions(arm64LinuxGNUTriple)); err != nil {
+		t.Fatalf("call-result code-address taint cannot expose the fresh private stack address: %v", err)
+	}
+}
diff --git a/arm64_private_structure_memory.go b/arm64_private_structure_memory.go
new file mode 100644
index 000000000..ad9af2fa3
--- /dev/null
+++ b/arm64_private_structure_memory.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import "fmt"
+
+// Decoding/lowering a structure access alone cannot certify a physical frame.
+// In a raw framed source, any missing complete source proof remains Context,
+// rather than silently falling back to a larger guarded LLVM allocation.
+func requireARM64RawStructureFrameProof(fn Func, unexposed bool) error {
+	if unexposed || !arm64RawStructureFrameProofRequired(fn) {
+		return nil
+	}
+	return fmt.Errorf("%w: ARM64 raw framed structure memory needs the complete physical-stack/source-escape proof", ErrProbeNeedsContext)
+}
+
+func arm64RawStructureFrameProofRequired(fn Func) bool {
+	if !arm64HasRawFrameCode(fn) || !arm64SourceGoFrame(fn).present {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if _, handled, _ := parseARM64StructureMemory(ins); handled {
+			return true
+		}
+	}
+	return false
+}
+
+// Structures cannot preserve a pointer's exact identity through the SIMD bank.
+// The complete transfer width still supplies a bounds/overlap certificate; a
+// register-indexed writeback remains unknown for a private affine base.
+func (s *arm64RawPrivateFrameState) structureMemory(form arm64StructureMemoryForm, frameSize int64) bool {
+	base := form.memory.Mem.Base
+	address, private := s.address(base)
+	if _, frame := s.address(form.index); frame || private && form.index != "" {
+		return false
+	}
+	if !s.memory(arm64RawPrivateMemoryForm{
+		memory: form.memory, registers: []Reg{form.registers[0]},
+		elementBytes: form.width(), store: !form.load,
+	}, frameSize) {
+		return false
+	}
+	if private && form.post {
+		updated, valid := arm64PrivateFrameOffset(address, form.increment)
+		if !valid || !updated.exact || updated.offset < s.sp || updated.offset > frameSize+8 {
+			return false
+		}
+		return s.assign(base, updated, true)
+	}
+	return true
+}
+
+func (state *arm64ControlState) transferStructureMemory(ins Instr) bool {
+	form, handled, err := parseARM64StructureMemory(ins)
+	if !handled || err != nil {
+		return false
+	}
+	if form.load {
+		value := state.readMemoryWidth(form.memory, form.width(), false)
+		for _, reg := range form.registers {
+			if form.lane >= 0 {
+				// LDn lane preserves the remaining physical vector bits.
+				value = arm64ControlUnion(value, arm64ControlRead(state.regs, reg))
+			}
+			state.write(Operand{Kind: OpReg, Reg: reg}, value, false)
+		}
+	} else {
+		value := arm64ControlExternal()
+		for _, reg := range form.registers {
+			value = arm64ControlUnion(value, arm64ControlRead(state.regs, reg))
+		}
+		state.writeMemoryWidth(form.memory, value, form.width(), false)
+	}
+	if form.post {
+		base := arm64ControlBase(form.memory.Mem.Base)
+		value := arm64ControlRead(state.regs, base)
+		if form.index == "" {
+			value = arm64ControlOffset(value, form.increment)
+		} else {
+			value = arm64ControlUnion(arm64ControlExternal(), arm64ControlLabels(value))
+			value = arm64ControlUnion(value, arm64ControlLabels(arm64ControlRead(state.regs, form.index)))
+			if arm64ControlCount(arm64ControlLabels(value)) != 0 {
+				value = arm64ControlWithToken(value, "code-derived:")
+			}
+		}
+		state.regs[base] = value
+	}
+	return true
+}
diff --git a/arm64_private_structure_runtime_test.go b/arm64_private_structure_runtime_test.go
new file mode 100644
index 000000000..148612b10
--- /dev/null
+++ b/arm64_private_structure_runtime_test.go
@@ -0,0 +1,323 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64PrivateStructureCase struct {
+	name, instruction string
+	kind, count       int // 0 load, 1 store, 2 replicate, 3/4 lane, 5 external store
+	bits, lanes, lane int
+	post              int
+	contiguous        bool // LD1/ST1 concatenate; LD2-4/ST2-4 interleave.
+}
+
+// Whole-register cases share the independent Go encoder enumeration. Lane
+// cases use its separate independent architectural encoder, not a decoder's
+// own output. Only R0/R1/R2/R7/R9/R10 and SIMD registers are touched; these
+// first-party fixtures never write R18, g/R28, or an incoming physical frame.
+func arm64PrivateStructureCases() []arm64PrivateStructureCase {
+	var cases []arm64PrivateStructureCase
+	for _, tc := range arm64RawStructureCases() {
+		if tc.base != 3 { // One address/register tuple; widths/counts/modes are independent axes.
+			continue
+		}
+		kind := 0
+		if !tc.load {
+			kind = 1
+		} else if tc.replicate {
+			kind = 2
+		}
+		base := "R9"
+		if tc.post == 2 {
+			base = "R2" // Unknown register writeback is not a private-frame proof.
+			if !tc.load {
+				base, kind = "R1", 5
+			}
+		}
+		cases = append(cases, arm64PrivateStructureCase{
+			instruction: strings.ReplaceAll(tc.syntax, "(R3)", "("+base+")"),
+			kind:        kind, count: tc.count, bits: tc.bits, lanes: tc.lanes, lane: -1, post: tc.post,
+			contiguous: tc.op == "VLD1" || tc.op == "VST1",
+		})
+	}
+	for _, load := range []bool{false, true} {
+		for count := 1; count <= 4; count++ {
+			for _, bits := range []int{8, 16, 32, 64} {
+				for _, lane := range []int{0, 128/bits - 1} {
+					for post := 0; post < 3; post++ {
+						base, kind := 9, 4
+						if load {
+							kind = 3
+						}
+						mode := arm64RawStructureLanePost(post)
+						if post == 2 {
+							base = 2
+							if !load {
+								base, kind = 1, 6
+							}
+						}
+						word := encodeARM64RawStructureLane(load, count, bits, lane, mode, 7, base, 25)
+						cases = append(cases, arm64PrivateStructureCase{
+							instruction: fmt.Sprintf("WORD $%#08x", word),
+							kind:        kind, count: count, bits: bits, lanes: 128 / bits, lane: lane, post: post,
+						})
+					}
+				}
+			}
+		}
+	}
+	for index := range cases {
+		cases[index].name = fmt.Sprintf("structure_%03d", index)
+	}
+	return cases
+}
+
+func arm64PrivateStructureFixture(t *testing.T) (string, GoPackage, []arm64PrivateStructureCase) {
+	t.Helper()
+	cases := arm64PrivateStructureCases()
+	var source, declarations strings.Builder
+	for _, tc := range cases {
+		fmt.Fprintf(&declarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&source, `TEXT ·%s(SB),4,$120-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xd2800024
+VLD1 (R0),[V25.B16,V26.B16,V27.B16,V28.B16]
+ADD $64,R0,R2
+VLD1 (R2),[V16.B16,V17.B16,V18.B16,V19.B16]
+ADD $16,RSP,R9
+VST1 [V16.B16,V17.B16,V18.B16,V19.B16],(R9)
+`, tc.name)
+		if tc.post == 2 {
+			increment := tc.count * tc.bits / 8
+			if tc.lane < 0 && tc.kind != 2 {
+				increment *= tc.lanes
+			}
+			fmt.Fprintf(&source, "MOVD $%d,R7\n", increment)
+		}
+		source.WriteString(tc.instruction + "\nMOVD $0,R9\n")
+		if tc.kind == 1 || tc.kind == 4 {
+			source.WriteString(`ADD $16,RSP,R10
+VLD1 (R10),[V20.B16,V21.B16,V22.B16,V23.B16]
+VST1 [V20.B16,V21.B16,V22.B16,V23.B16],(R1)
+MOVD $0,R10
+`)
+		} else if tc.kind != 5 && tc.kind != 6 {
+			fmt.Fprintf(&source, "VST1 %s,(R1)\n", arm64TestVectorList(25, tc.count, "B16"))
+		}
+		source.WriteString("MOVD 0(RSP),R30\nRET\n")
+	}
+	pkg := mustGoPackage(t, "structureoracle", "package main\n"+declarations.String())
+	return source.String(), pkg, cases
+}
+
+func TestARM64PrivateStructureNumericalFamilyObjects(t *testing.T) {
+	source, pkg, cases := arm64PrivateStructureFixture(t)
+	requireARM64GoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ctx := llvm.NewContext()
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target, ResolveSym: testResolveSym("structureoracle"),
+		})
+		if err != nil {
+			ctx.Dispose()
+			t.Fatal(err)
+		}
+		ir := result.Module.String()
+		result.Module.Dispose()
+		ctx.Dispose()
+		compileLLVMToObject(t, llc, target, "structure-family.ll", "structure-family.o", ir)
+	}
+	t.Logf("%d initialized numerical fixtures; all structure mnemonics, arrangements, counts, post-index modes and first/last raw lanes", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64PrivateStructureFamily(t *testing.T) {
+	source, pkg, cases := arm64PrivateStructureFixture(t)
+	arm64RunPrivateStructureFixture(t, source, pkg, cases)
+}
+
+func arm64RunPrivateStructureFixture(t *testing.T, source string, pkg GoPackage, cases []arm64PrivateStructureCase) {
+	t.Helper()
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var declarations, checks, cDeclarations, cChecks strings.Builder
+	for _, tc := range cases {
+		fmt.Fprintf(&declarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&checks, "check(%s,%d,%d,%d,%d,%d,%t)\n", tc.name, tc.kind, tc.count, tc.bits/8, tc.lanes, tc.lane, tc.contiguous)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const unsigned char *,unsigned char *);\n", tc.name)
+		contiguous := 0
+		if tc.contiguous {
+			contiguous = 1
+		}
+		fmt.Fprintf(&cChecks, "if(check(%s,%d,%d,%d,%d,%d,%d)) return 1;\n", tc.name, tc.kind, tc.count, tc.bits/8, tc.lanes, tc.lane, contiguous)
+	}
+	dir := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod":         "module structureoracle\n\ngo 1.20\n",
+		"main.go":        arm64PrivateStructureGoOracle + declarations.String() + "func main(){\n" + checks.String() + "}\n",
+		"oracle_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=2", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go initialized structure oracle: %v\n%s", err, output)
+	}
+	llvmCtx := llvm.NewContext()
+	result, err := translateGoModuleInContext(llvmCtx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string {
+			return strings.TrimPrefix(symbol, "·")
+		},
+	})
+	if err != nil {
+		llvmCtx.Dispose()
+		t.Fatal(err)
+	}
+	ir := result.Module.String()
+	result.Module.Dispose()
+	llvmCtx.Dispose()
+	cSource := arm64PrivateStructureCOracle + cDeclarations.String() + "int main(void){\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "private_structure", triple, ir, cSource, runner)
+	t.Logf("actual Go + LLVM22/independent C: %d fixtures x 32 patterns x 3 unaligned offsets; complete inputs/outputs/canaries, non-roundtrip lane/interleave/replicate reference", len(cases))
+}
+
+const arm64PrivateStructureGoOracle = `package main
+
+func check(fn func(*byte, *byte), kind, count, width, lanes, lane int, contiguous bool) {
+	var input [192]byte
+	var output, want [128]byte
+	for trial := 0; trial < 32; trial++ {
+		for _, off := range []int{0, 1, 7} {
+			for i := range input {
+				input[i] = byte(i*71 + trial*53 + 19)
+			}
+			for i := range output {
+				output[i], want[i] = 0xa5, 0xa5
+			}
+			snapshot := input
+			p := want[off:]
+			if kind == 1 || kind == 4 {
+				copy(p[:64], input[off+64:off+128])
+			}
+			if kind == 0 || kind == 2 {
+				for i := 0; i < count*16; i++ {
+					p[i] = 0
+				}
+			}
+			if kind == 3 {
+				copy(p[:count*16], input[off:off+count*16])
+			}
+			for reg := 0; reg < count; reg++ {
+				if kind == 3 || kind == 4 || kind == 6 {
+					src, dst := 64+reg*width, reg*16+lane*width
+					if kind != 3 {
+						src, dst = reg*16+lane*width, reg*width
+					}
+					copy(p[dst:dst+width], input[off+src:off+src+width])
+					continue
+				}
+				for element := 0; element < lanes; element++ {
+					interleaved := (element*count + reg) * width
+					if contiguous {
+						interleaved = (reg*lanes + element) * width
+					}
+					src, dst := 64+interleaved, reg*16+element*width
+					if kind == 2 {
+						src = 64 + reg*width
+					}
+					if kind == 1 || kind == 5 {
+						src, dst = reg*16+element*width, interleaved
+					}
+					copy(p[dst:dst+width], input[off+src:off+src+width])
+				}
+			}
+			fn(&input[off], &output[off])
+			if input != snapshot || output != want {
+				println(kind, count, width, lanes, lane, trial, off)
+				panic("initialized structure layout/canary mismatch")
+			}
+		}
+	}
+}
+`
+
+const arm64PrivateStructureCOracle = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static int check(void (*fn)(const unsigned char *, unsigned char *),
+                 unsigned kind, unsigned count, unsigned width,
+                 unsigned lanes, int lane, unsigned contiguous) {
+  unsigned char input[192], snapshot[192], output[128], want[128];
+  const unsigned offsets[] = {0,1,7};
+  for (unsigned trial=0;trial<32;trial++) {
+    for (unsigned o=0;o<3;o++) {
+      unsigned off=offsets[o];
+      for (unsigned i=0;i<192;i++) input[i]=(unsigned char)(i*71+trial*53+19);
+      memcpy(snapshot,input,192);
+      memset(output,0xa5,128);
+      memset(want,0xa5,128);
+      unsigned char *p=want+off;
+      if (kind==1 || kind==4) memcpy(p,input+off+64,64);
+      if (kind==0 || kind==2) memset(p,0,count*16);
+      if (kind==3) memcpy(p,input+off,count*16);
+      for (unsigned reg=0;reg<count;reg++) {
+        if (kind==3 || kind==4 || kind==6) {
+          unsigned src=64+reg*width,dst=reg*16+lane*width;
+          if (kind!=3) {
+            src=reg*16+lane*width;
+            dst=reg*width;
+          }
+          memcpy(p+dst,input+off+src,width);
+          continue;
+        }
+        for (unsigned element=0;element<lanes;element++) {
+          unsigned interleaved=(element*count+reg)*width;
+          if (contiguous) interleaved=(reg*lanes+element)*width;
+          unsigned src=64+interleaved,dst=reg*16+element*width;
+          if (kind==2) src=64+reg*width;
+          if (kind==1 || kind==5) {
+            src=reg*16+element*width;
+            dst=interleaved;
+          }
+          memcpy(p+dst,input+off+src,width);
+        }
+      }
+      fn(input+off,output+off);
+      if (memcmp(input,snapshot,192) || memcmp(output,want,128)) {
+        fprintf(stderr,"structure kind/count/width/lanes/lane/trial/off %u/%u/%u/%u/%d/%u/%u\n",
+                kind,count,width,lanes,lane,trial,off);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_private_structure_test.go b/arm64_private_structure_test.go
new file mode 100644
index 000000000..ceb2b467d
--- /dev/null
+++ b/arm64_private_structure_test.go
@@ -0,0 +1,329 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64PrivateStructureSource(body string) string {
+	return `TEXT ·Structure(SB),4,$120-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xd2800024
+` + body + `
+MOVD $0,R9
+MOVD 0(RSP),R30
+RET
+`
+}
+
+func arm64PrivateStructureAPIs(t *testing.T, source string, wantContext bool, objects bool) {
+	t.Helper()
+	pkg := arm64PrivateCallDeclarations(t, "func Structure(in,out unsafe.Pointer)\n")
+	resolve := func(sym string) string {
+		return "test." + strings.TrimPrefix(sym, "·")
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if objects && llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		opt := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+		ir, err := Translate(file, opt)
+		check := func(api string, err error) {
+			t.Helper()
+			if wantContext {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s %s: want Context, got %v", triple, api, err)
+				}
+			} else if err != nil {
+				t.Errorf("%s %s: %v", triple, api, err)
+			}
+		}
+		check("Translate", err)
+		if err == nil && objects {
+			compileLLVMToObject(t, llc, triple, "private-structure.ll", "private-structure.o", ir)
+		}
+		ctx := llvm.NewContext()
+		module, moduleErr := TranslateModuleInContext(ctx, file, opt)
+		var moduleIR, boundIR string
+		if moduleErr == nil {
+			moduleIR = module.String()
+			module.Dispose()
+		}
+		check("Module", moduleErr)
+		bound, boundErr := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+		})
+		if boundErr == nil {
+			boundIR = bound.Module.String()
+			bound.Module.Dispose()
+		}
+		check("GoModule", boundErr)
+		ctx.Dispose()
+		if objects && moduleErr == nil {
+			compileLLVMToObject(t, llc, triple, "private-module.ll", "private-module.o", moduleIR)
+		}
+		if objects && boundErr == nil {
+			compileLLVMToObject(t, llc, triple, "private-go-module.ll", "private-go-module.o", boundIR)
+		}
+	}
+}
+
+func TestARM64PrivateStructureFrameAndContinuation(t *testing.T) {
+	for count := 1; count <= 4; count++ {
+		list := arm64TestVectorList(0, count, "S4")
+		body := fmt.Sprintf(`VLD1 (R0),%s
+ADD $16,RSP,R9
+VST%d %s,(R9)
+VLD%d (R9),%s
+VST1 %s,(R1)
+`, list, count, list, count, list, list)
+		source := arm64PrivateStructureSource(body)
+		requireARM64GoAssemblerResult(t, source, true)
+		arm64PrivateStructureAPIs(t, source, false, true)
+	}
+}
+
+func TestARM64PrivateStructureReservedRegistersRemainSame(t *testing.T) {
+	// These are valid raw UMOV instructions. Named R18 is deliberately not a
+	// Go scratch register, and R28 is g. Neither may borrow fresh-frame alias
+	// permission merely because the result transport does not mention it.
+	for _, word := range []uint32{0x0e043c12, 0x0e043c1c} {
+		source := arm64PrivateStructureSource(fmt.Sprintf("WORD $%#08x\nMOVD R0,(R1)", word))
+		requireARM64GoAssemblerResult(t, source, true)
+		arm64PrivateStructureAPIs(t, source, true, false)
+	}
+}
+
+func TestARM64PrivateStructureCompleteTypedExtents(t *testing.T) {
+	cases := arm64RawStructureCases()
+	var source strings.Builder
+	source.WriteString("TEXT structureFormats(SB),516,$0-0\n")
+	for _, tc := range cases {
+		fmt.Fprintln(&source, tc.syntax)
+	}
+	source.WriteString("UNDEF\n") // Compile-form harness, never executed.
+	code := assembleARM64StructureTestBytes(t, source.String())
+	if len(code) < 4*len(cases) {
+		t.Fatal("actual Go object omitted structure formats")
+	}
+	for index, tc := range cases {
+		if word := binary.LittleEndian.Uint32(code[index*4:]); word != tc.word {
+			t.Fatalf("actual Go object %s: %#08x != independent %#08x", tc.syntax, word, tc.word)
+		}
+		file, err := Parse(ArchARM64, "TEXT f(SB),$0-0\n"+tc.syntax+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, ins := range []Instr{file.Funcs[0].Instrs[1], {Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(tc.word)}}}} {
+			form, handled, err := parseARM64StructureMemory(ins)
+			width := int64(tc.count * tc.bits / 8)
+			if !tc.replicate {
+				width *= int64(tc.lanes)
+			}
+			if !handled || err != nil || form.width() != width || form.load != tc.load || form.replicate != tc.replicate ||
+				form.post != (tc.post != 0) || len(form.registers) != tc.count {
+				t.Fatalf("%s/%#08x: form=%+v handled=%v err=%v, width=%d", tc.syntax, tc.word, form, handled, err, width)
+			}
+			if tc.post == 1 && form.increment != width || tc.post == 2 && form.index != "R7" {
+				t.Fatalf("%s lost encoded writeback: %+v", tc.syntax, form)
+			}
+		}
+	}
+	for _, load := range []bool{false, true} {
+		for count := 1; count <= 4; count++ {
+			for _, bits := range []int{8, 16, 32, 64} {
+				for lane := 0; lane < 128/bits; lane++ {
+					for post := arm64RawStructureLaneNoPost; post <= arm64RawStructureLaneRegisterPost; post++ {
+						word := encodeARM64RawStructureLane(load, count, bits, lane, post, 7, 9, 30)
+						form, handled, err := parseARM64StructureMemory(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+						if !handled || err != nil || form.width() != int64(count*bits/8) || form.load != load || form.lane != lane {
+							t.Fatalf("raw lane %#08x: %+v/%v/%v", word, form, handled, err)
+						}
+					}
+				}
+			}
+		}
+	}
+	t.Logf("shared memory grammar: %d original Go C_LIST formats plus every raw LD/ST1-4 lane, element width and writeback", len(cases))
+}
+
+func TestARM64PrivateStructureBoundsSpillsAndJoinsRemainContext(t *testing.T) {
+	for _, body := range []string{
+		"ADD $16,RSP,R9\nMOVD R9,32(RSP)\nADD $32,RSP,R10\nVLD1 (R10),[V0.B16]\nMOVD $0,R10",
+		"ADD $16,RSP,R9\nMOVD R9,32(RSP)\nADD $33,RSP,R10\nVST1 V0.B[0],(R10)\nMOVD $0,R10",
+		"ADD $120,RSP,R9\nVLD1 (R9),[V0.B16]",
+		"SUB $16,RSP,R9\nVST1 [V0.B16],(R9)",
+		"ADD $16,RSP,R9\nVLD1.P (R9)(R4),[V0.B16]",
+		"ADD $16,RSP,R9\nVST1.P [V0.B16],(R9)(R4)",
+		"MOVD RSP,R9\nVST1 [V0.B16],(R1)(R9)",
+		"CBZ R4,other\nADD $16,RSP,R9\nB joined\nother:\nADD $24,RSP,R9\njoined:\nVLD1 (R9),[V0.B16]",
+		"CBZ R4,other\nADD $16,RSP,R9\nB joined\nother:\nMOVD R0,R9\njoined:\nVST1 [V0.B16],(R9)",
+		"VST1 [V0.B16],(RSP)",
+		"MOVD RSP,R9\nVST1 V0.H[0],1(R9)",
+		"ADD $16,RSP,R9\nMOVD R9,holder(SB)\nVLD1 (R9),[V0.B16]",
+		"ADD $16,RSP,R9\nMOVD R9,out+8(FP)\nVLD1 (R9),[V0.B16]",
+		"ADD $16,RSP,R9\nVMOV R9,V0.D[0]\nVST1 [V0.B16],(R1)",
+		"ADD $16,RSP,R9\nWORD $0xffffffff",
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", ";"), func(t *testing.T) {
+			source := arm64PrivateStructureSource(body) + "GLOBL holder(SB),NOPTR,$8\n"
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			linkOverlap := body == "VST1 [V0.B16],(RSP)" || body == "MOVD RSP,R9\nVST1 V0.H[0],1(R9)"
+			if arm64CallFrameUnexposed(file.Funcs[0]) && !linkOverlap {
+				t.Fatal("structure bounds/escape proof accepted uncertain source")
+			}
+			// Unknown encodings and malformed Go formats can be Unsupported;
+			// no public entry point may call them successful translations.
+			if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+				ResolveSym: testResolveSym("test"), Sigs: map[string]FuncSig{"test.Structure": arm64RawPrivateFrameSignature("test.Structure")}}); err == nil {
+				t.Fatal("unsafe original structure source passed translation")
+			}
+		})
+	}
+}
+
+func TestARM64PrivateStructureControlWidthsAndVectorAliases(t *testing.T) {
+	for _, tc := range []struct {
+		syntax string
+		width  int64
+	}{
+		{"VLD1R (R9),[V0.S4]", 4},
+		{"VLD4R (R9),[V0.D2,V1.D2,V2.D2,V3.D2]", 32},
+		{"VLD1 (R9),[V0.B8]", 8},
+		{"VLD4 (R9),[V0.H8,V1.H8,V2.H8,V3.H8]", 64},
+		{"VST1 V0.B[15],(R9)", 1},
+		{"VST1 [V0.B16],(R9)", 16},
+	} {
+		file, err := Parse(ArchARM64, "TEXT f(SB),$0-0\n"+tc.syntax+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		form, _, err := parseARM64StructureMemory(file.Funcs[0].Instrs[1])
+		if err != nil || form.width() != tc.width {
+			t.Fatalf("%s: %+v/%v", tc.syntax, form, err)
+		}
+		for _, offset := range []int64{-8, -1, 0, tc.width - 1, tc.width} {
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R9": arm64ControlFromMap(map[string]bool{"sp:0": true}), "F0": arm64ControlFromMap(map[string]bool{"label:vectorPC": true})},
+				memory: map[string]arm64ControlValue{fmt.Sprintf("sp:%d", offset): arm64ControlFromMap(map[string]bool{"label:caller": true})},
+			}
+			if !state.transferStructureMemory(file.Funcs[0].Instrs[1]) {
+				t.Fatal("validated memory effect was not consumed")
+			}
+			overlap := offset+8 > 0 && offset < tc.width
+			if form.load {
+				value := arm64ControlRead(state.regs, form.registers[0])
+				if arm64ControlHas(value, "label:caller") != overlap {
+					t.Fatalf("%s offset %d: source PC overlap washed/laundered: %v", tc.syntax, offset, value)
+				}
+			} else {
+				value := state.memory[fmt.Sprintf("sp:%d", offset)]
+				if arm64ControlHas(value, "") != overlap {
+					t.Fatalf("%s offset %d: store extent lost: %v", tc.syntax, offset, value)
+				}
+				if !arm64ControlHas(state.escaped, "label:vectorPC") && arm64ControlCount(arm64ControlLabels(state.memory["sp:0"])) == 0 {
+					t.Fatal("F/V physical alias lost stored code bits")
+				}
+			}
+		}
+	}
+}
+
+func TestARM64PrivateStructureLargeFrameR20RequiresTypedEntry(t *testing.T) {
+	source := strings.Replace(arm64PrivateStructureSource(`ADD $16,RSP,R9
+MOVD R4,(R9)
+ADD $16,R20,R10
+VLD1R (R10),[V0.S4]
+VST1 [V0.B16],(R1)
+MOVD $0,R10
+MOVD $0,R20`), "$120-16", "$232-16", 1)
+	requireARM64GoAssemblerResult(t, source, true)
+	arm64PrivateStructureAPIs(t, source, false, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Preserve the original source-only/unbound negative: a fallback signature
+	// does not supply the entry/result transport for its implicit R20 value.
+	_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"·Structure": {Name: "·Structure", Ret: I64}},
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("uncontracted original R20 source: %v", err)
+	}
+}
+
+func TestARM64PrivateStructureNamedLaneDisplacementIsNotRewritten(t *testing.T) {
+	for _, instruction := range []string{
+		"VLD1 1(R0),V0.B[0]",
+		"VST1 V0.H[0],2(R1)",
+	} {
+		// Go cases 96/97 accept C_LOREG here but encode Rm=31 in the
+		// no-post form. That field is architecturally reserved, not an
+		// address displacement or an implicit fixed post increment.
+		code := assembleARM64StructureTestBytes(t, "TEXT laneEncoding(SB),516,$0-0\n"+instruction+"\nUNDEF\n")
+		word := binary.LittleEndian.Uint32(code)
+		if word&(1<<23) != 0 || word>>16&31 != 31 {
+			t.Fatalf("actual Go %s lacks the no-post reserved Rm witness: %#08x", instruction, word)
+		}
+		if _, valid := decodeARM64RawStructureLane(word); valid {
+			t.Fatalf("reserved original Go encoding %#08x accepted as a valid lane", word)
+		}
+		arm64PrivateStructureAPIs(t, arm64PrivateStructureSource(instruction), true, false)
+	}
+}
+
+func TestARM64PrivateStructureNamedReservedD1IsNotRewritten(t *testing.T) {
+	for count := 2; count <= 4; count++ {
+		for _, load := range []bool{false, true} {
+			for _, mode := range []string{"plain", "implicit", "immediate", "register"} {
+				op, suffix, memory := fmt.Sprintf("VST%d", count), "", "(R1)"
+				if load {
+					op, memory = fmt.Sprintf("VLD%d", count), "(R0)"
+				}
+				if mode != "plain" {
+					suffix = ".P"
+				}
+				if mode == "immediate" {
+					memory = fmt.Sprintf("%d%s", count*8, memory)
+				} else if mode == "register" {
+					memory += "(R4)"
+				}
+				list := arm64TestVectorList(0, count, "D1")
+				instruction := op + suffix + " " + list + "," + memory
+				if load {
+					instruction = op + suffix + " " + memory + "," + list
+				}
+				code := assembleARM64StructureTestBytes(t, "TEXT reservedD1(SB),516,$0-0\n"+instruction+"\nUNDEF\n")
+				word := binary.LittleEndian.Uint32(code)
+				if word&(1<<30) != 0 || word>>10&3 != 3 {
+					t.Fatalf("actual Go %s lacks Q=0/size=3 witness: %#08x", instruction, word)
+				}
+				if _, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}); err == nil {
+					t.Fatalf("architecturally reserved original Go encoding %#08x decoded", word)
+				}
+				arm64PrivateStructureAPIs(t, arm64PrivateStructureSource(instruction), true, false)
+			}
+		}
+	}
+}
diff --git a/arm64_private_tail_contract.go b/arm64_private_tail_contract.go
new file mode 100644
index 000000000..31cbbd9cf
--- /dev/null
+++ b/arm64_private_tail_contract.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import "strings"
+
+func arm64PrivateTailSymbol(symbol string) bool {
+	base, _, ok := parseSBRef(strings.TrimSpace(symbol))
+	return ok && strings.HasSuffix(goTextSymbolForResolution(base), "<>")
+}
+
+// A standalone private source helper does not share its caller's virtual GP
+// registers or FP allocations. An ordinary Frame, even with identical Go
+// argument/result types, is not a source-register transport contract.
+func arm64ValidatePrivateTailTransport(symbol string, sig FuncSig, present bool) error {
+	if !arm64PrivateTailSymbol(symbol) {
+		return nil
+	}
+	_, offset, _ := parseSBRef(symbol)
+	if offset != 0 {
+		return arm64GoABIContext("private tail %q has no entry contract for a symbol offset", symbol)
+	}
+	if !present || len(sig.ArgRegs) == 0 || len(sig.ArgRegs) != len(sig.Args) {
+		return arm64GoABIContext("private tail %q requires an explicit complete register transport, not its caller's Frame", symbol)
+	}
+	for i, reg := range sig.ArgRegs {
+		_, floating := arm64ParseFReg(reg)
+		if arm64MachineScalarWidth(sig.Args[i]) == 0 ||
+			!floating && !isARM64GeneralOrZeroReg(reg) && !arm64StackReg(reg) {
+			return arm64GoABIContext("private tail %q has an unproved register/type at argument %d", symbol, i)
+		}
+	}
+	return nil
+}
diff --git a/arm64_private_tail_contract_test.go b/arm64_private_tail_contract_test.go
new file mode 100644
index 000000000..c2e668ef1
--- /dev/null
+++ b/arm64_private_tail_contract_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64PrivateTailResultPointerSource = `TEXT ·ReadSlot(SB),516,$0-16
+MOVD p+0(FP),R0
+MOVD $ret+8(FP),R8
+B slotbody<>(SB)
+TEXT slotbody<>(SB),516,$0-0
+MOVD (R0),R11
+MOVD R11,(R8)
+RET
+`
+
+func TestARM64PrivateTailCannotBorrowCallerFrame(t *testing.T) {
+	for _, tail := range []string{"B", "JMP", "RET"} {
+		t.Run(tail, func(t *testing.T) {
+			arm64PrivateTailCannotBorrowCallerFrame(t, strings.Replace(arm64PrivateTailResultPointerSource, "B slotbody", tail+" slotbody", 1))
+		})
+	}
+}
+
+func arm64PrivateTailCannotBorrowCallerFrame(t *testing.T, source string) {
+	t.Helper()
+	requireARM64GoABIInternalObject(t, source)
+	pkg := mustGoPackage(t, "test/privatetail", "package privatetail\nfunc ReadSlot(p *uint64) uint64\n")
+	resolve := func(symbol string) string {
+		return strings.TrimPrefix(goStripABISuffix(symbol), "·")
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	entry := *file
+	entry.Funcs = file.Funcs[:1]
+	// Derive the real entry only. The absent private helper must not acquire
+	// another function's FP allocation or untransported R0/R8 input.
+	entry.Funcs = append([]Func(nil), entry.Funcs...)
+	entry.Funcs[0].Instrs = entry.Funcs[0].Instrs[:1]
+	sigs, err := goSigsForAsmFile(pkg, &entry, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot := fmt.Sprintf("%#v", file)
+	for _, borrowed := range []bool{false, true} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			name := api
+			if borrowed {
+				name += "/explicit_Frame_only"
+			}
+			t.Run(name, func(t *testing.T) {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				options := Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolve, Sigs: map[string]FuncSig{"ReadSlot": sigs["ReadSlot"]}}
+				callee := sigs["ReadSlot"]
+				callee.Name = "slotbody"
+				if borrowed {
+					options.Sigs["slotbody"] = callee
+				}
+				var err error
+				switch api {
+				case "text":
+					_, err = Translate(file, options)
+				case "module":
+					module, failure := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					err = failure
+				case "GoModule":
+					opt := GoModuleOptions{GOARCH: "arm64", TargetTriple: options.TargetTriple, ResolveSym: resolve}
+					if borrowed {
+						opt.ManualSig = func(name string) (FuncSig, bool) { return callee, name == "slotbody" }
+					}
+					result, failure := translateGoModuleInContext(ctx, pkg, []byte(source), opt)
+					if result != nil && !result.Module.IsNil() {
+						defer result.Module.Dispose()
+					}
+					err = failure
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("private tail borrowed an unproved FP result-address/register transport: %v", err)
+				}
+				if fmt.Sprintf("%#v", file) != snapshot {
+					t.Fatal("private-tail rejection mutated the original parsed file")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PrivateTailExplicitTransportValidation(t *testing.T) {
+	valid := FuncSig{Args: []LLVMType{I64, Ptr}, Ret: I64, ArgRegs: []Reg{"R0", "R8"}}
+	for _, test := range []struct {
+		name        string
+		symbol      string
+		sig         FuncSig
+		present     bool
+		wantContext bool
+	}{
+		{"explicit", "helper<>(SB)", valid, true, false},
+		{"external_unchanged", "external(SB)", FuncSig{}, false, false},
+		{"missing", "helper<>(SB)", valid, false, true},
+		{"no_registers", "helper<>(SB)", FuncSig{Args: valid.Args, Ret: I64}, true, true},
+		{"partial", "helper<>(SB)", FuncSig{Args: valid.Args, ArgRegs: []Reg{"R0"}}, true, true},
+		{"unknown_width", "helper<>(SB)", FuncSig{Args: []LLVMType{"[2 x i64]"}, ArgRegs: []Reg{"R0"}}, true, true},
+		{"unknown_bank", "helper<>(SB)", FuncSig{Args: []LLVMType{I64}, ArgRegs: []Reg{"R99"}}, true, true},
+		{"frame_bank", "helper<>(SB)", FuncSig{Args: []LLVMType{Ptr}, ArgRegs: []Reg{"FP"}}, true, true},
+		{"offset", "helper<>+4(SB)", valid, true, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			err := arm64ValidatePrivateTailTransport(test.symbol, test.sig, test.present)
+			if test.wantContext != errors.Is(err, ErrProbeNeedsContext) || !test.wantContext && err != nil {
+				t.Fatalf("private tail transport classification changed: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64PrivateTailExplicitTransportThreeAPIObjects(t *testing.T) {
+	const source = `TEXT ·Pass<ABIInternal>(SB),516,$0-16
+ADD $9,R0
+B customTail<>(SB)
+TEXT customTail<>(SB),516,$0-0
+ADD $7,R0
+RET
+`
+	requireARM64GoABIInternalObject(t, source)
+	pkg := mustGoPackage(t, "test/privatetail", "package privatetail\nfunc Pass(uint64) uint64\n")
+	resolve := func(symbol string) string {
+		return strings.TrimSuffix(strings.TrimPrefix(goStripABISuffix(symbol), "·"), "<>")
+	}
+	manual := func(name string) (FuncSig, bool) {
+		return FuncSig{Name: "customTail", Args: []LLVMType{I64}, Ret: I64, ArgRegs: []Reg{"R0"}}, name == "customTail"
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, manual)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-unknown-freebsd", "aarch64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "GoModule"} {
+			t.Run(target+"/"+api, func(t *testing.T) {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+				var ir string
+				var err error
+				switch api {
+				case "text":
+					ir, err = Translate(file, options)
+				case "module":
+					module, failure := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						defer module.Dispose()
+						ir = module.String()
+					}
+					err = failure
+				case "GoModule":
+					result, failure := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve, ManualSig: manual})
+					if result != nil && !result.Module.IsNil() {
+						defer result.Module.Dispose()
+						ir = result.Module.String()
+					}
+					err = failure
+				}
+				if err != nil {
+					t.Fatalf("existing explicit private register contract was rejected: %v", err)
+				}
+				compileLLVMToObject(t, llc, target, "private-tail.ll", "private-tail.o", ir)
+			})
+		}
+	}
+}
diff --git a/arm64_private_tail_helper.go b/arm64_private_tail_helper.go
new file mode 100644
index 000000000..9866dd446
--- /dev/null
+++ b/arm64_private_tail_helper.go
@@ -0,0 +1,471 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// A source continuation has no callable helper ABI. Its complete zero-frame
+// body shares only its actual ABIInternal root's typed machine state. Keep an
+// independent snapshot: copying a prepared Func and editing its source cannot
+// retain this admission. Neither JSON nor a manual FuncSig constructs it.
+type arm64PrivateTailSource struct {
+	original Func
+	helpers  []Func
+	prepared Func
+}
+
+func arm64PrivateTailSnapshot(fn Func) Func {
+	fn.arm64PrivateTailSource = nil
+	fn.arm64ABI0TailSource = nil
+	fn.arm64PrivateCallSource = nil
+	fn.Instrs = append([]Instr(nil), fn.Instrs...)
+	for i := range fn.Instrs {
+		if offset := fn.Instrs[i].arm64ScalarMemoryFrameOffset; offset != nil {
+			copyOffset := *offset
+			fn.Instrs[i].arm64ScalarMemoryFrameOffset = &copyOffset
+		}
+		fn.Instrs[i].Args = append([]Operand(nil), fn.Instrs[i].Args...)
+		for j := range fn.Instrs[i].Args {
+			a := &fn.Instrs[i].Args[j]
+			a.RegList = append([]Reg(nil), a.RegList...)
+		}
+	}
+	return fn
+}
+
+func validateARM64PrivateTailSource(fn Func, sig FuncSig) error {
+	if fn.arm64PrivateTailSource == nil {
+		return nil
+	}
+	if !reflect.DeepEqual(arm64PrivateTailSnapshot(fn), fn.arm64PrivateTailSource.prepared) ||
+		!strings.HasSuffix(fn.Sym, "<ABIInternal>") || sig.ARM64GoRegisterABI == nil ||
+		fn.FrameSize != 0 || arm64SourceGoFrame(fn).present {
+		return arm64GoABIContext("private tail root lost its complete zero-frame source/register identity")
+	}
+	if err := arm64PrivateTailZeroFrame(fn.arm64PrivateTailSource.original, true); err != nil {
+		return err
+	}
+	for _, helper := range fn.arm64PrivateTailSource.helpers {
+		if err := arm64PrivateTailBody(helper); err != nil {
+			return err
+		}
+	}
+	return arm64ValidateGoRegisterABI(sig)
+}
+
+// A continuation does not give ordinary pointer inputs a noalias promise
+// against an immutable closure carrier. Keep the original root's complete
+// carrier gate unchanged; only sealed helper loads may join its prepared CFG.
+// Registered data-base pre/post updates change registers, never carrier memory.
+func validateARM64PrivateTailClosureSource(fn Func, sig FuncSig) error {
+	if err := validateARM64PrivateTailSource(fn, sig); err != nil {
+		return err
+	}
+	proof := fn.arm64PrivateTailSource
+	if err := validateARM64ClosureSource(proof.original, sig); err != nil {
+		return err
+	}
+	for _, helper := range proof.helpers {
+		for _, ins := range helper.Instrs[1:] {
+			memory := false
+			for _, arg := range ins.Args {
+				memory = memory || arg.Kind == OpMem
+			}
+			if !memory {
+				continue // Complete typed purity was independently rechecked above.
+			}
+			if form, valid := arm64RawPrivateMemory(ins); valid &&
+				form.memory.Kind == OpMem && !form.store && form.scratch == nil {
+				continue
+			}
+			if form, handled, err := parseARM64StructureMemory(ins); handled && err == nil &&
+				form.memory.Kind == OpMem && form.load {
+				continue
+			}
+			return arm64GoABIContext("%q private closure continuation has an unproved carrier-alias memory effect", sig.Name)
+		}
+	}
+	return nil
+}
+
+func arm64PrivateTailTarget(ins Instr) (string, bool) {
+	if ins.Op != "B" && ins.Op != "JMP" && ins.Op != OpRET || len(ins.Args) != 1 ||
+		ins.Args[0].Kind != OpSym || !strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
+		return "", false
+	}
+	base, off, ok := arm64PrivateSymbolRef(ins.Args[0].Sym)
+	return base, ok && off == 0 && arm64PrivateTailSymbol(ins.Args[0].Sym)
+}
+
+func arm64PrivateTailZeroFrame(fn Func, root bool) error {
+	if fn.arm64PrivateRegisterEntry || fn.arm64PrivateTailSource != nil ||
+		fn.FrameSize != 0 || arm64SourceGoFrame(fn).present || !arm64SourceFrameFlagsKnown(fn) ||
+		len(fn.Instrs) < 2 || fn.Instrs[0].Op != OpTEXT {
+		return arm64GoABIContext("private tail %q needs a complete zero physical frame", fn.Sym)
+	}
+	_, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) < 2 || len(parts) > 3 {
+		return arm64GoABIContext("private tail %q has incomplete TEXT", fn.Sym)
+	}
+	name, off, ok := parseSBRef(strings.TrimSpace(parts[0]))
+	frame, args, err := parseTEXTFrame(parts)
+	if !ok || off != 0 || name != fn.Sym || err != nil || frame != fn.FrameSize || args != fn.ArgSize ||
+		!root && args != 0 {
+		return arm64GoABIContext("private tail %q changed its original TEXT identity", fn.Sym)
+	}
+	// An omitted helper args suffix is intentionally retained as unknown. It
+	// describes a continuation, not an inferred zero-argument function ABI.
+	if root && (!strings.HasSuffix(fn.Sym, "<ABIInternal>") ||
+		strings.LastIndex(strings.TrimSpace(parts[len(parts)-1]), "-") <= 1) {
+		return arm64GoABIContext("private tail root %q needs explicit source ABIInternal/args", fn.Sym)
+	}
+	for _, ins := range fn.Instrs[1:] {
+		if ins.Op == OpTEXT || ins.Op == "CALL" || ins.Op == "BL" || ins.Op == "BLR" {
+			return arm64GoABIContext("private tail %q is not a zero-frame call-free source", fn.Sym)
+		}
+	}
+	return nil
+}
+
+func arm64PrivateTailDataRegister(reg Reg) bool {
+	if arm64PrivateDataGP(reg) {
+		return reg != "R26" // A private body has no hidden closure producer.
+	}
+	if _, ok := arm64ParseFReg(reg); ok {
+		return true
+	}
+	_, ok := arm64ParseVReg(reg)
+	return ok
+}
+
+// Purity does not prove an input initialized or a pointer safe. Actual typed
+// lowering, register must-def, local-code and memory/return proofs still run on
+// the entire resulting root CFG. Reject source expansions that independently
+// materialize Go R27 even when it is absent from the written operands.
+func arm64PrivateTailBody(fn Func) error {
+	if err := arm64PrivateTailZeroFrame(fn, false); err != nil {
+		return err
+	}
+	return arm64PrivateContinuationBody(fn, arm64PrivateTailDataRegister, nil, true)
+}
+
+// Operand purity is shared by CALL and tail continuations, but their entry and
+// return contracts remain separate. This grammar grants neither initialized
+// inputs nor pointer bounds: the complete root's independent proofs own those.
+func arm64PrivateContinuationBody(fn Func, dataRegister func(Reg) bool, scratchContract func(Op, Instr, arm64GPDataForm) bool, allowAlignment bool) error {
+	labels := map[string]bool{}
+	for _, ins := range fn.Instrs[1:] {
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel || ins.Args[0].Sym == "" || labels[ins.Args[0].Sym] {
+				return arm64GoABIContext("private tail %q has duplicate/incomplete labels", fn.Sym)
+			}
+			labels[ins.Args[0].Sym] = true
+		}
+	}
+	returns := 0
+	for _, ins := range fn.Instrs[1:] {
+		if _, alignment, err := arm64PCAlignment(ins); alignment {
+			if err != nil || !allowAlignment {
+				return arm64GoABIContext("private continuation %q has unproved alignment at %q", fn.Sym, ins.Raw)
+			}
+			continue
+		}
+		if ins.Op == OpTEXT || ins.Op == "CALL" || ins.Op == "BL" || ins.Op == "BLR" {
+			return arm64GoABIContext("private continuation %q is not a call-free complete source at %q", fn.Sym, ins.Raw)
+		}
+		if ins.Op == OpLABEL {
+			continue
+		}
+		if ins.Op == OpRET {
+			if len(ins.Args) != 0 {
+				return arm64GoABIContext("private tail %q has a non-caller return", fn.Sym)
+			}
+			returns++
+			continue
+		}
+		branch := ins.Op == "B" || ins.Op == "JMP" || arm64IsConditionalBranch(ins.Op)
+		if branch {
+			if len(ins.Args) == 0 || ins.Args[len(ins.Args)-1].Kind != OpIdent || !labels[ins.Args[len(ins.Args)-1].Ident] {
+				return arm64GoABIContext("private tail %q has unresolved/escaping control at %q", fn.Sym, ins.Raw)
+			}
+		}
+		op := arm64ControlOp(ins)
+		if f, handled, err := parseARM64GPDataForm(op, ins); handled {
+			if err != nil || (f.scratch != nil || len(f.implicit) != 0) &&
+				(scratchContract == nil || !scratchContract(op, ins, f)) {
+				return arm64GoABIContext("private continuation %q has unproved source scratch at %q", fn.Sym, ins.Raw)
+			}
+		}
+		if f, handled, err := parseARM64ScalarMemoryForm(op, ins); handled && (err != nil || f.scratch) {
+			return arm64GoABIContext("private tail %q has unproved memory scratch at %q", fn.Sym, ins.Raw)
+		}
+		pairBytes := arm64RawPrivatePairBytes(op)
+		scalarBytes := arm64RawPrivateScalarBytes(op)
+		_, structure, structureErr := parseARM64StructureMemory(ins)
+		data := branch
+		for i, arg := range ins.Args {
+			if branch && i == len(ins.Args)-1 {
+				continue
+			}
+			switch arg.Kind {
+			case OpImm:
+				if arg.ImmRaw != "" || arg.ImmIsFloat {
+					return arm64GoABIContext("private tail %q has an unresolved/pool operand", fn.Sym)
+				}
+			case OpReg, OpRegShift, OpRegExtend:
+				if !dataRegister(arg.Reg) || arg.ShiftReg != "" && !dataRegister(arg.ShiftReg) {
+					return arm64GoABIContext("private tail %q touches hidden/stack/scratch state at %q", fn.Sym, ins.Raw)
+				}
+				data = true
+			case OpRegList:
+				for _, reg := range arg.RegList {
+					if !dataRegister(reg) {
+						return arm64GoABIContext("private tail %q has an unproved register list", fn.Sym)
+					}
+				}
+				data = true
+			case OpMem:
+				m := arg.Mem
+				if m.Sym != "" || m.Segment != "" || m.OffRaw != "" || !arm64PrivateDataGP(m.Base) || m.Base == ZR || !dataRegister(m.Base) ||
+					m.Index != "" && (!arm64PrivateDataGP(m.Index) || !dataRegister(m.Index)) ||
+					pairBytes != 0 && (m.Index != "" || m.Off%pairBytes != 0 || m.Off < -64*pairBytes || m.Off > 63*pairBytes) {
+					return arm64GoABIContext("private tail %q has non-data or materialized memory at %q", fn.Sym, ins.Raw)
+				}
+				if structureErr != nil || !structure && scalarBytes == 0 && pairBytes == 0 ||
+					scalarBytes != 0 && (m.Index != "" && m.Off != 0 || m.Index == "" &&
+						!(m.Off >= -256 && m.Off <= 255 || m.Off >= 0 && m.Off%scalarBytes == 0 && m.Off/scalarBytes <= 4095)) {
+					return arm64GoABIContext("private tail %q lacks a no-scratch typed memory row at %q", fn.Sym, ins.Raw)
+				}
+				data = true
+			case OpIdent:
+				if !armCondCodes[arg.Ident] {
+					return arm64GoABIContext("private tail %q observes a non-data identity at %q", fn.Sym, ins.Raw)
+				}
+			default:
+				return arm64GoABIContext("private tail %q has external/frame operands at %q", fn.Sym, ins.Raw)
+			}
+		}
+		if !data {
+			return arm64GoABIContext("private tail %q has unproved effects at %q", fn.Sym, ins.Raw)
+		}
+	}
+	last := fn.Instrs[len(fn.Instrs)-1]
+	if returns == 0 || last.Op != OpRET && last.Op != "B" && last.Op != "JMP" {
+		return arm64GoABIContext("private tail %q falls outside its complete CFG", fn.Sym)
+	}
+	return nil
+}
+
+func coalesceARM64PrivateTailHelpers(file *File, remaining *int) (*File, error) {
+	return coalesceARM64PrivateTailHelpersWithABI0(file, remaining, nil, nil)
+}
+
+func coalesceARM64PrivateTailHelpersWithABI0(file *File, remaining *int, sigs map[string]FuncSig, resolve func(string) string) (*File, error) {
+	if file.Arch != ArchARM64 {
+		return file, nil
+	}
+	requested := map[string]bool{}
+	for _, fn := range file.Funcs {
+		declaredABI0 := resolve != nil && sigs[resolve(goTextSymbolForResolution(fn.Sym))].arm64ABI0TailDeclaration != nil
+		if !strings.HasSuffix(fn.Sym, "<ABIInternal>") && !declaredABI0 {
+			continue // Preserve existing explicit ABI0/private callable contracts.
+		}
+		for _, ins := range fn.Instrs {
+			if name, ok := arm64PrivateTailTarget(ins); ok {
+				requested[name] = true
+			}
+		}
+	}
+	helpers := map[string]Func{}
+	for _, fn := range file.Funcs {
+		if !requested[fn.Sym] {
+			continue
+		}
+		fp := false
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				fp = fp || arg.Kind == OpFP || arg.Kind == OpFPAddr
+			}
+		}
+		if fp || fn.ArgSize != 0 {
+			continue // Existing explicit FP/callee contracts are not continuations.
+		}
+		if _, duplicate := helpers[fn.Sym]; duplicate {
+			return nil, arm64GoABIContext("duplicate private tail TEXT %q", fn.Sym)
+		}
+		if err := arm64PrivateTailBody(fn); err != nil {
+			return nil, err
+		}
+		helpers[fn.Sym] = fn
+	}
+	if len(helpers) == 0 {
+		return file, nil
+	}
+	// Native PC/address observers anywhere in the original file prevent
+	// removing standalone helper TEXT identities, even if KeepFunc excludes it.
+	uses := map[string]int{}
+	for _, data := range file.Data {
+		for _, sym := range []string{data.Sym, data.Addr} {
+			if base, _, _ := arm64PrivateSymbolRef(sym); requested[base] {
+				return nil, arm64GoABIContext("private tail escapes through DATA")
+			}
+		}
+	}
+	for _, global := range file.Globl {
+		if base, _, _ := arm64PrivateSymbolRef(global.Sym); requested[base] {
+			return nil, arm64GoABIContext("private tail escapes through GLOBL")
+		}
+	}
+	if len(file.UnlinkedPrelude) != 0 {
+		return nil, arm64GoABIContext("private tail file has an unbound native prelude")
+	}
+	for _, fn := range file.Funcs {
+		if len(fn.Instrs) == 0 {
+			return nil, arm64GoABIContext("private tail file has an incomplete TEXT body")
+		}
+		for _, ins := range fn.Instrs[1:] {
+			if _, _, err := arm64PCAlignment(ins); err != nil {
+				return nil, err
+			}
+			switch ins.Op {
+			case OpWORD, "DWORD", "ADR", "ADRP":
+				return nil, arm64GoABIContext("private tail file observes native layout at %q", ins.Raw)
+			}
+			for _, arg := range ins.Args {
+				mem, memory := arg.Mem, arg.Kind == OpMem
+				if arg.Kind == OpSym && strings.HasPrefix(arg.Sym, "$") {
+					mem, memory = parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$")))
+				}
+				if memory && mem.Base == PC {
+					return nil, arm64GoABIContext("private tail file observes native PC")
+				}
+				if memory && mem.Sym != "" {
+					if base, _, _ := arm64PrivateSymbolRef(mem.Sym); requested[base] {
+						return nil, arm64GoABIContext("private tail has a native memory/address use")
+					}
+				}
+				if arg.Kind != OpSym {
+					continue
+				}
+				base, _, _ := arm64PrivateSymbolRef(arg.Sym)
+				if _, helper := helpers[base]; !helper {
+					continue
+				}
+				if target, ok := arm64PrivateTailTarget(ins); !ok || target != base {
+					return nil, arm64GoABIContext("private tail %q has another address/native use", base)
+				}
+				var err error
+				if strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+					err = arm64PrivateTailZeroFrame(fn, true)
+				} else if resolve != nil {
+					err = arm64ABI0TailRoot(fn, sigs[resolve(goTextSymbolForResolution(fn.Sym))])
+				} else {
+					err = arm64GoABIContext("private tail has no root source contract")
+				}
+				if err != nil {
+					return nil, err
+				}
+				uses[base]++
+			}
+		}
+	}
+	for name, helper := range helpers {
+		if uses[name] == 0 || uses[name] > *remaining/len(helper.Instrs) {
+			return nil, arm64GoABIContext("private tail source exceeds the shared expansion budget")
+		}
+		*remaining -= uses[name] * len(helper.Instrs)
+	}
+	result := *file
+	result.Funcs = make([]Func, 0, len(file.Funcs)-len(helpers))
+	for _, fn := range file.Funcs {
+		if _, helper := helpers[fn.Sym]; helper {
+			continue
+		}
+		copyFn := fn
+		var added []Instr
+		originalHelpers := map[string]bool{}
+		var helperSources []Func
+		occupied := map[string]bool{"entry": true, "ret": true}
+		for _, block := range arm64SplitBlocks(fn) {
+			occupied[arm64LLVMBlockName(block.name)] = true
+		}
+		for i, ins := range fn.Instrs {
+			name, tail := arm64PrivateTailTarget(ins)
+			helper, present := helpers[name]
+			if !tail || !present {
+				continue
+			}
+			if !originalHelpers[name] {
+				originalHelpers[name] = true
+				helperSources = append(helperSources, arm64PrivateTailSnapshot(helper))
+			}
+			if len(added) == 0 {
+				copyFn.Instrs = append([]Instr(nil), fn.Instrs...)
+			}
+			fresh := func() string {
+				label := fmt.Sprintf("__arm64_tail_%d", len(occupied))
+				for occupied[arm64LLVMBlockName(label)] {
+					label += "_"
+				}
+				occupied[arm64LLVMBlockName(label)] = true
+				return label
+			}
+			entry, labels := fresh(), map[string]string{}
+			for _, original := range helper.Instrs[1:] {
+				if original.Op == OpLABEL {
+					labels[original.Args[0].Sym] = fresh()
+				}
+			}
+			copyFn.Instrs[i].Op = "B"
+			copyFn.Instrs[i].Args = []Operand{{Kind: OpIdent, Ident: entry}}
+			added = append(added, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: entry}}})
+			for _, original := range helper.Instrs[1:] {
+				cloned := original
+				if original.Op == OpLABEL {
+					cloned.Args = []Operand{{Kind: OpLabel, Sym: labels[original.Args[0].Sym]}}
+				} else if original.Op == "B" || original.Op == "JMP" || arm64IsConditionalBranch(original.Op) {
+					cloned.Args = append([]Operand(nil), original.Args...)
+					last := len(cloned.Args) - 1
+					cloned.Args[last] = Operand{Kind: OpIdent, Ident: labels[original.Args[last].Ident]}
+				}
+				added = append(added, cloned)
+			}
+		}
+		if len(added) != 0 {
+			last := fn.Instrs[len(fn.Instrs)-1].Op
+			if last != OpRET && last != "B" && last != "JMP" {
+				return nil, arm64GoABIContext("private tail root %q has a source fallthrough", fn.Sym)
+			}
+			copyFn.Instrs = append(copyFn.Instrs, added...)
+			copyFn.arm64PrivateSourceAdded += len(added)
+			if strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+				copyFn.arm64PrivateTailSource = &arm64PrivateTailSource{
+					original: arm64PrivateTailSnapshot(fn), helpers: helperSources,
+					prepared: arm64PrivateTailSnapshot(copyFn),
+				}
+			} else {
+				sig := sigs[resolve(goTextSymbolForResolution(fn.Sym))]
+				// Bind the actual FP normalization before sealing the prepared
+				// source. Final consumers may not drop its physical-offset marker
+				// or accept arbitrary changes as a normalization projection.
+				var err error
+				copyFn, err = normalizeARM64ScalarMemoryFrame(copyFn)
+				if err != nil {
+					return nil, err
+				}
+				copyFn.arm64ABI0TailSource = &arm64ABI0TailSource{
+					declaration: sig.arm64ABI0TailDeclaration, original: arm64PrivateTailSnapshot(fn),
+					helpers: helperSources, prepared: arm64PrivateTailSnapshot(copyFn),
+				}
+				if err := validateARM64ABI0TailSource(copyFn, sig); err != nil {
+					return nil, err
+				}
+			}
+		}
+		result.Funcs = append(result.Funcs, copyFn)
+	}
+	return &result, nil
+}
diff --git a/arm64_privileged_probe_test.go b/arm64_privileged_probe_test.go
new file mode 100644
index 000000000..7007f8d97
--- /dev/null
+++ b/arm64_privileged_probe_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestProbeARM64PrivilegedOfficialFormsRequireExecutionContext(t *testing.T) {
+	for _, instruction := range []string{
+		"TLBI VMALLE1IS",
+		"TLBI VAE1IS, R0",
+		"TLBI VAE3IS, ZR",
+		"SYS $32768",
+		"SYS $32768, R1",
+		"SYSL $285440, R12",
+		"DCPS1 $11378",
+		"DCPS2 $10699",
+		"DCPS3 $24415",
+		"DRPS",
+		"ERET",
+		"HLT $65509",
+		"HLT",
+		"HVC $61428",
+		"HVC",
+		"SMC $37977",
+		"SMC",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT privileged(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			probeErr := ProbeInstruction(ArchARM64, "arm64", file.Funcs[0].Instrs[1])
+			if !errors.Is(probeErr, ErrProbeNeedsContext) {
+				t.Fatalf("ProbeInstruction(%q) error = %v, want ErrProbeNeedsContext", instruction, probeErr)
+			}
+			_, translateErr := Translate(file, Options{
+				TargetTriple: arm64LinuxGNUTriple,
+				Goarch:       "arm64",
+				Sigs:         map[string]FuncSig{"privileged": {Name: "privileged", Ret: Void}},
+			})
+			op := strings.Fields(instruction)[0]
+			supported := op == "SYS" || op == "SYSL" || op == "TLBI" || op == "HLT" || op == "HVC" || op == "SMC" ||
+				op == "DRPS" || op == "ERET" || strings.HasPrefix(op, "DCPS")
+			if supported && translateErr != nil {
+				t.Fatalf("targeted translation of supported privileged instruction %q failed: %v", instruction, translateErr)
+			}
+			if !supported && translateErr == nil {
+				t.Fatalf("unsupported privileged instruction %q unexpectedly translated", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_probe_context_test.go b/arm64_probe_context_test.go
new file mode 100644
index 000000000..c2e247b12
--- /dev/null
+++ b/arm64_probe_context_test.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestProbeARM64PCRelativeAddressRequiresFunctionContext(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT probe(SB),$0-0\n\tADR target, R1\ntarget:\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ProbeInstruction(ArchARM64, "arm64", file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("ProbeInstruction(ADR) error = %v, want ErrProbeNeedsContext", err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: arm64LinuxGNUTriple,
+		Goarch:       "arm64",
+		Sigs:         map[string]FuncSig{"probe": {Name: "probe", Ret: Void}},
+	}); err != nil {
+		t.Fatalf("full-function ADR translation failed: %v", err)
+	}
+}
diff --git a/arm64_probe_frame_fixture_test.go b/arm64_probe_frame_fixture_test.go
new file mode 100644
index 000000000..46e7be00d
--- /dev/null
+++ b/arm64_probe_frame_fixture_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func requireARM64ProbeGoObject(t *testing.T, source string) {
+	t.Helper()
+	// These primitive fixture forms are an actual object oracle in both
+	// supported Go versions, not a version-specific optab inventory skip.
+	if len(arm64ImmediateOriginalGoBytes(t, source, "linux")) == 0 {
+		t.Fatal("actual Go probe fixture object contains no instruction bytes")
+	}
+}
+
+func TestARM64ScalarAUTOProbeRetainsConcreteForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, address := range []string{"slot(SP)", "slot+4(SP)", "slot+255(SP)", "slot+256(SP)"} {
+			for _, store := range []bool{false, true} {
+				instruction := fmt.Sprintf("%s %s,R21", op, address)
+				if store {
+					instruction = fmt.Sprintf("%s R21,%s", op, address)
+				}
+				t.Run(instruction, func(t *testing.T) {
+					// This is our own compile-only source, not the frame of any
+					// function from which an isolated instruction was extracted.
+					source := arm64InstructionProbeTEXT + instruction + "\nB (ZR)\n"
+					requireARM64ProbeGoObject(t, source)
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					before := ins
+					before.Args = append([]Operand(nil), ins.Args...)
+					if err := ProbeInstruction(ArchARM64, "arm64", ins); err != nil {
+						t.Errorf("explicit compile-only AUTO fixture rejected: %v", err)
+					}
+					if err := ProbeInstructionSequence(ArchARM64, "arm64", []Instr{ins}); err != nil {
+						t.Errorf("sequence AUTO fixture rejected: %v", err)
+					}
+					if !reflect.DeepEqual(ins, before) || ins.arm64Encoded {
+						t.Fatal("probe mutated operands or invented physical encoding identity")
+					}
+					fn, err := arm64InstructionProbeFunc([]Instr{ins})
+					if err != nil {
+						t.Fatal(err)
+					}
+					if fn.FrameSize != 0 || fn.ArgSize != 0 || !arm64SourceFrameFlagsKnown(fn) ||
+						arm64SourceGoFrame(fn).present || fn.Instrs[0].Raw+"\n" != arm64InstructionProbeTEXT {
+						t.Fatal("isolated fixture borrowed a frame instead of its exact zero/NOFRAME source")
+					}
+					fn.Instrs = append(fn.Instrs, file.Funcs[0].Instrs[2])
+					for _, triple := range arm64TypedNativeTargets {
+						ir, err := Translate(&File{Arch: ArchARM64, Funcs: []Func{fn}}, Options{
+							Goarch: "arm64", TargetTriple: triple,
+							Sigs: map[string]FuncSig{fn.Sym: {Name: fn.Sym, Ret: Void}},
+						})
+						if err != nil {
+							t.Fatalf("%s concrete fixture: %v", triple, err)
+						}
+						if !strings.Contains(ir, `asm sideeffect "br $0", "r,~{memory}"(i64 0)`+"\n  unreachable") {
+							t.Fatal("compile-only fixture replaced its actual faulting exit with a return claim")
+						}
+						compileLLVMToObject(t, llc, triple, "probe.ll", "probe.o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ScalarAUTOProbeDoesNotAuthorizeForeignFrames(t *testing.T) {
+	for _, header := range []string{
+		"TEXT foreign(SB),4,$32-0",
+		"TEXT foreign(SB),UNKNOWN_FLAGS,$32-0",
+		"TEXT foreign(SB),516,$0-0",
+		"TEXT foreign(SB),4,$2147483640-0",
+	} {
+		t.Run(header, func(t *testing.T) {
+			file, err := Parse(ArchARM64, header+"\nMOVD slot(SP),R21\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := ProbeInstructionSequence(ArchARM64, "arm64", file.Funcs[0].Instrs); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("foreign TEXT replaced the isolated fixture: %v", err)
+			}
+		})
+	}
+	for _, op := range arm64MemoryScratchAuditMoves {
+		ins := arm64ImmediateTestInstruction(t, op+" slot(SP),R21")
+		for _, size := range []int64{0, 32, 1 << 30} {
+			file := &File{Arch: ArchARM64, Funcs: []Func{{Sym: "foreign", FrameSize: size, Instrs: []Instr{ins, {Op: OpRET, Raw: "RET"}}}}}
+			_, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"foreign": {Name: "foreign", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s frame size %d alone acquired source identity: %v", op, size, err)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarAUTOProbeRetainsContextAndInvalidOperands(t *testing.T) {
+	for _, op := range arm64MemoryScratchAuditMoves {
+		bits, _ := arm64ScalarMemoryBits(Op(op))
+		if bits == 0 {
+			t.Fatalf("missing scalar memory width for %s", op)
+		}
+		// This first out-of-range scaled displacement is accepted by Go,
+		// but old and current encoders leave different values in R27.
+		// The isolated fixture must not invent which native scratch it has.
+		scratchContext := fmt.Sprintf("%s slot+%d(SP),R21", op, 4096*bits/8)
+		requireARM64ProbeGoObject(t, arm64InstructionProbeTEXT+scratchContext+"\nB (ZR)\n")
+		for _, test := range []struct {
+			text    string
+			context bool
+		}{
+			{op + " UNKNOWN(RSP),R21", true},
+			{scratchContext, true},
+			{op + " slot+9223372036854775807(SP),R21", false},
+			{op + " input+0(FP),R21", true},
+			{op + " R21,output+0(FP)", true},
+		} {
+			t.Run(test.text, func(t *testing.T) {
+				ins := arm64ImmediateTestInstruction(t, test.text)
+				if err := ProbeInstruction(ArchARM64, "arm64", ins); err == nil || test.context && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unbound/overflowing isolated frame did not retain its rejection: %v", err)
+				}
+				if err := ProbeInstructionSequence(ArchARM64, "arm64", []Instr{ins}); err == nil {
+					t.Fatal("sequence fixture fabricated unresolved frame storage")
+				}
+			})
+		}
+		for _, text := range []string{
+			op + ".P slot(SP),R21",
+			op + " R21,slot(SP)(R2)",
+		} {
+			t.Run(text, func(t *testing.T) {
+				ins := arm64ImmediateTestInstruction(t, text)
+				if err := ProbeInstructionSequence(ArchARM64, "arm64", []Instr{ins}); err == nil {
+					t.Fatal("probe erased a Go-invalid AUTO writeback/indexed role")
+				}
+			})
+		}
+	}
+	for _, body := range []string{
+		"MOVD $0(RSP),R0\nBL (R0)\n",
+		"ADD R2,RSP,RSP\nMOVD slot(SP),R21\n",
+	} {
+		file, err := Parse(ArchARM64, "TEXT foreign(SB),516,$0-0\n"+body+"B (ZR)\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := ProbeInstructionSequence(ArchARM64, "arm64", file.Funcs[0].Instrs[1:len(file.Funcs[0].Instrs)-1]); err == nil {
+			t.Fatalf("probe acquired a native-call or unbounded SP contract:\n%s", body)
+		}
+	}
+	// A frame-address escape still cannot retain a saved caller link, even
+	// though the separate compile-only data fixture has a real TEXT header.
+	source := "TEXT escaped(SB),4,$32-0\nCALL sink(SB)\nMOVD $0(RSP),R0\nMOVD R0,(R1)\nMOVD R21,slot(SP)\nRET\nTEXT sink(SB),4,$0-0\nRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"escaped": {Name: "escaped", Ret: Void}, "sink": {Name: "sink", Ret: Void},
+	}})
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "caller") {
+		t.Fatalf("normal translation lost its escaping caller-frame guard: %v", err)
+	}
+}
diff --git a/arm64_probe_memory.go b/arm64_probe_memory.go
new file mode 100644
index 000000000..73ef98388
--- /dev/null
+++ b/arm64_probe_memory.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+// Pseudo-SP names annotate a frame slot; names relative to hardware RSP or a
+// GP register instead need the generated header's displacement definition.
+func arm64NamedStackOffset(memory MemRef) bool {
+	if memory.Base != SP || memory.OffRaw == "" {
+		return false
+	}
+	if offset, ok := parseNamedStackConstantOffset(memory.OffRaw); ok {
+		return offset == memory.Off
+	}
+	return validPPIdentifier(memory.OffRaw) && memory.Off == 0
+}
+
+func arm64MemoryOffsetNeedsContext(memory MemRef) bool {
+	if memory.OffRaw == "" || arm64NamedStackOffset(memory) {
+		return false
+	}
+	if _, scalable := parseVectorLengthScaleExpr(memory.OffRaw); scalable {
+		return false // VL is a typed address unit, not an include macro.
+	}
+	return memoryOffsetExpressionNeedsContext(memory.OffRaw)
+}
diff --git a/arm64_probe_memory_test.go b/arm64_probe_memory_test.go
new file mode 100644
index 000000000..d41220828
--- /dev/null
+++ b/arm64_probe_memory_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestARM64MemoryOffsetProbeNeedsMacroContext(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, base := range []string{"RSP", "R1"} {
+		for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+			for _, store := range []bool{false, true} {
+				instruction := fmt.Sprintf("%s machTimebaseInfo_denom(%s),R21", op, base)
+				if store {
+					instruction = fmt.Sprintf("%s R21,machTimebaseInfo_denom(%s)", op, base)
+				}
+				t.Run(instruction, func(t *testing.T) {
+					source := "TEXT macroprobe(SB),$16-0\n" + instruction + "\nRET\n"
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := ProbeInstruction(ArchARM64, "arm64", file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unexpanded offset probe error=%v, want macro context", err)
+					}
+					options := Options{Goarch: "arm64", Sigs: map[string]FuncSig{"macroprobe": {Name: "macroprobe", Ret: Void}}}
+					if _, err := Translate(file, options); err == nil {
+						t.Fatal("translation silently accepted an unresolved memory offset")
+					}
+					resolved := "#define machTimebaseInfo_denom 4\n" + source
+					requireARM64GoAssemblerResult(t, resolved, true)
+					file, err = Parse(ArchARM64, resolved)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+						options.TargetTriple = triple
+						ir, err := Translate(file, options)
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, triple, "macro.ll", "macro.o", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64MemoryOffsetProbeRetainsConcreteValidation(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		valid       bool
+	}{
+		{"MOVW 4(RSP),R21", true},
+		{"MOVW slot+4(SP),R21", true},
+		{"MOVW slot(SP),R21", true},
+		{"PLDR (VL*1)(RSP),P0", true},
+		{"MOVW (OFFSET+)(RSP),R21", false},
+		{"MOVW R2<<R3(R1),R21", false},
+		{"MOVW VL*1(R1),R21", false},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			source := "TEXT probe(SB),$16-0\n" + test.instruction + "\nRET\n"
+			if test.valid {
+				requireARM64SVEGoAssemblerResult(t, source, true)
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = ProbeInstruction(ArchARM64, "arm64", file.Funcs[0].Instrs[1])
+			if errors.Is(err, ErrProbeNeedsContext) || (err == nil) != test.valid {
+				t.Fatalf("probe error=%v, want concrete valid=%v", err, test.valid)
+			}
+		})
+	}
+}
diff --git a/arm64_r20_consumer_boundary_test.go b/arm64_r20_consumer_boundary_test.go
new file mode 100644
index 000000000..c443a66fc
--- /dev/null
+++ b/arm64_r20_consumer_boundary_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// The source-frame route and the typed read-before-write route have different
+// obligations. In particular, a format-only signature is not a numerical entry
+// contract, and an incomplete large TEXT cannot supply an incoming R20 value.
+func TestARM64R20ConsumerSeparatesProducerAndTypedSoftwareValues(t *testing.T) {
+	word := FuncSig{
+		Name: "value", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		},
+	}
+	for _, tc := range []struct {
+		name, text, body            string
+		sig                         FuncSig
+		producer, required, checked bool
+	}{
+		{"large", "$496-16", "MOVD arg+0(FP),R20", word, true, true, true},
+		{"small", "$224-16", "MOVD arg+0(FP),R20", word, false, false, true},
+		{"zero", "$0-16", "MOVD arg+0(FP),R20", word, false, false, true},
+		{"omitted_args", "$496", "MOVD 32(R20),R0", word, false, true, true},
+		{"dynamic_large", "$2097152-16", "MOVD arg+0(FP),R20", word, false, false, true},
+		{"nonleaf_software", "$496-16", "CALL callee(SB)\nMOVD arg+0(FP),R20", word, false, false, true},
+		{"format_only", "$0-0", "MOVD R30,R20", FuncSig{Name: "value", Ret: Void}, false, false, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, fmt.Sprintf("TEXT value(SB),4,%s\n%s\nRET\n", tc.text, tc.body))
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			if got := arm64SourceFrameR20(fn); got != tc.producer {
+				t.Errorf("producer=%v, want %v", got, tc.producer)
+			}
+			if got := arm64SourceFrameR20Required(fn); got != tc.required {
+				t.Errorf("frame-proof route=%v, want %v", got, tc.required)
+			}
+			if got := arm64SourceFrameR20Checked(fn, tc.sig, nil); got != tc.checked {
+				t.Errorf("typed availability=%v, want %v", got, tc.checked)
+			}
+		})
+	}
+}
+
+func TestARM64R20ConsumerTypedDynamicFrameDoesNotInventUnknownScratch(t *testing.T) {
+	pkg := mustGoPackage(t, "largeframe", "package largeframe\nfunc Value(uint64) uint64\n")
+	for _, frame := range []int{0, 8, 224, 496, 2 << 20} {
+		for _, body := range []string{
+			"MOVD R12,R20\nMOVD R20,ret+8(FP)",
+			"MOVD R20,ret+8(FP)",
+		} {
+			t.Run(fmt.Sprintf("%d/%s", frame, body), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$%d-16\n%s\nRET\n", frame, body)
+				requireARM64GoAssemblerResult(t, source, true)
+				arm64LargeFrameCheckAPIs(t, source, pkg, nil, true, false)
+			})
+		}
+	}
+}
diff --git a/arm64_raw_context_control.go b/arm64_raw_context_control.go
new file mode 100644
index 000000000..286348630
--- /dev/null
+++ b/arm64_raw_context_control.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import "reflect"
+
+// The coarse general CFG intentionally merges helper inputs. For a checked
+// raw zero-frame source, that can mix incoming pointers with disjoint private
+// scratch. Reuse the independent call-context interpreter instead of granting
+// alias permission to its mixed store. Nothing is published from a failed or
+// partial proof, and ordinary/raw-native functions retain the coarse path.
+func (c *arm64Ctx) rawZeroContextControlPlan(outer string) *arm64LocalControlPlan {
+	if !c.unexposedCallFrame || c.sourceGoFrame.present ||
+		!arm64CallFrameFreshEntry(c.sig) || c.sig.ARM64ClosureABI != nil {
+		return nil
+	}
+	if c.sig.ARM64GoRegisterABI != nil && arm64ValidateGoRegisterABI(c.sig) != nil {
+		return nil
+	}
+	if !reflect.DeepEqual(c.blocks, arm64SplitBlocks(c.normalizedSource)) {
+		return nil
+	}
+	plan := &arm64LocalControlPlan{
+		before:      make(map[[2]int]arm64ControlValue),
+		stackBefore: make(map[[2]int]arm64ControlValue),
+		linkBefore:  make(map[[2]int]arm64ControlValue),
+		reachable:   make([]bool, len(c.blocks)),
+		outer:       outer,
+	}
+	transport := &arm64PrivateFrameTransport{entry: c.sig, resolve: c.resolve, sigs: c.sigs}
+	if !arm64RawZeroFrameProof(c.normalizedSource, transport, plan) {
+		return nil
+	}
+	return plan
+}
+
+func (plan *arm64LocalControlPlan) recordRawZeroReturn(block, instruction int, state *arm64ControlState, entryLink string) {
+	point := [2]int{block, instruction}
+	link := arm64ControlFromMap(make(map[string]bool))
+	for _, token := range arm64ControlKeys(arm64ControlRead(state.regs, "R30")) {
+		if token == entryLink {
+			token = "label:" + plan.outer
+		}
+		link = arm64ControlSetToken(link, token, true)
+	}
+	plan.before[point] = arm64ControlUnion(plan.before[point], link)
+	plan.linkBefore[point] = arm64ControlUnion(plan.linkBefore[point], link)
+	plan.stackBefore[point] = arm64ControlUnion(plan.stackBefore[point], arm64ControlRead(state.regs, SP))
+}
diff --git a/arm64_raw_context_control_test.go b/arm64_raw_context_control_test.go
new file mode 100644
index 000000000..ecc9f91a9
--- /dev/null
+++ b/arm64_raw_context_control_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Both invocations of this exact raw helper are valid: one points at the
+// incoming output, the other at a disjoint slice of the fresh private frame.
+// A context-insensitive join cannot use external+SP as an exact memory cell.
+func arm64RawContextFixture(t *testing.T) string {
+	t.Helper()
+	source := `TEXT rawContext(SB),516,$0-16
+MOVD in+0(FP),R4
+MOVD out+8(FP),R1
+WORD $0xa9bc7bfd
+WORD $0x3dc00080
+MOVD R1,R0
+WORD $0x94000000
+WORD $0x910043e0
+WORD $0x94000000
+WORD $0x3dc007e1
+WORD $0x3d800421
+WORD $0xa8c47bfd
+WORD $0xd65f03c0
+helper:
+WORD $0x3d800000
+WORD $0xd65f03c0
+`
+	return arm64RawContextResolveCalls(t, source)
+}
+
+func arm64RawContextResolveCalls(t *testing.T, source string) string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var calls []int64
+	offset, helper := int64(0), int64(-1)
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == OpLABEL && ins.Args[0].Sym == "helper" {
+			helper = offset
+		}
+		if ins.Op == OpWORD && ins.Args[0].Imm == 0x94000000 {
+			calls = append(calls, offset)
+		}
+		width, known := arm64RawKnownSourceWidth(file.Funcs[0], ins)
+		if !known {
+			t.Fatalf("fixture source width is unknown: %s", ins.Raw)
+		}
+		offset += width
+	}
+	if helper < 0 || len(calls) != 2 {
+		t.Fatal("missing raw helper layout")
+	}
+	for _, call := range calls {
+		word := uint32(0x94000000) | uint32((helper-call)/4)&0x03ffffff
+		source = strings.Replace(source, "WORD $0x94000000", fmt.Sprintf("WORD $%#x", word), 1)
+	}
+	return source
+}
+
+func TestARM64RawContextLocalAndExternalHelperPointer(t *testing.T) {
+	source := arm64RawContextFixture(t)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	sig.Name = "rawContext"
+	if !arm64CallFrameUnexposedTyped(file.Funcs[0], sig, nil, nil) {
+		t.Fatal("valid raw helper contexts did not restore the independent whole-source caller proof")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "raw-context.ll", "raw-context.o", ir)
+	}
+}
+
+func arm64RawContextLowerer(t *testing.T, source string, sig FuncSig) *arm64Ctx {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, _, err := prepareARM64RawPCRelative(file.Funcs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	var output strings.Builder
+	return newARM64Ctx(&output, fn, sig, nil, nil, false)
+}
+
+func TestARM64RawContextControlRequiresCompleteBoundSource(t *testing.T) {
+	source := arm64RawContextFixture(t)
+	sig := arm64RawZeroFrameSig()
+	sig.Name = "rawContext"
+	for _, tc := range []struct {
+		name, old, replacement string
+	}{
+		{"full_overlap", "WORD $0x910043e0", "WORD $0x910003e0"},
+		{"one_byte_overlap", "WORD $0x910043e0", "WORD $0x91003fe0"},
+		{"escape_to_external", "helper:\n", "helper:\nMOVD R0,(R1)\n"},
+		{"escape_to_global", "helper:\n", "helper:\nMOVD R0,escaped(SB)\n"},
+		{"escape_alias", "helper:\n", "helper:\nMOVD R0,R9\nMOVD R9,(R1)\n"},
+		{"bad_lr", "helper:\n", "helper:\nMOVD R1,R30\n"},
+		{"bad_g", "helper:\n", "helper:\nMOVD $0,g\n"},
+		{"bad_os", "helper:\n", "helper:\nWORD $0xd2800012\n"},
+		{"bad_bp", "helper:\n", "helper:\nMOVD $0,R29\n"},
+		{"unbalanced_sp", "helper:\n", "helper:\nWORD $0xd10043ff\n"},
+		{"native_blr", "helper:\n", "helper:\nWORD $0xd63f0200\n"},
+		{"self_bl", "helper:\n", "helper:\nWORD $0x94000000\n"},
+		{"unknown_word", "helper:\n", "helper:\nWORD $0xffffffff\n"},
+		{"ordinary_unproved_call", "WORD $0x94000007", "BL helper"},
+		{"external_call", "helper:\n", "helper:\nBL external(SB)\n"},
+		{"conditional_sp_mismatch", "helper:\n", "helper:\nCBZ R2,join\nWORD $0xd10043ff\njoin:\n"},
+		{"conditional_lr_mismatch", "helper:\n", "helper:\nCBZ R2,join\nMOVD R1,R30\njoin:\n"},
+		{"conditional_g_mismatch", "helper:\n", "helper:\nCBZ R2,join\nMOVD $0,g\njoin:\n"},
+		{"mixed_pointer_store", "helper:\n", "helper:\nCBZ R2,join\nMOVD R1,R0\njoin:\n"},
+		{"conditional_pointer_escape", "helper:\n", "helper:\nCBZ R2,join\nMOVD R0,(R1)\njoin:\n"},
+		{"dead_unsafe_component", "helper:\n", "dead:\nWORD $0xffffffff\nWORD $0xd65f03c0\nhelper:\n"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			changed := strings.Replace(source, tc.old, tc.replacement, 1)
+			if tc.name == "dead_unsafe_component" {
+				changed = source + "dead:\nWORD $0xffffffff\nWORD $0xd65f03c0\n"
+			}
+			if tc.name == "bad_bp" {
+				changed = strings.Replace(changed, "WORD $0xa8c47bfd", "WORD $0xa8c47be4", 1)
+			}
+			if changed == source {
+				t.Fatalf("negative did not change fixture: %s", tc.old)
+			}
+			c := arm64RawContextLowerer(t, changed, sig)
+			// Even a caller-supplied true bool must not publish a partial plan
+			// from an independently failing normalized whole-source proof.
+			c.unexposedCallFrame = true
+			if c.rawZeroContextControlPlan("outer") != nil {
+				t.Fatal("unsafe/partial raw source published a continuation certificate")
+			}
+		})
+	}
+	for _, mutate := range []func(*arm64Ctx){
+		func(c *arm64Ctx) { c.unexposedCallFrame = false },
+		func(c *arm64Ctx) { c.sourceGoFrame.present = true },
+		func(c *arm64Ctx) { c.sig.ArgRegs = []Reg{SP, "R1"} },
+		func(c *arm64Ctx) { c.sig.Frame.Params = nil },
+		func(c *arm64Ctx) { c.sig.Ret = I64 },
+		func(c *arm64Ctx) { c.normalizedSource.Instrs = c.normalizedSource.Instrs[1:] },
+		func(c *arm64Ctx) { c.blocks = c.blocks[1:] },
+	} {
+		c := arm64RawContextLowerer(t, source, sig)
+		mutate(c)
+		if c.rawZeroContextControlPlan("outer") != nil {
+			t.Fatal("missing original/typed/fresh/normalized binding published a certificate")
+		}
+	}
+	// A user label must not collide with the independent caller sentinel.
+	c := arm64RawContextLowerer(t, strings.Replace(source, "helper:", "__entry_lr:", 1), sig)
+	if c.rawZeroContextControlPlan("outer") == nil {
+		t.Fatal("legitimate helper label collided with synthetic entry-LR identity")
+	}
+	// A helper CFG is permitted only when both paths independently restore
+	// the same exact continuation and stack; this is not a straight-line rule.
+	branched := strings.Replace(source, "helper:\nWORD $0x3d800000\n", `helper:
+CBZ R2,other
+WORD $0x3d800000
+B joined
+other:
+WORD $0x3d800000
+joined:
+`, 1)
+	c = arm64RawContextLowerer(t, branched, sig)
+	if c.rawZeroContextControlPlan("outer") == nil {
+		t.Fatal("same-source helper with matching branch contexts lost its complete proof")
+	}
+}
diff --git a/arm64_raw_context_runtime_test.go b/arm64_raw_context_runtime_test.go
new file mode 100644
index 000000000..45cbd6633
--- /dev/null
+++ b/arm64_raw_context_runtime_test.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func arm64RawContextMemoryFixture(t *testing.T) (*File, map[string]FuncSig, string, []arm64RawPrivateMemoryCase) {
+	t.Helper()
+	cases := arm64RawPrivateMemoryCases()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, tc := range cases {
+		name := fmt.Sprintf("contextMemory%d", index)
+		prep := []string{"ldr x4,[x3]", "ldr x5,[x3,#8]"}
+		outputs := []string{"str x9,[x1,#64]"}
+		if tc.count == 2 {
+			outputs = append(outputs, "str x10,[x1,#72]")
+		}
+		if tc.floating {
+			prep = []string{"ldr q0,[x3]", "ldr q1,[x3,#16]"}
+			bank := map[int]string{4: "s", 8: "d", 16: "q"}[tc.width]
+			outputs = []string{fmt.Sprintf("str %s2,[x1,#64]", bank)}
+			if tc.count == 2 {
+				outputs = append(outputs, fmt.Sprintf("str %s3,[x1,#%d]", bank, 64+tc.width))
+			}
+		}
+		lines := append(append([]string(nil), prep...), outputs...)
+		lines = append(lines, strings.ReplaceAll(tc.store, "sp", "x0"), strings.ReplaceAll(tc.load, "sp", "x0"))
+		words := assembleARM64LLVMWords(t, lines, "")
+		var body strings.Builder
+		fmt.Fprintf(&body, "TEXT %s(SB),516,$0-16\nMOVD in+0(FP),R3\nMOVD out+8(FP),R1\nWORD $0xa9bc7bfd\n", name)
+		for _, word := range words[:len(prep)] {
+			fmt.Fprintf(&body, "WORD $%#08x\n", word)
+		}
+		body.WriteString("MOVD R1,R0\n")
+		privateBase := 16
+		if strings.HasSuffix(tc.name, "pre_post") {
+			body.WriteString("WORD $0x91008000\n") // ADD 32,X0,X0.
+			privateBase = 48
+		}
+		body.WriteString("WORD $0x94000000\n")
+		fmt.Fprintf(&body, "WORD $%#08x\n", uint32(0x910003e0)|uint32(privateBase)<<10)
+		body.WriteString("WORD $0x94000000\n")
+		for _, word := range words[len(prep) : len(prep)+len(outputs)] {
+			fmt.Fprintf(&body, "WORD $%#08x\n", word)
+		}
+		body.WriteString("WORD $0xa8c47bfd\nWORD $0xd65f03c0\nhelper:\n")
+		for _, word := range words[len(words)-2:] {
+			fmt.Fprintf(&body, "WORD $%#08x\n", word)
+		}
+		body.WriteString("WORD $0xd65f03c0\n")
+		source.WriteString(arm64RawContextResolveCalls(t, body.String()))
+		sig := arm64RawZeroFrameSig()
+		sig.Name = name
+		sigs[name] = sig
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, sigs, source.String(), cases
+}
+
+func TestARM64RawContextMemoryFamilyObjects(t *testing.T) {
+	file, sigs, _, cases := arm64RawContextMemoryFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "context-memory.ll", "context-memory.o", ir)
+	}
+	t.Logf("%d same-source mixed external/private helper memory variants, actual Go and five LLVM22 objects", len(cases))
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawContextMemoryFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	file, sigs, source, cases := arm64RawContextMemoryFixture(t)
+	var goDecls, cDecls, goChecks, cChecks strings.Builder
+	for index, tc := range cases {
+		name := fmt.Sprintf("contextMemory%d", index)
+		fmt.Fprintf(&goDecls, "func %s(*byte, *byte)\n", name)
+		fmt.Fprintf(&cDecls, "extern void %s(const unsigned char *, unsigned char *);\n", name)
+		storeOffset, floating := 16, 0
+		if strings.HasSuffix(tc.name, "pre_post") || strings.HasSuffix(tc.name, "post_pre") {
+			storeOffset = 0
+		} else if strings.HasSuffix(tc.name, "unscaled") {
+			storeOffset = 9
+		}
+		if tc.floating {
+			floating = 1
+		}
+		fmt.Fprintf(&goChecks, "check(%s, %d, %d, %d, %d, %d)\n", name, tc.width, tc.count, tc.signBits, floating, storeOffset)
+		fmt.Fprintf(&cChecks, "if (check(%s, %d, %d, %d, %d, %d)) { return 1; }\n", name, tc.width, tc.count, tc.signBits, floating, storeOffset)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":  "module rawcontextmemoryoracle\n\ngo 1.20\n",
+		"main.go": arm64RawContextOracleGo + goDecls.String() + "func main() {\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT contextMemory", "TEXT ·contextMemory") +
+			"\nTEXT ·readGoG(SB),516,$0-8\nMOVD g,R0\nMOVD R0,ret+0(FP)\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "main", "-o", filepath.Join(dir, "oracle.o"), filepath.Join(dir, "oracle_arm64.s"))
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	listing, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || !strings.Contains(string(listing), "LEAF|NOFRAME, $0-16") || strings.Contains(string(listing), "MOVD.W\tR30,") {
+		t.Fatalf("actual Go raw helper object/prologue: %v\n%s", err, listing)
+	}
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	command = exec.CommandContext(ctx, "go", args...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go raw mixed-context helper numeric/canary/caller oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "raw_context_memory", triple, ir,
+		arm64RawContextOracleC+cDecls.String()+"int main(void) {\n"+cChecks.String()+"return 0;\n}\n", runner)
+	t.Logf("actual Go/LLVM22 independent oracles: %d variants x 128 patterns x 5 unaligned offsets; both external and private helper calls executed, full numeric/canaries and caller g/LR", len(cases))
+}
+
+const arm64RawContextOracleGo = `package main
+
+import "encoding/binary"
+
+func readGoG() uintptr
+
+func check(fn func(*byte, *byte), width, count, signBits, floating, storeOffset int) {
+	var input, output, want [128]byte
+	seed := uint64(0x0123456789abcdef)
+	for trial := 0; trial < 128; trial++ {
+		for _, off := range []int{0, 1, 3, 7, 17} {
+			for i := range input {
+				seed = seed*6364136223846793005 + 1
+				input[i] = byte(seed >> 56)
+				output[i], want[i] = 0xa5, 0xa5
+			}
+			if trial < 64 {
+				binary.LittleEndian.PutUint64(input[off:], uint64(1)<<trial)
+			}
+			if trial == 64 {
+				binary.LittleEndian.PutUint64(input[off:], ^uint64(0))
+			}
+			for item := 0; item < count; item++ {
+				inputStep, outputStep := 8, 8
+				if floating != 0 {
+					inputStep, outputStep = 16, width
+				}
+				bytes := input[off+item*inputStep : off+item*inputStep+width]
+				copy(want[off+storeOffset+item*width:], bytes)
+				if floating != 0 {
+					copy(want[off+64+item*outputStep:], bytes)
+				} else {
+					var value uint64
+					for b := width-1; b >= 0; b-- {
+						value = value<<8 | uint64(bytes[b])
+					}
+					if signBits != 0 && value&(uint64(1)<<(width*8-1)) != 0 {
+						value |= ^uint64(0) << (width*8)
+						if signBits == 32 {
+							value = uint64(uint32(value))
+						}
+					}
+					binary.LittleEndian.PutUint64(want[off+64+item*outputStep:], value)
+				}
+			}
+			snapshot := input
+			before := readGoG()
+			fn(&input[off], &output[off])
+			if before == 0 || before != readGoG() || input != snapshot || output != want {
+				panic("mixed helper numeric/input/output/caller mismatch")
+			}
+		}
+	}
+}
+`
+
+const arm64RawContextOracleC = `#include <stdint.h>
+#include <string.h>
+
+static uint64_t readG(void) {
+  uint64_t value;
+  __asm__ volatile("mov %0,x28" : "=r"(value));
+  return value;
+}
+
+static uint64_t readOS18(void) {
+  uint64_t value;
+  __asm__ volatile("mov %0,x18" : "=r"(value));
+  return value;
+}
+
+static int check(void (*fn)(const unsigned char *, unsigned char *),
+                 unsigned width, unsigned count, unsigned signBits,
+                 unsigned floating, unsigned storeOffset) {
+  unsigned char input[128], output[128], want[128], snapshot[128];
+  const unsigned offsets[] = {0, 1, 3, 7, 17};
+  uint64_t seed = UINT64_C(0x0123456789abcdef);
+  for (unsigned trial = 0; trial < 128; trial++) {
+    for (unsigned o = 0; o < 5; o++) {
+      unsigned off = offsets[o];
+      for (unsigned i = 0; i < 128; i++) {
+        seed = seed * UINT64_C(6364136223846793005) + 1;
+        input[i] = (unsigned char)(seed >> 56);
+        output[i] = want[i] = 0xa5;
+      }
+      if (trial <= 64) {
+        uint64_t value = trial < 64 ? UINT64_C(1) << trial : UINT64_MAX;
+        memcpy(input + off, &value, 8);
+      }
+      for (unsigned item = 0; item < count; item++) {
+        const unsigned char *bytes = input + off + item * (floating ? 16 : 8);
+        memcpy(want + off + storeOffset + item * width, bytes, width);
+        if (floating) {
+          memcpy(want + off + 64 + item * width, bytes, width);
+        } else {
+          uint64_t value = 0;
+          for (unsigned b = 0; b < width; b++) {
+            value |= (uint64_t)bytes[b] << (8*b);
+          }
+          if (signBits && (value & (UINT64_C(1) << (8*width-1)))) {
+            value |= UINT64_MAX << (8*width);
+            if (signBits == 32) { value = (uint32_t)value; }
+          }
+          memcpy(want + off + 64 + item * 8, &value, 8);
+        }
+      }
+      memcpy(snapshot, input, sizeof(input));
+      uint64_t beforeG = readG(), beforeOS18 = readOS18();
+      fn(input + off, output + off);
+      if (beforeG != readG() || beforeOS18 != readOS18() ||
+          memcmp(input, snapshot, sizeof(input)) || memcmp(output, want, sizeof(output))) {
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_decode.go b/arm64_raw_decode.go
new file mode 100644
index 000000000..e8b989aa1
--- /dev/null
+++ b/arm64_raw_decode.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// decodeARM64RawWordInstruction uses Go's architecture decoder to recover a
+// Plan 9 instruction from a WORD that is not covered by a specialized decoder.
+// The caller must run the returned instruction through the regular semantic
+// lowerers; decoding by itself never counts as supported.
+func decodeARM64RawWordInstruction(ins Instr) (Instr, error) {
+	return decodeARM64RawWordInstructionTarget(ins, "")
+}
+
+// decodeARM64RawWordInstructionTarget decodes one raw instruction. When the
+// instruction contains a PC-relative operand, target must be the exact source
+// label established by normalizeARM64RawPCRelative. Keeping the layout proof
+// out of this context-free decoder prevents guessed control-flow edges.
+func decodeARM64RawWordInstructionTarget(ins Instr, target string) (Instr, error) {
+	word, err := arm64RawWordValue(ins)
+	if err != nil {
+		return Instr{}, err
+	}
+	// A64 UDF has a fixed zero high half and the complete unsigned imm16
+	// field. x/arch predates this decode; do not classify these deliberate
+	// exception encodings as arbitrary unknown words or discard the immediate.
+	if word&0xffff0000 == 0 {
+		return Instr{
+			Op:                         "UNDEF",
+			Raw:                        fmt.Sprintf("UNDEF /* decoded from %s */", ins.Raw),
+			arm64RawUndefinedImmediate: uint16(word),
+		}, nil
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	decoded, err := arm64asm.Decode(code[:])
+	if err != nil {
+		return Instr{}, fmt.Errorf("decode ARM64 WORD %#08x: %w", word, err)
+	}
+	pcRelative := 0
+	for _, arg := range decoded.Args {
+		if arg == nil {
+			break
+		}
+		if _, ok := arg.(arm64asm.PCRel); ok {
+			pcRelative++
+		}
+	}
+	if pcRelative != 0 && target == "" {
+		return Instr{}, fmt.Errorf("ARM64 WORD %#08x is PC-relative and cannot be mapped safely to source labels: %q", word, ins.Raw)
+	}
+	if pcRelative > 1 {
+		return Instr{}, fmt.Errorf("ARM64 WORD %#08x has %d PC-relative operands: %q", word, pcRelative, ins.Raw)
+	}
+	syntax := decodedARM64GoSyntax(decoded)
+	file, err := Parse(ArchARM64, "TEXT decoded(SB), $0-0\n"+syntax+"\n")
+	if err != nil {
+		return Instr{}, fmt.Errorf("parse decoded ARM64 WORD %#08x as %q: %w", word, syntax, err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 2 {
+		return Instr{}, fmt.Errorf("decoded ARM64 WORD %#08x produced an invalid instruction sequence %q", word, syntax)
+	}
+	result := file.Funcs[0].Instrs[1]
+	result.arm64Encoded = true
+	if pcRelative != 0 {
+		replaced := 0
+		for i := range result.Args {
+			if result.Args[i].Kind == OpMem && result.Args[i].Mem.Base == PC {
+				result.Args[i] = Operand{Kind: OpIdent, Ident: target}
+				replaced++
+			}
+		}
+		if replaced != pcRelative {
+			return Instr{}, fmt.Errorf("decoded ARM64 WORD %#08x as %q but replaced %d/%d PC-relative operands", word, syntax, replaced, pcRelative)
+		}
+	}
+	result.Raw = fmt.Sprintf("%s /* decoded from %s */", result.Raw, ins.Raw)
+	result.arm64RawLocalCall = decoded.Op == arm64asm.BL && pcRelative == 1 && target != ""
+	return result, nil
+}
+
+func decodedARM64GoSyntax(inst arm64asm.Inst) string {
+	// LDPSW has the same typed pair/address grammar as LDP. x/arch's
+	// generic printer reverses its two destinations and drops .W/.P, so
+	// borrow the complete LDP printer, preserving the original opcode.
+	if inst.Op == arm64asm.LDPSW {
+		inst.Op = arm64asm.LDP
+		syntax := arm64asm.GoSyntax(inst, 0, nil, nil)
+		return "LDPSW" + strings.TrimPrefix(syntax, "LDP")
+	}
+	// Branch-register encodings read register 31 as XZR, never SP.
+	// x/arch's older BR printer spells it R31, which is not a Go GP
+	// register. Keep this complete BR/BLR/RET field on the zero path.
+	if inst.Args[0] == arm64asm.XZR {
+		switch inst.Op {
+		case arm64asm.BR:
+			return "JMP (ZR)"
+		case arm64asm.BLR:
+			return "CALL ZR"
+		case arm64asm.RET:
+			return "RET ZR"
+		}
+	}
+	// x/arch's typed decoder knows the complete structure family, but its
+	// Plan 9 printer handles operand order and post-index suffixes only for
+	// LD1/ST1. Reuse those printer rules with the original typed operands and
+	// restore the real opcode. Guard on the arranged-list type: single-lane
+	// instructions have a different operand grammar and their own lowerer.
+	if _, arranged := inst.Args[0].(arm64asm.RegisterWithArrangement); arranged {
+		original := inst.Op
+		switch original {
+		case arm64asm.LD2, arm64asm.LD3, arm64asm.LD4,
+			arm64asm.LD1R, arm64asm.LD2R, arm64asm.LD3R, arm64asm.LD4R:
+			inst.Op = arm64asm.LD1
+		case arm64asm.ST2, arm64asm.ST3, arm64asm.ST4:
+			inst.Op = arm64asm.ST1
+		}
+		if inst.Op != original {
+			syntax := arm64asm.GoSyntax(inst, 0, nil, nil)
+			return "V" + original.String() + strings.TrimPrefix(syntax, "V"+inst.Op.String())
+		}
+	}
+	syntax := arm64asm.GoSyntax(inst, 0, nil, nil)
+	op, rest, hasArgs := strings.Cut(syntax, " ")
+	if !hasArgs {
+		rest = ""
+	}
+	if op == "NOOP" {
+		return "NOP"
+	}
+	// x/arch v0.14 predates cmd/asm spellings for the unscaled signed-offset
+	// load aliases and prints names such as LDURBW. Canonicalize the complete
+	// integer family to the same MOV forms used for the corresponding LDR
+	// instructions so the regular width/sign-aware lowerers provide semantics.
+	switch inst.Op {
+	case arm64asm.MVN:
+		// x/arch calls the Advanced SIMD bitwise-not alias MVN and
+		// prints it as VMVN. Go's assembler names this form VNOT.
+		// Keep the scalar integer MVN spelling untouched.
+		if strings.HasPrefix(rest, "V") {
+			op = "VNOT"
+		}
+	case arm64asm.LDURB:
+		op = "MOVBU"
+	case arm64asm.LDURH:
+		op = "MOVHU"
+	case arm64asm.LDURSB:
+		op = "MOVB"
+		if arm64DecodedDestinationIsWord(inst) {
+			op = "MOVBW"
+		}
+	case arm64asm.LDURSH:
+		op = "MOVH"
+		if arm64DecodedDestinationIsWord(inst) {
+			op = "MOVHW"
+		}
+	case arm64asm.LDURSW:
+		op = "MOVW"
+	}
+	// x/arch v0.12 is the last decoder usable by this module's Go 1.20
+	// baseline. Its Plan 9 printer omits the V prefix for these Advanced SIMD
+	// forms; the operand arrangement tells them apart from their scalar forms.
+	if strings.HasPrefix(rest, "V") {
+		switch op {
+		case "FABS", "FNEG", "FSQRT", "FRINTN", "FRINTP", "FRINTM", "FRINTZ", "FRINTA", "FRINTX", "FRINTI",
+			"FCVTZS", "FCVTZU", "SCVTF", "UCVTF", "FMAXV", "FMINV", "FMAXNMV", "FMINNMV":
+			op = "V" + op
+		}
+	}
+	// Go's named reduction syntax spells the scalar destination as a bare V
+	// register, while the architecture decoder prints the aliased F register.
+	// Canonicalize raw reductions through the exact named-form lowerer.
+	if op == "VFMAXV" || op == "VFMINV" || op == "VFMAXNMV" || op == "VFMINNMV" {
+		if separator := strings.LastIndex(rest, ", F"); separator >= 0 {
+			rest = rest[:separator] + ", V" + rest[separator+3:]
+		}
+	}
+	if rest == "" {
+		return op
+	}
+	return op + " " + rest
+}
+
+func arm64DecodedDestinationIsWord(inst arm64asm.Inst) bool {
+	reg, ok := inst.Args[0].(arm64asm.Reg)
+	return ok && reg >= arm64asm.W0 && reg <= arm64asm.WZR
+}
diff --git a/arm64_raw_decode_test.go b/arm64_raw_decode_test.go
new file mode 100644
index 000000000..98cae3326
--- /dev/null
+++ b/arm64_raw_decode_test.go
@@ -0,0 +1,480 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawWordsUseOfficialDecoderAndSemanticLowering(t *testing.T) {
+	const source = `TEXT rawDecoded(SB), $0-0
+	MOVD $9, R0
+	MOVD $3, R16
+	WORD $0x9ad00800 // UDIV R16, R0, R0
+	WORD $0x2e211402 // VURHADD V1.B8, V0.B8, V2.B8
+	WORD $0x4ee0f8e7 // VFABS V7.D2, V7.D2
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: triple,
+				Sigs: map[string]FuncSig{
+					"rawDecoded": {Name: "rawDecoded", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatalf("Translate() error = %v", err)
+			}
+			for _, want := range []string{"udiv i64", "lshr <8 x i16>", "@llvm.fabs.v2f64"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("decoded semantics omitted %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-decoded.ll", "arm64-raw-decoded.o", ir)
+		})
+	}
+}
+
+func TestARM64RawPCRelativeInstructionFailsClosed(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		word uint32
+	}{
+		{name: "ADR without proven boundary", word: 0x100000a0},
+		{name: "ADRP nonzero page delta", word: 0xb0000000},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT rawADR(SB), $0-0\n\tWORD $" + fmt.Sprintf("%#08x", test.word) + "\n\tRET\n"
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatalf("Parse() error = %v", err)
+			}
+			_, err = Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{
+					"rawADR": {Name: "rawADR", Ret: Void},
+				},
+			})
+			if err == nil || !strings.Contains(err.Error(), "PC-relative") {
+				t.Fatalf("Translate() error = %v, want explicit PC-relative raw-instruction rejection", err)
+			}
+		})
+	}
+}
+
+func TestARM64RawZeroPageADRPResolvesAtExactInstructionBoundary(t *testing.T) {
+	const source = `TEXT rawADRPPage(SB), $0-8
+	WORD $0x90000000 // ADRP current page, R0
+	MOVD R0, ret+0(FP)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       "arm64",
+				TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawADRPPage": {
+					Name: "rawADRPPage", Ret: I64,
+					Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}},
+				}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "blockaddress(@rawADRPPage") || !strings.Contains(ir, "and i64") || !strings.Contains(ir, ", -4096") {
+				t.Fatalf("zero-page ADRP semantics missing:\n%s", ir)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-zero-adrp.ll", "arm64-raw-zero-adrp.o", ir)
+			if triple != "aarch64-apple-darwin" || runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+				return
+			}
+			clang := findLLVM22Tool("clang")
+			if clang == "" {
+				t.Fatal("LLVM 22 clang not found")
+			}
+			const mainC = `
+#include <stdint.h>
+extern uintptr_t rawADRPPage(void);
+int main(void) {
+  uintptr_t got = rawADRPPage();
+  uintptr_t want = ((uintptr_t)&rawADRPPage) & ~(uintptr_t)4095;
+  return got == want ? 0 : 1;
+}
+`
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_zero_adrp", triple, ir, mainC, nil)
+		})
+	}
+}
+
+func TestARM64RawPCRelativeWordsResolveExactInstructionBoundaries(t *testing.T) {
+	const source = `TEXT rawPCRelative(SB), $16-0
+	WORD $0x100000a0 // ADR +20, R0; crosses the framed RET expansion
+	MOVD R0, R1
+	RET
+target:
+	WORD $0x14000002 // B +8
+	WORD $0x91000400 // ADD $1, R0, R0
+done:
+	WORD $0xd65f03c0 // RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"rawPCRelative": {Name: "rawPCRelative", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Translate() error = %v", err)
+	}
+	for _, want := range []string{
+		"blockaddress(@rawPCRelative, %bb_target)",
+		"br label %bb_done",
+	} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw PC-relative lowering omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-raw-pcrel.ll", "arm64-raw-pcrel.o", ir)
+}
+
+func TestARM64RawPCRelativeLayoutMatchesFramedEntryWrapper(t *testing.T) {
+	const source = `TEXT rawEntry(SB), $16
+	NO_LOCAL_POINTERS
+	WORD $0x100000a0
+	MOVD R0, ret(FP)
+	RET
+rawBody:
+	WORD $0xd65f03c0
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	if len(file.Funcs) != 1 {
+		t.Fatalf("Parse() funcs = %d, want 1", len(file.Funcs))
+	}
+	if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err != nil {
+		for i, ins := range file.Funcs[0].Instrs {
+			t.Logf("instruction %d: op=%s args=%#v raw=%q", i, ins.Op, ins.Args, ins.Raw)
+		}
+		t.Fatalf("normalizeARM64RawPCRelative() error = %v", err)
+	}
+}
+
+func TestARM64RawPCRelativeSeparatesEmbeddedCodeAndConstantPools(t *testing.T) {
+	const source = `TEXT rawEmbedded(SB), $16-0
+	WORD $0x100000a0 // ADR +20, R0: entry wrapper returns embedded code
+	MOVD R0, R1
+	RET
+code:
+	WORD $0x10000042 // ADR +8, R2: embedded code addresses its constant pool
+	WORD $0xd65f03c0 // RET
+data:
+	WORD $0x04030201
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm64",
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"rawEmbedded": {Name: "rawEmbedded", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Translate() error = %v", err)
+	}
+	for _, want := range []string{
+		`@rawEmbedded.data.raw_data = private constant [4 x i8] c"\01\02\03\04"`,
+		"blockaddress(@rawEmbedded, %bb_code)",
+		"ptrtoint ptr @rawEmbedded.data.raw_data to i64",
+	} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("embedded raw-data lowering omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-raw-data.ll", "arm64-raw-data.o", ir)
+}
+
+func TestARM64RawPCRelativeCrossesCompleteFixedWidthJumpFamily(t *testing.T) {
+	for _, jump := range []string{
+		"B branchTarget",
+		"JMP branchTarget",
+		"JMP 1(PC)",
+		"JMP (R11)",
+		"BL branchTarget",
+		"BL 1(PC)",
+		"BL R3",
+		"BL (R4)",
+		"BL global(SB)",
+		"CALL R5",
+		"CALL (R6)",
+		"CALL global(SB)",
+	} {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(jump), func(t *testing.T) {
+			source := "TEXT rawJumpFamily(SB), $0-0\n\tWORD $0x1000005e // ADR +8, R30\n\t" + jump + "\n\tMOVD R0, R0\nbranchTarget:\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err != nil {
+				t.Fatalf("fixed-width %q broke raw PC-relative layout: %v", jump, err)
+			}
+		})
+	}
+}
+
+func TestARM64RawPCRelativeCrossesConditionalBranchFamily(t *testing.T) {
+	for _, branch := range []string{
+		"BCC", "BCS", "BEQ", "BGE", "BGT", "BHI", "BHS", "BLE",
+		"BLO", "BLS", "BLT", "BMI", "BNE", "BPL", "BVC", "BVS",
+	} {
+		t.Run(branch, func(t *testing.T) {
+			source := "TEXT rawConditionalBranch(SB), $0-0\n\tWORD $0x1000005e // ADR +8, R30\n\t" +
+				branch + " branchTarget\n\tMOVD R0, R0\nbranchTarget:\n\tRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err != nil {
+				t.Fatalf("fixed-width %s broke raw PC-relative layout: %v", branch, err)
+			}
+		})
+	}
+}
+
+func requireARM64GoSingleWordLogicalSpan(t *testing.T, source string) {
+	t.Helper()
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return
+	}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "logical.s")
+	obj := filepath.Join(dir, "logical.o")
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	assemble := exec.Command("go", "tool", "asm", "-p", "example.com/forms", "-o", obj, asm)
+	assemble.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	if out, err := assemble.CombinedOutput(); err != nil {
+		t.Fatalf("Go 1.27 assembler rejected logical form: %v\n%s", err, out)
+	}
+	objdump := exec.Command("go", "tool", "objdump", "-s", "rawLogical", obj)
+	objdump.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	out, err := objdump.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go object disassembly failed: %v\n%s", err, out)
+	}
+	pcByLine := make(map[int][]uint64)
+	for _, line := range strings.Split(string(out), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "logical.s:") {
+			continue
+		}
+		lineNumber, lineErr := strconv.Atoi(strings.TrimPrefix(fields[0], "logical.s:"))
+		pc, pcErr := strconv.ParseUint(fields[1], 0, 64)
+		if lineErr != nil || pcErr != nil {
+			t.Fatalf("invalid Go object location %q", line)
+		}
+		pcByLine[lineNumber] = append(pcByLine[lineNumber], pc)
+	}
+	for _, line := range []int{2, 3, 4, 6} {
+		if len(pcByLine[line]) != 1 {
+			t.Fatalf("source line %d emitted %d instructions, want one:\n%s", line, len(pcByLine[line]), out)
+		}
+	}
+	for _, pair := range [][2]int{{2, 3}, {3, 4}, {4, 6}} {
+		if got := pcByLine[pair[1]][0] - pcByLine[pair[0]][0]; got != 4 {
+			t.Fatalf("source lines %d-%d span %d bytes, want 4:\n%s", pair[0], pair[1], got, out)
+		}
+	}
+}
+
+func TestARM64RawPCRelativeCrossesLogicalImmediateFamily(t *testing.T) {
+	for _, logical := range []string{
+		"AND $0xffff000000000000, R1, R1",
+		"ORR $0xffff000000000000, R1, R1",
+		"EOR $0xffff000000000000, R1, R1",
+		"ANDS $0xffff000000000000, R1, R1",
+		"BIC $0xffff000000000000, R1, R1",
+		"ORN $0xffff000000000000, R1, R1",
+		"EON $0xffff000000000000, R1, R1",
+		"BICS $0xffff000000000000, R1, R1",
+		"TST $0xffff000000000000, R1",
+		"ANDW $0xff000000, R1, R1",
+		"ORRW $0xff000000, R1, R1",
+		"EORW $0xff000000, R1, R1",
+		"ANDSW $0xff000000, R1, R1",
+		"BICW $0xff000000, R1, R1",
+		"ORNW $0xff000000, R1, R1",
+		"EONW $0xff000000, R1, R1",
+		"BICSW $0xff000000, R1, R1",
+		"TSTW $0xff000000, R1",
+		"ORR $0xffff000000000000, R1",
+		"AND $0xffff000000000000, R1, RSP",
+	} {
+		t.Run(strings.Fields(logical)[0], func(t *testing.T) {
+			source := "TEXT rawLogical(SB), $0-0\n\tWORD $0x10000061 // ADR +12, R1\n\t" +
+				logical + "\n\tJMP (R1)\ntarget:\n\tRET\n"
+			requireARM64GoSingleWordLogicalSpan(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err != nil {
+				t.Fatalf("logical immediate %q broke raw PC-relative layout: %v", logical, err)
+			}
+		})
+	}
+}
+
+func TestARM64RawPCRelativeCrossesLogicalRegisterForms(t *testing.T) {
+	for _, logical := range []string{
+		"AND R2, R1, R1",
+		"ORR R2<<3, R1, R1",
+		"TST R2, R1",
+		"EORW R2<<3, R1, R1",
+		"AND R2, R1",
+		"ORR R2<<3, R1",
+	} {
+		t.Run(strings.Fields(logical)[0], func(t *testing.T) {
+			source := "TEXT rawLogical(SB), $0-0\n\tWORD $0x10000061 // ADR +12, R1\n\t" +
+				logical + "\n\tJMP (R1)\ntarget:\n\tRET\n"
+			requireARM64GoSingleWordLogicalSpan(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err != nil {
+				t.Fatalf("logical register %q broke raw PC-relative layout: %v", logical, err)
+			}
+		})
+	}
+}
+
+func TestARM64RawPCRelativeRejectsExpandingLogicalImmediate(t *testing.T) {
+	const source = `TEXT rawLogicalExpanded(SB), $0-0
+	WORD $0x10000061 // ADR +12, R1 does not reach the label after expansion.
+	ORR $0x123456789abcdef, R1, R1
+	JMP (R1)
+target:
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err == nil ||
+		!strings.Contains(err.Error(), "proven instruction boundary") {
+		t.Fatalf("expanding logical immediate was accepted as a fixed-width span: %v", err)
+	}
+}
+
+func TestARM64RawTrailingUnreferencedWordsBecomeDataAfterTerminator(t *testing.T) {
+	const source = `TEXT rawTrailingData(SB), $0-0
+	WORD $0xd65f03c0 // RET
+mask:
+	WORD $0x00000002
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawTrailingData": {Name: "rawTrailingData", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, `@rawTrailingData.mask.raw_data = private constant [4 x i8] c"\02\00\00\00"`) {
+		t.Fatalf("trailing raw data was not separated from code:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "arm64-raw-trailing-data.ll", "arm64-raw-trailing-data.o", ir)
+}
+
+func TestARM64RawReachableInvalidWordDoesNotBecomeData(t *testing.T) {
+	const source = `TEXT rawReachableInvalid(SB), $0-0
+	WORD $0xd503201f // NOP falls through
+reachable:
+	WORD $0xffffffff // Unknown, unlike the allocated UDF imm16 family.
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawReachableInvalid": {Name: "rawReachableInvalid", Ret: Void},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "unsupported ARM64 WORD encoding") {
+		t.Fatalf("reachable invalid WORD error = %v, want fail-closed rejection", err)
+	}
+}
diff --git a/arm64_raw_float_effects_test.go b/arm64_raw_float_effects_test.go
new file mode 100644
index 000000000..e3d099d4a
--- /dev/null
+++ b/arm64_raw_float_effects_test.go
@@ -0,0 +1,186 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawFloatDecodersHaveSharedEffectsAndLowering(t *testing.T) {
+	registry, err := parser.ParseFile(token.NewFileSet(), "arm64_raw_float_families.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registered := make(map[string]bool)
+	ast.Inspect(registry, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) == 0 {
+			return true
+		}
+		decoder, ok := call.Args[0].(*ast.Ident)
+		if !ok || !strings.HasPrefix(decoder.Name, "decodeARM64Raw") {
+			return true
+		}
+		if registered[decoder.Name] {
+			t.Fatalf("duplicate floating family %s", decoder.Name)
+		}
+		registered[decoder.Name] = true
+		return true
+	})
+	files, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range files {
+		name := entry.Name()
+		if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		floating := name == "arm64_lower_word_cvtf.go" || name == "arm64_lower_word_fcvtz.go" || name == "arm64_lower_word_fixed_int_to_float.go"
+		for _, prefix := range []string{"arm64_lower_word_float_", "arm64_lower_word_scalar_", "arm64_lower_word_half_", "arm64_lower_word_bfloat_"} {
+			floating = floating || strings.HasPrefix(name, prefix)
+		}
+		if !floating {
+			continue
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, decl := range file.Decls {
+			fn, ok := decl.(*ast.FuncDecl)
+			if ok && strings.HasPrefix(fn.Name.Name, "decodeARM64Raw") && !registered[fn.Name.Name] {
+				t.Errorf("%s has no shared effects/lowering family", fn.Name.Name)
+			}
+		}
+	}
+}
+
+func TestARM64RawFloatGPEffectsAllRegisterBanksAndDirections(t *testing.T) {
+	var lines []string
+	var wants []arm64RawContinuationEffects
+	for register := 0; register < 32; register++ {
+		x, w := fmt.Sprintf("x%d", register), fmt.Sprintf("w%d", register)
+		bit := uint32(1) << uint(register)
+		if register == 31 {
+			x, w, bit = "xzr", "wzr", 0
+		}
+		for _, test := range []struct {
+			format string
+			gp     string
+			writes bool
+		}{
+			{"fmov %s, h31", w, true}, {"fmov h31, %s", w, false},
+			{"fmov %s, s31", w, true}, {"fmov s31, %s", w, false},
+			{"fmov %s, d31", x, true}, {"fmov d31, %s", x, false},
+			{"fmov %s, v31.d[1]", x, true}, {"fmov v31.d[1], %s", x, false},
+			{"fcvtzs %s, h31", w, true}, {"fcvtnu %s, d31", x, true},
+			{"scvtf h31, %s", w, false}, {"ucvtf d31, %s", x, false},
+			{"scvtf s31, %s, #32", w, false}, {"ucvtf d31, %s, #64", x, false},
+		} {
+			lines = append(lines, fmt.Sprintf(test.format, test.gp))
+			effects := arm64RawContinuationEffects{gpReads: bit}
+			if test.writes {
+				effects = arm64RawContinuationEffects{gpWrites: bit}
+			}
+			wants = append(wants, effects)
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+fullfp16") {
+		_, effects, known := decodeARM64RawFloatFamily(word)
+		if !known || effects != wants[i] {
+			t.Errorf("%s: effects=%+v, known=%v; want %+v", lines[i], effects, known, wants[i])
+		}
+	}
+}
+
+func TestARM64RawFloatControlEffectsDistinguishGPAndVectorBanks(t *testing.T) {
+	tests := []struct {
+		assembly string
+		writes   uint32
+	}{
+		{"bfdot v30.4s, v31.8h, v29.8h", 0},
+		{"bfmmla v30.4s, v31.8h, v29.8h", 0},
+		{"fmlal v30.4s, v31.4h, v29.4h", 0},
+		{"scvtf v30.4s, v31.4s", 0},
+		{"fmla v30.4s, v31.4s, v29.4s", 0},
+		{"fmadd h30, h31, h29, h28", 0},
+		{"fmul v30.4s, v31.4s, v29.s[3]", 0},
+		{"fsqrt h30, h31", 0},
+		{"fcvtzs d30, d31", 0},
+		{"fadd d30, d31, d29", 0},
+		{"fcmp d30, d31", 0},
+		{"fcsel d30, d31, d29, eq", 0},
+		{"fmov h30, #1.0", 0},
+		{"scvtf d30, x30", 0},
+		{"scvtf d30, x30, #3", 0},
+		{"fmov x30, d31", 1 << 30},
+		{"fmov d30, x30", 0},
+		{"bfcvtn v30.4h, v31.4s", 0},
+		{"frinta v30.4s, v31.4s", 0},
+		{"fcvtn v30.4h, v31.4s", 0},
+		{"fcvtl v30.4s, v31.4h", 0},
+		{"fmaxv s30, v31.4s", 0},
+		{"faddp v30.4s, v31.4s, v29.4s", 0},
+		{"fminnmp v30.4s, v31.4s, v29.4s", 0},
+		{"fadd v30.4s, v31.4s, v29.4s", 0},
+		{"frecpe v30.4s, v31.4s", 0},
+		{"fsqrt v30.4s, v31.4s", 0},
+		{"fabs v30.8h, v31.8h", 0},
+		{"fcmeq v30.4s, v31.4s, v29.4s", 0},
+		{"fmov v30.4s, #1.0", 0},
+		{"fcvtzs x30, d31", 1 << 30},
+		{"fcvtzs v30.4s, v31.4s", 0},
+	}
+	lines := make([]string, len(tests))
+	for i, test := range tests {
+		lines[i] = test.assembly
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+bf16,+fullfp16,+fp16fml") {
+		test := tests[i]
+		t.Run(test.assembly, func(t *testing.T) {
+			if writes, known := arm64RawPoolGPWrites(word); !known || writes != test.writes {
+				t.Errorf("GP writes=%#x, known=%v; want %#x", writes, known, test.writes)
+			}
+			caller := arm64ControlFromMap(map[string]bool{"return:outer": true})
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": caller},
+				memory: map[string]arm64ControlValue{"sp:0": caller},
+			}
+			state.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}, OpWORD, false, nil)
+			if unknown := arm64ControlHas(state.regs["R30"], ""); unknown != (test.writes&(1<<30) != 0) {
+				t.Errorf("caller LR unknown=%v; GP writes=%#x", unknown, test.writes)
+			}
+			if arm64ControlHas(state.memory["sp:0"], "") {
+				t.Error("a register-only floating instruction cannot write a saved continuation")
+			}
+		})
+	}
+}
+
+func TestARM64RawFloatGPResultsCannotInventCallerReturn(t *testing.T) {
+	lines := []string{"fmov x30, d31", "fcvtzs x30, d31", "fcvtnu w30, h31"}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+fullfp16") {
+		source := fmt.Sprintf("TEXT control(SB),4,$0-0\nWORD $%#08x\nRET\n", word)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+		} {
+			_, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"control": {Name: "control", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s / %s: changed caller LR must remain Context, got %v", lines[i], triple, err)
+			}
+		}
+	}
+}
diff --git a/arm64_raw_float_families.go b/arm64_raw_float_families.go
new file mode 100644
index 000000000..68a1df58c
--- /dev/null
+++ b/arm64_raw_float_families.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+// Preserve the previous lowering precedence. Lowering, continuation provenance
+// and raw-pool GP effects all consume this same typed family registration.
+var arm64RawFloatFamilies = [...]arm64RawFamily{
+	arm64RawNoGPOrMemoryForm(decodeARM64RawBFloatDot, (*arm64Ctx).lowerRawBFloatDot),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawBFloatMatrix, (*arm64Ctx).lowerRawBFloatMatrix),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatMultiplyLong, (*arm64Ctx).lowerRawFloatMultiplyLong),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawCVTF, (*arm64Ctx).lowerRawCVTF),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFMLA, (*arm64Ctx).lowerRawFMLA),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawHalfFMA, (*arm64Ctx).lowerRawHalfFMA),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFMULByElement, (*arm64Ctx).lowerRawFMULByElement),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarHalfUnary, (*arm64Ctx).lowerRawScalarHalfUnary),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarVectorFCVTZ, (*arm64Ctx).lowerRawScalarVectorFCVTZ),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarFloatBinary, (*arm64Ctx).lowerRawScalarFloatBinary),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarFloatCompare, (*arm64Ctx).lowerRawScalarFloatCompare),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawConditionalCompare, (*arm64Ctx).lowerARM64ConditionalCompare),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarFloatSelect, (*arm64Ctx).lowerRawScalarFloatSelect),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarFloatImmediate, (*arm64Ctx).lowerRawScalarFloatImmediate),
+	arm64RawForm(decodeARM64RawScalarIntToFloat, (*arm64Ctx).lowerRawScalarIntToFloat,
+		func(form arm64RawScalarIntToFloat) arm64RawContinuationEffects {
+			if form.simdInteger {
+				return arm64RawContinuationEffects{}
+			}
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(form.source)}
+		}),
+	arm64RawForm(decodeARM64RawFixedIntToFloat, (*arm64Ctx).lowerRawFixedIntToFloat,
+		func(form arm64RawFixedIntToFloat) arm64RawContinuationEffects {
+			if form.vectorSource {
+				return arm64RawContinuationEffects{}
+			}
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(form.source)}
+		}),
+	arm64RawForm(decodeARM64RawFloatGPMove, (*arm64Ctx).lowerRawFloatGPMove,
+		func(form arm64RawFloatGPMove) arm64RawContinuationEffects {
+			if form.toFloat {
+				return arm64RawContinuationEffects{gpReads: arm64RawGPBit(form.gpReg)}
+			}
+			return arm64RawContinuationEffects{gpWrites: arm64RawGPBit(form.gpReg)}
+		}),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawBFloatConvert, (*arm64Ctx).lowerRawBFloatConvert),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawVectorFloatRound, (*arm64Ctx).lowerRawVectorFloatRound),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawVectorFloatNarrow, (*arm64Ctx).lowerRawVectorFloatNarrow),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawVectorFloatWiden, (*arm64Ctx).lowerRawVectorFloatWiden),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatMinMaxAcross, (*arm64Ctx).lowerRawFloatMinMaxAcross),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFADDP, (*arm64Ctx).lowerRawFADDP),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatPairwiseMinMax, (*arm64Ctx).lowerRawFloatPairwiseMinMax),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatBinary, (*arm64Ctx).lowerRawFloatBinary),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawReciprocalEstimate, (*arm64Ctx).lowerRawReciprocalEstimate),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFSQRT, (*arm64Ctx).lowerRawFSQRT),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatAbsNeg, (*arm64Ctx).lowerRawFloatAbsNeg),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatCompare, (*arm64Ctx).lowerRawFloatCompare),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFloatImmediate, (*arm64Ctx).lowerRawFloatImmediate),
+	arm64RawForm(decodeARM64RawScalarFCVTToInt, (*arm64Ctx).lowerRawScalarFCVTToInt,
+		func(form arm64RawScalarFCVTToInt) arm64RawContinuationEffects {
+			return arm64RawContinuationEffects{gpWrites: arm64RawGPBit(form.destination)}
+		}),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawFCVTZ, (*arm64Ctx).lowerRawFCVTZ),
+}
+
+func decodeARM64RawFloatFamily(word uint32) (arm64RawFamily, arm64RawContinuationEffects, bool) {
+	for _, family := range arm64RawFloatFamilies {
+		if effects, ok := family.effects(word); ok {
+			return family, effects, true
+		}
+	}
+	return arm64RawFamily{}, arm64RawContinuationEffects{}, false
+}
diff --git a/arm64_raw_integer_pair_decode_test.go b/arm64_raw_integer_pair_decode_test.go
new file mode 100644
index 000000000..e418f653f
--- /dev/null
+++ b/arm64_raw_integer_pair_decode_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawIntegerPairCompleteMemoryForms(t *testing.T) {
+	forms := []struct {
+		name string
+		word uint32
+	}{
+		{"LDP offset", 0xa97f0941},
+		{"LDP pre-index", 0xa9ff0941},
+		{"LDP post-index", 0xa8c10941},
+		{"LDPSW offset", 0x697f0941},
+		{"LDPSW pre-index", 0x69ff0941},
+		{"LDPSW post-index", 0x68c10941},
+		{"STPW offset", 0x293f0941},
+		{"STPW pre-index", 0x29bf0941},
+		{"STPW post-index", 0x28810941},
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawintegerpairforms(SB),$0-0\n")
+	for _, form := range forms {
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", form.word, form.name)
+		decoded, err := decodeARM64RawWordInstruction(Instr{
+			Op:   OpWORD,
+			Raw:  fmt.Sprintf("WORD $%#08x", form.word),
+			Args: []Operand{{Kind: OpImm, Imm: int64(form.word)}},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", form.name, err)
+		}
+		if len(decoded.Args) != 2 {
+			t.Fatalf("%s decoded %d operands, want two with a register pair: %q", form.name, len(decoded.Args), decoded.Raw)
+		}
+		pair := decoded.Args[1]
+		if strings.HasPrefix(form.name, "STP") {
+			pair = decoded.Args[0]
+		}
+		if pair.Kind != OpRegList || len(pair.RegList) != 2 {
+			t.Fatalf("%s decoded without register pair: %q", form.name, decoded.Raw)
+		}
+		if pair.RegList[0] != "R1" || pair.RegList[1] != "R2" {
+			t.Fatalf("%s decoded pair in wrong memory order: %v", form.name, pair.RegList)
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawintegerpairforms": {Name: "rawintegerpairforms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-integer-pair.ll", "arm64-raw-integer-pair.o", ir)
+		})
+	}
+}
+
+func TestARM64RawLDPSWRuntimeSignAndPairOrder(t *testing.T) {
+	if runtime.GOARCH != "arm64" {
+		t.Skip("native ARM64 runtime required")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `
+TEXT rawldpswruntime(SB),$0-16
+	MOVD input+0(FP), R10
+	MOVD output+8(FP), R11
+	WORD $0x697f0941 // LDPSW R1, R2, -8(R10)
+	MOVD R1, (R11)
+	MOVD R2, 8(R11)
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawldpswruntime": {
+			Name: "rawldpswruntime", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+extern void rawldpswruntime(const int32_t *, int64_t *);
+int main(void) {
+  const int32_t input[4] = {-7, 9, 11, 13};
+  int64_t output[2] = {0};
+  rawldpswruntime(input + 2, output);
+  return output[0] == -7 && output[1] == 9 ? 0 : 1;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_ldpsw", triple, ir, mainC, nil)
+}
diff --git a/arm64_raw_pc_relative.go b/arm64_raw_pc_relative.go
new file mode 100644
index 000000000..6444089f5
--- /dev/null
+++ b/arm64_raw_pc_relative.go
@@ -0,0 +1,684 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/bits"
+	"sort"
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+type arm64RawLayoutPoint struct {
+	segment int
+	offset  int64
+}
+
+type arm64RawDataBlob struct {
+	label   string
+	bytes   []byte
+	aliases map[string]int64
+}
+
+const arm64RawDataOp Op = "ARM64_RAW_DATA"
+
+// normalizeARM64RawPCRelative replaces raw ARM64 PC-relative instructions
+// with decoded instructions that name exact source labels. It deliberately
+// models only source spans whose cmd/asm widths are known. An unknown-width
+// pseudo instruction starts a new segment, so a raw displacement can never be
+// guessed across it.
+func normalizeARM64RawPCRelative(fn Func) (Func, error) {
+	result, _, err := prepareARM64RawPCRelative(fn)
+	return result, err
+}
+
+func prepareARM64RawPCRelative(fn Func) (Func, []arm64RawDataBlob, error) {
+	return prepareARM64RawPCRelativeWithReturnClobbers(fn, 0)
+}
+
+func prepareARM64RawPCRelativeWithReturnClobbers(fn Func, returnClobbers uint32) (Func, []arm64RawDataBlob, error) {
+	points := make([]arm64RawLayoutPoint, len(fn.Instrs))
+	boundaries := make(map[arm64RawLayoutPoint]int)
+	labels := make(map[arm64RawLayoutPoint]string)
+	labelIndices := make(map[string]int)
+	knownLabels := make(map[string]bool)
+
+	segment := 0
+	offset := int64(0)
+	for i, ins := range fn.Instrs {
+		point := arm64RawLayoutPoint{segment: segment, offset: offset}
+		points[i] = point
+		if ins.Op == OpLABEL && len(ins.Args) == 1 && ins.Args[0].Kind == OpLabel {
+			if _, exists := labels[point]; !exists {
+				labels[point] = ins.Args[0].Sym
+			}
+			knownLabels[ins.Args[0].Sym] = true
+			labelIndices[ins.Args[0].Sym] = i
+			continue
+		}
+
+		width, known := arm64RawKnownSourceWidth(fn, ins)
+		if !known {
+			segment++
+			offset = 0
+			continue
+		}
+		if width != 0 {
+			if _, exists := boundaries[point]; !exists {
+				boundaries[point] = i
+			}
+			offset += width
+		}
+	}
+	end := arm64RawLayoutPoint{segment: segment, offset: offset}
+	if _, exists := boundaries[end]; !exists {
+		boundaries[end] = len(fn.Instrs)
+	}
+
+	poolWords, poolBlobs, insertions := identifyARM64UnlabelledPool(fn, points, knownLabels, returnClobbers)
+	inspection := fn
+	if len(poolWords) != 0 {
+		inspection.Instrs = append([]Instr(nil), fn.Instrs...)
+		for at := range poolWords {
+			inspection.Instrs[at].Op = arm64RawDataOp
+		}
+	}
+	dataWords, dataBlobs, err := identifyARM64RawData(inspection, points, boundaries, labels, labelIndices)
+	if err != nil {
+		return Func{}, nil, err
+	}
+	for at := range poolWords {
+		dataWords[at] = true
+	}
+	dataBlobs = append(dataBlobs, poolBlobs...)
+	if anonymousData, err := identifyARM64AnonymousData(inspection, dataWords, labelIndices); err != nil {
+		return Func{}, nil, err
+	} else {
+		dataBlobs = append(dataBlobs, anonymousData...)
+	}
+
+	replacements := make(map[int]Instr)
+	if insertions == nil {
+		insertions = make(map[int]string)
+	}
+	for i, ins := range fn.Instrs {
+		if dataWords[i] {
+			continue
+		}
+		displacement, op, pcRelative, err := arm64RawPCRelativeDisplacement(ins)
+		if err != nil {
+			return Func{}, nil, err
+		}
+		if !pcRelative {
+			continue
+		}
+		switch op {
+		case "ADR", "B", "BL", "CBZ", "CBNZ", "TBZ", "TBNZ":
+			// These encodings define their displacement relative to the current
+			// instruction address.
+		case "ADRP":
+			// A zero displacement always denotes the page containing this exact
+			// instruction, independent of source layout and final link placement.
+			// Insert a boundary label at the instruction and let the ordinary ADRP
+			// lowerer page-align its blockaddress. Nonzero raw page deltas remain
+			// unsafe because source layout cannot prove their link-time target page.
+			if displacement != 0 {
+				return Func{}, nil, fmt.Errorf("ARM64 WORD PC-relative ADRP page delta %+d is not source-layout safe: %q", displacement, ins.Raw)
+			}
+		default:
+			return Func{}, nil, fmt.Errorf("ARM64 WORD PC-relative %s is not source-layout safe: %q", op, ins.Raw)
+		}
+
+		targetPoint := arm64RawLayoutPoint{
+			segment: points[i].segment,
+			offset:  points[i].offset + displacement,
+		}
+		target, ok := labels[targetPoint]
+		if !ok {
+			at, boundaryOK := boundaries[targetPoint]
+			if !boundaryOK {
+				return Func{}, nil, fmt.Errorf("ARM64 WORD PC-relative %s target %+d does not land on a proven instruction boundary: %q", op, displacement, ins.Raw)
+			}
+			if existing, exists := insertions[at]; exists {
+				target = existing
+			} else {
+				target = arm64UniqueRawTargetLabel(knownLabels, targetPoint)
+				knownLabels[target] = true
+				insertions[at] = target
+			}
+		}
+		decoded, err := decodeARM64RawWordInstructionTarget(ins, target)
+		if err != nil {
+			return Func{}, nil, err
+		}
+		replacements[i] = decoded
+	}
+
+	if len(replacements) == 0 && len(dataWords) == 0 {
+		return fn, dataBlobs, nil
+	}
+	result := fn
+	result.Instrs = make([]Instr, 0, len(fn.Instrs)+len(insertions))
+	for i, ins := range fn.Instrs {
+		if label, ok := insertions[i]; ok {
+			result.Instrs = append(result.Instrs, Instr{
+				Op:   OpLABEL,
+				Args: []Operand{{Kind: OpLabel, Sym: label}},
+				Raw:  label + ":",
+			})
+		}
+		if dataWords[i] {
+			ins.Op = arm64RawDataOp
+		} else if replacement, ok := replacements[i]; ok {
+			ins = replacement
+		}
+		result.Instrs = append(result.Instrs, ins)
+	}
+	if label, ok := insertions[len(fn.Instrs)]; ok {
+		result.Instrs = append(result.Instrs, Instr{
+			Op:   OpLABEL,
+			Args: []Operand{{Kind: OpLabel, Sym: label}},
+			Raw:  label + ":",
+		})
+	}
+	return result, dataBlobs, nil
+}
+
+// identifyARM64AnonymousData retains literal WORD islands between a
+// non-fallthrough branch and the next label (or function end). They have no
+// source label, so only a PC-relative reference could make them reachable.
+// Labeled regions are handled separately by identifyARM64RawData.
+func identifyARM64AnonymousData(fn Func, dataWords map[int]bool, labels map[string]int) ([]arm64RawDataBlob, error) {
+	for _, ins := range fn.Instrs {
+		_, _, pcRelative, err := arm64RawPCRelativeDisplacement(ins)
+		if err != nil {
+			return nil, err
+		}
+		if pcRelative {
+			return nil, nil
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind == OpMem && arg.Mem.Base == PC {
+				return nil, nil
+			}
+			if arg.Kind == OpSym && strings.Contains(arg.Sym, fn.Sym+"+") {
+				return nil, nil
+			}
+		}
+	}
+
+	var blobs []arm64RawDataBlob
+	for i := 1; i < len(fn.Instrs); {
+		if !arm64RawLiteralWord(fn.Instrs[i]) {
+			i++
+			continue
+		}
+		start := i
+		for i < len(fn.Instrs) && arm64RawLiteralWord(fn.Instrs[i]) {
+			i++
+		}
+		if !arm64RawAnonymousDataPredecessor(fn.Instrs[start-1]) ||
+			(i < len(fn.Instrs) && fn.Instrs[i].Op != OpLABEL) || dataWords[start] {
+			continue
+		}
+
+		name := fmt.Sprintf("__unreferenced_data_%d", start)
+		for {
+			if _, exists := labels[name]; !exists {
+				break
+			}
+			name += "_"
+		}
+		bytes := make([]byte, 0, 4*(i-start))
+		for j := start; j < i; j++ {
+			word := uint32(fn.Instrs[j].Args[0].Imm)
+			bytes = append(bytes, byte(word), byte(word>>8), byte(word>>16), byte(word>>24))
+			dataWords[j] = true
+		}
+		blobs = append(blobs, arm64RawDataBlob{label: name, bytes: bytes})
+	}
+	return blobs, nil
+}
+
+func arm64RawLiteralWord(ins Instr) bool {
+	return ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == ""
+}
+
+func arm64RawAnonymousDataPredecessor(ins Instr) bool {
+	if ins.Op == OpRET {
+		return true
+	}
+	op := strings.ToUpper(string(ins.Op))
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		op = op[:dot]
+	}
+	return op == "B" || op == "JMP"
+}
+
+// identifyARM64RawData recognizes generator-emitted local constant pools. The
+// characteristic form is ADR label followed later by a label and one or more
+// WORD directives. The one ADR before the first source RET is excluded: that
+// is the generated entry wrapper returning a pointer to the embedded code.
+func identifyARM64RawData(fn Func, points []arm64RawLayoutPoint, boundaries map[arm64RawLayoutPoint]int, labels map[arm64RawLayoutPoint]string, labelIndices map[string]int) (map[int]bool, []arm64RawDataBlob, error) {
+	firstReturn := len(fn.Instrs)
+	for i, ins := range fn.Instrs {
+		if ins.Op == OpRET {
+			firstReturn = i
+			break
+		}
+	}
+
+	starts := make(map[int]string)
+	codeLabels := make(map[string]bool)
+	for i, ins := range fn.Instrs {
+		displacement, op, pcRelative, err := arm64RawPCRelativeDisplacement(ins)
+		if err != nil {
+			return nil, nil, err
+		}
+		if !pcRelative {
+			continue
+		}
+		targetPoint := arm64RawLayoutPoint{segment: points[i].segment, offset: points[i].offset + displacement}
+		label, hasLabel := labels[targetPoint]
+		targetIndex, hasBoundary := boundaries[targetPoint]
+		if !hasLabel || !hasBoundary {
+			continue
+		}
+		if op != "ADR" {
+			codeLabels[label] = true
+			continue
+		}
+		// ADR may name a continuation reached through an indirect branch,
+		// not just an embedded literal pool. A label whose first instruction
+		// is not WORD is code; leave mixed WORD/non-WORD pools on the strict
+		// data path below so malformed tables cannot be silently reclassified.
+		if targetIndex < len(fn.Instrs) && fn.Instrs[targetIndex].Op != OpWORD {
+			codeLabels[label] = true
+			continue
+		}
+		// Generated entry wrappers return a pointer to the embedded routine.
+		// That ADR appears before the first source RET and points beyond it.
+		if i < firstReturn && targetIndex > firstReturn {
+			codeLabels[label] = true
+			continue
+		}
+		starts[targetIndex] = label
+	}
+	// Preserve every explicitly referenced local label as code. Raw embedded
+	// routines use PC-relative encodings handled above; source-level wrappers
+	// may use ordinary Plan 9 branch operands.
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpWORD || ins.Op == OpLABEL {
+			continue
+		}
+		for _, operand := range ins.Args {
+			var label string
+			switch operand.Kind {
+			case OpIdent:
+				label = operand.Ident
+			case OpSym:
+				label = strings.TrimSuffix(strings.TrimSuffix(operand.Sym, "(SB)"), "<>")
+			}
+			if _, exists := labelIndices[label]; exists {
+				codeLabels[label] = true
+			}
+		}
+	}
+
+	// Some generators append unreferenced metadata words (for example a mask
+	// discriminator) immediately after an unconditional terminator and before
+	// ADR-addressed tables. Classify only all-WORD label regions that cannot be
+	// reached by control flow. Once such a region starts, adjacent all-WORD
+	// labels remain data. Reachable invalid WORDs therefore still fail closed.
+	type labelRegion struct {
+		label       string
+		labelIndex  int
+		start, end  int
+		allRawWords bool
+	}
+	regions := make([]labelRegion, 0, len(labelIndices))
+	for label, labelIndex := range labelIndices {
+		start := labelIndex + 1
+		for start < len(fn.Instrs) && fn.Instrs[start].Op == OpLABEL {
+			start++
+		}
+		end := len(fn.Instrs)
+		for i := start; i < len(fn.Instrs); i++ {
+			if fn.Instrs[i].Op == OpLABEL {
+				end = i
+				break
+			}
+		}
+		allRawWords := start < end
+		for i := start; i < end && allRawWords; i++ {
+			ins := fn.Instrs[i]
+			allRawWords = ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == ""
+		}
+		regions = append(regions, labelRegion{label: label, labelIndex: labelIndex, start: start, end: end, allRawWords: allRawWords})
+	}
+	sort.Slice(regions, func(i, j int) bool { return regions[i].labelIndex < regions[j].labelIndex })
+	previousDataEnd := -1
+	for _, region := range regions {
+		if !region.allRawWords || codeLabels[region.label] {
+			previousDataEnd = -1
+			continue
+		}
+		_, alreadyData := starts[region.start]
+		followsData := previousDataEnd == region.labelIndex
+		followsTerminator := false
+		for i := region.labelIndex - 1; i >= 0; i-- {
+			if fn.Instrs[i].Op == OpLABEL {
+				continue
+			}
+			followsTerminator = arm64RawIsNonFallthroughTerminator(fn.Instrs[i])
+			break
+		}
+		if !alreadyData && !followsData && !followsTerminator {
+			previousDataEnd = -1
+			continue
+		}
+		starts[region.start] = region.label
+		previousDataEnd = region.end
+	}
+
+	dataWords := make(map[int]bool)
+	blobs := make([]arm64RawDataBlob, 0, len(starts))
+	startIndices := make([]int, 0, len(starts))
+	for start := range starts {
+		startIndices = append(startIndices, start)
+	}
+	sort.Ints(startIndices)
+	for _, start := range startIndices {
+		label := starts[start]
+		labelIndex := labelIndices[label]
+		end := len(fn.Instrs)
+		for i := labelIndex + 1; i < len(fn.Instrs); i++ {
+			if fn.Instrs[i].Op == OpLABEL {
+				end = i
+				break
+			}
+		}
+		buf := make([]byte, 0, (end-start)*4)
+		for i := start; i < end; i++ {
+			ins := fn.Instrs[i]
+			if ins.Op != OpWORD || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+				return nil, nil, fmt.Errorf("ARM64 raw data label %q contains a non-WORD directive: %q", label, ins.Raw)
+			}
+			word := uint32(ins.Args[0].Imm)
+			buf = append(buf, byte(word), byte(word>>8), byte(word>>16), byte(word>>24))
+			dataWords[i] = true
+		}
+		if len(buf) != 0 {
+			blobs = append(blobs, arm64RawDataBlob{label: label, bytes: buf})
+		}
+	}
+	return dataWords, blobs, nil
+}
+
+func arm64RawIsNonFallthroughTerminator(ins Instr) bool {
+	op := strings.ToUpper(string(ins.Op))
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		op = op[:dot]
+	}
+	if op == "RET" || op == "B" || op == "JMP" || op == "BR" {
+		return true
+	}
+	if ins.Op != OpWORD || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return false
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], uint32(ins.Args[0].Imm))
+	decoded, err := arm64asm.Decode(code[:])
+	if err != nil {
+		return false
+	}
+	switch decoded.Op.String() {
+	case "B", "BR", "RET", "ERET", "DRPS":
+		return true
+	default:
+		return false
+	}
+}
+
+func arm64RawPCRelativeDisplacement(ins Instr) (displacement int64, op string, pcRelative bool, err error) {
+	if ins.Op != OpWORD || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return 0, "", false, nil
+	}
+	word := uint32(ins.Args[0].Imm)
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	decoded, decodeErr := arm64asm.Decode(code[:])
+	if decodeErr != nil {
+		return 0, "", false, nil
+	}
+	count := 0
+	for _, arg := range decoded.Args {
+		if arg == nil {
+			break
+		}
+		if relative, ok := arg.(arm64asm.PCRel); ok {
+			displacement = int64(relative)
+			count++
+		}
+	}
+	if count == 0 {
+		return 0, decoded.Op.String(), false, nil
+	}
+	if count != 1 {
+		return 0, decoded.Op.String(), true, fmt.Errorf("ARM64 WORD %#08x has %d PC-relative operands: %q", word, count, ins.Raw)
+	}
+	return displacement, decoded.Op.String(), true, nil
+}
+
+func arm64RawKnownSourceWidth(fn Func, ins Instr) (int64, bool) {
+	if ins.arm64Encoded {
+		return 4, true // Only the actual one-WORD decoder can set this origin.
+	}
+	if bits, _ := arm64ScalarMemoryBits(arm64ControlOp(ins)); bits != 0 && len(ins.Args) == 2 {
+		// Width can be queried before the complete source normalizer. Bind
+		// its class offset to the same source TEXT/prologue, never the LLVM
+		// shadow slot's offset or an arbitrary caller-provided marker.
+		needsFrame := false
+		for _, operand := range ins.Args {
+			needsFrame = needsFrame || operand.Kind == OpFP || operand.Kind == OpMem && arm64NamedStackOffset(operand.Mem)
+		}
+		if needsFrame {
+			if !arm64SourceFrameFlagsKnown(fn) || fn.FrameSize < -8 || fn.FrameSize > (1<<31)-25 || fn.FrameSize&7 != 0 {
+				return 0, false
+			}
+			logical, autosize := int64(0), int64(0)
+			if arm64SourceGoFrame(fn).present {
+				logical, autosize = fn.FrameSize+8, arm64SourceFrameAutosize(fn.FrameSize)
+			}
+			var err error
+			ins, _, err = normalizeARM64ScalarMemoryInstruction(ins, logical, autosize)
+			if err != nil {
+				return 0, false
+			}
+		}
+	}
+	if form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins); handled {
+		if err == nil && !form.scratch {
+			return 4, true
+		}
+		return 0, false
+	}
+	if arm64RawFixedWidthLogical(ins) {
+		return 4, true
+	}
+	switch ins.Op {
+	case OpTEXT, OpLABEL, "NO_LOCAL_POINTERS", "PCDATA", "FUNCDATA":
+		return 0, true
+	case OpWORD:
+		return 4, true
+	case OpRET:
+		return arm64SourceReturnWidth(fn, ins)
+	case "B", OpJMP:
+		if arm64RawFixedWidthJumpOperand(ins, false) {
+			return 4, true
+		}
+		return 0, false
+	case "BL", OpCALL:
+		if arm64RawFixedWidthJumpOperand(ins, true) {
+			return 4, true
+		}
+		return 0, false
+	case "BCC", "BCS", "BEQ", "BGE", "BGT", "BHI", "BHS", "BLE",
+		"BLO", "BLS", "BLT", "BMI", "BNE", "BPL", "BVC", "BVS":
+		// Go 1.27's conditional-branch optab has a single C_SBRA form,
+		// always four bytes. Do not infer a width for other operand forms.
+		if len(ins.Args) == 1 {
+			switch ins.Args[0].Kind {
+			case OpIdent, OpSym:
+				return 4, true
+			case OpMem:
+				if ins.Args[0].Mem.Base == PC && ins.Args[0].Mem.Index == "" {
+					return 4, true
+				}
+			}
+		}
+		return 0, false
+	case OpMOVD:
+		if len(ins.Args) != 2 {
+			return 0, false
+		}
+		for _, arg := range ins.Args {
+			switch arg.Kind {
+			case OpReg, OpFP, OpMem:
+			default:
+				return 0, false
+			}
+		}
+		return 4, true
+	default:
+		return 0, false
+	}
+}
+
+// Go's ARM64 logical-op optab has one-word register and bitmask-immediate
+// forms, but also multiword constant-materialization forms. Only classify a
+// source instruction as four bytes when its immediate is an AArch64 logical
+// bitmask; guessing the width of the other forms would misplace raw ADR/branch
+// targets. The same AND optab covers this complete alias family and W forms.
+func arm64RawFixedWidthLogical(ins Instr) bool {
+	if form, handled, err := parseARM64GPImmediateForm(ins.Op, ins); handled && (err != nil || form.scratch) {
+		return false // A bitmask alone does not prove the destination's Go row.
+	}
+	op := strings.ToUpper(string(ins.Op))
+	switch op {
+	case "AND", "ORR", "EOR", "ANDS", "BIC", "ORN", "EON", "BICS", "TST",
+		"ANDW", "ORRW", "EORW", "ANDSW", "BICW", "ORNW", "EONW", "BICSW", "TSTW":
+	default:
+		return false
+	}
+	w32 := strings.HasSuffix(op, "W")
+	if op == "TST" || op == "TSTW" {
+		if len(ins.Args) != 2 {
+			return false
+		}
+	} else if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return false
+	}
+	source := ins.Args[0]
+	for i, arg := range ins.Args[1:] {
+		if arg.Kind != OpReg {
+			return false
+		}
+		if isARM64GeneralOrZeroReg(arg.Reg) {
+			continue
+		}
+		// The immediate optab also has a single-word C_RSP destination form.
+		last := i == len(ins.Args)-2
+		if source.Kind != OpImm || !last || (arg.Reg != SP && arg.Reg != "RSP") {
+			return false
+		}
+	}
+	switch source.Kind {
+	case OpReg:
+		return isARM64GeneralOrZeroReg(source.Reg)
+	case OpRegShift:
+		limit := int64(64)
+		if w32 {
+			limit = 32
+		}
+		return isARM64GeneralOrZeroReg(source.Reg) &&
+			source.ShiftAmount >= 0 && source.ShiftAmount < limit
+	case OpImm:
+		if source.ImmRaw != "" || source.ImmIsFloat {
+			return false
+		}
+		value := uint64(source.Imm)
+		if w32 {
+			value = uint64(uint32(value)) * 0x100000001
+		}
+		return arm64LogicalBitmaskImmediate(value)
+	default:
+		return false
+	}
+}
+
+func arm64LogicalBitmaskImmediate(value uint64) bool {
+	for width := uint(2); width <= 64; width *= 2 {
+		mask := ^uint64(0)
+		if width < 64 {
+			mask = uint64(1)<<width - 1
+		}
+		unit := value & mask
+		if unit == 0 || unit == mask {
+			continue
+		}
+		repeated := unit
+		for shift := width; shift < 64; shift *= 2 {
+			repeated |= repeated << shift
+		}
+		if repeated != value {
+			continue
+		}
+		prior := (unit<<1)&mask | unit>>(width-1)
+		starts := unit &^ prior & mask
+		if bits.OnesCount64(starts) == 1 {
+			return true
+		}
+	}
+	return false
+}
+
+// arm64RawFixedWidthJumpOperand mirrors Go 1.27's complete AB/ABL optab:
+// C_SBRA and C_ZOREG for B/JMP, plus C_ZREG for BL/CALL. Every accepted form
+// occupies one AArch64 instruction. Keeping this validation local prevents an
+// invalid or expanding pseudo-op from being guessed as four bytes.
+func arm64RawFixedWidthJumpOperand(ins Instr, link bool) bool {
+	if len(ins.Args) != 1 {
+		return false
+	}
+	operand := ins.Args[0]
+	switch operand.Kind {
+	case OpIdent, OpSym:
+		return true // C_SBRA: local or relocated branch target.
+	case OpReg:
+		return link && isARM64GeneralOrZeroReg(operand.Reg) // C_ZREG.
+	case OpMem:
+		if operand.Mem.Base == PC {
+			return operand.Mem.Index == "" // instruction-relative C_SBRA.
+		}
+		return operand.Mem.Off == 0 && operand.Mem.OffRaw == "" && operand.Mem.Index == "" &&
+			isARM64GeneralOrZeroReg(operand.Mem.Base) // C_ZOREG.
+	default:
+		return false
+	}
+}
+
+func arm64UniqueRawTargetLabel(known map[string]bool, point arm64RawLayoutPoint) string {
+	base := fmt.Sprintf("raw_pc_%d_%x", point.segment, point.offset)
+	base = strings.ReplaceAll(base, "-", "neg_")
+	for suffix := 0; ; suffix++ {
+		candidate := base
+		if suffix != 0 {
+			candidate = fmt.Sprintf("%s_%d", base, suffix)
+		}
+		if !known[candidate] {
+			return candidate
+		}
+	}
+}
diff --git a/arm64_raw_pool_affine.go b/arm64_raw_pool_affine.go
new file mode 100644
index 000000000..8903783d0
--- /dev/null
+++ b/arm64_raw_pool_affine.go
@@ -0,0 +1,556 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// Affine expressions use machine-width modular arithmetic. Keep relationships
+// such as (end-start)*8 until a dominating guard bounds end-start; bounding
+// the operands independently would discard precisely the required information.
+type arm64PoolAffine struct {
+	coefficient [31]int64
+	constant    uint64
+	relocations int64 // Unresolved common pool base; never two relocated addresses.
+}
+
+type arm64PoolInterval struct {
+	low, high uint64
+}
+
+type arm64PoolConstraint struct {
+	expression arm64PoolAffine
+	interval   arm64PoolInterval
+	mask       uint64 // Zero denotes an ordinary unmasked interval.
+	after      int    // A historical flag fact activates at this program point.
+}
+
+type arm64PoolAffineState struct {
+	at          int
+	expression  arm64PoolAffine
+	bound       arm64PoolInterval
+	constraints [8]arm64PoolConstraint
+	count       int
+}
+
+type arm64PoolAffineQuery struct {
+	at         int
+	expression arm64PoolAffine
+}
+
+var arm64PoolUnknownInterval = arm64PoolInterval{0, math.MaxUint64}
+
+func arm64PoolRegisterExpression(index int) arm64PoolAffine {
+	var expression arm64PoolAffine
+	if index < 31 {
+		expression.coefficient[index] = 1
+	}
+	return expression
+}
+
+func (expression arm64PoolAffine) isConstant() bool {
+	return expression.coefficient == [31]int64{}
+}
+
+// A complexity cap is a failed proof, never permission to accept a load. The
+// bounded coefficients also keep all host-side multiplication below int64 max.
+func (expression *arm64PoolAffine) add(other arm64PoolAffine, scale int64) bool {
+	const limit = int64(1 << 30)
+	if scale < -limit || scale > limit {
+		return false
+	}
+	relocations := expression.relocations + other.relocations*scale
+	if relocations < 0 || relocations > 1 {
+		return false
+	}
+	for n, coefficient := range other.coefficient {
+		value := expression.coefficient[n] + coefficient*scale
+		if value < -limit || value > limit {
+			return false
+		}
+		expression.coefficient[n] = value
+	}
+	expression.constant += other.constant * uint64(scale)
+	expression.relocations = relocations
+	return true
+}
+
+func (expression *arm64PoolAffine) substitute(index int, value arm64PoolAffine) bool {
+	scale := expression.coefficient[index]
+	expression.coefficient[index] = 0
+	return expression.add(value, scale)
+}
+
+// Return the exact affine image when it is one unsigned interval. An interval
+// spanning the machine wrap point cannot be represented here and stays unknown.
+func arm64PoolIntervalImage(input arm64PoolInterval, scale int64, delta uint64) arm64PoolInterval {
+	if scale == 0 {
+		return arm64PoolInterval{delta, delta}
+	}
+	abs := scale
+	if abs < 0 {
+		abs = -abs
+	}
+	if input.high-input.low > math.MaxUint64/uint64(abs) {
+		return arm64PoolUnknownInterval
+	}
+	low, high := input.low*uint64(scale)+delta, input.high*uint64(scale)+delta
+	if scale < 0 {
+		low, high = high, low
+	}
+	if low > high {
+		return arm64PoolUnknownInterval
+	}
+	return arm64PoolInterval{low, high}
+}
+
+func (expression arm64PoolAffine) constrainedBy(constraint arm64PoolConstraint) (arm64PoolInterval, bool) {
+	if constraint.mask != 0 || constraint.after != 0 {
+		return arm64PoolInterval{}, false
+	}
+	other := constraint.expression
+	var scale int64
+	found := false
+	for n, coefficient := range other.coefficient {
+		if coefficient == 0 {
+			if expression.coefficient[n] != 0 {
+				return arm64PoolInterval{}, false
+			}
+			continue
+		}
+		if !found {
+			if expression.coefficient[n]%coefficient != 0 {
+				return arm64PoolInterval{}, false
+			}
+			scale, found = expression.coefficient[n]/coefficient, true
+		}
+		if coefficient*scale != expression.coefficient[n] {
+			return arm64PoolInterval{}, false
+		}
+	}
+	if !found {
+		return arm64PoolInterval{}, false
+	}
+	if expression.relocations != other.relocations*scale {
+		return arm64PoolInterval{}, false
+	}
+	delta := expression.constant - other.constant*uint64(scale)
+	return arm64PoolIntervalImage(constraint.interval, scale, delta), true
+}
+
+func (flow *arm64RawPoolValues) boundedUpper(at int, reg arm64asm.Reg) uint64 {
+	upper := flow.upper(at, reg)
+	if flow == nil || reg < arm64asm.X0 || reg >= arm64asm.XZR || upper == 0 {
+		return upper
+	}
+	if refined := flow.affineInterval(at, arm64PoolRegisterExpression(int(reg-arm64asm.X0))).high; refined < upper {
+		return refined
+	}
+	return upper
+}
+
+// Walk all predecessor paths, substituting definitions into both the query and
+// its branch constraints. This is intentionally not a source-pattern match:
+// copies, cancellation, scaling and joins share the same expression grammar.
+// A changing cycle, unknown effect or exhausted budget makes the proof fail.
+func (flow *arm64RawPoolValues) affineInterval(at int, expression arm64PoolAffine) (answer arm64PoolInterval) {
+	// First try definitions and directly matching guards. Speculating about an
+	// independent residual at every intermediate instruction can exhaust the
+	// budget before reaching a simple dominating guard. Isolate the cheap
+	// proof's caches: its unknowns must not poison the richer fallback.
+	if flow != nil && !flow.affineDirect && len(flow.affineActive) == 0 {
+		query := arm64PoolAffineQuery{at, expression}
+		if cached, ok := flow.affineCache[query]; ok && cached != arm64PoolUnknownInterval {
+			return cached
+		}
+		direct := *flow
+		direct.clearValueCaches()
+		direct.affineDirect = true
+		if bound := direct.affineIntervalProof(at, expression); bound != arm64PoolUnknownInterval {
+			if flow.affineCache == nil {
+				flow.affineCache = make(map[arm64PoolAffineQuery]arm64PoolInterval)
+			}
+			flow.affineCache[query] = bound
+			flow.affineWork = direct.affineWork
+			return bound
+		}
+	}
+	return flow.affineIntervalProof(at, expression)
+}
+
+func (flow *arm64RawPoolValues) affineIntervalProof(at int, expression arm64PoolAffine) (answer arm64PoolInterval) {
+	if flow == nil || at < 0 || at >= len(flow.before) {
+		return arm64PoolUnknownInterval
+	}
+	flow.beginAffineProof()
+	query := arm64PoolAffineQuery{at, expression}
+	if cached, ok := flow.affineCache[query]; ok {
+		return cached
+	}
+	if flow.affineActive[query] || len(flow.affineActive) >= 32 {
+		return arm64PoolUnknownInterval
+	}
+	if flow.affineActive == nil {
+		flow.affineActive = make(map[arm64PoolAffineQuery]bool)
+		flow.affineCache = make(map[arm64PoolAffineQuery]arm64PoolInterval)
+	}
+	flow.affineActive[query] = true
+	defer func() {
+		delete(flow.affineActive, query)
+		flow.affineCache[query] = answer
+	}()
+	var sets arm64PoolAffineStateSets
+	initial := arm64PoolAffineState{at: at, expression: expression, bound: arm64PoolUnknownInterval}
+	queue := []arm64PoolAffineStateKey{sets.compact(&initial)}
+	visited := make(map[arm64PoolAffineStateKey]bool)
+	result, found := arm64PoolInterval{math.MaxUint64, 0}, false
+	addResult := func(value arm64PoolInterval) {
+		if value.low < result.low {
+			result.low = value.low
+		}
+		if value.high > result.high {
+			result.high = value.high
+		}
+		found = true
+	}
+	for steps := 0; len(queue) > 0; steps++ {
+		if steps >= 4096 || flow.affineWork >= 16384 {
+			return arm64PoolUnknownInterval
+		}
+		flow.affineWork++
+		key := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+		if visited[key] {
+			continue
+		}
+		visited[key] = true
+		state := sets.expand(key)
+		invariantLatch, invariantLoop := flow.rewindInvariantLoop(&state)
+		if constraint, ok := flow.loopBounds[state.at]; ok && !invariantLoop {
+			value, bounded := flow.affineConstraintBound(state.at, state.expression, constraint)
+			if !bounded || value == arm64PoolUnknownInterval {
+				value, bounded = flow.carriedLoopBound(state.at, state.expression, constraint)
+			}
+			if bounded && value != arm64PoolUnknownInterval {
+				if state.bound.low > value.low {
+					value.low = state.bound.low
+				}
+				if state.bound.high < value.high {
+					value.high = state.bound.high
+				}
+				if value.low <= value.high {
+					addResult(value)
+				}
+				continue
+			}
+		}
+		// Substitution can expose a stable origin after cancelling a transient
+		// index. Resolve that complete expression without accumulating unrelated
+		// loop predicates. The invariant proof preserves relocation cardinality
+		// and unions all entries, including separate ADRs of the same pool.
+		mask := state.expression.registerMask()
+		if !flow.affineDirect && len(flow.poolOrigins) != 0 && mask != 0 && mask&(mask-1) == 0 {
+			if invariant := flow.invariantInterval(state.at, state.expression); invariant != arm64PoolUnknownInterval {
+				if invariant.low < state.bound.low {
+					invariant.low = state.bound.low
+				}
+				if invariant.high > state.bound.high {
+					invariant.high = state.bound.high
+				}
+				if invariant.low <= invariant.high {
+					addResult(invariant)
+				}
+				continue
+			}
+		}
+		impossible := false
+		bound := state.bound
+		for n, constraint := range state.constraints[:state.count] {
+			if constraint.after != 0 {
+				if state.at != constraint.after {
+					continue
+				}
+				constraint.after = 0
+				state.constraints[n] = constraint
+			}
+			constraint = arm64PoolTightenConstraint(constraint, state.constraints[:state.count])
+			if constraint.interval.low > constraint.interval.high {
+				impossible = true
+				continue
+			}
+			if constraint.expression.isConstant() {
+				value := constraint.expression.constant
+				if constraint.mask != 0 {
+					value &= constraint.mask
+				}
+				impossible = impossible || value < constraint.interval.low || value > constraint.interval.high
+			}
+			if value, ok := flow.affineConstraintBound(state.at, state.expression, constraint); ok {
+				if value.low > bound.low {
+					bound.low = value.low
+				}
+				if value.high < bound.high {
+					bound.high = value.high
+				}
+			}
+		}
+		if impossible || bound.low > bound.high || !arm64PoolConstraintsFeasible(state.constraints[:state.count]) {
+			continue
+		}
+		state.compactConstraints()
+		state.bound = bound
+		if state.expression.isConstant() {
+			if value := state.expression.constant; value >= bound.low && value <= bound.high {
+				addResult(arm64PoolInterval{value, value})
+			}
+			continue
+		}
+		if bound.low == bound.high {
+			addResult(bound)
+			continue
+		}
+		if state.at < 0 || len(flow.before[state.at]) == 0 {
+			addResult(bound)
+			continue
+		}
+	predecessors:
+		for _, previous := range flow.before[state.at] {
+			if invariantLoop && previous == invariantLatch {
+				continue
+			}
+			if previous < 0 {
+				addResult(bound)
+				continue
+			}
+			if flow.opaque[previous] {
+				addResult(bound)
+				continue
+			}
+			next := state
+			next.at = previous
+			if constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{previous, state.at}); ok {
+				if !next.addConstraint(constraint) {
+					return arm64PoolUnknownInterval
+				}
+			}
+			word := flow.words[previous]
+			writes, known := flow.gpWrites(word)
+			if !known {
+				addResult(bound)
+				continue
+			}
+			if writes&next.expression.registerMask() != 0 {
+				if savedAt, saved, ok := flow.rewindStackLoad(previous, next.expression); ok {
+					// The proof rebases all queried values, not all predicates.
+					// Forget historical path facts rather than applying them to
+					// unrelated register values at the earlier save.
+					savedState := arm64PoolAffineState{
+						at: savedAt, expression: saved, bound: next.bound,
+					}
+					queue = append(queue, sets.compact(&savedState))
+					continue
+				}
+			}
+			destination, value, affine := flow.affineDefinition(word)
+			if offset, origin := flow.poolOrigins[previous]; origin && word&0x9f000000 == 0x10000000 {
+				index := int(word & 31)
+				// An offset proof may replace one occurrence of the relocation
+				// origin, never a sum of two aliases. The latter changes by
+				// twice the relocation distance, even when its numeric offset
+				// would happen to fit in the blob. Guards must not observe it.
+				coefficient := next.expression.coefficient[index]
+				if coefficient != 0 && coefficient != 1 {
+					return arm64PoolUnknownInterval
+				}
+				for _, constraint := range next.constraints[:next.count] {
+					if constraint.after == 0 && constraint.expression.coefficient[index] != 0 {
+						return arm64PoolUnknownInterval
+					}
+				}
+				destination, value, affine = int(word&31), arm64PoolAffine{constant: offset, relocations: 1}, true
+			}
+			// An earlier index proof may already have resolved this mask. Reuse
+			// that exact numeric definition for predicates too: folding the
+			// query must not erase a later comparison with the same result.
+			if constant, cached := flow.maskConstants[previous]; !affine && cached {
+				destination, value, affine = int(word&31), arm64PoolAffine{constant: constant}, true
+			}
+			if !affine && writes&next.expression.registerMask() != 0 {
+				// Resolve a non-affine mask only when it defines the queried
+				// value. An unrelated masked predicate may be forgotten below;
+				// recursively proving it must not consume the address's budget.
+				interval, bounded := flow.affineMaskInterval(previous, word)
+				if bounded && interval.low != interval.high {
+					// A partial mask may still subtract only fixed bits. Keep
+					// that relation instead of replacing it by an independent range.
+					value, _, affine, _ = flow.affineLogicalDefinition(previous, word)
+				}
+				if !bounded {
+					interval, bounded = flow.affineMoveKeepInterval(previous, word)
+				}
+				if !bounded {
+					value, interval, affine, bounded = flow.affineLogicalDefinition(previous, word)
+				}
+				if !bounded {
+					interval, bounded = flow.affineDivisionInterval(previous, word, next.constraints[:next.count])
+				}
+				if bounded {
+					destination = int(word & 31)
+					if interval.low == interval.high {
+						value, affine = arm64PoolAffine{constant: interval.low}, true
+					}
+					constraint := arm64PoolConstraint{
+						expression: arm64PoolRegisterExpression(destination), interval: interval,
+					}
+					// Intersect before a negative displacement or scale can
+					// wrap the interval image, e.g. (n & 7) != 0 then n-1.
+					constraint = arm64PoolTightenConstraint(constraint, next.constraints[:next.count])
+					if constraint.interval.low > constraint.interval.high {
+						continue predecessors
+					}
+					if span, ok := flow.affineConstraintBound(previous, next.expression, constraint); ok {
+						if span.low > next.bound.low {
+							next.bound.low = span.low
+						}
+						if span.high < next.bound.high {
+							next.bound.high = span.high
+						}
+					}
+					if next.bound.low > next.bound.high {
+						continue predecessors
+					}
+				}
+				if !affine && next.bound.low != next.bound.high {
+					if span, ok := flow.maskedDifferenceBound(previous, word, next.expression, next.constraints[:next.count]); ok {
+						if span.low > next.bound.low {
+							next.bound.low = span.low
+						}
+						if span.high < next.bound.high {
+							next.bound.high = span.high
+						}
+						if next.bound.low > next.bound.high {
+							continue predecessors
+						}
+					}
+				}
+			}
+			for index := 0; index < 31; index++ {
+				if writes&(1<<uint(index)) == 0 {
+					continue
+				}
+				if affine && index == destination {
+					if !next.expression.substitute(index, value) {
+						return arm64PoolUnknownInterval
+					}
+				} else if next.expression.coefficient[index] != 0 {
+					addResult(next.bound)
+					continue predecessors
+				}
+				count := 0
+				for _, constraint := range next.constraints[:next.count] {
+					if constraint.after == 0 && constraint.expression.coefficient[index] != 0 {
+						if !affine || index != destination {
+							replaced, ok := arm64PoolShiftConstraint(word, constraint)
+							if !ok {
+								continue
+							}
+							constraint = replaced
+						} else if !constraint.expression.substitute(index, value) {
+							continue // Forget this fact, never the queried value.
+						}
+					}
+					next.constraints[count] = constraint
+					count++
+				}
+				for n := count; n < next.count; n++ {
+					next.constraints[n] = arm64PoolConstraint{}
+				}
+				next.count = count
+			}
+			queue = append(queue, sets.compact(&next))
+		}
+	}
+	if !found {
+		return arm64PoolUnknownInterval
+	}
+	return result
+}
+
+func arm64PoolAffineDefinition(word uint32) (int, arm64PoolAffine, bool) {
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	destination := int(word & 31)
+	if err != nil {
+		return 0, arm64PoolAffine{}, false
+	}
+	if base, delta, ok := arm64PoolLoadWriteback(ins, word); ok {
+		value := arm64PoolRegisterExpression(base)
+		value.constant = uint64(delta)
+		return base, value, true
+	}
+	if destination == 31 {
+		return 0, arm64PoolAffine{}, false
+	}
+	var value arm64PoolAffine
+	if ins.Op == arm64asm.MOV {
+		switch source := ins.Args[1].(type) {
+		case arm64asm.Imm:
+			value.constant = uint64(source.Imm)
+		case arm64asm.Imm64:
+			value.constant = source.Imm
+		case arm64asm.Reg:
+			if source < arm64asm.X0 || source > arm64asm.XZR {
+				if source != arm64asm.WZR {
+					return 0, value, false
+				}
+			} else {
+				value = arm64PoolRegisterExpression(int(source - arm64asm.X0))
+			}
+		default:
+			return 0, value, false
+		}
+		return destination, value, true
+	}
+	if word>>31 == 0 {
+		return 0, value, false // A W write truncates, rather than preserving X arithmetic.
+	}
+	if ins.Op == arm64asm.LSL {
+		shift, ok := ins.Args[2].(arm64asm.Imm)
+		if source, reg := ins.Args[1].(arm64asm.Reg); ok && reg && shift.Imm <= 30 && source >= arm64asm.X0 && source <= arm64asm.XZR {
+			valid := value.add(arm64PoolRegisterExpression(int(source-arm64asm.X0)), int64(1)<<shift.Imm)
+			return destination, value, valid
+		}
+	}
+	switch ins.Op {
+	case arm64asm.ADD, arm64asm.ADDS, arm64asm.SUB, arm64asm.SUBS, arm64asm.NEG, arm64asm.NEGS:
+		// NEG/NEGS are SUB/SUBS with a zero-register first operand. The
+		// decoder chooses the alias, but its modular affine effect is shared.
+	default:
+		return 0, value, false
+	}
+	base := int(word >> 5 & 31)
+	value = arm64PoolRegisterExpression(base)
+	scale := int64(1)
+	if word&(1<<30) != 0 {
+		scale = -1
+	}
+	switch {
+	case word&0x1f800000 == 0x11000000 && base != 31:
+		immediate := uint64(word >> 10 & 4095)
+		if word&(1<<22) != 0 {
+			immediate <<= 12
+		}
+		value.constant = immediate * uint64(scale)
+	case word&0x1f200000 == 0x0b000000 && word>>22&3 == 0 && word>>10&63 <= 30:
+		scale *= int64(1) << (word >> 10 & 63)
+		if !value.add(arm64PoolRegisterExpression(int(word>>16&31)), scale) {
+			return 0, value, false
+		}
+	default:
+		return 0, value, false
+	}
+	return destination, value, true
+}
diff --git a/arm64_raw_pool_affine_guard.go b/arm64_raw_pool_affine_guard.go
new file mode 100644
index 000000000..5bd8935fc
--- /dev/null
+++ b/arm64_raw_pool_affine_guard.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import "math"
+
+func (state *arm64PoolAffineState) addConstraint(constraint arm64PoolConstraint) bool {
+	for n := 0; n < state.count; n++ {
+		previous := &state.constraints[n]
+		if previous.expression != constraint.expression || previous.mask != constraint.mask || previous.after != constraint.after {
+			continue
+		}
+		if constraint.interval.low > previous.interval.low {
+			previous.interval.low = constraint.interval.low
+		}
+		if constraint.interval.high < previous.interval.high {
+			previous.interval.high = constraint.interval.high
+		}
+		return true
+	}
+	if state.count == len(state.constraints) {
+		return false
+	}
+	state.constraints[state.count] = constraint
+	state.count++
+	return true
+}
+
+// Called only after infeasible constants have been rejected. Satisfied constant
+// guards are tautologies, and substitution may make different guards identical.
+// Neither should consume the small budget for still-symbolic path predicates.
+func (state *arm64PoolAffineState) compactConstraints() {
+	count := state.count
+	state.count = 0
+	for _, constraint := range state.constraints[:count] {
+		if constraint.after != 0 || !constraint.expression.isConstant() {
+			state.addConstraint(constraint)
+		}
+	}
+	for n := state.count; n < count; n++ {
+		state.constraints[n] = arm64PoolConstraint{}
+	}
+}
+
+func (flow *arm64RawPoolValues) affineEdgeConstraint(edge arm64RawPoolEdge) (arm64PoolConstraint, bool) {
+	var constraint arm64PoolConstraint
+	word := flow.words[edge.from]
+	if word&0xfe000000 == 0xb4000000 { // CBZ/CBNZ X: W does not bound the high bits.
+		target := edge.from + int(int32(word<<8)>>13)
+		if target == edge.from+1 || edge.to != target && edge.to != edge.from+1 {
+			return constraint, false
+		}
+		constraint.expression = arm64PoolRegisterExpression(int(word & 31))
+		if (edge.to == target) == (word&(1<<24) != 0) {
+			constraint.interval = arm64PoolInterval{1, math.MaxUint64}
+		}
+		return constraint, true
+	}
+	if word&0x7e000000 == 0x36000000 { // TBZ/TBNZ, including W views of low bits.
+		target := edge.from + int(int32(word<<13)>>18)
+		if target == edge.from+1 || edge.to != target && edge.to != edge.from+1 {
+			return constraint, false
+		}
+		bit := word>>19&31 | word>>31<<5
+		constraint.expression = arm64PoolRegisterExpression(int(word & 31))
+		constraint.mask = uint64(1) << bit
+		if (edge.to == target) == (word&(1<<24) != 0) {
+			constraint.interval = arm64PoolInterval{constraint.mask, constraint.mask}
+		}
+		return constraint, true
+	}
+	if word&0xff000010 != 0x54000000 {
+		return constraint, false
+	}
+	target := edge.from + int(int32(word<<8)>>13)
+	if target == edge.from+1 || edge.to != target && edge.to != edge.from+1 {
+		return constraint, false
+	}
+	compare, clobbered, after, ok := flow.affineFlagSourceBefore(edge.from)
+	if !ok {
+		return constraint, false
+	}
+	condition := word & 15
+	if edge.to != target {
+		condition ^= 1
+	}
+	// Z describes the modular arithmetic result, including register CMP/CMN
+	// and a retained ADDS/SUBS result. A retained result is a post-instruction
+	// register; CMP/CMN leave their input registers unchanged.
+	if condition <= 1 {
+		if compare&31 != 31 {
+			constraint.expression = arm64PoolRegisterExpression(int(compare & 31))
+		} else {
+			_, expression, valid := arm64PoolAffineDefinition(compare &^ ((1 << 29) | 31))
+			if !valid {
+				return constraint, false
+			}
+			constraint.expression = expression
+		}
+		if constraint.expression.registerMask()&clobbered != 0 {
+			constraint.after = after
+		}
+		if condition == 1 {
+			constraint.interval = arm64PoolInterval{1, math.MaxUint64}
+		}
+		return constraint, true
+	}
+	// A register limit must be an independently proved numeric constant at
+	// the comparison, not a later value or a relocated pool offset.
+	register, immediate, subtract, valid := flow.compareConstant(compare, after-1)
+	if !valid {
+		return constraint, false
+	}
+	constraint.expression = arm64PoolRegisterExpression(register)
+	if constraint.expression.registerMask()&clobbered != 0 {
+		constraint.after = after
+	}
+	constraint.interval = arm64PoolUnknownInterval
+	if !subtract { // CMN: C is the carry out of unsigned addition.
+		if immediate == 0 {
+			return constraint, false
+		}
+		// For a nonzero constant, carry and zero have the same unsigned
+		// conditions as CMP against its modular negation.
+		immediate = -immediate
+	}
+	switch condition {
+	case 0:
+		constraint.interval = arm64PoolInterval{immediate, immediate}
+	case 2:
+		constraint.interval.low = immediate
+	case 3:
+		if immediate == 0 {
+			return constraint, false
+		}
+		constraint.interval.high = immediate - 1
+	case 8:
+		if immediate == math.MaxUint64 {
+			return constraint, false
+		}
+		constraint.interval.low = immediate + 1
+	case 9:
+		constraint.interval.high = immediate
+	default:
+		return constraint, false
+	}
+	return constraint, true
+}
+
+// affineFlagSourceBefore already validated the CMP/CMN encoding with the
+// architecture decoder. Cover its immediate, shifted-register and extended-
+// register operand classes. SP and W comparisons stay outside this X domain.
+func (flow *arm64RawPoolValues) compareConstant(word uint32, at int) (register int, value uint64, subtract, ok bool) {
+	register, subtract = int(word>>5&31), word&(1<<30) != 0
+	if register == 31 {
+		return
+	}
+	if word&0xbf80001f == 0xb100001f {
+		value = uint64(word >> 10 & 4095)
+		if word&(1<<22) != 0 {
+			value <<= 12
+		}
+		ok = true
+		return
+	}
+	if word&0xbf00001f != 0xab00001f {
+		return
+	}
+	numeric := flow.numericValues()
+	bound := numeric.invariantInterval(at, arm64PoolRegisterExpression(int(word>>16&31)))
+	flow.affineWork = numeric.affineWork
+	if bound.low != bound.high {
+		return
+	}
+	value = bound.low
+	if word&(1<<21) == 0 {
+		shift := word >> 10 & 63
+		switch word >> 22 & 3 {
+		case 0:
+			value <<= shift
+		case 1:
+			value >>= shift
+		case 2:
+			value = uint64(int64(value) >> shift)
+		default:
+			return
+		}
+	} else {
+		width := uint32(8) << (word >> 13 & 3)
+		value <<= 64 - width
+		if word&(1<<15) != 0 {
+			value = uint64(int64(value) >> (64 - width))
+		} else {
+			value >>= 64 - width
+		}
+		value <<= word >> 10 & 7
+	}
+	ok = true
+	return
+}
+
+// A tested bit can exclude a path only when another reaching guard proves
+// that bit's value for the entire interval. Testing a low W bit never bounds
+// the untested high bits of X. Keep both facts until definitions normalize
+// their expressions; this retains path information across arithmetic aliases.
+func arm64PoolConstraintsFeasible(constraints []arm64PoolConstraint) bool {
+	for _, test := range constraints {
+		if test.mask == 0 || test.after != 0 {
+			continue
+		}
+		input := arm64PoolUnknownInterval
+		for _, constraint := range constraints {
+			if value, ok := test.expression.constrainedBy(constraint); ok {
+				if value.low > input.low {
+					input.low = value.low
+				}
+				if value.high < input.high {
+					input.high = value.high
+				}
+			}
+		}
+		if input.low > input.high {
+			return false
+		}
+		masked := arm64PoolMaskInterval(input, test.mask)
+		if masked.high < test.interval.low || masked.low > test.interval.high {
+			return false
+		}
+	}
+	return true
+}
+
+// Intersect guards before projecting through scaled or negative offsets.
+// Separate images can each straddle the unsigned wrap point even when the
+// intersection has one small, non-wrapping image, e.g. 8 <= n <= 15 and 8*n-64.
+func arm64PoolTightenConstraint(target arm64PoolConstraint, constraints []arm64PoolConstraint) arm64PoolConstraint {
+	if target.mask != 0 || target.after != 0 {
+		return target
+	}
+	for _, constraint := range constraints {
+		if value, ok := target.expression.constrainedBy(constraint); ok {
+			if value.low > target.interval.low {
+				target.interval.low = value.low
+			}
+			if value.high < target.interval.high {
+				target.interval.high = value.high
+			}
+		}
+	}
+	return target
+}
diff --git a/arm64_raw_pool_affine_mask.go b/arm64_raw_pool_affine_mask.go
new file mode 100644
index 000000000..79cf7afbc
--- /dev/null
+++ b/arm64_raw_pool_affine_mask.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math"
+	"math/bits"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// AND is not affine. Keep its interval even when it is not an exact value.
+// Only an exact result, such as [8,15] & 24 == 8, permits constant substitution.
+func (flow *arm64RawPoolValues) affineMaskInterval(at int, word uint32) (arm64PoolInterval, bool) {
+	if word&0xff800000 != 0x92000000 { // AND Xd, Xn, logical immediate.
+		return arm64PoolInterval{}, false
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil || ins.Op != arm64asm.AND {
+		return arm64PoolInterval{}, false
+	}
+	source, ok := ins.Args[1].(arm64asm.Reg)
+	if !ok || source < arm64asm.X0 || source > arm64asm.XZR {
+		return arm64PoolInterval{}, false
+	}
+	var mask uint64
+	switch operand := ins.Args[2].(type) {
+	case arm64asm.Imm:
+		mask = uint64(operand.Imm)
+	case arm64asm.Imm64:
+		mask = operand.Imm
+	default:
+		return arm64PoolInterval{}, false
+	}
+	if flow.maskConstants == nil {
+		flow.maskConstants = make(map[int]uint64)
+	}
+	input := flow.integerInterval(at, source)
+	if input.low > input.high {
+		return arm64PoolUnknownInterval, false
+	}
+	result := arm64PoolMaskInterval(input, mask)
+	if result.low == result.high {
+		flow.maskConstants[at] = result.low
+	}
+	return result, true
+}
+
+func arm64PoolMaskInterval(input arm64PoolInterval, mask uint64) arm64PoolInterval {
+	if input.low > input.high {
+		return arm64PoolUnknownInterval
+	}
+	// Partition into aligned power-of-two blocks. Each block has independent
+	// low bits, so its masked extrema are exact. Union at most 128 blocks;
+	// treating every bit below the endpoints' common prefix as free would
+	// incorrectly include zero in [8,19] & 24 and lose loop termination proof.
+	result := arm64PoolInterval{math.MaxUint64, 0}
+	for low := input.low; ; {
+		remaining := input.high - low
+		width := bits.TrailingZeros64(low)
+		if remaining != math.MaxUint64 {
+			if available := bits.Len64(remaining+1) - 1; available < width {
+				width = available
+			}
+		}
+		varying := uint64(1)<<uint(width) - 1
+		if minimum := low & mask; minimum < result.low {
+			result.low = minimum
+		}
+		if maximum := (low | varying) & mask; maximum > result.high {
+			result.high = maximum
+		}
+		if varying == remaining {
+			return result
+		}
+		low += varying + 1
+	}
+}
diff --git a/arm64_raw_pool_affine_residual.go b/arm64_raw_pool_affine_residual.go
new file mode 100644
index 000000000..4667b5cc7
--- /dev/null
+++ b/arm64_raw_pool_affine_residual.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "math"
+
+// q = scale*guard + remainder. The remainder can be an independent bounded
+// value, notably the relocated pool origin. Prove it at this exact program
+// point rather than treating an unrelated register as a constant by name.
+func (flow *arm64RawPoolValues) affineConstraintBound(at int, query arm64PoolAffine, constraint arm64PoolConstraint) (arm64PoolInterval, bool) {
+	if constraint.mask != 0 || constraint.after != 0 {
+		return arm64PoolInterval{}, false
+	}
+	if bound, ok := query.constrainedBy(constraint); ok {
+		return bound, true
+	}
+	if flow.affineDirect {
+		return arm64PoolInterval{}, false
+	}
+	// An almost-full-width NE/range guard cannot independently bound a pool
+	// footprint through an unrelated residual. Recursing on it repeatedly
+	// consumes the shared budget in loops. Keep the direct fact above, and
+	// defer decomposition until guard intersection narrows the interval.
+	if constraint.interval.high-constraint.interval.low > math.MaxInt64 {
+		return arm64PoolInterval{}, false
+	}
+	for index, coefficient := range constraint.expression.coefficient {
+		if coefficient == 0 || query.coefficient[index] == 0 || query.coefficient[index]%coefficient != 0 {
+			continue
+		}
+		scale := query.coefficient[index] / coefficient
+		remainder := query
+		if !remainder.add(constraint.expression, -scale) {
+			continue
+		}
+		// The eliminated coefficient makes this a strictly different query.
+		// Recursive proof budgets and active-query detection still apply.
+		residual := flow.invariantInterval(at, remainder)
+		if residual == arm64PoolUnknownInterval {
+			// If only part of the guard was eliminated, recursively bounding
+			// its remaining operands chases the same dependency cycle. A known
+			// invariant above is fine; otherwise defer until definitions have
+			// normalized all guard operands out of the remainder.
+			if remainder.registerMask()&constraint.expression.registerMask() != 0 {
+				continue
+			}
+			residual = flow.affineInterval(at, remainder)
+		}
+		if residual == arm64PoolUnknownInterval {
+			continue
+		}
+		bound := arm64PoolIntervalImage(constraint.interval, scale, residual.low)
+		width := residual.high - residual.low
+		if bound.high > math.MaxUint64-width {
+			continue
+		}
+		bound.high += width
+		return bound, true
+	}
+	return arm64PoolInterval{}, false
+}
diff --git a/arm64_raw_pool_affine_state.go b/arm64_raw_pool_affine_state.go
new file mode 100644
index 000000000..9734beb3e
--- /dev/null
+++ b/arm64_raw_pool_affine_state.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+// Transfer helpers still receive the complete value state. Only this proof's
+// queue and visited table use an exact, query-local constraint-set identity.
+type arm64PoolAffineStateKey struct {
+	at         int
+	expression arm64PoolAffine
+	bound      arm64PoolInterval
+	set        int
+	count      int
+}
+
+// A bucket is not a constraint identity. Omitting coefficients makes the lookup
+// smaller, but all candidates still require complete array equality below.
+// Inactive slots, ordering and historical flag positions remain significant.
+type arm64PoolConstraintBucket [8]struct {
+	constant    uint64
+	relocations int64
+	interval    arm64PoolInterval
+	mask        uint64
+	after       int
+}
+
+func arm64PoolConstraintBucketFor(constraints *[8]arm64PoolConstraint) arm64PoolConstraintBucket {
+	var bucket arm64PoolConstraintBucket
+	for n := range constraints {
+		constraint := &constraints[n]
+		bucket[n].constant = constraint.expression.constant
+		bucket[n].relocations = constraint.expression.relocations
+		bucket[n].interval = constraint.interval
+		bucket[n].mask = constraint.mask
+		bucket[n].after = constraint.after
+	}
+	return bucket
+}
+
+type arm64PoolAffineStateSets struct {
+	sets    [][8]arm64PoolConstraint
+	buckets map[arm64PoolConstraintBucket][]int
+}
+
+func (sets *arm64PoolAffineStateSets) identity(constraints *[8]arm64PoolConstraint) int {
+	// Zero is the exact all-zero array, not merely an empty active prefix.
+	if *constraints == [8]arm64PoolConstraint{} {
+		return 0
+	}
+	bucket := arm64PoolConstraintBucketFor(constraints)
+	for _, identity := range sets.buckets[bucket] {
+		if sets.sets[identity-1] == *constraints {
+			return identity
+		}
+	}
+	if sets.buckets == nil {
+		sets.buckets = make(map[arm64PoolConstraintBucket][]int)
+	}
+	// Copy the entire array. A later transfer cannot mutate a stored set or any
+	// previously queued/visited state, and expansion returns another value copy.
+	sets.sets = append(sets.sets, *constraints)
+	identity := len(sets.sets)
+	sets.buckets[bucket] = append(sets.buckets[bucket], identity)
+	return identity
+}
+
+func (sets *arm64PoolAffineStateSets) compact(state *arm64PoolAffineState) arm64PoolAffineStateKey {
+	return arm64PoolAffineStateKey{
+		at: state.at, expression: state.expression, bound: state.bound,
+		set: sets.identity(&state.constraints), count: state.count,
+	}
+}
+
+func (sets *arm64PoolAffineStateSets) expand(key arm64PoolAffineStateKey) arm64PoolAffineState {
+	state := arm64PoolAffineState{
+		at: key.at, expression: key.expression, bound: key.bound, count: key.count,
+	}
+	if key.set != 0 {
+		state.constraints = sets.sets[key.set-1]
+	}
+	return state
+}
diff --git a/arm64_raw_pool_affine_state_test.go b/arm64_raw_pool_affine_state_test.go
new file mode 100644
index 000000000..ca64867a4
--- /dev/null
+++ b/arm64_raw_pool_affine_state_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"math/rand"
+	"testing"
+	"unsafe"
+)
+
+func TestARM64PoolAffineQueueAndVisitedAvoidFullConstraintCopies(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "arm64_raw_pool_affine.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof *ast.FuncDecl
+	for _, decl := range file.Decls {
+		if function, ok := decl.(*ast.FuncDecl); ok && function.Name.Name == "affineIntervalProof" {
+			proof = function
+		}
+	}
+	if proof == nil {
+		t.Fatal("original affine proof consumer missing")
+	}
+	ast.Inspect(proof.Body, func(node ast.Node) bool {
+		var element ast.Expr
+		switch typed := node.(type) {
+		case *ast.ArrayType:
+			element = typed.Elt
+		case *ast.MapType:
+			element = typed.Key
+		}
+		if ident, ok := element.(*ast.Ident); ok && ident.Name == "arm64PoolAffineState" {
+			t.Error("queue/visited still copy the complete eight-constraint transfer state")
+		}
+		return true
+	})
+}
+
+func TestARM64PoolAffineStateExactRoundtrip(t *testing.T) {
+	var sets arm64PoolAffineStateSets
+	random := rand.New(rand.NewSource(17))
+	for n := 0; n < 128; n++ {
+		state := arm64PoolAffineState{
+			at: n - 1, expression: arm64PoolRegisterExpression(n % 31),
+			bound: arm64PoolInterval{uint64(n), uint64(n + 32)}, count: n % 9,
+		}
+		for slot := range state.constraints {
+			constraint := &state.constraints[slot]
+			for register := range constraint.expression.coefficient {
+				constraint.expression.coefficient[register] = random.Int63() - random.Int63()
+			}
+			constraint.expression.constant = random.Uint64()
+			constraint.expression.relocations = random.Int63()
+			constraint.interval = arm64PoolInterval{random.Uint64(), random.Uint64()}
+			constraint.mask, constraint.after = random.Uint64(), n-slot
+		}
+		key := sets.compact(&state)
+		if actual := sets.expand(key); actual != state {
+			t.Fatalf("full state changed in roundtrip %d", n)
+		}
+		if repeated := sets.compact(&state); repeated != key {
+			t.Fatalf("equal state acquired another key in roundtrip %d", n)
+		}
+	}
+	if compact, full := unsafe.Sizeof(arm64PoolAffineStateKey{}), unsafe.Sizeof(arm64PoolAffineState{}); compact >= full/2 {
+		t.Fatalf("queue key still carries full constraint storage: compact=%d full=%d", compact, full)
+	}
+}
+
+func TestARM64PoolAffineStateCompleteArrayIdentity(t *testing.T) {
+	for count := 0; count <= 8; count++ {
+		t.Run(string(rune('0'+count)), func(t *testing.T) {
+			var sets arm64PoolAffineStateSets
+			original := arm64PoolAffineState{count: count}
+			originalKey := sets.compact(&original)
+			for slot := 0; slot < 8; slot++ {
+				for field := 0; field < 37; field++ {
+					changed := original
+					constraint := &changed.constraints[slot]
+					switch {
+					case field < 31:
+						constraint.expression.coefficient[field] = -1
+					case field == 31:
+						constraint.expression.constant = 1 << 63
+					case field == 32:
+						constraint.expression.relocations = 1
+					case field == 33:
+						constraint.interval.low = 3
+					case field == 34:
+						constraint.interval.high = 7
+					case field == 35:
+						constraint.mask = 15
+					case field == 36:
+						constraint.after = -4
+					}
+					key := sets.compact(&changed)
+					if key == originalKey || sets.expand(key) != changed {
+						t.Fatalf("active/inactive field lost: count=%d slot=%d field=%d", count, slot, field)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PoolAffineStateForcedBucketCollisionAndOwnership(t *testing.T) {
+	var sets arm64PoolAffineStateSets
+	first := arm64PoolAffineState{count: 1}
+	first.constraints[0].expression.coefficient[0] = 1
+	second := first
+	second.constraints[0].expression.coefficient[30] = -1
+	if arm64PoolConstraintBucketFor(&first.constraints) != arm64PoolConstraintBucketFor(&second.constraints) {
+		t.Fatal("fixture did not force the same lookup key/hash")
+	}
+	firstKey, secondKey := sets.compact(&first), sets.compact(&second)
+	if firstKey == secondKey || len(sets.buckets) != 1 || len(sets.sets) != 2 {
+		t.Fatal("colliding unequal complete arrays merged")
+	}
+	if sets.expand(firstKey) != first || sets.expand(secondKey) != second {
+		t.Fatal("collision replaced an earlier complete array")
+	}
+	copy := sets.expand(firstKey)
+	copy.constraints[0].after = 17
+	if sets.expand(firstKey) != first || sets.compact(&first) != firstKey {
+		t.Fatal("expanded value aliases private stored constraints")
+	}
+	first.constraints[0].mask = 31
+	if sets.expand(firstKey).constraints[0].mask != 0 {
+		t.Fatal("input value aliases private stored constraints")
+	}
+	var other arm64PoolAffineStateSets
+	otherKey := other.compact(&second)
+	if otherKey.set != 1 || other.expand(otherKey) != second || sets.expand(firstKey) == second {
+		t.Fatal("query-local identities leaked across proof invocations")
+	}
+}
+
+func TestARM64PoolAffineStateVisitedEqualityMatchesFullState(t *testing.T) {
+	var sets arm64PoolAffineStateSets
+	full := make(map[arm64PoolAffineState]bool)
+	compact := make(map[arm64PoolAffineStateKey]bool)
+	for n := 0; n < 768; n++ {
+		state := arm64PoolAffineState{at: n % 7, count: n % 9,
+			expression: arm64PoolAffine{constant: uint64(n % 13)},
+			bound:      arm64PoolInterval{0, uint64(n % 11)}}
+		// Different order, inactive tail, historical flags and coefficients
+		// distinguish states even if their bucket projections collide.
+		state.constraints[n%8] = arm64PoolConstraint{
+			expression: arm64PoolRegisterExpression(n % 31), after: n % 3,
+		}
+		for repeat := 0; repeat < 2; repeat++ {
+			key := sets.compact(&state)
+			if compact[key] != full[state] || sets.expand(key) != state {
+				t.Fatalf("old complete-state equality changed at %d/%d", n, repeat)
+			}
+			full[state], compact[key] = true, true
+		}
+	}
+	if len(full) != len(compact) {
+		t.Fatal("visited state denominator changed")
+	}
+}
diff --git a/arm64_raw_pool_affine_test.go b/arm64_raw_pool_affine_test.go
new file mode 100644
index 000000000..ce2a0dcb6
--- /dev/null
+++ b/arm64_raw_pool_affine_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64PoolAffineIntervalImages(t *testing.T) {
+	for _, test := range []struct {
+		input arm64PoolInterval
+		scale int64
+		delta uint64
+		want  arm64PoolInterval
+	}{
+		{arm64PoolInterval{math.MaxUint64 - 14, math.MaxUint64}, 1, 16, arm64PoolInterval{1, 15}},
+		{arm64PoolInterval{math.MaxUint64 - 14, math.MaxUint64}, 8, 128, arm64PoolInterval{8, 120}},
+		{arm64PoolInterval{1, 15}, -1, 16, arm64PoolInterval{1, 15}},
+		{arm64PoolInterval{0, 16}, -1, 8, arm64PoolUnknownInterval},
+		{arm64PoolInterval{0, math.MaxUint64}, 2, 0, arm64PoolUnknownInterval},
+		{arm64PoolUnknownInterval, 0, 42, arm64PoolInterval{42, 42}},
+	} {
+		if got := arm64PoolIntervalImage(test.input, test.scale, test.delta); got != test.want {
+			t.Fatalf("image(%+v, %d, %d)=%+v, want %+v", test.input, test.scale, test.delta, got, test.want)
+		}
+	}
+	// Check represented images against concrete modular arithmetic, including
+	// negative and near-wrap inputs. Unknown is conservative, never a mismatch.
+	for _, base := range []uint64{0, 31, 1 << 63, math.MaxUint64 - 31} {
+		for width := uint64(0); width < 16; width++ {
+			for scale := int64(-8); scale <= 8; scale++ {
+				for _, delta := range []uint64{0, 7, 128, math.MaxUint64 - 7} {
+					span := arm64PoolIntervalImage(arm64PoolInterval{base, base + width}, scale, delta)
+					for n := uint64(0); n <= width; n++ {
+						value := (base+n)*uint64(scale) + delta
+						if value < span.low || value > span.high {
+							t.Fatalf("image excludes %d: base=%d width=%d scale=%d delta=%d span=%+v", value, base, width, scale, delta, span)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64PoolMaskIntervals(t *testing.T) {
+	for _, base := range []uint64{0, 8, 16, 1 << 63, math.MaxUint64 - 31} {
+		for width := uint64(0); width < 16; width++ {
+			for _, mask := range []uint64{0, 1, 7, 16, 24, 0xff, math.MaxUint64, math.MaxUint64 - 7} {
+				span := arm64PoolMaskInterval(arm64PoolInterval{base, base + width}, mask)
+				for n := uint64(0); n <= width; n++ {
+					value := (base + n) & mask
+					if value < span.low || value > span.high {
+						t.Fatalf("mask excludes %d: base=%d width=%d mask=%x span=%+v", value, base, width, mask, span)
+					}
+				}
+			}
+		}
+	}
+	if got := arm64PoolMaskInterval(arm64PoolInterval{8, 15}, 24); got != (arm64PoolInterval{8, 8}) {
+		t.Fatalf("guarded mask: %+v", got)
+	}
+	if got := arm64PoolMaskInterval(arm64PoolInterval{8, 19}, 24); got != (arm64PoolInterval{8, 16}) {
+		t.Fatalf("mask crossing a power-of-two boundary: %+v", got)
+	}
+	for low := uint64(0); low < 32; low++ {
+		for high := low; high < 32; high++ {
+			for mask := uint64(0); mask < 32; mask++ {
+				want := arm64PoolInterval{math.MaxUint64, 0}
+				for value := low; value <= high; value++ {
+					masked := value & mask
+					if masked < want.low {
+						want.low = masked
+					}
+					if masked > want.high {
+						want.high = masked
+					}
+				}
+				if got := arm64PoolMaskInterval(arm64PoolInterval{low, high}, mask); got != want {
+					t.Fatalf("[%d,%d] & %d = %+v, want %+v", low, high, mask, got, want)
+				}
+			}
+		}
+	}
+}
+
+func arm64RawPoolAffineIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{
+		"adr x9, #0",
+		"sub x3, x1, x2", "sub x4, x3, #16", "cmn x4, #15", "orr x8, x1, x1", "b.lo #16",
+		"sub x5, x1, x2", "ldrb w5, [x9, x5]", "str x5, [x0]",
+		"cmp x3, #3", "b.hi #20", "lsl x6, x1, #2", "sub x6, x6, x2, lsl #2",
+		"ldr w6, [x9, x6]", "str x6, [x0, #8]",
+		"cmp x3, #8", "b.lo #28", "cmp x3, #15", "b.hi #20",
+		"and x7, x3, #24", "sub x7, x7, #8", "ldr q0, [x9, x7]", "str q0, [x0, #16]",
+		"sub x10, x9, x1, lsl #3", "add x10, x10, x1, lsl #3", "ldr w10, [x10]", "str x10, [x0, #32]",
+		"mov x11, x9", "cbz x2, #8", "add x11, x11, #8", "ldr x11, [x11]", "str x11, [x0, #40]",
+		"ldr x1, [x0, #48]", "ldr x2, [x0, #56]", "sub x3, x2, x1", "cmp x3, #1", "b.hi #20",
+		"sub x10, x9, x1, lsl #3", "add x10, x10, x2, lsl #3", "ldr x10, [x10]", "str x10, [x0, #64]",
+		"cmp x3, #15", "b.ls #20", "cmp x3, #19", "b.hi #20", "tbnz w3, #3, #8", "b #12",
+		"ldrb w4, [x9, x3]", "str x4, [x0, #72]",
+		"cmp x3, #8", "b.lo #32", "cmp x3, #9", "b.hi #24",
+		"sub x10, x9, x1, lsl #3", "add x10, x10, x2, lsl #3", "sub x10, x10, #64",
+		"ldr x10, [x10]", "str x10, [x0, #80]",
+		"cmp x1, x2", "orr x8, x1, x1", "b.ne #16",
+		"sub x10, x2, x1", "ldr q0, [x9, x10]", "str q0, [x0, #88]",
+		"cmn x1, x2", "orr x8, x1, x1", "b.ne #16",
+		"add x10, x1, x2", "ldr q0, [x9, x10]", "str q0, [x0, #104]",
+		"mov x9, xzr", "ret",
+	}
+	lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_affine(SB),$0-24\nMOVD out+0(FP),R0\nMOVD end+8(FP),R1\nMOVD start+16(FP),R2\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := 0; i < 4; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", uint32(0x17b4a140+i))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_affine": {
+			Name: "pool_affine", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolAffineLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolAffineIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_affine.ll", "pool_affine.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "pool_affine", triple, ir, arm64RawPoolAffineMain, nil)
+			}
+		})
+	}
+}
+
+const arm64RawPoolAffineMain = `
+#include <stdint.h>
+#include <string.h>
+extern void pool_affine(uint64_t *, uint64_t, uint64_t);
+int main(void) {
+  const uint32_t words[4] = {0x17b4a140, 0x17b4a141, 0x17b4a142, 0x17b4a143};
+  uint8_t bytes[16];
+  memcpy(bytes, words, sizeof(bytes));
+  const uint64_t starts[] = {0, 31, 1ULL << 63, UINT64_MAX - 7};
+  const uint64_t lengths[] = {0, 1, 2, 3, 4, 8, 9, 10, 13, 14, 15, 16, 17, 18, 19, 20, 255,
+                              1ULL << 32, 1ULL << 63, UINT64_MAX};
+  for (unsigned i = 0; i < sizeof(starts) / sizeof(starts[0]); i++) {
+    for (unsigned j = 0; j < sizeof(lengths) / sizeof(lengths[0]); j++) {
+      uint64_t n = lengths[j];
+      uint64_t result[17] = {0};
+      result[0] = 0x1234;
+      result[16] = 0x5678;
+      result[7] = starts[i];
+      result[8] = starts[i] + n;
+      pool_affine(result + 1, starts[i] + n, starts[i]);
+      uint64_t expected[2] = {0, 0};
+      if (n >= 8 && n <= 15) memcpy(expected, words, sizeof(words));
+      uint64_t joined;
+      memcpy(&joined, words + (starts[i] != 0 ? 2 : 0), sizeof(joined));
+      uint64_t loaded = 0;
+      if (n <= 1) memcpy(&loaded, words + n * 2, sizeof(loaded));
+      uint64_t negative = 0;
+      if (n >= 8 && n <= 9) memcpy(&negative, words + (n - 8) * 2, sizeof(negative));
+      uint64_t equal[2] = {0, 0}, zero_sum[2] = {0, 0};
+      if (n == 0) memcpy(equal, words, sizeof(words));
+      if (starts[i] + starts[i] + n == 0) memcpy(zero_sum, words, sizeof(words));
+      if (result[0] != 0x1234 || result[16] != 0x5678 ||
+          result[1] != (n >= 1 && n <= 15 ? bytes[n] : 0) ||
+          result[2] != (n <= 3 ? words[n] : 0) ||
+          result[3] != expected[0] || result[4] != expected[1] ||
+          result[5] != words[0] || result[6] != joined ||
+          result[7] != starts[i] || result[8] != starts[i] + n || result[9] != loaded ||
+          result[10] != (n <= 15 ? bytes[n] : 0) || result[11] != negative ||
+          result[12] != equal[0] || result[13] != equal[1] ||
+          result[14] != zero_sum[0] || result[15] != zero_sum[1]) return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_pool_alias.go b/arm64_raw_pool_alias.go
new file mode 100644
index 000000000..d7ed11b51
--- /dev/null
+++ b/arm64_raw_pool_alias.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// A pool offset is an inclusive interval. Keep both endpoints: using only
+// an upper bound would miss negative displacements after SUB or LDUR.
+type arm64RawPoolRange struct {
+	low, high int64
+}
+
+// arm64RawPoolAlias follows the address-preserving subset of MOV and ADD/SUB.
+// Validate with the instruction decoder before consulting encoding fields.
+// Flag-setting, truncating, stack-pointer and address-scaling forms cannot
+// preserve the relocation contract and remain on the rejecting generic path.
+func arm64RawPoolAlias(word uint32, at, address int, offset arm64RawPoolRange, bounds *arm64RawPoolBounds) (int, arm64RawPoolRange, bool) {
+	// Most words are unrelated vector/memory instructions. Avoid decoding
+	// them twice in the pointer walker; these masks are only a coarse filter.
+	if word&0xffe0ffe0 != 0xaa0003e0 && word&0xbf800000 != 0x91000000 && word&0xbf000000 != 0x8b000000 {
+		return 0, arm64RawPoolRange{}, false
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil || word&31 == 31 {
+		return 0, arm64RawPoolRange{}, false
+	}
+	destination := int(word & 31)
+	if ins.Op == arm64asm.MOV && ins.Args[1] == arm64asm.X0+arm64asm.Reg(address) &&
+		ins.Args[0] == arm64asm.X0+arm64asm.Reg(destination) && bounds != nil {
+		return destination, offset, true
+	}
+	if (ins.Op != arm64asm.ADD && ins.Op != arm64asm.SUB) || word>>31 == 0 {
+		return 0, arm64RawPoolRange{}, false
+	}
+	base, index := int(word>>5&31), int(word>>16&31)
+	subtract := ins.Op == arm64asm.SUB
+	delta := arm64RawPoolRange{}
+	switch {
+	case word&0x1f800000 == 0x11000000: // Immediate, optionally shifted by 12.
+		if base != address {
+			return 0, delta, false
+		}
+		delta.high = int64(word >> 10 & 4095)
+		if word&(1<<22) != 0 {
+			delta.high <<= 12
+		}
+		delta.low = delta.high
+	case word&0x1f200000 == 0x0b000000: // Shifted register.
+		shift, kind := word>>10&63, word>>22&3
+		if base != address {
+			// ADD is commutative only when the address itself is unshifted.
+			if subtract || index != address || shift != 0 || kind != 0 {
+				return 0, delta, false
+			}
+			index = base
+		} else if index == address {
+			return 0, delta, false
+		}
+		if bounds == nil {
+			return 0, delta, false
+		}
+		upper := bounds.values.boundedUpper(at, arm64asm.X0+arm64asm.Reg(index))
+		switch kind {
+		case 0: // LSL: prove that no bit is lost or enters the sign bit.
+			if upper > math.MaxInt64>>shift {
+				return 0, delta, false
+			}
+			upper <<= shift
+		case 1: // LSR.
+			upper >>= shift
+		case 2: // ASR, only with a proven nonnegative source.
+			if upper > math.MaxInt64 {
+				return 0, delta, false
+			}
+			upper >>= shift
+		default:
+			return 0, delta, false
+		}
+		if upper > math.MaxInt64 {
+			return 0, delta, false
+		}
+		delta.high = int64(upper)
+	case word&0x1f200000 == 0x0b200000: // Extended register; shift 0..4.
+		if base != address || index == address || bounds == nil {
+			return 0, delta, false
+		}
+		extension, shift := word>>13&7, word>>10&7
+		bits := uint(8 << (extension & 3))
+		reg := arm64asm.X0 + arm64asm.Reg(index)
+		if bits < 64 {
+			reg = arm64asm.W0 + arm64asm.Reg(index)
+		}
+		upper := bounds.values.boundedUpper(at, reg)
+		if extension < 4 { // Unsigned extension masks the source.
+			limit := uint64(math.MaxUint64) >> (64 - bits)
+			if upper > limit {
+				upper = limit
+			}
+		} else if upper > uint64(math.MaxInt64)>>(64-bits) {
+			return 0, delta, false
+		}
+		if shift > 4 || upper > math.MaxInt64>>shift {
+			return 0, delta, false
+		}
+		delta.high = int64(upper << shift)
+	default:
+		return 0, delta, false
+	}
+	if subtract {
+		delta = arm64RawPoolRange{-delta.high, -delta.low}
+	}
+	// The ordinary walker can accept an in-place identity without a blob.
+	if bounds == nil {
+		return destination, offset, destination == address && delta.low == 0 && delta.high == 0
+	}
+	// Arithmetic stays in the blob (one-past may be dereferenced only with a
+	// negative displacement). These checks also avoid signed host overflow.
+	if delta.low < -offset.low || delta.high > bounds.size-offset.high {
+		return 0, delta, false
+	}
+	return destination, arm64RawPoolRange{offset.low + delta.low, offset.high + delta.high}, true
+}
diff --git a/arm64_raw_pool_alias_test.go b/arm64_raw_pool_alias_test.go
new file mode 100644
index 000000000..418cebdbc
--- /dev/null
+++ b/arm64_raw_pool_alias_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64RawPoolAliases(t *testing.T) {
+	// Go asm7.go's MOVD and ADD/SUB rows include immediate, shifted and
+	// extended registers. Relocation must follow every surviving alias,
+	// including aliases whose original register has already been overwritten.
+	const loadedDifference = "ldr x1, [x0]\nldr x2, [x0, #8]\nsub x3, x2, x1\n"
+	for _, test := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"copy", "mov x12, x9\nldr x0, [x12]", true},
+		{"immediate-add", "add x12, x9, #8\nldr x0, [x12]", true},
+		{"immediate-sub", "sub x12, x9, #8\nldr x0, [x12]", true},
+		{"alias-chain", "add x10, x9, #16\nsub x12, x10, #8\nldr x0, [x12]\nmov x10, xzr", true},
+		{"transient-offset-cancelled", "sub x10, x9, x1, lsl #3\nadd x12, x10, x1, lsl #3\nldr x0, [x12]\nmov x10, xzr", true},
+		{"transient-add-cancelled", "add x10, x9, x1, lsl #3\nsub x12, x10, x1, lsl #3\nldr x0, [x12]\nmov x10, xzr", true},
+		{
+			"transient-guarded-difference",
+			loadedDifference + "cmp x3, #5\nb.hi #16\n" +
+				"sub x10, x9, x1, lsl #3\nadd x12, x10, x2, lsl #3\n" +
+				"ldr x0, [x12]\nmov x10, xzr",
+			true,
+		},
+		{
+			"transient-guarded-overrun",
+			loadedDifference + "cmp x3, #6\nb.hi #16\n" +
+				"sub x10, x9, x1, lsl #3\nadd x12, x10, x2, lsl #3\n" +
+				"ldr x0, [x12]\nmov x10, xzr",
+			false,
+		},
+		{
+			"transient-guarded-negative-displacement",
+			loadedDifference + "cmp x3, #8\nb.lo #28\ncmp x3, #13\nb.hi #20\n" +
+				"sub x10, x9, x1, lsl #3\nadd x12, x10, x2, lsl #3\n" +
+				"sub x12, x12, #64\nldr x0, [x12]\nmov x10, xzr",
+			true,
+		},
+		{
+			"transient-guarded-negative-underrun",
+			loadedDifference + "cmp x3, #5\nb.lo #28\ncmp x3, #13\nb.hi #20\n" +
+				"sub x10, x9, x1, lsl #3\nadd x12, x10, x2, lsl #3\n" +
+				"sub x12, x12, #64\nldr x0, [x12]\nmov x10, xzr",
+			false,
+		},
+		{"transient-offset-not-cancelled", "sub x10, x9, x1, lsl #3\nadd x12, x10, x2, lsl #3\nldr x0, [x12]\nmov x10, xzr", false},
+		{"transient-index-clobbered", "sub x10, x9, x1\nmov x1, x2\nadd x12, x10, x1\nldr x0, [x12]\nmov x10, xzr", false},
+		{"transient-flags-observed", "sub x10, x9, x1\ncmp x10, #0\nadd x12, x10, x1\nldr x0, [x12]\nmov x10, xzr", false},
+		{"transient-offset-escapes", "sub x10, x9, x1, lsl #3\nstr x10, [x0]\nadd x12, x10, x1, lsl #3\nldr x0, [x12]\nmov x10, xzr", false},
+		{"transient-offset-writes", "sub x10, x9, x1, lsl #3\nadd x12, x10, x1, lsl #3\nstr x0, [x12]\nmov x10, xzr", false},
+		{"original-killed", "mov x12, x9\nmov x9, xzr\nldr x0, [x12]", true},
+		{"load-kills-alias", "mov x12, x9\nldr x12, [x12]", true},
+		{"shifted-add", "and x1, x0, #3\nadd x12, x9, x1, lsl #3\nldr x0, [x12]", true},
+		{"shifted-sub", "and x1, x0, #1\nsub x12, x9, x1, lsl #3\nldr x0, [x12]", true},
+		{"commuted-add", "and x1, x0, #15\nadd x12, x1, x9\nldr x0, [x12]", true},
+		{"masked-numeric-difference", "and x1, x0, #15\nadd x1, x1, #8\nand x2, x1, #24\nsub x3, x1, x2\nadd x12, x9, x3\nldrb w0, [x12]", true},
+		{"masked-address-not-relocated", "and x1, x9, #-8\nsub x12, x9, x1\nldrb w0, [x12]", false},
+		{"masked-address-not-an-index", "and x1, x9, #-8\nsub x2, x9, x1\nadd x12, x9, x2\nldrb w0, [x12]", false},
+		{"uxtw", "and w1, w0, #3\nadd x12, x9, w1, uxtw #3\nldr x0, [x12]", true},
+		{"sxtw-nonnegative", "and w1, w0, #3\nadd x12, x9, w1, sxtw #3\nldr x0, [x12]", true},
+		{"unchanging-loop", "mov x12, x9\nldr x0, [x12]\ncbnz x1, #-4", true},
+		{"escaping-copy", "mov x12, x9\nstr x12, [x0]\nldr x0, [x9]", false},
+		{"escaping-after-kill", "mov x12, x9\nmov x9, xzr\nstr x12, [x0]\nldr x0, [x12]", false},
+		{"second-alias-escapes", "mov x10, x9\nmov x12, x10\nmov x10, xzr\nldr x0, [x9]\nstr x12, [x1]", false},
+		{"return-alias", "mov x0, x9\nldr x1, [x9]", false},
+		{"truncated-copy", "mov w12, w9\nldr x0, [x12]", false},
+		{"truncated-add", "add w12, w9, #8\nldr x0, [x12]", false},
+		{"flags-observe-address", "adds x12, x9, #8\nldr x0, [x12]", false},
+		{"unknown-index", "add x12, x9, x1\nldr x0, [x12]", false},
+		{"shifted-address", "mov x1, #1\nadd x12, x1, x9, lsl #1\nldr x0, [x12]", false},
+		{"two-addresses", "add x12, x9, x9\nldr x0, [x12]", false},
+		{"two-address-aliases", "mov x10, x9\nadd x12, x9, x10\nldr x0, [x12]\nmov x10, xzr", false},
+		{"two-address-aliases-shifted", "mov x10, x9\nadd x12, x9, x10, lsl #1\nldr x0, [x12]\nmov x10, xzr", false},
+		{"reverse-subtraction", "mov x1, #1\nsub x12, x1, x9\nldr x0, [x12]", false},
+		{"negative-sxtw", "mov w1, #-1\nadd x12, x9, w1, sxtw\nldr x0, [x12]", false},
+		{"shift-overflow", "mov x1, #2\nadd x12, x9, x1, lsl #63\nldr x0, [x12]", false},
+		{"out-of-bounds", "add x12, x9, #48\nldr x0, [x12]", false},
+		{"negative-footprint", "sub x12, x9, #16\nldur x0, [x12, #-1]", false},
+		{"alias-join", "mov x12, x9\ncbz x1, #8\nadd x12, x12, #8\nldr x0, [x12]", true},
+		{"alias-join-overrun", "mov x12, x9\ncbz x1, #8\nadd x12, x12, #48\nldr x0, [x12]", false},
+		{"alias-changing-loop", "mov x12, x9\nldr x0, [x12]\nadd x12, x12, #8\ncbnz x1, #-8", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := append([]string{"adr x9, #0"}, strings.Split(test.body, "\n")...)
+			lines = append(lines, "mov x9, xzr", "mov x12, xzr", "ret")
+			lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4+16)
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, lines, "") {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			for i := 0; i < 16; i++ {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+			}
+			points := make([]arm64RawLayoutPoint, len(instructions))
+			for i := range points {
+				points[i].offset = int64(i * 4)
+			}
+			data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+			if got := len(data) == 16; got != test.want {
+				t.Fatalf("pool alias proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolAliasArithmeticForms(t *testing.T) {
+	// Exercise the independent encoding axes, including all eight extension
+	// modes. Signed modes require a nonnegative bound; unknown signed values
+	// are covered by the rejection cases above.
+	for _, op := range []string{"add", "sub"} {
+		for _, modifier := range []string{"lsl", "lsr", "asr", "uxtb", "uxth", "uxtw", "uxtx", "sxtb", "sxth", "sxtw", "sxtx"} {
+			for _, shift := range []int{0, 1, 4} {
+				index := "x1"
+				reg := arm64asm.X1
+				if strings.HasSuffix(modifier, "b") || strings.HasSuffix(modifier, "h") || strings.HasSuffix(modifier, "w") {
+					index, reg = "w1", arm64asm.W1
+				}
+				line := fmt.Sprintf("%s x12, x9, %s, %s #%d", op, index, modifier, shift)
+				t.Run(line, func(t *testing.T) {
+					word := assembleARM64LLVMWords(t, []string{line}, "")[0]
+					values := &arm64RawPoolValues{cache: map[arm64RawPoolValue]uint64{{0, reg}: 7}}
+					bounds := &arm64RawPoolBounds{size: 512, values: values}
+					dest, got, ok := arm64RawPoolAlias(word, 0, 9, arm64RawPoolRange{128, 128}, bounds)
+					delta := int64(7 << uint(shift))
+					if modifier == "lsr" || modifier == "asr" {
+						delta = 7 >> uint(shift)
+					}
+					want := arm64RawPoolRange{128, 128 + delta}
+					if op == "sub" {
+						want = arm64RawPoolRange{128 - delta, 128}
+					}
+					if !ok || dest != 12 || got != want {
+						t.Fatalf("alias=(%d, %+v, %v), want (12, %+v, true)", dest, got, ok, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func arm64RawPoolAliasesIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{
+		"adr x9, #0", "mov x10, x9", "add x12, x10, #16", "mov x9, xzr",
+		"and x3, x1, #3", "add x11, x12, x3, lsl #3", "ldr x4, [x11]", "str x4, [x0]",
+		"sub x11, x12, x3, lsl #2", "ldr w4, [x11]", "str x4, [x0, #8]",
+		"and w3, w1, #7", "add x11, x10, w3, uxtw #2", "ldr w11, [x11]", "str x11, [x0, #16]",
+		"add x11, x10, #48", "ldur x4, [x11, #-8]", "str x4, [x0, #24]",
+		"mov x10, xzr", "mov x11, xzr", "mov x12, xzr", "ret",
+	}
+	lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_alias(SB),$0-16\nMOVD out+0(FP),R0\nMOVD index+8(FP),R1\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := 0; i < 12; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", uint32(0x17b4a140+i))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_alias": {
+			Name: "pool_alias", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolAliasesLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolAliasesIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_alias.ll", "pool_alias.o", ir)
+			// Linux execution is also required by the cross-runtime matrix.
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "pool_alias", triple, ir, arm64RawPoolAliasesMain, nil)
+			}
+		})
+	}
+}
+
+const arm64RawPoolAliasesMain = `
+#include <stdint.h>
+#include <string.h>
+extern void pool_alias(uint64_t *, uint64_t);
+int main(void) {
+  uint32_t words[12];
+  for (unsigned i = 0; i < 12; i++) words[i] = 0x17b4a140 + i;
+  const uint64_t indexes[] = {0, 1, 2, 3, 4, 7, 8, 255, UINT64_MAX};
+  for (unsigned i = 0; i < sizeof(indexes) / sizeof(indexes[0]); i++) {
+    uint64_t result[6] = {0x1234, 0, 0, 0, 0, 0x5678};
+    uint64_t pair, last;
+    memcpy(&pair, words + 4 + (indexes[i] & 3) * 2, sizeof(pair));
+    memcpy(&last, words + 10, sizeof(last));
+    pool_alias(result + 1, indexes[i]);
+    if (result[0] != 0x1234 || result[5] != 0x5678 ||
+        result[1] != pair || result[2] != words[4 - (indexes[i] & 3)] ||
+        result[3] != words[indexes[i] & 7] || result[4] != last) return 1;
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_pool_bit_guard_test.go b/arm64_raw_pool_bit_guard_test.go
new file mode 100644
index 000000000..dbd7319aa
--- /dev/null
+++ b/arm64_raw_pool_bit_guard_test.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolAffineBitGuardForms(t *testing.T) {
+	for _, op := range []string{"tbz", "tbnz"} {
+		for bit := uint(0); bit < 64; bit++ {
+			register := "x1"
+			if bit < 32 {
+				register = "w1"
+			}
+			for _, displacement := range []int{-8, 8} {
+				name := fmt.Sprintf("%s %s, #%d, #%d", op, register, bit, displacement)
+				t.Run(name, func(t *testing.T) {
+					word := assembleARM64LLVMWords(t, []string{name}, "")[0]
+					flow := &arm64RawPoolValues{words: []uint32{0, 0, word, 0, 0}}
+					for _, taken := range []bool{false, true} {
+						target := 3
+						if taken {
+							target = 2 + displacement/4
+						}
+						constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{2, target})
+						mask := uint64(1) << bit
+						value := uint64(0)
+						if taken == (op == "tbnz") {
+							value = mask
+						}
+						if !ok || constraint.expression != arm64PoolRegisterExpression(1) ||
+							constraint.mask != mask || constraint.interval != (arm64PoolInterval{value, value}) {
+							t.Fatalf("taken=%v: constraint=%+v valid=%v", taken, constraint, ok)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_cache_test.go b/arm64_raw_pool_cache_test.go
new file mode 100644
index 000000000..dc7e4801d
--- /dev/null
+++ b/arm64_raw_pool_cache_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolRevisitInconclusiveQuery(t *testing.T) {
+	for _, invariant := range []bool{false, true} {
+		flow := arm64PoolTestFlow(t, []string{"mov x1, #8", "ret"})
+		query := arm64PoolAffineQuery{1, arm64PoolRegisterExpression(1)}
+		// An earlier nested proof may exhaust the shared work budget. Unknown
+		// records that failed attempt, not a fact about the register's value.
+		flow.affineCache = map[arm64PoolAffineQuery]arm64PoolInterval{query: arm64PoolUnknownInterval}
+		flow.invariantCache = map[arm64PoolAffineQuery]arm64PoolInterval{query: arm64PoolUnknownInterval}
+		flow.affineActive = make(map[arm64PoolAffineQuery]bool)
+		var got arm64PoolInterval
+		if invariant {
+			got = flow.invariantInterval(query.at, query.expression)
+		} else {
+			got = flow.affineInterval(query.at, query.expression)
+		}
+		if got != (arm64PoolInterval{8, 8}) {
+			t.Fatalf("invariant=%v: a previous inconclusive attempt poisoned the new proof: %+v", invariant, got)
+		}
+	}
+}
diff --git a/arm64_raw_pool_carried.go b/arm64_raw_pool_carried.go
new file mode 100644
index 000000000..34dd68821
--- /dev/null
+++ b/arm64_raw_pool_carried.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import "math"
+
+// Rewind an unchanged query through a certified loop without replacing it by
+// an interval. This retains relationships to earlier definitions, such as a
+// nonzero remainder guarded using a different copy of the original length.
+// Only active constraints independently preserved by the entire body survive;
+// a counter predicate from one iteration must not constrain its entry value.
+func (flow *arm64RawPoolValues) rewindInvariantLoop(state *arm64PoolAffineState) (int, bool) {
+	latch, ok := flow.loopLatches[state.at]
+	if !ok || flow.affineDirect {
+		return 0, false
+	}
+	delta, valid := flow.loopExpressionDelta(state.at, latch, state.expression)
+	if !valid || delta != 0 {
+		return 0, false
+	}
+	count := 0
+	for _, constraint := range state.constraints[:state.count] {
+		if constraint.after != 0 {
+			continue
+		}
+		change, preserved := flow.loopExpressionDelta(state.at, latch, constraint.expression)
+		if !preserved || change != 0 {
+			continue
+		}
+		state.constraints[count] = constraint
+		count++
+	}
+	for index := count; index < state.count; index++ {
+		state.constraints[index] = arm64PoolConstraint{}
+	}
+	state.count = count
+	return latch, true
+}
+
+// The loop body is already certified straight-line and single-entry. Substitute
+// its effects backwards to prove a constant per-iteration delta; an unknown
+// load result, nonlinear update or changing coefficient is not such a proof.
+func (flow *arm64RawPoolValues) loopExpressionDelta(head, latch int, expression arm64PoolAffine) (int64, bool) {
+	next := expression
+	for at := latch - 1; at >= head; at-- {
+		word := flow.words[at]
+		writes, known := flow.gpWrites(word)
+		if !known {
+			return 0, false
+		}
+		if affected := writes & next.registerMask(); affected != 0 {
+			destination, value, valid := flow.affineDefinition(word)
+			if !valid || affected != 1<<uint(destination) || !next.substitute(destination, value) {
+				return 0, false
+			}
+		}
+	}
+	if next.coefficient != expression.coefficient || next.relocations != expression.relocations {
+		return 0, false
+	}
+	return int64(next.constant - expression.constant), true
+}
+
+// A carried address and the remaining count can change together even though
+// they occupy unrelated registers: p -= 64 and remaining += 8 preserve
+// p+8*remaining. Prove that invariant from the external entries, then combine
+// it with the independently established counter range. No loop is unrolled or
+// assumed to run once, and entry analysis cannot recursively use this rule.
+func (flow *arm64RawPoolValues) carriedLoopBound(head int, query arm64PoolAffine, counter arm64PoolConstraint) (arm64PoolInterval, bool) {
+	latch, ok := flow.loopLatches[head]
+	if !ok || flow.affineDirect {
+		return arm64PoolInterval{}, false
+	}
+	step, valid := flow.loopExpressionDelta(head, latch, counter.expression)
+	if !valid || step == 0 || step < -(1<<30) || step > 1<<30 {
+		return arm64PoolInterval{}, false
+	}
+	delta, valid := flow.loopExpressionDelta(head, latch, query)
+	if !valid || delta < -(1<<30) || delta > 1<<30 || delta%step != 0 {
+		return arm64PoolInterval{}, false
+	}
+	scale := delta / step
+	invariant := query
+	if !invariant.add(counter.expression, -scale) {
+		return arm64PoolInterval{}, false
+	}
+	entry := flow.counterLoopEntry(head, latch)
+	if entry == nil {
+		return arm64PoolInterval{}, false
+	}
+	entry.poolOrigins = flow.poolOrigins
+	entry.loopLatches = nil // Entry proof must not recursively summarize another loop.
+	// Keep the entire relation while substituting entry definitions. Bounding
+	// p and remaining separately would lose their correlation before the
+	// cancellation that establishes the invariant constant.
+	nearest := counter.interval.low
+	if nearest > math.MaxInt64 {
+		nearest = counter.interval.high
+	}
+	for _, anchor := range []uint64{0, nearest} {
+		// Shift the reference count, not the represented address. An invariant
+		// spanning unsigned zero may become one ordinary interval when centered
+		// at the counter endpoint nearest zero. No wraparound is clamped away.
+		anchored := invariant
+		anchored.constant += uint64(scale) * anchor
+		value := entry.invariantIntervalProof(head, anchored, true)
+		if value == arm64PoolUnknownInterval {
+			work := entry.affineWork
+			value = entry.affineInterval(head, anchored)
+			entry.affineWork += work
+		}
+		flow.affineWork += entry.affineWork
+		if flow.affineWork >= 16384 {
+			return arm64PoolInterval{}, false
+		}
+		if value == arm64PoolUnknownInterval {
+			continue
+		}
+		result := arm64PoolIntervalImage(counter.interval, scale, value.low-uint64(scale)*anchor)
+		width := value.high - value.low
+		if result == arm64PoolUnknownInterval || result.high > math.MaxUint64-width {
+			continue
+		}
+		result.high += width
+		return result, true
+	}
+	return arm64PoolInterval{}, false
+}
diff --git a/arm64_raw_pool_carried_test.go b/arm64_raw_pool_carried_test.go
new file mode 100644
index 000000000..622c98cb4
--- /dev/null
+++ b/arm64_raw_pool_carried_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolCarriedStridedAddress(t *testing.T) {
+	for _, step := range []uint64{1, 2, 4, 8, 16} {
+		for _, ascending := range []bool{false, true} {
+			for _, pointerIncreasing := range []bool{false, true} {
+				name := fmt.Sprintf("step=%d/ascending=%v/pointerIncreasing=%v", step, ascending, pointerIncreasing)
+				t.Run(name, func(t *testing.T) {
+					lines := []string{fmt.Sprintf("and x1,x0,#%d", step), fmt.Sprintf("add x1,x1,#%d", step),
+						"lsl x3,x1,#3", "add x3,x3,#32"}
+					pointerDelta := -int64(step * 8)
+					want := arm64PoolInterval{32 + step*8, 32 + step*16}
+					if pointerIncreasing {
+						lines = append(lines, "mov x4,#512", "sub x3,x4,x3")
+						pointerDelta, want = -pointerDelta, arm64PoolInterval{512 - want.high, 512 - want.low}
+					}
+					update := fmt.Sprintf("sub x1,x1,#%d", step)
+					if ascending {
+						lines = append(lines, "neg x1,x1")
+						update = fmt.Sprintf("add x1,x1,#%d", step)
+					}
+					head := len(lines)
+					lines = append(lines, fmt.Sprintf("ldr x4,[x3],#%d", pointerDelta), update, "cbnz x1,#-8", "ret")
+					flow := arm64PoolTestFlow(t, lines)
+					if got := flow.affineInterval(head, arm64PoolRegisterExpression(3)); got != want {
+						t.Fatalf("carried address=%+v, want %+v", got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64PoolCarriedStrideRejectsUnprovedRelation(t *testing.T) {
+	for _, change := range []string{
+		"sub x3,x3,#7", // Non-integral address/counter ratio.
+		"add x3,x3,x5", // Unknown per-iteration delta.
+		"ldr x3,[x5]",  // No affine recurrence.
+	} {
+		flow := arm64PoolTestFlow(t, []string{
+			"and x1,x0,#8", "add x1,x1,#8", "lsl x3,x1,#3",
+			"nop", change, "sub x1,x1,#8", "cbnz x1,#-12", "ret",
+		})
+		if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != arm64PoolUnknownInterval {
+			t.Fatalf("%s invented a carried bound: %+v", change, got)
+		}
+	}
+}
+
+func TestARM64PoolCarriedInvariantAcrossUnsignedZero(t *testing.T) {
+	for _, ascending := range []bool{false, true} {
+		lines := []string{"and x1,x0,#8", "add x1,x1,#8", "and x4,x0,#7",
+			"add x3,x1,x4", "sub x3,x3,#4"}
+		update := "sub x1,x1,#8"
+		if ascending {
+			lines = append(lines, "neg x1,x1")
+			update = "add x1,x1,#8"
+		}
+		head := len(lines)
+		lines = append(lines, "ldr x5,[x3],#-8", update, "cbnz x1,#-8", "ret")
+		flow := arm64PoolTestFlow(t, lines)
+		// The invariant is x4-4, spanning [-4,3], but every actual address
+		// remains in [4,19]. Recenter the invariant; never clamp a wrapped span.
+		if got := flow.affineInterval(head, arm64PoolRegisterExpression(3)); got != (arm64PoolInterval{4, 19}) {
+			t.Fatalf("ascending=%v: carried bound=%+v, want [4,19]", ascending, got)
+		}
+	}
+}
+
+func TestARM64PoolCarriedAddressCounterRelation(t *testing.T) {
+	for _, test := range []struct {
+		name          string
+		initial, load string
+		want          arm64PoolInterval
+	}{
+		{"decreasing", "mov x3, #64", "ldr x4, [x3], #-8", arm64PoolInterval{8, 64}},
+		{"increasing", "mov x3, #0", "ldr x4, [x3], #8", arm64PoolInterval{0, 56}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				test.initial, "mov x1, #0", "mov x2, #8", test.load,
+				"add x1, x1, #1", "cmp x1, x2", "b.lt #-12", "ret",
+			})
+			if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != test.want {
+				t.Fatalf("carried address = %+v, want %+v", got, test.want)
+			}
+		})
+	}
+	flow := arm64PoolTestFlow(t, []string{
+		"mov x3, #64", "mov x1, #0", "mov x2, #8", "ldr x4, [x3], #-8",
+		"add x3, x3, x5", "add x1, x1, #1", "cmp x1, x2", "b.lt #-16", "ret",
+	})
+	if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != arm64PoolUnknownInterval {
+		t.Fatalf("nonconstant address recurrence accepted: %+v", got)
+	}
+}
diff --git a/arm64_raw_pool_constant_compare_test.go b/arm64_raw_pool_constant_compare_test.go
new file mode 100644
index 000000000..7cefb7733
--- /dev/null
+++ b/arm64_raw_pool_constant_compare_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+func TestARM64PoolConstantRegisterCompareGuards(t *testing.T) {
+	for _, operand := range []struct {
+		text  string
+		input uint64
+		limit uint64
+	}{
+		{"x2", 15, 15},
+		{"x2,lsl #1", 15, 30},
+		{"x2,lsr #1", 30, 15},
+		{"x2,asr #1", math.MaxUint64 - 29, math.MaxUint64 - 14},
+		{"w2,uxtb #1", 0xff0f, 30},
+		{"w2,uxth #1", 0xff0f, 0x1fe1e},
+		{"w2,uxtw #1", 15, 30},
+		{"x2,uxtx #1", 15, 30},
+		{"w2,sxtb #1", 0xff, math.MaxUint64 - 1},
+		{"w2,sxth #1", 0xffff, math.MaxUint64 - 1},
+		{"w2,sxtw #1", math.MaxUint64, math.MaxUint64 - 1},
+		{"x2,sxtx #1", math.MaxUint64, math.MaxUint64 - 1},
+	} {
+		for _, condition := range []string{"hs", "lo", "hi", "ls"} {
+			t.Run(operand.text+"/"+condition, func(t *testing.T) {
+				flow := arm64PoolTestFlow(t, []string{
+					fmt.Sprintf("mov x2,#%#x", operand.input), "cmp x1," + operand.text,
+					"b." + condition + " #8", "nop", "ret",
+				})
+				constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{2, 4})
+				want := arm64PoolUnknownInterval
+				switch condition {
+				case "hs":
+					want.low = operand.limit
+				case "lo":
+					want.high = operand.limit - 1
+				case "hi":
+					want.low = operand.limit + 1
+				case "ls":
+					want.high = operand.limit
+				}
+				if !ok || constraint.expression != arm64PoolRegisterExpression(1) || constraint.interval != want {
+					t.Fatalf("guard=%+v/%v, want R1 in %+v", constraint, ok, want)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolConstantCompareRejectsUnprovedLimits(t *testing.T) {
+	for _, lines := range [][]string{
+		{"nop", "cmp x1,x2", "b.hs #8", "nop", "ret"},
+		{"mov x2,#15", "cmp w1,w2", "b.hs #8", "nop", "ret"},
+		{"mov x2,#15", "cmp sp,x2", "b.hs #8", "nop", "ret"},
+		{"adr x2,#16", "cmp x1,x2", "b.hs #8", "nop", "ret"},
+	} {
+		flow := arm64PoolTestFlow(t, lines)
+		flow.poolOrigins = map[int]uint64{0: 16}
+		if constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{2, 4}); ok {
+			t.Fatalf("%v invented numeric limit: %+v", lines, constraint)
+		}
+	}
+	flow := arm64PoolTestFlow(t, []string{"mov x2,#15", "cmp x1,x2", "mov x2,#7", "b.hs #8", "nop", "ret"})
+	if constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{3, 5}); !ok || constraint.interval.low != 15 {
+		t.Fatalf("comparison used its overwritten limit: %+v/%v", constraint, ok)
+	}
+}
+
+func TestARM64PoolConstantRegisterCMNGuards(t *testing.T) {
+	for _, condition := range []string{"hs", "lo", "hi", "ls"} {
+		flow := arm64PoolTestFlow(t, []string{"mov x2,#15", "cmn x1,x2,lsl #1", "b." + condition + " #8", "nop", "ret"})
+		constraint, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{2, 4})
+		threshold := uint64(math.MaxUint64 - 29)
+		want := arm64PoolUnknownInterval
+		switch condition {
+		case "hs":
+			want.low = threshold
+		case "lo":
+			want.high = threshold - 1
+		case "hi":
+			want.low = threshold + 1
+		case "ls":
+			want.high = threshold
+		}
+		if !ok || constraint.expression != arm64PoolRegisterExpression(1) || constraint.interval != want {
+			t.Fatalf("CMN %s: %+v/%v, want %+v", condition, constraint, ok, want)
+		}
+	}
+	for _, test := range []struct{ setup, compare, branch string }{
+		{"mov x2,#-1", "cmp x1,x2", "b.hi #8"},
+		{"mov x2,#0", "cmp x1,x2", "b.lo #8"},
+		{"mov x2,#1", "cmn x1,x2", "b.hi #8"},
+	} {
+		flow := arm64PoolTestFlow(t, []string{test.setup, test.compare, test.branch, "nop", "ret"})
+		if guard, ok := flow.affineEdgeConstraint(arm64RawPoolEdge{2, 4}); ok && guard.interval != arm64PoolUnknownInterval {
+			t.Fatalf("impossible comparison wrapped to a live bound: %+v", guard)
+		}
+	}
+}
diff --git a/arm64_raw_pool_delayed_guard_test.go b/arm64_raw_pool_delayed_guard_test.go
new file mode 100644
index 000000000..9da87ae8a
--- /dev/null
+++ b/arm64_raw_pool_delayed_guard_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolHistoricalCompareOperands(t *testing.T) {
+	for _, test := range []struct {
+		name  string
+		lines []string
+		query int
+		want  arm64PoolInterval
+	}{
+		{"masked-index-minus-one", []string{
+			"and x2, x0, #7", "add x2, x2, #8", "and x4, x2, #0xfffffffffffffff8",
+			"sub x6, x2, x4", "cmp x2, x4", "mov x4, xzr", "b.eq #12",
+			"sub x6, x6, #1", "nop", "ret",
+		}, 8, arm64PoolInterval{0, 6}},
+		{"masked-tail", []string{
+			"cmp x2, #8", "b.lo #40", "cmp x2, #15", "b.hi #32",
+			"and x4, x2, #0xfffffffffffffff8", "sub x6, x2, x4",
+			"cmp x2, x4", "mov x4, x0", "b.eq #12", "nop", "ret", "ret",
+		}, 9, arm64PoolInterval{1, 7}},
+		{"saved-cmp-operand", []string{
+			"mov x6, x2", "cmp x2, #7", "mov x2, x0", "b.hi #8", "nop", "ret",
+		}, 4, arm64PoolInterval{0, 7}},
+		{"saved-adds-result", []string{
+			"adds x2, x1, #1", "mov x6, x2", "mov x2, x0", "b.ne #8", "nop", "ret",
+		}, 4, arm64PoolInterval{0, 0}},
+		{"current-value-is-not-compared-value", []string{
+			"cmp x6, #7", "mov x6, x0", "b.hi #8", "nop", "ret",
+		}, 3, arm64PoolUnknownInterval},
+		{"new-flags-win", []string{
+			"mov x6, x2", "cmp x2, #7", "mov x2, x0", "tst x3, x4", "b.hi #8", "nop", "ret",
+		}, 5, arm64PoolUnknownInterval},
+		{"bypassed-compare", []string{
+			"mov x6, x2", "cbz x1, #8", "cmp x2, #7", "mov x2, x0", "b.hi #8", "nop", "ret",
+		}, 5, arm64PoolUnknownInterval},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, test.lines)
+			if got := flow.affineInterval(test.query, arm64PoolRegisterExpression(6)); got != test.want {
+				t.Fatalf("historical comparison range=%+v, want %+v", got, test.want)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_direct_test.go b/arm64_raw_pool_direct_test.go
new file mode 100644
index 000000000..9b9a7183b
--- /dev/null
+++ b/arm64_raw_pool_direct_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolDirectBoundsBeforeResidualProofs(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"cmp x1, #7", "b.hi #28", "cmp x1, #1", "b.lo #20",
+		"sub x2, x1, x3", "cmp x2, #5", "b.hi #8", "nop", "ret",
+	})
+	flow.clearValueCaches()
+	if got := flow.affineInterval(7, arm64PoolRegisterExpression(1)); got != (arm64PoolInterval{1, 7}) {
+		t.Fatalf("direct dominating bounds lost: %+v", got)
+	}
+	if len(flow.invariantCache) != 0 {
+		t.Fatal("simple dominating guards speculatively queried unrelated residuals")
+	}
+}
+
+func TestARM64PoolLongGuardSchedules(t *testing.T) {
+	for _, constant := range []bool{false, true} {
+		lines := []string{"mov x1, #8"}
+		for n := 0; n < 12; n++ {
+			if constant {
+				lines = append(lines, "mov x2, #0", "cbnz x2, #0")
+			} else {
+				lines = append(lines, "cmp x2, #20", "b.hi #0")
+			}
+		}
+		query := len(lines)
+		lines = append(lines, "nop", "ret")
+		for at := 2; at < query; at += 2 {
+			if constant {
+				lines[at] = fmt.Sprintf("cbnz x2, #%d", (query+1-at)*4)
+			} else {
+				lines[at] = fmt.Sprintf("b.hi #%d", (query+1-at)*4)
+			}
+		}
+		flow := arm64PoolTestFlow(t, lines)
+		if got := flow.affineInterval(query, arm64PoolRegisterExpression(1)); got != (arm64PoolInterval{8, 8}) {
+			t.Fatalf("constant=%v: redundant guards exhausted the constraint budget: %+v", constant, got)
+		}
+	}
+}
+
+func TestARM64PoolMaskPredicateAfterLogicalFold(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"mov x1, #0", "cmp x2, #16", "b.lo #36", "cmp x2, #19", "b.hi #28",
+		"and x4, x2, #0xfffffffffffffff0", "cmp x2, x4", "b.eq #16",
+		"orr x5, x1, x4", "sub x6, x2, x5", "nop", "ret",
+	})
+	if got := flow.affineInterval(10, arm64PoolRegisterExpression(6)); got != (arm64PoolInterval{1, 3}) {
+		t.Fatalf("folded mask lost its nonempty-tail predicate: %+v", got)
+	}
+}
diff --git a/arm64_raw_pool_division.go b/arm64_raw_pool_division.go
new file mode 100644
index 000000000..c5e86d3a3
--- /dev/null
+++ b/arm64_raw_pool_division.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"math"
+	"math/bits"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+type arm64PoolValuePoint struct {
+	at, register int
+}
+
+type arm64PoolQuotient struct {
+	numerator arm64PoolValuePoint
+	divisor   uint64
+}
+
+// Stop at joins and actual definitions, following only unchanged registers and
+// exact X copies. Equal canonical points denote the same historic value; a
+// current register name alone does not establish that identity.
+func (flow *arm64RawPoolValues) valueDefinition(point arm64PoolValuePoint) (arm64PoolValuePoint, int, bool) {
+	visited := make(map[arm64PoolValuePoint]bool)
+	for steps := 0; steps < 512; steps++ {
+		if point.register == 31 {
+			return arm64PoolValuePoint{-1, 31}, 0, false
+		}
+		if point.at < 0 || point.at >= len(flow.before) || len(flow.before[point.at]) != 1 ||
+			visited[point] || flow.affineWork >= 16384 {
+			break
+		}
+		visited[point] = true
+		flow.affineWork++
+		previous := flow.before[point.at][0]
+		if previous < 0 || flow.opaque[previous] {
+			break
+		}
+		word := flow.words[previous]
+		writes, known := flow.gpWrites(word)
+		if !known {
+			break
+		}
+		if writes&(1<<uint(point.register)) != 0 {
+			ins, decoded := arm64PoolDecodeWord(word)
+			if decoded && ins.Op == arm64asm.MOV {
+				destination, x := ins.Args[0].(arm64asm.Reg)
+				source, reg := ins.Args[1].(arm64asm.Reg)
+				if x && destination >= arm64asm.X0 && destination <= arm64asm.XZR &&
+					reg && source >= arm64asm.X0 && source <= arm64asm.XZR {
+					point = arm64PoolValuePoint{previous, int(source - arm64asm.X0)}
+					continue
+				}
+			}
+			return arm64PoolValuePoint{previous + 1, point.register}, previous, true
+		}
+		point.at = previous
+	}
+	return point, 0, false
+}
+
+func (flow *arm64RawPoolValues) sameValue(left, right arm64PoolValuePoint) bool {
+	left, _, _ = flow.valueDefinition(left)
+	right, _, _ = flow.valueDefinition(right)
+	return left == right
+}
+
+func (flow *arm64RawPoolValues) unsignedShiftSource(point arm64PoolValuePoint) (arm64PoolValuePoint, uint, bool) {
+	_, at, ok := flow.valueDefinition(point)
+	if !ok {
+		return point, 0, false
+	}
+	word := flow.words[at]
+	ins, decoded := arm64PoolDecodeWord(word)
+	amount, immediate := ins.Args[2].(arm64asm.Imm)
+	if !decoded || ins.Op != arm64asm.LSR || word>>31 == 0 || !immediate {
+		return point, 0, false
+	}
+	return arm64PoolValuePoint{at, int(word >> 5 & 31)}, uint(amount.Imm), true
+}
+
+// If d*m = 2^k + e and n_max*e < 2^k, floor(n*m/2^k) equals
+// floor(n/d) for every n in the domain: even remainder d-1 cannot round up.
+// Evaluate that sufficient condition with full 128-bit products, not floats
+// or sampled values. A pre-shift reduces the domain and multiplies d by 2^pre.
+func arm64PoolReciprocalDivisor(multiplier uint64, pre, post uint) (uint64, bool) {
+	if multiplier == 0 || pre > 63 || post > 63 || uint64(1)<<post >= multiplier {
+		return 0, false
+	}
+	power := uint64(1) << post
+	divisor, remainder := bits.Div64(power, 0, multiplier)
+	if remainder != 0 {
+		if divisor == math.MaxUint64 {
+			return 0, false
+		}
+		divisor++
+	}
+	high, error := bits.Mul64(divisor, multiplier)
+	if high != power {
+		return 0, false
+	}
+	errorHigh, _ := bits.Mul64(math.MaxUint64>>pre, error)
+	if errorHigh >= power || divisor > math.MaxUint64>>pre {
+		return 0, false
+	}
+	return divisor << pre, true
+}
+
+func (flow *arm64RawPoolValues) exactUnsignedQuotient(point arm64PoolValuePoint) (arm64PoolQuotient, bool) {
+	var post uint
+	for {
+		source, shift, ok := flow.unsignedShiftSource(point)
+		if !ok {
+			break
+		}
+		post += shift
+		if post > 63 {
+			return arm64PoolQuotient{}, false
+		}
+		point = source
+	}
+	_, at, found := flow.valueDefinition(point)
+	if !found {
+		return arm64PoolQuotient{}, false
+	}
+	word := flow.words[at]
+	ins, ok := arm64PoolDecodeWord(word)
+	if !ok || word>>31 == 0 {
+		return arm64PoolQuotient{}, false
+	}
+	left, right := int(word>>5&31), int(word>>16&31)
+	if ins.Op == arm64asm.UDIV && post == 0 {
+		divisor := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(right))
+		if divisor.low != 0 && divisor.low == divisor.high {
+			return arm64PoolQuotient{arm64PoolValuePoint{at, left}, divisor.low}, true
+		}
+		return arm64PoolQuotient{}, false
+	}
+	if ins.Op != arm64asm.UMULH {
+		return arm64PoolQuotient{}, false
+	}
+	for _, pair := range [][2]int{{left, right}, {right, left}} {
+		multiplier := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(pair[1]))
+		if multiplier.low != multiplier.high {
+			continue
+		}
+		source := arm64PoolValuePoint{at, pair[0]}
+		var pre uint
+		for {
+			previous, shift, ok := flow.unsignedShiftSource(source)
+			if !ok {
+				break
+			}
+			pre += shift
+			source = previous
+			if pre > 63 {
+				break
+			}
+		}
+		if divisor, valid := arm64PoolReciprocalDivisor(multiplier.low, pre, post); valid {
+			return arm64PoolQuotient{source, divisor}, true
+		}
+	}
+	return arm64PoolQuotient{}, false
+}
+
+func (flow *arm64RawPoolValues) affineDivisionInterval(at int, word uint32, constraints []arm64PoolConstraint) (arm64PoolInterval, bool) {
+	ins, ok := arm64PoolDecodeWord(word)
+	if !ok || word>>31 == 0 || word&31 == 31 {
+		return arm64PoolInterval{}, false
+	}
+	if ins.Op == arm64asm.MSUB {
+		left, right, numerator := int(word>>5&31), int(word>>16&31), int(word>>10&31)
+		for _, pair := range [][2]int{{left, right}, {right, left}} {
+			quotient, valid := flow.exactUnsignedQuotient(arm64PoolValuePoint{at, pair[0]})
+			if !valid {
+				continue
+			}
+			divisor := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(pair[1]))
+			if divisor.low == quotient.divisor && divisor.high == quotient.divisor &&
+				flow.sameValue(quotient.numerator, arm64PoolValuePoint{at, numerator}) {
+				return arm64PoolInterval{0, quotient.divisor - 1}, true
+			}
+		}
+		return arm64PoolInterval{}, false
+	}
+	if ins.Op != arm64asm.LSR && ins.Op != arm64asm.UMULH && ins.Op != arm64asm.UDIV {
+		return arm64PoolInterval{}, false
+	}
+	quotient, valid := flow.exactUnsignedQuotient(arm64PoolValuePoint{at + 1, int(word & 31)})
+	if !valid {
+		return arm64PoolInterval{}, false
+	}
+	input := arm64PoolUnknownInterval
+	for _, constraint := range constraints {
+		if constraint.after != 0 || constraint.mask != 0 {
+			continue
+		}
+		for reg := 0; reg < 31; reg++ {
+			// The constraint is on the post-instruction state. If the
+			// destination aliases the numerator, its guard describes the new
+			// quotient, not the old numerator that the quotient proof names.
+			if reg == int(word&31) || constraint.expression != arm64PoolRegisterExpression(reg) ||
+				!flow.sameValue(quotient.numerator, arm64PoolValuePoint{at, reg}) {
+				continue
+			}
+			if constraint.interval.low > input.low {
+				input.low = constraint.interval.low
+			}
+			if constraint.interval.high < input.high {
+				input.high = constraint.interval.high
+			}
+		}
+	}
+	if input == arm64PoolUnknownInterval {
+		input = flow.integerInterval(quotient.numerator.at, arm64asm.X0+arm64asm.Reg(quotient.numerator.register))
+	}
+	if input.low > input.high {
+		return arm64PoolInterval{1, 0}, true
+	}
+	return arm64PoolInterval{input.low / quotient.divisor, input.high / quotient.divisor}, true
+}
diff --git a/arm64_raw_pool_division_test.go b/arm64_raw_pool_division_test.go
new file mode 100644
index 000000000..1a7a6133d
--- /dev/null
+++ b/arm64_raw_pool_division_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"math/bits"
+	"testing"
+)
+
+func arm64PoolMaterialize(register string, value uint64) []string {
+	lines := []string{fmt.Sprintf("mov %s, #%d", register, value&0xffff)}
+	for shift := uint(16); shift < 64; shift += 16 {
+		lines = append(lines, fmt.Sprintf("movk %s, #%d, lsl #%d", register, value>>shift&0xffff, shift))
+	}
+	return lines
+}
+
+func TestARM64PoolExactDivisionRemainders(t *testing.T) {
+	for _, test := range []struct {
+		divisor, multiplier uint64
+		pre, post           uint
+	}{
+		{3, 0xaaaaaaaaaaaaaaab, 0, 1},
+		{5, 0xcccccccccccccccd, 0, 2},
+		{10, 0xcccccccccccccccd, 0, 3},
+		{100, 0x28f5c28f5c28f5c3, 2, 2},
+		{8, 0x8000000000000000, 2, 0},
+	} {
+		for _, swapped := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%d/swap=%v", test.divisor, swapped), func(t *testing.T) {
+				lines := arm64PoolMaterialize("x15", test.multiplier)
+				lines = append(lines, fmt.Sprintf("mov x16, #%d", test.divisor), "mov x21, x0",
+					fmt.Sprintf("lsr x7, x0, #%d", test.pre), "umulh x7, x7, x15",
+					fmt.Sprintf("lsr x7, x7, #%d", test.post))
+				subtract := "msub x22, x7, x16, x21"
+				if swapped {
+					lines[7] = "umulh x7, x15, x7"
+					subtract = "msub x22, x16, x7, x21"
+				}
+				lines = append(lines, subtract, "ret")
+				flow := arm64PoolTestFlow(t, lines)
+				want := arm64PoolInterval{0, test.divisor - 1}
+				if got := flow.affineInterval(len(lines)-1, arm64PoolRegisterExpression(22)); got != want {
+					t.Fatalf("remainder=%+v, want %+v", got, want)
+				}
+			})
+		}
+	}
+	flow := arm64PoolTestFlow(t, []string{
+		"mov x2, #7", "udiv x3, x0, x2", "msub x4, x3, x2, x0", "ret",
+	})
+	if got := flow.affineInterval(3, arm64PoolRegisterExpression(4)); got != (arm64PoolInterval{0, 6}) {
+		t.Fatalf("direct division remainder=%+v", got)
+	}
+}
+
+func TestARM64PoolShiftedGuardPreimage(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"lsr x2, x1, #4", "cmp x2, #624", "b.hi #12", "mov x3, x1", "nop", "ret",
+	})
+	if got := flow.affineInterval(4, arm64PoolRegisterExpression(3)); got != (arm64PoolInterval{0, 9999}) {
+		t.Fatalf("right-shift guard preimage=%+v", got)
+	}
+}
+
+func TestARM64PoolReciprocalQuotientUnderExitGuard(t *testing.T) {
+	lines := arm64PoolMaterialize("x15", 0x28f5c28f5c28f5c3)
+	lines = append(lines, "mov x21, x0", "lsr x7, x0, #2", "umulh x7, x7, x15",
+		"lsr x7, x7, #2", "lsr x21, x21, #4", "cmp x21, #624", "b.hi #8", "nop", "ret")
+	flow := arm64PoolTestFlow(t, lines)
+	if got := flow.affineInterval(11, arm64PoolRegisterExpression(7)); got != (arm64PoolInterval{0, 99}) {
+		t.Fatalf("guarded quotient=%+v", got)
+	}
+}
+
+func TestARM64PoolQuotientGuardDoesNotConstrainOldNumerator(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"mov x2, #3", "udiv x0, x0, x2", "cmp x0, #10", "b.hi #8", "nop", "ret",
+	})
+	if got := flow.affineInterval(4, arm64PoolRegisterExpression(0)); got != (arm64PoolInterval{0, 10}) {
+		t.Fatalf("quotient guard was applied to its old input: %+v", got)
+	}
+}
+
+func TestARM64PoolReciprocalProofArithmetic(t *testing.T) {
+	state := uint64(0x9e3779b97f4a7c15)
+	next := func() uint64 {
+		state ^= state << 13
+		state ^= state >> 7
+		state ^= state << 17
+		return state
+	}
+	proved := 0
+	for n := 0; n < 10000; n++ {
+		multiplier, pre, post := next(), uint(next()%64), uint(next()%64)
+		divisor, ok := arm64PoolReciprocalDivisor(multiplier, pre, post)
+		if !ok {
+			continue
+		}
+		proved++
+		for _, input := range []uint64{0, 1, divisor - 1, divisor, math.MaxUint64, next(), next()} {
+			high, _ := bits.Mul64(input>>pre, multiplier)
+			if got := high >> post; got != input/divisor {
+				t.Fatalf("invalid reciprocal proof: m=%x pre=%d post=%d d=%d n=%d q=%d", multiplier, pre, post, divisor, input, got)
+			}
+		}
+	}
+	if proved == 0 {
+		t.Fatal("reciprocal arithmetic test exercised no accepted proof")
+	}
+	for _, test := range []struct {
+		multiplier uint64
+		pre, post  uint
+	}{
+		{0, 0, 0}, {0xaaaaaaaaaaaaaaab, 64, 1}, {0xaaaaaaaaaaaaaaab, 0, 64},
+		{0xaaaaaaaaaaaaaaaa, 0, 1}, {0xaaaaaaaaaaaaaaac, 0, 1},
+		{0x28f5c28f5c28f5c3, 0, 2},
+	} {
+		if divisor, ok := arm64PoolReciprocalDivisor(test.multiplier, test.pre, test.post); ok {
+			t.Fatalf("invalid reciprocal parameters accepted as divisor %d: %+v", divisor, test)
+		}
+	}
+}
+
+func TestARM64PoolRejectsInvalidRemainderIdentities(t *testing.T) {
+	for _, test := range []struct {
+		name                      string
+		multiplier                uint64
+		divisor                   int
+		multiply, extra, subtract string
+	}{
+		{"rounded-down", 0xaaaaaaaaaaaaaaaa, 3, "umulh", "nop", "msub x22, x7, x16, x21"},
+		{"too-large", 0xaaaaaaaaaaaaaaac, 3, "umulh", "nop", "msub x22, x7, x16, x21"},
+		{"signed-high", 0xaaaaaaaaaaaaaaab, 3, "smulh", "nop", "msub x22, x7, x16, x21"},
+		{"wrong-divisor", 0xaaaaaaaaaaaaaaab, 4, "umulh", "nop", "msub x22, x7, x16, x21"},
+		{"changed-numerator", 0xaaaaaaaaaaaaaaab, 3, "umulh", "add x21, x21, #1", "msub x22, x7, x16, x21"},
+		{"changed-quotient", 0xaaaaaaaaaaaaaaab, 3, "umulh", "add x7, x7, #1", "msub x22, x7, x16, x21"},
+		{"truncated-product", 0xaaaaaaaaaaaaaaab, 3, "umulh", "nop", "msub w22, w7, w16, w21"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := arm64PoolMaterialize("x15", test.multiplier)
+			lines = append(lines, fmt.Sprintf("mov x16, #%d", test.divisor), "mov x21, x0",
+				test.multiply+" x7, x0, x15", "lsr x7, x7, #1", test.extra, test.subtract, "ret")
+			flow := arm64PoolTestFlow(t, lines)
+			if got := flow.affineInterval(len(lines)-1, arm64PoolRegisterExpression(22)); got != arm64PoolUnknownInterval {
+				t.Fatalf("invalid remainder identity accepted: %+v", got)
+			}
+		})
+	}
+	for _, shift := range []string{"lsr w2, w1, #4", "lsr x2, x1, #4"} {
+		flow := arm64PoolTestFlow(t, []string{
+			shift, "cmp x2, #624", "mov x1, x0", "b.hi #8", "nop", "ret",
+		})
+		if got := flow.affineInterval(4, arm64PoolRegisterExpression(1)); got != arm64PoolUnknownInterval {
+			t.Fatalf("shift guard bounded an unrelated replacement: %+v", got)
+		}
+	}
+}
diff --git a/arm64_raw_pool_effect_cache_test.go b/arm64_raw_pool_effect_cache_test.go
new file mode 100644
index 000000000..dd563a6e8
--- /dev/null
+++ b/arm64_raw_pool_effect_cache_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64RawPoolGPEffectsReuseHasNoDecodeAllocations(t *testing.T) {
+	// This actual register-indexed LDRB appears in the large SVE pool fixture.
+	// Repeated range/CFG queries must not rebuild unrelated SVE operands.
+	const word uint32 = 0x38616922
+	flow := &arm64RawPoolValues{}
+	want, known := arm64RawPoolGPWrites(word)
+	if !known {
+		t.Fatal("fixture lacks actual known GP effects")
+	}
+	flow.gpWrites(word)
+	allocations := testing.AllocsPerRun(100, func() {
+		got, valid := flow.gpWrites(word)
+		if got != want || valid != known {
+			t.Fatal("cached query changed its architectural effects")
+		}
+	})
+	if allocations != 0 {
+		t.Fatalf("warmed raw-word effect queries still allocate %.0f objects", allocations)
+	}
+}
+
+func TestARM64RawPoolGPEffectsPreserveKnownAndUnknownWords(t *testing.T) {
+	words := []uint32{
+		0x38616922, // LDRB with a register-indexed address.
+		0xd503201f, // NOP.
+		0xd65f03c0, // Preserve the return-form classification too.
+		0xffffffff,
+		0x00000000,
+	}
+	first, second := &arm64RawPoolValues{}, &arm64RawPoolValues{}
+	for _, word := range words {
+		want, known := arm64RawPoolGPWrites(word)
+		for repeat := 0; repeat < 3; repeat++ {
+			for _, flow := range []*arm64RawPoolValues{first, second} {
+				got, valid := flow.gpWrites(word)
+				if got != want || valid != known {
+					t.Fatalf("word %#08x: effects %#x/%v, want %#x/%v", word, got, valid, want, known)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawPoolGPEffectsKeyCompleteEncodingAndSurviveFactReset(t *testing.T) {
+	flow := &arm64RawPoolValues{}
+	for _, base := range []uint32{0x38616920, 0xf9400020, 0x04a02020, 0x65068000, 0xffffffE0} {
+		for register := uint32(0); register < 32; register++ {
+			word := base | register
+			want, known := arm64RawPoolGPWrites(word)
+			got, valid := flow.gpWrites(word)
+			if got != want || valid != known {
+				t.Fatalf("full encoding %#08x lost its exact effects", word)
+			}
+		}
+	}
+	if len(flow.gpWriteCache) != 160 {
+		t.Fatalf("cache does not retain exactly the queried machine words: %d", len(flow.gpWriteCache))
+	}
+	flow.clearValueCaches()
+	allocations := testing.AllocsPerRun(100, func() {
+		flow.gpWrites(0x38616922)
+	})
+	if allocations != 0 {
+		t.Fatal("resetting context-dependent facts rebuilt context-free effects")
+	}
+}
+
+func BenchmarkARM64RawPoolRepeatedGPEffects(b *testing.B) {
+	const word uint32 = 0x38616922
+	flow := &arm64RawPoolValues{}
+	flow.gpWrites(word)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for index := 0; index < b.N; index++ {
+		flow.gpWrites(word)
+	}
+}
diff --git a/arm64_raw_pool_flags.go b/arm64_raw_pool_flags.go
new file mode 100644
index 000000000..3c54ad663
--- /dev/null
+++ b/arm64_raw_pool_flags.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func (expression arm64PoolAffine) registerMask() uint32 {
+	var mask uint32
+	for index, coefficient := range expression.coefficient {
+		if coefficient != 0 {
+			mask |= 1 << uint(index)
+		}
+	}
+	return mask
+}
+
+// Follow a single dominating predecessor chain to the flags' definition.
+// Every intervening instruction must preserve NZCV, and the caller must also
+// check that it did not overwrite a register used in the comparison. Merely
+// finding an earlier CMP in the instruction stream proves neither property.
+func (flow *arm64RawPoolValues) affineFlagsBefore(at int) (uint32, uint32, bool) {
+	word, clobbered, _, ok := flow.affineFlagSourceBefore(at)
+	return word, clobbered, ok
+}
+
+// after is the point just after the defining arithmetic instruction. A guard
+// whose GP operands were overwritten later can still constrain their historic
+// values here, never their unrelated replacements at the branch.
+func (flow *arm64RawPoolValues) affineFlagSourceBefore(at int) (uint32, uint32, int, bool) {
+	var clobbered uint32
+	for steps := 0; steps < 512; steps++ {
+		if at < 0 || at >= len(flow.before) || len(flow.before[at]) != 1 {
+			return 0, 0, 0, false
+		}
+		at = flow.before[at][0]
+		if at < 0 {
+			return 0, 0, 0, false
+		}
+		word := flow.words[at]
+		if arm64RawPoolSVEPreservesNZCV(word) {
+			// x/arch does not decode these SVE families. Reuse their typed
+			// grammar, but keep flag effects separate from GP write effects.
+			writes, known := flow.gpWrites(word)
+			if !known {
+				return 0, 0, 0, false
+			}
+			clobbered |= writes
+			continue
+		}
+		var code [4]byte
+		binary.LittleEndian.PutUint32(code[:], word)
+		ins, err := arm64asm.Decode(code[:])
+		if err != nil {
+			return 0, 0, 0, false
+		}
+		switch ins.Op {
+		case arm64asm.CMP, arm64asm.CMN, arm64asm.ADDS, arm64asm.SUBS:
+			if word>>31 == 0 {
+				return 0, 0, 0, false // A W comparison does not constrain an X value.
+			}
+			return word, clobbered, at + 1, true
+		}
+		writes, known := flow.gpWrites(word)
+		if !known || !arm64RawPoolInstructionPreservesNZCV(ins) {
+			return 0, 0, 0, false
+		}
+		clobbered |= writes
+	}
+	return 0, 0, 0, false
+}
+
+// These complete scalable families preserve NZCV. Predicate logical operations
+// instead share the lowerer's explicit flag bit; their S variants cannot carry
+// an earlier scalar comparison. In particular, no-GP-output is insufficient:
+// SVE comparisons, WHILE*, PTEST and unknown instructions remain barriers.
+func arm64RawPoolSVEPreservesNZCV(word uint32) bool {
+	if _, ok := decodeARM64RawSVEAddress(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVECnt(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEEOR(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEDupImmediate(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEDupElement(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEDupGeneral(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVECopy(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEUnpack(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEMultiplyAccumulate(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEIntegerReduction(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+		return true
+	}
+	if ins, ok := decodeARM64RawSVEPredicateLogical(word); ok {
+		spec, known := arm64SVEPredicateLogicalSpecs[ins.Op]
+		return known && !spec.flags
+	}
+	return false
+}
+
+func arm64RawPoolInstructionPreservesNZCV(instruction arm64asm.Inst) bool {
+	if form, valid := decodeARM64RawNZCV(instruction.Enc); valid {
+		return form.read
+	}
+	if form, valid := decodeARM64RawScalarRegister(instruction.Enc); valid {
+		return !form.flags
+	}
+	if _, valid := decodeARM64RawBitfield(instruction.Enc); valid {
+		return true
+	}
+	return arm64RawPoolPreservesNZCV(instruction.Op)
+}
+
+// An explicit effect whitelist, not a guess from a mnemonic suffix. In
+// particular floating comparisons, system operations and unknown SVE flag
+// effects must stop the proof even when they have no general-register output.
+func arm64RawPoolPreservesNZCV(op arm64asm.Op) bool {
+	if arm64RawPoolReadOnlyLoad(op) {
+		return true
+	}
+	switch op {
+	case arm64asm.NOP, arm64asm.ADR, arm64asm.MOV, arm64asm.MOVK, arm64asm.MOVN, arm64asm.MOVZ,
+		arm64asm.ADD, arm64asm.SUB, arm64asm.ADC, arm64asm.SBC, arm64asm.NEG, arm64asm.NGC,
+		arm64asm.AND, arm64asm.BIC, arm64asm.ORR, arm64asm.ORN, arm64asm.EOR, arm64asm.EON, arm64asm.MVN,
+		arm64asm.LSL, arm64asm.LSR, arm64asm.ASR, arm64asm.ROR,
+		arm64asm.FMOV, arm64asm.UMOV, arm64asm.SMOV, arm64asm.ADDP, arm64asm.FADDP,
+		arm64asm.MUL, arm64asm.MNEG, arm64asm.MADD, arm64asm.MSUB,
+		arm64asm.SMADDL, arm64asm.SMSUBL, arm64asm.SMULL, arm64asm.SMNEGL, arm64asm.SMULH,
+		arm64asm.UMADDL, arm64asm.UMSUBL, arm64asm.UMULL, arm64asm.UMNEGL, arm64asm.UMULH,
+		arm64asm.EXT, arm64asm.UXTL, arm64asm.UXTL2, arm64asm.SXTL, arm64asm.SXTL2,
+		arm64asm.CMEQ, arm64asm.CMGE, arm64asm.CMGT, arm64asm.CMHI, arm64asm.CMHS,
+		arm64asm.CMLE, arm64asm.CMLT, arm64asm.CMTST,
+		arm64asm.CSEL, arm64asm.CSINC, arm64asm.CSINV, arm64asm.CSNEG,
+		arm64asm.CSET, arm64asm.CSETM, arm64asm.CINC, arm64asm.CINV, arm64asm.CNEG,
+		arm64asm.STR, arm64asm.STRB, arm64asm.STRH, arm64asm.STUR, arm64asm.STURB, arm64asm.STURH,
+		arm64asm.STTR, arm64asm.STTRB, arm64asm.STTRH, arm64asm.STLR, arm64asm.STLRB, arm64asm.STLRH,
+		arm64asm.STP, arm64asm.STNP, arm64asm.ST1, arm64asm.ST2, arm64asm.ST3, arm64asm.ST4:
+		return true
+	}
+	return false
+}
diff --git a/arm64_raw_pool_guard.go b/arm64_raw_pool_guard.go
new file mode 100644
index 000000000..0fd7c9bab
--- /dev/null
+++ b/arm64_raw_pool_guard.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import "golang.org/x/arch/arm64/arm64asm"
+
+// edgeUpper proves an unsigned bound on the selected CFG edge, not on the
+// branch instruction as a whole. Inspect both successors even when they merge:
+// the opposite edge must never inherit the taken edge's bound.
+func (flow *arm64RawPoolValues) edgeUpper(edge arm64RawPoolEdge, reg arm64asm.Reg) (uint64, bool) {
+	index, ok := arm64RawPoolGP(reg)
+	if !ok || edge.from < 0 {
+		return 0, false
+	}
+	word := flow.words[edge.from]
+	conditional := word&0xff000010 == 0x54000000
+	zeroBranch := word&0x7e000000 == 0x34000000
+	if !conditional && !zeroBranch {
+		return 0, false
+	}
+	target := edge.from + int(int32(word<<8)>>13)
+	if target == edge.from+1 || edge.to != target && edge.to != edge.from+1 {
+		return 0, false
+	}
+	taken := edge.to == target
+	if zeroBranch {
+		// W comparisons do not constrain an X register's upper 32 bits.
+		if int(word&31) != index || word>>31 == 0 && reg >= arm64asm.X0 {
+			return 0, false
+		}
+		return 0, taken == (word&(1<<24) == 0)
+	}
+
+	// Require the immediately preceding CMP to dominate this branch. Merely
+	// looking at adjacent bytes is unsound when another edge bypasses the CMP.
+	predecessors := flow.before[edge.from]
+	if len(predecessors) != 1 || predecessors[0] != edge.from-1 || edge.from == 0 {
+		return 0, false
+	}
+	compare := flow.words[edge.from-1]
+	if compare&0x7f80001f != 0x7100001f || int(compare>>5&31) != index ||
+		compare>>31 == 0 && reg >= arm64asm.X0 {
+		return 0, false
+	}
+	immediate := uint64(compare >> 10 & 4095)
+	if compare&(1<<22) != 0 {
+		immediate <<= 12
+	}
+	condition := word & 15
+	if !taken {
+		condition ^= 1
+	}
+	switch condition {
+	case 0, 9: // EQ or LS.
+		return immediate, true
+	case 3: // LO. For CMP #0 this edge has no feasible machine state.
+		if immediate == 0 {
+			return 0, true
+		}
+		return immediate - 1, true
+	default:
+		// Signed comparisons admit negative indexes; flags such as overflow
+		// and sign alone do not establish an unsigned interval.
+		return 0, false
+	}
+}
diff --git a/arm64_raw_pool_guard_test.go b/arm64_raw_pool_guard_test.go
new file mode 100644
index 000000000..f5963b379
--- /dev/null
+++ b/arm64_raw_pool_guard_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolGuardIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{
+		"adr x9, #0",
+		"cmp x1, #16", "b.hs #12", "ldrb w2, [x9, x1]", "str x2, [x0]",
+		"cmp x1, #3", "b.hi #16", "add x12, x9, x1, lsl #2", "ldr w12, [x12]", "str x12, [x0, #8]",
+		"cmp w1, #3", "b.hi #16", "add x12, x9, w1, uxtw #2", "ldr w12, [x12]", "str x12, [x0, #16]",
+		"mov x9, xzr", "mov x12, xzr", "ret",
+	}
+	lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_guard(SB),$0-16\nMOVD out+0(FP),R0\nMOVD index+8(FP),R1\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := 0; i < 4; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", uint32(0x17b4a140+i))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_guard": {
+			Name: "pool_guard", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolGuardLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolGuardIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_guard.ll", "pool_guard.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "pool_guard", triple, ir, arm64RawPoolGuardMain, nil)
+			}
+		})
+	}
+}
+
+const arm64RawPoolGuardMain = `
+#include <stdint.h>
+#include <string.h>
+extern void pool_guard(uint64_t *, uint64_t);
+int main(void) {
+  const uint32_t words[4] = {0x17b4a140, 0x17b4a141, 0x17b4a142, 0x17b4a143};
+  uint8_t bytes[16];
+  memcpy(bytes, words, sizeof(bytes));
+  const uint64_t indexes[] = {0, 1, 3, 4, 15, 16, 255, 1ULL << 32, (1ULL << 32) + 3, UINT64_MAX};
+  for (unsigned i = 0; i < sizeof(indexes) / sizeof(indexes[0]); i++) {
+    uint64_t index = indexes[i];
+    uint64_t result[5] = {0x1234, 0, 0, 0, 0x5678};
+    pool_guard(result + 1, index);
+    if (result[0] != 0x1234 || result[4] != 0x5678 ||
+        result[1] != (index < 16 ? bytes[index] : 0) ||
+        result[2] != (index <= 3 ? words[index] : 0) ||
+        result[3] != ((uint32_t)index <= 3 ? words[(uint32_t)index] : 0)) return 1;
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_pool_impossible_compare.go b/arm64_raw_pool_impossible_compare.go
new file mode 100644
index 000000000..0d3ee23db
--- /dev/null
+++ b/arm64_raw_pool_impossible_compare.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+// Remove only edges whose independently bounded incoming value cannot satisfy
+// the unchanged CMP/CMN condition. This is proof-graph refinement, not deletion
+// of executable branches. In particular, a larger VL can make an entire SVE
+// path unreachable even though its unconstrained pool offsets do not fit.
+func (flow *arm64RawPoolValues) refineConstantCompareEdges() {
+	for at, word := range flow.words {
+		if word&0xff000010 != 0x54000000 {
+			continue
+		}
+		switch word & 15 {
+		case 2, 3, 8, 9:
+		default:
+			continue
+		}
+		target := at + int(int32(word<<8)>>13)
+		for _, next := range []int{at + 1, target} {
+			if next < 0 || next >= len(flow.before) {
+				continue
+			}
+			edge := arm64RawPoolEdge{at, next}
+			guard, ok := flow.affineEdgeConstraint(edge)
+			if !ok || guard.after != 0 || guard.mask != 0 {
+				continue
+			}
+			numeric := flow.numericValues()
+			input := numeric.affineInterval(at, guard.expression)
+			if input.high < guard.interval.low || input.low > guard.interval.high {
+				flow.excludeEdge(edge)
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_impossible_compare_test.go b/arm64_raw_pool_impossible_compare_test.go
new file mode 100644
index 000000000..93eb4f717
--- /dev/null
+++ b/arm64_raw_pool_impossible_compare_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolImpossibleConstantCompareEdges(t *testing.T) {
+	for _, test := range []struct {
+		compare, branch string
+		limit           string
+	}{
+		{"cmp x1,x2", "b.hs #12", "32"},
+		{"cmp x1,x2", "b.hi #12", "31"},
+		{"cmp x1,x2", "b.lo #12", "16"},
+		{"cmp x1,x2", "b.ls #12", "15"},
+		{"cmp x1,#32", "b.hs #12", "0"},
+		{"cmn x1,x2", "b.hs #12", "15"},
+	} {
+		flow := arm64PoolTestFlow(t, []string{
+			"and x1,x0,#3", "add x1,x1,#16", "mov x2,#" + test.limit,
+			test.compare, test.branch, "mov x3,#7", "b #8", "mov x3,#99", "ret",
+		})
+		if !flow.excluded[arm64RawPoolEdge{4, 7}] {
+			t.Fatalf("%s/%s did not exclude its impossible edge", test.compare, test.branch)
+		}
+		if got := flow.affineInterval(8, arm64PoolRegisterExpression(3)); got != (arm64PoolInterval{7, 7}) {
+			t.Fatalf("impossible path polluted the joined value: %+v", got)
+		}
+	}
+}
+
+func TestARM64PoolCompareEdgesRemainWhenUnproved(t *testing.T) {
+	for _, setup := range [][]string{
+		{"nop", "mov x2,#32", "cmp x1,x2", "nop"},
+		{"mov x1,#16", "nop", "cmp x1,x2", "nop"},
+		{"mov x1,#16", "mov x2,#32", "cmp x1,x2", "cmp x0,#0"},
+		{"mov x1,#16", "mov x2,#32", "cmp x1,x2", "mov x1,#99"},
+		{"mov x1,#16", "cbz x0,#12", "cmp x1,#32", "nop"},
+	} {
+		lines := append(append([]string(nil), setup...), "b.hs #12", "mov x3,#7", "b #8", "mov x3,#99", "ret")
+		flow := arm64PoolTestFlow(t, lines)
+		if flow.excluded[arm64RawPoolEdge{4, 7}] {
+			t.Fatalf("unproved/bypassed/overwritten comparison excluded an edge: %v", setup)
+		}
+	}
+}
diff --git a/arm64_raw_pool_index_test.go b/arm64_raw_pool_index_test.go
new file mode 100644
index 000000000..1d2878e05
--- /dev/null
+++ b/arm64_raw_pool_index_test.go
@@ -0,0 +1,262 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64RawPoolBoundedIndexes(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"constant", "mov x1, #15\nldr b0, [x9, x1]", true},
+		{"mask", "and x1, x0, #15\nldr b0, [x9, x1]", true},
+		{"byte-explicit-zero-shift", "and x1, x0, #15\nldrb w2, [x9, x1, lsl #0]", true},
+		{"shifted-double", "and x1, x0, #1\nldr d0, [x9, x1, lsl #3]", true},
+		{"uxtw", "and w1, w0, #15\nldrb w2, [x9, w1, uxtw]", true},
+		{"sxtw-positive", "and w1, w0, #15\nldrb w2, [x9, w1, sxtw]", true},
+		{"sxtx-positive", "and x1, x0, #15\nldrb w2, [x9, x1, sxtx]", true},
+		{"byte-high-nibble", "ldrb w1, [x0]\nlsr x1, x1, #4\nldrb w2, [x9, x1]", true},
+		{"select", "mov w2, #8\ncsel x1, x2, xzr, ge\nldr d0, [x9, x1]", true},
+		{"select-loop", "mov w2, #8\ncsel x1, x2, xzr, ge\nldr d0, [x9, x1]\ncbnz x0, #-8", true},
+		{"mask-after-loop", "add x1, x1, #1\ncbnz x0, #-4\nand x1, x1, #15\nldrb w2, [x9, x1]", true},
+		{"dead-unbounded-predecessor", "b #8\nmov x1, x0\nand x1, x0, #15\nldrb w2, [x9, x1]", true},
+		{"join-bounded", "cbz x0, #12\nmov x1, #8\nb #8\nmov x1, #4\nldr d0, [x9, x1]", true},
+		{"definition-before-adr", "and x1, x0, #15\n@ADR@\nldrb w2, [x9, x1]", true},
+		{"zero-index", "ldr q0, [x9, xzr]", true},
+		{"guard-lo", "cmp x1, #16\nb.hs #8\nldrb w2, [x9, x1]", true},
+		{"guard-ls", "cmp x1, #15\nb.hi #8\nldrb w2, [x9, x1]", true},
+		{"guard-taken", "cmp x1, #15\nb.ls #8\nb #8\nldrb w2, [x9, x1]", true},
+		{"guard-equal", "cmp x1, #15\nb.ne #8\nldrb w2, [x9, x1]", true},
+		{"guard-word-index", "cmp w1, #15\nb.hi #8\nldrb w2, [x9, w1, uxtw]", true},
+		{"guard-zero-fallthrough", "cbnz x1, #8\nldr q0, [x9, x1]", true},
+		{"guard-zero-taken", "cbz x1, #8\nb #8\nldr q0, [x9, x1]", true},
+		{"guard-preserved-flags", "cmp x1, #16\norr x3, x3, x3\nb.hs #8\nldrb w2, [x9, x1]", true},
+		{"guard-register-equality", "cmp x1, x2\nnop\nb.ne #12\nsub x3, x1, x2\nldr q0, [x9, x3]", true},
+		{"guard-register-zero-sum", "cmn x1, x2\nnop\nb.ne #12\nadd x3, x1, x2\nldr q0, [x9, x3]", true},
+		{"guard-preserved-flags-changed-input", "cmp x1, #16\nmov x1, #16\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-register-equality-changed-input", "mov x2, #15\ncmp x1, x2\nmov x1, x0\nb.ne #8\nldrb w2, [x9, x1]", false},
+		{"guard-preserved-flags-bypassed-compare", "cbz x0, #8\ncmp x1, #16\norr x3, x3, x3\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-float-clobbered-flags", "cmp x1, #16\nfcmp d0, d1\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-conditional-clobbered-flags", "cmp x1, #16\nccmp x0, #0, #0, eq\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-system-clobbered-flags", "cmp x1, #16\nmsr nzcv, x0\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-memory-preserved-flags", "cmp x1, #16\nldr x2, [x0], #8\nb.hs #8\nldrb w2, [x9, x1]", true},
+		{"guard-memory-clobbered-input", "cmp x1, #16\nldr x2, [x1], #1\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-cmn-wrap", "sub x2, x1, #16\ncmn x2, #15\nb.lo #8\nldrb w2, [x9, x1]", true},
+		{"guard-cmn-taken", "sub x2, x1, #16\ncmn x2, #15\nb.hs #8\nb #8\nldrb w2, [x9, x1]", true},
+		{"guard-affine-difference", "sub x2, x3, x4\nsub x5, x2, #16\ncmn x5, #15\nb.lo #12\nsub x1, x3, x4\nldrb w2, [x9, x1]", true},
+		{"guard-affine-scaled", "sub x2, x3, x4\ncmp x2, #3\nb.hi #16\nlsl x1, x3, #2\nsub x1, x1, x4, lsl #2\nldr w2, [x9, x1]", true},
+		{"guard-mask-exact", "cmp x1, #8\nb.lo #24\ncmp x1, #15\nb.hi #16\nand x2, x1, #24\nsub x2, x2, #8\nldr q0, [x9, x2]", true},
+		{"guard-mask-overrun", "cmp x1, #8\nb.lo #24\ncmp x1, #16\nb.hi #16\nand x2, x1, #24\nsub x2, x2, #8\nldr q0, [x9, x2]", false},
+		{"guard-bit-infeasible-nonzero", "cmp x1, #15\nb.ls #20\ncmp x1, #19\nb.hi #16\ntbnz w1, #3, #8\nb #8\nldrb w2, [x9, x1]", true},
+		{"guard-bit-infeasible-zero", "cmp x1, #15\nb.ls #20\ncmp x1, #19\nb.hi #16\ntbz x1, #4, #8\nb #8\nldrb w2, [x9, x1]", true},
+		{"guard-bit-feasible-overrun", "cmp x1, #15\nb.ls #20\ncmp x1, #19\nb.hi #16\ntbnz x1, #4, #8\nb #8\nldrb w2, [x9, x1]", false},
+		{"guard-bit-redefined-index", "cmp x1, #15\nb.ls #24\ncmp x1, #19\nb.hi #20\ntbnz w1, #3, #12\nmov x1, #16\nb #4\nldrb w2, [x9, x1]", false},
+		{"guard-cmn-wrong-edge", "sub x2, x1, #16\ncmn x2, #15\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-cmn-bypassed", "sub x2, x1, #16\ncbz x0, #8\ncmn x2, #15\nb.lo #8\nldrb w2, [x9, x1]", false},
+		{"guard-cmn-word-not-whole-register", "sub w2, w1, #16\ncmn w2, #15\nb.lo #8\nldrb w2, [x9, x1]", false},
+		{"guard-affine-changed-source", "sub x2, x3, x4\ncmp x2, #15\nb.hi #16\nadd x3, x3, #1\nsub x1, x3, x4\nldrb w2, [x9, x1]", false},
+		{"guard-changing-flags", "cmp x1, #16\nadds x2, x2, #1\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-bypassed-compare", "cbz x0, #8\ncmp x1, #16\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-bypassed-bound", "cmp x1, #16\nb.lo #8\nnop\nldrb w2, [x9, x1]", false},
+		{"guard-word-not-whole-register", "cmp w1, #16\nb.hs #8\nldrb w2, [x9, x1]", false},
+		{"guard-signed-negative", "cmp x1, #16\nb.ge #8\nldrb w2, [x9, x1]", false},
+		{"guard-redefined-index", "cmp x1, #16\nb.hs #12\nmov x1, x0\nldrb w2, [x9, x1]", false},
+		{"guard-converged-edges", "cmp x1, #16\nb.hs #4\nldrb w2, [x9, x1]", false},
+		{"unbounded", "ldr b0, [x9, x1]", false},
+		{"mask-bypassed", "cbz x0, #8\nand x1, x1, #15\nldrb w2, [x9, x1]", false},
+		{"join-too-large", "cbz x0, #12\nmov x1, #16\nb #8\nmov x1, #4\nldrb w2, [x9, x1]", false},
+		{"loop-changing", "mov x1, #0\nldrb w2, [x9, x1]\nadd x1, x1, #1\ncbnz x0, #-8", false},
+		{"select-unbounded", "csel x1, x0, xzr, ge\nldrb w2, [x9, x1]", false},
+		{"load-overrun", "mov x1, #15\nldr h0, [x9, x1]", false},
+		{"shift-overrun", "mov x1, #2\nldr d0, [x9, x1, lsl #3]", false},
+		{"signed-negative", "mov w1, #-1\nldrb w2, [x9, w1, sxtw]", false},
+		{"unsigned-large", "mov w1, #-1\nldrb w2, [x9, w1, uxtw]", false},
+		{"writeback-clobber", "mov x1, #0\nldr w2, [x1], #32\nldrb w2, [x9, x1]", false},
+		{"pair-second-clobber", "mov x1, #0\nldp x2, x1, [x0]\nldrb w2, [x9, x1]", false},
+		{"gp-from-vector-clobber", "mov x1, #0\nfmov x1, d0\nldrb w2, [x9, x1]", false},
+		{"move-keep-clobber", "mov x1, #0\nmovk x1, #1, lsl #48\nldrb w2, [x9, x1]", false},
+		{"system-clobber-before-adr", "mov x1, #0\nmrs x1, tpidr_el0\n@ADR@\nldrb w2, [x9, x1]", false},
+		{"unknown-before-adr", "mov x1, #0\nnop\n@ADR@\nldrb w2, [x9, x1]", false},
+		{"unknown-word-clobber", "mov x1, #0\nnop\nldrb w2, [x9, x1]", false},
+		{"address-as-index", "and x1, x0, #15\nldrb w2, [x1, x9]", false},
+		{"indexed-store", "mov x1, #0\nstrb w2, [x9, x1]", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			body := test.body
+			if !strings.Contains(body, "@ADR@") {
+				body = "@ADR@\n" + body
+			}
+			lines := strings.Split(body, "\n")
+			for i, line := range lines {
+				if line == "@ADR@" {
+					lines[i] = fmt.Sprintf("adr x9, #%d", (len(lines)+2-i)*4)
+				}
+			}
+			lines = append(lines, "mov x9, xzr", "ret")
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, lines, "") {
+				if strings.HasPrefix(test.name, "unknown-") && word == 0xd503201f {
+					word = 0xffffffff
+				}
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			for i := 0; i < 4; i++ {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+			}
+			points := make([]arm64RawLayoutPoint, len(instructions))
+			for i := range points {
+				points[i].offset = int64(i * 4)
+			}
+			data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+			if got := len(data) == 4; got != test.want {
+				for _, ins := range instructions[:len(lines)] {
+					var code [4]byte
+					word := uint32(ins.Args[0].Imm)
+					binary.LittleEndian.PutUint32(code[:], word)
+					decoded, _ := arm64asm.Decode(code[:])
+					writes, known := arm64RawPoolGPWrites(word)
+					t.Logf("%s args=%#v writes=%x known=%v", decoded, decoded.Args, writes, known)
+				}
+				t.Fatalf("pool proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolIndexedMemoryForms(t *testing.T) {
+	// Go's C_ROFF load rows cover integer signed/unsigned widths and scalar
+	// floating/vector destinations. Exercise each encoding with every index
+	// extension and its optional natural-size shift, including byte LSL #0.
+	for _, load := range []struct {
+		op, reg string
+		shift   int
+	}{
+		{"ldrb", "w0", 0}, {"ldrh", "w0", 1},
+		{"ldrsb", "w0", 0}, {"ldrsb", "x0", 0},
+		{"ldrsh", "w0", 1}, {"ldrsh", "x0", 1}, {"ldrsw", "x0", 2},
+		{"ldr", "w0", 2}, {"ldr", "x0", 3},
+		{"ldr", "b0", 0}, {"ldr", "h0", 1}, {"ldr", "s0", 2},
+		{"ldr", "d0", 3}, {"ldr", "q0", 4},
+	} {
+		for _, index := range []string{"x1", "x1, lsl", "w1, uxtw", "w1, sxtw", "x1, sxtx"} {
+			for _, shifted := range []bool{false, true} {
+				if shifted && index == "x1" {
+					continue
+				}
+				address := index
+				if shifted {
+					address += fmt.Sprintf(" #%d", load.shift)
+				} else if index == "x1, lsl" {
+					continue // LSL requires the amount; plain X1 is the omitted form.
+				}
+				line := fmt.Sprintf("%s %s, [x9, %s]", load.op, load.reg, address)
+				t.Run(line, func(t *testing.T) {
+					word := assembleARM64LLVMWords(t, []string{line}, "")[0]
+					var code [4]byte
+					binary.LittleEndian.PutUint32(code[:], word)
+					ins, err := arm64asm.Decode(code[:])
+					if err != nil {
+						t.Fatal(err)
+					}
+					memory := ins.Args[1].(arm64asm.MemExtend)
+					flow := &arm64RawPoolValues{cache: map[arm64RawPoolValue]uint64{{0, memory.Index}: 1}}
+					width := int64(1) << uint(load.shift)
+					displacement := int64(1)
+					if shifted {
+						displacement = width
+					}
+					bounds := &arm64RawPoolBounds{size: displacement + width, values: flow}
+					if !arm64RawPoolIndexedLoadInBounds(ins, word, memory, 0, 0, bounds) {
+						t.Fatal("exact ending footprint rejected")
+					}
+					bounds.size--
+					if arm64RawPoolIndexedLoadInBounds(ins, word, memory, 0, 0, bounds) {
+						t.Fatal("one-byte overrun accepted")
+					}
+				})
+			}
+		}
+	}
+}
+
+func arm64RawPoolIndexedIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{
+		"adr x9, #0", "and x3, x1, #15", "ldrb w4, [x9, x3, lsl #0]", "str x4, [x0]",
+		"mov w5, #8", "cmp x2, #0", "csel x3, x5, xzr, ge", "ldr d0, [x9, x3]", "str d0, [x0, #8]",
+		"and w3, w1, #15", "ldrb w4, [x9, w3, sxtw]", "str x4, [x0, #16]",
+		"and w3, w1, #7", "ldrh w4, [x9, w3, uxtw #1]", "str x4, [x0, #24]",
+		"mov x9, xzr", "ret",
+	}
+	lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_index(SB),$0-24\nMOVD out+0(FP),R0\nMOVD index+8(FP),R1\nMOVD choose+16(FP),R2\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for _, word := range []uint32{0x17b4a14d, 0x03020100, 0x07060504, 0x0b0a0908} {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_index": {
+			Name: "pool_index", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolIndexedLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "pool_index.ll", "pool_index.o", arm64RawPoolIndexedIR(t, triple))
+		})
+	}
+}
+
+const arm64RawPoolIndexedMain = `
+#include <stdint.h>
+#include <string.h>
+extern void pool_index(uint64_t *, uint64_t, int64_t);
+int main(void) {
+  const uint8_t bytes[16] = {0x4d, 0xa1, 0xb4, 0x17, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+  const uint64_t indexes[] = {0, 1, 15, 16, 255, UINT64_MAX};
+  for (unsigned i = 0; i < sizeof(indexes) / sizeof(indexes[0]); i++) {
+    for (int choice = -1; choice <= 1; choice++) {
+      uint64_t result[6] = {0x1234, 0, 0, 0, 0, 0x5678};
+      uint64_t expected;
+      uint16_t half;
+      memcpy(&expected, bytes + (choice >= 0 ? 8 : 0), sizeof(expected));
+      memcpy(&half, bytes + (indexes[i] & 7) * 2, sizeof(half));
+      pool_index(result + 1, indexes[i], choice);
+      if (result[0] != 0x1234 || result[5] != 0x5678 ||
+          result[1] != bytes[indexes[i] & 15] || result[2] != expected ||
+          result[3] != bytes[indexes[i] & 15] || result[4] != half) return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_pool_invariant.go b/arm64_raw_pool_invariant.go
new file mode 100644
index 000000000..98aff2e38
--- /dev/null
+++ b/arm64_raw_pool_invariant.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import "math"
+
+// Prove an independent residual without collecting branch predicates. In a
+// loop an invariant pool origin retains its value while the counter and its
+// predicates change on every iteration. Repeated predicate substitution can
+// obscure that simple fact. This proof unions every path and never uses a
+// guard to discard one; changing recurrences and unknown effects fail closed.
+func (flow *arm64RawPoolValues) invariantInterval(at int, expression arm64PoolAffine) (answer arm64PoolInterval) {
+	return flow.invariantIntervalProof(at, expression, false)
+}
+
+// Full arithmetic is reserved for a certified carried invariant's entry
+// expression. Ordinary speculative residual queries keep the cheap copy-only
+// walk and its cache; they must not acquire this more expensive search mode.
+func (flow *arm64RawPoolValues) invariantIntervalProof(at int, expression arm64PoolAffine, arithmetic bool) (answer arm64PoolInterval) {
+	flow.beginAffineProof()
+	query := arm64PoolAffineQuery{at, expression}
+	if !arithmetic {
+		if cached, ok := flow.invariantCache[query]; ok {
+			return cached
+		}
+		if flow.invariantCache == nil {
+			flow.invariantCache = make(map[arm64PoolAffineQuery]arm64PoolInterval)
+		}
+		defer func() { flow.invariantCache[query] = answer }()
+	}
+	queue := []arm64PoolAffineQuery{{at, expression}}
+	visited := make(map[arm64PoolAffineQuery]bool)
+	type recurrence struct {
+		at          int
+		coefficient [31]int64
+		relocations int64
+	}
+	constants := make(map[recurrence]uint64)
+	result, found := arm64PoolInterval{math.MaxUint64, 0}, false
+	for steps := 0; len(queue) > 0; steps++ {
+		if steps >= 4096 || flow.affineWork >= 16384 {
+			return arm64PoolUnknownInterval
+		}
+		flow.affineWork++
+		state := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+		if visited[state] {
+			continue
+		}
+		visited[state] = true
+		key := recurrence{state.at, state.expression.coefficient, state.expression.relocations}
+		if previous, ok := constants[key]; ok && previous != state.expression.constant {
+			return arm64PoolUnknownInterval
+		}
+		constants[key] = state.expression.constant
+		if state.expression.isConstant() {
+			value := state.expression.constant
+			if value < result.low {
+				result.low = value
+			}
+			if value > result.high {
+				result.high = value
+			}
+			found = true
+			continue
+		}
+		if state.at < 0 || state.at >= len(flow.before) || len(flow.before[state.at]) == 0 {
+			return arm64PoolUnknownInterval
+		}
+		for _, previous := range flow.before[state.at] {
+			if previous < 0 || flow.opaque[previous] && !flow.opaquePreserves(previous, state.expression) {
+				return arm64PoolUnknownInterval
+			}
+			word := flow.words[previous]
+			writes, known := flow.gpWrites(word)
+			if !known {
+				return arm64PoolUnknownInterval
+			}
+			next := arm64PoolAffineQuery{previous, state.expression}
+			if affected := writes & next.expression.registerMask(); affected != 0 {
+				if arithmetic {
+					if savedAt, saved, ok := flow.rewindStackLoad(previous, next.expression); ok {
+						queue = append(queue, arm64PoolAffineQuery{savedAt, saved})
+						continue
+					}
+				}
+				destination, value, valid := flow.affineDefinition(word)
+				if !valid && word&0x7f800000 == 0x72800000 {
+					if constant, known := flow.materializedConstant(previous, word); known {
+						destination, value, valid = int(word&31), arm64PoolAffine{constant: constant}, true
+					}
+				}
+				if offset, origin := flow.poolOrigins[previous]; origin && word&0x9f000000 == 0x10000000 {
+					destination = int(word & 31)
+					if next.expression.coefficient[destination] != 1 {
+						return arm64PoolUnknownInterval
+					}
+					value, valid = arm64PoolAffine{constant: offset, relocations: 1}, true
+				}
+				// Follow constants, copies and constant displacements. A changing
+				// displacement recurrence is rejected above on its second visit;
+				// multi-register arithmetic belongs to the guarded solver.
+				if !arithmetic && !value.isConstant() {
+					mask := value.registerMask()
+					copy := mask != 0 && mask&(mask-1) == 0
+					for _, coefficient := range value.coefficient {
+						copy = copy && (coefficient == 0 || coefficient == 1)
+					}
+					valid = valid && copy
+				}
+				if !valid || affected != 1<<uint(destination) || !next.expression.substitute(destination, value) {
+					return arm64PoolUnknownInterval
+				}
+			}
+			queue = append(queue, next)
+		}
+	}
+	if !found {
+		return arm64PoolUnknownInterval
+	}
+	return result
+}
diff --git a/arm64_raw_pool_logical.go b/arm64_raw_pool_logical.go
new file mode 100644
index 000000000..26d2b7379
--- /dev/null
+++ b/arm64_raw_pool_logical.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math/bits"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// Logical operations already have lowering for the complete Go grammar. This
+// proof layer recognizes when OR/XOR also preserve an affine relationship:
+// operands with disjoint possible one-bits cannot carry, so OR/XOR equal ADD.
+// AND/BIC can subtract bits proved constant across the input interval. Other
+// cases retain conservative bit bounds, never an invented affine identity.
+type arm64PoolLogicalOperand struct {
+	must, may uint64
+	value     arm64PoolAffine
+	affine    bool
+}
+
+func arm64PoolIntervalBits(interval arm64PoolInterval) (must, may uint64) {
+	varying := uint64(1)<<uint(bits.Len64(interval.low^interval.high)) - 1
+	return interval.low &^ varying, interval.high | varying
+}
+
+// A pool-relative offset is not the numeric address's bit pattern. Logical
+// proofs must use ordinary integer definitions even inside a relocation proof.
+func (flow *arm64RawPoolValues) numericValues() *arm64RawPoolValues {
+	numeric := flow
+	if len(flow.poolOrigins) != 0 {
+		copy := *flow
+		copy.poolOrigins = nil
+		copy.affineCache = make(map[arm64PoolAffineQuery]arm64PoolInterval)
+		copy.invariantCache = nil
+		copy.affineActive = make(map[arm64PoolAffineQuery]bool)
+		for query, active := range flow.affineActive {
+			copy.affineActive[query] = active
+		}
+		numeric = &copy
+	}
+	return numeric
+}
+
+func (flow *arm64RawPoolValues) integerInterval(at int, reg arm64asm.Reg) arm64PoolInterval {
+	numeric := flow.numericValues()
+	expression := arm64PoolRegisterExpression(int(reg - arm64asm.X0))
+	interval := numeric.invariantInterval(at, expression)
+	if interval == arm64PoolUnknownInterval {
+		interval = numeric.affineInterval(at, expression)
+	}
+	flow.affineWork = numeric.affineWork
+	if upper := flow.upper(at, reg); upper < interval.high {
+		interval.high = upper
+	}
+	if interval.low > interval.high {
+		return arm64PoolUnknownInterval
+	}
+	return interval
+}
+
+func (flow *arm64RawPoolValues) logicalRegister(at, index int) arm64PoolLogicalOperand {
+	interval := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(index))
+	must, may := arm64PoolIntervalBits(interval)
+	value := arm64PoolRegisterExpression(index)
+	if interval.low == interval.high {
+		value = arm64PoolAffine{constant: interval.low}
+	}
+	return arm64PoolLogicalOperand{must: must, may: may, value: value, affine: true}
+}
+
+func (operand arm64PoolLogicalOperand) shifted(kind, amount uint32) arm64PoolLogicalOperand {
+	shift := func(value uint64) uint64 {
+		switch kind {
+		case 0:
+			return value << amount
+		case 1:
+			return value >> amount
+		case 2:
+			return uint64(int64(value) >> amount)
+		default:
+			return bits.RotateLeft64(value, -int(amount))
+		}
+	}
+	operand.must, operand.may = shift(operand.must), shift(operand.may)
+	if operand.must == operand.may {
+		operand.value = arm64PoolAffine{constant: operand.must}
+		operand.affine = true
+	} else if amount != 0 {
+		value := arm64PoolAffine{}
+		if kind == 0 && amount <= 30 && value.add(operand.value, int64(1)<<amount) {
+			operand.value = value
+		} else {
+			operand.affine = false
+		}
+	}
+	return operand
+}
+
+func (flow *arm64RawPoolValues) affineLogicalDefinition(at int, word uint32) (arm64PoolAffine, arm64PoolInterval, bool, bool) {
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil || word>>31 == 0 || word&31 == 31 ||
+		(ins.Op != arm64asm.ORR && ins.Op != arm64asm.EOR && ins.Op != arm64asm.AND && ins.Op != arm64asm.BIC) {
+		return arm64PoolAffine{}, arm64PoolInterval{}, false, false
+	}
+	// The decoder validates the complete logical-immediate/shifted-register
+	// encoding. Register bit fields are used only after that typed validation.
+	left := flow.logicalRegister(at, int(word>>5&31))
+	var right arm64PoolLogicalOperand
+	switch {
+	case word&0x1f800000 == 0x12000000:
+		var value uint64
+		switch immediate := ins.Args[2].(type) {
+		case arm64asm.Imm:
+			value = uint64(immediate.Imm)
+		case arm64asm.Imm64:
+			value = immediate.Imm
+		default:
+			return arm64PoolAffine{}, arm64PoolInterval{}, false, false
+		}
+		right = arm64PoolLogicalOperand{
+			must: value, may: value, value: arm64PoolAffine{constant: value}, affine: true,
+		}
+	case word&0x1f000000 == 0x0a000000:
+		right = flow.logicalRegister(at, int(word>>16&31)).shifted(word>>22&3, word>>10&63)
+	default:
+		return arm64PoolAffine{}, arm64PoolInterval{}, false, false
+	}
+	if ins.Op == arm64asm.AND || ins.Op == arm64asm.BIC {
+		if ins.Op == arm64asm.BIC {
+			right.must, right.may = ^right.may, ^right.must
+			right.affine = false
+		}
+		interval := arm64PoolInterval{left.must & right.must, left.may & right.may}
+		if interval.low == interval.high {
+			return arm64PoolAffine{constant: interval.low}, interval, true, true
+		}
+		if value, ok := left.maskedAffine(right); ok {
+			return value, interval, true, true
+		}
+		if value, ok := right.maskedAffine(left); ok {
+			return value, interval, true, true
+		}
+		return arm64PoolAffine{}, interval, false, true
+	}
+	if overlap := left.may & right.may; overlap != 0 && left.affine && right.affine {
+		// An interval loses alignment bits: [8,16] includes odd numbers even
+		// when the actual values came from n&24. Independently prove just the
+		// low-bit residue needed for disjointness, using the existing bounded
+		// arithmetic/mask grammar. Never infer alignment from the endpoints.
+		width := bits.Len64(overlap)
+		if width <= 30 {
+			step := uint64(1) << uint(width)
+			numeric := flow.numericValues()
+			if numeric.multipleOfPowerOfTwo(at, right.value, step) {
+				right.may &^= step - 1
+			} else if numeric.multipleOfPowerOfTwo(at, left.value, step) {
+				left.may &^= step - 1
+			}
+			flow.affineWork = numeric.affineWork
+		}
+	}
+	interval := arm64PoolInterval{left.must | right.must, left.may | right.may}
+	if ins.Op == arm64asm.EOR {
+		interval.low = left.must&^right.may | right.must&^left.may
+		interval.high = left.may&^right.must | right.may&^left.must
+	}
+	if interval.low == interval.high {
+		return arm64PoolAffine{constant: interval.low}, interval, true, true
+	}
+	value := left.value
+	affine := left.affine && right.affine && left.may&right.may == 0 && value.add(right.value, 1)
+	return value, interval, affine, true
+}
+
+func (operand arm64PoolLogicalOperand) maskedAffine(mask arm64PoolLogicalOperand) (arm64PoolAffine, bool) {
+	if !operand.affine || mask.must != mask.may {
+		return arm64PoolAffine{}, false
+	}
+	removed := operand.must &^ mask.must
+	if removed != operand.may&^mask.must {
+		return arm64PoolAffine{}, false
+	}
+	// Clearing fixed one-bits is subtraction without a borrow. This preserves
+	// the relation to the original input, including modular high-bit values.
+	value := operand.value
+	value.constant -= removed
+	return value, true
+}
diff --git a/arm64_raw_pool_logical_test.go b/arm64_raw_pool_logical_test.go
new file mode 100644
index 000000000..eec01a57c
--- /dev/null
+++ b/arm64_raw_pool_logical_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+func TestARM64PoolDisjointLogicalBounds(t *testing.T) {
+	for _, op := range []string{"orr", "eor"} {
+		for _, source := range []struct {
+			operand string
+			value   int
+			want    arm64PoolInterval
+		}{
+			{"x2", 16, arm64PoolInterval{16, 17}},
+			{"x2, lsl #4", 1, arm64PoolInterval{16, 17}},
+			{"x2, lsr #1", 32, arm64PoolInterval{16, 17}},
+			{"x2, asr #1", 32, arm64PoolInterval{16, 17}},
+			{"x2, ror #63", 8, arm64PoolInterval{16, 17}},
+			{"#16", 0, arm64PoolInterval{16, 17}},
+		} {
+			line := fmt.Sprintf("%s x3, x1, %s", op, source.operand)
+			t.Run(line, func(t *testing.T) {
+				flow := arm64PoolTestFlow(t, []string{
+					"and x1, x0, #1", fmt.Sprintf("mov x2, #%d", source.value), line, "ret",
+				})
+				if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != source.want {
+					t.Fatalf("logical result=%+v, want %+v", got, source.want)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolPartialMaskBounds(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{"and x1, x0, #1", "add x2, x1, #16", "ret"})
+	if got := flow.affineInterval(2, arm64PoolRegisterExpression(2)); got != (arm64PoolInterval{16, 17}) {
+		t.Fatalf("nonconstant mask lost its range: %+v", got)
+	}
+}
+
+func TestARM64PoolLogicalBoundsDoNotInventRelations(t *testing.T) {
+	for _, op := range []string{"orr", "eor"} {
+		flow := arm64PoolTestFlow(t, []string{
+			"and x1, x0, #3", "and x2, x0, #3", op + " x3, x1, x2", "ret",
+		})
+		value, span, affine, known := flow.affineLogicalDefinition(2, flow.words[2])
+		if !known || affine || span != (arm64PoolInterval{0, 3}) {
+			t.Fatalf("%s overlapping bits: value=%+v span=%+v affine=%v known=%v",
+				op, value, span, affine, known)
+		}
+		if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != span {
+			t.Fatalf("%s lost conservative bit bounds: %+v", op, got)
+		}
+	}
+	flow := arm64PoolTestFlow(t, []string{"orr w3, w1, w2", "ret"})
+	if _, _, _, known := flow.affineLogicalDefinition(0, flow.words[0]); known {
+		t.Fatal("a truncating W operation became an X affine definition")
+	}
+	flow = arm64PoolTestFlow(t, []string{
+		"cbz x0, #12", "and x1, x2, #1", "b #8", "and x1, x2, #16", "ret",
+	})
+	if got := flow.affineInterval(4, arm64PoolRegisterExpression(1)); got != (arm64PoolInterval{0, 16}) {
+		t.Fatalf("one predecessor's bound leaked into another: %+v", got)
+	}
+}
+
+func TestARM64PoolLogicalDisjointAlignmentRelation(t *testing.T) {
+	for _, op := range []string{"orr", "eor"} {
+		for _, operands := range []string{"x1,x2", "x2,x1"} {
+			line := op + " x3," + operands
+			t.Run(line, func(t *testing.T) {
+				flow := arm64PoolTestFlow(t, []string{
+					"and x1,x0,#1", "and x2,x0,#24", line, "ret",
+				})
+				query := arm64PoolRegisterExpression(3)
+				query.add(arm64PoolRegisterExpression(1), -1)
+				query.add(arm64PoolRegisterExpression(2), -1)
+				if got := flow.affineInterval(3, query); got != (arm64PoolInterval{0, 0}) {
+					t.Fatalf("disjoint variable low/aligned bits lost their sum relation: %+v", got)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolLogicalAlignmentProofBoundaries(t *testing.T) {
+	for _, op := range []string{"orr", "eor"} {
+		for _, test := range []struct {
+			name, operand string
+			definitions   []string
+			want          bool
+		}{
+			{"mask-copy", "x2", []string{"and x4,x0,#24", "mov x2,x4"}, true},
+			{"mask-bic", "x2", []string{"mov x4,#-25", "bic x2,x0,x4"}, true},
+			{"aligned-add", "x2", []string{"and x2,x0,#24", "add x2,x2,#8"}, true},
+			{"aligned-subtract-wrap", "x2", []string{"and x2,x0,#24", "sub x2,x2,#8"}, true},
+			{"shifted-alignment", "x2,lsl #1", []string{"and x2,x0,#12"}, true},
+			{"unaligned-add", "x2", []string{"and x2,x0,#24", "add x2,x2,#1"}, false},
+			{"overlapping-mask", "x2", []string{"mov x4,#25", "and x2,x0,x4"}, false},
+			{"unknown-load", "x2", []string{"ldr x2,[x4]"}, false},
+			{"unaligned-join", "x2", []string{"and x2,x0,#24", "cbz x4,#8", "add x2,x2,#1"}, false},
+			{"non-affine-right-shift", "x2,lsr #3", []string{"and x2,x0,#24"}, false},
+		} {
+			t.Run(op+"/"+test.name, func(t *testing.T) {
+				lines := append([]string{"and x1,x0,#1"}, test.definitions...)
+				at := len(lines)
+				lines = append(lines, op+" x3,x1,"+test.operand, "ret")
+				flow := arm64PoolTestFlow(t, lines)
+				_, _, affine, known := flow.affineLogicalDefinition(at, flow.words[at])
+				if !known || affine != test.want {
+					t.Fatalf("alignment relation=%v known=%v, want %v", affine, known, test.want)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolLogicalBitsAreNotRelocatedOffsets(t *testing.T) {
+	for _, test := range []struct {
+		line string
+		want arm64PoolInterval
+	}{
+		{"and x1, x0, #15", arm64PoolInterval{0, 15}},
+		{"orr x1, x0, #16", arm64PoolInterval{16, math.MaxUint64}},
+		{"eor x1, x0, #16", arm64PoolUnknownInterval},
+	} {
+		flow := arm64PoolTestFlow(t, []string{"adr x0, #8", test.line, "ret"})
+		flow.poolOrigins = map[int]uint64{0: 8}
+		if got := flow.affineInterval(2, arm64PoolRegisterExpression(1)); got != test.want {
+			t.Fatalf("%s used an offset as address bits: %+v, want %+v", test.line, got, test.want)
+		}
+	}
+}
+
+func TestARM64PoolLogicalShiftBitBounds(t *testing.T) {
+	for _, base := range []uint64{0, 31, 1 << 63, math.MaxUint64 - 31} {
+		for width := uint64(0); width < 16; width++ {
+			must, may := arm64PoolIntervalBits(arm64PoolInterval{base, base + width})
+			for kind := uint32(0); kind < 4; kind++ {
+				for _, amount := range []uint32{0, 1, 4, 30, 31, 32, 63} {
+					operand := arm64PoolLogicalOperand{
+						must: must, may: may, value: arm64PoolRegisterExpression(1), affine: true,
+					}.shifted(kind, amount)
+					for n := uint64(0); n <= width; n++ {
+						value := base + n
+						var shifted uint64
+						switch kind {
+						case 0:
+							shifted = value << amount
+						case 1:
+							shifted = value >> amount
+						case 2:
+							shifted = uint64(int64(value) >> amount)
+						case 3:
+							shifted = value>>amount | value<<((64-amount)&63)
+						}
+						if shifted&operand.must != operand.must || shifted&^operand.may != 0 {
+							t.Fatalf("shift %d/%d excluded %x: %+v", kind, amount, shifted, operand)
+						}
+						if operand.affine && operand.value.constant+uint64(operand.value.coefficient[1])*value != shifted {
+							t.Fatalf("shift %d/%d invented affine value: %+v", kind, amount, operand)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_loop.go b/arm64_raw_pool_loop.go
new file mode 100644
index 000000000..0c04fe97a
--- /dev/null
+++ b/arm64_raw_pool_loop.go
@@ -0,0 +1,308 @@
+package plan9asm
+
+import "golang.org/x/arch/arm64/arm64asm"
+
+func (flow *arm64RawPoolValues) clearValueCaches() {
+	flow.cache = make(map[arm64RawPoolValue]uint64)
+	flow.active = make(map[arm64RawPoolValue]bool)
+	flow.affineCache = nil
+	flow.affineActive = nil
+	flow.affineWork = 0
+	flow.invariantCache = nil
+	flow.maskConstants = make(map[int]uint64)
+}
+
+// Positive bounds remain valid across queries on this immutable graph.
+// Unknown can instead reflect a recursive dependency or an exhausted shared
+// budget. Keep that negative cache within one proof, not across fresh roots.
+func (flow *arm64RawPoolValues) beginAffineProof() {
+	if len(flow.affineActive) != 0 {
+		return
+	}
+	flow.affineWork = 0
+	for query, bound := range flow.affineCache {
+		if bound == arm64PoolUnknownInterval {
+			delete(flow.affineCache, query)
+		}
+	}
+	for query, bound := range flow.invariantCache {
+		if bound == arm64PoolUnknownInterval {
+			delete(flow.invariantCache, query)
+		}
+	}
+}
+
+func (flow *arm64RawPoolValues) excludeEdge(edge arm64RawPoolEdge) {
+	if flow.excluded == nil {
+		flow.excluded = make(map[arm64RawPoolEdge]bool)
+	}
+	flow.excluded[edge] = true
+	var remaining []int
+	for _, previous := range flow.before[edge.to] {
+		if previous != edge.from {
+			remaining = append(remaining, previous)
+		}
+	}
+	flow.before[edge.to] = remaining
+	if latch, recorded := flow.loopLatches[edge.to]; recorded && latch == edge.from {
+		delete(flow.loopBounds, edge.to)
+		delete(flow.loopLatches, edge.to)
+	}
+	flow.pruneUnreachablePredecessors()
+	flow.clearValueCaches()
+}
+
+func (flow *arm64RawPoolValues) pruneUnreachablePredecessors() {
+	successors := make([][]int, len(flow.before))
+	var queue []int
+	for at, predecessors := range flow.before {
+		for _, previous := range predecessors {
+			if previous < 0 {
+				queue = append(queue, at)
+			} else {
+				successors[previous] = append(successors[previous], at)
+			}
+		}
+	}
+	reachable := make([]bool, len(flow.before))
+	for len(queue) > 0 {
+		at := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+		if !reachable[at] {
+			reachable[at] = true
+			queue = append(queue, successors[at]...)
+		}
+	}
+	for at, predecessors := range flow.before {
+		var remaining []int
+		for _, previous := range predecessors {
+			if previous < 0 || reachable[previous] {
+				remaining = append(remaining, previous)
+			}
+		}
+		flow.before[at] = remaining
+	}
+}
+
+// Refine a proof graph only with facts established on its unreduced input.
+// This never rewrites executable control flow. The pointer-use walker shares
+// the excluded-edge witnesses, rather than silently ignoring an arbitrary path.
+func (flow *arm64RawPoolValues) prepareControlFlow() {
+	// A proven one-iteration loop can sharpen a later branch, which in turn
+	// sharpens another loop's entry. Refinements only remove proven-impossible
+	// paths or add independently proved invariants. A cap loses precision only.
+	for pass := 0; pass < 3; pass++ {
+		excluded, loops := len(flow.excluded), len(flow.loopBounds)
+		flow.refineBitEdges()
+		flow.refineConstantCompareEdges()
+		for latch := range flow.words {
+			flow.proveCounterLoop(latch)
+			flow.proveOrderedCounterLoop(latch)
+			flow.proveRelationalOneIterationLoop(latch)
+		}
+		flow.clearValueCaches()
+		if excluded == len(flow.excluded) && loops == len(flow.loopBounds) {
+			break
+		}
+	}
+}
+
+func (flow *arm64RawPoolValues) refineBitEdges() {
+	for at, word := range flow.words {
+		if word&0x7e000000 != 0x36000000 {
+			continue
+		}
+		input := flow.affineInterval(at, arm64PoolRegisterExpression(int(word&31)))
+		target := at + int(int32(word<<13)>>18)
+		for _, next := range []int{at + 1, target} {
+			if next < 0 || next >= len(flow.before) {
+				continue
+			}
+			edge := arm64RawPoolEdge{at, next}
+			constraint, ok := flow.affineEdgeConstraint(edge)
+			if !ok {
+				continue
+			}
+			masked := arm64PoolMaskInterval(input, constraint.mask)
+			if masked.high < constraint.interval.low || masked.low > constraint.interval.high {
+				flow.excludeEdge(edge)
+			}
+		}
+	}
+}
+
+// Recognize a single-entry straight-line body with exactly one counter update
+// and a 64-bit nonzero backedge. Unknown effects, side entries, conditional body
+// exits and flag clobbers are not induction proofs.
+func (flow *arm64RawPoolValues) proveCounterLoop(latch int) {
+	word := flow.words[latch]
+	register := -1
+	switch {
+	case word&0xff000000 == 0xb5000000:
+		register = int(word & 31)
+	case word&0xff00001f == 0x54000001:
+		compare, clobbered, ok := flow.affineFlagsBefore(latch)
+		if !ok || compare&31 == 31 || clobbered&(1<<(compare&31)) != 0 {
+			return
+		}
+		register = int(compare & 31)
+	default:
+		return
+	}
+	head := latch + int(int32(word<<8)>>13)
+	update, delta, valid := flow.counterLoopUpdate(head, latch, register)
+	if !valid {
+		return
+	}
+	if word&0xff00001f == 0x54000001 {
+		compare, _, _ := flow.affineFlagsBefore(latch)
+		if compare != flow.words[update] {
+			return
+		}
+	}
+
+	entry := flow.counterLoopEntry(head, latch)
+	if entry == nil {
+		return
+	}
+	expression := arm64PoolRegisterExpression(register)
+	initial := entry.affineInterval(head, expression)
+	if upper := entry.upper(head, arm64asm.X0+arm64asm.Reg(register)); upper < initial.high {
+		initial.high = upper
+	}
+	if initial.low > initial.high {
+		return
+	}
+	if initial.low == initial.high && initial.low+delta == 0 {
+		flow.excludeEdge(arm64RawPoolEdge{latch, head})
+		return
+	}
+	// Non-unit power-of-two strides additionally require a residue proof;
+	// a contiguous interval alone cannot establish that zero is reached.
+	bound := arm64PoolInterval{1, initial.high}
+	if delta != ^uint64(0) || initial.low == 0 || initial == arm64PoolUnknownInterval {
+		var proved bool
+		bound, proved = entry.counterStrideBound(head, expression, initial, delta)
+		if !proved {
+			return
+		}
+	}
+	if flow.loopBounds == nil {
+		flow.loopBounds = make(map[int]arm64PoolConstraint)
+	}
+	flow.loopBounds[head] = arm64PoolConstraint{expression: expression, interval: bound}
+	flow.recordLoopLatch(head, latch)
+	flow.clearValueCaches()
+}
+
+func (flow *arm64RawPoolValues) recordLoopLatch(head, latch int) {
+	if flow.loopLatches == nil {
+		flow.loopLatches = make(map[int]int)
+	}
+	flow.loopLatches[head] = latch
+}
+
+func (flow *arm64RawPoolValues) counterLoopUpdate(head, latch, register int) (int, uint64, bool) {
+	if register >= 31 || !flow.straightLineLoopBody(head, latch) {
+		return 0, 0, false
+	}
+	update := -1
+	var delta uint64
+	for at := head; at < latch; at++ {
+		current := flow.words[at]
+		writes, _ := flow.gpWrites(current)
+		if writes&(1<<uint(register)) == 0 {
+			continue
+		}
+		destination, expression, affine := flow.affineDefinition(current)
+		expected := arm64PoolRegisterExpression(register)
+		if !affine || destination != register || expression.coefficient != expected.coefficient || update != -1 {
+			return 0, 0, false
+		}
+		update, delta = at, expression.constant
+	}
+	if update == -1 || delta == 0 {
+		return 0, 0, false
+	}
+	return update, delta, true
+}
+
+func (flow *arm64RawPoolValues) straightLineLoopBody(head, latch int) bool {
+	if head < 0 || head >= latch || latch-head > 512 {
+		return false
+	}
+	for at := head + 1; at <= latch; at++ {
+		if len(flow.before[at]) != 1 || flow.before[at][0] != at-1 {
+			return false
+		}
+	}
+	for at := head; at < latch; at++ {
+		word := flow.words[at]
+		if word&0x7c000000 == 0x14000000 || word&0x7e000000 == 0x34000000 ||
+			word&0x7e000000 == 0x36000000 || word&0xff000010 == 0x54000000 ||
+			word&0xfe000000 == 0xd6000000 {
+			return false
+		}
+		if _, known := flow.gpWrites(word); !known {
+			return false
+		}
+	}
+	return true
+}
+
+func (flow *arm64RawPoolValues) counterLoopEntry(head, latch int) *arm64RawPoolValues {
+	// Infer the first iteration from external entry paths only. A prior body
+	// execution reached through an enclosing loop is opaque: deleting a
+	// backedge must not assume that such an earlier execution ran just once.
+	entry := &arm64RawPoolValues{
+		vectorBytes: flow.vectorBytes,
+		words:       flow.words, before: append([][]int(nil), flow.before...),
+		opaque: map[int]bool{latch: true}, loopBounds: flow.loopBounds,
+		opaqueLoops: map[int]int{latch: head},
+	}
+	entry.clearValueCaches()
+	// Only already-proved, structurally earlier loops can help establish this
+	// loop's entry values. Never use this loop or an enclosing loop as its
+	// own induction premise. Carried-invariant entry proofs disable these
+	// summaries again, keeping that analysis non-recursive.
+	for previousHead, previousLatch := range flow.loopLatches {
+		if previousLatch < head {
+			entry.recordLoopLatch(previousHead, previousLatch)
+		}
+	}
+	entry.before[head] = nil
+	for _, previous := range flow.before[head] {
+		if previous == latch {
+			continue
+		}
+		if previous >= head && previous < latch {
+			return nil
+		}
+		entry.before[head] = append(entry.before[head], previous)
+	}
+	if len(entry.before[head]) == 0 {
+		return nil
+	}
+	return entry
+}
+
+// An earlier execution of the same body is opaque for changing values, but
+// cannot change an expression made solely from preserved registers. Checking
+// every instruction avoids inventing a first-iteration value in an outer loop.
+func (flow *arm64RawPoolValues) opaquePreserves(at int, expression arm64PoolAffine) bool {
+	head, ok := flow.opaqueLoops[at]
+	if !ok {
+		return false
+	}
+	for instruction := head; instruction < at; instruction++ {
+		if flow.affineWork >= 16384 {
+			return false
+		}
+		flow.affineWork++
+		writes, known := flow.gpWrites(flow.words[instruction])
+		if !known || writes&expression.registerMask() != 0 {
+			return false
+		}
+	}
+	return true
+}
diff --git a/arm64_raw_pool_loop_runtime_test.go b/arm64_raw_pool_loop_runtime_test.go
new file mode 100644
index 000000000..8cac5212e
--- /dev/null
+++ b/arm64_raw_pool_loop_runtime_test.go
@@ -0,0 +1,379 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const arm64RawPoolLoopWordCount = 32
+
+func arm64RawPoolLoopSource(t *testing.T) string {
+	t.Helper()
+	lines := []string{
+		"adr x9, #0", "mov x4, xzr", "cmp x1, #7", "b.hi #0", "cbz x1, #0",
+		"ldr x3, [x9, x1, lsl #3]", "add x4, x4, x3", "subs x1, x1, #1",
+	}
+	for i := 0; i < 12; i++ {
+		lines = append(lines, "ext v0.16b, v1.16b, v2.16b, #8", "uxtl v3.4s, v4.4h",
+			"cmhi v5.8b, v6.8b, v7.8b", "mul x2, xzr, xzr")
+	}
+	lines = append(lines, fmt.Sprintf("b.ne #%d", (5-len(lines))*4))
+	lines[3] = fmt.Sprintf("b.hi #%d", (len(lines)-3)*4)
+	lines[4] = fmt.Sprintf("cbz x1, #%d", (len(lines)-4)*4)
+	lines = append(lines,
+		"str x4, [x0]",
+
+		"add x10, x9, #32", "mov x2, #-8",
+		"ldp q0, q1, [x10], #-64", "add x2, x2, #8", "cbnz x2, #-8",
+		"stp q0, q1, [x0, #16]",
+
+		"mov x10, x9", "mov x2, #16",
+		"ldp q2, q3, [x10, #16]!", "sub x2, x2, #16", "cbnz x2, #-8",
+		"stp q2, q3, [x0, #48]",
+
+		"add x10, x9, #24", "ldr x2, [x10], #8", "ldr x3, [x10, #8]!",
+		"stp x2, x3, [x0, #80]",
+
+		"mov x10, x9", "cbz x1, #8", "adr x10, #0",
+		"sub x12, x10, x2", "add x12, x12, x2", "ldr x3, [x12]", "str x3, [x0, #96]",
+	)
+	output := 104
+	for _, op := range []string{"orr", "eor"} {
+		for _, source := range []struct {
+			operand string
+			value   int
+		}{
+			{"x4", 16}, {"x4, lsl #4", 1}, {"x4, lsr #1", 32},
+			{"x4, asr #1", 32}, {"x4, ror #63", 8}, {"#16", 0},
+		} {
+			lines = append(lines, "and x2, x1, #1", fmt.Sprintf("mov x4, #%d", source.value),
+				fmt.Sprintf("%s x3, x2, %s", op, source.operand),
+				"ldrb w3, [x9, x3]", fmt.Sprintf("str x3, [x0, #%d]", output))
+			output += 8
+		}
+	}
+	for _, branch := range []struct{ up, down string }{
+		{"lt", "gt"}, {"lo", "hi"}, {"le", "ge"}, {"ls", "hs"},
+	} {
+		for _, ascending := range []bool{true, false} {
+			for _, reversed := range []bool{false, true} {
+				initial, difference, update := 8, "sub x5, x3, x2", "add x2, x2, #1"
+				condition, compare := branch.up, "cmp x2, x3"
+				if !ascending {
+					initial, difference, update = 24, "sub x5, x2, x3", "sub x2, x2, #1"
+					condition = branch.down
+				}
+				if reversed {
+					compare = "cmp x3, x2"
+					condition = branch.down
+					if !ascending {
+						condition = branch.up
+					}
+				}
+				lines = append(lines, "and x2, x1, #7", fmt.Sprintf("add x2, x2, #%d", initial),
+					"mov x3, #16", "mov x4, xzr")
+				head := len(lines)
+				lines = append(lines, difference, "ldrb w5, [x9, x5]", "add x4, x4, x5",
+					update, compare, "orr w6, w6, w7")
+				lines = append(lines, fmt.Sprintf("b.%s #%d", condition, (head-len(lines))*4),
+					fmt.Sprintf("str x4, [x0, #%d]", output))
+				output += 8
+			}
+		}
+	}
+	lines = append(lines,
+		"and x2, x1, #7", "add x2, x2, #8", "and x4, x2, #0xfffffffffffffff8",
+		"sub x5, x2, x4", "cmp x2, x4", "mov x4, xzr", "b.eq #16",
+		"sub x5, x5, #1", "ldrb w5, [x9, x5]", fmt.Sprintf("str x5, [x0, #%d]", output),
+
+		"adds x2, x1, #1", "mov x5, x2", "mov x2, xzr", "b.ne #12",
+		"ldrb w5, [x9, x5]", fmt.Sprintf("str x5, [x0, #%d]", output+8),
+
+		"and x2, x1, #15", "mov x5, x2", "cmp x2, #7", "mov x2, xzr", "b.hi #12",
+		"ldrb w5, [x9, x5]", fmt.Sprintf("str x5, [x0, #%d]", output+16),
+	)
+	output += 24
+	for _, reverse := range []bool{true, false} {
+		lines = append(lines, "and x3, x1, #7", "add x3, x3, #1", "mov x2, xzr", "mov x4, xzr")
+		load := "ldr x5, [x10], #-8"
+		if reverse {
+			lines = append(lines, "add x10, x9, x3, lsl #3", "sub x10, x10, #8")
+		} else {
+			lines = append(lines, "add x10, x9, #64", "sub x10, x10, x3, lsl #3")
+			load = "ldr x5, [x10], #8"
+		}
+		head := len(lines)
+		lines = append(lines, load, "add x4, x4, x5", "add x2, x2, #1", "cmp x2, x3")
+		lines = append(lines, fmt.Sprintf("b.lt #%d", (head-len(lines))*4),
+			fmt.Sprintf("str x4, [x0, #%d]", output), "mov x10, xzr")
+		output += 8
+	}
+	lines = append(lines,
+		"and x2, x1, #7", "str x2, [sp, #8]", "mov x2, #99", "ldr x3, [sp, #8]",
+		"ldr x3, [x9, x3, lsl #3]", fmt.Sprintf("str x3, [x0, #%d]", output),
+		"and x2, x1, #3", "add x4, x2, #4", "stp x2, x4, [sp, #8]",
+		"mov x2, #99", "mov x4, #99", "ldp x2, x4, [sp, #8]",
+		"ldr x2, [x9, x2, lsl #3]", "ldr x4, [x9, x4, lsl #3]",
+		fmt.Sprintf("str x2, [x0, #%d]", output+8), fmt.Sprintf("str x4, [x0, #%d]", output+16),
+	)
+	output += 24
+	for _, division := range []struct {
+		divisor, multiplier uint64
+		pre, post           uint
+	}{
+		{3, 0xaaaaaaaaaaaaaaab, 0, 1}, {5, 0xcccccccccccccccd, 0, 2},
+		{10, 0xcccccccccccccccd, 0, 3}, {100, 0x28f5c28f5c28f5c3, 2, 2},
+		{8, 0x8000000000000000, 2, 0},
+	} {
+		lines = append(lines, arm64PoolMaterialize("x15", division.multiplier)...)
+		lines = append(lines, fmt.Sprintf("mov x16, #%d", division.divisor), "mov x21, x1",
+			fmt.Sprintf("lsr x7, x1, #%d", division.pre), "umulh x7, x7, x15",
+			fmt.Sprintf("lsr x7, x7, #%d", division.post), "msub x22, x7, x16, x21",
+			"ldrb w22, [x9, x22]", fmt.Sprintf("str x22, [x0, #%d]", output))
+		output += 8
+	}
+	lines = append(lines, "mov x16, #7", "udiv x7, x1, x16", "msub x22, x7, x16, x1",
+		"ldrb w22, [x9, x22]", fmt.Sprintf("str x22, [x0, #%d]", output))
+	output += 8
+	lines = append(lines, arm64PoolMaterialize("x15", 0x28f5c28f5c28f5c3)...)
+	lines = append(lines, "and x2, x1, #16383", "mov x21, x2",
+		"lsr x7, x2, #2", "umulh x7, x7, x15", "lsr x7, x7, #2",
+		"lsr x21, x21, #4", "cmp x21, #624", "b.hi #12",
+		"ldrb w7, [x9, x7]", fmt.Sprintf("str x7, [x0, #%d]", output),
+		"mov x12, xzr", "mov x9, xzr", "mov x10, xzr",
+		// Skip the 32 raw data words and reach the source RET below. A
+		// hardware RET here would bypass Go's automatic $32 epilogue.
+		fmt.Sprintf("b #%d", 4*(arm64RawPoolLoopWordCount+1)))
+	lines[0] = fmt.Sprintf("adr x9, #%d", len(lines)*4)
+	for at, line := range lines {
+		if line == "adr x10, #0" {
+			lines[at] = fmt.Sprintf("adr x10, #%d", (len(lines)-at)*4+8)
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT pool_loop(SB),$32-16\nMOVD out+0(FP),R0\nMOVD count+8(FP),R1\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := 0; i < arm64RawPoolLoopWordCount; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", uint32(0x17b4a140+i))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	return source.String()
+}
+
+func arm64RawPoolLoopIR(t *testing.T, triple string) string {
+	t.Helper()
+	file, err := Parse(ArchARM64, arm64RawPoolLoopSource(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_loop": {
+			Name: "pool_loop", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawPoolLoop(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := strings.Replace(arm64RawPoolLoopSource(t), "TEXT pool_loop(SB)", "TEXT ·pool_loop(SB)", 1)
+	runARM64LocalRegisterGoOracle(t, source, arm64RawPoolLoopGoMain, len(runner) != 0)
+	ir := arm64RawPoolLoopIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "pool_loop_oracle", triple, ir, arm64RawPoolLoopMain, runner)
+}
+
+func TestARM64RawPoolLoopLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolLoopIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_loop.ll", "pool_loop.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "pool_loop", triple, ir, arm64RawPoolLoopMain, nil)
+			}
+		})
+	}
+}
+
+const arm64RawPoolLoopMain = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void pool_loop(uint64_t *, uint64_t);
+int main(void) {
+  uint32_t words[32];
+  for (unsigned i = 0; i < 32; i++) words[i] = 0x17b4a140 + i;
+  uint64_t values[16];
+  memcpy(values, words, sizeof(values));
+  const uint64_t counts[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 19, 20, 23, 32, 255,
+                             1234, 9999, 10000, 16383, 1ULL << 32, 1ULL << 63, UINT64_MAX};
+  for (unsigned i = 0; i < sizeof(counts) / sizeof(counts[0]); i++) {
+    uint64_t result[58] = {0}, expected[56] = {0};
+    result[0] = 0x12345678;
+    result[57] = 0x87654321;
+    if (counts[i] <= 7) {
+      for (uint64_t n = 1; n <= counts[i]; n++) expected[0] += values[n];
+    }
+    memcpy(expected + 2, values + 4, 32);
+    memcpy(expected + 6, values + 2, 32);
+    expected[10] = values[3];
+    expected[11] = values[5];
+    expected[12] = values[counts[i] > 7 ? 1 : 0];
+    const uint8_t *bytes = (const uint8_t *)words;
+    uint64_t remaining = counts[i] > 7 ? counts[i] : 0;
+    for (unsigned j = 13; j < 25; j++) expected[j] = bytes[16 + (remaining & 1)];
+    unsigned output = 25;
+    for (unsigned kind = 0; kind < 4; kind++) {
+      for (unsigned direction = 0; direction < 2; direction++) {
+        for (unsigned reversed = 0; reversed < 2; reversed++) {
+          unsigned distance = direction ? 8 + (remaining & 7) : 8 - (remaining & 7);
+          for (unsigned n = kind < 2 ? 1 : 0; n <= distance; n++) expected[output] += bytes[n];
+          output++;
+        }
+      }
+    }
+    if ((remaining & 7) != 0) expected[41] = bytes[(remaining & 7) - 1];
+    if (remaining == UINT64_MAX) expected[42] = bytes[0];
+    if ((remaining & 15) <= 7) expected[43] = bytes[remaining & 15];
+    unsigned distance = (remaining & 7) + 1;
+    for (unsigned n = 0; n < distance; n++) {
+      expected[44] += values[n];
+      expected[45] += values[7-n];
+    }
+    expected[46] = values[remaining & 7];
+    expected[47] = values[remaining & 3];
+    expected[48] = values[4 + (remaining & 3)];
+    const unsigned divisors[] = {3, 5, 10, 100, 8, 7};
+    for (unsigned j = 0; j < 6; j++) expected[49+j] = bytes[remaining % divisors[j]];
+    if ((remaining & 16383) <= 9999) expected[55] = bytes[(remaining & 16383) / 100];
+    pool_loop(result + 1, counts[i]);
+    if (result[0] != 0x12345678 || result[57] != 0x87654321) {
+      fprintf(stderr, "pool loop overwrote a canary for count %llu\n", (unsigned long long)counts[i]);
+      return 1;
+    }
+    for (unsigned j = 0; j < sizeof(expected) / sizeof(expected[0]); j++) {
+      if (result[j+1] != expected[j]) {
+        fprintf(stderr, "pool loop count=%llu output=%u actual=%llx expected=%llx\n",
+                (unsigned long long)counts[i], j,
+                (unsigned long long)result[j+1], (unsigned long long)expected[j]);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+
+const arm64RawPoolLoopGoMain = `package main
+
+import "encoding/binary"
+
+func pool_loop(*uint64, uint64)
+
+func main() {
+	var bytes [128]byte
+	var values [16]uint64
+	for i := 0; i < 32; i++ {
+		binary.LittleEndian.PutUint32(bytes[i*4:], uint32(0x17b4a140+i))
+	}
+	for i := range values {
+		values[i] = binary.LittleEndian.Uint64(bytes[i*8:])
+	}
+	counts := []uint64{
+		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 19, 20, 23, 32, 255,
+		1234, 9999, 10000, 16383, 1 << 32, 1 << 63, ^uint64(0),
+	}
+	for _, count := range counts {
+		var result [58]uint64
+		var expected [56]uint64
+		result[0], result[57] = 0x12345678, 0x87654321
+		if count <= 7 {
+			for n := uint64(1); n <= count; n++ {
+				expected[0] += values[n]
+			}
+		}
+		copy(expected[2:6], values[4:8])
+		copy(expected[6:10], values[2:6])
+		expected[10], expected[11] = values[3], values[5]
+		remaining := uint64(0)
+		if count > 7 {
+			expected[12], remaining = values[1], count
+		} else {
+			expected[12] = values[0]
+		}
+		for j := 13; j < 25; j++ {
+			expected[j] = uint64(bytes[16+(remaining&1)])
+		}
+		output := 25
+		for kind := 0; kind < 4; kind++ {
+			for direction := 0; direction < 2; direction++ {
+				for reversed := 0; reversed < 2; reversed++ {
+					distance := uint64(8) - (remaining & 7)
+					if direction != 0 {
+						distance = 8 + (remaining & 7)
+					}
+					start := uint64(0)
+					if kind < 2 {
+						start = 1
+					}
+					for n := start; n <= distance; n++ {
+						expected[output] += uint64(bytes[n])
+					}
+					output++
+				}
+			}
+		}
+		if remaining&7 != 0 {
+			expected[41] = uint64(bytes[(remaining&7)-1])
+		}
+		if remaining == ^uint64(0) {
+			expected[42] = uint64(bytes[0])
+		}
+		if remaining&15 <= 7 {
+			expected[43] = uint64(bytes[remaining&15])
+		}
+		for n := uint64(0); n < (remaining&7)+1; n++ {
+			expected[44] += values[n]
+			expected[45] += values[7-n]
+		}
+		expected[46] = values[remaining&7]
+		expected[47] = values[remaining&3]
+		expected[48] = values[4+(remaining&3)]
+		for j, divisor := range []uint64{3, 5, 10, 100, 8, 7} {
+			expected[49+j] = uint64(bytes[remaining%divisor])
+		}
+		if remaining&16383 <= 9999 {
+			expected[55] = uint64(bytes[(remaining&16383)/100])
+		}
+		pool_loop(&result[1], count)
+		if result[0] != 0x12345678 || result[57] != 0x87654321 {
+			panic("native Go pool loop overwrote a canary")
+		}
+		for j, want := range expected {
+			if result[j+1] != want {
+				println("pool loop", count, j, result[j+1], want)
+				panic("native Go pool loop mismatch")
+			}
+		}
+	}
+}
+`
diff --git a/arm64_raw_pool_loop_test.go b/arm64_raw_pool_loop_test.go
new file mode 100644
index 000000000..5d72e2e30
--- /dev/null
+++ b/arm64_raw_pool_loop_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func arm64PoolTestFlow(t *testing.T, lines []string) *arm64RawPoolValues {
+	t.Helper()
+	words := assembleARM64LLVMWords(t, lines, "")
+	instructions := make([]Instr, len(words))
+	reachable := make(map[int]bool)
+	for at, word := range words {
+		instructions[at] = Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}
+		reachable[at] = true
+	}
+	return newARM64RawPoolValues(instructions, 0, len(words), reachable)
+}
+
+func TestARM64PoolCounterLoops(t *testing.T) {
+	for _, test := range []struct {
+		name  string
+		lines []string
+		at    int
+		want  arm64PoolInterval
+	}{
+		{"countdown-cbnz", []string{
+			"and x1, x1, #7", "cbz x1, #20", "nop", "sub x1, x1, #1",
+			"nop", "cbnz x1, #-12", "ret",
+		}, 2, arm64PoolInterval{1, 7}},
+		{"countdown-preserved-flags", []string{
+			"and x1, x1, #7", "cbz x1, #20", "nop", "subs x1, x1, #1",
+			"orr w2, w2, w3", "b.ne #-12", "ret",
+		}, 2, arm64PoolInterval{1, 7}},
+		{"one-negative-step", []string{
+			"mov x1, #-8", "nop", "add x1, x1, #8", "cbnz x1, #-8", "ret",
+		}, 2, arm64PoolInterval{^uint64(7), ^uint64(7)}},
+		{"one-positive-step", []string{
+			"mov x1, #16", "nop", "sub x1, x1, #16", "cbnz x1, #-8", "ret",
+		}, 2, arm64PoolInterval{16, 16}},
+		{"zero-entry-wraps", []string{
+			"and x1, x1, #7", "nop", "sub x1, x1, #1", "cbnz x1, #-8", "ret",
+		}, 1, arm64PoolUnknownInterval},
+		{"wrong-step-can-wrap", []string{
+			"mov x1, #7", "nop", "sub x1, x1, #2", "cbnz x1, #-8", "ret",
+		}, 1, arm64PoolUnknownInterval},
+		{"clobbered-flags", []string{
+			"mov x1, #7", "nop", "subs x1, x1, #1", "cmp x2, #0", "b.ne #-12", "ret",
+		}, 1, arm64PoolUnknownInterval},
+		{"multiple-writes", []string{
+			"mov x1, #7", "nop", "sub x1, x1, #1", "add x1, x1, x2", "cbnz x1, #-12", "ret",
+		}, 1, arm64PoolUnknownInterval},
+		{"side-entry", []string{
+			"cbz x2, #16", "mov x1, #7", "nop", "sub x1, x1, #1", "nop", "cbnz x1, #-12", "ret",
+		}, 2, arm64PoolUnknownInterval},
+		{"word-test-not-x-bound", []string{
+			"mov x1, #7", "nop", "sub x1, x1, #1", "cbnz w1, #-8", "ret",
+		}, 1, arm64PoolUnknownInterval},
+		{"enclosing-loop-changes-entry", []string{
+			"mov x2, #1", "mov x1, #2", "nop", "sub x1, x1, #1", "add x2, x2, #1",
+			"cbnz x1, #-12", "mov x1, x2", "b #-20",
+		}, 2, arm64PoolUnknownInterval},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, test.lines)
+			if got := flow.affineInterval(test.at, arm64PoolRegisterExpression(1)); got != test.want {
+				t.Fatalf("counter interval = %+v, want %+v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64PoolExcludedBackedgeDropsInductionMetadata(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"and x1,x0,#8", "add x1,x1,#8", "nop", "sub x1,x1,#8", "cbnz x1,#-8", "ret",
+	})
+	if _, proved := flow.loopBounds[2]; !proved {
+		t.Fatal("fixture did not establish a counter loop")
+	}
+	flow.excludeEdge(arm64RawPoolEdge{4, 2})
+	if _, retained := flow.loopBounds[2]; retained {
+		t.Fatal("excluded backedge retained its induction constraint")
+	}
+	if _, retained := flow.loopLatches[2]; retained {
+		t.Fatal("excluded backedge retained its carried-value latch")
+	}
+}
+
+func TestARM64PoolImpossibleBitEdge(t *testing.T) {
+	// The backwards TBNZ edge is impossible for 16..19, but its MOV would
+	// otherwise pollute the joined result before the query becomes constant.
+	flow := arm64PoolTestFlow(t, []string{
+		"cmp x1, #16", "b.lo #36", "cmp x1, #19", "b.hi #28", "b #12",
+		"mov x2, #99", "b #12", "mov x2, #8", "tbnz w1, #3, #-12", "nop", "ret",
+	})
+	if got := flow.affineInterval(9, arm64PoolRegisterExpression(2)); got != (arm64PoolInterval{8, 8}) {
+		t.Fatalf("impossible edge polluted value: %+v", got)
+	}
+}
+
+func TestARM64PoolCounterLoopInvariantResidual(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"mov x2, #64", "mov x1, #7", "add x3, x2, x1, lsl #3",
+		"subs x1, x1, #1", "b.ne #-8", "ret",
+	})
+	if got := flow.affineInterval(3, arm64PoolRegisterExpression(3)); got != (arm64PoolInterval{72, 120}) {
+		t.Fatalf("invariant residual lost: %+v", got)
+	}
+}
+
+func TestARM64PoolCounterLoopLongPreservedFlags(t *testing.T) {
+	for _, clobber := range []bool{false, true} {
+		t.Run(fmt.Sprintf("clobber=%v", clobber), func(t *testing.T) {
+			lines := []string{"mov x1, #7", "nop", "subs x1, x1, #1"}
+			for i := 0; i < 12; i++ {
+				lines = append(lines, "ext v0.16b, v1.16b, v2.16b, #8", "uxtl v3.4s, v4.4h",
+					"cmhi v5.8b, v6.8b, v7.8b", "mul x2, x3, x4")
+			}
+			if clobber {
+				lines[20] = "tst x2, x3"
+			}
+			lines = append(lines, fmt.Sprintf("b.ne #%d", (1-len(lines))*4), "ret")
+			flow := arm64PoolTestFlow(t, lines)
+			want := arm64PoolInterval{1, 7}
+			if clobber {
+				want = arm64PoolUnknownInterval
+			}
+			if got := flow.affineInterval(1, arm64PoolRegisterExpression(1)); got != want {
+				t.Fatalf("counter = %+v, want %+v", got, want)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_mask_difference_test.go b/arm64_raw_pool_mask_difference_test.go
new file mode 100644
index 000000000..233505c6f
--- /dev/null
+++ b/arm64_raw_pool_mask_difference_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolMaskedDifference(t *testing.T) {
+	for _, test := range []struct {
+		setup, mask string
+	}{
+		{"mov x2,#24", "and x3,x1,#24"},
+		{"mov x2,#24", "ands x3,x1,#24"},
+		{"mov x2,#24", "and x3,x1,x2"},
+		{"mov x2,#24", "ands x3,x2,x1"},
+		{"mov x2,#-25", "bic x3,x1,x2"},
+		{"mov x2,#-25", "bics x3,x1,x2"},
+		{"mov x2,#12", "and x3,x1,x2,lsl #1"},
+		{"mov x2,#48", "and x3,x1,x2,lsr #1"},
+		{"mov x2,#48", "and x3,x1,x2,asr #1"},
+		{"mov x2,#12", "and x3,x1,x2,ror #63"},
+	} {
+		t.Run(test.mask, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				"and x4,x0,#15", "add x4,x4,#8", "mov x1,x4", test.setup, test.mask, "ret",
+			})
+			for _, source := range []int{1, 4} {
+				query := arm64PoolRegisterExpression(source)
+				query.add(arm64PoolRegisterExpression(3), -1)
+				if got := flow.affineInterval(5, query); got != (arm64PoolInterval{0, 7}) {
+					t.Errorf("source=x%d, masked difference=%+v, want [0,7]", source, got)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PoolMaskedDifferenceRejectsUnrelatedValues(t *testing.T) {
+	for _, mask := range []string{"and x3,x1,x2", "and w3,w1,#24"} {
+		flow := arm64PoolTestFlow(t, []string{mask, "ret"})
+		query := arm64PoolRegisterExpression(4)
+		query.add(arm64PoolRegisterExpression(3), -1)
+		if got := flow.affineInterval(1, query); got != arm64PoolUnknownInterval {
+			t.Fatalf("%s: unrelated difference bounded as %+v", mask, got)
+		}
+	}
+}
+
+func TestARM64PoolMaskedDifferenceIntersectsNonzeroGuard(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"and x1,x0,#15", "add x1,x1,#8", "and x3,x1,#24",
+		"cmp x1,x3", "b.eq #12", "sub x4,x1,x3", "nop", "ret",
+	})
+	if got := flow.affineInterval(6, arm64PoolRegisterExpression(4)); got != (arm64PoolInterval{1, 7}) {
+		t.Fatalf("nonzero masked difference=%+v, want [1,7]", got)
+	}
+	query := arm64PoolRegisterExpression(4)
+	query.constant = ^uint64(0)
+	if got := flow.affineInterval(6, query); got != (arm64PoolInterval{0, 6}) {
+		t.Fatalf("nonzero masked difference minus one=%+v, want [0,6]", got)
+	}
+}
diff --git a/arm64_raw_pool_mask_relation.go b/arm64_raw_pool_mask_relation.go
new file mode 100644
index 000000000..5e9e8fcc5
--- /dev/null
+++ b/arm64_raw_pool_mask_relation.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+type arm64PoolMaskedDefinition struct {
+	destination, source int
+	mask                uint64
+}
+
+// Normalize immediate and shifted-register AND/BIC, including flag-setting
+// forms, only after typed decoding. Both residue and difference proofs consume
+// this same definition; an unknown register mask is not a constant.
+func (flow *arm64RawPoolValues) maskedConstantDefinition(at int, word uint32) (arm64PoolMaskedDefinition, bool) {
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil || word>>31 == 0 || word&31 == 31 ||
+		(ins.Op != arm64asm.AND && ins.Op != arm64asm.ANDS && ins.Op != arm64asm.BIC && ins.Op != arm64asm.BICS) {
+		return arm64PoolMaskedDefinition{}, false
+	}
+	var mask uint64
+	source := int(word >> 5 & 31)
+	switch {
+	case word&0x1f800000 == 0x12000000:
+		switch immediate := ins.Args[2].(type) {
+		case arm64asm.Imm:
+			mask = uint64(immediate.Imm)
+		case arm64asm.Imm64:
+			mask = immediate.Imm
+		default:
+			return arm64PoolMaskedDefinition{}, false
+		}
+	case word&0x1f000000 == 0x0a000000:
+		value, known := flow.independentMaskConstant(at, int(word>>16&31))
+		if !known {
+			// Unshifted AND is commutative; BIC and a shifted variable source
+			// cannot be exchanged with the constant mask in this grammar.
+			if (ins.Op != arm64asm.AND && ins.Op != arm64asm.ANDS) || word>>10&63 != 0 {
+				return arm64PoolMaskedDefinition{}, false
+			}
+			value, known = flow.independentMaskConstant(at, source)
+			if !known {
+				return arm64PoolMaskedDefinition{}, false
+			}
+			source = int(word >> 16 & 31)
+		}
+		operand := arm64PoolLogicalOperand{must: value, may: value}.shifted(word>>22&3, word>>10&63)
+		mask = operand.must
+	default:
+		return arm64PoolMaskedDefinition{}, false
+	}
+	if ins.Op == arm64asm.BIC || ins.Op == arm64asm.BICS {
+		mask = ^mask
+	}
+	return arm64PoolMaskedDefinition{int(word & 31), source, mask}, true
+}
+
+func (flow *arm64RawPoolValues) independentMaskConstant(at, register int) (uint64, bool) {
+	// Preserve the enclosing budget and never interpret a pool-relative
+	// offset as the mask's numeric bit pattern.
+	numeric := *flow.numericValues()
+	numeric.clearValueCaches()
+	value := numeric.invariantInterval(at, arm64PoolRegisterExpression(register))
+	flow.affineWork += numeric.affineWork
+	return value.low, value.low == value.high
+}
+
+// n-(n&mask) equals n&^mask without borrow. Retain that relation even when the
+// removed bits vary. The source must survive the write; an in-place mask's old
+// source cannot be confused with its new destination.
+func (flow *arm64RawPoolValues) maskedDifferenceBound(at int, word uint32, query arm64PoolAffine, constraints []arm64PoolConstraint) (arm64PoolInterval, bool) {
+	definition, ok := flow.maskedConstantDefinition(at, word)
+	if !ok || definition.source == definition.destination {
+		return arm64PoolInterval{}, false
+	}
+	scale := -query.coefficient[definition.destination]
+	if scale == 0 {
+		return arm64PoolInterval{}, false
+	}
+	relation := arm64PoolRegisterExpression(definition.source)
+	relation.add(arm64PoolRegisterExpression(definition.destination), -1)
+	remainder := query
+	if !remainder.add(relation, -scale) {
+		return arm64PoolInterval{}, false
+	}
+	// The destination is now eliminated. Every remaining register has the
+	// same value before and after this instruction, so entry definitions are
+	// valid for the independent residual, including an aliased source.
+	residual := flow.invariantInterval(at, remainder)
+	if residual == arm64PoolUnknownInterval {
+		residual = flow.affineInterval(at, remainder)
+	}
+	if residual == arm64PoolUnknownInterval {
+		return arm64PoolInterval{}, false
+	}
+	input := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(definition.source))
+	span := arm64PoolMaskInterval(input, ^definition.mask)
+	// Apply matching guards before a negative displacement can wrap the
+	// unsigned image, e.g. n-(n&mask) != 0 followed by subtracting one.
+	constraint := arm64PoolTightenConstraint(arm64PoolConstraint{expression: relation, interval: span}, constraints)
+	if constraint.interval.low > constraint.interval.high {
+		return constraint.interval, true
+	}
+	result := arm64PoolIntervalImage(constraint.interval, scale, residual.low)
+	width := residual.high - residual.low
+	if result.high > math.MaxUint64-width || flow.affineWork >= 16384 {
+		return arm64PoolInterval{}, false
+	}
+	result.high += width
+	return result, true
+}
diff --git a/arm64_raw_pool_masked_logical_test.go b/arm64_raw_pool_masked_logical_test.go
new file mode 100644
index 000000000..ce21ab263
--- /dev/null
+++ b/arm64_raw_pool_masked_logical_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+func TestARM64PoolMaskedLogicalRelations(t *testing.T) {
+	for _, test := range []struct {
+		line string
+		mask uint64
+	}{
+		{"and x3,x1,x2", 15},
+		{"and x3,x2,x1", 15},
+		{"and x3,x1,#15", 0},
+		{"and x3,x1,x2,lsl #1", 7},
+		{"and x3,x1,x2,lsr #1", 30},
+		{"and x3,x1,x2,asr #1", 30},
+		{"and x3,x1,x2,ror #63", 1<<63 | 7},
+		{"bic x3,x1,x2", ^uint64(15)},
+		{"bic x3,x1,x2,lsl #1", ^uint64(6)},
+		{"bic x3,x1,x2,lsr #1", math.MaxUint64 - 31},
+		{"bic x3,x1,x2,asr #1", math.MaxUint64 - 31},
+		{"bic x3,x1,x2,ror #63", ^uint64(1<<63 | 7)},
+	} {
+		t.Run(test.line, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				"and x1,x0,#3", "add x1,x1,#16",
+				fmt.Sprintf("mov x2,#%#x", test.mask), test.line, "ret",
+			})
+			value, span, affine, known := flow.affineLogicalDefinition(3, flow.words[3])
+			if !known {
+				t.Fatalf("masked logical form was not modeled: %s", test.line)
+			}
+			// LSL produces a mask that drops one variable bit: it must retain
+			// bounds without pretending the result is an affine displacement.
+			shifted := test.line == "and x3,x1,x2,lsl #1" || test.line == "bic x3,x1,x2,lsl #1"
+			want := arm64PoolInterval{0, 3}
+			if shifted {
+				want.high = 2
+				if test.line == "bic x3,x1,x2,lsl #1" {
+					want.high = 1
+				}
+			}
+			if span != want || affine == shifted {
+				t.Fatalf("result=%+v affine=%v, want %+v affine=%v", span, affine, want, !shifted)
+			}
+			if affine {
+				expected := arm64PoolRegisterExpression(1)
+				expected.constant = math.MaxUint64 - 15
+				if value != expected {
+					t.Fatalf("lost n & mask = n - 16 relationship: %+v", value)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64PoolMaskedAffineConcreteValues(t *testing.T) {
+	for _, base := range []uint64{0, 16, 31, 1 << 63, math.MaxUint64 - 31} {
+		for width := uint64(0); width < 16; width++ {
+			must, may := arm64PoolIntervalBits(arm64PoolInterval{base, base + width})
+			operand := arm64PoolLogicalOperand{
+				must: must, may: may, value: arm64PoolRegisterExpression(1), affine: true,
+			}
+			for _, mask := range []uint64{0, 1, 7, 15, 16, 24, 255, 1 << 63, math.MaxUint64} {
+				value, affine := operand.maskedAffine(arm64PoolLogicalOperand{must: mask, may: mask})
+				if !affine {
+					continue
+				}
+				for n := base; n <= base+width; n++ {
+					if got := uint64(value.coefficient[1])*n + value.constant; got != n&mask {
+						t.Fatalf("mask=%#x n=%#x produced %#x from %+v", mask, n, got, value)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64PoolMaskedLogicalUnknownAndRelocatedValues(t *testing.T) {
+	for _, op := range []string{"and", "bic"} {
+		flow := arm64PoolTestFlow(t, []string{op + " x3,x1,x2", "ret"})
+		_, span, affine, known := flow.affineLogicalDefinition(0, flow.words[0])
+		if !known || affine || span != arm64PoolUnknownInterval {
+			t.Fatalf("%s invented a relation for unknown operands: %+v/%v/%v", op, span, affine, known)
+		}
+		flow = arm64PoolTestFlow(t, []string{op + " w3,w1,w2", "ret"})
+		if _, _, _, known := flow.affineLogicalDefinition(0, flow.words[0]); known {
+			t.Fatalf("%s truncating W form became an X relation", op)
+		}
+	}
+	flow := arm64PoolTestFlow(t, []string{"adr x1,#12", "mov x2,#15", "and x3,x1,x2", "ret"})
+	flow.poolOrigins = map[int]uint64{0: 16}
+	_, span, affine, known := flow.affineLogicalDefinition(2, flow.words[2])
+	if !known || affine || span != (arm64PoolInterval{0, 15}) {
+		t.Fatalf("pool offset became numeric address bits: %+v/%v/%v", span, affine, known)
+	}
+}
diff --git a/arm64_raw_pool_masked_runtime_test.go b/arm64_raw_pool_masked_runtime_test.go
new file mode 100644
index 000000000..4e1526af0
--- /dev/null
+++ b/arm64_raw_pool_masked_runtime_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolMaskedIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{"adr x9,#0", "mov x2,#15", "mov x3,#-16", "mov x6,#16", "mov x7,#19"}
+	forms := []string{"and x4,x1,x2", "and x4,x2,x1", "bic x4,x1,x3", "and x4,x1,#15"}
+	for mode, limits := range [][2]string{{"#16", "#19"}, {"x6", "x7"}} {
+		for index, form := range forms {
+			lines = append(lines, "cmp x1,"+limits[0], "b.lo #32", "cmp x1,"+limits[1], "b.hi #24", form,
+				"sub x5,x1,x4", "sub x5,x5,#16", "ldr x5,[x9,x5]", fmt.Sprintf("str x5,[x0,#%d]", (mode*len(forms)+index)*8))
+		}
+	}
+	for index, compare := range []string{"cmp x11,x4", "cmp x4,x11"} {
+		start := len(lines)
+		lines = append(lines, "cmp x1,#16", "b.lo #0", "cmp x1,#19", "b.hi #0",
+			"mov x10,x9", "mov x11,x1", "and x4,x1,x2")
+		head := len(lines)
+		// A second iteration would read beyond the twenty-four-byte pool. The
+		// relational zero proof must establish that the backedge is impossible.
+		lines = append(lines, "ldr x5,[x10],#24", "sub x11,x11,x6", compare)
+		lines = append(lines, fmt.Sprintf("b.ne #%d", (head-len(lines))*4),
+			fmt.Sprintf("str x5,[x0,#%d]", 64+index*8), "mov x10,xzr")
+		lines[start+1] = fmt.Sprintf("b.lo #%d", (len(lines)-start-1)*4)
+		lines[start+3] = fmt.Sprintf("b.hi #%d", (len(lines)-start-3)*4)
+	}
+	// The alternative load is genuinely out of bounds. Only the proved
+	// incoming 16..19 interval makes its branch impossible.
+	lines = append(lines, "and x12,x1,#3", "add x12,x12,#16", "mov x6,#32",
+		"cmp x12,x6", "b.hs #12", "ldr x5,[x9]", "b #8", "ldr x5,[x9,#24]",
+		"str x5,[x0,#80]")
+	for index := 0; index < 4; index++ {
+		ascending, carried := index&1 != 0, index&2 != 0
+		lines = append(lines, "and x11,x1,#8", "add x11,x11,#8", "mov x12,#0")
+		copy, update := "mov x10,x11", "sub x11,x11,#8"
+		if ascending {
+			lines = append(lines, "neg x11,x11")
+			copy, update = "neg x10,x11", "add x11,x11,#8"
+		}
+		if carried {
+			lines = append(lines, copy, "sub x10,x10,#8", "add x10,x9,x10")
+		}
+		head := len(lines)
+		if carried {
+			lines = append(lines, "ldr x5,[x10],#-8")
+		} else {
+			lines = append(lines, copy, "sub x10,x10,#8", "ldr x5,[x9,x10]")
+		}
+		lines = append(lines, "add x12,x12,x5", update)
+		lines = append(lines, fmt.Sprintf("cbnz x11,#%d", (head-len(lines))*4),
+			fmt.Sprintf("str x12,[x0,#%d]", 88+index*8), "mov x10,xzr")
+	}
+	lines = append(lines, "mov x6,#-25")
+	for index, mask := range []string{"and x10,x11,#24", "ands x10,x11,#24", "bic x10,x11,x6", "bics x10,x11,x6"} {
+		lines = append(lines, "and x11,x1,#15", "add x11,x11,#8", mask,
+			"sub x10,x11,x10", "ldrb w5,[x9,x10]", fmt.Sprintf("str x5,[x0,#%d]", 120+index*8))
+	}
+	for index, ascending := range []bool{false, true} {
+		lines = append(lines, "and x11,x1,#8", "add x11,x11,#8", "and x12,x1,#7",
+			"add x10,x11,x12", "sub x10,x10,#4", "add x10,x9,x10", "mov x12,#0")
+		update := "sub x11,x11,#8"
+		if ascending {
+			lines = append(lines, "neg x11,x11")
+			update = "add x11,x11,#8"
+		}
+		head := len(lines)
+		lines = append(lines, "ldrb w5,[x10],#-8", "add x12,x12,x5", update)
+		lines = append(lines, fmt.Sprintf("cbnz x11,#%d", (head-len(lines))*4),
+			fmt.Sprintf("str x12,[x0,#%d]", 152+index*8), "mov x10,xzr")
+	}
+	lines = append(lines, "and x11,x1,#15", "add x11,x11,#8", "and x10,x11,#24",
+		"cmp x11,x10", "b.eq #20", "sub x10,x11,x10", "sub x10,x10,#1",
+		"ldrb w5,[x9,x10]", "str x5,[x0,#168]")
+	// The earlier loop preserves a relation expressed using different copies
+	// of the length. Its guard excludes a zero remainder before the later
+	// countdown indexes the pool. The input is also an arbitrary base offset,
+	// including values for which base+length wraps at the machine width.
+	lines = append(lines, "and x17,x1,#15", "add x17,x17,#8", "mov x16,x1",
+		"add x14,x16,x17", "and x6,x17,#24", "neg x7,x6",
+		"nop", "add x7,x7,#8", "cbnz x7,#-8", "cmp x17,x6",
+		"b.eq #44", "sub x17,x14,x6", "add x6,x6,x16", "sub x16,x17,x16", "mov x12,#0",
+		"sub x7,x16,#1", "ldrb w5,[x9,x7]", "add x12,x12,x5", "subs x16,x16,#1", "b.ne #-16",
+		"str x12,[x0,#176]")
+	for index, op := range []string{"orr", "eor"} {
+		lines = append(lines, "and x11,x1,#15", "add x11,x11,#8", "and x10,x11,#24",
+			"and x12,x1,#1", op+" x10,x10,x12", "sub x10,x10,x12", "sub x10,x11,x10",
+			"ldrb w5,[x9,x10]", fmt.Sprintf("str x5,[x0,#%d]", 184+index*8))
+	}
+	lines = append(lines, "mov x9,xzr", "ret")
+	lines[0] = fmt.Sprintf("adr x9,#%d", len(lines)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_masked(SB),$0-16\nMOVD out+0(FP),R0\nMOVD input+8(FP),R1\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for index := 0; index < 6; index++ {
+		fmt.Fprintf(&source, "WORD $%#x\n", 0x17b4a140+index)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_masked": {
+			Name: "pool_masked", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolMaskedLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolMaskedIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_masked.ll", "pool_masked.o", ir)
+			if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "pool_masked", triple, ir, arm64RawPoolMaskedMain, nil)
+			}
+		})
+	}
+}
+
+const arm64RawPoolMaskedMain = `
+#include <stdint.h>
+#include <string.h>
+extern void pool_masked(uint64_t *, uint64_t);
+int main(void) {
+  const uint64_t inputs[] = {0, 1, 15, 16, 17, 18, 19, 20, 31, 255, UINT64_C(1)<<63, UINT64_MAX};
+  const uint64_t poolWords[] = {UINT64_C(0x17b4a14117b4a140), UINT64_C(0x17b4a14317b4a142), UINT64_C(0x17b4a14517b4a144)};
+  uint8_t poolBytes[24];
+  memcpy(poolBytes, poolWords, sizeof(poolBytes));
+  for (unsigned test = 0; test < 32 + sizeof(inputs)/sizeof(inputs[0]); test++) {
+    uint64_t out[27] = {0x1234};
+    out[26] = 0x5678;
+    uint64_t n = test < 32 ? test : inputs[test - 32];
+    pool_masked(out+1, n);
+    if (out[0] != 0x1234 || out[26] != 0x5678) return 1;
+    uint64_t expected = n >= 16 && n <= 19 ? UINT64_C(0x17b4a14117b4a140) : 0;
+    for (unsigned form = 0; form < 10; form++) {
+      if (out[form+1] != expected) return 2;
+    }
+    if (out[11] != UINT64_C(0x17b4a14117b4a140)) return 3;
+    uint64_t sum = UINT64_C(0x17b4a14117b4a140);
+    if (n & 8) sum += UINT64_C(0x17b4a14317b4a142);
+    for (unsigned form = 12; form < 16; form++) {
+      if (out[form] != sum) return 4;
+    }
+    uint64_t remainderByte = (UINT64_C(0x17b4a14117b4a140) >> ((n & 7) * 8)) & 255;
+    for (unsigned form = 16; form < 20; form++) {
+      if (out[form] != remainderByte) return 5;
+    }
+    uint64_t byteSum = 0;
+    for (unsigned remaining = (n & 8) + 8; remaining; remaining -= 8) {
+      byteSum += poolBytes[remaining + (n & 7) - 4];
+    }
+    if (out[20] != byteSum || out[21] != byteSum) return 6;
+    if (out[22] != ((n & 7) ? poolBytes[(n & 7) - 1] : 0)) return 7;
+    uint64_t tailSum = 0;
+    for (unsigned index = 0; index < (n & 7); index++) tailSum += poolBytes[index];
+    if (out[23] != tailSum) return 8;
+    if (out[24] != poolBytes[n & 7] || out[25] != poolBytes[n & 7]) return 9;
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_pool_materialize.go b/arm64_raw_pool_materialize.go
new file mode 100644
index 000000000..1ac462ff0
--- /dev/null
+++ b/arm64_raw_pool_materialize.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// Track overwritten bit fields back to an immediate seed. This is a finite
+// definition walk, not a recursive value query, so a MOVK inside a changing
+// loop cannot recursively ask itself for its own input. Covering every bit
+// also proves a constant without an initial MOVZ/MOVN.
+func (flow *arm64RawPoolValues) materializedConstant(at int, word uint32) (uint64, bool) {
+	keep, value := uint64(math.MaxUint64), uint64(0)
+	for steps := 0; steps < 64; steps++ {
+		ins, decoded := arm64PoolDecodeWord(word)
+		if !decoded {
+			return 0, false
+		}
+		if ins.Op != arm64asm.MOVK {
+			_, initial, affine := arm64PoolAffineDefinition(word)
+			if affine && initial.isConstant() && initial.relocations == 0 {
+				return value | initial.constant&keep, true
+			}
+			return 0, false
+		}
+		shift := (word >> 21 & 3) * 16
+		mask := uint64(0xffff) << shift
+		value |= uint64(word>>5&0xffff) << shift & keep
+		keep &^= mask
+		if word>>31 == 0 {
+			keep &= math.MaxUint32
+		}
+		if keep == 0 {
+			return value, true
+		}
+		_, previous, known := flow.valueDefinition(arm64PoolValuePoint{at, int(word & 31)})
+		if !known {
+			return 0, false
+		}
+		at, word = previous, flow.words[previous]
+	}
+	return 0, false
+}
+
+func (flow *arm64RawPoolValues) affineMoveKeepInterval(at int, word uint32) (arm64PoolInterval, bool) {
+	if word&0x7f800000 != 0x72800000 || word&31 == 31 {
+		return arm64PoolInterval{}, false
+	}
+	ins, ok := arm64PoolDecodeWord(word)
+	if !ok || ins.Op != arm64asm.MOVK {
+		return arm64PoolInterval{}, false
+	}
+	if constant, known := flow.materializedConstant(at, word); known {
+		return arm64PoolInterval{constant, constant}, true
+	}
+	shift := (word >> 21 & 3) * 16
+	mask := ^(uint64(0xffff) << shift)
+	if word>>31 == 0 {
+		mask &= math.MaxUint32 // A W write also clears the entire upper X half.
+	}
+	input := flow.integerInterval(at, arm64asm.X0+arm64asm.Reg(word&31))
+	result := arm64PoolMaskInterval(input, mask)
+	immediate := uint64(word>>5&0xffff) << shift
+	// Both extrema have the replaced field cleared. OR is therefore an
+	// exact addition of that field, with no carry into any preserved bit.
+	result.low |= immediate
+	result.high |= immediate
+	return result, true
+}
diff --git a/arm64_raw_pool_materialize_test.go b/arm64_raw_pool_materialize_test.go
new file mode 100644
index 000000000..deba3c83d
--- /dev/null
+++ b/arm64_raw_pool_materialize_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolMoveWideConstants(t *testing.T) {
+	for _, width := range []int{32, 64} {
+		for shift := 0; shift < width; shift += 16 {
+			for _, immediate := range []uint64{0, 0x1234, 0xffff} {
+				name := fmt.Sprintf("%d/shift%d/%x", width, shift, immediate)
+				t.Run(name, func(t *testing.T) {
+					register := "x1"
+					initial := uint64(0x0123456789abcdef)
+					if width == 32 {
+						register = "w1"
+						initial = uint64(uint32(initial))
+					}
+					lines := []string{
+						"mov x1, #0xcdef", "movk x1, #0x89ab, lsl #16",
+						"movk x1, #0x4567, lsl #32", "movk x1, #0x123, lsl #48",
+						fmt.Sprintf("movk %s, #%d, lsl #%d", register, immediate, shift), "ret",
+					}
+					flow := arm64PoolTestFlow(t, lines)
+					want := initial&^(uint64(0xffff)<<uint(shift)) | immediate<<uint(shift)
+					if got := flow.affineInterval(5, arm64PoolRegisterExpression(1)); got != (arm64PoolInterval{want, want}) {
+						t.Fatalf("wide constant = %+v, want %x", got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64PoolMoveWideInvariantAndCompleteOverwrite(t *testing.T) {
+	for _, initial := range []string{"mov x1, #0xcdef", "movk x1, #0xcdef"} {
+		lines := []string{initial, "movk x1, #0x89ab, lsl #16",
+			"movk x1, #0x4567, lsl #32", "movk x1, #0x123, lsl #48",
+			"add x2, x2, #1", "cmp x2, x0", "b.ne #-8", "ret"}
+		flow := arm64PoolTestFlow(t, lines)
+		want := arm64PoolInterval{0x0123456789abcdef, 0x0123456789abcdef}
+		if got := flow.invariantInterval(7, arm64PoolRegisterExpression(1)); got != want {
+			t.Fatalf("materialized invariant %q=%+v", initial, got)
+		}
+	}
+}
diff --git a/arm64_raw_pool_memory.go b/arm64_raw_pool_memory.go
new file mode 100644
index 000000000..951dd49b6
--- /dev/null
+++ b/arm64_raw_pool_memory.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"math"
+	"strconv"
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func arm64RawPoolIndexedLoadInBounds(ins arm64asm.Inst, word uint32, memory arm64asm.MemExtend, at int, offset int64, bounds *arm64RawPoolBounds) bool {
+	upper := bounds.values.boundedUpper(at, memory.Index)
+	switch memory.Extend.String() {
+	case "UXTW":
+		if upper > math.MaxUint32 {
+			upper = math.MaxUint32
+		}
+	case "SXTW":
+		if upper > math.MaxInt32 {
+			return false
+		}
+	case "SXTX":
+		if upper > math.MaxInt64 {
+			return false
+		}
+	case "LSL":
+	default:
+		return false
+	}
+	shift := memory.Amount
+	if memory.ShiftMustBeZero {
+		shift = 0
+	}
+	if offset < 0 || shift >= 63 || upper > uint64(math.MaxInt64-offset)>>shift {
+		return false
+	}
+	return arm64RawPoolContains(offset+int64(upper<<shift), arm64RawPoolLoadBytes(ins, word), bounds.size)
+}
+
+func arm64RawPoolContains(offset, bytes, size int64) bool {
+	return offset >= 0 && bytes > 0 && bytes <= size && offset <= size-bytes
+}
+
+func arm64RawPoolReplicateLoad(word uint32) (Instr, bool) {
+	if ins, ok := decodeARM64RawSVEReplicateScalar(word); ok {
+		return ins, true
+	}
+	return decodeARM64RawSVEReplicateBlock(word)
+}
+
+func arm64RawPoolLoadInBounds(ins arm64asm.Inst, word uint32, memory arm64asm.MemImmediate, offset, size int64) bool {
+	displacement, _, ok := arm64PoolImmediateAddress(memory)
+	if !ok {
+		return false
+	}
+	if memory.Mode != arm64asm.AddrOffset {
+		if _, _, valid := arm64PoolLoadWriteback(ins, word); !valid {
+			return false
+		}
+	}
+	return arm64RawPoolContains(offset+displacement, arm64RawPoolLoadBytes(ins, word), size)
+}
+
+// Return the load displacement and the separate base-register update. A post
+// index is not part of the read footprint; a pre index is part of both effects.
+func arm64PoolImmediateAddress(memory arm64asm.MemImmediate) (int64, int64, bool) {
+	// x/arch exposes the addressing mode but keeps the decoded immediate
+	// private. Its checked printer specifies offset, pre and post separately.
+	// Use that checked representation rather than duplicating every encoder.
+	text := memory.String()
+	prefix := "[" + memory.Base.String()
+	suffix := "]"
+	switch memory.Mode {
+	case arm64asm.AddrOffset:
+		if text == prefix+"]" {
+			return 0, 0, true
+		}
+		prefix += ",#"
+	case arm64asm.AddrPreIndex:
+		prefix, suffix = prefix+",#", "]!"
+	case arm64asm.AddrPostIndex:
+		prefix, suffix = prefix+"],#", ""
+	default:
+		return 0, 0, false
+	}
+	if !strings.HasPrefix(text, prefix) || !strings.HasSuffix(text, suffix) {
+		return 0, 0, false
+	}
+	delta, err := strconv.ParseInt(strings.TrimSuffix(strings.TrimPrefix(text, prefix), suffix), 10, 32)
+	if err != nil {
+		return 0, 0, false
+	}
+	switch memory.Mode {
+	case arm64asm.AddrPreIndex:
+		return delta, delta, true
+	case arm64asm.AddrPostIndex:
+		return 0, delta, true
+	}
+	return delta, 0, true
+}
+
+func arm64PoolLoadWriteback(ins arm64asm.Inst, word uint32) (int, int64, bool) {
+	if !arm64RawPoolReadOnlyLoad(ins.Op) || arm64RawPoolLoadBytes(ins, word) == 0 {
+		return 0, 0, false
+	}
+	for _, arg := range ins.Args {
+		memory, ok := arg.(arm64asm.MemImmediate)
+		if !ok || memory.Mode != arm64asm.AddrPreIndex && memory.Mode != arm64asm.AddrPostIndex {
+			continue
+		}
+		base, gp := arm64RawPoolGP(arm64asm.Reg(memory.Base))
+		_, delta, valid := arm64PoolImmediateAddress(memory)
+		if !gp || !valid {
+			return 0, 0, false
+		}
+		for _, output := range ins.Args {
+			if register, ok := output.(arm64asm.Reg); ok {
+				if index, gp := arm64RawPoolGP(register); gp && index == base {
+					return 0, 0, false // Constrained-unpredictable base/destination overlap.
+				}
+			}
+		}
+		return base, delta, true
+	}
+	return 0, 0, false
+}
+
+func arm64RawPoolLoadBytes(ins arm64asm.Inst, word uint32) int64 {
+	switch ins.Op {
+	case arm64asm.LDRB, arm64asm.LDRSB, arm64asm.LDURB, arm64asm.LDURSB,
+		arm64asm.LDTRB, arm64asm.LDTRSB, arm64asm.LDARB:
+		return 1
+	case arm64asm.LDRH, arm64asm.LDRSH, arm64asm.LDURH, arm64asm.LDURSH,
+		arm64asm.LDTRH, arm64asm.LDTRSH, arm64asm.LDARH:
+		return 2
+	case arm64asm.LDRSW, arm64asm.LDURSW, arm64asm.LDTRSW:
+		return 4
+	case arm64asm.LDPSW:
+		return 8
+	case arm64asm.LDR, arm64asm.LDUR, arm64asm.LDTR, arm64asm.LDAR,
+		arm64asm.LDP, arm64asm.LDNP:
+		reg, ok := ins.Args[0].(arm64asm.Reg)
+		if !ok {
+			return 0
+		}
+		bytes := int64(0)
+		switch {
+		case reg >= arm64asm.B0 && reg <= arm64asm.B31:
+			bytes = 1
+		case reg >= arm64asm.H0 && reg <= arm64asm.H31:
+			bytes = 2
+		case reg >= arm64asm.W0 && reg <= arm64asm.WZR || reg >= arm64asm.S0 && reg <= arm64asm.S31:
+			bytes = 4
+		case reg >= arm64asm.X0 && reg <= arm64asm.XZR || reg >= arm64asm.D0 && reg <= arm64asm.D31:
+			bytes = 8
+		case reg >= arm64asm.Q0 && reg <= arm64asm.Q31:
+			bytes = 16
+		}
+		if ins.Op == arm64asm.LDP || ins.Op == arm64asm.LDNP {
+			bytes *= 2
+		}
+		return bytes
+	case arm64asm.LD1R, arm64asm.LD2R, arm64asm.LD3R, arm64asm.LD4R:
+		if form, ok := decodeARM64RawLDnR(word); ok && !form.post {
+			return int64(form.count * form.arrangement.elementBits / 8)
+		}
+	case arm64asm.LD1, arm64asm.LD2, arm64asm.LD3, arm64asm.LD4:
+		if form, ok := decodeARM64RawStructureLane(word); ok && form.load && !form.post {
+			return int64(form.count * form.elementBits / 8)
+		}
+		// x/arch already validated this multiple-structure instruction.
+		// Restrict to no writeback, then use opcode's register count and Q.
+		if word&0xbfff0000 == 0x0c400000 {
+			count := map[uint32]int64{0: 4, 2: 4, 4: 3, 6: 3, 7: 1, 8: 2, 10: 2}[word>>12&15]
+			return count * (8 << (word >> 30 & 1))
+		}
+	}
+	return 0
+}
diff --git a/arm64_raw_pool_negate_test.go b/arm64_raw_pool_negate_test.go
new file mode 100644
index 000000000..7144317b1
--- /dev/null
+++ b/arm64_raw_pool_negate_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolAffineNegateAliases(t *testing.T) {
+	type example struct {
+		line   string
+		value  arm64PoolAffine
+		affine bool
+	}
+	var examples []example
+	for _, opcode := range []string{"neg", "negs"} {
+		for _, width := range []string{"x", "w"} {
+			for _, shift := range []string{"lsl", "lsr", "asr"} {
+				for _, amount := range []uint{0, 1, 30, 31, 63} {
+					if width == "w" && amount > 31 {
+						continue
+					}
+					line := fmt.Sprintf("%s %s1,%s2,%s #%d", opcode, width, width, shift, amount)
+					affine := width == "x" && shift == "lsl" && amount <= 30
+					var value arm64PoolAffine
+					if affine {
+						value.coefficient[2] = -(int64(1) << amount)
+					}
+					examples = append(examples, example{line, value, affine})
+				}
+			}
+		}
+		examples = append(examples, example{opcode + " x1,xzr", arm64PoolAffine{}, true})
+	}
+	var lines []string
+	for _, test := range examples {
+		lines = append(lines, test.line)
+	}
+	words := assembleARM64LLVMWords(t, lines, "")
+	for at, test := range examples {
+		destination, value, affine := arm64PoolAffineDefinition(words[at])
+		if affine != test.affine || affine && (destination != 1 || value != test.value) {
+			t.Errorf("%s: destination=%d value=%+v affine=%v, want %+v affine=%v",
+				test.line, destination, value, affine, test.value, test.affine)
+		}
+	}
+}
diff --git a/arm64_raw_pool_offset_test.go b/arm64_raw_pool_offset_test.go
new file mode 100644
index 000000000..ba3935304
--- /dev/null
+++ b/arm64_raw_pool_offset_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64RawPoolBoundedOffsets(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"add", "add x9, x9, #16\nldr q0, [x9]", true},
+		{"subtract", "sub x9, x9, #16\nldr q0, [x9]", true},
+		{"negative-load-offset", "add x9, x9, #16\nldur x0, [x9, #-32]", true},
+		{"pair-end", "add x9, x9, #32\nldp x0, x1, [x9]", true},
+		{"scalar-post-index", "ldr x0, [x9], #8\nldr x1, [x9]", true},
+		{"scalar-pre-index", "ldr x0, [x9, #-16]!\nldr x1, [x9]", true},
+		{"pair-post-index", "ldp q0, q1, [x9], #16\nldp q2, q3, [x9]", true},
+		{"pair-pre-index", "ldp q0, q1, [x9, #16]!", true},
+		{"post-index-transient-before-pool", "ldr x0, [x9], #-32\nadd x9, x9, #32\nldr x1, [x9]", true},
+		{"post-index-underrun", "ldr x0, [x9], #-32\nldr x1, [x9]", false},
+		{"post-index-overrun", "ldr x0, [x9], #48\nldr x1, [x9]", false},
+		{"pre-index-overrun", "ldp q0, q1, [x9, #32]!", false},
+		{"countdown-index", "mov x1, #5\nldr x0, [x9, x1, lsl #3]\nsubs x1, x1, #1\nb.ne #-8", true},
+		{"countdown-index-overrun", "mov x1, #6\nldr x0, [x9, x1, lsl #3]\nsubs x1, x1, #1\nb.ne #-8", false},
+		{"single-vector-iteration", "mov x1, #16\nldp q0, q1, [x9], #64\nsub x1, x1, #16\ncbnz x1, #-8", true},
+		{"second-vector-iteration-overrun", "mov x1, #32\nldp q0, q1, [x9], #64\nsub x1, x1, #16\ncbnz x1, #-8", false},
+		{"replicate-scalar", "add x9, x9, #40\nld1rd {z0.d}, p0/z, [x9]", true},
+		{"replicate-block", "add x9, x9, #16\nld1rqd {z0.d}, p0/z, [x9]", true},
+		{"past-end", "add x9, x9, #48\nldr b0, [x9]", false},
+		{"before-start", "sub x9, x9, #17\nldr b0, [x9]", false},
+		{"load-overrun", "add x9, x9, #40\nldr q0, [x9]", false},
+		{"pair-overrun", "add x9, x9, #40\nldp x0, x1, [x9]", false},
+		{"replicate-overrun", "add x9, x9, #44\nld1rd {z0.d}, p0/z, [x9]", false},
+		{"replicate-block-overrun", "add x9, x9, #40\nld1rqd {z0.d}, p0/z, [x9]", false},
+		{"negative-load-underrun", "sub x9, x9, #16\nldur x0, [x9, #-1]", false},
+		{"shifted-overrun", "add x9, x9, #1, lsl #12\nldr x0, [x9]", false},
+		{"truncating", "add w9, w9, #16\nldr x0, [x9]", false},
+		{"address-flags", "adds x9, x9, #16\nldr x0, [x9]", false},
+		{"escaping", "add x9, x9, #16\nstr x9, [x0]", false},
+		{"index-unknown", "add x9, x9, #16\nldr x0, [x9, x1]", false},
+		{"offset-loop", "add x9, x9, #8\nldr x0, [x9]\ncbnz x1, #-8", false},
+		{"same-offset-join", "cbz x1, #8\nadd x9, x9, #0\nldr x0, [x9]", true},
+		{"different-offset-join", "cbz x1, #8\nadd x9, x9, #8\nldr x0, [x9]", true},
+		{"different-offset-join-overrun", "cbz x1, #8\nadd x9, x9, #48\nldr x0, [x9]", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			body := strings.Split(test.body, "\n")
+			lines := []string{fmt.Sprintf("adr x9, #%d", (len(body)+3)*4+16)}
+			lines = append(lines, body...)
+			lines = append(lines, "mov x9, xzr", "ret")
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			for i := 0; i < 16; i++ {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+			}
+			points := make([]arm64RawLayoutPoint, len(instructions))
+			for i := range points {
+				points[i].offset = int64(i * 4)
+			}
+			data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+			if got := len(data) == 16; got != test.want {
+				t.Fatalf("pool proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolLoadFootprints(t *testing.T) {
+	type footprint struct {
+		line  string
+		bytes int64
+	}
+	var cases []footprint
+	for _, load := range []struct {
+		op, reg string
+		bytes   int64
+	}{
+		{"ldr", "b0", 1}, {"ldr", "h0", 2}, {"ldr", "s0", 4},
+		{"ldr", "d0", 8}, {"ldr", "q0", 16}, {"ldr", "w0", 4}, {"ldr", "x0", 8},
+		{"ldrb", "w0", 1}, {"ldrh", "w0", 2},
+		{"ldrsb", "w0", 1}, {"ldrsb", "x0", 1},
+		{"ldrsh", "w0", 2}, {"ldrsh", "x0", 2}, {"ldrsw", "x0", 4},
+		{"ldur", "b0", 1}, {"ldur", "h0", 2}, {"ldur", "s0", 4},
+		{"ldur", "d0", 8}, {"ldur", "q0", 16}, {"ldur", "w0", 4}, {"ldur", "x0", 8},
+		{"ldurb", "w0", 1}, {"ldurh", "w0", 2},
+		{"ldursb", "w0", 1}, {"ldursb", "x0", 1},
+		{"ldursh", "w0", 2}, {"ldursh", "x0", 2}, {"ldursw", "x0", 4},
+		{"ldtr", "w0", 4}, {"ldtr", "x0", 8}, {"ldtrb", "w0", 1}, {"ldtrh", "w0", 2},
+		{"ldtrsb", "w0", 1}, {"ldtrsb", "x0", 1}, {"ldtrsh", "w0", 2}, {"ldtrsh", "x0", 2}, {"ldtrsw", "x0", 4},
+		{"ldar", "w0", 4}, {"ldar", "x0", 8}, {"ldarb", "w0", 1}, {"ldarh", "w0", 2},
+	} {
+		cases = append(cases, footprint{load.op + " " + load.reg + ", [x9]", load.bytes})
+	}
+	for _, op := range []string{"ldp", "ldnp"} {
+		for _, reg := range []struct {
+			name  string
+			bytes int64
+		}{{"w", 4}, {"x", 8}, {"s", 4}, {"d", 8}, {"q", 16}} {
+			cases = append(cases, footprint{fmt.Sprintf("%s %s0, %s1, [x9]", op, reg.name, reg.name), reg.bytes * 2})
+		}
+	}
+	cases = append(cases, footprint{"ldpsw x0, x1, [x9]", 8})
+	for count := 1; count <= 4; count++ {
+		for _, width := range []struct {
+			name  string
+			bytes int64
+		}{{"b", 1}, {"h", 2}, {"s", 4}, {"d", 8}} {
+			var lanes, vectors, replicas []string
+			for reg := 0; reg < count; reg++ {
+				lanes = append(lanes, fmt.Sprintf("v%d.%s", reg, width.name))
+				vectors = append(vectors, fmt.Sprintf("v%d.%d%s", reg, 16/width.bytes, width.name))
+				replicas = append(replicas, fmt.Sprintf("v%d.%d%s", reg, 8/width.bytes, width.name))
+			}
+			cases = append(cases,
+				footprint{fmt.Sprintf("ld%d {%s}[0], [x9]", count, strings.Join(lanes, ", ")), int64(count) * width.bytes},
+				footprint{fmt.Sprintf("ld%d {%s}, [x9]", count, strings.Join(vectors, ", ")), int64(count) * 16},
+				footprint{fmt.Sprintf("ld%dr {%s}, [x9]", count, strings.Join(replicas, ", ")), int64(count) * width.bytes},
+			)
+		}
+	}
+	var lines []string
+	for _, test := range cases {
+		lines = append(lines, test.line)
+	}
+	words := assembleARM64LLVMWords(t, lines, "")
+	for i, test := range cases {
+		var code [4]byte
+		binary.LittleEndian.PutUint32(code[:], words[i])
+		ins, err := arm64asm.Decode(code[:])
+		if err != nil {
+			t.Fatalf("decode %s: %v", test.line, err)
+		}
+		if got := arm64RawPoolLoadBytes(ins, words[i]); got != test.bytes {
+			t.Errorf("%s reads %d bytes, want %d", test.line, got, test.bytes)
+		}
+	}
+}
+
+func arm64RawPoolOffsetIR(t *testing.T, triple string) string {
+	t.Helper()
+	lines := []string{
+		"adr x19, #68", "add x19, x19, #8", "ldr w2, [x19]", "str x2, [x0]",
+		"sub x19, x19, #16", "mov x3, #1", "whilelo p0.d, xzr, x3",
+		"ld1rd {z0.d}, p0/z, [x19]", "fneg z0.d, p0/m, z0.d",
+		"add x1, x0, #8", "st1d {z0.d}, p0, [x1]",
+		"mov x19, xzr", "ret",
+	}
+	// ADR reaches byte 16 of this 32-byte pool; ADD and SUB then select
+	// offsets 24 and 8. The constant that resembles B must remain data.
+	var source strings.Builder
+	source.WriteString("TEXT pool_offset(SB),$0-8\nMOVD out+0(FP),R0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for _, word := range []uint32{0, 0, 0x11223344, 0x55667788, 0, 0, 0x17b4a14d, 0} {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_offset": {
+			Name: "pool_offset", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolOffsetLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "pool_offset.ll", "pool_offset.o", arm64RawPoolOffsetIR(t, triple))
+		})
+	}
+}
+
+const arm64RawPoolOffsetMain = `
+#include <stdint.h>
+extern void pool_offset(uint64_t *);
+int main(void) {
+  uint64_t result[4] = {1, 0, 0, 2};
+  pool_offset(result + 1);
+  return result[0] != 1 || result[1] != 0x17b4a14d ||
+         result[2] != 0xd566778811223344ULL || result[3] != 2;
+}
+`
diff --git a/arm64_raw_pool_ordered_loop.go b/arm64_raw_pool_ordered_loop.go
new file mode 100644
index 000000000..47fa6c4a1
--- /dev/null
+++ b/arm64_raw_pool_ordered_loop.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// Normalize the eight signed/unsigned ordered conditions to smaller <= larger,
+// with an inclusive flag distinguishing <= from <. The induction below proves
+// both operands nonnegative and below the sign bit; only in that common domain
+// are the signed and unsigned comparisons interchangeable.
+func (flow *arm64RawPoolValues) orderedLoopCompare(latch int) (smaller, larger int, inclusive, ok bool) {
+	word := flow.words[latch]
+	if word&0xff000010 != 0x54000000 {
+		return
+	}
+	compare, clobbered, valid := flow.affineFlagsBefore(latch)
+	if !valid || compare&0xffe0fc1f != 0xeb00001f {
+		return // CMP Xn, Xm, without a shift or an extension.
+	}
+	smaller, larger = int(compare>>5&31), int(compare>>16&31)
+	if smaller == 31 || larger == 31 || smaller == larger ||
+		clobbered&((1<<uint(smaller))|(1<<uint(larger))) != 0 {
+		return
+	}
+	switch word & 15 {
+	case 3, 11: // LO, LT
+	case 9, 13: // LS, LE
+		inclusive = true
+	case 8, 12: // HI, GT
+		smaller, larger = larger, smaller
+	case 2, 10: // HS, GE
+		smaller, larger, inclusive = larger, smaller, true
+	default:
+		return
+	}
+	ok = true
+	return
+}
+
+func (flow *arm64RawPoolValues) proveOrderedCounterLoop(latch int) {
+	smaller, larger, inclusive, ok := flow.orderedLoopCompare(latch)
+	if !ok {
+		return
+	}
+	head := latch + int(int32(flow.words[latch]<<8)>>13)
+	for _, counter := range []int{smaller, larger} {
+		_, delta, valid := flow.counterLoopUpdate(head, latch, counter)
+		if !valid || counter == smaller && delta != 1 || counter == larger && delta != math.MaxUint64 {
+			continue
+		}
+		limit := smaller
+		if counter == smaller {
+			limit = larger
+		}
+		unchanged := true
+		for at := head; at < latch; at++ {
+			writes, known := flow.gpWrites(flow.words[at])
+			unchanged = unchanged && known && writes&(1<<uint(limit)) == 0
+		}
+		if !unchanged {
+			continue
+		}
+		entry := flow.counterLoopEntry(head, latch)
+		if entry == nil {
+			continue
+		}
+		first := entry.integerInterval(head, arm64asm.X0+arm64asm.Reg(counter))
+		last := entry.integerInterval(head, arm64asm.X0+arm64asm.Reg(limit))
+		if first.high > math.MaxInt64 || last.high > math.MaxInt64 {
+			continue
+		}
+		// Inclusive loops execute once at equality, then step past the limit.
+		// Prove that final update cannot wrap or cross the signed boundary.
+		if inclusive && (counter == smaller && last.high == math.MaxInt64 ||
+			counter == larger && last.low == 0) {
+			continue
+		}
+		remaining := arm64PoolRegisterExpression(larger)
+		remaining.add(arm64PoolRegisterExpression(smaller), -1)
+		initial := entry.affineInterval(head, remaining)
+		minimum := uint64(1)
+		if inclusive {
+			minimum = 0
+		}
+		if initial.low < minimum || initial.high > math.MaxInt64 {
+			continue
+		}
+		if flow.loopBounds == nil {
+			flow.loopBounds = make(map[int]arm64PoolConstraint)
+		}
+		flow.loopBounds[head] = arm64PoolConstraint{
+			expression: remaining, interval: arm64PoolInterval{minimum, initial.high},
+		}
+		flow.recordLoopLatch(head, latch)
+		flow.clearValueCaches()
+		return
+	}
+}
diff --git a/arm64_raw_pool_ordered_loop_test.go b/arm64_raw_pool_ordered_loop_test.go
new file mode 100644
index 000000000..fdcf43537
--- /dev/null
+++ b/arm64_raw_pool_ordered_loop_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolOrderedCounterLoops(t *testing.T) {
+	for _, condition := range []struct {
+		up, down  string
+		inclusive bool
+	}{
+		{"lt", "gt", false}, {"lo", "hi", false},
+		{"le", "ge", true}, {"ls", "hs", true},
+	} {
+		for _, ascending := range []bool{true, false} {
+			name := fmt.Sprintf("%s/up=%v", condition.up, ascending)
+			t.Run(name, func(t *testing.T) {
+				initial, update, branch := "mov x1, #8", "add x1, x1, #1", condition.up
+				expression := arm64PoolRegisterExpression(2)
+				expression.add(arm64PoolRegisterExpression(1), -1)
+				if !ascending {
+					initial, update, branch = "mov x1, #24", "sub x1, x1, #1", condition.down
+					expression = arm64PoolRegisterExpression(1)
+					expression.add(arm64PoolRegisterExpression(2), -1)
+				}
+				lines := []string{initial, "mov x2, #16", "nop", update,
+					"cmp x1, x2", "orr w3, w3, w4", "b." + branch + " #-16", "ret"}
+				flow := arm64PoolTestFlow(t, lines)
+				low := uint64(1)
+				if condition.inclusive {
+					low = 0
+				}
+				want := arm64PoolInterval{low, 8}
+				if got := flow.affineInterval(2, expression); got != want {
+					t.Fatalf("remaining = %+v, want %+v", got, want)
+				}
+				// Swap CMP operands and use the inverse ordered condition.
+				lines[4] = "cmp x2, x1"
+				branch = condition.down
+				if !ascending {
+					branch = condition.up
+				}
+				lines[6] = "b." + branch + " #-16"
+				flow = arm64PoolTestFlow(t, lines)
+				if got := flow.affineInterval(2, expression); got != want {
+					t.Fatalf("reversed comparison remaining = %+v, want %+v", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolOrderedLoopRejectsUnprovedInduction(t *testing.T) {
+	base := []string{"mov x1, #8", "mov x2, #16", "nop",
+		"add x1, x1, #1", "cmp x1, x2", "nop", "b.lt #-16", "ret"}
+	for _, test := range []struct {
+		name string
+		at   int
+		line string
+	}{
+		{"negative-counter", 0, "mov x1, #-8"},
+		{"zero-remaining", 0, "mov x1, #16"},
+		{"unknown-limit", 1, "mov x2, x5"},
+		{"changing-limit", 2, "add x2, x2, #1"},
+		{"wrong-step", 3, "add x1, x1, #2"},
+		{"wrong-direction", 3, "sub x1, x1, #1"},
+		{"truncating-update", 3, "add w1, w1, #1"},
+		{"word-compare", 4, "cmp w1, w2"},
+		{"flag-clobber", 5, "tst x3, x4"},
+		{"operand-clobber", 5, "mov x1, x3"},
+		{"side-entry", 1, "cbz x5, #8"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := append([]string(nil), base...)
+			lines[test.at] = test.line
+			flow := arm64PoolTestFlow(t, lines)
+			if bound, ok := flow.loopBounds[2]; ok {
+				t.Fatalf("unproved induction accepted: %+v", bound)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_origins_test.go b/arm64_raw_pool_origins_test.go
new file mode 100644
index 000000000..45addd2ef
--- /dev/null
+++ b/arm64_raw_pool_origins_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64RawPoolRepeatedOrigins(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		lines   []string
+		origins map[int]int
+		want    bool
+	}{
+		{"reacquire-at-join", []string{
+			"adr x9, #0", "cbz x0, #8", "adr x9, #0",
+			"sub x12, x9, x2", "add x12, x12, x2", "ldr x1, [x12]",
+			"mov x12, xzr", "mov x9, xzr", "ret",
+		}, map[int]int{0: 0, 2: 8}, true},
+		{"independent-registers", []string{
+			"adr x9, #0", "adr x10, #0", "ldr x1, [x9]", "ldr x2, [x10]",
+			"mov x9, xzr", "mov x10, xzr", "ret",
+		}, map[int]int{0: 0, 1: 8}, true},
+		{"copied-or-reacquired", []string{
+			"adr x9, #0", "cbz x0, #12", "adr x10, #0", "b #8", "mov x10, x9",
+			"sub x12, x10, x2", "add x12, x12, x2", "ldr x1, [x12]",
+			"mov x12, xzr", "mov x9, xzr", "mov x10, xzr", "ret",
+		}, map[int]int{0: 0, 2: 8}, true},
+		{"sum-of-origins", []string{
+			"adr x9, #0", "adr x10, #0", "add x12, x9, x10", "ldr x1, [x12]",
+			"mov x9, xzr", "mov x10, xzr", "mov x12, xzr", "ret",
+		}, map[int]int{0: 0, 1: 8}, false},
+		{"shifted-sum-of-origins", []string{
+			"adr x9, #0", "adr x10, #0", "add x12, x9, x10, lsl #1", "ldr x1, [x12]",
+			"mov x9, xzr", "mov x10, xzr", "mov x12, xzr", "ret",
+		}, map[int]int{0: 0, 1: 4}, false},
+		{"reacquired-overrun", []string{
+			"adr x9, #0", "cbz x0, #8", "adr x9, #0", "ldr x1, [x9]", "mov x9, xzr", "ret",
+		}, map[int]int{0: 0, 2: 12}, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			for at, offset := range test.origins {
+				register := 9
+				if test.lines[at] == "adr x10, #0" {
+					register = 10
+				}
+				test.lines[at] = fmt.Sprintf("adr x%d, #%d", register, (len(test.lines)-at)*4+offset)
+			}
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, test.lines, "") {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			for i := 0; i < 4; i++ {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+			}
+			points := make([]arm64RawLayoutPoint, len(instructions))
+			for i := range points {
+				points[i].offset = int64(i * 4)
+			}
+			data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+			if got := len(data) == 4; got != test.want {
+				t.Fatalf("repeated-origin proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_relational_loop.go b/arm64_raw_pool_relational_loop.go
new file mode 100644
index 000000000..843d51d15
--- /dev/null
+++ b/arm64_raw_pool_relational_loop.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+// Prove the first comparison is equal on every external entry. This excludes
+// only the nonzero backedge; it does not infer a general multi-iteration range.
+// Rewind the compared expression, not independent ranges for its operands.
+func (flow *arm64RawPoolValues) proveRelationalOneIterationLoop(latch int) {
+	word := flow.words[latch]
+	if word&0xff00001f != 0x54000001 {
+		return
+	}
+	head := latch + int(int32(word<<8)>>13)
+	if flow.excluded[arm64RawPoolEdge{latch, head}] || !flow.straightLineLoopBody(head, latch) {
+		return
+	}
+	compare, _, after, known := flow.affineFlagSourceBefore(latch)
+	if !known || after <= head || after > latch {
+		return
+	}
+	_, expression, affine := flow.affineDefinition(compare &^ ((1 << 29) | 31))
+	if !affine {
+		return
+	}
+	for at := after - 2; at >= head; at-- {
+		writes, _ := flow.gpWrites(flow.words[at])
+		if affected := writes & expression.registerMask(); affected != 0 {
+			destination, value, valid := flow.affineDefinition(flow.words[at])
+			if !valid || affected != 1<<uint(destination) || !expression.substitute(destination, value) {
+				return
+			}
+		}
+	}
+	entry := flow.counterLoopEntry(head, latch)
+	if entry == nil {
+		return
+	}
+	entry = entry.numericValues()
+	// Rewinding can introduce an invariant step (for example RDVL). Prove
+	// its entry value independently; a prior enclosing iteration remains
+	// opaque whenever it could have changed the queried register.
+	for register, coefficient := range expression.coefficient {
+		if coefficient == 0 {
+			continue
+		}
+		bound := entry.invariantInterval(head, arm64PoolRegisterExpression(register))
+		if bound.low == bound.high {
+			if !expression.substitute(register, arm64PoolAffine{constant: bound.low}) {
+				return
+			}
+		}
+	}
+	if entry.affineInterval(head, expression) == (arm64PoolInterval{0, 0}) {
+		flow.excludeEdge(arm64RawPoolEdge{latch, head})
+	}
+}
diff --git a/arm64_raw_pool_relational_loop_test.go b/arm64_raw_pool_relational_loop_test.go
new file mode 100644
index 000000000..f6f369b27
--- /dev/null
+++ b/arm64_raw_pool_relational_loop_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolOneIterationRelations(t *testing.T) {
+	for _, test := range []struct {
+		name, step, compare string
+		base                int
+		body                []string
+		want                bool
+	}{
+		{"compare", "16", "cmp x1,x3", 16, nil, true},
+		{"reversed", "16", "cmp x3,x1", 16, nil, true},
+		{"retained-result", "16", "subs x5,x1,x3", 16, nil, true},
+		{"preserved-flags", "16", "cmp x1,x3", 16, []string{"mov x1,#99"}, true},
+		{"wrong-step", "15", "cmp x1,x3", 16, nil, false},
+		{"multiple-iterations", "16", "cmp x1,x3", 32, nil, false},
+		{"underflow", "16", "cmp x1,x3", 0, nil, false},
+		{"other-limit", "16", "cmp x1,x0", 16, nil, false},
+		{"word-flags", "16", "cmp w1,w3", 16, nil, false},
+		{"clobbered-flags", "16", "cmp x1,x3", 16, []string{"tst x0,x0"}, false},
+		{"changed-limit-and-flags", "16", "cmp x1,x3", 16, []string{"adds x3,x3,#1"}, false},
+		{"unknown-effects", "16", "cmp x1,x3", 16, []string{"udf #0"}, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := []string{"and x1,x0,#3", fmt.Sprintf("add x1,x1,#%d", test.base),
+				"mov x2,#15", "and x3,x1,x2", "mov x4,#" + test.step}
+			head := len(lines)
+			lines = append(lines, "sub x1,x1,x4", test.compare)
+			lines = append(lines, test.body...)
+			latch := len(lines)
+			lines = append(lines, fmt.Sprintf("b.ne #%d", (head-latch)*4), "ret")
+			flow := arm64PoolTestFlow(t, lines)
+			if got := flow.excluded[arm64RawPoolEdge{latch, head}]; got != test.want {
+				t.Fatalf("excluded one-iteration backedge=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64PoolRelationalLoopEntries(t *testing.T) {
+	for _, sideEntry := range []bool{false, true} {
+		lines := []string{"and x1,x0,#3", "add x1,x1,#16", "mov x2,#15", "and x3,x1,x2", "mov x4,#16"}
+		if sideEntry {
+			lines = append(lines, "cbz x0,#8")
+		}
+		head := len(lines)
+		lines = append(lines, "sub x1,x1,x4", "cmp x1,x3", "b.ne #-8")
+		latch := len(lines) - 1
+		if !sideEntry {
+			lines = append(lines, "add x1,x1,#32", fmt.Sprintf("b #%d", (head-len(lines)-1)*4))
+		} else {
+			lines = append(lines, "ret")
+		}
+		flow := arm64PoolTestFlow(t, lines)
+		if flow.excluded[arm64RawPoolEdge{latch, head}] {
+			t.Fatalf("side-entry=%v: ignored an unproved incoming iteration", sideEntry)
+		}
+	}
+}
diff --git a/arm64_raw_pool_relevance_test.go b/arm64_raw_pool_relevance_test.go
new file mode 100644
index 000000000..d5ad4a4fb
--- /dev/null
+++ b/arm64_raw_pool_relevance_test.go
@@ -0,0 +1,13 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolIgnoresUnrelatedMaskDefinition(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{"mov x1, #8", "and x2, x0, #24", "ret"})
+	if got := flow.affineInterval(2, arm64PoolRegisterExpression(1)); got != (arm64PoolInterval{8, 8}) {
+		t.Fatalf("unrelated mask lost a constant: %+v", got)
+	}
+	if _, queried := flow.affineCache[arm64PoolAffineQuery{1, arm64PoolRegisterExpression(0)}]; queried {
+		t.Fatal("an unrelated mask definition started another affine proof")
+	}
+}
diff --git a/arm64_raw_pool_residual_budget_test.go b/arm64_raw_pool_residual_budget_test.go
new file mode 100644
index 000000000..e4107896f
--- /dev/null
+++ b/arm64_raw_pool_residual_budget_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"math"
+	"testing"
+)
+
+func TestARM64PoolAffineResidualBudget(t *testing.T) {
+	word := assembleARM64LLVMWords(t, []string{"mov x15, #8"}, "")[0]
+	newFlow := func() *arm64RawPoolValues {
+		return &arm64RawPoolValues{words: []uint32{word, 0}, before: [][]int{{-1}, {0}}}
+	}
+	query := arm64PoolRegisterExpression(14)
+	difference := query
+	if !difference.add(arm64PoolRegisterExpression(15), -1) {
+		t.Fatal("cannot construct difference")
+	}
+	wide := arm64PoolConstraint{expression: difference, interval: arm64PoolInterval{1, math.MaxUint64}}
+	flow := newFlow()
+	bound, ok := flow.affineConstraintBound(1, query, wide)
+	if ok || len(flow.affineCache) != 0 || flow.affineWork != 0 {
+		t.Fatalf("uninformative NE decomposition spent proof budget: bound=%+v ok=%v queries=%d work=%d",
+			bound, ok, len(flow.affineCache), flow.affineWork)
+	}
+	// The direct nonzero fact is still useful. Only speculative decomposition
+	// into other registers is deferred until another guard bounds its width.
+	if bound, ok := flow.affineConstraintBound(1, difference, wide); !ok || bound != wide.interval {
+		t.Fatalf("lost direct nonzero guard: %+v %v", bound, ok)
+	}
+	tight := wide
+	tight.interval.high = 19
+	flow = newFlow()
+	if bound, ok := flow.affineConstraintBound(1, query, tight); !ok || bound != (arm64PoolInterval{9, 27}) {
+		t.Fatalf("bounded residual: %+v %v", bound, ok)
+	}
+	// A partially eliminated guard is not an independent subproblem. Unless
+	// its residual is already invariant, wait for reaching definitions to
+	// normalize it instead of recursively chasing the same unknown operands.
+	flow = newFlow()
+	flow.words[0] = assembleARM64LLVMWords(t, []string{"mov x15, x0"}, "")[0]
+	bound, ok = flow.affineConstraintBound(1, query, tight)
+	if ok || len(flow.affineCache) != 0 {
+		t.Fatalf("partially eliminated guard recursed: bound=%+v ok=%v queries=%d", bound, ok, len(flow.affineCache))
+	}
+}
diff --git a/arm64_raw_pool_sequential_loop_test.go b/arm64_raw_pool_sequential_loop_test.go
new file mode 100644
index 000000000..6787b647c
--- /dev/null
+++ b/arm64_raw_pool_sequential_loop_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolCounterAfterProvedEarlierLoop(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"and x17,x0,#15", "add x17,x17,#8", "and x6,x17,#24", "neg x7,x6",
+		"nop", "add x7,x7,#8", "cbnz x7,#-8", "cmp x17,x6", "b.eq #20",
+		"sub x16,x17,x6", "nop", "subs x16,x16,#1", "b.ne #-8", "ret",
+	})
+	if got := flow.affineInterval(10, arm64PoolRegisterExpression(16)); got != (arm64PoolInterval{1, 7}) {
+		t.Fatalf("tail counter after unchanged earlier-loop values=%+v, want [1,7]", got)
+	}
+}
+
+func TestARM64PoolSequentialLoopRejectsChangedRelations(t *testing.T) {
+	for _, change := range []string{"add x14,x14,#1", "add x17,x17,#1", "ldr x14,[x2]", "ldr x17,[x2]"} {
+		t.Run(change, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				"and x14,x0,#15", "add x14,x14,#8", "mov x16,#0", "sub x17,x14,x16",
+				"and x6,x17,#24", "neg x7,x6", change, "add x7,x7,#8", "cbnz x7,#-8",
+				"cmp x17,x6", "b.eq #28", "sub x17,x14,x6", "add x6,x6,x16",
+				"sub x16,x17,x16", "nop", "subs x16,x16,#1", "b.ne #-8", "ret",
+			})
+			if got := flow.affineInterval(14, arm64PoolRegisterExpression(16)); got.low >= 1 && got.high <= 7 {
+				t.Fatalf("changed length/guard incorrectly retained the old remainder: %+v", got)
+			}
+		})
+	}
+}
+
+func TestARM64PoolInvariantLoopForgetsChangingConstraints(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"and x7,x0,#8", "add x7,x7,#8", "nop", "sub x7,x7,#8", "cbnz x7,#-8", "ret",
+	})
+	stable := arm64PoolConstraint{expression: arm64PoolRegisterExpression(17), interval: arm64PoolInterval{1, 7}}
+	changing := arm64PoolConstraint{expression: arm64PoolRegisterExpression(7), interval: arm64PoolInterval{8, 8}}
+	historical := stable
+	historical.after = 1
+	state := arm64PoolAffineState{
+		at: 2, expression: arm64PoolRegisterExpression(17),
+		constraints: [8]arm64PoolConstraint{changing, historical, stable}, count: 3,
+	}
+	if latch, ok := flow.rewindInvariantLoop(&state); !ok || latch != 4 {
+		t.Fatalf("unchanged query not rewound: latch=%d ok=%v", latch, ok)
+	}
+	if state.count != 1 || state.constraints != ([8]arm64PoolConstraint{stable}) {
+		t.Fatalf("retained a changing or inactive constraint: %+v", state)
+	}
+	state.expression = arm64PoolRegisterExpression(7)
+	if _, ok := flow.rewindInvariantLoop(&state); ok {
+		t.Fatal("rewound a changing counter as invariant")
+	}
+	flow.loopLatches = nil
+	state.expression = arm64PoolRegisterExpression(17)
+	if _, ok := flow.rewindInvariantLoop(&state); ok {
+		t.Fatal("rewound an uncertified loop")
+	}
+}
+
+func TestARM64PoolCounterAfterEarlierLoopPreservesRelationalGuard(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"and x14,x0,#15", "add x14,x14,#8", "mov x16,#0", "sub x17,x14,x16",
+		"and x6,x17,#24", "neg x7,x6", "nop", "add x7,x7,#8", "cbnz x7,#-8",
+		"cmp x17,x6", "b.eq #28", "sub x17,x14,x6", "add x6,x6,x16",
+		"sub x16,x17,x16", "nop", "subs x16,x16,#1", "b.ne #-8", "ret",
+	})
+	if got := flow.affineInterval(14, arm64PoolRegisterExpression(16)); got != (arm64PoolInterval{1, 7}) {
+		t.Fatalf("tail counter with an earlier equivalent guard=%+v, want [1,7]", got)
+	}
+}
diff --git a/arm64_raw_pool_shift_guard.go b/arm64_raw_pool_shift_guard.go
new file mode 100644
index 000000000..48db4c11b
--- /dev/null
+++ b/arm64_raw_pool_shift_guard.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func arm64PoolShiftConstraint(word uint32, constraint arm64PoolConstraint) (arm64PoolConstraint, bool) {
+	if constraint.after != 0 || constraint.mask != 0 || word>>31 == 0 || word&31 == 31 ||
+		constraint.expression != arm64PoolRegisterExpression(int(word&31)) {
+		return constraint, false
+	}
+	ins, decoded := arm64PoolDecodeWord(word)
+	shift, immediate := ins.Args[2].(arm64asm.Imm)
+	if !decoded || ins.Op != arm64asm.LSR || !immediate {
+		return constraint, false
+	}
+	maximum := uint64(math.MaxUint64) >> shift.Imm
+	if constraint.interval.high > maximum {
+		constraint.interval.high = maximum
+	}
+	constraint.expression = arm64PoolRegisterExpression(int(word >> 5 & 31))
+	if constraint.interval.low > constraint.interval.high {
+		constraint.interval = arm64PoolInterval{1, 0}
+		return constraint, true
+	}
+	constraint.interval.low <<= shift.Imm
+	constraint.interval.high = constraint.interval.high<<shift.Imm | (uint64(1)<<shift.Imm - 1)
+	return constraint, true
+}
diff --git a/arm64_raw_pool_stack.go b/arm64_raw_pool_stack.go
new file mode 100644
index 000000000..ba2a3dec1
--- /dev/null
+++ b/arm64_raw_pool_stack.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+type arm64PoolStackAccess struct {
+	offset, bytes int64
+	registers     [2]int
+	count         int
+	read, gp64    bool
+}
+
+// Decode ordinary scalar/pair SP-relative accesses. Narrow/vector stores still
+// have a footprint, but cannot provide a saved 64-bit GP value. Writeback,
+// indexed, atomic and exclusive accesses are deliberately not folded.
+func arm64PoolDecodeStackAccess(ins arm64asm.Inst, word uint32) (arm64PoolStackAccess, bool) {
+	access := arm64PoolStackAccess{count: 1, gp64: true}
+	size := ins
+	switch ins.Op {
+	case arm64asm.LDR, arm64asm.LDUR:
+		access.read = true
+	case arm64asm.LDP, arm64asm.LDNP:
+		access.read, access.count = true, 2
+	case arm64asm.STR:
+		size.Op = arm64asm.LDR
+	case arm64asm.STUR:
+		size.Op = arm64asm.LDUR
+	case arm64asm.STP, arm64asm.STNP:
+		size.Op, access.count = arm64asm.LDP, 2
+	case arm64asm.STRB, arm64asm.STURB:
+		size.Op, access.gp64 = arm64asm.LDRB, false
+	case arm64asm.STRH, arm64asm.STURH:
+		size.Op, access.gp64 = arm64asm.LDRH, false
+	default:
+		return access, false
+	}
+	memory, ok := ins.Args[access.count].(arm64asm.MemImmediate)
+	if !ok || arm64asm.Reg(memory.Base) != arm64asm.SP || memory.Mode != arm64asm.AddrOffset {
+		return access, false
+	}
+	access.offset, _, ok = arm64PoolImmediateAddress(memory)
+	access.bytes = arm64RawPoolLoadBytes(size, word)
+	if !ok || access.offset < 0 || access.bytes <= 0 {
+		return access, false
+	}
+	for n := 0; n < access.count; n++ {
+		reg, ok := ins.Args[n].(arm64asm.Reg)
+		if !ok || reg < arm64asm.X0 || reg > arm64asm.XZR {
+			access.gp64 = false
+			continue
+		}
+		access.registers[n] = int(reg - arm64asm.X0)
+	}
+	if access.bytes != int64(access.count*8) {
+		access.gp64 = false
+	}
+	if access.read && access.count == 2 && access.gp64 &&
+		access.registers[0] == access.registers[1] && access.registers[0] != 31 {
+		return access, false // Constrained-unpredictable pair destination overlap.
+	}
+	return access, true
+}
+
+func arm64PoolDecodeWord(word uint32) (arm64asm.Inst, bool) {
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	return ins, err == nil
+}
+
+// Rewind the whole query to a dominating save, not just the source register's
+// current value. Every other queried GP value must be unchanged along the one
+// predecessor chain. Any possible aliasing store, overlap, call, unknown effect
+// or SP change rejects the proof. Nonoverlapping direct SP stores are harmless.
+func (flow *arm64RawPoolValues) rewindStackLoad(at int, query arm64PoolAffine) (int, arm64PoolAffine, bool) {
+	word := flow.words[at]
+	if word&0x0a000000 != 0x08000000 || word>>5&31 != 31 {
+		return 0, query, false
+	}
+	ins, ok := arm64PoolDecodeWord(flow.words[at])
+	if !ok {
+		return 0, query, false
+	}
+	load, ok := arm64PoolDecodeStackAccess(ins, flow.words[at])
+	if !ok || !load.read || !load.gp64 {
+		return 0, query, false
+	}
+	remainder := query
+	var scales [2]int64
+	for n := 0; n < load.count; n++ {
+		if reg := load.registers[n]; reg < 31 {
+			scales[n] = remainder.coefficient[reg]
+			remainder.coefficient[reg] = 0
+		}
+	}
+	if scales == [2]int64{} {
+		return 0, query, false
+	}
+	visited := make(map[int]bool)
+	for steps := 0; steps < 512; steps++ {
+		if flow.affineWork >= 16384 {
+			return 0, query, false
+		}
+		flow.affineWork++
+		if len(flow.before[at]) != 1 {
+			return 0, query, false
+		}
+		at = flow.before[at][0]
+		if at < 0 || flow.opaque[at] || visited[at] {
+			return 0, query, false
+		}
+		visited[at] = true
+		word := flow.words[at]
+		ins, decoded := arm64PoolDecodeWord(word)
+		writes, known := flow.gpWrites(word)
+		if !decoded || !known || writes&remainder.registerMask() != 0 {
+			return 0, query, false
+		}
+		// SP used as a GP operand could change or expose the frame base.
+		// Memory operands carry their base inside a distinct typed argument.
+		for _, arg := range ins.Args {
+			switch arg := arg.(type) {
+			case arm64asm.RegSP:
+				if arm64asm.Reg(arg) == arm64asm.SP || arm64asm.Reg(arg) == arm64asm.WSP {
+					return 0, query, false
+				}
+			case arm64asm.MemImmediate:
+				if arm64asm.Reg(arg.Base) == arm64asm.SP && arg.Mode != arm64asm.AddrOffset {
+					return 0, query, false
+				}
+			}
+		}
+		if store, ok := arm64PoolDecodeStackAccess(ins, word); ok && !store.read {
+			overlap, matches := false, true
+			saved := remainder
+			for n := 0; n < load.count; n++ {
+				if scales[n] == 0 {
+					continue
+				}
+				offset := load.offset + int64(n*8)
+				overlap = overlap || offset < store.offset+store.bytes && store.offset < offset+8
+				part := (offset - store.offset) / 8
+				if !store.gp64 || offset < store.offset || (offset-store.offset)%8 != 0 ||
+					part >= int64(store.count) || !saved.add(arm64PoolRegisterExpression(store.registers[part]), scales[n]) {
+					matches = false
+				}
+			}
+			if overlap {
+				return at, saved, matches
+			}
+			continue
+		}
+		// Typed non-SP stores may alias the slot. Never assume that an
+		// arbitrary GP address names a different allocation from the stack.
+		if !arm64RawPoolReadOnlyLoad(ins.Op) {
+			for _, arg := range ins.Args {
+				switch arg.(type) {
+				case arm64asm.MemImmediate, arm64asm.MemExtend:
+					return 0, query, false
+				}
+			}
+		}
+	}
+	return 0, query, false
+}
diff --git a/arm64_raw_pool_stack_test.go b/arm64_raw_pool_stack_test.go
new file mode 100644
index 000000000..be198fa57
--- /dev/null
+++ b/arm64_raw_pool_stack_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64PoolSavedStackValues(t *testing.T) {
+	for _, test := range []struct {
+		name, save, load string
+		want             uint64
+	}{
+		{"scaled", "str x2, [sp, #8]", "ldr x3, [sp, #8]", 64},
+		{"unscaled", "stur x2, [sp, #9]", "ldur x3, [sp, #9]", 64},
+		{"pair-first", "stp x2, x1, [sp, #8]", "ldp x3, x4, [sp, #8]", 64},
+		{"pair-second", "stp x1, x2, [sp, #8]", "ldp x4, x3, [sp, #8]", 64},
+		{"scalar-from-pair", "stp x1, x2, [sp]", "ldr x3, [sp, #8]", 64},
+		{"nontemporal", "stnp x2, x1, [sp, #8]", "ldnp x3, x4, [sp, #8]", 64},
+		{"zero-source", "str xzr, [sp, #8]", "ldr x3, [sp, #8]", 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				"sub sp, sp, #32", "mov x2, #64", test.save, "mov x2, #99",
+				"strb w0, [sp, #31]", test.load, "nop", "add sp, sp, #32", "ret",
+			})
+			want := arm64PoolInterval{test.want, test.want}
+			if got := flow.affineInterval(6, arm64PoolRegisterExpression(3)); got != want {
+				t.Fatalf("saved value = %+v, want %+v", got, want)
+			}
+		})
+	}
+}
+
+func TestARM64PoolSavedStackRelationship(t *testing.T) {
+	flow := arm64PoolTestFlow(t, []string{
+		"sub sp, sp, #32", "add x2, x1, #8", "str x2, [sp, #8]", "mov x2, #99",
+		"ldr x3, [sp, #8]", "nop", "add sp, sp, #32", "ret",
+	})
+	expression := arm64PoolRegisterExpression(3)
+	expression.add(arm64PoolRegisterExpression(1), -1)
+	if got := flow.affineInterval(5, expression); got != (arm64PoolInterval{8, 8}) {
+		t.Fatalf("saved relationship = %+v", got)
+	}
+}
+
+func TestARM64PoolStackReadsRejectAmbiguousMemory(t *testing.T) {
+	for _, test := range []struct {
+		name, save, middle, load string
+	}{
+		{"overlapping-byte", "str x2, [sp, #8]", "strb w0, [sp, #9]", "ldr x3, [sp, #8]"},
+		{"overlapping-pair", "str x2, [sp, #8]", "stp d0, d1, [sp]", "ldr x3, [sp, #8]"},
+		{"possible-alias", "str x2, [sp, #8]", "str x0, [x5]", "ldr x3, [sp, #8]"},
+		{"stack-moved", "str x2, [sp, #8]", "add sp, sp, #16", "ldr x3, [sp, #8]"},
+		{"stack-writeback", "str x2, [sp, #8]", "ldr x5, [sp], #16", "ldr x3, [sp, #8]"},
+		{"narrow-save", "str w2, [sp, #8]", "nop", "ldr x3, [sp, #8]"},
+		{"narrow-load", "str x2, [sp, #8]", "nop", "ldr w3, [sp, #8]"},
+		{"different-slot", "str x2, [sp, #16]", "nop", "ldr x3, [sp, #8]"},
+		{"unknown-call", "str x2, [sp, #8]", "blr x5", "ldr x3, [sp, #8]"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			flow := arm64PoolTestFlow(t, []string{
+				"sub sp, sp, #32", "mov x2, #64", test.save, test.middle,
+				test.load, "nop", "ret",
+			})
+			if got := flow.affineInterval(5, arm64PoolRegisterExpression(3)); got != arm64PoolUnknownInterval {
+				t.Fatalf("ambiguous saved value accepted: %+v", got)
+			}
+		})
+	}
+	flow := arm64PoolTestFlow(t, []string{
+		"sub sp, sp, #32", "mov x2, #64", "str x2, [sp, #8]", "add x1, x1, #1",
+		"ldr x3, [sp, #8]", "nop", "ret",
+	})
+	expression := arm64PoolRegisterExpression(3)
+	expression.add(arm64PoolRegisterExpression(1), 1)
+	if got := flow.affineInterval(5, expression); got != arm64PoolUnknownInterval {
+		t.Fatalf("changed residual was rewound to its old value: %+v", got)
+	}
+}
+
+func TestARM64PoolOpaqueLoopPreservesUnmodifiedValues(t *testing.T) {
+	for _, change := range []bool{false, true} {
+		body := "nop"
+		if change {
+			body = "add x3, x3, #1"
+		}
+		flow := arm64PoolTestFlow(t, []string{
+			"mov x3, #64", "mov x1, #2", body, "sub x1, x1, #1", "cbnz x1, #-8",
+			"cbz x0, #12", "mov x1, #2", "b #-20", "ret",
+		})
+		entry := flow.counterLoopEntry(2, 4)
+		want := arm64PoolInterval{64, 64}
+		if change {
+			want = arm64PoolUnknownInterval
+		}
+		if got := entry.invariantIntervalProof(2, arm64PoolRegisterExpression(3), true); got != want {
+			t.Fatalf("changing=%v: enclosing-loop entry=%+v, want %+v", change, got, want)
+		}
+	}
+}
diff --git a/arm64_raw_pool_stride.go b/arm64_raw_pool_stride.go
new file mode 100644
index 000000000..89df08588
--- /dev/null
+++ b/arm64_raw_pool_stride.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import "math"
+
+func (flow *arm64RawPoolValues) counterStrideBound(at int, expression arm64PoolAffine, initial arm64PoolInterval, delta uint64) (arm64PoolInterval, bool) {
+	signed := int64(delta)
+	if signed == 0 || signed < -(1<<30) || signed > 1<<30 {
+		return arm64PoolInterval{}, false
+	}
+	step := uint64(signed)
+	if signed < 0 {
+		step = -step
+	}
+	if step&(step-1) != 0 {
+		return arm64PoolInterval{}, false
+	}
+	if signed < 0 {
+		if initial.low == 0 || initial.high > math.MaxInt64 {
+			return arm64PoolInterval{}, false
+		}
+	} else {
+		if initial.low <= math.MaxInt64 {
+			return arm64PoolInterval{}, false
+		}
+	}
+	if !flow.multipleOfPowerOfTwo(at, expression, step) || initial.low > math.MaxUint64-(step-1) {
+		return arm64PoolInterval{}, false
+	}
+	// Refine the independently proved interval with the independently proved
+	// residue. For example [-19,-1] contains only -16 and -8 divisible by eight.
+	initial.low = (initial.low + step - 1) &^ (step - 1)
+	initial.high &^= step - 1
+	if initial.low > initial.high {
+		return arm64PoolInterval{}, false
+	}
+	if signed < 0 {
+		return arm64PoolInterval{step, initial.high}, true
+	}
+	return arm64PoolInterval{initial.low, -step}, true
+}
+
+// Retain only the residue through arithmetic definitions. In particular,
+// -(n & 24) is divisible by eight even though its interval includes values
+// between the two actual possibilities -16 and -8. No branch predicate is
+// needed; every predecessor must establish residue zero independently.
+func (flow *arm64RawPoolValues) multipleOfPowerOfTwo(at int, expression arm64PoolAffine, step uint64) bool {
+	mask := step - 1
+	normalize := func(value arm64PoolAffine) arm64PoolAffine {
+		value.constant &= mask
+		for register, coefficient := range value.coefficient {
+			value.coefficient[register] = int64(uint64(coefficient) & mask)
+		}
+		return value
+	}
+	queue := []arm64PoolAffineQuery{{at, normalize(expression)}}
+	visited := make(map[arm64PoolAffineQuery]bool)
+	found := false
+	for work := 0; len(queue) > 0; work++ {
+		if work >= 4096 || flow.affineWork >= 16384 {
+			return false
+		}
+		flow.affineWork++
+		state := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+		if visited[state] {
+			continue
+		}
+		visited[state] = true
+		if state.expression.relocations != 0 {
+			return false
+		}
+		if state.expression.isConstant() {
+			if state.expression.constant != 0 {
+				return false
+			}
+			found = true
+			continue
+		}
+		if state.at < 0 || state.at >= len(flow.before) || len(flow.before[state.at]) == 0 {
+			return false
+		}
+		for _, previous := range flow.before[state.at] {
+			if previous < 0 || flow.opaque[previous] && !flow.opaquePreserves(previous, state.expression) {
+				return false
+			}
+			word := flow.words[previous]
+			writes, known := flow.gpWrites(word)
+			if !known {
+				return false
+			}
+			next := arm64PoolAffineQuery{previous, state.expression}
+			if affected := writes & next.expression.registerMask(); affected != 0 {
+				if savedAt, saved, ok := flow.rewindStackLoad(previous, next.expression); ok {
+					queue = append(queue, arm64PoolAffineQuery{savedAt, normalize(saved)})
+					continue
+				}
+				destination, value, valid := flow.affineDefinition(word)
+				if !valid {
+					destination, value, valid = flow.maskedResidueDefinition(previous, word, mask)
+				}
+				if !valid || affected != 1<<uint(destination) || !next.expression.substitute(destination, value) {
+					return false
+				}
+				next.expression = normalize(next.expression)
+			}
+			queue = append(queue, next)
+		}
+	}
+	return found
+}
+
+func (flow *arm64RawPoolValues) maskedResidueDefinition(at int, word uint32, residueMask uint64) (int, arm64PoolAffine, bool) {
+	definition, ok := flow.maskedConstantDefinition(at, word)
+	if !ok {
+		return 0, arm64PoolAffine{}, false
+	}
+	switch definition.mask & residueMask {
+	case 0:
+		return definition.destination, arm64PoolAffine{}, true
+	case residueMask:
+		return definition.destination, arm64PoolRegisterExpression(definition.source), true
+	default:
+		return 0, arm64PoolAffine{}, false
+	}
+}
diff --git a/arm64_raw_pool_stride_test.go b/arm64_raw_pool_stride_test.go
new file mode 100644
index 000000000..f2d5964e4
--- /dev/null
+++ b/arm64_raw_pool_stride_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64PoolPowerOfTwoCounterStrides(t *testing.T) {
+	for shift := uint(0); shift <= 23; shift++ {
+		step := uint64(1) << shift
+		for _, ascending := range []bool{false, true} {
+			name := fmt.Sprintf("step=%d/ascending=%v", step, ascending)
+			t.Run(name, func(t *testing.T) {
+				lines := []string{fmt.Sprintf("and x1,x0,#%d", step), fmt.Sprintf("add x1,x1,#%d", step)}
+				update := fmt.Sprintf("sub x1,x1,#%d", step)
+				want := arm64PoolInterval{step, 2 * step}
+				if ascending {
+					lines = append(lines, "neg x1,x1")
+					update = fmt.Sprintf("add x1,x1,#%d", step)
+					want = arm64PoolInterval{-(2 * step), -step}
+				}
+				head := len(lines)
+				lines = append(lines, "nop", update, "cbnz x1,#-8", "ret")
+				flow := arm64PoolTestFlow(t, lines)
+				if got := flow.affineInterval(head, arm64PoolRegisterExpression(1)); got != want {
+					t.Fatalf("counter bound=%+v, want %+v", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64PoolCounterStrideFlags(t *testing.T) {
+	for _, ascending := range []bool{false, true} {
+		lines := []string{"and x1,x0,#8", "add x1,x1,#8"}
+		update := "subs x1,x1,#8"
+		want := arm64PoolInterval{8, 16}
+		if ascending {
+			lines = append(lines, "negs x1,x1")
+			update, want = "adds x1,x1,#8", arm64PoolInterval{^uint64(15), ^uint64(7)}
+		}
+		head := len(lines)
+		lines = append(lines, "nop", update, "b.ne #-8", "ret")
+		flow := arm64PoolTestFlow(t, lines)
+		if got := flow.affineInterval(head, arm64PoolRegisterExpression(1)); got != want {
+			t.Fatalf("ascending=%v: counter bound=%+v, want %+v", ascending, got, want)
+		}
+	}
+}
+
+func TestARM64PoolCounterStrideRoundsProvedResidue(t *testing.T) {
+	for _, ascending := range []bool{false, true} {
+		lines := []string{"and x1,x0,#8", "add x1,x1,#8"}
+		initial, want, delta := arm64PoolInterval{1, 19}, arm64PoolInterval{8, 16}, ^uint64(7)
+		if ascending {
+			lines = append(lines, "neg x1,x1")
+			initial = arm64PoolInterval{^uint64(18), ^uint64(0)}
+			want, delta = arm64PoolInterval{^uint64(15), ^uint64(7)}, 8
+		}
+		at := len(lines)
+		flow := arm64PoolTestFlow(t, append(lines, "ret"))
+		got, proved := flow.counterStrideBound(at, arm64PoolRegisterExpression(1), initial, delta)
+		if !proved || got != want {
+			t.Fatalf("ascending=%v: residue-refined bound=%+v proved=%v, want %+v", ascending, got, proved, want)
+		}
+	}
+}
+
+func TestARM64PoolCounterResidueMasks(t *testing.T) {
+	for _, test := range []struct {
+		lines []string
+		want  bool
+	}{
+		{[]string{"and x1,x0,#24"}, true},
+		{[]string{"ands x1,x0,#24"}, true},
+		{[]string{"mov x2,#24", "and x1,x0,x2"}, true},
+		{[]string{"mov x2,#12", "and x1,x0,x2,lsl #1"}, true},
+		{[]string{"mov x2,#48", "ands x1,x0,x2,lsr #1"}, true},
+		{[]string{"mov x2,#48", "and x1,x0,x2,asr #1"}, true},
+		{[]string{"mov x2,#12", "and x1,x0,x2,ror #63"}, true},
+		{[]string{"mov x2,#7", "bic x1,x0,x2"}, true},
+		{[]string{"mov x2,#14", "bics x1,x0,x2,lsr #1"}, true},
+		{[]string{"mov x2,#14", "bic x1,x0,x2,asr #1"}, true},
+		{[]string{"mov x2,#14", "bic x1,x0,x2,ror #1"}, true},
+		{[]string{"and x1,x0,#24", "str x1,[sp,#8]", "ldr x1,[sp,#8]"}, true},
+		{[]string{"and x1,x0,#24", "and x1,x1,#15"}, true},
+		{[]string{"and x1,x0,#7"}, false},
+		{[]string{"mov x2,#7", "bic x1,x0,x2,lsl #1"}, false},
+		{[]string{"and x1,x0,x2"}, false},
+		{[]string{"and w1,w0,#24"}, false},
+		{[]string{"adr x1,#0"}, false},
+		{[]string{"and x1,x0,#24", "add x1,x1,#1"}, false},
+		{[]string{"and x1,x0,#24", "str x1,[sp,#8]", "str x2,[sp,#8]", "ldr x1,[sp,#8]"}, false},
+	} {
+		lines := append(append([]string(nil), test.lines...), "ret")
+		flow := arm64PoolTestFlow(t, lines)
+		flow.clearValueCaches()
+		if got := flow.multipleOfPowerOfTwo(len(test.lines), arm64PoolRegisterExpression(1), 8); got != test.want {
+			t.Errorf("%v: divisible=%v, want %v", test.lines, got, test.want)
+		}
+		flow.affineWork = 16384
+		if flow.multipleOfPowerOfTwo(len(test.lines), arm64PoolRegisterExpression(1), 8) {
+			t.Fatal("exhausted residue budget became a successful proof")
+		}
+	}
+}
+
+func TestARM64PoolCounterStrideRejectsUnprovedResidues(t *testing.T) {
+	for _, prefix := range [][]string{
+		{"and x1,x0,#7", "add x1,x1,#8"},
+		{"and x1,x0,#8"},
+		{"and x1,x0,#8", "add x1,x1,#9"},
+		{"and x1,x0,#8", "add x1,x1,#8", "add x1,x1,x2"},
+		{"and x1,x0,#8", "add x1,x1,#8", "str x1,[sp,#8]", "str x2,[sp,#8]", "ldr x1,[sp,#8]"},
+	} {
+		head := len(prefix)
+		lines := append(append([]string(nil), prefix...), "nop", "sub x1,x1,#8", "cbnz x1,#-8", "ret")
+		flow := arm64PoolTestFlow(t, lines)
+		if _, proved := flow.loopBounds[head]; proved {
+			t.Fatalf("unproved residue accepted: %v", prefix)
+		}
+	}
+}
diff --git a/arm64_raw_pool_sve_alias.go b/arm64_raw_pool_sve_alias.go
new file mode 100644
index 000000000..479e9dc6a
--- /dev/null
+++ b/arm64_raw_pool_sve_alias.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+// ADDVL/ADDPL preserve one relocated address. Their signed six-bit immediate
+// scales the architectural VL (16..256 bytes) or PL (2..32 bytes), never merely
+// the host's current value. RDVL produces a number, not an address alias.
+func arm64RawPoolScalableAlias(form arm64RawSVEAddress, offset arm64RawPoolRange, bounds *arm64RawPoolBounds) (arm64RawPoolRange, bool) {
+	if form.op == "RDVL" || form.destination == 31 || bounds == nil {
+		return arm64RawPoolRange{}, false
+	}
+	if bounds.symbolic {
+		// Numeric offsets are recovered from reaching definitions at every
+		// dereference. Only a fixed architectural partition can model them.
+		return arm64RawPoolRange{}, bounds.values.vectorBytes != 0
+	}
+	unit := int64(16)
+	if form.op == "ADDPL" {
+		unit = 2
+	}
+	low := int64(form.immediate) * unit
+	high := low * 16
+	if low > high {
+		low, high = high, low
+	}
+	if offset.low < 0 || offset.high > bounds.size ||
+		low < -offset.low || high > bounds.size-offset.high {
+		return arm64RawPoolRange{}, false
+	}
+	return arm64RawPoolRange{offset.low + low, offset.high + high}, true
+}
diff --git a/arm64_raw_pool_sve_alias_test.go b/arm64_raw_pool_sve_alias_test.go
new file mode 100644
index 000000000..3690674dd
--- /dev/null
+++ b/arm64_raw_pool_sve_alias_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawPoolScalableAddressAliases(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		offset     int
+		want       bool
+	}{
+		{"addvl", "addvl x12,x9,#1\nldr x0,[x12]", 512, true},
+		{"addpl", "addpl x12,x9,#1\nldr x0,[x12]", 512, true},
+		{"negative-addvl", "addvl x12,x9,#-1\nldr x0,[x12]", 512, true},
+		{"negative-addpl", "addpl x12,x9,#-1\nldr x0,[x12]", 512, true},
+		{"in-place", "addvl x9,x9,#1\nldr x0,[x9]", 512, true},
+		{"original-killed", "addpl x12,x9,#1\nmov x9,xzr\nldr x0,[x12]", 512, true},
+		{"maximum-vl-overrun", "addvl x12,x9,#1\nldr x0,[x12]", 800, false},
+		{"maximum-pl-overrun", "addpl x12,x9,#1\nldr x0,[x12]", 1000, false},
+		{"maximum-vl-underrun", "addvl x12,x9,#-1\nldr x0,[x12]", 16, false},
+		{"escaping-alias", "addvl x12,x9,#1\nstr x12,[x0]\nldr x0,[x12]", 512, false},
+		{"stack-pointer-escape", "addvl sp,x9,#0\nldr x0,[sp]", 512, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := append([]string{"adr x9,#0"}, strings.Split(test.body, "\n")...)
+			lines = append(lines, "mov x9,xzr", "mov x12,xzr", "ret")
+			lines[0] = fmt.Sprintf("adr x9,#%d", len(lines)*4+test.offset)
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			const poolWords = 256
+			for i := 0; i < poolWords; i++ {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+			}
+			points := make([]arm64RawLayoutPoint, len(instructions))
+			for i := range points {
+				points[i].offset = int64(i * 4)
+			}
+			data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+			if got := len(data) == poolWords; got != test.want {
+				t.Fatalf("pool proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolScalableAliasImmediateFamily(t *testing.T) {
+	var assembly []string
+	for _, op := range []string{"addvl", "addpl"} {
+		for immediate := -32; immediate <= 31; immediate++ {
+			assembly = append(assembly, fmt.Sprintf("%s x12,x9,#%d", op, immediate))
+		}
+	}
+	words := assembleARM64LLVMWords(t, assembly, "+sve")
+	for index, word := range words {
+		form, ok := decodeARM64RawSVEAddress(word)
+		if !ok {
+			t.Fatalf("missing typed decoder for %s", assembly[index])
+		}
+		bounds := &arm64RawPoolBounds{size: 32768}
+		got, ok := arm64RawPoolScalableAlias(form, arm64RawPoolRange{16384, 16384}, bounds)
+		want := arm64RawPoolRange{32768, 0}
+		for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+			unit := vectorBytes
+			if index >= 64 {
+				unit /= 8
+			}
+			offset := 16384 + int64(index%64-32)*unit
+			if offset < want.low {
+				want.low = offset
+			}
+			if offset > want.high {
+				want.high = offset
+			}
+		}
+		if !ok || got != want {
+			t.Fatalf("%s: got %+v/%v, want %+v", assembly[index], got, ok, want)
+		}
+	}
+}
+
+func arm64RawPoolSVEAliasesRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var machine []string
+	var origins []int
+	var cases strings.Builder
+	for _, op := range []string{"addvl", "addpl"} {
+		for _, immediate := range []int{-32, -1, 0, 1, 31} {
+			for _, destination := range []int{9, 12} {
+				origins = append(origins, len(machine))
+				machine = append(machine, "adr x9,#0",
+					fmt.Sprintf("%s x%d,x9,#%d", op, destination, immediate),
+					fmt.Sprintf("ldr x1,[x%d]", destination),
+					fmt.Sprintf("str x1,[x0,#%d]", (len(origins)-1)*8),
+					"mov x9,xzr", "mov x12,xzr")
+				divisor := 1
+				if op == "addpl" {
+					divisor = 8
+				}
+				fmt.Fprintf(&cases, "{%d, %d},", divisor, immediate)
+			}
+		}
+	}
+	machine = append(machine, "ret")
+	for _, at := range origins {
+		machine[at] = fmt.Sprintf("adr x9,#%d", (len(machine)-at)*4+8192)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT pool_sve(SB),$0-8\nMOVD out+0(FP),R0\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := uint32(0); i < 4096; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", i*0x9e3779b9^(i>>4))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_sve": {
+			Name: "pool_sve", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	checks := fmt.Sprintf(`
+  const int cases[][2] = {%s};
+  uint64_t out[22] = {0};
+  out[0] = 0x1234;
+  out[21] = 0x5678;
+  pool_sve(out + 1);
+  if (out[0] != 0x1234 || out[21] != 0x5678) return 1;
+  for (unsigned i = 0; i < 20; i++) {
+    int offset = 8192 + cases[i][1] * (int)(vl / cases[i][0]);
+    uint64_t expected = 0;
+    for (unsigned byte = 0; byte < 8; byte++) {
+      unsigned at = (unsigned)offset + byte;
+      uint32_t word = (at / 4) * UINT32_C(0x9e3779b9) ^ (at / 4 >> 4);
+      expected |= (uint64_t)((word >> ((at %% 4) * 8)) & 255) << (byte * 8);
+    }
+    if (out[i + 1] != expected) {
+      fprintf(stderr, "pool alias case=%%u VL=%%u\n", i, vl);
+      return 2;
+    }
+  }
+`, cases.String())
+	return ir, arm64SVEVectorLengthMain("extern void pool_sve(uint64_t *);\n", checks)
+}
+
+func TestARM64RawPoolSVEAliasesLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64RawPoolSVEAliasesRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_sve.ll", "pool_sve.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_contiguous_runtime_test.go b/arm64_raw_pool_sve_contiguous_runtime_test.go
new file mode 100644
index 000000000..c5ce4cf2f
--- /dev/null
+++ b/arm64_raw_pool_sve_contiguous_runtime_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolSVEContiguousRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	machine := []string{"adr x9,#0", "mov x10,#-3"}
+	var cases strings.Builder
+	count := 0
+	for _, signed := range []bool{false, true} {
+		for memory := 0; memory < 4; memory++ {
+			for element := memory; element < 4; element++ {
+				if signed && element == memory {
+					continue
+				}
+				for _, kind := range []string{"register", "immediate"} {
+					form := arm64RawSVELoadCase{memorySize: memory, elementSize: element, kind: kind}
+					for _, active := range []int{0, 1} {
+						machine = append(machine, "ptrue p7.b")
+						if active == 0 {
+							machine = append(machine, "eor p7.b,p7/z,p7.b,p7.b")
+						}
+						machine = append(machine, form.loadAssembly(signed, 31, 7, 9, 10, -2),
+							"str z31,[x0]", "add x0,x0,#256")
+						negative, immediate := 0, 0
+						if signed {
+							negative = 1
+						}
+						if kind == "immediate" {
+							immediate = 1
+						}
+						fmt.Fprintf(&cases, "  {%d,%d,%d,%d,%d},\n", 1<<memory, 1<<element, negative, immediate, active)
+						count++
+					}
+				}
+			}
+		}
+	}
+	machine = append(machine, "mov x9,xzr", "ret")
+	machine[0] = fmt.Sprintf("adr x9,#%d", len(machine)*4+2048)
+	var source strings.Builder
+	source.WriteString("TEXT pool_sve_contiguous(SB),$0-8\nMOVD out+0(FP),R0\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := uint32(0); i < 1024; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", i*0x9e3779b9^(i>>4))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_sve_contiguous": {
+			Name: "pool_sve_contiguous", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	checks := fmt.Sprintf(`
+  const struct { unsigned memory, element, negative, immediate, active; } cases[] = {
+%s
+  };
+  uint8_t out[%d * 256 + 2];
+  memset(out, 0xaa, sizeof(out));
+  pool_sve_contiguous(out + 1);
+  if (out[0] != 0xaa || out[sizeof(out)-1] != 0xaa) return 1;
+  for (unsigned test = 0; test < sizeof(cases)/sizeof(cases[0]); test++) {
+    unsigned memory = cases[test].memory, element = cases[test].element;
+    unsigned offset = cases[test].immediate ? 2048 - 2*vl*memory/element : 2048 - 3*memory;
+    for (unsigned byte = 0; byte < 256; byte++) {
+      unsigned expected = 0xaa;
+      if (byte < vl) {
+        uint64_t value = 0;
+        if (cases[test].active) {
+          for (unsigned part = 0; part < memory; part++) {
+            unsigned at = offset + (byte/element)*memory + part;
+            uint32_t word = (at/4)*UINT32_C(0x9e3779b9) ^ (at/4 >> 4);
+            value |= (uint64_t)((word >> ((at%%4)*8)) & 255) << (part*8);
+          }
+          if (cases[test].negative && (value & (UINT64_C(1) << (memory*8-1))))
+            value |= UINT64_MAX << (memory*8);
+        }
+        expected = (value >> ((byte%%element)*8)) & 255;
+      }
+      if (out[test*256+byte+1] != expected) {
+        fprintf(stderr, "SVE contiguous pool case=%%u VL=%%u byte=%%u\n", test, vl, byte);
+        return 2;
+      }
+    }
+  }
+`, cases.String(), count)
+	const lengths = "16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256"
+	return ir, arm64SVEVectorLengthsMain("extern void pool_sve_contiguous(uint8_t *);\n", checks, lengths)
+}
+
+func TestARM64RawPoolSVEContiguousLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64RawPoolSVEContiguousRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_sve_contiguous.ll", "pool_sve_contiguous.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_contiguous_test.go b/arm64_raw_pool_sve_contiguous_test.go
new file mode 100644
index 000000000..72abe77d6
--- /dev/null
+++ b/arm64_raw_pool_sve_contiguous_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64RawPoolContiguousScalableLoads(t *testing.T) {
+	for _, signed := range []bool{false, true} {
+		for memory := 0; memory < 4; memory++ {
+			for element := memory; element < 4; element++ {
+				if signed && element == memory {
+					continue
+				}
+				form := arm64RawSVELoadCase{memorySize: memory, elementSize: element}
+				width := 256 >> uint(element-memory)
+				for _, kind := range []string{"immediate", "register"} {
+					form.kind = kind
+					load := form.loadAssembly(signed, 31, 7, 9, 10, 0)
+					for _, short := range []bool{false, true} {
+						words := width / 4
+						if short {
+							words--
+						}
+						t.Run(fmt.Sprintf("%s/short=%v", load, short), func(t *testing.T) {
+							body := "mov x10,#0\n" + load
+							if got := arm64PoolScalableProof(t, body, words); got == short {
+								t.Fatalf("pool proof=%v, want %v", got, !short)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawPoolContiguousScalableIndexGuards(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"bounded-doubleword", "and x10,x10,#7\nld1d {z31.d},p7/z,[x9,x10,lsl #3]", true},
+		{"byte-address-in-index", "and x10,x10,#7\nld1b {z31.b},p7/z,[x10,x9]", true},
+		{"correlated-displacement", "addvl x9,x9,#-1\ncntd x10\nld1d {z31.d},p7/z,[x9,x10,lsl #3]\naddvl x9,x9,#1", true},
+		{"unknown-index", "ld1d {z31.d},p7/z,[x9,x10,lsl #3]", false},
+		{"out-of-range-index", "mov x10,#9\nld1d {z31.d},p7/z,[x9,x10,lsl #3]", false},
+		{"scaled-relocated-index", "mov x10,#0\nld1d {z31.d},p7/z,[x10,x9,lsl #3]", false},
+		{"double-relocation", "ld1b {z31.b},p7/z,[x9,x9]", false},
+		{"store-is-not-read", "mov x10,#0\nst1d {z31.d},p7,[x9,x10,lsl #3]", false},
+		{"first-fault-not-ordinary", "ldff1d {z31.d},p7/z,[x9]", false},
+		{"vector-index-unproved", "ld1d {z31.d},p7/z,[x9,z30.d,lsl #3]", false},
+		{"masked-off-still-unproved", "pfalse p7.b\nld1d {z31.d},p7/z,[x9,x10,lsl #3]", false},
+		{"vector-length-mode-change", "smstart sm\nld1d {z31.d},p7/z,[x9]", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := arm64PoolScalableProof(t, test.body, 80); got != test.want {
+				t.Fatalf("indexed pool proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolContiguousScalableImmediateGrammar(t *testing.T) {
+	var lines []string
+	var widths []int64
+	for _, signed := range []bool{false, true} {
+		for memory := 0; memory < 4; memory++ {
+			for element := memory; element < 4; element++ {
+				if signed && element == memory {
+					continue
+				}
+				form := arm64RawSVELoadCase{memorySize: memory, elementSize: element, kind: "immediate"}
+				for immediate := -8; immediate < 8; immediate++ {
+					lines = append(lines, form.loadAssembly(signed, 31, 7, 9, 10, immediate))
+					widths = append(widths, 1<<uint(element-memory))
+				}
+			}
+		}
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		row, ok := arm64RawPoolContiguousLoad(word)
+		if !ok {
+			t.Fatalf("missing typed contiguous load: %s", lines[index])
+		}
+		if _, ok := arm64RawPoolContiguousLoad(word | (1 << 20)); ok {
+			t.Fatalf("%s: reserved immediate high bit accepted", lines[index])
+		}
+		for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+			flow := &arm64RawPoolValues{
+				words: []uint32{0x10000009, word}, before: [][]int{{-1}, {0}}, vectorBytes: vectorBytes,
+			}
+			bounds := (&arm64RawPoolBounds{size: 1024, offset: 512, values: flow}).withSymbolicOrigin(0)
+			width := vectorBytes / widths[index]
+			offset := 512 + int64(index%16-8)*width
+			want := offset >= 0 && offset+width <= 1024
+			if got := bounds.contiguousScalableLoadInBounds(1, word, row); got != want {
+				t.Fatalf("%s VL=%d: footprint proof=%v, want %v", lines[index], vectorBytes, got, want)
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_sve_effects_test.go b/arm64_raw_pool_sve_effects_test.go
new file mode 100644
index 000000000..f7dccb0d3
--- /dev/null
+++ b/arm64_raw_pool_sve_effects_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawPoolSVETypedEffects(t *testing.T) {
+	type effect struct {
+		line string
+		want bool
+	}
+	var cases []effect
+	for _, extract := range []struct {
+		op, destination, lane string
+		lanes                 int
+	}{
+		{"umov", "w9", "b", 16}, {"umov", "w9", "h", 8},
+		{"umov", "w9", "s", 4}, {"umov", "x9", "d", 2},
+		{"smov", "w9", "b", 16}, {"smov", "w9", "h", 8},
+		{"smov", "x9", "b", 16}, {"smov", "x9", "h", 8}, {"smov", "x9", "s", 4},
+	} {
+		for lane := 0; lane < extract.lanes; lane++ {
+			cases = append(cases, effect{fmt.Sprintf("%s %s, v31.%s[%d]", extract.op, extract.destination, extract.lane, lane), true})
+		}
+	}
+	for _, op := range []string{"and", "ands", "bic", "bics", "eor", "eors", "nand", "nands", "nor", "nors", "orn", "orns", "orr", "orrs"} {
+		cases = append(cases, effect{op + " p9.b, p15/z, p9.b, p14.b", true})
+	}
+	cases = append(cases, effect{"sel p9.b, p15, p9.b, p14.b", true})
+	for _, reg := range []string{"z31", "p15"} {
+		for _, op := range []string{"ldr", "str"} {
+			cases = append(cases,
+				effect{fmt.Sprintf("%s %s, [x30, #255, mul vl]", op, reg), true},
+				effect{fmt.Sprintf("%s %s, [sp, #-256, mul vl]", op, reg), true},
+				effect{fmt.Sprintf("%s %s, [x9]", op, reg), false},
+			)
+		}
+	}
+	for _, op := range []string{"addvl", "addpl"} {
+		for _, immediate := range []int{-32, 0, 31} {
+			cases = append(cases,
+				effect{fmt.Sprintf("%s x9, x30, #%d", op, immediate), true},
+				effect{fmt.Sprintf("%s x30, sp, #%d", op, immediate), true},
+				effect{fmt.Sprintf("%s x30, x9, #%d", op, immediate), false},
+				effect{fmt.Sprintf("%s x9, x9, #%d", op, immediate), false},
+			)
+		}
+	}
+	cases = append(cases, effect{"rdvl x9, #1", true}, effect{"rdvl x30, #-32", true})
+	cases = append(cases, effect{"dupm z9.d, #0x3ff0000000000000", true})
+	cases = append(cases, effect{"movprfx z9, z31\nadd z9.d, p0/m, z9.d, z30.d", true})
+	for _, op := range []string{"cntb", "cnth", "cntw", "cntd", "incb", "inch", "incw", "incd", "decb", "dech", "decw", "decd"} {
+		cases = append(cases, effect{op + " x30, all, mul #16", true})
+		cases = append(cases, effect{op + " x9, all, mul #16", strings.HasPrefix(op, "cnt")})
+	}
+	for _, width := range []string{"b", "h", "s", "d"} {
+		for _, immediate := range []int{-128, -1, 0, 1, 127} {
+			cases = append(cases, effect{fmt.Sprintf("dup z9.%s, #%d", width, immediate), true})
+			if width != "b" {
+				cases = append(cases, effect{fmt.Sprintf("dup z9.%s, #%d, lsl #8", width, immediate), true})
+			}
+		}
+		cases = append(cases,
+			effect{fmt.Sprintf("movprfx z9.%s, p7/m, z31.%s\nadd z9.%s, p7/m, z9.%s, z30.%s", width, width, width, width, width), true},
+			effect{fmt.Sprintf("movprfx z9.%s, p7/z, z31.%s\nadd z9.%s, p7/m, z9.%s, z30.%s", width, width, width, width, width), true},
+			effect{fmt.Sprintf("asrd z9.%s, p7/m, z9.%s, #1", width, width), true},
+			effect{fmt.Sprintf("mov z9.%s, p15/m, #7", width), true},
+			effect{fmt.Sprintf("mov z9.%s, p15/z, #-7", width), true},
+			effect{fmt.Sprintf("mov z9.%s, p7/m, %s9", width, width), true},
+			effect{fmt.Sprintf("sel z9.%s, p15, z30.%s, z31.%s", width, width, width), true},
+			effect{fmt.Sprintf("dup z9.%s, z31.%s[0]", width, width), true},
+		)
+		for _, op := range []string{"sub", "sqadd", "uqadd", "sqsub", "uqsub"} {
+			cases = append(cases, effect{fmt.Sprintf("%s z9.%s, z30.%s, z31.%s", op, width, width, width), true})
+		}
+		for _, op := range []string{"lsl", "lsr", "asr"} {
+			cases = append(cases, effect{fmt.Sprintf("%s z9.%s, z31.%s, #1", op, width, width), true})
+		}
+	}
+	for _, op := range []string{"zip1", "zip2", "uzp1", "uzp2", "trn1", "trn2"} {
+		for _, width := range []string{"b", "h", "s", "d"} {
+			cases = append(cases, effect{fmt.Sprintf("%s z9.%s, z9.%s, z31.%s", op, width, width, width), true})
+		}
+	}
+	for _, width := range []string{"h", "s", "d"} {
+		for _, op := range []string{"frecps", "frsqrts"} {
+			cases = append(cases, effect{
+				fmt.Sprintf("%s z9.%s, z30.%s, z31.%s", op, width, width, width), true,
+			})
+		}
+		for _, op := range []string{"fadd", "fsub", "fmul", "fdiv", "fdivr", "fscale", "fmax", "fmin"} {
+			cases = append(cases, effect{fmt.Sprintf("%s z9.%s, p7/m, z9.%s, z31.%s", op, width, width, width), true})
+		}
+		for _, op := range []string{"fabs", "fneg", "fsqrt"} {
+			cases = append(cases, effect{fmt.Sprintf("%s z9.%s, p7/m, z31.%s", op, width, width), true})
+		}
+		cases = append(cases,
+			effect{fmt.Sprintf("fmov z9.%s, #1.0", width), true},
+			effect{fmt.Sprintf("fcmgt p7.%s, p7/z, z9.%s, z31.%s", width, width, width), true},
+			effect{fmt.Sprintf("fmla z9.%s, p7/m, z9.%s, z31.%s", width, width, width), true},
+			effect{fmt.Sprintf("scvtf z9.%s, p7/m, z31.%s", width, width), true},
+		)
+	}
+	for _, width := range []string{"b", "h", "s", "d"} {
+		gp := "w"
+		if width == "d" {
+			gp = "x"
+		}
+		cases = append(cases,
+			effect{fmt.Sprintf("cntp x30, p15, p14.%s", width), true},
+			effect{fmt.Sprintf("cntp x9, p15, p14.%s", width), true},
+			effect{fmt.Sprintf("cntp x30, pn15.%s, vlx2", width), true},
+			effect{fmt.Sprintf("cntp x9, pn15.%s, vlx4", width), true},
+			effect{fmt.Sprintf("dup z31.%s, %s30", width, gp), true},
+			effect{fmt.Sprintf("dup z31.%s, %s9", width, gp), false},
+			effect{fmt.Sprintf("compact z31.%s, p7, z30.%s", width, width), true},
+			effect{fmt.Sprintf("cnt z31.%s, p7/m, z30.%s", width, width), true},
+			effect{fmt.Sprintf("cnt z31.%s, p7/z, z30.%s", width, width), true},
+		)
+		for _, condition := range []string{"ge", "gt", "hi", "hs", "le", "lo", "ls", "lt"} {
+			for _, inputs := range []struct {
+				first, second string
+				want          bool
+			}{
+				{"xzr", "x30", true}, {"x9", "x30", false},
+				{"x30", "x9", false}, {"x9", "x9", false},
+			} {
+				cases = append(cases, effect{
+					fmt.Sprintf("while%s p15.%s, %s, %s", condition, width, inputs.first, inputs.second), inputs.want,
+				})
+			}
+		}
+	}
+	for _, memory := range []struct {
+		suffix, width string
+		shift         int
+	}{
+		{"b", "b", 0}, {"b", "h", 0}, {"b", "s", 0}, {"b", "d", 0},
+		{"h", "h", 1}, {"h", "s", 1}, {"h", "d", 1},
+		{"w", "s", 2}, {"d", "d", 3},
+	} {
+		for _, load := range []bool{false, true} {
+			op, mode := "st1", ""
+			if load {
+				op, mode = "ld1", "/z"
+			}
+			for _, address := range []struct {
+				text string
+				want bool
+			}{
+				{"[x30]", true}, {"[sp, #-8, mul vl]", true},
+				{"[x9]", false}, {"[x9, #7, mul vl]", false},
+				{fmt.Sprintf("[x30, x29, lsl #%d]", memory.shift), true},
+				{fmt.Sprintf("[x30, x9, lsl #%d]", memory.shift), false},
+				{fmt.Sprintf("[x9, x30, lsl #%d]", memory.shift), false},
+			} {
+				cases = append(cases, effect{
+					fmt.Sprintf("%s%s {z31.%s}, p7%s, %s", op, memory.suffix, memory.width, mode, address.text), address.want,
+				})
+			}
+		}
+	}
+	// A GP source cannot be mistaken for a vector register sharing its number.
+	cases = append(cases, effect{"dup z31.d, x9", false})
+	var lines []string
+	starts := []int{0}
+	for _, test := range cases {
+		lines = append(lines, "adr x9, #64", "ldr w1, [x9]")
+		lines = append(lines, strings.Split(test.line, "\n")...)
+		lines = append(lines, "mov x9, xzr", "ret")
+		starts = append(starts, len(lines))
+	}
+	words := assembleARM64LLVMWords(t, lines, "+sve2p2")
+	for i, test := range cases {
+		t.Run(test.line, func(t *testing.T) {
+			var instructions []Instr
+			for _, word := range words[starts[i]:starts[i+1]] {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			if got := arm64RawAddressOnlyLoaded(instructions, 0, len(instructions)); got != test.want {
+				t.Fatalf("load-only proof=%v, want %v for %s", got, test.want, test.line)
+			}
+		})
+	}
+	if decoded, ok := decodeARM64RawSVEWhile(0x25ae1ff3); !ok || decoded.Op != "PWHILELS" {
+		t.Fatalf("previously unmodeled WHILELS word did not enter the typed family: %+v", decoded)
+	}
+	if !arm64RawPoolSVEIgnoresAddress(0x25ae1ff3, 9) {
+		t.Fatal("WHILELS reading XZR and X14 unexpectedly depends on the pool address in X9")
+	}
+	for _, word := range []uint32{0, 0x6ea0f16c, 0x6ebee0e4} {
+		if arm64RawPoolSVEIgnoresAddress(word, 9) {
+			t.Fatalf("unknown or unmodeled encoding %#08x acquired a safe effect", word)
+		}
+	}
+}
+
+func TestARM64RawPoolFlagArithmeticKills(t *testing.T) {
+	for _, width := range []string{"w", "x"} {
+		for _, op := range []string{"add", "adds", "adc", "adcs", "sub", "subs", "sbc", "sbcs", "neg", "negs", "ngc", "ngcs"} {
+			for _, source := range []int{0, 9} {
+				line := fmt.Sprintf("%s %s9, %s%d", op, width, width, source)
+				if !strings.HasPrefix(op, "n") {
+					line += fmt.Sprintf(", %s1", width)
+				}
+				t.Run(line, func(t *testing.T) {
+					var instructions []Instr
+					for _, word := range assembleARM64LLVMWords(t, []string{"adr x9, #64", "ldr w2, [x9]", line, "ret"}, "") {
+						instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+					}
+					if got := arm64RawAddressOnlyLoaded(instructions, 0, len(instructions)); got != (source != 9) {
+						t.Fatalf("load-only proof=%v for %s", got, line)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_sve_flags_runtime_test.go b/arm64_raw_pool_sve_flags_runtime_test.go
new file mode 100644
index 000000000..7290517d6
--- /dev/null
+++ b/arm64_raw_pool_sve_flags_runtime_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolSVEFlagsRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	forms := arm64PoolSVEFlagPreservingForms()
+	machine := []string{
+		"adr x9,#0", "ptrue p7.b", "ptrue p15.b",
+		"dup z9.b,#2", "dup z30.b,#3", "dup z31.b,#4",
+	}
+	for index, form := range forms {
+		machine = append(machine, "cmp x1,#15", form, "b.hi #12",
+			"ldrb w2,[x9,x1]", fmt.Sprintf("str x2,[x0,#%d]", index*8))
+	}
+	// Keep the vector computation observable as well as the guarded reads.
+	machine = append(machine, fmt.Sprintf("add x0,x0,#%d", len(forms)*8),
+		"str z31,[x0]", "add x0,x0,#256", "str z9,[x0]",
+		"add x0,x0,#256", "str p9,[x0]", "mov x9,xzr", "ret")
+	machine[0] = fmt.Sprintf("adr x9,#%d", len(machine)*4)
+	var source strings.Builder
+	source.WriteString("TEXT pool_sve_flags(SB),$0-16\nMOVD out+0(FP),R0\nMOVD index+8(FP),R1\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := 0; i < 4; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", uint32(0x17b4a140+i))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_sve_flags": {
+			Name: "pool_sve_flags", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	checks := fmt.Sprintf(`
+  const uint32_t words[4] = {0x17b4a140, 0x17b4a141, 0x17b4a142, 0x17b4a143};
+  const uint64_t indexes[] = {0, 1, 3, 7, 15, 16, 255, UINT64_C(1)<<32, UINT64_MAX};
+  uint8_t bytes[16];
+  memcpy(bytes, words, sizeof(bytes));
+  for (unsigned input = 0; input < sizeof(indexes)/sizeof(indexes[0]); input++) {
+    uint64_t out[%d + 68 + 2];
+    memset(out, 0xaa, sizeof(out));
+    pool_sve_flags(out + 1, indexes[input]);
+    if (out[0] != UINT64_C(0xaaaaaaaaaaaaaaaa) ||
+        out[sizeof(out)/sizeof(out[0])-1] != UINT64_C(0xaaaaaaaaaaaaaaaa)) return 1;
+    uint64_t expected = indexes[input] <= 15 ? bytes[indexes[input]] : UINT64_C(0xaaaaaaaaaaaaaaaa);
+    for (unsigned form = 0; form < %d; form++) {
+      if (out[form+1] != expected) {
+        fprintf(stderr, "SVE pool flags form=%%u VL=%%u input=%%u\n", form, vl, input);
+        return 2;
+      }
+    }
+  }
+`, len(forms), len(forms))
+	const lengths = "16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256"
+	return ir, arm64SVEVectorLengthsMain("extern void pool_sve_flags(uint64_t *, uint64_t);\n", checks, lengths)
+}
+
+func TestARM64RawPoolSVEFlagsLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64RawPoolSVEFlagsRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_sve_flags.ll", "pool_sve_flags.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_flags_test.go b/arm64_raw_pool_sve_flags_test.go
new file mode 100644
index 000000000..e0b5cf9fc
--- /dev/null
+++ b/arm64_raw_pool_sve_flags_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// Enumerate operations and orthogonal width/index modes independently of the
+// decoder. LLVM 22 supplies the encodings, including the flag-writing siblings.
+func arm64PoolSVEFlagPreservingForms() []string {
+	var lines []string
+	for _, op := range []string{"sunpklo", "sunpkhi", "uunpklo", "uunpkhi"} {
+		for _, widths := range [][2]string{{"h", "b"}, {"s", "h"}, {"d", "s"}} {
+			lines = append(lines, fmt.Sprintf("%s z9.%s,z31.%s", op, widths[0], widths[1]))
+		}
+	}
+	for _, op := range []string{"mla", "mls", "mad", "msb"} {
+		for size := 0; size < 4; size++ {
+			lines = append(lines, arm64RawSVEMultiplyAccumulateAssembly(op, size, 31, 30, 29, 7, -1))
+			if size == 0 || op == "mad" || op == "msb" {
+				continue
+			}
+			for lane := 0; lane < 16>>size; lane++ {
+				lines = append(lines, arm64RawSVEMultiplyAccumulateAssembly(op, size, 31, 30, 7, 0, lane))
+			}
+		}
+	}
+	for _, width := range "bhsd" {
+		for _, immediate := range []int{-128, -1, 0, 1, 127} {
+			lines = append(lines, fmt.Sprintf("dup z9.%c,#%d", width, immediate))
+			if width != 'b' {
+				lines = append(lines, fmt.Sprintf("dup z9.%c,#%d,lsl #8", width, immediate))
+			}
+		}
+		general := "w1"
+		if width == 'd' {
+			general = "x1"
+		}
+		lines = append(lines, fmt.Sprintf("dup z9.%c,%s", width, general))
+		for _, op := range []string{"and", "bic", "eor", "orr"} {
+			lines = append(lines, fmt.Sprintf("%s z9.%c,p7/m,z9.%c,z31.%c", op, width, width, width))
+			if op != "bic" {
+				lines = append(lines, fmt.Sprintf("%s z9.%c,z9.%c,#1", op, width, width))
+			}
+		}
+		for _, op := range []string{"andv", "eorv", "orv"} {
+			lines = append(lines, fmt.Sprintf("%s %c9,p7,z31.%c", op, width, width))
+		}
+		lines = append(lines, fmt.Sprintf("uaddv d9,p7,z31.%c", width))
+		if width != 'd' {
+			lines = append(lines, fmt.Sprintf("saddv d9,p7,z31.%c", width))
+		}
+	}
+	for size, width := range "bhsdq" {
+		for lane := 0; lane < 64>>size; lane++ {
+			lines = append(lines, fmt.Sprintf("dup z9.%c,z31.%c[%d]", width, width, lane))
+		}
+	}
+	for _, op := range []string{"and", "bic", "eor", "orr"} {
+		lines = append(lines, fmt.Sprintf("%s z9.d,z30.d,z31.d", op))
+	}
+	for _, op := range []string{"addqv", "andqv", "eorqv", "orqv"} {
+		for size := 0; size < 4; size++ {
+			lines = append(lines, arm64RawSVEIntegerReductionAssembly(op, size, 9, 31, 7))
+		}
+	}
+	for _, op := range []string{"and", "bic", "eor", "nand", "nor", "orn", "orr"} {
+		lines = append(lines, op+" p9.b,p15/z,p9.b,p14.b")
+	}
+	lines = append(lines, "sel p9.b,p15,p9.b,p14.b")
+	return append(lines, arm64RawSVECopyForms()...)
+}
+
+func TestARM64RawPoolSVEFlagProvenance(t *testing.T) {
+	lines := arm64PoolSVEFlagPreservingForms()
+	wants := make([]bool, len(lines))
+	for index := range wants {
+		wants[index] = true
+	}
+	for _, op := range []string{"ands", "bics", "eors", "nands", "nors", "orns", "orrs"} {
+		lines = append(lines, op+" p9.b,p15/z,p9.b,p14.b")
+	}
+	lines = append(lines,
+		"ptest p7,p9.b", "whilelo p7.b,x1,x2", "cmpeq p7.b,p7/z,z9.b,z31.b",
+		"fcmgt p7.s,p7/z,z9.s,z31.s", "msr nzcv,x1", "smstart sm", "udf #0",
+	)
+	for len(wants) < len(lines) {
+		wants = append(wants, false)
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve2p1,+sme") {
+		// CMP X1,#7, followed by exactly this instruction. A no-GP-write
+		// classification alone must not license carrying CMP's NZCV through it.
+		flow := &arm64RawPoolValues{words: []uint32{0xf1001c3f, word, 0xd503201f},
+			before: [][]int{{-1}, {0}, {1}}}
+		compare, clobbered, after, ok := flow.affineFlagSourceBefore(2)
+		if ok != wants[index] || ok && (compare != flow.words[0] || clobbered != 0 || after != 1) {
+			t.Errorf("%s: flags=(%#x,%#x,%d,%v), want preserved=%v", lines[index], compare, clobbered, after, ok, wants[index])
+		}
+	}
+}
+
+func TestARM64RawPoolSVEFlagsRespectControlFlow(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		body []string
+		want bool
+	}{
+		{"preserved", []string{"uunpklo z9.h,z31.b", "mla z31.d,p7/m,z30.d,z29.d"}, true},
+		{"predicate-flags", []string{"uunpklo z9.h,z31.b", "ands p9.b,p15/z,p9.b,p14.b"}, false},
+		{"scalar-flags", []string{"uunpklo z9.h,z31.b", "tst x2,x3"}, false},
+		{"bypassed-compare", []string{"uunpklo z9.h,z31.b", "mla z31.d,p7/m,z30.d,z29.d"}, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			lines := []string{"mov x1,#7", "nop", "subs x1,x1,#1"}
+			lines = append(lines, test.body...)
+			lines = append(lines, fmt.Sprintf("b.ne #%d", (1-len(lines))*4), "ret")
+			if test.name == "bypassed-compare" {
+				lines[1] = "cbz x2,#8"
+			}
+			words := assembleARM64LLVMWords(t, lines, "+sve2")
+			instructions := make([]Instr, len(words))
+			reachable := make(map[int]bool)
+			for at, word := range words {
+				instructions[at] = Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}
+				reachable[at] = true
+			}
+			flow := newARM64RawPoolValues(instructions, 0, len(words), reachable)
+			want := arm64PoolUnknownInterval
+			if test.want {
+				want = arm64PoolInterval{1, 7}
+			}
+			if got := flow.affineInterval(1, arm64PoolRegisterExpression(1)); got != want {
+				t.Fatalf("counter interval=%+v, want %+v", got, want)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolSVECopyGeneralEffects(t *testing.T) {
+	for _, width := range "bhsd" {
+		for _, source := range []int{0, 9, 30, 31} {
+			register := fmt.Sprintf("w%d", source)
+			if width == 'd' {
+				register = fmt.Sprintf("x%d", source)
+			}
+			if source == 31 {
+				register = "wsp"
+				if width == 'd' {
+					register = "sp"
+				}
+			}
+			line := fmt.Sprintf("cpy z9.%c,p7/m,%s", width, register)
+			word := assembleARM64LLVMWords(t, []string{line}, "+sve")[0]
+			if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 {
+				t.Errorf("%s: GP writes=%#x, known=%v", line, writes, known)
+			}
+			for address := 0; address < 32; address++ {
+				if ignored := arm64RawPoolSVEIgnoresAddress(word, address); ignored != (address != source) {
+					t.Errorf("%s: ignored address R%d=%v", line, address, ignored)
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_raw_pool_sve_memory.go b/arm64_raw_pool_sve_memory.go
new file mode 100644
index 000000000..53c69058d
--- /dev/null
+++ b/arm64_raw_pool_sve_memory.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+// A scalable transfer is accepted only inside a fixed architectural VL
+// partition. The caller proves all partitions. Predicate loads transfer VL/8
+// bytes, whereas whole-vector loads transfer VL bytes; stores are never reads
+// of a relocatable constant pool.
+func (bounds *arm64RawPoolBounds) wholeScalableLoadInBounds(at int, form arm64RawSVELoadStore) bool {
+	if !form.load || bounds == nil || !bounds.symbolic || bounds.values.vectorBytes == 0 || form.base == 31 {
+		return false
+	}
+	width := bounds.values.vectorBytes
+	if form.predicate {
+		width /= 8
+	}
+	expression := arm64PoolRegisterExpression(form.base)
+	expression.constant = uint64(int64(form.immediate) * width)
+	return bounds.scalableFootprintInBounds(at, expression, width)
+}
+
+// Reuse the complete signed/unsigned scalar-base LD1 grammar, including
+// widening arrangements. Gather, PN, first-fault and non-faulting operations
+// have different address/state contracts and are not ordinary contiguous reads.
+func arm64RawPoolContiguousLoad(word uint32) (arm64RawSVELoadRow, bool) {
+	row, ok := arm64RawSVEUnsignedLoadRows[word&0xffe0e000]
+	if !ok {
+		row, ok = arm64RawSVELoadRows[word&0xffe0e000]
+	}
+	if !ok || row.address != arm64SVELoadRegister && row.address != arm64SVELoadImmediate {
+		return arm64RawSVELoadRow{}, false
+	}
+	// In particular, Xm=31 and the high immediate bit are reserved, not
+	// aliases of zero. The lowerer's decoder is the authority for these fields.
+	_, valid := decodeARM64RawSVELoadAddress(word, row)
+	return row, valid
+}
+
+func (bounds *arm64RawPoolBounds) contiguousScalableLoadInBounds(at int, word uint32, row arm64RawSVELoadRow) bool {
+	base := int(word>>5) & 31
+	if bounds == nil || !bounds.symbolic || bounds.values.vectorBytes == 0 || base == 31 {
+		return false
+	}
+	spec := arm64SVEOrdinaryMemorySpecs[row.op]
+	// Conservatively assume every predicate lane is active. Extending a
+	// memory element changes the destination width, never the bytes accessed.
+	width := bounds.values.vectorBytes * int64(spec.memoryBits) / int64(row.elementBits)
+	expression := arm64PoolRegisterExpression(base)
+	if row.address == arm64SVELoadRegister {
+		index := int(word>>16) & 31
+		expression.add(arm64PoolRegisterExpression(index), row.scale)
+	} else {
+		immediate := int64(word>>16) & 15
+		if immediate >= 8 {
+			immediate -= 16
+		}
+		expression.constant = uint64(immediate * width)
+	}
+	return bounds.scalableFootprintInBounds(at, expression, width)
+}
+
+func (bounds *arm64RawPoolBounds) scalableFootprintInBounds(at int, expression arm64PoolAffine, width int64) bool {
+	value := bounds.values.invariantInterval(at, expression)
+	if value == arm64PoolUnknownInterval {
+		value = bounds.values.affineInterval(at, expression)
+	}
+	return value.low <= value.high && value.high <= uint64(bounds.size) &&
+		arm64RawPoolContains(int64(value.low), width, bounds.size) &&
+		arm64RawPoolContains(int64(value.high), width, bounds.size)
+}
diff --git a/arm64_raw_pool_sve_memory_runtime_test.go b/arm64_raw_pool_sve_memory_runtime_test.go
new file mode 100644
index 000000000..36fd289b6
--- /dev/null
+++ b/arm64_raw_pool_sve_memory_runtime_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolSVEMemoryRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var machine []string
+	var origins []int
+	for _, register := range []string{"z31", "p15"} {
+		for _, immediate := range []int{-1, 0, 1, 3} {
+			origins = append(origins, len(machine))
+			machine = append(machine, "adr x9,#0",
+				fmt.Sprintf("ldr %s,[x9,#%d,mul vl]", register, immediate),
+				fmt.Sprintf("str %s,[x0]", register),
+				"add x0,x0,#256", "mov x9,xzr")
+		}
+	}
+	machine = append(machine, "ret")
+	for _, at := range origins {
+		machine[at] = fmt.Sprintf("adr x9,#%d", (len(machine)-at)*4+2048)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT pool_sve_memory(SB),$0-8\nMOVD out+0(FP),R0\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := uint32(0); i < 1024; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", i*0x9e3779b9^(i>>4))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_sve_memory": {
+			Name: "pool_sve_memory", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const checks = `
+  uint8_t out[8 * 256 + 2];
+  memset(out, 0xaa, sizeof(out));
+  pool_sve_memory(out + 1);
+  if (out[0] != 0xaa || out[sizeof(out)-1] != 0xaa) return 1;
+  const int immediates[] = {-1, 0, 1, 3};
+  for (unsigned test = 0; test < 8; test++) {
+    unsigned width = test < 4 ? vl : vl / 8;
+    int offset = 2048 + immediates[test % 4] * (int)width;
+    for (unsigned byte = 0; byte < 256; byte++) {
+      unsigned expected = 0xaa;
+      if (byte < width) {
+        unsigned at = offset + byte;
+        uint32_t word = (at / 4) * UINT32_C(0x9e3779b9) ^ (at / 4 >> 4);
+        expected = (word >> ((at % 4) * 8)) & 255;
+      }
+      if (out[test * 256 + byte + 1] != expected) {
+        fprintf(stderr, "scalable pool load case=%u VL=%u byte=%u\n", test, vl, byte);
+        return 2;
+      }
+    }
+  }
+`
+	const lengths = "16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256"
+	main := arm64SVEVectorLengthsMain("extern void pool_sve_memory(uint8_t *);\n", checks, lengths)
+	return ir, main
+}
+
+func TestARM64RawPoolSVEMemoryLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64RawPoolSVEMemoryRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_sve_memory.ll", "pool_sve_memory.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_memory_test.go b/arm64_raw_pool_sve_memory_test.go
new file mode 100644
index 000000000..7c8f96646
--- /dev/null
+++ b/arm64_raw_pool_sve_memory_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64RawPoolWholeScalableImmediateGrammar(t *testing.T) {
+	var lines []string
+	for _, register := range []string{"z31", "p15"} {
+		for immediate := -256; immediate <= 255; immediate++ {
+			lines = append(lines, fmt.Sprintf("ldr %s,[x9,#%d,mul vl]", register, immediate))
+		}
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		form, ok := decodeARM64RawSVELoadStore(word)
+		if !ok {
+			t.Fatalf("missing typed whole-register memory form: %s", lines[index])
+		}
+		for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+			flow := &arm64RawPoolValues{
+				words: []uint32{0x10000009, word}, before: [][]int{{-1}, {0}},
+				vectorBytes: vectorBytes,
+			}
+			bounds := (&arm64RawPoolBounds{
+				size: 1024, offset: 512, values: flow,
+			}).withSymbolicOrigin(0)
+			width := vectorBytes
+			if index >= 512 {
+				width /= 8
+			}
+			offset := 512 + int64(index%512-256)*width
+			want := offset >= 0 && offset+width <= 1024
+			if got := bounds.wholeScalableLoadInBounds(1, form); got != want {
+				t.Fatalf("%s VL=%d: proof=%v, want %v", lines[index], vectorBytes, got, want)
+			}
+		}
+	}
+}
+
+func TestARM64RawPoolWholeScalableLoadBounds(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		words      int
+		want       bool
+	}{
+		{"vector", "ldr z31,[x9]", 64, true},
+		{"predicate", "ldr p15,[x9]", 8, true},
+		{"vector-short", "ldr z31,[x9]", 63, false},
+		{"predicate-short", "ldr p15,[x9]", 7, false},
+		{"vector-immediate", "ldr z31,[x9,#1,mul vl]", 128, true},
+		{"predicate-immediate", "ldr p15,[x9,#1,mul vl]", 16, true},
+		{"vector-negative", "addvl x9,x9,#1\nldr z31,[x9,#-1,mul vl]\naddvl x9,x9,#-1", 64, true},
+		{"predicate-negative", "addpl x9,x9,#1\nldr p15,[x9,#-1,mul vl]\naddpl x9,x9,#-1", 8, true},
+		{"vector-before-pool", "ldr z31,[x9,#-1,mul vl]", 64, false},
+		{"predicate-before-pool", "ldr p15,[x9,#-1,mul vl]", 8, false},
+		{"vector-write", "str z31,[x9]", 64, false},
+		{"predicate-write", "str p15,[x9]", 8, false},
+		{"unrelated-vector-write", "str z31,[x0]\nldr p15,[x9]", 8, true},
+		{"predicate-overrun", "ldr p15,[x9,#1,mul vl]", 15, false},
+		{"vector-overrun", "ldr z31,[x9,#1,mul vl]", 127, false},
+		{"vector-length-mode-change", "smstart sm\nldr z31,[x9]", 64, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := arm64PoolScalableProof(t, test.body, test.words); got != test.want {
+				t.Fatalf("whole scalable load proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_unpack_test.go b/arm64_raw_pool_sve_unpack_test.go
new file mode 100644
index 000000000..00d1dde2e
--- /dev/null
+++ b/arm64_raw_pool_sve_unpack_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestARM64RawPoolSVEUnpackEffects(t *testing.T) {
+	var lines []string
+	for _, op := range []string{"sunpklo", "sunpkhi", "uunpklo", "uunpkhi"} {
+		for _, widths := range [][2]string{{"h", "b"}, {"s", "h"}, {"d", "s"}} {
+			for _, source := range []int{0, 9, 31} {
+				lines = append(lines, fmt.Sprintf("%s z9.%s,z%d.%s", op, widths[0], source, widths[1]))
+			}
+		}
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		if !arm64RawPoolSVEPreservesNZCV(word) {
+			t.Errorf("%s: unpack unexpectedly clobbers NZCV", lines[index])
+		}
+		if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 {
+			t.Errorf("%s: GP effects=%#x/%v, want no GP writes", lines[index], writes, known)
+		}
+		if !arm64RawPoolSVEIgnoresAddress(word, 9) {
+			t.Errorf("%s: vector register was mistaken for an address use", lines[index])
+		}
+		// Size zero is reserved, even though the register fields are valid.
+		if arm64RawPoolIndependentSVE(word&^(3<<22)) || arm64RawPoolSVEPreservesNZCV(word&^(3<<22)) {
+			t.Errorf("%s: reserved byte destination acquired a safe effect", lines[index])
+		}
+	}
+}
diff --git a/arm64_raw_pool_sve_values.go b/arm64_raw_pool_sve_values.go
new file mode 100644
index 000000000..15fa7150c
--- /dev/null
+++ b/arm64_raw_pool_sve_values.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+// A VL partition represents one architectural vector length, never the host
+// setting. The caller must prove every multiple of 16 bytes through 256 and
+// exclude instructions that could change the vector-length execution mode.
+func (flow *arm64RawPoolValues) affineDefinition(word uint32) (int, arm64PoolAffine, bool) {
+	if flow.vectorBytes == 0 {
+		return arm64PoolAffineDefinition(word)
+	}
+	if form, ok := decodeARM64RawSVEAddress(word); ok {
+		if form.destination == 31 || form.op != "RDVL" && form.source == 31 {
+			return 0, arm64PoolAffine{}, false
+		}
+		unit := flow.vectorBytes
+		if form.op == "ADDPL" {
+			unit /= 8
+		}
+		value := arm64PoolAffine{constant: uint64(int64(form.immediate) * unit)}
+		if form.op != "RDVL" {
+			value.coefficient[form.source] = 1
+		}
+		return form.destination, value, true
+	}
+	if form, ok := decodeARM64RawSVECnt(word); ok && !form.vector && form.destination != 31 {
+		count := arm64PoolPatternCount(flow.vectorBytes*8/int64(form.elementBits), form.pattern)
+		value := arm64PoolAffine{constant: uint64(count * int64(form.multiplier))}
+		if form.operation != "" {
+			value.coefficient[form.destination] = 1
+			if form.operation == "sub" {
+				value.constant = -value.constant
+			}
+		}
+		return form.destination, value, true
+	}
+	return arm64PoolAffineDefinition(word)
+}
+
+// DecodePredCount: fixed VL patterns are zero if the requested element count
+// does not fit. Reserved patterns are zero, not ALL. No saturating INC/DEC or
+// vector destination is admitted by the scalar affine grammar above.
+func arm64PoolPatternCount(elements int64, pattern int) int64 {
+	switch {
+	case pattern == 0:
+		count := int64(1)
+		for count*2 <= elements {
+			count *= 2
+		}
+		return count
+	case pattern >= 1 && pattern <= 13:
+		count := int64(pattern)
+		if pattern >= 9 {
+			count = 16 << uint(pattern-9)
+		}
+		if count <= elements {
+			return count
+		}
+	case pattern == 29:
+		return elements / 4 * 4
+	case pattern == 30:
+		return elements / 3 * 3
+	case pattern == 31:
+		return elements
+	}
+	return 0
+}
+
+func arm64RawPoolAddressProof(instructions []Instr, end int, size int64, clobbers uint32, values *arm64RawPoolValues, origins map[int]uint64) bool {
+	// Deterministic order also prevents bounded proof caches from depending on
+	// map iteration. Each ADR still carries exactly one common relocation.
+	for at := range values.words {
+		offset, origin := origins[at]
+		if !origin {
+			continue
+		}
+		bounds := &arm64RawPoolBounds{offset: int64(offset), size: size, values: values, origins: origins}
+		if arm64RawAddressOnlyLoadedWithinPool(instructions, at, end, clobbers, bounds) {
+			continue
+		}
+		if !arm64RawAddressOnlyLoadedWithinPool(instructions, at, end, clobbers, bounds.withSymbolicOrigin(at)) {
+			return false
+		}
+	}
+	return true
+}
+
+func arm64RawPoolAllVectorLengths(instructions []Instr, start, end int, size int64, clobbers uint32, reachable map[int]bool, origins map[int]uint64) bool {
+	usesLength := false
+	for at := range reachable {
+		word := uint32(instructions[at].Args[0].Imm)
+		if word&0xfffffc1f == 0xd65f0000 {
+			continue
+		}
+		if _, known := arm64RawPoolGPWrites(word); !known {
+			return false // Calls, mode changes and unknown effects cannot fix VL.
+		}
+		if _, address := decodeARM64RawSVEAddress(word); address {
+			usesLength = true
+		}
+		if form, count := decodeARM64RawSVECnt(word); count && !form.vector {
+			usesLength = true
+		}
+		if _, memory := decodeARM64RawSVELoadStore(word); memory {
+			usesLength = true
+		}
+		if _, memory := arm64RawPoolContiguousLoad(word); memory {
+			usesLength = true
+		}
+	}
+	if !usesLength {
+		return false
+	}
+	for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+		// Rebuild all CFG/loop facts, not just numeric caches: a counted loop
+		// or an impossible edge may differ between vector lengths.
+		values := newARM64RawPoolValuesForVL(instructions, start, end, reachable, vectorBytes)
+		if !arm64RawPoolAddressProof(instructions, end, size, clobbers, values, origins) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/arm64_raw_pool_sve_values_runtime_test.go b/arm64_raw_pool_sve_values_runtime_test.go
new file mode 100644
index 000000000..e31f8e977
--- /dev/null
+++ b/arm64_raw_pool_sve_values_runtime_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolSVEValuesRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var machine []string
+	var origins []int
+	var checks strings.Builder
+	add := func(body []string, expected string) {
+		at := len(machine)
+		index := len(origins)
+		origins = append(origins, at)
+		machine = append(machine, "adr x9,#0")
+		machine = append(machine, body...)
+		machine = append(machine, "ldr x1,[x9]", fmt.Sprintf("str x1,[x0,#%d]", index*8), "mov x9,xzr")
+		fmt.Fprintf(&checks, "  offsets[%d] = %s;\n", index, expected)
+	}
+	for _, op := range []string{"cnt", "inc", "dec"} {
+		for width, suffix := range "bhwd" {
+			for _, pattern := range []int{0, 8, 9, 13, 14, 29, 30, 31} {
+				body := []string{"mov x15,#7", "cmp x15,#7", "addvl x9,x9,#-8", "mov x10,#0",
+					fmt.Sprintf("%s%c x10,#%d,mul #16", op, suffix, pattern),
+					"rdvl x11,#8", "addpl x12,x11,#-1", "b.hs #8", "ldr x1,[x9,#16384]", "add x9,x9,x11"}
+				sign := "+"
+				if op == "dec" {
+					sign = "-"
+				}
+				body = append(body, "add x9,x9,x10")
+				add(body, fmt.Sprintf("8192 %s 16 * pattern_count(vl >> %d, %d)", sign, width, pattern))
+			}
+		}
+	}
+	for _, op := range []string{"inc", "dec"} {
+		for size := 1; size < 4; size++ {
+			for _, pattern := range []int{0, 14, 31} {
+				for _, multiplier := range []int{1, 16} {
+					add([]string{"dup z10.d,#1", "mov x15,#7", "cmp x15,#7",
+						fmt.Sprintf("%s%c z10.%c,#%d,mul #%d", op, "bhwd"[size], "bhsd"[size], pattern, multiplier),
+						"b.hs #8", "ldr x1,[x9,#16384]"}, "8192")
+				}
+			}
+		}
+	}
+	machine = append(machine, "ret")
+	for _, at := range origins {
+		machine[at] = fmt.Sprintf("adr x9,#%d", (len(machine)-at)*4+8192)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT pool_sve_values(SB),$0-8\nMOVD out+0(FP),R0\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	for i := uint32(0); i < 4096; i++ {
+		fmt.Fprintf(&source, "WORD $%#08x\n", i*0x9e3779b9^(i>>4))
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"pool_sve_values": {
+			Name: "pool_sve_values", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const declarations = `
+extern void pool_sve_values(uint64_t *);
+static int pattern_count(unsigned n, unsigned pattern) {
+  const unsigned fixed[] = {0,1,2,3,4,5,6,7,8,16,32,64,128,256};
+  if (pattern == 0) {
+    unsigned result = 1;
+    while (result <= n / 2) result *= 2;
+    return result;
+  }
+  if (pattern < sizeof(fixed) / sizeof(fixed[0]))
+    return fixed[pattern] <= n ? fixed[pattern] : 0;
+  if (pattern == 29) return n - n % 4;
+  if (pattern == 30) return n - n % 3;
+  if (pattern == 31) return n;
+  return 0;
+}
+`
+	main := fmt.Sprintf(`
+  uint64_t out[%d] = {0};
+  int offsets[%d] = {0};
+  out[0] = 0x1234;
+  out[%d] = 0x5678;
+  pool_sve_values(out + 1);
+  if (out[0] != 0x1234 || out[%d] != 0x5678) return 1;
+%s
+  for (unsigned i = 0; i < %d; i++) {
+    uint64_t expected = 0;
+    for (unsigned byte = 0; byte < 8; byte++) {
+      unsigned at = offsets[i] + byte;
+      uint32_t word = (at / 4) * UINT32_C(0x9e3779b9) ^ (at / 4 >> 4);
+      expected |= (uint64_t)((word >> ((at %% 4) * 8)) & 255) << (byte * 8);
+    }
+    if (out[i + 1] != expected) {
+      fprintf(stderr, "pool count case=%%u VL=%%u\n", i, vl);
+      return 2;
+    }
+  }
+`, len(origins)+2, len(origins), len(origins)+1, len(origins)+1, checks.String(), len(origins))
+	const lengths = "16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256"
+	return ir, arm64SVEVectorLengthsMain(declarations, main, lengths)
+}
+
+func TestARM64RawPoolSVEValuesLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64RawPoolSVEValuesRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_sve_values.ll", "pool_sve_values.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_pool_sve_values_test.go b/arm64_raw_pool_sve_values_test.go
new file mode 100644
index 000000000..50c596529
--- /dev/null
+++ b/arm64_raw_pool_sve_values_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+	"testing"
+)
+
+// Keep the oracle independent of the proof's pattern decoder.
+func arm64PoolExpectedPattern(elements int64, pattern int) int64 {
+	counts := [32]int64{0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256}
+	counts[0] = 1 << (bits.Len64(uint64(elements)) - 1)
+	counts[29] = elements &^ 3
+	counts[30] = elements - elements%3
+	counts[31] = elements
+	if counts[pattern] > elements {
+		return 0
+	}
+	return counts[pattern]
+}
+
+func TestARM64RawPoolScalableCountGrammar(t *testing.T) {
+	var assembly []string
+	for _, op := range []string{"cnt", "inc", "dec"} {
+		for _, width := range "bhwd" {
+			for pattern := 0; pattern < 32; pattern++ {
+				for multiplier := 1; multiplier <= 16; multiplier++ {
+					assembly = append(assembly, fmt.Sprintf("%s%c x10,#%d,mul #%d", op, width, pattern, multiplier))
+				}
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, assembly, "+sve")
+	for index, word := range words {
+		requireARM64PoolScalableFlags(t, assembly[index], word, 1<<10)
+		op, width := index/(4*32*16), index/(32*16)%4
+		pattern, multiplier := index/16%32, index%16+1
+		for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+			flow := &arm64RawPoolValues{vectorBytes: vectorBytes}
+			destination, got, ok := flow.affineDefinition(word)
+			count := arm64PoolExpectedPattern(vectorBytes>>uint(width), pattern) * int64(multiplier)
+			want := arm64PoolAffine{constant: uint64(count)}
+			if op != 0 {
+				want.coefficient[10] = 1
+			}
+			if op == 2 {
+				want.constant = -want.constant
+			}
+			if !ok || destination != 10 || got != want {
+				t.Fatalf("%s VL=%d: got r%d %+v/%v, want %+v", assembly[index], vectorBytes, destination, got, ok, want)
+			}
+		}
+	}
+}
+
+func TestARM64RawPoolScalableAddressGrammar(t *testing.T) {
+	var assembly []string
+	for _, op := range []string{"rdvl", "addvl", "addpl"} {
+		for immediate := -32; immediate <= 31; immediate++ {
+			operands := "x10,x9"
+			if op == "rdvl" {
+				operands = "x10"
+			}
+			assembly = append(assembly, fmt.Sprintf("%s %s,#%d", op, operands, immediate))
+		}
+	}
+	for index, word := range assembleARM64LLVMWords(t, assembly, "+sve") {
+		requireARM64PoolScalableFlags(t, assembly[index], word, 1<<10)
+		for vectorBytes := int64(16); vectorBytes <= 256; vectorBytes += 16 {
+			unit := vectorBytes
+			if index >= 128 {
+				unit /= 8
+			}
+			want := arm64PoolAffine{constant: uint64(int64(index%64-32) * unit)}
+			if index >= 64 {
+				want.coefficient[9] = 1
+			}
+			flow := &arm64RawPoolValues{vectorBytes: vectorBytes}
+			destination, got, ok := flow.affineDefinition(word)
+			if !ok || destination != 10 || got != want {
+				t.Fatalf("%s VL=%d: got r%d %+v/%v, want %+v", assembly[index], vectorBytes, destination, got, ok, want)
+			}
+		}
+	}
+}
+
+func requireARM64PoolScalableFlags(t *testing.T, line string, word, wantWrites uint32) {
+	t.Helper()
+	flow := &arm64RawPoolValues{
+		words: []uint32{0xf1001c3f, word, 0xd503201f}, before: [][]int{{-1}, {0}, {1}},
+	}
+	compare, writes, after, ok := flow.affineFlagSourceBefore(2)
+	if !ok || compare != flow.words[0] || writes != wantWrites || after != 1 {
+		t.Fatalf("%s: flags=(%#x,%#x,%d,%v), want preserved with writes=%#x", line, compare, writes, after, ok, wantWrites)
+	}
+}
+
+func arm64PoolScalableProof(t *testing.T, body string, poolWords int) bool {
+	t.Helper()
+	lines := append([]string{"adr x9,#0"}, strings.Split(body, "\n")...)
+	lines = append(lines, "ldr x0,[x9]", "mov x9,xzr", "ret")
+	lines[0] = fmt.Sprintf("adr x9,#%d", len(lines)*4)
+	var instructions []Instr
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve,+sme") {
+		instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+	}
+	for i := 0; i < poolWords; i++ {
+		instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x17b4a14d}}})
+	}
+	points := make([]arm64RawLayoutPoint, len(instructions))
+	for i := range points {
+		points[i].offset = int64(i * 4)
+	}
+	data, _, _ := identifyARM64UnlabelledPool(Func{Instrs: instructions}, points, map[string]bool{}, 0)
+	return len(data) == poolWords
+}
+
+func TestARM64RawPoolScalableValueCorrelations(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		want       bool
+	}{
+		{"addvl-cancellation", "addvl x9,x9,#-31\naddvl x9,x9,#31", true},
+		{"addpl-cancellation", "addpl x9,x9,#-32\nrdvl x10,#4\nadd x9,x9,x10", true},
+		{"rdvl-cancellation", "addvl x9,x9,#-8\nrdvl x10,#8\nadd x9,x9,x10", true},
+		{"negative-rdvl", "addvl x9,x9,#-1\nrdvl x10,#-1\nsub x9,x9,x10", true},
+		{"count-bytes", "addvl x9,x9,#-16\ncntb x10,all,mul #16\nadd x9,x9,x10", true},
+		{"count-halfwords", "addpl x9,x9,#-4\ncnth x10\nadd x9,x9,x10", true},
+		{"count-words", "addpl x9,x9,#-2\ncntw x10\nadd x9,x9,x10", true},
+		{"count-doublewords", "addpl x9,x9,#-1\ncntd x10\nadd x9,x9,x10", true},
+		{"increment", "addvl x9,x9,#-1\nmov x10,#0\nincb x10\nadd x9,x9,x10", true},
+		{"decrement", "addvl x9,x9,#-1\nmov x10,#0\ndecb x10\nsub x9,x9,x10", true},
+		{"maximum-vl-overrun", "rdvl x10,#1\nadd x9,x9,x10", false},
+		{"mismatched-units", "addvl x9,x9,#-1\ncnth x10\nadd x9,x9,x10", false},
+		{"changed-vector-length", "rdvl x10,#1\nsmstart sm\naddvl x9,x9,#-1\nadd x9,x9,x10", false},
+		{"unknown-input", "addvl x9,x9,#-1\nadd x9,x9,x10", false},
+		{"truncated-count", "addvl x9,x9,#-1\nrdvl x10,#1\nadd w9,w9,w10", false},
+		{"read-before-cancellation", "addvl x9,x9,#-1\nldr x0,[x9]\naddvl x9,x9,#1", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := arm64PoolScalableProof(t, test.body, 8); got != test.want {
+				t.Fatalf("scalable pool proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_pool_symbolic.go b/arm64_raw_pool_symbolic.go
new file mode 100644
index 000000000..11bc96155
--- /dev/null
+++ b/arm64_raw_pool_symbolic.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "golang.org/x/arch/arm64/arm64asm"
+
+func (bounds *arm64RawPoolBounds) withSymbolicOrigin(at int) *arm64RawPoolBounds {
+	copy := *bounds
+	copy.symbolic = true
+	origins := bounds.origins
+	if len(origins) == 0 {
+		origins = map[int]uint64{at: uint64(bounds.offset)}
+	}
+	// Origins share one pool base but remain proof-local. Never reuse a cache
+	// computed with a different pool basis or modify ordinary integer analysis.
+	copy.values = &arm64RawPoolValues{
+		vectorBytes: bounds.values.vectorBytes,
+		words:       bounds.values.words, before: bounds.values.before,
+		cache: make(map[arm64RawPoolValue]uint64), active: make(map[arm64RawPoolValue]bool),
+		poolOrigins: origins,
+		excluded:    bounds.values.excluded, loopBounds: bounds.values.loopBounds,
+		loopLatches: bounds.values.loopLatches,
+	}
+	return &copy
+}
+
+func (bounds *arm64RawPoolBounds) offsetAt(at int, register arm64asm.Reg, fallback arm64RawPoolRange) (arm64RawPoolRange, bool) {
+	if bounds == nil || !bounds.symbolic {
+		return fallback, true
+	}
+	expression := arm64PoolRegisterExpression(int(register - arm64asm.X0))
+	value := bounds.values.invariantInterval(at, expression)
+	if value == arm64PoolUnknownInterval {
+		value = bounds.values.affineInterval(at, expression)
+	}
+	if value.low > value.high || value.high > uint64(bounds.size) {
+		return arm64RawPoolRange{}, false
+	}
+	return arm64RawPoolRange{int64(value.low), int64(value.high)}, true
+}
+
+func arm64RawPoolSymbolicAlias(word uint32, address int) (int, bool) {
+	// Restrict this extension to MOV/ADD/SUB without flag writes. The affine
+	// decoder excludes truncation and SP operands. Scaling or subtracting the
+	// relocated address itself would change its relocation coefficient.
+	if word&0xffe0ffe0 != 0xaa0003e0 && word&0xbf800000 != 0x91000000 && word&0xbf000000 != 0x8b000000 {
+		return 0, false
+	}
+	destination, expression, ok := arm64PoolAffineDefinition(word)
+	return destination, ok && expression.coefficient[address] == 1
+}
diff --git a/arm64_raw_pool_values.go b/arm64_raw_pool_values.go
new file mode 100644
index 000000000..b212674a3
--- /dev/null
+++ b/arm64_raw_pool_values.go
@@ -0,0 +1,337 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"math"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// Value bounds are separate from pointer relocation: a bound proves only an
+// unsigned integer interval, never that copying or escaping a pointer is safe.
+// Predecessors include every reachable edge. A conditional edge can narrow a
+// value only when its exact comparison and flag provenance are established.
+type arm64RawPoolValues struct {
+	words        []uint32
+	before       [][]int
+	cache        map[arm64RawPoolValue]uint64
+	active       map[arm64RawPoolValue]bool
+	vectorBytes  int64
+	gpWriteCache map[uint32]arm64RawPoolGPEffects
+
+	affineCache    map[arm64PoolAffineQuery]arm64PoolInterval
+	affineActive   map[arm64PoolAffineQuery]bool
+	affineWork     int
+	affineDirect   bool
+	maskConstants  map[int]uint64
+	invariantCache map[arm64PoolAffineQuery]arm64PoolInterval
+	poolOrigins    map[int]uint64
+	excluded       map[arm64RawPoolEdge]bool
+	loopBounds     map[int]arm64PoolConstraint
+	loopLatches    map[int]int
+	opaque         map[int]bool
+	opaqueLoops    map[int]int
+}
+
+type arm64RawPoolValue struct {
+	at  int
+	reg arm64asm.Reg
+}
+
+type arm64RawPoolEdge struct {
+	from, to int
+}
+
+type arm64RawPoolGPEffects struct {
+	writes uint32
+	known  bool
+}
+
+func newARM64RawPoolValues(instructions []Instr, start, end int, reachable map[int]bool) *arm64RawPoolValues {
+	return newARM64RawPoolValuesForVL(instructions, start, end, reachable, 0)
+}
+
+func newARM64RawPoolValuesForVL(instructions []Instr, start, end int, reachable map[int]bool, vectorBytes int64) *arm64RawPoolValues {
+	flow := &arm64RawPoolValues{
+		vectorBytes: vectorBytes,
+		words:       make([]uint32, end), before: make([][]int, end),
+		cache: make(map[arm64RawPoolValue]uint64), active: make(map[arm64RawPoolValue]bool),
+	}
+	flow.before[start] = []int{-1} // The function's unknown incoming registers.
+	// Stable predecessor order keeps bounded proofs and their caches
+	// reproducible; map iteration must not decide whether a budget is met.
+	for at := start; at < end; at++ {
+		if !reachable[at] {
+			continue
+		}
+		word := uint32(instructions[at].Args[0].Imm)
+		flow.words[at] = word
+		if word&0xfffffc1f == 0xd65f0000 {
+			continue
+		}
+		displacement, op, relative, _ := arm64RawPCRelativeDisplacement(instructions[at])
+		if relative && op != "ADR" {
+			target := at + int(displacement/4)
+			if target >= start && target < end {
+				flow.before[target] = append(flow.before[target], at)
+			}
+		}
+		if word&0xfc000000 != 0x14000000 && at+1 < end {
+			flow.before[at+1] = append(flow.before[at+1], at)
+		}
+	}
+	flow.prepareControlFlow()
+	return flow
+}
+
+func arm64RawPoolGP(reg arm64asm.Reg) (int, bool) {
+	switch {
+	case reg >= arm64asm.W0 && reg < arm64asm.WZR:
+		return int(reg - arm64asm.W0), true
+	case reg >= arm64asm.X0 && reg < arm64asm.XZR:
+		return int(reg - arm64asm.X0), true
+	}
+	return 0, false
+}
+
+func (flow *arm64RawPoolValues) gpWrites(word uint32) (uint32, bool) {
+	if effects, found := flow.gpWriteCache[word]; found {
+		return effects.writes, effects.known
+	}
+	writes, known := arm64RawPoolGPWrites(word)
+	if flow.gpWriteCache == nil {
+		flow.gpWriteCache = make(map[uint32]arm64RawPoolGPEffects)
+	}
+	// Only context-free architectural effects are memoized, by the complete
+	// machine word. Unknown remains unknown; no value/edge/interval fact is
+	// cached here. The map belongs to this analysis, never a global decoder.
+	flow.gpWriteCache[word] = arm64RawPoolGPEffects{writes: writes, known: known}
+	return writes, known
+}
+
+// Walk backwards through unchanged-register edges, unioning all reaching
+// definitions. A loop that preserves the register is harmless. A value-changing
+// cycle, unknown effect or unknown entry produces the full unsigned range.
+func (flow *arm64RawPoolValues) upper(at int, reg arm64asm.Reg) uint64 {
+	if reg == arm64asm.XZR || reg == arm64asm.WZR {
+		return 0
+	}
+	index, ok := arm64RawPoolGP(reg)
+	if flow == nil || !ok {
+		return math.MaxUint64
+	}
+	key := arm64RawPoolValue{at, reg}
+	if value, ok := flow.cache[key]; ok {
+		return value
+	}
+	limit := uint64(math.MaxUint64)
+	if reg < arm64asm.WZR {
+		limit = math.MaxUint32
+	}
+	if flow.active[key] {
+		return limit
+	}
+	flow.active[key] = true
+	defer delete(flow.active, key)
+
+	var queue []arm64RawPoolEdge
+	enqueue := func(at int) {
+		for _, previous := range flow.before[at] {
+			queue = append(queue, arm64RawPoolEdge{previous, at})
+		}
+	}
+	enqueue(at)
+	visited := make(map[int]bool)
+	upper, found := uint64(0), false
+	for len(queue) > 0 {
+		edge := queue[len(queue)-1]
+		previous := edge.from
+		queue = queue[:len(queue)-1]
+		if previous < 0 {
+			return limit
+		}
+		if flow.opaque[previous] {
+			return limit
+		}
+		if bound, ok := flow.edgeUpper(edge, reg); ok {
+			if bound > limit {
+				bound = limit
+			}
+			if bound > upper {
+				upper = bound
+			}
+			found = true
+			continue
+		}
+		if visited[previous] {
+			continue
+		}
+		visited[previous] = true
+		word := flow.words[previous]
+		writes, known := flow.gpWrites(word)
+		if !known {
+			return limit
+		}
+		if writes&(1<<uint(index)) == 0 {
+			enqueue(previous)
+			continue
+		}
+		value := flow.definitionUpper(previous, word, index)
+		if value > limit {
+			value = limit
+		}
+		if value > upper {
+			upper = value
+		}
+		found = true
+	}
+	if !found {
+		return limit
+	}
+	flow.cache[key] = upper
+	return upper
+}
+
+func (flow *arm64RawPoolValues) definitionUpper(at int, word uint32, index int) uint64 {
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil {
+		return math.MaxUint64
+	}
+	destination, ok := ins.Args[0].(arm64asm.Reg)
+	if reg, sp := ins.Args[0].(arm64asm.RegSP); sp {
+		destination, ok = arm64asm.Reg(reg), true
+	}
+	if actual, gp := arm64RawPoolGP(destination); !ok || !gp || actual != index {
+		return math.MaxUint64 // Includes memory-base writeback and second outputs.
+	}
+	// Loads with writeback may also overwrite the nominal destination's base.
+	for _, arg := range ins.Args {
+		if memory, ok := arg.(arm64asm.MemImmediate); ok && memory.Mode != arm64asm.AddrOffset {
+			if base, gp := arm64RawPoolGP(arm64asm.Reg(memory.Base)); gp && base == index {
+				return math.MaxUint64
+			}
+		}
+	}
+	argUpper := func(arg arm64asm.Arg) uint64 {
+		switch arg := arg.(type) {
+		case arm64asm.Reg:
+			return flow.upper(at, arg)
+		case arm64asm.Imm:
+			return uint64(arg.Imm)
+		case arm64asm.Imm64:
+			return arg.Imm
+		}
+		return math.MaxUint64
+	}
+	switch ins.Op {
+	case arm64asm.MOV:
+		return argUpper(ins.Args[1])
+	case arm64asm.AND:
+		if _, ok := ins.Args[2].(arm64asm.Imm); ok {
+			return argUpper(ins.Args[2])
+		}
+		if _, ok := ins.Args[2].(arm64asm.Imm64); ok {
+			return argUpper(ins.Args[2])
+		}
+	case arm64asm.CSEL:
+		left, right := argUpper(ins.Args[1]), argUpper(ins.Args[2])
+		if left > right {
+			return left
+		}
+		return right
+	case arm64asm.LSR:
+		if shift, ok := ins.Args[2].(arm64asm.Imm); ok {
+			return argUpper(ins.Args[1]) >> shift.Imm
+		}
+	case arm64asm.LDRB, arm64asm.LDURB, arm64asm.LDTRB, arm64asm.LDARB, arm64asm.UXTB:
+		return math.MaxUint8
+	case arm64asm.LDRH, arm64asm.LDURH, arm64asm.LDTRH, arm64asm.LDARH, arm64asm.UXTH:
+		return math.MaxUint16
+	}
+	return math.MaxUint64
+}
+
+// Explicit destination effects for the base data-processing classes and
+// ordinary memory instructions. x/arch must validate the encoding first. Do
+// not infer effects for system, call, exclusive, atomic or unknown operations.
+func arm64RawPoolGPWrites(word uint32) (uint32, bool) {
+	if form, valid := decodeARM64RawScalarRegister(word); valid {
+		_, writes, _ := form.gpEffects()
+		return writes, true
+	}
+	if form, valid := decodeARM64RawBitfield(word); valid {
+		_, writes := form.gpEffects()
+		return writes, true
+	}
+	if effects, ok := arm64RawContinuationEffectsForWord(word); ok {
+		return effects.gpWrites, true
+	}
+	if effects, ok := arm64RawSVEEffects(word); ok {
+		return effects.gpWrites, true
+	}
+	if form, ok := decodeARM64RawSVEAddress(word); ok {
+		return 1 << uint(form.destination), true
+	}
+	if form, ok := decodeARM64RawSVECnt(word); ok && !form.vector {
+		return 1 << uint(form.destination), true
+	}
+	if _, ok := decodeARM64RawSVEPredicateCount(word); ok {
+		return 1 << (word & 31), true
+	}
+	if arm64RawPoolSVEIgnoresAddress(word, -1) {
+		return 0, true
+	}
+	if _, ok := arm64RawPoolReplicateLoad(word); ok {
+		return 0, true
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	ins, err := arm64asm.Decode(code[:])
+	if err != nil {
+		return 0, false
+	}
+	destinations := 0
+	switch {
+	case word&0x1c000000 == 0x10000000, word&0x0e000000 == 0x0a000000, word&0x0e000000 == 0x0e000000:
+		destinations = 1
+		switch ins.Op {
+		case arm64asm.CMP, arm64asm.CMN, arm64asm.TST, arm64asm.CCMP, arm64asm.CCMN:
+			destinations = 0
+		}
+	case arm64RawPoolReadOnlyLoad(ins.Op):
+		destinations = 1
+		if ins.Op == arm64asm.LDP || ins.Op == arm64asm.LDNP || ins.Op == arm64asm.LDPSW {
+			destinations = 2
+		}
+	default:
+		switch ins.Op {
+		case arm64asm.B, arm64asm.CBZ, arm64asm.CBNZ, arm64asm.TBZ, arm64asm.TBNZ, arm64asm.NOP,
+			arm64asm.STR, arm64asm.STRB, arm64asm.STRH, arm64asm.STUR, arm64asm.STURB, arm64asm.STURH,
+			arm64asm.STTR, arm64asm.STTRB, arm64asm.STTRH, arm64asm.STLR, arm64asm.STLRB, arm64asm.STLRH,
+			arm64asm.STP, arm64asm.STNP, arm64asm.ST1, arm64asm.ST2, arm64asm.ST3, arm64asm.ST4:
+		default:
+			return 0, false
+		}
+	}
+	var writes uint32
+	for n, arg := range ins.Args {
+		if reg, ok := arg.(arm64asm.Reg); ok && n < destinations {
+			if index, gp := arm64RawPoolGP(reg); gp {
+				writes |= 1 << uint(index)
+			}
+		}
+		if reg, ok := arg.(arm64asm.RegSP); ok && n < destinations {
+			if index, gp := arm64RawPoolGP(arm64asm.Reg(reg)); gp {
+				writes |= 1 << uint(index)
+			}
+		}
+		if memory, ok := arg.(arm64asm.MemImmediate); ok && memory.Mode != arm64asm.AddrOffset {
+			if index, gp := arm64RawPoolGP(arm64asm.Reg(memory.Base)); gp {
+				writes |= 1 << uint(index)
+			}
+		}
+	}
+	return writes, true
+}
diff --git a/arm64_raw_pool_writeback_test.go b/arm64_raw_pool_writeback_test.go
new file mode 100644
index 000000000..b601d1c9f
--- /dev/null
+++ b/arm64_raw_pool_writeback_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64RawPoolWritebackFootprints(t *testing.T) {
+	// Go asm7.go MOV[BHWD], FMOV[SDQ] and LDP[W/SW]/FLDP[SDQ] have
+	// independent offset/pre/post rows. Check every load width and sign view;
+	// store, exclusive and atomic operations are never read-only pool uses.
+	type form struct {
+		line         string
+		bytes, delta int64
+		pre          bool
+	}
+	var cases []form
+	for _, load := range []struct {
+		operands string
+		bytes    int64
+	}{
+		{"ldr b0", 1}, {"ldr h0", 2}, {"ldr s0", 4}, {"ldr d0", 8}, {"ldr q0", 16},
+		{"ldr w0", 4}, {"ldr x0", 8}, {"ldr xzr", 8}, {"ldrb w0", 1}, {"ldrh w0", 2},
+		{"ldrsb w0", 1}, {"ldrsb x0", 1}, {"ldrsh w0", 2}, {"ldrsh x0", 2}, {"ldrsw x0", 4},
+		{"ldp w0, w1", 8}, {"ldp x0, x1", 16}, {"ldpsw x0, x1", 8},
+		{"ldp s0, s1", 8}, {"ldp d0, d1", 16}, {"ldp q0, q1", 32},
+	} {
+		for _, delta := range []int64{-16, 0, 16} {
+			for _, pre := range []bool{false, true} {
+				memory := fmt.Sprintf("[x9], #%d", delta)
+				if pre {
+					memory = fmt.Sprintf("[x9, #%d]!", delta)
+				}
+				cases = append(cases, form{load.operands + ", " + memory, load.bytes, delta, pre})
+			}
+		}
+	}
+	lines := make([]string, len(cases))
+	for i, test := range cases {
+		lines[i] = test.line
+	}
+	words := assembleARM64LLVMWords(t, lines, "")
+	for i, test := range cases {
+		t.Run(test.line, func(t *testing.T) {
+			var code [4]byte
+			binary.LittleEndian.PutUint32(code[:], words[i])
+			ins, err := arm64asm.Decode(code[:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			var memory arm64asm.MemImmediate
+			for _, arg := range ins.Args {
+				if value, ok := arg.(arm64asm.MemImmediate); ok {
+					memory = value
+				}
+			}
+			start := int64(64)
+			if test.pre {
+				start += test.delta
+			}
+			if !arm64RawPoolLoadInBounds(ins, words[i], memory, 64, start+test.bytes) {
+				t.Fatal("exact footprint rejected")
+			}
+			if arm64RawPoolLoadInBounds(ins, words[i], memory, 64, start+test.bytes-1) {
+				t.Fatal("one-byte overrun accepted")
+			}
+			base, delta, valid := arm64PoolLoadWriteback(ins, words[i])
+			if !valid || base != 9 || delta != test.delta {
+				t.Fatalf("writeback=(%d, %d, %v), want (9, %d, true)", base, delta, valid, test.delta)
+			}
+			_, value, affine := arm64PoolAffineDefinition(words[i])
+			expected := arm64PoolRegisterExpression(9)
+			expected.constant = uint64(test.delta)
+			if !affine || value != expected {
+				t.Fatalf("wrong affine base update: %+v, %v", value, affine)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolWritebackRejectsOverlaps(t *testing.T) {
+	for _, line := range []string{"ldr x0, [x9], #8", "ldr w0, [x9, #-8]!", "ldp x0, x1, [x9], #16"} {
+		word := assembleARM64LLVMWords(t, []string{line}, "")[0]
+		for _, shift := range []uint{0, 10} {
+			if shift == 10 && word&0x3a000000 != 0x28000000 {
+				continue
+			}
+			overlap := word&^(31<<shift) | 9<<shift
+			var code [4]byte
+			binary.LittleEndian.PutUint32(code[:], overlap)
+			if ins, err := arm64asm.Decode(code[:]); err == nil {
+				if _, _, valid := arm64PoolLoadWriteback(ins, overlap); valid {
+					t.Fatalf("accepted destination/base overlap: %s (%#x)", line, overlap)
+				}
+			}
+			if _, _, valid := arm64PoolAffineDefinition(overlap); valid {
+				t.Fatalf("overlap invented an affine definition: %s (%#x)", line, overlap)
+			}
+		}
+	}
+}
diff --git a/arm64_raw_private_frame.go b/arm64_raw_private_frame.go
new file mode 100644
index 000000000..65cad6180
--- /dev/null
+++ b/arm64_raw_private_frame.go
@@ -0,0 +1,651 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// This additive proof is only for framed source-leaf functions containing raw
+// encodings or checked R20 uses. Unlike the older affine proof it tracks physical SP
+// movement and privately spilled frame-address values. Neither decoding a WORD
+// nor a generic GP-write mask supplies permission to expose or erase an address.
+type arm64RawPrivateFrameState struct {
+	sp     int64
+	regs   arm64PrivateFrameAddresses
+	spills map[int64]arm64PrivateFrameAddress // eight-byte address-bearing cells
+	fixed  *arm64ControlState                 // independent R18/g entry identities and saved cells
+}
+
+func (s *arm64RawPrivateFrameState) clone() *arm64RawPrivateFrameState {
+	next := &arm64RawPrivateFrameState{sp: s.sp, regs: s.regs.clone(), spills: make(map[int64]arm64PrivateFrameAddress)}
+	for offset, value := range s.spills {
+		next.spills[offset] = value
+	}
+	if s.fixed != nil {
+		next.fixed = s.fixed.clone()
+	}
+	return next
+}
+
+func (s *arm64RawPrivateFrameState) address(reg Reg) (arm64PrivateFrameAddress, bool) {
+	if arm64StackReg(reg) {
+		return arm64PrivateFrameAddress{offset: s.sp, exact: true}, true
+	}
+	value, present := s.regs[reg]
+	return value, present
+}
+
+func (s *arm64RawPrivateFrameState) assign(reg Reg, value arm64PrivateFrameAddress, present bool) bool {
+	if arm64StackReg(reg) {
+		if !present || !value.exact || value.offset > 0 || value.offset < -arm64MaxLocalStackSpan {
+			return false
+		}
+		s.sp = value.offset
+		return true
+	}
+	return s.regs.assign(reg, value, present)
+}
+
+func arm64HasRawFrameCode(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpWORD {
+			return true
+		}
+	}
+	return false
+}
+
+func arm64RawPrivateFrameUnexposed(fn Func) bool {
+	return arm64RawPrivateFrameUnexposedForTransport(fn, nil)
+}
+
+func arm64RawPrivateFrameUnexposedForTransport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	frame := arm64SourceGoFrame(fn)
+	if !frame.present || frame.restoresLink || !arm64SourceFrameFlagsKnown(fn) || fn.FrameSize < 0 || fn.FrameSize > arm64MaxLocalStackSpan || fn.FrameSize&7 != 0 {
+		return false
+	}
+	text := false
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpTEXT {
+			continue
+		}
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) < 2 || len(parts) > 3 || !strings.HasPrefix(strings.TrimSpace(parts[len(parts)-1]), "$") {
+			return false
+		}
+		size, _, err := parseTEXTFrame(parts)
+		if err != nil || size != fn.FrameSize || text {
+			return false
+		}
+		text = true
+	}
+	if !text {
+		return false
+	}
+	// Register raw PC edges through the exact source-boundary checker. Once
+	// these edges are named, use that CFG directly: reclassifying skipped WORDs
+	// as anonymous data would change the original executable source role.
+	// Unknown words and every dead component still pass the guards below.
+	prepared := fn
+	rawBranch := false
+	for _, ins := range fn.Instrs {
+		_, _, relative, err := arm64RawPCRelativeDisplacement(ins)
+		if err != nil {
+			return false
+		}
+		if relative {
+			// Decode only the control role here. The placeholder is never
+			// emitted or trusted as a target; prepare below proves that target.
+			decoded, err := decodeARM64RawWordInstructionTarget(ins, "checked_branch_role")
+			op := arm64ControlOp(decoded)
+			if err != nil || op != "B" && op != OpJMP && !arm64IsConditionalBranch(op) {
+				// In particular BAL/BNV, BL and native address producers cannot
+				// be mistaken for ordinary fallthrough or known frame branches.
+				return false
+			}
+			rawBranch = true
+		}
+	}
+	if rawBranch {
+		var blobs []arm64RawDataBlob
+		var err error
+		prepared, blobs, err = prepareARM64RawPCRelative(fn)
+		if err != nil || len(blobs) != 0 {
+			return false
+		}
+	}
+	blocks := arm64SplitBlocks(prepared)
+	indices := make(map[string]int, len(blocks))
+	for index, block := range blocks {
+		indices[block.name] = index
+	}
+	before := make([]*arm64RawPrivateFrameState, len(blocks))
+	queue := []int{}
+	queued := make([]bool, len(blocks))
+	propagate := func(index int, state *arm64RawPrivateFrameState) bool {
+		if index < 0 || index >= len(blocks) {
+			return false
+		}
+		changed := false
+		if before[index] == nil {
+			before[index], changed = state.clone(), true
+		} else {
+			old := before[index]
+			// Do not merge distinct physical SP values into a guessed frame.
+			if old.sp != state.sp {
+				return false
+			}
+			changed = old.regs.merge(state.regs)
+			spillUnion := make(map[int64]arm64PrivateFrameAddress)
+			for offset, value := range old.spills {
+				if other, ok := state.spills[offset]; !ok || value != other {
+					value = arm64PrivateFrameAddress{}
+				}
+				spillUnion[offset] = value
+			}
+			for offset := range state.spills {
+				if _, ok := old.spills[offset]; !ok {
+					spillUnion[offset] = arm64PrivateFrameAddress{}
+				}
+			}
+			if !reflect.DeepEqual(old.spills, spillUnion) {
+				old.spills, changed = spillUnion, true
+			}
+			changed = old.fixed.merge(state.fixed) || changed
+		}
+		if changed && !queued[index] {
+			queue, queued[index] = append(queue, index), true
+		}
+		return true
+	}
+	// Include dead source components: later normalization cannot erase an escape.
+	for seed := range blocks {
+		if before[seed] != nil {
+			continue
+		}
+		entry := &arm64RawPrivateFrameState{
+			regs: arm64PrivateFrameAddresses{"R18": {}, "R28": {}, "R29": {}},
+			// The Go prologue itself saves the incoming frame pointer here.
+			// Reading it must not silently turn its unknown may-frame value
+			// into an ordinary external scalar.
+			spills: map[int64]arm64PrivateFrameAddress{-8: {}},
+			fixed: &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{SP: arm64ControlFromMap(map[string]bool{"sp:0": true})},
+				memory: make(map[string]arm64ControlValue), unexposedSP: true,
+			},
+		}
+		for _, fixed := range arm64RawZeroFixedEntry[:2] {
+			entry.fixed.regs[fixed.reg] = arm64ControlFromMap(map[string]bool{fixed.token: true})
+		}
+		if arm64SourceUsesR20(fn) {
+			entry.regs["R20"] = arm64PrivateFrameAddress{}
+		}
+		r20Transport := arm64SourceFrameR20(fn) && arm64SourceFrameR20Transport(fn, transport)
+		if arm64SourceFrameAutosize(fn.FrameSize) > 0xf0 {
+			entry.regs["R20"] = arm64PrivateFrameAddress{
+				exact: r20Transport,
+			}
+			if entry.regs["R20"].exact {
+				entry.fixed.regs["R20"] = arm64ControlFromMap(map[string]bool{"sp:0": true})
+				entry.fixed.regs["R30"] = arm64ControlFromMap(map[string]bool{"label:entry-lr": true})
+				entry.fixed.memory["sp:0"] = entry.fixed.regs["R30"]
+			}
+		}
+		if !propagate(seed, entry) {
+			return false
+		}
+		for next := 0; next < len(queue); next++ {
+			index := queue[next]
+			queued[index] = false
+			state := before[index].clone()
+			terminated := false
+			for _, original := range blocks[index].instrs {
+				ins := arm64ControlDecode(original)
+				op := arm64ControlOp(ins)
+				if op == OpRET {
+					// Only a source Go RET consumes its implicit frame pointer.
+					// The separate continuation proof still checks SP and LR.
+					if !arm64RawPrivateSourceRET(original) || state.sp != 0 {
+						return false
+					}
+					delete(state.regs, "R29")
+					if r20Transport {
+						// A source leaf RET uses R30, but Go's traceback still
+						// owns the automatic saved-link cell. Its exact identity
+						// cannot be discarded merely because LLVM returns natively.
+						link := state.fixed.source(Operand{Kind: OpMem, Mem: MemRef{Base: SP}}, false)
+						if arm64ControlCount(link) != 1 || !arm64ControlHas(link, "label:entry-lr") {
+							return false
+						}
+					}
+					for _, fixed := range arm64RawZeroFixedEntry[:2] {
+						value := arm64ControlRead(state.fixed.regs, fixed.reg)
+						if arm64ControlCount(value) != 1 || !arm64ControlHas(value, fixed.token) {
+							return false
+						}
+						delete(state.regs, fixed.reg)
+					}
+					if len(state.regs) != 0 && (!r20Transport || !state.regs.bounded(fn.FrameSize) ||
+						!transport.consume(original, state.regs, false)) {
+						return false
+					}
+					terminated = true
+					break
+				}
+				switch op {
+				case "CALL", "BL", "BLR", "ADR", "ADRP", "BAL", "BNV", arm64RawDataOp:
+					return false
+				}
+				if !state.transfer(original, ins, fn.FrameSize) {
+					return false
+				}
+				if !state.fixed.transferStructureMemory(original) {
+					state.fixed.transfer(ins, op, strings.HasSuffix(string(ins.Op), ".P"), nil)
+				}
+				if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+					if len(ins.Args) == 0 {
+						return false
+					}
+					name, ok := arm64BranchTarget(ins.Args[len(ins.Args)-1])
+					target, local := indices[name]
+					if !ok || !local || !propagate(target, state) {
+						return false
+					}
+					if arm64IsConditionalBranch(op) && !propagate(index+1, state) {
+						return false
+					}
+					terminated = true
+					break
+				}
+			}
+			if !terminated && !propagate(index+1, state) {
+				return false
+			}
+		}
+		queue = queue[:0]
+	}
+	return true
+}
+
+func arm64RawPrivateSourceRET(ins Instr) bool {
+	if ins.Op != OpRET {
+		return false
+	}
+	if len(ins.Args) == 0 {
+		return true
+	}
+	if len(ins.Args) != 1 {
+		return false
+	}
+	arg := ins.Args[0]
+	return arg.Kind == OpReg && arg.Reg == "R30" ||
+		arg.Kind == OpMem && arg.Mem.Base == "R30" && arg.Mem.Index == "" && arg.Mem.Off == 0 && arg.Mem.OffRaw == ""
+}
+
+func (s *arm64RawPrivateFrameState) transfer(original, ins Instr, frameSize int64) bool {
+	op := arm64ControlOp(ins)
+	if immediate, handled, err := parseARM64GPImmediateForm(op, ins); handled {
+		if err != nil {
+			return false
+		}
+		if immediate.scratch && !s.assign("R27", arm64PrivateFrameAddress{}, false) {
+			return false
+		}
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind == OpFPAddr {
+			return false
+		}
+	}
+	if form, handled, err := parseARM64StructureMemory(original); handled {
+		return err == nil && s.structureMemory(form, frameSize)
+	}
+	if op == OpWORD {
+		if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+			return false
+		}
+		effects, known := arm64RawContinuationEffectsForWord(uint32(ins.Args[0].Imm))
+		if !known || effects.stores || effects.readsSP {
+			return false
+		}
+		for reg := range s.regs {
+			index, gp := arm64StackIndex(reg)
+			if !gp || effects.gpReads&(1<<uint(index)) != 0 || effects.gpWrites&(1<<uint(index)) != 0 {
+				return false
+			}
+		}
+		return true
+	}
+	if form, handled, err := parseARM64RegisterAddressForm(op, ins); handled {
+		if err != nil || form.usesScratch {
+			return false
+		}
+		value, present := s.address(form.base)
+		if present {
+			var ok bool
+			value, ok = arm64PrivateFrameOffset(value, form.offset)
+			if !ok {
+				return false
+			}
+		}
+		return s.assign(form.destination, value, present)
+	}
+	if form, ok := arm64RawPrivateMemory(ins); ok {
+		return s.memory(form, frameSize)
+	}
+	if op == "MOVD" && string(ins.Op) == "MOVD" && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		src := ins.Args[0]
+		if src.Kind == OpReg {
+			value, present := s.address(src.Reg)
+			return s.assign(ins.Args[1].Reg, value, present)
+		}
+		if src.Kind == OpImm && src.ImmRaw == "" || src.Kind == OpFP || src.Kind == OpSym && strings.HasSuffix(src.Sym, "(SB)") {
+			return s.assign(ins.Args[1].Reg, arm64PrivateFrameAddress{}, false)
+		}
+	}
+	if (op == "ADD" || op == "SUB") && string(ins.Op) == string(op) && len(ins.Args) >= 2 && len(ins.Args) <= 3 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" && ins.Args[1].Kind == OpReg && ins.Args[len(ins.Args)-1].Kind == OpReg {
+		value, present := s.address(ins.Args[1].Reg)
+		if present {
+			offset := ins.Args[0].Imm
+			if op == "SUB" {
+				if offset == int64(-1<<63) {
+					return false
+				}
+				offset = -offset
+			}
+			var ok bool
+			value, ok = arm64PrivateFrameOffset(value, offset)
+			if !ok {
+				return false
+			}
+		}
+		return s.assign(ins.Args[len(ins.Args)-1].Reg, value, present)
+	}
+	if form, handled, err := parseARM64GPDataForm(op, ins); handled {
+		if err != nil {
+			return false
+		}
+		for _, reg := range arm64GPDataInputRegisters(form) {
+			if _, frame := s.address(reg); frame {
+				return false
+			}
+		}
+		for _, reg := range arm64GPDataOutputRegisters(form) {
+			if !s.assign(reg, arm64PrivateFrameAddress{}, false) {
+				return false
+			}
+		}
+		return true
+	}
+	// No unrecognized transform can kill a may-frame register. Its explicit
+	// operands must not consume an address; native/implicit-effect forms are
+	// excluded even when no temporary happens to be live.
+	switch op {
+	case "DWORD", "BYTE", "QUAD", "SVC", "HVC", "SMC", "BRK", "HLT", "DCPS1", "DCPS2", "DCPS3", "DRPS", "ERET", "UNDEF", "MRS", "MSR", "SYS", "SYSL", "DC", "IC", "TLBI":
+		return false
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(arg.Sym), "$") {
+			if strings.Contains(arg.Sym, "(FP)") {
+				return false
+			}
+			if memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$"))); ok {
+				if _, frame := s.address(memory.Base); frame {
+					return false
+				}
+				if _, frame := s.address(memory.Index); frame {
+					return false
+				}
+			}
+		}
+		regs := []Reg{arg.Reg, arg.ShiftReg, arg.Mem.Base, arg.Mem.Index}
+		regs = append(regs, arg.RegList...)
+		for _, reg := range regs {
+			if _, frame := s.address(reg); frame {
+				return false
+			}
+		}
+		if arg.Kind == OpMem || arg.Kind == OpFP || arg.Kind == OpFPAddr {
+			return false // Unknown memory direction/width is not an external store.
+		}
+	}
+	if original.Op == OpWORD {
+		word := uint32(original.Args[0].Imm)
+		// Validated ordinary data-processing encodings have explicit GP/FP
+		// operands. Other classes need a separately typed effect contract.
+		return word&0x1c000000 == 0x10000000 || word&0x0e000000 == 0x0a000000 || word&0x0e000000 == 0x0e000000
+	}
+	return true
+}
+
+type arm64RawPrivateMemoryForm struct {
+	memory       Operand
+	registers    []Reg
+	elementBytes int64
+	store, gp    bool
+	pre, post    bool
+	scratch      *arm64ScalarMemoryForm
+}
+
+func arm64RawPrivateScalarBytes(op Op) int64 {
+	switch op {
+	case "MOVB", "MOVBU", "MOVBW":
+		return 1
+	case "MOVH", "MOVHU", "MOVHW":
+		return 2
+	case "MOVW", "MOVWU", "FMOVS":
+		return 4
+	case "MOVD", "FMOVD":
+		return 8
+	case "FMOVQ":
+		return 16
+	}
+	return 0
+}
+
+func arm64RawPrivatePairBytes(op Op) int64 {
+	switch op {
+	case "LDPW", "LDPSW", "STPW", "FLDPS", "FSTPS":
+		return 4
+	case "LDP", "STP", "FLDPD", "FSTPD":
+		return 8
+	case "FLDPQ", "FSTPQ":
+		return 16
+	}
+	return 0
+}
+
+func arm64RawPrivateMemory(ins Instr) (arm64RawPrivateMemoryForm, bool) {
+	op := arm64ControlOp(ins)
+	form := arm64RawPrivateMemoryForm{}
+	if scalar, handled, err := parseARM64ScalarMemoryForm(op, ins); handled {
+		if err != nil {
+			return form, false
+		}
+		form.memory, form.registers = scalar.memory, []Reg{scalar.data}
+		form.elementBytes, form.store, form.gp = int64(scalar.bits/8), scalar.store, true
+		form.pre, form.post = scalar.pre, scalar.post
+		if scalar.scratch {
+			form.scratch = &scalar
+		}
+		return form, true
+	}
+	suffix := strings.TrimPrefix(string(ins.Op), string(op))
+	if suffix != "" && suffix != ".W" && suffix != ".P" || len(ins.Args) != 2 {
+		return form, false
+	}
+	form.pre, form.post = suffix == ".W", suffix == ".P"
+	width := arm64RawPrivateScalarBytes(op)
+	if width != 0 {
+		value := ins.Args[1]
+		form.memory = ins.Args[0]
+		if ins.Args[1].Kind == OpMem || ins.Args[1].Kind == OpFP || ins.Args[1].Kind == OpSym {
+			value, form.memory, form.store = ins.Args[0], ins.Args[1], true
+		}
+		form.gp = !strings.HasPrefix(string(op), "F")
+		// Go obj7.progedit's complete zrReplace MOVB/H/W/D family maps
+		// a resolved literal $0 source to ZR, including its unsigned aliases.
+		if form.store && form.gp && value.Kind == OpImm && value.Imm == 0 && value.ImmRaw == "" {
+			value = Operand{Kind: OpReg, Reg: ZR}
+		}
+		if value.Kind != OpReg {
+			return form, false
+		}
+		if form.gp && !isARM64GeneralOrZeroReg(value.Reg) {
+			return form, false
+		}
+		if !form.gp {
+			if _, ok := arm64ParseFReg(value.Reg); !ok {
+				return form, false
+			}
+		}
+		form.elementBytes, form.registers = width, []Reg{value.Reg}
+	} else {
+		width = arm64RawPrivatePairBytes(op)
+		if width == 0 {
+			return form, false
+		}
+		form.store = op == "STP" || op == "STPW" || strings.HasPrefix(string(op), "FSTP")
+		pair := ins.Args[1]
+		form.memory = ins.Args[0]
+		if form.store {
+			pair, form.memory = ins.Args[0], ins.Args[1]
+		}
+		if pair.Kind != OpRegList || len(pair.RegList) != 2 {
+			return form, false
+		}
+		form.gp = !strings.HasPrefix(string(op), "F")
+		for _, reg := range pair.RegList {
+			if form.gp && !isARM64GeneralOrZeroReg(reg) {
+				return form, false
+			}
+			if !form.gp {
+				if _, ok := arm64ParseFReg(reg); !ok {
+					return form, false
+				}
+			}
+		}
+		form.elementBytes, form.registers = width, pair.RegList
+	}
+	if !form.store && len(form.registers) == 2 && form.registers[0] == form.registers[1] {
+		return form, false
+	}
+	// $offset(base) and $symbol(SB) materialize an address, not memory
+	// contents. Their own typed grammar must retain source provenance and
+	// Go's implicit R27 literal scratch effect before any memory transfer.
+	if form.memory.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(form.memory.Sym), "$") {
+		return form, false
+	}
+	if form.pre || form.post {
+		if form.memory.Kind != OpMem || form.memory.Mem.Index != "" || form.memory.Mem.OffRaw != "" {
+			return form, false
+		}
+		// ARM writeback with a transferred GP base register is constrained
+		// unpredictable. Never derive a proof from a guessed update order.
+		if form.gp {
+			for _, reg := range form.registers {
+				if reg == form.memory.Mem.Base {
+					return form, false
+				}
+			}
+		}
+	}
+	return form, form.memory.Kind == OpMem || form.memory.Kind == OpFP || form.memory.Kind == OpSym
+}
+
+func (s *arm64RawPrivateFrameState) memory(form arm64RawPrivateMemoryForm, frameSize int64) bool {
+	address, local := arm64PrivateFrameAddress{}, false
+	if form.memory.Kind == OpMem {
+		mem := form.memory.Mem
+		if _, frame := s.address(mem.Index); frame {
+			return false
+		}
+		address, local = s.address(mem.Base)
+		if local && (!address.exact || mem.Index != "" || mem.OffRaw != "") {
+			return false
+		}
+		if local {
+			offset := mem.Off
+			if form.post {
+				offset = 0
+			}
+			var ok bool
+			address, ok = arm64PrivateFrameOffset(address, offset)
+			low := s.sp
+			if form.pre && mem.Base != "" && arm64StackReg(mem.Base) {
+				low = address.offset
+			}
+			if low > -8 {
+				low = -8 // Go's implicit saved-FP cell, not a general red zone.
+			}
+			width := form.elementBytes * int64(len(form.registers))
+			if !ok || low < -arm64MaxLocalStackSpan || address.offset < low || address.offset > frameSize+8-width {
+				return false
+			}
+		}
+	}
+	if form.scratch != nil {
+		value, frame := s.regs.scalarMemoryScratch(*form.scratch)
+		if !s.assign("R27", value, frame) {
+			return false
+		}
+	}
+	for index, reg := range form.registers {
+		offset := address.offset + int64(index)*form.elementBytes
+		if form.store {
+			value, frame := s.address(reg)
+			if frame && (!local || !form.gp || form.elementBytes != 8) {
+				return false
+			}
+			if local {
+				for cell := range s.spills {
+					if offset < cell+8 && cell < offset+form.elementBytes {
+						if offset > cell || offset+form.elementBytes < cell+8 {
+							return false // A partial overwrite cannot wash a spill clean.
+						}
+						delete(s.spills, cell)
+					}
+				}
+				if frame {
+					s.spills[offset] = value
+				}
+			}
+		} else {
+			value, frame := arm64PrivateFrameAddress{}, false
+			if local {
+				matches := 0
+				for cell, stored := range s.spills {
+					if offset < cell+8 && cell < offset+form.elementBytes {
+						if !form.gp {
+							return false // Do not lose a frame address in the SIMD bank.
+						}
+						matches++
+						value, frame = arm64PrivateFrameAddress{}, true
+						if matches == 1 && cell == offset && form.elementBytes == 8 {
+							value = stored
+						}
+					}
+				}
+			}
+			if form.gp && !s.assign(reg, value, frame) {
+				return false
+			}
+		}
+	}
+	if form.pre || form.post {
+		if form.memory.Kind != OpMem || form.memory.Mem.Index != "" || form.memory.Mem.OffRaw != "" {
+			return false
+		}
+		base := form.memory.Mem.Base
+		value, frame := s.address(base)
+		if frame {
+			var ok bool
+			value, ok = arm64PrivateFrameOffset(value, form.memory.Mem.Off)
+			if !ok || !s.assign(base, value, true) {
+				return false
+			}
+		}
+	}
+	return true
+}
diff --git a/arm64_raw_private_frame_epilogue_test.go b/arm64_raw_private_frame_epilogue_test.go
new file mode 100644
index 000000000..c24178b95
--- /dev/null
+++ b/arm64_raw_private_frame_epilogue_test.go
@@ -0,0 +1,384 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type arm64RawFrameSourceLine struct {
+	line int
+	text string
+}
+
+type arm64RawFrameSourceFunction struct {
+	line int
+	body []arm64RawFrameSourceLine
+}
+
+type arm64RawFrameListingRow struct {
+	pc, line int
+	text     string
+}
+
+type arm64RawFrameListingFunction struct {
+	symbol string
+	size   int
+	text   bool
+	meta   uint8
+	rows   []arm64RawFrameListingRow
+	bytes  []byte
+}
+
+// These are fixture-specific observers, not a frame-permission producer.
+// Each function must retain its own original source positions, explicit raw
+// LR/SP restoration and independently observed Go machine words. There is no
+// version guess: either exact, equivalent obj7 epilogue is accepted.
+func checkARM64RawPrivateFrameGoListing(sourcePath, source, listing string) error {
+	sourceHeader := regexp.MustCompile(`^TEXT ·(rawFrame_[A-Za-z0-9_]+)\(SB\),4,\$120-16$`)
+	wanted := make(map[string]*arm64RawFrameSourceFunction)
+	var currentSource *arm64RawFrameSourceFunction
+	for index, line := range strings.Split(source, "\n") {
+		text := strings.Join(strings.Fields(line), " ")
+		if text == "" {
+			continue
+		}
+		if strings.HasPrefix(text, "TEXT ") {
+			match := sourceHeader.FindStringSubmatch(text)
+			if match == nil || wanted[match[1]] != nil {
+				return fmt.Errorf("unexpected/duplicate original TEXT at line %d", index+1)
+			}
+			currentSource = &arm64RawFrameSourceFunction{line: index + 1}
+			wanted[match[1]] = currentSource
+		} else if currentSource == nil {
+			return fmt.Errorf("original instruction outside TEXT at line %d", index+1)
+		} else {
+			currentSource.body = append(currentSource.body, arm64RawFrameSourceLine{index + 1, text})
+		}
+	}
+	if sourcePath == "" || len(wanted) == 0 || len(listing) > 32<<20 {
+		return fmt.Errorf("empty original functions or overlong Go listing")
+	}
+	header := regexp.MustCompile(`^((?:main|"")\.(rawFrame_[A-Za-z0-9_]+)) STEXT nosplit asm size=([0-9]+) (?:args=0x10 locals=0x88 funcid=0x0 align=0x0|align=0x0 args=0x10 locals=0x88 funcid=0x0) leaf$`)
+	row := regexp.MustCompile(`^\s*0x([0-9a-f]+)\s+([0-9]+)\s+\((.*):([0-9]+)\)\s+(.*)$`)
+	observed := make(map[string]*arm64RawFrameListingFunction)
+	var current *arm64RawFrameListingFunction
+	for _, line := range strings.Split(listing, "\n") {
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		if match := header.FindStringSubmatch(line); match != nil {
+			if wanted[match[2]] == nil || observed[match[2]] != nil {
+				return fmt.Errorf("unexpected/duplicate Go function %s", match[2])
+			}
+			size, err := strconv.Atoi(match[3])
+			if err != nil || size < 56 || size > 1<<20 || size%16 != 0 {
+				return fmt.Errorf("unexpected object size for %s", match[2])
+			}
+			current = &arm64RawFrameListingFunction{symbol: match[1], size: size}
+			observed[match[2]] = current
+			continue
+		}
+		if current == nil {
+			return fmt.Errorf("Go output outside an expected STEXT: %q", line)
+		}
+		if match := row.FindStringSubmatch(line); match != nil {
+			pc, pcErr := strconv.ParseUint(match[1], 16, 32)
+			decimalPC, decimalErr := strconv.ParseUint(match[2], 10, 32)
+			sourceLine, lineErr := strconv.Atoi(match[4])
+			if pcErr != nil || decimalErr != nil || pc != decimalPC || lineErr != nil || match[3] != sourcePath {
+				return fmt.Errorf("Go instruction has mismatched original location/PC: %q", line)
+			}
+			text := strings.Join(strings.Fields(match[5]), " ")
+			name := strings.TrimPrefix(strings.TrimPrefix(current.symbol, "main."), `"".`)
+			original := wanted[name]
+			if strings.HasPrefix(text, "TEXT ") {
+				if current.text || pc != 0 || sourceLine != original.line || len(current.rows) != 0 || text != "TEXT "+current.symbol+"(SB), NOSPLIT|LEAF, $144-16" {
+					return fmt.Errorf("unexpected generated TEXT for %s", name)
+				}
+				current.text = true
+				continue
+			}
+			if strings.HasPrefix(text, "FUNCDATA ") {
+				if !current.text || sourceLine != original.line || pc != 12 || len(current.rows) != 3 ||
+					(text != "FUNCDATA $5, "+current.symbol+".arginfo0(SB)" && text != "FUNCDATA $0, "+current.symbol+".args_stackmap(SB)") {
+					return fmt.Errorf("unexpected generated metadata for %s", name)
+				}
+				bit := uint8(1)
+				if strings.HasPrefix(text, "FUNCDATA $0,") {
+					bit = 2
+				}
+				if current.meta&bit != 0 {
+					return fmt.Errorf("duplicate generated metadata for %s", name)
+				}
+				current.meta |= bit
+				continue
+			}
+			if !current.text || len(current.bytes) != 0 || int(pc) != 4*len(current.rows) {
+				return fmt.Errorf("noncontiguous Go instruction rows for %s", name)
+			}
+			current.rows = append(current.rows, arm64RawFrameListingRow{int(pc), sourceLine, text})
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) < 17 || !strings.HasPrefix(fields[0], "0x") {
+			return fmt.Errorf("unexpected Go listing syntax: %q", line)
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		if err != nil || int(offset) != len(current.bytes) || len(current.bytes)+16 > current.size {
+			return fmt.Errorf("noncontiguous/overlong Go object dump for %s", current.symbol)
+		}
+		for _, token := range fields[1:17] {
+			b, err := strconv.ParseUint(token, 16, 8)
+			if err != nil || len(token) != 2 {
+				return fmt.Errorf("invalid Go object byte %q", token)
+			}
+			current.bytes = append(current.bytes, byte(b))
+		}
+	}
+	if len(observed) != len(wanted) {
+		return fmt.Errorf("Go listing omits original functions: %d != %d", len(observed), len(wanted))
+	}
+	for name, original := range wanted {
+		if err := checkARM64RawFrameFunction(original, observed[name]); err != nil {
+			return fmt.Errorf("%s: %w", name, err)
+		}
+	}
+	return nil
+}
+
+func checkARM64RawFrameFunction(source *arm64RawFrameSourceFunction, object *arm64RawFrameListingFunction) error {
+	if len(source.body) < 8 || source.body[0].text != "MOVD in+0(FP),R0" ||
+		source.body[1].text != "MOVD out+8(FP),R1" ||
+		source.body[2].text != "WORD $0xa9ba6ffc" || source.body[3].text != "WORD $0xa9057bfd" ||
+		source.body[4].text != "WORD $0x910143fd" {
+		return fmt.Errorf("original framed leaf prefix changed")
+	}
+	n := len(source.body)
+	if source.body[n-3].text != "WORD $0xa9457bfd" || source.body[n-2].text != "WORD $0xa8c66ffc" || source.body[n-1].text != "RET" {
+		return fmt.Errorf("original LR/SP restore and RET changed")
+	}
+	if object == nil || !object.text || object.meta != 3 || len(object.rows) < 11 || len(object.bytes) != object.size || 4*len(object.rows) > object.size {
+		return fmt.Errorf("partial original Go object/listing")
+	}
+	check := func(index, line int, text string, word uint32) bool {
+		r := object.rows[index]
+		return r.line == line && r.text == text && binary.LittleEndian.Uint32(object.bytes[r.pc:r.pc+4]) == word
+	}
+	if !check(0, source.line, "MOVD.W R30, -144(RSP)", 0xf8170ffe) ||
+		!check(1, source.line, "MOVD R29, -8(RSP)", 0xf81f83fd) ||
+		!check(2, source.line, "SUB $8, RSP, R29", 0xd10023fd) {
+		return fmt.Errorf("original Go prologue bytes/source contract changed")
+	}
+	// Every source WORD must have exactly one matching original line and byte
+	// sequence; a correct spill in another function cannot discharge this one.
+	words := make(map[int]uint32)
+	for _, line := range source.body[:n-1] {
+		if line.text == "RET" {
+			return fmt.Errorf("unexpected original RET")
+		}
+		if strings.HasPrefix(line.text, "WORD ") {
+			value, err := strconv.ParseUint(strings.TrimPrefix(line.text, "WORD $"), 0, 32)
+			if err != nil {
+				return fmt.Errorf("invalid original WORD")
+			}
+			words[line.line] = uint32(value)
+		}
+	}
+	end := len(object.rows) - 3
+	for _, r := range object.rows[3:end] {
+		if r.line <= source.line || r.line >= source.body[n-1].line {
+			return fmt.Errorf("body row outside original function")
+		}
+		if strings.HasPrefix(r.text, "WORD ") {
+			word, ok := words[r.line]
+			if !ok || r.text != fmt.Sprintf("WORD $%d", word) || binary.LittleEndian.Uint32(object.bytes[r.pc:r.pc+4]) != word {
+				return fmt.Errorf("original WORD line/bytes changed")
+			}
+			delete(words, r.line)
+		}
+	}
+	if len(words) != 0 ||
+		!check(end-2, source.body[n-3].line, "WORD $2839903229", 0xa9457bfd) ||
+		!check(end-1, source.body[n-2].line, "WORD $2831577084", 0xa8c66ffc) {
+		return fmt.Errorf("explicit original LR/SP restore missing before epilogue")
+	}
+	retLine := source.body[n-1].line
+	// Both finish at entry SP and entry-SP-8 in R29. Neither reloads R30:
+	// restoration of the caller LR must still come from the raw source above.
+	old := check(end, retLine, "ADD $144, RSP", 0x910243ff) &&
+		check(end+1, retLine, "SUB $8, RSP, R29", 0xd10023fd)
+	current := check(end, retLine, "ADD $136, RSP, R29", 0x910223fd) &&
+		check(end+1, retLine, "ADD $144, RSP", 0x910243ff)
+	if (!old && !current) || !check(end+2, retLine, "RET (R30)", 0xd65f03c0) {
+		return fmt.Errorf("original Go epilogue order/SP/FP/LR/bytes changed")
+	}
+	for _, b := range object.bytes[4*len(object.rows):] {
+		if b != 0 {
+			return fmt.Errorf("unexpected code after original RET")
+		}
+	}
+	return nil
+}
+
+// The source positions and machine words are from the two independently
+// assembled Go1.20/Go1.27 probe objects, not from the listing checker.
+func arm64RawFrameListingFixture(styles ...bool) (sourcePath, source, listing string) {
+	sourcePath = "/fixture/oracle_arm64.s"
+	var src, out strings.Builder
+	for index, current := range styles {
+		name := fmt.Sprintf("rawFrame_%d", index)
+		prefix := `"".`
+		if current {
+			prefix = "main."
+		}
+		symbol := prefix + name
+		fmt.Fprintf(&src, `TEXT ·%s(SB),4,$120-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xa9ba6ffc
+WORD $0xa9057bfd
+WORD $0x910143fd
+MOVD R0,(R1)
+WORD $0xa9457bfd
+WORD $0xa8c66ffc
+RET
+`, name)
+		attributes := "args=0x10 locals=0x88 funcid=0x0 align=0x0"
+		if current {
+			attributes = "align=0x0 args=0x10 locals=0x88 funcid=0x0"
+		}
+		fmt.Fprintf(&out, "%s STEXT nosplit asm size=64 %s leaf\n", symbol, attributes)
+		line := index*10 + 1
+		row := func(pc, sourceLine int, op string) {
+			fmt.Fprintf(&out, "\t0x%04x %05d (%s:%d)\t%s\n", pc, pc, sourcePath, sourceLine, op)
+		}
+		row(0, line, "TEXT\t"+symbol+"(SB), NOSPLIT|LEAF, $144-16")
+		row(0, line, "MOVD.W\tR30, -144(RSP)")
+		row(4, line, "MOVD\tR29, -8(RSP)")
+		row(8, line, "SUB\t$8, RSP, R29")
+		row(12, line, "FUNCDATA\t$5, "+symbol+".arginfo0(SB)")
+		row(12, line, "FUNCDATA\t$0, "+symbol+".args_stackmap(SB)")
+		row(12, line+1, "MOVD\tin(FP), R0")
+		row(16, line+2, "MOVD\tout+8(FP), R1")
+		row(20, line+3, "WORD\t$2847567868")
+		row(24, line+4, "WORD\t$2835708925")
+		row(28, line+5, "WORD\t$2432779261")
+		row(32, line+6, "MOVD\tR0, (R1)")
+		row(36, line+7, "WORD\t$2839903229")
+		row(40, line+8, "WORD\t$2831577084")
+		epilogue := []uint32{0x910243ff, 0xd10023fd, 0xd65f03c0}
+		if current {
+			row(44, line+9, "ADD\t$136, RSP, R29")
+			row(48, line+9, "ADD\t$144, RSP")
+			epilogue = []uint32{0x910223fd, 0x910243ff, 0xd65f03c0}
+		} else {
+			row(44, line+9, "ADD\t$144, RSP")
+			row(48, line+9, "SUB\t$8, RSP, R29")
+		}
+		row(52, line+9, "RET\t(R30)")
+		words := []uint32{
+			0xf8170ffe, 0xf81f83fd, 0xd10023fd, 0xf9404fe0,
+			0xf94053e1, 0xa9ba6ffc, 0xa9057bfd, 0x910143fd,
+			0xf9000020, 0xa9457bfd, 0xa8c66ffc,
+		}
+		words = append(words, epilogue...)
+		words = append(words, 0, 0)
+		bytes := make([]byte, 4*len(words))
+		for i, word := range words {
+			binary.LittleEndian.PutUint32(bytes[4*i:], word)
+		}
+		for offset := 0; offset < len(bytes); offset += 16 {
+			fmt.Fprintf(&out, "\t0x%04x", offset)
+			for _, b := range bytes[offset : offset+16] {
+				fmt.Fprintf(&out, " %02x", b)
+			}
+			out.WriteString("  ................\n")
+		}
+	}
+	return sourcePath, src.String(), out.String()
+}
+
+func TestARM64RawPrivateFrameGoEpiloguePerFunction(t *testing.T) {
+	for _, tc := range []struct {
+		name   string
+		styles []bool
+	}{
+		{"go120", []bool{false}},
+		{"go127", []bool{true}},
+		{"both_independent", []bool{false, true}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			path, source, listing := arm64RawFrameListingFixture(tc.styles...)
+			if err := checkARM64RawPrivateFrameGoListing(path, source, listing); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestARM64RawPrivateFrameGoEpilogueRejectsBrokenIdentity(t *testing.T) {
+	for _, tc := range []struct {
+		name       string
+		sourceOld  string
+		sourceNew  string
+		listingOld string
+		listingNew string
+	}{
+		{name: "missing_old_sp", listingOld: "ADD\t$144, RSP", listingNew: "NOP"},
+		{name: "reversed_old_sp_fp", listingOld: "ADD\t$144, RSP", listingNew: "SUB\t$8, RSP, R29"},
+		{name: "wrong_sp_delta", listingOld: "ADD\t$144, RSP", listingNew: "ADD\t$143, RSP"},
+		{name: "wrong_old_fp", listingOld: "0x0030 00048 (/fixture/oracle_arm64.s:10)\tSUB\t$8, RSP, R29", listingNew: "0x0030 00048 (/fixture/oracle_arm64.s:10)\tSUB\t$16, RSP, R29"},
+		{name: "wrong_current_fp", listingOld: "ADD\t$136, RSP, R29", listingNew: "ADD\t$128, RSP, R29"},
+		{name: "wrong_sp_register", listingOld: "ADD\t$144, RSP", listingNew: "ADD\t$144, R28"},
+		{name: "wrong_lr_ret", listingOld: "RET\t(R30)", listingNew: "RET\t(R29)"},
+		{name: "missing_raw_lr_restore", listingOld: "WORD\t$2839903229", listingNew: "WORD\t$2839903228"},
+		{name: "missing_raw_sp_restore", listingOld: "WORD\t$2831577084", listingNew: "WORD\t$2831577085"},
+		{name: "wrong_prologue_lr", listingOld: "MOVD.W\tR30, -144(RSP)", listingNew: "MOVD.W\tR29, -144(RSP)"},
+		{name: "wrong_prologue_frame", listingOld: "MOVD.W\tR30, -144(RSP)", listingNew: "MOVD.W\tR30, -128(RSP)"},
+		{name: "wrong_listing_frame", listingOld: "$144-16", listingNew: "$128-16"},
+		{name: "wrong_listing_locals", listingOld: "locals=0x88", listingNew: "locals=0x90"},
+		{name: "wrong_source_frame", sourceOld: "$120-16", sourceNew: "$128-16"},
+		{name: "wrong_original_lr", sourceOld: "WORD $0xa9457bfd", sourceNew: "WORD $0xa9457bfc"},
+		{name: "wrong_original_ret", sourceOld: "\nRET\n", sourceNew: "\nWORD $0xd65f03c0\n"},
+		{name: "foreign_path", listingOld: "/fixture/oracle_arm64.s:8", listingNew: "/foreign/oracle_arm64.s:8"},
+		{name: "foreign_line", listingOld: "/fixture/oracle_arm64.s:8", listingNew: "/fixture/oracle_arm64.s:9"},
+		{name: "wrong_decimal_pc", listingOld: "0x002c 00044", listingNew: "0x002c 00040"},
+		{name: "wrong_prologue_bytes", listingOld: "fe 0f 17 f8", listingNew: "ff 0f 17 f8"},
+		{name: "wrong_ret_bytes", listingOld: "c0 03 5f d6", listingNew: "a0 03 5f d6"},
+		{name: "nonzero_ret_padding", listingOld: "c0 03 5f d6 00 00 00 00", listingNew: "c0 03 5f d6 01 00 00 00"},
+		{name: "missing_text", listingOld: "TEXT\t\"\".rawFrame_0(SB), NOSPLIT|LEAF, $144-16", listingNew: "FUNCDATA\t$5, \"\".rawFrame_0.arginfo0(SB)"},
+		{name: "duplicate_metadata", listingOld: "FUNCDATA\t$0, \"\".rawFrame_0.args_stackmap(SB)", listingNew: "FUNCDATA\t$5, \"\".rawFrame_0.arginfo0(SB)"},
+		{name: "borrowed_function", listingOld: `"".rawFrame_0 STEXT`, listingNew: `"".rawFrame_other STEXT`},
+		{name: "duplicate_function", listingOld: "main.rawFrame_1", listingNew: `"".rawFrame_0`},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			path, source, listing := arm64RawFrameListingFixture(false, true)
+			if tc.sourceOld != "" {
+				source = strings.Replace(source, tc.sourceOld, tc.sourceNew, 1)
+			}
+			if tc.listingOld != "" {
+				listing = strings.Replace(listing, tc.listingOld, tc.listingNew, 1)
+			}
+			if err := checkARM64RawPrivateFrameGoListing(path, source, listing); err == nil {
+				t.Fatal("broken per-function source/epilogue/object contract accepted")
+			}
+		})
+	}
+	path, source, listing := arm64RawFrameListingFixture(false, true)
+	for _, tc := range []struct{ name, listing string }{
+		{"missing_function", strings.Split(listing, "main.rawFrame_1 STEXT")[0]},
+		{"missing_dump", strings.Split(listing, "\t0x0030 fd 23 00 d1")[0]},
+		{"missing_epilogue_row", strings.Replace(listing, "\t0x002c 00044 (/fixture/oracle_arm64.s:10)\tADD\t$144, RSP\n", "", 1)},
+		{"duplicate_text_row", strings.Replace(listing, "\t0x0000 00000 (/fixture/oracle_arm64.s:1)\tTEXT", "\t0x0000 00000 (/fixture/oracle_arm64.s:1)\tTEXT\t\"\".rawFrame_0(SB), NOSPLIT|LEAF, $144-16\n\t0x0000 00000 (/fixture/oracle_arm64.s:1)\tTEXT", 1)},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if err := checkARM64RawPrivateFrameGoListing(path, source, tc.listing); err == nil {
+				t.Fatal("incomplete/duplicate per-function source/object contract accepted")
+			}
+		})
+	}
+}
diff --git a/arm64_raw_private_frame_family_test.go b/arm64_raw_private_frame_family_test.go
new file mode 100644
index 000000000..1690c1be3
--- /dev/null
+++ b/arm64_raw_private_frame_family_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawPrivateMemoryCase struct {
+	name, store, load string
+	width, count      int
+	signBits          int // 0 unsigned, 32 sign-extend to W, 64 sign-extend to X
+	floating          bool
+}
+
+func arm64RawPrivateMemoryCases() []arm64RawPrivateMemoryCase {
+	var cases []arm64RawPrivateMemoryCase
+	for _, shape := range []struct {
+		name, store, load string
+		width, count      int
+		signBits          int
+		floating          bool
+	}{
+		{name: "byte", store: "strb w4", load: "ldrb w9", width: 1, count: 1},
+		{name: "signed_byte_x", store: "strb w4", load: "ldrsb x9", width: 1, count: 1, signBits: 64},
+		{name: "signed_byte_w", store: "strb w4", load: "ldrsb w9", width: 1, count: 1, signBits: 32},
+		{name: "half", store: "strh w4", load: "ldrh w9", width: 2, count: 1},
+		{name: "signed_half_x", store: "strh w4", load: "ldrsh x9", width: 2, count: 1, signBits: 64},
+		{name: "signed_half_w", store: "strh w4", load: "ldrsh w9", width: 2, count: 1, signBits: 32},
+		{name: "word", store: "str w4", load: "ldr w9", width: 4, count: 1},
+		{name: "signed_word", store: "str w4", load: "ldrsw x9", width: 4, count: 1, signBits: 64},
+		{name: "double", store: "str x4", load: "ldr x9", width: 8, count: 1},
+		{name: "fp_s", store: "str s0", load: "ldr s2", width: 4, count: 1, floating: true},
+		{name: "fp_d", store: "str d0", load: "ldr d2", width: 8, count: 1, floating: true},
+		{name: "fp_q", store: "str q0", load: "ldr q2", width: 16, count: 1, floating: true},
+		{name: "pair_x", store: "stp x4,x5", load: "ldp x9,x10", width: 8, count: 2},
+		{name: "pair_w", store: "stp w4,w5", load: "ldp w9,w10", width: 4, count: 2},
+		{name: "pair_sw", store: "stp w4,w5", load: "ldpsw x9,x10", width: 4, count: 2, signBits: 64},
+		{name: "fp_pair_s", store: "stp s0,s1", load: "ldp s2,s3", width: 4, count: 2, floating: true},
+		{name: "fp_pair_d", store: "stp d0,d1", load: "ldp d2,d3", width: 8, count: 2, floating: true},
+		{name: "fp_pair_q", store: "stp q0,q1", load: "ldp q2,q3", width: 16, count: 2, floating: true},
+	} {
+		for _, mode := range []string{"offset", "pre_post", "post_pre", "unscaled"} {
+			if mode == "unscaled" && shape.count != 1 {
+				continue // Pair encodings have no unscaled-address sibling.
+			}
+			store, load := shape.store+",[sp,#16]", shape.load+",[sp,#16]"
+			if mode == "pre_post" {
+				store, load = shape.store+",[sp,#-32]!", shape.load+",[sp],#32"
+			}
+			if mode == "post_pre" {
+				store, load = shape.store+",[sp],#32", shape.load+",[sp,#-32]!"
+			}
+			if mode == "unscaled" {
+				store = strings.Replace(shape.store, "str", "stur", 1) + ",[sp,#9]"
+				load = strings.Replace(shape.load, "ldr", "ldur", 1) + ",[sp,#9]"
+			}
+			cases = append(cases, arm64RawPrivateMemoryCase{
+				name: "rawFrame_" + shape.name + "_" + mode, store: store, load: load,
+				width: shape.width, count: shape.count, signBits: shape.signBits, floating: shape.floating,
+			})
+		}
+	}
+	return cases
+}
+
+// LLVM MC independently assembles each native memory spelling. Actual Go then
+// assembles every raw WORD and its framed source epilogue. Each recovered form
+// still goes through the regular width/sign/register-aware semantic lowerer.
+func arm64RawPrivateFamilyFixture(t *testing.T) (*File, map[string]FuncSig, string, []arm64RawPrivateMemoryCase) {
+	t.Helper()
+	cases := arm64RawPrivateMemoryCases()
+	var lines []string
+	for _, tc := range cases {
+		lines = append(lines, tc.store, tc.load)
+	}
+	words := assembleARM64LLVMWords(t, lines, "")
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, tc := range cases {
+		prep := "MOVD (R0),R4\nMOVD 8(R0),R5\n"
+		outputs := "MOVD R9,(R1)\n"
+		if tc.count == 2 {
+			outputs += "MOVD R10,8(R1)\n"
+		}
+		if tc.floating {
+			prep = "FMOVQ (R0),F0\nFMOVQ 16(R0),F1\n"
+			op := map[int]string{4: "FMOVS", 8: "FMOVD", 16: "FMOVQ"}[tc.width]
+			outputs = op + " F2,(R1)\n"
+			if tc.count == 2 {
+				outputs += fmt.Sprintf("%s F3,%d(R1)\n", op, tc.width)
+			}
+		}
+		// Keep tested stores below, rather than on top of, the original
+		// R28/R27 spill. In particular a post-index store at SP must not
+		// corrupt the real Go g register when the spill is later restored.
+		body := "WORD $0xd10103ff\n" + prep +
+			fmt.Sprintf("WORD $%#08x\nWORD $%#08x\n", words[2*index], words[2*index+1]) +
+			outputs + "WORD $0x910103ff\n"
+		// Do not overwrite the observed output with the fixture's pointer copy.
+		fixture := arm64RawPrivateFrameFixture(tc.name, body)
+		fixture = strings.Replace(fixture, "MOVD R0,(R1)\nWORD $0xa9457bfd", "WORD $0xa9457bfd", 1)
+		source.WriteString(fixture)
+		sigs[tc.name] = arm64RawPrivateFrameSignature(tc.name)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		if !arm64CallFrameUnexposed(fn) {
+			for _, ins := range fn.Instrs {
+				t.Logf("source %s -> decoded %s", ins.Raw, arm64ControlDecode(ins).Raw)
+			}
+			t.Fatalf("typed raw store/read lost its bounded private-frame proof: %s", fn.Sym)
+		}
+	}
+	return file, sigs, source.String(), cases
+}
+
+func TestARM64RawPrivateFrameMemoryFamilyObjects(t *testing.T) {
+	file, sigs, _, cases := arm64RawPrivateFamilyFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw_frame_family.ll", "raw_frame_family.o", ir)
+		})
+	}
+	t.Logf("actual Go + LLVM22 objects: %d raw scalar/GP-pair/FP-pair width/sign/offset/writeback variants", len(cases))
+}
+
+func TestARM64RawLDPSWPreservesCompletePairAddressGrammar(t *testing.T) {
+	for _, tc := range []struct{ native, plan9 string }{
+		{"ldpsw x9,x10,[sp,#16]", "LDPSW"},
+		{"ldpsw x9,x10,[sp,#-32]!", "LDPSW.W"},
+		{"ldpsw x9,x10,[sp],#32", "LDPSW.P"},
+	} {
+		word := assembleARM64LLVMWords(t, []string{tc.native}, "")[0]
+		ins, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ins.Op != Op(tc.plan9) || len(ins.Args) != 2 || ins.Args[1].Kind != OpRegList ||
+			len(ins.Args[1].RegList) != 2 || ins.Args[1].RegList[0] != "R9" || ins.Args[1].RegList[1] != "R10" {
+			t.Fatalf("LDPSW width/order/writeback changed: %s: %+v", tc.native, ins)
+		}
+	}
+}
+
+func TestARM64RawPrivateFrameMemoryGrammarRejectsUncertainEffects(t *testing.T) {
+	for _, tc := range []struct {
+		native      string
+		mask, value uint32
+	}{
+		// LLVM rejects constrained-unpredictable source spellings. Change only
+		// their encoded Rn or Rt2 field from a legal independent MC object.
+		{native: "ldr x9,[x11],#8", mask: 31 << 5, value: 9 << 5},
+		{native: "ldp x9,x10,[x11],#16", mask: 31 << 5, value: 9 << 5},
+		{native: "str x9,[x11,#-8]!", mask: 31 << 5, value: 9 << 5},
+		{native: "stp x9,x10,[x11,#-16]!", mask: 31 << 5, value: 9 << 5},
+		{native: "ldp x9,x10,[sp,#16]", mask: 31 << 10, value: 9 << 10},
+		{native: "ldp d0,d1,[sp,#16]", mask: 31 << 10},
+		{native: "ldnp x9,x10,[sp,#16]"}, // No Go named non-temporal pair optab.
+		{native: "stnp x9,x10,[sp,#16]"},
+		{native: "ldr x9,[sp,x0]"},
+		{native: "str x9,[sp,x0]"},
+	} {
+		word := assembleARM64LLVMWords(t, []string{tc.native}, "")[0]
+		word = word&^tc.mask | tc.value
+		source := arm64RawPrivateFrameFixture("rawUncertainMemory", fmt.Sprintf("ADD $16,RSP,R9\nWORD $%#08x\nMOVD $0,R9", word))
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("unproven raw memory grammar acquired a private frame: %s masked %#08x", tc.native, word)
+		}
+	}
+}
diff --git a/arm64_raw_private_frame_runtime_test.go b/arm64_raw_private_frame_runtime_test.go
new file mode 100644
index 000000000..973496966
--- /dev/null
+++ b/arm64_raw_private_frame_runtime_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64RawPrivateFrameFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	file, sigs, source, cases := arm64RawPrivateFamilyFixture(t)
+	var goDeclarations, goChecks, cDeclarations, cChecks strings.Builder
+	for _, tc := range cases {
+		fmt.Fprintf(&goDeclarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const unsigned char *,unsigned char *);\n", tc.name)
+		floating := 0
+		if tc.floating {
+			floating = 1
+		}
+		fmt.Fprintf(&goChecks, "check(%s,%d,%d,%d,%d)\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+		fmt.Fprintf(&cChecks, "if(check(%s,%d,%d,%d,%d)) return 1;\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+	}
+	dir := t.TempDir()
+	goSource := strings.ReplaceAll(source, "TEXT rawFrame_", "TEXT ·rawFrame_")
+	for name, body := range map[string]string{
+		"go.mod": "module rawframeoracle\n\ngo 1.20\n",
+		"main.go": arm64RawPrivateFrameOracleGo + goDeclarations.String() +
+			"func main(){\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": goSource,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	// Actual Go obj7 prologue/epilogue is part of the RET proof. This is a
+	// framed leaf: Go rewrites R29, restores physical SP, and does not reload
+	// R30. Therefore the explicit raw LR spill/reload remains mandatory.
+	cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "main", "-o", filepath.Join(dir, "oracle.o"), filepath.Join(dir, "oracle_arm64.s"))
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	listing, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil {
+		t.Fatalf("actual Go framed raw source object: %v\n%s", err, listing)
+	}
+	if err := checkARM64RawPrivateFrameGoListing(filepath.Join(dir, "oracle_arm64.s"), goSource, string(listing)); err != nil {
+		t.Fatalf("actual Go framed-leaf source/object contract: %v\n%s", err, listing)
+	}
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd = exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go raw private-frame caller oracle: %v\n%s", err, output)
+	}
+	t.Logf("actual Go original raw frame/leaf epilogue: %d variants x 256 patterns x 5 unaligned offsets, full input/output canaries", len(cases))
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := arm64RawPrivateFrameOracleC + cDeclarations.String() + "int main(void){\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "raw_private_frame_family", triple, ir, cMain, runner)
+	t.Logf("LLVM22 typed caller / independent C: same %d memory variants, %d total cases", len(cases), len(cases)*256*5)
+}
+
+const arm64RawPrivateFrameOracleGo = `package main
+
+import "encoding/binary"
+
+func check(fn func(*byte, *byte), width, count, signBits, floating int) {
+	var input [96]byte
+	var output, want [96]byte
+	seed := uint32(0x12345678)
+	for trial := 0; trial < 256; trial++ {
+		for _, offset := range []int{0, 1, 3, 7, 17} {
+			for i := range input {
+				seed = seed*1664525 + 1013904223
+				input[i] = byte(seed >> 24)
+				if trial == 0 {
+					input[i] = 0
+				}
+				if trial == 1 {
+					input[i] = 255
+				}
+				if trial >= 2 && trial < 34 {
+					input[i] = 0
+					if i == offset+(trial-2)/8 {
+						input[i] = 1 << uint((trial-2)%8)
+					}
+				}
+			}
+			snapshot := input
+			for i := range output {
+				output[i] = 0xa5
+				want[i] = 0xa5
+			}
+			for i := 0; i < count; i++ {
+				if floating != 0 {
+					copy(want[offset+i*width:offset+(i+1)*width], input[offset+i*16:offset+i*16+width])
+					continue
+				}
+				var value uint64
+				for j := 0; j < width; j++ {
+					value |= uint64(input[offset+i*8+j]) << uint(8*j)
+				}
+				if signBits != 0 && width < 8 && value>>(uint(width*8)-1) != 0 {
+					value |= ^uint64(0) << uint(width*8)
+				}
+				if signBits == 32 {
+					value = uint64(uint32(value))
+				}
+				binary.LittleEndian.PutUint64(want[offset+i*8:], value)
+			}
+			fn(&input[offset], &output[offset])
+			if input != snapshot || output != want {
+				println(width, count, signBits, floating, trial, offset)
+				panic("Go raw frame/caller/memory/canary mismatch")
+			}
+		}
+	}
+}
+`
+
+const arm64RawPrivateFrameOracleC = `
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+static int check(void (*fn)(const unsigned char *, unsigned char *), unsigned width,
+                 unsigned count, unsigned sign_bits, int floating) {
+  unsigned char input[96], snapshot[96], output[96], want[96];
+  uint32_t seed = UINT32_C(0x12345678);
+  const unsigned offsets[] = {0, 1, 3, 7, 17};
+  for (unsigned trial = 0; trial < 256; trial++)
+    for (unsigned o = 0; o < 5; o++) {
+      unsigned offset = offsets[o];
+      for (unsigned i = 0; i < 96; i++) {
+        seed = seed * UINT32_C(1664525) + UINT32_C(1013904223);
+        input[i] = (unsigned char)(seed >> 24);
+        if (trial == 0)
+          input[i] = 0;
+        if (trial == 1)
+          input[i] = 255;
+        if (trial >= 2 && trial < 34)
+          input[i] = i == offset + (trial - 2) / 8
+                         ? (unsigned char)(1U << ((trial - 2) % 8))
+                         : 0;
+      }
+      memcpy(snapshot, input, 96);
+      memset(output, 0xa5, 96);
+      memset(want, 0xa5, 96);
+      for (unsigned i = 0; i < count; i++) {
+        if (floating) {
+          memcpy(want + offset + i * width, input + offset + i * 16, width);
+          continue;
+        }
+        uint64_t value = 0;
+        for (unsigned j = 0; j < width; j++)
+          value |= (uint64_t)input[offset + i * 8 + j] << (8 * j);
+        if (sign_bits && width < 8 && (value >> (width * 8 - 1)))
+          value |= UINT64_MAX << (width * 8);
+        if (sign_bits == 32)
+          value = (uint32_t)value;
+        for (unsigned j = 0; j < 8; j++)
+          want[offset + i * 8 + j] = (unsigned char)(value >> (8 * j));
+      }
+      fn(input + offset, output + offset);
+      if (memcmp(input, snapshot, 96) || memcmp(output, want, 96)) {
+        fprintf(stderr,
+                "raw frame width/count/sign/FP/trial/offset %u/%u/%u/%d/%u/%u\n", width,
+                count, sign_bits, floating, trial, offset);
+        return 1;
+      }
+    }
+  return 0;
+}
+`
diff --git a/arm64_raw_private_frame_test.go b/arm64_raw_private_frame_test.go
new file mode 100644
index 000000000..a269b4651
--- /dev/null
+++ b/arm64_raw_private_frame_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawPrivateFrameOriginalPairedSpill(t *testing.T) {
+	// Original krypto encKeySetup: a raw 96-byte private spill frame nested
+	// below the Go-generated frame, exact LR spill/reload and balanced SP.
+	const source = `TEXT rawPrivateSpill(SB),4,$120-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xa9ba6ffc
+WORD $0xa9057bfd
+WORD $0x910143fd
+MOVD R0,(R1)
+WORD $0xa9457bfd
+WORD $0xa8c66ffc
+RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	sig := FuncSig{
+		Name: "rawPrivateSpill", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}},
+	}
+	for _, triple := range arm64TypedNativeTargets {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawPrivateSpill": sig}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "@rawPrivateSpill(") {
+				t.Fatal("typed raw spill function was not emitted")
+			}
+			compileLLVMToObject(t, llc, triple, "raw-private-frame.ll", "raw-private-frame.o", ir)
+		})
+	}
+}
+
+func arm64RawPrivateFrameFixture(name, body string) string {
+	return fmt.Sprintf(`TEXT %s(SB),4,$120-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xa9ba6ffc
+WORD $0xa9057bfd
+WORD $0x910143fd
+%s
+MOVD R0,(R1)
+WORD $0xa9457bfd
+WORD $0xa8c66ffc
+RET
+`, name, body)
+}
+
+func arm64RawPrivateFrameSignature(name string) FuncSig {
+	return FuncSig{
+		Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}},
+	}
+}
+
+func TestARM64RawPrivateFrameSourceProofFailClosed(t *testing.T) {
+	for _, tc := range []struct {
+		name, body string
+	}{
+		{"external_store", "MOVD R29,(R1)"},
+		{"symbol_store", "MOVD R29,holder(SB)"},
+		{"incoming_argument_store", "MOVD R29,in+0(FP)"},
+		{"alias_store", "MOVD R29,R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"literal_frame_address_store", "MOVD $16(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"frame_result", "MOVD R29,R0"},
+		{"frame_temporary_at_ret", "MOVD R29,R9"},
+		{"frame_address_spill_restore_escape", "MOVD R29,16(RSP)\nMOVD 16(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"saved_unknown_fp_escape", "MOVD 80(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"partial_scalar_spill_overlap", "MOVB R0,81(RSP)"},
+		{"partial_pair_spill_overlap", "STPW (R0,R1),84(RSP)"},
+		{"partial_fp_spill_overlap", "FSTPS (F0,F1),84(RSP)"},
+		{"fp_read_of_pointer_spill", "FMOVD 80(RSP),F0"},
+		{"narrow_pointer_read_then_escape", "MOVWU 80(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"mixed_external_frame_join", "CBZ R0,other\nMOVD R29,R9\nB joined\nother:\nMOVD R0,R9\njoined:\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"mixed_offset_join", "CBZ R0,other\nADD $16,RSP,R9\nB joined\nother:\nADD $24,RSP,R9\njoined:\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"mixed_spill_join", "CBZ R0,other\nMOVD R29,16(RSP)\nB joined\nother:\nMOVD R0,16(RSP)\njoined:\nMOVD 16(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"sp_delta_join", "CBZ R0,joined\nSUB $16,RSP\njoined:\nMOVD $0,R9"},
+		{"sp_multi_delta_join", "CBZ R0,other\nSUB $16,RSP\nB joined\nother:\nSUB $32,RSP\njoined:\nADD $16,RSP"},
+		{"unbalanced_pop", "ADD $16,RSP"},
+		{"unbalanced_push", "SUB $16,RSP"},
+		{"unknown_index", "MOVD (RSP)(R0),R9"},
+		{"unknown_index_writeback", "MOVD.P (RSP)(R0),R9"},
+		{"load_writeback_base_overlap", "ADD $16,RSP,R9\nMOVD.P 8(R9),R9\nMOVD $0,R9"},
+		{"frame_index", "MOVD RSP,R9\nMOVD (R0)(R9),R10\nMOVD $0,R9"},
+		{"unknown_transform_cannot_kill", "MOVD RSP,R9\nEOR R9,R9\nMOVD R9,(R1)\nMOVD $0,R9"},
+		{"unknown_word", "WORD $0xffffffff"},
+		{"unknown_data", "DWORD $0"},
+		{"raw_native_ret", "WORD $0xd65f03c0"},
+		{"raw_native_call", "WORD $0xd63f0000"},
+		{"source_call", "CALL unknown(SB)"},
+		{"local_call", "CALL helper\nhelper:"},
+		{"native_exception", "SVC $0"},
+		{"dead_escape", "B skip\ndead:\nMOVD R29,(R1)\nskip:"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64RawPrivateFrameFixture("rawNegative", tc.body))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if arm64CallFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("raw private frame proof erased an escape or uncertain effect")
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+				Sigs: map[string]FuncSig{"rawNegative": arm64RawPrivateFrameSignature("rawNegative")}})
+			if err == nil {
+				t.Fatal("unsafe raw source passed through an alternate translation path")
+			}
+		})
+	}
+	for _, change := range []struct{ from, to string }{
+		{"4,$120-16", "516,$120-16"},
+		{"4,$120-16", "UnknownFlags,$120-16"},
+		{"4,$120-16", "4,$121-16"},
+		{"RET\n", "RET R29\n"},
+		{"RET\n", ""},
+		{"WORD $0x910143fd\n", "MOVD R29,R9\nMOVD R9,(R1)\nMOVD $0,R9\n"},
+	} {
+		source := strings.Replace(arm64RawPrivateFrameFixture("rawNegative", ""), change.from, change.to, 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("unproven source contract: %s -> %s", change.from, change.to)
+		}
+	}
+}
+
+func TestARM64RawPrivateFrameLocalSpillsCopiesAndExactJoins(t *testing.T) {
+	for _, body := range []string{
+		"ADD $16,RSP,R9\nMOVD R9,32(RSP)\nMOVD $0,R9\nMOVD 32(RSP),R10\nMOVD (R10),R11\nMOVD $0,R10",
+		"CBZ R0,other\nADD $16,RSP,R9\nB joined\nother:\nMOVD $16(RSP),R9\njoined:\nMOVD R9,R10\nMOVD $0,R9\nMOVD (R10),R11\nMOVD $0,R10",
+		"MOVD R29,16(RSP)\nMOVD R0,16(RSP)",                                            // A known full overwrite, not an arbitrary raw write mask.
+		"CBZ R0,other\nMOVD R29,R9\nB joined\nother:\nMOVD R0,R9\njoined:\nMOVD $0,R9", // Taint is kept at the join then explicitly overwritten.
+	} {
+		source := arm64RawPrivateFrameFixture("rawLocalRead", body)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !arm64CallFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("known private spill/copy/read lost its exact proof: %s", body)
+		}
+		_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+			Sigs: map[string]FuncSig{"rawLocalRead": arm64RawPrivateFrameSignature("rawLocalRead")}})
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	file, err := Parse(ArchARM64, arm64RawPrivateFrameFixture("rawNoHelpers", "CALL helper<>(SB)")+"TEXT helper<>(SB),4,$0\nADD $1,R9\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := coalesceARM64PrivateRegisterHelpers(file); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("raw byte-layout helper root cannot silently borrow coalescing: %v", err)
+	}
+}
+
+func TestARM64RawPrivateFrameContinuationGuardsRemainIndependent(t *testing.T) {
+	for _, body := range []string{
+		"MOVD R0,88(RSP)",       // Full LR overwrite, even though no frame address escaped.
+		"MOVB R0,89(RSP)",       // Partial LR overwrite.
+		"FSTPQ (F0,F1),72(RSP)", // A full FP pair also overlaps the saved LR.
+	} {
+		file, err := Parse(ArchARM64, arm64RawPrivateFrameFixture("rawLinkClobber", body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+			Sigs: map[string]FuncSig{"rawLinkClobber": arm64RawPrivateFrameSignature("rawLinkClobber")}})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unknown caller LR cannot borrow the address proof: %s: %v", body, err)
+		}
+	}
+	source := strings.Replace(arm64RawPrivateFrameFixture("rawLinkClobber", ""), "RET\n", "MOVD $0,R30\nRET\n", 1)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"rawLinkClobber": arm64RawPrivateFrameSignature("rawLinkClobber")}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("the Go leaf epilogue must not wash an explicitly clobbered R30: %v", err)
+	}
+}
+
+func TestARM64RawPrivateFrameOverlappingPointerReadsRemainTainted(t *testing.T) {
+	for trial := 0; trial < 100; trial++ {
+		state := &arm64RawPrivateFrameState{
+			regs: make(arm64PrivateFrameAddresses),
+			spills: map[int64]arm64PrivateFrameAddress{
+				16: {offset: 8, exact: true},
+				24: {offset: 32, exact: true},
+			},
+		}
+		form := arm64RawPrivateMemoryForm{
+			memory:    Operand{Kind: OpMem, Mem: MemRef{Base: SP, Off: 20}},
+			registers: []Reg{"R9"}, elementBytes: 8, gp: true,
+		}
+		if !state.memory(form, 120) {
+			t.Fatal("known bounded pointer read failed")
+		}
+		value, frame := state.address("R9")
+		if !frame || value.exact {
+			t.Fatal("map iteration cannot choose one of two overlapping pointer cells")
+		}
+	}
+}
diff --git a/arm64_raw_register_families.go b/arm64_raw_register_families.go
new file mode 100644
index 000000000..2b7a51dd6
--- /dev/null
+++ b/arm64_raw_register_families.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawContinuationEffects struct {
+	gpReads  uint32
+	gpWrites uint32
+	readsSP  bool
+	stores   bool
+}
+
+// These effects track source GP outputs and external memory stores for caller
+// continuation provenance. FP/SIMD/ZA state is a different register bank, and
+// backend scratch clobbers are not writes to source virtual GP registers.
+// Each concrete decoder retains its complete operand and reserved-bit grammar.
+type arm64RawFamily struct {
+	effects func(uint32) (arm64RawContinuationEffects, bool)
+	lower   func(*arm64Ctx, uint32) error
+}
+
+func arm64RawForm[T any](
+	decode func(uint32) (T, bool),
+	lower func(*arm64Ctx, T) error,
+	effects func(T) arm64RawContinuationEffects,
+) arm64RawFamily {
+	return arm64RawFamily{
+		effects: func(word uint32) (arm64RawContinuationEffects, bool) {
+			form, ok := decode(word)
+			if !ok {
+				return arm64RawContinuationEffects{}, false
+			}
+			return effects(form), true
+		},
+		lower: func(c *arm64Ctx, word uint32) error {
+			form, ok := decode(word)
+			if !ok {
+				return fmt.Errorf("ARM64 raw family rejected its selected encoding %#08x", word)
+			}
+			return lower(c, form)
+		},
+	}
+}
+
+// Only explicitly registered forms with no GP outputs or external memory
+// access use this constructor. Their FP/SIMD/ZA effects are still lowered;
+// GP conversions and memory forms provide typed bank/direction effects.
+func arm64RawNoGPOrMemoryForm[T any](decode func(uint32) (T, bool), lower func(*arm64Ctx, T) error) arm64RawFamily {
+	return arm64RawForm(decode, lower, func(T) arm64RawContinuationEffects {
+		return arm64RawContinuationEffects{}
+	})
+}
+
+func arm64RawGPBit(index int) uint32 {
+	if index >= 0 && index < 31 {
+		return 1 << uint(index)
+	}
+	return 0 // Encoding 31 is WZR/XZR, not SP.
+}
+
+// Lowering, raw-pool writes and source continuation proof share typed decoders.
+// Unregistered encodings still fall through to conservative effect analysis.
+func arm64RawContinuationEffectsForWord(word uint32) (arm64RawContinuationEffects, bool) {
+	if _, effects, ok := decodeARM64RawFloatFamily(word); ok {
+		return effects, true
+	}
+	if _, effects, ok := decodeARM64RawVectorFamily(word); ok {
+		return effects, true
+	}
+	if _, effects, ok := decodeARM64RawStateFamily(word); ok {
+		return effects, true
+	}
+	return arm64RawContinuationEffects{}, false
+}
diff --git a/arm64_raw_scalar_fabd_runtime_test.go b/arm64_raw_scalar_fabd_runtime_test.go
new file mode 100644
index 000000000..55be006a0
--- /dev/null
+++ b/arm64_raw_scalar_fabd_runtime_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64ScalarABDMulRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var source, oracle, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	oracle.WriteString("#include <stdint.h>\n#include <string.h>\n")
+	widths := []struct {
+		bits                  int
+		letter, ctype, values string
+		fabd, fmulx           uint32
+	}{
+		{16, "h", "_Float16", "0,0x8000,0x3c00,0xbc00,1,0x03ff,0x7bff,0x7c00,0xfc00,0x7e55,0x7d11", 0x7ec01400, 0x5e401c00},
+		{32, "s", "float", "0,0x80000000,0x3f800000,0xbf800000,1,0x007fffff,0x7f7fffff,0x7f800000,0xff800000,0x7fc05555,0x7f800111", 0x7ea0d400, 0x5e20dc00},
+		{64, "d", "double", "0,0x8000000000000000ULL,0x3ff0000000000000ULL,0xbff0000000000000ULL,1,0x000fffffffffffffULL,0x7fefffffffffffffULL,0x7ff0000000000000ULL,0xfff0000000000000ULL,0x7ff8000000005555ULL,0x7ff0000000000111ULL", 0x7ee0d400, 0x5e60dc00},
+	}
+	for _, width := range widths {
+		for _, op := range []string{"fabd", "fmulx"} {
+			base := width.fabd
+			if op == "fmulx" {
+				base = width.fmulx
+			}
+			name := fmt.Sprintf("%s%d", op, width.bits)
+			fmt.Fprintf(&source, `TEXT %s(SB),$0-24
+MOVD a+0(FP),R0
+MOVD b+8(FP),R1
+MOVD out+16(FP),R2
+VLD1 (R0),[V1.B16]
+VLD1 (R1),[V2.B16]
+WORD $%#08x
+VST1 [V0.B16],(R2)
+RET
+`, name, base|2<<16|1<<5)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&oracle, `extern void %s(const void *, const void *, void *);
+static int check_%s(void) {
+  const uint%d_t bits[] = {%s};
+  for (unsigned i = 0; i < sizeof(bits)/sizeof(bits[0]); i++) {
+    for (unsigned j = 0; j < sizeof(bits)/sizeof(bits[0]); j++) {
+      unsigned char a[16] = {0}, b[16] = {0}, got[16], want[16] = {0};
+      %s x, y, result;
+      memcpy(a, &bits[i], sizeof(x));
+      memcpy(b, &bits[j], sizeof(y));
+      memcpy(&x, a, sizeof(x));
+      memcpy(&y, b, sizeof(y));
+      __asm__ volatile("%s %%%s0, %%%s1, %%%s2" : "=w"(result) : "w"(x), "w"(y));
+      memcpy(want, &result, sizeof(result));
+      %s(a, b, got);
+      if (memcmp(got, want, sizeof(got)) != 0) return 1;
+    }
+  }
+  return 0;
+}
+`, name, name, width.bits, width.values, width.ctype, op, width.letter, width.letter, width.letter, name)
+			fmt.Fprintf(&checks, "  if (check_%s()) return %d;\n", name, len(sigs))
+		}
+	}
+	oracle.WriteString("int main(void) {\n" + checks.String() + "  return 0;\n}\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir, oracle.String()
+}
+
+func TestARM64RawScalarABDMulNativeRuntime(t *testing.T) {
+	if runtime.GOARCH != "arm64" || runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+		t.Skip("native ARM64 execution has a required Linux QEMU counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, main := arm64ScalarABDMulRuntime(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang, "-march=armv8.2-a+fp16"}, "scalar_abd_mul", triple, ir, main, nil)
+}
diff --git a/arm64_raw_scalar_fabd_test.go b/arm64_raw_scalar_fabd_test.go
new file mode 100644
index 000000000..498941bb7
--- /dev/null
+++ b/arm64_raw_scalar_fabd_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawScalarAbsoluteDifferenceAndMultiplyExtended(t *testing.T) {
+	var native []string
+	for _, op := range []string{"fabd", "fmulx"} {
+		for _, width := range []string{"h", "s", "d"} {
+			for _, regs := range [][3]int{{0, 1, 2}, {29, 30, 31}, {31, 31, 31}} {
+				native = append(native, fmt.Sprintf("%s %s%d, %s%d, %s%d", op, width, regs[0], width, regs[1], width, regs[2]))
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, native, "+fullfp16")
+	var source strings.Builder
+	source.WriteString("TEXT rawscalarabsmul(SB),$0-0\n")
+	for _, word := range words {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawscalarabsmul": {Name: "rawscalarabsmul", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"fabd", "fmulx"} {
+				family := "sisd"
+				if op == "fmulx" {
+					family = "neon"
+				}
+				for _, width := range []int{16, 32, 64} {
+					if !strings.Contains(ir, fmt.Sprintf("@llvm.aarch64.%s.%s.f%d", family, op, width)) {
+						t.Fatalf("scalar %s f%d missing", op, width)
+					}
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "rawscalarabsmul.ll", "rawscalarabsmul.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_scalar_register_effects.go b/arm64_raw_scalar_register_effects.go
new file mode 100644
index 000000000..941d8c8b8
--- /dev/null
+++ b/arm64_raw_scalar_register_effects.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+// This scalar physical operand grammar is shared by native GP/R27/NZCV
+// observers. Go's obj7 cases 3 and 27 use these exact encoding classes,
+// including aliases. It supplies effects only, never a frame or input fact.
+type arm64RawScalarRegister struct {
+	width                      int
+	first, second, destination int
+	extended                   bool
+	flags                      bool
+}
+
+func decodeARM64RawScalarRegister(word uint32) (arm64RawScalarRegister, bool) {
+	width := 32
+	if word>>31 != 0 {
+		width = 64
+	}
+	form := arm64RawScalarRegister{
+		width: width, first: int(word>>5) & 31,
+		second: int(word>>16) & 31, destination: int(word) & 31,
+	}
+	switch {
+	case word&0x1f000000 == 0x0a000000:
+		// Logical shifted register: all four shifts, both complement states,
+		// and AND/OR/EOR/ANDS. W shifts must not set imm6's high bit.
+		if int(word>>10&63) >= width {
+			return arm64RawScalarRegister{}, false
+		}
+		form.flags = word>>29&3 == 3
+	case word&0x1f200000 == 0x0b000000:
+		// ADD/SUB shifted register: ROR is reserved, unlike logical shifts.
+		if word>>22&3 == 3 || int(word>>10&63) >= width {
+			return arm64RawScalarRegister{}, false
+		}
+		form.flags = word&(1<<29) != 0
+	case word&0x1fe00000 == 0x0b200000:
+		// ADD/SUB extended register: all eight extensions, shift 0..4.
+		// Rm=31 is zero even where Rn or a non-S Rd=31 denotes SP.
+		if word>>10&7 > 4 {
+			return arm64RawScalarRegister{}, false
+		}
+		form.extended = true
+		form.flags = word&(1<<29) != 0
+	default:
+		return arm64RawScalarRegister{}, false
+	}
+	return form, true
+}
+
+func (form arm64RawScalarRegister) gpEffects() (reads, writes uint32, stack bool) {
+	if form.second != 31 {
+		reads |= 1 << uint(form.second)
+	}
+	if form.first != 31 {
+		reads |= 1 << uint(form.first)
+	} else if form.extended {
+		stack = true
+	}
+	if form.destination != 31 {
+		writes |= 1 << uint(form.destination)
+	} else if form.extended && !form.flags {
+		stack = true
+	}
+	return reads, writes, stack
+}
diff --git a/arm64_raw_scalar_register_effects_test.go b/arm64_raw_scalar_register_effects_test.go
new file mode 100644
index 000000000..844abdfbd
--- /dev/null
+++ b/arm64_raw_scalar_register_effects_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"testing"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+func TestARM64NativeScratchScalarRegisterStackAndZeroRoles(t *testing.T) {
+	// Independent physical fixtures follow obj7 oprrr/opxrrr. Every valid
+	// synthetic word is also decoded by x/arch; it is not a Go object or a
+	// numerical execution certificate. In extended arithmetic Rn/non-S Rd
+	// 31 is SP, but Rm 31 is always zero. Shifted families use zero throughout.
+	for _, family := range []uint32{0x0a000000, 0x0a200000, 0x0b000000, 0x0b200000} {
+		for _, width := range []int{32, 64} {
+			for operation := uint32(0); operation < 4; operation++ {
+				for _, first := range []uint32{1, 27, 30, 31} {
+					for _, second := range []uint32{0, 1, 27, 30, 31} {
+						for _, destination := range []uint32{4, 27, 30, 31} {
+							word := family | operation<<29 | second<<16 | first<<5 | destination
+							if width == 64 {
+								word |= 1 << 31
+							}
+							var code [4]byte
+							binary.LittleEndian.PutUint32(code[:], word)
+							instruction, err := arm64asm.Decode(code[:])
+							if err != nil {
+								t.Fatalf("independent scalar word %08x: %v", word, err)
+							}
+							form, valid := decodeARM64RawScalarRegister(word)
+							if !valid || form.width != width {
+								t.Fatalf("valid scalar grammar rejected %08x", word)
+							}
+							extended := family == 0x0b200000
+							flags := operation&1 != 0
+							if family&0x1f000000 == 0x0a000000 {
+								flags = operation == 3
+							}
+							var reads, writes uint32
+							if first != 31 {
+								reads |= 1 << first
+							}
+							if second != 31 {
+								reads |= 1 << second
+							}
+							if destination != 31 {
+								writes = 1 << destination
+							}
+							stack := extended && (first == 31 || destination == 31 && !flags)
+							actualReads, actualWrites, actualStack := form.gpEffects()
+							if actualReads != reads || actualWrites != writes || actualStack != stack || form.flags != flags {
+								t.Fatalf("physical operand role changed for %08x", word)
+							}
+							effect, accepted := arm64ScratchNativeInputEffect(instruction, false)
+							if stack || (reads|writes)&(1<<30) != 0 {
+								if accepted {
+									t.Fatalf("scalar SP/LR acquired an input contract: %08x", word)
+								}
+							} else {
+								want := arm64ScratchInputEffect{reads: uint64(reads), writes: uint64(writes)}
+								if flags {
+									want.writes |= 15 << 31
+								}
+								if !accepted || effect != want {
+									t.Fatalf("scalar input effect changed for %08x: %+v", word, effect)
+								}
+							}
+							scratch, valid := arm64ScratchNativeEffect(instruction)
+							wantScratch := arm64ScratchEffect{reads: reads&(1<<27) != 0, defines: writes&(1<<27) != 0}
+							if !valid || scratch != wantScratch {
+								t.Fatalf("scalar R27 role changed for %08x", word)
+							}
+							gp, valid := arm64RawPoolGPWrites(word)
+							if !valid || gp != writes || arm64RawPoolInstructionPreservesNZCV(instruction) != !flags {
+								t.Fatalf("scalar GP/NZCV consumers differ for %08x", word)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64NativeScratchScalarRegisterReservedFields(t *testing.T) {
+	for _, word := range []uint32{
+		0x0a008000,                         // W logical shift >=32.
+		0x0b008000,                         // W arithmetic shift >=32.
+		0x8bc00000,                         // Arithmetic ROR is reserved.
+		0x0b201400, 0x0b201800, 0x0b201c00, // Extension shifts 5/6/7.
+		0x8b600000, 0x8ba00000, // Fixed extended-class bits are reserved.
+		0xd503201f, // NOP is not this scalar operand family.
+		0x9a000000, // ADC has a separate incoming-carry contract.
+		0x93407c24, // SXTW has its separate bitfield grammar.
+		0x4e201c00, // SIMD logical operands are not scalar GP inputs.
+	} {
+		if _, valid := decodeARM64RawScalarRegister(word); valid {
+			t.Fatalf("reserved/foreign word acquired scalar effects: %08x", word)
+		}
+	}
+}
diff --git a/arm64_raw_self_bl_caller_test.go b/arm64_raw_self_bl_caller_test.go
new file mode 100644
index 000000000..17ed40efc
--- /dev/null
+++ b/arm64_raw_self_bl_caller_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64SelfBLCallerDetectsCorruption(t *testing.T) {
+	_, _, compiler, runner := arm64FPPairRuntimeTools(t)
+	for _, tc := range []struct {
+		name, mutation, diagnostic string
+	}{
+		{name: "healthy"},
+		{name: "g", mutation: "eor x28,x28,#1", diagnostic: "fixed=1"},
+		{name: "os18", mutation: "eor x18,x18,#1", diagnostic: "fixed=1"},
+		{name: "numeric", mutation: "eor x8,x8,#1", diagnostic: "output=-?[1-9][0-9]*"},
+		{name: "output_canary", mutation: "strb wzr,[x1,#9]", diagnostic: "output=-?[1-9][0-9]*"},
+		{name: "input_canary", mutation: "ldrb w9,[x0,#8]\\neor w9,w9,#1\\nstrb w9,[x0,#8]", diagnostic: "input=-?[1-9][0-9]*"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			// The independent native stub deliberately bypasses the translator
+			// and its source proof. It establishes that this caller observes
+			// callee corruption, rather than just accepting a consistent IR.
+			stub := fmt.Sprintf(`
+__asm__(
+    ".text\n"
+    ".p2align 2\n"
+    ".globl " TERMINAL_SYMBOL "\n"
+    TERMINAL_SYMBOL ":\n"
+    "ldr x8,[x0]\n"
+    "%s\n"
+    "str x8,[x1]\n"
+    "ret\n");
+`, tc.mutation)
+			dir := t.TempDir()
+			source := filepath.Join(dir, "caller.c")
+			path := filepath.Join(dir, "caller")
+			if err := os.WriteFile(source, []byte(arm64RawSelfBLOracleC+stub), 0600); err != nil {
+				t.Fatal(err)
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			args := append(append([]string(nil), compiler[1:]...), source, "-O2", "-o", path)
+			command := exec.CommandContext(ctx, compiler[0], args...)
+			if output, err := command.CombinedOutput(); err != nil {
+				t.Fatalf("compile independent caller-corruption stub: %v\n%s", err, output)
+			}
+			args = append(append([]string(nil), runner...), path)
+			command = exec.CommandContext(ctx, args[0], args[1:]...)
+			command.Env = append(os.Environ(), "SELF_BL_SINK=0")
+			output, err := command.CombinedOutput()
+			if tc.mutation == "" {
+				if err != nil {
+					t.Fatalf("healthy independent callee: %v\n%s", err, output)
+				}
+				return
+			}
+			if err == nil || !regexp.MustCompile(tc.diagnostic).Match(output) {
+				t.Fatalf("callee corruption was not observed: %v\n%s", err, output)
+			}
+		})
+	}
+}
diff --git a/arm64_raw_self_bl_escape_test.go b/arm64_raw_self_bl_escape_test.go
new file mode 100644
index 000000000..8b6d38b87
--- /dev/null
+++ b/arm64_raw_self_bl_escape_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSelfBLGoAcceptedEscapeSources(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, mutation := range arm64RawSelfBLGuardMutations() {
+			if mutation.name != "escaping_loop" && mutation.name != "prefix_escape" {
+				continue
+			}
+			t.Run(goos+"/"+mutation.name, func(t *testing.T) {
+				base := arm64RawSelfBLFixture()
+				source := strings.Replace(base, mutation.old, mutation.replacement, 1)
+				if source == base {
+					t.Fatal("escape mutation no longer modifies the original fixture")
+				}
+				original := arm64ImmediateOriginalGoBytes(t, source, goos)
+				raw := "WORD $0x94000000"
+				if mutation.name == "escaping_loop" {
+					raw = "WORD $0x97fffffe"
+				}
+				named := strings.Replace(source, raw, "BL spin", 1)
+				if named == source {
+					t.Fatal("escape fixture is missing its independently checked raw branch")
+				}
+				// Compare the entire native TEXT bytes, including the Go
+				// expansion of both MOVDs. No pseudo width or BL PC is guessed.
+				want := arm64ImmediateOriginalGoBytes(t, named, goos)
+				if len(original) == 0 || !bytes.Equal(original, want) {
+					t.Fatalf("raw escape fixture differs from actual Go BL spin: got %x, want %x", original, want)
+				}
+				if mutation.name == "escaping_loop" {
+					wrongPC := strings.Replace(source, raw, "WORD $0x97ffffff", 1)
+					if bytes.Equal(arm64ImmediateOriginalGoBytes(t, wrongPC, goos), want) {
+						t.Fatal("byte oracle failed to distinguish the old one-instruction branch displacement")
+					}
+				}
+				t.Logf("actual Go %s TEXT bytes: %x", goos, original)
+				sig := arm64RawZeroFrameSig()
+				sig.Name = "terminal"
+				c := arm64RawContextLowerer(t, source, sig)
+				c.unexposedCallFrame = true
+				if c.rawZeroContextControlPlan("outer") != nil {
+					t.Fatal("Go-accepted SP-address escape acquired a terminal-sink control certificate")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64RawSelfBLDirectSPStoreIsNotEscapeOracle(t *testing.T) {
+	// Preserve the old source failure: direct SP-to-memory is not a legal
+	// Go MOVD form and cannot serve as a meaningful whole-source negative.
+	source := strings.Replace(arm64RawSelfBLFixture(), "spin:\nWORD $0x94000000",
+		"spin:\nMOVD RSP,(R1)\nWORD $0x97ffffff", 1)
+	for _, goos := range []string{"linux", "darwin"} {
+		t.Run(goos, func(t *testing.T) {
+			dir := t.TempDir()
+			path := filepath.Join(dir, "invalid.s")
+			if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output, err := arm64MemoryAuditGoCommand(t, goos, "tool", "asm", "-o", filepath.Join(dir, "invalid.o"), path)
+			if err == nil || !strings.Contains(string(output), "MOVD") || !strings.Contains(string(output), "RSP") {
+				t.Fatalf("old direct-SP source lost its actual Go rejection: %v\n%s", err, output)
+			}
+			t.Logf("actual Go source rejection: %s", strings.TrimSpace(string(output)))
+		})
+	}
+}
diff --git a/arm64_raw_self_bl_runtime_test.go b/arm64_raw_self_bl_runtime_test.go
new file mode 100644
index 000000000..d68556755
--- /dev/null
+++ b/arm64_raw_self_bl_runtime_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64RawSelfBLTerminal(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := arm64RawSelfBLFixture()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	sig.Name = "terminal"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":  "module rawselfbloracle\n\ngo 1.20\n",
+		"main.go": arm64RawSelfBLOracleGo,
+		"oracle_arm64.s": strings.Replace(source, "TEXT terminal", "TEXT ·terminal", 1) +
+			"\nTEXT ·readGoG(SB),516,$0-8\nMOVD g,R0\nMOVD R0,ret+0(FP)\nRET\n",
+		"oracle.ll": ir,
+		"main.c":    arm64RawSelfBLOracleC,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	defer cancel()
+	goPath, llvmPath := filepath.Join(dir, "go-oracle"), filepath.Join(dir, "llvm-oracle")
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", goPath, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("build original Go raw self-BL caller: %v\n%s", err, output)
+	}
+	obj := filepath.Join(dir, "oracle.o")
+	command = exec.CommandContext(ctx, llc, "-O0", "-mtriple="+triple, "-filetype=obj", filepath.Join(dir, "oracle.ll"), "-o", obj)
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("LLVM22 self-BL object: %v\n%s", err, output)
+	}
+	args := append(append([]string(nil), compiler[1:]...), obj, filepath.Join(dir, "main.c"), "-O2", "-o", llvmPath)
+	command = exec.CommandContext(ctx, compiler[0], args...)
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("link independent self-BL caller: %v\n%s", err, output)
+	}
+	goRunner := runner
+	if len(runner) != 0 {
+		goRunner = []string{runner[0]}
+	}
+	for _, tc := range []struct {
+		name, path string
+		runner     []string
+	}{
+		{name: "original-Go", path: goPath, runner: goRunner},
+		{name: "LLVM22-C", path: llvmPath, runner: runner},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			args := append(append([]string(nil), tc.runner...), tc.path)
+			command := exec.CommandContext(ctx, args[0], args[1:]...)
+			command.Env = append(os.Environ(), "SELF_BL_SINK=0")
+			if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+				t.Fatalf("numeric/canary/fixed-register/return oracle: %v\n%s", err, output)
+			}
+			// Execute the already-built ELF/Mach-O with an owned lifecycle.
+			// Cold Go/QEMU startup must not consume any of the full second
+			// observed after caller readiness, not an independently observed
+			// ASM PC. The original total bound stays.
+			output, err := runtimeOracleObserveSink(ctx, func(sinkCtx context.Context) *exec.Cmd {
+				command := exec.CommandContext(sinkCtx, args[0], args[1:]...)
+				command.Env = append(os.Environ(), "SELF_BL_SINK=1")
+				return command
+			}, 10*time.Second, time.Second)
+			if err != nil {
+				t.Fatalf("self-BL returned/trapped or was never entered: %v output=%q", err, output)
+			}
+		})
+	}
+	t.Log("original Go/LLVM22: 640 independent nonzero numeric/canary/g/LR cases each; caller-ready zero-input sink remained nonreturning until acknowledged direct-child cancellation")
+}
+
+const arm64RawSelfBLOracleGo = `package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+)
+
+func terminal(*byte, *byte)
+func readGoG() uintptr
+
+func main() {
+	var input, output, want [96]byte
+	if os.Getenv("SELF_BL_SINK") == "1" {
+		fmt.Println("entered")
+		terminal(&input[0], &output[0])
+		fmt.Println("returned")
+		panic("sink returned")
+	}
+	seed := uint64(0x0123456789abcdef)
+	for trial := 0; trial < 128; trial++ {
+		for _, off := range []int{0, 1, 3, 7, 17} {
+			for i := range input {
+				seed = seed*6364136223846793005 + 1
+				input[i] = byte(seed >> 56)
+				output[i], want[i] = 0xa5, 0xa5
+			}
+			value := seed | 1
+			binary.LittleEndian.PutUint64(input[off:], value)
+			binary.LittleEndian.PutUint64(want[off:], value)
+			snapshot := input
+			before := readGoG()
+			terminal(&input[off], &output[off])
+			if before == 0 || before != readGoG() || input != snapshot || output != want {
+				panic("normal self-BL sibling numeric/canary/caller mismatch")
+			}
+		}
+	}
+}
+`
+
+const arm64RawSelfBLOracleC = `#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern void terminal(const unsigned char *, unsigned char *);
+
+#ifdef __APPLE__
+#define TERMINAL_SYMBOL "_terminal"
+#define OS18_CLOBBER
+#else
+#define TERMINAL_SYMBOL "terminal"
+#define OS18_CLOBBER "x18",
+#endif
+
+static int checkedTerminal(const unsigned char *input, unsigned char *output) {
+  register const unsigned char *arg0 __asm__("x0") = input;
+  register unsigned char *arg1 __asm__("x1") = output;
+  uint64_t beforeG, beforeOS18, afterG, afterOS18;
+
+  // A single asm boundary prevents the C register allocator from writing
+  // x28 between its snapshots (for example to hold the x18 snapshot).
+  // The four early-clobber outputs cannot alias the fixed registers or args;
+  // ordinary AAPCS64 caller-clobbered GP/FP registers and LR are explicit.
+  __asm__ volatile(
+      "mov %0,x28\n"
+      "mov %1,x18\n"
+      "bl " TERMINAL_SYMBOL "\n"
+      "mov %2,x28\n"
+      "mov %3,x18\n"
+      "mov x28,%0\n"
+      "mov x18,%1\n"
+      : "=&r"(beforeG), "=&r"(beforeOS18), "=&r"(afterG), "=&r"(afterOS18),
+        "+r"(arg0), "+r"(arg1)
+      :
+      : "x2", "x3", "x4", "x5", "x6", "x7", "x8", "x9",
+        "x10", "x11", "x12", "x13", "x14", "x15", "x16", "x17",
+        OS18_CLOBBER "x28", "x30", "v0", "v1", "v2", "v3", "v4", "v5",
+        "v6", "v7", "v16", "v17", "v18", "v19", "v20", "v21",
+        "v22", "v23", "v24", "v25", "v26", "v27", "v28", "v29",
+        "v30", "v31", "memory", "cc");
+
+  return beforeG != afterG || beforeOS18 != afterOS18;
+}
+
+int main(void) {
+  unsigned char input[96] = {0}, output[96], want[96], snapshot[96];
+  const char *sink = getenv("SELF_BL_SINK");
+  if (sink && strcmp(sink, "1") == 0) {
+    puts("entered");
+    fflush(stdout);
+    terminal(input, output);
+    puts("returned");
+    fflush(stdout);
+    return 99;
+  }
+  const unsigned offsets[] = {0, 1, 3, 7, 17};
+  uint64_t seed = UINT64_C(0x0123456789abcdef);
+  for (unsigned trial = 0; trial < 128; trial++) {
+    for (unsigned o = 0; o < 5; o++) {
+      unsigned off = offsets[o];
+      for (unsigned i = 0; i < 96; i++) {
+        seed = seed * UINT64_C(6364136223846793005) + 1;
+        input[i] = (unsigned char)(seed >> 56);
+        output[i] = want[i] = 0xa5;
+      }
+      uint64_t value = seed | 1;
+      memcpy(input + off, &value, 8);
+      memcpy(want + off, &value, 8);
+      memcpy(snapshot, input, sizeof(input));
+      int fixedDiff = checkedTerminal(input + off, output + off);
+      int inputDiff = memcmp(input, snapshot, sizeof(input));
+      int outputDiff = memcmp(output, want, sizeof(output));
+      if (fixedDiff || inputDiff || outputDiff) {
+        fprintf(stderr, "trial=%u off=%u fixed=%d input=%d output=%d\n",
+                trial, off, fixedDiff, inputDiff, outputDiff);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_self_bl_test.go b/arm64_raw_self_bl_test.go
new file mode 100644
index 000000000..6475cf6bc
--- /dev/null
+++ b/arm64_raw_self_bl_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func arm64RawSelfBLFixture() string {
+	return `TEXT terminal(SB),516,$0-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xa9bf7bfd
+MOVD (R0),R4
+CBZ R4,spin
+MOVD R4,(R1)
+WORD $0xa8c17bfd
+WORD $0xd65f03c0
+spin:
+WORD $0x94000000
+WORD $0xd65f03c0
+`
+}
+
+func TestARM64RawSelfBLTerminalHasNoReturnCertificate(t *testing.T) {
+	source := arm64RawSelfBLFixture()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	sig.Name = "terminal"
+	c := arm64RawContextLowerer(t, source, sig)
+	plan := c.rawZeroContextControlPlan("outer")
+	if plan == nil {
+		t.Fatal("exact raw self-BL sink lost its independent whole-source proof")
+	}
+	found := false
+	for block, body := range c.blocks {
+		if body.name != "spin" {
+			continue
+		}
+		found = true
+		if !plan.reachable[block] || len(body.instrs) != 1 {
+			t.Fatal("sink does not have the exact single-instruction block")
+		}
+		point := [2]int{block, 0}
+		if plan.before[point] != nil || plan.linkBefore[point] != nil || plan.stackBefore[point] != nil {
+			t.Fatal("nonreturning raw loop fabricated a return certificate")
+		}
+	}
+	if !found {
+		t.Fatal("sink block not found")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		// The source BL must still write its own continuation and branch to
+		// itself, not become a return, no-op, native call or unreachable block.
+		if !regexp.MustCompile(`(?s)\nbb_spin:[^\n]*\n[^\n]*blockaddress\(@terminal, %bb_anon_5f[^\n]*\n[^\n]*store i64[^\n]*ptr %reg_R30[^\n]*\n\s+br label %bb_spin`).MatchString(ir) {
+			t.Fatalf("self-BL LR-write/control semantics lost:\n%s", ir)
+		}
+		compileLLVMToObject(t, llc, triple, "self-bl.ll", "self-bl.o", ir)
+	}
+	dir := t.TempDir()
+	path := filepath.Join(dir, "self.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "self.o"), path)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	output, err := command.CombinedOutput()
+	if err != nil || !strings.Contains(string(output), "00 00 00 94 c0 03 5f d6") {
+		t.Fatalf("original Go did not encode the exact unrelocated self BL: %v\n%s", err, output)
+	}
+	// A last-in-source self BL has only the block splitter's empty PC+4
+	// placeholder. It is not an unverified source component or return edge.
+	ending := strings.TrimSuffix(source, "WORD $0xd65f03c0\n")
+	requireARM64GoAssemblerResult(t, ending, true)
+	c = arm64RawContextLowerer(t, ending, sig)
+	plan = c.rawZeroContextControlPlan("outer")
+	if plan == nil || plan.reachable[len(c.blocks)-1] {
+		t.Fatal("synthetic empty fallthrough was fabricated as reachable source")
+	}
+	endingFile, err := Parse(ArchARM64, ending)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(endingFile, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "self-bl-ending.ll", "self-bl-ending.o", ir)
+	}
+	// Signed/unsigned expression spellings must encode the same actual BL,
+	// rather than being recognized by its spelling or a diagnostic comment.
+	for _, word := range []string{"2483027968", "-1811939328", "(0x93ffffff+1)"} {
+		changed := strings.Replace(source, "0x94000000", word, 1)
+		requireARM64GoAssemblerResult(t, changed, true)
+		if arm64RawContextLowerer(t, changed, sig).rawZeroContextControlPlan("outer") == nil {
+			t.Fatalf("actual self-BL integer encoding spelling lost proof: %s", word)
+		}
+	}
+}
+
+func arm64RawSelfBLGuardMutations() []struct{ name, old, replacement string } {
+	return []struct{ name, old, replacement string }{
+		{"ordinary_recursion", "WORD $0x94000000", "BL spin"},
+		{"other_target", "WORD $0x94000000", "WORD $0x94000001"},
+		{"multiline_helper", "spin:\nWORD $0x94000000", "spin:\nWORD $0xd503201f\nWORD $0x97ffffff"},
+		{"changing_sp_loop", "spin:\nWORD $0x94000000", "spin:\nWORD $0xd10043ff\nWORD $0x97ffffff"},
+		// SP cannot be a Go MOVD store source. Copy it to a GP first;
+		// the independent Go object oracle authenticates the raw BL PC.
+		{"escaping_loop", "spin:\nWORD $0x94000000", "spin:\nMOVD RSP,R9\nMOVD R9,(R1)\nWORD $0x97fffffe"},
+		{"prefix_escape", "CBZ R4,spin", "MOVD RSP,R9\nMOVD R9,(R1)\nCBZ R4,spin"},
+		{"prefix_hidden_escape", "CBZ R4,spin", "MOVD R29,(R1)\nCBZ R4,spin"},
+		{"return_lr", "WORD $0xa8c17bfd", "MOVD R1,R30\nWORD $0xa8c117e4"},
+		{"return_sp", "WORD $0xa8c17bfd", "WORD $0xa8c27bfd"},
+		{"return_g", "MOVD R4,(R1)", "MOVD R4,(R1)\nMOVD $0,g"},
+		{"dead_unknown", "spin:\n", "dead:\nWORD $0xffffffff\nWORD $0xd65f03c0\nspin:\n"},
+		{"different_sp_join", "CBZ R4,spin", "CBZ R4,left\nSUB $16,RSP\nB spin\nleft:\nB spin"},
+	}
+}
+
+func TestARM64RawSelfBLSinkCannotBypassWholeSourceGuards(t *testing.T) {
+	source := arm64RawSelfBLFixture()
+	sig := arm64RawZeroFrameSig()
+	sig.Name = "terminal"
+	for _, tc := range arm64RawSelfBLGuardMutations() {
+		t.Run(tc.name, func(t *testing.T) {
+			changed := strings.Replace(source, tc.old, tc.replacement, 1)
+			c := arm64RawContextLowerer(t, changed, sig)
+			c.unexposedCallFrame = true
+			if c.rawZeroContextControlPlan("outer") != nil {
+				t.Fatal("self-BL exemption erased a nonterminal effect or source/return/join failure")
+			}
+		})
+	}
+}
+
+func TestARM64ControlGPMoveRejectsFloatingImmediate(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, literal := range []string{"0.0", "1.5", "-1.5"} {
+			source := fmt.Sprintf("TEXT floating(SB),516,$0-0\n%s $%s,R30\nRET\n", op, literal)
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !ins.Args[0].ImmIsFloat {
+				t.Fatalf("float literal did not exercise typed immediate flag: %+v", ins.Args[0])
+			}
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": arm64ControlFromMap(map[string]bool{"label:caller": true})},
+				memory: make(map[string]arm64ControlValue),
+			}
+			if state.transferGPRegisterMove(ins) {
+				t.Fatalf("floating operand acquired an integer overwrite witness: %s", ins.Raw)
+			}
+			state.transfer(ins, ins.Op, false, nil)
+			if !arm64ControlHas(arm64ControlRead(state.regs, "R30"), "label:caller") {
+				t.Fatalf("fallback washed invalid floating MOV destination provenance: %s", ins.Raw)
+			}
+		}
+	}
+}
diff --git a/arm64_raw_side_effects_test.go b/arm64_raw_side_effects_test.go
new file mode 100644
index 000000000..ffae024e8
--- /dev/null
+++ b/arm64_raw_side_effects_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawStateFamiliesHavePreciseGPAndSavedMemoryEffects(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		word   uint32
+		writes uint32
+		stores bool
+	}{
+		{"ic_ivau", 0xd50b753e, 0, false},
+		{"rndr_x30", 0xd53b241e, 1 << 30, false},
+		{"rndrrs_xzr", 0xd53b243f, 0, false},
+		{"casp_expected_x2_x3", 0x48227f3e, 1<<2 | 1<<3, true},
+		{"smstart", 0xd503477f, 0, false},
+		{"zero_za", 0xc00800ff, 0, false},
+		{"fmopa", 0x80800020, 0, false},
+		{"sme_tile_read", 0xc0820000, 0, false},
+		{"sme_tile_write", 0xc080e000, 0, false},
+		{"sme_memory_load", 0xe01f0020, 0, false},
+		{"sme_memory_store", 0xe03f0000, 0, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if writes, known := arm64RawPoolGPWrites(test.word); !known || writes != test.writes {
+				t.Errorf("GP writes=%#x, known=%v; want %#x", writes, known, test.writes)
+			}
+			caller := arm64ControlFromMap(map[string]bool{"return:outer": true})
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": caller, "R2": caller, "R3": caller},
+				memory: map[string]arm64ControlValue{"sp:0": caller},
+			}
+			state.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(test.word)}}}, OpWORD, false, nil)
+			for _, register := range []struct {
+				name Reg
+				bit  uint32
+			}{{"R30", 1 << 30}, {"R2", 1 << 2}, {"R3", 1 << 3}} {
+				if arm64ControlHas(state.regs[register.name], "") != (test.writes&register.bit != 0) {
+					t.Errorf("%s provenance did not follow its exact GP output", register.name)
+				}
+			}
+			if arm64ControlHas(state.memory["sp:0"], "") != test.stores {
+				t.Errorf("saved continuation clobber must match a real memory store, want %v", test.stores)
+			}
+		})
+	}
+}
+
+func TestARM64RawStateGPBankAndSPEffectsCompleteIndependentAxes(t *testing.T) {
+	for register := 0; register < 32; register++ {
+		bit := uint32(1) << uint(register)
+		if register == 31 {
+			bit = 0
+		}
+		for _, base := range []uint32{0xd53b2400, 0xd53b2420} {
+			word := base | uint32(register)
+			_, effects, ok := decodeARM64RawStateFamily(word)
+			want := arm64RawContinuationEffects{gpWrites: bit}
+			if !ok || effects != want {
+				t.Errorf("RNDR word %#08x: %+v, %v; want %+v", word, effects, ok, want)
+			}
+		}
+		word := uint32(0xd50b7520) | uint32(register)
+		_, effects, ok := decodeARM64RawStateFamily(word)
+		want := arm64RawContinuationEffects{gpReads: bit}
+		if !ok || effects != want {
+			t.Errorf("IC IVAU word %#08x: %+v, %v; want %+v", word, effects, ok, want)
+		}
+	}
+	for _, bits := range []int{32, 64} {
+		for _, order := range []struct{ acquire, release bool }{
+			{}, {acquire: true}, {release: true}, {acquire: true, release: true},
+		} {
+			for expected := 0; expected < 32; expected += 2 {
+				for newValue := 0; newValue < 32; newValue += 2 {
+					for base := 0; base < 32; base++ {
+						word := arm64EncodeRawCASP(bits, order.acquire, order.release, expected, newValue, base)
+						_, effects, ok := decodeARM64RawStateFamily(word)
+						writes := uint32(3) << uint(expected) & 0x7fffffff
+						newReads := uint32(3) << uint(newValue) & 0x7fffffff
+						baseRead := uint32(1) << uint(base) & 0x7fffffff
+						want := arm64RawContinuationEffects{
+							gpReads: writes | newReads | baseRead, gpWrites: writes,
+							readsSP: base == 31, stores: true,
+						}
+						if !ok || effects != want {
+							t.Fatalf("CASP word %#08x: %+v, %v; want %+v", word, effects, ok, want)
+						}
+					}
+				}
+			}
+		}
+	}
+	// SME tile addresses use SP as a base, but XZR as a register offset.
+	// Vary each independent bank/width/direction axis without a huge product.
+	for register := 0; register < 32; register++ {
+		for size := uint32(0); size < 4; size++ {
+			for row := uint32(0); row < 4; row++ {
+				for _, store := range []bool{false, true} {
+					for _, spBase := range []bool{false, true} {
+						base, offset := uint32(register), uint32(31)
+						if spBase {
+							base, offset = 31, uint32(register)
+						}
+						word := uint32(0xe0000000) | size<<22 | offset<<16 | row<<13 | base<<5
+						if store {
+							word |= 1 << 21
+						}
+						_, effects, ok := decodeARM64RawStateFamily(word)
+						want := arm64RawContinuationEffects{
+							gpReads: (1 << (row + 12)) | ((1 << base) & 0x7fffffff) | ((1 << offset) & 0x7fffffff),
+							readsSP: base == 31, stores: store,
+						}
+						if !ok || effects != want {
+							t.Fatalf("SME word %#08x: %+v, %v; want %+v", word, effects, ok, want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawStateGPOutputsCannotInventCallerReturn(t *testing.T) {
+	for _, word := range []uint32{0xd53b241e, 0xd53b243e, 0x483e7c82} {
+		source := fmt.Sprintf("TEXT stateResult(SB),4,$0-0\nWORD $%#08x\nRET\n", word)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+		} {
+			_, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"stateResult": {Name: "stateResult", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%#08x / %s: overwritten caller LR requires source restoration, got %v", word, triple, err)
+			}
+		}
+	}
+}
+
+func TestARM64RawStateDecodersHaveSharedEffectsAndLowering(t *testing.T) {
+	registry, err := parser.ParseFile(token.NewFileSet(), "arm64_raw_state_families.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registered := make(map[string]bool)
+	ast.Inspect(registry, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) == 0 {
+			return true
+		}
+		decoder, ok := call.Args[0].(*ast.Ident)
+		if !ok || !strings.HasPrefix(decoder.Name, "decodeARM64Raw") {
+			return true
+		}
+		if registered[decoder.Name] {
+			t.Fatalf("duplicate state family %s", decoder.Name)
+		}
+		registered[decoder.Name] = true
+		return true
+	})
+	for _, name := range []string{
+		"arm64_lower_word_streaming_mode.go", "arm64_lower_word_za_zero.go",
+		"arm64_lower_word_sme_mopa.go", "arm64_lower_word_sme_tile_memory.go",
+		"arm64_lower_ic.go", "arm64_lower_word_rndr.go", "arm64_lower_word_casp.go",
+		"arm64_lower_cache_maintenance.go",
+		"arm64_nzcv_transport.go",
+	} {
+		file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, decl := range file.Decls {
+			fn, ok := decl.(*ast.FuncDecl)
+			if !ok || !strings.HasPrefix(fn.Name.Name, "decodeARM64Raw") || fn.Type.Results == nil {
+				continue
+			}
+			results := fn.Type.Results.List
+			if len(results) != 2 {
+				continue // Field extraction helpers are not encoding acceptors.
+			}
+			result, ok := results[1].Type.(*ast.Ident)
+			if !ok || result.Name != "bool" {
+				continue
+			}
+			if !registered[fn.Name.Name] {
+				t.Errorf("%s has no shared effects/lowering family", fn.Name.Name)
+			}
+			delete(registered, fn.Name.Name)
+		}
+	}
+	for name := range registered {
+		t.Errorf("%s was registered outside the reviewed state families", name)
+	}
+}
diff --git a/arm64_raw_state_families.go b/arm64_raw_state_families.go
new file mode 100644
index 000000000..ae3b233fa
--- /dev/null
+++ b/arm64_raw_state_families.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+// The state-bank and memory families below are not exceptions or native calls.
+// In particular, "~{memory}" on an inline asm is a compiler ordering barrier,
+// not evidence that an instruction stores to arbitrary source stack memory.
+var arm64RawStateFamilies = [...]arm64RawFamily{
+	arm64RawForm(decodeARM64RawNZCV, (*arm64Ctx).lowerARM64NZCV,
+		func(form arm64NZCVForm) arm64RawContinuationEffects {
+			reads, writes := form.gpEffects()
+			return arm64RawContinuationEffects{gpReads: reads, gpWrites: writes}
+		}),
+	arm64RawForm(decodeARM64RawDCZVA, (*arm64Ctx).lowerARM64CacheForm,
+		func(form arm64CacheForm) arm64RawContinuationEffects {
+			index, gp := arm64StackIndex(form.address)
+			if !gp || form.address == ZR {
+				return arm64RawContinuationEffects{stores: true}
+			}
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(index), stores: true}
+		}),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawStreamingModeControl, (*arm64Ctx).lowerRawStreamingModeControl),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawZAZero, (*arm64Ctx).lowerRawZAZero),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSMEOuterProduct, (*arm64Ctx).lowerRawSMEOuterProduct),
+	arm64RawForm(decodeARM64RawSMETileRead, (*arm64Ctx).lowerRawSMETileRead,
+		func(form arm64RawSMETileRead) arm64RawContinuationEffects {
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(form.row)}
+		}),
+	arm64RawForm(decodeARM64RawSMETileWrite, (*arm64Ctx).lowerRawSMETileWrite,
+		func(form arm64RawSMETileRead) arm64RawContinuationEffects {
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(form.row)}
+		}),
+	arm64RawForm(decodeARM64RawSMETileMemory, (*arm64Ctx).lowerRawSMETileMemory,
+		func(form arm64RawSMETileMemory) arm64RawContinuationEffects {
+			return arm64RawContinuationEffects{
+				gpReads: arm64RawGPBit(form.row) | arm64RawGPBit(form.base) | arm64RawGPBit(form.offset),
+				readsSP: form.base == 31,
+				stores:  form.store,
+			}
+		}),
+	arm64RawForm(decodeARM64RawICIVAU, (*arm64Ctx).lowerRawICIVAU,
+		func(reg Reg) arm64RawContinuationEffects {
+			index, gp := arm64StackIndex(reg)
+			if !gp || reg == ZR {
+				return arm64RawContinuationEffects{}
+			}
+			return arm64RawContinuationEffects{gpReads: arm64RawGPBit(index)}
+		}),
+	arm64RawForm(decodeARM64RawRNDR, (*arm64Ctx).lowerRawRNDR,
+		func(form arm64RawRNDR) arm64RawContinuationEffects {
+			return arm64RawContinuationEffects{gpWrites: arm64RawGPBit(form.reg)}
+		}),
+	arm64RawForm(decodeARM64RawCASP, (*arm64Ctx).lowerRawCASP,
+		func(form arm64RawCASP) arm64RawContinuationEffects {
+			expected := arm64RawGPBit(form.expected) | arm64RawGPBit(form.expected+1)
+			newValue := arm64RawGPBit(form.newValue) | arm64RawGPBit(form.newValue+1)
+			return arm64RawContinuationEffects{
+				gpReads:  expected | newValue | arm64RawGPBit(form.base),
+				gpWrites: expected,
+				readsSP:  form.base == 31,
+				stores:   true,
+			}
+		}),
+}
+
+func decodeARM64RawStateFamily(word uint32) (arm64RawFamily, arm64RawContinuationEffects, bool) {
+	for _, family := range arm64RawStateFamilies {
+		if effects, ok := family.effects(word); ok {
+			return family, effects, true
+		}
+	}
+	return arm64RawFamily{}, arm64RawContinuationEffects{}, false
+}
diff --git a/arm64_raw_structure_lane_test.go b/arm64_raw_structure_lane_test.go
new file mode 100644
index 000000000..027cafef8
--- /dev/null
+++ b/arm64_raw_structure_lane_test.go
@@ -0,0 +1,278 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64RawStructureLanePost int
+
+const (
+	arm64RawStructureLaneNoPost arm64RawStructureLanePost = iota
+	arm64RawStructureLaneFixedPost
+	arm64RawStructureLaneRegisterPost
+)
+
+func encodeARM64RawStructureLane(load bool, count, elementBits, lane int, post arm64RawStructureLanePost, postRegister, base, firstRegister int) uint32 {
+	word := uint32(0x0d000000 | base<<5 | firstRegister)
+	if load {
+		word |= 1 << 22
+	}
+	if count%2 == 0 {
+		word |= 1 << 21
+	}
+	if count >= 3 {
+		word |= 1 << 13
+	}
+	if post != arm64RawStructureLaneNoPost {
+		word |= 1 << 23
+		if post == arm64RawStructureLaneFixedPost {
+			postRegister = 31
+		}
+		word |= uint32(postRegister) << 16
+	}
+	switch elementBits {
+	case 8:
+		word |= uint32(lane>>3) << 30
+		word |= uint32(lane&7) << 10
+	case 16:
+		word |= 1 << 14
+		word |= uint32(lane>>2) << 30
+		word |= uint32(lane&3) << 11
+	case 32:
+		word |= 1 << 15
+		word |= uint32(lane>>1) << 30
+		word |= uint32(lane&1) << 12
+	case 64:
+		word |= 1 << 15
+		word |= 1 << 10
+		word |= uint32(lane) << 30
+	default:
+		panic("invalid ARM64 structure-lane element width")
+	}
+	return word
+}
+
+func TestTranslateARM64RawStructureLaneReportedEncoding(t *testing.T) {
+	const source = `TEXT rawStructureLane(SB),$0-0
+	WORD $0x0da14010 // ST2 {V16.H, V17.H}[0], [R0], R1
+	RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "aarch64-unknown-linux-gnu",
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{
+			"rawStructureLane": {Name: "rawStructureLane", Ret: Void},
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawStructureLaneDecoderCoversCompleteArchitectureFamily(t *testing.T) {
+	for _, load := range []bool{false, true} {
+		for count := 1; count <= 4; count++ {
+			for _, elementBits := range []int{8, 16, 32, 64} {
+				for lane := 0; lane < 128/elementBits; lane++ {
+					for _, post := range []arm64RawStructureLanePost{
+						arm64RawStructureLaneNoPost,
+						arm64RawStructureLaneFixedPost,
+						arm64RawStructureLaneRegisterPost,
+					} {
+						word := encodeARM64RawStructureLane(load, count, elementBits, lane, post, 17, 31, 31)
+						form, ok := decodeARM64RawStructureLane(word)
+						wantPostRegister := 0
+						if post == arm64RawStructureLaneFixedPost {
+							wantPostRegister = 31
+						} else if post == arm64RawStructureLaneRegisterPost {
+							wantPostRegister = 17
+						}
+						if !ok || form.load != load || form.count != count || form.elementBits != elementBits ||
+							form.lane != lane || form.firstRegister != 31 || form.base != 31 ||
+							form.post != (post != arm64RawStructureLaneNoPost) || form.postRegister != wantPostRegister {
+							t.Fatalf("decode load=%v count=%d bits=%d lane=%d post=%d word=%#08x: form=%#v ok=%v",
+								load, count, elementBits, lane, post, word, form, ok)
+						}
+						decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+						if err != nil {
+							t.Fatalf("architecture decoder rejected %#08x: %v", word, err)
+						}
+						wantPrefix := map[bool]string{false: "ST", true: "LD"}[load]
+						if count == 1 {
+							wantPrefix = "V" + wantPrefix
+						}
+						wantOp := fmt.Sprintf("%s%d", wantPrefix, count)
+						if strings.TrimSuffix(string(decoded.Op), ".P") != wantOp {
+							t.Fatalf("architecture decoder decoded %#08x as %s, want %s", word, decoded.Op, wantOp)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawStructureLaneDecoderRejectsAdjacentEncodings(t *testing.T) {
+	validB := encodeARM64RawStructureLane(true, 1, 8, 0, arm64RawStructureLaneNoPost, 0, 0, 0)
+	validH := encodeARM64RawStructureLane(true, 2, 16, 0, arm64RawStructureLaneNoPost, 0, 0, 0)
+	validS := encodeARM64RawStructureLane(false, 3, 32, 0, arm64RawStructureLaneNoPost, 0, 0, 0)
+	validD := encodeARM64RawStructureLane(false, 4, 64, 0, arm64RawStructureLaneNoPost, 0, 0, 0)
+	for _, word := range []uint32{
+		validB | 3<<14, // load-and-replicate opcode space
+		validH | 1<<10,
+		validS | 1<<11,
+		validD | 1<<12,
+		validB | 1<<16, // Rm is reserved without post-indexing
+		validB | 1<<29,
+	} {
+		if form, ok := decodeARM64RawStructureLane(word); ok {
+			t.Fatalf("decoded reserved or adjacent encoding %#08x as %#v", word, form)
+		}
+	}
+}
+
+func TestTranslateARM64RawStructureLaneCompleteArchitectureFamily(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawStructureLaneArchitectureForms(SB),$0-0\n")
+	for _, load := range []bool{false, true} {
+		for count := 1; count <= 4; count++ {
+			for _, elementBits := range []int{8, 16, 32, 64} {
+				for _, lane := range []int{0, 128/elementBits - 1} {
+					for _, post := range []arm64RawStructureLanePost{
+						arm64RawStructureLaneNoPost,
+						arm64RawStructureLaneFixedPost,
+						arm64RawStructureLaneRegisterPost,
+					} {
+						word := encodeARM64RawStructureLane(load, count, elementBits, lane, post, 21, 20, 31)
+						fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+					}
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin",
+		"aarch64-unknown-linux-gnu",
+		"aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawStructureLaneArchitectureForms": {Name: "rawStructureLaneArchitectureForms", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"load i", "store i", "insertelement", "extractelement", "add i64"} {
+				if !strings.Contains(ll, operation) {
+					t.Fatalf("%s omitted %s semantics:\n%s", triple, operation, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-structure-lane.ll", "arm64-raw-structure-lane.o", ll)
+		})
+	}
+}
+
+func TestARM64RawStructureLaneRuntimeSemantics(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("runtime execution test requires a Darwin arm64 host")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	load4H := encodeARM64RawStructureLane(true, 4, 16, 3, arm64RawStructureLaneNoPost, 0, 0, 8)
+	store4HPost := encodeARM64RawStructureLane(false, 4, 16, 3, arm64RawStructureLaneFixedPost, 0, 4, 8)
+	load3SPost := encodeARM64RawStructureLane(true, 3, 32, 2, arm64RawStructureLaneRegisterPost, 5, 0, 12)
+	source := fmt.Sprintf(`TEXT rawStructureLaneSemantics(SB),$0-32
+	MOVD input+0(FP), R0
+	MOVD initial+8(FP), R1
+	MOVD output+16(FP), R2
+	MOVD updates+24(FP), R3
+	VLD1.P 64(R1), [V8.B16, V9.B16, V10.B16, V11.B16]
+	VLD1.P 48(R1), [V12.B16, V13.B16, V14.B16]
+	WORD $%#08x
+	VST1 [V8.B16, V9.B16, V10.B16, V11.B16], (R2)
+	ADD $64, R2, R4
+	WORD $%#08x
+	MOVD R4, 0(R3)
+	MOVD $12, R5
+	WORD $%#08x
+	MOVD R0, 8(R3)
+	ADD $80, R2, R6
+	VST1.P [V12.B16, V13.B16, V14.B16], 48(R6)
+	RET
+`, load4H, store4HPost, load3SPost)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ll, err := Translate(file, Options{
+		TargetTriple: triple,
+		Goarch:       "arm64",
+		Sigs: map[string]FuncSig{"rawStructureLaneSemantics": {
+			Name: "rawStructureLaneSemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = `
+#include <stdint.h>
+#include <string.h>
+extern void rawStructureLaneSemantics(const uint8_t *, const uint8_t *, uint8_t *, uintptr_t *);
+int main(void) {
+  uint8_t input[32], initial[112], output[128] = {0};
+  uintptr_t updates[2] = {0};
+  for (int i = 0; i < 32; i++) input[i] = (uint8_t)(i * 7u + 3u);
+  for (int i = 0; i < 112; i++) initial[i] = (uint8_t)(i * 11u + 5u);
+  rawStructureLaneSemantics(input, initial, output, updates);
+  for (int reg = 0; reg < 4; reg++) {
+    for (int byte = 0; byte < 16; byte++) {
+      uint8_t want = initial[reg * 16 + byte];
+      if (byte == 6 || byte == 7) want = input[reg * 2 + byte - 6];
+      if (output[reg * 16 + byte] != want) return 1 + reg * 16 + byte;
+    }
+  }
+  if (memcmp(output + 64, input, 8) != 0) return 70;
+  for (int reg = 0; reg < 3; reg++) {
+    for (int byte = 0; byte < 16; byte++) {
+      uint8_t want = initial[64 + reg * 16 + byte];
+      if (byte >= 8 && byte < 12) want = input[reg * 4 + byte - 8];
+      if (output[80 + reg * 16 + byte] != want) return 80 + reg * 16 + byte;
+    }
+  }
+  if (updates[0] != (uintptr_t)(output + 72)) return 201;
+  if (updates[1] != (uintptr_t)(input + 12)) return 202;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_structure_lane", triple, ll, mainC, nil)
+}
diff --git a/arm64_raw_structure_test.go b/arm64_raw_structure_test.go
new file mode 100644
index 000000000..6f5cb515d
--- /dev/null
+++ b/arm64_raw_structure_test.go
@@ -0,0 +1,302 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type arm64RawStructureCase struct {
+	op, arrangement, syntax string
+	word                    uint32
+	count, bits, lanes      int
+	base, first, post       int // post: 0 = none, 1 = fixed, 2 = register
+	load, replicate         bool
+}
+
+// Enumerate the complete cmd/internal/obj/arm64/asm7.go C_LIST family:
+// load rows 81, store rows 84, and maskOpvldvst's opcode/count mapping.
+// Do not use the production decoder to construct its own expected answers.
+func arm64RawStructureCases() []arm64RawStructureCase {
+	var cases []arm64RawStructureCase
+	for _, load := range []bool{false, true} {
+		for _, replicate := range []bool{false, true} {
+			if replicate && !load {
+				continue
+			}
+			for structure := 1; structure <= 4; structure++ {
+				for count := 1; count <= 4; count++ {
+					if (replicate || structure != 1) && count != structure {
+						continue
+					}
+					for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D1", "D2"} {
+						if arrangement == "D1" && !replicate && structure != 1 {
+							continue // reserved multiple-structure Q=0, size=3
+						}
+						bits := map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[arrangement[0]]
+						lanes, _ := strconv.Atoi(arrangement[1:])
+						for _, registers := range [][2]int{{3, 25}, {31, 30}} {
+							for post := 0; post < 3; post++ {
+								base, first := registers[0], registers[1]
+								op := fmt.Sprintf("VST%d", structure)
+								word := uint32(0x0c000000)
+								if load {
+									op = fmt.Sprintf("VLD%d", structure)
+									word |= 1 << 22
+								}
+								if replicate {
+									op += "R"
+									word = 0x0d40c000 | uint32((count-1)%2)<<21 | uint32((count-1)/2)<<13
+								} else if structure == 1 {
+									word |= map[int]uint32{1: 7, 2: 10, 3: 6, 4: 2}[count] << 12
+								} else {
+									word |= map[int]uint32{2: 8, 3: 4, 4: 0}[structure] << 12
+								}
+								if bits*lanes == 128 {
+									word |= 1 << 30
+								}
+								word |= map[int]uint32{8: 0, 16: 1, 32: 2, 64: 3}[bits]<<10 | uint32(base)<<5 | uint32(first)
+								baseName := fmt.Sprintf("R%d", base)
+								if base == 31 {
+									baseName = "RSP"
+								}
+								memory := "(" + baseName + ")"
+								suffix := ""
+								if post != 0 {
+									suffix = ".P"
+									word |= 1 << 23
+									if post == 1 {
+										word |= 31 << 16
+										increment := count * bits * lanes / 8
+										if replicate {
+											increment = count * bits / 8
+										}
+										memory = strconv.Itoa(increment) + memory
+									} else {
+										word |= 7 << 16
+										memory += "(R7)"
+									}
+								}
+								list := arm64TestVectorList(first, count, arrangement)
+								syntax := op + suffix + " " + list + ", " + memory
+								if load {
+									syntax = op + suffix + " " + memory + ", " + list
+								}
+								cases = append(cases, arm64RawStructureCase{op, arrangement, syntax, word, count, bits, lanes, base, first, post, load, replicate})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func TestARM64RawStructureReportedVST4(t *testing.T) {
+	const source = "TEXT rawStructureReported(SB),$0-0\nWORD $0x0c9f0079\nRET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: map[string]FuncSig{
+		"rawStructureReported": {Name: "rawStructureReported", Ret: Void},
+	}}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64RawStructureRejectsReservedEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0x0c018079, // Rm is reserved without post-indexing.
+		0x0c008c79, // ST2 with Q=0 and size=3 is reserved.
+		0x0c208079, // Reserved bit 21 in the multiple-structure space.
+	} {
+		if decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}); err == nil {
+			t.Fatalf("decoded reserved structure encoding %#08x as %s", word, decoded.Raw)
+		}
+	}
+	// Bit 29 selects the adjacent vector-pair instruction space, not an
+	// invalid structure encoding. It must retain its own opcode and grammar.
+	decoded, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0x2c008079}}})
+	if err != nil || decoded.Op != "VSTNP" {
+		t.Fatalf("adjacent vector-pair decoding = %s, %v; want VSTNP", decoded.Raw, err)
+	}
+}
+
+func TestARM64RawStructureCompleteGoForms(t *testing.T) {
+	cases := arm64RawStructureCases()
+	var named, raw strings.Builder
+	// Post-indexed address-bank SP is a real write. R18_PLATFORM is never
+	// an output of these vector forms; restore source SP before returning.
+	named.WriteString("TEXT rawStructureForms(SB),$0-0\nMOVD RSP,R18_PLATFORM\n")
+	raw.WriteString("TEXT rawStructureForms(SB),$0-0\nMOVD RSP,R18_PLATFORM\n")
+	for _, test := range cases {
+		fmt.Fprintln(&named, test.syntax)
+		fmt.Fprintf(&raw, "WORD $%#08x\n", test.word)
+	}
+	named.WriteString("MOVD R18_PLATFORM,RSP\nRET\n")
+	raw.WriteString("MOVD R18_PLATFORM,RSP\nRET\n")
+	// These forms predate Go 1.20, so use each compatibility lane's real
+	// assembler. Checking WORD acceptance alone cannot validate an encoding.
+	code := assembleARM64StructureTestBytes(t, named.String())
+	if len(code) < 4*(len(cases)+3) {
+		t.Fatalf("Go assembler emitted %d bytes for %d instructions", len(code), len(cases)+3)
+	}
+	for i, test := range cases {
+		if got := binary.LittleEndian.Uint32(code[4*(i+1):]); got != test.word {
+			t.Fatalf("Go encoded %s as %#08x, fixture expected %#08x", test.syntax, got, test.word)
+		}
+	}
+	file, err := Parse(ArchARM64, named.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for i, test := range cases {
+		got, err := decodeARM64RawWordInstruction(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(test.word)}}})
+		if err != nil {
+			t.Fatalf("decode %s (%#08x): %v", test.syntax, test.word, err)
+		}
+		want := file.Funcs[0].Instrs[i+2]
+		if got.Op != want.Op || !reflect.DeepEqual(got.Args, want.Args) {
+			t.Fatalf("decode %#08x = %s %+v; want %s %+v", test.word, got.Op, got.Args, want.Op, want.Args)
+		}
+	}
+	t.Logf("checked %d exact Go encodings and typed operand forms", len(cases))
+	file, err = Parse(ArchARM64, raw.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"rawStructureForms": {Name: "rawStructureForms", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-structure.ll", "raw-structure.o", ir)
+		})
+	}
+}
+
+func assembleARM64StructureTestBytes(t *testing.T, source string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "forms.s")
+	if err := os.WriteFile(path, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "forms.o"), path)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go assembler rejected structure family: %v\n%s", err, out)
+	}
+	var code []byte
+	for _, line := range strings.Split(string(out), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseUint(fields[0][2:], 16, 32)
+		if err != nil || int(offset) != len(code) {
+			t.Fatalf("noncontiguous Go instruction bytes: %s", line)
+		}
+		for _, field := range fields[1:] {
+			if len(field) != 2 {
+				break
+			}
+			value, err := strconv.ParseUint(field, 16, 8)
+			if err != nil {
+				break
+			}
+			code = append(code, byte(value))
+		}
+	}
+	return code
+}
+
+func TestARM64RawStructureRuntimeSemantics(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	if runtime.GOARCH != "arm64" || (runtime.GOOS != "darwin" && runtime.GOOS != "linux") {
+		t.Skip("native structure execution requires a Darwin or Linux ARM64 host; the complete object matrix runs on every host")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for i, test := range arm64RawStructureCases() {
+		if test.base != 3 {
+			continue // SP and wraparound are covered by the all-host matrix.
+		}
+		name := fmt.Sprintf("rawStructure%d", i)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: I64}
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\nMOVD $5,R7\n", name)
+		list := arm64TestVectorList(test.first, test.count, test.arrangement)
+		if test.load {
+			fmt.Fprintf(&source, "MOVD R0,R3\nWORD $%#08x\nVST1 %s,(R1)\n", test.word, list)
+		} else {
+			fmt.Fprintf(&source, "MOVD R1,R3\nVLD1 (R0),%s\nWORD $%#08x\n", list, test.word)
+		}
+		source.WriteString("MOVD R3,R0\nRET\n")
+		fmt.Fprintf(&declarations, "extern uintptr_t %s(const unsigned char *, unsigned char *);\n", name)
+		checks.WriteString("memset(output, 0xcc, sizeof(output)); memset(expected, 0xcc, sizeof(expected));\n")
+		for reg := 0; reg < test.count; reg++ {
+			for lane := 0; lane < test.lanes; lane++ {
+				linear := (reg*test.lanes + lane) * test.bits / 8
+				structured := (lane*test.count + reg) * test.bits / 8
+				if test.op == "VLD1" || test.op == "VST1" {
+					structured = linear
+				}
+				if test.replicate {
+					structured = reg * test.bits / 8
+				}
+				from, to := linear, structured
+				if test.load {
+					from, to = structured, linear
+				}
+				fmt.Fprintf(&checks, "memcpy(expected+3+%d, input+1+%d, %d);\n", to, from, test.bits/8)
+			}
+		}
+		base := "output+3"
+		if test.load {
+			base = "input+1"
+		}
+		increment := 0
+		if test.post == 1 {
+			increment = test.count * test.bits * test.lanes / 8
+			if test.replicate {
+				increment = test.count * test.bits / 8
+			}
+		} else if test.post == 2 {
+			increment = 5
+		}
+		fmt.Fprintf(&checks, "if (%s(input+1,output+3) != (uintptr_t)(%s+%d) || memcmp(output,expected,sizeof(output))) { fprintf(stderr, \"%s failed\\n\"); return 1; }\n", name, base, increment, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() +
+		"int main(void) { unsigned char input[160], output[160], expected[160]; for (int i=0;i<160;i++) input[i]=(unsigned char)(i*37+11);\n" + checks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "arm64_raw_structure", triple, ir, mainC, nil)
+	t.Logf("executed %d raw structure load/store/replicate cases with unaligned buffers and writeback checks", len(sigs))
+}
diff --git a/arm64_raw_sve_add_sub_wide_runtime_test.go b/arm64_raw_sve_add_sub_wide_runtime_test.go
new file mode 100644
index 000000000..ef7f15158
--- /dev/null
+++ b/arm64_raw_sve_add_sub_wide_runtime_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEAddSubWideRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		op, name string
+		size     int
+		native   []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for _, op := range arm64SVEAddSubWideNativeOps {
+		for size := 1; size < 4; size++ {
+			for _, destination := range []int{31, 30, 29} {
+				native := []string{
+					"ptrue p0.b", "ld1b { z30.b }, p0/z, [x0]", "ld1b { z29.b }, p0/z, [x1]",
+					arm64SVEAddSubWideAssembly(op, size, destination, 30, 29),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x2]", destination),
+				}
+				cases = append(cases, runtimeCase{op, fmt.Sprintf("add_sub_wide_%d", len(cases)), size, native})
+				allNative = append(allNative, native...)
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve2")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEAddSubWideRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", test.name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[test.name] = FuncSig{Name: test.name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [out]"r"(out)
+    : "p0", "z29", "z30", "z31", "memory");
+}
+`, test.name, assembly)
+		signed, subtract, top := 0, 0, 0
+		if test.op[0] == 's' {
+			signed = 1
+		}
+		if strings.Contains(test.op, "sub") {
+			subtract = 1
+		}
+		if strings.HasSuffix(test.op, "t") {
+			top = 1
+		}
+		fmt.Fprintf(&checks, "  if (check_add_sub_wide(vl, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			1<<test.size, signed, subtract, top, test.name, test.name, test.name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_add_sub_wide", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEAddSubWideRuntimeReference = `
+typedef void (*add_sub_wide_fn)(const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_add_sub_wide(unsigned vl, unsigned bytes, int signed_input, int subtract,
+    int top, add_sub_wide_fn translated, add_sub_wide_fn native_instruction, const char *name) {
+  unsigned char a[256], b[256], got[256], native[256], scalar[256];
+  const unsigned narrow = bytes / 2, narrow_bits = narrow * 8;
+  uint64_t maximum = UINT64_MAX >> (64 - narrow_bits), sign = UINT64_C(1) << (narrow_bits - 1);
+  uint64_t values[] = {0, 1, maximum, sign, sign - 1, sign + 1, 2, 3};
+  for (unsigned phase = 0; phase < 16; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i++) a[i] = phase == 0 ? 0xff : i * 71 + phase * 53;
+    for (unsigned i = 0; i < sizeof(b); i += narrow) {
+      uint64_t value = phase < 8 ? values[(i / narrow + phase) % 8] : 0x456789abcdef0123ULL * (i + phase);
+      memcpy(b + i, &value, narrow);
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      uint64_t x = 0, y = 0;
+      memcpy(&x, a + i, bytes);
+      memcpy(&y, b + i + top * narrow, narrow);
+      if (signed_input && (y & sign)) y |= ~maximum;
+      uint64_t value = subtract ? x - y : x + y;
+      memcpy(scalar + i, &value, bytes);
+    }
+    native_instruction(a, b, native);
+    translated(a, b, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u\n", name, vl, phase);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_add_sub_wide_test.go b/arm64_raw_sve_add_sub_wide_test.go
new file mode 100644
index 000000000..954c0774b
--- /dev/null
+++ b/arm64_raw_sve_add_sub_wide_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var arm64SVEAddSubWideNativeOps = []string{
+	"saddwb", "saddwt", "ssubwb", "ssubwt", "uaddwb", "uaddwt", "usubwb", "usubwt",
+}
+
+func arm64SVEAddSubWideAssembly(op string, size, dst, first, second int) string {
+	return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c", op, dst, "bhsd"[size], first, "bhsd"[size], second, "bhsd"[size-1])
+}
+
+func TestARM64RawSVEAddSubWideCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, op := range arm64SVEAddSubWideNativeOps {
+		for size := 1; size < 4; size++ {
+			lines = append(lines, arm64SVEAddSubWideAssembly(op, size, 31, 30, 29))
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawaddsubwide(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawaddsubwide": {Name: "rawaddsubwide", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawaddsubwide.ll", "rawaddsubwide.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEAddSubWideOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, op := range arm64SVEAddSubWideNativeOps {
+		for size := 1; size < 4; size++ {
+			for field := 0; field < 3; field++ {
+				for value := 0; value < 32; value++ {
+					registers := [3]int{31, 30, 29}
+					registers[field] = value
+					dst, first, second := registers[0], registers[1], registers[2]
+					lines = append(lines, arm64SVEAddSubWideAssembly(op, size, dst, first, second))
+					wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(op)), Args: []Operand{
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", second, "BHSD"[size-1]))},
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", first, "BHSD"[size]))},
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", dst, "BHSD"[size]))},
+					}})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVEAddSubWide(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+		if got, ok := decodeARM64RawSVEAddSubWide(word &^ (3 << 22)); ok {
+			t.Fatalf("unallocated byte destination decoded as %+v", got)
+		}
+	}
+	for _, word := range []uint32{0, 0x45400000, 0x45406000, 0x45c08000} {
+		if got, ok := decodeARM64RawSVEAddSubWide(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_address_generation_runtime_test.go b/arm64_raw_sve_address_generation_runtime_test.go
new file mode 100644
index 000000000..ba1c6d105
--- /dev/null
+++ b/arm64_raw_sve_address_generation_runtime_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEAddressGenerationRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		name        string
+		mode, shift int
+		native      []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for mode := 0; mode < 4; mode++ {
+		for shift := 0; shift < 4; shift++ {
+			for _, destination := range []int{31, 30, 29} {
+				native := []string{
+					"ptrue p0.b", "ld1b { z30.b }, p0/z, [x0]", "ld1b { z29.b }, p0/z, [x1]",
+					arm64SVEAddressGenerationAssembly(mode, shift, destination, 30, 29),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x2]", destination),
+				}
+				cases = append(cases, runtimeCase{fmt.Sprintf("address_generation_%d", len(cases)), mode, shift, native})
+				allNative = append(allNative, native...)
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEAddressGenerationRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", test.name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[test.name] = FuncSig{Name: test.name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [out]"r"(out)
+    : "p0", "z29", "z30", "z31", "memory");
+}
+`, test.name, assembly)
+		fmt.Fprintf(&checks, "  if (check_address_generation(vl, %d, %d, %s, %s_native, %q)) return 1;\n",
+			test.mode, test.shift, test.name, test.name, test.name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_address_generation", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEAddressGenerationRuntimeReference = `
+typedef void (*address_generation_fn)(const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_address_generation(unsigned vl, unsigned mode, unsigned shift,
+    address_generation_fn translated, address_generation_fn native_instruction, const char *name) {
+  unsigned char base[256], index[256], got[256], native[256], scalar[256];
+  const unsigned bytes = mode == 2 ? 4 : 8;
+  const uint64_t values[] = {0, 1, UINT64_MAX, UINT64_C(0x80000000), UINT64_C(0x7fffffff),
+    UINT64_C(0x8000000000000000), UINT64_C(0xffffffff00000001), UINT64_C(0x12345678ffffffff)};
+  for (unsigned phase = 0; phase < 16; phase++) {
+    for (unsigned i = 0; i < sizeof(base); i += bytes) {
+      uint64_t a = values[(i / bytes + phase) % 8];
+      uint64_t b = values[(i / bytes * 3 + phase / 2) % 8];
+      memcpy(base + i, &a, bytes);
+      memcpy(index + i, &b, bytes);
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      uint64_t a = 0, b = 0;
+      memcpy(&a, base + i, bytes);
+      memcpy(&b, index + i, bytes);
+      if (mode == 0 || mode == 1) {
+        b &= UINT64_C(0xffffffff);
+        if (mode == 0 && (b & UINT64_C(0x80000000))) b |= UINT64_C(0xffffffff00000000);
+      }
+      uint64_t value = a + (b << shift);
+      memcpy(scalar + i, &value, bytes);
+    }
+    native_instruction(base, index, native);
+    translated(base, index, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u\n", name, vl, phase);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_address_generation_test.go b/arm64_raw_sve_address_generation_test.go
new file mode 100644
index 000000000..df26a60e4
--- /dev/null
+++ b/arm64_raw_sve_address_generation_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SVEAddressGenerationAssembly(mode, shift, dst, base, index int) string {
+	width, modifier := byte('d'), "lsl"
+	switch mode {
+	case 0:
+		modifier = "sxtw"
+	case 1:
+		modifier = "uxtw"
+	case 2:
+		width = 's'
+	}
+	return fmt.Sprintf("adr z%d.%c, [z%d.%c, z%d.%c, %s #%d]", dst, width, base, width, index, width, modifier, shift)
+}
+
+func TestARM64RawSVEAddressGenerationCompleteFormats(t *testing.T) {
+	var lines []string
+	for mode := 0; mode < 4; mode++ {
+		for shift := 0; shift < 4; shift++ {
+			lines = append(lines, arm64SVEAddressGenerationAssembly(mode, shift, 31, 30, 29))
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawaddressgeneration(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawaddressgeneration": {Name: "rawaddressgeneration", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawaddressgeneration.ll", "rawaddressgeneration.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEAddressGenerationOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for mode := 0; mode < 4; mode++ {
+		for shift := 0; shift < 4; shift++ {
+			for field := 0; field < 3; field++ {
+				for value := 0; value < 32; value++ {
+					fields := [3]int{31, 30, 29}
+					fields[field] = value
+					dst, base, index := fields[0], fields[1], fields[2]
+					lines = append(lines, arm64SVEAddressGenerationAssembly(mode, shift, dst, base, index))
+					width := byte('D')
+					if mode == 2 {
+						width = 'S'
+					}
+					reg := func(number int) Reg { return Reg(fmt.Sprintf("Z%d.%c", number, width)) }
+					extension := [...]ExtendOp{ExtendSXTW, ExtendUXTW, "", ""}[mode]
+					wants = append(wants, Instr{Op: "ZADR", Args: []Operand{
+						{Kind: OpMem, Mem: MemRef{Base: reg(base), Index: reg(index), IndexExt: extension, Scale: 1 << shift}},
+						{Kind: OpReg, Reg: reg(dst)},
+					}})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVEAddressGeneration(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0, 0x0420b000, 0x04208000, 0x0400a000} {
+		if got, ok := decodeARM64RawSVEAddressGeneration(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_compact_runtime_test.go b/arm64_raw_sve_compact_runtime_test.go
new file mode 100644
index 000000000..c3209fee0
--- /dev/null
+++ b/arm64_raw_sve_compact_runtime_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVECompactRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	// QEMU's baseline SVE covers S/D. B/H require SVE2.2 and have independent
+	// assembler and object tests; they are not claimed as executed here.
+	for _, width := range []struct {
+		suffix string
+		bytes  int
+	}{{"s", 4}, {"d", 8}} {
+		for _, destination := range []int{30, 31} {
+			name := fmt.Sprintf("compact_%s_%d", width.suffix, destination)
+			native := []string{
+				"ptrue p0.b",
+				"ld1b { z30.b }, p0/z, [x0]",
+				"ld1b { z1.b }, p0/z, [x1]",
+				fmt.Sprintf("cmpeq p7.%s, p0/z, z1.%s, #0", width.suffix, width.suffix),
+				fmt.Sprintf("compact z%d.%s, p7, z30.%s", destination, width.suffix, width.suffix),
+				fmt.Sprintf("st1b { z%d.b }, p0, [x2]", destination),
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+			for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+			assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+			fmt.Fprintf(&checks, `    {
+      const unsigned element = %d;
+      for (unsigned pattern = 0; pattern < 12; pattern++) {
+        unsigned char a[256], b[256] = {0}, got[256], want[256], oracle[256];
+        for (unsigned i = 0; i < vl; i++) a[i] = (i * 17 + pattern * 43) %% 251 + 1;
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        memset(oracle, 0x5a, sizeof(oracle));
+        memset(oracle, 0, vl);
+        unsigned count = 0;
+        for (unsigned i = 0; i < vl / element; i++) {
+          b[i * element] = pattern < 2 ? pattern : ((i * 17 + pattern) %% 7) < 3;
+          if (b[i * element] == 0) {
+            memcpy(oracle + count * element, a + i * element, element);
+            count++;
+          }
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [out]"r"(want)
+          : "p0", "p7", "z1", "z30", "z31", "memory");
+        %s(a, b, got);
+        if (memcmp(got, want, sizeof(got)) != 0 || memcmp(got, oracle, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u pattern=%%u\n", vl, pattern);
+          return %d;
+        }
+      }
+    }
+`, width.bytes, assembly, name, name, len(sigs))
+		}
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_compact", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_compact_test.go b/arm64_raw_sve_compact_test.go
new file mode 100644
index 000000000..9109e6603
--- /dev/null
+++ b/arm64_raw_sve_compact_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVECompactCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, width := range []string{"b", "h", "s", "d"} {
+		lines = append(lines, fmt.Sprintf("compact z31.%s, p7, z30.%s", width, width))
+	}
+	source.WriteString("TEXT rawcompact(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawcompact": {Name: "rawcompact", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawcompact.ll", "rawcompact.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVECompactOperandFields(t *testing.T) {
+	var lines []string
+	var args [][]Reg
+	for _, width := range []string{"b", "h", "s", "d"} {
+		for field, limit := range []int{32, 8, 32} {
+			for register := 0; register < limit; register++ {
+				registers := [3]int{31, 7, 30}
+				registers[field] = register
+				destination := fmt.Sprintf("Z%d.%s", registers[0], strings.ToUpper(width))
+				predicate := fmt.Sprintf("P%d", registers[1])
+				source := fmt.Sprintf("Z%d.%s", registers[2], strings.ToUpper(width))
+				lines = append(lines, "compact "+destination+", "+predicate+", "+source)
+				args = append(args, []Reg{Reg(source), Reg(predicate), Reg(destination)})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p2") {
+		got, ok := decodeARM64RawSVECompact(word)
+		if !ok || got.Op != "ZCOMPACT" || len(got.Args) != 3 {
+			t.Fatalf("%s: decoded %#08x as %+v, %v", lines[i], word, got, ok)
+		}
+		for j, register := range args[i] {
+			if got.Args[j].Reg != register {
+				t.Errorf("%s: operand %d = %s, want %s", lines[i], j, got.Args[j].Reg, register)
+			}
+		}
+	}
+	for _, word := range []uint32{0x05208000, 0x05218000 ^ 0x2000, 0x05218000 ^ 0x4000, 0x04218000} {
+		if got, ok := decodeARM64RawSVECompact(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_copy_runtime_test.go b/arm64_raw_sve_copy_runtime_test.go
new file mode 100644
index 000000000..f0b95b6c0
--- /dev/null
+++ b/arm64_raw_sve_copy_runtime_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVECopyRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64RawSVECopyForms() {
+		// SP is validated as an operand, not compared between different frames.
+		if strings.HasSuffix(form, "sp") {
+			continue
+		}
+		name := fmt.Sprintf("copy_%d", len(sigs))
+		form = strings.NewReplacer("w30", "w10", "x30", "x10").Replace(form)
+		native := []string{
+			"ptrue p0.b",
+			"ld1b { z31.b }, p0/z, [x0]",
+			"ld1b { z30.b }, p0/z, [x1]",
+			"ldr x10, [x1]",
+			"ld1b { z1.b }, p0/z, [x2]",
+			"cmpne p7.b, p0/z, z1.b, #0",
+			"orr p15.b, p0/z, p7.b, p7.b",
+			form,
+			"st1b { z31.b }, p0, [x3]",
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+		fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], mask[256], got[256], want[256];
+      for (unsigned pattern = 0; pattern < 8; pattern++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = (i * 17 + pattern * 29) %% 251 + 1;
+          b[i] = (i * 31 + pattern * 131) & 255;
+          mask[i] = pattern < 2 ? pattern : (i + pattern) %% 3;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(want)
+          : "p0", "p7", "p15", "z1", "z30", "z31", "x10", "memory");
+        %s(a, b, mask, got);
+        if (memcmp(got, want, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u pattern=%%u\n", vl, pattern);
+          return %d;
+        }
+      }
+    }
+`, assembly, name, form, len(sigs))
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_copy", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_copy_test.go b/arm64_raw_sve_copy_test.go
new file mode 100644
index 000000000..8b174e4de
--- /dev/null
+++ b/arm64_raw_sve_copy_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVECopyForms() []string {
+	var lines []string
+	for _, width := range []string{"b", "h", "s", "d"} {
+		for _, mode := range []string{"m", "z"} {
+			for _, value := range []int{-128, -1, 0, 127} {
+				lines = append(lines, fmt.Sprintf("cpy z31.%s, p15/%s, #%d", width, mode, value))
+				if width != "b" {
+					lines = append(lines, fmt.Sprintf("cpy z31.%s, p15/%s, #%d, lsl #8", width, mode, value))
+				}
+			}
+		}
+		gp, sp := "w30", "wsp"
+		if width == "d" {
+			gp, sp = "x30", "sp"
+		}
+		lines = append(lines, fmt.Sprintf("cpy z31.%s, p7/m, %s", width, gp),
+			fmt.Sprintf("cpy z31.%s, p7/m, %s", width, sp),
+			fmt.Sprintf("cpy z31.%s, p7/m, %s30", width, width))
+	}
+	return lines
+}
+
+func TestARM64RawSVECopyOperandFields(t *testing.T) {
+	lines := arm64RawSVECopyForms()
+	for register := 0; register < 32; register++ {
+		gp := fmt.Sprintf("x%d", register)
+		if register == 31 {
+			gp = "sp"
+		}
+		lines = append(lines, fmt.Sprintf("cpy z%d.d, p%d/m, %s", register, register%8, gp),
+			fmt.Sprintf("cpy z%d.s, p%d/m, s%d", register, register%8, register),
+			fmt.Sprintf("cpy z%d.h, p%d/z, #-128, lsl #8", register, register%16))
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVECopy(word)
+		if !ok || len(got.Args) != 3 {
+			t.Fatalf("%s: decoded %#08x as %+v, %v", lines[i], word, got, ok)
+		}
+		fields := strings.Fields(strings.ReplaceAll(strings.ToUpper(lines[i]), ",", ""))
+		predicate := strings.ReplaceAll(fields[2], "/", ".")
+		if got.Args[1].Reg != Reg(predicate) || got.Args[2].Reg != Reg(fields[1]) {
+			t.Errorf("%s: wrong predicate/destination: %+v", lines[i], got)
+		}
+		value := fields[3]
+		wantOp := Op("ZCPY")
+		if value[0] == '#' {
+			immediate, err := strconv.ParseInt(value[1:], 10, 64)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(fields) > 4 {
+				immediate <<= 8
+			}
+			if got.Args[0].Kind != OpImm || got.Args[0].Imm != immediate {
+				t.Errorf("%s: wrong immediate: %+v", lines[i], got)
+			}
+		} else {
+			register := "R" + value[1:]
+			if strings.Contains("BHSD", value[:1]) && value != "SP" {
+				wantOp = Op("ZCPY" + value[:1])
+				register = "V" + value[1:]
+			} else {
+				if value[0] == 'W' {
+					wantOp = "ZCPYW"
+				}
+				if value == "SP" || value == "WSP" {
+					register = "RSP"
+				}
+			}
+			if got.Args[0].Kind != OpReg || got.Args[0].Reg != Reg(register) {
+				t.Errorf("%s: wrong scalar: %+v", lines[i], got)
+			}
+		}
+		if got.Op != wantOp {
+			t.Errorf("%s: opcode %s, want %s", lines[i], got.Op, wantOp)
+		}
+	}
+	for _, word := range []uint32{0x05102000, 0x05106000, 0x05108000, 0x05280000, 0x0520a000} {
+		if got, ok := decodeARM64RawSVECopy(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
+
+func TestARM64RawSVECopyCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawcopy(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, arm64RawSVECopyForms(), "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawcopy": {Name: "rawcopy", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawcopy.ll", "rawcopy.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_sve_count_test.go b/arm64_raw_sve_count_test.go
new file mode 100644
index 000000000..f7fec8e8d
--- /dev/null
+++ b/arm64_raw_sve_count_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVECountPatternAndMultiplier(t *testing.T) {
+	const source = `TEXT rawcount(SB),$0-0
+WORD $0x0470e7ea // DECH X10
+WORD $0x04a3e3e9 // CNTW X9, ALL, MUL #4
+WORD $0x043fe010 // INCB X16, POW2, MUL #16
+RET
+`
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"rawcount": {Name: "rawcount", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"@llvm.aarch64.sve.cnth(i32 31)", "@llvm.aarch64.sve.cntw(i32 31)",
+		"@llvm.aarch64.sve.cntb(i32 0)", "sub i64", "add i64", ", 4\n", ", 16\n"} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw count IR omitted %q", want)
+		}
+	}
+}
+
+func TestARM64RawSVECountCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawcountforms(SB),$0-0\n")
+	for size := uint32(0); size < 4; size++ {
+		for _, base := range []uint32{0x0420e000, 0x0430e000, 0x0430e400} {
+			for pattern := 0; pattern < 32; pattern++ {
+				for _, multiplier := range []uint32{1, 4, 16} {
+					word := base | size<<22 | (multiplier-1)<<16 | uint32(pattern)<<5 | 10
+					fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawcountforms": {Name: "rawcountforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawcount.ll", "rawcount.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVECountMatchesLLVM22Encoder(t *testing.T) {
+	var lines []string
+	type expectation struct {
+		op                             Op
+		bits, multiplier, pattern, dst int
+	}
+	var wants []expectation
+	for size, suffix := range []string{"b", "h", "w", "d"} {
+		for _, prefix := range []string{"cnt", "inc", "dec"} {
+			for _, pattern := range []int{0, 13, 14, 28, 29, 30, 31} {
+				for _, multiplier := range []int{1, 7, 16} {
+					lines = append(lines, fmt.Sprintf("%s%s x30, #%d, mul #%d", prefix, suffix, pattern, multiplier))
+					wants = append(wants, expectation{Op(strings.ToUpper(prefix + suffix)), 8 << size, multiplier, pattern, 30})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVECnt(word)
+		want := wants[i]
+		if !ok || got.op != want.op || got.elementBits != want.bits || got.pattern != want.pattern ||
+			got.multiplier != want.multiplier || got.destination != want.dst {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, want)
+		}
+	}
+	for _, word := range []uint32{0x0420e400, 0x0430c000, 0x0430f000, 0x0520e000} {
+		if got, ok := decodeARM64RawSVECnt(word); ok {
+			t.Fatalf("count decoder accepted adjacent instruction %#08x as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_effects_test.go b/arm64_raw_sve_effects_test.go
new file mode 100644
index 000000000..581b7c99f
--- /dev/null
+++ b/arm64_raw_sve_effects_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEGPResultEffectsAllRegisters(t *testing.T) {
+	var lines []string
+	var wants []uint32
+	for register := 0; register < 32; register++ {
+		name := fmt.Sprintf("x%d", register)
+		mask := uint32(1) << uint(register)
+		if register == 31 {
+			name, mask = "xzr", 0
+		}
+		for _, format := range []string{
+			"cntp %s, p7, p15.d", "cntp %s, pn15.d, vlx4",
+			"incp %s, p15.d", "uqdecp %s, p15.d",
+			"lasta %s, p7, z31.d", "lastb %s, p7, z31.d",
+		} {
+			lines = append(lines, fmt.Sprintf(format, name))
+			wants = append(wants, mask)
+		}
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		if writes, known := arm64RawPoolGPWrites(word); !known || writes != wants[index] {
+			t.Errorf("%s: writes=%#x, known=%v; want %#x", lines[index], writes, known, wants[index])
+		}
+	}
+}
+
+func TestARM64RawSVEGPResultDoesNotInventCallerReturn(t *testing.T) {
+	lines := []string{"cntp x30, p7, p15.d", "incp x30, p15.d", "lasta x30, p7, z31.d"}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		source := fmt.Sprintf("TEXT control(SB),$0-0\nWORD $%#08x\nRET\n", word)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+		} {
+			_, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"control": {Name: "control", Ret: Void}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s / %s: discarded real caller LR must retain Context, got %v", lines[index], triple, err)
+			}
+		}
+	}
+}
+
+func TestARM64RawSVEInstrDecodersHaveSharedFamily(t *testing.T) {
+	registry, err := parser.ParseFile(token.NewFileSet(), "arm64_raw_sve_families.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registered := make(map[string]bool)
+	ast.Inspect(registry, func(node ast.Node) bool {
+		field, ok := node.(*ast.KeyValueExpr)
+		if !ok {
+			return true
+		}
+		key, ok := field.Key.(*ast.Ident)
+		if !ok || key.Name != "decode" {
+			return true
+		}
+		decoder, ok := field.Value.(*ast.Ident)
+		if !ok || registered[decoder.Name] {
+			t.Fatal("raw SVE decoder must have one explicit family")
+		}
+		registered[decoder.Name] = true
+		return true
+	})
+	// These are nested grammar helpers, not alternative lowering routes.
+	delegated := map[string]string{
+		"decodeARM64RawSVEPNLoad":      "decodeARM64RawSVEUnsignedLoad",
+		"decodeARM64RawSVELoadAddress": "decodeARM64RawSVEUnsignedLoad",
+	}
+	files, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, file := range files {
+		if !strings.HasPrefix(file.Name(), "arm64_") || !strings.HasSuffix(file.Name(), ".go") || strings.HasSuffix(file.Name(), "_test.go") {
+			continue
+		}
+		source, err := parser.ParseFile(token.NewFileSet(), file.Name(), nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, decl := range source.Decls {
+			fn, ok := decl.(*ast.FuncDecl)
+			if !ok || !strings.HasPrefix(fn.Name.Name, "decodeARM64RawSVE") || fn.Type.Results == nil || len(fn.Type.Results.List) != 2 {
+				continue
+			}
+			result, ok := fn.Type.Results.List[0].Type.(*ast.Ident)
+			if !ok || result.Name != "Instr" || registered[fn.Name.Name] {
+				continue
+			}
+			if parent := delegated[fn.Name.Name]; parent != "" && registered[parent] {
+				continue
+			}
+			t.Errorf("%s has no shared lowerer/control-effect family", fn.Name.Name)
+		}
+	}
+}
+
+// Destination effects and memory effects are independent. In particular a
+// predicate/vector numbered 30 must not clobber X30, and a load must not erase
+// a saved continuation merely because its address is unknown.
+func TestARM64RawSVETypedControlEffects(t *testing.T) {
+	tests := []struct {
+		assembly string
+		writes   uint32
+		stores   bool
+	}{
+		{"rev p15.d, p14.d", 0, false},
+		{"zip1 p15.b, p14.b, p13.b", 0, false},
+		{"punpkhi p15.h, p14.b", 0, false},
+		{"match p7.b, p7/z, z30.b, z31.b", 0, false},
+		{"brka p15.b, p7/z, p14.b", 0, false},
+		{"ptest p7, p15.b", 0, false},
+		{"whilelo p7.d, x30, x29", 0, false},
+		{"index z30.d, x30, x29", 0, false},
+		{"adr z30.d, [z31.d, z29.d, lsl #3]", 0, false},
+		{"sdot z30.s, z31.b, z29.b", 0, false},
+		{"mul z30.d, p7/m, z30.d, z31.d", 0, false},
+		{"tbl z30.d, {z31.d}, z29.d", 0, false},
+		{"umullb z30.d, z31.s, z29.s", 0, false},
+		{"umlalb z30.d, z31.s, z29.s", 0, false},
+		{"fmaxnmv d30, p7, z31.d", 0, false},
+		{"saddwb z30.d, z31.d, z29.s", 0, false},
+		{"umax z30.d, p7/m, z30.d, z31.d", 0, false},
+		{"lasta d30, p7, z31.d", 0, false},
+		{"lasta x30, p7, z31.d", 1 << 30, false},
+		{"lastb xzr, p7, z31.d", 0, false},
+		{"cntp x30, p7, p15.d", 1 << 30, false},
+		{"cntp xzr, pn15.d, vlx4", 0, false},
+		{"incp x30, p15.d", 1 << 30, false},
+		{"uqdecp xzr, p15.d", 0, false},
+		{"ld1b {z30.d}, p7/z, [x29]", 0, false},
+		{"ld1sb {z30.d}, p7/z, [x29]", 0, false},
+		{"ld1rw {z30.s}, p7/z, [x29]", 0, false},
+		{"ld2d {z30.d, z31.d}, p7/z, [x29]", 0, false},
+		{"st1b {z30.d}, p7, [x29]", 0, true},
+		{"st2d {z30.d, z31.d}, p7, [x29]", 0, true},
+	}
+	lines := make([]string, len(tests))
+	for index, test := range tests {
+		lines[index] = test.assembly
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		test := tests[index]
+		t.Run(test.assembly, func(t *testing.T) {
+			if writes, known := arm64RawPoolGPWrites(word); !known || writes != test.writes {
+				t.Errorf("GP writes = %#x, known=%v; want %#x", writes, known, test.writes)
+			}
+			continuation := arm64ControlFromMap(map[string]bool{"return:outer": true})
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": continuation},
+				memory: map[string]arm64ControlValue{"sp:0": continuation},
+			}
+			state.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}, OpWORD, false, nil)
+			if got := arm64ControlHas(state.regs["R30"], ""); got != (test.writes&(1<<30) != 0) {
+				t.Errorf("X30 became unknown=%v, writes=%#x", got, test.writes)
+			}
+			if got := arm64ControlHas(state.memory["sp:0"], ""); got != test.stores {
+				t.Errorf("saved continuation became unknown=%v, memory store=%v", got, test.stores)
+			}
+		})
+	}
+}
+
+func TestARM64RawUnknownControlEffectsRemainConservative(t *testing.T) {
+	for _, word := range []uint32{0xffffffff, 0x05304010, 0x25208a00, 0xd63f0000} {
+		continuation := arm64ControlFromMap(map[string]bool{"return:outer": true})
+		state := &arm64ControlState{
+			regs:   map[Reg]arm64ControlValue{"R30": continuation},
+			memory: map[string]arm64ControlValue{"sp:0": continuation},
+		}
+		state.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}, OpWORD, false, nil)
+		if !arm64ControlHas(state.regs["R30"], "") || !arm64ControlHas(state.memory["sp:0"], "") {
+			t.Errorf("unmodeled/call word %#08x silently preserved continuation", word)
+		}
+	}
+}
diff --git a/arm64_raw_sve_extended_load_runtime_test.go b/arm64_raw_sve_extended_load_runtime_test.go
new file mode 100644
index 000000000..390828f94
--- /dev/null
+++ b/arm64_raw_sve_extended_load_runtime_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEExtendedLoadRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		kind, size, count, offset int
+		zeroIndex                 bool
+		native                    []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for kind := 0; kind < 5; kind++ {
+		for size := 0; size < 5; size++ {
+			if kind < 2 && size > 3 || (kind == 2 || kind == 3) && (size < 2 || size > 3) || kind == 4 && size != 4 {
+				continue
+			}
+			counts := []int{1}
+			if kind < 2 {
+				counts = []int{2, 4}
+			}
+			for _, count := range counts {
+				offsets := []int{0}
+				if kind == 0 || kind == 2 {
+					offsets = []int{-8, 0, 7}
+				} else if kind == 1 || kind == 4 {
+					offsets = []int{0, 1} // ordinary index and the architectural XZR alias
+				}
+				for _, offset := range offsets {
+					zeroIndex := (kind == 1 || kind == 4) && offset == 1
+					native := []string{
+						"ptrue p0.b", "ld1b {z30.b}, p0/z, [x1]", "ld1b {z20.b}, p0/z, [x2]",
+						"cmpne p7.b, p0/z, z20.b, #0", "ldr x4, [x1, #256]", "ldr x5, [x1, #264]", "mov x6, #0",
+					}
+					address := fmt.Sprintf("[x0, x4, lsl #%d]", size)
+					if kind == 0 || kind == 2 {
+						address = fmt.Sprintf("[x0, #%d, mul vl]", offset*count)
+					} else if zeroIndex && kind == 1 {
+						address = fmt.Sprintf("[x0, xzr, lsl #%d]", size)
+					}
+					if kind < 2 {
+						native = append(native,
+							fmt.Sprintf("whilelo pn15.%c, x6, x5, vlx%d", "bhsd"[size], count),
+							fmt.Sprintf("ld1%c {z28.%c-z%d.%c}, pn15/z, %s", "bhwd"[size], "bhsd"[size], 27+count, "bhsd"[size], address))
+					} else if kind == 4 {
+						index := "x4"
+						if zeroIndex {
+							index = "xzr"
+						}
+						native = append(native, fmt.Sprintf("ld1q {z30.q}, p7/z, [z30.d, %s]", index))
+					} else {
+						native = append(native, fmt.Sprintf("ld1%c {z30.q}, p7/z, %s", "bhwd"[size], address))
+					}
+					for i := 0; i < count; i++ {
+						register := 28 + i
+						if kind >= 2 {
+							register = 30
+						}
+						native = append(native, fmt.Sprintf("st1b {z%d.b}, p0, [x3, #%d, mul vl]", register, i))
+					}
+					cases = append(cases, runtimeCase{kind, size, count, offset, zeroIndex, native})
+					allNative = append(allNative, native...)
+				}
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve2p1")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEExtendedLoadRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("extended_load_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD base+0(FP),R0\nMOVD indices+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		var native strings.Builder
+		native.WriteString("mov x0, %[base]\\n\\tmov x1, %[indices]\\n\\tmov x2, %[mask]\\n\\tmov x3, %[out]\\n\\t")
+		for i, word := range words[:len(test.native)] {
+			if test.kind < 2 && i == 7 {
+				fmt.Fprintf(&source, "PWHILELO VLX%d, R5, R6, PN15.%c\n", test.count, "BHSD"[test.size])
+			} else {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			fmt.Fprintf(&native, ".inst %#08x\\n\\t", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *base, const void *indices, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [base]"r"(base), [indices]"r"(indices), [mask]"r"(mask), [out]"r"(out)
+    : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "p0", "p7", "p15", "z20", "z28", "z29", "z30", "z31", "cc", "memory");
+}
+`, name, native.String())
+		zero := 0
+		if test.zeroIndex {
+			zero = 1
+		}
+		fmt.Fprintf(&checks, "  if (check_extended_load(vl, %d, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			test.kind, 1<<test.size, test.count, test.offset, zero, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_extended_load", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEExtendedLoadRuntimeReference = `
+typedef void (*extended_load_fn)(const void *, const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_extended_load(unsigned vl, unsigned kind, unsigned access, unsigned count,
+    int offset, int zero_index, extended_load_fn translated, extended_load_fn native_instruction, const char *name) {
+  unsigned char memory[32768], indices[272], mask[256], got[1024], native[1024], scalar[1024];
+  unsigned element = kind < 2 ? access : 16;
+  for (unsigned phase = 0; phase < 8; phase++) {
+    for (unsigned i = 0; i < sizeof(memory); i++) memory[i] = i * 71 + (i >> 8) + phase;
+    memset(indices, 0, sizeof(indices));
+    memset(mask, 0, sizeof(mask));
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    memset(scalar, 0, vl * count);
+    unsigned char *base = phase ? memory + 16384 + phase % 4 : 0;
+    int64_t index = zero_index ? 0 : (int64_t)(phase % 3) * 11 - 7;
+    uint64_t limit = phase == 0 ? 0 : phase == 1 ? vl * count / access : vl * (phase % count + 1) / access - 1;
+    memcpy(indices + 256, &index, sizeof(index));
+    memcpy(indices + 264, &limit, sizeof(limit));
+    for (unsigned i = 0; i < vl * count; i += element) {
+      unsigned lane = i / element;
+      int active = kind < 2 ? lane < limit : phase < 2 ? phase : (lane + phase) % 3 != 0;
+      uintptr_t address = (uintptr_t)base;
+      if (kind == 0) address += (int64_t)offset * vl * count + i;
+      else if (kind == 1) address += index * access + i;
+      else if (kind == 2) address += (int64_t)offset * (vl / 16 * access) + lane * access;
+      else if (kind == 3) address += index * access + lane * access;
+      else {
+        uintptr_t encoded = active ? (uintptr_t)(memory + 16384 + lane * 37 + phase % 4) : 0;
+        memcpy(indices + i, &encoded, sizeof(encoded));
+        address = encoded + index;
+      }
+      if (kind >= 2) memset(mask + i, active, element);
+      if (active) memcpy(scalar + i, (void *)address, access);
+    }
+    native_instruction(base, indices, mask, native);
+    translated(base, indices, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u native=%d scalar=%d\n", name, vl, phase,
+        memcmp(got, native, sizeof(got)), memcmp(got, scalar, sizeof(got)));
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_extra_shift_runtime_test.go b/arm64_raw_sve_extra_shift_runtime_test.go
new file mode 100644
index 000000000..d2925e4f7
--- /dev/null
+++ b/arm64_raw_sve_extra_shift_runtime_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEExtraShiftRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		form                                arm64RawSVEExtraShiftCase
+		operation, size, shift, destination int
+		native                              []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for operation, form := range arm64RawSVEExtraShiftCases() {
+		for size := 0; size < 4; size++ {
+			bits := 8 << size
+			shifts := []int{1, bits / 2, bits - 1, bits}
+			if form.left {
+				shifts = []int{0, 1, bits / 2, bits - 1}
+			}
+			if form.reverse {
+				shifts = []int{0}
+			}
+			for _, shift := range shifts {
+				for _, destination := range []int{31, 30} {
+					native := []string{
+						"ptrue p0.b", "ld1b { z29.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z29.b, #0",
+						"ld1b { z30.b }, p0/z, [x0]", "ld1b { z31.b }, p0/z, [x1]",
+						form.assembly(size, destination, 30, 7, shift),
+						fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+					}
+					cases = append(cases, runtimeCase{form, operation, size, shift, destination, native})
+					allNative = append(allNative, native...)
+				}
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve2")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEExtraShiftScalarReference)
+	declarations.WriteString(arm64SVEExtraShiftRuntimeDriver)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("extra_shift_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(out)
+    : "p0", "p7", "z29", "z30", "z31", "memory");
+}
+`, name, assembly)
+		oldB, inputB, predicated := 0, 0, 0
+		if test.destination == 31 {
+			oldB = 1
+		}
+		if test.form.predicated && !test.form.reverse {
+			inputB = oldB
+		}
+		if test.form.predicated {
+			predicated = 1
+		}
+		fmt.Fprintf(&checks, "  if (check_extra_shift(vl, %d, %d, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			8<<test.size, test.operation, test.shift, inputB, oldB, predicated, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_extra_shift", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+// Share data generation and comparisons across all 344 native/translated
+// pairs. Keep this out of the compiler's per-case specialization pipeline.
+const arm64SVEExtraShiftRuntimeDriver = `
+typedef void (*extra_shift_fn)(const void *, const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_extra_shift(unsigned vl, unsigned bits, unsigned operation, unsigned shift,
+    int input_b, int old_b, int predicated, extra_shift_fn translated,
+    extra_shift_fn native_instruction, const char *name) {
+  unsigned char a[256], b[256], mask[256], got[256], native[256], scalar[256];
+  const unsigned bytes = bits / 8;
+  uint64_t sign = UINT64_C(1) << (bits - 1), maximum = UINT64_MAX >> (64 - bits);
+  uint64_t values[] = {0, 1, maximum, sign, sign - 1, sign + 1, bits - 1, bits, bits + 1,
+    maximum >> 1, 2, 3, 0x5555555555555555ULL, 0xaaaaaaaaaaaaaaaaULL};
+  for (unsigned phase = 0; phase < 18; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i += bytes) {
+      unsigned lane = i / bytes;
+      uint64_t x = values[(lane + phase) % 14], y = values[(lane * 3 + phase * 5) % 14];
+      if (phase >= 14) {
+        x = (0x0123456789abcdefULL * (lane + phase)) ^ maximum;
+        y = 0xfedcba9876543211ULL * (lane * 7 + phase);
+      }
+      memcpy(a + i, &x, bytes);
+      memcpy(b + i, &y, bytes);
+      for (unsigned j = 0; j < bytes; j++) mask[i + j] = phase < 2 ? phase : (lane + phase) % 3 != 0;
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      uint64_t x = 0, old = 0;
+      memcpy(&x, (input_b ? b : a) + i, bytes);
+      memcpy(&old, (old_b ? b : a) + i, bytes);
+      uint64_t value = old;
+      if (!predicated || mask[i]) value = extra_shift_reference(operation, bits, x, old, shift);
+      memcpy(scalar + i, &value, bytes);
+    }
+    native_instruction(a, b, mask, native);
+    translated(a, b, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u native=%d scalar=%d\n", name, vl, phase,
+        memcmp(got, native, sizeof(got)), memcmp(got, scalar, sizeof(got)));
+      return 1;
+    }
+  }
+  return 0;
+}
+`
+
+// Widen intermediate arithmetic so rounding, sign extension and 64-bit shifts
+// never overflow or shift by the C type width. Operation order matches the
+// independent native-case list, not the implementation's intrinsic table.
+const arm64SVEExtraShiftScalarReference = `
+#include <stdlib.h>
+static uint64_t extra_shift_reference(unsigned op, unsigned bits, uint64_t x, uint64_t old, unsigned shift) {
+  unsigned __int128 modulus = (unsigned __int128)1 << bits;
+  uint64_t maximum = (uint64_t)(modulus - 1);
+  __int128 signed_x = (x & (UINT64_C(1) << (bits - 1))) ? (__int128)x - (__int128)modulus : x;
+  unsigned __int128 value = x, rounding = shift ? (unsigned __int128)1 << (shift - 1) : 0;
+  switch (op) {
+  case 0: return signed_x / ((__int128)1 << shift); // ASRD rounds toward zero.
+  case 1: return (old & ((UINT64_C(1) << shift) - 1)) | (value << shift);
+  case 2:
+    if (signed_x < 0) return 0;
+    value <<= shift;
+    return value > maximum ? maximum : value;
+  case 3: return (old & (maximum ^ ((uint64_t)(modulus >> shift) - 1))) | (value >> shift);
+  case 4: return (signed_x + (__int128)rounding) >> shift;
+  case 5: return old + ((signed_x + (__int128)rounding) >> shift);
+  case 6: return old + (signed_x >> shift);
+  case 7: return (value + rounding) >> shift;
+  case 8: return old + ((value + rounding) >> shift);
+  case 9: return old + (value >> shift);
+  case 10: return old >= bits ? (signed_x < 0 ? maximum : 0) : signed_x >> old;
+  case 11: return old >= bits ? 0 : x << old;
+  case 12: return old >= bits ? 0 : x >> old;
+  default: abort();
+  }
+}
+`
diff --git a/arm64_raw_sve_extra_shift_test.go b/arm64_raw_sve_extra_shift_test.go
new file mode 100644
index 000000000..7cde9442b
--- /dev/null
+++ b/arm64_raw_sve_extra_shift_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVEExtraShiftCase struct {
+	op         string
+	predicated bool
+	left       bool
+	reverse    bool
+}
+
+func arm64RawSVEExtraShiftCases() []arm64RawSVEExtraShiftCase {
+	return []arm64RawSVEExtraShiftCase{
+		{op: "asrd", predicated: true},
+		{op: "sli", left: true},
+		{op: "sqshlu", predicated: true, left: true},
+		{op: "sri"},
+		{op: "srshr", predicated: true},
+		{op: "srsra"},
+		{op: "ssra"},
+		{op: "urshr", predicated: true},
+		{op: "ursra"},
+		{op: "usra"},
+		{op: "asrr", predicated: true, reverse: true},
+		{op: "lslr", predicated: true, reverse: true},
+		{op: "lsrr", predicated: true, reverse: true},
+	}
+}
+
+func (form arm64RawSVEExtraShiftCase) assembly(size, dst, src, pred, shift int) string {
+	width := "bhsd"[size]
+	if form.reverse {
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, z%d.%c", form.op, dst, width, pred, dst, width, src, width)
+	}
+	if form.predicated {
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, #%d", form.op, dst, width, pred, dst, width, shift)
+	}
+	return fmt.Sprintf("%s z%d.%c, z%d.%c, #%d", form.op, dst, width, src, width, shift)
+}
+
+func TestARM64RawSVEExtraShiftCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, form := range arm64RawSVEExtraShiftCases() {
+		for size := 0; size < 4; size++ {
+			minimum, maximum := 1, 8<<size
+			if form.left {
+				minimum, maximum = 0, maximum-1
+			}
+			if form.reverse {
+				maximum = minimum
+			}
+			for shift := minimum; shift <= maximum; shift++ {
+				lines = append(lines, form.assembly(size, 31, 30, 7, shift))
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawextrashift(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawextrashift": {Name: "rawextrashift", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawextrashift.ll", "rawextrashift.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEExtraShiftOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, form := range arm64RawSVEExtraShiftCases() {
+		for size := 0; size < 4; size++ {
+			limits := []int{32, 32, 8, 8 << size}
+			if !form.predicated {
+				limits[2] = 1
+			}
+			if form.predicated && !form.reverse {
+				limits[1] = 1
+			}
+			if form.reverse {
+				limits[3] = 1
+			}
+			for field, limit := range limits {
+				for value := 0; value < limit; value++ {
+					fields := [4]int{31, 30, limits[2] - 1, 0}
+					fields[field] = value
+					dst, src, pred, shift := fields[0], fields[1], fields[2], fields[3]
+					if !form.left {
+						shift++
+					}
+					lines = append(lines, form.assembly(size, dst, src, pred, shift))
+					reg := func(n int) Operand {
+						return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", n, "BHSD"[size]))}
+					}
+					first := Operand{Kind: OpImm, Imm: int64(shift)}
+					if form.reverse {
+						first = reg(src)
+					}
+					args := []Operand{first}
+					if form.predicated {
+						args = append(args, reg(dst), Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", pred))})
+					} else {
+						args = append(args, reg(src))
+					}
+					args = append(args, reg(dst))
+					wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(form.op)), Args: args})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVEExtraShift(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, form := range arm64RawSVEExtraShiftCases() {
+		if form.reverse {
+			continue
+		}
+		spec := arm64SVEImmediateShiftSpecs[Op("Z"+strings.ToUpper(form.op))]
+		lowBit := 16
+		if form.predicated {
+			lowBit = 5
+		}
+		for immediate := uint32(0); immediate < 8; immediate++ {
+			word := spec.rawBase | immediate<<lowBit
+			if got, ok := decodeARM64RawSVEExtraShift(word); ok {
+				t.Errorf("unallocated tsize in %#08x decoded as %+v", word, got)
+			}
+		}
+	}
+	for _, word := range []uint32{0, 0x04008000, 0x04108000, 0x4500fc00} {
+		if got, ok := decodeARM64RawSVEExtraShift(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_families.go b/arm64_raw_sve_families.go
new file mode 100644
index 000000000..7adfe9ee3
--- /dev/null
+++ b/arm64_raw_sve_families.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import "fmt"
+
+type arm64RawSVEMemory uint8
+
+const (
+	arm64RawSVENoMemory arm64RawSVEMemory = iota
+	arm64RawSVEReadMemory
+	arm64RawSVEMemoryOperand
+)
+
+// The accepted decoder, lowerer and architectural effects belong to one
+// family. A vector address operand is not a memory access, and predicate
+// flags are not GP writes. Never infer either property from an opcode prefix.
+type arm64RawSVEFamily struct {
+	decode      func(uint32) (Instr, bool)
+	lower       func(*arm64Ctx, Instr) error
+	gpResult    bool
+	readsResult bool
+	memory      arm64RawSVEMemory
+}
+
+type arm64RawSVEControlEffects struct {
+	gpWrites uint32
+	gpReads  uint32
+	stores   bool
+	accesses bool
+}
+
+type arm64RawSVEVectorFamily struct {
+	matches func(uint32) bool
+	lower   func(*arm64Ctx, uint32) error
+}
+
+// T retains each family's concrete decoded form; no reflection or untyped
+// payload is involved. This constructor is only for the explicitly registered
+// vector-only families below: no GP input/output, control flow or memory.
+func arm64RawSVEVectorForm[T any](decode func(uint32) (T, bool), lower func(*arm64Ctx, T) error) arm64RawSVEVectorFamily {
+	return arm64RawSVEVectorFamily{
+		matches: func(word uint32) bool {
+			_, ok := decode(word)
+			return ok
+		},
+		lower: func(c *arm64Ctx, word uint32) error {
+			form, ok := decode(word)
+			if !ok {
+				return fmt.Errorf("ARM64 raw SVE vector family rejected its selected encoding %#08x", word)
+			}
+			return lower(c, form)
+		},
+	}
+}
+
+var arm64RawSVEVectorFamilies = [...]arm64RawSVEVectorFamily{
+	arm64RawSVEVectorForm(decodeARM64RawSVEMultiply, (*arm64Ctx).lowerRawSVEMultiply),
+	arm64RawSVEVectorForm(decodeARM64RawSVETable, (*arm64Ctx).lowerRawSVETable),
+	arm64RawSVEVectorForm(decodeARM64RawSVEUMULLB, (*arm64Ctx).lowerRawSVEUMULLB),
+	arm64RawSVEVectorForm(decodeARM64RawSVEMultiplyAccumulateLong, (*arm64Ctx).lowerRawSVEMultiplyAccumulateLong),
+	arm64RawSVEVectorForm(decodeARM64RawSVEFloatMinMaxReduction,
+		func(c *arm64Ctx, form arm64RawSVEFloatMinMaxReduction) error {
+			return c.lowerARM64SVEFloatMinMaxReductionForm(form.spec, form.form, form.destination)
+		}),
+}
+
+func arm64RawSVEEffects(word uint32) (arm64RawSVEControlEffects, bool) {
+	if family, decoded, ok := decodeARM64RawSVEFamily(word); ok {
+		return family.effects(decoded), true
+	}
+	for _, family := range arm64RawSVEVectorFamilies {
+		if family.matches(word) {
+			return arm64RawSVEControlEffects{}, true
+		}
+	}
+	return arm64RawSVEControlEffects{}, false
+}
+
+func arm64RawSVENamed(lower func(*arm64Ctx, Op, Instr) (bool, bool, error)) func(*arm64Ctx, Instr) error {
+	return func(c *arm64Ctx, ins Instr) error {
+		handled, terminated, err := lower(c, ins.Op, ins)
+		if err == nil && (!handled || terminated) {
+			return fmt.Errorf("ARM64 raw SVE family did not lower its decoded instruction: %s", ins.Op)
+		}
+		return err
+	}
+}
+
+// Keep the former raw-lowering precedence. The same table drives lowering,
+// GP/control effects and relocated-pool address independence.
+var arm64RawSVEFamilies = [...]arm64RawSVEFamily{
+	{decode: decodeARM64RawSVEIndex,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEIndex)},
+	{decode: decodeARM64RawSVEFloatMinMax,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatMinMax)},
+	{decode: decodeARM64RawSVEFloatUnary,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatUnary)},
+	{decode: decodeARM64RawSVEFloatImmediate,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatImmediate)},
+	{decode: decodeARM64RawSVEDupM,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEDupM)},
+	{decode: decodeARM64RawSVEFloatMultiplyAccumulate,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatMultiplyAccumulate)},
+	{decode: decodeARM64RawSVEFloatReciprocalStep,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatReciprocalStep)},
+	{decode: decodeARM64RawSVEConvert,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEConvert)},
+	{decode: decodeARM64RawSVEWhile,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateWhile)},
+	{decode: decodeARM64RawSVECharacterMatch,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVECharacterMatch)},
+	{decode: decodeARM64RawSVEPredicateBreak,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateBreak)},
+	{decode: decodeARM64RawSVEPredicateCount, gpResult: true,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateCounter)},
+	{decode: decodeARM64RawSVEPredicateIncDec, gpResult: true, readsResult: true,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateIncDec)},
+	{decode: decodeARM64RawSVEFloatCompare,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVECompare)},
+	{decode: decodeARM64RawSVEIntegerCompare,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVECompare)},
+	{decode: decodeARM64RawSVEPredicateLogical,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateLogical)},
+	{decode: decodeARM64RawSVEPredicatePermute,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicatePermute)},
+	{decode: decodeARM64RawSVECompact,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVECompact)},
+	{decode: decodeARM64RawSVECopy,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVECopy)},
+	{decode: decodeARM64RawSVEIntegerUnary,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEIntegerUnary)},
+	{decode: decodeARM64RawSVERevd,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVERevd)},
+	{decode: decodeARM64RawSVEStructuredMemory, memory: arm64RawSVEMemoryOperand,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEStructuredMemory)},
+	{decode: decodeARM64RawSVEMultiplyAccumulate,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEMultiplyAccumulate)},
+	{decode: decodeARM64RawSVETernaryBitwise,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVETernaryBitwise)},
+	{decode: decodeARM64RawSVEIntegerReduction,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEIntegerReduction)},
+	{decode: decodeARM64RawSVEIntegerDot,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEIntegerDot)},
+	{decode: decodeARM64RawSVEXAR,
+		lower: (*arm64Ctx).lowerARM64RawSVEXAR},
+	{decode: decodeARM64RawSVEExtraShift,
+		lower: (*arm64Ctx).lowerARM64RawSVEExtraShift},
+	{decode: decodeARM64RawSVESplice,
+		lower: (*arm64Ctx).lowerARM64RawSVESplice},
+	{decode: decodeARM64RawSVEReplicateScalar, memory: arm64RawSVEReadMemory,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEReplicateMemory)},
+	{decode: decodeARM64RawSVEReplicateBlock, memory: arm64RawSVEReadMemory,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEReplicateMemory)},
+	{decode: decodeARM64RawSVEUnsignedLoad, memory: arm64RawSVEReadMemory,
+		lower: (*arm64Ctx).lowerRawSVEUnsignedLoad},
+	{decode: decodeARM64RawSVEContiguousMemory, memory: arm64RawSVEMemoryOperand,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEOrdinaryMemory)},
+	{decode: decodeARM64RawSVESignedLoad, memory: arm64RawSVEReadMemory,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEOrdinaryMemory)},
+	{decode: decodeARM64RawSVEAddSubWide,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEWideningAddSub)},
+	{decode: decodeARM64RawSVEMultiplyHigh,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEMultiplyHigh)},
+	{decode: decodeARM64RawSVEAddressGeneration,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEAddressGeneration)},
+	{decode: decodeARM64RawSVEFloatDivideScale,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEFloatDivideScale)},
+	{decode: decodeARM64RawSVEUnpack,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEUnpack)},
+	{decode: decodeARM64RawSVEAddPairwiseLong,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEAbsoluteDifference)},
+	{decode: decodeARM64RawSVEIntegerMinMax,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEMinMax)},
+	{decode: decodeARM64RawSVEIntegerMinMaxReduction,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEMinMax)},
+	{decode: decodeARM64RawSVEPTest,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEPredicateState)},
+	{decode: decodeARM64RawSVEMOVPRFX,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVEMOVPRFX)},
+	{decode: decodeARM64RawSVELast, gpResult: true,
+		lower: arm64RawSVENamed((*arm64Ctx).lowerARM64SVELast)},
+}
+
+func decodeARM64RawSVEFamily(word uint32) (arm64RawSVEFamily, Instr, bool) {
+	for _, family := range arm64RawSVEFamilies {
+		if ins, ok := family.decode(word); ok {
+			return family, ins, true
+		}
+	}
+	return arm64RawSVEFamily{}, Instr{}, false
+}
+
+func (family arm64RawSVEFamily) effects(ins Instr) arm64RawSVEControlEffects {
+	var effects arm64RawSVEControlEffects
+	last := len(ins.Args) - 1
+	for index, arg := range ins.Args {
+		if arg.Kind == OpReg {
+			if register, gp := arm64StackIndex(arg.Reg); gp {
+				mask := uint32(1) << uint(register)
+				if family.gpResult && index == last {
+					effects.gpWrites |= mask
+					if !family.readsResult {
+						continue
+					}
+				}
+				effects.gpReads |= mask
+			}
+		}
+		if arg.Kind == OpMem {
+			for _, reg := range []Reg{arg.Mem.Base, arg.Mem.Index} {
+				if register, gp := arm64StackIndex(reg); gp {
+					effects.gpReads |= uint32(1) << uint(register)
+				}
+			}
+			if family.memory != arm64RawSVENoMemory {
+				effects.accesses = true
+				effects.stores = family.memory == arm64RawSVEMemoryOperand && index == last
+			}
+		}
+	}
+	return effects
+}
diff --git a/arm64_raw_sve_float_arithmetic_runtime_test.go b/arm64_raw_sve_float_arithmetic_runtime_test.go
new file mode 100644
index 000000000..78eabf9dc
--- /dev/null
+++ b/arm64_raw_sve_float_arithmetic_runtime_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEFloatArithmeticRuntime(t *testing.T, llc string) {
+	testARM64RawSVEFloatBinaryRuntime(t, llc, arm64RawSVEFloatArithmeticCases())
+}
+
+func testARM64RawSVEFloatDivideScaleRuntime(t *testing.T, llc string) {
+	testARM64RawSVEFloatBinaryRuntime(t, llc, arm64RawSVEFloatDivideScaleCases())
+}
+
+func testARM64RawSVEFloatBinaryRuntime(t *testing.T, llc string, forms []arm64RawSVEFloatArithmeticCase) {
+	type runtimeCase struct {
+		form                arm64RawSVEFloatArithmeticCase
+		destination, second int
+		native              []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for _, form := range forms {
+		second := 29
+		if form.mode == "indexed" {
+			second = 7
+			if form.size == 3 {
+				second = 15
+			}
+		}
+		for _, destination := range []int{31, 30, second} {
+			native := []string{
+				"ptrue p0.b", "ld1b { z30.b }, p0/z, [x0]", "ld1b { z31.b }, p0/z, [x0]",
+				fmt.Sprintf("ld1b { z%d.b }, p0/z, [x1]", second),
+				"ld1b { z28.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z28.b, #0",
+				form.assembly(destination, 30, second, 7),
+				fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+			}
+			cases = append(cases, runtimeCase{form, destination, second, native})
+			allNative = append(allNative, native...)
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEFloatArithmeticRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("float_arithmetic_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(out)
+    : "p0", "p7", "z7", "z15", "z28", "z29", "z30", "z31", "memory");
+}
+`, name, assembly)
+		predicated, firstB, lane := 0, 0, -1
+		if test.form.mode == "predicated" || test.form.mode == "immediate" {
+			predicated = 1
+			if test.destination == test.second {
+				firstB = 1
+			}
+		} else if test.form.mode == "indexed" {
+			lane = test.form.lane
+		}
+		operation := map[string]int{"fadd": 0, "fsub": 1, "fsubr": 2, "fmul": 3, "fdiv": 4, "fdivr": 5, "fscale": 6}[test.form.op]
+		fmt.Fprintf(&checks, "  if (check_float_arithmetic(vl, %d, %d, %d, %d, %d, %.1f, %s, %s_native, %q)) return 1;\n",
+			1<<test.form.size, operation, predicated, firstB, lane, test.form.immediate, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_float_arithmetic", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEFloatArithmeticRuntimeReference = `
+#include <math.h>
+typedef void (*float_arithmetic_fn)(const void *, const void *, const void *, void *);
+static double unpack_float(const unsigned char *p, unsigned bytes) {
+  if (bytes == 2) { _Float16 x; memcpy(&x, p, 2); return x; }
+  if (bytes == 4) { float x; memcpy(&x, p, 4); return x; }
+  double x; memcpy(&x, p, 8); return x;
+}
+static void pack_float(unsigned char *p, unsigned bytes, double x) {
+  if (bytes == 2) { _Float16 y = x; memcpy(p, &y, 2); }
+  else if (bytes == 4) { float y = x; memcpy(p, &y, 4); }
+  else memcpy(p, &x, 8);
+}
+__attribute__((noinline, noclone))
+static int check_float_arithmetic(unsigned vl, unsigned bytes, unsigned operation,
+    int predicated, int first_b, int lane, double immediate, float_arithmetic_fn translated,
+    float_arithmetic_fn native_instruction, const char *name) {
+  const uint64_t patterns[3][12] = {
+    {0, 0x8000, 0x3c00, 0xbc00, 0x7bff, 1, 0x0400, 0x7c00, 0xfc00, 0x7e13, 0x7c23, 0x3555},
+    {0, 0x80000000, 0x3f800000, 0xbf800000, 0x7f7fffff, 1, 0x00800000, 0x7f800000, 0xff800000, 0x7fc00013, 0x7f800023, 0x3eaaaaab},
+    {0, 0x8000000000000000ULL, 0x3ff0000000000000ULL, 0xbff0000000000000ULL,
+     0x7fefffffffffffffULL, 1, 0x0010000000000000ULL, 0x7ff0000000000000ULL,
+     0xfff0000000000000ULL, 0x7ff8000000000013ULL, 0x7ff0000000000023ULL, 0x3fd5555555555555ULL}
+  };
+  unsigned char a[256], b[256], mask[256], got[256], native[256], scalar[256];
+  unsigned row = bytes == 2 ? 0 : bytes == 4 ? 1 : 2;
+  for (unsigned phase = 0; phase < 16; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i += bytes) {
+      unsigned element = i / bytes;
+      uint64_t x = patterns[row][(element + phase) % 12], y = patterns[row][(element * 3 + phase * 7) % 12];
+      if (operation == 6) {
+        const int64_t exponents[] = {0, 1, -1, 2, -2, 127, -149, 1023, -1074, 32767, -32768, INT64_MIN};
+        y = (uint64_t)exponents[(element * 3 + phase * 7) % 12];
+      }
+      memcpy(a + i, &x, bytes);
+      memcpy(b + i, &y, bytes);
+      for (unsigned j = 0; j < bytes; j++) mask[i + j] = phase < 2 ? phase : (element + phase) % 3 != 0;
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      const unsigned char *first = (first_b ? b : a) + i;
+      if (predicated && !mask[i]) { memcpy(scalar + i, first, bytes); continue; }
+      double x = unpack_float(first, bytes);
+      double y = immediate ? immediate : unpack_float(b + (lane < 0 ? i : (i & ~15u) + lane * bytes), bytes);
+      double value;
+      switch (operation) {
+        case 0: value = x + y; break;
+        case 1: value = x - y; break;
+        case 2: value = y - x; break;
+        case 3: value = x * y; break;
+        case 4: value = x / y; break;
+        case 5: value = y / x; break;
+        default: {
+          uint64_t encoded = 0;
+          memcpy(&encoded, b + i, bytes);
+          int64_t exponent = bytes == 2 ? (int16_t)encoded : bytes == 4 ? (int32_t)encoded : (int64_t)encoded;
+          int clamped = exponent > 65536 ? 65536 : exponent < -65536 ? -65536 : (int)exponent;
+          value = scalbn(x, clamped);
+          break;
+        }
+      }
+      pack_float(scalar + i, bytes, value);
+    }
+    native_instruction(a, b, mask, native);
+    translated(a, b, mask, got);
+    if (memcmp(got, native, sizeof(got))) {
+      fprintf(stderr, "%s: native mismatch vl=%u phase=%u\n", name, vl, phase);
+      return 1;
+    }
+    for (unsigned i = 0; i < vl; i += bytes) {
+      // The native comparison above checks exact NaN payloads and inactive
+      // signaling NaNs; scalar C conversions may quiet or canonicalize NaNs.
+      if (isnan(unpack_float(scalar + i, bytes)) && isnan(unpack_float(got + i, bytes))) continue;
+      if (memcmp(got + i, scalar + i, bytes)) {
+        fprintf(stderr, "%s: scalar mismatch vl=%u phase=%u offset=%u\n", name, vl, phase, i);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_float_arithmetic_test.go b/arm64_raw_sve_float_arithmetic_test.go
new file mode 100644
index 000000000..98c02171b
--- /dev/null
+++ b/arm64_raw_sve_float_arithmetic_test.go
@@ -0,0 +1,165 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVEFloatArithmeticCase struct {
+	op        string
+	size      int
+	mode      string
+	immediate float64
+	lane      int
+}
+
+func arm64RawSVEFloatArithmeticCases() []arm64RawSVEFloatArithmeticCase {
+	var forms []arm64RawSVEFloatArithmeticCase
+	for _, op := range []string{"fadd", "fsub", "fsubr", "fmul"} {
+		for size := 1; size < 4; size++ {
+			forms = append(forms, arm64RawSVEFloatArithmeticCase{op: op, size: size, mode: "predicated"})
+			if op != "fsubr" {
+				forms = append(forms, arm64RawSVEFloatArithmeticCase{op: op, size: size, mode: "vector"})
+			}
+			largeImmediate := 1.0
+			if op == "fmul" {
+				largeImmediate = 2.0
+				for lane := 0; lane < 16>>size; lane++ {
+					forms = append(forms, arm64RawSVEFloatArithmeticCase{op: op, size: size, mode: "indexed", lane: lane})
+				}
+			}
+			for _, immediate := range []float64{0.5, largeImmediate} {
+				forms = append(forms, arm64RawSVEFloatArithmeticCase{op: op, size: size, mode: "immediate", immediate: immediate})
+			}
+		}
+	}
+	return forms
+}
+
+func (form arm64RawSVEFloatArithmeticCase) assembly(dst, first, second, predicate int) string {
+	width := "bhsd"[form.size]
+	switch form.mode {
+	case "vector":
+		return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c", form.op, dst, width, first, width, second, width)
+	case "indexed":
+		return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c[%d]", form.op, dst, width, first, width, second, width, form.lane)
+	case "immediate":
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, #%0.1f", form.op, dst, width, predicate, dst, width, form.immediate)
+	default:
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, z%d.%c", form.op, dst, width, predicate, dst, width, second, width)
+	}
+}
+
+func TestARM64RawSVEFloatArithmeticCompleteFormats(t *testing.T) {
+	forms := arm64RawSVEFloatArithmeticCases()
+	if len(forms) != 59 {
+		t.Fatalf("floating arithmetic cases=%d, want 59 including every indexed lane", len(forms))
+	}
+	testARM64RawSVEFloatArithmeticObjects(t, forms)
+}
+
+func testARM64RawSVEFloatArithmeticObjects(t *testing.T, forms []arm64RawSVEFloatArithmeticCase) {
+	t.Helper()
+	var lines []string
+	for _, form := range forms {
+		second := 29
+		if form.mode == "indexed" {
+			second = 7
+			if form.size == 3 {
+				second = 15
+			}
+		}
+		lines = append(lines, form.assembly(31, 30, second, 7))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatarithmetic(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawfloatarithmetic": {Name: "rawfloatarithmetic", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawfloatarithmetic.ll", "rawfloatarithmetic.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEFloatArithmeticOperandFields(t *testing.T) {
+	var lines []string
+	var wants []arm64RawSVEFloat
+	for _, form := range arm64RawSVEFloatArithmeticCases() {
+		predicated := form.mode == "predicated" || form.mode == "immediate"
+		limits := []int{32, 32, 32, 1}
+		if predicated {
+			limits[1], limits[3] = 1, 8
+		}
+		if form.mode == "immediate" {
+			limits[2] = 1
+		} else if form.mode == "indexed" {
+			limits[2] = 8
+			if form.size == 3 {
+				limits[2] = 16
+			}
+		}
+		for field, limit := range limits {
+			for value := 0; value < limit; value++ {
+				fields := [4]int{31, 30, limits[2] - 1, limits[3] - 1}
+				fields[field] = value
+				dst, first, second, predicate := fields[0], fields[1], fields[2], fields[3]
+				lines = append(lines, form.assembly(dst, first, second, predicate))
+				kind := map[string]arm64RawSVEFloatKind{
+					"fadd": arm64RawSVEFloatAdd, "fsub": arm64RawSVEFloatSub,
+					"fsubr": arm64RawSVEFloatSubReverse, "fmul": arm64RawSVEFloatMul,
+				}[form.op]
+				want := arm64RawSVEFloat{kind: kind, elementBits: 8 << form.size,
+					destination: dst, first: first, second: second, predicated: predicated}
+				if predicated {
+					want.first, want.second, want.predicate = second, 0, predicate
+				}
+				if form.mode == "immediate" {
+					want.first, want.hasImmediate, want.immediate = dst, true, form.immediate
+				} else if form.mode == "indexed" {
+					want.hasLane, want.lane = true, form.lane
+				}
+				wants = append(wants, want)
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVEFloat(word)
+		if !ok || got != wants[i] {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+		if wants[i].hasImmediate {
+			for bit := uint32(6); bit < 10; bit++ {
+				if got, ok := decodeARM64RawSVEFloat(word | 1<<bit); ok {
+					t.Fatalf("reserved immediate bit %d decoded as %+v", bit, got)
+				}
+			}
+		}
+		if !wants[i].hasLane {
+			if got, ok := decodeARM64RawSVEFloat(word &^ (3 << 22)); ok {
+				t.Fatalf("reserved byte-width encoding decoded as %+v", got)
+			}
+		}
+	}
+	for _, word := range []uint32{0, 0x651c8000, 0x64a02400, 0x65048000} {
+		if got, ok := decodeARM64RawSVEFloat(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_float_compare_runtime_test.go b/arm64_raw_sve_float_compare_runtime_test.go
new file mode 100644
index 000000000..3b760f6fe
--- /dev/null
+++ b/arm64_raw_sve_float_compare_runtime_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEFloatCompareRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, width := range []struct {
+		suffix, load, ctype, samples string
+		bytes                        int
+	}{
+		{"h", "h", "uint16_t", "0, 0x8000, 0x3c00, 0xbc00, 0x7c00, 0xfc00, 0x7e01, 0x7c01, 1, 0x8001", 2},
+		{"s", "w", "uint32_t", "0, 0x80000000, 0x3f800000, 0xbf800000, 0x7f800000, 0xff800000, 0x7fc00001, 0x7f800001, 1, 0x80000001", 4},
+		{"d", "d", "uint64_t", "0, 0x8000000000000000ULL, 0x3ff0000000000000ULL, 0xbff0000000000000ULL, 0x7ff0000000000000ULL, 0xfff0000000000000ULL, 0x7ff8000000000001ULL, 0x7ff0000000000001ULL, 1, 0x8000000000000001ULL", 8},
+	} {
+		for _, zero := range []bool{false, true} {
+			ops := []string{"facge", "facgt", "fcmeq", "fcmge", "fcmgt", "fcmne", "fcmuo"}
+			if zero {
+				ops = []string{"fcmeq", "fcmge", "fcmgt", "fcmle", "fcmlt", "fcmne"}
+			}
+			for _, op := range ops {
+				for _, pattern := range []string{"all", "vl3"} {
+					name := fmt.Sprintf("compare_%s_%s_%t_%s", op, width.suffix, zero, pattern)
+					second := "z31." + width.suffix
+					if zero {
+						second = "#0.0"
+					}
+					native := []string{
+						"ptrue p0.b",
+						fmt.Sprintf("ptrue p7.%s, %s", width.suffix, pattern),
+						fmt.Sprintf("ld1%s { z30.%s }, p0/z, [x0]", width.load, width.suffix),
+						fmt.Sprintf("ld1%s { z31.%s }, p0/z, [x1]", width.load, width.suffix),
+						fmt.Sprintf("%s p15.%s, p7/z, z30.%s, %s", op, width.suffix, width.suffix, second),
+						"mov z0.b, #-1",
+						"mov z1.b, #0",
+						fmt.Sprintf("sel z0.%s, p15, z0.%s, z1.%s", width.suffix, width.suffix, width.suffix),
+						"st1b { z0.b }, p0, [x2]",
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+					for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+						fmt.Fprintf(&source, "WORD $%#08x\n", word)
+					}
+					source.WriteString("RET\n")
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+					assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+					fmt.Fprintf(&checks, `    {
+      const %s samples[] = {%s};
+      for (unsigned shift = 0; shift < 10; shift++) {
+        %s a[128], b[128];
+        for (unsigned i = 0; i < vl / %d; i++) {
+          a[i] = samples[(i + shift) %% 10];
+          b[i] = samples[(9 - i %% 10 + shift) %% 10];
+        }
+        unsigned char got[256] = {0}, want[256] = {0};
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [out]"r"(want)
+          : "p0", "p7", "p15", "z0", "z1", "z30", "z31", "memory");
+        %s(a, b, got);
+        if (memcmp(got, want, vl) != 0) {
+          fprintf(stderr, "%s: vl=%%u shift=%%u\n", vl, shift);
+          return %d;
+        }
+      }
+    }
+`, width.ctype, width.samples, width.ctype, width.bytes, assembly, name, name, len(sigs))
+				}
+			}
+		}
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_float_compare", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_float_compare_test.go b/arm64_raw_sve_float_compare_test.go
new file mode 100644
index 000000000..9562b7df4
--- /dev/null
+++ b/arm64_raw_sve_float_compare_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEFloatCompareNativeForms() []string {
+	var result []string
+	for _, width := range []string{"h", "s", "d"} {
+		for _, op := range []string{"facge", "facgt", "fcmeq", "fcmge", "fcmgt", "fcmne", "fcmuo"} {
+			result = append(result, fmt.Sprintf("%s p15.%s, p7/z, z30.%s, z31.%s", op, width, width, width))
+		}
+		for _, op := range []string{"fcmeq", "fcmge", "fcmgt", "fcmle", "fcmlt", "fcmne"} {
+			result = append(result, fmt.Sprintf("%s p1.%s, p0/z, z2.%s, #0.0", op, width, width))
+		}
+	}
+	return result
+}
+
+func TestARM64RawSVEFloatingCompareCompleteFormats(t *testing.T) {
+	lines := arm64RawSVEFloatCompareNativeForms()
+	var source strings.Builder
+	source.WriteString("TEXT rawfloatcompare(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawfloatcompare": {Name: "rawfloatcompare", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, comparison := range []string{"oge", "ogt", "ole", "olt", "oeq", "une", "uno"} {
+				if !strings.Contains(ir, "fcmp "+comparison) {
+					t.Fatalf("missing %s comparison", comparison)
+				}
+			}
+			compileLLVMToObject(t, llc, triple, "floatcompare.ll", "floatcompare.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEFloatingCompareOperandFields(t *testing.T) {
+	lines := arm64RawSVEFloatCompareNativeForms()
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVEFloatCompare(word)
+		if !ok {
+			t.Fatalf("%s: rejected %#08x", lines[i], word)
+		}
+		width := "HSD"[i/13]
+		wantOp := Op("Z" + strings.ToUpper(strings.Fields(lines[i])[0]))
+		first, governing, destination := "Z30", "P7.Z", "P15"
+		if i%13 >= 7 {
+			first, governing, destination = "Z2", "P0.Z", "P1"
+			if got.Args[0].Kind != OpImm || !got.Args[0].ImmIsFloat || got.Args[0].Imm != 0 {
+				t.Errorf("%s: expected floating zero, got %+v", lines[i], got.Args[0])
+			}
+		} else if got.Args[0].Reg != Reg(fmt.Sprintf("Z31.%c", width)) {
+			t.Errorf("%s: wrong second source: %+v", lines[i], got.Args[0])
+		}
+		if got.Op != wantOp || got.Args[1].Reg != Reg(fmt.Sprintf("%s.%c", first, width)) ||
+			got.Args[2].Reg != Reg(governing) || got.Args[3].Reg != Reg(fmt.Sprintf("%s.%c", destination, width)) {
+			t.Errorf("%s: wrong decoded operands: %+v", lines[i], got)
+		}
+	}
+	for _, word := range []uint32{0x6500c000, 0x65a0c000, 0x6591a000, 0x65922010} {
+		if got, ok := decodeARM64RawSVEFloatCompare(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_float_divide_scale_test.go b/arm64_raw_sve_float_divide_scale_test.go
new file mode 100644
index 000000000..47bf755d8
--- /dev/null
+++ b/arm64_raw_sve_float_divide_scale_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEFloatDivideScaleCases() []arm64RawSVEFloatArithmeticCase {
+	var forms []arm64RawSVEFloatArithmeticCase
+	for _, op := range []string{"fdiv", "fdivr", "fscale"} {
+		for size := 1; size < 4; size++ {
+			forms = append(forms, arm64RawSVEFloatArithmeticCase{op: op, size: size, mode: "predicated"})
+		}
+	}
+	return forms
+}
+
+func TestARM64RawSVEFloatDivideScaleCompleteFormats(t *testing.T) {
+	testARM64RawSVEFloatArithmeticObjects(t, arm64RawSVEFloatDivideScaleCases())
+}
+
+func TestARM64RawSVEFloatDivideScaleOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, form := range arm64RawSVEFloatDivideScaleCases() {
+		for field, limit := range [3]int{32, 32, 8} {
+			for value := 0; value < limit; value++ {
+				fields := [3]int{31, 30, 7}
+				fields[field] = value
+				dst, second, predicate := fields[0], fields[1], fields[2]
+				lines = append(lines, form.assembly(dst, dst, second, predicate))
+				register := func(number int) Operand {
+					return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", number, "BHSD"[form.size]))}
+				}
+				wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(form.op)), Args: []Operand{
+					register(second), register(dst), {Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", predicate))}, register(dst),
+				}})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		got, ok := decodeARM64RawSVEFloatDivideScale(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+		if got, ok := decodeARM64RawSVEFloatDivideScale(word &^ (3 << 22)); ok {
+			t.Errorf("reserved byte-width encoding decoded as %+v", got)
+		}
+	}
+	for _, word := range []uint32{0x65008000, 0x650da000, 0x65098000, 0x658da000, 0x65808000} {
+		if got, ok := decodeARM64RawSVEFloatDivideScale(word); ok {
+			t.Errorf("neighboring/reserved word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_float_immediate_runtime_test.go b/arm64_raw_sve_float_immediate_runtime_test.go
new file mode 100644
index 000000000..e0d138e75
--- /dev/null
+++ b/arm64_raw_sve_float_immediate_runtime_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEFloatImmediateRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		size, predicate int
+		native          []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for size := 1; size < 4; size++ {
+		for _, predicate := range []int{-1, 0, 7, 8, 15} {
+			native := []string{
+				"ptrue p1.b", "ld1b { z30.b }, p1/z, [x0]",
+				"ld1b { z28.b }, p1/z, [x1]", "cmpne p7.b, p1/z, z28.b, #0",
+			}
+			if predicate >= 0 {
+				native = append(native, fmt.Sprintf("orr p%d.b, p1/z, p7.b, p7.b", predicate))
+			}
+			// Batch all immediates in one function, with sequential VL-sized
+			// outputs. The complete domain needs only fifteen runtime functions.
+			for imm := 0; imm < 256; imm++ {
+				native = append(native, "mov z31.d, z30.d",
+					arm64SVEFloatImmediateAssembly(size, 31, predicate, imm),
+					"st1b { z31.b }, p1, [x2]", "addvl x2, x2, #1")
+			}
+			cases = append(cases, runtimeCase{size, predicate, native})
+			allNative = append(allNative, native...)
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEFloatImmediateRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("float_immediate_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD mask+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("x0", "%[a]", "x1", "%[mask]", "x2", "%[out]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" : [out]"+&r"(out) : [a]"r"(a), [mask]"r"(mask)
+    : "p0", "p1", "p7", "p8", "p15", "z28", "z30", "z31", "memory");
+}
+`, name, assembly)
+		predicated := 0
+		if test.predicate >= 0 {
+			predicated = 1
+		}
+		fmt.Fprintf(&checks, "  if (check_float_immediate(vl, %d, %d, %s, %s_native, %q)) return 1;\n",
+			1<<test.size, predicated, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_float_immediate", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEFloatImmediateRuntimeReference = `
+#include <math.h>
+typedef void (*float_immediate_fn)(const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_float_immediate(unsigned vl, unsigned bytes, int predicated,
+    float_immediate_fn translated, float_immediate_fn native_instruction, const char *name) {
+  unsigned char a[256], mask[256];
+  unsigned char got[256 * 256 + 32], native[sizeof(got)], scalar[sizeof(got)];
+  for (unsigned phase = 0; phase < 8; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i++) {
+      a[i] = i * 17 + phase * 29;
+      mask[i] = phase < 2 ? phase : (i + phase) % 3 != 0;
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned imm = 0; imm < 256; imm++) {
+      double value = ldexp(16 + (imm & 15), (int)(((imm >> 4) & 7) ^ 4) - 7);
+      if (imm & 128) value = -value;
+      unsigned char bits[8];
+      if (bytes == 2) {
+        __fp16 h = value;
+        memcpy(bits, &h, bytes);
+      } else if (bytes == 4) {
+        float f = value;
+        memcpy(bits, &f, bytes);
+      } else {
+        memcpy(bits, &value, bytes);
+      }
+      for (unsigned i = 0; i < vl; i += bytes) {
+        memcpy(scalar + imm * vl + i, !predicated || mask[i] ? bits : a + i, bytes);
+      }
+    }
+    native_instruction(a, mask, native);
+    translated(a, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u translated/native=%d native/scalar=%d\n",
+          name, vl, phase, memcmp(got, native, sizeof(got)), memcmp(native, scalar, sizeof(got)));
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_float_minmax_test.go b/arm64_raw_sve_float_minmax_test.go
new file mode 100644
index 000000000..3818d6300
--- /dev/null
+++ b/arm64_raw_sve_float_minmax_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEFloatMinMaxNativeForms() []string {
+	var lines []string
+	for _, op := range []string{"fmax", "fmin", "fmaxnm", "fminnm"} {
+		for i, width := range []string{"h", "s", "d"} {
+			lines = append(lines,
+				fmt.Sprintf("%s z31.%s, p7/m, z31.%s, z30.%s", op, width, width, width),
+				fmt.Sprintf("%s z31.%s, p7/m, z31.%s, #0.0", op, width, width),
+				fmt.Sprintf("%s z31.%s, p7/m, z31.%s, #1.0", op, width, width),
+				fmt.Sprintf("%sp z31.%s, p7/m, z31.%s, z30.%s", op, width, width, width),
+				fmt.Sprintf("%sqv v31.%d%s, p7, z30.%s", op, 8>>i, width, width),
+				fmt.Sprintf("%sv %s31, p7, z30.%s", op, width, width))
+		}
+	}
+	return lines
+}
+
+func TestARM64RawSVEFloatMinMaxOperandFields(t *testing.T) {
+	lines := arm64RawSVEFloatMinMaxNativeForms()
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		if i%6 == 5 {
+			if _, ok := decodeARM64RawSVEFloatMinMaxReduction(word); !ok {
+				t.Errorf("missing ordinary reduction %s", lines[i])
+			}
+			continue
+		}
+		got, ok := decodeARM64RawSVEFloatMinMax(word)
+		if !ok {
+			t.Fatalf("%s: rejected %#08x", lines[i], word)
+		}
+		fields := strings.Fields(lines[i])
+		width := "HSD"[(i/6)%3]
+		if got.Op != Op("Z"+strings.ToUpper(fields[0])) {
+			t.Errorf("%s: wrong opcode %s", lines[i], got.Op)
+		}
+		if i%6 == 1 || i%6 == 2 {
+			if got.Args[0].Kind != OpImm || !got.Args[0].ImmIsFloat || math.Float64frombits(uint64(got.Args[0].Imm)) != float64(i%6-1) {
+				t.Errorf("%s: wrong immediate %+v", lines[i], got.Args[0])
+			}
+		} else if got.Args[0].Reg != Reg(fmt.Sprintf("Z30.%c", width)) {
+			t.Errorf("%s: wrong source %+v", lines[i], got.Args[0])
+		}
+		if i%6 == 4 {
+			if got.Args[1].Reg != "P7" || got.Args[2].Reg != Reg(fmt.Sprintf("V31.%c%d", width, 8>>((i/6)%3))) {
+				t.Errorf("%s: wrong quad reduction %+v", lines[i], got)
+			}
+		} else if got.Args[1].Reg != Reg(fmt.Sprintf("Z31.%c", width)) || got.Args[2].Reg != "P7.M" || got.Args[3].Reg != got.Args[1].Reg {
+			t.Errorf("%s: wrong destructive form %+v", lines[i], got)
+		}
+	}
+	for _, word := range []uint32{0x65068000, 0x659e8040, 0x65888000, 0x659ea000} {
+		if got, ok := decodeARM64RawSVEFloatMinMax(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
+
+func TestARM64RawSVEFloatMinMaxCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawminmax(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, arm64RawSVEFloatMinMaxNativeForms(), "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawminmax": {Name: "rawminmax", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawminmax.ll", "rawminmax.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_sve_float_regression_test.go b/arm64_raw_sve_float_regression_test.go
new file mode 100644
index 000000000..d142b1e78
--- /dev/null
+++ b/arm64_raw_sve_float_regression_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEFloatOpcodeAndSourceFields(t *testing.T) {
+	for _, test := range []struct {
+		native             string
+		kind               arm64RawSVEFloatKind
+		first, destination int
+	}{
+		{"fsub z4.s, p2/m, z4.s, z7.s", arm64RawSVEFloatSub, 7, 4},
+		{"fmul z4.d, p7/m, z4.d, z7.d", arm64RawSVEFloatMul, 7, 4},
+		{"faddv h3, p1, z7.h", arm64RawSVEFloatFADDV, 7, 3},
+	} {
+		word := assembleARM64LLVMWords(t, []string{test.native}, "+sve")[0]
+		got, ok := decodeARM64RawSVEFloat(word)
+		if !ok || got.kind != test.kind || got.first != test.first || got.destination != test.destination {
+			t.Errorf("%s: decoded %#08x as %+v, %v", test.native, word, got, ok)
+		}
+	}
+	for _, native := range []string{"fmax z4.s, p2/m, z4.s, z7.s", "fdiv z0.d, p0/m, z0.d, z1.d"} {
+		word := assembleARM64LLVMWords(t, []string{native}, "+sve")[0]
+		if got, ok := decodeARM64RawSVEFloat(word); ok {
+			t.Errorf("unrelated %s must not decode as arithmetic %+v", native, got)
+		}
+	}
+}
+
+func TestARM64RawSVEFloatUsesSharedNamedSemantics(t *testing.T) {
+	for _, test := range []struct{ native, want string }{
+		{"fsub z4.s, p2/m, z4.s, z7.s", "fsub <vscale x 4 x float>"},
+		{"fmul z4.d, p7/m, z4.d, z7.d", "fmul <vscale x 2 x double>"},
+		{"faddv h3, p1, z7.h", "call half @llvm.aarch64.sve.faddv.nxv8f16"},
+		{"fadda s3, p1, s3, z7.s", "call float @llvm.aarch64.sve.fadda.nxv4f32"},
+	} {
+		word := assembleARM64LLVMWords(t, []string{test.native}, "+sve")[0]
+		source := fmt.Sprintf("TEXT rawfloat(SB),$0-0\nWORD $%#08x\nRET\n", word)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"rawfloat": {Name: "rawfloat", Ret: Void}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(ir, test.want) {
+			t.Errorf("%s omitted %s", test.native, test.want)
+		}
+	}
+}
diff --git a/arm64_raw_sve_float_runtime_test.go b/arm64_raw_sve_float_runtime_test.go
new file mode 100644
index 000000000..1534963a6
--- /dev/null
+++ b/arm64_raw_sve_float_runtime_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEFloatRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	ops := []string{"fadd", "fsub", "fmul", "faddv", "fadda", "frecpe", "frsqrte"}
+	for _, op := range []string{"fabs", "fneg", "frecpx", "frinta", "frinti", "frintm", "frintn", "frintp", "frintx", "frintz", "fsqrt"} {
+		ops = append(ops, op, op+"_zero")
+	}
+	for _, op := range []string{"fmax", "fmin", "fmaxnm", "fminnm"} {
+		ops = append(ops, op, op+"_zeroimm", op+"_oneimm", op+"p", op+"v")
+	}
+	for _, width := range []struct {
+		suffix, scalar, ctype string
+		bytes                 int
+	}{
+		{"h", "h", "_Float16", 2}, {"s", "s", "float", 4}, {"d", "d", "double", 8},
+	} {
+		for _, op := range ops {
+			minmax := strings.HasPrefix(op, "fmax") || strings.HasPrefix(op, "fmin")
+			name := op + "_" + width.suffix
+			loadStore := map[int]string{2: "h", 4: "w", 8: "d"}[width.bytes]
+			native := []string{
+				"ptrue p7.b",
+				fmt.Sprintf("ptrue p0.%s, vl3", width.suffix),
+				fmt.Sprintf("ld1%s { z0.%s }, p7/z, [x0]", loadStore, width.suffix),
+				fmt.Sprintf("ld1%s { z1.%s }, p7/z, [x1]", loadStore, width.suffix),
+				fmt.Sprintf("ld1%s { z5.%s }, p7/z, [x0]", loadStore, width.suffix),
+			}
+			count := "vl"
+			if op == "faddv" || op == "fadda" {
+				native[2] = fmt.Sprintf("ld1%s { z0.%s }, p7/z, [x1]", loadStore, width.suffix)
+				instruction := fmt.Sprintf("faddv %s0, p0, z5.%s", width.scalar, width.suffix)
+				if op == "fadda" {
+					instruction = fmt.Sprintf("fadda %s0, p0, %s0, z5.%s", width.scalar, width.scalar, width.suffix)
+				}
+				native = append(native, instruction, "st1b { z0.b }, p7, [x2]")
+			} else if minmax {
+				instruction := ""
+				if strings.HasSuffix(op, "v") {
+					instruction = fmt.Sprintf("%s %s0, p0, z5.%s", op, width.scalar, width.suffix)
+				} else {
+					operation, second := op, "z1."+width.suffix
+					if strings.HasSuffix(op, "imm") {
+						operation = strings.SplitN(op, "_", 2)[0]
+						second = "#0.0"
+						if strings.HasSuffix(op, "_oneimm") {
+							second = "#1.0"
+						}
+					}
+					instruction = fmt.Sprintf("%s z0.%s, p0/m, z0.%s, %s", operation, width.suffix, width.suffix, second)
+				}
+				native = append(native, instruction, "st1b { z0.b }, p7, [x2]")
+			} else if op == "fadd" || op == "fsub" || op == "fmul" {
+				native = append(native, fmt.Sprintf("%s z0.%s, p0/m, z0.%s, z1.%s", op, width.suffix, width.suffix, width.suffix),
+					"st1b { z0.b }, p7, [x2]")
+			} else if op == "frecpe" || op == "frsqrte" {
+				native = append(native, fmt.Sprintf("%s z0.%s, z5.%s", op, width.suffix, width.suffix), "st1b { z0.b }, p7, [x2]")
+			} else {
+				operation := strings.TrimSuffix(op, "_zero")
+				native = append(native, fmt.Sprintf("%s z0.%s, p0/m, z5.%s", operation, width.suffix, width.suffix), "st1b { z0.b }, p7, [x2]")
+			}
+			raw := append([]string(nil), native...)
+			if strings.HasSuffix(op, "_zero") {
+				// QEMU's SVE1 oracle expresses newer zeroing encodings as a
+				// cleared destination followed by the native merging operation.
+				at := len(native) - 2
+				raw[at] = strings.Replace(raw[at], "p0/m", "p0/z", 1)
+				native = append(native[:at:at], "mov z0.b, #0", native[at], native[at+1])
+			}
+			words := assembleARM64LLVMWords(t, raw, "+sve2p2")
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+			for _, word := range words {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+			assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+			samples, sampleCount, phases := "65504, -65504, 0.125, -0.0, 0.00001, -1.0", 6, 1
+			second := fmt.Sprintf("(%s)(i + 2)", width.ctype)
+			if minmax {
+				samples = "0.0, -0.0, __builtin_nan(\"\"), 1.0, -1.0, __builtin_inf(), -__builtin_inf(), 0.00001, 65504, -65504"
+				sampleCount, phases = 10, 10
+				second = fmt.Sprintf("(%s)samples[(i + phase + 3) %% 10]", width.ctype)
+			}
+			fmt.Fprintf(&checks, `    {
+    for (unsigned phase = 0; phase < %d; phase++) {
+      %s a[128], b[128];
+      const double samples[] = {%s};
+      for (unsigned i = 0; i < vl / %d; i++) {
+        a[i] = (%s)samples[(i + phase) %% %d];
+        b[i] = %s;
+      }
+      unsigned char got[256] = {0}, want[256] = {0};
+      __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [out]"r"(want)
+        : "p0", "p7", "z0", "z1", "z5", "memory");
+      %s(a, b, got);
+      if (memcmp(got, want, %s) != 0) {
+        fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+        return %d;
+      }
+    }
+    }
+`, phases, width.ctype, samples, width.bytes, width.ctype, sampleCount, second, assembly, name, count, name, len(sigs))
+		}
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.5-a+sve2"}, "raw_float_sve", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_float_unary_test.go b/arm64_raw_sve_float_unary_test.go
new file mode 100644
index 000000000..95efe0cd2
--- /dev/null
+++ b/arm64_raw_sve_float_unary_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEFloatUnaryNativeForms() []string {
+	var lines []string
+	for _, op := range []string{"fabs", "fneg", "frecpx", "frinta", "frinti", "frintm", "frintn", "frintp", "frintx", "frintz", "fsqrt", "frint32x", "frint32z", "frint64x", "frint64z", "frecpe", "frsqrte"} {
+		widths := []string{"h", "s", "d"}
+		if strings.HasPrefix(op, "frint32") || strings.HasPrefix(op, "frint64") {
+			widths = widths[1:]
+		}
+		for _, width := range widths {
+			if op == "frecpe" || op == "frsqrte" {
+				lines = append(lines, fmt.Sprintf("%s z31.%s, z30.%s", op, width, width))
+				continue
+			}
+			for _, mode := range []string{"m", "z"} {
+				lines = append(lines, fmt.Sprintf("%s z31.%s, p7/%s, z30.%s", op, width, mode, width))
+			}
+		}
+	}
+	return lines
+}
+
+func TestARM64RawSVEFloatUnaryCompleteFormats(t *testing.T) {
+	lines := arm64RawSVEFloatUnaryNativeForms()
+	var source strings.Builder
+	source.WriteString("TEXT rawunary(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p2,+fptoint") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawunary": {Name: "rawunary", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawunary.ll", "rawunary.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEFloatUnaryOperandFields(t *testing.T) {
+	lines := arm64RawSVEFloatUnaryNativeForms()
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p2,+fptoint") {
+		got, ok := decodeARM64RawSVEFloatUnary(word)
+		if !ok {
+			t.Fatalf("%s: rejected %#08x", lines[i], word)
+		}
+		fields := strings.Fields(strings.ReplaceAll(lines[i], ",", ""))
+		if got.Op != Op("Z"+strings.ToUpper(fields[0])) ||
+			got.Args[0].Reg != Reg(strings.ToUpper(fields[len(fields)-1])) ||
+			got.Args[len(got.Args)-1].Reg != Reg(strings.ToUpper(fields[1])) {
+			t.Errorf("%s: wrong operands: %+v", lines[i], got)
+		}
+		if len(fields) == 4 && got.Args[1].Reg != Reg(strings.ToUpper(strings.ReplaceAll(fields[2], "/", "."))) {
+			t.Errorf("%s: wrong predicate: %+v", lines[i], got.Args[1])
+		}
+	}
+	for _, word := range []uint32{0x041da000, 0x6591a000, 0x658eb000, 0x658e3400, 0x049de000} {
+		if got, ok := decodeARM64RawSVEFloatUnary(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_index_test.go b/arm64_raw_sve_index_test.go
new file mode 100644
index 000000000..a7d4ce4a6
--- /dev/null
+++ b/arm64_raw_sve_index_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEIndexCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawindex(SB),$0-0\n")
+	for size := uint32(0); size < 4; size++ {
+		for form := uint32(0); form < 4; form++ {
+			for _, operands := range [][3]uint32{{0, 1, 16}, {15, 16, 31}, {31, 31, 0}} {
+				word := uint32(0x04204000) | size<<22 | form<<10 |
+					operands[0]<<5 | operands[1]<<16 | operands[2]
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawindex": {Name: "rawindex", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, bits := range []int{8, 16, 32, 64} {
+				want := fmt.Sprintf("call <vscale x %d x i%d> @llvm.aarch64.sve.index", 128/bits, bits)
+				if got := strings.Count(ir, want); got != 12 {
+					t.Fatalf("%d-bit INDEX calls = %d, want 12", bits, got)
+				}
+			}
+			if !strings.Contains(ir, "i32 0, i32 1)") || !strings.Contains(ir, "i8 15, i8 -16)") {
+				t.Fatal("INDEX lost immediate order or sign extension")
+			}
+			compileLLVMToObject(t, llc, triple, "rawindex.ll", "rawindex.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEIndexDecoderBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		op          Op
+		step, start Operand
+		dst         Reg
+	}{
+		{0x04a14010, "ZINDEX", Operand{Kind: OpImm, Imm: 1}, Operand{Kind: OpImm}, "Z16.S"},
+		{0x04304483, "ZINDEXW", Operand{Kind: OpImm, Imm: -16}, Operand{Kind: OpReg, Reg: "R4"}, "Z3.B"},
+		{0x046649e5, "ZINDEXW", Operand{Kind: OpReg, Reg: "R6"}, Operand{Kind: OpImm, Imm: 15}, "Z5.H"},
+		{0x04e94d07, "ZINDEX", Operand{Kind: OpReg, Reg: "R9"}, Operand{Kind: OpReg, Reg: "R8"}, "Z7.D"},
+		{0x04bf4ffe, "ZINDEXW", Operand{Kind: OpReg, Reg: ZR}, Operand{Kind: OpReg, Reg: ZR}, "Z30.S"},
+	} {
+		got, ok := decodeARM64RawSVEIndex(test.word)
+		if !ok || got.Op != test.op || len(got.Args) != 3 {
+			t.Fatalf("decode %#08x = %+v, %v", test.word, got, ok)
+		}
+		if !reflect.DeepEqual(got.Args[0], test.step) || !reflect.DeepEqual(got.Args[1], test.start) || got.Args[2].Reg != test.dst {
+			t.Errorf("decode %#08x operands = %+v", test.word, got.Args)
+		}
+	}
+	for _, word := range []uint32{0x04205000, 0x04004000, 0x04208000, 0x05204000} {
+		if got, ok := decodeARM64RawSVEIndex(word); ok {
+			t.Errorf("INDEX accepted adjacent encoding %#08x as %+v", word, got)
+		}
+	}
+}
+
+func TestARM64RawSVEIndexMatchesLLVM22Encoder(t *testing.T) {
+	var lines []string
+	var want []uint32
+	for size, width := range []string{"b", "h", "s", "d"} {
+		reg := "w"
+		if width == "d" {
+			reg = "x"
+		}
+		lines = append(lines,
+			fmt.Sprintf("index z16.%s, #0, #1", width),
+			fmt.Sprintf("index z16.%s, %s0, #1", width, reg),
+			fmt.Sprintf("index z16.%s, #0, %s1", width, reg),
+			fmt.Sprintf("index z16.%s, %s0, %s1", width, reg, reg))
+		for form := uint32(0); form < 4; form++ {
+			want = append(want, 0x04214010|uint32(size)<<22|form<<10)
+		}
+	}
+	if got := assembleARM64LLVMWords(t, lines, "+sve"); !reflect.DeepEqual(got, want) {
+		t.Fatalf("LLVM 22 INDEX encodings = %#v, want %#v", got, want)
+	}
+}
diff --git a/arm64_raw_sve_integer_dot_runtime_test.go b/arm64_raw_sve_integer_dot_runtime_test.go
new file mode 100644
index 000000000..aedcea07a
--- /dev/null
+++ b/arm64_raw_sve_integer_dot_runtime_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEIntegerDotRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(`
+static int64_t dot_element(const unsigned char *data, unsigned index, unsigned bytes, int is_signed) {
+  uint16_t value = 0;
+  memcpy(&value, data + index * bytes, bytes);
+  if (is_signed) return bytes == 1 ? (int8_t)value : (int16_t)value;
+  return value;
+}
+`)
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64RawSVEIntegerDotCases() {
+		// QEMU 10.2 implements SVE2.1 but not the SVE2.3 B->H dot products.
+		// The latter retain independent encoding and three-platform object tests.
+		if form.destination == "h" {
+			continue
+		}
+		lanes := 1
+		if form.indexed {
+			lanes = form.lanes
+		}
+		first := form.maximumVector
+		for lane := 0; lane < lanes; lane++ {
+			for _, destination := range []int{first, 30, 31} {
+				name := fmt.Sprintf("integerdot_%d", len(sigs))
+				native := []string{
+					"ptrue p0.b",
+					fmt.Sprintf("ld1b { z%d.b }, p0/z, [x0]", first),
+					"ld1b { z30.b }, p0/z, [x1]",
+					"ld1b { z31.b }, p0/z, [x2]",
+					form.assembly(destination, 30, first, lane),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD acc+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+				words := assembleARM64LLVMWords(t, native, "+sve2p1,+i8mm")
+				for _, word := range words {
+					fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				}
+				source.WriteString("RET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+				// The cross assembler can predate SVE2.1. Encode just the tested
+				// instruction with the independently checked LLVM MC word.
+				native[4] = fmt.Sprintf(".inst %#08x", words[4])
+				assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[acc]]", "[x3]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+				sourceBytes, destinationBytes := 1, 4
+				if form.source == "h" {
+					sourceBytes = 2
+				}
+				if form.destination == "d" {
+					destinationBytes = 8
+				}
+				firstSigned, secondSigned, indexed := 0, 0, 0
+				if form.op == "sdot" || form.op == "usdot" {
+					firstSigned = 1
+				}
+				if form.op == "sdot" || form.op == "sudot" {
+					secondSigned = 1
+				}
+				if form.indexed {
+					indexed = 1
+				}
+				accumulator := "acc"
+				if destination == first {
+					accumulator = "a"
+				} else if destination == 30 {
+					accumulator = "b"
+				}
+				fmt.Fprintf(&checks, `    {
+      static const unsigned char edge[] = {0, 1, 127, 128, 255, 254, 85, 170};
+      unsigned char a[256], b[256], acc[256], got[256], want[256], oracle[256];
+      const unsigned source_bytes = %d, destination_bytes = %d;
+      for (unsigned phase = 0; phase < 12; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase < 8 ? edge[(phase + i) %% 8] : i * 37 + phase * 13;
+          b[i] = phase < 8 ? edge[(phase * 3 + i / 2) %% 8] : i * 17 + phase * 71;
+          acc[i] = phase < 8 ? edge[phase] : i * 29 + phase;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        memset(oracle, 0x5a, sizeof(oracle));
+        for (unsigned i = 0; i < vl / destination_bytes; i++) {
+          uint64_t value = 0;
+          memcpy(&value, %s + i * destination_bytes, destination_bytes);
+          unsigned group = destination_bytes / source_bytes;
+          for (unsigned j = 0; j < group; j++) {
+            unsigned first_index = %d ? (i * destination_bytes / 16) * (16 / source_bytes) + %d * group + j : i * group + j;
+            int64_t first = dot_element(a, first_index, source_bytes, %d);
+            int64_t second = dot_element(b, i * group + j, source_bytes, %d);
+            value += (uint64_t)(first * second);
+          }
+          memcpy(oracle + i * destination_bytes, &value, destination_bytes);
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [acc]"r"(acc), [out]"r"(want)
+          : "p0", "z7", "z15", "z30", "z31", "memory");
+        %s(a, b, acc, got);
+        if (memcmp(got, want, sizeof(got)) != 0 || memcmp(got, oracle, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          for (unsigned i = 0; i < sizeof(got); i++) {
+            if (got[i] != want[i] || got[i] != oracle[i]) {
+              fprintf(stderr, "byte %%u: got %%02x, native %%02x, scalar %%02x\n", i, got[i], want[i], oracle[i]);
+              break;
+            }
+          }
+          return %d;
+        }
+      }
+    }
+`, sourceBytes, destinationBytes, accumulator, indexed, lane, firstSigned, secondSigned,
+					assembly, name, form.assembly(destination, 30, first, lane), len(sigs))
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.6-a+sve2+i8mm"}, "raw_integerdot", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_integer_dot_test.go b/arm64_raw_sve_integer_dot_test.go
new file mode 100644
index 000000000..c478d5caf
--- /dev/null
+++ b/arm64_raw_sve_integer_dot_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVEIntegerDotCase struct {
+	op, source, destination string
+	indexed                 bool
+	maximumVector, lanes    int
+}
+
+func arm64RawSVEIntegerDotCases() []arm64RawSVEIntegerDotCase {
+	var forms []arm64RawSVEIntegerDotCase
+	for _, op := range []string{"sdot", "udot"} {
+		for _, widths := range []struct {
+			source, destination  string
+			maximumVector, lanes int
+		}{{"b", "h", 7, 8}, {"h", "s", 7, 4}, {"b", "s", 7, 4}, {"h", "d", 15, 2}} {
+			for _, indexed := range []bool{false, true} {
+				forms = append(forms, arm64RawSVEIntegerDotCase{op, widths.source, widths.destination, indexed, widths.maximumVector, widths.lanes})
+			}
+		}
+	}
+	return append(forms,
+		arm64RawSVEIntegerDotCase{"usdot", "b", "s", false, 7, 4},
+		arm64RawSVEIntegerDotCase{"usdot", "b", "s", true, 7, 4},
+		arm64RawSVEIntegerDotCase{"sudot", "b", "s", true, 7, 4})
+}
+
+func (form arm64RawSVEIntegerDotCase) assembly(destination, second, first, lane int) string {
+	index := ""
+	if form.indexed {
+		index = fmt.Sprintf("[%d]", lane)
+	}
+	return fmt.Sprintf("%s z%d.%s, z%d.%s, z%d.%s%s", form.op, destination, form.destination, second, form.source, first, form.source, index)
+}
+
+func TestARM64RawSVEIntegerDotCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, form := range arm64RawSVEIntegerDotCases() {
+		maximumVector, lanes := 31, 1
+		if form.indexed {
+			maximumVector, lanes = form.maximumVector, form.lanes
+		}
+		for lane := 0; lane < lanes; lane++ {
+			lines = append(lines, form.assembly(31, 30, maximumVector, lane))
+		}
+	}
+	source.WriteString("TEXT rawintegerdot(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p3,+i8mm") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawintegerdot": {Name: "rawintegerdot", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawintegerdot.ll", "rawintegerdot.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEIntegerDotOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, form := range arm64RawSVEIntegerDotCases() {
+		limits := []int{32, 32, 32, 1}
+		if form.indexed {
+			limits[2], limits[3] = form.maximumVector+1, form.lanes
+		}
+		for field, limit := range limits {
+			for value := 0; value < limit; value++ {
+				fields := [4]int{31, 30, limits[2] - 1, limits[3] - 1}
+				fields[field] = value
+				lines = append(lines, form.assembly(fields[0], fields[1], fields[2], fields[3]))
+				index := ""
+				if form.indexed {
+					index = fmt.Sprintf("[%d]", fields[3])
+				}
+				wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(form.op)), Args: []Operand{
+					{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s%s", fields[2], strings.ToUpper(form.source), index))},
+					{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", fields[1], strings.ToUpper(form.source)))},
+					{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%s", fields[0], strings.ToUpper(form.destination)))},
+				}})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p3,+i8mm") {
+		got, ok := decodeARM64RawSVEIntegerDot(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x44000000, 0x44000400, 0x44800800, 0x44807400, 0x44a02000} {
+		if got, ok := decodeARM64RawSVEIntegerDot(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_integer_reduction_runtime_test.go b/arm64_raw_sve_integer_reduction_runtime_test.go
new file mode 100644
index 000000000..09b5c4e91
--- /dev/null
+++ b/arm64_raw_sve_integer_reduction_runtime_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEIntegerReductionRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"andv", "eorv", "orv", "addqv", "andqv", "eorqv", "orqv"} {
+		for size := 0; size < 4; size++ {
+			for _, destination := range []int{30, 31} {
+				name := fmt.Sprintf("integer_reduce_%d", len(sigs))
+				native := []string{
+					"ptrue p0.b", "ld1b { z20.b }, p0/z, [x1]", "cmpne p7.b, p0/z, z20.b, #0",
+					"ld1b { z30.b }, p0/z, [x0]", "ld1b { z31.b }, p0/z, [x0]",
+					arm64RawSVEIntegerReductionAssembly(op, size, destination, 31, 7),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x2]", destination),
+				}
+				words := assembleARM64LLVMWords(t, native, "+sve2p1")
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD mask+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+				for _, word := range words {
+					fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				}
+				source.WriteString("RET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+				// LLVM's independent assembler supplies SVE2.1 encodings, so the
+				// native oracle also works with older cross-binutils assemblers.
+				native[5] = fmt.Sprintf(".inst %#08x", words[5])
+				assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[mask]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+				outputBytes, stride := 1<<size, 1<<size
+				if strings.HasSuffix(op, "qv") {
+					outputBytes, stride = 16, 16
+				}
+				identity, operator := "0", "|"
+				switch {
+				case strings.HasPrefix(op, "and"):
+					identity, operator = "UINT64_MAX", "&"
+				case strings.HasPrefix(op, "eor"):
+					operator = "^"
+				case strings.HasPrefix(op, "add"):
+					operator = "+"
+				}
+				fmt.Fprintf(&checks, `    {
+      unsigned char a[256], mask[256], got[256], native[256], scalar[256];
+      const unsigned element = %d;
+      for (unsigned phase = 0; phase < 12; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase == 2 ? 0xff : i * 71 + phase * 83;
+          mask[i] = phase < 2 ? phase : (i / element + phase * 3) %% 7 != 0;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        memset(scalar, 0, vl);
+        for (unsigned j = 0; j < %d; j += element) {
+          uint64_t value = %s;
+          for (unsigned i = j; i < vl; i += %d) {
+            if (mask[i]) {
+              uint64_t input = 0;
+              memcpy(&input, a + i, element);
+              value = value %s input;
+            }
+          }
+          memcpy(scalar + j, &value, element);
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [mask]"r"(mask), [out]"r"(native)
+          : "p0", "p7", "z20", "z30", "z31", "memory");
+        %s(a, mask, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, 1<<size, outputBytes, identity, stride, operator, assembly, name, name, len(sigs))
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_integer_reduce", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_integer_reduction_test.go b/arm64_raw_sve_integer_reduction_test.go
new file mode 100644
index 000000000..9174b0313
--- /dev/null
+++ b/arm64_raw_sve_integer_reduction_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEIntegerReductionAssembly(op string, size, destination, source, predicate int) string {
+	width := "bhsd"[size]
+	register := fmt.Sprintf("%c%d", width, destination)
+	if strings.HasSuffix(op, "qv") {
+		register = fmt.Sprintf("v%d.%d%c", destination, 16>>size, width)
+	}
+	return fmt.Sprintf("%s %s, p%d, z%d.%c", op, register, predicate, source, width)
+}
+
+func TestARM64RawSVEIntegerReductionCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, op := range []string{"andv", "eorv", "orv", "addqv", "andqv", "eorqv", "orqv"} {
+		for size := 0; size < 4; size++ {
+			lines = append(lines, arm64RawSVEIntegerReductionAssembly(op, size, 31, 30, 7))
+		}
+	}
+	source.WriteString("TEXT rawintegerreduce(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawintegerreduce": {Name: "rawintegerreduce", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawintegerreduce.ll", "rawintegerreduce.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEIntegerReductionOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, op := range []string{"andv", "eorv", "orv", "addqv", "andqv", "eorqv", "orqv"} {
+		for size := 0; size < 4; size++ {
+			for field, limit := range []int{32, 32, 8} {
+				for value := 0; value < limit; value++ {
+					fields := [3]int{31, 31, 7}
+					fields[field] = value
+					dst, src, pred := fields[0], fields[1], fields[2]
+					lines = append(lines, arm64RawSVEIntegerReductionAssembly(op, size, dst, src, pred))
+					width := "BHSD"[size]
+					mnemonic := "Z" + strings.ToUpper(op)
+					destination := fmt.Sprintf("V%d", dst)
+					if strings.HasSuffix(op, "qv") {
+						destination += fmt.Sprintf(".%c%d", width, 16>>size)
+					} else {
+						mnemonic += string(width)
+					}
+					wants = append(wants, Instr{Op: Op(mnemonic), Args: []Operand{
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", src, width))},
+						{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", pred))},
+						{Kind: OpReg, Reg: Reg(destination)},
+					}})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		if !arm64RawPoolSVEPreservesNZCV(word) {
+			t.Fatalf("%s: integer reduction unexpectedly clobbers NZCV", lines[i])
+		}
+		if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 || !arm64RawPoolSVEIgnoresAddress(word, 9) {
+			t.Fatalf("%s: vector reduction has unknown or address-dependent GP effects", lines[i])
+		}
+		got, ok := decodeARM64RawSVEIntegerReduction(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x04050000, 0x04054000, 0x04182000 ^ (1 << 13), 0x041b2000, 0x041f2000} {
+		if got, ok := decodeARM64RawSVEIntegerReduction(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_integer_unary_complete_test.go b/arm64_raw_sve_integer_unary_complete_test.go
new file mode 100644
index 000000000..dc24456b1
--- /dev/null
+++ b/arm64_raw_sve_integer_unary_complete_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVEUnaryCase struct {
+	assembly, reference string
+	op                  Op
+	width               string
+	mode                string
+}
+
+func arm64RawSVEUnaryCompleteCases() []arm64RawSVEUnaryCase {
+	var cases []arm64RawSVEUnaryCase
+	for _, family := range []struct {
+		op, widths string
+	}{
+		{"abs", "bhsd"}, {"cls", "bhsd"}, {"clz", "bhsd"}, {"cnot", "bhsd"},
+		{"cnt", "bhsd"}, {"neg", "bhsd"}, {"not", "bhsd"}, {"rbit", "bhsd"},
+		{"sqabs", "bhsd"}, {"sqneg", "bhsd"}, {"revb", "hsd"}, {"revh", "sd"},
+		{"revw", "d"}, {"sxtb", "hsd"}, {"sxth", "sd"}, {"sxtw", "d"},
+		{"uxtb", "hsd"}, {"uxth", "sd"}, {"uxtw", "d"},
+		{"urecpe", "s"}, {"ursqrte", "s"}, {"revd", "q"},
+	} {
+		for _, width := range family.widths {
+			for _, mode := range []string{"m", "z"} {
+				assembly := fmt.Sprintf("%s z0.%c, p7/%s, z30.%c", family.op, width, mode, width)
+				// New zeroing encodings have a baseline merging oracle with a
+				// cleared destination. Source and destination are distinct here.
+				reference := strings.ReplaceAll(assembly, "/z", "/m")
+				if mode == "z" {
+					reference = "mov z0.b, #0\\n\\t" + reference
+				}
+				cases = append(cases, arm64RawSVEUnaryCase{assembly, reference,
+					Op("Z" + strings.ToUpper(family.op)), strings.ToUpper(string(width)), strings.ToUpper(mode)})
+			}
+		}
+	}
+	for _, width := range "bhsd" {
+		assembly := fmt.Sprintf("rev z0.%c, z30.%c", width, width)
+		cases = append(cases, arm64RawSVEUnaryCase{assembly, assembly, "ZREV", strings.ToUpper(string(width)), ""})
+	}
+	return cases
+}
+
+func TestARM64RawSVEIntegerUnaryCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, form := range arm64RawSVEUnaryCompleteCases() {
+		lines = append(lines, form.assembly)
+	}
+	source.WriteString("TEXT rawunary(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawunary": {Name: "rawunary", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawunary.ll", "rawunary.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEIntegerUnaryCompleteOperandFields(t *testing.T) {
+	forms := arm64RawSVEUnaryCompleteCases()
+	var lines []string
+	for _, form := range forms {
+		lines = append(lines, form.assembly)
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p2") {
+		form := forms[i]
+		decode := decodeARM64RawSVEIntegerUnary
+		if form.op == "ZREVD" {
+			decode = decodeARM64RawSVERevd
+		}
+		for field, limit := range []int{32, 32, 8} {
+			if form.mode == "" && field == 2 {
+				continue
+			}
+			for register := 0; register < limit; register++ {
+				shifts := [3]uint{0, 5, 10}
+				mask := uint32(limit-1) << shifts[field]
+				probe := word&^mask | uint32(register)<<shifts[field]
+				regs := [3]int{0, 30, 7}
+				regs[field] = register
+				got, ok := decode(probe)
+				want := []Reg{Reg(fmt.Sprintf("Z%d.%s", regs[1], form.width))}
+				if form.mode != "" {
+					want = append(want, Reg(fmt.Sprintf("P%d.%s", regs[2], form.mode)))
+				}
+				want = append(want, Reg(fmt.Sprintf("Z%d.%s", regs[0], form.width)))
+				if !ok || got.Op != form.op || len(got.Args) != len(want) {
+					t.Fatalf("%s: decoded %#08x as %+v, %v", form.assembly, probe, got, ok)
+				}
+				for j, operand := range want {
+					if got.Args[j].Reg != operand {
+						t.Errorf("%s: operand %d = %s, want %s", form.assembly, j, got.Args[j].Reg, operand)
+					}
+				}
+			}
+		}
+	}
+	for _, word := range []uint32{0x05248000, 0x05658000, 0x05a68000, 0x4400a000, 0x44c1a000, 0x05383c00} {
+		if got, ok := decodeARM64RawSVEIntegerUnary(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+	for _, word := range []uint32{0x056e8000, 0x052ec000, 0x052e6000} {
+		if got, ok := decodeARM64RawSVERevd(word); ok {
+			t.Errorf("reserved/neighboring REVD word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_integer_unary_runtime_test.go b/arm64_raw_sve_integer_unary_runtime_test.go
new file mode 100644
index 000000000..efe29f4c8
--- /dev/null
+++ b/arm64_raw_sve_integer_unary_runtime_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEIntegerUnaryRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	cases := arm64RawSVEUnaryCompleteCases()
+	aliases := make(map[Op]bool)
+	for _, form := range cases {
+		if !aliases[form.op] {
+			aliases[form.op] = true
+			form.assembly = strings.ReplaceAll(form.assembly, "z0.", "z30.")
+			form.reference = strings.ReplaceAll(form.reference, "z0.", "z30.")
+			cases = append(cases, form)
+		}
+	}
+	for _, form := range cases {
+		// QEMU 8 cannot execute SVE2.1 REVD. Its two forms retain required
+		// independent encoding and three-platform object checks.
+		if form.op == "ZREVD" {
+			continue
+		}
+		name := fmt.Sprintf("integer_unary_%d", len(sigs))
+		destination := "z0"
+		if strings.Fields(form.assembly)[1] == "z30."+strings.ToLower(form.width)+"," {
+			destination = "z30"
+		}
+		native := []string{
+			"ptrue p0.b",
+			"ld1b { z0.b }, p0/z, [x0]",
+			"ld1b { z30.b }, p0/z, [x1]",
+			"ld1b { z1.b }, p0/z, [x2]",
+			"cmpne p7.b, p0/z, z1.b, #0",
+			form.assembly,
+			"st1b { " + destination + ".b }, p0, [x3]",
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range assembleARM64LLVMWords(t, native, "+sve2p2") {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+		native[5] = form.reference
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+		fmt.Fprintf(&checks, `    {
+      const uint64_t samples[] = {0, 1, ~0ULL, 0x8080808080808080ULL,
+        0x8000800080008000ULL, 0x8000000080000000ULL, 0x8000000000000000ULL,
+        0x7f7f7f7f7f7f7f7fULL, 0x7fff7fff7fff7fffULL, 0x7fffffff7fffffffULL,
+        0x7fffffffffffffffULL, 0xaaaaaaaaaaaaaaaaULL, 0x5555555555555555ULL};
+      unsigned char a[256], b[256], mask[256], got[256], want[256];
+      for (unsigned pattern = 0; pattern < 15; pattern++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = (i * 17 + pattern * 29) %% 251 + 1;
+          b[i] = samples[(i / 8 + pattern) %% 13] >> (8 * (i %% 8));
+          mask[i] = pattern < 2 ? pattern : (i + pattern) %% 3;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(want)
+          : "p0", "p7", "z0", "z1", "z30", "memory");
+        %s(a, b, mask, got);
+        if (memcmp(got, want, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u pattern=%%u\n", vl, pattern);
+          return %d;
+        }
+      }
+    }
+`, assembly, name, form.assembly, len(sigs))
+	}
+	// A vector-length change must not occur in a live SVE-compiled frame:
+	// compiler-generated spills can use the previous length and corrupt it.
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("checking %d unary forms and aliases across six SVE lengths", len(sigs))
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.5-a+sve2"}, "raw_integer_unary", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_mul_high_runtime_test.go b/arm64_raw_sve_mul_high_runtime_test.go
new file mode 100644
index 000000000..fbbd1fbcc
--- /dev/null
+++ b/arm64_raw_sve_mul_high_runtime_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEMultiplyHighRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		op                           string
+		size, predicate, destination int
+		native                       []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for _, op := range []string{"smulh", "umulh"} {
+		for size := 0; size < 4; size++ {
+			for _, predicate := range []int{-1, 7} {
+				for _, destination := range []int{31, 30, 29} {
+					native := []string{
+						"ptrue p0.b", "ld1b { z30.b }, p0/z, [x0]", "ld1b { z31.b }, p0/z, [x0]",
+						"ld1b { z29.b }, p0/z, [x1]", "ld1b { z28.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z28.b, #0",
+						arm64RawSVEMulHighAssembly(op, size, destination, 30, 29, predicate),
+						fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+					}
+					cases = append(cases, runtimeCase{op, size, predicate, destination, native})
+					allNative = append(allNative, native...)
+				}
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve2")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVEMultiplyHighRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("multiply_high_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(out)
+    : "p0", "p7", "z28", "z29", "z30", "z31", "memory");
+}
+`, name, assembly)
+		signed, predicated, firstB := 0, 0, 0
+		if test.op == "smulh" {
+			signed = 1
+		}
+		if test.predicate >= 0 {
+			predicated = 1
+			if test.destination == 29 {
+				firstB = 1
+			}
+		}
+		fmt.Fprintf(&checks, "  if (check_multiply_high(vl, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			8<<test.size, signed, predicated, firstB, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_multiply_high", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVEMultiplyHighRuntimeReference = `
+typedef void (*multiply_high_fn)(const void *, const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_multiply_high(unsigned vl, unsigned bits, int signed_product, int predicated,
+    int first_b, multiply_high_fn translated, multiply_high_fn native_instruction, const char *name) {
+  unsigned char a[256], b[256], mask[256], got[256], native[256], scalar[256];
+  unsigned bytes = bits / 8;
+  uint64_t sign = UINT64_C(1) << (bits - 1), maximum = UINT64_MAX >> (64 - bits);
+  uint64_t values[] = {0, 1, maximum, sign, sign - 1, sign + 1, 2, 3};
+  for (unsigned phase = 0; phase < 16; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i += bytes) {
+      unsigned lane = i / bytes;
+      uint64_t x = values[(lane + phase) % 8], y = values[(lane * 3 + phase * 7) % 8];
+      if (phase >= 8) {
+        x = 0x76543210abcdef01ULL * (lane + phase);
+        y = 0xfedcba9876543211ULL * (lane * 7 + phase);
+      }
+      memcpy(a + i, &x, bytes);
+      memcpy(b + i, &y, bytes);
+      for (unsigned j = 0; j < bytes; j++) mask[i + j] = phase < 2 ? phase : (lane + phase) % 3 != 0;
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      uint64_t x = 0, y = 0;
+      memcpy(&x, (first_b ? b : a) + i, bytes);
+      memcpy(&y, b + i, bytes);
+      uint64_t value = x;
+      if (!predicated || mask[i]) {
+        unsigned __int128 product;
+        if (signed_product) {
+          __int128 sx = x & sign ? (__int128)x - ((__int128)1 << bits) : x;
+          __int128 sy = y & sign ? (__int128)y - ((__int128)1 << bits) : y;
+          product = (unsigned __int128)(sx * sy);
+        } else {
+          product = (unsigned __int128)x * y;
+        }
+        value = product >> bits;
+      }
+      memcpy(scalar + i, &value, bytes);
+    }
+    native_instruction(a, b, mask, native);
+    translated(a, b, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u\n", name, vl, phase);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_mul_high_test.go b/arm64_raw_sve_mul_high_test.go
new file mode 100644
index 000000000..4b41b3055
--- /dev/null
+++ b/arm64_raw_sve_mul_high_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEMulHighAssembly(op string, size, dst, first, second, predicate int) string {
+	width := "bhsd"[size]
+	if predicate >= 0 {
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, z%d.%c", op, dst, width, predicate, dst, width, second, width)
+	}
+	return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c", op, dst, width, first, width, second, width)
+}
+
+func TestARM64RawSVEMultiplyHighCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, op := range []string{"smulh", "umulh"} {
+		for size := 0; size < 4; size++ {
+			for _, predicate := range []int{-1, 7} {
+				lines = append(lines, arm64RawSVEMulHighAssembly(op, size, 31, 30, 29, predicate))
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawmulhigh(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawmulhigh": {Name: "rawmulhigh", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawmulhigh.ll", "rawmulhigh.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEMultiplyHighOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, op := range []string{"smulh", "umulh"} {
+		for size := 0; size < 4; size++ {
+			for _, predicated := range []bool{false, true} {
+				limits := []int{32, 32, 32, 1}
+				if predicated {
+					limits[1], limits[3] = 1, 8
+				}
+				for field, limit := range limits {
+					for value := 0; value < limit; value++ {
+						fields := [4]int{31, 30, 29, 0}
+						fields[field] = value
+						dst, first, second, pred := fields[0], fields[1], fields[2], fields[3]
+						if predicated {
+							first = dst
+						} else {
+							pred = -1
+						}
+						lines = append(lines, arm64RawSVEMulHighAssembly(op, size, dst, first, second, pred))
+						reg := func(number int) Operand {
+							return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", number, "BHSD"[size]))}
+						}
+						args := []Operand{reg(second), reg(first)}
+						if predicated {
+							args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", pred))})
+						}
+						args = append(args, reg(dst))
+						wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(op)), Args: args})
+					}
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVEMultiplyHigh(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0, 0x04100000, 0x04206400, 0x04207000} {
+		if got, ok := decodeARM64RawSVEMultiplyHigh(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_multiply_accumulate_runtime_test.go b/arm64_raw_sve_multiply_accumulate_runtime_test.go
new file mode 100644
index 000000000..70bd55db5
--- /dev/null
+++ b/arm64_raw_sve_multiply_accumulate_runtime_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEMultiplyAccumulateRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"mla", "mls", "mad", "msb"} {
+		for size := 0; size < 4; size++ {
+			lanes := []int{-1}
+			if size > 0 && (op == "mla" || op == "mls") {
+				for lane := 0; lane < 16>>size; lane++ {
+					lanes = append(lanes, lane)
+				}
+			}
+			multiplier := 7
+			if size == 3 {
+				multiplier = 15
+			}
+			for _, lane := range lanes {
+				for _, destination := range []int{31, 30, multiplier} {
+					name := fmt.Sprintf("multiply_accumulate_%d", len(sigs))
+					native := []string{
+						"ptrue p0.b", "ld1b { z20.b }, p0/z, [x3]", "cmpne p7.b, p0/z, z20.b, #0",
+						"ld1b { z30.b }, p0/z, [x0]", fmt.Sprintf("ld1b { z%d.b }, p0/z, [x1]", multiplier),
+						fmt.Sprintf("ld1b { z%d.b }, p0/z, [x2]", destination),
+						arm64RawSVEMultiplyAccumulateAssembly(op, size, destination, 30, multiplier, 7, lane),
+						fmt.Sprintf("st1b { z%d.b }, p0, [x4]", destination),
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-40\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD c+16(FP),R2\nMOVD mask+24(FP),R3\nMOVD out+32(FP),R4\n", name)
+					for _, word := range assembleARM64LLVMWords(t, native, "+sve2") {
+						fmt.Fprintf(&source, "WORD $%#08x\n", word)
+					}
+					source.WriteString("RET\n")
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+						{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, const void *, void *);\n", name)
+					assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[c]]", "[x3]", "[%[mask]]", "[x4]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+					first, second, operator := "a", "b", "+"
+					if destination == 30 {
+						first = "c"
+					}
+					if destination == multiplier {
+						second = "c"
+					}
+					if op == "mls" {
+						operator = "-"
+					}
+					expression := "accumulator " + operator + " x * y"
+					if op == "mad" {
+						expression = "y + accumulator * x"
+					} else if op == "msb" {
+						expression = "y - accumulator * x"
+					}
+					fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], c[256], mask[256], got[256], native[256], scalar[256];
+      const unsigned element = %d;
+      const int lane = %d;
+      for (unsigned phase = 0; phase < 12; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase == 2 ? 0xff : i * 71 + phase * 83;
+          b[i] = phase == 2 ? 0xff : i * 17 + phase * 51;
+          c[i] = phase == 2 ? 0xff : i * 59 + phase * 29;
+          mask[i] = phase < 2 ? phase : (i / element + phase * 3) %% 7 != 0;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        for (unsigned i = 0; i < vl; i += element) {
+          uint64_t x = 0, y = 0, accumulator = 0;
+          unsigned multiplier_offset = lane < 0 ? i : (i & ~15u) + lane * element;
+          memcpy(&x, %s + i, element);
+          memcpy(&y, %s + multiplier_offset, element);
+          memcpy(&accumulator, c + i, element);
+          if (lane >= 0 || mask[i]) accumulator = %s;
+          memcpy(scalar + i, &accumulator, element);
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [c]"r"(c), [mask]"r"(mask), [out]"r"(native)
+          : "p0", "p7", "z7", "z15", "z20", "z30", "z31", "memory");
+        %s(a, b, c, mask, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, 1<<size, lane, first, second, expression, assembly, name, name, len(sigs))
+				}
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_multiply_accumulate", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_multiply_accumulate_test.go b/arm64_raw_sve_multiply_accumulate_test.go
new file mode 100644
index 000000000..21dbad599
--- /dev/null
+++ b/arm64_raw_sve_multiply_accumulate_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEMultiplyAccumulateAssembly(op string, size, destination, first, second, predicate, lane int) string {
+	width := "bhsd"[size]
+	if lane >= 0 {
+		return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c[%d]", op, destination, width, first, width, second, width, lane)
+	}
+	return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, z%d.%c", op, destination, width, predicate, first, width, second, width)
+}
+
+func TestARM64RawSVEMultiplyAccumulateCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, op := range []string{"mla", "mls", "mad", "msb"} {
+		for size := 0; size < 4; size++ {
+			lines = append(lines, arm64RawSVEMultiplyAccumulateAssembly(op, size, 31, 30, 29, 7, -1))
+			if size == 0 || op == "mad" || op == "msb" {
+				continue
+			}
+			for lane := 0; lane < 16>>size; lane++ {
+				second := 7
+				if size == 3 {
+					second = 15
+				}
+				lines = append(lines, arm64RawSVEMultiplyAccumulateAssembly(op, size, 31, 30, second, 0, lane))
+			}
+		}
+	}
+	source.WriteString("TEXT rawmultiplyaccumulate(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawmultiplyaccumulate": {Name: "rawmultiplyaccumulate", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawmultiplyaccumulate.ll", "rawmultiplyaccumulate.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEMultiplyAccumulateOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, op := range []string{"mla", "mls", "mad", "msb"} {
+		for size := 0; size < 4; size++ {
+			for _, indexed := range []bool{false, true} {
+				if indexed && (size == 0 || op == "mad" || op == "msb") {
+					continue
+				}
+				limits := []int{32, 32, 32, 8, 1}
+				if indexed {
+					limits[2], limits[3], limits[4] = 8, 1, 16>>size
+					if size == 3 {
+						limits[2] = 16
+					}
+				}
+				for field, limit := range limits {
+					for value := 0; value < limit; value++ {
+						fields := [5]int{31, 31, limits[2] - 1, limits[3] - 1, limits[4] - 1}
+						fields[field] = value
+						dst, first, second, pred, lane := fields[0], fields[1], fields[2], fields[3], fields[4]
+						index := ""
+						if indexed {
+							index = fmt.Sprintf("[%d]", lane)
+						} else {
+							lane = -1
+						}
+						lines = append(lines, arm64RawSVEMultiplyAccumulateAssembly(op, size, dst, first, second, pred, lane))
+						width := "BHSD"[size]
+						args := []Operand{
+							{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c%s", second, width, index))},
+							{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", first, width))},
+						}
+						if !indexed {
+							args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.M", pred))})
+						}
+						args = append(args, Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", dst, width))})
+						wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(op)), Args: args})
+					}
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		if !arm64RawPoolSVEPreservesNZCV(word) {
+			t.Fatalf("%s: multiply-accumulate unexpectedly clobbers NZCV", lines[i])
+		}
+		if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 || !arm64RawPoolSVEIgnoresAddress(word, 9) {
+			t.Fatalf("%s: vector-only operation has unknown or address-dependent GP effects", lines[i])
+		}
+		got, ok := decodeARM64RawSVEMultiplyAccumulate(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0, 0x04008000, 0x04204000, 0x44200400, 0x44a01000, 0x44c00800} {
+		if got, ok := decodeARM64RawSVEMultiplyAccumulate(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_predicate_count_test.go b/arm64_raw_sve_predicate_count_test.go
new file mode 100644
index 000000000..f0c58cd0d
--- /dev/null
+++ b/arm64_raw_sve_predicate_count_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVEPredicateCountNativeForms() []string {
+	var lines []string
+	for _, width := range []string{"b", "h", "s", "d"} {
+		lines = append(lines, fmt.Sprintf("cntp x0, p15, p14.%s", width), fmt.Sprintf("cntp xzr, p0, p1.%s", width))
+		for _, multiplier := range []int{2, 4} {
+			lines = append(lines, fmt.Sprintf("cntp x30, pn0.%s, vlx%d", width, multiplier),
+				fmt.Sprintf("cntp xzr, pn15.%s, vlx%d", width, multiplier))
+		}
+	}
+	return lines
+}
+
+func TestARM64RawSVEPredicateCountCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	// Some complete forms write X30. Preserve the real source continuation;
+	// the instruction-format fixture must not synthesize a return after losing it.
+	source.WriteString("TEXT rawcntp(SB),$0-0\nMOVD R30,R25\n")
+	for _, word := range assembleARM64LLVMWords(t, arm64RawSVEPredicateCountNativeForms(), "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("MOVD R25,R30\nRET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawcntp": {Name: "rawcntp", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawcntp.ll", "rawcntp.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEPredicateCountOperandFields(t *testing.T) {
+	lines := arm64RawSVEPredicateCountNativeForms()
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		got, ok := decodeARM64RawSVEPredicateCount(word)
+		if !ok {
+			t.Fatalf("%s: rejected %#08x", lines[i], word)
+		}
+		fields := strings.Fields(strings.ReplaceAll(strings.ToUpper(lines[i]), ",", ""))
+		destination := "R" + strings.TrimPrefix(fields[1], "X")
+		if fields[1] == "XZR" {
+			destination = "ZR"
+		}
+		if got.Op != "PCNTP" || got.Args[2].Reg != Reg(destination) {
+			t.Errorf("%s: wrong destination: %+v", lines[i], got)
+		}
+		if strings.HasPrefix(fields[2], "PN") {
+			if got.Args[0].Kind != OpIdent || got.Args[0].Ident != fields[3] || got.Args[1].Reg != Reg(fields[2]) {
+				t.Errorf("%s: wrong counter form: %+v", lines[i], got)
+			}
+		} else if got.Args[0].Reg != Reg(fields[3]) || got.Args[1].Reg != Reg(fields[2]) {
+			t.Errorf("%s: wrong predicate form: %+v", lines[i], got)
+		}
+	}
+	for _, word := range []uint32{0x25208a00, 0x2520c000, 0x25207810} {
+		if got, ok := decodeARM64RawSVEPredicateCount(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_predicate_memory_runtime_test.go b/arm64_raw_sve_predicate_memory_runtime_test.go
new file mode 100644
index 000000000..76046b1db
--- /dev/null
+++ b/arm64_raw_sve_predicate_memory_runtime_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEPredicateMemoryRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for i, offset := range []int{-256, -1, 0, 1, 255} {
+		name := fmt.Sprintf("predicate_memory_%d", i)
+		native := []string{
+			fmt.Sprintf("ldr p15, [x0, #%d, mul vl]", offset),
+			fmt.Sprintf("str p15, [x1, #%d, mul vl]", offset),
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVD src+0(FP),R0\nMOVD dst+8(FP),R1\n", name)
+		for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}}}
+		fmt.Fprintf(&declarations, "extern void %s(const void *, void *);\n", name)
+		assembly := strings.NewReplacer("[x0,", "[%[src],", "[x1,", "[%[dst],").Replace(strings.Join(native, "\\n\\t"))
+		fmt.Fprintf(&checks, `    {
+      unsigned char source[16448], got[16448], want[16448], oracle[16448];
+      for (unsigned phase = 0; phase < 4; phase++) {
+        for (unsigned i = 0; i < sizeof(source); i++) source[i] = (i * 17 + phase * 83) & 255;
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        memset(oracle, 0x5a, sizeof(oracle));
+        unsigned position = 8192 + (%d) * (int)(vl / 8);
+        memcpy(oracle + position, source + position, vl / 8);
+        __asm__ volatile("%s" :: [src]"r"(source + 8192), [dst]"r"(want + 8192) : "p15", "memory");
+        %s(source + 8192, got + 8192);
+        if (memcmp(got, want, sizeof(got)) != 0 || memcmp(got, oracle, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, offset, assembly, name, name, i+1)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_predicate_memory", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_predicate_memory_test.go b/arm64_raw_sve_predicate_memory_test.go
new file mode 100644
index 000000000..941b05d86
--- /dev/null
+++ b/arm64_raw_sve_predicate_memory_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEPredicateMemoryCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, op := range []string{"ldr", "str"} {
+		for _, offset := range []int{-256, -1, 0, 1, 255} {
+			for _, base := range []string{"x0", "sp"} {
+				lines = append(lines, fmt.Sprintf("%s p15, [%s, #%d, mul vl]", op, base, offset))
+			}
+		}
+	}
+	source.WriteString("TEXT rawpredmem(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawpredmem": {Name: "rawpredmem", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawpredmem.ll", "rawpredmem.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEPredicateMemoryOperandFields(t *testing.T) {
+	var lines []string
+	var wants []arm64RawSVELoadStore
+	for _, load := range []bool{false, true} {
+		op := "str"
+		if load {
+			op = "ldr"
+		}
+		for field, limit := range []int{512, 32, 16} {
+			for value := 0; value < limit; value++ {
+				fields := [3]int{-256, 31, 15}
+				fields[field] = value
+				if field == 0 {
+					fields[0] -= 256
+				}
+				base := fmt.Sprintf("x%d", fields[1])
+				if fields[1] == 31 {
+					base = "sp"
+				}
+				lines = append(lines, fmt.Sprintf("%s p%d, [%s, #%d, mul vl]", op, fields[2], base, fields[0]))
+				wants = append(wants, arm64RawSVELoadStore{load: load, predicate: true,
+					immediate: fields[0], base: fields[1], vector: fields[2]})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		if got, ok := decodeARM64RawSVELoadStore(word); !ok || got != wants[i] {
+			t.Errorf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x85800010, 0xe5800010, 0x85802000, 0xe5400000} {
+		if got, ok := decodeARM64RawSVELoadStore(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_predicate_permute_runtime_test.go b/arm64_raw_sve_predicate_permute_runtime_test.go
new file mode 100644
index 000000000..edbbe6379
--- /dev/null
+++ b/arm64_raw_sve_predicate_permute_runtime_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEPredicatePermuteRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	// Observe every predicate bit, including inactive bits between wide elements.
+	// Both source aliases are tested against the native instructions.
+	for _, destination := range []int{15, 14, 13} {
+		for _, form := range arm64RawPredicatePermuteForms(destination, 14, 13) {
+			name := fmt.Sprintf("predicate_permute_%d", len(sigs))
+			native := []string{
+				"ptrue p0.b",
+				"ld1b { z0.b }, p0/z, [x0]",
+				"ld1b { z1.b }, p0/z, [x1]",
+				"cmpeq p14.b, p0/z, z0.b, #0",
+				"cmpeq p13.b, p0/z, z1.b, #0",
+				form.assembly,
+				"mov z0.b, #-1",
+				"mov z1.b, #0",
+				fmt.Sprintf("sel z0.b, p%d, z0.b, z1.b", destination),
+				"st1b { z0.b }, p0, [x2]",
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+			for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+			assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+			fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], got[256], want[256];
+      for (unsigned pattern = 0; pattern < 12; pattern++) {
+        for (unsigned i = 0; i < vl; i++) {
+          a[i] = pattern < 4 ? pattern & 1 : ((i * 17 + pattern) %% 7) < 3;
+          b[i] = pattern < 4 ? pattern >> 1 : ((i * 11 + pattern) %% 9) < 5;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [out]"r"(want)
+          : "p0", "p13", "p14", "p15", "z0", "z1", "memory");
+        %s(a, b, got);
+        if (memcmp(got, want, sizeof(got)) != 0) {
+          fprintf(stderr, "%s: vl=%%u pattern=%%u\n", vl, pattern);
+          return %d;
+        }
+      }
+    }
+`, assembly, name, form.assembly, len(sigs))
+		}
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_predicate_permute", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_predicate_permute_test.go b/arm64_raw_sve_predicate_permute_test.go
new file mode 100644
index 000000000..9178dd14d
--- /dev/null
+++ b/arm64_raw_sve_predicate_permute_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawPredicatePermuteForm struct {
+	assembly string
+	op       Op
+	args     []Reg
+}
+
+func arm64RawPredicatePermuteForms(destination, first, second int) []arm64RawPredicatePermuteForm {
+	var forms []arm64RawPredicatePermuteForm
+	for _, width := range []string{"b", "h", "s", "d"} {
+		pd := fmt.Sprintf("p%d.%s", destination, width)
+		pn := fmt.Sprintf("p%d.%s", first, width)
+		pm := fmt.Sprintf("p%d.%s", second, width)
+		forms = append(forms, arm64RawPredicatePermuteForm{
+			"rev " + pd + ", " + pn, "PREV", []Reg{Reg(strings.ToUpper(pn)), Reg(strings.ToUpper(pd))},
+		})
+		for _, op := range []string{"trn1", "trn2", "uzp1", "uzp2", "zip1", "zip2"} {
+			forms = append(forms, arm64RawPredicatePermuteForm{
+				op + " " + pd + ", " + pn + ", " + pm, Op("P" + strings.ToUpper(op)),
+				[]Reg{Reg(strings.ToUpper(pm)), Reg(strings.ToUpper(pn)), Reg(strings.ToUpper(pd))},
+			})
+		}
+	}
+	for _, op := range []string{"punpkhi", "punpklo"} {
+		forms = append(forms, arm64RawPredicatePermuteForm{
+			fmt.Sprintf("%s p%d.h, p%d.b", op, destination, first), Op("P" + strings.ToUpper(op)),
+			[]Reg{Reg(fmt.Sprintf("P%d.B", first)), Reg(fmt.Sprintf("P%d.H", destination))},
+		})
+	}
+	return forms
+}
+
+func TestARM64RawSVEPredicatePermuteCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, form := range arm64RawPredicatePermuteForms(15, 14, 13) {
+		lines = append(lines, form.assembly)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawpermute(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawpermute": {Name: "rawpermute", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawpermute.ll", "rawpermute.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEPredicatePermuteOperandFields(t *testing.T) {
+	var forms []arm64RawPredicatePermuteForm
+	var lines []string
+	for field := 0; field < 3; field++ {
+		for register := 0; register < 16; register++ {
+			registers := [3]int{15, 14, 13}
+			registers[field] = register
+			forms = append(forms, arm64RawPredicatePermuteForms(registers[0], registers[1], registers[2])...)
+		}
+	}
+	for _, form := range forms {
+		lines = append(lines, form.assembly)
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		want := forms[i]
+		got, ok := decodeARM64RawSVEPredicatePermute(word)
+		if !ok || got.Op != want.op || len(got.Args) != len(want.args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v", want.assembly, word, got, ok)
+		}
+		for j, register := range want.args {
+			if got.Args[j].Reg != register {
+				t.Errorf("%s: operand %d = %s, want %s", want.assembly, j, got.Args[j].Reg, register)
+			}
+		}
+	}
+	for _, word := range []uint32{0x05304010, 0x05304200, 0x05704000, 0x05344010, 0x05205c00, 0x05204010, 0x05204200} {
+		if got, ok := decodeARM64RawSVEPredicatePermute(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_saturating_add_sub_runtime_test.go b/arm64_raw_sve_saturating_add_sub_runtime_test.go
new file mode 100644
index 000000000..8ed1dd517
--- /dev/null
+++ b/arm64_raw_sve_saturating_add_sub_runtime_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVESaturatingAddSubRuntime(t *testing.T, llc string) {
+	type runtimeCase struct {
+		form        arm64SVESaturatingAddSubCase
+		destination int
+		native      []string
+		named       bool
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for _, form := range arm64SVESaturatingAddSubCases() {
+		for _, destination := range []int{31, 30, 29} {
+			native := []string{
+				"ptrue p0.b", "ld1b { z30.b }, p0/z, [x0]", "ld1b { z31.b }, p0/z, [x0]",
+				"ld1b { z29.b }, p0/z, [x1]", "ld1b { z28.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z28.b, #0",
+				form.assembly(destination, 30, 29, 7),
+				fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+			}
+			cases = append(cases, runtimeCase{form: form, destination: destination, native: native})
+			allNative = append(allNative, native...)
+			if form.mode == arm64SVEAddImmediate && strings.HasPrefix(form.op, "s") && uint64(form.immediate) >= uint64(1)<<((8<<form.size)-1) {
+				cases = append(cases, runtimeCase{form: form, destination: destination, native: native, named: true})
+				allNative = append(allNative, native...)
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, allNative, "+sve2")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVESaturatingAddSubRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("saturating_%s_%d", test.form.op, len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for index, word := range words[:len(test.native)] {
+			if test.named && index == 6 {
+				register := fmt.Sprintf("Z%d.%c", test.destination, "BHSD"[test.form.size])
+				fmt.Fprintf(&source, "Z%s $%d, %s, %s\n", strings.ToUpper(test.form.op), test.form.immediate, register, register)
+				continue
+			}
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *a, const void *b, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(out)
+    : "p0", "p7", "z28", "z29", "z30", "z31", "memory");
+}
+`, name, assembly)
+		signed, subtract, reverse, predicated, firstB := 0, 0, 0, 0, 0
+		if strings.HasPrefix(test.form.op, "s") {
+			signed = 1
+		}
+		if strings.Contains(test.form.op, "sub") {
+			subtract = 1
+		}
+		if strings.HasSuffix(test.form.op, "r") {
+			reverse = 1
+		}
+		if test.form.mode == arm64SVEAddPredicated {
+			predicated = 1
+		}
+		if test.form.mode != arm64SVEAddUnpredicated && test.destination == 29 {
+			firstB = 1
+		}
+		immediate := -1
+		if test.form.mode == arm64SVEAddImmediate {
+			immediate = test.form.immediate
+		}
+		fmt.Fprintf(&checks, "  if (check_saturating(vl, %d, %d, %d, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			8<<test.form.size, signed, subtract, reverse, predicated, firstB, immediate, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_saturating", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVESaturatingAddSubRuntimeReference = `
+typedef void (*saturating_fn)(const void *, const void *, const void *, void *);
+__attribute__((noinline, noclone))
+static int check_saturating(unsigned vl, unsigned bits, int signed_value, int subtract, int reverse,
+    int predicated, int first_b, int immediate, saturating_fn translated,
+    saturating_fn native_instruction, const char *name) {
+  unsigned char a[256], b[256], mask[256], got[256], native[256], scalar[256];
+  unsigned bytes = bits / 8;
+  uint64_t sign = UINT64_C(1) << (bits - 1), maximum = UINT64_MAX >> (64 - bits);
+  uint64_t values[] = {0, 1, maximum, sign, sign - 1, sign + 1, 2, 3};
+  for (unsigned phase = 0; phase < 16; phase++) {
+    for (unsigned i = 0; i < sizeof(a); i += bytes) {
+      unsigned lane = i / bytes;
+      uint64_t x = values[(lane + phase) % 8], y = values[(lane * 3 + phase * 7) % 8];
+      if (phase >= 8) {
+        x = 0x76543210abcdef01ULL * (lane + phase);
+        y = 0xfedcba9876543211ULL * (lane * 7 + phase);
+      }
+      memcpy(a + i, &x, bytes);
+      memcpy(b + i, &y, bytes);
+      for (unsigned j = 0; j < bytes; j++) mask[i + j] = phase < 2 ? phase : (lane + phase) % 3 != 0;
+    }
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    for (unsigned i = 0; i < vl; i += bytes) {
+      uint64_t x = 0, y = 0;
+      memcpy(&x, (first_b ? b : a) + i, bytes);
+      memcpy(&y, b + i, bytes);
+      uint64_t value = x;
+      if (!predicated || mask[i]) {
+        __int128 sx = x, sy = y;
+        __int128 minimum = 0, limit = maximum;
+        if (signed_value) {
+          if (x & sign) sx -= (__int128)1 << bits;
+          if (y & sign) sy -= (__int128)1 << bits;
+          minimum = -(__int128)sign;
+          limit = sign - 1;
+        }
+        // Saturating immediates are unsigned, even for signed operations.
+        if (immediate >= 0) sy = immediate;
+        __int128 result = subtract ? (reverse ? sy - sx : sx - sy) : sx + sy;
+        if (result < minimum) result = minimum;
+        if (result > limit) result = limit;
+        value = (uint64_t)result;
+      }
+      memcpy(scalar + i, &value, bytes);
+    }
+    native_instruction(a, b, mask, native);
+    translated(a, b, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: bits=%u vl=%u phase=%u imm=%d translated/native=%d native/scalar=%d\n",
+          name, bits, vl, phase, immediate, memcmp(got, native, sizeof(got)), memcmp(native, scalar, sizeof(got)));
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/arm64_raw_sve_saturating_add_sub_test.go b/arm64_raw_sve_saturating_add_sub_test.go
new file mode 100644
index 000000000..72ac960ec
--- /dev/null
+++ b/arm64_raw_sve_saturating_add_sub_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64SVESaturatingAddSubCase struct {
+	op        string
+	size      int
+	mode      arm64SVEAddMode
+	immediate int
+}
+
+func arm64SVESaturatingAddSubCases() []arm64SVESaturatingAddSubCase {
+	var cases []arm64SVESaturatingAddSubCase
+	for _, op := range []string{"sqadd", "sqsub", "sqsubr", "uqadd", "uqsub", "uqsubr"} {
+		for size := 0; size < 4; size++ {
+			cases = append(cases, arm64SVESaturatingAddSubCase{op: op, size: size, mode: arm64SVEAddPredicated})
+			if strings.HasSuffix(op, "r") {
+				continue
+			}
+			cases = append(cases, arm64SVESaturatingAddSubCase{op: op, size: size, mode: arm64SVEAddUnpredicated})
+			for _, immediate := range []int{0, 1, 127, 128, 255, 256, 32768, 65280} {
+				if size == 0 && immediate > 255 {
+					continue
+				}
+				cases = append(cases, arm64SVESaturatingAddSubCase{op, size, arm64SVEAddImmediate, immediate})
+			}
+		}
+	}
+	return cases
+}
+
+func (form arm64SVESaturatingAddSubCase) assembly(dst, first, second, predicate int) string {
+	width := "bhsd"[form.size]
+	switch form.mode {
+	case arm64SVEAddUnpredicated:
+		return fmt.Sprintf("%s z%d.%c, z%d.%c, z%d.%c", form.op, dst, width, first, width, second, width)
+	case arm64SVEAddPredicated:
+		return fmt.Sprintf("%s z%d.%c, p%d/m, z%d.%c, z%d.%c", form.op, dst, width, predicate, dst, width, second, width)
+	default:
+		return fmt.Sprintf("%s z%d.%c, z%d.%c, #%d", form.op, dst, width, dst, width, form.immediate)
+	}
+}
+
+func TestARM64RawSVESaturatingAddSubCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, form := range arm64SVESaturatingAddSubCases() {
+		lines = append(lines, form.assembly(31, 30, 29, 7))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawsaturating(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawsaturating": {Name: "rawsaturating", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawsaturating.ll", "rawsaturating.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVESaturatingAddSubOperandFields(t *testing.T) {
+	var lines []string
+	var wants []arm64RawSVEAdd
+	var ops []Op
+	appendCase := func(form arm64SVESaturatingAddSubCase, dst, first, second, pred int) {
+		lines = append(lines, form.assembly(dst, first, second, pred))
+		want := arm64RawSVEAdd{mode: form.mode, elementBits: 8 << form.size, destination: dst, first: first}
+		switch form.mode {
+		case arm64SVEAddUnpredicated:
+			want.second = second
+		case arm64SVEAddPredicated:
+			want.first, want.second, want.predicate = dst, second, pred
+		case arm64SVEAddImmediate:
+			want.first, want.immediate = dst, form.immediate
+		}
+		wants = append(wants, want)
+		ops = append(ops, Op("Z"+strings.ToUpper(form.op)))
+	}
+	for _, form := range arm64SVESaturatingAddSubCases() {
+		if form.mode == arm64SVEAddImmediate && form.immediate != 0 {
+			continue
+		}
+		limits := [4]int{32, 32, 32, 1}
+		if form.mode == arm64SVEAddPredicated {
+			limits[1], limits[3] = 1, 8
+		} else if form.mode == arm64SVEAddImmediate {
+			limits[1], limits[2] = 1, 1
+		}
+		for field, limit := range limits {
+			for value := 0; value < limit; value++ {
+				fields := [4]int{31, 30, 29, 7}
+				fields[field] = value
+				appendCase(form, fields[0], fields[1], fields[2], fields[3])
+			}
+		}
+		if form.mode == arm64SVEAddImmediate {
+			for _, shift := range []int{0, 8} {
+				if form.size == 0 && shift != 0 {
+					continue
+				}
+				for imm := 0; imm < 256; imm++ {
+					form.immediate = imm << shift
+					appendCase(form, 31, 31, 0, 0)
+					// Preserve shifted zero as a distinct physical encoding.
+					lines[len(lines)-1] = fmt.Sprintf("%s z31.%c, z31.%c, #%d, lsl #%d",
+						form.op, "bhsd"[form.size], "bhsd"[form.size], imm, shift)
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		op, got, ok := decodeARM64RawSVEAddSub(word)
+		if !ok || op != ops[i] || got != wants[i] {
+			t.Fatalf("%s: %#08x = %s %+v, %v; want %s %+v", lines[i], word, op, got, ok, ops[i], wants[i])
+		}
+	}
+	for _, word := range []uint32{
+		0x2524e000, 0x2525e000, 0x2526e000, 0x2527e000, // Reserved shifted byte immediates.
+		0x441c8000, 0x441d8000, 0x04200c00, 0x2528c000, // Adjacent operations, not this family.
+	} {
+		if op, form, ok := decodeARM64RawSVEAddSub(word); ok {
+			t.Errorf("reserved/neighboring word %#08x decoded as %s %+v", word, op, form)
+		}
+	}
+}
diff --git a/arm64_raw_sve_signed_load_runtime_test.go b/arm64_raw_sve_signed_load_runtime_test.go
new file mode 100644
index 000000000..af1d5a8c8
--- /dev/null
+++ b/arm64_raw_sve_signed_load_runtime_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVESignedLoadRuntime(t *testing.T, llc string) {
+	testARM64RawSVELoadRuntime(t, llc, arm64RawSVESignedLoadCases(), true)
+}
+
+func testARM64RawSVEUnsignedLoadRuntime(t *testing.T, llc string) {
+	testARM64RawSVELoadRuntime(t, llc, arm64RawSVEUnsignedLoadCases(), false)
+}
+
+func testARM64RawSVELoadRuntime(t *testing.T, llc string, forms []arm64RawSVELoadCase, signed bool) {
+	type runtimeCase struct {
+		form                arm64RawSVELoadCase
+		destination, offset int
+		native              []string
+	}
+	var cases []runtimeCase
+	var allNative []string
+	for _, form := range forms {
+		offsets := []int{0}
+		if form.kind == "immediate" {
+			offsets = []int{-8, 0, 7}
+		} else if form.kind == "base" {
+			offsets = []int{0, 31}
+		}
+		for _, offset := range offsets {
+			for _, destination := range []int{30, 31} {
+				base, index := 0, 30
+				if form.kind == "base" {
+					base = 30
+				} else if form.kind == "register" {
+					index = 4
+				}
+				native := []string{
+					"ptrue p0.b", "ld1b { z30.b }, p0/z, [x1]", "ld1b { z31.b }, p0/z, [x1]",
+					"ld1b { z29.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z29.b, #0", "ldr x4, [x1]",
+					form.loadAssembly(signed, destination, 7, base, index, offset),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x3]", destination),
+				}
+				cases = append(cases, runtimeCase{form, destination, offset, native})
+				allNative = append(allNative, native...)
+			}
+		}
+	}
+	// One assembler invocation covers all cases; do not spawn a compiler for
+	// every operand combination. C data/oracle loops are shared below as well.
+	words := assembleARM64LLVMWords(t, allNative, "+sve")
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(arm64SVELoadRuntimeReference)
+	sigs := make(map[string]FuncSig)
+	for _, test := range cases {
+		name := fmt.Sprintf("ordinary_load_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD base+0(FP),R0\nMOVD indices+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+		for _, word := range words[:len(test.native)] {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		words = words[len(test.native):]
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+		}}}
+		assembly := "mov x0, %[base]\\n\\t" + strings.NewReplacer("[x1]", "[%[indices]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(test.native, "\\n\\t"))
+		fmt.Fprintf(&declarations, `extern void %[1]s(const void *, const void *, const void *, void *);
+static void %[1]s_native(const void *base, const void *indices, const void *mask, void *out) {
+  __asm__ volatile("%[2]s" :: [base]"r"(base), [indices]"r"(indices), [mask]"r"(mask), [out]"r"(out)
+    : "x0", "x4", "p0", "p7", "z29", "z30", "z31", "memory");
+}
+`, name, assembly)
+		kind := map[string]int{"immediate": 0, "register": 1, "offset": 2, "base": 3}[test.form.kind]
+		extension := map[string]int{"": 0, "uxtw": 1, "sxtw": 2}[test.form.extension]
+		scale := 1
+		if test.form.scaled {
+			scale <<= test.form.memorySize
+		}
+		signedInput := 0
+		if signed {
+			signedInput = 1
+		}
+		fmt.Fprintf(&checks, "  if (check_ordinary_load(vl, %d, %d, %d, %d, %d, %d, %d, %s, %s_native, %q)) return 1;\n",
+			1<<test.form.memorySize, 1<<test.form.elementSize, kind, extension, scale, test.offset, signedInput, name, name, name)
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_ordinary_load", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SVELoadRuntimeReference = `
+#include <sys/mman.h>
+typedef void (*ordinary_load_fn)(const void *, const void *, const void *, void *);
+
+__attribute__((noinline, noclone))
+static int check_ordinary_load(unsigned vl, unsigned access, unsigned element, unsigned kind,
+    unsigned extension, unsigned scale, int offset, int signed_input, ordinary_load_fn translated,
+    ordinary_load_fn native_instruction, const char *name) {
+  const size_t allocation = 32768;
+  unsigned char *memory = mmap((void *)0x20000000, allocation, PROT_NONE,
+    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (memory == MAP_FAILED) { perror("mmap"); return 1; }
+  if ((uintptr_t)memory + allocation > UINT32_MAX ||
+      mprotect(memory + 8192, 16384, PROT_READ | PROT_WRITE)) {
+    fprintf(stderr, "cannot create guarded 32-bit-addressable SVE fixture\n");
+    munmap(memory, allocation);
+    return 1;
+  }
+  for (unsigned i = 8192; i < 24576; i++) memory[i] = i * 71 + (i >> 8);
+  for (unsigned phase = 0; phase < 12; phase++) {
+    unsigned char indices[256] = {0}, mask[256], got[256], native[256], scalar[256];
+    unsigned char *base = phase ? memory + 16384 + phase % 4 : 0;
+    int64_t scalar_index = (int64_t)(phase % 3) * 11 - 7;
+    memset(got, 0x5a, sizeof(got));
+    memset(native, 0x5a, sizeof(native));
+    memset(scalar, 0x5a, sizeof(scalar));
+    memset(scalar, 0, vl);
+    for (unsigned i = 0; i < sizeof(indices); i += element) {
+      unsigned lane = i / element;
+      int active = phase < 2 ? phase : (lane + phase) % 3 != 0;
+      for (unsigned j = 0; j < element; j++) mask[i + j] = active;
+      int64_t index = (int64_t)((lane * 17 + phase * 23) % 251) - 125;
+      if (extension == 1) index += 125;
+      uint64_t encoded = index;
+      uintptr_t address = 0;
+      if (kind == 0) {
+        address = (uintptr_t)base + offset * (int)(vl / element * access) + lane * access;
+      } else if (kind == 1) {
+        address = (uintptr_t)base + scalar_index * access + lane * access;
+      } else if (kind == 2) {
+        address = (uintptr_t)base + index * scale;
+        if (extension) encoded = 0x9876543200000000ULL | (uint32_t)index;
+        if (!active) encoded = phase ? (uintptr_t)(memory + 28672 - base) / scale : 0;
+      } else {
+        encoded = (uintptr_t)(memory + 16384) + index * access + phase % 4;
+        address = encoded + offset * access;
+        if (!active) encoded = phase ? (uintptr_t)(memory + 28672) : 0;
+      }
+      memcpy(indices + i, &encoded, element);
+      if (i < vl && active) {
+        uint64_t value = 0;
+        memcpy(&value, (void *)address, access);
+        if (signed_input && (value >> (access * 8 - 1))) value |= ~(UINT64_MAX >> (64 - access * 8));
+        memcpy(scalar + i, &value, element);
+      }
+    }
+    if (kind == 1) memcpy(indices, &scalar_index, sizeof(scalar_index));
+    native_instruction(base, indices, mask, native);
+    translated(base, indices, mask, got);
+    if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+      fprintf(stderr, "%s: vl=%u phase=%u native=%d scalar=%d\n", name, vl, phase,
+        memcmp(got, native, sizeof(got)), memcmp(got, scalar, sizeof(got)));
+      munmap(memory, allocation);
+      return 1;
+    }
+  }
+  return munmap(memory, allocation) != 0;
+}
+`
diff --git a/arm64_raw_sve_signed_load_test.go b/arm64_raw_sve_signed_load_test.go
new file mode 100644
index 000000000..7e56847c5
--- /dev/null
+++ b/arm64_raw_sve_signed_load_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVELoadCase struct {
+	memorySize  int
+	elementSize int
+	kind        string
+	extension   string
+	scaled      bool
+}
+
+func arm64RawSVESignedLoadCases() []arm64RawSVELoadCase {
+	var forms []arm64RawSVELoadCase
+	for memory := 0; memory < 3; memory++ {
+		for element := memory + 1; element < 4; element++ {
+			for _, kind := range []string{"immediate", "register", "offset", "base"} {
+				if element < 2 && (kind == "offset" || kind == "base") {
+					continue
+				}
+				form := arm64RawSVELoadCase{memorySize: memory, elementSize: element, kind: kind}
+				if kind != "offset" {
+					forms = append(forms, form)
+					continue
+				}
+				for _, extension := range []string{"", "uxtw", "sxtw"} {
+					if element == 2 && extension == "" {
+						continue
+					}
+					form.extension = extension
+					for _, scaled := range []bool{false, true} {
+						if memory == 0 && scaled {
+							continue
+						}
+						form.scaled = scaled
+						forms = append(forms, form)
+					}
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func (form arm64RawSVELoadCase) assembly(dst, pred, base, index, offset int) string {
+	return form.loadAssembly(true, dst, pred, base, index, offset)
+}
+
+func (form arm64RawSVELoadCase) loadAssembly(signed bool, dst, pred, base, index, offset int) string {
+	baseName := fmt.Sprintf("x%d", base)
+	if base == 31 {
+		baseName = "sp"
+	}
+	width := "bhsd"[form.elementSize]
+	address := ""
+	switch form.kind {
+	case "immediate":
+		address = fmt.Sprintf("[%s, #%d, mul vl]", baseName, offset)
+	case "register":
+		shift := ""
+		if form.memorySize > 0 {
+			shift = fmt.Sprintf(", lsl #%d", form.memorySize)
+		}
+		address = fmt.Sprintf("[%s, x%d%s]", baseName, index, shift)
+	case "offset":
+		extension := form.extension
+		if form.scaled {
+			if extension == "" {
+				extension = "lsl"
+			}
+			extension += fmt.Sprintf(" #%d", form.memorySize)
+		}
+		if extension != "" {
+			extension = ", " + extension
+		}
+		address = fmt.Sprintf("[%s, z%d.%c%s]", baseName, index, width, extension)
+	case "base":
+		address = fmt.Sprintf("[z%d.%c, #%d]", base, width, offset<<form.memorySize)
+	}
+	op := "ld1"
+	if signed {
+		op += "s"
+	}
+	return fmt.Sprintf("%s%c { z%d.%c }, p%d/z, %s", op, "bhwd"[form.memorySize], dst, width, pred, address)
+}
+
+func TestARM64RawSVESignedLoadCompleteFormats(t *testing.T) {
+	forms := arm64RawSVESignedLoadCases()
+	if len(forms) != 38 {
+		t.Fatalf("signed-load grammar has %d forms, want 38", len(forms))
+	}
+	var lines []string
+	for _, form := range forms {
+		offset := 7
+		if form.kind == "base" {
+			offset = 31
+		}
+		lines = append(lines, form.assembly(31, 7, 31, 30, offset))
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawsignedload(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawsignedload": {Name: "rawsignedload", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawsignedload.ll", "rawsignedload.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVESignedLoadOperandFields(t *testing.T) {
+	testARM64RawSVELoadOperandFields(t, arm64RawSVESignedLoadCases(), true, decodeARM64RawSVESignedLoad)
+	for _, word := range []uint32{0xa4a0a000, 0xc4a0c000, 0xc440a000, 0x8420a000, 0x84a02000} {
+		if got, ok := decodeARM64RawSVESignedLoad(word); ok {
+			t.Errorf("unsigned/first-fault/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
+
+func testARM64RawSVELoadOperandFields(t *testing.T, forms []arm64RawSVELoadCase, signed bool, decode func(uint32) (Instr, bool)) {
+	t.Helper()
+	var lines []string
+	var wants []Instr
+	var reserved []int
+	for _, form := range forms {
+		limits := []int{32, 8, 32, 32, 1}
+		if form.kind == "register" {
+			limits[3] = 31
+		} else if form.kind == "immediate" {
+			limits[3], limits[4] = 1, 16
+		} else if form.kind == "base" {
+			limits[3], limits[4] = 1, 32
+		}
+		for field, limit := range limits {
+			for value := 0; value < limit; value++ {
+				fields := [5]int{31, 7, 31, limits[3] - 1, limits[4] - 1}
+				fields[field] = value
+				dst, pred, base, index, offset := fields[0], fields[1], fields[2], fields[3], fields[4]
+				if form.kind == "immediate" {
+					offset -= 8
+				}
+				lines = append(lines, form.loadAssembly(signed, dst, pred, base, index, offset))
+				memory := MemRef{Base: Reg(fmt.Sprintf("R%d", base))}
+				if base == 31 {
+					memory.Base = "RSP"
+				}
+				width := "BHSD"[form.elementSize]
+				switch form.kind {
+				case "immediate":
+					if offset < 0 {
+						memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+					} else if offset > 0 {
+						memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+					}
+					reserved = append(reserved, len(lines)-1)
+				case "register":
+					memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", index)), 1<<form.memorySize
+					if form.memorySize == 0 {
+						memory.Base, memory.Index = memory.Index, memory.Base
+					}
+					reserved = append(reserved, len(lines)-1)
+				case "offset":
+					memory.Index = Reg(fmt.Sprintf("Z%d.%c", index, width))
+					memory.IndexExt = ExtendOp(strings.ToUpper(form.extension))
+					memory.Scale = 1
+					if form.scaled {
+						memory.Scale <<= form.memorySize
+					}
+				case "base":
+					memory.Base = Reg(fmt.Sprintf("Z%d.%c", base, width))
+					memory.Off = int64(offset) << form.memorySize
+				}
+				op := "ZLD1"
+				if signed {
+					op += "S"
+				}
+				wants = append(wants, Instr{Op: Op(op + string("BHWD"[form.memorySize])), Args: []Operand{
+					{Kind: OpMem, Mem: memory},
+					{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", pred))},
+					{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.%c", dst, width))}},
+				}})
+			}
+		}
+	}
+	words := assembleARM64LLVMWords(t, lines, "+sve")
+	for i, word := range words {
+		got, ok := decode(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, i := range reserved {
+		word := words[i] | 31<<16
+		if got, ok := decode(word); ok {
+			t.Errorf("reserved scalar-index/immediate bits in %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_splice_runtime_test.go b/arm64_raw_sve_splice_runtime_test.go
new file mode 100644
index 000000000..3f0a918c3
--- /dev/null
+++ b/arm64_raw_sve_splice_runtime_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVESpliceRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	type spliceForm struct {
+		constructive               bool
+		first, second, destination int
+	}
+	forms := []spliceForm{{false, 31, 0, 31}, {false, 31, 31, 31}}
+	for _, first := range []int{0, 31} {
+		for _, destination := range []int{first, (first + 1) % 32, 15} {
+			forms = append(forms, spliceForm{true, first, (first + 1) % 32, destination})
+		}
+	}
+	for size, width := range "bhsd" {
+		for _, form := range forms {
+			name := fmt.Sprintf("splice_%d", len(sigs))
+			native := []string{
+				"ptrue p0.b", "ld1b { z20.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z20.b, #0",
+				fmt.Sprintf("ld1b { z%d.b }, p0/z, [x0]", form.first),
+			}
+			second := "a"
+			if form.first != form.second {
+				native = append(native, fmt.Sprintf("ld1b { z%d.b }, p0/z, [x1]", form.second))
+				second = "b"
+			}
+			encodedSource := form.second
+			if form.constructive {
+				encodedSource = form.first
+			}
+			native = append(native, arm64RawSVESpliceAssembly(form.constructive, width, form.destination, encodedSource, 7),
+				fmt.Sprintf("st1b { z%d.b }, p0, [x3]", form.destination))
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+			for _, word := range assembleARM64LLVMWords(t, native, "+sve2") {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+			assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+			fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], mask[256], got[256], native[256], scalar[256];
+      const unsigned element = %d;
+      for (unsigned phase = 0; phase < 12; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = i * 17 + phase * 83;
+          b[i] = i * 59 + phase * 23;
+          mask[i] = phase < 2 ? phase : (i / element + phase * 3) %% 7 == 0;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        int first = -1, last = -1;
+        for (unsigned i = 0; i < vl / element; i++) {
+          if (mask[i * element]) {
+            if (first < 0) first = i;
+            last = i;
+          }
+        }
+        unsigned count = first < 0 ? 0 : (last - first + 1) * element;
+        if (count) memcpy(scalar, a + first * element, count);
+        memcpy(scalar + count, %s, vl - count);
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [mask]"r"(mask), [out]"r"(native)
+          : "p0", "p7", "z0", "z1", "z15", "z20", "z31", "memory");
+        %s(a, b, mask, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, 1<<size, second, assembly, name, name, len(sigs))
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_splice", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_splice_test.go b/arm64_raw_sve_splice_test.go
new file mode 100644
index 000000000..86dea55c3
--- /dev/null
+++ b/arm64_raw_sve_splice_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVESpliceAssembly(constructive bool, width rune, destination, source, predicate int) string {
+	if constructive {
+		return fmt.Sprintf("splice z%d.%c, p%d, { z%d.%c, z%d.%c }", destination, width, predicate, source, width, (source+1)%32, width)
+	}
+	return fmt.Sprintf("splice z%d.%c, p%d, z%d.%c, z%d.%c", destination, width, predicate, destination, width, source, width)
+}
+
+func TestARM64RawSVESpliceCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, constructive := range []bool{false, true} {
+		for _, width := range "bhsd" {
+			for _, first := range []int{0, 30, 31} {
+				for _, destination := range []int{first, (first + 1) % 32, 15} {
+					lines = append(lines, arm64RawSVESpliceAssembly(constructive, width, destination, first, 7))
+				}
+			}
+		}
+	}
+	source.WriteString("TEXT rawsplice(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawsplice": {Name: "rawsplice", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawsplice.ll", "rawsplice.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVESpliceOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, constructive := range []bool{false, true} {
+		for size, width := range "bhsd" {
+			for field, limit := range []int{32, 32, 8} {
+				for value := 0; value < limit; value++ {
+					fields := [3]int{31, 31, 7}
+					fields[field] = value
+					dst, src, pred := fields[0], fields[1], fields[2]
+					lines = append(lines, arm64RawSVESpliceAssembly(constructive, width, dst, src, pred))
+					destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", dst, "BHSD"[size]))}
+					source := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", src, "BHSD"[size]))}
+					predicate := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d", pred))}
+					args := []Operand{source, destination, predicate, destination}
+					if constructive {
+						list := Operand{Kind: OpRegList, RegList: []Reg{source.Reg, Reg(fmt.Sprintf("Z%d.%c", (src+1)%32, "BHSD"[size]))}}
+						args = []Operand{list, predicate, destination}
+					}
+					wants = append(wants, Instr{Op: "ZSPLICE", Args: args})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVESplice(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x052c6000, 0x052ca000, 0x052da000, 0x052e8000} {
+		if got, ok := decodeARM64RawSVESplice(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_structured_memory_runtime_test.go b/arm64_raw_sve_structured_memory_runtime_test.go
new file mode 100644
index 000000000..24dfc1244
--- /dev/null
+++ b/arm64_raw_sve_structured_memory_runtime_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEStructuredMemoryRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64RawSVEStructuredCases() {
+		if form.width == "q" { // SVE2.1 Q forms have object checks; QEMU 8 lacks them.
+			continue
+		}
+		for _, indexed := range []bool{false, true} {
+			name := fmt.Sprintf("structure_%d", len(sigs))
+			native := []string{"ptrue p0.b", "ld1b { z20.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z20.b, #0"}
+			if !form.load {
+				for i := 0; i < form.count; i++ {
+					native = append(native, fmt.Sprintf("ld1b { z%d.b }, p0/z, [x0, #%d, mul vl]", (31+i)%32, i))
+				}
+			}
+			base := "x1"
+			if form.load {
+				base = "x0"
+			}
+			address := fmt.Sprintf("[%s, #%d, mul vl]", base, form.count)
+			if indexed {
+				address = fmt.Sprintf("[%s, x4, lsl #%d]", base, form.shift)
+			}
+			native = append(native, form.assembly(31, 7, address))
+			if form.load {
+				for i := 0; i < form.count; i++ {
+					native = append(native, fmt.Sprintf("st1b { z%d.b }, p0, [x1, #%d, mul vl]", (31+i)%32, i))
+				}
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD src+0(FP),R0\nMOVD dst+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD index+24(FP),R4\n", name)
+			for _, word := range assembleARM64LLVMWords(t, native, "+sve") {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: I64, Index: 3, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, void *, const void *, int64_t);\n", name)
+			assembly := strings.NewReplacer("[x0", "[%[src]", "[x1", "[%[dst]", "[x2", "[%[mask]", "x4", "%[index]").Replace(strings.Join(native, "\\n\\t"))
+			load := 0
+			if form.load {
+				load = 1
+			}
+			fmt.Fprintf(&checks, `    {
+      unsigned char input[12288], got[12288], want[12288], mask[256];
+      for (unsigned phase = 0; phase < 8; phase++) {
+        for (unsigned i = 0; i < sizeof(input); i++) input[i] = (i * 17 + phase * 83) & 255;
+        for (unsigned i = 0; i < sizeof(mask); i++) mask[i] = phase < 2 ? phase : (i + phase) %% 3;
+        memset(got, 0x5a, sizeof(got));
+        memset(want, 0x5a, sizeof(want));
+        const int64_t offsets[] = {-3, 0, 5};
+        int64_t index = offsets[phase %% 3];
+        const void *src = phase == 0 && %d ? NULL : input + 4096;
+        void *dst = phase == 0 && !%d ? NULL : want + 4096;
+        __asm__ volatile("%s" :: [src]"r"(src), [dst]"r"(dst), [mask]"r"(mask), [index]"r"(index)
+          : "p0", "p7", "z31", "z0", "z1", "z2", "z20", "memory");
+        %s(src, phase == 0 && !%d ? NULL : got + 4096, mask, index);
+        if (memcmp(got, want, sizeof(got)) != 0) {
+          fprintf(stderr, "%s indexed=%t: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, load, load, assembly, name, load, form.op, indexed, len(sigs))
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_structure", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_structured_memory_test.go b/arm64_raw_sve_structured_memory_test.go
new file mode 100644
index 000000000..4285bfd4e
--- /dev/null
+++ b/arm64_raw_sve_structured_memory_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RawSVEStructuredCase struct {
+	op, width string
+	count     int
+	shift     int
+	load      bool
+}
+
+func arm64RawSVEStructuredCases() []arm64RawSVEStructuredCase {
+	var cases []arm64RawSVEStructuredCase
+	for _, load := range []bool{true, false} {
+		prefix := "st"
+		if load {
+			prefix = "ld"
+		}
+		for _, count := range []int{2, 3, 4} {
+			for shift, suffix := range "bhwdq" {
+				cases = append(cases, arm64RawSVEStructuredCase{
+					fmt.Sprintf("%s%d%c", prefix, count, suffix), string("bhsdq"[shift]), count, shift, load,
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func (form arm64RawSVEStructuredCase) assembly(start, predicate int, address string) string {
+	var registers []string
+	for i := 0; i < form.count; i++ {
+		registers = append(registers, fmt.Sprintf("z%d.%s", (start+i)%32, form.width))
+	}
+	mode := ""
+	if form.load {
+		mode = "/z"
+	}
+	return fmt.Sprintf("%s { %s }, p%d%s, %s", form.op, strings.Join(registers, ", "), predicate, mode, address)
+}
+
+func TestARM64RawSVEStructuredMemoryCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, form := range arm64RawSVEStructuredCases() {
+		for _, base := range []string{"x0", "sp"} {
+			for _, offset := range []int{-8, 0, 7} {
+				lines = append(lines, form.assembly(31, 7, fmt.Sprintf("[%s, #%d, mul vl]", base, offset*form.count)))
+			}
+			lines = append(lines, form.assembly(31, 7, fmt.Sprintf("[%s, x30, lsl #%d]", base, form.shift)))
+		}
+	}
+	source.WriteString("TEXT rawstructure(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawstructure": {Name: "rawstructure", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawstructure.ll", "rawstructure.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEStructuredMemoryOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, form := range arm64RawSVEStructuredCases() {
+		for _, indexed := range []bool{false, true} {
+			limits := []int{32, 8, 32, 16}
+			if indexed {
+				limits[3] = 31
+			}
+			for field, limit := range limits {
+				for value := 0; value < limit; value++ {
+					fields := [4]int{31, 7, 31, 3}
+					fields[field] = value
+					base, baseReg := fmt.Sprintf("x%d", fields[0]), Reg(fmt.Sprintf("R%d", fields[0]))
+					if fields[0] == 31 {
+						base, baseReg = "sp", "RSP"
+					}
+					memory := MemRef{Base: baseReg}
+					var address string
+					if indexed {
+						address = fmt.Sprintf("[%s, x%d, lsl #%d]", base, fields[3], form.shift)
+						memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", fields[3])), int64(1<<form.shift)
+						if form.shift == 0 {
+							memory.Base, memory.Index = memory.Index, memory.Base
+						}
+					} else {
+						offset := (fields[3] - 8) * form.count
+						address = fmt.Sprintf("[%s, #%d, mul vl]", base, offset)
+						if offset < 0 {
+							memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+						} else if offset > 0 {
+							memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+						}
+					}
+					lines = append(lines, form.assembly(fields[2], fields[1], address))
+					list := Operand{Kind: OpRegList}
+					for i := 0; i < form.count; i++ {
+						list.RegList = append(list.RegList, Reg(fmt.Sprintf("Z%d.%s", (fields[2]+i)%32, strings.ToUpper(form.width))))
+					}
+					mode := ""
+					if form.load {
+						mode = ".Z"
+					}
+					predicate := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d%s", fields[1], mode))}
+					args := []Operand{list, predicate, {Kind: OpMem, Mem: memory}}
+					if form.load {
+						args[0], args[2] = args[2], args[0]
+					}
+					wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(form.op)), Args: args})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		got, ok := decodeARM64RawSVEStructuredMemory(word)
+		want := wants[i]
+		if !ok || got.Op != want.Op || fmt.Sprint(got.Args) != fmt.Sprint(want.Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, want)
+		}
+	}
+	for _, form := range arm64RawSVEStructuredCases() {
+		word := assembleARM64LLVMWords(t, []string{form.assembly(0, 0, fmt.Sprintf("[x0, x30, lsl #%d]", form.shift))}, "+sve2p1")[0]
+		word |= 31 << 16
+		if got, ok := decodeARM64RawSVEStructuredMemory(word); ok {
+			t.Errorf("reserved Rm=31 word %#08x decoded as %+v", word, got)
+		}
+	}
+	for _, word := range []uint32{0xa400c000, 0xe410e000, 0xa410e000} {
+		if got, ok := decodeARM64RawSVEStructuredMemory(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_ternary_bitwise_runtime_test.go b/arm64_raw_sve_ternary_bitwise_runtime_test.go
new file mode 100644
index 000000000..11f4265ce
--- /dev/null
+++ b/arm64_raw_sve_ternary_bitwise_runtime_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVETernaryBitwiseRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"bcax", "bsl", "bsl1n", "bsl2n", "eor3", "nbsl"} {
+		for _, registers := range [][2]int{{30, 29}, {31, 29}, {30, 31}, {30, 30}, {31, 31}} {
+			name := fmt.Sprintf("ternary_%d", len(sigs))
+			native := []string{
+				"ptrue p0.b", "ld1b { z31.b }, p0/z, [x0]", "ld1b { z30.b }, p0/z, [x1]",
+				"ld1b { z29.b }, p0/z, [x2]", arm64RawSVETernaryAssembly(op, 31, registers[0], registers[1]),
+				"st1b { z31.b }, p0, [x3]",
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD c+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+			for _, word := range assembleARM64LLVMWords(t, native, "+sve2") {
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+			}
+			source.WriteString("RET\n")
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+			}}}
+			fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, const void *, void *);\n", name)
+			assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[c]]", "[x3]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+			second := map[int]string{31: "a", 30: "b"}[registers[0]]
+			third := map[int]string{31: "a", 30: "b", 29: "c"}[registers[1]]
+			expression := map[string]string{
+				"bcax": "x ^ (y & ~z)", "eor3": "x ^ y ^ z",
+				"bsl": "(x & z) | (y & ~z)", "bsl1n": "(~x & z) | (y & ~z)",
+				"bsl2n": "(x & z) | (~y & ~z)", "nbsl": "~((x & z) | (y & ~z))",
+			}[op]
+			fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], c[256], got[256], native[256], scalar[256];
+      for (unsigned phase = 0; phase < 16; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase < 8 ? ((phase & 1) ? 0xff : 0) : i * 71 + phase * 83;
+          b[i] = phase < 8 ? ((phase & 2) ? 0xff : 0) : i * 17 + phase * 51;
+          c[i] = phase < 8 ? ((phase & 4) ? 0xff : 0) : i * 59 + phase * 29;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        for (unsigned i = 0; i < vl; i++) {
+          unsigned x = a[i], y = %s[i], z = %s[i];
+          scalar[i] = %s;
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [c]"r"(c), [out]"r"(native)
+          : "p0", "z29", "z30", "z31", "memory");
+        %s(a, b, c, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, second, third, expression, assembly, name, name, len(sigs))
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_ternary", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_ternary_bitwise_test.go b/arm64_raw_sve_ternary_bitwise_test.go
new file mode 100644
index 000000000..eb64b9d1e
--- /dev/null
+++ b/arm64_raw_sve_ternary_bitwise_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawSVETernaryAssembly(op string, destination, second, third int) string {
+	return fmt.Sprintf("%s z%d.d, z%d.d, z%d.d, z%d.d", op, destination, destination, second, third)
+}
+
+func TestARM64RawSVETernaryBitwiseCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for _, op := range []string{"bcax", "bsl", "bsl1n", "bsl2n", "eor3", "nbsl"} {
+		lines = append(lines, arm64RawSVETernaryAssembly(op, 31, 30, 29))
+	}
+	source.WriteString("TEXT rawternary(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawternary": {Name: "rawternary", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawternary.ll", "rawternary.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVETernaryBitwiseOperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for _, op := range []string{"bcax", "bsl", "bsl1n", "bsl2n", "eor3", "nbsl"} {
+		for field := 0; field < 3; field++ {
+			for value := 0; value < 32; value++ {
+				fields := [3]int{31, 31, 31}
+				fields[field] = value
+				dst, second, third := fields[0], fields[1], fields[2]
+				lines = append(lines, arm64RawSVETernaryAssembly(op, dst, second, third))
+				vector := func(index int) Operand {
+					return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.D", index))}
+				}
+				wants = append(wants, Instr{Op: Op("Z" + strings.ToUpper(op)), Args: []Operand{
+					vector(third), vector(second), vector(dst), vector(dst),
+				}})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVETernaryBitwise(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x04a03800, 0x04e03800, 0x04203000, 0x04203400, 0x04603400} {
+		if got, ok := decodeARM64RawSVETernaryBitwise(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_unsigned_load_test.go b/arm64_raw_sve_unsigned_load_test.go
new file mode 100644
index 000000000..4b5fbf6b0
--- /dev/null
+++ b/arm64_raw_sve_unsigned_load_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Classic SVE unsigned loads share the signed-load address axes but also
+// accept natural-width destinations. Newer Q and PN forms are tested below.
+func arm64RawSVEUnsignedLoadCases() []arm64RawSVELoadCase {
+	var forms []arm64RawSVELoadCase
+	for memory := 0; memory < 4; memory++ {
+		for element := memory; element < 4; element++ {
+			for _, kind := range []string{"immediate", "register", "offset", "base"} {
+				if element < 2 && (kind == "offset" || kind == "base") {
+					continue
+				}
+				form := arm64RawSVELoadCase{memorySize: memory, elementSize: element, kind: kind}
+				if kind != "offset" {
+					forms = append(forms, form)
+					continue
+				}
+				for _, extension := range []string{"", "uxtw", "sxtw"} {
+					if element == 2 && extension == "" {
+						continue
+					}
+					form.extension = extension
+					for _, scaled := range []bool{false, true} {
+						if memory == 0 && scaled {
+							continue
+						}
+						form.scaled = scaled
+						forms = append(forms, form)
+					}
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func (form arm64RawSVELoadCase) unsignedAssembly(dst, pred, base, index, offset int) string {
+	return form.loadAssembly(false, dst, pred, base, index, offset)
+}
+
+func arm64RawSVEUnsignedExtendedLoadAssembly() []string {
+	var lines []string
+	for memory := 0; memory < 4; memory++ {
+		for _, count := range []int{2, 4} {
+			width := "bhsd"[memory]
+			registers := fmt.Sprintf("{ z28.%c-z%d.%c }", width, 28+count-1, width)
+			lines = append(lines,
+				fmt.Sprintf("ld1%c %s, pn15/z, [sp, x30, lsl #%d]", "bhwd"[memory], registers, memory),
+				fmt.Sprintf("ld1%c %s, pn15/z, [sp, #%d, mul vl]", "bhwd"[memory], registers, -8*count))
+		}
+	}
+	for memory := 2; memory < 4; memory++ {
+		lines = append(lines,
+			fmt.Sprintf("ld1%c { z31.q }, p7/z, [sp, x30, lsl #%d]", "bhwd"[memory], memory),
+			fmt.Sprintf("ld1%c { z31.q }, p7/z, [sp, #-8, mul vl]", "bhwd"[memory]))
+	}
+	return append(lines, "ld1q { z31.q }, p7/z, [z30.d, x29]")
+}
+
+func TestARM64RawSVEUnsignedLoadCompleteFormats(t *testing.T) {
+	forms := arm64RawSVEUnsignedLoadCases()
+	if len(forms) != 58 {
+		t.Fatalf("unsigned-load grammar has %d classic forms, want 58", len(forms))
+	}
+	var lines []string
+	for _, form := range forms {
+		lines = append(lines, form.unsignedAssembly(31, 7, 31, 30, 7))
+	}
+	lines = append(lines, arm64RawSVEUnsignedExtendedLoadAssembly()...)
+	var source strings.Builder
+	source.WriteString("TEXT rawunsignedload(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawunsignedload": {Name: "rawunsignedload", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawunsignedload.ll", "rawunsignedload.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEUnsignedLoadOperandFields(t *testing.T) {
+	testARM64RawSVELoadOperandFields(t, arm64RawSVEUnsignedLoadCases(), false, decodeARM64RawSVEUnsignedLoad)
+	for _, word := range []uint32{0xa4006000, 0xc4008000, 0x84000000, 0xc440e000, 0x8420a000} {
+		if got, ok := decodeARM64RawSVEUnsignedLoad(word); ok {
+			t.Errorf("signed/first-fault/neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
+
+func TestARM64RawSVEUnsignedLoadReservedDoesNotFallThrough(t *testing.T) {
+	var lines []string
+	for _, form := range arm64RawSVEUnsignedLoadCases() {
+		if form.kind != "immediate" && form.kind != "register" {
+			continue
+		}
+		lines = append(lines, form.unsignedAssembly(0, 0, 0, 0, 0))
+	}
+	for _, validWord := range assembleARM64LLVMWords(t, lines, "+sve") {
+		word := validWord | 31<<16
+		file, err := Parse(ArchARM64, fmt.Sprintf("TEXT reservedload(SB),$0-0\nWORD $%#08x\nRET\n", word))
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"reservedload": {Name: "reservedload", Ret: Void}}})
+		if err == nil {
+			t.Errorf("reserved load %#08x fell through to a legacy decoder", word)
+		}
+	}
+}
+
+func TestARM64RawSVEUnsignedExtendedLoadFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for size := 0; size < 4; size++ {
+		for _, count := range []int{2, 4} {
+			for _, immediate := range []bool{false, true} {
+				limits := [4]int{32 / count, 8, 32, 32}
+				if immediate {
+					limits[3] = 16
+				}
+				for field, limit := range limits {
+					for value := 0; value < limit; value++ {
+						fields := [4]int{0, 7, 31, 0}
+						fields[field] = value
+						dst, predicate, base, index := fields[0]*count, fields[1]+8, fields[2], fields[3]
+						baseName, goBase := fmt.Sprintf("x%d", base), Reg(fmt.Sprintf("R%d", base))
+						if base == 31 {
+							baseName, goBase = "sp", "RSP"
+						}
+						memory := MemRef{Base: goBase}
+						address := ""
+						if immediate {
+							offset := (index - 8) * count
+							address = fmt.Sprintf("[%s, #%d, mul vl]", baseName, offset)
+							if offset < 0 {
+								memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+							} else if offset > 0 {
+								memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+							}
+						} else {
+							indexName := fmt.Sprintf("x%d", index)
+							if index == 31 {
+								indexName = "xzr"
+							} else {
+								memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", index)), 1<<size
+								if size == 0 {
+									memory.Base, memory.Index = memory.Index, memory.Base
+								}
+							}
+							address = fmt.Sprintf("[%s, %s, lsl #%d]", baseName, indexName, size)
+						}
+						lines = append(lines, fmt.Sprintf("ld1%c {z%d.%c-z%d.%c}, pn%d/z, %s",
+							"bhwd"[size], dst, "bhsd"[size], dst+count-1, "bhsd"[size], predicate, address))
+						registers := make([]Reg, count)
+						for i := range registers {
+							registers[i] = Reg(fmt.Sprintf("Z%d.%c", dst+i, "BHSD"[size]))
+						}
+						wants = append(wants, Instr{Op: Op("ZLD1" + string("BHWD"[size])), Args: []Operand{
+							{Kind: OpMem, Mem: memory}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("PN%d.Z", predicate))},
+							{Kind: OpRegList, RegList: registers},
+						}})
+					}
+				}
+			}
+		}
+	}
+	for size := 2; size < 4; size++ {
+		for _, immediate := range []bool{false, true} {
+			limits := [4]int{32, 8, 32, 31}
+			if immediate {
+				limits[3] = 16
+			}
+			for field, limit := range limits {
+				for value := 0; value < limit; value++ {
+					fields := [4]int{31, 7, 31, 0}
+					fields[field] = value
+					dst, predicate, base, index := fields[0], fields[1], fields[2], fields[3]
+					baseName := fmt.Sprintf("x%d", base)
+					memory := MemRef{Base: Reg(fmt.Sprintf("R%d", base))}
+					if base == 31 {
+						baseName, memory.Base = "sp", "RSP"
+					}
+					address := ""
+					if immediate {
+						offset := index - 8
+						address = fmt.Sprintf("[%s, #%d, mul vl]", baseName, offset)
+						if offset < 0 {
+							memory.OffRaw = fmt.Sprintf("-VL*%d", -offset)
+						} else if offset > 0 {
+							memory.OffRaw = fmt.Sprintf("VL*%d", offset)
+						}
+					} else {
+						address = fmt.Sprintf("[%s, x%d, lsl #%d]", baseName, index, size)
+						memory.Index, memory.Scale = Reg(fmt.Sprintf("R%d", index)), 1<<size
+					}
+					lines = append(lines, fmt.Sprintf("ld1%c {z%d.q}, p%d/z, %s", "bhwd"[size], dst, predicate, address))
+					wants = append(wants, Instr{Op: Op("ZLD1" + string("BHWD"[size])), Args: []Operand{
+						{Kind: OpMem, Mem: memory}, {Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", predicate))},
+						{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.Q", dst))}},
+					}})
+				}
+			}
+		}
+	}
+	for field, limit := range [4]int{32, 8, 32, 32} {
+		for value := 0; value < limit; value++ {
+			fields := [4]int{31, 7, 31, 0}
+			fields[field] = value
+			dst, predicate, base, index := fields[0], fields[1], fields[2], fields[3]
+			indexName, goIndex := fmt.Sprintf("x%d", index), Reg(fmt.Sprintf("R%d", index))
+			if index == 31 {
+				indexName, goIndex = "xzr", ZR
+			}
+			lines = append(lines, fmt.Sprintf("ld1q {z%d.q}, p%d/z, [z%d.d, %s]", dst, predicate, base, indexName))
+			wants = append(wants, Instr{Op: "ZLD1Q", Args: []Operand{
+				{Kind: OpMem, Mem: MemRef{Base: goIndex, Index: Reg(fmt.Sprintf("Z%d.D", base)), Scale: 1}},
+				{Kind: OpReg, Reg: Reg(fmt.Sprintf("P%d.Z", predicate))},
+				{Kind: OpRegList, RegList: []Reg{Reg(fmt.Sprintf("Z%d.Q", dst))}},
+			}})
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2p1") {
+		got, ok := decodeARM64RawSVEUnsignedLoad(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0xa0000001, 0xa0008002, 0xa0500000, 0xa500a000, 0xa59f8000} {
+		if got, ok := decodeARM64RawSVEUnsignedLoad(word); ok {
+			t.Errorf("neighboring/reserved extended load %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_vector_count_runtime_test.go b/arm64_raw_sve_vector_count_runtime_test.go
new file mode 100644
index 000000000..ddbaa270f
--- /dev/null
+++ b/arm64_raw_sve_vector_count_runtime_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEVectorCountRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	declarations.WriteString(`
+static uint64_t vector_count(unsigned pattern, unsigned lanes) {
+  if (pattern == 31) return lanes;
+  if (pattern == 30) return lanes / 3 * 3;
+  if (pattern == 29) return lanes / 4 * 4;
+  if (pattern == 0) {
+    unsigned n = 1;
+    while (n * 2 <= lanes) n *= 2;
+    return n;
+  }
+  unsigned n = pattern <= 8 ? pattern : pattern <= 13 ? 1u << (pattern - 5) : 0;
+  return n <= lanes ? n : 0;
+}
+`)
+	sigs := make(map[string]FuncSig)
+	for _, operation := range []string{"inc", "dec"} {
+		for size := 1; size < 4; size++ {
+			for pattern := 0; pattern < 32; pattern++ {
+				name := fmt.Sprintf("vector_count_%d", len(sigs))
+				multiplier := pattern%16 + 1
+				native := []string{
+					"ptrue p0.b", "ld1b { z31.b }, p0/z, [x0]",
+					fmt.Sprintf("%s%c z31.%c, #%d, mul #%d", operation, "bhwd"[size], "bhsd"[size], pattern, multiplier),
+					"st1b { z31.b }, p0, [x1]",
+				}
+				words := assembleARM64LLVMWords(t, native, "+sve")
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVD a+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+				for _, word := range words {
+					fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				}
+				source.WriteString("RET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *, void *);\n", name)
+				// Some GNU assembler versions reject unnamed predicate patterns.
+				// Their encodings are legal and architecturally count zero.
+				native[2] = fmt.Sprintf(".inst %#08x", words[2])
+				assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+				operator := "+"
+				if operation == "dec" {
+					operator = "-"
+				}
+				fmt.Fprintf(&checks, `    {
+      unsigned char a[256], got[256], native[256], scalar[256];
+      const unsigned element = %d;
+      uint64_t count = vector_count(%d, vl / element) * %d;
+      for (unsigned phase = 0; phase < 8; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase == 0 ? 0xff : phase == 1 ? 0 : i * 71 + phase * 83;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        for (unsigned i = 0; i < vl; i += element) {
+          uint64_t value = 0;
+          memcpy(&value, a + i, element);
+          value = value %s count;
+          memcpy(scalar + i, &value, element);
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [out]"r"(native) : "p0", "z31", "memory");
+        %s(a, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, 1<<size, pattern, multiplier, operator, assembly, name, name, len(sigs))
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "raw_vector_count", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_vector_count_test.go b/arm64_raw_sve_vector_count_test.go
new file mode 100644
index 000000000..fd27e5d09
--- /dev/null
+++ b/arm64_raw_sve_vector_count_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEVectorCountCompleteFormats(t *testing.T) {
+	var lines []string
+	for _, operation := range []string{"inc", "dec"} {
+		for size := 1; size < 4; size++ {
+			for pattern := 0; pattern < 32; pattern++ {
+				for _, multiplier := range []int{1, 7, 16} {
+					lines = append(lines, fmt.Sprintf("%s%c z31.%c, #%d, mul #%d", operation, "bhwd"[size], "bhsd"[size], pattern, multiplier))
+				}
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawvectorcount(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawvectorcount": {Name: "rawvectorcount", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawvectorcount.ll", "rawvectorcount.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEVectorCountOperandFields(t *testing.T) {
+	var lines []string
+	var wants []arm64RawSVECnt
+	for _, operation := range []string{"inc", "dec"} {
+		for size := 1; size < 4; size++ {
+			for field, limit := range []int{32, 32, 16} {
+				for value := 0; value < limit; value++ {
+					fields := [3]int{31, 31, 15}
+					fields[field] = value
+					dst, pattern, multiplier := fields[0], fields[1], fields[2]+1
+					lines = append(lines, fmt.Sprintf("%s%c z%d.%c, #%d, mul #%d", operation, "bhwd"[size], dst, "bhsd"[size], pattern, multiplier))
+					arithmetic := "add"
+					if operation == "dec" {
+						arithmetic = "sub"
+					}
+					wants = append(wants, arm64RawSVECnt{
+						op: Op(strings.ToUpper(operation + string("bhwd"[size]))), elementBits: 8 << size,
+						destination: dst, pattern: pattern, multiplier: multiplier, operation: arithmetic, vector: true,
+					})
+				}
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		requireARM64PoolScalableFlags(t, lines[i], word, 0)
+		for address := 0; address < 32; address++ {
+			if !arm64RawPoolSVEIgnoresAddress(word, address) {
+				t.Fatalf("%s: vector-only count unexpectedly reads R%d", lines[i], address)
+			}
+		}
+		got, ok := decodeARM64RawSVECnt(word)
+		if !ok || got != wants[i] {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for _, word := range []uint32{0x0430c000, 0x0430c400, 0x0470c800, 0x0470d000, 0x0460c000} {
+		if got, ok := decodeARM64RawSVECnt(word); ok {
+			t.Errorf("unallocated or adjacent word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_sve_xar_runtime_test.go b/arm64_raw_sve_xar_runtime_test.go
new file mode 100644
index 000000000..e7ce1f318
--- /dev/null
+++ b/arm64_raw_sve_xar_runtime_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64RawSVEXARRuntime(t *testing.T, llc string) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for size, width := range "bhsd" {
+		bits := 8 << size
+		for _, shift := range []int{1, bits / 2, bits - 1, bits} {
+			for _, destination := range []int{30, 31} {
+				name := fmt.Sprintf("xar_%d", len(sigs))
+				native := []string{
+					"ptrue p0.b",
+					"ld1b { z30.b }, p0/z, [x0]",
+					"ld1b { z31.b }, p0/z, [x1]",
+					fmt.Sprintf("xar z%d.%c, z%d.%c, z30.%c, #%d", destination, width, destination, width, width, shift),
+					fmt.Sprintf("st1b { z%d.b }, p0, [x2]", destination),
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD a+0(FP),R0\nMOVD b+8(FP),R1\nMOVD out+16(FP),R2\n", name)
+				for _, word := range assembleARM64LLVMWords(t, native, "+sve2") {
+					fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				}
+				source.WriteString("RET\n")
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+				fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *);\n", name)
+				assembly := strings.NewReplacer("[x0]", "[%[a]]", "[x1]", "[%[b]]", "[x2]", "[%[out]]").Replace(strings.Join(native, "\\n\\t"))
+				first := "b"
+				if destination == 30 {
+					first = "a"
+				}
+				fmt.Fprintf(&checks, `    {
+      unsigned char a[256], b[256], got[256], native[256], scalar[256];
+      const unsigned bytes = %d, bits = %d, rotation = %d %% bits;
+      for (unsigned phase = 0; phase < 12; phase++) {
+        for (unsigned i = 0; i < sizeof(a); i++) {
+          a[i] = phase < 2 ? 255 * phase : i * 17 + phase * 83;
+          b[i] = phase < 2 ? 255 * (1 - phase) : i * 59 + phase * 23;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        for (unsigned i = 0; i < vl; i += bytes) {
+          uint64_t first = 0, second = 0;
+          memcpy(&first, %s + i, bytes);
+          memcpy(&second, a + i, bytes);
+          uint64_t value = first ^ second;
+          if (rotation) value = (value >> rotation) | (value << (bits - rotation));
+          memcpy(scalar + i, &value, bytes);
+        }
+        __asm__ volatile("%s" :: [a]"r"(a), [b]"r"(b), [out]"r"(native)
+          : "p0", "z30", "z31", "memory");
+        %s(a, b, got);
+        if (memcmp(got, native, sizeof(got)) || memcmp(got, scalar, sizeof(got))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u\n", vl, phase);
+          return %d;
+        }
+      }
+    }
+`, bits/8, bits, shift, first, assembly, name, name, len(sigs))
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve2"}, "raw_xar", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_raw_sve_xar_test.go b/arm64_raw_sve_xar_test.go
new file mode 100644
index 000000000..1ef355cbe
--- /dev/null
+++ b/arm64_raw_sve_xar_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSVEXARCompleteFormats(t *testing.T) {
+	var source strings.Builder
+	var lines []string
+	for size, width := range "bhsd" {
+		for shift := 1; shift <= 8<<size; shift++ {
+			lines = append(lines, fmt.Sprintf("xar z31.%c, z31.%c, z30.%c, #%d", width, width, width, shift))
+		}
+	}
+	source.WriteString("TEXT rawxar(SB),$0-0\n")
+	for _, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawxar": {Name: "rawxar", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "rawxar.ll", "rawxar.o", ir)
+		})
+	}
+}
+
+func TestARM64RawSVEXAROperandFields(t *testing.T) {
+	var lines []string
+	var wants []Instr
+	for size, width := range "bhsd" {
+		limits := []int{32, 32, 8 << size}
+		for field, limit := range limits {
+			for value := 0; value < limit; value++ {
+				fields := [3]int{31, 30, (8 << size) - 1}
+				fields[field] = value
+				dst, src, shift := fields[0], fields[1], fields[2]+1
+				lines = append(lines, fmt.Sprintf("xar z%d.%c, z%d.%c, z%d.%c, #%d", dst, width, dst, width, src, width, shift))
+				destination := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", dst, "BHSD"[size]))}
+				wants = append(wants, Instr{Op: "ZXAR", Args: []Operand{
+					{Kind: OpImm, Imm: int64(shift)},
+					{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d.%c", src, "BHSD"[size]))},
+					destination, destination,
+				}})
+			}
+		}
+	}
+	for i, word := range assembleARM64LLVMWords(t, lines, "+sve2") {
+		got, ok := decodeARM64RawSVEXAR(word)
+		if !ok || got.Op != wants[i].Op || fmt.Sprint(got.Args) != fmt.Sprint(wants[i].Args) {
+			t.Fatalf("%s: decoded %#08x as %+v, %v; want %+v", lines[i], word, got, ok, wants[i])
+		}
+	}
+	for shift := uint32(0); shift < 8; shift++ {
+		word := uint32(0x04203400) | shift<<16
+		if got, ok := decodeARM64RawSVEXAR(word); ok {
+			t.Errorf("reserved tsize=0000 word %#08x decoded as %+v", word, got)
+		}
+	}
+	for _, word := range []uint32{0x04283000, 0x04283800, 0x04283020} {
+		if got, ok := decodeARM64RawSVEXAR(word); ok {
+			t.Errorf("neighboring word %#08x decoded as %+v", word, got)
+		}
+	}
+}
diff --git a/arm64_raw_undefined_test.go b/arm64_raw_undefined_test.go
new file mode 100644
index 000000000..f1dd21429
--- /dev/null
+++ b/arm64_raw_undefined_test.go
@@ -0,0 +1,315 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var arm64UndefinedImmediateCases = []uint16{0, 1, 16, 0x1234, 0x7fff, 0xffff}
+
+func arm64UndefinedSource() (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, immediate := range arm64UndefinedImmediateCases {
+		name := fmt.Sprintf("rawUDF%d", immediate)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\nWORD $%#08x\n", name, immediate)
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+	}
+	return source.String(), sigs
+}
+
+func TestARM64RawUndefinedEncodingsPreserveImmediate(t *testing.T) {
+	source, sigs := arm64UndefinedSource()
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, immediate := range arm64UndefinedImmediateCases {
+				want := fmt.Sprintf("asm sideeffect \"udf #%d\", \"~{memory}\"()\n  unreachable", immediate)
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing exact terminating exception %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			requireARM64UndefinedObjectEncodings(t, llc, triple, ir)
+		})
+	}
+}
+
+func requireARM64UndefinedObjectEncodings(t *testing.T, llc, triple, ir string) {
+	t.Helper()
+	objdump := findLLVM22Tool("llvm-objdump")
+	if objdump == "" {
+		t.Fatal("LLVM 22 llvm-objdump not found")
+	}
+	nm := findLLVM22Tool("llvm-nm")
+	if nm == "" {
+		t.Fatal("LLVM 22 llvm-nm not found")
+	}
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "udf.ll"), filepath.Join(dir, "udf.o")
+	if err := os.WriteFile(source, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if output, err := exec.Command(llc, "-O0", "-mtriple="+triple, "-filetype=obj", source, "-o", object).CombinedOutput(); err != nil {
+		t.Fatalf("LLVM 22 UDF object: %v\n%s", err, output)
+	}
+	listing, err := exec.Command(objdump, "-d", object).CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM 22 UDF disassembly: %v\n%s", err, listing)
+	}
+	names, err := exec.Command(nm, "-n", "--defined-only", object).CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM 22 UDF symbol table: %v\n%s", err, names)
+	}
+	addresses := make(map[uint64]string)
+	for _, match := range regexp.MustCompile(`(?m)^([0-9a-f]+)\s+[Tt]\s+_?(rawUDF[0-9]+)$`).FindAllSubmatch(names, -1) {
+		address, err := strconv.ParseUint(string(match[1]), 16, 64)
+		if err != nil || addresses[address] != "" {
+			t.Fatalf("invalid/duplicate UDF function address:\n%s", names)
+		}
+		addresses[address] = string(match[2])
+	}
+	// Mach-O can print ltmp0 instead of the external symbol at the first
+	// function's address. Bind that region through the actual symbol table;
+	// never guess that a coincidental UDF elsewhere belongs to this function.
+	symbols := regexp.MustCompile(`(?m)^([0-9a-f]+) <[^>]+>:\n`).FindAllSubmatchIndex(listing, -1)
+	if len(symbols) != len(arm64UndefinedImmediateCases) {
+		t.Fatalf("incomplete UDF symbol inventory:\n%s", listing)
+	}
+	seen := make(map[string]bool)
+	for index, symbol := range symbols {
+		address, err := strconv.ParseUint(string(listing[symbol[2]:symbol[3]]), 16, 64)
+		if err != nil || addresses[address] == "" {
+			t.Fatalf("disassembly region has no exact UDF function binding:\n%s", listing)
+		}
+		name := addresses[address]
+		end := len(listing)
+		if index+1 < len(symbols) {
+			end = symbols[index+1][0]
+		}
+		matched := false
+		for _, immediate := range arm64UndefinedImmediateCases {
+			if name != fmt.Sprintf("rawUDF%d", immediate) {
+				continue
+			}
+			pattern := fmt.Sprintf(`(?m)^\s*[0-9a-f]+:\s+%08x\s+udf\s+#`, immediate)
+			if !regexp.MustCompile(pattern).Match(listing[symbol[1]:end]) {
+				t.Fatalf("%s lacks exact UDF imm16 machine bytes:\n%s", name, listing[symbol[1]:end])
+			}
+			matched = true
+		}
+		if !matched || seen[name] {
+			t.Fatalf("unexpected/duplicate UDF symbol %s", name)
+		}
+		seen[name] = true
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawUndefinedFaultOracles(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, sigs := arm64UndefinedSource()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "arm64-raw-udf-fault", triple, ir,
+		arm64UndefinedFaultOracleC(), runner)
+
+	// Link and call the original Go WORD bodies independently. Go's signal
+	// handler reports SIGILL and terminates the child with exit code 2.
+	dir := t.TempDir()
+	var mainGo strings.Builder
+	mainGo.WriteString("package main\nimport \"os\"\n")
+	for _, immediate := range arm64UndefinedImmediateCases {
+		fmt.Fprintf(&mainGo, "func rawUDF%d()\n", immediate)
+	}
+	mainGo.WriteString("func main() { switch os.Args[1] {\n")
+	for _, immediate := range arm64UndefinedImmediateCases {
+		fmt.Fprintf(&mainGo, "case \"%d\": rawUDF%d()\n", immediate, immediate)
+	}
+	mainGo.WriteString("} }\n")
+	for name, content := range map[string]string{
+		"go.mod":      "module example.com/udf-native\n\ngo 1.20\n",
+		"main.go":     mainGo.String(),
+		"udf_arm64.s": strings.ReplaceAll(source, "TEXT rawUDF", "TEXT ·rawUDF"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original-udf")
+	ctx, cancel := runtimeOracleStageContext(t)
+	build := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", executable, ".")
+	build.Dir, build.Env = dir, append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=arm64")
+	if len(runner) != 0 {
+		build.Env = append(build.Env, "GOOS=linux")
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, build)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go UDF build: %v\n%s", err, output)
+	}
+	for _, immediate := range arm64UndefinedImmediateCases {
+		args := runtimeOracleGuestArguments(t, runner, executable, fmt.Sprint(immediate))
+		ctx, cancel = runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, args[0], args[1:]...)
+		command.Env = append(os.Environ(), "GOTRACEBACK=single")
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		exit, ok := err.(*exec.ExitError)
+		if !ok || exit.ExitCode() != 2 || !strings.Contains(string(output), "SIGILL: illegal instruction") {
+			t.Fatalf("original Go UDF #%d did not deliver the expected SIGILL: %v\n%s", immediate, err, output)
+		}
+	}
+}
+
+func arm64UndefinedFaultOracleC() string {
+	var main strings.Builder
+	main.WriteString(`#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+`)
+	for _, immediate := range arm64UndefinedImmediateCases {
+		fmt.Fprintf(&main, "extern void rawUDF%d(void);\n", immediate)
+	}
+	main.WriteString("\nstatic void (*fault_functions[])(void) = {\n")
+	for _, immediate := range arm64UndefinedImmediateCases {
+		fmt.Fprintf(&main, "    rawUDF%d,\n", immediate)
+	}
+	main.WriteString(`};
+
+int main(void) {
+    struct rlimit no_core = {0, 0};
+    if (setrlimit(RLIMIT_CORE, &no_core)) return 1;
+
+    for (unsigned i = 0; i < sizeof(fault_functions) / sizeof(fault_functions[0]); i++) {
+        pid_t child = fork();
+        if (child < 0) return 2;
+        if (!child) {
+            fault_functions[i]();
+            _exit(90);
+        }
+
+        int status;
+        if (waitpid(child, &status, 0) != child ||
+            !WIFSIGNALED(status) || WTERMSIG(status) != SIGILL) return 3;
+    }
+    return 0;
+}
+`)
+	return main.String()
+}
+
+func TestARM64RawUndefinedDecoderRejectsAdjacentEncodings(t *testing.T) {
+	for _, word := range []uint32{0x00010000, 0x0001ffff, 0x01000000, 0xffffffff} {
+		ins := Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}
+		decoded, err := decodeARM64RawWordInstruction(ins)
+		if err == nil && decoded.Op == "UNDEF" {
+			t.Fatalf("unrelated word %#08x became an undefined-exception witness", word)
+		}
+	}
+}
+
+func TestARM64RawReachableUndefinedWordDoesNotBecomeData(t *testing.T) {
+	const source = `TEXT rawReachableUndefined(SB),4,$0-0
+	WORD $0xd503201f // NOP falls through into the trap.
+reachable:
+	WORD $0x00000002 // Allocated UDF #2, not a trailing constant pool.
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{
+			"rawReachableUndefined": {Name: "rawReachableUndefined", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, `asm sideeffect "udf #2"`) || strings.Contains(ir, ".raw_data") {
+		t.Fatalf("reachable UDF became data or lost its immediate:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "reachable-udf.ll", "reachable-udf.o", ir)
+}
+
+func TestARM64RawUndefinedDecoderCompleteImmediateField(t *testing.T) {
+	for word := uint32(0); word <= 0xffff; word++ {
+		ins := Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}
+		decoded, err := decodeARM64RawWordInstruction(ins)
+		if err != nil || decoded.Op != "UNDEF" || len(decoded.Args) != 0 || decoded.arm64RawUndefinedImmediate != uint16(word) {
+			t.Fatalf("UDF %#08x decoded as %+v, %v", word, decoded, err)
+		}
+		if features := inferFuncTargetFeaturesForGOARCH(ArchARM64, "arm64", Func{Instrs: []Instr{ins}}); features != "" {
+			t.Fatalf("baseline UDF %#08x acquired unrelated target features %q", word, features)
+		}
+	}
+}
+
+func TestARM64RawUndefinedRequiresActualIntegerEncoding(t *testing.T) {
+	for _, value := range []string{"0.0", "-0.0", "1.25"} {
+		source := "TEXT badRawUndefined(SB),4,$0-0\nWORD $(" + value + ")\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"badRawUndefined": {Name: "badRawUndefined", Ret: Void}}}); err == nil {
+			t.Fatalf("floating constant %s acquired an integer machine-code witness", value)
+		}
+	}
+}
+
+func TestARM64ExceptionImmediateRejectsFloatingConstantsLikeGo(t *testing.T) {
+	for _, op := range []string{"BRK", "HLT", "HVC", "SMC", "DCPS1", "DCPS2", "DCPS3"} {
+		for _, value := range []string{"0.0", "-0.0", "1.25"} {
+			t.Run(op+"/"+value, func(t *testing.T) {
+				source := "TEXT badException(SB),4,$0-0\n" + op + " $(" + value + ")\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"badException": {Name: "badException", Ret: Void}}}); err == nil {
+					t.Fatalf("%s accepted Go's floating operand class %s as an imm16", op, value)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_raw_unlabelled_pool.go b/arm64_raw_unlabelled_pool.go
new file mode 100644
index 000000000..d7ed10201
--- /dev/null
+++ b/arm64_raw_unlabelled_pool.go
@@ -0,0 +1,587 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/arm64/arm64asm"
+)
+
+// identifyARM64UnlabelledPool handles a trailing, contiguous raw routine and
+// its appended constants. Walk actual control-flow edges before examining
+// address references: data bytes can themselves look like branches or ADRs.
+// Unknown source widths, indirect control flow, escaping addresses and mixed
+// code/data regions remain on the ordinary fail-closed path.
+func identifyARM64UnlabelledPool(fn Func, points []arm64RawLayoutPoint, known map[string]bool, returnClobbers uint32) (map[int]bool, []arm64RawDataBlob, map[int]string) {
+	end := len(fn.Instrs)
+	if end > 0 && fn.Instrs[end-1].Op == OpRET {
+		end--
+	}
+	sourceReturn := end < len(fn.Instrs) && len(fn.Instrs[end].Args) == 0
+	start := end
+	for start > 0 && arm64RawLiteralWord(fn.Instrs[start-1]) {
+		start--
+	}
+	if start == end {
+		return nil, nil, nil
+	}
+	for _, ins := range fn.Instrs[:start] {
+		if ins.Op == OpWORD {
+			return nil, nil, nil
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind == OpMem && arg.Mem.Base == PC || arg.Kind == OpSym && strings.Contains(arg.Sym, fn.Sym+"+") {
+				return nil, nil, nil
+			}
+		}
+	}
+
+	visited := make(map[int]bool)
+	queue := []int{start}
+	last := start
+	addresses := make(map[int]int)
+	for len(queue) > 0 {
+		at := queue[len(queue)-1]
+		queue = queue[:len(queue)-1]
+		if visited[at] {
+			continue
+		}
+		if at == end && sourceReturn {
+			// A raw branch may cross the appended data to the ordinary
+			// source RET. Preserve its Go auto-epilogue rather than require
+			// an unsafe hardware RET before the pool. No other boundary or
+			// register-return contract is inferred here.
+			continue
+		}
+		if at < start || at >= end {
+			return nil, nil, nil
+		}
+		visited[at] = true
+		if at > last {
+			last = at
+		}
+		word := uint32(fn.Instrs[at].Args[0].Imm)
+		// BR and BLR cannot prove their successor without value-flow analysis.
+		if word&0xfffffc1f == 0xd61f0000 || word&0xfffffc1f == 0xd63f0000 {
+			return nil, nil, nil
+		}
+		if word&0xfffffc1f == 0xd65f0000 { // RET Xn.
+			continue
+		}
+		displacement, op, relative, err := arm64RawPCRelativeDisplacement(fn.Instrs[at])
+		if err != nil {
+			return nil, nil, nil
+		}
+		if relative {
+			if displacement%4 != 0 {
+				return nil, nil, nil
+			}
+			target := at + int(displacement/4)
+			switch op {
+			case "ADR":
+				addresses[at] = target
+			case "B", "BL", "CBZ", "CBNZ", "TBZ", "TBNZ":
+				queue = append(queue, target)
+			default:
+				return nil, nil, nil
+			}
+		}
+		if word&0xfc000000 != 0x14000000 { // Only unconditional B ends fallthrough.
+			queue = append(queue, at+1)
+		}
+	}
+	pool := last + 1
+	if pool >= end {
+		return nil, nil, nil
+	}
+
+	// An ADR can also construct a function pointer. Only classify its target
+	// as data when the produced address is used exclusively by loads and killed
+	// on every outgoing path (possibly by an explicit return contract).
+	values := newARM64RawPoolValues(fn.Instrs, start, pool, visited)
+	origins := make(map[int]uint64)
+	for at, target := range addresses {
+		if target >= pool && target < end {
+			origins[at] = uint64(target-pool) * 4
+		}
+	}
+	size := int64(end-pool) * 4
+	if !arm64RawPoolAddressProof(fn.Instrs, pool, size, returnClobbers, values, origins) &&
+		!arm64RawPoolAllVectorLengths(fn.Instrs, start, pool, size, returnClobbers, visited, origins) {
+		return nil, nil, nil
+	}
+	insertions := make(map[int]string)
+	label := func(at int) string {
+		if name, ok := insertions[at]; ok {
+			return name
+		}
+		name := arm64UniqueRawTargetLabel(known, points[at])
+		known[name] = true
+		insertions[at] = name
+		return name
+	}
+	blob := arm64RawDataBlob{label: label(pool), aliases: make(map[string]int64)}
+	for _, target := range addresses {
+		if target >= pool && target < end {
+			blob.aliases[label(target)] = int64(target-pool) * 4
+		}
+	}
+	words := make(map[int]bool)
+	for at := pool; at < end; at++ {
+		words[at] = true
+		var bytes [4]byte
+		binary.LittleEndian.PutUint32(bytes[:], uint32(fn.Instrs[at].Args[0].Imm))
+		blob.bytes = append(blob.bytes, bytes[:]...)
+	}
+	return words, []arm64RawDataBlob{blob}, insertions
+}
+
+func arm64RawAddressOnlyLoaded(instructions []Instr, at, end int) bool {
+	return arm64RawAddressOnlyLoadedWithExit(instructions, at, end, 0)
+}
+
+// Only the translating caller has a FuncSig. Standalone layout probes remain
+// conservative. Explicit parameter/result contracts identify registers that
+// cannot be results. Restrict terminal kills to R0..R17, avoiding platform,
+// callee-preserved, frame, Go-context and link registers. Exclude both normal
+// ABI results and every frame-slot fallback register used by lowerRET.
+func arm64RawPoolReturnClobbers(fn Func, sig FuncSig) uint32 {
+	if len(sig.ArgRegs) != 0 || len(sig.Frame.Params) == 0 || fn.ArgSize <= 0 {
+		return 0
+	}
+	const scratch = (1 << 18) - 1
+	if sig.Ret == Void {
+		if len(sig.Frame.Results) != 0 {
+			return 0
+		}
+		return scratch
+	}
+	if len(sig.Frame.Results) == 0 {
+		return 0
+	}
+	fields, aggregate := parseLiteralStructFields(sig.Ret)
+	if !aggregate {
+		fields = []LLVMType{sig.Ret}
+	}
+	mask := uint32(scratch)
+	cursor := arm64ABIRegisterCursor{}
+	for _, typ := range fields {
+		if _, err := cursor.next(typ); err != nil {
+			return 0
+		}
+		if isARM64ABIIntegerType(typ) {
+			mask &^= 1 << (cursor.integer - 1)
+		}
+	}
+	for _, slot := range sig.Frame.Results {
+		if slot.Index < 0 || slot.Index > 31 {
+			return 0
+		}
+		mask &^= 1 << slot.Index
+	}
+	return mask
+}
+
+func arm64RawAddressOnlyLoadedWithExit(instructions []Instr, at, end int, returnClobbers uint32) bool {
+	return arm64RawAddressOnlyLoadedWithinPool(instructions, at, end, returnClobbers, nil)
+}
+
+type arm64RawPoolBounds struct {
+	offset   int64
+	size     int64
+	values   *arm64RawPoolValues
+	origins  map[int]uint64
+	symbolic bool
+}
+
+type arm64RawPoolFlow struct {
+	at       int
+	register arm64asm.Reg
+	offset   arm64RawPoolRange
+}
+
+func arm64RawAddressOnlyLoadedWithinPool(instructions []Instr, at, end int, returnClobbers uint32, bounds *arm64RawPoolBounds) bool {
+	register := arm64asm.X0 + arm64asm.Reg(uint32(instructions[at].Args[0].Imm)&31)
+	loaded := false
+	initialOffset := int64(0)
+	if bounds != nil {
+		initialOffset = bounds.offset
+		if bounds.symbolic {
+			initialOffset = 0 // Numeric offsets come from reaching definitions at each read.
+		}
+	}
+	visited := make(map[arm64RawPoolValue]arm64RawPoolRange)
+	queue := []arm64RawPoolFlow{{at + 1, register, arm64RawPoolRange{initialOffset, initialOffset}}}
+	for len(queue) > 0 {
+		state := queue[len(queue)-1]
+		i, offset := state.at, state.offset
+		register := state.register
+		wordRegister := register - arm64asm.X0 + arm64asm.W0
+		isAddress := func(r arm64asm.Reg) bool { return r == register || r == wordRegister }
+		next := func(at int) {
+			if bounds != nil && bounds.values != nil && bounds.values.excluded[arm64RawPoolEdge{i, at}] {
+				return
+			}
+			nextOffset := offset
+			if bounds != nil && bounds.symbolic {
+				nextOffset = arm64RawPoolRange{}
+			}
+			queue = append(queue, arm64RawPoolFlow{at, register, nextOffset})
+		}
+		queue = queue[:len(queue)-1]
+		if i < 0 || i >= end {
+			return false
+		}
+		key := arm64RawPoolValue{i, register}
+		if previous, ok := visited[key]; ok {
+			// A changing loop offset or disagreeing join needs range analysis,
+			// not an instruction-only visited set that drops the second path.
+			if previous != offset {
+				return false
+			}
+			continue
+		}
+		visited[key] = offset
+		if !arm64RawLiteralWord(instructions[i]) {
+			return false
+		}
+		word := uint32(instructions[i].Args[0].Imm)
+		if form, ok := decodeARM64RawSVEAddress(word); ok {
+			if form.op != "RDVL" && form.source == int(register-arm64asm.X0) {
+				derived, ok := arm64RawPoolScalableAlias(form, offset, bounds)
+				if !ok {
+					return false
+				}
+				alias := arm64asm.X0 + arm64asm.Reg(form.destination)
+				queue = append(queue, arm64RawPoolFlow{i + 1, alias, derived})
+			}
+			if form.destination != int(register-arm64asm.X0) {
+				next(i + 1)
+			}
+			continue
+		}
+		if form, ok := decodeARM64RawSVECnt(word); ok {
+			if !form.vector && form.destination == int(register-arm64asm.X0) {
+				if form.operation != "" { // INC/DEC reads and changes the address.
+					return false
+				}
+			} else {
+				next(i + 1)
+			}
+			continue
+		}
+		// CNTP has only predicate inputs and overwrites its explicit GP
+		// destination. Writing this register kills the old pool address.
+		if ins, ok := decodeARM64RawSVEPredicateCount(word); ok {
+			if ins.Args[2].Reg != Reg(fmt.Sprintf("R%d", register-arm64asm.X0)) {
+				next(i + 1)
+			}
+			continue
+		}
+		if bounds != nil && bounds.symbolic {
+			if destination, ok := arm64RawPoolSymbolicAlias(word, int(register-arm64asm.X0)); ok {
+				alias := arm64asm.X0 + arm64asm.Reg(destination)
+				queue = append(queue, arm64RawPoolFlow{i + 1, alias, arm64RawPoolRange{}})
+				if alias != register {
+					next(i + 1)
+				}
+				continue
+			}
+		}
+		if destination, derived, ok := arm64RawPoolAlias(word, i, int(register-arm64asm.X0), offset, bounds); ok {
+			alias := arm64asm.X0 + arm64asm.Reg(destination)
+			queue = append(queue, arm64RawPoolFlow{i + 1, alias, derived})
+			if alias != register {
+				next(i + 1) // Overwriting the original later does not kill its copy.
+			}
+			continue
+		}
+		if ins, ok := arm64RawPoolReplicateLoad(word); ok {
+			memory := ins.Args[0].Mem
+			name := Reg(fmt.Sprintf("R%d", register-arm64asm.X0))
+			if memory.Index == name {
+				return false
+			}
+			if memory.Base == name {
+				var proven bool
+				offset, proven = bounds.offsetAt(i, register, offset)
+				if !proven {
+					return false
+				}
+				spec := arm64SVEReplicateMemorySpecs[ins.Op]
+				bytes := spec.blockBytes
+				if bytes == 0 {
+					bytes = spec.memoryBits / 8
+				}
+				if bounds == nil || memory.Index != "" && memory.Index != ZR || memory.OffRaw != "" ||
+					!arm64RawPoolContains(offset.low+memory.Off, int64(bytes), bounds.size) ||
+					!arm64RawPoolContains(offset.high+memory.Off, int64(bytes), bounds.size) {
+					return false
+				}
+				loaded = true
+			}
+			next(i + 1)
+			continue
+		}
+		if form, ok := decodeARM64RawSVELoadStore(word); ok && form.base == int(register-arm64asm.X0) {
+			if !bounds.wholeScalableLoadInBounds(i, form) {
+				return false
+			}
+			loaded = true
+			next(i + 1)
+			continue
+		}
+		if row, ok := arm64RawPoolContiguousLoad(word); ok &&
+			(int(word>>5)&31 == int(register-arm64asm.X0) ||
+				row.address == arm64SVELoadRegister && int(word>>16)&31 == int(register-arm64asm.X0)) {
+			if !bounds.contiguousScalableLoadInBounds(i, word, row) {
+				return false
+			}
+			loaded = true
+			next(i + 1)
+			continue
+		}
+		// x/arch does not decode SVE. Consult validated typed grammars for
+		// vector-only effects and explicit unrelated scalar/memory operands.
+		// Unknown effects and any use of this address still fail below.
+		if arm64RawPoolSVEIgnoresAddress(word, int(register-arm64asm.X0)) {
+			next(i + 1)
+			continue
+		}
+		var code [4]byte
+		binary.LittleEndian.PutUint32(code[:], word)
+		decoded, err := arm64asm.Decode(code[:])
+		if err != nil {
+			return false
+		}
+		// A canonical return can kill a scratch address only when the caller
+		// supplied an explicit return contract. Calls and other indirect exits
+		// still expose live registers; RET through the address is never data.
+		if word == 0xd65f03c0 && returnClobbers&(1<<uint(register-arm64asm.X0)) != 0 {
+			continue
+		}
+		switch decoded.Op {
+		case arm64asm.BL, arm64asm.BLR, arm64asm.BR, arm64asm.RET, arm64asm.ERET, arm64asm.DRPS:
+			return false
+		}
+		// Restrict kill recognition to these unambiguous destination-first
+		// operations. Other encodings can read/write registers implicitly.
+		destinations := 0
+		switch decoded.Op.String() {
+		case "ADR", "MOV", "MOVZ", "MOVN", "AND", "ORR", "EOR":
+			destinations = 1
+		case "ADD", "ADDS", "ADC", "ADCS", "SUB", "SUBS", "SBC", "SBCS",
+			"NEG", "NEGS", "NGC", "NGCS":
+			destinations = 1
+		case "LSL", "LSR", "ASR", "ROR", "FMOV", "SMOV", "UMOV":
+			destinations = 1
+		case "LDR", "LDRB", "LDRH", "LDRSB", "LDRSH", "LDRSW",
+			"LDUR", "LDURB", "LDURH", "LDURSB", "LDURSH", "LDURSW",
+			"CSEL", "CSINC", "CSINV", "CSNEG":
+			destinations = 1
+		case "LDP", "LDNP", "LDPSW":
+			destinations = 2
+		}
+		kills := false
+		for n, arg := range decoded.Args {
+			if arg == nil {
+				break
+			}
+			switch arg := arg.(type) {
+			case arm64asm.PCRel:
+				switch decoded.Op {
+				case arm64asm.ADR:
+				case arm64asm.B, arm64asm.CBZ, arm64asm.CBNZ, arm64asm.TBZ, arm64asm.TBNZ:
+					if int64(arg)%4 != 0 {
+						return false
+					}
+					next(i + int(arg)/4)
+				default:
+					return false
+				}
+			case arm64asm.Reg:
+				if isAddress(arg) {
+					if n < destinations {
+						kills = true
+					} else {
+						return false
+					}
+				}
+			case arm64asm.RegSP:
+				if isAddress(arm64asm.Reg(arg)) {
+					if n < destinations {
+						kills = true
+					} else {
+						return false
+					}
+				}
+			case arm64asm.MemImmediate:
+				if arg.Mode == arm64asm.AddrPostReg {
+					// x/arch's arg_Xns_mem_post_Xm keeps Rm private, but its
+					// decoder defines it as bits 20:16. An unrelated post-index
+					// operand is harmless; using the address as Rm is not.
+					index := arm64asm.X0 + arm64asm.Reg(word>>16&31)
+					if isAddress(index) {
+						return false
+					}
+				}
+				if arm64asm.Reg(arg.Base) == register {
+					if !arm64RawPoolReadOnlyLoad(decoded.Op) {
+						return false
+					}
+					if arg.Mode != arm64asm.AddrOffset {
+						if _, _, valid := arm64PoolLoadWriteback(decoded, word); !valid || bounds == nil || !bounds.symbolic {
+							return false
+						}
+					}
+					var proven bool
+					offset, proven = bounds.offsetAt(i, register, offset)
+					if !proven {
+						return false
+					}
+					if bounds != nil && (!arm64RawPoolLoadInBounds(decoded, word, arg, offset.low, bounds.size) ||
+						!arm64RawPoolLoadInBounds(decoded, word, arg, offset.high, bounds.size)) {
+						return false
+					}
+					loaded = true
+				}
+			case arm64asm.MemExtend:
+				if isAddress(arg.Index) {
+					return false
+				}
+				if isAddress(arm64asm.Reg(arg.Base)) {
+					var proven bool
+					offset, proven = bounds.offsetAt(i, register, offset)
+					if !proven {
+						return false
+					}
+					if bounds == nil || !arm64RawPoolReadOnlyLoad(decoded.Op) ||
+						offset.low < 0 || !arm64RawPoolIndexedLoadInBounds(decoded, word, arg, i, offset.high, bounds) {
+						return false
+					}
+					loaded = true
+				}
+			case arm64asm.RegExtshiftAmount:
+				// x/arch keeps this typed operand's register field private, but
+				// prints the register before the comma separating its modifier.
+				name := strings.SplitN(arg.String(), ",", 2)[0]
+				if name == register.String() || name == wordRegister.String() {
+					return false
+				}
+			}
+		}
+		if kills {
+			continue
+		}
+		if word&0xfc000000 != 0x14000000 {
+			next(i + 1)
+		}
+	}
+	return loaded
+}
+
+// Do not infer memory effects from an LD prefix: exclusive loads retain an
+// address in the monitor and newer LD* atomics can also write memory.
+func arm64RawPoolReadOnlyLoad(op arm64asm.Op) bool {
+	switch op {
+	case arm64asm.LDR, arm64asm.LDRB, arm64asm.LDRH, arm64asm.LDRSB, arm64asm.LDRSH, arm64asm.LDRSW,
+		arm64asm.LDUR, arm64asm.LDURB, arm64asm.LDURH, arm64asm.LDURSB, arm64asm.LDURSH, arm64asm.LDURSW,
+		arm64asm.LDTR, arm64asm.LDTRB, arm64asm.LDTRH, arm64asm.LDTRSB, arm64asm.LDTRSH, arm64asm.LDTRSW,
+		arm64asm.LDAR, arm64asm.LDARB, arm64asm.LDARH,
+		arm64asm.LDP, arm64asm.LDNP, arm64asm.LDPSW,
+		arm64asm.LD1, arm64asm.LD2, arm64asm.LD3, arm64asm.LD4,
+		arm64asm.LD1R, arm64asm.LD2R, arm64asm.LD3R, arm64asm.LD4R:
+		return true
+	}
+	return false
+}
+
+func arm64RawPoolIndependentSVE(word uint32) bool {
+	if effects, ok := arm64RawSVEEffects(word); ok {
+		return effects.gpReads == 0 && effects.gpWrites == 0 && !effects.accesses
+	}
+	if form, ok := decodeARM64RawSVECnt(word); ok && form.vector {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEPTrue(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEEOR(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEAdd(word); ok {
+		return true
+	}
+	if _, _, ok := decodeARM64RawSVEAddSub(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEShift(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVESelect(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEDupElement(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEDupImmediate(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEPermute(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEFloat(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+		return true // Scalar result is a V register, not a GP destination.
+	}
+	return false
+}
+
+// These instruction families have no implicit GP operands or writeback.
+// Their memory may be mutable, but cannot contain the relocated pool address:
+// the proof rejects every earlier copy/escape of that address. Do not extend
+// this to exclusive/first-fault operations with hidden architectural state.
+func arm64RawPoolSVEIgnoresAddress(word uint32, address int) bool {
+	if effects, ok := arm64RawSVEEffects(word); ok {
+		return address < 0 || address < 32 && effects.gpReads&(1<<uint(address)) == 0
+	}
+	if arm64RawPoolIndependentSVE(word) {
+		return true
+	}
+	if ins, ok := decodeARM64RawSVECopy(word); ok && arm64SVECopyGeneralRegister(ins.Args[0]) {
+		// A GP/SP copy writes only a vector, but copying this pool address
+		// into that vector would expose a relocation-dependent numeric value.
+		return int(word>>5)&31 != address
+	}
+	if row, ok := arm64RawPoolContiguousLoad(word); ok {
+		return int(word>>5)&31 != address &&
+			(row.address != arm64SVELoadRegister || int(word>>16)&31 != address)
+	}
+	if form, ok := decodeARM64RawSVELoadStore(word); ok {
+		return form.base != address
+	}
+	if _, ok := decodeARM64RawSVEWhile(word); ok {
+		return int(word>>5&31) != address && int(word>>16&31) != address
+	}
+	if form, ok := decodeARM64RawSVEDupGeneral(word); ok {
+		return form.source != address
+	}
+	if form, ok := decodeARM64RawSVELDST1W(word); ok {
+		return form.base != address && (!form.registerOffset || form.index != address)
+	}
+	if form, ok := decodeARM64RawSVELDST1D(word); ok {
+		return form.base != address && (!form.registerOffset || form.index != address)
+	}
+	if ins, ok := decodeARM64RawSVEContiguousMemory(word); ok {
+		register := Reg(fmt.Sprintf("R%d", address))
+		for _, operand := range ins.Args {
+			if operand.Kind == OpMem {
+				return operand.Mem.Base != register && operand.Mem.Index != register
+			}
+		}
+	}
+	return false
+}
diff --git a/arm64_raw_unlabelled_pool_test.go b/arm64_raw_unlabelled_pool_test.go
new file mode 100644
index 000000000..c973c10d8
--- /dev/null
+++ b/arm64_raw_unlabelled_pool_test.go
@@ -0,0 +1,597 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64RawPoolControlFlowIR(t *testing.T, triple string) string {
+	words := assembleARM64LLVMWords(t, []string{
+		"adr x9, #52", "cbz x3, #32", "ldr w1, [x9]",
+		"add x4, x3, x3, lsl #2", "sub x3, x3, #1", "cbnz x3, #-12",
+		"mov x9, xzr", "str w1, [x0]", "ret",
+		"ldr w1, [x9, #4]", "mov x9, xzr", "str w1, [x0]", "ret",
+	}, "")
+	words = append(words, 0x11223344, 0xaabbccdd)
+	var source strings.Builder
+	source.WriteString("TEXT branchpool(SB),$0-16\nMOVD out+0(FP),R0\nMOVD count+8(FP),R3\n")
+	for _, word := range words {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"branchpool": {Name: "branchpool", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}}}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "private constant [8 x i8]") {
+		t.Fatal("missing proven data pool")
+	}
+	return ir
+}
+
+const arm64RawPoolControlFlowMain = `
+#include <stdint.h>
+extern void branchpool(uint32_t *, uint64_t);
+int main(void) {
+  for (unsigned count = 0; count < 5; count++) {
+    uint32_t got = 0;
+    branchpool(&got, count);
+    if (got != (count ? 0x11223344U : 0xaabbccddU)) return 1;
+  }
+  return 0;
+}
+`
+
+func TestARM64RawPoolControlFlowLLVM(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolControlFlowIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "branchpool.ll", "branchpool.o", ir)
+			native := runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" ||
+				runtime.GOOS == "linux" && triple == "aarch64-unknown-linux-gnu"
+			if runtime.GOARCH == "arm64" && native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "branchpool", triple, ir, arm64RawPoolControlFlowMain, nil)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolAddressAcrossControlFlow(t *testing.T) {
+	lines := []string{
+		"adr x9, #48", "cbz x3, #28",
+		"ldr w1, [x9]", "add x4, x4, x5, lsl #2", "sub x3, x3, #1", "cbnz x3, #-12",
+		"mov x9, xzr", "ret",
+		"ldr w1, [x9, #4]", "ldr w2, [x0, x4, lsl #2]", "mov x9, xzr", "ret",
+	}
+	for _, test := range []struct {
+		name, old, replacement string
+		want                   bool
+	}{
+		{name: "loop-and-diamond", want: true},
+		{"escape-one-edge", "mov x9, xzr", "str x9, [x0]", false},
+		{"shifted-address", "add x4, x4, x5, lsl #2", "add x4, x4, x9, lsl #2", false},
+		{"indexed-address", "ldr w2, [x0, x4, lsl #2]", "ldr w2, [x0, x9, lsl #2]", false},
+		{"call-with-live-address", "add x4, x4, x5, lsl #2", "blr x5", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			asm := strings.Join(lines, "\n")
+			if test.old != "" {
+				asm = strings.Replace(asm, test.old, test.replacement, 1)
+			}
+			words := assembleARM64LLVMWords(t, strings.Split(asm, "\n"), "")
+			var instructions []Instr
+			for _, word := range words {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			if got := arm64RawAddressOnlyLoaded(instructions, 0, len(instructions)); got != test.want {
+				t.Fatalf("load-only proof = %v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+const arm64RawUnlabelledPoolSource = `TEXT rawpool(SB),$0-8
+MOVD out+0(FP),R0
+WORD $0x10000109 // ADR X9, +32
+WORD $0x1000010a // ADR X10, +32
+WORD $0xb9400521 // LDR W1, [X9, #4]
+WORD $0xb85fc142 // LDUR W2, [X10, #-4]
+WORD $0x29000801 // STP W1, W2, [X0]
+WORD $0xaa1f03e9 // MOV X9, XZR
+WORD $0x9100800a // ADD X10, X0, #32 overwrites the pool pointer.
+WORD $0xd65f03c0 // RET
+WORD $0x11223344
+WORD $0xaabbccdd
+WORD $0x17b4a14d // Data that resembles a branch must not be decoded.
+RET
+`
+
+func TestARM64RawUnlabelledPoolBranchToSourceEpilogue(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, frame := range []string{"0", "32"} {
+		t.Run("frame_"+frame, func(t *testing.T) {
+			source := strings.Replace(arm64RawUnlabelledPoolSource, "$0-8", "$"+frame+"-8", 1)
+			source = strings.Replace(source, "WORD $0xd65f03c0 // RET", "WORD $0x14000004 // B +16 reaches the source RET, not the pool.", 1)
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+			} {
+				ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"rawpool": {Name: "rawpool", Args: []LLVMType{Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if strings.Count(ir, "private constant [12 x i8]") != 1 {
+					t.Fatal("a source-RET edge must preserve the single load-only data pool")
+				}
+				compileLLVMToObject(t, llc, triple, "pool-epilogue.ll", "pool-epilogue.o", ir)
+			}
+		})
+	}
+}
+
+func TestARM64RawUnlabelledPoolCannotInventSourceEpilogue(t *testing.T) {
+	for _, test := range []struct{ name, branch, suffix string }{
+		{"past-return", "WORD $0x14000005", "RET\n"},
+		{"into-data", "WORD $0x14000002", "RET\n"},
+		{"unknown-return", "WORD $0x14000004", "RET R9\n"},
+		{"no-return", "WORD $0x14000004", ""},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := strings.Replace(arm64RawUnlabelledPoolSource, "WORD $0xd65f03c0 // RET", test.branch, 1)
+			source = strings.TrimSuffix(source, "RET\n") + test.suffix
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"rawpool": {Name: "rawpool", Args: []LLVMType{Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}},
+			}})
+			if err == nil {
+				t.Fatal("a branch cannot fabricate an ordinary source epilogue or classify reachable code as data")
+			}
+		})
+	}
+}
+
+func TestARM64RawUnlabelledPoolAliases(t *testing.T) {
+	requireARM64GoAssemblerResult(t, arm64RawUnlabelledPoolSource, true)
+	file, err := Parse(ArchARM64, arm64RawUnlabelledPoolSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"rawpool": {Name: "rawpool", Args: []LLVMType{Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Count(ir, "private constant [12 x i8]") != 1 {
+				t.Fatalf("pool aliases must share one contiguous global:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "rawpool.ll", "rawpool.o", ir)
+			native := runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" ||
+				runtime.GOOS == "linux" && triple == "aarch64-unknown-linux-gnu"
+			if runtime.GOARCH == "arm64" && native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "rawpool", triple, ir, `
+#include <stdint.h>
+extern void rawpool(uint32_t *);
+int main(void) {
+  uint32_t result[2] = {0};
+  rawpool(result);
+  return result[0] != 0xaabbccdd || result[1] != 0x11223344;
+}
+`, nil)
+			}
+		})
+	}
+}
+
+func TestARM64RawUnlabelledPoolRejectsCodeAndEscapedAddresses(t *testing.T) {
+	for _, change := range [][2]string{
+		{"0x10000109", "0x14000008"}, // Executable branch into the apparent pool.
+		{"0xaa1f03e9", "0xf9000009"}, // Escape the address with STR X9, [X0].
+		{"0xd65f03c0", "0xd503201f"}, // Fall through into the words.
+	} {
+		source := strings.Replace(arm64RawUnlabelledPoolSource, change[0], change[1], 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, _, err = prepareARM64RawPCRelative(file.Funcs[0])
+		if err == nil {
+			t.Errorf("unsafe pool %v was accepted", change)
+		}
+	}
+}
+
+func arm64RawVoidPoolIR(t *testing.T, triple string) string {
+	t.Helper()
+	source := strings.ReplaceAll(arm64RawUnlabelledPoolSource, "rawpool", "voidpool")
+	source = strings.Replace(source, "0xaa1f03e9", "0xd503201f", 1)
+	source = strings.Replace(source, "0x9100800a", "0xd503201f", 1)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "voidpool", Args: []LLVMType{Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"voidpool": sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "private constant [12 x i8]") {
+		t.Fatal("missing proven data pool in a void function")
+	}
+	return ir
+}
+
+const arm64RawVoidPoolMain = `
+#include <stdint.h>
+extern void voidpool(uint32_t *);
+int main(void) {
+  uint32_t result[2] = {0};
+  voidpool(result);
+  return result[0] != 0xaabbccdd || result[1] != 0x11223344;
+}
+`
+
+func TestARM64RawPoolExplicitVoidSignature(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawVoidPoolIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "voidpool.ll", "voidpool.o", ir)
+			native := runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" ||
+				runtime.GOOS == "linux" && triple == "aarch64-unknown-linux-gnu"
+			if runtime.GOARCH == "arm64" && native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "voidpool", triple, ir, arm64RawVoidPoolMain, nil)
+			}
+		})
+	}
+}
+
+func TestARM64RawPoolVoidReturnDoesNotHideEscapes(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		ret    LLVMType
+		custom bool
+		frame  bool
+		old    string
+		word   string
+	}{
+		{name: "unknown-signature", ret: Void},
+		{name: "register-result", ret: I64, frame: true},
+		{name: "custom-register-ABI", ret: Void, custom: true, frame: true},
+		{name: "stored-address", ret: Void, frame: true, old: "0xd503201f", word: "0xf9000009"},
+		{name: "indirect-call", ret: Void, frame: true, old: "0xd503201f", word: "0xd63f00a0"},
+		{name: "return-through-address", ret: Void, frame: true, old: "0xd65f03c0", word: "0xd65f0120"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := strings.Replace(arm64RawUnlabelledPoolSource, "0xaa1f03e9", "0xd503201f", 1)
+			if test.old != "" {
+				source = strings.Replace(source, test.old, test.word, 1)
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := FuncSig{Name: "rawpool", Args: []LLVMType{Ptr}, Ret: test.ret}
+			if test.frame {
+				sig.Frame.Params = []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}
+			}
+			if test.custom {
+				sig.ArgRegs = []Reg{"R0"}
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: map[string]FuncSig{"rawpool": sig}}); err == nil {
+				t.Fatal("accepted an unproven or escaping pool address")
+			}
+		})
+	}
+	words := assembleARM64LLVMWords(t, []string{"adr x19, #12", "ldr x1, [x19]", "ret"}, "")
+	var instructions []Instr
+	for _, word := range words {
+		instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+	}
+	if arm64RawAddressOnlyLoadedWithExit(instructions, 0, len(instructions), (1<<18)-1) {
+		t.Fatal("callee-preserved register must not become a terminal scratch kill")
+	}
+}
+
+func TestARM64RawPoolLoadKillsAndPostIndexEffects(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		want        bool
+	}{
+		{"ldr x9, [x0]", true}, {"ldr w9, [x0]", true},
+		{"ldrb w9, [x0]", true}, {"ldrh w9, [x0]", true},
+		{"ldrsb x9, [x0]", true}, {"ldrsb w9, [x0]", true},
+		{"ldrsh x9, [x0]", true}, {"ldrsh w9, [x0]", true}, {"ldrsw x9, [x0]", true},
+		{"ldur x9, [x0]", true}, {"ldur w9, [x0]", true},
+		{"ldurb w9, [x0]", true}, {"ldurh w9, [x0]", true},
+		{"ldursb x9, [x0]", true}, {"ldursb w9, [x0]", true},
+		{"ldursh x9, [x0]", true}, {"ldursh w9, [x0]", true}, {"ldursw x9, [x0]", true},
+		{"csel x9, x0, x1, eq", true}, {"csinc x9, x0, x1, eq", true},
+		{"csinv x9, x0, x1, eq", true}, {"csneg x9, x0, x1, eq", true},
+		{"ldr x9, [x9]", true},
+		{"ld1 {v0.16b}, [x0], x1\nmov x9, xzr", true},
+		{"ld1 {v0.16b}, [x0], x9\nmov x9, xzr", false},
+		{"ld1 {v0.16b}, [x9], x0\nmov x9, xzr", false},
+		{"csel x9, x0, x9, eq", false}, {"csinc x9, x9, x1, eq", false},
+		{"str x9, [x0]\nmov x9, xzr", false},
+		{"ldp x9, x10, [x0]", true}, {"ldp x10, x9, [x0]", true},
+		{"ldp w9, w10, [x0]", true}, {"ldp w10, w9, [x0]", true},
+		{"ldnp x9, x10, [x0]", true}, {"ldnp x10, x9, [x0]", true},
+		{"ldnp w9, w10, [x0]", true}, {"ldnp w10, w9, [x0]", true},
+		{"ldpsw x9, x10, [x0]", true}, {"ldpsw x10, x9, [x0]", true},
+		{"ldp x9, x10, [x0, #16]!", true}, {"ldp x10, x9, [x0], #16", true},
+		{"ldp x9, x10, [x9]", true},
+		{"ldp x0, x1, [x9], #16", false},
+		{"ldp d9, d10, [x0]", false}, {"ldp q9, q10, [x0]", false},
+		{"stp x9, x10, [x0]\nmov x9, xzr", false},
+		{"stp x10, x9, [x0]\nmov x9, xzr", false},
+		{"ldxr x0, [x9]\nmov x9, xzr", false}, // The exclusive monitor would retain the address.
+		{"lsl x9, x0, #3", true}, {"lsl w9, w0, w1", true},
+		{"lsr w9, w0, #3", true}, {"lsr x9, x0, x1", true},
+		{"asr x9, x0, #3", true}, {"asr w9, w0, w1", true},
+		{"ror w9, w0, #3", true}, {"ror x9, x0, x1", true},
+		{"lsl x9, x9, #3", false}, {"lsr w9, w0, w9", false},
+		{"fmov w9, s0", true}, {"fmov x9, d0", true},
+		{"fmov d0, x9\nmov x9, xzr", false},
+		{"ptrue p15.b\nmov x9, xzr", true},
+		{"ptrue p0.h, vl4\nmov x9, xzr", true},
+		{"ptrue p7.s\nmov x9, xzr", true},
+		{"ptrue p8.d\nmov x9, xzr", true},
+		{"orr z31.d, z30.d, z29.d\nmov x9, xzr", true},
+		{"and z31.h, p7/m, z31.h, z30.h\nmov x9, xzr", true},
+		{"eor z31.s, z31.s, #1\nmov x9, xzr", true},
+		{"bic z31.d, z30.d, z29.d\nmov x9, xzr", true},
+		{"add z31.b, z30.b, z29.b\nmov x9, xzr", true},
+		{"add z31.h, p7/m, z31.h, z30.h\nmov x9, xzr", true},
+		{"add z31.s, z31.s, #12\nmov x9, xzr", true},
+		{"dup z31.d, x9\nmov x9, xzr", false},
+		{"ld1b { z31.b }, p0/z, [x9]\nmov x9, xzr", false}, // Not a proven scalar load effect.
+		{"add x9, x9, #0\nmov x9, xzr", true},
+		{"sub x9, x9, #0, lsl #12\nmov x9, xzr", true},
+		{"add w9, w9, #0\nmov x9, xzr", false},  // Truncates the address.
+		{"adds x9, x9, #0\nmov x9, xzr", false}, // Exposes address bits through flags.
+		{"add x9, x9, #40\nmov x9, xzr", false}, // Requires an offset/range proof.
+		{"sub x9, x9, #40\nmov x9, xzr", false},
+		{"index z31.s, #1, #1\nmov x9, xzr", true},
+		{"index z31.d, x9, #1\nmov x9, xzr", false},
+		{"index z31.d, #1, x9\nmov x9, xzr", false},
+		{"cmpne p3.s, p0/z, z17.s, #0\nmov x9, xzr", true},
+		{"cmpeq p15.d, p7/z, z31.d, z30.d\nmov x9, xzr", true},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			lines := []string{"adr x9, #64", "ldr w1, [x9]"}
+			lines = append(lines, strings.Split(test.instruction, "\n")...)
+			lines = append(lines, "ret")
+			var instructions []Instr
+			for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+				instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+			}
+			if got := arm64RawAddressOnlyLoaded(instructions, 0, len(instructions)); got != test.want {
+				t.Fatalf("load-only proof=%v, want %v", got, test.want)
+			}
+		})
+	}
+}
+
+func arm64RawPoolRegisterEffectsIR(t *testing.T, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, test := range []struct {
+		name    string
+		effects []string
+	}{
+		{"pool_pair_first", []string{"ptrue p15.b", "ldp x19, x20, [x1]"}},
+		{"pool_pair_second", []string{"ldp x20, x19, [x1]"}},
+		{"pool_shift", []string{"lsl x19, x1, #3"}},
+		{"pool_carry", []string{"adds x5, xzr, xzr", "adcs x19, x1, xzr"}},
+		{"pool_float", []string{"fmov d0, x1", "fmov x19, d0"}},
+		{"pool_umov", []string{"dup v0.4s, w2", "umov w19, v0.s[3]", "str w19, [x0, #4]"}},
+		{"pool_smov", []string{"movi v0.16b, #128", "smov x19, v0.b[15]", "str w19, [x0, #4]"}},
+		{"pool_sve", []string{
+			"mov x3, #1", "ptrue p0.s", "dup z0.s, w2",
+			"zip1 z0.s, z0.s, z0.s",
+			"compact z1.s, p0, z0.s", "cnt z1.s, p0/m, z1.s",
+			"addvl x5, x1, #2", "addpl x5, x5, #-8", "str z1, [x5]", "ldr z1, [x5]",
+			"movprfx z2, z1", "asrd z2.s, p0/m, z2.s, #1",
+			"dup z3.s, #1", "add z2.s, z2.s, z3.s",
+			"whilelo p1.s, xzr, x3", "ands p1.b, p0/z, p1.b, p1.b", "cntp x4, p0, p1.s",
+			"st1w {z2.s}, p1, [x0, x4, lsl #2]", "cntp x19, p0, p1.s",
+		}},
+	} {
+		// R19 is deliberately outside every terminal-clobber mask: these
+		// functions need an actual overwrite, not just a void return contract.
+		lines := []string{fmt.Sprintf("adr x19, #%d", (4+len(test.effects))*4), "ldr w2, [x19]", "str w2, [x0]"}
+		lines = append(lines, test.effects...)
+		lines = append(lines, "ret")
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVD out+0(FP),R0\nMOVD restore+8(FP),R1\n", test.name)
+		for _, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+			fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		}
+		source.WriteString("WORD $0x17b4a14d\nRET\n")
+		sigs[test.name] = FuncSig{Name: test.name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}}}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolRegisterEffectsLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolRegisterEffectsIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_effects.ll", "pool_effects.o", ir)
+		})
+	}
+}
+
+const arm64RawPoolRegisterEffectsMain = `
+#include <stdint.h>
+extern void pool_pair_first(uint32_t *, const uint64_t *);
+extern void pool_pair_second(uint32_t *, const uint64_t *);
+extern void pool_shift(uint32_t *, const uint64_t *);
+extern void pool_float(uint32_t *, const uint64_t *);
+extern void pool_sve(uint32_t *, const uint64_t *);
+extern void pool_carry(uint32_t *, const uint64_t *);
+extern void pool_umov(uint32_t *, const uint64_t *);
+extern void pool_smov(uint32_t *, const uint64_t *);
+int main(void) {
+  uint64_t restore[512] = {0x123456789abcdef0ULL, 0xfedcba9876543210ULL};
+  uint32_t result[13] = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2};
+  pool_pair_first(result + 1, restore);
+  pool_pair_second(result + 2, restore);
+  pool_shift(result + 3, restore);
+  pool_float(result + 4, restore);
+  pool_sve(result + 5, restore);
+  pool_carry(result + 7, restore);
+  pool_umov(result + 8, restore);
+  pool_smov(result + 10, restore);
+  for (unsigned i = 1; i < 6; i++) if (result[i] != 0x17b4a14d) return 1;
+  unsigned count = 0;
+  for (uint32_t value = 0x17b4a14d; value; value >>= 1) count += value & 1;
+  return result[0] != 1 || result[6] != count / 2 + 1 || result[7] != 0x17b4a14d ||
+         result[8] != 0x17b4a14d || result[9] != 0x17b4a14d ||
+         result[10] != 0x17b4a14d || result[11] != 0xffffff80 || result[12] != 2;
+}
+`
+
+func arm64RawPoolResultIR(t *testing.T, triple string) string {
+	t.Helper()
+	file, err := Parse(ArchARM64, `
+TEXT pool_result(SB),$0-16
+MOVD unused+0(FP), R1
+	WORD $0x10000089 // ADR X9, #16
+	WORD $0xf9400120 // LDR X0, [X9]
+	WORD $0x91000129 // ADD X9, X9, #0: still the same non-result pointer.
+WORD $0xd65f03c0 // RET: X0 is observable, X9 is not.
+WORD $0x17b4a14d
+WORD $0x11223344
+RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "pool_result", Args: []LLVMType{Ptr}, Ret: I64, Frame: FrameLayout{
+		Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+		Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+	}}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"pool_result": sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64RawPoolExplicitResultContract(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := arm64RawPoolResultIR(t, triple)
+			compileLLVMToObject(t, llc, triple, "pool_result.ll", "pool_result.o", ir)
+		})
+	}
+}
+
+func TestARM64RawPoolResultRegistersRemainObservable(t *testing.T) {
+	const scratch = (1 << 18) - 1
+	for _, test := range []struct {
+		name    string
+		ret     LLVMType
+		results []FrameSlot
+		want    uint32
+	}{
+		{"integer", I64, []FrameSlot{{Type: I64, Index: 0}}, scratch &^ 1},
+		{"pointer", Ptr, []FrameSlot{{Type: Ptr, Index: 0}}, scratch &^ 1},
+		{"float-frame-fallback", "double", []FrameSlot{{Type: "double", Index: 3}}, scratch &^ (1 << 3)},
+		{"aggregate", "{ i64, double, ptr }", []FrameSlot{{Type: I64, Index: 0}, {Type: "double", Index: 1}, {Type: Ptr, Index: 2}}, scratch &^ 7},
+		{"high-frame-fallback", I64, []FrameSlot{{Type: I64, Index: 9}}, scratch &^ (1 | 1<<9)},
+		{"missing-result-contract", I64, nil, 0},
+		{"unknown-result-type", "i128", []FrameSlot{{Type: "i128", Index: 0}}, 0},
+		{"inconsistent-void", Void, []FrameSlot{{Type: Ptr, Index: 0}}, 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			sig := FuncSig{Ret: test.ret, Args: []LLVMType{Ptr}, Frame: FrameLayout{
+				Params: []FrameSlot{{Type: Ptr, Index: 0, Field: -1}}, Results: test.results,
+			}}
+			mask := arm64RawPoolReturnClobbers(Func{ArgSize: 16}, sig)
+			if mask != test.want {
+				t.Fatalf("terminal-clobber mask=%#x, want %#x", mask, test.want)
+			}
+			for _, reg := range []int{0, 1, 2, 3, 9, 17, 19} {
+				lines := []string{fmt.Sprintf("adr x%d, #12", reg), fmt.Sprintf("ldr d0, [x%d]", reg), "ret"}
+				var instructions []Instr
+				for _, word := range assembleARM64LLVMWords(t, lines, "") {
+					instructions = append(instructions, Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+				}
+				if got := arm64RawAddressOnlyLoadedWithExit(instructions, 0, len(instructions), mask); got != (test.want&(1<<reg) != 0) {
+					t.Fatalf("incorrect pool proof for R%d result contract", reg)
+				}
+			}
+		})
+	}
+}
+
+const arm64RawPoolResultMain = `
+#include <stdint.h>
+extern uint64_t pool_result(void *);
+int main(void) {
+  return pool_result(0) != UINT64_C(0x1122334417b4a14d);
+}
+`
diff --git a/arm64_raw_unscaled_memory_test.go b/arm64_raw_unscaled_memory_test.go
new file mode 100644
index 000000000..d2e166802
--- /dev/null
+++ b/arm64_raw_unscaled_memory_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawUnscaledMemoryCompleteArchitecturalFamily(t *testing.T) {
+	forms := []struct {
+		word uint32
+		op   Op
+	}{
+		{0xb84bf1a1, "MOVWU"}, // LDUR W1, [X13,#191]
+		{0xf85c42c3, "MOVD"},  // LDUR X3, [X22,#-60]
+		{0x3850122e, "MOVBU"}, // LDURB W14, [X17,#-255]
+		{0x78480026, "MOVHU"}, // LDURH W6, [X1,#128]
+		{0x38cde3c3, "MOVBW"}, // LDURSB W3, [X30,#222]
+		{0x38896127, "MOVB"},  // LDURSB X7, [X9,#150]
+		{0x78db717c, "MOVHW"}, // LDURSH W28, [X11,#-73]
+		{0x789e101d, "MOVH"},  // LDURSH X29, [X0,#-31]
+		{0xb88480d4, "MOVW"},  // LDURSW X20, [X6,#72]
+		{0xb8022015, "MOVW"},  // STUR W21, [X0,#34]
+		{0xf8177239, "MOVD"},  // STUR X25, [X17,#-137]
+		{0x3801328f, "MOVB"},  // STURB W15, [X20,#19]
+		{0x781b02eb, "MOVH"},  // STURH W11, [X23,#-80]
+		{0x3c5df1b8, "FMOVB"}, // LDUR B24, [X13,#-33]
+		{0x7c5c6395, "FMOVH"}, // LDUR H21, [X28,#-58]
+		{0xbc46d027, "FMOVS"}, // LDUR S7, [X1,#109]
+		{0xfc4e6221, "FMOVD"}, // LDUR D1, [X17,#230]
+		{0x3cd8d26d, "FMOVQ"}, // LDUR Q13, [X19,#-115]
+		{0x3c0ab0a7, "FMOVB"}, // STUR B7, [X5,#171]
+		{0x7c10e340, "FMOVH"}, // STUR H0, [X26,#-242]
+		{0xbc1f9118, "FMOVS"}, // STUR S24, [X8,#-7]
+		{0xfc07c0fc, "FMOVD"}, // STUR D28, [X7,#124]
+		{0x3c8912db, "FMOVQ"}, // STUR Q27, [X22,#145]
+	}
+
+	var source strings.Builder
+	source.WriteString("TEXT rawUnscaledMemory(SB), $0-0\n")
+	for _, form := range forms {
+		ins := Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(form.word)}}, Raw: fmt.Sprintf("WORD $%#08x", form.word)}
+		decoded, err := decodeARM64RawWordInstruction(ins)
+		if err != nil {
+			t.Fatalf("decode %#08x: %v", form.word, err)
+		}
+		if decoded.Op != form.op {
+			t.Fatalf("decode %#08x op = %s, want %s (%q)", form.word, decoded.Op, form.op, decoded.Raw)
+		}
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", form.word)
+	}
+	source.WriteString("\tRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ll, err := Translate(file, Options{
+				TargetTriple: triple,
+				Goarch:       "arm64",
+				Sigs: map[string]FuncSig{
+					"rawUnscaledMemory": {Name: "rawUnscaledMemory", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{"load i8", "load i16", "load i32", "load i64", "load <16 x i8>", "store i8", "store i16", "store i32", "store i64", "store <16 x i8>"} {
+				if !strings.Contains(ll, want) {
+					t.Fatalf("unscaled memory lowering for %s omitted %q:\n%s", triple, want, ll)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, triple, "arm64-raw-unscaled-memory.ll", "arm64-raw-unscaled-memory.o", ll)
+		})
+	}
+}
diff --git a/arm64_raw_vector_effects_test.go b/arm64_raw_vector_effects_test.go
new file mode 100644
index 000000000..ecf25cdf7
--- /dev/null
+++ b/arm64_raw_vector_effects_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func arm64RawVectorFamilyOracleLines() []string {
+	return []string{
+		"aese v30.16b, v31.16b",
+		"sm4e v30.4s, v31.4s",
+		"sm3ss1 v30.4s, v31.4s, v29.4s, v28.4s",
+		"sqrdmlah v30.4s, v31.4s, v29.4s",
+		"addp d30, v31.2d",
+		"sdot v30.4s, v31.16b, v29.16b",
+		"smmla v30.4s, v31.16b, v29.16b",
+		"tbl v30.16b, {v31.16b}, v29.16b",
+		"sqrdmulh v30.4s, v31.4s, v29.4s",
+		"suqadd v30.4s, v31.4s",
+		"sqdmulh v30.4s, v31.4s, v29.4s",
+		"mul v30.4s, v31.4s, v29.4s",
+		"shadd v30.4s, v31.4s, v29.4s",
+		"cmgt v30.4s, v31.4s, v29.4s",
+		"mls v30.4s, v31.4s, v29.4s",
+		"saddlp v30.2d, v31.4s",
+		"umull v30.2d, v31.2s, v29.2s",
+		"addhn v30.2s, v31.2d, v29.2d",
+		"uzp1 v30.4s, v31.4s, v29.4s",
+		"sqshrn v30.2s, v31.2d, #32",
+		"sqshlu v30.2d, v31.2d, #63",
+		"ushll v30.2d, v31.2s, #31",
+		"umlal v30.2d, v31.2s, v29.2s",
+		"dup v30.2d, v31.d[1]",
+		"mla v30.4s, v31.4s, v29.4s",
+		"eor v30.16b, v31.16b, v29.16b",
+		"movi v30.4s, #255",
+		"eor3 v30.16b, v31.16b, v29.16b, v28.16b",
+	}
+}
+
+func TestARM64RawVectorDecodersHaveSharedEffectsAndLowering(t *testing.T) {
+	registry, err := parser.ParseFile(token.NewFileSet(), "arm64_raw_vector_families.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registered := make(map[string]bool)
+	ast.Inspect(registry, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) == 0 {
+			return true
+		}
+		decoder, ok := call.Args[0].(*ast.Ident)
+		if !ok || !strings.HasPrefix(decoder.Name, "decodeARM64Raw") {
+			return true
+		}
+		if registered[decoder.Name] {
+			t.Fatalf("duplicate vector family %s", decoder.Name)
+		}
+		registered[decoder.Name] = true
+		return true
+	})
+	// These are the complete existing register-only integer/crypto families
+	// migrated here. Memory, GP extraction, system and SME use separate effects.
+	files := []string{
+		"arm64_lower_word_uhadd.go",
+		"arm64_lower_integer_pairwise.go",
+		"arm64_lower_word_cmgt.go",
+		"arm64_lower_word_mla.go",
+		"arm64_lower_word_umull.go",
+		"arm64_lower_word_rdma.go",
+		"arm64_lower_word_logical.go",
+		"arm64_lower_word_sqshlu.go",
+		"arm64_lower_word_sqrdmulh.go",
+		"arm64_lower_saturating_shift_narrow.go",
+		"arm64_lower_word_mul.go",
+		"arm64_lower_word_mls.go",
+		"arm64_lower_word_mixed_saturating_add.go",
+		"arm64_lower_word_modified_immediate.go",
+		"arm64_lower_word_add_high_narrow.go",
+		"arm64_lower_word_table_lookup.go",
+		"arm64_lower_word_sha3.go",
+		"arm64_lower_word_uzp.go",
+		"arm64_lower_word_dup_element.go",
+		"arm64_lower_word_ushll.go",
+		"arm64_lower_word_uadalp.go",
+		"arm64_lower_word_sqdmulh.go",
+		"arm64_lower_word_sm4.go",
+		"arm64_lower_word_sm3.go",
+		"arm64_lower_word_dot_product.go",
+		"arm64_lower_aes.go",
+		"arm64_lower_word_umlal.go",
+		"arm64_lower_word_matrix_multiply.go",
+	}
+	for _, name := range files {
+		file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, decl := range file.Decls {
+			fn, ok := decl.(*ast.FuncDecl)
+			if !ok || !strings.HasPrefix(fn.Name.Name, "decodeARM64Raw") {
+				continue
+			}
+			if !registered[fn.Name.Name] {
+				t.Errorf("%s has no shared effects/lowering family", fn.Name.Name)
+			}
+			delete(registered, fn.Name.Name)
+		}
+	}
+	for name := range registered {
+		t.Errorf("%s was registered outside the reviewed vector-only families", name)
+	}
+}
+
+func TestARM64RawVectorFamiliesTranslateAndCompileLLVM22Targets(t *testing.T) {
+	words := assembleARM64LLVMWords(t, arm64RawVectorFamilyOracleLines(), "+aes,+sm4,+sha3,+dotprod,+i8mm,+rdm")
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for i, word := range words {
+		name := fmt.Sprintf("rawVectorFamily%d", i)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for r := 0; r < 32; r++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", r)
+		}
+		fmt.Fprintf(&source, "WORD $%#08x\nVST1 [V30.B16],(R1)\nRET\n", word)
+		sigs[name] = FuncSig{
+			Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-vector-families.ll", "raw-vector-families.o", ir)
+		})
+	}
+}
+
+func TestARM64RawVectorRegisterFamiliesPreserveGPAndSavedLink(t *testing.T) {
+	lines := arm64RawVectorFamilyOracleLines()
+	for index, word := range assembleARM64LLVMWords(t, lines, "+aes,+sm4,+sha3,+dotprod,+i8mm,+rdm") {
+		t.Run(lines[index], func(t *testing.T) {
+			if writes, known := arm64RawPoolGPWrites(word); !known || writes != 0 {
+				t.Errorf("register-only SIMD family has unknown GP effects: writes=%#x, known=%v", writes, known)
+			}
+			caller := arm64ControlFromMap(map[string]bool{"return:outer": true})
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R30": caller},
+				memory: map[string]arm64ControlValue{"sp:0": caller},
+			}
+			state.transfer(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}}, OpWORD, false, nil)
+			if arm64ControlHas(state.regs["R30"], "") || arm64ControlHas(state.memory["sp:0"], "") {
+				t.Error("vector register 30 must not clobber GP LR or memory")
+			}
+		})
+	}
+}
diff --git a/arm64_raw_vector_families.go b/arm64_raw_vector_families.go
new file mode 100644
index 000000000..f03c6ac2b
--- /dev/null
+++ b/arm64_raw_vector_families.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+// These existing Advanced SIMD integer and crypto decoders accept only scalar
+// FP/SIMD or vector registers. Their encoded register 30 is not GP R30, and
+// register 31 is an ordinary vector register rather than XZR/SP. Retain each
+// complete decoder's arrangement, lane and reserved-encoding validation.
+var arm64RawVectorFamilies = [...]arm64RawFamily{
+	arm64RawNoGPOrMemoryForm(decodeARM64RawAES, (*arm64Ctx).lowerRawAES),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSM4, (*arm64Ctx).lowerRawSM4),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSM3, (*arm64Ctx).lowerRawSM3),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawRDMA, (*arm64Ctx).lowerRawRDMA),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawScalarADDP, (*arm64Ctx).lowerRawScalarADDP),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawDotProduct, (*arm64Ctx).lowerRawDotProduct),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawMatrixMultiply, (*arm64Ctx).lowerRawMatrixMultiply),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawTableLookup, (*arm64Ctx).lowerRawTableLookup),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSQRDMULH, (*arm64Ctx).lowerRawSQRDMULH),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawMixedSaturatingAdd, (*arm64Ctx).lowerRawMixedSaturatingAdd),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSQDMULH, (*arm64Ctx).lowerRawSQDMULH),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawMUL, (*arm64Ctx).lowerRawMUL),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawHalvingAddSub, (*arm64Ctx).lowerRawHalvingAddSub),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawIntegerCompare, (*arm64Ctx).lowerRawIntegerCompare),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawMLS, (*arm64Ctx).lowerRawMLS),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawPairwiseAddLong, (*arm64Ctx).lowerRawPairwiseAddLong),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawUMULL, (*arm64Ctx).lowerRawUMULL),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawAddHighNarrow, (*arm64Ctx).lowerRawAddHighNarrow),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawUZP, (*arm64Ctx).lowerRawUZP),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSaturatingShiftNarrow, (*arm64Ctx).lowerRawSaturatingShiftNarrow),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSQSHLU, (*arm64Ctx).lowerRawSQSHLU),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawUSHLL, (*arm64Ctx).lowerRawUSHLL),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawUMLAL, (*arm64Ctx).lowerRawUMLAL),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawDUPElement, (*arm64Ctx).lowerRawDUPElement),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawMLA, (*arm64Ctx).lowerRawMLA),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawSHA3, (*arm64Ctx).lowerRawSHA3),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawLogical, (*arm64Ctx).lowerRawLogical),
+	arm64RawNoGPOrMemoryForm(decodeARM64RawModifiedImmediate, (*arm64Ctx).lowerRawModifiedImmediate),
+}
+
+func decodeARM64RawVectorFamily(word uint32) (arm64RawFamily, arm64RawContinuationEffects, bool) {
+	for _, family := range arm64RawVectorFamilies {
+		if effects, ok := family.effects(word); ok {
+			return family, effects, true
+		}
+	}
+	return arm64RawFamily{}, arm64RawContinuationEffects{}, false
+}
diff --git a/arm64_raw_word_preflight.go b/arm64_raw_word_preflight.go
new file mode 100644
index 000000000..957186975
--- /dev/null
+++ b/arm64_raw_word_preflight.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "fmt"
+
+// Native-target preflights must not disguise malformed WORDs as missing
+// target context. This is syntax-only: registered forms still require their
+// original source, machine-entry, continuation and layout proofs later.
+func arm64RawWordPreflightError(instruction Instr) error {
+	if instruction.Op != OpWORD {
+		return nil
+	}
+	word, err := arm64RawWordValue(instruction)
+	if err != nil {
+		return err
+	}
+	if arm64RawScalarConversion(word) {
+		return nil
+	}
+	if _, valid := arm64RawContinuationEffectsForWord(word); valid {
+		return nil
+	}
+	if _, valid := arm64RawSVEEffects(word); valid {
+		return nil
+	}
+	// The placeholder only lets the decoder check PC-relative syntax. It is
+	// never an edge or source-location witness consumed by translation.
+	_, err = decodeARM64RawWordInstructionTarget(instruction, "preflight")
+	return err
+}
+
+// Go's AWORD constant row is C_LCON, classified before case 14 truncates to
+// uint32. Wide MOV/bitmask constants can satisfy that row; arbitrary C_VCON
+// values cannot, even when their low word happens to encode a valid opcode.
+func arm64RawWordValue(instruction Instr) (uint32, error) {
+	for _, operand := range instruction.Args {
+		if err := unresolvedSymbolicImmediateError(operand); err != nil {
+			return 0, fmt.Errorf("arm64 WORD: %w", err)
+		}
+	}
+	if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+		instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+		return 0, fmt.Errorf("arm64 WORD expects exactly one resolved integer constant: %q", instruction.Raw)
+	}
+	value := instruction.Args[0].Imm
+	if !arm64GoLCON(value) {
+		return 0, fmt.Errorf("arm64 WORD constant does not satisfy Go's C_LCON operand class: %q", instruction.Raw)
+	}
+	return uint32(value), nil
+}
diff --git a/arm64_raw_word_source_class_test.go b/arm64_raw_word_source_class_test.go
new file mode 100644
index 000000000..0a3b5f4e3
--- /dev/null
+++ b/arm64_raw_word_source_class_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawWordRejectsVCONBeforeTruncation(t *testing.T) {
+	// All low words are real instructions. Reject the original Go constant
+	// class before a decoder can turn an invalid source into one of them.
+	for _, word := range []int64{0xd503201f, 0x1f0f7ce0, 0x14000000} {
+		for _, value := range []int64{word + (1 << 32), word - (1 << 33)} {
+			line := fmt.Sprintf("WORD $%d", value)
+			source := "TEXT comparison(SB),516,$0-0\n" + line + "\nRET\n"
+			goAssemblerOracleOutput(t, "arm64", source, "", false)
+			instruction := arm64ImmediateTestInstruction(t, line)
+			if err := arm64RawWordPreflightError(instruction); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("Go-rejected C_VCON became a native instruction: %s: %v", line, err)
+			}
+			if _, err := decodeARM64RawWordInstructionTarget(instruction, "target"); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("raw decoder truncated Go-rejected source: %s: %v", line, err)
+			}
+			if word == 0xd503201f {
+				context := &arm64Ctx{b: &strings.Builder{}}
+				if err := context.lowerRawWord(instruction); err == nil || context.b.Len() != 0 {
+					t.Errorf("raw lowering emitted a truncated native NOP: %s: %v", line, err)
+				}
+			}
+			for _, target := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+				for _, api := range []string{"text", "module", "Go", "public-module"} {
+					for _, dead := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%x/%s/%s/dead=%t", value, target, api, dead), func(t *testing.T) {
+							body := source
+							if dead {
+								body = "TEXT comparison(SB),516,$0-0\nRET\n" + line + "\n"
+							}
+							present, err := arm64FPControlTargetAPI(t, api, body, target)
+							if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("source constant class disappeared before translation: output=%t err=%v", present, err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RawWordWideLCONStillAccepted(t *testing.T) {
+	// Go's C_LCON row includes wide MOV/bitmask classes, not only int32 or
+	// uint32. These all emit low-word UDF encodings and require no CPU state.
+	for _, value := range []int64{0, 0xffff, 1 << 32, 0x1234 << 32, 0x1234 << 48, 0x0000ffff0000ffff} {
+		line := fmt.Sprintf("WORD $%d", value)
+		source := "TEXT comparison(SB),516,$0-0\n" + line + "\nRET\n"
+		goAssemblerOracleOutput(t, "arm64", source, "", true)
+		if err := arm64RawWordPreflightError(arm64ImmediateTestInstruction(t, line)); err != nil {
+			t.Fatalf("Go-accepted wide LCON rejected: %s: %v", line, err)
+		}
+		for _, api := range []string{"text", "module", "Go", "public-module"} {
+			present, err := arm64FPControlTargetAPI(t, api, source, "aarch64-unknown-linux-gnu")
+			if err != nil || !present {
+				t.Fatalf("%s lost Go-accepted wide source: %s: %v", api, line, err)
+			}
+		}
+	}
+}
+
+func TestARM64RawWordConstantClassesMatchGo(t *testing.T) {
+	accepted := []int64{0, 1, 0xfff, 0x123000, 0xfff000, 0xffffff, 0x11223344,
+		-0x7fffffff, 0xffffffff, 0x00ff00ff00ff00ff, 0x5555555555555555, 0x7fffffffffffffff, -1 << 63}
+	for _, shift := range []uint{0, 16, 32, 48} {
+		value := int64(uint64(0x1234) << shift)
+		accepted = append(accepted, value, ^value)
+	}
+	for _, group := range []struct {
+		accepted bool
+		values   []int64
+	}{
+		{true, accepted},
+		{false, []int64{0x1122334455667788, -0x1122334455667788, 0x1d503201f, -0x12afcdfe1}},
+	} {
+		for _, value := range group.values {
+			line := fmt.Sprintf("WORD $%d", value)
+			goAssemblerOracleOutput(t, "arm64", "TEXT original(SB),516,$0-0\n"+line+"\nRET\n", "", group.accepted)
+			word, err := arm64RawWordValue(arm64ImmediateTestInstruction(t, line))
+			if group.accepted {
+				if err != nil || word != uint32(value) {
+					t.Errorf("Go-accepted constant lost its exact low word: %s: %#x, %v", line, word, err)
+				}
+			} else if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("Go-rejected constant acquired a decoder word: %s: %#x, %v", line, word, err)
+			}
+		}
+	}
+}
+
+func TestARM64RawWordConstantEncoderRow(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "arm64", "asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Both actual compatibility SDKs retain the same constant class, encoder
+	// case, byte size and attributes. Only the extra NONE column differs.
+	row := regexp.MustCompile(`\{AWORD,\s*C_NONE,\s*C_NONE,\s*C_NONE,\s*C_LCON,\s*(?:C_NONE,\s*)?14,\s*4,\s*0,\s*0,\s*0\}`)
+	if matches := row.FindAll(data, -1); len(matches) != 1 {
+		t.Fatalf("actual Go WORD constant encoder row changed: matched %d", len(matches))
+	}
+}
+
+func TestARM64RawWordWideLCONObjects(t *testing.T) {
+	var source strings.Builder
+	signatures := make(map[string]FuncSig)
+	for index, value := range []int64{1 << 32, 0x1234 << 32, 0x1234 << 48, 0x0000ffff0000ffff} {
+		name := fmt.Sprintf("constant%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),516,$0-0\nWORD $%d\nRET\n", name, value)
+		signatures[name] = FuncSig{Name: name, Ret: Void}
+	}
+	goAssemblerOracleOutput(t, "arm64", source.String(), "", true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: signatures})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "word.ll", "word.o", ir)
+		})
+	}
+}
diff --git a/arm64_raw_zero_fixed_register_test.go b/arm64_raw_zero_fixed_register_test.go
new file mode 100644
index 000000000..2d05788a2
--- /dev/null
+++ b/arm64_raw_zero_fixed_register_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawZeroFrameTypedVoidPreservesFixedEntryRegisters(t *testing.T) {
+	words := assembleARM64LLVMWords(t, []string{"add x28,sp,#0", "add x18,sp,#0"}, "")
+	for index, reg := range []string{"g", "reserved_r18"} {
+		t.Run(reg, func(t *testing.T) {
+			source := arm64RawZeroFrameFixture(516, false, fmt.Sprintf("WORD $%#08x\nMOVD R4,(R1)\n", words[index]))
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := arm64RawZeroFrameSig()
+			transport := &arm64PrivateFrameTransport{entry: sig}
+			if arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], transport) {
+				t.Fatal("typed void consumed an unrestored fixed entry register")
+			}
+		})
+	}
+}
+
+func arm64RawZeroFixedFixture(t *testing.T, middle string) string {
+	t.Helper()
+	words := assembleARM64LLVMWords(t, []string{
+		"stp x28,x18,[sp,#-16]!", "add x28,sp,#0", "add x18,sp,#0", "ldp x28,x18,[sp],#16",
+	}, "")
+	body := fmt.Sprintf("WORD $%#08x\nWORD $%#08x\nWORD $%#08x\n%s\nWORD $%#08x\nMOVD RSP,R9\nMOVD R4,(R1)\n", words[0], words[1], words[2], middle, words[3])
+	return arm64RawZeroFrameFixture(516, false, body)
+}
+
+func TestARM64RawZeroFrameFixedRegisterSaveRestoreAndOverlap(t *testing.T) {
+	source := arm64RawZeroFixedFixture(t, "")
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	transport := &arm64PrivateFrameTransport{entry: sig}
+	if !arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], transport) {
+		t.Fatal("original raw STP/LDP did not restore exact g/OS entry state")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "fixed-entry.ll", "fixed-entry.o", ir)
+	}
+	// Restore must preserve the complete eight-byte identity, not just a
+	// pointer-shaped may-frame taint or the eventual SP/LR balance.
+	for _, middle := range []string{
+		"MOVB R4,0(RSP)", "MOVH R4,0(RSP)", "MOVW R4,0(RSP)", "MOVD R4,0(RSP)",
+		"MOVB R4,8(RSP)", "MOVH R4,8(RSP)", "MOVW R4,8(RSP)", "MOVD R4,8(RSP)",
+		"MOVB R4,16(RSP)", "MOVD R4,24(RSP)",
+		"MOVD 0(RSP),R9\nMOVD R9,(R1)",
+		"MOVD 8(RSP),R9\nMOVD R9,holder(SB)",
+		"MOVD (RSP)(R0),R9", "WORD $0xffffffff", "CALL foreign(SB)",
+		"CBZ R0,joined\nMOVB R4,0(RSP)\njoined:",
+	} {
+		t.Run(middle, func(t *testing.T) {
+			file, err := Parse(ArchARM64, arm64RawZeroFixedFixture(t, middle))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], transport) {
+				t.Fatal("partial/aliased/unknown save-cell write erased fixed entry identity")
+			}
+		})
+	}
+	for _, reg := range []string{"x18", "x28", "x29", "x30"} {
+		word := assembleARM64LLVMWords(t, []string{"mov " + reg + ",#0"}, "")[0]
+		broken := strings.Replace(source, "WORD $0xd65f03c0", fmt.Sprintf("WORD $%#08x\nWORD $0xd65f03c0", word), 1)
+		requireARM64GoAssemblerResult(t, broken, true)
+		file, err := Parse(ArchARM64, broken)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], transport) {
+			t.Fatalf("constant non-address overwrite lost preserved %s", reg)
+		}
+	}
+}
diff --git a/arm64_raw_zero_frame.go b/arm64_raw_zero_frame.go
new file mode 100644
index 000000000..2572cedb8
--- /dev/null
+++ b/arm64_raw_zero_frame.go
@@ -0,0 +1,379 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Raw leaf/C bodies can own an explicit stack allocation without a Go
+// prologue. This is a separate whole-source proof: it does not invent a Go
+// frame, turn arbitrary native calls into helpers, or weaken caller LR checks.
+// Every local raw BL is interpreted in its bounded call context; every root
+// return restores the entry SP, LR and BP. Incoming pointers cannot alias the
+// fresh LLVM stack object unless an address escapes this checked source.
+type arm64RawZeroState struct {
+	addresses *arm64RawPrivateFrameState
+	control   *arm64ControlState
+}
+
+// Go 1.27 abi-internal.md's ARM64 special-purpose table also applies to ABI0:
+// R18 is OS-reserved; R28 carries g; R29 is BP. Their return meaning is Same,
+// unlike ordinary scratch or the closure-context register R26. Raw WORD can
+// touch registers excluded by Go's textual parser, so track their full entry
+// identity independently of void-result transport and may-frame addresses.
+var arm64RawZeroFixedEntry = [...]struct {
+	reg   Reg
+	token string
+}{
+	{reg: "R18", token: "entry-os18:"},
+	{reg: "R28", token: "entry-g:"},
+	{reg: "R29", token: "entry-bp:"},
+}
+
+func (s *arm64RawZeroState) clone() *arm64RawZeroState {
+	return &arm64RawZeroState{addresses: s.addresses.clone(), control: s.control.clone()}
+}
+
+func (s *arm64RawZeroState) merge(other *arm64RawZeroState) (bool, bool) {
+	if s.addresses.sp != other.addresses.sp {
+		return false, false
+	}
+	changed := s.addresses.regs.merge(other.addresses.regs)
+	spills := make(map[int64]arm64PrivateFrameAddress)
+	for offset, value := range s.addresses.spills {
+		if incoming, present := other.addresses.spills[offset]; !present || incoming != value {
+			value = arm64PrivateFrameAddress{}
+		}
+		spills[offset] = value
+	}
+	for offset := range other.addresses.spills {
+		if _, present := spills[offset]; !present {
+			spills[offset] = arm64PrivateFrameAddress{}
+		}
+	}
+	if !reflect.DeepEqual(spills, s.addresses.spills) {
+		s.addresses.spills, changed = spills, true
+	}
+	return s.control.merge(other.control) || changed, true
+}
+
+type arm64RawZeroCall struct {
+	block int
+	sp    int64
+}
+
+type arm64RawZeroPoint struct {
+	block   int
+	context string
+}
+
+func arm64RawZeroFrameUnexposed(fn Func) bool {
+	return arm64RawZeroFrameUnexposedForTransport(fn, nil)
+}
+
+// Only a complete ordinary ABI0 void declaration establishes that temporary
+// virtual GP values are dead at the root return. This is not permission to
+// expose them before returning, or to consume an unknown native register ABI.
+func arm64RawZeroVoidTransport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	if transport == nil || fn.arm64PrivateRegisterEntry || strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return false
+	}
+	sig := transport.entry
+	if sig.Ret != Void || len(sig.Frame.Results) != 0 || len(sig.ArgRegs) != 0 ||
+		sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.ARMEntry != nil ||
+		sig.WASMContext != "" || sig.WASMNative || len(sig.Frame.Params) != len(sig.Args) ||
+		fn.ArgSize != int64(len(sig.Args))*8 {
+		return false
+	}
+	for index, typ := range sig.Args {
+		slot := sig.Frame.Params[index]
+		if (typ != Ptr && typ != I64) || slot.Type != typ || slot.Offset != int64(index)*8 ||
+			slot.Index != index || slot.Field != -1 || len(slot.Fields) != 0 {
+			return false
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpTEXT {
+			continue
+		}
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) == 3 {
+			expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+				if value, ok := goTextFlagValues[name]; ok {
+					return value
+				}
+				return name
+			})
+			flags, known := parseImmExpr(expression)
+			if !known || flags&64 != 0 { // NEEDCTXT is hidden transport.
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func arm64RawZeroFrameUnexposedForTransport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	return arm64RawZeroFrameProof(fn, transport, nil)
+}
+
+func arm64RawZeroFrameProof(fn Func, transport *arm64PrivateFrameTransport, control *arm64LocalControlPlan) bool {
+	if fn.FrameSize != 0 || arm64SourceGoFrame(fn).present || !arm64SourceFrameFlagsKnown(fn) ||
+		(!arm64HasRawFrameCode(fn) && !arm64SourceUsesR20(fn)) {
+		return false
+	}
+	text := 0
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpTEXT {
+			text++
+		}
+	}
+	if text != 1 {
+		return false
+	}
+	voidTransport := arm64RawZeroVoidTransport(fn, transport)
+	// The exact raw PC boundary checker supplies only same-source labels.
+	// Run it on the original too: later normalization cannot erase an escape.
+	normalized, blobs, err := prepareARM64RawPCRelative(fn)
+	if err != nil || len(blobs) != 0 {
+		return false
+	}
+	if control != nil && !reflect.DeepEqual(fn.Instrs, normalized.Instrs) {
+		return false // A plan cannot describe an earlier or differently normalized CFG.
+	}
+	blocks := arm64SplitBlocks(normalized)
+	indices := make(map[string]int, len(blocks))
+	for index, block := range blocks {
+		indices[block.name] = index
+	}
+	entryLabel := "__entry_lr"
+	for {
+		if _, exists := indices[entryLabel]; !exists {
+			break
+		}
+		entryLabel += "_"
+	}
+	entryLink := "label:" + entryLabel
+	before := make(map[arm64RawZeroPoint]*arm64RawZeroState)
+	contexts := map[string][]arm64RawZeroCall{"": nil}
+	visited := make([]bool, len(blocks))
+	queue := make([]arm64RawZeroPoint, 0, len(blocks))
+	queued := make(map[arm64RawZeroPoint]bool)
+	propagate := func(point arm64RawZeroPoint, state *arm64RawZeroState) bool {
+		if point.block < 0 || point.block >= len(blocks) || len(before) >= 16384 {
+			return false
+		}
+		changed := false
+		if old := before[point]; old == nil {
+			before[point], changed = state.clone(), true
+		} else {
+			var valid bool
+			changed, valid = old.merge(state)
+			if !valid {
+				return false
+			}
+		}
+		if changed && !queued[point] {
+			queue, queued[point] = append(queue, point), true
+		}
+		return true
+	}
+	operations := 0
+	for seed := range blocks {
+		if visited[seed] {
+			continue
+		}
+		entry := &arm64RawZeroState{
+			addresses: &arm64RawPrivateFrameState{
+				regs:   arm64PrivateFrameAddresses{"R18": {}, "R28": {}, "R29": {}},
+				spills: make(map[int64]arm64PrivateFrameAddress),
+			},
+			control: &arm64ControlState{
+				regs: map[Reg]arm64ControlValue{
+					SP:    arm64ControlFromMap(map[string]bool{"sp:0": true}),
+					"R30": arm64ControlFromMap(map[string]bool{entryLink: true}),
+				},
+				memory: make(map[string]arm64ControlValue), unexposedSP: true,
+			},
+		}
+		if arm64SourceUsesR20(fn) {
+			entry.addresses.regs["R20"] = arm64PrivateFrameAddress{}
+		}
+		for _, fixed := range arm64RawZeroFixedEntry {
+			entry.control.regs[fixed.reg] = arm64ControlFromMap(map[string]bool{fixed.token: true})
+		}
+		if !propagate(arm64RawZeroPoint{block: seed}, entry) {
+			return false
+		}
+		for next := 0; next < len(queue); next++ {
+			point := queue[next]
+			queued[point] = false
+			visited[point.block] = true
+			if control != nil && seed == 0 {
+				control.reachable[point.block] = true
+			}
+			state := before[point].clone()
+			calls := contexts[point.context]
+			terminated := false
+			for instructionIndex, original := range blocks[point.block].instrs {
+				operations++
+				if operations > 1<<24 {
+					return false
+				}
+				ins := arm64ControlDecode(original)
+				op := arm64ControlOp(ins)
+				if arm64RawZeroReturn(original) {
+					link := arm64ControlRead(state.control.regs, "R30")
+					if len(calls) == 0 {
+						if state.addresses.sp != 0 || arm64ControlCount(link) != 1 || !arm64ControlHas(link, entryLink) {
+							return false
+						}
+						for _, fixed := range arm64RawZeroFixedEntry {
+							value := arm64ControlRead(state.control.regs, fixed.reg)
+							if arm64ControlCount(value) != 1 || !arm64ControlHas(value, fixed.token) {
+								return false
+							}
+							delete(state.addresses.regs, fixed.reg)
+						}
+						if len(state.addresses.regs) != 0 && !voidTransport {
+							return false
+						}
+					} else {
+						caller := calls[len(calls)-1]
+						label := "label:" + blocks[caller.block].name
+						if state.addresses.sp != caller.sp || arm64ControlCount(link) != 1 || !arm64ControlHas(link, label) {
+							return false
+						}
+						parent := point.context[:strings.LastIndex(point.context, "/")]
+						if !propagate(arm64RawZeroPoint{block: caller.block, context: parent}, state) {
+							return false
+						}
+					}
+					if control != nil && seed == 0 {
+						control.recordRawZeroReturn(point.block, instructionIndex, state.control, entryLink)
+					}
+					terminated = true
+					break
+				}
+				if op == "BL" || op == "CALL" || op == "BLR" {
+					if !original.arm64RawLocalCall || len(ins.Args) != 1 || len(calls) >= 16 || point.block+1 >= len(blocks) {
+						return false
+					}
+					name, local := arm64BranchTarget(ins.Args[0])
+					target, exists := indices[name]
+					if !local || !exists || !arm64IsLocalBranchLink(ins) {
+						return false
+					}
+					if target == point.block && arm64RawZeroSelfBLSink(blocks[point.block]) {
+						// Exact same-PC raw BL writes LR and branches to itself
+						// forever. There is no return edge or continuation proof.
+						// Every prefix effect/join was checked before reaching it.
+						if point.block+2 == len(blocks) && len(blocks[point.block+1].instrs) == 0 &&
+							len(normalized.Instrs) != 0 && normalized.Instrs[len(normalized.Instrs)-1].arm64RawLocalCall {
+							// SplitBlocks creates an empty PC+4 continuation when
+							// the final source instruction is a call. This sink
+							// cannot reach it, and it contains no source to check.
+							visited[point.block+1] = true
+						}
+						terminated = true
+						break
+					}
+					context := point.context + "/" + strconv.Itoa(point.block+1)
+					contexts[context] = append(append([]arm64RawZeroCall(nil), calls...), arm64RawZeroCall{block: point.block + 1, sp: state.addresses.sp})
+					state.control.regs["R30"] = arm64ControlFromMap(map[string]bool{"label:" + blocks[point.block+1].name: true})
+					if !propagate(arm64RawZeroPoint{block: target, context: context}, state) {
+						return false
+					}
+					terminated = true
+					break
+				}
+				if op == "B" || op == "JMP" || arm64IsConditionalBranch(op) {
+					if len(ins.Args) == 0 {
+						return false
+					}
+					name, local := arm64BranchTarget(ins.Args[len(ins.Args)-1])
+					target, exists := indices[name]
+					if !local || !exists || !propagate(arm64RawZeroPoint{block: target, context: point.context}, state) {
+						return false
+					}
+					if arm64IsConditionalBranch(op) && !propagate(arm64RawZeroPoint{block: point.block + 1, context: point.context}, state) {
+						return false
+					}
+					terminated = true
+					break
+				}
+				if op == "ADR" || op == "ADRP" || op == OpRET || op == arm64RawDataOp || !state.transfer(original, ins) {
+					return false
+				}
+			}
+			if !terminated && !propagate(arm64RawZeroPoint{block: point.block + 1, context: point.context}, state) {
+				return false
+			}
+		}
+		queue = queue[:0]
+	}
+	return true
+}
+
+// Only the decoder's exact raw-PC boundary witness may identify this sink.
+// A block containing any additional effect remains an ordinary bounded call.
+func arm64RawZeroSelfBLSink(block arm64Block) bool {
+	if len(block.instrs) != 1 {
+		return false
+	}
+	ins := block.instrs[0]
+	return (ins.Op == "BL" || ins.Op == "CALL") && ins.arm64RawLocalCall && len(ins.Args) == 1 &&
+		ins.Args[0].Kind == OpIdent && ins.Args[0].Ident == block.name
+}
+
+func arm64RawZeroReturn(original Instr) bool {
+	if original.Op == OpWORD {
+		decoded, err := decodeARM64RawWordInstruction(original)
+		return err == nil && arm64RawPrivateSourceRET(decoded)
+	}
+	return arm64RawPrivateSourceRET(original)
+}
+
+func (s *arm64RawZeroState) transfer(original, ins Instr) bool {
+	if ins.Op == "NOP" && len(ins.Args) == 0 && (original.Op != OpWORD ||
+		len(original.Args) == 1 && original.Args[0].Kind == OpImm && original.Args[0].ImmRaw == "" && original.Args[0].Imm == 0xd503201f) {
+		return true // Exact architectural NOP, not the wider system/hint class.
+	}
+	if form, handled, err := parseARM64StructureMemory(original); handled {
+		if err != nil {
+			return false
+		}
+		if address, private := s.addresses.address(form.memory.Mem.Base); private {
+			if !address.exact || address.offset < s.addresses.sp || address.offset > -form.width() {
+				return false // No implicit Go cell exists in a zero-source frame.
+			}
+		}
+	}
+	if form, known := arm64RawPrivateMemory(ins); known && form.memory.Kind == OpMem {
+		mem := form.memory.Mem
+		if address, private := s.addresses.address(mem.Base); private {
+			offset := mem.Off
+			if form.post {
+				offset = 0
+			}
+			address, valid := arm64PrivateFrameOffset(address, offset)
+			low := s.addresses.sp
+			if form.pre && arm64StackReg(mem.Base) {
+				low = address.offset
+			}
+			width := form.elementBytes * int64(len(form.registers))
+			if !valid || !address.exact || mem.Index != "" || mem.OffRaw != "" || address.offset < low || address.offset > -width {
+				return false // No implicit Go cell or unallocated red zone exists.
+			}
+		}
+	}
+	if !s.addresses.transfer(original, ins, -8) {
+		return false
+	}
+	if !s.control.transferStructureMemory(original) {
+		s.control.transfer(ins, arm64ControlOp(ins), strings.HasSuffix(string(ins.Op), ".P"), nil)
+	}
+	return true
+}
diff --git a/arm64_raw_zero_frame_family_test.go b/arm64_raw_zero_frame_family_test.go
new file mode 100644
index 000000000..0bec40d87
--- /dev/null
+++ b/arm64_raw_zero_frame_family_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Reuse the independently MC-encoded complete scalar/GP-pair/FP-pair matrix.
+// Unlike the framed-leaf family this source receives no Go prologue, owns only
+// its explicit negative-SP envelope, and also exercises local raw BL returns.
+func arm64RawZeroFrameFamilyFixture(t *testing.T) (*File, map[string]FuncSig, string, []arm64RawPrivateMemoryCase) {
+	t.Helper()
+	base := arm64RawPrivateMemoryCases()
+	var native []string
+	for _, tc := range base {
+		native = append(native, tc.store, tc.load)
+	}
+	words := assembleARM64LLVMWords(t, native, "")
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	var cases []arm64RawPrivateMemoryCase
+	for index, original := range base {
+		for _, call := range []bool{false, true} {
+			tc := original
+			tc.name = "zero_" + tc.name
+			if call {
+				tc.name += "_local_call"
+			}
+			prep := "MOVD (R0),R4\nMOVD 8(R0),R5\n"
+			outputs := "MOVD R9,(R1)\n"
+			if tc.count == 2 {
+				outputs += "MOVD R10,8(R1)\n"
+			}
+			if tc.floating {
+				prep = "FMOVQ (R0),F0\nFMOVQ 16(R0),F1\n"
+				op := map[int]string{4: "FMOVS", 8: "FMOVD", 16: "FMOVQ"}[tc.width]
+				outputs = op + " F2,(R1)\n"
+				if tc.count == 2 {
+					outputs += fmt.Sprintf("%s F3,%d(R1)\n", op, tc.width)
+				}
+			}
+			body := "WORD $0xd10183ff\n" + prep +
+				fmt.Sprintf("WORD $%#08x\nWORD $%#08x\n", words[2*index], words[2*index+1]) +
+				outputs + "WORD $0x910183ff\n"
+			flags := 4
+			if index&1 != 0 {
+				flags = 516
+			}
+			fixture := strings.Replace(arm64RawZeroFrameFixture(flags, call, body), "rawZero", tc.name, 1)
+			source.WriteString(fixture)
+			sig := arm64RawZeroFrameSig()
+			sig.Name = tc.name
+			sigs[tc.name] = sig
+			cases = append(cases, tc)
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		if !arm64RawZeroFrameUnexposed(fn) {
+			t.Fatalf("complete private envelope rejected %s", fn.Sym)
+		}
+	}
+	return file, sigs, source.String(), cases
+}
+
+func TestARM64RawZeroFrameMemoryFamilyObjects(t *testing.T) {
+	file, sigs, _, cases := arm64RawZeroFrameFamilyFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-zero-family.ll", "raw-zero-family.o", ir)
+		})
+	}
+	t.Logf("actual Go + LLVM22 objects: %d typed scalar/GP-pair/FP-pair offset/writeback/raw-local-call variants", len(cases))
+}
+
+func TestARM64RawZeroFrameGoMemorySpellings(t *testing.T) {
+	// asm7 AMOVB/H/W aliases, AMOVD, floating S/D/Q and all typed pair
+	// widths share this ownership proof, not a guessed raw write mask.
+	for _, pair := range []struct{ store, load string }{
+		{"MOVB R4", "MOVB"}, {"MOVBU R4", "MOVBU"},
+		{"MOVH R4", "MOVH"}, {"MOVHU R4", "MOVHU"},
+		{"MOVW R4", "MOVW"}, {"MOVWU R4", "MOVWU"}, {"MOVD R4", "MOVD"},
+		{"FMOVS F0", "FMOVS"}, {"FMOVD F0", "FMOVD"}, {"FMOVQ F0", "FMOVQ"},
+		{"STP (R4,R5)", "LDP"}, {"STPW (R4,R5)", "LDPW"}, {"STPW (R4,R5)", "LDPSW"},
+		{"FSTPS (F0,F1)", "FLDPS"}, {"FSTPD (F0,F1)", "FLDPD"}, {"FSTPQ (F0,F1)", "FLDPQ"},
+	} {
+		for _, mode := range []string{"offset", "pre_post", "post_pre"} {
+			t.Run(pair.store+"/"+pair.load+"/"+mode, func(t *testing.T) {
+				storeOp, values, _ := strings.Cut(pair.store, " ")
+				destination := "R9"
+				if strings.HasPrefix(pair.load, "F") {
+					destination = "F2"
+				}
+				if strings.Contains(values, ",") {
+					destination = "(R9,R10)"
+					if strings.HasPrefix(pair.load, "F") {
+						destination = "(F2,F3)"
+					}
+				}
+				store := fmt.Sprintf("%s %s,16(RSP)", storeOp, values)
+				load := fmt.Sprintf("%s 16(RSP),%s", pair.load, destination)
+				if mode == "pre_post" {
+					store = fmt.Sprintf("%s.W %s,-32(RSP)", storeOp, values)
+					load = fmt.Sprintf("%s.P 32(RSP),%s", pair.load, destination)
+				} else if mode == "post_pre" {
+					store = fmt.Sprintf("%s.P %s,32(RSP)", storeOp, values)
+					load = fmt.Sprintf("%s.W -32(RSP),%s", pair.load, destination)
+				}
+				body := "SUB $96,RSP\n" + store + "\n" + load + "\nMOVD R4,(R1)\nADD $96,RSP\n"
+				source := arm64RawZeroFrameFixture(516, false, body)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !arm64RawZeroFrameUnexposed(file.Funcs[0]) {
+					t.Fatal("Go-accepted complete memory spelling lost ownership")
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_raw_zero_frame_runtime_test.go b/arm64_raw_zero_frame_runtime_test.go
new file mode 100644
index 000000000..33f1d7534
--- /dev/null
+++ b/arm64_raw_zero_frame_runtime_test.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64RawZeroFrameFamily(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	file, sigs, source, cases := arm64RawZeroFrameFamilyFixture(t)
+	var goDeclarations, goChecks, cDeclarations, cChecks strings.Builder
+	for _, tc := range cases {
+		fmt.Fprintf(&goDeclarations, "func %s(*byte,*byte)\n", tc.name)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const unsigned char *,unsigned char *);\n", tc.name)
+		floating := 0
+		if tc.floating {
+			floating = 1
+		}
+		fmt.Fprintf(&goChecks, "check(%s,%d,%d,%d,%d)\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+		fmt.Fprintf(&cChecks, "if(check(%s,%d,%d,%d,%d)) return 1;\n", tc.name, tc.width, tc.count, tc.signBits, floating)
+	}
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod":         "module rawzeroframeoracle\n\ngo 1.20\n",
+		"main.go":        arm64RawPrivateFrameOracleGo + goDeclarations.String() + "func main(){\n" + goChecks.String() + "}\n",
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT zero_", "TEXT ·zero_"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "main", "-o", filepath.Join(dir, "oracle.o"), filepath.Join(dir, "oracle_arm64.s"))
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	listing, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil {
+		t.Fatalf("actual Go zero/raw leaf object: %v\n%s", err, listing)
+	}
+	if !strings.Contains(string(listing), "LEAF|NOFRAME, $0-16") || strings.Contains(string(listing), "MOVD.W\tR30,") {
+		t.Fatal("actual Go unexpectedly provided a framed LR prologue to a raw local BL")
+	}
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd = exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go raw zero-frame LR/SP/BP caller oracle: %v\n%s", err, output)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := arm64RawPrivateFrameOracleC + cDeclarations.String() + "int main(void){\n" + cChecks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "raw_zero_frame_family", triple, ir, cMain, runner)
+	t.Logf("actual Go raw WORD and LLVM22/independent C: %d variants x 256 patterns x 5 unaligned offsets; full input/output canaries and real LR-returning callers", len(cases))
+}
+
+func arm64RawZeroRepeatedNumericSource(t *testing.T) string {
+	t.Helper()
+	// Use ordinary callee-saved temporaries for an executed Go fixture.
+	// Temporarily pointing g/OS18 at SP is not safe for asynchronous observers,
+	// even when the separate source/object proof verifies their restoration.
+	words := assembleARM64LLVMWords(t, []string{
+		"add x4,x4,x2", "eor x4,x4,x5", "stp x22,x23,[sp,#-16]!",
+		"add x22,sp,#0", "add x23,sp,#0", "ldp x22,x23,[sp],#16",
+	}, "")
+	return fmt.Sprintf(`TEXT rawZeroNumeric(SB),516,$0-24
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+MOVD salt+16(FP),R2
+WORD $0xa9bf7bfd
+WORD $%#08x
+WORD $%#08x
+WORD $%#08x
+MOVD (R0),R4
+MOVD $17,R5
+WORD $0x94000007
+WORD $0x94000006
+MOVD R4,(R1)
+MOVD RSP,R9
+WORD $%#08x
+WORD $0xa8c17bfd
+WORD $0xd65f03c0
+WORD $%#08x
+WORD $%#08x
+WORD $0xd65f03c0
+`, words[2], words[3], words[4], words[5], words[0], words[1])
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawZeroFrameRepeatedNumericHelper(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := arm64RawZeroRepeatedNumericSource(t)
+	if err := arm64RawZeroRuntimeRegisterSafety(source); err != nil {
+		t.Fatal(err)
+	}
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := arm64RawZeroFrameSig()
+	sig.Name, sig.Args = "rawZeroNumeric", []LLVMType{Ptr, Ptr, I64}
+	sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: 16, Type: I64, Index: 2, Field: -1})
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{sig.Name: sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	const goOracle = `package main
+
+import "encoding/binary"
+
+func rawZeroNumeric(*byte, *byte, uint64)
+func readGoG() uintptr
+func main() {
+	var input, output, want [96]byte
+	seed := uint64(0x0123456789abcdef)
+	for trial := 0; trial < 256; trial++ {
+		for _, off := range []int{0, 1, 3, 7, 17} {
+			for i := range input {
+				seed = seed*6364136223846793005 + 1
+				input[i] = byte(seed >> 56)
+				output[i] = 0xa5
+				want[i] = 0xa5
+			}
+			if trial < 64 {
+				binary.LittleEndian.PutUint64(input[off:], uint64(1)<<trial)
+			}
+			if trial == 64 {
+				binary.LittleEndian.PutUint64(input[off:], ^uint64(0))
+			}
+			x := binary.LittleEndian.Uint64(input[off:])
+			salt := seed
+			x = (x + salt) ^ 17
+			x = (x + salt) ^ 17
+			binary.LittleEndian.PutUint64(want[off:], x)
+			snapshot := input
+			beforeG := readGoG()
+			rawZeroNumeric(&input[off], &output[off], salt)
+			afterG := readGoG()
+			if beforeG == 0 || beforeG != afterG || input != snapshot || output != want {
+				panic("raw repeated helper math/canary/caller/g mismatch")
+			}
+		}
+	}
+}
+`
+	for name, body := range map[string]string{
+		"go.mod":  "module rawzeronumericoracle\n\ngo 1.20\n",
+		"main.go": goOracle,
+		"oracle_arm64.s": strings.Replace(source, "TEXT rawZeroNumeric", "TEXT ·rawZeroNumeric", 1) +
+			"\nTEXT ·readGoG(SB),516,$0-8\nMOVD g,R0\nMOVD R0,ret+0(FP)\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	args := []string{"run", "-p=1", "."}
+	if len(runner) != 0 {
+		args = []string{"run", "-p=1", "-exec=qemu-aarch64", "."}
+	}
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		cmd.Env = append(cmd.Env, "GOOS=linux")
+	}
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go repeated raw BL math/LR oracle: %v\n%s", err, output)
+	}
+	const cOracle = `#include <stdint.h>
+#include <string.h>
+extern void rawZeroNumeric(const unsigned char *, unsigned char *, uint64_t);
+static uint64_t readG(void) {
+  uint64_t v;
+  __asm__ volatile("mov %0,x28" : "=r"(v));
+  return v;
+}
+static uint64_t readOS18(void) {
+  uint64_t v;
+  __asm__ volatile("mov %0,x18" : "=r"(v));
+  return v;
+}
+int main(void) {
+  unsigned char input[96], output[96], want[96], snapshot[96];
+  const unsigned offsets[] = {0, 1, 3, 7, 17};
+  uint64_t seed = UINT64_C(0x0123456789abcdef);
+  for (unsigned trial = 0; trial < 256; trial++)
+    for (unsigned o = 0; o < 5; o++) {
+      unsigned off = offsets[o];
+      for (unsigned i = 0; i < 96; i++) {
+        seed = seed * UINT64_C(6364136223846793005) + 1;
+        input[i] = (unsigned char)(seed >> 56);
+        output[i] = 0xa5;
+        want[i] = 0xa5;
+      }
+      if (trial < 64) {
+        uint64_t v = UINT64_C(1) << trial;
+        memcpy(input + off, &v, 8);
+      }
+      if (trial == 64) {
+        uint64_t v = UINT64_MAX;
+        memcpy(input + off, &v, 8);
+      }
+      uint64_t x;
+      memcpy(&x, input + off, 8);
+      x = (x + seed) ^ 17;
+      x = (x + seed) ^ 17;
+      memcpy(want + off, &x, 8);
+      memcpy(snapshot, input, 96);
+      uint64_t beforeG = readG(), beforeOS18 = readOS18();
+      rawZeroNumeric(input + off, output + off, seed);
+      if (beforeG != readG() || beforeOS18 != readOS18() ||
+          memcmp(input, snapshot, 96) || memcmp(output, want, 96))
+        return 1;
+    }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "raw_zero_numeric", triple, ir, cOracle, runner)
+	t.Log("actual Go raw BL and LLVM22/C: 1280 independent overflow/bit-pattern cases, two executed arithmetic helper calls, dead private GP at typed void return, ordinary R22/R23 spill restoration, unchanged actual Go g and native caller g/OS18 snapshots, full canaries/caller LR")
+}
diff --git a/arm64_raw_zero_frame_test.go b/arm64_raw_zero_frame_test.go
new file mode 100644
index 000000000..50050557e
--- /dev/null
+++ b/arm64_raw_zero_frame_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RawZeroFrameFixture(flags int, call bool, body string) string {
+	if call {
+		body += "WORD $0x94000004\n"
+	}
+	source := fmt.Sprintf(`TEXT rawZero(SB),%d,$0-16
+MOVD in+0(FP),R0
+MOVD out+8(FP),R1
+WORD $0xa9bf7bfd
+MOVD $0,R4
+%sWORD $0xa8c17bfd
+WORD $0xd65f03c0
+`, flags, body)
+	if call {
+		source += "WORD $0xd503201f\nWORD $0xd65f03c0\n"
+	}
+	return source
+}
+
+func TestARM64RawZeroFrameEscapesAndCallerStateFailClosed(t *testing.T) {
+	for _, body := range []string{
+		"MOVD R29,(R1)",
+		"MOVD R29,holder(SB)",
+		"MOVD R29,out+8(FP)",
+		"MOVD R29,R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD 0(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD RSP,R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"ADD $8,RSP,R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD RSP,R0",
+		"MOVD RSP,R9",
+		"CBZ R0,other\nMOVD RSP,R9\nB joined\nother:\nMOVD R0,R9\njoined:\nMOVD R9,(R1)\nMOVD $0,R9",
+		"CBZ R0,other\nMOVD RSP,R9\nB joined\nother:\nADD $8,RSP,R9\njoined:\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD RSP,R9\nEOR R9,R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD (RSP)(R0),R9",
+		"MOVD.P (RSP)(R0),R9",
+		"MOVD RSP,R9\nMOVD (R0)(R9),R10\nMOVD $0,R9",
+		"MOVD.P 8(R29),R29",
+		"MOVB R4,1(RSP)",
+		"MOVH R4,2(RSP)",
+		"MOVW R4,4(RSP)",
+		"MOVB R4,9(RSP)",
+		"MOVH R4,10(RSP)",
+		"MOVW R4,12(RSP)",
+		"MOVD R4,8(RSP)",
+		"STPW (R4,R5),4(RSP)",
+		"FSTPS (F0,F1),4(RSP)",
+		"FMOVQ F0,0(RSP)",
+		"FMOVD 0(RSP),F0",
+		"MOVWU 0(RSP),R9\nMOVD R9,(R1)\nMOVD $0,R9",
+		"MOVD R4,-8(RSP)",
+		"MOVD R4,16(RSP)",
+		"SUB $16,RSP",
+		"ADD $16,RSP",
+		"CBZ R0,joined\nSUB $16,RSP\njoined:",
+		"WORD $0xffffffff",
+		"DWORD $0",
+		"WORD $0xd63f0000", // Native BLR X0, not a source-local continuation.
+		"WORD $0x94010000", // Raw BL outside the exact source envelope.
+		"CALL unknown(SB)",
+		"SVC $0",
+		"B dead_end\ndead:\nMOVD R29,(R1)\ndead_end:",
+	} {
+		t.Run(body, func(t *testing.T) {
+			// The final external store forces actual continuation lowering to
+			// need the disjointness proof; otherwise some valid unsafe-to-grant
+			// bodies can still translate without ever borrowing that permission.
+			file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, body+"\nMOVD R4,(R1)\n"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if arm64RawZeroFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("whole-source zero-frame proof erased an escape, overlap or unknown effect")
+			}
+			sig := arm64RawZeroFrameSig()
+			if body == "MOVD RSP,R0" || body == "MOVD RSP,R9" {
+				// Unknown/result transport cannot discard these live addresses.
+				sig.Ret = I64
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple, Sigs: map[string]FuncSig{sig.Name: sig}})
+			if err == nil {
+				t.Fatal("unsafe source borrowed another translation path")
+			}
+		})
+	}
+	for _, replacement := range []string{
+		"MOVD $0,R29\nWORD $0xd65f03c0",
+		"MOVD $0,R30\nWORD $0xd65f03c0",
+		"RET R0",
+		"B (R0)",
+		"WORD $0xd65f0000", // Physical RET X0.
+	} {
+		source := strings.Replace(arm64RawZeroFrameFixture(516, false, ""), "WORD $0xd65f03c0", replacement, 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64RawZeroFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("unrestored/unknown caller state inherited a proof: %s", replacement)
+		}
+	}
+}
+
+func TestARM64RawZeroFrameRawCallsStayPhysicalLeaf(t *testing.T) {
+	file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(4, true, "MOVD R4,(R1)\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeARM64RawPCRelative(file.Funcs[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if arm64SourceGoFrame(file.Funcs[0]).present || arm64SourceGoFrame(normalized).present {
+		t.Fatal("normalizing a raw BL invented a Go LR/FP prologue")
+	}
+	for _, mutation := range []string{
+		"MOVD R29,(R1)\nWORD $0xd65f03c0",
+		"SUB $16,RSP\nWORD $0xd65f03c0",
+		"MOVD $0,R30\nWORD $0xd65f03c0",
+		"WORD $0x97ffffff\nWORD $0xd65f03c0", // Recursive raw call remains bounded/fails.
+	} {
+		source := strings.Replace(arm64RawZeroFrameFixture(516, true, "MOVD R4,(R1)\n"), "WORD $0xd503201f\nWORD $0xd65f03c0", mutation, 1)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if arm64RawZeroFrameUnexposed(file.Funcs[0]) {
+			t.Fatalf("raw local-call context lost its independent return/effect contract: %s", mutation)
+		}
+	}
+	// A textual local BL does cause Go's prologue selection. It cannot borrow
+	// the raw-call witness merely by copying a diagnostic comment.
+	manual := normalized
+	manual.Instrs = append([]Instr(nil), normalized.Instrs...)
+	for index := range manual.Instrs {
+		if manual.Instrs[index].arm64RawLocalCall {
+			manual.Instrs[index].arm64RawLocalCall = false
+		}
+	}
+	if !arm64SourceGoFrame(manual).present || arm64RawZeroFrameUnexposed(manual) {
+		t.Fatal("a comment was accepted as authenticated raw-call origin")
+	}
+	_, err = Translate(&File{Arch: ArchARM64, Funcs: []Func{manual}}, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"rawZero": arm64RawZeroFrameSig()}})
+	if err == nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unproved source call must stay fail-closed: %v", err)
+	}
+}
+
+func arm64RawZeroFrameSig() FuncSig {
+	return FuncSig{
+		Name: "rawZero", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+		}},
+	}
+}
+
+func TestARM64RawZeroFrameCallerDisjointStore(t *testing.T) {
+	for _, tc := range []struct {
+		name  string
+		flags int
+		call  bool
+	}{
+		{name: "zero_leaf", flags: 4},
+		{name: "noframe_leaf", flags: 516},
+		{name: "zero_raw_local_call", flags: 4, call: true},
+		{name: "noframe_raw_local_call", flags: 516, call: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64RawZeroFrameFixture(tc.flags, tc.call, "MOVD R4,(R1)\n")
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := arm64RawZeroFrameSig()
+			ir, err := Translate(file, Options{
+				Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+				Sigs: map[string]FuncSig{sig.Name: sig},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "@rawZero(") {
+				t.Fatal("typed raw zero-frame root was not emitted")
+			}
+		})
+	}
+}
+
+func TestARM64RawZeroFrameTypedVoidDiscardsOnlyDeadVirtualGP(t *testing.T) {
+	for _, body := range []string{
+		"MOVD RSP,R9",
+		"MOVD RSP,R0",
+		"MOVD RSP,R9\nMOVD R9,R10",
+		"CBZ R0,other\nMOVD RSP,R9\nB joined\nother:\nMOVD R0,R9\njoined:",
+	} {
+		t.Run(body, func(t *testing.T) {
+			source := arm64RawZeroFrameFixture(516, false, body+"\nMOVD R4,(R1)\n")
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if arm64RawZeroFrameUnexposed(file.Funcs[0]) {
+				t.Fatal("source-only proof cannot guess the caller's return transport")
+			}
+			sig := arm64RawZeroFrameSig()
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{sig.Name: sig}})
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestARM64RawZeroFrameTypedVoidRequiresCompleteABI0(t *testing.T) {
+	file, err := Parse(ArchARM64, arm64RawZeroFrameFixture(516, false, "MOVD RSP,R9\nMOVD R4,(R1)\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, tc := range []struct {
+		name string
+		edit func(*Func, *FuncSig)
+	}{
+		{"result", func(_ *Func, sig *FuncSig) { sig.Ret = I64 }},
+		{"result_slot", func(_ *Func, sig *FuncSig) { sig.Frame.Results = []FrameSlot{{Type: I64}} }},
+		{"custom_regs", func(_ *Func, sig *FuncSig) { sig.ArgRegs = []Reg{"R0", "R1"} }},
+		{"register_abi", func(_ *Func, sig *FuncSig) { sig.ARM64GoRegisterABI = &ARM64GoRegisterABI{} }},
+		{"closure", func(_ *Func, sig *FuncSig) { sig.ARM64ClosureABI = &ARM64ClosureABI{} }},
+		{"machine_entry", func(_ *Func, sig *FuncSig) { sig.ARMEntry = &ARMMachineEntry{} }},
+		{"context", func(_ *Func, sig *FuncSig) { sig.WASMContext = Ptr }},
+		{"native", func(_ *Func, sig *FuncSig) { sig.WASMNative = true }},
+		{"missing_slot", func(_ *Func, sig *FuncSig) { sig.Frame.Params = sig.Frame.Params[:1] }},
+		{"aggregate", func(_ *Func, sig *FuncSig) { sig.Args[0] = "{ ptr, i64 }" }},
+		{"narrow", func(_ *Func, sig *FuncSig) { sig.Args[0] = I32; sig.Frame.Params[0].Type = I32 }},
+		{"slot_type", func(_ *Func, sig *FuncSig) { sig.Frame.Params[0].Type = I64 }},
+		{"slot_offset", func(_ *Func, sig *FuncSig) { sig.Frame.Params[0].Offset = 8 }},
+		{"slot_index", func(_ *Func, sig *FuncSig) { sig.Frame.Params[0].Index = 1 }},
+		{"slot_field", func(_ *Func, sig *FuncSig) { sig.Frame.Params[0].Field = 0 }},
+		{"slot_fields", func(_ *Func, sig *FuncSig) { sig.Frame.Params[0].Fields = []int{0} }},
+		{"arg_size", func(fn *Func, _ *FuncSig) { fn.ArgSize++ }},
+		{"internal", func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" }},
+		{"helper", func(fn *Func, _ *FuncSig) { fn.arm64PrivateRegisterEntry = true }},
+		{"hidden_context", func(fn *Func, _ *FuncSig) { fn.Instrs[0].Raw = "TEXT rawZero(SB),NOSPLIT|NOFRAME|NEEDCTXT,$0-16" }},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			fn, sig := file.Funcs[0], arm64RawZeroFrameSig()
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			tc.edit(&fn, &sig)
+			transport := &arm64PrivateFrameTransport{entry: sig}
+			if arm64RawZeroVoidTransport(fn, transport) || arm64RawZeroFrameUnexposedForTransport(fn, transport) {
+				t.Fatal("incomplete/nonordinary caller transport discarded a live frame address")
+			}
+		})
+	}
+	if arm64RawZeroFrameUnexposedForTransport(file.Funcs[0], nil) {
+		t.Fatal("absent caller contract inherited void transport")
+	}
+}
diff --git a/arm64_raw_zero_runtime_registers_test.go b/arm64_raw_zero_runtime_registers_test.go
new file mode 100644
index 000000000..4a243d8fc
--- /dev/null
+++ b/arm64_raw_zero_runtime_registers_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Return-state restoration is sufficient for the separate object proof,
+// but an asynchronous Go runtime observer can see a temporary g/OS18 write.
+// The fixture actually executed by Go therefore never writes either register.
+func arm64RawZeroRuntimeRegisterSafety(source string) error {
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return err
+	}
+	if len(file.Funcs) != 1 {
+		return fmt.Errorf("runtime fixture must contain one function")
+	}
+	const reserved = uint32(1<<18 | 1<<28)
+	for _, ins := range file.Funcs[0].Instrs {
+		switch ins.Op {
+		case OpTEXT:
+		case "MOVD":
+			if len(ins.Args) != 2 {
+				return fmt.Errorf("unknown fixture MOVD: %s", ins.Raw)
+			}
+			destination := ins.Args[1]
+			if destination.Kind == OpReg && (destination.Reg == "R18" || destination.Reg == "R28" || destination.Reg == "g") {
+				return fmt.Errorf("runtime fixture writes reserved register: %s", ins.Raw)
+			}
+		case OpWORD:
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat {
+				return fmt.Errorf("unresolved fixture WORD: %s", ins.Raw)
+			}
+			word := uint32(ins.Args[0].Imm)
+			// Direct BL writes LR; exact RET reads LR. Neither writes g/OS18.
+			if word&0xfc000000 == 0x94000000 || word == 0xd65f03c0 {
+				continue
+			}
+			writes, known := arm64RawPoolGPWrites(word)
+			if !known {
+				return fmt.Errorf("unknown fixture WORD effects: %s", ins.Raw)
+			}
+			if writes&reserved != 0 {
+				return fmt.Errorf("runtime fixture writes reserved register: %s", ins.Raw)
+			}
+		default:
+			return fmt.Errorf("unknown runtime fixture instruction: %s", ins.Raw)
+		}
+	}
+	return nil
+}
+
+func TestARM64RawZeroRepeatedRuntimeKeepsReservedRegisters(t *testing.T) {
+	source := arm64RawZeroRepeatedNumericSource(t)
+	if err := arm64RawZeroRuntimeRegisterSafety(source); err != nil {
+		t.Fatal(err)
+	}
+	// Keep the guard tied to decoded effects, including the restore load,
+	// rather than just detecting the old ADD spelling or eventual identity.
+	words := assembleARM64LLVMWords(t, []string{
+		"add x28,sp,#0", "add x18,sp,#0", "ldp x28,x18,[sp],#16",
+	}, "")
+	for _, word := range words {
+		broken := strings.Replace(source, "MOVD (R0),R4", fmt.Sprintf("WORD $%#08x\nMOVD (R0),R4", word), 1)
+		if err := arm64RawZeroRuntimeRegisterSafety(broken); err == nil {
+			t.Fatalf("reserved-register WORD %#08x passed runtime safety", word)
+		}
+	}
+	for _, instruction := range []string{"MOVD R0,g", "MOVD R0,R18", "WORD $0xffffffff"} {
+		broken := strings.Replace(source, "MOVD (R0),R4", instruction+"\nMOVD (R0),R4", 1)
+		if err := arm64RawZeroRuntimeRegisterSafety(broken); err == nil {
+			t.Fatalf("unsafe/unknown fixture instruction passed: %s", instruction)
+		}
+	}
+}
diff --git a/arm64_register_address.go b/arm64_register_address.go
new file mode 100644
index 000000000..2563651c3
--- /dev/null
+++ b/arm64_register_address.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64RegisterAddressForm struct {
+	base, destination Reg
+	offset            int64
+	usesScratch       bool
+	constantBase      bool
+}
+
+// Go's C_AACON/C_AACON2 rows use ADD/SUB immediates. C_LACON first
+// materializes the literal into R27 and then reads the base for ADD.
+func arm64AddressUsesScratch(offset int64) bool {
+	addImmediate := func(value int64) bool {
+		return value >= 0 && (value <= 0xfff || value&0xfff == 0 && value>>12 <= 0xfff)
+	}
+	return !addImmediate(offset) && !addImmediate(-offset) && (offset < 0 || offset > 0xffffff)
+}
+
+func parseARM64RegisterAddressForm(op Op, ins Instr) (arm64RegisterAddressForm, bool, error) {
+	var f arm64RegisterAddressForm
+	if len(ins.Args) == 0 || ins.Args[0].Kind != OpSym {
+		return f, false, nil
+	}
+	address := strings.TrimSpace(ins.Args[0].Sym)
+	if !strings.HasPrefix(address, "$") || strings.HasSuffix(address, "(SB)") {
+		return f, false, nil
+	}
+	memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(address, "$")))
+	if !ok {
+		return f, false, nil // Named constants retain their separate resolution.
+	}
+	constantBase := memory.Base == ZR
+	if op != "MOVD" || string(ins.Op) != "MOVD" || len(ins.Args) != 2 ||
+		ins.Args[1].Kind != OpReg ||
+		(!arm64AddressReg(ins.Args[1].Reg) && !(constantBase && ins.Args[1].Reg == ZR)) ||
+		(!arm64AddressReg(memory.Base) && !constantBase) || memory.Index != "" || memory.OffRaw != "" {
+		return f, true, fmt.Errorf("arm64 register address requires MOVD $offset(GP/RSP),GP/RSP with no suffix: %q", ins.Raw)
+	}
+	f.base, f.destination, f.offset = memory.Base, ins.Args[1].Reg, memory.Off
+	if constantBase && arm64StackReg(f.destination) {
+		return f, true, fmt.Errorf("arm64 zero-base literal is not a GP/RSP address row: %q", ins.Raw)
+	}
+	f.constantBase = constantBase
+	f.usesScratch = !constantBase && arm64AddressUsesScratch(memory.Off)
+	return f, true, nil
+}
+
+func arm64AddressReg(reg Reg) bool {
+	return arm64StackReg(reg) || isARM64GeneralOrZeroReg(reg) && reg != ZR
+}
+
+func (c *arm64Ctx) lowerARM64RegisterAddress(op Op, ins Instr) (bool, bool, error) {
+	f, handled, err := parseARM64RegisterAddressForm(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	if f.constantBase {
+		return true, false, c.storeReg(f.destination, c.imm64(f.offset))
+	}
+	if f.usesScratch {
+		if err := c.storeReg("R27", c.imm64(f.offset)); err != nil {
+			return true, false, err
+		}
+	}
+	base, err := c.loadReg(f.base)
+	if err != nil {
+		return true, false, err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %s, %s\n", result, base, c.imm64(f.offset))
+	return true, false, c.storeReg(f.destination, "%"+result)
+}
diff --git a/arm64_register_address_runtime_test.go b/arm64_register_address_runtime_test.go
new file mode 100644
index 000000000..c646dcd79
--- /dev/null
+++ b/arm64_register_address_runtime_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64RegisterAddress(t *testing.T) {
+	runARM64RegisterAddressRuntime(t, []string{"R2", "R27", "RSP"}, []string{"R2", "R27", "RSP"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RegisterAddressScratch(t *testing.T) {
+	runARM64RegisterAddressRuntime(t, []string{"R27"}, []string{"R2"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RegisterAddressZeroBase(t *testing.T) {
+	// Go classifies a zero base as a constant, not C_AACON/C_LACON. It
+	// neither reads SP nor performs the large-address R27 materialization.
+	runARM64RegisterAddressRuntime(t, []string{"ZR"}, []string{"R2", "R27"})
+}
+
+func runARM64RegisterAddressRuntime(t *testing.T, bases, destinations []string) {
+	t.Helper()
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	count := 0
+	for _, offset := range []int64{-65537, -65536, -4097, -4096, -1, 0, 1, 4095, 4096, 4097, 5900, 65536, 65537} {
+		for _, base := range bases {
+			for _, destination := range destinations {
+				name := fmt.Sprintf("registerAddress%d", count)
+				count++
+				fmt.Fprintf(&source, `TEXT ·%s(SB),516,$0-16
+MOVD a+0(FP),R0
+MOVD out+8(FP),R10
+MOVD RSP,R20
+MOVD R0,R2
+MOVD $73,R27
+CMP $1,R0
+CSET EQ,R12
+CSET MI,R13
+CSET CS,R14
+CSET VS,R15
+MOVD $%d(%s),%s
+MOVD %s,R3
+MOVD R20,RSP
+`, name, offset, base, destination, destination)
+				if base == "RSP" {
+					source.WriteString("SUB R20,R3\n")
+				}
+				source.WriteString("MOVD R3,0(R10)\n")
+				if base == "RSP" && destination == "R27" {
+					// Stack addresses differ between the independent programs.
+					// Compare the emitted address relative to its captured SP.
+					source.WriteString("SUB R20,R27\n")
+				}
+				source.WriteString(`MOVD R27,8(R10)
+CSET EQ,R3
+EOR R12,R3
+CSET MI,R4
+EOR R13,R4
+ORR R4,R3
+CSET CS,R4
+EOR R14,R4
+ORR R4,R3
+CSET VS,R4
+EOR R15,R4
+ORR R4,R3
+MOVD R3,16(R10)
+RET
+`)
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{I64, Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					}},
+				}
+				fmt.Fprintf(&goDecl, "func %s(uint64,*[3]uint64)\n", name)
+				fmt.Fprintf(&cDecl, "extern void %s(uint64_t,uint64_t*);\n", name)
+				// The independent oracle follows Go's emitted ADD/SUB and
+				// literal-load sequence, including read-after-clobber R27.
+				scratch := base != "ZR" && (offset < 0 && !arm64RuntimeAddressSingleImmediate(-offset) || offset > 0xffffff)
+				want := "a+uint64(offset)"
+				wantC := fmt.Sprintf("a+(uint64_t)(INT64_C(%d))", offset)
+				if base == "RSP" || base == "ZR" {
+					want, wantC = "uint64(offset)", fmt.Sprintf("(uint64_t)(INT64_C(%d))", offset)
+				} else if base == "R27" {
+					baseValue := int64(73)
+					if scratch {
+						baseValue = offset
+					}
+					want = "uint64(73)+uint64(offset)"
+					if scratch {
+						want = "uint64(offset)+uint64(offset)"
+					}
+					wantC = fmt.Sprintf("(uint64_t)(INT64_C(%d))+(uint64_t)(INT64_C(%d))", baseValue, offset)
+				}
+				wantScratch, wantScratchC := "uint64(73)", "UINT64_C(73)"
+				if scratch {
+					wantScratch, wantScratchC = "uint64(offset)", fmt.Sprintf("(uint64_t)(INT64_C(%d))", offset)
+				}
+				if destination == "R27" {
+					wantScratch, wantScratchC = want, wantC
+				}
+				fmt.Fprintf(&goChecks, `
+for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+var out [3]uint64
+offset:=int64(%d)
+%s(a,&out)
+if out != [3]uint64{%s,%s,0} { println("%s",a,out[0],out[1],out[2]);panic("register-address Go oracle") }
+}
+`, offset, name, want, wantScratch, name)
+				fmt.Fprintf(&cChecks, `
+for(unsigned i=0;i<5;i++) {
+uint64_t a=inputs[i],out[3]={0};
+%s(a,out);
+if(out[0]!=(%s)||out[1]!=(%s)||out[2]!=0) {
+fprintf(stderr,"%s address/scratch/flags mismatch: %%llx %%llx %%llx\n",(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2]);return 1;
+}
+}
+`, name, wantC, wantScratchC, name)
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "register_address", triple, ir, main, runner)
+	t.Logf("%d address functions x 5 inputs match native Go and LLVM/C", count)
+}
+
+func arm64RuntimeAddressSingleImmediate(value int64) bool {
+	return value >= 0 && (value <= 4095 || value%4096 == 0 && value/4096 <= 4095)
+}
diff --git a/arm64_register_address_test.go b/arm64_register_address_test.go
new file mode 100644
index 000000000..764b68832
--- /dev/null
+++ b/arm64_register_address_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARM64RegisterAddressClobberedLinkNeedsContext(t *testing.T) {
+	const source = "TEXT addressLink(SB),516,$0-0\nMOVD R30,R27\nMOVD $-4097(R2),R3\nRET R27\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"addressLink": {Name: "addressLink", Ret: Void},
+	}})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("R27 literal materialization cannot retain a saved caller-link proof: %v", err)
+	}
+}
+
+func TestARM64RegisterAddressGrammarMatchesGoEncoder(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Older Go tables have no trailing To3 operand class. In both layouts
+	// the same three address classes select encoder types 4 and 34.
+	rows := regexp.MustCompile(`\{AMOVD, C_(AACON2?|LACON), C_NONE, C_NONE, C_RSP, (?:C_NONE, )?(\d+),`).FindAllStringSubmatch(string(source), -1)
+	want := map[string]string{"AACON": "4", "AACON2": "4", "LACON": "34"}
+	if len(rows) != len(want) {
+		t.Fatalf("Go register-address family has %d rows, want %d", len(rows), len(want))
+	}
+	for _, row := range rows {
+		if want[row[1]] != row[2] {
+			t.Fatalf("unexpected Go register-address row: %s", row[0])
+		}
+		delete(want, row[1])
+	}
+	if len(want) != 0 {
+		t.Fatalf("missing Go register-address classes: %v", want)
+	}
+}
+
+func TestARM64RegisterAddressClassBoundaries(t *testing.T) {
+	for _, item := range []struct {
+		offset  int64
+		scratch bool
+	}{
+		{0, false}, {4095, false}, {-4095, false}, {4096, false}, {-4096, false},
+		{4097, false}, {-4097, true}, {0xfff000, false}, {-0xfff000, false},
+		{0xffffff, false}, {-0xffffff, true}, {1 << 24, true}, {-1 << 24, true},
+		{1<<63 - 1, true}, {-1 << 63, true},
+	} {
+		if got := arm64AddressUsesScratch(item.offset); got != item.scratch {
+			t.Errorf("offset %d scratch=%v, want %v", item.offset, got, item.scratch)
+		}
+	}
+}
+
+// asm7's C_AACON, C_AACON2 and C_LACON MOVD rows share address arithmetic,
+// not symbol loads. Row 34 additionally materializes its offset into R27.
+func TestARM64RegisterAddressCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT addressForms(SB),516,$0-0\nMOVD RSP,R20\n")
+	for _, offset := range []int64{-65537, -65536, -4097, -4096, -1, 0, 1, 4095, 4096, 4097, 5900, 65536, 65537} {
+		for _, base := range []string{"R0", "R2", "R27", "RSP", "LR", "g", "R18_PLATFORM"} {
+			for _, destination := range []string{"R2", "R27", "RSP"} {
+				fmt.Fprintf(&source, "MOVD $%d(%s),%s\nMOVD R20,RSP\n", offset, base, destination)
+			}
+		}
+	}
+	source.WriteString("B (ZR)\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"addressForms": {Name: "addressForms", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "register-address.ll", "register-address.o", ir)
+	}
+}
+
+func TestARM64RegisterAddressZeroBaseConstantGoForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT zeroAddress(SB),516,$0-0\n")
+	for _, offset := range []int64{-1 << 63, -65537, -4097, -1, 0, 1, 4097, 65537, 1 << 24, 1<<63 - 1} {
+		for _, destination := range []string{"R2", "R27", "ZR"} {
+			fmt.Fprintf(&source, "MOVD $%d(ZR),%s\n", offset, destination)
+		}
+	}
+	source.WriteString("B (ZR)\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"zeroAddress": {Name: "zeroAddress", Ret: Void},
+	}}
+	if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "native inline assembly") {
+		t.Fatal("native zero-base branch escaped its explicit target requirement", ir != "", err)
+	}
+	options.TargetTriple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "aarch64-unknown-linux-gnu", "zero-address.ll", "zero-address.o", ir)
+}
+
+func TestARM64RegisterAddressPreservesLargeScratch(t *testing.T) {
+	for _, offset := range []int64{-65537, -4097, 1 << 24} {
+		source := fmt.Sprintf("TEXT addressScratch(SB),516,$0-8\nMOVD $73,R27\nMOVD $%d(R27),R2\nMOVD R27,result+0(FP)\nRET\n", offset)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+			"addressScratch": {Name: "addressScratch", Ret: I64,
+				Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}},
+		}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(ir, fmt.Sprintf("store i64 %d, ptr %%reg_R27", offset)) {
+			t.Fatal("large address must preserve Go's R27 literal materialization before reading an R27 base")
+		}
+	}
+}
+
+func TestARM64RegisterAddressRejectsGoInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVD $8(R2),ZR", "MOVD $8(R2),F0", "MOVD $8(R2),(R3)",
+		"MOVW $8(R2),R3", "MOVWU $8(R2),R3", "MOVB $8(R2),R3",
+		"MOVD.P $8(R2),R3", "MOVD.W $8(R2),R3", "MOVD $8(R31),R3",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT badAddress(SB),516,$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"badAddress": {Name: "badAddress", Ret: Void},
+			}}); err == nil {
+				t.Fatal("Go-rejected address form was accepted")
+			}
+		})
+	}
+}
diff --git a/arm64_register_control.go b/arm64_register_control.go
new file mode 100644
index 000000000..2add8f30b
--- /dev/null
+++ b/arm64_register_control.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's AB accepts C_ZOREG; ABL accepts C_ZREG and C_ZOREG. Encoding
+// register 31 in BR/BLR reads XZR, even when the frontend spells it RSP.
+func (c *arm64Ctx) registerBranchAddress(op Op, ins Instr) (string, error) {
+	if len(ins.Args) != 1 || strings.Contains(string(ins.Op), ".") {
+		return "", fmt.Errorf("arm64 %s expects one unsuffixed register target: %q", op, ins.Raw)
+	}
+	target := ins.Args[0]
+	if op == OpRET {
+		// obj7's RET auto-epilogue keeps only To.Reg (or the default LR),
+		// then emits zero-displacement ARET. Its source displacement/index
+		// and a sole immediate operand are deliberately not branch offsets.
+		if normalized, ok := arm64RegisterReturnTarget(ins, false); ok {
+			target = normalized
+		}
+	}
+	if target.Kind == OpReg {
+		if (op != "BL" && op != "BLR" && op != "CALL" && op != OpRET) || !isARM64GeneralOrZeroReg(target.Reg) {
+			return "", fmt.Errorf("arm64 %s does not accept this bare register: %q", op, ins.Raw)
+		}
+		return c.loadReg(target.Reg)
+	}
+	if target.Kind != OpMem || target.Mem.Off != 0 || target.Mem.OffRaw != "" || target.Mem.Index != "" {
+		return "", fmt.Errorf("arm64 %s expects (general register) with zero displacement: %q", op, ins.Raw)
+	}
+	reg := target.Mem.Base
+	if reg == SP || reg == Reg("RSP") || reg == ZR {
+		return "0", nil
+	}
+	if !isARM64GeneralOrZeroReg(reg) {
+		return "", fmt.Errorf("arm64 %s expects (general register): %q", op, ins.Raw)
+	}
+	return c.loadReg(reg)
+}
+
+func (c *arm64Ctx) storeLocalLink(continuation string) error {
+	link := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr blockaddress(%s, %%%s) to i64\n", link, llvmGlobal(c.sig.Name), arm64LLVMBlockName(continuation))
+	return c.storeReg(Reg("R30"), "%"+link)
+}
+
+func (c *arm64Ctx) storeCallerLink() error {
+	pointer, address := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call ptr @llvm.returnaddress(i32 0)\n  %%%s = ptrtoint ptr %%%s to i64\n", pointer, address, pointer)
+	return c.storeReg(Reg("R30"), "%"+address)
+}
+
+func (c *arm64Ctx) lowerRegisterControl(bi int, op Op, ins Instr) (bool, error) {
+	// BLR R30 must read its destination before replacing the link register.
+	addr, err := c.registerBranchAddress(op, ins)
+	if err != nil {
+		return false, err
+	}
+	if c.lowerProvenUnreachableControl(bi) {
+		return true, nil
+	}
+	targets, err := c.localControlTargets(bi)
+	if err != nil {
+		return false, err
+	}
+	call := op == "BL" || op == "BLR" || op == "CALL"
+	if call {
+		if bi+1 >= len(c.blocks) {
+			return false, fmt.Errorf("arm64 %s has no continuation block: %q", op, ins.Raw)
+		}
+		if err := c.storeLocalLink(c.blocks[bi+1].name); err != nil {
+			return false, err
+		}
+	}
+	if len(targets) != 0 {
+		// The caller's native link is not an in-function blockaddress. A
+		// reaching-definition proof of that one target lowers to an ordinary
+		// LLVM return block; no native pointer goes through indirectbr.
+		if len(targets) == 1 && targets[0] == c.localControl.outer {
+			if call {
+				return false, fmt.Errorf("%w: ARM64 call through native caller link has no callee ABI contract: %q", ErrProbeNeedsContext, ins.Raw)
+			}
+			if op != OpRET && c.localControl.autoFrame {
+				return false, fmt.Errorf("%w: ARM64 branch through caller link has no Go frame epilogue proof: %q", ErrProbeNeedsContext, ins.Raw)
+			}
+			if err := c.requireCallerSPRestored(bi, ins); err != nil {
+				return false, err
+			}
+			fmt.Fprintf(c.b, "  br label %%%s\n", arm64LLVMBlockName(targets[0]))
+			c.recordARM64FlagFlowEdges(targets[0])
+			return true, nil
+		}
+		if op == OpRET && c.localControl.autoFrame {
+			for _, target := range targets {
+				if target != c.localControl.outer {
+					return false, fmt.Errorf("%w: ARM64 framed RET to a local code address requires the caller-frame epilogue, not a local helper return: %q", ErrProbeNeedsContext, ins.Raw)
+				}
+			}
+		}
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i64 %s to ptr\n  indirectbr ptr %%%s, [", pointer, addr, pointer)
+		for index, target := range targets {
+			if index != 0 {
+				c.b.WriteString(", ")
+			}
+			fmt.Fprintf(c.b, "label %%%s", arm64LLVMBlockName(target))
+		}
+		c.b.WriteString("]\n")
+		c.recordARM64FlagFlowEdges(targets...)
+		return true, nil
+	}
+	if call {
+		if addr == "0" {
+			// Physical BLR XZR always faults; it cannot return to observe an
+			// ABI result. Keep the real zero branch, not a guessed void call.
+			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 0)\n  unreachable\n", "blr $0", "r,~{memory}")
+			return true, nil
+		}
+		return false, fmt.Errorf("%w: ARM64 native register call needs a callee ABI and virtual register/result contract: %q", ErrProbeNeedsContext, ins.Raw)
+	}
+	if addr == "0" {
+		// As with BLR XZR, a physical zero branch cannot return. In
+		// particular it must not fabricate a successful LLVM return.
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i64 0)\n  unreachable\n", "br $0", "r,~{memory}")
+		return true, nil
+	}
+	return false, fmt.Errorf("%w: ARM64 native register branch needs a tail ABI, native frame/link and virtual register/result contract: %q", ErrProbeNeedsContext, ins.Raw)
+}
diff --git a/arm64_remainder_scratch_proof_test.go b/arm64_remainder_scratch_proof_test.go
new file mode 100644
index 000000000..eb2062e18
--- /dev/null
+++ b/arm64_remainder_scratch_proof_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64RemainderScratchNumericBoundsCannotSurvive(t *testing.T) {
+	for _, op := range []string{"REM", "REMW", "UREM", "UREMW"} {
+		file, err := Parse(ArchARM64, "TEXT bounds(SB),4,$0-0\n"+op+" R1,R0,R2\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := newARM64PrivateDataState()
+		state.regs["R27"] = arm64PrivateDataNumber(arm64PoolInterval{8, 8})
+		state.comparison = arm64PrivateDataCompare{leftReg: "R27", valid: true}
+		if _, valid := state.transfer(file.Funcs[0].Instrs[1], 1, 64); !valid {
+			t.Fatalf("numeric remainder must have known effects: %s", op)
+		}
+		if state.value("R27") != arm64PrivateDataUnknown || state.comparison.valid {
+			t.Fatalf("%s retained pre-DIV quotient bounds/comparison: %+v", op, state)
+		}
+	}
+}
+
+func TestARM64DivideRemainderTypedImplicitEffects(t *testing.T) {
+	for _, op := range []string{"SDIV", "SDIVW", "UDIV", "UDIVW", "REM", "REMW", "UREM", "UREMW"} {
+		for _, two := range []bool{false, true} {
+			text := op + " R1,R0,R2"
+			if two {
+				text = op + " R1,R2"
+			}
+			file, err := Parse(ArchARM64, "TEXT effects(SB),4,$0-0\n"+text+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			form, handled, err := parseARM64GPDataForm(Op(op), ins)
+			if !handled || err != nil {
+				t.Fatalf("typed form rejected: %s: %v", text, err)
+			}
+			outputs := arm64GPDataOutputRegisters(form)
+			remainder := strings.Contains(op, "REM")
+			count := 1
+			if remainder {
+				count++
+			}
+			if len(outputs) != count || outputs[0] != "R2" || remainder && outputs[1] != "R27" {
+				t.Fatalf("wrong explicit/implicit outputs for %s: %v", text, outputs)
+			}
+			for _, input := range arm64GPDataInputRegisters(form) {
+				state := &arm64ControlState{
+					regs:   map[Reg]arm64ControlValue{input: arm64ControlFromMap(map[string]bool{"label:caller": true})},
+					memory: make(map[string]arm64ControlValue),
+				}
+				state.transfer(ins, Op(op), false, nil)
+				for _, output := range outputs {
+					if !arm64ControlHas(arm64ControlRead(state.regs, output), "code-derived:") {
+						t.Fatalf("%s %s -> %s lost code provenance", text, input, output)
+					}
+				}
+				mayFrame := arm64PrivateFrameAddress{offset: 8, exact: true}
+				raw := &arm64RawPrivateFrameState{regs: arm64PrivateFrameAddresses{input: mayFrame}, spills: make(map[int64]arm64PrivateFrameAddress)}
+				readOnly := raw.regs.clone()
+				indexed := newARM64PrivateDataState()
+				indexed.regs[input] = arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{8, 8}}
+				_, valid := indexed.transfer(ins, 1, 64)
+				if raw.transfer(ins, ins, 64) || readOnly.transfer(ins, 64) || valid {
+					t.Fatalf("%s consumed private frame input %s as numerical data", text, input)
+				}
+			}
+			if !two {
+				mayFrame := arm64PrivateFrameAddress{offset: 8, exact: true}
+				raw := &arm64RawPrivateFrameState{
+					regs: arm64PrivateFrameAddresses{"R2": mayFrame, "R27": mayFrame}, spills: make(map[int64]arm64PrivateFrameAddress),
+				}
+				readOnly := raw.regs.clone()
+				if !raw.transfer(ins, ins, 64) || !readOnly.transfer(ins, 64) {
+					t.Fatalf("write-only destinations acquired false inputs: %s", text)
+				}
+				for _, output := range outputs {
+					if _, present := raw.regs[output]; present {
+						t.Fatalf("%s retained stale output frame category %s", text, output)
+					}
+					if _, present := readOnly[output]; present {
+						t.Fatalf("%s retained stale read-only output frame category %s", text, output)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64DivideRemainderCompleteGoRows(t *testing.T) {
+	bytes, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(bytes)
+	for _, family := range []struct {
+		name, encoder string
+		aliases       []string
+	}{
+		{"AREM", "16", []string{"REMW", "UREM", "UREMW"}},
+		// CRC32 shares this Go operand class, not division semantics.
+		{"ASDIV", "1", []string{"SDIVW", "UDIV", "UDIVW", "CRC32B", "CRC32CB", "CRC32CH", "CRC32CW", "CRC32CX", "CRC32H", "CRC32W", "CRC32X"}},
+	} {
+		rows := regexp.MustCompile(`(?m)^\s*\{`+family.name+`, C_ZREG, C_(?:ZREG|NONE), C_NONE, C_ZREG,(?: C_NONE,)? `+family.encoder+`,`).FindAllString(source, -1)
+		if len(rows) != 2 {
+			t.Fatalf("Go %s two/three-operand rows changed: %v", family.name, rows)
+		}
+		block := regexp.MustCompile(`case ` + family.name + `:\s*\n((?:\s*oprangeset\([^\n]+\n)+)`).FindStringSubmatch(source)
+		if len(block) != 2 {
+			t.Fatalf("Go %s alias table not recognized", family.name)
+		}
+		aliases := regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block[1], -1)
+		if len(aliases) != len(family.aliases) {
+			t.Fatalf("Go %s alias family changed: %v", family.name, aliases)
+		}
+		for index, alias := range aliases {
+			if alias[1] != family.aliases[index] {
+				t.Fatalf("Go %s alias mismatch: %v", family.name, aliases)
+			}
+		}
+	}
+	expansion := regexp.MustCompile(`(?s)case 16:.*?\n\s*case 17:`).FindString(source)
+	current := strings.Contains(expansion, "c.oprrr(p, p.As, REGTMP, r, rf)") &&
+		strings.Contains(expansion, "c.oprrrr(p, AMSUBW, rt, REGTMP, rf, r)")
+	// Go 1.20 uses the same machine sequence but fills the exact register
+	// fields after selecting each instruction's base opcode.
+	legacy := strings.Contains(expansion, "o1 = c.oprrr(p, p.As)") &&
+		strings.Contains(expansion, "o1 |= (uint32(rf&31) << 16) | (uint32(r&31) << 5) | REGTMP&31") &&
+		strings.Contains(expansion, "o2 = c.oprrr(p, AMSUBW)") &&
+		strings.Contains(expansion, "o2 |= (uint32(rf&31) << 16) | (uint32(r&31) << 10) | (REGTMP & 31 << 5) | uint32(rt&31)")
+	if !current && !legacy {
+		t.Fatal("Go REM quotient/MSUB expansion changed")
+	}
+	registers, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/a.out.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !regexp.MustCompile(`REGTMP\s*=\s*REG_R27`).Match(registers) {
+		t.Fatal("Go REM scratch identity changed")
+	}
+}
+
+func TestARM64RemainderImplicitScratchCannotRestoreCaller(t *testing.T) {
+	for _, op := range []string{"REM", "REMW", "UREM", "UREMW"} {
+		source := fmt.Sprintf(`TEXT ·scratch(SB),4,$0-0
+MOVD R30,R27
+MOVD $9,R0
+MOVD $2,R1
+%s R1,R0,R2
+MOVD R27,R30
+RET
+`, op)
+		// Stock Go accepts this source, but executing its damaged link would
+		// be unsafe. Only object syntax and fail-closed translation are tested.
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin",
+			"aarch64-pc-windows-msvc", "aarch64-w64-windows-gnu",
+		} {
+			options := Options{Goarch: "arm64", TargetTriple: triple,
+				ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs:       map[string]FuncSig{"scratch": {Name: "scratch", Ret: Void}},
+			}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s %s Translate retained overwritten R27 caller link: %v", op, triple, err)
+			}
+			ctx := llvm.NewContext()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err == nil {
+				module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s %s module retained overwritten R27 caller link: %v", op, triple, err)
+			}
+			pkg := mustGoPackage(t, "scratch", "package scratch\nfunc scratch()\n")
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: triple, ResolveSym: options.ResolveSym,
+			})
+			if err == nil {
+				bound.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("%s %s Go module retained overwritten R27 caller link: %v", op, triple, err)
+			}
+			ctx.Dispose()
+		}
+	}
+}
diff --git a/arm64_remainder_scratch_runtime_test.go b/arm64_remainder_scratch_runtime_test.go
new file mode 100644
index 000000000..1e3d14eb2
--- /dev/null
+++ b/arm64_remainder_scratch_runtime_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64RemainderScratchCases() []arm64DivRemRuntimeCase {
+	var cases []arm64DivRemRuntimeCase
+	for _, op := range []string{"REM", "REMW", "UREM", "UREMW", "SDIV", "SDIVW", "UDIV", "UDIVW"} {
+		for _, divisor := range []Reg{"R0", "R1", "R27", ZR} {
+			for _, dest := range []Reg{"R0", "R1", "R2", "R27", ZR} {
+				cases = append(cases, arm64DivRemRuntimeCase{
+					op: op, divisor: divisor, dividend: dest, dest: dest, two: true,
+				})
+				for _, dividend := range []Reg{"R0", "R1", "R27", ZR} {
+					cases = append(cases, arm64DivRemRuntimeCase{
+						op: op, divisor: divisor, dividend: dividend, dest: dest,
+					})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func arm64RemainderScratchSource(cases []arm64DivRemRuntimeCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·DivideRem(SB),4,$0-16\nMOVD input+0(FP),R10\nMOVD output+8(FP),R11\n")
+	for index, tc := range cases {
+		source.WriteString("MOVD 0(R10),R0\nMOVD 8(R10),R1\nMOVD 16(R10),R27\nMOVD 16(R10),R6\nMOVD 24(R10),R7\n")
+		fmt.Fprintf(&source, "MOVD $%#x,R2\nCMP R7,R6\n", arm64DivRemDiscard)
+		if tc.two {
+			fmt.Fprintf(&source, "%s %s,%s\n", tc.op, tc.divisor, tc.dest)
+		} else {
+			fmt.Fprintf(&source, "%s %s,%s,%s\n", tc.op, tc.divisor, tc.dividend, tc.dest)
+		}
+		result := tc.dest
+		if result == ZR {
+			result = "R2"
+		}
+		fmt.Fprintf(&source, "MOVD %s,%d(R11)\nMOVD R27,%d(R11)\n", result, index*24, index*24+8)
+		source.WriteString("CSET MI,R3\nCSET EQ,R4\nCSET HS,R5\nCSET VS,R8\n")
+		source.WriteString("LSL $1,R4\nLSL $2,R5\nLSL $3,R8\nORR R4,R3\nORR R5,R3\nORR R8,R3\n")
+		fmt.Fprintf(&source, "MOVD R3,%d(R11)\n", index*24+16)
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+// Go asm7 case 16 emits DIV Rm,Rn,R27 followed by MSUB R27,Rm,Rn,Rd.
+// The second instruction reads the already overwritten R27, including when
+// Rm or Rn aliases it. This is not an architectural remainder instruction.
+func arm64RemainderScratchExpected(tc arm64DivRemRuntimeCase, input [4]uint64) (result, scratch uint64) {
+	registers := map[Reg]uint64{"R0": input[0], "R1": input[1], "R2": arm64DivRemDiscard, "R27": input[2], ZR: 0}
+	numerator, denominator := registers[tc.dividend], registers[tc.divisor]
+	word := strings.HasSuffix(tc.op, "W")
+	if word {
+		numerator, denominator = uint64(uint32(numerator)), uint64(uint32(denominator))
+	}
+	if denominator != 0 {
+		if strings.HasPrefix(tc.op, "U") {
+			scratch = numerator / denominator
+		} else if word {
+			scratch = uint64(int64(int32(numerator)) / int64(int32(denominator)))
+		} else {
+			scratch = uint64(int64(numerator) / int64(denominator))
+		}
+	}
+	if word {
+		scratch = uint64(uint32(scratch))
+	}
+	if !strings.Contains(tc.op, "REM") {
+		result = scratch
+		scratch = input[2]
+		if tc.dest == "R27" {
+			scratch = result
+		}
+		if tc.dest == ZR {
+			result = arm64DivRemDiscard
+		}
+		return result, scratch
+	}
+	registers["R27"] = scratch
+	result = registers[tc.dividend] - scratch*registers[tc.divisor]
+	if word {
+		result = uint64(uint32(result))
+	}
+	if tc.dest == "R27" {
+		scratch = result
+	}
+	if tc.dest == ZR {
+		result = arm64DivRemDiscard
+	}
+	return result, scratch
+}
+
+func arm64RemainderScratchPrograms(cases []arm64DivRemRuntimeCase) (string, string) {
+	count := len(cases) * 3
+	var goText, cText strings.Builder
+	fmt.Fprintf(&goText, `package main
+func DivideRem(input *[4]uint64, output *[%d]uint64)
+func main() {
+	type row struct { input [4]uint64; want [%d]uint64 }
+	rows := []row{
+`, count, count)
+	fmt.Fprintf(&cText, `#include <stdint.h>
+#include <stdio.h>
+extern void DivideRem(const uint64_t *, uint64_t *);
+struct row { uint64_t input[4]; uint64_t want[%d]; };
+static const struct row rows[] = {
+`, count)
+	for _, input := range arm64DivRemRuntimeInputs() {
+		fmt.Fprintf(&goText, "{input:[4]uint64{%#x,%#x,%#x,%#x}, want:[%d]uint64{", input[0], input[1], input[2], input[3], count)
+		fmt.Fprintf(&cText, "{{UINT64_C(%#x),UINT64_C(%#x),UINT64_C(%#x),UINT64_C(%#x)}, {", input[0], input[1], input[2], input[3])
+		for _, tc := range cases {
+			result, scratch := arm64RemainderScratchExpected(tc, input)
+			flags := arm64DivRemRuntimeFlags(input[2], input[3])
+			fmt.Fprintf(&goText, "%#x,%#x,%#x,", result, scratch, flags)
+			fmt.Fprintf(&cText, "UINT64_C(%#x),UINT64_C(%#x),UINT64_C(%#x),", result, scratch, flags)
+		}
+		goText.WriteString("}},\n")
+		cText.WriteString("}},\n")
+	}
+	fmt.Fprintf(&goText, `
+	}
+	for rowIndex, r := range rows {
+		input := r.input
+		out := struct { left uint64; values [%d]uint64; right uint64 }{
+			left: 0x1122334455667788, right: 0x8877665544332211,
+		}
+		for i := range out.values {
+			out.values[i] = 0xa7a7a7a7a7a7a7a7
+		}
+		DivideRem(&input, &out.values)
+		if input != r.input || out.left != 0x1122334455667788 || out.right != 0x8877665544332211 {
+			panic("remainder input or canary changed")
+		}
+		for index, want := range r.want {
+			if got := out.values[index]; got != want {
+				println(rowIndex, index, got, want)
+				panic("Go pseudo-remainder/R27/NZCV mismatch")
+			}
+		}
+	}
+}
+`, count)
+	fmt.Fprintf(&cText, `
+};
+int main(void) {
+  for (unsigned row = 0; row < sizeof(rows)/sizeof(rows[0]); row++) {
+    uint64_t input[4];
+    struct { uint64_t left; uint64_t values[%d]; uint64_t right; } out;
+    out.left = UINT64_C(0x1122334455667788);
+    out.right = UINT64_C(0x8877665544332211);
+    for (unsigned i = 0; i < 4; i++) input[i] = rows[row].input[i];
+    for (unsigned i = 0; i < %d; i++) out.values[i] = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    DivideRem(input, out.values);
+    if (out.left != UINT64_C(0x1122334455667788) || out.right != UINT64_C(0x8877665544332211)) return 1;
+    for (unsigned i = 0; i < 4; i++) if (input[i] != rows[row].input[i]) return 2;
+    for (unsigned i = 0; i < %d; i++) {
+      if (out.values[i] != rows[row].want[i]) {
+        fprintf(stderr, "row=%%u result=%%u got=%%llx want=%%llx\n", row, i,
+          (unsigned long long)out.values[i], (unsigned long long)rows[row].want[i]);
+        return 3;
+      }
+    }
+  }
+  return 0;
+}
+`, count, count, count)
+	return goText.String(), cText.String()
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RemainderScratch(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	cases := arm64RemainderScratchCases()
+	source := arm64RemainderScratchSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	goSource, cSource := arm64RemainderScratchPrograms(cases)
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	for api, ir := range arm64DivRemRuntimeIRs(t, source, triple, len(cases)*3) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("remainder-scratch-%d", api), triple, ir, cSource, runner)
+	}
+	t.Logf("original Go and three LLVM APIs: %d divide/REM W/X signed/unsigned forms x %d initialized inputs, observable R27/aliases/ZR, preserved NZCV and canaries", len(cases), len(arm64DivRemRuntimeInputs()))
+}
+
+func TestARM64RemainderScratchCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	cases := arm64RemainderScratchCases()
+	source := arm64RemainderScratchSource(cases)
+	requireARM64GoAssemblerResult(t, source, true)
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin",
+		"aarch64-pc-windows-msvc", "aarch64-w64-windows-gnu",
+	} {
+		for api, ir := range arm64DivRemRuntimeIRs(t, source, target, len(cases)*3) {
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("remainder-%d.ll", api), fmt.Sprintf("remainder-%d.o", api), ir)
+		}
+	}
+}
diff --git a/arm64_result_tail_compiler_audit_test.go b/arm64_result_tail_compiler_audit_test.go
new file mode 100644
index 000000000..c747d4f6d
--- /dev/null
+++ b/arm64_result_tail_compiler_audit_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const arm64ResultTailAuditGo = `package tailaudit
+
+func F(ptr *uint32, val uint32) uint32
+
+func Caller(ptr *uint32, val uint32) uint32 {
+	return F(ptr, val)
+}
+`
+
+// This isolates the unchanged native-width result effect from Or32's separate
+// atomic/CPU dispatch. It is not a replacement implementation of Or32.
+const arm64ResultTailAuditASM = `TEXT ·F(SB),4,$0-20
+	MOVD ptr+0(FP),R0
+	MOVW val+8(FP),R1
+	MOVD R1,ret+16(FP)
+	RET
+`
+
+func arm64ResultTailAuditCommand(t *testing.T, goos, dir string, args ...string) []byte {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual Go %s/arm64 %v: %v\n%s", goos, args, err, output)
+	}
+	return output
+}
+
+func arm64ResultTailAuditSection(t *testing.T, listing, name string) string {
+	t.Helper()
+	start := strings.Index(listing, name+" STEXT ")
+	if start < 0 || (start > 0 && listing[start-1] != '\n') {
+		t.Fatalf("actual compiler has no complete TEXT %s:\n%s", name, listing)
+	}
+	rest := listing[start:]
+	if end := regexp.MustCompile(`\n[^\t\n]`).FindStringIndex(rest); end != nil {
+		rest = rest[:end[0]]
+	}
+	return rest
+}
+
+// These are actual compiler observations, not a source-backed permission token.
+// In particular a generated wrapper does not close every assembly caller.
+func TestARM64ABI0ResultTailCompilerCallerObservation(t *testing.T) {
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			dir := t.TempDir()
+			for name, source := range map[string]string{
+				"original.go": arm64ResultTailAuditGo,
+				// Spell the fixture package explicitly. Historical asm -S keeps
+				// the empty package placeholder for ·F despite its -p option;
+				// this changes neither instruction operands nor native bytes.
+				"original.s": strings.Replace(arm64ResultTailAuditASM, "·F", "tailaudit·F", 1),
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			arm64ResultTailAuditCommand(t, goos, dir, "tool", "asm", "-p", "tailaudit",
+				"-gensymabis", "-o", "symabis", "original.s")
+			asm := arm64ResultTailAuditCommand(t, goos, dir, "tool", "asm", "-p", "tailaudit",
+				"-S", "-o", "original.o", "original.s")
+			compiler := arm64ResultTailAuditCommand(t, goos, dir, "tool", "compile", "-p", "tailaudit",
+				"-S", "-symabis", "symabis", "-o", "compiler.o", "original.go")
+
+			section := arm64ResultTailAuditSection(t, string(asm), "tailaudit.F")
+			var code []byte
+			for _, match := range regexp.MustCompile(`(?m)^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`).FindAllStringSubmatch(section, -1) {
+				bytes, err := hex.DecodeString(strings.ReplaceAll(match[1], " ", ""))
+				if err != nil {
+					t.Fatal(err)
+				}
+				code = append(code, bytes...)
+			}
+			// STR X1,[SP,#24] writes the complete native result plus four tail
+			// bytes. The +8 is ARM64's physical saved-link entry offset.
+			if len(code) != 16 || binary.LittleEndian.Uint32(code[8:12]) != 0xf9000fe1 {
+				t.Fatalf("original native store was narrowed or has another source frame: %x\n%s", code, asm)
+			}
+			for _, name := range []string{"tailaudit.F", "tailaudit.Caller"} {
+				body := arm64ResultTailAuditSection(t, string(compiler), name)
+				frame := regexp.MustCompile(`\tTEXT\t` + regexp.QuoteMeta(name) + `\(SB\),[^\n]*\$([0-9]+)-16\n`).FindStringSubmatch(body)
+				if frame == nil {
+					t.Fatalf("actual %s has no bound caller TEXT frame:\n%s", name, body)
+				}
+				bytes, err := strconv.ParseInt(frame[1], 10, 64)
+				if err != nil || bytes < 32 || bytes > 4096 ||
+					!strings.Contains(body, fmt.Sprintf("\tMOVD.W\tR30, -%d(RSP)\n", bytes)) {
+					t.Fatalf("actual %s does not allocate its complete physical outgoing store envelope [24,32):\n%s", name, body)
+				}
+				for _, instruction := range []string{
+					"MOVD\tR0, 8(RSP)", "MOVW\tR1, 16(RSP)",
+					"CALL\ttailaudit.F(SB)", "MOVWU\t24(RSP), R0",
+				} {
+					if !strings.Contains(body, "\t"+instruction+"\n") {
+						t.Fatalf("actual %s does not supply the observed ABI0 caller mapping %q:\n%s", name, instruction, body)
+					}
+				}
+				t.Logf("actual %s source-bound listing:\n%s", name, body)
+			}
+			for _, name := range []string{"original.o", "compiler.o", "symabis"} {
+				data, err := os.ReadFile(filepath.Join(dir, name))
+				if err != nil || len(data) == 0 {
+					t.Fatalf("missing actual %s: %v", name, err)
+				}
+				t.Logf("actual %s bytes=%d SHA256=%x", name, len(data), sha256.Sum256(data))
+			}
+			t.Logf("original native code=%x; declared result [16,20), physical native store [16,24); no frame permission", code)
+		})
+	}
+}
+
+func arm64ResultTailAuditTranslate(t *testing.T, api, target, declaration, source string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "tailaudit", "package tailaudit\n"+declaration)
+	resolve := testResolveSym(pkg.Path)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOOS: "linux", GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			ir := translated.Module.String()
+			translated.Module.Dispose()
+			return ir, err
+		}
+		return "", err
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		ir := module.String()
+		module.Dispose()
+		return ir, err
+	}
+	return "", err
+}
+
+func TestARM64ABI0ResultTailAllocationIsNotSlotPermission(t *testing.T) {
+	for _, test := range []struct {
+		name, declaration, source string
+	}{
+		{"original Or32 result width", "func F(ptr *uint32,val uint32) uint32\n", arm64ResultTailAuditASM},
+		{"aligned TEXT", "func F(ptr *uint32,val uint32) uint32\n", strings.Replace(arm64ResultTailAuditASM, "$0-20", "$0-24", 1)},
+		{"beyond aligned end", "func F(ptr *uint32,val uint32) uint32\n", strings.Replace(arm64ResultTailAuditASM, "ret+16", "ret+20", 1)},
+		{"result interior gap", "func F() (a uint8,b uint64)\n", "TEXT ·F(SB),4,$0-16\nMOVD $1,R0\nMOVD R0,a+0(FP)\nMOVD R0,b+8(FP)\nRET\n"},
+		{"argument gap", "func F(a uint8,b uint64) uint64\n", "TEXT ·F(SB),4,$0-24\nMOVD a+0(FP),R0\nMOVD R0,ret+16(FP)\nRET\n"},
+		{"escaped tail address", "func F(ptr *uint32,val uint32) uint32\n", "TEXT ·F(SB),4,$0-20\nMOVD $ret+20(FP),R0\nMOVD R0,ret+16(FP)\nRET\n"},
+	} {
+		for _, target := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+			"aarch64-pc-windows-msvc", "aarch64-unknown-freebsd",
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", test.name, target, api), func(t *testing.T) {
+					if _, err := arm64ResultTailAuditTranslate(t, api, target, test.declaration, test.source); err == nil {
+						t.Fatal("ABI allocation or a type-only declaration fabricated padding/address permission")
+					} else if !strings.Contains(err.Error(), "FP") {
+						t.Fatalf("unrelated error does not establish the frame boundary: %v", err)
+					} else {
+						t.Logf("original boundary remains rejected: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ABI0ResultTailAdjacentDeclaredResultsAreNotPadding(t *testing.T) {
+	const declaration = "func F(ptr *uint32,val uint32) (lo uint32,hi uint32)\n"
+	const source = "TEXT ·F(SB),4,$0-24\nMOVD $0x123456789abcdef0,R0\nMOVD R0,lo+16(FP)\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-pc-windows-msvc", "aarch64-unknown-freebsd",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target+"/"+api, func(t *testing.T) {
+				ir, err := arm64ResultTailAuditTranslate(t, api, target, declaration, source)
+				if err != nil {
+					t.Fatalf("two actual adjacent uint32 results must retain every native byte: %v", err)
+				}
+				compileLLVMToObject(t, llc, target, "declared-results.ll", "declared-results.o", ir)
+			})
+		}
+	}
+}
diff --git a/arm64_result_tail_native_observer_test.go b/arm64_result_tail_native_observer_test.go
new file mode 100644
index 000000000..48768f244
--- /dev/null
+++ b/arm64_result_tail_native_observer_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64NativeResultTailCase struct {
+	op                    Op
+	resultBits, storeBits int
+}
+
+// These are the complete wider-than-result combinations of Go's seven scalar
+// memory moves. The assembler checks the original widths independently.
+func arm64NativeResultTailCases() []arm64NativeResultTailCase {
+	var cases []arm64NativeResultTailCase
+	for _, row := range []struct {
+		op   Op
+		bits int
+	}{
+		{"MOVB", 8}, {"MOVBU", 8}, {"MOVH", 16}, {"MOVHU", 16},
+		{"MOVW", 32}, {"MOVWU", 32}, {"MOVD", 64},
+	} {
+		for _, resultBits := range []int{8, 16, 32} {
+			if row.bits > resultBits {
+				cases = append(cases, arm64NativeResultTailCase{
+					op: row.op, resultBits: resultBits, storeBits: row.bits,
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func (test arm64NativeResultTailCase) name() string {
+	return fmt.Sprintf("%s_u%d", test.op, test.resultBits)
+}
+
+func (test arm64NativeResultTailCase) declaration() string {
+	return fmt.Sprintf("func %s(input uint64) (result uint%d)\n", test.name(), test.resultBits)
+}
+
+func (test arm64NativeResultTailCase) source() string {
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n"+
+		"MOVD input+0(FP),R0\n%s R0,result+8(FP)\nRET\n",
+		test.name(), 8+test.resultBits/8, test.op)
+}
+
+func arm64NativeResultTailObserver(test arm64NativeResultTailCase) string {
+	return fmt.Sprintf(`
+TEXT ·observe_%s(SB),4,$48-32
+    MOVD input+0(FP),R0
+    MOVD R0,8(RSP)
+    MOVD $0xfeedfacecafebeef,R1
+    MOVD R1,16(RSP)
+    MOVD $0x7ac35ef012345678,R1
+    MOVD R1,24(RSP)
+    CALL ·%s(SB)
+    MOVD 16(RSP),R0
+    MOVD R0,native+16(FP)
+    %s 16(RSP),R0
+    MOVD R0,value+8(FP)
+    MOVD 24(RSP),R0
+    MOVD R0,guard+24(FP)
+    RET
+`, test.name(), test.name(), map[int]string{8: "MOVBU", 16: "MOVHU", 32: "MOVWU"}[test.resultBits])
+}
+
+func TestARM64NativeResultTailExactDeclaredWidthObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	source := "TEXT ·Exact(SB),4,$0-16\n" +
+		"MOVD input+0(FP),R0\nMOVD R0,result+8(FP)\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	pkg := mustGoPackage(t, "tailobserve", "package tailobserve\nfunc Exact(input uint64) (result uint64)\n")
+	resolve := testResolveSym(pkg.Path)
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				var ir string
+				var failure error
+				if api == "Go" {
+					translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+						GOOS: "linux", GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+					})
+					if translated != nil && !translated.Module.IsNil() {
+						ir = translated.Module.String()
+						translated.Module.Dispose()
+					}
+					failure = err
+				} else {
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					signatures, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{
+						Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: signatures,
+					}
+					if api == "text" {
+						ir, failure = Translate(file, options)
+					} else {
+						module, err := TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							ir = module.String()
+							module.Dispose()
+						}
+						failure = err
+					}
+				}
+				if failure != nil {
+					t.Fatalf("exact declared native width lost its ordinary contract: %v", failure)
+				}
+				compileLLVMToObject(t, llc, triple, "exact-result.ll", "exact-result.o", ir)
+			})
+		}
+	}
+}
+
+// A callee-only type snapshot cannot prove that the native result tail is
+// unobservable. In particular KeepFunc must not make a caller disappear from
+// the proof boundary. Neither a code address nor a DATA reference closes it.
+func TestARM64NativeResultTailNeedsCallerContract(t *testing.T) {
+	cases := arm64NativeResultTailCases()
+	if len(cases) != 9 {
+		t.Fatalf("complete scalar-width family changed: %d", len(cases))
+	}
+	for _, test := range cases {
+		t.Run(test.name(), func(t *testing.T) {
+			for _, scope := range []string{"isolated", "dropped-caller", "dropped-code-address", "data-code-address"} {
+				declarations := "package tailobserve\n" + test.declaration()
+				source := test.source()
+				switch scope {
+				case "dropped-caller":
+					declarations += fmt.Sprintf("func observe_%s(input uint64) (value, native, guard uint64)\n", test.name())
+					source += arm64NativeResultTailObserver(test)
+				case "dropped-code-address":
+					declarations += "func Address() (result uint64)\n"
+					source += fmt.Sprintf("TEXT ·Address(SB),4,$0-8\n"+
+						"MOVD $·%s(SB),R0\nMOVD R0,result+0(FP)\nRET\n", test.name())
+				case "data-code-address":
+					source += fmt.Sprintf("DATA root<>+0(SB)/8,$·%s(SB)\nGLOBL root<>(SB),8,$8\n", test.name())
+				}
+				t.Run(scope, func(t *testing.T) {
+					requireARM64GoAssemblerResult(t, source, true)
+					pkg := mustGoPackage(t, "tailobserve", declarations)
+					resolve := testResolveSym(pkg.Path)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							var failure error
+							if api == "Go" {
+								translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+									GOOS: "linux", GOARCH: "arm64", TargetTriple: arm64LinuxGNUTriple,
+									ResolveSym: resolve,
+									KeepFunc: func(symbol, _ string) bool {
+										return symbol == "·"+test.name()
+									},
+								})
+								if translated != nil && !translated.Module.IsNil() {
+									translated.Module.Dispose()
+								}
+								failure = err
+							} else {
+								file, err := Parse(ArchARM64, source)
+								if err != nil {
+									t.Fatal(err)
+								}
+								signatures, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+								if err != nil {
+									t.Fatal(err)
+								}
+								// The low-level API is likewise given only the selected root.
+								// Dropping an observer never proves it cannot observe the tail.
+								file.Funcs = file.Funcs[:1]
+								options := Options{
+									Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+									ResolveSym: resolve, Sigs: signatures,
+								}
+								if api == "text" {
+									_, failure = Translate(file, options)
+								} else {
+									module, err := TranslateModuleInContext(ctx, file, options)
+									if !module.IsNil() {
+										module.Dispose()
+									}
+									failure = err
+								}
+							}
+							if failure == nil {
+								t.Fatal("callee-only declaration discarded an observable native result-tail write")
+							}
+							if !errors.Is(failure, ErrProbeNeedsContext) &&
+								!(strings.Contains(failure.Error(), "FP frame range") &&
+									strings.Contains(failure.Error(), "has no slot")) {
+								t.Fatalf("unrelated rejection cannot prove the native-tail boundary: %v", failure)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_result_tail_native_runtime_test.go b/arm64_result_tail_native_runtime_test.go
new file mode 100644
index 000000000..eb7ec51f5
--- /dev/null
+++ b/arm64_result_tail_native_runtime_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This is an observation of the unchanged original Go caller and callee, not
+// an LLVM projection oracle. Native padding writes are separately observable.
+func TestCrossLinuxRuntimeMatrixARM64NativeResultTailObserver(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	var declarations, assembly, driver strings.Builder
+	declarations.WriteString("package main\n\n")
+	driver.WriteString("package main\n\nimport \"fmt\"\n\n")
+	cases := arm64NativeResultTailCases()
+	for _, test := range cases {
+		declarations.WriteString(test.declaration())
+		fmt.Fprintf(&declarations, "func observe_%s(input uint64) (value, native, guard uint64)\n", test.name())
+		assembly.WriteString(test.source())
+		assembly.WriteString(arm64NativeResultTailObserver(test))
+	}
+	driver.WriteString("func main() {\n    inputs := []uint64{\n")
+	for _, value := range arm64PaddingRuntimeInputs() {
+		fmt.Fprintf(&driver, "        0x%x,\n", value)
+	}
+	driver.WriteString("    }\n    observations := 0\n")
+	for _, test := range cases {
+		resultMask := ^uint64(0) >> uint(64-test.resultBits)
+		storeMask := ^uint64(0) >> uint(64-test.storeBits)
+		fmt.Fprintf(&driver, `    for _, input := range inputs {
+        value, native, guard := observe_%s(input)
+        wantValue := input & 0x%x
+        wantNative := (uint64(0xfeedfacecafebeef) &^ uint64(0x%x)) | (input & 0x%x)
+        if value != wantValue || native != wantNative || guard != 0x7ac35ef012345678 {
+            panic(fmt.Sprintf("%s input=%%x value=%%x native=%%x guard=%%x", input, value, native, guard))
+        }
+        observations++
+    }
+`, test.name(), resultMask, storeMask, storeMask, test.name())
+	}
+	driver.WriteString("    fmt.Printf(\"native tail observations %d\\n\", observations)\n}\n")
+
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module tailobserve\n\ngo 1.20\n",
+		"decl.go": declarations.String(), "main.go": driver.String(),
+		"tailobserve_arm64.s": assembly.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	args := []string{"run", "-p=1"}
+	if len(runner) != 0 {
+		quoted, err := arm64PaddingGoExecArguments(runner)
+		if err != nil {
+			t.Fatal(err)
+		}
+		args = append(args, "-exec="+quoted)
+	}
+	command := exec.CommandContext(ctx, "go", append(args, ".")...)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "CGO_ENABLED=0", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	if len(runner) != 0 {
+		command.Env = append(command.Env, "GOOS=linux")
+	}
+	out, err := runtimeOracleCombinedOutput(ctx, command)
+	want := fmt.Sprintf("native tail observations %d\n", len(cases)*len(arm64PaddingRuntimeInputs()))
+	if err != nil || string(out) != want {
+		t.Fatalf("original Go result, observable native tail, and adjacent canary: %v\n%s", err, out)
+	}
+	t.Logf("%d original Go observations establish native-tail visibility, not LLVM equivalence",
+		len(cases)*len(arm64PaddingRuntimeInputs()))
+}
diff --git a/arm64_result_tail_sdk_audit_go127_test.go b/arm64_result_tail_sdk_audit_go127_test.go
new file mode 100644
index 000000000..4d256db1b
--- /dev/null
+++ b/arm64_result_tail_sdk_audit_go127_test.go
@@ -0,0 +1,95 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Or32 is absent from Go 1.20. The cross-SDK first-party caller/ASM observation
+// is untagged; this separate current-source root binds the real benchmark origin.
+func TestARM64ABI0ResultTailCurrentSDKPublicBoundary(t *testing.T) {
+	read := func(name string) string {
+		t.Helper()
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(name)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("actual SDK source %s bytes=%d SHA256=%x", name, len(data), sha256.Sum256(data))
+		return string(data)
+	}
+	goSource := read("internal/runtime/atomic/atomic_arm64.go")
+	parsed, err := parser.ParseFile(token.NewFileSet(), "atomic_arm64.go", goSource, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var count int
+	for _, node := range parsed.Decls {
+		decl, ok := node.(*ast.FuncDecl)
+		if !ok || decl.Name.Name != "Or32" {
+			continue
+		}
+		count++
+		if decl.Body != nil || decl.Recv != nil || decl.Type.Params == nil || decl.Type.Results == nil ||
+			len(decl.Type.Params.List) != 2 || len(decl.Type.Results.List) != 1 {
+			t.Fatal("actual Or32 bodyless ABI declaration changed")
+		}
+		pointer, ok := decl.Type.Params.List[0].Type.(*ast.StarExpr)
+		if !ok {
+			t.Fatal("actual Or32 first parameter is no longer *uint32")
+		}
+		for _, typ := range []ast.Expr{pointer.X, decl.Type.Params.List[1].Type, decl.Type.Results.List[0].Type} {
+			identifier, ok := typ.(*ast.Ident)
+			if !ok || identifier.Name != "uint32" {
+				t.Fatal("actual Or32 uint32 language identity changed")
+			}
+		}
+	}
+	if count != 1 {
+		t.Fatalf("actual Or32 declaration count=%d, want one", count)
+	}
+
+	assembly := read("internal/runtime/atomic/atomic_arm64.s")
+	start := strings.Index(assembly, "TEXT ·Or32(SB), NOSPLIT, $0-20\n")
+	if start < 0 {
+		t.Fatal("original Or32 TEXT/frame source changed")
+	}
+	body := assembly[start:]
+	if next := strings.Index(body[1:], "\nTEXT "); next >= 0 {
+		body = body[:next+1]
+	}
+	if strings.Count(body, "ret+16(FP)") != 2 ||
+		!strings.Contains(body, "MOVD\tR2, ret+16(FP)") ||
+		!strings.Contains(body, "MOVD R2, ret+16(FP)") {
+		t.Fatal("both original Or32 paths must retain their native eight-byte result store")
+	}
+	t.Logf("original Or32 source, not a translated success:\n%s", body)
+
+	linknames := read("internal/runtime/atomic/linkname.go")
+	if strings.Count(linknames, "//go:linknamestd Or32\n") != 1 {
+		t.Fatal("original public linkname boundary changed; re-audit caller closure")
+	}
+	callers := read("sync/atomic/asm.s")
+	for _, name := range []string{"OrInt32", "OrUint32"} {
+		start := strings.Index(callers, "TEXT ·"+name+"(SB),NOSPLIT,$0\n")
+		if start < 0 {
+			t.Fatalf("original assembly caller %s changed", name)
+		}
+		body := callers[start:]
+		if next := strings.Index(body[1:], "\nTEXT "); next >= 0 {
+			body = body[:next+1]
+		}
+		if strings.Count(body, "\tJMP\tinternal∕runtime∕atomic·Or32(SB)\n") != 1 {
+			t.Fatalf("original %s no longer has its source-bound ASM tail caller", name)
+		}
+		t.Logf("original assembly entry remains outside a generated Go wrapper's closure:\n%s", body)
+	}
+}
diff --git a/arm64_ret_fallback_test.go b/arm64_ret_fallback_test.go
index 4afd92579..ce9426615 100644
--- a/arm64_ret_fallback_test.go
+++ b/arm64_ret_fallback_test.go
@@ -1,53 +1,125 @@
 package plan9asm
 
 import (
+	"errors"
+	"go/types"
 	"strings"
 	"testing"
 )
 
-func translateARM64WithSig(t *testing.T, src string, sig FuncSig, resolvedName string) string {
-	t.Helper()
-	file, err := Parse(ArchARM64, src)
-	if err != nil {
-		t.Fatalf("parse asm: %v", err)
-	}
-	resolve := func(sym string) string {
-		sym = strings.TrimSuffix(sym, "<ABIInternal>")
-		sym = strings.TrimSuffix(sym, "<>")
-		if strings.HasPrefix(sym, "·") {
-			return resolvedName
+const arm64RetArgSource = `
+TEXT ·RetArg<ABIInternal>(SB),NOSPLIT,$0-16
+	RET
+`
+
+func TestCrossLinuxRuntimeMatrixARM64ReturnFallbackGoOracle(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	// This trusted assembler identity permits the explicit source selector;
+	// the ordinary Go compiler still uses the real declaration and symabis.
+	runARM64GoInternalOracle(t, "#include \"textflag.h\"\n"+arm64RetArgSource, `package main
+func RetArg(uint64) uint64
+func main() {
+	for _, input := range []uint64{0, 1, 123, 0x8000000000000000, ^uint64(0)} {
+		if RetArg(input) != input {
+			panic("ABIInternal unmodified R0 result mismatch")
 		}
-		return sym
 	}
-	sig.Name = resolvedName
-	ll, err := Translate(file, Options{
-		ResolveSym: resolve,
-		Sigs:       map[string]FuncSig{resolvedName: sig},
-		Goarch:     "arm64",
+}
+`, len(runner) != 0)
+	const main = `#include <stdint.h>
+extern uint64_t retArg(uint64_t);
+int main(void) {
+	uint64_t inputs[] = {0, 1, 123, UINT64_C(0x8000000000000000), UINT64_MAX};
+	for (unsigned i = 0; i < 5; i++) {
+		if (retArg(inputs[i]) != inputs[i]) return 1;
+	}
+	return 0;
+}
+`
+	const shim = `
+define i64 @retArg(i64 %input) {
+  %result = call i64 @test.RetArg(i64 %input)
+  ret i64 %result
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "ret_arg_internal", triple, translateARM64RetArgWithGoContract(t, triple)+shim, main, runner)
+}
+
+func translateARM64RetArgWithGoContract(t *testing.T, triple string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "test", "package test\nfunc RetArg(uint64) uint64\n")
+	tr, err := TranslateGoModule(pkg, []byte(arm64RetArgSource), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(sym string) string { return "test." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
 	})
 	if err != nil {
 		t.Fatalf("translate: %v", err)
 	}
-	return ll
+	defer tr.Module.Dispose()
+	sig := tr.Signatures["test.RetArg"]
+	if sig.ARM64GoRegisterABI == nil {
+		t.Fatal("source ABIInternal selector and real declaration did not derive an entry contract")
+	}
+	if len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 8 {
+		t.Fatalf("expected the declaration-backed, unwritten result slot at FP+8: %+v", sig.Frame)
+	}
+	return tr.Module.String()
 }
 
 func TestARM64ReturnFallbackToRegisterWhenResultSlotNotWritten(t *testing.T) {
-	src := `
-TEXT ·RetArg<ABIInternal>(SB),NOSPLIT,$0-16
-	RET
-`
-	sig := FuncSig{
-		Args: []LLVMType{I64},
-		Ret:  I64,
-		Frame: FrameLayout{
-			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
-		},
-	}
-	ll := translateARM64WithSig(t, src, sig, "test.RetArg")
-	if strings.Contains(ll, "ret i64 0") {
-		t.Fatalf("unexpected zero return when result slot is not written:\n%s", ll)
-	}
-	if !strings.Contains(ll, "ret i64 %") {
-		t.Fatalf("expected register-based non-constant return:\n%s", ll)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(target, func(t *testing.T) {
+			ll := translateARM64RetArgWithGoContract(t, target)
+			if strings.Contains(ll, "ret i64 0") {
+				t.Fatalf("unexpected zero return when result slot is not written:\n%s", ll)
+			}
+			if !strings.Contains(ll, "ret i64 %") {
+				t.Fatalf("expected register-based non-constant return:\n%s", ll)
+			}
+			compileLLVMToObject(t, llc, target, "ret_arg.ll", "ret_arg.o", ll)
+		})
+	}
+}
+
+func TestARM64ReturnFallbackNeedsCompleteEntryContract(t *testing.T) {
+	pkg := mustGoPackage(t, "test", "package test\nfunc RetArg(uint64) uint64\n")
+	for _, declared := range []bool{false, true} {
+		sig := FuncSig{
+			Name: "test.RetArg", Args: []LLVMType{I64}, Ret: I64,
+			Frame: FrameLayout{
+				Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+			},
+		}
+		if declared {
+			var err error
+			sig, err = goFuncSigForDeclaredFunc("test.RetArg", pkg.Types.Scope().Lookup("RetArg").(*types.Func), "arm64", nil, nil, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+		for _, target := range []string{
+			"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+			"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+		} {
+			file, err := Parse(ArchARM64, arm64RetArgSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				Goarch: "arm64", TargetTriple: target,
+				ResolveSym: func(sym string) string { return "test." + strings.TrimPrefix(goStripABISuffix(sym), "·") },
+				Sigs:       map[string]FuncSig{"test.RetArg": sig},
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "complete typed register contract") {
+				t.Errorf("%s declared=%t: missing entry contract must remain Context, got %v", target, declared, err)
+			}
+		}
 	}
 }
diff --git a/arm64_ret_source_width.go b/arm64_ret_source_width.go
new file mode 100644
index 000000000..2e8fb86c5
--- /dev/null
+++ b/arm64_ret_source_width.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import "strings"
+
+// Source RET is expanded by Go obj7 before encoding. Only raw AWORD RET is
+// always one instruction. The source leaf/frame contract must be inspected
+// before any raw AWORD BL has been rewritten into a semantic BL instruction.
+func arm64SourceReturnWidth(fn Func, ins Instr) (int64, bool) {
+	if ins.Op != OpRET || len(ins.Args) > 1 {
+		return 0, false
+	}
+	if len(ins.Args) == 1 {
+		target := ins.Args[0]
+		switch target.Kind {
+		case OpReg:
+			if !isARM64GeneralOrZeroReg(target.Reg) && target.Reg != SP && target.Reg != "RSP" {
+				return 0, false
+			}
+		case OpMem:
+			if !isARM64GeneralOrZeroReg(target.Mem.Base) && target.Mem.Base != SP && target.Mem.Base != "RSP" {
+				return 0, false
+			}
+		case OpSym:
+			if !strings.HasSuffix(target.Sym, "(SB)") {
+				return 0, false
+			}
+		default:
+			return 0, false
+		}
+	}
+	// Go's autosize is int32. Stay within its non-overflowing, aligned range;
+	// invalid declarations cannot establish a raw instruction boundary.
+	if fn.FrameSize < 0 && fn.FrameSize != -8 || fn.FrameSize > (1<<31)-25 || fn.FrameSize&7 != 0 {
+		return 0, false
+	}
+	if !arm64SourceFrameFlagsKnown(fn) {
+		return 0, false
+	}
+	frame := arm64SourceGoFrame(fn)
+	if !frame.present {
+		return 4, fn.FrameSize <= 0
+	}
+	autosize := arm64SourceFrameAutosize(fn.FrameSize)
+	if autosize <= 0 || autosize >= 1<<12 {
+		// Large source epilogues differ across supported Go encoders. A
+		// parsed Func has no sealed original SDK identity, so neither a host
+		// version nor a current obj7 expansion can establish their width.
+		return 0, false
+	}
+	// In the common Go 1.20–1.27 small-frame domain, both the leaf and
+	// nonleaf expansions are two one-word frame operations plus a one-word
+	// branch. Their order and return-register semantics are not certified by
+	// this width proof. It grants only a raw source-layout boundary.
+	return 12, true
+}
+
+// Call only after checking the source's framed, aligned int32 Go contract.
+// obj7 reserves the LR and pads the top of this native frame for the old BP.
+func arm64SourceFrameAutosize(frameSize int64) int64 {
+	autosize := frameSize + 8
+	if autosize&15 == 8 {
+		autosize += 8
+	} else {
+		autosize += 16
+	}
+	return autosize
+}
+
+func arm64SourceFrameFlagsKnown(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpTEXT {
+			continue
+		}
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) == 2 {
+			return true
+		}
+		if len(parts) != 3 {
+			return false
+		}
+		if _, resolved := parseImmExpr(strings.TrimSpace(parts[1])); resolved {
+			return true
+		}
+		// Canonical textflag.h names have known NOFRAME membership. An
+		// unresolved user flag may contain NOFRAME and cannot fix the width.
+		for _, flag := range strings.Split(parts[1], "|") {
+			switch strings.TrimSpace(flag) {
+			case "NOPROF", "DUPOK", "NOSPLIT", "RODATA", "NOPTR", "WRAPPER", "NEEDCTXT", "TLSBSS", "NOFRAME", "REFLECTMETHOD", "TOPFRAME", "ABIWRAPPER":
+			default:
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
diff --git a/arm64_ret_source_width_test.go b/arm64_ret_source_width_test.go
new file mode 100644
index 000000000..c298ffe65
--- /dev/null
+++ b/arm64_ret_source_width_test.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestARM64RawSourceRETWidthMatchesGoObjects(t *testing.T) {
+	type fixture struct {
+		name                string
+		fn                  Func
+		ret                 Instr
+		retLine, markerLine int
+	}
+	var source strings.Builder
+	var fixtures []fixture
+	line := 1
+	for _, header := range []struct {
+		flags int
+		frame int64
+	}{
+		{4, -8}, {4, 0}, {516, 0}, {4, 8}, {4, 32}, {4, 240}, {4, 4080},
+		{4, 4096}, {4, 65536}, {4, 1 << 20}, {4, 1 << 30},
+	} {
+		for _, call := range []string{"", "BL anchor(SB)", "CALL anchor(SB)", "WORD $0x94000000", "WORD $0xd63f0000"} {
+			for _, ret := range []string{"RET", "RET R30", "RET R0", "RET (R30)", "RET 8(R30)", "RET anchor(SB)"} {
+				name := fmt.Sprintf("retWidth%d", len(fixtures))
+				body := fmt.Sprintf("TEXT %s(SB),%d,$%d-0\n", name, header.flags, header.frame)
+				if call != "" {
+					body += call + "\n"
+				}
+				retLine := line + strings.Count(body, "\n")
+				body += ret + "\nWORD $0xd503201f\n"
+				file, err := Parse(ArchARM64, body)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				fixtures = append(fixtures, fixture{name, fn, fn.Instrs[len(fn.Instrs)-2], retLine, retLine + 1})
+				source.WriteString(body)
+				line += strings.Count(body, "\n")
+			}
+		}
+	}
+	source.WriteString("TEXT anchor(SB),4,$0-0\nRET\n")
+	positions := arm64RETObjectPositions(t, "ret-width", source.String())
+	type crossing struct {
+		fn                     Func
+		branchLine, markerLine int
+		displacement           int64
+		bound                  bool
+	}
+	var crossSource strings.Builder
+	var crossings []crossing
+	line = 1
+	bound, unbound := 0, 0
+	for _, fixture := range fixtures {
+		start, startOK := positions[fixture.retLine]
+		end, endOK := positions[fixture.markerLine]
+		if !startOK || !endOK || end <= start {
+			t.Fatalf("missing RET object span for %s: %d..%d", fixture.name, start, end)
+		}
+		got, known := arm64RawKnownSourceWidth(fixture.fn, fixture.ret)
+		wantBound := fixture.fn.FrameSize <= 240
+		if known != wantBound || known && got != end-start {
+			t.Errorf("%s %s: unbound-source width=(%d,%v), common-domain bound=%v, actual Go object=%d bytes", fixture.fn.Instrs[0].Raw, fixture.ret.Raw, got, known, wantBound, end-start)
+		}
+		if wantBound {
+			bound++
+		} else {
+			unbound++
+		}
+
+		// A second actual Go source puts a literal branch immediately before
+		// RET. Its displacement comes only from the independently measured
+		// object above, not from the translator's unbound width estimate.
+		displacement := end - start + 4
+		word := uint32(0x14000000) | uint32(displacement/4)
+		var body strings.Builder
+		branchLine := 0
+		for index, ins := range fixture.fn.Instrs {
+			if index == len(fixture.fn.Instrs)-2 {
+				branchLine = line + strings.Count(body.String(), "\n")
+				fmt.Fprintf(&body, "WORD $0x%08x\n", word)
+			}
+			fmt.Fprintln(&body, ins.Raw)
+		}
+		file, err := Parse(ArchARM64, body.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		crossings = append(crossings, crossing{file.Funcs[0], branchLine, branchLine + 2, displacement, wantBound})
+		crossSource.WriteString(body.String())
+		line += strings.Count(body.String(), "\n")
+	}
+	if len(fixtures) != 330 || bound != 180 || unbound != 150 {
+		t.Fatalf("RET matrix denominator changed: total=%d bound=%d unbound=%d", len(fixtures), bound, unbound)
+	}
+	crossSource.WriteString("TEXT anchor(SB),4,$0-0\nRET\n")
+	crossPositions := arm64RETObjectPositions(t, "ret-crossing", crossSource.String())
+	for _, cross := range crossings {
+		start, startOK := crossPositions[cross.branchLine]
+		end, endOK := crossPositions[cross.markerLine]
+		if !startOK || !endOK || end-start != cross.displacement {
+			t.Fatalf("actual cross-RET branch is not bound to its object marker: %s %d..%d, displacement=%d", cross.fn.Sym, start, end, cross.displacement)
+		}
+		_, err := normalizeARM64RawPCRelative(cross.fn)
+		if cross.bound && err != nil {
+			t.Errorf("common-domain source branch lost its proven boundary: %s: %v", cross.fn.Sym, err)
+		}
+		if !cross.bound && (err == nil || !strings.Contains(err.Error(), "proven instruction boundary")) {
+			t.Errorf("unbound source RET encoder admitted an actual cross-RET branch: %s: %v", cross.fn.Sym, err)
+		}
+	}
+	t.Logf("all %d actual object RET spans measured; %d common-domain widths/crossings match, %d unbound actual source crossings reject; RET R0 width does not certify its SDK-specific target semantics", len(fixtures), bound, unbound)
+}
+
+func arm64RETObjectPositions(t *testing.T, name, source string) map[int]int64 {
+	t.Helper()
+	dir := t.TempDir()
+	asm := filepath.Join(dir, name+".s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-o", filepath.Join(dir, name+".o"), asm)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	listing, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil {
+		t.Fatalf("Go assembler RET object oracle: %v\n%s", err, listing)
+	}
+	positions := make(map[int]int64)
+	rows := regexp.MustCompile(`(?m)^\s*0x([0-9a-f]+)\s+\d+\s+\([^\n]+:(\d+)\)\s+[A-Z]`)
+	for _, row := range rows.FindAllStringSubmatch(string(listing), -1) {
+		pc, err := strconv.ParseInt(row[1], 16, 64)
+		if err != nil {
+			t.Fatal(err)
+		}
+		line, err := strconv.Atoi(row[2])
+		if err != nil {
+			t.Fatal(err)
+		}
+		if old, exists := positions[line]; !exists || pc < old {
+			positions[line] = pc
+		}
+	}
+	return positions
+}
+
+func TestARM64RawSourceRETWidthFailsClosed(t *testing.T) {
+	for _, source := range []string{
+		"TEXT badWidth(SB),4,$3-0\nRET\n",
+		"TEXT badWidth(SB),4,$-16-0\nRET\n",
+		"TEXT badWidth(SB),516,$8-0\nRET\n",
+		"TEXT badWidth(SB),UNKNOWN_FLAGS,$0-0\nCALL anchor(SB)\nRET\n",
+		"TEXT badWidth(SB),4,$0-0\nRET F0\n",
+		"TEXT badWidth(SB),4,$0-0\nRET.P R30\n",
+	} {
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		fn := file.Funcs[0]
+		if width, known := arm64RawKnownSourceWidth(fn, fn.Instrs[len(fn.Instrs)-1]); known {
+			t.Fatalf("invalid/unresolved RET source established a %d-byte boundary: %s", width, source)
+		}
+	}
+	for _, frame := range []int64{1<<31 - 8, 1 << 32, 1 << 62} {
+		file, err := Parse(ArchARM64, fmt.Sprintf("TEXT unknownWidth(SB),4,$%d-0\nRET\n", frame))
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := file.Funcs[0]
+		if width, known := arm64RawKnownSourceWidth(fn, fn.Instrs[1]); known {
+			t.Fatalf("overflowing Go int32 autosize established a %d-byte boundary", width)
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64RawBranchCrossesSourceRET(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, frame := range []int{0, 8, 32, 240} {
+		for _, call := range []string{"", "BL ·widthVoid(SB)", "CALL ·widthVoid(SB)", "rawBL", "rawBLR"} {
+			name := fmt.Sprintf("retWidthRuntime%d", index)
+			index++
+			retWidth := 12
+			if frame == 0 && (call == "" || strings.HasPrefix(call, "raw")) {
+				retWidth = 4
+			}
+			body := call
+			if strings.HasPrefix(call, "raw") {
+				link := "WORD $0x97ffffff"
+				if call == "rawBLR" {
+					link = "ADR helper,R9\nWORD $0xd63f0120"
+				}
+				body = "MOVD R30,R22\nB callsite\nhelper:\nB (R30)\ncallsite:\n" + link + "\nMOVD R22,R30"
+			}
+			fmt.Fprintf(&source, `TEXT ·%s(SB),4,$%d-16
+%s
+MOVD a+0(FP),R0
+WORD $%#08x
+RET
+finish:
+WORD $0x91002c00
+MOVD R0,ret+8(FP)
+RET
+`, name, frame, body, 0x14000000+uint32((retWidth+4)/4))
+			sigs[name] = arm64LocalRegisterBranchSig(name)
+			fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+			fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+			fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		println(got)
+		panic("raw branch across source RET mismatch")
+	}
+}
+`, name)
+			fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"raw branch across source RET mismatch\n");
+		return 1;
+	}
+}
+`, name)
+		}
+	}
+	source.WriteString("TEXT ·widthVoid(SB),4,$0-0\nRET\n")
+	goDecl.WriteString("func widthVoid()\n")
+	sigs["widthVoid"] = FuncSig{Name: "widthVoid", Ret: Void}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, target, "ret-width-runtime.ll", "ret-width-runtime.o", ir)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){ uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "ret_width_runtime", triple, ir, main, runner)
+	t.Logf("%d raw branch across source RET fixtures x 5 inputs passed native Go and LLVM22, plus four-target objects", index)
+}
diff --git a/arm64_ret_unbound_source_test.go b/arm64_ret_unbound_source_test.go
new file mode 100644
index 000000000..29eeb5a82
--- /dev/null
+++ b/arm64_ret_unbound_source_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64UnboundRETWidthRejectsSDKDependentRawBranches(t *testing.T) {
+	// The two SDKs encode these source epilogues differently. Neither actual
+	// object observation identifies the encoder of an arbitrary parsed Func.
+	for _, test := range []struct {
+		frame int
+		call  string
+		span  int
+	}{
+		{4080, "CALL anchor(SB)\n", 12},
+		{4080, "CALL anchor(SB)\n", 16},
+		{4096, "", 16},
+		{4096, "", 20},
+	} {
+		t.Run(fmt.Sprintf("frame%d-call%t-span%d", test.frame, test.call != "", test.span), func(t *testing.T) {
+			word := uint32(0x14000000 | ((test.span + 4) / 4))
+			source := fmt.Sprintf("TEXT rawUnboundRET(SB),4,$%d-0\n%sWORD $0x%08x\nRET\nWORD $0xd503201f\nTEXT anchor(SB),4,$0-0\nRET\n", test.frame, test.call, word)
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err == nil || !strings.Contains(err.Error(), "proven instruction boundary") {
+				t.Fatalf("unbound original RET encoder admitted a cross-RET raw branch: %v\n%s", err, source)
+			}
+		})
+	}
+}
+
+func TestARM64LiteralReturnWordKeepsFourByteSourceWidth(t *testing.T) {
+	const source = `TEXT rawLiteralRET(SB),4,$4096-0
+	WORD $0x14000002
+	WORD $0xd65f03c0
+target:
+	WORD $0xd503201f
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn := file.Funcs[0]
+	if width, known := arm64RawKnownSourceWidth(fn, fn.Instrs[2]); !known || width != 4 {
+		t.Fatalf("literal WORD RET lost its exact source width: (%d,%v)", width, known)
+	}
+	if _, err := normalizeARM64RawPCRelative(fn); err != nil {
+		t.Fatalf("literal four-byte return disrupted its raw branch: %v", err)
+	}
+}
+
+func TestARM64UnboundRETWidthDoesNotRejectOrdinaryReturn(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, frame := range []int{4080, 4096, 65536, 1 << 20, 1 << 30} {
+		source := fmt.Sprintf("TEXT ordinaryRET(SB),4,$%d-0\nRET\n", frame)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := file.Funcs[0]
+		if width, known := arm64RawKnownSourceWidth(fn, fn.Instrs[1]); known {
+			t.Fatalf("unbound frame established a guessed RET width: %d", width)
+		}
+		for _, target := range []string{
+			"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+			"aarch64-apple-darwin", "aarch64-pc-windows-msvc", "aarch64-unknown-freebsd",
+		} {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: target,
+				Sigs: map[string]FuncSig{"ordinaryRET": {Name: "ordinaryRET", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatalf("unbound source width must not ban ordinary RET: frame=%d target=%s: %v", frame, target, err)
+			}
+			compileLLVMToObject(t, llc, target, "ordinary-ret.ll", "ordinary-ret.o", ir)
+		}
+	}
+}
+
+func TestARM64UnboundRETWidthCommonDomainEdges(t *testing.T) {
+	for _, frame := range []int{4064, 4072} {
+		for _, call := range []string{"", "CALL anchor(SB)\n"} {
+			source := fmt.Sprintf("TEXT domainEdge(SB),4,$%d-0\n%sRET\nWORD $0xd503201f\nTEXT anchor(SB),4,$0-0\nRET\n", frame, call)
+			retLine := 2 + strings.Count(call, "\n")
+			positions := arm64RETObjectPositions(t, "domain-edge", source)
+			start, startOK := positions[retLine]
+			end, endOK := positions[retLine+1]
+			if !startOK || !endOK || end <= start {
+				t.Fatal("actual Go object lost the domain-edge RET span")
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			width, known := arm64RawKnownSourceWidth(fn, fn.Instrs[len(fn.Instrs)-2])
+			if known != (frame == 4064) || known && (width != 12 || width != end-start) {
+				t.Fatalf("domain edge frame=%d call=%t width=(%d,%v), actual=%d", frame, call != "", width, known, end-start)
+			}
+			word := uint32(0x14000000) | uint32((end-start+4)/4)
+			crossSource := strings.Replace(source, "\nRET\nWORD", fmt.Sprintf("\nWORD $0x%08x\nRET\nWORD", word), 1)
+			crossPositions := arm64RETObjectPositions(t, "domain-crossing", crossSource)
+			if branch, ok := crossPositions[retLine]; !ok || crossPositions[retLine+2]-branch != end-start+4 {
+				t.Fatal("domain-edge raw branch is not bound to its actual marker")
+			}
+			crossFile, err := Parse(ArchARM64, crossSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = normalizeARM64RawPCRelative(crossFile.Funcs[0])
+			if known && err != nil || !known && (err == nil || !strings.Contains(err.Error(), "proven instruction boundary")) {
+				t.Fatalf("domain-edge source crossing frame=%d call=%t: %v", frame, call != "", err)
+			}
+		}
+	}
+}
diff --git a/arm64_rndr.go b/arm64_rndr.go
new file mode 100644
index 000000000..e87af5d80
--- /dev/null
+++ b/arm64_rndr.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// RNG reads share Go's MRS/MOVD C_SPR -> C_ZREG row, not a general system-
+// register or caller-state permission. The raw Rt/reseed decoder remains the
+// single numerical/status representation used by lowering and continuation.
+func parseARM64RNDR(instruction Instr) (arm64RawRNDR, bool, error) {
+	op := arm64ControlOp(instruction)
+	if op == OpWORD {
+		if instruction.Op == OpWORD && len(instruction.Args) == 1 && instruction.Args[0].Kind == OpImm &&
+			instruction.Args[0].ImmRaw == "" && !instruction.Args[0].ImmIsFloat {
+			form, matched := decodeARM64RawRNDR(uint32(instruction.Args[0].Imm))
+			return form, matched, nil
+		}
+		return arm64RawRNDR{}, false, nil
+	}
+	if op != "MRS" && op != "MSR" && op != "MOVD" {
+		return arm64RawRNDR{}, false, nil
+	}
+	matched := false
+	for _, operand := range instruction.Args {
+		if operand.Kind == OpIdent {
+			switch strings.ToUpper(operand.Ident) {
+			case "RNDR", "RNDRRS", "S3_3_C2_C4_0", "S3_3_C2_C4_1":
+				matched = true
+			}
+		}
+	}
+	if !matched {
+		return arm64RawRNDR{}, false, nil
+	}
+	invalid := func() (arm64RawRNDR, bool, error) {
+		return arm64RawRNDR{}, true, fmt.Errorf("arm64 RNG requires MRS/MOVD RNDR/RNDRRS,GP/ZR without suffix: %q", instruction.Raw)
+	}
+	if instruction.Op != op || op == "MSR" || len(instruction.Args) != 2 {
+		return invalid()
+	}
+	system, destination := instruction.Args[0], instruction.Args[1]
+	if system.Kind != OpIdent || (system.Ident != "RNDR" && system.Ident != "RNDRRS") ||
+		destination.Kind != OpReg || !isARM64GeneralOrZeroReg(destination.Reg) {
+		return invalid()
+	}
+	register := 31
+	if destination.Reg != ZR {
+		var valid bool
+		register, valid = arm64StackIndex(destination.Reg)
+		if !valid || register < 0 || register > 30 {
+			return invalid()
+		}
+	}
+	return arm64RawRNDR{reseed: system.Ident == "RNDRRS", reg: register}, true, nil
+}
+
+func validateARM64RNDRTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			_, matched, err := parseARM64RNDR(instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+		}
+	}
+	if needsNative && (!arm64ScalarConversionNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm64") {
+		return fmt.Errorf("%w: ARM64 RNG requires an explicit native little-endian AArch64 target", ErrProbeNeedsContext)
+	}
+	return nil
+}
diff --git a/arm64_rndr_consumers_test.go b/arm64_rndr_consumers_test.go
new file mode 100644
index 000000000..f6e99e95c
--- /dev/null
+++ b/arm64_rndr_consumers_test.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARM64RNDRRequiredOriginalRuntimeOwner(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(), "arm64_rndr_cross_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	calls := 0
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestCrossLinuxRuntimeMatrixARM64RNDR" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				if name, ok := call.Fun.(*ast.Ident); ok && name.Name == "arm64RNDRFullStateRuntime" {
+					calls++
+				}
+			}
+			return true
+		})
+	}
+	if calls != 1 {
+		t.Fatal("required Linux RNG owner lost its full original-Go oracle", calls)
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") ||
+		!strings.Contains(string(workflow), "PLAN9ASM_CROSS_EXEC: '1'") {
+		t.Fatal("CI lost mandatory RNG runtime selection", err)
+	}
+}
diff --git a/arm64_rndr_cross_test.go b/arm64_rndr_cross_test.go
new file mode 100644
index 000000000..622ca7678
--- /dev/null
+++ b/arm64_rndr_cross_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// FEAT_RNG is optional on physical ARM64 hosts. Exercise both random-source
+// variants on the required Linux/QEMU CPU=max cross-runtime job.
+func TestCrossLinuxRuntimeMatrixARM64RNDR(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("RNDR execution belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64RNDRStatusFixtureIR(t, triple)
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc"}, "arm64_rndr_status", triple, ir,
+		arm64RNDRStatusOracleC,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+	arm64RNDRFullStateRuntime(t, llc, []string{"aarch64-linux-gnu-gcc"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func TestARM64RNDRStatusFixtureLLVM22Object(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir := arm64RNDRStatusFixtureIR(t, triple)
+	compileLLVMToObject(t, llc, triple, "arm64-rndr-status.ll", "arm64-rndr-status.o", ir)
+}
+
+func arm64RNDRStatusFixtureIR(t *testing.T, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range []struct {
+		name string
+		word uint32
+	}{
+		{name: "randomStatus", word: 0xd53b2400},
+		{name: "reseedStatus", word: 0xd53b2420},
+	} {
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\n", form.name)
+		source.WriteString("MOVD out+0(FP),R10\n")
+		fmt.Fprintf(&source, "WORD $%#08x\n", form.word)
+		source.WriteString("CSET EQ,R1\nCSET MI,R2\nCSET CS,R3\nCSET VS,R4\n")
+		source.WriteString("MOVD R0,0(R10)\nMOVD R1,8(R10)\n")
+		source.WriteString("MOVD R2,16(R10)\nMOVD R3,24(R10)\n")
+		source.WriteString("MOVD R4,32(R10)\nRET\n")
+		sigs[form.name] = FuncSig{
+			Name: form.name, Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+			}},
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+const arm64RNDRStatusOracleC = `
+#include <stdint.h>
+
+extern void randomStatus(uint64_t out[5]);
+extern void reseedStatus(uint64_t out[5]);
+
+static int check(void (*read_status)(uint64_t out[5])) {
+    unsigned successes = 0;
+    for (unsigned i = 0; i < 128; i++) {
+        uint64_t out[5] = {0};
+        read_status(out);
+        // The architecture writes NZCV=0000 on success, 0100 on failure.
+        if (out[1] > 1 || out[2] != 0 || out[3] != 0 || out[4] != 0)
+            return 1;
+        if (out[1] != 0 && out[0] != 0)
+            return 2;
+        successes += out[1] == 0;
+    }
+    return successes == 0 ? 3 : 0;
+}
+
+int main(void) {
+    int result = check(randomStatus);
+    if (result != 0)
+        return result;
+    result = check(reseedStatus);
+    return result == 0 ? 0 : result + 3;
+}
+`
diff --git a/arm64_rndr_named_test.go b/arm64_rndr_named_test.go
new file mode 100644
index 000000000..9276bd74c
--- /dev/null
+++ b/arm64_rndr_named_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestARM64RNDRNamedAndRawStatusAgreement(t *testing.T) {
+	for _, operation := range []struct {
+		name string
+		word uint32
+	}{{"RNDR", 0xd53b2400}, {"RNDRRS", 0xd53b2420}} {
+		for _, instruction := range []string{
+			"MRS " + operation.name + ",R0",
+			"MOVD " + operation.name + ",R0",
+			fmt.Sprintf("WORD $%#08x", operation.word),
+		} {
+			source := "TEXT comparison(SB),516,$0-0\n" + instruction + "\nCSET EQ,R0\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "public-module", "Go"} {
+				t.Run(api+"/"+instruction, func(t *testing.T) {
+					present, err := arm64FPControlTargetAPI(t, api, source, "aarch64-unknown-linux-gnu")
+					if !present || err != nil {
+						t.Fatalf("original-Go RNG defines all NZCV bits for every spelling: output=%t err=%v", present, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64RNDRCompleteGoGrammarAndBytes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, operation := range []string{"MRS", "MOVD"} {
+		row := `\{A` + operation + `,\s*C_SPR,\s*C_NONE,\s*C_NONE,\s*C_ZREG,\s*(?:C_NONE,\s*)?35,\s*4,\s*0,\s*0,\s*0\}`
+		if !regexp.MustCompile(row).Match(data) {
+			t.Fatalf("complete Go RNG read row changed: %s", row)
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT original(SB),516,$0-0\n")
+	var words []uint32
+	for index, name := range []string{"RNDR", "RNDRRS"} {
+		spec, present := arm64GoSystemRegisters[name]
+		if !present || !spec.readable || spec.writable || spec.encoding != uint16(0x5920+index) {
+			t.Fatalf("Go RNG encoding/read-only role changed: %s %+v", name, spec)
+		}
+		for _, operation := range []string{"MRS", "MOVD"} {
+			for bank := 0; bank < 32; bank++ {
+				register := fmt.Sprintf("R%d", bank)
+				switch bank {
+				case 18:
+					register = "R18_PLATFORM"
+				case 28:
+					register = "g"
+				case 31:
+					register = "ZR"
+				}
+				line := operation + " " + name + "," + register
+				instruction := arm64ImmediateTestInstruction(t, line)
+				form, matched, err := parseARM64RNDR(instruction)
+				if !matched || err != nil || form.reg != bank || form.reseed != (index == 1) {
+					t.Fatalf("named grammar %s: %+v %t %v", line, form, matched, err)
+				}
+				word := uint32(0xd53b2400 + index*32 + bank)
+				raw, matched := decodeARM64RawRNDR(word)
+				if !matched || form != raw {
+					t.Fatalf("named/raw grammar mismatch %s / %#08x", line, word)
+				}
+				if features := inferFuncTargetFeaturesForGOARCH(ArchARM64, "arm64", Func{Instrs: []Instr{instruction}}); features != "+rand" {
+					t.Fatalf("exact RNG feature inference %s: %q", line, features)
+				}
+				source.WriteString(line + "\n")
+				words = append(words, word)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	actual := arm64ImmediateOriginalGoBytes(t, source.String(), "linux")
+	if len(words) != 128 || len(actual) < 4*len(words) {
+		t.Fatal("incomplete Go RNG bank/spelling family", len(words), len(actual))
+	}
+	for index, word := range words {
+		if got := binary.LittleEndian.Uint32(actual[4*index:]); got != word {
+			t.Fatalf("actual Go word %d got %#08x want %#08x", index, got, word)
+		}
+	}
+}
+
+func TestARM64RNDRSourceErrorsBeforeTargetContext(t *testing.T) {
+	invalid := []string{
+		"MRS RNDR", "MRS RNDR,R0,R1", "MRS RNDR,F0", "MRS RNDR,RSP",
+		"MRS RNDR,(R0)", "MRS RNDR,$0", "MRS.P RNDR,R0", "MRS rndr,R0",
+		"MRS S3_3_C2_C4_0,R0", "MSR R0,RNDR", "MSR $0,RNDRRS",
+		"MOVD R0,RNDR", "MOVD RNDRRS,F0", "MOVD RNDRRS,(R0)",
+	}
+	for _, line := range invalid {
+		requireARM64GoAssemblerResult(t, "TEXT invalid(SB),516,$0-0\n"+line+"\nRET\n", false)
+	}
+	for _, api := range []string{"text", "module", "public-module", "Go"} {
+		for _, target := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "aarch64_be-unknown-linux-gnu"} {
+			for _, line := range []string{"MRS RNDR,R0", "MOVD RNDRRS,ZR", "WORD $0xd53b2420"} {
+				for _, prefix := range []string{"", "RET\n"} {
+					present, err := arm64FPControlTargetAPI(t, api, "TEXT comparison(SB),516,$0-0\n"+prefix+line+"\nRET\n", target)
+					if present || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("unbound native RNG: %s %s %s output=%t err=%v", api, target, line, present, err)
+					}
+				}
+			}
+			for _, line := range append(append([]string{}, invalid...), "WORD $0xffffffff", "WORD $(0.0)") {
+				source := "TEXT comparison(SB),516,$0-0\nMRS RNDR,R0\nRET\n" + line + "\nRET\n"
+				present, err := arm64FPControlTargetAPI(t, api, source, target)
+				if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("invalid RNG source hidden by target context: %s %s %s output=%t err=%v", api, target, line, present, err)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64RNDRDoesNotSupplyOtherEntryRoles(t *testing.T) {
+	for _, body := range []string{
+		"CBZ R0,done\nMRS RNDR,R1\ndone:\nCSET EQ,R0",
+		"MRS RNDR,R18_PLATFORM", "MOVD RNDRRS,g", "MRS RNDR,R30",
+		"WORD $0xd53b2412", "WORD $0xd53b243c",
+		"MRS RNDR,R1\nMRS TPIDR_EL0,R2\nCSET EQ,R0",
+		"MRS RNDR,R1\nADD R9,R0,R0",
+	} {
+		file, err := Parse(ArchARM64, arm64TypedNativeSource(body))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ir, err := Translate(file, arm64TypedNativeOptions(t, "aarch64-unknown-linux-gnu")); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("RNG acquired unrelated machine-entry role: %s: %v", body, err)
+		}
+	}
+}
diff --git a/arm64_rndr_state_test.go b/arm64_rndr_state_test.go
new file mode 100644
index 000000000..cc13a0439
--- /dev/null
+++ b/arm64_rndr_state_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64RNDRFixtureForm struct {
+	name string
+	bank int
+	kind int
+	word uint32
+}
+
+func arm64RNDRFixtureForms() []arm64RNDRFixtureForm {
+	var forms []arm64RNDRFixtureForm
+	for operation, name := range []string{"RNDR", "RNDRRS"} {
+		for bank := 0; bank < 32; bank++ {
+			if bank == 18 || bank == 28 || bank == 29 || bank == 30 {
+				continue // Syntax/objects alone do not supply these physical entry roles.
+			}
+			forms = append(forms, arm64RNDRFixtureForm{name, bank, 0, uint32(0xd53b2400 + operation*32 + bank)})
+		}
+		for kind := 1; kind < 3; kind++ {
+			for _, bank := range []int{0, 31} {
+				forms = append(forms, arm64RNDRFixtureForm{name, bank, kind, uint32(0xd53b2400 + operation*32 + bank)})
+			}
+		}
+	}
+	return forms
+}
+
+func arm64RNDRStateFixture(forms []arm64RNDRFixtureForm) (source, declarations, original, driver string) {
+	var assembly, goDeclarations, cDeclarations, goTable, cTable strings.Builder
+	for index, form := range forms {
+		name := fmt.Sprintf("compareRNG%d", index)
+		fmt.Fprintf(&goDeclarations, "func %s(*uint64,*uint64)\n", name)
+		fmt.Fprintf(&cDeclarations, "extern void %s(uint64_t*,uint64_t*);\n", name)
+		fmt.Fprintf(&goTable, "{%s,%t},\n", name, form.bank == 31)
+		fmt.Fprintf(&cTable, "{%s,%d},\n", name, map[bool]int{false: 0, true: 1}[form.bank == 31])
+		var safe []int
+		for _, register := range []int{19, 20, 21, 22, 23, 24} {
+			if register != form.bank {
+				safe = append(safe, register)
+			}
+		}
+		in, out, flags, temporary, canary := safe[0], safe[1], safe[2], safe[3], safe[4]
+		fmt.Fprintf(&assembly, "TEXT %s(SB),516,$0-16\nMOVD in+0(FP),R%d\nMOVD out+8(FP),R%d\n", name, in, out)
+		fmt.Fprintf(&assembly, "MOVD (R%d),R%d\nMOVD $0x123456789abcdef0,R%d\nMSR R%d,NZCV\n", in, flags, canary, flags)
+		register := fmt.Sprintf("R%d", form.bank)
+		if form.bank == 31 {
+			register = "ZR"
+		}
+		line := "MRS " + form.name + "," + register
+		if form.kind == 1 {
+			line = "MOVD " + form.name + "," + register
+		} else if form.kind == 2 {
+			line = fmt.Sprintf("WORD $%#08x", form.word)
+		}
+		fmt.Fprintln(&assembly, line)
+		fmt.Fprintf(&assembly, "MOVD %s,(R%d)\nMRS NZCV,R%d\nMOVD R%d,8(R%d)\n", register, out, temporary, temporary, out)
+		fmt.Fprintf(&assembly, "MOVD R%d,16(R%d)\nRET\n", canary, out)
+	}
+	original = `package main
+import "fmt"
+` + goDeclarations.String() + `
+func main() {
+ forms := []struct{ fn func(*uint64,*uint64); discard bool }{
+` + goTable.String() + `}
+ successes, failures, rows := 0,0,0
+ for index, form := range forms {
+  for flags:=uint64(0);flags<16;flags++ {
+   for trial:=0;trial<2;trial++ {
+    input:=flags<<28
+    var out [3]uint64
+    form.fn(&input,&out[0])
+    if (out[1]!=0 && out[1]!=0x40000000) || out[2]!=0x123456789abcdef0 || ((form.discard || out[1]!=0) && out[0]!=0) {
+     panic(fmt.Sprintf("RNG form=%d flags=%x result=%x",index,flags,out))
+    }
+    if out[1]==0 { successes++ } else { failures++ }
+    rows++
+   }
+  }
+ }
+ if successes==0 { panic("no actual RNG success observed") }
+ fmt.Printf("ARM64_COMPARE_ORIGINAL_PASS RNG rows=%d successes=%d failures=%d; no forced-failure claim\n",rows,successes,failures)
+}
+`
+	driver = `#include <stdint.h>
+#include <stdio.h>
+` + cDeclarations.String() + `
+int main(void) {
+ struct { void (*fn)(uint64_t*,uint64_t*); int discard; } forms[]={
+` + cTable.String() + `};
+ unsigned successes=0, failures=0;
+ for(unsigned index=0;index<sizeof(forms)/sizeof(forms[0]);index++) {
+  for(uint64_t flags=0;flags<16;flags++) {
+   for(unsigned trial=0;trial<2;trial++) {
+    uint64_t input=flags<<28, out[3]={0};
+    forms[index].fn(&input,out);
+    if((out[1]!=0 && out[1]!=UINT64_C(0x40000000)) || out[2]!=UINT64_C(0x123456789abcdef0) ||
+       ((forms[index].discard || out[1]!=0) && out[0]!=0)) {
+     fprintf(stderr,"RNG form=%u flags=%llx result=%llx/%llx/%llx\n",index,
+      (unsigned long long)flags,(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2]);
+     return 1;
+    }
+    if(out[1]==0) successes++; else failures++;
+   }
+  }
+ }
+ printf("RNG successes=%u failures=%u; no forced-failure claim\n",successes,failures);
+ return successes==0 ? 2 : 0;
+}
+`
+	return assembly.String(), "package compare\n" + goDeclarations.String(), original, driver
+}
+
+func TestARM64RNDRCompleteConsumerObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	forms := arm64RNDRFixtureForms()
+	if len(forms) != 64 {
+		t.Fatal("RNG independent-axis matrix lost forms", len(forms))
+	}
+	for batch := 0; batch < len(forms); batch += 32 {
+		source, declarations, _, _ := arm64RNDRStateFixture(forms[batch : batch+32])
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+			for _, consumer := range arm64NZCVConsumerIRs(t, source, declarations, triple) {
+				t.Run(fmt.Sprintf("batch%d/%s/%s", batch/32, triple, consumer.name), func(t *testing.T) {
+					compileLLVMToObject(t, llc, triple, "rng.ll", "rng.o", consumer.ir)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64RNDRDeadCallsSurviveOptimization(t *testing.T) {
+	for _, line := range []string{"MRS RNDR,ZR", "MOVD RNDRRS,ZR", "WORD $0xd53b241f", "WORD $0xd53b243f"} {
+		source := "TEXT deadRandom(SB),516,$0-0\n" + line + "\nRET\n"
+		for _, consumer := range arm64NZCVConsumerIRs(t, source, "package compare\nfunc deadRandom()\n", "aarch64-unknown-linux-gnu") {
+			if optimized := armFloatEffectOptimizedIR(t, consumer.ir); !strings.Contains(optimized, "call { i64, i1 } @llvm.aarch64.rndr") {
+				t.Errorf("%s discarded RNG side effect in %s", consumer.name, line)
+			}
+		}
+	}
+}
+
+func arm64RNDRFullStateRuntime(t *testing.T, llc string, compiler, runner []string) {
+	t.Helper()
+	forms := arm64RNDRFixtureForms()
+	if len(forms) != 64 {
+		t.Fatal("RNG runtime matrix lost forms", len(forms))
+	}
+	for batch := 0; batch < len(forms); batch += 32 {
+		t.Run(fmt.Sprintf("batch%d", batch/32), func(t *testing.T) {
+			source, declarations, original, driver := arm64RNDRStateFixture(forms[batch : batch+32])
+			arm64ScalarCompareActualGo(t, source, original, "linux", runner)
+			arm64NZCVRunConsumers(t, llc, compiler, "rng_state", "aarch64-unknown-linux-gnu", source, declarations, driver, runner)
+		})
+	}
+	// Independent allowed-state invariants, not equality of nondeterministic
+	// random values from separate original-Go and LLVM executions.
+	t.Log("64 forms × 16 initial NZCV states × 2 trials = 2048 rows per executable; 4 consumers × 4 optimization axes")
+}
diff --git a/arm64_scalar_atomic_effects.go b/arm64_scalar_atomic_effects.go
new file mode 100644
index 000000000..427da444f
--- /dev/null
+++ b/arm64_scalar_atomic_effects.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+// Scalar atomics have a memory operand before their final GP operand. Treating
+// only that final operand as a write would miss an actual saved-LR overwrite.
+// Reuse the lowerer's complete opcode families; operand errors remain its
+// responsibility and never acquire a narrower control-effect exception here.
+func (state *arm64ControlState) transferScalarAtomicStore(ins Instr, op Op) bool {
+	output, data := 2, 0
+	status := false
+	if form, matched := parseARM64ExclusiveOpcode(op); matched {
+		if form.isLoad {
+			return false
+		}
+		status = true
+	} else if _, matched := parseARM64AtomicCASOpcode(op); matched {
+		output, data = 0, 2
+	} else if _, matched := parseARM64AtomicRMWOpcode(op); !matched {
+		return false
+	}
+	if len(ins.Args) != 3 || ins.Args[1].Kind != OpMem {
+		return false
+	}
+	// CAS/exclusive may leave the original bytes untouched. Arithmetic RMW
+	// results are not an affine/code pointer proof either. Preserve all prior
+	// address taint, but mark both stored contents and returned old bits unknown.
+	memory := ins.Args[1]
+	observed := arm64ControlUnion(state.source(memory, false), arm64ControlExternal())
+	value := arm64ControlUnion(observed, state.source(ins.Args[data], false))
+	state.write(memory, value, false)
+	if status {
+		observed = arm64ControlExternal()
+	}
+	state.write(ins.Args[output], observed, false)
+	return true
+}
diff --git a/arm64_scalar_binary.go b/arm64_scalar_binary.go
new file mode 100644
index 000000000..477eb924a
--- /dev/null
+++ b/arm64_scalar_binary.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ScalarBinarySpec struct {
+	opcode string
+	bits   int
+}
+
+// Go asm7 case 54 shares both FREG,FREG and FREG,FREG,FREG rows.
+// H is a separately authenticated WORD encoding, not a named Go spelling.
+var arm64ScalarBinarySpecs = map[Op]arm64ScalarBinarySpec{
+	"FADDS": {"fadd", 32}, "FADDD": {"fadd", 64},
+	"FSUBS": {"fsub", 32}, "FSUBD": {"fsub", 64},
+	"FMULS": {"fmul", 32}, "FMULD": {"fmul", 64},
+	"FNMULS": {"fnmul", 32}, "FNMULD": {"fnmul", 64},
+	"FDIVS": {"fdiv", 32}, "FDIVD": {"fdiv", 64},
+}
+
+type arm64ScalarBinaryForm struct {
+	arm64ScalarBinarySpec
+	first, second, destination Reg
+}
+
+func parseARM64ScalarBinary(op Op, instruction Instr) (arm64ScalarBinaryForm, bool, error) {
+	spec, matched := arm64ScalarBinarySpecs[op]
+	if !matched {
+		return arm64ScalarBinaryForm{}, false, nil
+	}
+	if strings.ToUpper(string(instruction.Op)) != string(op) || len(instruction.Args) != 2 && len(instruction.Args) != 3 {
+		return arm64ScalarBinaryForm{}, true, fmt.Errorf("arm64 %s expects Fsrc,Fdst or Fsrc1,Fsrc2,Fdst and no suffix: %q", op, instruction.Raw)
+	}
+	for _, operand := range instruction.Args {
+		if operand.Kind != OpReg || !isARM64FReg(operand.Reg) {
+			return arm64ScalarBinaryForm{}, true, fmt.Errorf("arm64 %s accepts only F registers: %q", op, instruction.Raw)
+		}
+	}
+	return arm64ScalarBinaryForm{spec, instruction.Args[1].Reg, instruction.Args[0].Reg, instruction.Args[len(instruction.Args)-1].Reg}, true, nil
+}
+
+func arm64ScalarBinaryOpcode(kind string) string {
+	switch kind {
+	case "add", "sub", "mul", "nmul", "div":
+		return "f" + kind
+	default:
+		return ""
+	}
+}
+
+func (c *arm64Ctx) recordARM64ScalarBinary(form arm64ScalarBinaryForm) func() {
+	flow := c.machineAvailability
+	if flow == nil || flow.flagsOnly || flow.suspended != 0 {
+		return func() {}
+	}
+	c.recordMachineRegister(form.first, form.bits, false)
+	c.recordMachineRegister(form.second, form.bits, false)
+	// FPCR.NEP can copy the first source's upper bits, not the old destination.
+	// Preserve their exact definedness without inventing or requiring dead bits.
+	flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects,
+		arm64MachineEffect{register: arm64MachineRegister(form.destination), copyFrom: arm64MachineRegister(form.first),
+			width: 128, write: true, vectorSpan: true, source: flow.source},
+		arm64MachineEffect{register: arm64MachineRegister(form.destination), width: form.bits,
+			write: true, vectorSpan: true, source: flow.source},
+	)
+	flow.suspended++
+	return func() { flow.suspended-- }
+}
+
+func (c *arm64Ctx) lowerARM64ScalarBinary(form arm64ScalarBinaryForm) error {
+	if form.bits != 16 && form.bits != 32 && form.bits != 64 {
+		return fmt.Errorf("arm64 invalid scalar binary width %d", form.bits)
+	}
+	switch form.opcode {
+	case "fadd", "fsub", "fmul", "fnmul", "fdiv":
+	default:
+		return fmt.Errorf("arm64 invalid scalar binary operation %q", form.opcode)
+	}
+	for _, register := range []Reg{form.first, form.second, form.destination} {
+		if !isARM64FReg(register) {
+			return fmt.Errorf("arm64 invalid scalar binary register %q", register)
+		}
+	}
+	if !arm64ScalarConversionNativeTarget(c.targetTriple) {
+		return fmt.Errorf("%w: ARM64 scalar binary requires an explicit native little-endian AArch64 FPCR/FPSR target", ErrProbeNeedsContext)
+	}
+	finish := c.recordARM64ScalarBinary(form)
+	defer finish()
+	first, err := c.loadVReg(form.first)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadVReg(form.second)
+	if err != nil {
+		return err
+	}
+	modifier := arm64ScalarConversionModifier(form.bits, false)
+	operation := fmt.Sprintf("%s ${0:%s}, ${1:%s}, ${2:%s}", form.opcode, modifier, modifier, modifier)
+	result := c.newTmp()
+	// DDI0602: native scalar arithmetic observes FPCR, accumulates FPSR and
+	// can trap even when its value is dead. IsMerging(FPCR) copies V[n]'s high
+	// bits. Tie the full first source to the output to preserve that identity.
+	// The compiler barrier orders MRS/MSR; it grants no data-memory access and
+	// does not change the independently tracked NZCV bank.
+	c.emitMachineNeutralNativeIR("  %%%s = call <16 x i8> asm sideeffect %q, %q(<16 x i8> %s, <16 x i8> %s)\n",
+		result, operation, "=w,0,w,~{memory}", first, second)
+	return c.storeVReg(form.destination, "%"+result)
+}
+
+func validateARM64ScalarBinaryTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	var rawError error
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if instruction.Op == OpWORD && rawError == nil {
+				rawError = arm64RawWordPreflightError(instruction)
+			}
+			_, matched, err := parseARM64ScalarBinary(arm64ControlOp(instruction), instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+			if instruction.Op != OpWORD || len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+				instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+				continue // Unidentified WORDs retain their generic source validator.
+			}
+			word := uint32(instruction.Args[0].Imm)
+			switch word & 0xff20fc00 {
+			case 0x1e200800, 0x1e201800, 0x1e202800, 0x1e203800, 0x1e208800:
+				form, valid := decodeARM64RawScalarFloatBinary(word)
+				if !valid || arm64ScalarBinaryOpcode(form.kind) == "" {
+					return fmt.Errorf("unsupported ARM64 scalar binary WORD encoding %#08x: %q", word, instruction.Raw)
+				}
+				needsNative = true
+			}
+		}
+	}
+	if needsNative && rawError != nil {
+		return rawError // Illegal/dead WORD syntax is not native-target Context.
+	}
+	if needsNative && (!arm64ScalarConversionNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm64") {
+		return fmt.Errorf("%w: ARM64 scalar binary requires an explicit native little-endian AArch64 FPCR/FPSR target, got %q/%q",
+			ErrProbeNeedsContext, options.Goarch, options.TargetTriple)
+	}
+	return nil
+}
diff --git a/arm64_scalar_binary_consumers_test.go b/arm64_scalar_binary_consumers_test.go
new file mode 100644
index 000000000..673a7d7e7
--- /dev/null
+++ b/arm64_scalar_binary_consumers_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"strings"
+	"testing"
+)
+
+// The shared compare helper covers text, caller-owned context and typed Go.
+// Explicitly add the public module-owned-context API; none is a substitute for
+// another API. Callers consume all four outputs and dispose each LLVM owner.
+func arm64BinaryMatrixIRs(t *testing.T, source, declarations, triple string) []string {
+	t.Helper()
+	irs := arm64CompareMatrixIRs(t, source, declarations, triple)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "compare", declarations)
+	sizes := types.SizesFor("gc", "arm64")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	module, err := TranslateModule(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve})
+	if err != nil {
+		t.Fatal(err)
+	}
+	irs = append(irs, module.String())
+	module.Dispose()
+	return irs
+}
+
+func arm64BinaryTargetAPI(t *testing.T, api, source, triple string) (bool, error) {
+	t.Helper()
+	if api != "owned-module" {
+		return arm64CompareTargetAPI(t, api, source, triple)
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return false, err
+	}
+	module, err := TranslateModule(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"comparison": {Name: "comparison", Ret: Void}},
+	})
+	present := !module.IsNil()
+	if present {
+		module.Dispose()
+	}
+	return present, err
+}
+
+func TestARM64ScalarBinaryRuntimeOwnership(t *testing.T) {
+	if len(arm64BinaryStateCases()) != 157 {
+		t.Fatal("complete scalar binary runtime forms changed")
+	}
+	for _, bits := range []int{16, 32, 64} {
+		if len(arm64BinarySamples(bits, true)) != 560 || len(arm64BinarySamples(bits, false)) != 2 {
+			t.Fatal("complete runtime control/input denominator changed")
+		}
+	}
+	const filename = "arm64_scalar_binary_runtime_linux_test.go"
+	for _, target := range []struct{ os, arch string }{{"linux", "amd64"}, {"linux", "arm64"}, {"darwin", "arm64"}, {"windows", "amd64"}, {"js", "wasm"}} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", filename)
+		if err != nil || selected != (target.os == "linux") {
+			t.Fatal("required runtime source role changed", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"TestCrossLinuxRuntimeMatrixARM64ScalarBinaryDeadNative":      "arm64ScalarBinaryDeadRuntime",
+		"TestCrossLinuxRuntimeMatrixARM64ScalarBinaryFullStateNative": "arm64BinaryStateRuntime",
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		helper, required := want[function.Name.Name]
+		if !required {
+			continue
+		}
+		calls := 0
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			if name, ok := call.Fun.(*ast.Ident); ok && name.Name == helper {
+				calls++
+				if helper == "arm64BinaryStateRuntime" {
+					last, ok := call.Args[len(call.Args)-1].(*ast.Ident)
+					if !ok || last.Name != "true" {
+						t.Error("required owner lost actual NEP/AH semantic effects")
+					}
+				}
+			}
+			return true
+		})
+		if calls != 1 {
+			t.Fatalf("owner %s lost helper %s", function.Name.Name, helper)
+		}
+		delete(want, function.Name.Name)
+	}
+	if len(want) != 0 {
+		t.Fatal("required Linux runtime roots absent", want)
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") || !strings.Contains(string(workflow), "PLAN9ASM_CROSS_EXEC: '1'") {
+		t.Fatal("CI lost mandatory scalar binary runtime selection", err)
+	}
+}
diff --git a/arm64_scalar_binary_effects_test.go b/arm64_scalar_binary_effects_test.go
new file mode 100644
index 000000000..cec3f4af5
--- /dev/null
+++ b/arm64_scalar_binary_effects_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarBinaryEveryInputByteAndNativeEffect(t *testing.T) {
+	for _, operation := range arm64BinaryTestKinds {
+		for _, bits := range []int{16, 32, 64} {
+			for _, destination := range []Reg{"F0", "F31", "F15"} {
+				for hole := -1; hole < 2*bits/8; hole++ {
+					ctx, flow := arm64FlagScratchBankFixture()
+					ctx.targetTriple = "aarch64-unknown-linux-gnu"
+					ctx.vRegSlot = map[int]string{0: "%left", 31: "%right", 15: "%destination"}
+					flow.used, flow.entry = true, &ARM64GoRegisterABI{}
+					for source, register := range []string{"V0", "V31"} {
+						for offset := 0; offset < bits; offset += 8 {
+							if hole != source*bits/8+offset/8 {
+								flow.blocks[0].effects = append(flow.blocks[0].effects, arm64MachineEffect{
+									register: register, width: 8, vectorOffset: offset, vectorSpan: true, write: true,
+								})
+							}
+						}
+					}
+					before, start := len(flow.blocks[0].effects), ctx.b.Len()
+					form := arm64ScalarBinaryForm{arm64ScalarBinarySpec{strings.ToLower(operation.name), bits}, "F0", "F31", destination}
+					if err := ctx.lowerARM64ScalarBinary(form); err != nil {
+						t.Fatal(err)
+					}
+					ctx.recordMachineOpaqueIR(start, Instr{})
+					effects := flow.blocks[0].effects[before:]
+					if len(effects) != 4 || effects[0].write || effects[1].write || effects[0].width != bits || effects[1].width != bits ||
+						effects[2].copyFrom != "V0" || effects[2].width != 128 || !effects[2].write || !effects[2].vectorSpan ||
+						effects[3].width != bits || !effects[3].write || !effects[3].vectorSpan {
+						t.Fatalf("wrong complete scalar effects: %+v", effects)
+					}
+					for _, effect := range effects {
+						if effect.opaque || effect.store || effect.unavailable || effect.nzcv != 0 || effect.call != nil {
+							t.Fatalf("scalar operation gained unrelated authority: %+v", effect)
+						}
+					}
+					err := flow.validate()
+					if hole < 0 && err != nil || hole >= 0 && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s %d hole %d destination %s: %v", operation.name, bits, hole, destination, err)
+					}
+					start = ctx.b.Len()
+					fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+					ctx.recordMachineOpaqueIR(start, Instr{})
+					if !flow.blocks[0].effects[len(flow.blocks[0].effects)-1].opaque {
+						t.Fatal("family proof escaped its exact native instruction")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarBinarySparseMergeAndCFG(t *testing.T) {
+	for _, bits := range []int{16, 32, 64} {
+		for _, destination := range []string{"V0", "V31", "V15"} {
+			state := arm64MachineState{values: make(map[string]int)}
+			state.setVectorDefinition(destination, arm64MachineVectorMask(0, 128))
+			want := arm64MachineVectorMask(0, bits)
+			want.high = 0xff000000000000ff
+			state.setVectorDefinition("V0", want)
+			effect := arm64MachineEffect{register: destination, copyFrom: "V0", width: 128, vectorSpan: true, write: true}
+			if err := state.applyVectorSpan(effect); err != nil {
+				t.Fatal(err)
+			}
+			want.scalable = true
+			if got := state.vectorDefinition(destination); got != want {
+				t.Fatalf("sparse source identity lost: %+v != %+v", got, want)
+			}
+		}
+		for _, complete := range []bool{false, true} {
+			flow := &arm64MachineAvailability{used: true, entry: &ARM64GoRegisterABI{}, blocks: []arm64MachineBlock{
+				{name: "entry", successors: []string{"left", "right"}},
+				{name: "left", successors: []string{"join"}},
+				{name: "right", successors: []string{"join"}},
+				{name: "join"},
+			}}
+			for _, path := range []int{1, 2} {
+				width := bits
+				if complete || path == 1 {
+					width = 128
+				}
+				flow.blocks[path].effects = []arm64MachineEffect{
+					{register: "V0", width: width, write: true},
+					{register: "V15", copyFrom: "V0", width: 128, write: true, vectorSpan: true},
+					{register: "V15", width: bits, write: true, vectorSpan: true},
+				}
+			}
+			flow.blocks[3].effects = []arm64MachineEffect{{register: "V15", width: 128}}
+			err := flow.validate()
+			if complete && err != nil || !complete && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("CFG borrowed another predecessor's upper source bits: %t %v", complete, err)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarBinaryDirectHelperContracts(t *testing.T) {
+	for _, target := range []string{"", "x86_64-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu"} {
+		ctx, _ := arm64FlagScratchBankFixture()
+		ctx.targetTriple = target
+		instruction := arm64ImmediateTestInstruction(t, "FADDS F0,F1")
+		known, _, err := ctx.lowerARM64ScalarFloatBinary(instruction.Op, instruction)
+		if !known || !errors.Is(err, ErrProbeNeedsContext) || ctx.b.Len() != 0 {
+			t.Fatalf("direct helper bypassed native target: %t %v", known, err)
+		}
+	}
+	ctx, _ := arm64FlagScratchBankFixture()
+	instruction := arm64ImmediateTestInstruction(t, "FADDS F0,F1")
+	if _, known, err := parseARM64ScalarBinary("RET", instruction); known || err != nil {
+		t.Fatal("typed family claimed unrelated dispatch")
+	}
+	if known, _, err := ctx.lowerARM64ScalarFloatBinary("FADDD", instruction); !known || err == nil || ctx.b.Len() != 0 {
+		t.Fatal("source mismatch gained IR")
+	}
+	for _, form := range []arm64ScalarBinaryForm{
+		{arm64ScalarBinarySpec{"fadd", 8}, "F0", "F1", "F2"},
+		{arm64ScalarBinarySpec{"fmadd", 32}, "F0", "F1", "F2"},
+		{arm64ScalarBinarySpec{"fadd", 32}, "R0", "F1", "F2"},
+	} {
+		if err := ctx.lowerARM64ScalarBinary(form); err == nil || errors.Is(err, ErrProbeNeedsContext) || ctx.b.Len() != 0 {
+			t.Fatalf("invalid direct form gained Context or IR: %+v %v", form, err)
+		}
+	}
+}
+
+func TestARM64ScalarBinaryCannotInventSourceFlags(t *testing.T) {
+	for _, api := range []string{"text", "module", "owned-module", "Go"} {
+		for _, operation := range arm64ScalarBinaryNames {
+			for _, complete := range []bool{false, true} {
+				prefix := ""
+				if complete {
+					prefix = "CMP R0,R0\n"
+				}
+				source := "TEXT comparison(SB),4,$0-0\n" + prefix + "CBZ R0,use\nCMP R0,R0\nuse:\n" + operation + " F0,F1\nCSET EQ,R2\nRET\n"
+				present, err := arm64BinaryTargetAPI(t, api, source, "aarch64-unknown-linux-gnu")
+				if complete {
+					if !present || err != nil {
+						t.Fatalf("%s source flags lost across %s: %v", api, operation, err)
+					}
+				} else if present || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s borrowed entry/path NZCV: %t %v", api, operation, present, err)
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_scalar_binary_forms_test.go b/arm64_scalar_binary_forms_test.go
new file mode 100644
index 000000000..9c81a2565
--- /dev/null
+++ b/arm64_scalar_binary_forms_test.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// DDI0602 scalar two-source opcode field, independent of production decoding.
+var arm64BinaryTestKinds = []struct {
+	name   string
+	opcode uint32
+}{
+	{"FADD", 0x2800}, {"FSUB", 0x3800}, {"FMUL", 0x0800},
+	{"FNMUL", 0x8800}, {"FDIV", 0x1800},
+}
+
+func arm64BinaryTestWord(kind, bits, first, second, destination int) uint32 {
+	word := uint32(0x1e200000) | arm64BinaryTestKinds[kind].opcode
+	if bits == 64 {
+		word |= 1 << 22
+	} else if bits == 16 {
+		word |= 3 << 22
+	}
+	return word | uint32(first)<<5 | uint32(second)<<16 | uint32(destination)
+}
+
+func TestARM64ScalarBinaryCompleteGoTableAndBytes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	sdk := string(data)
+	rows := regexp.MustCompile(`(?m)^\s*\{AFADDS,[^\n]+`).FindAllString(sdk, -1)
+	if len(rows) != 2 {
+		t.Fatalf("Go binary family acquired unreviewed rows: %v", rows)
+	}
+	for index, row := range rows {
+		fields := strings.Split(strings.Trim(strings.TrimSpace(row), "{},"), ",")
+		for i := range fields {
+			fields[i] = strings.TrimSpace(fields[i])
+		}
+		second := []string{"C_NONE", "C_FREG"}[index]
+		want := []string{"AFADDS", "C_FREG", second, "C_NONE", "C_FREG", "54", "4", "0", "0", "0"}
+		if len(fields) == 11 {
+			want = append(append([]string{}, want[:5]...), append([]string{"C_NONE"}, want[5:]...)...)
+		}
+		if !reflect.DeepEqual(fields, want) {
+			t.Fatalf("complete Go binary row changed: %v", fields)
+		}
+	}
+	alias := regexp.MustCompile(`case AFADDS:\s*((?:oprangeset\([^\n]+\)\s*)+)`).FindStringSubmatch(sdk)
+	if len(alias) != 2 {
+		t.Fatal("Go case54 inheritance missing")
+	}
+	for _, name := range arm64ScalarBinaryNames[1:] {
+		if strings.Count(alias[1], "oprangeset(A"+name+", t)") != 1 {
+			t.Fatalf("complete Go inheritance lacks %s", name)
+		}
+	}
+	for kind, operation := range arm64BinaryTestKinds {
+		for width, suffix := range []string{"S", "D"} {
+			// Older Go returns the encoding directly; current Go assigns it
+			// before the shared epilogue. The complete attributes stay exact.
+			encoding := fmt.Sprintf(`case A%s%s:\s*(?:op =|return) FPOP2S\(0, 0, %d, %d\)`, operation.name, suffix, width, []int{2, 3, 0, 8, 1}[kind])
+			if !regexp.MustCompile(encoding).MatchString(sdk) {
+				t.Fatalf("Go changed %s%s opcode attributes", operation.name, suffix)
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT original(SB),516,$0-0\n")
+	var expected []uint32
+	add := func(kind, bits, first, second, destination, operands int) {
+		op := arm64BinaryTestKinds[kind].name + map[int]string{32: "S", 64: "D"}[bits]
+		line := fmt.Sprintf("%s F%d,F%d,F%d", op, second, first, destination)
+		if operands == 2 {
+			first = destination
+			line = fmt.Sprintf("%s F%d,F%d", op, second, destination)
+		}
+		form, known, err := parseARM64ScalarBinary(Op(op), arm64ImmediateTestInstruction(t, line))
+		if !known || err != nil || form.bits != bits || form.opcode != strings.ToLower(arm64BinaryTestKinds[kind].name) ||
+			form.first != Reg(fmt.Sprintf("F%d", first)) || form.second != Reg(fmt.Sprintf("F%d", second)) || form.destination != Reg(fmt.Sprintf("F%d", destination)) {
+			t.Fatalf("typed original Go row %s: %+v %v", line, form, err)
+		}
+		source.WriteString(line + "\n")
+		expected = append(expected, arm64BinaryTestWord(kind, bits, first, second, destination))
+	}
+	for kind := range arm64BinaryTestKinds {
+		for _, bits := range []int{32, 64} {
+			for bank := 0; bank < 32; bank++ {
+				add(kind, bits, bank, 31, 15, 3)
+				add(kind, bits, 0, bank, 15, 3)
+				add(kind, bits, 0, 31, bank, 3)
+				add(kind, bits, bank, bank, bank, 3)
+				add(kind, bits, bank, (bank+1)%32, bank, 2)
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	actual := arm64ImmediateOriginalGoBytes(t, source.String(), "linux")
+	if len(actual) < 4*(len(expected)+1) {
+		t.Fatalf("short actual Go object: %d", len(actual))
+	}
+	for index, word := range expected {
+		if got := binary.LittleEndian.Uint32(actual[index*4:]); got != word {
+			t.Fatalf("Go word %d got %#08x want %#08x", index, got, word)
+		}
+	}
+	t.Logf("%d actual Go words; two complete table rows, ten names, independent banks/aliases", len(expected))
+}
+
+func TestARM64ScalarBinaryActualGoRejectsInvalidFormats(t *testing.T) {
+	for _, operation := range arm64ScalarBinaryNames {
+		for _, suffix := range []string{" F0", " F0,F1,F2,F3", " R0,F1", " F0,R1", " V0.S4,F1", " (R0),F1", " F0,0(FP)", " $1.0,F1", " F0,F32", ".P F0,F1"} {
+			requireARM64GoAssemblerResult(t, "TEXT invalid(SB),4,$0-0\n"+operation+suffix+"\nRET\n", false)
+		}
+	}
+}
+
+func TestARM64ScalarBinaryRawCompleteFields(t *testing.T) {
+	count := 0
+	for kind, operation := range arm64BinaryTestKinds {
+		for _, bits := range []int{16, 32, 64} {
+			for first := 0; first < 32; first++ {
+				for second := 0; second < 32; second++ {
+					for destination := 0; destination < 32; destination++ {
+						word := arm64BinaryTestWord(kind, bits, first, second, destination)
+						form, known := decodeARM64RawScalarFloatBinary(word)
+						if !known || form.kind != strings.ToLower(operation.name[1:]) || form.bits != bits ||
+							form.first != first || form.second != second || form.destination != destination {
+							t.Fatalf("raw word %#08x: %+v %t", word, form, known)
+						}
+						count++
+					}
+				}
+			}
+			for _, bit := range []uint{10, 21, 24, 25, 26, 27, 28, 29, 30, 31} {
+				word := arm64BinaryTestWord(kind, bits, 0, 31, 15) ^ (1 << bit)
+				if _, known := decodeARM64RawScalarFloatBinary(word); known {
+					t.Fatalf("fixed bit %d changed to known scalar family: %#08x", bit, word)
+				}
+			}
+		}
+		word := arm64BinaryTestWord(kind, 32, 0, 31, 15) | 2<<22
+		if _, known := decodeARM64RawScalarFloatBinary(word); known {
+			t.Fatalf("reserved type accepted: %#08x", word)
+		}
+	}
+	t.Logf("%d exact H/S/D field/alias decode observations; not runtime credit", count)
+}
+
+func TestARM64ScalarBinaryNativeIndependentAxisObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT compareMatrix0(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n")
+	for bank := 0; bank < 32; bank++ {
+		fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", bank)
+	}
+	source.WriteString("CMP R0,R0\n")
+	count := 0
+	for _, operation := range arm64ScalarBinaryNames {
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "%s F%d,F%d\n%s F%d,F%d,F%d\n", operation, bank, bank, operation, bank, (bank+1)%32, (bank+2)%32)
+			count += 2
+		}
+	}
+	for kind := range arm64BinaryTestKinds {
+		for _, bits := range []int{16, 32, 64} {
+			fmt.Fprintf(&source, "WORD $%#08x\n", arm64BinaryTestWord(kind, bits, 31, 0, 15))
+			count++
+		}
+	}
+	source.WriteString("CSET EQ,R2\nMOVD R2,(R1)\nRET\n")
+	for _, target := range []struct{ os, triple string }{{"linux", "aarch64-unknown-linux-gnu"}, {"darwin", "aarch64-apple-darwin"}, {"windows", "aarch64-pc-windows-msvc"}} {
+		t.Run(target.os, func(t *testing.T) {
+			arm64CompareGoObject(t, source.String(), target.os)
+			for api, ir := range arm64BinaryMatrixIRs(t, source.String(), "package compare\nfunc compareMatrix0(*[66]uint64,*[69]uint64)\n", target.triple) {
+				optimized := armFloatEffectOptimizedIR(t, ir)
+				if strings.Count(optimized, "call <16 x i8> asm sideeffect") != count {
+					t.Fatalf("API%d lost a dead native operation", api)
+				}
+				compileLLVMToObject(t, llc, target.triple, "binary.ll", "binary.o", optimized)
+			}
+		})
+	}
+	t.Logf("%d initialized independent-axis forms × three APIs plus typed-Go × three target objects", count)
+}
+
+func TestARM64ScalarBinaryTargetAndCompleteSourceBoundaries(t *testing.T) {
+	for _, api := range []string{"text", "module", "owned-module", "Go"} {
+		for _, operation := range arm64ScalarBinaryNames {
+			for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu", "aarch64bad-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+				for _, body := range []string{operation + " F0,F31", "RET\n" + operation + " F0,F31,F15"} {
+					present, err := arm64BinaryTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\n"+body+"\nRET\n", triple)
+					if triple == "aarch64-unknown-linux-gnu" {
+						if !present || err != nil {
+							t.Fatalf("%s native target rejected: %v", api, err)
+						}
+					} else if present || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s unbound native role produced output=%t error=%v", api, present, err)
+					}
+				}
+				for _, suffix := range []string{"", " F0", " F0,F1,F2,F3", " R0,F1", " F0,R1", " V0.S4,F1", " (R0),F1", " F0,0(FP)", " $1.0,F1", " F0,F32", ".P F0,F1"} {
+					source := "TEXT comparison(SB),4,$0-0\nFADDS F0,F1\nRET\n" + operation + suffix + "\n"
+					present, err := arm64BinaryTargetAPI(t, api, source, triple)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s dead malformed source masked by target: %t %v\n%s", api, present, err, source)
+					}
+				}
+			}
+		}
+		for kind := range arm64BinaryTestKinds {
+			for _, bits := range []int{16, 32, 64} {
+				word := arm64BinaryTestWord(kind, bits, 0, 31, 15)
+				present, err := arm64BinaryTargetAPI(t, api, fmt.Sprintf("TEXT comparison(SB),4,$0-0\nRET\nWORD $%#08x\n", word), "")
+				if present || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("raw native role escaped target: %t %v", present, err)
+				}
+			}
+			word := arm64BinaryTestWord(kind, 32, 0, 31, 15) | 2<<22
+			present, err := arm64BinaryTargetAPI(t, api, fmt.Sprintf("TEXT comparison(SB),4,$0-0\nFADDS F0,F1\nRET\nWORD $%#08x\n", word), "")
+			if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("reserved raw type masked by native Context: %t %v", present, err)
+			}
+		}
+	}
+}
diff --git a/arm64_scalar_binary_native_test.go b/arm64_scalar_binary_native_test.go
new file mode 100644
index 000000000..e13cea0a1
--- /dev/null
+++ b/arm64_scalar_binary_native_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent asm7.go case-54 named family, not the production specification.
+var arm64ScalarBinaryNames = []string{
+	"FADDS", "FADDD", "FSUBS", "FSUBD", "FMULS", "FMULD",
+	"FNMULS", "FNMULD", "FDIVS", "FDIVD",
+}
+
+func arm64ScalarBinaryDeadFixture() (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index, operation := range arm64ScalarBinaryNames {
+		for _, operands := range []int{2, 3} {
+			name := fmt.Sprintf("compareBinary%d_%d", index, operands)
+			fmt.Fprintf(&declarations, "func %s(*[3]uint64,*[4]uint64)\n", name)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+			source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD 8(R0),R2\nMSR R2,FPCR\nMOVD 16(R0),R2\nMSR R2,FPSR\n")
+			move := "FMOVS"
+			if strings.HasSuffix(operation, "D") {
+				move = "FMOVD"
+			}
+			fmt.Fprintf(&source, "%s (R0),F0\n%s (R0),F31\nCMP R0,R0\n%s F31,F0", move, move, operation)
+			if operands == 3 {
+				source.WriteString(",F15")
+			}
+			// The numerical destination is deliberately dead, not reloaded.
+			source.WriteString("\nCSET EQ,R4\nMRS FPSR,R2\nMRS FPCR,R3\nMOVD R2,(R1)\nMOVD R3,8(R1)\nMOVD R4,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func arm64ScalarBinaryDeadRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, declarations := arm64ScalarBinaryDeadFixture()
+	var original, driver strings.Builder
+	original.WriteString(strings.Replace(declarations, "package compare", "package main\nimport \"fmt\"", 1))
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range arm64ScalarBinaryNames {
+		for _, operands := range []int{2, 3} {
+			fmt.Fprintf(&driver, "extern void compareBinary%d_%d(uint64_t*,uint64_t*);\n", index, operands)
+		}
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) {\n")
+	count := 0
+	for index, operation := range arm64ScalarBinaryNames {
+		for _, operands := range []int{2, 3} {
+			for _, signaling := range []bool{false, true} {
+				value := uint64(0x7ff8000000000001)
+				if strings.HasSuffix(operation, "S") {
+					value = 0x7fc00001
+				}
+				if signaling {
+					if strings.HasSuffix(operation, "S") {
+						value = 0x7f800001
+					} else {
+						value = 0x7ff0000000000001
+					}
+				}
+				status := 0x10
+				if signaling {
+					status |= 1
+				}
+				for _, control := range []uint64{0, 1 << 25} {
+					fmt.Fprintf(&original, "{ in:=[3]uint64{%#x,%#x,0x10};out:=[4]uint64{0,0,0,0x1234};compareBinary%d_%d(&in,&out);if out!=[4]uint64{%d,%#x,1,0x1234}{panic(fmt.Sprintf(\"case %d %s got %%x\",out))} }\n", value, control, index, operands, status, control, count, operation)
+					fmt.Fprintf(&driver, "{uint64_t in[3]={%#xULL,%#xULL,0x10},out[4]={0,0,0,0x1234};compareBinary%d_%d(in,out);if(out[0]!=%d || out[1]!=%#xULL || out[2]!=1 || out[3]!=0x1234){fprintf(stderr,\"case %d %s got %%llx %%llx %%llx %%llx\\n\",(unsigned long long)out[0],(unsigned long long)out[1],(unsigned long long)out[2],(unsigned long long)out[3]);return 1;}}\n", value, control, index, operands, status, control, count, operation)
+					count++
+				}
+			}
+		}
+	}
+	fmt.Fprintf(&original, "fmt.Println(\"ARM64_COMPARE_ORIGINAL_PASS binary dead %d rows\")\n}\n", count)
+	driver.WriteString("return 0;\n}\n")
+	arm64ScalarCompareActualGo(t, source, original.String(), goos, runner)
+	for api, ir := range arm64BinaryMatrixIRs(t, source, declarations, triple) {
+		for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("api%d/IR_%s/backend_O%d", api, variant.name, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "scalar_binary_dead", triple, variant.ir, driver.String(), runner, level)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ScalarBinaryDeadNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU owner executes the same original Go fixture")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64ScalarBinaryDeadRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_scalar_binary_raw_priority_test.go b/arm64_scalar_binary_raw_priority_test.go
new file mode 100644
index 000000000..3ed4401a4
--- /dev/null
+++ b/arm64_scalar_binary_raw_priority_test.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestARM64ScalarBinaryIllegalWordPrecedesNativeContext(t *testing.T) {
+	for _, api := range []string{"text", "module", "owned-module", "Go"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+			for _, invalid := range []string{"WORD $0xffffffff", "WORD $(0.0)"} {
+				for _, body := range []string{
+					invalid + "\nFADDS F0,F1", "FADDS F0,F1\n" + invalid,
+					"RET\n" + invalid + "\nFADDS F0,F1", "FADDS F0,F1\nRET\n" + invalid,
+				} {
+					present, err := arm64BinaryTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\n"+body+"\nRET\n", triple)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %q malformed WORD became output/context: %t %v\n%s", api, triple, present, err, body)
+					}
+				}
+			}
+			present, err := arm64BinaryTargetAPI(t, api,
+				"TEXT comparison(SB),4,$0-0\nWORD $0xd503201f\nFADDS F0,F1\nRET\n", triple)
+			if triple == "aarch64-unknown-linux-gnu" {
+				if !present || err != nil {
+					t.Fatalf("%s valid raw neighbor lost native translation: %v", api, err)
+				}
+			} else if present || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s valid raw neighbor changed native target requirement: %t %v", api, present, err)
+			}
+		}
+	}
+}
diff --git a/arm64_scalar_binary_runtime_linux_test.go b/arm64_scalar_binary_runtime_linux_test.go
new file mode 100644
index 000000000..b1003f87c
--- /dev/null
+++ b/arm64_scalar_binary_runtime_linux_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarBinaryDeadNative(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64ScalarBinaryDeadRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarBinaryFullStateNative(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64BinaryStateRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"}, true)
+}
diff --git a/arm64_scalar_binary_state_test.go b/arm64_scalar_binary_state_test.go
new file mode 100644
index 000000000..bfc4ee8dc
--- /dev/null
+++ b/arm64_scalar_binary_state_test.go
@@ -0,0 +1,382 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type arm64BinaryStateCase struct {
+	kind, bits, first, second, destination int
+	raw, destructive, dead, full           bool
+}
+
+func (row arm64BinaryStateCase) instruction() string {
+	if row.raw {
+		return fmt.Sprintf("WORD $%#08x", arm64BinaryTestWord(row.kind, row.bits, row.first, row.second, row.destination))
+	}
+	op := arm64BinaryTestKinds[row.kind].name + map[int]string{32: "S", 64: "D"}[row.bits]
+	if row.destructive {
+		return fmt.Sprintf("%s F%d,F%d", op, row.second, row.destination)
+	}
+	return fmt.Sprintf("%s F%d,F%d,F%d", op, row.second, row.first, row.destination)
+}
+
+func arm64BinaryStateCases() []arm64BinaryStateCase {
+	var cases []arm64BinaryStateCase
+	for kind := range arm64BinaryTestKinds {
+		for _, bits := range []int{16, 32, 64} {
+			for _, raw := range []bool{false, true} {
+				if bits == 16 && !raw {
+					continue
+				}
+				for _, dead := range []bool{false, true} {
+					cases = append(cases, arm64BinaryStateCase{kind, bits, 0, 31, 15, raw, false, dead, true})
+				}
+				cases = append(cases,
+					arm64BinaryStateCase{kind, bits, 15, 31, 15, raw, !raw, false, false},
+					arm64BinaryStateCase{kind, bits, 15, 31, 31, raw, false, false, false},
+					arm64BinaryStateCase{kind, bits, 15, 15, 15, raw, !raw, false, false},
+				)
+			}
+		}
+	}
+	// Bank axes are shared across the typed family. Do not compile a separate
+	// 32^3 Cartesian set for every spelling; the raw decoder covers it above.
+	for bank := 0; bank < 32; bank++ {
+		cases = append(cases, arm64BinaryStateCase{bank % 5, []int{16, 32, 64}[bank%3], bank, (bank + 1) % 32, (bank + 2) % 32, true, false, false, false})
+	}
+	return cases
+}
+
+type arm64BinarySample struct{ a, b, control, status uint64 }
+
+func arm64BinarySamples(bits int, full bool) []arm64BinarySample {
+	values := arm64CompareValues(bits)
+	if !full {
+		return []arm64BinarySample{{values[2], values[3], 0, 0x08000080}, {values[2], values[3], 4, 0x08000080}}
+	}
+	var pairs [][2]uint64
+	for _, pair := range [][2]int{{0, 1}, {1, 0}, {2, 3}, {3, 2}, {2, 0}, {0, 0}, {4, 5}, {4, 4}, {4, 0},
+		{6, 2}, {2, 6}, {8, 2}, {2, 8}, {6, 8}, {8, 6}, {7, 9}, {9, 7},
+		{10, 2}, {2, 10}, {11, 2}, {12, 13}, {13, 12}, {14, 14}, {15, 14}} {
+		pairs = append(pairs, [2]uint64{values[pair[0]], values[pair[1]]})
+	}
+	fraction, bias := uint(23), uint64(127)
+	if bits == 16 {
+		fraction, bias = 10, 15
+	} else if bits == 64 {
+		fraction, bias = 52, 1023
+	}
+	pairs = append(pairs, [2]uint64{values[2], (bias - uint64(fraction) - 1) << fraction}, // halfway addition
+		[2]uint64{values[2], (bias + 1) << fraction},  // two: quotient/multiply
+		[2]uint64{values[14], (bias + 1) << fraction}, // overflow
+		[2]uint64{values[13], (bias + 1) << fraction}) // underflow edge
+	var controls []uint64
+	for rounding := 0; rounding < 4; rounding++ {
+		for mode := 0; mode < 4; mode++ {
+			control := uint64(rounding)<<22 | uint64(mode&1)<<24 | uint64(mode>>1)<<25
+			if bits == 16 && mode&1 != 0 {
+				control |= 1 << 19
+			}
+			controls = append(controls, control)
+		}
+	}
+	controls = append(controls, 2, 4, 6, 1<<19) // AH, NEP, their combination, independent FZ16
+	var samples []arm64BinarySample
+	for _, pair := range pairs {
+		for index, control := range controls {
+			status := uint64(0x08000000)
+			if index&1 != 0 {
+				status |= 0x80
+			}
+			samples = append(samples, arm64BinarySample{pair[0], pair[1], control, status})
+		}
+	}
+	return samples
+}
+
+func arm64BinaryStateSource(cases []arm64BinaryStateCase) (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index, row := range cases {
+		name := fmt.Sprintf("compareBinaryState%d", index)
+		fmt.Fprintf(&declarations, "func %s(*[66]uint64,*[69]uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", bank)
+		}
+		source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD (R0),R12\nMSR R12,FPCR\nMOVD 8(R0),R12\nMSR R12,FPSR\n")
+		source.WriteString([]string{
+			"CMP R0,R0\n", "MOVD $0,R2\nCMP $1,R2\n", "MOVD $2,R2\nCMP $1,R2\n",
+			"MOVD $0x8000000000000000,R2\nCMP $1,R2\n",
+		}[row.kind%4])
+		source.WriteString(row.instruction() + "\n")
+		if row.dead {
+			fmt.Fprintf(&source, "VEOR V%d.B16,V%d.B16,V%d.B16\n", row.destination, row.destination, row.destination)
+		}
+		source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET CS,R4\nCSET VS,R5\nLSL $3,R2,R2\nLSL $2,R3,R3\nLSL $1,R4,R4\nORR R3,R2,R2\nORR R4,R2,R2\nORR R5,R2,R2\nMRS FPSR,R3\nMRS FPCR,R4\n")
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VST1.P [V%d.B16],16(R1)\n", bank)
+		}
+		source.WriteString("MOVD R3,(R1)\nMOVD R4,8(R1)\nMOVD R2,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func arm64BinaryOriginalOutput(t *testing.T, source, program, goos string, runner []string) []byte {
+	t.Helper()
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module binaryoracle\n\ngo 1.20\n", "main.go": program,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT compare", "TEXT ·compare"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	arguments := []string{"run", "-p=1"}
+	if len(runner) != 0 {
+		arguments = append(arguments, "-exec="+strings.Join(runner, " "))
+	}
+	command := exec.CommandContext(ctx, "go", append(arguments, ".")...)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual original scalar binary: %v\n%s", err, output)
+	}
+	return output
+}
+
+func arm64BinaryStatePrograms(cases []arm64BinaryStateCase, declarations, path string) (string, string, int) {
+	var original, driver strings.Builder
+	original.WriteString(strings.Replace(declarations, "package compare", "package main\nimport (\"encoding/binary\";\"os\")", 1))
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range cases {
+		fmt.Fprintf(&driver, "extern void compareBinaryState%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("var functions=[]func(*[66]uint64,*[69]uint64){\n")
+	driver.WriteString("static void (*functions[])(uint64_t*,uint64_t*)={\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "compareBinaryState%d,\n", index)
+		fmt.Fprintf(&driver, "compareBinaryState%d,\n", index)
+	}
+	original.WriteString("}\nvar forms=[]struct{bits,first,second,full int}{\n")
+	driver.WriteString("};\nstatic const struct{unsigned bits,first,second,full;} forms[]={\n")
+	for _, row := range cases {
+		full := 0
+		if row.full {
+			full = 1
+		}
+		fmt.Fprintf(&original, "{%d,%d,%d,%d},\n", row.bits, row.first, row.second, full)
+		fmt.Fprintf(&driver, "{%d,%d,%d,%d},\n", row.bits, row.first, row.second, full)
+	}
+	original.WriteString("}\nvar samples=[]struct{bits,full int;a,b,control,status uint64}{\n")
+	driver.WriteString("};\nstatic const struct{unsigned bits,full;uint64_t a,b,control,status;} samples[]={\n")
+	for _, bits := range []int{16, 32, 64} {
+		for full := 0; full < 2; full++ {
+			for _, sample := range arm64BinarySamples(bits, full == 1) {
+				fmt.Fprintf(&original, "{%d,%d,%#x,%#x,%#x,%#x},\n", bits, full, sample.a, sample.b, sample.control, sample.status)
+				fmt.Fprintf(&driver, "{%d,%d,%#xULL,%#xULL,%#xULL,%#xULL},\n", bits, full, sample.a, sample.b, sample.control, sample.status)
+			}
+		}
+	}
+	original.WriteString(`}
+func main() {
+    for index,form:=range forms {
+        for _,sample:=range samples {
+            if sample.bits!=form.bits || sample.full!=form.full { continue }
+            var input [66]uint64
+            for word:=0;word<64;word++ { input[word]=0x123456789abcdef0+uint64(word)*0x0102030405060708 }
+            mask:=^uint64(0)
+            if form.bits<64 { mask=(uint64(1)<<form.bits)-1 }
+            input[2*form.first]=input[2*form.first]&^mask|sample.a
+            if form.first!=form.second { input[2*form.second]=input[2*form.second]&^mask|sample.b }
+            input[64],input[65]=sample.control,sample.status
+            before:=input
+            var output [69]uint64
+            output[67],output[68]=0x123456789abcdef0,0xfedcba9876543210
+            functions[index](&input,&output)
+            if input!=before { panic("original modified input") }
+            if err:=binary.Write(os.Stdout,binary.LittleEndian,output);err!=nil { panic(err) }
+        }
+    }
+}
+`)
+	fmt.Fprintf(&driver, "};\nint main(void) { FILE* expected=fopen(%q,\"rb\");if(!expected)return 2;unsigned count=0;\n", path)
+	driver.WriteString(`
+    for(unsigned index=0;index<sizeof(forms)/sizeof(forms[0]);index++) {
+        for(unsigned sample=0;sample<sizeof(samples)/sizeof(samples[0]);sample++) {
+            if(samples[sample].bits!=forms[index].bits || samples[sample].full!=forms[index].full) continue;
+            uint64_t input[66]={0},output[69]={0},before[66],want[69];
+            for(unsigned word=0;word<64;word++) input[word]=0x123456789abcdef0ULL+(uint64_t)word*0x0102030405060708ULL;
+            uint64_t mask=UINT64_MAX;
+            if(forms[index].bits<64) mask=(UINT64_C(1)<<forms[index].bits)-1;
+            unsigned first=2*forms[index].first,second=2*forms[index].second;
+            input[first]=(input[first]&~mask)|samples[sample].a;
+            if(first!=second) input[second]=(input[second]&~mask)|samples[sample].b;
+            input[64]=samples[sample].control;input[65]=samples[sample].status;
+            for(unsigned word=0;word<66;word++) before[word]=input[word];
+            output[67]=0x123456789abcdef0ULL;output[68]=0xfedcba9876543210ULL;
+            if(fread(want,sizeof(uint64_t),69,expected)!=69) return 3;
+            functions[index](input,output);
+            for(unsigned word=0;word<66;word++) if(input[word]!=before[word]) return 4;
+            for(unsigned word=0;word<69;word++) {
+                if(output[word]!=want[word]) {
+                    fprintf(stderr,"form=%u sample=%u word=%u got=%llx want=%llx\n",index,sample,word,(unsigned long long)output[word],(unsigned long long)want[word]);
+                    return 1;
+                }
+            }
+            count++;
+        }
+    }
+    if(fgetc(expected)!=EOF || fclose(expected)) return 5;
+    printf("ARM64_BINARY_TRANSLATED_PASS %u\n",count);
+    return 0;
+}
+`)
+	count := 0
+	for _, row := range cases {
+		count += len(arm64BinarySamples(row.bits, row.full))
+	}
+	return original.String(), driver.String(), count
+}
+
+func arm64BinaryCheckOriginal(t *testing.T, cases []arm64BinaryStateCase, output []byte) (nep, ah int) {
+	t.Helper()
+	position := 0
+	for _, row := range cases {
+		baseline := make(map[[2]uint64][2]uint64)
+		for _, sample := range arm64BinarySamples(row.bits, row.full) {
+			if len(output)-position < 69*8 {
+				t.Fatal("truncated original binary transcript")
+			}
+			var got [69]uint64
+			for index := range got {
+				got[index] = binary.LittleEndian.Uint64(output[position : position+8])
+				position += 8
+			}
+			if got[66] != []uint64{6, 8, 2, 3}[row.kind%4] || got[67] != 0x123456789abcdef0 || got[68] != 0xfedcba9876543210 || got[64]&sample.status != sample.status {
+				t.Fatalf("original changed NZCV/canary/cumulative status: %x", got[64:])
+			}
+			mask := ^uint64(0)
+			if row.bits < 64 {
+				mask = uint64(1)<<uint(row.bits) - 1
+			}
+			for word := 0; word < 64; word++ {
+				want := uint64(0x123456789abcdef0) + uint64(word)*0x0102030405060708
+				if word == 2*row.first {
+					want = want&^mask | sample.a
+				} else if word == 2*row.second {
+					want = want&^mask | sample.b
+				}
+				if word/2 != row.destination && got[word] != want {
+					t.Fatalf("original corrupted bank %d: got=%x want=%x", word, got[word], want)
+				}
+			}
+			if row.dead {
+				if got[2*row.destination] != 0 || got[2*row.destination+1] != 0 {
+					t.Fatal("dead fixture did not erase the destination")
+				}
+				continue
+			}
+			upperLow, upperHigh := uint64(0), uint64(0)
+			if got[65]&4 != 0 {
+				upperLow = (uint64(0x123456789abcdef0) + uint64(2*row.first)*0x0102030405060708) &^ mask
+				upperHigh = uint64(0x123456789abcdef0) + uint64(2*row.first+1)*0x0102030405060708
+				nep++
+			}
+			if got[2*row.destination]&^mask != upperLow || got[2*row.destination+1] != upperHigh {
+				t.Fatalf("original first-source NEP merge mismatch: %+v ctrl=%x result=%x", row, got[65], got[2*row.destination:2*row.destination+2])
+			}
+			key := [2]uint64{sample.a, sample.b}
+			value := [2]uint64{got[2*row.destination] & mask, got[64] & 0x1f}
+			if sample.control == 0 {
+				baseline[key] = value
+			} else if sample.control == 2 && got[65]&2 != 0 && value != baseline[key] {
+				ah++
+			}
+		}
+	}
+	if position != len(output) {
+		t.Fatal("extra original transcript bytes")
+	}
+	return nep, ah
+}
+
+func arm64BinaryStateRuntime(t *testing.T, triple, goos string, compiler, runner []string, requireAFP bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	cases := arm64BinaryStateCases()
+	total, nep, ah := 0, 0, 0
+	seen := make(map[arm64BinaryStateCase]bool)
+	for first := 0; first < len(cases); first += 32 {
+		last := first + 32
+		if last > len(cases) {
+			last = len(cases)
+		}
+		t.Run(fmt.Sprintf("batch%d", first/32), func(t *testing.T) {
+			batch := cases[first:last]
+			for _, row := range batch {
+				if seen[row] {
+					t.Fatalf("duplicate runtime form: %+v", row)
+				}
+				seen[row] = true
+			}
+			source, declarations := arm64BinaryStateSource(batch)
+			path := filepath.Join(t.TempDir(), "original.bin")
+			original, driver, count := arm64BinaryStatePrograms(batch, declarations, path)
+			output := arm64BinaryOriginalOutput(t, source, original, goos, runner)
+			if len(output) != count*69*8 {
+				t.Fatalf("original bytes=%d want=%d", len(output), count*69*8)
+			}
+			newNEP, newAH := arm64BinaryCheckOriginal(t, batch, output)
+			total, nep, ah = total+count, nep+newNEP, ah+newAH
+			t.Logf("actual original Go rows=%d NEP-merges=%d AH-differences=%d", count, newNEP, newAH)
+			if err := os.WriteFile(path, output, 0600); err != nil {
+				t.Fatal(err)
+			}
+			for api, ir := range arm64BinaryMatrixIRs(t, source, declarations, triple) {
+				for _, optimized := range []bool{false, true} {
+					if optimized {
+						ir = armFloatEffectOptimizedIR(t, ir)
+					}
+					for _, level := range []int{0, 2} {
+						t.Run(fmt.Sprintf("API%d/IR_O2=%t/backend_O%d", api, optimized, level), func(t *testing.T) {
+							compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "binary_state", triple, ir, driver, runner, level)
+						})
+					}
+				}
+			}
+		})
+	}
+	if total != 28214 || len(seen) != 157 {
+		t.Fatalf("changed complete runtime denominator: rows=%d forms=%d", total, len(seen))
+	}
+	if requireAFP && (nep == 0 || ah == 0) {
+		t.Fatalf("required actual AFP effects missing: NEP=%d AH=%d", nep, ah)
+	}
+	t.Logf("ARM64_BINARY_FULL_STATE_PASS original=%d LLVM=%d NEP=%d AH=%d", total, total*16, nep, ah)
+}
+
+func TestARM64ScalarBinaryFullStateNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin native counterpart; required Linux/QEMU owner covers other hosts")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	arm64BinaryStateRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil, false)
+}
diff --git a/arm64_scalar_compare_effects_test.go b/arm64_scalar_compare_effects_test.go
new file mode 100644
index 000000000..1bc4c7c91
--- /dev/null
+++ b/arm64_scalar_compare_effects_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarCompareNativeEffectsRemainSourceBound(t *testing.T) {
+	for _, row := range arm64CompareCases([]int{0, 31}, false) {
+		if row.dead {
+			continue
+		}
+		for _, initialized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/initialized=%t", row.instruction(), initialized), func(t *testing.T) {
+				ctx, flow := arm64FlagScratchBankFixture()
+				flow.used, flow.entry = true, &ARM64GoRegisterABI{}
+				ctx.vRegSlot = map[int]string{row.left: "%left", row.right: "%right"}
+				if initialized {
+					ctx.recordMachineRegister(Reg(fmt.Sprintf("F%d", row.left)), row.bits, true)
+					if !row.zero {
+						ctx.recordMachineRegister(Reg(fmt.Sprintf("F%d", row.right)), row.bits, true)
+					}
+				}
+				file, err := Parse(ArchARM64, "TEXT effect(SB),4,$0-0\n"+row.instruction()+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				instruction := file.Funcs[0].Instrs[0]
+				if instruction.Op == OpTEXT {
+					instruction = file.Funcs[0].Instrs[1]
+				}
+				before, start := len(flow.blocks[0].effects), ctx.b.Len()
+				matched, _, err := ctx.lowerARM64ScalarFloatCompare(instruction.Op, instruction)
+				if !matched || err != nil {
+					t.Fatalf("typed native lowerer: matched=%t err=%v", matched, err)
+				}
+				ctx.recordMachineOpaqueIR(start, instruction)
+				reads, flags := 0, arm64FlagMask(0)
+				for _, effect := range flow.blocks[0].effects[before:] {
+					if effect.opaque || effect.store || effect.unavailable {
+						t.Fatalf("native compare gained an unrelated effect: %+v", effect)
+					}
+					if effect.nzcv != 0 {
+						if !effect.write {
+							t.Fatal("compare read an incoming NZCV bit")
+						}
+						flags |= effect.nzcv
+					} else {
+						if effect.write || !strings.HasPrefix(effect.register, "V") || effect.width != row.bits {
+							t.Fatalf("compare changed source width or wrote a register: %+v", effect)
+						}
+						reads++
+					}
+				}
+				wantReads := 2
+				if row.zero {
+					wantReads = 1
+				}
+				if reads != wantReads || flags != arm64FlagAll {
+					t.Fatalf("got reads=%d flags=%x", reads, flags)
+				}
+				err = flow.validate()
+				if initialized && err != nil || !initialized && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("native compare invented initialized source registers: %v", err)
+				}
+				// The exact paired callout is not a whitelist for another native
+				// callout, even if it appears in the same source instruction.
+				start = ctx.b.Len()
+				fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+				ctx.recordMachineOpaqueIR(start, instruction)
+				if !flow.blocks[0].effects[len(flow.blocks[0].effects)-1].opaque {
+					t.Fatal("compare callout proof leaked to unrelated native IR")
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_scalar_compare_matrix_test.go b/arm64_scalar_compare_matrix_test.go
new file mode 100644
index 000000000..c15d398fa
--- /dev/null
+++ b/arm64_scalar_compare_matrix_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64CompareCase struct {
+	op          string
+	bits        int
+	left, right int
+	zero, dead  bool
+	raw         bool
+}
+
+func arm64CompareCases(banks []int, raw bool) []arm64CompareCase {
+	var cases []arm64CompareCase
+	for _, op := range arm64ScalarCompareNames {
+		bits := 32
+		if strings.HasSuffix(op, "D") {
+			bits = 64
+		}
+		for _, bank := range banks {
+			for _, form := range []int{0, 1, 2} {
+				for _, dead := range []bool{false, true} {
+					right := (bank + 1) % 32
+					if form == 1 {
+						right = bank
+					}
+					cases = append(cases, arm64CompareCase{op, bits, bank, right, form == 2, dead, raw})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func (row arm64CompareCase) instruction() string {
+	if row.raw {
+		word := uint32(0x1e202000) | uint32(row.left)<<5
+		if row.bits == 64 {
+			word |= 1 << 22
+		} else if row.bits == 16 {
+			word |= 3 << 22
+		}
+		if strings.Contains(row.op, "E") {
+			word |= 1 << 4
+		}
+		if row.zero {
+			word |= 1 << 3
+		} else {
+			word |= uint32(row.right) << 16
+		}
+		return fmt.Sprintf("WORD $%#08x", word)
+	}
+	if row.zero {
+		// Nonzero C_FCON spellings are accepted by Go and encode zero.
+		return fmt.Sprintf("%s $(-1.25),F%d", row.op, row.left)
+	}
+	return fmt.Sprintf("%s F%d,F%d", row.op, row.right, row.left)
+}
+
+func arm64CompareMatrixSource(cases []arm64CompareCase) (source, goSource string) {
+	var assembly, declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index, row := range cases {
+		name := fmt.Sprintf("compareMatrix%d", index)
+		fmt.Fprintf(&declarations, "func %s(*[66]uint64,*[69]uint64)\n", name)
+		fmt.Fprintf(&assembly, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for register := 0; register < 32; register++ {
+			fmt.Fprintf(&assembly, "VLD1.P 16(R0),[V%d.B16]\n", register)
+		}
+		assembly.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD (R0),R12\nMSR R12,FPCR\nMOVD 8(R0),R12\nMSR R12,FPSR\n")
+		assembly.WriteString(row.instruction() + "\n")
+		if row.dead {
+			assembly.WriteString("CMP R0,R0\n")
+		}
+		assembly.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET CS,R4\nCSET VS,R5\nLSL $3,R2,R2\nLSL $2,R3,R3\nLSL $1,R4,R4\nORR R3,R2,R2\nORR R4,R2,R2\nORR R5,R2,R2\n")
+		assembly.WriteString("MRS FPCR,R3\nMRS FPSR,R4\n")
+		for register := 0; register < 32; register++ {
+			fmt.Fprintf(&assembly, "VST1.P [V%d.B16],16(R1)\n", register)
+		}
+		assembly.WriteString("MOVD R2,(R1)\nMOVD R4,8(R1)\nMOVD R3,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return assembly.String(), declarations.String()
+}
+
+func arm64CompareMatrixIRs(t *testing.T, source, goSource, triple string) []string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "compare", goSource)
+	sizes := types.SizesFor("gc", "arm64")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+	text, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	direct := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBound := bound.Module.String()
+	bound.Module.Dispose()
+	return []string{text, direct, goBound}
+}
+
+func TestARM64ScalarCompareNativeFamilyObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	// Every source/destination register occurs, including same-register aliases.
+	// Raw H/S/D is a separate existing decoder domain, never a named H grant.
+	var banks []int
+	for bank := 0; bank < 32; bank++ {
+		banks = append(banks, bank)
+	}
+	cases := arm64CompareCases(banks, false)
+	raw := arm64CompareCases([]int{0, 31}, true)
+	for _, row := range raw {
+		if row.bits == 32 {
+			row.bits = 16
+			cases = append(cases, row)
+		}
+	}
+	cases = append(cases, raw...)
+	// One initialized register bank is enough for format/object coverage. The
+	// runtime matrix separately tests each operation with complete bank output.
+	var fixture strings.Builder
+	fixture.WriteString("TEXT compareMatrix0(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n")
+	for register := 0; register < 32; register++ {
+		fmt.Fprintf(&fixture, "VLD1.P 16(R0),[V%d.B16]\n", register)
+	}
+	for _, row := range cases {
+		fixture.WriteString(row.instruction() + "\n")
+		if row.dead {
+			fixture.WriteString("CMP R0,R0\n")
+		}
+	}
+	fixture.WriteString("CSET VS,R2\nMOVD R2,(R1)\nRET\n")
+	source := fixture.String()
+	declarations := "package compare\nfunc compareMatrix0(*[66]uint64,*[69]uint64)\n"
+	for _, target := range []struct{ goos, triple string }{
+		{"darwin", "aarch64-apple-darwin"},
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			arm64CompareGoObject(t, source, target.goos)
+			for api, ir := range arm64CompareMatrixIRs(t, source, declarations, target.triple) {
+				if got := strings.Count(ir, `asm sideeffect "fcmp`); got != len(cases) {
+					t.Fatalf("API %d kept %d/%d native comparisons", api, got, len(cases))
+				}
+				optimized := armFloatEffectOptimizedIR(t, ir)
+				if got := strings.Count(optimized, `asm sideeffect "fcmp`); got != len(cases) {
+					t.Fatalf("API %d removed a dead native compare: %d/%d", api, got, len(cases))
+				}
+				compileLLVMToObject(t, llc, target.triple, "compare-matrix.ll", "compare-matrix.o", optimized)
+			}
+		})
+	}
+	t.Logf("%d initialized named/raw/register/zero/bank/alias/live/dead rows ×3 APIs ×3 OS objects", len(cases))
+}
+
+func TestARM64ScalarCompareNativeMalformedFamily(t *testing.T) {
+	for _, op := range arm64ScalarCompareNames {
+		for _, suffix := range []string{
+			" F0", " F0,F1,F2", " R0,F1", " F0,R1", " V0.S4,F1",
+			" $0,F1", " $(1),F1", " (R0),F1", " F0,(R1)", ".P F0,F1",
+		} {
+			t.Run(op+suffix, func(t *testing.T) {
+				source := "TEXT invalid(SB),4,$0-0\n" + op + suffix + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				context := llvm.NewContext()
+				defer context.Dispose()
+				pkg := mustGoPackage(t, "compare", "package compare\nfunc invalid()\n")
+				for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+					options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{"invalid": {Name: "invalid", Ret: Void}}}
+					if ir, err := Translate(file, options); err == nil || ir != "" {
+						t.Fatalf("invalid form acquired text IR: %v", err)
+					}
+					module, err := TranslateModuleInContext(context, file, options)
+					if !module.IsNil() {
+						module.Dispose()
+						t.Fatal("invalid form published LLVM module")
+					}
+					if err == nil {
+						t.Fatal("invalid form has no module error")
+					}
+					bound, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: triple})
+					if bound != nil {
+						bound.Module.Dispose()
+						t.Fatal("invalid form published Go module")
+					}
+					if err == nil {
+						t.Fatal("invalid form has no Go module error")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_scalar_compare_native_linux_test.go b/arm64_scalar_compare_native_linux_test.go
new file mode 100644
index 000000000..a09e8d3c7
--- /dev/null
+++ b/arm64_scalar_compare_native_linux_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarCompareDeadNative(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64ScalarCompareDeadRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarCompareWholeState(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64CompareStatusRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_scalar_compare_native_test.go b/arm64_scalar_compare_native_test.go
new file mode 100644
index 000000000..f223402ec
--- /dev/null
+++ b/arm64_scalar_compare_native_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// asm7.go case 56: FREG,FREG and FCON,FREG; all FCON values encode zero.
+// This table is independent of the lowering and includes both NaN policies.
+var arm64ScalarCompareNames = []string{"FCMPS", "FCMPD", "FCMPES", "FCMPED"}
+
+func arm64ScalarCompareDeadFixture() (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, op := range arm64ScalarCompareNames {
+		name := fmt.Sprintf("compareDead%d", index)
+		sigs[name] = arm64SM3Signature(name)
+		move := "FMOVS"
+		if strings.HasSuffix(op, "D") {
+			move = "FMOVD"
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMSR ZR,FPCR\nMSR ZR,FPSR\n")
+		fmt.Fprintf(&source, "%s (R0),F31\n%s F31,F31\n", move, op)
+		// NZCV is intentionally dead: the instruction must still update FPSR.
+		source.WriteString("MRS FPSR,R2\nMOVD R2,(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), sigs
+}
+
+func TestARM64ScalarCompareDeadNativeIR(t *testing.T) {
+	source, sigs := arm64ScalarCompareDeadFixture()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, operation := range []string{`asm sideeffect "fcmp `, `asm sideeffect "fcmpe `} {
+		if strings.Count(ir, operation) != 2 {
+			t.Errorf("four dead comparisons must retain their actual quiet/signaling operation: missing %s", operation)
+		}
+	}
+}
+
+func arm64ScalarCompareActualGo(t *testing.T, source, main, goos string, runner []string) {
+	t.Helper()
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":         "module compareoracle\n\ngo 1.20\n",
+		"main.go":        main,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT compare", "TEXT ·compare"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	arguments := []string{"run", "-p=1"}
+	if len(runner) != 0 {
+		arguments = append(arguments, "-exec="+strings.Join(runner, " "))
+	}
+	command := exec.CommandContext(ctx, "go", append(arguments, ".")...)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || !strings.Contains(string(output), "ARM64_COMPARE_ORIGINAL_PASS") {
+		t.Fatalf("actual original Go compare: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+}
+
+func arm64CompareGoObject(t *testing.T, source, goos string) {
+	t.Helper()
+	directory := t.TempDir()
+	assembly, object := filepath.Join(directory, "compare.s"), filepath.Join(directory, "compare.o")
+	if err := os.WriteFile(assembly, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "compare", "-o", object, assembly)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(assembly, object, output, err, ctx.Err(), true, "arm64"); failure != nil {
+		t.Fatalf("actual Go %s object: %v\n%s", goos, failure, output)
+	}
+}
+
+func arm64ScalarCompareDeadRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, sigs := arm64ScalarCompareDeadFixture()
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range arm64ScalarCompareNames {
+		fmt.Fprintf(&original, "func compareDead%d(*uint64,*uint64)\n", index)
+		fmt.Fprintf(&driver, "extern void compareDead%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) { uint64_t input,output;\n")
+	for index, op := range arm64ScalarCompareNames {
+		for _, signaling := range []bool{false, true} {
+			value := uint64(0x7ff8000000000001)
+			if signaling {
+				value = 0x7ff0000000000001
+			}
+			if strings.HasSuffix(op, "S") {
+				value = 0x7fc00001
+				if signaling {
+					value = 0x7f800001
+				}
+			}
+			want := 0
+			if signaling || strings.Contains(op, "E") {
+				want = 1
+			}
+			fmt.Fprintf(&original, "{ input:=uint64(%#x); var output uint64; compareDead%d(&input,&output); if output!=%d { panic(fmt.Sprintf(\"%s signaling=%t got %%x want %d\",output)) } }\n", value, index, want, op, signaling, want)
+			fmt.Fprintf(&driver, "input=%#xULL;output=0;compareDead%d(&input,&output);if(output!=%d){fprintf(stderr,\"%s signaling=%t got %%llx want %d\\n\",(unsigned long long)output);return 1;}\n", value, index, want, op, signaling, want)
+		}
+	}
+	original.WriteString("fmt.Println(\"ARM64_COMPARE_ORIGINAL_PASS dead NaN\")\n}\n")
+	driver.WriteString("return 0;\n}\n")
+	arm64ScalarCompareActualGo(t, source, original.String(), goos, runner)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "compare_dead", triple, variant.ir, driver.String(), runner, level)
+			})
+		}
+	}
+}
+
+func TestARM64ScalarCompareDeadNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU matrix also runs the same original-source oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64ScalarCompareDeadRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_scalar_compare_status_test.go b/arm64_scalar_compare_status_test.go
new file mode 100644
index 000000000..37c3e03de
--- /dev/null
+++ b/arm64_scalar_compare_status_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Integer-only IEEE reference: no host float operation or production helper.
+// Arm FPCompare unpacks both operands using FPCR, signals sNaNs (all NaNs
+// for FCMPE), and writes 0011/1000/0110/0010 for unordered/less/equal/greater.
+func arm64CompareExpected(bits int, left, right, control uint64, signaling bool) (flags, status uint64) {
+	fractionBits, exponentBits := uint(23), uint(8)
+	if bits == 64 {
+		fractionBits, exponentBits = 52, 11
+	} else if bits == 16 {
+		fractionBits, exponentBits = 10, 5
+	}
+	fraction := uint64(1)<<fractionBits - 1
+	exponent := (uint64(1)<<exponentBits - 1) << fractionBits
+	sign := uint64(1) << uint(bits-1)
+	left &= sign | exponent | fraction
+	right &= sign | exponent | fraction
+	nan := false
+	for _, operand := range []*uint64{&left, &right} {
+		value := *operand
+		if value&exponent == exponent && value&fraction != 0 {
+			nan = true
+			if signaling || value&(uint64(1)<<(fractionBits-1)) == 0 {
+				status |= 1
+			}
+		}
+		flush := control&(1<<24) != 0
+		if bits == 16 {
+			flush = control&(1<<19) != 0
+		}
+		if flush && value&exponent == 0 && value&fraction != 0 {
+			*operand = value & sign
+			if bits != 16 {
+				status |= 1 << 7
+			}
+		}
+	}
+	if nan {
+		return 3, status
+	}
+	if left == right || left&^sign == 0 && right&^sign == 0 {
+		return 6, status
+	}
+	less := left < right
+	if (left^right)&sign != 0 {
+		less = left&sign != 0
+	} else if left&sign != 0 {
+		less = left > right
+	}
+	if less {
+		return 8, status
+	}
+	return 2, status
+}
+
+func arm64CompareValues(bits int) []uint64 {
+	if bits == 16 {
+		return []uint64{0, 0x8000, 0x3c00, 0xbc00, 0x7c00, 0xfc00, 0x7e01, 0xfe01, 0x7c01, 0xfc01, 1, 0x8001, 0x3ff, 0x400, 0x7bff, 0xfbff}
+	}
+	if bits == 32 {
+		return []uint64{0, 0x80000000, 0x3f800000, 0xbf800000, 0x7f800000, 0xff800000, 0x7fc00001, 0xffc00001, 0x7f800001, 0xff800001, 1, 0x80000001, 0x007fffff, 0x00800000, 0x7f7fffff, 0xff7fffff}
+	}
+	return []uint64{0, 0x8000000000000000, 0x3ff0000000000000, 0xbff0000000000000, 0x7ff0000000000000, 0xfff0000000000000, 0x7ff8000000000001, 0xfff8000000000001, 0x7ff0000000000001, 0xfff0000000000001, 1, 0x8000000000000001, 0x000fffffffffffff, 0x0010000000000000, 0x7fefffffffffffff, 0xffefffffffffffff}
+}
+
+func arm64CompareStatusPrograms(cases []arm64CompareCase) (string, string, int) {
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "func compareMatrix%d(*[66]uint64,*[69]uint64)\n", index)
+		fmt.Fprintf(&driver, "extern void compareMatrix%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("var functions = [...]func(*[66]uint64,*[69]uint64){\n")
+	driver.WriteString("static void (*functions[])(uint64_t*,uint64_t*)={\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "compareMatrix%d,\n", index)
+		fmt.Fprintf(&driver, "compareMatrix%d,\n", index)
+	}
+	original.WriteString("}\nvar forms = []struct { bits,left,right,mode int; signaling,dead bool }{\n")
+	driver.WriteString("};\nstatic const struct { int bits,left,right,mode,signaling,dead; } forms[]={\n")
+	for _, row := range cases {
+		mode, signaling, dead := 0, 0, 0
+		if row.left == row.right {
+			mode = 1
+		}
+		if row.zero {
+			mode = 2
+		}
+		if strings.Contains(row.op, "E") {
+			signaling = 1
+		}
+		if row.dead {
+			dead = 1
+		}
+		fmt.Fprintf(&original, "{%d,%d,%d,%d,%t,%t},\n", row.bits, row.left, row.right, mode, signaling != 0, row.dead)
+		fmt.Fprintf(&driver, "{%d,%d,%d,%d,%d,%d},\n", row.bits, row.left, row.right, mode, signaling, dead)
+	}
+	original.WriteString("}\nvar samples = []struct { bits,mode int; a,b,control,flags,quiet,signaling uint64 }{\n")
+	driver.WriteString("};\nstatic const struct { int bits,mode; uint64_t a,b,control,flags,quiet,signaling; } samples[]={\n")
+	seen := make(map[int]bool)
+	count := 0
+	for _, row := range cases {
+		if seen[row.bits] {
+			continue
+		}
+		seen[row.bits] = true
+		for mode := 0; mode < 3; mode++ {
+			for _, left := range arm64CompareValues(row.bits) {
+				for rightIndex, value := range arm64CompareValues(row.bits) {
+					right := value
+					if mode != 0 && rightIndex != 0 {
+						continue
+					}
+					if mode == 1 {
+						right = left
+					} else if mode == 2 {
+						right = 0
+					}
+					for rounding := 0; rounding < 4; rounding++ {
+						for controls := 0; controls < 4; controls++ {
+							control := uint64(rounding)<<22 | uint64(controls&1)<<24 | uint64(controls>>1)<<25
+							if row.bits == 16 && controls&1 != 0 {
+								control |= 1 << 19
+							}
+							flags, quiet := arm64CompareExpected(row.bits, left, right, control, false)
+							_, signaling := arm64CompareExpected(row.bits, left, right, control, true)
+							fmt.Fprintf(&original, "{%d,%d,%#x,%#x,%#x,%#x,%#x,%#x},\n", row.bits, mode, left, right, control, flags, quiet, signaling)
+							fmt.Fprintf(&driver, "{%d,%d,%#xULL,%#xULL,%#xULL,%#xULL,%#xULL,%#xULL},\n", row.bits, mode, left, right, control, flags, quiet, signaling)
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	original.WriteString(`}
+func main() {
+    count:=0
+    for function,form:=range forms {
+        for _,sample:=range samples {
+            if sample.bits!=form.bits || sample.mode!=form.mode { continue }
+            var input [66]uint64
+            for i:=0;i<64;i++ { input[i]=0x123456789abcdef0+uint64(i)*0x0102030405060708 }
+            mask:=^uint64(0)
+            if form.bits<64 { mask=(uint64(1)<<form.bits)-1 }
+            input[2*form.left]=input[2*form.left]&^mask|sample.a
+            if form.mode==0 { input[2*form.right]=input[2*form.right]&^mask|sample.b }
+            input[64],input[65]=sample.control,0x08000002
+            var output,want [69]uint64
+            copy(want[:64],input[:64])
+            want[64],want[65],want[66]=sample.flags,input[65]|sample.quiet,input[64]
+            if form.signaling { want[65]=input[65]|sample.signaling }
+            if form.dead { want[64]=6 }
+            output[67],output[68]=0x123456789abcdef0,0xfedcba9876543210
+            want[67],want[68]=output[67],output[68]
+            functions[function](&input,&output)
+            if output!=want { panic(fmt.Sprintf("function %d sample %+v got %x want %x",function,sample,output,want)) }
+            count++
+        }
+    }
+    fmt.Println("ARM64_COMPARE_ORIGINAL_PASS",count)
+}
+`)
+	driver.WriteString(`};
+int main(void) {
+    unsigned count=0;
+    for(unsigned function=0;function<sizeof(forms)/sizeof(forms[0]);function++) {
+        for(unsigned index=0;index<sizeof(samples)/sizeof(samples[0]);index++) {
+            if(samples[index].bits!=forms[function].bits || samples[index].mode!=forms[function].mode) continue;
+            uint64_t input[66]={0},output[69]={0},want[69]={0};
+            for(unsigned i=0;i<64;i++) input[i]=0x123456789abcdef0ULL+(uint64_t)i*0x0102030405060708ULL;
+            uint64_t mask=UINT64_MAX;
+            if(forms[function].bits<64) mask=(UINT64_C(1)<<forms[function].bits)-1;
+            unsigned left=2*forms[function].left,right=2*forms[function].right;
+            input[left]=(input[left]&~mask)|samples[index].a;
+            if(forms[function].mode==0) input[right]=(input[right]&~mask)|samples[index].b;
+            input[64]=samples[index].control;input[65]=0x08000002;
+            for(unsigned i=0;i<64;i++) want[i]=input[i];
+            want[64]=forms[function].dead?6:samples[index].flags;
+            want[65]=input[65]|(forms[function].signaling?samples[index].signaling:samples[index].quiet);
+            want[66]=input[64];
+            output[67]=want[67]=0x123456789abcdef0ULL;
+            output[68]=want[68]=0xfedcba9876543210ULL;
+            functions[function](input,output);
+            for(unsigned word=0;word<69;word++) {
+                if(output[word]!=want[word]) {
+                    fprintf(stderr,"function %u sample %u word %u got %llx want %llx\n",function,index,word,(unsigned long long)output[word],(unsigned long long)want[word]);
+                    return 1;
+                }
+            }
+            count++;
+        }
+    }
+    printf("ARM64_COMPARE_TRANSLATED_PASS %u\n",count);
+    return 0;
+}
+`)
+	return original.String(), driver.String(), count
+}
+
+func arm64CompareStatusRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	cases := arm64CompareCases([]int{0, 15, 31}, false)
+	raw := arm64CompareCases([]int{31}, true)
+	cases = append(cases, raw...)
+	for _, row := range raw {
+		if row.bits == 32 {
+			row.bits = 16
+			cases = append(cases, row)
+		}
+	}
+	source, declarations := arm64CompareMatrixSource(cases)
+	original, driver, samples := arm64CompareStatusPrograms(cases)
+	arm64ScalarCompareActualGo(t, source, original, goos, runner)
+	// The three API object gate is separate. Runtime exercises the typed Go
+	// consumer and both IR/backend optimization axes on the same original file.
+	ir := arm64CompareMatrixIRs(t, source, declarations, triple)[2]
+	for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "compare_status", triple, variant.ir, driver, runner, level)
+			})
+		}
+	}
+	t.Logf("%d named/raw/live/dead/zero/alias/bank kernels; %d integer IEEE/FPCR reference samples; entire 32-V bank, NZCV, FPSR, FPCR and output canaries", len(cases), samples)
+}
+
+func TestARM64ScalarCompareWholeStateRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin host counterpart; required Linux/QEMU matrix runs the same complete oracle")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
+	}
+	arm64CompareStatusRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_scalar_compare_target.go b/arm64_scalar_compare_target.go
new file mode 100644
index 000000000..eb5073d37
--- /dev/null
+++ b/arm64_scalar_compare_target.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func validateARM64ScalarCompareTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			op := Op(strings.SplitN(strings.ToUpper(string(instruction.Op)), ".", 2)[0])
+			_, matched, err := parseARM64ScalarCompare(op, instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+			_, matched, err = parseARM64ConditionalCompare(op, instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+			if instruction.Op != OpWORD {
+				continue
+			}
+			if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+				instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+				// Only decoded members belong to this family's target check.
+				// Symbolic constants and unrelated malformed WORD operands keep
+				// their existing resolution and generic-validation ownership.
+				continue
+			}
+			word := uint32(instruction.Args[0].Imm)
+			if word&0xff200c00 == 0x1e200400 {
+				if _, valid := decodeARM64RawConditionalCompare(word); !valid {
+					return fmt.Errorf("unsupported ARM64 conditional compare WORD encoding %#08x: %q", word, instruction.Raw)
+				}
+				needsNative = true
+				continue
+			}
+			if word&0xff20fc00 != 0x1e202000 {
+				continue
+			}
+			// Complete architectural scalar-compare class, including reserved
+			// ftype/opc fields. Do not turn malformed raw source into Context.
+			if _, valid := decodeARM64RawScalarFloatCompare(word); !valid {
+				return fmt.Errorf("unsupported ARM64 scalar compare WORD encoding %#08x: %q", word, instruction.Raw)
+			}
+			needsNative = true
+		}
+	}
+	if !needsNative {
+		return nil
+	}
+	return requireARM64ScalarCompareTarget(options.Goarch, options.TargetTriple)
+}
+
+func requireARM64ScalarCompareTarget(goarch, target string) error {
+	arch := strings.SplitN(target, "-", 2)[0]
+	if (arch != "aarch64" && arch != "arm64") || goarch != "" && goarch != "arm64" {
+		return fmt.Errorf("%w: ARM64 scalar compare requires an explicit native little-endian AArch64 FPCR/FPSR target, got %q/%q",
+			ErrProbeNeedsContext, goarch, target)
+	}
+	return nil
+}
diff --git a/arm64_scalar_compare_target_test.go b/arm64_scalar_compare_target_test.go
new file mode 100644
index 000000000..d3b4d8ac7
--- /dev/null
+++ b/arm64_scalar_compare_target_test.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64CompareTargetAPI(t *testing.T, api, source, triple string) (bool, error) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return false, err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"comparison": {Name: "comparison", Ret: Void}},
+	}
+	if api == "text" {
+		ir, err := Translate(file, options)
+		return ir != "", err
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(context, file, options)
+		present := !module.IsNil()
+		if present {
+			module.Dispose()
+		}
+		return present, err
+	}
+	pkg := mustGoPackage(t, "comparison", "package comparison\nfunc comparison()\n")
+	bound, err := translateGoModuleInContext(context, pkg,
+		[]byte(strings.ReplaceAll(source, "TEXT comparison", "TEXT ·comparison")),
+		GoModuleOptions{GOOS: "linux", GOARCH: "arm64", TargetTriple: triple})
+	if bound != nil {
+		bound.Module.Dispose()
+	}
+	return bound != nil, err
+}
+
+func TestARM64ScalarCompareRequiresNativeTarget(t *testing.T) {
+	var instructions []string
+	for _, row := range arm64CompareCases([]int{31}, false) {
+		if !row.dead {
+			instructions = append(instructions, row.instruction())
+		}
+	}
+	for _, row := range arm64CompareCases([]int{31}, true) {
+		if !row.dead {
+			instructions = append(instructions, row.instruction())
+			if row.bits == 32 {
+				row.bits = 16
+				instructions = append(instructions, row.instruction())
+			}
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "armv7-unknown-linux-gnueabihf", "aarch64_be-unknown-linux-gnu", "aarch64bad-unknown-linux-gnu"} {
+			for _, dead := range []bool{false, true} {
+				for _, instruction := range instructions {
+					t.Run(fmt.Sprintf("%s/%s/dead=%t/%s", api, triple, dead, instruction), func(t *testing.T) {
+						prefix := ""
+						if dead {
+							prefix = "RET\n"
+						}
+						source := "TEXT comparison(SB),4,$0-0\n" + prefix + instruction + "\nRET\n"
+						present, err := arm64CompareTargetAPI(t, api, source, triple)
+						if present || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("native compare target missing but output=%t err=%v", present, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarCompareTargetKeepsMalformedSourcePriority(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+			for _, invalid := range []string{"FCMPS F0", "FCMPD R0,F1", "FCMPES $0,F1", "FCMPED.P F0,F1", "WORD $0x1e202001", "WORD $0x1ea02000"} {
+				for _, body := range []string{invalid, "FCMPS F0,F1\n" + invalid, "FCMPS F0,F1\nRET\n" + invalid, invalid + "\nFCMPD F0,F1"} {
+					source := "TEXT comparison(SB),4,$0-0\n" + body + "\nRET\n"
+					present, err := arm64CompareTargetAPI(t, api, source, triple)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s %s malformed source changed to native context/output: %t %v\n%s", api, triple, present, err, source)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarCompareTargetKeepsNativeAndOrdinaryForms(t *testing.T) {
+	const source = "TEXT comparison(SB),4,$0-0\nFCMPS F0,F1\nFCMPED $(-1.25),F31\nWORD $0x1ee02000\nRET\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "arm64-apple-darwin", "aarch64-pc-windows-msvc"} {
+			present, err := arm64CompareTargetAPI(t, api, source, triple)
+			if !present || err != nil {
+				t.Fatalf("%s explicit native %s rejected: %v", api, triple, err)
+			}
+		}
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			present, err := arm64CompareTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\nRET\n", triple)
+			if !present || err != nil {
+				t.Fatalf("%s non-family portability changed: %v", api, err)
+			}
+		}
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, goarch := range []string{"amd64", "386", "arm", "wasm"} {
+		if err := validateARM64ScalarCompareTarget(file, Options{Goarch: goarch, TargetTriple: "aarch64-unknown-linux-gnu"}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("native target accepted conflicting GOARCH=%s: %v", goarch, err)
+		}
+	}
+}
+
+func TestARM64ScalarCompareTargetLeavesUnidentifiedWordsToGenericValidation(t *testing.T) {
+	for _, operands := range [][]Operand{
+		nil,
+		{{Kind: OpImm, Imm: 1}, {Kind: OpImm, Imm: 2}},
+		{{Kind: OpReg, Reg: "R0"}},
+		{{Kind: OpImm, ImmRaw: "$(COMPARE_OPCODE)"}},
+		{{Kind: OpImm, ImmRaw: "$(COMPARE_BASE | (31 << 5))"}},
+		{{Kind: OpImm, ImmIsFloat: true}},
+		{{Kind: OpImm, Imm: 0xd503201f}}, // NOP, outside the compare class.
+	} {
+		file, err := Parse(ArchARM64, "TEXT comparison(SB),4,$0-0\nWORD $0\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if file.Funcs[0].Instrs[1].Op != OpWORD {
+			t.Fatal("fixture no longer selects the WORD instruction")
+		}
+		file.Funcs[0].Instrs[1].Args = operands
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+			if err := validateARM64ScalarCompareTarget(file, Options{TargetTriple: triple}); err != nil {
+				t.Fatalf("compare preflight claimed unrelated WORD operands %+v: %v", operands, err)
+			}
+		}
+	}
+}
diff --git a/arm64_scalar_conversion.go b/arm64_scalar_conversion.go
new file mode 100644
index 000000000..e6b5849cf
--- /dev/null
+++ b/arm64_scalar_conversion.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ScalarConversionSpec struct {
+	floatBits, integerBits int
+	toFloat, unsigned      bool
+	simdInteger            bool
+}
+
+var arm64ScalarConversionSpecs = map[Op]arm64ScalarConversionSpec{
+	"FCVTZSD": {64, 64, false, false, false}, "FCVTZSDW": {64, 32, false, false, false},
+	"FCVTZSS": {32, 64, false, false, false}, "FCVTZSSW": {32, 32, false, false, false},
+	"FCVTZUD": {64, 64, false, true, false}, "FCVTZUDW": {64, 32, false, true, false},
+	"FCVTZUS": {32, 64, false, true, false}, "FCVTZUSW": {32, 32, false, true, false},
+	"SCVTFD": {64, 64, true, false, false}, "SCVTFS": {32, 64, true, false, false},
+	"SCVTFWD": {64, 32, true, false, false}, "SCVTFWS": {32, 32, true, false, false},
+	"UCVTFD": {64, 64, true, true, false}, "UCVTFS": {32, 64, true, true, false},
+	"UCVTFWD": {64, 32, true, true, false}, "UCVTFWS": {32, 32, true, true, false},
+	// These existing decoder spellings describe scalar SIMD integer carriers,
+	// not the GP operand classes of Go asm7 case 29.
+	"SCVTFDD": {64, 64, true, false, true}, "SCVTFSS": {32, 32, true, false, true},
+	"UCVTFDD": {64, 64, true, true, true}, "UCVTFSS": {32, 32, true, true, true},
+}
+
+type arm64ScalarConversionForm struct {
+	arm64ScalarConversionSpec
+	source, destination Reg
+	rounding            arm64FloatToIntegerRounding
+}
+
+func parseARM64ScalarConversion(op Op, instruction Instr) (arm64ScalarConversionForm, bool, error) {
+	spec, matched := arm64ScalarConversionSpecs[op]
+	if !matched {
+		return arm64ScalarConversionForm{}, false, nil
+	}
+	if spec.simdInteger && !instruction.arm64Encoded {
+		return arm64ScalarConversionForm{}, true, fmt.Errorf("arm64 %s is a decoder-only scalar conversion, not a Go source opcode: %q", op, instruction.Raw)
+	}
+	if strings.ToUpper(string(instruction.Op)) != string(op) || len(instruction.Args) != 2 ||
+		instruction.Args[0].Kind != OpReg || instruction.Args[1].Kind != OpReg {
+		return arm64ScalarConversionForm{}, true, fmt.Errorf("arm64 %s expects two scalar registers and no suffix: %q", op, instruction.Raw)
+	}
+	source, destination := instruction.Args[0].Reg, instruction.Args[1].Reg
+	sourceOK, destinationOK := isARM64FReg(source), isARM64GeneralOrZeroReg(destination)
+	if spec.toFloat {
+		sourceOK, destinationOK = isARM64GeneralOrZeroReg(source), isARM64FReg(destination)
+		if spec.simdInteger {
+			sourceOK = isARM64FReg(source)
+		}
+	}
+	if !sourceOK || !destinationOK {
+		return arm64ScalarConversionForm{}, true, fmt.Errorf("arm64 %s has the wrong scalar register classes: %q", op, instruction.Raw)
+	}
+	return arm64ScalarConversionForm{spec, source, destination, arm64FloatRoundZero}, true, nil
+}
+
+// Only the written scalar bits become newly defined. FEAT_AFP permits the
+// native instruction to preserve old destination bits when FPCR.NEP is set.
+// Without a source-bound NEP=0 proof, virtual zero-filled slots do not define
+// those bits. This is the existing lane-write rule, not a new caller grant.
+func (c *arm64Ctx) recordARM64ScalarConversion(form arm64ScalarConversionForm) func() {
+	flow := c.machineAvailability
+	if flow == nil || flow.flagsOnly || flow.suspended != 0 {
+		return func() {}
+	}
+	sourceBits, resultBits := form.floatBits, form.integerBits
+	if form.toFloat {
+		sourceBits, resultBits = form.integerBits, form.floatBits
+	}
+	c.recordMachineRegister(form.source, sourceBits, false)
+	if form.toFloat || form.simdInteger {
+		flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects, arm64MachineEffect{
+			register: arm64MachineRegister(form.destination), width: resultBits,
+			write: true, vectorSpan: true, source: flow.source,
+		})
+	} else {
+		c.recordMachineRegister(form.destination, 64, true) // W writes zero the X upper half.
+	}
+	flow.suspended++
+	return func() { flow.suspended-- }
+}
+
+func arm64ScalarConversionModifier(bits int, gp bool) string {
+	if gp {
+		if bits == 32 {
+			return "w"
+		}
+		return "x"
+	}
+	switch bits {
+	case 16:
+		return "h"
+	case 32:
+		return "s"
+	default:
+		return "d"
+	}
+}
+
+func (c *arm64Ctx) lowerARM64ScalarConversion(form arm64ScalarConversionForm) error {
+	if _, _, valid := arm64ScalarFloatType(form.floatBits); !valid ||
+		form.integerBits != 32 && form.integerBits != 64 && !(form.simdInteger && form.integerBits == 16) {
+		return fmt.Errorf("arm64 invalid scalar conversion widths: %+v", form)
+	}
+	opcode := "scvtf"
+	if form.toFloat {
+		if form.unsigned {
+			opcode = "ucvtf"
+		}
+	} else {
+		modes := [...]string{"n", "a", "p", "m", "z"}
+		if int(form.rounding) >= len(modes) {
+			return fmt.Errorf("arm64 unsupported scalar float rounding mode %d", form.rounding)
+		}
+		opcode = "fcvt" + modes[form.rounding] + "s"
+		if form.unsigned {
+			opcode = "fcvt" + modes[form.rounding] + "u"
+		}
+	}
+	finish := c.recordARM64ScalarConversion(form)
+	defer finish()
+	sourceBits, resultBits := form.floatBits, form.integerBits
+	sourceGP, resultGP := false, !form.simdInteger
+	if form.toFloat {
+		sourceBits, resultBits = form.integerBits, form.floatBits
+		sourceGP, resultGP = !form.simdInteger, false
+	}
+	sourceType, sourceConstraint := "<16 x i8>", "w"
+	var source string
+	var err error
+	if sourceGP {
+		sourceType, sourceConstraint = fmt.Sprintf("i%d", sourceBits), "r"
+		source, err = c.loadRegisterWidth(form.source, sourceBits)
+		if err == nil && sourceBits == 32 {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, source)
+			source = "%" + narrow
+		}
+	} else {
+		source, err = c.loadVReg(form.source)
+	}
+	if err != nil {
+		return err
+	}
+	operation := fmt.Sprintf("%s ${0:%s}, ${1:%s}", opcode,
+		arm64ScalarConversionModifier(resultBits, resultGP), arm64ScalarConversionModifier(sourceBits, sourceGP))
+	result := c.newTmp()
+	if resultGP {
+		resultType := fmt.Sprintf("i%d", resultBits)
+		// Native status is observable even with a ZR/dead result. The compiler
+		// barrier orders this exact operation with existing native MRS/MSR.
+		c.emitMachineNeutralNativeIR("  %%%s = call %s asm sideeffect %q, %q(%s %s)\n",
+			result, resultType, operation, "=r,"+sourceConstraint+",~{memory}", sourceType, source)
+		value := "%" + result
+		if resultBits == 32 {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", wide, value)
+			value = "%" + wide
+		}
+		return c.storeReg(form.destination, value)
+	}
+	old, err := c.loadVReg(form.destination)
+	if err != nil {
+		return err
+	}
+	// Arm DDI0602's GP->F and scalar SIMD integer conversions merge V[d],
+	// not V[n], under IsMerging(FPCR). A tied complete 128-bit operand lets
+	// native hardware implement both zeroing and merging without fake FPCR.
+	c.emitMachineNeutralNativeIR("  %%%s = call <16 x i8> asm sideeffect %q, %q(%s %s, <16 x i8> %s)\n",
+		result, operation, "=w,"+sourceConstraint+",0,~{memory}", sourceType, source, old)
+	return c.storeVReg(form.destination, "%"+result)
+}
diff --git a/arm64_scalar_conversion_boundary_test.go b/arm64_scalar_conversion_boundary_test.go
new file mode 100644
index 000000000..acced0c7e
--- /dev/null
+++ b/arm64_scalar_conversion_boundary_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64ScalarConversionAPI(t *testing.T, api, source, triple string) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"conversion": {Name: "conversion", Ret: Void}},
+	}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api == "module" {
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err := TranslateModuleInContext(context, file, options)
+		if err != nil {
+			return "", err
+		}
+		defer module.Dispose()
+		return module.String(), nil
+	}
+	pkg := mustGoPackage(t, "example.com/conversion", "package conversion\nfunc conversion()\n")
+	result, err := TranslateGoModule(pkg, []byte(strings.ReplaceAll(source, "TEXT conversion", "TEXT ·conversion")), GoModuleOptions{
+		GOOS: "linux", GOARCH: "arm64", TargetTriple: triple,
+	})
+	if result != nil {
+		defer result.Module.Dispose()
+		return result.Module.String(), err
+	}
+	return "", err
+}
+
+func arm64ScalarConversionInstruction(fixture arm64ScalarConversionFixture) string {
+	if fixture.word != 0 {
+		word := fixture.word
+		if fixture.zero && !fixture.simd {
+			if fixture.toFloat {
+				word = word&^uint32(31<<5) | 31<<5
+			} else {
+				word |= 31
+			}
+		}
+		return fmt.Sprintf("WORD $%#08x", word)
+	}
+	gp := "R2"
+	if fixture.toFloat {
+		if fixture.zero {
+			gp = "ZR"
+		}
+		return fixture.name + " " + gp + ",F23"
+	}
+	if fixture.zero {
+		return fixture.name + " F6,ZR"
+	}
+	return fixture.name + " F6,R3"
+}
+
+func TestARM64ScalarConversionThreeAPIObjectsAndTargetBoundary(t *testing.T) {
+	var body strings.Builder
+	for _, fixture := range arm64ScalarConversionFixtures() {
+		body.WriteString(arm64ScalarConversionInstruction(fixture) + "\n")
+	}
+	source := "TEXT conversion(SB),4,$0-0\n" + body.String() + "RET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+			t.Run(api+"/"+triple, func(t *testing.T) {
+				ir, err := arm64ScalarConversionAPI(t, api, source, triple)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "scalar-conversion.ll", "scalar-conversion.o", ir)
+			})
+		}
+		for _, triple := range []string{"", "armv7-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "aarch64_be-unknown-linux-gnu", "arm64_32-apple-watchos", "arm64e-apple-darwin", "wasm32-unknown-unknown"} {
+			if _, err := arm64ScalarConversionAPI(t, api, source, triple); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s %q lost native target boundary: %v", api, triple, err)
+			}
+			for _, body := range []string{
+				"FCVTZSS F0,R0\nWORD $0xffffffff", "WORD $0xffffffff\nFCVTZSS F0,R0",
+				"RET\nFCVTZSS F0,R0\nWORD $0xffffffff", "RET\nWORD $0xffffffff\nFCVTZSS F0,R0",
+				"SCVTFD R0,F0\nSCVTFWS.P R0,F1", "RET\nSCVTFS RSP,F0",
+			} {
+				bad := "TEXT conversion(SB),4,$0-0\n" + body + "\nRET\n"
+				if _, err := arm64ScalarConversionAPI(t, api, bad, triple); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %q invalid/dead form hidden by native target: %v", api, body, err)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarConversionDoesNotDefineUnknownMergedLanes(t *testing.T) {
+	for _, instruction := range []string{"SCVTFD R0,F21", "SCVTFWS R0,F21", "WORD $0x5ee1b815"} {
+		for _, initialize := range []bool{false, true} {
+			body := "FMOVD R0,F0\n"
+			if initialize {
+				body += "VMOV R0,V21.D[1]\n"
+			}
+			body += instruction + "\nVMOV V21.D[1],R0\nRET\n"
+			arm64ImmediateOriginalGoBytes(t, "TEXT original(SB),4,$0-0\n"+body, "linux")
+			pkg := mustGoPackage(t, "example.com/merge", "package merge\nfunc Pass(uint64) uint64\n")
+			result, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\n"+body), GoModuleOptions{
+				GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+			})
+			if result != nil {
+				result.Module.Dispose()
+			}
+			if initialize && err != nil || !initialize && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s initialized=%v: %v", instruction, initialize, err)
+			}
+			if !initialize && !strings.Contains(err.Error(), "read") {
+				t.Fatalf("missing high-lane proof failed for unrelated reason: %v", err)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarConversionDecoderSpellingsAreNotGoSource(t *testing.T) {
+	for _, name := range []string{"SCVTFDD", "SCVTFSS", "UCVTFDD", "UCVTFSS"} {
+		source := "TEXT conversion(SB),4,$0-0\n" + name + " F0,F1\nRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := arm64ScalarConversionAPI(t, api, source, "aarch64-unknown-linux-gnu"); err == nil {
+				t.Errorf("%s accepted decoder-only %s as public Go source", api, name)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarConversionTargetPreflightPreservesRegisteredRawFamilies(t *testing.T) {
+	lines := []string{
+		"mul z0.b, z1.b, z2.b", "tbl z0.b, {z1.b}, z2.b",
+		"umullb z0.h, z1.b, z2.b", "umlalb z0.h, z1.b, z2.b",
+		"fmaxnmv h0, p0, z1.h",
+	}
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve2,+fullfp16") {
+		if _, registered := arm64RawSVEEffects(word); !registered {
+			t.Fatalf("fixture %s has no existing registered grammar", lines[index])
+		}
+		source := fmt.Sprintf("TEXT conversion(SB),4,$0-0\nSCVTFD R0,F0\nWORD $%#08x\nRET\n", word)
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := validateARM64ScalarConversionNativeTarget(file, Options{TargetTriple: "aarch64-unknown-linux-gnu"}); err != nil {
+			t.Errorf("native scalar preflight rejected existing %s: %v", lines[index], err)
+		}
+		if err := validateARM64ScalarConversionNativeTarget(file, Options{}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("existing %s obscured missing native target: %v", lines[index], err)
+		}
+	}
+}
diff --git a/arm64_scalar_conversion_exception_runtime_linux_test.go b/arm64_scalar_conversion_exception_runtime_linux_test.go
new file mode 100644
index 000000000..68ed0cebe
--- /dev/null
+++ b/arm64_scalar_conversion_exception_runtime_linux_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"math"
+	"math/bits"
+	"testing"
+)
+
+// Test-only independent FPToFixed/FixedToFP reference. Production never uses
+// software rounding, saturation or invented FPSR. Each expected full-bank row
+// is first checked by an original Go object under QEMU before LLVM comparison.
+func arm64ScalarConversionReference(fixture arm64ScalarConversionFixture, value, control uint64) (uint64, uint64) {
+	fraction, exponentBits, bias := 52, 11, 1023
+	if fixture.floatBits == 32 {
+		fraction, exponentBits, bias = 23, 8, 127
+	} else if fixture.floatBits == 16 {
+		fraction, exponentBits, bias = 10, 5, 15
+	}
+	floatSign := uint64(1) << uint(fixture.floatBits-1)
+	integerMask := ^uint64(0) >> uint(64-fixture.integerBits)
+	if fixture.toFloat {
+		value &= integerMask
+		negative := !fixture.unsigned && value>>(fixture.integerBits-1) != 0
+		magnitude := value
+		if negative {
+			magnitude = -value & integerMask
+		}
+		if magnitude == 0 {
+			return 0, 0
+		}
+		exponent := bits.Len64(magnitude) - 1
+		shift := exponent - fraction
+		significand, remainder := magnitude, uint64(0)
+		if shift > 0 {
+			significand = magnitude >> uint(shift)
+			remainder = magnitude & (uint64(1)<<uint(shift) - 1)
+		} else {
+			significand <<= uint(-shift)
+		}
+		rounding := control >> 22 & 3
+		up := false
+		if remainder != 0 {
+			switch rounding {
+			case 0:
+				half := uint64(1) << uint(shift-1)
+				up = remainder > half || remainder == half && significand&1 != 0
+			case 1:
+				up = !negative
+			case 2:
+				up = negative
+			}
+		}
+		if up {
+			significand++
+			if significand == uint64(1)<<uint(fraction+1) {
+				significand >>= 1
+				exponent++
+			}
+		}
+		flags := uint64(0)
+		if remainder != 0 {
+			flags = 0x10
+		}
+		result := uint64(exponent+bias)<<uint(fraction) | significand&(uint64(1)<<uint(fraction)-1)
+		if exponent > bias {
+			// Integer->half can overflow; S/D cannot for a 64-bit integer.
+			infinity := (uint64(1)<<uint(exponentBits) - 1) << uint(fraction)
+			result = infinity - 1
+			if rounding == 0 || rounding == 1 && !negative || rounding == 2 && negative {
+				result = infinity
+			}
+			flags = 0x14 // OFC | IXC, including directed finite saturation.
+		}
+		if negative {
+			result |= floatSign
+		}
+		return result, flags
+	}
+
+	exponent := value >> uint(fraction) & (uint64(1)<<uint(exponentBits) - 1)
+	mantissa := value & (uint64(1)<<uint(fraction) - 1)
+	negative := value&floatSign != 0
+	if exponent == uint64(1)<<uint(exponentBits)-1 && mantissa != 0 {
+		return 0, 1 // Both signaling and quiet NaNs are invalid integer inputs.
+	}
+	flush := control&(1<<24) != 0
+	if fixture.floatBits == 16 {
+		flush = control&(1<<19) != 0 // FZ16 is separate from FZ.
+	}
+	if exponent == 0 && mantissa != 0 && flush {
+		if fixture.floatBits == 16 {
+			return 0, 0 // Arm FPCR.FZ16 never generates Input Denormal.
+		}
+		return 0, 0x80
+	}
+	var number float64
+	if fixture.floatBits == 64 {
+		number = math.Float64frombits(value)
+	} else if fixture.floatBits == 32 {
+		number = float64(math.Float32frombits(uint32(value)))
+	} else {
+		if exponent == 31 {
+			number = math.Inf(1)
+		} else if exponent == 0 {
+			number = math.Ldexp(float64(mantissa), -24)
+		} else {
+			number = math.Ldexp(float64(1024+mantissa), int(exponent)-25)
+		}
+		if negative {
+			number = -number
+		}
+	}
+	rounded := math.Trunc(number)
+	switch fixture.rounding {
+	case 0:
+		rounded = math.RoundToEven(number)
+	case 1:
+		rounded = math.Round(number)
+	case 2:
+		rounded = math.Ceil(number)
+	case 3:
+		rounded = math.Floor(number)
+	}
+	limit := math.Ldexp(1, fixture.integerBits-1)
+	if fixture.unsigned {
+		limit *= 2
+		if rounded < 0 {
+			return 0, 1
+		}
+		if rounded >= limit {
+			return integerMask, 1
+		}
+	} else {
+		if rounded < -limit {
+			return uint64(1) << uint(fixture.integerBits-1), 1
+		}
+		if rounded >= limit {
+			return uint64(1)<<uint(fixture.integerBits-1) - 1, 1
+		}
+	}
+	flags := uint64(0)
+	if rounded != number {
+		flags = 0x10
+	}
+	if fixture.unsigned {
+		return uint64(rounded) & integerMask, flags
+	}
+	return uint64(int64(rounded)) & integerMask, flags
+}
+
+func arm64ScalarConversionExceptionalValues(fixture arm64ScalarConversionFixture) []uint64 {
+	if fixture.toFloat {
+		mask := ^uint64(0) >> uint(64-fixture.integerBits)
+		return []uint64{0, 1, mask, mask - 1, 1 << uint(fixture.integerBits-1),
+			1<<uint(fixture.integerBits-1) - 1, 2049, 4095, 65504, 65519, 65520, 65535,
+			1<<24 - 1, 1<<24 + 1, 1<<24 + 3, 1<<53 - 1, 1<<53 + 1, 1<<53 + 3}
+	}
+	var values []uint64
+	switch fixture.floatBits {
+	case 16:
+		values = []uint64{0, 1, 0x3ff, 0x400, 0x3e00, 0x4300, 0x7800, 0x7bff, 0x7c00, 0x7e01, 0x7c01}
+	case 32:
+		values = []uint64{0, 1, 0x7fffff, 0x800000, 0x3fc00000, 0x40600000, 0x4effffff,
+			0x4f000000, 0x4f7fffff, 0x4f800000, 0x5effffff, 0x5f000000, 0x5f7fffff, 0x5f800000,
+			0x7f800000, 0x7fc00001, 0x7f800001}
+	case 64:
+		values = []uint64{0, 1, 0xfffffffffffff, 0x10000000000000, 0x3ff8000000000000,
+			0x400c000000000000, 0x41dfffffffffffff, 0x41e0000000000000, 0x41efffffffffffff,
+			0x41f0000000000000, 0x43dfffffffffffff, 0x43e0000000000000, 0x43efffffffffffff,
+			0x43f0000000000000, 0x7ff0000000000000, 0x7ff8000000000001, 0x7ff0000000000001}
+	}
+	for _, value := range append([]uint64(nil), values...) {
+		values = append(values, value|uint64(1)<<uint(fixture.floatBits-1))
+	}
+	return values
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarConversionExceptionalInputs(t *testing.T) {
+	fixtures := arm64ScalarConversionFixtures()
+	for _, fixture := range append([]arm64ScalarConversionFixture(nil), fixtures...) {
+		fixture.dead = true
+		fixtures = append(fixtures, fixture)
+	}
+	var rows []arm64ScalarConversionObservation
+	for index, fixture := range fixtures {
+		for _, value := range arm64ScalarConversionExceptionalValues(fixture) {
+			for rounding := 0; rounding < 4; rounding++ {
+				for flush := 0; flush < 2; flush++ {
+					for defaultNaN := 0; defaultNaN < 2; defaultNaN++ {
+						control := uint64(rounding)<<22 | uint64(flush)<<24 | uint64(defaultNaN)<<25
+						if fixture.floatBits == 16 && flush != 0 {
+							control |= 1 << 19
+						}
+						row := arm64ScalarConversionKnownObservation(index, fixture, control)
+						row.input[fixture.sourceWord()] = value
+						copy(row.want[:66], row.input[:66])
+						result, flags := arm64ScalarConversionReference(fixture, value, control)
+						if !fixture.dead {
+							word := fixture.resultWord()
+							row.want[word] = result
+							if fixture.toFloat || fixture.simd {
+								row.want[word+1] = 0
+							}
+						}
+						row.want[67] = row.input[67] | flags
+						rows = append(rows, row)
+					}
+				}
+			}
+		}
+	}
+	runARM64ScalarConversionObservations(t, fixtures, rows)
+}
diff --git a/arm64_scalar_conversion_merge_runtime_linux_test.go b/arm64_scalar_conversion_merge_runtime_linux_test.go
new file mode 100644
index 000000000..bc62502d5
--- /dev/null
+++ b/arm64_scalar_conversion_merge_runtime_linux_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarConversionNativeMerge(t *testing.T) {
+	var fixtures []arm64ScalarConversionFixture
+	for _, fixture := range arm64ScalarConversionFixtures() {
+		if !fixture.toFloat && !fixture.simd {
+			continue // GP results do not use IsMerging(FPCR).
+		}
+		fixtures = append(fixtures, fixture)
+		if fixture.simd {
+			alias := fixture
+			alias.word = alias.word&^uint32(31) | alias.word>>5&31
+			fixtures = append(fixtures, alias)
+		}
+	}
+	for _, fixture := range append([]arm64ScalarConversionFixture(nil), fixtures...) {
+		fixture.dead = true
+		fixtures = append(fixtures, fixture)
+	}
+
+	var rows []arm64ScalarConversionObservation
+	for index, fixture := range fixtures {
+		for _, control := range []uint64{0, 4, 0x03400000, 0x03400004} {
+			row := arm64ScalarConversionKnownObservation(index, fixture, control)
+			source, destination := fixture.sourceWord(), fixture.resultWord()
+			if !fixture.toFloat || fixture.simd {
+				sourceBits := fixture.floatBits
+				if fixture.toFloat {
+					sourceBits = fixture.integerBits
+				}
+				mask := ^uint64(0) >> uint(64-sourceBits)
+				row.input[source] |= 0xfedcba9876543210 &^ mask
+				if fixture.dead || source != destination {
+					row.want[source] = row.input[source]
+				}
+			}
+			if control&4 != 0 && !fixture.dead {
+				resultBits := fixture.integerBits
+				if fixture.toFloat {
+					resultBits = fixture.floatBits
+				}
+				mask := ^uint64(0) >> uint(64-resultBits)
+				// DDI0602's covered GP->F and scalar SIMD conversions merge
+				// old V[d], including the remainder of its low 64-bit word.
+				row.want[destination] = row.input[destination]&^mask | row.want[destination]&mask
+				row.want[destination+1] = row.input[destination+1]
+			}
+			rows = append(rows, row)
+		}
+	}
+	if len(fixtures) != 88 || len(rows) != 352 {
+		t.Fatalf("native merge matrix changed: %d functions, %d rows", len(fixtures), len(rows))
+	}
+	// The independent full-state expectation requires actual NEP readback and
+	// high-lane preservation. An emulator ignoring NEP cannot pass this root.
+	// This observes these opcodes, not the entire advertised FEAT_AFP contract.
+	runARM64ScalarConversionObservations(t, fixtures, rows)
+}
diff --git a/arm64_scalar_conversion_status_runtime_linux_test.go b/arm64_scalar_conversion_status_runtime_linux_test.go
new file mode 100644
index 000000000..96c1b01a2
--- /dev/null
+++ b/arm64_scalar_conversion_status_runtime_linux_test.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type arm64ScalarConversionObservation struct {
+	function int
+	input    [68]uint64
+	want     [70]uint64
+}
+
+func arm64ScalarConversionKnownObservation(index int, fixture arm64ScalarConversionFixture, control uint64) arm64ScalarConversionObservation {
+	row := arm64ScalarConversionObservation{function: index}
+	for i := 0; i < 66; i++ {
+		row.input[i] = 0x9876543200000000 + uint64(i)*0x01010101
+	}
+	value, result, flags := uint64(0x3ff8000000000000), uint64(1), uint64(0x10)
+	if fixture.floatBits == 32 {
+		value = 0x3fc00000
+	} else if fixture.floatBits == 16 {
+		value = 0x3e00
+	}
+	if fixture.rounding < 3 {
+		result = 2 // N/A/P of positive 1.5; M/Z produce 1.
+	}
+	if fixture.toFloat {
+		value, result = 1<<24|1, 0x4b800000
+		if fixture.floatBits == 16 {
+			value, result = 2049, 0x6800
+		} else if fixture.floatBits == 64 {
+			if fixture.integerBits == 64 {
+				value, result = 1<<53|1, 0x4340000000000000
+			} else {
+				value, result, flags = 1<<24|1, 0x4170000010000000, 0
+			}
+		}
+		if control>>22&3 == 1 && flags != 0 {
+			result++ // Round toward positive infinity; other modes round down here.
+		}
+	}
+	row.input[fixture.sourceWord()] = value
+	if fixture.zero && fixture.toFloat {
+		result, flags = 0, 0
+	}
+	copy(row.want[:66], row.input[:66])
+	if !fixture.dead {
+		if fixture.toFloat || fixture.simd {
+			word := fixture.resultWord()
+			row.want[word], row.want[word+1] = result, 0
+		} else if !fixture.zero {
+			row.want[65] = result
+		}
+	}
+	row.input[66], row.input[67] = control, 0x08000002
+	row.want[66], row.want[67] = control, row.input[67]|flags
+	row.want[68], row.want[69] = 0x123456789abcdef0, 0xfedcba9876543210
+	return row
+}
+
+func arm64ScalarConversionPrograms(fixtures []arm64ScalarConversionFixture, rows []arm64ScalarConversionObservation) (string, string) {
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range fixtures {
+		fmt.Fprintf(&original, "func scalarStatus%d(*[68]uint64,*[70]uint64)\n", index)
+		fmt.Fprintf(&driver, "extern void scalarStatus%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("var functions = [...]func(*[68]uint64,*[70]uint64){\n")
+	driver.WriteString("static void (*functions[])(uint64_t*,uint64_t*)={\n")
+	for index := range fixtures {
+		fmt.Fprintf(&original, "scalarStatus%d,\n", index)
+		fmt.Fprintf(&driver, "scalarStatus%d,\n", index)
+	}
+	original.WriteString("}\ntype change struct { index int; value uint64 }\nvar rows = []struct { function int; input,want [4]change }{\n")
+	driver.WriteString("};\nstruct change { int index; uint64_t value; };\nstatic const struct { unsigned function; struct change input[4],want[4]; } rows[]={\n")
+	for _, row := range rows {
+		// Lossless sparse encoding keeps generated compiler inputs bounded;
+		// every runtime still compares all 70 words, never just the changes.
+		var baseline [68]uint64
+		for index := 0; index < 66; index++ {
+			baseline[index] = 0x9876543200000000 + uint64(index)*0x01010101
+		}
+		var expected [70]uint64
+		copy(expected[:68], row.input[:])
+		expected[68], expected[69] = 0x123456789abcdef0, 0xfedcba9876543210
+		fmt.Fprintf(&original, "{%d,", row.function)
+		fmt.Fprintf(&driver, "{%d,", row.function)
+		for _, pair := range []struct{ base, actual []uint64 }{{baseline[:], row.input[:]}, {expected[:], row.want[:]}} {
+			original.WriteString("[4]change{")
+			driver.WriteString("{")
+			count := 0
+			for index, value := range pair.actual {
+				if value != pair.base[index] {
+					fmt.Fprintf(&original, "{%d,%#x},", index, value)
+					fmt.Fprintf(&driver, "{%d,%#xULL},", index, value)
+					count++
+				}
+			}
+			if count > 4 {
+				panic("scalar conversion fixture exceeds its lossless sparse row encoding")
+			}
+			for ; count < 4; count++ {
+				original.WriteString("{-1,0},")
+				driver.WriteString("{-1,0},")
+			}
+			original.WriteString("},")
+			driver.WriteString("},")
+		}
+		original.WriteString("},\n")
+		driver.WriteString("},\n")
+	}
+	original.WriteString(`}
+func main() {
+    for index, row := range rows {
+        var input [68]uint64
+        for word:=0;word<66;word++ { input[word]=0x9876543200000000+uint64(word)*0x01010101 }
+        for _,change:=range row.input { if change.index>=0 { input[change.index]=change.value } }
+        var out,want [70]uint64
+        copy(want[:68],input[:])
+        out[68],out[69] = 0x123456789abcdef0,0xfedcba9876543210
+        want[68],want[69] = out[68],out[69]
+        for _,change:=range row.want { if change.index>=0 { want[change.index]=change.value } }
+        functions[row.function](&input,&out)
+        if out != want { panic(fmt.Sprintf("original row %d function %d got %x want %x",index,row.function,out,want)) }
+    }
+    fmt.Printf("ORIGINAL_ARM64_SCALAR_STATUS %d\n",len(rows))
+}
+`)
+	driver.WriteString(`};
+int main(void) {
+    unsigned failures=0;
+    for(unsigned row=0;row<sizeof(rows)/sizeof(rows[0]);row++) {
+        uint64_t input[68]={0},out[70]={0},want[70]={0};
+        for(unsigned word=0;word<66;word++) input[word]=0x9876543200000000ULL+(uint64_t)word*0x01010101;
+        for(unsigned i=0;i<4;i++) {
+            struct change change=rows[row].input[i];
+            if(change.index>=0) input[change.index]=change.value;
+        }
+        for(unsigned word=0;word<68;word++) want[word]=input[word];
+        out[68]=want[68]=0x123456789abcdef0ULL;
+        out[69]=want[69]=0xfedcba9876543210ULL;
+        for(unsigned i=0;i<4;i++) {
+            struct change change=rows[row].want[i];
+            if(change.index>=0) want[change.index]=change.value;
+        }
+        functions[rows[row].function](input,out);
+        for(unsigned word=0;word<70;word++) {
+            if(out[word]!=want[word]) {
+                if(failures<16) fprintf(stderr,"row %u function %u word %u got %016llx want %016llx\n",
+                    row,rows[row].function,word,(unsigned long long)out[word],(unsigned long long)want[word]);
+                failures++;
+            }
+        }
+    }
+    printf("ARM64_SCALAR_STATUS failures=%u\n",failures);
+    return failures!=0;
+}
+`)
+	return original.String(), driver.String()
+}
+
+func runARM64ScalarConversionObservations(t *testing.T, fixtures []arm64ScalarConversionFixture, rows []arm64ScalarConversionObservation) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("native FPCR/FPSR execution belongs to the required Linux/QEMU matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("ARM64 conversion runtime requires the Linux/amd64 cross executor")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"qemu-aarch64", "aarch64-linux-gnu-gcc"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("QEMU_CPU", "max")
+	source, sigs := arm64ScalarConversionSource(fixtures)
+	original, driver := arm64ScalarConversionPrograms(fixtures, rows)
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module scalarstatusoracle\n\ngo 1.20\n", "main.go": original,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT scalarStatus", "TEXT ·scalarStatus"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "run", "-p=1", "-exec=qemu-aarch64", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || !strings.Contains(string(output), fmt.Sprintf("ORIGINAL_ARM64_SCALAR_STATUS %d", len(rows))) {
+		t.Fatalf("actual Go object / independent values and flags: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-no-pie"},
+					"arm64_scalar_status", triple, variant.ir, driver,
+					[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"}, level)
+				t.Logf("matched original Go: %d whole-vector/GP/FPCR/FPSR/canary observations", len(rows))
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarConversionNativeStatus(t *testing.T) {
+	fixtures := arm64ScalarConversionFixtures()
+	for _, fixture := range append([]arm64ScalarConversionFixture(nil), fixtures...) {
+		fixture.dead = true
+		fixtures = append(fixtures, fixture)
+	}
+	var rows []arm64ScalarConversionObservation
+	for index, fixture := range fixtures {
+		for rounding := 0; rounding < 4; rounding++ {
+			for flush := 0; flush < 2; flush++ {
+				for defaultNaN := 0; defaultNaN < 2; defaultNaN++ {
+					control := uint64(rounding)<<22 | uint64(flush)<<24 | uint64(defaultNaN)<<25
+					rows = append(rows, arm64ScalarConversionKnownObservation(index, fixture, control))
+				}
+			}
+		}
+	}
+	runARM64ScalarConversionObservations(t, fixtures, rows)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarConversionBanksAliasesAndZR(t *testing.T) {
+	requireARM64ScalarConversionBankPartition(t)
+	totalRows := 0
+	for batch, fixtures := range arm64ScalarConversionBankPartitions() {
+		t.Run(fmt.Sprintf("batch_%d", batch), func(t *testing.T) {
+			var rows []arm64ScalarConversionObservation
+			for index, fixture := range fixtures {
+				for _, control := range []uint64{0, 0x03400000} {
+					rows = append(rows, arm64ScalarConversionKnownObservation(index, fixture, control))
+				}
+			}
+			totalRows += len(rows)
+			// Each child closes its temporary Go/LLVM/native files before the
+			// next batch. The IR optimizer already disposes module then context.
+			runARM64ScalarConversionObservations(t, fixtures, rows)
+		})
+	}
+	if totalRows != 1712 {
+		t.Fatalf("bank runtime omitted rows: %d, want 1712", totalRows)
+	}
+}
diff --git a/arm64_scalar_conversion_status_test.go b/arm64_scalar_conversion_status_test.go
new file mode 100644
index 000000000..c13cd93e1
--- /dev/null
+++ b/arm64_scalar_conversion_status_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This table is independent of the production decoder. Go asm7's case 29
+// exposes eight F->GP and eight GP->F names. Arm DDI0602 additionally defines
+// the registered H/S/D WORDs, five explicit F->GP rounding modes and scalar
+// SIMD integer carriers. Arranged vector, SVE and fixed-point forms are absent.
+type arm64ScalarConversionFixture struct {
+	name                          string
+	word                          uint32
+	floatBits, integerBits        int
+	toFloat, unsigned, simd, dead bool
+	zero                          bool
+	rounding                      int // N, A, P, M, Z in architecture order below.
+}
+
+func (fixture arm64ScalarConversionFixture) sourceWord() int {
+	if fixture.toFloat && !fixture.simd {
+		return 64
+	}
+	if fixture.word != 0 {
+		return int(fixture.word>>5&31) * 2
+	}
+	return 12
+}
+
+func (fixture arm64ScalarConversionFixture) resultWord() int {
+	if !fixture.toFloat && !fixture.simd {
+		return 65
+	}
+	if fixture.word != 0 {
+		return int(fixture.word&31) * 2
+	}
+	return 46
+}
+
+func arm64ScalarConversionFixtures() []arm64ScalarConversionFixture {
+	var fixtures []arm64ScalarConversionFixture
+	for _, unsigned := range []bool{false, true} {
+		for _, width := range []struct {
+			bits int
+			code uint32
+		}{{16, 3}, {32, 0}, {64, 1}} {
+			for _, integerBits := range []int{32, 64} {
+				fields := width.code<<22 | 6<<5 | 3
+				if unsigned {
+					fields |= 1 << 16
+				}
+				if integerBits == 64 {
+					fields |= 1 << 31
+				}
+				for rounding, base := range []uint32{0x1e200000, 0x1e240000, 0x1e280000, 0x1e300000, 0x1e380000} {
+					fixtures = append(fixtures, arm64ScalarConversionFixture{
+						word: base | fields, floatBits: width.bits, integerBits: integerBits,
+						unsigned: unsigned, rounding: rounding,
+					})
+				}
+				fixtures = append(fixtures, arm64ScalarConversionFixture{
+					word:      0x1e220000 | fields&^uint32(31<<5|31) | 2<<5 | 23,
+					floatBits: width.bits, integerBits: integerBits, unsigned: unsigned, toFloat: true,
+				})
+			}
+			base := map[int]uint32{16: 0x5ef9b800, 32: 0x5ea1b800, 64: 0x5ee1b800}[width.bits]
+			if unsigned {
+				base |= 1 << 29
+			}
+			fixtures = append(fixtures, arm64ScalarConversionFixture{
+				word: base | 6<<5 | 23, floatBits: width.bits, integerBits: width.bits,
+				unsigned: unsigned, simd: true, rounding: 4,
+			})
+			base = map[int]uint32{16: 0x5e79d800, 32: 0x5e21d800, 64: 0x5e61d800}[width.bits]
+			if unsigned {
+				base |= 1 << 29
+			}
+			fixtures = append(fixtures, arm64ScalarConversionFixture{
+				word: base | 6<<5 | 23, floatBits: width.bits, integerBits: width.bits,
+				unsigned: unsigned, simd: true, toFloat: true,
+			})
+		}
+	}
+	// Named forms are separate witnesses, not decoder-generated spellings.
+	for _, unsigned := range []bool{false, true} {
+		for _, floatBits := range []int{32, 64} {
+			for _, integerBits := range []int{32, 64} {
+				kind, width, integer := "S", "S", ""
+				if unsigned {
+					kind = "U"
+				}
+				if floatBits == 64 {
+					width = "D"
+				}
+				if integerBits == 32 {
+					integer = "W"
+				}
+				fixtures = append(fixtures,
+					arm64ScalarConversionFixture{name: "FCVTZ" + kind + width + integer, floatBits: floatBits, integerBits: integerBits, unsigned: unsigned, rounding: 4},
+					arm64ScalarConversionFixture{name: kind + "CVTF" + integer + width, floatBits: floatBits, integerBits: integerBits, unsigned: unsigned, toFloat: true},
+				)
+			}
+		}
+	}
+	return fixtures
+}
+
+func arm64ScalarConversionSource(fixtures []arm64ScalarConversionFixture) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, fixture := range fixtures {
+		name := fmt.Sprintf("scalarStatus%d", index)
+		sigs[name] = arm64SM3Signature(name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for register := 0; register < 32; register++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", register)
+		}
+		source.WriteString("MOVD (R0),R2\nMOVD 8(R0),R3\nMRS FPCR,R10\nMRS FPSR,R11\n")
+		source.WriteString("MOVD 16(R0),R12\nMSR R12,FPCR\nMOVD 24(R0),R12\nMSR R12,FPSR\n")
+		source.WriteString(arm64ScalarConversionInstruction(fixture) + "\n")
+		if fixture.dead {
+			source.WriteString("SUB $512,R0,R4\n")
+			for register := 0; register < 32; register++ {
+				fmt.Fprintf(&source, "VLD1.P 16(R4),[V%d.B16]\n", register)
+			}
+			source.WriteString("MOVD 8(R0),R3\n")
+		}
+		for register := 0; register < 32; register++ {
+			fmt.Fprintf(&source, "VST1.P [V%d.B16],16(R1)\n", register)
+		}
+		source.WriteString("MOVD R2,(R1)\nMOVD R3,8(R1)\nMRS FPCR,R12\nMOVD R12,16(R1)\n")
+		source.WriteString("MRS FPSR,R12\nMOVD R12,24(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), sigs
+}
+
+func TestARM64ScalarConversionStatusRetainsNativeEffects(t *testing.T) {
+	fixtures := arm64ScalarConversionFixtures()
+	if len(fixtures) != 100 {
+		t.Fatalf("independent family changed: %d", len(fixtures))
+	}
+	for i := range fixtures {
+		fixtures[i].dead = true
+	}
+	source, sigs := arm64ScalarConversionSource(fixtures)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []string{ir, armFloatEffectOptimizedIR(t, ir)} {
+		count := 0
+		for _, line := range strings.Split(variant, "\n") {
+			if strings.Contains(line, "asm sideeffect") && strings.Contains(line, "cvt") {
+				count++
+			}
+		}
+		if count != len(fixtures) {
+			t.Errorf("retained %d/%d native conversion effects with dead outputs", count, len(fixtures))
+		}
+	}
+}
+
+func arm64ScalarConversionBankFixtures() []arm64ScalarConversionFixture {
+	var fixtures []arm64ScalarConversionFixture
+	for _, fixture := range arm64ScalarConversionFixtures() {
+		if fixture.simd {
+			for source := 0; source < 32; source++ {
+				for _, destination := range []int{source, 31 - source} {
+					alias := fixture
+					alias.word = alias.word&^uint32(31<<5|31) | uint32(source)<<5 | uint32(destination)
+					fixtures = append(fixtures, alias)
+				}
+			}
+		} else {
+			fixture.zero = true
+			fixtures = append(fixtures, fixture)
+		}
+	}
+	return fixtures
+}
+
+func arm64ScalarConversionBankPartitions() [][]arm64ScalarConversionFixture {
+	fixtures := arm64ScalarConversionBankFixtures()
+	var partitions [][]arm64ScalarConversionFixture
+	for start := 0; start < len(fixtures); start += 128 {
+		end := start + 128
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		partitions = append(partitions, fixtures[start:end])
+	}
+	return partitions
+}
+
+func requireARM64ScalarConversionBankPartition(t *testing.T) {
+	t.Helper()
+	complete := arm64ScalarConversionBankFixtures()
+	partitions := arm64ScalarConversionBankPartitions()
+	if len(complete) != 856 || len(partitions) != 7 {
+		t.Fatalf("bank matrix changed: %d functions, %d partitions", len(complete), len(partitions))
+	}
+	seen := make(map[string]bool)
+	position := 0
+	for _, partition := range partitions {
+		if len(partition) == 0 || len(partition) > 128 {
+			t.Fatalf("unbounded/empty native bank partition: %d", len(partition))
+		}
+		for _, fixture := range partition {
+			instruction := arm64ScalarConversionInstruction(fixture)
+			if seen[instruction] || position >= len(complete) || fixture != complete[position] {
+				t.Fatalf("duplicated, reordered or foreign function at %d: %s", position, instruction)
+			}
+			seen[instruction] = true
+			position++
+		}
+	}
+	if position != len(complete) || len(seen)*2 != 1712 {
+		t.Fatalf("native bank partition omitted functions/rows: %d functions, %d unique rows", position, len(seen)*2)
+	}
+}
+
+func TestARM64ScalarConversionBankPartitionIsExact(t *testing.T) {
+	requireARM64ScalarConversionBankPartition(t)
+}
diff --git a/arm64_scalar_conversion_target.go b/arm64_scalar_conversion_target.go
new file mode 100644
index 000000000..037798252
--- /dev/null
+++ b/arm64_scalar_conversion_target.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func arm64ScalarConversionNativeTarget(triple string) bool {
+	parts := strings.Split(triple, "-")
+	return len(parts) >= 3 && (parts[0] == "aarch64" || parts[0] == "arm64")
+}
+
+func arm64RawScalarConversion(word uint32) bool {
+	if _, ok := decodeARM64RawScalarFCVTToInt(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawScalarIntToFloat(word); ok {
+		return true
+	}
+	if _, ok := decodeARM64RawScalarVectorFCVTZ(word); ok {
+		return true
+	}
+	return false
+}
+
+func validateARM64ScalarConversionNativeTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	var rawError error
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if instruction.Op == OpWORD {
+				if err := arm64RawWordPreflightError(instruction); err != nil && rawError == nil {
+					rawError = err
+				}
+				if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+					instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+					continue
+				}
+				word := uint32(instruction.Args[0].Imm)
+				if arm64RawScalarConversion(word) {
+					needsNative = true
+				}
+				continue
+			}
+			_, matched, err := parseARM64ScalarConversion(arm64ControlOp(instruction), instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+		}
+	}
+	if !needsNative {
+		return nil
+	}
+	if rawError != nil {
+		return rawError // Illegal/dead WORDs are not target-context successes.
+	}
+	if !arm64ScalarConversionNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm64" {
+		return fmt.Errorf("%w: ARM64 scalar conversion requires an explicit native little-endian AArch64 FPCR/FPSR target, got %q/%q",
+			ErrProbeNeedsContext, options.Goarch, options.TargetTriple)
+	}
+	return nil
+}
diff --git a/arm64_scalar_memory_backing_test.go b/arm64_scalar_memory_backing_test.go
new file mode 100644
index 000000000..cd98c61ff
--- /dev/null
+++ b/arm64_scalar_memory_backing_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64ScalarMemoryBackingFixture() (source, declaration, goProgram, cProgram string) {
+	var assembly, decl, goChecks, cDecl, cChecks strings.Builder
+	for i, op := range arm64MemoryScratchAuditMoves {
+		width := 1 << (i / 2)
+		offset := width
+		if width == 8 {
+			offset = 0
+		}
+		for region := 0; region < 3; region++ {
+			name := fmt.Sprintf("Backing%d", i*3+region)
+			fmt.Fprintf(&decl, "func %s(input uint64, output *[2]uint64) uint64\n", name)
+			frame := 0
+			if region == 2 {
+				frame = 32
+			}
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$%d-24\n", name, frame)
+			assembly.WriteString("MOVD input+0(FP),R0\nMOVD output+8(FP),R11\nMOVD $0x10203040aa80feff,R1\nMOVD $107,R27\nMOVD $255,R6\nMOVD $1,R7\nCMP R7,R6\n")
+			whole, partial := "input+0(FP)", fmt.Sprintf("input+%d(FP)", offset)
+			if region == 1 {
+				whole, partial = "ret+16(FP)", fmt.Sprintf("ret+%d(FP)", 16+offset)
+			} else if region == 2 {
+				// Go AUTO offsets are relative to the logical top of the
+				// declared frame. This is initialized local data, not SP0.
+				whole, partial = "local-24(SP)", fmt.Sprintf("local%+d(SP)", -24+offset)
+			}
+			fmt.Fprintf(&assembly, "MOVD R0,%s\n%s R1,%s\nMOVD %s,R0\nMOVD R0,ret+16(FP)\n", whole, op, partial, whole)
+			assembly.WriteString("MOVD R27,(R11)\nCSET HS,R2\nMOVD R2,8(R11)\nRET\n")
+			mask := ^uint64(0)
+			if width != 8 {
+				mask = (uint64(1) << uint(width*8)) - 1
+			}
+			want := uint64(0xfedcba9876543210)&^(mask<<uint(offset*8)) |
+				(uint64(0x10203040aa80feff)&mask)<<uint(offset*8)
+			fmt.Fprintf(&goChecks, `
+    {
+        output := struct { left uint64; values [2]uint64; right uint64 }{left:0x1234,right:0x5678}
+        got := %s(0xfedcba9876543210,&output.values)
+        if got != %#x || output.values != ([2]uint64{107,1}) { panic("%s typed backing") }
+        if output.left != 0x1234 || output.right != 0x5678 { panic("%s output canary") }
+    }
+`, name, want, name, name)
+			fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t,uint64_t *);\n", name)
+			fmt.Fprintf(&cChecks, `
+    {
+        struct { uint64_t left,values[2],right; } output={.left=0x1234,.right=0x5678};
+        uint64_t got=%s(UINT64_C(0xfedcba9876543210),output.values);
+        if (got!=UINT64_C(%#x) || output.values[0]!=107 || output.values[1]!=1) {
+            fprintf(stderr,"%s typed backing: %%#llx\n",(unsigned long long)got);
+            return 1;
+        }
+        if (output.left!=0x1234 || output.right!=0x5678) return 2;
+    }
+`, name, want, name)
+		}
+	}
+	source, declaration = assembly.String(), decl.String()
+	goProgram = "package main\n" + declaration + "func main() {\n" + goChecks.String() + "}\n"
+	cProgram = "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void) {\n" + cChecks.String() + "return 0;\n}\n"
+	return
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMemoryTypedBacking(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, declaration, goProgram, cProgram := arm64ScalarMemoryBackingFixture()
+	runARM64LocalRegisterGoOracle(t, source, goProgram, len(runner) != 0, "1.20")
+	for api, ir := range arm64ScalarMemoryIRs(t, source, declaration, target) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("scalar-memory-backing-%d", api), target, ir, cProgram, runner)
+	}
+	t.Log("21 initialized typed parameter/result/AUTO partial writes preserve untouched bits; output canaries and R27/NZCV")
+}
+
+func TestARM64ScalarMemoryTypedBackingLLVM22Objects(t *testing.T) {
+	source, declaration, _, _ := arm64ScalarMemoryBackingFixture()
+	requireARM64GoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc unavailable")
+	}
+	for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		for api, ir := range arm64ScalarMemoryIRs(t, source, declaration, target) {
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("scalar-memory-backing-%d.ll", api), fmt.Sprintf("scalar-memory-backing-%d.o", api), ir)
+		}
+	}
+}
diff --git a/arm64_scalar_memory_encoding_audit_test.go b/arm64_scalar_memory_encoding_audit_test.go
new file mode 100644
index 000000000..c564f90be
--- /dev/null
+++ b/arm64_scalar_memory_encoding_audit_test.go
@@ -0,0 +1,344 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+func arm64MemoryAuditGoCommand(t *testing.T, goos string, args ...string) ([]byte, error) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if ctx.Err() != nil {
+		t.Fatalf("actual Go command deadline: %v", ctx.Err())
+	}
+	var unavailable *exec.Error
+	if errors.As(err, &unavailable) {
+		t.Fatalf("actual Go tool unavailable: %v", err)
+	}
+	if err != nil && len(args) >= 2 && args[0] == "tool" && args[1] == "asm" && !bytes.Contains(output, []byte("asm:")) {
+		t.Fatalf("Go command failed without an assembler source diagnostic: %v\n%s", err, output)
+	}
+	return output, err
+}
+
+func TestARM64ScalarMemoryAuditCompleteGoOptabs(t *testing.T) {
+	root, err := arm64MemoryAuditGoCommand(t, "linux", "env", "GOROOT")
+	if err != nil {
+		t.Fatalf("actual Go GOROOT: %v\n%s", err, root)
+	}
+	path := filepath.Join(strings.TrimSpace(string(root)), "src", "cmd", "internal", "obj", "arm64", "asm7.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count, err := arm64ScalarMemoryLegacyGoRows(string(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual Go asm7 SHA256 %x; four base mnemonics × %d memory rows, unsigned aliases expand to seven × %d", sha256.Sum256(source), count, count)
+}
+
+// This exposes the original count-only audit unchanged in scope, so its
+// attribute blind spots can be tested against the same source bytes.
+func arm64ScalarMemoryLegacyGoRows(source string) (int, error) {
+	expected := map[int]int{20: 4, 21: 4, 30: 4, 31: 4, 22: 2, 23: 2, 98: 1, 99: 1, 64: 1, 65: 1}
+	// This is an audit of the actual Go table, not a production encoder guess.
+	// Go 1.20 has no separate LAUTOPOOL/LOREGPOOL rows. Its case body
+	// chooses the literal pool after selecting the two ordinary long rows.
+	if !strings.Contains(source, "C_LAUTOPOOL") {
+		expected[30], expected[31] = 2, 2
+	}
+	rows := make(map[string]map[int]int)
+	for _, line := range strings.Split(source, "\n") {
+		line = strings.TrimSpace(line)
+		if end := strings.IndexByte(line, '}'); end >= 0 {
+			line = line[:end+1]
+		}
+		if !strings.HasPrefix(line, "{AMOV") {
+			continue
+		}
+		fields := strings.Split(strings.TrimSuffix(strings.TrimSuffix(line, ","), "}"), ",")
+		name := strings.TrimPrefix(fields[0], "{")
+		if name != "AMOVB" && name != "AMOVH" && name != "AMOVW" && name != "AMOVD" {
+			continue
+		}
+		if len(fields) != 10 && len(fields) != 11 {
+			return 0, fmt.Errorf("unknown actual Go optab shape: %s", line)
+		}
+		kind, err := strconv.Atoi(strings.TrimSpace(fields[len(fields)-5]))
+		if err != nil {
+			return 0, err
+		}
+		if _, memory := expected[kind]; !memory {
+			continue
+		}
+		if rows[name] == nil {
+			rows[name] = make(map[int]int)
+		}
+		rows[name][kind]++
+	}
+	var failures []error
+	for _, name := range []string{"AMOVB", "AMOVH", "AMOVW", "AMOVD"} {
+		for kind, count := range expected {
+			if got := rows[name][kind]; got != count {
+				failures = append(failures, fmt.Errorf("actual %s case %d has %d rows, want %d", name, kind, got, count))
+			}
+		}
+	}
+	for _, alias := range []string{"AMOVBU", "AMOVHU", "AMOVWU"} {
+		if !strings.Contains(source, "oprangeset("+alias+", t)") {
+			failures = append(failures, fmt.Errorf("missing actual Go unsigned MOV alias: %s", alias))
+		}
+	}
+	count := 0
+	for _, rows := range expected {
+		count += rows
+	}
+	return count, errors.Join(failures...)
+}
+
+type arm64MemoryAuditForm struct {
+	instruction string
+	width       int // Known operation width only. Zero means pool/source-variant audit.
+}
+
+func arm64MemoryAuditForms() []arm64MemoryAuditForm {
+	var forms []arm64MemoryAuditForm
+	for index, op := range arm64MemoryScratchAuditMoves {
+		width := 1 << (index / 2)
+		if op == "MOVD" {
+			width = 8
+		}
+		for _, memory := range []string{
+			"-256(R0)", "-1(R0)", "0(R0)", "255(R0)",
+			fmt.Sprintf("%d(R0)", 4095*width),
+			"-8192(R0)", "-257(R0)", "65536(R0)",
+			"65536(RSP)", "65536(ZR)", "slot+65536(FP)", "local+65536(SP)",
+		} {
+			operationWidth := 4
+			if strings.Contains(memory, "65536") || memory == "-257(R0)" {
+				operationWidth = 8
+			}
+			if memory == "-8192(R0)" {
+				operationWidth = 0
+			}
+			forms = append(forms,
+				arm64MemoryAuditForm{op + " " + memory + ",R1", operationWidth},
+				arm64MemoryAuditForm{op + " R1," + memory, operationWidth})
+		}
+		for _, memory := range []string{"32768(R0)", "65537(R0)", "-4095(R0)", "-4096(R0)"} {
+			forms = append(forms,
+				arm64MemoryAuditForm{op + " " + memory + ",R1", 0},
+				arm64MemoryAuditForm{op + " R1," + memory, 0})
+		}
+		for _, suffix := range []string{".P", ".W"} {
+			for _, offset := range []int{-256, 0, 255} {
+				memory := fmt.Sprintf("%d(R0)", offset)
+				forms = append(forms,
+					arm64MemoryAuditForm{op + suffix + " " + memory + ",R1", 4},
+					arm64MemoryAuditForm{op + suffix + " R1," + memory, 4})
+			}
+		}
+		indices := []string{"R2"}
+		for _, extension := range []string{".UXTW", ".SXTW", ".SXTX", ""} {
+			indices = append(indices, "R2"+extension+"<<0")
+			if width != 1 {
+				indices = append(indices, fmt.Sprintf("R2%s<<%d", extension, index/2))
+			}
+		}
+		for _, indexed := range indices {
+			memory := "(R0)(" + indexed + ")"
+			forms = append(forms,
+				arm64MemoryAuditForm{op + " " + memory + ",R1", 4},
+				arm64MemoryAuditForm{op + " R1," + memory, 4})
+		}
+		for _, instruction := range []string{
+			op + " (R0)(R27),R1", op + " R27,(R0)(R2)",
+			op + " (R27),R1", op + " R27,(R0)",
+			op + " (R0),ZR", op + " ZR,(R0)",
+			op + " $0,(R0)", op + ".P $0,255(R0)",
+		} {
+			forms = append(forms, arm64MemoryAuditForm{instruction, 4})
+		}
+		forms = append(forms, arm64MemoryAuditForm{op + " $0,65536(R0)", 8})
+		for _, memory := range []string{"payload+0(SB)", "payload+1(SB)"} {
+			operationWidth := 8
+			if width != 1 && memory == "payload+1(SB)" {
+				operationWidth = 12
+			}
+			forms = append(forms,
+				arm64MemoryAuditForm{op + " " + memory + ",R1", operationWidth},
+				arm64MemoryAuditForm{op + " R1," + memory, operationWidth})
+		}
+		// Non-pool aliasing is accepted: data/base R27 are reread after ADD.
+		for _, instruction := range []string{
+			op + " 65536(R27),R1", op + " 65536(R0),R27",
+			op + " R27,65536(R0)", op + " R1,65536(R27)",
+		} {
+			forms = append(forms, arm64MemoryAuditForm{instruction, 8})
+		}
+	}
+	return forms
+}
+
+func arm64MemoryAuditRejectedForms() []string {
+	var rejected []string
+	for _, op := range arm64MemoryScratchAuditMoves {
+		rejected = append(rejected, []string{
+			op + " -8192(R27),R1",
+			op + " R27,-8192(R0)", op + " R1,-8192(R27)",
+			op + ".P 256(R0),R1", op + ".W R1,-257(R0)",
+			op + ".P (R0),R0", op + ".W R0,(R0)",
+			op + ".P slot+0(FP),R1", op + ".W R1,local+0(SP)",
+			op + " (R0),RSP", op + " RSP,(R0)",
+			op + " (R0),(R1)", op + " $1,(R0)",
+			op + " (R0)(R2.UXTX),R1", op + " R1,(R0)(R2.SXTB)",
+			op + " 1(R0)(R2),R1", op + " $0.0,(R0)",
+			op + " (R31),R1", op + " (R0),W1",
+			op + " R27,payload(SB)", op + " (F0),R1",
+			op + " (R0),F1", op + ".P.W (R0),R1",
+		}...)
+	}
+	return rejected
+}
+
+func TestARM64ScalarMemoryAuditRejectedGoFormats(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "rejected.s")
+	rejected := arm64MemoryAuditRejectedForms()
+	for _, instruction := range rejected {
+		source := "TEXT rejected(SB),4,$0-0\n" + instruction + "\nRET\n"
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		output, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-o", filepath.Join(dir, "rejected.o"), path)
+		if err == nil {
+			t.Errorf("actual Go accepted expected rejected format: %s", instruction)
+		}
+		t.Logf("Go rejected %s: %s", instruction, strings.TrimSpace(string(output)))
+	}
+	t.Logf("actual Go %d rejected scalar GP memory formats", len(rejected))
+}
+
+func TestARM64ScalarMemoryAuditPoolDestinationR27VersionBoundary(t *testing.T) {
+	// The current source diagnoses this alias; the old source does not.
+	// Record the actual acceptance boundary without making the old accepted
+	// source look like a current Go rejection or numerical execution proof.
+	dir := t.TempDir()
+	path := filepath.Join(dir, "pool-destination.s")
+	for _, op := range arm64MemoryScratchAuditMoves {
+		source := "TEXT poolDestination(SB),4,$0-0\n" + op + " -8192(R0),R27\nRET\n"
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		output, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", filepath.Join(dir, "pool-destination.o"), path)
+		t.Logf("actual Go %s pool destination R27 accepted=%v diagnostics/listing:\n%s", op, err == nil, output)
+	}
+}
+
+func TestARM64ScalarMemoryAuditWideOffsetGoEncodingBoundary(t *testing.T) {
+	// Object-only audit: do not allocate or execute any huge-offset access.
+	dir := t.TempDir()
+	path := filepath.Join(dir, "wide.s")
+	for _, offset := range []string{"2147483647", "2147483648", "4294959104", "4294967295", "4295032832", "-2147483648", "-2147483649"} {
+		source := "TEXT wide(SB),4,$0-0\nMOVD " + offset + "(R0),R1\nRET\n"
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		output, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", filepath.Join(dir, "wide.o"), path)
+		t.Logf("actual Go offset=%s accepted=%v diagnostics/listing:\n%s", offset, err == nil, output)
+	}
+	// Go's writeback encoder also explicitly narrows the source displacement
+	// to int32 before testing its signed-nine-bit range. Keep this genuine
+	// accepted/rejected source distinction separate from literal-pool offsets.
+	for _, offset := range []string{"4294967296", "4294967551", "4294967552", "-4294967296", "-4294967552", "-4294967553"} {
+		source := "TEXT wide(SB),4,$0-0\nMOVD.P " + offset + "(R0),R1\nRET\n"
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		output, err := arm64MemoryAuditGoCommand(t, "linux", "tool", "asm", "-S", "-o", filepath.Join(dir, "wide.o"), path)
+		t.Logf("actual Go post-index offset=%s accepted=%v diagnostics/listing:\n%s", offset, err == nil, output)
+	}
+}
+
+func TestARM64ScalarMemoryAuditOriginalGoObjects(t *testing.T) {
+	forms := arm64MemoryAuditForms()
+	var source strings.Builder
+	for index, form := range forms {
+		fmt.Fprintf(&source, "TEXT audit%d(SB),4,$0-0\n%s\nRET\n", index, form.instruction)
+	}
+	source.WriteString("GLOBL payload(SB),8,$16\nDATA payload+0(SB)/8,$0x10203040aa80feff\nDATA payload+8(SB)/8,$0xfedcba9876543210\n")
+	dir := t.TempDir()
+	path := filepath.Join(dir, "original.s")
+	if err := os.WriteFile(path, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	functionHeader := regexp.MustCompile(`^audit([0-9]+) STEXT `)
+	bytesRow := regexp.MustCompile(`^\s*0x[0-9a-f]+((?: [0-9a-f]{2}){4,16})(?:\s|$)`)
+	returnRow := regexp.MustCompile(`^\s*0x([0-9a-f]+) [0-9]+ .*\)\s+RET(?:\s|$)`)
+	for _, goos := range []string{"linux", "darwin"} {
+		listing, err := arm64MemoryAuditGoCommand(t, goos, "tool", "asm", "-S", "-o", filepath.Join(dir, goos+".o"), path)
+		if err != nil {
+			t.Fatalf("actual Go %s memory object family: %v\n%s", goos, err, listing)
+		}
+		data := make([][]byte, len(forms))
+		returnPC := make([]int, len(forms))
+		current := -1
+		for _, line := range strings.Split(string(listing), "\n") {
+			if match := functionHeader.FindStringSubmatch(line); match != nil {
+				current, err = strconv.Atoi(match[1])
+				if err != nil || current >= len(forms) {
+					t.Fatal("invalid original Go listing function identity")
+				}
+			}
+			if current < 0 {
+				continue
+			}
+			if strings.HasPrefix(line, "payload ") {
+				current = -1
+				continue
+			}
+			if match := bytesRow.FindStringSubmatch(line); match != nil {
+				row, err := hex.DecodeString(strings.ReplaceAll(match[1], " ", ""))
+				if err != nil {
+					t.Fatal(err)
+				}
+				data[current] = append(data[current], row...)
+			}
+			if match := returnRow.FindStringSubmatch(line); match != nil {
+				pc, parseErr := strconv.ParseInt(match[1], 16, 32)
+				err = parseErr
+				if err != nil {
+					t.Fatal(err)
+				}
+				returnPC[current] = int(pc)
+			}
+		}
+		for index, form := range forms {
+			if len(data[index]) < 12 || returnPC[index] == 0 {
+				t.Fatalf("missing actual Go %s case %d bytes/RET: %s", goos, index, form.instruction)
+			}
+			if form.width != 0 && returnPC[index] != form.width {
+				t.Errorf("actual Go %s %s width %d want %d", goos, form.instruction, returnPC[index], form.width)
+			}
+			t.Logf("%s %03d %-31s RET-PC=%d bytes=%x", goos, index, form.instruction, returnPC[index], data[index])
+		}
+		t.Logf("actual Go %s original source SHA256 %x object listing SHA256 %x; %d accepted memory formats", goos, sha256.Sum256([]byte(source.String())), sha256.Sum256(listing), len(forms))
+	}
+}
diff --git a/arm64_scalar_memory_forms.go b/arm64_scalar_memory_forms.go
new file mode 100644
index 000000000..baa31ae65
--- /dev/null
+++ b/arm64_scalar_memory_forms.go
@@ -0,0 +1,351 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+)
+
+// The seven GP moves share Go asm7's 20/21, 30/31, 22/23,
+// 98/99 and 64/65 rows. A long named move is an ordered expansion:
+// materialize R27, then read the transfer register. A decoded architectural
+// instruction never acquires that source-encoder effect.
+type arm64ScalarMemoryForm struct {
+	memory         Operand
+	data           Reg
+	bits           int
+	signed, store  bool
+	pre, post      bool
+	scratch        bool
+	scratchKnown   bool
+	scratchAddress bool
+	scratchBase    Reg
+	scratchOffset  int64
+}
+
+func arm64ScalarMemoryBits(op Op) (int, bool) {
+	switch op {
+	case "MOVB", "MOVBU":
+		return 8, op == "MOVB"
+	case "MOVH", "MOVHU":
+		return 16, op == "MOVH"
+	case "MOVW", "MOVWU":
+		return 32, op == "MOVW"
+	case "MOVD":
+		return 64, false
+	}
+	return 0, false
+}
+
+func arm64ScalarMoveOperandClassError(op Op, ins Instr) error {
+	if bits, _ := arm64ScalarMemoryBits(op); bits == 0 {
+		return nil
+	}
+	// TYPE_FCONST is Go's distinct C_FCON class, not an integer zero or
+	// bit-pattern constant. Every scalar move consumer uses this same rule;
+	// FMOV retains its separate floating-point grammar.
+	for _, operand := range ins.Args {
+		if operand.Kind == OpImm && operand.ImmIsFloat {
+			return fmt.Errorf("arm64 %s cannot use a floating immediate: %q", op, ins.Raw)
+		}
+	}
+	return nil
+}
+
+func parseARM64ScalarMemoryForm(op Op, ins Instr) (f arm64ScalarMemoryForm, handled bool, err error) {
+	f.bits, f.signed = arm64ScalarMemoryBits(op)
+	if f.bits == 0 || len(ins.Args) != 2 {
+		return f, false, nil
+	}
+	isMemory := func(a Operand) bool {
+		return a.Kind == OpMem || a.Kind == OpFP || a.Kind == OpSym &&
+			!strings.HasPrefix(strings.TrimSpace(a.Sym), "$")
+	}
+	f.memory, f.store = ins.Args[0], false
+	data := ins.Args[1]
+	if isMemory(ins.Args[1]) {
+		f.memory, data, f.store = ins.Args[1], ins.Args[0], true
+	}
+	if !isMemory(f.memory) {
+		return f, false, nil
+	}
+	if err := arm64ScalarMoveOperandClassError(op, ins); err != nil {
+		return f, true, err
+	}
+	invalid := func() (arm64ScalarMemoryForm, bool, error) {
+		return f, true, fmt.Errorf("arm64 %s memory operands are outside its Go scalar rows: %q", op, ins.Raw)
+	}
+	if f.store && data.Kind == OpImm && data.Imm == 0 && data.ImmRaw == "" && !data.ImmIsFloat {
+		data = Operand{Kind: OpReg, Reg: ZR}
+	}
+	if data.Kind != OpReg || !isARM64GeneralOrZeroReg(data.Reg) {
+		return invalid()
+	}
+	if !ins.arm64Encoded && !arm64ScalarMemoryGoRegisterSpelling(ins) {
+		return invalid()
+	}
+	f.data = data.Reg
+	suffix := strings.TrimPrefix(string(ins.Op), string(op))
+	f.pre, f.post = suffix == ".W", suffix == ".P"
+	if suffix != "" && !f.pre && !f.post {
+		return invalid()
+	}
+	if f.memory.Kind == OpSym {
+		if strings.ContainsAny(f.memory.Sym, "()") && !strings.HasSuffix(f.memory.Sym, "(SB)") {
+			return invalid() // An invalid register memory is not a bare SB alias.
+		}
+		if f.pre || f.post || f.store && f.data == "R27" {
+			return invalid()
+		}
+		if _, _, ok := parseSBRef(f.memory.Sym); !ok {
+			if sourceSymbolOffsetNeedsContext(f.memory.Sym) {
+				return f, true, fmt.Errorf("%w: arm64 %s symbol displacement requires generated assembler constants: %q", ErrProbeNeedsContext, op, ins.Raw)
+			}
+			return invalid()
+		}
+		// Native ADRP's page identity depends on the actual linked layout.
+		// LLVM globals alone do not supply that physical page contract.
+		f.scratch, f.scratchAddress = !ins.arm64Encoded, true
+		return f, true, nil
+	}
+	offset := f.memory.FPOffset
+	if f.memory.Kind == OpFP {
+		if f.pre || f.post {
+			return invalid()
+		}
+		if ins.arm64ScalarMemoryFrameOffset == nil {
+			f.scratch, f.scratchAddress = true, true
+			return f, true, nil // No guessed physical FP offset/backing identity.
+		}
+		offset = *ins.arm64ScalarMemoryFrameOffset
+	} else {
+		mem := f.memory.Mem
+		if mem.Sym != "" || mem.Segment != "" || mem.OffRaw != "" ||
+			!arm64AddressReg(mem.Base) && mem.Base != ZR {
+			return invalid()
+		}
+		if mem.Base == ZR || mem.Base == "RSP" {
+			f.memory.Mem.Base = SP // Encoding 31 is SP in the address bank.
+		}
+		offset = mem.Off
+		if f.pre || f.post {
+			// Go regoff narrows to int32 before matching the signed-nine-bit
+			// field. This is a source encoding rule, not a wide update.
+			offset = int64(int32(offset))
+			if mem.Index != "" || offset < -256 || offset > 255 {
+				return invalid()
+			}
+			if !arm64StackReg(f.memory.Mem.Base) && mem.Base == f.data {
+				return f, true, fmt.Errorf("arm64 %s writeback has base/data register overlap: %q", op, ins.Raw)
+			}
+			f.memory.Mem.Off = offset
+			return f, true, nil
+		}
+		if mem.Index != "" {
+			if offset != 0 || !isARM64GeneralOrZeroReg(mem.Index) ||
+				mem.Scale != 0 && mem.Scale != 1 && mem.Scale != int64(f.bits/8) {
+				return invalid()
+			}
+			switch mem.IndexExt {
+			case "", ExtendUXTW, ExtendSXTW, ExtendSXTX:
+			case ExtendUXTX:
+				if !ins.arm64Encoded { // Go textual UXTX is not its LSL row.
+					return invalid()
+				}
+			default:
+				return invalid()
+			}
+			return f, true, nil
+		}
+		f.scratchBase = f.memory.Mem.Base
+	}
+	if ins.arm64Encoded || arm64ScalarMemoryDirectOffset(offset, f.bits) {
+		return f, true, nil
+	}
+	if offset < math.MinInt32 || offset > math.MaxInt32 {
+		return f, true, fmt.Errorf("%w: arm64 %s long offset requires its original narrowed Go encoder", ErrProbeNeedsContext, op)
+	}
+	f.scratch = true
+	currentBase, current := arm64ScalarMemoryCurrentScratch(offset, f.bits)
+	legacyBase, legacy := arm64ScalarMemoryLegacyScratch(offset, f.bits)
+	f.scratchAddress = currentBase || legacyBase
+	f.scratchOffset = current
+	f.scratchKnown = currentBase == legacyBase && current == legacy
+	// FP shadow slots are not the native caller frame's physical SP.
+	if f.memory.Kind == OpFP && f.scratchAddress {
+		f.scratchKnown = false
+	}
+	if (!currentBase || !legacyBase) && f.memory.Kind == OpMem &&
+		(f.scratchBase == "R27" || f.store && f.data == "R27") {
+		return invalid() // Both Go pool paths forbid their REGTMP inputs.
+	}
+	if !currentBase && !legacyBase && !f.store && f.data == "R27" {
+		return f, true, fmt.Errorf("%w: arm64 pool load to R27 differs between original Go encoders", ErrProbeNeedsContext)
+	}
+	if !f.scratchKnown && f.store && f.data == "R27" {
+		return f, true, fmt.Errorf("%w: arm64 store consumes an unproved original Go R27 materialization", ErrProbeNeedsContext)
+	}
+	return f, true, nil
+}
+
+// The public parser keeps historical W aliases for other consumers. In an
+// original named Go memory instruction they are not in the asm register map.
+// This is only a rejection check, never authority to set decoder/source proof.
+func arm64ScalarMemoryGoRegisterSpelling(ins Instr) bool {
+	op, rest := splitOpcode(ins.Raw)
+	if op != string(ins.Op) {
+		return true // A structured public instruction has no raw spelling proof.
+	}
+	wRegister := func(text string) bool {
+		text = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(text), "*"))
+		_, register := parseReg(text)
+		return register && strings.HasPrefix(strings.ToUpper(text), "W")
+	}
+	for _, operand := range splitTopLevelCSV(rest) {
+		if wRegister(operand) {
+			return false
+		}
+		for remaining := operand; ; {
+			start := strings.IndexByte(remaining, '(')
+			if start < 0 {
+				break
+			}
+			remaining = remaining[start+1:]
+			end := strings.IndexByte(remaining, ')')
+			if end < 0 {
+				break
+			}
+			terminal := strings.TrimSpace(remaining[:end])
+			if separator := strings.IndexAny(terminal, ".<*"); separator >= 0 {
+				terminal = terminal[:separator]
+			}
+			if wRegister(terminal) {
+				return false
+			}
+			remaining = remaining[end+1:]
+		}
+	}
+	return true
+}
+
+func arm64ScalarMemoryDirectOffset(offset int64, bits int) bool {
+	width := int64(bits / 8)
+	return offset >= -256 && offset <= 255 || offset >= 0 && offset%width == 0 && offset/width <= 4095
+}
+
+func arm64ScalarMemoryCurrentScratch(offset int64, bits int) (address bool, value int64) {
+	if offset >= -4095 && offset <= 4095 {
+		return true, offset
+	}
+	width := int64(bits / 8)
+	if offset < 0 || offset > 0xfff000+0xfff*width {
+		return false, offset
+	}
+	hi := offset - 0xfff*width
+	if remainder := offset & (width - 1); remainder > hi {
+		hi = remainder
+	}
+	if hi <= 0xfff {
+		return true, hi
+	}
+	hi = offset - (offset/width&0xfff)*width
+	if hi > 0xfff000 {
+		hi = 0xfff000
+	}
+	if hi&^int64(0xfff000) == 0 && (offset-hi)%width == 0 {
+		return true, hi
+	}
+	return false, offset
+}
+
+func arm64ScalarMemoryLegacyScratch(offset int64, bits int) (address bool, value int64) {
+	width := int64(bits / 8)
+	if offset < 0 || offset&(width-1) != 0 {
+		return false, offset
+	}
+	hi := offset - (offset/width&0xfff)*width
+	if hi&^int64(0xfff000) != 0 {
+		return false, offset
+	}
+	return true, hi
+}
+
+// Resolve Go's AUTO/FP class offsets before any source-frame/CFG proof.
+// Keep ordinary typed FP operands intact: their LLVM shadow storage is still
+// distinct from a physical native SP. No public input can assert this marker.
+func normalizeARM64ScalarMemoryFrame(fn Func) (Func, error) {
+	frame := arm64SourceGoFrame(fn)
+	frameKnown := arm64SourceFrameFlagsKnown(fn) && fn.FrameSize >= -8 &&
+		fn.FrameSize <= math.MaxInt32-24 && fn.FrameSize&7 == 0
+	logical, autosize := int64(0), int64(0)
+	if frameKnown && frame.present {
+		if fn.FrameSize < 0 || fn.FrameSize > math.MaxInt64-32 {
+			return fn, fmt.Errorf("invalid ARM64 scalar source frame size %d", fn.FrameSize)
+		}
+		logical, autosize = fn.FrameSize+8, arm64SourceFrameAutosize(fn.FrameSize)
+	}
+	copied := false
+	for i, ins := range fn.Instrs {
+		if !frameKnown {
+			for _, operand := range ins.Args {
+				if bits, _ := arm64ScalarMemoryBits(arm64ControlOp(ins)); bits == 0 || ins.arm64Encoded {
+					break
+				}
+				if operand.Kind == OpMem && arm64NamedStackOffset(operand.Mem) {
+					return fn, fmt.Errorf("%w: ARM64 scalar AUTO needs the original source-frame identity", ErrProbeNeedsContext)
+				}
+			}
+			// An old private marker cannot authorize a changed source frame.
+			if ins.arm64ScalarMemoryFrameOffset != nil {
+				if !copied {
+					fn.Instrs = append([]Instr(nil), fn.Instrs...)
+					copied = true
+				}
+				fn.Instrs[i].arm64ScalarMemoryFrameOffset = nil
+			}
+			continue
+		}
+		normalized, changed, err := normalizeARM64ScalarMemoryInstruction(ins, logical, autosize)
+		if err != nil {
+			return fn, err
+		}
+		if changed {
+			if !copied {
+				fn.Instrs = append([]Instr(nil), fn.Instrs...)
+				copied = true
+			}
+			fn.Instrs[i] = normalized
+		}
+	}
+	return fn, nil
+}
+
+func normalizeARM64ScalarMemoryInstruction(ins Instr, logical, autosize int64) (Instr, bool, error) {
+	if bits, _ := arm64ScalarMemoryBits(arm64ControlOp(ins)); bits == 0 || ins.arm64Encoded || len(ins.Args) != 2 {
+		return ins, false, nil
+	}
+	changed := false
+	for j, arg := range ins.Args {
+		switch {
+		case arg.Kind == OpFP:
+			if arg.FPOffset > math.MaxInt64-autosize-8 {
+				return ins, false, fmt.Errorf("ARM64 FP source offset overflows")
+			}
+			offset := arg.FPOffset + autosize + 8
+			ins.arm64ScalarMemoryFrameOffset = &offset
+			changed = true
+		case arg.Kind == OpMem && arm64NamedStackOffset(arg.Mem):
+			if string(ins.Op) != string(arm64ControlOp(ins)) || arg.Mem.Index != "" {
+				return ins, false, fmt.Errorf("ARM64 scalar AUTO memory has no indexed/writeback Go row: %q", ins.Raw)
+			}
+			if arg.Mem.Off > math.MaxInt64-logical {
+				return ins, false, fmt.Errorf("ARM64 AUTO source offset overflows")
+			}
+			ins.Args = append([]Operand(nil), ins.Args...)
+			ins.Args[j].Mem.Off += logical
+			ins.Args[j].Mem.OffRaw = ""
+			changed = true
+		}
+	}
+	return ins, changed, nil
+}
diff --git a/arm64_scalar_memory_go_rows_oracle_test.go b/arm64_scalar_memory_go_rows_oracle_test.go
new file mode 100644
index 000000000..e0496de5c
--- /dev/null
+++ b/arm64_scalar_memory_go_rows_oracle_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+type arm64MOVGoRow struct {
+	fields  []string
+	ordinal int
+	line    int
+}
+
+// Independently transcribed from Go asm7's memory rows, not from the
+// production grammar. code size is not the memory width. Go 1.20/1.21 lack
+// a5 and separate pool classes; their ordinary long rows carry pool flags.
+func arm64MOVExpectedGoRows(op, auto, oreg string, columns int) [][]string {
+	var rows [][]string
+	add := func(from, to, kind, size, param, flag, suffix string) {
+		row := []string{op, from, "C_NONE", "C_NONE", to}
+		if columns == 11 {
+			row = append(row, "C_NONE")
+		}
+		rows = append(rows, append(row, kind, size, param, flag, suffix))
+	}
+	add("C_ZREG", "C_ADDR", "64", "12", "0", "0", "0")
+	add("C_ADDR", "C_ZREG", "65", "12", "0", "0", "0")
+	for _, memory := range []struct{ class, param string }{
+		{auto, "REGSP"}, {oreg, "0"}, {"C_NSAUTO", "REGSP"}, {"C_NSOREG", "0"},
+	} {
+		add("C_ZREG", memory.class, "20", "4", memory.param, "0", "0")
+	}
+	for _, memory := range []struct{ class, param string }{
+		{auto, "REGSP"}, {oreg, "0"}, {"C_NSAUTO", "REGSP"}, {"C_NSOREG", "0"},
+	} {
+		add(memory.class, "C_ZREG", "21", "4", memory.param, "0", "0")
+	}
+	for _, store := range []bool{true, false} {
+		kind, pool := "31", "LFROM"
+		if store {
+			kind, pool = "30", "LTO"
+		}
+		for _, memory := range []struct{ class, param string }{
+			{"C_LAUTO", "REGSP"}, {"C_LOREG", "0"},
+		} {
+			flag := "0"
+			if columns == 10 {
+				flag = pool
+			}
+			from, to := memory.class, "C_ZREG"
+			if store {
+				from, to = to, from
+			}
+			add(from, to, kind, "8", memory.param, flag, "0")
+			if columns == 11 {
+				if store {
+					to += "POOL"
+				} else {
+					from += "POOL"
+				}
+				add(from, to, kind, "8", memory.param, pool, "0")
+			}
+		}
+	}
+	for _, suffix := range []string{"C_XPOST", "C_XPRE"} {
+		add("C_LOREG", "C_ZREG", "22", "4", "0", "0", suffix)
+	}
+	for _, suffix := range []string{"C_XPOST", "C_XPRE"} {
+		add("C_ZREG", "C_LOREG", "23", "4", "0", "0", suffix)
+	}
+	add("C_ROFF", "C_ZREG", "98", "4", "0", "0", "0")
+	add("C_ZREG", "C_ROFF", "99", "4", "0", "0", "0")
+	return rows
+}
+
+func arm64MOVGoExpr(expr ast.Expr) string {
+	var out bytes.Buffer
+	if err := format.Node(&out, token.NewFileSet(), expr); err != nil {
+		return ""
+	}
+	return out.String()
+}
+
+func arm64MOVReadGoRows(source, version string) (map[string][]arm64MOVGoRow, int, error) {
+	if len(source) == 0 || len(source) > 8<<20 {
+		return nil, 0, fmt.Errorf("unknown or oversized SDK source")
+	}
+	columns, err := arm64CarryProbeGoOptabColumns(source, version)
+	if err != nil {
+		return nil, 0, err
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "asm7.go", source, parser.SkipObjectResolution)
+	if err != nil {
+		return nil, 0, err
+	}
+	bases := map[string]bool{"AMOVB": true, "AMOVH": true, "AMOVW": true, "AMOVD": true}
+	memoryCases := map[string]bool{"20": true, "21": true, "22": true, "23": true, "30": true, "31": true, "64": true, "65": true, "98": true, "99": true}
+	// These are the separate GP/literal/address/system-register cases, not
+	// additional memory forms or grammar authority. A new case fails closed.
+	otherCases := map[string]bool{
+		"4": true, "12": true, "24": true, "32": true, "34": true,
+		"35": true, "36": true, "37": true, "45": true,
+		"68": true, "69": true, "70": true, "71": true,
+	}
+	memoryClass := func(class string) bool {
+		for _, prefix := range []string{"C_UAUTO", "C_UOREG", "C_NSAUTO", "C_NSOREG", "C_LAUTO", "C_LOREG", "C_ADDR", "C_ROFF"} {
+			if strings.HasPrefix(class, prefix) {
+				return true
+			}
+		}
+		return false
+	}
+	rows := make(map[string][]arm64MOVGoRow)
+	tables, builders, aliasCalls := 0, 0, 0
+	aliases := map[string]string{"AMOVB": "AMOVBU", "AMOVH": "AMOVHU", "AMOVW": "AMOVWU"}
+	seenAliases := make(map[string]bool)
+	for _, declaration := range file.Decls {
+		if group, ok := declaration.(*ast.GenDecl); ok && group.Tok == token.VAR {
+			for _, spec := range group.Specs {
+				value := spec.(*ast.ValueSpec)
+				for index, name := range value.Names {
+					if name.Name != "optab" {
+						continue
+					}
+					tables++
+					if index >= len(value.Values) {
+						return nil, 0, fmt.Errorf("missing actual optab literal")
+					}
+					table, ok := value.Values[index].(*ast.CompositeLit)
+					if !ok {
+						return nil, 0, fmt.Errorf("actual optab is not a literal")
+					}
+					array, ok := table.Type.(*ast.ArrayType)
+					if !ok || array.Len != nil || arm64MOVGoExpr(array.Elt) != "Optab" {
+						return nil, 0, fmt.Errorf("unknown original optab type")
+					}
+					for ordinal, element := range table.Elts {
+						row, ok := element.(*ast.CompositeLit)
+						if !ok || len(row.Elts) == 0 {
+							return nil, 0, fmt.Errorf("unknown actual optab row")
+						}
+						op := arm64MOVGoExpr(row.Elts[0])
+						if op == "AMOVBU" || op == "AMOVHU" || op == "AMOVWU" {
+							return nil, 0, fmt.Errorf("unsigned MOV acquired a direct row")
+						}
+						if !bases[op] {
+							continue
+						}
+						if len(row.Elts) != columns {
+							return nil, 0, fmt.Errorf("MOV row does not match full SDK schema")
+						}
+						fields := make([]string, columns)
+						for field, expr := range row.Elts {
+							if _, keyed := expr.(*ast.KeyValueExpr); keyed {
+								return nil, 0, fmt.Errorf("unknown keyed MOV row")
+							}
+							fields[field] = arm64MOVGoExpr(expr)
+						}
+						kind := fields[columns-5]
+						if _, err := strconv.ParseInt(kind, 10, 8); err != nil {
+							return nil, 0, fmt.Errorf("unknown MOV encoder type: %q", kind)
+						}
+						memory := memoryCases[kind]
+						for _, class := range fields[1 : columns-5] {
+							memory = memory || memoryClass(class)
+						}
+						if memory {
+							rows[op] = append(rows[op], arm64MOVGoRow{fields, ordinal, fset.Position(row.Pos()).Line})
+						} else if !otherCases[kind] {
+							return nil, 0, fmt.Errorf("unregistered MOV table case %s", kind)
+						}
+					}
+				}
+			}
+		}
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "buildop" || function.Body == nil {
+			continue
+		}
+		builders++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if ok && arm64MOVGoExpr(call.Fun) == "oprangeset" && len(call.Args) != 0 {
+				switch arm64MOVGoExpr(call.Args[0]) {
+				case "AMOVBU", "AMOVHU", "AMOVWU":
+					aliasCalls++
+				}
+			}
+			return true
+		})
+		var aliasErr error
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			clause, ok := node.(*ast.CaseClause)
+			if !ok || len(clause.List) != 1 {
+				return true
+			}
+			base := arm64MOVGoExpr(clause.List[0])
+			alias, selected := aliases[base]
+			if !selected {
+				return true
+			}
+			if seenAliases[base] || len(clause.Body) != 1 {
+				aliasErr = fmt.Errorf("unknown or repeated MOV alias base %s", base)
+				return false
+			}
+			statement, ok := clause.Body[0].(*ast.ExprStmt)
+			if !ok {
+				aliasErr = fmt.Errorf("unknown MOV alias statement")
+				return false
+			}
+			call, ok := statement.X.(*ast.CallExpr)
+			if !ok || arm64MOVGoExpr(call.Fun) != "oprangeset" || len(call.Args) != 2 ||
+				arm64MOVGoExpr(call.Args[0]) != alias || arm64MOVGoExpr(call.Args[1]) != "t" {
+				aliasErr = fmt.Errorf("changed exact MOV alias %s -> %s", base, alias)
+				return false
+			}
+			seenAliases[base] = true
+			return false
+		})
+		if aliasErr != nil {
+			return nil, 0, aliasErr
+		}
+	}
+	if tables != 1 || builders != 1 || len(seenAliases) != 3 || aliasCalls != 3 {
+		return nil, 0, fmt.Errorf("incomplete original MOV table/alias inventory")
+	}
+	return rows, columns, nil
+}
+
+func arm64MOVCheckCompleteGoRows(source, version string) (map[string][]arm64MOVGoRow, int, error) {
+	rows, columns, err := arm64MOVReadGoRows(source, version)
+	if err != nil {
+		return nil, 0, err
+	}
+	for _, family := range []struct{ op, auto, oreg string }{
+		{"AMOVB", "C_UAUTO4K", "C_UOREG4K"},
+		{"AMOVH", "C_UAUTO8K", "C_UOREG8K"},
+		{"AMOVW", "C_UAUTO16K", "C_UOREG16K"},
+		{"AMOVD", "C_UAUTO32K", "C_UOREG32K"},
+	} {
+		var fields [][]string
+		for _, row := range rows[family.op] {
+			fields = append(fields, row.fields)
+		}
+		want := arm64MOVExpectedGoRows(family.op, family.auto, family.oreg, columns)
+		if !reflect.DeepEqual(fields, want) {
+			return nil, 0, fmt.Errorf("complete Go %s %s memory rows changed: got %v want %v", version, family.op, fields, want)
+		}
+	}
+	return rows, columns, nil
+}
diff --git a/arm64_scalar_memory_go_rows_test.go b/arm64_scalar_memory_go_rows_test.go
new file mode 100644
index 000000000..e9b630680
--- /dev/null
+++ b/arm64_scalar_memory_go_rows_test.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func arm64MOVSelectedGoSource(t *testing.T) (string, string) {
+	t.Helper()
+	root := testGOROOT(t)
+	source, err := os.ReadFile(filepath.Join(root, "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	version, err := os.ReadFile(filepath.Join(root, "VERSION"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := strings.SplitN(strings.TrimSpace(string(version)), "\n", 2)[0]
+	t.Logf("MOV_ROW_SOURCE version=%s source_sha256=%x", name, sha256.Sum256(source))
+	return string(source), name
+}
+
+type arm64MOVAttributeMutation struct {
+	name, source string
+}
+
+// These mutations edit complete selected-SDK rows, not production properties.
+// Each preserves all per-opcode/case counts and the unsigned alias statements.
+func arm64MOVSameCountMutations(source string) ([]arm64MOVAttributeMutation, error) {
+	var changes []arm64MOVAttributeMutation
+	for _, name := range []string{"param", "pool_flag", "prepost", "code_size", "class", "case_role"} {
+		lines := strings.Split(source, "\n")
+		changed := 0
+		for index, line := range lines {
+			trimmed := strings.TrimSpace(line)
+			if !strings.HasPrefix(trimmed, "{AMOVH,") {
+				continue
+			}
+			end := strings.IndexByte(trimmed, '}')
+			if end < 0 {
+				return nil, fmt.Errorf("unterminated original MOV row")
+			}
+			fields := strings.Split(trimmed[1:end], ",")
+			if len(fields) != 10 && len(fields) != 11 {
+				return nil, fmt.Errorf("unknown original MOV row shape")
+			}
+			for field := range fields {
+				fields[field] = strings.TrimSpace(fields[field])
+			}
+			kindAt := len(fields) - 5
+			kind, err := strconv.Atoi(fields[kindAt])
+			if err != nil {
+				return nil, err
+			}
+			edit := false
+			switch name {
+			case "param":
+				edit = changed == 0 && kind == 20 && fields[4] == "C_UAUTO8K"
+				if edit {
+					fields[kindAt+2] = "0"
+				}
+			case "pool_flag":
+				edit = changed == 0 && kind == 30 && fields[kindAt+3] == "LTO"
+				if edit {
+					fields[kindAt+3] = "0"
+				}
+			case "prepost", "class":
+				edit = changed == 0 && kind == 22 && fields[kindAt+4] == "C_XPRE"
+				if edit && name == "prepost" {
+					fields[kindAt+4] = "C_XPOST"
+				} else if edit {
+					fields[1] = "C_NSOREG"
+				}
+			case "code_size":
+				edit = changed == 0 && kind == 30
+				if edit {
+					fields[kindAt+1] = "4"
+				}
+			case "case_role":
+				edit = changed == 0 && kind == 20 || changed == 1 && kind == 21
+				if edit {
+					fields[kindAt] = strconv.Itoa(41 - kind)
+				}
+			}
+			if edit {
+				lines[index] = "\t{" + strings.Join(fields, ", ") + "},"
+				changed++
+			}
+		}
+		want := 1
+		if name == "case_role" {
+			want = 2
+		}
+		if changed != want {
+			return nil, fmt.Errorf("%s requires %d actual row edits, got %d", name, want, changed)
+		}
+		changes = append(changes, arm64MOVAttributeMutation{name, strings.Join(lines, "\n")})
+	}
+	return changes, nil
+}
+
+func TestARM64ScalarMemoryGoRowsRejectSameCountAttributeMutations(t *testing.T) {
+	source, version := arm64MOVSelectedGoSource(t)
+	count, err := arm64ScalarMemoryLegacyGoRows(source)
+	if err != nil {
+		t.Fatalf("unmodified actual SDK prerequisites: %v", err)
+	}
+	if _, _, err := arm64MOVCheckCompleteGoRows(source, version); err != nil {
+		t.Fatalf("unmodified complete SDK prerequisites: %v", err)
+	}
+	mutations, err := arm64MOVSameCountMutations(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range mutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			if mutation.source == source {
+				t.Fatal("attribute mutation did not change the actual input")
+			}
+			if got, err := arm64ScalarMemoryLegacyGoRows(mutation.source); err != nil || got != count {
+				t.Fatalf("mutation changed the legacy denominator/aliases: %d/%d %v", got, count, err)
+			}
+			if _, _, err := arm64MOVCheckCompleteGoRows(mutation.source, version); err == nil {
+				t.Fatal("complete MOV oracle accepted a changed attribute despite identical legacy counts/aliases")
+			}
+		})
+	}
+}
+
+func TestARM64ScalarMemoryGoRowsMatchCompleteSelectedTable(t *testing.T) {
+	source, version := arm64MOVSelectedGoSource(t)
+	rows, columns, err := arm64MOVCheckCompleteGoRows(source, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"AMOVB", "AMOVH", "AMOVW", "AMOVD"} {
+		t.Run(op, func(t *testing.T) {
+			previous := -1
+			for _, row := range rows[op] {
+				t.Run(fmt.Sprintf("row_%d", row.ordinal), func(t *testing.T) {
+					if len(row.fields) != columns || row.ordinal <= previous || row.line <= 0 {
+						t.Fatal("complete row/physical order was discarded")
+					}
+					previous = row.ordinal
+					t.Logf("MOV_ROW line=%d ordinal=%d fields=%v", row.line, row.ordinal, row.fields)
+				})
+			}
+		})
+	}
+}
+
+func arm64MOVReplaceSourceRow(t *testing.T, source string, row arm64MOVGoRow, fields []string) string {
+	t.Helper()
+	lines := strings.Split(source, "\n")
+	if row.line <= 0 || row.line > len(lines) || !strings.Contains(lines[row.line-1], "{"+row.fields[0]+",") {
+		t.Fatal("mutation lost the actual source-row identity")
+	}
+	lines[row.line-1] = "\t{" + strings.Join(fields, ", ") + "},"
+	changed := strings.Join(lines, "\n")
+	if changed == source {
+		t.Fatal("source row was not changed")
+	}
+	return changed
+}
+
+func TestARM64ScalarMemoryGoRowsRejectEveryRetainedFieldMutation(t *testing.T) {
+	source, version := arm64MOVSelectedGoSource(t)
+	rows, columns, err := arm64MOVCheckCompleteGoRows(source, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := []string{"as", "a1", "a2", "a3", "a4"}
+	values := []string{"AMOVUNKNOWN", "C_UNKNOWN", "C_UNKNOWN", "C_UNKNOWN", "C_UNKNOWN"}
+	if columns == 11 {
+		names, values = append(names, "a5"), append(values, "C_UNKNOWN")
+	}
+	names = append(names, "type_", "size_", "param", "flag", "scond")
+	values = append(values, "127", "3", "REGTMP", "LFROM | LTO", "C_XUNKNOWN")
+	row := rows["AMOVH"][0]
+	for index, name := range names {
+		t.Run(name, func(t *testing.T) {
+			fields := append([]string(nil), row.fields...)
+			fields[index] = values[index]
+			changed := arm64MOVReplaceSourceRow(t, source, row, fields)
+			if _, _, err := arm64MOVCheckCompleteGoRows(changed, version); err == nil {
+				t.Fatal("an independent encoder field was discarded")
+			}
+		})
+	}
+}
+
+func TestARM64ScalarMemoryGoRowsRejectUnknownRolesAndDuplicates(t *testing.T) {
+	source, version := arm64MOVSelectedGoSource(t)
+	rows, _, err := arm64MOVCheckCompleteGoRows(source, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	row := rows["AMOVH"][2] // First type-20 AUTO store, followed by the OREG store.
+	extraField := append(append([]string(nil), row.fields...), "0")
+	duplicate := arm64MOVReplaceSourceRow(t, source, rows["AMOVH"][3], row.fields)
+	aliasSwap := strings.NewReplacer("oprangeset(AMOVHU, t)", "oprangeset(AMOVWU, t)",
+		"oprangeset(AMOVWU, t)", "oprangeset(AMOVHU, t)").Replace(source)
+	for _, change := range []struct{ name, source, version string }{
+		{"unknown_version", source, "go1.99.1"},
+		{"unknown_schema", strings.Replace(source, "type Optab struct {", "type Optab struct {\nforeign int", 1), version},
+		{"missing_table", strings.Replace(source, "var optab", "var unrelatedOptab", 1), version},
+		{"unknown_table_type", strings.Replace(source, "var optab = []Optab", "var optab = []Foreign", 1), version},
+		{"extra_row_attribute", arm64MOVReplaceSourceRow(t, source, row, extraField), version},
+		{"duplicate_same_count_row", duplicate, version},
+		{"wrong_alias_base", aliasSwap, version},
+		{"extra_alias", strings.Replace(source, "func buildop(ctxt *obj.Link) {", "func buildop(ctxt *obj.Link) {\noprangeset(AMOVHU, nil)", 1), version},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			if change.source == source && change.version == version {
+				t.Fatal("negative fixture did not change the source role")
+			}
+			if _, _, err := arm64MOVCheckCompleteGoRows(change.source, change.version); err == nil {
+				t.Fatal("unknown role or duplicate was silently reduced to known MOV rows")
+			}
+		})
+	}
+}
+
+// This bridge checks semantic shapes, not which overlapping row oplook chose
+// for a concrete object. It creates no storage/carrier/native certificate.
+func TestARM64ScalarMemoryGoRowsAndTypedShapesAgree(t *testing.T) {
+	source, version := arm64MOVSelectedGoSource(t)
+	rows, columns, err := arm64MOVCheckCompleteGoRows(source, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, family := range []struct {
+		op, base string
+		bits     int
+		signed   bool
+	}{
+		{"MOVB", "AMOVB", 8, true}, {"MOVBU", "AMOVB", 8, false},
+		{"MOVH", "AMOVH", 16, true}, {"MOVHU", "AMOVH", 16, false},
+		{"MOVW", "AMOVW", 32, true}, {"MOVWU", "AMOVW", 32, false},
+		{"MOVD", "AMOVD", 64, false},
+	} {
+		t.Run(family.op, func(t *testing.T) {
+			for _, row := range rows[family.base] {
+				t.Run(fmt.Sprintf("row_%d", row.ordinal), func(t *testing.T) {
+					kind := row.fields[columns-5]
+					store := kind == "20" || kind == "30" || kind == "23" || kind == "99" || kind == "64"
+					class := row.fields[1]
+					if store {
+						class = row.fields[4]
+					}
+					memory := "0(R0)"
+					switch {
+					case class == "C_ADDR":
+						memory = "payload(SB)"
+					case class == "C_ROFF":
+						memory = "(R0)(R2)"
+					case class == "C_NSAUTO":
+						memory = "local-1(SP)"
+					case class == "C_NSOREG":
+						memory = "-1(R0)"
+					case strings.HasPrefix(class, "C_UAUTO"):
+						memory = "local+0(SP)"
+					case strings.HasPrefix(class, "C_LAUTO"):
+						memory = "local+65536(SP)"
+						if strings.HasSuffix(class, "POOL") {
+							memory = "local-8192(SP)"
+						}
+					case strings.HasPrefix(class, "C_LOREG") && kind != "22" && kind != "23":
+						memory = "65536(R0)"
+						if strings.HasSuffix(class, "POOL") {
+							memory = "-8192(R0)"
+						}
+					}
+					pre, post := row.fields[columns-1] == "C_XPRE", row.fields[columns-1] == "C_XPOST"
+					suffix := ""
+					if pre {
+						suffix = ".W"
+					} else if post {
+						suffix = ".P"
+					}
+					operands := memory + ",R1"
+					if store {
+						operands = "R1," + memory
+					}
+					text := family.op + suffix + " " + operands
+					file, err := Parse(ArchARM64, "TEXT shape(SB),516,$0-0\n"+text+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					fn, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0])
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := fn.Instrs[1]
+					form, handled, err := parseARM64ScalarMemoryForm(Op(family.op), ins)
+					if !handled || err != nil || form.bits != family.bits || form.signed != family.signed ||
+						form.store != store || form.pre != pre || form.post != post || form.data != "R1" {
+						t.Fatalf("complete independent row disagrees with typed shape %s: %+v handled=%v error=%v", text, form, handled, err)
+					}
+					wantScratch := kind == "30" || kind == "31" || kind == "64" || kind == "65"
+					if form.scratch != wantScratch {
+						t.Fatalf("source expansion role disagrees for %s: %+v", text, form)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/arm64_scalar_memory_invalid_transfer_test.go b/arm64_scalar_memory_invalid_transfer_test.go
new file mode 100644
index 000000000..855d02547
--- /dev/null
+++ b/arm64_scalar_memory_invalid_transfer_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarMemoryWritebackOverlapRetainsConcreteDiagnostic(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, suffix := range []string{".P", ".W"} {
+			for _, offset := range []int{-256, 0, 255} {
+				for _, store := range []bool{false, true} {
+					operands := fmt.Sprintf("%d(R13),R13", offset)
+					if store {
+						operands = fmt.Sprintf("R13,%d(R13)", offset)
+					}
+					instruction := op + suffix + " " + operands
+					t.Run(instruction, func(t *testing.T) {
+						source := "TEXT overlap(SB),516,$0-0\n" + instruction + "\nRET\n"
+						requireARM64GoAssemblerResult(t, source, false)
+						file, err := Parse(ArchARM64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						_, handled, err := parseARM64ScalarMemoryForm(Op(op), file.Funcs[0].Instrs[1])
+						if !handled || err == nil || !strings.Contains(err.Error(), "base/data register overlap") {
+							t.Fatalf("writeback overlap = (%v, %v), want its concrete Go rejection", handled, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemoryRejectsStackPointerDataLikeGo(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, operands := range []string{"(R0),RSP", "RSP,(R0)"} {
+			instruction := op + " " + operands
+			t.Run(instruction, func(t *testing.T) {
+				source := "TEXT invalid(SB),516,$0-0\n" + instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, handled, err := parseARM64ScalarMemoryForm(Op(op), file.Funcs[0].Instrs[1])
+				if !handled || err == nil {
+					t.Fatalf("memory data RSP = (%v, %v), accepted Go-invalid transfer", handled, err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_scalar_memory_proof_test.go b/arm64_scalar_memory_proof_test.go
new file mode 100644
index 000000000..946919bc7
--- /dev/null
+++ b/arm64_scalar_memory_proof_test.go
@@ -0,0 +1,383 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64ScalarMemoryCompleteSourceGrammar(t *testing.T) {
+	for _, tc := range arm64MemoryAuditForms() {
+		ins := arm64ImmediateTestInstruction(t, tc.instruction)
+		before := ins
+		file, err := Parse(ArchARM64, "TEXT grammar(SB),4,$0-0\n"+tc.instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := file.Funcs[0]
+		normalized, err := normalizeARM64ScalarMemoryFrame(fn)
+		if err != nil {
+			t.Fatalf("%s normalization: %v", tc.instruction, err)
+		}
+		form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), normalized.Instrs[1])
+		if !handled || err != nil {
+			t.Errorf("original Go accepted %s: handled=%v error=%v", tc.instruction, handled, err)
+		}
+		if !reflect.DeepEqual(ins, before) {
+			t.Fatalf("%s mutated source operands", tc.instruction)
+		}
+		if tc.width == 4 && form.scratch {
+			t.Errorf("direct %s acquired source scratch", tc.instruction)
+		}
+	}
+	// The original Go encoder accepts the int32-narrowed field, not a wide
+	// update. The real assembler bytes are independently checked by the audit.
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, suffix := range []string{".P", ".W"} {
+			ins := arm64ImmediateTestInstruction(t, op+suffix+" $0,4294967551(R0)")
+			form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins)
+			if !handled || err != nil || form.memory.Mem.Off != 255 || form.scratch {
+				t.Fatalf("%s original narrowed writeback: %+v %v", ins.Raw, form, err)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemoryScratchOrderedProvenance(t *testing.T) {
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, direction := range []bool{false, true} {
+			text := op + " 65536(R0),R1"
+			if direction {
+				text = op + " R1,65536(R0)"
+			}
+			ins := arm64ImmediateTestInstruction(t, text)
+			state := &arm64ControlState{
+				regs:   map[Reg]arm64ControlValue{"R0": arm64ControlFromMap(map[string]bool{"label:actual_pc": true}), "R27": arm64ControlFromMap(map[string]bool{"label:old_lr": true})},
+				memory: make(map[string]arm64ControlValue),
+			}
+			state.transfer(ins, ins.Op, false, nil)
+			if arm64ControlHas(state.regs["R27"], "label:old_lr") || !arm64ControlHas(state.regs["R27"], "code-derived:") || !arm64ControlHas(state.regs["R27"], "label:actual_pc") {
+				t.Fatalf("%s lost address-PC provenance or retained old LR: %+v", text, state.regs["R27"])
+			}
+			literal := arm64ImmediateTestInstruction(t, op+" -8192(R0),R1")
+			state.transfer(literal, literal.Op, false, nil)
+			if arm64ControlCount(arm64ControlLabels(state.regs["R27"])) != 0 {
+				t.Fatalf("%s literal scratch inherited base/old-R27 code", literal.Raw)
+			}
+		}
+	}
+	// The old effective address is read before materialization; the transfer
+	// data R27 is read afterwards. This is not a register-independent store.
+	ins := arm64ImmediateTestInstruction(t, "MOVD R27,65536(R27)")
+	state := &arm64ControlState{
+		regs:   map[Reg]arm64ControlValue{"R27": arm64ControlFromMap(map[string]bool{"sp:16": true})},
+		memory: make(map[string]arm64ControlValue),
+	}
+	state.transfer(ins, ins.Op, false, nil)
+	if !arm64ControlHas(state.memory["sp:65552"], "sp:65552") || !arm64ControlHas(state.regs["R27"], "sp:65552") {
+		t.Fatalf("base/data alias lost ordered address or data: %+v", state)
+	}
+}
+
+func TestARM64ScalarMemoryScratchPrivateAndNumericEffects(t *testing.T) {
+	for _, tc := range []struct {
+		text   string
+		frame  bool
+		offset int64
+	}{
+		{"MOVD 65536(R0),R1", true, 65552},
+		{"MOVD -8192(R0),R1", false, -8192},
+		{"MOVD 32768(R0),R1", true, 0}, // Encoder variants retain may-frame, not bounds.
+	} {
+		ins := arm64ImmediateTestInstruction(t, tc.text)
+		address := arm64PrivateFrameAddress{offset: 16, exact: true}
+		read := arm64PrivateFrameAddresses{"R0": address, "R27": {offset: 8, exact: true}}
+		if !tc.frame {
+			delete(read, "R0") // Literal scratch's data address is external storage.
+		}
+		raw := &arm64RawPrivateFrameState{regs: read.clone(), spills: make(map[int64]arm64PrivateFrameAddress)}
+		numeric := newARM64PrivateDataState()
+		numeric.regs["R0"] = arm64PrivateDataValue{frame: true, interval: arm64PoolInterval{16, 16}}
+		if !tc.frame {
+			delete(numeric.regs, "R0")
+		}
+		numeric.regs["R27"] = arm64PrivateDataNumber(arm64PoolInterval{7, 7})
+		numeric.comparison = arm64PrivateDataCompare{valid: true, leftReg: "R27"}
+		if !read.transfer(ins, 131072) || !raw.transfer(ins, ins, 131072) {
+			t.Fatalf("%s bounded initialized address proof failed", tc.text)
+		}
+		if _, valid := numeric.transfer(ins, 0, 131072); !valid {
+			t.Fatalf("%s numeric proof failed", tc.text)
+		}
+		for _, addresses := range []arm64PrivateFrameAddresses{read, raw.regs} {
+			value, frame := addresses.address("R27")
+			if frame != tc.frame || tc.frame && tc.offset != 0 && (!value.exact || value.offset != tc.offset) ||
+				tc.frame && tc.offset == 0 && value.exact {
+				t.Errorf("%s stale/private scratch: %+v frame=%v", tc.text, value, frame)
+			}
+		}
+		value := numeric.value("R27")
+		if value.frame != tc.frame || !tc.frame && value.interval != (arm64PoolInterval{uint64(tc.offset), uint64(tc.offset)}) ||
+			tc.frame && tc.offset != 0 && value.interval != (arm64PoolInterval{uint64(tc.offset), uint64(tc.offset)}) || numeric.comparison.valid {
+			t.Errorf("%s stale numeric scratch/comparison: %+v", tc.text, value)
+		}
+		stack := arm64StackState{0: {local: true, low: 16, high: 16}, 27: {local: true, low: 8, high: 8}}
+		if !tc.frame {
+			stack[0] = arm64StackRange{}
+		}
+		if err := arm64StackStep(&stack, ins, ins); err != nil {
+			t.Fatal(err)
+		}
+		if stack[27].local != tc.frame || tc.frame && tc.offset != 0 && stack[27].low != tc.offset ||
+			tc.frame && tc.offset == 0 && !stack[27].unknown {
+			t.Errorf("%s stale stack interval: %+v", tc.text, stack[27])
+		}
+	}
+}
+
+func TestARM64ScalarMemoryCoarsePrivateFrameStoreBoundary(t *testing.T) {
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, tc := range []struct {
+			operands string
+			accepted bool
+		}{
+			{"R11,8(RSP)", true}, // Original source-relative store policy.
+			{"R11,(R9)", false},  // Derived GP stores require the DATA proof.
+			{"R9,8(RSP)", false}, // An SP-relative store cannot spill a frame pointer.
+			{"(R9),R11", true},   // The original bounded read remains supported.
+			{".P R11,8(RSP)", false},
+			{"R11,(RSP)(R7)", false},
+		} {
+			text := op + " " + tc.operands
+			if strings.HasPrefix(tc.operands, ".") {
+				text = op + tc.operands
+			}
+			ins := arm64ImmediateTestInstruction(t, text)
+			state := arm64PrivateFrameAddresses{"R9": {offset: 8, exact: true}}
+			if got := state.transfer(ins, 32); got != tc.accepted {
+				t.Errorf("%s coarse source-only boundary = %v, want %v", text, got, tc.accepted)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemorySourceScratchAvailability(t *testing.T) {
+	for _, tail := range []struct {
+		text  string
+		valid bool
+	}{
+		{"MOVD R1,ret+8(FP)\nRET", true},
+		{"MOVD $19,R27\nMOVD R27,ret+8(FP)\nRET", true},
+		{"MOVD R27,ret+8(FP)\nRET", false},
+		{"MOVD R27,R5\nMOVD R5,ret+8(FP)\nRET", false},
+		{"CBZ R1,join\nMOVD $19,R27\njoin:\nMOVD R27,ret+8(FP)\nRET", false},
+		{"CBZ R1,other\nMOVD $19,R27\nB join\nother:\nMOVD $20,R27\njoin:\nMOVD R27,ret+8(FP)\nRET", true},
+	} {
+		for _, move := range []struct {
+			text    string
+			unknown bool
+		}{
+			{"MOVD 32768(R0),R1", true},
+			{"MOVD -257(R0),R1", true},
+			{"MOVD 32769(R0),R1", true},
+			// Both primary encoders load this exact literal into R27.
+			{"MOVD 65537(R0),R1", false},
+		} {
+			source := "TEXT ·Scratch(SB),4,$0-16\nMOVD input+0(FP),R0\n" + move.text + "\n" + tail.text + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "test/memory", "package memory\nfunc Scratch(input *[131072]byte) uint64\n")
+			resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+			sizes := types.SizesFor("gc", "arm64")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+				check := func(api string, err error) {
+					valid := tail.valid || !move.unknown
+					if valid && err != nil || !valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %s %s tail %q: %v", api, target, move.text, tail.text, err)
+					}
+				}
+				_, err = Translate(file, options)
+				check("Translate", err)
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if err == nil {
+					module.Dispose()
+				}
+				check("Module", err)
+				result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+				if err == nil {
+					result.Module.Dispose()
+				}
+				ctx.Dispose()
+				check("GoModule", err)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemoryDecoderOriginIsPrivate(t *testing.T) {
+	source := arm64ImmediateTestInstruction(t, "MOVD 65536(R0),R1")
+	source.Raw = "WORD $0xf9400001"
+	bytes, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var decodedJSON Instr
+	if err := json.Unmarshal(bytes, &decodedJSON); err != nil {
+		t.Fatal(err)
+	}
+	for _, ins := range []Instr{source, decodedJSON} {
+		form, handled, err := parseARM64ScalarMemoryForm(ins.Op, ins)
+		if !handled || err != nil || !form.scratch || ins.arm64Encoded {
+			t.Fatalf("public/Raw text asserted physical decoder identity: %+v %v", form, err)
+		}
+	}
+	raw := arm64ImmediateTestInstruction(t, "WORD $0xf9400361")
+	physical, err := decodeARM64RawWordInstruction(raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	form, handled, err := parseARM64ScalarMemoryForm(physical.Op, physical)
+	if !handled || err != nil || form.scratch || !physical.arm64Encoded {
+		t.Fatalf("genuine physical LDR acquired Go R27 expansion: %+v %v", form, err)
+	}
+	if _, handled, err := parseARM64ScalarMemoryForm("MOVB", source); !handled || err == nil {
+		t.Fatal("conflicting dispatch identity acquired typed memory proof")
+	}
+	var output strings.Builder
+	ctx := &arm64Ctx{b: &output}
+	if handled, _, err := ctx.lowerARM64ScalarMemory("MOVB", source); !handled || err == nil || output.Len() != 0 {
+		t.Fatalf("invalid dispatch emitted IR: %s %v", output.String(), err)
+	}
+	t.Logf("decoder-only raw %s remains one physical instruction", fmt.Sprint(raw.Args))
+}
+
+func TestARM64ScalarMemoryFrameClassRequiresSourceIdentity(t *testing.T) {
+	for _, text := range []string{"MOVD local+0(SP),R1", "MOVD R1,local+0(SP)"} {
+		ins := arm64ImmediateTestInstruction(t, text)
+		if _, err := normalizeARM64ScalarMemoryFrame(Func{FrameSize: 32, Instrs: []Instr{ins}}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("AUTO acquired a frame from its size alone: %s: %v", text, err)
+		}
+		file, err := Parse(ArchARM64, "TEXT frame(SB),UNRESOLVED_FLAGS,$32-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0]); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unknown NOFRAME membership supplied AUTO identity: %s: %v", text, err)
+		}
+	}
+	for _, text := range []string{"MOVD.P local+0(SP),R1", "MOVD R1,local+0(SP)(R2)"} {
+		file, err := Parse(ArchARM64, "TEXT frame(SB),4,$32-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0]); err == nil {
+			t.Fatalf("normalization erased a Go-invalid AUTO role: %s", text)
+		}
+		if _, known := arm64RawKnownSourceWidth(file.Funcs[0], file.Funcs[0].Instrs[1]); known {
+			t.Fatalf("raw-PC width erased a Go-invalid AUTO role: %s", text)
+		}
+	}
+	for _, text := range []string{"MOVD (R0),R1", "MOVD R1,255(R0)"} {
+		ins := arm64ImmediateTestInstruction(t, text)
+		if width, known := arm64RawKnownSourceWidth(Func{}, ins); !known || width != 4 {
+			t.Fatalf("non-frame direct form acquired a new frame requirement: %s", text)
+		}
+	}
+}
+
+func TestARM64ScalarMemoryRejectsOriginalGoInvalidFormats(t *testing.T) {
+	for _, instruction := range arm64MemoryAuditRejectedForms() {
+		file, err := Parse(ArchARM64, "TEXT rejected(SB),4,$0-0\n"+instruction+"\nRET\n")
+		if err != nil {
+			continue // A parser rejection is not a successfully lowered format.
+		}
+		normalized, err := normalizeARM64ScalarMemoryFrame(file.Funcs[0])
+		if err != nil {
+			continue
+		}
+		ins := normalized.Instrs[1]
+		if _, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins); !handled || err == nil {
+			t.Errorf("original Go-rejected memory form acquired a typed grammar: %s: handled=%v error=%v", instruction, handled, err)
+		}
+	}
+}
+
+func arm64ScalarMemoryCheckPublicAPIs(t *testing.T, source, declaration, target string, valid bool) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "test/memory", "package memory\n"+declaration)
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	check := func(api string, err error) {
+		if valid && err != nil || !valid && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("%s %s valid=%v: %v\n%s", api, target, valid, err, source)
+		}
+	}
+	options := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	_, err = Translate(file, options)
+	check("Translate", err)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if err == nil {
+		module.Dispose()
+	}
+	check("Module", err)
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+	if err == nil {
+		bound.Module.Dispose()
+	}
+	check("GoModule", err)
+}
+
+func TestARM64ScalarMemoryPhysicalSourceRoles(t *testing.T) {
+	const data = "GLOBL payload(SB),8,$16\nDATA payload+0(SB)/8,$17\nDATA payload+8(SB)/8,$19\n"
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, move := range []string{op + " payload(SB),R1", op + " R1,payload(SB)"} {
+			for _, readScratch := range []bool{false, true} {
+				tail := "RET\n"
+				if readScratch {
+					tail = "MOVD R27,R30\nRET\n"
+				}
+				source := "TEXT ·Scratch(SB),4,$0-0\nMOVD $17,R1\nMOVD R30,R27\n" + move + "\n" + tail + data
+				requireARM64GoAssemblerResult(t, source, true) // Object only: corrupt LR is never executed.
+				for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+					arm64ScalarMemoryCheckPublicAPIs(t, source, "func Scratch()\n", target, !readScratch)
+				}
+			}
+		}
+	}
+	for _, readScratch := range []bool{false, true} {
+		move := ""
+		if readScratch {
+			move = "MOVD R27,R0\n" // This missing value reaches the actual result.
+		}
+		source := "TEXT ·Scratch(SB),4,$65536-16\nMOVD input+0(FP),R0\n" + move + "MOVD R0,ret+8(FP)\nRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+			arm64ScalarMemoryCheckPublicAPIs(t, source, "func Scratch(input uint64) uint64\n", target, !readScratch)
+		}
+	}
+}
diff --git a/arm64_scalar_memory_runtime_test.go b/arm64_scalar_memory_runtime_test.go
new file mode 100644
index 000000000..a09bdb1a6
--- /dev/null
+++ b/arm64_scalar_memory_runtime_test.go
@@ -0,0 +1,323 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type arm64ScalarMemoryCase struct {
+	op, suffix, index  string
+	bits               int
+	offset, indexValue int64
+	scale              int64
+	store, signed      bool
+	base27, data27     bool
+	scratchKind        int // Independent oracle: 0 preserved, 1 base+hi, 2 literal.
+	scratchValue       int64
+}
+
+func arm64ScalarMemoryCases() []arm64ScalarMemoryCase {
+	var cases []arm64ScalarMemoryCase
+	for i, op := range arm64MemoryScratchAuditMoves {
+		bits := 8 << (i / 2)
+		if op == "MOVD" {
+			bits = 64
+		}
+		for _, store := range []bool{false, true} {
+			base := arm64ScalarMemoryCase{op: op, bits: bits, signed: i%2 == 0 && bits < 64, store: store, scale: 1}
+			for _, offset := range []int64{-256, -1, 0, 255, 4095 * int64(bits/8), 65536, -8192} {
+				tc := base
+				tc.offset = offset
+				if offset == 65536 {
+					tc.scratchKind, tc.scratchValue = 1, 65536
+				} else if offset == -8192 {
+					tc.scratchKind, tc.scratchValue = 2, -8192
+				}
+				cases = append(cases, tc)
+			}
+			if op == "MOVD" {
+				tc := base
+				tc.offset, tc.scratchKind, tc.scratchValue = 65537, 2, 65537
+				cases = append(cases, tc)
+			}
+			for _, suffix := range []string{".P", ".W"} {
+				for _, offset := range []int64{-256, 0, 255} {
+					tc := base
+					tc.suffix, tc.offset = suffix, offset
+					cases = append(cases, tc)
+				}
+			}
+			for _, index := range []struct {
+				text  string
+				value int64
+				scale int64
+			}{
+				{"R2", 3, 1},
+				{fmt.Sprintf("R2<<%d", i/2), 3, int64(bits / 8)},
+				{"R2.SXTW<<0", -3, 1},
+				{fmt.Sprintf("R2.UXTW<<%d", i/2), 0x100000003, int64(bits / 8)},
+				{fmt.Sprintf("R2.SXTX<<%d", i/2), -3, int64(bits / 8)},
+			} {
+				tc := base
+				tc.index, tc.indexValue, tc.scale = index.text, index.value, index.scale
+				cases = append(cases, tc)
+			}
+			for _, aliases := range [][2]bool{{true, false}, {false, true}, {true, true}} {
+				tc := base
+				tc.base27, tc.data27 = aliases[0], aliases[1]
+				tc.offset, tc.scratchKind, tc.scratchValue = 65536, 1, 65536
+				cases = append(cases, tc)
+			}
+		}
+	}
+	return cases
+}
+
+func arm64ScalarMemoryFixture() (source, declaration string, cases []arm64ScalarMemoryCase) {
+	cases = arm64ScalarMemoryCases()
+	var assembly, goDecl strings.Builder
+	for i, tc := range cases {
+		name := fmt.Sprintf("Memory%d", i)
+		fmt.Fprintf(&goDecl, "func %s(input *[262144]byte, output *[4]uint64)\n", name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-16\n", name)
+		assembly.WriteString("MOVD input+0(FP),R0\nMOVD output+8(FP),R11\nADD $65536,R0\nMOVD R0,R9\nMOVD $107,R27\nMOVD $0x10203040aa80feff,R1\n")
+		base, data := "R0", "R1"
+		if tc.base27 {
+			base = "R27"
+			assembly.WriteString("MOVD R0,R27\n")
+		}
+		if tc.data27 {
+			data = "R27"
+		}
+		fmt.Fprintf(&assembly, "MOVD $%d,R2\n", tc.indexValue)
+		assembly.WriteString("MOVD $255,R6\nMOVD $1,R7\nCMP R7,R6\n")
+		memory := fmt.Sprintf("%d(%s)", tc.offset, base)
+		if tc.index != "" {
+			memory = fmt.Sprintf("(%s)(%s)", base, tc.index)
+		}
+		if tc.store {
+			fmt.Fprintf(&assembly, "%s%s %s,%s\n", tc.op, tc.suffix, data, memory)
+		} else {
+			fmt.Fprintf(&assembly, "%s%s %s,%s\n", tc.op, tc.suffix, memory, data)
+		}
+		fmt.Fprintf(&assembly, "MOVD %s,(R11)\n", data)
+		if tc.scratchKind == 1 && (!tc.data27 || tc.store) || tc.scratchKind == 0 && tc.base27 {
+			assembly.WriteString("SUB R9,R27,R5\nMOVD R5,8(R11)\n")
+		} else {
+			assembly.WriteString("MOVD R27,8(R11)\n")
+		}
+		fmt.Fprintf(&assembly, "SUB R9,%s,R5\nMOVD R5,16(R11)\n", base)
+		assembly.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET HS,R4\nCSET VS,R5\nLSL $1,R3\nLSL $2,R4\nLSL $3,R5\nORR R3,R2\nORR R4,R2\nORR R5,R2\nMOVD R2,24(R11)\nRET\n")
+	}
+	return assembly.String(), goDecl.String(), cases
+}
+
+func arm64ScalarMemoryIRs(t *testing.T, source, declaration, target string) []string {
+	t.Helper()
+	pkg := mustGoPackage(t, "test/memory", "package memory\n"+declaration)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	ir, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	moduleIR := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+	if err != nil {
+		t.Fatal(err)
+	}
+	boundIR := bound.Module.String()
+	bound.Module.Dispose()
+	return []string{ir, moduleIR, boundIR}
+}
+
+func arm64ScalarMemoryPrograms(declaration string, cases []arm64ScalarMemoryCase) (string, string) {
+	boolInt := func(value bool) int {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	var goCases, cDecl, cCases strings.Builder
+	for i, tc := range cases {
+		index := tc.indexValue
+		if strings.Contains(tc.index, "UXTW") {
+			index = int64(uint32(index))
+		}
+		effective := tc.offset + index*tc.scale
+		if tc.suffix == ".P" {
+			effective = 0
+		}
+		fmt.Fprintf(&goCases, "{Memory%d,%d,%t,%t,%t,%t,%d,%d,%d,%d,%t},\n", i, tc.bits, tc.signed, tc.store, tc.base27, tc.data27, effective, tc.offset, tc.scratchKind, tc.scratchValue, tc.suffix != "")
+		fmt.Fprintf(&cDecl, "extern void Memory%d(uint8_t *,uint64_t *);\n", i)
+		fmt.Fprintf(&cCases, "{Memory%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d},\n", i, tc.bits, boolInt(tc.signed), boolInt(tc.store), boolInt(tc.base27), boolInt(tc.data27), effective, tc.offset, tc.scratchKind, tc.scratchValue, boolInt(tc.suffix != ""))
+	}
+	goProgram := `package main
+import (
+    "fmt"
+    "unsafe"
+)
+` + declaration + `
+type memoryCase struct {
+    fn func(*[262144]byte,*[4]uint64)
+    bits int
+    signed,store,base27,data27 bool
+    effective,offset int64
+    scratch int
+    scratchValue int64
+    writeback bool
+}
+func initialByte(i int) byte { return byte(i*73+128) }
+func main() {
+    cases := []memoryCase{
+` + goCases.String() + `
+    }
+    storage := new([262160]byte)
+    input := (*[262144]byte)(unsafe.Pointer(&storage[8]))
+    for number,tc := range cases {
+        for i := range storage { storage[i]=0xa7 }
+        for i := range input { input[i]=initialByte(i) }
+        output := struct { left uint64; values [4]uint64; right uint64 }{left:0x1234,right:0x5678}
+        base := uint64(uintptr(unsafe.Pointer(&input[65536])))
+        data := uint64(0x10203040aa80feff)
+        scratch := uint64(107)
+        if tc.base27 { scratch=base }
+        if tc.scratch==1 { scratch=base+uint64(tc.scratchValue) }
+        if tc.scratch==2 { scratch=uint64(tc.scratchValue) }
+        if tc.data27 && tc.store { data=scratch }
+        at := 65536+int(tc.effective)
+        if !tc.store {
+            data=0
+            for j:=0;j<tc.bits/8;j++ { data|=uint64(input[at+j])<<uint(j*8) }
+            if tc.signed && data&(uint64(1)<<uint(tc.bits-1))!=0 { data|=^uint64(0)<<uint(tc.bits) }
+            if tc.data27 { scratch=data }
+        }
+        baseAfter := base
+        if tc.base27 { baseAfter=scratch }
+        if tc.writeback { baseAfter+=uint64(tc.offset) }
+        observedScratch := scratch
+        if tc.scratch==1 && (!tc.data27 || tc.store) || tc.scratch==0 && tc.base27 { observedScratch-=base }
+        expected := [4]uint64{data,observedScratch,baseAfter-base,4}
+        tc.fn(input,&output.values)
+        if output.values!=expected { panic(fmt.Sprintf("Go case %d got %x want %x",number,output.values,expected)) }
+        for i,value := range input {
+            want:=initialByte(i)
+            if tc.store && i>=at && i<at+tc.bits/8 { want=byte(data>>uint((i-at)*8)) }
+            if value!=want { panic(fmt.Sprintf("Go case %d input byte %d",number,i)) }
+        }
+        for i:=0;i<8;i++ { if storage[i]!=0xa7 || storage[262152+i]!=0xa7 { panic("Go input canary") } }
+        if output.left!=0x1234 || output.right!=0x5678 { panic("Go output canary") }
+    }
+}
+`
+	cProgram := `#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+` + cDecl.String() + `
+struct memory_case {
+    void (*fn)(uint8_t *,uint64_t *);
+    unsigned bits,signed_load,store,base27,data27;
+    int64_t effective,offset;
+    unsigned scratch;
+    int64_t scratch_value;
+    unsigned writeback;
+};
+static uint8_t initial_byte(unsigned i) { return (uint8_t)(i*73+128); }
+int main(void) {
+    const struct memory_case cases[]={
+` + cCases.String() + `
+    };
+    uint8_t *storage=malloc(262160);
+    if (!storage) return 90;
+    uint8_t *input=storage+8;
+    for (unsigned number=0;number<sizeof(cases)/sizeof(cases[0]);number++) {
+        struct memory_case tc=cases[number];
+        memset(storage,0xa7,262160);
+        for (unsigned i=0;i<262144;i++) input[i]=initial_byte(i);
+        struct { uint64_t left,values[4],right; } output={.left=0x1234,.right=0x5678};
+        uint64_t base=(uintptr_t)(input+65536),data=UINT64_C(0x10203040aa80feff),scratch=107;
+        if (tc.base27) scratch=base;
+        if (tc.scratch==1) scratch=base+(uint64_t)tc.scratch_value;
+        if (tc.scratch==2) scratch=(uint64_t)tc.scratch_value;
+        if (tc.data27 && tc.store) data=scratch;
+        unsigned at=(unsigned)(65536+tc.effective);
+        if (!tc.store) {
+            data=0;
+            for (unsigned j=0;j<tc.bits/8;j++) data|=(uint64_t)input[at+j]<<(j*8);
+            if (tc.signed_load && (data&(UINT64_C(1)<<(tc.bits-1)))) data|=UINT64_MAX<<tc.bits;
+            if (tc.data27) scratch=data;
+        }
+        uint64_t base_after=tc.base27 ? scratch : base;
+        if (tc.writeback) base_after+=(uint64_t)tc.offset;
+        uint64_t observed_scratch=scratch;
+        if ((tc.scratch==1 && (!tc.data27 || tc.store)) || (tc.scratch==0 && tc.base27)) observed_scratch-=base;
+        const uint64_t expected[]={data,observed_scratch,base_after-base,4};
+        tc.fn(input,output.values);
+        for (unsigned i=0;i<4;i++) {
+            if (output.values[i]!=expected[i]) {
+                fprintf(stderr,"LLVM case %u field %u got %#llx want %#llx\n",number,i,(unsigned long long)output.values[i],(unsigned long long)expected[i]);
+                free(storage);
+                return 1;
+            }
+        }
+        for (unsigned i=0;i<262144;i++) {
+            uint8_t want=initial_byte(i);
+            if (tc.store && i>=at && i<at+tc.bits/8) want=(uint8_t)(data>>((i-at)*8));
+            if (input[i]!=want) { fprintf(stderr,"LLVM case %u input byte %u\n",number,i); free(storage); return 2; }
+        }
+        for (unsigned i=0;i<8;i++) if (storage[i]!=0xa7 || storage[262152+i]!=0xa7) { free(storage); return 3; }
+        if (output.left!=0x1234 || output.right!=0x5678) { free(storage); return 4; }
+    }
+    free(storage);
+    return 0;
+}
+`
+	return goProgram, cProgram
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMemoryComplete(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	source, declaration, cases := arm64ScalarMemoryFixture()
+	goProgram, cProgram := arm64ScalarMemoryPrograms(declaration, cases)
+	runARM64LocalRegisterGoOracle(t, source, goProgram, len(runner) != 0, "1.20")
+	for api, ir := range arm64ScalarMemoryIRs(t, source, declaration, target) {
+		compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("scalar-memory-complete-%d", api), target, ir, cProgram, runner)
+	}
+	t.Logf("%d initialized original Go / three API LLVM cases, full input/output canaries and NZCV", len(cases))
+}
+
+func TestARM64ScalarMemoryCompleteLLVM22Objects(t *testing.T) {
+	source, declaration, cases := arm64ScalarMemoryFixture()
+	requireARM64GoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc unavailable")
+	}
+	for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		for api, ir := range arm64ScalarMemoryIRs(t, source, declaration, target) {
+			compileLLVMToObject(t, llc, target, fmt.Sprintf("scalar-memory-%d.ll", api), fmt.Sprintf("scalar-memory-%d.o", api), ir)
+		}
+	}
+	t.Logf("%d original Go-accepted scalar-memory cases × 3 APIs × 5 object targets", len(cases))
+}
diff --git a/arm64_scalar_memory_scratch_audit_test.go b/arm64_scalar_memory_scratch_audit_test.go
new file mode 100644
index 000000000..ebec70143
--- /dev/null
+++ b/arm64_scalar_memory_scratch_audit_test.go
@@ -0,0 +1,355 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"go/types"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var arm64MemoryScratchAuditMoves = []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"}
+
+func arm64MemoryScratchAuditSource() string {
+	var source strings.Builder
+	source.WriteString("TEXT ·DivideRem(SB),4,$0-16\nMOVD input+0(FP),R0\nMOVD output+8(FP),R11\n")
+	for direction := 0; direction < 2; direction++ {
+		for _, op := range arm64MemoryScratchAuditMoves {
+			source.WriteString("MOVD $107,R27\nMOVD $255,R6\nMOVD $1,R7\nCMP R7,R6\n")
+			if direction == 0 {
+				fmt.Fprintf(&source, "%s 65536(R0),R1\n", op)
+			} else {
+				source.WriteString("MOVD $0x10203040aa80feff,R1\n")
+				fmt.Fprintf(&source, "%s R1,65536(R0)\n", op)
+			}
+			source.WriteString("MOVD R1,(R11)\nSUB R0,R27,R5\nMOVD R5,8(R11)\n")
+			source.WriteString("CSET MI,R2\nCSET EQ,R3\nCSET HS,R4\nCSET VS,R5\nLSL $1,R3\nLSL $2,R4\nLSL $3,R5\nORR R3,R2\nORR R4,R2\nORR R5,R2\nMOVD R2,16(R11)\nADD $24,R11\n")
+		}
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func arm64MemoryScratchAuditPrograms() (string, string) {
+	const count = 42
+	goSource := fmt.Sprintf(`package main
+import (
+    "fmt"
+    "unsafe"
+)
+func DivideRem(input *[131072]byte, output *[%d]uint64)
+func initialByte(index int) byte { return byte(index*73+128) }
+func main() {
+    storage := new([131088]byte)
+    for i := range storage { storage[i] = 0xa7 }
+    input := (*[131072]byte)(unsafe.Pointer(&storage[8]))
+    for i := range input { input[i] = initialByte(i) }
+    output := struct { left uint64; values [%d]uint64; right uint64 }{left:0x1234,right:0x5678}
+    DivideRem(input,&output.values)
+    widths := [...]uint{8,8,16,16,32,32,64}
+    for i, width := range widths {
+        value := uint64(0)
+        for j := uint(0); j < width/8; j++ { value |= uint64(initialByte(65536+int(j))) << (j*8) }
+        if i%%2 == 0 && width < 64 && value&(uint64(1)<<(width-1)) != 0 { value |= ^uint64(0) << width }
+        if got := output.values[i*3]; got != value { panic(fmt.Sprintf("original Go load %%d got %%#x want %%#x",i,got,value)) }
+        if got := output.values[(i+7)*3]; got != 0x10203040aa80feff { panic(fmt.Sprintf("original Go store %%d source changed: %%#x",i,got)) }
+    }
+    for i := 0; i < 14; i++ {
+        if output.values[i*3+1] != 65536 || output.values[i*3+2] != 4 { panic(fmt.Sprintf("original Go case %%d R27/NZCV got %%x",i,output.values[i*3:i*3+3])) }
+    }
+    for i, value := range input {
+        want := initialByte(i)
+        if i >= 65536 && i < 65544 { want = byte(uint64(0x10203040aa80feff) >> (uint(i-65536)*8)) }
+        if value != want { panic(fmt.Sprintf("original Go input byte %%d got %%x want %%x",i,value,want)) }
+    }
+    for i := 0; i < 8; i++ {
+        if storage[i] != 0xa7 || storage[131080+i] != 0xa7 { panic("original Go input canary") }
+    }
+    if output.left != 0x1234 || output.right != 0x5678 { panic("original Go output canary") }
+}
+`, count, count)
+	cSource := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+extern void DivideRem(uint8_t *,uint64_t *);
+static uint8_t initial_byte(unsigned index) { return (uint8_t)(index*73+128); }
+int main(void) {
+    uint8_t *storage=malloc(131088);
+    if (!storage) return 90;
+    memset(storage,0xa7,131088);
+    uint8_t *input=storage+8;
+    for (unsigned i=0;i<131072;i++) input[i]=initial_byte(i);
+    struct { uint64_t left,values[%d],right; } output={.left=0x1234,.right=0x5678};
+    DivideRem(input,output.values);
+    unsigned failed=0;
+    const unsigned widths[]={8,8,16,16,32,32,64};
+    for (unsigned i=0;i<7;i++) {
+        unsigned width=widths[i];
+        uint64_t value=0;
+        for (unsigned j=0;j<width/8;j++) value|=(uint64_t)initial_byte(65536+j)<<(j*8);
+        if (!(i%%2) && width<64 && (value&(UINT64_C(1)<<(width-1)))) value|=UINT64_MAX<<width;
+        if (output.values[i*3]!=value || output.values[(i+7)*3]!=UINT64_C(0x10203040aa80feff)) {
+            fprintf(stderr,"LLVM case %%u data mismatch\n",i);
+            failed++;
+        }
+    }
+    for (unsigned i=0;i<14;i++) {
+        if (output.values[i*3+1]!=65536 || output.values[i*3+2]!=4) {
+            fprintf(stderr,"LLVM case %%u R27 delta %%#llx NZCV %%llu; want 0x10000 / 4\n",i,(unsigned long long)output.values[i*3+1],(unsigned long long)output.values[i*3+2]);
+            failed++;
+        }
+    }
+    for (unsigned i=0;i<131072;i++) {
+        uint8_t want=initial_byte(i);
+        if (i>=65536 && i<65544) want=(uint8_t)(UINT64_C(0x10203040aa80feff)>>((i-65536)*8));
+        if (input[i]!=want) { fprintf(stderr,"LLVM input byte %%u mismatch\n",i); failed++; break; }
+    }
+    for (unsigned i=0;i<8;i++) if (storage[i]!=0xa7 || storage[131080+i]!=0xa7) failed++;
+    if (output.left!=0x1234 || output.right!=0x5678) failed++;
+    free(storage);
+    return failed ? 1 : 0;
+}
+`, count)
+	return goSource, cSource
+}
+
+func arm64MemoryScratchAuditIRs(t *testing.T, source, target string) []string {
+	t.Helper()
+	// Match the actual standalone Go oracle's pointer types, not an unrelated
+	// numerical fixture whose pointee only happens to have the same ABI width.
+	pkg := mustGoPackage(t, "test/memory", "package memory\nfunc DivideRem(input *[131072]byte, output *[42]uint64)\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	sizes := types.SizesFor("gc", "arm64")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+	ir, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	moduleIR := module.String()
+	module.Dispose()
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+	if err != nil {
+		t.Fatal(err)
+	}
+	boundIR := bound.Module.String()
+	bound.Module.Dispose()
+	return []string{ir, moduleIR, boundIR}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMemoryScratchAudit(t *testing.T) {
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := arm64MemoryScratchAuditSource()
+	goSource, cSource := arm64MemoryScratchAuditPrograms()
+	runARM64LocalRegisterGoOracle(t, source, goSource, len(runner) != 0, "1.20")
+	for api, ir := range arm64MemoryScratchAuditIRs(t, source, target) {
+		t.Run(fmt.Sprintf("API%d", api), func(t *testing.T) {
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, fmt.Sprintf("memory-scratch-%d", api), target, ir, cSource, runner)
+		})
+	}
+}
+
+func TestARM64ScalarMemoryScratchAuditSavedCaller(t *testing.T) {
+	pkg := mustGoPackage(t, "test/memory", "package memory\nfunc Scratch(input *[131072]byte)\n")
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	for _, op := range arm64MemoryScratchAuditMoves {
+		for _, instruction := range []string{op + " 65536(R0),R1", op + " R1,65536(R0)"} {
+			source := "TEXT ·Scratch(SB),4,$0-8\nMOVD input+0(FP),R0\nMOVD $17,R1\nMOVD R30,R27\n" + instruction + "\nMOVD R27,R30\nRET\n"
+			requireARM64GoAssemblerResult(t, source, true) // Compile only: deliberately corrupted continuation.
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", "arm64")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+				opt := Options{Goarch: "arm64", TargetTriple: target, ResolveSym: resolve, Sigs: sigs}
+				if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s %s stale caller LR accepted by Translate: %v", target, instruction, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s %s stale caller LR accepted by Module: %v", target, instruction, err)
+				}
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: resolve})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s %s stale caller LR accepted by GoModule: %v", target, instruction, err)
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemoryScratchAuditRawPCWidth(t *testing.T) {
+	for _, text := range []string{"MOVD 65536(R0),R1", "MOVD R1,65536(R0)", "MOVD slot+65536(FP),R1"} {
+		ins := arm64ImmediateTestInstruction(t, text)
+		if width, known := arm64RawKnownSourceWidth(Func{}, ins); known {
+			t.Errorf("long source memory pseudo acquired guessed physical width %d: %s", width, text)
+		}
+		// The raw ADR reaches the second instruction inside Go's expansion,
+		// not the next source RET. Its original bytes are accepted, but there
+		// is no source label at that physical PC for the current normalizer.
+		source := "TEXT uncertain(SB),4,$0-0\nWORD $0x10000040\n" + text + "\ntarget:\nRET\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := normalizeARM64RawPCRelative(file.Funcs[0]); err == nil {
+			t.Errorf("raw ADR acquired a false source RET label across long memory pseudo: %s", text)
+		}
+	}
+	decoded, err := decodeARM64RawWordInstruction(arm64ImmediateTestInstruction(t, "WORD $0xf9400361"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if width, known := arm64RawKnownSourceWidth(Func{}, decoded); !known || width != 4 {
+		t.Fatal("physical one-WORD load lost exact four-byte width")
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMemoryOriginalGoEncoderState(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	goos := runtime.GOOS
+	if len(runner) != 0 {
+		goos = "linux"
+	}
+	positive := arm64ImmediateOriginalGoBytes(t, "TEXT encoder(SB),4,$0-0\nMOVD 32768(R0),R1\nRET\n", goos)
+	if len(positive) < 12 {
+		t.Fatal("missing positive original Go expansion")
+	}
+	first := binary.LittleEndian.Uint32(positive)
+	var high uint64
+	switch first {
+	case 0x9100201b: // ADD $8,R0,R27, followed by LDR #4095*8.
+		high = 8
+	case 0x9140201b: // ADD $32768,R0,R27, followed by LDR #0.
+		high = 32768
+	default:
+		t.Fatalf("unknown actual original Go expansion: %x", positive)
+	}
+	negative := arm64ImmediateOriginalGoBytes(t, "TEXT encoder(SB),4,$0-0\nMOVD -257(R0),R1\nRET\n", goos)
+	if len(negative) < 12 {
+		t.Fatal("missing negative original Go expansion")
+	}
+	first = binary.LittleEndian.Uint32(negative)
+	address := first == 0xd104041b // SUB $257,R0,R27.
+	if !address && first&0xff00001f != 0x5800001b {
+		t.Fatalf("unknown actual original Go pool expansion: %x", negative)
+	}
+	unaligned := arm64ImmediateOriginalGoBytes(t, "TEXT encoder(SB),4,$0-0\nMOVD 32769(R0),R1\nRET\n", goos)
+	if len(unaligned) < 12 {
+		t.Fatal("missing unaligned original Go expansion")
+	}
+	first = binary.LittleEndian.Uint32(unaligned)
+	unalignedAddress := first == 0x9100241b // ADD $9,R0,R27.
+	if !unalignedAddress && first&0xff00001f != 0x1800001b {
+		t.Fatalf("unknown actual original Go unaligned expansion: %x", unaligned)
+	}
+	literal := arm64ImmediateOriginalGoBytes(t, "TEXT encoder(SB),4,$0-0\nMOVD 65537(R0),R1\nRET\n", goos)
+	if len(literal) < 12 || binary.LittleEndian.Uint32(literal)&0xff00001f != 0x1800001b {
+		t.Fatalf("65537 is not the independently accepted literal expansion: %x", literal)
+	}
+	source := `TEXT ·EncoderState(SB),4,$0-16
+MOVD input+0(FP),R0
+MOVD output+8(FP),R11
+MOVD $255,R6
+MOVD $1,R7
+CMP R7,R6
+MOVD $107,R27
+MOVD 32768(R0),R1
+SUB R0,R27,R5
+MOVD R5,(R11)
+MOVD R1,8(R11)
+MOVD $107,R27
+MOVD -257(R0),R1
+MOVD R27,16(R11)
+MOVD R1,24(R11)
+MOVD $107,R27
+MOVD -8192(R0),R1
+MOVD R27,32(R11)
+MOVD R1,40(R11)
+MOVD 32769(R0),R1
+MOVD R27,48(R11)
+MOVD R1,56(R11)
+MOVD 65537(R0),R1
+MOVD R27,64(R11)
+MOVD R1,72(R11)
+CSET MI,R2
+CSET EQ,R3
+CSET HS,R4
+CSET VS,R5
+LSL $1,R3
+LSL $2,R4
+LSL $3,R5
+ORR R3,R2
+ORR R4,R2
+ORR R5,R2
+MOVD R2,80(R11)
+RET
+`
+	program := fmt.Sprintf(`package main
+import "unsafe"
+func EncoderState(input *[131072]byte, output *[11]uint64)
+func pattern(index int) byte { return byte(index*73+128) }
+func main() {
+    storage := new([262144]byte)
+    for index := range storage { storage[index] = pattern(index) }
+    input := (*[131072]byte)(unsafe.Pointer(&storage[65536]))
+    output := struct { left uint64; values [11]uint64; right uint64 }{left:0x1234,right:0x5678}
+    EncoderState(input,&output.values)
+    if output.left != 0x1234 || output.right != 0x5678 { panic("Go encoder output canary") }
+    if output.values[0] != %d || output.values[4] != uint64(0xffffffffffffe000) || output.values[8] != 65537 || output.values[10] != 4 {
+        panic("Go encoder R27 high/pool/NZCV")
+    }
+    wantNegative := uint64(0xfffffffffffffeff)
+    if %v { wantNegative = uint64(uintptr(unsafe.Pointer(input))) - 257 }
+    if output.values[2] != wantNegative { panic("Go encoder negative R27 category") }
+    wantUnaligned := uint64(32769)
+    if %v { wantUnaligned = uint64(uintptr(unsafe.Pointer(input))) + 9 }
+    if output.values[6] != wantUnaligned { panic("Go encoder unaligned R27 category") }
+    offsets := [...]int{32768,-257,-8192,32769,65537}
+    for index, offset := range offsets {
+        value := uint64(0)
+        for byteIndex := 0; byteIndex < 8; byteIndex++ {
+            value |= uint64(pattern(65536+offset+byteIndex)) << (uint(byteIndex)*8)
+        }
+        if output.values[index*2+1] != value { panic("Go encoder initialized load") }
+    }
+    for index, value := range storage {
+        if value != pattern(index) { panic("Go encoder input canary/data changed") }
+    }
+}
+`, high, address, unalignedAddress)
+	runARM64LocalRegisterGoOracle(t, source, program, len(runner) != 0, "1.20")
+	t.Logf("actual original Go bytes/state: 32768 R27=base+%d (%x); -257 address=%v (%x); 32769 address=%v (%x); 65537 literal (%x); -8192 exact signed offset; initialized data/NZCV/canaries passed", high, positive, address, negative, unalignedAddress, unaligned, literal)
+}
diff --git a/arm64_scalar_memory_validation_order_test.go b/arm64_scalar_memory_validation_order_test.go
new file mode 100644
index 000000000..0de7ce122
--- /dev/null
+++ b/arm64_scalar_memory_validation_order_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarMemoryGrammarPreservesFloatingClassDiagnostic(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, literal := range []string{"0.0", "-0.0", "1.5", "-1.5"} {
+			for _, shape := range []struct{ suffix, memory string }{
+				{memory: "8(R0)"},
+				{memory: "ret+8(FP)"},
+				{memory: "storage(SB)"},
+				{suffix: ".P", memory: "8(R0)"},
+				{suffix: ".W", memory: "8(R0)"},
+			} {
+				instruction := fmt.Sprintf("%s%s $%s,%s", op, shape.suffix, literal, shape.memory)
+				t.Run(instruction, func(t *testing.T) {
+					file, err := Parse(ArchARM64, "TEXT invalid(SB),516,$0-16\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					_, handled, err := parseARM64ScalarMemoryForm(Op(op), file.Funcs[0].Instrs[1])
+					if !handled || err == nil || !strings.Contains(err.Error(), "floating immediate") {
+						t.Fatalf("typed memory grammar = (%v, %v), want the distinct floating class refusal", handled, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMemoryNonzeroImmediateStoreRejectedLikeGo(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, shape := range []struct{ suffix, memory string }{
+			{memory: "8(R0)"},
+			{memory: "ret+8(FP)"},
+			{memory: "storage(SB)"},
+			{suffix: ".P", memory: "8(R0)"},
+			{suffix: ".W", memory: "8(R0)"},
+		} {
+			instruction := fmt.Sprintf("%s%s $21,%s", op, shape.suffix, shape.memory)
+			t.Run(instruction, func(t *testing.T) {
+				source := "GLOBL storage(SB),16,$8\nTEXT invalid(SB),516,$0-16\n" + instruction + "\nRET\n"
+				requireARM64GoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, handled, err := parseARM64ScalarMemoryForm(Op(op), file.Funcs[0].Instrs[1])
+				if !handled || err == nil {
+					t.Fatalf("typed memory grammar = (%v, %v), accepted Go-invalid immediate store", handled, err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_scalar_minmax.go b/arm64_scalar_minmax.go
new file mode 100644
index 000000000..9cca2bae8
--- /dev/null
+++ b/arm64_scalar_minmax.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64ScalarMinMaxSpec struct {
+	opcode string
+	bits   int
+}
+
+var arm64ScalarMinMaxSpecs = map[Op]arm64ScalarMinMaxSpec{
+	"FMAXS": {"fmax", 32}, "FMAXD": {"fmax", 64},
+	"FMINS": {"fmin", 32}, "FMIND": {"fmin", 64},
+	"FMAXNMS": {"fmaxnm", 32}, "FMAXNMD": {"fmaxnm", 64},
+	"FMINNMS": {"fminnm", 32}, "FMINNMD": {"fminnm", 64},
+}
+
+type arm64ScalarMinMaxForm struct {
+	arm64ScalarMinMaxSpec
+	first, second, destination Reg
+}
+
+func parseARM64ScalarMinMax(op Op, instruction Instr) (arm64ScalarMinMaxForm, bool, error) {
+	spec, matched := arm64ScalarMinMaxSpecs[op]
+	if !matched {
+		return arm64ScalarMinMaxForm{}, false, nil
+	}
+	if strings.ToUpper(string(instruction.Op)) != string(op) || len(instruction.Args) != 2 && len(instruction.Args) != 3 {
+		return arm64ScalarMinMaxForm{}, true, fmt.Errorf("arm64 %s expects Fsrc,Fdst or Fsrc1,Fsrc2,Fdst and no suffix: %q", op, instruction.Raw)
+	}
+	for _, operand := range instruction.Args {
+		if operand.Kind != OpReg || !isARM64FReg(operand.Reg) {
+			return arm64ScalarMinMaxForm{}, true, fmt.Errorf("arm64 %s accepts only F registers: %q", op, instruction.Raw)
+		}
+	}
+	return arm64ScalarMinMaxForm{spec, instruction.Args[1].Reg, instruction.Args[0].Reg, instruction.Args[len(instruction.Args)-1].Reg}, true, nil
+}
+
+func arm64ScalarMinMaxOpcode(kind string) string {
+	switch kind {
+	case "maximum":
+		return "fmax"
+	case "minimum":
+		return "fmin"
+	case "maxnum":
+		return "fmaxnm"
+	case "minnum":
+		return "fminnm"
+	default:
+		return ""
+	}
+}
+
+func (c *arm64Ctx) recordARM64ScalarMinMax(form arm64ScalarMinMaxForm) func() {
+	flow := c.machineAvailability
+	if flow == nil || flow.flagsOnly || flow.suspended != 0 {
+		return func() {}
+	}
+	c.recordMachineRegister(form.first, form.bits, false)
+	c.recordMachineRegister(form.second, form.bits, false)
+	// FPCR.NEP may copy V[n]'s upper bits to V[d]. Copy their definedness,
+	// not old V[d]'s definition, without requiring unobserved upper inputs.
+	flow.blocks[flow.current].effects = append(flow.blocks[flow.current].effects,
+		arm64MachineEffect{register: arm64MachineRegister(form.destination), copyFrom: arm64MachineRegister(form.first),
+			width: 128, write: true, vectorSpan: true, source: flow.source},
+		arm64MachineEffect{register: arm64MachineRegister(form.destination), width: form.bits,
+			write: true, vectorSpan: true, source: flow.source},
+	)
+	flow.suspended++
+	return func() { flow.suspended-- }
+}
+
+func (c *arm64Ctx) lowerARM64ScalarMinMax(form arm64ScalarMinMaxForm) error {
+	if form.bits != 16 && form.bits != 32 && form.bits != 64 {
+		return fmt.Errorf("arm64 invalid scalar min/max width %d", form.bits)
+	}
+	switch form.opcode {
+	case "fmax", "fmin", "fmaxnm", "fminnm":
+	default:
+		return fmt.Errorf("arm64 invalid scalar min/max operation %q", form.opcode)
+	}
+	for _, register := range []Reg{form.first, form.second, form.destination} {
+		if !isARM64FReg(register) {
+			return fmt.Errorf("arm64 invalid scalar min/max register %q", register)
+		}
+	}
+	if !arm64ScalarConversionNativeTarget(c.targetTriple) {
+		return fmt.Errorf("%w: ARM64 scalar min/max requires an explicit native little-endian AArch64 FPCR/FPSR target", ErrProbeNeedsContext)
+	}
+	finish := c.recordARM64ScalarMinMax(form)
+	defer finish()
+	first, err := c.loadVReg(form.first)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadVReg(form.second)
+	if err != nil {
+		return err
+	}
+	modifier := arm64ScalarConversionModifier(form.bits, false)
+	operation := fmt.Sprintf("%s ${0:%s}, ${1:%s}, ${2:%s}", form.opcode, modifier, modifier, modifier)
+	result := c.newTmp()
+	// DDI0602 scalar FMIN/FMAX and numeric variants merge V[n], not V[d],
+	// under IsMerging(FPCR). Tie the full first-source carrier to the output.
+	// One native instruction preserves NaN priority, AH/FZ/DN and cumulative
+	// FPSR/traps even with a dead result. The compiler barrier orders MRS/MSR;
+	// it confers no memory permission and does not write NZCV.
+	c.emitMachineNeutralNativeIR("  %%%s = call <16 x i8> asm sideeffect %q, %q(<16 x i8> %s, <16 x i8> %s)\n",
+		result, operation, "=w,0,w,~{memory}", first, second)
+	return c.storeVReg(form.destination, "%"+result)
+}
+
+func validateARM64ScalarMinMaxTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM64 {
+		return nil
+	}
+	needsNative := false
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			_, matched, err := parseARM64ScalarMinMax(arm64ControlOp(instruction), instruction)
+			if err != nil {
+				return err
+			}
+			needsNative = needsNative || matched
+			if instruction.Op != OpWORD || len(instruction.Args) != 1 || instruction.Args[0].Kind != OpImm ||
+				instruction.Args[0].ImmRaw != "" || instruction.Args[0].ImmIsFloat {
+				continue // Unidentified WORDs keep their generic source validator.
+			}
+			word := uint32(instruction.Args[0].Imm)
+			if word&0xff20cc00 != 0x1e204800 {
+				continue
+			}
+			form, valid := decodeARM64RawScalarFloatBinary(word)
+			if !valid || arm64ScalarMinMaxOpcode(form.kind) == "" {
+				return fmt.Errorf("unsupported ARM64 scalar min/max WORD encoding %#08x: %q", word, instruction.Raw)
+			}
+			needsNative = true
+		}
+	}
+	if !needsNative {
+		return nil
+	}
+	// Unrelated files retain their existing raw/source validator. Only this
+	// native family needs the complete syntax pass before its target check.
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if err := arm64RawWordPreflightError(instruction); err != nil {
+				return err
+			}
+		}
+	}
+	if !arm64ScalarConversionNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm64" {
+		return fmt.Errorf("%w: ARM64 scalar min/max requires an explicit native little-endian AArch64 FPCR/FPSR target, got %q/%q",
+			ErrProbeNeedsContext, options.Goarch, options.TargetTriple)
+	}
+	return nil
+}
diff --git a/arm64_scalar_minmax_consumers_test.go b/arm64_scalar_minmax_consumers_test.go
new file mode 100644
index 000000000..ca79c97f8
--- /dev/null
+++ b/arm64_scalar_minmax_consumers_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarMinMaxRuntimeMatrixOwnership(t *testing.T) {
+	if len(arm64MinMaxCases()) != 20 || len(arm64MinMaxStateCases(true)) != 820 || len(arm64MinMaxStateCases(false)) != 40 {
+		t.Fatal("changed complete named/raw bank/state denominator")
+	}
+	for _, bits := range []int{16, 32, 64} {
+		if len(arm64MinMaxSamples(bits, true)) != 2 || len(arm64MinMaxSamples(bits, false)) != 324 {
+			t.Fatal("changed independent control/status/input denominator", bits)
+		}
+	}
+	const filename = "arm64_scalar_minmax_runtime_linux_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "arm64"}, {"darwin", "arm64"}, {"windows", "amd64"}, {"js", "wasm"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", filename)
+		if err != nil || selected != (target.os == "linux") {
+			t.Fatal("required min/max source-selection role changed", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxDeadNative": "arm64MinMaxDeadRuntime",
+		"arm64MinMaxLinuxFamilyRuntime":                          "arm64MinMaxStateRuntimeFamily",
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		helper, required := want[function.Name.Name]
+		if !required {
+			continue
+		}
+		calls := 0
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			if name, ok := call.Fun.(*ast.Ident); ok && name.Name == helper {
+				calls++
+				if helper == "arm64MinMaxStateRuntimeFamily" {
+					last, ok := call.Args[len(call.Args)-1].(*ast.Ident)
+					if !ok || last.Name != "true" {
+						t.Error("required Linux owner lost actual NEP/AH effect requirement")
+					}
+				}
+			}
+			return true
+		})
+		if calls != 1 {
+			t.Fatalf("required owner %s lost its exact native helper", function.Name.Name)
+		}
+		delete(want, function.Name.Name)
+	}
+	if len(want) != 0 {
+		t.Fatal("required native roots absent", want)
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") || !strings.Contains(string(workflow), "PLAN9ASM_CROSS_EXEC: '1'") {
+		t.Fatal("CI lost mandatory native min/max selection", err)
+	}
+}
diff --git a/arm64_scalar_minmax_matrix_test.go b/arm64_scalar_minmax_matrix_test.go
new file mode 100644
index 000000000..b84946ac8
--- /dev/null
+++ b/arm64_scalar_minmax_matrix_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarMinMaxCompleteGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	rows := regexp.MustCompile(`\{AFADDS,\s*C_FREG,\s*C_(NONE|FREG),\s*C_NONE,\s*C_FREG,\s*(?:C_NONE,\s*)?54,\s*4,\s*0,\s*0,\s*0\}`).FindAllString(source, -1)
+	allRows := regexp.MustCompile(`\{AFADDS,`).FindAllString(source, -1)
+	if len(rows) != 2 || len(allRows) != 2 {
+		t.Fatalf("Go's complete scalar binary optab changed: matching=%d complete=%d", len(rows), len(allRows))
+	}
+	for index, operation := range []string{"FMAX", "FMIN", "FMAXNM", "FMINNM"} {
+		for width, suffix := range []string{"S", "D"} {
+			name := operation + suffix
+			encoding := fmt.Sprintf(`case A%s:\s*(?:op =|return) FPOP2S\(0, 0, %d, %d\)`, name, width, index+4)
+			if !regexp.MustCompile(encoding).MatchString(source) || strings.Count(source, "oprangeset(A"+name+", t)") != 1 {
+				t.Fatalf("Go %s no longer has the complete case-54 alias and exact encoding", name)
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxCompleteFormatsObjects(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT minmaxFormats(SB),4,$0-0\n")
+	count := 0
+	for _, row := range arm64MinMaxCases() {
+		for bank := 0; bank < 32; bank++ {
+			for _, destination := range []int{bank, (bank + 1) % 32, (bank + 2) % 32} {
+				source.WriteString(row.instruction(bank, (bank+1)%32, destination, false) + "\n")
+				count++
+			}
+			source.WriteString(row.instruction(bank, bank, bank, row.word == 0) + "\n")
+			count++
+		}
+	}
+	source.WriteString("RET\n")
+	if count != 2560 {
+		t.Fatal("changed independent format/width/register/alias denominator", count)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	signatures := map[string]FuncSig{"minmaxFormats": {Name: "minmaxFormats", Ret: Void}}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "arm64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		for api, ir := range arm64MinMaxIRs(t, source.String(), triple, signatures) {
+			t.Run(fmt.Sprintf("%s/API%d", triple, api), func(t *testing.T) {
+				compileLLVMToObject(t, llc, triple, "minmax.ll", "minmax.o", ir)
+			})
+		}
+		pkg := mustGoPackage(t, "example.com/minmax", "package minmax\nfunc minmaxFormats()\n")
+		bound, err := TranslateGoModule(pkg, []byte(strings.ReplaceAll(source.String(), "TEXT minmaxFormats", "TEXT ·minmaxFormats")), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: triple,
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir := bound.Module.String()
+		bound.Module.Dispose()
+		if len(bound.Functions) != 1 || len(bound.Signatures) != 1 || strings.Count(ir, "asm sideeffect") != count {
+			t.Fatal("typed Go consumer lost min/max format rows")
+		}
+		compileLLVMToObject(t, llc, triple, "minmax-go.ll", "minmax-go.o", ir)
+	}
+}
+
+func TestARM64ScalarMinMaxNativeTargetAndMalformedPriority(t *testing.T) {
+	for _, row := range arm64MinMaxCases() {
+		for _, dead := range []bool{false, true} {
+			prefix := ""
+			if dead {
+				prefix = "RET\n"
+			}
+			body := prefix + row.instruction(0, 1, 31, false) + "\nRET\n"
+			for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "aarch64_be-unknown-linux-gnu"} {
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext", "TranslateGoModule"} {
+					present, err := arm64MinMaxTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\n"+body, triple)
+					if present || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %s dead=%t missing native target %q: output=%t err=%v", row.name, api, dead, triple, present, err)
+					}
+				}
+			}
+		}
+		if row.word != 0 {
+			continue
+		}
+		for _, suffix := range []string{" F0", " F0,F1,F2,F3", " R0,F1", " F0,R1", " $0.0,F1", " (R0),F1", ".P F0,F1", " F32,F1", " F0,F-1", " V0.S4,V1.S4"} {
+			invalid := row.name + suffix
+			requireARM64GoAssemblerResult(t, "TEXT invalid(SB),4,$0-0\n"+invalid+"\nRET\n", false)
+			for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext", "TranslateGoModule"} {
+					source := "TEXT comparison(SB),4,$0-0\n" + row.instruction(0, 1, 2, false) + "\nRET\n" + invalid + "\nRET\n"
+					present, err := arm64MinMaxTargetAPI(t, api, source, triple)
+					if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %q malformed source became context/output: %t %v", api, invalid, present, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxSparseMergeEffect(t *testing.T) {
+	// The NEP merge source is V[n], not old V[d]. Preserve sparse known bits,
+	// never require the unobserved upper bits and never initialize them.
+	for _, alias := range []bool{false, true} {
+		destination := "V2"
+		if alias {
+			destination = "V0"
+		}
+		state := arm64MachineState{values: make(map[string]int)}
+		input := arm64MachineVectorDefinition{low: 0xffffffff, high: 0x00ff00ff00ff00ff}
+		state.setVectorDefinition("V0", input)
+		if !alias {
+			state.setVectorDefinition(destination, arm64MachineVectorDefinition{low: ^uint64(0), high: ^uint64(0)})
+		}
+		if err := state.applyVectorSpan(arm64MachineEffect{register: destination, copyFrom: "V0", width: 128, vectorSpan: true, write: true}); err != nil {
+			t.Fatal(err)
+		}
+		if err := state.applyVectorSpan(arm64MachineEffect{register: destination, width: 32, vectorSpan: true, write: true}); err != nil {
+			t.Fatal(err)
+		}
+		input.scalable = true // Architectural scalar write clears scalable high bits.
+		if got := state.vectorDefinition(destination); got != input {
+			t.Errorf("NEP first-source sparse merge alias=%t got %+v, want %+v", alias, got, input)
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxDefinednessAndNativePairing(t *testing.T) {
+	for _, row := range arm64MinMaxCases() {
+		for _, firstKnown := range []int{0, row.bits, 128} {
+			for _, readWidth := range []int{row.bits, 128} {
+				ctx, flow := arm64FlagScratchBankFixture()
+				ctx.targetTriple = "aarch64-unknown-linux-gnu"
+				ctx.vRegSlot = map[int]string{0: "%first", 1: "%second", 2: "%destination"}
+				flow.used, flow.entry = true, &ARM64GoRegisterABI{}
+				if firstKnown != 0 {
+					ctx.recordMachineRegister("F0", firstKnown, true)
+				}
+				ctx.recordMachineRegister("F1", row.bits, true)
+				ctx.recordMachineRegister("F2", 128, true) // Must not survive a different-source merge.
+				kind := strings.ToLower(strings.TrimSuffix(strings.TrimSuffix(row.name, "S"), "D"))
+				form := arm64ScalarMinMaxForm{arm64ScalarMinMaxSpec{kind, row.bits}, "F0", "F1", "F2"}
+				start := ctx.b.Len()
+				if err := ctx.lowerARM64ScalarMinMax(form); err != nil {
+					t.Fatal(err)
+				}
+				ctx.recordMachineOpaqueIR(start, Instr{})
+				ctx.recordMachineRegister("F2", readWidth, false)
+				err := flow.validate()
+				want := firstKnown >= readWidth
+				if want && err != nil || !want && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s/%d first=%d read=%d changed definedness: %v", row.name, row.bits, firstKnown, readWidth, err)
+				}
+				start = ctx.b.Len()
+				fmt.Fprintln(ctx.b, `  call void asm sideeffect "nop", ""()`)
+				ctx.recordMachineOpaqueIR(start, Instr{})
+				if !flow.blocks[0].effects[len(flow.blocks[0].effects)-1].opaque {
+					t.Fatal("min/max native-line proof leaked to an unrelated callout")
+				}
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxSparseCopyBoundariesAndJoins(t *testing.T) {
+	for _, effect := range []arm64MachineEffect{
+		{register: "V0", copyFrom: "R0", width: 128, vectorSpan: true, write: true},
+		{register: "R0", copyFrom: "V0", width: 128, vectorSpan: true, write: true},
+		{register: "V0", copyFrom: "V1", width: 128, vectorSpan: true},
+		{register: "V0", copyFrom: "V1", width: 64, vectorSpan: true, write: true},
+		{register: "V0", copyFrom: "V1", width: 128, vectorOffset: 1, vectorSpan: true, write: true},
+	} {
+		state := arm64MachineState{values: make(map[string]int)}
+		if err := state.applyVectorSpan(effect); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("invalid definedness copy accepted", effect, err)
+		}
+	}
+	for _, readWidth := range []int{32, 128} {
+		flow := &arm64MachineAvailability{used: true, entry: &ARM64GoRegisterABI{}, blocks: []arm64MachineBlock{
+			{name: "entry", successors: []string{"left", "right"}},
+			{name: "left", successors: []string{"join"}, effects: []arm64MachineEffect{{register: "V0", width: 128, write: true}}},
+			{name: "right", successors: []string{"join"}, effects: []arm64MachineEffect{{register: "V0", width: 32, write: true}}},
+			{name: "join", effects: []arm64MachineEffect{
+				{register: "V2", copyFrom: "V0", width: 128, vectorSpan: true, write: true},
+				{register: "V2", width: 32, vectorSpan: true, write: true},
+				{register: "V2", width: readWidth},
+			}},
+		}}
+		err := flow.validate()
+		if readWidth == 32 && err != nil || readWidth == 128 && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("merge restored bits unavailable on one predecessor, read=%d: %v", readWidth, err)
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxWholeStateTranslation(t *testing.T) {
+	for _, banks := range []bool{false, true} {
+		cases := arm64MinMaxStateCases(banks)
+		source, signatures := arm64MinMaxStateSource(cases[:4])
+		for _, ir := range arm64MinMaxIRs(t, source, "aarch64-unknown-linux-gnu", signatures) {
+			if strings.Count(ir, `asm sideeffect "fmax `) != 4 {
+				t.Fatal("complete state consumer lost its min/max operations")
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxRawReservedAndUnrelatedWordBoundaries(t *testing.T) {
+	for _, row := range arm64MinMaxCases() {
+		if row.word == 0 {
+			continue
+		}
+		reserved := row.word&^(3<<22) | 2<<22
+		for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext", "TranslateGoModule"} {
+			for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+				source := fmt.Sprintf("TEXT comparison(SB),4,$0-0\n%s\nRET\nWORD $%#08x\nRET\n", row.instruction(0, 1, 2, false), reserved)
+				present, err := arm64MinMaxTargetAPI(t, api, source, triple)
+				if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("reserved scalar min/max WORD became target context/output: %s/%s %t %v", api, triple, present, err)
+				}
+			}
+		}
+	}
+	for _, operands := range [][]Operand{
+		nil, {{Kind: OpImm, ImmRaw: "$(OTHER_OPCODE)"}},
+		{{Kind: OpReg, Reg: "R0"}}, {{Kind: OpImm, ImmIsFloat: true}},
+		{{Kind: OpImm, Imm: 0xd503201f}},
+	} {
+		file := &File{Arch: ArchARM64, Funcs: []Func{{Instrs: []Instr{{Op: OpWORD, Args: operands}}}}}
+		if err := validateARM64ScalarMinMaxTarget(file, Options{}); err != nil {
+			t.Fatalf("min/max claimed unrelated or unresolved WORD %+v: %v", operands, err)
+		}
+	}
+}
diff --git a/arm64_scalar_minmax_native_test.go b/arm64_scalar_minmax_native_test.go
new file mode 100644
index 000000000..102b1f277
--- /dev/null
+++ b/arm64_scalar_minmax_native_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Independent Go asm7 case-54 names and architectural scalar encodings.
+// Half precision is an existing raw WORD role, not a named Go instruction.
+type arm64MinMaxCase struct {
+	name string
+	bits int
+	word uint32
+}
+
+func arm64MinMaxCases() []arm64MinMaxCase {
+	var rows []arm64MinMaxCase
+	for index, operation := range []string{"FMAX", "FMIN", "FMAXNM", "FMINNM"} {
+		for _, width := range []struct {
+			bits   int
+			suffix string
+			typeID uint32
+		}{{32, "S", 0}, {64, "D", 1}, {16, "", 3}} {
+			word := uint32(0x1e204800) | uint32(index)<<12 | width.typeID<<22
+			if width.bits != 16 {
+				rows = append(rows, arm64MinMaxCase{operation + width.suffix, width.bits, 0})
+			}
+			rows = append(rows, arm64MinMaxCase{operation + width.suffix, width.bits, word})
+		}
+	}
+	return rows
+}
+
+func (row arm64MinMaxCase) instruction(left, right, destination int, destructive bool) string {
+	if row.word != 0 {
+		return fmt.Sprintf("WORD $%#08x", row.word|uint32(left)<<5|uint32(right)<<16|uint32(destination))
+	}
+	if destructive {
+		return fmt.Sprintf("%s F%d,F%d", row.name, right, left)
+	}
+	return fmt.Sprintf("%s F%d,F%d,F%d", row.name, right, left, destination)
+}
+
+func arm64MinMaxDeadFixture() (string, map[string]FuncSig) {
+	var source strings.Builder
+	signatures := make(map[string]FuncSig)
+	for index, row := range arm64MinMaxCases() {
+		name := fmt.Sprintf("compareMinMaxDead%d", index)
+		signatures[name] = arm64SM3Signature(name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMSR ZR,FPCR\nMSR ZR,FPSR\nFMOVD (R0),F0\n")
+		source.WriteString(row.instruction(0, 0, 1, false) + "\n")
+		// F1 is deliberately dead. Only architectural cumulative status escapes.
+		source.WriteString("MRS FPSR,R2\nMOVD R2,(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), signatures
+}
+
+func arm64MinMaxIRs(t *testing.T, source, triple string, signatures map[string]FuncSig) []string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, Sigs: signatures}
+	text, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	module, err := TranslateModule(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	direct := module.String()
+	module.Dispose()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err = TranslateModuleInContext(context, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound := module.String()
+	module.Dispose()
+	return []string{text, direct, bound}
+}
+
+func TestARM64ScalarMinMaxDeadNativeIR(t *testing.T) {
+	source, signatures := arm64MinMaxDeadFixture()
+	requireARM64GoAssemblerResult(t, source, true)
+	for api, ir := range arm64MinMaxIRs(t, source, "aarch64-unknown-linux-gnu", signatures) {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("API%d/O2=%t", api, optimized), func(t *testing.T) {
+				if optimized {
+					ir = armFloatEffectOptimizedIR(t, ir)
+				}
+				for _, operation := range []string{"fmax", "fmin", "fmaxnm", "fminnm"} {
+					if got := strings.Count(ir, `asm sideeffect "`+operation+" "); got != 5 {
+						t.Errorf("dead %s lost native FPCR/FPSR operation: got %d, want 5", operation, got)
+					}
+				}
+			})
+		}
+	}
+}
+
+func arm64MinMaxDeadRuntime(t *testing.T, triple, goos string, compiler, runner []string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	source, signatures := arm64MinMaxDeadFixture()
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range arm64MinMaxCases() {
+		fmt.Fprintf(&original, "func compareMinMaxDead%d(*uint64,*uint64)\n", index)
+		fmt.Fprintf(&driver, "extern void compareMinMaxDead%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) { uint64_t input,output; unsigned failures=0;\n")
+	for index, row := range arm64MinMaxCases() {
+		for _, signaling := range []bool{false, true} {
+			value := uint64(0x7ff8000000000001)
+			if row.bits == 32 {
+				value = 0x7fc00001
+			} else if row.bits == 16 {
+				value = 0x7e01
+			}
+			want := 0
+			if signaling {
+				want = 1
+				switch row.bits {
+				case 16:
+					value = 0x7c01
+				case 32:
+					value = 0x7f800001
+				default:
+					value = 0x7ff0000000000001
+				}
+			}
+			fmt.Fprintf(&original, "{ input:=uint64(%#x); var output uint64; compareMinMaxDead%d(&input,&output); if output!=%d { panic(fmt.Sprintf(\"%s/%d signaling=%t status %%x want %d\",output)) } }\n", value, index, want, row.name, row.bits, signaling, want)
+			fmt.Fprintf(&driver, "input=%#xULL;output=0;compareMinMaxDead%d(&input,&output);if(output!=%d){fprintf(stderr,\"%s/%d signaling=%t status %%llx want %d\\n\",(unsigned long long)output);failures++;}\n", value, index, want, row.name, row.bits, signaling, want)
+		}
+	}
+	original.WriteString("fmt.Println(\"ARM64_COMPARE_ORIGINAL_PASS minmax dead NaN 40\")\n}\n")
+	driver.WriteString("return failures?1:0;\n}\n")
+	arm64ScalarCompareActualGo(t, source, original.String(), goos, runner)
+	for api, ir := range arm64MinMaxIRs(t, source, triple, signatures) {
+		for _, optimized := range []bool{false, true} {
+			if optimized {
+				ir = armFloatEffectOptimizedIR(t, ir)
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("API%d/IR_O2=%t/backend_O%d", api, optimized, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "minmax_dead", triple, ir, driver.String(), runner, level)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ScalarMinMaxDeadNativeRuntime(t *testing.T) {
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin native counterpart; required Linux/QEMU owner covers other hosts")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	arm64MinMaxDeadRuntime(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil)
+}
diff --git a/arm64_scalar_minmax_partition_test.go b/arm64_scalar_minmax_partition_test.go
new file mode 100644
index 000000000..0365ef218
--- /dev/null
+++ b/arm64_scalar_minmax_partition_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarMinMaxBoundedRuntimeRoots(t *testing.T) {
+	checkARM64MinMaxRuntimeOwners(t, "arm64_scalar_minmax_runtime_linux_test.go",
+		"arm64MinMaxLinuxFamilyRuntime", "TestCrossLinuxRuntimeMatrixARM64ScalarMinMax")
+}
+
+func TestARM64ScalarMinMaxDarwinBoundedRuntimeRoots(t *testing.T) {
+	checkARM64MinMaxRuntimeOwners(t, "arm64_scalar_minmax_state_test.go",
+		"arm64MinMaxDarwinFamilyRuntime", "TestARM64ScalarMinMaxNativeRuntime")
+}
+
+func checkARM64MinMaxRuntimeOwners(t *testing.T, filename, helper, prefix string) {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		prefix + "FMAX":   "FMAX",
+		prefix + "FMIN":   "FMIN",
+		prefix + "FMAXNM": "FMAXNM",
+		prefix + "FMINNM": "FMINNM",
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		if function.Name.Name == "TestARM64ScalarMinMaxFullStateNativeRuntime" {
+			t.Fatal("monolithic native owner duplicates the bounded family roots")
+		}
+		family, required := want[function.Name.Name]
+		if !required {
+			if strings.HasPrefix(function.Name.Name, prefix) && function.Name.Name != prefix+"DeadNative" {
+				t.Fatal("unexpected or duplicate min/max runtime owner", function.Name.Name)
+			}
+			continue
+		}
+		calls := 0
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			name, ok := call.Fun.(*ast.Ident)
+			if !ok || name.Name != helper {
+				return true
+			}
+			calls++
+			if len(call.Args) != 2 {
+				t.Fatal("partition owner lost explicit family", function.Name.Name)
+			}
+			value, ok := call.Args[1].(*ast.BasicLit)
+			if !ok || value.Kind != token.STRING || value.Value != "\""+family+"\"" {
+				t.Fatal("partition owner changed family", function.Name.Name)
+			}
+			return true
+		})
+		if calls != 1 {
+			t.Fatal("partition owner lost exact runtime helper", function.Name.Name)
+		}
+		delete(want, function.Name.Name)
+	}
+	if len(want) != 0 {
+		t.Fatal("45-minute root needs exhaustive independently schedulable families", want)
+	}
+}
+
+func TestARM64ScalarMinMaxFamilyPartitionsComplete(t *testing.T) {
+	total := 0
+	for _, banks := range []bool{true, false} {
+		seen := make(map[arm64MinMaxStateCase]bool)
+		for _, family := range []string{"FMAX", "FMIN", "FMAXNM", "FMINNM"} {
+			rows := arm64MinMaxFamilyStateCases(banks, family)
+			expected := 205
+			if !banks {
+				expected = 10
+			}
+			if len(rows) != expected {
+				t.Fatal("changed full family denominator", family, banks, len(rows))
+			}
+			for _, row := range rows {
+				if seen[row] {
+					t.Fatal("duplicate cross-partition runtime form", row)
+				}
+				seen[row] = true
+				total += len(arm64MinMaxSamples(row.bits, banks))
+			}
+		}
+		original := arm64MinMaxStateCases(banks)
+		if len(seen) != len(original) {
+			t.Fatal("partition union differs from original complete grammar")
+		}
+		for _, row := range original {
+			if !seen[row] {
+				t.Fatal("original runtime form was omitted", row)
+			}
+		}
+	}
+	if total != 14600 {
+		t.Fatal("partitioning removed original Go/LLVM state comparisons", total)
+	}
+	if len(arm64MinMaxFamilyStateCases(true, "unknown")) != 0 {
+		t.Fatal("unknown family borrowed another partition")
+	}
+}
+
+func TestARM64ScalarMinMaxAFPPartitionWitnesses(t *testing.T) {
+	// The original oracle increments AH only for the ordinary min/max signed-
+	// zero witness. NM partitions retain their full AH input matrix but cannot
+	// acquire that counter from a different partition's instruction family.
+	for _, family := range []string{"", "FMAX", "FMIN", "FMAXNM", "FMINNM"} {
+		numeric := family == "FMAXNM" || family == "FMINNM"
+		for _, counts := range [][2]int{{0, 0}, {0, 40}, {1025, 0}, {1025, 40}} {
+			nep, ah := counts[0], counts[1]
+			want := nep > 0 && (numeric || ah > 0)
+			err := arm64MinMaxAFPObservationError(family, nep, ah)
+			if (err == nil) != want {
+				t.Errorf("family=%q NEP=%d AH=%d: error=%v; want accepted=%t", family, nep, ah, err, want)
+			}
+		}
+	}
+	if err := arm64MinMaxAFPObservationError("unknown", 1025, 40); err == nil {
+		t.Fatal("unknown partition inherited another family's witnesses")
+	}
+}
diff --git a/arm64_scalar_minmax_runtime_linux_test.go b/arm64_scalar_minmax_runtime_linux_test.go
new file mode 100644
index 000000000..7dcf170c2
--- /dev/null
+++ b/arm64_scalar_minmax_runtime_linux_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxDeadNative(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64MinMaxDeadRuntime(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+// Complete family roots are separate scheduler inputs. Keep every original
+// bank, state, API and optimization axis without extending the CI deadline.
+func TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxFMAX(t *testing.T) {
+	arm64MinMaxLinuxFamilyRuntime(t, "FMAX")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxFMIN(t *testing.T) {
+	arm64MinMaxLinuxFamilyRuntime(t, "FMIN")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxFMAXNM(t *testing.T) {
+	arm64MinMaxLinuxFamilyRuntime(t, "FMAXNM")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarMinMaxFMINNM(t *testing.T) {
+	arm64MinMaxLinuxFamilyRuntime(t, "FMINNM")
+}
+
+func arm64MinMaxLinuxFamilyRuntime(t *testing.T, family string) {
+	t.Helper()
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/QEMU cross-runtime owner")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross runtime requires Linux/amd64")
+	}
+	arm64MinMaxStateRuntimeFamily(t, "aarch64-unknown-linux-gnu", "linux",
+		[]string{"aarch64-linux-gnu-gcc", "-no-pie"},
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"}, family, true)
+}
diff --git a/arm64_scalar_minmax_state_test.go b/arm64_scalar_minmax_state_test.go
new file mode 100644
index 000000000..2158c66cc
--- /dev/null
+++ b/arm64_scalar_minmax_state_test.go
@@ -0,0 +1,412 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+type arm64MinMaxStateCase struct {
+	arm64MinMaxCase
+	first, second, destination int
+	destructive, dead          bool
+}
+
+type arm64MinMaxSample struct {
+	a, b, control, status uint64
+}
+
+func arm64MinMaxStateCases(banks bool) []arm64MinMaxStateCase {
+	var cases []arm64MinMaxStateCase
+	for _, row := range arm64MinMaxCases() {
+		if !banks {
+			for _, dead := range []bool{false, true} {
+				cases = append(cases, arm64MinMaxStateCase{row, 0, 1, 2, false, dead})
+			}
+			continue
+		}
+		// Independent axes: every physical register in every operand position;
+		// all aliases additionally at low/middle/high banks, not a huge product.
+		for bank := 0; bank < 32; bank++ {
+			cases = append(cases, arm64MinMaxStateCase{row, bank, (bank + 1) % 32, (bank + 2) % 32, false, false})
+		}
+		for _, bank := range []int{0, 15, 31} {
+			other := (bank + 1) % 32
+			cases = append(cases,
+				arm64MinMaxStateCase{row, bank, other, bank, row.word == 0, false},
+				arm64MinMaxStateCase{row, bank, other, other, false, false},
+				arm64MinMaxStateCase{row, bank, bank, bank, false, false},
+			)
+		}
+	}
+	return cases
+}
+
+func arm64MinMaxSamples(bits int, banks bool) []arm64MinMaxSample {
+	values := arm64CompareValues(bits) // Independent integer IEEE input patterns.
+	if banks {
+		return []arm64MinMaxSample{{values[2], values[3], 0, 0x08000082}, {values[2], values[3], 4, 0x08000082}}
+	}
+	pairs := [][2]int{{0, 1}, {1, 0}, {2, 3}, {3, 2}, {4, 5}, {5, 4},
+		{6, 2}, {2, 6}, {8, 2}, {2, 8}, {6, 8}, {8, 6}, {7, 9}, {9, 7},
+		{10, 0}, {0, 10}, {11, 1}, {1, 11}, {12, 13}, {13, 12}}
+	var result []arm64MinMaxSample
+	for _, pair := range pairs {
+		for controls := 0; controls < 16; controls++ {
+			control := uint64(controls&1)<<24 | uint64((controls>>1)&1)<<25 |
+				uint64((controls>>2)&1)<<2 | uint64((controls>>3)&1)<<1
+			if bits == 16 && controls&1 != 0 {
+				control |= 1 << 19
+			}
+			status := uint64(0x08000002)
+			if controls&1 != 0 {
+				status |= 0x81
+			}
+			result = append(result, arm64MinMaxSample{values[pair[0]], values[pair[1]], control, status})
+		}
+	}
+	for rounding := 0; rounding < 4; rounding++ {
+		result = append(result, arm64MinMaxSample{values[10], values[11], uint64(rounding)<<22 | 7, 0x08000082})
+	}
+	return result
+}
+
+func arm64MinMaxStateSource(cases []arm64MinMaxStateCase) (string, map[string]FuncSig) {
+	var source strings.Builder
+	signatures := make(map[string]FuncSig)
+	for index, row := range cases {
+		name := fmt.Sprintf("minmaxState%d", index)
+		signatures[name] = arm64SM3Signature(name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.B16]\n", bank)
+		}
+		source.WriteString("MRS FPCR,R10\nMRS FPSR,R11\nMOVD (R0),R12\nMSR R12,FPCR\nMOVD 8(R0),R12\nMSR R12,FPSR\nCMP R0,R0\n")
+		source.WriteString(row.instruction(row.first, row.second, row.destination, row.destructive) + "\n")
+		if row.dead {
+			fmt.Fprintf(&source, "VEOR V%d.B16,V%d.B16,V%d.B16\n", row.destination, row.destination, row.destination)
+		}
+		// Consume the source NZCV bank through CSET, as the existing compare
+		// oracle does. Native MRS NZCV has a separate physical-state contract.
+		source.WriteString("CSET MI,R4\nLSL $31,R4,R4\nCSET EQ,R5\nLSL $30,R5,R5\nORR R5,R4,R4\nCSET CS,R5\nLSL $29,R5,R5\nORR R5,R4,R4\nCSET VS,R5\nLSL $28,R5,R5\nORR R5,R4,R4\nMRS FPCR,R2\nMRS FPSR,R3\n")
+		for bank := 0; bank < 32; bank++ {
+			fmt.Fprintf(&source, "VST1.P [V%d.B16],16(R1)\n", bank)
+		}
+		source.WriteString("MOVD R3,(R1)\nMOVD R2,8(R1)\nMOVD R4,16(R1)\nMSR R10,FPCR\nMSR R11,FPSR\nRET\n")
+	}
+	return source.String(), signatures
+}
+
+func arm64MinMaxOriginalOutput(t *testing.T, source, program, goos string, runner []string) []byte {
+	t.Helper()
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module minmaxoracle\n\ngo 1.20\n", "main.go": program,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT minmaxState", "TEXT ·minmaxState"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	arguments := []string{"run", "-p=1"}
+	if len(runner) != 0 {
+		arguments = append(arguments, "-exec="+strings.Join(runner, " "))
+	}
+	command := exec.CommandContext(ctx, "go", append(arguments, ".")...)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("actual original min/max program: %v\n%s", err, output)
+	}
+	return output
+}
+
+func arm64MinMaxStatePrograms(cases []arm64MinMaxStateCase, banks bool, expectedPath string) (string, string, int) {
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport (\"encoding/binary\";\"os\")\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "func minmaxState%d(*[66]uint64,*[69]uint64)\n", index)
+		fmt.Fprintf(&driver, "extern void minmaxState%d(uint64_t*,uint64_t*);\n", index)
+	}
+	original.WriteString("var functions = [...]func(*[66]uint64,*[69]uint64){\n")
+	driver.WriteString("static void (*functions[])(uint64_t*,uint64_t*)={\n")
+	for index := range cases {
+		fmt.Fprintf(&original, "minmaxState%d,\n", index)
+		fmt.Fprintf(&driver, "minmaxState%d,\n", index)
+	}
+	original.WriteString("}\nvar forms=[]struct{ bits,first,second int }{\n")
+	driver.WriteString("};\nstatic const struct{unsigned bits,first,second;} forms[]={\n")
+	for _, row := range cases {
+		fmt.Fprintf(&original, "{%d,%d,%d},\n", row.bits, row.first, row.second)
+		fmt.Fprintf(&driver, "{%d,%d,%d},\n", row.bits, row.first, row.second)
+	}
+	original.WriteString("}\nvar samples=[]struct{bits int;a,b,control,status uint64}{\n")
+	driver.WriteString("};\nstatic const struct{unsigned bits;uint64_t a,b,control,status;} samples[]={\n")
+	for _, bits := range []int{16, 32, 64} {
+		for _, sample := range arm64MinMaxSamples(bits, banks) {
+			fmt.Fprintf(&original, "{%d,%#x,%#x,%#x,%#x},\n", bits, sample.a, sample.b, sample.control, sample.status)
+			fmt.Fprintf(&driver, "{%d,%#xULL,%#xULL,%#xULL,%#xULL},\n", bits, sample.a, sample.b, sample.control, sample.status)
+		}
+	}
+	original.WriteString(`}
+func main() {
+    for index,form:=range forms {
+        for _,sample:=range samples {
+            if sample.bits!=form.bits { continue }
+            var input [66]uint64
+            for word:=0;word<64;word++ { input[word]=0x123456789abcdef0+uint64(word)*0x0102030405060708 }
+            mask:=^uint64(0)
+            if form.bits<64 { mask=(uint64(1)<<form.bits)-1 }
+            input[2*form.first]=input[2*form.first]&^mask|sample.a
+            if form.first!=form.second { input[2*form.second]=input[2*form.second]&^mask|sample.b }
+            input[64],input[65]=sample.control,sample.status
+            before:=input
+            var output [69]uint64
+            output[67],output[68]=0x123456789abcdef0,0xfedcba9876543210
+            functions[index](&input,&output)
+            if input!=before { panic("original modified input") }
+            if err:=binary.Write(os.Stdout,binary.LittleEndian,output);err!=nil { panic(err) }
+        }
+    }
+}
+`)
+	fmt.Fprintf(&driver, "};\nint main(void) { FILE* expected=fopen(%q,\"rb\"); if(!expected)return 2;unsigned count=0;\n", expectedPath)
+	driver.WriteString(`
+    for(unsigned index=0;index<sizeof(forms)/sizeof(forms[0]);index++) {
+        for(unsigned sample=0;sample<sizeof(samples)/sizeof(samples[0]);sample++) {
+            if(samples[sample].bits!=forms[index].bits) continue;
+            uint64_t input[66]={0},output[69]={0},before[66],want[69];
+            for(unsigned word=0;word<64;word++) input[word]=0x123456789abcdef0ULL+(uint64_t)word*0x0102030405060708ULL;
+            uint64_t mask=UINT64_MAX;
+            if(forms[index].bits<64) mask=(UINT64_C(1)<<forms[index].bits)-1;
+            unsigned first=2*forms[index].first,second=2*forms[index].second;
+            input[first]=(input[first]&~mask)|samples[sample].a;
+            if(first!=second) input[second]=(input[second]&~mask)|samples[sample].b;
+            input[64]=samples[sample].control;input[65]=samples[sample].status;
+            for(unsigned word=0;word<66;word++) before[word]=input[word];
+            output[67]=0x123456789abcdef0ULL;output[68]=0xfedcba9876543210ULL;
+            if(fread(want,sizeof(uint64_t),69,expected)!=69) return 3;
+            functions[index](input,output);
+            for(unsigned word=0;word<66;word++) if(input[word]!=before[word]) return 4;
+            for(unsigned word=0;word<69;word++) {
+                if(output[word]!=want[word]) {
+                    fprintf(stderr,"form=%u sample=%u word=%u got=%llx want=%llx\n",index,sample,word,(unsigned long long)output[word],(unsigned long long)want[word]);
+                    return 1;
+                }
+            }
+            count++;
+        }
+    }
+    if(fgetc(expected)!=EOF || fclose(expected)) return 5;
+    printf("ARM64_MINMAX_TRANSLATED_PASS %u\n",count);
+    return 0;
+}
+`)
+	count := 0
+	for _, row := range cases {
+		count += len(arm64MinMaxSamples(row.bits, banks))
+	}
+	return original.String(), driver.String(), count
+}
+
+func arm64MinMaxCheckOriginalState(t *testing.T, cases []arm64MinMaxStateCase, banks bool, output []byte) (nep, ah int) {
+	t.Helper()
+	position := 0
+	for _, row := range cases {
+		for _, sample := range arm64MinMaxSamples(row.bits, banks) {
+			if len(output)-position < 69*8 {
+				t.Fatal("original min/max output is truncated")
+			}
+			var got [69]uint64
+			for index := range got {
+				got[index] = binary.LittleEndian.Uint64(output[position : position+8])
+				position += 8
+			}
+			if got[66] != 0x60000000 || got[67] != 0x123456789abcdef0 || got[68] != 0xfedcba9876543210 || got[64]&sample.status != sample.status {
+				t.Fatalf("original min/max changed NZCV/canary/cumulative status: %x", got[64:])
+			}
+			mask := ^uint64(0)
+			if row.bits < 64 {
+				mask = uint64(1)<<uint(row.bits) - 1
+			}
+			for word := 0; word < 64; word++ {
+				want := uint64(0x123456789abcdef0) + uint64(word)*0x0102030405060708
+				if word == 2*row.first {
+					want = want&^mask | sample.a
+				} else if word == 2*row.second {
+					want = want&^mask | sample.b
+				}
+				if word/2 != row.destination && got[word] != want {
+					t.Fatalf("original min/max corrupted non-destination bank %d: got=%x want=%x", word, got[word], want)
+				}
+			}
+			if row.dead {
+				if got[2*row.destination] != 0 || got[2*row.destination+1] != 0 {
+					t.Fatal("original dead-destination fixture did not overwrite the complete vector")
+				}
+				continue
+			}
+			upperLow, upperHigh := uint64(0), uint64(0)
+			if got[65]&4 != 0 {
+				upperLow = (uint64(0x123456789abcdef0) + uint64(2*row.first)*0x0102030405060708) &^ mask
+				upperHigh = uint64(0x123456789abcdef0) + uint64(2*row.first+1)*0x0102030405060708
+				nep++ // Actual nonzero first-source merge, checked below.
+			}
+			if got[2*row.destination]&^mask != upperLow || got[2*row.destination+1] != upperHigh {
+				t.Fatalf("original NEP result is not first-source merge: %+v ctrl=%x result=%x", row, got[65], got[2*row.destination:2*row.destination+2])
+			}
+			isNumeric := strings.Contains(row.name, "NM")
+			sign := uint64(1) << uint(row.bits-1)
+			if !isNumeric && sample.a&^sign == 0 && sample.b&^sign == 0 && row.first != row.second {
+				want := sample.a & sample.b // FMAX prefers positive zero.
+				if strings.HasPrefix(row.name, "FMIN") {
+					want = sample.a | sample.b
+				}
+				if got[65]&2 != 0 {
+					if want != sample.b {
+						ah++ // Exact AH result differs from the standard rule.
+					}
+					want = sample.b
+				}
+				if got[2*row.destination]&mask != want {
+					t.Fatalf("original AH/zero behavior mismatch: %+v ctrl=%x got=%x want=%x", row, got[65], got[2*row.destination]&mask, want)
+				}
+			}
+		}
+	}
+	if position != len(output) {
+		t.Fatal("unexpected extra original min/max transcript bytes")
+	}
+	return nep, ah
+}
+
+func arm64MinMaxFamilyStateCases(banks bool, family string) []arm64MinMaxStateCase {
+	var selected []arm64MinMaxStateCase
+	for _, row := range arm64MinMaxStateCases(banks) {
+		name := strings.TrimSuffix(strings.TrimSuffix(row.name, "S"), "D")
+		if family == "" || name == family {
+			selected = append(selected, row)
+		}
+	}
+	return selected
+}
+
+func arm64MinMaxStateRuntimeFamily(t *testing.T, triple, goos string, compiler, runner []string, family string, requireAFP bool) {
+	t.Helper()
+	if family != "FMAX" && family != "FMIN" && family != "FMAXNM" && family != "FMINNM" {
+		t.Fatal("unknown min/max runtime partition", family)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	total, nep, ah := 0, 0, 0
+	for _, banks := range []bool{true, false} {
+		cases := arm64MinMaxFamilyStateCases(banks, family)
+		for first := 0; first < len(cases); first += 32 {
+			last := first + 32
+			if last > len(cases) {
+				last = len(cases)
+			}
+			t.Run(fmt.Sprintf("banks=%t/batch%d", banks, first/32), func(t *testing.T) {
+				batch := cases[first:last]
+				source, signatures := arm64MinMaxStateSource(batch)
+				path := filepath.Join(t.TempDir(), "original.bin")
+				original, driver, count := arm64MinMaxStatePrograms(batch, banks, path)
+				started := time.Now()
+				output := arm64MinMaxOriginalOutput(t, source, original, goos, runner)
+				t.Logf("phase=original-Go elapsed=%s", time.Since(started))
+				if len(output) != count*69*8 {
+					t.Fatalf("actual Go output bytes=%d want=%d", len(output), count*69*8)
+				}
+				newNEP, newAH := arm64MinMaxCheckOriginalState(t, batch, banks, output)
+				nep, ah = nep+newNEP, ah+newAH
+				total += count
+				t.Logf("actual original Go rows=%d NEP-merges=%d AH-differences=%d", count, newNEP, newAH)
+				if err := os.WriteFile(path, output, 0600); err != nil {
+					t.Fatal(err)
+				}
+				started = time.Now()
+				irs := arm64MinMaxIRs(t, source, triple, signatures)
+				t.Logf("phase=three-API-IR elapsed=%s", time.Since(started))
+				for api, ir := range irs {
+					for _, optimized := range []bool{false, true} {
+						if optimized {
+							started = time.Now()
+							ir = armFloatEffectOptimizedIR(t, ir)
+							t.Logf("phase=IR-O2 API=%d elapsed=%s", api, time.Since(started))
+						}
+						for _, level := range []int{0, 2} {
+							t.Run(fmt.Sprintf("API%d/IR_O2=%t/backend_O%d", api, optimized, level), func(t *testing.T) {
+								compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "minmax_state", triple, ir, driver, runner, level)
+							})
+						}
+					}
+				}
+			})
+		}
+	}
+	if total != 3650 {
+		t.Fatal("changed complete min/max runtime denominator", total)
+	}
+	if requireAFP {
+		if err := arm64MinMaxAFPObservationError(family, nep, ah); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Logf("ARM64_MINMAX_FULL_STATE_PASS family=%q original=%d LLVM=%d NEP=%d AH=%d", family, total, total*12, nep, ah)
+}
+
+func arm64MinMaxAFPObservationError(family string, nep, ah int) error {
+	// AH counts the ordinary FMAX/FMIN signed-zero witness, not every row
+	// with AH enabled. Numeric partitions must still execute their complete
+	// AH matrix and compare every result/status byte with the original Go.
+	needsAH := family == "" || family == "FMAX" || family == "FMIN"
+	if !needsAH && family != "FMAXNM" && family != "FMINNM" {
+		return fmt.Errorf("unknown min/max AFP witness partition %q", family)
+	}
+	if nep <= 0 || ah < 0 || (needsAH && ah == 0) {
+		return fmt.Errorf("required actual AFP semantic effects missing for %q: NEP=%d AH=%d", family, nep, ah)
+	}
+	return nil
+}
+
+// Keep the same complete native denominator as the Linux owners, split into
+// independently schedulable roots rather than one 45-minute package occupant.
+func TestARM64ScalarMinMaxNativeRuntimeFMAX(t *testing.T) {
+	arm64MinMaxDarwinFamilyRuntime(t, "FMAX")
+}
+
+func TestARM64ScalarMinMaxNativeRuntimeFMIN(t *testing.T) {
+	arm64MinMaxDarwinFamilyRuntime(t, "FMIN")
+}
+
+func TestARM64ScalarMinMaxNativeRuntimeFMAXNM(t *testing.T) {
+	arm64MinMaxDarwinFamilyRuntime(t, "FMAXNM")
+}
+
+func TestARM64ScalarMinMaxNativeRuntimeFMINNM(t *testing.T) {
+	arm64MinMaxDarwinFamilyRuntime(t, "FMINNM")
+}
+
+func arm64MinMaxDarwinFamilyRuntime(t *testing.T, family string) {
+	t.Helper()
+	if runtime.GOOS != "darwin" || runtime.GOARCH != "arm64" {
+		t.Skip("Darwin native counterpart; required Linux/QEMU owner covers other hosts")
+	}
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	arm64MinMaxStateRuntimeFamily(t, "aarch64-apple-darwin", "darwin", []string{clang}, nil, family, false)
+}
diff --git a/arm64_scalar_minmax_target_test.go b/arm64_scalar_minmax_target_test.go
new file mode 100644
index 000000000..bcd77db7e
--- /dev/null
+++ b/arm64_scalar_minmax_target_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64MinMaxTargetAPI(t *testing.T, api, source, triple string) (bool, error) {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return false, err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"comparison": {Name: "comparison", Ret: Void}},
+	}
+	switch api {
+	case "Translate":
+		ir, err := Translate(file, options)
+		return ir != "", err
+	case "TranslateModule":
+		module, err := TranslateModule(file, options)
+		present := !module.IsNil()
+		if present {
+			module.Dispose()
+		}
+		return present, err
+	case "TranslateModuleInContext":
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err := TranslateModuleInContext(context, file, options)
+		present := !module.IsNil()
+		if present {
+			module.Dispose()
+		}
+		return present, err
+	case "TranslateGoModule":
+		pkg := mustGoPackage(t, "comparison", "package comparison\nfunc comparison()\n")
+		bound, err := TranslateGoModule(pkg,
+			[]byte(strings.ReplaceAll(source, "TEXT comparison", "TEXT ·comparison")),
+			GoModuleOptions{GOOS: "linux", GOARCH: "arm64", TargetTriple: triple})
+		if bound != nil {
+			bound.Module.Dispose()
+		}
+		return bound != nil, err
+	default:
+		t.Fatal("unknown min/max API", api)
+		return false, nil
+	}
+}
+
+func TestARM64ScalarMinMaxUnrelatedRawSyntaxPriority(t *testing.T) {
+	for _, row := range arm64MinMaxCases() {
+		native := row.instruction(0, 1, 2, false)
+		for _, invalid := range []string{"WORD $0xffffffff", "WORD $1.5", "WORD R0"} {
+			for _, body := range []string{
+				invalid + "\n" + native,
+				native + "\n" + invalid,
+				native + "\nRET\n" + invalid,
+				"RET\n" + invalid + "\n" + native,
+			} {
+				for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown", "aarch64-unknown-linux-gnu"} {
+					for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext", "TranslateGoModule"} {
+						present, err := arm64MinMaxTargetAPI(t, api, "TEXT comparison(SB),4,$0-0\n"+body+"\nRET\n", triple)
+						if present || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+							t.Errorf("%s %s %s source=%q: output=%t err=%v", row.name, api, triple, body, present, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_scalar_move_immediate_type_test.go b/arm64_scalar_move_immediate_type_test.go
new file mode 100644
index 000000000..a703499e9
--- /dev/null
+++ b/arm64_scalar_move_immediate_type_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestARM64ScalarGPMoveRejectsFloatingOperandThroughFullTranslate(t *testing.T) {
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		for _, literal := range []string{"0.0", "-0.0", "1.5", "-1.5"} {
+			for _, shape := range []struct{ suffix, operands string }{
+				{operands: "$%s,R0"},
+				{operands: "$%s,8(R0)"},
+				{operands: "$%s,storage(SB)"},
+				{operands: "R0,$%s"},
+				{suffix: ".P", operands: "$%s,8(R0)"},
+				{suffix: ".W", operands: "$%s,8(R0)"},
+			} {
+				instruction := op + shape.suffix + " " + fmt.Sprintf(shape.operands, literal)
+				t.Run(instruction, func(t *testing.T) {
+					source := "GLOBL storage(SB),16,$8\nTEXT floating(SB),516,$0-0\n" + instruction + "\nRET\n"
+					requireARM64GoAssemblerResult(t, source, false)
+					file, err := Parse(ArchARM64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					found := false
+					for _, operand := range file.Funcs[0].Instrs[1].Args {
+						found = found || operand.Kind == OpImm && operand.ImmIsFloat
+					}
+					if !found {
+						t.Fatal("test did not reach the typed floating immediate")
+					}
+
+					_, err = Translate(file, Options{
+						Goarch:       "arm64",
+						TargetTriple: "aarch64-unknown-linux-gnu",
+						Sigs: map[string]FuncSig{
+							"floating": {Name: "floating", Ret: Void},
+						},
+					})
+					if err == nil || !strings.Contains(err.Error(), "floating immediate") {
+						t.Fatalf("full lowerer did not reject the invalid floating operand: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64ScalarGPMoveImmediateClassMatchesGo(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// TYPE_FCONST is a distinct C_FCON class. The seven scalar GP spellings
+	// have no such row; the unsigned spellings inherit the signed family's
+	// rows (also checked by the complete GP move family test).
+	for _, op := range []string{"AMOVB", "AMOVBU", "AMOVH", "AMOVHU", "AMOVW", "AMOVWU", "AMOVD"} {
+		if regexp.MustCompile(`(?m)^\s*\{` + op + `, C_FCON,`).Match(source) {
+			t.Fatalf("Go acquired a floating GP MOV row: %s; audit its complete semantics", op)
+		}
+	}
+	for _, op := range []string{"AFMOVS", "AFMOVD"} {
+		if !regexp.MustCompile(`(?m)^\s*\{` + op + `, C_FCON, C_NONE, C_NONE, C_FREG,`).Match(source) {
+			t.Fatalf("Go floating immediate row changed: %s", op)
+		}
+	}
+}
+
+func TestARM64ScalarGPMoveFloatGuardKeepsValidIntegerAndFPTransfers(t *testing.T) {
+	lines := []string{"GLOBL storage(SB),16,$8", "TEXT valid(SB),516,$0-0"}
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		lines = append(lines, op+" $0,R0", op+" R1,R0", op+" $0,8(R0)", op+" $0,storage(SB)")
+	}
+	lines = append(lines,
+		"MOVW $806,R0", "MOVD $-601,R0", "MOVD $0x123456789abcdef,R0",
+		"FMOVS $0.0,F0", "FMOVD $-0.0,F0", "FMOVS $1.5,F0", "FMOVD $-1.5,F0",
+		"FMOVS R1,F0", "FMOVS F0,R1", "FMOVD R1,F0", "FMOVD F0,R1", "RET",
+	)
+	source := strings.Join(lines, "\n") + "\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required")
+	}
+	for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+		ir, err := Translate(file, Options{
+			Goarch:       "arm64",
+			TargetTriple: triple,
+			Sigs: map[string]FuncSig{
+				"valid": {Name: "valid", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "valid-moves.ll", "valid-moves.o", ir)
+	}
+}
diff --git a/arm64_scalar_writeback.go b/arm64_scalar_writeback.go
new file mode 100644
index 000000000..141139552
--- /dev/null
+++ b/arm64_scalar_writeback.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's asm7 types 22/23 accept pre/post-indexed scalar loads and stores
+// with a signed nine-bit immediate. Unsigned narrow moves share the same
+// table through oprangeset. Keep their typed load/store semantics in lowerData.
+func (c *arm64Ctx) lowerARM64ScalarMemoryWriteback(op Op, ins Instr) (bool, bool, error) {
+	switch op {
+	case "MOVD", "MOVW", "MOVWU", "MOVH", "MOVHU", "MOVB", "MOVBU":
+	default:
+		return false, false, nil
+	}
+	rawOp := strings.ToUpper(string(ins.Op))
+	if rawOp == string(op) {
+		return false, false, nil
+	}
+	post := rawOp == string(op)+".P"
+	pre := rawOp == string(op)+".W"
+	if (!post && !pre) || len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm64 %s requires a single .P or .W memory writeback suffix: %q", op, ins.Raw)
+	}
+
+	memoryIndex, dataIndex := 0, 1
+	if ins.Args[1].Kind == OpMem {
+		memoryIndex, dataIndex = 1, 0
+	}
+	memory, data := ins.Args[memoryIndex], ins.Args[dataIndex]
+	// Go's arm64 progedit rewrites literal $0 to REGZERO for these seven
+	// move opcodes before matching asm7 types 22/23. Keep that exact source
+	// alias; unresolved expressions and nonzero immediates are not registers.
+	zeroStore := memoryIndex == 1 && data.Kind == OpImm && data.Imm == 0 && data.ImmRaw == ""
+	if zeroStore {
+		data = Operand{Kind: OpReg, Reg: ZR}
+	}
+	if memory.Kind != OpMem || data.Kind != OpReg || !isARM64GeneralOrZeroReg(data.Reg) {
+		return true, false, fmt.Errorf("arm64 %s writeback requires memory and a general or zero register: %q", op, ins.Raw)
+	}
+	mem := memory.Mem
+	if mem.OffRaw != "" || mem.Index != "" || mem.Off < -256 || mem.Off > 255 {
+		return true, false, fmt.Errorf("arm64 %s writeback requires a signed nine-bit immediate memory offset: %q", op, ins.Raw)
+	}
+	if mem.Base != SP && mem.Base != Reg("RSP") && mem.Base == data.Reg {
+		return true, false, fmt.Errorf("arm64 %s writeback has constrained unpredictable base/data register overlap: %q", op, ins.Raw)
+	}
+
+	normalized := ins
+	normalized.Op = op
+	if zeroStore || pre {
+		normalized.Args = append([]Operand(nil), ins.Args...)
+	}
+	if zeroStore {
+		normalized.Args[dataIndex] = data
+	}
+	if pre {
+		base := mem.Base
+		if base == ZR || base == Reg("RSP") {
+			base = SP
+		}
+		if err := c.updatePostInc(base, mem.Off); err != nil {
+			return true, false, err
+		}
+		memory.Mem.Off = 0
+		normalized.Args[memoryIndex] = memory
+	}
+	return c.lowerData(op, post, normalized)
+}
diff --git a/arm64_scalar_writeback_test.go b/arm64_scalar_writeback_test.go
new file mode 100644
index 000000000..fa65d8b5f
--- /dev/null
+++ b/arm64_scalar_writeback_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+var arm64ScalarWritebackOps = []struct {
+	op     string
+	bits   int
+	signed bool
+}{
+	{"MOVD", 64, false},
+	{"MOVW", 32, true},
+	{"MOVWU", 32, false},
+	{"MOVH", 16, true},
+	{"MOVHU", 16, false},
+	{"MOVB", 8, true},
+	{"MOVBU", 8, false},
+}
+
+func TestARM64ScalarWritebackCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	// The Cartesian product changes SP by a nonzero net amount. Preserve the
+	// real entry SP in a register that none of these forms writes, then restore
+	// it before the caller RET. This is an object-form oracle, not execution of
+	// deliberately unaligned SP accesses or unknown-pointer R1 accesses.
+	source.WriteString("TEXT scalarWritebackForms(SB),$0-0\nMOVD RSP,R20\n")
+	for _, form := range arm64ScalarWritebackOps {
+		for _, suffix := range []string{".P", ".W"} {
+			for _, off := range []int{-256, -1, 0, 1, 255} {
+				fmt.Fprintf(&source, "%s%s %d(R1), R2\n", form.op, suffix, off)
+				fmt.Fprintf(&source, "%s%s %d(RSP), ZR\n", form.op, suffix, off)
+				fmt.Fprintf(&source, "%s%s R2, %d(R1)\n", form.op, suffix, off)
+				fmt.Fprintf(&source, "%s%s ZR, %d(RSP)\n", form.op, suffix, off)
+				fmt.Fprintf(&source, "%s%s $0, %d(R1)\n", form.op, suffix, off)
+				fmt.Fprintf(&source, "%s%s $0, %d(RSP)\n", form.op, suffix, off)
+			}
+		}
+	}
+	source.WriteString("MOVD R20,RSP\nRET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: map[string]FuncSig{
+			"scalarWritebackForms": {Name: "scalarWritebackForms", Ret: Void},
+		}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "scalar-writeback.ll", "scalar-writeback.o", ir)
+	}
+}
+
+func TestARM64ScalarWritebackRejectsGoInvalidForms(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVD.P R1, R2", "MOVD.W $1, R2",
+		"MOVD.P frame+0(FP), R2", "MOVD.W R2, frame+0(FP)",
+		"MOVD.P data(SB), R2", "MOVD.W R2, data(SB)",
+		"MOVD.P (R1)(R2), R3", "MOVD.W R3, (R1)(R2)",
+		"MOVD.P 256(R1), R2", "MOVD.W R2, -257(R1)",
+		"MOVD.P 8(R1), R1", "MOVWU.W R1, 4(R1)",
+		"MOVBW.P R2, 1(R1)", "MOVHW.W R2, 1(R1)",
+		"MOVD.P $1, 8(R1)", "MOVD.W $-1, 8(R1)",
+		"MOVW.P $1, 4(R1)", "MOVW.W $-1, 4(R1)",
+		"MOVWU.P $1, 4(R1)", "MOVWU.W $-1, 4(R1)",
+		"MOVH.P $1, 2(R1)", "MOVH.W $-1, 2(R1)",
+		"MOVHU.P $1, 2(R1)", "MOVHU.W $-1, 2(R1)",
+		"MOVB.P $1, 1(R1)", "MOVB.W $-1, 1(R1)",
+		"MOVBU.P $1, 1(R1)", "MOVBU.W $-1, 1(R1)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT badScalarWriteback(SB),$0-16\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"badScalarWriteback": {Name: "badScalarWriteback", Ret: Void},
+			}})
+			if err == nil {
+				t.Fatal("translator accepted Go-rejected scalar memory writeback")
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64ScalarWriteback(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, declarations, checks, goDeclarations, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64ScalarWritebackOps {
+		for _, suffix := range []string{"", ".P", ".W"} {
+			for _, off := range []int{-4, 0, 4} {
+				for _, access := range []struct {
+					store bool
+					zero  bool
+				}{
+					{}, {store: true}, {store: true, zero: true},
+				} {
+					store := access.store
+					name := fmt.Sprintf("scalar_wb_%d", len(sigs))
+					instruction := fmt.Sprintf("%s%s %d(R1), R4", form.op, suffix, off)
+					if store {
+						instruction = fmt.Sprintf("%s%s R2, %d(R1)", form.op, suffix, off)
+					}
+					if access.zero {
+						instruction = fmt.Sprintf("%s%s $0, %d(R1)", form.op, suffix, off)
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD base+0(FP), R1\nMOVD R1, R0\nMOVD value+8(FP), R2\nMOVD out+16(FP), R3\n%s\n", name, instruction)
+					if !store {
+						source.WriteString("MOVD R4, (R3)\n")
+					}
+					source.WriteString("SUB R0, R1, R5\nMOVD R5, ret+24(FP)\nRET\n")
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64, Ptr}, Ret: I64, Frame: FrameLayout{
+						Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}, {Offset: 16, Type: Ptr, Index: 2, Field: -1}},
+						Results: []FrameSlot{{Offset: 24, Type: I64, Index: 0, Field: -1}},
+					}}
+					fmt.Fprintf(&declarations, "extern int64_t %s(unsigned char *, uint64_t, uint64_t *);\n", name)
+					fmt.Fprintf(&goDeclarations, "func %s(base *byte, value uint64, out *uint64) int64\n", name)
+					addressOff := off
+					baseDelta := off
+					if suffix == ".P" {
+						addressOff = 0
+					}
+					if suffix == "" {
+						baseDelta = 0
+					}
+					fmt.Fprintf(&goChecks, "{\nvar buffer, expected [128]byte\nfor i := range buffer { buffer[i] = byte(i*13 + 131) }\nexpected = buffer\nvar observed, want uint64\nvalue := uint64(0xfedcba9876543210)\n")
+					if access.zero {
+						goChecks.WriteString("value = 0\n")
+					}
+					if store {
+						fmt.Fprintf(&goChecks, "for i := 0; i < %d; i++ { expected[%d+i] = byte(value >> (8*i)) }\n", form.bits/8, 64+addressOff)
+					} else {
+						fmt.Fprintf(&goChecks, "for i := 0; i < %d; i++ { want |= uint64(buffer[%d+i]) << (8*i) }\n", form.bits/8, 64+addressOff)
+						if form.signed {
+							fmt.Fprintf(&goChecks, "want = uint64(int64(int%d(want)))\n", form.bits)
+						}
+					}
+					fmt.Fprintf(&goChecks, "delta := %s(&buffer[64], value, &observed)\nif delta != %d || observed != want || buffer != expected { println(\"%s\", delta, observed, want); panic(\"Go scalar writeback oracle\") }\n}\n", name, baseDelta, instruction)
+					fmt.Fprintf(&checks, "  { /* %s */\n    unsigned char bytes[128], expected[128];\n    for (unsigned i = 0; i < sizeof bytes; i++) bytes[i] = (unsigned char)(i * 13 + 131);\n    memcpy(expected, bytes, sizeof bytes);\n    uint64_t observed = 0, want = 0, value = UINT64_C(0xfedcba9876543210);\n", instruction)
+					if access.zero {
+						checks.WriteString("    value = 0;\n")
+					}
+					if store {
+						fmt.Fprintf(&checks, "    memcpy(expected + %d, &value, %d);\n", 64+addressOff, form.bits/8)
+					} else {
+						fmt.Fprintf(&checks, "    memcpy(&want, bytes + %d, %d);\n", 64+addressOff, form.bits/8)
+						if form.signed {
+							fmt.Fprintf(&checks, "    want = (uint64_t)(int64_t)(int%d_t)want;\n", form.bits)
+						}
+					}
+					fmt.Fprintf(&checks, "    int64_t delta = %s(bytes + 64, value, &observed);\n    if (delta != %d || observed != want || memcmp(bytes, expected, sizeof bytes)) { fprintf(stderr, \"%s delta=%%lld want=%d observed=%%llx expected=%%llx\\n\", (long long)delta, (unsigned long long)observed, (unsigned long long)want); return 1; }\n  }\n", name, baseDelta, instruction, baseDelta)
+				}
+			}
+		}
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	goSource := "package main\n" + goDeclarations.String() + "func main() {\n" + goChecks.String() + "}\n"
+	arm64ScalarWritebackGoOracle(t, source.String(), goSource, len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "scalar_writeback", triple, ir, main, runner)
+}
+
+func arm64ScalarWritebackGoOracle(t *testing.T, source, main string, cross bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":         "module scalarwritebackoracle\n\ngo 1.20\n",
+		"main.go":        main,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT scalar_wb_", "TEXT ·scalar_wb_"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run", "-p=2", "."}
+	env := append(os.Environ(), "GOARCH=arm64", "CGO_ENABLED=0")
+	if cross {
+		args = []string{"run", "-p=2", "-exec=qemu-aarch64", "."}
+		env = append(env, "GOOS=linux")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", args...)
+	cmd.Dir, cmd.Env = dir, env
+	if out, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("native Go scalar writeback oracle: %v\n%s", err, out)
+	}
+}
diff --git a/arm64_scheduler_hook_control_test.go b/arm64_scheduler_hook_control_test.go
new file mode 100644
index 000000000..a3c37652e
--- /dev/null
+++ b/arm64_scheduler_hook_control_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These are the unmodified two functions and declarations from x/sys v0.18.0
+// unix/asm_linux_arm64.s and unix/syscall_linux_gc.go. The complete original
+// files have SHA-256 9d1514c08da093cd38b77f03ff5fe265c16500a42295b32c66509dc828a34045
+// and 41a54001d221205e9f1538066105b46c08cd329e85d4529426063961daa86235.
+const arm64OriginalNoErrorSyscalls = `TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
+	BL	runtime·entersyscall(SB)
+	MOVD	a1+8(FP), R0
+	MOVD	a2+16(FP), R1
+	MOVD	a3+24(FP), R2
+	MOVD	$0, R3
+	MOVD	$0, R4
+	MOVD	$0, R5
+	MOVD	trap+0(FP), R8
+	SVC
+	MOVD	R0, r1+32(FP)
+	MOVD	R1, r2+40(FP)
+	BL	runtime·exitsyscall(SB)
+	RET
+
+TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
+	MOVD	a1+8(FP), R0
+	MOVD	a2+16(FP), R1
+	MOVD	a3+24(FP), R2
+	MOVD	$0, R3
+	MOVD	$0, R4
+	MOVD	$0, R5
+	MOVD	trap+0(FP), R8
+	SVC
+	MOVD	R0, r1+32(FP)
+	MOVD	R1, r2+40(FP)
+	RET
+`
+
+func requireARM64SchedulerHookGoObject(t *testing.T, source string) {
+	t.Helper()
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // Old-Go lanes still execute the API and LLVM object tests.
+	}
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "syscalls.s"), filepath.Join(dir, "syscalls.o")
+	if err := os.WriteFile(input, []byte("#include \"textflag.h\"\n"+source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-S", "-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-p", "golang.org/x/sys/unix", "-o", output, input)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("original Go source object failed: %v\n%s", err, out)
+	}
+	if strings.Contains(source, "TEXT ·SyscallNoError") {
+		listing := strings.Join(strings.Fields(string(out)), " ")
+		for _, want := range []string{"MOVD.W R30, -16(RSP)", "MOVD.P 16(RSP), R30"} {
+			if !strings.Contains(listing, want) {
+				t.Fatalf("Go's nonleaf zero-TEXT-frame must save and restore the caller LR; missing %q:\n%s", want, out)
+			}
+		}
+	}
+	info, err := os.Stat(output)
+	if err != nil || info.Size() == 0 {
+		t.Fatalf("Go assembler did not create an object: %v", err)
+	}
+}
+
+func TestARM64SchedulerHookOriginalSyscallReturn(t *testing.T) {
+	pkg := mustGoPackage(t, "golang.org/x/sys/unix", `package unix
+func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+`)
+	requireARM64SchedulerHookGoObject(t, arm64OriginalNoErrorSyscalls)
+
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, call := range []string{"BL", "CALL"} {
+		source := strings.ReplaceAll(arm64OriginalNoErrorSyscalls, "BL\t", call+"\t")
+		requireARM64SchedulerHookGoObject(t, source)
+		for _, triple := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+			t.Run(call+"/"+triple, func(t *testing.T) {
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOOS: "linux", GOARCH: "arm64", TargetTriple: triple,
+					ResolveSym: testResolveSym(pkg.Path),
+				})
+				if triple != "aarch64-unknown-linux-gnu" && triple != "aarch64-unknown-linux-musl" {
+					if tr != nil && !tr.Module.IsNil() {
+						tr.Module.Dispose()
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("Linux bare-SVC source cannot acquire another target's syscall ABI: %v", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer tr.Module.Dispose()
+				ir := tr.Module.String()
+				for _, line := range strings.Split(ir, "\n") {
+					if strings.Contains(line, " call ") && (strings.Contains(line, "runtime.entersyscall") || strings.Contains(line, "runtime.exitsyscall")) {
+						t.Fatal("elided scheduler hooks must not become native calls")
+					}
+				}
+				if len(tr.Signatures[pkg.Path+".SyscallNoError"].Frame.Params) != 4 || len(tr.Signatures[pkg.Path+".SyscallNoError"].Frame.Results) != 2 {
+					t.Fatal("original Go declaration must supply the actual ABI0 frame")
+				}
+				compileLLVMToObject(t, llc, triple, "no-error-syscalls.ll", "no-error-syscalls.o", ir)
+			})
+		}
+	}
+}
+
+func TestARM64SchedulerHookUnknownCalleeStillInvalidatesReturn(t *testing.T) {
+	pkg := mustGoPackage(t, "golang.org/x/sys/unix", `package unix
+func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+`)
+	for _, name := range []string{"runtime·entersyscall", "runtime·exitsyscall"} {
+		for _, unknown := range []string{"runtime·entersyscallblock", "other·entersyscall", "runtime·exitsyscallfast", name + "+4"} {
+			t.Run(name+"/"+unknown, func(t *testing.T) {
+				source := strings.Replace(arm64OriginalNoErrorSyscalls, name+"(SB)", unknown+"(SB)", 1)
+				requireARM64SchedulerHookGoObject(t, source)
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					ResolveSym: testResolveSym(pkg.Path),
+				})
+				if err == nil {
+					tr.Module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("untyped native call must keep the caller-LR gap: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SchedulerHookLoweringHasNoMachineCallEffect(t *testing.T) {
+	for _, name := range []string{"runtime.entersyscall", "runtime.exitsyscall"} {
+		t.Run(name, func(t *testing.T) {
+			flow := &arm64MachineAvailability{blocks: make([]arm64MachineBlock, 1)}
+			ctx, ir := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "example.f", Ret: Void}, nil)
+			ctx.machineAvailability = flow
+			before := ir.String()
+			if err := ctx.callSym(Operand{Kind: OpSym, Sym: name + "(SB)"}); err != nil {
+				t.Fatal(err)
+			}
+			if ir.String() != before || len(flow.blocks[0].effects) != 0 {
+				t.Fatalf("an elided hook has neither emitted call nor virtual register effect: %q, %+v", ir.String()[len(before):], flow.blocks[0].effects)
+			}
+		})
+	}
+}
+
+func TestARM64SchedulerHookDoesNotRepairSourceContinuation(t *testing.T) {
+	for _, mutation := range []string{
+		"MOVD $0,0(RSP)",
+		"MOVD RSP,R20\nMOVD $0,(R20)",
+		"SUB $16,RSP",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			source := "TEXT ·stub(SB),NOSPLIT,$0-0\nBL runtime·entersyscall(SB)\n" + mutation + "\nBL runtime·exitsyscall(SB)\nRET\n"
+			requireARM64SchedulerHookGoObject(t, source)
+			pkg := mustGoPackage(t, "example.com/hooks", "package hooks\nfunc stub()\n")
+			tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				ResolveSym: testResolveSym(pkg.Path),
+			})
+			if err == nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("no-op hooks cannot repair a source-clobbered continuation: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64SchedulerHookSyscallFrameExposureRemainsContext(t *testing.T) {
+	pkg := mustGoPackage(t, "golang.org/x/sys/unix", `package unix
+func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+`)
+	for _, exposure := range []string{
+		"MOVD RSP,R1",
+		"MOVD RSP,R20\nMOVD R20,R1",
+		"MOVD R30,R1\nADD $1,R1",
+	} {
+		t.Run(exposure, func(t *testing.T) {
+			source := strings.Replace(arm64OriginalNoErrorSyscalls, "\tSVC\n", exposure+"\n\tSVC\n", 1)
+			requireARM64SchedulerHookGoObject(t, source)
+			tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				ResolveSym: testResolveSym(pkg.Path),
+			})
+			if err == nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved native syscall frame effects must remain context: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64SchedulerHookSyscallResultsCannotReestablishContinuation(t *testing.T) {
+	pkg := mustGoPackage(t, "golang.org/x/sys/unix", `package unix
+func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
+`)
+	for _, reg := range []string{"R0", "R1"} {
+		for _, svc := range []string{"SVC", "SVC $0"} {
+			t.Run(reg+"/"+svc, func(t *testing.T) {
+				replacement := "MOVD 0(RSP)," + reg + "\n" + svc + "\nMOVD " + reg + ",0(RSP)\n"
+				source := strings.Replace(arm64OriginalNoErrorSyscalls, "\tSVC\n", replacement, 1)
+				requireARM64SchedulerHookGoObject(t, source)
+				tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+					GOOS: "linux", GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					ResolveSym: testResolveSym(pkg.Path),
+				})
+				if err == nil {
+					tr.Module.Dispose()
+				}
+				if reg == "R0" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("new Linux R0 result is not the old caller continuation: %v", err)
+				}
+				if reg == "R1" && err != nil {
+					t.Fatalf("untouched Linux R1 lost its original saved caller continuation: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_single_route_test.go b/arm64_single_route_test.go
new file mode 100644
index 000000000..28b5291b7
--- /dev/null
+++ b/arm64_single_route_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64TinyFunctionsCannotBypassCallerLinkProof(t *testing.T) {
+	pkg := mustGoPackage(t, "test/tinycontrol", "package tinycontrol\nfunc F()\n")
+	for _, body := range []string{
+		"MOVD $0,R30\nRET",
+		"MOVD R0,R30\nRET",
+		"MOVD R30,R0\nMOVD R1,R30\nRET",
+	} {
+		source := "TEXT ·F(SB),4,$0-0\n" + body + "\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+		} {
+			options := Options{Goarch: "arm64", TargetTriple: triple,
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+				Sigs:       map[string]FuncSig{"F": {Name: "F", Ret: Void}}}
+			_, err := Translate(file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("text / %s / %s accepted changed caller LR: %v", triple, body, err)
+			}
+			ctx := llvm.NewContext()
+			mod, err := TranslateModuleInContext(ctx, file, options)
+			if err == nil {
+				mod.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("module / %s / %s accepted changed caller LR: %v", triple, body, err)
+			}
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: triple, ResolveSym: options.ResolveSym,
+			})
+			if err == nil {
+				translated.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("Go module / %s / %s accepted changed caller LR: %v", triple, body, err)
+			}
+		}
+	}
+}
+
+func TestARM64TinyDirectPrototypeRequiresArchitectureProof(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT F(SB),4,$0-0\nMOVD $7,R0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod, err := translateModuleDirect(file, Options{Goarch: "arm64",
+		Sigs: map[string]FuncSig{"F": {Name: "F", Ret: I64}}})
+	if err == nil {
+		mod.Dispose()
+	}
+	if !errors.Is(err, errDirectModuleUnsupported) {
+		t.Fatalf("legacy direct ARM64 prototype must request architecture-aware fallback: %v", err)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64TinyCallerLinkRoundTrip(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = `TEXT ·tinyRoundTrip(SB),4,$0-16
+MOVD a+0(FP),R0
+MOVD R30,R9
+MOVD R9,R30
+MOVD R0,ret+8(FP)
+RET
+`
+	const goMain = `package main
+func tinyRoundTrip(uint64) uint64
+func main() {
+    for _, a := range []uint64{0, 1, 123, 0x8000000000000000, ^uint64(0)} {
+        if tinyRoundTrip(a) != a { panic("tiny caller link round trip") }
+    }
+}
+`
+	runARM64LocalRegisterGoOracle(t, source, goMain, len(runner) != 0)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "tinyRoundTrip", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		Sigs:       map[string]FuncSig{"tinyRoundTrip": sig}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const cMain = `#include <stdint.h>
+extern uint64_t tinyRoundTrip(uint64_t);
+int main(void) {
+    const uint64_t values[] = {0, 1, 123, UINT64_C(0x8000000000000000), UINT64_MAX};
+    for (unsigned i = 0; i < 5; i++) {
+        if (tinyRoundTrip(values[i]) != values[i]) return 1;
+    }
+    return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "tiny_caller_link", triple, ir, cMain, runner)
+}
diff --git a/arm64_sm3_runtime_test.go b/arm64_sm3_runtime_test.go
new file mode 100644
index 000000000..485ee30f7
--- /dev/null
+++ b/arm64_sm3_runtime_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func arm64SM3RuntimeFixture(t *testing.T) (*File, map[string]FuncSig, string, string, string) {
+	t.Helper()
+	var source, goDeclarations, goChecks, cDeclarations, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, tc := range arm64SM3AliasCases() {
+		source.WriteString(arm64SM3Fixture(tc.name, tc.word))
+		sigs[tc.name] = arm64SM3Signature(tc.name)
+		fmt.Fprintf(&goDeclarations, "func %s(*[128]uint32, *[132]uint32)\n", tc.name)
+		fmt.Fprintf(&goChecks, "check(%s,%d,%d,%d,%d,%d,%d)\n", tc.name, tc.kind, tc.d, tc.n, tc.m, tc.a, tc.lane)
+		fmt.Fprintf(&cDeclarations, "extern void %s(const uint32_t *, uint32_t *);\n", tc.name)
+		fmt.Fprintf(&cChecks, "if(check(%s,%d,%d,%d,%d,%d,%d)) return 1;\n", tc.name, tc.kind, tc.d, tc.n, tc.m, tc.a, tc.lane)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goMain := arm64SM3OracleGo + goDeclarations.String() + "func main(){\n" + goChecks.String() + "}\n"
+	cMain := arm64SM3OracleC + cDeclarations.String() + "int main(void){\n" + cChecks.String() + "return 0;\n}\n"
+	return file, sigs, source.String(), goMain, cMain
+}
+
+func TestARM64RawSM3PortableRuntimeSemantics(t *testing.T) {
+	// This executes the lowered arithmetic, not the original SM3 instruction.
+	// The separate mandatory Linux/QEMU test executes the original Go WORD.
+	if runtime.GOARCH != "arm64" || runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+		t.Skip("portable ARM64 execution is also covered by the required cross matrix")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	file, sigs, _, _, main := arm64SM3RuntimeFixture(t)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "raw_sm3_portable", triple, ir, main, nil)
+	t.Log("LLVM arithmetic / independent C: 105 register-alias/lane cases x 256 inputs, all vectors/NZCV/canaries")
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SM3(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("original SM3 WORD execution belongs to the required Linux/QEMU matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("SM3 cross-runtime driver requires Linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"qemu-aarch64", "aarch64-linux-gnu-gcc"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required SM3 cross-runtime tool %s: %v", tool, err)
+		}
+	}
+	t.Setenv("QEMU_CPU", "max")
+	file, sigs, source, goMain, cMain := arm64SM3RuntimeFixture(t)
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module sm3raworacle\n\ngo 1.20\n", "main.go": goMain,
+		"oracle_arm64.s": strings.ReplaceAll(source, "TEXT sm3case", "TEXT ·sm3case"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "run", "-p=1", "-exec=qemu-aarch64", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go SM3 raw WORD / independent Go scalar oracle: %v\n%s", err, output)
+	}
+	t.Log("actual Go raw WORD / independent Go scalar: 105 alias/lane cases x 256 inputs, all vectors/NZCV/canaries")
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "raw_sm3_cross", triple, ir, cMain,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+	t.Log("LLVM22 / independent C scalar oracle passed the same 26880 cases")
+}
+
+const arm64SM3OracleGo = `package main
+import "math/bits"
+func reference(kind,lane int,d,n,m,a [4]uint32) (out [4]uint32) {
+ rol:=bits.RotateLeft32
+ p1:=func(x uint32)uint32{return x^rol(x,15)^rol(x,23)}
+ switch kind {
+ case 0:
+  for i:=0;i<3;i++ {out[i]=p1(d[i]^n[i]^rol(m[i+1],15))}
+  out[3]=p1(d[3]^n[3]^rol(out[0],15))
+ case 1:
+  var x [4]uint32
+  for i:=range x {x[i]=n[i]^rol(m[i],7);out[i]=d[i]^x[i]}
+  out[3]^=p1(rol(x[0],15))
+ case 2: out[3]=rol(rol(n[3],12)+m[3]+a[3],7)
+ default:
+  x:=d[3]^d[2]^d[1]
+  if kind==4 {x=(d[3]&d[2])|(d[3]&d[1])|(d[2]&d[1])}
+  if kind==6 {x=(d[3]&d[2])|(^d[3]&d[1])}
+  ss:=n[3]; rotation:=19
+  if kind==3||kind==4 {ss^=rol(d[3],12);rotation=9}
+  x+=d[0]+ss+m[lane]
+  if rotation==19 {x^=rol(x,9)^rol(x,17)}
+  out=[4]uint32{d[1],rol(d[2],rotation),d[3],x}
+ }
+ return
+}
+func check(fn func(*[128]uint32,*[132]uint32),kind,d,n,m,a,lane int) {
+ var input [128]uint32
+ var got,want [132]uint32
+ seed:=uint32(0x12345678)
+ var seenZero,seenOne uint32
+ for trial:=0;trial<256;trial++ {
+  for i:=range input {
+   seed=seed*1664525+1013904223
+   input[i]=seed
+   if trial==0 {input[i]=0}
+   if trial==1 {input[i]=0xffffffff}
+   if trial>=2&&trial<130 {input[i]=0;if i==trial-2 {input[i]=1<<uint(i%32)}}
+  }
+  for i:=range got {got[i]=0xa5a5a5a5;want[i]=0xa5a5a5a5}
+  copy(want[:128],input[:])
+  vector:=func(r int)(v [4]uint32){copy(v[:],input[r*4:r*4+4]);return}
+  out:=reference(kind,lane,vector(d),vector(n),vector(m),vector(a))
+  copy(want[d*4:d*4+4],out[:])
+  left:=uint64(input[0])|uint64(input[1])<<32
+  right:=uint64(input[2])|uint64(input[3])<<32
+  sum,carry:=bits.Add64(left,right,0)
+  flags:=uint32(sum>>63)|uint32(carry)<<2|uint32(((left^sum)&(right^sum))>>63)<<3
+  if sum==0 {flags|=2}
+  want[128]=flags;want[129]=0
+  seenZero|=(^flags)&15;seenOne|=flags
+  fn(&input,&got)
+  if got!=want {println(kind,d,n,m,a,lane,trial);panic("Go SM3 raw result/source/NZCV/canary mismatch")}
+ }
+ if seenZero!=15||seenOne!=15 {panic("SM3 oracle did not exercise both values of every NZCV flag")}
+}
+`
+
+const arm64SM3OracleC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static uint32_t rol(uint32_t x,unsigned n){return (x<<n)|(x>>(32-n));}
+static uint32_t p1(uint32_t x){return x^rol(x,15)^rol(x,23);}
+static void reference(uint32_t out[4],int kind,int lane,const uint32_t d[4],
+                      const uint32_t n[4],const uint32_t m[4],const uint32_t a[4]) {
+ if(kind==0) {
+  for(unsigned i=0;i<3;i++) out[i]=p1(d[i]^n[i]^rol(m[i+1],15));
+  out[3]=p1(d[3]^n[3]^rol(out[0],15));
+ } else if(kind==1) {
+  uint32_t x[4];
+  for(unsigned i=0;i<4;i++){x[i]=n[i]^rol(m[i],7);out[i]=d[i]^x[i];}
+  out[3]^=p1(rol(x[0],15));
+ } else if(kind==2) {
+  out[0]=out[1]=out[2]=0;
+  out[3]=rol(rol(n[3],12)+m[3]+a[3],7);
+ } else {
+  uint32_t boolean=d[3]^d[2]^d[1],ss=n[3];
+  if(kind==4) boolean=(d[3]&d[2])|(d[3]&d[1])|(d[2]&d[1]);
+  if(kind==6) boolean=(d[3]&d[2])|(~d[3]&d[1]);
+  unsigned rotation=19;
+  if(kind==3||kind==4){ss^=rol(d[3],12);rotation=9;}
+  uint32_t x=boolean+d[0]+ss+m[lane];
+  out[0]=d[1];out[1]=rol(d[2],rotation);out[2]=d[3];
+  out[3]=rotation==19 ? x^rol(x,9)^rol(x,17) : x;
+ }
+}
+static int check(void(*fn)(const uint32_t *,uint32_t *),int kind,int d,int n,int m,int a,int lane) {
+ uint32_t input[128],got[132],want[132],out[4],seed=0x12345678;
+ uint32_t seen_zero=0,seen_one=0;
+ for(unsigned trial=0;trial<256;trial++) {
+  for(unsigned i=0;i<128;i++) {
+   seed=seed*1664525U+1013904223U;
+   input[i]=seed;
+   if(trial==0) input[i]=0;
+   if(trial==1) input[i]=UINT32_MAX;
+   if(trial>=2&&trial<130) input[i]=i==trial-2 ? UINT32_C(1)<<(i%32) : 0;
+  }
+  for(unsigned i=0;i<132;i++) got[i]=want[i]=UINT32_C(0xa5a5a5a5);
+  memcpy(want,input,sizeof(input));
+  reference(out,kind,lane,input+4*d,input+4*n,input+4*m,input+4*a);
+  memcpy(want+4*d,out,sizeof(out));
+  uint64_t left=(uint64_t)input[0]|(uint64_t)input[1]<<32;
+  uint64_t right=(uint64_t)input[2]|(uint64_t)input[3]<<32;
+  uint64_t sum=left+right;
+  uint32_t flags=(uint32_t)(sum>>63)|((uint32_t)(sum==0)<<1)|
+                 ((uint32_t)(sum<left)<<2)|((uint32_t)(((left^sum)&(right^sum))>>63)<<3);
+  want[128]=flags;want[129]=0;
+  seen_zero|=(~flags)&15;seen_one|=flags;
+  fn(input,got);
+  if(memcmp(got,want,sizeof(got))) {
+   fprintf(stderr,"SM3 kind=%d d=%d n=%d m=%d a=%d lane=%d trial=%u\n",kind,d,n,m,a,lane,trial);
+   return 1;
+  }
+ }
+ if(seen_zero!=15||seen_one!=15){fprintf(stderr,"SM3 NZCV inputs lack flag coverage\n");return 1;}
+ return 0;
+}
+`
diff --git a/arm64_sm4_cross_test.go b/arm64_sm4_cross_test.go
new file mode 100644
index 000000000..4f1bb205a
--- /dev/null
+++ b/arm64_sm4_cross_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// FEAT_SM4 is not universally available on ARM64 hosts. Execute it on the
+// required Linux/QEMU CPU=max matrix, not an optional host-feature probe.
+func TestCrossLinuxRuntimeMatrixARM64SM4(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("SM4 execution belongs to the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, tool := range []string{"aarch64-linux-gnu-gcc", "qemu-aarch64"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", tool, err)
+		}
+	}
+
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	for _, op := range []string{"sm4e", "sm4ekey"} {
+		// Independent registers, each possible destination/source alias, source
+		// aliasing and all-equal. Rotate through the complete V0..V31 range.
+		aliases := [][3]int{{0, 1, 2}, {0, 0, 1}, {0, 1, 0}, {0, 1, 1}, {0, 0, 0}}
+		if op == "sm4e" {
+			aliases = [][3]int{{0, 0, 1}, {0, 0, 0}}
+		}
+		for offset := 0; offset < 32; offset++ {
+			for _, alias := range aliases {
+				d, n, m := (offset+alias[0])%32, (offset+alias[1])%32, (offset+alias[2])%32
+				name := fmt.Sprintf("sm4case%d", index)
+				index++
+				word := uint32(0xce60c800 | m<<16 | n<<5 | d)
+				key := 1
+				if op == "sm4e" {
+					word = uint32(0xcec08400 | m<<5 | d)
+					key = 0
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVD in+0(FP),R0\nMOVD out+8(FP),R1\n", name)
+				// Save all physical vectors to check both the result and untouched
+				// source/neighbor registers, rather than observing just one lane.
+				for r := 0; r < 32; r++ {
+					fmt.Fprintf(&source, "VLD1.P 16(R0),[V%d.S4]\n", r)
+				}
+				source.WriteString("CMP $0,R0\n")
+				fmt.Fprintf(&source, "WORD $%#08x\n", word)
+				for r := 0; r < 32; r++ {
+					fmt.Fprintf(&source, "VST1.P [V%d.S4],16(R1)\n", r)
+				}
+				// SM4 must preserve NZCV; R0 is a non-null advanced input pointer.
+				source.WriteString("CSET NE,R2\nMOVD R2,(R1)\nRET\n")
+				sigs[name] = FuncSig{
+					Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					}},
+				}
+				fmt.Fprintf(&declarations, "extern void %s(const uint32_t *, uint32_t *);\n", name)
+				fmt.Fprintf(&checks, "    if (check(%s, %d, %d, %d, %d)) return 1;\n", name, d, n, m, key)
+			}
+		}
+	}
+	if index != 224 {
+		t.Fatalf("generated %d cases, want 224", index)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mainC := arm64SM4OracleC + declarations.String() + "\nint main(void) {\n" + checks.String() + "    return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc,
+		[]string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sm4"}, "sm4_semantics", triple, ir, mainC,
+		[]string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+}
+
+const arm64SM4OracleC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static const uint8_t sbox[256] = {
+    0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05,
+    0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99,
+    0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62,
+    0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6,
+    0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8,
+    0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35,
+    0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87,
+    0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e,
+    0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1,
+    0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3,
+    0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f,
+    0xd5,0xdb,0x37,0x45,0xde,0xfd,0x8e,0x2f,0x03,0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51,
+    0x8d,0x1b,0xaf,0x92,0xbb,0xdd,0xbc,0x7f,0x11,0xd9,0x5c,0x41,0x1f,0x10,0x5a,0xd8,
+    0x0a,0xc1,0x31,0x88,0xa5,0xcd,0x7b,0xbd,0x2d,0x74,0xd0,0x12,0xb8,0xe5,0xb4,0xb0,
+    0x89,0x69,0x97,0x4a,0x0c,0x96,0x77,0x7e,0x65,0xb9,0xf1,0x09,0xc5,0x6e,0xc6,0x84,
+    0x18,0xf0,0x7d,0xec,0x3a,0xdc,0x4d,0x20,0x79,0xee,0x5f,0x3e,0xd7,0xcb,0x39,0x48
+};
+
+static uint32_t rotate(uint32_t x, unsigned n) {
+    return (x << n) | (x >> (32 - n));
+}
+
+// Four rounds, with word/byte order explicitly matching Arm DDI 0602.
+static void reference(uint32_t out[4], const uint32_t in[4], const uint32_t constants[4], int key) {
+    uint32_t state[8];
+    memcpy(state, in, 16);
+    for (unsigned round = 0; round < 4; round++) {
+        uint32_t x = state[round + 1] ^ state[round + 2] ^ state[round + 3] ^ constants[round];
+        uint32_t y = 0;
+        for (unsigned byte = 0; byte < 4; byte++) {
+            y |= (uint32_t)sbox[(x >> (8 * byte)) & 255] << (8 * byte);
+        }
+        uint32_t linear = key ? y ^ rotate(y, 13) ^ rotate(y, 23)
+                              : y ^ rotate(y, 2) ^ rotate(y, 10) ^ rotate(y, 18) ^ rotate(y, 24);
+        state[round + 4] = state[round] ^ linear;
+    }
+    memcpy(out, state + 4, 16);
+}
+
+typedef uint32_t words __attribute__((vector_size(16)));
+
+static void native(uint32_t out[4], const uint32_t in[4], const uint32_t constants[4], int key) {
+    words a, b, result;
+    memcpy(&a, in, 16);
+    memcpy(&b, constants, 16);
+    if (key) {
+        __asm__("sm4ekey %0.4s, %1.4s, %2.4s" : "=w"(result) : "w"(a), "w"(b));
+    } else {
+        result = a;
+        __asm__("sm4e %0.4s, %1.4s" : "+w"(result) : "w"(b));
+    }
+    memcpy(out, &result, 16);
+}
+
+static int check(void (*fn)(const uint32_t *, uint32_t *), int d, int n, int m, int key) {
+    uint32_t input[128], expected[130], actual[130], hardware[4];
+    uint32_t seed = 0x12345678;
+    for (unsigned trial = 0; trial < 256; trial++) {
+        for (unsigned i = 0; i < 128; i++) {
+            seed = seed * 1664525U + 1013904223U;
+            input[i] = trial == 0 ? 0 : trial == 1 ? UINT32_MAX : seed;
+        }
+        memcpy(expected, input, sizeof(input));
+        expected[128] = 1;
+        expected[129] = 0;
+        reference(expected + 4 * d, input + 4 * n, input + 4 * m, key);
+        native(hardware, input + 4 * n, input + 4 * m, key);
+        if (memcmp(hardware, expected + 4 * d, 16)) {
+            fprintf(stderr, "SM4 reference/native mismatch key=%d trial=%u\n", key, trial);
+            return 1;
+        }
+        memset(actual, 0xa5, sizeof(actual));
+        fn(input, actual);
+        if (memcmp(actual, expected, sizeof(actual))) {
+            fprintf(stderr, "SM4 translated mismatch key=%d d=%d n=%d m=%d trial=%u\n", key, d, n, m, trial);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/arm64_source_frame_r20.go b/arm64_source_frame_r20.go
new file mode 100644
index 000000000..aaab1cd12
--- /dev/null
+++ b/arm64_source_frame_r20.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import "strings"
+
+// Go obj7's large-frame prologue assigns R20 before entering the source body:
+// SUB autosize,SP,R20; STP (BP,LR),-8(R20); MOVD R20,SP. This is the new
+// private SP root, not an arbitrary incoming pointer or the native caller SP.
+// Keep this producer tied to the complete source TEXT contract.
+func arm64SourceFrameR20(fn Func) bool {
+	if !arm64SourceFrameR20Candidate(fn) {
+		return false
+	}
+	texts := 0
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpTEXT {
+			continue
+		}
+		texts++
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) < 2 || len(parts) > 3 {
+			return false
+		}
+		// An omitted args suffix is Go's ArgsSizeUnknown, not an explicit
+		// zero-sized caller frame (the parser retains zero for both).
+		spec := strings.TrimSpace(parts[len(parts)-1])
+		if !strings.HasPrefix(spec, "$") || strings.LastIndex(spec, "-") <= 1 {
+			return false
+		}
+		size, args, err := parseTEXTFrame(parts)
+		if err != nil || size != fn.FrameSize || args != fn.ArgSize {
+			return false
+		}
+	}
+	return texts == 1
+}
+
+// Only a large source-leaf frame may require the separate R20 producer. A
+// software definition in an ordinary small function must not replace its
+// existing stack/control proof with the framed raw-leaf proof.
+//
+// Keep malformed or incomplete large TEXT metadata on this checked path:
+// arm64SourceFrameR20 must independently establish the complete producer before
+// R20 becomes available. An omitted argument suffix cannot turn that read into
+// an unchecked, zero-initialized virtual register.
+func arm64SourceFrameR20Required(fn Func) bool {
+	return arm64SourceFrameR20Candidate(fn) && arm64SourceUsesR20(fn)
+}
+
+// This is only a cost/routing predicate, not permission to initialize R20.
+// Larger dynamic allocations, ordinary nonleaf calls and existing source-local
+// register helpers keep their own stack and entry contracts.
+func arm64SourceFrameR20Candidate(fn Func) bool {
+	frame := arm64SourceGoFrame(fn)
+	return frame.present && !frame.restoresLink && arm64SourceFrameFlagsKnown(fn) &&
+		fn.FrameSize > 0 && fn.FrameSize <= arm64MaxLocalStackSpan && fn.FrameSize&7 == 0 &&
+		arm64SourceFrameAutosize(fn.FrameSize) > 0xf0
+}
+
+// The bounded scalar-word transport requires reaching definitions even when
+// software overwrites R20. Other existing entry contracts retain their own
+// availability checks; legacy format-only signatures acquire no new contract.
+func arm64SourceFrameR20Checked(fn Func, sig FuncSig, resolve func(string) string) bool {
+	return arm64SourceUsesR20(fn) && (arm64SourceFrameR20Required(fn) ||
+		(len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0) &&
+			arm64SourceFrameR20Transport(fn, &arm64PrivateFrameTransport{entry: sig, resolve: resolve}))
+}
+
+func arm64SourceUsesR20(fn Func) bool {
+	for _, original := range fn.Instrs {
+		ins := arm64ControlDecode(original)
+		for _, arg := range ins.Args {
+			regs := []Reg{arg.Reg, arg.ShiftReg, arg.Mem.Base, arg.Mem.Index}
+			regs = append(regs, arg.RegList...)
+			if arg.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(arg.Sym), "$") {
+				if mem, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$"))); ok {
+					regs = append(regs, mem.Base, mem.Index)
+				}
+			}
+			for _, reg := range regs {
+				if arm64MachineRegister(reg) == "R20" {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+// This bounded family uses the ordinary complete ABI0 scalar-word frame,
+// including explicit result slots. A manual equivalent must be just as
+// complete; no default/fallback signature, hidden context, custom register ABI
+// or aggregate layout grants dead-scratch transport at RET.
+func arm64SourceFrameR20Transport(fn Func, transport *arm64PrivateFrameTransport) bool {
+	if transport == nil || fn.arm64PrivateRegisterEntry || strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return false
+	}
+	sig := transport.entry
+	name := fn.Sym
+	if transport.resolve != nil {
+		name = transport.resolve(name)
+	}
+	if sig.Name != name || len(sig.ArgRegs) != 0 || sig.ARM64GoRegisterABI != nil ||
+		sig.ARM64ClosureABI != nil || sig.ARMEntry != nil || sig.WASMContext != "" || sig.WASMNative ||
+		len(sig.Frame.Params) != len(sig.Args) {
+		return false
+	}
+	for index, typ := range sig.Args {
+		if !arm64SourceFrameR20Scalar(typ) || !arm64SourceFrameR20Slot(sig.Frame.Params[index], typ, index, int64(index)*8) {
+			return false
+		}
+	}
+	bytes := int64(len(sig.Args)) * 8
+	if sig.Ret == Void {
+		if len(sig.Frame.Results) != 0 {
+			return false
+		}
+	} else {
+		// Floating FP-slot fallback currently reads a GP ordinal, whereas
+		// typed call results use the FP bank. Do not borrow that separate
+		// unfinished result contract to make a private address dead.
+		if (sig.Ret != I64 && sig.Ret != Ptr) || len(sig.Frame.Results) != 1 ||
+			!arm64SourceFrameR20Slot(sig.Frame.Results[0], sig.Ret, 0, bytes) {
+			return false
+		}
+		bytes += 8
+	}
+	if bytes != fn.ArgSize {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpTEXT {
+			continue
+		}
+		_, rest := splitOpcode(ins.Raw)
+		parts := strings.Split(rest, ",")
+		if len(parts) == 3 {
+			expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+				if value, ok := goTextFlagValues[name]; ok {
+					return value
+				}
+				return name
+			})
+			flags, known := parseImmExpr(expression)
+			if !known || flags&64 != 0 { // NEEDCTXT is an unproved hidden input.
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func arm64SourceFrameR20Scalar(typ LLVMType) bool {
+	return typ == I64 || typ == Ptr || typ == "double"
+}
+
+func arm64SourceFrameR20Slot(slot FrameSlot, typ LLVMType, index int, offset int64) bool {
+	return slot.Type == typ && slot.Index == index && slot.Offset == offset &&
+		slot.Field == -1 && len(slot.Fields) == 0
+}
diff --git a/arm64_source_noop_call.go b/arm64_source_noop_call.go
new file mode 100644
index 000000000..e8be34c8b
--- /dev/null
+++ b/arm64_source_noop_call.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// This per-translation source witness narrows only the unknown-scratch
+// observer check. It is not a caller-save, native ABI, memory or flags promise,
+// and cannot be supplied through Options or serialized as a trusted marker.
+type arm64SourceNoopCall struct {
+	original Func
+	resolved string
+	native   *arm64ScratchBinding
+}
+
+func captureARM64SourceNoopCalls(file *File, resolve func(string) string, sigs map[string]FuncSig) map[string]arm64SourceNoopCall {
+	if file.Arch != ArchARM64 {
+		return nil
+	}
+	symbols, resolved := make(map[string]int), make(map[string]int)
+	for _, fn := range file.Funcs {
+		symbols[fn.Sym]++
+		resolved[resolve(fn.Sym)]++
+	}
+	proofs := make(map[string]arm64SourceNoopCall)
+	for _, fn := range file.Funcs {
+		name := resolve(fn.Sym)
+		sig, present := sigs[name]
+		if !present || symbols[fn.Sym] != 1 || resolved[name] != 1 || sig.Name != name ||
+			!arm64SourceNoopSignature(sig) || !arm64SourceNoopBody(fn) {
+			continue
+		}
+		original := fn
+		original.Instrs = append([]Instr(nil), fn.Instrs...)
+		proofs[fn.Sym] = arm64SourceNoopCall{original: original, resolved: name}
+	}
+	return proofs
+}
+
+func arm64SourceNoopSignature(sig FuncSig) bool {
+	return sig.Name != "" && sig.Ret == Void && len(sig.Args) == 0 &&
+		len(sig.Frame.Params) == 0 && len(sig.Frame.Results) == 0 && len(sig.ArgRegs) == 0 &&
+		sig.ARM64GoRegisterABI == nil && sig.ARM64ClosureABI == nil && sig.ARMEntry == nil &&
+		sig.WASMContext == "" && !sig.WASMNative
+}
+
+// The complete source is exactly a NOSPLIT|NOFRAME zero-argument ABI0 TEXT
+// and an ordinary RET. Go obj7 emits no stack-check/prologue/epilogue scratch
+// for that leaf. A label, raw RET, transitive call or extra instruction is not
+// inferred harmless. ABI selectors and hidden/wrapper flags keep their own
+// contracts; even an empty callable signature alone proves nothing.
+func arm64SourceNoopBody(fn Func) bool {
+	if fn.Sym == "" || strings.Contains(fn.Sym, "<") || fn.FrameSize != 0 || fn.ArgSize != 0 ||
+		len(fn.Instrs) != 2 || fn.Instrs[0].Op != OpTEXT || len(fn.Instrs[0].Args) != 0 ||
+		fn.Instrs[1].Op != OpRET || len(fn.Instrs[1].Args) != 0 {
+		return false
+	}
+	_, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if len(parts) != 3 || strings.LastIndex(strings.TrimSpace(parts[2]), "-") <= 1 {
+		return false
+	}
+	expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+		if value, ok := goTextFlagValues[name]; ok {
+			return value
+		}
+		return name
+	})
+	flags, known := parseImmExpr(expression)
+	if !known || flags != 4|512 { // NOSPLIT | NOFRAME, and no hidden entry effects.
+		return false
+	}
+	// Reparse retained source independently. A changed public instruction or
+	// physical-decoder marker must not borrow a matching-looking Raw string.
+	parsed, err := Parse(ArchARM64, fn.Instrs[0].Raw+"\n"+fn.Instrs[1].Raw+"\n")
+	return err == nil && len(parsed.Funcs) == 1 && reflect.DeepEqual(parsed.Funcs[0], fn)
+}
+
+func (proof arm64SourceNoopCall) matchesNormalized(fn Func, sig FuncSig) bool {
+	if proof.native != nil {
+		// The native closure is checked on complete original input before the
+		// trusted normalizer. It is not a prepared-function or register-entry
+		// promise; ordinary typed/machine/CFG checks still run on this body.
+		return true
+	}
+	return sig.Name == proof.resolved && arm64SourceNoopSignature(sig) && arm64SourceNoopBody(proof.original) &&
+		arm64SourceNoopBody(fn) && reflect.DeepEqual(proof.original, fn)
+}
+
+func (c *arm64Ctx) sourceCallDoesNotObserveScratch(symbol string) bool {
+	proof, present := c.sourceNoopCalls[symbol]
+	if !present {
+		return false
+	}
+	if proof.native != nil {
+		return proof.native.hasCall(symbol)
+	}
+	sig, present := c.sigs[c.resolve(symbol)]
+	return present && sig.Name == c.resolve(symbol) && proof.matchesNormalized(proof.original, sig)
+}
diff --git a/arm64_source_noop_call_test.go b/arm64_source_noop_call_test.go
new file mode 100644
index 000000000..81464bc59
--- /dev/null
+++ b/arm64_source_noop_call_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64SourceNoopCallFixture(move, call, tail, callee string) string {
+	return fmt.Sprintf("#include \"textflag.h\"\nTEXT ·Scratch(SB),0,$32904-16\n%s n+0(FP),R1\n%s\n%s\nRET\n%s",
+		move, call, tail, callee)
+}
+
+func TestARM64SourceNoopCallScratchBoundary(t *testing.T) {
+	const noop = "TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0\nRET\n"
+	for _, tc := range []struct {
+		name, call, tail, callee string
+		accepted                 bool
+	}{
+		{"closed_ret", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", noop, true},
+		{"bl_closed_ret", "BL ·Noop(SB)", "MOVD R1,ret+8(FP)", noop, true},
+		{"numeric_flags", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "NOSPLIT|NOFRAME", "516", 1), true},
+		{"missing_source", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", "", false},
+		{"reads_scratch", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "MOVD R27,R0\nRET", 1), false},
+		{"stores_scratch", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "MOVD R27,(R0)\nRET", 1), false},
+		{"callee_scratch_result", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "MOVD R27,ret+0(FP)\nRET", 1), false},
+		{"scratch_result", "CALL ·Noop(SB)", "MOVD R27,ret+8(FP)", noop, false},
+		{"scratch_copy", "CALL ·Noop(SB)", "MOVD R27,R5\nMOVD R5,ret+8(FP)", noop, false},
+		{"transitive_call", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "CALL ·Other(SB)\nRET", 1) + "TEXT ·Other(SB),NOSPLIT|NOFRAME,$0-0\nRET\n", false},
+		{"label_body", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "return_here:\nRET", 1), false},
+		{"raw_ret", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "WORD $0xd65f03c0", 1), false},
+		{"operand_ret", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "RET", "RET (R30)", 1), false},
+		{"missing_nosplit", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "NOSPLIT|NOFRAME", "NOFRAME", 1), false},
+		{"missing_args_size", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "$0-0", "$0", 1), false},
+		{"missing_noframe", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "NOSPLIT|NOFRAME", "NOSPLIT", 1), false},
+		{"hidden_context", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", strings.Replace(noop, "NOSPLIT|NOFRAME", "NOSPLIT|NOFRAME|NEEDCTXT", 1), false},
+		{"internal_selector_mismatch", "CALL ·Noop<ABIInternal>(SB)", "MOVD R1,ret+8(FP)", noop, false},
+		{"abi0_selector_mismatch", "CALL ·Noop<ABI0>(SB)", "MOVD R1,ret+8(FP)", noop, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			for _, move := range arm64MemoryScratchAuditMoves {
+				source := arm64SourceNoopCallFixture(move, tc.call, tc.tail, tc.callee)
+				pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch(n uint64) uint64\nfunc Noop()\nfunc Other()\n")
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(name string) string { return strings.TrimPrefix(goStripABISuffix(name), "·") }
+				sizes := types.SizesFor("gc", "arm64")
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", sizes, sizes, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Missing source must fail even with a plausible complete signature.
+				if tc.callee == "" {
+					sigs["Noop"] = FuncSig{Name: "Noop", Ret: Void}
+				}
+				options := Options{Goarch: "arm64", ResolveSym: resolve, Sigs: sigs}
+				check := func(api string, err error) {
+					if tc.accepted && err != nil || !tc.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s %s accepted=%t: %v", api, move, tc.accepted, err)
+					}
+				}
+				_, err = Translate(file, options)
+				check("Translate", err)
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if err == nil {
+					module.Dispose()
+				}
+				check("Module", err)
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", ResolveSym: resolve})
+				if err == nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				check("GoModule", err)
+			}
+		})
+	}
+}
+
+func TestARM64SourceNoopCallUniqueBinding(t *testing.T) {
+	const noop = "TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0\nRET\n"
+	for _, tc := range []struct {
+		name   string
+		suffix string
+		alias  bool
+	}{
+		{"duplicate_source", noop, false},
+		{"resolved_alias", strings.Replace(noop, "·Noop", "·Other", 1), true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			source := arm64SourceNoopCallFixture("MOVD", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", noop+tc.suffix)
+			pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch(n uint64) uint64\nfunc Noop()\nfunc Other()\n")
+			ctx := llvm.NewContext()
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", ResolveSym: func(name string) string {
+					name = strings.TrimPrefix(name, "·")
+					if tc.alias && name == "Other" {
+						return "Noop"
+					}
+					return name
+				},
+			})
+			if err == nil {
+				bound.Module.Dispose()
+			}
+			ctx.Dispose()
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("ambiguous same-file source acquired a scratch proof: %v", err)
+			}
+		})
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch(n uint64) uint64\nfunc Noop()\n")
+	source := arm64SourceNoopCallFixture("MOVD", "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", noop)
+	bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: "arm64", KeepFunc: func(symbol, _ string) bool { return symbol != "·Noop" },
+	})
+	if err == nil {
+		bound.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("an excluded/cross-file callee borrowed complete same-file source: %v", err)
+	}
+	t.Run("missing_actual_declaration", func(t *testing.T) {
+		pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch(n uint64) uint64\n")
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64"})
+		if err == nil {
+			bound.Module.Dispose()
+		}
+		if err == nil || !strings.Contains(err.Error(), "missing Go declaration for asm symbol") {
+			t.Fatalf("same-file RET alone supplied a missing actual Go declaration: %v", err)
+		}
+	})
+}
+
+func TestARM64SourceNoopCallRechecksNormalizedSource(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT ·Leaf(SB),NOSPLIT|NOFRAME,$0-0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "Leaf", Ret: Void}
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	proofs := captureARM64SourceNoopCalls(file, resolve, map[string]FuncSig{"Leaf": sig})
+	proof, present := proofs["·Leaf"]
+	if !present || !proof.matchesNormalized(file.Funcs[0], sig) {
+		t.Fatal("complete arbitrary-named source leaf did not receive its exact witness")
+	}
+	for _, mutate := range []struct {
+		name string
+		fn   func(*Func)
+	}{
+		{"symbol", func(fn *Func) { fn.Sym = "·Other" }},
+		{"frame", func(fn *Func) { fn.FrameSize = 8 }},
+		{"args", func(fn *Func) { fn.ArgSize = 8 }},
+		{"flags", func(fn *Func) { fn.Instrs[0].Raw = "TEXT ·Leaf(SB),NOSPLIT,$0-0" }},
+		{"equivalent_but_changed_text", func(fn *Func) { fn.Instrs[0].Raw = "TEXT ·Leaf(SB),516,$0-0" }},
+		{"changed_raw_ret", func(fn *Func) { fn.Instrs[1].Raw = "RET (R27)" }},
+		{"changed_ret_operand", func(fn *Func) { fn.Instrs[1].Args = []Operand{{Kind: OpReg, Reg: "R27"}} }},
+		{"physical_ret_identity", func(fn *Func) { fn.Instrs[1].arm64Encoded = true }},
+		{"private_entry", func(fn *Func) { fn.arm64PrivateRegisterEntry = true }},
+	} {
+		t.Run(mutate.name, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			mutate.fn(&fn)
+			if proof.matchesNormalized(fn, sig) {
+				t.Fatal("changed normalized source consumed the original leaf witness")
+			}
+		})
+	}
+	for _, changed := range []FuncSig{
+		{Name: "Other", Ret: Void},
+		{Name: "Leaf", Ret: I64},
+		{Name: "Leaf", Ret: Void, Args: []LLVMType{I64}},
+		{Name: "Leaf", Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Type: I64}}}},
+		{Name: "Leaf", Ret: Void, ArgRegs: []Reg{"R27"}},
+		{Name: "Leaf", Ret: Void, ARM64GoRegisterABI: &ARM64GoRegisterABI{}},
+		{Name: "Leaf", Ret: Void, ARM64ClosureABI: &ARM64ClosureABI{}},
+	} {
+		if proof.matchesNormalized(file.Funcs[0], changed) {
+			t.Errorf("changed callable/hidden ABI consumed the original zero-frame witness: %+v", changed)
+		}
+	}
+	// This permission affects only validateSourceScratch. The independent typed
+	// GP contract must still reject an otherwise opaque ABI0 call.
+	flow := &arm64MachineAvailability{
+		used: true, sourceScratch: true, entry: &ARM64GoRegisterABI{},
+		blocks: []arm64MachineBlock{{name: "entry", effects: []arm64MachineEffect{
+			{register: "R27", unavailable: true},
+			{opaque: true, noScratchObserver: true, source: "closed leaf"},
+		}}},
+	}
+	if err := flow.validateSourceScratch(); err != nil {
+		t.Fatalf("the exact non-observer did not preserve missing scratch: %v", err)
+	}
+	if err := flow.validate(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("scratch witness bypassed the independent typed GP call boundary: %v", err)
+	}
+}
+
+func TestARM64SourceNoopCallScalarFrameLLVM22Objects(t *testing.T) {
+	const noop = "TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0\nRET\n"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc unavailable")
+	}
+	for _, move := range arm64MemoryScratchAuditMoves {
+		source := arm64SourceNoopCallFixture(move, "CALL ·Noop(SB)", "MOVD R1,ret+8(FP)", noop)
+		arm64PrivateCallGoObject(t, source)
+		for _, target := range append(append([]string(nil), arm64TypedNativeTargets...), "aarch64-w64-windows-gnu") {
+			for api, ir := range arm64ScalarMemoryIRs(t, source, "func Scratch(n uint64) uint64\nfunc Noop()\n", target) {
+				compileLLVMToObject(t, llc, target, fmt.Sprintf("closed-%s-%d.ll", move, api), fmt.Sprintf("closed-%s-%d.o", move, api), ir)
+			}
+		}
+	}
+}
+
+func TestARM64SourceNoopCallDoesNotAuthorizeNativeEffects(t *testing.T) {
+	const noop = "TEXT ·Noop(SB),NOSPLIT|NOFRAME,$0-0\nRET\n"
+	for _, tail := range []string{"SVC $0", "MOVD R27,(R0)", "MOVD R27,R0\nMOVD R0,ret+8(FP)"} {
+		source := arm64SourceNoopCallFixture("MOVD", "CALL ·Noop(SB)", tail, noop)
+		pkg := mustGoPackage(t, "test/scratch", "package scratch\nfunc Scratch(n uint64) uint64\nfunc Noop()\n")
+		ctx := llvm.NewContext()
+		bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64"})
+		if err == nil {
+			bound.Module.Dispose()
+		}
+		ctx.Dispose()
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("closed call erased the later source effect %q: %v", tail, err)
+		}
+	}
+}
diff --git a/arm64_stack_allocation_test.go b/arm64_stack_allocation_test.go
new file mode 100644
index 000000000..3223b1f93
--- /dev/null
+++ b/arm64_stack_allocation_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func arm64StackAllocationContext(t testing.TB, count int) *arm64Ctx {
+	t.Helper()
+	source := "TEXT allocation(SB),$0-0\n" + strings.Repeat("MOVD $1,R0\n", count) + "RET\n"
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+}
+
+func TestARM64StackProofAllocationDoesNotScaleWithReadOnlyOperands(t *testing.T) {
+	measure := func(count int) float64 {
+		ctx := arm64StackAllocationContext(t, count)
+		return testing.AllocsPerRun(5, func() {
+			low, high, err := ctx.stackMovementRange()
+			if err != nil || low != 0 || high != 0 {
+				t.Fatalf("stack bounds [%d,%d]: %v", low, high, err)
+			}
+		})
+	}
+	small, large := measure(1), measure(256)
+	if large > small+8 {
+		t.Fatalf("read-only instructions added %.0f allocations: small=%.0f large=%.0f", large-small, small, large)
+	}
+}
+
+func TestARM64StackProofIndexedWritebackKeepsSourceImmutable(t *testing.T) {
+	file, err := Parse(ArchARM64, "TEXT zero_writeback(SB),$0-0\nVST1.P [V0.B16],(RSP)(R7)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+	var source *Instr
+	for i := range ctx.blocks {
+		for j := range ctx.blocks[i].instrs {
+			if ctx.blocks[i].instrs[j].Op == "VST1.P" {
+				source = &ctx.blocks[i].instrs[j]
+			}
+		}
+	}
+	if source == nil {
+		t.Fatal("missing indexed writeback instruction")
+	}
+	want := append([]Operand(nil), source.Args...)
+	for attempt := 0; attempt < 3; attempt++ {
+		if _, _, err := ctx.stackMovementRange(); err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(source.Args, want) {
+			t.Fatalf("stack proof mutated source operands: got %+v, want %+v", source.Args, want)
+		}
+	}
+}
+
+func BenchmarkARM64StackProofReadOnlyOperands(b *testing.B) {
+	ctx := arm64StackAllocationContext(b, 4096)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, _, err := ctx.stackMovementRange(); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/arm64_stack_bounds.go b/arm64_stack_bounds.go
new file mode 100644
index 000000000..9eabf23c7
--- /dev/null
+++ b/arm64_stack_bounds.go
@@ -0,0 +1,469 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// The allocation is bounded by source control flow, not by an arbitrary extra
+// stack cushion. A cycle with a net SP change cannot fit a static local object.
+const arm64MaxLocalStackSpan = int64(1 << 20)
+
+type arm64StackRange struct {
+	low, high int64
+	local     bool
+	unknown   bool
+}
+
+// Index 31 is SP; other entries describe aliases of this function's allocation.
+// Non-local pointers need no storage in that allocation. An unknown local alias
+// must never be mistaken for an externally supplied stack pointer.
+type arm64StackState [32]arm64StackRange
+
+func arm64StackIndex(reg Reg) (int, bool) {
+	if arm64StackReg(reg) {
+		return 31, true
+	}
+	if reg == "g" {
+		return 28, true
+	}
+	name := string(reg)
+	if len(name) < 2 || name[0] != 'R' {
+		return 0, false
+	}
+	index, err := strconv.Atoi(name[1:])
+	return index, err == nil && index >= 0 && index < 31
+}
+
+func (state arm64StackState) value(reg Reg) arm64StackRange {
+	if index, ok := arm64StackIndex(reg); ok {
+		return state[index]
+	}
+	return arm64StackRange{}
+}
+
+func arm64MergeStackRange(a, b arm64StackRange) arm64StackRange {
+	if !a.local {
+		return b
+	}
+	if !b.local {
+		return a
+	}
+	if a.unknown || b.unknown {
+		return arm64StackRange{local: true, unknown: true}
+	}
+	if b.low < a.low {
+		a.low = b.low
+	}
+	if b.high > a.high {
+		a.high = b.high
+	}
+	return a
+}
+
+func arm64StackReg(reg Reg) bool { return reg == SP || reg == "RSP" }
+
+func arm64StackInstruction(ins Instr) Instr {
+	if ins.Op == OpWORD {
+		if len(ins.Args) == 1 {
+			if form, ok := decodeARM64RawSVEAddress(uint32(ins.Args[0].Imm)); ok {
+				reg := func(index int) Operand {
+					if index == 31 {
+						return Operand{Kind: OpReg, Reg: SP}
+					}
+					return Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", index))}
+				}
+				args := []Operand{{Kind: OpImm, Imm: int64(form.immediate)}}
+				if form.op != "RDVL" {
+					args = append(args, reg(form.source))
+				}
+				args = append(args, reg(form.destination))
+				return Instr{Op: form.op, Args: args, Raw: ins.Raw}
+			}
+		}
+		if decoded, err := decodeARM64RawWordInstruction(ins); err == nil {
+			return decoded
+		}
+	}
+	return ins
+}
+
+func (c *arm64Ctx) stackMovementRange() (minimum, maximum int64, err error) {
+	if len(c.blocks) == 0 {
+		return 0, 0, nil
+	}
+	c.dynamicStack = c.planDynamicStack()
+	labels := make(map[string]int)
+	zeroRegisters := c.stackUnwrittenZeroRegisters()
+	for i, block := range c.blocks {
+		labels[block.name] = i
+	}
+	inputs := make([]arm64StackState, len(c.blocks))
+	seen := make([]bool, len(c.blocks))
+	queued := make([]bool, len(c.blocks))
+	visits := make([]int, len(c.blocks))
+	inputs[0][31] = arm64StackRange{local: true}
+	seen[0], queued[0] = true, true
+	queue := []int{0}
+	steps := 0
+	for len(queue) != 0 {
+		at := queue[0]
+		queue = queue[1:]
+		queued[at] = false
+		visits[at]++
+		steps++
+		if steps > 64*len(c.blocks)+64 {
+			return 0, 0, fmt.Errorf("ARM64 local stack movement proof exhausted its convergence budget")
+		}
+		state := inputs[at]
+		returned := false
+		for _, original := range c.blocks[at].instrs {
+			ins := arm64StackInstruction(original)
+			copied := false
+			for i, arg := range ins.Args {
+				if arg.Kind != OpMem {
+					continue
+				}
+				index, ok := arm64StackIndex(arg.Mem.Index)
+				if !ok || zeroRegisters&(1<<uint(index)) == 0 {
+					continue
+				}
+				// Proofs normally inspect immutable operands. Copy only when
+				// normalizing a proved-zero index; never alter source slices.
+				if !copied {
+					ins.Args = append([]Operand(nil), ins.Args...)
+					copied = true
+				}
+				ins.Args[i].Mem.Index = ""
+			}
+			if ins.Op == OpRET {
+				returned = true
+				break
+			}
+			// A restored SP need not be bounded if it is never dereferenced
+			// again (for example asmcgocall's final restore before RET).
+			// Require bounds at each actual local-memory use instead.
+			controlOp := normalizeInstructionOpcode(ins.Op)
+			call := controlOp == "BL" || controlOp == "CALL" || controlOp == "BLR"
+			branch := controlOp == "B" || controlOp == "JMP" || controlOp == "BR"
+			for _, arg := range ins.Args {
+				// A parenthesized branch target is a register, not a memory
+				// dereference. In BR/BLR register 31 reads XZR, not SP.
+				if arg.Kind != OpMem || call || branch || !arm64StackReg(arg.Mem.Base) && arg.Mem.Base != ZR {
+					continue
+				}
+				address := state[31]
+				if !address.local {
+					continue
+				}
+				offsetLow, offsetHigh, width, err := arm64StackMemoryExtent(ins, arg.Mem)
+				if address.unknown || err != nil {
+					return 0, 0, fmt.Errorf("ARM64 cannot bound dynamic local stack access: %q", original.Raw)
+				}
+				if arg.Mem.Off < -arm64MaxLocalStackSpan || arg.Mem.Off > arm64MaxLocalStackSpan {
+					return 0, 0, fmt.Errorf("ARM64 local stack operand exceeds %d bytes", arm64MaxLocalStackSpan)
+				}
+				low, high := address.low+offsetLow, address.high+offsetHigh+width
+				if low < minimum {
+					minimum = low
+				}
+				if high > maximum {
+					maximum = high
+				}
+			}
+			if call && state[31].unknown {
+				return 0, 0, fmt.Errorf("ARM64 cannot bound call frame after dynamic stack restore: %q", original.Raw)
+			}
+			amount, dynamic := arm64DynamicStackAmount(ins)
+			if !dynamic || c.dynamicStack == nil || amount != c.dynamicStack.amount {
+				if err := arm64StackStep(&state, original, ins); err != nil {
+					return 0, 0, err
+				}
+			}
+			sp := state[31]
+			if !sp.local || sp.unknown {
+				continue
+			}
+			if sp.low < -arm64MaxLocalStackSpan || sp.high > arm64MaxLocalStackSpan {
+				return 0, 0, fmt.Errorf("ARM64 local stack movement exceeds %d bytes at %q", arm64MaxLocalStackSpan, original.Raw)
+			}
+			if sp.low < minimum {
+				minimum = sp.low
+			}
+			if sp.high > maximum {
+				maximum = sp.high
+			}
+		}
+		if returned {
+			continue
+		}
+		for _, next := range c.stackSuccessors(at, labels) {
+			merged := inputs[next]
+			changed := !seen[next]
+			for reg := range state {
+				value := arm64MergeStackRange(merged[reg], state[reg])
+				if reg != 31 && visits[next] >= 2 && value.local && value != merged[reg] {
+					// Widen changing aliases, not SP itself. Walking a pointer
+					// need not enlarge the allocation; restoring an unbounded
+					// alias into SP still fails when that SP is dereferenced.
+					value = arm64StackRange{local: true, unknown: true}
+				}
+				changed = changed || value != merged[reg]
+				merged[reg] = value
+			}
+			if changed {
+				inputs[next], seen[next] = merged, true
+				if !queued[next] {
+					queue, queued[next] = append(queue, next), true
+				}
+			}
+		}
+	}
+	return minimum, maximum, nil
+}
+
+func arm64StackStep(state *arm64StackState, original, ins Instr) error {
+	op := strings.ToUpper(string(ins.Op))
+	base, suffix, _ := strings.Cut(op, ".")
+	adjust := func(value arm64StackRange, delta int64) arm64StackRange {
+		if value.unknown {
+			return arm64StackRange{local: value.local, unknown: true}
+		}
+		if value.local {
+			if delta < -arm64MaxLocalStackSpan || delta > arm64MaxLocalStackSpan ||
+				value.low < -arm64MaxLocalStackSpan || value.high > arm64MaxLocalStackSpan {
+				value.unknown = true
+			} else {
+				value.low += delta
+				value.high += delta
+			}
+		}
+		return value
+	}
+	if form, handled, err := parseARM64ScalarMemoryForm(arm64ControlOp(ins), ins); handled {
+		if err != nil {
+			return err
+		}
+		address := arm64StackRange{}
+		if form.memory.Kind == OpMem {
+			address = state.value(form.memory.Mem.Base)
+			if state.value(form.memory.Mem.Index).local {
+				address.local, address.unknown = true, true
+			}
+		}
+		if form.scratch {
+			value := arm64StackRange{}
+			if form.scratchAddress && form.scratchBase != "" {
+				value = state.value(form.scratchBase)
+				if form.scratchKnown {
+					value = adjust(value, form.scratchOffset)
+				} else {
+					value.unknown = value.local
+				}
+			}
+			(*state)[27] = value
+		}
+		if !form.store && form.data != ZR {
+			if index, gp := arm64StackIndex(form.data); gp {
+				// An owned-stack load may recover a previously spilled private
+				// address. Its bounds are not an invented interval for the data.
+				(*state)[index] = arm64StackRange{local: address.local, unknown: address.local}
+			}
+		}
+		if form.pre || form.post {
+			if index, gp := arm64StackIndex(form.memory.Mem.Base); gp {
+				(*state)[index] = adjust(address, form.memory.Mem.Off)
+			}
+		}
+		return nil
+	}
+	if len(ins.Args) != 0 {
+		destination := ins.Args[len(ins.Args)-1]
+		index, register := arm64StackIndex(destination.Reg)
+		if destination.Kind == OpReg && register {
+			switch base {
+			case "ADDVL", "ADDPL":
+				if len(ins.Args) == 3 && ins.Args[0].Kind == OpImm && ins.Args[1].Kind == OpReg {
+					value := state.value(ins.Args[1].Reg)
+					unit := int64(16)
+					if base == "ADDPL" {
+						unit = 2
+					}
+					// Cover every architectural VL, not just the host's VL.
+					low, high := unit*ins.Args[0].Imm, 16*unit*ins.Args[0].Imm
+					if low > high {
+						low, high = high, low
+					}
+					if value.local && !value.unknown {
+						value.low += low
+						value.high += high
+					}
+					state[index] = value
+					return nil
+				}
+			case "RDVL":
+				state[index] = arm64StackRange{}
+				return nil
+			case "MOVD":
+				if form, handled, err := parseARM64RegisterAddressForm(Op(base), ins); handled && err == nil {
+					if form.usesScratch {
+						state[27] = arm64StackRange{}
+					}
+					state[index] = adjust(state.value(form.base), form.offset)
+					return nil
+				}
+				if len(ins.Args) == 2 && ins.Args[0].Kind == OpReg {
+					state[index] = state.value(ins.Args[0].Reg)
+					return nil
+				}
+				if len(ins.Args) == 2 && suffix == "" {
+					// A context switch may install externally owned storage.
+					// Reloading from our own stack is not proof of that: it may
+					// be a saved local SP, whose offset needs a separate proof.
+					local := ins.Args[0].Kind == OpMem && state.value(ins.Args[0].Mem.Base).local
+					state[index] = arm64StackRange{local: local, unknown: local}
+					return nil
+				}
+			case "ADD", "SUB":
+				value := state[index]
+				if len(ins.Args) == 3 && ins.Args[1].Kind == OpReg {
+					value = state.value(ins.Args[1].Reg)
+				}
+				if ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+					delta := ins.Args[0].Imm
+					if delta < -arm64MaxLocalStackSpan || delta > arm64MaxLocalStackSpan {
+						value.unknown = value.local
+					} else if base == "SUB" {
+						delta = -delta
+					}
+					state[index] = adjust(value, delta)
+					return nil
+				}
+			case "AND", "BIC":
+				if ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+					mask := uint64(ins.Args[0].Imm)
+					if base == "AND" {
+						mask = ^mask
+					}
+					if mask <= uint64(arm64MaxLocalStackSpan) && mask&(mask+1) == 0 {
+						value := state[index]
+						if len(ins.Args) == 3 && ins.Args[1].Kind == OpReg {
+							value = state.value(ins.Args[1].Reg)
+						}
+						// Alignment rounds an address down by at most mask,
+						// irrespective of the alloca's actual base alignment.
+						if value.local && !value.unknown {
+							value.low -= int64(mask)
+						}
+						state[index] = value
+						return nil
+					}
+				}
+			}
+		}
+	}
+	arm64StackInvalidateWrites(state, original, ins)
+	if suffix == "P" || suffix == "W" {
+		for _, operand := range ins.Args {
+			if operand.Kind == OpMem && (arm64StackReg(operand.Mem.Base) || operand.Mem.Base == ZR) {
+				if state[31].local && (operand.Mem.Index != "" && operand.Mem.Index != ZR || operand.Mem.OffRaw != "") {
+					return fmt.Errorf("ARM64 cannot bound indexed stack writeback: %q", ins.Raw)
+				}
+				state[31] = adjust(state[31], operand.Mem.Off)
+				return nil
+			}
+		}
+	}
+	return nil
+}
+
+func arm64StackInvalidateWrites(state *arm64StackState, original, ins Instr) {
+	// Unmodeled arithmetic can retain a local address but loses its bounds.
+	// Stores and flag-only/branch operations do not overwrite their GP inputs.
+	op := strings.ToUpper(string(ins.Op))
+	base, _, _ := strings.Cut(op, ".")
+	if strings.HasPrefix(base, "CMP") || strings.HasPrefix(base, "CMN") ||
+		strings.HasPrefix(base, "TST") || base == "NOP" || base == "B" || base == "JMP" ||
+		strings.HasPrefix(base, "CB") || strings.HasPrefix(base, "TB") {
+		return
+	}
+	var writes uint32
+	var derived bool
+	for _, arg := range ins.Args {
+		if arg.Kind == OpReg || arg.Kind == OpRegShift || arg.Kind == OpRegExtend {
+			derived = derived || state.value(arg.Reg).local
+			if index, ok := arm64StackIndex(arg.Reg); ok {
+				writes |= 1 << uint(index)
+			}
+		}
+	}
+	if original.Op == OpWORD && len(original.Args) == 1 {
+		if mask, known := arm64RawPoolGPWrites(uint32(original.Args[0].Imm)); known {
+			writes = mask
+		} else {
+			writes = 0x7fffffff
+			for index, value := range state {
+				if index != 31 {
+					derived = derived || value.local
+				}
+			}
+		}
+	} else if len(ins.Args) != 0 {
+		last := ins.Args[len(ins.Args)-1]
+		if last.Kind == OpMem || base == "STP" || base == "STNP" {
+			writes = 0
+		} else if last.Kind == OpReg {
+			writes = 0
+			if index, ok := arm64StackIndex(last.Reg); ok {
+				writes = 1 << uint(index)
+			}
+		} else if last.Kind == OpRegList {
+			writes = 0
+			for _, reg := range last.RegList {
+				if index, ok := arm64StackIndex(reg); ok {
+					writes |= 1 << uint(index)
+				}
+			}
+		}
+	}
+	for index := range state {
+		if writes&(1<<uint(index)) != 0 {
+			state[index] = arm64StackRange{local: derived, unknown: derived}
+		}
+	}
+}
+
+func (c *arm64Ctx) stackSuccessors(at int, labels map[string]int) []int {
+	block := c.blocks[at]
+	var successors []int
+	canFallThrough := true
+	if len(block.instrs) != 0 {
+		last := arm64StackInstruction(block.instrs[len(block.instrs)-1])
+		op := strings.ToUpper(string(last.Op))
+		switch op {
+		case "RET", "UNDEF", "BRK":
+			canFallThrough = false
+		case "B", "JMP", "BR", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT", "BHS", "BLS",
+			"BMI", "BPL", "BVS", "BVC", "BCC", "BCS", "CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ", "BL", "BLR", "CALL":
+			canFallThrough = op != "B" && op != "JMP" && op != "BR"
+			if len(last.Args) != 0 {
+				target := last.Args[len(last.Args)-1]
+				if name, ok := arm64BranchTarget(target); ok {
+					if next, local := labels[name]; local {
+						successors = append(successors, next)
+					}
+				} else if target.Kind == OpReg && !canFallThrough {
+					// Computed local branches must not hide a stack-changing path.
+					for next := range c.blocks {
+						successors = append(successors, next)
+					}
+				}
+			}
+		}
+	}
+	if canFallThrough && at+1 < len(c.blocks) {
+		successors = append(successors, at+1)
+	}
+	return successors
+}
diff --git a/arm64_stack_bounds_test.go b/arm64_stack_bounds_test.go
new file mode 100644
index 000000000..ad11a1e03
--- /dev/null
+++ b/arm64_stack_bounds_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestARM64StackAllocationIncludesAdjustments(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		for _, test := range []struct {
+			name, source string
+			machine      []string
+			low, high    int64
+		}{
+			{"subtract", "SUB $192,RSP\nMOVD R0,(RSP)\nADD $192,RSP\n",
+				[]string{"sub sp,sp,#192", "str x0,[sp]", "add sp,sp,#192"}, -192, 0},
+			{"add", "ADD $512,RSP\nMOVD R0,8(RSP)\nSUB $512,RSP\n",
+				[]string{"add sp,sp,#512", "str x0,[sp,#8]", "sub sp,sp,#512"}, 0, 528},
+			{"nested", "SUB $512,RSP\nSTP.W (R0,R1),-32(RSP)\nLDP.P 32(RSP),(R0,R1)\nADD $512,RSP\n",
+				[]string{"sub sp,sp,#512", "stp x0,x1,[sp,#-32]!", "ldp x0,x1,[sp],#32", "add sp,sp,#512"}, -544, 0},
+			{"restore", "MOVD RSP,R3\nSUB $192,RSP\nMOVD R3,RSP\nSUB $512,RSP\nMOVD R0,(RSP)\nADD $512,RSP\n",
+				[]string{"mov x3,sp", "sub sp,sp,#192", "mov sp,x3", "sub sp,sp,#512", "str x0,[sp]", "add sp,sp,#512"}, -512, 0},
+		} {
+			t.Run(fmt.Sprintf("%s/raw=%v", test.name, raw), func(t *testing.T) {
+				source := "TEXT stack_bounds(SB),$0-0\n" + test.source + "RET\n"
+				if raw {
+					var body strings.Builder
+					for _, word := range assembleARM64LLVMWords(t, test.machine, "") {
+						fmt.Fprintf(&body, "WORD $%#08x\n", word)
+					}
+					source = "TEXT stack_bounds(SB),$0-0\n" + body.String() + "RET\n"
+				}
+				requireARM64GoAssemblerResult(t, source, true)
+				ir := arm64StackTestIR(t, source)
+				match := regexp.MustCompile(`getelementptr inbounds \[(\d+) x i8\], ptr %local_stack, i32 0, i64 (\d+)`).FindStringSubmatch(ir)
+				if len(match) != 3 {
+					t.Fatal("missing local stack allocation")
+				}
+				size, _ := strconv.ParseInt(match[1], 10, 64)
+				bias, _ := strconv.ParseInt(match[2], 10, 64)
+				if bias+test.low < 0 || bias+test.high > size {
+					t.Fatalf("stack [%d,%d) relative to initial SP cannot contain [%d,%d)", -bias, size-bias, test.low, test.high)
+				}
+			})
+		}
+	}
+}
+
+func arm64StackBoundsRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var machine []string
+	for i, size := range []int{192, 512, 4096} {
+		machine = append(machine, fmt.Sprintf("sub sp,sp,#%d", size),
+			"stp x0,x1,[sp,#16]", "mov x0,xzr", "mov x1,xzr",
+			"movi v0.16b,#0x5a", "stp q0,q0,[sp,#-32]!",
+			"str q0,[sp,#64]", "ldp q1,q2,[sp],#32",
+			"ldp x0,x1,[sp,#16]", fmt.Sprintf("add sp,sp,#%d", size),
+			fmt.Sprintf("str x1,[x0,#%d]", i*8))
+	}
+	var source strings.Builder
+	source.WriteString(`TEXT stack_runtime(SB),$32-16
+MOVD out+0(FP),R0
+MOVD value+8(FP),R1
+MOVD R1,n-8(SP)
+MOVD R0,p-16(SP)
+MOVD $0,R1
+MOVD n-8(SP),R1
+MOVD p-16(SP),R0
+`)
+	for _, word := range assembleARM64LLVMWords(t, machine, "") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"stack_runtime": {
+			Name: "stack_runtime", Args: []LLVMType{Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `
+#include <stdint.h>
+extern void stack_runtime(uint64_t*, uint64_t);
+int main(void) {
+  uint64_t value = 1;
+  for (unsigned i = 0; i < 128; i++) {
+    uint64_t got[5] = {0x12345678, 0, 0, 0, 0x87654321};
+    stack_runtime(got + 1, value);
+    if (got[0] != 0x12345678 || got[4] != 0x87654321) return 1;
+    for (unsigned j = 1; j <= 3; j++) if (got[j] != value) return 2;
+    value = value * UINT64_C(6364136223846793005) + 1;
+  }
+  return 0;
+}
+`
+	return ir, main
+}
+
+func TestARM64StackBoundsLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64StackBoundsRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "stack.ll", "stack.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "stack", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func arm64StackTestIR(t *testing.T, source string) string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"stack_bounds": {Name: "stack_bounds", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64StackMovementControlFlow(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		low, high  int64
+		failure    bool
+	}{
+		{"balanced-loop", "loop:\nSUB $192,RSP\nMOVD R0,(RSP)\nADD $192,RSP\nCBNZ R0,loop\nRET\n", -192, 0, false},
+		{"alias-walk-without-sp-restore", "MOVD RSP,R3\nloop:\nADD $1,R3\nCBNZ R0,loop\nRET\n", 0, 0, false},
+		{"unbalanced-loop", "loop:\nSUB $192,RSP\nCBNZ R0,loop\nRET\n", 0, 0, true},
+		{"diamond", "CBZ R0,small\nSUB $512,RSP\nB done\nsmall:\nSUB $192,RSP\ndone:\nMOVD R0,(RSP)\nRET\n", -512, 0, false},
+		{"raw-return", "SUB $192,RSP\nCBZ R0,tail\nend:\nADD $192,RSP\nWORD $0xd65f03c0\ntail:\nB end\nRET\n", -192, 0, false},
+		{"runtime-sized-backing", "SUB R0,RSP\nMOVD R1,(RSP)\nRET\n", 0, 64, false},
+		{"saved-sp", "MOVD RSP,R3\nSUB $192,RSP\nMOVD R3,RSP\nSUB $512,RSP\nRET\n", -512, 0, false},
+		{"derived-sp", "SUB $512,RSP,R3\nMOVD R3,RSP\nRET\n", -512, 0, false},
+		{"aligned-sp-bic", "SUB $16,RSP,R3\nBIC $15,R3\nMOVD R3,RSP\nRET\n", -31, 0, false},
+		{"aligned-sp-and", "AND $-16,RSP,R3\nMOVD R3,RSP\nRET\n", -15, 0, false},
+		{"saved-sp-join", "MOVD RSP,R3\nCBZ R0,small\nSUB $512,R3\nB done\nsmall:\nSUB $192,R3\ndone:\nMOVD R3,RSP\nRET\n", -512, 0, false},
+		{"dynamic-alias", "MOVD RSP,R3\nSUB R0,R3\nMOVD R3,RSP\nMOVD R1,(RSP)\nRET\n", 0, 0, true},
+		{"external-sp", "MOVD (R0),R3\nMOVD R3,RSP\nSUB R1,RSP\nRET\n", 0, 0, false},
+		{"unused-stack-restore", "SUB $16,RSP\nMOVD 8(RSP),R2\nMOVD R2,RSP\nRET\n", -16, 56, false},
+		{"unproved-stack-reload", "MOVD RSP,R3\nMOVD R3,(RSP)\nMOVD (RSP),R4\nMOVD R4,RSP\nMOVD R0,(RSP)\nRET\n", 0, 0, true},
+		{"alias-clobber", "MOVD RSP,R3\nMUL R0,R3\nMOVD R3,RSP\nMOVD R1,(RSP)\nRET\n", 0, 0, true},
+		{"excessive", "SUB $2097152,RSP\nMOVD R1,(RSP)\nRET\n", 0, 0, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT stack_bounds(SB),$0-0\n" + test.body
+			if test.name == "external-sp" || test.name == "unproved-stack-reload" {
+				// Memory-to-RSP is not a Go row. Keep the unknown-SP range
+				// and failed bounded-write proof using legal GP transfers.
+				requireARM64GoAssemblerResult(t, source, true)
+			}
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+			low, high, err := ctx.stackMovementRange()
+			if test.failure {
+				if err == nil {
+					t.Fatal("unbounded stack movement accepted")
+				}
+				return
+			}
+			if err != nil || low != test.low || high != test.high {
+				t.Fatalf("range=[%d,%d] err=%v, want [%d,%d]", low, high, err, test.low, test.high)
+			}
+		})
+	}
+}
+
+func TestARM64StackOperandBoundsRejectOverflow(t *testing.T) {
+	for _, offset := range []int64{1 << 21, -1 << 21, 1<<63 - 1, -1 << 63} {
+		source := fmt.Sprintf("TEXT stack_bounds(SB),$0-0\nMOVD R0,%d(RSP)\nRET\n", offset)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ctx := &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+		if _, _, err := ctx.stackOffsetRange(); err == nil {
+			t.Fatalf("accepted oversized stack offset %d", offset)
+		}
+	}
+}
+
+func TestARM64StackScalableAdjustments(t *testing.T) {
+	for _, op := range []string{"ADDVL", "ADDPL"} {
+		for _, immediate := range []int{-32, -1, 31} {
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%d/raw=%v", op, immediate, raw), func(t *testing.T) {
+					body := fmt.Sprintf("%s $%d,RSP,RSP\n", op, immediate)
+					if raw {
+						machine := fmt.Sprintf("%s sp,sp,#%d", strings.ToLower(op), immediate)
+						word := assembleARM64LLVMWords(t, []string{machine}, "+sve")[0]
+						body = fmt.Sprintf("WORD $%#08x\n", word)
+					}
+					file, err := Parse(ArchARM64, "TEXT scalable_stack(SB),$0-0\n"+body+"RET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ctx := &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+					low, high, err := ctx.stackMovementRange()
+					maximumScale := int64(256)
+					if op == "ADDPL" {
+						maximumScale = 32
+					}
+					wantLow, wantHigh := int64(0), int64(0)
+					if immediate < 0 {
+						wantLow = int64(immediate) * maximumScale
+					} else {
+						wantHigh = int64(immediate) * maximumScale
+					}
+					if err != nil || low != wantLow || high != wantHigh {
+						t.Fatalf("range=[%d,%d] err=%v, want [%d,%d]", low, high, err, wantLow, wantHigh)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/arm64_stack_dynamic.go b/arm64_stack_dynamic.go
new file mode 100644
index 000000000..465987d5f
--- /dev/null
+++ b/arm64_stack_dynamic.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+type arm64DynamicStackPlan struct {
+	amount  Reg
+	aliases uint32
+}
+
+func arm64DynamicStackAmount(ins Instr) (Reg, bool) {
+	if ins.Op != "SUB" || len(ins.Args) < 2 || len(ins.Args) > 3 || ins.Args[0].Kind != OpReg {
+		return "", false
+	}
+	for _, arg := range ins.Args[1:] {
+		if arg.Kind != OpReg || !arm64StackReg(arg.Reg) {
+			return "", false
+		}
+	}
+	index, gp := arm64StackIndex(ins.Args[0].Reg)
+	return ins.Args[0].Reg, gp && index < 31
+}
+
+// A single runtime-sized extension can move this function's private backing
+// only before a local address has escaped or been observed numerically. Copy
+// the original bytes and relocate every live alias together, preserving saved
+// SPs, address differences and accesses to the original frame. Arbitrary
+// dynamic restores, multiple extensions and re-entry remain unproved.
+func (c *arm64Ctx) planDynamicStack() *arm64DynamicStackPlan {
+	blockAt, instructionAt := -1, -1
+	var amount Reg
+	labels := make(map[string]int)
+	for block, body := range c.blocks {
+		labels[body.name] = block
+		for at, original := range body.instrs {
+			if reg, ok := arm64DynamicStackAmount(arm64StackInstruction(original)); ok {
+				if blockAt >= 0 {
+					return nil
+				}
+				blockAt, instructionAt, amount = block, at, reg
+			}
+		}
+	}
+	if blockAt < 0 {
+		return nil
+	}
+	for block := range c.blocks {
+		for _, next := range c.stackSuccessors(block, labels) {
+			if next <= blockAt && (block >= blockAt || next != block+1) {
+				return nil // Only the straight-line prefix may reach the extension.
+			}
+		}
+	}
+	var state arm64StackState
+	state[31] = arm64StackRange{local: true}
+	for block := 0; block <= blockAt; block++ {
+		for at, original := range c.blocks[block].instrs {
+			if block == blockAt && at == instructionAt {
+				if state.value(amount).local || !state[31].local {
+					return nil
+				}
+				plan := &arm64DynamicStackPlan{amount: amount}
+				for index, value := range state {
+					if value.local {
+						if value.unknown || index == 28 {
+							return nil
+						}
+						plan.aliases |= 1 << uint(index)
+					}
+				}
+				return plan
+			}
+			ins := arm64StackInstruction(original)
+			if !arm64StackRelocatablePrefix(state, ins) {
+				return nil
+			}
+			if err := arm64StackStep(&state, original, ins); err != nil {
+				return nil
+			}
+		}
+	}
+	return nil
+}
+
+func arm64StackRelocatablePrefix(state arm64StackState, ins Instr) bool {
+	op := strings.ToUpper(string(ins.Op))
+	// No hidden state observation: unknown/system effects and calls cannot
+	// be inferred safe from the absence of an explicit SP operand.
+	switch op {
+	case "TEXT", "NOP", "MOVD", "MOVW", "MOVWU", "MOVH", "MOVHU", "MOVB", "MOVBU",
+		"STP", "LDP", "STP.P", "LDP.P", "STP.W", "LDP.W",
+		"ADD", "SUB", "AND", "BIC", "LSL", "LSR", "ASR", "MUL",
+		"CMP", "CMN", "TST", "B", "BEQ", "BNE", "BLO", "BHI", "BLT", "BGE", "BLE", "BGT", "BHS", "BLS",
+		"BMI", "BPL", "BVS", "BVC", "BCC", "BCS", "CBZ", "CBNZ", "CBZW", "CBNZW", "TBZ", "TBNZ":
+	default:
+		return false
+	}
+	usesAddress := false
+	for _, arg := range ins.Args {
+		switch arg.Kind {
+		case OpReg, OpRegShift, OpRegExtend:
+			usesAddress = usesAddress || state.value(arg.Reg).local
+		case OpRegList:
+			for _, reg := range arg.RegList {
+				usesAddress = usesAddress || state.value(reg).local
+			}
+		case OpMem:
+			if state.value(arg.Mem.Index).local {
+				return false
+			}
+		case OpSym:
+			// Effective-address operands are values, not memory reads. Their
+			// destinations are not in the register-copy alias proof above;
+			// never relocate storage while leaving such a hidden alias behind.
+			if strings.HasPrefix(arg.Sym, "$") {
+				memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(arg.Sym, "$")))
+				if ok && (state.value(memory.Base).local || state.value(memory.Index).local || memory.Base == ZR) {
+					return false
+				}
+			}
+		}
+	}
+	if !usesAddress {
+		return true
+	}
+	// A memory base is not an escaped value, but a GP/list source in a store,
+	// comparison, system write or vector insertion can expose the old address.
+	last := ins.Args[len(ins.Args)-1]
+	if last.Kind != OpReg {
+		return false
+	}
+	if op == "MOVD" && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg {
+		return true
+	}
+	if (op == "ADD" || op == "SUB") && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		return true
+	}
+	return false
+}
+
+func (c *arm64Ctx) lowerDynamicStack(ins Instr) (bool, error) {
+	amount, ok := arm64DynamicStackAmount(ins)
+	if !ok || c.dynamicStack == nil || amount != c.dynamicStack.amount {
+		return false, nil
+	}
+	value, err := c.loadReg(amount)
+	if err != nil {
+		return true, err
+	}
+	negative, negated, absolute := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %s, 0\n", negative, value)
+	fmt.Fprintf(c.b, "  %%%s = sub i64 0, %s\n", negated, value)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 %%%s, i64 %s\n", absolute, negative, negated, value)
+	valid, ready, invalid := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ule i64 %%%s, %d\n", valid, absolute, int64(1<<63-1)-c.localStackSize-15)
+	fmt.Fprintf(c.b, "  br i1 %%%s, label %%%s, label %%%s\n%s:\n", valid, ready, invalid, invalid)
+	c.b.WriteString("  call void @llvm.trap()\n  unreachable\n")
+	fmt.Fprintf(c.b, "%s:\n", ready)
+	rounded, extent, bytes := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, 15\n", rounded, absolute)
+	fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, -16\n", extent, rounded)
+	fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %d\n", bytes, extent, c.localStackSize)
+	storage, prefix, original := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = alloca i8, i64 %%%s, align 16\n", storage, bytes)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 0, i64 %%%s\n", prefix, negative, extent)
+	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %%%s, i64 %%%s\n", original, storage, prefix)
+	fmt.Fprintf(c.b, "  call void @llvm.memcpy.p0.p0.i64(ptr %%%s, ptr %s, i64 %d, i1 false)\n", original, c.localStackSlot, c.localStackSize)
+	oldAddress, newAddress, shift := c.newTmp(), c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i64\n", oldAddress, c.localStackSlot)
+	fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %%%s to i64\n", newAddress, original)
+	fmt.Fprintf(c.b, "  %%%s = sub i64 %%%s, %%%s\n", shift, newAddress, oldAddress)
+	var aliases []string
+	for reg := range c.regSlot {
+		if index, ok := arm64StackIndex(reg); ok && c.dynamicStack.aliases&(1<<uint(index)) != 0 {
+			aliases = append(aliases, string(reg))
+		}
+	}
+	sort.Strings(aliases)
+	for _, name := range aliases {
+		reg := Reg(name)
+		old, err := c.loadReg(reg)
+		if err != nil {
+			return true, err
+		}
+		rebased := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i64 %s, %%%s\n", rebased, old, shift)
+		result := "%" + rebased
+		if arm64StackReg(reg) {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sub i64 %s, %s\n", adjusted, result, value)
+			result = "%" + adjusted
+		}
+		if err := c.storeReg(reg, result); err != nil {
+			return true, err
+		}
+	}
+	return true, nil
+}
diff --git a/arm64_stack_dynamic_test.go b/arm64_stack_dynamic_test.go
new file mode 100644
index 000000000..34d964eff
--- /dev/null
+++ b/arm64_stack_dynamic_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func arm64DynamicStackRuntime(t *testing.T, triple string) (string, string) {
+	return arm64DynamicStackRuntimeWithFrame(t, triple, 0)
+}
+
+func arm64DynamicStackRuntimeWithFrame(t *testing.T, triple string, frame int64) (string, string) {
+	t.Helper()
+	source := fmt.Sprintf(`TEXT dynamic_stack(SB),$%d-24
+MOVD out+0(FP),R0
+MOVD size+8(FP),R1
+MOVD value+16(FP),R2
+MOVD RSP,R20
+ADD $8,RSP,R21
+MOVD R2,8(RSP)
+SUB R1,RSP
+MOVD RSP,R3
+ADD R1,R3
+SUB R3,R20,R4
+MOVD R4,0(R0)
+MOVD R2,(RSP)
+MOVD 8(R20),R5
+MOVD R5,8(R0)
+MOVD (RSP),R6
+MOVD R6,16(R0)
+MOVD (R21),R7
+MOVD R7,24(R0)
+MOVD R20,RSP
+MOVD 8(RSP),R8
+MOVD R8,32(R0)
+RET
+`, frame)
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"dynamic_stack": {
+			Name: "dynamic_stack", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "alloca i8, i64 %") || !strings.Contains(ir, "@llvm.memcpy.p0.p0.i64") {
+		t.Fatal("missing runtime-sized backing or preservation of the original frame")
+	}
+	const main = `
+#include <stdint.h>
+extern void dynamic_stack(uint64_t*, uint64_t, uint64_t);
+int main(void) {
+  const uint64_t sizes[] = {0,16,32,192,512,4096,65536,(uint64_t)-16,(uint64_t)-512};
+  uint64_t value = 7;
+  for (unsigned i = 0; i < 128; i++) {
+    for (unsigned n = 0; n < sizeof(sizes)/sizeof(sizes[0]); n++) {
+      uint64_t out[7] = {0x1234,99,0,0,0,0,0x5678};
+      dynamic_stack(out+1,sizes[n],value);
+      if (out[0] != 0x1234 || out[6] != 0x5678 || out[1] != 0) return 1;
+      for (unsigned j = 2; j <= 5; j++) if (out[j] != value) return 2;
+    }
+    value = value * UINT64_C(6364136223846793005) + 1;
+  }
+  return 0;
+}
+
+`
+	return ir, main
+}
+
+func TestARM64DynamicStackLargeDeclaredFrameLLVM(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM 22 llc and clang are required")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64DynamicStackRuntimeWithFrame(t, triple, 1<<21)
+			if !strings.Contains(ir, "%local_stack = alloca i8, i64 %") {
+				t.Fatal("declared backing must itself use the large-frame dynamic allocation path")
+			}
+			compileLLVMToObject(t, llc, triple, "dynamic-large.ll", "dynamic-large.o", ir)
+			native := runtime.GOARCH == "arm64" && ((runtime.GOOS == "darwin" && strings.Contains(triple, "apple")) ||
+				(runtime.GOOS == "linux" && strings.Contains(triple, "linux")) ||
+				(runtime.GOOS == "freebsd" && strings.Contains(triple, "freebsd")))
+			if native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "dynamic-large", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func TestARM64DynamicStackLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64DynamicStackRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "dynamic.ll", "dynamic.o", ir)
+			if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && triple == "aarch64-apple-darwin" {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "dynamic", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func TestARM64DynamicStackRejectsUnprovedRelocation(t *testing.T) {
+	for _, body := range []string{
+		"MOVD $8(RSP),R3\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"MOVD RSP,R20\nMOVD $8(R20),R3\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"MOVD RSP,R3\nMOVD R3,(R0)\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"MOVD RSP,R3\nMOVD R3,8(RSP)\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"CMP RSP,R0\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"BL callee(SB)\nSUB R1,RSP\nMOVD R2,(RSP)",
+		"SUB R1,RSP\nSUB R2,RSP\nMOVD R2,(RSP)",
+		"again:\nSUB R1,RSP\nMOVD R2,(RSP)\nCBNZ R0,again",
+		"MOVD RSP,R3\nEOR $31,R3\nSUB R1,RSP\nMOVD R2,(RSP)",
+	} {
+		t.Run(body, func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT dynamic(SB),$0-0\n"+body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"dynamic": {Name: "dynamic", Ret: Void}}}); err == nil {
+				t.Fatal("accepted a frame whose pointers cannot be relocated safely")
+			}
+		})
+	}
+}
diff --git a/arm64_stack_memory.go b/arm64_stack_memory.go
new file mode 100644
index 000000000..2c0a5bb59
--- /dev/null
+++ b/arm64_stack_memory.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Size the statically expressed displacement and transfer. Register/vector
+// indexes are address computations, not declarations of additional stack
+// storage; their source program must keep accesses inside its allocated frame.
+func arm64StackMemoryExtent(ins Instr, mem MemRef) (low, high, width int64, err error) {
+	low, high, width = mem.Off, mem.Off, 64
+	op := strings.ToUpper(string(ins.Op))
+	if strings.HasPrefix(op, "Z") || strings.HasPrefix(op, "P") {
+		// At most four scalable vectors, each at most 256 bytes. Predicate
+		// and widening/narrowing memory forms require no larger footprint.
+		width = 4 * 256
+	}
+	if mem.OffRaw == "" {
+		return
+	}
+	if arm64NamedStackOffset(mem) {
+		return
+	}
+	if multiplier, ok := parseVectorLengthScaleExpr(mem.OffRaw); ok {
+		if multiplier < -arm64MaxLocalStackSpan/256 || multiplier > arm64MaxLocalStackSpan/256 {
+			err = fmt.Errorf("scalable stack displacement exceeds allocation limit")
+			return
+		}
+		// Using full vector bytes also conservatively covers predicate-sized
+		// VL units and narrower element-memory ratios.
+		low, high = 0, multiplier*256
+		if low > high {
+			low, high = high, low
+		}
+		return
+	}
+	err = fmt.Errorf("unresolved stack displacement %q", mem.OffRaw)
+	return
+}
+
+// Entry emission initializes non-argument GP registers to zero. Prove only
+// registers untouched by the entire function, rather than guessing the value
+// of a dynamic writeback register. Calls and unknown effects invalidate this
+// small proof. This also keeps isolated operand-form probes faithful to their
+// actual initialized state.
+func (c *arm64Ctx) stackUnwrittenZeroRegisters() uint32 {
+	if len(c.sig.Args) != 0 {
+		return 0
+	}
+	written := uint32(1 << 31)
+	for _, block := range c.blocks {
+		for _, original := range block.instrs {
+			if original.Op == OpWORD && len(original.Args) == 1 {
+				word := uint32(original.Args[0].Imm)
+				if word&0xfffffc1f == 0xd65f0000 {
+					continue
+				}
+				mask, known := arm64RawPoolGPWrites(word)
+				if !known {
+					return 0
+				}
+				written |= mask
+				continue
+			}
+			ins := arm64StackInstruction(original)
+			op := strings.ToUpper(string(ins.Op))
+			if op == "BL" || op == "BLR" || op == "CALL" || op == "SVC" {
+				return 0
+			}
+			mark := func(reg Reg) {
+				if index, ok := arm64StackIndex(reg); ok {
+					written |= 1 << uint(index)
+				}
+			}
+			for _, arg := range ins.Args {
+				switch arg.Kind {
+				case OpReg, OpRegShift, OpRegExtend:
+					mark(arg.Reg)
+				case OpRegList:
+					for _, reg := range arg.RegList {
+						mark(reg)
+					}
+				case OpMem:
+					if strings.HasSuffix(op, ".P") || strings.HasSuffix(op, ".W") {
+						mark(arg.Mem.Base)
+					}
+				}
+			}
+		}
+	}
+	return ^written
+}
diff --git a/arm64_stack_memory_test.go b/arm64_stack_memory_test.go
new file mode 100644
index 000000000..c1e882143
--- /dev/null
+++ b/arm64_stack_memory_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "testing"
+
+func TestARM64StackMemoryScalableExtent(t *testing.T) {
+	for _, test := range []struct {
+		op, source string
+		low, high  int64
+	}{
+		{"PLDR", "-VL*256", -65536, 0},
+		{"ZLDR", "VL*255", 0, 65280},
+		{"ZST4D", "-VL*2", -512, 0},
+		{"PPRFB", "VL*1", 0, 256},
+	} {
+		low, high, width, err := arm64StackMemoryExtent(Instr{Op: Op(test.op)}, MemRef{Base: SP, OffRaw: test.source})
+		if err != nil || low != test.low || high != test.high || width != 1024 {
+			t.Fatalf("%s %s: got [%d,%d]+%d, %v", test.op, test.source, low, high, width, err)
+		}
+	}
+	for _, source := range []string{"unknown_offset", "VL*8192", "-VL*8192"} {
+		if _, _, _, err := arm64StackMemoryExtent(Instr{Op: "ZLDR"}, MemRef{Base: "RSP", OffRaw: source}); err == nil {
+			t.Fatalf("accepted unresolved or excessive displacement %s", source)
+		}
+	}
+}
+
+func TestARM64StackWritebackZeroRegisterProof(t *testing.T) {
+	for _, test := range []struct {
+		name, prefix string
+		failure      bool
+	}{
+		{"zero-entry", "", false},
+		{"written-index", "MOVD $16,R7\n", true},
+		{"call-clobber", "BL callee(SB)\n", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchARM64, "TEXT zero_writeback(SB),$0-0\n"+test.prefix+"VST1.P [V0.B16],(RSP)(R7)\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := &arm64Ctx{blocks: arm64SplitBlocks(file.Funcs[0])}
+			_, _, err = ctx.stackMovementRange()
+			if (err != nil) != test.failure {
+				t.Fatalf("error=%v; want failure=%v", err, test.failure)
+			}
+		})
+	}
+}
diff --git a/arm64_stack_tail_source_oracle_test.go b/arm64_stack_tail_source_oracle_test.go
new file mode 100644
index 000000000..68796f89d
--- /dev/null
+++ b/arm64_stack_tail_source_oracle_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64StackTailTargetSource() string {
+	var source strings.Builder
+	source.WriteString("TEXT ·arm64ABI0TailTarget(SB),4,$0-144\nMOVD $0,R0\n")
+	for i := 0; i < 17; i++ {
+		fmt.Fprintf(&source, "MOVD a%d+%d(FP),R1\nADD R1,R0\n", i, i*8)
+	}
+	source.WriteString("MOVD R0,ret+136(FP)\nRET\n")
+	return source.String()
+}
+
+func arm64StackTailOriginalSource() string {
+	var source strings.Builder
+	source.WriteString("TEXT ·arm64ABI0StackTail(SB),$144-0\n")
+	for i := 0; i < 17; i++ {
+		fmt.Fprintf(&source, "MOVD $%d,R0\nMOVD R0,%d(RSP)\n", i+1, 8+i*8)
+	}
+	source.WriteString("JMP ·arm64ABI0TailTarget(SB)\n")
+	return source.String()
+}
+
+func TestCrossLinuxRuntimeMatrixARM64StackTailOriginalSPOracle(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	source := `TEXT ·Measure(SB),516,$0-16
+MOVD RSP,R19
+MOVD R30,R23
+MOVD R29,R24
+CALL ·arm64ABI0StackTail(SB)
+MOVD 144(RSP),R1
+SUB R19,RSP,R0
+MOVD R19,RSP
+MOVD R24,R29
+MOVD R23,R30
+MOVD R0,delta+0(FP)
+MOVD R1,sum+8(FP)
+RET
+` + arm64StackTailOriginalSource() + arm64StackTailTargetSource()
+	runARM64LocalRegisterGoOracle(t, source, `package main
+func Measure() (int64,uint64)
+func arm64ABI0StackTail()
+func arm64ABI0TailTarget(uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64,uint64) uint64
+func main() {
+  for i:=0;i<5;i++ {
+    delta,sum:=Measure()
+    if delta!=-160 || sum!=153 { println(delta,sum); panic("original framed JMP does not unwind its Go frame") }
+  }
+}
+`, len(runner) != 0)
+	t.Log("native Go original 17-slot JMP computes 153 but leaves caller SP delta -160; real caller state is restored by observation trampoline")
+}
+
+// Matching incoming Go ABI0 slots can be forwarded without manufacturing an
+// outgoing frame. This is a real frameless source tail, including arguments
+// beyond both the Go and platform-native register banks.
+func TestCrossLinuxRuntimeMatrixARM64StackTailIncomingFrame(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	source := "TEXT ·Pass(SB),4,$0-144\nB ·arm64ABI0TailTarget(SB)\n" + arm64StackTailTargetSource()
+	var parameters, arguments strings.Builder
+	for i := 0; i < 17; i++ {
+		if i != 0 {
+			parameters.WriteString(",")
+			arguments.WriteString(",")
+		}
+		parameters.WriteString("uint64")
+		fmt.Fprintf(&arguments, "a+%d", i+1)
+	}
+	decl := fmt.Sprintf("func Pass(%s) uint64\nfunc arm64ABI0TailTarget(%s) uint64\n", parameters.String(), parameters.String())
+	runARM64LocalRegisterGoOracle(t, source, "package main\n"+decl+fmt.Sprintf(`func main() {
+  for _,a:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    if Pass(%s)!=a*17+153 { panic("proper incoming-frame tail mismatch") }
+  }
+}
+`, arguments.String()), len(runner) != 0)
+	pkg := mustGoPackage(t, "test/stacktail", "package stacktail\n"+decl)
+	translate := func(target string) string {
+		tr, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+			GOARCH: "arm64", TargetTriple: target,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer tr.Module.Dispose()
+		return tr.Module.String()
+	}
+	for _, target := range []string{"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-apple-darwin", "aarch64-pc-windows-msvc"} {
+		compileLLVMToObject(t, llc, target, "incoming-tail.ll", "incoming-tail.o", translate(target))
+	}
+	cParams := strings.TrimSuffix(strings.Repeat("uint64_t,", 17), ",")
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "incoming_tail", triple, translate(triple), fmt.Sprintf(`#include <stdint.h>
+extern uint64_t Pass(%s);
+int main(void) {
+  uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) {
+    uint64_t a=inputs[i];
+    if (Pass(%s)!=a*17+153) return 1;
+  }
+  return 0;
+}
+`, cParams, arguments.String()), runner)
+}
diff --git a/arm64_structure_dispatch_test.go b/arm64_structure_dispatch_test.go
new file mode 100644
index 000000000..80d438a2e
--- /dev/null
+++ b/arm64_structure_dispatch_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func arm64StructureDispatchInstruction(t *testing.T, syntax string) Instr {
+	t.Helper()
+	file, err := Parse(ArchARM64, "TEXT dispatch(SB),$0-0\n"+syntax+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func arm64StructureDispatchIR(t *testing.T, op Op, post bool, input, canonical Instr, vectorDispatcher bool) string {
+	t.Helper()
+	snapshot := input
+	snapshot.Args = append([]Operand(nil), input.Args...)
+	for index := range snapshot.Args {
+		snapshot.Args[index].RegList = append([]Reg(nil), input.Args[index].RegList...)
+	}
+	c, output := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{canonical}}, FuncSig{Ret: Void}, nil)
+	var ok, terminated bool
+	var err error
+	if vectorDispatcher {
+		ok, terminated, err = c.lowerVec(op, post, input)
+	} else {
+		ok, terminated, err = c.lowerARM64StructureLoadStore(op, post, input)
+	}
+	if !ok || terminated || err != nil {
+		t.Fatalf("%s legacy=%v vector=%v: handled=%v terminated=%v err=%v", canonical.Raw, input.Op == "", vectorDispatcher, ok, terminated, err)
+	}
+	if !reflect.DeepEqual(input, snapshot) {
+		t.Fatal("semantic lowering changed the caller's original instruction")
+	}
+	return output.String()
+}
+
+func TestARM64StructureDispatchLegacyAndCanonicalAgree(t *testing.T) {
+	// The independent Go table enumerator spans every whole/replicate form.
+	for _, tc := range arm64RawStructureCases() {
+		canonical := arm64StructureDispatchInstruction(t, tc.syntax)
+		legacy := canonical
+		legacy.Op = ""
+		want := arm64StructureDispatchIR(t, Op(tc.op), tc.post != 0, canonical, canonical, false)
+		for _, vector := range []bool{false, true} {
+			for _, input := range []Instr{canonical, legacy} {
+				got := arm64StructureDispatchIR(t, Op(tc.op), tc.post != 0, input, canonical, vector)
+				if got != want {
+					t.Fatalf("semantic dispatch differs for %s, empty-op=%v vector=%v", tc.syntax, input.Op == "", vector)
+				}
+			}
+		}
+	}
+	for _, syntax := range []string{
+		"VLD1 (R0),V0.B[15]", "VLD1.P 2(R0),V0.H[7]",
+		"VST1 V0.S[3],(R0)", "VST1.P V0.D[1],(R0)(R1)",
+	} {
+		canonical := arm64StructureDispatchInstruction(t, syntax)
+		legacy := canonical
+		legacy.Op = ""
+		op := arm64ControlOp(canonical)
+		post := canonical.Op != op
+		want := arm64StructureDispatchIR(t, op, post, canonical, canonical, false)
+		if got := arm64StructureDispatchIR(t, op, post, legacy, canonical, true); got != want {
+			t.Fatalf("empty-op lane semantics differs for %s", syntax)
+		}
+	}
+}
+
+func TestARM64StructureDispatchConflictHasNoIRSideEffects(t *testing.T) {
+	for _, tc := range []struct {
+		op     Op
+		post   bool
+		syntax string
+	}{
+		{"VLD1", false, "VLD2 (R0),[V0.S4,V1.S4]"},
+		{"VST2", false, "VST1 [V0.S4,V1.S4],(R0)"},
+		{"VLD1R", false, "VLD1 (R0),[V0.S4]"},
+		{"VLD1", true, "VLD1 (R0),[V0.S4]"},
+		{"VST1", false, "VST1.P [V0.S4],16(R0)"},
+		{"ADD", false, "VLD1 (R0),[V0.S4]"},
+		{"VMOV", false, "VLD1 (R0),[V0.S4]"},
+		{"VLD1", false, "VMOV V0.B16,V1.B16"},
+		{"VLD1", false, "VLD1.W 16(R0),[V0.S4]"},
+		{"VLD1.P", true, "VLD1.P 16(R0),[V0.S4]"},
+	} {
+		ins := arm64StructureDispatchInstruction(t, tc.syntax)
+		for _, vector := range []bool{false, true} {
+			snapshot := ins
+			snapshot.Args = append([]Operand(nil), ins.Args...)
+			for index := range snapshot.Args {
+				snapshot.Args[index].RegList = append([]Reg(nil), ins.Args[index].RegList...)
+			}
+			c, output := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			before := output.String()
+			var ok, terminated bool
+			var err error
+			if vector {
+				ok, terminated, err = c.lowerVec(tc.op, tc.post, ins)
+			} else {
+				ok, terminated, err = c.lowerARM64StructureLoadStore(tc.op, tc.post, ins)
+			}
+			if !ok || terminated || err == nil {
+				t.Errorf("op=%s post=%v source=%s vector=%v: (%v,%v,%v), want handled conflict", tc.op, tc.post, ins.Op, vector, ok, terminated, err)
+			}
+			if output.String() != before {
+				t.Errorf("conflicting %s/%s emitted partial IR", tc.op, ins.Op)
+			}
+			if !reflect.DeepEqual(ins, snapshot) {
+				t.Error("conflicting dispatch changed the caller's original instruction")
+			}
+		}
+	}
+}
+
+func TestARM64StructureDispatchUnrelatedSourceIsUnhandled(t *testing.T) {
+	ins := arm64StructureDispatchInstruction(t, "ADD $1,R0,R1")
+	for _, legacy := range []bool{false, true} {
+		input := ins
+		if legacy {
+			input.Op = ""
+		}
+		c, output := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+		before := output.String()
+		ok, terminated, err := c.lowerARM64StructureLoadStore("ADD", false, input)
+		if ok || terminated || err != nil || output.String() != before {
+			t.Fatalf("unrelated source legacy=%v: (%v,%v,%v), want unhandled without IR effects", legacy, ok, terminated, err)
+		}
+	}
+}
+
+func TestARM64StructureDispatchOldLaneHelpersMatchGo(t *testing.T) {
+	for _, tc := range []struct {
+		memory string
+		lane   string
+		width  int
+	}{
+		{"R21", "V4.B[3]", 1},
+		{"R20", "V3.D[1]", 8},
+		{"R20", "V4.S[1]", 4},
+		{"R20", "V5.H[3]", 2},
+	} {
+		// Preserve the invalid original first-party helper source. Go case
+		// 97 requires one element's actual width for immediate lane .P.
+		original := fmt.Sprintf("VLD1.P (%s),%s", tc.memory, tc.lane)
+		corrected := fmt.Sprintf("VLD1.P %d(%s),%s", tc.width, tc.memory, tc.lane)
+		for _, syntax := range []string{original, corrected} {
+			valid := syntax == corrected
+			requireARM64GoAssemblerResult(t, "TEXT laneHelper(SB),516,$0-0\n"+syntax+"\nUNDEF\n", valid)
+			ins := arm64StructureDispatchInstruction(t, syntax)
+			c, output := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			before := output.String()
+			ok, terminated, err := c.lowerVec("VLD1", true, ins)
+			if !ok || terminated || (err == nil) != valid {
+				t.Fatalf("%s: (%v,%v,%v), want Go-valid=%v", syntax, ok, terminated, err, valid)
+			}
+			if !valid && output.String() != before {
+				t.Fatalf("Go-rejected %s emitted partial IR", syntax)
+			}
+		}
+	}
+}
+
+func TestARM64StructureDispatchRawReplicateProducer(t *testing.T) {
+	for count := 1; count <= 4; count++ {
+		for size := 0; size <= 3; size++ {
+			for _, q := range []bool{false, true} {
+				for _, rm := range []int{-1, 31, 7} {
+					post := rm >= 0
+					encodedRM := rm
+					if !post {
+						encodedRM = 0
+					}
+					word := encodeARM64RawLDnRForTest(count, size, q, post, encodedRM, 3, 30)
+					form, valid := decodeARM64RawLDnR(word)
+					if !valid {
+						t.Fatalf("independent replicate encoding %#08x rejected", word)
+					}
+					arrangement := arm64VectorArrangementName(form.arrangement)
+					memory, suffix := "(R3)", ""
+					if post {
+						suffix = ".P"
+						if rm == 31 {
+							memory = fmt.Sprintf("%d(R3)", count*(8<<size)/8)
+						} else {
+							memory += "(R7)"
+						}
+					}
+					op := Op(fmt.Sprintf("VLD%dR", count))
+					canonical := arm64StructureDispatchInstruction(t, string(op)+suffix+" "+memory+","+arm64TestVectorList(30, count, arrangement))
+					want := arm64StructureDispatchIR(t, op, post, canonical, canonical, false)
+					c, output := newARM64CtxWithFuncForTest(t, Func{Instrs: []Instr{canonical}}, FuncSig{Ret: Void}, nil)
+					if err := c.lowerRawLDnR(form); err != nil {
+						t.Fatal(err)
+					}
+					if output.String() != want {
+						t.Fatalf("raw replicate producer %#08x differs from canonical typed form", word)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm64_structure_memory.go b/arm64_structure_memory.go
new file mode 100644
index 000000000..ea688f4d1
--- /dev/null
+++ b/arm64_structure_memory.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// One operand grammar supplies lowering and both frame/control proofs. The
+// extent is the encoded transfer, not the width of LLVM's vector backing or
+// (for VLD2-4) necessarily the number of registers written in Go's C_LIST.
+type arm64StructureMemoryForm struct {
+	op              Op
+	memory          Operand
+	registers       []Reg
+	arrangement     arm64VectorArrangement
+	load, replicate bool
+	lane            int // -1 means a whole-register or replicate transfer
+	post            bool
+	increment       int64
+	index           Reg
+}
+
+func (f arm64StructureMemoryForm) width() int64 {
+	width := int64(f.arrangement.elementBits / 8 * len(f.registers))
+	if f.lane < 0 && !f.replicate {
+		width *= int64(f.arrangement.lanes)
+	}
+	return width
+}
+
+func parseARM64StructureMemory(ins Instr) (form arm64StructureMemoryForm, handled bool, err error) {
+	if ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		word := uint32(ins.Args[0].Imm)
+		if raw, valid := decodeARM64RawStructureLane(word); valid {
+			return raw.memoryForm(), true, nil
+		}
+		if word&0xbf000000 == 0x0c000000 || word&0xbf000000 == 0x0d000000 {
+			decoded, err := decodeARM64RawWordInstruction(ins)
+			if err != nil {
+				return form, true, err
+			}
+			return parseARM64StructureMemory(decoded)
+		}
+	}
+	op := arm64ControlOp(ins)
+	count, handled := arm64StructureLoadStoreCounts[op]
+	if !handled {
+		return form, false, nil
+	}
+	form.op, form.load, form.replicate, form.lane = op, strings.HasPrefix(string(op), "VLD"), strings.HasSuffix(string(op), "R"), -1
+	suffix := strings.TrimPrefix(string(ins.Op), string(op))
+	if (suffix != "" && suffix != ".P") || len(ins.Args) != 2 {
+		return form, true, fmt.Errorf("arm64 %s requires memory/vector operands and only optional .P: %q", op, ins.Raw)
+	}
+	form.post = suffix == ".P"
+	vector := ins.Args[0]
+	form.memory = ins.Args[1]
+	if form.load {
+		form.memory, vector = ins.Args[0], ins.Args[1]
+	}
+	if form.memory.Kind != OpMem {
+		return form, true, fmt.Errorf("arm64 %s requires a register-based memory operand: %q", op, ins.Raw)
+	}
+
+	written := 1
+	if (op == "VLD1" || op == "VST1") && vector.Kind == OpReg {
+		kind, lane, valid := arm64ParseVRegLane(vector.Reg)
+		first, vectorOK := arm64ParseVReg(vector.Reg)
+		if !valid || !vectorOK {
+			return form, true, fmt.Errorf("arm64 %s requires a valid vector lane: %q", op, ins.Raw)
+		}
+		bits := map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[kind]
+		form.arrangement = arm64VectorArrangement{elementBits: bits, lanes: 128 / bits}
+		form.registers, form.lane = []Reg{Reg(fmt.Sprintf("V%d", first))}, lane
+	} else {
+		if vector.Kind != OpRegList || len(vector.RegList) < 1 || len(vector.RegList) > 4 {
+			return form, true, fmt.Errorf("arm64 %s requires one through four arranged vector registers: %q", op, ins.Raw)
+		}
+		listed := vector.RegList
+		arrangement, valid := parseARM64VectorArrangement(listed[0])
+		first, vectorOK := arm64ParseVReg(listed[0])
+		if !valid || !vectorOK {
+			return form, true, fmt.Errorf("arm64 %s requires an arranged vector list: %q", op, ins.Raw)
+		}
+		for i, reg := range listed {
+			other, valid := parseARM64VectorArrangement(reg)
+			index, vectorOK := arm64ParseVReg(reg)
+			if !valid || !vectorOK || other != arrangement || index != (first+i)%32 {
+				return form, true, fmt.Errorf("arm64 %s requires consecutive same-arrangement registers: %q", op, ins.Raw)
+			}
+		}
+		written, form.arrangement = len(listed), arrangement
+		if op == "VLD1" || op == "VST1" {
+			count = written
+		} else if !form.replicate && arrangement.elementBits == 64 && arrangement.lanes == 1 {
+			// Go's C_LIST encoder accepts Q=0/size=3 for LD/ST2-4,
+			// but the raw architectural decoder correctly rejects it.
+			return form, true, fmt.Errorf("%w: ARM64 %s D1 has a reserved original Go structure encoding: %q", ErrProbeNeedsContext, op, ins.Raw)
+		}
+		for i := 0; i < count; i++ {
+			form.registers = append(form.registers, Reg(fmt.Sprintf("V%d.%s", (first+i)%32, arm64VectorArrangementName(arrangement))))
+		}
+	}
+
+	mem := form.memory.Mem
+	if mem.Sym != "" || mem.OffRaw != "" || mem.IndexExt != "" || (mem.Scale != 0 && mem.Scale != 1) ||
+		(!isARM64GeneralOrZeroReg(mem.Base) && !arm64StackReg(mem.Base)) {
+		return form, true, fmt.Errorf("arm64 %s requires a plain GP/SP base: %q", op, ins.Raw)
+	}
+	if mem.Base == ZR || arm64StackReg(mem.Base) {
+		mem.Base = SP // encoding Rn=31 selects SP, not the zero register.
+	}
+	if !form.post {
+		if mem.Index != "" || form.lane < 0 && mem.Off != 0 {
+			return form, true, fmt.Errorf("arm64 %s non-post form requires (Rbase): %q", op, ins.Raw)
+		}
+		// Go cases 96/97 accept nonzero C_LOREG for a no-post lane,
+		// but set Rm=31, which is reserved in that encoding. Do not turn
+		// the original source into a valid zero-offset access silently.
+		if form.lane >= 0 && mem.Off != 0 {
+			return form, true, fmt.Errorf("%w: ARM64 %s no-post lane displacement has a reserved original Go Rm encoding: %q", ErrProbeNeedsContext, op, ins.Raw)
+		}
+	} else if mem.Index != "" {
+		if mem.Off != 0 || !isARM64GeneralOrZeroReg(mem.Index) {
+			return form, true, fmt.Errorf("arm64 %s register post-increment requires (Rbase)(Rindex): %q", op, ins.Raw)
+		}
+		if mem.Index != ZR {
+			form.index = mem.Index
+		}
+	} else {
+		expected := form.width()
+		if form.lane < 0 {
+			expected = int64(written * form.arrangement.elementBits / 8)
+			if !form.replicate {
+				expected *= int64(form.arrangement.lanes)
+			}
+		}
+		if form.lane >= 0 && mem.Off == 0 || mem.Off != 0 && mem.Off != expected ||
+			mem.Off != 0 && form.lane < 0 && op != "VLD1" && op != "VST1" && written != count {
+			return form, true, fmt.Errorf("arm64 %s invalid immediate post-increment: %q", op, ins.Raw)
+		}
+	}
+	if form.post && form.index == "" {
+		form.increment = form.width()
+	}
+	// The access itself always uses the original base. A post displacement
+	// describes writeback, not an address offset.
+	mem.Off, mem.Index = 0, ""
+	form.memory.Mem = mem
+	return form, true, nil
+}
+
+func (raw arm64RawStructureLane) memoryForm() arm64StructureMemoryForm {
+	base := Reg(fmt.Sprintf("R%d", raw.base))
+	if raw.base == 31 {
+		base = SP
+	}
+	form := arm64StructureMemoryForm{
+		memory: Operand{Kind: OpMem, Mem: MemRef{Base: base}},
+		load:   raw.load, lane: raw.lane, post: raw.post,
+		arrangement: arm64VectorArrangement{elementBits: raw.elementBits, lanes: 128 / raw.elementBits},
+	}
+	for i := 0; i < raw.count; i++ {
+		form.registers = append(form.registers, Reg(fmt.Sprintf("V%d", (raw.firstRegister+i)%32)))
+	}
+	if raw.post {
+		if raw.postRegister == 31 {
+			form.increment = form.width()
+		} else {
+			form.index = Reg(fmt.Sprintf("R%d", raw.postRegister))
+		}
+	}
+	return form
+}
+
+func (c *arm64Ctx) structureAddress(form arm64StructureMemoryForm) (address, increment string, err error) {
+	address, err = c.loadReg(form.memory.Mem.Base)
+	if err != nil || !form.post {
+		return address, "", err
+	}
+	if form.index != "" {
+		increment, err = c.loadReg(form.index)
+	} else {
+		increment = c.imm64(form.increment)
+	}
+	return address, increment, err
+}
diff --git a/arm64_sve_count_features.go b/arm64_sve_count_features.go
new file mode 100644
index 000000000..f2e156faf
--- /dev/null
+++ b/arm64_sve_count_features.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Custom FuncSig.Attrs may suppress optional source-feature inference, but
+// cannot make an emitted native count intrinsic executable without SVE. Merge
+// the actual LLVM attribute, including referenced groups, rather than appending
+// a duplicate textual key or replacing other caller-selected features.
+func completeARM64SVECountFeatures(module llvm.Module) error {
+	callers := make(map[llvm.Value]bool)
+	for _, suffix := range []string{"b", "h", "w", "d"} {
+		intrinsic := module.NamedFunction("llvm.aarch64.sve.cnt" + suffix)
+		if intrinsic.IsNil() {
+			continue
+		}
+		for use := intrinsic.FirstUse(); !use.IsNil(); use = use.NextUse() {
+			instruction := use.User().IsAInstruction()
+			if !instruction.IsNil() {
+				callers[instruction.InstructionParent().Parent()] = true
+			}
+		}
+	}
+	for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+		if !callers[function] {
+			continue
+		}
+		features, hasSVE := "", false
+		for _, attribute := range function.GetFunctionAttributes() {
+			if attribute.IsString() && attribute.GetStringKind() == "target-features" {
+				features = attribute.GetStringValue()
+			}
+		}
+		for _, feature := range strings.Split(features, ",") {
+			switch strings.TrimSpace(feature) {
+			case "-sve":
+				return fmt.Errorf("%w: ARM64 count in %q conflicts with explicit -sve", ErrProbeNeedsContext, function.Name())
+			case "+sve":
+				hasSVE = true
+			}
+		}
+		if !hasSVE {
+			if features != "" {
+				features += ","
+			}
+			function.AddTargetDependentFunctionAttr("target-features", features+"+sve")
+		}
+	}
+	return nil
+}
diff --git a/arm64_sve_count_index_runtime_test.go b/arm64_sve_count_index_runtime_test.go
new file mode 100644
index 000000000..f0c8bf420
--- /dev/null
+++ b/arm64_sve_count_index_runtime_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Called by the required Linux cross-runtime matrix: QEMU supplies SVE on
+// runners whose host CPU does not have it. No host-feature skip is involved.
+func testARM64RawSVECountIndexRuntime(t *testing.T, llc string) {
+	var source, main strings.Builder
+	sigs := make(map[string]FuncSig)
+	main.WriteString(`#include <stdint.h>
+#include <string.h>
+#include <sys/prctl.h>
+
+static uint64_t count(unsigned pattern, unsigned lanes) {
+  if (pattern == 31) return lanes;
+  if (pattern == 30) return lanes / 3 * 3;
+  if (pattern == 29) return lanes / 4 * 4;
+  if (pattern == 0) {
+    unsigned n = 1;
+    while (n * 2 <= lanes) n *= 2;
+    return n;
+  }
+  unsigned n = pattern <= 8 ? pattern : pattern <= 13 ? 1u << (pattern - 5) : 0;
+  return n <= lanes ? n : 0;
+}
+`)
+	var checks strings.Builder
+	for size := uint32(0); size < 4; size++ {
+		for pattern := uint32(0); pattern < 32; pattern++ {
+			name := fmt.Sprintf("predicate_count_%d_%d", size, pattern)
+			tested := uint32(0x2518e000) | size<<22 | pattern<<5 | 1
+			governing := uint32(0x2518e000) | size<<22 | (31-pattern)<<5 | 15
+			count := uint32(0x25208000) | size<<22 | 15<<10 | 1<<5 | 10
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nWORD $%#08x\nWORD $%#08x\nWORD $%#08x\nMOVD R10,ret+8(FP)\nRET\n", name, tested, governing, count)
+			sigs[name] = crossUnarySig("arm64", name)
+			fmt.Fprintf(&main, "extern uint64_t %s(uint64_t);\n", name)
+			fmt.Fprintf(&checks, `    {
+      uint64_t tested = count(%d, vl / %d), governing = count(%d, vl / %d);
+      if (%s(x) != (tested < governing ? tested : governing)) return 6;
+    }
+`, pattern, 1<<size, 31-pattern, 1<<size, name)
+			selectName := name + "_select"
+			all := uint32(0x2518e3e2) | size<<22 // P2 is the inactive selection.
+			selectWord := uint32(0x25004210 | 2<<16 | 1<<5 | 15<<10 | 3)
+			selectCount := uint32(0x25208000) | size<<22 | 2<<10 | 3<<5 | 10
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nWORD $%#08x\nWORD $%#08x\nWORD $%#08x\nWORD $%#08x\nWORD $%#08x\nMOVD R10,ret+8(FP)\nRET\n", selectName, tested, governing, all, selectWord, selectCount)
+			sigs[selectName] = crossUnarySig("arm64", selectName)
+			fmt.Fprintf(&main, "extern uint64_t %s(uint64_t);\n", selectName)
+			fmt.Fprintf(&checks, `    {
+      uint64_t tested = count(%d, vl / %d), governing = count(%d, vl / %d);
+      uint64_t active = tested < governing ? tested : governing;
+      if (%s(x) != vl / %d - governing + active) return 7;
+    }
+`, pattern, 1<<size, 31-pattern, 1<<size, selectName, 1<<size)
+		}
+		for operation, base := range []uint32{0x0420e000, 0x0430e000, 0x0430e400} {
+			for pattern := uint32(0); pattern < 32; pattern++ {
+				name := fmt.Sprintf("count_%d_%d_%d", size, operation, pattern)
+				multiplier := pattern%16 + 1
+				word := base | size<<22 | (multiplier-1)<<16 | pattern<<5 | 10
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVD x+0(FP),R10\nWORD $%#08x\nMOVD R10,ret+8(FP)\nRET\n", name, word)
+				sigs[name] = crossUnarySig("arm64", name)
+				fmt.Fprintf(&main, "extern uint64_t %s(uint64_t);\n", name)
+				want := fmt.Sprintf("count(%d, vl / %d) * %d", pattern, 1<<size, multiplier)
+				if operation == 1 {
+					want = "x + " + want
+				} else if operation == 2 {
+					want = "x - " + want
+				}
+				fmt.Fprintf(&checks, "    if (%s(x) != (%s)) return %d;\n", name, want, 1+operation)
+			}
+		}
+		for form := uint32(0); form < 4; form++ {
+			name := fmt.Sprintf("index_%d_%d", size, form)
+			start, step := uint32(16), uint32(15)
+			if form&1 != 0 {
+				start = 1
+			}
+			if form&2 != 0 {
+				step = 2
+			}
+			word := uint32(0x04204000) | size<<22 | form<<10 | start<<5 | step<<16 | 16
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-24\nMOVD out+0(FP),R0\nMOVD start+8(FP),R1\nMOVD step+16(FP),R2\nWORD $%#08x\nWORD $0x2518e3e0\nZST1B [Z16.B],P0,(R0)\nRET\n", name, word)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I64, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: I64, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}}}
+			fmt.Fprintf(&main, "extern void %s(void *, int64_t, int64_t);\n", name)
+			wantStart, wantStep := -16, 15
+			if form&1 != 0 {
+				wantStart = -257
+			}
+			if form&2 != 0 {
+				wantStep = 129
+			}
+			fmt.Fprintf(&checks, `    %s(buf, -257, 129);
+    for (unsigned i = 0; i < vl / %d; i++) {
+      uint64_t got = 0, want = (uint64_t)((int64_t)%d + (int64_t)i * %d);
+      memcpy(&got, buf + i * %d, %d);
+      if (memcmp(&got, &want, %d) != 0) return 4;
+    }
+`, name, 1<<size, wantStart, wantStep, 1<<size, 1<<size, 1<<size)
+		}
+	}
+	mainC := arm64SVEVectorLengthMain(main.String(),
+		"unsigned char buf[256] = {0};\nuint64_t x = UINT64_MAX - 3;\n"+checks.String())
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "arm64", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "raw_sve_count_index", triple, ir, mainC,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_sve_dup_indexed_test.go b/arm64_sve_dup_indexed_test.go
new file mode 100644
index 000000000..8631ed0be
--- /dev/null
+++ b/arm64_sve_dup_indexed_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Go's encodeImm2Tsz and LLVM's sve_int_perm_dup_i encode an index within
+// 512 bits, independently of the vector length currently selected at runtime.
+func TestARM64SVEDupIndexedCompleteGrammar(t *testing.T) {
+	var lines []string
+	var forms []arm64RawSVEDupElement
+	var source strings.Builder
+	source.WriteString("TEXT dup_indexed_forms(SB),$0-0\n")
+	for size, width := range "bhsdq" {
+		for lane := 0; lane < 64>>size; lane++ {
+			lines = append(lines, fmt.Sprintf("dup z2.%c,z31.%c[%d]", width, width, lane))
+			forms = append(forms, arm64RawSVEDupElement{elementBits: 8 << size, lane: lane, source: 31, destination: 2})
+			fmt.Fprintf(&source, "ZDUP Z31.%c[%d],Z2.%c\n", "BHSDQ"[size], lane, "BHSDQ"[size])
+		}
+	}
+	source.WriteString("RET\n")
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	for index, word := range assembleARM64LLVMWords(t, lines, "+sve") {
+		if got, ok := decodeARM64RawSVEDupElement(word); !ok || got != forms[index] {
+			t.Errorf("%s: decoded %+v/%v, want %+v", lines[index], got, ok, forms[index])
+		}
+	}
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"dup_indexed_forms": {Name: "dup_indexed_forms", Ret: Void}}}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestARM64SVEDupIndexedRejectsOutOfRangeLanes(t *testing.T) {
+	for size, width := range "BHSDQ" {
+		for _, lane := range []int{-1, 64 >> size} {
+			instruction := fmt.Sprintf("ZDUP Z31.%c[%d],Z2.%c", width, lane, width)
+			t.Run(instruction, func(t *testing.T) {
+				source := "TEXT bad_dup(SB),$0-0\n" + instruction + "\nRET\n"
+				requireARM64SVEGoAssemblerResult(t, source, false)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					return
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+					Sigs: map[string]FuncSig{"bad_dup": {Name: "bad_dup", Ret: Void}}})
+				if err == nil {
+					t.Fatalf("accepted out-of-range lane: %s", instruction)
+				}
+			})
+		}
+	}
+}
+
+func arm64SVEDupIndexedRuntime(t *testing.T, triple string) (string, string) {
+	t.Helper()
+	var machine []string
+	var cases strings.Builder
+	count := 0
+	for size, width := range "bhsdq" {
+		for lane := 0; lane < 64>>size; lane++ {
+			for _, destination := range []int{2, 31} {
+				machine = append(machine, "ldr z31,[x1]",
+					fmt.Sprintf("dup z%d.%c,z31.%c[%d]", destination, width, width, lane),
+					fmt.Sprintf("str z%d,[x0]", destination), "add x0,x0,#256")
+				fmt.Fprintf(&cases, "  {%d,%d},\n", 1<<size, lane)
+				count++
+			}
+		}
+	}
+	machine = append(machine, "ret")
+	var source, native strings.Builder
+	source.WriteString("TEXT dup_indexed(SB),$0-16\nMOVD out+0(FP),R0\nMOVD input+8(FP),R1\n")
+	native.WriteString("__asm__(\".text\\n.p2align 2\\n.global native_dup\\nnative_dup:\\n\"\n")
+	for _, word := range assembleARM64LLVMWords(t, machine, "+sve") {
+		fmt.Fprintf(&source, "WORD $%#08x\n", word)
+		fmt.Fprintf(&native, "\".inst %#08x\\n\"\n", word)
+	}
+	native.WriteString(");\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"dup_indexed": {
+			Name: "dup_indexed", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	checks := fmt.Sprintf(`
+  const struct { unsigned width, lane; } cases[] = {
+%s
+  };
+  uint8_t input[256], translated[%d*256+2], native[%d*256+2];
+  for (unsigned byte = 0; byte < sizeof(input); byte++) input[byte] = 1 + byte%%251;
+  memset(translated, 0xaa, sizeof(translated));
+  memset(native, 0xaa, sizeof(native));
+  dup_indexed(translated+1, input);
+  native_dup(native+1, input);
+  if (memcmp(translated, native, sizeof(native))) return 1;
+  if (translated[0] != 0xaa || translated[sizeof(translated)-1] != 0xaa) return 2;
+  for (unsigned test = 0; test < sizeof(cases)/sizeof(cases[0]); test++) {
+    unsigned width = cases[test].width, lane = cases[test].lane;
+    for (unsigned byte = 0; byte < 256; byte++) {
+      unsigned expected = 0xaa;
+      if (byte < vl) expected = lane*width < vl ? input[lane*width+byte%%width] : 0;
+      if (translated[test*256+byte+1] != expected) {
+        fprintf(stderr, "SVE DUP width=%%u lane=%%u VL=%%u byte=%%u\n", width, lane, vl, byte);
+        return 3;
+      }
+    }
+  }
+`, cases.String(), count, count)
+	declarations := "extern void dup_indexed(uint8_t *, const uint8_t *);\nextern void native_dup(uint8_t *, const uint8_t *);\n" + native.String()
+	const lengths = "16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, 256"
+	return ir, arm64SVEVectorLengthsMain(declarations, checks, lengths)
+}
+
+func TestARM64SVEDupIndexedLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, _ := arm64SVEDupIndexedRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "dup_indexed.ll", "dup_indexed.o", ir)
+		})
+	}
+}
diff --git a/arm64_sve_ordinary_memory_offset_runtime_test.go b/arm64_sve_ordinary_memory_offset_runtime_test.go
new file mode 100644
index 000000000..88c3534d5
--- /dev/null
+++ b/arm64_sve_ordinary_memory_offset_runtime_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func testARM64SVEMemoryOffsetRuntime(t *testing.T, llc string, nonFaulting bool) {
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	ops := []string{"ld1b", "ld1h", "ld1w", "ld1d", "ld1sb", "ld1sh", "ld1sw", "st1b", "st1h", "st1w", "st1d"}
+	if nonFaulting {
+		ops = []string{"ldnf1b", "ldnf1h", "ldnf1w", "ldnf1d", "ldnf1sb", "ldnf1sh", "ldnf1sw"}
+	}
+	for _, op := range ops {
+		memoryBytes := map[byte]int{'b': 1, 'h': 2, 'w': 4, 'd': 8}[op[len(op)-1]]
+		load, signed := strings.HasPrefix(op, "ld"), strings.Contains(op, "1s")
+		for size := 0; size < 5; size++ {
+			elementBytes := 1 << size
+			if elementBytes < memoryBytes || signed && elementBytes == memoryBytes || size == 4 && (nonFaulting || signed || memoryBytes < 4) {
+				continue
+			}
+			// Named tests cover all currently accepted single-vector forms;
+			// existing raw B/H decoders share their address implementation.
+			forms := []bool{false}
+			if !nonFaulting && !signed && memoryBytes <= 2 {
+				forms = append(forms, true)
+			}
+			for _, raw := range forms {
+				for _, offset := range []int{-8, 1, 7} {
+					name := fmt.Sprintf("ordinary_offset_%d", len(sigs))
+					mode := ""
+					if load {
+						mode = "/z"
+					}
+					native := []string{
+						"ptrue p0.b", "ld1b { z20.b }, p0/z, [x2]", "cmpne p7.b, p0/z, z20.b, #0",
+						"ld1b { z31.b }, p0/z, [x1]",
+						fmt.Sprintf("%s { z31.%c }, p7%s, [x0, #%d, mul vl]", op, "bhsdq"[size], mode, offset),
+						"st1b { z31.b }, p0, [x3]",
+					}
+					if nonFaulting {
+						native = append(native, "rdffr p1.b", "add x4,x3,#256", "str p1,[x4]")
+					}
+					words := assembleARM64LLVMWords(t, native, "+sve2p1")
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-32\nMOVD base+0(FP),R0\nMOVD data+8(FP),R1\nMOVD mask+16(FP),R2\nMOVD out+24(FP),R3\n", name)
+					if nonFaulting {
+						source.WriteString("SETFFR\n")
+					}
+					for i, word := range words {
+						if nonFaulting && i == 6 {
+							source.WriteString("PRDFFR P1.B\n")
+							continue
+						}
+						if i != 4 || raw {
+							fmt.Fprintf(&source, "WORD $%#08x\n", word)
+							continue
+						}
+						address := fmt.Sprintf("(VL*%d)(R0)", offset)
+						if offset < 0 {
+							address = fmt.Sprintf("(-VL*%d)(R0)", -offset)
+						}
+						if load {
+							fmt.Fprintf(&source, "Z%s %s, P7.Z, [Z31.%c]\n", strings.ToUpper(op), address, "BHSDQ"[size])
+						} else {
+							fmt.Fprintf(&source, "Z%s [Z31.%c], P7, %s\n", strings.ToUpper(op), "BHSDQ"[size], address)
+						}
+					}
+					source.WriteString("RET\n")
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+					}}}
+					fmt.Fprintf(&declarations, "extern void %s(void *, const void *, const void *, void *);\n", name)
+					// SVE2.1 Q forms can predate the native cross assembler. The
+					// independent LLVM encoding still addresses X0, loaded below.
+					native[4] = fmt.Sprintf("mov x0, %%[base]\\n\\t.inst %#08x", words[4])
+					assembly := strings.NewReplacer("[x1]", "[%[data]]", "[x2]", "[%[mask]]", "[x3]", "[%[out]]", "x4,x3", "x4,%[out]").Replace(strings.Join(native, "\\n\\t"))
+					if nonFaulting {
+						assembly = "setffr\\n\\t" + assembly
+					}
+					isLoad, isSigned := 0, 0
+					if load {
+						isLoad = 1
+					}
+					if signed {
+						isSigned = 1
+					}
+					isNonFaulting := 0
+					if nonFaulting {
+						isNonFaulting = 1
+					}
+					// Non-faulting loads may stop even on mapped memory. QEMU
+					// 10.2.3 deliberately stops at the second page (sve_helper.c,
+					// sve_ldnfff1_r). Match page offsets, capture both FFRs, and
+					// compare only defined bytes before the first cleared FFR bit.
+					// The aligned layout still requires every lane to be checked.
+					fmt.Fprintf(&checks, `    {
+      _Alignas(4096) unsigned char memory[8192], reference[8192], scalar_memory[8192];
+      unsigned char data[256], mask[256];
+      unsigned char got[288], native[288], scalar[288];
+      const unsigned element = %d, access = %d;
+      const int load = %d, signed_load = %d, non_faulting = %d;
+      const int displacement = %d * (int)(vl / element * access);
+      for (unsigned layout = 0; layout < 2; layout++) {
+        const unsigned origin = layout ? 6016 : 4096;
+      for (unsigned phase = 0; phase < 5; phase++) {
+        for (unsigned i = 0; i < sizeof(memory); i++) memory[i] = i * 53 + (i >> 8) + phase * 71;
+        memcpy(reference, memory, sizeof(memory));
+        memcpy(scalar_memory, memory, sizeof(memory));
+        for (unsigned i = 0; i < sizeof(data); i++) {
+          data[i] = i * 83 + phase * 23;
+          mask[i] = phase < 2 ? phase : (i / element + phase * 3) %% 7 != 0;
+        }
+        memset(got, 0x5a, sizeof(got));
+        memset(native, 0x5a, sizeof(native));
+        memset(scalar, 0x5a, sizeof(scalar));
+        if (load) memset(scalar, 0, vl);
+        else memcpy(scalar, data, vl);
+        for (unsigned i = 0; i < vl / element; i++) {
+          if (!mask[i * element]) continue;
+          unsigned char *location = scalar_memory + origin + displacement + i * access;
+          if (load) {
+            uint64_t value = 0;
+            memcpy(&value, location, access);
+            if (signed_load && (value >> (access * 8 - 1))) value |= ~(UINT64_MAX >> (64 - access * 8));
+            memcpy(scalar + i * element, &value, element < 8 ? element : 8);
+          } else {
+            memcpy(location, data + i * element, access);
+          }
+        }
+        void *base = phase ? memory + origin : 0;
+        void *native_base = phase ? reference + origin : 0;
+        __asm__ volatile("%s" :: [base]"r"(native_base), [data]"r"(data), [mask]"r"(mask), [out]"r"(native)
+          : "x0", "x4", "p0", "p1", "p7", "z20", "z31", "memory");
+        %s(base, data, mask, got);
+        unsigned valid_bytes = vl;
+        int mismatch = memcmp(got + 256, native + 256, 32) != 0;
+        if (non_faulting) {
+          for (unsigned i = 0; i < vl; i++) {
+            if (!(native[256 + i / 8] & (1u << (i %% 8)))) {
+              valid_bytes = i;
+              break;
+            }
+          }
+          /* The aligned layout must exercise complete loads, not an empty prefix. */
+          if (!layout && valid_bytes != vl) mismatch = 1;
+        }
+        for (unsigned i = 0; i < 256; i++) {
+          if (i >= valid_bytes && i < vl) continue;
+          if (got[i] != native[i] || got[i] != scalar[i]) mismatch = 1;
+        }
+        if (mismatch ||
+            memcmp(memory, reference, sizeof(memory)) || memcmp(memory, scalar_memory, sizeof(memory))) {
+          fprintf(stderr, "%s: vl=%%u phase=%%u layout=%%u valid=%%u\n", vl, phase, layout, valid_bytes);
+          for (unsigned i = 0; i < 256; i++) {
+            if (i >= valid_bytes && i < vl) continue;
+            if (got[i] != native[i] || got[i] != scalar[i]) {
+              fprintf(stderr, "byte=%%u translated=%%02x native=%%02x scalar=%%02x\n", i, got[i], native[i], scalar[i]);
+              break;
+            }
+          }
+          return %d;
+        }
+      }
+      }
+    }
+`, elementBytes, memoryBytes, isLoad, isSigned, isNonFaulting, offset, assembly, name, name, len(sigs))
+				}
+			}
+		}
+	}
+	requireARM64SVEGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := arm64SVEVectorLengthMain(declarations.String(), checks.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "ordinary_memory_offset", triple, ir, main,
+		[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+}
diff --git a/arm64_sve_runtime_helpers_test.go b/arm64_sve_runtime_helpers_test.go
new file mode 100644
index 000000000..0a4bbe03a
--- /dev/null
+++ b/arm64_sve_runtime_helpers_test.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+// Set VL only in a non-SVE frame, then enter a fresh, non-inlined test frame.
+// Changing VL inside an SVE-compiled C function can invalidate the compiler's
+// scalable spill slots. In particular, the integer-unary oracle reproduced a
+// stack-canary failure when its loop changed VL inside that same frame.
+func arm64SVEVectorLengthMain(declarations, checks string) string {
+	return arm64SVEVectorLengthsMain(declarations, checks, "16, 32, 48, 64, 128, 256")
+}
+
+func arm64SVEVectorLengthsMain(declarations, checks, lengths string) string {
+	return "#include <stdint.h>\n#include <string.h>\n#include <stdio.h>\n#include <sys/prctl.h>\n" + declarations + `
+__attribute__((noinline)) static int check_length(unsigned vl) {
+` + checks + `
+  return 0;
+}
+
+__attribute__((target("arch=armv8-a")))
+int main(void) {
+  const unsigned lengths[] = {` + lengths + `};
+  for (unsigned i = 0; i < sizeof(lengths)/sizeof(lengths[0]); i++) {
+    unsigned vl = lengths[i];
+    if (prctl(PR_SVE_SET_VL, vl) != (int)vl) return 99;
+    int result = check_length(vl);
+    if (result) return result;
+  }
+  return 0;
+}
+`
+}
diff --git a/arm64_sve_state.go b/arm64_sve_state.go
new file mode 100644
index 000000000..071520816
--- /dev/null
+++ b/arm64_sve_state.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import "fmt"
+
+func (c *arm64Ctx) loadZReg(index int) (string, error) {
+	c.recordMachineRegister(Reg(fmt.Sprintf("Z%d", index)), arm64WholeScalableRegister, false)
+	slot := c.zRegSlot[index]
+	if slot == "" {
+		return "", fmt.Errorf("arm64 SVE Z%d was not allocated", index)
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load <vscale x 16 x i8>, ptr %s\n", value, slot)
+	return "%" + value, nil
+}
+
+func (c *arm64Ctx) storeZReg(index int, value string) error {
+	c.recordMachineRegister(Reg(fmt.Sprintf("Z%d", index)), arm64WholeScalableRegister, true)
+	slot := c.zRegSlot[index]
+	if slot == "" {
+		return fmt.Errorf("arm64 SVE Z%d was not allocated", index)
+	}
+	fmt.Fprintf(c.b, "  store <vscale x 16 x i8> %s, ptr %s\n", value, slot)
+	return nil
+}
+
+func (c *arm64Ctx) loadPReg(index int) (string, error) {
+	c.recordMachineRegister(Reg(fmt.Sprintf("P%d", index)), arm64WholeScalableRegister, false)
+	slot := c.pRegSlot[index]
+	if slot == "" {
+		return "", fmt.Errorf("arm64 SVE P%d was not allocated", index)
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load <vscale x 16 x i1>, ptr %s\n", value, slot)
+	return "%" + value, nil
+}
+
+func (c *arm64Ctx) storePReg(index int, value string) error {
+	c.recordMachineRegister(Reg(fmt.Sprintf("P%d", index)), arm64WholeScalableRegister, true)
+	slot := c.pRegSlot[index]
+	if slot == "" {
+		return fmt.Errorf("arm64 SVE P%d was not allocated", index)
+	}
+	fmt.Fprintf(c.b, "  store <vscale x 16 x i1> %s, ptr %s\n", value, slot)
+	return nil
+}
+
+func (c *arm64Ctx) loadPNReg(index int) (string, error) {
+	c.recordMachineRegister(Reg(fmt.Sprintf("PN%d", index)), arm64WholeScalableRegister, false)
+	slot := c.pnRegSlot[index]
+	if slot == "" {
+		return "", fmt.Errorf("arm64 SVE PN%d was not allocated", index)
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load target(\"aarch64.svcount\"), ptr %s\n", value, slot)
+	return "%" + value, nil
+}
+
+func (c *arm64Ctx) storePNReg(index int, value string) error {
+	c.recordMachineRegister(Reg(fmt.Sprintf("PN%d", index)), arm64WholeScalableRegister, true)
+	slot := c.pnRegSlot[index]
+	if slot == "" {
+		return fmt.Errorf("arm64 SVE PN%d was not allocated", index)
+	}
+	fmt.Fprintf(c.b, "  store target(\"aarch64.svcount\") %s, ptr %s\n", value, slot)
+	return nil
+}
+
+func (c *arm64Ctx) storePRegElements(index, elementBits int, value string) error {
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	if elementBits == 8 {
+		return c.storePReg(index, value)
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <vscale x 16 x i1> @llvm.aarch64.sve.convert.to.svbool.nxv%di1(<vscale x %d x i1> %s)\n", converted, lanes, lanes, value)
+	return c.storePReg(index, "%"+converted)
+}
+
+func arm64SVEVectorType(elementBits int) (string, int, error) {
+	if elementBits != 8 && elementBits != 16 && elementBits != 32 && elementBits != 64 {
+		return "", 0, fmt.Errorf("unsupported ARM64 SVE element width %d", elementBits)
+	}
+	lanes := 128 / elementBits
+	return fmt.Sprintf("<vscale x %d x i%d>", lanes, elementBits), lanes, nil
+}
+
+func (c *arm64Ctx) loadZRegElements(index, elementBits int) (value, vectorType string, err error) {
+	bytes, err := c.loadZReg(index)
+	if err != nil {
+		return "", "", err
+	}
+	vectorType, _, err = arm64SVEVectorType(elementBits)
+	if err != nil {
+		return "", "", err
+	}
+	if elementBits == 8 {
+		return bytes, vectorType, nil
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <vscale x 16 x i8> %s to %s\n", converted, bytes, vectorType)
+	return "%" + converted, vectorType, nil
+}
+
+func (c *arm64Ctx) storeZRegElements(index, elementBits int, value string) error {
+	vectorType, _, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return err
+	}
+	if elementBits == 8 {
+		return c.storeZReg(index, value)
+	}
+	bytes := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to <vscale x 16 x i8>\n", bytes, vectorType, value)
+	return c.storeZReg(index, "%"+bytes)
+}
+
+func (c *arm64Ctx) loadPRegElements(index, elementBits int) (value, predicateType string, err error) {
+	predicate, err := c.loadPReg(index)
+	if err != nil {
+		return "", "", err
+	}
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return "", "", err
+	}
+	predicateType = fmt.Sprintf("<vscale x %d x i1>", lanes)
+	if elementBits == 8 {
+		return predicate, predicateType, nil
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.convert.from.svbool.nxv%di1(<vscale x 16 x i1> %s)\n",
+		converted, predicateType, lanes, predicate)
+	return "%" + converted, predicateType, nil
+}
+
+func (c *arm64Ctx) allTruePRegElements(elementBits int) (value, predicateType string, err error) {
+	_, lanes, err := arm64SVEVectorType(elementBits)
+	if err != nil {
+		return "", "", err
+	}
+	predicateType = fmt.Sprintf("<vscale x %d x i1>", lanes)
+	valueName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call %s @llvm.aarch64.sve.ptrue.nxv%di1(i32 31)\n", valueName, predicateType, lanes)
+	return "%" + valueName, predicateType, nil
+}
+
+func (c *arm64Ctx) setSVEPredicateFlags(governing, result, predicateType string, lanes int) {
+	c.setSVEPredicateSequenceFlags(governing, []string{result}, predicateType, lanes)
+}
+
+func (c *arm64Ctx) setSVEPredicateSequenceFlags(governing string, results []string, predicateType string, lanes int) {
+	if len(results) == 0 {
+		return
+	}
+	negative := c.newTmp()
+	zero := c.newTmp()
+	last := c.newTmp()
+	carry := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i1 @llvm.aarch64.sve.ptest.first.nxv%di1(%s %s, %s %s)\n", negative, lanes, predicateType, governing, predicateType, results[0])
+	anyValues := make([]string, 0, len(results))
+	for _, result := range results {
+		any := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i1 @llvm.aarch64.sve.ptest.any.nxv%di1(%s %s, %s %s)\n", any, lanes, predicateType, governing, predicateType, result)
+		anyValues = append(anyValues, "%"+any)
+	}
+	anyValue := anyValues[0]
+	for _, value := range anyValues[1:] {
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %s, %s\n", combined, anyValue, value)
+		anyValue = "%" + combined
+	}
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %s, true\n", zero, anyValue)
+	fmt.Fprintf(c.b, "  %%%s = call i1 @llvm.aarch64.sve.ptest.last.nxv%di1(%s %s, %s %s)\n", last, lanes, predicateType, governing, predicateType, results[len(results)-1])
+	fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", carry, last)
+	c.flagsWritten = true
+	c.storeFlag(c.flagsNSlot, "%"+negative)
+	c.storeFlag(c.flagsZSlot, "%"+zero)
+	c.storeFlag(c.flagsCSlot, "%"+carry)
+	c.storeFlag(c.flagsVSlot, "false")
+}
diff --git a/arm64_symbol_memory.go b/arm64_symbol_memory.go
new file mode 100644
index 000000000..69f68ea58
--- /dev/null
+++ b/arm64_symbol_memory.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's C_ADDR forms load/store the symbol's bytes. They are distinct from
+// C_VCONADDR ($symbol(SB)), which materializes an address without dereferencing
+// it. Keep all scalar widths together so a MOVD load cannot become an address
+// and a store cannot silently disappear.
+func (c *arm64Ctx) lowerARM64SymbolScalarMove(op Op, ins Instr) (bool, bool, error) {
+	bits, signed := 0, false
+	switch op {
+	case "MOVD":
+		bits = 64
+	case "MOVW", "MOVWU":
+		bits, signed = 32, op == "MOVW"
+	case "MOVH", "MOVHU":
+		bits, signed = 16, op == "MOVH"
+	case "MOVB", "MOVBU":
+		bits, signed = 8, op == "MOVB"
+	default:
+		return false, false, nil
+	}
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpSym && ins.Args[1].Kind != OpSym {
+		return false, false, nil
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	if src.Kind == OpSym {
+		if dst.Kind != OpReg || !isARM64GeneralOrZeroReg(dst.Reg) {
+			return true, false, fmt.Errorf("arm64 %s symbolic source requires a general or zero destination register: %q", op, ins.Raw)
+		}
+		if strings.HasPrefix(strings.TrimSpace(src.Sym), "$") {
+			// asm7's type 68 rejects MOVW, but MOVWU uses the same full
+			// address materialization as MOVD. It is not a 32-bit load.
+			if op != "MOVD" && (op != "MOVWU" || !strings.HasSuffix(strings.TrimSpace(src.Sym), "(SB)")) {
+				return true, false, fmt.Errorf("arm64 %s does not accept this address source: %q", op, ins.Raw)
+			}
+			if string(ins.Op) != string(op) || !arm64ScalarMemoryGoRegisterSpelling(ins) {
+				return true, false, fmt.Errorf("arm64 %s symbol address requires an original Go register spelling and no suffix: %q", op, ins.Raw)
+			}
+			if sourceSymbolOffsetNeedsContext(src.Sym) {
+				return true, false, fmt.Errorf("%w: arm64 %s symbol address requires generated assembler constants: %q", ErrProbeNeedsContext, op, ins.Raw)
+			}
+			value, err := c.eval64(src, false)
+			if err != nil {
+				return true, false, err
+			}
+			return true, false, c.storeReg(dst.Reg, value)
+		}
+		ptr, err := c.ptrFromSB(src.Sym)
+		if err != nil {
+			return true, false, err
+		}
+		loaded := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", loaded, bits, ptr)
+		value := "%" + loaded
+		if bits != 64 {
+			wide := c.newTmp()
+			extension := "zext"
+			if signed {
+				extension = "sext"
+			}
+			fmt.Fprintf(c.b, "  %%%s = %s i%d %s to i64\n", wide, extension, bits, value)
+			value = "%" + wide
+		}
+		return true, false, c.storeReg(dst.Reg, value)
+	}
+	// obj7.progedit canonicalizes a resolved From literal $0 to ZR for all
+	// seven scalar moves, including C_ADDR stores. An unresolved expression
+	// with a placeholder zero value is not this alias.
+	if src.Kind == OpImm && src.Imm == 0 && src.ImmRaw == "" {
+		src = Operand{Kind: OpReg, Reg: ZR}
+	}
+	if strings.HasPrefix(strings.TrimSpace(dst.Sym), "$") || src.Kind != OpReg || !isARM64GeneralOrZeroReg(src.Reg) {
+		return true, false, fmt.Errorf("arm64 %s symbolic destination requires a general or zero source register: %q", op, ins.Raw)
+	}
+	ptr, err := c.ptrFromSB(dst.Sym)
+	if err != nil {
+		return true, false, err
+	}
+	value, err := c.loadReg(src.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	if bits != 64 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i%d\n", narrow, value, bits)
+		value = "%" + narrow
+	}
+	fmt.Fprintf(c.b, "  store i%d %s, ptr %s, align 1\n", bits, value, ptr)
+	return true, false, nil
+}
diff --git a/arm64_symbol_memory_test.go b/arm64_symbol_memory_test.go
new file mode 100644
index 000000000..6761a27ae
--- /dev/null
+++ b/arm64_symbol_memory_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func resolveARM64SymbolMemoryTest(symbol string) string {
+	return strings.TrimPrefix(symbol, "·")
+}
+
+// Go 1.27 asm7.go's C_ADDR load/store rows cover MOVD and the signed and
+// unsigned byte/halfword/word aliases. C_VCONADDR is separately address-valued.
+func TestARM64SymbolScalarCompleteGoForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT symbolForms(SB),$0-0\n")
+	for _, form := range arm64ScalarWritebackOps {
+		for _, off := range []int{-65537, -8, 0, 1, 8, 65537} {
+			fmt.Fprintf(&source, "%s buffer%+d(SB), R2\n%s R2, buffer%+d(SB)\n%s ZR, buffer%+d(SB)\n%s $0, buffer%+d(SB)\n", form.op, off, form.op, off, form.op, off, form.op, off)
+		}
+	}
+	// The encoder rejects MOVW addresses but permits MOVWU through its
+	// address-materialization row; that spelling retains the full address.
+	for _, op := range []string{"MOVD", "MOVWU"} {
+		fmt.Fprintf(&source, "%s $buffer+3(SB), R2\n", op)
+	}
+	source.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolveARM64SymbolMemoryTest, Sigs: map[string]FuncSig{
+			"symbolForms": {Name: "symbolForms", Ret: Void},
+		}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "symbol-scalar.ll", "symbol-scalar.o", ir)
+	}
+}
+
+func TestARM64SymbolScalarLoadStoreNotAddress(t *testing.T) {
+	for _, form := range arm64ScalarWritebackOps {
+		t.Run(form.op, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT symbolMemory(SB),$0-0\n%s buffer(SB), R2\n%s R2, buffer(SB)\nRET\n", form.op, form.op)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolveARM64SymbolMemoryTest, Sigs: map[string]FuncSig{
+				"symbolMemory": {Name: "symbolMemory", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantPointer := fmt.Sprintf("ptr %s, align 1", llvmGlobal("buffer"))
+			wantLoad := fmt.Sprintf("load i%d, %s", form.bits, wantPointer)
+			wantStore := fmt.Sprintf("store i%d ", form.bits)
+			stored := false
+			for _, line := range strings.Split(ir, "\n") {
+				stored = stored || strings.Contains(line, wantStore) && strings.Contains(line, wantPointer)
+			}
+			if !strings.Contains(ir, wantLoad) || !stored {
+				t.Fatalf("%s symbolic load/store must access memory at native width, not return its address or omit the store; missing %q/%q", form.op, wantLoad, wantStore)
+			}
+		})
+	}
+}
+
+func TestARM64SymbolScalarRejectsGoInvalidForms(t *testing.T) {
+	instructions := []string{
+		"MOVD buffer(SB), other(SB)", "MOVD $1, buffer(SB)",
+		"MOVD R2, $buffer(SB)", "MOVD $buffer(SB), buffer(SB)",
+		"MOVB $buffer(SB), R2", "MOVBU $buffer(SB), R2",
+		"MOVH $buffer(SB), R2", "MOVHU $buffer(SB), R2",
+		"MOVW $buffer(SB), R2",
+		"MOVD.P buffer(SB), R2", "MOVD.W R2, buffer(SB)",
+	}
+	for _, form := range arm64ScalarWritebackOps {
+		instructions = append(instructions, form.op+" $1, buffer(SB)", form.op+" $UNRESOLVED_ZERO, buffer(SB)")
+	}
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT badSymbol(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARM64GoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"badSymbol": {Name: "badSymbol", Ret: Void}}})
+			if err == nil {
+				t.Fatal("translator accepted Go-rejected symbolic memory move")
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SymbolScalarZeroStore(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, declarations, checks, goDeclarations, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64ScalarWritebackOps {
+		name := fmt.Sprintf("scalar_wb_zero_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-0\n%s $0, buffer+7(SB)\nRET\n", name, form.op)
+		sigs[name] = FuncSig{Name: name, Ret: Void}
+		fmt.Fprintf(&declarations, "extern void %s(void);\n", name)
+		fmt.Fprintf(&goDeclarations, "func %s()\n", name)
+		fmt.Fprintf(&checks, "{ unsigned char expected[80]; for(unsigned i=0;i<80;i++) buffer[i]=(unsigned char)(i*13+131); memcpy(expected,buffer,80); memset(expected+7,0,%d); %s(); if(memcmp(buffer,expected,80)) return %d; }\n", form.bits/8, name, len(sigs))
+		fmt.Fprintf(&goChecks, "{ for i:=range buffer { buffer[i]=byte(i*13+131) }; expected:=buffer; for i:=0;i<%d;i++ { expected[7+i]=0 }; %s(); if buffer!=expected { panic(\"%s zero store oracle\") } }\n", form.bits/8, name, form.op)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	goSource := "package main\nvar buffer [80]byte\n" + goDeclarations.String() + "func main() {\n" + goChecks.String() + "}\n"
+	arm64ScalarWritebackGoOracle(t, strings.ReplaceAll(source.String(), "buffer", "·buffer"), goSource, len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolveARM64SymbolMemoryTest, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <string.h>\nunsigned char buffer[80];\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "symbol_scalar_zero_store", triple, ir, main, runner)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SymbolScalarMemory(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, declarations, checks, goDeclarations, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, form := range arm64ScalarWritebackOps {
+		for _, off := range []int{0, 1, 7, 8, 32} {
+			loadName := fmt.Sprintf("scalar_wb_symbol_%d", len(sigs))
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-8\n%s buffer+%d(SB), R2\nMOVD R2, ret+0(FP)\nRET\n", loadName, form.op, off)
+			sigs[loadName] = FuncSig{Name: loadName, Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+			storeName := fmt.Sprintf("scalar_wb_symbol_%d", len(sigs))
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-8\nMOVD value+0(FP), R2\n%s R2, buffer+%d(SB)\nRET\n", storeName, form.op, off)
+			sigs[storeName] = FuncSig{Name: storeName, Args: []LLVMType{I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+			fmt.Fprintf(&declarations, "extern uint64_t %s(void);\nextern void %s(uint64_t);\n", loadName, storeName)
+			fmt.Fprintf(&goDeclarations, "func %s() uint64\nfunc %s(value uint64)\n", loadName, storeName)
+			fmt.Fprintf(&checks, "{ unsigned char expected[80]; for (unsigned i=0;i<80;i++) buffer[i]=(unsigned char)(i*13+131); memcpy(expected,buffer,80); uint64_t want=0; memcpy(&want,buffer+%d,%d);\n", off, form.bits/8)
+			fmt.Fprintf(&goChecks, "{ for i := range buffer { buffer[i]=byte(i*13+131) }; expected:=buffer; var want uint64; for i:=0;i<%d;i++ { want |= uint64(buffer[%d+i]) << (8*i) };\n", form.bits/8, off)
+			if form.signed {
+				fmt.Fprintf(&checks, "want=(uint64_t)(int64_t)(int%d_t)want;\n", form.bits)
+				fmt.Fprintf(&goChecks, "want=uint64(int64(int%d(want)));\n", form.bits)
+			}
+			fmt.Fprintf(&checks, "if (%s()!=want) { fprintf(stderr,\"%s +%d load failed\\n\"); return 1; } uint64_t value=UINT64_C(0xfedcba9876543210); memcpy(expected+%d,&value,%d); %s(value); if(memcmp(buffer,expected,80)) { fprintf(stderr,\"%s +%d store failed\\n\"); return 2; } }\n", loadName, form.op, off, off, form.bits/8, storeName, form.op, off)
+			fmt.Fprintf(&goChecks, "if %s()!=want { panic(\"%s load failed\") }; value:=uint64(0xfedcba9876543210); for i:=0;i<%d;i++ { expected[%d+i]=byte(value>>(8*i)) }; %s(value); if buffer!=expected { panic(\"%s store failed\") } }\n", loadName, form.op, form.bits/8, off, storeName, form.op)
+		}
+	}
+	for _, op := range []string{"MOVD"} {
+		name := fmt.Sprintf("scalar_wb_symbol_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-8\n%s $buffer+3(SB), R2\nMOVD R2, ret+0(FP)\nRET\n", name, op)
+		sigs[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+		fmt.Fprintf(&declarations, "extern uint64_t %s(void);\n", name)
+		fmt.Fprintf(&goDeclarations, "func %s() uint64\n", name)
+		fmt.Fprintf(&checks, "if (%s()!=(uintptr_t)(buffer+3)) { fprintf(stderr,\"%s symbolic address failed\\n\"); return 3; }\n", name, op)
+		fmt.Fprintf(&goChecks, "if %s()!=uint64(uintptr(unsafe.Pointer(&buffer[3]))) { panic(\"%s symbolic address failed\") };\n", name, op)
+	}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	goSource := "package main\nimport \"unsafe\"\nvar buffer [80]byte\n" + goDeclarations.String() + "func main() {\n" + goChecks.String() + "}\n"
+	arm64ScalarWritebackGoOracle(t, strings.ReplaceAll(source.String(), "buffer", "·buffer"), goSource, len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolveARM64SymbolMemoryTest, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\nunsigned char buffer[80];\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "symbol_scalar_memory", triple, ir, main, runner)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SymbolScalarAddress(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = "TEXT scalar_wb_symbol_address(SB),$0-8\nMOVWU $buffer+3(SB), R2\nMOVD R2, ret+0(FP)\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	const goSource = `package main
+import "unsafe"
+var buffer [80]byte
+func scalar_wb_symbol_address() uint64
+func main() {
+ if scalar_wb_symbol_address() != uint64(uintptr(unsafe.Pointer(&buffer[3]))) { panic("Go MOVWU address oracle") }
+}
+`
+	arm64ScalarWritebackGoOracle(t, strings.ReplaceAll(source, "buffer", "·buffer"), goSource, len(runner) != 0)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolveARM64SymbolMemoryTest, Sigs: map[string]FuncSig{
+		"scalar_wb_symbol_address": {Name: "scalar_wb_symbol_address", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+unsigned char buffer[80];
+extern uint64_t scalar_wb_symbol_address(void);
+int main(void) { return scalar_wb_symbol_address() != (uintptr_t)(buffer+3); }
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "symbol_scalar_address", triple, ir, main, runner)
+}
+
+// Keep the MOVD store's old no-op independently observable: a load failure in
+// the combined family oracle must not hide this separate memory side effect.
+func TestCrossLinuxRuntimeMatrixARM64SymbolScalarStore(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	const source = "TEXT scalar_wb_symbol_store(SB),$0-8\nMOVD value+0(FP), R2\nMOVD R2, buffer+7(SB)\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	const goSource = `package main
+var buffer [80]byte
+func scalar_wb_symbol_store(value uint64)
+func main() {
+ for i := range buffer { buffer[i]=byte(i*13+131) }
+ expected:=buffer
+ value:=uint64(0xfedcba9876543210)
+ for i:=0;i<8;i++ { expected[7+i]=byte(value>>(8*i)) }
+ scalar_wb_symbol_store(value)
+ if buffer!=expected { panic("Go MOVD symbolic store oracle") }
+}
+`
+	arm64ScalarWritebackGoOracle(t, strings.ReplaceAll(source, "buffer", "·buffer"), goSource, len(runner) != 0)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolveARM64SymbolMemoryTest, Sigs: map[string]FuncSig{
+		"scalar_wb_symbol_store": {Name: "scalar_wb_symbol_store", Args: []LLVMType{I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+#include <string.h>
+unsigned char buffer[80];
+extern void scalar_wb_symbol_store(uint64_t);
+int main(void) {
+ unsigned char expected[80];
+ for(unsigned i=0;i<80;i++) buffer[i]=(unsigned char)(i*13+131);
+ memcpy(expected,buffer,80);
+ uint64_t value=UINT64_C(0xfedcba9876543210);
+ memcpy(expected+7,&value,8);
+ scalar_wb_symbol_store(value);
+ return memcmp(buffer,expected,80)!=0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "symbol_scalar_store", triple, ir, main, runner)
+}
diff --git a/arm64_symbol_offset_context_go127_test.go b/arm64_symbol_offset_context_go127_test.go
new file mode 100644
index 000000000..a48fe8e02
--- /dev/null
+++ b/arm64_symbol_offset_context_go127_test.go
@@ -0,0 +1,192 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const arm64SymbolOffsetDefinitions = "#define OFFSET 4\n" +
+	"#define const_offsetARM64HasATOMICS 8\n#define machTimebaseInfo_denom 4\n"
+
+// Independent asm7 C_ADDR rows 64/65 cover these seven spellings. Row 68
+// additionally admits MOVD/MOVWU address values, not the five narrow aliases.
+func arm64SymbolOffsetContextRows() []string {
+	var rows []string
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		rows = append(rows,
+			op+" ·memory+OFFSET(SB),R2", op+" R2,·memory-OFFSET(SB)",
+			op+" ZR,·memory+OFFSET(SB)", op+" $0,·memory+OFFSET(SB)",
+			op+" ·memory+OFFSET(SB),ZR", op+" ·memory+OFFSET(SB),R27")
+	}
+	for _, expression := range []string{
+		"+(OFFSET+4)", "+(OFFSET*2)", "+(OFFSET/2)", "+(OFFSET%3)",
+		"+(OFFSET<<1)", "+(OFFSET>>1)", "+(OFFSET&3)", "+(OFFSET|3)",
+		"+(OFFSET^3)", "+(~OFFSET)", "+(OFFSET+'x')",
+		"+(OFFSET/(OFFSET+1))", "+(1/(OFFSET-1))", "+(OFFSET<<OFFSET)",
+	} {
+		rows = append(rows, "MOVD ·memory"+expression+"(SB),R2")
+	}
+	rows = append(rows,
+		"MOVD $·memory+OFFSET(SB),R2", "MOVWU $·memory-OFFSET(SB),R2",
+		"MOVD ·memory<>+OFFSET(SB),R2", "MOVD R2,·memory<>-OFFSET(SB)",
+		"MOVBU internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB),R4",
+		"MOVD $timebase<>+machTimebaseInfo_denom(SB),R21",
+		"MOVD $timebase<>+machTimebaseInfo_denom(SB),R22")
+	return rows
+}
+
+func TestARM64SymbolOffsetNeedsGeneratedConstantContext(t *testing.T) {
+	rows := arm64SymbolOffsetContextRows()
+	if len(rows) != 63 {
+		t.Fatal("incomplete independent seven-member memory/address inventory", len(rows))
+	}
+	// Only this original-Go prior receives generated definitions. The public
+	// probes and translations retain the exact unresolved source below.
+	requireARM64GoAssemblerResult(t, arm64SymbolOffsetDefinitions+
+		"TEXT symbolic(SB),$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT symbolic(SB),$0-0\n" + row + "\nRET\n"
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			original := append([]Operand(nil), instruction.Args...)
+			for _, err := range []error{
+				ProbeInstruction(ArchARM64, "arm64", instruction),
+				ProbeInstructionSequence(ArchARM64, "arm64", []Instr{instruction}),
+			} {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("valid unresolved GP symbol addend lost its source context: %v", err)
+				}
+			}
+			options := Options{Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+				Sigs: map[string]FuncSig{"symbolic": {Name: "symbolic", Ret: Void}}}
+			ir, err := Translate(file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Errorf("unresolved GP symbol acquired textual output or lost Context: IR=%q error=%v", ir, err)
+			}
+			module, err := TranslateModule(file, options)
+			empty := module.IsNil()
+			if !empty {
+				module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || !empty {
+				t.Errorf("unresolved GP symbol acquired a module or lost Context: empty=%v error=%v", empty, err)
+			}
+			if !reflect.DeepEqual(file.Funcs[0].Instrs[1].Args, original) ||
+				file.Funcs[0].Instrs[1].Raw != row {
+				t.Fatal("probe/translation changed the original unresolved operand")
+			}
+		})
+	}
+}
+
+func TestARM64SymbolOffsetContextDoesNotHideInvalidForms(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		rows = append(rows,
+			op+".P ·memory+OFFSET(SB),R2", op+".W R2,·memory+OFFSET(SB)",
+			op+" ·memory+OFFSET(SB),SP", op+" RSP,·memory+OFFSET(SB)",
+			op+" ·memory+OFFSET(SB),W2", op+" R27,·memory+OFFSET(SB)",
+			op+" ·memory+OFFSET(SB),·other(SB)", op+" $0.0,·memory+OFFSET(SB)",
+			op+" ·memory+OFFSET(SB)", op+" ·memory+OFFSET(SB),R2,R3")
+		if op != "MOVD" && op != "MOVWU" {
+			rows = append(rows, op+" $·memory+OFFSET(SB),R2")
+		}
+	}
+	for _, op := range []string{"MOVD", "MOVWU"} {
+		rows = append(rows,
+			op+".P $·memory+OFFSET(SB),R2", op+".W $·memory+OFFSET(SB),R2",
+			op+" $·memory+OFFSET(SB),SP", op+" $·memory+OFFSET(SB),W2")
+	}
+	for _, expression := range []string{
+		"+(OFFSET+)", "+(OFFSET/0)", "+(OFFSET%0)", "+(OFFSET<<-1)",
+		"+(OFFSET<<1*2)", "+(OFFSET<<1<<2)", "+((-1)/OFFSET)",
+		"+((1<<63)>>OFFSET)", "+1.5", "+(OFFSET==4)",
+	} {
+		rows = append(rows, "MOVD ·memory"+expression+"(SB),R2")
+	}
+	rows = append(rows,
+		"MOVD ·memory+OFFSET(XX),R2", "MOVD ·memory+OFFSET(SB),F2",
+		"MOVD F2,·memory+OFFSET(SB)", "MOVD $1,·memory+OFFSET(SB)")
+	if len(rows) != 97 {
+		t.Fatal("incomplete independent invalid GP symbol inventory", len(rows))
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			source := "TEXT invalidsymbol(SB),$0-0\n" + row + "\nRET\n"
+			requireARM64GoAssemblerResult(t, arm64SymbolOffsetDefinitions+source, false)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				return
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			for _, err := range []error{
+				ProbeInstruction(ArchARM64, "arm64", instruction),
+				ProbeInstructionSequence(ArchARM64, "arm64", []Instr{instruction}),
+			} {
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("invalid complete GP grammar was hidden as Context: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64SymbolOffsetConcreteFormsStayConcrete(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		rows = append(rows, op+" ·memory+4(SB),R2", op+" R2,·memory-4(SB)")
+	}
+	rows = append(rows, "MOVD $·memory+4(SB),R2", "MOVWU $·memory-4(SB),R2")
+	requireARM64GoAssemblerResult(t, "TEXT concrete(SB),$0-0\n"+
+		strings.Join(rows, "\n")+"\nRET\n", true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			file, err := Parse(ArchARM64, fmt.Sprintf("TEXT concrete(SB),$0-0\n%s\nRET\n", row))
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			if strings.Contains(row, "$·memory") {
+				if err := ProbeInstruction(ArchARM64, "arm64", instruction); err != nil {
+					t.Fatalf("a concrete GP address became unresolved: %v", err)
+				}
+				return
+			}
+			op, _ := splitOpcode(row)
+			form, handled, err := parseARM64ScalarMemoryForm(Op(op), instruction)
+			store := strings.Contains(row, " R2,")
+			wantSymbol, wantOffset := "·memory+4(SB)", int64(4)
+			if store {
+				wantSymbol, wantOffset = "·memory-4(SB)", -4
+			}
+			bits := map[string]int{"MOVB": 8, "MOVBU": 8, "MOVH": 16, "MOVHU": 16,
+				"MOVW": 32, "MOVWU": 32, "MOVD": 64}[op]
+			if !handled || err != nil || form.memory.Kind != OpSym || form.memory.Sym != wantSymbol ||
+				form.data != "R2" || form.store != store || form.bits != bits ||
+				form.signed != (op == "MOVB" || op == "MOVH" || op == "MOVW") ||
+				form.pre || form.post || !form.scratch || !form.scratchAddress || form.scratchKnown {
+				t.Fatalf("concrete typed symbol/access facts changed: %+v handled=%v error=%v", form, handled, err)
+			}
+			if symbol, offset, resolved := parseSBRef(form.memory.Sym); !resolved ||
+				symbol != "·memory" || offset != wantOffset {
+				t.Fatalf("concrete relocation was not retained: %q offset=%d resolved=%v", symbol, offset, resolved)
+			}
+			// This isolated probe has no original Go R27/layout observation.
+			// Concrete syntax cannot manufacture that independent authority.
+			if err := ProbeInstruction(ArchARM64, "arm64", instruction); !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "unbound original Go memory scratch") ||
+				strings.Contains(err.Error(), "generated assembler constants") {
+				t.Fatalf("concrete offset lost its existing physical-scratch boundary: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_symbol_tail_frame_test.go b/arm64_symbol_tail_frame_test.go
new file mode 100644
index 000000000..4f4d26417
--- /dev/null
+++ b/arm64_symbol_tail_frame_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARM64SymbolTailRequiresGoFrameEpilogue(t *testing.T) {
+	for _, frame := range []int{8, 32, 240} {
+		for _, instruction := range []string{"B anchor(SB)", "JMP anchor(SB)"} {
+			t.Run(fmt.Sprintf("frame%d/%s", frame, instruction), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT symbolTail(SB),4,$%d-0\n%s\n", frame, instruction)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+					"symbolTail": {Name: "symbolTail", Ret: Void},
+					"anchor":     {Name: "anchor", Ret: Void},
+				}})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("B/JMP do not pop the implicit Go frame: %v", err)
+				}
+			})
+		}
+	}
+	for _, instruction := range []string{"B anchor(SB)", "JMP anchor(SB)"} {
+		t.Run("nonleaf_zero/"+instruction, func(t *testing.T) {
+			source := "TEXT symbolTail(SB),4,$0-0\nCALL anchor(SB)\nMOVD (RSP),R30\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"symbolTail": {Name: "symbolTail", Ret: Void}, "anchor": {Name: "anchor", Ret: Void},
+			}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("symbol CALL creates a 16-byte Go frame even at TEXT $0: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64FramedLeafReturnRequiresCallerLink(t *testing.T) {
+	for _, instruction := range []string{"RET", "RET R30", "RET anchor(SB)"} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT leafReturn(SB),4,$32-0\nMOVD $123,R30\n" + instruction + "\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"leafReturn": {Name: "leafReturn", Ret: Void}, "anchor": {Name: "anchor", Ret: Void},
+			}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Go leaf RET pops SP but does not reload caller LR: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64RawBranchLinkDoesNotCreateGoFrame(t *testing.T) {
+	for _, fixture := range []struct {
+		body      string
+		indirects int
+	}{
+		{"WORD $0x94000002\nRET\nhelper:\nB (R30)", 2},
+		{"ADR helper,R0\nWORD $0xd63f0000\nRET\nhelper:\nB (R30)", 3},
+	} {
+		source := "TEXT rawLeaf(SB),4,$0-0\n" + fixture.body + "\n"
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+			"rawLeaf": {Name: "rawLeaf", Ret: Void},
+		}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Both helper return and subsequent RET target the real local link.
+		// With no caller-link restoration, this is an in-function loop, not
+		// an automatically restored outer return. Do not execute that loop.
+		if strings.Count(ir, "indirectbr") != fixture.indirects {
+			t.Fatalf("raw AWORD BL/BLR must not invent an auto-epilogue caller return:\n%s", ir)
+		}
+	}
+}
+
+func TestARM64NonleafReturnRequiresSavedCallerLink(t *testing.T) {
+	for _, instruction := range []string{"RET", "RET anchor(SB)"} {
+		for _, store := range []string{"MOVD R0,(RSP)", "MOVB R0,7(RSP)", "MOVW R0,4(RSP)"} {
+			t.Run(instruction+"/"+store, func(t *testing.T) {
+				source := "TEXT nonleafReturn(SB),4,$32-0\nCALL anchor(SB)\nMOVD $123,R0\n" + store + "\n" + instruction + "\n"
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+					"nonleafReturn": {Name: "nonleafReturn", Ret: Void}, "anchor": {Name: "anchor", Ret: Void},
+				}})
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("nonleaf Go RET reloads LR from the overwritten implicit frame cell: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SymbolTailGoFrameOracle(t *testing.T) {
+	_, _, _, runner := arm64FPPairRuntimeTools(t)
+	var source, decl, checks strings.Builder
+	index := 0
+	add := func(frame int, body string, want int) {
+		name := fmt.Sprintf("goFrameTarget%d", index)
+		measure := fmt.Sprintf("goFrameMeasure%d", index)
+		index++
+		fmt.Fprintf(&source, `TEXT ·%s(SB),516,$0-8
+MOVD RSP,R19
+MOVD R30,R23
+MOVD R29,R24
+MOVD $0,R25
+BL ·%s(SB)
+SUB R19,RSP,R0
+ADD R25,R0
+MOVD R19,RSP
+MOVD R24,R29
+MOVD R23,R30
+MOVD R0,ret+0(FP)
+RET
+TEXT ·%s(SB),4,$%d-0
+%s
+`, measure, name, name, frame, body)
+		fmt.Fprintf(&decl, "func %s() int64\n", measure)
+		fmt.Fprintf(&decl, "func %s()\n", name)
+		fmt.Fprintf(&checks, "if got := %s(); got != %d { println(%q,got); panic(\"Go frame delta mismatch\") }\n", measure, want, name)
+	}
+	for _, frame := range []struct{ declared, allocated int }{{0, 0}, {8, 32}, {32, 48}, {240, 256}} {
+		for _, op := range []string{"B", "JMP", "RET"} {
+			want := -frame.allocated
+			if op == "RET" {
+				want = 0
+			}
+			add(frame.declared, op+" ·goFrameAnchor(SB)", want)
+		}
+	}
+	for _, op := range []string{"B", "JMP", "RET"} {
+		want := -16
+		if op == "RET" {
+			want = 0
+		}
+		add(0, "CALL ·goFrameAnchor(SB)\nMOVD (RSP),R30\n"+op+" ·goFrameAnchor(SB)", want)
+	}
+	// These calls are encoded as AWORD, not Go's ABL. The native assembler
+	// therefore leaves TEXT $0 frameless. Save and restore the real caller LR.
+	add(0, "MOVD R30,R22\nWORD $0x94000003\nMOVD R22,R30\nRET\nhelper:\nB (R30)", 0)
+	add(0, "MOVD R30,R22\nADR helper,R0\nWORD $0xd63f0000\nMOVD R22,R30\nRET\nhelper:\nB (R30)", 0)
+	// Redirect a source RET to a safe witness label, then return through the
+	// original native link. Leaf RET uses current LR; nonleaf RET reloads the
+	// saved LR cell. Both pop their Go frame before reaching the witness.
+	add(32, "MOVD R30,R22\nADR redirected,R30\nRET\nredirected:\nMOVD R22,R30\nMOVD $123,R25\nB ·goFrameAnchor(SB)", 123)
+	add(32, "CALL ·goFrameAnchor(SB)\nMOVD (RSP),R22\nADR redirected,R0\nMOVD R0,(RSP)\nRET\nredirected:\nMOVD R22,R30\nMOVD $123,R25\nB ·goFrameAnchor(SB)", 123)
+	source.WriteString("TEXT ·goFrameAnchor(SB),4,$0-0\nRET\n")
+	decl.WriteString("func goFrameAnchor()\n")
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "frame.s")
+	if err := os.WriteFile(asm, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-S", "-o", filepath.Join(dir, "frame.o"), asm)
+	cmd.Env = append(os.Environ(), "GOARCH=arm64")
+	listing, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go frame object listing: %v\n%s", err, listing)
+	}
+	t.Logf("Go frame object listing:\n%s", listing)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+decl.String()+"func main(){\n"+checks.String()+"}\n", len(runner) != 0)
+	t.Logf("Native Go measured %d B/JMP/RET, raw BL/BLR and leaf/nonleaf LR witnesses; trampoline restores the actual caller SP/LR/FP", index)
+}
+
+func TestCrossLinuxRuntimeMatrixARM64SymbolTailReturnContracts(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, goDecl, cDecl, goChecks, cChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	index := 0
+	add := func(frame int, body string) {
+		name := fmt.Sprintf("symbolReturn%d", index)
+		index++
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$%d-16\n%s\n", name, frame, body)
+		sigs[name] = arm64LocalRegisterBranchSig(name)
+		fmt.Fprintf(&goDecl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&cDecl, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&goChecks, `
+for _, a := range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+	if got := %s(a); got != a+11 {
+		println(got)
+		panic("symbol return contract mismatch")
+	}
+}
+`, name)
+		fmt.Fprintf(&cChecks, `
+for (unsigned i=0;i<5;i++) {
+	if (%s(inputs[i])!=inputs[i]+11) {
+		fprintf(stderr,"symbol return contract mismatch\n");
+		return 1;
+	}
+}
+`, name)
+	}
+	for _, frame := range []int{0, 8, 32, 240} {
+		add(frame, "RET ·symbolValueAnchor(SB)")
+		add(frame, "CALL ·symbolVoidAnchor(SB)\nRET ·symbolValueAnchor(SB)")
+	}
+	for _, op := range []string{"B", "JMP"} {
+		add(0, "MOVD R30,R22\nMOVD $123,R30\nMOVD R22,R30\n"+op+" ·symbolValueAnchor(SB)")
+	}
+	for _, op := range []string{"RET", "RET ·symbolValueAnchor(SB)"} {
+		body := "MOVD R30,8(RSP)\nMOVD $123,R30\nMOVD 8(RSP),R30\n"
+		if op == "RET" {
+			body += "MOVD a+0(FP),R0\nADD $11,R0\nMOVD R0,ret+8(FP)\n"
+		}
+		add(32, body+op)
+		body = "MOVD (RSP),R22\nMOVD R22,8(RSP)\nCALL ·symbolVoidAnchor(SB)\nMOVD $123,R0\nMOVD R0,(RSP)\nMOVD 8(RSP),R22\nMOVD R22,(RSP)\n"
+		if op == "RET" {
+			body += "MOVD a+0(FP),R0\nADD $11,R0\nMOVD R0,ret+8(FP)\n"
+		}
+		add(32, body+op)
+	}
+	for _, call := range []string{"B callsite\nhelper:\nWORD $0x91002400\nB (R30)\ncallsite:\nWORD $0x97fffffe", "ADR helper,R3\nWORD $0xd63f0060"} {
+		helper := "\nhelper:\nADD $9,R0\nB (R30)"
+		if strings.HasPrefix(call, "B callsite") {
+			helper = ""
+		}
+		add(0, "MOVD a+0(FP),R0\nMOVD R30,R22\n"+call+"\nADD $2,R0\nMOVD R22,R30\nMOVD R0,ret+8(FP)\nRET"+helper)
+	}
+	source.WriteString(`TEXT ·symbolValueAnchor(SB),4,$0-16
+MOVD a+0(FP),R0
+ADD $11,R0
+MOVD R0,ret+8(FP)
+RET
+TEXT ·symbolVoidAnchor(SB),4,$0-0
+RET
+`)
+	goDecl.WriteString("func symbolValueAnchor(uint64) uint64\nfunc symbolVoidAnchor()\n")
+	sigs["symbolValueAnchor"] = arm64LocalRegisterBranchSig("symbolValueAnchor")
+	sigs["symbolVoidAnchor"] = FuncSig{Name: "symbolVoidAnchor", Ret: Void}
+	requireARM64GoAssemblerResult(t, source.String(), true)
+	runARM64LocalRegisterGoOracle(t, source.String(), "package main\n"+goDecl.String()+"func main(){\n"+goChecks.String()+"}\n", len(runner) != 0)
+	file, err := Parse(ArchARM64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs,
+			ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, target, "symbol-return.ll", "symbol-return.o", ir)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + "int main(void){ uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};\n" + cChecks.String() + "return 0;}\n"
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "symbol_return_contracts", triple, ir, main, runner)
+	t.Logf("%d symbol/caller-link return fixtures x 5 inputs passed native Go and LLVM22, plus four-target objects", index)
+}
diff --git a/arm64_syscall_effects.go b/arm64_syscall_effects.go
new file mode 100644
index 000000000..33161d25f
--- /dev/null
+++ b/arm64_syscall_effects.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type arm64SyscallOS uint8
+
+const (
+	arm64SyscallLinux arm64SyscallOS = iota + 1
+	arm64SyscallDarwinCarry
+)
+
+// This is the ordinary return of the typed libc bridge, not a source-entry,
+// memory-borrow, restart, sigreturn, SME or exclusive-monitor certificate.
+// The same descriptor drives lowering, continuation taint and IR effects.
+type arm64SyscallForm struct {
+	target           string
+	os               arm64SyscallOS
+	trap             uint16
+	number           Reg
+	gpWrites         uint32
+	gpUnavailable    uint32
+	flagsWrites      arm64FlagMask
+	flagsUnavailable arm64FlagMask
+}
+
+type arm64SyscallIRProof struct {
+	identity                   *arm64SyscallIRProof
+	owner                      *arm64Ctx
+	control                    *arm64LocalControlPlan
+	form                       arm64SyscallForm
+	nanosleep                  *arm64NanosleepInputProof
+	source                     Instr
+	block, instruction, offset int
+}
+
+func (proof *arm64SyscallIRProof) matches(c *arm64Ctx, original Instr, offset int) bool {
+	if proof == nil || proof.identity != proof || proof.owner != c || proof.offset != offset ||
+		proof.block != c.currentBlock || proof.instruction != c.currentInstruction ||
+		proof.block < 0 || proof.block >= len(c.blocks) || proof.instruction < 0 ||
+		proof.instruction >= len(c.blocks[proof.block].instrs) || c.localControl == nil || proof.control != c.localControl {
+		return false
+	}
+	if !reflect.DeepEqual(proof.source, original) ||
+		!reflect.DeepEqual(proof.source, c.blocks[proof.block].instrs[proof.instruction]) {
+		return false
+	}
+	form, err := parseARM64SyscallForm(c.targetTriple, arm64ControlDecode(original))
+	if err != nil || form != proof.form || proof.nanosleep != c.nanosleepInput {
+		return false
+	}
+	if proof.nanosleep != nil {
+		input, valid := c.nanosleepInputAt([2]int{proof.block, proof.instruction})
+		return valid && input.form == form
+	}
+	return true
+}
+
+func parseARM64SyscallForm(target string, ins Instr) (arm64SyscallForm, error) {
+	var form arm64SyscallForm
+	if strings.ToUpper(string(ins.Op)) != "SVC" || len(ins.Args) > 1 {
+		return form, fmt.Errorf("arm64 SVC expects no suffix and an optional integer immediate: %q", ins.Raw)
+	}
+	if len(ins.Args) == 1 {
+		operand := ins.Args[0]
+		if operand.Kind != OpImm || operand.ImmRaw != "" || operand.ImmIsFloat {
+			return form, fmt.Errorf("arm64 SVC expects a resolved integer immediate: %q", ins.Raw)
+		}
+		// Go accepts its entire C_VCON class, then encodes Offset & 0xffff.
+		form.trap = uint16(operand.Imm)
+	}
+	parts := strings.Split(target, "-")
+	if len(parts) < 3 || (parts[0] != "aarch64" && parts[0] != "arm64") {
+		return form, fmt.Errorf("%w: ARM64 syscall requires an explicit ARM64 target: %q", ErrProbeNeedsContext, target)
+	}
+	form.target = target
+	switch {
+	case parts[2] == "linux":
+		// Linux selects the A64 syscall ABI from R8, never the SVC immediate.
+		form.os, form.number, form.gpWrites = arm64SyscallLinux, "R8", 1
+	case arm64SyscallDarwinComponent(parts[2]):
+		if form.trap != 0x80 {
+			return form, fmt.Errorf("%w: unmodeled Darwin ARM64 trap %#x", ErrProbeNeedsContext, form.trap)
+		}
+		form.os, form.number, form.gpWrites = arm64SyscallDarwinCarry, "R16", 3
+		// A single-result libc call cannot supply Darwin's secondary return
+		// or certify its other native flags. Keep only the existing C role.
+		form.gpUnavailable = 1 << 1
+		form.flagsWrites = arm64FlagC
+		form.flagsUnavailable = arm64FlagAll &^ arm64FlagC
+	default:
+		return form, fmt.Errorf("%w: unmodeled ARM64 syscall target %q", ErrProbeNeedsContext, target)
+	}
+	return form, nil
+}
+
+func arm64SyscallDarwinComponent(component string) bool {
+	for _, name := range []string{"darwin", "macosx"} {
+		if component == name {
+			return true
+		}
+		if !strings.HasPrefix(component, name) {
+			continue
+		}
+		version := strings.TrimPrefix(component, name)
+		if len(version) == 0 || version[0] < '0' || version[0] > '9' {
+			continue
+		}
+		valid := true
+		for _, digit := range version {
+			if (digit < '0' || digit > '9') && digit != '.' {
+				valid = false
+			}
+		}
+		if valid {
+			return true
+		}
+	}
+	return false
+}
+
+// Register only these actual typed call lines, and retain their real memory
+// effects. The reader rebinds the descriptor to this source instruction and
+// target; a callee name, another native line or changed descriptor is opaque.
+func (c *arm64Ctx) emitARM64SyscallIR(form arm64SyscallForm, format string, args ...any) {
+	start := c.b.Len()
+	fmt.Fprintf(c.b, format, args...)
+	if flow := c.machineAvailability; flow != nil {
+		if c.localControl == nil || c.currentBlock < 0 || c.currentBlock >= len(c.blocks) ||
+			c.currentInstruction < 0 || c.currentInstruction >= len(c.blocks[c.currentBlock].instrs) {
+			return // No complete original CFG/frame guard supplied this bridge.
+		}
+		source := c.blocks[c.currentBlock].instrs[c.currentInstruction]
+		actual, err := parseARM64SyscallForm(c.targetTriple, arm64ControlDecode(source))
+		if err != nil || actual != form {
+			return
+		}
+		source.Args = append([]Operand(nil), source.Args...)
+		for index := range source.Args {
+			source.Args[index].RegList = append([]Reg(nil), source.Args[index].RegList...)
+		}
+		proof := &arm64SyscallIRProof{owner: c, control: c.localControl, form: form, source: source,
+			block: c.currentBlock, instruction: c.currentInstruction, offset: start, nanosleep: c.nanosleepInput}
+		proof.identity = proof
+		if flow.nativeIR == nil {
+			flow.nativeIR = make(map[int]arm64MachineNativeProof)
+		}
+		flow.nativeIR[start] = arm64MachineNativeProof{line: c.b.String()[start:], store: true, syscall: proof}
+	}
+}
diff --git a/arm64_syscall_effects_test.go b/arm64_syscall_effects_test.go
new file mode 100644
index 000000000..b2bb598d9
--- /dev/null
+++ b/arm64_syscall_effects_test.go
@@ -0,0 +1,268 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are numerical, zero-frame fixtures. Neither a syscall format nor a
+// target OS supplies a native entry, saved-frame or local-memory capability.
+const arm64SyscallEffectSetup = "MOVD $0,R0\nMOVD $11,R1\nMOVD $12,R2\nMOVD $13,R3\nMOVD $14,R4\nMOVD $15,R5\nMOVD $172,R8\nMOVD $57,R16\n"
+
+func arm64SyscallEffectSource(body string) string {
+	return "TEXT ·trap(SB),516,$0-8\n" + arm64SyscallEffectSetup + body + "\nMOVD R0,ret+0(FP)\nRET\n"
+}
+
+func arm64SyscallEffectAPI(t *testing.T, api, triple, source string) (string, error) {
+	t.Helper()
+	const packagePath = "example.com/syscalleffects"
+	pkg := mustGoPackage(t, packagePath, "package syscalleffects\nfunc trap() uint64\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := testResolveSym(packagePath)
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "arm64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs, AnnotateSource: true}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	switch api {
+	case "text":
+		return Translate(file, options)
+	case "module":
+		module, err := TranslateModuleInContext(context, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			return module.String(), err
+		}
+		return "", err
+	case "Go":
+		goos := "linux"
+		if strings.Contains(triple, "apple-darwin") {
+			goos = "darwin"
+		}
+		result, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+			GOOS: goos, GOARCH: "arm64", TargetTriple: triple, ResolveSym: resolve, AnnotateSource: true,
+		})
+		if result != nil && !result.Module.IsNil() {
+			defer result.Module.Dispose()
+			return result.Module.String(), err
+		}
+		return "", err
+	default:
+		t.Fatalf("unknown syscall API %q", api)
+		return "", nil
+	}
+}
+
+func arm64SyscallEffectIR(t *testing.T, ir, spelling string) string {
+	t.Helper()
+	// LLVM's parser removes source comments. Observe the sole actual call and
+	// its contiguous number/argument loads, through the later result read.
+	lines := strings.Split(ir, "\n")
+	call, start, end := -1, -1, -1
+	for index, line := range lines {
+		if strings.Contains(line, "call i64 @syscall(") {
+			if call >= 0 {
+				t.Fatalf("ambiguous actual syscall call for %s", spelling)
+			}
+			call = index
+		}
+	}
+	if call >= 0 {
+		for index := call - 1; index >= 0; index-- {
+			line := lines[index]
+			if strings.Contains(line, "load i64, ptr %reg_R8,") || strings.Contains(line, "load i64, ptr %reg_R16,") {
+				start = index
+				break
+			}
+		}
+		for index := call + 1; index < len(lines); index++ {
+			if strings.Contains(lines[index], "load i64, ptr %reg_R0,") {
+				end = index
+				break
+			}
+		}
+	}
+	if start < 0 || end <= call {
+		t.Fatalf("actual number/call/result sequence absent for %s", spelling)
+	}
+	return strings.Join(lines[start:end], "\n")
+}
+
+func TestARM64SyscallLinuxNormalReturnEffects(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, spelling := range []string{"SVC", "SVC $0", "SVC $0x80", "SVC $65535", "SVC $65536", "SVC $-1"} {
+			t.Run(api+"/"+spelling, func(t *testing.T) {
+				source := arm64SyscallEffectSource("CMP R2,R1\n" + spelling + "\nCSET MI,R2\nCSET EQ,R3\nCSET CS,R4\nCSET VS,R5")
+				ir, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fragment := arm64SyscallEffectIR(t, ir, spelling)
+				if !strings.Contains(fragment, "@syscall(") || !strings.Contains(fragment, "ptr %reg_R8") ||
+					!strings.Contains(fragment, "sub i64 0") {
+					t.Fatalf("Linux trap must use R8 and raw -errno: %s", fragment)
+				}
+				for _, line := range strings.Split(fragment, "\n") {
+					if strings.Contains(line, "store ") && (strings.Contains(line, "ptr %reg_R1") || strings.Contains(line, "ptr %flags_")) {
+						t.Errorf("Linux normal-return GP/NZCV preservation violated: %s", line)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallFlagsRequireCompletePredecessors(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, body := range []string{
+			"SVC\nCSET CS,R2",
+			"SVC $0x80\nCSET MI,R2",
+			"SVC\nJMP observe\nobserve:\nCSET VS,R2",
+			"CBZ R0,trap\nCMP R2,R1\ntrap:\nSVC\nCSET EQ,R2",
+		} {
+			t.Run(api+"/"+body, func(t *testing.T) {
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource(body))
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("SVC cannot supply missing original NZCV: %v", err)
+				}
+			})
+		}
+		for _, body := range []string{
+			"CMP R2,R1\nJMP trap\ntrap:\nSVC\nJMP observe\nobserve:\nCSET CS,R2",
+			"JMP compare\nobserve:\nCSET VS,R2\nJMP finish\ncompare:\nCMP R2,R1\nSVC\nJMP observe\nfinish:",
+			"CBZ R0,left\nCMP R2,R1\nJMP trap\nleft:\nCMP R3,R1\ntrap:\nSVC\nCSET EQ,R2",
+		} {
+			t.Run(api+"/defined/"+body, func(t *testing.T) {
+				if _, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource(body)); err != nil {
+					t.Fatalf("complete reaching CMP must survive Linux SVC: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallRequiresExplicitSupportedTarget(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"", "aarch64-unknown-freebsd", "aarch64-pc-windows-msvc", "x86_64-unknown-linux-gnu", "aarch64-unknown-notlinux-gnu", "aarch64-unknown-linuxish-gnu"} {
+			t.Run(api+"/"+triple, func(t *testing.T) {
+				_, err := arm64SyscallEffectAPI(t, api, triple, arm64SyscallEffectSource("SVC $0x80"))
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("target cannot be inferred from host, immediate or GP values: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallDarwinCarryRoleIsSeparate(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := arm64SyscallEffectAPI(t, api, "aarch64-apple-darwin", arm64SyscallEffectSource("SVC $0x80\nCSET CS,R2"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			fragment := arm64SyscallEffectIR(t, ir, "SVC $0x80")
+			if !strings.Contains(fragment, "ptr %reg_R16") || strings.Contains(fragment, "ptr %reg_R8") || strings.Contains(fragment, "sub i64 0") {
+				t.Fatalf("Darwin carry bridge selected Linux number/error convention: %s", fragment)
+			}
+			if !strings.Contains(fragment, "store i1") || !strings.Contains(fragment, "ptr %flags_c") {
+				t.Fatal("Darwin carry write missing")
+			}
+		})
+		for _, spelling := range []string{"SVC", "SVC $0", "SVC $1", "SVC $65535"} {
+			t.Run(api+"/unknown-trap/"+spelling, func(t *testing.T) {
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-apple-darwin", arm64SyscallEffectSource(spelling))
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unmodeled Darwin trap cannot become Linux: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallDarwinUnknownOutputsRemainContext(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, observation := range []string{
+			"CSET MI,R2", "CSET EQ,R2", "CSET VS,R2", "CSET HI,R2",
+			"MOVD R1,R0", "JMP observe\nobserve:\nCSET GT,R2",
+		} {
+			t.Run(api+"/"+observation, func(t *testing.T) {
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-apple-darwin",
+					arm64SyscallEffectSource("CMP R2,R1\nSVC $0x80\n"+observation))
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Darwin carry-only bridge cannot invent secondary result or other NZCV: %v", err)
+				}
+			})
+		}
+		for _, body := range []string{
+			"SVC $0x80\nCMP R3,R2\nCSET HI,R2",
+			"SVC $0x80\nMOVD $37,R1\nMOVD R1,R0",
+			"SVC $0x80\nJMP redefine\nredefine:\nCMP R3,R2\nCSET GT,R2",
+		} {
+			t.Run(api+"/redefined/"+body, func(t *testing.T) {
+				if _, err := arm64SyscallEffectAPI(t, api, "aarch64-apple-darwin", arm64SyscallEffectSource(body)); err != nil {
+					t.Fatalf("complete fresh writes must restore only their actual defined outputs: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallContinuationEffects(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, register := range []string{"R0", "R1", "R2", "R16"} {
+			t.Run(api+"/"+register, func(t *testing.T) {
+				body := fmt.Sprintf("ADR resume,%s\nSVC\nJMP (%s)\nresume:", register, register)
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource(body))
+				if register == "R0" {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("new syscall R0 cannot impersonate old local continuation: %v", err)
+					}
+				} else if err != nil {
+					t.Fatalf("untouched Linux %s local continuation lost: %v", register, err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallRejectsNonIntegerAndMalformedForms(t *testing.T) {
+	for _, spelling := range []string{"SVC R0", "SVC (R0)", "SVC $0,$1", "SVC $1.5", "SVC $missing", "SVC.P $0", "SVC.W $0"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api+"/"+spelling, func(t *testing.T) {
+				if _, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource(spelling)); err == nil {
+					t.Fatal("malformed/unresolved syscall emitted successful IR")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64SyscallCarryReadersRequireActualDefinition(t *testing.T) {
+	for _, op := range []string{"ADC", "ADCW", "ADCS", "ADCSW", "SBC", "SBCW", "SBCS", "SBCSW", "NGC", "NGCW", "NGCS", "NGCSW"} {
+		instruction := op + " R2,R3"
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api+"/missing/"+op, func(t *testing.T) {
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource("SVC\n"+instruction))
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("carry read cannot consume alloca initialization or fabricated SVC carry: %v", err)
+				}
+			})
+			t.Run(api+"/defined/"+op, func(t *testing.T) {
+				body := "CMP R2,R1\nJMP trap\ntrap:\nSVC\nJMP observe\nobserve:\n" + instruction
+				if _, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource(body)); err != nil {
+					t.Fatalf("actual reaching C must survive Linux SVC for %s: %v", op, err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_syscall_forms_go127_test.go b/arm64_syscall_forms_go127_test.go
new file mode 100644
index 000000000..30e006e4e
--- /dev/null
+++ b/arm64_syscall_forms_go127_test.go
@@ -0,0 +1,96 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestARM64SyscallGoCompleteConstantClassOriginalBytes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	// Go asm7's ASVC C_VCON and C_NONE rows encode Offset & 0xffff.
+	// This is an encoding observation, not entry/memory or Linux execution proof.
+	cases := []struct {
+		spelling string
+		word     uint32
+	}{
+		{"SVC", 0xd4000001}, {"SVC $0", 0xd4000001}, {"SVC $1", 0xd4000021},
+		{"SVC $0x80", 0xd4001001}, {"SVC $65535", 0xd41fffe1},
+		{"SVC $65536", 0xd4000001}, {"SVC $65537", 0xd4000021},
+		{"SVC $-1", 0xd41fffe1}, {"SVC $-65536", 0xd4000001},
+		{"SVC $9223372036854775807", 0xd41fffe1}, {"SVC $-9223372036854775808", 0xd4000001},
+	}
+	var source strings.Builder
+	for index, test := range cases {
+		fmt.Fprintf(&source, "TEXT ·form_%d(SB),516,$0-0\n%s\nRET\n", index, test.spelling)
+	}
+	directory := t.TempDir()
+	input, output := filepath.Join(directory, "forms.s"), filepath.Join(directory, "forms.o")
+	if err := os.WriteFile(input, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, release := runtimeOracleStageContext(t)
+	defer release()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "example.com/svcforms", "-o", output, input)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64", "GOARM64=v8.0")
+	raw, err := runtimeOracleCombinedOutput(ctx, command)
+	if err := goAssemblerOracleOutcome(input, output, raw, err, ctx.Err(), true, "arm64"); err != nil {
+		t.Fatalf("independent original Go C_VCON/C_NONE: %v\n%s", err, raw)
+	}
+	object, err := os.ReadFile(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtins, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	texts, err := gostaticstorage.ObserveARM64AssemblyText(object, builtins, "linux/arm64")
+	if err != nil || len(texts) != len(cases) {
+		t.Fatalf("actual original object inventory: %v count=%d", err, len(texts))
+	}
+	for index, test := range cases {
+		t.Run(test.spelling, func(t *testing.T) {
+			text := texts[index]
+			if text.Name != fmt.Sprintf("example.com/svcforms.form_%d", index) || text.ABI != 0 ||
+				len(text.Code) < 8 || len(text.Relocations) != 0 || len(text.Positions) == 0 ||
+				binary.LittleEndian.Uint32(text.Code[:4]) != test.word || binary.LittleEndian.Uint32(text.Code[4:8]) != 0xd65f03c0 {
+				t.Fatalf("independent actual ASVC constant bytes differ: %+v", text)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", arm64SyscallEffectSource("CMP R2,R1\n"+test.spelling))
+					if err != nil {
+						t.Fatalf("Go-accepted C_VCON spelling missing: %v", err)
+					}
+					fragment := arm64SyscallEffectIR(t, ir, test.spelling)
+					if !strings.Contains(fragment, "ptr %reg_R8") || strings.Contains(fragment, "ptr %flags_") {
+						t.Fatalf("encoded immediate selected a non-Linux ABI/effect: %s", fragment)
+					}
+					for _, optimization := range []int{0, 2} {
+						t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+							arm64LinuxSyscallEffectCompileObject(t, llc, ir, optimization)
+						})
+					}
+				})
+			}
+		})
+	}
+	for _, spelling := range []string{"SVC R0", "SVC (R0)", "SVC $0,$1", "SVC $1.5", "SVC.P $0", "SVC.W $0"} {
+		t.Run("Go-reject/"+spelling, func(t *testing.T) {
+			requireARM64GoAssemblerResult(t, "TEXT ·invalid(SB),516,$0-0\n"+spelling+"\nRET\n", false)
+		})
+	}
+}
diff --git a/arm64_syscall_proof_test.go b/arm64_syscall_proof_test.go
new file mode 100644
index 000000000..0a8e2625e
--- /dev/null
+++ b/arm64_syscall_proof_test.go
@@ -0,0 +1,281 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64SyscallProofFixture(t *testing.T) (*arm64Ctx, int, Instr) {
+	t.Helper()
+	source := arm64SyscallEffectSource("CMP R2,R1\nSVC\nCSET CS,R2")
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatalf("complete first-party syscall fixture: %v", err)
+	}
+	var output strings.Builder
+	sig := FuncSig{Name: "example.com/syscalleffects.trap", Ret: I64,
+		Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+	c := newARM64CtxWithTarget(&output, file.Funcs[0], sig, testResolveSym("example.com/syscalleffects"), nil,
+		"aarch64-unknown-linux-gnu", false)
+	if err := c.prepareLocalControl(); err != nil {
+		t.Fatal("actual whole-source continuation/frame prerequisite", err)
+	}
+	c.emitEntryAllocasAndArgInit()
+	c.machineAvailability = newARM64MachineAvailability(c)
+	if err := c.lowerBlocks(); err != nil {
+		t.Fatal("actual source lowering prerequisite", err)
+	}
+	if err := c.machineAvailability.validate(); err != nil {
+		t.Fatal("actual numerical effect prerequisite", err)
+	}
+	start := -1
+	var original Instr
+	count := 0
+	for offset, native := range c.machineAvailability.nativeIR {
+		if native.syscall == nil {
+			continue
+		}
+		count++
+		if strings.Contains(native.line, "call i64 @syscall(") {
+			start, original = offset, native.syscall.source
+			c.currentBlock, c.currentInstruction = native.syscall.block, native.syscall.instruction
+			c.machineAvailability.current = c.currentBlock
+		}
+	}
+	if count != 2 || start < 0 {
+		t.Fatalf("actual typed bridge must retain two distinct call effects: count=%d", count)
+	}
+	c.machineAvailability.blocks[c.currentBlock].effects = nil
+	return c, start, original
+}
+
+func TestARM64SyscallBridgeProofExactIdentity(t *testing.T) {
+	for _, change := range []struct {
+		name  string
+		apply func(*arm64Ctx, int, *Instr) *arm64Ctx
+	}{
+		{"unaltered", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx { return c }},
+		{"context-copy", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx { copy := *c; return &copy }},
+		{"proof-copy", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			native := c.machineAvailability.nativeIR[offset]
+			copy := *native.syscall
+			native.syscall = &copy
+			c.machineAvailability.nativeIR[offset] = native
+			return c
+		}},
+		{"descriptor", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			c.machineAvailability.nativeIR[offset].syscall.form.gpWrites = 3
+			return c
+		}},
+		{"target", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx { c.targetTriple = "aarch64-unknown-linux-musl"; return c }},
+		{"line", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			native := c.machineAvailability.nativeIR[offset]
+			native.line = strings.Replace(native.line, "i64", "i32", 1)
+			c.machineAvailability.nativeIR[offset] = native
+			return c
+		}},
+		{"offset", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			c.machineAvailability.nativeIR[offset+1] = c.machineAvailability.nativeIR[offset]
+			delete(c.machineAvailability.nativeIR, offset)
+			return c
+		}},
+		{"ordinal", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			c.machineAvailability.nativeIR[offset].syscall.instruction++
+			return c
+		}},
+		{"block", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			c.machineAvailability.nativeIR[offset].syscall.block++
+			return c
+		}},
+		{"source", func(c *arm64Ctx, _ int, ins *Instr) *arm64Ctx { ins.Raw += " foreign"; return c }},
+		{"source-op", func(c *arm64Ctx, _ int, ins *Instr) *arm64Ctx { ins.Op = "NOP"; return c }},
+		{"source-operand", func(c *arm64Ctx, _ int, ins *Instr) *arm64Ctx {
+			ins.Args = []Operand{{Kind: OpImm, Imm: 1}}
+			return c
+		}},
+		{"current-source", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx {
+			c.blocks[c.currentBlock].instrs[c.currentInstruction].Raw += " changed"
+			return c
+		}},
+		{"store-effect", func(c *arm64Ctx, offset int, _ *Instr) *arm64Ctx {
+			native := c.machineAvailability.nativeIR[offset]
+			native.store = false
+			c.machineAvailability.nativeIR[offset] = native
+			return c
+		}},
+		{"missing-CFG", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx { c.localControl = nil; return c }},
+		{"replaced-CFG", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx {
+			copy := *c.localControl
+			c.localControl = &copy
+			return c
+		}},
+		{"same-callee-unregistered", func(c *arm64Ctx, _ int, _ *Instr) *arm64Ctx {
+			c.b.WriteString("  %foreign = call i64 @syscall(i64 0, i64 0, i64 0, i64 0, i64 0, i64 0, i64 0)\n")
+			return c
+		}},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			c, offset, original := arm64SyscallProofFixture(t)
+			c = change.apply(c, offset, &original)
+			c.recordMachineOpaqueIR(offset, original)
+			stores, opaque := 0, 0
+			for _, effect := range c.machineAvailability.blocks[c.machineAvailability.current].effects {
+				if effect.store {
+					stores++
+				}
+				if effect.opaque {
+					opaque++
+				}
+			}
+			if change.name == "unaltered" {
+				if stores != 2 || opaque != 0 {
+					t.Fatalf("actual ordinary-return bridge erased stores or gained opaque effects: stores=%d opaque=%d", stores, opaque)
+				}
+			} else if opaque == 0 {
+				t.Fatal("copied/changed/private-unregistered bridge acquired typed effects")
+			}
+		})
+	}
+}
+
+func TestARM64SyscallUnmodeledFlagsCannotBorrowCMP(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			_, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu",
+				arm64SyscallEffectSource("CMP R2,R1\nMSR R3,TPIDR_EL0\nSVC\nCSET CS,R2"))
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unregistered native state cannot retain old CMP witness through SVC: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64FlagsUnmodeledNativeCalloutWithoutSyscall(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, observation := range []string{"CSET CS,R2", "JMP observe\nobserve:\nCSET EQ,R2", "ADC R2,R3"} {
+			t.Run(api+"/"+observation, func(t *testing.T) {
+				source := arm64SyscallEffectSource("CMP R2,R1\nMSR R3,TPIDR_EL0\n" + observation)
+				requireARM64GoAssemblerResult(t, source, true)
+				_, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", source)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("non-SVC native effect cannot reuse the old virtual flag witness: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64FlagsOnlyNativeObservationHasNoEntryOrDuplicateCFG(t *testing.T) {
+	for _, body := range []string{
+		"MOVD $3,R3\nMSR R3,NZCV",                 // Exact source NZCV write needs no entry flags.
+		"CMP R2,R1\nMRS DCZID_EL0,R4\nCSET CS,R2", // Exact registered preservation.
+		"MSR R3,NZCV\nCMP R2,R1\nCSET CS,R2",      // A real later producer restores flags.
+	} {
+		t.Run(body, func(t *testing.T) {
+			source := arm64SyscallEffectSource(body)
+			requireARM64GoAssemblerResult(t, source, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := arm64SyscallEffectAPI(t, api, "aarch64-unknown-linux-gnu", source); err != nil {
+					t.Fatalf("light observation changed nonobserving/redefined %s source: %v", api, err)
+				}
+			}
+			// The API controls above keep their real FP result. Its existing
+			// scalar-memory scratch observation legitimately requires the full
+			// machine CFG. Check flags-only storage with a separate original Go
+			// zero-result source, without borrowing that FP role.
+			observationSource := "TEXT ·trap(SB),516,$0-0\n" + arm64SyscallEffectSetup + body + "\nRET\n"
+			requireARM64GoAssemblerResult(t, observationSource, true)
+			file, err := Parse(ArchARM64, observationSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var output strings.Builder
+			c := newARM64CtxWithTarget(&output, file.Funcs[0], FuncSig{Ret: Void}, testResolveSym("example"), nil,
+				"aarch64-unknown-linux-gnu", false)
+			if err := c.prepareLocalControl(); err != nil {
+				t.Fatal(err)
+			}
+			flow := newARM64MachineAvailability(c)
+			if !flow.flagsOnly || flow.used || flow.entry != nil || len(flow.blocks) != 0 {
+				t.Fatal("ordered flag observation created an entry role or duplicate machine CFG")
+			}
+		})
+	}
+}
+
+func TestARM64FlagPredicateReadsOnlyItsRequiredBits(t *testing.T) {
+	for _, test := range []struct {
+		condition string
+		mask      arm64FlagMask
+	}{
+		{"EQ", arm64FlagZ}, {"NE", arm64FlagZ},
+		{"CS", arm64FlagC}, {"HS", arm64FlagC}, {"CC", arm64FlagC}, {"LO", arm64FlagC},
+		{"HI", arm64FlagC | arm64FlagZ}, {"LS", arm64FlagC | arm64FlagZ},
+		{"MI", arm64FlagN}, {"PL", arm64FlagN}, {"VS", arm64FlagV}, {"VC", arm64FlagV},
+		{"GE", arm64FlagN | arm64FlagV}, {"LT", arm64FlagN | arm64FlagV},
+		{"GT", arm64FlagN | arm64FlagV | arm64FlagZ}, {"LE", arm64FlagN | arm64FlagV | arm64FlagZ},
+		{"AL", 0}, {"NV", 0},
+	} {
+		t.Run(test.condition, func(t *testing.T) {
+			c, output := newARM64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			// This is an isolated typed bit-flow unit, not an original entry or
+			// caller certificate. The source/API tests provide the latter roles.
+			c.flagsKnown = test.mask
+			start := output.Len()
+			if _, err := c.condValue(test.condition); err != nil {
+				t.Fatal(err)
+			}
+			for _, slot := range []string{c.flagsNSlot, c.flagsZSlot, c.flagsCSlot, c.flagsVSlot} {
+				read := strings.Contains(output.String()[start:], "load i1, ptr "+slot+"\n")
+				if read != (c.arm64FlagSlotMask(slot)&test.mask != 0) {
+					t.Fatalf("%s read an unrelated/unknown bit at %s", test.condition, slot)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64FlagFlowOrderedBitEffects(t *testing.T) {
+	for _, bit := range []arm64FlagMask{arm64FlagN, arm64FlagZ, arm64FlagC, arm64FlagV} {
+		for _, test := range []struct {
+			name    string
+			effects []arm64FlagEffect
+			valid   bool
+		}{
+			{"write-read", []arm64FlagEffect{{write: bit}, {read: bit}}, true},
+			{"read-write", []arm64FlagEffect{{read: bit}, {write: bit}}, false},
+			{"other-bit", []arm64FlagEffect{{write: arm64FlagAll &^ bit}, {read: bit}}, false},
+			{"write-invalidate-read", []arm64FlagEffect{{write: arm64FlagAll}, {invalidate: bit}, {read: bit}}, false},
+			{"invalidate-write-read", []arm64FlagEffect{{invalidate: bit}, {write: bit}, {read: bit}}, true},
+			{"unread-other-invalid", []arm64FlagEffect{{write: arm64FlagAll}, {invalidate: arm64FlagAll &^ bit}, {read: bit}}, true},
+		} {
+			t.Run(fmt.Sprintf("%x/%s", bit, test.name), func(t *testing.T) {
+				flow := &arm64FlagFlow{blocks: []arm64FlagFlowBlock{{name: "entry", effects: test.effects}}, indices: map[string]int{"entry": 0}}
+				err := flow.validate()
+				if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("actual ordered bit effects valid=%v: %v", test.valid, err)
+				}
+			})
+		}
+		for _, invalidate := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%x/loop-invalidate-%v", bit, invalidate), func(t *testing.T) {
+				loop := []arm64FlagEffect{{read: bit}}
+				if invalidate {
+					loop = append(loop, arm64FlagEffect{invalidate: bit})
+				}
+				flow := &arm64FlagFlow{blocks: []arm64FlagFlowBlock{
+					{name: "entry", effects: []arm64FlagEffect{{write: bit}}, successors: []string{"loop", "join"}},
+					{name: "loop", effects: loop, successors: []string{"loop", "join"}},
+					{name: "join", effects: []arm64FlagEffect{{read: bit}}},
+				}, indices: map[string]int{"entry": 0, "loop": 1, "join": 2}}
+				err := flow.validate()
+				if !invalidate && err != nil || invalidate && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unknown loop predecessor was lost: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_sysregs.go b/arm64_sysregs.go
new file mode 100644
index 000000000..34a1fe572
--- /dev/null
+++ b/arm64_sysregs.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import "fmt"
+
+//go:generate go run ./cmd/plan9asmgenregs -out arm64_sysregs_generated.go
+
+// A named Go register and a raw MRS/MSR word share the same physical operand
+// grammar. Canonical encodings avoid LLVM's feature-gated aliases without
+// replacing a system-register read with an invented constant.
+type arm64SystemRegisterSpec struct {
+	encoding           uint16
+	readable, writable bool
+}
+
+func arm64CheckedSystemRegister(name string, read bool) (string, error) {
+	if spec, ok := arm64GoSystemRegisters[name]; ok {
+		if (read && !spec.readable) || (!read && !spec.writable) {
+			access := "writable"
+			if read {
+				access = "readable"
+			}
+			return "", fmt.Errorf("arm64 system register %s is not %s", name, access)
+		}
+		return arm64EncodedSystemRegisterName(spec.encoding), nil
+	}
+	// Encoded names also occur in decoded raw instructions. Their grammar is
+	// validated by the raw decoder and LLVM's assembler, not a named alias table.
+	return arm64CanonicalSysReg(name), nil
+}
+
+// SR_READ alone is not an execution or source-machine-state contract. Most
+// registers require privileged entry state, feature state, or access to the
+// source's virtual NZCV/FP state. DCZID_EL0 is an architectural EL0 read whose
+// only data effect is defining Xt; even prohibited DC ZVA is reported as a bit
+// in the value rather than performed by this read.
+func arm64SystemReadHasTypedEffects(encoding uint16) bool {
+	spec, ok := arm64GoSystemRegisters["DCZID_EL0"]
+	return ok && spec.readable && encoding == spec.encoding
+}
+
+func (c *arm64Ctx) emitARM64SystemRegisterRead(sysreg string, encoding uint16, known bool, dst Reg) string {
+	value := c.newTmp()
+	format := "  %%%s = call i64 asm sideeffect %q, %q()\n"
+	// A virtual data value cannot grant a hidden platform/g entry contract.
+	if known && arm64SystemReadHasTypedEffects(encoding) && dst != "R18" && dst != "R28" {
+		c.emitMachineNeutralNativeIR(format, value, "mrs $0, "+sysreg, "=r,~{memory}")
+	} else {
+		fmt.Fprintf(c.b, format, value, "mrs $0, "+sysreg, "=r,~{memory}")
+	}
+	return "%" + value
+}
diff --git a/arm64_sysregs_generated.go b/arm64_sysregs_generated.go
new file mode 100644
index 000000000..2f274a85e
--- /dev/null
+++ b/arm64_sysregs_generated.go
@@ -0,0 +1,437 @@
+// Code generated by plan9asmgenregs from the Go assembler system-register table. DO NOT EDIT.
+
+package plan9asm
+
+var arm64GoSystemRegisters = map[string]arm64SystemRegisterSpec{
+	"ACTLR_EL1":         {encoding: 0x4081, readable: true, writable: true},
+	"AFSR0_EL1":         {encoding: 0x4288, readable: true, writable: true},
+	"AFSR1_EL1":         {encoding: 0x4289, readable: true, writable: true},
+	"AIDR_EL1":          {encoding: 0x4807, readable: true, writable: false},
+	"AMAIR_EL1":         {encoding: 0x4518, readable: true, writable: true},
+	"AMCFGR_EL0":        {encoding: 0x5e91, readable: true, writable: false},
+	"AMCGCR_EL0":        {encoding: 0x5e92, readable: true, writable: false},
+	"AMCNTENCLR0_EL0":   {encoding: 0x5e94, readable: true, writable: true},
+	"AMCNTENCLR1_EL0":   {encoding: 0x5e98, readable: true, writable: true},
+	"AMCNTENSET0_EL0":   {encoding: 0x5e95, readable: true, writable: true},
+	"AMCNTENSET1_EL0":   {encoding: 0x5e99, readable: true, writable: true},
+	"AMCR_EL0":          {encoding: 0x5e90, readable: true, writable: true},
+	"AMEVCNTR00_EL0":    {encoding: 0x5ea0, readable: true, writable: true},
+	"AMEVCNTR01_EL0":    {encoding: 0x5ea1, readable: true, writable: true},
+	"AMEVCNTR02_EL0":    {encoding: 0x5ea2, readable: true, writable: true},
+	"AMEVCNTR03_EL0":    {encoding: 0x5ea3, readable: true, writable: true},
+	"AMEVCNTR04_EL0":    {encoding: 0x5ea4, readable: true, writable: true},
+	"AMEVCNTR05_EL0":    {encoding: 0x5ea5, readable: true, writable: true},
+	"AMEVCNTR06_EL0":    {encoding: 0x5ea6, readable: true, writable: true},
+	"AMEVCNTR07_EL0":    {encoding: 0x5ea7, readable: true, writable: true},
+	"AMEVCNTR08_EL0":    {encoding: 0x5ea8, readable: true, writable: true},
+	"AMEVCNTR09_EL0":    {encoding: 0x5ea9, readable: true, writable: true},
+	"AMEVCNTR010_EL0":   {encoding: 0x5eaa, readable: true, writable: true},
+	"AMEVCNTR011_EL0":   {encoding: 0x5eab, readable: true, writable: true},
+	"AMEVCNTR012_EL0":   {encoding: 0x5eac, readable: true, writable: true},
+	"AMEVCNTR013_EL0":   {encoding: 0x5ead, readable: true, writable: true},
+	"AMEVCNTR014_EL0":   {encoding: 0x5eae, readable: true, writable: true},
+	"AMEVCNTR015_EL0":   {encoding: 0x5eaf, readable: true, writable: true},
+	"AMEVCNTR10_EL0":    {encoding: 0x5ee0, readable: true, writable: true},
+	"AMEVCNTR11_EL0":    {encoding: 0x5ee1, readable: true, writable: true},
+	"AMEVCNTR12_EL0":    {encoding: 0x5ee2, readable: true, writable: true},
+	"AMEVCNTR13_EL0":    {encoding: 0x5ee3, readable: true, writable: true},
+	"AMEVCNTR14_EL0":    {encoding: 0x5ee4, readable: true, writable: true},
+	"AMEVCNTR15_EL0":    {encoding: 0x5ee5, readable: true, writable: true},
+	"AMEVCNTR16_EL0":    {encoding: 0x5ee6, readable: true, writable: true},
+	"AMEVCNTR17_EL0":    {encoding: 0x5ee7, readable: true, writable: true},
+	"AMEVCNTR18_EL0":    {encoding: 0x5ee8, readable: true, writable: true},
+	"AMEVCNTR19_EL0":    {encoding: 0x5ee9, readable: true, writable: true},
+	"AMEVCNTR110_EL0":   {encoding: 0x5eea, readable: true, writable: true},
+	"AMEVCNTR111_EL0":   {encoding: 0x5eeb, readable: true, writable: true},
+	"AMEVCNTR112_EL0":   {encoding: 0x5eec, readable: true, writable: true},
+	"AMEVCNTR113_EL0":   {encoding: 0x5eed, readable: true, writable: true},
+	"AMEVCNTR114_EL0":   {encoding: 0x5eee, readable: true, writable: true},
+	"AMEVCNTR115_EL0":   {encoding: 0x5eef, readable: true, writable: true},
+	"AMEVTYPER00_EL0":   {encoding: 0x5eb0, readable: true, writable: false},
+	"AMEVTYPER01_EL0":   {encoding: 0x5eb1, readable: true, writable: false},
+	"AMEVTYPER02_EL0":   {encoding: 0x5eb2, readable: true, writable: false},
+	"AMEVTYPER03_EL0":   {encoding: 0x5eb3, readable: true, writable: false},
+	"AMEVTYPER04_EL0":   {encoding: 0x5eb4, readable: true, writable: false},
+	"AMEVTYPER05_EL0":   {encoding: 0x5eb5, readable: true, writable: false},
+	"AMEVTYPER06_EL0":   {encoding: 0x5eb6, readable: true, writable: false},
+	"AMEVTYPER07_EL0":   {encoding: 0x5eb7, readable: true, writable: false},
+	"AMEVTYPER08_EL0":   {encoding: 0x5eb8, readable: true, writable: false},
+	"AMEVTYPER09_EL0":   {encoding: 0x5eb9, readable: true, writable: false},
+	"AMEVTYPER010_EL0":  {encoding: 0x5eba, readable: true, writable: false},
+	"AMEVTYPER011_EL0":  {encoding: 0x5ebb, readable: true, writable: false},
+	"AMEVTYPER012_EL0":  {encoding: 0x5ebc, readable: true, writable: false},
+	"AMEVTYPER013_EL0":  {encoding: 0x5ebd, readable: true, writable: false},
+	"AMEVTYPER014_EL0":  {encoding: 0x5ebe, readable: true, writable: false},
+	"AMEVTYPER015_EL0":  {encoding: 0x5ebf, readable: true, writable: false},
+	"AMEVTYPER10_EL0":   {encoding: 0x5ef0, readable: true, writable: true},
+	"AMEVTYPER11_EL0":   {encoding: 0x5ef1, readable: true, writable: true},
+	"AMEVTYPER12_EL0":   {encoding: 0x5ef2, readable: true, writable: true},
+	"AMEVTYPER13_EL0":   {encoding: 0x5ef3, readable: true, writable: true},
+	"AMEVTYPER14_EL0":   {encoding: 0x5ef4, readable: true, writable: true},
+	"AMEVTYPER15_EL0":   {encoding: 0x5ef5, readable: true, writable: true},
+	"AMEVTYPER16_EL0":   {encoding: 0x5ef6, readable: true, writable: true},
+	"AMEVTYPER17_EL0":   {encoding: 0x5ef7, readable: true, writable: true},
+	"AMEVTYPER18_EL0":   {encoding: 0x5ef8, readable: true, writable: true},
+	"AMEVTYPER19_EL0":   {encoding: 0x5ef9, readable: true, writable: true},
+	"AMEVTYPER110_EL0":  {encoding: 0x5efa, readable: true, writable: true},
+	"AMEVTYPER111_EL0":  {encoding: 0x5efb, readable: true, writable: true},
+	"AMEVTYPER112_EL0":  {encoding: 0x5efc, readable: true, writable: true},
+	"AMEVTYPER113_EL0":  {encoding: 0x5efd, readable: true, writable: true},
+	"AMEVTYPER114_EL0":  {encoding: 0x5efe, readable: true, writable: true},
+	"AMEVTYPER115_EL0":  {encoding: 0x5eff, readable: true, writable: true},
+	"AMUSERENR_EL0":     {encoding: 0x5e93, readable: true, writable: true},
+	"APDAKeyHi_EL1":     {encoding: 0x4111, readable: true, writable: true},
+	"APDAKeyLo_EL1":     {encoding: 0x4110, readable: true, writable: true},
+	"APDBKeyHi_EL1":     {encoding: 0x4113, readable: true, writable: true},
+	"APDBKeyLo_EL1":     {encoding: 0x4112, readable: true, writable: true},
+	"APGAKeyHi_EL1":     {encoding: 0x4119, readable: true, writable: true},
+	"APGAKeyLo_EL1":     {encoding: 0x4118, readable: true, writable: true},
+	"APIAKeyHi_EL1":     {encoding: 0x4109, readable: true, writable: true},
+	"APIAKeyLo_EL1":     {encoding: 0x4108, readable: true, writable: true},
+	"APIBKeyHi_EL1":     {encoding: 0x410b, readable: true, writable: true},
+	"APIBKeyLo_EL1":     {encoding: 0x410a, readable: true, writable: true},
+	"CCSIDR2_EL1":       {encoding: 0x4802, readable: true, writable: false},
+	"CCSIDR_EL1":        {encoding: 0x4800, readable: true, writable: false},
+	"CLIDR_EL1":         {encoding: 0x4801, readable: true, writable: false},
+	"CNTFRQ_EL0":        {encoding: 0x5f00, readable: true, writable: true},
+	"CNTKCTL_EL1":       {encoding: 0x4708, readable: true, writable: true},
+	"CNTP_CTL_EL0":      {encoding: 0x5f11, readable: true, writable: true},
+	"CNTP_CVAL_EL0":     {encoding: 0x5f12, readable: true, writable: true},
+	"CNTP_TVAL_EL0":     {encoding: 0x5f10, readable: true, writable: true},
+	"CNTPCT_EL0":        {encoding: 0x5f01, readable: true, writable: false},
+	"CNTPS_CTL_EL1":     {encoding: 0x7f11, readable: true, writable: true},
+	"CNTPS_CVAL_EL1":    {encoding: 0x7f12, readable: true, writable: true},
+	"CNTPS_TVAL_EL1":    {encoding: 0x7f10, readable: true, writable: true},
+	"CNTV_CTL_EL0":      {encoding: 0x5f19, readable: true, writable: true},
+	"CNTV_CVAL_EL0":     {encoding: 0x5f1a, readable: true, writable: true},
+	"CNTV_TVAL_EL0":     {encoding: 0x5f18, readable: true, writable: true},
+	"CNTVCT_EL0":        {encoding: 0x5f02, readable: true, writable: false},
+	"CONTEXTIDR_EL1":    {encoding: 0x4681, readable: true, writable: true},
+	"CPACR_EL1":         {encoding: 0x4082, readable: true, writable: true},
+	"CSSELR_EL1":        {encoding: 0x5000, readable: true, writable: true},
+	"CTR_EL0":           {encoding: 0x5801, readable: true, writable: false},
+	"CurrentEL":         {encoding: 0x4212, readable: true, writable: false},
+	"DAIF":              {encoding: 0x5a11, readable: true, writable: true},
+	"DBGAUTHSTATUS_EL1": {encoding: 0x3f6, readable: true, writable: false},
+	"DBGBCR0_EL1":       {encoding: 0x5, readable: true, writable: true},
+	"DBGBCR1_EL1":       {encoding: 0xd, readable: true, writable: true},
+	"DBGBCR2_EL1":       {encoding: 0x15, readable: true, writable: true},
+	"DBGBCR3_EL1":       {encoding: 0x1d, readable: true, writable: true},
+	"DBGBCR4_EL1":       {encoding: 0x25, readable: true, writable: true},
+	"DBGBCR5_EL1":       {encoding: 0x2d, readable: true, writable: true},
+	"DBGBCR6_EL1":       {encoding: 0x35, readable: true, writable: true},
+	"DBGBCR7_EL1":       {encoding: 0x3d, readable: true, writable: true},
+	"DBGBCR8_EL1":       {encoding: 0x45, readable: true, writable: true},
+	"DBGBCR9_EL1":       {encoding: 0x4d, readable: true, writable: true},
+	"DBGBCR10_EL1":      {encoding: 0x55, readable: true, writable: true},
+	"DBGBCR11_EL1":      {encoding: 0x5d, readable: true, writable: true},
+	"DBGBCR12_EL1":      {encoding: 0x65, readable: true, writable: true},
+	"DBGBCR13_EL1":      {encoding: 0x6d, readable: true, writable: true},
+	"DBGBCR14_EL1":      {encoding: 0x75, readable: true, writable: true},
+	"DBGBCR15_EL1":      {encoding: 0x7d, readable: true, writable: true},
+	"DBGBVR0_EL1":       {encoding: 0x4, readable: true, writable: true},
+	"DBGBVR1_EL1":       {encoding: 0xc, readable: true, writable: true},
+	"DBGBVR2_EL1":       {encoding: 0x14, readable: true, writable: true},
+	"DBGBVR3_EL1":       {encoding: 0x1c, readable: true, writable: true},
+	"DBGBVR4_EL1":       {encoding: 0x24, readable: true, writable: true},
+	"DBGBVR5_EL1":       {encoding: 0x2c, readable: true, writable: true},
+	"DBGBVR6_EL1":       {encoding: 0x34, readable: true, writable: true},
+	"DBGBVR7_EL1":       {encoding: 0x3c, readable: true, writable: true},
+	"DBGBVR8_EL1":       {encoding: 0x44, readable: true, writable: true},
+	"DBGBVR9_EL1":       {encoding: 0x4c, readable: true, writable: true},
+	"DBGBVR10_EL1":      {encoding: 0x54, readable: true, writable: true},
+	"DBGBVR11_EL1":      {encoding: 0x5c, readable: true, writable: true},
+	"DBGBVR12_EL1":      {encoding: 0x64, readable: true, writable: true},
+	"DBGBVR13_EL1":      {encoding: 0x6c, readable: true, writable: true},
+	"DBGBVR14_EL1":      {encoding: 0x74, readable: true, writable: true},
+	"DBGBVR15_EL1":      {encoding: 0x7c, readable: true, writable: true},
+	"DBGCLAIMCLR_EL1":   {encoding: 0x3ce, readable: true, writable: true},
+	"DBGCLAIMSET_EL1":   {encoding: 0x3c6, readable: true, writable: true},
+	"DBGDTR_EL0":        {encoding: 0x1820, readable: true, writable: true},
+	"DBGDTRRX_EL0":      {encoding: 0x1828, readable: true, writable: false},
+	"DBGDTRTX_EL0":      {encoding: 0x1828, readable: false, writable: true},
+	"DBGPRCR_EL1":       {encoding: 0xa4, readable: true, writable: true},
+	"DBGWCR0_EL1":       {encoding: 0x7, readable: true, writable: true},
+	"DBGWCR1_EL1":       {encoding: 0xf, readable: true, writable: true},
+	"DBGWCR2_EL1":       {encoding: 0x17, readable: true, writable: true},
+	"DBGWCR3_EL1":       {encoding: 0x1f, readable: true, writable: true},
+	"DBGWCR4_EL1":       {encoding: 0x27, readable: true, writable: true},
+	"DBGWCR5_EL1":       {encoding: 0x2f, readable: true, writable: true},
+	"DBGWCR6_EL1":       {encoding: 0x37, readable: true, writable: true},
+	"DBGWCR7_EL1":       {encoding: 0x3f, readable: true, writable: true},
+	"DBGWCR8_EL1":       {encoding: 0x47, readable: true, writable: true},
+	"DBGWCR9_EL1":       {encoding: 0x4f, readable: true, writable: true},
+	"DBGWCR10_EL1":      {encoding: 0x57, readable: true, writable: true},
+	"DBGWCR11_EL1":      {encoding: 0x5f, readable: true, writable: true},
+	"DBGWCR12_EL1":      {encoding: 0x67, readable: true, writable: true},
+	"DBGWCR13_EL1":      {encoding: 0x6f, readable: true, writable: true},
+	"DBGWCR14_EL1":      {encoding: 0x77, readable: true, writable: true},
+	"DBGWCR15_EL1":      {encoding: 0x7f, readable: true, writable: true},
+	"DBGWVR0_EL1":       {encoding: 0x6, readable: true, writable: true},
+	"DBGWVR1_EL1":       {encoding: 0xe, readable: true, writable: true},
+	"DBGWVR2_EL1":       {encoding: 0x16, readable: true, writable: true},
+	"DBGWVR3_EL1":       {encoding: 0x1e, readable: true, writable: true},
+	"DBGWVR4_EL1":       {encoding: 0x26, readable: true, writable: true},
+	"DBGWVR5_EL1":       {encoding: 0x2e, readable: true, writable: true},
+	"DBGWVR6_EL1":       {encoding: 0x36, readable: true, writable: true},
+	"DBGWVR7_EL1":       {encoding: 0x3e, readable: true, writable: true},
+	"DBGWVR8_EL1":       {encoding: 0x46, readable: true, writable: true},
+	"DBGWVR9_EL1":       {encoding: 0x4e, readable: true, writable: true},
+	"DBGWVR10_EL1":      {encoding: 0x56, readable: true, writable: true},
+	"DBGWVR11_EL1":      {encoding: 0x5e, readable: true, writable: true},
+	"DBGWVR12_EL1":      {encoding: 0x66, readable: true, writable: true},
+	"DBGWVR13_EL1":      {encoding: 0x6e, readable: true, writable: true},
+	"DBGWVR14_EL1":      {encoding: 0x76, readable: true, writable: true},
+	"DBGWVR15_EL1":      {encoding: 0x7e, readable: true, writable: true},
+	"DCZID_EL0":         {encoding: 0x5807, readable: true, writable: false},
+	"DISR_EL1":          {encoding: 0x4609, readable: true, writable: true},
+	"DIT":               {encoding: 0x5a15, readable: true, writable: true},
+	"DLR_EL0":           {encoding: 0x5a29, readable: true, writable: true},
+	"DSPSR_EL0":         {encoding: 0x5a28, readable: true, writable: true},
+	"ELR_EL1":           {encoding: 0x4201, readable: true, writable: true},
+	"ERRIDR_EL1":        {encoding: 0x4298, readable: true, writable: false},
+	"ERRSELR_EL1":       {encoding: 0x4299, readable: true, writable: true},
+	"ERXADDR_EL1":       {encoding: 0x42a3, readable: true, writable: true},
+	"ERXCTLR_EL1":       {encoding: 0x42a1, readable: true, writable: true},
+	"ERXFR_EL1":         {encoding: 0x42a0, readable: true, writable: false},
+	"ERXMISC0_EL1":      {encoding: 0x42a8, readable: true, writable: true},
+	"ERXMISC1_EL1":      {encoding: 0x42a9, readable: true, writable: true},
+	"ERXMISC2_EL1":      {encoding: 0x42aa, readable: true, writable: true},
+	"ERXMISC3_EL1":      {encoding: 0x42ab, readable: true, writable: true},
+	"ERXPFGCDN_EL1":     {encoding: 0x42a6, readable: true, writable: true},
+	"ERXPFGCTL_EL1":     {encoding: 0x42a5, readable: true, writable: true},
+	"ERXPFGF_EL1":       {encoding: 0x42a4, readable: true, writable: false},
+	"ERXSTATUS_EL1":     {encoding: 0x42a2, readable: true, writable: true},
+	"ESR_EL1":           {encoding: 0x4290, readable: true, writable: true},
+	"FAR_EL1":           {encoding: 0x4300, readable: true, writable: true},
+	"FPCR":              {encoding: 0x5a20, readable: true, writable: true},
+	"FPSR":              {encoding: 0x5a21, readable: true, writable: true},
+	"GCR_EL1":           {encoding: 0x4086, readable: true, writable: true},
+	"GMID_EL1":          {encoding: 0x18a0, readable: true, writable: false},
+	"ICC_AP0R0_EL1":     {encoding: 0x4644, readable: true, writable: true},
+	"ICC_AP0R1_EL1":     {encoding: 0x4645, readable: true, writable: true},
+	"ICC_AP0R2_EL1":     {encoding: 0x4646, readable: true, writable: true},
+	"ICC_AP0R3_EL1":     {encoding: 0x4647, readable: true, writable: true},
+	"ICC_AP1R0_EL1":     {encoding: 0x4648, readable: true, writable: true},
+	"ICC_AP1R1_EL1":     {encoding: 0x4649, readable: true, writable: true},
+	"ICC_AP1R2_EL1":     {encoding: 0x464a, readable: true, writable: true},
+	"ICC_AP1R3_EL1":     {encoding: 0x464b, readable: true, writable: true},
+	"ICC_ASGI1R_EL1":    {encoding: 0x465e, readable: false, writable: true},
+	"ICC_BPR0_EL1":      {encoding: 0x4643, readable: true, writable: true},
+	"ICC_BPR1_EL1":      {encoding: 0x4663, readable: true, writable: true},
+	"ICC_CTLR_EL1":      {encoding: 0x4664, readable: true, writable: true},
+	"ICC_DIR_EL1":       {encoding: 0x4659, readable: false, writable: true},
+	"ICC_EOIR0_EL1":     {encoding: 0x4641, readable: false, writable: true},
+	"ICC_EOIR1_EL1":     {encoding: 0x4661, readable: false, writable: true},
+	"ICC_HPPIR0_EL1":    {encoding: 0x4642, readable: true, writable: false},
+	"ICC_HPPIR1_EL1":    {encoding: 0x4662, readable: true, writable: false},
+	"ICC_IAR0_EL1":      {encoding: 0x4640, readable: true, writable: false},
+	"ICC_IAR1_EL1":      {encoding: 0x4660, readable: true, writable: false},
+	"ICC_IGRPEN0_EL1":   {encoding: 0x4666, readable: true, writable: true},
+	"ICC_IGRPEN1_EL1":   {encoding: 0x4667, readable: true, writable: true},
+	"ICC_PMR_EL1":       {encoding: 0x4230, readable: true, writable: true},
+	"ICC_RPR_EL1":       {encoding: 0x465b, readable: true, writable: false},
+	"ICC_SGI0R_EL1":     {encoding: 0x465f, readable: false, writable: true},
+	"ICC_SGI1R_EL1":     {encoding: 0x465d, readable: false, writable: true},
+	"ICC_SRE_EL1":       {encoding: 0x4665, readable: true, writable: true},
+	"ICV_AP0R0_EL1":     {encoding: 0x4644, readable: true, writable: true},
+	"ICV_AP0R1_EL1":     {encoding: 0x4645, readable: true, writable: true},
+	"ICV_AP0R2_EL1":     {encoding: 0x4646, readable: true, writable: true},
+	"ICV_AP0R3_EL1":     {encoding: 0x4647, readable: true, writable: true},
+	"ICV_AP1R0_EL1":     {encoding: 0x4648, readable: true, writable: true},
+	"ICV_AP1R1_EL1":     {encoding: 0x4649, readable: true, writable: true},
+	"ICV_AP1R2_EL1":     {encoding: 0x464a, readable: true, writable: true},
+	"ICV_AP1R3_EL1":     {encoding: 0x464b, readable: true, writable: true},
+	"ICV_BPR0_EL1":      {encoding: 0x4643, readable: true, writable: true},
+	"ICV_BPR1_EL1":      {encoding: 0x4663, readable: true, writable: true},
+	"ICV_CTLR_EL1":      {encoding: 0x4664, readable: true, writable: true},
+	"ICV_DIR_EL1":       {encoding: 0x4659, readable: false, writable: true},
+	"ICV_EOIR0_EL1":     {encoding: 0x4641, readable: false, writable: true},
+	"ICV_EOIR1_EL1":     {encoding: 0x4661, readable: false, writable: true},
+	"ICV_HPPIR0_EL1":    {encoding: 0x4642, readable: true, writable: false},
+	"ICV_HPPIR1_EL1":    {encoding: 0x4662, readable: true, writable: false},
+	"ICV_IAR0_EL1":      {encoding: 0x4640, readable: true, writable: false},
+	"ICV_IAR1_EL1":      {encoding: 0x4660, readable: true, writable: false},
+	"ICV_IGRPEN0_EL1":   {encoding: 0x4666, readable: true, writable: true},
+	"ICV_IGRPEN1_EL1":   {encoding: 0x4667, readable: true, writable: true},
+	"ICV_PMR_EL1":       {encoding: 0x4230, readable: true, writable: true},
+	"ICV_RPR_EL1":       {encoding: 0x465b, readable: true, writable: false},
+	"ID_AA64AFR0_EL1":   {encoding: 0x402c, readable: true, writable: false},
+	"ID_AA64AFR1_EL1":   {encoding: 0x402d, readable: true, writable: false},
+	"ID_AA64DFR0_EL1":   {encoding: 0x4028, readable: true, writable: false},
+	"ID_AA64DFR1_EL1":   {encoding: 0x4029, readable: true, writable: false},
+	"ID_AA64ISAR0_EL1":  {encoding: 0x4030, readable: true, writable: false},
+	"ID_AA64ISAR1_EL1":  {encoding: 0x4031, readable: true, writable: false},
+	"ID_AA64MMFR0_EL1":  {encoding: 0x4038, readable: true, writable: false},
+	"ID_AA64MMFR1_EL1":  {encoding: 0x4039, readable: true, writable: false},
+	"ID_AA64MMFR2_EL1":  {encoding: 0x403a, readable: true, writable: false},
+	"ID_AA64PFR0_EL1":   {encoding: 0x4020, readable: true, writable: false},
+	"ID_AA64PFR1_EL1":   {encoding: 0x4021, readable: true, writable: false},
+	"ID_AA64ZFR0_EL1":   {encoding: 0x4024, readable: true, writable: false},
+	"ID_AFR0_EL1":       {encoding: 0x400b, readable: true, writable: false},
+	"ID_DFR0_EL1":       {encoding: 0x400a, readable: true, writable: false},
+	"ID_ISAR0_EL1":      {encoding: 0x4010, readable: true, writable: false},
+	"ID_ISAR1_EL1":      {encoding: 0x4011, readable: true, writable: false},
+	"ID_ISAR2_EL1":      {encoding: 0x4012, readable: true, writable: false},
+	"ID_ISAR3_EL1":      {encoding: 0x4013, readable: true, writable: false},
+	"ID_ISAR4_EL1":      {encoding: 0x4014, readable: true, writable: false},
+	"ID_ISAR5_EL1":      {encoding: 0x4015, readable: true, writable: false},
+	"ID_ISAR6_EL1":      {encoding: 0x4017, readable: true, writable: false},
+	"ID_MMFR0_EL1":      {encoding: 0x400c, readable: true, writable: false},
+	"ID_MMFR1_EL1":      {encoding: 0x400d, readable: true, writable: false},
+	"ID_MMFR2_EL1":      {encoding: 0x400e, readable: true, writable: false},
+	"ID_MMFR3_EL1":      {encoding: 0x400f, readable: true, writable: false},
+	"ID_MMFR4_EL1":      {encoding: 0x4016, readable: true, writable: false},
+	"ID_PFR0_EL1":       {encoding: 0x4008, readable: true, writable: false},
+	"ID_PFR1_EL1":       {encoding: 0x4009, readable: true, writable: false},
+	"ID_PFR2_EL1":       {encoding: 0x401c, readable: true, writable: false},
+	"ISR_EL1":           {encoding: 0x4608, readable: true, writable: false},
+	"LORC_EL1":          {encoding: 0x4523, readable: true, writable: true},
+	"LOREA_EL1":         {encoding: 0x4521, readable: true, writable: true},
+	"LORID_EL1":         {encoding: 0x4527, readable: true, writable: false},
+	"LORN_EL1":          {encoding: 0x4522, readable: true, writable: true},
+	"LORSA_EL1":         {encoding: 0x4520, readable: true, writable: true},
+	"MAIR_EL1":          {encoding: 0x4510, readable: true, writable: true},
+	"MDCCINT_EL1":       {encoding: 0x10, readable: true, writable: true},
+	"MDCCSR_EL0":        {encoding: 0x1808, readable: true, writable: false},
+	"MDRAR_EL1":         {encoding: 0x80, readable: true, writable: false},
+	"MDSCR_EL1":         {encoding: 0x12, readable: true, writable: true},
+	"MIDR_EL1":          {encoding: 0x4000, readable: true, writable: false},
+	"MPAM0_EL1":         {encoding: 0x4529, readable: true, writable: true},
+	"MPAM1_EL1":         {encoding: 0x4528, readable: true, writable: true},
+	"MPAMIDR_EL1":       {encoding: 0x4524, readable: true, writable: false},
+	"MPIDR_EL1":         {encoding: 0x4005, readable: true, writable: false},
+	"MVFR0_EL1":         {encoding: 0x4018, readable: true, writable: false},
+	"MVFR1_EL1":         {encoding: 0x4019, readable: true, writable: false},
+	"MVFR2_EL1":         {encoding: 0x401a, readable: true, writable: false},
+	"NZCV":              {encoding: 0x5a10, readable: true, writable: true},
+	"OSDLR_EL1":         {encoding: 0x9c, readable: true, writable: true},
+	"OSDTRRX_EL1":       {encoding: 0x2, readable: true, writable: true},
+	"OSDTRTX_EL1":       {encoding: 0x1a, readable: true, writable: true},
+	"OSECCR_EL1":        {encoding: 0x32, readable: true, writable: true},
+	"OSLAR_EL1":         {encoding: 0x84, readable: false, writable: true},
+	"OSLSR_EL1":         {encoding: 0x8c, readable: true, writable: false},
+	"PAN":               {encoding: 0x4213, readable: true, writable: true},
+	"PAR_EL1":           {encoding: 0x43a0, readable: true, writable: true},
+	"PMBIDR_EL1":        {encoding: 0x44d7, readable: true, writable: false},
+	"PMBLIMITR_EL1":     {encoding: 0x44d0, readable: true, writable: true},
+	"PMBPTR_EL1":        {encoding: 0x44d1, readable: true, writable: true},
+	"PMBSR_EL1":         {encoding: 0x44d3, readable: true, writable: true},
+	"PMCCFILTR_EL0":     {encoding: 0x5f7f, readable: true, writable: true},
+	"PMCCNTR_EL0":       {encoding: 0x5ce8, readable: true, writable: true},
+	"PMCEID0_EL0":       {encoding: 0x5ce6, readable: true, writable: false},
+	"PMCEID1_EL0":       {encoding: 0x5ce7, readable: true, writable: false},
+	"PMCNTENCLR_EL0":    {encoding: 0x5ce2, readable: true, writable: true},
+	"PMCNTENSET_EL0":    {encoding: 0x5ce1, readable: true, writable: true},
+	"PMCR_EL0":          {encoding: 0x5ce0, readable: true, writable: true},
+	"PMEVCNTR0_EL0":     {encoding: 0x5f40, readable: true, writable: true},
+	"PMEVCNTR1_EL0":     {encoding: 0x5f41, readable: true, writable: true},
+	"PMEVCNTR2_EL0":     {encoding: 0x5f42, readable: true, writable: true},
+	"PMEVCNTR3_EL0":     {encoding: 0x5f43, readable: true, writable: true},
+	"PMEVCNTR4_EL0":     {encoding: 0x5f44, readable: true, writable: true},
+	"PMEVCNTR5_EL0":     {encoding: 0x5f45, readable: true, writable: true},
+	"PMEVCNTR6_EL0":     {encoding: 0x5f46, readable: true, writable: true},
+	"PMEVCNTR7_EL0":     {encoding: 0x5f47, readable: true, writable: true},
+	"PMEVCNTR8_EL0":     {encoding: 0x5f48, readable: true, writable: true},
+	"PMEVCNTR9_EL0":     {encoding: 0x5f49, readable: true, writable: true},
+	"PMEVCNTR10_EL0":    {encoding: 0x5f4a, readable: true, writable: true},
+	"PMEVCNTR11_EL0":    {encoding: 0x5f4b, readable: true, writable: true},
+	"PMEVCNTR12_EL0":    {encoding: 0x5f4c, readable: true, writable: true},
+	"PMEVCNTR13_EL0":    {encoding: 0x5f4d, readable: true, writable: true},
+	"PMEVCNTR14_EL0":    {encoding: 0x5f4e, readable: true, writable: true},
+	"PMEVCNTR15_EL0":    {encoding: 0x5f4f, readable: true, writable: true},
+	"PMEVCNTR16_EL0":    {encoding: 0x5f50, readable: true, writable: true},
+	"PMEVCNTR17_EL0":    {encoding: 0x5f51, readable: true, writable: true},
+	"PMEVCNTR18_EL0":    {encoding: 0x5f52, readable: true, writable: true},
+	"PMEVCNTR19_EL0":    {encoding: 0x5f53, readable: true, writable: true},
+	"PMEVCNTR20_EL0":    {encoding: 0x5f54, readable: true, writable: true},
+	"PMEVCNTR21_EL0":    {encoding: 0x5f55, readable: true, writable: true},
+	"PMEVCNTR22_EL0":    {encoding: 0x5f56, readable: true, writable: true},
+	"PMEVCNTR23_EL0":    {encoding: 0x5f57, readable: true, writable: true},
+	"PMEVCNTR24_EL0":    {encoding: 0x5f58, readable: true, writable: true},
+	"PMEVCNTR25_EL0":    {encoding: 0x5f59, readable: true, writable: true},
+	"PMEVCNTR26_EL0":    {encoding: 0x5f5a, readable: true, writable: true},
+	"PMEVCNTR27_EL0":    {encoding: 0x5f5b, readable: true, writable: true},
+	"PMEVCNTR28_EL0":    {encoding: 0x5f5c, readable: true, writable: true},
+	"PMEVCNTR29_EL0":    {encoding: 0x5f5d, readable: true, writable: true},
+	"PMEVCNTR30_EL0":    {encoding: 0x5f5e, readable: true, writable: true},
+	"PMEVTYPER0_EL0":    {encoding: 0x5f60, readable: true, writable: true},
+	"PMEVTYPER1_EL0":    {encoding: 0x5f61, readable: true, writable: true},
+	"PMEVTYPER2_EL0":    {encoding: 0x5f62, readable: true, writable: true},
+	"PMEVTYPER3_EL0":    {encoding: 0x5f63, readable: true, writable: true},
+	"PMEVTYPER4_EL0":    {encoding: 0x5f64, readable: true, writable: true},
+	"PMEVTYPER5_EL0":    {encoding: 0x5f65, readable: true, writable: true},
+	"PMEVTYPER6_EL0":    {encoding: 0x5f66, readable: true, writable: true},
+	"PMEVTYPER7_EL0":    {encoding: 0x5f67, readable: true, writable: true},
+	"PMEVTYPER8_EL0":    {encoding: 0x5f68, readable: true, writable: true},
+	"PMEVTYPER9_EL0":    {encoding: 0x5f69, readable: true, writable: true},
+	"PMEVTYPER10_EL0":   {encoding: 0x5f6a, readable: true, writable: true},
+	"PMEVTYPER11_EL0":   {encoding: 0x5f6b, readable: true, writable: true},
+	"PMEVTYPER12_EL0":   {encoding: 0x5f6c, readable: true, writable: true},
+	"PMEVTYPER13_EL0":   {encoding: 0x5f6d, readable: true, writable: true},
+	"PMEVTYPER14_EL0":   {encoding: 0x5f6e, readable: true, writable: true},
+	"PMEVTYPER15_EL0":   {encoding: 0x5f6f, readable: true, writable: true},
+	"PMEVTYPER16_EL0":   {encoding: 0x5f70, readable: true, writable: true},
+	"PMEVTYPER17_EL0":   {encoding: 0x5f71, readable: true, writable: true},
+	"PMEVTYPER18_EL0":   {encoding: 0x5f72, readable: true, writable: true},
+	"PMEVTYPER19_EL0":   {encoding: 0x5f73, readable: true, writable: true},
+	"PMEVTYPER20_EL0":   {encoding: 0x5f74, readable: true, writable: true},
+	"PMEVTYPER21_EL0":   {encoding: 0x5f75, readable: true, writable: true},
+	"PMEVTYPER22_EL0":   {encoding: 0x5f76, readable: true, writable: true},
+	"PMEVTYPER23_EL0":   {encoding: 0x5f77, readable: true, writable: true},
+	"PMEVTYPER24_EL0":   {encoding: 0x5f78, readable: true, writable: true},
+	"PMEVTYPER25_EL0":   {encoding: 0x5f79, readable: true, writable: true},
+	"PMEVTYPER26_EL0":   {encoding: 0x5f7a, readable: true, writable: true},
+	"PMEVTYPER27_EL0":   {encoding: 0x5f7b, readable: true, writable: true},
+	"PMEVTYPER28_EL0":   {encoding: 0x5f7c, readable: true, writable: true},
+	"PMEVTYPER29_EL0":   {encoding: 0x5f7d, readable: true, writable: true},
+	"PMEVTYPER30_EL0":   {encoding: 0x5f7e, readable: true, writable: true},
+	"PMINTENCLR_EL1":    {encoding: 0x44f2, readable: true, writable: true},
+	"PMINTENSET_EL1":    {encoding: 0x44f1, readable: true, writable: true},
+	"PMMIR_EL1":         {encoding: 0x44f6, readable: true, writable: false},
+	"PMOVSCLR_EL0":      {encoding: 0x5ce3, readable: true, writable: true},
+	"PMOVSSET_EL0":      {encoding: 0x5cf3, readable: true, writable: true},
+	"PMSCR_EL1":         {encoding: 0x44c8, readable: true, writable: true},
+	"PMSELR_EL0":        {encoding: 0x5ce5, readable: true, writable: true},
+	"PMSEVFR_EL1":       {encoding: 0x44cd, readable: true, writable: true},
+	"PMSFCR_EL1":        {encoding: 0x44cc, readable: true, writable: true},
+	"PMSICR_EL1":        {encoding: 0x44ca, readable: true, writable: true},
+	"PMSIDR_EL1":        {encoding: 0x44cf, readable: true, writable: false},
+	"PMSIRR_EL1":        {encoding: 0x44cb, readable: true, writable: true},
+	"PMSLATFR_EL1":      {encoding: 0x44ce, readable: true, writable: true},
+	"PMSWINC_EL0":       {encoding: 0x5ce4, readable: false, writable: true},
+	"PMUSERENR_EL0":     {encoding: 0x5cf0, readable: true, writable: true},
+	"PMXEVCNTR_EL0":     {encoding: 0x5cea, readable: true, writable: true},
+	"PMXEVTYPER_EL0":    {encoding: 0x5ce9, readable: true, writable: true},
+	"REVIDR_EL1":        {encoding: 0x4006, readable: true, writable: false},
+	"RGSR_EL1":          {encoding: 0x4085, readable: true, writable: true},
+	"RMR_EL1":           {encoding: 0x4602, readable: true, writable: true},
+	"RNDR":              {encoding: 0x5920, readable: true, writable: false},
+	"RNDRRS":            {encoding: 0x5921, readable: true, writable: false},
+	"RVBAR_EL1":         {encoding: 0x4601, readable: true, writable: false},
+	"SCTLR_EL1":         {encoding: 0x4080, readable: true, writable: true},
+	"SCXTNUM_EL0":       {encoding: 0x5e87, readable: true, writable: true},
+	"SCXTNUM_EL1":       {encoding: 0x4687, readable: true, writable: true},
+	"SP_EL0":            {encoding: 0x4208, readable: true, writable: true},
+	"SP_EL1":            {encoding: 0x6208, readable: true, writable: true},
+	"SPSel":             {encoding: 0x4210, readable: true, writable: true},
+	"SPSR_abt":          {encoding: 0x6219, readable: true, writable: true},
+	"SPSR_EL1":          {encoding: 0x4200, readable: true, writable: true},
+	"SPSR_fiq":          {encoding: 0x621b, readable: true, writable: true},
+	"SPSR_irq":          {encoding: 0x6218, readable: true, writable: true},
+	"SPSR_und":          {encoding: 0x621a, readable: true, writable: true},
+	"SSBS":              {encoding: 0x5a16, readable: true, writable: true},
+	"TCO":               {encoding: 0x5a17, readable: true, writable: true},
+	"TCR_EL1":           {encoding: 0x4102, readable: true, writable: true},
+	"TFSR_EL1":          {encoding: 0x42b0, readable: true, writable: true},
+	"TFSRE0_EL1":        {encoding: 0x42b1, readable: true, writable: true},
+	"TPIDR_EL0":         {encoding: 0x5e82, readable: true, writable: true},
+	"TPIDR_EL1":         {encoding: 0x4684, readable: true, writable: true},
+	"TPIDRRO_EL0":       {encoding: 0x5e83, readable: true, writable: true},
+	"TRFCR_EL1":         {encoding: 0x4091, readable: true, writable: true},
+	"TTBR0_EL1":         {encoding: 0x4100, readable: true, writable: true},
+	"TTBR1_EL1":         {encoding: 0x4101, readable: true, writable: true},
+	"UAO":               {encoding: 0x4214, readable: true, writable: true},
+	"VBAR_EL1":          {encoding: 0x4600, readable: true, writable: true},
+	"ZCR_EL1":           {encoding: 0x4090, readable: true, writable: true},
+}
diff --git a/arm64_text_frame_test.go b/arm64_text_frame_test.go
new file mode 100644
index 000000000..45f9f28e0
--- /dev/null
+++ b/arm64_text_frame_test.go
@@ -0,0 +1,363 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestARM64TextFrameAllocation(t *testing.T) {
+	for _, test := range []struct {
+		name             string
+		frame, low, high int64
+		body             string
+	}{
+		{"zero", 0, 0, 0, ""},
+		{"no-frame", -8, 0, 0, ""},
+		{"small", 16, 0, 16, ""},
+		{"snappy-table", 32904, 0, 32904, "ADD $128,RSP,R17\nMOVD R0,(R17)\n"},
+		{"negative-sp", 32904, -512, 32904, "SUB $512,RSP\nMOVD R0,(RSP)\nADD $512,RSP\n"},
+		{"positive-sp", 32904, 0, 32904 + 512, "ADD $512,RSP\nMOVD R0,(RSP)\nSUB $512,RSP\n"},
+		{"explicit-beyond-frame", 16, 0, 4160, "MOVD R0,4096(RSP)\n"},
+		{"runtime-call2MiB", 1 << 21, 0, 1 << 21, ""},
+		{"runtime-call1GiB", 1 << 30, 0, 1 << 30, ""},
+		{"large-frame-sp-movement", 1 << 21, -512, 1<<21 + 512, "SUB $512,RSP\nMOVD R0,(RSP)\nADD $1024,RSP\nMOVD R0,(RSP)\nSUB $512,RSP\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT stack_bounds(SB),$%d-0\nMOVD RSP,R9\n%sRET\n", test.frame, test.body)
+			requireARM64GoAssemblerResult(t, source, true)
+			ir := arm64StackTestIR(t, source)
+			match := regexp.MustCompile(`getelementptr inbounds \[(\d+) x i8\], ptr %local_stack, i32 0, i64 (\d+)`).FindStringSubmatch(ir)
+			if len(match) != 3 {
+				t.Fatal("missing local stack allocation")
+			}
+			size, _ := strconv.ParseInt(match[1], 10, 64)
+			bias, _ := strconv.ParseInt(match[2], 10, 64)
+			if bias+test.low < 0 || bias+test.high > size {
+				t.Fatalf("allocation [%d,%d) does not contain declared frame/accesses [%d,%d)", -bias, size-bias, test.low, test.high)
+			}
+		})
+	}
+}
+
+func TestARM64TextFrameRejectsInvalidSize(t *testing.T) {
+	for _, frame := range []int64{-16, -1, 1<<31 + 8, 1<<63 - 1} {
+		t.Run(strconv.FormatInt(frame, 10), func(t *testing.T) {
+			file, err := Parse(ArchARM64, fmt.Sprintf("TEXT frame(SB),$%d-0\nMOVD RSP,R9\nRET\n", frame))
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"frame": {Name: "frame", Ret: Void},
+			}})
+			if err == nil {
+				t.Fatalf("invalid or oversized TEXT frame %d accepted", frame)
+			}
+		})
+	}
+}
+
+func TestARM64LargeTextFrameLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, frame := range []int64{1 << 21, 1 << 28, 1 << 30} {
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		} {
+			t.Run(fmt.Sprintf("%d/%s", frame, triple), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT large_frame(SB),$%d-0\nADD $128,RSP,R3\nMOVD R3,R0\nRET\n", frame)
+				requireARM64GoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"large_frame": {Name: "large_frame", Ret: Ptr, Attrs: "uwtable"}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, `asm sideeffect "", "=r,0"`) || !strings.Contains(ir, "%local_stack = alloca i8, i64 %") {
+					t.Fatal("large declared frame must retain its full size through a dynamic alloca")
+				}
+				compileLLVMToObject(t, llc, triple, "large-frame.ll", "large-frame.o", ir)
+				compileARM64LargeFrameOptimized(t, llc, triple, ir)
+			})
+		}
+	}
+}
+
+func compileARM64LargeFrameOptimized(t *testing.T, llc, triple, ir string) {
+	t.Helper()
+	opt := findLLVM22Tool("opt")
+	readobj := findLLVM22Tool("llvm-readobj")
+	if opt == "" || readobj == "" {
+		t.Fatal("LLVM 22 opt and llvm-readobj are required")
+	}
+	dir := t.TempDir()
+	input, optimized := filepath.Join(dir, "input.ll"), filepath.Join(dir, "optimized.ll")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if out, err := exec.Command(opt, "-passes=default<O2>", "-S", input, "-o", optimized).CombinedOutput(); err != nil {
+		t.Fatalf("optimize large frame: %v\n%s", err, out)
+	}
+	data, err := os.ReadFile(optimized)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "alloca i8, i64 %") || !strings.Contains(string(data), "uwtable") {
+		t.Fatal("optimization lost the dynamic allocation or caller's unwind attribute")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		object := filepath.Join(dir, strings.TrimPrefix(level, "-")+".o")
+		if out, err := exec.Command(llc, level, "-mtriple="+triple, "-filetype=obj", optimized, "-o", object).CombinedOutput(); err != nil {
+			t.Fatalf("compile optimized large frame %s: %v\n%s", level, err, out)
+		}
+		if strings.Contains(triple, "windows") {
+			out, err := exec.Command(readobj, "--unwind", object).CombinedOutput()
+			if err != nil {
+				t.Fatalf("inspect Windows unwind: %v\n%s", err, out)
+			}
+			if !strings.Contains(string(out), "RuntimeFunction {") || !strings.Contains(string(out), "mov x29, sp") {
+				t.Fatalf("dynamic frame lost its Windows unwind frame chain:\n%s", out)
+			}
+		}
+	}
+}
+
+const arm64TextFrameSource = `TEXT frame_table(SB),$32904-16
+MOVD value+0(FP),R0
+MOVD R0,64(RSP)
+ADD $128,RSP,R17
+ADD $32768,R17,R6
+MOVD R0,(R6)
+MOVD $32768,R4
+fill:
+MOVD R0,(R17)
+ADD $8,R17
+SUB $8,R4
+CBNZ R4,fill
+ADD $128,RSP,R17
+MOVD $32768,R4
+BL frame_observe(SB)
+MOVD $0,R5
+check:
+MOVD (R17),R1
+EOR R0,R1
+ORR R1,R5
+ADD $8,R17
+SUB $8,R4
+CBNZ R4,check
+MOVD 64(RSP),R1
+EOR R0,R1
+ORR R1,R5
+MOVD (R6),R1
+EOR R0,R1
+ORR R1,R5
+MOVD R5,ret+8(FP)
+RET
+`
+
+// The original observer call escapes a pointer to the private Go frame. Its
+// manual register signature provides no bounds or non-escape memory contract.
+// Keep that full source as a Context regression rather than pretending that the
+// C observer body is a contract available to the translator.
+func TestARM64TextFrameObserverNeedsBoundedMemoryContract(t *testing.T) {
+	for _, large := range []bool{false, true} {
+		source := arm64TextFrameSource
+		if large {
+			source = strings.ReplaceAll(source, "32904", "2097288")
+			source = strings.ReplaceAll(source, "32768", "2097152")
+		}
+		requireARM64GoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{
+			"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+			"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+		} {
+			t.Run(fmt.Sprintf("large=%v/%s", large, triple), func(t *testing.T) {
+				_, err := Translate(file, Options{
+					Goarch: "arm64", TargetTriple: triple,
+					Sigs: arm64TextFrameSigs(),
+				})
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "caller LR") {
+					t.Fatalf("unbounded private-frame observer must retain Context: %v", err)
+				}
+			})
+		}
+	}
+}
+
+// This separate positive fixture has no escaping call. Both its Go and LLVM
+// runtime oracles execute this exact source, not different versions of it.
+func arm64TextFrameNoEscapeSource() string {
+	return strings.ReplaceAll(arm64TextFrameSource, "BL frame_observe(SB)\n", "")
+}
+
+func arm64TextFrameNoEscapeRuntime(t *testing.T, triple string) (string, string) {
+	return arm64TextFrameRuntimeForSource(t, triple, arm64TextFrameNoEscapeSource())
+}
+
+func arm64TextFrameSigs() map[string]FuncSig {
+	return map[string]FuncSig{"frame_table": {
+		Name: "frame_table", Args: []LLVMType{I64}, Ret: I64,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		},
+	}, "frame_observe": {
+		Name: "frame_observe", Args: []LLVMType{Ptr, I64, I64}, Ret: Void,
+		ArgRegs: []Reg{"R17", "R4", "R0"},
+	}}
+}
+
+func arm64TextFrameRuntimeForSource(t *testing.T, triple, source string) (string, string) {
+	t.Helper()
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+		Sigs: arm64TextFrameSigs(),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `
+#include <stdint.h>
+#include <stdio.h>
+extern uint64_t frame_table(uint64_t);
+int main(void) {
+  volatile uint64_t canary[2] = {UINT64_C(0x123456789abcdef0), UINT64_C(0xfedcba9876543210)};
+  uint64_t value = UINT64_C(0x89abcdef01234567);
+  for (unsigned i = 0; i < 128; i++) {
+    uint64_t got = frame_table(value);
+    if (got != 0) {
+      fprintf(stderr, "frame table mismatch: %llx\n", (unsigned long long)got);
+      return 1;
+    }
+    if (canary[0] != UINT64_C(0x123456789abcdef0) || canary[1] != UINT64_C(0xfedcba9876543210)) return 2;
+    value = value * UINT64_C(6364136223846793005) + 1;
+  }
+  return 0;
+}
+`
+	return ir, main
+}
+
+func TestARM64LargeTextFrameNoEscapeRuntime(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM 22 llc and clang are required")
+	}
+	source := strings.ReplaceAll(arm64TextFrameNoEscapeSource(), "32904", "2097288")
+	source = strings.ReplaceAll(source, "32768", "2097152")
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64TextFrameRuntimeForSource(t, triple, source)
+			if !strings.Contains(ir, "%local_stack = alloca i8, i64 %") {
+				t.Fatal("2 MiB runtime oracle did not exercise the large-frame allocation path")
+			}
+			compileLLVMToObject(t, llc, triple, "large-runtime.ll", "large-runtime.o", ir)
+			native := runtime.GOARCH == "arm64" && ((runtime.GOOS == "darwin" && strings.Contains(triple, "apple")) ||
+				(runtime.GOOS == "linux" && strings.Contains(triple, "linux")) ||
+				(runtime.GOOS == "freebsd" && strings.Contains(triple, "freebsd")))
+			if native {
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "large-runtime", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func TestARM64TextFrameNoEscapeLLVM(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-freebsd", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, main := arm64TextFrameNoEscapeRuntime(t, triple)
+			compileLLVMToObject(t, llc, triple, "frame.ll", "frame.o", ir)
+			native := runtime.GOARCH == "arm64" && ((runtime.GOOS == "darwin" && strings.Contains(triple, "apple")) ||
+				(runtime.GOOS == "linux" && strings.Contains(triple, "linux")) ||
+				(runtime.GOOS == "freebsd" && strings.Contains(triple, "freebsd")))
+			if native {
+				clang := findLLVM22Tool("clang")
+				if clang == "" {
+					t.Fatal("LLVM 22 clang not found")
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "frame", triple, ir, main, nil)
+			}
+		})
+	}
+}
+
+func TestARM64TextFrameNoEscapeNativeGo(t *testing.T) {
+	cross := runtime.GOOS == "linux" && runtime.GOARCH == "amd64" && os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+	if runtime.GOARCH != "arm64" && !cross {
+		t.Skip("native Go oracle runs on arm64 or required Linux/QEMU")
+	}
+	const main = `package main
+func frame_table(value uint64) uint64
+func main() {
+  value := uint64(0x89abcdef01234567)
+  for i := 0; i < 128; i++ {
+    if got := frame_table(value); got != 0 { panic("declared frame table mismatch") }
+    value = value * 6364136223846793005 + 1
+  }
+}
+`
+	for _, large := range []bool{false, true} {
+		t.Run(fmt.Sprintf("large=%v", large), func(t *testing.T) {
+			source := arm64TextFrameNoEscapeSource()
+			if large {
+				source = strings.ReplaceAll(source, "32904", "2097288")
+				source = strings.ReplaceAll(source, "32768", "2097152")
+			}
+			dir := t.TempDir()
+			for name, data := range map[string]string{
+				"go.mod":        "module frameoracle\n\ngo 1.20\n",
+				"main.go":       main,
+				"frame_arm64.s": strings.Replace(source, "TEXT frame_table", "TEXT ·frame_table", 1),
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			args := []string{"run", "."}
+			if cross {
+				if _, err := exec.LookPath("qemu-aarch64"); err != nil {
+					t.Fatal(err)
+				}
+				args = []string{"run", "-exec=qemu-aarch64", "."}
+			}
+			cmd := exec.Command("go", args...)
+			cmd.Dir = dir
+			cmd.Env = append(os.Environ(), "GOWORK=off", "GOARCH=arm64", "CGO_ENABLED=0")
+			if out, err := cmd.CombinedOutput(); err != nil {
+				t.Fatalf("Go TEXT frame oracle: %v\n%s", err, out)
+			}
+		})
+	}
+}
diff --git a/arm64_translate.go b/arm64_translate.go
index cfa69899b..9533d2a91 100644
--- a/arm64_translate.go
+++ b/arm64_translate.go
@@ -9,12 +9,868 @@ type arm64EmitBr func(target string)
 type arm64EmitCondBr func(cond string, target string, fall string) error
 
 func emitARM64Prelude(b *strings.Builder) {
+	b.WriteString("declare ptr @llvm.returnaddress(i32 immarg)\n")
+	b.WriteString("declare void @llvm.memcpy.p0.p0.i64(ptr, ptr, i64, i1 immarg)\n")
+	b.WriteString("declare void @llvm.trap()\n")
 	b.WriteString("declare i64 @syscall(i64, i64, i64, i64, i64, i64, i64)\n")
+	b.WriteString("declare { i64, i1 } @llvm.aarch64.rndr()\n")
+	b.WriteString("declare { i64, i1 } @llvm.aarch64.rndrrs()\n")
 	b.WriteString("declare i32 @cliteErrno()\n")
 	b.WriteString("declare i64 @llvm.bitreverse.i64(i64)\n")
+	b.WriteString("declare i32 @llvm.bitreverse.i32(i32)\n")
+	b.WriteString("declare <8 x i8> @llvm.bitreverse.v8i8(<8 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.bitreverse.v16i8(<16 x i8>)\n")
 	b.WriteString("declare i64 @llvm.ctlz.i64(i64, i1)\n")
+	b.WriteString("declare i32 @llvm.ctlz.i32(i32, i1)\n")
 	b.WriteString("declare i64 @llvm.bswap.i64(i64)\n")
 	b.WriteString("declare i32 @llvm.bswap.i32(i32)\n")
+	b.WriteString("declare <8 x i8> @llvm.ctpop.v8i8(<8 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.ctpop.v16i8(<16 x i8>)\n")
+	for _, intrinsic := range []string{"smmla", "ummla", "usmmla"} {
+		fmt.Fprintf(b, "declare <vscale x 4 x i32> @llvm.aarch64.sve.%s.nxv4i32(<vscale x 4 x i32>, <vscale x 16 x i8>, <vscale x 16 x i8>)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.bfmmla(<vscale x 4 x float>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fmmla.nxv4f32(<vscale x 4 x float>, <vscale x 4 x float>, <vscale x 4 x float>)\n")
+	b.WriteString("declare <vscale x 2 x double> @llvm.aarch64.sve.fmmla.nxv2f64(<vscale x 2 x double>, <vscale x 2 x double>, <vscale x 2 x double>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fmmla.nxv4f32.nxv8f16(<vscale x 4 x float>, <vscale x 8 x half>, <vscale x 8 x half>)\n")
+	for _, vector := range []struct{ lanes, bits int }{{8, 8}, {16, 8}, {4, 16}, {8, 16}, {2, 32}, {4, 32}} {
+		fmt.Fprintf(b, "declare <%d x i%d> @llvm.ctlz.v%di%d(<%d x i%d>, i1)\n", vector.lanes, vector.bits, vector.lanes, vector.bits, vector.lanes, vector.bits)
+	}
+	b.WriteString("declare <8 x i16> @llvm.aarch64.neon.pmull.v8i16(<8 x i8>, <8 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.aarch64.neon.pmull64(i64, i64)\n")
+	b.WriteString("declare <2 x float> @llvm.aarch64.neon.bfdot.v2f32.v4bf16(<2 x float>, <4 x bfloat>, <4 x bfloat>)\n")
+	b.WriteString("declare <4 x float> @llvm.aarch64.neon.bfdot.v4f32.v8bf16(<4 x float>, <8 x bfloat>, <8 x bfloat>)\n")
+	b.WriteString("declare <4 x float> @llvm.aarch64.neon.bfmmla(<4 x float>, <8 x bfloat>, <8 x bfloat>)\n")
+	for _, shape := range []struct {
+		lanes    int
+		typeName string
+		suffix   string
+	}{{4, "half", "f16"}, {8, "half", "f16"}, {2, "float", "f32"}, {4, "float", "f32"}, {2, "double", "f64"}} {
+		vectorType := fmt.Sprintf("<%d x %s>", shape.lanes, shape.typeName)
+		for _, intrinsic := range []string{"fabd", "fmulx"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.v%d%s(%s, %s)\n",
+				vectorType, intrinsic, shape.lanes, shape.suffix, vectorType, vectorType)
+		}
+	}
+	for _, scalar := range []struct{ typeName, suffix string }{{"half", "f16"}, {"float", "f32"}, {"double", "f64"}} {
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sisd.fabd.%s(%s, %s)\n",
+			scalar.typeName, scalar.suffix, scalar.typeName, scalar.typeName)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.fmulx.%s(%s, %s)\n",
+			scalar.typeName, scalar.suffix, scalar.typeName, scalar.typeName)
+	}
+	for _, shape := range []struct {
+		lanes    int
+		typeName string
+		suffix   string
+	}{
+		{1, "half", "f16"},
+		{1, "float", "f32"},
+		{1, "double", "f64"},
+		{4, "half", "v4f16"},
+		{8, "half", "v8f16"},
+		{2, "float", "v2f32"},
+		{4, "float", "v4f32"},
+		{2, "double", "v2f64"},
+	} {
+		typeName := shape.typeName
+		if shape.lanes != 1 {
+			typeName = fmt.Sprintf("<%d x %s>", shape.lanes, shape.typeName)
+		}
+		for _, intrinsic := range []string{"frecpe", "frsqrte"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.%s(%s)\n",
+				typeName, intrinsic, shape.suffix, typeName)
+		}
+		if shape.lanes == 1 {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.frecpx.%s(%s)\n",
+				typeName, shape.suffix, typeName)
+		}
+		for _, intrinsic := range []string{"frecps", "frsqrts"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.%s(%s, %s)\n",
+				typeName, intrinsic, shape.suffix, typeName, typeName)
+		}
+	}
+	for _, vector := range []struct{ lanes, bits int }{{8, 8}, {16, 8}, {4, 16}, {8, 16}, {2, 32}, {4, 32}, {2, 64}} {
+		vectorType := fmt.Sprintf("<%d x i%d>", vector.lanes, vector.bits)
+		for _, intrinsic := range []string{"sshl", "srshl", "ushl", "urshl", "sqshl", "uqshl"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.v%di%d(%s, %s)\n", vectorType, intrinsic, vector.lanes, vector.bits, vectorType, vectorType)
+		}
+	}
+	for _, intrinsic := range []string{"sshl", "srshl", "ushl", "urshl"} {
+		fmt.Fprintf(b, "declare i64 @llvm.aarch64.neon.%s.i64(i64, i64)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"suqadd", "usqadd"} {
+		for _, bits := range []int{8, 16, 32, 64} {
+			for _, vectorBits := range []int{64, 128} {
+				if bits > vectorBits {
+					continue
+				}
+				lanes := vectorBits / bits
+				typeName := fmt.Sprintf("<%d x i%d>", lanes, bits)
+				fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.v%di%d(%s, %s)\n",
+					typeName, intrinsic, lanes, bits, typeName, typeName)
+			}
+		}
+	}
+	for _, intrinsic := range []string{"saddlv", "uaddlv"} {
+		for _, shape := range []struct{ lanes, bits int }{
+			{8, 8}, {16, 8}, {4, 16}, {8, 16}, {4, 32},
+		} {
+			resultBits := shape.bits * 2
+			if resultBits < 32 {
+				resultBits = 32
+			}
+			fmt.Fprintf(b, "declare i%d @llvm.aarch64.neon.%s.i%d.v%di%d(<%d x i%d>)\n",
+				resultBits, intrinsic, resultBits, shape.lanes, shape.bits, shape.lanes, shape.bits)
+		}
+	}
+	b.WriteString("declare <16 x i8> @llvm.aarch64.crypto.aese(<16 x i8>, <16 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.aarch64.crypto.aesd(<16 x i8>, <16 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.aarch64.crypto.aesmc(<16 x i8>)\n")
+	b.WriteString("declare <16 x i8> @llvm.aarch64.crypto.aesimc(<16 x i8>)\n")
+	for _, spec := range arm64RawSM4Specs {
+		fmt.Fprintf(b, "declare <4 x i32> @llvm.aarch64.crypto.%s(<4 x i32>, <4 x i32>)\n", spec.intrinsic)
+	}
+	for _, spec := range arm64RawRDMASpecs[:2] {
+		for _, shape := range []struct{ lanes, bits int }{{4, 16}, {8, 16}, {2, 32}, {4, 32}} {
+			vectorType := fmt.Sprintf("<%d x i%d>", shape.lanes, shape.bits)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.neon.%s.v%di%d(%s, %s, %s)\n",
+				vectorType, spec.intrinsic, shape.lanes, shape.bits, vectorType, vectorType, vectorType)
+		}
+	}
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha1c(<4 x i32>, i32, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha1p(<4 x i32>, i32, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha1m(<4 x i32>, i32, <4 x i32>)\n")
+	b.WriteString("declare i32 @llvm.aarch64.crypto.sha1h(i32)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha1su0(<4 x i32>, <4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha1su1(<4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha256h(<4 x i32>, <4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha256h2(<4 x i32>, <4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha256su0(<4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <4 x i32> @llvm.aarch64.crypto.sha256su1(<4 x i32>, <4 x i32>, <4 x i32>)\n")
+	b.WriteString("declare <2 x i64> @llvm.aarch64.crypto.sha512h(<2 x i64>, <2 x i64>, <2 x i64>)\n")
+	b.WriteString("declare <2 x i64> @llvm.aarch64.crypto.sha512h2(<2 x i64>, <2 x i64>, <2 x i64>)\n")
+	b.WriteString("declare <2 x i64> @llvm.aarch64.crypto.sha512su0(<2 x i64>, <2 x i64>)\n")
+	b.WriteString("declare <2 x i64> @llvm.aarch64.crypto.sha512su1(<2 x i64>, <2 x i64>, <2 x i64>)\n")
+	b.WriteString("declare i64 @llvm.vscale.i64()\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.masked.load.nxv2i64.p0(ptr, <vscale x 2 x i1>, <vscale x 2 x i64>)\n")
+	b.WriteString("declare void @llvm.masked.store.nxv2i64.p0(<vscale x 2 x i64>, ptr, <vscale x 2 x i1>)\n")
+	for _, bits := range []int{8, 16, 32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		for _, intrinsic := range []string{"eorbt", "eortb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType, vectorType)
+		}
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld1ro.nxv%di%d(%s, ptr)\n", vectorType, lanes, bits, predicateType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld1rq.nxv%di%d(%s, ptr)\n", vectorType, lanes, bits, predicateType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldnt1.nxv%di%d(%s, ptr)\n", vectorType, lanes, bits, predicateType)
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.stnt1.nxv%di%d(%s, %s, ptr)\n", lanes, bits, vectorType, predicateType)
+		fmt.Fprintf(b, "declare { %s, %s } @llvm.aarch64.sve.ldnt1.pn.x2.nxv%di%d(target(\"aarch64.svcount\"), ptr)\n", vectorType, vectorType, lanes, bits)
+		fmt.Fprintf(b, "declare { %s, %s, %s, %s } @llvm.aarch64.sve.ldnt1.pn.x4.nxv%di%d(target(\"aarch64.svcount\"), ptr)\n", vectorType, vectorType, vectorType, vectorType, lanes, bits)
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.stnt1.pn.x2.nxv%di%d(%s, %s, target(\"aarch64.svcount\"), ptr)\n", lanes, bits, vectorType, vectorType)
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.stnt1.pn.x4.nxv%di%d(%s, %s, %s, %s, target(\"aarch64.svcount\"), ptr)\n", lanes, bits, vectorType, vectorType, vectorType, vectorType)
+	}
+	for _, destinationBits := range []int{32, 64} {
+		lanes := 128 / destinationBits
+		baseType := fmt.Sprintf("<vscale x %d x i%d>", lanes, destinationBits)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		for _, memoryBits := range []int{8, 16, 32, 64} {
+			if memoryBits > destinationBits {
+				continue
+			}
+			memoryType := fmt.Sprintf("<vscale x %d x i%d>", lanes, memoryBits)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldnt1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s, %s, i64)\n", memoryType, lanes, memoryBits, lanes, destinationBits, predicateType, baseType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.stnt1.scatter.scalar.offset.nxv%di%d.nxv%di%d(%s, %s, %s, i64)\n", lanes, memoryBits, lanes, destinationBits, memoryType, predicateType, baseType)
+		}
+	}
+	for _, destinationBits := range []int{8, 16, 32, 64} {
+		lanes := 128 / destinationBits
+		indexType := fmt.Sprintf("<vscale x %d x i%d>", lanes, destinationBits)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		for _, memoryBits := range []int{8, 16, 32, 64} {
+			if memoryBits > destinationBits {
+				continue
+			}
+			memoryType := fmt.Sprintf("<vscale x %d x i%d>", lanes, memoryBits)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldff1.nxv%di%d(%s, ptr)\n", memoryType, lanes, memoryBits, predicateType)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldnf1.nxv%di%d(%s, ptr)\n", memoryType, lanes, memoryBits, predicateType)
+			if destinationBits != 32 && destinationBits != 64 {
+				continue
+			}
+			suffixes := []string{"", ".index"}
+			if destinationBits == 32 {
+				suffixes = append(suffixes, ".uxtw", ".uxtw.index", ".sxtw", ".sxtw.index")
+			}
+			for _, suffix := range suffixes {
+				fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldff1.gather%s.nxv%di%d(%s, ptr, %s)\n", memoryType, suffix, lanes, memoryBits, predicateType, indexType)
+			}
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ldff1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s, %s, i64)\n",
+				memoryType, lanes, memoryBits, lanes, destinationBits, predicateType, indexType)
+		}
+	}
+	for _, destinationBits := range []int{8, 16, 32, 64} {
+		lanes := 128 / destinationBits
+		indexType := fmt.Sprintf("<vscale x %d x i%d>", lanes, destinationBits)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		for _, memoryBits := range []int{8, 16, 32, 64} {
+			if memoryBits > destinationBits {
+				continue
+			}
+			memoryType := fmt.Sprintf("<vscale x %d x i%d>", lanes, memoryBits)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld1.nxv%di%d(%s, ptr)\n", memoryType, lanes, memoryBits, predicateType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st1.nxv%di%d(%s, %s, ptr)\n", lanes, memoryBits, memoryType, predicateType)
+			if destinationBits != 32 && destinationBits != 64 {
+				continue
+			}
+			suffixes := []string{"", ".index"}
+			if destinationBits == 32 {
+				suffixes = append(suffixes, ".uxtw", ".uxtw.index", ".sxtw", ".sxtw.index")
+			}
+			for _, suffix := range suffixes {
+				fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld1.gather%s.nxv%di%d(%s, ptr, %s)\n", memoryType, suffix, lanes, memoryBits, predicateType, indexType)
+				fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st1.scatter%s.nxv%di%d(%s, %s, ptr, %s)\n", suffix, lanes, memoryBits, memoryType, predicateType, indexType)
+			}
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld1.gather.scalar.offset.nxv%di%d.nxv%di%d(%s, %s, i64)\n",
+				memoryType, lanes, memoryBits, lanes, destinationBits, predicateType, indexType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st1.scatter.scalar.offset.nxv%di%d.nxv%di%d(%s, %s, %s, i64)\n",
+				lanes, memoryBits, lanes, destinationBits, memoryType, predicateType, indexType)
+		}
+	}
+	for _, bits := range []int{8, 16, 32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		fmt.Fprintf(b, "declare { %s, %s } @llvm.aarch64.sve.ld1.pn.x2.nxv%di%d(target(\"aarch64.svcount\"), ptr)\n", vectorType, vectorType, lanes, bits)
+		fmt.Fprintf(b, "declare { %s, %s, %s, %s } @llvm.aarch64.sve.ld1.pn.x4.nxv%di%d(target(\"aarch64.svcount\"), ptr)\n", vectorType, vectorType, vectorType, vectorType, lanes, bits)
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st1.pn.x2.nxv%di%d(%s, %s, target(\"aarch64.svcount\"), ptr)\n", lanes, bits, vectorType, vectorType)
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st1.pn.x4.nxv%di%d(%s, %s, %s, %s, target(\"aarch64.svcount\"), ptr)\n", lanes, bits, vectorType, vectorType, vectorType, vectorType)
+	}
+	b.WriteString("declare <vscale x 1 x i1> @llvm.aarch64.sve.convert.from.svbool.nxv1i1(<vscale x 16 x i1>)\n")
+	b.WriteString("declare <vscale x 4 x i32> @llvm.aarch64.sve.ld1uwq.nxv4i32(<vscale x 1 x i1>, ptr)\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.ld1udq.nxv2i64(<vscale x 1 x i1>, ptr)\n")
+	b.WriteString("declare void @llvm.aarch64.sve.st1wq.nxv4i32(<vscale x 4 x i32>, <vscale x 1 x i1>, ptr)\n")
+	b.WriteString("declare void @llvm.aarch64.sve.st1dq.nxv2i64(<vscale x 2 x i64>, <vscale x 1 x i1>, ptr)\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.ld1q.gather.scalar.offset.nxv2i64.nxv2i64(<vscale x 1 x i1>, <vscale x 2 x i64>, i64)\n")
+	b.WriteString("declare void @llvm.aarch64.sve.st1q.scatter.scalar.offset.nxv2i64.nxv2i64(<vscale x 2 x i64>, <vscale x 1 x i1>, <vscale x 2 x i64>, i64)\n")
+	for _, count := range []int{2, 3, 4} {
+		for _, bits := range []int{8, 16, 32, 64} {
+			lanes := 128 / bits
+			vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+			predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+			aggregateType := arm64SVEAggregateType(vectorType, count)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld%d.sret.nxv%di%d(%s, ptr)\n", aggregateType, count, lanes, bits, predicateType)
+			values := make([]string, count)
+			for i := range values {
+				values[i] = vectorType
+			}
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st%d.nxv%di%d(%s, %s, ptr)\n", count, lanes, bits, strings.Join(values, ", "), predicateType)
+		}
+		vectorType := "<vscale x 2 x i64>"
+		predicateType := "<vscale x 2 x i1>"
+		aggregateType := arm64SVEAggregateType(vectorType, count)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ld%dq.sret.nxv2i64(%s, ptr)\n", aggregateType, count, predicateType)
+		values := make([]string, count)
+		for i := range values {
+			values[i] = vectorType
+		}
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.st%dq.nxv2i64(%s, %s, ptr)\n", count, strings.Join(values, ", "), predicateType)
+	}
+	for _, suffix := range []string{"b", "h", "w", "d"} {
+		fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.cnt%s(i32 immarg)\n", suffix)
+	}
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		fmt.Fprintf(b, "declare target(\"aarch64.svcount\") @llvm.aarch64.sve.ptrue.c%d()\n", elementBits)
+		fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.cntp.c%d(target(\"aarch64.svcount\"), i32 immarg)\n", elementBits)
+		lanes := 128 / elementBits
+		fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.cntp.nxv%di1(<vscale x %d x i1>, <vscale x %d x i1>)\n", lanes, lanes, lanes)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.pext.nxv%di1(target(\"aarch64.svcount\"), i32 immarg)\n", predicateType, lanes)
+		fmt.Fprintf(b, "declare { %s, %s } @llvm.aarch64.sve.pext.x2.nxv%di1(target(\"aarch64.svcount\"), i32 immarg)\n", predicateType, predicateType, lanes)
+		for _, condition := range []string{"whilege", "whilegt", "whilehi", "whilehs", "whilele", "whilelo", "whilels", "whilelt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di1.i64(i64, i64)\n", predicateType, condition, lanes)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di1.i32(i32, i32)\n", predicateType, condition, lanes)
+			fmt.Fprintf(b, "declare { %s, %s } @llvm.aarch64.sve.%s.x2.nxv%di1(i64, i64)\n", predicateType, predicateType, condition, lanes)
+			fmt.Fprintf(b, "declare target(\"aarch64.svcount\") @llvm.aarch64.sve.%s.c%d(i64, i64, i32 immarg)\n", condition, elementBits)
+		}
+		letter := strings.ToLower(map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[elementBits])
+		for _, condition := range []string{"whilerw", "whilewr"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s.nxv%di1.p0(ptr, ptr)\n", predicateType, condition, letter, lanes)
+		}
+		for _, intrinsic := range []string{"sqdecp", "sqincp", "uqdecp", "uqincp"} {
+			fmt.Fprintf(b, "declare i32 @llvm.aarch64.sve.%s.n32.nxv%di1(i32, %s)\n", intrinsic, lanes, predicateType)
+			fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.%s.n64.nxv%di1(i64, %s)\n", intrinsic, lanes, predicateType)
+		}
+		fmt.Fprintf(b, "declare void @llvm.aarch64.sve.prf.nxv%di1(%s, ptr, i32 immarg)\n", lanes, predicateType)
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, elementBits)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.index.nxv%di%d(i%d, i%d)\n", vectorType, lanes, elementBits, elementBits, elementBits)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.insr.nxv%di%d(%s, i%d)\n", vectorType, lanes, elementBits, vectorType, elementBits)
+		for _, intrinsic := range []string{"lasta", "lastb"} {
+			fmt.Fprintf(b, "declare i%d @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", elementBits, intrinsic, lanes, elementBits, predicateType, vectorType)
+		}
+		for _, intrinsic := range []string{"clasta", "clastb"} {
+			fmt.Fprintf(b, "declare i%d @llvm.aarch64.sve.%s.n.nxv%di%d(%s, i%d, %s)\n", elementBits, intrinsic, lanes, elementBits, predicateType, elementBits, vectorType)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", vectorType, intrinsic, lanes, elementBits, predicateType, vectorType, vectorType)
+		}
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.compact.nxv%di%d(%s, %s)\n", vectorType, lanes, elementBits, predicateType, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.expand.nxv%di%d(%s, %s)\n", vectorType, lanes, elementBits, predicateType, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.splice.nxv%di%d(%s, %s, %s)\n", vectorType, lanes, elementBits, predicateType, vectorType, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.pmov.to.pred.lane.zero.nxv%di%d(%s)\n", predicateType, lanes, elementBits, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.pmov.to.pred.lane.nxv%di%d(%s, i32 immarg)\n", predicateType, lanes, elementBits, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.pmov.to.vector.lane.zeroing.nxv%di%d(%s)\n", vectorType, lanes, elementBits, predicateType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.pmov.to.vector.lane.merging.nxv%di%d(%s, %s, i32 immarg)\n", vectorType, lanes, elementBits, vectorType, predicateType)
+	}
+	for _, destinationBits := range []int{16, 32, 64} {
+		destinationLanes := 128 / destinationBits
+		sourceBits := destinationBits / 2
+		sourceLanes := 128 / sourceBits
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		for _, intrinsic := range []string{"saddlb", "saddlbt", "saddlt", "ssublb", "ssublbt", "ssublt", "ssubltb", "uaddlb", "uaddlt", "usublb", "usublt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", destinationType, intrinsic, destinationLanes, destinationBits, sourceType, sourceType)
+		}
+		for _, intrinsic := range []string{"sshllb", "sshllt", "ushllb", "ushllt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, i32 immarg)\n", destinationType, intrinsic, destinationLanes, destinationBits, sourceType)
+		}
+		for _, intrinsic := range []string{"saddwb", "saddwt", "ssubwb", "ssubwt", "uaddwb", "uaddwt", "usubwb", "usubwt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", destinationType, intrinsic, destinationLanes, destinationBits, destinationType, sourceType)
+		}
+		for _, intrinsic := range []string{"sabdlb", "sabdlt", "uabdlb", "uabdlt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", destinationType, intrinsic, destinationLanes, destinationBits, sourceType, sourceType)
+		}
+		for _, intrinsic := range []string{"sabalb", "sabalt", "uabalb", "uabalt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", destinationType, intrinsic, destinationLanes, destinationBits, destinationType, sourceType, sourceType)
+		}
+		for _, intrinsic := range []string{"sadalp", "uadalp"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, %s, %s)\n", destinationType, intrinsic, destinationLanes, destinationBits, destinationLanes, destinationType, sourceType)
+		}
+	}
+	for _, sourceBits := range []int{16, 32, 64} {
+		sourceLanes := 128 / sourceBits
+		destinationBits := sourceBits / 2
+		destinationLanes := 128 / destinationBits
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		for _, intrinsic := range []string{"addhnb", "raddhnb", "rsubhnb", "subhnb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", destinationType, intrinsic, sourceLanes, sourceBits, sourceType, sourceType)
+		}
+		for _, intrinsic := range []string{"addhnt", "raddhnt", "rsubhnt", "subhnt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", destinationType, intrinsic, sourceLanes, sourceBits, destinationType, sourceType, sourceType)
+		}
+	}
+	for _, intrinsic := range []string{"bcax", "bsl", "bsl1n", "bsl2n", "eor3", "nbsl"} {
+		fmt.Fprintf(b, "declare <vscale x 2 x i64> @llvm.aarch64.sve.%s.nxv2i64(<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>)\n", intrinsic)
+	}
+	for _, bits := range []int{8, 16, 32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		for _, intrinsic := range []string{"bdep.x", "bext.x", "bgrp.x"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType)
+		}
+	}
+	for _, bits := range []int{32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		for _, intrinsic := range []string{"adclb", "adclt", "sbclb", "sbclt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType, vectorType)
+		}
+	}
+	for _, bits := range []int{8, 16, 32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		for _, intrinsic := range []string{"sclamp", "uclamp"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType, vectorType)
+		}
+	}
+	for _, bits := range []int{16, 32, 64} {
+		_, vectorType, lanes, _ := arm64SVEFloatType(bits)
+		suffix := map[int]string{16: "f16", 32: "f32", 64: "f64"}[bits]
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fclamp.nxv%d%s(%s, %s, %s)\n", vectorType, lanes, suffix, vectorType, vectorType, vectorType)
+	}
+	b.WriteString("declare <vscale x 8 x bfloat> @llvm.aarch64.sve.fclamp.nxv8bf16(<vscale x 8 x bfloat>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.bfdot(<vscale x 4 x float>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.bfdot.lane.v2(<vscale x 4 x float>, <vscale x 8 x bfloat>, <vscale x 8 x bfloat>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 8 x half> @llvm.aarch64.sve.fp8.fdot.nxv8f16(<vscale x 8 x half>, <vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 8 x half> @llvm.aarch64.sve.fp8.fdot.lane.nxv8f16(<vscale x 8 x half>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fp8.fdot.nxv4f32(<vscale x 4 x float>, <vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fp8.fdot.lane.nxv4f32(<vscale x 4 x float>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fdot.x2.nxv4f32(<vscale x 4 x float>, <vscale x 8 x half>, <vscale x 8 x half>)\n")
+	b.WriteString("declare <vscale x 4 x float> @llvm.aarch64.sve.fdot.lane.x2.nxv4f32(<vscale x 4 x float>, <vscale x 8 x half>, <vscale x 8 x half>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 4 x i32> @llvm.aarch64.sve.cdot.nxv4i32(<vscale x 4 x i32>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 4 x i32> @llvm.aarch64.sve.cdot.lane.nxv4i32(<vscale x 4 x i32>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg, i32 immarg)\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.cdot.nxv2i64(<vscale x 2 x i64>, <vscale x 8 x i16>, <vscale x 8 x i16>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.cdot.lane.nxv2i64(<vscale x 2 x i64>, <vscale x 8 x i16>, <vscale x 8 x i16>, i32 immarg, i32 immarg)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.luti2.lane.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 8 x i16> @llvm.aarch64.sve.luti2.lane.nxv8i16(<vscale x 8 x i16>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.luti4.lane.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 8 x i16> @llvm.aarch64.sve.luti4.lane.nxv8i16(<vscale x 8 x i16>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 8 x i16> @llvm.aarch64.sve.luti4.lane.x2.nxv8i16(<vscale x 8 x i16>, <vscale x 8 x i16>, <vscale x 16 x i8>, i32 immarg)\n")
+	for _, intrinsic := range []string{"fmlalb", "fmlalt", "fmlslb", "fmlslt"} {
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.%s.nxv4f32(<vscale x 4 x float>, <vscale x 8 x half>, <vscale x 8 x half>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.%s.lane.nxv4f32(<vscale x 4 x float>, <vscale x 8 x half>, <vscale x 8 x half>, i32 immarg)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"fmlalb", "fmlalt"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x half> @llvm.aarch64.sve.fp8.%s.nxv8f16(<vscale x 8 x half>, <vscale x 16 x i8>, <vscale x 16 x i8>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 8 x half> @llvm.aarch64.sve.fp8.%s.lane.nxv8f16(<vscale x 8 x half>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"fmlallbb", "fmlallbt", "fmlalltb", "fmlalltt"} {
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.fp8.%s.nxv4f32(<vscale x 4 x float>, <vscale x 16 x i8>, <vscale x 16 x i8>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 4 x float> @llvm.aarch64.sve.fp8.%s.lane.nxv4f32(<vscale x 4 x float>, <vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"sqcvtn", "sqcvtun", "uqcvtn"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x i16> @llvm.aarch64.sve.%s.x2.nxv4i32(<vscale x 4 x i32>, <vscale x 4 x i32>)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"sqrshrn", "sqrshrun", "uqrshrn"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x i16> @llvm.aarch64.sve.%s.x2.nxv4i32(<vscale x 4 x i32>, <vscale x 4 x i32>, i32 immarg)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 16 x i8> @llvm.vector.interleave2.nxv16i8(<vscale x 8 x i8>, <vscale x 8 x i8>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.aesimc(<vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.aesmc(<vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.aesd(<vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.aese(<vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.rax1(<vscale x 2 x i64>, <vscale x 2 x i64>)\n")
+	b.WriteString("declare <vscale x 4 x i32> @llvm.aarch64.sve.sm4e(<vscale x 4 x i32>, <vscale x 4 x i32>)\n")
+	b.WriteString("declare <vscale x 4 x i32> @llvm.aarch64.sve.sm4ekey(<vscale x 4 x i32>, <vscale x 4 x i32>)\n")
+	for _, count := range []int{2, 4} {
+		types := make([]string, count)
+		arguments := make([]string, count+2)
+		for i := 0; i < count; i++ {
+			types[i] = "<vscale x 16 x i8>"
+			arguments[i] = "<vscale x 16 x i8>"
+		}
+		arguments[count] = "<vscale x 16 x i8>"
+		arguments[count+1] = "i32 immarg"
+		aggregateType := "{ " + strings.Join(types, ", ") + " }"
+		for _, intrinsic := range []string{"aesd", "aesdimc", "aese", "aesemc"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.lane.x%d(%s)\n", aggregateType, intrinsic, count, strings.Join(arguments, ", "))
+		}
+	}
+	b.WriteString("declare <vscale x 2 x i64> @llvm.aarch64.sve.revd.nxv2i64(<vscale x 2 x i64>, <vscale x 2 x i1>, <vscale x 2 x i64>)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.pmul.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+	for _, bits := range []int{8, 32, 64} {
+		lanes := 128 / bits
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+		for _, intrinsic := range []string{"pmullb.pair", "pmullt.pair"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType)
+		}
+	}
+	b.WriteString("declare { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.pmull.pair.x2(<vscale x 2 x i64>, <vscale x 2 x i64>)\n")
+	b.WriteString("declare { <vscale x 2 x i64>, <vscale x 2 x i64> } @llvm.aarch64.sve.pmlal.pair.x2(<vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>, <vscale x 2 x i64>)\n")
+	for _, form := range []struct{ destinationBits, sourceBits int }{{16, 8}, {32, 16}, {32, 8}, {64, 16}} {
+		destinationLanes := 128 / form.destinationBits
+		sourceLanes := 128 / form.sourceBits
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, form.destinationBits)
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, form.sourceBits)
+		x2 := ""
+		if form.destinationBits == form.sourceBits*2 {
+			x2 = ".x2"
+		}
+		for _, intrinsic := range []string{"sdot", "udot"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s%s.nxv%di%d(%s, %s, %s)\n", destinationType, intrinsic, x2, destinationLanes, form.destinationBits, destinationType, sourceType, sourceType)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.lane%s.nxv%di%d(%s, %s, %s, i32 immarg)\n", destinationType, intrinsic, x2, destinationLanes, form.destinationBits, destinationType, sourceType, sourceType)
+		}
+	}
+	for _, intrinsic := range []string{"usdot", "usdot.lane", "sudot.lane"} {
+		fmt.Fprintf(b, "declare <vscale x 4 x i32> @llvm.aarch64.sve.%s.nxv4i32(<vscale x 4 x i32>, <vscale x 16 x i8>, <vscale x 16 x i8>", intrinsic)
+		if strings.Contains(intrinsic, ".lane") {
+			b.WriteString(", i32 immarg")
+		}
+		b.WriteString(")\n")
+	}
+	for _, sourceBits := range []int{8, 16, 32} {
+		destinationBits := sourceBits * 2
+		sourceLanes := 128 / sourceBits
+		destinationLanes := 128 / destinationBits
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		for _, intrinsic := range []string{"sunpkhi", "sunpklo", "uunpkhi", "uunpklo"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s)\n", destinationType, intrinsic, destinationLanes, destinationBits, sourceType)
+		}
+	}
+	for _, sourceBits := range []int{16, 32, 64} {
+		destinationBits := sourceBits / 2
+		sourceLanes := 128 / sourceBits
+		destinationLanes := 128 / destinationBits
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		for _, intrinsic := range []string{"sqxtnb", "sqxtunb", "uqxtnb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s)\n", destinationType, intrinsic, sourceLanes, sourceBits, sourceType)
+		}
+		for _, intrinsic := range []string{"sqxtnt", "sqxtunt", "uqxtnt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", destinationType, intrinsic, sourceLanes, sourceBits, destinationType, sourceType)
+		}
+	}
+	for _, sourceBits := range []int{16, 32, 64} {
+		destinationBits := sourceBits / 2
+		sourceLanes := 128 / sourceBits
+		destinationLanes := 128 / destinationBits
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		for _, intrinsic := range []string{"shrnb", "rshrnb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, i32 immarg)\n", destinationType, intrinsic, sourceLanes, sourceBits, sourceType)
+		}
+		for _, intrinsic := range []string{"shrnt", "rshrnt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, i32 immarg)\n", destinationType, intrinsic, sourceLanes, sourceBits, destinationType, sourceType)
+		}
+	}
+	for _, sourceBits := range []int{16, 32, 64} {
+		destinationBits := sourceBits / 2
+		sourceLanes := 128 / sourceBits
+		destinationLanes := 128 / destinationBits
+		sourceType := fmt.Sprintf("<vscale x %d x i%d>", sourceLanes, sourceBits)
+		destinationType := fmt.Sprintf("<vscale x %d x i%d>", destinationLanes, destinationBits)
+		for _, intrinsic := range []string{"sqshrnb", "sqrshrnb", "sqshrunb", "sqrshrunb", "uqshrnb", "uqrshrnb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, i32 immarg)\n", destinationType, intrinsic, sourceLanes, sourceBits, sourceType)
+		}
+		for _, intrinsic := range []string{"sqshrnt", "sqrshrnt", "sqshrunt", "sqrshrunt", "uqshrnt", "uqrshrnt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s, i32 immarg)\n", destinationType, intrinsic, sourceLanes, sourceBits, destinationType, sourceType)
+		}
+	}
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.ext.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	b.WriteString("declare <vscale x 16 x i8> @llvm.aarch64.sve.extq.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>, i32 immarg)\n")
+	emitARM64SVEConvertDeclarations(b)
+	emitARM64SVEFloatNarrowConversionDeclarations(b)
+	emitARM64SVEBFloatArithmeticDeclarations(b)
+	emitARM64SVEBFloatMLADeclarations(b)
+	for _, elementBits := range []int{16, 32, 64} {
+		_, vectorType, lanes, _ := arm64SVEFloatType(elementBits)
+		code := map[int]string{16: "f16", 32: "f32", 64: "f64"}[elementBits]
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fmul.lane.nxv%d%s(%s, %s, i32 immarg)\n", vectorType, lanes, code, vectorType, vectorType)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fmulx.nxv%d%s(%s, %s, %s)\n", vectorType, lanes, code, predicateType, vectorType, vectorType)
+		for _, intrinsic := range []string{"ftsmul", "ftssel"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.x.nxv%d%s(%s, <vscale x %d x i%d>)\n", vectorType, intrinsic, lanes, code, vectorType, lanes, elementBits)
+		}
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.ftmad.x.nxv%d%s(%s, %s, i32 immarg)\n", vectorType, lanes, code, vectorType, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fcmla.nxv%d%s(%s, %s, %s, %s, i32 immarg)\n", vectorType, lanes, code, predicateType, vectorType, vectorType, vectorType)
+		if elementBits != 64 {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fcmla.lane.nxv%d%s(%s, %s, %s, i32 immarg, i32 immarg)\n", vectorType, lanes, code, vectorType, vectorType, vectorType)
+		}
+		for _, intrinsic := range []string{"fmla", "fmls", "fmad", "fmsb", "fnmla", "fnmls", "fnmad", "fnmsb"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%d%s(%s, %s, %s, %s)\n", vectorType, intrinsic, lanes, code, predicateType, vectorType, vectorType, vectorType)
+		}
+		for _, intrinsic := range []string{"fmla", "fmls"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.lane.nxv%d%s(%s, %s, %s, i32 immarg)\n", vectorType, intrinsic, lanes, code, vectorType, vectorType, vectorType)
+		}
+	}
+	for _, vectorBits := range []int{32, 64} {
+		lanes := 128 / vectorBits
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, vectorBits)
+		for _, letter := range []string{"b", "h", "w", "d"} {
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.prf%s.gather.index.nxv%di%d(%s, ptr, %s, i32 immarg)\n", letter, lanes, vectorBits, predicateType, vectorType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.prf%s.gather.uxtw.index.nxv%di%d(%s, ptr, %s, i32 immarg)\n", letter, lanes, vectorBits, predicateType, vectorType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.prf%s.gather.sxtw.index.nxv%di%d(%s, ptr, %s, i32 immarg)\n", letter, lanes, vectorBits, predicateType, vectorType)
+			fmt.Fprintf(b, "declare void @llvm.aarch64.sve.prf%s.gather.scalar.offset.nxv%di%d(%s, %s, i64, i32 immarg)\n", letter, lanes, vectorBits, predicateType, vectorType)
+		}
+	}
+	for _, lanes := range []int{16, 8, 4, 2} {
+		for _, intrinsic := range []string{"any", "first", "last"} {
+			fmt.Fprintf(b, "declare i1 @llvm.aarch64.sve.ptest.%s.nxv%di1(<vscale x %d x i1>, <vscale x %d x i1>)\n", intrinsic, lanes, lanes, lanes)
+		}
+	}
+	b.WriteString("declare <vscale x 16 x i1> @llvm.aarch64.sve.rdffr()\n")
+	b.WriteString("declare <vscale x 16 x i1> @llvm.aarch64.sve.rdffr.z(<vscale x 16 x i1>)\n")
+	b.WriteString("declare void @llvm.aarch64.sve.setffr()\n")
+	b.WriteString("declare void @llvm.aarch64.sve.wrffr(<vscale x 16 x i1>)\n")
+	for _, intrinsic := range []string{"brka", "brkb"} {
+		fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.%s.nxv16i1(<vscale x 16 x i1>, <vscale x 16 x i1>, <vscale x 16 x i1>)\n", intrinsic)
+		fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.%s.z.nxv16i1(<vscale x 16 x i1>, <vscale x 16 x i1>)\n", intrinsic)
+	}
+	for _, intrinsic := range []string{"brkn.z", "brkpa.z", "brkpb.z"} {
+		fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.%s.nxv16i1(<vscale x 16 x i1>, <vscale x 16 x i1>, <vscale x 16 x i1>)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 16 x i1> @llvm.vector.reverse.nxv16i1(<vscale x 16 x i1>)\n")
+	for _, elementBits := range []int{16, 32, 64} {
+		fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.rev.b%d(<vscale x 16 x i1>)\n", elementBits)
+	}
+	for _, intrinsic := range []string{"trn1", "trn2", "uzp1", "uzp2", "zip1", "zip2"} {
+		fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.%s.nxv16i1(<vscale x 16 x i1>, <vscale x 16 x i1>)\n", intrinsic)
+		for _, elementBits := range []int{16, 32, 64} {
+			fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.%s.b%d(<vscale x 16 x i1>, <vscale x 16 x i1>)\n", intrinsic, elementBits)
+		}
+	}
+	for _, intrinsic := range []string{"punpkhi", "punpklo"} {
+		fmt.Fprintf(b, "declare <vscale x 8 x i1> @llvm.aarch64.sve.%s.nxv16i1(<vscale x 16 x i1>)\n", intrinsic)
+	}
+	b.WriteString("declare <vscale x 16 x i1> @llvm.aarch64.sve.pfirst.nxv16i1(<vscale x 16 x i1>, <vscale x 16 x i1>)\n")
+	for _, lanes := range []int{16, 8, 4, 2} {
+		fmt.Fprintf(b, "declare <vscale x %d x i1> @llvm.aarch64.sve.pnext.nxv%di1(<vscale x %d x i1>, <vscale x %d x i1>)\n", lanes, lanes, lanes, lanes)
+		for _, intrinsic := range []string{"firstp", "lastp"} {
+			fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.%s.nxv%di1(<vscale x %d x i1>, <vscale x %d x i1>)\n", intrinsic, lanes, lanes, lanes)
+		}
+	}
+	for _, lanes := range []int{16, 8, 4, 2} {
+		bits := 128 / lanes
+		fmt.Fprintf(b, "declare <vscale x %d x i1> @llvm.aarch64.sve.ptrue.nxv%di1(i32 immarg)\n", lanes, lanes)
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.dupq.lane.nxv%di%d(<vscale x %d x i%d>, i64)\n", lanes, bits, lanes, bits, lanes, bits)
+		for _, intrinsic := range []string{"asr", "lsl", "lsr"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"suqadd", "usqadd"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.addp.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, lanes, bits, lanes, bits)
+		if bits != 8 {
+			for _, intrinsic := range []string{"sqdecp", "sqincp", "uqdecp", "uqincp"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i1>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes)
+			}
+		}
+		for _, intrinsic := range []string{"asrd", "sqshlu", "srshr", "urshr"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits)
+		}
+		for _, intrinsic := range []string{"sli", "sri", "srsra", "ssra", "ursra", "usra"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits)
+		}
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.mul.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, lanes, bits, lanes, bits)
+		for _, intrinsic := range []string{"mad", "mla", "mls", "msb"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"smulh", "smulh.u", "umulh", "umulh.u"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"sqshl", "uqshl", "sqrshl", "uqrshl", "srshl", "urshl"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"sqdmulh", "sqrdmulh"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"saba", "uaba"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"sabd", "uabd"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"shadd", "shsub", "shsubr", "srhadd", "uhadd", "uhsub", "uhsubr", "urhadd"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		if bits >= 32 {
+			for _, intrinsic := range []string{"sdiv", "sdivr", "udiv", "udivr"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+			}
+		}
+		for _, intrinsic := range []string{"cmla", "sqrdcmlah"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.x.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"sqrdmlah", "sqrdmlsh"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"smax", "smin", "umax", "umin", "smaxp", "sminp", "umaxp", "uminp"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"cadd.x", "sqcadd.x"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits)
+		}
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.xar.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		if bits == 8 || bits == 16 {
+			for _, intrinsic := range []string{"match", "nmatch"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i1> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, intrinsic, lanes, bits, lanes, lanes, bits, lanes, bits)
+			}
+		}
+		if bits == 8 {
+			fmt.Fprintf(b, "declare <vscale x 16 x i8> @llvm.aarch64.sve.histseg.nxv16i8(<vscale x 16 x i8>, <vscale x 16 x i8>)\n")
+		}
+		if bits == 32 || bits == 64 {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.histcnt.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, lanes, bits, lanes, bits)
+		}
+		for _, intrinsic := range []string{"abs", "cls", "clz", "cnot", "cnt", "neg", "not", "rbit", "revb", "revh", "revw", "sqabs", "sqneg", "sxtb", "sxth", "sxtw", "uxtb", "uxth", "uxtw", "urecpe", "ursqrte"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i1>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, lanes, bits)
+		}
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.vector.reverse.nxv%di%d(<vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, bits)
+		for _, intrinsic := range []string{"andv", "eorv", "orv", "smaxv", "sminv", "umaxv", "uminv"} {
+			fmt.Fprintf(b, "declare i%d @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>)\n", bits, intrinsic, lanes, bits, lanes, lanes, bits)
+		}
+		for _, intrinsic := range []string{"saddv", "uaddv"} {
+			fmt.Fprintf(b, "declare i64 @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>)\n", intrinsic, lanes, bits, lanes, lanes, bits)
+		}
+		for _, intrinsic := range []string{"addqv", "andqv", "eorqv", "orqv", "smaxqv", "sminqv", "umaxqv", "uminqv"} {
+			fmt.Fprintf(b, "declare <%d x i%d> @llvm.aarch64.sve.%s.v%di%d.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, lanes, bits)
+		}
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.tbl.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.tbl2.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.tblq.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		for _, intrinsic := range []string{"tbx", "tbxq"} {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+		}
+		if bits != 8 {
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.mul.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+			for _, intrinsic := range []string{"mla", "mls"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+			}
+			for _, intrinsic := range []string{"sqdmulh", "sqrdmulh"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits)
+			}
+			if bits != 64 {
+				for _, intrinsic := range []string{"cmla", "sqrdcmlah"} {
+					fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.x.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+				}
+			}
+			for _, intrinsic := range []string{"sqrdmlah", "sqrdmlsh"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", lanes, bits, intrinsic, lanes, bits, lanes, bits, lanes, bits, lanes, bits)
+			}
+		}
+		if bits != 64 {
+			for _, intrinsic := range []string{"asr", "lsl", "lsr"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.wide.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x 2 x i64>)\n", lanes, bits, intrinsic, lanes, bits, lanes, lanes, bits)
+			}
+		}
+		if bits != 64 {
+			for _, intrinsic := range []string{"cmpeq", "cmpge", "cmpgt", "cmphi", "cmphs", "cmpne"} {
+				fmt.Fprintf(b, "declare <vscale x %d x i1> @llvm.aarch64.sve.%s.wide.nxv%di%d(<vscale x %d x i1>, <vscale x %d x i%d>, <vscale x 2 x i64>)\n", lanes, intrinsic, lanes, bits, lanes, lanes, bits)
+			}
+		}
+		if lanes != 16 {
+			fmt.Fprintf(b, "declare <vscale x 16 x i1> @llvm.aarch64.sve.convert.to.svbool.nxv%di1(<vscale x %d x i1>)\n", lanes, lanes)
+			fmt.Fprintf(b, "declare <vscale x %d x i1> @llvm.aarch64.sve.convert.from.svbool.nxv%di1(<vscale x 16 x i1>)\n", lanes, lanes)
+		}
+	}
+	for _, sourceBits := range []int{8, 16, 32} {
+		sourceLanes := 128 / sourceBits
+		destinationBits := sourceBits * 2
+		destinationLanes := 128 / destinationBits
+		for _, op := range arm64SVEMultiplyLongOps {
+			spec := arm64SVEMultiplyLongSpecs[op]
+			if spec.accumulate {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", destinationLanes, destinationBits, spec.intrinsic, destinationLanes, destinationBits, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+			} else {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", destinationLanes, destinationBits, spec.intrinsic, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+			}
+		}
+		for _, op := range arm64SVEMultiplyAccumulateLongOpsBySelector {
+			intrinsic := arm64SVEMultiplyAccumulateLongIntrinsics[op]
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>)\n", destinationLanes, destinationBits, intrinsic, destinationLanes, destinationBits, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+		}
+		if sourceBits != 8 {
+			for _, op := range arm64SVEMultiplyLongOps {
+				spec := arm64SVEMultiplyLongSpecs[op]
+				if spec.laneHBase == 0 {
+					continue
+				}
+				if spec.accumulate {
+					fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", destinationLanes, destinationBits, spec.intrinsic, destinationLanes, destinationBits, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+				} else {
+					fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", destinationLanes, destinationBits, spec.intrinsic, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+				}
+			}
+			for _, op := range arm64SVEMultiplyAccumulateLongOpsBySelector {
+				intrinsic := arm64SVEMultiplyAccumulateLongIntrinsics[op]
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.lane.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>, <vscale x %d x i%d>, i32 immarg)\n", destinationLanes, destinationBits, intrinsic, destinationLanes, destinationBits, destinationLanes, destinationBits, sourceLanes, sourceBits, sourceLanes, sourceBits)
+			}
+		}
+	}
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		lanes := 128 / elementBits
+		for _, op := range arm64SVEPermuteOpsByIndex {
+			intrinsic := arm64SVEPermuteIntrinsics[op]
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, elementBits, intrinsic, lanes, elementBits, lanes, elementBits, lanes, elementBits)
+		}
+		for _, op := range arm64SVEQPermuteOpsByIndex {
+			intrinsic := arm64SVEPermuteIntrinsics[op]
+			fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.%s.nxv%di%d(<vscale x %d x i%d>, <vscale x %d x i%d>)\n", lanes, elementBits, intrinsic, lanes, elementBits, lanes, elementBits, lanes, elementBits)
+		}
+	}
+	for _, elementBits := range []int{16, 32, 64} {
+		lanes := 128 / elementBits
+		scalarType := map[int]string{16: "half", 32: "float", 64: "double"}[elementBits]
+		vectorType := fmt.Sprintf("<vscale x %d x %s>", lanes, scalarType)
+		predicateType := fmt.Sprintf("<vscale x %d x i1>", lanes)
+		mangle := fmt.Sprintf("nxv%d%s", lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[elementBits])
+		for _, intrinsic := range []string{"fabd", "faddp", "famax", "famin", "fmax", "fmin", "fmaxnm", "fminnm", "fmaxp", "fminp", "fmaxnmp", "fminnmp"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s, %s, %s)\n", vectorType, intrinsic, mangle, predicateType, vectorType, vectorType)
+		}
+		for _, intrinsic := range []string{"fmaxv", "fminv", "fmaxnmv", "fminnmv"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s, %s)\n", scalarType, intrinsic, mangle, predicateType, vectorType)
+		}
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fadda.%s(%s, %s, %s)\n", scalarType, mangle, predicateType, scalarType, vectorType)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.faddv.%s(%s, %s)\n", scalarType, mangle, predicateType, vectorType)
+		for _, intrinsic := range []string{"faddqv", "fmaxqv", "fminqv", "fmaxnmqv", "fminnmqv"} {
+			fmt.Fprintf(b, "declare <%d x %s> @llvm.aarch64.sve.%s.v%d%s.%s(%s, %s)\n", lanes, scalarType, intrinsic, lanes, map[int]string{16: "f16", 32: "f32", 64: "f64"}[elementBits], mangle, predicateType, vectorType)
+		}
+		for _, intrinsic := range []string{"fabs", "fneg", "frecpx", "frint32x", "frint32z", "frint64x", "frint64z", "frinta", "frinti", "frintm", "frintn", "frintp", "frintx", "frintz", "fsqrt"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s, %s, %s)\n", vectorType, intrinsic, mangle, vectorType, predicateType, vectorType)
+		}
+		for _, intrinsic := range []string{"frecpe.x", "frsqrte.x"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s)\n", vectorType, intrinsic, mangle, vectorType)
+		}
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fexpa.x.%s(<vscale x %d x i%d>)\n", vectorType, mangle, lanes, elementBits)
+		fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.aarch64.sve.flogb.%s(<vscale x %d x i%d>, %s, %s)\n", lanes, elementBits, mangle, lanes, elementBits, predicateType, vectorType)
+		for _, intrinsic := range []string{"fdiv", "fdivr"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s, %s, %s)\n", vectorType, intrinsic, mangle, predicateType, vectorType, vectorType)
+		}
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fscale.%s(%s, %s, <vscale x %d x i%d>)\n", vectorType, mangle, predicateType, vectorType, lanes, elementBits)
+		fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.fcadd.%s(%s, %s, %s, i32 immarg)\n", vectorType, mangle, predicateType, vectorType, vectorType)
+		for _, intrinsic := range []string{"frecps.x", "frsqrts.x"} {
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.%s(%s, %s)\n", vectorType, intrinsic, mangle, vectorType, vectorType)
+		}
+		for _, intrinsic := range []string{"rint", "trunc"} {
+			fmt.Fprintf(b, "declare %s @llvm.%s.%s(%s)\n", vectorType, intrinsic, mangle, vectorType)
+		}
+		if elementBits != 16 {
+			for _, integerBits := range []int{32, 64} {
+				fmt.Fprintf(b, "declare <vscale x %d x i%d> @llvm.fptosi.sat.nxv%di%d.%s(%s)\n", lanes, integerBits, lanes, integerBits, mangle, vectorType)
+			}
+		}
+	}
+	for _, op := range arm64SVEPermuteOpsByIndex {
+		intrinsic := arm64SVEPermuteIntrinsics[op] + "q"
+		fmt.Fprintf(b, "declare <vscale x 2 x i64> @llvm.aarch64.sve.%s.nxv2i64(<vscale x 2 x i64>, <vscale x 2 x i64>)\n", intrinsic)
+	}
+	b.WriteString("declare float @llvm.sqrt.f32(float)\n")
+	b.WriteString("declare double @llvm.sqrt.f64(double)\n")
+	b.WriteString("declare float @llvm.fma.f32(float, float, float)\n")
+	b.WriteString("declare double @llvm.fma.f64(double, double, double)\n")
+	b.WriteString("declare half @llvm.fma.f16(half, half, half)\n")
+	for _, intrinsic := range []string{"fabs", "roundeven", "ceil", "floor", "trunc", "round", "rint", "nearbyint"} {
+		b.WriteString("declare float @llvm." + intrinsic + ".f32(float)\n")
+		b.WriteString("declare double @llvm." + intrinsic + ".f64(double)\n")
+	}
+	b.WriteString("declare <2 x float> @llvm.fma.v2f32(<2 x float>, <2 x float>, <2 x float>)\n")
+	b.WriteString("declare <4 x float> @llvm.fma.v4f32(<4 x float>, <4 x float>, <4 x float>)\n")
+	b.WriteString("declare <2 x double> @llvm.fma.v2f64(<2 x double>, <2 x double>, <2 x double>)\n")
+	b.WriteString("declare <4 x half> @llvm.fma.v4f16(<4 x half>, <4 x half>, <4 x half>)\n")
+	b.WriteString("declare <8 x half> @llvm.fma.v8f16(<8 x half>, <8 x half>, <8 x half>)\n")
+	for _, intrinsic := range []string{"fabs", "sqrt", "roundeven", "round", "rint", "nearbyint", "ceil", "floor", "trunc"} {
+		b.WriteString("declare <4 x half> @llvm." + intrinsic + ".v4f16(<4 x half>)\n")
+		b.WriteString("declare <8 x half> @llvm." + intrinsic + ".v8f16(<8 x half>)\n")
+		b.WriteString("declare <2 x float> @llvm." + intrinsic + ".v2f32(<2 x float>)\n")
+		b.WriteString("declare <4 x float> @llvm." + intrinsic + ".v4f32(<4 x float>)\n")
+		b.WriteString("declare <2 x double> @llvm." + intrinsic + ".v2f64(<2 x double>)\n")
+	}
+	for _, intrinsic := range []string{"fptosi.sat", "fptoui.sat"} {
+		for _, destination := range []string{"i32", "i64"} {
+			b.WriteString("declare " + destination + " @llvm." + intrinsic + "." + destination + ".f32(float)\n")
+			b.WriteString("declare " + destination + " @llvm." + intrinsic + "." + destination + ".f64(double)\n")
+		}
+		b.WriteString("declare <2 x i32> @llvm." + intrinsic + ".v2i32.v2f32(<2 x float>)\n")
+		b.WriteString("declare <4 x i32> @llvm." + intrinsic + ".v4i32.v4f32(<4 x float>)\n")
+		b.WriteString("declare <2 x i64> @llvm." + intrinsic + ".v2i64.v2f64(<2 x double>)\n")
+	}
+	for _, intrinsic := range []string{"maximum", "minimum", "maxnum", "minnum"} {
+		b.WriteString("declare half @llvm." + intrinsic + ".f16(half, half)\n")
+		b.WriteString("declare float @llvm." + intrinsic + ".f32(float, float)\n")
+		b.WriteString("declare double @llvm." + intrinsic + ".f64(double, double)\n")
+		b.WriteString("declare <4 x half> @llvm." + intrinsic + ".v4f16(<4 x half>, <4 x half>)\n")
+		b.WriteString("declare <8 x half> @llvm." + intrinsic + ".v8f16(<8 x half>, <8 x half>)\n")
+		b.WriteString("declare <2 x float> @llvm." + intrinsic + ".v2f32(<2 x float>, <2 x float>)\n")
+		b.WriteString("declare <4 x float> @llvm." + intrinsic + ".v4f32(<4 x float>, <4 x float>)\n")
+		b.WriteString("declare <2 x double> @llvm." + intrinsic + ".v2f64(<2 x double>, <2 x double>)\n")
+	}
+	for _, intrinsic := range []string{"sadd.sat", "uadd.sat", "ssub.sat", "usub.sat"} {
+		for _, vector := range []struct {
+			lanes int
+			bits  int
+		}{
+			{8, 8}, {16, 8}, {4, 16}, {8, 16}, {2, 32}, {4, 32}, {2, 64},
+		} {
+			vectorType := fmt.Sprintf("<%d x i%d>", vector.lanes, vector.bits)
+			fmt.Fprintf(b, "declare %s @llvm.%s.v%di%d(%s, %s)\n", vectorType, intrinsic, vector.lanes, vector.bits, vectorType, vectorType)
+		}
+	}
+	for _, intrinsic := range []string{"sqadd.x", "uqadd.x", "sqsub.x", "uqsub.x"} {
+		for _, bits := range []int{8, 16, 32, 64} {
+			lanes := 128 / bits
+			vectorType := fmt.Sprintf("<vscale x %d x i%d>", lanes, bits)
+			fmt.Fprintf(b, "declare %s @llvm.aarch64.sve.%s.nxv%di%d(%s, %s)\n", vectorType, intrinsic, lanes, bits, vectorType, vectorType)
+		}
+	}
 	// AArch64 CRC32 and CRC32C intrinsics.
 	// Note: B/H forms take the data operand as i32 (low bits used).
 	b.WriteString("declare i32 @llvm.aarch64.crc32b(i32, i32)\n")
@@ -31,34 +887,191 @@ func emitARM64Prelude(b *strings.Builder) {
 	b.WriteString("\n")
 }
 
-func translateFuncARM64(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, annotateSource bool) error {
+func translateFuncARM64(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, data []DataStmt, annotateSource bool) error {
+	return translateFuncARM64WithSourceCalls(b, fn, sig, resolve, sigs, data, annotateSource, nil)
+}
+
+func translateFuncARM64WithSourceCalls(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, data []DataStmt, annotateSource bool, sourceCalls map[string]arm64SourceNoopCall) error {
+	return translateFuncARM64WithSourceCallsAndAttrs(b, fn, sig, resolve, sigs, "", data, annotateSource, sourceCalls, sig.Attrs)
+}
+
+// Inferred target-feature attribute groups are an emission projection, not a
+// mutation of a declaration-backed source signature. Validate its exact input
+// fields and emit the separately computed group without granting ABI rights.
+func translateFuncARM64WithSourceCallsAndAttrs(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, target string, data []DataStmt, annotateSource bool, sourceCalls map[string]arm64SourceNoopCall, emissionAttrs string) error {
+	alignment, err := arm64FunctionPCAlignment(fn)
+	if err != nil {
+		return err
+	}
+	if err := validateARM64PrivateCallSource(fn); err != nil {
+		return err
+	}
+	if err := validateARM64ABI0TailSource(fn, sig); err != nil {
+		return err
+	}
+	if err := validateARM64PrivateTailSource(fn, sig); err != nil {
+		return err
+	}
+	paddingSource := fn
+	originalNanosleep, originalNanosleepRequired := arm64NanosleepInputForSource(fn,
+		&arm64PrivateFrameTransport{entry: sig, resolve: resolve, sigs: sigs}, target)
+	if originalNanosleepRequired && originalNanosleep == nil {
+		return fmt.Errorf("%w: original Linux nanosleep private input is unproved", ErrProbeNeedsContext)
+	}
+	fn, err = normalizeARM64ScalarMemoryFrame(fn)
+	if err != nil {
+		return err
+	}
+	if err := validateARM64ClosureSource(fn, sig); err != nil {
+		return err
+	}
+	// Validate the original complete function as well as the normalized CFG
+	// checked by the lowerer. Raw layout rewriting must not erase a private
+	// address source before granting native, hardware-sized store effects.
+	if err := validateARM64DCZVASource(fn, data); err != nil {
+		return err
+	}
+	sourceGoFrame := arm64SourceGoFrame(fn)
+	structureFrameProofRequired := arm64RawStructureFrameProofRequired(fn)
+	r20FrameProofRequired := arm64SourceFrameR20Required(fn)
+	unexposedCallFrame := arm64CallFrameUnexposedTypedTarget(fn, sig, resolve, sigs, target)
+	if r20FrameProofRequired && !unexposedCallFrame {
+		return fmt.Errorf("%w: ARM64 implicit R20 entry needs the complete typed source-frame/escape proof", ErrProbeNeedsContext)
+	}
+	if err := requireARM64RawStructureFrameProof(fn, unexposedCallFrame); err != nil {
+		return err
+	}
+	if strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		if sig.ARM64GoRegisterABI != nil {
+			if err := arm64ValidateGoRegisterABI(sig); err != nil {
+				return err
+			}
+			for _, ins := range fn.Instrs {
+				for _, arg := range ins.Args {
+					if arg.Kind == OpFP || arg.Kind == OpFPAddr {
+						return arm64GoABIContext("%q references FP spill storage not described by its register-only contract", sig.Name)
+					}
+				}
+			}
+		} else if len(sig.ArgRegs) == 0 || len(sig.ArgRegs) != len(sig.Args) {
+			return arm64GoABIContext("entry %q needs a complete typed register contract", sig.Name)
+		}
+	}
+	fn, err = normalizeARM64AtomicPairNamedMemory(fn)
+	if err != nil {
+		return err
+	}
+	fn, err = normalizeARM64NamedPCRelative(fn)
+	if err != nil {
+		return err
+	}
+	var rawData []arm64RawDataBlob
+	fn, rawData, err = prepareARM64RawPCRelativeWithReturnClobbers(fn, arm64RawPoolReturnClobbers(fn, sig))
+	if err != nil {
+		return err
+	}
+	if err := validateARM64ClosureSource(fn, sig); err != nil {
+		return err
+	}
+	if proof, present := sourceCalls[fn.Sym]; present && !proof.matchesNormalized(fn, sig) {
+		return arm64GoABIContext("normalized callee %q lost its complete original no-scratch-observer source", fn.Sym)
+	}
+	paddingReads, err := arm64FPPaddingReadProof(paddingSource, fn, sig)
+	if err != nil {
+		return err
+	}
+	if err := validateARM64ABI0TailSource(fn, sig); err != nil {
+		return err
+	}
+	rawDataGlobals := make(map[string]string, len(rawData))
+	rawDataOffsets := make(map[string]int64)
+	for _, data := range rawData {
+		name := sig.Name + "." + data.label + ".raw_data"
+		rawDataGlobals[data.label] = name
+		for label, offset := range data.aliases {
+			rawDataGlobals[label] = name
+			rawDataOffsets[label] = offset
+		}
+		fmt.Fprintf(b, "%s = private constant [%d x i8] %s, align %d\n", llvmGlobal(name), len(data.bytes), llvmI8ArrayInit(data.bytes), bestAlign(int64(len(data.bytes))))
+	}
+	if len(rawData) != 0 {
+		b.WriteString("\n")
+	}
 	fmt.Fprintf(b, "define %s %s(", sig.Ret, llvmGlobal(sig.Name))
+	if sig.ARM64ClosureABI != nil {
+		fmt.Fprintf(b, "ptr %s %%closure", sig.ARM64ClosureABI.llvmAttribute())
+	}
 	for i, t := range sig.Args {
-		if i > 0 {
+		if i > 0 || sig.ARM64ClosureABI != nil {
 			b.WriteString(", ")
 		}
 		fmt.Fprintf(b, "%s %%arg%d", t, i)
 	}
 	b.WriteString(")")
-	if sig.Attrs != "" {
-		b.WriteString(" " + sig.Attrs)
+	if alignment != 0 {
+		fmt.Fprintf(b, " align %d", alignment)
+	}
+	if emissionAttrs != "" {
+		b.WriteString(" " + emissionAttrs)
 	}
 	b.WriteString(" {\n")
 
-	c := newARM64Ctx(b, fn, sig, resolve, sigs, annotateSource)
+	c := newARM64CtxWithTarget(b, fn, sig, resolve, sigs, target, annotateSource)
+	c.fpPaddingReads = paddingReads
+	c.nanosleepOriginal = originalNanosleep
+	if originalNanosleep != nil {
+		originalNanosleep.owner = c
+		c.nanosleepOriginalSource = arm64NanosleepCloneSource(paddingSource)
+	}
+	c.sourceGoFrame = sourceGoFrame
+	c.unexposedCallFrame = unexposedCallFrame && c.unexposedCallFrame
+	if r20FrameProofRequired && !c.unexposedCallFrame {
+		return fmt.Errorf("%w: ARM64 normalized source lost its implicit R20 entry proof", ErrProbeNeedsContext)
+	}
+	// The producer and its complete frame proof remain separate from reaching
+	// software values, which borrow neither ownership nor a private SP root.
+	c.sourceFrameR20 = r20FrameProofRequired && arm64SourceFrameR20(fn) &&
+		arm64SourceFrameR20Transport(fn, &arm64PrivateFrameTransport{entry: sig, resolve: resolve, sigs: sigs})
+	c.checkedR20Entry = arm64SourceFrameR20Checked(fn, sig, resolve)
+	if structureFrameProofRequired && !c.unexposedCallFrame {
+		return fmt.Errorf("%w: ARM64 normalized framed structure source lost its complete physical-stack/source-escape proof", ErrProbeNeedsContext)
+	}
+	c.sourceData = data
+	c.sourceNoopCalls = sourceCalls
+	c.rawDataGlobals = rawDataGlobals
+	c.rawDataOffsets = rawDataOffsets
+	if err := c.prepareLocalControl(); err != nil {
+		return err
+	}
 	if err := c.emitEntryAllocasAndArgInit(); err != nil {
 		return err
 	}
+	c.machineAvailability = newARM64MachineAvailability(c)
+	fmt.Fprintf(b, "  br label %%%s\n", arm64LLVMBlockName(c.blocks[0].name))
 	if err := c.lowerBlocks(); err != nil {
 		return err
 	}
+	fmt.Fprintf(b, "\n%s:\n", arm64LLVMBlockName(c.localControl.outer))
+	if flow := c.machineAvailability; flow != nil {
+		flow.current = len(c.blocks)
+		flow.source = "typed caller return"
+	}
+	if err := c.lowerRET(); err != nil {
+		return err
+	}
+	if err := c.machineAvailability.validate(); err != nil {
+		return err
+	}
 
 	b.WriteString("}\n")
 	return nil
 }
 
 func (c *arm64Ctx) lowerBlocks() error {
+	c.flagFlow = newARM64FlagFlow(c.blocks)
+	defer func() { c.flagFlow = nil }()
 	emitBr := func(target string) {
+		c.recordARM64FlagFlowEdges(target)
 		fmt.Fprintf(c.b, "  br label %%%s\n", arm64LLVMBlockName(target))
 	}
 	emitCondBr := func(cond string, target string, fall string) error {
@@ -66,20 +1079,34 @@ func (c *arm64Ctx) lowerBlocks() error {
 		if err != nil {
 			return err
 		}
-		fmt.Fprintf(c.b, "  br i1 %s, label %%%s, label %%%s\n", cv, arm64LLVMBlockName(target), arm64LLVMBlockName(fall))
+		c.emitPredicateBranch(cv, target, fall)
 		return nil
 	}
 
 	for bi := 0; bi < len(c.blocks); bi++ {
+		c.currentBlock = bi
 		blk := c.blocks[bi]
-		if bi != 0 {
-			fmt.Fprintf(c.b, "\n%s:\n", arm64LLVMBlockName(blk.name))
+		c.flagFlow.current = bi
+		c.flagsWritten = false
+		c.flagsKnown = 0
+		if flow := c.machineAvailability; flow != nil {
+			flow.current = bi
 		}
+		fmt.Fprintf(c.b, "\n%s:\n", arm64LLVMBlockName(blk.name))
 
 		terminated := false
-		for _, ins := range blk.instrs {
+		for ii, ins := range blk.instrs {
+			c.currentInstruction = ii
 			c.emitSourceComment(ins)
+			start := c.b.Len()
+			if flow := c.machineAvailability; flow != nil {
+				flow.source, flow.skipReads = ins.Raw, arm64MachineZeroInputs(ins)
+			}
 			term, err := c.lowerInstr(bi, ins, emitBr, emitCondBr)
+			c.recordMachineOpaqueIR(start, ins)
+			if flow := c.machineAvailability; flow != nil {
+				flow.skipReads = false
+			}
 			if err != nil {
 				return err
 			}
@@ -88,10 +1115,12 @@ func (c *arm64Ctx) lowerBlocks() error {
 				break
 			}
 		}
-
 		if terminated {
 			continue
 		}
+		if c.lowerProvenUnreachableControl(bi) {
+			continue
+		}
 		// Fallthrough to next block.
 		if bi+1 < len(c.blocks) {
 			emitBr(c.blocks[bi+1].name)
@@ -100,7 +1129,7 @@ func (c *arm64Ctx) lowerBlocks() error {
 		// Last block: implicit return zero.
 		c.lowerRetZero()
 	}
-	return nil
+	return c.flagFlow.validate()
 }
 
 func (c *arm64Ctx) lowerInstr(bi int, ins Instr, emitBr arm64EmitBr, emitCondBr arm64EmitCondBr) (terminated bool, err error) {
@@ -111,34 +1140,460 @@ func (c *arm64Ctx) lowerInstr(bi int, ins Instr, emitBr arm64EmitBr, emitCondBr
 		baseOp = baseOp[:dot]
 	}
 	op := Op(baseOp)
-	if strings.HasPrefix(rawOp, "SAVE_R19_TO_R28(") ||
-		strings.HasPrefix(rawOp, "RESTORE_R19_TO_R28(") ||
-		strings.HasPrefix(rawOp, "SAVE_F8_TO_F15(") ||
-		strings.HasPrefix(rawOp, "RESTORE_F8_TO_F15(") {
-		return false, nil
-	}
-
 	switch op {
-	case OpTEXT, OpBYTE:
+	case OpTEXT:
 		return false, nil
+	case OpBYTE:
+		return false, fmt.Errorf("arm64 BYTE cannot be lowered safely as a partial machine instruction: %q", ins.Raw)
 	case OpRET:
+		if strings.Contains(string(ins.Op), ".") {
+			return true, fmt.Errorf("arm64 RET does not accept a suffix: %q", ins.Raw)
+		}
+		if c.flagFlow != nil {
+			c.flagFlow.blocks[c.flagFlow.current].returns = true
+		}
 		if len(ins.Args) == 1 && ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
+			if c.lowerProvenUnreachableControl(bi) {
+				return true, nil
+			}
+			if err := c.requireCallerSPRestored(bi, ins); err != nil {
+				return true, err
+			}
+			if err := c.requireCallerLinkRestored(bi, ins); err != nil {
+				return true, err
+			}
 			return true, c.tailCallAndRet(ins.Args[0])
 		}
 		if len(ins.Args) > 1 {
 			return true, fmt.Errorf("arm64 RET expects at most 1 operand: %q", ins.Raw)
 		}
-		return true, c.lowerRET()
-	case OpWORD:
-		return false, c.lowerRawWord(ins)
-	case "PCALIGN", "NO_LOCAL_POINTERS", "PCDATA", "FUNCDATA", "DMB", "DSB", "ISB", "DC", "PRFM",
-		"BREAK", "BRK", "UNDEF", "#UNDEF", "YIELD", "NOP",
-		"FLDPD", "FSTPD", "FMOVS", "STY",
-		"P256ADDINLINE", "P256MULBY2INLINE", "MOV",
-		"#IFDEF", "#ELSE", "#ENDIF":
-		return false, nil
-	}
-
+		if len(ins.Args) == 1 {
+			if _, err := c.registerBranchAddress(OpRET, ins); err != nil {
+				return true, err
+			}
+		}
+		if c.localControl != nil {
+			if target, register := arm64RegisterReturnTarget(ins, c.localControl.autoFrame); register {
+				ins.Args = []Operand{target}
+				return c.lowerRegisterControl(bi, OpRET, ins)
+			}
+		}
+		if c.lowerProvenUnreachableControl(bi) {
+			return true, nil
+		}
+		if err := c.requireCallerSPRestored(bi, ins); err != nil {
+			return true, err
+		}
+		if err := c.requireCallerLinkRestored(bi, ins); err != nil {
+			return true, err
+		}
+		return true, c.lowerRET()
+	case OpWORD:
+		rawErr := c.lowerRawWord(ins)
+		if rawErr == nil {
+			return false, nil
+		} else if !strings.Contains(rawErr.Error(), "unsupported ARM64 WORD encoding") {
+			return false, rawErr
+		}
+		decoded, err := decodeARM64RawWordInstruction(ins)
+		if err != nil {
+			if strings.Contains(err.Error(), "PC-relative") {
+				return false, err
+			}
+			return false, rawErr
+		}
+		decoded = arm64HardwareReturnAsBranch(decoded)
+		return c.lowerInstr(bi, decoded, emitBr, emitCondBr)
+	case arm64RawDataOp:
+		return false, nil
+	case "END":
+		// Go's assembler end-of-file directive emits no instruction.
+		return false, nil
+	case "PCALIGN", "PCALIGNMAX":
+		_, _, err := arm64PCAlignment(ins)
+		return false, err
+	case "NO_LOCAL_POINTERS", "PCDATA", "FUNCDATA":
+		return false, nil
+	}
+	if ok, term, err := c.lowerARM64Barrier(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64CacheMaintenance(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SYS(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64TLBI(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64Prefetch(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64Exception(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64Hint(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAddress(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAddressGeneration(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECnt(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEDupImmediate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAdd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAddSub(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatAddSub(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatMultiply(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatMultiplyExtended(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatTrigMultiply(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatTrigMultiplyAdd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatComplexMultiplyAccumulate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatMultiplyAccumulate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiplyAccumulate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEBFDOT(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEIntegerDot(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAESMix(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAESRound(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEOptionalCrypto(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVERevd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPMUL(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPMULL(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPMULLPair(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESaturatingMultiplyHigh(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEComplexMultiplyAccumulate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEComplexAdd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEXAR(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESaturatingRoundingMultiplyAccumulateHigh(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatMinMax(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatPredicatedPairwise(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatReciprocalStep(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatExponent(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatImmediate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatDivideScale(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMixedSaturatingAdd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatComplexAdd(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEDupW(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEDupQ(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEDupM(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFDOT(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECDOT(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVELUTI(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEWideningFloatMLA(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiNarrow(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatNarrowConversion(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEBFloatArithmetic(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEBFloatMLA(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFloatUnary(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEIntegerUnary(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateLogical(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateBreak(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicatePermute(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateState(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateIterate(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicatePosition(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateCounter(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateWhile(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateIncDec(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPredicateMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEWholeVectorMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEVectorPrefetch(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVENonTemporalMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEOrdinaryMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEStructuredMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEFirstFaultMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVENonFaultingMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEReplicateMemory(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64CTERM(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPMOV(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEIndex(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEInsert(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVELast(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECLast(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECompact(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEExpand(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMOVPRFX(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEEXT(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESplice(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECopy(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEConvert(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECompare(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECharacterMatch(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEHistogram(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMinMax(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEIntegerReduction(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAddReduction(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEWideningAddSub(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEShiftLong(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEAbsoluteDifference(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEHalvingAddSub(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEDivide(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVETernaryBitwise(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEEORInterleave(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEBitPermute(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVECarryLong(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEClamp(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEUnpack(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESaturatingNarrow(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEShiftNarrow(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESaturatingShiftNarrow(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVELSR(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEExtraShift(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMatrixMultiply(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPairwiseTail(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiplyAddTail(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEVectorPredicateIncDec(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESelect(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiply(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiplyHigh(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVESaturatingShift(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEEOR(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVETable(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVETableExtension(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEUMULLB(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEMultiplyAccumulateLong(op, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerARM64SVEPermute(op, ins); ok {
+		return term, err
+	}
+
+	if form, matched, err := parseARM64RNDR(ins); matched {
+		if err != nil {
+			return false, err
+		}
+		return false, c.lowerRawRNDR(form)
+	}
+	if ok, term, err := c.lowerPCRelativeAddress(bi, op, ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerData(op, postInc, ins); ok {
 		return term, err
 	}
@@ -167,35 +1622,53 @@ func (c *arm64Ctx) lowerInstr(bi int, ins Instr, emitBr arm64EmitBr, emitCondBr
 }
 
 func (c *arm64Ctx) lowerRET() error {
+	if c.goRegisterEntry {
+		if c.sig.Ret == Void {
+			c.b.WriteString("  ret void\n")
+			return nil
+		}
+		value, err := c.collectGoABIValue(c.sig.Ret, c.sig.ARM64GoRegisterABI.Results)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, value)
+		return nil
+	}
 	// Prefer classic Go asm return slots if present; many stdlib asm functions
 	// never materialize the return value in R0 and only store to ret+off(FP).
 	if len(c.fpResults) == 0 {
-		r0, err := c.loadReg(Reg("R0"))
+		if c.sig.Ret == Void {
+			c.b.WriteString("  ret void\n")
+			return nil
+		}
+		cursor := arm64ABIRegisterCursor{}
+		if fields, aggregate := parseLiteralStructFields(c.sig.Ret); aggregate {
+			result := "undef"
+			for fieldIndex, fieldType := range fields {
+				reg, err := cursor.next(fieldType)
+				if err != nil {
+					return fmt.Errorf("arm64 RET result field %d: %w", fieldIndex, err)
+				}
+				value, err := c.loadABIRegisterValue(reg, fieldType)
+				if err != nil {
+					return err
+				}
+				inserted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = insertvalue %s %s, %s %s, %d\n", inserted, c.sig.Ret, result, fieldType, value, fieldIndex)
+				result = "%" + inserted
+			}
+			fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, result)
+			return nil
+		}
+		reg, err := cursor.next(c.sig.Ret)
 		if err != nil {
-			return err
+			return fmt.Errorf("arm64 RET unsupported register result type %s", c.sig.Ret)
 		}
-		switch c.sig.Ret {
-		case Void:
-			c.b.WriteString("  ret void\n")
-		case I1:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i1\n", t, r0)
-			fmt.Fprintf(c.b, "  ret i1 %%%s\n", t)
-		case I8:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i8\n", t, r0)
-			fmt.Fprintf(c.b, "  ret i8 %%%s\n", t)
-		case I16:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i16\n", t, r0)
-			fmt.Fprintf(c.b, "  ret i16 %%%s\n", t)
-		case I32:
-			t := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t, r0)
-			fmt.Fprintf(c.b, "  ret i32 %%%s\n", t)
-		default:
-			fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, r0)
+		value, err := c.loadABIRegisterValue(reg, c.sig.Ret)
+		if err != nil {
+			return err
 		}
+		fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, value)
 		return nil
 	}
 
@@ -205,7 +1678,7 @@ func (c *arm64Ctx) lowerRET() error {
 		slot := c.fpResults[0]
 		var v string
 		var err error
-		if c.fpResWritten[slot.Index] || c.fpResAddrTaken[slot.Index] {
+		if c.checkedABI0Tail || c.fpResWritten[slot.Index] || c.fpResAddrTaken[slot.Index] {
 			v, err = c.loadFPResult(slot)
 		} else {
 			v, err = c.loadRetSlotFallback(slot)
@@ -223,7 +1696,7 @@ func (c *arm64Ctx) lowerRET() error {
 	for _, slot := range c.fpResults {
 		var v string
 		var err error
-		if c.fpResWritten[slot.Index] || c.fpResAddrTaken[slot.Index] {
+		if c.checkedABI0Tail || c.fpResWritten[slot.Index] || c.fpResAddrTaken[slot.Index] {
 			v, err = c.loadFPResult(slot)
 		} else {
 			v, err = c.loadRetSlotFallback(slot)
@@ -244,9 +1717,7 @@ func (c *arm64Ctx) lowerRetZero() {
 	switch c.sig.Ret {
 	case Void:
 		c.b.WriteString("  ret void\n")
-	case I32:
-		c.b.WriteString("  ret i32 0\n")
 	default:
-		fmt.Fprintf(c.b, "  ret %s 0\n", c.sig.Ret)
+		fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, llvmZeroValue(c.sig.Ret))
 	}
 }
diff --git a/arm64_typed_native_effects_runtime_test.go b/arm64_typed_native_effects_runtime_test.go
new file mode 100644
index 000000000..b5052ef4f
--- /dev/null
+++ b/arm64_typed_native_effects_runtime_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestCrossLinuxRuntimeMatrixARM64TypedNativeEffects(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source strings.Builder
+	fmt.Fprintln(&source, "TEXT ·ReadDCZID<ABIInternal>(SB),4,$0\nMRS DCZID_EL0,R0\nRET")
+	spec := arm64GoSystemRegisters["DCZID_EL0"]
+	fmt.Fprintf(&source, "TEXT ·ReadDCZIDRaw<ABIInternal>(SB),4,$0\nWORD $0x%08x\nRET\n", uint32(0xd5300000)|uint32(spec.encoding)<<5)
+	fmt.Fprintln(&source, "TEXT ·PrefetchHints<ABIInternal>(SB),4,$0\nCMP $0,R1")
+	// PRFM hints are not loads/stores, and do not alter GP registers or NZCV.
+	// RPRFM is object-tested separately: executing its newer ISA without an
+	// independently established CPU feature would not be a valid oracle.
+	for _, hint := range []string{
+		"PLDL1KEEP", "PLDL1STRM", "PLDL2KEEP", "PLDL2STRM", "PLDL3KEEP", "PLDL3STRM",
+		"PLIL1KEEP", "PLIL1STRM", "PLIL2KEEP", "PLIL2STRM", "PLIL3KEEP", "PLIL3STRM",
+		"PSTL1KEEP", "PSTL1STRM", "PSTL2KEEP", "PSTL2STRM", "PSTL3KEEP", "PSTL3STRM",
+	} {
+		fmt.Fprintf(&source, "PRFM (R0),%s\n", hint)
+	}
+	fmt.Fprintln(&source, "MRS DCZID_EL0,R3\nADD $9,R1,R0\nCINC NE,R0,R0\nRET")
+	const declarations = "func ReadDCZID() uint64\nfunc ReadDCZIDRaw() uint64\nfunc PrefetchHints(*byte,uint64) uint64\n"
+	goMain := "package main\n" + declarations + `func main() {
+  a := [64]byte{}
+  for i:=range a { a[i]=byte(i*7+3) }
+  saved:=a
+  for _,input:=range []uint64{0,1,123,0x8000000000000000,^uint64(0)} {
+    want:=input+9; if input!=0 { want++ }
+    if PrefetchHints(&a[3],input)!=want || a!=saved { panic("prefetch data/GP/NZCV effect") }
+    if ReadDCZID()!=ReadDCZIDRaw() { panic("named/raw DCZID mismatch") }
+  }
+}
+`
+	runARM64GoInternalOracle(t, source.String(), goMain, len(runner) != 0)
+	pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\n"+declarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	tr, err := translateGoModuleInContext(ctx, pkg, []byte(source.String()), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	const main = `#include <stdint.h>
+#include <string.h>
+extern uint64_t ReadDCZID(void), ReadDCZIDRaw(void);
+extern uint64_t PrefetchHints(uint8_t*,uint64_t);
+int main(void) {
+  uint8_t a[64], saved[64];
+  for (unsigned i=0;i<64;i++) a[i]=(uint8_t)(i*7+3);
+  memcpy(saved,a,64);
+  const uint64_t inputs[]={0,1,123,UINT64_C(0x8000000000000000),UINT64_MAX};
+  for (unsigned i=0;i<5;i++) {
+    uint64_t native;
+    __asm__ volatile("mrs %0, DCZID_EL0" : "=r"(native));
+    if (ReadDCZID()!=native || ReadDCZIDRaw()!=native) return 1;
+    if (PrefetchHints(a+3,inputs[i])!=inputs[i]+9+(inputs[i]!=0)) return 2;
+    if (memcmp(a,saved,64)!=0) return 3;
+  }
+  return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "typed_native_effects", triple, tr.Module.String(), main, runner)
+}
diff --git a/arm64_typed_native_effects_test.go b/arm64_typed_native_effects_test.go
new file mode 100644
index 000000000..a97e23ca0
--- /dev/null
+++ b/arm64_typed_native_effects_test.go
@@ -0,0 +1,276 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var arm64TypedNativeTargets = []string{
+	"aarch64-unknown-linux-gnu",
+	"aarch64-unknown-linux-musl",
+	"aarch64-apple-darwin",
+	"aarch64-pc-windows-msvc",
+}
+
+func arm64TypedNativeOptions(t *testing.T, target string) Options {
+	t.Helper()
+	sig := FuncSig{Name: "NativeEffects", Args: []LLVMType{I64}, Ret: I64}
+	var err error
+	sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return Options{
+		Goarch: "arm64", TargetTriple: target,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") },
+		Sigs:       map[string]FuncSig{"NativeEffects": sig},
+	}
+}
+
+func arm64TypedNativeSource(body string) string {
+	return "TEXT ·NativeEffects<ABIInternal>(SB),4,$0\n" + body + "\nRET\n"
+}
+
+func arm64TypedNativeGoObject(t *testing.T, source string) {
+	t.Helper()
+	if goToolchainAtLeast(runtime.Version(), 1, 27) {
+		requireARM64GoABIInternalObject(t, source)
+	}
+}
+
+func TestARM64TypedNativeEffectsCompletePrefetchFamily(t *testing.T) {
+	// Reuse the complete existing Go PRFM grammar fixture, but give every
+	// consumed GP register a real reaching value at the typed entry.
+	lines := strings.Split(arm64PrefetchForms, "\n")
+	var body strings.Builder
+	for i := 1; i < 30; i++ {
+		if i != 18 && i != 28 {
+			fmt.Fprintf(&body, "MOVD R0,R%d\n", i)
+		}
+	}
+	for _, line := range lines {
+		if strings.Contains(line, "PRFM ") {
+			fmt.Fprintln(&body, line)
+		}
+	}
+	for _, hint := range []string{"PLDKEEP", "PSTKEEP", "PLDSTRM", "PSTSTRM"} {
+		fmt.Fprintf(&body, "RPRFM (R0),R1,%s\n", hint)
+	}
+	for hint := 0; hint < 64; hint++ {
+		fmt.Fprintf(&body, "RPRFM (RSP),R2,$%d\n", hint)
+	}
+	for hint := 0; hint < 32; hint++ {
+		fmt.Fprintf(&body, "PRFM (R30),$%d\n", hint)
+	}
+	source := arm64TypedNativeSource(body.String())
+	arm64TypedNativeGoObject(t, source)
+	arm64TypedNativeAllAPIsAndObjects(t, source, 58, 68)
+}
+
+func TestARM64TypedNativeEffectsDCZIDNamedAndRaw(t *testing.T) {
+	var body strings.Builder
+	// Go's physical platform register R18 is deliberately not made an
+	// ordinary typed GP result by this system-register proof.
+	for i := 0; i < 30; i++ {
+		if i != 18 && i != 27 && i != 28 {
+			fmt.Fprintf(&body, "MRS DCZID_EL0,R%d\n", i)
+		}
+	}
+	fmt.Fprintln(&body, "MRS DCZID_EL0,ZR")
+	fmt.Fprintln(&body, "MRS DCZID_EL0,R27")
+	fmt.Fprintln(&body, "MOVD R30,R27")
+	fmt.Fprintln(&body, "MRS DCZID_EL0,R30")
+	fmt.Fprintln(&body, "MOVD R27,R30")
+	spec := arm64GoSystemRegisters["DCZID_EL0"]
+	for reg := uint32(0); reg < 32; reg++ {
+		if reg == 18 || reg == 28 {
+			continue
+		}
+		saved := 27
+		if reg == 27 {
+			saved = 25
+		}
+		fmt.Fprintf(&body, "MOVD R30,R%d\nWORD $0x%08x\nMOVD R%d,R30\n",
+			saved, uint32(0xd5300000)|uint32(spec.encoding)<<5|reg, saved)
+	}
+	source := arm64TypedNativeSource(body.String())
+	arm64TypedNativeGoObject(t, source)
+	arm64TypedNativeAllAPIsAndObjects(t, source, 0, 0)
+}
+
+func arm64TypedNativeAllAPIsAndObjects(t *testing.T, source string, prfm, rprfm int) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			opt := arm64TypedNativeOptions(t, target)
+			text, err := Translate(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Count(text, `asm sideeffect "prfm #`) != prfm ||
+				strings.Count(text, `asm sideeffect "rprfm #`) != rprfm {
+				t.Fatal("typed proof changed the actual prefetch instruction inventory")
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := module.String()
+			module.Dispose()
+			compileLLVMToObject(t, llc, target, "typed-native.ll", "typed-native.o", ir)
+			pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\nfunc NativeEffects(uint64) uint64\n")
+			bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound.Module.Dispose()
+		})
+	}
+}
+
+func TestARM64TypedNativeEffectsUnknownStateRemainsContext(t *testing.T) {
+	spec := arm64GoSystemRegisters["DCZID_EL0"]
+	for _, body := range []string{
+		"PRFM (R9),PLDL1KEEP",
+		"RPRFM (R0),R9,PLDKEEP",
+		"MRS DCZID_EL0,R30",
+		"MRS DCZID_EL0,R18_PLATFORM",
+		"MRS DCZID_EL0,g",
+		"MRS DCZID_EL0,R9\nB (R9)",
+		"MRS NZCV,R0",
+		// RNG defines its result and NZCV, but not an unrelated GP input.
+		"MRS RNDR,R0\nADD R9,R0,R0",
+		"MRS SCTLR_EL1,R0",
+		"MSR R0,TPIDR_EL0",
+		"WORD $0xd5300000",
+		"WORD $0xd51bd040", // MSR R0,TPIDR_EL0 stays outside this typed role.
+		fmt.Sprintf("WORD $0x%08x", uint32(0xd5300000)|uint32(spec.encoding)<<5|18),
+		fmt.Sprintf("WORD $0x%08x", uint32(0xd5300000)|uint32(spec.encoding)<<5|28),
+	} {
+		t.Run(strings.ReplaceAll(body, "\n", "_"), func(t *testing.T) {
+			source := arm64TypedNativeSource(body)
+			arm64TypedNativeGoObject(t, source)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, target := range arm64TypedNativeTargets {
+				opt := arm64TypedNativeOptions(t, target)
+				_, err := Translate(file, opt)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: unknown state accepted: %v", target, err)
+				}
+				ctx := llvm.NewContext()
+				module, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					module.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: module accepted unknown state: %v", target, err)
+				}
+				pkg := mustGoPackage(t, "test/nativeeffects", "package nativeeffects\nfunc NativeEffects(uint64) uint64\n")
+				bound, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: "arm64", TargetTriple: target, ResolveSym: opt.ResolveSym,
+				})
+				if bound != nil {
+					bound.Module.Dispose()
+				}
+				ctx.Dispose()
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s: Go binding accepted unknown state: %v", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestARM64TypedNativeEffectsMRSRejectsNonGPDestinations(t *testing.T) {
+	for _, instruction := range []string{
+		"MRS DCZID_EL0,RSP", "MRS DCZID_EL0,F0", "MRS DCZID_EL0,V0",
+		"MRS DCZID_EL0,(R0)", "MRS.W DCZID_EL0,R0", "MRS.P DCZID_EL0,R0",
+		"MRS DCZID_EL0,$1", "MRS R0,R1", "MRS DCZID_EL0",
+	} {
+		source := "TEXT bad(SB),4,$0\n" + instruction + "\nRET\n"
+		requireARM64GoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM64, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+			t.Errorf("MRS accepted an instruction outside the Go form table: %s", instruction)
+		}
+	}
+}
+
+func TestARM64TypedNativeEffectsProofIsBoundToExactEmission(t *testing.T) {
+	var ir strings.Builder
+	flow := &arm64MachineAvailability{
+		blocks: []arm64MachineBlock{{name: "entry"}}, source: "PRFM (R0),PLDL1KEEP",
+	}
+	ctx := &arm64Ctx{
+		b: &ir, machineAvailability: flow, flagsKnown: arm64FlagAll, flagsWritten: true,
+		flagsNSlot: "flags_N", flagsZSlot: "flags_Z", flagsCSlot: "flags_C", flagsVSlot: "flags_V",
+	}
+	opaqueCount := func() int {
+		count := 0
+		for _, effect := range flow.blocks[0].effects {
+			if effect.opaque {
+				count++
+			}
+		}
+		return count
+	}
+	ctx.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q()\n", "nop", "")
+	ctx.recordMachineOpaqueIR(0, Instr{})
+	if len(flow.blocks[0].effects) != 0 || ctx.flagsKnown != arm64FlagAll || !ctx.flagsWritten {
+		t.Fatal("exact validated native emission remained opaque")
+	}
+	start := ir.Len()
+	fmt.Fprint(&ir, "  call void asm sideeffect \"nop\", \"\"()\n")
+	ctx.recordMachineOpaqueIR(start, Instr{})
+	if opaqueCount() != 1 || ctx.flagsKnown != 0 || ctx.flagsWritten {
+		t.Fatal("identical unproven native IR borrowed a different emission's proof")
+	}
+	unavailable := make(map[string]int)
+	for _, effect := range flow.blocks[0].effects {
+		if !effect.unavailable {
+			continue
+		}
+		if effect.width != 1 {
+			t.Fatalf("native flag invalidation widened %s to %d bits", effect.register, effect.width)
+		}
+		unavailable[effect.register]++
+	}
+	if len(unavailable) != 4 {
+		t.Fatalf("native callout did not separately revoke all four flags: %v", unavailable)
+	}
+	for _, slot := range []string{ctx.flagsNSlot, ctx.flagsZSlot, ctx.flagsCSlot, ctx.flagsVSlot} {
+		if unavailable[slot] != 1 {
+			t.Fatalf("native callout did not revoke %s exactly once: %v", slot, unavailable)
+		}
+	}
+	start = ir.Len()
+	ctx.emitMachineNeutralNativeIR("  call void asm sideeffect %q, %q()\n", "nop", "")
+	fmt.Fprint(&ir, "  call void @unknown()\n")
+	ctx.recordMachineOpaqueIR(start, Instr{})
+	if opaqueCount() != 2 {
+		t.Fatal("one proven line excused a second unknown callout")
+	}
+}
diff --git a/arm64_vdup_physical_lane_test.go b/arm64_vdup_physical_lane_test.go
new file mode 100644
index 000000000..b82cca03e
--- /dev/null
+++ b/arm64_vdup_physical_lane_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type arm64VDUPPhysicalCase struct {
+	spelling, arrangement string
+	bits, lanes, index    int
+}
+
+func TestARM64VDUPPhysicalLaneCannotBorrowAnotherRowOrInput(t *testing.T) {
+	for _, spelling := range []string{"B", "H", "S", "D"} {
+		for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+			bits := map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[arrangement[0]]
+			for _, index := range []int{-1, 128 / bits} {
+				instruction := fmt.Sprintf("VDUP V20.%s[%d],V21.%s", spelling, index, arrangement)
+				t.Run(instruction, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "arm64", "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+					if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", instruction+"\nRET\n"); err == nil {
+						t.Fatal("physical destination bound did not reject invalid lane")
+					}
+				})
+			}
+		}
+	}
+	for _, instruction := range []string{
+		"VMOV V20.D[15],R0", "VMOV V20.D[15],V21.D[0]", "VDUP V20.D[15],V21",
+		"VDUP V20.Q[0],V21.B16", "VDUP V20.D[1],V21.D1", "VDUP V32.B[0],V21.B16",
+	} {
+		goAssemblerOracleOutput(t, "arm64", "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+		if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", instruction+"\nRET\n"); err == nil {
+			t.Fatalf("case79 syntax leaked to another operand class: %s", instruction)
+		}
+	}
+	for _, body := range []string{
+		"VDUP V20.D[15],V21.B16\nVMOV V21.D[0],R0\nRET\n",
+		"VMOV R0,V20.B[14]\nVDUP V20.D[15],V21.B16\nVMOV V21.D[0],R0\nRET\n",
+		"VMOV R0,V20.B[15]\nVDUP V20.B[1],V21.D2\nVMOV V21.D[0],R0\nRET\n",
+	} {
+		if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", body); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("source suffix or adjacent lane supplied unknown physical bits: %v", err)
+		}
+	}
+}
+
+func arm64VDUPPhysicalProgram() (declarations, ordinary, internal string) {
+	var decl, abi0, reg strings.Builder
+	for i, tc := range arm64VDUPPhysicalCases() {
+		name := fmt.Sprintf("Dup%d", i)
+		fmt.Fprintf(&decl, "func %s(uint64) (uint64,uint64)\n", name)
+		fmt.Fprintf(&abi0, "TEXT ·%s(SB),4,$0-24\nMOVD a+0(FP),R0\n%sMOVD R0,ret+8(FP)\nMOVD R1,ret1+16(FP)\nRET\n", name, arm64VDUPPhysicalBody(tc))
+		fmt.Fprintf(&reg, "TEXT ·%s<ABIInternal>(SB),4,$0-24\n%sRET\n", name, arm64VDUPPhysicalBody(tc))
+	}
+	return decl.String(), abi0.String(), reg.String()
+}
+
+func arm64VDUPPhysicalIR(t *testing.T, target string) string {
+	t.Helper()
+	decl, _, source := arm64VDUPPhysicalProgram()
+	pkg := mustGoPackage(t, "test/vdupphysical", "package vdupphysical\n"+decl)
+	result, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer result.Module.Dispose()
+	return result.Module.String()
+}
+
+func TestARM64VDUPPhysicalLaneObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(target, func(t *testing.T) {
+			compileLLVMToObject(t, llc, target, "physical-vdup.ll", "physical-vdup.o", arm64VDUPPhysicalIR(t, target))
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64VDUPPhysicalLanes(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	decl, original, _ := arm64VDUPPhysicalProgram()
+	var goChecks, cDecl, cChecks, shims strings.Builder
+	for i, tc := range arm64VDUPPhysicalCases() {
+		mask := ^uint64(0)
+		if tc.bits < 64 {
+			mask = uint64(1)<<uint(tc.bits) - 1
+		}
+		multiplier := ^uint64(0) / mask
+		fmt.Fprintf(&goChecks, `{
+    var want uint64
+    for shift := uint(0); shift < 64; shift += %d {
+        want |= (a & %d) << shift
+    }
+    high := want
+    if %d == 64 { high = 0 }
+    lo, hi := Dup%d(a)
+    if lo != want || hi != high { panic("Go physical VDUP case %d") }
+}
+`, tc.bits, mask, tc.bits*tc.lanes, i, i)
+		for field, label := range []string{"Lo", "Hi"} {
+			fmt.Fprintf(&shims, "define i64 @Dup%d%s(i64 %%a) {\n  %%r = call { i64, i64 } @Dup%d(i64 %%a)\n  %%v = extractvalue { i64, i64 } %%r, %d\n  ret i64 %%v\n}\n", i, label, i, field)
+			fmt.Fprintf(&cDecl, "extern uint64_t Dup%d%s(uint64_t);\n", i, label)
+		}
+		high := "want"
+		if tc.bits*tc.lanes == 64 {
+			high = "0"
+		}
+		fmt.Fprintf(&cChecks, "{\n  uint64_t want = (a & UINT64_C(%d)) * UINT64_C(%d);\n  if (Dup%dLo(a) != want || Dup%dHi(a) != (%s)) { fprintf(stderr, \"VDUP case %d input %%u\\n\", i); return 1; }\n}\n", mask, multiplier, i, i, high, i)
+	}
+	goMain := "package main\n" + decl + `
+func main() {
+    for _, a := range []uint64{0, 1, 0x123456789abcdef0, 0x8000000000000000, ^uint64(0)} {
+` + goChecks.String() + "\n}\n}\n"
+	runARM64LocalRegisterGoOracle(t, original, goMain, len(runner) != 0, "1.20")
+	cMain := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + `
+int main(void) {
+    const uint64_t inputs[] = {0, 1, UINT64_C(0x123456789abcdef0),
+        UINT64_C(0x8000000000000000), UINT64_MAX};
+    const volatile uint64_t canary = UINT64_C(0x7432656876458798);
+    for (unsigned i = 0; i < 5; i++) {
+        uint64_t a = inputs[i];
+` + cChecks.String() + `
+    }
+    if (canary != UINT64_C(0x7432656876458798)) return 2;
+    return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "physical_vdup", triple, arm64VDUPPhysicalIR(t, triple)+shims.String(), cMain, runner)
+}
+
+func arm64VDUPPhysicalCases() []arm64VDUPPhysicalCase {
+	var cases []arm64VDUPPhysicalCase
+	for _, spelling := range []string{"B", "H", "S", "D"} {
+		for _, destination := range []struct {
+			name        string
+			bits, lanes int
+		}{{"B8", 8, 8}, {"B16", 8, 16}, {"H4", 16, 4}, {"H8", 16, 8}, {"S2", 32, 2}, {"S4", 32, 4}, {"D2", 64, 2}} {
+			for index := 0; index < 128/destination.bits; index++ {
+				cases = append(cases, arm64VDUPPhysicalCase{spelling: spelling, arrangement: destination.name,
+					bits: destination.bits, lanes: destination.lanes, index: index})
+			}
+		}
+	}
+	return cases
+}
+
+func arm64VDUPPhysicalBody(tc arm64VDUPPhysicalCase) string {
+	kind := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[tc.bits]
+	return fmt.Sprintf("VMOV R0,V20.%s[%d]\nVDUP V20.%s[%d],V21.%s\nVMOV V21.D[0],R0\nVMOV V21.D[1],R1\n", kind, tc.index, tc.spelling, tc.index, tc.arrangement)
+}
+
+func TestARM64VDUPPhysicalLaneUsesDestinationWidth(t *testing.T) {
+	var ordinary strings.Builder
+	for i, tc := range arm64VDUPPhysicalCases() {
+		fmt.Fprintf(&ordinary, "TEXT lane%d(SB),4,$0-0\n%sRET\n", i, arm64VDUPPhysicalBody(tc))
+	}
+	// This actual object must succeed before the translator's independent
+	// grammar/availability check; the source suffix is not a physical bound.
+	arm64ImmediateOriginalGoBytes(t, ordinary.String(), "linux")
+	for _, tc := range arm64VDUPPhysicalCases() {
+		name := fmt.Sprintf("%s%d_%s", tc.spelling, tc.index, tc.arrangement)
+		t.Run(name, func(t *testing.T) {
+			pkg := mustGoPackage(t, "test/vdupphysical", "package vdupphysical\nfunc Pass(uint64) (uint64,uint64)\n")
+			result, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-24\n"+arm64VDUPPhysicalBody(tc)+"RET\n"), GoModuleOptions{GOARCH: "arm64"})
+			if result != nil {
+				result.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatalf("actual Go case79 physical source span lost: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_vector_forms_test.go b/arm64_vector_forms_test.go
new file mode 100644
index 000000000..30f6783e1
--- /dev/null
+++ b/arm64_vector_forms_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARM64SharedVectorTransferCompleteRows(t *testing.T) {
+	file, err := Parse(ArchARM64, arm64VectorDuplicateForms+arm64VMOVSource(arm64VMOVCases()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			if ins.Op != "VMOV" && ins.Op != "VDUP" {
+				continue
+			}
+			if _, err := parseARM64VectorTransfer(ins.Op, ins); err != nil {
+				t.Fatalf("complete existing actual-Go fixture lost %s: %v", ins.Raw, err)
+			}
+		}
+	}
+}
+
+func TestARM64SharedVectorShiftFullBoundaries(t *testing.T) {
+	var original strings.Builder
+	original.WriteString("TEXT vectorShiftForms(SB),$0-0\n")
+	// Four architectural variants have no named Go mnemonic. Their complete
+	// decoder and shared lowering grammar are exercised with original WORDs,
+	// not by claiming the corresponding internal spellings are Go aliases.
+	bases := map[Op]uint32{
+		"VSSHR": 0x0f000400, "VSSRA": 0x0f001400,
+		"VSRSHR": 0x0f002400, "VSRSRA": 0x0f003400,
+		"VUSHR": 0x2f000400, "VUSRA": 0x2f001400,
+		"VURSHR": 0x2f002400, "VURSRA": 0x2f003400,
+	}
+	for _, arrangement := range []string{"B8", "B16", "H4", "H8", "S2", "S4", "D2"} {
+		width := map[byte]int{'B': 8, 'H': 16, 'S': 32, 'D': 64}[arrangement[0]]
+		for _, shift := range []int{0, width - 1} {
+			fmt.Fprintf(&original, "VSHL $%d,V0.%s,V0.%s\n", shift, arrangement, arrangement)
+		}
+		for op := range arm64VectorShiftRightSpecs {
+			for _, shift := range []int{1, width} {
+				full := strings.HasSuffix(arrangement, "16") || strings.HasSuffix(arrangement, "8") && width == 16 ||
+					strings.HasSuffix(arrangement, "4") && width == 32 || width == 64
+				word := encodeARM64ImmediateShiftRight(bases[op], width, shift, full, 0, 0)
+				fmt.Fprintf(&original, "WORD $%#08x\n", word)
+			}
+		}
+	}
+	original.WriteString("RET\n")
+	requireARM64GoAssemblerResult(t, original.String(), true)
+	file, err := Parse(ArchARM64, original.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == OpRET || ins.Op == OpTEXT {
+			continue
+		}
+		ins = arm64ControlDecode(ins)
+		form, err := parseARM64VectorShift(ins.Op, ins)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, badShift := range []int64{-1, int64(form.arrangement.elementBits + 1)} {
+			changed := ins
+			changed.Args = append([]Operand(nil), ins.Args...)
+			changed.Args[0].Imm = badShift
+			if _, err := parseARM64VectorShift(ins.Op, changed); err == nil {
+				t.Fatalf("shift boundary mutation accepted: %s shift=%d", ins.Raw, badShift)
+			}
+		}
+		changed := ins
+		changed.Args = append([]Operand(nil), ins.Args...)
+		changed.Args[0].ImmIsFloat = true
+		if _, err := parseARM64VectorShift(ins.Op, changed); err == nil {
+			t.Fatalf("float-class immediate accepted: %s", ins.Raw)
+		}
+	}
+}
diff --git a/arm64_vector_identity_test.go b/arm64_vector_identity_test.go
new file mode 100644
index 000000000..69b6f64d7
--- /dev/null
+++ b/arm64_vector_identity_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARM64SharedVectorHelperCaseIdentity(t *testing.T) {
+	for _, line := range []string{"VMOV ZR,V0.B16", "VDUP ZR,V0.B16", "VSHL $1,V0.S4,V0.S4", "VSSHR $1,V0.S4,V0.S4"} {
+		file, err := Parse(ArchARM64, "TEXT identity(SB),$0-0\n"+line+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		for _, identity := range []string{strings.ToLower(string(instruction.Op)), "", "VEOR"} {
+			t.Run(line+"/"+identity, func(t *testing.T) {
+				context, output := newARM64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Name: "identity", Ret: Void}, nil)
+				changed := instruction
+				changed.Op = Op(identity)
+				before := output.Len()
+				handled, _, err := context.lowerVec(instruction.Op, false, changed)
+				if identity == strings.ToLower(string(instruction.Op)) {
+					if !handled || err != nil {
+						t.Fatalf("historical case-insensitive helper dispatch rejected: handled=%t err=%v", handled, err)
+					}
+				} else if !handled || err == nil || output.Len() != before {
+					t.Fatalf("empty/contradictory identity emitted before rejection: handled=%t err=%v bytes=%d", handled, err, output.Len()-before)
+				}
+			})
+		}
+	}
+}
diff --git a/arm64_vector_lane_availability_test.go b/arm64_vector_lane_availability_test.go
new file mode 100644
index 000000000..197af18b0
--- /dev/null
+++ b/arm64_vector_lane_availability_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func arm64VectorLaneTranslation(t *testing.T, declaration, body string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "test/lanebits", "package lanebits\n"+declaration+"\n")
+	result, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\n"+body), GoModuleOptions{GOARCH: "arm64"})
+	if result == nil {
+		return "", err
+	}
+	defer result.Module.Dispose()
+	return result.Module.String(), err
+}
+
+func TestARM64GoRegisterVectorLaneInsertKeepsUnwrittenBitsUnknown(t *testing.T) {
+	for _, element := range []struct {
+		name string
+		bits int
+	}{
+		{name: "B", bits: 8},
+		{name: "H", bits: 16},
+		{name: "S", bits: 32},
+		{name: "D", bits: 64},
+	} {
+		for lane := 0; lane < 128/element.bits; lane++ {
+			name := fmt.Sprintf("%s%d", element.name, lane)
+			t.Run(name, func(t *testing.T) {
+				body := fmt.Sprintf("VMOV R0,V21.%s[%d]\nVMOV V21.%s[%d],R0\nRET\n", element.name, lane, element.name, lane)
+				// The instruction family exists in both supported SDKs. This
+				// actual ordinary object observes its machine encoding only;
+				// it is not an ABIInternal caller or runtime certificate.
+				bytes := arm64ImmediateOriginalGoBytes(t, "TEXT lane(SB),4,$0-0\n"+body, "linux")
+				if len(bytes) < 12 {
+					t.Fatalf("original VMOV insert/extract object is incomplete: %x", bytes)
+				}
+				pkg := mustGoPackage(t, "test/lanebits", "package lanebits\nfunc Pass(uint64) uint64\n")
+				result, err := TranslateGoModule(pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\n"+body), GoModuleOptions{GOARCH: "arm64"})
+				if result != nil {
+					result.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatalf("a defined inserted lane incorrectly read preserved unknown destination bits: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestARM64GoRegisterVectorLaneTransferDefinedSpans(t *testing.T) {
+	for name, body := range map[string]string{
+		"matching lane copy":         "VMOV R0,V20.S[3]\nVMOV V20.S[3],V21.S[1]\nVMOV V21.S[1],R0\nRET\n",
+		"scalar lane clears upper":   "VMOV R0,V20.B[15]\nVMOV V20.B[15],V21\nVMOV V21.D[1],R0\nRET\n",
+		"lane duplicate":             "VMOV R0,V20.H[7]\nVDUP V20.H[7],V21.H8\nVMOV V21.D[1],R0\nRET\n",
+		"mixed suffix encoded width": "VMOV R0,V20.B[1]\nVDUP V20.D[1],V21.B16\nVMOV V21.D[1],R0\nRET\n",
+		"GP duplicate clears upper":  "VMOV R0,V21.B8\nVMOV V21.D[1],R0\nRET\n",
+		"low copy clears upper":      "VMOV R0,V20.D[0]\nVMOV V20.B8,V21.B8\nVMOV V21.D[1],R0\nRET\n",
+		"complete copy":              "VMOV R0,V20.D[0]\nVMOV R0,V20.D[1]\nVMOV V20.B16,V21.B16\nVMOV V21.D[1],R0\nRET\n",
+		"same register lane alias":   "VMOV R0,V20.D[0]\nVMOV V20.D[0],V20.D[1]\nVMOV V20.B16,V21.B16\nVMOV V21.D[1],R0\nRET\n",
+		"scalar F/V low alias":       "VMOV R0,V21.D[0]\nFMOVD F21,R0\nRET\n",
+		"both incoming paths":        "CBZ R0,left\nVMOV R0,V21.D[1]\nB join\nleft:\nVMOV ZR,V21.D[1]\njoin:\nVMOV V21.D[1],R0\nRET\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			arm64ImmediateOriginalGoBytes(t, "TEXT lane(SB),4,$0-0\n"+body, "linux")
+			if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", body); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	for _, bits := range []int{8, 16, 32, 64} {
+		t.Run(fmt.Sprintf("narrow GP %d", bits), func(t *testing.T) {
+			kind := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[bits]
+			body := fmt.Sprintf("VMOV R0,V21.%s[0]\nVMOV V21.%s[0],R0\nRET\n", kind, kind)
+			if _, err := arm64VectorLaneTranslation(t, fmt.Sprintf("func Pass(uint%d) uint64", bits), body); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	if _, err := arm64VectorLaneTranslation(t, "func Pass(float64) uint64", "VMOV V0.D[0],V21.D[1]\nVMOV V21.D[1],R0\nRET\n"); err != nil {
+		t.Fatalf("typed F/V scalar alias lost its defined low double: %v", err)
+	}
+}
+
+func TestARM64GoRegisterVectorLaneCannotInitializePreservedInputs(t *testing.T) {
+	for name, body := range map[string]string{
+		"unwritten lane":                "VMOV R0,V21.D[0]\nVMOV V21.D[1],R0\nRET\n",
+		"whole vector":                  "VMOV R0,V21.D[0]\nVMOV V21.B16,V22.B16\nVMOV V22.D[0],R0\nRET\n",
+		"unknown source lane":           "VMOV V20.D[1],V21.D[0]\nVMOV V21.D[0],R0\nRET\n",
+		"unknown GP source":             "VMOV R9,V21.D[0]\nVMOV V21.D[0],R0\nRET\n",
+		"scalar alias reads low":        "VMOV R0,V21.D[1]\nFMOVD F21,R0\nRET\n",
+		"missing path":                  "CBZ R0,join\nVMOV R0,V21.D[0]\njoin:\nVMOV V21.D[0],R0\nRET\n",
+		"different incoming lanes":      "CBZ R0,left\nVMOV R0,V21.D[0]\nB join\nleft:\nVMOV R0,V21.D[1]\njoin:\nVMOV V21.D[0],R0\nRET\n",
+		"typed call resets vector bank": "VMOV R0,V21.D[0]\nCALL ·Compute<ABIInternal>(SB)\nVMOV V21.D[0],R0\nRET\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			_, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64\nfunc Compute() uint64", body)
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "read") {
+				t.Fatalf("unknown preserved/input bits acquired numerical authority: %v", err)
+			}
+		})
+	}
+	for _, test := range []struct {
+		declaration string
+		body        string
+	}{
+		{declaration: "func Pass(uint8) uint64", body: "VMOV R0,V21.H[0]\nVMOV V21.H[0],R0\nRET\n"},
+		{declaration: "func Pass(float32) uint64", body: "VMOV V0.S[1],V21.S[0]\nVMOV V21.S[0],R0\nRET\n"},
+	} {
+		if _, err := arm64VectorLaneTranslation(t, test.declaration, test.body); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("narrow scalar entry supplied undefined wider/later bits: %v", err)
+		}
+	}
+	if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", "VMOV R0,V21.D[0]\nCALL ·Unknown<ABIInternal>(SB)\nVMOV V21.D[0],R0\nRET\n"); err == nil {
+		t.Fatal("unknown callee inherited a lane or continuation contract")
+	}
+}
+
+func TestARM64GoRegisterVectorLaneActualRejectsAdjacentForms(t *testing.T) {
+	for _, instruction := range []string{
+		"VMOV R0,V21.B[16]", "VMOV R0,V21.H[8]", "VMOV R0,V21.S[4]", "VMOV R0,V21.D[2]",
+		"VMOV V20.B[-1],R0", "VMOV V20.Q[0],R0", "VMOV V20.S[0],V21.H[0]",
+		"VMOV RSP,V21.D[0]", "VMOV V21.D[0],RSP", "VMOV.P R0,V21.D[0]",
+		"VMOV V20.B8,V21.B16", "VMOV (R0),V21.B16", "VMOV V20,V21",
+		"VDUP V20.S[4],V21.S4", "VDUP V20.D[1],V21.D1", "VDUP RSP,V21.B16",
+		"VDUP.P R0,V21.B16", "VDUP R0,V21", "VDUP V20.S4,V21.S4",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			goAssemblerOracleOutput(t, "arm64", "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			if _, err := arm64VectorLaneTranslation(t, "func Pass(uint64) uint64", instruction+"\nRET\n"); err == nil {
+				t.Fatalf("Go-rejected vector lane form acquired defined-bit permission: %s", instruction)
+			}
+		})
+	}
+}
diff --git a/arm64_vector_lane_runtime_test.go b/arm64_vector_lane_runtime_test.go
new file mode 100644
index 000000000..9979edd1c
--- /dev/null
+++ b/arm64_vector_lane_runtime_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestARM64GoRegisterVectorLaneActualGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "arm64", "asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`(?m)^\s*\{AV(?:MOV|DUP),[^\n]+\},`).FindAllString(string(data), -1)
+	for i := range rows {
+		rows[i] = strings.Join(strings.Fields(rows[i]), "")
+	}
+	want := []string{
+		"{AVMOV,C_ELEM,C_NONE,C_NONE,C_ZREG,73,4,0,0,0},",
+		"{AVMOV,C_ELEM,C_NONE,C_NONE,C_ELEM,92,4,0,0,0},",
+		"{AVMOV,C_ELEM,C_NONE,C_NONE,C_VREG,80,4,0,0,0},",
+		"{AVMOV,C_ZREG,C_NONE,C_NONE,C_ARNG,82,4,0,0,0},",
+		"{AVMOV,C_ZREG,C_NONE,C_NONE,C_ELEM,78,4,0,0,0},",
+		"{AVMOV,C_ARNG,C_NONE,C_NONE,C_ARNG,83,4,0,0,0},",
+		"{AVDUP,C_ELEM,C_NONE,C_NONE,C_ARNG,79,4,0,0,0},",
+		"{AVDUP,C_ELEM,C_NONE,C_NONE,C_VREG,80,4,0,0,0},",
+		"{AVDUP,C_ZREG,C_NONE,C_NONE,C_ARNG,82,4,0,0,0},",
+	}
+	// The newer Optab adds a sixth operand class before the encoder case.
+	// All nine audited rows leave it C_NONE; accept only these two complete
+	// table shapes, not an arbitrary extra operand or a partial row match.
+	modern := make([]string, len(want))
+	for i, row := range want {
+		fields := strings.Split(row, ",")
+		modern[i] = strings.Join(fields[:5], ",") + ",C_NONE," + strings.Join(fields[5:], ",")
+	}
+	if !reflect.DeepEqual(rows, want) && !reflect.DeepEqual(rows, modern) {
+		t.Fatalf("actual SDK vector transfer optab changed: got %v, want %v", rows, want)
+	}
+}
+
+type arm64DefinedLaneCase struct {
+	body string
+	bits int
+	zero bool
+}
+
+// Reuse the independently audited six-row format matrix, but initialize only
+// the source span being consumed. No unrelated destination bytes are promised.
+func arm64DefinedLaneCases() []arm64DefinedLaneCase {
+	var cases []arm64DefinedLaneCase
+	for _, tc := range arm64VMOVCases() {
+		kind := map[int]string{1: "B", 2: "H", 4: "S", 8: "D"}[tc.bytes]
+		instruction := strings.NewReplacer("R3", "R0", "R4", "R0").Replace(tc.instruction)
+		body, destination := "", "V1"
+		if tc.alias {
+			destination = "V0"
+		}
+		switch tc.shape {
+		case "lane", "scalar", "extract":
+			body = fmt.Sprintf("VMOV R0,V0.%s[%d]\n", kind, tc.sourceLane)
+		case "copy":
+			body = "VMOV R0,V0.D[0]\n"
+			if tc.bytes == 16 {
+				body += "VMOV R0,V0.D[1]\n"
+			}
+		}
+		body += instruction + "\n"
+		readLane := tc.destinationLane
+		if tc.shape == "scalar" || tc.shape == "duplicate" {
+			readLane = 0
+		}
+		if tc.shape == "copy" {
+			kind, readLane = "D", 0
+		}
+		if tc.shape != "extract" {
+			body += fmt.Sprintf("VMOV %s.%s[%d],R0\n", destination, kind, readLane)
+		}
+		bits := tc.bytes * 8
+		if bits > 64 {
+			bits = 64
+		}
+		cases = append(cases, arm64DefinedLaneCase{body: body, bits: bits, zero: tc.zero})
+	}
+	return cases
+}
+
+func arm64DefinedLaneProgram() (declarations, ordinary, internal string) {
+	var decl, abi0, reg strings.Builder
+	for i, tc := range arm64DefinedLaneCases() {
+		name := fmt.Sprintf("Lane%d", i)
+		fmt.Fprintf(&decl, "func %s(uint64) uint64\n", name)
+		fmt.Fprintf(&abi0, "TEXT ·%s(SB),4,$0-16\nMOVD a+0(FP),R0\n%sMOVD R0,ret+8(FP)\nRET\n", name, tc.body)
+		fmt.Fprintf(&reg, "TEXT ·%s<ABIInternal>(SB),4,$0-16\n%sRET\n", name, tc.body)
+	}
+	return decl.String(), abi0.String(), reg.String()
+}
+
+func arm64DefinedLaneIR(t *testing.T, triple string) string {
+	t.Helper()
+	decl, _, source := arm64DefinedLaneProgram()
+	pkg := mustGoPackage(t, "test/definedlane", "package definedlane\n"+decl)
+	result, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer result.Module.Dispose()
+	return result.Module.String()
+}
+
+func TestARM64GoRegisterVectorLaneCompleteObjects(t *testing.T) {
+	_, ordinary, _ := arm64DefinedLaneProgram()
+	if bytes := arm64ImmediateOriginalGoBytes(t, ordinary, "linux"); len(bytes) < 4*len(arm64DefinedLaneCases()) {
+		t.Fatal("actual stock Go transfer object was incomplete")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl",
+		"aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "defined-lane.ll", "defined-lane.o", arm64DefinedLaneIR(t, triple))
+		})
+	}
+	// VDUP's separate arranged/scalar rows consume the exact selected span.
+	arm64ImmediateOriginalGoBytes(t, arm64VectorDuplicateForms, "linux")
+}
+
+func TestARM64GoRegisterVectorLaneAllTranslationAPIs(t *testing.T) {
+	const source = "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nVMOV R0,V21.D[1]\nVMOV V21.D[1],R0\nRET\n"
+	pkg := mustGoPackage(t, "test/laneapis", "package laneapis\nfunc Pass(uint64) uint64\n")
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"} {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "arm64", TargetTriple: target, ResolveSym: testResolveSym(pkg.Path)})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer result.Module.Dispose()
+			compileLLVMToObject(t, llc, target, "go-module.ll", "go-module.o", result.Module.String())
+			options := Options{Goarch: "arm64", TargetTriple: target, Sigs: result.Signatures, ResolveSym: testResolveSym(pkg.Path)}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, target, "text.ll", "text.o", ir)
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, target, "module.ll", "module.o", module.String())
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64GoRegisterDefinedVectorLanes(t *testing.T) {
+	llc, triple, compiler, runner := arm64FPPairRuntimeTools(t)
+	decl, original, _ := arm64DefinedLaneProgram()
+	var goChecks, cDecl, cChecks strings.Builder
+	for i, tc := range arm64DefinedLaneCases() {
+		mask := ^uint64(0)
+		if tc.bits < 64 {
+			mask = uint64(1)<<uint(tc.bits) - 1
+		}
+		goWant, cWant := fmt.Sprintf("a&%d", mask), fmt.Sprintf("a & UINT64_C(%d)", mask)
+		if tc.zero {
+			goWant, cWant = "0", "0"
+		}
+		fmt.Fprintf(&goChecks, "if got := Lane%d(a); got != %s { panic(\"Go defined-lane case %d\") }\n", i, goWant, i)
+		fmt.Fprintf(&cDecl, "extern uint64_t Lane%d(uint64_t);\n", i)
+		fmt.Fprintf(&cChecks, "if (Lane%d(a) != (%s)) { fprintf(stderr, \"LLVM lane %d input %%u\\n\", i); return 1; }\n", i, cWant, i)
+	}
+	goMain := "package main\n" + decl + `
+func main() {
+    for _, a := range []uint64{0, 1, 0x123456789abcdef0, 0x8000000000000000, ^uint64(0)} {
+` + goChecks.String() + "\n}\n}\n"
+	// The ordinary caller and the translated register entry use the same lane
+	// instructions but different explicit ABI transports. Neither observation
+	// certifies a third-party caller, memory region or preserved unknown value.
+	runARM64LocalRegisterGoOracle(t, original, goMain, len(runner) != 0, "1.20")
+	cMain := "#include <stdint.h>\n#include <stdio.h>\n" + cDecl.String() + `
+int main(void) {
+    const uint64_t inputs[] = {0, 1, UINT64_C(0x123456789abcdef0),
+        UINT64_C(0x8000000000000000), UINT64_MAX};
+    const volatile uint64_t canary = UINT64_C(0x7498243681789876);
+    for (unsigned i = 0; i < 5; i++) {
+        uint64_t a = inputs[i];
+` + cChecks.String() + `
+    }
+    if (canary != UINT64_C(0x7498243681789876)) return 2;
+    return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "defined_lane", triple, arm64DefinedLaneIR(t, triple), cMain, runner)
+}
diff --git a/arm64_vector_lane_state_test.go b/arm64_vector_lane_state_test.go
new file mode 100644
index 000000000..c151f6701
--- /dev/null
+++ b/arm64_vector_lane_state_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestARM64GoRegisterVectorLaneStateIntersectsAndRevokes(t *testing.T) {
+	write := func(state *arm64MachineState, offset, width int) {
+		t.Helper()
+		if err := state.applyVectorSpan(arm64MachineEffect{register: "V21", vectorOffset: offset, width: width, write: true}); err != nil {
+			t.Fatal(err)
+		}
+	}
+	read := func(state *arm64MachineState, offset, width int, available bool) {
+		t.Helper()
+		err := state.applyVectorSpan(arm64MachineEffect{register: "V21", vectorOffset: offset, width: width})
+		if (err == nil) != available || (!available && !errors.Is(err, ErrProbeNeedsContext)) {
+			t.Fatalf("span [%d,%d) available=%t: %v", offset, offset+width, available, err)
+		}
+	}
+	state := arm64MachineBoundary(nil)
+	write(&state, 64, 64)
+	read(&state, 64, 64, true)
+	read(&state, 0, 64, false)
+	copy := state.clone()
+	write(&copy, 0, 64)
+	if copy.values["V21"] != arm64WholeScalableRegister || state.values["V21"] != 0 {
+		t.Fatal("clone shared a lane mask or a full bank failed to initialize")
+	}
+	if !copy.merge(state) || copy.values["V21"] != 0 {
+		t.Fatal("join did not remove the missing low half")
+	}
+	read(&copy, 64, 64, true)
+	read(&copy, 0, 64, false)
+	if copy.merge(state) {
+		t.Fatal("identical definition merge did not converge")
+	}
+	other := arm64MachineBoundary(nil)
+	write(&other, 0, 64)
+	copy.merge(other)
+	read(&copy, 64, 64, false)
+	read(&copy, 0, 64, false)
+
+	for _, effect := range []arm64MachineEffect{
+		{register: "V21", vectorOffset: -1, width: 1},
+		{register: "V21", vectorOffset: 128, width: 1},
+		{register: "V21", vectorOffset: 127, width: 2},
+		{register: "V21", width: 0},
+		{register: "V21", width: 129},
+		{register: "R21", width: 64},
+	} {
+		if err := state.applyVectorSpan(effect); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("invalid finite vector span accepted: %+v: %v", effect, err)
+		}
+	}
+	for name, revoke := range map[string]arm64MachineEffect{
+		"original scratch invalidation": {register: "V21", unavailable: true},
+		"scalar overwrite":              {register: "V21", width: 32, write: true},
+		"typed call":                    {call: &ARM64GoRegisterABI{}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			flow := &arm64MachineAvailability{used: true, entry: &ARM64GoRegisterABI{}, blocks: []arm64MachineBlock{{name: "entry", effects: []arm64MachineEffect{
+				{register: "V21", vectorOffset: 64, width: 64, write: true, vectorSpan: true},
+				revoke,
+				{register: "V21", vectorOffset: 64, width: 64, vectorSpan: true},
+			}}}}
+			if err := flow.validate(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("replaced or revoked bank retained old lane authority: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm64_vector_memory_indexbyte_test.go b/arm64_vector_memory_indexbyte_test.go
new file mode 100644
index 000000000..84b74532f
--- /dev/null
+++ b/arm64_vector_memory_indexbyte_test.go
@@ -0,0 +1,194 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is a native measurement, not a speed-ratio acceptance gate. Run the
+// exact same command before/after the change on the same ARM64 machine.
+// It translates the complete original SDK file, without a KeepFunc filter or
+// an llgo runtime build whose separate closure-entry boundary is not closed.
+func TestARM64VectorMemoryStdlibIndexByteBenchmark(t *testing.T) {
+	if runtime.GOARCH != "arm64" || runtime.GOOS != "darwin" && runtime.GOOS != "linux" {
+		t.Skip("throughput requires native ARM64; instruction semantics have the required cross-runtime counterpart")
+	}
+	llc, triple, compiler, _ := arm64FPPairRuntimeTools(t)
+	opt := findLLVM22Tool("opt")
+	if opt == "" {
+		t.Fatal("LLVM 22 opt not found")
+	}
+	pkg := arm64BytealgCountSDKPackage(t) // Complete actual bytealg declarations/selection, not copied signatures.
+	filename := filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg", "indexbyte_arm64.s")
+	source, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	translated, err := TranslateGoModule(pkg, source, GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: triple, FileName: "indexbyte_arm64.s",
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := translated.Module.String()
+	translated.Module.Dispose()
+	for _, name := range []string{"IndexByte", "IndexByteString"} {
+		if _, present := translated.Signatures[name]; !present {
+			t.Fatalf("complete original indexbyte file lost %s", name)
+		}
+	}
+	// An explicit scalar LLVM shim avoids borrowing the host C compiler's
+	// aggregate ABI to call the translator's typed Go slice parameter.
+	ir += `
+define i64 @vector_bench_index_byte(ptr %p, i64 %n, i8 %c) {
+  %s0 = insertvalue { ptr, i64, i64 } poison, ptr %p, 0
+  %s1 = insertvalue { ptr, i64, i64 } %s0, i64 %n, 1
+  %s2 = insertvalue { ptr, i64, i64 } %s1, i64 %n, 2
+  %r = call i64 @IndexByte({ ptr, i64, i64 } %s2, i8 %c)
+  ret i64 %r
+}
+`
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"indexbyte.ll": ir, "main.c": arm64VectorMemoryIndexByteC,
+		"go.mod": "module indexbytebenchmark\n\ngo 1.20\n", "main.go": arm64VectorMemoryIndexByteGo,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	run := func(name string, args ...string) {
+		t.Helper()
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		command := exec.CommandContext(ctx, name, args...)
+		command.Dir = dir
+		command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=arm64", "GOOS="+runtime.GOOS)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		if err != nil {
+			t.Fatalf("indexbyte measurement command %s: %v\n%s", name, err, output)
+		}
+		if len(output) != 0 {
+			t.Log(strings.TrimSpace(string(output)))
+		}
+	}
+	t.Logf("temporary diagnostic IR/assembly/objects/executables: %s (automatically cleaned)", dir)
+	optimizedIR := filepath.Join(dir, "indexbyte-optimized.ll")
+	run(opt, "-passes=default<O2>", "-S", filepath.Join(dir, "indexbyte.ll"), "-o", optimizedIR)
+	var llvmExecutables []string
+	for _, pipeline := range []struct{ name, input string }{
+		{"raw-llc-O2", filepath.Join(dir, "indexbyte.ll")},
+		{"optimized-llvm-O2", optimizedIR},
+	} {
+		object := filepath.Join(dir, pipeline.name+".o")
+		executable := filepath.Join(dir, pipeline.name)
+		arguments := []string{"-mtriple=" + triple, "-relocation-model=pic", "-O=2"}
+		run(llc, append(append([]string(nil), arguments...), "-filetype=obj", pipeline.input, "-o", object)...)
+		run(llc, append(append([]string(nil), arguments...), "-filetype=asm", pipeline.input, "-o", filepath.Join(dir, pipeline.name+".s"))...)
+		linkArgs := append(append([]string(nil), compiler[1:]...), "-O2", object, filepath.Join(dir, "main.c"),
+			"-DVECTOR_BENCH_ENGINE=\""+pipeline.name+"\"", "-o", executable)
+		run(compiler[0], linkArgs...)
+		llvmExecutables = append(llvmExecutables, executable)
+	}
+	goExecutable := filepath.Join(dir, "indexbyte-go")
+	run(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=2", "-o", goExecutable, "main.go")
+	t.Logf("actual SDK=%s sourceSHA256=%x; raw=no IR prepass; optimized=opt default<O2>; both llc-O2/C-O2; sizes=1048576 iterations=1024 offsets=0,1,31", runtime.Version(), sha256.Sum256(source))
+	run(goExecutable)
+	for _, executable := range llvmExecutables {
+		run(executable)
+	}
+	after, err := os.ReadFile(filename)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(source) {
+		t.Fatalf("original indexbyte source changed during observation: %v", err)
+	}
+}
+
+const arm64VectorMemoryIndexByteGo = `package main
+
+import (
+	"bytes"
+	"fmt"
+	"time"
+	"unsafe"
+)
+
+func main() {
+	const size = 1 << 20
+	const iterations = 1024
+	storage := make([]byte, size+96)
+	for i := range storage {
+		storage[i] = 0x5a
+	}
+	aligned := int((32 - uintptr(unsafe.Pointer(&storage[0]))%32) % 32)
+	for _, off := range []int{0, 1, 31} {
+		data := storage[aligned+off : aligned+off+size]
+		var checksum int64
+		start := time.Now()
+		for i := 0; i < iterations; i++ {
+			checksum += int64(bytes.IndexByte(data, 0xfe))
+		}
+		elapsed := time.Since(start).Nanoseconds()
+		if checksum != -iterations || elapsed <= 0 {
+			panic("stock Go result/time mismatch")
+		}
+		fmt.Printf("engine=stock-Go size=%d iterations=%d offset=%d ns=%d checksum=%d GB/s=%.3f\n",
+			size, iterations, off, elapsed, checksum, float64(size)*iterations/float64(elapsed))
+	}
+}
+`
+
+const arm64VectorMemoryIndexByteC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#ifndef VECTOR_BENCH_ENGINE
+#error benchmark engine label is required
+#endif
+extern int64_t vector_bench_index_byte(const unsigned char *, int64_t, unsigned char);
+
+static int64_t nanos(void) {
+  struct timespec t;
+  if (clock_gettime(CLOCK_MONOTONIC, &t)) exit(1);
+  return (int64_t)t.tv_sec * 1000000000 + t.tv_nsec;
+}
+
+int main(void) {
+  const unsigned size = 1 << 20, iterations = 1024;
+  unsigned char *storage = malloc(size + 96);
+  if (!storage) return 1;
+  memset(storage, 0x5a, size + 96);
+  unsigned char *aligned = (unsigned char *)(((uintptr_t)storage + 31) & ~(uintptr_t)31);
+  const unsigned offsets[] = {0, 1, 31};
+  for (unsigned i = 0; i < 3; i++) {
+    unsigned off = offsets[i];
+    unsigned char *data = aligned + off;
+    for (unsigned length = 0; length <= 80; length++) {
+      if (vector_bench_index_byte(data, length, 0xfe) != -1) return 1;
+      for (unsigned hit = 0; hit < length; hit++) {
+        data[hit] = 0xfe;
+        if (vector_bench_index_byte(data, length, 0xfe) != (int64_t)hit) return 1;
+        data[hit] = 0x5a;
+      }
+    }
+    int64_t checksum = 0, start = nanos();
+    for (unsigned n = 0; n < iterations; n++) {
+      checksum += vector_bench_index_byte(data, size, 0xfe);
+    }
+    int64_t elapsed = nanos() - start;
+    if (checksum != -(int64_t)iterations || elapsed <= 0) return 1;
+    printf("engine=%s size=%u iterations=%u offset=%u ns=%lld checksum=%lld GB/s=%.3f\n",
+           VECTOR_BENCH_ENGINE, size, iterations, off, (long long)elapsed, (long long)checksum,
+           (double)size * iterations / elapsed);
+  }
+  free(storage);
+  return 0;
+}
+`
diff --git a/arm64_vector_memory_test.go b/arm64_vector_memory_test.go
new file mode 100644
index 000000000..cbd27019e
--- /dev/null
+++ b/arm64_vector_memory_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are Go's C_LIST arrangements, not a projection of the lowerer's table.
+// LD/ST1 concatenate one through four registers; LD/ST2-4 interleave instead.
+var arm64VectorMemoryArrangements = []struct {
+	name        string
+	bits, lanes int
+}{
+	{"B8", 8, 8}, {"B16", 8, 16}, {"H4", 16, 4}, {"H8", 16, 8},
+	{"S2", 32, 2}, {"S4", 32, 4}, {"D1", 64, 1}, {"D2", 64, 2},
+}
+
+func arm64VectorMemoryOperands(bytes, mode int, base string) (suffix, memory string) {
+	switch mode {
+	case 0:
+		return "", "(" + base + ")"
+	case 1:
+		return ".P", fmt.Sprintf("%d(%s)", bytes, base)
+	case 2:
+		return ".P", "(" + base + ")(R7)"
+	default:
+		return ".P", "(" + base + ")" // implicit whole-list byte increment
+	}
+}
+
+func arm64VectorMemoryTranslate(t *testing.T, source, target string, sigs map[string]FuncSig) string {
+	t.Helper()
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: target, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func TestARM64VectorMemoryTypedWholeTransfers(t *testing.T) {
+	// Checking source IR (before optimization) prevents relying on a backend
+	// pass to recover SIMD from dozens of independently emitted byte accesses.
+	// A transfer may not acquire alignment or read beyond its encoded 8/16 bytes.
+	for _, arrangement := range arm64VectorMemoryArrangements {
+		for count := 1; count <= 4; count++ {
+			for mode := 0; mode < 4; mode++ {
+				name := fmt.Sprintf("%s/list%d/mode%d", arrangement.name, count, mode)
+				t.Run(name, func(t *testing.T) {
+					width := arrangement.bits * arrangement.lanes / 8
+					registers := arm64TestVectorList(30, count, arrangement.name)
+					loadSuffix, input := arm64VectorMemoryOperands(count*width, mode, "R0")
+					storeSuffix, output := arm64VectorMemoryOperands(count*width, mode, "R1")
+					source := fmt.Sprintf("TEXT vectorcopy(SB),$0-0\nVLD1%s %s,%s\nVST1%s %s,%s\nRET\n",
+						loadSuffix, input, registers, storeSuffix, registers, output)
+					ir := arm64VectorMemoryTranslate(t, source, "aarch64-unknown-linux-gnu",
+						map[string]FuncSig{"vectorcopy": {Name: "vectorcopy", Ret: Void}})
+					arm64VectorMemoryCheckAccesses(t, ir, "vectorcopy", arrangement.bits, arrangement.lanes, count)
+				})
+			}
+		}
+	}
+}
+
+func TestARM64VectorMemoryLaneAccessesStayExact(t *testing.T) {
+	for _, bits := range []int{8, 16, 32, 64} {
+		kind := map[int]string{8: "B", 16: "H", 32: "S", 64: "D"}[bits]
+		for lane := 0; lane < 128/bits; lane++ {
+			for mode := 0; mode < 3; mode++ {
+				t.Run(fmt.Sprintf("%s/lane%d/mode%d", kind, lane, mode), func(t *testing.T) {
+					suffix, input := arm64VectorMemoryOperands(bits/8, mode, "R0")
+					_, output := arm64VectorMemoryOperands(bits/8, mode, "R1")
+					source := fmt.Sprintf("TEXT vectorlane(SB),$0-0\nVLD1%s %s,V30.%s[%d]\nVST1%s V30.%s[%d],%s\nRET\n",
+						suffix, input, kind, lane, suffix, kind, lane, output)
+					ir := arm64VectorMemoryTranslate(t, source, "aarch64-unknown-linux-gnu",
+						map[string]FuncSig{"vectorlane": {Name: "vectorlane", Ret: Void}})
+					arm64VectorMemoryCheckAccesses(t, ir, "vectorlane", bits, 0, 1)
+				})
+			}
+		}
+	}
+}
+
+func arm64VectorMemoryCheckAccesses(t *testing.T, ir, name string, bits, lanes, count int) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	function := module.NamedFunction(name)
+	if function.IsNil() || function.FirstBasicBlock().IsNil() {
+		t.Fatal("original memory-transfer function disappeared", name)
+	}
+	loads, stores := 0, 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+			var pointer llvm.Value
+			var typ llvm.Type
+			switch ins.InstructionOpcode() {
+			case llvm.Load:
+				pointer, typ = ins.Operand(0), ins.Type()
+			case llvm.Store:
+				pointer, typ = ins.Operand(1), ins.Operand(0).Type()
+			default:
+				continue
+			}
+			// Register banks and FLAGS are implementation allocas, not native
+			// memory accesses. Follow only pointer-preserving derivations.
+			for depth := 0; depth < 16 && (!pointer.IsAGetElementPtrInst().IsNil() || !pointer.IsABitCastInst().IsNil()); depth++ {
+				pointer = pointer.Operand(0)
+			}
+			if pointer.IsAIntToPtrInst().IsNil() {
+				continue
+			}
+			if ins.InstructionOpcode() == llvm.Load {
+				loads++
+			} else {
+				stores++
+			}
+			if ins.Alignment() != 1 {
+				t.Errorf("native transfer acquired unsupported alignment: %s", ins.String())
+			}
+			if lanes != 0 {
+				if typ.TypeKind() != llvm.VectorTypeKind || typ.VectorSize() != lanes {
+					t.Errorf("whole transfer is not one exact %d-lane vector: %s", lanes, ins.String())
+					continue
+				}
+				typ = typ.ElementType()
+			}
+			if typ.TypeKind() != llvm.IntegerTypeKind || typ.IntTypeWidth() != bits {
+				t.Errorf("native transfer lost its exact i%d element width: %s", bits, ins.String())
+			}
+		}
+	}
+	if loads != count || stores != count {
+		t.Errorf("native accesses: loads=%d stores=%d, want %d/%d", loads, stores, count, count)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARM64VectorMemorySemantics(t *testing.T) {
+	// The shared helper executes natively on Linux/Darwin ARM64, or in the
+	// mandatory Linux/amd64 cross matrix. Other hosts retain explicit SKIP.
+	llc, target, compiler, runner := arm64FPPairRuntimeTools(t)
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	index := 0
+	for _, arrangement := range arm64VectorMemoryArrangements {
+		for count := 1; count <= 4; count++ {
+			for mode := 0; mode < 4; mode++ {
+				width := arrangement.bits * arrangement.lanes / 8
+				name := fmt.Sprintf("vector_memory_%d", index)
+				index++
+				registers := arm64TestVectorList(30, count, arrangement.name)
+				suffix, input := arm64VectorMemoryOperands(count*width, mode, "R0")
+				_, output := arm64VectorMemoryOperands(count*width, mode, "R1")
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-0\nMOVD $%d,R7\n", name, count*width+5)
+				if width == 8 {
+					// Seed every upper byte so preserving an old half cannot
+					// impersonate the Q=0 load's required upper-half clearing.
+					for register := 0; register < count; register++ {
+						fmt.Fprintf(&source, "VMOVI $0xa5,V%d.B16\n", (30+register)%32)
+					}
+				}
+				fmt.Fprintf(&source, "VLD1%s %s,%s\nVST1%s %s,%s\n", suffix, input, registers, suffix, registers, output)
+				fmt.Fprint(&source, "MOVD R0,0(R2)\nMOVD R1,8(R2)\nADD $16,R2,R3\n")
+				fmt.Fprintf(&source, "VST1 %s,(R3)\nRET\n", arm64TestVectorList(30, count, "B16"))
+				sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void, ArgRegs: []Reg{"R0", "R1", "R2"}}
+				fmt.Fprintf(&declarations, "extern void %s(const unsigned char *,unsigned char *,void *);\n", name)
+				fmt.Fprintf(&checks, "if(check(%s,%d,%d,%d)) return 1;\n", name, width, count, mode)
+			}
+		}
+	}
+	// The independent scalar C reference observes every byte, inactive upper
+	// halves, wrapping register lists, post-index bases and store canaries.
+	// Protected pages additionally reject widening the encoded read or write.
+	main := arm64VectorMemoryCOracle + declarations.String() + "int main(void){\n" + checks.String() + "return 0;\n}\n"
+	ir := arm64VectorMemoryTranslate(t, source.String(), target, sigs)
+	for _, optimization := range []int{0, 2} {
+		t.Run(fmt.Sprintf("O%d", optimization), func(t *testing.T) {
+			compileAndRunRuntimeTestWithCompiler(t, llc, compiler, "vector_memory", target, ir, main, runner, optimization)
+		})
+	}
+}
+
+const arm64VectorMemoryCOracle = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+typedef void (*transfer)(const unsigned char *,unsigned char *,void *);
+struct observed { uintptr_t input, output; unsigned char vectors[64]; };
+static int one(transfer fn,const unsigned char *in,unsigned char *out,
+               unsigned width,unsigned count,unsigned mode) {
+  struct observed observed;
+  memset(&observed,0xa5,sizeof(observed));
+  fn(in,out,&observed);
+  unsigned size=width*count;
+  unsigned increment=mode==0?0:mode==2?size+5:size;
+  if(observed.input!=(uintptr_t)in+increment || observed.output!=(uintptr_t)out+increment) {
+    fprintf(stderr,"writeback width/count/mode %u/%u/%u\n",width,count,mode); return 1;
+  }
+  if(memcmp(in,out,size)) { fprintf(stderr,"byte-order/copy mismatch\n"); return 1; }
+  for(unsigned reg=0;reg<count;reg++) for(unsigned byte=0;byte<16;byte++) {
+    unsigned char want=byte<width?in[reg*width+byte]:0;
+    if(observed.vectors[reg*16+byte]!=want) {
+      fprintf(stderr,"lane/upper-half mismatch %u/%u/%u/%u/%u\n",width,count,mode,reg,byte); return 1;
+    }
+  }
+  return 0;
+}
+static int check(transfer fn,unsigned width,unsigned count,unsigned mode) {
+  unsigned char input[192],snapshot[192],output[192];
+  for(unsigned trial=0;trial<16;trial++) for(unsigned off=0;off<16;off++) {
+    for(unsigned i=0;i<192;i++) input[i]=(unsigned char)(i*71+trial*53+19);
+    memcpy(snapshot,input,192); memset(output,0xa5,192);
+    if(one(fn,input+32+off,output+32+off,width,count,mode)) return 1;
+    if(memcmp(input,snapshot,192)) return 1;
+    for(unsigned i=0;i<192;i++) if((i<32+off || i>=32+off+width*count) && output[i]!=0xa5) {
+      fprintf(stderr,"store canary changed\n"); return 1;
+    }
+  }
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<=0) return 1;
+  unsigned char *a=mmap(0,(size_t)page*3,PROT_NONE,MAP_PRIVATE|MAP_ANON,-1,0);
+  unsigned char *b=mmap(0,(size_t)page*3,PROT_NONE,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(a==MAP_FAILED || b==MAP_FAILED) return 1;
+  if(mprotect(a+page,(size_t)page,PROT_READ|PROT_WRITE) || mprotect(b+page,(size_t)page,PROT_READ|PROT_WRITE)) return 1;
+  unsigned size=width*count;
+  unsigned char *in=a+2*page-size,*out=b+2*page-size;
+  for(unsigned i=0;i<size;i++) in[i]=(unsigned char)(i*37+11);
+  int failed=one(fn,in,out,width,count,mode);
+  if(munmap(a,(size_t)page*3) || munmap(b,(size_t)page*3)) return 1;
+  return failed;
+}
+`
diff --git a/arm64_vector_shift_forms.go b/arm64_vector_shift_forms.go
new file mode 100644
index 000000000..2dfd2701c
--- /dev/null
+++ b/arm64_vector_shift_forms.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64VectorShiftRightSpec struct {
+	signed, rounding, accumulate bool
+}
+
+var arm64VectorShiftRightSpecs = map[Op]arm64VectorShiftRightSpec{
+	"VSSHR": {signed: true}, "VSSRA": {signed: true, accumulate: true},
+	"VSRSHR": {signed: true, rounding: true}, "VSRSRA": {signed: true, rounding: true, accumulate: true},
+	"VUSHR": {}, "VUSRA": {accumulate: true},
+	"VURSHR": {rounding: true}, "VURSRA": {rounding: true, accumulate: true},
+}
+
+type arm64VectorShiftForm struct {
+	arrangement         arm64VectorArrangement
+	source, destination Reg
+	shift               int64
+	scalar              bool
+}
+
+func parseARM64VectorShift(op Op, ins Instr) (arm64VectorShiftForm, error) {
+	f := arm64VectorShiftForm{}
+	_, right := arm64VectorShiftRightSpecs[op]
+	if (op != "VSHL" && !right) || !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat ||
+		ins.Args[1].Kind != OpReg || ins.Args[2].Kind != OpReg {
+		return f, fmt.Errorf("arm64 %s expects a resolved integer shift and matching vector operands: %q", op, ins.Raw)
+	}
+	f.source, f.destination, f.shift = ins.Args[1].Reg, ins.Args[2].Reg, ins.Args[0].Imm
+	source, sourceValid := parseARM64VectorArrangement(f.source)
+	destination, destinationValid := parseARM64VectorArrangement(f.destination)
+	f.scalar = right && !strings.Contains(string(f.source), ".") && !strings.Contains(string(f.destination), ".")
+	if f.scalar {
+		_, sourceValid = arm64ParseVReg(f.source)
+		_, destinationValid = arm64ParseVReg(f.destination)
+		source = arm64VectorArrangement{elementBits: 64, lanes: 1}
+		destination = source
+	}
+	if !sourceValid || !destinationValid || source != destination || !f.scalar && !arm64VDUPArrangementAllowed(source) {
+		return f, fmt.Errorf("arm64 %s requires matching Go vector arrangements: %q", op, ins.Raw)
+	}
+	minimum, maximum := int64(0), int64(source.elementBits-1)
+	if right {
+		minimum, maximum = 1, int64(source.elementBits)
+	}
+	if f.shift < minimum || f.shift > maximum {
+		return f, fmt.Errorf("arm64 %s shift must be in [%d,%d]: %q", op, minimum, maximum, ins.Raw)
+	}
+	f.arrangement = source
+	return f, nil
+}
diff --git a/arm64_vector_transfer_forms.go b/arm64_vector_transfer_forms.go
new file mode 100644
index 000000000..807b93bc6
--- /dev/null
+++ b/arm64_vector_transfer_forms.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type arm64VectorTransferForm struct {
+	source, destination Reg
+	bits, lanes         int
+	sourceLane          int
+	destinationLane     int
+	sourceGP            bool
+	destinationGP       bool
+	splat               bool
+	copy                bool
+	preserve            bool
+}
+
+// VMOV's six rows and VDUP's three rows are distinct operand classes. The
+// physical element width of VDUP's arranged destination selects its source
+// lane width, including the mixed-suffix spellings accepted by Go case 79.
+func parseARM64VectorTransfer(op Op, ins Instr) (arm64VectorTransferForm, error) {
+	f := arm64VectorTransferForm{}
+	invalid := func() (arm64VectorTransferForm, error) {
+		return f, fmt.Errorf("arm64 %s operands are outside the complete Go vector transfer rows: %q", op, ins.Raw)
+	}
+	if (op != "VMOV" && op != "VDUP") || !strings.EqualFold(string(ins.Op), string(op)) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpReg {
+		return invalid()
+	}
+	f.source, f.destination = ins.Args[0].Reg, ins.Args[1].Reg
+	sourceKind, sourceLane, sourceElement := arm64ParseVRegLane(f.source)
+	destinationKind, destinationLane, destinationElement := arm64ParseVRegLane(f.destination)
+	_, sourceVector := arm64ParseVReg(f.source)
+	_, destinationVector := arm64ParseVReg(f.destination)
+	destination, arranged := parseARM64VectorArrangement(f.destination)
+	bits := func(kind byte) int {
+		switch kind {
+		case 'B':
+			return 8
+		case 'H':
+			return 16
+		case 'S':
+			return 32
+		case 'D':
+			return 64
+		}
+		return 0
+	}
+	if op == "VDUP" {
+		if arranged {
+			// Go case79 checks the index against the destination's physical
+			// width. The source suffix is an ELEM class, not its lane bound.
+			sourceLane, sourceElement = arm64VDUPPhysicalLaneIndex(f.source)
+		}
+		if sourceElement && sourceVector {
+			f.bits, f.sourceLane = bits(sourceKind), sourceLane
+			if arranged && arm64VDUPArrangementAllowed(destination) {
+				f.bits, f.lanes, f.splat = destination.elementBits, destination.lanes, true
+				if sourceLane < 128/f.bits {
+					return f, nil
+				}
+			} else if destinationVector && !strings.Contains(string(f.destination), ".") {
+				f.lanes = 1
+				return f, nil
+			}
+			return invalid()
+		}
+		if isARM64GeneralOrZeroReg(f.source) && arranged && arm64VDUPArrangementAllowed(destination) {
+			f.bits, f.lanes, f.sourceGP, f.splat = destination.elementBits, destination.lanes, true, true
+			return f, nil
+		}
+		return invalid()
+	}
+	if sourceElement && sourceVector {
+		f.bits, f.sourceLane = bits(sourceKind), sourceLane
+		switch {
+		case destinationElement && destinationVector && sourceKind == destinationKind:
+			f.destinationLane, f.preserve, f.lanes = destinationLane, true, 1
+		case isARM64GeneralOrZeroReg(f.destination):
+			f.destinationGP, f.lanes = true, 1
+		case destinationVector && !strings.Contains(string(f.destination), "."):
+			f.lanes = 1
+		default:
+			return invalid()
+		}
+		return f, nil
+	}
+	if isARM64GeneralOrZeroReg(f.source) {
+		f.sourceGP = true
+		if destinationElement && destinationVector {
+			f.bits, f.destinationLane, f.preserve, f.lanes = bits(destinationKind), destinationLane, true, 1
+			return f, nil
+		}
+		if arranged && arm64VDUPArrangementAllowed(destination) {
+			f.bits, f.lanes, f.splat = destination.elementBits, destination.lanes, true
+			return f, nil
+		}
+		return invalid()
+	}
+	source, sourceArranged := parseARM64VectorArrangement(f.source)
+	if sourceVector && destinationVector && sourceArranged && arranged && source == destination &&
+		source.elementBits == 8 && (source.lanes == 8 || source.lanes == 16) {
+		f.bits, f.lanes, f.copy = 8, source.lanes, true
+		return f, nil
+	}
+	return invalid()
+}
+
+// This syntax-only element parser is restricted to VDUP's arranged case79.
+// VMOV and scalar VDUP retain their own suffix-selected lane bounds.
+func arm64VDUPPhysicalLaneIndex(reg Reg) (int, bool) {
+	if _, valid := arm64ParseVReg(reg); !valid {
+		return 0, false
+	}
+	text := strings.ToUpper(strings.TrimSpace(string(reg)))
+	dot := strings.IndexByte(text, '.')
+	if dot < 0 {
+		return 0, false
+	}
+	suffix := text[dot+1:]
+	if len(suffix) < 4 || !strings.ContainsRune("BHSD", rune(suffix[0])) || suffix[1] != '[' || suffix[len(suffix)-1] != ']' {
+		return 0, false
+	}
+	index, valid := arm64ParseLaneDecimalToken(suffix[2 : len(suffix)-1])
+	return index, valid && index < 16
+}
diff --git a/arm_blocks.go b/arm_blocks.go
index ff67347d5..0af92f413 100644
--- a/arm_blocks.go
+++ b/arm_blocks.go
@@ -6,8 +6,9 @@ import (
 )
 
 type armBlock struct {
-	name   string
-	instrs []Instr
+	name      string
+	instrs    []Instr
+	synthetic bool
 }
 
 var armCondCodes = map[string]bool{
@@ -31,13 +32,14 @@ var armCondCodes = map[string]bool{
 }
 
 func armSplitBlocks(fn Func) []armBlock {
-	blocks := []armBlock{{name: "entry"}}
+	names := newAssemblyBlockNames(fn)
+	blocks := []armBlock{{name: names.fresh("entry"), synthetic: true}}
 	cur := 0
 	anon := 0
 
 	startAnon := func() {
 		anon++
-		blocks = append(blocks, armBlock{name: fmt.Sprintf("anon_%d", anon)})
+		blocks = append(blocks, armBlock{name: names.fresh(fmt.Sprintf("anon_%d", anon)), synthetic: true})
 		cur = len(blocks) - 1
 	}
 
@@ -90,8 +92,9 @@ func armSplitBlocks(fn Func) []armBlock {
 	for _, ins := range fn.Instrs {
 		if ins.Op == OpLABEL && len(ins.Args) == 1 && ins.Args[0].Kind == OpLabel {
 			lbl := ins.Args[0].Sym
-			if len(blocks[cur].instrs) == 0 && strings.HasPrefix(blocks[cur].name, "anon_") {
+			if cur != 0 && len(blocks[cur].instrs) == 0 && blocks[cur].synthetic {
 				blocks[cur].name = lbl
+				blocks[cur].synthetic = false
 				continue
 			}
 			blocks = append(blocks, armBlock{name: lbl})
@@ -109,7 +112,7 @@ func armSplitBlocks(fn Func) []armBlock {
 		}
 	}
 
-	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && strings.HasPrefix(blocks[len(blocks)-1].name, "anon_") {
+	if len(blocks) > 1 && len(blocks[len(blocks)-1].instrs) == 0 && blocks[len(blocks)-1].synthetic {
 		blocks = blocks[:len(blocks)-1]
 	}
 	return blocks
@@ -161,7 +164,7 @@ func armDecodeOp(raw string) (base string, cond string, postInc bool, setFlags b
 	base = parts[0]
 	for _, p := range parts[1:] {
 		switch p {
-		case "P":
+		case "P", "PW", "WP":
 			postInc = true
 		case "S":
 			setFlags = true
diff --git a/arm_caller_sp_test.go b/arm_caller_sp_test.go
new file mode 100644
index 000000000..0594c97c7
--- /dev/null
+++ b/arm_caller_sp_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestTranslateARMCallerSPPseudoAddress(t *testing.T) {
+	src := `TEXT callerSP(SB),NOSPLIT,$8-0
+	MOVW $sp-4(FP), R7
+	RET
+`
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv5te-unknown-linux-gnueabi",
+		Sigs: map[string]FuncSig{
+			"callerSP": {Name: "callerSP", Ret: Void},
+		},
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("caller-SP address without typed backing must retain context failure: %v", err)
+	}
+}
+
+func TestTranslateARMCallerSPPseudoAddressRejectsOtherOffsets(t *testing.T) {
+	src := "TEXT callerSP(SB),NOSPLIT,$8-0\n\tMOVW $sp-8(FP), R7\n\tRET\n"
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv5te-unknown-linux-gnueabi",
+		Sigs: map[string]FuncSig{
+			"callerSP": {Name: "callerSP", Ret: Void},
+		},
+	}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unknown caller-SP offset must retain context failure: %v", err)
+	}
+}
diff --git a/arm_conditional_flags_runtime_test.go b/arm_conditional_flags_runtime_test.go
new file mode 100644
index 000000000..052126155
--- /dev/null
+++ b/arm_conditional_flags_runtime_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMConditionalFlags(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for actual ARM predicated-flags execution")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM conditional-flags oracle requires a Linux driver")
+	}
+	for _, tool := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT conditional(SB),4,$0-8\n MOVW out+4(FP),R4\n")
+	for index, instruction := range []string{
+		"CMP.NE $1,R0", "CMN.NE $1,R0", "TST.NE $1,R0", "TEQ.NE $1,R0",
+		"ADD.EQ.S $1,R0", "ORR.EQ.S $0x80000000,R0", "MOVW.EQ.S R0,R2",
+		"MOVW $0,R0\n CMP $1,R0\n ORR.S $0x80000000,R0", "AND.EQ.S $0x7fffffff,R0",
+		"TST $0x40000000,R0", "TEQ $0x40000000,R0",
+	} {
+		fmt.Fprintf(&source, " MOVW value+0(FP),R0\n CMP R0,R0\n %s\n MOVW CPSR,R1\n SRL $28,R1\n MOVW R1,%d(R4)\n", instruction, index*4)
+	}
+	source.WriteString(" RET\n")
+	const main = `package main
+import "fmt"
+func conditional(value uint32,out *[11]uint32)
+func main() {
+ inputs := [...]uint32{0,1,0x7fffffff,0x80000000,0xffffffff}
+ additions := [...]uint32{0,0,9,8,6}
+ moves := [...]uint32{6,2,2,10,10}
+ complements := [...]uint32{6,2,2,6,2}
+ tests := [...]uint32{4,4,0,4,0}
+ exclusive := [...]uint32{0,0,0,8,8}
+ for i,value := range inputs {
+  var out [11]uint32
+  conditional(value,&out)
+  want := [11]uint32{6,6,6,6,additions[i],10,moves[i],10,complements[i],tests[i],exclusive[i]}
+  if out != want { panic(fmt.Sprintf("Go predicated flags input=%x got=%v want=%v",value,out,want)) }
+ }
+ fmt.Println("Go CMP/CMN/TST/TEQ false predicates and ADD/ORR single-decision flag writes passed")
+}
+`
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module armpredicateoracle\n\ngo 1.20\n", "main.go": main,
+		"oracle_arm.s": strings.Replace(source.String(), "TEXT conditional(", "TEXT ·conditional(", 1),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM predicated-flags oracle: %v\n%s", err, output)
+	} else {
+		t.Logf("actual Go oracle: %s", output)
+	}
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+		"conditional": {Name: "conditional", Args: []LLVMType{I32, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1},
+		}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const oracle = `#include <stdint.h>
+#include <stdio.h>
+extern void conditional(uint32_t,uint32_t*);
+int main(void) {
+ const uint32_t inputs[]={0,1,0x7fffffffu,0x80000000u,0xffffffffu},additions[]={0,0,9,8,6};
+ const uint32_t moves[]={6,2,2,10,10},complements[]={6,2,2,6,2},tests[]={4,4,0,4,0},exclusive[]={0,0,0,8,8};
+ for (unsigned i=0;i<5;i++) {
+  uint32_t out[11]={0},want[]={6,6,6,6,additions[i],10,moves[i],10,complements[i],tests[i],exclusive[i]};
+  conditional(inputs[i],out);
+  for (unsigned j=0;j<11;j++) if(out[j]!=want[j]) {
+   fprintf(stderr,"LLVM predicated flags input=%x lane=%u got=%x want=%x\n",inputs[i],j,out[j],want[j]);return 1;
+  }
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "conditional_flags", "armv7-unknown-linux-gnueabihf", ir, oracle,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_ctx.go b/arm_ctx.go
index 650be718e..6ace6e434 100644
--- a/arm_ctx.go
+++ b/arm_ctx.go
@@ -27,6 +27,13 @@ type armCtx struct {
 	flagsCSlot   string
 	flagsVSlot   string
 	flagsWritten bool
+	// Emission traversal only, never a source/CFG authority. Raw compare does
+	// not write virtual APSR; its closed VMRS continuation performs that copy.
+	vfpCompareWritten bool
+
+	// Only a validated physical entry shim supplies this private body input.
+	// It never changes the source entry's caller-visible arguments.
+	machineState string
 
 	exclusiveValidSlot string
 	exclusivePtrSlot   string
@@ -81,7 +88,7 @@ func (c *armCtx) newTmp() string {
 }
 
 func (c *armCtx) slotName(r Reg) string {
-	return "%" + armLLVMBlockName("reg_"+string(r))
+	return "%reg_" + amd64LLVMSafeName(string(r))
 }
 
 func (c *armCtx) scanUsedRegs() {
@@ -106,6 +113,10 @@ func (c *armCtx) scanUsedRegs() {
 		case OpMem:
 			markReg(op.Mem.Base)
 			markReg(op.Mem.Index)
+			if shift, ok := armMemoryShift(op.Mem); ok {
+				markReg(shift.Reg)
+				markReg(shift.ShiftReg)
+			}
 		case OpRegList:
 			for _, r := range op.RegList {
 				markReg(r)
@@ -114,6 +125,253 @@ func (c *armCtx) scanUsedRegs() {
 	}
 	for _, blk := range c.blocks {
 		for _, ins := range blk.instrs {
+			op, _, _, _ := armDecodeOp(string(ins.Op))
+			if form, handled, err := parseARMWordFloatConversion(op, ins); handled && err == nil && form.usesScratch() {
+				markReg("F15")
+			}
+			if ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm {
+				if structure, ok := decodeARMRawNEONStructureFourMultiple(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", structure.base)))
+					if structure.offset != 13 && structure.offset != 15 {
+						markReg(Reg(fmt.Sprintf("R%d", structure.offset)))
+					}
+					for index := 0; index < 4; index++ {
+						markReg(armRawVFPBackingReg(structure.first+index*structure.stride, 64))
+					}
+				}
+				if immediate, ok := decodeARMRawNEONModifiedImmediate(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(immediate.destination, 64))
+					if immediate.quad {
+						markReg(armRawVFPBackingReg(immediate.destination+1, 64))
+					}
+				}
+				if move, ok := decodeARMRawNEONCoreLaneMove(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", move.core)))
+					markReg(armRawVFPBackingReg(move.vector, 64))
+				}
+				if structure, ok := decodeARMRawNEONStructureOneLane(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", structure.base)))
+					if structure.offset != 13 && structure.offset != 15 {
+						markReg(Reg(fmt.Sprintf("R%d", structure.offset)))
+					}
+					markReg(armRawVFPBackingReg(structure.first, 64))
+				}
+				if structure, ok := decodeARMRawNEONStructureFourLane(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", structure.base)))
+					if structure.offset != 13 && structure.offset != 15 {
+						markReg(Reg(fmt.Sprintf("R%d", structure.offset)))
+					}
+					for index := 0; index < 4; index++ {
+						markReg(armRawVFPBackingReg(structure.first+index*structure.stride, 64))
+					}
+				}
+				if transpose, ok := decodeARMRawNEONTranspose(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(transpose.first, 64))
+					markReg(armRawVFPBackingReg(transpose.second, 64))
+					if transpose.quad {
+						markReg(armRawVFPBackingReg(transpose.first+1, 64))
+						markReg(armRawVFPBackingReg(transpose.second+1, 64))
+					}
+				}
+				if narrow, ok := decodeARMRawNEONShiftRightNarrow(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(narrow.source, 64))
+					markReg(armRawVFPBackingReg(narrow.source+1, 64))
+					markReg(armRawVFPBackingReg(narrow.destination, 64))
+				}
+				if clear, ok := decodeARMRawNEONBitClearImmediate(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(clear.destination, 64))
+					if clear.quad {
+						markReg(armRawVFPBackingReg(clear.destination+1, 64))
+					}
+				}
+				if extract, ok := decodeARMRawNEONExtract(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(extract.lhs, 64))
+					markReg(armRawVFPBackingReg(extract.rhs, 64))
+					markReg(armRawVFPBackingReg(extract.destination, 64))
+					if extract.quad {
+						markReg(armRawVFPBackingReg(extract.lhs+1, 64))
+						markReg(armRawVFPBackingReg(extract.rhs+1, 64))
+						markReg(armRawVFPBackingReg(extract.destination+1, 64))
+					}
+				}
+				if narrow, ok := decodeARMRawNEONMoveNarrow(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(narrow.source, 64))
+					markReg(armRawVFPBackingReg(narrow.source+1, 64))
+					markReg(armRawVFPBackingReg(narrow.destination, 64))
+				}
+				if insert, ok := decodeARMRawNEONShiftInsert(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(insert.source, 64))
+					markReg(armRawVFPBackingReg(insert.destination, 64))
+					if insert.quad {
+						markReg(armRawVFPBackingReg(insert.source+1, 64))
+						markReg(armRawVFPBackingReg(insert.destination+1, 64))
+					}
+				}
+				if shift, ok := decodeARMRawNEONShiftRightImmediate(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(shift.source, 64))
+					markReg(armRawVFPBackingReg(shift.destination, 64))
+					if shift.quad {
+						markReg(armRawVFPBackingReg(shift.source+1, 64))
+						markReg(armRawVFPBackingReg(shift.destination+1, 64))
+					}
+				}
+				if reverse, ok := decodeARMRawNEONReverse(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(reverse.source, 64))
+					markReg(armRawVFPBackingReg(reverse.destination, 64))
+					if reverse.quad {
+						markReg(armRawVFPBackingReg(reverse.source+1, 64))
+						markReg(armRawVFPBackingReg(reverse.destination+1, 64))
+					}
+				}
+				if multiply, ok := decodeARMRawNEONMultiplyLongLane(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(multiply.lhs, 64))
+					markReg(armRawVFPBackingReg(multiply.scalar, 64))
+					markReg(armRawVFPBackingReg(multiply.destination, 64))
+					markReg(armRawVFPBackingReg(multiply.destination+1, 64))
+				}
+				if multiply, ok := decodeARMRawNEONMultiplyLongVector(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(multiply.lhs, 64))
+					markReg(armRawVFPBackingReg(multiply.rhs, 64))
+					markReg(armRawVFPBackingReg(multiply.destination, 64))
+					markReg(armRawVFPBackingReg(multiply.destination+1, 64))
+				}
+				if arithmetic, ok := decodeARMRawNEONAddSub(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(arithmetic.lhs, 64))
+					markReg(armRawVFPBackingReg(arithmetic.rhs, 64))
+					markReg(armRawVFPBackingReg(arithmetic.destination, 64))
+					if arithmetic.quad {
+						markReg(armRawVFPBackingReg(arithmetic.lhs+1, 64))
+						markReg(armRawVFPBackingReg(arithmetic.rhs+1, 64))
+						markReg(armRawVFPBackingReg(arithmetic.destination+1, 64))
+					}
+				}
+				if transfer, ok := decodeARMRawVFPLoadStore(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", transfer.base)))
+					markReg(armRawVFPBackingReg(transfer.register, transfer.bits))
+				}
+				if shift, ok := decodeARMRawNEONShiftImmediate(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(shift.source, 64))
+					markReg(armRawVFPBackingReg(shift.destination, 64))
+					if shift.quad {
+						markReg(armRawVFPBackingReg(shift.source+1, 64))
+						markReg(armRawVFPBackingReg(shift.destination+1, 64))
+					}
+				}
+				if move, ok := decodeARMRawVFPMove(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(move.source, move.bits))
+					markReg(armRawVFPBackingReg(move.destination, move.bits))
+				}
+				if pairwise, ok := decodeARMRawNEONPairwiseMinMax(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(pairwise.lhs, 64))
+					markReg(armRawVFPBackingReg(pairwise.rhs, 64))
+					markReg(armRawVFPBackingReg(pairwise.destination, 64))
+				}
+				if minmax, ok := decodeARMRawNEONMinMax(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(minmax.lhs, 64))
+					markReg(armRawVFPBackingReg(minmax.rhs, 64))
+					markReg(armRawVFPBackingReg(minmax.destination, 64))
+					if minmax.quad {
+						markReg(armRawVFPBackingReg(minmax.lhs+1, 64))
+						markReg(armRawVFPBackingReg(minmax.rhs+1, 64))
+						markReg(armRawVFPBackingReg(minmax.destination+1, 64))
+					}
+				}
+				if status, ok := decodeARMRawVFPStatusTransfer(uint32(ins.Args[0].Imm)); ok && !status.toFlags {
+					markReg(Reg(fmt.Sprintf("R%d", status.core)))
+				}
+				if arithmetic, ok := decodeARMRawVFPScalarArithmetic(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(arithmetic.lhs, arithmetic.bits))
+					markReg(armRawVFPBackingReg(arithmetic.rhs, arithmetic.bits))
+					markReg(armRawVFPBackingReg(arithmetic.destination, arithmetic.bits))
+				}
+				if multiply, ok := decodeARMRawNEONMultiplyLane(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(multiply.scalar, 64))
+					markReg(armRawVFPBackingReg(multiply.lhs, 64))
+					markReg(armRawVFPBackingReg(multiply.destination, 64))
+					if multiply.quad {
+						markReg(armRawVFPBackingReg(multiply.lhs+1, 64))
+						markReg(armRawVFPBackingReg(multiply.destination+1, 64))
+					}
+				}
+				if conversion, ok := decodeARMRawNEONConvertFloat32(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(conversion.source, 64))
+					markReg(armRawVFPBackingReg(conversion.destination, 64))
+					if conversion.quad {
+						markReg(armRawVFPBackingReg(conversion.source+1, 64))
+						markReg(armRawVFPBackingReg(conversion.destination+1, 64))
+					}
+				}
+				if moveLong, ok := decodeARMRawNEONMoveLong(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(moveLong.source, 64))
+					markReg(armRawVFPBackingReg(moveLong.destination, 64))
+					markReg(armRawVFPBackingReg(moveLong.destination+1, 64))
+				}
+				if widening, ok := decodeARMRawNEONWideningAddSub(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(widening.lhs, 64))
+					markReg(armRawVFPBackingReg(widening.rhs, 64))
+					markReg(armRawVFPBackingReg(widening.destination, 64))
+					markReg(armRawVFPBackingReg(widening.destination+1, 64))
+				}
+				if duplicate, ok := decodeARMRawNEONDup(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", duplicate.core)))
+					markReg(armRawVFPBackingReg(duplicate.destination, 64))
+					if duplicate.quad {
+						markReg(armRawVFPBackingReg(duplicate.destination+1, 64))
+					}
+				}
+				if immediate, ok := decodeARMRawVFPImmediate(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(immediate.destination, immediate.bits))
+				}
+				if decoded, err := decodeARMRawWordInstruction(ins); err == nil {
+					for _, op := range decoded.Args {
+						markOp(op)
+						if single, ok := armSingleOperandNumber(op); ok {
+							markReg(armRawVFPBackingReg(single, 32))
+						}
+					}
+				}
+				if compare, ok := decodeARMRawVFPCompare(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(compare.lhs, compare.bits))
+					if !compare.zeroRHS {
+						markReg(armRawVFPBackingReg(compare.rhs, compare.bits))
+					}
+				}
+				if pair, ok := decodeARMRawVMOVPair(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", pair.firstCore)))
+					markReg(Reg(fmt.Sprintf("R%d", pair.secondCore)))
+					if pair.double {
+						markReg(armRawVFPBackingReg(pair.firstDouble, 64))
+					} else {
+						markReg(armRawVFPBackingReg(pair.firstSingle, 32))
+						markReg(armRawVFPBackingReg(pair.firstSingle+1, 32))
+					}
+				}
+				if multiple, ok := decodeARMRawVFPMultiple(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", multiple.base)))
+					for register := multiple.first; register < multiple.first+multiple.count; register++ {
+						markReg(armRawVFPBackingReg(register, multiple.bits))
+					}
+				}
+				if structure, ok := decodeARMRawNEONStructureOne(uint32(ins.Args[0].Imm)); ok {
+					markReg(Reg(fmt.Sprintf("R%d", structure.base)))
+					if structure.offset != 13 && structure.offset != 15 {
+						markReg(Reg(fmt.Sprintf("R%d", structure.offset)))
+					}
+					for register := structure.first; register < structure.first+structure.count; register++ {
+						markReg(armRawVFPBackingReg(register, 64))
+					}
+				}
+				if logical, ok := decodeARMRawNEONBitwise(uint32(ins.Args[0].Imm)); ok {
+					markReg(armRawVFPBackingReg(logical.lhs, 64))
+					markReg(armRawVFPBackingReg(logical.rhs, 64))
+					markReg(armRawVFPBackingReg(logical.destination, 64))
+					if logical.quad {
+						markReg(armRawVFPBackingReg(logical.lhs+1, 64))
+						markReg(armRawVFPBackingReg(logical.rhs+1, 64))
+						markReg(armRawVFPBackingReg(logical.destination+1, 64))
+					}
+				}
+			}
 			for _, op := range ins.Args {
 				markOp(op)
 			}
@@ -132,6 +390,11 @@ func (c *armCtx) scanUsedRegs() {
 		markReg(Reg(fmt.Sprintf("R%d", i)))
 	}
 	markReg(SP)
+	if c.machineState != "" && c.sig.ARMEntry.VFP {
+		for i := 0; i < 16; i++ {
+			markReg(Reg(fmt.Sprintf("F%d", i)))
+		}
+	}
 }
 
 func (c *armCtx) emitEntryAllocasAndArgInit() error {
@@ -142,7 +405,7 @@ func (c *armCtx) emitEntryAllocasAndArgInit() error {
 	}
 	sort.Strings(regs)
 
-	c.b.WriteString(armLLVMBlockName("entry") + ":\n")
+	c.b.WriteString(armLLVMBlockName(c.blocks[0].name) + ":\n")
 	for _, rs := range regs {
 		r := Reg(rs)
 		slot := c.slotName(r)
@@ -157,7 +420,7 @@ func (c *armCtx) emitEntryAllocasAndArgInit() error {
 	sort.Strings(fregs)
 	for _, rs := range fregs {
 		r := Reg(rs)
-		slot := "%" + armLLVMBlockName("freg_"+string(r))
+		slot := "%freg_" + amd64LLVMSafeName(string(r))
 		c.fRegSlot[r] = slot
 		fmt.Fprintf(c.b, "  %s = alloca i64\n", slot)
 		fmt.Fprintf(c.b, "  store i64 0, ptr %s\n", slot)
@@ -194,9 +457,9 @@ func (c *armCtx) emitEntryAllocasAndArgInit() error {
 			return fmt.Errorf("arm: FP param slot +%d(FP) invalid arg index %d", p.Offset, p.Index)
 		}
 		value := fmt.Sprintf("%%arg%d", p.Index)
-		if p.Field >= 0 {
+		if fields := frameSlotFields(p); len(fields) != 0 {
 			extracted := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", extracted, c.sig.Args[p.Index], value, p.Field)
+			fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", extracted, c.sig.Args[p.Index], value, frameSlotExtractSuffix(p))
 			value = "%" + extracted
 		}
 		name := fmt.Sprintf("%%fp_arg_%d", p.Offset)
@@ -229,6 +492,9 @@ func (c *armCtx) emitEntryAllocasAndArgInit() error {
 			fmt.Fprintf(c.b, "  store i32 %s, ptr %s\n", v, slot)
 		}
 	}
+	if c.machineState != "" {
+		return c.initializeMachineState()
+	}
 	return nil
 }
 
@@ -262,6 +528,14 @@ func armValueAsI32(c *armCtx, ty LLVMType, v string) (out string, ok bool, err e
 }
 
 func (c *armCtx) loadReg(r Reg) (string, error) {
+	if r == PC {
+		return "", fmt.Errorf("arm: pseudo-register PC is not a general-register operand")
+	}
+	if r == Reg("R15") {
+		// Architectural PC reads depend on the source instruction's actual
+		// address and encoding, not on an initialized LLVM register slot.
+		return "", fmt.Errorf("%w: arm hardware PC R15 requires source instruction layout context", ErrProbeNeedsContext)
+	}
 	slot, ok := c.regSlot[r]
 	if !ok {
 		return "", fmt.Errorf("arm: unknown reg %s", r)
@@ -272,6 +546,14 @@ func (c *armCtx) loadReg(r Reg) (string, error) {
 }
 
 func (c *armCtx) storeReg(r Reg, v string) error {
+	if r == PC {
+		return fmt.Errorf("arm: pseudo-register PC is not a general-register operand")
+	}
+	if r == Reg("R15") {
+		// PC destinations are control transfers or instruction-specific
+		// system-state effects. Storing a virtual value is not either contract.
+		return fmt.Errorf("%w: arm hardware PC R15 requires explicit control-flow/system-state context", ErrProbeNeedsContext)
+	}
 	slot, ok := c.regSlot[r]
 	if !ok {
 		return fmt.Errorf("arm: unknown reg %s", r)
diff --git a/arm_deep_coverage_test.go b/arm_deep_coverage_test.go
index 598d3f239..35001e373 100644
--- a/arm_deep_coverage_test.go
+++ b/arm_deep_coverage_test.go
@@ -1,6 +1,7 @@
 package plan9asm
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
@@ -57,10 +58,13 @@ func TestARMEvalCoverage(t *testing.T) {
 		{Kind: OpFPAddr, FPName: "ret", FPOffset: 32},
 		{Kind: OpMem, Mem: MemRef{Base: "R7", Off: 4}},
 		{Kind: OpSym, Sym: "$runtime·main+4(SB)"},
-		{Kind: OpIdent, Ident: "CS"},
 	}
-	if got, err := c.evalFPAddr32(Operand{Kind: OpFPAddr, FPName: "argframe", FPOffset: 99}); err != nil || got != "0" {
-		t.Fatalf("evalFPAddr32(dynamic) = (%q, %v), want (0, nil)", got, err)
+	// ARM has no x86 CS value operand: an unknown identifier is not zero.
+	if got, err := c.eval32(Operand{Kind: OpIdent, Ident: "CS"}, false); err == nil || got != "" {
+		t.Fatalf("eval32(unknown CS) fabricated a value: (%q, %v)", got, err)
+	}
+	if got, err := c.evalFPAddr32(Operand{Kind: OpFPAddr, FPName: "argframe", FPOffset: 99}); !errors.Is(err, ErrProbeNeedsContext) || got != "" {
+		t.Fatalf("evalFPAddr32(dynamic) = (%q, %v), want unbound frame context", got, err)
 	}
 	if got, err := c.evalFPValue32(Operand{Kind: OpFP, FPName: "f_hi", FPOffset: 24}); err != nil || got == "" {
 		t.Fatalf("evalFPValue32(split i64 high) = (%q, %v)", got, err)
@@ -360,7 +364,7 @@ func TestARMArithCoverageDeep(t *testing.T) {
 	if err := c.lowerARMMULAWT("", Instr{Raw: "MULAWT R0, R1, R2", Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpReg, Reg: "R1"}, {Kind: OpReg, Reg: "R2"}}}); err == nil {
 		t.Fatalf("lowerARMMULAWT(invalid) unexpectedly succeeded")
 	}
-	if err := c.lowerARMDIVUHW("", Instr{Raw: "DIVUHW R0, R1", Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpReg, Reg: "R1"}}}); err == nil {
+	if err := c.lowerARMDIVUHW("", Instr{Raw: "DIVUHW R0", Args: []Operand{{Kind: OpReg, Reg: "R0"}}}); err == nil {
 		t.Fatalf("lowerARMDIVUHW(invalid) unexpectedly succeeded")
 	}
 	if err := c.lowerARMCLZ("", Instr{Raw: "CLZ R0, $1", Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpImm, Imm: 1}}}); err == nil {
@@ -380,7 +384,7 @@ func TestARMArithCoverageDeep(t *testing.T) {
 		"mul i64",
 		"udiv i32",
 		"call i32 @llvm.ctlz.i32",
-		`asm sideeffect "mrc p15, 0, $0, 1, 0, 0"`,
+		`asm sideeffect "mrc p15, #0, $0, c1, c0, #0"`,
 	} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
@@ -443,10 +447,10 @@ func TestARMBranchMovmAndSyscallCoverage(t *testing.T) {
 	}
 
 	c2, _ := newARMCtxForTest(t, FuncSig{Name: "example.callers", Ret: I32}, map[string]FuncSig{
-		"example.ret32":   {Name: "example.ret32", Ret: I32},
-		"example.retVoid": {Name: "example.retVoid", Ret: Void},
-		"example.retBad":  {Name: "example.retBad", Ret: LLVMType("vector")},
-		"example.tail64":  {Name: "example.tail64", Ret: I64},
+		"example.ret32":     {Name: "example.ret32", Ret: I32},
+		"example.retVoid":   {Name: "example.retVoid", Ret: Void},
+		"example.retBad":    {Name: "example.retBad", Ret: LLVMType("vector")},
+		"example.tailFloat": {Name: "example.tailFloat", Ret: LLVMType("double")},
 	})
 	if err := c2.callSym(Operand{Kind: OpSym, Sym: "ret32(SB)"}); err != nil {
 		t.Fatalf("callSym(ret32) error = %v", err)
@@ -472,7 +476,7 @@ func TestARMBranchMovmAndSyscallCoverage(t *testing.T) {
 	if err := c2.tailCallAndRet(Operand{Kind: OpSym, Sym: "missing(SB)"}); err != nil {
 		t.Fatalf("tailCallAndRet(missing sig) error = %v", err)
 	}
-	if err := c2.tailCallAndRet(Operand{Kind: OpSym, Sym: "tail64(SB)"}); err == nil {
+	if err := c2.tailCallAndRet(Operand{Kind: OpSym, Sym: "tailFloat(SB)"}); err == nil {
 		t.Fatalf("tailCallAndRet(mismatch) unexpectedly succeeded")
 	}
 
@@ -496,6 +500,17 @@ func TestARMBranchMovmAndSyscallCoverage(t *testing.T) {
 		t.Fatalf("tailCallAndRet(ptr -> i32) output:\n%s", got)
 	}
 
+	floatSig := FuncSig{Name: "example.floatcaller", Args: []LLVMType{LLVMType("float")}, Ret: LLVMType("float")}
+	cTailFloat, bTailFloat := newARMCtxForTest(t, floatSig, map[string]FuncSig{
+		"example.floatcallee": {Name: "example.floatcallee", Args: []LLVMType{LLVMType("float")}, Ret: LLVMType("float")},
+	})
+	if err := cTailFloat.tailCallAndRet(Operand{Kind: OpSym, Sym: "floatcallee(SB)"}); err != nil {
+		t.Fatalf("tailCallAndRet(identical float signature) error = %v", err)
+	}
+	if got := bTailFloat.String(); !strings.Contains(got, `call float @"example.floatcallee"(float %arg0)`) || !strings.Contains(got, "ret float") {
+		t.Fatalf("tailCallAndRet(identical float signature) output:\n%s", got)
+	}
+
 	out := b.String()
 	for _, want := range []string{
 		`call void @"example.tail"()`,
@@ -510,7 +525,7 @@ func TestARMBranchMovmAndSyscallCoverage(t *testing.T) {
 	}
 }
 
-func TestTranslateARMLinearCoverageDeep(t *testing.T) {
+func TestTranslateARMStraightLineCoverageDeep(t *testing.T) {
 	ll := translateARMForTest(t, `TEXT ·linear(SB),NOSPLIT,$0-0
 	MOVB $1, R1
 	MOVBU $2, R2
@@ -531,9 +546,9 @@ func TestTranslateARMLinearCoverageDeep(t *testing.T) {
 		},
 	})
 	for _, want := range []string{
-		"trunc i64 1 to i8",
-		"zext i8",
-		"add i32 %arg0, %arg1",
+		"store i32 1",
+		"store i32 2",
+		"add i32",
 		"sub i32",
 		"and i32",
 		"or i32",
diff --git a/arm_ecosystem_test.go b/arm_ecosystem_test.go
new file mode 100644
index 000000000..5a4ffb213
--- /dev/null
+++ b/arm_ecosystem_test.go
@@ -0,0 +1,586 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func translateARMCompleteForms(t *testing.T, src string, sigs map[string]FuncSig) string {
+	t.Helper()
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs:         sigs,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-complete-forms.ll", "arm-complete-forms.o", ll)
+	return ll
+}
+
+func rejectARMFormsOutsideGo127Optabs(t *testing.T, instructions []string) {
+	t.Helper()
+	for _, instruction := range instructions {
+		t.Run(strings.NewReplacer(" ", "_", "(", "_", ")", "_").Replace(instruction), func(t *testing.T) {
+			file, err := Parse(ArchARM, "TEXT bad(SB),0,$0-0\n\t"+instruction+"\n\tRET\n")
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{
+				TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Goarch:       "arm",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("Translate accepted %q outside Go 1.27's ARM optabs", instruction)
+			}
+		})
+	}
+}
+
+func TestTranslateARMScalarFloatMoveFamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT floatmoves(SB),0,$0-0
+	CMP R0, R0
+	MOVF F0, F1
+	MOVD F1, F2
+	MOVF $0.5, F3
+	MOVD $0.5, F4
+	MOVF F0, 4(R1)
+	MOVF 4(R1), F0
+	MOVD F1, 8(R1)
+	MOVD 8(R1), F1
+	MOVF F0, 8192(R1)
+	MOVF 8192(R1), F0
+	MOVD F1, 8192(R1)
+	MOVD 8192(R1), F1
+	MOVF F0, float32global(SB)
+	MOVF float32global(SB), F0
+	MOVD F1, float64global(SB)
+	MOVD float64global(SB), F1
+	MOVF.EQ F0, F1
+	MOVD.NE F1, F2
+	MOVF.P F0, 4(R1)
+	MOVD.W 8(R1), F0
+	MOVF.PW F0, 4(R1)
+	MOVD.U 8(R1), F0
+	RET
+
+TEXT floatframe(SB),0,$0-8
+	MOVF x+0(FP), F0
+	MOVF F0, ret+4(FP)
+	RET
+
+TEXT doubleframe(SB),0,$0-16
+	MOVD x+0(FP), F0
+	MOVD F0, ret+8(FP)
+	RET
+`, map[string]FuncSig{
+		"floatmoves": {Name: "floatmoves", Ret: Void},
+		"floatframe": {
+			Name: "floatframe", Args: []LLVMType{LLVMType("float")}, Ret: LLVMType("float"),
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: LLVMType("float"), Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 4, Type: LLVMType("float"), Index: 0, Field: -1}},
+			},
+		},
+		"doubleframe": {
+			Name: "doubleframe", Args: []LLVMType{LLVMType("double")}, Ret: LLVMType("double"),
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}},
+			},
+		},
+	})
+	for _, want := range []string{
+		"load i32", "store i32", "load i64", "store i64", "add i32",
+		"load i32, ptr %fp_arg_0", "load i64, ptr %fp_arg_0", "br i1",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM float-move family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMScalarFloatMoveFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"MOVF R0, F0",
+		"MOVD F0, R0",
+		"MOVF (R0), (R1)",
+		"MOVD $0.5, (R0)",
+		"MOVF F0",
+		"MOVD.S F0, F1",
+		"MOVF.P F0, F1",
+	})
+}
+
+func TestTranslateARMFloatUnaryAndConvertFamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT floatunary(SB),0,$0-0
+	CMP R0, R0
+	NEGF F0, F1
+	NEGD.EQ F1, F2
+	ABSF F2, F3
+	ABSD.NE F3, F4
+	SQRTF F4, F5
+	SQRTD F5, F6
+	MOVFD F6, F7
+	MOVDF F7, F0
+	RET
+`, map[string]FuncSig{"floatunary": {Name: "floatunary", Ret: Void}})
+	for _, want := range []string{
+		"fneg float", "fneg double", "@llvm.fabs.f32", "@llvm.fabs.f64",
+		"@llvm.sqrt.f32", "@llvm.sqrt.f64", "fpext float", "fptrunc double", "br i1",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM float unary/convert family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMFloatUnaryAndConvertFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"SQRTD F0",
+		"SQRTF F0, R1",
+		"ABSD (R0), F1",
+		"ABSF F0, (R1)",
+		"NEGD F0, F1, F2",
+		"MOVFD.S F0, F1",
+		"MOVDF.P F0, F1",
+	})
+}
+
+func TestTranslateARMScalarFloatArithmeticFamilyCompleteGo127Forms(t *testing.T) {
+	// Go 1.27 routes this whole family through AADDF's two optab rows. Plain
+	// arithmetic permits both Fsrc,Fdst and Fsrc1,Fsrc2,Fdst; accumulating
+	// variants require the explicit three-register form.
+	ll := translateARMCompleteForms(t, `
+TEXT floatarithmetic(SB),0,$0-0
+	CMP R0, R0
+	ADDF F0, F1
+	ADDD.EQ F0, F1, F2
+	SUBF F0, F1
+	SUBD.NE F0, F1, F2
+	MULF F0, F1
+	MULD F0, F1, F2
+	NMULF F0, F1
+	NMULD F0, F1, F2
+	DIVF F0, F1
+	DIVD F0, F1, F2
+	MULAF F0, F1, F2
+	MULAD F0, F1, F2
+	MULSF F0, F1, F2
+	MULSD F0, F1, F2
+	NMULAF F0, F1, F2
+	NMULAD F0, F1, F2
+	NMULSF F0, F1, F2
+	NMULSD F0, F1, F2
+	FMULAF F0, F1, F2
+	FMULAD F0, F1, F2
+	FMULSF F0, F1, F2
+	FMULSD F0, F1, F2
+	FNMULAF F0, F1, F2
+	FNMULAD F0, F1, F2
+	FNMULSF F0, F1, F2
+	FNMULSD F0, F1, F2
+	RET
+`, map[string]FuncSig{"floatarithmetic": {Name: "floatarithmetic", Ret: Void}})
+	for _, want := range []string{"fadd float", "fadd double", "fsub float", "fmul float", "fdiv float", "fneg float", "br i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM scalar float-arithmetic family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMScalarFloatArithmeticFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"ADDF F0",
+		"ADDF R0, F1",
+		"ADDD F0, R1",
+		"SUBF F0, F1, F2, F3",
+		"MULAF F0, F1",
+		"NMULSD F0, F1",
+		"FMULAF F0, F1",
+		"FNMULSD F0, F1",
+		"DIVF F0, (R1)",
+		"ADDF.S F0, F1",
+	})
+}
+
+func TestTranslateARMWordFloatConversionFamilyCompleteGo127Forms(t *testing.T) {
+	// MOV{W}{F,D} converts signed/unsigned 32-bit integers to floating point;
+	// MOV{F,D}W truncates floating point to signed/unsigned 32-bit integers.
+	// Go's optab permits the integer bits to live in either an R or F register.
+	ll := translateARMCompleteForms(t, `
+TEXT wordfloatconversions(SB),0,$0-0
+	CMP R0, R0
+	MOVWF R0, F0
+	MOVWF F0, F1
+	MOVWF.U R1, F2
+	MOVWF.EQ F2, F3
+	MOVWD R2, F4
+	MOVWD F4, F5
+	MOVWD.U R3, F6
+	MOVWD.NE F6, F7
+	MOVFW F0, R4
+	MOVFW F1, F2
+	MOVFW.U F2, R5
+	MOVFW.EQ F3, F4
+	MOVDW F4, R6
+	MOVDW F5, F6
+	MOVDW.U F6, R7
+	MOVDW.NE F7, F8
+	RET
+`, map[string]FuncSig{"wordfloatconversions": {Name: "wordfloatconversions", Ret: Void}})
+	for _, want := range []string{"vcvt.f32.s32", "vcvt.f32.u32", "vcvt.f64.s32", "vcvt.f64.u32", "vcvt.s32.f32", "vcvt.u32.f32", "vcvt.s32.f64", "vcvt.u32.f64", "br i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM word/float conversion family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMWordFloatConversionFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"MOVWF R0",
+		"MOVWF (R0), F0",
+		"MOVWF R0, R1",
+		"MOVWD F0, R0",
+		"MOVFW R0, F0",
+		"MOVFW F0, (R1)",
+		"MOVDW F0, F1, F2",
+		"MOVFW.P F0, R0",
+		"MOVWD.S R0, F0",
+	})
+}
+
+func TestTranslateARMWordRegisterBitTransferSubfamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT wordregisterbittransfers(SB),0,$0-0
+	CMP R0, R0
+	MOVW R0, F0
+	MOVW F0, R1
+	MOVW.EQ R2, F3
+	MOVW.NE F3, R4
+	RET
+`, map[string]FuncSig{"wordregisterbittransfers": {Name: "wordregisterbittransfers", Ret: Void}})
+	for _, want := range []string{"trunc i64", "zext i32", "br i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM MOVW R/F bit-transfer IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMWordRegisterBitTransferSubfamilyRejectsNonGoForms(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"MOVW $1, F0",
+		"MOVW (R0), F0",
+		"MOVW F0, (R1)",
+		"MOVW F0, F1",
+		"MOVW.S R0, F0",
+	})
+}
+
+func TestTranslateARMPreloadFamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT preloadforms(SB),0,$0-0
+	CMP R0, R0
+	PLD (R0)
+	PLD 4095(R1)
+	PLD -4095(R2)
+	PLD (2*64)(R3)
+	PLD.EQ 64(R4)
+	RET
+`, map[string]FuncSig{"preloadforms": {Name: "preloadforms", Ret: Void}})
+	if !strings.Contains(ll, "@llvm.prefetch.p0") || !strings.Contains(ll, "br i1") {
+		t.Fatalf("ARM PLD family IR is incomplete:\n%s", ll)
+	}
+}
+
+func TestTranslateARMPreloadFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"PLD",
+		"PLD R0",
+		"PLD 4096(R0)",
+		"PLD -4096(R0)",
+		"PLD (R0)(R1)",
+		"PLD source(SB)",
+		"PLD.P (R0)",
+		"PLD.W (R0)",
+		"PLD.U (R0)",
+		"PLD.S (R0)",
+	})
+}
+
+func TestTranslateARMScalarFloatCompareFamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT floatcompareforms(SB),0,$0-0
+	CMP R0, R0
+	CMPF F0
+	BGT compare1
+compare1:
+	CMPF F0, F1
+	BLT compare2
+compare2:
+	CMPD F2
+	BEQ compare3
+compare3:
+	CMPD.EQ F2, F3
+	BVS done
+done:
+	RET
+`, map[string]FuncSig{"floatcompareforms": {Name: "floatcompareforms", Ret: Void}})
+	for _, want := range []string{"vcmpe.f32", "vcmpe.f64", "vmrs $0, fpscr", "lshr i32"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM scalar float-compare family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMScalarFloatCompareFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"CMPF",
+		"CMPF R0",
+		"CMPF F0, R1",
+		"CMPD (R0)",
+		"CMPD F0, F1, F2",
+		"CMPF.S F0, F1",
+	})
+}
+
+func TestTranslateARMRawVFPCompareAndVMRSFamily(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT rawvfpcompare(SB),0,$0-0
+	WORD $0xeeb56ac0 // VCMPE.F32 F6, #0
+	WORD $0xeef1fa10 // VMRS APSR_nzcv, FPSCR
+	BGT rawgreater
+rawgreater:
+	WORD $0xeeb42ac0 // VCMPE.F32 F2, F0
+	WORD $0xeef1fa10
+	BLT done
+	WORD $0xeeb41ac4 // VCMPE.F32 S2, S8 (Go F1, F4)
+	WORD $0xeef1fa10
+	MOVF.GT F1, F4
+done:
+	RET
+`, map[string]FuncSig{"rawvfpcompare": {Name: "rawvfpcompare", Ret: Void}})
+	if !strings.Contains(ll, "vcmpe.f32") || !strings.Contains(ll, "vmrs $0, fpscr") || !strings.Contains(ll, "br i1") {
+		t.Fatalf("raw ARM VFP compare/VMRS sequence was not modeled:\n%s", ll)
+	}
+}
+
+func TestDecodeARMRawVFPCompareFamily(t *testing.T) {
+	tests := []struct {
+		name    string
+		word    uint32
+		bits    int
+		zeroRHS bool
+	}{
+		{"vcmp-f32-register", 0xeeb40a40, 32, false},
+		{"vcmpe-f32-register", 0xeeb40ac0, 32, false},
+		{"vcmp-f32-zero", 0xeeb50a40, 32, true},
+		{"vcmpe-f32-zero", 0xeeb50ac0, 32, true},
+		{"vcmp-f64-register", 0xeeb40b40, 64, false},
+		{"vcmpe-f64-register", 0xeeb40bc0, 64, false},
+		{"vcmp-f64-zero", 0xeeb50b40, 64, true},
+		{"vcmpe-f64-zero", 0xeeb50bc0, 64, true},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			word := test.word | 3<<12
+			if !test.zeroRHS {
+				word |= 2
+			}
+			decoded, ok := decodeARMRawVFPCompare(word)
+			if !ok {
+				t.Fatalf("decodeARMRawVFPCompare(%#08x) failed", test.word)
+			}
+			wantLHS := 6
+			if test.bits == 64 {
+				wantLHS = 3
+			}
+			if decoded.bits != test.bits || decoded.zeroRHS != test.zeroRHS || decoded.lhs != wantLHS {
+				t.Fatalf("decodeARMRawVFPCompare(%#08x) = %#v", test.word, decoded)
+			}
+			if test.zeroRHS && decoded.rhs != 0 {
+				t.Fatalf("zero comparison rhs = %d, want zero encoding", decoded.rhs)
+			}
+		})
+	}
+	for _, word := range []uint32{
+		0xeeb50a41, // zero form must encode Vm=0.
+		0xeeb50a60, // zero form must also have M=0.
+		0xfeb40a40, // unconditional/reserved condition field.
+	} {
+		if decoded, ok := decodeARMRawVFPCompare(word); ok {
+			t.Fatalf("decodeARMRawVFPCompare(%#08x) = %#v, want rejected", word, decoded)
+		}
+	}
+}
+
+func TestTranslateARMDivModFamilyCompleteGo127Forms(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT divmod(SB),0,$0-0
+	CMP R0, R0
+	DIV R0, R1
+	DIV R0, R1, R2
+	DIVU R0, R1
+	CMP R0, R0
+	DIVU.EQ R0, R1, R2
+	MOD R0, R1
+	CMP R0, R0
+	MOD.NE R0, R1, R2
+	MODU R0, R1
+	MODU R0, R1, R2
+	RET
+`, map[string]FuncSig{"divmod": {Name: "divmod", Ret: Void}})
+	for _, want := range []string{"sdiv i32", "udiv i32", "srem i32", "urem i32", "select i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM div/mod family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMDivModFamilyRejectsFormsOutsideGo127Optabs(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"DIV $2, R1",
+		"DIV (R0), R1",
+		"DIV R0, (R1)",
+		"DIV R0, R1, (R2)",
+		"DIVU R0",
+		"MODU R0, R1, R2, R3",
+		"MOD.S R0, R1",
+	})
+}
+
+func TestTranslateARMFrameAddressIncludesParametersAndInteriorOffsets(t *testing.T) {
+	ll := translateARMCompleteForms(t, `
+TEXT frameaddr(SB),0,$0-12
+	MOVW $word+0(FP), R0
+	MOVW $wordhi+4(FP), R1
+	MOVW $ret+8(FP), R2
+	RET
+`, map[string]FuncSig{
+		"frameaddr": {
+			Name: "frameaddr", Args: []LLVMType{I64}, Ret: I32,
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}},
+			},
+		},
+	})
+	for _, want := range []string{"ptrtoint ptr %fp_arg_0 to i32", "getelementptr i8, ptr %fp_arg_0, i32 4", "ptrtoint ptr %fp_ret_0 to i32"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM frame-address IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMExplicitShiftFamily(t *testing.T) {
+	file, err := Parse(ArchARM, `
+TEXT shifts(SB),NOSPLIT,$0-0
+	CMP $0, R0
+	SLL $3, R0
+	SLL $5, R0, R1
+	SLL R2, R1
+	SLL R2, R1, R3
+	SRL $3, R3
+	SRL $5, R3, R4
+	SRL R2, R4
+	SRL R2, R4, R5
+	SRA $3, R5
+	SRA $5, R5, R6
+	SRA R2, R6
+	SRA.EQ.S R2, R6, R7
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs:         map[string]FuncSig{"shifts": {Name: "shifts", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"shl i32", "lshr i32", "ashr i32", "and i32", "icmp ugt i32", "select i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("shift-family IR missing %q:\n%s", want, ll)
+		}
+	}
+}
+
+func TestTranslateARMExplicitShiftFamilyRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"SLL R0",
+		"SRL $257, R0",
+		"SRA $1, $2, R0",
+		"SLL $1, R0, 0(R1)",
+		"SRL R0, R1, R2, R3",
+	} {
+		file, err := Parse(ArchARM, "TEXT bad(SB),NOSPLIT,$0-0\n"+instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate(%q) unexpectedly succeeded", instruction)
+		}
+	}
+}
+
+func TestTranslateARMFallbackI64Return(t *testing.T) {
+	file, err := Parse(ArchARM, `
+TEXT helper(SB),NOSPLIT,$0-0
+	MOVW $1, R0
+	MOVW $2, R1
+	B done
+done:
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs: map[string]FuncSig{
+			"helper": {Name: "helper", Ret: I64},
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestTranslateARMRawTSTFeedsConditionalInstruction(t *testing.T) {
+	file, err := Parse(ArchARM, `
+TEXT rawtst(SB),NOSPLIT,$0-0
+	WORD $0xe1180008
+	MOVW.EQ $1, R0
+	WORD $0xe31e0003
+	MOVW.NE $2, R0
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs:         map[string]FuncSig{"rawtst": {Name: "rawtst", Ret: Void}},
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/arm_eval.go b/arm_eval.go
index e5d6db33c..ee01d15a2 100644
--- a/arm_eval.go
+++ b/arm_eval.go
@@ -11,6 +11,9 @@ func (c *armCtx) imm32(n int64) string {
 }
 
 func (c *armCtx) addrI32(mem MemRef, postInc bool) (addr string, base Reg, inc int64, err error) {
+	if mem.OffRaw != "" && !armNamedStackOffset(mem) {
+		return "", "", 0, fmt.Errorf("arm: unresolved address offset %q requires a typed address form", mem.OffRaw)
+	}
 	base = mem.Base
 	baseVal, err := c.loadReg(base)
 	if err != nil {
@@ -62,23 +65,33 @@ func (c *armCtx) loadMem(mem MemRef, bits int, postInc bool, signed bool) (strin
 	if err != nil {
 		return "", err
 	}
+	out, err := c.loadMemAddress(addr, bits, signed)
+	if err == nil {
+		err = c.updatePostInc(base, inc)
+	}
+	return out, err
+}
+
+func (c *armCtx) loadMemAddress(addr string, bits int, signed bool) (string, error) {
 	pt := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pt, addr)
-	ptr := "%" + pt
+	return c.loadMemoryPointer("%"+pt, bits, signed)
+}
 
+func (c *armCtx) loadMemoryPointer(ptr string, bits int, signed bool) (string, error) {
 	var out string
 	switch bits {
 	case 64:
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s, align 1\n", t, ptr)
 		out = "%" + t
 	case 32:
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  %%%s = load i32, ptr %s, align 1\n", t, ptr)
 		out = "%" + t
 	case 16:
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  %%%s = load i16, ptr %s, align 1\n", t, ptr)
 		e := c.newTmp()
 		if signed {
 			fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i32\n", e, t)
@@ -88,7 +101,7 @@ func (c *armCtx) loadMem(mem MemRef, bits int, postInc bool, signed bool) (strin
 		out = "%" + e
 	case 8:
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  %%%s = load i8, ptr %s, align 1\n", t, ptr)
 		e := c.newTmp()
 		if signed {
 			fmt.Fprintf(c.b, "  %%%s = sext i8 %%%s to i32\n", e, t)
@@ -99,9 +112,6 @@ func (c *armCtx) loadMem(mem MemRef, bits int, postInc bool, signed bool) (strin
 	default:
 		return "", fmt.Errorf("arm: unsupported load bits %d", bits)
 	}
-	if err := c.updatePostInc(base, inc); err != nil {
-		return "", err
-	}
 	return out, nil
 }
 
@@ -110,26 +120,36 @@ func (c *armCtx) storeMem(mem MemRef, bits int, postInc bool, v32 string) error
 	if err != nil {
 		return err
 	}
+	if err := c.storeMemAddress(addr, bits, v32); err != nil {
+		return err
+	}
+	return c.updatePostInc(base, inc)
+}
+
+func (c *armCtx) storeMemAddress(addr string, bits int, v32 string) error {
 	pt := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pt, addr)
-	ptr := "%" + pt
+	return c.storeMemoryPointer("%"+pt, bits, v32)
+}
+
+func (c *armCtx) storeMemoryPointer(ptr string, bits int, v32 string) error {
 	switch bits {
 	case 64:
-		fmt.Fprintf(c.b, "  store i64 %s, ptr %s\n", v32, ptr)
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 1\n", v32, ptr)
 	case 32:
-		fmt.Fprintf(c.b, "  store i32 %s, ptr %s\n", v32, ptr)
+		fmt.Fprintf(c.b, "  store i32 %s, ptr %s, align 1\n", v32, ptr)
 	case 16:
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", t, v32)
-		fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  store i16 %%%s, ptr %s, align 1\n", t, ptr)
 	case 8:
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i8\n", t, v32)
-		fmt.Fprintf(c.b, "  store i8 %%%s, ptr %s\n", t, ptr)
+		fmt.Fprintf(c.b, "  store i8 %%%s, ptr %s, align 1\n", t, ptr)
 	default:
 		return fmt.Errorf("arm: unsupported store bits %d", bits)
 	}
-	return c.updatePostInc(base, inc)
+	return nil
 }
 
 func (c *armCtx) eval32(op Operand, postInc bool) (string, error) {
@@ -172,53 +192,36 @@ func (c *armCtx) eval32(op Operand, postInc bool) (string, error) {
 		t := c.newTmp()
 		switch strings.ToUpper(op.Ident) {
 		case "CPSR":
+			if c.machineState != "" {
+				return c.statusWithModeledNZCV(c.loadMachineValue(armMachineCPSROffset, I32)), nil
+			}
 			fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n", t, "mrs $0, cpsr", "=r,~{memory}")
-			return "%" + t, nil
+			return c.statusWithModeledNZCV("%" + t), nil
 		case "FPCR", "FPSR":
+			if c.machineState != "" {
+				return c.loadMachineValue(armMachineFPSCROffset, I32), nil
+			}
 			fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n", t, "vmrs $0, fpscr", "=r,~{memory}")
 			return "%" + t, nil
+		case "SPSR":
+			return "", fmt.Errorf("ARM SPSR spelling is not accepted by the Go assembler register table")
 		}
-		return "0", nil
+		return "", fmt.Errorf("ARM unknown status/value identifier %q needs an actual source definition", op.Ident)
 	default:
 		return "", fmt.Errorf("arm: unsupported operand for i32: %s", op.String())
 	}
 }
 
 func (c *armCtx) evalShift(op Operand) (string, error) {
-	base, err := c.loadReg(op.Reg)
-	if err != nil {
-		return "", err
-	}
-	var sh string
-	if op.ShiftReg != "" {
-		sh, err = c.loadReg(op.ShiftReg)
-		if err != nil {
-			return "", err
-		}
-	} else {
-		sh = c.imm32(op.ShiftAmount)
-	}
-	t := c.newTmp()
-	switch op.ShiftOp {
-	case ShiftLeft:
-		fmt.Fprintf(c.b, "  %%%s = shl i32 %s, %s\n", t, base, sh)
-	case ShiftRight:
-		fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, %s\n", t, base, sh)
-	case ShiftArith:
-		fmt.Fprintf(c.b, "  %%%s = ashr i32 %s, %s\n", t, base, sh)
-	case ShiftRotate:
-		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.fshr.i32(i32 %s, i32 %s, i32 %s)\n", t, base, base, sh)
-	default:
-		return "", fmt.Errorf("arm: unsupported shift op %q", op.ShiftOp)
-	}
-	return "%" + t, nil
+	value, _, err := c.evalARMShifter(op)
+	return value, err
 }
 
 func (c *armCtx) evalFPValue32(op Operand) (string, error) {
 	slot, ok := c.fpParams[op.FPOffset]
 	if !ok {
 		for base, candidate := range c.fpParams {
-			if candidate.Type != I64 || op.FPOffset != base+4 {
+			if candidate.Type != I64 && candidate.Type != LLVMType("double") || op.FPOffset != base+4 {
 				continue
 			}
 			p := c.fpParamAlloca[base]
@@ -226,10 +229,16 @@ func (c *armCtx) evalFPValue32(op Operand) (string, error) {
 				return "", fmt.Errorf("arm: missing FP param alloca for +%d(FP)", base)
 			}
 			full := c.newTmp()
+			fullValue := "%" + full
 			hi := c.newTmp()
 			word := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", full, p)
-			fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 32\n", hi, full)
+			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s\n", full, candidate.Type, p)
+			if candidate.Type == LLVMType("double") {
+				bits := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", bits, fullValue)
+				fullValue = "%" + bits
+			}
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", hi, fullValue)
 			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", word, hi)
 			return "%" + word, nil
 		}
@@ -243,10 +252,10 @@ func (c *armCtx) evalFPValue32(op Operand) (string, error) {
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s\n", t, slot.Type, p)
 		arg = "%" + t
-	} else if slot.Field >= 0 {
+	} else if fields := frameSlotFields(slot); len(fields) != 0 {
 		aggTy := c.sig.Args[slot.Index]
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s, %d\n", t, aggTy, arg, slot.Field)
+		fmt.Fprintf(c.b, "  %%%s = extractvalue %s %s%s\n", t, aggTy, arg, frameSlotExtractSuffix(slot))
 		arg = "%" + t
 	}
 	switch slot.Type {
@@ -272,25 +281,113 @@ func (c *armCtx) evalFPValue32(op Operand) (string, error) {
 		t := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", t, arg)
 		return "%" + t, nil
+	case LLVMType("double"):
+		bits := c.newTmp()
+		word := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", bits, arg)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", word, bits)
+		return "%" + word, nil
 	default:
 		return "", fmt.Errorf("arm: unsupported FP slot type %q", slot.Type)
 	}
 }
 
 func (c *armCtx) evalFPAddr32(op Operand) (string, error) {
-	if slot, ok := c.fpResAllocaOff[op.FPOffset]; ok {
-		c.markFPResultAddrTaken(op.FPOffset)
+	ptr, resultOffset, isResult, ok := c.armFramePointer(op.FPOffset, 0)
+	if ok {
+		if isResult {
+			c.markFPResultAddrTaken(resultOffset)
+		}
 		t := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i32\n", t, slot)
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i32\n", t, ptr)
 		return "%" + t, nil
 	}
-	if op.FPName == "argframe" {
-		// Dynamic reflect/callback stubs use $argframe(FP) without a statically
-		// declared argument frame. An ordinary LLVM function signature cannot
-		// recover that caller-owned address. Keep corpus/object lowering permissive,
-		// as the ARM64 lowering does, while executable ABI tests remain responsible
-		// for using only addressable, modeled slots.
-		return "0", nil
+	// Neither a familiar source name nor a TEXT frame declaration supplies a
+	// caller-owned FP address. Only the typed backing resolved above may be
+	// materialized; an unbound address must not become a zero placeholder.
+	return "", fmt.Errorf("%w: arm FP address %s requires bound typed frame storage", ErrProbeNeedsContext, op.String())
+}
+
+func armFrameTypeSize(typ LLVMType) int64 {
+	switch typ {
+	case I1, I8:
+		return 1
+	case I16:
+		return 2
+	case I32, Ptr, LLVMType("float"):
+		return 4
+	case I64, LLVMType("double"):
+		return 8
+	default:
+		// Frame slots are normally scalar leaves. Preserve the established
+		// conservative aggregate fallback used by the x86 classic-frame model.
+		return 16
+	}
+}
+
+// armFramePointer resolves exact and interior classic-frame offsets to the
+// backing alloca. accessBytes == 0 forms an address; positive sizes additionally
+// prove that the requested load/store remains inside that modeled slot.
+func (c *armCtx) armFramePointer(off, accessBytes int64) (ptr string, base int64, isResult, ok bool) {
+	type candidate struct {
+		slot     FrameSlot
+		ptr      string
+		isResult bool
+	}
+	candidates := make([]candidate, 0, len(c.sig.Frame.Params)+len(c.fpResults))
+	for _, slot := range c.sig.Frame.Params {
+		if p := c.fpParamAlloca[slot.Offset]; p != "" {
+			candidates = append(candidates, candidate{slot: slot, ptr: p})
+		}
+	}
+	for _, slot := range c.fpResults {
+		if p := c.fpResAllocaIdx[slot.Index]; p != "" {
+			candidates = append(candidates, candidate{slot: slot, ptr: p, isResult: true})
+		}
+	}
+	// Prefer an exact slot when one starts at the same offset as the end of an
+	// earlier slot.
+	for pass := 0; pass < 2; pass++ {
+		for _, candidate := range candidates {
+			size := armFrameTypeSize(candidate.slot.Type)
+			exact := off == candidate.slot.Offset
+			inside := off >= candidate.slot.Offset && off < candidate.slot.Offset+size
+			if (pass == 0 && !exact) || (pass == 1 && exact) || !inside {
+				continue
+			}
+			if accessBytes > 0 && off+accessBytes > candidate.slot.Offset+size {
+				continue
+			}
+			resolved := candidate.ptr
+			if delta := off - candidate.slot.Offset; delta != 0 {
+				t := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i32 %d\n", t, resolved, delta)
+				resolved = "%" + t
+			}
+			return resolved, candidate.slot.Offset, candidate.isResult, true
+		}
+	}
+	return "", 0, false, false
+}
+
+func (c *armCtx) loadARMFrameBits(off int64, bits int) (string, error) {
+	ptr, _, _, ok := c.armFramePointer(off, int64(bits/8))
+	if !ok {
+		return "", fmt.Errorf("arm: unsupported %d-bit FP frame load at +%d(FP)", bits, off)
+	}
+	value := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s\n", value, bits, ptr)
+	return "%" + value, nil
+}
+
+func (c *armCtx) storeARMFrameBits(off int64, bits int, value string) error {
+	ptr, resultOffset, isResult, ok := c.armFramePointer(off, int64(bits/8))
+	if !ok {
+		return fmt.Errorf("arm: unsupported %d-bit FP frame store at +%d(FP)", bits, off)
+	}
+	fmt.Fprintf(c.b, "  store i%d %s, ptr %s\n", bits, value, ptr)
+	if isResult {
+		c.markFPResultWritten(resultOffset)
 	}
-	return "", fmt.Errorf("arm: unsupported FP addr slot: %s", op.String())
+	return nil
 }
diff --git a/arm_extension_rotate_runtime_test.go b/arm_extension_rotate_runtime_test.go
new file mode 100644
index 000000000..8277083f2
--- /dev/null
+++ b/arm_extension_rotate_runtime_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMExtensionRotateZeroIsNotRRX(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	var source, goVectors, cVectors strings.Builder
+	source.WriteString("TEXT oracle(SB),4,$0-20\n MOVW value+0(FP),R0\n MOVW out+16(FP),R4\n MOVW status+12(FP),R6\n MOVW R6,CPSR\n")
+	lane := 0
+	for _, op := range []string{"MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, rotation := range []int{0, 8, 16, 24} {
+			fmt.Fprintf(&source, " %s R0@>%d,R3\n MOVW R3,%d(R4)\n", op, rotation, lane*4)
+			lane++
+		}
+	}
+	fmt.Fprintf(&source, " MOVW CPSR,R6\n SRL $28,R6\n MOVW R6,%d(R4)\n RET\n", lane*4)
+	for _, value := range []uint32{0, 0x80ff7f01, 0xffffffff, 0x12345678} {
+		for flags := uint32(0); flags < 16; flags++ {
+			fmt.Fprintf(&goVectors, "{%d,%d,[25]uint32{", value, flags<<28)
+			fmt.Fprintf(&cVectors, "{%du,%du,{", value, flags<<28)
+			for _, op := range []string{"MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+				for _, rotation := range []int{0, 8, 16, 24} {
+					rotated := bits.RotateLeft32(value, -rotation)
+					var want uint32
+					switch op {
+					case "MOVB", "MOVBS":
+						want = uint32(int32(int8(rotated)))
+					case "MOVBU":
+						want = uint32(uint8(rotated))
+					case "MOVH", "MOVHS":
+						want = uint32(int32(int16(rotated)))
+					case "MOVHU":
+						want = uint32(uint16(rotated))
+					}
+					fmt.Fprintf(&goVectors, "%d,", want)
+					fmt.Fprintf(&cVectors, "%du,", want)
+				}
+			}
+			fmt.Fprintf(&goVectors, "%d}},\n", flags)
+			fmt.Fprintf(&cVectors, "%du}},\n", flags)
+		}
+	}
+	goMain := fmt.Sprintf(`package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *[25]uint32)
+var vectors=[]struct{value,status uint32;want [25]uint32}{%s}
+func main(){for i,v:=range vectors{var out [25]uint32;oracle(v.value,0,0,v.status,&out);if out!=v.want{panic(fmt.Sprintf("Go extension vector=%%d got=%%x want=%%x",i,out,v.want))}};fmt.Println("all extension rotations preserve NZCV; rotation zero is not RRX")}
+`, goVectors.String())
+	runARMGoSourceOracle(t, source.String(), goMain)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+static const struct{uint32_t value,status,want[25];}vectors[]={%s};
+int main(void){for(unsigned i=0;i<sizeof(vectors)/sizeof(vectors[0]);i++){uint32_t out[25]={0};oracle(vectors[i].value,0,0,vectors[i].status,out);for(unsigned j=0;j<25;j++)if(out[j]!=vectors[i].want[j]){fprintf(stderr,"LLVM extension vector=%%u lane=%%u got=%%x want=%%x\n",i,j,out[j],vectors[i].want[j]);return 1;}}return 0;}
+`, cVectors.String())
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "extension_rotations", "armv7-unknown-linux-gnueabihf", ir, cMain,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_flags.go b/arm_flags.go
index 922c62f2a..aaa0a170b 100644
--- a/arm_flags.go
+++ b/arm_flags.go
@@ -38,6 +38,32 @@ func (c *armCtx) storeFlagsFromStatus(status string) {
 	c.flagsWritten = true
 }
 
+// LLVM arithmetic does not carry Plan 9's modeled NZCV in physical APSR.
+// Keep the physical non-NZCV status bits, but read the same condition state
+// used by source predicates after a source flags write or typed native call.
+func (c *armCtx) statusWithModeledNZCV(status string) string {
+	if !c.flagsWritten {
+		return status
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 268435455\n", result, status)
+	for _, item := range []struct {
+		shift int
+		slot  string
+	}{
+		{31, c.flagsNSlot}, {30, c.flagsZSlot},
+		{29, c.flagsCSlot}, {28, c.flagsVSlot},
+	} {
+		flag, wide, shifted, merged := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", flag, item.slot)
+		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i32\n", wide, flag)
+		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %d\n", shifted, wide, item.shift)
+		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", merged, result, shifted)
+		result = merged
+	}
+	return "%" + result
+}
+
 func (c *armCtx) storeFlagCond(cond, slot, v string) error {
 	if cond == "" || strings.EqualFold(cond, "AL") {
 		c.storeFlag(slot, v)
@@ -56,6 +82,11 @@ func (c *armCtx) storeFlagCond(cond, slot, v string) error {
 }
 
 func (c *armCtx) setFlagsSub(cond, dst, src, res string) error {
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		return c.emitConditionalEffect(cond, func() error {
+			return c.setFlagsSub("", dst, src, res)
+		})
+	}
 	c.flagsWritten = true
 	z := c.newTmp()
 	n := c.newTmp()
@@ -84,6 +115,11 @@ func (c *armCtx) setFlagsSub(cond, dst, src, res string) error {
 }
 
 func (c *armCtx) setFlagsAdd(cond, dst, src, res string) error {
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		return c.emitConditionalEffect(cond, func() error {
+			return c.setFlagsAdd("", dst, src, res)
+		})
+	}
 	c.flagsWritten = true
 	z := c.newTmp()
 	n := c.newTmp()
@@ -114,6 +150,11 @@ func (c *armCtx) setFlagsAdd(cond, dst, src, res string) error {
 }
 
 func (c *armCtx) setFlagsLogic(cond, res string) error {
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		return c.emitConditionalEffect(cond, func() error {
+			return c.setFlagsLogic("", res)
+		})
+	}
 	c.flagsWritten = true
 	z := c.newTmp()
 	n := c.newTmp()
@@ -125,6 +166,42 @@ func (c *armCtx) setFlagsLogic(cond, res string) error {
 	return c.storeFlagCond(cond, c.flagsNSlot, "%"+n)
 }
 
+// Go's ARM C_RCON row encodes an eight-bit immediate rotated right by an
+// even count. A nonzero rotation supplies C from bit 31; an unshifted register
+// (including a materialized large constant) preserves C. AND's C_NCON row
+// instead uses BIC with the complemented immediate (asm5 encoder type 114).
+func armLogicalImmediateCarry(op string, source Operand) string {
+	if source.Kind != OpImm || source.ImmRaw != "" {
+		return ""
+	}
+	value := uint32(source.Imm)
+	if op == "AND" && !armRotatedImmediateEncodable(value) && armRotatedImmediateEncodable(^value) {
+		value = ^value
+	}
+	if value <= 255 || !armRotatedImmediateEncodable(value) {
+		return ""
+	}
+	if value&(1<<31) != 0 {
+		return "true"
+	}
+	return "false"
+}
+
+func (c *armCtx) setARMLogicalFlags(condition, result, carry string) error {
+	if condition != "" && !strings.EqualFold(condition, "AL") {
+		return c.emitConditionalEffect(condition, func() error {
+			return c.setARMLogicalFlags("", result, carry)
+		})
+	}
+	if err := c.setFlagsLogic("", result); err != nil {
+		return err
+	}
+	if carry != "" {
+		c.storeFlag(c.flagsCSlot, carry)
+	}
+	return nil
+}
+
 func (c *armCtx) condValue(cond string) (string, error) {
 	if !c.flagsWritten {
 		return "", fmt.Errorf("%w: arm condition %s has no prior flags write", ErrProbeNeedsContext, cond)
diff --git a/arm_float_register_effects_test.go b/arm_float_register_effects_test.go
new file mode 100644
index 000000000..73c94d188
--- /dev/null
+++ b/arm_float_register_effects_test.go
@@ -0,0 +1,230 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Each fixture initializes and observes whole D registers. In particular the
+// other half of an S write is a known canary, not an unspecified native value.
+type armFloatEffectCase struct {
+	instruction string
+	input       [4]uint64 // D0, D1, D15, R2 (low word)
+	want        [4]uint64
+}
+
+func armFloatEffectSeed() [4]uint64 {
+	return [4]uint64{0x4312345640000000, 0x4423456740800000, 0x4534567840e00000, 0xabcdef0100000003}
+}
+
+func armFloatEffectLow(old uint64, low uint32) uint64 {
+	return old&0xffffffff00000000 | uint64(low)
+}
+
+func armFloatConversionEffectCases() []armFloatEffectCase {
+	var cases []armFloatEffectCase
+	// Go asm5 rows 84/85 have no hidden destination. Rows 86/87 use S30
+	// (the low half of F15), including when an explicit operand aliases F15.
+	for _, op := range []string{"MOVWF", "MOVWD", "MOVFW", "MOVDW"} {
+		toFloat := strings.HasPrefix(op, "MOVW")
+		double := strings.Contains(op, "D")
+		for _, unsigned := range []bool{false, true} {
+			for _, pair := range [][2]string{
+				{"F0", "F1"}, {"F0", "F0"}, {"F15", "F0"},
+				{"F0", "F15"}, {"F15", "F15"}, {"R2", "F0"}, {"R2", "F15"},
+			} {
+				if !toFloat && pair[0] == "R2" {
+					pair[0], pair[1] = pair[1], pair[0]
+				}
+				for _, condition := range []string{"", ".EQ", ".NE"} {
+					index := func(reg string) int {
+						switch reg {
+						case "F0":
+							return 0
+						case "F1":
+							return 1
+						case "F15":
+							return 2
+						default:
+							return 3
+						}
+					}
+					src, dst := index(pair[0]), index(pair[1])
+					input := armFloatEffectSeed()
+					integer := uint32(0xfffffff9) // -7; exact at either precision.
+					floating := -7.75
+					if unsigned {
+						integer = 0x80000000
+						floating = 3221225472 // exact, above the signed boundary.
+					}
+					if toFloat {
+						input[src] = armFloatEffectLow(input[src], integer)
+					} else if double {
+						input[src] = math.Float64bits(floating)
+					} else {
+						input[src] = armFloatEffectLow(input[src], math.Float32bits(float32(floating)))
+					}
+					want := input
+					if condition != ".NE" {
+						if toFloat {
+							value := float64(int32(integer))
+							if unsigned {
+								value = float64(integer)
+							}
+							if src == 3 {
+								want[2] = armFloatEffectLow(want[2], integer)
+							}
+							if double {
+								want[dst] = math.Float64bits(value)
+							} else {
+								want[dst] = armFloatEffectLow(want[dst], math.Float32bits(float32(value)))
+							}
+						} else {
+							value := uint32(int32(floating))
+							if unsigned {
+								value = uint32(floating)
+							}
+							if dst == 3 {
+								want[2] = armFloatEffectLow(want[2], value)
+							}
+							want[dst] = armFloatEffectLow(want[dst], value)
+						}
+					}
+					suffix := condition
+					if unsigned {
+						suffix = ".U" + suffix
+					}
+					cases = append(cases, armFloatEffectCase{
+						instruction: fmt.Sprintf("%s%s %s,%s", op, suffix, pair[0], pair[1]),
+						input:       input, want: want,
+					})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func armFloatHalfWriteEffectCases() []armFloatEffectCase {
+	var cases []armFloatEffectCase
+	// Cover every named producer using the common single-register writer,
+	// including all arithmetic aliases, two/three operands, and full-D controls.
+	for _, operation := range []struct {
+		op, operands string
+		value        float32
+	}{
+		{"MOVF", "$2.0,F1", 2}, {"MOVF", "F0,F1", 2}, {"MOVF", "F1,F1", 4},
+		{"MOVF", "0(R0),F1", 2}, {"MOVW", "R2,F1", math.Float32frombits(3)},
+		{"ADDF", "F0,F1", 6}, {"ADDF", "F0,F1,F1", 6},
+		{"SUBF", "F0,F1", 2}, {"SUBF", "F0,F1,F1", 2},
+		{"MULF", "F0,F1", 8}, {"MULF", "F0,F1,F1", 8},
+		{"NMULF", "F0,F1", -8}, {"NMULF", "F0,F1,F1", -8},
+		{"DIVF", "F0,F1", 2}, {"DIVF", "F0,F1,F1", 2},
+		{"MULAF", "F0,F1,F1", 12}, {"FMULAF", "F0,F1,F1", 12},
+		{"MULSF", "F0,F1,F1", -4}, {"FMULSF", "F0,F1,F1", -4},
+		{"NMULAF", "F0,F1,F1", -12}, {"FNMULAF", "F0,F1,F1", -12},
+		{"NMULSF", "F0,F1,F1", 4}, {"FNMULSF", "F0,F1,F1", 4},
+		{"NEGF", "F1,F1", -4}, {"ABSF", "F1,F1", 4}, {"SQRTF", "F1,F1", 2},
+		{"MOVDF", "F0,F1", 2}, {"MOVD", "F0,F1", 2}, {"MOVFD", "F0,F1", 2},
+	} {
+		for _, condition := range []string{"", ".EQ", ".NE"} {
+			input := armFloatEffectSeed()
+			if operation.op == "MOVDF" || operation.op == "MOVD" {
+				input[0] = math.Float64bits(2)
+			}
+			want := input
+			if condition != ".NE" {
+				if operation.op == "MOVD" || operation.op == "MOVFD" {
+					want[1] = math.Float64bits(float64(operation.value))
+				} else {
+					want[1] = armFloatEffectLow(want[1], math.Float32bits(operation.value))
+				}
+			}
+			cases = append(cases, armFloatEffectCase{
+				instruction: operation.op + condition + " " + operation.operands,
+				input:       input, want: want,
+			})
+		}
+	}
+	return cases
+}
+
+func armFloatEffectSource(cases []armFloatEffectCase) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig, len(cases))
+	for i, fixture := range cases {
+		name := fmt.Sprintf("effect%d", i)
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-8
+MOVW input+0(FP),R0
+MOVW output+4(FP),R1
+MOVD 0(R0),F0
+MOVD 8(R0),F1
+MOVD 16(R0),F15
+MOVW 24(R0),R2
+MOVW $0,R3
+CMP $0,R3
+%s
+MOVD F0,0(R1)
+MOVD F1,8(R1)
+MOVD F15,16(R1)
+MOVW R2,24(R1)
+RET
+`, name, fixture.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	return source.String(), sigs
+}
+
+func TestARMFloatRegisterEffectMatrixCoverage(t *testing.T) {
+	conversions := armFloatConversionEffectCases()
+	writers := armFloatHalfWriteEffectCases()
+	if len(conversions) != 168 || len(writers) != 87 {
+		t.Fatalf("incomplete effect matrix: conversions=%d writers=%d", len(conversions), len(writers))
+	}
+	source, sigs := armFloatEffectSource(append(conversions, writers...))
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm-float-effects.ll", "arm-float-effects.o", ir)
+		})
+	}
+}
+
+func armFloatEffectOptimizedIR(t *testing.T, ir string) string {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	return module.String()
+}
diff --git a/arm_fp.go b/arm_fp.go
index 441bfb2e9..e8aeede05 100644
--- a/arm_fp.go
+++ b/arm_fp.go
@@ -25,7 +25,7 @@ func (c *armCtx) markFPResultAddrTaken(off int64) {
 
 func (c *armCtx) storeFPResult32(off int64, v32 string) error {
 	for _, meta := range c.fpResults {
-		if meta.Type != I64 || (off != meta.Offset && off != meta.Offset+4) {
+		if meta.Type != I64 && meta.Type != LLVMType("double") || (off != meta.Offset && off != meta.Offset+4) {
 			continue
 		}
 		slot := c.fpResAllocaIdx[meta.Index]
@@ -33,22 +33,34 @@ func (c *armCtx) storeFPResult32(off int64, v32 string) error {
 			return fmt.Errorf("arm: missing FP result alloca for index %d", meta.Index)
 		}
 		old := c.newTmp()
+		oldBits := "%" + old
 		word := c.newTmp()
 		cleared := c.newTmp()
-		fmt.Fprintf(c.b, "  %%%s = load i64, ptr %s\n", old, slot)
+		fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s\n", old, meta.Type, slot)
+		if meta.Type == LLVMType("double") {
+			bits := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", bits, oldBits)
+			oldBits = "%" + bits
+		}
 		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", word, v32)
 		inserted := "%" + word
 		if off == meta.Offset {
-			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, -4294967296\n", cleared, old)
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, -4294967296\n", cleared, oldBits)
 		} else {
-			fmt.Fprintf(c.b, "  %%%s = and i64 %%%s, 4294967295\n", cleared, old)
+			fmt.Fprintf(c.b, "  %%%s = and i64 %s, 4294967295\n", cleared, oldBits)
 			shifted := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", shifted, word)
 			inserted = "%" + shifted
 		}
 		merged := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", merged, cleared, inserted)
-		fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", merged, slot)
+		stored := "%" + merged
+		if meta.Type == LLVMType("double") {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to double\n", value, stored)
+			stored = "%" + value
+		}
+		fmt.Fprintf(c.b, "  store %s %s, ptr %s\n", meta.Type, stored, slot)
 		c.fpResWritten[meta.Index] = true
 		return nil
 	}
diff --git a/arm_fp_address_context_test.go b/arm_fp_address_context_test.go
new file mode 100644
index 000000000..c719d8e76
--- /dev/null
+++ b/arm_fp_address_context_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARMFPAddressRequiresBoundStorage(t *testing.T) {
+	for _, arch := range []Arch{ArchARM, ArchARM64} {
+		for _, op := range []Operand{
+			{Kind: OpFPAddr, FPName: "argframe", FPOffset: 0},
+			{Kind: OpFPAddr, FPName: "argframe", FPOffset: 99},
+			{Kind: OpFPAddr, FPName: "sp", FPOffset: -4},
+			{Kind: OpFPAddr, FPName: "SP", FPOffset: -4},
+			{Kind: OpFPAddr, FPName: "sp", FPOffset: -8},
+			{Kind: OpFPAddr, FPName: "missing", FPOffset: 16},
+		} {
+			t.Run(string(arch)+"/"+op.String(), func(t *testing.T) {
+				var output strings.Builder
+				sig := FuncSig{Name: "address", Ret: Void}
+				var value string
+				var err error
+				if arch == ArchARM {
+					c := newARMCtx(&output, Func{}, sig, testResolveSym("example"), nil, false)
+					value, err = c.evalFPAddr32(op)
+				} else {
+					c := newARM64Ctx(&output, Func{}, sig, testResolveSym("example"), nil, false)
+					value, err = c.evalFPAddr64(op)
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || value != "" {
+					t.Fatalf("unbound FP address must not become a zero pointer: (%q, %v)", value, err)
+				}
+				if output.Len() != 0 {
+					t.Fatalf("unbound FP address emitted IR: %s", output.String())
+				}
+			})
+		}
+	}
+}
+
+func TestARMFPAddressDeclaredSlotNeedsBacking(t *testing.T) {
+	// A slot declaration alone is not storage. The lowering must have emitted
+	// the typed backing before taking its address.
+	sig := FuncSig{Name: "address", Args: []LLVMType{I32}, Ret: I32, Frame: FrameLayout{
+		Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+		Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+	}}
+	for _, arch := range []Arch{ArchARM, ArchARM64} {
+		for _, off := range []int64{0, 4} {
+			t.Run(fmt.Sprintf("%s/%d", arch, off), func(t *testing.T) {
+				var output strings.Builder
+				op := Operand{Kind: OpFPAddr, FPName: "declared", FPOffset: off}
+				var err error
+				if arch == ArchARM {
+					c := newARMCtx(&output, Func{}, sig, testResolveSym("example"), nil, false)
+					_, err = c.evalFPAddr32(op)
+				} else {
+					c := newARM64Ctx(&output, Func{}, sig, testResolveSym("example"), nil, false)
+					_, err = c.evalFPAddr64(op)
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("a declaration without backing must retain context failure: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateARMUnboundFPAddressesRetainContext(t *testing.T) {
+	for _, arch := range []Arch{ArchARM, ArchARM64} {
+		goarch, move, triple := "arm", "MOVW", "armv7-unknown-linux-gnueabihf"
+		if arch == ArchARM64 {
+			goarch, move, triple = "arm64", "MOVD", "aarch64-unknown-linux-gnu"
+		}
+		for _, address := range []string{"$argframe(FP)", "$argframe+99(FP)", "$sp-4(FP)", "$sp-8(FP)", "$missing+16(FP)"} {
+			t.Run(goarch+"/"+address, func(t *testing.T) {
+				// Keep the original caller-SP source, including its TEXT and RET.
+				// Go accepts the address spelling; that does not supply LLVM with
+				// a caller-owned frame or justify replacing its address with zero.
+				source := "TEXT address(SB),NOSPLIT,$8-0\n\t" + move + " " + address + ", R7\n\tRET\n"
+				// The existing Go object helper does not include textflag.h;
+				// provide its NOSPLIT value without rewriting the parsed source.
+				goSource := "#define NOSPLIT 4\n" + source
+				if arch == ArchARM {
+					requireARMGoAssemblerResult(t, goSource, true)
+				} else {
+					requireARM64GoAssemblerResult(t, goSource, true)
+				}
+				file, err := Parse(arch, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				instruction := file.Funcs[0].Instrs[1]
+				if err := ProbeInstruction(arch, goarch, instruction); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("single-instruction FP probe lost its frame context: %v", err)
+				}
+				if err := ProbeInstructionSequence(arch, goarch, []Instr{instruction}); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "bound typed frame storage") {
+					t.Errorf("FP address sequence lost its unbound-storage context: %v", err)
+				}
+				options := Options{Goarch: goarch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"address": {Name: "address", Ret: Void}},
+				}
+				if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "bound typed frame storage") {
+					t.Errorf("full source translation accepted an unbound FP address: %v", err)
+				}
+				module, err := TranslateModule(file, options)
+				if err == nil {
+					module.Dispose()
+					t.Error("module translation accepted an unbound FP address")
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "bound typed frame storage") {
+					t.Fatalf("module translation lost the FP address context: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateARMFPAddressesTypedStorageLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, arch := range []Arch{ArchARM, ArchARM64} {
+		goarch, move, word, typ := "arm", "MOVW", 4, I32
+		triples := []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"}
+		if arch == ArchARM64 {
+			goarch, move, word, typ = "arm64", "MOVD", 8, I64
+			triples = []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"}
+		}
+		// Binding is by the typed offset, not a name-based whitelist: the old
+		// argframe/sp spellings must use real backing when a slot is supplied.
+		source := fmt.Sprintf(`TEXT address(SB),4,$8-%d
+	%s $value+0(FP), R0
+	%s $result+%d(FP), R1
+	%s $argframe(FP), R2
+	%s $sp+%d(FP), R3
+	%s $7, R0
+	%s R0, result+%d(FP)
+	RET
+`, 2*word, move, move, word, move, move, word, move, move, word)
+		if arch == ArchARM {
+			requireARMGoAssemblerResult(t, source, true)
+		} else {
+			requireARM64GoAssemblerResult(t, source, true)
+		}
+		file, err := Parse(arch, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := FuncSig{Name: "address", Args: []LLVMType{typ}, Ret: typ, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: int64(word), Type: typ, Index: 0, Field: -1}},
+		}}
+		for _, triple := range triples {
+			t.Run(triple, func(t *testing.T) {
+				ir, err := Translate(file, Options{Goarch: goarch, TargetTriple: triple,
+					Sigs: map[string]FuncSig{"address": sig},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got := strings.Count(ir, "ptrtoint ptr %fp_"); got != 4 {
+					t.Fatalf("typed FP addresses must use four actual backing addresses, got %d:\n%s", got, ir)
+				}
+				compileLLVMToObject(t, llc, triple, "typed-fp-address.ll", "typed-fp-address.o", ir)
+			})
+		}
+	}
+}
diff --git a/arm_fp_symbol_offset_context_go127_test.go b/arm_fp_symbol_offset_context_go127_test.go
new file mode 100644
index 000000000..cf2b5e3e2
--- /dev/null
+++ b/arm_fp_symbol_offset_context_go127_test.go
@@ -0,0 +1,208 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type armFPSymbolTarget struct {
+	arch    Arch
+	goarch  string
+	ops     []string
+	suffix  []string
+	triples []string
+}
+
+var armFPSymbolTargets = []armFPSymbolTarget{
+	{ArchARM, "arm", []string{"MOVF", "MOVD"},
+		[]string{"", ".U", ".P", ".W", ".U.P", ".U.W", ".P.W", ".U.P.W", ".EQ", ".NE.P", ".EQ.U.W"},
+		[]string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"}},
+	{ArchARM64, "arm64", []string{"FMOVS", "FMOVD", "FMOVQ"}, []string{""},
+		[]string{"aarch64-unknown-linux-gnu", "arm64-apple-macosx", "aarch64-pc-windows-msvc"}},
+}
+
+func armFPSymbolRows(target armFPSymbolTarget, expressions []string) []string {
+	var rows []string
+	for _, op := range target.ops {
+		for _, suffix := range target.suffix {
+			for _, expression := range expressions {
+				rows = append(rows, op+suffix+" ·memory"+expression+"(SB),F0",
+					op+suffix+" F0,·memory"+expression+"(SB)")
+			}
+		}
+	}
+	return rows
+}
+
+func armFPSymbolProgram(rows []string, resolved bool) string {
+	prefix := ""
+	if resolved {
+		prefix = "#define OFFSET 4\nDATA ·memory+0(SB)/8,$0x0123456789abcdef\nGLOBL ·memory(SB),8,$64\n"
+	}
+	return prefix + "TEXT ·Probe(SB),4,$0-0\nCMP R2,R2\n" + strings.Join(rows, "\n") + "\nRET\n"
+}
+
+func TestARMFPSymbolOffsetCompleteOriginalGoRows(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj")
+	arm, err := os.ReadFile(filepath.Join(root, "arm", "asm5.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{AMOVF, (C_FREG|C_ADDR), C_NONE, (C_FREG|C_ADDR), (68|69),`).FindAllString(string(arm), -1)
+	if len(rows) != 2 || !regexp.MustCompile(`case AMOVF:\s*opset\(AMOVD, r0\)`).Match(arm) {
+		t.Fatal("actual ARM symbol FP load/store rows or MOVD alias changed")
+	}
+	arm64, err := os.ReadFile(filepath.Join(root, "arm64", "asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows64 := regexp.MustCompile(`\{AFMOV([SDQ]), (C_FREG|C_ADDR), C_NONE, C_NONE, (C_FREG|C_ADDR), C_NONE, (64|65),`).FindAllStringSubmatch(string(arm64), -1)
+	counts := map[string]int{}
+	for _, row := range rows64 {
+		if row[2] == row[3] {
+			t.Fatal("an unrelated row acquired the C_ADDR FP role", row)
+		}
+		counts[row[1]]++
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"S": 2, "D": 2, "Q": 2}) {
+		t.Fatal("actual ARM64 complete FP symbol family changed", counts)
+	}
+	for _, target := range armFPSymbolTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			goAssemblerOracleOutput(t, target.goarch,
+				armFPSymbolProgram(armFPSymbolRows(target, []string{"+OFFSET", "-OFFSET"}), true), "", true)
+		})
+	}
+}
+
+func TestARMFPSymbolOffsetNeedsOriginalConstants(t *testing.T) {
+	for _, target := range armFPSymbolTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			rows := armFPSymbolRows(target, []string{"+OFFSET", "+(OFFSET/(OFFSET+1))"})
+			// This prior precedes every probe/API, and uses the same complete
+			// source with real definitions instead of guessed placeholder bytes.
+			goAssemblerOracleOutput(t, target.goarch, armFPSymbolProgram(rows, true), "", true)
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+			for _, row := range rows {
+				t.Run(row, func(t *testing.T) {
+					source := armFPSymbolProgram([]string{row}, false)
+					file, err := Parse(target.arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					instruction := file.Funcs[0].Instrs[2]
+					original := append([]Operand(nil), instruction.Args...)
+					for _, err := range []error{
+						ProbeInstruction(target.arch, target.goarch, instruction),
+						ProbeInstructionSequence(target.arch, target.goarch, []Instr{instruction}),
+					} {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Errorf("valid original FP symbol expression was not contextual: %v", err)
+						}
+					}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						ctx := llvm.NewContext()
+						module, _, err := goASMIntegerGrammarTranslate(ctx, pkg, source,
+							target.arch, target.goarch, target.triples[0], api)
+						created := !module.IsNil()
+						if created {
+							module.Dispose()
+						}
+						ctx.Dispose()
+						if !errors.Is(err, ErrProbeNeedsContext) || created {
+							t.Errorf("%s guessed or lost the original generated FP offset: created=%t %v", api, created, err)
+						}
+					}
+					if !reflect.DeepEqual(file.Funcs[0].Instrs[2].Args, original) {
+						t.Fatal("the original unresolved operand was rewritten")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestARMFPSymbolOffsetConcreteOriginalObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 is required for original resolved FP symbol objects")
+	}
+	for _, target := range armFPSymbolTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			source := armFPSymbolProgram(armFPSymbolRows(target, []string{"+OFFSET", "-OFFSET"}), true)
+			goAssemblerOracleOutput(t, target.goarch, source, "", true)
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+			for _, triple := range target.triples {
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(triple+"/"+api, func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						module, _, err := goASMIntegerGrammarTranslate(ctx, pkg, source,
+							target.arch, target.goarch, triple, api)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						if err != nil || module.IsNil() {
+							t.Fatal("resolved original symbol source no longer translates", err)
+						}
+						compileLLVMToObject(t, llc, triple, "fp-symbol.ll", "fp-symbol.o", module.String())
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestARMFPSymbolOffsetDoesNotHideInvalidGrammar(t *testing.T) {
+	for _, target := range armFPSymbolTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			var rows []string
+			for _, op := range target.ops {
+				rows = append(rows,
+					op+" ·memory+OFFSET(SB),R2", op+" R2,·memory+OFFSET(SB)",
+					op+" ·memory+OFFSET(SB),SP", op+".S ·memory+OFFSET(SB),F0",
+					op+" $·memory+OFFSET(SB),F0", op+" F0,$·memory+OFFSET(SB)",
+					op+" ·memory+OFFSET(SB),·other(SB)", op+" ·memory+(OFFSET+)(SB),F0",
+					op+" ·memory+(OFFSET/0)(SB),F0", op+" ·memory+1.5(SB),F0",
+					op+" ·memory+OFFSET(XX),F0", op+" ·memory+OFFSET(SB)",
+					op+" ·memory+OFFSET(SB),F0,F1")
+				if target.arch == ArchARM64 {
+					rows = append(rows, op+".P ·memory+OFFSET(SB),F0", op+".W F0,·memory+OFFSET(SB)")
+				}
+			}
+			if target.arch == ArchARM64 {
+				for _, op := range []string{"FMOVB", "FMOVH"} {
+					rows = append(rows, op+" ·memory+OFFSET(SB),F0", op+" F0,·memory+OFFSET(SB)")
+				}
+			}
+			for _, row := range rows {
+				t.Run(row, func(t *testing.T) {
+					goAssemblerOracleOutput(t, target.goarch, armFPSymbolProgram([]string{row}, true), "", false)
+					file, err := Parse(target.arch, armFPSymbolProgram([]string{row}, false))
+					if err != nil {
+						return // Actual Go rejection already bound this original row.
+					}
+					instruction := file.Funcs[0].Instrs[2]
+					for _, err := range []error{
+						ProbeInstruction(target.arch, target.goarch, instruction),
+						ProbeInstructionSequence(target.arch, target.goarch, []Instr{instruction}),
+					} {
+						if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+							t.Errorf("invalid FP operand acquired a contextual instruction role: %v", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/arm_helper_edge_test.go b/arm_helper_edge_test.go
index f5af1c8f0..b68cc1afd 100644
--- a/arm_helper_edge_test.go
+++ b/arm_helper_edge_test.go
@@ -65,6 +65,9 @@ func TestARMParserFlagAndHelperEdges(t *testing.T) {
 		t.Fatalf("storeFlagCond(AL) error = %v", err)
 	}
 	c.flagsWritten = true
+	if err := c.storeFlagCond("EQ", c.flagsZSlot, "true"); err != nil {
+		t.Fatalf("single-flag storeFlagCond(EQ) error = %v", err)
+	}
 	for _, cond := range []string{"EQ", "NE", "CS", "CC", "HI", "LS", "LT", "GE", "GT", "LE", "MI", "PL", "VS", "VC", "AL"} {
 		if got, err := c.condValue(cond); err != nil || got == "" {
 			t.Fatalf("condValue(%s) = (%q, %v)", cond, got, err)
@@ -88,7 +91,7 @@ func TestARMParserFlagAndHelperEdges(t *testing.T) {
 	}
 
 	out := b.String()
-	for _, want := range []string{"store i1 true", "select i1", "icmp eq i1", "xor i1", "or i1"} {
+	for _, want := range []string{"store i1 true", "select i1", "br i1", "icmp eq i1", "xor i1", "or i1"} {
 		if !strings.Contains(out, want) {
 			t.Fatalf("missing %q in output:\n%s", want, out)
 		}
diff --git a/arm_instruction_flags_fixture_test.go b/arm_instruction_flags_fixture_test.go
new file mode 100644
index 000000000..c3ca21249
--- /dev/null
+++ b/arm_instruction_flags_fixture_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARMSingleInstructionProbeSuppliesExplicitFlagsFixture(t *testing.T) {
+	var objectSource strings.Builder
+	objectSource.WriteString("TEXT fixture(SB),4,$0\n")
+	for _, op := range []string{"ADC", "SBC", "RSC"} {
+		for _, source := range []string{"R0", "$255", "R0<<28", "R0>>28", "R0->28", "R0@>28", "R0<<R1", "R0>>R1", "R0->R1", "R0@>R1"} {
+			for _, destination := range []string{"R2", "R2,R3"} {
+				instruction := op + " " + source + "," + destination
+				file, err := Parse(ArchARM, "TEXT fixture(SB),$0\n "+instruction+"\n RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if err := ProbeInstruction(ArchARM, "arm", ins); err != nil {
+					t.Errorf("single-form fixture supplies explicit source carry for %s: %v", instruction, err)
+				}
+				if err := ProbeInstructionSequence(ArchARM, "arm", []Instr{ins}); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("a source sequence must not invent entry carry for %s: %v", instruction, err)
+				}
+				objectSource.WriteString(" CMP R0,R0\n " + instruction + "\n")
+			}
+		}
+	}
+	objectSource.WriteString(" RET\n")
+	requireARMGoAssemblerResult(t, objectSource.String(), true)
+
+	conditional, err := Parse(ArchARM, "TEXT fixture(SB),$0\n MOVW.EQ $1,R2\n RET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := conditional.Funcs[0].Instrs[1]
+	if err := ProbeInstruction(ArchARM, "arm", ins); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unrelated predicate-only form retains its context boundary: %v", err)
+	}
+	if err := ProbeInstructionSequence(ArchARM, "arm", []Instr{ins}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("full sequence cannot invent incoming predicate: %v", err)
+	}
+}
+
+func TestARMFlagsProbeFixtureDoesNotInventNativeCPSR(t *testing.T) {
+	for _, instruction := range []string{"MOVW CPSR,R0", "MOVW.EQ CPSR,R0"} {
+		file, err := Parse(ArchARM, "TEXT fixture(SB),$0\n "+instruction+"\n RET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := ProbeInstruction(ArchARM, "arm", file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("native CPSR source cannot be replaced by synthetic flags: %s: %v", instruction, err)
+		}
+	}
+}
diff --git a/arm_integer_memory_test.go b/arm_integer_memory_test.go
new file mode 100644
index 000000000..0ad88d70d
--- /dev/null
+++ b/arm_integer_memory_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARMIntegerMemoryShiftEffects(t *testing.T) {
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, load := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/load=%v", op, load), func(t *testing.T) {
+				instruction := op + " R2, g<<0(R1)"
+				if load {
+					instruction = op + " g<<0(R1), R2"
+				}
+				source := "TEXT memshift(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+				requireARMGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := Translate(file, Options{Goarch: "arm", Sigs: map[string]FuncSig{"memshift": {Name: "memshift", Ret: Void}}})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, "load i32, ptr %reg_R10") {
+					t.Fatal("shifted address discarded its g/R10 index")
+				}
+			})
+		}
+	}
+}
+
+func TestARMIntegerMemoryWritebackAndConditionalEffects(t *testing.T) {
+	for _, instruction := range []string{"MOVW.W 8(R1), R2", "MOVW.W R2, 8(R1)", "MOVBU.W 8(R1), R2", "MOVH.W 8(R1), R2"} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT memwriteback(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			ir := translateARMForTest(t, source, map[string]FuncSig{"example.memwriteback": {Name: "example.memwriteback", Ret: Void}})
+			writes := 0
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, "store i32") && strings.Contains(line, ", ptr %reg_R1,") {
+					writes++
+				}
+			}
+			if writes < 2 { // entry initialization plus actual address writeback
+				t.Fatalf("pre-indexed memory operation discarded .W writeback:\n%s", ir)
+			}
+		})
+	}
+	const source = "TEXT condmem(SB),$0-0\n\tCMP R0, R0\n\tMOVW.NE.P 8(R1), R2\n\tRET\n"
+	requireARMGoAssemblerResult(t, source, true)
+	ir := translateARMForTest(t, source, map[string]FuncSig{"example.condmem": {Name: "example.condmem", Ret: Void}})
+	if !strings.Contains(ir, "cond_5feffect_5ftaken") {
+		t.Fatal("conditional memory load/writeback executes unconditionally")
+	}
+}
+
+func TestARMIntegerMemoryGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm/asm5.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A(MOV\w+), C_(SHIFTADDR|REG), C_NONE, C_(SHIFTADDR|REG),`).FindAllStringSubmatch(string(data), -1)
+	seen := map[string]int{}
+	for _, row := range rows {
+		if row[2] == row[3] {
+			continue
+		}
+		if _, ok := armIntegerMemorySpecs[row[1]]; !ok {
+			t.Errorf("Go C_SHIFTADDR family member %s missing", row[1])
+		}
+		seen[row[1]]++
+	}
+	if len(seen) != len(armIntegerMemorySpecs) || len(seen) != 7 {
+		t.Fatalf("Go shift-address grammar has %d mnemonics; spec has %d", len(seen), len(armIntegerMemorySpecs))
+	}
+	for op, count := range seen {
+		if count != 2 {
+			t.Errorf("%s has %d load/store rows, want two", op, count)
+		}
+	}
+}
+
+func TestARMIntegerMemoryNamedStackOffsets(t *testing.T) {
+	for _, tc := range []struct {
+		address string
+		offset  int64
+	}{
+		{"w+4(SP)", 4}, {"end-4(SP)", -4}, {"scratch(SP)", 0},
+	} {
+		for _, load := range []bool{false, true} {
+			instruction := "MOVW R7, " + tc.address
+			if load {
+				instruction = "MOVW " + tc.address + ", R7"
+			}
+			source := "TEXT stackoffset(SB),$32-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			form, err := parseARMIntegerMemoryForm("MOVW", file.Funcs[0].Instrs[1])
+			if err != nil || form.offset.Kind != OpImm || form.offset.Imm != tc.offset {
+				t.Errorf("%s: offset=%+v err=%v; want %d", instruction, form.offset, err, tc.offset)
+			}
+		}
+	}
+}
+
+type armMemoryTestCase struct {
+	op, instruction, suffix, offset string
+	load                            bool
+}
+
+func armIntegerMemoryCases() []armMemoryTestCase {
+	var cases []armMemoryTestCase
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, load := range []bool{false, true} {
+			full := op == "MOVW" || load && op == "MOVBU" || !load && (op == "MOVB" || op == "MOVBS" || op == "MOVBU")
+			offsets := []string{"0", "4", "-4", "R0<<0"}
+			if full {
+				for _, shift := range []string{"<<", ">>", "->", "@>"} {
+					for _, amount := range []int{0, 1, 31} {
+						if shift != "<<" || amount != 0 {
+							offsets = append(offsets, fmt.Sprintf("R0%s%d", shift, amount))
+						}
+					}
+				}
+			}
+			for _, offset := range offsets {
+				for _, suffix := range []string{"", ".U", ".W", ".P", ".U.W", ".U.P", ".P.W"} {
+					if full && offset == "-4" && strings.Contains(suffix, ".U") {
+						continue
+					}
+					instruction := op + suffix + " R2, " + offset + "(R1)"
+					if load {
+						instruction = op + suffix + " " + offset + "(R1), R2"
+					}
+					cases = append(cases, armMemoryTestCase{op, instruction, suffix, offset, load})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func TestARMIntegerMemoryCompleteFormsAcrossTargets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT memforms(SB),$0-0\n")
+	cases := armIntegerMemoryCases()
+	t.Logf("checking %d instruction/address combinations", len(cases))
+	for _, tc := range cases {
+		fmt.Fprintln(&source, tc.instruction)
+	}
+	source.WriteString("RET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"memforms": {Name: "memforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "mem.ll", "mem.o", ir)
+		})
+	}
+}
+
+func TestARMIntegerMemoryRejectsInvalidFormats(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVW R0<<R3(R1), R2", "MOVW R0<<32(R1), R2",
+		"MOVB R0<<1(R1), R2", "MOVBS R0>>0(R1), R2",
+		"MOVH R0@>1(R1), R2", "MOVHU R2, R0<<1(R1)",
+		"MOVHS R2, R0->0(R1)", "MOVW.S (R1), R2",
+		"MOVW.U -4(R1), R2", "MOVBU.U R2, -4(R1)",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT badmemory(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", Sigs: map[string]FuncSig{"badmemory": {Name: "badmemory", Ret: Void}}}); err == nil {
+				t.Fatal("accepted memory format rejected by Go")
+			}
+		})
+	}
+}
+
+// Execute the address-calculation IR on the host without dereferencing synthetic
+// 32-bit pointers. Actual ARM memory execution is a separate cross-runtime gate.
+func TestARMIntegerMemoryAddressModelRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var ir, declarations, checks strings.Builder
+	ir.WriteString("declare i32 @llvm.fshr.i32(i32, i32, i32)\n")
+	for i, tc := range armIntegerMemoryCases() {
+		file, err := Parse(ArchARM, "TEXT probe(SB),$0-0\n"+tc.instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		form, err := parseARMIntegerMemoryForm(tc.op, file.Funcs[0].Instrs[1])
+		if err != nil {
+			t.Fatalf("%s: %v", tc.instruction, err)
+		}
+		name := fmt.Sprintf("address_%d", i)
+		fmt.Fprintf(&ir, "define i64 @%s(i32 %%arg0, i32 %%arg1, i1 %%arg2) {\n", name)
+		c := newARMCtx(&ir, Func{}, FuncSig{Name: name, Args: []LLVMType{I32, I32, I1}, ArgRegs: []Reg{"R0", "R1", "R2"}, Ret: I64}, nil, nil, false)
+		if err := c.emitEntryAllocasAndArgInit(); err != nil {
+			t.Fatal(err)
+		}
+		c.storeFlag(c.flagsCSlot, "%arg2")
+		addr, updated, err := c.integerMemoryAddress(form)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !form.writeback {
+			updated = "%arg1"
+		}
+		fmt.Fprintf(&ir, "  %%address = zext i32 %s to i64\n  %%base = zext i32 %s to i64\n  %%hi = shl i64 %%address, 32\n  %%result = or i64 %%hi, %%base\n  ret i64 %%result\n}\n", addr, updated)
+		fmt.Fprintf(&declarations, "extern uint64_t %s(uint32_t, uint32_t, _Bool);\n", name)
+		for _, value := range []uint32{3, 0x80000003} {
+			for carry := uint32(0); carry <= 1; carry++ {
+				delta := uint32(0)
+				switch tc.offset {
+				case "0":
+				case "4":
+					delta = 4
+				case "-4":
+					delta = ^uint32(3)
+				default:
+					var shift string
+					var n uint
+					fmt.Sscanf(tc.offset, "R0%2s%d", &shift, &n)
+					if n == 0 {
+						shift = "<<" // Go oplook canonicalizes all non-extension zero shifts.
+					}
+					switch shift {
+					case "<<":
+						delta = value << n
+					case ">>":
+						delta = value >> n
+					case "->":
+						delta = uint32(int32(value) >> n)
+					case "@>":
+						delta = bits.RotateLeft32(value, -int(n))
+					default:
+						t.Fatalf("bad test shift %q", tc.offset)
+					}
+				}
+				if strings.Contains(tc.suffix, ".U") && (strings.HasPrefix(tc.offset, "R") || tc.op == "MOVW" || tc.load && tc.op == "MOVBU" || !tc.load && (tc.op == "MOVB" || tc.op == "MOVBS" || tc.op == "MOVBU")) {
+					delta = -delta
+				}
+				addr, after := uint32(1024)+delta, uint32(1024)
+				if strings.Contains(tc.suffix, ".P") || strings.Contains(tc.suffix, ".W") {
+					after += delta
+				}
+				if strings.Contains(tc.suffix, ".P") {
+					addr = 1024
+				}
+				want := uint64(addr)<<32 | uint64(after)
+				fmt.Fprintf(&checks, "if (%s(%du, 1024u, %du) != UINT64_C(%d)) { puts(\"%s\"); return 1; }\n", name, value, carry, want, tc.instruction)
+			}
+		}
+	}
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0; }\n"
+	compileAndRunRuntimeTest(t, llc, clang, "arm_address_model", ir.String(), mainC)
+}
diff --git a/arm_kernel_continuation.go b/arm_kernel_continuation.go
new file mode 100644
index 000000000..13b97fb74
--- /dev/null
+++ b/arm_kernel_continuation.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A source B retains its Go frame and its current physical LR. It is not a
+// Go RET helper, which restores the saved LR and removes the caller frame.
+// Until an explicit machine-state bridge models those continuations, native
+// tails require the same zero-frame leaf boundary used by Go's ARM obj5.go.
+func proveARMKernelContinuation(fn Func) error {
+	hasCall, hasTail, nonLeaf := false, false, false
+	for _, ins := range fn.Instrs {
+		if ins.armKernelCall != nil {
+			hasCall = true
+			hasTail = hasTail || ins.armKernelCall.tail
+		}
+		op, _, _, _ := armDecodeOp(string(ins.Op))
+		switch op {
+		case "BL", "CALL", "BX", "DIV", "DIVU", "MOD", "MODU", "DUFFZERO", "DUFFCOPY":
+			// Go's leaf scan includes unreachable instructions as well.
+			nonLeaf = true
+		}
+	}
+	if !hasCall {
+		return nil
+	}
+	noFrame, err := armKernelSourceNoFrame(fn)
+	if err != nil {
+		return err
+	}
+	if hasTail && (fn.FrameSize != 0 && fn.FrameSize != -4 || nonLeaf) {
+		return fmt.Errorf("%w: ARM kernel tail in %q needs a zero-frame leaf Go SP/LR continuation", ErrProbeNeedsContext, fn.Sym)
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpWORD || ins.Op == OpBYTE || ins.Op == "LONG" {
+			return fmt.Errorf("%w: ARM kernel continuation in %q needs a decoded raw SP/LR effect contract: %s", ErrProbeNeedsContext, fn.Sym, ins.Raw)
+		}
+		if ins.armKernelCall != nil && !ins.armKernelCall.tail && noFrame {
+			return fmt.Errorf("%w: ARM kernel BL/CALL in NOFRAME %q overwrites native LR without a source return bridge", ErrProbeNeedsContext, fn.Sym)
+		}
+		for _, arg := range ins.Args {
+			if armKernelOperandUsesReg(arg, "R14") {
+				return fmt.Errorf("%w: ARM kernel continuation in %q explicitly observes or replaces native LR: %s", ErrProbeNeedsContext, fn.Sym, ins.Raw)
+			}
+			if armKernelOperandUsesReg(arg, "R13") || armKernelOperandUsesReg(arg, SP) {
+				return fmt.Errorf("%w: ARM kernel continuation in %q needs explicit source SP backing/provenance: %s", ErrProbeNeedsContext, fn.Sym, ins.Raw)
+			}
+		}
+	}
+	return nil
+}
+
+func armKernelSourceNoFrame(fn Func) (bool, error) {
+	if len(fn.Instrs) == 0 || fn.Instrs[0].Op != OpTEXT {
+		return false, fmt.Errorf("%w: ARM kernel caller %q has no source TEXT flags", ErrProbeNeedsContext, fn.Sym)
+	}
+	parts := splitTopLevelCSV(fn.Instrs[0].Raw)
+	flags := uint64(0)
+	if len(parts) == 3 {
+		expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+			if value, ok := goTextFlagValues[name]; ok {
+				return value
+			}
+			return name
+		})
+		var ok bool
+		flags, ok = parseImmExpr(strings.TrimSpace(expression))
+		if !ok {
+			return false, fmt.Errorf("%w: ARM kernel caller %q has unresolved TEXT flags %q", ErrProbeNeedsContext, fn.Sym, parts[1])
+		}
+	} else if len(parts) != 2 {
+		return false, fmt.Errorf("%w: ARM kernel caller %q has malformed TEXT metadata", ErrProbeNeedsContext, fn.Sym)
+	}
+	return fn.FrameSize == -4 || flags&512 != 0, nil
+}
+
+func armKernelOperandUsesReg(arg Operand, reg Reg) bool {
+	switch arg.Kind {
+	case OpReg, OpRegShift, OpRegExtend:
+		return arg.Reg == reg || arg.ShiftReg == reg
+	case OpMem:
+		if arg.Mem.Base == reg || arg.Mem.Index == reg {
+			return true
+		}
+		if shift, ok := armMemoryShift(arg.Mem); ok {
+			return shift.Reg == reg || shift.ShiftReg == reg
+		}
+	case OpRegList:
+		for _, item := range arg.RegList {
+			if item == reg {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/arm_kernel_continuation_runtime_test.go b/arm_kernel_continuation_runtime_test.go
new file mode 100644
index 000000000..d42afac95
--- /dev/null
+++ b/arm_kernel_continuation_runtime_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+// This is deliberately a Go-only witness for source continuations that the
+// LLVM helper contract must reject. The wrapper restores the observed SP
+// before crossing back into Go, so a framed B does not corrupt the Go caller.
+func TestCrossLinuxRuntimeMatrixARMKernelSourceContinuation(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for the actual Go ARM continuation oracle")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM continuation oracle requires a Linux driver")
+	}
+	if _, err := exec.LookPath("qemu-arm"); err != nil {
+		t.Fatal(err)
+	}
+	const main = `package main
+import "fmt"
+func oracle(ptr *uint32, out *[4]uint32, kind uint32)
+func main() {
+ deltas := [...]uint32{0,8,20,36,0,0,0,0,4,0,0}
+ for kind,delta := range deltas {
+  word,out := uint32(0),[4]uint32{}
+  oracle(&word,&out,uint32(kind))
+  marker := uint32(77)
+  if kind == 10 { marker = 99 }
+  if word != 1 || out != [4]uint32{delta,0,1,marker} {
+   panic(fmt.Sprintf("Go continuation kind=%d word=%x out=%v want delta=%d marker=%d",kind,word,out,delta,marker))
+  }
+  fmt.Printf("kind=%d SP-delta=%d status=%d C=%d continuation=%d\n",kind,out[0],out[1],out[2],out[3])
+ }
+}
+`
+	const assembly = `#include "textflag.h"
+TEXT cas<>(SB),NOSPLIT,$0
+ MOVW $0xffff0fc0,R15
+TEXT dummy<>(SB),NOSPLIT,$0
+ RET
+TEXT b0<>(SB),NOSPLIT,$0
+ B cas<>(SB)
+TEXT b4<>(SB),NOSPLIT,$4
+ B cas<>(SB)
+TEXT b16<>(SB),NOSPLIT,$16
+ B cas<>(SB)
+TEXT b32<>(SB),NOSPLIT,$32
+ B cas<>(SB)
+TEXT ret0<>(SB),NOSPLIT,$0
+ RET cas<>(SB)
+TEXT ret4<>(SB),NOSPLIT,$4
+ RET cas<>(SB)
+TEXT ret16<>(SB),NOSPLIT,$16
+ RET cas<>(SB)
+TEXT ret32<>(SB),NOSPLIT,$32
+ RET cas<>(SB)
+TEXT implicitB<>(SB),NOSPLIT,$0
+ BL dummy<>(SB)
+ MOVW (R13),R14
+ B cas<>(SB)
+TEXT implicitRET<>(SB),NOSPLIT,$0
+ BL dummy<>(SB)
+ RET cas<>(SB)
+TEXT redirect<>(SB),NOSPLIT,$0
+ MOVW R14,R9
+ MOVW $continuation<>(SB),R14
+ B cas<>(SB)
+TEXT continuation<>(SB),NOSPLIT,$0
+ MOVW $99,R7
+ MOVW R9,R14
+ RET
+TEXT ·oracle(SB),NOSPLIT,$96-12
+ MOVW ptr+0(FP),R2
+ MOVW out+4(FP),R4
+ MOVW kind+8(FP),R5
+ MOVW $0,R0
+ MOVW $1,R1
+ MOVW $77,R7
+ MOVW R13,R8
+ CMP $0,R5
+ BEQ case0
+ CMP $1,R5
+ BEQ case1
+ CMP $2,R5
+ BEQ case2
+ CMP $3,R5
+ BEQ case3
+ CMP $4,R5
+ BEQ case4
+ CMP $5,R5
+ BEQ case5
+ CMP $6,R5
+ BEQ case6
+ CMP $7,R5
+ BEQ case7
+ CMP $8,R5
+ BEQ case8
+ CMP $9,R5
+ BEQ case9
+ BL redirect<>(SB)
+ B report
+case0:
+ BL b0<>(SB)
+ B report
+case1:
+ BL b4<>(SB)
+ B report
+case2:
+ BL b16<>(SB)
+ B report
+case3:
+ BL b32<>(SB)
+ B report
+case4:
+ BL ret0<>(SB)
+ B report
+case5:
+ BL ret4<>(SB)
+ B report
+case6:
+ BL ret16<>(SB)
+ B report
+case7:
+ BL ret32<>(SB)
+ B report
+case8:
+ BL implicitB<>(SB)
+ B report
+case9:
+ BL implicitRET<>(SB)
+report:
+ MOVW $0,R6
+ MOVW.CS $1,R6
+ SUB R13,R8,R5
+ MOVW R8,R13
+ MOVW R5,0(R4)
+ MOVW R0,4(R4)
+ MOVW R6,8(R4)
+ MOVW R7,12(R4)
+ RET
+`
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":  "module armcontinuationoracle\n\ngo 1.20\n",
+		"main.go": main, "oracle_arm.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("actual Go source B/RET/SP/LR oracle: %v\n%s", err, output)
+	}
+	t.Logf("actual Go source continuation witness:\n%s", output)
+}
diff --git a/arm_kernel_continuation_test.go b/arm_kernel_continuation_test.go
new file mode 100644
index 000000000..04f40b3d2
--- /dev/null
+++ b/arm_kernel_continuation_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARMKernelHelperContinuationRequiresSourceLRAndFrameProof(t *testing.T) {
+	tests := []struct {
+		name, text, body string
+	}{
+		{"frame4", "NOSPLIT,$4", "B gate<>(SB)"},
+		{"frame16", "NOSPLIT,$16", "JMP gate<>(SB)"},
+		{"frame32", "NOSPLIT,$32", "B gate<>(SB)"},
+		{"implicit_call_frame", "NOSPLIT,$0", "BL other<>(SB)\n B gate<>(SB)"},
+		{"unreachable_call_frame", "NOSPLIT,$0", "B gate<>(SB)\n BL other<>(SB)"},
+		{"implicit_div_frame", "NOSPLIT,$0", "MOVW $2,R0\n DIV R0,R0\n B gate<>(SB)"},
+		{"implicit_divu_frame", "NOSPLIT,$0", "MOVW $2,R0\n DIVU R0,R0\n B gate<>(SB)"},
+		{"implicit_mod_signed_frame", "NOSPLIT,$0", "MOVW $2,R0\n MOD R0,R0\n B gate<>(SB)"},
+		{"implicit_mod_frame", "NOSPLIT,$0", "MOVW $2,R0\n MODU R0,R0\n B gate<>(SB)"},
+		{"implicit_bx_frame", "NOSPLIT,$0", "BX (R0)\n B gate<>(SB)"},
+		{"implicit_duffzero_frame", "NOSPLIT,$0", "DUFFZERO $0\n B gate<>(SB)"},
+		{"implicit_duffcopy_frame", "NOSPLIT,$0", "DUFFCOPY $0\n B gate<>(SB)"},
+		{"noframe_native_call", "NOSPLIT|NOFRAME,$0", "BL gate<>(SB)\n RET"},
+		{"numeric_noframe_native_call", "516,$0", "CALL gate<>(SB)\n RET"},
+		{"historical_noframe_call", "NOSPLIT,$-4", "BL gate<>(SB)\n RET"},
+		{"unknown_flags", "UNKNOWN,$0", "BL gate<>(SB)\n RET"},
+		{"lr_write_tail", "NOSPLIT,$0", "MOVW $123,R14\n B gate<>(SB)"},
+		{"lr_read_call", "NOSPLIT,$0", "BL gate<>(SB)\n MOVW R14,R0\n RET"},
+		{"lr_memory_base", "NOSPLIT,$0", "MOVW (R14),R0\n BL gate<>(SB)\n RET"},
+		{"lr_shift_source", "NOSPLIT,$0", "MOVW R0<<R14,R1\n BL gate<>(SB)\n RET"},
+		{"lr_register_list", "NOSPLIT,$0", "MOVM [R0,R14],(R1)\n BL gate<>(SB)\n RET"},
+		{"tail_sp_read", "NOSPLIT,$0", "MOVW R13,R0\n B gate<>(SB)"},
+		{"tail_sp_store", "NOSPLIT,$0", "MOVW.W R0,-4(R13)\n B gate<>(SB)"},
+		{"call_sp_read", "NOSPLIT,$0", "MOVW R13,R0\n BL gate<>(SB)\n RET"},
+		{"call_sp_store", "NOSPLIT,$16", "MOVW R0,4(R13)\n BL gate<>(SB)\n RET"},
+		{"raw_lr_write", "NOSPLIT,$0", "WORD $0xe3a0e000\n B gate<>(SB)"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT gate<>(SB),NOSPLIT,$0\n MOVW $0xffff0fa0,R15\n" +
+				"TEXT other<>(SB),NOSPLIT,$0\n RET\n" +
+				"TEXT caller(SB)," + test.text + "\n " + test.body + "\n"
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]FuncSig{
+				"gate<>":  {Name: "gate<>", Ret: Void},
+				"other<>": {Name: "other<>", Ret: Void},
+				"caller":  {Name: "caller", Ret: Void},
+			}
+			_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("source LR/frame continuation cannot be replaced by an ordinary LLVM return: %v", err)
+			}
+		})
+	}
+}
+
+func TestARMKernelHelperContinuationKeepsProvedLeafTailAndFramedCalls(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, text := range []string{"NOSPLIT,$0", "NOSPLIT|NOFRAME,$0", "516,$0", "NOSPLIT,$-4"} {
+		for _, branch := range []string{"B", "JMP"} {
+			source := "TEXT gate<>(SB),NOSPLIT,$0\n MOVW $0xffff0fa0,R15\n" +
+				"TEXT caller(SB)," + text + "\n " + branch + " gate<>(SB)\n"
+			requireARMGoAssemblerResult(t, strings.NewReplacer("NOSPLIT", "4", "NOFRAME", "512").Replace(source), true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"gate<>": {Name: "gate<>", Ret: Void}, "caller": {Name: "caller", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatalf("proved zero-frame native tail %s / %s: %v", text, branch, err)
+			}
+			compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "leaf-tail.ll", "leaf-tail.o", ir)
+		}
+	}
+	for _, frame := range []string{"0", "4", "16", "32"} {
+		source := strings.Replace(armKernelHelperSource, "TEXT oracle(SB),$0-16", "TEXT oracle(SB),NOSPLIT,$"+frame+"-16", 1)
+		requireARMGoAssemblerResult(t, strings.ReplaceAll(source, "NOSPLIT", "4"), true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armKernelHelperSigs()})
+		if err != nil {
+			t.Fatalf("Go saves and restores source LR around ordinary framed BL / RET: %v", err)
+		}
+		compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "framed-call.ll", "framed-call.o", ir)
+	}
+}
diff --git a/arm_kernel_helper.go b/arm_kernel_helper.go
new file mode 100644
index 000000000..32c5fb7b5
--- /dev/null
+++ b/arm_kernel_helper.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armKernelEntry uint8
+
+const (
+	armKernelCompareExchange32 armKernelEntry = iota + 1
+	armKernelMemoryBarrier
+)
+
+type armKernelSpec struct {
+	entry  armKernelEntry
+	addr   uint32
+	inputs []Reg
+}
+
+// These are Linux's documented user-mode entry points, not function-name
+// aliases. The native cmpxchg ABI returns status in R0 and success in C, and
+// clobbers R3/IP/flags. The barrier preserves registers and orders memory.
+// https://docs.kernel.org/arch/arm/kernel_user_helpers.html
+var armKernelSpecs = [...]armKernelSpec{
+	{entry: armKernelCompareExchange32, addr: 0xffff0fc0, inputs: []Reg{"R0", "R1", "R2"}},
+	{entry: armKernelMemoryBarrier, addr: 0xffff0fa0},
+}
+
+type armKernelCall struct {
+	spec      armKernelSpec
+	condition string
+	tail      bool
+}
+
+func armKernelBranchForm(ins Instr) (condition string, tail bool, ok bool) {
+	op, condition, _, _ := armDecodeOp(string(ins.Op))
+	if op == "BL" || op == "CALL" || op == "B" || op == "JMP" {
+		if err := armRequireConditionOnlySuffix(ins); err != nil {
+			return "", false, false
+		}
+		return condition, op == "B" || op == "JMP", true
+	}
+	if len(op) > 1 && op[0] == 'B' && armCondCodes[op[1:]] {
+		return op[1:], true, true
+	}
+	return "", false, false
+}
+
+func armKernelSourceSpec(fn Func) (armKernelSpec, bool) {
+	if !strings.HasSuffix(fn.Sym, "<>") || fn.FrameSize != 0 || fn.ArgSize != 0 || len(fn.Instrs) != 2 || fn.Instrs[0].Op != OpTEXT {
+		return armKernelSpec{}, false
+	}
+	ins := fn.Instrs[1]
+	if ins.Op != "MOVW" || len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[1].Kind != OpReg || ins.Args[1].Reg != "R15" {
+		return armKernelSpec{}, false
+	}
+	for _, spec := range armKernelSpecs {
+		if ins.Args[0].Imm == int64(spec.addr) || ins.Args[0].Imm == int64(int32(spec.addr)) {
+			return spec, true
+		}
+	}
+	return armKernelSpec{}, false
+}
+
+// ARMKernelHelperFuncSig identifies a source-local Linux kernel entry thunk.
+// It is a metadata placeholder, not a void C ABI callable: translation must
+// still prove the concrete Linux target and every closed native continuation.
+// No name heuristic, public symbol, extra instruction, or FP frame is accepted.
+func ARMKernelHelperFuncSig(fn Func, resolved string) (FuncSig, bool) {
+	if _, ok := armKernelSourceSpec(fn); !ok {
+		return FuncSig{}, false
+	}
+	return FuncSig{Name: resolved, Ret: Void}, true
+}
+
+func prepareARMKernelHelpers(file *File, opt Options) (*File, error) {
+	if file.Arch != ArchARM {
+		return file, nil
+	}
+	helpers := map[string]armKernelSpec{}
+	seen := map[string]bool{}
+	resolve := opt.ResolveSym
+	if resolve == nil {
+		resolve = func(s string) string { return s }
+	}
+	for _, fn := range file.Funcs {
+		if seen[fn.Sym] {
+			return nil, fmt.Errorf("duplicate ARM TEXT %q", fn.Sym)
+		}
+		seen[fn.Sym] = true
+		spec, ok := armKernelSourceSpec(fn)
+		if !ok {
+			continue
+		}
+		if !strings.Contains(opt.TargetTriple, "-linux-") {
+			return nil, fmt.Errorf("%w: ARM kernel helper %q requires a concrete Linux target", ErrProbeNeedsContext, fn.Sym)
+		}
+		sig, ok := opt.Sigs[resolve(fn.Sym)]
+		if !ok || sig.Name != "" && sig.Name != resolve(fn.Sym) || sig.Ret != Void || len(sig.Args) != 0 || len(sig.ArgRegs) != 0 || len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+			return nil, fmt.Errorf("%w: ARM kernel helper %q needs a private native register ABI, not a Go/FP entry", ErrProbeNeedsContext, fn.Sym)
+		}
+		if _, duplicate := helpers[fn.Sym]; duplicate {
+			return nil, fmt.Errorf("duplicate ARM kernel helper %q", fn.Sym)
+		}
+		helpers[fn.Sym] = spec
+	}
+	if len(helpers) == 0 {
+		return file, nil
+	}
+
+	uses := map[string]int{}
+	result := *file
+	result.Funcs = make([]Func, 0, len(file.Funcs))
+	for _, fn := range file.Funcs {
+		if _, helper := helpers[fn.Sym]; helper {
+			continue
+		}
+		copyFn := fn
+		copyFn.Instrs = append([]Instr(nil), fn.Instrs...)
+		for i, ins := range copyFn.Instrs {
+			for ai, arg := range ins.Args {
+				if arg.Kind != OpSym {
+					continue
+				}
+				base, off, ok := parseSBRef(arg.Sym)
+				spec, helper := helpers[strings.TrimPrefix(base, "$")]
+				if !ok || !helper {
+					continue
+				}
+				condition, tail, branch := armKernelBranchForm(ins)
+				if branch && tail && condition != "" && condition != "AL" {
+					return nil, fmt.Errorf("arm conditional branch to a symbolic helper is absent from Go's assembler grammar: %s", ins.Raw)
+				}
+				if !branch || off != 0 || ai != 0 || len(ins.Args) != 1 || strings.HasPrefix(base, "$") {
+					return nil, fmt.Errorf("%w: ARM kernel helper address escapes its direct continuation in %q: %s", ErrProbeNeedsContext, fn.Sym, ins.Raw)
+				}
+				copyFn.Instrs[i].armKernelCall = &armKernelCall{spec: spec, condition: condition, tail: tail}
+				uses[base]++
+			}
+		}
+		if err := proveARMKernelContinuation(copyFn); err != nil {
+			return nil, err
+		}
+		if err := proveARMKernelInputs(copyFn, opt.Sigs[resolve(fn.Sym)]); err != nil {
+			return nil, err
+		}
+		result.Funcs = append(result.Funcs, copyFn)
+	}
+	for _, data := range file.Data {
+		if _, helper := helpers[data.Sym]; helper {
+			return nil, fmt.Errorf("%w: ARM kernel helper cannot contain DATA", ErrProbeNeedsContext)
+		}
+		base, _, _ := parseSBRef(data.Addr)
+		if _, helper := helpers[strings.TrimPrefix(base, "$")]; helper {
+			return nil, fmt.Errorf("%w: ARM kernel helper address escapes through DATA", ErrProbeNeedsContext)
+		}
+	}
+	for _, global := range file.Globl {
+		if _, helper := helpers[global.Sym]; helper {
+			return nil, fmt.Errorf("%w: ARM kernel helper cannot be a data global", ErrProbeNeedsContext)
+		}
+	}
+	for name := range helpers {
+		if uses[name] == 0 {
+			return nil, fmt.Errorf("%w: ARM kernel helper %q has no closed caller continuation", ErrProbeNeedsContext, name)
+		}
+	}
+	return &result, nil
+}
+
+func armKernelValueDefined(source Operand, sig FuncSig, defined armKernelState) bool {
+	switch source.Kind {
+	case OpImm:
+		return source.ImmRaw == ""
+	case OpReg:
+		return defined.has(armKernelRegBit(source.Reg))
+	case OpFP, OpFPAddr:
+		return armKernelTypedFPInput(source, sig)
+	case OpRegShift:
+		return defined.has(armKernelRegBit(source.Reg)) && (source.ShiftReg == "" || defined.has(armKernelRegBit(source.ShiftReg)))
+	case OpMem:
+		return defined.has(armKernelRegBit(source.Mem.Base)) && (source.Mem.Index == "" || defined.has(armKernelRegBit(source.Mem.Index))) && source.Mem.OffRaw == ""
+	case OpSym:
+		_, _, ok := parseSBRef(source.Sym)
+		return ok && strings.HasSuffix(source.Sym, "(SB)")
+	}
+	return false
+}
+
+func armKernelTypedFPInput(source Operand, sig FuncSig) bool {
+	for _, slot := range sig.Frame.Params {
+		if slot.Offset == source.FPOffset && slot.Index >= 0 && slot.Index < len(sig.Args) {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *armCtx) lowerKernelHelperCall(call armKernelCall) (bool, error) {
+	emit := func() error {
+		if err := c.emitKernelHelper(call.spec); err != nil {
+			return err
+		}
+		if call.tail {
+			return c.lowerRET()
+		}
+		return nil
+	}
+	if call.condition == "" || call.condition == "AL" {
+		return call.tail, emit()
+	}
+	return false, c.emitConditionalEffect(call.condition, emit)
+}
+
+func (c *armCtx) emitKernelHelper(spec armKernelSpec) error {
+	if spec.entry == armKernelMemoryBarrier {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %d)\n", "blx $0", "r,~{lr},~{memory}", spec.addr)
+		return nil
+	}
+	inputs := make([]string, len(spec.inputs))
+	for i, reg := range spec.inputs {
+		value, err := c.loadReg(reg)
+		if err != nil {
+			return err
+		}
+		inputs[i] = value
+	}
+	result := c.newTmp()
+	// Read status and APSR inside the same assembly region as the call: an
+	// ordinary LLVM function return does not carry the callee's flags. R3/IP
+	// are explicit outputs as well, preserving any subsequent source reads.
+	fmt.Fprintf(c.b, "  %%%s = call {i32,i32,i32,i32} asm sideeffect %q, %q(i32 %s, i32 %s, i32 %s, i32 %d)\n",
+		result, "blx $7; mrs $3, apsr", "={r0},={r3},={r12},=&r,0,{r1},{r2},r,~{lr},~{cc},~{memory}",
+		inputs[0], inputs[1], inputs[2], spec.addr)
+	for i, reg := range []Reg{"R0", "R3", "R12"} {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractvalue {i32,i32,i32,i32} %%%s, %d\n", value, result, i)
+		if err := c.storeReg(reg, "%"+value); err != nil {
+			return err
+		}
+	}
+	status := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractvalue {i32,i32,i32,i32} %%%s, 3\n", status, result)
+	c.storeFlagsFromStatus("%" + status)
+	return nil
+}
diff --git a/arm_kernel_helper_proof.go b/arm_kernel_helper_proof.go
new file mode 100644
index 000000000..252176da6
--- /dev/null
+++ b/arm_kernel_helper_proof.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armKernelState uint32
+
+const (
+	armKernelN armKernelState = 1 << (17 + iota)
+	armKernelZ
+	armKernelC
+	armKernelV
+	armKernelFlags = armKernelN | armKernelZ | armKernelC | armKernelV
+	armKernelTop   = (1 << 21) - 1
+)
+
+func armKernelRegBit(reg Reg) armKernelState {
+	if reg == SP {
+		return 1 << 16
+	}
+	for i := 0; i < 15; i++ {
+		if reg == Reg(fmt.Sprintf("R%d", i)) {
+			return 1 << i
+		}
+	}
+	return 0 // R15 is not an ordinary source-state value.
+}
+
+func (s armKernelState) has(mask armKernelState) bool { return mask != 0 && s&mask == mask }
+
+func armKernelConditionBits(condition string) armKernelState {
+	switch condition {
+	case "", "AL":
+		return 0
+	case "EQ", "NE":
+		return armKernelZ
+	case "CS", "HS", "CC", "LO":
+		return armKernelC
+	case "MI", "PL":
+		return armKernelN
+	case "VS", "VC":
+		return armKernelV
+	case "HI", "LS":
+		return armKernelC | armKernelZ
+	case "GE", "LT":
+		return armKernelN | armKernelV
+	case "GT", "LE":
+		return armKernelN | armKernelV | armKernelZ
+	}
+	return armKernelFlags
+}
+
+// Native inputs cannot come from zero-filled generic register slots. This is
+// a must-definition analysis: entry comes only from explicit typed registers,
+// and every reachable predecessor must prove an input at a join. Loops use a
+// descending fixed point; unreachable blocks do not manufacture a proof.
+func proveARMKernelInputs(fn Func, sig FuncSig) error {
+	blocks := armSplitBlocks(fn)
+	if len(blocks) == 0 {
+		return nil
+	}
+	hasCall := false
+	for _, ins := range fn.Instrs {
+		hasCall = hasCall || ins.armKernelCall != nil
+	}
+	if !hasCall {
+		return nil
+	}
+	entry := armKernelState(0)
+	for i, reg := range sig.ArgRegs {
+		if i < len(sig.Args) {
+			entry |= armKernelRegBit(reg)
+		}
+	}
+	preds, reachable := armSourcePredecessors(blocks)
+	in, out := make([]armKernelState, len(blocks)), make([]armKernelState, len(blocks))
+	for i := range blocks {
+		if reachable[i] {
+			in[i], out[i] = armKernelTop, armKernelTop
+		}
+	}
+	for changed := true; changed; {
+		changed = false
+		for i, block := range blocks {
+			if !reachable[i] {
+				continue
+			}
+			state := armKernelState(armKernelTop)
+			if i == 0 {
+				state = entry
+			}
+			for _, pred := range preds[i] {
+				state &= out[pred]
+			}
+			in[i] = state
+			for _, ins := range block.instrs {
+				state, _ = armKernelTransfer(fn.Sym, sig, state, ins, false)
+			}
+			if out[i] != state {
+				out[i], changed = state, true
+			}
+		}
+	}
+	for i, block := range blocks {
+		state := in[i]
+		for _, ins := range block.instrs {
+			var err error
+			state, err = armKernelTransfer(fn.Sym, sig, state, ins, true)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func armKernelTransfer(name string, sig FuncSig, state armKernelState, ins Instr, check bool) (armKernelState, error) {
+	op, condition, post, setFlags := armDecodeOp(string(ins.Op))
+	status, statusMove, statusError := parseARMStatusMove(ins)
+	if statusMove {
+		if statusError != nil {
+			return state, statusError
+		}
+		condition = status.condition
+	}
+	if len(op) > 1 && op[0] == 'B' && armCondCodes[op[1:]] {
+		condition = op[1:]
+	}
+	bits := armKernelConditionBits(condition)
+	predicate := bits == 0 || state.has(bits)
+	if check && !predicate {
+		return state, fmt.Errorf("%w: ARM native continuation in %q has unproved condition %s: %s", ErrProbeNeedsContext, name, condition, ins.Raw)
+	}
+	assign := func(mask armKernelState, known bool) {
+		if bits != 0 {
+			known = known && predicate && state.has(mask)
+		}
+		state &^= mask
+		if known {
+			state |= mask
+		}
+	}
+	if statusMove {
+		if status.write {
+			assign(armKernelFlags, armKernelValueDefined(status.source, sig, state))
+		} else {
+			assign(armKernelRegBit(status.dest), state.has(armKernelFlags))
+		}
+		return state, nil
+	}
+	if call := ins.armKernelCall; call != nil {
+		for _, reg := range call.spec.inputs {
+			if check && !state.has(armKernelRegBit(reg)) {
+				return state, fmt.Errorf("%w: ARM kernel call in %q requires a typed/source-defined %s input: %s", ErrProbeNeedsContext, name, reg, ins.Raw)
+			}
+		}
+		if call.spec.entry == armKernelCompareExchange32 {
+			assign(armKernelRegBit("R0"), true)
+			// R3/IP and non-C flags are explicitly clobbered by this ABI.
+			state &^= armKernelRegBit("R3") | armKernelRegBit("R12") | armKernelN | armKernelZ | armKernelV
+			assign(armKernelC, true)
+		}
+		return state, nil
+	}
+	if _, move := armIntegerMemorySpecs[op]; move && len(ins.Args) == 2 {
+		if ins.Args[1].Kind == OpIdent && strings.EqualFold(ins.Args[1].Ident, "CPSR") {
+			assign(armKernelFlags, armKernelValueDefined(ins.Args[0], sig, state))
+			return state, nil
+		}
+		if ins.Args[1].Kind == OpReg {
+			known := armKernelValueDefined(ins.Args[0], sig, state)
+			assign(armKernelRegBit(ins.Args[1].Reg), known)
+			if setFlags {
+				assign(armKernelN|armKernelZ, known)
+				state &^= armKernelC
+			}
+		}
+		if post {
+			for _, arg := range ins.Args {
+				if arg.Kind == OpMem {
+					state &^= armKernelRegBit(arg.Mem.Base)
+				}
+			}
+		}
+		return state, nil
+	}
+	if op == "BL" || op == "CALL" {
+		return state &^ (armKernelRegBit("R0") | armKernelRegBit("R1") | armKernelRegBit("R2") | armKernelRegBit("R3") | armKernelRegBit("R12") | armKernelFlags), nil
+	}
+	if op == "CMP" || op == "CMN" || op == "TST" || op == "TEQ" {
+		known := len(ins.Args) == 2
+		for _, arg := range ins.Args {
+			known = known && armKernelValueDefined(arg, sig, state)
+		}
+		mask := armKernelFlags
+		if op == "TST" || op == "TEQ" {
+			mask = armKernelN | armKernelZ
+			state &^= armKernelC
+		}
+		assign(mask, known)
+		return state, nil
+	}
+	if _, _, branch := armKernelBranchForm(ins); branch {
+		return state, nil
+	}
+	switch op {
+	case "TEXT", "PCDATA", "FUNCDATA", "NO_LOCAL_POINTERS", "NOP", "DMB", "RET", "UNDEF":
+		return state, nil
+	case "ADD", "SUB", "AND", "ORR", "EOR", "BIC", "RSB", "MUL", "SRL", "SLL", "SRA", "ROR":
+		if len(ins.Args) >= 2 && ins.Args[len(ins.Args)-1].Kind == OpReg {
+			destination := armKernelRegBit(ins.Args[len(ins.Args)-1].Reg)
+			known := len(ins.Args) != 2 || state.has(destination)
+			for _, arg := range ins.Args[:len(ins.Args)-1] {
+				known = known && armKernelValueDefined(arg, sig, state)
+			}
+			assign(destination, known)
+			if setFlags {
+				mask := armKernelFlags
+				if op != "ADD" && op != "SUB" && op != "RSB" {
+					mask = armKernelN | armKernelZ
+					state &^= armKernelC
+				}
+				assign(mask, known)
+			}
+			return state, nil
+		}
+	}
+	// Raw words and unproved machine effects invalidate, never preserve stale
+	// ABI inputs or manufacture a value from generic initialized slots.
+	return 0, nil
+}
diff --git a/arm_kernel_helper_test.go b/arm_kernel_helper_test.go
new file mode 100644
index 000000000..0ecca70c1
--- /dev/null
+++ b/arm_kernel_helper_test.go
@@ -0,0 +1,373 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const armKernelHelperSource = `
+TEXT first<>(SB),$0
+ MOVW $0xffff0fc0,R15
+TEXT second<>(SB),$0
+ MOVW $0xffff0fa0,R15
+TEXT oracle(SB),$0-16
+ MOVW ptr+0(FP),R2
+ MOVW old+4(FP),R0
+ MOVW next+8(FP),R1
+ MOVW out+12(FP),R4
+ BL first<>(SB)
+ MOVW CPSR,R7
+ AND $(1<<29),R7
+ SRL $29,R7
+ MOVW R7,16(R4)
+ MOVW R0,0(R4)
+ MOVW $0,R3
+ MOVW.CS $1,R3
+ MOVW R3,4(R4)
+ MOVW R1,8(R4)
+ MOVW (R2),R5
+ MOVW R5,12(R4)
+ BL second<>(SB)
+ MOVW $0,R6
+ MOVW.CS $1,R6
+ MOVW R6,4(R4)
+ MOVW R0,0(R4)
+ MOVW R1,8(R4)
+ MOVW (R2),R5
+ MOVW R5,12(R4)
+ RET
+`
+
+func armKernelHelperSigs() map[string]FuncSig {
+	return map[string]FuncSig{
+		"first<>":  {Name: "first<>", Ret: Void},
+		"second<>": {Name: "second<>", Ret: Void},
+		"oracle": {
+			Name: "oracle", Args: []LLVMType{Ptr, I32, I32, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 4, Type: I32, Index: 1, Field: -1},
+				{Offset: 8, Type: I32, Index: 2, Field: -1},
+				{Offset: 12, Type: Ptr, Index: 3, Field: -1},
+			}},
+		},
+	}
+}
+
+func TestARMKernelHelperCallsNeedTypedNativeContract(t *testing.T) {
+	requireARMGoAssemblerResult(t, armKernelHelperSource, true)
+	file, err := Parse(ArchARM, armKernelHelperSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: armKernelHelperSigs()})
+		if err != nil {
+			t.Fatalf("closed Linux native helper must retain its register/carry/memory contract: %v", err)
+		}
+		for _, want := range []string{"blx", "mrs", "~{memory}", "{r0}", "{r1}", "{r2}", "extractvalue", "store i32"} {
+			if !strings.Contains(ir, want) {
+				t.Fatalf("native helper contract missing %q:\n%s", want, ir)
+			}
+		}
+		if strings.Contains(ir, "call void @\"first<>\"") || strings.Contains(ir, "call void @\"second<>\"") {
+			t.Fatal("private machine-register helper cannot use the old void C ABI")
+		}
+		compileLLVMToObject(t, llc, triple, "kernel-helper.ll", "kernel-helper.o", ir)
+	}
+}
+
+func TestARMKernelHelperGoBindingRequiresRealNativeContract(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/kernel", "package kernel\nfunc oracle(ptr *uint32, old,next uint32,out *[5]uint32)\n")
+	resolve := func(name string) string {
+		if strings.HasSuffix(name, "<>") {
+			return "example.com/kernel." + strings.TrimSuffix(name, "<>") + "$local"
+		}
+		return "example.com/kernel." + name
+	}
+	translation, err := TranslateGoModule(pkg, []byte(armKernelHelperSource), GoModuleOptions{
+		GOOS: "linux", GOARCH: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	if !strings.Contains(translation.Module.String(), "blx") {
+		t.Fatal("Go binding did not retain the native kernel contract")
+	}
+}
+
+func TestARMKernelHelperRequiresClosedSourceAndLinuxTarget(t *testing.T) {
+	tests := []struct {
+		name, source, triple string
+		mutate               func(map[string]FuncSig)
+	}{
+		{"unknown_entry", strings.Replace(armKernelHelperSource, "0xffff0fc0", "0xffff0fc4", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"extra_body", strings.Replace(armKernelHelperSource, "MOVW $0xffff0fc0,R15", "ADD $1,R0\n MOVW $0xffff0fc0,R15", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"helper_frame", strings.Replace(armKernelHelperSource, "TEXT first<>(SB),$0", "TEXT first<>(SB),$4", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"public_entry", strings.ReplaceAll(armKernelHelperSource, "first<>", "first"), "armv7-unknown-linux-gnueabihf", nil},
+		{"address_escape", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "MOVW $first<>(SB),R6\n BL first<>(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"offset_reference", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "BL first<>+4(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"data_escape", armKernelHelperSource + "DATA escaped+0(SB)/4,$first<>(SB)\nGLOBL escaped(SB),$4\n", "armv7-unknown-linux-gnueabihf", nil},
+		{"no_callers", "TEXT first<>(SB),$0\n MOVW $0xffff0fc0,R15\n", "armv7-unknown-linux-gnueabihf", nil},
+		{"missing_input", strings.Replace(armKernelHelperSource, "MOVW old+4(FP),R0", "NOP", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"unknown_overwrite", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "ADD R7,R0\n BL first<>(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"conditional_input", strings.Replace(armKernelHelperSource, "MOVW old+4(FP),R0", "CMP R2,R2\n MOVW.EQ old+4(FP),R0", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"joined_input", strings.Replace(armKernelHelperSource, "MOVW old+4(FP),R0", "CMP $0,R2\n BEQ joined\n MOVW old+4(FP),R0\njoined:", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"unproved_predicate", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "CMP $0,R7\n BL.EQ first<>(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"unproved_status_write", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "CMP R2,R2\n MOVW R7,CPSR\n BL.CS first<>(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"undefined_native_flags", strings.Replace(armKernelHelperSource, "MOVW.CS $1,R3", "MOVW.EQ $1,R3", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"unreachable_input", strings.Replace(armKernelHelperSource, "BL first<>(SB)", "RET\n BL first<>(SB)", 1), "armv7-unknown-linux-gnueabihf", nil},
+		{"missing_target", armKernelHelperSource, "", nil},
+		{"windows", armKernelHelperSource, "thumbv7-pc-windows-msvc", nil},
+		{"explicit_go_abi", armKernelHelperSource, "armv7-unknown-linux-gnueabihf", func(sigs map[string]FuncSig) {
+			sig := sigs["first<>"]
+			sig.Args = []LLVMType{I32}
+			sigs["first<>"] = sig
+		}},
+		{"signature_name_conflict", armKernelHelperSource, "armv7-unknown-linux-gnueabihf", func(sigs map[string]FuncSig) {
+			sigs["first<>"] = FuncSig{Name: "other", Ret: Void}
+		}},
+		{"register_signature_conflict", armKernelHelperSource, "armv7-unknown-linux-gnueabihf", func(sigs map[string]FuncSig) {
+			sigs["first<>"] = FuncSig{Name: "first<>", Ret: Void, ArgRegs: []Reg{"R0"}}
+		}},
+		{"missing_helper_signature", armKernelHelperSource, "armv7-unknown-linux-gnueabihf", func(sigs map[string]FuncSig) {
+			delete(sigs, "first<>")
+		}},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchARM, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := armKernelHelperSigs()
+			if test.name == "public_entry" {
+				sigs["first"] = FuncSig{Name: "first", Ret: Void}
+			}
+			if test.mutate != nil {
+				test.mutate(sigs)
+			}
+			_, err = Translate(file, Options{Goarch: "arm", TargetTriple: test.triple, Sigs: sigs})
+			if test.name == "signature_name_conflict" || test.name == "missing_helper_signature" {
+				if err == nil || !strings.Contains(err.Error(), "signature") {
+					t.Fatalf("invalid signature metadata must fail before native lowering: %v", err)
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unproved native helper must remain a context failure: %v", err)
+			}
+		})
+	}
+}
+
+func TestARMKernelHelperInputProofFollowsAllPredecessors(t *testing.T) {
+	for _, source := range []string{
+		strings.Replace(armKernelHelperSource, "BL first<>(SB)", "joined:\n BL first<>(SB)", 1),
+		strings.Replace(armKernelHelperSource, "MOVW old+4(FP),R0", "CMP $0,R2\n BEQ alternate\n MOVW old+4(FP),R0\n B joined\nalternate:\n MOVW old+4(FP),R0\njoined:", 1),
+		strings.Replace(armKernelHelperSource, "BL first<>(SB)", "CMP $0,R2\nloop:\n BL first<>(SB)\n CMP $0,R0\n BNE loop", 1),
+	} {
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armKernelHelperSigs()}); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestARMKernelHelperBranchGrammarAndSourceImmutability(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, branch := range []string{"BL", "CALL", "B", "JMP", "BL.EQ", "CALL.NE", "BL.CS", "BL.CC", "BL.HI", "BL.LS", "BL.MI", "BL.PL", "BL.VS", "BL.VC", "BL.GE", "BL.LT", "BL.GT", "BL.LE", "BL.HS", "BL.LO"} {
+		t.Run(branch, func(t *testing.T) {
+			source := "TEXT unnamed<>(SB),$0\n MOVW $0xffff0fc0,R15\nTEXT caller(SB),$0-12\n MOVW ptr+0(FP),R2\n MOVW old+4(FP),R0\n MOVW next+8(FP),R1\n CMP R0,R0\n " + branch + " unnamed<>(SB)\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := armKernelHelperSigs()["oracle"]
+			sig.Name, sig.Args, sig.Frame.Params = "caller", sig.Args[:3], sig.Frame.Params[:3]
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"unnamed<>": {Name: "unnamed<>", Ret: Void}, "caller": sig,
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(file.Funcs) != 2 || file.Funcs[1].Instrs[5].armKernelCall != nil {
+				t.Fatal("closed-helper lowering mutated the source inventory")
+			}
+			compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "kernel-branch.ll", "kernel-branch.o", ir)
+		})
+	}
+	for _, branch := range []string{"B.EQ", "JMP.NE", "BEQ", "BCC", "BCS", "BHI", "BLS", "BMI", "BPL", "BVS", "BVC", "BGE", "BLT", "BGT", "BLE", "BHS", "BLO"} {
+		t.Run("rejected_"+branch, func(t *testing.T) {
+			source := strings.Replace(armKernelHelperSource, "BL first<>(SB)", branch+" first<>(SB)", 1)
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armKernelHelperSigs()}); err == nil {
+				t.Fatal("native contract accepted a conditional symbolic tail branch rejected by Go")
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMKernelHelper(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for actual Linux ARM kernel-helper execution")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("kernel-helper runtime oracle requires a Linux driver")
+	}
+	for _, tool := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	source := armKernelHelperSource + `
+TEXT tail(SB),NOSPLIT|NOFRAME,$0-12
+ MOVW ptr+0(FP),R2
+ MOVW old+4(FP),R0
+ MOVW next+8(FP),R1
+ B first<>(SB)
+TEXT conditional(SB),$0-16
+ MOVW ptr+0(FP),R2
+ MOVW old+4(FP),R0
+ MOVW next+8(FP),R1
+ MOVW out+12(FP),R4
+ CMP R0,R0
+ BL.NE first<>(SB)
+ MOVW R0,0(R4)
+ MOVW $0,R3
+ MOVW.CS $1,R3
+ MOVW R3,4(R4)
+ MOVW R1,8(R4)
+ MOVW (R2),R5
+ MOVW R5,12(R4)
+ RET
+TEXT status(SB),$0-16
+ MOVW ptr+0(FP),R2
+ MOVW old+4(FP),R0
+ MOVW next+8(FP),R1
+ MOVW out+12(FP),R4
+ BL first<>(SB)
+ MOVW R0,0(R4)
+ CMP R2,R2
+ MOVW CPSR,R3
+ AND $0xf0000000,R3
+ SRL $28,R3
+ MOVW R3,4(R4)
+ RET
+`
+	sigs := armKernelHelperSigs()
+	tailSig := sigs["oracle"]
+	tailSig.Name, tailSig.Args, tailSig.Frame.Params = "tail", tailSig.Args[:3], tailSig.Frame.Params[:3]
+	sigs["tail"] = tailSig
+	conditionalSig := sigs["oracle"]
+	conditionalSig.Name = "conditional"
+	sigs["conditional"] = conditionalSig
+	statusSig := sigs["oracle"]
+	statusSig.Name = "status"
+	sigs["status"] = statusSig
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const goMain = `package main
+func oracle(ptr *uint32, old,next uint32,out *[5]uint32)
+func conditional(ptr *uint32, old,next uint32,out *[4]uint32)
+func tail(ptr *uint32,old,next uint32)
+func status(ptr *uint32,old,next uint32,out *[2]uint32)
+func main() {
+ for _, initial := range []uint32{0,1,0x80000000,0xffffffff,0x12345678} {
+  for _, success := range []bool{true,false} {
+   word,old,next := initial,initial,initial^0xabcdef01
+   if !success { old ^= 1 }
+   var out [5]uint32
+   oracle(&word,old,next,&out)
+   want,carry := initial,uint32(0)
+   if success { want,carry = next,1 }
+   if (out[0] == 0) != success || out[1] != carry || out[2] != next || out[3] != want || out[4] != carry || word != want { panic("Go kernel CAS contract") }
+   word = initial
+   var conditionalOut [4]uint32
+   conditional(&word,old,next,&conditionalOut)
+   if conditionalOut != [4]uint32{old,1,next,initial} || word != initial { panic("Go predicated native call") }
+   tail(&word,old,next)
+   if word != want { panic("Go native tail continuation") }
+   word = initial
+   var statusOut [2]uint32
+   status(&word,initial^1,next,&statusOut)
+   if statusOut[0] == 0 || statusOut[1] != 6 || word != initial { panic("Go modeled CMP / CPSR contract") }
+  }
+ }
+}
+`
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module armkerneloracle\n\ngo 1.20\n", "main.go": goMain,
+		"oracle_arm.s": "#include \"textflag.h\"\n" + strings.NewReplacer("TEXT oracle(", "TEXT ·oracle(", "TEXT conditional(", "TEXT ·conditional(", "TEXT tail(", "TEXT ·tail(", "TEXT status(", "TEXT ·status(").Replace(source),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM kernel-helper oracle: %v\n%s", err, output)
+	}
+	t.Log("actual Go ARM private helper / CAS status / carry / preserved R1 / memory oracle passed")
+	const cMain = `#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t*,uint32_t,uint32_t,uint32_t*);
+extern void conditional(uint32_t*,uint32_t,uint32_t,uint32_t*);
+extern void tail(uint32_t*,uint32_t,uint32_t);
+extern void status(uint32_t*,uint32_t,uint32_t,uint32_t*);
+int main(void) {
+ const uint32_t inputs[] = {0,1,0x80000000u,0xffffffffu,0x12345678u};
+ for (unsigned i=0;i<5;i++) for (unsigned success=0;success<2;success++) {
+  uint32_t word=inputs[i], old=inputs[i]^(success?0:1), next=inputs[i]^0xabcdef01u, out[5]={0};
+  uint32_t want=success?next:inputs[i];
+  oracle(&word,old,next,out);
+  if ((out[0]==0)!=success || out[1]!=success || out[2]!=next || out[3]!=want || out[4]!=success || word!=want) {
+   fprintf(stderr,"kernel CAS i=%u success=%u word=%x status=%x C=%u R1=%x postload=%x CPSR.C=%u\n",i,success,word,out[0],out[1],out[2],out[3],out[4]); return 1;
+  }
+  word=inputs[i]; conditional(&word,old,next,out);
+  if (out[0]!=old || out[1]!=1 || out[2]!=next || out[3]!=inputs[i] || word!=inputs[i]) { fprintf(stderr,"predicated native call\n"); return 1; }
+  tail(&word,old,next);
+  if (word!=want) { fprintf(stderr,"native tail continuation\n"); return 1; }
+  word=inputs[i]; status(&word,inputs[i]^1,next,out);
+  if (out[0]==0 || out[1]!=6 || word!=inputs[i]) { fprintf(stderr,"modeled CMP / CPSR status=%x NZCV=%x\n",out[0],out[1]); return 1; }
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "kernel_helper", "armv7-unknown-linux-gnueabihf", ir, cMain,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_lower_address.go b/arm_lower_address.go
new file mode 100644
index 000000000..c5989cb6f
--- /dev/null
+++ b/arm_lower_address.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's C_RACON/C_LACON rows are address calculations, not SB symbol loads.
+// The small row uses ADD or SUB; the large row materializes the signed offset
+// in R11, then always uses ADD. Both allow conditions and the flag-setting bit.
+type armRegisterAddressForm struct {
+	base, destination Reg
+	offset            int64
+	large, setFlags   bool
+}
+
+func parseARMRegisterAddressForm(op string, ins Instr, memory MemRef) (armRegisterAddressForm, error) {
+	f := armRegisterAddressForm{base: memory.Base, offset: memory.Off}
+	if op != "MOVW" || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg || !isARMGeneralReg(ins.Args[1].Reg) {
+		return f, fmt.Errorf("arm register address requires MOVW $offset(register),register: %q", ins.Raw)
+	}
+	f.destination = ins.Args[1].Reg
+	if f.destination == PC || f.destination == SP || f.base == PC {
+		return f, fmt.Errorf("arm register address cannot use PC/SP as a general-register operand: %q", ins.Raw)
+	}
+	if !isARMGeneralReg(f.base) || memory.Index != "" || memory.OffRaw != "" {
+		return f, fmt.Errorf("arm register address requires a concrete immediate offset and one base register: %q", ins.Raw)
+	}
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix == "S" {
+			f.setFlags = true
+		} else if suffix != "" && !armCondCodes[suffix] {
+			return f, fmt.Errorf("arm MOVW register-address suffix %q is absent from the Go optab: %q", suffix, ins.Raw)
+		}
+	}
+	f.large = !armRotatedImmediateEncodable(uint32(f.offset)) && !armRotatedImmediateEncodable(uint32(-f.offset))
+	return f, nil
+}
+
+func (c *armCtx) lowerRegisterAddressMove(op, cond string, ins Instr) (bool, bool, error) {
+	if _, ok := armIntegerMemorySpecs[op]; !ok || len(ins.Args) == 0 || ins.Args[0].Kind != OpSym {
+		return false, false, nil
+	}
+	address := strings.TrimSpace(ins.Args[0].Sym)
+	if !strings.HasPrefix(address, "$") {
+		return false, false, nil
+	}
+	memory, ok := parseMem(strings.TrimSpace(strings.TrimPrefix(address, "$")))
+	if !ok || memory.Base == SP {
+		// Named pseudo-SP/FP addresses retain their separate frame contract.
+		return false, false, nil
+	}
+	f, err := parseARMRegisterAddressForm(op, ins, memory)
+	if err != nil {
+		return true, false, err
+	}
+	err = c.emitConditionalEffect(cond, func() error {
+		if f.large {
+			// This happens before reading the base. An explicit R11 base must
+			// therefore see the newly materialized offset, just like Go.
+			if err := c.storeReg("R11", c.imm32(f.offset)); err != nil {
+				return err
+			}
+		}
+		left, err := c.loadReg(f.base)
+		if err != nil {
+			return err
+		}
+		operation, offset := "add", f.offset
+		if !f.large && offset < 0 {
+			operation, offset = "sub", -offset
+		}
+		right := c.imm32(offset)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %s\n", result, operation, left, right)
+		if err := c.storeReg(f.destination, "%"+result); err != nil {
+			return err
+		}
+		if !f.setFlags {
+			return nil
+		}
+		// The condition is evaluated once before the effect. Testing it again
+		// after updating one flag would change later flag writes' predicate.
+		if operation == "sub" {
+			return c.setFlagsSub("", left, right, "%"+result)
+		}
+		return c.setFlagsAdd("", left, right, "%"+result)
+	})
+	return true, false, err
+}
diff --git a/arm_lower_arith.go b/arm_lower_arith.go
index b2f88431a..d77c3d8da 100644
--- a/arm_lower_arith.go
+++ b/arm_lower_arith.go
@@ -2,6 +2,7 @@ package plan9asm
 
 import (
 	"fmt"
+	"math/bits"
 	"strings"
 )
 
@@ -11,35 +12,346 @@ func (c *armCtx) lowerArith(op, cond string, setFlags bool, ins Instr) (ok bool,
 		return true, false, c.lowerARMALU(op, cond, setFlags, ins)
 	case "MVN":
 		return true, false, c.lowerARMMVN(cond, setFlags, ins)
-	case "ADC", "SBC":
+	case "ADC", "SBC", "RSC":
 		return true, false, c.lowerARMADCSBC(op, cond, setFlags, ins)
 	case "MUL", "MULU":
-		return true, false, c.lowerARMMUL(cond, ins)
+		return true, false, c.lowerARMBasicMultiply(op, cond, setFlags, ins)
 	case "MULLU":
-		return true, false, c.lowerARMMULLU(cond, ins)
+		return true, false, c.lowerARMBasicMultiply(op, cond, setFlags, ins)
+	case "MULL":
+		return true, false, c.lowerARMBasicMultiply(op, cond, setFlags, ins)
+	case "MMUL", "MMULA", "MMULS", "MULABB", "MULAWB", "MULBB", "MULS", "MULWB", "MULWT":
+		return true, false, c.lowerARMSignedMultiply(op, cond, setFlags, ins)
 	case "MULA":
-		return true, false, c.lowerARMMULA(cond, ins)
+		return true, false, c.lowerARMBasicMultiply(op, cond, setFlags, ins)
 	case "MULAL", "MULALU":
-		return true, false, c.lowerARMMULAL(cond, ins)
+		return true, false, c.lowerARMBasicMultiply(op, cond, setFlags, ins)
 	case "MULAWT":
-		return true, false, c.lowerARMMULAWT(cond, ins)
-	case "DIVUHW":
-		return true, false, c.lowerARMDIVUHW(cond, ins)
+		return true, false, c.lowerARMSignedMultiply(op, cond, setFlags, ins)
+	case "DIV", "DIVU", "MOD", "MODU", "DIVHW", "DIVUHW":
+		return true, false, c.lowerARMDivMod(op, cond, setFlags, ins)
 	case "CLZ":
 		return true, false, c.lowerARMCLZ(cond, ins)
+	case "REV", "REV16", "REVSH", "RBIT":
+		return true, false, c.lowerARMReverseBits(op, cond, ins)
+	case "BFC", "BFI", "BFX", "BFXU":
+		return true, false, c.lowerARMBitfield(op, cond, ins)
+	case "XTAB", "XTABU", "XTAH", "XTAHU":
+		return true, false, c.lowerARMExtendAdd(op, cond, ins)
+	case "SWPW", "SWPBU":
+		return true, false, c.lowerARMAtomicSwap(op, cond, ins)
+	case "UADD8", "USUB8":
+		return true, false, c.lowerARMUnsignedParallelByteAddSub(op, cond, setFlags, ins)
+	case "SLL", "SRL", "SRA":
+		return true, false, c.lowerARMShift(op, cond, setFlags, ins)
 	case "MRC":
 		return true, false, c.lowerARMMRC(ins)
+	case "MCR":
+		return true, false, c.lowerARMMCR(ins)
 	case "CMP", "CMN", "TST", "TEQ":
 		return true, false, c.lowerARMCompare(op, ins)
 	}
 	return false, false, nil
 }
 
+func (c *armCtx) lowerARMDivMod(op, cond string, setFlags bool, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if setFlags {
+		return fmt.Errorf("arm %s does not accept the .S suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fmt.Errorf("arm %s expects divisor, dst or divisor, numerator, dst: %q", op, ins.Raw)
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg || !isARMGeneralReg(operand.Reg) {
+			return fmt.Errorf("arm %s accepts only general registers: %q", op, ins.Raw)
+		}
+	}
+
+	divisor, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	numeratorOperand := ins.Args[len(ins.Args)-2]
+	destination := ins.Args[len(ins.Args)-1].Reg
+	numerator, err := c.loadReg(numeratorOperand.Reg)
+	if err != nil {
+		return err
+	}
+
+	zero := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", zero, divisor)
+	safeDivisor := divisor
+	overflow := "false"
+	if op == "DIV" || op == "MOD" || op == "DIVHW" {
+		isMin := c.newTmp()
+		isMinusOne := c.newTmp()
+		overflowTmp := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, -2147483648\n", isMin, numerator)
+		fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, -1\n", isMinusOne, divisor)
+		fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %%%s\n", overflowTmp, isMin, isMinusOne)
+		overflow = "%" + overflowTmp
+		invalid := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = or i1 %%%s, %s\n", invalid, zero, overflow)
+		safe := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 1, i32 %s\n", safe, invalid, divisor)
+		safeDivisor = "%" + safe
+	} else {
+		safe := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 1, i32 %s\n", safe, zero, divisor)
+		safeDivisor = "%" + safe
+	}
+
+	calculated := c.newTmp()
+	switch op {
+	case "DIV", "DIVHW":
+		fmt.Fprintf(c.b, "  %%%s = sdiv i32 %s, %s\n", calculated, numerator, safeDivisor)
+	case "DIVU", "DIVUHW":
+		fmt.Fprintf(c.b, "  %%%s = udiv i32 %s, %s\n", calculated, numerator, safeDivisor)
+	case "MOD":
+		fmt.Fprintf(c.b, "  %%%s = srem i32 %s, %s\n", calculated, numerator, safeDivisor)
+	case "MODU":
+		fmt.Fprintf(c.b, "  %%%s = urem i32 %s, %s\n", calculated, numerator, safeDivisor)
+	}
+	result := "%" + calculated
+	if op == "DIV" || op == "DIVHW" {
+		wrapped := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i32 -2147483648, i32 %s\n", wrapped, overflow, result)
+		result = "%" + wrapped
+	} else if op == "MOD" {
+		wrapped := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i32 0, i32 %s\n", wrapped, overflow, result)
+		result = "%" + wrapped
+	}
+	zeroResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 0, i32 %s\n", zeroResult, zero, result)
+	return c.selectRegWrite(destination, cond, "%"+zeroResult)
+}
+
+func armRotatedImmediateEncodable(value uint32) bool {
+	for i := 0; i < 16; i++ {
+		if value&^uint32(0xff) == 0 {
+			return true
+		}
+		value = bits.RotateLeft32(value, 2)
+	}
+	return false
+}
+
+func (c *armCtx) lowerARMShift(op, cond string, setFlags bool, ins Instr) error {
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fmt.Errorf("arm %s expects shift, dstReg or shift, srcReg, dstReg: %q", op, ins.Raw)
+	}
+	shift := ins.Args[0]
+	var src, dst Operand
+	if len(ins.Args) == 2 {
+		src, dst = ins.Args[1], ins.Args[1]
+	} else {
+		src, dst = ins.Args[1], ins.Args[2]
+	}
+	if src.Kind != OpReg || dst.Kind != OpReg {
+		return fmt.Errorf("arm %s source and destination must be registers: %q", op, ins.Raw)
+	}
+	srcValue, err := c.loadReg(src.Reg)
+	if err != nil {
+		return err
+	}
+	if _, err := c.loadReg(dst.Reg); err != nil {
+		return err
+	}
+
+	execute := "true"
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		execute, err = c.condValue(cond)
+		if err != nil {
+			return err
+		}
+	}
+
+	var result, carry string
+	switch shift.Kind {
+	case OpImm:
+		if shift.Imm < 0 || uint64(shift.Imm) > uint64(^uint32(0)) || !armRotatedImmediateEncodable(uint32(shift.Imm)) {
+			return fmt.Errorf("arm %s immediate is not a Go ARM rotated immediate: %q", op, ins.Raw)
+		}
+		encodedOp := op
+		if shift.Imm == 0 {
+			encodedOp = "SLL" // Go oplook canonicalizes explicit SRL/SRA $0.
+		}
+		result, carry = c.emitARMImmediateShift(encodedOp, srcValue, uint32(shift.Imm)&31)
+	case OpReg:
+		shiftValue, loadErr := c.loadReg(shift.Reg)
+		if loadErr != nil {
+			return loadErr
+		}
+		result, carry = c.emitARMRegisterShift(op, srcValue, shiftValue)
+	default:
+		return fmt.Errorf("arm %s shift must be an immediate or register: %q", op, ins.Raw)
+	}
+	if err := c.selectRegWrite(dst.Reg, cond, result); err != nil {
+		return err
+	}
+	if setFlags {
+		return c.setARMShiftFlags(execute, result, carry)
+	}
+	return nil
+}
+
+func (c *armCtx) emitARMImmediateShift(op, value string, encodedAmount uint32) (result, carry string) {
+	amount := encodedAmount
+	if (op == "SRL" || op == "SRA") && amount == 0 {
+		amount = 32
+	}
+	switch op {
+	case "SLL":
+		if amount == 0 {
+			result = value
+			carry = c.loadFlagValue(c.flagsCSlot)
+			return result, carry
+		}
+		result = c.emitARMConstantShift("shl", value, amount)
+		carry = c.emitARMShiftBit(value, 32-amount)
+	case "SRL":
+		if amount == 32 {
+			result = "0"
+		} else {
+			result = c.emitARMConstantShift("lshr", value, amount)
+		}
+		carry = c.emitARMShiftBit(value, amount-1)
+	case "SRA":
+		if amount == 32 {
+			result = c.emitARMConstantShift("ashr", value, 31)
+		} else {
+			result = c.emitARMConstantShift("ashr", value, amount)
+		}
+		carry = c.emitARMShiftBit(value, amount-1)
+	case "ROR":
+		if amount == 0 {
+			oldCarry := c.loadFlagValue(c.flagsCSlot)
+			wide, high, low, merged := c.newTmp(), c.newTmp(), c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i1 %s to i32\n", wide, oldCarry)
+			fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, 31\n", high, wide)
+			fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, 1\n", low, value)
+			fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", merged, high, low)
+			return "%" + merged, c.emitARMShiftBit(value, 0)
+		}
+		result = c.emitARMRotate(value, fmt.Sprint(amount))
+		carry = c.emitARMShiftBit(result, 31)
+	}
+	return result, carry
+}
+
+func (c *armCtx) emitARMRegisterShift(op, value, rawAmount string) (result, carry string) {
+	amount := c.newTmp()
+	safeAmount := c.newTmp()
+	isZero := c.newTmp()
+	isAbove32 := c.newTmp()
+	isAtLeast32 := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %s, 255\n", amount, rawAmount)
+	fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", safeAmount, amount)
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %%%s, 0\n", isZero, amount)
+	fmt.Fprintf(c.b, "  %%%s = icmp ugt i32 %%%s, 32\n", isAbove32, amount)
+	fmt.Fprintf(c.b, "  %%%s = icmp uge i32 %%%s, 32\n", isAtLeast32, amount)
+	if op == "ROR" {
+		result = c.emitARMRotate(value, "%"+safeAmount)
+		candidate := c.emitARMShiftBit(result, 31)
+		oldCarry := c.loadFlagValue(c.flagsCSlot)
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %s, i1 %s\n", selected, isZero, oldCarry, candidate)
+		return result, "%" + selected
+	}
+
+	shifted := c.newTmp()
+	llvmOp := map[string]string{"SLL": "shl", "SRL": "lshr", "SRA": "ashr"}[op]
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %%%s\n", shifted, llvmOp, value, safeAmount)
+	overflowResult := "0"
+	if op == "SRA" {
+		overflowResult = c.emitARMConstantShift("ashr", value, 31)
+	}
+	overflowSelected := c.newTmp()
+	zeroSelected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %s, i32 %%%s\n", overflowSelected, isAtLeast32, overflowResult, shifted)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 %s, i32 %%%s\n", zeroSelected, isZero, value, overflowSelected)
+	result = "%" + zeroSelected
+
+	position := c.newTmp()
+	if op == "SLL" {
+		fmt.Fprintf(c.b, "  %%%s = sub i32 32, %%%s\n", position, amount)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, 1\n", position, amount)
+	}
+	safePosition := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, 31\n", safePosition, position)
+	candidateCarry := c.emitARMVariableShiftBit(value, "%"+safePosition)
+	overflowCarry := "false"
+	if op == "SRA" {
+		overflowCarry = c.emitARMShiftBit(value, 31)
+	}
+	overflowCarrySelected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %s, i1 %s\n", overflowCarrySelected, isAbove32, overflowCarry, candidateCarry)
+	oldCarry := c.loadFlagValue(c.flagsCSlot)
+	zeroCarrySelected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i1 %s, i1 %%%s\n", zeroCarrySelected, isZero, oldCarry, overflowCarrySelected)
+	return result, "%" + zeroCarrySelected
+}
+
+func (c *armCtx) emitARMConstantShift(op, value string, amount uint32) string {
+	tmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %d\n", tmp, op, value, amount)
+	return "%" + tmp
+}
+
+func (c *armCtx) emitARMShiftBit(value string, position uint32) string {
+	return c.emitARMVariableShiftBit(value, fmt.Sprintf("%d", position))
+}
+
+func (c *armCtx) emitARMVariableShiftBit(value, position string) string {
+	shifted := c.newTmp()
+	bit := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, %s\n", shifted, value, position)
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %%%s to i1\n", bit, shifted)
+	return "%" + bit
+}
+
+func (c *armCtx) loadFlagValue(slot string) string {
+	tmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", tmp, slot)
+	return "%" + tmp
+}
+
+func (c *armCtx) setARMShiftFlags(execute, result, carry string) error {
+	c.flagsWritten = true
+	zero := c.newTmp()
+	negative := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", zero, result)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i32 %s, 0\n", negative, result)
+	c.storeFlagPredicate(c.flagsZSlot, "%"+zero, execute)
+	c.storeFlagPredicate(c.flagsNSlot, "%"+negative, execute)
+	c.storeFlagPredicate(c.flagsCSlot, carry, execute)
+	return nil
+}
+
+func (c *armCtx) storeFlagPredicate(slot, value, execute string) {
+	if execute == "true" {
+		c.storeFlag(slot, value)
+		return
+	}
+	old := c.loadFlagValue(slot)
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i1 %s, i1 %s\n", selected, execute, value, old)
+	c.storeFlag(slot, "%"+selected)
+}
+
 func (c *armCtx) lowerARMALU(op, cond string, setFlags bool, ins Instr) error {
+	if err := validateARMDataProcessing(op, ins, setFlags); err != nil {
+		return err
+	}
 	if len(ins.Args) != 2 && len(ins.Args) != 3 {
 		return fmt.Errorf("arm %s expects 2 or 3 operands: %q", op, ins.Raw)
 	}
-	var src, lhs string
+	var src, lhs, shifterCarry string
 	dst := Operand{}
 	var err error
 	if len(ins.Args) == 2 {
@@ -47,7 +359,7 @@ func (c *armCtx) lowerARMALU(op, cond string, setFlags bool, ins Instr) error {
 		if dst.Kind != OpReg {
 			return fmt.Errorf("arm %s dst must be reg: %q", op, ins.Raw)
 		}
-		src, err = c.eval32(ins.Args[0], false)
+		src, shifterCarry, err = c.evalARMLogicalOperand(op, ins.Args[0])
 		if err != nil {
 			return err
 		}
@@ -60,7 +372,7 @@ func (c *armCtx) lowerARMALU(op, cond string, setFlags bool, ins Instr) error {
 		if dst.Kind != OpReg {
 			return fmt.Errorf("arm %s dst must be reg: %q", op, ins.Raw)
 		}
-		src, err = c.eval32(ins.Args[0], false)
+		src, shifterCarry, err = c.evalARMLogicalOperand(op, ins.Args[0])
 		if err != nil {
 			return err
 		}
@@ -102,20 +414,38 @@ func (c *armCtx) lowerARMALU(op, cond string, setFlags bool, ins Instr) error {
 	case "RSB":
 		return c.setFlagsSub(cond, src, lhs, "%"+t)
 	case "AND", "ORR", "EOR", "BIC":
-		return c.setFlagsLogic(cond, "%"+t)
+		return c.setARMLogicalFlags(cond, "%"+t, shifterCarry)
 	default:
 		return nil
 	}
 }
 
 func (c *armCtx) lowerARMCompare(op string, ins Instr) error {
+	return c.lowerARMCompareWithCarry(op, ins, "")
+}
+
+func (c *armCtx) lowerARMCompareWithCarry(op string, ins Instr, rawCarry string) error {
+	if err := validateARMDataProcessing(op, ins, false); err != nil {
+		return err
+	}
 	if len(ins.Args) != 2 {
 		return fmt.Errorf("arm %s expects 2 operands: %q", op, ins.Raw)
 	}
-	src, err := c.eval32(ins.Args[0], false)
+	_, condition, _, _ := armDecodeOp(string(ins.Op))
+	if condition != "" && condition != "AL" {
+		unconditional := ins
+		unconditional.Op = Op(op)
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerARMCompareWithCarry(op, unconditional, rawCarry)
+		})
+	}
+	src, shifterCarry, err := c.evalARMLogicalOperand(op, ins.Args[0])
 	if err != nil {
 		return err
 	}
+	if rawCarry != "" {
+		shifterCarry = rawCarry
+	}
 	lhs, err := c.eval32(ins.Args[1], false)
 	if err != nil {
 		return err
@@ -134,12 +464,12 @@ func (c *armCtx) lowerARMCompare(op string, ins Instr) error {
 		}
 	case "TST":
 		fmt.Fprintf(c.b, "  %%%s = and i32 %s, %s\n", res, lhs, src)
-		if err := c.setFlagsLogic("", "%"+res); err != nil {
+		if err := c.setARMLogicalFlags("", "%"+res, shifterCarry); err != nil {
 			return err
 		}
 	case "TEQ":
 		fmt.Fprintf(c.b, "  %%%s = xor i32 %s, %s\n", res, lhs, src)
-		if err := c.setFlagsLogic("", "%"+res); err != nil {
+		if err := c.setARMLogicalFlags("", "%"+res, shifterCarry); err != nil {
 			return err
 		}
 	}
@@ -147,20 +477,23 @@ func (c *armCtx) lowerARMCompare(op string, ins Instr) error {
 }
 
 func (c *armCtx) lowerARMMVN(cond string, setFlags bool, ins Instr) error {
+	if err := validateARMDataProcessing("MVN", ins, setFlags); err != nil {
+		return err
+	}
 	if len(ins.Args) != 2 && len(ins.Args) != 3 {
 		return fmt.Errorf("arm MVN expects 2 or 3 operands: %q", ins.Raw)
 	}
-	var src string
+	var src, shifterCarry string
 	var dst Operand
 	var err error
 	if len(ins.Args) == 2 {
-		src, err = c.eval32(ins.Args[0], false)
+		src, shifterCarry, err = c.evalARMLogicalOperand("MVN", ins.Args[0])
 		if err != nil {
 			return err
 		}
 		dst = ins.Args[1]
 	} else {
-		src, err = c.eval32(ins.Args[1], false)
+		src, shifterCarry, err = c.evalARMLogicalOperand("MVN", ins.Args[1])
 		if err != nil {
 			return err
 		}
@@ -175,7 +508,7 @@ func (c *armCtx) lowerARMMVN(cond string, setFlags bool, ins Instr) error {
 		return err
 	}
 	if setFlags {
-		return c.setFlagsLogic(cond, "%"+t)
+		return c.setARMLogicalFlags(cond, "%"+t, shifterCarry)
 	}
 	return nil
 }
@@ -184,6 +517,20 @@ func (c *armCtx) lowerARMADCSBC(op, cond string, setFlags bool, ins Instr) error
 	if len(ins.Args) != 2 && len(ins.Args) != 3 {
 		return fmt.Errorf("arm %s expects 2 or 3 operands: %q", op, ins.Raw)
 	}
+	if op == "RSC" {
+		source := ins.Args[0]
+		sourceOK := source.Kind == OpImm ||
+			source.Kind == OpReg && isARMGeneralReg(source.Reg) ||
+			source.Kind == OpRegShift && isARMGeneralReg(source.Reg)
+		if !sourceOK {
+			return fmt.Errorf("arm RSC source must be an immediate, general register, or shifted general register: %q", ins.Raw)
+		}
+		for _, operand := range ins.Args[1:] {
+			if operand.Kind != OpReg || !isARMGeneralReg(operand.Reg) {
+				return fmt.Errorf("arm RSC input and destination must be general registers: %q", ins.Raw)
+			}
+		}
+	}
 	var src, lhs string
 	dst := Operand{}
 	var err error
@@ -217,7 +564,7 @@ func (c *armCtx) lowerARMADCSBC(op, cond string, setFlags bool, ins Instr) error
 	cf := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = load i1, ptr %s\n", cf, c.flagsCSlot)
 	cin := c.newTmp()
-	if op == "SBC" {
+	if op == "SBC" || op == "RSC" {
 		ncf := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = xor i1 %%%s, true\n", ncf, cf)
 		fmt.Fprintf(c.b, "  %%%s = zext i1 %%%s to i32\n", cin, ncf)
@@ -227,11 +574,13 @@ func (c *armCtx) lowerARMADCSBC(op, cond string, setFlags bool, ins Instr) error
 	t0 := c.newTmp()
 	if op == "SBC" {
 		fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %s\n", t0, lhs, src)
+	} else if op == "RSC" {
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %s\n", t0, src, lhs)
 	} else {
 		fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", t0, lhs, src)
 	}
 	res := c.newTmp()
-	if op == "SBC" {
+	if op == "SBC" || op == "RSC" {
 		fmt.Fprintf(c.b, "  %%%s = sub i32 %%%s, %%%s\n", res, t0, cin)
 	} else {
 		fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %%%s\n", res, t0, cin)
@@ -260,17 +609,21 @@ func (c *armCtx) lowerARMADCSBC(op, cond string, setFlags bool, ins Instr) error
 				return err
 			}
 		} else {
+			minuend, subtrahend := lhs, src
+			if op == "RSC" {
+				minuend, subtrahend = src, lhs
+			}
 			l64 := c.newTmp()
 			s64 := c.newTmp()
 			b64 := c.newTmp()
 			subtr := c.newTmp()
 			borrow := c.newTmp()
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", l64, lhs)
-			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", s64, src)
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", l64, minuend)
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", s64, subtrahend)
 			fmt.Fprintf(c.b, "  %%%s = zext i32 %%%s to i64\n", b64, cin)
 			fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", subtr, s64, b64)
 			fmt.Fprintf(c.b, "  %%%s = icmp ult i64 %%%s, %%%s\n", borrow, l64, subtr)
-			if err := c.setFlagsSub(cond, lhs, src, "%"+res); err != nil {
+			if err := c.setFlagsSub(cond, minuend, subtrahend, "%"+res); err != nil {
 				return err
 			}
 			nb := c.newTmp()
@@ -313,183 +666,34 @@ func (c *armCtx) selectRegPairWrite(hi, lo Reg, cond, newHi, newLo string) error
 }
 
 func (c *armCtx) lowerARMMUL(cond string, ins Instr) error {
-	if len(ins.Args) != 2 && len(ins.Args) != 3 {
-		return fmt.Errorf("arm MUL expects 2 or 3 operands: %q", ins.Raw)
-	}
-	var a, b string
-	var dst Operand
-	var err error
-	if len(ins.Args) == 2 {
-		dst = ins.Args[1]
-		if dst.Kind != OpReg {
-			return fmt.Errorf("arm MUL dst must be reg: %q", ins.Raw)
-		}
-		a, err = c.eval32(ins.Args[0], false)
-		if err != nil {
-			return err
-		}
-		b, err = c.loadReg(dst.Reg)
-		if err != nil {
-			return err
-		}
-	} else {
-		dst = ins.Args[2]
-		if dst.Kind != OpReg {
-			return fmt.Errorf("arm MUL dst must be reg: %q", ins.Raw)
-		}
-		a, err = c.eval32(ins.Args[0], false)
-		if err != nil {
-			return err
-		}
-		b, err = c.eval32(ins.Args[1], false)
-		if err != nil {
-			return err
-		}
-	}
-	t := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", t, a, b)
-	return c.selectRegWrite(dst.Reg, cond, "%"+t)
+	_, _, _, flags := armDecodeOp(string(ins.Op))
+	return c.lowerARMBasicMultiply("MUL", cond, flags, ins)
 }
 
 func (c *armCtx) lowerARMMULLU(cond string, ins Instr) error {
-	if len(ins.Args) != 3 || ins.Args[2].Kind != OpRegList || len(ins.Args[2].RegList) != 2 {
-		return fmt.Errorf("arm MULLU expects src, lhs, (hi,lo): %q", ins.Raw)
-	}
-	a, err := c.eval32(ins.Args[0], false)
-	if err != nil {
-		return err
-	}
-	b, err := c.eval32(ins.Args[1], false)
-	if err != nil {
-		return err
-	}
-	a64 := c.zextI32ToI64(a)
-	b64 := c.zextI32ToI64(b)
-	prod := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", prod, a64, b64)
-	lo := c.newTmp()
-	hiShift := c.newTmp()
-	hi := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", lo, prod)
-	fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 32\n", hiShift, prod)
-	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi, hiShift)
-	return c.selectRegPairWrite(ins.Args[2].RegList[0], ins.Args[2].RegList[1], cond, "%"+hi, "%"+lo)
+	_, _, _, flags := armDecodeOp(string(ins.Op))
+	return c.lowerARMBasicMultiply("MULLU", cond, flags, ins)
 }
 
 func (c *armCtx) lowerARMMULA(cond string, ins Instr) error {
-	if len(ins.Args) != 4 || ins.Args[3].Kind != OpReg {
-		return fmt.Errorf("arm MULA expects a, b, acc, dst: %q", ins.Raw)
-	}
-	a, err := c.eval32(ins.Args[0], false)
-	if err != nil {
-		return err
-	}
-	b, err := c.eval32(ins.Args[1], false)
-	if err != nil {
-		return err
-	}
-	acc, err := c.eval32(ins.Args[2], false)
-	if err != nil {
-		return err
-	}
-	mul := c.newTmp()
-	res := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", mul, a, b)
-	fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %s\n", res, mul, acc)
-	return c.selectRegWrite(ins.Args[3].Reg, cond, "%"+res)
+	_, _, _, flags := armDecodeOp(string(ins.Op))
+	return c.lowerARMBasicMultiply("MULA", cond, flags, ins)
 }
 
 func (c *armCtx) lowerARMMULAL(cond string, ins Instr) error {
-	if len(ins.Args) != 3 || ins.Args[2].Kind != OpRegList || len(ins.Args[2].RegList) != 2 {
-		return fmt.Errorf("arm MULAL expects a, b, (hi,lo): %q", ins.Raw)
+	op, _, _, flags := armDecodeOp(string(ins.Op))
+	if op != "MULALU" {
+		op = "MULAL"
 	}
-	hiReg := ins.Args[2].RegList[0]
-	loReg := ins.Args[2].RegList[1]
-	a, err := c.eval32(ins.Args[0], false)
-	if err != nil {
-		return err
-	}
-	b, err := c.eval32(ins.Args[1], false)
-	if err != nil {
-		return err
-	}
-	oldHi, err := c.loadReg(hiReg)
-	if err != nil {
-		return err
-	}
-	oldLo, err := c.loadReg(loReg)
-	if err != nil {
-		return err
-	}
-	oldHi64 := c.zextI32ToI64(oldHi)
-	oldLo64 := c.zextI32ToI64(oldLo)
-	hiSh := c.newTmp()
-	old64 := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 32\n", hiSh, oldHi64)
-	fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", old64, hiSh, oldLo64)
-	prod := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", prod, c.zextI32ToI64(a), c.zextI32ToI64(b))
-	sum := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = add i64 %%%s, %%%s\n", sum, old64, prod)
-	lo := c.newTmp()
-	hiShift := c.newTmp()
-	hi := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", lo, sum)
-	fmt.Fprintf(c.b, "  %%%s = lshr i64 %%%s, 32\n", hiShift, sum)
-	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi, hiShift)
-	return c.selectRegPairWrite(hiReg, loReg, cond, "%"+hi, "%"+lo)
+	return c.lowerARMBasicMultiply(op, cond, flags, ins)
 }
 
 func (c *armCtx) lowerARMMULAWT(cond string, ins Instr) error {
-	if len(ins.Args) != 4 || ins.Args[3].Kind != OpReg {
-		return fmt.Errorf("arm MULAWT expects a, b, acc, dst: %q", ins.Raw)
-	}
-	a, err := c.eval32(ins.Args[0], false)
-	if err != nil {
-		return err
-	}
-	b, err := c.eval32(ins.Args[1], false)
-	if err != nil {
-		return err
-	}
-	acc, err := c.eval32(ins.Args[2], false)
-	if err != nil {
-		return err
-	}
-	a64 := c.newTmp()
-	b64 := c.newTmp()
-	prod := c.newTmp()
-	hiShift := c.newTmp()
-	hi := c.newTmp()
-	res := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", a64, a)
-	fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", b64, b)
-	fmt.Fprintf(c.b, "  %%%s = mul i64 %%%s, %%%s\n", prod, a64, b64)
-	fmt.Fprintf(c.b, "  %%%s = ashr i64 %%%s, 32\n", hiShift, prod)
-	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi, hiShift)
-	fmt.Fprintf(c.b, "  %%%s = add i32 %%%s, %s\n", res, hi, acc)
-	return c.selectRegWrite(ins.Args[3].Reg, cond, "%"+res)
+	return c.lowerARMSignedMultiply("MULAWT", cond, false, ins)
 }
 
 func (c *armCtx) lowerARMDIVUHW(cond string, ins Instr) error {
-	if len(ins.Args) != 3 || ins.Args[2].Kind != OpReg {
-		return fmt.Errorf("arm DIVUHW expects divisor, numerator, dst: %q", ins.Raw)
-	}
-	divisor, err := c.eval32(ins.Args[0], false)
-	if err != nil {
-		return err
-	}
-	numer, err := c.eval32(ins.Args[1], false)
-	if err != nil {
-		return err
-	}
-	zero := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = icmp eq i32 %s, 0\n", zero, divisor)
-	div := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = udiv i32 %s, %s\n", div, numer, divisor)
-	sel := c.newTmp()
-	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i32 0, i32 %%%s\n", sel, zero, div)
-	return c.selectRegWrite(ins.Args[2].Reg, cond, "%"+sel)
+	return c.lowerARMDivMod("DIVUHW", cond, false, ins)
 }
 
 func (c *armCtx) lowerARMCLZ(cond string, ins Instr) error {
@@ -511,11 +715,36 @@ func (c *armCtx) lowerARMMRC(ins Instr) error {
 	}
 	part := func(op Operand) string {
 		s := strings.ToLower(strings.TrimSpace(op.String()))
-		return strings.TrimPrefix(s, "$")
+		s = strings.TrimPrefix(s, "$")
+		return strings.TrimPrefix(s, "c")
 	}
 	// LLVM inline asm refers to the single output register via $0.
-	asm := fmt.Sprintf("mrc p%s, %s, $0, %s, %s, %s", part(ins.Args[0]), part(ins.Args[1]), part(ins.Args[3]), part(ins.Args[4]), part(ins.Args[5]))
+	asm := fmt.Sprintf("mrc p%s, #%s, $0, c%s, c%s, #%s",
+		part(ins.Args[0]), part(ins.Args[1]), part(ins.Args[3]), part(ins.Args[4]), part(ins.Args[5]))
 	t := c.newTmp()
 	fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n", t, asm, "=r,~{memory}")
 	return c.storeReg(ins.Args[2].Reg, "%"+t)
 }
+
+func (c *armCtx) lowerARMMCR(ins Instr) error {
+	if len(ins.Args) != 6 || ins.Args[2].Kind != OpReg || !isARMGeneralReg(ins.Args[2].Reg) {
+		return fmt.Errorf("arm MCR expects coprocessor, operation, source register, CRn, CRm, information: %q", ins.Raw)
+	}
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix != "" && suffix != "S" && !armCondCodes[suffix] {
+			return fmt.Errorf("arm MCR suffix %q is absent from the Go 1.27 optab: %q", suffix, ins.Raw)
+		}
+	}
+	part := func(op Operand) string {
+		s := strings.ToLower(strings.TrimSpace(op.String()))
+		s = strings.TrimPrefix(s, "$")
+		return strings.TrimPrefix(s, "c")
+	}
+	value, err := c.loadReg(ins.Args[2].Reg)
+	if err != nil {
+		return err
+	}
+	asm := fmt.Sprintf("mcr p%s, #%s, $0, c%s, c%s, #%s", part(ins.Args[0]), part(ins.Args[1]), part(ins.Args[3]), part(ins.Args[4]), part(ins.Args[5]))
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n", asm, "r,~{memory}", value)
+	return nil
+}
diff --git a/arm_lower_atomic.go b/arm_lower_atomic.go
index 245a3eb6a..69697a82e 100644
--- a/arm_lower_atomic.go
+++ b/arm_lower_atomic.go
@@ -97,14 +97,34 @@ func (c *armCtx) lowerAtomic(op string, ins Instr) (ok bool, terminated bool, er
 		return true, false, c.storeReg(ins.Args[1].Reg, v)
 
 	case "LDREXD":
-		if len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg {
-			return true, false, fmt.Errorf("arm LDREXD expects mem, regLo: %q", ins.Raw)
+		var mem Operand
+		var loReg, hiReg Reg
+		switch {
+		case len(ins.Args) == 2 && ins.Args[0].Kind == OpMem && ins.Args[1].Kind == OpReg:
+			mem, loReg = ins.Args[0], ins.Args[1].Reg
+		case len(ins.Args) == 3 && ins.Args[0].Kind == OpMem && ins.Args[1].Kind == OpReg && ins.Args[2].Kind == OpReg:
+			// x/arch's raw ARM syntax prints the implicit pair explicitly as
+			// mem, regHi, regLo; Go source syntax prints mem, regLo.
+			mem, hiReg, loReg = ins.Args[0], ins.Args[1].Reg, ins.Args[2].Reg
+		default:
+			return true, false, fmt.Errorf("arm LDREXD expects mem, regLo (or decoded mem, regHi, regLo): %q", ins.Raw)
 		}
-		hiReg, err := armNextReg(ins.Args[1].Reg)
-		if err != nil {
-			return true, false, err
+		if hiReg == "" {
+			var err error
+			hiReg, err = armNextReg(loReg)
+			if err != nil {
+				return true, false, err
+			}
+		} else {
+			wantHi, err := armNextReg(loReg)
+			if err != nil || hiReg != wantHi {
+				return true, false, fmt.Errorf("arm LDREXD register pair must be consecutive: %q", ins.Raw)
+			}
 		}
-		ptr, err := c.atomicMemPtr(ins.Args[0].Mem)
+		if loReg == "" {
+			return true, false, fmt.Errorf("arm LDREXD missing low register: %q", ins.Raw)
+		}
+		ptr, err := c.atomicMemPtr(mem.Mem)
 		if err != nil {
 			return true, false, err
 		}
@@ -120,7 +140,7 @@ func (c *armCtx) lowerAtomic(op string, ins Instr) (ok bool, terminated bool, er
 		fmt.Fprintf(c.b, "  store ptr %s, ptr %s\n", ptr, c.exclusivePtrSlot)
 		fmt.Fprintf(c.b, "  store i8 8, ptr %s\n", c.exclusiveSizeSlot)
 		fmt.Fprintf(c.b, "  store i64 %%%s, ptr %s\n", ld, c.exclusiveValueSlot)
-		if err := c.storeReg(ins.Args[1].Reg, "%"+lo); err != nil {
+		if err := c.storeReg(loReg, "%"+lo); err != nil {
 			return true, false, err
 		}
 		return true, false, c.storeReg(hiReg, "%"+hi)
@@ -152,14 +172,30 @@ func (c *armCtx) lowerAtomic(op string, ins Instr) (ok bool, terminated bool, er
 		return true, false, c.storeReg(ins.Args[2].Reg, status)
 
 	case "STREXD":
-		if len(ins.Args) != 3 || ins.Args[0].Kind != OpReg || ins.Args[1].Kind != OpMem || ins.Args[2].Kind != OpReg {
-			return true, false, fmt.Errorf("arm STREXD expects srcLoReg, mem, statusReg: %q", ins.Raw)
+		var loReg, hiReg, statusReg Reg
+		var mem Operand
+		switch {
+		case len(ins.Args) == 3 && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpMem && ins.Args[2].Kind == OpReg:
+			loReg, mem, statusReg = ins.Args[0].Reg, ins.Args[1], ins.Args[2].Reg
+		case len(ins.Args) == 4 && ins.Args[0].Kind == OpMem && ins.Args[1].Kind == OpReg && ins.Args[2].Kind == OpReg && ins.Args[3].Kind == OpReg:
+			// x/arch's raw ARM syntax prints mem, regHi, regLo, status.
+			mem, hiReg, loReg, statusReg = ins.Args[0], ins.Args[1].Reg, ins.Args[2].Reg, ins.Args[3].Reg
+		default:
+			return true, false, fmt.Errorf("arm STREXD expects srcLoReg, mem, statusReg (or decoded mem, regHi, regLo, statusReg): %q", ins.Raw)
+		}
+		var err error
+		if hiReg == "" {
+			hiReg, err = armNextReg(loReg)
+		} else {
+			wantHi, pairErr := armNextReg(loReg)
+			if pairErr != nil || hiReg != wantHi {
+				err = fmt.Errorf("arm STREXD register pair must be consecutive: %q", ins.Raw)
+			}
 		}
-		hiReg, err := armNextReg(ins.Args[0].Reg)
 		if err != nil {
 			return true, false, err
 		}
-		lo, err := c.loadReg(ins.Args[0].Reg)
+		lo, err := c.loadReg(loReg)
 		if err != nil {
 			return true, false, err
 		}
@@ -173,7 +209,7 @@ func (c *armCtx) lowerAtomic(op string, ins Instr) (ok bool, terminated bool, er
 		new64 := c.newTmp()
 		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 32\n", hiShift, hi64)
 		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", new64, hiShift, lo64)
-		ptr, err := c.atomicMemPtr(ins.Args[1].Mem)
+		ptr, err := c.atomicMemPtr(mem.Mem)
 		if err != nil {
 			return true, false, err
 		}
@@ -181,7 +217,7 @@ func (c *armCtx) lowerAtomic(op string, ins Instr) (ok bool, terminated bool, er
 		if err != nil {
 			return true, false, err
 		}
-		return true, false, c.storeReg(ins.Args[2].Reg, status)
+		return true, false, c.storeReg(statusReg, status)
 	}
 	return false, false, nil
 }
diff --git a/arm_lower_atomic_swap.go b/arm_lower_atomic_swap.go
new file mode 100644
index 000000000..a7d6e0d56
--- /dev/null
+++ b/arm_lower_atomic_swap.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import "fmt"
+
+func (c *armCtx) lowerARMAtomicSwap(op, cond string, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if len(ins.Args) != 3 ||
+		ins.Args[0].Kind != OpReg || !isARMGeneralReg(ins.Args[0].Reg) ||
+		ins.Args[1].Kind != OpMem || ins.Args[1].Mem.Base == "" || ins.Args[1].Mem.Off != 0 ||
+		ins.Args[1].Mem.OffRaw != "" || ins.Args[1].Mem.Index != "" || ins.Args[1].Mem.Sym != "" ||
+		ins.Args[2].Kind != OpReg || !isARMGeneralReg(ins.Args[2].Reg) {
+		return fmt.Errorf("arm %s expects source register, (base register), destination register: %q", op, ins.Raw)
+	}
+	if cond != "" {
+		return c.emitConditionalEffect(cond, func() error {
+			return c.lowerARMAtomicSwap(op, "", ins)
+		})
+	}
+	source, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	address, _, _, err := c.addrI32(ins.Args[1].Mem, false)
+	if err != nil {
+		return err
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, address)
+	if op == "SWPW" {
+		old := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = atomicrmw xchg ptr %%%s, i32 %s seq_cst\n", old, pointer, source)
+		return c.storeReg(ins.Args[2].Reg, "%"+old)
+	}
+	narrowed := c.newTmp()
+	old := c.newTmp()
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i8\n", narrowed, source)
+	fmt.Fprintf(c.b, "  %%%s = atomicrmw xchg ptr %%%s, i8 %%%s seq_cst\n", old, pointer, narrowed)
+	fmt.Fprintf(c.b, "  %%%s = zext i8 %%%s to i32\n", extended, old)
+	return c.storeReg(ins.Args[2].Reg, "%"+extended)
+}
diff --git a/arm_lower_atomic_swap_test.go b/arm_lower_atomic_swap_test.go
new file mode 100644
index 000000000..5c8362d79
--- /dev/null
+++ b/arm_lower_atomic_swap_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armAtomicSwapForms = `TEXT atomicSwapForms(SB),$0-0
+	SWPW R3, (R7), R9
+	SWPBU R4, (R2), R8
+	RET
+`
+
+func TestTranslateARMAtomicSwapCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armAtomicSwapForms, true)
+	ll := translateARMForTest(t, armAtomicSwapForms, map[string]FuncSig{
+		"example.atomicSwapForms": {Name: "example.atomicSwapForms", Ret: Void},
+	})
+	for _, want := range []string{"atomicrmw xchg ptr", "i32", "i8", "zext i8"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM atomic swap lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-atomic-swap.ll", "arm-atomic-swap.o", ll)
+}
+
+func TestTranslateARMAtomicSwapRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"SWPW R0, 4(R1), R2", "SWPBU R0, (R1)"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM atomic-swap optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_basic_multiply.go b/arm_lower_basic_multiply.go
new file mode 100644
index 000000000..545f17de7
--- /dev/null
+++ b/arm_lower_basic_multiply.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import "fmt"
+
+// Go asm5 types 15/17/99 and their opset aliases admit .S for exactly this
+// ordinary multiply family. ARMv5 and newer preserve C/V, setting N/Z from
+// the complete 32- or 64-bit result (Arm DUI 0489C sections 3.5.1/3.5.2).
+type armBasicMultiplySpec struct {
+	width      int
+	signed     bool
+	accumulate bool
+}
+
+var armBasicMultiplySpecs = map[string]armBasicMultiplySpec{
+	"MUL":    {width: 32},
+	"MULU":   {width: 32},
+	"MULA":   {width: 32, accumulate: true},
+	"MULL":   {width: 64, signed: true},
+	"MULLU":  {width: 64},
+	"MULAL":  {width: 64, signed: true, accumulate: true},
+	"MULALU": {width: 64, accumulate: true},
+}
+
+func (c *armCtx) lowerARMBasicMultiply(op, condition string, setFlags bool, ins Instr) error {
+	spec, ok := armBasicMultiplySpecs[op]
+	if !ok {
+		return fmt.Errorf("ARM multiply has no typed specification: %s", ins.Raw)
+	}
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix != "" && suffix != "S" && !armCondCodes[suffix] {
+			return fmt.Errorf("ARM %s suffix %q is absent from Go asm5: %s", op, suffix, ins.Raw)
+		}
+	}
+	want := 3
+	if spec.width == 32 && spec.accumulate {
+		want = 4
+	}
+	if len(ins.Args) != want && !(spec.width == 32 && !spec.accumulate && len(ins.Args) == 2) {
+		return fmt.Errorf("ARM %s has an invalid register operand count: %s", op, ins.Raw)
+	}
+	for i, source := range ins.Args {
+		if i == len(ins.Args)-1 && spec.width == 64 {
+			if source.Kind != OpRegList || len(source.RegList) != 2 || !armRegListAllGPR(source.RegList) {
+				return fmt.Errorf("ARM %s requires an (hi,lo) register pair: %s", op, ins.Raw)
+			}
+		} else if source.Kind != OpReg || !isARMGeneralReg(source.Reg) {
+			return fmt.Errorf("ARM %s requires general-register operands: %s", op, ins.Raw)
+		}
+	}
+	return c.emitConditionalEffect(condition, func() error {
+		first, err := c.loadReg(ins.Args[0].Reg)
+		if err != nil {
+			return err
+		}
+		second, err := c.loadReg(ins.Args[1].Reg)
+		if err != nil {
+			return err
+		}
+		if spec.width == 64 {
+			extend := func(value string) string {
+				if !spec.signed {
+					return c.zextI32ToI64(value)
+				}
+				tmp := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", tmp, value)
+				return "%" + tmp
+			}
+			first, second = extend(first), extend(second)
+		}
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i%d %s, %s\n", product, spec.width, first, second)
+		result := "%" + product
+		destination := ins.Args[len(ins.Args)-1]
+		if spec.accumulate {
+			var accumulator string
+			if spec.width == 32 {
+				accumulator, err = c.loadReg(ins.Args[2].Reg)
+			} else {
+				hi, loadErr := c.loadReg(destination.RegList[0])
+				if loadErr != nil {
+					return loadErr
+				}
+				lo, loadErr := c.loadReg(destination.RegList[1])
+				if loadErr != nil {
+					return loadErr
+				}
+				wideHi, wideLo := c.zextI32ToI64(hi), c.zextI32ToI64(lo)
+				shifted, combined := c.newTmp(), c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 32\n", shifted, wideHi)
+				fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", combined, shifted, wideLo)
+				accumulator = "%" + combined
+			}
+			if err != nil {
+				return err
+			}
+			sum := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i%d %s, %s\n", sum, spec.width, result, accumulator)
+			result = "%" + sum
+		}
+		if spec.width == 32 {
+			if err := c.storeReg(destination.Reg, result); err != nil {
+				return err
+			}
+		} else {
+			lo, shifted, hi := c.newTmp(), c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", lo, result)
+			fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", shifted, result)
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", hi, shifted)
+			if err := c.selectRegPairWrite(destination.RegList[0], destination.RegList[1], "", "%"+hi, "%"+lo); err != nil {
+				return err
+			}
+		}
+		if setFlags {
+			zero, negative := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp eq i%d %s, 0\n", zero, spec.width, result)
+			fmt.Fprintf(c.b, "  %%%s = icmp slt i%d %s, 0\n", negative, spec.width, result)
+			c.storeFlag(c.flagsZSlot, "%"+zero)
+			c.storeFlag(c.flagsNSlot, "%"+negative)
+			c.flagsWritten = true
+		}
+		return nil
+	})
+}
diff --git a/arm_lower_bitfield.go b/arm_lower_bitfield.go
new file mode 100644
index 000000000..d8dc8dcd3
--- /dev/null
+++ b/arm_lower_bitfield.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import "fmt"
+
+func (c *armCtx) lowerARMBitfield(op, cond string, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if len(ins.Args) != 3 && len(ins.Args) != 4 {
+		return fmt.Errorf("arm %s expects width, lsb, dst or width, lsb, src, dst: %q", op, ins.Raw)
+	}
+	if op == "BFC" && len(ins.Args) != 3 {
+		return fmt.Errorf("arm BFC expects width, lsb, dst: %q", ins.Raw)
+	}
+	if ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" ||
+		ins.Args[1].Kind != OpImm || ins.Args[1].ImmRaw != "" {
+		return fmt.Errorf("arm %s width and lsb must be resolved integer constants: %q", op, ins.Raw)
+	}
+	width, lsb := ins.Args[0].Imm, ins.Args[1].Imm
+	if width <= 0 || width > 32 || lsb < 0 || lsb >= 32 || width+lsb > 32 {
+		return fmt.Errorf("arm %s requires 1 <= width <= 32 and 0 <= lsb with width+lsb <= 32: %q", op, ins.Raw)
+	}
+	sourceOperand := ins.Args[len(ins.Args)-1]
+	if len(ins.Args) == 4 {
+		sourceOperand = ins.Args[2]
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	if sourceOperand.Kind != OpReg || !isARMGeneralReg(sourceOperand.Reg) ||
+		destination.Kind != OpReg || !isARMGeneralReg(destination.Reg) {
+		return fmt.Errorf("arm %s source and destination must be general registers: %q", op, ins.Raw)
+	}
+	source, err := c.loadReg(sourceOperand.Reg)
+	if err != nil {
+		return err
+	}
+	fieldMask := ^uint32(0)
+	if width < 32 {
+		fieldMask = uint32(1)<<uint(width) - 1
+	}
+	placedMask := fieldMask << uint(lsb)
+	result := ""
+	switch op {
+	case "BFX", "BFXU":
+		shifted := c.newTmp()
+		if op == "BFX" {
+			left := 32 - width - lsb
+			fmt.Fprintf(c.b, "  %%%s = shl i32 %s, %d\n", shifted, source, left)
+			extended := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = ashr i32 %%%s, %d\n", extended, shifted, 32-width)
+			result = "%" + extended
+		} else {
+			fmt.Fprintf(c.b, "  %%%s = lshr i32 %s, %d\n", shifted, source, lsb)
+			masked := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = and i32 %%%s, %d\n", masked, shifted, int32(fieldMask))
+			result = "%" + masked
+		}
+	case "BFC":
+		cleared := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, %d\n", cleared, source, int32(^placedMask))
+		result = "%" + cleared
+	case "BFI":
+		old, loadErr := c.loadReg(destination.Reg)
+		if loadErr != nil {
+			return loadErr
+		}
+		cleared := c.newTmp()
+		masked := c.newTmp()
+		shifted := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, %d\n", cleared, old, int32(^placedMask))
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, %d\n", masked, source, int32(fieldMask))
+		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, %d\n", shifted, masked, lsb)
+		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", combined, cleared, shifted)
+		result = "%" + combined
+	default:
+		return fmt.Errorf("arm: unsupported bitfield instruction %s", op)
+	}
+	return c.selectRegWrite(destination.Reg, cond, result)
+}
diff --git a/arm_lower_bitfield_test.go b/arm_lower_bitfield_test.go
new file mode 100644
index 000000000..c8156d969
--- /dev/null
+++ b/arm_lower_bitfield_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armBitfieldForms = `TEXT bitfieldForms(SB),$0-0
+	BFX $16, $8, R1, R2
+	BFX $29, $2, R8
+	BFXU $16, $8, R1, R2
+	BFXU $29, $2, R8
+	BFC $29, $2, R8
+	BFI $29, $2, R8
+	BFI $16, $8, R1, R2
+	RET
+`
+
+func TestTranslateARMBitfieldCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armBitfieldForms, true)
+	ll := translateARMForTest(t, armBitfieldForms, map[string]FuncSig{
+		"example.bitfieldForms": {Name: "example.bitfieldForms", Ret: Void},
+	})
+	for _, want := range []string{"ashr i32", "lshr i32", "shl i32", "and i32", "or i32"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM bitfield lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-bitfield.ll", "arm-bitfield.o", ll)
+}
+
+func TestTranslateARMBitfieldRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{
+		"BFX $0, $0, R1, R2",
+		"BFXU $16, $17, R1, R2",
+		"BFC $8, $0, R1, R2",
+		"BFI $8, $0, (R1), R2",
+	} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM bitfield optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_branch.go b/arm_lower_branch.go
index 4cff875b9..ae22e994f 100644
--- a/arm_lower_branch.go
+++ b/arm_lower_branch.go
@@ -12,6 +12,13 @@ func (c *armCtx) lowerBranch(bi int, op, cond string, ins Instr, emitBr armEmitB
 	switch op {
 	case "JMP":
 		op = "B"
+	case "BX":
+		if cond != "" || len(ins.Args) != 1 || ins.Args[0].Kind != OpMem ||
+			!isARMGeneralReg(ins.Args[0].Mem.Base) || ins.Args[0].Mem.Base == PC || ins.Args[0].Mem.Off != 0 ||
+			ins.Args[0].Mem.OffRaw != "" || ins.Args[0].Mem.Index != "" || ins.Args[0].Mem.Sym != "" {
+			return true, false, fmt.Errorf("arm BX expects exactly (general-register): %q", ins.Raw)
+		}
+		op = "B"
 	}
 	switch op {
 	case "BL", "CALL":
@@ -144,9 +151,25 @@ func (c *armCtx) tailCallAndRet(symOp Operand) error {
 		csig = c.sig
 		csig.Name = callee
 	}
+	if csig.ARMEntry != nil {
+		return fmt.Errorf("%w: ARM machine entry %q has no ordinary typed tail-call ABI", ErrProbeNeedsContext, callee)
+	}
 	callee = funcSigSymbol(callee, csig)
 	args := make([]string, 0, len(csig.Args))
+	useLLVMArgs := len(csig.ArgRegs) == 0 && len(csig.Args) == len(c.sig.Args) && csig.Ret == c.sig.Ret
+	if useLLVMArgs {
+		for i := range csig.Args {
+			if csig.Args[i] != c.sig.Args[i] {
+				useLLVMArgs = false
+				break
+			}
+		}
+	}
 	for i := 0; i < len(csig.Args); i++ {
+		if useLLVMArgs {
+			args = append(args, fmt.Sprintf("%s %%arg%d", csig.Args[i], i))
+			continue
+		}
 		r := Reg(fmt.Sprintf("R%d", i))
 		if i < len(csig.ArgRegs) {
 			r = csig.ArgRegs[i]
@@ -181,7 +204,13 @@ func (c *armCtx) tailCallAndRet(symOp Operand) error {
 	}
 	if c.sig.Ret != csig.Ret {
 		conv := c.newTmp()
+		calleeBits, calleeInteger := armIntegerTypeWidth(csig.Ret)
+		callerBits, callerInteger := armIntegerTypeWidth(c.sig.Ret)
 		switch {
+		case calleeInteger && callerInteger && calleeBits > callerBits:
+			fmt.Fprintf(c.b, "  %%%s = trunc %s %%%s to %s\n", conv, csig.Ret, t, c.sig.Ret)
+		case calleeInteger && callerInteger && calleeBits < callerBits:
+			fmt.Fprintf(c.b, "  %%%s = zext %s %%%s to %s\n", conv, csig.Ret, t, c.sig.Ret)
 		case csig.Ret == I32 && (c.sig.Ret == I1 || c.sig.Ret == I8 || c.sig.Ret == I16):
 			fmt.Fprintf(c.b, "  %%%s = trunc i32 %%%s to %s\n", conv, t, c.sig.Ret)
 		case (csig.Ret == I1 || csig.Ret == I8 || csig.Ret == I16) && c.sig.Ret == I32:
@@ -200,6 +229,23 @@ func (c *armCtx) tailCallAndRet(symOp Operand) error {
 	return nil
 }
 
+func armIntegerTypeWidth(typ LLVMType) (int, bool) {
+	switch typ {
+	case I1:
+		return 1, true
+	case I8:
+		return 8, true
+	case I16:
+		return 16, true
+	case I32:
+		return 32, true
+	case I64:
+		return 64, true
+	default:
+		return 0, false
+	}
+}
+
 func (c *armCtx) callSym(symOp Operand) error {
 	if symOp.Kind != OpSym {
 		return fmt.Errorf("arm call expects sym operand, got %s", symOp.String())
@@ -216,6 +262,9 @@ func (c *armCtx) callSym(symOp Operand) error {
 	if !ok {
 		csig = FuncSig{Name: callee, Ret: Void}
 	}
+	if csig.ARMEntry != nil {
+		return fmt.Errorf("%w: ARM machine entry %q requires a physical call-site bridge", ErrProbeNeedsContext, callee)
+	}
 	callee = funcSigSymbol(callee, csig)
 	args := make([]string, 0, len(csig.Args))
 	for i := 0; i < len(csig.Args); i++ {
diff --git a/arm_lower_branch_exchange_test.go b/arm_lower_branch_exchange_test.go
new file mode 100644
index 000000000..2b35fb516
--- /dev/null
+++ b/arm_lower_branch_exchange_test.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMBranchExchangeCompleteFormat(t *testing.T) {
+	const source = "TEXT branchExchange(SB),$0-0\n\tBX (R0)\n"
+	requireARMGoAssemblerResult(t, source, true)
+	ll := translateARMForTest(t, source, map[string]FuncSig{
+		"example.branchExchange": {Name: "example.branchExchange", Ret: Void},
+	})
+	if !strings.Contains(ll, `asm sideeffect "bx $0"`) {
+		t.Fatalf("ARM BX lowering omitted indirect branch exchange:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-bx.ll", "arm-bx.o", ll)
+}
+
+func TestTranslateARMBranchExchangeRejectsFormsOutsideGoOptab(t *testing.T) {
+	const source = "TEXT bad(SB),$0-0\n\tBX R0\n"
+	requireARMGoAssemblerResult(t, source, false)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		return
+	}
+	if _, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+	}); err == nil {
+		t.Fatal("Translate accepted BX R0 outside Go 1.27's ARM BX optab")
+	}
+}
diff --git a/arm_lower_coprocessor_write_test.go b/arm_lower_coprocessor_write_test.go
new file mode 100644
index 000000000..94277afb2
--- /dev/null
+++ b/arm_lower_coprocessor_write_test.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMCoprocessorWriteCompleteFormat(t *testing.T) {
+	const source = "TEXT coprocessorWrite(SB),$0-0\n\tMCR.S 4, 6, R1, C2, C3, 7\n\tRET\n"
+	requireARMGoAssemblerResult(t, source, true)
+	ll := translateARMForTest(t, source, map[string]FuncSig{
+		"example.coprocessorWrite": {Name: "example.coprocessorWrite", Ret: Void},
+	})
+	if !strings.Contains(ll, `asm sideeffect "mcr p4, #6, $0, c2, c3, #7"`) {
+		t.Fatalf("ARM MCR lowering omitted coprocessor write:\n%s", ll)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-mcr.ll", "arm-mcr.o", ll)
+}
+
+func TestTranslateARMCoprocessorWriteRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"MCR.S 4, 6, R1, C2, C3", "MCR.S 4, 6, (R1), C2, C3, 7"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM MCR optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_data.go b/arm_lower_data.go
index 7a1c58070..2e0ec86ec 100644
--- a/arm_lower_data.go
+++ b/arm_lower_data.go
@@ -6,39 +6,56 @@ import (
 )
 
 func (c *armCtx) lowerData(op, cond string, postInc bool, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerRegisterAddressMove(op, cond, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerIntegerSymbolMove(op, cond, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerIntegerMemoryMove(op, cond, ins); ok {
+		return ok, terminated, err
+	}
 	switch op {
-	case "MOVD":
+	case "MOVF", "MOVD":
+		return c.lowerARMFloatMove(op, cond, ins)
+	case "MOVW":
 		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm MOVD expects 2 operands: %q", ins.Raw)
+			return true, false, fmt.Errorf("arm MOVW expects 2 operands: %q", ins.Raw)
 		}
 		src, dst := ins.Args[0], ins.Args[1]
-		switch {
-		case src.Kind == OpReg && strings.HasPrefix(string(src.Reg), "F") && dst.Kind == OpMem:
-			v, err := c.loadFReg(src.Reg)
-			if err != nil {
+		srcF := src.Kind == OpReg && isARMFReg(src.Reg)
+		dstF := dst.Kind == OpReg && isARMFReg(dst.Reg)
+		if srcF || dstF {
+			if err := armRequireConditionOnlySuffix(ins); err != nil {
 				return true, false, err
 			}
-			return true, false, c.storeMem(dst.Mem, 64, postInc, v)
-		case src.Kind == OpMem && dst.Kind == OpReg && strings.HasPrefix(string(dst.Reg), "F"):
-			v, err := c.loadMem(src.Mem, 64, postInc, false)
-			if err != nil {
-				return true, false, err
+			srcR := src.Kind == OpReg && isARMGeneralReg(src.Reg) && !srcF
+			dstR := dst.Kind == OpReg && isARMGeneralReg(dst.Reg) && !dstF
+			if (!srcR || !dstF) && (!srcF || !dstR) {
+				return true, false, fmt.Errorf("arm MOVW R/F bit transfer expects Rsrc,Fdst or Fsrc,Rdst: %q", ins.Raw)
 			}
-			return true, false, c.storeFReg(dst.Reg, v)
-		case src.Kind == OpReg && strings.HasPrefix(string(src.Reg), "F") && dst.Kind == OpReg && strings.HasPrefix(string(dst.Reg), "F"):
-			v, err := c.loadFReg(src.Reg)
-			if err != nil {
+			if cond != "" && !strings.EqualFold(cond, "AL") {
+				err := c.emitConditionalEffect(cond, func() error {
+					_, _, innerErr := c.lowerData(op, "", postInc, ins)
+					return innerErr
+				})
 				return true, false, err
 			}
-			return true, false, c.storeFReg(dst.Reg, v)
-		default:
-			return true, false, fmt.Errorf("arm MOVD unsupported operands: %q", ins.Raw)
-		}
-	case "MOVW":
-		if len(ins.Args) != 2 {
-			return true, false, fmt.Errorf("arm MOVW expects 2 operands: %q", ins.Raw)
+			if srcR {
+				value, loadErr := c.loadReg(src.Reg)
+				if loadErr != nil {
+					return true, false, loadErr
+				}
+				return true, false, c.storeARMFloatBits(dst.Reg, "", 32, value)
+			}
+			value, loadErr := c.loadFReg(src.Reg)
+			if loadErr != nil {
+				return true, false, loadErr
+			}
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, value)
+			return true, false, c.storeReg(dst.Reg, "%"+narrow)
 		}
-		src, dst := ins.Args[0], ins.Args[1]
 		if cond != "" && (dst.Kind == OpMem || dst.Kind == OpFP || dst.Kind == OpSym || dst.Kind == OpIdent) {
 			err := c.emitConditionalEffect(cond, func() error {
 				_, _, err := c.lowerData(op, "", postInc, ins)
@@ -46,17 +63,24 @@ func (c *armCtx) lowerData(op, cond string, postInc bool, ins Instr) (ok bool, t
 			})
 			return true, false, err
 		}
-		v := ""
+		v, shifterCarry := "", ""
 		if src.Kind == OpMem {
 			v, err = c.loadMem(src.Mem, 32, postInc, false)
 		} else {
-			v, err = c.eval32(src, false)
+			v, shifterCarry, err = c.evalARMLogicalOperand("MOVW", src)
 		}
 		if err != nil {
 			return true, false, err
 		}
-		return true, false, c.storeARMValue(dst, v, 32, cond, postInc, ins.Raw)
-	case "MOVB", "MOVBU", "MOVH", "MOVHU":
+		if err := c.storeARMValue(dst, v, 32, cond, postInc, ins.Raw); err != nil {
+			return true, false, err
+		}
+		_, _, _, setFlags := armDecodeOp(string(ins.Op))
+		if setFlags && (src.Kind == OpReg || src.Kind == OpRegShift) && dst.Kind == OpReg {
+			return true, false, c.setARMLogicalFlags(cond, v, shifterCarry)
+		}
+		return true, false, nil
+	case "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU":
 		if len(ins.Args) != 2 {
 			return true, false, fmt.Errorf("arm %s expects 2 operands: %q", op, ins.Raw)
 		}
@@ -70,13 +94,39 @@ func (c *armCtx) lowerData(op, cond string, postInc bool, ins Instr) (ok bool, t
 		}
 		v := ""
 		bits := 8
-		if op == "MOVH" || op == "MOVHU" {
+		if op == "MOVH" || op == "MOVHS" || op == "MOVHU" {
 			bits = 16
 		}
 		if src.Kind == OpMem {
-			v, err = c.loadMem(src.Mem, bits, postInc, op == "MOVB" || op == "MOVH")
+			v, err = c.loadMem(src.Mem, bits, postInc, op == "MOVB" || op == "MOVBS" || op == "MOVH" || op == "MOVHS")
+		} else if src.Kind == OpRegShift {
+			// Go asm5 type 23 is SXTB/SXTH/UXTB/UXTH with an optional
+			// rotation, not the data-processing ROR #0 (RRX) shifter.
+			if src.ShiftOp != ShiftRotate || src.ShiftReg != "" || src.ShiftAmount < 0 || src.ShiftAmount > 24 || src.ShiftAmount%8 != 0 {
+				return true, false, fmt.Errorf("arm %s extension rotation must be 0/8/16/24: %q", op, ins.Raw)
+			}
+			base, loadErr := c.loadReg(src.Reg)
+			if loadErr != nil {
+				return true, false, loadErr
+			}
+			v = c.emitARMRotate(base, fmt.Sprint(src.ShiftAmount))
+			narrow, extended := c.newTmp(), c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i%d\n", narrow, v, bits)
+			extension := "zext"
+			if op == "MOVB" || op == "MOVBS" || op == "MOVH" || op == "MOVHS" {
+				extension = "sext"
+			}
+			fmt.Fprintf(c.b, "  %%%s = %s i%d %%%s to i32\n", extended, extension, bits, narrow)
+			v = "%" + extended
 		} else {
 			v, err = c.eval32(src, false)
+			if err == nil && (op == "MOVBS" || op == "MOVHS") {
+				narrow := c.newTmp()
+				extended := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i%d\n", narrow, v, bits)
+				fmt.Fprintf(c.b, "  %%%s = sext i%d %%%s to i32\n", extended, bits, narrow)
+				v = "%" + extended
+			}
 		}
 		if err != nil {
 			return true, false, err
@@ -165,9 +215,7 @@ func (c *armCtx) storeARMValue(dst Operand, v string, bits int, cond string, pos
 	case OpIdent:
 		switch strings.ToUpper(dst.Ident) {
 		case "CPSR":
-			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n", "msr cpsr_fsxc, $0", "r,~{cc},~{memory}", v)
-			c.storeFlagsFromStatus(v)
-			return nil
+			return fmt.Errorf("ARM CPSR write must pass the typed Go/raw status transfer grammar: %q", raw)
 		case "FPCR", "FPSR":
 			fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n", "vmsr fpscr, $0", "r,~{memory}", v)
 			return nil
diff --git a/arm_lower_extend_add.go b/arm_lower_extend_add.go
new file mode 100644
index 000000000..6b5a77aae
--- /dev/null
+++ b/arm_lower_extend_add.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import "fmt"
+
+func (c *armCtx) lowerARMExtendAdd(op, cond string, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fmt.Errorf("arm %s expects rotated source, dst or rotated source, accumulator, dst: %q", op, ins.Raw)
+	}
+	sourceOperand := ins.Args[0]
+	if sourceOperand.Kind != OpRegShift || sourceOperand.ShiftOp != ShiftRotate || sourceOperand.ShiftReg != "" ||
+		!isARMGeneralReg(sourceOperand.Reg) ||
+		(sourceOperand.ShiftAmount != 0 && sourceOperand.ShiftAmount != 8 && sourceOperand.ShiftAmount != 16 && sourceOperand.ShiftAmount != 24) {
+		return fmt.Errorf("arm %s source must be a general register rotated right by 0, 8, 16, or 24: %q", op, ins.Raw)
+	}
+	accumulatorOperand := ins.Args[len(ins.Args)-1]
+	if len(ins.Args) == 3 {
+		accumulatorOperand = ins.Args[1]
+	}
+	destination := ins.Args[len(ins.Args)-1]
+	if accumulatorOperand.Kind != OpReg || !isARMGeneralReg(accumulatorOperand.Reg) ||
+		destination.Kind != OpReg || !isARMGeneralReg(destination.Reg) {
+		return fmt.Errorf("arm %s accumulator and destination must be general registers: %q", op, ins.Raw)
+	}
+	rotated, err := c.evalShift(sourceOperand)
+	if err != nil {
+		return err
+	}
+	bits := 8
+	if op == "XTAH" || op == "XTAHU" {
+		bits = 16
+	}
+	narrowed := c.newTmp()
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i%d\n", narrowed, rotated, bits)
+	if op == "XTAB" || op == "XTAH" {
+		fmt.Fprintf(c.b, "  %%%s = sext i%d %%%s to i32\n", extended, bits, narrowed)
+	} else {
+		fmt.Fprintf(c.b, "  %%%s = zext i%d %%%s to i32\n", extended, bits, narrowed)
+	}
+	accumulator, err := c.loadReg(accumulatorOperand.Reg)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %s, %%%s\n", result, accumulator, extended)
+	return c.selectRegWrite(destination.Reg, cond, "%"+result)
+}
diff --git a/arm_lower_extend_add_test.go b/arm_lower_extend_add_test.go
new file mode 100644
index 000000000..d3d23cb86
--- /dev/null
+++ b/arm_lower_extend_add_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armExtendAddForms = `TEXT extendAddForms(SB),$0-0
+	XTAB R2@>0, R8
+	XTAB R2@>8, R8
+	XTAB R2@>16, R8
+	XTAB R2@>24, R8
+	XTAB R2@>0, R4, R8
+	XTAB R2@>8, R4, R8
+	XTAB R2@>16, R4, R8
+	XTAB R2@>24, R4, R8
+	XTAH R3@>0, R9
+	XTAH R3@>8, R9
+	XTAH R3@>16, R9
+	XTAH R3@>24, R9
+	XTAH R3@>0, R4, R9
+	XTAH R3@>8, R4, R9
+	XTAH R3@>16, R4, R9
+	XTAH R3@>24, R4, R9
+	XTABU R4@>0, R7
+	XTABU R4@>8, R7
+	XTABU R4@>16, R7
+	XTABU R4@>24, R7
+	XTABU R4@>0, R0, R7
+	XTABU R4@>8, R0, R7
+	XTABU R4@>16, R0, R7
+	XTABU R4@>24, R0, R7
+	XTAHU R5@>0, R1
+	XTAHU R5@>8, R1
+	XTAHU R5@>16, R1
+	XTAHU R5@>24, R1
+	XTAHU R5@>0, R9, R1
+	XTAHU R5@>8, R9, R1
+	XTAHU R5@>16, R9, R1
+	XTAHU R5@>24, R9, R1
+	RET
+`
+
+func TestTranslateARMExtendAddCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armExtendAddForms, true)
+	ll := translateARMForTest(t, armExtendAddForms, map[string]FuncSig{
+		"example.extendAddForms": {Name: "example.extendAddForms", Ret: Void},
+	})
+	for _, want := range []string{
+		"call i32 @llvm.fshr.i32", "trunc i32", "sext i8", "sext i16", "zext i8", "zext i16", "add i32",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM extend-and-add lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-extend-add.ll", "arm-extend-add.o", ll)
+}
+
+func TestTranslateARMExtendAddRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"XTAB R0<<8, R1", "XTAHU R0@>4, R1", "XTABU R0@>8, (R1)"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM extend-and-add optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_float.go b/arm_lower_float.go
new file mode 100644
index 000000000..b5056d093
--- /dev/null
+++ b/arm_lower_float.go
@@ -0,0 +1,584 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+)
+
+func isARMFReg(r Reg) bool {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "F") {
+		return false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "F"))
+	return err == nil && n >= 0 && n <= 15
+}
+
+func armSingleRegisterNumber(r Reg) (int, bool) {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if !strings.HasPrefix(s, "S") {
+		return 0, false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "S"))
+	return n, err == nil && n >= 0 && n <= 31
+}
+
+func armSingleOperandNumber(op Operand) (int, bool) {
+	switch op.Kind {
+	case OpReg:
+		return armSingleRegisterNumber(op.Reg)
+	case OpIdent:
+		return armSingleRegisterNumber(Reg(op.Ident))
+	default:
+		return 0, false
+	}
+}
+
+func isARMGeneralReg(r Reg) bool {
+	s := strings.ToUpper(strings.TrimSpace(string(r)))
+	if s == "SP" || s == "PC" {
+		return true
+	}
+	if !strings.HasPrefix(s, "R") {
+		return false
+	}
+	n, err := strconv.Atoi(strings.TrimPrefix(s, "R"))
+	return err == nil && n >= 0 && n <= 15
+}
+
+func armInstructionSuffixes(ins Instr) []string {
+	parts := strings.Split(strings.ToUpper(strings.TrimSpace(string(ins.Op))), ".")
+	if len(parts) < 2 {
+		return nil
+	}
+	return parts[1:]
+}
+
+func armRequireConditionOnlySuffix(ins Instr) error {
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix != "" && !armCondCodes[suffix] {
+			return fmt.Errorf("arm %s suffix %q is absent from the Go 1.27 optab: %q", ins.Op, suffix, ins.Raw)
+		}
+	}
+	return nil
+}
+
+func armMemoryModifiers(ins Instr) (postIndex, writeback, up bool, err error) {
+	for _, suffix := range armInstructionSuffixes(ins) {
+		switch suffix {
+		case "", "AL":
+		case "P":
+			postIndex = true
+		case "W":
+			writeback = true
+		case "U":
+			up = true
+		case "PW", "WP":
+			postIndex = true
+			writeback = true
+		default:
+			if !armCondCodes[suffix] {
+				return false, false, false, fmt.Errorf("arm %s suffix %q is absent from the Go memory optab: %q", ins.Op, suffix, ins.Raw)
+			}
+		}
+	}
+	return postIndex, writeback, up, nil
+}
+
+func armRawOperands(ins Instr) []string {
+	raw := strings.TrimSpace(ins.Raw)
+	separator := strings.IndexAny(raw, " \t")
+	if separator < 0 {
+		return nil
+	}
+	return splitTopLevelCSV(strings.TrimSpace(raw[separator+1:]))
+}
+
+func armFloatImmediateBits(ins Instr, bits int) (string, error) {
+	operands := armRawOperands(ins)
+	if len(operands) == 0 {
+		return "", fmt.Errorf("arm floating move cannot recover its source spelling: %q", ins.Raw)
+	}
+	source := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(operands[0]), "$"))
+	// The Go ARM parser classifies integer constants as C_*CON, none of which
+	// occur in MOVF/MOVD's rows. Require a floating token rather than silently
+	// accepting forms such as MOVD $1, F0.
+	if !strings.ContainsAny(source, ".eEpP") {
+		return "", fmt.Errorf("arm MOVF/MOVD immediate must be a Go floating constant: %q", ins.Raw)
+	}
+	if ins.Args[0].ImmRaw != "" {
+		return "", fmt.Errorf("arm unresolved floating immediate %q", ins.Args[0].ImmRaw)
+	}
+	value := math.Float64frombits(uint64(ins.Args[0].Imm))
+	if bits == 32 {
+		return strconv.FormatUint(uint64(math.Float32bits(float32(value))), 10), nil
+	}
+	return strconv.FormatUint(math.Float64bits(value), 10), nil
+}
+
+func (c *armCtx) selectFRegWrite(dst Reg, cond, value string) error {
+	if cond == "" || strings.EqualFold(cond, "AL") {
+		return c.storeFReg(dst, value)
+	}
+	condition, err := c.condValue(cond)
+	if err != nil {
+		return err
+	}
+	old, err := c.loadFReg(dst)
+	if err != nil {
+		return err
+	}
+	selected := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", selected, condition, value, old)
+	return c.storeFReg(dst, "%"+selected)
+}
+
+func (c *armCtx) storeARMFloatBits(reg Reg, condition string, bits int, value string) error {
+	if bits == 64 {
+		return c.selectFRegWrite(reg, condition, value)
+	}
+	if bits != 32 || !isARMFReg(reg) {
+		return fmt.Errorf("arm floating write requires a named F register and 32/64-bit width: %s/%d", reg, bits)
+	}
+	// Go Fn names Dn for double operations and S(2*n) for single operations.
+	// A single write preserves S(2*n+1); share the raw decoder's physical
+	// half-register writer instead of zero-extending over the whole D register.
+	number, _ := strconv.Atoi(strings.TrimPrefix(strings.ToUpper(strings.TrimSpace(string(reg))), "F"))
+	return c.storeARMRawSingleBits(2*number, value, condition)
+}
+
+func (c *armCtx) loadARMFloatMemoryBits(op Operand, bits int, postIndex, writeback bool) (string, error) {
+	switch op.Kind {
+	case OpFP:
+		return c.loadARMFrameBits(op.FPOffset, bits)
+	case OpSym:
+		ptr, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return "", err
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %s, align 1\n", value, bits, ptr)
+		return "%" + value, nil
+	case OpMem:
+		value, err := c.loadMem(op.Mem, bits, postIndex, false)
+		if err != nil {
+			return "", err
+		}
+		if writeback && !postIndex {
+			if err := c.updatePostInc(op.Mem.Base, op.Mem.Off); err != nil {
+				return "", err
+			}
+		}
+		return value, nil
+	default:
+		return "", fmt.Errorf("arm floating load has unsupported operand %s", op.String())
+	}
+}
+
+func (c *armCtx) storeARMFloatMemoryBits(op Operand, bits int, postIndex, writeback bool, value string) error {
+	switch op.Kind {
+	case OpFP:
+		return c.storeARMFrameBits(op.FPOffset, bits, value)
+	case OpSym:
+		ptr, err := c.ptrFromSB(op.Sym)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i%d %s, ptr %s, align 1\n", bits, value, ptr)
+		return nil
+	case OpMem:
+		if err := c.storeMem(op.Mem, bits, postIndex, value); err != nil {
+			return err
+		}
+		if writeback && !postIndex {
+			return c.updatePostInc(op.Mem.Base, op.Mem.Off)
+		}
+		return nil
+	default:
+		return fmt.Errorf("arm floating store has unsupported operand %s", op.String())
+	}
+}
+
+func isARMFloatMemory(op Operand) bool {
+	return op.Kind == OpFP || op.Kind == OpMem || (op.Kind == OpSym && !strings.HasPrefix(strings.TrimSpace(op.Sym), "$"))
+}
+
+func (c *armCtx) lowerARMFloatMove(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	bits := 32
+	if op == "MOVD" {
+		bits = 64
+	}
+	if len(ins.Args) != 2 {
+		return true, false, fmt.Errorf("arm %s expects exactly 2 operands: %q", op, ins.Raw)
+	}
+	postIndex, writeback, up, err := armMemoryModifiers(ins)
+	if err != nil {
+		return true, false, err
+	}
+	src, dst := ins.Args[0], ins.Args[1]
+	srcF := src.Kind == OpReg && isARMFReg(src.Reg)
+	dstF := dst.Kind == OpReg && isARMFReg(dst.Reg)
+	srcMemory := isARMFloatMemory(src)
+	dstMemory := isARMFloatMemory(dst)
+	valid := (srcF && (dstF || dstMemory)) || (srcMemory && dstF) || (src.Kind == OpImm && dstF)
+	if !valid {
+		return true, false, fmt.Errorf("arm %s operands are absent from the Go 1.27 optab: %q", op, ins.Raw)
+	}
+	if (postIndex || writeback || up) && !srcMemory && !dstMemory {
+		return true, false, fmt.Errorf("arm %s addressing suffix requires a memory operand: %q", op, ins.Raw)
+	}
+	memory := src
+	if dstMemory {
+		memory = dst
+	}
+	if up && memory.Kind == OpMem && memory.Mem.Off < 0 {
+		return true, false, fmt.Errorf("arm %s .U cannot be used with a negative offset: %q", op, ins.Raw)
+	}
+	if memory.Kind == OpSym && sourceSymbolOffsetNeedsContext(memory.Sym) {
+		return true, false, fmt.Errorf("%w: arm %s symbol displacement requires generated assembler constants: %q", ErrProbeNeedsContext, op, ins.Raw)
+	}
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		err := c.emitConditionalEffect(cond, func() error {
+			_, _, innerErr := c.lowerARMFloatMove(op, "", ins)
+			return innerErr
+		})
+		return true, false, err
+	}
+
+	var value string
+	switch {
+	case src.Kind == OpImm:
+		value, err = armFloatImmediateBits(ins, bits)
+	case srcF:
+		value, err = c.loadFReg(src.Reg)
+		if err == nil && bits == 32 {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, value)
+			value = "%" + narrow
+		}
+	case srcMemory:
+		value, err = c.loadARMFloatMemoryBits(src, bits, postIndex, writeback)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	if dstF {
+		return true, false, c.storeARMFloatBits(dst.Reg, "", bits, value)
+	}
+	return true, false, c.storeARMFloatMemoryBits(dst, bits, postIndex, writeback, value)
+}
+
+func (c *armCtx) loadARMFloatRegValue(reg Reg, bits int) (string, error) {
+	value, err := c.loadFReg(reg)
+	if err != nil {
+		return "", err
+	}
+	integerType := "i64"
+	floatType := "double"
+	if bits == 32 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, value)
+		value = "%" + narrow
+		integerType = "i32"
+		floatType = "float"
+	}
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", converted, integerType, value, floatType)
+	return "%" + converted, nil
+}
+
+func (c *armCtx) storeARMFloatRegValue(reg Reg, cond string, bits int, value string) error {
+	floatType := "double"
+	integerType := "i64"
+	if bits == 32 {
+		floatType = "float"
+		integerType = "i32"
+	}
+	encoded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast %s %s to %s\n", encoded, floatType, value, integerType)
+	return c.storeARMFloatBits(reg, cond, bits, "%"+encoded)
+}
+
+func (c *armCtx) lowerARMFloatCompare(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	form, matched, err := parseARMScalarCompare(op, ins)
+	if !matched || err != nil {
+		return matched, false, err
+	}
+	form.condition = cond
+	return true, false, c.lowerARMScalarCompare(form)
+}
+
+func armWordFloatConversionUnsigned(ins Instr) (bool, error) {
+	unsigned := false
+	for _, suffix := range armInstructionSuffixes(ins) {
+		switch {
+		case suffix == "", suffix == "AL", armCondCodes[suffix]:
+		case suffix == "U":
+			unsigned = true
+		default:
+			return false, fmt.Errorf("arm %s suffix %q is absent from the Go 1.27 conversion optab: %q", ins.Op, suffix, ins.Raw)
+		}
+	}
+	return unsigned, nil
+}
+
+func (c *armCtx) lowerARMWordFloatConversion(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	form, handled, err := parseARMWordFloatConversion(op, ins)
+	if !handled || err != nil {
+		return handled, false, err
+	}
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		err := c.emitConditionalEffect(cond, func() error {
+			_, _, innerErr := c.lowerARMWordFloatConversion(op, "", ins)
+			return innerErr
+		})
+		return true, false, err
+	}
+
+	if form.wordToFloat {
+		var integer string
+		switch form.source.kind {
+		case armConversionCore:
+			integer, err = c.loadReg(form.source.reg)
+		case armConversionSingle:
+			integer, err = c.loadARMRawSingleBits(form.source.single)
+		default:
+			var wide string
+			wide, err = c.loadFReg(form.source.reg)
+			if err == nil {
+				narrow := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, wide)
+				integer = "%" + narrow
+			}
+		}
+		if err != nil {
+			return true, false, err
+		}
+		if form.usesScratch() {
+			if err := c.storeARMFloatBits("F15", "", 32, integer); err != nil {
+				return true, false, err
+			}
+		}
+		converted := c.emitARMWordFloatNativeConversion(form, integer)
+		if form.destination.kind == armConversionSingle {
+			bits := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits, converted)
+			return true, false, c.storeARMRawSingleBits(form.destination.single, "%"+bits, "")
+		}
+		return true, false, c.storeARMFloatRegValue(form.destination.reg, "", form.floatBits, converted)
+	}
+
+	var floating string
+	if form.source.kind == armConversionSingle {
+		floating, err = c.loadARMRawVFPRegValue(form.source.single, 32)
+	} else {
+		floating, err = c.loadARMFloatRegValue(form.source.reg, form.floatBits)
+	}
+	if err != nil {
+		return true, false, err
+	}
+	integer := c.emitARMWordFloatNativeConversion(form, floating)
+	if form.usesScratch() {
+		if err := c.storeARMFloatBits("F15", "", 32, integer); err != nil {
+			return true, false, err
+		}
+	}
+	switch form.destination.kind {
+	case armConversionCore:
+		return true, false, c.storeReg(form.destination.reg, integer)
+	case armConversionSingle:
+		return true, false, c.storeARMRawSingleBits(form.destination.single, integer, "")
+	default:
+		return true, false, c.storeARMFloatBits(form.destination.reg, "", 32, integer)
+	}
+}
+
+func armScalarFloatArithmeticKind(op string) (kind string, bits int, accumulating bool, ok bool) {
+	bits = 32
+	if strings.HasSuffix(op, "D") {
+		bits = 64
+	}
+	switch op {
+	case "ADDF", "ADDD":
+		return "add", bits, false, true
+	case "SUBF", "SUBD":
+		return "sub", bits, false, true
+	case "MULF", "MULD":
+		return "mul", bits, false, true
+	case "NMULF", "NMULD":
+		return "nmul", bits, false, true
+	case "DIVF", "DIVD":
+		return "div", bits, false, true
+	case "MULAF", "MULAD", "FMULAF", "FMULAD":
+		return "madd", bits, true, true
+	case "MULSF", "MULSD", "FMULSF", "FMULSD":
+		return "msub", bits, true, true
+	case "NMULAF", "NMULAD", "FNMULAF", "FNMULAD":
+		return "nmadd", bits, true, true
+	case "NMULSF", "NMULSD", "FNMULSF", "FNMULSD":
+		return "nmsub", bits, true, true
+	default:
+		return "", 0, false, false
+	}
+}
+
+func (c *armCtx) lowerARMScalarFloatArithmetic(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	kind, bits, accumulating, handled := armScalarFloatArithmeticKind(op)
+	if !handled {
+		return false, false, nil
+	}
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return true, false, err
+	}
+	wantMin := 2
+	if accumulating {
+		wantMin = 3
+	}
+	if len(ins.Args) < wantMin || len(ins.Args) > 3 {
+		if accumulating {
+			return true, false, fmt.Errorf("arm %s expects Fsrc1, Fsrc2, Faccumulator: %q", op, ins.Raw)
+		}
+		return true, false, fmt.Errorf("arm %s expects Fsrc,Fdst or Fsrc1,Fsrc2,Fdst: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg || !isARMFReg(arg.Reg) {
+			return true, false, fmt.Errorf("arm %s accepts only floating registers: %q", op, ins.Raw)
+		}
+	}
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		err := c.emitConditionalEffect(cond, func() error {
+			_, _, innerErr := c.lowerARMScalarFloatArithmetic(op, "", ins)
+			return innerErr
+		})
+		return true, false, err
+	}
+
+	// obj/arm encodes p.From as Vm and p.Reg (or p.To for two-operand
+	// instructions) as Vn. Plan 9 order is therefore Vm,Vn,Vd and subtraction
+	// and division must compute Vn op Vm.
+	rhs, err := c.loadARMFloatRegValue(ins.Args[0].Reg, bits)
+	if err != nil {
+		return true, false, err
+	}
+	lhsIndex := 1
+	dstIndex := len(ins.Args) - 1
+	lhs, err := c.loadARMFloatRegValue(ins.Args[lhsIndex].Reg, bits)
+	if err != nil {
+		return true, false, err
+	}
+	floatType := "float"
+	if bits == 64 {
+		floatType = "double"
+	}
+	emitBinary := func(operation, left, right string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", name, operation, floatType, left, right)
+		return "%" + name
+	}
+	emitNeg := func(value string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", name, floatType, value)
+		return "%" + name
+	}
+
+	var result string
+	switch kind {
+	case "add":
+		result = emitBinary("fadd", lhs, rhs)
+	case "sub":
+		result = emitBinary("fsub", lhs, rhs)
+	case "mul":
+		result = emitBinary("fmul", lhs, rhs)
+	case "nmul":
+		result = emitNeg(emitBinary("fmul", lhs, rhs))
+	case "div":
+		result = emitBinary("fdiv", lhs, rhs)
+	default:
+		product := emitBinary("fmul", lhs, rhs)
+		accumulator, loadErr := c.loadARMFloatRegValue(ins.Args[dstIndex].Reg, bits)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		switch kind {
+		case "madd":
+			result = emitBinary("fadd", accumulator, product)
+		case "msub":
+			result = emitBinary("fsub", accumulator, product)
+		case "nmadd":
+			result = emitNeg(emitBinary("fadd", accumulator, product))
+		case "nmsub":
+			result = emitBinary("fsub", product, accumulator)
+		}
+	}
+	return true, false, c.storeARMFloatRegValue(ins.Args[dstIndex].Reg, "", bits, result)
+}
+
+func (c *armCtx) lowerFloat(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	if ok, terminated, err := c.lowerARMFloatCompare(op, cond, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARMWordFloatConversion(op, cond, ins); ok {
+		return ok, terminated, err
+	}
+	if ok, terminated, err := c.lowerARMScalarFloatArithmetic(op, cond, ins); ok {
+		return ok, terminated, err
+	}
+	switch op {
+	case "NEGF", "NEGD", "ABSF", "ABSD", "SQRTF", "SQRTD", "MOVFD", "MOVDF":
+	default:
+		return false, false, nil
+	}
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return true, false, err
+	}
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg || !isARMFReg(ins.Args[0].Reg) || ins.Args[1].Kind != OpReg || !isARMFReg(ins.Args[1].Reg) {
+		return true, false, fmt.Errorf("arm %s expects Fsrc, Fdst: %q", op, ins.Raw)
+	}
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		err := c.emitConditionalEffect(cond, func() error {
+			_, _, innerErr := c.lowerFloat(op, "", ins)
+			return innerErr
+		})
+		return true, false, err
+	}
+
+	sourceBits, destinationBits := 32, 32
+	if strings.HasSuffix(op, "D") {
+		sourceBits, destinationBits = 64, 64
+	}
+	if op == "MOVFD" {
+		sourceBits, destinationBits = 32, 64
+	} else if op == "MOVDF" {
+		sourceBits, destinationBits = 64, 32
+	}
+	source, err := c.loadARMFloatRegValue(ins.Args[0].Reg, sourceBits)
+	if err != nil {
+		return true, false, err
+	}
+	result := source
+	resultName := c.newTmp()
+	floatType := "float"
+	if sourceBits == 64 {
+		floatType = "double"
+	}
+	switch {
+	case strings.HasPrefix(op, "NEG"):
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", resultName, floatType, source)
+		result = "%" + resultName
+	case strings.HasPrefix(op, "ABS"):
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.fabs.f%d(%s %s)\n", resultName, floatType, sourceBits, floatType, source)
+		result = "%" + resultName
+	case strings.HasPrefix(op, "SQRT"):
+		fmt.Fprintf(c.b, "  %%%s = call %s @llvm.sqrt.f%d(%s %s)\n", resultName, floatType, sourceBits, floatType, source)
+		result = "%" + resultName
+	case op == "MOVFD":
+		fmt.Fprintf(c.b, "  %%%s = fpext float %s to double\n", resultName, source)
+		result = "%" + resultName
+	case op == "MOVDF":
+		fmt.Fprintf(c.b, "  %%%s = fptrunc double %s to float\n", resultName, source)
+		result = "%" + resultName
+	}
+	return true, false, c.storeARMFloatRegValue(ins.Args[1].Reg, "", destinationBits, result)
+}
diff --git a/arm_lower_hardware_divide_test.go b/arm_lower_hardware_divide_test.go
new file mode 100644
index 000000000..7be7753c0
--- /dev/null
+++ b/arm_lower_hardware_divide_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armHardwareDivideForms = `TEXT hardwareDivide(SB),$0-0
+	DIVHW R0, R1, R2
+	DIVUHW R0, R1, R2
+	DIVHW R0, R1
+	DIVUHW R0, R1
+	RET
+`
+
+func TestTranslateARMHardwareDivideCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armHardwareDivideForms, true)
+	ll := translateARMForTest(t, armHardwareDivideForms, map[string]FuncSig{
+		"example.hardwareDivide": {Name: "example.hardwareDivide", Ret: Void},
+	})
+	for _, want := range []string{"sdiv i32", "udiv i32", "icmp eq i32", "select i1"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM hardware divide lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-hardware-divide.ll", "arm-hardware-divide.o", ll)
+}
+
+func TestTranslateARMHardwareDivideRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"DIVHW R0", "DIVUHW (R0), R1"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM hardware-divide optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_memory.go b/arm_lower_memory.go
new file mode 100644
index 000000000..1f5231754
--- /dev/null
+++ b/arm_lower_memory.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+)
+
+// Go's integer load/store family shares one address grammar. Signed byte and
+// halfword loads, and halfword stores, have only an unshifted register offset;
+// word and the other byte forms also admit all four immediate shift kinds.
+type armIntegerMemorySpec struct {
+	bits   int
+	signed bool
+}
+
+var armIntegerMemorySpecs = map[string]armIntegerMemorySpec{
+	"MOVW": {bits: 32}, "MOVB": {bits: 8, signed: true},
+	"MOVBS": {bits: 8, signed: true}, "MOVBU": {bits: 8},
+	"MOVH": {bits: 16, signed: true}, "MOVHS": {bits: 16, signed: true}, "MOVHU": {bits: 16},
+}
+
+type armIntegerMemoryForm struct {
+	spec      armIntegerMemorySpec
+	base, reg Reg
+	offset    Operand
+	displace  int64
+	load      bool
+	postIndex bool
+	writeback bool
+	subtract  bool
+}
+
+type armIntegerSymbolForm struct {
+	spec    armIntegerMemorySpec
+	symbol  string
+	reg     Reg
+	load    bool
+	address bool
+}
+
+func parseARMIntegerSymbolForm(op string, ins Instr) (armIntegerSymbolForm, error) {
+	f := armIntegerSymbolForm{spec: armIntegerMemorySpecs[op]}
+	if len(ins.Args) != 2 {
+		return f, fmt.Errorf("arm %s symbol form expects two operands: %q", op, ins.Raw)
+	}
+	symbol, register := ins.Args[1], ins.Args[0]
+	if ins.Args[0].Kind == OpSym {
+		symbol, register, f.load = ins.Args[0], ins.Args[1], true
+	}
+	if symbol.Kind != OpSym || register.Kind != OpReg || !isARMGeneralReg(register.Reg) {
+		return f, fmt.Errorf("arm %s symbol form requires a symbol and a general register: %q", op, ins.Raw)
+	}
+	f.symbol, f.reg = strings.TrimSpace(symbol.Sym), register.Reg
+	f.address = strings.HasPrefix(f.symbol, "$")
+	if f.address {
+		if op != "MOVW" || !f.load {
+			return f, fmt.Errorf("arm symbol address constants require MOVW $symbol(SB),register: %q", ins.Raw)
+		}
+		if err := armRequireConditionOnlySuffix(ins); err != nil {
+			return f, err
+		}
+	} else if _, _, _, err := armMemoryModifiers(ins); err != nil {
+		return f, err
+	}
+	_, _, concrete := parseSBRef(f.symbol)
+	unresolved := !concrete && sourceSymbolOffsetNeedsContext(f.symbol)
+	if !strings.HasSuffix(f.symbol, "(SB)") || !concrete && !unresolved {
+		return f, fmt.Errorf("arm %s requires a valid symbol(SB) reference: %q", op, ins.Raw)
+	}
+	switch strings.ToUpper(strings.TrimSpace(string(f.reg))) {
+	case "PC", "SP":
+		// Go rejects pseudo-register PC/SP in these forms. Hardware registers
+		// are spelled R15/R13; PC must not inherit an ordinary register's semantics.
+		return f, fmt.Errorf("arm %s symbol form cannot use pseudo-register %s: %q", op, f.reg, ins.Raw)
+	case "R15":
+		if f.load {
+			return f, fmt.Errorf("%w: arm %s symbol destination R15 requires explicit control-flow context: %q", ErrProbeNeedsContext, op, ins.Raw)
+		}
+		// Go first expands a symbolic address into a literal load through
+		// R11. Reading PC in the following store therefore depends on the
+		// source instruction layout, not on an initialized virtual register.
+		return f, fmt.Errorf("%w: arm %s symbol source R15 requires source instruction layout context: %q", ErrProbeNeedsContext, op, ins.Raw)
+	}
+	if unresolved {
+		return f, fmt.Errorf("%w: arm %s symbol displacement requires generated assembler constants: %q", ErrProbeNeedsContext, op, ins.Raw)
+	}
+	return f, nil
+}
+
+func (c *armCtx) lowerIntegerSymbolMove(op, cond string, ins Instr) (bool, bool, error) {
+	if _, ok := armIntegerMemorySpecs[op]; !ok {
+		return false, false, nil
+	}
+	hasSymbol := false
+	for _, operand := range ins.Args {
+		hasSymbol = hasSymbol || operand.Kind == OpSym && strings.HasSuffix(strings.TrimSpace(operand.Sym), "(SB)")
+	}
+	if !hasSymbol {
+		return false, false, nil
+	}
+	f, err := parseARMIntegerSymbolForm(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	err = c.emitConditionalEffect(cond, func() error {
+		ptr, err := c.ptrFromSB(f.symbol)
+		if err != nil {
+			return err
+		}
+		address := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ptrtoint ptr %s to i32\n", address, ptr)
+		if f.address {
+			return c.storeReg(f.reg, "%"+address)
+		}
+		// Go's C_ADDR rows materialize the address in REGTMP (R11) before
+		// the actual load/store. P/W/U operate on a zero displacement from
+		// that scratch address, not on the symbol's relocation addend.
+		if err := c.storeReg("R11", "%"+address); err != nil {
+			return err
+		}
+		if f.load {
+			value, err := c.loadMemoryPointer(ptr, f.spec.bits, f.spec.signed)
+			if err != nil {
+				return err
+			}
+			return c.storeReg(f.reg, value)
+		}
+		value, err := c.loadReg(f.reg)
+		if err != nil {
+			return err
+		}
+		return c.storeMemoryPointer(ptr, f.spec.bits, value)
+	})
+	return true, false, err
+}
+
+func armMemoryShift(mem MemRef) (Operand, bool) {
+	reg, shift, amount, countReg, ok := parseRegShift(mem.OffRaw)
+	return Operand{Kind: OpRegShift, Reg: reg, ShiftOp: shift, ShiftAmount: amount, ShiftReg: countReg}, ok
+}
+
+// Go's C_AUTO address names annotate SP slots; they are not unresolved
+// displacement expressions. Keep the already parsed numeric offset intact.
+func armNamedStackOffset(mem MemRef) bool {
+	if mem.Base != SP || mem.Index != "" || mem.OffRaw == "" {
+		return false
+	}
+	name, offset := splitSymPlusOff(mem.OffRaw)
+	if name == "" || offset != mem.Off {
+		return false
+	}
+	for i, ch := range name {
+		if ch != '_' && ch != '·' && !unicode.IsLetter(ch) && (i == 0 || !unicode.IsDigit(ch)) {
+			return false
+		}
+	}
+	return true
+}
+
+func parseARMIntegerMemoryForm(op string, ins Instr) (armIntegerMemoryForm, error) {
+	f := armIntegerMemoryForm{spec: armIntegerMemorySpecs[op]}
+	if len(ins.Args) != 2 {
+		return f, fmt.Errorf("arm %s memory form expects two operands: %q", op, ins.Raw)
+	}
+	memory, register := ins.Args[1], ins.Args[0]
+	if ins.Args[0].Kind == OpMem {
+		memory, register, f.load = ins.Args[0], ins.Args[1], true
+	}
+	if memory.Kind != OpMem || register.Kind != OpReg || !isARMGeneralReg(register.Reg) || !isARMGeneralReg(memory.Mem.Base) {
+		return f, fmt.Errorf("arm %s memory form requires an address and a general register: %q", op, ins.Raw)
+	}
+	f.base, f.reg = memory.Mem.Base, register.Reg
+	if armNamedStackOffset(memory.Mem) {
+		memory.Mem.OffRaw = ""
+	}
+	post, write, down, err := armMemoryModifiers(ins)
+	if err != nil {
+		return f, err
+	}
+	f.postIndex, f.writeback = post, post || write
+	f.offset = Operand{Kind: OpImm, Imm: memory.Mem.Off}
+	fullShift := op == "MOVW" || f.load && op == "MOVBU" || !f.load && f.spec.bits == 8
+	if memory.Mem.OffRaw != "" {
+		if memory.Mem.Index != "" || memory.Mem.Off != 0 {
+			return f, fmt.Errorf("arm %s mixes incompatible address offset forms: %q", op, ins.Raw)
+		}
+		shift, ok := armMemoryShift(memory.Mem)
+		if !ok || !isARMGeneralReg(shift.Reg) || shift.ShiftReg != "" || shift.ShiftAmount < 0 || shift.ShiftAmount > 31 {
+			return f, fmt.Errorf("arm %s has an invalid immediate register-offset shift: %q", op, ins.Raw)
+		}
+		if !fullShift && (shift.ShiftOp != ShiftLeft || shift.ShiftAmount != 0) {
+			return f, fmt.Errorf("arm %s signed-byte/halfword address only permits R<<0: %q", op, ins.Raw)
+		}
+		f.offset, f.subtract = shift, down
+	} else if memory.Mem.Index != "" {
+		// Preserve the existing structured MemRef API; source Go ARM spellings
+		// reach the shift branch above, not x86/ARM64 parenthesized indexes.
+		if !isARMGeneralReg(memory.Mem.Index) || memory.Mem.IndexExt != "" {
+			return f, fmt.Errorf("arm %s has an invalid address index: %q", op, ins.Raw)
+		}
+		amount := int64(0)
+		for scale := memory.Mem.Scale; scale > 1 && scale%2 == 0; scale /= 2 {
+			amount++
+		}
+		if memory.Mem.Scale != 0 && memory.Mem.Scale != int64(1)<<uint(amount) || amount > 31 {
+			return f, fmt.Errorf("arm %s has an invalid address scale: %q", op, ins.Raw)
+		}
+		f.offset = Operand{Kind: OpRegShift, Reg: memory.Mem.Index, ShiftOp: ShiftLeft, ShiftAmount: amount}
+		f.displace, f.subtract = memory.Mem.Off, down
+	} else {
+		// Go's olr rejects .U on negative immediate offsets. olhr (signed
+		// byte / halfword immediates) ignores .U, unlike its C_SHIFTADDR rows.
+		if down && fullShift && memory.Mem.Off < 0 {
+			return f, fmt.Errorf("arm %s .U on negative offset: %q", op, ins.Raw)
+		}
+		f.subtract = down && fullShift
+	}
+	return f, nil
+}
+
+func (c *armCtx) integerMemoryAddress(f armIntegerMemoryForm) (address, updated string, err error) {
+	base, err := c.loadReg(f.base)
+	if err != nil {
+		return "", "", err
+	}
+	delta, err := c.eval32(f.offset, false)
+	if err != nil {
+		return "", "", err
+	}
+	if f.displace != 0 {
+		tmp := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", tmp, delta, f.displace)
+		delta = "%" + tmp
+	}
+	op := "add"
+	if f.subtract {
+		op = "sub"
+	}
+	tmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %s\n", tmp, op, base, delta)
+	updated = "%" + tmp
+	address = updated
+	if f.postIndex {
+		address = base
+	}
+	return address, updated, nil
+}
+
+func (c *armCtx) lowerIntegerMemoryMove(op, cond string, ins Instr) (bool, bool, error) {
+	if _, ok := armIntegerMemorySpecs[op]; !ok {
+		return false, false, nil
+	}
+	hasMemory := false
+	for _, operand := range ins.Args {
+		hasMemory = hasMemory || operand.Kind == OpMem
+	}
+	if !hasMemory {
+		return false, false, nil
+	}
+	f, err := parseARMIntegerMemoryForm(op, ins)
+	if err != nil {
+		return true, false, err
+	}
+	err = c.emitConditionalEffect(cond, func() error {
+		address, updated, err := c.integerMemoryAddress(f)
+		if err != nil {
+			return err
+		}
+		var value string
+		if f.load {
+			value, err = c.loadMemAddress(address, f.spec.bits, f.spec.signed)
+		} else {
+			value, err = c.loadReg(f.reg)
+			if err == nil {
+				err = c.storeMemAddress(address, f.spec.bits, value)
+			}
+		}
+		if err != nil {
+			return err
+		}
+		if f.writeback {
+			if err := c.storeReg(f.base, updated); err != nil {
+				return err
+			}
+		}
+		if f.load {
+			return c.storeReg(f.reg, value)
+		}
+		return nil
+	})
+	return true, false, err
+}
diff --git a/arm_lower_parallel_byte.go b/arm_lower_parallel_byte.go
new file mode 100644
index 000000000..f05fc7a5d
--- /dev/null
+++ b/arm_lower_parallel_byte.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// lowerARMUnsignedParallelByteAddSub implements the complete three-register
+// UADD8/USUB8 result family decoded by Go's vendored ARM instruction table.
+// The four packed byte lanes deliberately wrap independently, matching the
+// architectural data result rather than carrying between adjacent lanes.
+func (c *armCtx) lowerARMUnsignedParallelByteAddSub(op, cond string, setFlags bool, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if setFlags {
+		return fmt.Errorf("arm %s does not accept the .S suffix: %q", op, ins.Raw)
+	}
+	if len(ins.Args) != 3 {
+		return fmt.Errorf("arm %s expects Rm, Rn, Rd: %q", op, ins.Raw)
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg || !isARMParallelDataReg(operand.Reg) {
+			return fmt.Errorf("arm %s accepts only R0-R14 registers: %q", op, ins.Raw)
+		}
+	}
+	rm, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	rn, err := c.loadReg(ins.Args[1].Reg)
+	if err != nil {
+		return err
+	}
+	rmBytes := c.newTmp()
+	rnBytes := c.newTmp()
+	resultBytes := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to <4 x i8>\n", rmBytes, rm)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to <4 x i8>\n", rnBytes, rn)
+	operation := "add"
+	if op == "USUB8" {
+		operation = "sub"
+	}
+	fmt.Fprintf(c.b, "  %%%s = %s <4 x i8> %%%s, %%%s\n", resultBytes, operation, rnBytes, rmBytes)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i8> %%%s to i32\n", result, resultBytes)
+	return c.selectRegWrite(ins.Args[2].Reg, cond, "%"+result)
+}
+
+func isARMParallelDataReg(reg Reg) bool {
+	s := strings.ToUpper(strings.TrimSpace(string(reg)))
+	return isARMGeneralReg(reg) && s != "PC" && s != "R15"
+}
diff --git a/arm_lower_parallel_byte_test.go b/arm_lower_parallel_byte_test.go
new file mode 100644
index 000000000..a2520bcea
--- /dev/null
+++ b/arm_lower_parallel_byte_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARMUnsignedParallelByteAddSubCompleteDecodedForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT parallelBytes(SB), $0-0\n\tCMP R0, R0\n")
+	for condition := uint32(0); condition <= 14; condition++ {
+		for _, base := range []uint32{0x06500f90, 0x06500ff0} {
+			// Rd=R2, Rn=R3, Rm=R4. The decoder table defines one
+			// three-register form for each of ARM's 15 executable conditions.
+			word := condition<<28 | base | 3<<16 | 2<<12 | 4
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatalf("Parse() error = %v", err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{
+			"parallelBytes": {Name: "parallelBytes", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatalf("Translate() error = %v", err)
+	}
+	for _, want := range []string{"add <4 x i8>", "sub <4 x i8>"} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("parallel byte semantics omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-parallel-byte.ll", "arm-parallel-byte.o", ir)
+}
+
+func TestARMUnsignedParallelByteAddSubRejectsNonExecutableCondition(t *testing.T) {
+	for _, word := range []uint32{0xf6500f91, 0xf6500ff1} {
+		t.Run(fmt.Sprintf("%#08x", word), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT invalid(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatalf("Parse() error = %v", err)
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "arm",
+				TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{
+					"invalid": {Name: "invalid", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate() accepted reserved encoding %#08x", word)
+			}
+		})
+	}
+}
+
+func TestARMUnsignedParallelByteAddSubRejectsNamedFormsOutsideDecoderShape(t *testing.T) {
+	for _, instruction := range []string{
+		"UADD8 R0, R1",
+		"USUB8 $1, R0, R1",
+		"UADD8.S R0, R1, R2",
+		"USUB8 R0, R1, R2, R3",
+	} {
+		t.Run(strings.ReplaceAll(instruction, " ", "_"), func(t *testing.T) {
+			source := "TEXT invalid(SB), $0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatalf("Parse() error = %v", err)
+			}
+			if _, err := Translate(file, Options{
+				Goarch:       "arm",
+				TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{
+					"invalid": {Name: "invalid", Ret: Void},
+				},
+			}); err == nil {
+				t.Fatalf("Translate() accepted invalid form %q", instruction)
+			}
+		})
+	}
+}
diff --git a/arm_lower_prefetch.go b/arm_lower_prefetch.go
new file mode 100644
index 000000000..8686ec46c
--- /dev/null
+++ b/arm_lower_prefetch.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *armCtx) lowerPreload(op, cond string, ins Instr) (ok bool, terminated bool, err error) {
+	switch op {
+	case "PLD":
+	default:
+		return false, false, nil
+	}
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return true, false, err
+	}
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpMem {
+		return true, false, fmt.Errorf("arm PLD expects one register-relative memory operand: %q", ins.Raw)
+	}
+	mem := ins.Args[0].Mem
+	if !isARMGeneralReg(mem.Base) || mem.Index != "" || mem.Sym != "" || mem.Off < -4095 || mem.Off > 4095 {
+		return true, false, fmt.Errorf("arm PLD operand is absent from Go 1.27's C_SOREG optab row: %q", ins.Raw)
+	}
+	if cond != "" && !strings.EqualFold(cond, "AL") {
+		err := c.emitConditionalEffect(cond, func() error {
+			_, _, innerErr := c.lowerPreload(op, "", ins)
+			return innerErr
+		})
+		return true, false, err
+	}
+	addr, _, _, err := c.addrI32(mem, false)
+	if err != nil {
+		return true, false, err
+	}
+	ptr := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", ptr, addr)
+	fmt.Fprintf(c.b, "  call void @llvm.prefetch.p0(ptr %%%s, i32 0, i32 3, i32 1)\n", ptr)
+	return true, false, nil
+}
diff --git a/arm_lower_reverse_bits.go b/arm_lower_reverse_bits.go
new file mode 100644
index 000000000..a6b9af19c
--- /dev/null
+++ b/arm_lower_reverse_bits.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "fmt"
+
+func (c *armCtx) lowerARMReverseBits(op, cond string, ins Instr) error {
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return err
+	}
+	if len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpReg || !isARMGeneralReg(ins.Args[0].Reg) ||
+		ins.Args[1].Kind != OpReg || !isARMGeneralReg(ins.Args[1].Reg) {
+		return fmt.Errorf("arm %s expects two general registers: %q", op, ins.Raw)
+	}
+	source, err := c.loadReg(ins.Args[0].Reg)
+	if err != nil {
+		return err
+	}
+	result := ""
+	switch op {
+	case "REV":
+		reversed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.bswap.i32(i32 %s)\n", reversed, source)
+		result = "%" + reversed
+	case "RBIT":
+		reversed := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.bitreverse.i32(i32 %s)\n", reversed, source)
+		result = "%" + reversed
+	case "REV16":
+		low := c.newTmp()
+		high := c.newTmp()
+		lowShifted := c.newTmp()
+		highShifted := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, 16711935\n", low, source)
+		fmt.Fprintf(c.b, "  %%%s = and i32 %s, -16711936\n", high, source)
+		fmt.Fprintf(c.b, "  %%%s = shl i32 %%%s, 8\n", lowShifted, low)
+		fmt.Fprintf(c.b, "  %%%s = lshr i32 %%%s, 8\n", highShifted, high)
+		fmt.Fprintf(c.b, "  %%%s = or i32 %%%s, %%%s\n", combined, lowShifted, highShifted)
+		result = "%" + combined
+	case "REVSH":
+		narrowed := c.newTmp()
+		reversed := c.newTmp()
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", narrowed, source)
+		fmt.Fprintf(c.b, "  %%%s = call i16 @llvm.bswap.i16(i16 %%%s)\n", reversed, narrowed)
+		fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i32\n", extended, reversed)
+		result = "%" + extended
+	default:
+		return fmt.Errorf("arm: unsupported reverse instruction %s", op)
+	}
+	return c.selectRegWrite(ins.Args[1].Reg, cond, result)
+}
diff --git a/arm_lower_reverse_bits_test.go b/arm_lower_reverse_bits_test.go
new file mode 100644
index 000000000..af2940cfb
--- /dev/null
+++ b/arm_lower_reverse_bits_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armReverseBitsForms = `TEXT reverseBits(SB),$0-0
+	REV R1, R2
+	REV16 R2, R3
+	REVSH R3, R4
+	RBIT R4, R5
+	RET
+`
+
+func TestTranslateARMReverseBitsCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armReverseBitsForms, true)
+	ll := translateARMForTest(t, armReverseBitsForms, map[string]FuncSig{
+		"example.reverseBits": {Name: "example.reverseBits", Ret: Void},
+	})
+	for _, want := range []string{
+		"call i32 @llvm.bswap.i32", "call i32 @llvm.bitreverse.i32", "sext i16", "and i32", "shl i32", "lshr i32",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM reverse-bit/byte lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-reverse-bits.ll", "arm-reverse-bits.o", ll)
+}
+
+func TestTranslateARMReverseBitsRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"REV (R0), R1", "RBIT R0, R1, R2"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM reverse-bit/byte optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_reverse_subtract_carry_test.go b/arm_lower_reverse_subtract_carry_test.go
new file mode 100644
index 000000000..20b0a04da
--- /dev/null
+++ b/arm_lower_reverse_subtract_carry_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armReverseSubtractCarryForms = `TEXT reverseSubtractCarry(SB),$0-0
+	CMP R0, R0
+	RSC $255, R0, R1
+	RSC.S $255, R0, R1
+	RSC $255, R0
+	RSC.S $255, R0
+	RSC R0, R1, R2
+	RSC.S R0, R1, R2
+	RSC R0, R1
+	RSC.S R0, R1
+	RSC R0>>28, R1, R2
+	RSC R0<<28, R1, R2
+	RSC R0->28, R1, R2
+	RSC R0@>28, R1, R2
+	RSC.S R0>>28, R1, R2
+	RSC.S R0<<28, R1, R2
+	RSC.S R0->28, R1, R2
+	RSC.S R0@>28, R1, R2
+	RSC R0<<28, R1
+	RSC R0>>28, R1
+	RSC R0->28, R1
+	RSC R0@>28, R1
+	RSC.S R0<<28, R1
+	RSC.S R0>>28, R1
+	RSC.S R0->28, R1
+	RSC.S R0@>28, R1
+	RSC R0<<R1, R2, R3
+	RSC R0>>R1, R2, R3
+	RSC R0->R1, R2, R3
+	RSC R0@>R1, R2, R3
+	RSC.S R0<<R1, R2, R3
+	RSC.S R0>>R1, R2, R3
+	RSC.S R0->R1, R2, R3
+	RSC.S R0@>R1, R2, R3
+	RSC R0<<R1, R2
+	RSC R0>>R1, R2
+	RSC R0->R1, R2
+	RSC R0@>R1, R2
+	RSC.S R0<<R1, R2
+	RSC.S R0>>R1, R2
+	RSC.S R0->R1, R2
+	RSC.S R0@>R1, R2
+	RET
+`
+
+func TestTranslateARMReverseSubtractCarryCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armReverseSubtractCarryForms, true)
+	ll := translateARMForTest(t, armReverseSubtractCarryForms, map[string]FuncSig{
+		"example.reverseSubtractCarry": {Name: "example.reverseSubtractCarry", Ret: Void},
+	})
+	for _, want := range []string{
+		"call i32 @llvm.fshr.i32", "sub i32", "load i1", "xor i1", "icmp ult i64",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("RSC lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-rsc.ll", "arm-rsc.o", ll)
+}
+
+func TestTranslateARMReverseSubtractCarryRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"RSC R0", "RSC (R0), R1"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM RSC optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_saturation.go b/arm_lower_saturation.go
new file mode 100644
index 000000000..9af5e9a6c
--- /dev/null
+++ b/arm_lower_saturation.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import "fmt"
+
+type armSaturationSpec struct {
+	intrinsic string
+	minWidth  int64
+	maxWidth  int64
+	shifted   bool
+}
+
+var armSaturationSpecs = map[string]armSaturationSpec{
+	"SSAT":   {intrinsic: "ssat", minWidth: 1, maxWidth: 32, shifted: true},
+	"USAT":   {intrinsic: "usat", minWidth: 0, maxWidth: 31, shifted: true},
+	"SSAT16": {intrinsic: "ssat16", minWidth: 1, maxWidth: 16},
+	"USAT16": {intrinsic: "usat16", minWidth: 0, maxWidth: 15},
+}
+
+func armSaturationRegister(reg Reg) bool {
+	return isARMGeneralReg(reg) && reg != PC && reg != Reg("R15")
+}
+
+func (c *armCtx) lowerSaturation(op, condition string, ins Instr) (bool, bool, error) {
+	spec, ok := armSaturationSpecs[op]
+	if !ok {
+		return false, false, nil
+	}
+	if len(ins.Args) != 3 || ins.Args[1].Kind != OpImm || ins.Args[1].ImmRaw != "" ||
+		ins.Args[2].Kind != OpReg || !armSaturationRegister(ins.Args[2].Reg) {
+		return true, false, fmt.Errorf("arm %s expects register or shifted register, saturation width, destination register: %q", op, ins.Raw)
+	}
+	width := ins.Args[1].Imm
+	if width < spec.minWidth || width > spec.maxWidth {
+		return true, false, fmt.Errorf("arm %s saturation width %d is outside [%d, %d]: %q", op, width, spec.minWidth, spec.maxWidth, ins.Raw)
+	}
+	source := ins.Args[0]
+	switch source.Kind {
+	case OpReg:
+		if !armSaturationRegister(source.Reg) {
+			return true, false, fmt.Errorf("arm %s source must be R0-R14: %q", op, ins.Raw)
+		}
+	case OpRegShift:
+		if !spec.shifted || !armSaturationRegister(source.Reg) || source.ShiftReg != "" {
+			return true, false, fmt.Errorf("arm %s does not accept this source shift: %q", op, ins.Raw)
+		}
+		switch source.ShiftOp {
+		case ShiftLeft:
+			if source.ShiftAmount < 0 || source.ShiftAmount > 31 {
+				return true, false, fmt.Errorf("arm %s LSL amount is outside [0, 31]: %q", op, ins.Raw)
+			}
+		case ShiftArith:
+			if source.ShiftAmount < 1 || source.ShiftAmount > 32 {
+				return true, false, fmt.Errorf("arm %s ASR amount is outside [1, 32]: %q", op, ins.Raw)
+			}
+		default:
+			return true, false, fmt.Errorf("arm %s supports only LSL and ASR source shifts: %q", op, ins.Raw)
+		}
+	default:
+		return true, false, fmt.Errorf("arm %s source must be a general register: %q", op, ins.Raw)
+	}
+
+	err := c.emitConditionalEffect(condition, func() error {
+		value, err := c.loadReg(source.Reg)
+		if err != nil {
+			return err
+		}
+		if source.Kind == OpRegShift && source.ShiftAmount != 0 {
+			amount := source.ShiftAmount
+			operation := "shl"
+			if source.ShiftOp == ShiftArith {
+				operation = "ashr"
+				if amount == 32 {
+					amount = 31
+				}
+			}
+			shifted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %d\n", shifted, operation, value, amount)
+			value = "%" + shifted
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.arm.%s(i32 %s, i32 %d)\n", result, spec.intrinsic, value, width)
+		return c.storeReg(ins.Args[2].Reg, "%"+result)
+	})
+	return true, false, err
+}
diff --git a/arm_lower_signed_move_alias_test.go b/arm_lower_signed_move_alias_test.go
new file mode 100644
index 000000000..ae1c2c6b6
--- /dev/null
+++ b/arm_lower_signed_move_alias_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const armSignedMoveAliasForms = `TEXT signedMoveAliases(SB),$0-0
+	MOVBS R5, R6
+	MOVBS R1, (R2)
+	MOVBS.P R1, (R2)
+	MOVBS.W R1, 32(R2)
+	MOVBS (R2), R1
+	MOVBS.P 32(R2), R1
+	MOVBS.W -32(R2), R1
+	MOVBS R0, math·Exp(SB)
+	MOVBS math·Exp(SB), R0
+	MOVBS R2@>0, R8
+	MOVHS R5, R6
+	MOVHS R4, (R3)
+	MOVHS.P R4, (R3)
+	MOVHS.W R3, 32(R4)
+	MOVHS (R9), R8
+	MOVHS.P 34(R9), R8
+	MOVHS.W -36(R9), R8
+	MOVHS R0, math·Exp(SB)
+	MOVHS math·Exp(SB), R0
+	MOVHS R3@>8, R9
+	RET
+`
+
+func requireARMGoAssemblerResult(t *testing.T, src string, wantSuccess bool) {
+	t.Helper()
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return
+	}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "forms.s")
+	if err := os.WriteFile(asm, []byte(src), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-p", "example.com/forms", "-o", filepath.Join(dir, "forms.o"), asm)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm")
+	out, err := cmd.CombinedOutput()
+	if wantSuccess && err != nil {
+		t.Fatalf("Go 1.27 ARM assembler rejected accepted forms: %v\n%s", err, out)
+	}
+	if !wantSuccess && err == nil {
+		t.Fatalf("Go 1.27 ARM assembler accepted a form expected outside the optab:\n%s", src)
+	}
+}
+
+func TestTranslateARMSignedMoveAliasCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armSignedMoveAliasForms, true)
+	ll := translateARMForTest(t, armSignedMoveAliasForms, map[string]FuncSig{
+		"example.signedMoveAliases": {Name: "example.signedMoveAliases", Ret: Void},
+	})
+	for _, want := range []string{
+		"sext i8", "sext i16", "trunc i32", "llvm.fshr.i32", "@math.Exp",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("signed move alias lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-signed-move-alias.ll", "arm-signed-move-alias.o", ll)
+}
+
+func TestTranslateARMSignedMoveAliasRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"MOVBS R1", "MOVHS R1, R2, R3"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM MOVBS/MOVHS optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_signed_multiply.go b/arm_lower_signed_multiply.go
new file mode 100644
index 000000000..baab8eb12
--- /dev/null
+++ b/arm_lower_signed_multiply.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (c *armCtx) lowerARMSignedMultiply(op, cond string, setFlags bool, ins Instr) error {
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix == "" || armCondCodes[suffix] || suffix == "S" && op == "MULL" {
+			continue
+		}
+		return fmt.Errorf("arm %s suffix %q is absent from the Go 1.27 optab: %q", op, suffix, ins.Raw)
+	}
+	if setFlags && op != "MULL" {
+		return fmt.Errorf("arm %s does not accept the .S suffix: %q", op, ins.Raw)
+	}
+	loadRegOperand := func(operand Operand) (string, error) {
+		if operand.Kind != OpReg || !isARMGeneralReg(operand.Reg) {
+			return "", fmt.Errorf("arm %s accepts only general-register operands: %q", op, ins.Raw)
+		}
+		return c.loadReg(operand.Reg)
+	}
+	signed64 := func(value string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sext i32 %s to i64\n", name, value)
+		return "%" + name
+	}
+	signedHalf := func(value string, top bool) string {
+		if top {
+			name := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = ashr i32 %s, 16\n", name, value)
+			return "%" + name
+		}
+		narrow := c.newTmp()
+		extended := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i16\n", narrow, value)
+		fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i32\n", extended, narrow)
+		return "%" + extended
+	}
+	multiply64 := func(first, second string) string {
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i64 %s, %s\n", product, signed64(first), signed64(second))
+		return "%" + product
+	}
+	highWord := func(product string) string {
+		shifted := c.newTmp()
+		word := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, 32\n", shifted, product)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", word, shifted)
+		return "%" + word
+	}
+
+	if op == "MULL" {
+		if len(ins.Args) != 3 || ins.Args[2].Kind != OpRegList || len(ins.Args[2].RegList) != 2 ||
+			!armRegListAllGPR(ins.Args[2].RegList) {
+			return fmt.Errorf("arm MULL expects src, src, (hi,lo): %q", ins.Raw)
+		}
+		first, err := loadRegOperand(ins.Args[0])
+		if err != nil {
+			return err
+		}
+		second, err := loadRegOperand(ins.Args[1])
+		if err != nil {
+			return err
+		}
+		product := multiply64(first, second)
+		low := c.newTmp()
+		highShifted := c.newTmp()
+		high := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low, product)
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", highShifted, product)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", high, highShifted)
+		if err := c.selectRegPairWrite(ins.Args[2].RegList[0], ins.Args[2].RegList[1], cond, "%"+high, "%"+low); err != nil {
+			return err
+		}
+		if setFlags {
+			execute := "true"
+			if cond != "" && !strings.EqualFold(cond, "AL") {
+				execute, err = c.condValue(cond)
+				if err != nil {
+					return err
+				}
+			}
+			zero := c.newTmp()
+			negative := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp eq i64 %s, 0\n", zero, product)
+			fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %s, 0\n", negative, product)
+			c.storeFlagPredicate(c.flagsZSlot, "%"+zero, execute)
+			c.storeFlagPredicate(c.flagsNSlot, "%"+negative, execute)
+			c.flagsWritten = true
+		}
+		return nil
+	}
+
+	wantArgs := 3
+	if op == "MMULA" || op == "MMULS" || op == "MULABB" || op == "MULAWB" || op == "MULAWT" || op == "MULS" {
+		wantArgs = 4
+	}
+	if len(ins.Args) != wantArgs {
+		return fmt.Errorf("arm %s expects %d general-register operands: %q", op, wantArgs, ins.Raw)
+	}
+	values := make([]string, len(ins.Args))
+	for i, operand := range ins.Args {
+		value, err := loadRegOperand(operand)
+		if err != nil {
+			return err
+		}
+		values[i] = value
+	}
+	result := ""
+	switch op {
+	case "MMUL", "MMULA", "MMULS":
+		high := highWord(multiply64(values[0], values[1]))
+		if op == "MMUL" {
+			result = high
+		} else {
+			combined := c.newTmp()
+			llvmOp := "add"
+			if op == "MMULS" {
+				llvmOp = "sub"
+				fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %s\n", combined, values[2], high)
+			} else {
+				fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %s\n", combined, llvmOp, high, values[2])
+			}
+			result = "%" + combined
+		}
+	case "MULBB", "MULABB":
+		first := signedHalf(values[0], false)
+		second := signedHalf(values[1], false)
+		product := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, first, second)
+		result = "%" + product
+		if op == "MULABB" {
+			combined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", combined, result, values[2])
+			result = "%" + combined
+		}
+	case "MULWB", "MULWT", "MULAWB", "MULAWT":
+		top := op == "MULWT" || op == "MULAWT"
+		half := signedHalf(values[0], top)
+		product := multiply64(half, values[1])
+		shifted := c.newTmp()
+		word := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = ashr i64 %s, 16\n", shifted, product)
+		fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", word, shifted)
+		result = "%" + word
+		if op == "MULAWB" || op == "MULAWT" {
+			combined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", combined, result, values[2])
+			result = "%" + combined
+		}
+	case "MULS":
+		product := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = mul i32 %s, %s\n", product, values[0], values[1])
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %%%s\n", combined, values[2], product)
+		result = "%" + combined
+	default:
+		return fmt.Errorf("arm: unsupported signed multiply instruction %s", op)
+	}
+	return c.selectRegWrite(ins.Args[len(ins.Args)-1].Reg, cond, result)
+}
diff --git a/arm_lower_signed_multiply_test.go b/arm_lower_signed_multiply_test.go
new file mode 100644
index 000000000..42680bcc5
--- /dev/null
+++ b/arm_lower_signed_multiply_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+const armSignedMultiplyForms = `TEXT signedMultiplyForms(SB),$0-0
+	MULAWT R1, R2, R3, R4
+	MULAWB R1, R2, R3, R4
+	MULS R1, R2, R3, R4
+	MMULA R1, R2, R3, R4
+	MMULS R1, R2, R3, R4
+	MULABB R1, R2, R3, R4
+	MULL R1, R2, (R4, R3)
+	MULL.S R1, R2, (R4, R3)
+	MMUL R1, R2, R3
+	MULBB R1, R2, R3
+	MULWB R1, R2, R3
+	MULWT R1, R2, R3
+	RET
+`
+
+func TestTranslateARMSignedMultiplyCompleteFormats(t *testing.T) {
+	requireARMGoAssemblerResult(t, armSignedMultiplyForms, true)
+	ll := translateARMForTest(t, armSignedMultiplyForms, map[string]FuncSig{
+		"example.signedMultiplyForms": {Name: "example.signedMultiplyForms", Ret: Void},
+	})
+	for _, want := range []string{
+		"sext i16", "sext i32", "mul i64", "ashr i64", "add i32", "sub i32", "icmp eq i64", "icmp slt i64",
+	} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("ARM signed multiply lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-signed-multiply.ll", "arm-signed-multiply.o", ll)
+}
+
+func TestTranslateARMSignedMultiplyRejectsFormsOutsideGoOptab(t *testing.T) {
+	for _, instruction := range []string{"MMUL R0, R1", "MULBB (R0), R1, R2", "MULL R0, R1, R2"} {
+		source := "TEXT bad(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Goarch:       "arm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted %q outside Go 1.27's ARM signed-multiply optab", instruction)
+		}
+	}
+}
diff --git a/arm_lower_svc_test.go b/arm_lower_svc_test.go
new file mode 100644
index 000000000..c5c1fcb5a
--- /dev/null
+++ b/arm_lower_svc_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMSVCAsLinuxSyscall(t *testing.T) {
+	const source = `TEXT rawSVC(SB), $0-0
+	SVC $0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"rawSVC": {Name: "rawSVC", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@syscall") {
+		t.Fatalf("ARM SVC did not lower through syscall ABI:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-svc.ll", "arm-svc.o", ir)
+}
diff --git a/arm_lower_syscall.go b/arm_lower_syscall.go
index dd47741fa..6b5bd9fe2 100644
--- a/arm_lower_syscall.go
+++ b/arm_lower_syscall.go
@@ -16,9 +16,9 @@ func (c *armCtx) truncI64ToI32(v64 string) string {
 
 func (c *armCtx) lowerSyscall(op string, ins Instr) (ok bool, terminated bool, err error) {
 	switch op {
-	case "SWI":
+	case "SWI", "SVC":
 		if len(ins.Args) > 1 || (len(ins.Args) == 1 && ins.Args[0].Kind != OpImm) {
-			return true, false, fmt.Errorf("arm SWI expects optional immediate operand: %q", ins.Raw)
+			return true, false, fmt.Errorf("arm %s expects optional immediate operand: %q", op, ins.Raw)
 		}
 		num32 := ""
 		if len(ins.Args) == 1 && ins.Args[0].Imm != 0 {
diff --git a/arm_lower_word.go b/arm_lower_word.go
new file mode 100644
index 000000000..9e2aea168
--- /dev/null
+++ b/arm_lower_word.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+)
+
+type armRawVFPCompare = armScalarCompareForm
+
+func decodeARMRawVFPCompare(word uint32) (armRawVFPCompare, bool) {
+	// VCMP/VCMPE.{F32,F64} Vd,Vm and Vd,#0 share this encoding shape.
+	// E (quiet/signaling), precision, Vd, Vm, D/M extension bits, zero, and the
+	// ARM condition field are the variable bits. For F32, D/M select the odd
+	// half of a D register; for F64 they extend D0..D15 to D16..D31.
+	const variable = uint32(0xf0000000 | 0x00400000 | 0x00010000 | 0x0000f000 | 0x00000100 | 0x00000080 | 0x00000020 | 0x0000000f)
+	const base = uint32(0x0eb40a40)
+	if word&^variable != base {
+		return armRawVFPCompare{}, false
+	}
+	zero := word&(1<<16) != 0
+	if zero && word&0x2f != 0 {
+		return armRawVFPCompare{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPCompare{}, false
+	}
+	bits := 32
+	if word&(1<<8) != 0 {
+		bits = 64
+	}
+	lhs := int((word >> 12) & 0xf)
+	rhs := int(word & 0xf)
+	if bits == 32 {
+		lhs = lhs*2 + int((word>>22)&1)
+		rhs = rhs*2 + int((word>>5)&1)
+	} else {
+		lhs += int((word>>22)&1) * 16
+		rhs += int((word>>5)&1) * 16
+	}
+	return armRawVFPCompare{
+		lhs:       lhs,
+		rhs:       rhs,
+		zeroRHS:   zero,
+		signaling: word&(1<<7) != 0,
+		bits:      bits,
+		condition: condition,
+	}, true
+}
+
+func armRawVFPBackingReg(number, bits int) Reg {
+	if bits == 32 {
+		number /= 2
+	}
+	return Reg(fmt.Sprintf("F%d", number))
+}
+
+func (c *armCtx) loadARMRawVFPRegValue(number, bits int) (string, error) {
+	reg := armRawVFPBackingReg(number, bits)
+	if bits == 64 || number%2 == 0 {
+		return c.loadARMFloatRegValue(reg, bits)
+	}
+	wide, err := c.loadFReg(reg)
+	if err != nil {
+		return "", err
+	}
+	shifted := c.newTmp()
+	narrow := c.newTmp()
+	converted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", shifted, wide)
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", narrow, shifted)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i32 %%%s to float\n", converted, narrow)
+	return "%" + converted, nil
+}
+
+func armRawCondition(value uint32) (string, bool) {
+	conditions := []string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL"}
+	if value >= uint32(len(conditions)) {
+		return "", false
+	}
+	return conditions[value], true
+}
+
+// lowerRawWord recognizes ARM instructions that older assembly used as raw
+// encodings because the contemporary Go assembler could not spell them. Keep
+// the decoder deliberately narrow: an unknown word remains an opaque directive.
+func (c *armCtx) lowerRawWord(ins Instr) (bool, error) {
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm {
+		return false, nil
+	}
+	word := uint32(ins.Args[0].Imm)
+	switch word {
+	case 0xe320f001: // YIELD, encoded explicitly so it remains a NOP before ARMv6K.
+		c.b.WriteString("  call void asm sideeffect \".long 0xe320f001\", \"~{memory}\"()\n")
+		return true, nil
+	}
+	if immediate, ok := decodeARMRawVFPImmediate(word); ok {
+		return true, c.lowerRawVFPImmediate(immediate)
+	}
+	if compare, ok := decodeARMRawVFPCompare(word); ok {
+		return true, c.lowerARMScalarCompare(compare)
+	}
+	decoded, carry, ok := decodeARMRawTST(word, ins.Raw)
+	if !ok {
+		return false, nil
+	}
+	return true, c.lowerARMCompareWithCarry("TST", decoded, carry)
+}
+
+// Raw immediate carry depends on the encoded rotation, not on the canonical
+// rotation that Go would choose for the decoded literal. Share this narrow
+// grammar between source proof and lowering.
+func decodeARMRawTST(word uint32, raw string) (Instr, string, bool) {
+	if word>>28 != 0xe || word&(3<<26) != 0 || (word>>21)&0xf != 8 || word&(1<<20) == 0 {
+		return Instr{}, "", false
+	}
+	rn := Reg(fmt.Sprintf("R%d", (word>>16)&0xf))
+	operand2 := word & 0xfff
+	var src Operand
+	carry := ""
+	if word&(1<<25) != 0 {
+		rotate := int(((operand2 >> 8) & 0xf) * 2)
+		value := bits.RotateLeft32(operand2&0xff, -rotate)
+		src = Operand{Kind: OpImm, Imm: int64(value)}
+		if rotate != 0 {
+			carry = "false"
+			if value>>31 != 0 {
+				carry = "true"
+			}
+		}
+	} else {
+		if operand2&0xff0 != 0 {
+			return Instr{}, "", false
+		}
+		src = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", operand2&0xf))}
+	}
+	decoded := Instr{
+		Op:   "TST",
+		Args: []Operand{src, {Kind: OpReg, Reg: rn}},
+		Raw:  raw,
+	}
+	return decoded, carry, true
+}
diff --git a/arm_lower_word_coprocessor_test.go b/arm_lower_word_coprocessor_test.go
new file mode 100644
index 000000000..a5960a2c8
--- /dev/null
+++ b/arm_lower_word_coprocessor_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawMRCWord(t *testing.T) {
+	const source = `TEXT rawMRC(SB), $0-0
+	WORD $0xee100f10 // mrc p15, 0, r0, c0, c0, 0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"rawMRC": {Name: "rawMRC", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mrc p15") {
+		t.Fatalf("ARM raw MRC did not lower to inline asm:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-mrc.ll", "arm-raw-mrc.o", ir)
+}
+
+func TestTranslateARMRawMCRWord(t *testing.T) {
+	const source = `TEXT rawMCR(SB), $0-0
+	WORD $0xee000f10 // mcr p15, 0, r0, c0, c0, 0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"rawMCR": {Name: "rawMCR", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "mcr p15") {
+		t.Fatalf("ARM raw MCR did not lower to inline asm:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-mcr.ll", "arm-raw-mcr.o", ir)
+}
+
+func TestTranslateARMMRCNamedControlRegisters(t *testing.T) {
+	const source = `TEXT ·namedMRC(SB), $0-0
+	MRC $15, $0, R0, C13, C0, $3
+	RET
+`
+	ir := translateARMForTest(t, source, map[string]FuncSig{
+		"example.namedMRC": {Name: "example.namedMRC", Ret: Void},
+	})
+	if !strings.Contains(ir, `mrc p15, #0, $0, c13, c0, #3`) {
+		t.Fatalf("named ARM MRC did not normalize control registers:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-named-mrc.ll", "arm-named-mrc.o", ir)
+}
diff --git a/arm_lower_word_extend.go b/arm_lower_word_extend.go
new file mode 100644
index 000000000..4bd3061db
--- /dev/null
+++ b/arm_lower_word_extend.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "fmt"
+
+type armRawSXTB struct {
+	condition   string
+	rotation    int
+	source      int
+	destination int
+}
+
+func armConditionName(code int) string {
+	return [...]string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL"}[code]
+}
+
+// decodeARMRawSXTB covers every A32 SXTB Rd, Rm{, ROR #8|16|24}
+// encoding: all four rotations, every register field, and the 15 executable
+// conditions. Condition 0xf belongs to the unconditional instruction space.
+func decodeARMRawSXTB(word uint32) (armRawSXTB, bool) {
+	if word&0x0fff03f0 != 0x06af0070 || word>>28 == 0xf {
+		return armRawSXTB{}, false
+	}
+	return armRawSXTB{
+		condition:   armConditionName(int(word >> 28)),
+		rotation:    int(word>>10&3) * 8,
+		source:      int(word) & 15,
+		destination: int(word>>12) & 15,
+	}, true
+}
+
+func (c *armCtx) lowerRawSXTB(form armRawSXTB) error {
+	if form.source == 15 || form.destination == 15 {
+		return fmt.Errorf("arm SXTB cannot safely use PC")
+	}
+	source, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.source)))
+	if err != nil {
+		return err
+	}
+	if form.rotation != 0 {
+		rotated := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.fshr.i32(i32 %s, i32 %s, i32 %d)\n", rotated, source, source, form.rotation)
+		source = "%" + rotated
+	}
+	narrowed := c.newTmp()
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i8\n", narrowed, source)
+	fmt.Fprintf(c.b, "  %%%s = sext i8 %%%s to i32\n", extended, narrowed)
+	return c.selectRegWrite(Reg(fmt.Sprintf("R%d", form.destination)), form.condition, "%"+extended)
+}
diff --git a/arm_lower_word_ldrexd_test.go b/arm_lower_word_ldrexd_test.go
new file mode 100644
index 000000000..dc83e859f
--- /dev/null
+++ b/arm_lower_word_ldrexd_test.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawLDREXDDecoderFormat(t *testing.T) {
+	ll := translateARMForTest(t, `TEXT ·rawLDREXD(SB),NOSPLIT,$0-0
+	WORD $0xe1bd0f9f // LDREXD [SP], R1, R0
+	WORD $0xe1a90f98 // STREXD [R9], R9, R8, R0
+	WORD $0xf57ff01f // CLREX
+	RET
+`, map[string]FuncSig{"example.rawLDREXD": {Name: "example.rawLDREXD", Ret: Void}})
+	for _, want := range []string{"load atomic i64", "cmpxchg ptr", "store i32", "exclusive_valid", `asm sideeffect "clrex"`} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("raw LDREXD lowering omitted %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-ldrexd.ll", "arm-raw-ldrexd.o", ll)
+}
diff --git a/arm_lower_word_neon_add_sub.go b/arm_lower_word_neon_add_sub.go
new file mode 100644
index 000000000..881305a25
--- /dev/null
+++ b/arm_lower_word_neon_add_sub.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONAddSub struct {
+	subtract    bool
+	floating    bool
+	quad        bool
+	elementBits int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONAddSub covers A32 Advanced SIMD VADD/VSUB register forms:
+// integer elements of 8, 16, 32, or 64 bits and floating elements of 16 or
+// 32 bits, each in both D and Q registers.
+func decodeARMRawNEONAddSub(word uint32) (armRawNEONAddSub, bool) {
+	const variable = uint32(0x00400000 | 0x00300000 | 0x000f0000 |
+		0x0000f000 | 0x000000e0 | 0x0000000f)
+	var floating, subtract bool
+	switch word &^ variable {
+	case 0xf2000800:
+	case 0xf3000800:
+		subtract = true
+	case 0xf2000d00:
+		floating = true
+		subtract = word>>21&1 != 0
+	default:
+		return armRawNEONAddSub{}, false
+	}
+	encodedSize := int(word >> 20 & 3)
+	elementBits := 8 << encodedSize
+	if floating {
+		elementBits = 32
+		if encodedSize&1 != 0 {
+			elementBits = 16
+		}
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	lhs := int(word>>16)&15 | int(word>>7&1)*16
+	rhs := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || lhs&1 != 0 || rhs&1 != 0) {
+		return armRawNEONAddSub{}, false
+	}
+	return armRawNEONAddSub{
+		subtract:    subtract,
+		floating:    floating,
+		quad:        quad,
+		elementBits: elementBits,
+		destination: destination,
+		lhs:         lhs,
+		rhs:         rhs,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONAddSub(form armRawNEONAddSub) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	operation := "add"
+	if form.subtract {
+		operation = "sub"
+	}
+	if form.floating {
+		elementType = "half"
+		if form.elementBits == 32 {
+			elementType = "float"
+		}
+		operation = "f" + operation
+	}
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, form.quad, elementType)
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, form.elementBits, form.quad, elementType)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s, %s\n",
+		result, operation, lanes, elementType, lhs, rhs)
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_add_sub_test.go b/arm_lower_word_neon_add_sub_test.go
new file mode 100644
index 000000000..57351ac51
--- /dev/null
+++ b/arm_lower_word_neon_add_sub_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONAddSub(subtract, floating, quad bool, elementBits, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf2000800)
+	if floating {
+		word = 0xf2000d00
+		if elementBits == 16 {
+			word |= 1 << 20
+		}
+		if subtract {
+			word |= 1 << 21
+		}
+	} else {
+		if subtract {
+			word |= 1 << 24
+		}
+		for bits := 8; bits < elementBits; bits *= 2 {
+			word += 1 << 20
+		}
+	}
+	word |= uint32(destination&15)<<12 | uint32(destination/16)<<22
+	word |= uint32(lhs&15)<<16 | uint32(lhs/16)<<7
+	word |= uint32(rhs&15) | uint32(rhs/16)<<5
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONAddSubLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		subtract    bool
+		floating    bool
+		quad        bool
+		elementBits int
+		destination int
+		lhs         int
+		rhs         int
+	}{
+		{0xf2010802, false, false, false, 8, 0, 1, 2},
+		{0xf2110802, false, false, false, 16, 0, 1, 2},
+		{0xf2210802, false, false, false, 32, 0, 1, 2},
+		{0xf2310802, false, false, false, 64, 0, 1, 2},
+		{0xf2020844, false, false, true, 8, 0, 2, 4},
+		{0xf226e868, false, false, true, 32, 14, 6, 24},
+		{0xf326e868, true, false, true, 32, 14, 6, 24},
+		{0xf2010d02, false, true, false, 32, 0, 1, 2},
+		{0xf2110d02, false, true, false, 16, 0, 1, 2},
+		{0xf2210d02, true, true, false, 32, 0, 1, 2},
+		{0xf2310d02, true, true, false, 16, 0, 1, 2},
+	} {
+		got, ok := decodeARMRawNEONAddSub(test.word)
+		if !ok || got.subtract != test.subtract || got.floating != test.floating ||
+			got.quad != test.quad || got.elementBits != test.elementBits ||
+			got.destination != test.destination || got.lhs != test.lhs || got.rhs != test.rhs {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONAddSub(
+			test.subtract, test.floating, test.quad, test.elementBits,
+			test.destination, test.lhs, test.rhs,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONAddSubAllFields(t *testing.T) {
+	count := 0
+	for _, floating := range []bool{false, true} {
+		widths := []int{8, 16, 32, 64}
+		if floating {
+			widths = []int{16, 32}
+		}
+		for _, elementBits := range widths {
+			for _, subtract := range []bool{false, true} {
+				for _, quad := range []bool{false, true} {
+					step := 1
+					if quad {
+						step = 2
+					}
+					for destination := 0; destination < 32; destination += step {
+						for lhs := 0; lhs < 32; lhs += step {
+							for rhs := 0; rhs < 32; rhs += step {
+								word := encodeARMRawNEONAddSub(
+									subtract, floating, quad, elementBits, destination, lhs, rhs,
+								)
+								got, ok := decodeARMRawNEONAddSub(word)
+								if !ok || got.subtract != subtract || got.floating != floating ||
+									got.quad != quad || got.elementBits != elementBits ||
+									got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+									t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 442368 {
+		t.Fatalf("covered %d NEON VADD/VSUB forms, want 442368", count)
+	}
+}
+
+func TestTranslateARMRawNEONAddSubAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawAddSub(SB), $0-0\n")
+	for _, floating := range []bool{false, true} {
+		widths := []int{8, 16, 32, 64}
+		if floating {
+			widths = []int{16, 32}
+		}
+		for _, elementBits := range widths {
+			for _, subtract := range []bool{false, true} {
+				for _, quad := range []bool{false, true} {
+					word := encodeARMRawNEONAddSub(subtract, floating, quad, elementBits, 0, 2, 4)
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawAddSub": {Name: "rawAddSub", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"add <8 x i8>", "sub <8 x i8>", "add <4 x i16>", "sub <4 x i16>",
+		"add <2 x i32>", "sub <2 x i32>", "add <1 x i64>", "sub <1 x i64>",
+		"fadd <4 x half>", "fsub <4 x half>", "fadd <2 x float>", "fsub <2 x float>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VADD/VSUB omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-add-sub.ll", "arm-raw-neon-add-sub.o", ir)
+}
+
+func TestARMRawNEONAddSubRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONAddSub(false, false, true, 32, 0, 2, 4)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1<<16,
+		base | 1,
+		base ^ 1<<9,
+	} {
+		if _, ok := decodeARMRawNEONAddSub(word); ok {
+			t.Fatalf("accepted reserved VADD/VSUB encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_bit_clear_immediate.go b/arm_lower_word_neon_bit_clear_immediate.go
new file mode 100644
index 000000000..aab98aba9
--- /dev/null
+++ b/arm_lower_word_neon_bit_clear_immediate.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONBitClearImmediate struct {
+	quad        bool
+	elementBits int
+	shift       int
+	destination int
+	imm8        int
+}
+
+// decodeARMRawNEONBitClearImmediate covers all A32 VBIC modified-immediate
+// forms accepted by LLVM 22: i16 byte positions 0/8 and i32 byte positions
+// 0/8/16/24, with every imm8 value and D/Q destination register.
+func decodeARMRawNEONBitClearImmediate(word uint32) (armRawNEONBitClearImmediate, bool) {
+	const variable = uint32(0x01000000 | 0x00400000 | 0x00070000 |
+		0x0000f000 | 0x00000f00 | 0x00000040 | 0x0000000f)
+	if word&^variable != 0xf2800030 {
+		return armRawNEONBitClearImmediate{}, false
+	}
+	cmode := int(word >> 8 & 15)
+	elementBits := 32
+	shift := 0
+	switch cmode {
+	case 1, 3, 5, 7:
+		shift = (cmode - 1) / 2 * 8
+	case 9, 11:
+		elementBits = 16
+		shift = (cmode - 9) / 2 * 8
+	default:
+		return armRawNEONBitClearImmediate{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	if quad && destination&1 != 0 {
+		return armRawNEONBitClearImmediate{}, false
+	}
+	return armRawNEONBitClearImmediate{
+		quad:        quad,
+		elementBits: elementBits,
+		shift:       shift,
+		destination: destination,
+		imm8:        int(word>>24&1)*128 | int(word>>16&7)*16 | int(word&15),
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONBitClearImmediate(form armRawNEONBitClearImmediate) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	destination, lanes, err := c.loadARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	widthMask := uint64(1)<<form.elementBits - 1
+	clearMask := widthMask &^ (uint64(form.imm8) << form.shift)
+	constants := make([]string, lanes)
+	for index := range constants {
+		constants[index] = fmt.Sprintf("%s %d", elementType, clearMask)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and <%d x %s> %s, <%s>\n",
+		result, lanes, elementType, destination, strings.Join(constants, ", "))
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_bit_clear_immediate_test.go b/arm_lower_word_neon_bit_clear_immediate_test.go
new file mode 100644
index 000000000..652adf47c
--- /dev/null
+++ b/arm_lower_word_neon_bit_clear_immediate_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONBitClearImmediate(quad bool, elementBits, shift, destination, imm8 int) uint32 {
+	cmode := 1 + shift/4
+	if elementBits == 16 {
+		cmode = 9 + shift/4
+	}
+	word := uint32(0xf2800030 | (imm8>>7)<<24 | ((imm8>>4)&7)<<16 |
+		(destination&15)<<12 | (destination/16)<<22 | cmode<<8 | imm8&15)
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONBitClearImmediateLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		quad        bool
+		elementBits int
+		shift       int
+		destination int
+		imm8        int
+	}{
+		{0xf387093c, false, 16, 0, 0, 0xfc},
+		{0xf3870b7c, true, 16, 8, 0, 0xfc},
+		{0xf387013c, false, 32, 0, 0, 0xfc},
+		{0xf387037c, true, 32, 8, 0, 0xfc},
+		{0xf387053c, false, 32, 16, 0, 0xfc},
+		{0xf3c7073c, false, 32, 24, 16, 0xfc},
+	} {
+		got, ok := decodeARMRawNEONBitClearImmediate(test.word)
+		if !ok || got.quad != test.quad || got.elementBits != test.elementBits ||
+			got.shift != test.shift || got.destination != test.destination || got.imm8 != test.imm8 {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONBitClearImmediate(
+			test.quad, test.elementBits, test.shift, test.destination, test.imm8,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONBitClearImmediateAllFields(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{16, 32} {
+		for shift := 0; shift < elementBits; shift += 8 {
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for imm8 := 0; imm8 < 256; imm8++ {
+						word := encodeARMRawNEONBitClearImmediate(
+							quad, elementBits, shift, destination, imm8,
+						)
+						got, ok := decodeARMRawNEONBitClearImmediate(word)
+						if !ok || got.quad != quad || got.elementBits != elementBits ||
+							got.shift != shift || got.destination != destination || got.imm8 != imm8 {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 73728 {
+		t.Fatalf("covered %d VBIC immediate forms, want 73728", count)
+	}
+}
+
+func TestTranslateARMRawNEONBitClearImmediateAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawBIC(SB), $0-0\n")
+	for _, elementBits := range []int{16, 32} {
+		for shift := 0; shift < elementBits; shift += 8 {
+			for _, quad := range []bool{false, true} {
+				word := encodeARMRawNEONBitClearImmediate(quad, elementBits, shift, 16, 0xfc)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawBIC": {Name: "rawBIC", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"and <4 x i16>", "and <8 x i16>",
+		"and <2 x i32>", "and <4 x i32>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VBIC immediate omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vbic-imm.ll", "arm-raw-neon-vbic-imm.o", ir)
+}
+
+func TestARMRawNEONBitClearImmediateRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONBitClearImmediate(true, 32, 24, 0, 0xfc)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base ^ 1<<5,
+		base &^ (7 << 8),
+	} {
+		if _, ok := decodeARMRawNEONBitClearImmediate(word); ok {
+			t.Fatalf("accepted reserved VBIC immediate encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_convert_float32.go b/arm_lower_word_neon_convert_float32.go
new file mode 100644
index 000000000..24e8bee02
--- /dev/null
+++ b/arm_lower_word_neon_convert_float32.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONConvertFloat32 struct {
+	toFloat     bool
+	unsigned    bool
+	quad        bool
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONConvertFloat32 covers all eight classic A32 NEON VCVT
+// integer/float32 forms: signed or unsigned, both directions, and D or Q
+// vectors. Fixed-point, FP16, and ARMv8 directed-rounding encodings are
+// separate architectural families.
+func decodeARMRawNEONConvertFloat32(word uint32) (armRawNEONConvertFloat32, bool) {
+	if word&0xffbf0010 != 0xf3bb0000 {
+		return armRawNEONConvertFloat32{}, false
+	}
+	op := int(word>>7) & 31
+	if op < 0b01100 || op > 0b01111 {
+		return armRawNEONConvertFloat32{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	source := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || source&1 != 0) {
+		return armRawNEONConvertFloat32{}, false
+	}
+	return armRawNEONConvertFloat32{
+		toFloat:     op == 0b01100 || op == 0b01101,
+		unsigned:    op == 0b01101 || op == 0b01111,
+		quad:        quad,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONConvertFloat32(form armRawNEONConvertFloat32) error {
+	sourceType := "i32"
+	destinationType := "float"
+	wordKind := "s32"
+	if form.unsigned {
+		wordKind = "u32"
+	}
+	sourceKind, destinationKind := wordKind, "f32"
+	if !form.toFloat {
+		sourceType = "float"
+		destinationType = "i32"
+		sourceKind, destinationKind = "f32", wordKind
+	}
+	source, lanes, err := c.loadARMRawNEONVector(form.source, 32, form.quad, sourceType)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	// Advanced SIMD VCVT uses standard rounding/denormal controls, not the
+	// scalar VFP operation's ambient FPSCR mode. Its cumulative exceptions
+	// still update native FPSCR, even for dead outputs. Keep the whole D/Q
+	// operation and order it with the existing VMRS/VMSR memory barriers.
+	// LLVM22's w constraint selects D0..31 / Q0..15 for these vector widths.
+	operation := "vcvt." + destinationKind + "." + sourceKind + " $0, $1"
+	fmt.Fprintf(c.b, "  %%%s = call <%d x %s> asm sideeffect %q, %q(<%d x %s> %s)\n",
+		result, lanes, destinationType, operation, "=w,w,~{memory}", lanes, sourceType, source)
+	return c.storeARMRawNEONVector(form.destination, 32, form.quad, destinationType, "%"+result)
+}
diff --git a/arm_lower_word_neon_convert_float32_test.go b/arm_lower_word_neon_convert_float32_test.go
new file mode 100644
index 000000000..9cd502bfe
--- /dev/null
+++ b/arm_lower_word_neon_convert_float32_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONConvertFloat32(toFloat, unsigned, quad bool, destination, source int) uint32 {
+	op := 0b01100
+	if !toFloat {
+		op = 0b01110
+	}
+	if unsigned {
+		op++
+	}
+	word := uint32(0xf3bb0000 | (destination&15)<<12 | op<<7 | source&15)
+	word |= uint32(destination/16) << 22
+	word |= uint32(source/16) << 5
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestTranslateARMRawNEONVCVTFloat32GoDSPRegression(t *testing.T) {
+	const source = `TEXT rawConvertFloat32(SB), $0-0
+	WORD $0xf3bb2642 // vcvt.f32.s32 q1, q1
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawConvertFloat32": {Name: "rawConvertFloat32", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{`call <4 x float> asm sideeffect "vcvt.f32.s32`, `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VCVT IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vcvt.ll", "arm-raw-neon-vcvt.o", ir)
+}
+
+func TestARMRawNEONVCVTFloat32DecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, toFloat := range []bool{false, true} {
+		for _, unsigned := range []bool{false, true} {
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for source := 0; source < 32; source += step {
+						word := encodeARMRawNEONConvertFloat32(toFloat, unsigned, quad, destination, source)
+						got, ok := decodeARMRawNEONConvertFloat32(word)
+						if !ok || got.toFloat != toFloat || got.unsigned != unsigned || got.quad != quad || got.destination != destination || got.source != source {
+							t.Fatalf("decoded NEON VCVT %#08x as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 5120 {
+		t.Fatalf("covered %d NEON VCVT encodings, want 5120", count)
+	}
+}
+
+func TestTranslateARMRawNEONVCVTFloat32AllOperations(t *testing.T) {
+	source := "TEXT rawConvertFloat32All(SB), $0-0\n"
+	for _, test := range []struct {
+		toFloat  bool
+		unsigned bool
+		quad     bool
+	}{
+		{true, false, false}, {true, true, false}, {false, false, false}, {false, true, false},
+		{true, false, true}, {true, true, true}, {false, false, true}, {false, true, true},
+	} {
+		word := encodeARMRawNEONConvertFloat32(test.toFloat, test.unsigned, test.quad, 0, 2)
+		source += fmt.Sprintf("\tWORD $%#08x\n", word)
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawConvertFloat32All": {Name: "rawConvertFloat32All", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`call <2 x float> asm sideeffect "vcvt.f32.s32`,
+		`call <4 x float> asm sideeffect "vcvt.f32.u32`,
+		`call <2 x i32> asm sideeffect "vcvt.s32.f32`,
+		`call <4 x i32> asm sideeffect "vcvt.u32.f32`,
+	} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VCVT all operations omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vcvt-all.ll", "arm-raw-neon-vcvt-all.o", ir)
+}
+
+func TestARMRawNEONVCVTFloat32RejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONConvertFloat32(true, false, false, 0, 0) &^ (uint32(31) << 7),
+		encodeARMRawNEONConvertFloat32(true, false, true, 0, 0) | 1<<12,
+		encodeARMRawNEONConvertFloat32(true, false, true, 0, 0) | 1,
+		encodeARMRawNEONConvertFloat32(true, false, false, 0, 0) | 1<<4,
+	} {
+		if _, ok := decodeARMRawNEONConvertFloat32(word); ok {
+			t.Fatalf("NEON VCVT decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_core_lane_move.go b/arm_lower_word_neon_core_lane_move.go
new file mode 100644
index 000000000..34261f357
--- /dev/null
+++ b/arm_lower_word_neon_core_lane_move.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONCoreLaneMove struct {
+	toVector    bool
+	unsigned    bool
+	condition   string
+	elementBits int
+	lane        int
+	vector      int
+	core        int
+}
+
+// decodeARMRawNEONCoreLaneMove covers A32 VMOV between a core register and a
+// D-register element: 8/16/32-bit insertion and signed/unsigned 8/16-bit or
+// ordinary 32-bit extraction, with all executable condition and lane fields.
+func decodeARMRawNEONCoreLaneMove(word uint32) (armRawNEONCoreLaneMove, bool) {
+	const variable = uint32(0xf0fff0e0)
+	if word&^variable != 0x0e000b10 {
+		return armRawNEONCoreLaneMove{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawNEONCoreLaneMove{}, false
+	}
+	toVector := word>>20&1 == 0
+	unsigned := word>>23&1 != 0
+	if toVector && unsigned {
+		return armRawNEONCoreLaneMove{}, false
+	}
+	elementBits := 32
+	lane := int(word >> 21 & 1)
+	if word>>22&1 != 0 {
+		elementBits = 8
+		lane = int(word>>21&1)*4 | int(word>>6&1)*2 | int(word>>5&1)
+	} else if word>>5&1 != 0 {
+		elementBits = 16
+		lane = int(word>>21&1)*2 | int(word>>6&1)
+	} else if word>>6&1 != 0 || unsigned {
+		return armRawNEONCoreLaneMove{}, false
+	}
+	return armRawNEONCoreLaneMove{
+		toVector:    toVector,
+		unsigned:    unsigned,
+		condition:   condition,
+		elementBits: elementBits,
+		lane:        lane,
+		vector:      int(word>>16)&15 | int(word>>7&1)*16,
+		core:        int(word >> 12 & 15),
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONCoreLaneMove(form armRawNEONCoreLaneMove) error {
+	if form.core == 15 {
+		return fmt.Errorf("arm NEON core/lane VMOV cannot safely use PC")
+	}
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawNEONCoreLaneMove(form)
+		})
+	}
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	coreReg := Reg(fmt.Sprintf("R%d", form.core))
+	vector, lanes, err := c.loadARMRawNEONVector(
+		form.vector, form.elementBits, false, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	if form.toVector {
+		value, err := c.loadReg(coreReg)
+		if err != nil {
+			return err
+		}
+		if form.elementBits != 32 {
+			narrow := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to %s\n", narrow, value, elementType)
+			value = "%" + narrow
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %s, i32 %d\n",
+			result, lanes, elementType, vector, elementType, value, form.lane)
+		return c.storeARMRawNEONVector(
+			form.vector, form.elementBits, false, elementType, "%"+result,
+		)
+	}
+	extracted := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n",
+		extracted, lanes, elementType, vector, form.lane)
+	value := "%" + extracted
+	if form.elementBits != 32 {
+		extend := "sext"
+		if form.unsigned {
+			extend = "zext"
+		}
+		wide := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s to i32\n", wide, extend, elementType, value)
+		value = "%" + wide
+	}
+	return c.storeReg(coreReg, value)
+}
diff --git a/arm_lower_word_neon_core_lane_move_test.go b/arm_lower_word_neon_core_lane_move_test.go
new file mode 100644
index 000000000..7a1a0a136
--- /dev/null
+++ b/arm_lower_word_neon_core_lane_move_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONCoreLaneMove(toVector, unsigned bool, condition, elementBits, lane, vector, core int) uint32 {
+	word := uint32(condition)<<28 | 0x0e000b10 | uint32(vector&15)<<16 |
+		uint32(vector/16)<<7 | uint32(core)<<12
+	if !toVector {
+		word |= 1 << 20
+		if unsigned {
+			word |= 1 << 23
+		}
+	}
+	switch elementBits {
+	case 8:
+		word |= 1 << 22
+		word |= uint32(lane/4) << 21
+		word |= uint32(lane>>1&1) << 6
+		word |= uint32(lane&1) << 5
+	case 16:
+		word |= 1 << 5
+		word |= uint32(lane/2) << 21
+		word |= uint32(lane&1) << 6
+	case 32:
+		word |= uint32(lane) << 21
+	}
+	return word
+}
+
+func TestARMRawNEONCoreLaneMoveLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		toVector    bool
+		unsigned    bool
+		elementBits int
+		lane        int
+		vector      int
+		core        int
+	}{
+		{0xee401b10, true, false, 8, 0, 0, 1},
+		{0xee601b70, true, false, 8, 7, 0, 1},
+		{0xee001b30, true, false, 16, 0, 0, 1},
+		{0xee201b70, true, false, 16, 3, 0, 1},
+		{0xee001b10, true, false, 32, 0, 0, 1},
+		{0xee201b10, true, false, 32, 1, 0, 1},
+		{0xee005b90, true, false, 32, 0, 16, 5},
+		{0xeed01b10, false, true, 8, 0, 0, 1},
+		{0xee501b10, false, false, 8, 0, 0, 1},
+		{0xee901b30, false, true, 16, 0, 0, 1},
+		{0xee101b30, false, false, 16, 0, 0, 1},
+		{0xee101b10, false, false, 32, 0, 0, 1},
+		{0xee105b90, false, false, 32, 0, 16, 5},
+	} {
+		got, ok := decodeARMRawNEONCoreLaneMove(test.word)
+		if !ok || got.toVector != test.toVector || got.unsigned != test.unsigned ||
+			got.elementBits != test.elementBits || got.lane != test.lane ||
+			got.vector != test.vector || got.core != test.core {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONCoreLaneMove(
+			test.toVector, test.unsigned, 14, test.elementBits,
+			test.lane, test.vector, test.core,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONCoreLaneMoveAllFields(t *testing.T) {
+	count := 0
+	for _, toVector := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for _, unsigned := range []bool{false, true} {
+				if toVector && unsigned || elementBits == 32 && unsigned {
+					continue
+				}
+				for condition := 0; condition < 15; condition++ {
+					for vector := 0; vector < 32; vector++ {
+						for lane := 0; lane < 64/elementBits; lane++ {
+							word := encodeARMRawNEONCoreLaneMove(
+								toVector, unsigned, condition, elementBits, lane, vector, 5,
+							)
+							got, ok := decodeARMRawNEONCoreLaneMove(word)
+							if !ok || got.toVector != toVector || got.unsigned != unsigned ||
+								got.condition != armConditionName(condition) ||
+								got.elementBits != elementBits || got.lane != lane ||
+								got.vector != vector || got.core != 5 {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 19200 {
+		t.Fatalf("covered %d VMOV core/lane forms, want 19200", count)
+	}
+}
+
+func TestTranslateARMRawNEONCoreLaneMoveAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawCoreLane(SB), $0-0\n")
+	for _, elementBits := range []int{8, 16, 32} {
+		for _, toVector := range []bool{false, true} {
+			unsignedValues := []bool{false}
+			if !toVector && elementBits != 32 {
+				unsignedValues = []bool{false, true}
+			}
+			for _, unsigned := range unsignedValues {
+				word := encodeARMRawNEONCoreLaneMove(
+					toVector, unsigned, 14, elementBits, 1, 16, 5,
+				)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawCoreLane": {Name: "rawCoreLane", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"insertelement <8 x i8>", "extractelement <8 x i8>",
+		"insertelement <4 x i16>", "extractelement <4 x i16>",
+		"insertelement <2 x i32>", "extractelement <2 x i32>",
+		"sext i8", "zext i8",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMOV core/lane omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-core-lane.ll", "arm-raw-neon-core-lane.o", ir)
+}
+
+func TestARMRawNEONCoreLaneMoveRejectsReservedAndUnsafe(t *testing.T) {
+	base := encodeARMRawNEONCoreLaneMove(true, false, 14, 32, 0, 16, 5)
+	for _, word := range []uint32{
+		base | 1<<23,
+		base | 1<<6,
+		base | 0xf0000000,
+	} {
+		if _, ok := decodeARMRawNEONCoreLaneMove(word); ok {
+			t.Fatalf("accepted reserved VMOV core/lane encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawNEONCoreLaneMove(true, false, 14, 32, 0, 16, 15)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badCoreLane(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"badCoreLane": {Name: "badCoreLane", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted unsafe PC core/lane transfer")
+	}
+}
diff --git a/arm_lower_word_neon_dup.go b/arm_lower_word_neon_dup.go
new file mode 100644
index 000000000..9541ba667
--- /dev/null
+++ b/arm_lower_word_neon_dup.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONDup struct {
+	condition   string
+	elementBits int
+	destination int
+	core        int
+	quad        bool
+}
+
+// decodeARMRawNEONDup covers the complete A32 VDUP (ARM core register)
+// family for 8-, 16-, and 32-bit elements and both D and Q destinations.
+func decodeARMRawNEONDup(word uint32) (armRawNEONDup, bool) {
+	if word&0x0f900f5f != 0x0e800b10 {
+		return armRawNEONDup{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawNEONDup{}, false
+	}
+	bit8 := word>>22&1 != 0
+	bit16 := word>>5&1 != 0
+	if bit8 && bit16 {
+		return armRawNEONDup{}, false
+	}
+	elementBits := 32
+	if bit8 {
+		elementBits = 8
+	} else if bit16 {
+		elementBits = 16
+	}
+	destination := int(word>>16)&15 | int(word>>7&1)*16
+	quad := word>>21&1 != 0
+	if quad && destination&1 != 0 {
+		return armRawNEONDup{}, false
+	}
+	return armRawNEONDup{
+		condition:   condition,
+		elementBits: elementBits,
+		destination: destination,
+		core:        int(word>>12) & 15,
+		quad:        quad,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONDup(form armRawNEONDup) error {
+	if form.core == 15 {
+		return fmt.Errorf("arm NEON VDUP cannot safely use PC")
+	}
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawNEONDup(form)
+		})
+	}
+	source, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.core)))
+	if err != nil {
+		return err
+	}
+	element := source
+	if form.elementBits != 32 {
+		narrow := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = trunc i32 %s to i%d\n", narrow, source, form.elementBits)
+		element = "%" + narrow
+	}
+	lanes := 64 / form.elementBits
+	inserted := c.newTmp()
+	broadcast := c.newTmp()
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x i%d> poison, i%d %s, i32 0\n", inserted, lanes, form.elementBits, form.elementBits, element)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i%d> %%%s, <%d x i%d> poison, <%d x i32> zeroinitializer\n", broadcast, lanes, form.elementBits, inserted, lanes, form.elementBits, lanes)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to i64\n", bits, lanes, form.elementBits, broadcast)
+	if err := c.storeFReg(armRawVFPBackingReg(form.destination, 64), "%"+bits); err != nil {
+		return err
+	}
+	if form.quad {
+		return c.storeFReg(armRawVFPBackingReg(form.destination+1, 64), "%"+bits)
+	}
+	return nil
+}
diff --git a/arm_lower_word_neon_dup_test.go b/arm_lower_word_neon_dup_test.go
new file mode 100644
index 000000000..24cdaf955
--- /dev/null
+++ b/arm_lower_word_neon_dup_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONDup(condition, elementBits, destination, core int, quad bool) uint32 {
+	word := uint32(condition)<<28 | 0x0e800b10 | uint32(destination&15)<<16 | uint32(core)<<12 | uint32(destination/16)<<7
+	if quad {
+		word |= 1 << 21
+	}
+	switch elementBits {
+	case 8:
+		word |= 1 << 22
+	case 16:
+		word |= 1 << 5
+	}
+	return word
+}
+
+func TestTranslateARMRawNEONDupCompleteForms(t *testing.T) {
+	const source = `TEXT rawDup(SB), $0-0
+	WORD $0xeec00b10 // vdup.8 d0, r0
+	WORD $0xeee00b10 // vdup.8 q0, r0
+	WORD $0xee834b30 // vdup.16 d3, r4
+	WORD $0xeea64b30 // vdup.16 q3, r4
+	WORD $0xee8feb10 // vdup.32 d15, r14
+	WORD $0xeeaeeb10 // vdup.32 q7, r14
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawDup": {Name: "rawDup", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"shufflevector <8 x i8>", "shufflevector <4 x i16>", "shufflevector <2 x i32>", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VDUP IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-dup.ll", "arm-raw-neon-dup.o", ir)
+}
+
+func TestARMRawNEONDupDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for _, elementBits := range []int{8, 16, 32} {
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for core := 0; core < 16; core++ {
+						word := encodeARMRawNEONDup(condition, elementBits, destination, core, quad)
+						got, ok := decodeARMRawNEONDup(word)
+						if !ok || got.condition != armConditionName(condition) || got.elementBits != elementBits || got.destination != destination || got.core != core || got.quad != quad {
+							t.Fatalf("decoded NEON VDUP %#08x as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count == 0 {
+		t.Fatal("covered no NEON VDUP encodings")
+	}
+}
+
+func TestARMRawNEONDupRejectsReservedAndUnsafeForms(t *testing.T) {
+	reserved := encodeARMRawNEONDup(14, 8, 0, 0, false) | 1<<5
+	if _, ok := decodeARMRawNEONDup(reserved); ok {
+		t.Fatal("NEON VDUP decoder accepted reserved size encoding")
+	}
+	for _, word := range []uint32{encodeARMRawNEONDup(15, 8, 0, 0, false), encodeARMRawNEONDup(14, 8, 1, 0, true)} {
+		if _, ok := decodeARMRawNEONDup(word); ok {
+			t.Fatalf("NEON VDUP decoder accepted reserved encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawNEONDup(14, 8, 0, 15, false)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badDup(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"badDup": {Name: "badDup", Ret: Void}}}); err == nil {
+		t.Fatal("Translate accepted PC as NEON VDUP source")
+	}
+}
diff --git a/arm_lower_word_neon_eor.go b/arm_lower_word_neon_eor.go
new file mode 100644
index 000000000..763cfb421
--- /dev/null
+++ b/arm_lower_word_neon_eor.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONEOR struct {
+	operation   string
+	quad        bool
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONBitwise covers the complete classic A32 Advanced SIMD
+// VAND/VBIC/VORR/VORN/VEOR register families for D and Q registers.
+func decodeARMRawNEONBitwise(word uint32) (armRawNEONEOR, bool) {
+	const variable = uint32(0x00400000 | 0x000f0000 | 0x0000f000 | 0x00000080 | 0x00000040 | 0x00000020 | 0x0000000f)
+	operation := ""
+	switch word &^ variable {
+	case 0xf2000110:
+		operation = "and"
+	case 0xf2100110:
+		operation = "bic"
+	case 0xf2300110:
+		operation = "orn"
+	case 0xf3000110:
+		operation = "xor"
+	case 0xf2200110:
+		operation = "or"
+	default:
+		return armRawNEONEOR{}, false
+	}
+
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	lhs := int(word>>16)&15 | int(word>>7&1)*16
+	rhs := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || lhs&1 != 0 || rhs&1 != 0) {
+		return armRawNEONEOR{}, false
+	}
+	return armRawNEONEOR{
+		operation:   operation,
+		quad:        quad,
+		destination: destination,
+		lhs:         lhs,
+		rhs:         rhs,
+	}, true
+}
+
+func decodeARMRawNEONEOR(word uint32) (armRawNEONEOR, bool) {
+	form, ok := decodeARMRawNEONBitwise(word)
+	return form, ok && form.operation == "xor"
+}
+
+func (c *armCtx) lowerRawNEONBitwise(form armRawNEONEOR) error {
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, 64, form.quad, "i64")
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, 64, form.quad, "i64")
+	if err != nil {
+		return err
+	}
+	operation := form.operation
+	if operation == "bic" || operation == "orn" {
+		inverted := c.newTmp()
+		allOnes := "<i64 -1>"
+		if lanes == 2 {
+			allOnes = "<i64 -1, i64 -1>"
+		}
+		fmt.Fprintf(c.b, "  %%%s = xor <%d x i64> %s, %s\n",
+			inverted, lanes, rhs, allOnes)
+		rhs = "%" + inverted
+		operation = "and"
+		if form.operation == "orn" {
+			operation = "or"
+		}
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i64> %s, %s\n", result, operation, lanes, lhs, rhs)
+	return c.storeARMRawNEONVector(form.destination, 64, form.quad, "i64", "%"+result)
+}
diff --git a/arm_lower_word_neon_eor_test.go b/arm_lower_word_neon_eor_test.go
new file mode 100644
index 000000000..eabe15527
--- /dev/null
+++ b/arm_lower_word_neon_eor_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONEOR(quad bool, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf3000110 | (destination&15)<<12 | (lhs&15)<<16 | rhs&15)
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	word |= uint32(rhs/16) << 5
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func encodeARMRawNEONORR(quad bool, destination, lhs, rhs int) uint32 {
+	return encodeARMRawNEONEOR(quad, destination, lhs, rhs) ^ 0x01200000
+}
+
+func encodeARMRawNEONBitwise(operation string, quad bool, destination, lhs, rhs int) uint32 {
+	word := encodeARMRawNEONEOR(quad, destination, lhs, rhs)
+	switch operation {
+	case "and":
+		return word ^ 0x01000000
+	case "bic":
+		return word ^ 0x01100000
+	case "or":
+		return word ^ 0x01200000
+	case "orn":
+		return word ^ 0x01300000
+	default:
+		return word
+	}
+}
+
+func TestARMRawNEONBitwiseAllLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		operation string
+		base      uint32
+	}{
+		{"and", 0xf2010112},
+		{"bic", 0xf2110112},
+		{"or", 0xf2210112},
+		{"orn", 0xf2310112},
+		{"xor", 0xf3010112},
+	} {
+		for _, quad := range []bool{false, true} {
+			step := 1
+			if quad {
+				step = 2
+			}
+			for destination := 0; destination < 32; destination += step {
+				for lhs := 0; lhs < 32; lhs += step {
+					for rhs := 0; rhs < 32; rhs += step {
+						word := encodeARMRawNEONBitwise(
+							test.operation, quad, destination, lhs, rhs,
+						)
+						got, ok := decodeARMRawNEONBitwise(word)
+						if !ok || got.operation != test.operation || got.quad != quad ||
+							got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+		if encoded := encodeARMRawNEONBitwise(test.operation, false, 0, 1, 2); encoded != test.base {
+			t.Fatalf("encoded %s as %#08x, want %#08x", test.operation, encoded, test.base)
+		}
+	}
+}
+
+func TestTranslateARMRawNEONBitwiseAllLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawBitwise(SB), $0-0\n")
+	for _, operation := range []string{"and", "bic", "or", "orn", "xor"} {
+		for _, quad := range []bool{false, true} {
+			word := encodeARMRawNEONBitwise(operation, quad, 0, 2, 4)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawBitwise": {Name: "rawBitwise", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"and <1 x i64>", "and <2 x i64>",
+		"or <1 x i64>", "or <2 x i64>",
+		"xor <1 x i64>", "xor <2 x i64>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("bitwise IR omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-bitwise-all.ll", "arm-raw-neon-bitwise-all.o", ir)
+}
+
+func TestARMRawNEONORRLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		quad        bool
+		destination int
+		lhs         int
+		rhs         int
+	}{
+		{0xf2210112, false, 0, 1, 2},
+		{0xf2220154, true, 0, 2, 4},
+		{0xf2208150, true, 8, 0, 0},
+		{0xf260f19f, false, 31, 16, 15},
+		{0xf260e1fc, true, 30, 16, 28},
+	} {
+		got, ok := decodeARMRawNEONBitwise(test.word)
+		if !ok || got.operation != "or" || got.quad != test.quad ||
+			got.destination != test.destination || got.lhs != test.lhs || got.rhs != test.rhs {
+			t.Fatalf("LLVM 22 VORR encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONORR(test.quad, test.destination, test.lhs, test.rhs); encoded != test.word {
+			t.Fatalf("encoded VORR %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestTranslateARMRawNEONORRWireGuardRegression(t *testing.T) {
+	const source = `TEXT rawORR(SB), $0-0
+	WORD $0xf2208150 // vmov q4,q0, encoded as vorr q4,q0,q0
+	WORD $0xf2210112 // vorr d0,d1,d2
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"rawORR": {Name: "rawORR", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{"or <2 x i64>", "or <1 x i64>"} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VORR omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vorr.ll", "arm-raw-neon-vorr.o", ir)
+}
+
+func TestARMRawNEONORRAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, quad := range []bool{false, true} {
+		step := 1
+		if quad {
+			step = 2
+		}
+		for destination := 0; destination < 32; destination += step {
+			for lhs := 0; lhs < 32; lhs += step {
+				for rhs := 0; rhs < 32; rhs += step {
+					word := encodeARMRawNEONORR(quad, destination, lhs, rhs)
+					got, ok := decodeARMRawNEONBitwise(word)
+					if !ok || got.operation != "or" || got.quad != quad ||
+						got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+						t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 36864 {
+		t.Fatalf("covered %d VORR forms, want 36864", count)
+	}
+}
+
+func TestTranslateARMRawNEONVEORPionTransportRegression(t *testing.T) {
+	const source = `TEXT rawXor(SB), $0-0
+	WORD $0xF3004154 // veor q2, q0, q2
+	WORD $0xF3026156 // veor q3, q1, q3
+	WORD $0xF3002152 // veor q1, q0, q1
+	WORD $0xF3001111 // veor d1, d0, d1
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawXor": {Name: "rawXor", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"xor <2 x i64>", "xor <1 x i64>", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VEOR IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-veor.ll", "arm-raw-neon-veor.o", ir)
+}
+
+func TestARMRawNEONVEORDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, quad := range []bool{false, true} {
+		step := 1
+		if quad {
+			step = 2
+		}
+		for destination := 0; destination < 32; destination += step {
+			for lhs := 0; lhs < 32; lhs += step {
+				for rhs := 0; rhs < 32; rhs += step {
+					word := encodeARMRawNEONEOR(quad, destination, lhs, rhs)
+					got, ok := decodeARMRawNEONEOR(word)
+					if !ok || got.quad != quad || got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+						t.Fatalf("decoded NEON VEOR %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 36864 {
+		t.Fatalf("covered %d NEON VEOR encodings, want 36864", count)
+	}
+}
+
+func TestARMRawNEONVEORRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONEOR(true, 0, 0, 0) | 1<<12,
+		encodeARMRawNEONEOR(true, 0, 0, 0) | 1<<16,
+		encodeARMRawNEONEOR(true, 0, 0, 0) | 1,
+		encodeARMRawNEONEOR(false, 0, 0, 0) ^ 1<<8,
+	} {
+		if got, ok := decodeARMRawNEONEOR(word); ok {
+			t.Fatalf("NEON VEOR decoder accepted reserved encoding %#08x as %s", word, fmt.Sprint(got))
+		}
+	}
+}
diff --git a/arm_lower_word_neon_extract.go b/arm_lower_word_neon_extract.go
new file mode 100644
index 000000000..46923d3f4
--- /dev/null
+++ b/arm_lower_word_neon_extract.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONExtract struct {
+	quad        bool
+	destination int
+	lhs         int
+	rhs         int
+	offset      int
+}
+
+// decodeARMRawNEONExtract covers A32 VEXT register forms. Element spellings
+// of .8/.16/.32/.64 share the same byte-extract encoding; only the byte
+// offset matters. D forms permit offsets 0..7 and Q forms 0..15.
+func decodeARMRawNEONExtract(word uint32) (armRawNEONExtract, bool) {
+	const variable = uint32(0x00400000 | 0x000f0000 | 0x0000f000 |
+		0x00000f00 | 0x000000e0 | 0x0000000f)
+	if word&^variable != 0xf2b00000 {
+		return armRawNEONExtract{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	lhs := int(word>>16)&15 | int(word>>7&1)*16
+	rhs := int(word)&15 | int(word>>5&1)*16
+	offset := int(word >> 8 & 15)
+	if !quad && offset >= 8 ||
+		quad && (destination&1 != 0 || lhs&1 != 0 || rhs&1 != 0) {
+		return armRawNEONExtract{}, false
+	}
+	return armRawNEONExtract{
+		quad:        quad,
+		destination: destination,
+		lhs:         lhs,
+		rhs:         rhs,
+		offset:      offset,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONExtract(form armRawNEONExtract) error {
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, 8, form.quad, "i8")
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, 8, form.quad, "i8")
+	if err != nil {
+		return err
+	}
+	indices := make([]string, lanes)
+	for index := range indices {
+		indices[index] = fmt.Sprintf("i32 %d", form.offset+index)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x i8> %s, <%d x i8> %s, <%d x i32> <%s>\n",
+		result, lanes, lhs, lanes, rhs, lanes, strings.Join(indices, ", "))
+	return c.storeARMRawNEONVector(form.destination, 8, form.quad, "i8", "%"+result)
+}
diff --git a/arm_lower_word_neon_extract_test.go b/arm_lower_word_neon_extract_test.go
new file mode 100644
index 000000000..7b39ff28b
--- /dev/null
+++ b/arm_lower_word_neon_extract_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONExtract(quad bool, destination, lhs, rhs, offset int) uint32 {
+	word := uint32(0xf2b00000 | (destination&15)<<12 | (destination/16)<<22 |
+		(lhs&15)<<16 | (lhs/16)<<7 | rhs&15 | (rhs/16)<<5 | offset<<8)
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONExtractLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		quad        bool
+		destination int
+		lhs         int
+		rhs         int
+		offset      int
+	}{
+		{0xf2b10002, false, 0, 1, 2, 0},
+		{0xf2b10702, false, 0, 1, 2, 7},
+		{0xf2b20044, true, 0, 2, 4, 0},
+		{0xf2b20f44, true, 0, 2, 4, 15},
+		{0xf2b44844, true, 4, 4, 4, 8},
+		{0xf2f0efec, true, 30, 16, 28, 15},
+	} {
+		got, ok := decodeARMRawNEONExtract(test.word)
+		if !ok || got.quad != test.quad || got.destination != test.destination ||
+			got.lhs != test.lhs || got.rhs != test.rhs || got.offset != test.offset {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONExtract(
+			test.quad, test.destination, test.lhs, test.rhs, test.offset,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONExtractAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, quad := range []bool{false, true} {
+		step, offsets := 1, 8
+		if quad {
+			step, offsets = 2, 16
+		}
+		for destination := 0; destination < 32; destination += step {
+			for lhs := 0; lhs < 32; lhs += step {
+				for rhs := 0; rhs < 32; rhs += step {
+					for offset := 0; offset < offsets; offset++ {
+						word := encodeARMRawNEONExtract(quad, destination, lhs, rhs, offset)
+						got, ok := decodeARMRawNEONExtract(word)
+						if !ok || got.quad != quad || got.destination != destination ||
+							got.lhs != lhs || got.rhs != rhs || got.offset != offset {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 327680 {
+		t.Fatalf("covered %d VEXT forms, want 327680", count)
+	}
+}
+
+func TestTranslateARMRawNEONExtractAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawExtract(SB), $0-0\n")
+	for _, quad := range []bool{false, true} {
+		maxOffset := 7
+		if quad {
+			maxOffset = 15
+		}
+		for _, offset := range []int{0, maxOffset / 2, maxOffset} {
+			word := encodeARMRawNEONExtract(quad, 4, 2, 6, offset)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawExtract": {Name: "rawExtract", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{"shufflevector <8 x i8>", "shufflevector <16 x i8>"} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VEXT omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vext.ll", "arm-raw-neon-vext.o", ir)
+}
+
+func TestARMRawNEONExtractRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONExtract(true, 0, 2, 4, 8)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1<<16,
+		base | 1,
+		base ^ 1<<24,
+		encodeARMRawNEONExtract(false, 0, 1, 2, 8),
+	} {
+		if _, ok := decodeARMRawNEONExtract(word); ok {
+			t.Fatalf("accepted reserved VEXT encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_helpers.go b/arm_lower_word_neon_helpers.go
new file mode 100644
index 000000000..aa22347a0
--- /dev/null
+++ b/arm_lower_word_neon_helpers.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import "fmt"
+
+// loadARMRawNEONVector reads a D register or the consecutive D-register pair
+// that encodes a Q register and views the bits as an LLVM vector.
+func (c *armCtx) loadARMRawNEONVector(first, elementBits int, quad bool, elementType string) (string, int, error) {
+	lanes := 64 / elementBits
+	low, err := c.loadFReg(armRawVFPBackingReg(first, 64))
+	if err != nil {
+		return "", 0, err
+	}
+	bits := low
+	totalBits := 64
+	if quad {
+		lanes *= 2
+		totalBits = 128
+		high, err := c.loadFReg(armRawVFPBackingReg(first+1, 64))
+		if err != nil {
+			return "", 0, err
+		}
+		lowWide := c.newTmp()
+		highWide := c.newTmp()
+		highShifted := c.newTmp()
+		joined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", lowWide, low)
+		fmt.Fprintf(c.b, "  %%%s = zext i64 %s to i128\n", highWide, high)
+		fmt.Fprintf(c.b, "  %%%s = shl i128 %%%s, 64\n", highShifted, highWide)
+		fmt.Fprintf(c.b, "  %%%s = or i128 %%%s, %%%s\n", joined, lowWide, highShifted)
+		bits = "%" + joined
+	}
+	vector := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast i%d %s to <%d x %s>\n", vector, totalBits, bits, lanes, elementType)
+	return "%" + vector, lanes, nil
+}
+
+func (c *armCtx) storeARMRawNEONVector(first, elementBits int, quad bool, elementType, value string) error {
+	lanes := 64 / elementBits
+	totalBits := 64
+	if quad {
+		lanes *= 2
+		totalBits = 128
+	}
+	bits := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x %s> %s to i%d\n", bits, lanes, elementType, value, totalBits)
+	if !quad {
+		return c.storeFReg(armRawVFPBackingReg(first, 64), "%"+bits)
+	}
+	low := c.newTmp()
+	highWide := c.newTmp()
+	high := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", low, bits)
+	fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", highWide, bits)
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", high, highWide)
+	if err := c.storeFReg(armRawVFPBackingReg(first, 64), "%"+low); err != nil {
+		return err
+	}
+	return c.storeFReg(armRawVFPBackingReg(first+1, 64), "%"+high)
+}
diff --git a/arm_lower_word_neon_minmax.go b/arm_lower_word_neon_minmax.go
new file mode 100644
index 000000000..c572091db
--- /dev/null
+++ b/arm_lower_word_neon_minmax.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMinMax struct {
+	minimum     bool
+	floating    bool
+	unsigned    bool
+	quad        bool
+	elementBits int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONMinMax covers the complete classic A32 Advanced SIMD
+// VMAX/VMIN family described by LLVM 22's ARMInstrNEON.td: signed and
+// unsigned 8/16/32-bit integers plus 16/32-bit floating point, for both D and
+// Q vectors. ARMv8 VMAXNM/VMINNM encodings are a separate instruction family.
+func decodeARMRawNEONMinMax(word uint32) (armRawNEONMinMax, bool) {
+	// N3V fixes 31:25=1111001 and bit 23=0.
+	if word&0xfe800000 != 0xf2000000 {
+		return armRawNEONMinMax{}, false
+	}
+	op := int(word>>8) & 15
+	size := int(word>>20) & 3
+	minimum := false
+	floating := false
+	unsigned := false
+	elementBits := 0
+	switch op {
+	case 0b0110:
+		if size == 3 {
+			return armRawNEONMinMax{}, false
+		}
+		minimum = word>>4&1 != 0
+		unsigned = word>>24&1 != 0
+		elementBits = 8 << size
+	case 0b1111:
+		if word>>24&1 != 0 || word>>4&1 != 0 {
+			return armRawNEONMinMax{}, false
+		}
+		floating = true
+		minimum = size >= 2
+		if size&1 == 0 {
+			elementBits = 32
+		} else {
+			elementBits = 16
+		}
+	default:
+		return armRawNEONMinMax{}, false
+	}
+
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	lhs := int(word>>16)&15 | int(word>>7&1)*16
+	rhs := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || lhs&1 != 0 || rhs&1 != 0) {
+		return armRawNEONMinMax{}, false
+	}
+	return armRawNEONMinMax{
+		minimum:     minimum,
+		floating:    floating,
+		unsigned:    unsigned,
+		quad:        quad,
+		elementBits: elementBits,
+		destination: destination,
+		lhs:         lhs,
+		rhs:         rhs,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMinMax(form armRawNEONMinMax) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	if form.floating {
+		elementType = "half"
+		if form.elementBits == 32 {
+			elementType = "float"
+		}
+	}
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, form.quad, elementType)
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, form.elementBits, form.quad, elementType)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	if form.floating {
+		operation := "maximum"
+		if form.minimum {
+			operation = "minimum"
+		}
+		fmt.Fprintf(c.b, "  %%%s = call <%d x %s> @llvm.%s.v%df%d(<%d x %s> %s, <%d x %s> %s)\n", result, lanes, elementType, operation, lanes, form.elementBits, lanes, elementType, lhs, lanes, elementType, rhs)
+	} else {
+		predicate := "sgt"
+		if form.unsigned {
+			predicate = "ugt"
+		}
+		if form.minimum {
+			predicate = "slt"
+			if form.unsigned {
+				predicate = "ult"
+			}
+		}
+		condition := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = icmp %s <%d x %s> %s, %s\n", condition, predicate, lanes, elementType, lhs, rhs)
+		fmt.Fprintf(c.b, "  %%%s = select <%d x i1> %%%s, <%d x %s> %s, <%d x %s> %s\n", result, lanes, condition, lanes, elementType, lhs, lanes, elementType, rhs)
+	}
+	return c.storeARMRawNEONVector(form.destination, form.elementBits, form.quad, elementType, "%"+result)
+}
diff --git a/arm_lower_word_neon_minmax_test.go b/arm_lower_word_neon_minmax_test.go
new file mode 100644
index 000000000..5e5bc8db6
--- /dev/null
+++ b/arm_lower_word_neon_minmax_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawNEONVMAXGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawMaximum(SB), $0-0
+	WORD $0xf2088f42 // vmax.f32 q4, q4, q1
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMaximum": {Name: "rawMaximum", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@llvm.maximum.v4f32") {
+		t.Fatalf("raw NEON VMAX.F32 IR omitted maximum intrinsic:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vmax.ll", "arm-raw-neon-vmax.o", ir)
+}
+
+func encodeARMRawNEONMinMax(minimum, floating, unsigned, quad bool, elementBits, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf2000000 | (destination&15)<<12 | (lhs&15)<<16 | rhs&15)
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	word |= uint32(rhs/16) << 5
+	if quad {
+		word |= 1 << 6
+	}
+	if floating {
+		word |= 0b1111 << 8
+		size := 0
+		if elementBits == 16 {
+			size = 1
+		}
+		if minimum {
+			size += 2
+		}
+		word |= uint32(size) << 20
+	} else {
+		word |= 0b0110 << 8
+		word |= uint32(map[int]int{8: 0, 16: 1, 32: 2}[elementBits]) << 20
+		if unsigned {
+			word |= 1 << 24
+		}
+		if minimum {
+			word |= 1 << 4
+		}
+	}
+	return word
+}
+
+func TestARMRawNEONMinMaxDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, floating := range []bool{false, true} {
+		for _, minimum := range []bool{false, true} {
+			unsignedValues := []bool{false, true}
+			elementSizes := []int{8, 16, 32}
+			if floating {
+				unsignedValues = []bool{false}
+				elementSizes = []int{16, 32}
+			}
+			for _, unsigned := range unsignedValues {
+				for _, quad := range []bool{false, true} {
+					step := 1
+					if quad {
+						step = 2
+					}
+					for _, elementBits := range elementSizes {
+						for destination := 0; destination < 32; destination += step {
+							for lhs := 0; lhs < 32; lhs += step {
+								for rhs := 0; rhs < 32; rhs += step {
+									word := encodeARMRawNEONMinMax(minimum, floating, unsigned, quad, elementBits, destination, lhs, rhs)
+									got, ok := decodeARMRawNEONMinMax(word)
+									if !ok || got.minimum != minimum || got.floating != floating || got.unsigned != unsigned || got.quad != quad || got.elementBits != elementBits || got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+										t.Fatalf("decoded NEON min/max %#08x as %+v, ok=%v", word, got, ok)
+									}
+									count++
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 589824 {
+		t.Fatalf("covered %d NEON min/max encodings, want 589824", count)
+	}
+}
+
+func TestTranslateARMRawNEONMinMaxAllFormats(t *testing.T) {
+	source := "TEXT rawMinMaxAll(SB), $0-0\n"
+	for _, minimum := range []bool{false, true} {
+		for _, unsigned := range []bool{false, true} {
+			for _, quad := range []bool{false, true} {
+				for _, bits := range []int{8, 16, 32} {
+					source += fmt.Sprintf("\tWORD $%#08x\n", encodeARMRawNEONMinMax(minimum, false, unsigned, quad, bits, 0, 2, 4))
+				}
+			}
+		}
+		for _, quad := range []bool{false, true} {
+			for _, bits := range []int{16, 32} {
+				source += fmt.Sprintf("\tWORD $%#08x\n", encodeARMRawNEONMinMax(minimum, true, false, quad, bits, 0, 2, 4))
+			}
+		}
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMinMaxAll": {Name: "rawMinMaxAll", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"icmp sgt <8 x i8>", "icmp ugt <16 x i8>", "icmp slt <2 x i32>", "icmp ult <4 x i32>", "@llvm.maximum.v4f16", "@llvm.maximum.v4f32", "@llvm.minimum.v8f16", "@llvm.minimum.v2f32", "+fullfp16", "+neon"} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON min/max formats omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-minmax-all.ll", "arm-raw-neon-minmax-all.o", ir)
+}
+
+func TestARMRawNEONMinMaxRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONMinMax(false, false, false, false, 8, 0, 0, 0) | 3<<20,
+		encodeARMRawNEONMinMax(false, true, false, false, 32, 0, 0, 0) | 1<<24,
+		encodeARMRawNEONMinMax(false, true, false, false, 32, 0, 0, 0) | 1<<4,
+		encodeARMRawNEONMinMax(false, false, false, true, 8, 0, 0, 0) | 1<<12,
+		encodeARMRawNEONMinMax(false, false, false, true, 8, 0, 0, 0) | 1<<16,
+		encodeARMRawNEONMinMax(false, false, false, true, 8, 0, 0, 0) | 1,
+	} {
+		if _, ok := decodeARMRawNEONMinMax(word); ok {
+			t.Fatalf("NEON min/max decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_modified_immediate.go b/arm_lower_word_neon_modified_immediate.go
new file mode 100644
index 000000000..6857ba937
--- /dev/null
+++ b/arm_lower_word_neon_modified_immediate.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONModifiedImmediate struct {
+	kind        string
+	cmode       int
+	invert      bool
+	quad        bool
+	elementBits int
+	destination int
+	imm8        int
+}
+
+// decodeARMRawNEONModifiedImmediate covers A32 Advanced SIMD VMOV/VMVN
+// modified-immediate register forms: i8, i16, i32, i64 byte-mask, and f32
+// bit patterns. Odd cmodes 1..11 belong to VORR/VBIC, not to this family.
+func decodeARMRawNEONModifiedImmediate(word uint32) (armRawNEONModifiedImmediate, bool) {
+	const variable = uint32(0x01000000 | 0x00400000 | 0x00070000 |
+		0x0000f000 | 0x00000f00 | 0x00000040 | 0x00000020 | 0x0000000f)
+	if word&^variable != 0xf2800010 {
+		return armRawNEONModifiedImmediate{}, false
+	}
+	cmode := int(word >> 8 & 15)
+	invert := word>>5&1 != 0
+	form := armRawNEONModifiedImmediate{
+		kind:        "mov",
+		cmode:       cmode,
+		invert:      invert,
+		quad:        word>>6&1 != 0,
+		destination: int(word>>12)&15 | int(word>>22&1)*16,
+		imm8:        int(word>>24&1)*128 | int(word>>16&7)*16 | int(word&15),
+	}
+	switch cmode {
+	case 0, 2, 4, 6, 12, 13:
+		form.elementBits = 32
+	case 8, 10:
+		form.elementBits = 16
+	case 14:
+		form.elementBits = 8
+		if invert {
+			form.elementBits = 64
+		}
+	case 15:
+		if invert {
+			return armRawNEONModifiedImmediate{}, false
+		}
+		form.elementBits = 32
+		form.kind = "float"
+	default:
+		return armRawNEONModifiedImmediate{}, false
+	}
+	if invert && cmode < 14 {
+		form.kind = "mvn"
+	}
+	if form.quad && form.destination&1 != 0 {
+		return armRawNEONModifiedImmediate{}, false
+	}
+	return form, true
+}
+
+func expandARMRawNEONModifiedImmediate(form armRawNEONModifiedImmediate) uint64 {
+	byteValue := uint64(form.imm8)
+	var value uint64
+	switch form.cmode {
+	case 0, 2, 4, 6:
+		value = byteValue << (form.cmode / 2 * 8)
+	case 8, 10:
+		value = byteValue << ((form.cmode - 8) / 2 * 8)
+	case 12:
+		value = byteValue<<8 | 0xff
+	case 13:
+		value = byteValue<<16 | 0xffff
+	case 14:
+		if form.invert {
+			for index := 0; index < 8; index++ {
+				if form.imm8>>index&1 != 0 {
+					value |= uint64(0xff) << (index * 8)
+				}
+			}
+		} else {
+			value = byteValue
+		}
+	case 15:
+		value = expandARMVFPImmediate(uint8(form.imm8), 32)
+	}
+	if form.kind == "mvn" {
+		value = ^value
+	}
+	if form.elementBits < 64 {
+		value &= uint64(1)<<form.elementBits - 1
+	}
+	return value
+}
+
+func (c *armCtx) lowerRawNEONModifiedImmediate(form armRawNEONModifiedImmediate) error {
+	value := expandARMRawNEONModifiedImmediate(form)
+	var signed int64
+	switch form.elementBits {
+	case 8:
+		signed = int64(int8(value))
+	case 16:
+		signed = int64(int16(value))
+	case 32:
+		signed = int64(int32(value))
+	case 64:
+		signed = int64(value)
+	}
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	lanes := 64 / form.elementBits
+	if form.quad {
+		lanes *= 2
+	}
+	constants := make([]string, lanes)
+	for index := range constants {
+		constants[index] = fmt.Sprintf("%s %d", elementType, signed)
+	}
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType,
+		"<"+strings.Join(constants, ", ")+">",
+	)
+}
diff --git a/arm_lower_word_neon_modified_immediate_test.go b/arm_lower_word_neon_modified_immediate_test.go
new file mode 100644
index 000000000..dca613591
--- /dev/null
+++ b/arm_lower_word_neon_modified_immediate_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONModifiedImmediate(cmode int, invert, quad bool, destination, imm8 int) uint32 {
+	word := uint32(0xf2800010 | (imm8>>7)<<24 | ((imm8>>4)&7)<<16 |
+		(destination&15)<<12 | (destination/16)<<22 | cmode<<8 | imm8&15)
+	if invert {
+		word |= 1 << 5
+	}
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONModifiedImmediateLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		cmode       int
+		invert      bool
+		quad        bool
+		destination int
+		imm8        int
+	}{
+		{0xf2810e12, 14, false, false, 0, 0x12},
+		{0xf2810e52, 14, false, true, 0, 0x12},
+		{0xf2810812, 8, false, false, 0, 0x12},
+		{0xf2810a12, 10, false, false, 0, 0x12},
+		{0xf2810012, 0, false, false, 0, 0x12},
+		{0xf2810212, 2, false, false, 0, 0x12},
+		{0xf2810412, 4, false, false, 0, 0x12},
+		{0xf2c0c651, 6, false, true, 28, 0x01},
+		{0xf2810c12, 12, false, false, 0, 0x12},
+		{0xf2810d12, 13, false, false, 0, 0x12},
+		{0xf3820e3a, 14, true, false, 0, 0xaa},
+		{0xf2810032, 0, true, false, 0, 0x12},
+		{0xf2810832, 8, true, false, 0, 0x12},
+		{0xf2870f10, 15, false, false, 0, 0x70},
+	} {
+		got, ok := decodeARMRawNEONModifiedImmediate(test.word)
+		if !ok || got.cmode != test.cmode || got.invert != test.invert ||
+			got.quad != test.quad || got.destination != test.destination || got.imm8 != test.imm8 {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONModifiedImmediate(
+			test.cmode, test.invert, test.quad, test.destination, test.imm8,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONModifiedImmediateAllFields(t *testing.T) {
+	count := 0
+	for _, cmode := range []int{0, 2, 4, 6, 8, 10, 12, 13, 14, 15} {
+		for _, invert := range []bool{false, true} {
+			if cmode == 15 && invert {
+				continue
+			}
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for imm8 := 0; imm8 < 256; imm8++ {
+						word := encodeARMRawNEONModifiedImmediate(
+							cmode, invert, quad, destination, imm8,
+						)
+						got, ok := decodeARMRawNEONModifiedImmediate(word)
+						if !ok || got.cmode != cmode || got.invert != invert ||
+							got.quad != quad || got.destination != destination || got.imm8 != imm8 {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 233472 {
+		t.Fatalf("covered %d VMOV/VMVN immediate forms, want 233472", count)
+	}
+}
+
+func TestTranslateARMRawNEONModifiedImmediateAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawModifiedImmediate(SB), $0-0\n")
+	for _, cmode := range []int{0, 2, 4, 6, 8, 10, 12, 13, 14, 15} {
+		for _, invert := range []bool{false, true} {
+			if cmode == 15 && invert {
+				continue
+			}
+			for _, quad := range []bool{false, true} {
+				word := encodeARMRawNEONModifiedImmediate(cmode, invert, quad, 16, 0x12)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawModifiedImmediate": {Name: "rawModifiedImmediate", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"bitcast <8 x i8>", "bitcast <4 x i16>", "bitcast <2 x i32>",
+		"bitcast <1 x i64>", "bitcast <4 x i32>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMOV/VMVN modified immediate omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-modified-immediate.ll", "arm-raw-neon-modified-immediate.o", ir)
+}
+
+func TestARMRawNEONModifiedImmediateExpandedValues(t *testing.T) {
+	for _, test := range []struct {
+		cmode  int
+		invert bool
+		imm8   int
+		want   uint64
+	}{
+		{0, false, 0x12, 0x00000012},
+		{2, false, 0x12, 0x00001200},
+		{4, false, 0x12, 0x00120000},
+		{6, false, 0x01, 0x01000000},
+		{8, false, 0x12, 0x0012},
+		{10, false, 0x12, 0x1200},
+		{12, false, 0x12, 0x000012ff},
+		{13, false, 0x12, 0x0012ffff},
+		{14, false, 0x12, 0x12},
+		{14, true, 0xaa, 0xff00ff00ff00ff00},
+		{15, false, 0x70, 0x3f800000},
+		{0, true, 0x12, 0xffffffed},
+	} {
+		word := encodeARMRawNEONModifiedImmediate(test.cmode, test.invert, false, 0, test.imm8)
+		form, ok := decodeARMRawNEONModifiedImmediate(word)
+		if !ok {
+			t.Fatalf("encoding %#08x rejected", word)
+		}
+		if got := expandARMRawNEONModifiedImmediate(form); got != test.want {
+			t.Fatalf("encoding %#08x expanded to %#x, want %#x", word, got, test.want)
+		}
+	}
+}
+
+func TestARMRawNEONModifiedImmediateRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONModifiedImmediate(1, false, false, 0, 0x12),
+		encodeARMRawNEONModifiedImmediate(3, true, false, 0, 0x12),
+		encodeARMRawNEONModifiedImmediate(15, true, false, 0, 0x12),
+		encodeARMRawNEONModifiedImmediate(6, false, true, 1, 0x12),
+	} {
+		if _, ok := decodeARMRawNEONModifiedImmediate(word); ok {
+			t.Fatalf("accepted reserved VMOV/VMVN immediate encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_move_long.go b/arm_lower_word_neon_move_long.go
new file mode 100644
index 000000000..38be0cff6
--- /dev/null
+++ b/arm_lower_word_neon_move_long.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMoveLong struct {
+	unsigned    bool
+	elementBits int
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONMoveLong covers the complete A32 VMOVL family: signed and
+// unsigned widening from 8-, 16-, or 32-bit lanes in a D register to a Q
+// register.
+func decodeARMRawNEONMoveLong(word uint32) (armRawNEONMoveLong, bool) {
+	if word&0xfe800fd0 != 0xf2800a10 {
+		return armRawNEONMoveLong{}, false
+	}
+	var elementBits int
+	switch word >> 16 & 0x3f {
+	case 0b001000:
+		elementBits = 8
+	case 0b010000:
+		elementBits = 16
+	case 0b100000:
+		elementBits = 32
+	default:
+		return armRawNEONMoveLong{}, false
+	}
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	if destination&1 != 0 {
+		return armRawNEONMoveLong{}, false
+	}
+	return armRawNEONMoveLong{
+		unsigned:    word>>24&1 != 0,
+		elementBits: elementBits,
+		destination: destination,
+		source:      int(word)&15 | int(word>>5&1)*16,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMoveLong(form armRawNEONMoveLong) error {
+	sourceBits, err := c.loadFReg(armRawVFPBackingReg(form.source, 64))
+	if err != nil {
+		return err
+	}
+	lanes := 64 / form.elementBits
+	wideBits := form.elementBits * 2
+	source := c.newTmp()
+	result := c.newTmp()
+	resultBits := c.newTmp()
+	extend := "sext"
+	if form.unsigned {
+		extend = "zext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <%d x i%d>\n", source, sourceBits, lanes, form.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %%%s to <%d x i%d>\n", result, extend, lanes, form.elementBits, source, lanes, wideBits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to i128\n", resultBits, lanes, wideBits, result)
+	low := c.newTmp()
+	highWide := c.newTmp()
+	high := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", low, resultBits)
+	fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", highWide, resultBits)
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", high, highWide)
+	if err := c.storeFReg(armRawVFPBackingReg(form.destination, 64), "%"+low); err != nil {
+		return err
+	}
+	return c.storeFReg(armRawVFPBackingReg(form.destination+1, 64), "%"+high)
+}
diff --git a/arm_lower_word_neon_move_long_test.go b/arm_lower_word_neon_move_long_test.go
new file mode 100644
index 000000000..f7c06ad32
--- /dev/null
+++ b/arm_lower_word_neon_move_long_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONMoveLong(unsigned bool, elementBits, destination, source int) uint32 {
+	word := uint32(0xf2800a10 | (destination&15)<<12 | source&15)
+	if unsigned {
+		word |= 1 << 24
+	}
+	word |= uint32(destination/16) << 22
+	word |= uint32(map[int]int{8: 0b001000, 16: 0b010000, 32: 0b100000}[elementBits]) << 16
+	word |= uint32(source/16) << 5
+	return word
+}
+
+func TestTranslateARMRawNEONVMOVLGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawMoveLong(SB), $0-0
+	WORD $0xf2902a34 // vmovl.s16 q1, d20
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMoveLong": {Name: "rawMoveLong", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"sext <4 x i16>", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VMOVL IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vmovl.ll", "arm-raw-neon-vmovl.o", ir)
+}
+
+func TestARMRawNEONVMOVLDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for destination := 0; destination < 32; destination += 2 {
+				for source := 0; source < 32; source++ {
+					word := encodeARMRawNEONMoveLong(unsigned, elementBits, destination, source)
+					got, ok := decodeARMRawNEONMoveLong(word)
+					if !ok || got.unsigned != unsigned || got.elementBits != elementBits || got.destination != destination || got.source != source {
+						t.Fatalf("decoded NEON VMOVL %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 3072 {
+		t.Fatalf("covered %d NEON VMOVL encodings, want 3072", count)
+	}
+}
+
+func TestARMRawNEONVMOVLRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONMoveLong(false, 8, 0, 0) &^ (uint32(0x3f) << 16),
+		encodeARMRawNEONMoveLong(false, 8, 0, 0) | 1<<12,
+		encodeARMRawNEONMoveLong(false, 8, 0, 0) | 1<<6,
+	} {
+		if _, ok := decodeARMRawNEONMoveLong(word); ok {
+			t.Fatalf("NEON VMOVL decoder accepted reserved encoding %#08x", word)
+		}
+	}
+
+	const unsignedSource = `TEXT rawUnsignedMoveLong(SB), $0-0
+	WORD $0xf3880a10 // vmovl.u8 q0, d0
+	RET
+`
+	file, err := Parse(ArchARM, unsignedSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawUnsignedMoveLong": {Name: "rawUnsignedMoveLong", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "zext <8 x i8>") {
+		t.Fatalf("unsigned NEON VMOVL omitted zero extension:\n%s", ir)
+	}
+}
diff --git a/arm_lower_word_neon_move_narrow.go b/arm_lower_word_neon_move_narrow.go
new file mode 100644
index 000000000..d683b5a18
--- /dev/null
+++ b/arm_lower_word_neon_move_narrow.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMoveNarrow struct {
+	sourceBits  int
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONMoveNarrow covers every non-saturating A32 VMOVN register
+// form: 16-to-8, 32-to-16, and 64-to-32 narrowing from Q to D.
+func decodeARMRawNEONMoveNarrow(word uint32) (armRawNEONMoveNarrow, bool) {
+	const variable = uint32(0x004cf02f)
+	if word&^variable != 0xf3b20200 {
+		return armRawNEONMoveNarrow{}, false
+	}
+	size := int(word >> 18 & 3)
+	if size == 3 {
+		return armRawNEONMoveNarrow{}, false
+	}
+	source := int(word)&15 | int(word>>5&1)*16
+	if source&1 != 0 {
+		return armRawNEONMoveNarrow{}, false
+	}
+	return armRawNEONMoveNarrow{
+		sourceBits:  16 << size,
+		destination: int(word>>12)&15 | int(word>>22&1)*16,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMoveNarrow(form armRawNEONMoveNarrow) error {
+	sourceType := fmt.Sprintf("i%d", form.sourceBits)
+	resultBits := form.sourceBits / 2
+	resultType := fmt.Sprintf("i%d", resultBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.sourceBits, true, sourceType,
+	)
+	if err != nil {
+		return err
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc <%d x %s> %s to <%d x %s>\n",
+		result, lanes, sourceType, source, lanes, resultType)
+	return c.storeARMRawNEONVector(
+		form.destination, resultBits, false, resultType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_move_narrow_test.go b/arm_lower_word_neon_move_narrow_test.go
new file mode 100644
index 000000000..b74ff67f9
--- /dev/null
+++ b/arm_lower_word_neon_move_narrow_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONMoveNarrow(sourceBits, destination, source int) uint32 {
+	word := uint32(0xf3b20200 | (destination&15)<<12 | (destination/16)<<22 |
+		source&15 | (source/16)<<5)
+	switch sourceBits {
+	case 32:
+		word |= 1 << 18
+	case 64:
+		word |= 2 << 18
+	}
+	return word
+}
+
+func TestARMRawNEONMoveNarrowLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		sourceBits  int
+		destination int
+		source      int
+	}{
+		{0xf3b20202, 16, 0, 2},
+		{0xf3f2f22e, 16, 31, 30},
+		{0xf3b60202, 32, 0, 2},
+		{0xf3f6f22e, 32, 31, 30},
+		{0xf3ba0202, 64, 0, 2},
+		{0xf3fa0220, 64, 16, 16},
+		{0xf3faf22e, 64, 31, 30},
+	} {
+		got, ok := decodeARMRawNEONMoveNarrow(test.word)
+		if !ok || got.sourceBits != test.sourceBits ||
+			got.destination != test.destination || got.source != test.source {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONMoveNarrow(
+			test.sourceBits, test.destination, test.source,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONMoveNarrowAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, sourceBits := range []int{16, 32, 64} {
+		for destination := 0; destination < 32; destination++ {
+			for source := 0; source < 32; source += 2 {
+				word := encodeARMRawNEONMoveNarrow(sourceBits, destination, source)
+				got, ok := decodeARMRawNEONMoveNarrow(word)
+				if !ok || got.sourceBits != sourceBits ||
+					got.destination != destination || got.source != source {
+					t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+				}
+				count++
+			}
+		}
+	}
+	if count != 1536 {
+		t.Fatalf("covered %d VMOVN forms, want 1536", count)
+	}
+}
+
+func TestTranslateARMRawNEONMoveNarrowAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawNarrow(SB), $0-0\n")
+	for _, sourceBits := range []int{16, 32, 64} {
+		word := encodeARMRawNEONMoveNarrow(sourceBits, 16, 16)
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawNarrow": {Name: "rawNarrow", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"trunc <8 x i16>", "trunc <4 x i32>", "trunc <2 x i64>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMOVN omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-movn.ll", "arm-raw-neon-movn.o", ir)
+}
+
+func TestARMRawNEONMoveNarrowRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONMoveNarrow(64, 0, 16)
+	for _, word := range []uint32{
+		base | 1,
+		base ^ 1<<8,
+		base | 1<<18,
+	} {
+		if _, ok := decodeARMRawNEONMoveNarrow(word); ok {
+			t.Fatalf("accepted reserved VMOVN encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_multiply_lane.go b/arm_lower_word_neon_multiply_lane.go
new file mode 100644
index 000000000..f66d4b1e1
--- /dev/null
+++ b/arm_lower_word_neon_multiply_lane.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMultiplyLane struct {
+	floating    bool
+	quad        bool
+	elementBits int
+	destination int
+	lhs         int
+	scalar      int
+	lane        int
+}
+
+// decodeARMRawNEONMultiplyLane covers every LLVM 22 ARMInstrNEON VMUL scalar
+// lane form: integer i16/i32 and floating f16/f32, D and Q destinations. The
+// 16-bit encoding addresses D0..D7 with four lanes; the 32-bit encoding
+// addresses D0..D15 with two lanes.
+func decodeARMRawNEONMultiplyLane(word uint32) (armRawNEONMultiplyLane, bool) {
+	if word&0xfe800e50 != 0xf2800840 {
+		return armRawNEONMultiplyLane{}, false
+	}
+	elementBits := 0
+	switch word >> 20 & 3 {
+	case 1:
+		elementBits = 16
+	case 2:
+		elementBits = 32
+	default:
+		return armRawNEONMultiplyLane{}, false
+	}
+	quad := word>>24&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	lhs := int(word>>16)&15 | int(word>>7&1)*16
+	if quad && (destination&1 != 0 || lhs&1 != 0) {
+		return armRawNEONMultiplyLane{}, false
+	}
+	scalar := int(word) & 15
+	lane := int(word>>5) & 1
+	if elementBits == 16 {
+		scalar &= 7
+		lane = int(word>>3)&1 | int(word>>5&1)*2
+	}
+	return armRawNEONMultiplyLane{
+		floating:    word>>8&1 != 0,
+		quad:        quad,
+		elementBits: elementBits,
+		destination: destination,
+		lhs:         lhs,
+		scalar:      scalar,
+		lane:        lane,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMultiplyLane(form armRawNEONMultiplyLane) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	operation := "mul"
+	if form.floating {
+		elementType = "half"
+		if form.elementBits == 32 {
+			elementType = "float"
+		}
+		operation = "fmul"
+	}
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, form.quad, elementType)
+	if err != nil {
+		return err
+	}
+	scalars, scalarLanes, err := c.loadARMRawNEONVector(form.scalar, form.elementBits, false, elementType)
+	if err != nil {
+		return err
+	}
+	scalar := c.newTmp()
+	inserted := c.newTmp()
+	broadcast := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", scalar, scalarLanes, elementType, scalars, form.lane)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> poison, %s %%%s, i32 0\n", inserted, lanes, elementType, elementType, scalar)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> zeroinitializer\n", broadcast, lanes, elementType, inserted, lanes, elementType, lanes)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s, %%%s\n", result, operation, lanes, elementType, lhs, broadcast)
+	return c.storeARMRawNEONVector(form.destination, form.elementBits, form.quad, elementType, "%"+result)
+}
diff --git a/arm_lower_word_neon_multiply_lane_test.go b/arm_lower_word_neon_multiply_lane_test.go
new file mode 100644
index 000000000..9e2d15f55
--- /dev/null
+++ b/arm_lower_word_neon_multiply_lane_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONMultiplyLane(floating, quad bool, elementBits, destination, lhs, scalar, lane int) uint32 {
+	word := uint32(0xf2800840 | (destination&15)<<12 | (lhs&15)<<16)
+	if floating {
+		word |= 1 << 8
+	}
+	if quad {
+		word |= 1 << 24
+	}
+	word |= uint32(map[int]int{16: 1, 32: 2}[elementBits]) << 20
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	if elementBits == 16 {
+		word |= uint32(scalar & 7)
+		word |= uint32(lane&1) << 3
+		word |= uint32(lane/2) << 5
+	} else {
+		word |= uint32(scalar & 15)
+		word |= uint32(lane) << 5
+	}
+	return word
+}
+
+func TestTranslateARMRawNEONVMULLaneGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawMultiplyLane(SB), $0-0
+	WORD $0xf3a22940 // vmul.f32 q1, q1, d0[0]
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMultiplyLane": {Name: "rawMultiplyLane", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"extractelement <2 x float>", "fmul <4 x float>", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VMUL-by-lane IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vmul-lane.ll", "arm-raw-neon-vmul-lane.o", ir)
+}
+
+func TestARMRawNEONVMULLaneDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, floating := range []bool{false, true} {
+		for _, quad := range []bool{false, true} {
+			step := 1
+			if quad {
+				step = 2
+			}
+			for _, elementBits := range []int{16, 32} {
+				scalarRegisters := 8
+				lanes := 4
+				if elementBits == 32 {
+					scalarRegisters = 16
+					lanes = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for lhs := 0; lhs < 32; lhs += step {
+						for scalar := 0; scalar < scalarRegisters; scalar++ {
+							for lane := 0; lane < lanes; lane++ {
+								word := encodeARMRawNEONMultiplyLane(floating, quad, elementBits, destination, lhs, scalar, lane)
+								got, ok := decodeARMRawNEONMultiplyLane(word)
+								if !ok || got.floating != floating || got.quad != quad || got.elementBits != elementBits || got.destination != destination || got.lhs != lhs || got.scalar != scalar || got.lane != lane {
+									t.Fatalf("decoded NEON VMUL-by-lane %#08x as %+v, ok=%v", word, got, ok)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 163840 {
+		t.Fatalf("covered %d NEON VMUL-by-lane encodings, want 163840", count)
+	}
+}
+
+func TestTranslateARMRawNEONVMULLaneAllFormats(t *testing.T) {
+	source := "TEXT rawMultiplyLaneAll(SB), $0-0\n"
+	for _, test := range []struct {
+		floating    bool
+		quad        bool
+		elementBits int
+	}{
+		{false, false, 16}, {false, true, 16}, {false, false, 32}, {false, true, 32},
+		{true, false, 16}, {true, true, 16}, {true, false, 32}, {true, true, 32},
+	} {
+		word := encodeARMRawNEONMultiplyLane(test.floating, test.quad, test.elementBits, 0, 2, 1, 1)
+		source += fmt.Sprintf("\tWORD $%#08x\n", word)
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMultiplyLaneAll": {Name: "rawMultiplyLaneAll", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"mul <4 x i16>", "mul <4 x i32>", "fmul <4 x half>", "fmul <4 x float>", "+fullfp16", "+neon"} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VMUL-by-lane formats omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vmul-lane-all.ll", "arm-raw-neon-vmul-lane-all.o", ir)
+}
+
+func TestARMRawNEONVMULLaneRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONMultiplyLane(false, false, 16, 0, 0, 0, 0) &^ (uint32(3) << 20),
+		encodeARMRawNEONMultiplyLane(false, true, 16, 0, 0, 0, 0) | 1<<12,
+		encodeARMRawNEONMultiplyLane(false, true, 16, 0, 0, 0, 0) | 1<<16,
+		encodeARMRawNEONMultiplyLane(false, false, 16, 0, 0, 0, 0) | 1<<4,
+	} {
+		if _, ok := decodeARMRawNEONMultiplyLane(word); ok {
+			t.Fatalf("NEON VMUL-by-lane decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_multiply_long_lane.go b/arm_lower_word_neon_multiply_long_lane.go
new file mode 100644
index 000000000..f2647a1ec
--- /dev/null
+++ b/arm_lower_word_neon_multiply_long_lane.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMultiplyLongLane struct {
+	kind        string
+	unsigned    bool
+	elementBits int
+	destination int
+	lhs         int
+	scalar      int
+	lane        int
+}
+
+// decodeARMRawNEONMultiplyLongLane covers A32 VMULL/VMLAL/VMLSL signed and
+// unsigned 16-/32-bit scalar-lane forms. Every form widens a D-register
+// product into an even-numbered D pair representing a Q destination.
+func decodeARMRawNEONMultiplyLongLane(word uint32) (armRawNEONMultiplyLongLane, bool) {
+	kind := ""
+	switch word & 0xfe800e50 {
+	case 0xf2800a40:
+		kind = "mul"
+	case 0xf2800240:
+		kind = "mla"
+	case 0xf2800640:
+		kind = "mls"
+	default:
+		return armRawNEONMultiplyLongLane{}, false
+	}
+	encodedSize := int(word >> 20 & 3)
+	if encodedSize != 1 && encodedSize != 2 {
+		return armRawNEONMultiplyLongLane{}, false
+	}
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	if destination&1 != 0 {
+		return armRawNEONMultiplyLongLane{}, false
+	}
+	scalar := int(word) & 15
+	lane := int(word>>5) & 1
+	if encodedSize == 1 {
+		scalar &= 7
+		lane = int(word>>3)&1 | int(word>>5&1)*2
+	}
+	return armRawNEONMultiplyLongLane{
+		kind:        kind,
+		unsigned:    word>>24&1 != 0,
+		elementBits: 8 << encodedSize,
+		destination: destination,
+		lhs:         int(word>>16)&15 | int(word>>7&1)*16,
+		scalar:      scalar,
+		lane:        lane,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMultiplyLongLane(form armRawNEONMultiplyLongLane) error {
+	narrowType := fmt.Sprintf("i%d", form.elementBits)
+	wideBits := form.elementBits * 2
+	wideType := fmt.Sprintf("i%d", wideBits)
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, false, narrowType)
+	if err != nil {
+		return err
+	}
+	scalars, scalarLanes, err := c.loadARMRawNEONVector(form.scalar, form.elementBits, false, narrowType)
+	if err != nil {
+		return err
+	}
+	extend := "sext"
+	if form.unsigned {
+		extend = "zext"
+	}
+	lhsWide := c.newTmp()
+	scalar := c.newTmp()
+	scalarWide := c.newTmp()
+	inserted := c.newTmp()
+	broadcast := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s to <%d x %s>\n",
+		lhsWide, extend, lanes, narrowType, lhs, lanes, wideType)
+	fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n",
+		scalar, scalarLanes, narrowType, scalars, form.lane)
+	fmt.Fprintf(c.b, "  %%%s = %s %s %%%s to %s\n",
+		scalarWide, extend, narrowType, scalar, wideType)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> poison, %s %%%s, i32 0\n",
+		inserted, lanes, wideType, wideType, scalarWide)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %%%s, <%d x %s> poison, <%d x i32> zeroinitializer\n",
+		broadcast, lanes, wideType, inserted, lanes, wideType, lanes)
+	return c.lowerARMRawNEONWideningProduct(
+		form.kind, form.elementBits, form.destination, "%"+lhsWide, "%"+broadcast,
+	)
+}
+
+func (c *armCtx) lowerARMRawNEONWideningProduct(
+	kind string, elementBits, destination int, lhsWide, rhsWide string,
+) error {
+	lanes := 64 / elementBits
+	wideBits := elementBits * 2
+	wideType := fmt.Sprintf("i%d", wideBits)
+	product := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = mul <%d x %s> %s, %s\n",
+		product, lanes, wideType, lhsWide, rhsWide)
+	result := "%" + product
+	if kind != "mul" {
+		accumulator, _, err := c.loadARMRawNEONVector(
+			destination, wideBits, true, wideType,
+		)
+		if err != nil {
+			return err
+		}
+		operation := "add"
+		if kind == "mls" {
+			operation = "sub"
+		}
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s, %%%s\n",
+			combined, operation, lanes, wideType, accumulator, product)
+		result = "%" + combined
+	}
+	return c.storeARMRawNEONVector(
+		destination, wideBits, true, wideType, result,
+	)
+}
diff --git a/arm_lower_word_neon_multiply_long_lane_test.go b/arm_lower_word_neon_multiply_long_lane_test.go
new file mode 100644
index 000000000..3c69c2486
--- /dev/null
+++ b/arm_lower_word_neon_multiply_long_lane_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONMultiplyLongLane(unsigned bool, elementBits, destination, lhs, scalar, lane int) uint32 {
+	word := uint32(0xf2800a40 | (destination&15)<<12 | (lhs&15)<<16)
+	if unsigned {
+		word |= 1 << 24
+	}
+	if elementBits == 16 {
+		word |= 1 << 20
+		word |= uint32(scalar & 7)
+		word |= uint32(lane&1) << 3
+		word |= uint32(lane/2) << 5
+	} else {
+		word |= 2 << 20
+		word |= uint32(scalar & 15)
+		word |= uint32(lane) << 5
+	}
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	return word
+}
+
+func encodeARMRawNEONWideningMultiplyLane(kind string, unsigned bool, elementBits, destination, lhs, scalar, lane int) uint32 {
+	word := encodeARMRawNEONMultiplyLongLane(unsigned, elementBits, destination, lhs, scalar, lane)
+	switch kind {
+	case "mla":
+		return word&^0xf00 | 0x200
+	case "mls":
+		return word&^0xf00 | 0x600
+	default:
+		return word
+	}
+}
+
+func TestARMRawNEONWideningMultiplyLaneAccumulateLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		kind        string
+		unsigned    bool
+		elementBits int
+		destination int
+		lhs         int
+		scalar      int
+		lane        int
+	}{
+		{0xf2910242, "mla", false, 16, 0, 1, 2, 0},
+		{0xf3910242, "mla", true, 16, 0, 1, 2, 0},
+		{0xf2a10242, "mla", false, 32, 0, 1, 2, 0},
+		{0xf3a7a262, "mla", true, 32, 10, 7, 2, 1},
+		{0xf2910642, "mls", false, 16, 0, 1, 2, 0},
+		{0xf3910642, "mls", true, 16, 0, 1, 2, 0},
+		{0xf2a10642, "mls", false, 32, 0, 1, 2, 0},
+		{0xf3a10642, "mls", true, 32, 0, 1, 2, 0},
+	} {
+		got, ok := decodeARMRawNEONMultiplyLongLane(test.word)
+		if !ok || got.kind != test.kind || got.unsigned != test.unsigned ||
+			got.elementBits != test.elementBits || got.destination != test.destination ||
+			got.lhs != test.lhs || got.scalar != test.scalar || got.lane != test.lane {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONWideningMultiplyLane(
+			test.kind, test.unsigned, test.elementBits, test.destination,
+			test.lhs, test.scalar, test.lane,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestTranslateARMRawNEONWideningMultiplyLaneAccumulateLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawWideningMultiplyAccumulate(SB), $0-0\n")
+	for _, kind := range []string{"mla", "mls"} {
+		for _, unsigned := range []bool{false, true} {
+			for _, elementBits := range []int{16, 32} {
+				word := encodeARMRawNEONWideningMultiplyLane(
+					kind, unsigned, elementBits, 10, 2, 0, 1,
+				)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawWideningMultiplyAccumulate": {Name: "rawWideningMultiplyAccumulate", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{"mul <4 x i32>", "mul <2 x i64>", "add <4 x i32>", "sub <2 x i64>"} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMLAL/VMLSL omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vmlal-vmlsl.ll", "arm-raw-neon-vmlal-vmlsl.o", ir)
+}
+
+func TestARMRawNEONMultiplyLongLaneLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		unsigned    bool
+		elementBits int
+		destination int
+		lhs         int
+		scalar      int
+		lane        int
+	}{
+		{0xf2910a42, false, 16, 0, 1, 2, 0},
+		{0xf2dfeaef, false, 16, 30, 31, 7, 3},
+		{0xf3910a42, true, 16, 0, 1, 2, 0},
+		{0xf3dfeaef, true, 16, 30, 31, 7, 3},
+		{0xf2a10a42, false, 32, 0, 1, 2, 0},
+		{0xf2efeaef, false, 32, 30, 31, 15, 1},
+		{0xf3a10a42, true, 32, 0, 1, 2, 0},
+		{0xf3efeaef, true, 32, 30, 31, 15, 1},
+		{0xf3a0aa60, true, 32, 10, 0, 0, 1},
+	} {
+		got, ok := decodeARMRawNEONMultiplyLongLane(test.word)
+		if !ok || got.unsigned != test.unsigned || got.elementBits != test.elementBits ||
+			got.destination != test.destination || got.lhs != test.lhs ||
+			got.scalar != test.scalar || got.lane != test.lane {
+			t.Fatalf("LLVM 22 VMULL lane encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONMultiplyLongLane(
+			test.unsigned, test.elementBits, test.destination, test.lhs, test.scalar, test.lane,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONMultiplyLongLaneAllFields(t *testing.T) {
+	count := 0
+	for _, kind := range []string{"mul", "mla", "mls"} {
+		for _, unsigned := range []bool{false, true} {
+			for _, elementBits := range []int{16, 32} {
+				scalarRegisters, lanes := 8, 4
+				if elementBits == 32 {
+					scalarRegisters, lanes = 16, 2
+				}
+				for destination := 0; destination < 32; destination += 2 {
+					for lhs := 0; lhs < 32; lhs++ {
+						for scalar := 0; scalar < scalarRegisters; scalar++ {
+							for lane := 0; lane < lanes; lane++ {
+								word := encodeARMRawNEONWideningMultiplyLane(
+									kind, unsigned, elementBits, destination, lhs, scalar, lane,
+								)
+								got, ok := decodeARMRawNEONMultiplyLongLane(word)
+								if !ok || got.kind != kind || got.unsigned != unsigned || got.elementBits != elementBits ||
+									got.destination != destination || got.lhs != lhs ||
+									got.scalar != scalar || got.lane != lane {
+									t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 196608 {
+		t.Fatalf("covered %d VMULL/VMLAL/VMLSL lane forms, want 196608", count)
+	}
+}
+
+func TestTranslateARMRawNEONMultiplyLongLaneAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawVMULLLane(SB), $0-0\n")
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{16, 32} {
+			word := encodeARMRawNEONMultiplyLongLane(unsigned, elementBits, 10, 2, 0, 1)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawVMULLLane": {Name: "rawVMULLLane", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"sext <4 x i16>", "zext <4 x i16>", "mul <4 x i32>",
+		"sext <2 x i32>", "zext <2 x i32>", "mul <2 x i64>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMULL lane omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vmull-lane.ll", "arm-raw-neon-vmull-lane.o", ir)
+}
+
+func TestARMRawNEONMultiplyLongLaneRejectsReservedForms(t *testing.T) {
+	base := encodeARMRawNEONMultiplyLongLane(true, 32, 0, 0, 0, 0)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base &^ (3 << 20),
+		base | 1<<4,
+		base ^ 1<<9,
+	} {
+		if _, ok := decodeARMRawNEONMultiplyLongLane(word); ok {
+			t.Fatalf("accepted reserved VMULL lane encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_multiply_long_vector.go b/arm_lower_word_neon_multiply_long_vector.go
new file mode 100644
index 000000000..6faf4946f
--- /dev/null
+++ b/arm_lower_word_neon_multiply_long_vector.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONMultiplyLongVector struct {
+	kind        string
+	unsigned    bool
+	elementBits int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONMultiplyLongVector covers every signed and unsigned A32
+// VMULL/VMLAL/VMLSL register form, for 8-, 16-, and 32-bit D-register lanes.
+func decodeARMRawNEONMultiplyLongVector(word uint32) (armRawNEONMultiplyLongVector, bool) {
+	kind := ""
+	switch word & 0xfe800f50 {
+	case 0xf2800c00:
+		kind = "mul"
+	case 0xf2800800:
+		kind = "mla"
+	case 0xf2800a00:
+		kind = "mls"
+	default:
+		return armRawNEONMultiplyLongVector{}, false
+	}
+	size := int(word >> 20 & 3)
+	if size == 3 {
+		return armRawNEONMultiplyLongVector{}, false
+	}
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	if destination&1 != 0 {
+		return armRawNEONMultiplyLongVector{}, false
+	}
+	return armRawNEONMultiplyLongVector{
+		kind:        kind,
+		unsigned:    word>>24&1 != 0,
+		elementBits: 8 << size,
+		destination: destination,
+		lhs:         int(word>>16)&15 | int(word>>7&1)*16,
+		rhs:         int(word)&15 | int(word>>5&1)*16,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONMultiplyLongVector(form armRawNEONMultiplyLongVector) error {
+	narrowType := fmt.Sprintf("i%d", form.elementBits)
+	wideType := fmt.Sprintf("i%d", form.elementBits*2)
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, false, narrowType)
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, form.elementBits, false, narrowType)
+	if err != nil {
+		return err
+	}
+	extend := "sext"
+	if form.unsigned {
+		extend = "zext"
+	}
+	lhsWide := c.newTmp()
+	rhsWide := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s to <%d x %s>\n",
+		lhsWide, extend, lanes, narrowType, lhs, lanes, wideType)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s to <%d x %s>\n",
+		rhsWide, extend, lanes, narrowType, rhs, lanes, wideType)
+	return c.lowerARMRawNEONWideningProduct(
+		form.kind, form.elementBits, form.destination, "%"+lhsWide, "%"+rhsWide,
+	)
+}
diff --git a/arm_lower_word_neon_multiply_long_vector_test.go b/arm_lower_word_neon_multiply_long_vector_test.go
new file mode 100644
index 000000000..80d1a6b23
--- /dev/null
+++ b/arm_lower_word_neon_multiply_long_vector_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONMultiplyLongVector(kind string, unsigned bool, elementBits, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf2800c00 | (destination&15)<<12 | (lhs&15)<<16 | rhs&15)
+	switch kind {
+	case "mla":
+		word &^= 0x400
+	case "mls":
+		word &^= 0x400
+		word |= 0x200
+	}
+	if unsigned {
+		word |= 1 << 24
+	}
+	word |= uint32(map[int]int{8: 0, 16: 1, 32: 2}[elementBits]) << 20
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	word |= uint32(rhs/16) << 5
+	return word
+}
+
+func TestARMRawNEONMultiplyLongVectorLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		kind        string
+		unsigned    bool
+		elementBits int
+		destination int
+		lhs         int
+		rhs         int
+	}{
+		{0xf2810c02, "mul", false, 8, 0, 1, 2},
+		{0xf3810c02, "mul", true, 8, 0, 1, 2},
+		{0xf2910c02, "mul", false, 16, 0, 1, 2},
+		{0xf3910c02, "mul", true, 16, 0, 1, 2},
+		{0xf2a10c02, "mul", false, 32, 0, 1, 2},
+		{0xf3a9ec80, "mul", true, 32, 14, 25, 0},
+		{0xf2810802, "mla", false, 8, 0, 1, 2},
+		{0xf3810802, "mla", true, 8, 0, 1, 2},
+		{0xf2910802, "mla", false, 16, 0, 1, 2},
+		{0xf3910802, "mla", true, 16, 0, 1, 2},
+		{0xf2a10802, "mla", false, 32, 0, 1, 2},
+		{0xf3a10802, "mla", true, 32, 0, 1, 2},
+		{0xf2810a02, "mls", false, 8, 0, 1, 2},
+		{0xf3810a02, "mls", true, 8, 0, 1, 2},
+		{0xf2910a02, "mls", false, 16, 0, 1, 2},
+		{0xf3910a02, "mls", true, 16, 0, 1, 2},
+		{0xf2a10a02, "mls", false, 32, 0, 1, 2},
+		{0xf3a10a02, "mls", true, 32, 0, 1, 2},
+	} {
+		got, ok := decodeARMRawNEONMultiplyLongVector(test.word)
+		if !ok || got.kind != test.kind || got.unsigned != test.unsigned ||
+			got.elementBits != test.elementBits || got.destination != test.destination ||
+			got.lhs != test.lhs || got.rhs != test.rhs {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONMultiplyLongVector(
+			test.kind, test.unsigned, test.elementBits, test.destination, test.lhs, test.rhs,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONMultiplyLongVectorAllFields(t *testing.T) {
+	count := 0
+	for _, kind := range []string{"mul", "mla", "mls"} {
+		for _, unsigned := range []bool{false, true} {
+			for _, elementBits := range []int{8, 16, 32} {
+				for destination := 0; destination < 32; destination += 2 {
+					for lhs := 0; lhs < 32; lhs++ {
+						for rhs := 0; rhs < 32; rhs++ {
+							word := encodeARMRawNEONMultiplyLongVector(
+								kind, unsigned, elementBits, destination, lhs, rhs,
+							)
+							got, ok := decodeARMRawNEONMultiplyLongVector(word)
+							if !ok || got.kind != kind || got.unsigned != unsigned ||
+								got.elementBits != elementBits || got.destination != destination ||
+								got.lhs != lhs || got.rhs != rhs {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 294912 {
+		t.Fatalf("covered %d VMULL/VMLAL/VMLSL vector forms, want 294912", count)
+	}
+}
+
+func TestTranslateARMRawNEONMultiplyLongVectorLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawWideningMultiplyVector(SB), $0-0\n")
+	for _, kind := range []string{"mul", "mla", "mls"} {
+		for _, unsigned := range []bool{false, true} {
+			for _, elementBits := range []int{8, 16, 32} {
+				word := encodeARMRawNEONMultiplyLongVector(kind, unsigned, elementBits, 10, 2, 4)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawWideningMultiplyVector": {Name: "rawWideningMultiplyVector", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"mul <8 x i16>", "mul <4 x i32>", "mul <2 x i64>",
+		"add <8 x i16>", "sub <2 x i64>", "sext <8 x i8>", "zext <8 x i8>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VMULL/VMLAL/VMLSL omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-multiply-long-vector.ll", "arm-raw-neon-multiply-long-vector.o", ir)
+}
+
+func TestARMRawNEONMultiplyLongVectorRejectsReservedForms(t *testing.T) {
+	base := encodeARMRawNEONMultiplyLongVector("mul", false, 8, 0, 0, 0)
+	for _, word := range []uint32{
+		base | 3<<20,
+		base | 1<<12,
+		base | 1<<4,
+		base | 1<<6,
+	} {
+		if _, ok := decodeARMRawNEONMultiplyLongVector(word); ok {
+			t.Fatalf("accepted reserved multiply-long vector encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_pairwise_minmax.go b/arm_lower_word_neon_pairwise_minmax.go
new file mode 100644
index 000000000..e1a2b95fa
--- /dev/null
+++ b/arm_lower_word_neon_pairwise_minmax.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONPairwiseMinMax struct {
+	minimum     bool
+	floating    bool
+	unsigned    bool
+	elementBits int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONPairwiseMinMax covers every classic A32 VPMAX/VPMIN form
+// in LLVM 22's ARMInstrNEON.td: signed and unsigned 8/16/32-bit integers plus
+// 16/32-bit floating point. Pairwise forms operate only on D registers.
+func decodeARMRawNEONPairwiseMinMax(word uint32) (armRawNEONPairwiseMinMax, bool) {
+	// N3VDInt fixes 31:25=1111001, bit 23=0, and bit 6=0.
+	if word&0xfe800040 != 0xf2000000 {
+		return armRawNEONPairwiseMinMax{}, false
+	}
+	op := int(word>>8) & 15
+	size := int(word>>20) & 3
+	minimum := false
+	floating := false
+	unsigned := false
+	elementBits := 0
+	switch op {
+	case 0b1010:
+		if size == 3 {
+			return armRawNEONPairwiseMinMax{}, false
+		}
+		minimum = word>>4&1 != 0
+		unsigned = word>>24&1 != 0
+		elementBits = 8 << size
+	case 0b1111:
+		if word>>24&1 == 0 || word>>4&1 != 0 {
+			return armRawNEONPairwiseMinMax{}, false
+		}
+		floating = true
+		minimum = size >= 2
+		if size&1 == 0 {
+			elementBits = 32
+		} else {
+			elementBits = 16
+		}
+	default:
+		return armRawNEONPairwiseMinMax{}, false
+	}
+	return armRawNEONPairwiseMinMax{
+		minimum:     minimum,
+		floating:    floating,
+		unsigned:    unsigned,
+		elementBits: elementBits,
+		destination: int(word>>12)&15 | int(word>>22&1)*16,
+		lhs:         int(word>>16)&15 | int(word>>7&1)*16,
+		rhs:         int(word)&15 | int(word>>5&1)*16,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONPairwiseMinMax(form armRawNEONPairwiseMinMax) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	if form.floating {
+		elementType = "half"
+		if form.elementBits == 32 {
+			elementType = "float"
+		}
+	}
+	lhs, lanes, err := c.loadARMRawNEONVector(form.lhs, form.elementBits, false, elementType)
+	if err != nil {
+		return err
+	}
+	rhs, _, err := c.loadARMRawNEONVector(form.rhs, form.elementBits, false, elementType)
+	if err != nil {
+		return err
+	}
+	result := "poison"
+	for destinationLane := 0; destinationLane < lanes; destinationLane++ {
+		source := lhs
+		sourceLane := destinationLane * 2
+		if destinationLane >= lanes/2 {
+			source = rhs
+			sourceLane = (destinationLane - lanes/2) * 2
+		}
+		first := c.newTmp()
+		second := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", first, lanes, elementType, source, sourceLane)
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n", second, lanes, elementType, source, sourceLane+1)
+		selected := c.newTmp()
+		if form.floating {
+			operation := "maximum"
+			if form.minimum {
+				operation = "minimum"
+			}
+			fmt.Fprintf(c.b, "  %%%s = call %s @llvm.%s.f%d(%s %%%s, %s %%%s)\n", selected, elementType, operation, form.elementBits, elementType, first, elementType, second)
+		} else {
+			predicate := "sgt"
+			if form.unsigned {
+				predicate = "ugt"
+			}
+			if form.minimum {
+				predicate = "slt"
+				if form.unsigned {
+					predicate = "ult"
+				}
+			}
+			condition := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = icmp %s %s %%%s, %%%s\n", condition, predicate, elementType, first, second)
+			fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, %s %%%s, %s %%%s\n", selected, condition, elementType, first, elementType, second)
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n", inserted, lanes, elementType, result, elementType, selected, destinationLane)
+		result = "%" + inserted
+	}
+	return c.storeARMRawNEONVector(form.destination, form.elementBits, false, elementType, result)
+}
diff --git a/arm_lower_word_neon_pairwise_minmax_test.go b/arm_lower_word_neon_pairwise_minmax_test.go
new file mode 100644
index 000000000..a32f5c5de
--- /dev/null
+++ b/arm_lower_word_neon_pairwise_minmax_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawNEONVPMAXGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawPairwiseMaximum(SB), $0-0
+	WORD $0xf3004f01 // vpmax.f32 d4, d0, d1
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawPairwiseMaximum": {Name: "rawPairwiseMaximum", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "@llvm.maximum.f32") {
+		t.Fatalf("raw NEON VPMAX.F32 IR omitted maximum intrinsic:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vpmax.ll", "arm-raw-neon-vpmax.o", ir)
+}
+
+func encodeARMRawNEONPairwiseMinMax(minimum, floating, unsigned bool, elementBits, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf2000000 | (destination&15)<<12 | (lhs&15)<<16 | rhs&15)
+	word |= uint32(destination/16) << 22
+	word |= uint32(lhs/16) << 7
+	word |= uint32(rhs/16) << 5
+	if floating {
+		word |= 1 << 24
+		word |= 0b1111 << 8
+		size := 0
+		if elementBits == 16 {
+			size = 1
+		}
+		if minimum {
+			size += 2
+		}
+		word |= uint32(size) << 20
+	} else {
+		word |= 0b1010 << 8
+		word |= uint32(map[int]int{8: 0, 16: 1, 32: 2}[elementBits]) << 20
+		if unsigned {
+			word |= 1 << 24
+		}
+		if minimum {
+			word |= 1 << 4
+		}
+	}
+	return word
+}
+
+func TestARMRawNEONPairwiseMinMaxDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, floating := range []bool{false, true} {
+		for _, minimum := range []bool{false, true} {
+			unsignedValues := []bool{false, true}
+			elementSizes := []int{8, 16, 32}
+			if floating {
+				unsignedValues = []bool{false}
+				elementSizes = []int{16, 32}
+			}
+			for _, unsigned := range unsignedValues {
+				for _, elementBits := range elementSizes {
+					for destination := 0; destination < 32; destination++ {
+						for lhs := 0; lhs < 32; lhs++ {
+							for rhs := 0; rhs < 32; rhs++ {
+								word := encodeARMRawNEONPairwiseMinMax(minimum, floating, unsigned, elementBits, destination, lhs, rhs)
+								got, ok := decodeARMRawNEONPairwiseMinMax(word)
+								if !ok || got.minimum != minimum || got.floating != floating || got.unsigned != unsigned || got.elementBits != elementBits || got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+									t.Fatalf("decoded NEON pairwise min/max %#08x as %+v, ok=%v", word, got, ok)
+								}
+								count++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 524288 {
+		t.Fatalf("covered %d NEON pairwise min/max encodings, want 524288", count)
+	}
+}
+
+func TestTranslateARMRawNEONPairwiseMinMaxAllFormats(t *testing.T) {
+	source := "TEXT rawPairwiseMinMaxAll(SB), $0-0\n"
+	for _, minimum := range []bool{false, true} {
+		for _, unsigned := range []bool{false, true} {
+			for _, bits := range []int{8, 16, 32} {
+				source += fmt.Sprintf("\tWORD $%#08x\n", encodeARMRawNEONPairwiseMinMax(minimum, false, unsigned, bits, 0, 1, 2))
+			}
+		}
+		for _, bits := range []int{16, 32} {
+			source += fmt.Sprintf("\tWORD $%#08x\n", encodeARMRawNEONPairwiseMinMax(minimum, true, false, bits, 0, 1, 2))
+		}
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawPairwiseMinMaxAll": {Name: "rawPairwiseMinMaxAll", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"icmp sgt i8", "icmp ugt i16", "icmp slt i32", "icmp ult i8", "@llvm.maximum.f16", "@llvm.maximum.f32", "@llvm.minimum.f16", "@llvm.minimum.f32", "+fullfp16", "+neon"} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON pairwise min/max formats omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-pairwise-minmax-all.ll", "arm-raw-neon-pairwise-minmax-all.o", ir)
+}
+
+func TestARMRawNEONPairwiseMinMaxRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONPairwiseMinMax(false, false, false, 8, 0, 0, 0) | 3<<20,
+		encodeARMRawNEONPairwiseMinMax(false, true, false, 32, 0, 0, 0) &^ (1 << 24),
+		encodeARMRawNEONPairwiseMinMax(false, true, false, 32, 0, 0, 0) | 1<<4,
+		encodeARMRawNEONPairwiseMinMax(false, false, false, 8, 0, 0, 0) | 1<<6,
+	} {
+		if _, ok := decodeARMRawNEONPairwiseMinMax(word); ok {
+			t.Fatalf("NEON pairwise min/max decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_reverse.go b/arm_lower_word_neon_reverse.go
new file mode 100644
index 000000000..b94caeb3c
--- /dev/null
+++ b/arm_lower_word_neon_reverse.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONReverse struct {
+	blockBits   int
+	elementBits int
+	quad        bool
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONReverse covers A32 VREV16.8, VREV32.8/.16, and
+// VREV64.8/.16/.32 for both D and Q registers. Invalid equal-width and
+// reserved register encodings are rejected.
+func decodeARMRawNEONReverse(word uint32) (armRawNEONReverse, bool) {
+	const variable = uint32(0x00400000 | 0x000c0000 | 0x0000f000 |
+		0x00000180 | 0x00000060 | 0x0000000f)
+	if word&^variable != 0xf3b00000 {
+		return armRawNEONReverse{}, false
+	}
+	blockBits := 64
+	switch word >> 7 & 3 {
+	case 1:
+		blockBits = 32
+	case 2:
+		blockBits = 16
+	case 3:
+		return armRawNEONReverse{}, false
+	}
+	elementBits := 8 << (word >> 18 & 3)
+	if elementBits >= blockBits {
+		return armRawNEONReverse{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	source := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || source&1 != 0) {
+		return armRawNEONReverse{}, false
+	}
+	return armRawNEONReverse{
+		blockBits:   blockBits,
+		elementBits: elementBits,
+		quad:        quad,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONReverse(form armRawNEONReverse) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	blockLanes := form.blockBits / form.elementBits
+	indices := make([]string, lanes)
+	for lane := range indices {
+		blockStart := lane / blockLanes * blockLanes
+		index := blockStart + blockLanes - 1 - lane%blockLanes
+		indices[lane] = fmt.Sprintf("i32 %d", index)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b,
+		"  %%%s = shufflevector <%d x %s> %s, <%d x %s> poison, <%d x i32> <%s>\n",
+		result, lanes, elementType, source, lanes, elementType, lanes, strings.Join(indices, ", "),
+	)
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_reverse_test.go b/arm_lower_word_neon_reverse_test.go
new file mode 100644
index 000000000..0d7bbb2ce
--- /dev/null
+++ b/arm_lower_word_neon_reverse_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONReverse(blockBits, elementBits, destination, source int, quad bool) uint32 {
+	word := uint32(0xf3b00000 | (destination&15)<<12 | (destination/16)<<22 |
+		source&15 | (source/16)<<5)
+	if quad {
+		word |= 1 << 6
+	}
+	switch blockBits {
+	case 16:
+		word |= 1 << 8
+	case 32:
+		word |= 1 << 7
+	}
+	switch elementBits {
+	case 16:
+		word |= 1 << 18
+	case 32:
+		word |= 1 << 19
+	}
+	return word
+}
+
+func TestARMRawNEONReverseLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		blockBits   int
+		elementBits int
+		destination int
+		source      int
+		quad        bool
+	}{
+		{0xf3b00101, 16, 8, 0, 1, false},
+		{0xf3b00142, 16, 8, 0, 2, true},
+		{0xf3b00081, 32, 8, 0, 1, false},
+		{0xf3b460c6, 32, 16, 6, 6, true},
+		{0xf3b00001, 64, 8, 0, 1, false},
+		{0xf3b40001, 64, 16, 0, 1, false},
+		{0xf3b80001, 64, 32, 0, 1, false},
+		{0xf3f4e0e0, 32, 16, 30, 16, true},
+	} {
+		got, ok := decodeARMRawNEONReverse(test.word)
+		if !ok || got.blockBits != test.blockBits || got.elementBits != test.elementBits ||
+			got.destination != test.destination || got.source != test.source || got.quad != test.quad {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONReverse(
+			test.blockBits, test.elementBits, test.destination, test.source, test.quad,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONReverseAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, blockBits := range []int{16, 32, 64} {
+		for elementBits := 8; elementBits < blockBits; elementBits *= 2 {
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for destination := 0; destination < 32; destination += step {
+					for source := 0; source < 32; source += step {
+						word := encodeARMRawNEONReverse(blockBits, elementBits, destination, source, quad)
+						got, ok := decodeARMRawNEONReverse(word)
+						if !ok || got.blockBits != blockBits || got.elementBits != elementBits ||
+							got.destination != destination || got.source != source || got.quad != quad {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 7680 {
+		t.Fatalf("covered %d VREV forms, want 7680", count)
+	}
+}
+
+func TestTranslateARMRawNEONReverseAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawReverse(SB), $0-0\n")
+	for _, blockBits := range []int{16, 32, 64} {
+		for elementBits := 8; elementBits < blockBits; elementBits *= 2 {
+			for _, quad := range []bool{false, true} {
+				word := encodeARMRawNEONReverse(blockBits, elementBits, 6, 8, quad)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawReverse": {Name: "rawReverse", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"shufflevector <8 x i8>", "shufflevector <16 x i8>",
+		"shufflevector <4 x i16>", "shufflevector <8 x i16>",
+		"shufflevector <2 x i32>", "shufflevector <4 x i32>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VREV omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-reverse.ll", "arm-raw-neon-reverse.o", ir)
+}
+
+func TestARMRawNEONReverseRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONReverse(32, 16, 6, 8, true)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1,
+		base | 1<<8,
+		encodeARMRawNEONReverse(16, 16, 0, 2, false),
+		encodeARMRawNEONReverse(32, 32, 0, 2, false),
+	} {
+		if _, ok := decodeARMRawNEONReverse(word); ok {
+			t.Fatalf("accepted reserved VREV encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_shift_immediate.go b/arm_lower_word_neon_shift_immediate.go
new file mode 100644
index 000000000..0c117eb59
--- /dev/null
+++ b/arm_lower_word_neon_shift_immediate.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONShiftImmediate struct {
+	elementBits int
+	shift       int
+	quad        bool
+	destination int
+	source      int
+}
+
+// Classic A32 VSHL immediate has one D/Q encoding for each 8-, 16-, 32-,
+// and 64-bit element width. The highest set bit of imm7 selects the width;
+// the remaining bits are the immediate shift. Signed and unsigned spellings
+// have identical left-shift semantics and the same encoding.
+func decodeARMRawNEONShiftImmediate(word uint32) (armRawNEONShiftImmediate, bool) {
+	const variable = uint32(0x007ff0ef)
+	const base = uint32(0xf2800510)
+	if word&^variable != base {
+		return armRawNEONShiftImmediate{}, false
+	}
+	imm7 := int(word>>16&0x3f) | int(word>>7&1)<<6
+	if imm7 < 8 {
+		return armRawNEONShiftImmediate{}, false
+	}
+	elementBits := 8
+	for elementBits*2 <= imm7 {
+		elementBits *= 2
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	source := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || source&1 != 0) {
+		return armRawNEONShiftImmediate{}, false
+	}
+	return armRawNEONShiftImmediate{
+		elementBits: elementBits,
+		shift:       imm7 - elementBits,
+		quad:        quad,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONShiftImmediate(form armRawNEONShiftImmediate) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	counts := make([]string, lanes)
+	for index := range counts {
+		counts[index] = fmt.Sprintf("%s %d", elementType, form.shift)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shl <%d x %s> %s, <%s>\n",
+		result, lanes, elementType, source, strings.Join(counts, ", "))
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_shift_immediate_test.go b/arm_lower_word_neon_shift_immediate_test.go
new file mode 100644
index 000000000..ca5d02366
--- /dev/null
+++ b/arm_lower_word_neon_shift_immediate_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONShiftImmediate(elementBits, shift, destination, source int, quad bool) uint32 {
+	imm7 := elementBits + shift
+	word := uint32(0xf2800510 | (imm7&0x3f)<<16 | (imm7>>6)<<7 |
+		(destination&15)<<12 | (destination/16)<<22 | source&15 | (source/16)<<5)
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestTranslateARMRawNEONShiftImmediateWireGuardRegression(t *testing.T) {
+	const source = `TEXT rawNEONShift(SB), $0-0
+	WORD $0xf2e1a538
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs:         map[string]FuncSig{"rawNEONShift": {Name: "rawNEONShift", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "shl <2 x i32>") {
+		t.Fatalf("raw ARM VSHL.I32 omitted per-lane shift:\n%s", ir)
+	}
+}
+
+func TestARMRawNEONShiftImmediateLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		elementBits int
+		shift       int
+		destination int
+		source      int
+		quad        bool
+	}{
+		{0xf28b1512, 8, 3, 1, 2, false},
+		{0xf2951512, 16, 5, 1, 2, false},
+		{0xf2a11512, 32, 1, 1, 2, false},
+		{0xf2a51592, 64, 37, 1, 2, false},
+		{0xf28f6558, 8, 7, 6, 8, true},
+		{0xf29f6558, 16, 15, 6, 8, true},
+		{0xf2bf6558, 32, 31, 6, 8, true},
+		{0xf2bf65d8, 64, 63, 6, 8, true},
+		{0xf2e1a538, 32, 1, 26, 24, false},
+	} {
+		got, ok := decodeARMRawNEONShiftImmediate(test.word)
+		if !ok || got.elementBits != test.elementBits || got.shift != test.shift ||
+			got.destination != test.destination || got.source != test.source || got.quad != test.quad {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONShiftImmediate(
+			test.elementBits, test.shift, test.destination, test.source, test.quad,
+		); encoded != test.word {
+			t.Fatalf("form %+v encoded as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONShiftImmediateAllFields(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, quad := range []bool{false, true} {
+			step := 1
+			if quad {
+				step = 2
+			}
+			for _, shift := range []int{0, elementBits / 2, elementBits - 1} {
+				for destination := 0; destination < 32; destination += step {
+					for source := 0; source < 32; source += step {
+						word := encodeARMRawNEONShiftImmediate(
+							elementBits, shift, destination, source, quad,
+						)
+						got, ok := decodeARMRawNEONShiftImmediate(word)
+						if !ok || got.elementBits != elementBits || got.shift != shift ||
+							got.quad != quad || got.destination != destination || got.source != source {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 15360 {
+		t.Fatalf("covered %d VSHL immediate encodings, want 15360", count)
+	}
+}
+
+func TestTranslateARMRawNEONShiftImmediateAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawNEONShiftFamily(SB), $0-0\n")
+	for _, elementBits := range []int{8, 16, 32, 64} {
+		for _, quad := range []bool{false, true} {
+			word := encodeARMRawNEONShiftImmediate(elementBits, elementBits-1, 0, 2, quad)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: triple,
+		Sigs:         map[string]FuncSig{"rawNEONShiftFamily": {Name: "rawNEONShiftFamily", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"shl <8 x i8>", "shl <16 x i8>", "shl <4 x i16>", "shl <8 x i16>",
+		"shl <2 x i32>", "shl <4 x i32>", "shl <1 x i64>", "shl <2 x i64>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("VSHL immediate family IR omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-neon-vshl-immediate.ll", "arm-neon-vshl-immediate.o", ir)
+}
+
+func TestARMRawNEONShiftImmediateRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONShiftImmediate(16, 5, 0, 2, false)
+	for _, word := range []uint32{
+		0xf2800510 | 7<<16,
+		base &^ (1 << 4),
+		base | 1<<24,
+		encodeARMRawNEONShiftImmediate(16, 5, 1, 2, true),
+		encodeARMRawNEONShiftImmediate(16, 5, 0, 3, true),
+	} {
+		if _, ok := decodeARMRawNEONShiftImmediate(word); ok {
+			t.Fatalf("accepted reserved VSHL immediate encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_shift_insert.go b/arm_lower_word_neon_shift_insert.go
new file mode 100644
index 000000000..a6f151ed5
--- /dev/null
+++ b/arm_lower_word_neon_shift_insert.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONShiftInsert struct {
+	left        bool
+	quad        bool
+	elementBits int
+	shift       int
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONShiftInsert covers A32 VSLI and VSRI immediate forms for
+// 8-, 16-, 32-, and 64-bit elements, both D/Q widths, and every legal shift.
+func decodeARMRawNEONShiftInsert(word uint32) (armRawNEONShiftInsert, bool) {
+	const variable = uint32(0x007ff0ef)
+	left := false
+	switch word &^ variable {
+	case 0xf3800510:
+		left = true
+	case 0xf3800410:
+	default:
+		return armRawNEONShiftInsert{}, false
+	}
+	imm7 := int(word>>16&0x3f) | int(word>>7&1)<<6
+	if imm7 < 8 {
+		return armRawNEONShiftInsert{}, false
+	}
+	elementBits := 8
+	for elementBits*2 <= imm7 {
+		elementBits *= 2
+	}
+	shift := imm7 - elementBits
+	if !left {
+		shift = 2*elementBits - imm7
+	}
+	if left && (shift < 0 || shift >= elementBits) ||
+		!left && (shift < 1 || shift > elementBits) {
+		return armRawNEONShiftInsert{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	source := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || source&1 != 0) {
+		return armRawNEONShiftInsert{}, false
+	}
+	return armRawNEONShiftInsert{
+		left:        left,
+		quad:        quad,
+		elementBits: elementBits,
+		shift:       shift,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONShiftInsert(form armRawNEONShiftInsert) error {
+	if !form.left && form.shift == form.elementBits {
+		return nil
+	}
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	destination, _, err := c.loadARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	operation := "lshr"
+	mask := ^uint64(0) << (form.elementBits - form.shift)
+	if form.left {
+		operation = "shl"
+		mask = uint64(1)<<form.shift - 1
+	}
+	if form.elementBits < 64 {
+		mask &= uint64(1)<<form.elementBits - 1
+	}
+	counts := make([]string, lanes)
+	masks := make([]string, lanes)
+	for index := range counts {
+		counts[index] = fmt.Sprintf("%s %d", elementType, form.shift)
+		masks[index] = fmt.Sprintf("%s %d", elementType, int64(mask))
+	}
+	shifted := c.newTmp()
+	kept := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s, <%s>\n",
+		shifted, operation, lanes, elementType, source, strings.Join(counts, ", "))
+	fmt.Fprintf(c.b, "  %%%s = and <%d x %s> %s, <%s>\n",
+		kept, lanes, elementType, destination, strings.Join(masks, ", "))
+	fmt.Fprintf(c.b, "  %%%s = or <%d x %s> %%%s, %%%s\n",
+		result, lanes, elementType, kept, shifted)
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_shift_insert_test.go b/arm_lower_word_neon_shift_insert_test.go
new file mode 100644
index 000000000..a3508290c
--- /dev/null
+++ b/arm_lower_word_neon_shift_insert_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONShiftInsert(left, quad bool, elementBits, shift, destination, source int) uint32 {
+	imm7 := elementBits + shift
+	word := uint32(0xf3800410)
+	if left {
+		word |= 1 << 8
+	} else {
+		imm7 = 2*elementBits - shift
+	}
+	word |= uint32((imm7&0x3f)<<16 | (imm7>>6)<<7 |
+		(destination&15)<<12 | (destination/16)<<22 |
+		source&15 | (source/16)<<5)
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONShiftInsertLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		left        bool
+		quad        bool
+		elementBits int
+		shift       int
+		destination int
+		source      int
+	}{
+		{0xf3880511, true, false, 8, 0, 0, 1},
+		{0xf38f0511, true, false, 8, 7, 0, 1},
+		{0xf3930552, true, true, 16, 3, 0, 2},
+		{0xf3ac2578, true, true, 32, 12, 2, 24},
+		{0xf3bf05d2, true, true, 64, 63, 0, 2},
+		{0xf38f0411, false, false, 8, 1, 0, 1},
+		{0xf3880411, false, false, 8, 8, 0, 1},
+		{0xf39d0452, false, true, 16, 3, 0, 2},
+		{0xf3b42478, false, true, 32, 12, 2, 24},
+		{0xf38004d2, false, true, 64, 64, 0, 2},
+	} {
+		got, ok := decodeARMRawNEONShiftInsert(test.word)
+		if !ok || got.left != test.left || got.quad != test.quad ||
+			got.elementBits != test.elementBits || got.shift != test.shift ||
+			got.destination != test.destination || got.source != test.source {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONShiftInsert(
+			test.left, test.quad, test.elementBits, test.shift,
+			test.destination, test.source,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONShiftInsertAllFields(t *testing.T) {
+	count := 0
+	for _, left := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			shifts := []int{1, elementBits / 2, elementBits}
+			if left {
+				shifts = []int{0, elementBits / 2, elementBits - 1}
+			}
+			for _, shift := range shifts {
+				for _, quad := range []bool{false, true} {
+					step := 1
+					if quad {
+						step = 2
+					}
+					for destination := 0; destination < 32; destination += step {
+						for source := 0; source < 32; source += step {
+							word := encodeARMRawNEONShiftInsert(
+								left, quad, elementBits, shift, destination, source,
+							)
+							got, ok := decodeARMRawNEONShiftInsert(word)
+							if !ok || got.left != left || got.quad != quad ||
+								got.elementBits != elementBits || got.shift != shift ||
+								got.destination != destination || got.source != source {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 30720 {
+		t.Fatalf("covered %d VSLI/VSRI forms, want 30720", count)
+	}
+}
+
+func TestTranslateARMRawNEONShiftInsertAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawInsert(SB), $0-0\n")
+	for _, left := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			for _, quad := range []bool{false, true} {
+				shift := elementBits / 2
+				word := encodeARMRawNEONShiftInsert(left, quad, elementBits, shift, 0, 2)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawInsert": {Name: "rawInsert", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"shl <8 x i8>", "lshr <8 x i8>",
+		"shl <4 x i16>", "lshr <4 x i16>",
+		"shl <2 x i32>", "lshr <2 x i32>",
+		"shl <1 x i64>", "lshr <1 x i64>",
+		"and <2 x i32>", "or <2 x i32>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VSLI/VSRI omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-shift-insert.ll", "arm-raw-neon-shift-insert.o", ir)
+}
+
+func TestARMRawNEONShiftInsertRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONShiftInsert(true, true, 32, 12, 0, 2)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1,
+		base ^ 1<<9,
+		0xf3800510,
+	} {
+		if _, ok := decodeARMRawNEONShiftInsert(word); ok {
+			t.Fatalf("accepted reserved VSLI/VSRI encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_shift_right_immediate.go b/arm_lower_word_neon_shift_right_immediate.go
new file mode 100644
index 000000000..a8ba28027
--- /dev/null
+++ b/arm_lower_word_neon_shift_right_immediate.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONShiftRightImmediate struct {
+	unsigned    bool
+	quad        bool
+	elementBits int
+	shift       int
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONShiftRightImmediate covers A32 VSHR.S/U immediate forms
+// for 8-, 16-, 32-, and 64-bit elements in D and Q registers. The immediate
+// range includes a full-element shift, whose unsigned result is zero.
+func decodeARMRawNEONShiftRightImmediate(word uint32) (armRawNEONShiftRightImmediate, bool) {
+	const variable = uint32(0x017ff0ef)
+	const base = uint32(0xf2800010)
+	if word&^variable != base {
+		return armRawNEONShiftRightImmediate{}, false
+	}
+	imm7 := int(word>>16&0x3f) | int(word>>7&1)<<6
+	if imm7 < 8 {
+		return armRawNEONShiftRightImmediate{}, false
+	}
+	elementBits := 8
+	for elementBits*2 <= imm7 {
+		elementBits *= 2
+	}
+	shift := 2*elementBits - imm7
+	if shift < 1 || shift > elementBits {
+		return armRawNEONShiftRightImmediate{}, false
+	}
+	quad := word>>6&1 != 0
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	source := int(word)&15 | int(word>>5&1)*16
+	if quad && (destination&1 != 0 || source&1 != 0) {
+		return armRawNEONShiftRightImmediate{}, false
+	}
+	return armRawNEONShiftRightImmediate{
+		unsigned:    word>>24&1 != 0,
+		quad:        quad,
+		elementBits: elementBits,
+		shift:       shift,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONShiftRightImmediate(form armRawNEONShiftRightImmediate) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	if form.unsigned && form.shift == form.elementBits {
+		return c.storeARMRawNEONVector(
+			form.destination, form.elementBits, form.quad, elementType, "zeroinitializer",
+		)
+	}
+	operation := "ashr"
+	if form.unsigned {
+		operation = "lshr"
+	}
+	shift := form.shift
+	if shift == form.elementBits {
+		shift--
+	}
+	counts := make([]string, lanes)
+	for index := range counts {
+		counts[index] = fmt.Sprintf("%s %d", elementType, shift)
+	}
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x %s> %s, <%s>\n",
+		result, operation, lanes, elementType, source, strings.Join(counts, ", "))
+	return c.storeARMRawNEONVector(
+		form.destination, form.elementBits, form.quad, elementType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_shift_right_immediate_test.go b/arm_lower_word_neon_shift_right_immediate_test.go
new file mode 100644
index 000000000..bcd261d91
--- /dev/null
+++ b/arm_lower_word_neon_shift_right_immediate_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONShiftRightImmediate(unsigned, quad bool, elementBits, shift, destination, source int) uint32 {
+	imm7 := 2*elementBits - shift
+	word := uint32(0xf2800010 | (imm7&0x3f)<<16 | (imm7>>6)<<7 |
+		(destination&15)<<12 | (destination/16)<<22 |
+		source&15 | (source/16)<<5)
+	if unsigned {
+		word |= 1 << 24
+	}
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONShiftRightImmediateLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		unsigned    bool
+		quad        bool
+		elementBits int
+		shift       int
+		destination int
+		source      int
+	}{
+		{0xf28f0011, false, false, 8, 1, 0, 1},
+		{0xf29b0011, false, false, 16, 5, 0, 1},
+		{0xf2ac0011, false, false, 32, 20, 0, 1},
+		{0xf2a60091, false, false, 64, 26, 0, 1},
+		{0xf38f0011, true, false, 8, 1, 0, 1},
+		{0xf39b0011, true, false, 16, 5, 0, 1},
+		{0xf3ac2078, true, true, 32, 20, 2, 24},
+		{0xf3e6e0f0, true, true, 64, 26, 30, 16},
+		{0xf3a00011, true, false, 32, 32, 0, 1},
+		{0xf3800091, true, false, 64, 64, 0, 1},
+		{0xf3880052, true, true, 8, 8, 0, 2},
+		{0xf2a00052, false, true, 32, 32, 0, 2},
+	} {
+		got, ok := decodeARMRawNEONShiftRightImmediate(test.word)
+		if !ok || got.unsigned != test.unsigned || got.quad != test.quad ||
+			got.elementBits != test.elementBits || got.shift != test.shift ||
+			got.destination != test.destination || got.source != test.source {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONShiftRightImmediate(
+			test.unsigned, test.quad, test.elementBits, test.shift,
+			test.destination, test.source,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONShiftRightImmediateAllFields(t *testing.T) {
+	count := 0
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			for _, shift := range []int{1, elementBits / 2, elementBits} {
+				for _, quad := range []bool{false, true} {
+					step := 1
+					if quad {
+						step = 2
+					}
+					for destination := 0; destination < 32; destination += step {
+						for source := 0; source < 32; source += step {
+							word := encodeARMRawNEONShiftRightImmediate(
+								unsigned, quad, elementBits, shift, destination, source,
+							)
+							got, ok := decodeARMRawNEONShiftRightImmediate(word)
+							if !ok || got.unsigned != unsigned || got.quad != quad ||
+								got.elementBits != elementBits || got.shift != shift ||
+								got.destination != destination || got.source != source {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 30720 {
+		t.Fatalf("covered %d VSHR forms, want 30720", count)
+	}
+}
+
+func TestTranslateARMRawNEONShiftRightImmediateAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawVSHR(SB), $0-0\n")
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32, 64} {
+			for _, shift := range []int{elementBits / 2, elementBits} {
+				for _, quad := range []bool{false, true} {
+					word := encodeARMRawNEONShiftRightImmediate(
+						unsigned, quad, elementBits, shift, 0, 2,
+					)
+					fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+				}
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawVSHR": {Name: "rawVSHR", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"ashr <8 x i8>", "lshr <8 x i8>",
+		"ashr <4 x i16>", "lshr <4 x i16>",
+		"ashr <2 x i32>", "lshr <2 x i32>",
+		"ashr <1 x i64>", "lshr <1 x i64>",
+		"zeroinitializer",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VSHR omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vshr.ll", "arm-raw-neon-vshr.o", ir)
+}
+
+func TestARMRawNEONShiftRightImmediateRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONShiftRightImmediate(true, true, 32, 20, 0, 2)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1,
+		base ^ 1<<8,
+		0xf2800010,
+	} {
+		if _, ok := decodeARMRawNEONShiftRightImmediate(word); ok {
+			t.Fatalf("accepted reserved VSHR encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_shift_right_narrow.go b/arm_lower_word_neon_shift_right_narrow.go
new file mode 100644
index 000000000..2eb934436
--- /dev/null
+++ b/arm_lower_word_neon_shift_right_narrow.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONShiftRightNarrow struct {
+	sourceBits  int
+	shift       int
+	destination int
+	source      int
+}
+
+// decodeARMRawNEONShiftRightNarrow covers all non-saturating A32 VSHRN
+// immediate forms: i16-to-i8, i32-to-i16, and i64-to-i32, with shifts 1
+// through the destination element width and all D/Q register fields.
+func decodeARMRawNEONShiftRightNarrow(word uint32) (armRawNEONShiftRightNarrow, bool) {
+	const variable = uint32(0x007ff02f)
+	if word&^variable != 0xf2800810 {
+		return armRawNEONShiftRightNarrow{}, false
+	}
+	imm6 := int(word >> 16 & 0x3f)
+	if imm6 < 8 {
+		return armRawNEONShiftRightNarrow{}, false
+	}
+	resultBits := 8
+	for resultBits*2 <= imm6 {
+		resultBits *= 2
+	}
+	if resultBits > 32 {
+		return armRawNEONShiftRightNarrow{}, false
+	}
+	sourceBits := resultBits * 2
+	shift := sourceBits - imm6
+	if shift < 1 || shift > resultBits {
+		return armRawNEONShiftRightNarrow{}, false
+	}
+	source := int(word)&15 | int(word>>5&1)*16
+	if source&1 != 0 {
+		return armRawNEONShiftRightNarrow{}, false
+	}
+	return armRawNEONShiftRightNarrow{
+		sourceBits:  sourceBits,
+		shift:       shift,
+		destination: int(word>>12)&15 | int(word>>22&1)*16,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONShiftRightNarrow(form armRawNEONShiftRightNarrow) error {
+	sourceType := fmt.Sprintf("i%d", form.sourceBits)
+	resultBits := form.sourceBits / 2
+	resultType := fmt.Sprintf("i%d", resultBits)
+	source, lanes, err := c.loadARMRawNEONVector(
+		form.source, form.sourceBits, true, sourceType,
+	)
+	if err != nil {
+		return err
+	}
+	counts := make([]string, lanes)
+	for index := range counts {
+		counts[index] = fmt.Sprintf("%s %d", sourceType, form.shift)
+	}
+	shifted := c.newTmp()
+	result := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = lshr <%d x %s> %s, <%s>\n",
+		shifted, lanes, sourceType, source, strings.Join(counts, ", "))
+	fmt.Fprintf(c.b, "  %%%s = trunc <%d x %s> %%%s to <%d x %s>\n",
+		result, lanes, sourceType, shifted, lanes, resultType)
+	return c.storeARMRawNEONVector(
+		form.destination, resultBits, false, resultType, "%"+result,
+	)
+}
diff --git a/arm_lower_word_neon_shift_right_narrow_test.go b/arm_lower_word_neon_shift_right_narrow_test.go
new file mode 100644
index 000000000..efbf34e6b
--- /dev/null
+++ b/arm_lower_word_neon_shift_right_narrow_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONShiftRightNarrow(sourceBits, shift, destination, source int) uint32 {
+	imm6 := sourceBits - shift
+	return uint32(0xf2800810 | imm6<<16 | (destination&15)<<12 |
+		(destination/16)<<22 | source&15 | (source/16)<<5)
+}
+
+func TestARMRawNEONShiftRightNarrowLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		sourceBits  int
+		shift       int
+		destination int
+		source      int
+	}{
+		{0xf28f0812, 16, 1, 0, 2},
+		{0xf2880812, 16, 8, 0, 2},
+		{0xf29f0812, 32, 1, 0, 2},
+		{0xf2900812, 32, 16, 0, 2},
+		{0xf2bf0812, 64, 1, 0, 2},
+		{0xf2e6e832, 64, 26, 30, 18},
+		{0xf2a00812, 64, 32, 0, 2},
+	} {
+		got, ok := decodeARMRawNEONShiftRightNarrow(test.word)
+		if !ok || got.sourceBits != test.sourceBits || got.shift != test.shift ||
+			got.destination != test.destination || got.source != test.source {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONShiftRightNarrow(
+			test.sourceBits, test.shift, test.destination, test.source,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONShiftRightNarrowAllFields(t *testing.T) {
+	count := 0
+	for _, sourceBits := range []int{16, 32, 64} {
+		for _, shift := range []int{1, sourceBits / 4, sourceBits / 2} {
+			for destination := 0; destination < 32; destination++ {
+				for source := 0; source < 32; source += 2 {
+					word := encodeARMRawNEONShiftRightNarrow(sourceBits, shift, destination, source)
+					got, ok := decodeARMRawNEONShiftRightNarrow(word)
+					if !ok || got.sourceBits != sourceBits || got.shift != shift ||
+						got.destination != destination || got.source != source {
+						t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 4608 {
+		t.Fatalf("covered %d VSHRN forms, want 4608", count)
+	}
+}
+
+func TestTranslateARMRawNEONShiftRightNarrowAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawShiftNarrow(SB), $0-0\n")
+	for _, sourceBits := range []int{16, 32, 64} {
+		for _, shift := range []int{1, sourceBits / 2} {
+			word := encodeARMRawNEONShiftRightNarrow(sourceBits, shift, 16, 18)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawShiftNarrow": {Name: "rawShiftNarrow", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"lshr <8 x i16>", "trunc <8 x i16>",
+		"lshr <4 x i32>", "trunc <4 x i32>",
+		"lshr <2 x i64>", "trunc <2 x i64>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VSHRN omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vshrn.ll", "arm-raw-neon-vshrn.o", ir)
+}
+
+func TestARMRawNEONShiftRightNarrowRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONShiftRightNarrow(64, 26, 0, 18)
+	for _, word := range []uint32{
+		base | 1,
+		base ^ 1<<8,
+		base | 1<<7,
+		0xf2800810,
+	} {
+		if _, ok := decodeARMRawNEONShiftRightNarrow(word); ok {
+			t.Fatalf("accepted reserved VSHRN encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_structure.go b/arm_lower_word_neon_structure.go
new file mode 100644
index 000000000..3257e100e
--- /dev/null
+++ b/arm_lower_word_neon_structure.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import "fmt"
+
+// armRawNEONStructureOne describes the A32 Advanced SIMD VLD1/VST1
+// "multiple single elements" encoding. Each transfer moves one to four
+// consecutive 64-bit D registers without interleaving their elements.
+type armRawNEONStructureOne struct {
+	load        bool
+	base        int
+	offset      int
+	first       int
+	count       int
+	elementBits int
+	alignment   int
+}
+
+// decodeARMRawNEONStructureOne covers every VLD1/VST1 multiple-single-element
+// form described by LLVM's ARMInstrNEON.td VLD1D/VLD1Q/VLD1D3/VLD1D4 and the
+// corresponding VST1 classes. offset 15 means no writeback; offset 13 selects
+// fixed writeback by the transfer size; every other value is a register
+// post-index.
+func decodeARMRawNEONStructureOne(word uint32) (armRawNEONStructureOne, bool) {
+	// 11110100 D L 0 Rn Vd type size align Rm
+	if word&0xff900000 != 0xf4000000 {
+		return armRawNEONStructureOne{}, false
+	}
+
+	typeField := int(word>>8) & 15
+	count := 0
+	maxAlignmentCode := 0
+	switch typeField {
+	case 0b0111:
+		count = 1
+		maxAlignmentCode = 1 // omitted or 64-bit
+	case 0b1010:
+		count = 2
+		maxAlignmentCode = 2 // omitted, 64-bit, or 128-bit
+	case 0b0110:
+		count = 3
+		maxAlignmentCode = 1 // omitted or 64-bit
+	case 0b0010:
+		count = 4
+		maxAlignmentCode = 3 // omitted, 64-, 128-, or 256-bit
+	default:
+		return armRawNEONStructureOne{}, false
+	}
+
+	alignmentCode := int(word>>4) & 3
+	if alignmentCode > maxAlignmentCode {
+		return armRawNEONStructureOne{}, false
+	}
+	first := int(word>>12)&15 | int(word>>22&1)*16
+	if first+count > 32 {
+		return armRawNEONStructureOne{}, false
+	}
+	alignment := 0
+	if alignmentCode != 0 {
+		alignment = 4 << alignmentCode // 1,2,3 encode 8,16,32 bytes.
+	}
+	return armRawNEONStructureOne{
+		load:        word>>21&1 != 0,
+		base:        int(word>>16) & 15,
+		offset:      int(word) & 15,
+		first:       first,
+		count:       count,
+		elementBits: 8 << (word >> 6 & 3),
+		alignment:   alignment,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONStructureOne(form armRawNEONStructureOne) error {
+	if form.base == 15 {
+		return fmt.Errorf("arm NEON VLD1/VST1 cannot safely use PC as its base")
+	}
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	alignment := form.alignment
+	if alignment == 0 {
+		alignment = 1
+	}
+	for i := 0; i < form.count; i++ {
+		address := base
+		if offset := i * 8; offset != 0 {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", adjusted, base, offset)
+			address = "%" + adjusted
+		}
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, address)
+		register := armRawVFPBackingReg(form.first+i, 64)
+		if form.load {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load i64, ptr %%%s, align %d\n", value, pointer, alignment)
+			if err := c.storeFReg(register, "%"+value); err != nil {
+				return err
+			}
+			continue
+		}
+		value, err := c.loadFReg(register)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i64 %s, ptr %%%s, align %d\n", value, pointer, alignment)
+	}
+
+	if form.offset == 15 {
+		return nil
+	}
+	increment := ""
+	if form.offset == 13 {
+		increment = fmt.Sprintf("%d", form.count*8)
+	} else {
+		increment, err = c.loadReg(Reg(fmt.Sprintf("R%d", form.offset)))
+		if err != nil {
+			return err
+		}
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", updated, base, increment)
+	return c.storeReg(baseReg, "%"+updated)
+}
diff --git a/arm_lower_word_neon_structure_four_lane.go b/arm_lower_word_neon_structure_four_lane.go
new file mode 100644
index 000000000..1e23243e8
--- /dev/null
+++ b/arm_lower_word_neon_structure_four_lane.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONStructureLane struct {
+	load        bool
+	elementBits int
+	lane        int
+	first       int
+	stride      int
+	base        int
+	offset      int
+	alignment   int
+}
+
+// decodeARMRawNEONStructureFourLane covers A32 VLD4/VST4 one-lane forms for
+// 8-, 16-, and 32-bit elements, including register spacing, all legal lane
+// and alignment fields, and no/fixed/register post-index addressing.
+func decodeARMRawNEONStructureFourLane(word uint32) (armRawNEONStructureLane, bool) {
+	if word&0xff900000 != 0xf4800000 {
+		return armRawNEONStructureLane{}, false
+	}
+	form := armRawNEONStructureLane{
+		load:   word>>21&1 != 0,
+		first:  int(word>>12)&15 | int(word>>22&1)*16,
+		stride: 1,
+		base:   int(word>>16) & 15,
+		offset: int(word) & 15,
+	}
+	switch word >> 8 & 15 {
+	case 3:
+		form.elementBits = 8
+		form.lane = int(word >> 5 & 7)
+		if word>>4&1 != 0 {
+			form.alignment = 4
+		}
+	case 7:
+		form.elementBits = 16
+		form.lane = int(word >> 6 & 3)
+		if word>>5&1 != 0 {
+			form.stride = 2
+		}
+		if word>>4&1 != 0 {
+			form.alignment = 8
+		}
+	case 11:
+		form.elementBits = 32
+		form.lane = int(word >> 7 & 1)
+		if word>>6&1 != 0 {
+			form.stride = 2
+		}
+		switch word >> 4 & 3 {
+		case 0:
+		case 1:
+			form.alignment = 8
+		case 2:
+			form.alignment = 16
+		default:
+			return armRawNEONStructureLane{}, false
+		}
+	default:
+		return armRawNEONStructureLane{}, false
+	}
+	if form.first+3*form.stride >= 32 {
+		return armRawNEONStructureLane{}, false
+	}
+	return form, true
+}
+
+func (c *armCtx) lowerRawNEONStructureFourLane(form armRawNEONStructureLane) error {
+	return c.lowerRawNEONStructureLane(form, 4)
+}
+
+func (c *armCtx) lowerRawNEONStructureLane(form armRawNEONStructureLane, count int) error {
+	if form.base == 15 {
+		return fmt.Errorf("arm NEON VLD4/VST4 lane cannot safely use PC as its base")
+	}
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	elementBytes := form.elementBits / 8
+	for index := 0; index < count; index++ {
+		address := base
+		byteOffset := index * elementBytes
+		if byteOffset != 0 {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", adjusted, base, byteOffset)
+			address = "%" + adjusted
+		}
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, address)
+		alignment := form.alignment
+		if alignment == 0 {
+			alignment = 1
+		}
+		for alignment > 1 && byteOffset%alignment != 0 {
+			alignment /= 2
+		}
+		register := form.first + index*form.stride
+		vector, lanes, err := c.loadARMRawNEONVector(register, form.elementBits, false, elementType)
+		if err != nil {
+			return err
+		}
+		if form.load {
+			value := c.newTmp()
+			updated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load %s, ptr %%%s, align %d\n", value, elementType, pointer, alignment)
+			fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n",
+				updated, lanes, elementType, vector, elementType, value, form.lane)
+			if err := c.storeARMRawNEONVector(
+				register, form.elementBits, false, elementType, "%"+updated,
+			); err != nil {
+				return err
+			}
+			continue
+		}
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n",
+			value, lanes, elementType, vector, form.lane)
+		fmt.Fprintf(c.b, "  store %s %%%s, ptr %%%s, align %d\n",
+			elementType, value, pointer, alignment)
+	}
+	if form.offset == 15 {
+		return nil
+	}
+	increment := fmt.Sprintf("%d", count*elementBytes)
+	if form.offset != 13 {
+		increment, err = c.loadReg(Reg(fmt.Sprintf("R%d", form.offset)))
+		if err != nil {
+			return err
+		}
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", updated, base, increment)
+	return c.storeReg(baseReg, "%"+updated)
+}
diff --git a/arm_lower_word_neon_structure_four_lane_test.go b/arm_lower_word_neon_structure_four_lane_test.go
new file mode 100644
index 000000000..742c09dbe
--- /dev/null
+++ b/arm_lower_word_neon_structure_four_lane_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONStructureFourLane(load bool, elementBits, lane, first, stride, base, offset, alignment int) uint32 {
+	word := uint32(0xf4800000 | base<<16 | (first&15)<<12 | (first/16)<<22 | offset)
+	if load {
+		word |= 1 << 21
+	}
+	switch elementBits {
+	case 8:
+		word |= 3 << 8
+		word |= uint32(lane) << 5
+		if alignment == 4 {
+			word |= 1 << 4
+		}
+	case 16:
+		word |= 7 << 8
+		word |= uint32(lane) << 6
+		if stride == 2 {
+			word |= 1 << 5
+		}
+		if alignment == 8 {
+			word |= 1 << 4
+		}
+	case 32:
+		word |= 11 << 8
+		word |= uint32(lane) << 7
+		if stride == 2 {
+			word |= 1 << 6
+		}
+		switch alignment {
+		case 8:
+			word |= 1 << 4
+		case 16:
+			word |= 2 << 4
+		}
+	}
+	return word
+}
+
+func TestARMRawNEONStructureFourLaneLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		load        bool
+		elementBits int
+		lane        int
+		first       int
+		stride      int
+		base        int
+		offset      int
+		alignment   int
+	}{
+		{0xf486030f, false, 8, 0, 0, 1, 6, 15, 0},
+		{0xf48603ed, false, 8, 7, 0, 1, 6, 13, 0},
+		{0xf4a6030f, true, 8, 0, 0, 1, 6, 15, 0},
+		{0xf486070f, false, 16, 0, 0, 1, 6, 15, 0},
+		{0xf48607cd, false, 16, 3, 0, 1, 6, 13, 0},
+		{0xf486072d, false, 16, 0, 0, 2, 6, 13, 0},
+		{0xf4860b0d, false, 32, 0, 0, 1, 6, 13, 0},
+		{0xf4870b8d, false, 32, 1, 0, 1, 7, 13, 0},
+		{0xf4a60b0d, true, 32, 0, 0, 1, 6, 13, 0},
+		{0xf4860b4d, false, 32, 0, 0, 2, 6, 13, 0},
+		{0xf4c6cb8d, false, 32, 1, 28, 1, 6, 13, 0},
+	} {
+		got, ok := decodeARMRawNEONStructureFourLane(test.word)
+		if !ok || got.load != test.load || got.elementBits != test.elementBits ||
+			got.lane != test.lane || got.first != test.first || got.stride != test.stride ||
+			got.base != test.base || got.offset != test.offset || got.alignment != test.alignment {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONStructureFourLane(
+			test.load, test.elementBits, test.lane, test.first,
+			test.stride, test.base, test.offset, test.alignment,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONStructureFourLaneAllFields(t *testing.T) {
+	count := 0
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			strides := []int{1, 2}
+			alignments := []int{0, 8}
+			if elementBits == 8 {
+				strides = []int{1}
+				alignments = []int{0, 4}
+			} else if elementBits == 32 {
+				alignments = []int{0, 8, 16}
+			}
+			for _, stride := range strides {
+				for _, alignment := range alignments {
+					for lane := 0; lane < 64/elementBits; lane++ {
+						for first := 0; first+3*stride < 32; first++ {
+							word := encodeARMRawNEONStructureFourLane(
+								load, elementBits, lane, first, stride, 6, 13, alignment,
+							)
+							got, ok := decodeARMRawNEONStructureFourLane(word)
+							if !ok || got.load != load || got.elementBits != elementBits ||
+								got.lane != lane || got.first != first || got.stride != stride ||
+								got.base != 6 || got.offset != 13 || got.alignment != alignment {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count == 0 {
+		t.Fatal("covered no VLD4/VST4 lane forms")
+	}
+}
+
+func TestTranslateARMRawNEONStructureFourLaneLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawStructureFour(SB), $0-0\n")
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for _, stride := range []int{1, 2} {
+				if elementBits == 8 && stride == 2 {
+					continue
+				}
+				word := encodeARMRawNEONStructureFourLane(
+					load, elementBits, 0, 0, stride, 6, 13, 0,
+				)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawStructureFour": {Name: "rawStructureFour", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"load i8, ptr", "store i8", "load i16, ptr", "store i16",
+		"load i32, ptr", "store i32", "insertelement", "extractelement",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VLD4/VST4 lane omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-structure-four-lane.ll", "arm-raw-neon-structure-four-lane.o", ir)
+}
+
+func TestARMRawNEONStructureFourLaneRejectsReservedAndUnsafe(t *testing.T) {
+	base := encodeARMRawNEONStructureFourLane(false, 32, 0, 0, 1, 6, 13, 0)
+	for _, word := range []uint32{
+		base | 3<<4,
+		base &^ (15 << 8),
+		encodeARMRawNEONStructureFourLane(false, 32, 0, 30, 1, 6, 13, 0),
+		encodeARMRawNEONStructureFourLane(false, 16, 0, 26, 2, 6, 13, 0),
+	} {
+		if _, ok := decodeARMRawNEONStructureFourLane(word); ok {
+			t.Fatalf("accepted reserved VLD4/VST4 lane encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawNEONStructureFourLane(true, 32, 0, 0, 1, 15, 13, 0)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badStructureFour(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"badStructureFour": {Name: "badStructureFour", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted PC as VLD4/VST4 lane base")
+	}
+}
diff --git a/arm_lower_word_neon_structure_four_multiple.go b/arm_lower_word_neon_structure_four_multiple.go
new file mode 100644
index 000000000..109c41112
--- /dev/null
+++ b/arm_lower_word_neon_structure_four_multiple.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONStructureFourMultiple struct {
+	load        bool
+	elementBits int
+	first       int
+	stride      int
+	base        int
+	offset      int
+	alignment   int
+}
+
+// decodeARMRawNEONStructureFourMultiple covers A32 VLD4/VST4 multiple-
+// structure forms in 8-, 16-, and 32-bit elements, with D-register spacing
+// one or two, every alignment code, and all post-index addressing modes.
+func decodeARMRawNEONStructureFourMultiple(word uint32) (armRawNEONStructureFourMultiple, bool) {
+	if word&0xff900000 != 0xf4000000 {
+		return armRawNEONStructureFourMultiple{}, false
+	}
+	typeField := int(word >> 8 & 15)
+	if typeField != 0 && typeField != 1 {
+		return armRawNEONStructureFourMultiple{}, false
+	}
+	size := int(word >> 6 & 3)
+	if size == 3 {
+		return armRawNEONStructureFourMultiple{}, false
+	}
+	stride := 1 + typeField
+	first := int(word>>12)&15 | int(word>>22&1)*16
+	if first+3*stride >= 32 {
+		return armRawNEONStructureFourMultiple{}, false
+	}
+	alignmentCode := int(word >> 4 & 3)
+	alignment := 0
+	if alignmentCode != 0 {
+		alignment = 4 << alignmentCode
+	}
+	return armRawNEONStructureFourMultiple{
+		load:        word>>21&1 != 0,
+		elementBits: 8 << size,
+		first:       first,
+		stride:      stride,
+		base:        int(word>>16) & 15,
+		offset:      int(word) & 15,
+		alignment:   alignment,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONStructureFourMultiple(form armRawNEONStructureFourMultiple) error {
+	if form.base == 15 {
+		return fmt.Errorf("arm NEON VLD4/VST4 multiple cannot safely use PC as its base")
+	}
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	elementBytes := form.elementBits / 8
+	lanes := 64 / form.elementBits
+	for registerIndex := 0; registerIndex < 4; registerIndex++ {
+		register := form.first + registerIndex*form.stride
+		vector := "poison"
+		if !form.load {
+			vector, _, err = c.loadARMRawNEONVector(
+				register, form.elementBits, false, elementType,
+			)
+			if err != nil {
+				return err
+			}
+		}
+		for lane := 0; lane < lanes; lane++ {
+			byteOffset := (lane*4 + registerIndex) * elementBytes
+			address := base
+			if byteOffset != 0 {
+				adjusted := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", adjusted, base, byteOffset)
+				address = "%" + adjusted
+			}
+			pointer := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, address)
+			alignment := form.alignment
+			if alignment == 0 {
+				alignment = 1
+			}
+			for alignment > 1 && byteOffset%alignment != 0 {
+				alignment /= 2
+			}
+			if form.load {
+				value := c.newTmp()
+				updated := c.newTmp()
+				fmt.Fprintf(c.b, "  %%%s = load %s, ptr %%%s, align %d\n",
+					value, elementType, pointer, alignment)
+				fmt.Fprintf(c.b, "  %%%s = insertelement <%d x %s> %s, %s %%%s, i32 %d\n",
+					updated, lanes, elementType, vector, elementType, value, lane)
+				vector = "%" + updated
+				continue
+			}
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <%d x %s> %s, i32 %d\n",
+				value, lanes, elementType, vector, lane)
+			fmt.Fprintf(c.b, "  store %s %%%s, ptr %%%s, align %d\n",
+				elementType, value, pointer, alignment)
+		}
+		if form.load {
+			if err := c.storeARMRawNEONVector(
+				register, form.elementBits, false, elementType, vector,
+			); err != nil {
+				return err
+			}
+		}
+	}
+	if form.offset == 15 {
+		return nil
+	}
+	increment := "32"
+	if form.offset != 13 {
+		increment, err = c.loadReg(Reg(fmt.Sprintf("R%d", form.offset)))
+		if err != nil {
+			return err
+		}
+	}
+	updated := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = add i32 %s, %s\n", updated, base, increment)
+	return c.storeReg(baseReg, "%"+updated)
+}
diff --git a/arm_lower_word_neon_structure_four_multiple_test.go b/arm_lower_word_neon_structure_four_multiple_test.go
new file mode 100644
index 000000000..1565550fb
--- /dev/null
+++ b/arm_lower_word_neon_structure_four_multiple_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONStructureFourMultiple(load bool, elementBits, first, stride, base, offset, alignment int) uint32 {
+	word := uint32(0xf4000000 | base<<16 | (first&15)<<12 | (first/16)<<22 | offset)
+	if load {
+		word |= 1 << 21
+	}
+	if stride == 2 {
+		word |= 1 << 8
+	}
+	word |= uint32(map[int]int{8: 0, 16: 1, 32: 2}[elementBits]) << 6
+	word |= uint32(map[int]int{0: 0, 8: 1, 16: 2, 32: 3}[alignment]) << 4
+	return word
+}
+
+func TestARMRawNEONStructureFourMultipleLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		load        bool
+		elementBits int
+		first       int
+		stride      int
+		base        int
+		offset      int
+		alignment   int
+	}{
+		{0xf421000f, true, 8, 0, 1, 1, 15, 0},
+		{0xf421010f, true, 8, 0, 2, 1, 15, 0},
+		{0xf421004f, true, 16, 0, 1, 1, 15, 0},
+		{0xf421014f, true, 16, 0, 2, 1, 15, 0},
+		{0xf421008f, true, 32, 0, 1, 1, 15, 0},
+		{0xf421018f, true, 32, 0, 2, 1, 15, 0},
+		{0xf461418f, true, 32, 20, 2, 1, 15, 0},
+		{0xf401008d, false, 32, 0, 1, 1, 13, 0},
+		{0xf401018d, false, 32, 0, 2, 1, 13, 0},
+		{0xf42100bd, true, 32, 0, 1, 1, 13, 32},
+	} {
+		got, ok := decodeARMRawNEONStructureFourMultiple(test.word)
+		if !ok || got.load != test.load || got.elementBits != test.elementBits ||
+			got.first != test.first || got.stride != test.stride ||
+			got.base != test.base || got.offset != test.offset || got.alignment != test.alignment {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONStructureFourMultiple(
+			test.load, test.elementBits, test.first, test.stride,
+			test.base, test.offset, test.alignment,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONStructureFourMultipleAllFields(t *testing.T) {
+	count := 0
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for _, stride := range []int{1, 2} {
+				for _, alignment := range []int{0, 8, 16, 32} {
+					for first := 0; first+3*stride < 32; first++ {
+						for _, offset := range []int{0, 13, 15} {
+							word := encodeARMRawNEONStructureFourMultiple(
+								load, elementBits, first, stride, 1, offset, alignment,
+							)
+							got, ok := decodeARMRawNEONStructureFourMultiple(word)
+							if !ok || got.load != load || got.elementBits != elementBits ||
+								got.first != first || got.stride != stride ||
+								got.base != 1 || got.offset != offset || got.alignment != alignment {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 3960 {
+		t.Fatalf("covered %d VLD4/VST4 multiple forms, want 3960", count)
+	}
+}
+
+func TestTranslateARMRawNEONStructureFourMultipleLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawStructureFourMultiple(SB), $0-0\n")
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for _, stride := range []int{1, 2} {
+				word := encodeARMRawNEONStructureFourMultiple(
+					load, elementBits, 16, stride, 1, 13, 0,
+				)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawStructureFourMultiple": {Name: "rawStructureFourMultiple", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"load i8, ptr", "store i8", "load i16, ptr", "store i16",
+		"load i32, ptr", "store i32", "insertelement", "extractelement",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VLD4/VST4 multiple omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-structure-four-multiple.ll", "arm-raw-neon-structure-four-multiple.o", ir)
+}
diff --git a/arm_lower_word_neon_structure_one_lane.go b/arm_lower_word_neon_structure_one_lane.go
new file mode 100644
index 000000000..ad4fed2a5
--- /dev/null
+++ b/arm_lower_word_neon_structure_one_lane.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+// decodeARMRawNEONStructureOneLane covers A32 VLD1/VST1 one-lane transfers
+// for 8-, 16-, and 32-bit elements, including all lane, register, alignment,
+// and post-index fields. It shares the typed memory lowerer with VLD4/VST4.
+func decodeARMRawNEONStructureOneLane(word uint32) (armRawNEONStructureLane, bool) {
+	if word&0xff900000 != 0xf4800000 {
+		return armRawNEONStructureLane{}, false
+	}
+	form := armRawNEONStructureLane{
+		load:   word>>21&1 != 0,
+		first:  int(word>>12)&15 | int(word>>22&1)*16,
+		stride: 1,
+		base:   int(word>>16) & 15,
+		offset: int(word) & 15,
+	}
+	switch word >> 8 & 15 {
+	case 0:
+		if word>>4&1 != 0 {
+			return armRawNEONStructureLane{}, false
+		}
+		form.elementBits = 8
+		form.lane = int(word >> 5 & 7)
+	case 4:
+		if word>>5&1 != 0 {
+			return armRawNEONStructureLane{}, false
+		}
+		form.elementBits = 16
+		form.lane = int(word >> 6 & 3)
+		if word>>4&1 != 0 {
+			form.alignment = 2
+		}
+	case 8:
+		if word>>6&1 != 0 {
+			return armRawNEONStructureLane{}, false
+		}
+		form.elementBits = 32
+		form.lane = int(word >> 7 & 1)
+		switch word >> 4 & 3 {
+		case 0:
+		case 3:
+			form.alignment = 4
+		default:
+			return armRawNEONStructureLane{}, false
+		}
+	default:
+		return armRawNEONStructureLane{}, false
+	}
+	return form, true
+}
diff --git a/arm_lower_word_neon_structure_one_lane_test.go b/arm_lower_word_neon_structure_one_lane_test.go
new file mode 100644
index 000000000..9fcc4bbdd
--- /dev/null
+++ b/arm_lower_word_neon_structure_one_lane_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONStructureOneLane(load bool, elementBits, lane, register, base, offset, alignment int) uint32 {
+	word := uint32(0xf4800000 | base<<16 | (register&15)<<12 | (register/16)<<22 | offset)
+	if load {
+		word |= 1 << 21
+	}
+	switch elementBits {
+	case 8:
+		word |= uint32(lane) << 5
+	case 16:
+		word |= 4 << 8
+		word |= uint32(lane) << 6
+		if alignment == 2 {
+			word |= 1 << 4
+		}
+	case 32:
+		word |= 8 << 8
+		word |= uint32(lane) << 7
+		if alignment == 4 {
+			word |= 3 << 4
+		}
+	}
+	return word
+}
+
+func TestARMRawNEONStructureOneLaneLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		load        bool
+		elementBits int
+		lane        int
+		register    int
+		base        int
+		offset      int
+		alignment   int
+	}{
+		{0xf486000f, false, 8, 0, 0, 6, 15, 0},
+		{0xf48600ed, false, 8, 7, 0, 6, 13, 0},
+		{0xf4a6000f, true, 8, 0, 0, 6, 15, 0},
+		{0xf486040f, false, 16, 0, 0, 6, 15, 0},
+		{0xf48604cd, false, 16, 3, 0, 6, 13, 0},
+		{0xf486883f, false, 32, 0, 8, 6, 15, 4},
+		{0xf48788bf, false, 32, 1, 8, 7, 15, 4},
+		{0xf4a6883f, true, 32, 0, 8, 6, 15, 4},
+	} {
+		got, ok := decodeARMRawNEONStructureOneLane(test.word)
+		if !ok || got.load != test.load || got.elementBits != test.elementBits ||
+			got.lane != test.lane || got.first != test.register ||
+			got.base != test.base || got.offset != test.offset || got.alignment != test.alignment {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONStructureOneLane(
+			test.load, test.elementBits, test.lane, test.register,
+			test.base, test.offset, test.alignment,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONStructureOneLaneAllFields(t *testing.T) {
+	count := 0
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			alignments := []int{0}
+			if elementBits == 16 {
+				alignments = []int{0, 2}
+			} else if elementBits == 32 {
+				alignments = []int{0, 4}
+			}
+			for _, alignment := range alignments {
+				for lane := 0; lane < 64/elementBits; lane++ {
+					for register := 0; register < 32; register++ {
+						for _, offset := range []int{0, 13, 15} {
+							word := encodeARMRawNEONStructureOneLane(
+								load, elementBits, lane, register, 6, offset, alignment,
+							)
+							got, ok := decodeARMRawNEONStructureOneLane(word)
+							if !ok || got.load != load || got.elementBits != elementBits ||
+								got.lane != lane || got.first != register || got.base != 6 ||
+								got.offset != offset || got.alignment != alignment {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 3840 {
+		t.Fatalf("covered %d VLD1/VST1 lane forms, want 3840", count)
+	}
+}
+
+func TestTranslateARMRawNEONStructureOneLaneLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawStructureOneLane(SB), $0-0\n")
+	for _, load := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			word := encodeARMRawNEONStructureOneLane(load, elementBits, 0, 16, 6, 13, 0)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawStructureOneLane": {Name: "rawStructureOneLane", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"load i8, ptr", "store i8", "load i16, ptr", "store i16",
+		"load i32, ptr", "store i32", "insertelement", "extractelement",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VLD1/VST1 lane omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-structure-one-lane.ll", "arm-raw-neon-structure-one-lane.o", ir)
+}
+
+func TestARMRawNEONStructureOneLaneRejectsReservedAndUnsafe(t *testing.T) {
+	base := encodeARMRawNEONStructureOneLane(false, 32, 0, 0, 6, 13, 0)
+	for _, word := range []uint32{
+		base | 1<<4,
+		base | 1<<5,
+		base | 1<<6,
+		base ^ 4<<8,
+	} {
+		if _, ok := decodeARMRawNEONStructureOneLane(word); ok {
+			t.Fatalf("accepted reserved VLD1/VST1 lane encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawNEONStructureOneLane(true, 32, 0, 0, 15, 13, 0)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badStructureOne(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"badStructureOne": {Name: "badStructureOne", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted PC as VLD1/VST1 lane base")
+	}
+}
diff --git a/arm_lower_word_neon_structure_test.go b/arm_lower_word_neon_structure_test.go
new file mode 100644
index 000000000..da64b2f22
--- /dev/null
+++ b/arm_lower_word_neon_structure_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONStructureOne(load bool, base, offset, first, count, elementBits, alignment int) uint32 {
+	typeField := map[int]int{1: 0b0111, 2: 0b1010, 3: 0b0110, 4: 0b0010}[count]
+	word := uint32(0xf4000000 | base<<16 | (first&15)<<12 | typeField<<8 | offset)
+	if load {
+		word |= 1 << 21
+	}
+	word |= uint32(first/16) << 22
+	word |= uint32(map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[elementBits]) << 6
+	word |= uint32(map[int]int{0: 0, 8: 1, 16: 2, 32: 3}[alignment]) << 4
+	return word
+}
+
+func TestTranslateARMRawNEONVLD1VST1PionTransportRegression(t *testing.T) {
+	const source = `TEXT rawStructure(SB), $0-0
+	WORD $0xF421020D // vld1.u8 {q0, q1}, [r1]!
+	WORD $0xF422420D // vld1.u8 {q2, q3}, [r2]!
+	WORD $0xF400420D // vst1.u8 {q2, q3}, [r0]!
+	WORD $0xF4210A0D // vld1.u8 q0, [r1]!
+	WORD $0xF4002A0D // vst1.u8 q1, [r0]!
+	WORD $0xF421070D // vld1.u8 d0, [r1]!
+	WORD $0xF400170D // vst1.u8 d1, [r0]!
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawStructure": {Name: "rawStructure", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"load i64, ptr", "store i64", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VLD1/VST1 IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-structure.ll", "arm-raw-neon-structure.o", ir)
+}
+
+func TestARMRawNEONVLD1VST1DecoderCoversEveryEncodingField(t *testing.T) {
+	countForms := 0
+	alignmentsByCount := map[int][]int{1: {0, 8}, 2: {0, 8, 16}, 3: {0, 8}, 4: {0, 8, 16, 32}}
+	for _, load := range []bool{false, true} {
+		for count := 1; count <= 4; count++ {
+			for _, elementBits := range []int{8, 16, 32, 64} {
+				for _, alignment := range alignmentsByCount[count] {
+					for first := 0; first+count <= 32; first++ {
+						for base := 0; base < 16; base++ {
+							for offset := 0; offset < 16; offset++ {
+								word := encodeARMRawNEONStructureOne(load, base, offset, first, count, elementBits, alignment)
+								got, ok := decodeARMRawNEONStructureOne(word)
+								if !ok || got.load != load || got.base != base || got.offset != offset || got.first != first || got.count != count || got.elementBits != elementBits || got.alignment != alignment {
+									t.Fatalf("decoded NEON VLD1/VST1 %#08x as %+v, ok=%v", word, got, ok)
+								}
+								countForms++
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if countForms != 681984 {
+		t.Fatalf("covered %d NEON VLD1/VST1 encodings, want 681984", countForms)
+	}
+}
+
+func TestARMRawNEONVLD1VST1RejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONStructureOne(true, 0, 15, 31, 1, 32, 0) &^ (uint32(15) << 8),
+		encodeARMRawNEONStructureOne(true, 0, 15, 0, 1, 32, 0) | 2<<4,
+		encodeARMRawNEONStructureOne(true, 0, 15, 31, 4, 32, 0),
+	} {
+		if _, ok := decodeARMRawNEONStructureOne(word); ok {
+			t.Fatalf("NEON VLD1/VST1 decoder accepted reserved encoding %#08x", word)
+		}
+	}
+
+	word := encodeARMRawNEONStructureOne(true, 15, 13, 0, 4, 32, 0)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badStructure(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"badStructure": {Name: "badStructure", Ret: Void}}}); err == nil {
+		t.Fatal("Translate accepted PC as NEON VLD1/VST1 base")
+	}
+}
+
+func TestTranslateARMRawNEONVLD1VST1AddressingModes(t *testing.T) {
+	source := "TEXT rawStructureModes(SB), $0-0\n"
+	for _, word := range []uint32{
+		encodeARMRawNEONStructureOne(true, 0, 15, 0, 1, 8, 8),
+		encodeARMRawNEONStructureOne(true, 1, 13, 1, 2, 16, 16),
+		encodeARMRawNEONStructureOne(false, 2, 4, 3, 3, 32, 8),
+		encodeARMRawNEONStructureOne(false, 3, 13, 6, 4, 64, 32),
+	} {
+		source += fmt.Sprintf("\tWORD $%#08x\n", word)
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawStructureModes": {Name: "rawStructureModes", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"align 8", "align 16", "align 32", "add i32", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VLD1/VST1 addressing IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-structure-modes.ll", "arm-raw-neon-structure-modes.o", ir)
+}
diff --git a/arm_lower_word_neon_transpose.go b/arm_lower_word_neon_transpose.go
new file mode 100644
index 000000000..9afa5997d
--- /dev/null
+++ b/arm_lower_word_neon_transpose.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armRawNEONTranspose struct {
+	quad        bool
+	elementBits int
+	first       int
+	second      int
+}
+
+// decodeARMRawNEONTranspose covers A32 VTRN.8/.16/.32 in D and Q registers.
+// Both operand fields are read and written by the instruction.
+func decodeARMRawNEONTranspose(word uint32) (armRawNEONTranspose, bool) {
+	const variable = uint32(0x004cf06f)
+	if word&^variable != 0xf3b20080 {
+		return armRawNEONTranspose{}, false
+	}
+	size := int(word >> 18 & 3)
+	if size == 3 {
+		return armRawNEONTranspose{}, false
+	}
+	quad := word>>6&1 != 0
+	first := int(word>>12)&15 | int(word>>22&1)*16
+	second := int(word)&15 | int(word>>5&1)*16
+	if quad && (first&1 != 0 || second&1 != 0) {
+		return armRawNEONTranspose{}, false
+	}
+	return armRawNEONTranspose{
+		quad:        quad,
+		elementBits: 8 << size,
+		first:       first,
+		second:      second,
+	}, true
+}
+
+func (c *armCtx) lowerRawNEONTranspose(form armRawNEONTranspose) error {
+	elementType := fmt.Sprintf("i%d", form.elementBits)
+	first, lanes, err := c.loadARMRawNEONVector(
+		form.first, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	second, _, err := c.loadARMRawNEONVector(
+		form.second, form.elementBits, form.quad, elementType,
+	)
+	if err != nil {
+		return err
+	}
+	firstIndices := make([]string, lanes)
+	secondIndices := make([]string, lanes)
+	for pair := 0; pair < lanes/2; pair++ {
+		firstIndices[2*pair] = fmt.Sprintf("i32 %d", 2*pair)
+		firstIndices[2*pair+1] = fmt.Sprintf("i32 %d", lanes+2*pair)
+		secondIndices[2*pair] = fmt.Sprintf("i32 %d", 2*pair+1)
+		secondIndices[2*pair+1] = fmt.Sprintf("i32 %d", lanes+2*pair+1)
+	}
+	firstResult := c.newTmp()
+	secondResult := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %s, <%d x %s> %s, <%d x i32> <%s>\n",
+		firstResult, lanes, elementType, first, lanes, elementType, second,
+		lanes, strings.Join(firstIndices, ", "))
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <%d x %s> %s, <%d x %s> %s, <%d x i32> <%s>\n",
+		secondResult, lanes, elementType, first, lanes, elementType, second,
+		lanes, strings.Join(secondIndices, ", "))
+	if err := c.storeARMRawNEONVector(
+		form.first, form.elementBits, form.quad, elementType, "%"+firstResult,
+	); err != nil {
+		return err
+	}
+	return c.storeARMRawNEONVector(
+		form.second, form.elementBits, form.quad, elementType, "%"+secondResult,
+	)
+}
diff --git a/arm_lower_word_neon_transpose_test.go b/arm_lower_word_neon_transpose_test.go
new file mode 100644
index 000000000..6788bf901
--- /dev/null
+++ b/arm_lower_word_neon_transpose_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONTranspose(quad bool, elementBits, first, second int) uint32 {
+	word := uint32(0xf3b20080 | (first&15)<<12 | (first/16)<<22 |
+		second&15 | (second/16)<<5)
+	switch elementBits {
+	case 16:
+		word |= 1 << 18
+	case 32:
+		word |= 2 << 18
+	}
+	if quad {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawNEONTransposeLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		quad        bool
+		elementBits int
+		first       int
+		second      int
+	}{
+		{0xf3b20081, false, 8, 0, 1},
+		{0xf3b60081, false, 16, 0, 1},
+		{0xf3ba008a, false, 32, 0, 10},
+		{0xf3b200c2, true, 8, 0, 2},
+		{0xf3b600c2, true, 16, 0, 2},
+		{0xf3ba00c2, true, 32, 0, 2},
+		{0xf3faf0a0, false, 32, 31, 16},
+		{0xf3fae0e0, true, 32, 30, 16},
+	} {
+		got, ok := decodeARMRawNEONTranspose(test.word)
+		if !ok || got.quad != test.quad || got.elementBits != test.elementBits ||
+			got.first != test.first || got.second != test.second {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONTranspose(
+			test.quad, test.elementBits, test.first, test.second,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONTransposeAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, elementBits := range []int{8, 16, 32} {
+		for _, quad := range []bool{false, true} {
+			step := 1
+			if quad {
+				step = 2
+			}
+			for first := 0; first < 32; first += step {
+				for second := 0; second < 32; second += step {
+					word := encodeARMRawNEONTranspose(quad, elementBits, first, second)
+					got, ok := decodeARMRawNEONTranspose(word)
+					if !ok || got.quad != quad || got.elementBits != elementBits ||
+						got.first != first || got.second != second {
+						t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 3840 {
+		t.Fatalf("covered %d VTRN forms, want 3840", count)
+	}
+}
+
+func TestTranslateARMRawNEONTransposeAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawTranspose(SB), $0-0\n")
+	for _, elementBits := range []int{8, 16, 32} {
+		for _, quad := range []bool{false, true} {
+			word := encodeARMRawNEONTranspose(quad, elementBits, 16, 18)
+			fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawTranspose": {Name: "rawTranspose", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"shufflevector <8 x i8>", "shufflevector <16 x i8>",
+		"shufflevector <4 x i16>", "shufflevector <8 x i16>",
+		"shufflevector <2 x i32>", "shufflevector <4 x i32>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VTRN omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vtrn.ll", "arm-raw-neon-vtrn.o", ir)
+}
+
+func TestARMRawNEONTransposeRejectsReservedFields(t *testing.T) {
+	base := encodeARMRawNEONTranspose(true, 32, 0, 2)
+	for _, word := range []uint32{
+		base | 1<<12,
+		base | 1,
+		base ^ 1<<8,
+		base | 1<<18,
+	} {
+		if _, ok := decodeARMRawNEONTranspose(word); ok {
+			t.Fatalf("accepted reserved VTRN encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_neon_widening_subtract.go b/arm_lower_word_neon_widening_subtract.go
new file mode 100644
index 000000000..ea8ee9990
--- /dev/null
+++ b/arm_lower_word_neon_widening_subtract.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import "fmt"
+
+type armRawNEONWideningSubtract struct {
+	operation   string
+	unsigned    bool
+	elementBits int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawNEONWideningAddSub covers complete A32 VADDL/VSUBL signed and
+// unsigned register families: 8-, 16-, and 32-bit D lanes widened into a Q
+// destination before the arithmetic operation.
+func decodeARMRawNEONWideningAddSub(word uint32) (armRawNEONWideningSubtract, bool) {
+	operation := ""
+	switch word & 0xfe800f50 {
+	case 0xf2800000:
+		operation = "add"
+	case 0xf2800200:
+		operation = "sub"
+	default:
+		return armRawNEONWideningSubtract{}, false
+	}
+	size := int(word>>20) & 3
+	if size == 3 {
+		return armRawNEONWideningSubtract{}, false
+	}
+	destination := int(word>>12)&15 | int(word>>22&1)*16
+	// A Q register is encoded as its even-numbered first D register.
+	if destination&1 != 0 {
+		return armRawNEONWideningSubtract{}, false
+	}
+	return armRawNEONWideningSubtract{
+		operation:   operation,
+		unsigned:    word>>24&1 != 0,
+		elementBits: 8 << size,
+		destination: destination,
+		lhs:         int(word>>16)&15 | int(word>>7&1)*16,
+		rhs:         int(word)&15 | int(word>>5&1)*16,
+	}, true
+}
+
+func decodeARMRawNEONWideningSubtract(word uint32) (armRawNEONWideningSubtract, bool) {
+	form, ok := decodeARMRawNEONWideningAddSub(word)
+	return form, ok && form.operation == "sub"
+}
+
+func (c *armCtx) lowerRawNEONWideningAddSub(form armRawNEONWideningSubtract) error {
+	lhsBits, err := c.loadFReg(armRawVFPBackingReg(form.lhs, 64))
+	if err != nil {
+		return err
+	}
+	rhsBits, err := c.loadFReg(armRawVFPBackingReg(form.rhs, 64))
+	if err != nil {
+		return err
+	}
+	lanes := 64 / form.elementBits
+	wideBits := form.elementBits * 2
+	lhsVector := c.newTmp()
+	rhsVector := c.newTmp()
+	lhsWide := c.newTmp()
+	rhsWide := c.newTmp()
+	result := c.newTmp()
+	resultBits := c.newTmp()
+	extend := "sext"
+	if form.unsigned {
+		extend = "zext"
+	}
+	fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <%d x i%d>\n", lhsVector, lhsBits, lanes, form.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast i64 %s to <%d x i%d>\n", rhsVector, rhsBits, lanes, form.elementBits)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %%%s to <%d x i%d>\n", lhsWide, extend, lanes, form.elementBits, lhsVector, lanes, wideBits)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %%%s to <%d x i%d>\n", rhsWide, extend, lanes, form.elementBits, rhsVector, lanes, wideBits)
+	fmt.Fprintf(c.b, "  %%%s = %s <%d x i%d> %%%s, %%%s\n",
+		result, form.operation, lanes, wideBits, lhsWide, rhsWide)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <%d x i%d> %%%s to i128\n", resultBits, lanes, wideBits, result)
+	low := c.newTmp()
+	highWide := c.newTmp()
+	high := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", low, resultBits)
+	fmt.Fprintf(c.b, "  %%%s = lshr i128 %%%s, 64\n", highWide, resultBits)
+	fmt.Fprintf(c.b, "  %%%s = trunc i128 %%%s to i64\n", high, highWide)
+	if err := c.storeFReg(armRawVFPBackingReg(form.destination, 64), "%"+low); err != nil {
+		return err
+	}
+	return c.storeFReg(armRawVFPBackingReg(form.destination+1, 64), "%"+high)
+}
diff --git a/arm_lower_word_neon_widening_subtract_test.go b/arm_lower_word_neon_widening_subtract_test.go
new file mode 100644
index 000000000..186a36779
--- /dev/null
+++ b/arm_lower_word_neon_widening_subtract_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawNEONWideningSubtract(unsigned bool, elementBits, destination, lhs, rhs int) uint32 {
+	word := uint32(0xf2800200 | (destination&15)<<12 | (lhs&15)<<16 | rhs&15)
+	if unsigned {
+		word |= 1 << 24
+	}
+	word |= uint32(destination/16) << 22
+	word |= uint32(map[int]int{8: 0, 16: 1, 32: 2}[elementBits]) << 20
+	word |= uint32(lhs/16) << 7
+	word |= uint32(rhs/16) << 5
+	return word
+}
+
+func encodeARMRawNEONWideningAdd(unsigned bool, elementBits, destination, lhs, rhs int) uint32 {
+	return encodeARMRawNEONWideningSubtract(unsigned, elementBits, destination, lhs, rhs) &^ (1 << 9)
+}
+
+func TestARMRawNEONWideningAddLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word        uint32
+		unsigned    bool
+		elementBits int
+		destination int
+		lhs         int
+		rhs         int
+	}{
+		{0xf2810002, false, 8, 0, 1, 2},
+		{0xf3810002, true, 8, 0, 1, 2},
+		{0xf2910002, false, 16, 0, 1, 2},
+		{0xf3910002, true, 16, 0, 1, 2},
+		{0xf2a10002, false, 32, 0, 1, 2},
+		{0xf3aaa02e, true, 32, 10, 10, 30},
+	} {
+		got, ok := decodeARMRawNEONWideningAddSub(test.word)
+		if !ok || got.operation != "add" || got.unsigned != test.unsigned ||
+			got.elementBits != test.elementBits || got.destination != test.destination ||
+			got.lhs != test.lhs || got.rhs != test.rhs {
+			t.Fatalf("LLVM 22 VADDL encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if encoded := encodeARMRawNEONWideningAdd(
+			test.unsigned, test.elementBits, test.destination, test.lhs, test.rhs,
+		); encoded != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, encoded, test.word)
+		}
+	}
+}
+
+func TestARMRawNEONWideningAddAllRegisterFields(t *testing.T) {
+	count := 0
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for destination := 0; destination < 32; destination += 2 {
+				for lhs := 0; lhs < 32; lhs++ {
+					for rhs := 0; rhs < 32; rhs++ {
+						word := encodeARMRawNEONWideningAdd(
+							unsigned, elementBits, destination, lhs, rhs,
+						)
+						got, ok := decodeARMRawNEONWideningAddSub(word)
+						if !ok || got.operation != "add" || got.unsigned != unsigned ||
+							got.elementBits != elementBits || got.destination != destination ||
+							got.lhs != lhs || got.rhs != rhs {
+							t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 98304 {
+		t.Fatalf("covered %d VADDL forms, want 98304", count)
+	}
+}
+
+func TestTranslateARMRawNEONWideningAddLLVM22(t *testing.T) {
+	source := "TEXT rawWideningAdd(SB), $0-0\n"
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			word := encodeARMRawNEONWideningAdd(unsigned, elementBits, 10, 2, 4)
+			source += fmt.Sprintf("\tWORD $%#08x\n", word)
+		}
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"rawWideningAdd": {Name: "rawWideningAdd", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{
+		"add <8 x i16>", "add <4 x i32>", "add <2 x i64>",
+		"sext <8 x i8>", "zext <8 x i8>",
+	} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VADDL omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-neon-vaddl.ll", "arm-raw-neon-vaddl.o", ir)
+}
+
+func TestTranslateARMRawNEONVSUBLGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawWideningSubtract(SB), $0-0
+	WORD $0xf3cc4280 // vsubl.u8 q10, d28, d0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawWideningSubtract": {Name: "rawWideningSubtract", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"zext <8 x i8>", "sub <8 x i16>", `"target-features"="+neon"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw NEON VSUBL IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-neon-vsubl.ll", "arm-raw-neon-vsubl.o", ir)
+}
+
+func TestARMRawNEONVSUBLDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, unsigned := range []bool{false, true} {
+		for _, elementBits := range []int{8, 16, 32} {
+			for destination := 0; destination < 32; destination += 2 {
+				for lhs := 0; lhs < 32; lhs++ {
+					for rhs := 0; rhs < 32; rhs++ {
+						word := encodeARMRawNEONWideningSubtract(unsigned, elementBits, destination, lhs, rhs)
+						got, ok := decodeARMRawNEONWideningSubtract(word)
+						if !ok || got.unsigned != unsigned || got.elementBits != elementBits || got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+							t.Fatalf("decoded NEON VSUBL %#08x as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 98304 {
+		t.Fatalf("covered %d NEON VSUBL encodings, want 98304", count)
+	}
+}
+
+func TestARMRawNEONVSUBLRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawNEONWideningSubtract(false, 8, 0, 0, 0) | 3<<20,
+		encodeARMRawNEONWideningSubtract(false, 8, 0, 0, 0) | 1<<12,
+		encodeARMRawNEONWideningSubtract(false, 8, 0, 0, 0) | 1<<6,
+	} {
+		if _, ok := decodeARMRawNEONWideningSubtract(word); ok {
+			t.Fatalf("NEON VSUBL decoder accepted reserved encoding %#08x", word)
+		}
+	}
+	if _, ok := decodeARMRawNEONWideningSubtract(encodeARMRawNEONWideningSubtract(true, 32, 30, 31, 31)); !ok {
+		t.Fatal("NEON VSUBL decoder rejected last valid registers")
+	}
+
+	const signedSource = `TEXT rawSignedWideningSubtract(SB), $0-0
+	WORD $0xf28c4280 // vsubl.s8 q2, d28, d0
+	RET
+`
+	file, err := Parse(ArchARM, signedSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawSignedWideningSubtract": {Name: "rawSignedWideningSubtract", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "sext <8 x i8>") {
+		t.Fatalf("signed NEON VSUBL omitted sign extension:\n%s", ir)
+	}
+}
diff --git a/arm_lower_word_saturation_test.go b/arm_lower_word_saturation_test.go
new file mode 100644
index 000000000..9d8bcf05d
--- /dev/null
+++ b/arm_lower_word_saturation_test.go
@@ -0,0 +1,361 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type armSaturationForm struct {
+	name        string
+	signed      bool
+	halfword    bool
+	condition   int
+	width       int
+	destination int
+	source      int
+	shift       int
+	arithmetic  bool
+}
+
+func encodeARMRawSaturation(signed, halfword bool, condition, width, destination, source, shift int, arithmetic bool) uint32 {
+	base := uint32(0x06a00010)
+	if !signed {
+		base = 0x06e00010
+	}
+	field := width
+	if signed {
+		field--
+	}
+	word := uint32(condition)<<28 | base | uint32(field)<<16 |
+		uint32(destination)<<12 | uint32(source)
+	if halfword {
+		return word | 0x00000f20
+	}
+	word |= uint32(shift) << 7
+	if arithmetic {
+		word |= 1 << 6
+	}
+	return word
+}
+
+func TestARMRawSaturationFamilyCompleteFormats(t *testing.T) {
+	forms := []armSaturationForm{
+		{name: "ssat-min", signed: true, condition: 14, width: 1, destination: 0, source: 1},
+		{name: "ssat-reported", signed: true, condition: 14, width: 16, destination: 0, source: 0},
+		{name: "ssat-max-asr32", signed: true, condition: 0, width: 32, destination: 14, source: 0, arithmetic: true},
+		{name: "ssat-lsl31", signed: true, condition: 1, width: 8, destination: 1, source: 14, shift: 31},
+		{name: "usat-min", condition: 14, width: 0, destination: 0, source: 1},
+		{name: "usat-max-asr32", condition: 0, width: 31, destination: 14, source: 0, arithmetic: true},
+		{name: "usat-lsl31", condition: 1, width: 8, destination: 1, source: 14, shift: 31},
+		{name: "ssat16-min", signed: true, halfword: true, condition: 14, width: 1, destination: 0, source: 1},
+		{name: "ssat16-max", signed: true, halfword: true, condition: 0, width: 16, destination: 14, source: 0},
+		{name: "usat16-min", halfword: true, condition: 14, width: 0, destination: 0, source: 1},
+		{name: "usat16-max", halfword: true, condition: 1, width: 15, destination: 14, source: 0},
+	}
+	for _, family := range []struct {
+		name     string
+		signed   bool
+		halfword bool
+		minWidth int
+		maxWidth int
+	}{
+		{name: "ssat", signed: true, minWidth: 1, maxWidth: 32},
+		{name: "usat", minWidth: 0, maxWidth: 31},
+		{name: "ssat16", signed: true, halfword: true, minWidth: 1, maxWidth: 16},
+		{name: "usat16", halfword: true, minWidth: 0, maxWidth: 15},
+	} {
+		for width := family.minWidth; width <= family.maxWidth; width++ {
+			forms = append(forms, armSaturationForm{
+				name:        fmt.Sprintf("%s-width-%d", family.name, width),
+				signed:      family.signed,
+				halfword:    family.halfword,
+				condition:   14,
+				width:       width,
+				destination: 0,
+				source:      1,
+			})
+		}
+		for condition := 0; condition < 15; condition++ {
+			forms = append(forms, armSaturationForm{
+				name:        fmt.Sprintf("%s-condition-%d", family.name, condition),
+				signed:      family.signed,
+				halfword:    family.halfword,
+				condition:   condition,
+				width:       8,
+				destination: 2,
+				source:      3,
+			})
+		}
+		if !family.halfword {
+			for _, shift := range []int{1, 16, 31} {
+				forms = append(forms, armSaturationForm{
+					name:        fmt.Sprintf("%s-lsl-%d", family.name, shift),
+					signed:      family.signed,
+					condition:   14,
+					width:       8,
+					destination: 4,
+					source:      5,
+					shift:       shift,
+				})
+			}
+			for _, shift := range []int{1, 16, 32} {
+				forms = append(forms, armSaturationForm{
+					name:        fmt.Sprintf("%s-asr-%d", family.name, shift),
+					signed:      family.signed,
+					condition:   14,
+					width:       8,
+					destination: 4,
+					source:      5,
+					shift:       shift % 32,
+					arithmetic:  true,
+				})
+			}
+		}
+	}
+	var source strings.Builder
+	source.WriteString("TEXT saturationforms(SB),$0-0\n\tCMP R0, R1\n")
+	for _, form := range forms {
+		word := encodeARMRawSaturation(
+			form.signed, form.halfword, form.condition, form.width,
+			form.destination, form.source, form.shift, form.arithmetic,
+		)
+		fmt.Fprintf(&source, "\tWORD $%#08x // %s\n", word, form.name)
+	}
+	source.WriteString("\tRET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{
+			"saturationforms": {Name: "saturationforms", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, intrinsic := range []string{
+		"@llvm.arm.ssat", "@llvm.arm.usat",
+		"@llvm.arm.ssat16", "@llvm.arm.usat16",
+	} {
+		if !strings.Contains(ir, intrinsic) {
+			t.Fatalf("saturation family omitted %s", intrinsic)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"armv7-unknown-linux-gnueabihf",
+		"armv7-none-eabi",
+		"armv7-unknown-freebsd",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "arm-saturation.ll", "arm-saturation.o", ir)
+		})
+	}
+}
+
+func TestARMRawSaturationRejectsInvalidOperandForms(t *testing.T) {
+	for _, instruction := range []string{
+		"SSAT R1, $0, R0",
+		"SSAT R1, $33, R0",
+		"USAT R1, $32, R0",
+		"SSAT16 R1, $0, R0",
+		"SSAT16 R1, $17, R0",
+		"USAT16 R1, $16, R0",
+		"SSAT R15, $8, R0",
+		"USAT R1, $8, R15",
+		"SSAT R1>>1, $8, R0",
+		"SSAT R1<<R2, $8, R0",
+		"SSAT R1<<32, $8, R0",
+		"USAT R1->0, $8, R0",
+		"USAT R1->33, $8, R0",
+		"SSAT16 R1<<1, $8, R0",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT invalid(SB),$0-0\n\t" + instruction + "\n\tRET\n"
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				Goarch:       "arm",
+				TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{
+					"invalid": {Name: "invalid", Ret: Void},
+				},
+			})
+			if err == nil {
+				t.Fatalf("Translate accepted invalid saturation form %q", instruction)
+			}
+		})
+	}
+}
+
+func armSaturationRuntimeFixture() (string, map[string]FuncSig, string) {
+	forms := []struct {
+		name       string
+		signed     bool
+		halfword   bool
+		width      int
+		shift      int
+		arithmetic bool
+		condition  int
+	}{
+		{name: "ssat_scalar", signed: true, width: 16, condition: 14},
+		{name: "usat_scalar", width: 8, condition: 14},
+		{name: "ssat_pair", signed: true, halfword: true, width: 8, condition: 14},
+		{name: "usat_pair", halfword: true, width: 8, condition: 14},
+		{name: "ssat_asr32", signed: true, width: 1, arithmetic: true, condition: 14},
+		{name: "usat_lsl1", width: 8, shift: 1, condition: 14},
+		{name: "ssat_equal", signed: true, width: 16, condition: 0},
+		{name: "ssat_not_equal", signed: true, width: 16, condition: 1},
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig, len(forms))
+	for _, form := range forms {
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-8\n", form.name)
+		source.WriteString("\tMOVW value+0(FP), R1\n")
+		if form.condition != 14 {
+			source.WriteString("\tMOVW R1, R0\n\tCMP R1, R1\n")
+		}
+		word := encodeARMRawSaturation(
+			form.signed, form.halfword, form.condition, form.width,
+			0, 1, form.shift, form.arithmetic,
+		)
+		fmt.Fprintf(&source, "\tWORD $%#08x\n\tMOVW R0, ret+4(FP)\n\tRET\n", word)
+		sigs[form.name] = FuncSig{
+			Name: form.name, Args: []LLVMType{I32}, Ret: I32,
+			Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+			},
+		}
+	}
+	const checks = `#include <stdint.h>
+#include <stdio.h>
+
+extern uint32_t ssat_scalar(uint32_t);
+extern uint32_t usat_scalar(uint32_t);
+extern uint32_t ssat_pair(uint32_t);
+extern uint32_t usat_pair(uint32_t);
+extern uint32_t ssat_asr32(uint32_t);
+extern uint32_t usat_lsl1(uint32_t);
+extern uint32_t ssat_equal(uint32_t);
+extern uint32_t ssat_not_equal(uint32_t);
+
+static int32_t signed_saturate(int32_t value, int width) {
+    int32_t limit = (int32_t)(1u << (width - 1));
+    if (value < -limit) {
+        return -limit;
+    }
+    if (value > limit - 1) {
+        return limit - 1;
+    }
+    return value;
+}
+
+static uint32_t unsigned_saturate(int32_t value, int width) {
+    uint32_t limit = (1u << width) - 1;
+    if (value < 0) {
+        return 0;
+    }
+    if ((uint32_t)value > limit) {
+        return limit;
+    }
+    return (uint32_t)value;
+}
+
+static uint32_t pair_saturate(uint32_t value, int is_signed) {
+    uint32_t result = 0;
+    for (int lane = 0; lane < 2; lane++) {
+        int32_t input = (int16_t)(value >> (lane * 16));
+        uint32_t output = is_signed
+            ? (uint16_t)signed_saturate(input, 8)
+            : unsigned_saturate(input, 8);
+        result |= (output & 0xffffu) << (lane * 16);
+    }
+    return result;
+}
+
+int main(void) {
+    const uint32_t inputs[] = {
+        0u, 1u, 127u, 255u, 256u, 32767u, 32768u,
+        0xffffffffu, 0x80000000u, 0x80008000u, 0x7fff7fffu, 0x1234fedcu,
+    };
+    for (unsigned i = 0; i < sizeof(inputs) / sizeof(inputs[0]); i++) {
+        uint32_t value = inputs[i];
+        if (ssat_scalar(value) != (uint32_t)signed_saturate((int32_t)value, 16)) {
+            return 1;
+        }
+        if (usat_scalar(value) != unsigned_saturate((int32_t)value, 8)) {
+            return 2;
+        }
+        if (ssat_pair(value) != pair_saturate(value, 1)) {
+            return 3;
+        }
+        if (usat_pair(value) != pair_saturate(value, 0)) {
+            return 4;
+        }
+        if (ssat_asr32(value) != (uint32_t)((int32_t)value < 0 ? -1 : 0)) {
+            return 5;
+        }
+        if (usat_lsl1(value) != unsigned_saturate((int32_t)(value << 1), 8)) {
+            return 6;
+        }
+        if (ssat_equal(value) != (uint32_t)signed_saturate((int32_t)value, 16)) {
+            return 7;
+        }
+        if (ssat_not_equal(value) != value) {
+            return 8;
+        }
+    }
+    return 0;
+}
+`
+	return source.String(), sigs, checks
+}
+
+func TestARMRawSaturationRuntimeCross(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("actual ARM execution is required by the Linux cross-runtime job")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatalf("cross-execution driver requires linux/amd64, got %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+	for _, name := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(name); err != nil {
+			t.Fatalf("required tool %s: %v", name, err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, sigs, checks := armSaturationRuntimeFixture()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(
+		t, llc, []string{"arm-linux-gnueabihf-gcc"},
+		"arm_raw_saturation", triple, ir, checks,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"},
+	)
+}
diff --git a/arm_lower_word_vfp_immediate.go b/arm_lower_word_vfp_immediate.go
new file mode 100644
index 000000000..348f882ee
--- /dev/null
+++ b/arm_lower_word_vfp_immediate.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type armRawVFPImmediate struct {
+	condition   string
+	bits        int
+	destination int
+	immediate   uint8
+}
+
+// decodeARMRawVFPImmediate covers the complete A32 VMOV (immediate) family:
+// every ordinary ARM condition, both F32/F64 widths, all S0..S31/D0..D31
+// destinations, and all 256 encodable floating constants.
+func decodeARMRawVFPImmediate(word uint32) (armRawVFPImmediate, bool) {
+	const mask = uint32(0x0fb00ef0)
+	const base = uint32(0x0eb00a00)
+	if word&mask != base {
+		return armRawVFPImmediate{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPImmediate{}, false
+	}
+	width := 32
+	destination := int(word>>12) & 15
+	if word>>8&1 != 0 {
+		width = 64
+		destination += int(word>>22&1) * 16
+	} else {
+		destination = destination*2 + int(word>>22&1)
+	}
+	immediate := uint8(word>>16&15)<<4 | uint8(word&15)
+	return armRawVFPImmediate{
+		condition:   condition,
+		bits:        width,
+		destination: destination,
+		immediate:   immediate,
+	}, true
+}
+
+// expandARMVFPImmediate implements the VFPExpandImm operation from the ARM
+// architecture. Returning the IEEE bits avoids rounding the encoded constant
+// through a host floating-point parser.
+func expandARMVFPImmediate(immediate uint8, width int) uint64 {
+	exponentBits, fractionBits := 8, 23
+	if width == 64 {
+		exponentBits, fractionBits = 11, 52
+	}
+	repeated := uint64(immediate>>6) & 1
+	exponent := (repeated ^ 1) << (exponentBits - 1)
+	if repeated != 0 {
+		exponent |= ((uint64(1) << (exponentBits - 3)) - 1) << 2
+	}
+	exponent |= uint64(immediate>>4) & 3
+	fraction := uint64(immediate&15) << (fractionBits - 4)
+	sign := uint64(immediate>>7) << (width - 1)
+	return sign | exponent<<fractionBits | fraction
+}
+
+func (c *armCtx) lowerRawVFPImmediate(form armRawVFPImmediate) error {
+	bits := expandARMVFPImmediate(form.immediate, form.bits)
+	if form.bits == 64 {
+		return c.selectFRegWrite(
+			armRawVFPBackingReg(form.destination, 64),
+			form.condition,
+			strconv.FormatUint(bits, 10),
+		)
+	}
+
+	reg := armRawVFPBackingReg(form.destination, 32)
+	old, err := c.loadFReg(reg)
+	if err != nil {
+		return err
+	}
+	newBits := strconv.FormatUint(bits, 10)
+	if form.destination&1 != 0 {
+		kept := c.newTmp()
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 4294967295\n", kept, old)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %d\n", merged, kept, bits<<32)
+		newBits = "%" + merged
+	} else {
+		kept := c.newTmp()
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, -4294967296\n", kept, old)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", merged, kept, newBits)
+		newBits = "%" + merged
+	}
+	return c.selectFRegWrite(reg, form.condition, newBits)
+}
diff --git a/arm_lower_word_vfp_immediate_test.go b/arm_lower_word_vfp_immediate_test.go
new file mode 100644
index 000000000..e9ce4825f
--- /dev/null
+++ b/arm_lower_word_vfp_immediate_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawVFPImmediate(condition, bits, destination, immediate int) uint32 {
+	word := uint32(condition)<<28 | 0x0eb00a00
+	word |= uint32(immediate>>4) << 16
+	word |= uint32(immediate & 15)
+	if bits == 32 {
+		word |= uint32(destination&1) << 22
+		word |= uint32(destination>>1) << 12
+	} else {
+		word |= 1 << 8
+		word |= uint32(destination>>4) << 22
+		word |= uint32(destination&15) << 12
+	}
+	return word
+}
+
+func TestARMRawVFPImmediateDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for _, width := range []int{32, 64} {
+			for destination := 0; destination < 32; destination++ {
+				for immediate := 0; immediate < 256; immediate++ {
+					word := encodeARMRawVFPImmediate(condition, width, destination, immediate)
+					got, ok := decodeARMRawVFPImmediate(word)
+					if !ok {
+						t.Fatalf("decodeARMRawVFPImmediate(%#08x) failed", word)
+					}
+					if got.bits != width || got.destination != destination || got.immediate != uint8(immediate) {
+						t.Fatalf("decodeARMRawVFPImmediate(%#08x) = %+v", word, got)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 15*2*32*256 {
+		t.Fatalf("covered %d VFP immediate encodings", count)
+	}
+}
+
+func TestARMRawVFPImmediateExpansion(t *testing.T) {
+	for _, test := range []struct {
+		immediate uint8
+		bits      int
+		want      uint64
+	}{
+		{immediate: 0x70, bits: 32, want: 0x3f800000},
+		{immediate: 0x70, bits: 64, want: 0x3ff0000000000000},
+		{immediate: 0xf0, bits: 32, want: 0xbf800000},
+		{immediate: 0xf0, bits: 64, want: 0xbff0000000000000},
+		{immediate: 0x00, bits: 32, want: 0x40000000},
+		{immediate: 0x0f, bits: 64, want: 0x400f000000000000},
+	} {
+		if got := expandARMVFPImmediate(test.immediate, test.bits); got != test.want {
+			t.Fatalf("expandARMVFPImmediate(%#x, %d) = %#x, want %#x", test.immediate, test.bits, got, test.want)
+		}
+	}
+}
+
+func TestTranslateARMRawVFPImmediateFamilyThroughLLVM22(t *testing.T) {
+	words := []uint32{
+		encodeARMRawVFPImmediate(14, 64, 0, 0x70),
+		encodeARMRawVFPImmediate(14, 32, 30, 0x70),
+		encodeARMRawVFPImmediate(14, 32, 31, 0xf0),
+		encodeARMRawVFPImmediate(14, 64, 16, 0x00),
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawVFPImmediate(SB), $0-0\n")
+	for _, word := range words {
+		fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"rawVFPImmediate": {Name: "rawVFPImmediate", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"1065353216", "-4647714815446351872", "4611686018427387904", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP immediate family omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-vfp-immediate.ll", "arm-vfp-immediate.o", ir)
+}
+
+func TestARMRawVFPImmediateRejectsReservedAndDifferentForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawVFPImmediate(15, 64, 0, 0x70),
+		encodeARMRawVFPImmediate(14, 64, 0, 0x70) | 1<<6,
+		0xeeb00b40, // VMOV.F64 D0,D0.
+	} {
+		if got, ok := decodeARMRawVFPImmediate(word); ok {
+			t.Fatalf("decoded reserved/different form %#08x as %+v", word, got)
+		}
+	}
+}
diff --git a/arm_lower_word_vfp_load_store.go b/arm_lower_word_vfp_load_store.go
new file mode 100644
index 000000000..c7b0830ea
--- /dev/null
+++ b/arm_lower_word_vfp_load_store.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import "fmt"
+
+type armRawVFPLoadStore struct {
+	load      bool
+	add       bool
+	condition string
+	base      int
+	bits      int
+	register  int
+	offset    int
+}
+
+// decodeARMRawVFPLoadStore covers classic A32 VLDR/VSTR immediate-offset
+// forms: both transfer widths, offset signs, all executable conditions,
+// S0..S31 and D0..D31, and the complete 8-bit scaled offset field.
+func decodeARMRawVFPLoadStore(word uint32) (armRawVFPLoadStore, bool) {
+	const variable = uint32(0xf0000000 | 0x00800000 | 0x00400000 |
+		0x00100000 | 0x000f0000 | 0x0000f000 | 0x00000100 | 0x000000ff)
+	const base = uint32(0x0d000a00)
+	if word&^variable != base {
+		return armRawVFPLoadStore{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPLoadStore{}, false
+	}
+	bits := 32
+	register := int(word>>12) & 15
+	if word>>8&1 != 0 {
+		bits = 64
+		register += int(word>>22&1) * 16
+	} else {
+		register = register*2 + int(word>>22&1)
+	}
+	return armRawVFPLoadStore{
+		load:      word>>20&1 != 0,
+		add:       word>>23&1 != 0,
+		condition: condition,
+		base:      int(word>>16) & 15,
+		bits:      bits,
+		register:  register,
+		offset:    int(word&0xff) * 4,
+	}, true
+}
+
+func (c *armCtx) lowerRawVFPLoadStore(form armRawVFPLoadStore) error {
+	if form.base == 15 {
+		return fmt.Errorf("arm VFP immediate transfer cannot safely use PC as its base")
+	}
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawVFPLoadStore(form)
+		})
+	}
+	base, err := c.loadReg(Reg(fmt.Sprintf("R%d", form.base)))
+	if err != nil {
+		return err
+	}
+	address := base
+	if form.offset != 0 {
+		adjusted := c.newTmp()
+		operation := "sub"
+		if form.add {
+			operation = "add"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %d\n", adjusted, operation, base, form.offset)
+		address = "%" + adjusted
+	}
+	pointer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, address)
+	if form.load {
+		value := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %%%s, align 1\n", value, form.bits, pointer)
+		if form.bits == 32 {
+			return c.storeARMRawSingleBits(form.register, "%"+value, "")
+		}
+		return c.storeFReg(armRawVFPBackingReg(form.register, 64), "%"+value)
+	}
+	var value string
+	if form.bits == 32 {
+		value, err = c.loadARMRawSingleBits(form.register)
+	} else {
+		value, err = c.loadFReg(armRawVFPBackingReg(form.register, 64))
+	}
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  store i%d %s, ptr %%%s, align 1\n", form.bits, value, pointer)
+	return nil
+}
diff --git a/arm_lower_word_vfp_load_store_test.go b/arm_lower_word_vfp_load_store_test.go
new file mode 100644
index 000000000..862a141f8
--- /dev/null
+++ b/arm_lower_word_vfp_load_store_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawVFPLoadStore(load, add bool, condition, base, bits, register, offset int) uint32 {
+	word := uint32(condition)<<28 | 0x0d000a00 | uint32(base)<<16 | uint32(offset/4)
+	if load {
+		word |= 1 << 20
+	}
+	if add {
+		word |= 1 << 23
+	}
+	if bits == 32 {
+		word |= uint32(register/2) << 12
+		word |= uint32(register&1) << 22
+	} else {
+		word |= 1 << 8
+		word |= uint32(register&15) << 12
+		word |= uint32(register/16) << 22
+	}
+	return word
+}
+
+func TestARMRawVFPLoadStoreLLVM22Forms(t *testing.T) {
+	for _, test := range []struct {
+		word     uint32
+		load     bool
+		add      bool
+		base     int
+		bits     int
+		register int
+		offset   int
+	}{
+		{0xed841a01, false, true, 4, 32, 2, 4},
+		{0xed4dfaff, false, false, 13, 32, 31, 1020},
+		{0xedcd8b11, false, true, 13, 64, 24, 68},
+		{0xed941a01, true, true, 4, 32, 2, 4},
+		{0xed5d8b11, true, false, 13, 64, 24, 68},
+		{0xedd1fbff, true, true, 1, 64, 31, 1020},
+	} {
+		got, ok := decodeARMRawVFPLoadStore(test.word)
+		if !ok || got.load != test.load || got.add != test.add ||
+			got.base != test.base || got.bits != test.bits ||
+			got.register != test.register || got.offset != test.offset {
+			t.Fatalf("LLVM 22 encoding %#08x decoded as %+v, ok=%v", test.word, got, ok)
+		}
+		if word := encodeARMRawVFPLoadStore(
+			test.load, test.add, 14, test.base, test.bits, test.register, test.offset,
+		); word != test.word {
+			t.Fatalf("encoded %+v as %#08x, want %#08x", test, word, test.word)
+		}
+	}
+}
+
+func TestARMRawVFPLoadStoreAllFields(t *testing.T) {
+	for condition := 0; condition < 15; condition++ {
+		for _, load := range []bool{false, true} {
+			for _, add := range []bool{false, true} {
+				for _, bits := range []int{32, 64} {
+					for register := 0; register < 32; register++ {
+						for _, offset := range []int{0, 4, 68, 1020} {
+							word := encodeARMRawVFPLoadStore(load, add, condition, 13, bits, register, offset)
+							got, ok := decodeARMRawVFPLoadStore(word)
+							if !ok || got.load != load || got.add != add || got.bits != bits ||
+								got.register != register || got.offset != offset ||
+								got.condition != armConditionName(condition) {
+								t.Fatalf("encoding %#08x decoded as %+v, ok=%v", word, got, ok)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateARMRawVFPLoadStoreAllFormatsLLVM22(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT rawVFPLoadStore(SB), $0-0\n")
+	for _, load := range []bool{false, true} {
+		for _, add := range []bool{false, true} {
+			for _, bits := range []int{32, 64} {
+				word := encodeARMRawVFPLoadStore(load, add, 14, 13, bits, 24, 68)
+				fmt.Fprintf(&source, "\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source.WriteString("\tRET\n")
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: triple,
+		Sigs:         map[string]FuncSig{"rawVFPLoadStore": {Name: "rawVFPLoadStore", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fragment := range []string{"load i32, ptr", "load i64, ptr", "store i32", "store i64"} {
+		if !strings.Contains(ir, fragment) {
+			t.Fatalf("raw VFP load/store family omitted %q:\n%s", fragment, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, triple, "arm-raw-vfp-load-store.ll", "arm-raw-vfp-load-store.o", ir)
+}
+
+func TestARMRawVFPLoadStoreRejectsReservedAndUnsafeForms(t *testing.T) {
+	base := encodeARMRawVFPLoadStore(true, true, 14, 13, 64, 24, 68)
+	for _, word := range []uint32{base | 1<<21, base &^ 1 << 24, base &^ 1 << 9, base | 0xf0000000} {
+		if _, ok := decodeARMRawVFPLoadStore(word); ok {
+			t.Fatalf("accepted reserved VFP load/store encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawVFPLoadStore(true, true, 14, 15, 64, 24, 68)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badVFPLoad(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"badVFPLoad": {Name: "badVFPLoad", Ret: Void}},
+	}); err == nil {
+		t.Fatal("accepted unsafe PC-relative raw VFP load")
+	}
+}
diff --git a/arm_lower_word_vfp_move.go b/arm_lower_word_vfp_move.go
new file mode 100644
index 000000000..901a1f3bd
--- /dev/null
+++ b/arm_lower_word_vfp_move.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+type armRawVFPMove struct {
+	condition   string
+	bits        int
+	destination int
+	source      int
+}
+
+// decodeARMRawVFPMove covers the complete A32 scalar VMOV (register) family:
+// every condition and all S0..S31 and D0..D31 source/destination fields. Raw
+// single-register moves need a dedicated path because x/arch's Go syntax uses
+// F<n> for even S registers and S<n> for odd ones, while source-level Go F
+// registers represent a different register view.
+func decodeARMRawVFPMove(word uint32) (armRawVFPMove, bool) {
+	const mask = uint32(0x0fbf0ed0)
+	const base = uint32(0x0eb00a40)
+	if word&mask != base {
+		return armRawVFPMove{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPMove{}, false
+	}
+	bits := 32
+	destination := int(word>>12) & 15
+	source := int(word) & 15
+	if word>>8&1 != 0 {
+		bits = 64
+		destination += int(word>>22&1) * 16
+		source += int(word>>5&1) * 16
+	} else {
+		destination = destination*2 + int(word>>22&1)
+		source = source*2 + int(word>>5&1)
+	}
+	return armRawVFPMove{
+		condition:   condition,
+		bits:        bits,
+		destination: destination,
+		source:      source,
+	}, true
+}
+
+func (c *armCtx) lowerRawVFPMove(form armRawVFPMove) error {
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawVFPMove(form)
+		})
+	}
+	if form.bits == 32 {
+		value, err := c.loadARMRawSingleBits(form.source)
+		if err != nil {
+			return err
+		}
+		return c.storeARMRawSingleBits(form.destination, value, "")
+	}
+	value, err := c.loadFReg(armRawVFPBackingReg(form.source, 64))
+	if err != nil {
+		return err
+	}
+	return c.storeFReg(armRawVFPBackingReg(form.destination, 64), value)
+}
diff --git a/arm_lower_word_vfp_move_test.go b/arm_lower_word_vfp_move_test.go
new file mode 100644
index 000000000..09e359777
--- /dev/null
+++ b/arm_lower_word_vfp_move_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawVFPConditionalMoveGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawConditionalMove(SB), $0-0
+	CMP R0, R1
+	WORD $0xceb04a60 // vmovgt.f32 s8, s1
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawConditionalMove": {Name: "rawConditionalMove", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"lshr i64", "trunc i64", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw conditional VFP move IR omitted %q:\n%s", want, ir)
+		}
+	}
+	// Inspect the real conditional edge and its store, not the private
+	// spelling of an injectively escaped block label.
+	edge := regexp.MustCompile(`br i1 (%[A-Za-z0-9_]+), label %([A-Za-z0-9_]+), label %([A-Za-z0-9_]+)`).FindStringSubmatch(ir)
+	if len(edge) != 4 || edge[2] == edge[3] {
+		t.Fatal("conditional VFP move lost its distinct taken/join edges")
+	}
+	taken := regexp.MustCompile(`(?ms)^` + regexp.QuoteMeta(edge[2]) + `:[^\n]*\n(.*?)(?:^[A-Za-z0-9_]+:|^\})`).FindStringSubmatch(ir)
+	if len(taken) != 2 || !strings.Contains(taken[1], "ptr %freg_F4") ||
+		!regexp.MustCompile(`store i64 %[A-Za-z0-9_]+, ptr %freg_F4`).MatchString(taken[1]) ||
+		!strings.Contains(taken[1], "br label %"+edge[3]) ||
+		len(regexp.MustCompile(`store i64 %[A-Za-z0-9_]+, ptr %freg_F4`).FindAllString(ir, -1)) != 1 {
+		t.Fatalf("conditional VFP store is not confined to the taken edge:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-move.ll", "arm-raw-vfp-move.o", ir)
+}
+
+func encodeARMRawVFPMove(condition, bits, destination, source int) uint32 {
+	word := uint32(condition)<<28 | 0x0eb00a40
+	if bits == 32 {
+		word |= uint32(destination/2) << 12
+		word |= uint32(destination&1) << 22
+		word |= uint32(source / 2)
+		word |= uint32(source&1) << 5
+	} else {
+		word |= 1 << 8
+		word |= uint32(destination&15) << 12
+		word |= uint32(destination/16) << 22
+		word |= uint32(source & 15)
+		word |= uint32(source/16) << 5
+	}
+	return word
+}
+
+func TestARMRawVFPMoveDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for _, bits := range []int{32, 64} {
+			for destination := 0; destination < 32; destination++ {
+				for source := 0; source < 32; source++ {
+					word := encodeARMRawVFPMove(condition, bits, destination, source)
+					got, ok := decodeARMRawVFPMove(word)
+					if !ok || got.condition != armConditionName(condition) || got.bits != bits || got.destination != destination || got.source != source {
+						t.Fatalf("decoded VFP VMOV %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 30720 {
+		t.Fatalf("covered %d scalar VFP VMOV encodings, want 30720", count)
+	}
+}
+
+func TestTranslateARMRawVFPMoveCompleteFormats(t *testing.T) {
+	source := "TEXT rawMoveAll(SB), $0-0\n\tCMP R0, R1\n"
+	for condition := 0; condition < 15; condition++ {
+		for _, test := range []struct {
+			bits        int
+			destination int
+			source      int
+		}{{32, 0, 31}, {32, 31, 0}, {64, 0, 31}, {64, 31, 0}} {
+			source += fmt.Sprintf("\tWORD $%#08x\n", encodeARMRawVFPMove(condition, test.bits, test.destination, test.source))
+		}
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMoveAll": {Name: "rawMoveAll", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"lshr i64", "shl i64", "cond_5feffect_5ftaken", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP VMOV complete formats omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-move-all.ll", "arm-raw-vfp-move-all.o", ir)
+}
+
+func TestARMRawVFPMoveRejectsReservedConditionAndDifferentFamilies(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawVFPMove(15, 32, 0, 0),
+		encodeARMRawVFPMove(14, 32, 0, 0) | 1<<16,
+		encodeARMRawVFPMove(14, 32, 0, 0) | 1<<4,
+	} {
+		if _, ok := decodeARMRawVFPMove(word); ok {
+			t.Fatalf("scalar VFP VMOV decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_vfp_multiple.go b/arm_lower_word_vfp_multiple.go
new file mode 100644
index 000000000..d694a8696
--- /dev/null
+++ b/arm_lower_word_vfp_multiple.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import "fmt"
+
+type armRawVFPMultiple struct {
+	load      bool
+	decrement bool
+	writeback bool
+	condition string
+	base      int
+	bits      int
+	first     int
+	count     int
+}
+
+// decodeARMRawVFPMultiple covers the complete A32 VLDM/VSTM IA and DB
+// encoding family for contiguous S0..S31 and D0..D31 register lists. DB is
+// architecturally a writeback form; encodings without W are rejected.
+func decodeARMRawVFPMultiple(word uint32) (armRawVFPMultiple, bool) {
+	if word&0x0e000e00 != 0x0c000a00 {
+		return armRawVFPMultiple{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPMultiple{}, false
+	}
+	p := word>>24&1 != 0
+	u := word>>23&1 != 0
+	if p == u || p && word>>21&1 == 0 {
+		return armRawVFPMultiple{}, false
+	}
+	bits := 32
+	if word>>8&1 != 0 {
+		bits = 64
+	}
+	first := int(word>>12) & 15
+	if bits == 32 {
+		first = first*2 + int(word>>22&1)
+	} else {
+		first += int(word>>22&1) * 16
+	}
+	encodedCount := int(word & 0xff)
+	if encodedCount == 0 || bits == 64 && encodedCount&1 != 0 {
+		return armRawVFPMultiple{}, false
+	}
+	count := encodedCount
+	if bits == 64 {
+		count /= 2
+	}
+	if first+count > 32 {
+		return armRawVFPMultiple{}, false
+	}
+	return armRawVFPMultiple{
+		load:      word>>20&1 != 0,
+		decrement: p,
+		writeback: word>>21&1 != 0,
+		condition: condition,
+		base:      int(word>>16) & 15,
+		bits:      bits,
+		first:     first,
+		count:     count,
+	}, true
+}
+
+func (c *armCtx) lowerRawVFPMultiple(form armRawVFPMultiple) error {
+	if form.base == 15 {
+		return fmt.Errorf("arm VFP multiple transfer cannot safely use PC as its base")
+	}
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawVFPMultiple(form)
+		})
+	}
+
+	baseReg := Reg(fmt.Sprintf("R%d", form.base))
+	base, err := c.loadReg(baseReg)
+	if err != nil {
+		return err
+	}
+	bytes := form.count * (form.bits / 8)
+	address := base
+	if form.decrement {
+		adjusted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub i32 %s, %d\n", adjusted, base, bytes)
+		address = "%" + adjusted
+	}
+	for i := 0; i < form.count; i++ {
+		itemAddress := address
+		if offset := i * (form.bits / 8); offset != 0 {
+			adjusted := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = add i32 %s, %d\n", adjusted, address, offset)
+			itemAddress = "%" + adjusted
+		}
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", pointer, itemAddress)
+		register := form.first + i
+		if form.load {
+			value := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = load i%d, ptr %%%s, align 1\n", value, form.bits, pointer)
+			if form.bits == 32 {
+				if err := c.storeARMRawSingleBits(register, "%"+value, ""); err != nil {
+					return err
+				}
+			} else if err := c.storeFReg(armRawVFPBackingReg(register, 64), "%"+value); err != nil {
+				return err
+			}
+			continue
+		}
+
+		var value string
+		if form.bits == 32 {
+			value, err = c.loadARMRawSingleBits(register)
+		} else {
+			value, err = c.loadFReg(armRawVFPBackingReg(register, 64))
+		}
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i%d %s, ptr %%%s, align 1\n", form.bits, value, pointer)
+	}
+	if form.writeback {
+		updated := c.newTmp()
+		operation := "add"
+		if form.decrement {
+			operation = "sub"
+		}
+		fmt.Fprintf(c.b, "  %%%s = %s i32 %s, %d\n", updated, operation, base, bytes)
+		return c.storeReg(baseReg, "%"+updated)
+	}
+	return nil
+}
diff --git a/arm_lower_word_vfp_multiple_test.go b/arm_lower_word_vfp_multiple_test.go
new file mode 100644
index 000000000..3991314be
--- /dev/null
+++ b/arm_lower_word_vfp_multiple_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawVFPMultiple(load, decrement, writeback bool, condition, base, bits, first, count int) uint32 {
+	word := uint32(condition)<<28 | 0x0c000a00 | uint32(base)<<16
+	if decrement {
+		word |= 1 << 24
+	} else {
+		word |= 1 << 23
+	}
+	if writeback {
+		word |= 1 << 21
+	}
+	if load {
+		word |= 1 << 20
+	}
+	if bits == 32 {
+		word |= uint32(first/2) << 12
+		word |= uint32(first&1) << 22
+		word |= uint32(count)
+	} else {
+		word |= 1 << 8
+		word |= uint32(first&15) << 12
+		word |= uint32(first/16) << 22
+		word |= uint32(count * 2)
+	}
+	return word
+}
+
+func TestTranslateARMRawVFPMultipleCompleteModes(t *testing.T) {
+	const source = `TEXT rawMultiple(SB), $0-0
+	WORD $0xeca30a04 // vstmia r3!, {s0-s3}
+	WORD $0xecb11a04 // vldmia r1!, {s2-s5}
+	WORD $0xecb02b10 // vldmia r0!, {d2-d9}
+	WORD $0xeca12b10 // vstmia r1!, {d2-d9}
+	WORD $0xed324a04 // vldmdb r2!, {s8-s11}
+	WORD $0xed630b20 // vstmdb r3!, {d16-d31}
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawMultiple": {Name: "rawMultiple", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"load i32, ptr", "load i64, ptr", "store i32", "store i64", "sub i32", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP multiple IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-multiple.ll", "arm-raw-vfp-multiple.o", ir)
+}
+
+func TestARMRawVFPMultipleDecoderCoversEveryValidField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for _, load := range []bool{false, true} {
+			for _, decrement := range []bool{false, true} {
+				for _, writeback := range []bool{false, true} {
+					if decrement && !writeback {
+						continue
+					}
+					for base := 0; base < 16; base++ {
+						for _, bits := range []int{32, 64} {
+							for first := 0; first < 32; first++ {
+								for registers := 1; registers <= 32-first; registers++ {
+									word := encodeARMRawVFPMultiple(load, decrement, writeback, condition, base, bits, first, registers)
+									got, ok := decodeARMRawVFPMultiple(word)
+									if !ok || got.load != load || got.decrement != decrement || got.writeback != writeback || got.condition != armConditionName(condition) || got.base != base || got.bits != bits || got.first != first || got.count != registers {
+										t.Fatalf("decoded VFP multiple %#08x as %+v, ok=%v", word, got, ok)
+									}
+									count++
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if count == 0 {
+		t.Fatal("covered no VFP multiple encodings")
+	}
+}
+
+func TestARMRawVFPMultipleRejectsReservedAndUnsafeForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawVFPMultiple(true, false, true, 15, 0, 32, 0, 1),
+		encodeARMRawVFPMultiple(true, true, false, 14, 0, 32, 0, 1),
+		encodeARMRawVFPMultiple(true, false, true, 14, 0, 32, 31, 2),
+	} {
+		if _, ok := decodeARMRawVFPMultiple(word); ok {
+			t.Fatalf("VFP multiple decoder accepted reserved encoding %#08x", word)
+		}
+	}
+	word := encodeARMRawVFPMultiple(true, false, true, 14, 15, 32, 0, 1)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT badMultiple(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"badMultiple": {Name: "badMultiple", Ret: Void}}}); err == nil {
+		t.Fatal("Translate accepted PC as VFP multiple base")
+	}
+}
diff --git a/arm_lower_word_vfp_scalar_arithmetic.go b/arm_lower_word_vfp_scalar_arithmetic.go
new file mode 100644
index 000000000..2fd9e270f
--- /dev/null
+++ b/arm_lower_word_vfp_scalar_arithmetic.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import "fmt"
+
+type armRawVFPScalarArithmetic struct {
+	kind        string
+	condition   string
+	bits        int
+	destination int
+	lhs         int
+	rhs         int
+}
+
+// decodeARMRawVFPScalarArithmetic covers the complete classic A32 scalar VFP
+// arithmetic family: add, subtract, multiply, negative multiply, divide, and
+// the four accumulating multiply forms, for F32/F64 and every executable
+// condition and register field.
+func decodeARMRawVFPScalarArithmetic(word uint32) (armRawVFPScalarArithmetic, bool) {
+	const variable = uint32(0xf0000000 | 0x00400000 | 0x000f0000 | 0x0000f000 | 0x00000100 | 0x00000080 | 0x00000020 | 0x0000000f)
+	var kind string
+	switch word &^ variable {
+	case 0x0e300a00:
+		kind = "add"
+	case 0x0e300a40:
+		kind = "sub"
+	case 0x0e200a00:
+		kind = "mul"
+	case 0x0e200a40:
+		kind = "nmul"
+	case 0x0e800a00:
+		kind = "div"
+	case 0x0e000a00:
+		kind = "madd"
+	case 0x0e000a40:
+		kind = "msub"
+	case 0x0e100a40:
+		kind = "nmadd"
+	case 0x0e100a00:
+		kind = "nmsub"
+	default:
+		return armRawVFPScalarArithmetic{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPScalarArithmetic{}, false
+	}
+	bits := 32
+	destination := int(word>>12) & 15
+	lhs := int(word>>16) & 15
+	rhs := int(word) & 15
+	if word>>8&1 != 0 {
+		bits = 64
+		destination += int(word>>22&1) * 16
+		lhs += int(word>>7&1) * 16
+		rhs += int(word>>5&1) * 16
+	} else {
+		destination = destination*2 + int(word>>22&1)
+		lhs = lhs*2 + int(word>>7&1)
+		rhs = rhs*2 + int(word>>5&1)
+	}
+	return armRawVFPScalarArithmetic{
+		kind:        kind,
+		condition:   condition,
+		bits:        bits,
+		destination: destination,
+		lhs:         lhs,
+		rhs:         rhs,
+	}, true
+}
+
+func (c *armCtx) storeARMRawVFPRegValue(number, bits int, value string) error {
+	encoded := c.newTmp()
+	if bits == 32 {
+		fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", encoded, value)
+		return c.storeARMRawSingleBits(number, "%"+encoded, "")
+	}
+	fmt.Fprintf(c.b, "  %%%s = bitcast double %s to i64\n", encoded, value)
+	return c.storeFReg(armRawVFPBackingReg(number, 64), "%"+encoded)
+}
+
+func (c *armCtx) lowerRawVFPScalarArithmetic(form armRawVFPScalarArithmetic) error {
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawVFPScalarArithmetic(form)
+		})
+	}
+	lhs, err := c.loadARMRawVFPRegValue(form.lhs, form.bits)
+	if err != nil {
+		return err
+	}
+	rhs, err := c.loadARMRawVFPRegValue(form.rhs, form.bits)
+	if err != nil {
+		return err
+	}
+	floatType := "float"
+	if form.bits == 64 {
+		floatType = "double"
+	}
+	emitBinary := func(operation, left, right string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = %s %s %s, %s\n", name, operation, floatType, left, right)
+		return "%" + name
+	}
+	emitNeg := func(value string) string {
+		name := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = fneg %s %s\n", name, floatType, value)
+		return "%" + name
+	}
+
+	var result string
+	switch form.kind {
+	case "add":
+		result = emitBinary("fadd", lhs, rhs)
+	case "sub":
+		result = emitBinary("fsub", lhs, rhs)
+	case "mul":
+		result = emitBinary("fmul", lhs, rhs)
+	case "nmul":
+		result = emitNeg(emitBinary("fmul", lhs, rhs))
+	case "div":
+		result = emitBinary("fdiv", lhs, rhs)
+	default:
+		accumulator, loadErr := c.loadARMRawVFPRegValue(form.destination, form.bits)
+		if loadErr != nil {
+			return loadErr
+		}
+		product := emitBinary("fmul", lhs, rhs)
+		switch form.kind {
+		case "madd":
+			result = emitBinary("fadd", accumulator, product)
+		case "msub":
+			result = emitBinary("fsub", accumulator, product)
+		case "nmadd":
+			result = emitNeg(emitBinary("fadd", accumulator, product))
+		case "nmsub":
+			result = emitBinary("fsub", product, accumulator)
+		}
+	}
+	return c.storeARMRawVFPRegValue(form.destination, form.bits, result)
+}
diff --git a/arm_lower_word_vfp_scalar_arithmetic_test.go b/arm_lower_word_vfp_scalar_arithmetic_test.go
new file mode 100644
index 000000000..ca8092215
--- /dev/null
+++ b/arm_lower_word_vfp_scalar_arithmetic_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var armRawVFPScalarArithmeticTestBases = map[string]uint32{
+	"add":   0x0e300a00,
+	"sub":   0x0e300a40,
+	"mul":   0x0e200a00,
+	"nmul":  0x0e200a40,
+	"div":   0x0e800a00,
+	"madd":  0x0e000a00,
+	"msub":  0x0e000a40,
+	"nmadd": 0x0e100a40,
+	"nmsub": 0x0e100a00,
+}
+
+func encodeARMRawVFPScalarArithmetic(kind string, condition, bits, destination, lhs, rhs int) uint32 {
+	word := uint32(condition)<<28 | armRawVFPScalarArithmeticTestBases[kind]
+	if bits == 64 {
+		word |= 1 << 8
+		word |= uint32(destination&15) << 12
+		word |= uint32(destination/16) << 22
+		word |= uint32(lhs&15) << 16
+		word |= uint32(lhs/16) << 7
+		word |= uint32(rhs & 15)
+		word |= uint32(rhs/16) << 5
+		return word
+	}
+	word |= uint32(destination/2) << 12
+	word |= uint32(destination&1) << 22
+	word |= uint32(lhs/2) << 16
+	word |= uint32(lhs&1) << 7
+	word |= uint32(rhs / 2)
+	word |= uint32(rhs&1) << 5
+	return word
+}
+
+func TestTranslateARMRawVFPScalarArithmeticGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawScalarArithmetic(SB), $0-0
+	WORD $0xee611a80 // vmul.f32 s3, s3, s0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawScalarArithmetic": {Name: "rawScalarArithmetic", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"fmul float", "lshr i64", "and i64", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP scalar arithmetic omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-scalar-arithmetic.ll", "arm-raw-vfp-scalar-arithmetic.o", ir)
+}
+
+func TestARMRawVFPScalarArithmeticDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for kind := range armRawVFPScalarArithmeticTestBases {
+		for condition := 0; condition < 15; condition++ {
+			for _, bits := range []int{32, 64} {
+				for destination := 0; destination < 32; destination++ {
+					for lhs := 0; lhs < 32; lhs++ {
+						for rhs := 0; rhs < 32; rhs++ {
+							word := encodeARMRawVFPScalarArithmetic(kind, condition, bits, destination, lhs, rhs)
+							got, ok := decodeARMRawVFPScalarArithmetic(word)
+							if !ok || got.kind != kind || got.condition != armConditionName(condition) || got.bits != bits || got.destination != destination || got.lhs != lhs || got.rhs != rhs {
+								t.Fatalf("decoded scalar VFP arithmetic %#08x as %+v, ok=%v", word, got, ok)
+							}
+							count++
+						}
+					}
+				}
+			}
+		}
+	}
+	if count != 8847360 {
+		t.Fatalf("covered %d scalar VFP arithmetic encodings, want 8847360", count)
+	}
+}
+
+func TestTranslateARMRawVFPScalarArithmeticAllOperations(t *testing.T) {
+	source := "TEXT rawScalarArithmeticAll(SB), $0-0\n\tCMP R0, R1\n"
+	for kind := range armRawVFPScalarArithmeticTestBases {
+		for _, bits := range []int{32, 64} {
+			for _, condition := range []int{1, 14} {
+				word := encodeARMRawVFPScalarArithmetic(kind, condition, bits, 3, 5, 7)
+				source += fmt.Sprintf("\tWORD $%#08x\n", word)
+			}
+		}
+	}
+	source += "\tRET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawScalarArithmeticAll": {Name: "rawScalarArithmeticAll", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"fadd float", "fsub double", "fmul float", "fdiv double", "fneg float", "cond_5feffect_5ftaken", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP scalar arithmetic family omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-scalar-arithmetic-all.ll", "arm-raw-vfp-scalar-arithmetic-all.o", ir)
+}
+
+func TestARMRawVFPScalarArithmeticRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawVFPScalarArithmetic("mul", 15, 32, 0, 0, 0),
+		encodeARMRawVFPScalarArithmetic("mul", 14, 32, 0, 0, 0) ^ 1<<9,
+	} {
+		if _, ok := decodeARMRawVFPScalarArithmetic(word); ok {
+			t.Fatalf("scalar VFP arithmetic decoder accepted reserved encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_lower_word_vfp_status.go b/arm_lower_word_vfp_status.go
new file mode 100644
index 000000000..6ee9312af
--- /dev/null
+++ b/arm_lower_word_vfp_status.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import "fmt"
+
+type armRawVFPStatusTransfer struct {
+	toCore    bool
+	toFlags   bool
+	condition string
+	core      int
+}
+
+// decodeARMRawVFPStatusTransfer covers VMRS Rt,FPSCR, VMSR FPSCR,Rt, and the
+// VMRS APSR_nzcv,FPSCR form for every executable A32 condition. PC is reserved
+// as a VMSR source and denotes APSR_nzcv only in the VMRS direction.
+func decodeARMRawVFPStatusTransfer(word uint32) (armRawVFPStatusTransfer, bool) {
+	const mask = uint32(0x0fff0fff)
+	key := word & mask
+	toCore := false
+	switch key {
+	case 0x0ee10a10:
+	case 0x0ef10a10:
+		toCore = true
+	default:
+		return armRawVFPStatusTransfer{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVFPStatusTransfer{}, false
+	}
+	core := int(word>>12) & 15
+	if !toCore && core == 15 {
+		return armRawVFPStatusTransfer{}, false
+	}
+	return armRawVFPStatusTransfer{
+		toCore:    toCore,
+		toFlags:   toCore && core == 15,
+		condition: condition,
+		core:      core,
+	}, true
+}
+
+func (c *armCtx) lowerRawVFPStatusTransfer(form armRawVFPStatusTransfer) error {
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerRawVFPStatusTransfer(form)
+		})
+	}
+	if form.toFlags {
+		if !c.flagsWritten && !c.vfpCompareWritten {
+			return fmt.Errorf("%w: raw VMRS has no preceding modeled VFP flag write", ErrProbeNeedsContext)
+		}
+		status := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n", status, "vmrs $0, fpscr", "=r,~{memory}")
+		c.storeFlagsFromStatus("%" + status)
+		return nil
+	}
+	core := Reg(fmt.Sprintf("R%d", form.core))
+	if form.toCore {
+		status := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect %q, %q()\n", status, "vmrs $0, fpscr", "=r,~{memory}")
+		return c.storeReg(core, "%"+status)
+	}
+	status, err := c.loadReg(core)
+	if err != nil {
+		return err
+	}
+	fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n", "vmsr fpscr, $0", "r,~{memory}", status)
+	return nil
+}
diff --git a/arm_lower_word_vfp_status_test.go b/arm_lower_word_vfp_status_test.go
new file mode 100644
index 000000000..a422a45b6
--- /dev/null
+++ b/arm_lower_word_vfp_status_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawVFPStatusTransfer(toCore bool, condition, core int) uint32 {
+	word := uint32(condition)<<28 | 0x0ee10a10 | uint32(core)<<12
+	if toCore {
+		word |= 1 << 20
+	}
+	return word
+}
+
+func TestTranslateARMRawVFPStatusGoDSPRegression(t *testing.T) {
+	const source = `TEXT rawStatus(SB), $0-0
+	WORD $0xeef13a10 // vmrs r3, fpscr
+	WORD $0xeee13a10 // vmsr fpscr, r3
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawStatus": {Name: "rawStatus", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"vmrs $0, fpscr", "vmsr fpscr, $0", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VFP status transfer omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vfp-status.ll", "arm-raw-vfp-status.o", ir)
+}
+
+func TestARMRawVFPStatusDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for core := 0; core < 15; core++ {
+			for _, toCore := range []bool{false, true} {
+				word := encodeARMRawVFPStatusTransfer(toCore, condition, core)
+				got, ok := decodeARMRawVFPStatusTransfer(word)
+				if !ok || got.toCore != toCore || got.toFlags || got.condition != armConditionName(condition) || got.core != core {
+					t.Fatalf("decoded VFP status transfer %#08x as %+v, ok=%v", word, got, ok)
+				}
+				count++
+			}
+		}
+		word := encodeARMRawVFPStatusTransfer(true, condition, 15)
+		got, ok := decodeARMRawVFPStatusTransfer(word)
+		if !ok || !got.toCore || !got.toFlags || got.condition != armConditionName(condition) {
+			t.Fatalf("decoded VFP flag transfer %#08x as %+v, ok=%v", word, got, ok)
+		}
+		count++
+	}
+	if count != 465 {
+		t.Fatalf("covered %d VFP status transfers, want 465", count)
+	}
+}
+
+func TestARMRawVFPStatusRejectsReservedForms(t *testing.T) {
+	for _, word := range []uint32{
+		encodeARMRawVFPStatusTransfer(false, 14, 15),
+		encodeARMRawVFPStatusTransfer(true, 15, 0),
+		encodeARMRawVFPStatusTransfer(true, 14, 0) ^ 1<<8,
+	} {
+		if got, ok := decodeARMRawVFPStatusTransfer(word); ok {
+			t.Fatalf("VFP status decoder accepted reserved encoding %#08x as %+v", word, got)
+		}
+	}
+
+	word := encodeARMRawVFPStatusTransfer(true, 14, 15)
+	file, err := Parse(ArchARM, fmt.Sprintf("TEXT missingCompare(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"missingCompare": {Name: "missingCompare", Ret: Void}}}); err == nil || !strings.Contains(err.Error(), ErrProbeNeedsContext.Error()) {
+		t.Fatalf("flag transfer without comparison returned %v, want context error", err)
+	}
+}
diff --git a/arm_lower_word_vmov_pair.go b/arm_lower_word_vmov_pair.go
new file mode 100644
index 000000000..cf50bde04
--- /dev/null
+++ b/arm_lower_word_vmov_pair.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import "fmt"
+
+type armRawVMOVPair struct {
+	toFloat     bool
+	double      bool
+	condition   string
+	firstCore   int
+	secondCore  int
+	firstSingle int
+	firstDouble int
+}
+
+// decodeARMRawVMOVPair covers both A32 directions between a pair of core
+// registers and either two adjacent S registers or one D register, across
+// every executable condition and encoded register field.
+func decodeARMRawVMOVPair(word uint32) (armRawVMOVPair, bool) {
+	const mask = uint32(0x0ff00fd0)
+
+	toFloat := false
+	double := false
+	switch word & mask {
+	case 0x0c400a10:
+		toFloat = true
+	case 0x0c500a10:
+	case 0x0c400b10:
+		toFloat = true
+		double = true
+	case 0x0c500b10:
+		double = true
+	default:
+		return armRawVMOVPair{}, false
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armRawVMOVPair{}, false
+	}
+	firstSingle := int(word&0xf)*2 + int(word>>5&1)
+	if !double && firstSingle >= 31 {
+		return armRawVMOVPair{}, false
+	}
+	return armRawVMOVPair{
+		toFloat:     toFloat,
+		double:      double,
+		condition:   condition,
+		firstCore:   int(word>>12) & 15,
+		secondCore:  int(word>>16) & 15,
+		firstSingle: firstSingle,
+		firstDouble: int(word&0xf) + int(word>>5&1)*16,
+	}, true
+}
+
+func (c *armCtx) loadARMRawSingleBits(number int) (string, error) {
+	wide, err := c.loadFReg(armRawVFPBackingReg(number, 32))
+	if err != nil {
+		return "", err
+	}
+	if number&1 != 0 {
+		shifted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", shifted, wide)
+		wide = "%" + shifted
+	}
+	narrow := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", narrow, wide)
+	return "%" + narrow, nil
+}
+
+func (c *armCtx) storeARMRawSingleBits(number int, value, condition string) error {
+	reg := armRawVFPBackingReg(number, 32)
+	old, err := c.loadFReg(reg)
+	if err != nil {
+		return err
+	}
+	extended := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", extended, value)
+	newBits := "%" + extended
+	if number&1 != 0 {
+		shifted := c.newTmp()
+		kept := c.newTmp()
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %s, 32\n", shifted, newBits)
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, 4294967295\n", kept, old)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", merged, kept, shifted)
+		newBits = "%" + merged
+	} else {
+		kept := c.newTmp()
+		merged := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = and i64 %s, -4294967296\n", kept, old)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %s\n", merged, kept, newBits)
+		newBits = "%" + merged
+	}
+	if condition != "" && condition != "AL" {
+		conditionValue, err := c.condValue(condition)
+		if err != nil {
+			return err
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", selected, conditionValue, newBits, old)
+		newBits = "%" + selected
+	}
+	return c.storeFReg(reg, newBits)
+}
+
+func (c *armCtx) lowerRawVMOVPair(form armRawVMOVPair) error {
+	if form.firstCore == 15 || form.secondCore == 15 {
+		return fmt.Errorf("arm VMOV register pair cannot safely use PC")
+	}
+	firstCore := Reg(fmt.Sprintf("R%d", form.firstCore))
+	secondCore := Reg(fmt.Sprintf("R%d", form.secondCore))
+	if form.double {
+		return c.lowerRawVMOVDoublePair(form, firstCore, secondCore)
+	}
+	if form.toFloat {
+		first, err := c.loadReg(firstCore)
+		if err != nil {
+			return err
+		}
+		second, err := c.loadReg(secondCore)
+		if err != nil {
+			return err
+		}
+		if err := c.storeARMRawSingleBits(form.firstSingle, first, form.condition); err != nil {
+			return err
+		}
+		return c.storeARMRawSingleBits(form.firstSingle+1, second, form.condition)
+	}
+
+	first, err := c.loadARMRawSingleBits(form.firstSingle)
+	if err != nil {
+		return err
+	}
+	second, err := c.loadARMRawSingleBits(form.firstSingle + 1)
+	if err != nil {
+		return err
+	}
+	if err := c.selectRegWrite(firstCore, form.condition, first); err != nil {
+		return err
+	}
+	return c.selectRegWrite(secondCore, form.condition, second)
+}
+
+func (c *armCtx) lowerRawVMOVDoublePair(form armRawVMOVPair, firstCore, secondCore Reg) error {
+	floatReg := armRawVFPBackingReg(form.firstDouble, 64)
+	if form.toFloat {
+		low, err := c.loadReg(firstCore)
+		if err != nil {
+			return err
+		}
+		high, err := c.loadReg(secondCore)
+		if err != nil {
+			return err
+		}
+		lowWide := c.newTmp()
+		highWide := c.newTmp()
+		shifted := c.newTmp()
+		combined := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", lowWide, low)
+		fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", highWide, high)
+		fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", shifted, highWide)
+		fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", combined, lowWide, shifted)
+		value := "%" + combined
+		if form.condition != "" && form.condition != "AL" {
+			condition, err := c.condValue(form.condition)
+			if err != nil {
+				return err
+			}
+			old, err := c.loadFReg(floatReg)
+			if err != nil {
+				return err
+			}
+			selected := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = select i1 %s, i64 %s, i64 %s\n", selected, condition, value, old)
+			value = "%" + selected
+		}
+		return c.storeFReg(floatReg, value)
+	}
+
+	wide, err := c.loadFReg(floatReg)
+	if err != nil {
+		return err
+	}
+	low := c.newTmp()
+	shifted := c.newTmp()
+	high := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %s to i32\n", low, wide)
+	fmt.Fprintf(c.b, "  %%%s = lshr i64 %s, 32\n", shifted, wide)
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", high, shifted)
+	if err := c.selectRegWrite(firstCore, form.condition, "%"+low); err != nil {
+		return err
+	}
+	return c.selectRegWrite(secondCore, form.condition, "%"+high)
+}
diff --git a/arm_lower_word_vmov_pair_test.go b/arm_lower_word_vmov_pair_test.go
new file mode 100644
index 000000000..ef5ce492f
--- /dev/null
+++ b/arm_lower_word_vmov_pair_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func encodeARMRawVMOVPair(toFloat bool, condition, firstCore, secondCore, firstSingle int) uint32 {
+	word := uint32(condition)<<28 | 0x0c400a10 | uint32(secondCore)<<16 | uint32(firstCore)<<12 | uint32(firstSingle/2)
+	if !toFloat {
+		word |= 1 << 20
+	}
+	if firstSingle&1 != 0 {
+		word |= 1 << 5
+	}
+	return word
+}
+
+func encodeARMRawVMOVDoublePair(toFloat bool, condition, firstCore, secondCore, double int) uint32 {
+	word := uint32(condition)<<28 | 0x0c400b10 | uint32(secondCore)<<16 | uint32(firstCore)<<12 | uint32(double&15)
+	if !toFloat {
+		word |= 1 << 20
+	}
+	if double&16 != 0 {
+		word |= 1 << 5
+	}
+	return word
+}
+
+func TestTranslateARMRawVMOVDoublePairCompleteDirections(t *testing.T) {
+	const source = `TEXT rawVMOVDoublePair(SB), $0-0
+	WORD $0xec454b38 // vmov d24, r4, r5
+	WORD $0xec554b38 // vmov r4, r5, d24
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawVMOVDoublePair": {Name: "rawVMOVDoublePair", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"shl i64", "lshr i64", "trunc i64", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("double-register VMOV pair IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vmov-double-pair.ll", "arm-raw-vmov-double-pair.o", ir)
+}
+
+func TestARMRawVMOVDoublePairDecoderCoversEveryEncodingField(t *testing.T) {
+	for _, toFloat := range []bool{false, true} {
+		for condition := 0; condition < 15; condition++ {
+			for firstCore := 0; firstCore < 16; firstCore++ {
+				for secondCore := 0; secondCore < 16; secondCore++ {
+					for double := 0; double < 32; double++ {
+						word := encodeARMRawVMOVDoublePair(toFloat, condition, firstCore, secondCore, double)
+						got, ok := decodeARMRawVMOVPair(word)
+						if !ok || !got.double || got.toFloat != toFloat || got.condition != armConditionName(condition) || got.firstCore != firstCore || got.secondCore != secondCore || got.firstDouble != double {
+							t.Fatalf("decoded double-register VMOV pair %#08x as %+v, ok=%v", word, got, ok)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestTranslateARMRawVMOVPairCompleteDirections(t *testing.T) {
+	const source = `TEXT rawVMOVPair(SB), $0-0
+	WORD $0xec454a1e // vmov s28, s29, r4, r5
+	WORD $0xec476a1f // vmov s30, s31, r6, r7
+	WORD $0xec540a11 // vmov r0, r4, s2, s3
+	WORD $0xec5b8a12 // vmov r8, r11, s4, s5
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawVMOVPair": {Name: "rawVMOVPair", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"zext i32", "trunc i64", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("VMOV pair IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vmov-pair.ll", "arm-raw-vmov-pair.o", ir)
+}
+
+func TestARMRawVMOVPairDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for _, toFloat := range []bool{false, true} {
+		for condition := 0; condition < 15; condition++ {
+			for firstCore := 0; firstCore < 16; firstCore++ {
+				for secondCore := 0; secondCore < 16; secondCore++ {
+					for firstSingle := 0; firstSingle < 31; firstSingle++ {
+						word := encodeARMRawVMOVPair(toFloat, condition, firstCore, secondCore, firstSingle)
+						got, ok := decodeARMRawVMOVPair(word)
+						if !ok || got.toFloat != toFloat || got.condition != armConditionName(condition) || got.firstCore != firstCore || got.secondCore != secondCore || got.firstSingle != firstSingle {
+							t.Fatalf("decoded VMOV pair %#08x as %+v, ok=%v", word, got, ok)
+						}
+						count++
+					}
+				}
+			}
+		}
+	}
+	if count != 2*15*16*16*31 {
+		t.Fatalf("covered %d VMOV pair encodings", count)
+	}
+}
+
+func TestARMRawVMOVPairRejectsReservedAndUnsafeForms(t *testing.T) {
+	if _, ok := decodeARMRawVMOVPair(encodeARMRawVMOVPair(true, 15, 0, 1, 0)); ok {
+		t.Fatal("VMOV pair decoder accepted condition 0xf")
+	}
+	if _, ok := decodeARMRawVMOVPair(encodeARMRawVMOVDoublePair(true, 15, 0, 1, 0)); ok {
+		t.Fatal("double-register VMOV pair decoder accepted condition 0xf")
+	}
+	for _, word := range []uint32{
+		encodeARMRawVMOVPair(true, 14, 15, 1, 0),
+		encodeARMRawVMOVPair(false, 14, 0, 15, 0),
+		encodeARMRawVMOVDoublePair(true, 14, 15, 1, 0),
+		encodeARMRawVMOVDoublePair(false, 14, 0, 15, 0),
+	} {
+		file, err := Parse(ArchARM, fmt.Sprintf("TEXT badVMOVPair(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"badVMOVPair": {Name: "badVMOVPair", Ret: Void}}}); err == nil {
+			t.Fatalf("Translate accepted PC in VMOV pair %#08x", word)
+		}
+	}
+}
diff --git a/arm_machine_entry.go b/arm_machine_entry.go
new file mode 100644
index 000000000..3151541ff
--- /dev/null
+++ b/arm_machine_entry.go
@@ -0,0 +1,301 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// ARMMachineReturn describes the physical source continuation, not an LLVM
+// result type. The first closed entry contract supports a source RET through
+// the unchanged incoming LR. Stack-PC resumptions require a separate proof.
+type ARMMachineReturn uint8
+
+const (
+	ARMMachineReturnLR ARMMachineReturn = iota + 1
+)
+
+// ARMMachineEntry is an explicitly requested physical-register interface.
+// It requires NOSPLIT|NOFRAME, zero Go arguments and no implicit source frame.
+// StackBelow reserves source-owned bytes below the real incoming SP. A fresh
+// private capture region sits below that range, never in source stack storage.
+// The caller provides ordinary callee-owned stack space below StackBelow; no
+// source pointer may alias that fresh private storage. Source SP-derived memory
+// accesses must instead be proved inside the declared source-owned range.
+// VFP requires an incoming VFP2 machine and transports D0..D15 and FPSCR.
+// The caller supplies a valid at-least-four-byte-aligned native ARM stack;
+// the private AAPCS body bridge separately aligns its physical SP to eight.
+// Neither a symbol name nor a missing Go declaration establishes this contract.
+type ARMMachineEntry struct {
+	StackBelow uint32
+	VFP        bool
+	Return     ARMMachineReturn
+}
+
+const (
+	armMachineCPSROffset  = 60
+	armMachineFPSCROffset = 64
+	armMachineVFPOffset   = 72
+	armMachineStateBytes  = 200
+)
+
+func validateARMMachineEntryArchitecture(file *File, opt Options) error {
+	if file == nil || file.Arch == ArchARM {
+		return nil
+	}
+	for name, sig := range opt.Sigs {
+		if sig.ARMEntry != nil {
+			return fmt.Errorf("ARM machine-entry contract supplied for non-ARM function %q", name)
+		}
+	}
+	return nil
+}
+
+func validateARMMachineEntry(fn Func, sig FuncSig, triple string) error {
+	entry := sig.ARMEntry
+	if entry == nil || entry.Return != ARMMachineReturnLR {
+		return fmt.Errorf("ARM machine entry requires an explicit supported return contract")
+	}
+	if !(strings.HasPrefix(triple, "arm") || strings.HasPrefix(triple, "thumb")) ||
+		!(strings.Contains(triple, "linux") || strings.Contains(triple, "windows")) {
+		return fmt.Errorf("ARM machine entry needs an explicit supported ARM Linux/Windows target: %q", triple)
+	}
+	if len(sig.Args) != 0 || sig.Ret != Void || len(sig.ArgRegs) != 0 || len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0 {
+		return fmt.Errorf("ARM machine entry is address-only, not a zero-argument C/Go signature")
+	}
+	if fn.FrameSize != 0 || fn.ArgSize != 0 || len(fn.Instrs) == 0 || fn.Instrs[0].Op != OpTEXT {
+		return fmt.Errorf("%w: ARM machine entry needs exact zero Go TEXT frame/arguments", ErrProbeNeedsContext)
+	}
+	parts := splitTopLevelCSV(fn.Instrs[0].Raw)
+	if len(parts) != 3 {
+		return fmt.Errorf("ARM machine entry requires explicit NOSPLIT|NOFRAME TEXT flags")
+	}
+	expression := globlFlagName.ReplaceAllStringFunc(parts[1], func(name string) string {
+		if value, ok := goTextFlagValues[name]; ok {
+			return value
+		}
+		return name
+	})
+	flags, ok := parseImmExpr(strings.TrimSpace(expression))
+	if !ok || flags != 4|512 {
+		return fmt.Errorf("ARM machine entry requires exactly NOSPLIT|NOFRAME flags")
+	}
+	if entry.StackBelow > 1<<20 || entry.StackBelow%8 != 0 {
+		return fmt.Errorf("ARM source stack bound must be eight-byte aligned and at most 1MiB")
+	}
+	// This initial closed layer does not yet model SP/LR writes, source-call
+	// continuations, raw machine effects, or aliased source stack accesses.
+	// Fail closed; none of these become a signature guess or source N/A.
+	stackAliases := map[Reg]bool{"R13": true}
+	for changed := true; changed; {
+		changed = false
+		for _, ins := range fn.Instrs {
+			op, _, _, _ := armDecodeOp(string(ins.Op))
+			if len(ins.Args) < 2 || op == "CMP" || op == "CMN" || op == "TST" || op == "TEQ" {
+				continue
+			}
+			dst := ins.Args[len(ins.Args)-1]
+			var destinations []Reg
+			if dst.Kind == OpReg {
+				destinations = []Reg{dst.Reg}
+			} else if dst.Kind == OpRegList {
+				destinations = dst.RegList
+			} else {
+				continue
+			}
+			for _, arg := range ins.Args[:len(ins.Args)-1] {
+				if (arg.Kind == OpReg || arg.Kind == OpRegShift || arg.Kind == OpRegExtend) && (stackAliases[arg.Reg] || stackAliases[arg.ShiftReg]) {
+					for _, reg := range destinations {
+						if !stackAliases[reg] {
+							stackAliases[reg], changed = true, true
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, ins := range fn.Instrs[1:] {
+		op, _, _, _ := armDecodeOp(string(ins.Op))
+		switch op {
+		case "TEXT", "LABEL", "RET", "MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU", "MOVD", "CMP", "CMN", "TST", "TEQ", "MOVM", "ADD", "SUB", "RSB", "AND", "ORR", "EOR", "BIC", "MVN", "ADC", "SBC", "RSC", "SLL", "SRL", "SRA", "MUL", "MULU", "MULA", "MULL", "MULLU", "MULAL", "MULALU":
+		case "BL", "CALL", "BX", "B", "JMP":
+			return fmt.Errorf("%w: ARM machine-entry control transfer needs a closed native/Go call-site continuation contract: %s", ErrProbeNeedsContext, ins.Raw)
+		default:
+			return fmt.Errorf("ARM machine-entry source effect is not implemented in its typed state layer: %s", ins.Raw)
+		}
+		if op == "RET" && (len(ins.Args) != 0 || len(armInstructionSuffixes(ins)) != 0) {
+			return fmt.Errorf("%w: ARM machine entry needs unconditional unchanged-LR RET: %s", ErrProbeNeedsContext, ins.Raw)
+		}
+		for i, arg := range ins.Args {
+			if armKernelOperandUsesReg(arg, "R15") || armKernelOperandUsesReg(arg, PC) || armKernelOperandUsesReg(arg, SP) {
+				return fmt.Errorf("%w: ARM source PC/pseudo-SP needs a separate layout/frame contract: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if arg.Kind == OpFP || arg.Kind == OpFPAddr || arg.Kind == OpSym {
+				return fmt.Errorf("%w: ARM native source reference needs an explicit frame/symbol contract: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if i == len(ins.Args)-1 && op != "CMP" && op != "CMN" && op != "TST" && op != "TEQ" &&
+				(arg.Kind == OpReg || arg.Kind == OpRegList) && (armKernelOperandUsesReg(arg, "R13") || armKernelOperandUsesReg(arg, "R14")) {
+				return fmt.Errorf("%w: ARM native source SP/LR write needs an explicit continuation proof: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if arg.Kind == OpIdent {
+				name := strings.ToUpper(arg.Ident)
+				if i != 0 || name != "CPSR" && name != "FPCR" && name != "FPSR" || name != "CPSR" && !entry.VFP {
+					return fmt.Errorf("%w: ARM native status effect lacks a typed source contract: %s", ErrProbeNeedsContext, ins.Raw)
+				}
+			}
+			if arg.Kind == OpReg && isARMFReg(arg.Reg) && !entry.VFP {
+				return fmt.Errorf("ARM native VFP operand requires the explicit VFP entry contract: %s", ins.Raw)
+			}
+			if op == "MOVW" && arg.Kind == OpReg && isARMFReg(arg.Reg) {
+				return fmt.Errorf("ARM native partial-FP lane effect requires a separate complete subregister model: %s", ins.Raw)
+			}
+			if arg.Kind != OpMem {
+				continue
+			}
+			if armKernelOperandUsesReg(arg, "R14") {
+				return fmt.Errorf("%w: ARM native LR-address access needs code-layout/continuation context: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if stackAliases[arg.Mem.Base] && arg.Mem.Base != "R13" || stackAliases[arg.Mem.Index] {
+				return fmt.Errorf("%w: ARM native stack alias needs an explicit source-address proof: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if shift, ok := armMemoryShift(arg.Mem); ok && (stackAliases[shift.Reg] || stackAliases[shift.ShiftReg]) {
+				return fmt.Errorf("%w: ARM native shifted stack alias needs an explicit source-address proof: %s", ErrProbeNeedsContext, ins.Raw)
+			}
+			if arg.Mem.Base == "R13" {
+				width := int64(4)
+				if spec, ok := armIntegerMemorySpecs[op]; ok {
+					width = int64(spec.bits / 8)
+				} else if op == "MOVD" {
+					width = 8
+				} else if op != "MOVF" {
+					return fmt.Errorf("%w: ARM native stack access has no typed width: %s", ErrProbeNeedsContext, ins.Raw)
+				}
+				post, writeback, _, err := armMemoryModifiers(ins)
+				if err != nil {
+					return err
+				}
+				if post || writeback || arg.Mem.Index != "" || arg.Mem.OffRaw != "" || arg.Mem.Off < -int64(entry.StackBelow) || arg.Mem.Off > -width {
+					return fmt.Errorf("%w: ARM native stack access exceeds its real source-owned backing: %s", ErrProbeNeedsContext, ins.Raw)
+				}
+			}
+		}
+	}
+	if fn.Instrs[len(fn.Instrs)-1].Op != OpRET {
+		return fmt.Errorf("%w: ARM native entry requires an explicit source RET", ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+func translateFuncARMMachineEntry(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, triple string, annotate bool) error {
+	if err := validateARMMachineEntry(fn, sig, triple); err != nil {
+		return err
+	}
+	if err := proveARMStatusReads(fn, sig); err != nil {
+		return err
+	}
+	bodyName := sig.Name + ".machine_body"
+	attrs := sig.Attrs
+	if sig.ARMEntry.VFP {
+		// The transport itself uses VFP even when the source does not mention
+		// an F register, so source-opcode inference alone is insufficient.
+		attrs += ` "target-features"="+vfp2"`
+	}
+	frameBytes := sig.ARMEntry.StackBelow + armMachineStateBytes
+	var assembly []string
+	adjustSP := func(op string) {
+		for shift := uint(0); shift < 32; shift += 8 {
+			if amount := frameBytes & (255 << shift); amount != 0 {
+				assembly = append(assembly, fmt.Sprintf("%s sp, sp, #%d", op, amount))
+			}
+		}
+	}
+	adjustSP("sub")
+	assembly = append(assembly, "stmia sp, {r0-r12}", "mrs r1, cpsr", "str r1, [sp, #60]", "str lr, [sp, #56]")
+	assembly = append(assembly, "mov r1, sp")
+	for shift := uint(0); shift < 32; shift += 8 {
+		if amount := frameBytes & (255 << shift); amount != 0 {
+			assembly = append(assembly, fmt.Sprintf("add r1, r1, #%d", amount))
+		}
+	}
+	assembly = append(assembly, "str r1, [sp, #52]")
+	if sig.ARMEntry.VFP {
+		assembly = append(assembly, "vmrs r1, fpscr", "str r1, [sp, #64]", "add r1, sp, #72", "vstmia r1, {d0-d15}")
+	}
+	// Source Go ARM stacks may be only four-byte aligned. Keep the capture
+	// pointer in AAPCS-preserved R4, align only the private body's SP, and
+	// restore the exact capture base after its typed call.
+	assembly = append(assembly, "mov r4, sp", "bic r1, r4, #7", "mov sp, r1", "mov r0, r4", "bl ${0:c}", "mov sp, r4")
+	if sig.ARMEntry.VFP {
+		assembly = append(assembly, "ldr r1, [sp, #64]", "vmsr fpscr, r1", "add r1, sp, #72", "vldmia r1, {d0-d15}")
+	}
+	assembly = append(assembly, "ldr r1, [sp, #60]", "msr APSR_nzcvq, r1", "ldr lr, [sp, #56]", "ldmia sp, {r0-r12}")
+	adjustSP("add")
+	assembly = append(assembly, "bx lr")
+	fmt.Fprintf(b, "define void %s() naked noinline %s {\nentry:\n", llvmGlobal(sig.Name), attrs)
+	fmt.Fprintf(b, "  call void asm sideeffect %q, %q(ptr %s)\n", strings.Join(assembly, "; "), "i,~{memory}", llvmGlobal(bodyName))
+	b.WriteString("  unreachable\n}\n\n")
+	fmt.Fprintf(b, "define internal void %s(ptr %%machine_state) noinline %s {\n", llvmGlobal(bodyName), attrs)
+	c := newARMCtx(b, fn, sig, resolve, sigs, annotate)
+	c.machineState, c.flagsWritten = "%machine_state", true
+	if err := c.emitEntryAllocasAndArgInit(); err != nil {
+		return err
+	}
+	if err := c.lowerBlocks(); err != nil {
+		return err
+	}
+	b.WriteString("}\n")
+	return nil
+}
+
+func (c *armCtx) machinePointer(offset int) string {
+	tmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = getelementptr i8, ptr %s, i32 %d\n", tmp, c.machineState, offset)
+	return "%" + tmp
+}
+
+func (c *armCtx) loadMachineValue(offset int, typ LLVMType) string {
+	ptr, tmp := c.machinePointer(offset), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = load %s, ptr %s, align 4\n", tmp, typ, ptr)
+	return "%" + tmp
+}
+
+func (c *armCtx) initializeMachineState() error {
+	for i := 0; i <= 14; i++ {
+		if err := c.storeReg(Reg(fmt.Sprintf("R%d", i)), c.loadMachineValue(i*4, I32)); err != nil {
+			return err
+		}
+	}
+	if err := c.storeReg(SP, c.loadMachineValue(52, I32)); err != nil {
+		return err
+	}
+	if c.sig.ARMEntry.VFP {
+		for i := 0; i < 16; i++ {
+			if err := c.storeFReg(Reg(fmt.Sprintf("F%d", i)), c.loadMachineValue(armMachineVFPOffset+i*8, I64)); err != nil {
+				return err
+			}
+		}
+	}
+	c.storeFlagsFromStatus(c.loadMachineValue(armMachineCPSROffset, I32))
+	return nil
+}
+
+func (c *armCtx) returnMachineState() error {
+	for i := 0; i <= 14; i++ {
+		value, err := c.loadReg(Reg(fmt.Sprintf("R%d", i)))
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  store i32 %s, ptr %s\n", value, c.machinePointer(i*4))
+	}
+	if c.sig.ARMEntry.VFP {
+		for i := 0; i < 16; i++ {
+			value, err := c.loadFReg(Reg(fmt.Sprintf("F%d", i)))
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(c.b, "  store i64 %s, ptr %s, align 4\n", value, c.machinePointer(armMachineVFPOffset+i*8))
+		}
+	}
+	status := c.statusWithModeledNZCV(c.loadMachineValue(armMachineCPSROffset, I32))
+	fmt.Fprintf(c.b, "  store i32 %s, ptr %s\n  ret void\n", status, c.machinePointer(armMachineCPSROffset))
+	return nil
+}
diff --git a/arm_machine_entry_runtime_test.go b/arm_machine_entry_runtime_test.go
new file mode 100644
index 000000000..99f2155a9
--- /dev/null
+++ b/arm_machine_entry_runtime_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Snapshots are source instructions, not observations made by the private LLVM
+// bridge. The independent Go object and native call sites expose every incoming
+// and restored register, including registers unused by the source computation.
+func armMachineEntryRegisterSource() string {
+	var source strings.Builder
+	source.WriteString("TEXT oracleEntry(SB),516,$0-0\n")
+	for i := 0; i < 13; i++ {
+		reg := fmt.Sprintf("R%d", i)
+		if i == 10 {
+			reg = "g"
+		}
+		fmt.Fprintf(&source, " MOVW %s,%d(R0)\n", reg, 40+i*4)
+	}
+	for i := 0; i < 16; i++ {
+		fmt.Fprintf(&source, " MOVD F%d,%d(R0)\n", i, 96+i*8)
+	}
+	source.WriteString(" MOVW FPCR,R3\n MOVW R3,224(R0)\n MOVW -8(R13),R3\n MOVW R3,440(R0)\n")
+	source.WriteString(strings.SplitN(armMachineEntrySource, "\n", 2)[1])
+	return strings.Replace(source.String(), " RET\n", " MOVD $2.0,F7\n RET\n", 1)
+}
+
+func armMachineEntryGoCaller() string {
+	var source strings.Builder
+	source.WriteString("TEXT oracle(SB),4,$16-16\n MOVW out+12(FP),R0\n")
+	for i := 0; i < 16; i++ {
+		fmt.Fprintf(&source, " MOVD $%d.0,F%d\n", i+1, i)
+	}
+	source.WriteString(" MOVW fpscr+8(FP),R4\n MOVW R4,FPCR\n MOVW R13,R12\n MOVW R12,28(R0)\n MOVW g,228(R0)\n MOVW $0x13579bdf,R12\n MOVW R12,-8(R13)\n")
+	source.WriteString(" MOVW value+0(FP),R1\n MOVW $77,R2\n MOVW status+4(FP),R3\n")
+	for i := 4; i < 13; i++ {
+		if i != 10 {
+			fmt.Fprintf(&source, " MOVW $%d,R%d\n", i, i)
+		}
+	}
+	source.WriteString(" MOVW R3,CPSR\n BL oracleEntry(SB)\n")
+	for i := 0; i < 13; i++ {
+		reg := fmt.Sprintf("R%d", i)
+		if i == 10 {
+			reg = "g"
+		}
+		fmt.Fprintf(&source, " MOVW %s,%d(R0)\n", reg, 240+i*4)
+	}
+	for i := 0; i < 16; i++ {
+		fmt.Fprintf(&source, " MOVD F%d,%d(R0)\n", i, 304+i*8)
+	}
+	source.WriteString(" MOVW R14,R4\n MOVW R4,32(R0)\n MOVW CPSR,R4\n MOVW R4,36(R0)\n MOVW FPCR,R4\n MOVW R4,432(R0)\n MOVW R13,R4\n MOVW R4,436(R0)\n MOVW -8(R13),R4\n MOVW R4,444(R0)\n MOVW $0,R4\n MOVW R4,FPCR\n RET\n")
+	return source.String()
+}
+
+func armMachineEntryNativeCaller(fourAligned bool) string {
+	assembly := []string{".syntax unified", ".text", ".arm", ".global runOracle", ".type runOracle,%function", "runOracle:", "push {r4-r11,r12,lr}"}
+	if fourAligned {
+		assembly = append(assembly, "sub sp,sp,#4")
+	}
+	for i := 0; i < 16; i++ {
+		assembly = append(assembly, fmt.Sprintf("vmov.f64 d%d,#%d.0", i, i+1))
+	}
+	assembly = append(assembly, "vmsr fpscr,r3", "mov r12,sp", "str r12,[r0,#28]", "adr r12,1f", "str r12,[r0,#32]", "ldr r12,=0x13579bdf", "str r12,[sp,#-8]", "mov r3,r2", "mov r2,#77")
+	for i := 4; i < 13; i++ {
+		assembly = append(assembly, fmt.Sprintf("mov r%d,#%d", i, i))
+	}
+	assembly = append(assembly, "str r10,[r0,#228]", "msr APSR_nzcvq,r3", "bl oracleEntry", "1:")
+	for i := 0; i < 13; i++ {
+		assembly = append(assembly, fmt.Sprintf("str r%d,[r0,#%d]", i, 240+i*4))
+	}
+	for i := 0; i < 16; i++ {
+		assembly = append(assembly, fmt.Sprintf("vstr d%d,[r0,#%d]", i, 304+i*8))
+	}
+	assembly = append(assembly, "mrs r4,cpsr", "str r4,[r0,#36]", "vmrs r4,fpscr", "str r4,[r0,#432]", "mov r4,sp", "str r4,[r0,#436]", "ldr r4,[sp,#-8]", "str r4,[r0,#444]", "mov r4,#0", "vmsr fpscr,r4")
+	if fourAligned {
+		assembly = append(assembly, "add sp,sp,#4")
+	}
+	assembly = append(assembly, "pop {r4-r11,r12,pc}")
+	return fmt.Sprintf("__asm__(%q);\n", strings.Join(assembly, "\n")+"\n")
+}
+
+func TestCrossLinuxRuntimeMatrixARMMachineEntryPhysicalState(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	entrySource := armMachineEntryRegisterSource()
+	for _, profile := range []struct {
+		name       string
+		writesNZCV bool
+	}{
+		{"preserved", false}, {"source_nzcv_writer", true},
+	} {
+		t.Run(profile.name, func(t *testing.T) {
+			source := entrySource
+			if profile.writesNZCV {
+				source = strings.Replace(source, " RET\n", " ADD.S $1,R5\n RET\n", 1)
+			}
+			runARMMachineEntryPhysicalState(t, llc, source, profile.writesNZCV)
+		})
+	}
+}
+
+func runARMMachineEntryPhysicalState(t *testing.T, llc, entrySource string, writesNZCV bool) {
+	t.Helper()
+	goSource := armMachineEntryGoCaller() + entrySource
+	goMain := `package main
+import (
+ "fmt"
+ "math"
+ "unsafe"
+)
+func oracle(value, status, fpscr uint32, out *[112]uint32)
+func main() {
+ for flags := uint32(0); flags < 32; flags++ {
+  for rounding := uint32(0); rounding < 4; rounding++ {
+   var out [112]uint32
+   status := (flags&15)<<28 | (flags>>4)<<27
+   fpscr := rounding<<22
+   oracle(0x89abcdef, status, fpscr, &out)
+   want := uint32(77)
+   if flags&4 != 0 { want = 7 }
+   exitStatus := status
+   if WRITES_NZCV { exitStatus &= 0x08000000 }
+   if out[0]&0xf8000000 != status || out[1] != out[7] || out[1] != out[109] ||
+    out[2] != out[8] || out[3] != 0x89abcdef || out[4] != 0 || out[5] != 0x3ff00000 ||
+    out[6] != want || out[9]&0xf8000000 != exitStatus || out[56] != fpscr || out[108] != fpscr ||
+    out[110] != 0x13579bdf || out[111] != 0x13579bdf {
+    panic(fmt.Sprintf("Go physical core flags=%x fpscr=%x out=%x", flags, fpscr, out))
+   }
+   for i := 0; i < 13; i++ {
+    initial := uint32(i)
+    switch i {
+    case 0: initial = uint32(uintptr(unsafe.Pointer(&out)))
+    case 1: initial = 0x89abcdef
+    case 2: initial = 77
+    case 3: initial = status
+    case 10: initial = out[57]
+    }
+    final := initial
+    if i == 2 { final = want }
+    if i == 3 { final = 0x89abcdef }
+    if i == 5 && WRITES_NZCV { final = 6 }
+    if out[10+i] != initial || out[60+i] != final {
+     panic(fmt.Sprintf("Go R%d flags=%x entry=%x want=%x exit=%x want=%x", i, flags, out[10+i], initial, out[60+i], final))
+    }
+   }
+   for i := 0; i < 16; i++ {
+    initial := math.Float64bits(float64(i+1))
+    final := initial
+    if i == 7 { final = math.Float64bits(2) }
+    got := uint64(out[24+i*2]) | uint64(out[25+i*2])<<32
+    exit := uint64(out[76+i*2]) | uint64(out[77+i*2])<<32
+    if got != initial || exit != final {
+     panic(fmt.Sprintf("Go D%d entry=%x want=%x exit=%x want=%x", i, got, initial, exit, final))
+    }
+   }
+  }
+ }
+ fmt.Println("128 Go physical GP0..12/D0..15/FPSCR/NZCVQ/SP/LR vectors passed")
+}
+`
+	runARMGoSourceOracle(t, goSource, strings.ReplaceAll(goMain, "WRITES_NZCV", fmt.Sprint(writesNZCV)))
+	file, err := Parse(ArchARM, entrySource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, armMachineEntryOptions("armv7-unknown-linux-gnueabihf"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This native assembly call site supplies the physical contract. No C call
+	// pretends the address-only carrier has a guessed zero-argument signature.
+	cMain := `#include <stdint.h>
+#include <stdio.h>
+extern void runOracle(uint32_t*,uint32_t,uint32_t,uint32_t);
+CALL_SITE
+int main(void) {
+ for(unsigned f=0; f<32; f++) {
+  for(unsigned rounding=0; rounding<4; rounding++) {
+   uint32_t out[112]={0}, status=((f&15)<<28)|((f>>4)<<27), fpscr=rounding<<22;
+   runOracle(out,0x89abcdefu,status,fpscr);
+   uint32_t want=(f&4)?7:77;
+   uint32_t exitStatus=WRITES_NZCV ? status&0x08000000u : status;
+   if((out[0]&0xf8000000u)!=status || out[1]!=out[7] || out[1]!=out[109] ||
+    out[2]!=out[8] || out[3]!=0x89abcdefu || out[4]!=0 || out[5]!=0x3ff00000 ||
+    out[6]!=want || (out[9]&0xf8000000u)!=exitStatus || out[56]!=fpscr || out[108]!=fpscr ||
+    out[110]!=0x13579bdfu || out[111]!=0x13579bdfu) {
+    fprintf(stderr,"LLVM physical core flags=%x fpscr=%x entryStatus=%x exitStatus=%x sp=%x/%x/%x lr=%x/%x stack=%x fp=%x:%x pred=%x entryFpscr=%x exitFpscr=%x\n",
+     f,fpscr,out[0],out[9],out[1],out[7],out[109],out[2],out[8],out[3],out[5],out[4],out[6],out[56],out[108]);
+    return 1;
+   }
+   for(unsigned i=0; i<13; i++) {
+    uint32_t initial=i;
+    switch(i) {
+    case 0: initial=(uintptr_t)out; break;
+    case 1: initial=0x89abcdefu; break;
+    case 2: initial=77; break;
+    case 3: initial=status; break;
+    case 10: initial=out[57]; break;
+    }
+    uint32_t final=initial;
+    if(i==2) final=want;
+    if(i==3) final=0x89abcdefu;
+    if(i==5 && WRITES_NZCV) final=6;
+    if(out[10+i]!=initial || out[60+i]!=final) {
+     fprintf(stderr,"LLVM R%u flags=%x entry=%x want=%x exit=%x want=%x\n",i,f,out[10+i],initial,out[60+i],final);
+     return 1;
+    }
+   }
+   for(unsigned i=0; i<16; i++) {
+    union { double d; uint64_t bits; } expected={(double)(i+1)}, final=expected;
+    if(i==7) final.d=2.0;
+    uint64_t initial=(uint64_t)out[24+i*2]|(uint64_t)out[25+i*2]<<32;
+    uint64_t exit=(uint64_t)out[76+i*2]|(uint64_t)out[77+i*2]<<32;
+    if(initial!=expected.bits || exit!=final.bits) {
+     fprintf(stderr,"LLVM D%u entry=%llx want=%llx exit=%llx want=%llx\n",i,(unsigned long long)initial,(unsigned long long)expected.bits,(unsigned long long)exit,(unsigned long long)final.bits);
+     return 1;
+    }
+   }
+  }
+ }
+ return 0;
+}
+`
+	writerValue := "0"
+	if writesNZCV {
+		writerValue = "1"
+	}
+	cMain = strings.ReplaceAll(cMain, "WRITES_NZCV", writerValue)
+	for _, alignment := range []string{"eight", "four"} {
+		t.Run(alignment, func(t *testing.T) {
+			main := strings.Replace(cMain, "CALL_SITE", armMachineEntryNativeCaller(alignment == "four"), 1)
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "machine_entry", "armv7-unknown-linux-gnueabihf", ir, main,
+				[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+		})
+	}
+}
diff --git a/arm_machine_entry_test.go b/arm_machine_entry_test.go
new file mode 100644
index 000000000..82d778c62
--- /dev/null
+++ b/arm_machine_entry_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const armMachineEntrySource = `TEXT oracleEntry(SB),516,$0-0 // NOSPLIT|NOFRAME
+ MOVW CPSR,R3
+ MOVW R3,(R0)
+ MOVW R13,R3
+ MOVW R3,4(R0)
+ MOVW R14,R3
+ MOVW R3,8(R0)
+ MOVW R1,-4(R13)
+ MOVW -4(R13),R3
+ MOVW R3,12(R0)
+ MOVD F0,16(R0)
+ MOVW.EQ $7,R2
+ MOVW R2,24(R0)
+ RET
+`
+
+func armMachineEntryOptions(triple string) Options {
+	return Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{
+		"oracleEntry": {Name: "oracleEntry", Ret: Void, ARMEntry: &ARMMachineEntry{
+			StackBelow: 8, VFP: true, Return: ARMMachineReturnLR,
+		}},
+	}}
+}
+
+func TestARMMachineEntryCapturesSourceStateWithoutTypedCallerArguments(t *testing.T) {
+	requireARMGoAssemblerResult(t, armMachineEntrySource, true)
+	file, err := Parse(ArchARM, armMachineEntrySource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain := armMachineEntryOptions("armv7-unknown-linux-gnueabihf")
+	sig := plain.Sigs["oracleEntry"]
+	sig.ARMEntry = nil
+	plain.Sigs["oracleEntry"] = sig
+	if _, err := Translate(file, plain); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("no native-entry contract must remain a real source failure: %v", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, armMachineEntryOptions(triple))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, witness := range []string{"naked", "noinline", "ptr %machine_state", "mrs", "stm", "vstm", "msr", "vldm", "bx lr"} {
+			if !strings.Contains(ir, witness) {
+				t.Fatalf("machine-entry bridge lacks %s:\n%s", witness, ir)
+			}
+		}
+		compileLLVMToObject(t, llc, triple, "arm-entry.ll", "arm-entry.o", ir)
+	}
+}
+
+func TestARMMachineEntryRejectsUnprovedNativeBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		name, instruction string
+		context           bool
+	}{
+		{"source_sp_write", "ADD $4,R13", true},
+		{"source_lr_write", "MOVW R0,R14", true},
+		{"pc_read", "MOVW R15,R3", true},
+		{"pc_write", "MOVW R14,R15", true},
+		{"unbridged_go_call", "BL external(SB)", true},
+		{"unbridged_native_call", "BL (R1)", true},
+		{"source_tail", "B external(SB)", true},
+		{"raw_effect", "WORD $0xe1a00000", false},
+		{"partial_fp_lane", "MOVF F0,F1", false},
+		{"partial_fp_gp_lane", "MOVW R1,F0", false},
+		{"unknown_system_state", "MOVW R1,CPSR", true},
+		{"outside_source_backing", "MOVW R1,-16(R13)", true},
+		{"source_sp_writeback", "MOVW.W R1,-4(R13)", true},
+		{"lr_address_read", "MOVW (R14),R3", true},
+		{"lr_address_writeback", "MOVW.W R1,4(R14)", true},
+		{"source_sp_alias", "MOVW R13,R3\n MOVW (R3),R2", true},
+		{"shifted_sp_alias", "ADD R13<<0,R1,R3\n MOVW (R3),R2", true},
+		{"multiply_pair_sp_alias", "MULL R13,R1,(R2,R3)\n MOVW (R2),R4", true},
+		{"shifted_sp_index", "MOVW R13<<0(R0),R3", true},
+		{"unknown_return_target", "RET (R1)", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT oracleEntry(SB),516,$0-0\n " + test.instruction + "\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, armMachineEntryOptions("armv7-unknown-linux-gnueabihf"))
+			if err == nil || errors.Is(err, ErrProbeNeedsContext) != test.context {
+				t.Fatalf("boundary context=%v, ordinary source effects never become N/A: %v", test.context, err)
+			}
+		})
+	}
+}
+
+func TestARMMachineEntryRejectsGuessedTypedCallsAndMetadata(t *testing.T) {
+	for _, op := range []string{"CALL", "B"} {
+		source := "TEXT caller(SB),4,$0-0\n " + op + " oracleEntry(SB)\n RET\n" + armMachineEntrySource
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := armMachineEntryOptions("armv7-unknown-linux-gnueabihf")
+		options.Sigs["caller"] = FuncSig{Name: "caller", Ret: Void}
+		if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s may not treat an address-only carrier as an ordinary void C call: %v", op, err)
+		}
+	}
+	for _, mutation := range []func(*FuncSig){
+		func(sig *FuncSig) { sig.Args = []LLVMType{Ptr} },
+		func(sig *FuncSig) { sig.Ret = I32 },
+		func(sig *FuncSig) { sig.ArgRegs = []Reg{"R0"} },
+		func(sig *FuncSig) { sig.Frame.Params = []FrameSlot{{Offset: 0, Type: I32, Field: -1}} },
+		func(sig *FuncSig) { sig.Frame.Results = []FrameSlot{{Offset: 0, Type: I32, Field: -1}} },
+		func(sig *FuncSig) { sig.ARMEntry.Return = 0 },
+		func(sig *FuncSig) { sig.ARMEntry.StackBelow = 7 },
+		func(sig *FuncSig) { sig.ARMEntry.StackBelow = 1<<20 + 8 },
+		func(sig *FuncSig) { sig.ARMEntry.VFP = false },
+	} {
+		file, err := Parse(ArchARM, armMachineEntrySource)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := armMachineEntryOptions("armv7-unknown-linux-gnueabihf")
+		sig := options.Sigs["oracleEntry"]
+		mutation(&sig)
+		options.Sigs["oracleEntry"] = sig
+		if _, err := Translate(file, options); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("invalid caller-supplied machine contract is an error, not source N/A: %v", err)
+		}
+	}
+}
+
+func TestARMMachineEntryRequiresExactPhysicalEntryMetadata(t *testing.T) {
+	for _, text := range []string{
+		"TEXT oracleEntry(SB),4,$0-0", // NOSPLIT is not NOFRAME.
+		"TEXT oracleEntry(SB),516,$-4-0",
+		"TEXT oracleEntry(SB),4,$16-0",
+		"TEXT oracleEntry(SB),516,$0-4",
+	} {
+		source := text + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, armMachineEntryOptions("armv7-unknown-linux-gnueabihf")); err == nil {
+			t.Fatalf("physical entry must not silently reinterpret source metadata %q", text)
+		}
+	}
+	for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "armv7-apple-ios"} {
+		file, err := Parse(ArchARM, armMachineEntrySource)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, armMachineEntryOptions(triple)); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("unsupported requested entry target %q must be an options error: %v", triple, err)
+		}
+	}
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+	}{
+		{ArchAMD64, "386"}, {ArchAMD64, "amd64"}, {ArchARM64, "arm64"}, {ArchWASM, "wasm"},
+	} {
+		file, err := Parse(target.arch, "TEXT oracleEntry(SB),516,$0-0\n RET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := armMachineEntryOptions("armv7-unknown-linux-gnueabihf")
+		options.Goarch = target.goarch
+		if _, err := Translate(file, options); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("ARM entry option must not disappear on %s: %v", target.goarch, err)
+		}
+	}
+}
+
+func TestARMMachineEntryPublicAPIsAndFullRegisterObjects(t *testing.T) {
+	source := armMachineEntryRegisterSource()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, armMachineEntryOptions("armv7-unknown-linux-gnueabihf"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	if module.Context() != ctx {
+		t.Fatal("private entry body escaped its caller-owned LLVM context")
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+
+	// The native source entry has no invented zero-argument Go declaration.
+	// Only this explicit manual physical contract selects the address carrier.
+	pkg := mustGoPackage(t, "example.com/entry", "package entry\nfunc anchor()\n")
+	translation, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+		GOOS: "linux", GOARCH: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		ResolveSym: testResolveSym("example.com/entry"),
+		ManualSig: func(name string) (FuncSig, bool) {
+			if name != "example.com/entry.oracleEntry" {
+				return FuncSig{}, false
+			}
+			sig := armMachineEntryOptions("armv7-unknown-linux-gnueabihf").Sigs["oracleEntry"]
+			sig.Name = name
+			return sig, true
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	if translation.Signatures["example.com/entry.oracleEntry"].ARMEntry == nil ||
+		!strings.Contains(translation.Module.String(), ".machine_body") {
+		t.Fatal("public Go binding discarded the explicit physical contract")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, armMachineEntryOptions(triple))
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "arm-entry-registers.ll", "arm-entry-registers.o", ir)
+	}
+}
diff --git a/arm_memory_runtime_test.go b/arm_memory_runtime_test.go
new file mode 100644
index 000000000..c1464f09a
--- /dev/null
+++ b/arm_memory_runtime_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func armIntegerMemoryRuntimeFixture() (string, map[string]FuncSig, string) {
+	var source, declarations, checks strings.Builder
+	sigs := map[string]FuncSig{}
+	for _, tc := range armIntegerMemoryCases() {
+		// Four nonzero shifts all produce a safe four-byte displacement with
+		// their matching input; zero and boundary shifts use the host IR model.
+		input := 4
+		if strings.HasPrefix(tc.offset, "R") && tc.offset != "R0<<0" && tc.offset != "R0<<1" && tc.offset != "R0>>1" && tc.offset != "R0->1" && tc.offset != "R0@>1" {
+			continue
+		}
+		if tc.offset == "R0<<1" {
+			input = 2
+		}
+		if tc.offset == "R0>>1" || tc.offset == "R0->1" || tc.offset == "R0@>1" {
+			input = 8
+		}
+		name := fmt.Sprintf("mem_runtime_%d", len(sigs))
+		fmt.Fprintf(&source, "TEXT %s(SB),$0-16\nMOVW p+0(FP), R1\nMOVW R1, R3\nMOVW index+4(FP), R0\nMOVW $0xfedcba98, R2\n%s\nSUB R3, R1, R4\nMOVW R2, ret+8(FP)\nMOVW R4, ret+12(FP)\nRET\n", name, tc.instruction)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, I32}, Ret: I64, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}}
+		fmt.Fprintf(&declarations, "extern uint64_t %s(uint8_t *, uint32_t);\n", name)
+		delta := 4
+		if tc.offset == "0" {
+			delta = 0
+		}
+		if tc.offset == "-4" {
+			delta = -4
+		}
+		if strings.Contains(tc.suffix, ".U") && (strings.HasPrefix(tc.offset, "R") || tc.op == "MOVW" || tc.load && tc.op == "MOVBU" || !tc.load && (tc.op == "MOVB" || tc.op == "MOVBS" || tc.op == "MOVBU")) {
+			delta = -delta
+		}
+		address, after := 32+delta, 0
+		if strings.Contains(tc.suffix, ".W") || strings.Contains(tc.suffix, ".P") {
+			after = delta
+		}
+		if strings.Contains(tc.suffix, ".P") {
+			address = 32
+		}
+		width := 1
+		if tc.op == "MOVW" {
+			width = 4
+		}
+		if strings.HasPrefix(tc.op, "MOVH") {
+			width = 2
+		}
+		value := uint32(0xfedcba98)
+		if tc.load {
+			value = 0
+			for byteIndex := 0; byteIndex < width; byteIndex++ {
+				value |= uint32(byte(3*(address+byteIndex)+129)) << uint(8*byteIndex)
+			}
+			if tc.op == "MOVB" || tc.op == "MOVBS" {
+				value = uint32(int8(value))
+			}
+			if tc.op == "MOVH" || tc.op == "MOVHS" {
+				value = uint32(int16(value))
+			}
+		}
+		want := uint64(uint32(after))<<32 | uint64(value)
+		fmt.Fprintf(&checks, "for (int j=0;j<64;j++) data[j]=(uint8_t)(3*j+129);\nif (%s(data+32,%d) != UINT64_C(%d)) { puts(\"%s result\"); return 1; }\n", name, input, want, tc.instruction)
+		if !tc.load {
+			fmt.Fprintf(&checks, "for (int j=0;j<64;j++) { uint8_t expected=(uint8_t)(3*j+129); if (j>=%d && j<%d) expected=(uint8_t)(UINT32_C(0xfedcba98) >> (8*(j-%d))); if (data[j]!=expected) { puts(\"%s memory\"); return 1; } }\n", address, address+width, address, tc.instruction)
+		}
+	}
+	const conditional = "conditional_memory"
+	source.WriteString("TEXT " + conditional + "(SB),$0-8\nMOVW p+0(FP), R1\nCMP R0, R0\nMOVW.NE.P 8(R1), R2\nMOVW R1, ret+4(FP)\nRET\n")
+	sigs[conditional] = FuncSig{Name: conditional, Args: []LLVMType{Ptr}, Ret: I32, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}, Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}}}}
+	declarations.WriteString("extern uint32_t conditional_memory(uint8_t *);\n")
+	checks.WriteString("if (conditional_memory((uint8_t *)0) != 0) return 2;\n")
+	mainC := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + "int main(void) { uint8_t data[64];\n" + checks.String() + "return 0; }\n"
+	return source.String(), sigs, mainC
+}
+
+func TestARMIntegerMemoryRuntimeObjects(t *testing.T) {
+	source, sigs, _ := armIntegerMemoryRuntimeFixture()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "runtime-memory.ll", "runtime-memory.o", ir)
+		})
+	}
+}
+
+func TestARMIntegerMemoryRuntimeCross(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("actual ARM memory execution is required by the Linux cross-runtime job")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatalf("cross-execution driver requires linux/amd64, got %s/%s", runtime.GOOS, runtime.GOARCH)
+	}
+	for _, name := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(name); err != nil {
+			t.Fatalf("required tool %s: %v", name, err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	source, sigs, mainC := armIntegerMemoryRuntimeFixture()
+	t.Logf("executing %d ARM memory functions", len(sigs))
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc"}, "arm_integer_memory", triple, ir, mainC, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_more_test.go b/arm_more_test.go
index 04f80bb58..d7a1d1d07 100644
--- a/arm_more_test.go
+++ b/arm_more_test.go
@@ -75,7 +75,7 @@ func TestTranslateARMExtendedArithmetic(t *testing.T) {
 		"mul i64",
 		"select i1",
 		"call i32 @llvm.ctlz.i32",
-		`asm sideeffect "mrc p15, 0, $0, 1, 0, 0"`,
+		`asm sideeffect "mrc p15, #0, $0, c1, c0, #0"`,
 	} {
 		if !strings.Contains(ll, want) {
 			t.Fatalf("missing %q in output:\n%s", want, ll)
@@ -149,8 +149,8 @@ func TestARMHelperCoverage(t *testing.T) {
 		}
 
 		fn := Func{Instrs: []Instr{{Args: []Operand{{Kind: OpImm, ImmRaw: "$(sym)"}}}}}
-		if err := validateResolvedImmediates(ArchAMD64, fn); err != nil {
-			t.Fatalf("validateResolvedImmediates(amd64) error = %v", err)
+		if err := validateResolvedImmediates(ArchAMD64, fn); err == nil {
+			t.Fatal("validateResolvedImmediates(amd64) accepted an unresolved constant")
 		}
 		if err := validateResolvedImmediates(ArchARM, fn); err == nil {
 			t.Fatalf("validateResolvedImmediates(arm) unexpectedly succeeded")
@@ -348,7 +348,8 @@ TEXT ·tail(SB),NOSPLIT,$0-0
 		"lshr i32",
 		"ashr i32",
 		"call i32 @llvm.fshr.i32",
-		"ret i16 0",
+		"trunc i32",
+		"ret i16",
 	} {
 		if !strings.Contains(ll, want) {
 			t.Fatalf("missing %q in output:\n%s", want, ll)
@@ -356,6 +357,21 @@ TEXT ·tail(SB),NOSPLIT,$0-0
 	}
 }
 
+func TestTranslateARMTailCallAdaptsIntegerReturnWidths(t *testing.T) {
+	ll := translateARMForTest(t, `TEXT ·boolTail(SB),NOSPLIT,$0-0
+	B ·wide(SB)
+
+TEXT ·wide(SB),NOSPLIT,$0-0
+	RET
+`, map[string]FuncSig{
+		"example.boolTail": {Name: "example.boolTail", Ret: I1},
+		"example.wide":     {Name: "example.wide", Ret: I64},
+	})
+	if !strings.Contains(ll, "trunc i64 %") || !strings.Contains(ll, " to i1") {
+		t.Fatalf("ARM integer tailcall did not adapt i64 to i1:\n%s", ll)
+	}
+}
+
 func TestTranslateARMAdditionalAtomicForms(t *testing.T) {
 	ll := translateARMForTest(t, `TEXT ·atomics(SB),NOSPLIT,$0-0
 	LDREXB (R1), R0
diff --git a/arm_multiply_flags_runtime_test.go b/arm_multiply_flags_runtime_test.go
new file mode 100644
index 000000000..2bc7235a0
--- /dev/null
+++ b/arm_multiply_flags_runtime_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMMultiplyWithoutCPSRRead(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	const source = `TEXT oracle(SB),4,$0-20
+ MOVW value+0(FP),R0
+ MOVW amount+4(FP),R1
+ MOVW out+16(FP),R4
+ CMP $1,R0
+ MUL.S R0,R1,R2
+ MOVW $0,R3
+ MOVW.EQ $1,R3
+ MOVW R3,(R4)
+ RET
+`
+	runARMGoSourceOracle(t, source, `package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *uint32)
+func main(){var out uint32;oracle(0,2,0,0,&out);if out!=1{panic(fmt.Sprint(out))};fmt.Println("MUL.S result Z drives ordinary EQ predicate=1")}
+`)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "multiply_z_branch", "armv7-unknown-linux-gnueabihf", ir,
+		`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+int main(void){uint32_t out=99;oracle(0,2,0,0,&out);if(out!=1){fprintf(stderr,"LLVM MUL.S Z predicate=%u want=1\n",out);return 1;}return 0;}
+`, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
+
+type armMultiplyRuntimeCase struct {
+	op, condition string
+	setFlags      bool
+	twoOperands   bool
+}
+
+func armMultiplyRuntimeCases() []armMultiplyRuntimeCase {
+	var cases []armMultiplyRuntimeCase
+	for _, op := range []string{"MUL", "MULU", "MULA", "MULL", "MULLU", "MULAL", "MULALU"} {
+		for _, condition := range []string{"", "EQ", "NE", "CS", "CC", "HS", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL"} {
+			for _, flags := range []bool{false, true} {
+				cases = append(cases, armMultiplyRuntimeCase{op: op, condition: condition, setFlags: flags})
+				if op == "MUL" || op == "MULU" {
+					cases = append(cases, armMultiplyRuntimeCase{op: op, condition: condition, setFlags: flags, twoOperands: true})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func armMultiplyRuntimeSource(cases []armMultiplyRuntimeCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT oracle(SB),4,$0-20\n MOVW out+16(FP),R4\n")
+	for index, test := range cases {
+		mnemonic := test.op
+		if test.condition != "" {
+			mnemonic += "." + test.condition
+		}
+		if test.setFlags {
+			mnemonic += ".S"
+		}
+		args := "R0,R1,R3"
+		if test.twoOperands {
+			args = "R0,R3"
+		} else if test.op == "MULA" {
+			args = "R0,R1,R2,R3"
+		} else if test.op != "MUL" && test.op != "MULU" {
+			args = "R0,R1,(R5,R3)"
+		}
+		fmt.Fprintf(&source, " MOVW value+0(FP),R0\n MOVW amount+4(FP),R1\n MOVW lhs+8(FP),R2\n MOVW R2,R3\n MOVW $0x89abcdef,R5\n MOVW status+12(FP),R6\n MOVW R6,CPSR\n %s %s\n MOVW R3,%d(R4)\n MOVW R5,%d(R4)\n MOVW CPSR,R6\n SRL $28,R6\n MOVW R6,%d(R4)\n", mnemonic, args, index*12, index*12+4, index*12+8)
+	}
+	source.WriteString(" RET\n")
+	return source.String()
+}
+
+func armConditionReference(condition string, flags uint32) bool {
+	n, z, c, v := flags&8 != 0, flags&4 != 0, flags&2 != 0, flags&1 != 0
+	switch condition {
+	case "", "AL":
+		return true
+	case "EQ":
+		return z
+	case "NE":
+		return !z
+	case "CS", "HS":
+		return c
+	case "CC", "LO":
+		return !c
+	case "MI":
+		return n
+	case "PL":
+		return !n
+	case "VS":
+		return v
+	case "VC":
+		return !v
+	case "HI":
+		return c && !z
+	case "LS":
+		return !c || z
+	case "GE":
+		return n == v
+	case "LT":
+		return n != v
+	case "GT":
+		return !z && n == v
+	case "LE":
+		return z || n != v
+	}
+	panic("invalid reference condition")
+}
+
+func armMultiplyReference(test armMultiplyRuntimeCase, value, multiplier, accumulator, status uint32) (lo, hi, flags uint32) {
+	lo, hi, flags = accumulator, 0x89abcdef, status>>28
+	if !armConditionReference(test.condition, flags) {
+		return lo, hi, flags
+	}
+	if test.twoOperands {
+		multiplier = accumulator
+	}
+	product := uint64(value) * uint64(multiplier)
+	if test.op == "MULL" || test.op == "MULAL" {
+		product = uint64(int64(int32(value)) * int64(int32(multiplier)))
+	}
+	if test.op == "MULAL" || test.op == "MULALU" {
+		product += uint64(hi)<<32 | uint64(lo)
+	}
+	if test.op == "MULA" {
+		product += uint64(accumulator)
+	}
+	lo = uint32(product)
+	negative, zero := lo>>31, lo == 0
+	if test.op != "MUL" && test.op != "MULU" && test.op != "MULA" {
+		hi = uint32(product >> 32)
+		negative, zero = hi>>31, product == 0
+	}
+	if test.setFlags {
+		flags = flags&3 | negative<<3
+		if zero {
+			flags |= 4
+		}
+	}
+	return lo, hi, flags
+}
+
+func TestCrossLinuxRuntimeMatrixARMMultiplyCompleteFlags(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	cases := armMultiplyRuntimeCases()
+	source := armMultiplyRuntimeSource(cases)
+	var goVectors, cVectors strings.Builder
+	inputs := [][3]uint32{{0, 0xffffffff, 0}, {1, 0xffffffff, 1}, {0x80000000, 2, 0x7fffffff}, {0xffffffff, 0xffffffff, 0xffffffff}, {0x7fffffff, 0x7fffffff, 0x80000000}}
+	for _, input := range inputs {
+		for flags := uint32(0); flags < 16; flags++ {
+			fmt.Fprintf(&goVectors, "{[4]uint32{%d,%d,%d,%d},[%d]uint32{", input[0], input[1], input[2], flags<<28, 3*len(cases))
+			fmt.Fprintf(&cVectors, "{{%du,%du,%du,%du},{", input[0], input[1], input[2], flags<<28)
+			for _, test := range cases {
+				lo, hi, status := armMultiplyReference(test, input[0], input[1], input[2], flags<<28)
+				fmt.Fprintf(&goVectors, "%d,%d,%d,", lo, hi, status)
+				fmt.Fprintf(&cVectors, "%du,%du,%du,", lo, hi, status)
+			}
+			goVectors.WriteString("}},\n")
+			cVectors.WriteString("}},\n")
+		}
+	}
+	goMain := fmt.Sprintf(`package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *[%d]uint32)
+var vectors=[]struct{args [4]uint32;want [%d]uint32}{%s}
+func main(){for i,v:=range vectors{var out [%d]uint32;oracle(v.args[0],v.args[1],v.args[2],v.args[3],&out);for j,w:=range v.want{if out[j]!=w{panic(fmt.Sprintf("Go multiply vector=%%d lane=%%d got=%%x want=%%x",i,j,out[j],w))}}};fmt.Println("seven multiply members, complete conditions, result widths and NZCV passed")}
+`, 3*len(cases), 3*len(cases), goVectors.String(), 3*len(cases))
+	runARMGoSourceOracle(t, source, goMain)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+static const struct{uint32_t args[4],want[%d];}vectors[]={%s};
+int main(void){for(unsigned i=0;i<sizeof(vectors)/sizeof(vectors[0]);i++){uint32_t out[%d]={0};oracle(vectors[i].args[0],vectors[i].args[1],vectors[i].args[2],vectors[i].args[3],out);for(unsigned j=0;j<%d;j++)if(out[j]!=vectors[i].want[j]){fprintf(stderr,"LLVM multiply vector=%%u lane=%%u got=%%x want=%%x\n",i,j,out[j],vectors[i].want[j]);return 1;}}return 0;}
+`, 3*len(cases), cVectors.String(), 3*len(cases), 3*len(cases))
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "multiply_flags", "armv7-unknown-linux-gnueabihf", ir, cMain,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+	t.Logf("actual Go/LLVM: %d source forms x %d independent vectors", len(cases), len(inputs)*16)
+}
diff --git a/arm_needed.go b/arm_needed.go
index 7b49b9547..9147578aa 100644
--- a/arm_needed.go
+++ b/arm_needed.go
@@ -2,8 +2,9 @@ package plan9asm
 
 import "strings"
 
-// funcNeedsARMCFG decides whether ARM lowering needs the CFG-based path.
-// The linear prototype only handles straight-line arithmetic/data movement.
+// funcNeedsARMCFG is retained for focused classifier tests and historical
+// callers. Translate now always selects the CFG path for supported ARM code so
+// straight-line functions cannot bypass architecture-specific form checks.
 func funcNeedsARMCFG(fn Func) bool {
 	for _, ins := range fn.Instrs {
 		if ins.Op == OpLABEL {
@@ -28,7 +29,7 @@ func funcNeedsARMCFG(fn Func) bool {
 				return true
 			}
 			for _, arg := range ins.Args {
-				if arg.Kind == OpIdent {
+				if arg.Kind == OpIdent || arg.Kind == OpFPAddr {
 					return true
 				}
 			}
diff --git a/arm_neon_conversion_status_runtime_linux_test.go b/arm_neon_conversion_status_runtime_linux_test.go
new file mode 100644
index 000000000..8e6aec80e
--- /dev/null
+++ b/arm_neon_conversion_status_runtime_linux_test.go
@@ -0,0 +1,275 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+type armNEONConversionObservation struct {
+	function int
+	input    [65]uint32
+	want     [68]uint32
+}
+
+func armNEONConversionKnownObservation(index int, fixture armNEONConversionFixture, control uint32) armNEONConversionObservation {
+	row := armNEONConversionObservation{function: index}
+	for word := 0; word < 64; word++ {
+		row.input[word] = 0x98760000 + uint32(word)*0x0101
+	}
+	values := [4]uint32{0x3fc00000, 0x7fc12345, 0x4f800000, 1}
+	results := [4]uint32{1, 0, 0x7fffffff, 0}
+	flags := uint32(0x11) // Fractional input and qNaN: IXC | IOC.
+	if fixture.unsigned {
+		results[2] = 0xffffffff
+	}
+	if fixture.quad {
+		flags |= 0x80 // Advanced SIMD flushes the subnormal input: IDC.
+	}
+	if fixture.toFloat {
+		values = [4]uint32{0x01000001, 0xfeffffff, 0x80000001, 0xffffffff}
+		for lane, value := range values {
+			floating := float32(int32(value))
+			if fixture.unsigned {
+				floating = float32(value)
+			}
+			results[lane] = math.Float32bits(floating)
+		}
+		flags = 0x10 // Advanced SIMD always uses nearest, independent of FPSCR.
+	}
+	lanes := 2
+	if fixture.quad {
+		lanes = 4
+	}
+	copy(row.input[fixture.source*2:], values[:lanes])
+	copy(row.want[:64], row.input[:64])
+	if !fixture.dead {
+		copy(row.want[fixture.target*2:], results[:lanes])
+	}
+	row.input[64] = control
+	row.want[64] = control | flags
+	row.want[65], row.want[66], row.want[67] = 0x12345678, 0x87654321, 0xfedcba98
+	return row
+}
+
+// This bounded independent oracle follows A2.7 FPToFixed/FixedToFP with the
+// Advanced SIMD standard controls: nearest int->float, truncating float->int,
+// flushed input denormals, saturating invalid results, and cumulative flags.
+// It is test-only; production must execute native VCVT, not synthesize FPSCR.
+func armNEONConversionReference(fixture armNEONConversionFixture, bits uint32) (uint32, uint32) {
+	if fixture.toFloat {
+		integer := float64(int32(bits))
+		if fixture.unsigned {
+			integer = float64(bits)
+		}
+		value := float32(integer)
+		flags := uint32(0)
+		if float64(value) != integer {
+			flags = 0x10
+		}
+		return math.Float32bits(value), flags
+	}
+	if bits&0x7f800000 == 0 && bits&0x007fffff != 0 {
+		return 0, 0x80
+	}
+	value := float64(math.Float32frombits(bits))
+	if math.IsNaN(value) {
+		return 0, 1
+	}
+	minimum, maximum := -2147483648.0, 2147483647.0
+	if fixture.unsigned {
+		minimum, maximum = 0, 4294967295.0
+	}
+	truncated := math.Trunc(value)
+	if truncated < minimum {
+		if fixture.unsigned {
+			return 0, 1
+		}
+		return 0x80000000, 1
+	}
+	if truncated > maximum {
+		if fixture.unsigned {
+			return 0xffffffff, 1
+		}
+		return 0x7fffffff, 1
+	}
+	flags := uint32(0)
+	if truncated != value {
+		flags = 0x10
+	}
+	if fixture.unsigned {
+		return uint32(truncated), flags
+	}
+	return uint32(int32(truncated)), flags
+}
+
+func armNEONConversionDynamicObservation(index int, fixture armNEONConversionFixture, values [4]uint32, control uint32) armNEONConversionObservation {
+	row := armNEONConversionObservation{function: index}
+	for word := 0; word < 64; word++ {
+		row.input[word] = 0x87650000 + uint32(word)*0x0101
+	}
+	lanes := 2
+	if fixture.quad {
+		lanes = 4
+	}
+	copy(row.input[fixture.source*2:], values[:lanes])
+	copy(row.want[:64], row.input[:64])
+	flags := uint32(0)
+	for lane := 0; lane < lanes; lane++ {
+		result, exceptions := armNEONConversionReference(fixture, values[lane])
+		flags |= exceptions
+		if !fixture.dead {
+			row.want[fixture.target*2+lane] = result
+		}
+	}
+	row.input[64], row.want[64] = control, control|flags
+	row.want[65], row.want[66], row.want[67] = 0x12345678, 0x87654321, 0xfedcba98
+	return row
+}
+
+func armNEONConversionOraclePrograms(fixtures []armNEONConversionFixture, rows []armNEONConversionObservation) (string, string) {
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range fixtures {
+		fmt.Fprintf(&original, "func neonStatus%d(input *[65]uint32, output *[68]uint32)\n", index)
+		fmt.Fprintf(&driver, "extern void neonStatus%d(uint32_t*,uint32_t*);\n", index)
+	}
+	original.WriteString("var functions = [...]func(*[65]uint32,*[68]uint32){\n")
+	driver.WriteString("static void (*functions[])(uint32_t*,uint32_t*)={\n")
+	for index := range fixtures {
+		fmt.Fprintf(&original, "neonStatus%d,\n", index)
+		fmt.Fprintf(&driver, "neonStatus%d,\n", index)
+	}
+	original.WriteString("}\nvar rows = []struct { function int; input [65]uint32; want [68]uint32 }{\n")
+	driver.WriteString("};\nstatic const struct { unsigned function; uint32_t input[65], want[68]; } rows[]={\n")
+	for _, row := range rows {
+		fmt.Fprintf(&original, "{%d,[65]uint32{", row.function)
+		fmt.Fprintf(&driver, "{%d,{", row.function)
+		for _, value := range row.input {
+			fmt.Fprintf(&original, "%#x,", value)
+			fmt.Fprintf(&driver, "%#x,", value)
+		}
+		original.WriteString("},[68]uint32{")
+		driver.WriteString("},{")
+		for _, value := range row.want {
+			fmt.Fprintf(&original, "%#x,", value)
+			fmt.Fprintf(&driver, "%#x,", value)
+		}
+		original.WriteString("}},\n")
+		driver.WriteString("}},\n")
+	}
+	original.WriteString(`}
+func main() {
+    for index, row := range rows {
+        var out [68]uint32
+        for word := range out { out[word] = 0xa5a5a5a5 }
+        out[65],out[66],out[67] = 0x12345678,0x87654321,0xfedcba98
+        functions[row.function](&row.input,&out)
+        if out != row.want { panic(fmt.Sprintf("original row %d got %x want %x",index,out,row.want)) }
+    }
+    fmt.Printf("ORIGINAL_NEON_CONVERSION_STATUS %d\n",len(rows))
+}
+`)
+	driver.WriteString(`};
+int main(void) {
+    unsigned failures=0;
+    for(unsigned row=0;row<sizeof(rows)/sizeof(rows[0]);row++) {
+        uint32_t input[65],out[68];
+        for(unsigned word=0;word<65;word++) input[word]=rows[row].input[word];
+        for(unsigned word=0;word<68;word++) out[word]=0xa5a5a5a5;
+        out[65]=0x12345678; out[66]=0x87654321; out[67]=0xfedcba98;
+        functions[rows[row].function](input,out);
+        for(unsigned word=0;word<68;word++) {
+            if(out[word]!=rows[row].want[word]) {
+                if(failures<16) fprintf(stderr,"row %u function %u word %u got %08x want %08x\n",
+                    row,rows[row].function,word,out[word],rows[row].want[word]);
+                failures++;
+            }
+        }
+    }
+    printf("NEON_CONVERSION_STATUS failures=%u\n",failures);
+    return failures!=0;
+}
+`)
+	return original.String(), driver.String()
+}
+
+func TestCrossLinuxRuntimeMatrixARMNEONConversionNativeStatus(t *testing.T) {
+	fixtures := armNEONConversionStatusFixtures()
+	var rows []armNEONConversionObservation
+	for index, fixture := range fixtures {
+		for rounding := 0; rounding < 4; rounding++ {
+			for flush := 0; flush < 2; flush++ {
+				for defaultNaN := 0; defaultNaN < 2; defaultNaN++ {
+					control := uint32(rounding)<<22 | uint32(flush)<<24 | uint32(defaultNaN)<<25 | 0xa0000002
+					rows = append(rows, armNEONConversionKnownObservation(index, fixture, control))
+				}
+			}
+		}
+	}
+	runARMNEONConversionObservations(t, fixtures, rows)
+}
+
+func runARMNEONConversionObservations(t *testing.T, fixtures []armNEONConversionFixture, rows []armNEONConversionObservation) {
+	t.Helper()
+	llc := requireARMScalarRuntime(t)
+	source, sigs := armNEONConversionFixtureSource(fixtures)
+	original, driver := armNEONConversionOraclePrograms(fixtures, rows)
+	runARMConversionGoOracle(t, source, original, fmt.Sprintf("ORIGINAL_NEON_CONVERSION_STATUS %d", len(rows)))
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"unoptimized", ir}, {"optimized", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+					"arm_neon_conversion_status", "armv7-unknown-linux-gnueabihf", variant.ir, driver,
+					[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+				t.Logf("matched original Go: %d full-bank/result/FPSCR/canary rows", len(rows))
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMNEONConversionFullBanks(t *testing.T) {
+	fixtures := armNEONConversionEndpointFixtures()
+	var rows []armNEONConversionObservation
+	for index, fixture := range fixtures {
+		for _, control := range []uint32{0xa0000002, 0xabc00002} {
+			rows = append(rows, armNEONConversionKnownObservation(index, fixture, control))
+		}
+	}
+	runARMNEONConversionObservations(t, fixtures, rows)
+}
+
+func TestCrossLinuxRuntimeMatrixARMNEONConversionExceptionalInputs(t *testing.T) {
+	fixtures := armNEONConversionStatusFixtures()
+	var rows []armNEONConversionObservation
+	for index, fixture := range fixtures {
+		inputs := armConversionStatusMatrixValues(armConversionMatrixForm{toFloat: fixture.toFloat})
+		// Each important input appears in every D/Q lane at least once. Pair
+		// different exception classes rather than hiding them in splats.
+		for first := range inputs {
+			var values [4]uint32
+			for lane := range values {
+				values[lane] = uint32(inputs[(first+lane)%len(inputs)])
+			}
+			for rounding := 0; rounding < 4; rounding++ {
+				for flush := 0; flush < 2; flush++ {
+					for defaultNaN := 0; defaultNaN < 2; defaultNaN++ {
+						control := uint32(rounding)<<22 | uint32(flush)<<24 | uint32(defaultNaN)<<25 | 0xa8000002
+						rows = append(rows, armNEONConversionDynamicObservation(index, fixture, values, control))
+					}
+				}
+			}
+		}
+	}
+	runARMNEONConversionObservations(t, fixtures, rows)
+}
diff --git a/arm_neon_conversion_status_test.go b/arm_neon_conversion_status_test.go
new file mode 100644
index 000000000..3043eb352
--- /dev/null
+++ b/arm_neon_conversion_status_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type armNEONConversionFixture struct {
+	word           uint32
+	source, target int // Physical D number; a Q occupies an even pair.
+	quad, toFloat  bool
+	unsigned, dead bool
+}
+
+// Arm DDI0406C.c A8.8.305, independent of the production decoder. These
+// operations use StandardFPSCRValue, unlike the neighboring scalar VCVT.
+func armNEONConversionFixtureWord(toFloat, unsigned, quad bool, source, target int) uint32 {
+	word := uint32(0xf3bb0600)
+	if !toFloat {
+		word |= 1 << 8
+	}
+	if unsigned {
+		word |= 1 << 7
+	}
+	if quad {
+		word |= 1 << 6
+	}
+	return word | uint32(target%16)<<12 | uint32(target/16)<<22 | uint32(source%16) | uint32(source/16)<<5
+}
+
+func armNEONConversionStatusFixtures() []armNEONConversionFixture {
+	var fixtures []armNEONConversionFixture
+	for _, toFloat := range []bool{false, true} {
+		for _, unsigned := range []bool{false, true} {
+			for _, quad := range []bool{false, true} {
+				for _, dead := range []bool{false, true} {
+					fixtures = append(fixtures, armNEONConversionFixture{
+						word:   armNEONConversionFixtureWord(toFloat, unsigned, quad, 0, 2),
+						source: 0, target: 2, quad: quad, toFloat: toFloat, unsigned: unsigned, dead: dead,
+					})
+				}
+			}
+		}
+	}
+	return fixtures
+}
+
+func armNEONConversionEndpointFixtures() []armNEONConversionFixture {
+	var fixtures []armNEONConversionFixture
+	for _, toFloat := range []bool{false, true} {
+		for _, unsigned := range []bool{false, true} {
+			for _, quad := range []bool{false, true} {
+				step := 1
+				if quad {
+					step = 2
+				}
+				for source := 0; source < 32; source += step {
+					for _, alias := range []bool{false, true} {
+						target := source
+						if !alias {
+							target = (source + 7*step) % 32
+						}
+						fixtures = append(fixtures, armNEONConversionFixture{
+							word:   armNEONConversionFixtureWord(toFloat, unsigned, quad, source, target),
+							source: source, target: target, quad: quad, toFloat: toFloat, unsigned: unsigned,
+						})
+					}
+				}
+			}
+		}
+	}
+	return fixtures
+}
+
+func armNEONConversionFixtureSource(fixtures []armNEONConversionFixture) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig, len(fixtures))
+	loadBank := func() {
+		for register := 0; register < 32; register++ {
+			// VLDR Dn,[R0,#8*n], including the raw-only D16–31 bank.
+			word := uint32(0xed900b00 | (register%16)<<12 | (register/16)<<22 | register*2)
+			fmt.Fprintf(&source, "WORD $%#x\n", word)
+		}
+	}
+	for index, fixture := range fixtures {
+		name := fmt.Sprintf("neonStatus%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVW input+0(FP),R0\nMOVW output+4(FP),R1\n", name)
+		loadBank()
+		source.WriteString("WORD $0xeef14a10\nMOVW 256(R0),R3\nWORD $0xeee13a10\n")
+		fmt.Fprintf(&source, "WORD $%#x\n", fixture.word)
+		if fixture.dead {
+			// Every conversion output is overwritten. Its exception effect is
+			// nevertheless observable in the following real VMRS.
+			loadBank()
+		}
+		source.WriteString("WORD $0xeef13a10\nWORD $0xeee14a10\n")
+		for register := 0; register < 32; register++ {
+			// VSTR Dn,[R1,#8*n]. Observe every D alias, not just the result.
+			word := uint32(0xed810b00 | (register%16)<<12 | (register/16)<<22 | register*2)
+			fmt.Fprintf(&source, "WORD $%#x\n", word)
+		}
+		source.WriteString("MOVW R3,256(R1)\nRET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	return source.String(), sigs
+}
+
+func TestARMNEONConversionStatusRetainsNativeSideEffects(t *testing.T) {
+	fixtures := armNEONConversionStatusFixtures()
+	source, sigs := armNEONConversionFixtureSource(fixtures)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"unoptimized", ir}, {"optimized", armFloatEffectOptimizedIR(t, ir)}} {
+		if count := strings.Count(variant.ir, `asm sideeffect "vcvt.`); count != len(fixtures) {
+			t.Errorf("%s loses native NEON/dead exception effects: %d conversions, want %d", variant.name, count, len(fixtures))
+		}
+		for _, cast := range []string{" = fptosi ", " = fptoui ", " = sitofp ", " = uitofp "} {
+			if strings.Contains(variant.ir, cast) {
+				t.Errorf("%s replaces Advanced SIMD status with a pure conversion: %s", variant.name, cast)
+			}
+		}
+	}
+}
+
+func TestARMNEONConversionAllBankAndAliasObjects(t *testing.T) {
+	fixtures := armNEONConversionEndpointFixtures()
+	if len(fixtures) != 384 {
+		t.Fatalf("incomplete full D/Q bank and alias matrix: %d", len(fixtures))
+	}
+	source, sigs := armNEONConversionFixtureSource(fixtures)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm-neon-conversion-banks.ll", "arm-neon-conversion-banks.o", ir)
+		})
+	}
+}
+
+func TestARMNEONConversionNativeTargetAndInvalidSourceBoundary(t *testing.T) {
+	for _, fixture := range armNEONConversionStatusFixtures() {
+		if fixture.dead {
+			continue
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				source := fmt.Sprintf("TEXT conversion(SB),4,$0-0\nWORD $%#x\nRET\n", fixture.word)
+				if err := armWordFloatBoundaryAPI(t, api, source, triple); err != nil {
+					t.Fatalf("%s %s %#x rejects explicit native target: %v", api, triple, fixture.word, err)
+				}
+			}
+			for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "arm64-apple-darwin", "armeb-unknown-linux-gnueabi", "thumbeb-unknown-linux-gnu"} {
+				source := fmt.Sprintf("TEXT conversion(SB),4,$0-0\nWORD $%#x\nRET\n", fixture.word)
+				if err := armWordFloatBoundaryAPI(t, api, source, triple); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s %#x did not require native state: %v", api, triple, fixture.word, err)
+				}
+				for _, body := range []string{
+					fmt.Sprintf("WORD $%#x\nWORD $0xffffffff", fixture.word),
+					fmt.Sprintf("RET\nWORD $0xffffffff\nWORD $%#x", fixture.word),
+				} {
+					source := "TEXT conversion(SB),4,$0-0\n" + body + "\nRET\n"
+					if err := armWordFloatBoundaryAPI(t, api, source, triple); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s %s malformed raw input became target context: %v", api, triple, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/arm_official_directive_test.go b/arm_official_directive_test.go
new file mode 100644
index 000000000..d9dbcfdef
--- /dev/null
+++ b/arm_official_directive_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMEndDirective(t *testing.T) {
+	const source = "TEXT endDirective(SB),$0-0\n\tRET\n\tEND\n"
+	requireARMGoAssemblerResult(t, source, true)
+	ll := translateARMForTest(t, source, map[string]FuncSig{
+		"example.endDirective": {Name: "example.endDirective", Ret: Void},
+	})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-end.ll", "arm-end.o", ll)
+}
+
+func TestTranslateARMEndDirectiveIgnoresTrailingOperandsLikeGo(t *testing.T) {
+	const source = "TEXT endWithIgnoredOperand(SB),$0-0\n\tRET\n\tEND R0\n"
+	requireARMGoAssemblerResult(t, source, true)
+	translateARMForTest(t, source, map[string]FuncSig{
+		"example.endWithIgnoredOperand": {Name: "example.endWithIgnoredOperand", Ret: Void},
+	})
+}
+
+func TestProbeARMContextDependentOfficialDirectives(t *testing.T) {
+	cases := []struct {
+		name   string
+		source string
+	}{
+		{name: "return-from-exception", source: "RFE"},
+		{name: "undefined-raw-word", source: "WORD $4294967295"},
+		{name: "pc-relative-raw-word", source: "WORD $2863311530"},
+		{name: "stateful-raw-word", source: "WORD $1431655765"},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := Parse(ArchARM, "TEXT probe(SB),$0-0\n\t"+test.source+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			err = ProbeInstruction(ArchARM, "arm", instruction)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("ProbeInstruction(%s) error = %v, want ErrProbeNeedsContext", test.source, err)
+			}
+			if !strings.Contains(err.Error(), test.source) {
+				t.Fatalf("context error %q does not identify %q", err, test.source)
+			}
+		})
+	}
+}
diff --git a/arm_pc_state_test.go b/arm_pc_state_test.go
new file mode 100644
index 000000000..a60126d6d
--- /dev/null
+++ b/arm_pc_state_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARMCorePCStateRequiresContext(t *testing.T) {
+	tests := []struct {
+		instruction, reason string
+	}{
+		{"MOVW $0xffff0fc0,R15", "control-flow"},
+		{"MOVW R14,R15", "control-flow"},
+		{"MOVW.P 192(R13),R15", "control-flow"},
+		{"MOVW 0(R15),R0", "source instruction layout"},
+		{"MOVW R0,0(R15)", "source instruction layout"},
+		{"MOVW $4(R15),R0", "source instruction layout"},
+		{"MOVW $4(R0),R15", "control-flow"},
+		{"MOVW R15<<2,R0", "source instruction layout"},
+		{"ADD R15,R0,R1", "source instruction layout"},
+		{"ADD R0,R1,R15", "control-flow"},
+		{"CMP R15,R0", "source instruction layout"},
+		{"MOVM [R0,R15],(R1)", "source instruction layout"},
+		{"MOVM (R1),[R0,R15]", "control-flow"},
+		{"WORD $0xe1a0000f", "source instruction layout"},
+		{"WORD $0xe1a0f000", "control-flow"},
+		// x/arch's GoSyntax aliases these physical PC loads to RET. A
+		// textual alias is not a proof of the caller's stack-return contract.
+		{"WORD $0xe49df004", "control-flow"},
+		{"WORD $0xe49df0c0", "control-flow"},
+		{"WORD $0x149df0c0", "control-flow"},
+		{"WORD $0xe8bd8001", "control-flow"},
+	}
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		tests = append(tests,
+			struct{ instruction, reason string }{op + " R15,R0", "source instruction layout"},
+			struct{ instruction, reason string }{op + " R0,R15", "control-flow"},
+			struct{ instruction, reason string }{op + " R15,0(R0)", "source instruction layout"},
+			struct{ instruction, reason string }{op + " 0(R0),R15", "control-flow"},
+		)
+	}
+	for _, test := range tests {
+		t.Run(test.instruction, func(t *testing.T) {
+			source := "TEXT pcstate(SB),$256-0\nCMP R2,R2\n" + test.instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[2]
+			if err := ProbeInstruction(ArchARM, "arm", instruction); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("PC instruction probe silently accepts an unproved machine-state contract: %v", err)
+			}
+			if err := ProbeInstructionSequence(ArchARM, "arm", file.Funcs[0].Instrs[1:]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("sequence probe lost the PC contract failure: %v", err)
+			}
+			for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				options := Options{Goarch: "arm", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"pcstate": {Name: "pcstate", Ret: Void}},
+				}
+				if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), test.reason) {
+					t.Fatalf("%s full translation must retain %s failure: %v", triple, test.reason, err)
+				}
+				module, err := TranslateModule(file, options)
+				if err == nil {
+					module.Dispose()
+					t.Fatal("direct module translation accepted an unproved PC contract")
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), test.reason) {
+					t.Fatalf("direct module lost architectural context failure: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARMCorePCPseudoRegisterIsNotContext(t *testing.T) {
+	for _, instruction := range []string{"MOVW PC,R0", "MOVW R0,PC", "MOVW $4,PC", "ADD PC,R0,R1", "ADD R0,R1,PC"} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT illegalpc(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			for _, err := range []error{
+				ProbeInstruction(ArchARM, "arm", file.Funcs[0].Instrs[1]),
+				func() error {
+					_, err := Translate(file, Options{Goarch: "arm", Sigs: map[string]FuncSig{"illegalpc": {Name: "illegalpc", Ret: Void}}})
+					return err
+				}(),
+			} {
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-illegal pseudo PC must not succeed or become contextual: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARMCorePCGuardKeepsOrdinaryRegistersAndVFPFlags(t *testing.T) {
+	const source = "TEXT normal(SB),$0-0\nMOVW $123,R14\nMOVW R14,R0\nADD R0,R1,R2\nCMP R1,R2\nWORD $0xeef1fa10\nRET\n"
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"normal": {Name: "normal", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "pc-ordinary.ll", "pc-ordinary.o", ir)
+	}
+	t.Log("ordinary register and VMRS-to-NZCV contracts retain LLVM22 objects")
+}
diff --git a/arm_probe_memory.go b/arm_probe_memory.go
new file mode 100644
index 000000000..bb6fdf6ae
--- /dev/null
+++ b/arm_probe_memory.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+)
+
+// A standalone probe has no generated go_asm.h layout constants. This is
+// distinct from a concrete register shift or a descriptive C_AUTO stack name.
+// Translation still rejects unresolved offsets; the full corpus must supply
+// the definitions and compile the resulting instruction with LLVM.
+func armMemoryOffsetNeedsContext(memory MemRef) bool {
+	raw := memory.OffRaw
+	if raw == "" || armNamedStackOffset(memory) {
+		return false
+	}
+	if _, concreteShift := armMemoryShift(memory); concreteShift {
+		return false
+	}
+	for _, shift := range []ShiftOp{ShiftRotate, ShiftArith, ShiftLeft, ShiftRight} {
+		if i := strings.Index(raw, string(shift)); i >= 0 {
+			if reg, ok := parseReg(strings.TrimSpace(raw[:i])); ok && isARMGeneralReg(reg) {
+				raw = raw[i+len(shift):]
+				break
+			}
+		}
+	}
+	return memoryOffsetExpressionNeedsContext(raw)
+}
+
+func memoryOffsetExpressionNeedsContext(raw string) bool {
+	expr, err := parser.ParseExpr(strings.ReplaceAll(strings.TrimSpace(raw), "~", "^"))
+	if err != nil {
+		return false
+	}
+	symbolic := false
+	var valid func(ast.Expr) bool
+	valid = func(expr ast.Expr) bool {
+		switch expr := expr.(type) {
+		case *ast.Ident:
+			if _, register := parseReg(expr.Name); register || expr.Name == "g" {
+				return false
+			}
+			symbolic = true
+			return true
+		case *ast.BasicLit:
+			_, ok := parseImmExpr(expr.Value)
+			return ok
+		case *ast.ParenExpr:
+			return valid(expr.X)
+		case *ast.UnaryExpr:
+			return (expr.Op == token.ADD || expr.Op == token.SUB || expr.Op == token.XOR) && valid(expr.X)
+		case *ast.BinaryExpr:
+			switch expr.Op {
+			case token.ADD, token.SUB, token.MUL, token.QUO, token.REM, token.SHL, token.SHR, token.AND, token.OR, token.XOR:
+				return valid(expr.X) && valid(expr.Y)
+			}
+		}
+		return false
+	}
+	return valid(expr) && symbolic
+}
diff --git a/arm_probe_memory_test.go b/arm_probe_memory_test.go
new file mode 100644
index 000000000..40d734d0f
--- /dev/null
+++ b/arm_probe_memory_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestARMMemoryOffsetProbeNeedsMacroContext(t *testing.T) {
+	instructions := []string{
+		"MOVW gobuf_sp(R1), R13", "MOVW R0, g_stackguard0(g)",
+		"MOVW (gobuf_sp+4)(R1), R2", "MOVW R2<<(SHIFT+1)(R1), R4",
+		"MOVW R2@>SHIFT(R1), R4", "MOVW R2->SHIFT(R1), R4",
+		"MOVW gobuf_lr(R1), LR",
+	}
+	for _, op := range []string{"MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		instructions = append(instructions, op+" gobuf_sp(R1), R2", op+" R2, gobuf_sp(R1)")
+	}
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT macroprobe(SB),$0-0\n" + instruction + "\nRET\n"
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if err := ProbeInstruction(ArchARM, "arm", ins); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unexpanded offset probe error=%v, want macro context", err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", Sigs: map[string]FuncSig{"macroprobe": {Name: "macroprobe", Ret: Void}}}); err == nil {
+				t.Fatal("translation silently accepted an unresolved memory offset")
+			}
+			resolved := "#define gobuf_sp 4\n#define g_stackguard0 8\n#define gobuf_lr 12\n#define LR R14\n#define SHIFT 1\n" + source
+			requireARMGoAssemblerResult(t, resolved, true)
+			file, err = Parse(ArchARM, resolved)
+			if err != nil {
+				t.Fatal(err)
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"macroprobe": {Name: "macroprobe", Ret: Void}}})
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "probe.ll", "probe.o", ir)
+			}
+		})
+	}
+}
+
+func TestParenthesizedMemoryExpressionIsNotDiscarded(t *testing.T) {
+	for _, source := range []string{"(layout_offset+4)(R1)", "(layout_offset+4)(BX)(CX*2)", "(layout_offset+)(R1)"} {
+		memory, ok := parseMem(source)
+		if !ok || memory.OffRaw == "" {
+			t.Errorf("%s: dropped unresolved or invalid displacement: %+v, parsed=%v", source, memory, ok)
+		}
+	}
+}
+
+func TestARMMemoryContextExpressionGrammar(t *testing.T) {
+	for _, expression := range []string{
+		"OFFSET", "+OFFSET", "-OFFSET", "~OFFSET", "(OFFSET+4)",
+		"OFFSET-4", "OFFSET*4", "OFFSET/4", "OFFSET%4", "OFFSET<<2", "OFFSET>>2",
+		"OFFSET&7", "OFFSET|7", "OFFSET^7", "R2<<(SHIFT+1)", "R2@>SHIFT", "R2->SHIFT", "OFFSET+'x'",
+	} {
+		if !armMemoryOffsetNeedsContext(MemRef{Base: "R1", OffRaw: expression}) {
+			t.Errorf("symbolic integer expression %q did not require context", expression)
+		}
+	}
+	for _, expression := range []string{"", "4", "'x'", "1.2", "R2", "g", "R2<<2", "R2<<R3", "R2<<(R3+1)", "OFFSET+", "!OFFSET", "OFFSET==4", "OFFSET(4)", "OFFSET.field"} {
+		if armMemoryOffsetNeedsContext(MemRef{Base: "R1", OffRaw: expression}) {
+			t.Errorf("concrete or invalid expression %q was hidden as context", expression)
+		}
+	}
+}
+
+func TestARMMemoryOffsetProbeRetainsConcreteValidation(t *testing.T) {
+	for _, tc := range []struct {
+		offset string
+		valid  bool
+	}{
+		{"0(R1)", true}, {"R2<<2(R1)", true}, {"slot-4(SP)", true},
+		{"R2<<R3(R1)", false}, {"R2<<32(R1)", false}, {"R2<<(R3+1)(R1)", false},
+		{"(gobuf_sp+)(R1)", false},
+	} {
+		source := fmt.Sprintf("TEXT concreteprobe(SB),$0-0\nMOVW %s, R4\nRET\n", tc.offset)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			if tc.valid {
+				t.Fatal(err)
+			}
+			continue
+		}
+		err = ProbeInstruction(ArchARM, "arm", file.Funcs[0].Instrs[1])
+		if errors.Is(err, ErrProbeNeedsContext) || (err == nil) != tc.valid {
+			t.Errorf("%s: err=%v, want concrete valid=%v", tc.offset, err, tc.valid)
+		}
+	}
+}
diff --git a/arm_raw_data_forms.go b/arm_raw_data_forms.go
new file mode 100644
index 000000000..df997bdf6
--- /dev/null
+++ b/arm_raw_data_forms.go
@@ -0,0 +1,308 @@
+package plan9asm
+
+// armRawDataForm registers the existing typed data lowerers that do not write
+// APSR.NZCV. Emission and the source-status proof consume the same decoder.
+// This is not a native-entry or complete machine-effect contract: GP writes
+// conservatively invalidate typed value witnesses, and unknown WORDs stay opaque.
+type armRawDataForm struct {
+	family    string
+	condition string
+	gpWrites  armKernelState
+	lower     func(*armCtx) error
+}
+
+func armRawCoreWrites(registers ...int) armKernelState {
+	var writes armKernelState
+	for _, register := range registers {
+		if register >= 0 && register < 15 {
+			writes |= 1 << register
+			if register == 13 {
+				writes |= armKernelRegBit(SP)
+			}
+		}
+	}
+	return writes
+}
+
+func armRawDirectionWrites(write bool, registers ...int) armKernelState {
+	if !write {
+		return 0
+	}
+	return armRawCoreWrites(registers...)
+}
+
+func armRawPostIndexWrites(base, offset int) armKernelState {
+	return armRawDirectionWrites(offset != 15, base)
+}
+
+func decodeARMRawDataForm(ins Instr) (armRawDataForm, bool) {
+	if ins.Op != OpWORD || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return armRawDataForm{}, false
+	}
+	word := uint32(ins.Args[0].Imm)
+	if form, ok := decodeARMRawNEONStructureFourMultiple(word); ok {
+		return armRawDataForm{
+			family:    "StructureFourMultiple",
+			condition: "",
+			gpWrites:  armRawPostIndexWrites(form.base, form.offset),
+			lower:     func(c *armCtx) error { return c.lowerRawNEONStructureFourMultiple(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONModifiedImmediate(word); ok {
+		return armRawDataForm{
+			family:    "ModifiedImmediate",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONModifiedImmediate(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONCoreLaneMove(word); ok {
+		return armRawDataForm{
+			family:    "CoreLaneMove",
+			condition: form.condition,
+			gpWrites:  armRawDirectionWrites(!form.toVector, form.core),
+			lower:     func(c *armCtx) error { return c.lowerRawNEONCoreLaneMove(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONStructureOneLane(word); ok {
+		return armRawDataForm{
+			family:    "StructureOneLane",
+			condition: "",
+			gpWrites:  armRawPostIndexWrites(form.base, form.offset),
+			lower:     func(c *armCtx) error { return c.lowerRawNEONStructureLane(form, 1) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONStructureFourLane(word); ok {
+		return armRawDataForm{
+			family:    "StructureFourLane",
+			condition: "",
+			gpWrites:  armRawPostIndexWrites(form.base, form.offset),
+			lower:     func(c *armCtx) error { return c.lowerRawNEONStructureFourLane(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONTranspose(word); ok {
+		return armRawDataForm{
+			family:    "Transpose",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONTranspose(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONShiftRightNarrow(word); ok {
+		return armRawDataForm{
+			family:    "ShiftRightNarrow",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONShiftRightNarrow(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONBitClearImmediate(word); ok {
+		return armRawDataForm{
+			family:    "BitClearImmediate",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONBitClearImmediate(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONExtract(word); ok {
+		return armRawDataForm{
+			family:    "Extract",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONExtract(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMoveNarrow(word); ok {
+		return armRawDataForm{
+			family:    "MoveNarrow",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMoveNarrow(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONShiftInsert(word); ok {
+		return armRawDataForm{
+			family:    "ShiftInsert",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONShiftInsert(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONShiftRightImmediate(word); ok {
+		return armRawDataForm{
+			family:    "ShiftRightImmediate",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONShiftRightImmediate(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONReverse(word); ok {
+		return armRawDataForm{
+			family:    "Reverse",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONReverse(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMultiplyLongLane(word); ok {
+		return armRawDataForm{
+			family:    "MultiplyLongLane",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMultiplyLongLane(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMultiplyLongVector(word); ok {
+		return armRawDataForm{
+			family:    "MultiplyLongVector",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMultiplyLongVector(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONAddSub(word); ok {
+		return armRawDataForm{
+			family:    "AddSub",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONAddSub(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVFPLoadStore(word); ok {
+		return armRawDataForm{
+			family:    "VFPLoadStore",
+			condition: form.condition,
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawVFPLoadStore(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONShiftImmediate(word); ok {
+		return armRawDataForm{
+			family:    "ShiftImmediate",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONShiftImmediate(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVFPMove(word); ok {
+		return armRawDataForm{
+			family:    "VFPMove",
+			condition: form.condition,
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawVFPMove(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONPairwiseMinMax(word); ok {
+		return armRawDataForm{
+			family:    "PairwiseMinMax",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONPairwiseMinMax(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMinMax(word); ok {
+		return armRawDataForm{
+			family:    "MinMax",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMinMax(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVFPScalarArithmetic(word); ok {
+		return armRawDataForm{
+			family:    "VFPScalarArithmetic",
+			condition: form.condition,
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawVFPScalarArithmetic(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMultiplyLane(word); ok {
+		return armRawDataForm{
+			family:    "MultiplyLane",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMultiplyLane(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONConvertFloat32(word); ok {
+		return armRawDataForm{
+			family:    "ConvertFloat32",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONConvertFloat32(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONMoveLong(word); ok {
+		return armRawDataForm{
+			family:    "MoveLong",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONMoveLong(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONWideningAddSub(word); ok {
+		return armRawDataForm{
+			family:    "WideningAddSub",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONWideningAddSub(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONDup(word); ok {
+		return armRawDataForm{
+			family:    "Dup",
+			condition: form.condition,
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONDup(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONStructureOne(word); ok {
+		return armRawDataForm{
+			family:    "StructureOne",
+			condition: "",
+			gpWrites:  armRawPostIndexWrites(form.base, form.offset),
+			lower:     func(c *armCtx) error { return c.lowerRawNEONStructureOne(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawNEONBitwise(word); ok {
+		return armRawDataForm{
+			family:    "Bitwise",
+			condition: "",
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawNEONBitwise(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawSXTB(word); ok {
+		return armRawDataForm{
+			family:    "SXTB",
+			condition: form.condition,
+			gpWrites:  armRawCoreWrites(form.destination),
+			lower:     func(c *armCtx) error { return c.lowerRawSXTB(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVMOVPair(word); ok {
+		return armRawDataForm{
+			family:    "VMOVPair",
+			condition: form.condition,
+			gpWrites:  armRawDirectionWrites(!form.toFloat, form.firstCore, form.secondCore),
+			lower:     func(c *armCtx) error { return c.lowerRawVMOVPair(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVFPMultiple(word); ok {
+		return armRawDataForm{
+			family:    "VFPMultiple",
+			condition: form.condition,
+			gpWrites:  armRawDirectionWrites(form.writeback, form.base),
+			lower:     func(c *armCtx) error { return c.lowerRawVFPMultiple(form) },
+		}, true
+	}
+	if form, ok := decodeARMRawVFPImmediate(word); ok {
+		return armRawDataForm{
+			family:    "VFPImmediate",
+			condition: form.condition,
+			gpWrites:  0,
+			lower:     func(c *armCtx) error { return c.lowerRawVFPImmediate(form) },
+		}, true
+	}
+	return armRawDataForm{}, false
+}
diff --git a/arm_raw_decode.go b/arm_raw_decode.go
new file mode 100644
index 000000000..a59ccaf0e
--- /dev/null
+++ b/arm_raw_decode.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+
+	"golang.org/x/arch/arm/armasm"
+)
+
+// decodeARMRawWordInstruction recovers the Go assembler spelling for an ARM
+// WORD using Go's architecture decoder. The returned instruction is not
+// considered supported until the ordinary ARM semantic lowerer accepts it.
+func decodeARMRawWordInstruction(ins Instr) (Instr, error) {
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return Instr{}, fmt.Errorf("arm WORD expects exactly one resolved integer constant: %q", ins.Raw)
+	}
+	word := uint32(ins.Args[0].Imm)
+	if decoded, ok, err := decodeARMRawCoprocessorTransfer(word, ins.Raw); ok {
+		if err != nil {
+			return Instr{}, err
+		}
+		return decoded, nil
+	}
+	// A32 UDF has 16 immediate bits split around its fixed low nibble. Go's
+	// runtime uses UDF #16 as a GDB-recognized breakpoint; external assembly
+	// also uses UDF #0 as a terminating tail guard. x/arch does not decode
+	// these forms, but all immediates share Go's operand-free UNDEF semantics.
+	if word&0xfff000f0 == 0xe7f000f0 {
+		return Instr{Op: "UNDEF", Raw: fmt.Sprintf("UNDEF /* decoded from %s */", ins.Raw)}, nil
+	}
+	var code [4]byte
+	binary.LittleEndian.PutUint32(code[:], word)
+	decoded, err := armasm.Decode(code[:], armasm.ModeARM)
+	if err != nil {
+		return Instr{}, fmt.Errorf("decode ARM WORD %#08x: %w", word, err)
+	}
+	for _, arg := range decoded.Args {
+		if arg == nil {
+			break
+		}
+		if _, ok := arg.(armasm.PCRel); ok {
+			return Instr{}, fmt.Errorf("ARM WORD %#08x is PC-relative and cannot be mapped safely to source labels: %q", word, ins.Raw)
+		}
+	}
+	if decoded.Op&^15 == armasm.LDR_EQ {
+		reg, _ := decoded.Args[0].(armasm.Reg)
+		mem, _ := decoded.Args[1].(armasm.Mem)
+		if reg == armasm.R15 && mem.Base == armasm.SP && mem.Sign == 0 && mem.Mode == armasm.AddrPostIndex {
+			// GoSyntax prints this physical load and SP writeback as RET.
+			// That alias cannot establish the caller's stack-return contract;
+			// reject it before the original R15 destination is discarded.
+			return Instr{}, fmt.Errorf("%w: ARM WORD %#08x loads R15 with SP writeback and requires explicit control-flow/stack-return context: %q", ErrProbeNeedsContext, word, ins.Raw)
+		}
+	}
+	if decoded.Op&^15 == armasm.POP_EQ {
+		for _, arg := range decoded.Args {
+			if registers, ok := arg.(armasm.RegList); ok && registers&(1<<15) != 0 {
+				return Instr{}, fmt.Errorf("%w: ARM WORD %#08x pops R15 and requires explicit control-flow/stack-return context: %q", ErrProbeNeedsContext, word, ins.Raw)
+			}
+		}
+	}
+	syntax := armasm.GoSyntax(decoded, 0, nil, nil)
+	if op, rest, ok := strings.Cut(syntax, " "); ok && strings.HasPrefix(op, "BLX") {
+		condition := strings.TrimPrefix(op, "BLX")
+		if condition != "" && !strings.HasPrefix(condition, ".") {
+			condition = "." + condition
+		}
+		syntax = "BL" + condition + " (" + rest + ")"
+	}
+	// x/arch uses ARM architectural brackets for memory operands, while the
+	// Go assembler source grammar spells the same operand with parentheses.
+	// Convert them before parsing; otherwise [SP] is mistaken for a register
+	// list and raw LDREXD/STREXD forms lose their memory operand class.
+	syntax = strings.NewReplacer("[", "(", "]", ")").Replace(syntax)
+	file, err := Parse(ArchARM, "TEXT decoded(SB), $0-0\n"+syntax+"\n")
+	if err != nil {
+		return Instr{}, fmt.Errorf("parse decoded ARM WORD %#08x as %q: %w", word, syntax, err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 2 {
+		return Instr{}, fmt.Errorf("decoded ARM WORD %#08x produced an invalid instruction sequence %q", word, syntax)
+	}
+	result := file.Funcs[0].Instrs[1]
+	result.Raw = fmt.Sprintf("%s /* decoded from %s */", result.Raw, ins.Raw)
+	return result, nil
+}
+
+// decodeARMRawCoprocessorTransfer covers the A32 MRC/MCR register-transfer
+// encodings that Go assembly commonly emits as WORD (for example CP15 ID
+// reads). x/arch/arm intentionally does not decode coprocessor transfers, so
+// recover their complete operand fields here before falling back to it.
+func decodeARMRawCoprocessorTransfer(word uint32, raw string) (Instr, bool, error) {
+	if word&0x0f000010 != 0x0e000010 {
+		return Instr{}, false, nil
+	}
+	conditionNames := [...]string{
+		"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC",
+		"HI", "LS", "GE", "LT", "GT", "LE", "", "",
+	}
+	condition := conditionNames[word>>28&15]
+	if word>>28&15 == 15 {
+		return Instr{}, false, nil
+	}
+	op := "MCR"
+	if word>>20&1 != 0 {
+		op = "MRC"
+	}
+	if condition != "" {
+		op += "." + condition
+	}
+	part := func(value uint32) string { return fmt.Sprintf("$%d", value) }
+	syntax := fmt.Sprintf("%s %s, %s, R%d, %s, %s, %s",
+		op,
+		part(word>>8&15),
+		part(word>>21&7),
+		word>>12&15,
+		part(word>>16&15),
+		part(word>>0&15),
+		part(word>>5&7),
+	)
+	file, err := Parse(ArchARM, "TEXT decoded(SB), $0-0\n"+syntax+"\n")
+	if err != nil {
+		return Instr{}, true, fmt.Errorf("parse decoded ARM coprocessor WORD %#08x as %q: %w", word, syntax, err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 2 {
+		return Instr{}, true, fmt.Errorf("decoded ARM coprocessor WORD %#08x produced an invalid instruction sequence %q", word, syntax)
+	}
+	result := file.Funcs[0].Instrs[1]
+	result.Raw = fmt.Sprintf("%s /* decoded from %s */", result.Raw, raw)
+	return result, true, nil
+}
diff --git a/arm_raw_float_conversion_test.go b/arm_raw_float_conversion_test.go
new file mode 100644
index 000000000..89f14af3b
--- /dev/null
+++ b/arm_raw_float_conversion_test.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawSingleRegisterConversionCompleteFamily(t *testing.T) {
+	// These words cover both directions, signed and unsigned integer modes,
+	// even/odd single-register halves, and the S0/S31 register boundaries.
+	const source = `TEXT rawConversions(SB), $0-0
+	WORD $0xeef80aee // vcvt.f32.s32 s1, s29
+	WORD $0xeeb81a4f // vcvt.f32.u32 s2, s30
+	WORD $0xeefd1aef // vcvt.s32.f32 s3, s31
+	WORD $0xeebc2ac0 // vcvt.u32.f32 s4, s0
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawConversions": {Name: "rawConversions", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"vcvt.f32.s32", "vcvt.f32.u32", "vcvt.s32.f32", "vcvt.u32.f32", `"target-features"="+vfp2"`} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("raw VCVT family IR omitted %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-vcvt.ll", "arm-raw-vcvt.o", ir)
+}
diff --git a/arm_raw_status_continuation_test.go b/arm_raw_status_continuation_test.go
new file mode 100644
index 000000000..0b2cc0277
--- /dev/null
+++ b/arm_raw_status_continuation_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestARMRawVectorKeepsSourceDefinedNZCV(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, word := range []uint32{
+		0xf2200842, // VADD.I32 Q0,Q0,Q1
+		0xf3066150, // VEOR Q3,Q3,Q0
+		0xf3b460c6, // VREV32.16 Q3,Q3
+		0xf3ac2078, // VSHR.U32 Q1,Q12,#20
+		0xf3ac2578, // VSLI.32 Q1,Q12,#12
+		0xf423228f, // VLD1.32 {Q1,Q2},[R3]
+		0xedcd8b11, // VSTR D24,[SP,#68]
+		0x1e300a00, // VADDNE.F32 S0,S0,S0
+	} {
+		t.Run(fmt.Sprintf("%08x", word), func(t *testing.T) {
+			source := fmt.Sprintf("TEXT flags(SB),$128\n MOVW $2,R0\nloop:\n SUB.S $1,R0,R0\n WORD $%#08x\n B.NE loop\n MOVW CPSR,R0\n RET\n", word)
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{
+					"flags": {Name: "flags", Ret: I32},
+				}})
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "raw-flags.ll", "raw-flags.o", ir)
+			}
+		})
+	}
+}
+
+func TestARMRawVectorDoesNotInventPredicates(t *testing.T) {
+	for _, body := range []string{
+		"WORD $0x1e300a00", // Conditional scalar VFP.
+		"WORD $0x1ee00b10", // Conditional core VDUP.
+		"WORD $0xf2200842\n B.NE done\ndone:",
+		"CMP R0,R0\n WORD $0xffffffff\n B.NE done\ndone:",
+		"CMP R0,R0\n WORD $0xeef1fa10\n B.NE done\ndone:",
+		"B join\n CMP R0,R0\njoin:\n WORD $0xf2200842\n B.NE done\ndone:",
+	} {
+		source := "TEXT flags(SB),$0\n MOVW $0,R0\n" + body + "\n RET\n"
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+			"flags": {Name: "flags", Ret: Void},
+		}})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("raw source cannot invent or preserve unproved flags: %s: %v", body, err)
+		}
+	}
+}
+
+func TestARMRawDataStatusCFGAndGPOutputGuards(t *testing.T) {
+	tests := []struct {
+		name, body string
+		accepted   bool
+	}{
+		{name: "diamond", body: "CMP R0,R0\n B.EQ alternate\n WORD $0xf2200842\n B join\nalternate:\n WORD $0xf3066150\njoin:\n MOVW CPSR,R0", accepted: true},
+		{name: "unknown_join", body: "CMP R0,R0\n B.EQ alternate\n WORD $0xf2200842\n B join\nalternate:\n WORD $0xffffffff\njoin:\n MOVW CPSR,R0"},
+		{name: "call_flags", body: "CMP R0,R0\n WORD $0xf2200842\n BL other<>(SB)\n B.NE done\ndone:"},
+		{name: "partial_NZ", body: "TST R0,R0\n WORD $0xf2200842\n B.HI done\ndone:"},
+		{name: "lane_GP_output", body: "CMP R0,R0\n WORD $0xee100b10\n MOVW R0,CPSR"},
+		{name: "pair_GP_outputs", body: "CMP R0,R0\n WORD $0xec510b10\n MOVW R0,CPSR"},
+		{name: "extend_GP_output", body: "CMP R0,R0\n WORD $0xe6af0070\n MOVW R0,CPSR"},
+		{name: "NEON_writeback", body: "CMP R0,R0\n WORD $0xf420070d\n MOVW R0,CPSR"},
+		{name: "VFP_writeback", body: "CMP R0,R0\n WORD $0xeca00b04\n MOVW R0,CPSR"},
+		{name: "overwrite_killed_GP", body: "CMP R0,R0\n WORD $0xee100b10\n MOVW $0x60000000,R0\n MOVW R0,CPSR\n MOVW CPSR,R0", accepted: true},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT flags(SB),$128\n MOVW $0,R0\n" + test.body + "\n RET\nTEXT other<>(SB),$0\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"flags": {Name: "flags", Ret: Void}, "other<>": {Name: "other<>", Ret: Void},
+			}})
+			if test.accepted {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("raw data did not retain the source/CFG guard: %v", err)
+			}
+		})
+	}
+}
diff --git a/arm_raw_status_family_test.go b/arm_raw_status_family_test.go
new file mode 100644
index 000000000..353c3dd85
--- /dev/null
+++ b/arm_raw_status_family_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type armRawStatusCase struct {
+	family      string
+	instruction string
+	conditional bool
+}
+
+// This inventory covers every existing specialized raw-data registration.
+// LLVM MC supplies independent encodings; the family's own tests still cover
+// its complete operand fields, reserved encodings and arithmetic semantics.
+func armRawStatusFamilies() []armRawStatusCase {
+	return []armRawStatusCase{
+		{family: "StructureFourMultiple", instruction: "vld4.8 {d0,d1,d2,d3},[r4]!"},
+		{family: "ModifiedImmediate", instruction: "vmov.i8 q0,#18"},
+		{family: "CoreLaneMove", instruction: "vmov.32 r0,d0[0]", conditional: true},
+		{family: "StructureOneLane", instruction: "vst1.8 {d0[0]},[r4]!"},
+		{family: "StructureFourLane", instruction: "vld4.8 {d0[0],d1[0],d2[0],d3[0]},[r4]!"},
+		{family: "Transpose", instruction: "vtrn.8 d0,d1"},
+		{family: "ShiftRightNarrow", instruction: "vshrn.i16 d0,q1,#1"},
+		{family: "BitClearImmediate", instruction: "vbic.i32 d0,#255"},
+		{family: "Extract", instruction: "vext.8 q0,q1,q2,#3"},
+		{family: "MoveNarrow", instruction: "vmovn.i16 d0,q1"},
+		{family: "ShiftInsert", instruction: "vsli.32 q0,q1,#3"},
+		{family: "ShiftRightImmediate", instruction: "vshr.u32 q0,q1,#3"},
+		{family: "Reverse", instruction: "vrev32.16 q0,q1"},
+		{family: "MultiplyLongLane", instruction: "vmull.u32 q0,d1,d2[0]"},
+		{family: "MultiplyLongVector", instruction: "vmull.u8 q0,d1,d2"},
+		{family: "AddSub", instruction: "vadd.i32 q0,q1,q2"},
+		{family: "VFPLoadStore", instruction: "vstr d0,[r4]", conditional: true},
+		{family: "ShiftImmediate", instruction: "vshl.i32 q0,q1,#3"},
+		{family: "VFPMove", instruction: "vmov.f32 s0,s1", conditional: true},
+		{family: "PairwiseMinMax", instruction: "vpmax.f32 d0,d1,d2"},
+		{family: "MinMax", instruction: "vmax.f32 q0,q1,q2"},
+		{family: "VFPScalarArithmetic", instruction: "vadd.f32 s0,s1,s2", conditional: true},
+		{family: "MultiplyLane", instruction: "vmul.f32 q0,q1,d2[0]"},
+		{family: "ConvertFloat32", instruction: "vcvt.f32.s32 q0,q1"},
+		{family: "MoveLong", instruction: "vmovl.u8 q0,d1"},
+		{family: "WideningAddSub", instruction: "vsubl.u8 q0,d1,d2"},
+		{family: "Dup", instruction: "vdup.32 q0,r0", conditional: true},
+		{family: "StructureOne", instruction: "vld1.8 {d0,d1},[r4]!"},
+		{family: "Bitwise", instruction: "veor q0,q1,q2"},
+		{family: "SXTB", instruction: "sxtb r0,r1", conditional: true},
+		{family: "VMOVPair", instruction: "vmov r0,r1,d0", conditional: true},
+		{family: "VFPMultiple", instruction: "vstmia r4!,{d0,d1}", conditional: true},
+		{family: "VFPImmediate", instruction: "vmov.f32 s0,#1.0", conditional: true},
+	}
+}
+
+func armRawStatusVariants() []armRawStatusCase {
+	var variants []armRawStatusCase
+	for _, family := range armRawStatusFamilies() {
+		variants = append(variants, family)
+		if family.conditional {
+			for _, condition := range []string{"eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc", "hi", "ls", "ge", "lt", "gt", "le"} {
+				variant := family
+				end := strings.IndexAny(variant.instruction, ". ")
+				variant.instruction = variant.instruction[:end] + condition + variant.instruction[end:]
+				variants = append(variants, variant)
+			}
+		}
+	}
+	return variants
+}
+
+func assembleARMRawStatusWords(t *testing.T, variants []armRawStatusCase) []uint32 {
+	t.Helper()
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc not found")
+	}
+	var source strings.Builder
+	source.WriteString(".syntax unified\n.fpu neon\n")
+	for _, variant := range variants {
+		fmt.Fprintln(&source, variant.instruction)
+	}
+	cmd := exec.Command(mc, "-triple=armv7-unknown-linux-gnueabihf", "-show-encoding")
+	cmd.Stdin = strings.NewReader(source.String())
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM22 ARM raw-status encoder: %v\n%s", err, output)
+	}
+	encodings := regexp.MustCompile(`encoding: \[([^\]]+)\]`).FindAllStringSubmatch(string(output), -1)
+	if len(encodings) != len(variants) {
+		t.Fatalf("got %d encodings for %d variants: %s", len(encodings), len(variants), output)
+	}
+	words := make([]uint32, len(variants))
+	for i, encoding := range encodings {
+		fields := strings.Split(encoding[1], ",")
+		if len(fields) != 4 {
+			t.Fatalf("not an A32 word: %s", encoding[0])
+		}
+		var code [4]byte
+		for j, field := range fields {
+			value, err := strconv.ParseUint(strings.TrimSpace(field), 0, 8)
+			if err != nil {
+				t.Fatal(err)
+			}
+			code[j] = byte(value)
+		}
+		words[i] = binary.LittleEndian.Uint32(code[:])
+	}
+	return words
+}
+
+func armRawStatusSource(index int, word uint32) string {
+	return fmt.Sprintf("TEXT rawstatus_%d(SB),4,$128-12\n MOVW status+0(FP),R0\n MOVW R0,CPSR\n MOVW scratch+4(FP),R4\n MOVW R4,R0\n MOVW R4,R1\n WORD $%#08x\n MOVW CPSR,R0\n SRL $28,R0\n MOVW R0,ret+8(FP)\n RET\n", index, word)
+}
+
+func armRawStatusSignature(name string) FuncSig {
+	return FuncSig{Name: name, Args: []LLVMType{I32, Ptr}, Ret: I32, Frame: FrameLayout{
+		Params: []FrameSlot{
+			{Offset: 0, Type: I32, Index: 0, Field: -1},
+			{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+		},
+		Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}},
+	}}
+}
+
+func TestARMRawDataStatusRegistrationCompleteness(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "arm_raw_data_forms.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	registered := map[string]bool{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		literal, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return true
+		}
+		name, ok := literal.Type.(*ast.Ident)
+		if !ok || name.Name != "armRawDataForm" {
+			return true
+		}
+		for _, element := range literal.Elts {
+			field, ok := element.(*ast.KeyValueExpr)
+			if !ok {
+				continue
+			}
+			key, ok := field.Key.(*ast.Ident)
+			if !ok || key.Name != "family" {
+				continue
+			}
+			value, ok := field.Value.(*ast.BasicLit)
+			if !ok || value.Kind != token.STRING {
+				t.Fatal("raw status family registration needs an explicit inventory name")
+			}
+			name, err := strconv.Unquote(value.Value)
+			if err != nil || name == "" || registered[name] {
+				t.Fatalf("invalid/duplicate raw family registration: %s", value.Value)
+			}
+			registered[name] = true
+		}
+		return true
+	})
+	for _, family := range armRawStatusFamilies() {
+		if !registered[family.family] {
+			t.Fatalf("fixture family %q has no typed registration", family.family)
+		}
+		delete(registered, family.family)
+	}
+	if len(registered) != 0 {
+		t.Fatalf("registered raw families have no status oracle: %v", registered)
+	}
+}
+
+func TestARMRawDataStatusAllConditionsAndObjects(t *testing.T) {
+	variants := armRawStatusVariants()
+	words := assembleARMRawStatusWords(t, variants)
+	var source strings.Builder
+	sigs := map[string]FuncSig{}
+	for i, word := range words {
+		form, ok := decodeARMRawDataForm(Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}})
+		if !ok || form.family != variants[i].family {
+			t.Fatalf("%s %s decoded as %+v, registered=%v", variants[i].family, variants[i].instruction, form, ok)
+		}
+		text := armRawStatusSource(i, word)
+		requireARMGoAssemblerResult(t, text, true)
+		source.WriteString(text)
+		name := fmt.Sprintf("rawstatus_%d", i)
+		sigs[name] = armRawStatusSignature(name)
+	}
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "raw-status-family.ll", "raw-status-family.o", ir)
+	}
+	t.Logf("%d raw data families, %d independent LLVM-MC variants, three ARM object targets", len(armRawStatusFamilies()), len(variants))
+}
diff --git a/arm_raw_status_runtime_test.go b/arm_raw_status_runtime_test.go
new file mode 100644
index 000000000..0f15b7d9d
--- /dev/null
+++ b/arm_raw_status_runtime_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMRawDataStatus(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for required original Go WORD and LLVM ARM flag execution")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM raw status oracle requires a Linux driver")
+	}
+	for _, name := range []string{"qemu-arm", "arm-linux-gnueabihf-gcc"} {
+		if _, err := exec.LookPath(name); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	variants := armRawStatusVariants()
+	words := assembleARMRawStatusWords(t, variants)
+	var source, goMain, declarations, cFunctions strings.Builder
+	sigs := map[string]FuncSig{}
+	goMain.WriteString("package main\nimport \"fmt\"\n")
+	declarations.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for i, word := range words {
+		source.WriteString(armRawStatusSource(i, word))
+		name := fmt.Sprintf("rawstatus_%d", i)
+		sigs[name] = armRawStatusSignature(name)
+		fmt.Fprintf(&goMain, "func %s(status uint32,scratch *[256]byte) uint32\n", name)
+		fmt.Fprintf(&declarations, "extern uint32_t %s(uint32_t,uint8_t*);\n", name)
+		fmt.Fprintf(&cFunctions, "%s,\n", name)
+	}
+	goMain.WriteString("func main() {\n functions := []func(uint32,*[256]byte)uint32{\n")
+	for i := range words {
+		fmt.Fprintf(&goMain, "rawstatus_%d,\n", i)
+	}
+	goMain.WriteString(`}
+ for i,probe := range functions {
+  for flags:=uint32(0);flags<16;flags++ {
+   for seed:=0;seed<4;seed++ {
+    var scratch [256]byte
+    for j:=range scratch { scratch[j]=byte(j*17+seed*71) }
+    got:=probe(flags<<28,&scratch)
+    if got!=flags { panic(fmt.Sprintf("Go raw WORD family=%d flags=%x seed=%d got=%x",i,flags,seed,got)) }
+   }
+  }
+ }
+ fmt.Printf("original Go raw WORD: %d families/condition variants, all 16 NZCV states, four buffers passed\n",len(functions))
+}
+`)
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":       "module armrawstatusoracle\n\ngo 1.20\n",
+		"main.go":      goMain.String(),
+		"oracle_arm.s": strings.ReplaceAll(source.String(), "TEXT rawstatus_", "TEXT ·rawstatus_"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0", "QEMU_CPU=max")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual original Go ARM raw-status oracle: %v\n%s", err, output)
+	} else {
+		t.Logf("%s", output)
+	}
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := declarations.String() + "static uint32_t (*const functions[])(uint32_t,uint8_t*)={\n" + cFunctions.String() + `};
+int main(void) {
+ for(unsigned i=0;i<sizeof(functions)/sizeof(functions[0]);i++) {
+  for(uint32_t flags=0;flags<16;flags++) {
+   for(unsigned seed=0;seed<4;seed++) {
+    uint8_t scratch[256];
+    for(unsigned j=0;j<256;j++)scratch[j]=(uint8_t)(j*17+seed*71);
+    uint32_t got=functions[i](flags<<28,scratch);
+    if(got!=flags) {
+     fprintf(stderr,"LLVM raw-status family=%u flags=%x seed=%u got=%x\n",i,flags,seed,got);
+     return 1;
+    }
+   }
+  }
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "arm_raw_status", "armv7-unknown-linux-gnueabihf", ir, cMain,
+		[]string{"qemu-arm", "-cpu", "max", "-L", "/usr/arm-linux-gnueabihf"})
+	t.Logf("LLVM/C independent four-flag oracle: %d executed cases", len(words)*16*4)
+}
diff --git a/arm_raw_sxtb_test.go b/arm_raw_sxtb_test.go
new file mode 100644
index 000000000..d980975cf
--- /dev/null
+++ b/arm_raw_sxtb_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARMRawSXTBRotationFamilyUsesSemanticLowering(t *testing.T) {
+	const source = `TEXT rawSXTB(SB), $0-0
+	WORD $0xe6af4074 // sxtb r4, r4
+	WORD $0xe6af5474 // sxtb r5, r4, ror #8
+	WORD $0xe6af6874 // sxtb r6, r4, ror #16
+	WORD $0xe6af7c74 // sxtb r7, r4, ror #24
+	RET
+`
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"rawSXTB": {Name: "rawSXTB", Ret: Void}}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Count(ir, "sext i8") != 4 || strings.Count(ir, "= call i32 @llvm.fshr.i32") != 3 {
+		t.Fatalf("raw SXTB family did not retain rotate and signed-extension semantics:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-sxtb.ll", "arm-raw-sxtb.o", ir)
+}
+
+func TestARMRawSXTBDecoderCoversEveryEncodingField(t *testing.T) {
+	count := 0
+	for condition := 0; condition < 15; condition++ {
+		for rotation := 0; rotation < 4; rotation++ {
+			for source := 0; source < 16; source++ {
+				for destination := 0; destination < 16; destination++ {
+					word := uint32(condition)<<28 | 0x06af0070 | uint32(destination)<<12 | uint32(rotation)<<10 | uint32(source)
+					got, ok := decodeARMRawSXTB(word)
+					if !ok || got.condition != armConditionName(condition) || got.rotation != rotation*8 || got.source != source || got.destination != destination {
+						t.Fatalf("decoded ARM SXTB %#08x as %+v, ok=%v", word, got, ok)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 15*4*16*16 {
+		t.Fatalf("covered %d SXTB encodings, want %d", count, 15*4*16*16)
+	}
+}
+
+func TestARMRawSXTBRejectsReservedAndUnsafeForms(t *testing.T) {
+	if _, ok := decodeARMRawSXTB(0xf6af0070); ok {
+		t.Fatal("SXTB decoder accepted condition 0xf from the unconditional instruction space")
+	}
+	// 0xe6bf0070 is the official SXTH R0, R0 encoding, not a reserved
+	// SXTB-adjacent slot. The 0x69 variant is absent from the architectural
+	// signed/unsigned extend family (0x68, 0x6a-0x6c, and 0x6e-0x6f).
+	for _, word := range []uint32{0xe69f0070, 0xe6af047f} {
+		file, err := Parse(ArchARM, fmt.Sprintf("TEXT badSXTB(SB), $0-0\n\tWORD $%#08x\n\tRET\n", word))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"badSXTB": {Name: "badSXTB", Ret: Void}}}); err == nil {
+			t.Fatalf("Translate accepted reserved/unsafe SXTB-adjacent encoding %#08x", word)
+		}
+	}
+}
diff --git a/arm_raw_undef_test.go b/arm_raw_undef_test.go
new file mode 100644
index 000000000..8bc52cb98
--- /dev/null
+++ b/arm_raw_undef_test.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMRawUndefinedInstructionEncodings(t *testing.T) {
+	for _, word := range []uint32{
+		0xe7f000f0, // ARM UDF #0, used by wireguard-go's NEON tail guard.
+		0xe7f001f0, // Runtime's GDB-recognized software breakpoint.
+		0xe7f123f4, // ARM UDF #0x1234.
+		0xe7ffffff, // ARM UDF #0xffff.
+		0xf7fabcfd, // Encoding emitted by Go 1.27 for named UNDEF.
+	} {
+		t.Run(fmt.Sprintf("%08x", word), func(t *testing.T) {
+			src := fmt.Sprintf("TEXT rawundef(SB),NOSPLIT,$0-0\n\tWORD $%#08x\n", word)
+			file, err := Parse(ArchARM, src)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{
+				Goarch:       "arm",
+				TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{
+					"rawundef": {Name: "rawundef", Ret: Void},
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, want := range []string{`asm sideeffect "udf #0"`, "unreachable"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("raw UNDEF IR missing %q:\n%s", want, ir)
+				}
+			}
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-raw-undef.ll", "arm-raw-undef.o", ir)
+		})
+	}
+}
+
+func TestTranslateARMRawUndefinedRejectsUnrelatedWord(t *testing.T) {
+	src := "TEXT rawunknown(SB),NOSPLIT,$0-0\n\tWORD $0xffffffff\n\tRET\n"
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{
+		Goarch:       "arm",
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{
+			"rawunknown": {Name: "rawunknown", Ret: Void},
+		},
+	}); err == nil {
+		t.Fatal("Translate unexpectedly accepted an unrelated ARM WORD")
+	}
+}
+
+func TestTranslateARMRawFPSCRTransferPair(t *testing.T) {
+	src := `TEXT fpscr(SB),NOSPLIT,$0-0
+	WORD $0xeef1ba10
+	BIC $(1<<24), R11
+	WORD $0xeee1ba10
+	RET
+`
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf"} {
+		ir, err := Translate(file, Options{
+			Goarch:       "arm",
+			TargetTriple: triple,
+			Sigs: map[string]FuncSig{
+				"fpscr": {Name: "fpscr", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		for _, want := range []string{`vmrs $0, fpscr`, `vmsr fpscr, $0`} {
+			if !strings.Contains(ir, want) {
+				t.Fatalf("%s raw FPSCR IR missing %q:\n%s", triple, want, ir)
+			}
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm-raw-fpscr.ll", "arm-raw-fpscr.o", ir)
+	}
+}
+
+func TestTranslateARMRawYieldHint(t *testing.T) {
+	src := "TEXT yieldhint(SB),NOSPLIT,$0-0\n\tWORD $0xe320f001\n\tRET\n"
+	file, err := Parse(ArchARM, src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf"} {
+		ir, err := Translate(file, Options{
+			Goarch:       "arm",
+			TargetTriple: triple,
+			Sigs: map[string]FuncSig{
+				"yieldhint": {Name: "yieldhint", Ret: Void},
+			},
+		})
+		if err != nil {
+			t.Fatalf("%s: %v", triple, err)
+		}
+		if !strings.Contains(ir, `.long 0xe320f001`) {
+			t.Fatalf("%s raw YIELD encoding was not preserved:\n%s", triple, ir)
+		}
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc not found")
+		}
+		compileLLVMToObject(t, llc, triple, "arm-raw-yield.ll", "arm-raw-yield.o", ir)
+	}
+}
diff --git a/arm_register_address_encoder_test.go b/arm_register_address_encoder_test.go
new file mode 100644
index 000000000..2b0f435ef
--- /dev/null
+++ b/arm_register_address_encoder_test.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"testing"
+)
+
+func TestARMRegisterAddressGrammarMatchesGoEncoder(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm/asm5.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{AMOVW, C_(RACON|LACON), C_NONE, C_REG, (\d+),[^\n]*C_SBIT\}`).FindAllStringSubmatch(string(source), -1)
+	if len(rows) != 2 {
+		t.Fatalf("Go register-address family has %d rows, want both small and large classes", len(rows))
+	}
+	want := map[string]string{"RACON": "4", "LACON": "34"}
+	for _, row := range rows {
+		if want[row[1]] != row[2] {
+			t.Fatalf("unexpected Go register-address row: %s", row[0])
+		}
+		delete(want, row[1])
+	}
+	if len(want) != 0 {
+		t.Fatalf("missing Go register-address classes: %v", want)
+	}
+}
diff --git a/arm_register_address_model_runtime_test.go b/arm_register_address_model_runtime_test.go
new file mode 100644
index 000000000..a70fcbe65
--- /dev/null
+++ b/arm_register_address_model_runtime_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Pure integer/flag IR can run on the host without dereferencing truncated ARM
+// pointers. This is a semantic model test, separate from the ARM Go/C oracle.
+func TestARMRegisterAddressFlagsModelRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang not found")
+	}
+	var source, declarations, checks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, offset := range []int64{0, 255, -255, 4097, -4097} {
+		for _, condition := range []string{"", ".EQ", ".NE"} {
+			name := fmt.Sprintf("register_address_flags_%d", len(sigs))
+			fmt.Fprintf(&source, "TEXT %s(SB),$0-12\nMOVW input+0(FP),R0\nMOVW $0x13579bdf,R11\nMOVW $0x89abcdef,R1\nCMP R3,R3\nMOVW%s.S $%d(R0),R1\nMOVW $0,R2\nORR.MI $8,R2\nORR.EQ $4,R2\nORR.CS $2,R2\nORR.VS $1,R2\nMOVW R1,result+4(FP)\nMOVW R2,result+8(FP)\nRET\n", name, condition, offset)
+			sigs[name] = FuncSig{Name: name, Args: []LLVMType{I32}, Ret: I64, Frame: FrameLayout{
+				Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				Results: []FrameSlot{{Offset: 4, Type: I64, Index: 0, Field: -1}},
+			}}
+			fmt.Fprintf(&declarations, "extern uint64_t %s(uint32_t);\n", name)
+			for _, input := range []uint32{0, 1, 0xffffffff, 0x7fffffff, 0x80000000} {
+				want := armRegisterAddressExpected(input, 0x13579bdf, offset, true, condition != ".NE", "R0", "R1")
+				packed := uint64(want[1])<<32 | uint64(want[0])
+				fmt.Fprintf(&checks, "if(%s(UINT32_C(%d))!=UINT64_C(%d)) { fprintf(stderr,\"%s input=%d value/NZCV model failed\\n\"); return 1; }\n", name, input, packed, name, input)
+			}
+		}
+	}
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	compileAndRunRuntimeTest(t, llc, clang, "register_address_flags", ir, main)
+}
diff --git a/arm_register_address_test.go b/arm_register_address_test.go
new file mode 100644
index 000000000..daf79282d
--- /dev/null
+++ b/arm_register_address_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARMRegisterAddressCompleteForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT registeraddresses(SB),$0-0\nCMP R0,R0\n")
+	for _, offset := range []int64{0, 255, -255, 4096, -4096, 4097, -4097, 0x12345678, -0x12345678} {
+		for _, suffix := range []string{"", ".S", ".EQ", ".NE.S"} {
+			for _, registers := range [][2]string{{"R0", "R1"}, {"R11", "R1"}, {"R0", "R11"}, {"R13", "R14"}} {
+				fmt.Fprintf(&source, "MOVW%s $%d(%s),%s\n", suffix, offset, registers[0], registers[1])
+			}
+		}
+	}
+	source.WriteString("RET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"registeraddresses": {Name: "registeraddresses", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "register-addresses.ll", "register-addresses.o", ir)
+	}
+}
+
+func TestARMRegisterAddressRejectsNonGoForms(t *testing.T) {
+	var instructions []string
+	for _, op := range []string{"MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		instructions = append(instructions, op+" $4(R0),R1")
+	}
+	for _, suffix := range []string{".P", ".W", ".U", ".S.P"} {
+		instructions = append(instructions, "MOVW"+suffix+" $4(R0),R1")
+	}
+	instructions = append(instructions, "MOVW $4(R0),PC", "MOVW $4(R0),SP", "MOVW $4(PC),R1")
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT invalidaddress(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{"invalidaddress": {Name: "invalidaddress", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("accepted Go-illegal register address: %s", instruction)
+			}
+		})
+	}
+}
+
+// Reference the actual ADD/SUB expansion, not a second translation or an
+// encode/decode roundtrip. Large constants use Go's literal-R11 + ADD row.
+func armRegisterAddressExpected(input, scratch uint32, offset int64, flags, execute bool, base, destination string) [3]uint32 {
+	result, status, newScratch := uint32(0x89abcdef), uint32(6), scratch
+	if destination == "R11" {
+		result = scratch
+	}
+	if !execute {
+		return [3]uint32{result, status, newScratch}
+	}
+	left := input
+	if base == "R11" {
+		left = scratch
+	}
+	// These fixture classes are independently witnessed by Go's object: the
+	// four irregular constants use literal/MVN R11 + ADD, the others ADD/SUB.
+	large := offset == 4097 || offset == -4097 || offset == 0x12345678 || offset == -0x12345678
+	if large {
+		newScratch = uint32(offset)
+		if base == "R11" {
+			left = newScratch
+		}
+	}
+	right := uint32(offset)
+	subtract := !large && offset < 0
+	if subtract {
+		right = uint32(-offset)
+		result = left - right
+	} else {
+		result = left + right
+	}
+	if flags {
+		status = 0
+		if int32(result) < 0 {
+			status |= 8
+		}
+		if result == 0 {
+			status |= 4
+		}
+		if subtract && left >= right || !subtract && uint64(left)+uint64(right) > 0xffffffff {
+			status |= 2
+		}
+		signed := int64(int32(left)) + int64(int32(right))
+		if subtract {
+			signed = int64(int32(left)) - int64(int32(right))
+		}
+		if signed < -2147483648 || signed > 2147483647 {
+			status |= 1
+		}
+	}
+	if destination == "R11" {
+		newScratch = result
+	}
+	return [3]uint32{result, status, newScratch}
+}
+
+func armRegisterAddressFixture() (string, map[string]FuncSig, string, string) {
+	var source, cDecls, cChecks, goDecls, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, offset := range []int64{0, 255, -255, 4096, -4096, 4097, -4097, 0x12345678, -0x12345678} {
+		for _, flags := range []bool{false, true} {
+			for _, condition := range []string{"", ".EQ", ".NE"} {
+				for _, registers := range [][2]string{{"R0", "R1"}, {"R11", "R1"}, {"R0", "R11"}} {
+					name := fmt.Sprintf("register_address_%d", len(sigs))
+					suffix := condition
+					if flags {
+						suffix += ".S"
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),$0-12\nMOVW input+0(FP),R0\nMOVW scratch+4(FP),R11\nMOVW $0x89abcdef,R1\nCMP R3,R3\nMOVW%s $%d(%s),%s\nMOVW out+8(FP),R4\nMOVW %s,0(R4)\nMOVW $0,R2\nORR.MI $8,R2\nORR.EQ $4,R2\nORR.CS $2,R2\nORR.VS $1,R2\nMOVW R2,4(R4)\nMOVW R11,8(R4)\nRET\n", name, suffix, offset, registers[0], registers[1], registers[1])
+					sigs[name] = FuncSig{Name: name, Args: []LLVMType{I32, I32, Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{
+							{Offset: 0, Type: I32, Index: 0, Field: -1},
+							{Offset: 4, Type: I32, Index: 1, Field: -1},
+							{Offset: 8, Type: Ptr, Index: 2, Field: -1},
+						}},
+					}
+					fmt.Fprintf(&cDecls, "extern void %s(uint32_t,uint32_t,uint32_t*);\n", name)
+					fmt.Fprintf(&goDecls, "func %s(input,scratch uint32,out *[3]uint32)\n", name)
+					for _, input := range []uint32{0, 1, 0xffffffff, 0x7fffffff, 0x80000000} {
+						const scratch = uint32(0x13579bdf)
+						want := armRegisterAddressExpected(input, scratch, offset, flags, condition != ".NE", registers[0], registers[1])
+						fmt.Fprintf(&cChecks, "%s(UINT32_C(%d),UINT32_C(%d),out);\nif(out[0]!=UINT32_C(%d)||out[1]!=UINT32_C(%d)||out[2]!=UINT32_C(%d)) { fprintf(stderr,\"%s input=%d got=%%x/%%x/%%x\\n\",out[0],out[1],out[2]); return 1; }\n", name, input, scratch, want[0], want[1], want[2], name, input)
+						fmt.Fprintf(&goChecks, "%s(%d,%d,&out)\nif out != [3]uint32{%d,%d,%d} { panic(\"%s Go oracle\") }\n", name, input, scratch, want[0], want[1], want[2], name)
+					}
+				}
+			}
+		}
+	}
+	cMain := "#include <stdint.h>\n#include <stdio.h>\n" + cDecls.String() + "int main(void) { uint32_t out[3];\n" + cChecks.String() + "return 0;\n}\n"
+	goMain := "package main\n" + goDecls.String() + "func main() { var out [3]uint32\n" + goChecks.String() + "}\n"
+	return source.String(), sigs, cMain, goMain
+}
+
+func TestCrossLinuxRuntimeMatrixARMRegisterAddress(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("actual ARM register-address execution is required by the Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM runtime oracle requires a Linux driver")
+	}
+	for _, tool := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	source, sigs, cMain, goMain := armRegisterAddressFixture()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	source = strings.ReplaceAll(source, "TEXT register_", "TEXT ·register_")
+	for name, data := range map[string]string{
+		"go.mod":  "module armregisteraddressoracle\n\ngo 1.20\n",
+		"main.go": goMain, "oracle_arm.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=2", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM register-address oracle: %v\n%s", err, output)
+	}
+	t.Log("native Go ARM register-address value/NZCV/R11 oracle passed")
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "register_address", triple, ir, cMain,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_register_expression_test.go b/arm_register_expression_test.go
new file mode 100644
index 000000000..d167839f5
--- /dev/null
+++ b/arm_register_expression_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import "testing"
+
+func TestNormalizeARMParenthesizedRegistersMatchesGoPrefixTables(t *testing.T) {
+	for _, tc := range []struct {
+		arch Arch
+		in   string
+		want string
+	}{
+		{ArchARM, "12(R(1))", "12(R1)"},
+		{ArchARM, "R0>>R(1)", "R0>>R1"},
+		{ArchARM, "R(1)<<2(R(3))", "R1<<2(R3)"},
+		{ArchARM, "[R(0)-R(7)]", "[R0-R7]"},
+		{ArchARM, "F(15)", "F15"},
+		{ArchARM, "R(16)", "R(16)"},
+		{ArchARM64, "R(30)", "R30"},
+		{ArchARM64, "R(31)", "R(31)"},
+		{ArchARM64, "F(31), V(31).B16, Z(31).D2, P(15).B, PN(15).D", "F31, V31.B16, Z31.D2, P15.B, PN15.D"},
+		{ArchARM64, "P(16), PN(16)", "P(16), PN(16)"},
+		{ArchARM64, "SPR(269)", "SPR(269)"},
+	} {
+		if got := normalizeARMParenthesizedRegisters(tc.arch, tc.in); got != tc.want {
+			t.Errorf("normalizeARMParenthesizedRegisters(%v, %q) = %q, want %q", tc.arch, tc.in, got, tc.want)
+		}
+	}
+}
+
+func TestParseARMNumericRegisterExpressionsFromOfficialAssemblerCorpus(t *testing.T) {
+	file, err := Parse(ArchARM, "TEXT probe(SB),NOSPLIT,$0-0\nADD R(1)<<R(2), R(3), R(4)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 {
+		t.Fatalf("parsed functions = %#v", file.Funcs)
+	}
+	ins := file.Funcs[0].Instrs[1]
+	if len(ins.Args) != 3 || ins.Args[0].Kind != OpRegShift || ins.Args[0].Reg != "R1" || ins.Args[0].ShiftReg != "R2" || ins.Args[1].Kind != OpReg || ins.Args[1].Reg != "R3" || ins.Args[2].Kind != OpReg || ins.Args[2].Reg != "R4" {
+		t.Fatalf("ADD operands = %#v, want R1<<R2, R3, R4", ins.Args)
+	}
+	if err := ProbeInstruction(ArchARM, "arm", ins); err != nil {
+		t.Fatalf("official ARM ADD register-expression form is not lowerable: %v", err)
+	}
+}
diff --git a/arm_scalar_compare.go b/arm_scalar_compare.go
new file mode 100644
index 000000000..e3157e5a2
--- /dev/null
+++ b/arm_scalar_compare.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Go's CMPF/CMPD are signaling compares followed by VMRS APSR_nzcv,FPSCR.
+// The raw architectural family additionally admits quiet VCMP, odd S registers
+// and D16..D31, and changes only FPSCR until a separate VMRS instruction.
+type armScalarCompareForm struct {
+	lhs, rhs  int
+	bits      int
+	zeroRHS   bool
+	signaling bool
+	toAPSR    bool
+	condition string
+}
+
+func parseARMScalarCompare(op string, ins Instr) (armScalarCompareForm, bool, error) {
+	if op != "CMPF" && op != "CMPD" {
+		return armScalarCompareForm{}, false, nil
+	}
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return armScalarCompareForm{}, true, err
+	}
+	if len(ins.Args) < 1 || len(ins.Args) > 2 {
+		return armScalarCompareForm{}, true, fmt.Errorf("arm %s expects Fsrc or Fsrc1,Fsrc2: %q", op, ins.Raw)
+	}
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg || !isARMFReg(arg.Reg) {
+			return armScalarCompareForm{}, true, fmt.Errorf("arm %s accepts only Go floating registers F0..F15: %q", op, ins.Raw)
+		}
+	}
+	form := armScalarCompareForm{bits: 32, signaling: true, toAPSR: true, zeroRHS: len(ins.Args) == 1}
+	if op == "CMPD" {
+		form.bits = 64
+	}
+	_, form.condition, _, _ = armDecodeOp(string(ins.Op))
+	number := func(arg Operand) int {
+		value, _ := strconv.Atoi(strings.TrimPrefix(strings.ToUpper(strings.TrimSpace(string(arg.Reg))), "F"))
+		if form.bits == 32 {
+			value *= 2 // A Go F register's low S half.
+		}
+		return value
+	}
+	// Go's From operand is Vm; Reg is Vd. A single operand uses Vd,#0.
+	form.lhs = number(ins.Args[len(ins.Args)-1])
+	if !form.zeroRHS {
+		form.rhs = number(ins.Args[0])
+	}
+	return form, true, nil
+}
+
+func (c *armCtx) lowerARMScalarCompare(form armScalarCompareForm) error {
+	if form.condition != "" && form.condition != "AL" {
+		condition := form.condition
+		form.condition = "AL"
+		return c.emitConditionalEffect(condition, func() error {
+			return c.lowerARMScalarCompare(form)
+		})
+	}
+	lhs, err := c.loadARMRawVFPRegValue(form.lhs, form.bits)
+	if err != nil {
+		return err
+	}
+	rhs := ""
+	if !form.zeroRHS {
+		rhs, err = c.loadARMRawVFPRegValue(form.rhs, form.bits)
+		if err != nil {
+			return err
+		}
+	}
+	operation, floatType, suffix := "vcmp", "float", ".f32"
+	if form.signaling {
+		operation = "vcmpe"
+	}
+	if form.bits == 64 {
+		floatType, suffix = "double", ".f64"
+	}
+	first := 0
+	constraints := "t"
+	if form.toAPSR {
+		first = 1
+		constraints = "=r,t"
+	}
+	assembly := fmt.Sprintf("%s%s $%d, #0", operation, suffix, first)
+	arguments := floatType + " " + lhs
+	if !form.zeroRHS {
+		assembly = fmt.Sprintf("%s%s $%d, $%d", operation, suffix, first, first+1)
+		constraints += ",t"
+		arguments += ", " + floatType + " " + rhs
+	}
+	// LLVM's pure fcmp neither observes FZ/DN nor retains cumulative exceptions
+	// for dead flags. One native region performs the compare and, for named Go
+	// forms, captures its FPSCR before any following native FP instruction.
+	// The memory clobber orders this with native VMSR/VMRS and conversions.
+	constraints += ",~{memory}"
+	if form.toAPSR {
+		status := c.newTmp()
+		assembly += "\\0Avmrs $0, fpscr"
+		fmt.Fprintf(c.b, "  %%%s = call i32 asm sideeffect \"%s\", %q(%s)\n", status, assembly, constraints, arguments)
+		c.storeFlagsFromStatus("%" + status)
+	} else {
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(%s)\n", assembly, constraints, arguments)
+	}
+	c.vfpCompareWritten = true
+	return nil
+}
diff --git a/arm_scalar_compare_full_matrix_runtime_linux_test.go b/arm_scalar_compare_full_matrix_runtime_linux_test.go
new file mode 100644
index 000000000..ee57a637e
--- /dev/null
+++ b/arm_scalar_compare_full_matrix_runtime_linux_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"testing"
+)
+
+// Inputs and reference observations remain compact. The original Go program
+// and C driver independently reconstruct and verify the entire D bank; only
+// FPSCR/APSR need per-row reference storage. No software fcmp is the oracle.
+type armCompareMatrixRow struct {
+	function      int
+	lhs, rhs      uint64
+	control, apsr uint32
+	want          [2]uint32
+}
+
+func armCompareMatrixValues(bits int) [][2]uint64 {
+	if bits == 32 {
+		return [][2]uint64{
+			{0, 0x80000000}, {0x80000000, 0},
+			{0x3f800000, 0x40000000}, {0xc0000000, 0xbf800000},
+			{0x7f800000, 0xff800000}, {0xff800000, 0x7f800000},
+			{1, 0}, {0x80000001, 0}, {0x007fffff, 0x00800000},
+			{0x00800000, 0x007fffff}, {0x7fc12345, 0x3f800000},
+			{0x3f800000, 0xffc54321}, {0x7f812345, 0x3f800000},
+			{0x3f800000, 0xff812345}, {0x7fc12345, 0x7f812345},
+		}
+	}
+	return [][2]uint64{
+		{0, 0x8000000000000000}, {0x8000000000000000, 0},
+		{0x3ff0000000000000, 0x4000000000000000}, {0xc000000000000000, 0xbff0000000000000},
+		{0x7ff0000000000000, 0xfff0000000000000}, {0xfff0000000000000, 0x7ff0000000000000},
+		{1, 0}, {0x8000000000000001, 0}, {0x000fffffffffffff, 0x0010000000000000},
+		{0x0010000000000000, 0x000fffffffffffff}, {0x7ff8123456789abc, 0x3ff0000000000000},
+		{0x3ff0000000000000, 0xfff854321abcdef0}, {0x7ff0123456789abc, 0x3ff0000000000000},
+		{0x3ff0000000000000, 0xfff0123456789abc}, {0x7ff8123456789abc, 0x7ff0123456789abc},
+	}
+}
+
+func armCompareMatrixControls() []uint32 {
+	var controls []uint32
+	for _, flush := range []uint32{0, 1 << 24} {
+		for _, defaultNaN := range []uint32{0, 1 << 25} {
+			for _, cumulative := range []uint32{0, 1, 0x80, 0x81} {
+				// Seed unequal NZCV and an unrelated cumulative exception to
+				// distinguish overwrite, preservation and inactive conditions.
+				controls = append(controls, 0xa0000002|flush|defaultNaN|cumulative)
+			}
+		}
+	}
+	return controls
+}
+
+func armCompareMatrixRows(forms []armCompareMatrixForm, scope string) []armCompareMatrixRow {
+	var rows []armCompareMatrixRow
+	for index, form := range forms {
+		values := armCompareMatrixValues(form.bits)
+		controls := armCompareMatrixControls()
+		statuses := []uint32{0x60000000}
+		if scope == "banks" {
+			// The full exceptional/state product is a separate required root.
+			// Rotate finite, subnormal and NaN data through every bank/role.
+			values = [][2]uint64{values[index%len(values)]}
+			controls = []uint32{0xa0000002, 0xa3000083}
+		}
+		if scope == "conditions" {
+			values = [][2]uint64{values[2], values[12]}
+			controls = []uint32{0xa0000002, 0xa3000083}
+			statuses = nil
+			for flags := 0; flags < 16; flags++ {
+				statuses = append(statuses, uint32(flags)<<28)
+			}
+		}
+		for _, values := range values {
+			for _, control := range controls {
+				for _, apsr := range statuses {
+					rows = append(rows, armCompareMatrixRow{function: index, lhs: values[0], rhs: values[1], control: control, apsr: apsr})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func armCompareMatrixPrograms(forms []armCompareMatrixForm, rows []armCompareMatrixRow) (string, string) {
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range forms {
+		fmt.Fprintf(&original, "func matrixCompare%d(input *[65]uint32, output *[69]uint32, apsr uint32)\n", index)
+		fmt.Fprintf(&driver, "extern void matrixCompare%d(uint32_t*,uint32_t*,uint32_t);\n", index)
+	}
+	original.WriteString("var functions = [...]func(*[65]uint32,*[69]uint32,uint32){\n")
+	driver.WriteString("static void (*functions[])(uint32_t*,uint32_t*,uint32_t)={\n")
+	for index := range forms {
+		fmt.Fprintf(&original, "matrixCompare%d,\n", index)
+		fmt.Fprintf(&driver, "matrixCompare%d,\n", index)
+	}
+	original.WriteString("}\nvar forms = [...]struct { bits, lhs, rhs int; zero bool }{\n")
+	driver.WriteString("};\nstatic const struct { unsigned bits,lhs,rhs,zero; } forms[]={\n")
+	for _, form := range forms {
+		zero := 0
+		if form.zero {
+			zero = 1
+		}
+		fmt.Fprintf(&original, "{%d,%d,%d,%t},\n", form.bits, form.lhs, form.rhs, form.zero)
+		fmt.Fprintf(&driver, "{%d,%d,%d,%d},\n", form.bits, form.lhs, form.rhs, zero)
+	}
+	original.WriteString("}\nvar rows = [...]struct { function int; lhs,rhs uint64; control,apsr uint32 }{\n")
+	driver.WriteString("};\nstatic const struct { unsigned function; uint64_t lhs,rhs; uint32_t control,apsr,want[2]; } rows[]={\n")
+	for _, row := range rows {
+		fmt.Fprintf(&original, "{%d,%#x,%#x,%#x,%#x},\n", row.function, row.lhs, row.rhs, row.control, row.apsr)
+		fmt.Fprintf(&driver, "{%d,UINT64_C(%#x),UINT64_C(%#x),%#x,%#x,{%#x,%#x}},\n", row.function, row.lhs, row.rhs, row.control, row.apsr, row.want[0], row.want[1])
+	}
+	original.WriteString(`}
+func put(input *[65]uint32, bits, register int, value uint64) {
+    if bits == 64 {
+        input[register*2],input[register*2+1] = uint32(value),uint32(value>>32)
+    } else {
+        input[register] = uint32(value)
+    }
+}
+func main() {
+    for index,row := range rows {
+        form := forms[row.function]
+        var input [65]uint32
+        for word:=0;word<64;word++ { input[word]=0x98760000+uint32(word)*0x0101 }
+        put(&input,form.bits,form.lhs,row.lhs)
+        if !form.zero && form.lhs!=form.rhs { put(&input,form.bits,form.rhs,row.rhs) }
+        input[64]=row.control
+        before:=input
+        var output [69]uint32
+        for word:=range output { output[word]=0xa5a5a5a5 }
+        output[65],output[66],output[67],output[68]=0x12345678,0x87654321,0xfedcba98,0x10203040
+        functions[row.function](&input,&output,row.apsr)
+        if input!=before { panic(fmt.Sprintf("original input changed at row %d",index)) }
+        for word:=0;word<64;word++ {
+            if output[word]!=input[word] {
+                panic(fmt.Sprintf("original row %d bank word %d got %08x want %08x",index,word,output[word],input[word]))
+            }
+        }
+        if output[66]!=0x87654321 || output[67]!=0xfedcba98 || output[68]!=0x10203040 {
+            panic(fmt.Sprintf("original output canary changed at row %d",index))
+        }
+        fmt.Printf("%08x %08x\n",output[64],output[65])
+    }
+}
+`)
+	driver.WriteString(`};
+static void put(uint32_t *input,unsigned bits,unsigned reg,uint64_t value) {
+    if(bits==64) { input[reg*2]=(uint32_t)value; input[reg*2+1]=(uint32_t)(value>>32); }
+    else input[reg]=(uint32_t)value;
+}
+int main(void) {
+    unsigned failures=0;
+    for(unsigned row=0;row<sizeof(rows)/sizeof(rows[0]);row++) {
+        unsigned function=rows[row].function;
+        uint32_t input[65],before[65],output[69];
+        for(unsigned word=0;word<64;word++) input[word]=0x98760000+word*0x0101;
+        put(input,forms[function].bits,forms[function].lhs,rows[row].lhs);
+        if(!forms[function].zero && forms[function].lhs!=forms[function].rhs)
+            put(input,forms[function].bits,forms[function].rhs,rows[row].rhs);
+        input[64]=rows[row].control;
+        for(unsigned word=0;word<65;word++) before[word]=input[word];
+        for(unsigned word=0;word<69;word++) output[word]=0xa5a5a5a5;
+        output[65]=0x12345678; output[66]=0x87654321;
+        output[67]=0xfedcba98; output[68]=0x10203040;
+        functions[function](input,output,rows[row].apsr);
+        for(unsigned word=0;word<65;word++) {
+            if(input[word]!=before[word]) {
+                if(failures<16) fprintf(stderr,"row %u input word %u changed\n",row,word);
+                failures++;
+            }
+        }
+        for(unsigned word=0;word<69;word++) {
+            uint32_t expected=word<64?before[word]:word<66?rows[row].want[word-64]:
+                word==66?0x87654321:word==67?0xfedcba98:0x10203040;
+            if(output[word]!=expected) {
+                if(failures<16) fprintf(stderr,"row %u function %u word %u got %08x want %08x\n",
+                    row,function,word,output[word],expected);
+                failures++;
+            }
+        }
+    }
+    printf("ARM_COMPARE_MATRIX rows=%zu failures=%u\n",sizeof(rows)/sizeof(rows[0]),failures);
+    return failures!=0;
+}
+`)
+	return original.String(), driver.String()
+}
+
+func runARMCompareMatrixBatch(t *testing.T, forms []armCompareMatrixForm, scope string) {
+	t.Helper()
+	llc := requireARMScalarRuntime(t)
+	source, sigs := armCompareMatrixSource(forms, true)
+	rows := armCompareMatrixRows(forms, scope)
+	original, _ := armCompareMatrixPrograms(forms, rows)
+	observed := armConversionGoObservations(t, source, original)
+	reader := strings.NewReader(string(observed))
+	for index := range rows {
+		if _, err := fmt.Fscanf(reader, "%x %x\n", &rows[index].want[0], &rows[index].want[1]); err != nil {
+			t.Fatalf("original Go row %d of %d: %v\n%s", index, len(rows), err, observed)
+		}
+		form := forms[rows[index].function]
+		if !form.live && rows[index].want[1] != 0x12345678 {
+			t.Fatalf("dead APSR observation was unexpectedly written at original row %d", index)
+		}
+	}
+	if extra, err := io.ReadAll(reader); err != nil || strings.TrimSpace(string(extra)) != "" {
+		t.Fatalf("original Go returned extra/invalid observations: %q: %v", extra, err)
+	}
+	t.Logf("original Go: %d rows with all 32 D banks, input and output canaries", len(rows))
+	_, driver := armCompareMatrixPrograms(forms, rows)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := armCompareMatrixTranslate(t, file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs}, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+							"arm_compare_matrix", "armv7-unknown-linux-gnueabihf", variant.ir, driver,
+							[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMScalarCompareFullMatrix(t *testing.T) {
+	requireARMScalarRuntime(t)
+	for _, group := range []struct {
+		name  string
+		forms []armCompareMatrixForm
+	}{
+		{"banks", armCompareMatrixBanks()},
+		{"states", armCompareMatrixStates()},
+		{"conditions", armCompareMatrixConditions()},
+	} {
+		for first := 0; first < len(group.forms); first += 32 {
+			last := first + 32
+			if last > len(group.forms) {
+				last = len(group.forms)
+			}
+			t.Run(fmt.Sprintf("%s/%03d_%03d", group.name, first, last), func(t *testing.T) {
+				runARMCompareMatrixBatch(t, group.forms[first:last], group.name)
+			})
+		}
+	}
+}
diff --git a/arm_scalar_compare_full_matrix_test.go b/arm_scalar_compare_full_matrix_test.go
new file mode 100644
index 000000000..5efc7274f
--- /dev/null
+++ b/arm_scalar_compare_full_matrix_test.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The fixture encoding is independent of the production decoder. ARM ARM
+// DDI0406C.c VCMP/VCMPE A1 has E at bit 7 and sz at bit 8. Go asm5 types
+// 82/83 select E=1 and append VMRS APSR_nzcv,FPSCR, with the same condition.
+type armCompareMatrixForm struct {
+	bits, lhs, rhs int
+	kind           string
+	zero, live     bool
+	condition      string
+}
+
+func (form armCompareMatrixForm) word() uint32 {
+	word := uint32(0xeeb40a40)
+	if form.kind == "signaling" || form.kind == "named" {
+		word |= 1 << 7
+	}
+	if form.bits == 64 {
+		word |= 1 << 8
+		word |= uint32(form.lhs%16)<<12 | uint32(form.lhs/16)<<22
+		if !form.zero {
+			word |= uint32(form.rhs%16) | uint32(form.rhs/16)<<5
+		}
+	} else {
+		word |= uint32(form.lhs/2)<<12 | uint32(form.lhs%2)<<22
+		if !form.zero {
+			word |= uint32(form.rhs/2) | uint32(form.rhs%2)<<5
+		}
+	}
+	if form.zero {
+		word |= 1 << 16
+	}
+	return word
+}
+
+func (form armCompareMatrixForm) instruction() string {
+	if form.kind != "named" {
+		return fmt.Sprintf("WORD $%#x", form.word())
+	}
+	op, lhs, rhs := "CMPD", form.lhs, form.rhs
+	if form.bits == 32 {
+		op, lhs, rhs = "CMPF", lhs/2, rhs/2
+	}
+	if form.condition != "" {
+		op += "." + form.condition
+	}
+	if form.zero {
+		return fmt.Sprintf("%s F%d", op, lhs)
+	}
+	return fmt.Sprintf("%s F%d,F%d", op, rhs, lhs)
+}
+
+func armCompareMatrixBanks() []armCompareMatrixForm {
+	var forms []armCompareMatrixForm
+	for _, bits := range []int{32, 64} {
+		for _, kind := range []string{"named", "quiet", "signaling"} {
+			banks := 32
+			if kind == "named" {
+				banks = 16
+			}
+			for bank := 0; bank < banks; bank++ {
+				lhs, rhs := bank, (bank+7)%banks
+				if kind == "named" && bits == 32 {
+					lhs, rhs = lhs*2, rhs*2
+				}
+				for _, shape := range []string{"zero", "register", "alias"} {
+					form := armCompareMatrixForm{bits: bits, kind: kind, lhs: lhs, rhs: rhs, zero: shape == "zero", live: true}
+					if shape == "alias" {
+						form.rhs = form.lhs
+					}
+					forms = append(forms, form)
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func armCompareMatrixStates() []armCompareMatrixForm {
+	var forms []armCompareMatrixForm
+	for _, bits := range []int{32, 64} {
+		for _, kind := range []string{"named", "quiet", "signaling"} {
+			for _, live := range []bool{false, true} {
+				for _, shape := range []string{"zero", "register", "alias"} {
+					form := armCompareMatrixForm{bits: bits, kind: kind, lhs: 0, rhs: 2, zero: shape == "zero", live: live}
+					if shape == "alias" {
+						form.rhs = form.lhs
+					}
+					forms = append(forms, form)
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func armCompareMatrixConditions() []armCompareMatrixForm {
+	var forms []armCompareMatrixForm
+	for _, bits := range []int{32, 64} {
+		for _, condition := range []string{"AL", "EQ", "NE", "CS", "HS", "CC", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE"} {
+			for _, zero := range []bool{false, true} {
+				forms = append(forms, armCompareMatrixForm{bits: bits, kind: "named", lhs: 0, rhs: 2, zero: zero, live: true, condition: condition})
+			}
+		}
+	}
+	return forms
+}
+
+// Only the runtime harness loads/stores the complete physical D bank. The
+// smaller object matrix exercises exactly the same compare and source proof.
+func armCompareMatrixSource(forms []armCompareMatrixForm, fullBank bool) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, form := range forms {
+		name := fmt.Sprintf("matrixCompare%d", index)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-12\nMOVW input+0(FP),R0\nMOVW output+4(FP),R1\n", name)
+		if fullBank {
+			for bank := 0; bank < 32; bank++ {
+				word := uint32(0xed900b00 | (bank%16)<<12 | (bank/16)<<22 | bank*2)
+				fmt.Fprintf(&source, "WORD $%#x\n", word)
+			}
+		}
+		source.WriteString("WORD $0xeef14a10\nMOVW 256(R0),R3\nWORD $0xeee13a10\n")
+		if form.kind == "named" || form.live {
+			// A typed parameter is an existing whole-value CPSR witness. This
+			// does not grant an unproved pointer load native status authority.
+			source.WriteString("MOVW status+8(FP),R2\nMOVW R2,CPSR\n")
+		}
+		source.WriteString(form.instruction() + "\n")
+		if form.kind != "named" && form.live {
+			source.WriteString("WORD $0xeef1fa10\n")
+		}
+		if form.live {
+			source.WriteString("MOVW CPSR,R2\nAND $0xf0000000,R2\nMOVW R2,260(R1)\n")
+		}
+		source.WriteString("WORD $0xeef13a10\nWORD $0xeee14a10\nMOVW R3,256(R1)\n")
+		if fullBank {
+			for bank := 0; bank < 32; bank++ {
+				word := uint32(0xed810b00 | (bank%16)<<12 | (bank/16)<<22 | bank*2)
+				fmt.Fprintf(&source, "WORD $%#x\n", word)
+			}
+		}
+		source.WriteString("RET\n")
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I32}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 8, Type: I32, Index: 2, Field: -1},
+			}},
+		}
+	}
+	return source.String(), sigs
+}
+
+func armCompareMatrixTranslate(t *testing.T, file *File, options Options, api string) (string, error) {
+	t.Helper()
+	if api == "Translate" {
+		return Translate(file, options)
+	}
+	if api == "TranslateModule" {
+		module, err := TranslateModule(file, options)
+		if err != nil {
+			return "", err
+		}
+		defer module.Dispose()
+		return module.String(), nil
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, options)
+	if err != nil {
+		return "", err
+	}
+	defer module.Dispose()
+	return module.String(), nil
+}
+
+func TestARMScalarCompareFullMatrixObjects(t *testing.T) {
+	forms := armCompareMatrixBanks()
+	if len(forms) != 480 {
+		t.Fatalf("incomplete bank/alias matrix: %d", len(forms))
+	}
+	forms = append(forms, armCompareMatrixConditions()...)
+	source, sigs := armCompareMatrixSource(forms, false)
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := armCompareMatrixTranslate(t, file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs}, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, triple, "arm-compare-matrix.ll", "arm-compare-matrix.o", ir)
+			})
+		}
+	}
+}
+
+func TestARMScalarCompareFullMatrixNativeEffects(t *testing.T) {
+	forms := armCompareMatrixStates()
+	source, sigs := armCompareMatrixSource(forms, false)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := armCompareMatrixTranslate(t, file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs}, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+				if count := strings.Count(variant.ir, `asm sideeffect "vcmp`); count != len(forms) {
+					t.Errorf("%s native compare effects: got %d want %d (including dead APSR)", variant.name, count, len(forms))
+				}
+				if strings.Contains(variant.ir, " = fcmp ") {
+					t.Errorf("%s substitutes a pure comparison for native FPSCR effects", variant.name)
+				}
+			}
+		})
+	}
+}
+
+func TestARMScalarCompareFullMatrixClosedRawFlagsBoundary(t *testing.T) {
+	for _, bits := range []int{32, 64} {
+		for _, kind := range []string{"quiet", "signaling"} {
+			form := armCompareMatrixForm{bits: bits, kind: kind, lhs: 1, rhs: 31}
+			for _, sequence := range []string{
+				fmt.Sprintf("WORD $%#x\nMOVW CPSR,R2", form.word()),
+				fmt.Sprintf("WORD $%#x\nMOVW $0,R3\nWORD $0xeef1fa10\nMOVW CPSR,R2", form.word()),
+				fmt.Sprintf("WORD $%#x\nWORD $0x0ef1fa10\nMOVW CPSR,R2", form.word()&0x0fffffff),
+			} {
+				source := "TEXT boundary(SB),4,$0-0\nMOVW $0x60000000,R2\nMOVW R2,CPSR\n" + sequence + "\nRET\n"
+				requireARMGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					ir, err := armCompareMatrixTranslate(t, file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"boundary": {Name: "boundary", Ret: Void}}}, api)
+					if err == nil || ir != "" || !strings.Contains(err.Error(), "closed unconditional compare/VMRS") {
+						t.Fatalf("%s silently widened raw flags authority: %s: %v", api, sequence, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARMScalarCompareFullMatrixRawPredicateRequiresAllPaths(t *testing.T) {
+	for name, prefix := range map[string]string{
+		"bypassed_writer":   "B compare\nMOVW $0,R0\nCMP R0,R0\ncompare:\n",
+		"call_kills_writer": "MOVW $0,R0\nCMP R0,R0\nCALL helper(SB)\n",
+		"one_path_calls":    "MOVW $0,R0\nCMP R0,R0\nBEQ compare\nCALL helper(SB)\ncompare:\n",
+	} {
+		for _, word := range []uint32{0x0eb50a40, 0x1eb50ac0, 0x0eb50b40, 0x1eb50bc0} {
+			t.Run(fmt.Sprintf("%s/%08x", name, word), func(t *testing.T) {
+				// No following modeled condition/CPSR read can accidentally
+				// trigger the status proof on behalf of this raw predicate.
+				source := "TEXT helper(SB),4,$0-0\nRET\nTEXT boundary(SB),4,$0-0\n" + prefix + fmt.Sprintf("WORD $%#x\nRET\n", word)
+				requireARMGoAssemblerResult(t, source, true)
+				file, err := Parse(ArchARM, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs := map[string]FuncSig{"boundary": {Name: "boundary", Ret: Void}, "helper": {Name: "helper", Ret: Void}}
+				for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					ir, err := armCompareMatrixTranslate(t, file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs}, api)
+					if err == nil || ir != "" {
+						t.Errorf("%s admitted raw predicate without all-path status authority: %v", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/arm_scalar_compare_matrix_consumers_test.go b/arm_scalar_compare_matrix_consumers_test.go
new file mode 100644
index 000000000..44c341dfb
--- /dev/null
+++ b/arm_scalar_compare_matrix_consumers_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestARMScalarCompareTypedGoMatrixObjects(t *testing.T) {
+	forms := append(armCompareMatrixBanks(), armCompareMatrixConditions()...)
+	if len(forms) != 548 {
+		t.Fatalf("incomplete typed Go compare forms: %d", len(forms))
+	}
+	source, _ := armCompareMatrixSource(forms, false)
+	source = strings.ReplaceAll(source, "TEXT ", "TEXT ·")
+	var declarations strings.Builder
+	declarations.WriteString("package compare\n")
+	for index := range forms {
+		fmt.Fprintf(&declarations, "func matrixCompare%d(input *[65]uint32, output *[69]uint32, status uint32)\n", index)
+	}
+	pkg := mustGoPackage(t, "example.com/compare", declarations.String())
+	requireARMGoAssemblerResult(t, source, true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, target := range []struct{ os, triple string }{
+		{"linux", "armv5te-unknown-linux-gnueabi"},
+		{"linux", "armv6-unknown-linux-gnueabihf"},
+		{"linux", "armv7-unknown-linux-gnueabihf"},
+		{"windows", "thumbv7-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: target.os, GOARCH: "arm", TargetTriple: target.triple,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := translated.Module.String()
+			translated.Module.Dispose()
+			if len(translated.Functions) != len(forms) || len(translated.Signatures) != len(forms) {
+				t.Fatalf("typed declarations lost compare forms: functions=%d signatures=%d", len(translated.Functions), len(translated.Signatures))
+			}
+			if count := strings.Count(ir, `asm sideeffect "vcmp`); count != len(forms) {
+				t.Fatalf("typed Go route lost native effects: got %d want %d", count, len(forms))
+			}
+			compileLLVMToObject(t, llc, target.triple, "arm-compare-typed-go.ll", "arm-compare-typed-go.o", ir)
+		})
+	}
+}
+
+func TestARMScalarCompareRequiredRuntimeOwner(t *testing.T) {
+	const file = "arm_scalar_compare_full_matrix_runtime_linux_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "arm64"}, {"linux", "arm"},
+		{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"}, {"js", "wasm"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", file)
+		if err != nil || selected != (target.os == "linux") {
+			t.Fatal("required compare runtime source selection", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), file, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]map[string]bool{
+		"TestCrossLinuxRuntimeMatrixARMScalarCompareFullMatrix": {
+			"requireARMScalarRuntime": false,
+			"armCompareMatrixBanks":   false, "armCompareMatrixStates": false,
+			"armCompareMatrixConditions": false, "runARMCompareMatrixBatch": false,
+		},
+		"runARMCompareMatrixBatch": {
+			"requireARMScalarRuntime": false, "armConversionGoObservations": false,
+			"armCompareMatrixTranslate": false, "armFloatEffectOptimizedIR": false,
+			"compileAndRunRuntimeTestWithCompiler": false,
+		},
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		required, found := want[function.Name.Name]
+		if !found {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			if selector, ok := call.Fun.(*ast.SelectorExpr); ok && strings.HasPrefix(selector.Sel.Name, "Skip") {
+				t.Errorf("required runtime owner contains a local skip: %s", function.Name.Name)
+			}
+			if name, ok := call.Fun.(*ast.Ident); ok {
+				if _, found := required[name.Name]; found {
+					required[name.Name] = true
+				}
+			}
+			return true
+		})
+	}
+	for function, required := range want {
+		for name, found := range required {
+			if !found {
+				t.Errorf("required runtime owner %s lost %s", function, name)
+			}
+		}
+	}
+	workflow, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil || !strings.Contains(string(workflow), "-ci-selector '^(TestCrossLinuxRuntimeMatrix|") || !strings.Contains(string(workflow), "PLAN9ASM_CROSS_EXEC: '1'") {
+		t.Fatal("CI no longer selects and enables the mandatory native runtime owner", err)
+	}
+}
diff --git a/arm_scalar_compare_native_test.go b/arm_scalar_compare_native_test.go
new file mode 100644
index 000000000..0b4e0eeb4
--- /dev/null
+++ b/arm_scalar_compare_native_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARMScalarCompareNativeEffects(t *testing.T) {
+	for _, body := range []string{"CMPF F0", "CMPD F0,F1", "WORD $0xeeb50a40", "WORD $0xeeb50ac0"} {
+		source := "TEXT conversion(SB),4,$0-0\nMOVD $1.5,F0\nMOVD $2.5,F1\n" + body + "\nRET\n"
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+			Sigs: map[string]FuncSig{"conversion": {Name: "conversion", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		operation := "vcmpe."
+		if body == "WORD $0xeeb50a40" {
+			operation = "vcmp."
+		}
+		if strings.Contains(ir, "fcmp ") || !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, operation) {
+			t.Errorf("%s must retain the native signaling/FPSCR effect:\n%s", body, ir)
+		}
+	}
+}
+
+func TestARMScalarCompareNativeTargetBoundary(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, body := range []string{"CMPF F0", "CMPD F0,F1", "WORD $0xeeb50a40", "WORD $0xeeb50bc0"} {
+			for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "armeb-unknown-linux-gnueabi", "armanything-unknown-linux-gnu"} {
+				source := "TEXT conversion(SB),4,$0-0\n" + body + "\nRET\n"
+				if err := armWordFloatBoundaryAPI(t, api, source, triple); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s %s %q needs native FPSCR target: %v", api, body, triple, err)
+				}
+			}
+			for _, invalid := range []string{"CMPF R0", "CMPD.S F0", "WORD $0xffffffff"} {
+				for _, dead := range []string{"", "RET\n"} {
+					source := "TEXT conversion(SB),4,$0-0\n" + body + "\n" + dead + invalid + "\nRET\n"
+					if err := armWordFloatBoundaryAPI(t, api, source, ""); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+						t.Errorf("%s invalid source cannot become target Context: %v", api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestARMScalarCompareRawDefersAPSRUntilVMRS(t *testing.T) {
+	file, err := Parse(ArchARM, "TEXT conversion(SB),4,$0-0\nWORD $0xeeb50ac0\nWORD $0xeef1fa10\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, output := newARMCtxWithFuncForTest(t, file.Funcs[0], FuncSig{Name: "conversion", Ret: Void}, nil)
+	output.Reset()
+	compare := Instr{Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: 0xeeb50ac0}}}
+	if matched, err := ctx.lowerRawWord(compare); !matched || err != nil {
+		t.Fatalf("raw compare: matched=%t err=%v", matched, err)
+	}
+	if ctx.flagsWritten || strings.Contains(output.String(), "store i1") || strings.Contains(output.String(), "vmrs") {
+		t.Fatalf("VCMPE changes FPSCR, not APSR: %s", output.String())
+	}
+	form, ok := decodeARMRawVFPStatusTransfer(0xeef1fa10)
+	if !ok {
+		t.Fatal("VMRS APSR encoding not decoded")
+	}
+	if err := ctx.lowerRawVFPStatusTransfer(form); err != nil {
+		t.Fatal(err)
+	}
+	if !ctx.flagsWritten || strings.Count(output.String(), "store i1") != 4 || !strings.Contains(output.String(), "vmrs $0, fpscr") {
+		t.Fatalf("VMRS must copy all four native flags: %s", output.String())
+	}
+}
+
+func TestARMScalarCompareRawPredicateDoesNotInventEntryAPSR(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, body := range []string{"WORD $0x0eb50a40", "WORD $0x1eb50ac0", "WORD $0x0eb50b40", "WORD $0x1eb50bc0"} {
+			source := "TEXT conversion(SB),4,$0-0\n" + body + "\nRET\n"
+			if err := armWordFloatBoundaryAPI(t, api, source, "armv7-unknown-linux-gnueabihf"); err == nil {
+				t.Errorf("%s raw predicate must not use synthetic entry flags: %s", api, body)
+			}
+		}
+	}
+}
diff --git a/arm_scalar_compare_status_runtime_linux_test.go b/arm_scalar_compare_status_runtime_linux_test.go
new file mode 100644
index 000000000..094edd06c
--- /dev/null
+++ b/arm_scalar_compare_status_runtime_linux_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These first-party witnesses distinguish Go's named VCMPE+VMRS expansion
+// from both raw quiet VCMP and signaling VCMPE. FPSCR is observed even when
+// source APSR results are dead; neither LLVM fcmp nor a virtual NZCV result
+// establishes the native cumulative-exception or FPSCR condition effects.
+func TestCrossLinuxRuntimeMatrixARMScalarCompareNativeStatus(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	var source, original, driver strings.Builder
+	sigs := make(map[string]FuncSig)
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	var originalCalls, driverCalls strings.Builder
+	count := 0
+	for _, bits := range []int{32, 64} {
+		for _, kind := range []string{"named", "quiet", "signaling"} {
+			for _, signalingNaN := range []bool{false, true} {
+				for _, live := range []bool{false, true} {
+					name := fmt.Sprintf("compare%d", count)
+					count++
+					low, high := uint32(0x7fc12345), uint32(0x87654321)
+					if signalingNaN {
+						low = 0x7f812345
+					}
+					if bits == 64 {
+						low, high = 0x12345678, 0x7ff81234
+						if signalingNaN {
+							high = 0x7ff01234
+						}
+					}
+					status := uint32(0x30000000) // Unordered FPSCR.NZCV.
+					if kind != "quiet" || signalingNaN {
+						status |= 1 // IOC: VCMPE any NaN, VCMP only signaling NaN.
+					}
+					apsr := uint32(0x12345678)
+					if live {
+						apsr = 0x30000000
+					}
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-4\nMOVW out+0(FP),R0\nMOVD (R0),F0\n", name)
+					source.WriteString("WORD $0xeef14a10\nMOVW $0,R3\nWORD $0xeee13a10\n")
+					if kind == "named" {
+						op := "CMPF"
+						if bits == 64 {
+							op = "CMPD"
+						}
+						fmt.Fprintf(&source, "%s F0\n", op)
+					} else {
+						word := uint32(0xeeb50a40) // VCMP.F32 S0,#0.
+						if bits == 64 {
+							word |= 1 << 8
+						}
+						if kind == "signaling" {
+							word |= 1 << 7
+						}
+						fmt.Fprintf(&source, "WORD $%#x\n", word)
+						if live {
+							source.WriteString("WORD $0xeef1fa10\n")
+						}
+					}
+					if live {
+						source.WriteString("MOVW CPSR,R2\nAND $0xf0000000,R2\nMOVW R2,12(R0)\n")
+					}
+					source.WriteString("WORD $0xeef13a10\nWORD $0xeee14a10\nMOVW R3,8(R0)\nRET\n")
+					sigs[name] = FuncSig{
+						Name: name, Args: []LLVMType{Ptr}, Ret: Void,
+						Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+					}
+					fmt.Fprintf(&original, "func %s(out *[5]uint32)\n", name)
+					fmt.Fprintf(&driver, "extern void %s(uint32_t*);\n", name)
+					label := fmt.Sprintf("%s bits=%d %s sNaN=%t live=%t", name, bits, kind, signalingNaN, live)
+					fmt.Fprintf(&originalCalls, "{ out := [5]uint32{%#x,%#x,0x98765432,0x12345678,0xabcdef01}\n%s(&out)\n", low, high, name)
+					fmt.Fprintf(&originalCalls, "want := [5]uint32{%#x,%#x,%#x,%#x,0xabcdef01}\nif out != want { panic(fmt.Sprintf(%q,out,want)) } }\n", low, high, status, apsr, label+": got %x want %x")
+					fmt.Fprintf(&driverCalls, "{ uint32_t out[5]={%#x,%#x,0x98765432,0x12345678,0xabcdef01};\n%s(out);\n", low, high, name)
+					fmt.Fprintf(&driverCalls, "uint32_t want[5]={%#x,%#x,%#x,%#x,0xabcdef01};\n", low, high, status, apsr)
+					fmt.Fprintf(&driverCalls, "for(unsigned i=0;i<5;i++) { if(out[i]!=want[i]) { fprintf(stderr,%q,i,out[i],want[i]); failures++; } } }\n", label+" word %u: got %08x want %08x\n")
+				}
+			}
+		}
+	}
+	marker := fmt.Sprintf("ORIGINAL_ARM_SCALAR_COMPARE_STATUS %d", count)
+	fmt.Fprintf(&original, "func main() {\n%s\nfmt.Println(%q)\n}\n", originalCalls.String(), marker)
+	fmt.Fprintf(&driver, "int main(void) { unsigned failures=0;\n%s\nreturn failures != 0; }\n", driverCalls.String())
+	if output := armConversionGoObservations(t, source.String(), original.String()); string(output) != marker+"\n" {
+		t.Fatalf("original Go comparison observations:\n%s", output)
+	}
+	t.Log(marker)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"none", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR_%s/backend_O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+					"arm_scalar_compare_status", "armv7-unknown-linux-gnueabihf", variant.ir, driver.String(),
+					[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+			})
+		}
+	}
+}
diff --git a/arm_shifter.go b/arm_shifter.go
new file mode 100644
index 000000000..2343a80bb
--- /dev/null
+++ b/arm_shifter.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import "fmt"
+
+// Go asm5 types 3 and 23 use the ARM shifter operand, but oplook canonicalizes
+// every textual immediate-zero right shift to LSL #0 (issue 64715). Register
+// amounts use their low byte and saturate, except ROR. Neither rule is a raw
+// LLVM shift. Explicit SRL/SRA $0 are also canonicalized; $32 is not, so its
+// masked imm5 zero still means #32.
+func validateARMShifter(source Operand) error {
+	if source.Kind != OpRegShift || !isARMGeneralReg(source.Reg) {
+		return fmt.Errorf("ARM shifter requires a general register: %s", source.String())
+	}
+	switch source.ShiftOp {
+	case ShiftLeft, ShiftRight, ShiftArith, ShiftRotate:
+	default:
+		return fmt.Errorf("ARM shifter has invalid operation: %s", source.String())
+	}
+	if source.ShiftReg != "" {
+		if !isARMGeneralReg(source.ShiftReg) {
+			return fmt.Errorf("ARM shifter count requires a general register: %s", source.String())
+		}
+	} else if source.ShiftAmount < 0 || source.ShiftAmount > 31 {
+		return fmt.Errorf("ARM shifter immediate must fit Go's imm5 grammar: %s", source.String())
+	}
+	return nil
+}
+
+func (c *armCtx) evalARMShifter(source Operand) (result, carry string, err error) {
+	if err := validateARMShifter(source); err != nil {
+		return "", "", err
+	}
+	value, err := c.loadReg(source.Reg)
+	if err != nil {
+		return "", "", err
+	}
+	op := map[ShiftOp]string{ShiftLeft: "SLL", ShiftRight: "SRL", ShiftArith: "SRA", ShiftRotate: "ROR"}[source.ShiftOp]
+	if source.ShiftReg == "" {
+		if source.ShiftAmount == 0 {
+			return value, c.loadFlagValue(c.flagsCSlot), nil
+		}
+		result, carry = c.emitARMImmediateShift(op, value, uint32(source.ShiftAmount))
+	} else {
+		amount, loadErr := c.loadReg(source.ShiftReg)
+		if loadErr != nil {
+			return "", "", loadErr
+		}
+		result, carry = c.emitARMRegisterShift(op, value, amount)
+	}
+	return result, carry, nil
+}
+
+// Capture the shifter carry before writing an aliased destination. Re-reading
+// the shifted register afterwards would silently use the new register value.
+func (c *armCtx) evalARMLogicalOperand(op string, source Operand) (value, carry string, err error) {
+	if source.Kind == OpRegShift {
+		return c.evalARMShifter(source)
+	}
+	value, err = c.eval32(source, false)
+	return value, armLogicalImmediateCarry(op, source), err
+}
+
+func (c *armCtx) emitARMRotate(value, amount string) string {
+	tmp := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call i32 @llvm.fshr.i32(i32 %s, i32 %s, i32 %s)\n", tmp, value, value, amount)
+	return "%" + tmp
+}
+
+func armShifterDefinesCarry(source Operand) bool {
+	return source.Kind == OpRegShift && source.ShiftReg == "" && source.ShiftAmount != 0
+}
+
+func validateARMDataProcessing(op string, ins Instr, setFlags bool) error {
+	for _, suffix := range armInstructionSuffixes(ins) {
+		if suffix != "" && suffix != "S" && !armCondCodes[suffix] {
+			return fmt.Errorf("ARM %s data-processing suffix is outside Go asm5: %s", op, ins.Raw)
+		}
+	}
+	wantMin, wantMax := 2, 3
+	if op == "MOVW" || op == "MVN" || op == "TST" || op == "TEQ" || op == "CMP" || op == "CMN" {
+		wantMax = 2
+	}
+	if len(ins.Args) < wantMin || len(ins.Args) > wantMax {
+		return fmt.Errorf("ARM %s data-processing operand count is outside Go asm5: %s", op, ins.Raw)
+	}
+	source := ins.Args[0]
+	if source.Kind != OpImm && !(source.Kind == OpReg && isARMGeneralReg(source.Reg)) && source.Kind != OpRegShift {
+		return fmt.Errorf("ARM %s data-processing source must be an immediate/register/shifter: %s", op, ins.Raw)
+	}
+	if source.Kind == OpRegShift {
+		if err := validateARMShifter(source); err != nil {
+			return err
+		}
+	}
+	for _, operand := range ins.Args[1:] {
+		if operand.Kind != OpReg || !isARMGeneralReg(operand.Reg) {
+			return fmt.Errorf("ARM %s data-processing input/destination must be a general register: %s", op, ins.Raw)
+		}
+	}
+	if (op == "MOVW" || op == "MVN") && setFlags && source.Kind == OpImm {
+		return fmt.Errorf("ARM %s immediate .S is absent from Go asm5: %s", op, ins.Raw)
+	}
+	if op == "CMP" || op == "CMN" || op == "TST" || op == "TEQ" {
+		return armRequireConditionOnlySuffix(ins)
+	}
+	return nil
+}
diff --git a/arm_shifter_runtime_test.go b/arm_shifter_runtime_test.go
new file mode 100644
index 000000000..4c77c527e
--- /dev/null
+++ b/arm_shifter_runtime_test.go
@@ -0,0 +1,407 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func requireARMScalarRuntime(t *testing.T) string {
+	t.Helper()
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for actual ARM scalar Go/LLVM execution")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM scalar runtime requires a Linux driver")
+	}
+	for _, tool := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	return llc
+}
+
+func runARMGoSourceOracle(t *testing.T, source, main string) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module armshifteroracle\n\ngo 1.20\n", "main.go": main,
+		"oracle_arm.s": strings.ReplaceAll(source, "TEXT oracle(", "TEXT ·oracle("),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go ARM oracle: %v\n%s", err, output)
+	} else {
+		t.Logf("actual Go oracle: %s", output)
+	}
+}
+
+func armShifterOracleSignature() map[string]FuncSig {
+	return map[string]FuncSig{"oracle": {
+		Name: "oracle", Args: []LLVMType{I32, I32, I32, I32, Ptr}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I32, Index: 0, Field: -1},
+			{Offset: 4, Type: I32, Index: 1, Field: -1},
+			{Offset: 8, Type: I32, Index: 2, Field: -1},
+			{Offset: 12, Type: I32, Index: 3, Field: -1},
+			{Offset: 16, Type: Ptr, Index: 4, Field: -1},
+		}},
+	}}
+}
+
+func TestCrossLinuxRuntimeMatrixARMBarrelCarryWithoutCPSRRead(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	const source = `TEXT oracle(SB),4,$0-20
+ MOVW value+0(FP),R0
+ MOVW amount+4(FP),R1
+ MOVW out+16(FP),R4
+ MOVW $0,R2
+ CMP $1,R2
+ TST R0<<R1,R0
+ MOVW $0,R3
+ MOVW.CS $1,R3
+ MOVW R3,(R4)
+ RET
+`
+	runARMGoSourceOracle(t, source, `package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *uint32)
+func main(){var out uint32;oracle(0x80000000,1,0,0,&out);if out!=1{panic(fmt.Sprint(out))};fmt.Println("shifted TST carry branch=1")}
+`)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "barrel_carry_branch", "armv7-unknown-linux-gnueabihf", ir,
+		`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+int main(void){uint32_t out=99;oracle(0x80000000u,1,0,0,&out);if(out!=1){fprintf(stderr,"LLVM carry branch=%u want=1\n",out);return 1;}return 0;}
+`, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
+
+func TestCrossLinuxRuntimeMatrixARMRawTSTCarryEncoding(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	const source = `TEXT oracle(SB),4,$0-20
+ MOVW value+0(FP),R0
+ MOVW out+16(FP),R4
+ MOVW $0x30000000,R6
+ MOVW R6,CPSR
+ WORD $0xe3100001
+ MOVW CPSR,R3
+ SRL $28,R3
+ MOVW R3,0(R4)
+ MOVW $0x30000000,R6
+ MOVW R6,CPSR
+ WORD $0xe3100104
+ MOVW CPSR,R3
+ SRL $28,R3
+ MOVW R3,4(R4)
+ RET
+`
+	runARMGoSourceOracle(t, source, `package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *[2]uint32)
+func main(){for _,v:=range []uint32{0,1,0xffffffff}{var out [2]uint32;oracle(v,0,0,0,&out);want:=[2]uint32{3,1};if v&1==0{want=[2]uint32{7,5}};if out!=want{panic(fmt.Sprintf("raw TST value=%x got=%v want=%v",v,out,want))}};fmt.Println("same decoded literal, distinct raw rotated-immediate carry passed")}
+`)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "raw_tst_carry", "armv7-unknown-linux-gnueabihf", ir,
+		`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+int main(void){const uint32_t values[]={0,1,0xffffffffu};for(unsigned i=0;i<3;i++){uint32_t out[2]={0},want[2]={3,1};if((values[i]&1)==0){want[0]=7;want[1]=5;}oracle(values[i],0,0,0,out);if(out[0]!=want[0]||out[1]!=want[1]){fprintf(stderr,"raw carry got=%u,%u want=%u,%u\n",out[0],out[1],want[0],want[1]);return 1;}}return 0;}
+`, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
+
+func TestCrossLinuxRuntimeMatrixARMZeroShiftMemoryOffsets(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	const source = `TEXT oracle(SB),4,$0-20
+ MOVW value+0(FP),R0
+ MOVW lhs+8(FP),R2
+ MOVW out+16(FP),R4
+ MOVW R2,R0>>0(R4)
+ ADD $8,R4
+ MOVW R2,R0->0(R4)
+ ADD $8,R4
+ MOVW R2,R0@>0(R4)
+ RET
+`
+	runARMGoSourceOracle(t, source, `package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *[6]uint32)
+func main(){var out [6]uint32;oracle(4,0,123,0,&out);want:=[6]uint32{0,123,0,123,0,123};if out!=want{panic(fmt.Sprint(out))};fmt.Println("Go canonicalized memory zero-shift offsets passed")}
+`)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "zero_shift_memory", "armv7-unknown-linux-gnueabihf", ir,
+		`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+int main(void){uint32_t out[6]={0};oracle(4,0,123,0,out);for(unsigned i=0;i<6;i++)if(out[i]!=(i&1?123u:0u)){fprintf(stderr,"zero-shift offset lane=%u got=%u\n",i,out[i]);return 1;}return 0;}
+`, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
+
+type armShifterRuntimeCase struct {
+	instruction string
+	op          string
+	shift       int
+	amount      int // -1 means register-controlled; other values are encoded imm5.
+	condition   string
+	setFlags    bool
+	resultReg   string
+	aliasSource bool
+}
+
+func armShifterRuntimeCases() []armShifterRuntimeCase {
+	var cases []armShifterRuntimeCase
+	for shift, token := range []string{"<<", ">>", "->", "@>"} {
+		for _, amount := range []int{-1, 0, 1, 31} {
+			operand := "R0" + token + "R1"
+			if amount >= 0 {
+				operand = fmt.Sprintf("R0%s%d", token, amount)
+			}
+			for _, op := range []string{"MOVW", "MVN", "AND", "ORR", "EOR", "BIC", "TST", "TEQ"} {
+				for _, condition := range []string{"", "EQ", "NE"} {
+					for _, flags := range []bool{false, true} {
+						if (op == "TST" || op == "TEQ") && !flags {
+							continue
+						}
+						mnemonic := op
+						if condition != "" {
+							mnemonic += "." + condition
+						}
+						if flags && op != "TST" && op != "TEQ" {
+							mnemonic += ".S"
+						}
+						args := operand + ",R3"
+						if op == "AND" || op == "ORR" || op == "EOR" || op == "BIC" {
+							args = operand + ",R2,R3"
+						}
+						if op == "TST" || op == "TEQ" {
+							args = operand + ",R2"
+						}
+						cases = append(cases, armShifterRuntimeCase{instruction: mnemonic + " " + args, op: op, shift: shift, amount: amount, condition: condition, setFlags: flags})
+					}
+				}
+			}
+		}
+	}
+	for shift, op := range []string{"SLL", "SRL", "SRA"} {
+		for _, amount := range []int{-1, 0, 1, 31, 32} {
+			operand := "R1"
+			if amount >= 0 {
+				operand = fmt.Sprintf("$%d", amount)
+			}
+			for _, condition := range []string{"", "EQ", "NE"} {
+				mnemonic := op + ".S"
+				if condition != "" {
+					mnemonic = op + "." + condition + ".S"
+				}
+				cases = append(cases, armShifterRuntimeCase{instruction: mnemonic + " " + operand + ",R0,R3", op: op, shift: shift, amount: amount, condition: condition, setFlags: true})
+			}
+		}
+	}
+	for shift, token := range []string{"<<", ">>", "->", "@>"} {
+		for _, op := range []string{"MOVW", "MVN", "AND", "ORR", "EOR", "BIC"} {
+			for _, destination := range []string{"R0", "R1"} {
+				args := "R0" + token + "R1," + destination
+				aliasLeft := false
+				if op != "MOVW" && op != "MVN" {
+					args = "R0" + token + "R1,R2," + destination
+				}
+				cases = append(cases, armShifterRuntimeCase{instruction: op + ".S " + args, op: op, shift: shift, amount: -1, setFlags: true, resultReg: destination, aliasSource: aliasLeft})
+			}
+			if op != "MOVW" && op != "MVN" {
+				cases = append(cases, armShifterRuntimeCase{instruction: op + ".S R0" + token + "R1,R0", op: op, shift: shift, amount: -1, setFlags: true, resultReg: "R0", aliasSource: true})
+			}
+		}
+	}
+	return cases
+}
+
+func armShifterRuntimeSource(cases []armShifterRuntimeCase) string {
+	var source strings.Builder
+	source.WriteString("TEXT oracle(SB),4,$0-20\n MOVW out+16(FP),R4\n")
+	for index, test := range cases {
+		resultReg := test.resultReg
+		if resultReg == "" {
+			resultReg = "R3"
+		}
+		fmt.Fprintf(&source, " MOVW value+0(FP),R0\n MOVW amount+4(FP),R1\n MOVW lhs+8(FP),R2\n MOVW $0x13579bdf,R3\n MOVW status+12(FP),R6\n MOVW R6,CPSR\n %s\n MOVW %s,%d(R4)\n MOVW CPSR,R6\n SRL $28,R6\n MOVW R6,%d(R4)\n", test.instruction, resultReg, index*8, index*8+4)
+	}
+	source.WriteString(" RET\n")
+	return source.String()
+}
+
+// This reference follows the architectural barrel shifter directly, without
+// calling the translator's evaluators or reproducing their LLVM operations.
+func armShifterReference(test armShifterRuntimeCase, value, amount, lhs, status uint32) (result, flags uint32) {
+	result, flags = 0x13579bdf, status>>28
+	if test.resultReg == "R0" {
+		result = value
+	} else if test.resultReg == "R1" {
+		result = amount
+	}
+	if test.aliasSource {
+		lhs = value
+	}
+	if test.condition == "EQ" && flags&4 == 0 || test.condition == "NE" && flags&4 != 0 {
+		return result, flags
+	}
+	carry := flags >> 1 & 1
+	count := amount & 255
+	if test.amount >= 0 {
+		count = uint32(test.amount) & 31
+		if count == 0 && test.amount != 0 && (test.op == "SRL" || test.op == "SRA") {
+			count = 32
+		}
+	}
+	shifted := value
+	if test.amount == 0 {
+		count = 0 // Go oplook canonicalizes every shifted-operand zero to LSL #0.
+	}
+	switch test.shift {
+	case 0:
+		if count > 0 && count <= 32 {
+			carry = value >> (32 - count) & 1
+			shifted = value << count
+		} else if count > 32 {
+			shifted, carry = 0, 0
+		}
+	case 1:
+		if count > 0 && count <= 32 {
+			carry = value >> (count - 1) & 1
+			shifted = value >> count
+		} else if count > 32 {
+			shifted, carry = 0, 0
+		}
+	case 2:
+		if count > 0 {
+			if count >= 32 {
+				count = 32
+			}
+			carry = value >> (count - 1) & 1
+			shifted = uint32(int32(value) >> count)
+		}
+	case 3:
+		if count > 0 {
+			shifted = bits.RotateLeft32(value, -int(count))
+			carry = shifted >> 31
+		}
+	}
+	switch test.op {
+	case "MOVW", "SLL", "SRL", "SRA":
+		result = shifted
+	case "MVN":
+		result = ^shifted
+	case "AND":
+		result = lhs & shifted
+	case "ORR":
+		result = lhs | shifted
+	case "EOR":
+		result = lhs ^ shifted
+	case "BIC":
+		result = lhs &^ shifted
+	case "TST":
+		shifted = lhs & shifted
+	case "TEQ":
+		shifted = lhs ^ shifted
+	}
+	if test.setFlags {
+		flagResult := result
+		if test.op == "TST" || test.op == "TEQ" {
+			flagResult = shifted
+		}
+		flags = flags&1 | carry<<1 | flagResult>>31<<3
+		if flagResult == 0 {
+			flags |= 4
+		}
+	}
+	return result, flags
+}
+
+func TestCrossLinuxRuntimeMatrixARMBarrelShifterFullSemantics(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	cases := armShifterRuntimeCases()
+	source := armShifterRuntimeSource(cases)
+	var inputs [][4]uint32
+	for _, count := range []uint32{0, 1, 31, 32, 33, 63, 64, 255, 256, 257, 0x80000100, 0xffffffff} {
+		for _, status := range []uint32{0, 0x30000000, 0x60000000, 0x90000000} {
+			inputs = append(inputs, [4]uint32{0x80000001, count, 0x7fffffff, status})
+		}
+	}
+	for _, value := range []uint32{0, 1, 0x7fffffff, 0x80000000, 0xffffffff} {
+		for _, status := range []uint32{0, 0x30000000, 0x60000000, 0x90000000} {
+			inputs = append(inputs, [4]uint32{value, 1, 0xffffffff, status})
+		}
+	}
+	var goVectors, cVectors strings.Builder
+	for _, input := range inputs {
+		fmt.Fprintf(&goVectors, "{[4]uint32{%d,%d,%d,%d},[%d]uint32{", input[0], input[1], input[2], input[3], 2*len(cases))
+		fmt.Fprintf(&cVectors, "{{%du,%du,%du,%du},{", input[0], input[1], input[2], input[3])
+		for _, test := range cases {
+			value, flags := armShifterReference(test, input[0], input[1], input[2], input[3])
+			fmt.Fprintf(&goVectors, "%d,%d,", value, flags)
+			fmt.Fprintf(&cVectors, "%du,%du,", value, flags)
+		}
+		goVectors.WriteString("}},\n")
+		cVectors.WriteString("}},\n")
+	}
+	goMain := fmt.Sprintf(`package main
+import "fmt"
+func oracle(value,amount,lhs,status uint32,out *[%d]uint32)
+var vectors=[]struct{args [4]uint32;want [%d]uint32}{%s}
+func main(){for i,v:=range vectors{var out [%d]uint32;oracle(v.args[0],v.args[1],v.args[2],v.args[3],&out);for j,w:=range v.want{if out[j]!=w{panic(fmt.Sprintf("Go vector=%%d lane=%%d got=%%x want=%%x",i,j,out[j],w))}}};fmt.Println("complete barrel-shifter values/NZCV passed")}
+`, 2*len(cases), 2*len(cases), goVectors.String(), 2*len(cases))
+	runARMGoSourceOracle(t, source, goMain)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: armShifterOracleSignature()})
+	if err != nil {
+		t.Fatal(err)
+	}
+	cMain := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t,uint32_t,uint32_t*);
+static const struct{uint32_t args[4],want[%d];}vectors[]={%s};
+int main(void){for(unsigned i=0;i<sizeof(vectors)/sizeof(vectors[0]);i++){uint32_t out[%d]={0};oracle(vectors[i].args[0],vectors[i].args[1],vectors[i].args[2],vectors[i].args[3],out);for(unsigned j=0;j<%d;j++)if(out[j]!=vectors[i].want[j]){fprintf(stderr,"LLVM vector=%%u lane=%%u got=%%x want=%%x\n",i,j,out[j],vectors[i].want[j]);return 1;}}return 0;}
+`, 2*len(cases), cVectors.String(), 2*len(cases), 2*len(cases))
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "barrel_shifter", "armv7-unknown-linux-gnueabihf", ir, cMain,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+	t.Logf("actual Go/LLVM: %d source forms x %d independent vectors", len(cases), len(inputs))
+}
diff --git a/arm_shifter_test.go b/arm_shifter_test.go
new file mode 100644
index 000000000..da36ed475
--- /dev/null
+++ b/arm_shifter_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestARMShifterZeroCanonicalizationMatchesGoObject(t *testing.T) {
+	if !goToolchainAtLeast(runtime.Version(), 1, 27) {
+		return // Go1.20 API lane; the pinned Go1.27 object is the source oracle.
+	}
+	const source = "TEXT zero(SB),4,$0\n MOVW R0>>0,R3\n MOVW R0->0,R3\n MOVW R0@>0,R3\n MOVW R2,R0>>0(R1)\n MOVW R2,R0->0(R1)\n MOVW R2,R0@>0(R1)\n RET\n"
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "zero.s"), filepath.Join(dir, "zero.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	assemble := exec.Command("go", "tool", "asm", "-o", object, asm)
+	assemble.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm")
+	if output, err := assemble.CombinedOutput(); err != nil {
+		t.Fatalf("Go object: %v\n%s", err, output)
+	}
+	dump := exec.Command("go", "tool", "objdump", object)
+	output, err := dump.CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go objdump: %v\n%s", err, output)
+	}
+	for _, encoding := range []string{"e1a03000", "e7812000"} {
+		if strings.Count(string(output), encoding) != 3 {
+			t.Fatalf("Go zero-shift canonical encoding %s missing:\n%s", encoding, output)
+		}
+	}
+}
+
+func TestARMRawVFPProofDoesNotInventEarlyNZCVTransfer(t *testing.T) {
+	for _, body := range []string{"WORD $0xeeb40b40\n MOVW.EQ $1,R0", "WORD $0x1eb40b40\n WORD $0xeef1fa10\n MOVW CPSR,R0"} {
+		source := "TEXT flags(SB),$0\n MOVW $0,R0\n CMP R0,R0\n " + body + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: I32}}})
+		if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "closed unconditional") {
+			t.Fatalf("unmodeled pending FPSCR effect is an ordinary hard gap, not entry-state N/A: %v", err)
+		}
+	}
+}
+
+func TestARMShifterCompleteGoFormats(t *testing.T) {
+	cases := armShifterRuntimeCases()
+	source := armShifterRuntimeSource(cases)
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: armShifterOracleSignature()})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "shifter.ll", "shifter.o", ir)
+	}
+}
+
+func TestARMShifterRejectsOutsideGoGrammar(t *testing.T) {
+	for _, instruction := range []string{"TST R0<<32,R1", "ORR.S R0>>99,R1", "MUL.S $1,R1", "MULLU.S R0,R1,R2", "MULA.S R0,R1,R2", "MVN R0,R1,R2", "MVN.S $1,R2", "ORR.S (R0),R1", "ORR R0,R1<<1,R2", "TST.S R0,R1", "AND.P R0,R1", "ADD value+4(FP),R0"} {
+		source := "TEXT bad(SB),$0\n CMP R0,R0\n " + instruction + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, false)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+			t.Fatalf("accepted outside Go shifter/multiply grammar: %s", instruction)
+		}
+	}
+}
+
+func TestARMShifterNeedsCarryOnlyWhenSourceConsumesIt(t *testing.T) {
+	for _, body := range []string{"ADC $1,R0", "TST R0,R0\n MOVW.CS $1,R1", "MUL.S R0,R1\n MOVW.VS $1,R2", "CMP R0,R0\n DIV R0,R1\n MOVW.EQ $1,R2"} {
+		source := "TEXT flags(SB),$0\n MOVW $1,R0\n MOVW $1,R1\n " + body + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: Void}}})
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("source consumes undefined carry/overflow, not a zero flag slot: %s: %v", body, err)
+		}
+	}
+	for _, body := range []string{"TST R0<<1,R0\n MOVW.CS $1,R1", "MUL.S R0,R1\n MOVW.EQ $1,R2"} {
+		source := "TEXT flags(SB),$0\n MOVW $1,R0\n MOVW $1,R1\n " + body + "\n RET\n"
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: Void}}}); err != nil {
+			t.Fatalf("source defines exactly the consumed flags: %s: %v", body, err)
+		}
+	}
+}
+
+func TestARMStatusReachabilityDoesNotInventOrRequireDeadFlags(t *testing.T) {
+	for _, body := range []string{
+		"B live\ndead:\n MOVW CPSR,R2\n MOVW.EQ $1,R2\nlive:\n MOVW $7,R0\n RET",
+		"MOVW $0,R0\n CMP R0,R0\n B live\ndead:\n BL unknown<>(SB)\n MOVW CPSR,R2\nlive:\n MOVW CPSR,R0\n RET",
+	} {
+		source := "TEXT flags(SB),$0\n " + body + "\nTEXT unknown<>(SB),$0\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: I32}, "unknown<>": {Name: "unknown<>", Ret: Void}}}
+		if _, err := Translate(file, options); err != nil {
+			t.Fatalf("unreachable flags uses must not impose entry requirements: %v", err)
+		}
+		module, err := TranslateModule(file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		module.Dispose()
+	}
+	source := "TEXT flags(SB),$0\n B live\ndead:\n MOVW $0,R0\n CMP R0,R0\nlive:\n MOVW CPSR,R0\n RET\n"
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: I32}}}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("dead writer cannot prove a live CPSR read: %v", err)
+	}
+}
+
+func TestARMMultiplyFlagsCompleteGoFormats(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT flags(SB),$0\n MOVW $0,R0\n CMP R0,R0\n")
+	for _, instruction := range []string{"MUL.S R0,R1", "MULU.EQ.S R0,R1,R2", "MULA.S R0,R1,R2,R3", "MULL.S R0,R1,(R3,R2)", "MULLU.S R0,R1,(R3,R2)", "MULAL.S R0,R1,(R3,R2)", "MULALU.NE.S R0,R1,(R3,R2)"} {
+		source.WriteString(" " + instruction + "\n")
+	}
+	source.WriteString(" MOVW CPSR,R0\n RET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"flags": {Name: "flags", Ret: I32}}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "multiply-flags.ll", "multiply-flags.o", ir)
+	}
+}
diff --git a/arm_source_cfg.go b/arm_source_cfg.go
new file mode 100644
index 000000000..6f5966742
--- /dev/null
+++ b/arm_source_cfg.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+// The source CFG is shared by native-input and status-initialization proofs.
+// It uses the same label/PC-ordinal resolution as lowering, before any LLVM
+// block traversal can turn an unreachable writer into an entry-state proof.
+func armSourcePredecessors(blocks []armBlock) (preds [][]int, reachable []bool) {
+	indices := map[string]int{}
+	for i, block := range blocks {
+		indices[block.name] = i
+	}
+	succ := make([][]int, len(blocks))
+	ctx := armCtx{blocks: blocks}
+	for i, block := range blocks {
+		fall := i+1 < len(blocks)
+		if len(block.instrs) != 0 {
+			last := block.instrs[len(block.instrs)-1]
+			op, _, _, _ := armDecodeOp(string(last.Op))
+			condition, tail, branch := armKernelBranchForm(last)
+			if op == "RET" || op == "UNDEF" || tail && (condition == "" || condition == "AL") {
+				fall = false
+			}
+			if branch && tail && last.armKernelCall == nil && len(last.Args) == 1 {
+				if name, ok := ctx.resolveBranchTarget(i, last.Args[0]); ok {
+					if target, local := indices[name]; local {
+						succ[i] = append(succ[i], target)
+					}
+				}
+			}
+		}
+		if fall {
+			succ[i] = append(succ[i], i+1)
+		}
+	}
+	reachable = make([]bool, len(blocks))
+	var visit func(int)
+	visit = func(i int) {
+		if reachable[i] {
+			return
+		}
+		reachable[i] = true
+		for _, target := range succ[i] {
+			visit(target)
+		}
+	}
+	if len(blocks) != 0 {
+		visit(0)
+	}
+	preds = make([][]int, len(blocks))
+	for i, targets := range succ {
+		if reachable[i] {
+			for _, target := range targets {
+				preds[target] = append(preds[target], i)
+			}
+		}
+	}
+	return preds, reachable
+}
diff --git a/arm_split_float64_frame_test.go b/arm_split_float64_frame_test.go
new file mode 100644
index 000000000..51a0e5cbf
--- /dev/null
+++ b/arm_split_float64_frame_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestTranslateARMLegacySplitFloat64FrameWords(t *testing.T) {
+	file, err := Parse(ArchARM, `
+TEXT splitdouble(SB),NOSPLIT,$0
+	MOVW x_lo+0(FP), R0
+	MOVW x_hi+4(FP), R1
+	AND $((1<<31)-1), R1
+	MOVW R0, ret_lo+8(FP)
+	MOVW R1, ret_hi+12(FP)
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Goarch:       "arm",
+		Sigs: map[string]FuncSig{
+			"splitdouble": {
+				Name: "splitdouble",
+				Args: []LLVMType{LLVMType("double")},
+				Ret:  LLVMType("double"),
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}},
+				},
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"bitcast double", "lshr i64", "bitcast i64", "store double"} {
+		if !strings.Contains(ll, want) {
+			t.Fatalf("legacy split float64 IR missing %q:\n%s", want, ll)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "armv7-unknown-linux-gnueabihf", "arm-split-float64.ll", "arm-split-float64.o", ll)
+}
diff --git a/arm_status_cfg.go b/arm_status_cfg.go
new file mode 100644
index 000000000..0fe517531
--- /dev/null
+++ b/arm_status_cfg.go
@@ -0,0 +1,321 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armStatusState struct {
+	initialized armKernelState
+	values      armKernelState
+	vfpWitness  bool
+}
+
+// The emitter's flagsWritten boolean only describes compile-time traversal.
+// Reading CPSR instead requires a must-initialized proof for all four modeled
+// NZCV slots on every source path. Entry has no invented physical flags, and
+// an ordinary C call has no source-native flags-result contract.
+func proveARMStatusReads(fn Func, sig FuncSig) error {
+	if !armFunctionUsesModeledFlags(fn) {
+		return nil
+	}
+	// A raw VFP compare changes FPSCR only. Keep the source proof limited to
+	// a closed unconditional compare/VMRS pair before any condition observes
+	// its APSR result; the emitter copies native FPSCR at the VMRS itself.
+	// Other sequences remain ordinary hard gaps, never native-entry N/A.
+	fn.Instrs = append([]Instr(nil), fn.Instrs...)
+	for i, ins := range fn.Instrs {
+		if ins.Op != "WORD" || len(ins.Args) != 1 || ins.Args[0].Kind != OpImm {
+			continue
+		}
+		compare, ok := decodeARMRawVFPCompare(uint32(ins.Args[0].Imm))
+		if !ok {
+			continue
+		}
+		closed := compare.condition == "AL" && i+1 < len(fn.Instrs)
+		if closed {
+			next := fn.Instrs[i+1]
+			closed = next.Op == "WORD" && len(next.Args) == 1 && next.Args[0].Kind == OpImm && uint32(next.Args[0].Imm) == 0xeef1fa10
+		}
+		if !closed {
+			return fmt.Errorf("ARM raw VFP flags effect needs a closed unconditional compare/VMRS sequence: %s", ins.Raw)
+		}
+		fn.Instrs[i].Op = "CMPD" // Proof-only full NZCV writer; emitted source stays unchanged.
+	}
+	blocks := armSplitBlocks(fn)
+	preds, reachable := armSourcePredecessors(blocks)
+	entry := armStatusState{}
+	if sig.ARMEntry != nil {
+		// Full translation validates the entry contract before reaching this
+		// proof; its shim captures physical NZCV and every non-PC GP register.
+		entry.initialized = armKernelFlags
+		entry.values = armKernelTop &^ armKernelRegBit("R15")
+	}
+	for i, reg := range sig.ArgRegs {
+		if i < len(sig.Args) {
+			entry.values |= armKernelRegBit(reg)
+		}
+	}
+	in, out := make([]armStatusState, len(blocks)), make([]armStatusState, len(blocks))
+	for i := range blocks {
+		if reachable[i] {
+			in[i] = armStatusState{initialized: armKernelFlags, values: armKernelTop, vfpWitness: true}
+			out[i] = in[i]
+		}
+	}
+	for changed := true; changed; {
+		changed = false
+		for i, block := range blocks {
+			if !reachable[i] {
+				continue
+			}
+			state := armStatusState{initialized: armKernelFlags, values: armKernelTop, vfpWitness: true}
+			if i == 0 {
+				state = entry
+			}
+			for _, pred := range preds[i] {
+				state.initialized &= out[pred].initialized
+				state.values &= out[pred].values
+				state.vfpWitness = state.vfpWitness && out[pred].vfpWitness
+			}
+			in[i] = state
+			for _, ins := range block.instrs {
+				state, _ = armStatusTransfer(fn.Sym, sig, state, ins, false)
+			}
+			if out[i] != state {
+				out[i], changed = state, true
+			}
+		}
+	}
+	for i, block := range blocks {
+		if !reachable[i] {
+			continue
+		}
+		state := in[i]
+		for _, ins := range block.instrs {
+			var err error
+			state, err = armStatusTransfer(fn.Sym, sig, state, ins, true)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func armFunctionUsesModeledFlags(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if _, matched, _ := parseARMStatusMove(ins); matched {
+			return true
+		}
+		if armInstructionReadsStatus(ins) || armInstructionFlagInputs(ins) != 0 {
+			return true
+		}
+	}
+	return false
+}
+
+func armInstructionFlagInputs(ins Instr) armKernelState {
+	if form, ok := decodeARMRawDataForm(ins); ok {
+		return armKernelConditionBits(form.condition)
+	}
+	if ins.Op == OpWORD && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		if form, ok := decodeARMRawVFPCompare(uint32(ins.Args[0].Imm)); ok {
+			// A raw predicate consumes source APSR even when no subsequent
+			// named instruction reads flags. Enter the all-path proof; the
+			// existing closed-pair rule does not authorize conditional VCMP.
+			return armKernelConditionBits(form.condition)
+		}
+	}
+	if form, matched, err := parseARMStatusMove(ins); matched && err == nil {
+		return armKernelConditionBits(form.condition)
+	}
+	op, condition, _, _ := armDecodeOp(string(ins.Op))
+	if len(op) > 1 && op[0] == 'B' && armCondCodes[op[1:]] {
+		condition = op[1:]
+	}
+	inputs := armKernelConditionBits(condition)
+	if op == "ADC" || op == "SBC" || op == "RSC" {
+		inputs |= armKernelC
+	}
+	return inputs
+}
+
+func armInstructionReadsStatus(ins Instr) bool {
+	op, _, _, _ := armDecodeOp(string(ins.Op))
+	for i, arg := range ins.Args {
+		if arg.Kind != OpIdent || !strings.EqualFold(arg.Ident, "CPSR") {
+			continue
+		}
+		if _, move := armIntegerMemorySpecs[op]; move && i == 1 && len(ins.Args) == 2 {
+			continue // A destination is a source write, not a status read.
+		}
+		return true
+	}
+	return false
+}
+
+func armStatusTransfer(name string, sig FuncSig, state armStatusState, ins Instr, check bool) (armStatusState, error) {
+	if form, ok := decodeARMRawDataForm(ins); ok {
+		predicate := armKernelConditionBits(form.condition)
+		if check && predicate != 0 && !state.initialized.has(predicate) {
+			return state, fmt.Errorf("%w: ARM raw %s in %q has no initialized %s predicate: %s", ErrProbeNeedsContext, form.family, name, form.condition, ins.Raw)
+		}
+		// These exact typed data forms leave APSR unchanged. GP outputs cannot
+		// acquire a source-value witness from zero-initialized vector slots or
+		// an unproved memory read. FPSCR changes never revive a VMRS witness.
+		state.values &^= form.gpWrites
+		state.vfpWitness = false
+		return state, nil
+	}
+	if form, matched, err := parseARMStatusMove(ins); matched {
+		if err != nil {
+			return state, err
+		}
+		predicate := armKernelConditionBits(form.condition)
+		if check && predicate != 0 && !state.initialized.has(predicate) {
+			return state, fmt.Errorf("%w: ARM CPSR continuation in %q has no initialized %s predicate: %s", ErrProbeNeedsContext, name, form.condition, ins.Raw)
+		}
+		if !form.write {
+			if check && !state.initialized.has(armKernelFlags) {
+				return state, fmt.Errorf("%w: ARM CPSR read in %q needs source-defined NZCV on every path or an explicit native-entry state bridge: %s", ErrProbeNeedsContext, name, ins.Raw)
+			}
+			mask := armKernelRegBit(form.dest)
+			known := state.initialized.has(armKernelFlags) && (predicate == 0 || state.values.has(mask))
+			state.values &^= mask
+			if known {
+				state.values |= mask
+			}
+			return state, nil
+		}
+		known := armKernelValueDefined(form.source, sig, state.values)
+		if check && !known {
+			return state, fmt.Errorf("%w: ARM CPSR write in %q requires a typed/source-defined status value: %s", ErrProbeNeedsContext, name, ins.Raw)
+		}
+		if !known {
+			state.initialized = 0
+		} else if predicate == 0 {
+			state.initialized = armKernelFlags
+		}
+		state.vfpWitness = false
+		return state, nil
+	}
+	op, condition, _, setFlags := armDecodeOp(string(ins.Op))
+	if len(op) > 1 && op[0] == 'B' && armCondCodes[op[1:]] {
+		condition = op[1:]
+	}
+	predicate := armKernelConditionBits(condition)
+	if check && predicate != 0 && !state.initialized.has(predicate) {
+		return state, fmt.Errorf("%w: ARM CPSR continuation in %q has no initialized %s predicate: %s", ErrProbeNeedsContext, name, condition, ins.Raw)
+	}
+	readsStatus := armInstructionReadsStatus(ins)
+	if check && readsStatus && !state.initialized.has(armKernelFlags) {
+		return state, fmt.Errorf("%w: ARM CPSR read in %q needs source-defined NZCV on every path or an explicit native-entry state bridge: %s", ErrProbeNeedsContext, name, ins.Raw)
+	}
+	consumesCarry := op == "ADC" || op == "SBC" || op == "RSC"
+	if check && consumesCarry && !state.initialized.has(armKernelC) {
+		return state, fmt.Errorf("%w: ARM source carry input in %q has no source definition or typed native-entry bridge: %s", ErrProbeNeedsContext, name, ins.Raw)
+	}
+	values, _ := armKernelTransfer(name, sig, state.values, ins, false)
+	if readsStatus && state.initialized.has(armKernelFlags) && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		mask := armKernelRegBit(ins.Args[1].Reg)
+		if predicate == 0 || state.values.has(mask) {
+			values |= mask
+		}
+	}
+	if call := ins.armKernelCall; call != nil {
+		if call.spec.entry == armKernelCompareExchange32 && predicate == 0 {
+			// Unlike a C call, this typed region captures APSR in the same
+			// assembly region as the documented native helper return.
+			state.initialized = armKernelFlags
+		}
+		if call.spec.entry == armKernelCompareExchange32 {
+			state.vfpWitness = false
+		}
+		state.values = values
+		return state, nil
+	}
+	write := armKernelState(0)
+	logical := op == "TST" || op == "TEQ" || setFlags && (op == "AND" || op == "ORR" || op == "EOR" || op == "BIC" || op == "MVN" || op == "MOVW")
+	switch op {
+	case "CMP", "CMN", "CMPF", "CMPD":
+		write = armKernelFlags
+	case "TST", "TEQ":
+		write = armKernelN | armKernelZ
+	case "BL", "CALL", "BX", "DIV", "DIVU", "MOD", "MODU", "DUFFZERO", "DUFFCOPY":
+		state.initialized = 0
+		state.vfpWitness = false
+	case "WORD", "BYTE", "LONG":
+		keep := false
+		if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm {
+			if decoded, carry, ok := decodeARMRawTST(uint32(ins.Args[0].Imm), ins.Raw); ok {
+				state, err := armStatusTransfer(name, sig, state, decoded, check)
+				if carry != "" {
+					state.initialized |= armKernelC
+				}
+				return state, err
+			}
+			form, ok := decodeARMRawVFPStatusTransfer(uint32(ins.Args[0].Imm))
+			keep = ok && form.toFlags && state.vfpWitness
+		}
+		if !keep {
+			state.initialized = 0
+			state.vfpWitness = false
+		}
+	default:
+		if setFlags {
+			switch op {
+			case "ADD", "SUB", "RSB", "ADC", "SBC", "RSC":
+				write = armKernelFlags
+			case "AND", "ORR", "EOR", "BIC", "MVN", "SLL", "SRL", "SRA", "MUL", "MULU", "MULA", "MULL", "MULLU", "MULAL", "MULALU":
+				write = armKernelN | armKernelZ
+			default:
+				// Do not retain older slot values across an unmodeled .S
+				// source effect merely because some earlier CMP ran.
+				if op == "MOVW" && len(ins.Args) == 2 && ins.Args[0].Kind == OpSym {
+					address := strings.TrimSpace(ins.Args[0].Sym)
+					if strings.HasPrefix(address, "$") {
+						memory, ok := parseMem(strings.TrimPrefix(address, "$"))
+						if _, err := parseARMRegisterAddressForm(op, ins, memory); ok && err == nil {
+							write = armKernelFlags
+						}
+					}
+				}
+				if op == "MOVW" && len(ins.Args) == 2 && (ins.Args[0].Kind == OpReg || ins.Args[0].Kind == OpRegShift) && ins.Args[1].Kind == OpReg {
+					write = armKernelN | armKernelZ
+				}
+				if write == 0 {
+					return state, fmt.Errorf("ARM %s flag-setting source effect is not modeled: %s", op, ins.Raw)
+				}
+			}
+		}
+	}
+	if _, move := armIntegerMemorySpecs[op]; move && len(ins.Args) == 2 && ins.Args[1].Kind == OpIdent && strings.EqualFold(ins.Args[1].Ident, "CPSR") {
+		if armKernelValueDefined(ins.Args[0], sig, state.values) {
+			write = armKernelFlags
+		} else {
+			state.initialized = 0
+		}
+	}
+	if predicate == 0 {
+		state.initialized |= write
+		if logical && len(ins.Args) != 0 && (armLogicalImmediateCarry(op, ins.Args[0]) != "" || armShifterDefinesCarry(ins.Args[0])) {
+			state.initialized |= armKernelC
+		}
+		if setFlags && (op == "SLL" || op == "SRL" || op == "SRA") && len(ins.Args) != 0 && ins.Args[0].Kind == OpImm && ins.Args[0].Imm != 0 && (op != "SLL" || uint32(ins.Args[0].Imm)&31 != 0) {
+			state.initialized |= armKernelC
+		}
+	}
+	if write != 0 {
+		if op == "CMPF" || op == "CMPD" {
+			state.vfpWitness = predicate == 0 || state.vfpWitness
+		} else {
+			state.vfpWitness = false
+		}
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpIdent && (strings.EqualFold(ins.Args[1].Ident, "FPCR") || strings.EqualFold(ins.Args[1].Ident, "FPSR")) {
+		state.vfpWitness = false
+	}
+	state.values = values
+	return state, nil
+}
diff --git a/arm_status_cfg_runtime_test.go b/arm_status_cfg_runtime_test.go
new file mode 100644
index 000000000..35faf8d64
--- /dev/null
+++ b/arm_status_cfg_runtime_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMStatusCFG(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for actual Go/LLVM ARM status CFG execution")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM status CFG oracle requires a Linux driver")
+	}
+	for _, tool := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(tool); err != nil {
+			t.Fatal(err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	const rejected = `TEXT rejected<>(SB),4,$0
+ B read
+ CMP R0,R0
+read:
+ MOVW CPSR,R0
+ SRL $28,R0
+ RET
+`
+	const accepted = `TEXT flags(SB),4,$0-8
+ MOVW value+0(FP),R0
+ B setup
+read:
+ MOVW CPSR,R0
+ SRL $28,R0
+ MOVW R0,ret+4(FP)
+ RET
+setup:
+ CMP $0,R0
+ BEQ zero
+ CMP $1,R0
+ B read
+zero:
+ CMP $2,R0
+ B read
+`
+	const wrapper = `TEXT ·oracle(SB),4,$0-4
+ MOVW out+0(FP),R4
+ MOVW $0,R0
+ CMP R0,R0
+ BL rejected<>(SB)
+ MOVW R0,(R4)
+ RET
+`
+	const main = `package main
+import "fmt"
+func oracle(out *uint32)
+func flags(value uint32) uint32
+func main() {
+ out := uint32(0)
+ oracle(&out)
+ if out != 6 { panic(fmt.Sprintf("Go bypassed flags writer: got NZCV=%x want6",out)) }
+ for _,test := range []struct{value,want uint32}{{0,8},{1,6},{2,2},{0x80000000,3},{0xffffffff,10}} {
+  if actual := flags(test.value); actual != test.want { panic(fmt.Sprintf("Go CFG NZCV input=%x got=%x want=%x",test.value,actual,test.want)) }
+ }
+ fmt.Println("Go native-entry NZCV=6; source-defined CFG vectors passed")
+}
+`
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module armstatusoracle\n\ngo 1.20\n", "main.go": main,
+		"oracle_arm.s": rejected + wrapper + "TEXT ·" + accepted[len("TEXT "):],
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=1", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM status CFG oracle: %v\n%s", err, output)
+	} else {
+		t.Logf("actual Go oracle: %s", output)
+	}
+	file, err := Parse(ArchARM, rejected)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", ResolveSym: func(string) string { return "rejected" }, Sigs: map[string]FuncSig{
+		"rejected": {Name: "rejected", Ret: I32},
+	}})
+	if err == nil {
+		// The old implementation packs zero-filled slots because it saw an
+		// unreachable CMP while compiling, despite the real entry NZCV=6.
+		const oldOracle = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t rejected(void);
+int main(void) {
+ register uint32_t result __asm__("r0");
+ __asm__ volatile("cmp r0,r0; bl rejected" : "=r"(result) : : "r1","r2","r3","r12","lr","cc","memory");
+ if (result != 6) { fprintf(stderr,"LLVM bypassed-writer NZCV=%x; native Go=6\n",result); return 1; }
+ return 0;
+}
+`
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "old_status_cfg", "armv7-unknown-linux-gnueabihf", ir, oldOracle,
+			[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+		t.Fatal("unbound native-entry flags cannot pass by sampling physical flags after an LLVM prologue")
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unbound initial flags must remain a context failure: %v", err)
+	}
+	file, err = Parse(ArchARM, accepted)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+		"flags": {Name: "flags", Args: []LLVMType{I32}, Ret: I32, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+		}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const oracle = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t flags(uint32_t);
+int main(void) {
+ const uint32_t input[]={0,1,2,0x80000000u,0xffffffffu}, want[]={8,6,2,3,10};
+ for (unsigned i=0;i<5;i++) {
+  uint32_t actual=flags(input[i]);
+  if (actual!=want[i]) { fprintf(stderr,"LLVM CFG NZCV input=%x got=%x want=%x\n",input[i],actual,want[i]); return 1; }
+ }
+ return 0;
+}
+`
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "status_cfg", "armv7-unknown-linux-gnueabihf", ir, oracle,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_status_cfg_test.go b/arm_status_cfg_test.go
new file mode 100644
index 000000000..311b35ed9
--- /dev/null
+++ b/arm_status_cfg_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARMStatusReadRequiresInitializedNZCVOnEveryPath(t *testing.T) {
+	tests := []struct{ name, body string }{
+		{"native_entry", "MOVW CPSR,R0"},
+		{"bypassed_writer", "B read\n CMP R0,R0\nread:\n MOVW CPSR,R0"},
+		{"conditional_writer", "CMP.EQ R0,R0\n MOVW CPSR,R0"},
+		{"only_logic_flags", "TST R0,R0\n MOVW CPSR,R0"},
+		{"only_shift_flags", "SLL.S $1,R0\n MOVW CPSR,R0"},
+		{"only_multiply_flags", "MULL.S R0,R0,(R1,R2)\n MOVW CPSR,R0"},
+		{"unproved_call_status", "BL other<>(SB)\n MOVW CPSR,R0"},
+		{"conditional_status_write", "MOVW.EQ R0,CPSR\n MOVW CPSR,R0"},
+		{"unbound_status_source", "MOVW R7,CPSR\n MOVW CPSR,R0"},
+		{"raw_status_without_fp_witness", "CMP R0,R0\n WORD $0xeef1fa10\n MOVW CPSR,R0"},
+		{"raw_status_after_gp_overwrite", "MOVD $0.0,F0\n CMPD F0,F0\n CMP R0,R0\n WORD $0xeef1fa10\n MOVW CPSR,R0"},
+		{"loop_first_iteration", "B read\nloop:\n CMP R0,R0\nread:\n MOVW CPSR,R0\n B loop"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT flags(SB),$0\n MOVW $0,R0\n " + test.body + "\n RET\nTEXT other<>(SB),$0\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"flags": {Name: "flags", Ret: I32}, "other<>": {Name: "other<>", Ret: Void},
+			}}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("CPSR cannot read generic zero slots or unbound physical entry/callee flags: %v", err)
+			}
+			module, err := TranslateModule(file, options)
+			if err == nil {
+				module.Dispose()
+				t.Fatal("direct module translation lost the initial/CFG NZCV context failure")
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("direct module did not preserve status-context failure: %v", err)
+			}
+		})
+	}
+}
+
+func TestARMConditionalComparePreservesSkippedNZCV(t *testing.T) {
+	for _, op := range []string{"CMP", "CMN", "TST", "TEQ"} {
+		for _, condition := range []string{"EQ", "NE", "CS", "CC", "HS", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE"} {
+			source := "TEXT flags(SB),$0\n MOVW $0,R0\n CMP R0,R0\n " + op + "." + condition + " $1,R0\n MOVW CPSR,R0\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"flags": {Name: "flags", Ret: I32},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "br i1") {
+				t.Fatalf("%s.%s must preserve one source instruction's predicate", op, condition)
+			}
+		}
+	}
+}
+
+func TestARMStatusReadKeepsModeledShifterAndMultiplyEffects(t *testing.T) {
+	for _, instruction := range []string{"TST R0<<1,R0", "TEQ R0>>1,R0", "AND.S R0<<1,R0", "ORR.S R0>>1,R0", "EOR.S R0->1,R0", "BIC.S R0@>1,R0", "MUL.S R0,R0"} {
+		source := "TEXT flags(SB),$0\n MOVW $0,R0\n CMP R0,R0\n " + instruction + "\n MOVW CPSR,R0\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+			"flags": {Name: "flags", Ret: I32},
+		}})
+		if err != nil {
+			t.Fatalf("ordinary shifter/multiply effects must now be modeled, not become source N/A: %s: %v", instruction, err)
+		}
+	}
+}
+
+func TestARMStatusReadKeepsSourceDefinedCFGFlags(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, body := range []string{
+		"CMP R0,R0\n CMP.EQ R0,R0\n MOVW CPSR,R0",
+		"CMP R0,R0\n BEQ alternate\n CMP $1,R0\n B read\nalternate:\n CMP $2,R0\nread:\n MOVW CPSR,R0",
+		"CMP R0,R0\nloop:\n MOVW CPSR,R0\n CMP $0,R0\n BNE loop",
+		"B setup\nread:\n MOVW CPSR,R0\n RET\nsetup:\n CMP R0,R0\n B read",
+		"MOVW $0x60000000,R0\n MOVW R0,CPSR\n MOVW CPSR,R0",
+		"MOVW.S $4(R0),R1\n MOVW CPSR,R0",
+		"CMP R0,R0\n MOVW.S R0,R1\n MOVW CPSR,R0",
+		"CMP R0,R0\n MOVW.NE.S $4(R0),R1\n MOVW CPSR,R0",
+		"MOVD $0.0,F0\n CMPD F0,F0\n WORD $0xeef1fa10\n MOVW CPSR,R0",
+	} {
+		source := "TEXT flags(SB),$0\n MOVW $0,R0\n " + body + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"flags": {Name: "flags", Ret: I32},
+			}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "source-cfg-status.ll", "source-cfg-status.o", ir)
+		}
+	}
+}
diff --git a/arm_status_flags_test.go b/arm_status_flags_test.go
new file mode 100644
index 000000000..99920a435
--- /dev/null
+++ b/arm_status_flags_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestARMStatusReadUsesSourceNZCV(t *testing.T) {
+	const source = "TEXT flags(SB),$0-4\n MOVW value+0(FP),R0\n CMP R0,R0\n MOVW CPSR,R0\n RET\n"
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "flags", Args: []LLVMType{I32}, Ret: I32,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}},
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"flags": sig}})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, want := range []string{"mrs $0, cpsr", ", 268435455", "load i1, ptr %flags_n", "load i1, ptr %flags_z", "load i1, ptr %flags_c", "load i1, ptr %flags_v"} {
+			if !strings.Contains(ir, want) {
+				t.Fatalf("CPSR read did not preserve source NZCV/non-NZCV status separation: missing %q", want)
+			}
+		}
+		compileLLVMToObject(t, llc, triple, "source-status.ll", "source-status.o", ir)
+	}
+}
diff --git a/arm_status_move.go b/arm_status_move.go
new file mode 100644
index 000000000..55296b88e
--- /dev/null
+++ b/arm_status_move.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+)
+
+// Go asm5 types 35/36/37 select CPSR fields fs (mask 0xc), not fsxc.
+// The Go frontend excludes SPSR and checkSuffix rejects .S/.P/.W/.U/.F.
+// Raw A32 encodings may additionally select just f; control/extension fields
+// and SPSR require a privileged machine-entry contract which we do not invent.
+type armStatusMove struct {
+	condition string
+	write     bool
+	fields    string
+	source    Operand
+	dest      Reg
+}
+
+func armStatusOperand(operand Operand) bool {
+	return operand.Kind == OpIdent && (strings.EqualFold(operand.Ident, "CPSR") || strings.EqualFold(operand.Ident, "SPSR"))
+}
+
+func parseARMStatusMove(ins Instr) (armStatusMove, bool, error) {
+	if ins.Op == "WORD" && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		if ins.Args[0].ImmIsFloat {
+			return armStatusMove{}, true, fmt.Errorf("ARM WORD requires an integer encoding, not a floating operand: %s", ins.Raw)
+		}
+		return decodeARMRawStatusMove(uint32(ins.Args[0].Imm), ins.Raw)
+	}
+	matched := false
+	for _, operand := range ins.Args {
+		matched = matched || armStatusOperand(operand)
+	}
+	if !matched {
+		return armStatusMove{}, false, nil
+	}
+	op, condition, _, _ := armDecodeOp(string(ins.Op))
+	if op != "MOVW" || len(ins.Args) != 2 {
+		return armStatusMove{}, true, fmt.Errorf("ARM status transfer requires Go MOVW CPSR,Rn or Rn/rotated-immediate,CPSR: %s", ins.Raw)
+	}
+	if err := armRequireConditionOnlySuffix(ins); err != nil {
+		return armStatusMove{}, true, err
+	}
+	for _, operand := range armRawOperands(ins) {
+		if strings.TrimSpace(operand) == "R10" {
+			return armStatusMove{}, true, fmt.Errorf("ARM Go register table reserves R10; source must use the actual g spelling: %s", ins.Raw)
+		}
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpIdent && strings.EqualFold(operand.Ident, "SPSR") {
+			return armStatusMove{}, true, fmt.Errorf("ARM SPSR spelling is not accepted by the Go assembler register table: %s", ins.Raw)
+		}
+	}
+	form := armStatusMove{condition: condition, fields: "fs"}
+	if armStatusOperand(ins.Args[0]) {
+		form.dest = ins.Args[1].Reg
+		if ins.Args[1].Kind != OpReg || !isARMGeneralReg(form.dest) {
+			return form, true, fmt.Errorf("ARM CPSR read requires a physical GP destination: %s", ins.Raw)
+		}
+		return form, true, armStatusGPContext(form.dest, ins.Raw)
+	}
+	if !armStatusOperand(ins.Args[1]) {
+		return form, true, fmt.Errorf("ARM CPSR write requires the status destination: %s", ins.Raw)
+	}
+	form.write, form.source = true, ins.Args[0]
+	switch form.source.Kind {
+	case OpReg:
+		if !isARMGeneralReg(form.source.Reg) {
+			return form, true, fmt.Errorf("ARM CPSR write requires a physical GP input: %s", ins.Raw)
+		}
+		return form, true, armStatusGPContext(form.source.Reg, ins.Raw)
+	case OpImm:
+		// A numerically integral float remains Go C_FCON, not C_RCON.
+		if form.source.ImmIsFloat {
+			return form, true, fmt.Errorf("ARM CPSR immediate requires the Go integer operand class: %s", ins.Raw)
+		}
+		if form.source.ImmRaw == "" {
+			value := uint32(form.source.Imm)
+			for rotation := 0; rotation < 32; rotation += 2 {
+				if bits.RotateLeft32(value, rotation) <= 255 {
+					return form, true, nil
+				}
+			}
+		}
+	}
+	return form, true, fmt.Errorf("ARM CPSR write requires Go C_REG/C_RCON, not an arbitrary value or memory operand: %s", ins.Raw)
+}
+
+func armStatusGPContext(reg Reg, raw string) error {
+	if reg == "R15" || reg == PC || reg == SP {
+		return fmt.Errorf("%w: ARM status transfer using PC/pseudo-SP requires a physical source layout/stack contract: %s", ErrProbeNeedsContext, raw)
+	}
+	return nil
+}
+
+func decodeARMRawStatusMove(word uint32, raw string) (armStatusMove, bool, error) {
+	read := word&0x0fbf0fff == 0x010f0000
+	register := word&0x0fb0fff0 == 0x0120f000
+	immediate := word&0x0fb0f000 == 0x0320f000
+	if !read && !register && !immediate {
+		return armStatusMove{}, false, nil
+	}
+	// The zero-mask CPSR immediate space is architectural HINT, not MSR.
+	// Preserve the existing independent hint decoder (including old-CPU
+	// YIELD-as-NOP behavior); unknown hints still fail in normal lowering.
+	if immediate && word&(1<<22) == 0 && word>>16&15 == 0 {
+		return armStatusMove{}, false, nil
+	}
+	condition, ok := armRawCondition(word >> 28)
+	if !ok {
+		return armStatusMove{}, true, fmt.Errorf("ARM PSR encoding has no A32 condition: %s", raw)
+	}
+	form := armStatusMove{condition: condition, write: !read}
+	if word&(1<<22) != 0 {
+		return form, true, fmt.Errorf("%w: ARM SPSR transfer requires a privileged exception-state entry contract: %s", ErrProbeNeedsContext, raw)
+	}
+	if read {
+		form.dest = Reg(fmt.Sprintf("R%d", word>>12&15))
+		return form, true, armStatusGPContext(form.dest, raw)
+	}
+	switch word >> 16 & 15 {
+	case 8:
+		form.fields = "f"
+	case 12:
+		form.fields = "fs"
+	default:
+		return form, true, fmt.Errorf("%w: ARM CPSR fields %#x require a separate status/control/extension effect contract: %s", ErrProbeNeedsContext, word>>16&15, raw)
+	}
+	if register {
+		form.source = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("R%d", word&15))}
+		return form, true, armStatusGPContext(form.source.Reg, raw)
+	}
+	form.source = Operand{Kind: OpImm, Imm: int64(bits.RotateLeft32(word&255, -int(word>>8&15)*2))}
+	return form, true, nil
+}
+
+func (c *armCtx) lowerStatusMove(form armStatusMove) error {
+	return c.emitConditionalEffect(form.condition, func() error {
+		if !form.write {
+			value, err := c.eval32(Operand{Kind: OpIdent, Ident: "CPSR"}, false)
+			if err != nil {
+				return err
+			}
+			return c.storeReg(form.dest, value)
+		}
+		value, err := c.eval32(form.source, false)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(c.b, "  call void asm sideeffect %q, %q(i32 %s)\n", "msr cpsr_"+form.fields+", $0", "r,~{cc},~{memory}", value)
+		c.storeFlagsFromStatus(value)
+		return nil
+	})
+}
diff --git a/arm_status_move_runtime_test.go b/arm_status_move_runtime_test.go
new file mode 100644
index 000000000..cd7b2c5e1
--- /dev/null
+++ b/arm_status_move_runtime_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMStatusSaveRestore(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	conditions := []string{"EQ", "NE", "CS", "CC", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL"}
+	var source, modes, predicates strings.Builder
+	source.WriteString("TEXT oracle(SB),4,$0-12\n MOVW out+8(FP),R4\n")
+	lane := 0
+	for mode := 0; mode < 7; mode++ {
+		for condition, name := range conditions {
+			source.WriteString(" MOVW initial+0(FP),R0\n MOVW R0,CPSR\n MOVW CPSR,R6\n")
+			if mode < 5 {
+				source.WriteString(" MOVW $0,R7\n MOVW R7,CPSR\n")
+			}
+			source.WriteString(" MOVW selector+4(FP),R1\n CMP $0,R1\n")
+			switch mode {
+			case 0:
+				fmt.Fprintf(&source, " MOVW.%s R6,CPSR\n MOVW CPSR,R0\n", name)
+			case 1, 2:
+				word := uint32(condition)<<28 | 0x012cf006
+				if mode == 2 {
+					word = uint32(condition)<<28 | 0x0128f006
+				}
+				fmt.Fprintf(&source, " WORD $%#x\n MOVW CPSR,R0\n", word)
+			case 3:
+				fmt.Fprintf(&source, " MOVW.%s $0xff000000,CPSR\n MOVW CPSR,R0\n", name)
+			case 4:
+				fmt.Fprintf(&source, " WORD $%#x\n MOVW CPSR,R0\n", uint32(condition)<<28|0x032cf4ff)
+			case 5:
+				fmt.Fprintf(&source, " MOVW $0,R0\n MOVW.%s CPSR,R0\n", name)
+			case 6:
+				fmt.Fprintf(&source, " MOVW $0,R0\n WORD $%#x\n", uint32(condition)<<28|0x010f0000)
+			}
+			fmt.Fprintf(&source, " AND $0xf80f0000,R0\n MOVW R0,%d(R4)\n", lane*4)
+			fmt.Fprintf(&modes, "%d,", mode)
+			fmt.Fprintf(&predicates, "%d,", condition)
+			lane++
+		}
+	}
+	source.WriteString(" RET\n")
+	// Expectations are independently derived from ARM condition truth tables,
+	// CMP selector,#0, and the selected MSR field bytes. No translated helper
+	// computes the expected values and no encode/decode roundtrip can cancel.
+	main := fmt.Sprintf(`package main
+import "fmt"
+func oracle(initial, selector uint32, out *uint32)
+func passed(condition int, flags uint32) bool {
+ n,z,c,v := flags&8!=0, flags&4!=0, flags&2!=0, flags&1!=0
+ return []bool{z,!z,c,!c,n,!n,v,!v,c&&!z,!c||z,n==v,n!=v,!z&&n==v,z||n!=v,true}[condition]
+}
+func main() {
+ modes,conditions := []int{%s},[]int{%s}
+ var out [%d]uint32
+ for initialFlags:=uint32(0);initialFlags<16;initialFlags++ {
+  for q:=uint32(0);q<2;q++ { for ge:=uint32(0);ge<16;ge++ {
+   initial:=initialFlags<<28|q<<27|ge<<16
+   for index,selector:=range []uint32{0,1,0xffffffff,0x80000000} {
+    compareFlags:=[]uint32{6,2,10,10}[index]
+    oracle(initial,selector,&out[0])
+    for lane,mode:=range modes {
+     want:=compareFlags<<28
+     take:=passed(conditions[lane],compareFlags)
+     if mode>=5 { want=0; if take { want=compareFlags<<28|initial&0x080f0000 } } else if take {
+      switch mode {case 0,1:want=initial;case 2:want=initial&0xf8000000;case 3,4:want=0xf8000000}
+     }
+     if out[lane]!=want { panic(fmt.Sprintf("Go status initial=%%08x selector=%%08x lane=%%d mode=%%d condition=%%d got=%%08x want=%%08x",initial,selector,lane,mode,conditions[lane],out[lane],want)) }
+    }
+   }
+  } }
+ }
+ fmt.Println("Go CPSR save/restore: 2048 inputs x %d typed/raw conditional lanes passed")
+}
+`, modes.String(), predicates.String(), lane, lane)
+	runARMGoSourceOracle(t, source.String(), main)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+		"oracle": {Name: "oracle", Args: []LLVMType{I32, I32, Ptr}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: I32, Index: 0, Field: -1},
+			{Offset: 4, Type: I32, Index: 1, Field: -1},
+			{Offset: 8, Type: Ptr, Index: 2, Field: -1},
+		}}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	oracle := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern void oracle(uint32_t,uint32_t,uint32_t*);
+static int passed(unsigned condition,unsigned flags) {
+ int n=(flags>>3)&1,z=(flags>>2)&1,c=(flags>>1)&1,v=flags&1;
+ int result[]={z,!z,c,!c,n,!n,v,!v,c&&!z,!c||z,n==v,n!=v,!z&&n==v,z||n!=v,1};
+ return result[condition];
+}
+int main(void) {
+ const unsigned modes[]={%s},conditions[]={%s};
+ const uint32_t selectors[]={0,1,0xffffffffu,0x80000000u},compareFlags[]={6,2,10,10};
+ uint32_t out[%d];
+ for(unsigned nzcv=0;nzcv<16;nzcv++) for(unsigned q=0;q<2;q++) for(unsigned ge=0;ge<16;ge++) {
+  uint32_t initial=nzcv<<28|q<<27|ge<<16;
+  for(unsigned index=0;index<4;index++) {
+   oracle(initial,selectors[index],out);
+   for(unsigned lane=0;lane<%d;lane++) {
+    unsigned mode=modes[lane],take=passed(conditions[lane],compareFlags[index]);
+    uint32_t want=compareFlags[index]<<28;
+    if(mode>=5) {want=take?(compareFlags[index]<<28|initial&0x080f0000u):0;}
+    else if(take) {switch(mode) {case 0:case 1:want=initial;break;case 2:want=initial&0xf8000000u;break;case 3:case 4:want=0xf8000000u;break;}}
+    if(out[lane]!=want) {fprintf(stderr,"LLVM status initial=%%08x selector=%%08x lane=%%u mode=%%u condition=%%u got=%%08x want=%%08x\n",initial,selectors[index],lane,mode,conditions[lane],out[lane],want);return 1;}
+   }
+  }
+ }
+ puts("LLVM CPSR save/restore: 2048 inputs x %d typed/raw conditional lanes passed");
+ return 0;
+}
+`, modes.String(), predicates.String(), lane, lane, lane)
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "status_save_restore", "armv7-unknown-linux-gnueabihf", ir, oracle,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+	t.Logf("actual LLVM22 ARM object, GCC link, and QEMU execution: 2048 inputs x %d typed/raw conditional status lanes passed", lane)
+}
diff --git a/arm_status_move_test.go b/arm_status_move_test.go
new file mode 100644
index 000000000..b21e86cd0
--- /dev/null
+++ b/arm_status_move_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestARMStatusMoveMatchesGoFieldsAndConditions(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	conditions := []string{"", ".AL", ".EQ", ".NE", ".CS", ".CC", ".HS", ".LO", ".MI", ".PL", ".VS", ".VC", ".HI", ".LS", ".GE", ".LT", ".GT", ".LE"}
+	for _, condition := range conditions {
+		for _, operands := range []string{"CPSR,R1", "R1,CPSR", "$0xff,CPSR", "$0xff000000,CPSR"} {
+			instruction := "MOVW" + condition + " " + operands
+			source := "TEXT status(SB),4,$0-0\n MOVW $0,R0\n MOVW $0x60000000,R1\n CMP R0,R0\n " + instruction + "\n RET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{
+					"status": {Name: "status", Ret: Void},
+				}})
+				if err != nil {
+					t.Fatalf("%s %s: %v", triple, instruction, err)
+				}
+				if !strings.HasPrefix(operands, "CPSR,") && (!strings.Contains(ir, "msr cpsr_fs, $0") || strings.Contains(ir, "cpsr_fsxc")) {
+					t.Fatalf("Go asm5 type36/37 selects fields fs (0xc), not fsxc: %s", instruction)
+				}
+				compileLLVMToObject(t, llc, triple, "status-move.ll", "status-move.o", ir)
+			}
+		}
+	}
+}
+
+func TestARMStatusMoveGoObjectAndLLVMEncoderWitness(t *testing.T) {
+	dir := t.TempDir()
+	source := filepath.Join(dir, "status.s")
+	const assembly = `TEXT status(SB),4,$0-0
+ MOVW CPSR,R1
+ MOVW R1,CPSR
+ MOVW $0xff,CPSR
+ MOVW $0xff000000,CPSR
+ MOVW.EQ $0xff000000,CPSR
+ RET
+`
+	if err := os.WriteFile(source, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-S", "-p", "status", "-o", filepath.Join(dir, "status.o"), source)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm")
+	listing, err := cmd.CombinedOutput()
+	if err != nil || !strings.Contains(string(listing), "00 10 0f e1 01 f0 2c e1 ff f0 2c e3 ff f4 2c e3") || !strings.Contains(string(listing), "ff f4 2c 03") {
+		t.Fatalf("actual Go MRS/MSR and EQ masks differ: %v\n%s", err, listing)
+	}
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc not found")
+	}
+	cmd = exec.Command(mc, "-triple=armv7-unknown-linux-gnueabihf", "-show-encoding")
+	cmd.Stdin = strings.NewReader("mrs r1,cpsr\nmsr cpsr_fs,r1\nmsr cpsr_fs,#255\nmsr cpsr_fs,#0xff000000\nmsreq cpsr_fs,#0xff000000\nmrs r1,spsr\nmsr spsr_fs,r1\n")
+	encoding, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("LLVM22 ARM PSR encoder: %v\n%s", err, encoding)
+	}
+	for _, bytes := range []string{"[0x00,0x10,0x0f,0xe1]", "[0x01,0xf0,0x2c,0xe1]", "[0xff,0xf0,0x2c,0xe3]", "[0xff,0xf4,0x2c,0xe3]", "[0xff,0xf4,0x2c,0x03]", "[0x00,0x10,0x4f,0xe1]", "[0x01,0xf0,0x6c,0xe1]"} {
+		if !strings.Contains(string(encoding), bytes) {
+			t.Fatalf("LLVM22 PSR encoding lacks %s:\n%s", bytes, encoding)
+		}
+	}
+	t.Logf("actual Go status object encodings:\n%s\nLLVM22 independent MC encoding (SPSR is compile-only, not user-mode execution):\n%s", listing, encoding)
+}
+
+func TestARMStatusMoveRejectsNonGoForms(t *testing.T) {
+	for _, instruction := range []string{
+		"MOVW SPSR,R0", "MOVW R0,SPSR", "MOVW $0,SPSR", "MOVW APSR,R0", "MOVW CPSR_f,R0", "MOVW CS,R0",
+		"MOVW CPSR,R10", "MOVW R10,CPSR", "WORD $3775856640.0",
+		"MOVW.S CPSR,R0", "MOVW.F CPSR,R0", "MOVW.W CPSR,R0", "MOVW.P CPSR,R0", "MOVW.U CPSR,R0",
+		"MOVW.S R0,CPSR", "MOVW.F R0,CPSR", "MOVW.W R0,CPSR", "MOVW.P R0,CPSR", "MOVW.U R0,CPSR",
+		"MOVW $0x12345678,CPSR", "MOVW $0.0,CPSR", "MOVW CPSR,(R0)", "MOVW (R0),CPSR", "MOVW value+0(FP),CPSR", "MOVB CPSR,R0",
+	} {
+		t.Run(strings.ReplaceAll(instruction, "/", "_"), func(t *testing.T) {
+			source := "TEXT status(SB),4,$0-0\n MOVW $0,R0\n CMP R0,R0\n " + instruction + "\n RET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+				"status": {Name: "status", Ret: Void},
+			}})
+			if err == nil || ir != "" {
+				t.Fatalf("invalid Go status form became LLVM success: %s: %v; actual parsed instructions: %+v", instruction, err, file.Funcs[0].Instrs)
+			}
+		})
+	}
+}
+
+func TestARMStatusMoveKeepsConditionalSaveAndClobberFailures(t *testing.T) {
+	for _, body := range []string{
+		"MOVW $0,R0\n CMP R0,R0\n MOVW.EQ CPSR,R7\n MOVW R7,CPSR",
+		"MOVW $0,R0\n CMP R0,R0\n WORD $0x010f7000\n MOVW R7,CPSR",
+		"MOVW $0,R0\n CMP R0,R0\n MOVW CPSR,R7\n WORD $0xffffffff\n MOVW R7,CPSR",
+		"B done\n MOVW.F R0,CPSR\ndone:",
+	} {
+		source := "TEXT status(SB),4,$0-0\n " + body + "\n RET\n"
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+			"status": {Name: "status", Ret: Void},
+		}})
+		if err == nil || ir != "" {
+			t.Fatalf("conditional save/unknown machine effect/dead invalid grammar invented status: %s: %v", body, err)
+		}
+	}
+}
+
+func TestARMStatusMoveRawFieldsAndSourceProof(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, word := range []uint32{0xe10f1000, 0xe12cf001, 0xe128f001, 0xe32cf0ff, 0xe328f4ff, 0x012cf001, 0x010f1000} {
+		source := fmt.Sprintf("TEXT status(SB),4,$0-0\n MOVW $0,R0\n MOVW $0x60000000,R1\n CMP R0,R0\n WORD $%#x\n MOVW CPSR,R0\n RET\n", word)
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{
+				"status": {Name: "status", Ret: Void},
+			}})
+			if err != nil {
+				t.Fatalf("typed raw PSR word %#x: %v", word, err)
+			}
+			compileLLVMToObject(t, llc, triple, "raw-status-move.ll", "raw-status-move.o", ir)
+		}
+	}
+	for _, instruction := range []string{
+		"MOVW CPSR,R0", "MOVW R7,CPSR", "MOVW CPSR,R15", "MOVW R15,CPSR",
+		"WORD $0xe14f0000", "WORD $0xe16cf001", "WORD $0xe36cf0ff", // SPSR requires privileged exception state.
+		"WORD $0xe121f001", "WORD $0xe122f001", "WORD $0xe12ff001", // CPSR control/extension fields.
+		"WORD $0xe10ff000", "WORD $0xe12cf00f", // Architectural PC is not a zero GPR.
+	} {
+		setup := " MOVW $0,R0\n CMP R0,R0\n"
+		if instruction == "MOVW CPSR,R0" {
+			setup = ""
+		}
+		source := "TEXT status(SB),4,$0-0\n" + setup + " " + instruction + "\n RET\n"
+		requireARMGoAssemblerResult(t, source, true)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: map[string]FuncSig{
+			"status": {Name: "status", Ret: Void},
+		}})
+		if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatalf("unproved native/privileged status became success: %s: %v", instruction, err)
+		}
+	}
+}
+
+func TestARMPreemptOriginalSourceRetainsIncomingStatusContext(t *testing.T) {
+	rootOutput, err := exec.Command("go", "env", "GOROOT").CombinedOutput()
+	if err != nil {
+		t.Fatalf("Go root: %v: %s", err, rootOutput)
+	}
+	sourcePath := filepath.Join(strings.TrimSpace(string(rootOutput)), "src", "runtime", "preempt_arm.s")
+	source, err := os.ReadFile(sourcePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := ParseWithDefines(ArchARM, string(source), GoAssemblerDefines("linux", "arm"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != 1 || file.Funcs[0].FrameSize != 0 || !strings.Contains(string(source), "MOVW CPSR, R0") || !strings.Contains(string(source), "MOVW.P 192(R13), R15") {
+		t.Fatal("original incoming status/stack-PC source contract changed")
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", ResolveSym: func(string) string { return "runtime.asyncPreempt" }, Sigs: map[string]FuncSig{
+		"runtime.asyncPreempt": {Name: "runtime.asyncPreempt", Ret: Void},
+	}})
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "native-entry state bridge") || ir != "" {
+		t.Fatalf("original asyncPreempt must retain missing incoming-machine-state failure: %v", err)
+	}
+	contextFailure := err
+	cmd := exec.Command("go", "list", "-export", "-f", "{{.Export}}", "runtime")
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	archive, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("actual Go runtime object: %v: %s", err, archive)
+	}
+	objectBytes, err := exec.Command("go", "tool", "pack", "p", strings.TrimSpace(string(archive)), "preempt_arm.o").CombinedOutput()
+	if err != nil {
+		t.Fatalf("actual selected Go preempt object extraction: %v: %s", err, objectBytes)
+	}
+	object := filepath.Join(t.TempDir(), "preempt_arm.o")
+	if err := os.WriteFile(object, objectBytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing, err := exec.Command("go", "tool", "objdump", "-s", "^runtime.asyncPreempt$", object).CombinedOutput()
+	if err != nil || !strings.Contains(string(listing), "preempt_arm.s") || !strings.Contains(string(listing), "e10f0000") || !strings.Contains(string(listing), "e12cf000") {
+		t.Fatalf("actual selected Go preempt status object witness missing: %v\n%s", err, listing)
+	}
+	t.Logf("actual Go selected runtime object; original LLVM source remains FAILED: %v\n%s", contextFailure, listing)
+}
diff --git a/arm_symbol_memory_test.go b/arm_symbol_memory_test.go
new file mode 100644
index 000000000..f2c4836d6
--- /dev/null
+++ b/arm_symbol_memory_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func armSymbolMemoryFixture() (string, map[string]FuncSig, string, string) {
+	var source, declarations, checks, goDeclarations, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		spec := armIntegerMemorySpecs[op]
+		for _, offset := range []int{0, 1, 3, 11} {
+			for _, condition := range []string{"", ".EQ", ".NE"} {
+				load := fmt.Sprintf("symbol_load_%d", len(sigs))
+				store := fmt.Sprintf("symbol_store_%d", len(sigs))
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-4\nMOVW $0x76543210,R0\nCMP R2,R2\n%s%s ·memory+%d(SB),R0\nMOVW R0,ret+0(FP)\nRET\n", load, op, condition, offset)
+				fmt.Fprintf(&source, "TEXT %s(SB),$0-4\nMOVW value+0(FP),R0\nCMP R2,R2\n%s%s R0,·memory+%d(SB)\nRET\n", store, op, condition, offset)
+				sigs[load] = FuncSig{Name: load, Ret: I32, Frame: FrameLayout{
+					Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				}}
+				sigs[store] = FuncSig{Name: store, Args: []LLVMType{I32}, Ret: Void, Frame: FrameLayout{
+					Params: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				}}
+				fmt.Fprintf(&declarations, "extern uint32_t %s(void);\nextern void %s(uint32_t);\n", load, store)
+				fmt.Fprintf(&goDeclarations, "func %s() uint32\nfunc %s(value uint32)\n", load, store)
+				var want uint32
+				for i := 0; i < spec.bits/8; i++ {
+					want |= uint32(byte((offset+i)*13+131)) << uint(8*i)
+				}
+				if spec.signed && spec.bits == 8 {
+					want = uint32(int8(want))
+				}
+				if spec.signed && spec.bits == 16 {
+					want = uint32(int16(want))
+				}
+				if condition == ".NE" {
+					want = 0x76543210
+				}
+				fmt.Fprintf(&checks, "  reset_memory();\n  if (%s() != UINT32_C(%d)) { fprintf(stderr,\"%s load failed\\n\"); return 1; }\n  %s(UINT32_C(0xfedcba98));\n  for (unsigned i=0;i<sizeof memory;i++) { unsigned char want=(unsigned char)(i*13+131);\n", load, want, op+condition, store)
+				fmt.Fprintf(&goChecks, "resetMemory()\nif %s() != uint32(%d) { panic(\"%s Go load oracle\") }\n%s(0xfedcba98)\nfor i := range memory { want := byte(i*13+131)\n", load, want, op+condition, store)
+				if condition != ".NE" {
+					fmt.Fprintf(&checks, "    if(i>=%d && i<%d) want=(unsigned char)(UINT32_C(0xfedcba98) >> (8*(i-%d)));\n", offset, offset+spec.bits/8, offset)
+					fmt.Fprintf(&goChecks, "if i>=%d && i<%d { want=byte(uint32(0xfedcba98) >> (8*(i-%d))) }\n", offset, offset+spec.bits/8, offset)
+				}
+				fmt.Fprintf(&checks, "    if(memory[i]!=want) { fprintf(stderr,\"%s store canary failed\\n\"); return 2; }\n  }\n", op+condition)
+				fmt.Fprintf(&goChecks, "if memory[i]!=want { panic(\"%s Go store canary oracle\") }\n}\n", op+condition)
+			}
+		}
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\nunsigned char memory[80];\n" + declarations.String() +
+		"static void reset_memory(void) { for(unsigned i=0;i<sizeof memory;i++) memory[i]=(unsigned char)(i*13+131); }\nint main(void) {\n" + checks.String() + "return 0;\n}\n"
+	goMain := "package main\nvar memory [80]byte\n" + goDeclarations.String() +
+		"func resetMemory() { for i := range memory { memory[i]=byte(i*13+131) } }\nfunc main() {\n" + goChecks.String() + "}\n"
+	return source.String(), sigs, main, goMain
+}
+
+func translateARMSymbolFixture(t *testing.T, triple string) (string, string, string, string) {
+	t.Helper()
+	source, sigs, main, goMain := armSymbolMemoryFixture()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir, source, main, goMain
+}
+
+func TestARMSymbolIntegerMemorySemantics(t *testing.T) {
+	ir, _, _, _ := translateARMSymbolFixture(t, "armv7-unknown-linux-gnueabihf")
+	for _, text := range []string{"load i32, ptr @memory, align 1", "load i8, ptr", "load i16, ptr", "sext i8", "zext i8", "sext i16", "zext i16"} {
+		if !strings.Contains(ir, text) {
+			t.Fatalf("symbol memory semantics missing %q", text)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, _, _, _ := translateARMSymbolFixture(t, triple)
+		compileLLVMToObject(t, llc, triple, "arm-symbols.ll", "arm-symbols.o", ir)
+	}
+}
+
+func TestARMSymbolIntegerMemoryGrammarMatchesGoEncoder(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm/asm5.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{A(MOV\w+), C_(ADDR|REG), C_NONE, C_(ADDR|REG), (64|65|93|94),`).FindAllStringSubmatch(string(data), -1)
+	seen := make(map[string]int)
+	for _, row := range rows {
+		if row[2] == row[3] {
+			continue
+		}
+		if _, ok := armIntegerMemorySpecs[row[1]]; !ok {
+			t.Errorf("Go C_ADDR family member %s missing", row[1])
+		}
+		seen[row[1]]++
+	}
+	if len(seen) != 7 || len(seen) != len(armIntegerMemorySpecs) {
+		t.Fatalf("symbol grammar has %d mnemonics, spec has %d", len(seen), len(armIntegerMemorySpecs))
+	}
+	for op, count := range seen {
+		if count != 2 {
+			t.Errorf("%s has %d C_ADDR rows, want load and store", op, count)
+		}
+	}
+}
+
+func TestARMSymbolIntegerMemoryCompleteForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT symbolforms(SB),$0-0\nCMP R2,R2\n")
+	count := 0
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, offset := range []int{-4097, -1, 0, 1, 4097} {
+			for _, suffix := range []string{"", ".U", ".P", ".W", ".U.P", ".U.W", ".P.W", ".U.P.W", ".EQ", ".NE.P", ".EQ.U.W"} {
+				fmt.Fprintf(&source, "%s%s ·memory%+d(SB),R0\n%s%s R0,·memory%+d(SB)\n", op, suffix, offset, op, suffix, offset)
+				count += 2
+			}
+		}
+	}
+	// An address constant is not a memory load. Go only provides MOVW for
+	// this C_LCON row; narrow variants are covered by the rejection test.
+	source.WriteString("MOVW $·memory+3(SB),R0\nRET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"symbolforms": {Name: "symbolforms", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, llc, triple, "arm-symbol-forms.ll", "arm-symbol-forms.o", ir)
+	}
+	t.Logf("checked %d C_ADDR forms plus MOVW address constant", count)
+}
+
+func TestARMSymbolIntegerMemoryRejectsNonGoForms(t *testing.T) {
+	var instructions []string
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		instructions = append(instructions,
+			op+" ·memory(SB),·other(SB)",
+			op+" $0,·memory(SB)",
+			op+" R0,$·memory(SB)",
+			op+".S ·memory(SB),R0",
+		)
+		if op != "MOVW" {
+			instructions = append(instructions, op+" $·memory(SB),R0")
+		}
+	}
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT invalidsymbol(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{"invalidsymbol": {Name: "invalidsymbol", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("translator accepted %q outside Go's symbol-memory grammar", instruction)
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMSymbolMemory(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("actual ARM symbol execution is required by the Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM cross-runtime needs a Linux amd64 or arm64 driver")
+	}
+	for _, name := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(name); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", name, err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, source, main, goMain := translateARMSymbolFixture(t, triple)
+	dir := t.TempDir()
+	source = strings.ReplaceAll(source, "TEXT symbol_", "TEXT ·symbol_")
+	for name, contents := range map[string]string{
+		"go.mod": "module armsymboloracle\n\ngo 1.20\n", "main.go": goMain, "oracle_arm.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=2", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM symbol oracle: %v\n%s", err, output)
+	}
+	t.Log("native Go ARM symbol oracle passed")
+	// The object probe uses llc's static relocation model. Match it with a
+	// non-PIE executable rather than relying on the cross GCC distro default.
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "arm_symbol_memory", triple, ir, main,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_symbol_offset_context_go127_test.go b/arm_symbol_offset_context_go127_test.go
new file mode 100644
index 000000000..2eaca3e84
--- /dev/null
+++ b/arm_symbol_offset_context_go127_test.go
@@ -0,0 +1,158 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func armSymbolOffsetActualGo(t *testing.T, source string, success bool) {
+	t.Helper()
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "symbol.s"), filepath.Join(directory, "symbol.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "example.com/symbol", "-o", object, input)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm", "GOARM=5")
+	stdout, stderr, err := runtimeOracleMachineOutput(ctx, command)
+	if failure := goasmoracle.CheckOutcome(input, object, stdout, stderr,
+		err, ctx.Err(), success, 0, nil); failure != nil {
+		t.Fatalf("actual Go ARM source prior failed: %v\n%s", failure, stderr)
+	}
+}
+
+func TestARMSymbolOffsetNeedsGeneratedConstantContext(t *testing.T) {
+	// cmd/asm/internal/asm/parse.go symbolReference consumes a signed expr
+	// after the symbol; expr/term/factor use integer Go precedence, not a
+	// second symbol relocation. The generated-header identifiers below are
+	// replaced only in the independent stock-Go prior, never in the probe.
+	var instructions []string
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, suffix := range []string{"", ".EQ", ".NE.P"} {
+			instructions = append(instructions,
+				op+suffix+" ·memory+OFFSET(SB),R2",
+				op+suffix+" R2,·memory-OFFSET(SB)")
+		}
+	}
+	for _, expression := range []string{
+		"+(OFFSET+4)", "+(OFFSET*2)", "+(OFFSET/2)", "+(OFFSET%3)",
+		"+(OFFSET<<1)", "+(OFFSET>>1)", "+(OFFSET&3)", "+(OFFSET|3)",
+		"+(OFFSET^3)", "+(~OFFSET)", "+(OFFSET+'x')",
+		"+(OFFSET/(OFFSET+1))", "+(1/(OFFSET-1))", "+(OFFSET<<OFFSET)",
+	} {
+		instructions = append(instructions, "MOVW ·memory"+expression+"(SB),R2")
+	}
+	instructions = append(instructions,
+		"MOVW $·memory+OFFSET(SB),R2", "MOVW.EQ $·memory-OFFSET(SB),R2",
+		"MOVB internal∕cpu·ARM+const_offsetARMHasV7Atomics(SB),R11",
+		"MOVBU internal∕cpu·ARM+const_offsetARMHasIDIVA(SB),R11")
+	definitions := "#define OFFSET 4\n#define const_offsetARMHasV7Atomics 8\n#define const_offsetARMHasIDIVA 12\n"
+	armSymbolOffsetActualGo(t, definitions+"TEXT symbolic(SB),$0-0\n"+
+		strings.Join(instructions, "\n")+"\nRET\n", true)
+
+	for _, row := range instructions {
+		t.Run(row, func(t *testing.T) {
+			file, err := Parse(ArchARM, "TEXT symbolic(SB),$0-0\n"+row+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			original := append([]Operand(nil), instruction.Args...)
+			for _, err := range []error{
+				ProbeInstruction(ArchARM, "arm", instruction),
+				ProbeInstructionSequence(ArchARM, "arm", []Instr{instruction}),
+			} {
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("valid unresolved symbol addend lost its source context: %v", err)
+				}
+			}
+			options := Options{Goarch: "arm", TargetTriple: "armv5te-unknown-linux-gnueabi",
+				Sigs: map[string]FuncSig{"symbolic": {Name: "symbolic", Ret: Void}}}
+			if _, err := Translate(file, options); err == nil {
+				t.Error("unresolved symbol addend acquired a guessed numerical relocation")
+			}
+			module, err := TranslateModule(file, options)
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			if err == nil {
+				t.Error("unresolved symbol addend acquired a direct-module relocation")
+			}
+			if !reflect.DeepEqual(file.Funcs[0].Instrs[1].Args, original) {
+				t.Fatal("probe/translation rewrote the original unresolved symbol operand")
+			}
+		})
+	}
+}
+
+func TestARMSymbolOffsetContextDoesNotHideInvalidForms(t *testing.T) {
+	var instructions []string
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		instructions = append(instructions,
+			op+" ·memory+OFFSET(SB),SP", op+" SP,·memory+OFFSET(SB)",
+			op+".S ·memory+OFFSET(SB),R2", op+" ·memory+OFFSET(SB),·other(SB)")
+		if op != "MOVW" {
+			instructions = append(instructions, op+" $·memory+OFFSET(SB),R2")
+		}
+	}
+	instructions = append(instructions,
+		"MOVW ·memory+(OFFSET+)(SB),R2", "MOVW ·memory+(OFFSET/0)(SB),R2",
+		"MOVW ·memory+(OFFSET%0)(SB),R2", "MOVW ·memory+(OFFSET<<-1)(SB),R2",
+		"MOVW ·memory+(OFFSET<<1*2)(SB),R2", "MOVW ·memory+(OFFSET<<1<<2)(SB),R2",
+		"MOVW ·memory+((-1)/OFFSET)(SB),R2", "MOVW ·memory+((1<<63)>>OFFSET)(SB),R2",
+		"MOVW ·memory+1.5(SB),R2", "MOVW ·memory+(OFFSET==4)(SB),R2",
+		"MOVW ·memory+OFFSET(XX),R2", "MOVW ·memory+OFFSET(SB)",
+		"MOVW ·memory+OFFSET(SB),R2,R3")
+	for _, row := range instructions {
+		t.Run(row, func(t *testing.T) {
+			source := "#define OFFSET 4\nTEXT invalidsymbol(SB),$0-0\n" + row + "\nRET\n"
+			armSymbolOffsetActualGo(t, source, false)
+			file, err := Parse(ArchARM, strings.Replace(source, "#define OFFSET 4\n", "", 1))
+			if err != nil {
+				return // A real parser refusal cannot acquire an instruction role.
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			for _, err := range []error{
+				ProbeInstruction(ArchARM, "arm", instruction),
+				ProbeInstructionSequence(ArchARM, "arm", []Instr{instruction}),
+			} {
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("invalid complete operand grammar was hidden as source context: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARMSymbolOffsetConcreteFormsStayConcrete(t *testing.T) {
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, row := range []string{op + " ·memory+4(SB),R2", op + " R2,·memory-4(SB)"} {
+			t.Run(row, func(t *testing.T) {
+				file, err := Parse(ArchARM, fmt.Sprintf("TEXT concrete(SB),$0-0\n%s\nRET\n", row))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := ProbeInstruction(ArchARM, "arm", file.Funcs[0].Instrs[1]); err != nil {
+					t.Fatalf("concrete symbol displacement became unresolved: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/arm_symbol_pc_context_test.go b/arm_symbol_pc_context_test.go
new file mode 100644
index 000000000..7272d3ad4
--- /dev/null
+++ b/arm_symbol_pc_context_test.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARMSymbolMovePCRequiresRealContext(t *testing.T) {
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		for _, suffix := range []string{"", ".EQ", ".NE.P"} {
+			for _, load := range []bool{false, true} {
+				instruction := fmt.Sprintf("%s%s R15,·memory+3(SB)", op, suffix)
+				want := "source instruction layout"
+				if load {
+					instruction = fmt.Sprintf("%s%s ·memory+3(SB),R15", op, suffix)
+					want = "control-flow"
+				}
+				t.Run(instruction, func(t *testing.T) {
+					source := "TEXT pcreference(SB),$0-0\n" + instruction + "\nRET\n"
+					requireARMGoAssemblerResult(t, source, true)
+					file, err := Parse(ArchARM, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					instruction := file.Funcs[0].Instrs[1]
+					for _, err := range []error{
+						ProbeInstruction(ArchARM, "arm", instruction),
+						ProbeInstructionSequence(ArchARM, "arm", []Instr{instruction}),
+					} {
+						if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), want) {
+							t.Fatalf("symbol PC probe must preserve %s context: %v", want, err)
+						}
+					}
+					for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+						options := Options{Goarch: "arm", TargetTriple: triple,
+							Sigs: map[string]FuncSig{"pcreference": {Name: "pcreference", Ret: Void}},
+						}
+						if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), want) {
+							t.Fatalf("%s must fail closed with %s context, got %v", triple, want, err)
+						}
+						module, err := TranslateModule(file, options)
+						if err == nil {
+							module.Dispose()
+							t.Fatal("direct module translation accepted a machine-PC contract as a normal register")
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), want) {
+							t.Fatalf("direct module translation lost context failure: %v", err)
+						}
+					}
+				})
+			}
+		}
+	}
+	for _, suffix := range []string{"", ".EQ", ".NE"} {
+		instruction := "MOVW" + suffix + " $·memory+3(SB),R15"
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT addresspc(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			for _, err := range []error{
+				ProbeInstruction(ArchARM, "arm", instruction),
+				ProbeInstructionSequence(ArchARM, "arm", []Instr{instruction}),
+			} {
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "control-flow") {
+					t.Fatalf("symbol PC address probe must preserve control-flow context: %v", err)
+				}
+			}
+			for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+				options := Options{Goarch: "arm", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"addresspc": {Name: "addresspc", Ret: Void}},
+				}
+				if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "control-flow") {
+					t.Fatalf("MOVW symbol address to PC must not fall through: %v", err)
+				}
+				module, err := TranslateModule(file, options)
+				if err == nil {
+					module.Dispose()
+					t.Fatal("direct module translation accepted a symbol address to PC")
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "control-flow") {
+					t.Fatalf("direct module translation lost control-flow context: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestARMSymbolMoveRejectsPseudoRegistersExactlyLikeGo(t *testing.T) {
+	var instructions []string
+	for _, reg := range []string{"PC", "SP"} {
+		for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+			instructions = append(instructions, op+" "+reg+",·memory(SB)", op+" ·memory(SB),"+reg)
+		}
+		instructions = append(instructions, "MOVW $·memory(SB),"+reg)
+	}
+	for _, instruction := range instructions {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT pseudopc(SB),$0-0\n" + instruction + "\nRET\n"
+			requireARMGoAssemblerResult(t, source, false)
+			file, err := Parse(ArchARM, source)
+			if err != nil {
+				return
+			}
+			if err := ProbeInstruction(ArchARM, "arm", file.Funcs[0].Instrs[1]); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("Go-illegal pseudo-register must not be accepted or hidden as context: %v", err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{"pseudopc": {Name: "pseudopc", Ret: Void}},
+			}); err == nil {
+				t.Fatalf("accepted Go-illegal pseudo-register form %q", instruction)
+			}
+		})
+	}
+}
+
+func TestARMSymbolMoveKeepsHardwareSPForms(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT hardwaresp(SB),$0-0\n")
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		fmt.Fprintf(&source, "%s R13,·memory+3(SB)\n%s ·memory+3(SB),R13\n", op, op)
+	}
+	source.WriteString("MOVW $·memory+3(SB),R13\nRET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple,
+			Sigs: map[string]FuncSig{"hardwaresp": {Name: "hardwaresp", Ret: Void}},
+		})
+		if err != nil {
+			t.Fatalf("hardware R13 must remain distinct from pseudo SP: %v", err)
+		}
+		// This checks grammar and object generation only. Executing a fixture
+		// that arbitrarily overwrites the machine SP would not be a safe oracle.
+		compileLLVMToObject(t, llc, triple, "hardware-sp.ll", "hardware-sp.o", ir)
+	}
+}
diff --git a/arm_symbol_scratch_test.go b/arm_symbol_scratch_test.go
new file mode 100644
index 000000000..53fcc1def
--- /dev/null
+++ b/arm_symbol_scratch_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func armSymbolScratchFixture() (string, map[string]FuncSig, string, string) {
+	var source, cDeclarations, cChecks, goDeclarations, goChecks strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		spec := armIntegerMemorySpecs[op]
+		for _, offset := range []int{1, 3} {
+			for _, suffix := range []string{"", ".EQ", ".NE", ".P", ".W", ".U", ".EQ.U.W", ".NE.U.P"} {
+				for _, kind := range []string{"load_register", "load_scratch", "store_scratch"} {
+					// Writeback with the same base/data register is not a portable
+					// defined ARM runtime contract. Test those modifiers with R2,
+					// not R11; Go/object grammar coverage remains separate.
+					if kind != "load_register" && strings.ContainsAny(suffix, "PWU") {
+						continue
+					}
+					name := fmt.Sprintf("scratch_%d", len(sigs))
+					instruction := fmt.Sprintf("%s%s ·memory+%d(SB),R2", op, suffix, offset)
+					if kind == "load_scratch" {
+						instruction = fmt.Sprintf("%s%s ·memory+%d(SB),R11", op, suffix, offset)
+					} else if kind == "store_scratch" {
+						instruction = fmt.Sprintf("%s%s R11,·memory+%d(SB)", op, suffix, offset)
+					}
+					fmt.Fprintf(&source, `TEXT ·%s(SB),$0-4
+MOVW $0x76543210,R11
+CMP R2,R2
+%s
+MOVW R11,ret+0(FP)
+RET
+`, name, instruction)
+					sigs[name] = FuncSig{Name: name, Ret: I32, Frame: FrameLayout{
+						Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+					}}
+					fmt.Fprintf(&cDeclarations, "extern uint32_t %s(void);\n", name)
+					fmt.Fprintf(&goDeclarations, "func %s() uint32\n", name)
+					wantC := fmt.Sprintf("(uint32_t)(uintptr_t)&memory[%d]", offset)
+					wantGo := fmt.Sprintf("uint32(uintptr(unsafe.Pointer(&memory[%d])))", offset)
+					if strings.Contains(suffix, ".NE") {
+						wantC, wantGo = "UINT32_C(0x76543210)", "uint32(0x76543210)"
+					} else if kind == "load_scratch" {
+						var value uint32
+						for i := 0; i < spec.bits/8; i++ {
+							value |= uint32(byte((offset+i)*13+131)) << uint(8*i)
+						}
+						if spec.signed && spec.bits == 8 {
+							value = uint32(int8(value))
+						} else if spec.signed && spec.bits == 16 {
+							value = uint32(int16(value))
+						}
+						wantC, wantGo = fmt.Sprintf("UINT32_C(%d)", value), fmt.Sprintf("uint32(%d)", value)
+					}
+					fmt.Fprintf(&cChecks, `reset_memory();
+if (%s() != %s) { fprintf(stderr,"%s R11 mismatch\n"); return 1; }
+for (unsigned i=0; i<sizeof memory; i++) {
+  unsigned char want=(unsigned char)(i*13+131);
+`, name, wantC, name)
+					fmt.Fprintf(&goChecks, `resetMemory()
+if %s() != %s { panic("%s Go R11 mismatch") }
+for i := range memory {
+  want := byte(i*13+131)
+`, name, wantGo, name)
+					if kind == "store_scratch" && !strings.Contains(suffix, ".NE") {
+						fmt.Fprintf(&cChecks, "  if (i>=%d && i<%d) want=(unsigned char)((%s) >> (8*(i-%d)));\n", offset, offset+spec.bits/8, wantC, offset)
+						fmt.Fprintf(&goChecks, "  if i>=%d && i<%d { want=byte((%s) >> (8*(i-%d))) }\n", offset, offset+spec.bits/8, wantGo, offset)
+					}
+					fmt.Fprintf(&cChecks, "  if(memory[i]!=want) { fprintf(stderr,\"%s memory canary mismatch\\n\"); return 2; }\n}\n", name)
+					fmt.Fprintf(&goChecks, "  if memory[i]!=want { panic(\"%s Go memory canary mismatch\") }\n}\n", name)
+				}
+			}
+		}
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\nunsigned char memory[80];\n" + cDeclarations.String() + `
+static void reset_memory(void) {
+  for(unsigned i=0; i<sizeof memory; i++) memory[i]=(unsigned char)(i*13+131);
+}
+int main(void) {
+` + cChecks.String() + "return 0;\n}\n"
+	goMain := "package main\nimport \"unsafe\"\nvar memory [80]byte\n" + goDeclarations.String() + `
+func resetMemory() { for i := range memory { memory[i]=byte(i*13+131) } }
+func main() {
+` + goChecks.String() + "}\n"
+	return source.String(), sigs, main, goMain
+}
+
+func translateARMSymbolScratchFixture(t *testing.T, triple string) (string, string, string, string) {
+	t.Helper()
+	source, sigs, main, goMain := armSymbolScratchFixture()
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs,
+		ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir, source, main, goMain
+}
+
+func TestARMSymbolScratchCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		ir, _, _, _ := translateARMSymbolScratchFixture(t, triple)
+		compileLLVMToObject(t, llc, triple, "arm-scratch.ll", "arm-scratch.o", ir)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMSymbolScratch(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("actual ARM scratch execution is required by the Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Fatal("ARM cross-runtime needs a Linux amd64 or arm64 driver")
+	}
+	for _, name := range []string{"arm-linux-gnueabihf-gcc", "qemu-arm"} {
+		if _, err := exec.LookPath(name); err != nil {
+			t.Fatalf("required cross-runtime tool %s: %v", name, err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const triple = "armv7-unknown-linux-gnueabihf"
+	ir, source, main, goMain := translateARMSymbolScratchFixture(t, triple)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module armscratchoracle\n\ngo 1.20\n", "main.go": goMain, "oracle_arm.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.Command("go", "run", "-p=2", "-exec=qemu-arm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0")
+	if output, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("native Go ARM scratch oracle: %v\n%s", err, output)
+	}
+	t.Log("native Go ARM scratch oracle passed")
+	compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"}, "arm_scratch_memory", triple, ir, main,
+		[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"})
+}
diff --git a/arm_translate.go b/arm_translate.go
index 28571a305..2e3545d3c 100644
--- a/arm_translate.go
+++ b/arm_translate.go
@@ -6,6 +6,17 @@ func emitARMPrelude(b *strings.Builder) {
 	b.WriteString("declare i64 @syscall(i64, i64, i64, i64, i64, i64, i64)\n")
 	b.WriteString("declare i32 @llvm.fshr.i32(i32, i32, i32)\n")
 	b.WriteString("declare i32 @llvm.ctlz.i32(i32, i1)\n")
+	b.WriteString("declare i32 @llvm.bitreverse.i32(i32)\n")
+	b.WriteString("declare i32 @llvm.bswap.i32(i32)\n")
+	b.WriteString("declare i16 @llvm.bswap.i16(i16)\n")
+	for _, name := range []string{"ssat", "usat", "ssat16", "usat16"} {
+		b.WriteString("declare i32 @llvm.arm." + name + "(i32, i32)\n")
+	}
+	b.WriteString("declare float @llvm.fabs.f32(float)\n")
+	b.WriteString("declare double @llvm.fabs.f64(double)\n")
+	b.WriteString("declare float @llvm.sqrt.f32(float)\n")
+	b.WriteString("declare double @llvm.sqrt.f64(double)\n")
+	b.WriteString("declare void @llvm.prefetch.p0(ptr, i32, i32, i32)\n")
 	b.WriteString("\n")
 }
 
diff --git a/arm_translate_cfg.go b/arm_translate_cfg.go
index f1f7923b2..ab84c5524 100644
--- a/arm_translate_cfg.go
+++ b/arm_translate_cfg.go
@@ -1,11 +1,32 @@
 package plan9asm
 
 import (
+	"errors"
 	"fmt"
 	"strings"
 )
 
 func translateFuncARM(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, annotateSource bool) error {
+	for _, ins := range fn.Instrs {
+		if _, _, err := parseARMStatusMove(ins); err != nil {
+			return err // Validate even source-dead status operands before CFG proof.
+		}
+		op, _, _, _ := armDecodeOp(string(ins.Op))
+		if _, move := armIntegerMemorySpecs[op]; !move {
+			continue
+		}
+		for _, source := range ins.Args {
+			if source.Kind == OpSym && strings.HasSuffix(strings.TrimSpace(source.Sym), "(SB)") {
+				if _, err := parseARMIntegerSymbolForm(op, ins); err != nil {
+					return err // Preserve source grammar/PC failures before flags-context proof.
+				}
+				break
+			}
+		}
+	}
+	if err := proveARMStatusReads(fn, sig); err != nil {
+		return err
+	}
 	fmt.Fprintf(b, "define %s %s(", sig.Ret, llvmGlobal(sig.Name))
 	for i, t := range sig.Args {
 		if i > 0 {
@@ -20,6 +41,10 @@ func translateFuncARM(b *strings.Builder, fn Func, sig FuncSig, resolve func(str
 	b.WriteString(" {\n")
 
 	c := newARMCtx(b, fn, sig, resolve, sigs, annotateSource)
+	// The source proof above establishes initialization at each flag use,
+	// including a read block emitted before its backward-edge predecessor.
+	// This boolean selects the modeled representation, not initial NZCV.
+	c.flagsWritten = armFunctionUsesModeledFlags(fn)
 	if err := c.emitEntryAllocasAndArgInit(); err != nil {
 		return err
 	}
@@ -54,7 +79,7 @@ func (c *armCtx) lowerBlocks() error {
 			c.emitSourceComment(ins)
 			term, err := c.lowerInstr(bi, ins, emitBr, emitCondBr)
 			if err != nil {
-				return err
+				return fmt.Errorf("%s: %w", ins.Raw, err)
 			}
 			if term {
 				terminated = true
@@ -74,11 +99,22 @@ func (c *armCtx) lowerBlocks() error {
 }
 
 func (c *armCtx) lowerInstr(bi int, ins Instr, emitBr armEmitBr, emitCondBr armEmitCondBr) (bool, error) {
+	if form, matched, err := parseARMStatusMove(ins); matched {
+		if err != nil {
+			return false, err
+		}
+		return false, c.lowerStatusMove(form)
+	}
+	if ins.armKernelCall != nil {
+		return c.lowerKernelHelperCall(*ins.armKernelCall)
+	}
 	rawOp := strings.ToUpper(string(ins.Op))
 	baseOp, cond, postInc, setFlags := armDecodeOp(rawOp)
 	switch baseOp {
-	case string(OpTEXT), string(OpBYTE):
+	case string(OpTEXT):
 		return false, nil
+	case string(OpBYTE):
+		return false, fmt.Errorf("arm BYTE cannot be lowered safely as a partial machine instruction: %q", ins.Raw)
 	case string(OpRET):
 		if len(ins.Args) == 1 && ins.Args[0].Kind == OpSym && strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
 			return true, c.tailCallAndRet(ins.Args[0])
@@ -91,20 +127,58 @@ func (c *armCtx) lowerInstr(bi int, ins Instr, emitBr armEmitBr, emitCondBr armE
 		c.b.WriteString("  call void asm sideeffect \"udf #0\", \"~{memory}\"()\n")
 		c.b.WriteString("  unreachable\n")
 		return true, nil
+	case "CLREX":
+		if len(ins.Args) != 0 {
+			return false, fmt.Errorf("arm CLREX expects no operands: %q", ins.Raw)
+		}
+		// Preserve the architectural instruction for LLVM while also clearing
+		// the translator's modeled exclusive monitor used by STREX lowering.
+		c.b.WriteString("  call void asm sideeffect \"clrex\", \"~{memory}\"()\n")
+		fmt.Fprintf(c.b, "  store i1 false, ptr %s\n", c.exclusiveValidSlot)
+		return false, nil
 	case "MOVM":
 		if ok, term, err := c.lowerMOVM(rawOp, ins); ok {
 			return term, err
 		}
 		return false, fmt.Errorf("arm: unsupported instruction %s", ins.Op)
-	case "PCDATA", "FUNCDATA", "NO_LOCAL_POINTERS", string(OpWORD), "NOP", "DMB", "#IFDEF", "#ELSE", "#ENDIF":
+	case string(OpWORD):
+		if form, ok := decodeARMRawDataForm(ins); ok {
+			return false, form.lower(c)
+		}
+		if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+			if form, ok := decodeARMRawVFPStatusTransfer(uint32(ins.Args[0].Imm)); ok {
+				return false, c.lowerRawVFPStatusTransfer(form)
+			}
+		}
+		if handled, err := c.lowerRawWord(ins); handled {
+			return false, err
+		}
+		decoded, err := decodeARMRawWordInstruction(ins)
+		if err != nil {
+			if errors.Is(err, ErrProbeNeedsContext) || strings.Contains(err.Error(), "PC-relative") {
+				return false, err
+			}
+			return false, fmt.Errorf("arm WORD cannot be lowered safely because its encoding is unsupported: %q", ins.Raw)
+		}
+		return c.lowerInstr(bi, decoded, emitBr, emitCondBr)
+	case "PCDATA", "FUNCDATA", "NO_LOCAL_POINTERS", "NOP", "DMB", "END", "#IFDEF", "#ELSE", "#ENDIF":
 		return false, nil
 	}
 	if ok, term, err := c.lowerData(baseOp, cond, postInc, ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerPreload(baseOp, cond, ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerArith(baseOp, cond, setFlags, ins); ok {
 		return term, err
 	}
+	if ok, term, err := c.lowerFloat(baseOp, cond, ins); ok {
+		return term, err
+	}
+	if ok, term, err := c.lowerSaturation(baseOp, cond, ins); ok {
+		return term, err
+	}
 	if ok, term, err := c.lowerAtomic(baseOp, ins); ok {
 		return term, err
 	}
@@ -118,6 +192,9 @@ func (c *armCtx) lowerInstr(bi int, ins Instr, emitBr armEmitBr, emitCondBr armE
 }
 
 func (c *armCtx) lowerRET() error {
+	if c.machineState != "" {
+		return c.returnMachineState()
+	}
 	if len(c.fpResults) == 0 {
 		r0, err := c.loadReg(Reg("R0"))
 		if err != nil {
@@ -132,6 +209,20 @@ func (c *armCtx) lowerRET() error {
 			fmt.Fprintf(c.b, "  ret %s %%%s\n", c.sig.Ret, t)
 		case I32:
 			fmt.Fprintf(c.b, "  ret i32 %s\n", r0)
+		case I64:
+			r1, err := c.loadReg(Reg("R1"))
+			if err != nil {
+				return err
+			}
+			lo := c.newTmp()
+			hi := c.newTmp()
+			shifted := c.newTmp()
+			joined := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", lo, r0)
+			fmt.Fprintf(c.b, "  %%%s = zext i32 %s to i64\n", hi, r1)
+			fmt.Fprintf(c.b, "  %%%s = shl i64 %%%s, 32\n", shifted, hi)
+			fmt.Fprintf(c.b, "  %%%s = or i64 %%%s, %%%s\n", joined, lo, shifted)
+			fmt.Fprintf(c.b, "  ret i64 %%%s\n", joined)
 		case Ptr:
 			t := c.newTmp()
 			fmt.Fprintf(c.b, "  %%%s = inttoptr i32 %s to ptr\n", t, r0)
@@ -206,11 +297,7 @@ func (c *armCtx) lowerRetZero() {
 	switch c.sig.Ret {
 	case Void:
 		c.b.WriteString("  ret void\n")
-	case I1:
-		c.b.WriteString("  ret i1 false\n")
-	case Ptr:
-		c.b.WriteString("  ret ptr null\n")
 	default:
-		fmt.Fprintf(c.b, "  ret %s 0\n", c.sig.Ret)
+		fmt.Fprintf(c.b, "  ret %s %s\n", c.sig.Ret, llvmZeroValue(c.sig.Ret))
 	}
 }
diff --git a/arm_translate_test.go b/arm_translate_test.go
index 3dddd0669..658314a27 100644
--- a/arm_translate_test.go
+++ b/arm_translate_test.go
@@ -8,7 +8,8 @@ import (
 func TestTranslateARMLinearAdd(t *testing.T) {
 	file, err := Parse(ArchARM, `TEXT ·Add(SB),NOSPLIT,$0-12
 	MOVW	a+0(FP), R0
-	ADD	b+4(FP), R0
+	MOVW	b+4(FP), R1
+	ADD	R1, R0
 	MOVW	R0, ret+8(FP)
 	RET
 `)
@@ -113,6 +114,8 @@ TEXT ·spin(SB),NOSPLIT,$0-0
 
 func TestTranslateARMSystemRegisterMoves(t *testing.T) {
 	ll := translateARMForTest(t, `TEXT ·systemregs(SB),NOSPLIT,$0-0
+	MOVW $0,R0
+	CMP R0,R0
 	MOVW CPSR, R0
 	MOVW R0, CPSR
 	MOVW FPCR, R1
@@ -121,7 +124,7 @@ func TestTranslateARMSystemRegisterMoves(t *testing.T) {
 `, map[string]FuncSig{"example.systemregs": {Name: "example.systemregs", Ret: Void}})
 	for _, want := range []string{
 		"mrs $0, cpsr",
-		"msr cpsr_fsxc, $0",
+		"msr cpsr_fs, $0",
 		"vmrs $0, fpscr",
 		"vmsr fpscr, $0",
 	} {
diff --git a/arm_word_float_form.go b/arm_word_float_form.go
new file mode 100644
index 000000000..aaacb723c
--- /dev/null
+++ b/arm_word_float_form.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type armConversionRegisterKind uint8
+
+const (
+	armConversionInvalid armConversionRegisterKind = iota
+	armConversionFloat
+	armConversionSingle
+	armConversionCore
+)
+
+type armConversionRegister struct {
+	kind   armConversionRegisterKind
+	reg    Reg
+	single int
+}
+
+type armWordFloatConversionForm struct {
+	wordToFloat bool
+	floatBits   int
+	unsigned    bool
+	source      armConversionRegister
+	destination armConversionRegister
+}
+
+// Go's asm5 rows 84/85 are one native VCVT; rows 86/87 expand through
+// FREGTMP (F15/S30). This effect belongs to the parsed operand form, not to
+// the mnemonic alone. Raw S-register VCVT instructions have no such macro.
+func (form armWordFloatConversionForm) usesScratch() bool {
+	return form.source.kind == armConversionCore || form.destination.kind == armConversionCore
+}
+
+func parseARMWordFloatConversion(op string, ins Instr) (armWordFloatConversionForm, bool, error) {
+	form := armWordFloatConversionForm{}
+	switch op {
+	case "MOVWF", "MOVWD", "MOVFW", "MOVDW":
+	default:
+		return form, false, nil
+	}
+	unsigned, err := armWordFloatConversionUnsigned(ins)
+	if err != nil {
+		return form, true, err
+	}
+	if len(ins.Args) != 2 {
+		return form, true, fmt.Errorf("arm %s expects exactly 2 operands: %q", op, ins.Raw)
+	}
+	form.wordToFloat = strings.HasPrefix(op, "MOVW")
+	form.floatBits = 32
+	if strings.Contains(op, "D") {
+		form.floatBits = 64
+	}
+	form.unsigned = unsigned
+	// Only decoder-produced raw VCVT spellings can name S0..S31. Go source
+	// still requires F0..F15; sharing physical storage grants no source form.
+	rawSingles := strings.Contains(ins.Raw, "decoded from WORD")
+	register := func(operand Operand) armConversionRegister {
+		if operand.Kind == OpReg {
+			if isARMFReg(operand.Reg) {
+				return armConversionRegister{kind: armConversionFloat, reg: operand.Reg}
+			}
+			if isARMGeneralReg(operand.Reg) {
+				return armConversionRegister{kind: armConversionCore, reg: operand.Reg}
+			}
+		}
+		if number, ok := armSingleOperandNumber(operand); rawSingles && ok {
+			return armConversionRegister{kind: armConversionSingle, single: number}
+		}
+		return armConversionRegister{}
+	}
+	form.source, form.destination = register(ins.Args[0]), register(ins.Args[1])
+	floatRegister := func(operand armConversionRegister) bool {
+		return operand.kind == armConversionFloat || form.floatBits == 32 && operand.kind == armConversionSingle
+	}
+	wordRegister := func(operand armConversionRegister) bool {
+		return operand.kind == armConversionFloat || operand.kind == armConversionSingle || operand.kind == armConversionCore
+	}
+	if form.wordToFloat {
+		if !wordRegister(form.source) || !floatRegister(form.destination) {
+			return form, true, fmt.Errorf("arm %s expects R/F word source and F destination: %q", op, ins.Raw)
+		}
+	} else if !floatRegister(form.source) || !wordRegister(form.destination) {
+		return form, true, fmt.Errorf("arm %s expects F source and R/F word destination: %q", op, ins.Raw)
+	}
+	return form, true, nil
+}
diff --git a/arm_word_float_form_test.go b/arm_word_float_form_test.go
new file mode 100644
index 000000000..d65d715b5
--- /dev/null
+++ b/arm_word_float_form_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestARMWordFloatGrammarSharesExactScratchInventory(t *testing.T) {
+	for _, fixture := range armFloatConversionEffectCases() {
+		t.Run(strings.ReplaceAll(fixture.instruction, " ", "_"), func(t *testing.T) {
+			file, err := Parse(ArchARM, "TEXT conversion(SB),4,$0-0\nCMP R0,R0\n"+fixture.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[2] // TEXT, CMP, conversion, RET.
+			op, _, _, _ := armDecodeOp(string(ins.Op))
+			form, handled, err := parseARMWordFloatConversion(op, ins)
+			if err != nil || !handled {
+				t.Fatalf("valid Go conversion rejected: handled=%v, err=%v", handled, err)
+			}
+			wantScratch := strings.Contains(fixture.instruction, "R2")
+			if form.usesScratch() != wantScratch {
+				t.Fatalf("scratch=%v want %v", form.usesScratch(), wantScratch)
+			}
+			ir, err := Translate(file, Options{
+				Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+				Sigs: map[string]FuncSig{"conversion": {Name: "conversion", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantAllocation := wantScratch || strings.Contains(fixture.instruction, "F15")
+			if strings.Contains(ir, "%freg_F15 = alloca i64") != wantAllocation {
+				t.Fatalf("F15 allocation disagrees with typed effect, want %v:\n%s", wantAllocation, ir)
+			}
+		})
+	}
+}
+
+func TestARMWordFloatGrammarKeepsRawSingleInstructionsDistinct(t *testing.T) {
+	for _, word := range []uint32{0xeef80aee, 0xeeb81a4f, 0xeefd1aef, 0xeebc2ac0} {
+		ins, err := decodeARMRawWordInstruction(Instr{
+			Op: OpWORD, Args: []Operand{{Kind: OpImm, Imm: int64(word)}}, Raw: fmt.Sprintf("WORD $%#x", word),
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		op, _, _, _ := armDecodeOp(string(ins.Op))
+		form, handled, err := parseARMWordFloatConversion(op, ins)
+		if err != nil || !handled || form.usesScratch() {
+			t.Fatalf("raw %#x acquired a Go macro effect: %+v, %v", word, form, err)
+		}
+		if form.source.kind == armConversionSingle || form.destination.kind == armConversionSingle {
+			ins.Raw = "source spelling without decoder provenance"
+			if _, _, err := parseARMWordFloatConversion(op, ins); err == nil {
+				t.Fatalf("source Go spelling accepted decoder-only S registers: %#x", word)
+			}
+		} else if form.source.kind != armConversionFloat || form.destination.kind != armConversionFloat {
+			// The architectural decoder may spell two even halves with their
+			// exact Go F aliases. Neither spelling introduces a core-register macro.
+			t.Fatalf("raw %#x lost its physical floating operands: %+v", word, form)
+		}
+	}
+}
+
+func TestARMWordFloatGrammarRejectsAdjacentOperandAndSuffixClasses(t *testing.T) {
+	rejectARMFormsOutsideGo127Optabs(t, []string{
+		"MOVWF S0,F1", "MOVWD S0,F1", "MOVFW F0,S1", "MOVDW F0,S1",
+		"MOVWF F16,F0", "MOVWD R16,F0", "MOVFW F0,F16", "MOVDW F0,R16",
+		"MOVWF $1,F0", "MOVWD symbol(SB),F0", "MOVFW F0,result+0(FP)",
+		"MOVDW F0,(R0)", "MOVWF.P R0,F0", "MOVWD.W R0,F0",
+		"MOVFW.S F0,R0", "MOVDW.PW F0,R0",
+	})
+}
diff --git a/arm_word_float_matrix_runtime_linux_test.go b/arm_word_float_matrix_runtime_linux_test.go
new file mode 100644
index 000000000..311cb2697
--- /dev/null
+++ b/arm_word_float_matrix_runtime_linux_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type armConversionMatrixRow struct {
+	function int
+	input    [8]uint32
+}
+
+func armConversionMatrixOriginal(forms []armConversionMatrixForm, rows []armConversionMatrixRow) string {
+	var source strings.Builder
+	source.WriteString("package main\nimport (\"bufio\"; \"fmt\"; \"os\")\n")
+	for index := range forms {
+		fmt.Fprintf(&source, "func matrix%d(input *[8]uint32, output *[10]uint32)\n", index)
+	}
+	source.WriteString("var functions = [...]func(*[8]uint32,*[10]uint32){\n")
+	for index := range forms {
+		fmt.Fprintf(&source, "matrix%d,\n", index)
+	}
+	source.WriteString("}\nvar rows = []struct { function int; input [8]uint32 }{\n")
+	for _, row := range rows {
+		fmt.Fprintf(&source, "{%d,[8]uint32{", row.function)
+		for _, value := range row.input {
+			fmt.Fprintf(&source, "%#x,", value)
+		}
+		source.WriteString("}},\n")
+	}
+	source.WriteString(`}
+func main() {
+    writer := bufio.NewWriter(os.Stdout)
+    for _, row := range rows {
+        out := [10]uint32{0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,
+            0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0x12345678,0x87654321}
+        functions[row.function](&row.input,&out)
+        for _, value := range out { fmt.Fprintf(writer,"%08x",value) }
+        fmt.Fprintln(writer)
+    }
+    if err := writer.Flush(); err != nil { panic(err) }
+}
+`)
+	return source.String()
+}
+
+func armConversionMatrixDriver(t *testing.T, forms []armConversionMatrixForm, rows []armConversionMatrixRow, original []byte) string {
+	t.Helper()
+	// One fixed-size record per input, with no hashes or partial observations.
+	// The final two words are untouched neighboring-memory canaries.
+	if len(original) != len(rows)*81 {
+		t.Fatalf("original Go observation extent: got %d bytes, want %d", len(original), len(rows)*81)
+	}
+	var source strings.Builder
+	source.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for index := range forms {
+		fmt.Fprintf(&source, "extern void matrix%d(uint32_t*,uint32_t*);\n", index)
+	}
+	source.WriteString("static void (*functions[])(uint32_t*,uint32_t*)={\n")
+	for index := range forms {
+		fmt.Fprintf(&source, "matrix%d,\n", index)
+	}
+	source.WriteString("};\nstatic const struct { unsigned function; uint32_t input[8], want[10]; } rows[]={\n")
+	for index, row := range rows {
+		fmt.Fprintf(&source, "{%d,{", row.function)
+		for _, value := range row.input {
+			fmt.Fprintf(&source, "%#x,", value)
+		}
+		source.WriteString("},{")
+		line := string(original[index*81 : (index+1)*81])
+		if line[80] != '\n' {
+			t.Fatalf("unterminated original Go observation %d", index)
+		}
+		for word := 0; word < 10; word++ {
+			value, err := strconv.ParseUint(line[word*8:(word+1)*8], 16, 32)
+			if err != nil {
+				t.Fatalf("original Go row %d word %d: %v", index, word, err)
+			}
+			if word == 8 && value != 0x12345678 || word == 9 && value != 0x87654321 {
+				t.Fatalf("original Go row %d corrupted neighbor %d: %#x", index, word, value)
+			}
+			fmt.Fprintf(&source, "%#x,", value)
+		}
+		source.WriteString("}},\n")
+	}
+	source.WriteString(`};
+int main(void) {
+    unsigned failures = 0;
+    for (unsigned row=0; row<sizeof(rows)/sizeof(rows[0]); row++) {
+        uint32_t input[8];
+        for (unsigned word=0; word<8; word++) input[word]=rows[row].input[word];
+        uint32_t out[10]={0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,
+            0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0x12345678,0x87654321};
+        functions[rows[row].function](input,out);
+        for (unsigned word=0; word<10; word++) {
+            if (out[word] != rows[row].want[word]) {
+                if (failures<20) fprintf(stderr,"row %u function %u word %u got %08x want %08x\n",
+                    row,rows[row].function,word,out[word],rows[row].want[word]);
+                failures++;
+            }
+        }
+    }
+    printf("ARM_CONVERSION_MATRIX rows=%zu failures=%u\n",sizeof(rows)/sizeof(rows[0]),failures);
+    return failures != 0;
+}
+`)
+	return source.String()
+}
+
+func runARMConversionMatrix(t *testing.T, forms []armConversionMatrixForm, rows []armConversionMatrixRow) {
+	t.Helper()
+	llc := requireARMScalarRuntime(t)
+	source, sigs := armConversionMatrixSource(forms)
+	original := armConversionGoObservations(t, source, armConversionMatrixOriginal(forms, rows))
+	driver := armConversionMatrixDriver(t, forms, rows, original)
+	t.Logf("actual original Go: %d forms, %d result/FPSCR/full-register/canary rows", len(forms), len(rows))
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"unoptimized", ir}, {"optimized", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+					"arm_conversion_matrix", "armv7-unknown-linux-gnueabihf", variant.ir, driver,
+					[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+				t.Logf("LLVM22 matched original Go: %d rows, %d observed words", len(rows), len(rows)*10)
+			})
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMWordFloatAllPhysicalEndpoints(t *testing.T) {
+	forms := armConversionRawMatrixForms()
+	var rows []armConversionMatrixRow
+	for index, form := range forms {
+		values := []uint64{0x01000001, 0xfeffffff}
+		if !form.toFloat {
+			values = []uint64{0x3fc00000, 0x7fc12345}
+			if form.double {
+				values = []uint64{0x3ff8000000000000, 0x7ff8123456789abc}
+			}
+		}
+		for i, bits := range values {
+			control := uint32(i)<<22 | 0xa0000000 // Keep native NZCV canaries.
+			rows = append(rows, armConversionMatrixRow{index, armConversionMatrixInput(form, bits, control)})
+		}
+	}
+	runARMConversionMatrix(t, forms, rows)
+}
+
+func TestCrossLinuxRuntimeMatrixARMWordFloatDynamicStatus(t *testing.T) {
+	forms := armConversionStatusMatrixForms()
+	if len(forms) != 56 {
+		t.Fatalf("incomplete R/F/S and conditional status matrix: %d", len(forms))
+	}
+	var rows []armConversionMatrixRow
+	for index, form := range forms {
+		for _, bits := range armConversionStatusMatrixValues(form) {
+			for rounding := 0; rounding < 4; rounding++ {
+				for flush := 0; flush < 2; flush++ {
+					for defaultNaN := 0; defaultNaN < 2; defaultNaN++ {
+						control := uint32(rounding)<<22 | uint32(flush)<<24 | uint32(defaultNaN)<<25 | 0xa0000000
+						// Seed an unrelated cumulative exception on half the rows.
+						// Newly raised IOC/IXC/IDC must not erase it.
+						if rounding&1 != 0 {
+							control |= 2
+						}
+						rows = append(rows, armConversionMatrixRow{index, armConversionMatrixInput(form, bits, control)})
+					}
+				}
+			}
+		}
+	}
+	runARMConversionMatrix(t, forms, rows)
+}
diff --git a/arm_word_float_matrix_test.go b/arm_word_float_matrix_test.go
new file mode 100644
index 000000000..a6f5238c8
--- /dev/null
+++ b/arm_word_float_matrix_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These independent fixtures use the eight encodings in Arm DDI0406C.c
+// A8.8.306, not the translator's decoder or its typed conversion specification.
+type armConversionMatrixForm struct {
+	instruction string
+	toFloat     bool
+	double      bool
+	sourceD     int
+	targetD     int
+	sourceHalf  int
+	coreSource  bool
+}
+
+func armConversionRawMatrixWord(toFloat, double, unsigned bool, word, floating int) uint32 {
+	encoding := uint32(0xeeb80ac0) // VCVT.F32.S32 Sd,Sm.
+	source, destination := word, floating
+	if !toFloat {
+		encoding = 0xeebd0ac0 // VCVT.S32.F32 Sd,Sm.
+		source, destination = floating, word
+		if unsigned {
+			encoding &^= 1 << 16
+		}
+	} else if unsigned {
+		encoding &^= 1 << 7
+	}
+	if double {
+		encoding |= 1 << 8
+	}
+	if double && !toFloat {
+		encoding |= uint32(source)
+	} else {
+		encoding |= uint32(source/2) | uint32(source%2)<<5
+	}
+	if double && toFloat {
+		encoding |= uint32(destination) << 12
+	} else {
+		encoding |= uint32(destination/2)<<12 | uint32(destination%2)<<22
+	}
+	return encoding
+}
+
+func armConversionRawMatrixForms() []armConversionMatrixForm {
+	var forms []armConversionMatrixForm
+	for _, toFloat := range []bool{false, true} {
+		for _, double := range []bool{false, true} {
+			for _, unsigned := range []bool{false, true} {
+				for word := 0; word < 32; word++ {
+					// Same physical register (both S halves for F64), and a
+					// disjoint register. Every word S and every float S/D occurs.
+					for _, disjoint := range []bool{false, true} {
+						floating := word
+						if double {
+							floating /= 2
+						}
+						if disjoint {
+							if double {
+								floating = (floating + 7) % 16
+							} else {
+								floating = (floating + 15) % 32
+							}
+						}
+						form := armConversionMatrixForm{toFloat: toFloat, double: double}
+						floatD, floatHalf := floating/2, floating%2
+						if double {
+							floatD, floatHalf = floating, 0
+						}
+						form.sourceD, form.sourceHalf, form.targetD = floatD, floatHalf, word/2
+						if toFloat {
+							form.sourceD, form.sourceHalf, form.targetD = word/2, word%2, floatD
+						}
+						encoding := armConversionRawMatrixWord(toFloat, double, unsigned, word, floating)
+						form.instruction = fmt.Sprintf("WORD $%#x", encoding)
+						forms = append(forms, form)
+					}
+				}
+			}
+		}
+	}
+	return forms
+}
+
+func armConversionStatusMatrixForms() []armConversionMatrixForm {
+	var forms []armConversionMatrixForm
+	for _, op := range []string{"MOVFW", "MOVDW", "MOVWF", "MOVWD"} {
+		for _, unsigned := range []bool{false, true} {
+			for _, core := range []bool{false, true} {
+				for _, condition := range []string{"", ".EQ", ".NE"} {
+					form := armConversionMatrixForm{
+						toFloat: strings.HasPrefix(op, "MOVW"), double: strings.Contains(op, "D"),
+						sourceD: 0, targetD: 1,
+					}
+					source, target, suffix := "F0", "F1", condition
+					if unsigned {
+						suffix = ".U" + suffix
+					}
+					if core && form.toFloat {
+						source, form.coreSource = "R2", true
+					} else if core {
+						target = "R2"
+					}
+					form.instruction = fmt.Sprintf("%s%s %s,%s", op, suffix, source, target)
+					forms = append(forms, form)
+				}
+			}
+			// Odd raw S word and F32 endpoints: the word and float widths
+			// must be interpreted separately even for a double conversion.
+			form := armConversionMatrixForm{
+				toFloat: strings.HasPrefix(op, "MOVW"), double: strings.Contains(op, "D"),
+				sourceD: 0, targetD: 1, sourceHalf: 1,
+			}
+			word, floating := 3, 1
+			if form.toFloat {
+				word, floating = 1, 3
+				if form.double {
+					floating = 1
+				}
+			} else if form.double {
+				floating, form.sourceHalf = 0, 0
+			}
+			form.instruction = fmt.Sprintf("WORD $%#x", armConversionRawMatrixWord(form.toFloat, form.double, unsigned, word, floating))
+			forms = append(forms, form)
+		}
+	}
+	return forms
+}
+
+func armConversionMatrixSource(forms []armConversionMatrixForm) (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig, len(forms))
+	for index, form := range forms {
+		name := fmt.Sprintf("matrix%d", index)
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-8
+MOVW input+0(FP),R0
+MOVW output+4(FP),R1
+MOVD 16(R0),F15
+MOVD 8(R0),F%d
+MOVD 0(R0),F%d
+MOVW 24(R0),R2
+WORD $0xeef14a10 // VMRS R4,FPSCR: preserve the actual caller state.
+MOVW 28(R0),R3
+WORD $0xeee13a10 // VMSR FPSCR,R3.
+CMP R2,R2
+%s
+WORD $0xeef13a10 // VMRS R3,FPSCR: observe before restoring it.
+WORD $0xeee14a10 // VMSR FPSCR,R4.
+MOVD F%d,0(R1)
+MOVD F%d,8(R1)
+MOVD F15,16(R1)
+MOVW R2,24(R1)
+MOVW R3,28(R1)
+RET
+`, name, form.targetD, form.sourceD, form.instruction, form.sourceD, form.targetD)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 4, Type: Ptr, Index: 1, Field: -1},
+			}},
+		}
+	}
+	return source.String(), sigs
+}
+
+func armConversionMatrixInput(form armConversionMatrixForm, bits uint64, control uint32) [8]uint32 {
+	input := [8]uint32{0x12345678, 0x87654321, 0x10203040, 0x50607080, 0x11223344, 0x55667788, 0xfedcba98, control}
+	if form.coreSource {
+		input[6] = uint32(bits)
+	} else if form.double && !form.toFloat {
+		input[0], input[1] = uint32(bits), uint32(bits>>32)
+	} else {
+		input[form.sourceHalf] = uint32(bits)
+	}
+	return input
+}
+
+func armConversionStatusMatrixValues(form armConversionMatrixForm) []uint64 {
+	if form.toFloat {
+		return []uint64{0, 1, 0xffffffff, 0x80000000, 0x7fffffff, 0x00ffffff,
+			0x01000000, 0x01000001, 0xfeffffff, 0x80000001, 0xffffff00}
+	}
+	if !form.double {
+		return []uint64{0, 0x80000000, 0x3fc00000, 0xbfc00000, 0x3f000000, 0xbf000000,
+			0x4effffff, 0x4f000000, 0xcf000000, 0xcf000001, 0x4f7fffff, 0x4f800000,
+			0x7f800000, 0xff800000, 0x7fc12345, 0xffc12345, 0x7f812345, 0xff812345,
+			1, 0x80000001, 0x007fffff, 0x807fffff, 0x00800000, 0x80800000}
+	}
+	return []uint64{0, 0x8000000000000000, 0x3ff8000000000000, 0xbff8000000000000,
+		0x3fe0000000000000, 0xbfe0000000000000, 0x41dfffffffc00000, 0x41e0000000000000,
+		0xc1e0000000000000, 0xc1e0000000200000, 0x41efffffffe00000, 0x41f0000000000000,
+		0x7ff0000000000000, 0xfff0000000000000, 0x7ff8123456789abc, 0xfff8123456789abc,
+		0x7ff0123456789abc, 0xfff0123456789abc, 1, 0x8000000000000001,
+		0x000fffffffffffff, 0x800fffffffffffff, 0x0010000000000000, 0x8010000000000000}
+}
+
+func TestARMWordFloatRawPhysicalEndpointMatrix(t *testing.T) {
+	forms := armConversionRawMatrixForms()
+	if len(forms) != 8*32*2 {
+		t.Fatalf("incomplete eight-opcode / full-S-bank / alias matrix: %d", len(forms))
+	}
+	seen := make(map[string]bool, len(forms))
+	for _, form := range forms {
+		if seen[form.instruction] {
+			t.Fatalf("duplicate encoding: %s", form.instruction)
+		}
+		seen[form.instruction] = true
+	}
+	source, sigs := armConversionMatrixSource(forms)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: sigs})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm-conversion-endpoints.ll", "arm-conversion-endpoints.o", ir)
+		})
+	}
+}
+
+func TestARMWordFloatRawPhysicalMatrixDoesNotGrantSourceSingles(t *testing.T) {
+	for single := 0; single < 32; single++ {
+		for _, op := range []string{"MOVFW", "MOVDW", "MOVWF", "MOVWD"} {
+			for _, pair := range [][2]string{
+				{fmt.Sprintf("S%d", single), "F0"}, {"F0", fmt.Sprintf("S%d", single)},
+			} {
+				body := fmt.Sprintf("%s %s,%s", op, pair[0], pair[1])
+				file, err := Parse(ArchARM, "TEXT conversion(SB),4,$0-0\n"+body+"\nRET\n")
+				if err != nil {
+					continue
+				}
+				if _, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf"}); err == nil {
+					t.Fatalf("decoder-only S endpoint leaked to named source: %s", body)
+				}
+			}
+		}
+	}
+}
diff --git a/arm_word_float_native.go b/arm_word_float_native.go
new file mode 100644
index 000000000..2676f9b77
--- /dev/null
+++ b/arm_word_float_native.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func armWordFloatNativeTarget(triple string) bool {
+	parts := strings.Split(triple, "-")
+	if len(parts) < 3 {
+		return false
+	}
+	// Exact little-endian 32-bit ARM architecture components. In particular,
+	// an "arm" prefix is not proof: arm64/armeb and invented variants differ.
+	switch parts[0] {
+	case "arm", "armv5te", "armv6", "armv7", "thumb", "thumbv7":
+		return true
+	default:
+		return false
+	}
+}
+
+func validateARMWordFloatNativeTarget(file *File, options Options) error {
+	if file == nil || file.Arch != ArchARM {
+		return nil
+	}
+	needsNative := false
+	var rawError error
+	for _, function := range file.Funcs {
+		for _, source := range function.Instrs {
+			instruction := source
+			if instruction.Op == OpWORD {
+				if len(instruction.Args) == 1 && instruction.Args[0].Kind == OpImm && instruction.Args[0].ImmRaw == "" {
+					if _, ok := decodeARMRawVFPCompare(uint32(instruction.Args[0].Imm)); ok {
+						needsNative = true
+						continue
+					}
+					if _, ok := decodeARMRawNEONConvertFloat32(uint32(instruction.Args[0].Imm)); ok {
+						needsNative = true
+						continue
+					}
+				}
+				if armWordFloatPreflightSpecializedRaw(instruction) {
+					continue
+				}
+				decoded, err := decodeARMRawWordInstruction(instruction)
+				if err != nil {
+					if rawError == nil {
+						rawError = err
+					}
+					continue
+				}
+				instruction = decoded
+			}
+			op, _, _, _ := armDecodeOp(string(instruction.Op))
+			if _, matched, err := parseARMScalarCompare(op, instruction); err != nil {
+				return err
+			} else if matched {
+				needsNative = true
+				continue
+			}
+			_, matched, err := parseARMWordFloatConversion(op, instruction)
+			if err != nil {
+				return err // Invalid source is never reclassified as target context.
+			}
+			needsNative = needsNative || matched
+		}
+	}
+	// Check the complete original source, including dead instructions, before
+	// reclassifying a conversion as missing target context. Keep non-conversion
+	// functions on their existing ordinary validation path.
+	if needsNative && rawError != nil {
+		return rawError
+	}
+	if needsNative && (!armWordFloatNativeTarget(options.TargetTriple) || options.Goarch != "" && options.Goarch != "arm") {
+		return fmt.Errorf("%w: ARM scalar VFP operation requires an explicit native 32-bit little-endian ARM/Thumb FPSCR target, got %q/%q", ErrProbeNeedsContext, options.Goarch, options.TargetTriple)
+	}
+	return nil
+}
+
+func armWordFloatPreflightSpecializedRaw(ins Instr) bool {
+	// These typed paths precede the generic x/arch decoder in lowerInstr.
+	// A generic decoder failure must not reject a registered NEON/VFP family.
+	if _, ok := decodeARMRawDataForm(ins); ok {
+		return true
+	}
+	if len(ins.Args) != 1 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" {
+		return false
+	}
+	word := uint32(ins.Args[0].Imm)
+	if _, ok := decodeARMRawVFPStatusTransfer(word); ok {
+		return true
+	}
+	if word == 0xe320f001 { // YIELD, the remaining operand-free raw hint.
+		return true
+	}
+	if _, ok := decodeARMRawVFPCompare(word); ok {
+		return true
+	}
+	_, _, ok := decodeARMRawTST(word, ins.Raw)
+	return ok
+}
+
+// emitARMWordFloatNativeConversion preserves the complete VCVT effect, including
+// FPSCR rounding, cumulative exceptions, exceptional inputs and dead outputs.
+// LLVM's ordinary casts are pure and can instead fold to constants or poison.
+func (c *armCtx) emitARMWordFloatNativeConversion(form armWordFloatConversionForm, input string) string {
+	floatType, floatKind := "float", "f32"
+	if form.floatBits == 64 {
+		floatType, floatKind = "double", "f64"
+	}
+	wordKind := "s32"
+	if form.unsigned {
+		wordKind = "u32"
+	}
+	sourceType, resultType := floatType, "float"
+	sourceKind, resultKind := floatKind, wordKind
+	if form.wordToFloat {
+		carrier := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast i32 %s to float\n", carrier, input)
+		input = "%" + carrier
+		sourceType, resultType = "float", floatType
+		sourceKind, resultKind = wordKind, floatKind
+	}
+	result := c.newTmp()
+	// LLVM22 ARM constraint t selects S0..31 for float and D0..15 for double.
+	// This stays in the VFP2 register bank. The word is a bit carrier in an S
+	// register, never a numeric floating cast. Sideeffect retains exceptions;
+	// memory orders this call with the existing native VMRS/VMSR operations.
+	operation := "vcvt." + resultKind + "." + sourceKind + " $0, $1"
+	fmt.Fprintf(c.b, "  %%%s = call %s asm sideeffect %q, %q(%s %s)\n", result, resultType, operation, "=t,t,~{memory}", sourceType, input)
+	if form.wordToFloat {
+		return "%" + result
+	}
+	integer := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast float %%%s to i32\n", integer, result)
+	return "%" + integer
+}
diff --git a/arm_word_float_native_boundary_test.go b/arm_word_float_native_boundary_test.go
new file mode 100644
index 000000000..79783d525
--- /dev/null
+++ b/arm_word_float_native_boundary_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func armWordFloatBoundaryAPI(t *testing.T, api, source, triple string) error {
+	t.Helper()
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		return err
+	}
+	options := Options{Goarch: "arm", TargetTriple: triple,
+		Sigs: map[string]FuncSig{"conversion": {Name: "conversion", Ret: Void}},
+	}
+	switch api {
+	case "text":
+		_, err = Translate(file, options)
+	case "module":
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, moduleErr := TranslateModuleInContext(context, file, options)
+		if !module.IsNil() {
+			module.Dispose()
+		}
+		err = moduleErr
+	case "Go":
+		pkg := mustGoPackage(t, "example.com/conversion", "package conversion\nfunc conversion()\n")
+		module, moduleErr := TranslateGoModule(pkg, []byte(strings.ReplaceAll(source, "TEXT conversion", "TEXT ·conversion")), GoModuleOptions{
+			GOOS: "linux", GOARCH: "arm", TargetTriple: triple,
+		})
+		if module != nil {
+			module.Module.Dispose()
+		}
+		err = moduleErr
+	default:
+		t.Fatal("unknown translation API")
+	}
+	return err
+}
+
+func TestARMWordFloatNativeTargetBoundary(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, body := range []string{"MOVFW F0,F1", "WORD $0xeefd0bc0"} {
+			for _, triple := range []string{
+				"", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "arm64-apple-darwin",
+				"armeb-unknown-linux-gnueabi", "armv7eb-unknown-linux-gnueabi", "thumbeb-unknown-linux-gnueabi",
+				"armanything-unknown-linux-gnu", "wasm32-unknown-unknown",
+				"armv5te-unknown-linux-gnueabi", "armv6-unknown-linux-gnueabihf",
+				"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc",
+			} {
+				t.Run(api+"/"+body+"/"+triple, func(t *testing.T) {
+					source := "TEXT conversion(SB),4,$0-0\nMOVD $1.5,F0\n" + body + "\nRET\n"
+					err := armWordFloatBoundaryAPI(t, api, source, triple)
+					valid := triple == "armv5te-unknown-linux-gnueabi" || triple == "armv6-unknown-linux-gnueabihf" ||
+						triple == "armv7-unknown-linux-gnueabihf" || triple == "thumbv7-pc-windows-msvc"
+					if valid && err != nil || !valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("native=%v: %v", valid, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARMWordFloatNativeTargetDoesNotReclassifyInvalidSource(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, body := range []string{"MOVWF R0,R1", "MOVDW S0,F1", "MOVFW.P F0,F1", "WORD $0xffffffff"} {
+			source := "TEXT conversion(SB),4,$0-0\n" + body + "\nRET\n"
+			if err := armWordFloatBoundaryAPI(t, api, source, ""); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s %s invalid source became native-target context: %v", api, body, err)
+			}
+		}
+		if err := armWordFloatBoundaryAPI(t, api, "TEXT conversion(SB),4,$0-0\nRET\n", ""); err != nil {
+			t.Fatalf("%s ordinary non-conversion behavior changed: %v", api, err)
+		}
+	}
+}
+
+func TestARMWordFloatRawDoubleWordCarriers(t *testing.T) {
+	translateARMCompleteForms(t, `TEXT conversion(SB),4,$0-0
+WORD $0xeefd0bc0 // VCVT.S32.F64 S1,D0
+WORD $0xeeb80be0 // VCVT.F64.S32 D0,S1
+WORD $0xeebc0bc0 // VCVT.U32.F64 S0,D0
+WORD $0xeeb80b60 // VCVT.F64.U32 D0,S1
+RET
+`, map[string]FuncSig{"conversion": {Name: "conversion", Ret: Void}})
+}
+
+func TestARMWordFloatNativeTargetKeepsMixedRawErrors(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf"} {
+			for _, body := range []string{
+				"MOVFW F0,F1\nWORD $0xffffffff",
+				"WORD $0xffffffff\nMOVFW F0,F1",
+				"MOVFW F0,F1\nRET\nWORD $0xffffffff",
+				"RET\nWORD $0xffffffff\nMOVFW F0,F1",
+			} {
+				t.Run(api+"/"+triple+"/"+body, func(t *testing.T) {
+					source := "TEXT conversion(SB),4,$0-0\nMOVD $1.5,F0\n" + body + "\nRET\n"
+					err := armWordFloatBoundaryAPI(t, api, source, triple)
+					if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "WORD") {
+						t.Fatalf("invalid original raw source was hidden by target/deadness: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARMWordFloatNativeTargetPreservesSpecializedRawRegistry(t *testing.T) {
+	variants := armRawStatusFamilies()
+	variants = append(variants,
+		armRawStatusCase{family: "VFPStatus", instruction: "vmrs r0,fpscr"},
+		armRawStatusCase{family: "VFPCompare", instruction: "vcmp.f32 s0,s1"},
+		armRawStatusCase{family: "Yield", instruction: "yield"},
+		armRawStatusCase{family: "TSTCarry", instruction: "tst r0,#0x80000000"},
+	)
+	words := assembleARMRawStatusWords(t, variants)
+	for index, word := range words {
+		source := fmt.Sprintf("TEXT conversion(SB),4,$0-0\nWORD $%#x\nMOVFW F0,F1\nRET\n", word)
+		file, err := Parse(ArchARM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := validateARMWordFloatNativeTarget(file, Options{}); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("registered raw %s became invalid source: %v", variants[index].family, err)
+		}
+		if err := validateARMWordFloatNativeTarget(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf"}); err != nil {
+			t.Fatalf("registered raw %s rejected by native conversion preflight: %v", variants[index].family, err)
+		}
+	}
+}
diff --git a/arm_word_float_scratch_runtime_linux_test.go b/arm_word_float_scratch_runtime_linux_test.go
new file mode 100644
index 000000000..8ce524ba1
--- /dev/null
+++ b/arm_word_float_scratch_runtime_linux_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixARMWordFloatScratch(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	const source = `TEXT oracle(SB),4,$0-4
+MOVD $3.0,F15
+MOVF $7.0,F15
+MOVD $1.5,F0
+MOVDW F0,R1
+MOVW F15,R0
+MOVW R0,result+0(FP)
+RET
+`
+	directory := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod": "module armmovconvert\n\ngo 1.20\n",
+		"main.go": `package main
+import "fmt"
+func oracle() uint32
+func main() {
+    result := oracle()
+    if result != 1 { panic(fmt.Sprintf("original F15 scratch = %x, want 1", result)) }
+    fmt.Println("ORIGINAL_ARM_CONVERSION_SCRATCH 1")
+}
+
+`,
+		"original_arm.s": strings.ReplaceAll(source, "TEXT oracle(", "TEXT ·oracle("),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(directory, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", executable, ".")
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual Go conversion build: %v\n%s", err, output)
+	}
+	args := runtimeOracleGuestArguments(t, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, executable)
+	ctx, cancel = runtimeOracleStageContext(t)
+	output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, args[0], args[1:]...))
+	cancel()
+	if err != nil || string(output) != "ORIGINAL_ARM_CONVERSION_SCRATCH 1\n" {
+		t.Fatalf("actual unchanged Go F15 effect: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf",
+		Sigs: map[string]FuncSig{"oracle": {
+			Name: "oracle", Ret: I32,
+			Frame: FrameLayout{Results: []FrameSlot{{Type: I32, Field: -1}}},
+		}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t oracle(void);
+int main(void) {
+    uint32_t value = oracle();
+    if (value != 1) {
+        fprintf(stderr,"LLVM F15 scratch = %x, want 1\n",value);
+        return 1;
+    }
+    return 0;
+}
+`
+	for _, level := range []int{0, 2} {
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+			"arm_conversion_scratch", "armv7-unknown-linux-gnueabihf", ir, driver,
+			[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixARMFloatRegisterEffects(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	cases := append(armFloatConversionEffectCases(), armFloatHalfWriteEffectCases()...)
+	source, sigs := armFloatEffectSource(cases)
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for i := range cases {
+		fmt.Fprintf(&original, "func effect%d(input,output *[4]uint64)\n", i)
+		fmt.Fprintf(&driver, "extern void effect%d(uint64_t*,uint64_t*);\n", i)
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) { unsigned failures = 0;\n")
+	for i, fixture := range cases {
+		fmt.Fprintf(&original, "{ input := [4]uint64{%#x,%#x,%#x,%#x}; ",
+			fixture.input[0], fixture.input[1], fixture.input[2], fixture.input[3])
+		fmt.Fprintf(&original, "output := [4]uint64{0,0,0,0xabcdef0100000000}; effect%d(&input,&output); ", i)
+		fmt.Fprintf(&original, "want := [4]uint64{%#x,%#x,%#x,%#x}; ",
+			fixture.want[0], fixture.want[1], fixture.want[2], fixture.want[3])
+		fmt.Fprintf(&original, "if output != want { panic(fmt.Sprintf(%q,output,want)) } }\n",
+			fmt.Sprintf("case %d %s: got %%x want %%x", i, fixture.instruction))
+		fmt.Fprintf(&driver, "{ uint64_t input[4]={%#xULL,%#xULL,%#xULL,%#xULL}; ",
+			fixture.input[0], fixture.input[1], fixture.input[2], fixture.input[3])
+		fmt.Fprintf(&driver, "uint64_t output[4]={0,0,0,0xabcdef0100000000ULL}; effect%d(input,output); ", i)
+		fmt.Fprintf(&driver, "uint64_t want[4]={%#xULL,%#xULL,%#xULL,%#xULL}; ",
+			fixture.want[0], fixture.want[1], fixture.want[2], fixture.want[3])
+		fmt.Fprintf(&driver, `for (unsigned j=0;j<4;j++) { if (output[j]!=want[j]) {
+if (failures<16) fprintf(stderr,"case %d %s word %%u: got %%llx want %%llx\n",j,(unsigned long long)output[j],(unsigned long long)want[j]); failures++; } } }
+`, i, fixture.instruction)
+	}
+	fmt.Fprintf(&original, "fmt.Println(%q)\n}\n", fmt.Sprintf("ORIGINAL_ARM_FLOAT_EFFECTS %d", len(cases)))
+	fmt.Fprintf(&driver, "printf(\"LLVM_ARM_FLOAT_EFFECTS %d failures=%%u\\n\",failures); return failures != 0; }\n", len(cases))
+
+	directory := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":         "module armfloateffects\n\ngo 1.20\n",
+		"main.go":        original.String(),
+		"original_arm.s": strings.ReplaceAll(source, "TEXT effect", "TEXT ·effect"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(directory, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", executable, ".")
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual Go full-register effect build: %v\n%s", err, output)
+	}
+	args := runtimeOracleGuestArguments(t, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, executable)
+	ctx, cancel = runtimeOracleStageContext(t)
+	output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, args[0], args[1:]...))
+	cancel()
+	want := fmt.Sprintf("ORIGINAL_ARM_FLOAT_EFFECTS %d\n", len(cases))
+	if err != nil || string(output) != want {
+		t.Fatalf("actual Go full-register effects: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"unoptimized", ir}, {"optimized", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+					"arm_float_effects", "armv7-unknown-linux-gnueabihf", variant.ir, driver.String(),
+					[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+				t.Logf("LLVM22 %s O%d: %d full-register fixtures", variant.name, level, len(cases))
+			})
+		}
+	}
+}
diff --git a/arm_word_float_status_runtime_linux_test.go b/arm_word_float_status_runtime_linux_test.go
new file mode 100644
index 000000000..fb03743f1
--- /dev/null
+++ b/arm_word_float_status_runtime_linux_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func runARMConversionGoOracle(t *testing.T, source, main, marker string) {
+	t.Helper()
+	output := armConversionGoObservations(t, source, main)
+	if string(output) != marker+"\n" {
+		t.Fatalf("original Go conversion observations:\n%s", output)
+	}
+	t.Log(marker)
+}
+
+func armConversionGoObservations(t *testing.T, source, main string) []byte {
+	t.Helper()
+	directory := t.TempDir()
+	for name, content := range map[string]string{
+		"go.mod": "module armconversionoracle\n\ngo 1.20\n", "main.go": main,
+		"oracle_arm.s": strings.ReplaceAll(source, "TEXT ", "TEXT ·"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(directory, "original")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "build", "-p=1", "-o", executable, ".")
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm", "GOARM=7", "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go conversion build: %v\n%s", err, output)
+	}
+	args := runtimeOracleGuestArguments(t, []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, executable)
+	ctx, cancel = runtimeOracleStageContext(t)
+	output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, args[0], args[1:]...))
+	cancel()
+	if err != nil {
+		t.Fatalf("original Go conversion observations: %v\n%s", err, output)
+	}
+	return output
+}
+
+func TestCrossLinuxRuntimeMatrixARMWordFloatNativeStatusConstants(t *testing.T) {
+	llc := requireARMScalarRuntime(t)
+	source, sigs := armConversionStatusSource()
+	cases := armConversionStatusCases()
+	var original, driver strings.Builder
+	original.WriteString("package main\nimport \"fmt\"\n")
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	for _, fixture := range cases {
+		fmt.Fprintf(&original, "func %s(out *[4]uint32)\n", fixture.name)
+		fmt.Fprintf(&driver, "extern void %s(uint32_t*);\n", fixture.name)
+	}
+	original.WriteString("func main() {\n")
+	driver.WriteString("int main(void) { unsigned failures = 0;\n")
+	for _, fixture := range cases {
+		fmt.Fprintf(&original, "{ out := [4]uint32{0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0x12345678}\n%s(&out)\n", fixture.name)
+		fmt.Fprintf(&original, "want := [4]uint32{%#x,%#x,%#x,0x12345678}\n", uint32(fixture.value), uint32(fixture.value>>32), fixture.status)
+		fmt.Fprintf(&original, "if out != want { panic(fmt.Sprintf(%q,out,want)) } }\n", fixture.name+": got %x want %x")
+		fmt.Fprintf(&driver, "{ uint32_t out[4]={0xa5a5a5a5,0xa5a5a5a5,0xa5a5a5a5,0x12345678};\n%s(out);\n", fixture.name)
+		fmt.Fprintf(&driver, "uint32_t want[4]={%#x,%#x,%#x,0x12345678};\n", uint32(fixture.value), uint32(fixture.value>>32), fixture.status)
+		fmt.Fprintf(&driver, `for(unsigned i=0;i<4;i++) { if(out[i]!=want[i]) {
+fprintf(stderr,"%s word %%u: got %%08x want %%08x\n",i,out[i],want[i]); failures++; } } }
+`, fixture.name)
+	}
+	marker := fmt.Sprintf("ORIGINAL_ARM_CONVERSION_STATUS %d", len(cases))
+	fmt.Fprintf(&original, "fmt.Println(%q)\n}\n", marker)
+	driver.WriteString("return failures != 0; }\n")
+	runARMConversionGoOracle(t, source, original.String(), marker)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"unoptimized", ir}, {"optimized", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("%s/O%d", variant.name, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{"arm-linux-gnueabihf-gcc", "-no-pie"},
+					"arm_conversion_status", "armv7-unknown-linux-gnueabihf", variant.ir, driver.String(),
+					[]string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"}, level)
+				t.Logf("%d native result/FPSCR/canary observations", len(cases))
+			})
+		}
+	}
+}
diff --git a/arm_word_float_status_test.go b/arm_word_float_status_test.go
new file mode 100644
index 000000000..63b11d359
--- /dev/null
+++ b/arm_word_float_status_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+type armConversionStatusCase struct {
+	name, body string
+	control    uint32
+	value      uint64
+	status     uint32
+	double     bool
+}
+
+func armConversionStatusCases() []armConversionStatusCase {
+	return []armConversionStatusCase{
+		{name: "fraction32", body: "MOVF $1.5,F0\nMOVFW F0,R2", value: 1, status: 0x10},
+		{name: "fraction64", body: "MOVD $1.5,F0\nMOVDW F0,R2", value: 1, status: 0x10},
+		{name: "overflowSigned", body: "MOVD $2147483648.0,F0\nMOVDW F0,R2", value: 0x7fffffff, status: 1},
+		{name: "overflowUnsigned", body: "MOVD $4294967296.0,F0\nMOVDW.U F0,R2", value: 0xffffffff, status: 1},
+		{name: "nanSigned", body: "MOVW $0x7fc00000,R2\nMOVW R2,F0\nMOVFW F0,R2", status: 1},
+		{name: "negativeUnsigned", body: "MOVF $-1.0,F0\nMOVFW.U F0,R2", status: 1},
+		{name: "roundUp", body: "MOVW $16777217,R2\nMOVWF R2,F0\nMOVW F0,R2", control: 1 << 22, value: 0x4b800001, status: 1<<22 | 0x10},
+		{name: "roundDown", body: "MOVW $-16777217,R2\nMOVWF R2,F0\nMOVW F0,R2", control: 2 << 22, value: 0xcb800001, status: 2<<22 | 0x10},
+		{name: "roundUnsignedDown", body: "MOVW $0xffffffff,R2\nMOVWF.U R2,F0\nMOVW F0,R2", control: 2 << 22, value: 0x4f7fffff, status: 2<<22 | 0x10},
+		{name: "wordDoubleSigned", body: "MOVW $2147483647,R2\nMOVWD R2,F0", value: math.Float64bits(2147483647), double: true},
+		{name: "wordDoubleUnsigned", body: "MOVW $0xffffffff,R2\nMOVWD.U R2,F0", value: math.Float64bits(4294967295), double: true},
+		{name: "deadResult", body: "MOVF $1.5,F0\nMOVFW F0,R2\nMOVW $0,R2", status: 0x10},
+	}
+}
+
+func armConversionStatusSource() (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, fixture := range armConversionStatusCases() {
+		fmt.Fprintf(&source, `TEXT %s(SB),4,$0-4
+MOVW out+0(FP),R0
+MOVD $3.0,F0
+MOVD $3.0,F15
+WORD $0xeef14a10 // save native FPSCR in R4
+MOVW $%d,R3
+WORD $0xeee13a10 // install source control and clear cumulative flags
+%s
+WORD $0xeef13a10 // observe native FPSCR before restoring the caller
+WORD $0xeee14a10
+`, fixture.name, fixture.control, fixture.body)
+		if fixture.double {
+			source.WriteString("MOVD F0,0(R0)\n")
+		} else {
+			source.WriteString("MOVW R2,0(R0)\nMOVW $0,R2\nMOVW R2,4(R0)\n")
+		}
+		source.WriteString("MOVW R3,8(R0)\nRET\n")
+		sigs[fixture.name] = FuncSig{Name: fixture.name, Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}},
+		}
+	}
+	return source.String(), sigs
+}
+
+func TestARMWordFloatStatusIsNativeAndSurvivesOptimization(t *testing.T) {
+	source, sigs := armConversionStatusSource()
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: "armv7-unknown-linux-gnueabihf", Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, variant := range []struct{ name, ir string }{{"original", ir}, {"O2", armFloatEffectOptimizedIR(t, ir)}} {
+		for _, operation := range []string{"s32.f32", "u32.f32", "s32.f64", "u32.f64", "f32.s32", "f32.u32", "f64.s32", "f64.u32"} {
+			if !strings.Contains(variant.ir, `asm sideeffect "vcvt.`+operation+` `) {
+				t.Errorf("%s omits native side-effecting VCVT %s", variant.name, operation)
+			}
+		}
+		for _, forbidden := range []string{" = fptosi ", " = fptoui ", " = sitofp ", " = uitofp "} {
+			if strings.Contains(variant.ir, forbidden) {
+				t.Errorf("%s substitutes an ordinary LLVM conversion for native FPSCR: %s", variant.name, forbidden)
+			}
+		}
+		if count := strings.Count(variant.ir, `asm sideeffect "vcvt.`); count != len(armConversionStatusCases()) {
+			t.Errorf("%s drops source/dead conversion effects: %d", variant.name, count)
+		}
+	}
+}
diff --git a/assembler_profile.go b/assembler_profile.go
new file mode 100644
index 000000000..a50184364
--- /dev/null
+++ b/assembler_profile.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// GoAssemblerDefinesForEnvironment returns the CPU and target macros passed by
+// cmd/go for an explicitly observed target environment. Unlike
+// GoAssemblerDefines it never substitutes host/default CPU values. The caller
+// must supply the actual go env values used for source selection and assembly.
+//
+// GOEXPERIMENT macros are deliberately not included here: cmd/asm adds those
+// only to packages permitted by its package-special registration, not to
+// ordinary external packages merely because an experiment is enabled.
+func GoAssemblerDefinesForEnvironment(goos, goarch string, environment map[string]string) ([]string, error) {
+	if goos == "" || environment["GOOS"] != goos || environment["GOARCH"] != goarch {
+		return nil, fmt.Errorf("assembler profile target does not match its observed environment")
+	}
+	version := strings.Split(strings.TrimPrefix(environment["GOVERSION"], "go1."), ".")[0]
+	minor, err := strconv.Atoi(version)
+	if !strings.HasPrefix(environment["GOVERSION"], "go1.") || err != nil || minor < 20 || minor > 27 {
+		return nil, fmt.Errorf("assembler profile requires an audited observed Go 1.20–1.27 GOVERSION")
+	}
+	defines := []string{"GOOS_" + goos, "GOARCH_" + goarch}
+	key := map[string]string{"386": "GO386", "amd64": "GOAMD64", "arm": "GOARM", "arm64": "GOARM64", "wasm": "GOWASM"}[goarch]
+	if key == "" {
+		return nil, fmt.Errorf("unsupported assembler profile architecture %q", goarch)
+	}
+	value, exists := environment[key]
+	if !exists {
+		return nil, fmt.Errorf("assembler profile is missing observed %s", key)
+	}
+	switch goarch {
+	case "386":
+		if value != "sse2" && value != "softfloat" {
+			return nil, fmt.Errorf("invalid observed GO386 %q", value)
+		}
+		defines = append(defines, "GO386_"+value)
+	case "amd64":
+		if value != "v1" && value != "v2" && value != "v3" && value != "v4" {
+			return nil, fmt.Errorf("invalid observed GOAMD64 %q", value)
+		}
+		// Unlike cumulative build tags, cmd/go defines only the chosen level.
+		defines = append(defines, "GOAMD64_"+value)
+	case "arm":
+		parts := strings.Split(value, ",")
+		if len(parts) > 2 || parts[0] != "5" && parts[0] != "6" && parts[0] != "7" || len(parts) == 2 && (minor < 22 || parts[1] != "softfloat" && parts[1] != "hardfloat") {
+			return nil, fmt.Errorf("invalid observed GOARM %q", value)
+		}
+		if minor < 22 {
+			break // Go 1.20–1.21 asmArgs does not define GOARM_*.
+		}
+		for level := parts[0][0]; level >= '5'; level-- {
+			defines = append(defines, "GOARM_"+string(level))
+		}
+	case "arm64":
+		// Before Go 1.23 GOARM64 is absent (go env reports an empty string).
+		if minor < 23 && value == "" {
+			break
+		}
+		if minor < 23 {
+			return nil, fmt.Errorf("GOARM64 profile requires Go 1.23 or newer")
+		}
+		lse, err := goARM64ProfileLSE(value)
+		if err != nil {
+			return nil, err
+		}
+		if lse {
+			defines = append(defines, "GOARM64_LSE")
+		}
+	case "wasm":
+		for _, option := range strings.Split(value, ",") {
+			if option != "" && option != "satconv" && option != "signext" {
+				return nil, fmt.Errorf("invalid observed GOWASM %q", value)
+			}
+		}
+		// cmd/go does not register a GOWASM_* assembler macro.
+	}
+	return defines, nil
+}
+
+func goARM64ProfileLSE(value string) (bool, error) {
+	lse := false
+	for {
+		if strings.HasSuffix(value, ",lse") {
+			lse = true
+			value = strings.TrimSuffix(value, ",lse")
+		} else if strings.HasSuffix(value, ",crypto") {
+			value = strings.TrimSuffix(value, ",crypto")
+		} else {
+			break
+		}
+	}
+	if len(value) != 4 || value[0] != 'v' || value[2] != '.' || value[1] != '8' && value[1] != '9' || value[3] < '0' || value[3] > '9' || value[1] == '9' && value[3] > '5' {
+		return false, fmt.Errorf("invalid observed GOARM64 %q", value)
+	}
+	return lse || value != "v8.0", nil
+}
diff --git a/assembler_profile_test.go b/assembler_profile_test.go
new file mode 100644
index 000000000..557ff0cd2
--- /dev/null
+++ b/assembler_profile_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoAssemblerExplicitEnvironmentFamilies(t *testing.T) {
+	for _, tc := range []struct {
+		arch, key, value, want string
+	}{
+		{"386", "GO386", "sse2", "GO386_sse2"},
+		{"386", "GO386", "softfloat", "GO386_softfloat"},
+		{"amd64", "GOAMD64", "v1", "GOAMD64_v1"},
+		{"amd64", "GOAMD64", "v2", "GOAMD64_v2"},
+		{"amd64", "GOAMD64", "v3", "GOAMD64_v3"},
+		{"amd64", "GOAMD64", "v4", "GOAMD64_v4"},
+		{"arm", "GOARM", "5,softfloat", "GOARM_5"},
+		{"arm", "GOARM", "6", "GOARM_6,GOARM_5"},
+		{"arm", "GOARM", "7,hardfloat", "GOARM_7,GOARM_6,GOARM_5"},
+		{"arm64", "GOARM64", "v8.0", ""},
+		{"arm64", "GOARM64", "v8.0,crypto", ""},
+		{"arm64", "GOARM64", "v8.0,lse,crypto", "GOARM64_LSE"},
+		{"arm64", "GOARM64", "v8.1", "GOARM64_LSE"},
+		{"arm64", "GOARM64", "v9.5", "GOARM64_LSE"},
+		{"wasm", "GOWASM", "", ""},
+		{"wasm", "GOWASM", "satconv,signext", ""},
+	} {
+		t.Run(tc.arch+"/"+tc.value, func(t *testing.T) {
+			env := map[string]string{"GOOS": "linux", "GOARCH": tc.arch, "GOVERSION": "go1.27.1", tc.key: tc.value, "GOEXPERIMENT": "fieldtrack"}
+			got, err := GoAssemblerDefinesForEnvironment("linux", tc.arch, env)
+			want := []string{"GOOS_linux", "GOARCH_" + tc.arch}
+			if tc.want != "" {
+				want = append(want, strings.Split(tc.want, ",")...)
+			}
+			if err != nil || !reflect.DeepEqual(got, want) {
+				t.Fatalf("defines = %v, %v; want %v", got, err, want)
+			}
+		})
+	}
+}
+
+func TestGoAssemblerExplicitEnvironmentRejectsUnknownOrMissing(t *testing.T) {
+	for _, tc := range []struct{ arch, key, value string }{
+		{"386", "GO386", ""}, {"386", "GO386", "avx"},
+		{"amd64", "GOAMD64", "v5"}, {"arm", "GOARM", "8"},
+		{"arm", "GOARM", "6,unknown"}, {"arm64", "GOARM64", "v9.6"},
+		{"arm64", "GOARM64", "v8.0,unknown"}, {"wasm", "GOWASM", "avx"},
+	} {
+		env := map[string]string{"GOOS": "linux", "GOARCH": tc.arch, "GOVERSION": "go1.27.1", tc.key: tc.value}
+		if _, err := GoAssemblerDefinesForEnvironment("linux", tc.arch, env); err == nil {
+			t.Errorf("accepted invalid %s=%q", tc.key, tc.value)
+		}
+	}
+	for _, env := range []map[string]string{
+		{"GOOS": "darwin", "GOARCH": "amd64", "GOAMD64": "v1"},
+		{"GOOS": "linux", "GOARCH": "arm64", "GOAMD64": "v1"},
+		{"GOOS": "linux", "GOARCH": "amd64"},
+	} {
+		if _, err := GoAssemblerDefinesForEnvironment("linux", "amd64", env); err == nil {
+			t.Errorf("accepted incomplete/conflicting environment %v", env)
+		}
+	}
+}
+
+func TestGoAssemblerExplicitEnvironmentVersionBoundaries(t *testing.T) {
+	for _, version := range []string{"go1.20.14", "go1.21.13", "go1.22.12", "go1.27.1"} {
+		env := map[string]string{"GOOS": "linux", "GOARCH": "arm", "GOVERSION": version, "GOARM": "6"}
+		got, err := GoAssemblerDefinesForEnvironment("linux", "arm", env)
+		want := []string{"GOOS_linux", "GOARCH_arm"}
+		if version != "go1.20.14" && version != "go1.21.13" {
+			want = append(want, "GOARM_6", "GOARM_5")
+		}
+		if err != nil || !reflect.DeepEqual(got, want) {
+			t.Fatalf("%s defines=%v, %v; want %v", version, got, err, want)
+		}
+	}
+	for _, version := range []string{"", "go1.19.13", "go1.28.1", "devel go1.27"} {
+		env := map[string]string{"GOOS": "linux", "GOARCH": "amd64", "GOVERSION": version, "GOAMD64": "v1"}
+		if _, err := GoAssemblerDefinesForEnvironment("linux", "amd64", env); err == nil {
+			t.Fatalf("accepted missing/unaudited GOVERSION=%q", version)
+		}
+	}
+	for _, tc := range []struct{ version, value string }{{"go1.20.14", ""}, {"go1.22.12", ""}} {
+		if _, err := GoAssemblerDefinesForEnvironment("linux", "arm64", map[string]string{"GOOS": "linux", "GOARCH": "arm64", "GOVERSION": tc.version, "GOARM64": tc.value}); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/assembly_block_names.go b/assembly_block_names.go
new file mode 100644
index 000000000..adc829f6c
--- /dev/null
+++ b/assembly_block_names.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import "fmt"
+
+// Source labels and generated entry/fallthrough blocks are different roles.
+// Keep every source alias, and reserve fresh synthetic names before CFG
+// construction instead of guessing a role from a source-name prefix.
+type assemblyBlockNames struct {
+	used map[string]bool
+}
+
+func newAssemblyBlockNames(function Func) *assemblyBlockNames {
+	names := &assemblyBlockNames{used: make(map[string]bool)}
+	for _, instruction := range function.Instrs {
+		if instruction.Op == OpLABEL && len(instruction.Args) == 1 && instruction.Args[0].Kind == OpLabel {
+			names.used[instruction.Args[0].Sym] = true
+		}
+	}
+	return names
+}
+
+func (names *assemblyBlockNames) fresh(prefix string) string {
+	name := prefix
+	for suffix := 1; names.used[name]; suffix++ {
+		name = fmt.Sprintf("%s_%d", prefix, suffix)
+	}
+	names.used[name] = true
+	return name
+}
diff --git a/assembly_include.go b/assembly_include.go
new file mode 100644
index 000000000..da9cae2de
--- /dev/null
+++ b/assembly_include.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+var quotedGoAssemblyIncludeRE = regexp.MustCompile(`^#include[ \t]+"([^"\r\n]+)"[ \t]*(?://.*)?$`)
+
+// GoAssemblySourceReadReport is a plain read inventory, not source/CPP authority.
+// SearchMisses records preferred local names whose absence selected a fallback;
+// missing generated headers never become successful Inputs.
+type GoAssemblySourceReadReport struct {
+	Inputs       map[string]string
+	SearchMisses []string
+}
+
+// ReadGoAssemblySource reads one .s file and recursively expands quoted
+// includes from its module/source root or the active Go toolchain. Generated
+// headers which do not exist yet (notably go_asm.h) remain directives so the
+// type-aware expansion path can provide their values later.
+func ReadGoAssemblySource(asmFile, sourceRoot string) ([]byte, error) {
+	return readGoAssemblySource(asmFile, sourceRoot, "", nil)
+}
+
+// ReadGoAssemblySourceWithReport also reports the physical files and original
+// requested names actually read by the same expansion, with their byte hashes.
+// Missing generated headers are not invented inputs. This is an inventory, not
+// a compiler-backed source/CPP observation or any native-memory permission.
+func ReadGoAssemblySourceWithReport(asmFile, sourceRoot string) ([]byte, *GoAssemblySourceReadReport, error) {
+	inputs := &GoAssemblySourceReadReport{Inputs: make(map[string]string)}
+	source, err := readGoAssemblySource(asmFile, sourceRoot, "", inputs)
+	if err != nil {
+		return nil, nil, err
+	}
+	return source, inputs, nil
+}
+
+// ReadGoAssemblySourceAtGOROOT expands the same source inventory using the
+// explicitly selected Go installation. It does not substitute the host SDK's
+// headers when inspecting another compiler version. Missing generated headers
+// remain unresolved, just as in ReadGoAssemblySource; this is not a complete
+// compiler-backed CPP or translation observation.
+func ReadGoAssemblySourceAtGOROOT(asmFile, sourceRoot, goRoot string) ([]byte, error) {
+	if goRoot == "" {
+		return nil, fmt.Errorf("assembly source inventory requires an explicit GOROOT")
+	}
+	return readGoAssemblySource(asmFile, sourceRoot, goRoot, nil)
+}
+
+func readGoAssemblySource(asmFile, sourceRoot, goRoot string, inputs *GoAssemblySourceReadReport) ([]byte, error) {
+	root, err := filepath.Abs(sourceRoot)
+	if err != nil {
+		return nil, fmt.Errorf("resolve assembly source root: %w", err)
+	}
+	root, err = sourcepath.Resolve(root)
+	if err != nil {
+		return nil, fmt.Errorf("resolve assembly source root symlinks: %w", err)
+	}
+	file, err := filepath.Abs(asmFile)
+	if err != nil {
+		return nil, fmt.Errorf("resolve assembly path: %w", err)
+	}
+	requested := file
+	file, err = sourcepath.Resolve(file)
+	if err != nil {
+		return nil, fmt.Errorf("resolve assembly path symlinks: %w", err)
+	}
+	if !goAssemblyPathWithinRoot(root, file) {
+		return nil, fmt.Errorf("assembly source %s escapes source root %s", file, root)
+	}
+	source, err := expandGoAssemblyIncludes(file, root, goRoot, make(map[string]bool), inputs, 0)
+	if err == nil && inputs != nil {
+		inputs.Inputs[requested] = inputs.Inputs[file]
+	}
+	return source, err
+}
+
+func expandGoAssemblyIncludes(file, sourceRoot, goRoot string, active map[string]bool, inputs *GoAssemblySourceReadReport, depth int) ([]byte, error) {
+	if depth > 32 {
+		return nil, fmt.Errorf("assembly include depth exceeds 32 at %s", file)
+	}
+	if active[file] {
+		return nil, fmt.Errorf("assembly include cycle at %s", file)
+	}
+	src, err := os.ReadFile(file)
+	if err != nil {
+		return nil, err
+	}
+	if inputs != nil {
+		inputs.Inputs[file] = fmt.Sprintf("%x", sha256.Sum256(src))
+	}
+	active[file] = true
+	defer delete(active, file)
+
+	var out strings.Builder
+	for _, line := range strings.SplitAfter(string(src), "\n") {
+		trimmed := strings.TrimSpace(strings.TrimSuffix(line, "\n"))
+		match := quotedGoAssemblyIncludeRE.FindStringSubmatch(trimmed)
+		if match == nil || filepath.IsAbs(match[1]) {
+			out.WriteString(line)
+			continue
+		}
+
+		includedPath := filepath.Clean(filepath.Join(filepath.Dir(file), filepath.FromSlash(match[1])))
+		requestedPath := includedPath
+		localAllowed := goAssemblyPathWithinRoot(sourceRoot, includedPath)
+		var included []byte
+		var includeErr error
+		if localAllowed {
+			resolvedPath, err := sourcepath.Resolve(includedPath)
+			if err == nil {
+				if !goAssemblyPathWithinRoot(sourceRoot, resolvedPath) {
+					return nil, fmt.Errorf("assembly include %q escapes source root %s through symlink %s", match[1], sourceRoot, resolvedPath)
+				}
+				includedPath = resolvedPath
+			} else if !os.IsNotExist(err) {
+				return nil, fmt.Errorf("resolve assembly include %q from %s: %w", match[1], file, err)
+			}
+			included, includeErr = expandGoAssemblyIncludes(includedPath, sourceRoot, goRoot, active, inputs, depth+1)
+			if includeErr == nil && inputs != nil {
+				inputs.Inputs[requestedPath] = inputs.Inputs[includedPath]
+			}
+		}
+		if !localAllowed || os.IsNotExist(includeErr) {
+			if localAllowed && os.IsNotExist(includeErr) && inputs != nil {
+				inputs.SearchMisses = append(inputs.SearchMisses, requestedPath)
+			}
+			if goRoot == "" {
+				goRoot, err = gotoolchain.Root()
+				if err != nil {
+					return nil, err
+				}
+			}
+			goRoot, err = sourcepath.Resolve(filepath.Clean(goRoot))
+			if err != nil {
+				return nil, fmt.Errorf("resolve GOROOT symlinks: %w", err)
+			}
+			goIncludeRoot := filepath.Join(goRoot, "pkg", "include")
+			goIncludedPath := filepath.Clean(filepath.Join(goIncludeRoot, filepath.FromSlash(match[1])))
+			requestedPath := goIncludedPath
+			if goAssemblyPathWithinRoot(goRoot, goIncludedPath) {
+				resolvedPath, err := sourcepath.Resolve(goIncludedPath)
+				if err == nil {
+					if !goAssemblyPathWithinRoot(goRoot, resolvedPath) {
+						return nil, fmt.Errorf("assembly include %q escapes GOROOT %s through symlink %s", match[1], goRoot, resolvedPath)
+					}
+					goIncludedPath = resolvedPath
+				} else if !os.IsNotExist(err) {
+					return nil, fmt.Errorf("resolve Go assembly include %q: %w", match[1], err)
+				}
+				included, includeErr = expandGoAssemblyIncludes(goIncludedPath, goRoot, goRoot, active, inputs, depth+1)
+				if includeErr == nil && inputs != nil {
+					inputs.Inputs[requestedPath] = inputs.Inputs[goIncludedPath]
+				}
+			} else if !localAllowed {
+				return nil, fmt.Errorf("assembly include %q escapes source root %s and GOROOT %s", match[1], sourceRoot, goRoot)
+			}
+			if os.IsNotExist(includeErr) {
+				if !localAllowed {
+					return nil, fmt.Errorf("assembly include %q escapes source root %s", match[1], sourceRoot)
+				}
+				out.WriteString(line)
+				continue
+			}
+		}
+		if includeErr != nil {
+			return nil, fmt.Errorf("expand assembly include %q from %s: %w", match[1], file, includeErr)
+		}
+		out.Write(included)
+		if strings.HasSuffix(line, "\n") && len(included) != 0 && included[len(included)-1] != '\n' {
+			out.WriteByte('\n')
+		}
+	}
+	return []byte(out.String()), nil
+}
+
+func goAssemblyPathWithinRoot(root, candidate string) bool {
+	rel, err := filepath.Rel(root, candidate)
+	return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}
diff --git a/assembly_include_inputs_test.go b/assembly_include_inputs_test.go
new file mode 100644
index 000000000..65b1099b1
--- /dev/null
+++ b/assembly_include_inputs_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestReadGoAssemblySourceInputsShareExactExpansion(t *testing.T) {
+	root := t.TempDir()
+	files := map[string]string{
+		"entry_amd64.s": "#include \"middle.inc\"\n#include \"go_asm.h\"\nTEXT ·Value(SB),$0-0\nRET\n",
+		"middle.inc":    "#include \"value.inc\"\n", "value.inc": "#define BIAS 7\n",
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(root, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	input := filepath.Join(root, "entry_amd64.s")
+	plain, err := ReadGoAssemblySource(input, root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, inputs, err := ReadGoAssemblySourceWithReport(input, root)
+	if err != nil || !reflect.DeepEqual(plain, observed) {
+		t.Fatalf("input inventory altered the existing source expansion: %v", err)
+	}
+	want := make(map[string]string)
+	for name, data := range files {
+		physical, err := sourcepath.Resolve(filepath.Join(root, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		want[physical] = fmt.Sprintf("%x", sha256.Sum256([]byte(data)))
+	}
+	physicalEntry, err := sourcepath.Resolve(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want[input] = want[physicalEntry] // The original top-level request stays visible.
+	if !reflect.DeepEqual(inputs.Inputs, want) {
+		t.Fatalf("missing generated source invented or actual nested inputs lost: got=%v want=%v", inputs, want)
+	}
+	wantMiss := filepath.Join(filepath.Dir(physicalEntry), "go_asm.h")
+	if !reflect.DeepEqual(inputs.SearchMisses, []string{wantMiss}) {
+		t.Fatalf("unread generated header absence disappeared: %v", inputs.SearchMisses)
+	}
+}
+
+func TestReadGoAssemblySourceInputsRetainRequestedAliases(t *testing.T) {
+	root := t.TempDir()
+	entry := filepath.Join(root, "entry_amd64.s")
+	include := filepath.Join(root, "alias.inc")
+	target := filepath.Join(root, "actual.inc")
+	const data = "#define BIAS 7\n"
+	if err := os.WriteFile(target, []byte(data), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(target, include); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(entry, []byte("#include \"alias.inc\"\nTEXT ·Value(SB),$0-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	_, inputs, err := ReadGoAssemblySourceWithReport(entry, root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	physical, err := sourcepath.Resolve(target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	physicalDirectory, err := sourcepath.Resolve(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	requestedInclude := filepath.Join(physicalDirectory, filepath.Base(include))
+	if inputs.Inputs[requestedInclude] != fmt.Sprintf("%x", sha256.Sum256([]byte(data))) || inputs.Inputs[physical] != inputs.Inputs[requestedInclude] {
+		t.Fatal("original include alias/actual target disappeared from the same read inventory", inputs)
+	}
+}
+
+func TestReadGoAssemblySourceReportSeparatesFallbackSearchMiss(t *testing.T) {
+	for _, include := range []string{"fallback.inc", "missing/fallback.inc"} {
+		t.Run(include, func(t *testing.T) {
+			root, sdk := t.TempDir(), t.TempDir()
+			entry := filepath.Join(root, "entry_amd64.s")
+			fallback := filepath.Join(sdk, "pkg", "include", filepath.FromSlash(include))
+			if err := os.MkdirAll(filepath.Dir(fallback), 0700); err != nil {
+				t.Fatal(err)
+			}
+			const data = "#define BIAS 7\n"
+			if err := os.WriteFile(fallback, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(entry, []byte("#include \""+include+"\"\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			// This filesystem-only read report makes no compiler/source claim.
+			report := &GoAssemblySourceReadReport{Inputs: make(map[string]string)}
+			observed, err := readGoAssemblySource(entry, root, sdk, report)
+			plain, plainErr := ReadGoAssemblySourceAtGOROOT(entry, root, sdk)
+			if err != nil || plainErr != nil || string(observed) != data || !reflect.DeepEqual(plain, observed) {
+				t.Fatalf("same-pass fallback changed expansion: %q %v %v", observed, err, plainErr)
+			}
+			physicalRoot, err := sourcepath.Resolve(root)
+			if err != nil {
+				t.Fatal(err)
+			}
+			miss := filepath.Join(physicalRoot, filepath.FromSlash(include))
+			if _, invented := report.Inputs[miss]; invented || !reflect.DeepEqual(report.SearchMisses, []string{miss}) {
+				t.Fatalf("search miss became read input or disappeared: %+v", report)
+			}
+			physicalFallback, err := sourcepath.Resolve(fallback)
+			if err != nil || report.Inputs[physicalFallback] != fmt.Sprintf("%x", sha256.Sum256([]byte(data))) {
+				t.Fatalf("actual fallback bytes absent: %+v %v", report, err)
+			}
+		})
+	}
+}
+
+func TestReadGoAssemblySourceReportErrorReturnsNoInventory(t *testing.T) {
+	root := t.TempDir()
+	entry := filepath.Join(root, "entry_amd64.s")
+	if err := os.WriteFile(entry, []byte("#include \"cycle.inc\"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "cycle.inc"), []byte("#include \"cycle.inc\"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	data, report, err := ReadGoAssemblySourceWithReport(entry, root)
+	if err == nil || data != nil || report != nil {
+		t.Fatalf("partial read became successful inventory: %q %+v %v", data, report, err)
+	}
+}
diff --git a/assembly_include_symlink_test.go b/assembly_include_symlink_test.go
new file mode 100644
index 000000000..1de5d1032
--- /dev/null
+++ b/assembly_include_symlink_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestReadGoAssemblySourceRejectsSymlinkIncludeOutsideRoot(t *testing.T) {
+	sandbox := t.TempDir()
+	sourceRoot := filepath.Join(sandbox, "module")
+	if err := os.Mkdir(sourceRoot, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	outside := filepath.Join(sandbox, "outside.h")
+	if err := os.WriteFile(outside, []byte("#define OUTSIDE 1\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(outside, filepath.Join(sourceRoot, "escape.h")); err != nil {
+		t.Fatal(err)
+	}
+	asm := filepath.Join(sourceRoot, "entry_amd64.s")
+	if err := os.WriteFile(asm, []byte("#include \"escape.h\"\nTEXT ·entry(SB),$0-0\nRET\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := ReadGoAssemblySource(asm, sourceRoot)
+	if err == nil || !strings.Contains(err.Error(), "escapes source root") {
+		t.Fatalf("ReadGoAssemblySource symlink escape error = %v, want source-root rejection", err)
+	}
+}
diff --git a/assembly_include_test.go b/assembly_include_test.go
new file mode 100644
index 000000000..5df2836d7
--- /dev/null
+++ b/assembly_include_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"go/build"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestAssemblyIncludeSymlinkRegressionIsAvailableOnSupportedHosts(t *testing.T) {
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm"},
+		{"linux", "arm64"}, {"darwin", "amd64"}, {"darwin", "arm64"},
+		{"windows", "amd64"}, {"windows", "386"},
+	} {
+		t.Run(target.os+"/"+target.arch, func(t *testing.T) {
+			context := build.Default
+			context.GOOS, context.GOARCH = target.os, target.arch
+			included, err := context.MatchFile(".", "assembly_include_symlink_test.go")
+			if err != nil || !included {
+				t.Fatalf("source-root include escape regression is excluded: %v", err)
+			}
+		})
+	}
+}
+
+func TestReadGoAssemblySourceExpandsToolchainHeadersInTrimpathBinary(t *testing.T) {
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "funcdata_amd64.s")
+	source := `#include "funcdata.h"
+TEXT ·metadata(SB),$0-0
+ GO_ARGS
+ GO_RESULTS_INITIALIZED
+ NO_LOCAL_POINTERS
+ RET
+`
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	program := `package main
+import (
+    "fmt"
+    "os"
+    plan9asm "github.com/xgo-dev/plan9asm"
+)
+func main() {
+    source, err := plan9asm.ReadGoAssemblySource(os.Args[1], os.Args[2])
+    if err != nil {
+        panic(err)
+    }
+    file, err := plan9asm.Parse(plan9asm.ArchAMD64, string(source))
+    if err != nil {
+        panic(err)
+    }
+    for _, ins := range file.Funcs[0].Instrs {
+        fmt.Println(ins.Op)
+    }
+}
+`
+	mainFile := filepath.Join(dir, "main.go")
+	if err := os.WriteFile(mainFile, []byte(program), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	bin := filepath.Join(dir, "read-asm")
+	if runtime.GOOS == "windows" {
+		bin += ".exe"
+	}
+	build := frameworkChildGoBuildCommand("-trimpath", "-o", bin, mainFile)
+	if out, err := build.CombinedOutput(); err != nil {
+		t.Fatalf("build trimpath reader: %v\n%s", err, out)
+	}
+	run := exec.Command(bin, asm, dir)
+	for _, item := range os.Environ() {
+		if !strings.HasPrefix(item, "GOROOT=") {
+			run.Env = append(run.Env, item)
+		}
+	}
+	out, err := run.CombinedOutput()
+	if err != nil {
+		t.Fatalf("run trimpath reader: %v\n%s", err, out)
+	}
+	want := "TEXT\nFUNCDATA\nPCDATA\nFUNCDATA\nRET\n"
+	if string(out) != want {
+		t.Fatalf("trimpath reader ops = %q, want %q", out, want)
+	}
+}
+
+func TestReadGoAssemblySourceRejectsEscapedSourceAlias(t *testing.T) {
+	root := t.TempDir()
+	outside := filepath.Join(t.TempDir(), "outside.s")
+	if err := os.WriteFile(outside, []byte("TEXT ·Probe(SB),$0-0\nRET\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(root, "alias.s")
+	if err := os.Symlink(outside, alias); err != nil {
+		t.Fatal(err)
+	}
+	if source, err := ReadGoAssemblySource(alias, root); err == nil || len(source) != 0 {
+		t.Fatalf("existing source outside its resolved root was accepted: %v", err)
+	}
+}
+
+func TestReadGoAssemblySourceExpandsNestedLocalHeaders(t *testing.T) {
+	dir := t.TempDir()
+	write := func(name, content string) {
+		t.Helper()
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("ops.h", "#define SAVE(offset) MOVD R19, offset(RSP)\n")
+	write("abi.h", "#include \"ops.h\"\n")
+	write("entry_arm64.s", "#include \"abi.h\"\nTEXT entry(SB),$0-0\nSAVE(8)\nRET\n")
+
+	src, err := ReadGoAssemblySource(filepath.Join(dir, "entry_arm64.s"), dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(src), `#include "abi.h"`) || !strings.Contains(string(src), "#define SAVE") {
+		t.Fatalf("nested header was not expanded:\n%s", src)
+	}
+	if _, err := ParseWithDefines(ArchARM64, string(src), GoAssemblerDefines("linux", "arm64")); err != nil {
+		t.Fatalf("expanded assembly did not parse: %v\n%s", err, src)
+	}
+}
diff --git a/benchmark_compile_script_test.go b/benchmark_compile_script_test.go
new file mode 100644
index 000000000..d3a3d257d
--- /dev/null
+++ b/benchmark_compile_script_test.go
@@ -0,0 +1,308 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+var compileBenchmarkScriptTargets = []string{
+	"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm",
+}
+
+// These are command/report protocol fixtures, not Go/LLVM compilers or object
+// evidence. Real standard-library compilation remains a separate required gate.
+const compileBenchmarkScriptGoFixture = `#!/usr/bin/env bash
+set -euo pipefail
+if [[ "$1" == env && "$2" == GOVERSION ]]; then
+  printf 'go1.27.1\n'
+  exit 0
+fi
+if [[ "$1" != build ]]; then
+  exit 91
+fi
+while (( $# > 0 )); do
+  if [[ "$1" == -o ]]; then
+    cp "$PLAN9ASM_BENCH_TEST_TRANSLATOR" "$2"
+    exit 0
+  fi
+  shift
+done
+exit 92
+`
+
+const compileBenchmarkScriptTranslatorFixture = `#!/usr/bin/env bash
+set -euo pipefail
+goos= goarch= report= out= keep_going=
+for arg in "$@"; do
+  case "$arg" in
+    -goos=*) goos=${arg#*=} ;;
+    -goarch=*) goarch=${arg#*=} ;;
+    -report=*) report=${arg#*=} ;;
+    -out=*) out=${arg#*=} ;;
+    -keep-going=*) keep_going=${arg#*=} ;;
+  esac
+done
+printf '%s/%s %s\n' "$goos" "$goarch" "$keep_going" >> "$PLAN9ASM_BENCH_TEST_TRACE"
+mkdir -p "$out"
+printf 'protocol fixture only, not an LLVM object\n' > "$out/fixture.txt"
+
+total=2 success=2 failed=0 na=0 code=0
+if [[ "$goarch" == 386 ]]; then
+  case "$PLAN9ASM_BENCH_TEST_MODE" in
+    command_failure) success=1; failed=1; code=17 ;;
+    failed_counts) success=1; failed=1 ;;
+    nonzero_success_counts) code=17 ;;
+    incomplete) success=1 ;;
+    source_na) success=1; na=1 ;;
+    empty) total=0; success=0 ;;
+    negative_counts) success=-1; failed=3 ;;
+    excessive_counts) success=3 ;;
+    wrong_target) goarch=arm64 ;;
+    target_budget) sleep 2 ;;
+    malformed)
+      printf '{invalid report\n' > "$report"
+      exit 17
+      ;;
+    missing) exit 17 ;;
+  esac
+fi
+printf '{"goos":"%s","goarch":"%s","asm_files":["one.s","two.s"],"total_asm":%s,"success":%s,"failed":%s,"not_applicable":%s,"duration":"1ms"}\n' \
+  "$goos" "$goarch" "$total" "$success" "$failed" "$na" > "$report"
+if (( failed > 0 )); then
+  jq --argjson count "$failed" '
+    .fails = [range(0; $count) | {pkg_path:"fixture", asm_file:"one.s", err:"protocol failure"}]
+  ' "$report" > "$report.changed"
+  mv "$report.changed" "$report"
+fi
+if [[ "$goarch" == 386 && "$PLAN9ASM_BENCH_TEST_MODE" == stale_failures ]]; then
+  jq '.fails = [{pkg_path:"fixture", asm_file:"one.s", err:"retained failure"}]' \
+    "$report" > "$report.changed"
+  mv "$report.changed" "$report"
+fi
+if [[ "$goarch" == 386 && "$PLAN9ASM_BENCH_TEST_MODE" == duplicate_files ]]; then
+  jq '.asm_files = ["one.s", "one.s"]' "$report" > "$report.changed"
+  mv "$report.changed" "$report"
+fi
+exit "$code"
+`
+
+type compileBenchmarkScriptFixture struct {
+	directory, report, trace, script string
+	environment                      []string
+}
+
+func newCompileBenchmarkScriptFixture(t *testing.T, mode string) compileBenchmarkScriptFixture {
+	t.Helper()
+	jq, err := exec.LookPath("jq")
+	if err != nil {
+		t.Fatalf("benchmark protocol tests require jq: %v", err)
+	}
+	dir := t.TempDir()
+	bin := filepath.Join(dir, "bin")
+	scripts := filepath.Join(dir, "scripts")
+	for _, name := range []string{bin, scripts} {
+		if err := os.Mkdir(name, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, name := range []string{"benchmark-compile.sh", "llvm22.sh"} {
+		data, err := os.ReadFile(filepath.Join("scripts", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(scripts, name), data, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	translator := filepath.Join(bin, "protocol-translator")
+	for name, source := range map[string]string{
+		"go":                  compileBenchmarkScriptGoFixture,
+		"protocol-translator": compileBenchmarkScriptTranslatorFixture,
+		"llc-22":              "#!/bin/sh\nprintf 'LLVM version 22.1.8\\n'\n",
+	} {
+		if err := os.WriteFile(filepath.Join(bin, name), []byte(source), 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fixture := compileBenchmarkScriptFixture{
+		directory: dir, report: filepath.Join(dir, "reports"),
+		trace: filepath.Join(dir, "trace.txt"), script: filepath.Join(scripts, "benchmark-compile.sh"),
+	}
+	// The command directory remains native; Bash inputs and PATH must use
+	// that shell's actual path mapping, not Windows' semicolon search list.
+	paths := []string{bin, filepath.Dir(jq), translator, fixture.trace, fixture.script, fixture.report}
+	if runtime.GOOS == "windows" {
+		ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		args := append([]string{"-c", `for name in "$@"; do cygpath -u -- "$name" || exit; done`, "fixture-paths"}, paths...)
+		output, err := exec.CommandContext(ctx, "bash", args...).CombinedOutput()
+		if err != nil {
+			t.Fatalf("resolve native paths for the actual Bash fixture: %v\n%s", err, output)
+		}
+		converted := strings.Split(strings.TrimSuffix(string(output), "\n"), "\n")
+		if len(converted) != len(paths) {
+			t.Fatalf("incomplete shell path mapping: %q", output)
+		}
+		paths = converted
+	}
+	fixture.script = paths[4]
+	fixture.environment = append(os.Environ(),
+		"PATH="+paths[0]+":"+paths[1]+":/usr/bin:/bin",
+		"PLAN9ASM_BENCH_TEST_TRANSLATOR="+paths[2],
+		"PLAN9ASM_BENCH_TEST_MODE="+mode,
+		"PLAN9ASM_BENCH_TEST_TRACE="+paths[3],
+		"PLAN9ASM_BENCHMARK_TARGETS="+strings.Join(compileBenchmarkScriptTargets, ","),
+		"PLAN9ASM_BENCHMARK_REPORT_DIR="+paths[5],
+		"PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS=300",
+		"PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS=900",
+		"GITHUB_ACTIONS=true", "GITHUB_STEP_SUMMARY=",
+	)
+	if mode == "target_budget" {
+		fixture.environment = append(fixture.environment, "PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS=1")
+	}
+	return fixture
+}
+
+func (fixture compileBenchmarkScriptFixture) run(t *testing.T) (string, error) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, "bash", fixture.script)
+	command.Dir, command.Env = fixture.directory, fixture.environment
+	output, err := command.CombinedOutput()
+	if ctx.Err() != nil {
+		t.Fatalf("benchmark protocol fixture exceeded its bounded operation: %v\n%s", ctx.Err(), output)
+	}
+	return string(output), err
+}
+
+func TestCompileBenchmarkRetainsWholeFailedTargetMatrix(t *testing.T) {
+	fixture := newCompileBenchmarkScriptFixture(t, "command_failure")
+	output, err := fixture.run(t)
+	if err == nil {
+		t.Fatalf("failed command became a passing benchmark: %s", output)
+	}
+	data, err := os.ReadFile(fixture.trace)
+	if err != nil {
+		t.Fatalf("benchmark fixture did not execute its target matrix: %v\n%s", err, output)
+	}
+	var want []string
+	for _, target := range compileBenchmarkScriptTargets {
+		want = append(want, target+" true")
+	}
+	if got := strings.Split(strings.TrimSpace(string(data)), "\n"); !reflect.DeepEqual(got, want) {
+		t.Fatalf("first failure hid untested files or remaining platforms: got=%v want=%v\n%s", got, want, output)
+	}
+	if strings.Count(output, "::group::") != strings.Count(output, "::endgroup::") {
+		t.Fatalf("failed target left benchmark details unfolded: %s", output)
+	}
+}
+
+func TestCompileBenchmarkSummaryNeverHidesFailures(t *testing.T) {
+	for _, mode := range []string{
+		"success", "command_failure", "failed_counts", "nonzero_success_counts",
+		"incomplete", "source_na", "empty", "malformed", "missing",
+		"negative_counts", "excessive_counts", "wrong_target", "target_budget", "stale_failures", "duplicate_files",
+	} {
+		t.Run(mode, func(t *testing.T) {
+			fixture := newCompileBenchmarkScriptFixture(t, mode)
+			output, runErr := fixture.run(t)
+			data, err := os.ReadFile(filepath.Join(fixture.report, "summary.json"))
+			if err != nil {
+				t.Fatalf("failed benchmark omitted its complete summary: %v\n%s", err, output)
+			}
+			var summary struct {
+				SchemaVersion int  `json:"schema_version"`
+				AllPassed     bool `json:"all_passed"`
+				Targets       []struct {
+					Target      string `json:"target"`
+					Status      string `json:"status"`
+					CommandExit int    `json:"command_exit"`
+					ReportValid bool   `json:"report_valid"`
+					Unattempted *int   `json:"unattempted"`
+					Success     *int   `json:"success"`
+					Failed      *int   `json:"failed"`
+				} `json:"targets"`
+			}
+			if err := json.Unmarshal(data, &summary); err != nil {
+				t.Fatal(err)
+			}
+			if summary.SchemaVersion != 2 || len(summary.Targets) != len(compileBenchmarkScriptTargets) {
+				t.Fatalf("incomplete benchmark matrix: %s", data)
+			}
+			for index, target := range summary.Targets {
+				if target.Target != compileBenchmarkScriptTargets[index] ||
+					index > 0 && (target.Status != "passed" || target.CommandExit != 0) {
+					t.Fatalf("matrix lost independent later targets: %s", data)
+				}
+			}
+			wantPass := mode == "success"
+			if summary.AllPassed != wantPass || (runErr == nil) != wantPass ||
+				(summary.Targets[0].Status == "passed") != wantPass {
+				t.Fatalf("failed/missing/unattempted evidence became successful: mode=%s error=%v summary=%s", mode, runErr, data)
+			}
+			if mode == "command_failure" || mode == "nonzero_success_counts" || mode == "missing" || mode == "malformed" {
+				if summary.Targets[0].CommandExit != 17 {
+					t.Fatalf("actual command failure was discarded: %s", data)
+				}
+			}
+			if mode == "incomplete" && (summary.Targets[0].Unattempted == nil || *summary.Targets[0].Unattempted != 1) {
+				t.Fatalf("unattempted file was hidden: %s", data)
+			}
+			if mode == "command_failure" || mode == "failed_counts" {
+				first := summary.Targets[0]
+				if !first.ReportValid || first.Success == nil || *first.Success != 1 || first.Failed == nil || *first.Failed != 1 {
+					t.Fatalf("valid failure evidence lost its actual counters: %s", data)
+				}
+			}
+			switch mode {
+			case "negative_counts", "excessive_counts", "wrong_target", "empty", "malformed", "missing", "stale_failures", "duplicate_files":
+				if summary.Targets[0].ReportValid || summary.Targets[0].Unattempted != nil {
+					t.Fatalf("invalid evidence supplied known counts or a valid report: %s", data)
+				}
+			}
+		})
+	}
+}
+
+func TestCompileBenchmarkRefusesToOverwriteExistingEvidence(t *testing.T) {
+	fixture := newCompileBenchmarkScriptFixture(t, "success")
+	if err := os.Mkdir(fixture.report, 0700); err != nil {
+		t.Fatal(err)
+	}
+	file := filepath.Join(fixture.report, "summary.json")
+	original := []byte("retained failed report; not a reusable current-head pass\n")
+	if err := os.WriteFile(file, original, 0600); err != nil {
+		t.Fatal(err)
+	}
+	output, err := fixture.run(t)
+	if err == nil {
+		t.Fatalf("existing reports were silently overwritten: %s", output)
+	}
+	got, err := os.ReadFile(file)
+	if err != nil || string(got) != string(original) {
+		t.Fatalf("previous evidence was changed: %q %v", got, err)
+	}
+}
+
+func TestCompileBenchmarkRejectsDuplicateTargets(t *testing.T) {
+	fixture := newCompileBenchmarkScriptFixture(t, "success")
+	fixture.environment = append(fixture.environment, "PLAN9ASM_BENCHMARK_TARGETS=linux/amd64,linux/amd64")
+	output, err := fixture.run(t)
+	if err == nil {
+		t.Fatalf("duplicate target reuses one report as independent coverage: %s", output)
+	}
+	if _, err := os.Stat(fixture.trace); !os.IsNotExist(err) {
+		t.Fatalf("invalid target matrix launched a compiler: %v", err)
+	}
+	t.Log(fmt.Sprintf("duplicate target protocol was rejected: %s", strings.TrimSpace(output)))
+}
diff --git a/ci_module_policy_test.go b/ci_module_policy_test.go
new file mode 100644
index 000000000..c1f7cb06b
--- /dev/null
+++ b/ci_module_policy_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestCIModuleSuitesKeepExhaustiveUnixAndWindowsRoles(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	script, err := os.ReadFile("scripts/test-module-ci.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, item := range []struct {
+		job, flags string
+		parts      int
+	}{
+		{"test", "test) timeout=45m", 16},
+		{"race", "race) timeout=60m; flags=(-race); root_partitions=32; shards=64", 32},
+		{"coverage", "coverage) timeout=45m; flags=(-coverprofile=coverage-root.out)", 16},
+	} {
+		job, found := ciWorkflowJob(string(data), item.job)
+		command := "bash scripts/test-module-ci.sh " + item.job + " execute ${{ matrix.module-owner }} ${{ matrix.root-partition }}"
+		if !found || !strings.Contains(job, command) || !strings.Contains(string(script), item.flags) {
+			t.Errorf("%s must keep the complete actual module inventory/flags using bounded partition ownership", item.job)
+		}
+		var roles []string
+		for part := 0; part < item.parts; part++ {
+			roles = append(roles, fmt.Sprintf("root-%d", part))
+		}
+		roles = append(roles, "profile", "other")
+		normalizedJob := strings.Join(strings.Fields(job), " ")
+		for _, required := range []string{"module-role: [" + strings.Join(roles, ", ") + "]", "fail-fast: false", "actions/upload-artifact@v6"} {
+			if !strings.Contains(normalizedJob, required) {
+				t.Errorf("%s missing exhaustive scheduling/artifact requirement %q", item.job, required)
+			}
+		}
+		if strings.Contains(job, "module-owner: [") || strings.Contains(job, "max-parallel:") || strings.Contains(job, "continue-on-error:") {
+			t.Errorf("%s repeats package owners or masks/limits scheduling", item.job)
+		}
+	}
+	aggregate, found := ciWorkflowJob(string(data), "module-completion")
+	if !found || !strings.Contains(aggregate, "needs: [test, nested-cli, race, coverage, nested-cli-coverage]") || !strings.Contains(aggregate, "!cancelled()") ||
+		!strings.Contains(aggregate, "owner-0000") || !strings.Contains(aggregate, "owner-0001") || !strings.Contains(aggregate, "owner-0002") {
+		t.Error("missing mandatory complete cross-owner readback")
+	}
+	for part := 0; part < 32; part++ {
+		if !strings.Contains(aggregate, fmt.Sprintf("Download root part %d", part)) ||
+			!strings.Contains(aggregate, fmt.Sprintf("-owners/owner-0000/part-%04d", part)) {
+			t.Errorf("missing exact root part %d download", part)
+		}
+		marker := fmt.Sprintf("      - name: Download root part %d\n", part)
+		_, download, ok := strings.Cut(aggregate, marker)
+		if !ok {
+			continue
+		}
+		download, _, _ = strings.Cut(download, "\n      - name:")
+		if part < 16 {
+			if strings.Contains(download, "matrix.flavor ==") ||
+				(part != 0 && !strings.Contains(download, "if: ${{ !cancelled() }}")) {
+				t.Errorf("every flavor requires original root part %d even after another owner fails", part)
+			}
+		} else if !strings.Contains(download, "if: ${{ !cancelled() && matrix.flavor == 'race' }}") {
+			t.Errorf("only race owns global root part %d", part)
+		}
+	}
+	for _, required := range []string{"-module -out=", "-shards=$shards -workers=2", "root_partitions=16", "shards=32", "-module-root-partitions=$root_partitions", "-verify-module=_out/module-$flavor-owners", "go run ./cmd/plan9asmtest"} {
+		if !strings.Contains(string(script), required) {
+			t.Errorf("module driver changed complete inventory/scheduling: %s", required)
+		}
+	}
+	test, _ := ciWorkflowJob(string(data), "test")
+	windows, found := ciWorkflowJob(string(data), "windows-module")
+	if !found || !strings.Contains(windows, "needs: ci_policy") ||
+		!strings.Contains(windows, "module: [root, plan9asm, plan9asmll]") ||
+		!strings.Contains(windows, "uses: ./.github/workflows/windows-module.yml") ||
+		!strings.Contains(windows, "fail-fast: false") {
+		t.Error("all Windows modules need independent exhaustive partition/aggregate workflows")
+	}
+	if strings.Contains(test, "os: windows-latest") || strings.Contains(windows, "continue-on-error:") {
+		t.Error("Windows complete module roles must not duplicate direct suites or hide failures")
+	}
+	if !strings.Contains(test, "| grep -Fx 'TestAMD64DownloadedFixedLocalLLVM22Numerical'") {
+		t.Error("required numerical inventory must use the provisioned fixed-line filter, not optional ripgrep")
+	}
+	nested, found := ciWorkflowJob(string(data), "nested-cli")
+	if !found || !strings.Contains(nested, "needs: ci_policy") ||
+		!strings.Contains(nested, "go-version: ['1.24.x', '1.25.x', '1.26.x', '1.27.2']") ||
+		!strings.Contains(nested, "module: [plan9asm, plan9asmll]") ||
+		!strings.Contains(nested, "uses: ./.github/workflows/linux-cli-module.yml") ||
+		!strings.Contains(nested, "module: ${{ matrix.module }}") ||
+		!strings.Contains(nested, "go-version: ${{ matrix.go-version }}") ||
+		!strings.Contains(nested, "flavor: test") || !strings.Contains(nested, "fail-fast: false") {
+		t.Error("both complete nested CLIs need independent exhaustive SDK/module partition workflows")
+	}
+	if strings.Contains(test, "nested_modules") || strings.Contains(test, "working-directory: cmd/plan9asm") ||
+		strings.Contains(nested, "module-owner") || strings.Contains(nested, "max-parallel:") ||
+		strings.Contains(nested, "continue-on-error:") || strings.Contains(nested, "if:") {
+		t.Error("nested CLI jobs must remain independent of other module failures without skipped or hidden outcomes")
+	}
+	coverage, _ := ciWorkflowJob(string(data), "coverage")
+	if strings.Contains(coverage, "codecov/codecov-action") || !strings.Contains(aggregate, "files: ./coverage-root.out") {
+		t.Error("coverage upload must use complete module union, never one owner's partial file")
+	}
+	nestedCoverage, found := ciWorkflowJob(string(data), "nested-cli-coverage")
+	for _, required := range []string{
+		"needs: ci_policy", "go-version: '1.27.2'", "module: [plan9asm, plan9asmll]",
+		"fail-fast: false", "uses: ./.github/workflows/linux-cli-module.yml",
+		"module: ${{ matrix.module }}", "flavor: coverage",
+	} {
+		if !found || !strings.Contains(nestedCoverage, required) {
+			t.Errorf("complete CLI coverage needs independent original budgets and command: %s", required)
+		}
+	}
+	if strings.Contains(coverage, "working-directory: cmd/") || strings.Contains(nestedCoverage, "module-owner") ||
+		strings.Contains(nestedCoverage, "max-parallel:") || strings.Contains(nestedCoverage, "continue-on-error:") ||
+		strings.Contains(nestedCoverage, "if:") {
+		t.Error("complete CLI coverage cannot share remaining-package budgets or mask outcomes")
+	}
+	if !strings.Contains(aggregate, "if: ${{ !cancelled() && matrix.flavor == 'coverage' }}") ||
+		!strings.Contains(aggregate, "run: test '${{ needs['nested-cli-coverage'].result }}' = success") {
+		t.Error("failed CLI coverage must fail completion after original main-module evidence collection")
+	}
+}
+
+func TestCILinuxCLIModulesKeepCompleteRolesAndBudgets(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/linux-cli-module.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	roots, found := ciWorkflowJob(string(data), "root-parts")
+	if !found || !strings.Contains(roots, "part: [0, 1, 2, 3]") ||
+		!strings.Contains(roots, "timeout-minutes: 60") || !strings.Contains(roots, "fail-fast: false") {
+		t.Fatal("Linux CLI requires four independently budgeted exhaustive root parts")
+	}
+	for _, required := range []string{
+		"execute 0 ${{ matrix.part }}", "execute 1 -1", "execute 2 -1",
+		"!cancelled() && matrix.part == 0", "always() && matrix.part == 0",
+		"-owner-1/", "-owner-2/", "actions/upload-artifact@v6",
+	} {
+		if !strings.Contains(roots, required) {
+			t.Errorf("Linux CLI root part zero must retain actual other-owner protocol: %s", required)
+		}
+	}
+	complete, found := ciWorkflowJob(string(data), "complete")
+	if !found || !strings.Contains(complete, "needs: root-parts") ||
+		!strings.Contains(complete, "if: ${{ !cancelled() }}") ||
+		!strings.Contains(complete, "test '${{ needs.root-parts.result }}' = success") {
+		t.Fatal("Linux CLI complete reader must collect all evidence and reject failed owners")
+	}
+	for _, required := range []string{"owner-0001", "owner-0002", "part-0000", "part-0001", "part-0002", "part-0003",
+		"Verify complete CLI module", "inputs.flavor == 'coverage'",
+		"go tool cover -func=coverage-${{ inputs.module }}.out | tail -n 1"} {
+		if !strings.Contains(complete, required) {
+			t.Errorf("complete CLI union/coverage lost %s", required)
+		}
+	}
+	driver, err := os.ReadFile("scripts/test-linux-cli-module-ci.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{"-module", "-dir=cmd/$module", "-shards=8", "-workers=2",
+		"-timeout=30m", "-module-root-partitions=4", "-verify-module=", "GOMAXPROCS=2",
+		"test) flags=()", "coverage) flags=(\"-coverprofile=coverage-$module.out\")"} {
+		if !strings.Contains(string(driver), required) {
+			t.Errorf("Linux CLI driver changed exhaustive scope/budget: %s", required)
+		}
+	}
+}
+
+func TestCIWindowsModulesKeepCompleteCoverageAndBudgets(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/windows-module.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"root-parts", "other-owners", "complete"} {
+		job, found := ciWorkflowJob(string(data), name)
+		if !found || !strings.Contains(job, "runs-on: windows-latest") ||
+			!strings.Contains(job, "uses: ./.github/actions/setup-windows-llvm22") ||
+			!strings.Contains(job, "uses: ./.github/actions/setup-node22") || !strings.Contains(job, "timeout-minutes: 10") {
+			t.Fatalf("Windows %s must retain identical native tool/runtime setup", name)
+		}
+		if strings.Contains(job, "max-parallel:") || strings.Contains(job, "continue-on-error:") {
+			t.Fatalf("Windows %s masks or throttles required execution", name)
+		}
+	}
+	complete, _ := ciWorkflowJob(string(data), "complete")
+	if !strings.Contains(complete, "needs: [root-parts, other-owners]") ||
+		!strings.Contains(complete, "if: ${{ !cancelled() }}") ||
+		!strings.Contains(complete, "test-windows-module-ci.sh ${{ inputs.module }} complete") {
+		t.Fatal("Windows completion must independently reject missing/failed owners")
+	}
+	for part := 0; part < 8; part++ {
+		if !strings.Contains(complete, fmt.Sprintf("-owners/owner-0000/part-%04d", part)) {
+			t.Fatalf("missing Windows root part %d artifact", part)
+		}
+	}
+	for _, owner := range []string{"owner-0001", "owner-0002"} {
+		if !strings.Contains(complete, "-owners/"+owner) {
+			t.Fatalf("missing Windows %s artifact", owner)
+		}
+	}
+	script, err := os.ReadFile("scripts/test-windows-module-ci.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{"-module", "-timeout=30m", "-workers=2", "-module-root-partitions=$parts", "-tags=byollvm", "-verify-module="} {
+		if !strings.Contains(string(script), required) {
+			t.Fatalf("Windows module driver lost %s", required)
+		}
+	}
+}
diff --git a/ci_native_avx512_policy_test.go b/ci_native_avx512_policy_test.go
new file mode 100644
index 000000000..7ff443f5a
--- /dev/null
+++ b/ci_native_avx512_policy_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// The explicit inventory records pending native execution, never a passing
+// substitute for it. Grammar, original-source and object tests remain default.
+func TestCIAVX512NativeQualificationInventory(t *testing.T) {
+	data, err := os.ReadFile("testdata/native/avx512-roots.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := strings.Fields(string(data))
+	if len(want) != 65 || !sort.StringsAreSorted(want) {
+		t.Fatal("native qualification must retain all 65 canonical owners")
+	}
+	for i, name := range want {
+		if !strings.HasPrefix(name, "Test") || i > 0 && name == want[i-1] {
+			t.Fatal("invalid or duplicate native qualification owner", name)
+		}
+	}
+
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm64"},
+		{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+	} {
+		t.Run(target.os+"-"+target.arch, func(t *testing.T) {
+			ordinary := ciNativeAVX512Roots(t, target.os, target.arch, false)
+			qualified := ciNativeAVX512Roots(t, target.os, target.arch, true)
+			var added []string
+			for name := range ordinary {
+				if !qualified[name] {
+					t.Fatal("qualification tag removed an ordinary test", name)
+				}
+			}
+			for name := range qualified {
+				if !ordinary[name] {
+					added = append(added, name)
+				}
+			}
+			sort.Strings(added)
+			if target.os != "linux" || target.arch != "amd64" {
+				if len(added) != 0 {
+					t.Fatal("native AMD64 qualification escaped its actual host", added)
+				}
+				return
+			}
+			if !reflect.DeepEqual(added, want) {
+				t.Fatal("native qualification inventory differs from pending owners", added)
+			}
+			for _, name := range []string{
+				"TestAMD64ConformanceNativeGo",
+				"TestAMD64ConformanceLLVMRuntime",
+				"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedSSE",
+				"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalVEX",
+				"TestCrossLinuxRuntimeMatrixX86PackedConversionLegacyIEEEStatusFlags",
+				"TestCrossLinuxRuntimeMatrixX86PackedConversionLegacyDeadFaults",
+				"TestCrossLinuxRuntimeMatrixX86COMIDeadMemoryExtent",
+				"TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlags",
+				"TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSR",
+				"TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeLegacyUnmaskedTraps",
+				"TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansVEX",
+				"TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSRVEX",
+				"TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsVEX",
+				"TestAMD64ConformanceOriginalWideSourceCompiles",
+				"TestGoAMD64FixedLocalPackedWideRuntimeOracleCompileOnly",
+				"TestGoAMD64FixedLocalPackedWideRuntimeOracleModuleCompileOnly",
+				"TestGoAMD64FixedLocalPackedWideRuntimeOracleGoModuleCompileOnly",
+				"TestX86PackedConversionNativeRuntimeFixtureObjects",
+				"TestX86PackedConversionSignedNativeRuntimeFixtureObjects",
+				"TestX86PackedConversionFiveTargetsThreeAPIObjects",
+				"TestX86PackedMoveAlignedOriginalGoOracleCompileOnly",
+				"TestX86PackedMoveGrammarAxesAndFiveLLVM22Targets",
+				"TestX86PackedMoveAlignedResultFiveTargetsThreeAPIs",
+				"TestX86ScalarSqrtNativeFixtureObjects",
+				"TestX86Reciprocal14NativeOriginalGoProgramCompiles",
+				"TestX86Reciprocal14NativeSourceThreeAPIsActualProfileObjects",
+			} {
+				if !ordinary[name] {
+					t.Error("ordinary low-ISA/source/object owner was lost", name)
+				}
+			}
+		})
+	}
+}
+
+func ciNativeAVX512Roots(t *testing.T, goos, goarch string, qualified bool) map[string]bool {
+	t.Helper()
+	ctx := ciNativeAVX512BuildContext(goos, goarch, qualified)
+	entries, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	roots := make(map[string]bool)
+	for _, entry := range entries {
+		name := entry.Name()
+		if !strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		matched, err := ctx.MatchFile(".", name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !matched {
+			continue
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), name, nil, parser.SkipObjectResolution)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, declaration := range file.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Recv != nil || !strings.HasPrefix(function.Name.Name, "Test") {
+				continue
+			}
+			if roots[function.Name.Name] {
+				t.Fatal("duplicate test root", function.Name.Name)
+			}
+			roots[function.Name.Name] = true
+		}
+	}
+	return roots
+}
+
+// Select explicit test build inputs independently of the executing host or
+// ambient tags. This observes file ownership, never native execution.
+func ciNativeAVX512BuildContext(goos, goarch string, qualified bool) build.Context {
+	ctx := build.Default
+	ctx.GOOS, ctx.GOARCH = goos, goarch
+	ctx.BuildTags = nil
+	if qualified {
+		ctx.BuildTags = []string{"plan9asm_native_avx512"}
+	}
+	return ctx
+}
+
+// Fixture policies still inspect the complete original body and source/C
+// hashes. The new tagged root must call it directly after refusing auto mode.
+func ciNativeAVX512RequireWrapper(t *testing.T, root, helper string) {
+	t.Helper()
+	const path = "amd64_native_avx512_qualification_linux_amd64_test.go"
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != root {
+			continue
+		}
+		if fn.Body == nil || len(fn.Body.List) != 2 {
+			t.Fatal("native qualification must retain its policy and complete fixture", root)
+		}
+		for i, name := range []string{"x86RequireNativeAVX512Qualification", helper} {
+			statement, ok := fn.Body.List[i].(*ast.ExprStmt)
+			if !ok {
+				t.Fatal("native qualification call became conditional", root)
+			}
+			call, ok := statement.X.(*ast.CallExpr)
+			if !ok || len(call.Args) != 1 {
+				t.Fatal("native qualification call lost its original test owner", root)
+			}
+			callee, ok := call.Fun.(*ast.Ident)
+			argument, ordinary := call.Args[0].(*ast.Ident)
+			if !ok || !ordinary || callee.Name != name || argument.Name != "t" {
+				t.Fatal("native qualification replaced its complete fixture", root, name)
+			}
+		}
+		return
+	}
+	t.Fatal("missing explicit native qualification wrapper", root)
+}
diff --git a/ci_runtime_policy_test.go b/ci_runtime_policy_test.go
new file mode 100644
index 000000000..b499005e6
--- /dev/null
+++ b/ci_runtime_policy_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestCIFullSuitesHaveExplicitTimeout(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for line, command := range strings.Split(string(data), "\n") {
+		if !strings.Contains(command, "go test ") || !strings.Contains(command, "./...") {
+			continue
+		}
+		var timeout time.Duration
+		for _, field := range strings.Fields(command) {
+			if strings.HasPrefix(field, "-timeout=") {
+				timeout, err = time.ParseDuration(strings.TrimPrefix(field, "-timeout="))
+				if err != nil {
+					t.Errorf("line %d: invalid timeout: %v", line+1, err)
+				}
+			}
+		}
+		if timeout < 20*time.Minute {
+			t.Errorf("line %d: full suite requires an explicit timeout of at least 20m: %s", line+1, strings.TrimSpace(command))
+		}
+	}
+	driver, err := os.ReadFile("scripts/test-linux-cli-module-ci.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{"go run ./cmd/plan9asmtest -module", "-dir=cmd/$module",
+		"-shards=8 -workers=2 -timeout=30m -module-root-partitions=4", "-verify-module="} {
+		if !strings.Contains(string(driver), required) {
+			t.Errorf("complete CLI protocol lost its original command budget/inventory: %s", required)
+		}
+	}
+}
+
+// Follow the actual reusable workflow, checking each execution/reader job on
+// its own. A caller's setup cannot stand in for a missing callee dependency.
+func ciFullSuiteJob(t *testing.T, source, name string) (string, bool) {
+	t.Helper()
+	if strings.HasPrefix(name, "linux-cli-") {
+		data, err := os.ReadFile(".github/workflows/linux-cli-module.yml")
+		if err != nil {
+			t.Fatal(err)
+		}
+		return ciWorkflowJob(string(data), strings.TrimPrefix(name, "linux-cli-"))
+	}
+	return ciWorkflowJob(source, name)
+}
+
+func TestCIShellScriptsUseLFOnEveryHost(t *testing.T) {
+	attributes, err := os.ReadFile(".gitattributes")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(attributes), "*.sh text eol=lf") {
+		t.Fatal("executed and inspected shell scripts require LF checkout on Windows too")
+	}
+}
+
+func TestCIFullSuitesInstallWASMExecutionRuntime(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"cross-runtime", "cross-runtime-verify", "test", "linux-cli-root-parts", "linux-cli-complete", "race", "coverage", "module-completion"} {
+		job, found := ciFullSuiteJob(t, string(data), name)
+		if !found {
+			t.Fatalf("full-suite job %s is missing", name)
+		}
+		if !strings.Contains(job, "uses: ./.github/actions/setup-node22") || !strings.Contains(job, "timeout-minutes: 10") {
+			t.Errorf("%s must install the required wasm execution runtime, not depend on a runner's incidental PATH", name)
+		}
+	}
+}
+
+func TestCIFullSuitesInstallIA32ExecutionToolchain(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"test", "linux-cli-root-parts", "linux-cli-complete", "race", "coverage"} {
+		t.Run(name, func(t *testing.T) {
+			job, found := ciFullSuiteJob(t, string(data), name)
+			if !found {
+				t.Fatalf("full-suite job %s is missing", name)
+			}
+			// These suites include native Linux/386 tests even when the
+			// optional cross-execution matrix is not enabled.
+			install := "bash scripts/install-ci-llvm22-ubuntu.sh gcc-i686-linux-gnu libc6-dev-i386-cross"
+			installer := strings.Index(job, install)
+			runner := strings.Index(job, "bash scripts/test-module-ci.sh")
+			if strings.HasPrefix(name, "linux-cli-") {
+				runner = strings.Index(job, "bash scripts/test-linux-cli-module-ci.sh")
+			}
+			if installer < 0 || runner < 0 || installer >= runner {
+				t.Fatal("required IA32 compiler and libc must be installed before the complete module suite")
+			}
+		})
+	}
+}
+
+func TestCICrossRuntimeUsesPinnedQEMU(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cross, found := ciWorkflowJob(string(data), "cross-runtime")
+	if !found {
+		t.Fatal("cross-runtime job not found")
+	}
+	if !strings.Contains(cross, "bash scripts/install-ci-qemu.sh") || strings.Contains(cross, "qemu-user") {
+		t.Fatal("cross-runtime must install checksum-pinned QEMU, not Ubuntu 24.04's broken 8.2 dot-product implementation")
+	}
+	script, err := os.ReadFile("scripts/install-ci-qemu.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{
+		"version=10.2.3",
+		"release=deploy/v10.2.3-68",
+		"checksum=8e7d8f4c0c7809fc3fea0085199fd6b16f671e7c73d9bf6bec711e1cb535920a",
+		"sha256sum --check --status",
+		"tools=(qemu-aarch64 qemu-arm qemu-i386)",
+		"GITHUB_PATH",
+	} {
+		if !strings.Contains(string(script), required) {
+			t.Errorf("QEMU installer missing %q", required)
+		}
+	}
+}
+
+func TestCIFullSuitesInstallRequiredQEMU(t *testing.T) {
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"test", "linux-cli-root-parts", "linux-cli-complete", "race", "coverage", "module-completion"} {
+		t.Run(name, func(t *testing.T) {
+			job, found := ciFullSuiteJob(t, string(data), name)
+			if !found {
+				t.Fatal("missing complete suite", name)
+			}
+			install := strings.Index(job, "bash scripts/install-ci-qemu.sh")
+			runner := strings.Index(job, "bash scripts/test-module-ci.sh")
+			if strings.HasPrefix(name, "linux-cli-") {
+				runner = strings.Index(job, "bash scripts/test-linux-cli-module-ci.sh")
+			}
+			if install < 0 || runner < 0 || install >= runner {
+				t.Fatal("complete Linux suites require pinned QEMU before their 386 runtime tests")
+			}
+			stepStart := strings.LastIndex(job[:install], "\n      - ")
+			if stepStart < 0 {
+				t.Fatal("QEMU installer has no actual workflow step")
+			}
+			step := job[stepStart:install]
+			// Scope comparison binds the actual process PATH. Every owner and
+			// its aggregate must install the same runtimes in the same order.
+			condition := ""
+			if name == "test" {
+				condition = "if: runner.os == 'Linux'\n"
+			}
+			if !strings.Contains(step, condition) || strings.Contains(step, "matrix.") ||
+				condition == "" && strings.Contains(step, "if:") {
+				t.Fatal("all module owners and the aggregate need identical QEMU provisioning")
+			}
+			if node := strings.Index(job, "uses: ./.github/actions/setup-node22"); node < 0 || install >= node {
+				t.Fatal("all module roles must install QEMU before Node to retain identical PATH order")
+			}
+		})
+	}
+}
+
+func ciWorkflowJob(source, name string) (string, bool) {
+	source = strings.ReplaceAll(source, "\r\n", "\n")
+	_, job, found := strings.Cut(source, "\n  "+name+":\n")
+	if !found {
+		return "", false
+	}
+	lines := strings.Split(job, "\n")
+	for index, line := range lines {
+		if strings.HasPrefix(line, "  ") && len(line) > 2 && line[2] != ' ' && line[2] != '#' {
+			return strings.Join(lines[:index], "\n"), true
+		}
+	}
+	return job, true
+}
+
+func TestCIWorkflowJobLineEndings(t *testing.T) {
+	const source = "jobs:\n  first:\n    run: first\n\n  second:\n    run: second\n"
+	for _, ending := range []string{"\n", "\r\n"} {
+		text := strings.ReplaceAll(source, "\n", ending)
+		job, found := ciWorkflowJob(text, "first")
+		if !found || !strings.Contains(job, "run: first") || strings.Contains(job, "second") {
+			t.Fatalf("line ending %q: job=%q found=%v", ending, job, found)
+		}
+		if _, found := ciWorkflowJob(text, "absent"); found {
+			t.Fatal("missing job accepted")
+		}
+	}
+}
diff --git a/cmd/plan9asm/arm64_go_register_abi_test.go b/cmd/plan9asm/arm64_go_register_abi_test.go
new file mode 100644
index 000000000..1c1690fe2
--- /dev/null
+++ b/cmd/plan9asm/arm64_go_register_abi_test.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestSigsForAsmFileARM64GoInternalSourceContract(t *testing.T) {
+	for _, overflow := range []bool{false, true} {
+		declarations := "package p\nfunc Count([]byte,byte) int\nfunc CountString(string,byte) int\nfunc Classic(uint64) uint64\nfunc Zero() uint64\n"
+		source := "TEXT ·Count<ABIInternal>(SB),4,$0-40\nMOVD R3,R2\nB ·CountString<ABIInternal>(SB)\nTEXT ·CountString<ABIInternal>(SB),4,$0-32\nRET\nTEXT ·Classic(SB),4,$0-16\nCALL ·Zero<ABIInternal>(SB)\nRET\n"
+		if overflow {
+			declarations += "func Spill(" + strings.TrimSuffix(strings.Repeat("uint64,", 17), ",") + ") uint64\n"
+			source += "TEXT ·Forward(SB),4,$0\nCALL ·Spill<ABIInternal>(SB)\nRET\n"
+			declarations += "func Forward()\n"
+		}
+		fset := token.NewFileSet()
+		parsed, err := parser.ParseFile(fset, "p.go", declarations, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		typesPkg, err := new(types.Config).Check("test/internalcontract", fset, []*ast.File{parsed}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := &packages.Package{PkgPath: typesPkg.Path(), Types: typesPkg, TypesSizes: types.SizesFor("gc", "arm64")}
+		file, err := plan9asm.Parse(plan9asm.ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "arm64")
+		if overflow {
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("explicit referenced stack contract lost its error: %v", err)
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		for name, params := range map[string]int{"Count": 4, "CountString": 3, "Zero": 0} {
+			contract := sigs[typesPkg.Path()+"."+name].ARM64GoRegisterABI
+			if contract == nil || len(contract.Params) != params || len(contract.Results) != 1 {
+				t.Fatalf("%s: missing complete source-derived contract: %+v", name, contract)
+			}
+		}
+		if sigs[typesPkg.Path()+".Classic"].ARM64GoRegisterABI != nil {
+			t.Fatal("classic declaration invented an internal entry")
+		}
+	}
+}
diff --git a/cmd/plan9asm/go.mod b/cmd/plan9asm/go.mod
index 5809e299a..286da5460 100644
--- a/cmd/plan9asm/go.mod
+++ b/cmd/plan9asm/go.mod
@@ -8,9 +8,11 @@ require (
 )
 
 require (
-	github.com/xgo-dev/llvm v0.9.9 // indirect
+	github.com/xgo-dev/llvm v0.10.1 // indirect
+	golang.org/x/arch v0.14.0 // indirect
 	golang.org/x/mod v0.33.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
 )
 
 replace github.com/xgo-dev/plan9asm => ../..
diff --git a/cmd/plan9asm/go.sum b/cmd/plan9asm/go.sum
index 59f00a204..b9c5683e1 100644
--- a/cmd/plan9asm/go.sum
+++ b/cmd/plan9asm/go.sum
@@ -1,10 +1,14 @@
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/xgo-dev/llvm v0.9.9 h1:u4RZvy0vxu8nNt4oTrhttyMSyscYtmiy9geP+Kl/RYg=
-github.com/xgo-dev/llvm v0.9.9/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+github.com/xgo-dev/llvm v0.10.1 h1:GZeoapgSKC1Qgfy+xQmlIAKg0Suvrpg4U3Y3xticjqw=
+github.com/xgo-dev/llvm v0.10.1/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4=
+golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
 golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
 golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
diff --git a/cmd/plan9asm/imported_global_source_test.go b/cmd/plan9asm/imported_global_source_test.go
new file mode 100644
index 000000000..6235fdfda
--- /dev/null
+++ b/cmd/plan9asm/imported_global_source_test.go
@@ -0,0 +1,252 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+const simpleImportedStatePath = "example.com/clisource/state"
+
+// Load the real selected files/types once through the CLI's existing loader.
+// No synthetic AST/type package, SDK capture or translation-time reload supplies
+// the imported declarations. The other-OS file must remain unselected.
+func simpleImportedGlobalPackage(t *testing.T, arch string) (*loadedPackage, string, []byte) {
+	t.Helper()
+	directory := t.TempDir()
+	symbol := strings.NewReplacer("/", "∕", ".", "·").Replace(simpleImportedStatePath)
+	var source strings.Builder
+	for _, row := range []struct{ name, instruction string }{
+		{"CompareByte", "CMPB " + symbol + "·Flags(SB),$1"},
+		{"CompareWord", "CMPL " + symbol + "·Word(SB),$0x12345678"},
+		{"CompareLocal", "CMPB ·Flags(SB),$0"},
+	} {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n%s\nJNE different\nMOVL $1,ret+0(FP)\nRET\ndifferent:\nMOVL $0,ret+0(FP)\nRET\n", row.name, row.instruction)
+	}
+	inputs := map[string][]byte{
+		"go.mod":                          []byte("module example.com/clisource\n\ngo 1.24\n"),
+		"state/state.go":                  []byte("package state\ntype Byte uint8\nvar Flags Byte = 1\n"),
+		"state/word_linux.go":             []byte("//go:build linux\n\npackage state\nvar Word uint32 = 0x12345678\n"),
+		"state/word_other.go":             []byte("//go:build !linux\n\npackage state\nvar Word uint64\n"),
+		"consumer/consumer.go":            []byte("package consumer\nimport state \"" + simpleImportedStatePath + "\"\nvar _ = state.Flags\nvar _ = state.Word\nvar Flags uint8\nfunc CompareByte() uint32\nfunc CompareWord() uint32\nfunc CompareLocal() uint32\n"),
+		"consumer/compare_" + arch + ".s": []byte(source.String()),
+	}
+	for name, input := range inputs {
+		file := filepath.Join(directory, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, input, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Cleanup(func() {
+		for name, expected := range inputs {
+			actual, err := os.ReadFile(filepath.Join(directory, filepath.FromSlash(name)))
+			if err != nil || !bytes.Equal(actual, expected) {
+				t.Errorf("original loaded input changed: %s: %v", name, err)
+			}
+		}
+	})
+	for key, value := range map[string]string{
+		"GOROOT": runtime.GOROOT(), "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+		"GOFLAGS": "", "GOPACKAGESDRIVER": "off", "CGO_ENABLED": "0", "GOEXPERIMENT": "",
+		"GOAMD64": "v1", "GO386": "sse2", "GOCACHE": t.TempDir(),
+	} {
+		t.Setenv(key, value)
+	}
+	t.Chdir(filepath.Join(directory, "consumer"))
+	loaded, err := loadPackage(".", "linux", arch)
+	if err != nil || loaded == nil {
+		t.Fatalf("actual CLI package selection failed before translation: %v", err)
+	}
+	pkg := loaded.Package
+	dependency := pkg.Imports[simpleImportedStatePath]
+	if pkg.PkgPath != "example.com/clisource/consumer" || pkg.Types == nil || pkg.TypesSizes == nil ||
+		len(pkg.Syntax) != 1 || dependency == nil || dependency.Types == nil || len(dependency.Syntax) != 2 ||
+		len(dependency.CompiledGoFiles) != 2 || dependency.IllTyped || len(dependency.Errors) != 0 {
+		t.Fatal("actual target package or complete imported source/type selection is missing")
+	}
+	if word, ok := dependency.Types.Scope().Lookup("Word").(*types.Var); !ok ||
+		!types.Identical(word.Type(), types.Typ[types.Uint32]) || pkg.TypesSizes.Sizeof(word.Type()) != 4 {
+		t.Fatal("the original Linux source selection did not establish the real uint32 variable")
+	}
+	for _, name := range dependency.CompiledGoFiles {
+		if filepath.Base(name) != "state.go" && filepath.Base(name) != "word_linux.go" {
+			t.Fatal("unexpected imported compiled source", name)
+		}
+	}
+	assembly := filepath.Join(directory, "consumer", "compare_"+arch+".s")
+	return loaded, assembly, []byte(source.String())
+}
+
+func TestSimpleCLILoadedImportedGlobalSyntaxForwarding(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			loaded, _, _ := simpleImportedGlobalPackage(t, arch)
+			pkg := loaded.Package
+			view := goPackageView(pkg)
+			dependency := pkg.Imports[simpleImportedStatePath]
+			if view.Types != pkg.Types || view.Path != pkg.PkgPath || !reflect.DeepEqual(view.Syntax, pkg.Syntax) ||
+				view.Imports[simpleImportedStatePath] != dependency.Types ||
+				!reflect.DeepEqual(view.ImportSyntax[simpleImportedStatePath], dependency.Syntax) {
+				t.Fatal("CLI view discarded the actual complete imported declaration syntax or typed identity")
+			}
+		})
+	}
+}
+
+func simpleImportedGlobalModule(t *testing.T, pkg *packages.Package, source []byte, arch string) (string, error) {
+	t.Helper()
+	result, err := plan9asm.TranslateGoModule(goPackageView(pkg), source, plan9asm.GoModuleOptions{
+		GOOS: "linux", GOARCH: arch, TargetTriple: targetTriple("linux", arch),
+		Sizes: pkg.TypesSizes, FrameSizes: pkg.TypesSizes, ResolveSym: resolveSymFunc(pkg.PkgPath),
+		SourcePreprocessed: true,
+	})
+	if result == nil {
+		return "", err
+	}
+	defer result.Module.Dispose()
+	if err == nil {
+		if verify := llvm.VerifyModule(result.Module, llvm.ReturnStatusAction); verify != nil {
+			t.Fatal("actual loaded declaration module does not verify", verify)
+		}
+		if len(result.Functions) != 3 {
+			t.Fatal("complete original three-function source was cropped")
+		}
+	}
+	return result.Module.String(), err
+}
+
+func simpleImportedGlobalRequireReads(t *testing.T, ir, pkgPath string) {
+	t.Helper()
+	for _, name := range []string{simpleImportedStatePath + ".Flags", simpleImportedStatePath + ".Word", pkgPath + ".Flags"} {
+		if !strings.Contains(ir, `@"`+name+`" = external global `) {
+			t.Fatal("actual mutable Go storage lost its external namespace or became a definition/constant", name)
+		}
+	}
+	if strings.Count(ir, "load volatile i8") != 2 || strings.Count(ir, "load volatile i32") != 1 ||
+		!strings.Contains(ir, "br i1") {
+		t.Fatal("complete imported/local mutable reads lost exact widths or observable predicates")
+	}
+	for _, name := range []string{"CompareByte", "CompareWord", "CompareLocal"} {
+		if !strings.Contains(ir, `@"`+pkgPath+"."+name+`"(`) {
+			t.Fatal("original complete source entry missing", name)
+		}
+	}
+}
+
+func TestSimpleCLILoadedImportedGlobalWholeGoModule(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			loaded, _, source := simpleImportedGlobalPackage(t, arch)
+			ir, err := simpleImportedGlobalModule(t, loaded.Package, source, arch)
+			if err != nil || ir == "" {
+				t.Fatal("ordinary GoModule lost real CLI-loaded imported declarations", err)
+			}
+			simpleImportedGlobalRequireReads(t, ir, loaded.PkgPath)
+		})
+	}
+}
+
+func TestSimpleCLITranslateLoadedImportedGlobalFile(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			loaded, assembly, _ := simpleImportedGlobalPackage(t, arch)
+			translated, text, err := translateAsmForPackage(loaded.Package, assembly, "linux", arch, false, loaded.selected)
+			if err != nil || !text {
+				t.Fatal("actual CLI whole-file path omitted imported declaration binding", err)
+			}
+			if len(translated.Functions) != 3 {
+				t.Fatal("CLI omitted an original source entry")
+			}
+			simpleImportedGlobalRequireReads(t, translated.LLVMIR, loaded.PkgPath)
+		})
+	}
+}
+
+func TestSimpleCLIImportedTypeOnlyViewHasNoDeclarationAuthority(t *testing.T) {
+	loaded, assembly, source := simpleImportedGlobalPackage(t, "amd64")
+	pkg := *loaded.Package
+	dependency := *pkg.Imports[simpleImportedStatePath]
+	dependency.Syntax = nil // Preserve the real export/type identity, but no declaration source.
+	pkg.Imports = map[string]*packages.Package{simpleImportedStatePath: &dependency}
+	ir, err := simpleImportedGlobalModule(t, &pkg, source, "amd64")
+	if ir != "" || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("a real type-only import was incorrectly treated as complete declaration evidence", err)
+	}
+	translated, text, err := translateAsmForPackage(&pkg, assembly, "linux", "amd64", false, loaded.selected)
+	if text || translated.LLVMIR != "" || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("actual CLI fallback borrowed source declarations from a type-only import", err)
+	}
+}
+
+func TestSimpleCLIImportedGlobalDeclarationGuards(t *testing.T) {
+	for _, mutation := range []string{"missing-current-syntax", "changed-caller-import", "missing-import-types", "unselected-platform-source"} {
+		t.Run(mutation, func(t *testing.T) {
+			loaded, assembly, source := simpleImportedGlobalPackage(t, "amd64")
+			pkg := loaded.Package
+			switch mutation {
+			case "missing-current-syntax":
+				pkg.Syntax = nil
+			case "changed-caller-import":
+				// Mutate the actual loaded caller AST, leaving its old typed
+				// imports unchanged. Export identity alone must not hide this.
+				file := pkg.Syntax[0]
+				var declarations []ast.Decl
+				for _, declaration := range file.Decls {
+					if group, ok := declaration.(*ast.GenDecl); !ok || group.Tok != token.IMPORT {
+						declarations = append(declarations, declaration)
+					}
+				}
+				if len(declarations) == len(file.Decls) {
+					t.Fatal("actual caller import mutation did not apply")
+				}
+				file.Decls, file.Imports = declarations, nil
+			case "missing-import-types":
+				pkg.Imports[simpleImportedStatePath].Types = nil
+			case "unselected-platform-source":
+				dependency := pkg.Imports[simpleImportedStatePath]
+				inactive := filepath.Join(dependency.Dir, "word_other.go")
+				file, err := parser.ParseFile(token.NewFileSet(), inactive, nil, parser.ParseComments)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// These are real source bytes, but not the target's selected
+				// declaration. They describe uint64, not the loaded uint32.
+				changed := 0
+				for index, name := range dependency.CompiledGoFiles {
+					if filepath.Base(name) == "word_linux.go" {
+						dependency.Syntax[index] = file
+						changed++
+					}
+				}
+				if changed != 1 {
+					t.Fatal("selected platform source mutation did not apply exactly once")
+				}
+			}
+			ir, err := simpleImportedGlobalModule(t, pkg, source, "amd64")
+			if ir != "" || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("changed or absent original loaded declarations acquired read authority", err)
+			}
+			translated, text, err := translateAsmForPackage(pkg, assembly, "linux", "amd64", false, loaded.selected)
+			if text || translated.LLVMIR != "" || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("actual CLI fallback borrowed changed or absent loaded declarations", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asm/main.go b/cmd/plan9asm/main.go
index e352473e6..edd0b8796 100644
--- a/cmd/plan9asm/main.go
+++ b/cmd/plan9asm/main.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"flag"
@@ -15,10 +16,12 @@ import (
 	"regexp"
 	"runtime"
 	"sort"
-	"strconv"
 	"strings"
+	"time"
 
 	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/asmsig"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -235,7 +238,7 @@ func transpilePackageMode(patterns []string, outDir, goos, goarch string, annota
 		}
 
 		for _, sfile := range sfiles {
-			tr, ok, err := translateAsmForPackage(pkg, sfile, goos, goarch, annotate)
+			tr, ok, err := translateAsmForPackage(pkg.Package, sfile, goos, goarch, annotate, pkg.selected)
 			if err != nil {
 				return fmt.Errorf("transpile %s: %w", sfile, err)
 			}
@@ -308,7 +311,7 @@ func transpileSingleFileMode(inFile, outFile, goos, goarch string, annotate bool
 		return err
 	}
 
-	tr, ok, err := translateAsmForPackage(pkg, asmPath, goos, goarch, annotate)
+	tr, ok, err := translateAsmForPackage(pkg.Package, asmPath, goos, goarch, annotate, pkg.selected)
 	if err != nil {
 		return err
 	}
@@ -342,16 +345,32 @@ func transpileSingleFileMode(inFile, outFile, goos, goarch string, annotate bool
 	return nil
 }
 
-func translateAsmForPackage(pkg *packages.Package, asmPath, goos, goarch string, annotate bool) (translation, bool, error) {
-	src, err := os.ReadFile(asmPath)
+func translateAsmForPackage(pkg *packages.Package, asmPath, goos, goarch string, annotate bool, selections ...*sdkfrontend.Selection) (translation, bool, error) {
+	sourceRoot := filepath.Dir(asmPath)
+	if pkg != nil && pkg.Module != nil && pkg.Module.Dir != "" {
+		sourceRoot = pkg.Module.Dir
+	}
+	src, err := plan9asm.ReadGoAssemblySource(asmPath, sourceRoot)
 	if err != nil {
 		return translation{}, false, err
 	}
+	originalSource := src
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, imported := range pkg.Imports {
+		if imported != nil && imported.Types != nil {
+			imports[path] = imported.Types
+		}
+	}
+	src = plan9asm.ExpandGoAssemblySource(plan9asm.GoPackage{
+		Path:    pkg.PkgPath,
+		Types:   pkg.Types,
+		Imports: imports,
+	}, src, goarch)
 	arch, err := toPlan9Arch(goarch)
 	if err != nil {
 		return translation{}, false, err
 	}
-	file, err := plan9asm.Parse(arch, string(src))
+	file, err := plan9asm.ParseWithDefines(arch, string(src), plan9asm.GoAssemblerDefines(goos, goarch))
 	if err != nil {
 		if strings.Contains(err.Error(), "no TEXT directive found") {
 			return translation{}, false, nil
@@ -364,52 +383,8 @@ func translateAsmForPackage(pkg *packages.Package, asmPath, goos, goarch string,
 
 	resolve := resolveSymFunc(pkg.PkgPath)
 	if goarch == "wasm" {
-		wasmABI := plan9asm.WASMABIDirect
-		if goos == "js" || goos == "wasip1" {
-			wasmABI = plan9asm.WASMABIGo
-		}
-		imports := make(map[string]*types.Package, len(pkg.Imports))
-		for path, imported := range pkg.Imports {
-			if imported != nil && imported.Types != nil {
-				imports[path] = imported.Types
-			}
-		}
-		tr, err := plan9asm.TranslateGoModule(plan9asm.GoPackage{
-			Path:    pkg.PkgPath,
-			Types:   pkg.Types,
-			Imports: imports,
-			Syntax:  pkg.Syntax,
-		}, src, plan9asm.GoModuleOptions{
-			FileName:       asmPath,
-			GOOS:           goos,
-			GOARCH:         goarch,
-			Sizes:          pkg.TypesSizes,
-			TargetTriple:   targetTriple(goos, goarch),
-			WASMABI:        wasmABI,
-			AnnotateSource: annotate,
-			ResolveSym:     resolve,
-		})
-		if err != nil {
-			return translation{}, false, err
-		}
-		defer tr.Module.Dispose()
-		fns := make([]functionInfo, 0, len(tr.Functions))
-		for _, fn := range tr.Functions {
-			sig := tr.Signatures[fn.ResolvedSymbol]
-			args := make([]string, len(sig.Args))
-			for i, arg := range sig.Args {
-				args[i] = string(arg)
-			}
-			ret := string(sig.Ret)
-			if ret == "" {
-				ret = string(plan9asm.Void)
-			}
-			fns = append(fns, functionInfo{
-				Symbol: fn.TextSymbol, Resolved: fn.ResolvedSymbol,
-				Args: args, Ret: ret,
-			})
-		}
-		return translation{LLVMIR: tr.Module.String(), Functions: fns}, true, nil
+		tr, err := translateLoadedGoModule(pkg, src, asmPath, goos, goarch, annotate)
+		return tr, err == nil, err
 	}
 	sigs, err := sigsForAsmFile(pkg, file, resolve, goarch)
 	if err != nil {
@@ -423,6 +398,24 @@ func translateAsmForPackage(pkg *packages.Package, asmPath, goos, goarch string,
 		AnnotateSource: annotate,
 	})
 	if err != nil {
+		if errors.Is(err, plan9asm.ErrProbeNeedsContext) && sdkfrontend.NumericalOwnerRequested(sdkPackageView(pkg), file, goos+"/"+goarch) {
+			var selected *sdkfrontend.Selection
+			if len(selections) == 1 {
+				selected = selections[0]
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+			defer cancel()
+			tr, err := translateSDKSource(ctx, pkg, selected, file, asmPath, goos+"/"+goarch, annotate)
+			return tr, err == nil, err
+		}
+		if errors.Is(err, plan9asm.ErrProbeNeedsContext) && len(pkg.Syntax) != 0 &&
+			(goarch == "386" || goarch == "amd64" || goarch == "arm64") {
+			// Preserve the original successful hot path and SDK source route.
+			// This is at most one non-recursive second pass over the complete
+			// original source, using only the already-loaded typed declarations.
+			tr, err := translateLoadedGoModule(pkg, originalSource, asmPath, goos, goarch, annotate)
+			return tr, err == nil, err
+		}
 		return translation{}, false, err
 	}
 	fns := collectFunctionInfo(file, sigs, resolve)
@@ -522,17 +515,31 @@ func targetTriple(goos, goarch string) string {
 	return ""
 }
 
-func loadPackage(pkgPath, goos, goarch string) (*packages.Package, error) {
+func loadPackage(pkgPath, goos, goarch string) (*loadedPackage, error) {
+	environment, err := sdkfrontend.OrdinaryEnvironment(goos, goarch, os.Environ())
+	if err != nil {
+		return nil, err
+	}
+	directory, err := sdkfrontend.WorkingDirectory("")
+	if err != nil {
+		return nil, err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
 	cfg := &packages.Config{
+		Context: ctx,
+		Dir:     directory,
 		Mode: packages.NeedName |
 			packages.NeedFiles |
+			packages.NeedCompiledGoFiles |
+			packages.NeedModule |
 			packages.NeedDeps |
 			packages.NeedImports |
 			packages.NeedSyntax |
 			packages.NeedTypes |
 			packages.NeedTypesSizes |
 			packages.NeedTypesInfo,
-		Env: append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch),
+		Env: environment,
 	}
 	pkgs, err := packages.Load(cfg, pkgPath)
 	if err != nil {
@@ -551,14 +558,14 @@ func loadPackage(pkgPath, goos, goarch string) (*packages.Package, error) {
 			if p.Types == nil || p.Types.Scope() == nil {
 				return nil, fmt.Errorf("package %s loaded without types", pkgPath)
 			}
-			return p, nil
+			return &loadedPackage{p, sdkfrontend.CaptureSelection(sdkPackageView(p), goos+"/"+goarch, environment, nil)}, nil
 		}
 	}
 	p := pkgs[0]
 	if p.Types == nil || p.Types.Scope() == nil {
 		return nil, fmt.Errorf("package %s loaded without types", p.PkgPath)
 	}
-	return p, nil
+	return &loadedPackage{p, sdkfrontend.CaptureSelection(sdkPackageView(p), goos+"/"+goarch, environment, nil)}, nil
 }
 
 func resolvePath(path string) (string, error) {
@@ -582,10 +589,9 @@ func resolvePath(path string) (string, error) {
 func goListPackages(query, goos, goarch string) ([]goListPackage, error) {
 	args := []string{"list", "-json", query}
 	cmd := exec.Command("go", args...)
-	// Package discovery only needs metadata. Disabling cgo prevents a host C
-	// toolchain from being used while listing a different target (for example,
-	// Windows-hosted tooling inspecting Linux standard-library assembly).
-	cmd.Env = append(os.Environ(), "CGO_ENABLED=0", "GOOS="+goos, "GOARCH="+goarch)
+	// Metadata discovery and the later typed load must observe the same target
+	// selection, including Go's actual cgo default and explicit user settings.
+	cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)
 
 	out, err := cmd.Output()
 	if err != nil {
@@ -786,15 +792,21 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 	if pkg == nil || pkg.Types == nil || pkg.Types.Scope() == nil {
 		for _, fn := range file.Funcs {
 			fs := fallbackSigForAsmFunc(fn, resolve(stripABISuffix(fn.Sym)), goarch)
-			if goarch == "wasm" && strings.HasSuffix(fn.Sym, "<>") {
-				var err error
-				fs, err = plan9asm.InferWASMAssemblyFuncSig(fn, fs.Name)
-				if err != nil {
-					return nil, err
+			if goarch == "wasm" {
+				if native, ok := plan9asm.LookupGoWASMNativeFuncSig(fs.Name); ok {
+					fs = native
+				} else if strings.HasSuffix(stripABISuffix(fn.Sym), "<>") && plan9asm.WASMAssemblyUsesNativeReturn(fn) {
+					var err error
+					fs, err = plan9asm.InferWASMAssemblyFuncSig(fn, fs.Name)
+					if err != nil {
+						return nil, err
+					}
+					fs.WASMNative = true
 				}
 			}
 			sigs[fs.Name] = fs
 		}
+		asmsig.RefineTailForwarders(file, sigs, resolve, nil)
 		return sigs, nil
 	}
 
@@ -816,48 +828,70 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		if resolved == "" {
 			continue
 		}
-		fs, ok, err := tryDeclSig(scope, asmDeclLookupSym(pkg, sym), resolved, linknames, goarch, sz)
+		fs, ok, err := tryDeclSig(scope, asmDeclLookupSym(pkg, sym), resolved, linknames, goarch, sz, strings.HasSuffix(fn.Sym, "<ABIInternal>"))
 		if err != nil {
 			return nil, err
 		}
 		if !ok {
 			fs = fallbackSigForAsmFunc(fn, resolved, goarch)
 		} else {
+			if goarch == "arm64" {
+				inferred := fallbackSigForAsmFunc(fn, resolved, goarch)
+				if borrowed, ok := asmsig.ARM64BorrowedTailFrame(file, fn, fs, inferred, resolve); ok {
+					fs = borrowed
+				}
+			}
 			declaredSigs[resolved] = true
 		}
 		sigs[resolved] = fs
 	}
 	if goarch == "wasm" {
 		for _, fn := range file.Funcs {
-			if !strings.HasSuffix(fn.Sym, "<>") {
-				continue
-			}
 			resolved := resolve(stripABISuffix(fn.Sym))
-			fs, err := plan9asm.InferWASMAssemblyFuncSig(fn, resolved)
-			if err != nil {
-				return nil, err
+			fs, ok := plan9asm.LookupGoWASMNativeFuncSig(resolved)
+			if !ok {
+				if !strings.HasSuffix(stripABISuffix(fn.Sym), "<>") || !plan9asm.WASMAssemblyUsesNativeReturn(fn) {
+					continue
+				}
+				var err error
+				fs, err = plan9asm.InferWASMAssemblyFuncSig(fn, resolved)
+				if err != nil {
+					return nil, err
+				}
 			}
+			fs.WASMNative = true
 			sigs[resolved] = fs
 		}
 	}
 
+	var targetSigErr error
 	addTargetSig := func(sym string, caller plan9asm.FuncSig, tail bool) {
 		if sym == "" {
 			return
 		}
+		internal := goarch == "arm64" && strings.HasSuffix(sym, "<ABIInternal>")
 		sym = stripABISuffix(sym)
 		resolved := resolve(sym)
 		if resolved == "" {
 			return
 		}
 		if existing, ok := sigs[resolved]; ok {
+			if internal && declaredSigs[resolved] && existing.ARM64GoRegisterABI == nil {
+				fs, _, err := tryDeclSig(scope, asmDeclLookupSym(pkg, sym), resolved, linknames, goarch, sz, true)
+				if err != nil {
+					targetSigErr = err
+				} else {
+					sigs[resolved] = fs
+				}
+				return
+			}
 			// A local assembly helper may have no Go declaration and no FP result
 			// slots even though every entry reaches it by tail call. Preserve its
 			// inferred register/frame inputs, but make its LLVM return and matching
 			// result slots agree with the declared caller. Local helpers share the
 			// caller's physical frame, so a byte result may otherwise remain an i32
 			// fallback slot underneath an i1 function signature.
-			if tail && caller.Name != "" && !declaredSigs[resolved] {
+			if tail && declaredSigs[caller.Name] && !declaredSigs[resolved] {
 				existing.Ret = caller.Ret
 				if len(existing.Frame.Results) == len(caller.Frame.Results) {
 					for i := range existing.Frame.Results {
@@ -873,7 +907,17 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 			}
 			return
 		}
-		fs, ok, err := tryDeclSig(scope, asmDeclLookupSym(pkg, sym), resolved, linknames, goarch, sz)
+		if goarch == "wasm" {
+			if fs, ok := plan9asm.LookupGoWASMNativeFuncSig(resolved); ok {
+				sigs[resolved] = fs
+				return
+			}
+		}
+		fs, ok, err := tryDeclSig(scope, asmDeclLookupSym(pkg, sym), resolved, linknames, goarch, sz, internal)
+		if internal && err != nil {
+			targetSigErr = err
+			return
+		}
 		if err == nil && ok {
 			sigs[resolved] = fs
 			declaredSigs[resolved] = true
@@ -882,6 +926,7 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		if tail && caller.Name != "" {
 			copySig := caller
 			copySig.Name = resolved
+			copySig.ARM64GoRegisterABI = nil
 			sigs[resolved] = copySig
 			return
 		}
@@ -893,8 +938,8 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		caller := sigs[callerName]
 		for _, ins := range fn.Instrs {
 			op := strings.ToUpper(string(ins.Op))
-			tail := op == "JMP" || op == "B"
-			if !(tail || op == "CALL" || op == "BL") {
+			tail := op == "JMP" || op == "B" || (op == "RET" && len(ins.Args) == 1)
+			if !(tail || op == "CALL" || op == "CALLNORESUME" || op == "WASMCALL" || op == "BL") {
 				continue
 			}
 			if len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
@@ -927,6 +972,10 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		}
 	}
 
+	if targetSigErr != nil {
+		return nil, targetSigErr
+	}
+	asmsig.RefineTailForwarders(file, sigs, resolve, declaredSigs)
 	return sigs, nil
 }
 
@@ -942,13 +991,18 @@ func asmDeclLookupSym(pkg *packages.Package, sym string) string {
 }
 
 func fallbackSigForAsmFunc(fn plan9asm.Func, resolved, goarch string) plan9asm.FuncSig {
+	if goarch == "arm" {
+		if native, ok := plan9asm.ARMKernelHelperFuncSig(fn, resolved); ok {
+			return native
+		}
+	}
 	paramOff := map[int64]struct{}{}
 	retOff := map[int64]struct{}{}
 
 	for _, ins := range fn.Instrs {
 		op := strings.ToUpper(string(ins.Op))
 		for i, a := range ins.Args {
-			if a.Kind != plan9asm.OpFP {
+			if a.Kind != plan9asm.OpFP && a.Kind != plan9asm.OpFPAddr {
 				continue
 			}
 			if isLikelyResultSlot(op, i, len(ins.Args), a.FPName) {
@@ -981,7 +1035,12 @@ func fallbackSigForAsmFunc(fn plan9asm.Func, resolved, goarch string) plan9asm.F
 	ret := plan9asm.Void
 	switch len(results) {
 	case 0:
-		ret = word
+		// A fallback with FP parameters follows ABI0, whose results also live
+		// in explicit FP slots. No result slot therefore means void. Keep the
+		// conservative word return only for register-only assembly helpers.
+		if len(params) == 0 {
+			ret = word
+		}
 	case 1:
 		ret = word
 	default:
@@ -1025,7 +1084,7 @@ func sortOffsets(m map[int64]struct{}) []int64 {
 	return out
 }
 
-func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]string, goarch string, sz types.Sizes) (plan9asm.FuncSig, bool, error) {
+func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]string, goarch string, sz types.Sizes, internal bool) (plan9asm.FuncSig, bool, error) {
 	declName := strings.TrimPrefix(sym, "·")
 	if strings.ContainsRune(declName, '·') {
 		key := strings.ReplaceAll(sym, "∕", "/")
@@ -1048,6 +1107,10 @@ func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]s
 	if sig.Recv() != nil || sig.Variadic() {
 		return plan9asm.FuncSig{}, false, nil
 	}
+	if goarch == "amd64" || goarch == "386" {
+		actual, err := plan9asm.DeriveGoFuncABI0Signature(resolved, fn, goarch, sz)
+		return actual, err == nil, err
+	}
 
 	args, frameParams, nextOff, err := llvmArgsAndFrameSlotsForTuple(sig.Params(), goarch, sz, 0, false)
 	if err != nil {
@@ -1059,7 +1122,7 @@ func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]s
 		return plan9asm.FuncSig{}, false, fmt.Errorf("%s: %w", fn.FullName(), err)
 	}
 	ret := tupleRetType(retTys)
-	return plan9asm.FuncSig{
+	fs := plan9asm.FuncSig{
 		Name: resolved,
 		Args: args,
 		Ret:  ret,
@@ -1067,7 +1130,14 @@ func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]s
 			Params:  frameParams,
 			Results: frameResults,
 		},
-	}, true, nil
+	}
+	if goarch == "arm64" && internal {
+		fs.ARM64GoRegisterABI, err = plan9asm.DeriveARM64GoRegisterABI(fn, fs)
+		if err != nil {
+			return plan9asm.FuncSig{}, false, err
+		}
+	}
+	return fs, true, nil
 }
 
 func tupleRetType(ts []plan9asm.LLVMType) plan9asm.LLVMType {
@@ -1086,19 +1156,7 @@ func tupleRetType(ts []plan9asm.LLVMType) plan9asm.LLVMType {
 }
 
 func splitSymPlusOff(s string) (base string, off int64) {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return "", 0
-	}
-	sep := strings.LastIndexAny(s, "+-")
-	if sep <= 0 || sep == len(s)-1 {
-		return s, 0
-	}
-	n, err := strconv.ParseInt(strings.TrimSpace(s[sep:]), 0, 64)
-	if err != nil {
-		return s, 0
-	}
-	return strings.TrimSpace(s[:sep]), n
+	return plan9asm.SplitSymbolOffset(s)
 }
 
 func linknameRemoteToLocal(files []*ast.File) map[string]string {
diff --git a/cmd/plan9asm/main_test.go b/cmd/plan9asm/main_test.go
index 3a7c8f13c..dee1b2057 100644
--- a/cmd/plan9asm/main_test.go
+++ b/cmd/plan9asm/main_test.go
@@ -1,18 +1,44 @@
 package main
 
 import (
+	"go/constant"
 	"go/token"
 	"go/types"
 	"os"
 	"path/filepath"
 	"reflect"
 	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/xgo-dev/plan9asm"
 	"golang.org/x/tools/go/packages"
 )
 
+func TestX86DeclaredSignatureRetainsCanonicalABI0ResultNames(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg := types.NewPackage("example.com/sample", "sample")
+			parameters := types.NewTuple(types.NewVar(token.NoPos, pkg, "input", types.NewSlice(types.Typ[types.Uint8])))
+			results := types.NewTuple(
+				types.NewVar(token.NoPos, pkg, "first", types.Typ[types.Uint32]),
+				types.NewVar(token.NoPos, pkg, "second", types.Typ[types.Uint32]),
+			)
+			fn := types.NewFunc(token.NoPos, pkg, "Probe", types.NewSignatureType(nil, nil, nil, parameters, results, false))
+			pkg.Scope().Insert(fn)
+			sizes := types.SizesFor("gc", arch)
+			want, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path()+".Probe", fn, arch, sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			actual, found, err := tryDeclSig(pkg.Scope(), "·Probe", want.Name, nil, arch, sizes, false)
+			if err != nil || !found || !reflect.DeepEqual(actual, want) {
+				t.Fatalf("actual declaration layout differs from the shared ABI0 builder: %v\nactual=%+v\nwant=%+v", err, actual, want)
+			}
+		})
+	}
+}
+
 func TestPackageSFilesAbsFiltersNonPlan9Asm(t *testing.T) {
 	dir := t.TempDir()
 	abs := filepath.Join(t.TempDir(), "abs", "keep.s")
@@ -35,6 +61,99 @@ func TestPackageSFilesAbsFiltersNonPlan9Asm(t *testing.T) {
 	}
 }
 
+func TestSigsForAsmFileARM64TailHelperBorrowsCallerFrame(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/ring0", "ring0")
+	for _, name := range []string{"El1Sync", "HaltEl1ExceptionAndResume"} {
+		sig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, sig))
+	}
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "arm64"),
+	}
+	const source = `TEXT ·El1Sync(SB),NOSPLIT,$0-0
+	MOVD $7, R3
+	MOVD R3, 8(RSP)
+	B ·HaltEl1ExceptionAndResume(SB)
+TEXT ·HaltEl1ExceptionAndResume(SB),NOSPLIT,$0-0
+	MOVD vector+0(FP), R3
+	RET
+`
+	file, err := plan9asm.Parse(plan9asm.ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	helper := sigs[pkg.PkgPath+".HaltEl1ExceptionAndResume"]
+	if len(helper.Args) != 1 || helper.Args[0] != plan9asm.I64 ||
+		len(helper.Frame.Params) != 1 || helper.Frame.Params[0].Offset != 0 {
+		t.Fatalf("tail helper did not borrow caller's ABI0 frame: %+v", helper)
+	}
+}
+
+func TestTranslateAsmForPackageExpandsRuntimeStyleFunctionMacro(t *testing.T) {
+	dir := t.TempDir()
+	header := filepath.Join(dir, "abi.h")
+	asm := filepath.Join(dir, "entry_arm64.s")
+	if err := os.WriteFile(header, []byte("#ifdef GOOS_linux\n#define SAVE(offset) MOVD R19, offset(RSP)\n#else\n#define SAVE(offset) UNKNOWN_TARGET\n#endif\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(asm, []byte("#include \"abi.h\"\nTEXT ·entry(SB),NOSPLIT,$0-0\nSAVE(8)\nRET\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	pkgTypes := types.NewPackage("example.com/m/p", "p")
+	pkgTypes.Scope().Insert(types.NewFunc(token.NoPos, pkgTypes, "entry", types.NewSignature(nil, nil, nil, false)))
+	pkg := &packages.Package{
+		PkgPath:    pkgTypes.Path(),
+		Types:      pkgTypes,
+		TypesSizes: types.SizesFor("gc", "arm64"),
+		Module:     &packages.Module{Path: "example.com/m", Dir: dir},
+	}
+	tr, ok, err := translateAsmForPackage(pkg, asm, "linux", "arm64", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok || !strings.Contains(tr.LLVMIR, "store i64") {
+		t.Fatalf("included SAVE macro was not translated:\n%s", tr.LLVMIR)
+	}
+}
+
+func TestTranslateAsmForPackageExpandsGeneratedGoAsmConstants(t *testing.T) {
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "asm_amd64.s")
+	if err := os.WriteFile(asm, []byte(`#include "go_asm.h"
+#ifdef GOOS_windows
+GLOBL zeroTLS<>(SB),RODATA,$const_tlsSize
+#endif
+TEXT ·entry(SB),NOSPLIT,$0-0
+RET
+`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	pkgTypes := types.NewPackage("runtime", "runtime")
+	pkgTypes.Scope().Insert(types.NewConst(token.NoPos, pkgTypes, "tlsSize", types.Typ[types.Int], constant.MakeInt64(48)))
+	pkgTypes.Scope().Insert(types.NewFunc(token.NoPos, pkgTypes, "entry", types.NewSignature(nil, nil, nil, false)))
+	pkg := &packages.Package{
+		PkgPath:    pkgTypes.Path(),
+		Types:      pkgTypes,
+		TypesSizes: types.SizesFor("gc", "amd64"),
+		Module:     &packages.Module{Path: "runtime", Dir: dir},
+	}
+	tr, ok, err := translateAsmForPackage(pkg, asm, "windows", "amd64", false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok || !strings.Contains(tr.LLVMIR, `@"runtime.zeroTLS$local" = internal constant [48 x i8]`) {
+		t.Fatalf("generated const_tlsSize was not expanded:\n%s", tr.LLVMIR)
+	}
+}
+
 func TestFallbackSigUsesTargetWordSize(t *testing.T) {
 	fn := plan9asm.Func{Instrs: []plan9asm.Instr{{
 		Op: "MOVW",
@@ -62,6 +181,20 @@ func TestFallbackSigUsesTargetWordSize(t *testing.T) {
 	}
 }
 
+func TestFallbackSigTreatsAddressedFrameWithoutResultAsVoid(t *testing.T) {
+	fn := plan9asm.Func{Instrs: []plan9asm.Instr{{
+		Op: "LEAL",
+		Args: []plan9asm.Operand{
+			{Kind: plan9asm.OpFPAddr, FPName: "arg", FPOffset: 0},
+			{Kind: plan9asm.OpReg, Reg: "AX"},
+		},
+	}}}
+	got := fallbackSigForAsmFunc(fn, "example.helper$local", "386")
+	if len(got.Args) != 1 || got.Args[0] != plan9asm.I32 || got.Ret != plan9asm.Void {
+		t.Fatalf("fallback signature = %#v, want (i32) -> void", got)
+	}
+}
+
 func TestLikelyResultSlotUsesExplicitResultPrefix(t *testing.T) {
 	if !isLikelyResultSlot("MOVW", 0, 2, "ret0") {
 		t.Fatal("ret-prefixed FP slot was not classified as a result")
@@ -153,6 +286,17 @@ TEXT helper<>(SB),NOSPLIT,$0-1
 	}
 }
 
+func TestFallbackARMKernelHelperIsNotGuessedIntegerReturn(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM, "TEXT renamed<>(SB),$0\nMOVW $0xffff0fc0,R15\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := fallbackSigForAsmFunc(file.Funcs[0], "example.renamed$local", "arm")
+	if sig.Ret != plan9asm.Void || len(sig.Args)+len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+		t.Fatalf("kernel native entry acquired a guessed Go/C ABI: %#v", sig)
+	}
+}
+
 func TestPackageQualifiedAsmSymbolUsesLocalDeclaration(t *testing.T) {
 	file, err := plan9asm.Parse(plan9asm.ArchARM, `TEXT runtime·pipe2(SB),NOSPLIT,$0-16
 	MOVW $r+4(FP), R0
@@ -204,6 +348,74 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$0
 	}
 }
 
+func TestUndeclaredPureForwarderInheritsABI0Frame(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT forward(SB),$0-8\nJMP body(SB)\nTEXT body(SB),$0-8\nMOVQ arg+0(FP), AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, pkg := range []*packages.Package{nil, {Types: types.NewPackage("example", "example"), TypesSizes: types.SizesFor("gc", "amd64")}} {
+		sigs, err := sigsForAsmFile(pkg, file, resolveSymFunc("example"), "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		got := sigs["forward"]
+		if got.Ret != plan9asm.Void || len(got.Args) != 1 || len(got.Frame.Params) != 1 {
+			t.Fatalf("forward ABI = %#v", got)
+		}
+	}
+}
+
+func TestSigsForAsmFileDiscoversWasmCallOpcodes(t *testing.T) {
+	for _, op := range []string{"Call", "CALLNORESUME"} {
+		t.Run(op, func(t *testing.T) {
+			file, err := plan9asm.Parse(plan9asm.ArchWASM, "TEXT ·caller(SB),NOSPLIT,$0-0\n\t"+op+" ·target(SB)\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkgTypes := types.NewPackage("example", "example")
+			voidSig := types.NewSignature(nil, nil, nil, false)
+			pkgTypes.Scope().Insert(types.NewFunc(token.NoPos, pkgTypes, "caller", voidSig))
+			pkgTypes.Scope().Insert(types.NewFunc(token.NoPos, pkgTypes, "target", voidSig))
+			pkg := &packages.Package{Types: pkgTypes, TypesSizes: types.SizesFor("gc", "wasm")}
+			sigs, err := sigsForAsmFile(pkg, file, resolveSymFunc("example"), "wasm")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got, ok := sigs["example.target"]; !ok || got.Ret != plan9asm.Void {
+				t.Fatalf("%s target signature = %#v, present=%v; want void", op, got, ok)
+			}
+		})
+	}
+}
+
+func TestSigsForAsmFileUsesGoWasmNativeSignatures(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, `TEXT wasm_export_run(SB),NOSPLIT,$0
+	Call wasm_pc_f_loop(SB)
+	Return
+
+TEXT gcWriteBarrier<>(SB),NOSPLIT,$0
+	Get R0
+	I64Const $8
+	I64Add
+	Return
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkgTypes := types.NewPackage("runtime", "runtime")
+	pkg := &packages.Package{Types: pkgTypes, TypesSizes: types.SizesFor("gc", "wasm")}
+	sigs, err := sigsForAsmFile(pkg, file, resolveSymFunc("runtime"), "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := sigs["wasm_pc_f_loop"]; len(got.Args) != 0 || got.Ret != plan9asm.Void || !got.WASMNative {
+		t.Fatalf("wasm_pc_f_loop signature = %#v; want native () -> void", got)
+	}
+	if got := sigs["runtime.gcWriteBarrier$local"]; !reflect.DeepEqual(got.Args, []plan9asm.LLVMType{plan9asm.I64}) || got.Ret != plan9asm.I64 || !got.WASMNative {
+		t.Fatalf("gcWriteBarrier signature = %#v; want native (i64) -> i64", got)
+	}
+}
+
 func TestLLVMTypeForGoPointerLikeValues(t *testing.T) {
 	for name, typ := range map[string]types.Type{
 		"func": types.NewSignature(nil, nil, nil, false),
@@ -242,13 +454,13 @@ func TestInterfaceTupleUsesTwoPhysicalFrameSlots(t *testing.T) {
 	}
 }
 
-func TestGoListPackagesDisablesCgo(t *testing.T) {
+func TestGoListPackagesPreservesDefaultAndExplicitCgo(t *testing.T) {
 	dir := t.TempDir()
 	name := "go"
-	script := "#!/bin/sh\nprintf '%s\\n' \"{\\\"ImportPath\\\":\\\"$CGO_ENABLED\\\"}\"\n"
+	script := "#!/bin/sh\nprintf '%s\\n' \"{\\\"ImportPath\\\":\\\"cgo=$CGO_ENABLED\\\"}\"\n"
 	if runtime.GOOS == "windows" {
 		name = "go.cmd"
-		script = "@echo off\r\necho {\"ImportPath\":\"%CGO_ENABLED%\"}\r\n"
+		script = "@echo off\r\necho {\"ImportPath\":\"cgo=%CGO_ENABLED%\"}\r\n"
 	}
 	path := filepath.Join(dir, name)
 	if err := os.WriteFile(path, []byte(script), 0o755); err != nil {
@@ -261,11 +473,21 @@ func TestGoListPackagesDisablesCgo(t *testing.T) {
 	}
 	t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
 
-	pkgs, err := goListPackages("std", "linux", "amd64")
-	if err != nil {
-		t.Fatalf("goListPackages() error = %v", err)
-	}
-	if len(pkgs) != 1 || pkgs[0].ImportPath != "0" {
-		t.Fatalf("goListPackages() = %#v, want one package with CGO disabled", pkgs)
+	for _, value := range []string{"0", "1", ""} {
+		t.Run("cgo="+value, func(t *testing.T) {
+			t.Setenv("CGO_ENABLED", value)
+			if value == "" {
+				if err := os.Unsetenv("CGO_ENABLED"); err != nil {
+					t.Fatal(err)
+				}
+			}
+			pkgs, err := goListPackages("std", "linux", "amd64")
+			if err != nil {
+				t.Fatalf("goListPackages() error = %v", err)
+			}
+			if len(pkgs) != 1 || pkgs[0].ImportPath != "cgo="+value {
+				t.Fatalf("goListPackages() changed selected CGO_ENABLED=%q: %#v", value, pkgs)
+			}
+		})
 	}
 }
diff --git a/cmd/plan9asm/ordinary_global_sdk_go127_test.go b/cmd/plan9asm/ordinary_global_sdk_go127_test.go
new file mode 100644
index 000000000..ecb4e75af
--- /dev/null
+++ b/cmd/plan9asm/ordinary_global_sdk_go127_test.go
@@ -0,0 +1,131 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+// Keep the complete SDK counterexample above the isolated hasADX and TEST
+// rules. This is the ordinary typed GoModule API, not the CLI's SDK bridge,
+// a manufactured declaration package or a filtered function translation.
+func TestOriginalSDKMathBigAMD64WholeGoModule(t *testing.T) {
+	setSimpleSDKProfile(t)
+	t.Setenv("CGO_ENABLED", "0")
+	loaded, err := loadPackage("math/big", "linux", "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := loaded.Package
+	if pkg.PkgPath != "math/big" || pkg.Types == nil || pkg.TypesSizes == nil || len(pkg.Syntax) == 0 {
+		t.Fatal("actual selected SDK package lacks complete types, syntax or sizes")
+	}
+	input := ""
+	for _, name := range pkg.OtherFiles {
+		if filepath.Base(name) == "arith_amd64.s" {
+			if input != "" {
+				t.Fatal("duplicate selected SDK arithmetic assembly")
+			}
+			input = name
+		}
+	}
+	if input == "" || filepath.Clean(input) != filepath.Join(pkg.Dir, "arith_amd64.s") {
+		t.Fatal("the actual SDK did not select its original arithmetic assembly", input)
+	}
+	variable, valid := pkg.Types.Scope().Lookup("hasADX").(*types.Var)
+	if !valid || variable.Pkg() != pkg.Types || variable.IsField() || variable.Type().Underlying() != types.Typ[types.Bool] || pkg.TypesSizes.Sizeof(variable.Type()) != 1 {
+		t.Fatal("the original SDK feature flag is not a real same-package mutable bool")
+	}
+	source, inputs, err := plan9asm.ReadGoAssemblySourceWithReport(input, pkg.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	goPackage := goPackageView(pkg)
+	expanded := plan9asm.ExpandGoAssemblySource(goPackage, source, "amd64")
+	parsed, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(expanded), plan9asm.GoAssemblerDefines("linux", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string]bool{
+		"·addVV": true, "·subVV": true, "·lshVU": true, "·rshVU": true,
+		"·mulAddVWW": true, "·addMulVVWW": true,
+	}
+	if len(parsed.Funcs) != len(wanted) {
+		t.Fatalf("the complete original SDK TEXT inventory changed: got %d, want %d", len(parsed.Funcs), len(wanted))
+	}
+	seen := make(map[string]bool, len(wanted))
+	for _, function := range parsed.Funcs {
+		if !wanted[function.Sym] || seen[function.Sym] {
+			t.Fatal("unexpected or duplicate original SDK TEXT", function.Sym)
+		}
+		seen[function.Sym] = true
+	}
+	translated, err := plan9asm.TranslateGoModule(goPackage, source, plan9asm.GoModuleOptions{
+		FileName: input, GOOS: "linux", GOARCH: "amd64", Sizes: pkg.TypesSizes, FrameSizes: pkg.TypesSizes,
+		TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolveSymFunc(pkg.PkgPath),
+	})
+	if err != nil {
+		t.Fatal("complete original arithmetic file did not translate through the ordinary GoModule API", err)
+	}
+	defer translated.Module.Dispose()
+	if err := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal("the complete SDK module did not verify", err)
+	}
+	if len(translated.Functions) != len(wanted) {
+		t.Fatal("GoModule omitted an original SDK TEXT", len(translated.Functions))
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	seen = make(map[string]bool, len(wanted))
+	for _, function := range translated.Functions {
+		if !wanted[function.TextSymbol] || seen[function.TextSymbol] || function.ResolvedSymbol != resolve(function.TextSymbol) {
+			t.Fatal("the full source-to-output function mapping is not bijective", function)
+		}
+		entry := translated.Module.NamedFunction(function.ResolvedSymbol)
+		if entry.IsNil() || entry.FirstBasicBlock().IsNil() {
+			t.Fatal("an original SDK function has no translated body", function)
+		}
+		seen[function.TextSymbol] = true
+	}
+	ir := translated.Module.String()
+	if !strings.Contains(ir, `load volatile i8, ptr @"math/big.hasADX"`) ||
+		!strings.Contains(ir, `@"math/big.hasADX" = external global `) {
+		t.Fatal("the actual mutable feature flag lost its external volatile byte read")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	llc := sdkLLVM22LLC(t, ctx)
+	directory := t.TempDir()
+	file, object := filepath.Join(directory, "arith-amd64.ll"), filepath.Join(directory, "arith-amd64.o")
+	if err := os.WriteFile(file, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, directory, os.Environ(), llc,
+		"-mtriple=x86_64-unknown-linux-gnu", "-filetype=obj", "-o", object, file)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("the complete ordinary GoModule SDK file failed LLVM22 object compilation: %v\n%s%s", err, stdout, stderr)
+	}
+	info, err := os.Stat(object)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatal("the complete SDK object is absent or empty", err)
+	}
+	for name, expected := range inputs.Inputs {
+		data, err := os.ReadFile(name)
+		if err != nil || fmt.Sprintf("%x", sha256.Sum256(data)) != expected {
+			t.Fatal("an original SDK assembly/header input changed during translation", name, err)
+		}
+	}
+	t.Logf("complete original math/big: functions=%d sourceSHA256=%x LLVM22 objectBytes=%d; no native execution claimed",
+		len(translated.Functions), sha256.Sum256(source), info.Size())
+}
diff --git a/cmd/plan9asm/ordinary_load_directory_other_test.go b/cmd/plan9asm/ordinary_load_directory_other_test.go
new file mode 100644
index 000000000..ae3713704
--- /dev/null
+++ b/cmd/plan9asm/ordinary_load_directory_other_test.go
@@ -0,0 +1,15 @@
+//go:build !windows
+
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func ordinaryLoadDirectoryAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	if err := os.Symlink(actual, alias); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/cmd/plan9asm/ordinary_load_directory_test.go b/cmd/plan9asm/ordinary_load_directory_test.go
new file mode 100644
index 000000000..00aaa9333
--- /dev/null
+++ b/cmd/plan9asm/ordinary_load_directory_test.go
@@ -0,0 +1,62 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSimplePackageLoadSDKWorkingDirectoryIdentity(t *testing.T) {
+	actual, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "original-sdk")
+	ordinaryLoadDirectoryAlias(t, alias, actual)
+	for key, value := range map[string]string{
+		"GOROOT": alias, "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+		"GOFLAGS": "", "GOPACKAGESDRIVER": "off", "GOOS": "linux", "GOARCH": "amd64",
+	} {
+		t.Setenv(key, value)
+	}
+	t.Setenv("CGO_ENABLED", "")
+	if err := os.Unsetenv("CGO_ENABLED"); err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(alias, "src", "hash", "crc32")
+	t.Chdir(directory)
+	t.Setenv("PWD", directory)
+	loaded, err := loadPackage(".", "linux", "amd64")
+	if err != nil || loaded == nil || loaded.Package.PkgPath != "hash/crc32" || loaded.Package.Types == nil || loaded.Package.TypesSizes == nil {
+		t.Fatalf("actual SDK cwd/type selection failed: %v %+v", err, loaded)
+	}
+	for _, name := range append(append([]string(nil), loaded.Package.GoFiles...), loaded.Package.CompiledGoFiles...) {
+		physical, err := sourcepath.Resolve(name)
+		if err != nil || name != physical {
+			t.Errorf("SDK load retained mismatched directory spelling: %q != %q (%v)", name, physical, err)
+		}
+	}
+}
+
+func TestSimplePackageLoadOutsideSDKRetainsInternalImportRejection(t *testing.T) {
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":  "module example.invalid/outside-sdk\n\ngo 1.24\n",
+		"main.go": "package outside\nimport _ \"internal/byteorder\"\n",
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOPACKAGESDRIVER", "off")
+	t.Chdir(directory)
+	if loaded, err := loadPackage(".", runtime.GOOS, runtime.GOARCH); err == nil || loaded != nil || !strings.Contains(err.Error(), "use of internal package internal/byteorder not allowed") {
+		t.Fatalf("physical working directory bypassed original internal-import boundary: %v %+v", err, loaded)
+	}
+}
diff --git a/cmd/plan9asm/ordinary_load_directory_windows_test.go b/cmd/plan9asm/ordinary_load_directory_windows_test.go
new file mode 100644
index 000000000..788064ebb
--- /dev/null
+++ b/cmd/plan9asm/ordinary_load_directory_windows_test.go
@@ -0,0 +1,21 @@
+//go:build windows
+
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func ordinaryLoadDirectoryAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, "", nil, "cmd", "/c", "mklink", "/J", alias, actual)
+	if err != nil {
+		t.Fatalf("create actual Windows SDK junction: %v; %s; %s", err, stdout, stderr)
+	}
+}
diff --git a/cmd/plan9asm/sdk_literal_minimum_go127_test.go b/cmd/plan9asm/sdk_literal_minimum_go127_test.go
new file mode 100644
index 000000000..b3b244cf7
--- /dev/null
+++ b/cmd/plan9asm/sdk_literal_minimum_go127_test.go
@@ -0,0 +1,62 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestSimpleCLIOriginalSDKMapsLiteralMinimumSource(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			setSimpleSDKProfile(t) // Retain the actual default CGO profile, not a diagnostic CGO0 override.
+			input := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "maps", "memhash_amd64.s")
+			original, err := os.ReadFile(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			folder := t.TempDir()
+			output, meta := filepath.Join(folder, "maps.ll"), filepath.Join(folder, "maps.json")
+			if err := runTranspile([]string{"-goos=" + goos, "-goarch=amd64", "-i=" + input, "-o=" + output, "-meta=" + meta}); err != nil {
+				t.Fatal("complete original SDK minimum-demand publication", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || strings.Count(string(ir), "define ") != 2 || !strings.Contains(string(ir), "external global [128 x i8]") ||
+				!strings.Contains(string(ir), "internal/runtime/maps.checkMasksAndShiftsAlignment") || strings.Count(string(ir), "internal constant [256 x i8]") != 2 {
+				t.Fatal("complete original functions/private DATA/mutable AES source lost", err)
+			}
+			raw, err := os.ReadFile(meta)
+			var metadata struct{ Functions []functionInfo }
+			if err != nil || json.Unmarshal(raw, &metadata) != nil || len(metadata.Functions) != 2 {
+				t.Fatal("whole-file metadata differs", err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			for _, optimization := range []string{"0", "2"} {
+				object := filepath.Join(folder, "maps-O"+optimization+".o")
+				stdout, stderr, err := gotoolprofile.RunBounded(ctx, folder, os.Environ(), sdkLLVM22LLC(t, ctx), "-O="+optimization, "-filetype=obj", "-o", object, output)
+				if err != nil || len(stderr) != 0 {
+					t.Fatalf("whole SDK LLVM22 O%s object: %v\n%s%s", optimization, err, stdout, stderr)
+				}
+				if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+					t.Fatal("whole SDK object absent", err)
+				}
+			}
+			after, err := os.ReadFile(input)
+			if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+				t.Fatal("original SDK source changed", err)
+			}
+			t.Logf("complete SDK source SHA256=%x; 2 TEXT/all DATA public CLI + LLVM22 O0/O2 only, not physical SDK entry/execution", sha256.Sum256(original))
+		})
+	}
+}
diff --git a/cmd/plan9asm/sdk_source.go b/cmd/plan9asm/sdk_source.go
new file mode 100644
index 000000000..4c3c65108
--- /dev/null
+++ b/cmd/plan9asm/sdk_source.go
@@ -0,0 +1,184 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/types"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+type loadedPackage struct {
+	*packages.Package
+	selected *sdkfrontend.Selection
+}
+
+func sdkPackageView(pkg *packages.Package) *sdkfrontend.Package {
+	seen := make(map[*packages.Package]*sdkfrontend.Package)
+	var visit func(*packages.Package) *sdkfrontend.Package
+	visit = func(pkg *packages.Package) *sdkfrontend.Package {
+		if pkg == nil {
+			return nil
+		}
+		if view := seen[pkg]; view != nil {
+			return view
+		}
+		view := &sdkfrontend.Package{ID: pkg.ID, Name: pkg.Name, Path: pkg.PkgPath, Dir: pkg.Dir,
+			GoFiles: pkg.GoFiles, CompiledGoFiles: pkg.CompiledGoFiles, OtherFiles: pkg.OtherFiles,
+			Module: pkg.Module != nil, Test: strings.Contains(pkg.ID, " [") && strings.HasSuffix(pkg.ID, ".test]"),
+			IllTyped: pkg.IllTyped, Types: pkg.Types, Sizes: pkg.TypesSizes, Imports: make(map[string]*sdkfrontend.Package)}
+		seen[pkg] = view
+		for _, err := range pkg.Errors {
+			view.Errors = append(view.Errors, err.Error())
+		}
+		for path, dependency := range pkg.Imports {
+			view.Imports[path] = visit(dependency)
+		}
+		return view
+	}
+	return visit(pkg)
+}
+
+// The ordinary complete-file translation must fail before publication before
+// this independent source route is considered. No rejected/changed selection
+// is repaired by manufacturing a new load environment.
+func translateSDKSource(ctx context.Context, pkg *packages.Package, selected *sdkfrontend.Selection,
+	file *plan9asm.File, asmPath, target string, annotate bool,
+) (_ translation, result error) {
+	if err := sdkfrontend.Check(sdkPackageView(pkg), selected, target); err != nil {
+		return translation{}, err
+	}
+	original := pkg
+	defer func() {
+		result = errors.Join(result, sdkfrontend.Check(sdkPackageView(original), selected, target))
+	}()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return translation{}, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return translation{}, err
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		return translation{}, err
+	}
+	var actual *packages.Package
+	_, observed, close, err := sdkfrontend.Reload(ctx, binary, sdkPackageView(pkg), selected,
+		func(ctx context.Context, directory string, environment []string) (*sdkfrontend.Package, error) {
+			loaded, err := packages.Load(&packages.Config{Context: ctx, Dir: directory, Env: environment,
+				Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+					packages.NeedModule | packages.NeedDeps | packages.NeedImports | packages.NeedSyntax |
+					packages.NeedTypes | packages.NeedTypesSizes,
+			}, ".")
+			if err != nil {
+				return nil, err
+			}
+			if len(loaded) != 1 {
+				return nil, fmt.Errorf("SDK numerical reload selected %d packages, want one", len(loaded))
+			}
+			actual = loaded[0]
+			return sdkPackageView(actual), nil
+		})
+	if err != nil {
+		return translation{}, err
+	}
+	defer func() {
+		result = errors.Join(result, sdkfrontend.Check(sdkPackageView(actual), observed, target), close())
+	}()
+	values, err := sdkfrontend.EnvironmentValues(observed.Environment())
+	if err != nil {
+		return translation{}, err
+	}
+	file, source, err := sdkfrontend.Capture(ctx, sdkfrontend.CaptureRequest{
+		GoBinary: binary, Root: values["GOROOT"], Directory: actual.Dir, PackagePath: actual.PkgPath,
+		AssemblyFile: asmPath, Target: target, Environment: observed.Environment(),
+		Package: sdkPackageView(actual),
+	}, file)
+	if err != nil {
+		return translation{}, err
+	}
+	defer func() { result = errors.Join(result, source.Verify(ctx), source.Close()) }()
+	resolve := func(symbol string) string { return sdkfrontend.Resolve(actual.PkgPath, symbol) }
+	goos, goarch, _ := strings.Cut(target, "/")
+	sigs, err := sigsForAsmFile(actual, file, resolve, goarch)
+	if err != nil {
+		return translation{}, err
+	}
+	options, err := source.BindNumericalReads(ctx, goPackageView(actual), file, plan9asm.Options{
+		TargetTriple: targetTriple(goos, goarch), ResolveSym: resolve, Sigs: sigs, Goarch: goarch, AnnotateSource: annotate,
+	})
+	if err != nil {
+		return translation{}, err
+	}
+	ir, err := plan9asm.Translate(file, options)
+	if err != nil {
+		return translation{}, err
+	}
+	return translation{LLVMIR: ir, Functions: collectFunctionInfo(file, sigs, resolve)}, nil
+}
+
+func goPackageView(pkg *packages.Package) plan9asm.GoPackage {
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	syntax := make(map[string][]*ast.File, len(pkg.Imports))
+	for path, dependency := range pkg.Imports {
+		if dependency != nil {
+			imports[path] = dependency.Types
+			if dependency.Types != nil && len(dependency.Syntax) != 0 {
+				syntax[path] = dependency.Syntax
+			}
+		}
+	}
+	return plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Imports: imports,
+		Syntax: pkg.Syntax, ImportSyntax: syntax}
+}
+
+// The caller owns this one complete-source consumption. Never retain the LLVM
+// module or its call-local declaration facts after copying the public result.
+func translateLoadedGoModule(pkg *packages.Package, source []byte, asmPath, goos, goarch string, annotate bool) (translation, error) {
+	wasmABI := plan9asm.WASMABIDirect
+	if goarch == "wasm" && (goos == "js" || goos == "wasip1") {
+		wasmABI = plan9asm.WASMABIGo
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := plan9asm.TranslateGoModuleInContext(ctx, goPackageView(pkg), source, plan9asm.GoModuleOptions{
+		FileName: asmPath, GOOS: goos, GOARCH: goarch, Sizes: pkg.TypesSizes,
+		TargetTriple: targetTriple(goos, goarch), WASMABI: wasmABI,
+		AnnotateSource: annotate, ResolveSym: resolveSymFunc(pkg.PkgPath),
+	})
+	if module != nil && !module.Module.IsNil() {
+		defer module.Module.Dispose()
+	}
+	if err != nil {
+		return translation{}, err
+	}
+	if module == nil || module.Module.IsNil() {
+		return translation{}, fmt.Errorf("complete GoModule translation returned no LLVM module")
+	}
+	functions := make([]functionInfo, 0, len(module.Functions))
+	for _, function := range module.Functions {
+		signature := module.Signatures[function.ResolvedSymbol]
+		arguments := make([]string, len(signature.Args))
+		for index, argument := range signature.Args {
+			arguments[index] = string(argument)
+		}
+		result := string(signature.Ret)
+		if result == "" {
+			result = string(plan9asm.Void)
+		}
+		functions = append(functions, functionInfo{Symbol: function.TextSymbol,
+			Resolved: function.ResolvedSymbol, Args: arguments, Ret: result})
+	}
+	return translation{LLVMIR: module.Module.String(), Functions: functions}, nil
+}
diff --git a/cmd/plan9asm/sdk_source_go127_test.go b/cmd/plan9asm/sdk_source_go127_test.go
new file mode 100644
index 000000000..bbc8117dc
--- /dev/null
+++ b/cmd/plan9asm/sdk_source_go127_test.go
@@ -0,0 +1,286 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+)
+
+func setSimpleSDKProfile(t *testing.T) {
+	t.Helper()
+	for key, value := range map[string]string{
+		"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOPACKAGESDRIVER": "off",
+		"GOAMD64": "v1", "GO386": "sse2",
+	} {
+		t.Setenv(key, value)
+	}
+	for _, key := range []string{"CGO_ENABLED", "GOPATH", "GOMODCACHE", "GOTMPDIR"} {
+		t.Setenv(key, "")
+		if err := os.Unsetenv(key); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("GOCACHE", t.TempDir())
+}
+
+func TestTranslateOriginalSDKCRC32NumericalSource(t *testing.T) {
+	verifyOriginalSDKCRC32NumericalSource(t, "linux")
+}
+
+func TestTranslateOriginalSDKCRC32NumericalSourceNonLinux(t *testing.T) {
+	for _, goos := range []string{"darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			verifyOriginalSDKCRC32NumericalSource(t, goos)
+		})
+	}
+}
+
+func verifyOriginalSDKCRC32NumericalSource(t *testing.T, goos string) {
+	t.Helper()
+	setSimpleSDKProfile(t)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	input := filepath.Join(runtime.GOROOT(), "src", "hash", "crc32", "crc32_amd64.s")
+	original, err := os.ReadFile(input)
+	if err != nil || !strings.Contains(string(original), "CMPB internal∕cpu·X86+") {
+		t.Fatal("actual SDK CRC32 counterexample is absent", err)
+	}
+	pkg, err := loadPackage("hash/crc32", goos, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tr, ok, err := translateAsmForPackage(pkg.Package, input, goos, "amd64", false, pkg.selected)
+	if err != nil || !ok {
+		t.Fatalf("unchanged original SDK translation: %v (TEXT=%t)", err, ok)
+	}
+	if !strings.Contains(tr.LLVMIR, "target triple = \""+targetTriple(goos, "amd64")+"\"") {
+		t.Fatal("translated SDK source did not retain its actual target triple")
+	}
+	llc := sdkLLVM22LLC(t, ctx)
+	folder := t.TempDir()
+	ir, object := filepath.Join(folder, "crc32.ll"), filepath.Join(folder, "crc32.o")
+	if err := os.WriteFile(ir, []byte(tr.LLVMIR), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, folder, os.Environ(), llc, "-filetype=obj", "-o", object, ir)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual SDK LLVM22 object: %v\n%s%s", err, stdout, stderr)
+	}
+	info, err := os.Stat(object)
+	if err != nil || info.Size() == 0 {
+		t.Fatal("LLVM22 object is absent", err)
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("selected original SDK bytes changed", err)
+	}
+	t.Logf("original SDK SHA256=%x; LLVM22 object bytes=%d", sha256.Sum256(original), info.Size())
+}
+
+func TestSimpleCLIOriginalSDKCRC32PublicationAndRejection(t *testing.T) {
+	setSimpleSDKProfile(t)
+	input := filepath.Join(runtime.GOROOT(), "src", "hash", "crc32", "crc32_amd64.s")
+	original, err := os.ReadFile(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mode := range []string{"file", "package", "file-cgo"} {
+		t.Run(mode, func(t *testing.T) {
+			if mode == "file-cgo" {
+				t.Setenv("CGO_ENABLED", "1")
+			}
+			folder := t.TempDir()
+			meta := filepath.Join(folder, "metadata.json")
+			output := filepath.Join(folder, "crc32.ll")
+			args := []string{"-goos=linux", "-goarch=amd64", "-meta=" + meta}
+			if strings.HasPrefix(mode, "file") {
+				args = append(args, "-i="+input, "-o="+output)
+			} else {
+				args = append(args, "-dir="+folder, "hash/crc32")
+				output = filepath.Join(folder, "crc32_amd64.s.ll")
+			}
+			if err := runTranspile(args); err != nil {
+				t.Fatalf("public %s entry point rejected unchanged SDK source: %v", mode, err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "hash/crc32.r2r1<>") ||
+				!strings.Contains(string(ir), "internal/cpu.X86") || strings.Contains(string(ir), "hash/crc32.r2r1$local") {
+				t.Fatalf("public SDK result lost the original native namespace: %v", err)
+			}
+			raw, err := os.ReadFile(meta)
+			if err != nil || !json.Valid(raw) || !strings.Contains(string(raw), `"package": "hash/crc32"`) ||
+				!strings.Contains(string(raw), `"resolved": "hash/crc32.ieeeCLMUL"`) {
+				t.Fatalf("public SDK metadata is absent/incomplete: %v\n%s", err, raw)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			object := filepath.Join(folder, "crc32.o")
+			stdout, stderr, err := gotoolprofile.RunBounded(ctx, folder, os.Environ(), sdkLLVM22LLC(t, ctx),
+				"-filetype=obj", "-o", object, output)
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("public SDK LLVM22 object: %v\n%s%s", err, stdout, stderr)
+			}
+			if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+				t.Fatal("public SDK object is absent", err)
+			}
+		})
+	}
+	for _, row := range []struct{ key, value string }{{"GOAMD64", "v2"}, {"GOFLAGS", "-tags=unobserved_sdk_profile"}} {
+		t.Run("reject-"+row.key, func(t *testing.T) {
+			t.Setenv(row.key, row.value)
+			folder := t.TempDir()
+			output, meta := filepath.Join(folder, "rejected.ll"), filepath.Join(folder, "rejected.json")
+			const retained = "preexisting output\n"
+			for _, name := range []string{output, meta} {
+				if err := os.WriteFile(name, []byte(retained), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			err := runTranspile([]string{"-goos=linux", "-goarch=amd64", "-i=" + input, "-o=" + output, "-meta=" + meta})
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("unobserved profile was not rejected with its missing source contract: %v", err)
+			}
+			for _, name := range []string{output, meta} {
+				actual, err := os.ReadFile(name)
+				if err != nil || string(actual) != retained {
+					t.Fatalf("failed source observation published/overwrote output: %v", err)
+				}
+			}
+		})
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("public CLI changed original selected SDK source", err)
+	}
+}
+
+func TestSimpleSDKVariableQueryUsesOriginalMapsSource(t *testing.T) {
+	setSimpleSDKProfile(t)
+	pkg, err := loadPackage("internal/runtime/maps", "linux", "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := filepath.Join(pkg.Dir, "memhash_amd64.s")
+	selected := false
+	for _, name := range pkg.OtherFiles {
+		selected = selected || name == input
+	}
+	if !selected {
+		t.Fatal("the actual original SDK load did not select its AES source")
+	}
+	source, err := plan9asm.ReadGoAssemblySource(input, pkg.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(source), plan9asm.GoAssemblerDefines("linux", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	view := sdkPackageView(pkg.Package)
+	if sdkfrontend.CPUOwnerRequested(view, file, "linux/amd64") || !sdkfrontend.NumericalOwnerRequested(view, file, "linux/amd64") {
+		t.Fatal("the original SDK's Go-variable source still depends on the CPU-only cost query")
+	}
+	queries := sdkfrontend.OwnerRequests(view, file, "linux/amd64")
+	if len(queries) != 1 || queries[0].CPU || queries[0].PackagePath != pkg.PkgPath || len(queries[0].Variables) != 1 ||
+		queries[0].Variables[0].Name != "aeskeysched" {
+		t.Fatalf("original typed Go-variable query is incomplete: %+v", queries)
+	}
+	variable, valid := pkg.Types.Scope().Lookup("aeskeysched").(*types.Var)
+	if !valid || pkg.TypesSizes.Sizeof(variable.Type()) != 128 {
+		t.Fatal("actual compiler-selected variable/type extent differs")
+	}
+	// This original-source/type query is not an ABIInternal/native-entry join
+	// or successful maps translation. Those remain independent core contracts.
+}
+
+func TestSimpleCLIOriginalSDKMapsScalarRegisterSource(t *testing.T) {
+	setSimpleSDKProfile(t)
+	input := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "maps", "memhash_nosimd_amd64.s")
+	original, err := os.ReadFile(input)
+	if err != nil || !strings.Contains(string(original), "TEXT ·memHash32AES<ABIInternal>") ||
+		!strings.Contains(string(original), "TEXT ·memHash64AES<ABIInternal>") {
+		t.Fatal("complete original SDK scalar-register counterexample is absent", err)
+	}
+	folder := t.TempDir()
+	output, meta := filepath.Join(folder, "maps.ll"), filepath.Join(folder, "maps.json")
+	if err := runTranspile([]string{"-goos=linux", "-goarch=amd64", "-i=" + input, "-o=" + output, "-meta=" + meta}); err != nil {
+		t.Fatalf("complete unchanged SDK scalar-register source: %v", err)
+	}
+	raw, err := os.ReadFile(meta)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var metadata struct{ Functions []functionInfo }
+	if err := json.Unmarshal(raw, &metadata); err != nil || len(metadata.Functions) != 2 {
+		t.Fatalf("complete SDK scalar-register functions were not published: %v\n%s", err, raw)
+	}
+	for index, fn := range metadata.Functions {
+		first := "i32"
+		if index == 1 {
+			first = "i64"
+		}
+		if fn.Resolved != "internal/runtime/maps.memHash"+map[int]string{0: "32", 1: "64"}[index]+"AES" ||
+			len(fn.Args) != 2 || fn.Args[0] != first || fn.Args[1] != "i64" || fn.Ret != "i64" {
+			t.Fatalf("actual integer declaration/namespace changed: %+v", fn)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	llc := sdkLLVM22LLC(t, ctx)
+	for _, optimization := range []string{"0", "2"} {
+		object := filepath.Join(folder, "maps-O"+optimization+".o")
+		stdout, stderr, err := gotoolprofile.RunBounded(ctx, folder, os.Environ(), llc,
+			"-O="+optimization, "-filetype=obj", "-o", object, output)
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("complete SDK scalar-register LLVM22 O%s object: %v\n%s%s", optimization, err, stdout, stderr)
+		}
+		if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+			t.Fatal("complete SDK scalar-register object is absent", err)
+		}
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("SDK scalar-register original source changed", err)
+	}
+	t.Logf("complete original SDK scalar-register SHA256=%x; both declarations and LLVM22 O0/O2 objects passed", sha256.Sum256(original))
+}
+
+func sdkLLVM22LLC(t *testing.T, ctx context.Context) string {
+	t.Helper()
+	candidates := []string{"llc-22", "llc"}
+	if config := os.Getenv("LLVM_CONFIG"); config != "" {
+		bin, stderr, err := gotoolprofile.RunBounded(ctx, "", os.Environ(), config, "--bindir")
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("selected LLVM_CONFIG: %v\n%s%s", err, bin, stderr)
+		}
+		candidates = []string{filepath.Join(strings.TrimSpace(string(bin)), "llc")}
+	}
+	for _, candidate := range candidates {
+		llc, err := exec.LookPath(candidate)
+		if err != nil {
+			continue
+		}
+		version, stderr, err := gotoolprofile.RunBounded(ctx, "", os.Environ(), llc, "--version")
+		if err == nil && len(stderr) == 0 && strings.Contains(string(version), "LLVM version 22.") {
+			return llc
+		}
+	}
+	t.Fatal("required LLVM22 llc is absent")
+	return ""
+}
diff --git a/cmd/plan9asm/symbol_offset_test.go b/cmd/plan9asm/symbol_offset_test.go
new file mode 100644
index 000000000..0fe41428f
--- /dev/null
+++ b/cmd/plan9asm/symbol_offset_test.go
@@ -0,0 +1,23 @@
+package main
+
+import "testing"
+
+func TestSplitSymbolOffsetExpressions(t *testing.T) {
+	tests := []struct {
+		input string
+		name  string
+		off   int64
+	}{
+		{"data+ 8", "data", 8},
+		{"data - 8", "data", -8},
+		{"data+(4*2)", "data", 8},
+		{"data+8-4", "data", 4},
+		{"data-name", "data-name", 0},
+	}
+	for _, tt := range tests {
+		name, off := splitSymPlusOff(tt.input)
+		if name != tt.name || off != tt.off {
+			t.Errorf("splitSymPlusOff(%q) = %q, %d; want %q, %d", tt.input, name, off, tt.name, tt.off)
+		}
+	}
+}
diff --git a/cmd/plan9asmcorpus/main.go b/cmd/plan9asmcorpus/main.go
deleted file mode 100644
index 47dd6f170..000000000
--- a/cmd/plan9asmcorpus/main.go
+++ /dev/null
@@ -1,406 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-type corpusManifest struct {
-	SchemaVersion int               `json:"schema_version"`
-	Targets       []string          `json:"targets"`
-	Libraries     []libraryManifest `json:"libraries"`
-}
-
-type libraryManifest struct {
-	ID        string                       `json:"id"`
-	Origin    string                       `json:"origin"`
-	Issues    []string                     `json:"issues,omitempty"`
-	Module    string                       `json:"module"`
-	Version   string                       `json:"version"`
-	Inventory map[string]expectedInventory `json:"inventory"`
-}
-
-type expectedInventory struct {
-	AsmFiles int      `json:"asm_files"`
-	Packages []string `json:"packages"`
-}
-
-type moduleInfo struct {
-	Path    string `json:"Path"`
-	Version string `json:"Version"`
-}
-
-type commandInvocation struct {
-	Dir  string
-	Args []string
-}
-
-type matrixReport struct {
-	Targets      []targetReport `json:"targets"`
-	TotalTargets int            `json:"total_targets"`
-	TotalAsm     int            `json:"total_asm"`
-	Success      int            `json:"success"`
-	Failed       int            `json:"failed"`
-}
-
-type targetReport struct {
-	Goos        string   `json:"goos"`
-	Goarch      string   `json:"goarch"`
-	TotalPkgs   int      `json:"total_pkgs"`
-	AsmPackages []string `json:"asm_packages"`
-	TotalAsm    int      `json:"total_asm"`
-	Success     int      `json:"success"`
-	Failed      int      `json:"failed"`
-}
-
-var (
-	issueURLPattern = regexp.MustCompile(`^https://github\.com/xgo-dev/llgo/issues/[1-9][0-9]*$`)
-	idPattern       = regexp.MustCompile(`^[a-z0-9]+(?:-[a-z0-9]+)*$`)
-)
-
-const (
-	originLLGoIssue     = "llgo-issue"
-	originEcosystemScan = "ecosystem-scan"
-)
-
-func main() {
-	manifestPath := flag.String("manifest", "testdata/corpus/reported-libraries.json", "third-party library manifest")
-	corpusDir := flag.String("corpus-dir", "testdata/corpus", "module used to resolve third-party libraries")
-	repoRoot := flag.String("repo-root", ".", "plan9asm repository root")
-	translator := flag.String("translator", "", "path to the plan9asmll binary")
-	llc := flag.String("llc", "", "path to llc")
-	suite := flag.String("suite", "all", "suite id to run, or all")
-	checkLatest := flag.Bool("check-latest", true, "require each pinned module version to equal @latest")
-	list := flag.Bool("list", false, "list suite ids as a JSON array and exit")
-	flag.Parse()
-
-	manifest, err := loadManifest(*manifestPath)
-	check(err)
-	if *list {
-		ids := make([]string, 0, len(manifest.Libraries))
-		for _, library := range manifest.Libraries {
-			ids = append(ids, library.ID)
-		}
-		check(json.NewEncoder(os.Stdout).Encode(ids))
-		return
-	}
-	if *translator == "" {
-		check(errors.New("-translator is required"))
-	}
-	if *llc == "" {
-		check(errors.New("-llc is required"))
-	}
-
-	libraries, err := selectLibraries(manifest.Libraries, *suite)
-	check(err)
-	for _, library := range libraries {
-		check(runLibrary(manifest, library, *corpusDir, *repoRoot, *translator, *llc, *checkLatest))
-	}
-}
-
-func check(err error) {
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}
-
-func loadManifest(path string) (corpusManifest, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return corpusManifest{}, fmt.Errorf("open manifest: %w", err)
-	}
-	defer f.Close()
-	dec := json.NewDecoder(f)
-	dec.DisallowUnknownFields()
-	var manifest corpusManifest
-	if err := dec.Decode(&manifest); err != nil {
-		return corpusManifest{}, fmt.Errorf("decode manifest: %w", err)
-	}
-	if err := ensureJSONEOF(dec); err != nil {
-		return corpusManifest{}, err
-	}
-	if err := validateManifest(manifest); err != nil {
-		return corpusManifest{}, err
-	}
-	return manifest, nil
-}
-
-func ensureJSONEOF(dec *json.Decoder) error {
-	var extra interface{}
-	if err := dec.Decode(&extra); err == io.EOF {
-		return nil
-	} else if err != nil {
-		return fmt.Errorf("decode trailing manifest data: %w", err)
-	}
-	return errors.New("manifest contains more than one JSON value")
-}
-
-func validateManifest(manifest corpusManifest) error {
-	if manifest.SchemaVersion != 1 {
-		return fmt.Errorf("unsupported manifest schema_version %d", manifest.SchemaVersion)
-	}
-	if len(manifest.Targets) == 0 {
-		return errors.New("manifest has no targets")
-	}
-	targets := make(map[string]bool, len(manifest.Targets))
-	for _, target := range manifest.Targets {
-		if err := validateTarget(target); err != nil {
-			return err
-		}
-		if targets[target] {
-			return fmt.Errorf("duplicate target %q", target)
-		}
-		targets[target] = true
-	}
-	if len(manifest.Libraries) == 0 {
-		return errors.New("manifest has no libraries")
-	}
-	ids := make(map[string]bool, len(manifest.Libraries))
-	modules := make(map[string]bool, len(manifest.Libraries))
-	for _, library := range manifest.Libraries {
-		if !idPattern.MatchString(library.ID) {
-			return fmt.Errorf("invalid library id %q", library.ID)
-		}
-		if ids[library.ID] {
-			return fmt.Errorf("duplicate library id %q", library.ID)
-		}
-		ids[library.ID] = true
-		if library.Module == "" || library.Version == "" {
-			return fmt.Errorf("library %q requires module and version", library.ID)
-		}
-		if modules[library.Module] {
-			return fmt.Errorf("duplicate library module %q", library.Module)
-		}
-		modules[library.Module] = true
-		switch library.Origin {
-		case originLLGoIssue:
-			if len(library.Issues) == 0 {
-				return fmt.Errorf("library %q has no source issue", library.ID)
-			}
-		case originEcosystemScan:
-			if len(library.Issues) != 0 {
-				return fmt.Errorf("ecosystem-scan library %q must not claim a source issue", library.ID)
-			}
-		default:
-			return fmt.Errorf("library %q has invalid origin %q", library.ID, library.Origin)
-		}
-		seenIssues := make(map[string]bool, len(library.Issues))
-		for _, issue := range library.Issues {
-			if !issueURLPattern.MatchString(issue) {
-				return fmt.Errorf("library %q has invalid issue URL %q", library.ID, issue)
-			}
-			if seenIssues[issue] {
-				return fmt.Errorf("library %q repeats source issue %q", library.ID, issue)
-			}
-			seenIssues[issue] = true
-		}
-		totalAsm := 0
-		for target, inventory := range library.Inventory {
-			if !targets[target] {
-				return fmt.Errorf("library %q inventory has unknown target %q", library.ID, target)
-			}
-			if inventory.AsmFiles <= 0 {
-				return fmt.Errorf("library %q target %q has non-positive asm_files", library.ID, target)
-			}
-			if len(inventory.Packages) == 0 || inventory.AsmFiles < len(inventory.Packages) {
-				return fmt.Errorf("library %q target %q has inconsistent package/file inventory", library.ID, target)
-			}
-			if !sort.StringsAreSorted(inventory.Packages) {
-				return fmt.Errorf("library %q target %q packages are not sorted", library.ID, target)
-			}
-			for i, pkg := range inventory.Packages {
-				if pkg != library.Module && !strings.HasPrefix(pkg, library.Module+"/") {
-					return fmt.Errorf("library %q target %q package %q is outside module", library.ID, target, pkg)
-				}
-				if i > 0 && inventory.Packages[i-1] == pkg {
-					return fmt.Errorf("library %q target %q repeats package %q", library.ID, target, pkg)
-				}
-			}
-			totalAsm += inventory.AsmFiles
-		}
-		if totalAsm == 0 {
-			return fmt.Errorf("library %q contains no assembly on the target matrix", library.ID)
-		}
-	}
-	return nil
-}
-
-func validateTarget(target string) error {
-	parts := strings.Split(target, "/")
-	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
-		return fmt.Errorf("invalid target %q", target)
-	}
-	switch parts[1] {
-	case "386", "amd64", "arm", "arm64", "wasm":
-		return nil
-	default:
-		return fmt.Errorf("target %q uses unsupported Plan 9 architecture", target)
-	}
-}
-
-func selectLibraries(libraries []libraryManifest, suite string) ([]libraryManifest, error) {
-	if suite == "all" {
-		return libraries, nil
-	}
-	for _, library := range libraries {
-		if library.ID == suite {
-			return []libraryManifest{library}, nil
-		}
-	}
-	return nil, fmt.Errorf("unknown third-party library suite %q", suite)
-}
-
-func runLibrary(manifest corpusManifest, library libraryManifest, corpusDir, repoRoot, translator, llc string, checkLatest bool) error {
-	fmt.Printf("== third-party library %s (%s@%s; %s) ==\n", library.ID, library.Module, library.Version, library.Origin)
-	pinned, err := queryModule(corpusDir, library.Module)
-	if err != nil {
-		return fmt.Errorf("%s: resolve pinned module: %w", library.ID, err)
-	}
-	if pinned.Path != library.Module || pinned.Version != library.Version {
-		return fmt.Errorf("%s: corpus go.mod resolves %s@%s, manifest requires %s@%s", library.ID, pinned.Path, pinned.Version, library.Module, library.Version)
-	}
-	if checkLatest {
-		latest, err := queryModule(corpusDir, library.Module+"@latest")
-		if err != nil {
-			return fmt.Errorf("%s: resolve latest module: %w", library.ID, err)
-		}
-		if latest.Path != library.Module || latest.Version != library.Version {
-			return fmt.Errorf("%s: latest version is %s@%s; update the pinned corpus and inventory from %s@%s", library.ID, latest.Path, latest.Version, library.Module, library.Version)
-		}
-		fmt.Printf("latest version confirmed: %s@%s\n", latest.Path, latest.Version)
-	}
-	if err := runCommand(corpusDir, "go", "mod", "download", library.Module+"@"+library.Version); err != nil {
-		return fmt.Errorf("%s: download module: %w", library.ID, err)
-	}
-	tmpDir, err := os.MkdirTemp("", "plan9asm-third-party-"+library.ID+"-")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(tmpDir)
-	reportPath := filepath.Join(tmpDir, "report.json")
-	invocation := makeTranslatorInvocation(corpusDir, library.Module, filepath.Join(tmpDir, "out"), repoRoot, llc, reportPath)
-	if err := runCommand(invocation.Dir, translator, invocation.Args...); err != nil {
-		return fmt.Errorf("%s: translate and compile corpus: %w", library.ID, err)
-	}
-	report, err := loadReport(reportPath)
-	if err != nil {
-		return fmt.Errorf("%s: %w", library.ID, err)
-	}
-	if err := validateReport(manifest.Targets, library, report); err != nil {
-		return err
-	}
-	fmt.Printf("%s: all %d assembly translations passed across %d targets\n", library.ID, report.TotalAsm, report.TotalTargets)
-	return nil
-}
-
-func makeTranslatorInvocation(corpusDir, modulePath, outDir, repoRoot, llc, reportPath string) commandInvocation {
-	return commandInvocation{Dir: corpusDir, Args: []string{
-		"-all-targets",
-		"-patterns=" + modulePath + "/...",
-		"-module-path=" + modulePath,
-		"-out=" + outDir,
-		"-compile",
-		"-llc=" + llc,
-		"-report=" + reportPath,
-		"-repo-root=" + repoRoot,
-		"-strict-load",
-	}}
-}
-
-func queryModule(dir, query string) (moduleInfo, error) {
-	cmd := exec.Command("go", "list", "-m", "-json", query)
-	cmd.Dir = dir
-	var stdout, stderr bytes.Buffer
-	cmd.Stdout = &stdout
-	cmd.Stderr = &stderr
-	if err := cmd.Run(); err != nil {
-		return moduleInfo{}, fmt.Errorf("go list %s: %w: %s", query, err, strings.TrimSpace(stderr.String()))
-	}
-	var info moduleInfo
-	if err := json.Unmarshal(stdout.Bytes(), &info); err != nil {
-		return moduleInfo{}, fmt.Errorf("decode go list %s: %w", query, err)
-	}
-	return info, nil
-}
-
-func runCommand(dir, name string, args ...string) error {
-	cmd := exec.Command(name, args...)
-	cmd.Dir = dir
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	return cmd.Run()
-}
-
-func loadReport(path string) (matrixReport, error) {
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return matrixReport{}, fmt.Errorf("read report: %w", err)
-	}
-	var report matrixReport
-	if err := json.Unmarshal(data, &report); err != nil {
-		return matrixReport{}, fmt.Errorf("decode report: %w", err)
-	}
-	return report, nil
-}
-
-func validateReport(targets []string, library libraryManifest, report matrixReport) error {
-	if report.TotalTargets != len(targets) || len(report.Targets) != len(targets) {
-		return fmt.Errorf("%s: target coverage changed: got total=%d reports=%d, want %d", library.ID, report.TotalTargets, len(report.Targets), len(targets))
-	}
-	seen := make(map[string]bool, len(targets))
-	totalAsm := 0
-	totalSuccess := 0
-	for _, actual := range report.Targets {
-		target := actual.Goos + "/" + actual.Goarch
-		if seen[target] {
-			return fmt.Errorf("%s: duplicate target report %s", library.ID, target)
-		}
-		seen[target] = true
-		expected := library.Inventory[target]
-		packages := append([]string(nil), actual.AsmPackages...)
-		sort.Strings(packages)
-		if actual.TotalAsm != expected.AsmFiles || !equalStrings(packages, expected.Packages) {
-			return fmt.Errorf("%s: %s assembly inventory changed: got files=%d packages=%v, want files=%d packages=%v", library.ID, target, actual.TotalAsm, packages, expected.AsmFiles, expected.Packages)
-		}
-		if actual.TotalPkgs != len(actual.AsmPackages) {
-			return fmt.Errorf("%s: %s inconsistent package count: total_pkgs=%d asm_packages=%v", library.ID, target, actual.TotalPkgs, actual.AsmPackages)
-		}
-		if actual.Failed != 0 || actual.Success != actual.TotalAsm {
-			return fmt.Errorf("%s: %s failed: success=%d failed=%d total=%d", library.ID, target, actual.Success, actual.Failed, actual.TotalAsm)
-		}
-		totalAsm += actual.TotalAsm
-		totalSuccess += actual.Success
-	}
-	for _, target := range targets {
-		if !seen[target] {
-			return fmt.Errorf("%s: target %s was silently skipped", library.ID, target)
-		}
-	}
-	if report.TotalAsm != totalAsm || report.Success != totalSuccess || report.Failed != 0 || report.Success != report.TotalAsm {
-		return fmt.Errorf("%s: inconsistent matrix totals: success=%d failed=%d total=%d", library.ID, report.Success, report.Failed, report.TotalAsm)
-	}
-	return nil
-}
-
-func equalStrings(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}
diff --git a/cmd/plan9asmcorpus/main_test.go b/cmd/plan9asmcorpus/main_test.go
deleted file mode 100644
index 1815a31cd..000000000
--- a/cmd/plan9asmcorpus/main_test.go
+++ /dev/null
@@ -1,144 +0,0 @@
-package main
-
-import (
-	"path/filepath"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestRepositoryManifestTracksReportedAssemblyFailures(t *testing.T) {
-	manifest, err := loadManifest(filepath.Join("..", "..", "testdata", "corpus", "reported-libraries.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := map[string]string{
-		"coder-websocket":    "https://github.com/xgo-dev/llgo/issues/2464",
-		"klauspost-compress": "https://github.com/xgo-dev/llgo/issues/2552",
-		"go-hex":             "https://github.com/xgo-dev/llgo/issues/2576",
-	}
-	got := make(map[string]string, len(want))
-	for _, library := range manifest.Libraries {
-		if library.Origin == originLLGoIssue {
-			got[library.ID] = strings.Join(library.Issues, ",")
-		}
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("reported library issues = %#v, want %#v", got, want)
-	}
-	wantTargets := []string{
-		"darwin/amd64",
-		"darwin/arm64",
-		"linux/386",
-		"linux/amd64",
-		"linux/arm",
-		"linux/arm64",
-		"windows/386",
-		"windows/amd64",
-		"windows/arm64",
-		"js/wasm",
-		"wasip1/wasm",
-	}
-	if !reflect.DeepEqual(manifest.Targets, wantTargets) {
-		t.Fatalf("reported library targets = %#v, want %#v", manifest.Targets, wantTargets)
-	}
-}
-
-func TestRepositoryManifestTracksEcosystemDiscoveries(t *testing.T) {
-	manifest, err := loadManifest(filepath.Join("..", "..", "testdata", "corpus", "reported-libraries.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	want := map[string]bool{
-		"anacrolix-mmsg":        true,
-		"btcsuite-fastsha256":   true,
-		"cespare-xxhash-v1":     true,
-		"cespare-xxhash-v2":     true,
-		"dchest-siphash":        true,
-		"dgryski-go-bits":       true,
-		"dgryski-go-marvin32":   true,
-		"golang-snappy":         true,
-		"klauspost-cpuid-v1":    true,
-		"klauspost-cpuid-v2":    true,
-		"klauspost-reedsolomon": true,
-		"modern-go-gls":         true,
-		"minio-highwayhash":     true,
-		"pierrec-lz4-v4":        true,
-		"roaring-bitmap":        true,
-		"stevvooe-resumable":    true,
-		"tmthrgd-go-bitwise":    true,
-		"tmthrgd-go-popcount":   true,
-		"x-net":                 true,
-		"x-sys":                 true,
-		"zeebo-this":            true,
-	}
-	got := make(map[string]bool, len(want))
-	for _, library := range manifest.Libraries {
-		if library.Origin == originEcosystemScan {
-			got[library.ID] = true
-		}
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("ecosystem-discovered libraries = %#v, want %#v", got, want)
-	}
-}
-
-func TestTranslatorInvocationFiltersExactModule(t *testing.T) {
-	invocation := makeTranslatorInvocation("/corpus", "example.com/root", "/tmp/out", "/repo", "/bin/llc-22", "/tmp/report.json")
-	if invocation.Dir != "/corpus" {
-		t.Fatalf("translator directory = %q, want corpus module", invocation.Dir)
-	}
-	if !containsString(invocation.Args, "-patterns=example.com/root/...") {
-		t.Fatalf("translator args = %#v, want module package pattern", invocation.Args)
-	}
-	if !containsString(invocation.Args, "-module-path=example.com/root") {
-		t.Fatalf("translator args = %#v, want exact module ownership filter", invocation.Args)
-	}
-}
-
-func containsString(items []string, want string) bool {
-	for _, item := range items {
-		if item == want {
-			return true
-		}
-	}
-	return false
-}
-
-func TestValidateReportRejectsSilentlySkippedTarget(t *testing.T) {
-	library := libraryManifest{
-		ID: "example",
-		Inventory: map[string]expectedInventory{
-			"linux/amd64": {AsmFiles: 1, Packages: []string{"example.com/lib"}},
-		},
-	}
-	report := matrixReport{
-		Targets:      []targetReport{{Goos: "linux", Goarch: "amd64", TotalPkgs: 1, AsmPackages: []string{"example.com/lib"}, TotalAsm: 1, Success: 1}},
-		TotalTargets: 1,
-		TotalAsm:     1,
-		Success:      1,
-	}
-	err := validateReport([]string{"linux/amd64", "linux/arm64"}, library, report)
-	if err == nil || !strings.Contains(err.Error(), "target coverage changed") {
-		t.Fatalf("validateReport() error = %v, want target coverage failure", err)
-	}
-}
-
-func TestValidateReportRejectsInventoryDrift(t *testing.T) {
-	library := libraryManifest{
-		ID: "example",
-		Inventory: map[string]expectedInventory{
-			"linux/amd64": {AsmFiles: 1, Packages: []string{"example.com/lib"}},
-		},
-	}
-	report := matrixReport{
-		Targets:      []targetReport{{Goos: "linux", Goarch: "amd64", TotalPkgs: 1, AsmPackages: []string{"example.com/lib/newasm"}, TotalAsm: 1, Success: 1}},
-		TotalTargets: 1,
-		TotalAsm:     1,
-		Success:      1,
-	}
-	err := validateReport([]string{"linux/amd64"}, library, report)
-	if err == nil || !strings.Contains(err.Error(), "assembly inventory changed") {
-		t.Fatalf("validateReport() error = %v, want inventory failure", err)
-	}
-}
diff --git a/cmd/plan9asmdiscover/main.go b/cmd/plan9asmdiscover/main.go
deleted file mode 100644
index eb96ced16..000000000
--- a/cmd/plan9asmdiscover/main.go
+++ /dev/null
@@ -1,842 +0,0 @@
-// Command plan9asmdiscover finds public Go modules that contain Plan 9
-// assembly. It reads the official module index, resolves each distinct module
-// to @latest, and inspects the cached module ZIP without executing module code.
-package main
-
-import (
-	"archive/zip"
-	"bufio"
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path"
-	"sort"
-	"strings"
-	"sync"
-	"time"
-)
-
-const (
-	defaultIndexURL    = "https://index.golang.org/index"
-	defaultProxyURL    = "https://proxy.golang.org/cached-only"
-	discoverySchema    = 2
-	indexPageLimit     = 2000
-	defaultScanLimit   = 2000
-	defaultMaxZipSize  = 2 << 30
-	defaultHTTPTimeout = 60 * time.Second
-	zipDirectoryTail   = 8 << 20
-	maxAsmProbeSize    = 8 << 20
-	zipReadAhead       = 1 << 20
-	httpAttempts       = 3
-	httpRetryDelay     = 100 * time.Millisecond
-)
-
-type indexEntry struct {
-	Path      string    `json:"Path"`
-	Version   string    `json:"Version"`
-	Timestamp time.Time `json:"Timestamp"`
-}
-
-type latestInfo struct {
-	Version string `json:"Version"`
-}
-
-type moduleVersion struct {
-	Path    string `json:"module"`
-	Version string `json:"version"`
-}
-
-type candidate struct {
-	Module        string   `json:"module"`
-	Version       string   `json:"version"`
-	Architectures []string `json:"architectures"`
-	AsmFiles      []string `json:"asm_files"`
-}
-
-type scanFailure struct {
-	Module  string `json:"module"`
-	Version string `json:"version"`
-	Error   string `json:"error"`
-}
-
-type discoveryReport struct {
-	SchemaVersion int             `json:"schema_version"`
-	GeneratedAt   time.Time       `json:"generated_at"`
-	Since         string          `json:"since,omitempty"`
-	NextSince     string          `json:"next_since,omitempty"`
-	IndexEntries  int             `json:"index_entries"`
-	UniqueModules int             `json:"unique_modules"`
-	Skipped       int             `json:"skipped_previously_scanned,omitempty"`
-	Scanned       []moduleVersion `json:"scanned"`
-	Matched       []candidate     `json:"matched"`
-	Failures      []scanFailure   `json:"failures,omitempty"`
-}
-
-type config struct {
-	indexURL    string
-	proxyURL    string
-	since       string
-	limit       int
-	workers     int
-	maxZipSize  int64
-	httpTimeout time.Duration
-	seen        map[string]struct{}
-}
-
-type pathListFlag []string
-
-func (f *pathListFlag) String() string { return strings.Join(*f, ",") }
-
-func (f *pathListFlag) Set(value string) error {
-	if strings.TrimSpace(value) == "" {
-		return errors.New("seen report path must not be empty")
-	}
-	*f = append(*f, value)
-	return nil
-}
-
-func main() {
-	indexURL := flag.String("index-url", defaultIndexURL, "Go module index endpoint")
-	proxyURL := flag.String("proxy-url", defaultProxyURL, "Go module proxy endpoint")
-	since := flag.String("since", "", "oldest index timestamp (RFC3339); empty starts at the beginning")
-	limit := flag.Int("limit", defaultScanLimit, "maximum index records to inspect; 0 scans until the feed ends")
-	workers := flag.Int("workers", 8, "concurrent module ZIP inspections")
-	maxZipSize := flag.Int64("max-zip-bytes", defaultMaxZipSize, "maximum remote module ZIP size considered")
-	httpTimeout := flag.Duration("http-timeout", defaultHTTPTimeout, "timeout for each index or proxy request")
-	out := flag.String("out", "", "write JSON to this file instead of stdout")
-	var seenReports pathListFlag
-	flag.Var(&seenReports, "seen-report", "prior discovery report to skip (repeatable)")
-	flag.Parse()
-	seen, err := loadSeenReports(seenReports)
-	if err != nil {
-		fatal(err)
-	}
-
-	cfg := config{
-		indexURL:    *indexURL,
-		proxyURL:    strings.TrimRight(*proxyURL, "/"),
-		since:       *since,
-		limit:       *limit,
-		workers:     *workers,
-		maxZipSize:  *maxZipSize,
-		httpTimeout: *httpTimeout,
-		seen:        seen,
-	}
-	if err := validateConfig(cfg); err != nil {
-		fatal(err)
-	}
-
-	ctx := context.Background()
-	client := &http.Client{Timeout: cfg.httpTimeout}
-	report, err := discover(ctx, client, cfg)
-	if err != nil {
-		fatal(err)
-	}
-	var writer io.Writer = os.Stdout
-	if *out != "" {
-		file, err := os.Create(*out)
-		if err != nil {
-			fatal(err)
-		}
-		defer file.Close()
-		writer = file
-	}
-	enc := json.NewEncoder(writer)
-	enc.SetIndent("", "  ")
-	if err := enc.Encode(report); err != nil {
-		fatal(err)
-	}
-}
-
-func fatal(err error) {
-	fmt.Fprintln(os.Stderr, err)
-	os.Exit(1)
-}
-
-func validateConfig(cfg config) error {
-	if _, err := url.ParseRequestURI(cfg.indexURL); err != nil {
-		return fmt.Errorf("invalid index URL: %w", err)
-	}
-	if _, err := url.ParseRequestURI(cfg.proxyURL); err != nil {
-		return fmt.Errorf("invalid proxy URL: %w", err)
-	}
-	if cfg.since != "" {
-		if _, err := time.Parse(time.RFC3339Nano, cfg.since); err != nil {
-			return fmt.Errorf("invalid -since timestamp: %w", err)
-		}
-	}
-	if cfg.limit < 0 {
-		return errors.New("-limit must be nonnegative")
-	}
-	if cfg.workers <= 0 {
-		return errors.New("-workers must be positive")
-	}
-	if cfg.maxZipSize <= 0 {
-		return errors.New("-max-zip-bytes must be positive")
-	}
-	if cfg.httpTimeout <= 0 {
-		return errors.New("-http-timeout must be positive")
-	}
-	return nil
-}
-
-func discover(ctx context.Context, client *http.Client, cfg config) (discoveryReport, error) {
-	entries, nextSince, err := readIndex(ctx, client, cfg.indexURL, cfg.since, cfg.limit)
-	if err != nil {
-		return discoveryReport{}, err
-	}
-	moduleSet := make(map[string]string, len(entries))
-	for _, entry := range entries {
-		moduleSet[entry.Path] = entry.Version
-	}
-	modules := make([]moduleVersion, 0, len(moduleSet))
-	for modulePath, version := range moduleSet {
-		modules = append(modules, moduleVersion{Path: modulePath, Version: version})
-	}
-	sort.Slice(modules, func(i, j int) bool { return modules[i].Path < modules[j].Path })
-	uniqueModules := len(modules)
-	modules, skipped := filterPreviouslyScanned(modules, cfg.seen)
-
-	matched, failures, scanned := inspectModules(ctx, client, cfg.proxyURL, modules, cfg.workers, cfg.maxZipSize)
-	return discoveryReport{
-		SchemaVersion: discoverySchema,
-		GeneratedAt:   time.Now().UTC(),
-		Since:         cfg.since,
-		NextSince:     nextSince,
-		IndexEntries:  len(entries),
-		UniqueModules: uniqueModules,
-		Skipped:       skipped,
-		Scanned:       scanned,
-		Matched:       matched,
-		Failures:      failures,
-	}, nil
-}
-
-func loadSeenReports(paths []string) (map[string]struct{}, error) {
-	seen := make(map[string]struct{})
-	for _, reportPath := range paths {
-		data, err := os.ReadFile(reportPath)
-		if err != nil {
-			return nil, fmt.Errorf("read seen report %q: %w", reportPath, err)
-		}
-		var report discoveryReport
-		if err := json.Unmarshal(data, &report); err != nil {
-			return nil, fmt.Errorf("decode seen report %q: %w", reportPath, err)
-		}
-		for _, item := range report.Scanned {
-			if item.Path == "" || item.Version == "" {
-				return nil, fmt.Errorf("seen report %q contains an incomplete scanned version", reportPath)
-			}
-			seen[scanKey(item)] = struct{}{}
-		}
-		// Older reports did not contain the complete scanned set, but their
-		// successful matches are still safe to reuse.
-		for _, item := range report.Matched {
-			if item.Module != "" && item.Version != "" {
-				seen[scanKey(moduleVersion{Path: item.Module, Version: item.Version})] = struct{}{}
-			}
-		}
-	}
-	return seen, nil
-}
-
-func filterPreviouslyScanned(modules []moduleVersion, seen map[string]struct{}) ([]moduleVersion, int) {
-	if len(seen) == 0 {
-		return modules, 0
-	}
-	pending := make([]moduleVersion, 0, len(modules))
-	skipped := 0
-	for _, module := range modules {
-		if _, ok := seen[scanKey(module)]; ok {
-			skipped++
-			continue
-		}
-		pending = append(pending, module)
-	}
-	return pending, skipped
-}
-
-func scanKey(module moduleVersion) string {
-	return module.Path + "\x00" + module.Version
-}
-
-func readIndex(ctx context.Context, client *http.Client, endpoint, since string, limit int) ([]indexEntry, string, error) {
-	var entries []indexEntry
-	cursor := since
-	seen := make(map[string]struct{})
-	seenAt := make(map[string]int)
-	for limit == 0 || len(entries) < limit {
-		pageSize := indexPageLimit
-		if limit > 0 {
-			pageSize = limit - len(entries) + seenAt[cursor]
-			if pageSize > indexPageLimit {
-				pageSize = indexPageLimit
-			}
-		}
-		parsed, err := url.Parse(endpoint)
-		if err != nil {
-			return nil, "", err
-		}
-		query := parsed.Query()
-		query.Set("limit", fmt.Sprint(pageSize))
-		if cursor != "" {
-			query.Set("since", cursor)
-		}
-		parsed.RawQuery = query.Encode()
-
-		resp, err := doHTTPRequest(ctx, client, http.MethodGet, parsed.String(), nil)
-		if err != nil {
-			return nil, "", fmt.Errorf("read module index: %w", err)
-		}
-		if resp.StatusCode != http.StatusOK {
-			resp.Body.Close()
-			return nil, "", fmt.Errorf("read module index: %s", resp.Status)
-		}
-		scanner := bufio.NewScanner(resp.Body)
-		scanner.Buffer(make([]byte, 64<<10), 1<<20)
-		page := make([]indexEntry, 0, pageSize)
-		for scanner.Scan() {
-			var entry indexEntry
-			if err := json.Unmarshal(scanner.Bytes(), &entry); err != nil {
-				resp.Body.Close()
-				return nil, "", fmt.Errorf("decode module index: %w", err)
-			}
-			if entry.Path == "" || entry.Timestamp.IsZero() {
-				resp.Body.Close()
-				return nil, "", errors.New("module index entry is missing Path or Timestamp")
-			}
-			page = append(page, entry)
-		}
-		scanErr := scanner.Err()
-		resp.Body.Close()
-		if scanErr != nil {
-			return nil, "", fmt.Errorf("read module index: %w", scanErr)
-		}
-		if len(page) == 0 {
-			break
-		}
-		newEntries := 0
-		for _, entry := range page {
-			timestamp := entry.Timestamp.Format(time.RFC3339Nano)
-			key := entry.Path + "\x00" + entry.Version + "\x00" + timestamp
-			if _, ok := seen[key]; ok {
-				continue
-			}
-			seen[key] = struct{}{}
-			seenAt[timestamp]++
-			entries = append(entries, entry)
-			newEntries++
-			cursor = timestamp
-			if limit > 0 && len(entries) == limit {
-				break
-			}
-		}
-		if limit > 0 && len(entries) == limit {
-			break
-		}
-		if len(page) < pageSize {
-			break
-		}
-		lastTimestamp := page[len(page)-1].Timestamp.Format(time.RFC3339Nano)
-		if newEntries == 0 && lastTimestamp == cursor {
-			cursor = page[len(page)-1].Timestamp.Add(time.Nanosecond).Format(time.RFC3339Nano)
-		} else {
-			cursor = lastTimestamp
-		}
-	}
-	return entries, cursor, nil
-}
-
-func inspectModules(ctx context.Context, client *http.Client, proxyURL string, modules []moduleVersion, workers int, maxZipSize int64) ([]candidate, []scanFailure, []moduleVersion) {
-	tasks := make(chan moduleVersion)
-	results := make(chan candidate)
-	errorsOut := make(chan scanFailure)
-	completed := make(chan moduleVersion)
-	var wg sync.WaitGroup
-	for i := 0; i < workers; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for module := range tasks {
-				item, scanned, err := inspectIndexedModule(ctx, client, proxyURL, module, maxZipSize)
-				for _, version := range scanned {
-					completed <- version
-				}
-				if err != nil {
-					errorsOut <- scanFailure{Module: module.Path, Version: module.Version, Error: err.Error()}
-					continue
-				}
-				if len(item.AsmFiles) > 0 {
-					results <- item
-				}
-			}
-		}()
-	}
-	go func() {
-		for _, module := range modules {
-			tasks <- module
-		}
-		close(tasks)
-		wg.Wait()
-		close(results)
-		close(errorsOut)
-		close(completed)
-	}()
-
-	matched := make([]candidate, 0)
-	failures := make([]scanFailure, 0)
-	scannedSet := make(map[string]moduleVersion)
-	for results != nil || errorsOut != nil || completed != nil {
-		select {
-		case item, ok := <-results:
-			if !ok {
-				results = nil
-				continue
-			}
-			matched = append(matched, item)
-		case failure, ok := <-errorsOut:
-			if !ok {
-				errorsOut = nil
-				continue
-			}
-			failures = append(failures, failure)
-		case item, ok := <-completed:
-			if !ok {
-				completed = nil
-				continue
-			}
-			scannedSet[scanKey(item)] = item
-		}
-	}
-	scanned := make([]moduleVersion, 0, len(scannedSet))
-	for _, item := range scannedSet {
-		scanned = append(scanned, item)
-	}
-	sort.Slice(matched, func(i, j int) bool { return matched[i].Module < matched[j].Module })
-	sort.Slice(failures, func(i, j int) bool { return failures[i].Module < failures[j].Module })
-	sort.Slice(scanned, func(i, j int) bool {
-		if scanned[i].Path != scanned[j].Path {
-			return scanned[i].Path < scanned[j].Path
-		}
-		return scanned[i].Version < scanned[j].Version
-	})
-	return matched, failures, scanned
-}
-
-func inspectIndexedModule(ctx context.Context, client *http.Client, proxyURL string, module moduleVersion, maxZipSize int64) (candidate, []moduleVersion, error) {
-	indexed, err := inspectModuleVersion(ctx, client, proxyURL, module.Path, module.Version, maxZipSize)
-	if err != nil {
-		return candidate{}, nil, fmt.Errorf("inspect indexed version %s: %w", module.Version, err)
-	}
-	scanned := []moduleVersion{module}
-	if len(indexed.AsmFiles) == 0 {
-		return indexed, scanned, nil
-	}
-	latestVersion, err := resolveLatest(ctx, client, proxyURL, module.Path)
-	if err != nil {
-		return candidate{}, scanned, err
-	}
-	if latestVersion == module.Version {
-		return indexed, scanned, nil
-	}
-	latest, err := inspectModuleVersion(ctx, client, proxyURL, module.Path, latestVersion, maxZipSize)
-	if err != nil {
-		return candidate{}, scanned, err
-	}
-	scanned = append(scanned, moduleVersion{Path: module.Path, Version: latestVersion})
-	return latest, scanned, nil
-}
-
-func resolveLatest(ctx context.Context, client *http.Client, proxyURL, modulePath string) (string, error) {
-	escapedModule, err := escapeProxyPath(modulePath)
-	if err != nil {
-		return "", err
-	}
-	latestURL := proxyURL + "/" + escapedModule + "/@latest"
-	latestBody, err := get(ctx, client, latestURL, 1<<20)
-	if err != nil {
-		return "", fmt.Errorf("resolve @latest: %w", err)
-	}
-	var latest latestInfo
-	if err := json.Unmarshal(latestBody, &latest); err != nil || latest.Version == "" {
-		return "", fmt.Errorf("decode @latest: %w", err)
-	}
-	return latest.Version, nil
-}
-
-func inspectModuleVersion(ctx context.Context, client *http.Client, proxyURL, modulePath, version string, maxZipSize int64) (candidate, error) {
-	escapedModule, err := escapeProxyPath(modulePath)
-	if err != nil {
-		return candidate{}, err
-	}
-	escapedVersion, err := escapeProxyPath(version)
-	if err != nil {
-		return candidate{}, err
-	}
-	zipURL := proxyURL + "/" + escapedModule + "/@v/" + escapedVersion + ".zip"
-	reader, zipSize, err := newHTTPReaderAt(ctx, client, zipURL, maxZipSize)
-	if err != nil {
-		return candidate{}, fmt.Errorf("open %s ZIP: %w", version, err)
-	}
-	files, arches, err := inspectModuleZipReader(reader, zipSize)
-	if err != nil {
-		return candidate{}, fmt.Errorf("inspect %s: %w", version, err)
-	}
-	return candidate{Module: modulePath, Version: version, Architectures: arches, AsmFiles: files}, nil
-}
-
-func get(ctx context.Context, client *http.Client, endpoint string, maxBytes int64) ([]byte, error) {
-	resp, err := doHTTPRequest(ctx, client, http.MethodGet, endpoint, nil)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("%s", resp.Status)
-	}
-	if resp.ContentLength > maxBytes {
-		return nil, fmt.Errorf("response is %d bytes (limit %d)", resp.ContentLength, maxBytes)
-	}
-	body, err := io.ReadAll(io.LimitReader(resp.Body, maxBytes+1))
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(body)) > maxBytes {
-		return nil, fmt.Errorf("response exceeds %d bytes", maxBytes)
-	}
-	return body, nil
-}
-
-func inspectModuleZip(data []byte) ([]string, []string, error) {
-	return inspectModuleZipReader(bytes.NewReader(data), int64(len(data)))
-}
-
-func inspectModuleZipReader(reader io.ReaderAt, size int64) ([]string, []string, error) {
-	zr, err := zip.NewReader(reader, size)
-	if err != nil {
-		return nil, nil, err
-	}
-	type asmEntry struct {
-		name string
-		file *zip.File
-	}
-	asmFiles := make([]asmEntry, 0)
-	goDirs := make(map[string]struct{})
-	for _, file := range zr.File {
-		name := file.Name
-		at := strings.IndexByte(name, '@')
-		if at < 0 {
-			continue
-		}
-		rootSlash := strings.IndexByte(name[at:], '/')
-		if rootSlash < 0 {
-			continue
-		}
-		rootSlash += at
-		if rootSlash == len(name)-1 {
-			continue
-		}
-		rel := name[rootSlash+1:]
-		if containsPathElement(rel, "testdata") {
-			continue
-		}
-		switch path.Ext(rel) {
-		case ".go":
-			goDirs[path.Dir(rel)] = struct{}{}
-		case ".s":
-			if file.UncompressedSize64 > 0 {
-				asmFiles = append(asmFiles, asmEntry{name: rel, file: file})
-			}
-		}
-	}
-	files := make([]string, 0, len(asmFiles))
-	archSet := make(map[string]struct{})
-	for _, asm := range asmFiles {
-		if _, ok := goDirs[path.Dir(asm.name)]; !ok {
-			continue
-		}
-		hasContent, err := zipAssemblyFileHasContent(asm.file)
-		if err != nil {
-			return nil, nil, fmt.Errorf("read %s: %w", asm.name, err)
-		}
-		if !hasContent {
-			continue
-		}
-		files = append(files, asm.name)
-		archSet[inferAssemblyArchitecture(asm.name)] = struct{}{}
-	}
-	arches := make([]string, 0, len(archSet))
-	for arch := range archSet {
-		arches = append(arches, arch)
-	}
-	sort.Strings(files)
-	sort.Strings(arches)
-	return files, arches, nil
-}
-
-func zipAssemblyFileHasContent(file *zip.File) (bool, error) {
-	if file.UncompressedSize64 > maxAsmProbeSize {
-		// Keep unusually large files in the candidate set so the corpus stage can
-		// validate them; discovery must not silently discard code it did not read.
-		return true, nil
-	}
-	r, err := file.Open()
-	if err != nil {
-		return false, err
-	}
-	defer r.Close()
-	data, err := io.ReadAll(io.LimitReader(r, maxAsmProbeSize+1))
-	if err != nil {
-		return false, err
-	}
-	if len(data) > maxAsmProbeSize {
-		return true, nil
-	}
-	return assemblySourceHasContent(data), nil
-}
-
-func assemblySourceHasContent(data []byte) bool {
-	for i := 0; i < len(data); {
-		switch {
-		case data[i] == ' ' || data[i] == '\t' || data[i] == '\r' || data[i] == '\n' || data[i] == '\f':
-			i++
-		case i+1 < len(data) && data[i] == '/' && data[i+1] == '/':
-			i += 2
-			for i < len(data) && data[i] != '\n' {
-				i++
-			}
-		case i+1 < len(data) && data[i] == '/' && data[i+1] == '*':
-			end := bytes.Index(data[i+2:], []byte("*/"))
-			if end < 0 {
-				return true
-			}
-			i += end + 4
-		default:
-			return true
-		}
-	}
-	return false
-}
-
-type remoteZipReaderAt struct {
-	ctx        context.Context
-	client     *http.Client
-	endpoint   string
-	cachedTail []byte
-	cacheMu    sync.Mutex
-	cachedData map[int64][]byte
-	tailStart  int64
-	size       int64
-}
-
-func newHTTPReaderAt(ctx context.Context, client *http.Client, endpoint string, maxSize int64) (io.ReaderAt, int64, error) {
-	return newHTTPReaderAtWithTail(ctx, client, endpoint, maxSize, zipDirectoryTail)
-}
-
-func newHTTPReaderAtWithTail(ctx context.Context, client *http.Client, endpoint string, maxSize, tailSize int64) (io.ReaderAt, int64, error) {
-	if tailSize <= 0 {
-		return nil, 0, errors.New("ZIP tail size must be positive")
-	}
-	resp, err := doHTTPRequest(ctx, client, http.MethodHead, endpoint, nil)
-	if err != nil {
-		return nil, 0, err
-	}
-	resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return nil, 0, fmt.Errorf("%s", resp.Status)
-	}
-	if resp.ContentLength <= 0 {
-		return nil, 0, errors.New("ZIP response has no content length")
-	}
-	if resp.ContentLength > maxSize {
-		return nil, 0, fmt.Errorf("ZIP is %d bytes (limit %d)", resp.ContentLength, maxSize)
-	}
-	size := resp.ContentLength
-	start := size - tailSize
-	if start < 0 {
-		start = 0
-	}
-	headers := make(http.Header)
-	if start > 0 {
-		headers.Set("Range", fmt.Sprintf("bytes=%d-%d", start, size-1))
-	}
-	resp, err = doHTTPRequest(ctx, client, http.MethodGet, endpoint, headers)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer resp.Body.Close()
-	wantStatus := http.StatusOK
-	if start > 0 {
-		wantStatus = http.StatusPartialContent
-	}
-	if resp.StatusCode != wantStatus {
-		return nil, 0, fmt.Errorf("ZIP tail request returned %s", resp.Status)
-	}
-	wantBytes := size - start
-	data, err := io.ReadAll(io.LimitReader(resp.Body, wantBytes+1))
-	if err != nil {
-		return nil, 0, err
-	}
-	if int64(len(data)) != wantBytes {
-		return nil, 0, fmt.Errorf("ZIP tail returned %d bytes, want %d", len(data), wantBytes)
-	}
-	return &remoteZipReaderAt{
-		ctx:        ctx,
-		client:     client,
-		endpoint:   endpoint,
-		cachedTail: data,
-		cachedData: make(map[int64][]byte),
-		tailStart:  start,
-		size:       size,
-	}, size, nil
-}
-
-func (r *remoteZipReaderAt) ReadAt(p []byte, offset int64) (int, error) {
-	if len(p) == 0 {
-		return 0, nil
-	}
-	if offset < 0 || offset >= r.size || int64(len(p)) > r.size-offset {
-		return 0, io.EOF
-	}
-	written := 0
-	for written < len(p) {
-		current := offset + int64(written)
-		if current >= r.tailStart {
-			written += copy(p[written:], r.cachedTail[current-r.tailStart:])
-			continue
-		}
-		blockStart := current - current%zipReadAhead
-		r.cacheMu.Lock()
-		block, ok := r.cachedData[blockStart]
-		r.cacheMu.Unlock()
-		if !ok {
-			blockEnd := blockStart + zipReadAhead
-			if blockEnd > r.tailStart {
-				blockEnd = r.tailStart
-			}
-			var err error
-			block, err = r.readRange(blockStart, blockEnd)
-			if err != nil {
-				return written, err
-			}
-			r.cacheMu.Lock()
-			r.cachedData[blockStart] = block
-			r.cacheMu.Unlock()
-		}
-		n := copy(p[written:], block[current-blockStart:])
-		if n == 0 {
-			return written, io.ErrUnexpectedEOF
-		}
-		written += n
-	}
-	return written, nil
-}
-
-func (r *remoteZipReaderAt) readRange(start, end int64) ([]byte, error) {
-	headers := make(http.Header)
-	headers.Set("Range", fmt.Sprintf("bytes=%d-%d", start, end-1))
-	resp, err := doHTTPRequest(r.ctx, r.client, http.MethodGet, r.endpoint, headers)
-	if err != nil {
-		return nil, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusPartialContent {
-		return nil, fmt.Errorf("ZIP range request returned %s", resp.Status)
-	}
-	want := end - start
-	data, err := io.ReadAll(io.LimitReader(resp.Body, want+1))
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(data)) != want {
-		return nil, fmt.Errorf("ZIP range returned %d bytes, want %d", len(data), want)
-	}
-	return data, nil
-}
-
-func doHTTPRequest(ctx context.Context, client *http.Client, method, endpoint string, headers http.Header) (*http.Response, error) {
-	var lastErr error
-	for attempt := 1; attempt <= httpAttempts; attempt++ {
-		req, err := http.NewRequestWithContext(ctx, method, endpoint, nil)
-		if err != nil {
-			return nil, err
-		}
-		req.Header = headers.Clone()
-		resp, err := client.Do(req)
-		if err == nil && !isTransientHTTPStatus(resp.StatusCode) {
-			return resp, nil
-		}
-		if err != nil {
-			lastErr = err
-		} else {
-			lastErr = fmt.Errorf("%s", resp.Status)
-			if attempt == httpAttempts {
-				return resp, nil
-			}
-			_, _ = io.Copy(io.Discard, io.LimitReader(resp.Body, 4<<10))
-			resp.Body.Close()
-		}
-		if attempt == httpAttempts {
-			break
-		}
-		timer := time.NewTimer(time.Duration(attempt) * httpRetryDelay)
-		select {
-		case <-ctx.Done():
-			timer.Stop()
-			return nil, ctx.Err()
-		case <-timer.C:
-		}
-	}
-	return nil, lastErr
-}
-
-func isTransientHTTPStatus(status int) bool {
-	return status == http.StatusTooManyRequests || status >= 500
-}
-
-func containsPathElement(name, element string) bool {
-	for _, part := range strings.Split(name, "/") {
-		if part == element {
-			return true
-		}
-	}
-	return false
-}
-
-func inferAssemblyArchitecture(name string) string {
-	base := strings.TrimSuffix(path.Base(name), ".s")
-	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
-		if strings.HasSuffix(base, "_"+arch) {
-			return arch
-		}
-	}
-	return "unknown"
-}
-
-// escapeProxyPath implements the uppercase escaping used by the Go module
-// proxy protocol. Index entries are already valid module paths.
-func escapeProxyPath(value string) (string, error) {
-	if value == "" {
-		return "", errors.New("empty module path or version")
-	}
-	var out strings.Builder
-	for _, r := range value {
-		switch {
-		case r == '!':
-			out.WriteString("!!")
-		case r >= 'A' && r <= 'Z':
-			out.WriteByte('!')
-			out.WriteRune(r + ('a' - 'A'))
-		default:
-			out.WriteRune(r)
-		}
-	}
-	return out.String(), nil
-}
diff --git a/cmd/plan9asmdiscover/main_test.go b/cmd/plan9asmdiscover/main_test.go
deleted file mode 100644
index 5a68ae734..000000000
--- a/cmd/plan9asmdiscover/main_test.go
+++ /dev/null
@@ -1,368 +0,0 @@
-package main
-
-import (
-	"archive/zip"
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"reflect"
-	"strconv"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestEscapeProxyPath(t *testing.T) {
-	got, err := escapeProxyPath("github.com/Azure/azure-sdk-for-go")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want := "github.com/!azure/azure-sdk-for-go"; got != want {
-		t.Fatalf("escapeProxyPath() = %q, want %q", got, want)
-	}
-}
-
-func TestValidateConfigRejectsNonPositiveHTTPTimeout(t *testing.T) {
-	err := validateConfig(config{
-		indexURL:    defaultIndexURL,
-		proxyURL:    defaultProxyURL,
-		workers:     1,
-		maxZipSize:  1,
-		httpTimeout: 0,
-	})
-	if err == nil {
-		t.Fatal("validateConfig() accepted a non-positive HTTP timeout")
-	}
-}
-
-func TestSeenReportsSkipOnlyCompletedExactVersions(t *testing.T) {
-	reportPath := filepath.Join(t.TempDir(), "previous.json")
-	data, err := json.Marshal(discoveryReport{
-		SchemaVersion: 1,
-		Scanned: []moduleVersion{
-			{Path: "example.com/a", Version: "v1.0.0"},
-			{Path: "example.com/noasm", Version: "v2.0.0"},
-		},
-		Matched: []candidate{{Module: "example.com/old-match", Version: "v3.0.0"}},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(reportPath, data, 0o600); err != nil {
-		t.Fatal(err)
-	}
-	seen, err := loadSeenReports([]string{reportPath})
-	if err != nil {
-		t.Fatal(err)
-	}
-	pending, skipped := filterPreviouslyScanned([]moduleVersion{
-		{Path: "example.com/a", Version: "v1.0.0"},
-		{Path: "example.com/a", Version: "v1.1.0"},
-		{Path: "example.com/noasm", Version: "v2.0.0"},
-		{Path: "example.com/old-match", Version: "v3.0.0"},
-		{Path: "example.com/new", Version: "v1.0.0"},
-	}, seen)
-	want := []moduleVersion{
-		{Path: "example.com/a", Version: "v1.1.0"},
-		{Path: "example.com/new", Version: "v1.0.0"},
-	}
-	if !reflect.DeepEqual(pending, want) || skipped != 3 {
-		t.Fatalf("filterPreviouslyScanned() = (%#v, %d), want (%#v, 3)", pending, skipped, want)
-	}
-}
-
-func TestInspectModulesRecordsIndexedVersionWhenLatestFails(t *testing.T) {
-	archive := testModuleZip(t)
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case strings.HasSuffix(r.URL.Path, "/@latest"):
-			_, _ = io.WriteString(w, `{"Version":"v1.1.0"}`)
-		case strings.HasSuffix(r.URL.Path, "/@v/v1.0.0.zip"):
-			serveRangeData(t, w, r, archive)
-		case strings.HasSuffix(r.URL.Path, "/@v/v1.1.0.zip"):
-			http.Error(w, "missing", http.StatusNotFound)
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-	defer server.Close()
-
-	matched, failures, scanned := inspectModules(context.Background(), server.Client(), server.URL, []moduleVersion{
-		{Path: "example.com/lib", Version: "v1.0.0"},
-	}, 1, int64(len(archive))+1)
-	if len(matched) != 0 || len(failures) != 1 {
-		t.Fatalf("inspectModules() matched %d and failed %d modules, want 0 and 1", len(matched), len(failures))
-	}
-	want := []moduleVersion{{Path: "example.com/lib", Version: "v1.0.0"}}
-	if !reflect.DeepEqual(scanned, want) {
-		t.Fatalf("scanned versions = %#v, want %#v", scanned, want)
-	}
-}
-
-func TestInspectModuleZipFindsTargetAssembly(t *testing.T) {
-	var archive bytes.Buffer
-	zw := zip.NewWriter(&archive)
-	for _, name := range []string{
-		"example.com/lib@v1.2.3/hash/hash.go",
-		"example.com/lib@v1.2.3/hash/hash_amd64.s",
-		"example.com/lib@v1.2.3/hash/hash_arm64.s",
-		"example.com/lib@v1.2.3/hash/empty_arm.s",
-		"example.com/lib@v1.2.3/hash/comments_386.s",
-		"example.com/lib@v1.2.3/cpu/cpu.go",
-		"example.com/lib@v1.2.3/cpu/asm.s",
-		"example.com/lib@v1.2.3/testdata/rejected_arm.s",
-		"example.com/lib@v1.2.3/hash/not-go-assembly.S",
-		"example.com/lib@v1.2.3/README.md",
-	} {
-		w, err := zw.Create(name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if strings.Contains(name, "empty_arm.s") {
-			continue
-		}
-		if strings.Contains(name, "comments_386.s") {
-			if _, err := w.Write([]byte("//go:build 386\n\n/* license only */\n")); err != nil {
-				t.Fatal(err)
-			}
-			continue
-		}
-		if _, err := w.Write([]byte("TEXT ·f(SB),0,$0-0\n")); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := zw.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	files, arches, err := inspectModuleZip(archive.Bytes())
-	if err != nil {
-		t.Fatal(err)
-	}
-	wantFiles := []string{"cpu/asm.s", "hash/hash_amd64.s", "hash/hash_arm64.s"}
-	if !reflect.DeepEqual(files, wantFiles) {
-		t.Fatalf("assembly files = %#v, want %#v", files, wantFiles)
-	}
-	wantArches := []string{"amd64", "arm64", "unknown"}
-	if !reflect.DeepEqual(arches, wantArches) {
-		t.Fatalf("architectures = %#v, want %#v", arches, wantArches)
-	}
-}
-
-func TestInferAssemblyArchitecture(t *testing.T) {
-	tests := map[string]string{
-		"foo_386.s":           "386",
-		"foo_amd64.s":         "amd64",
-		"foo_arm.s":           "arm",
-		"foo_arm64.s":         "arm64",
-		"foo_wasm.s":          "wasm",
-		"asm_darwin_x86_gc.s": "unknown",
-	}
-	for name, want := range tests {
-		if got := inferAssemblyArchitecture(name); got != want {
-			t.Errorf("inferAssemblyArchitecture(%q) = %q, want %q", name, got, want)
-		}
-	}
-}
-
-func TestHTTPReaderAtFetchesCentralDirectoryOutsideCachedTail(t *testing.T) {
-	archive := testModuleZip(t)
-	server := newRangeServer(t, archive, nil)
-	defer server.Close()
-
-	reader, size, err := newHTTPReaderAtWithTail(context.Background(), server.Client(), server.URL, int64(len(archive)), 22)
-	if err != nil {
-		t.Fatal(err)
-	}
-	files, arches, err := inspectModuleZipReader(reader, size)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if want := []string{"pkg/asm_amd64.s"}; !reflect.DeepEqual(files, want) {
-		t.Fatalf("assembly files = %#v, want %#v", files, want)
-	}
-	if want := []string{"amd64"}; !reflect.DeepEqual(arches, want) {
-		t.Fatalf("architectures = %#v, want %#v", arches, want)
-	}
-}
-
-func TestHTTPReaderAtRetriesTransientResponses(t *testing.T) {
-	archive := testModuleZip(t)
-	var heads atomic.Int32
-	server := newRangeServer(t, archive, func(w http.ResponseWriter, r *http.Request) bool {
-		if r.Method == http.MethodHead && heads.Add(1) == 1 {
-			http.Error(w, "try again", http.StatusServiceUnavailable)
-			return true
-		}
-		return false
-	})
-	defer server.Close()
-
-	reader, size, err := newHTTPReaderAtWithTail(context.Background(), server.Client(), server.URL, int64(len(archive)), 22)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := inspectModuleZipReader(reader, size); err != nil {
-		t.Fatal(err)
-	}
-	if got := heads.Load(); got != 2 {
-		t.Fatalf("HEAD requests = %d, want 2", got)
-	}
-}
-
-func TestHTTPReaderAtReusesReadAheadForAssemblyEntries(t *testing.T) {
-	var archive bytes.Buffer
-	zw := zip.NewWriter(&archive)
-	for _, name := range []string{
-		"example.com/lib@v1.0.0/pkg/pkg.go",
-		"example.com/lib@v1.0.0/pkg/first_amd64.s",
-		"example.com/lib@v1.0.0/pkg/second_amd64.s",
-	} {
-		w, err := zw.Create(name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := w.Write([]byte("TEXT ·f(SB),0,$0-0\n")); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := zw.Close(); err != nil {
-		t.Fatal(err)
-	}
-
-	var ranges atomic.Int32
-	server := newRangeServer(t, archive.Bytes(), func(_ http.ResponseWriter, r *http.Request) bool {
-		if r.Method == http.MethodGet && r.Header.Get("Range") != "" {
-			ranges.Add(1)
-		}
-		return false
-	})
-	defer server.Close()
-	reader, size, err := newHTTPReaderAtWithTail(context.Background(), server.Client(), server.URL, int64(archive.Len()), 22)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, _, err := inspectModuleZipReader(reader, size); err != nil {
-		t.Fatal(err)
-	}
-	if got := ranges.Load(); got > 2 {
-		t.Fatalf("range requests = %d, want at most 2 (tail plus one read-ahead block)", got)
-	}
-}
-
-func TestReadIndexDoesNotSkipSharedBoundaryTimestamp(t *testing.T) {
-	base := time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC)
-	entries := make([]indexEntry, 2001)
-	for i := range entries {
-		timestamp := base.Add(time.Duration(i) * time.Nanosecond)
-		if i == 2000 {
-			timestamp = entries[1999].Timestamp
-		}
-		entries[i] = indexEntry{Path: fmt.Sprintf("example.com/mod%d", i), Version: "v1.0.0", Timestamp: timestamp}
-	}
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		limit, err := strconv.Atoi(r.URL.Query().Get("limit"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		var since time.Time
-		if raw := r.URL.Query().Get("since"); raw != "" {
-			since, err = time.Parse(time.RFC3339Nano, raw)
-			if err != nil {
-				t.Fatal(err)
-			}
-		}
-		enc := json.NewEncoder(w)
-		n := 0
-		for _, entry := range entries {
-			if entry.Timestamp.Before(since) {
-				continue
-			}
-			if n == limit {
-				break
-			}
-			if err := enc.Encode(entry); err != nil {
-				t.Fatal(err)
-			}
-			n++
-		}
-	}))
-	defer server.Close()
-
-	got, nextSince, err := readIndex(context.Background(), server.Client(), server.URL, "", len(entries))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(got) != len(entries) {
-		t.Fatalf("readIndex() returned %d entries, want %d", len(got), len(entries))
-	}
-	if want := entries[len(entries)-1].Timestamp.Format(time.RFC3339Nano); nextSince != want {
-		t.Fatalf("next since = %q, want %q", nextSince, want)
-	}
-}
-
-func testModuleZip(t *testing.T) []byte {
-	t.Helper()
-	var archive bytes.Buffer
-	zw := zip.NewWriter(&archive)
-	for _, name := range []string{
-		"example.com/lib@v1.0.0/pkg/pkg.go",
-		"example.com/lib@v1.0.0/pkg/asm_amd64.s",
-	} {
-		w, err := zw.Create(name)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if _, err := w.Write([]byte("TEXT ·f(SB),0,$0-0\n")); err != nil {
-			t.Fatal(err)
-		}
-	}
-	if err := zw.Close(); err != nil {
-		t.Fatal(err)
-	}
-	return archive.Bytes()
-}
-
-func newRangeServer(t *testing.T, data []byte, intercept func(http.ResponseWriter, *http.Request) bool) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if intercept != nil && intercept(w, r) {
-			return
-		}
-		serveRangeData(t, w, r, data)
-	}))
-}
-
-func serveRangeData(t *testing.T, w http.ResponseWriter, r *http.Request, data []byte) {
-	t.Helper()
-	if r.Method == http.MethodHead {
-		w.Header().Set("Content-Length", strconv.Itoa(len(data)))
-		return
-	}
-	if r.Method != http.MethodGet {
-		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	rangeHeader := r.Header.Get("Range")
-	if rangeHeader == "" {
-		w.Header().Set("Content-Length", strconv.Itoa(len(data)))
-		_, _ = w.Write(data)
-		return
-	}
-	var start, end int
-	if _, err := fmt.Sscanf(strings.TrimPrefix(rangeHeader, "bytes="), "%d-%d", &start, &end); err != nil || start < 0 || end < start || end >= len(data) {
-		http.Error(w, "bad range", http.StatusRequestedRangeNotSatisfiable)
-		return
-	}
-	w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, len(data)))
-	w.Header().Set("Content-Length", strconv.Itoa(end-start+1))
-	w.WriteHeader(http.StatusPartialContent)
-	_, _ = w.Write(data[start : end+1])
-}
diff --git a/cmd/plan9asmgenregs/main.go b/cmd/plan9asmgenregs/main.go
new file mode 100644
index 000000000..e5a63a8b3
--- /dev/null
+++ b/cmd/plan9asmgenregs/main.go
@@ -0,0 +1,71 @@
+// plan9asmgenregs regenerates the physical ARM64 system-register grammar
+// from the selected Go assembler, without depending on GOROOT at runtime.
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+)
+
+func generateSystemRegisters(source []byte) ([]byte, error) {
+	rows := regexp.MustCompile(`\{"([A-Za-z0-9_]+)", REG_\w+, (0x[0-9a-f]+), ([^}]+)\}`).FindAllSubmatch(source, -1)
+	if len(rows) == 0 {
+		return nil, fmt.Errorf("Go system-register table contains no recognized rows")
+	}
+	if len(rows) != bytes.Count(source, []byte(`{"`)) {
+		return nil, fmt.Errorf("Go system-register table contains unrecognized rows; refusing a partial grammar")
+	}
+	var output bytes.Buffer
+	output.WriteString("// Code generated by plan9asmgenregs from the Go assembler system-register table. DO NOT EDIT.\n\npackage plan9asm\n\n")
+	output.WriteString("var arm64GoSystemRegisters = map[string]arm64SystemRegisterSpec{\n")
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		name := string(row[1])
+		if seen[name] {
+			return nil, fmt.Errorf("duplicate system register %q", name)
+		}
+		seen[name] = true
+		encoding, err := strconv.ParseUint(string(row[2]), 0, 32)
+		if err != nil || encoding&^uint64(0x1fffe0) != 0 || encoding == 0 {
+			return nil, fmt.Errorf("invalid system-register encoding %q", row[2])
+		}
+		flags := strings.ReplaceAll(string(row[3]), " ", "")
+		if flags != "SR_READ" && flags != "SR_WRITE" && flags != "SR_READ|SR_WRITE" {
+			return nil, fmt.Errorf("invalid access flags %q for %s", flags, name)
+		}
+		fmt.Fprintf(&output, "%q: {encoding: %#x, readable: %t, writable: %t},\n",
+			name, (encoding>>5)&0x7fff, strings.Contains(flags, "SR_READ"), strings.Contains(flags, "SR_WRITE"))
+	}
+	output.WriteString("}\n")
+	return format.Source(output.Bytes())
+}
+
+func main() {
+	root := flag.String("goroot", runtime.GOROOT(), "Go toolchain containing the authoritative assembler table")
+	output := flag.String("out", "arm64_sysregs_generated.go", "generated Go source file")
+	flag.Parse()
+	if flag.NArg() != 0 {
+		fmt.Fprintln(os.Stderr, "unexpected positional arguments")
+		os.Exit(2)
+	}
+	source, err := os.ReadFile(filepath.Join(*root, "src", "cmd", "internal", "obj", "arm64", "sysRegEnc.go"))
+	if err == nil {
+		var generated []byte
+		generated, err = generateSystemRegisters(source)
+		if err == nil {
+			err = os.WriteFile(*output, generated, 0o644)
+		}
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
diff --git a/cmd/plan9asmgenregs/main_test.go b/cmd/plan9asmgenregs/main_test.go
new file mode 100644
index 000000000..ddbeddd22
--- /dev/null
+++ b/cmd/plan9asmgenregs/main_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestGenerateSystemRegistersPreservesPhysicalFieldsAndAccess(t *testing.T) {
+	source := []byte(`
+{"MIDR_EL1", REG_MIDR_EL1, 0x180000, SR_READ},
+{"DBGBVR0_EL1", REG_DBGBVR0_EL1, 0x80, SR_READ | SR_WRITE},
+{"OSLAR_EL1", REG_OSLAR_EL1, 0x10080, SR_WRITE},
+`)
+	generated, err := generateSystemRegisters(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, value := range []string{
+		`"MIDR_EL1":   {encoding: 0x4000, readable: true, writable: false}`,
+		`"DBGBVR0_EL1": {encoding: 0x4, readable: true, writable: true}`,
+		`"OSLAR_EL1":  {encoding: 0x804, readable: false, writable: true}`,
+	} {
+		// Formatting alignment is not part of the generator's schema.
+		normalize := func(text string) string { return strings.Join(strings.Fields(text), " ") }
+		if !strings.Contains(normalize(string(generated)), normalize(value)) {
+			t.Fatalf("generated source omitted %s:\n%s", value, generated)
+		}
+	}
+}
+
+func TestGenerateSystemRegistersFailsClosed(t *testing.T) {
+	for _, source := range []string{
+		"not a register table",
+		`{"ZERO", REG_ZERO, 0x0, SR_READ},`,
+		`{"BAD", REG_BAD, 0x100001, SR_READ},`,
+		`{"BAD", REG_BAD, 0x200000, SR_READ},`,
+		`{"BAD", REG_BAD, 0x100080, UNKNOWN},`,
+		`{"DUP", REG_DUP, 0x100080, SR_READ}, {"DUP", REG_DUP, 0x100080, SR_READ},`,
+		`{"VALID", REG_VALID, 0x100080, SR_READ}, {"LOST", REG_LOST, 0xXYZ, SR_READ},`,
+	} {
+		if generated, err := generateSystemRegisters([]byte(source)); err == nil {
+			t.Fatalf("invalid source generated a partial table:\n%s", generated)
+		}
+	}
+}
diff --git a/cmd/plan9asmgooracle/inputs.go b/cmd/plan9asmgooracle/inputs.go
new file mode 100644
index 000000000..7b9ae97bf
--- /dev/null
+++ b/cmd/plan9asmgooracle/inputs.go
@@ -0,0 +1,252 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type fileInput struct {
+	Path, Physical, SHA256, Mode, Modified string
+	Size                                   int64
+	Identity                               map[string]string
+}
+
+type inputIdentity struct {
+	Files             []fileInput
+	Directories       map[string][]string
+	DirectoryIdentity map[string]map[string]string
+	Environment       map[string]string
+	ASM, ASMVersion   string
+}
+
+type inputCommand struct {
+	Argv           []string
+	Started, Ended time.Time
+	Observation    goasmcmd.Observation
+	Failure        string
+}
+
+type inputRecord struct {
+	CaptureComplete bool
+	Failure         string
+	Identity        inputIdentity
+	SelectedSHA256  string
+	Commands        []inputCommand
+}
+
+type inputTransaction struct {
+	snapshot       *gooriginalsrc.Snapshot
+	record         inputRecord
+	corpus, family []byte
+	driver, goroot string
+	environment    []string
+}
+
+// Access time is not an input generation: the read itself can update it. Keep
+// inode, link count, change/write time and physical route where the OS exposes
+// them, together with Snapshot's actual SameFile and complete-byte guards.
+func generation(info os.FileInfo) map[string]string {
+	result := map[string]string{"Mode": info.Mode().String(), "Size": fmt.Sprint(info.Size()),
+		"Modified": info.ModTime().UTC().Format(time.RFC3339Nano)}
+	value := reflect.ValueOf(info.Sys())
+	if value.Kind() == reflect.Pointer && !value.IsNil() {
+		value = value.Elem()
+	}
+	if value.Kind() == reflect.Struct {
+		for _, name := range []string{"Dev", "Ino", "Nlink", "Ctim", "Ctimespec", "FileAttributes", "CreationTime", "LastWriteTime", "FileSizeHigh", "FileSizeLow"} {
+			field := value.FieldByName(name)
+			if field.IsValid() && field.CanInterface() {
+				result[name] = fmt.Sprint(field.Interface())
+			}
+		}
+	}
+	return result
+}
+
+func oracleEnvironment(goroot string) []string {
+	forced := map[string]string{"GOROOT": goroot, "GOTOOLCHAIN": "local", "GOENV": "off",
+		"GOWORK": "off", "GOFLAGS": "", "GOOS": "linux", "GOARCH": "arm64", "GOARM64": "v8.0"}
+	var environment []string
+	for _, assignment := range os.Environ() {
+		key, _, found := strings.Cut(assignment, "=")
+		if found {
+			if _, replaced := forced[key]; !replaced {
+				environment = append(environment, assignment)
+			}
+		}
+	}
+	keys := make([]string, 0, len(forced))
+	for key := range forced {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		environment = append(environment, key+"="+forced[key])
+	}
+	return environment
+}
+
+func (inputs *inputTransaction) command(ctx context.Context, args ...string) ([]byte, error) {
+	stage, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	item := inputCommand{Argv: append([]string{inputs.driver}, args...), Started: time.Now()}
+	observed, err := goasmcmd.Observe(stage, inputs.goroot, inputs.environment, inputs.driver, args...)
+	item.Ended, item.Observation = time.Now(), observed
+	if err == nil && (len(observed.Stderr) != 0 || !observed.Waited || observed.ExitCode != 0) {
+		err = fmt.Errorf("selected Go query is not a quiet completed success: %s", observed.Stderr)
+	}
+	if err != nil {
+		item.Failure = err.Error()
+	}
+	inputs.record.Commands = append(inputs.record.Commands, item)
+	return observed.Stdout, err
+}
+
+func captureInputs(ctx context.Context, opt options) (inputs *inputTransaction, failure error) {
+	inputs = &inputTransaction{snapshot: gooriginalsrc.NewSnapshot(), driver: opt.driver, goroot: opt.goroot}
+	defer func() {
+		if failure != nil {
+			inputs.record.Failure = failure.Error()
+		}
+	}()
+	if ctx == nil || ctx.Err() != nil {
+		return inputs, fmt.Errorf("input transaction requires live context")
+	}
+	for _, name := range []string{opt.cases, opt.families, opt.driver, opt.goroot} {
+		if !filepath.IsAbs(name) {
+			return inputs, fmt.Errorf("original input must be absolute")
+		}
+		physical, err := sourcepath.Resolve(name)
+		if err != nil || physical != name {
+			return inputs, fmt.Errorf("original input path must be canonical and accessible: %s", filepath.Base(name))
+		}
+	}
+	if opt.driver != filepath.Join(opt.goroot, "bin", "go") && opt.driver != filepath.Join(opt.goroot, "bin", "go.exe") {
+		return inputs, fmt.Errorf("selected driver is not this exact SDK's Go")
+	}
+	for _, name := range []string{opt.cases, opt.families} {
+		if _, ok := goasmoracle.ReadSource(name); !ok {
+			return inputs, fmt.Errorf("original corpus/family requires complete eight-MiB physical read")
+		}
+	}
+	inputs.environment = oracleEnvironment(opt.goroot)
+	for _, name := range []string{opt.cases, opt.families, filepath.Join(opt.goroot, "VERSION")} {
+		if err := inputs.snapshot.Retain(name); err != nil {
+			return inputs, err
+		}
+	}
+	if err := inputs.snapshot.RetainTool(opt.driver); err != nil {
+		return inputs, err
+	}
+	for _, name := range []string{opt.goroot, filepath.Dir(opt.driver), filepath.Dir(opt.cases), filepath.Dir(opt.families)} {
+		if err := inputs.snapshot.Directory(name, false); err != nil {
+			return inputs, err
+		}
+	}
+	include := filepath.Join(opt.goroot, "pkg", "include")
+	if err := inputs.snapshot.Directory(include, true); err != nil {
+		return inputs, err
+	}
+	for name, expected := range gostaticstorage.DecoderObjectFormatSourceHashes() {
+		path := filepath.Join(opt.goroot, filepath.FromSlash(name))
+		if err := inputs.snapshot.Retain(path); err != nil {
+			return inputs, err
+		}
+		if inputs.snapshot.View().Hashes[path] != expected {
+			return inputs, fmt.Errorf("selected SDK object schema differs: %s", name)
+		}
+	}
+	for _, name := range []string{"src/cmd/asm/main.go", "src/cmd/asm/internal/flags/flags.go", "src/cmd/internal/obj/objfile.go", "src/cmd/internal/objabi/util.go"} {
+		if err := inputs.snapshot.Retain(filepath.Join(opt.goroot, filepath.FromSlash(name))); err != nil {
+			return inputs, err
+		}
+	}
+	data, err := inputs.command(ctx, "env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOHOSTOS", "GOHOSTARCH", "GOOS", "GOARCH", "GOARM64", "GOTOOLCHAIN", "GOEXPERIMENT")
+	if err != nil {
+		return inputs, err
+	}
+	var environment map[string]string
+	if err := json.Unmarshal(data, &environment); err != nil {
+		return inputs, err
+	}
+	if len(environment) != 10 || environment["GOROOT"] != opt.goroot || !gotoolchain.AuditedGo127(environment["GOVERSION"]) ||
+		environment["GOOS"] != "linux" || environment["GOARCH"] != "arm64" || environment["GOARM64"] != "v8.0" || environment["GOTOOLCHAIN"] != "local" {
+		return inputs, fmt.Errorf("actual selected Go SDK/version/target differs")
+	}
+	version, err := inputs.snapshot.ReadRetained(filepath.Join(opt.goroot, "VERSION"))
+	if err != nil || !strings.HasPrefix(string(version), environment["GOVERSION"]+"\n") {
+		return inputs, fmt.Errorf("original SDK VERSION differs")
+	}
+	asm, err := inputs.command(ctx, "tool", "-n", "asm")
+	if err != nil {
+		return inputs, err
+	}
+	asmPath := strings.TrimSpace(string(asm))
+	if !filepath.IsAbs(asmPath) || strings.TrimSuffix(string(asm), "\n") != asmPath {
+		return inputs, fmt.Errorf("selected lazy ASM route is not exact")
+	}
+	if err := inputs.snapshot.RetainTool(asmPath); err != nil {
+		return inputs, err
+	}
+	if err := inputs.snapshot.Directory(filepath.Dir(asmPath), false); err != nil {
+		return inputs, err
+	}
+	asmVersion, err := inputs.command(ctx, "tool", "asm", "-V=full")
+	if err != nil || string(asmVersion) != "asm version "+environment["GOVERSION"]+"\n" {
+		return inputs, fmt.Errorf("actual ASM version differs: %q: %w", asmVersion, err)
+	}
+	inputs.corpus, err = inputs.snapshot.ReadRetained(opt.cases)
+	if err != nil {
+		return inputs, err
+	}
+	inputs.family, err = inputs.snapshot.ReadRetained(opt.families)
+	if err != nil {
+		return inputs, err
+	}
+	if _, ok := goasmoracle.ReadSource(opt.cases); !ok {
+		return inputs, fmt.Errorf("original corpus exceeds the existing eight-MiB fixture bound")
+	}
+	if _, ok := goasmoracle.ReadSource(opt.families); !ok {
+		return inputs, fmt.Errorf("original family manifest exceeds the existing eight-MiB fixture bound")
+	}
+	if err := inputs.snapshot.Verify(); err != nil {
+		return inputs, err
+	}
+	view := inputs.snapshot.View()
+	identity := inputIdentity{Environment: environment, ASM: asmPath, ASMVersion: string(asmVersion),
+		Directories: make(map[string][]string), DirectoryIdentity: make(map[string]map[string]string)}
+	names := make([]string, 0, len(view.Hashes))
+	for name := range view.Hashes {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		info, err := os.Lstat(name)
+		if err != nil {
+			return inputs, err
+		}
+		identity.Files = append(identity.Files, fileInput{Path: name, Physical: view.Paths[name], SHA256: view.Hashes[name],
+			Size: info.Size(), Mode: info.Mode().String(), Modified: info.ModTime().UTC().Format(time.RFC3339Nano), Identity: generation(info)})
+	}
+	for name, entries := range view.Entries {
+		identity.Directories[name] = append([]string(nil), entries...)
+		identity.DirectoryIdentity[name] = generation(view.Directories[name])
+	}
+	inputs.record.Identity = identity
+	inputs.record.CaptureComplete = true
+	return inputs, nil
+}
diff --git a/cmd/plan9asmgooracle/main.go b/cmd/plan9asmgooracle/main.go
new file mode 100644
index 000000000..492afdba9
--- /dev/null
+++ b/cmd/plan9asmgooracle/main.go
@@ -0,0 +1,274 @@
+// plan9asmgooracle retains strict stock-Go observations of the selected decoder
+// families. Source refusals are distinct from infrastructure/verification errors.
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type options struct {
+	cases, families, driver, goroot, output string
+}
+
+type result struct {
+	Index                                   int
+	CorpusRow, Instruction, Source, Object  string
+	SourceSHA256, ObjectSHA256              string
+	ObjectKind, ObjectTarget, ObjectVersion string
+	ObjectPhysical                          string
+	ObjectIdentity                          map[string]string
+	Argv                                    []string
+	Started, Ended                          time.Time
+	Status                                  string
+	ExitCode, PID, PGID                     int
+	Waited, Attempted, Complete, Reported   bool
+	TimedOut                                bool
+	Stdout, Stderr, Failure                 string
+	guard                                   *gooriginalsrc.Snapshot
+	directory                               os.FileInfo
+}
+
+type report struct {
+	Protocol                                          string
+	Selected, Accepted, Rejected, Failed              int
+	Attempted, Unattempted, TimedOut, ReportFailures  int
+	InventoryComplete, Verified, Passed, InputsStable bool
+	SetupFailure, InputFailure                        string
+	Results                                           []result
+}
+
+var selectedOpcode = regexp.MustCompile(`^([A-Z][A-Z0-9.]*)\s`)
+
+func writeJSON(path string, value any) error {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+	if err != nil {
+		return err
+	}
+	encodeErr := json.NewEncoder(file).Encode(value)
+	return errors.Join(encodeErr, file.Close())
+}
+
+func writeNew(path string, data []byte) error {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+	if err != nil {
+		return err
+	}
+	written, writeErr := file.Write(data)
+	if written != len(data) {
+		writeErr = errors.Join(writeErr, fmt.Errorf("incomplete new file write"))
+	}
+	return errors.Join(writeErr, file.Close())
+}
+
+func instruction(row string) (string, bool) {
+	_, asm, found := strings.Cut(row, "|")
+	asm = strings.TrimSpace(asm)
+	return asm, found && asm != "" && !strings.ContainsAny(asm, "\r\n")
+}
+
+// Preserve the original whole-file selector, including row order/duplicates.
+// There is no sampling, success-only denominator or unsupported-family filter.
+func selectedRows(data, family []byte) []string {
+	names := make(map[string]bool)
+	for _, line := range strings.Split(string(family), "\n") {
+		line = strings.TrimSpace(line)
+		if line != "" && !strings.HasPrefix(line, "#") {
+			names[line] = true
+		}
+	}
+	var rows []string
+	for _, line := range strings.Split(string(data), "\n") {
+		asm, ok := instruction(line)
+		if !ok {
+			continue
+		}
+		match := selectedOpcode.FindStringSubmatch(asm)
+		if match != nil && names[strings.SplitN(match[1], ".", 2)[0]] {
+			rows = append(rows, line)
+		}
+	}
+	return rows
+}
+
+func finalize(value *report, inputStable bool, deadline error) {
+	value.Accepted, value.Rejected, value.Failed = 0, 0, 0
+	value.Attempted, value.Unattempted, value.TimedOut = 0, 0, 0
+	value.InputsStable = inputStable
+	complete := value.SetupFailure == "" && value.Selected > 0 &&
+		len(value.Results) == value.Selected && inputStable && deadline == nil &&
+		value.ReportFailures == 0
+	for _, item := range value.Results {
+		if item.Attempted {
+			value.Attempted++
+		} else {
+			value.Unattempted++
+		}
+		if item.TimedOut {
+			value.TimedOut++
+		}
+		complete = complete && item.Attempted && item.Waited && item.Complete && item.Reported && !item.TimedOut
+		switch item.Status {
+		case "accepted":
+			value.Accepted++
+		case "rejected":
+			value.Rejected++
+		default:
+			value.Failed++
+		}
+	}
+	value.InventoryComplete = complete
+	value.Verified = complete && value.Failed == 0
+	value.Passed = value.Verified && value.Accepted > 0
+	value.Unattempted = value.Selected - value.Attempted
+}
+
+func retainResult(value *report, caseDir string, item result) error {
+	var err error
+	if item.directory == nil {
+		err = fmt.Errorf("case directory never acquired an owned identity")
+	} else {
+		current, statErr := os.Lstat(caseDir)
+		physical, pathErr := sourcepath.Resolve(caseDir)
+		if statErr != nil || pathErr != nil || !current.IsDir() || !os.SameFile(item.directory, current) || physical != caseDir {
+			err = fmt.Errorf("case directory identity changed before report")
+		}
+	}
+	if err == nil {
+		item.Reported = true
+		err = writeJSON(filepath.Join(caseDir, "result.json"), item)
+	}
+	if err != nil {
+		item.Reported = false
+		value.ReportFailures++
+	}
+	value.Results = append(value.Results, item)
+	return err
+}
+
+func execute(ctx context.Context, opt options) (report, error) {
+	value := report{Protocol: "actual_go_arm64_decoder_oracle_v1"}
+	if !filepath.IsAbs(opt.output) {
+		return value, fmt.Errorf("new report directory must be absolute")
+	}
+	if err := os.Mkdir(opt.output, 0700); err != nil {
+		return value, err
+	}
+	inputs, err := captureInputs(ctx, opt)
+	if err != nil {
+		value.SetupFailure = err.Error()
+		return value, errors.Join(err, writeJSON(filepath.Join(opt.output, "before.json"), inputs.record),
+			writeJSON(filepath.Join(opt.output, "report.json"), value))
+	}
+	rows := selectedRows(inputs.corpus, inputs.family)
+	value.Selected = len(rows)
+	inputs.record.SelectedSHA256 = fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(rows, "\n")+"\n")))
+	if len(rows) < 300 {
+		value.SetupFailure = fmt.Sprintf("required-family selection unexpectedly small: %d", len(rows))
+	}
+	var failures []error
+	if err := writeJSON(filepath.Join(opt.output, "before.json"), inputs.record); err != nil {
+		value.ReportFailures++
+		failures = append(failures, err)
+	}
+	// A failed before receipt or incomplete selection cannot start consumers.
+	if value.SetupFailure == "" && len(failures) == 0 {
+		for index, row := range rows {
+			caseDir := filepath.Join(opt.output, fmt.Sprintf("case-%06d", index))
+			item := probe(ctx, caseDir, inputs, index, row)
+			if err := retainResult(&value, caseDir, item); err != nil {
+				failures = append(failures, fmt.Errorf("case %d report: %w", index, err))
+			}
+		}
+	}
+	after, captureErr := captureInputs(ctx, opt)
+	stable := false
+	if captureErr == nil {
+		after.record.SelectedSHA256 = fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(selectedRows(after.corpus, after.family), "\n")+"\n")))
+		stable = inputs.snapshot.Verify() == nil && reflect.DeepEqual(inputs.record.Identity, after.record.Identity) &&
+			inputs.record.SelectedSHA256 == after.record.SelectedSHA256
+		if err := writeJSON(filepath.Join(opt.output, "after.json"), after.record); err != nil {
+			value.ReportFailures++
+			failures = append(failures, err)
+		}
+	} else {
+		value.InputFailure = captureErr.Error()
+		failures = append(failures, captureErr)
+		if err := writeJSON(filepath.Join(opt.output, "after.json"), after.record); err != nil {
+			value.ReportFailures++
+			failures = append(failures, err)
+		}
+	}
+	if !stable {
+		value.InputFailure = strings.TrimSpace(value.InputFailure + " original corpus/SDK/selected tool inputs changed or could not be reobserved")
+		failures = append(failures, fmt.Errorf("%s", value.InputFailure))
+	}
+	for _, item := range value.Results {
+		if item.guard != nil && item.guard.Verify() != nil {
+			stable = false
+			value.InputFailure = strings.TrimSpace(value.InputFailure + fmt.Sprintf(" case %d original source/object changed", item.Index))
+			failures = append(failures, fmt.Errorf("case %d original source/object changed", item.Index))
+		}
+	}
+	var accepted []string
+	for _, item := range value.Results {
+		if item.Status == "accepted" {
+			accepted = append(accepted, item.CorpusRow)
+		}
+	}
+	if err := writeNew(filepath.Join(opt.output, "accepted.txt"), []byte(strings.Join(accepted, "\n")+"\n")); err != nil {
+		value.ReportFailures++
+		failures = append(failures, err)
+	}
+	finalize(&value, stable, ctx.Err())
+	if err := writeJSON(filepath.Join(opt.output, "report.json"), value); err != nil {
+		value.ReportFailures++
+		value.InventoryComplete, value.Verified, value.Passed = false, false, false
+		failures = append(failures, err)
+	}
+	if !value.Passed {
+		failures = append(failures, fmt.Errorf("oracle incomplete or failed: selected=%d accepted=%d rejected=%d failed=%d unattempted=%d timed_out=%d report_failures=%d",
+			value.Selected, value.Accepted, value.Rejected, value.Failed, value.Unattempted, value.TimedOut, value.ReportFailures))
+	}
+	return value, errors.Join(append(failures, ctx.Err())...)
+}
+
+func run() error {
+	var opt options
+	flag.StringVar(&opt.cases, "cases", "", "complete exact decoder corpus")
+	flag.StringVar(&opt.families, "families", "", "complete required-family manifest")
+	flag.StringVar(&opt.driver, "go", "", "explicit original stock-Go driver")
+	flag.StringVar(&opt.goroot, "goroot", "", "explicit original SDK")
+	flag.StringVar(&opt.output, "out", "", "new retained report directory")
+	flag.Parse()
+	if flag.NArg() != 0 || opt.cases == "" || opt.families == "" || opt.driver == "" || opt.goroot == "" || opt.output == "" {
+		return fmt.Errorf("all five exact inputs are required, without positional arguments")
+	}
+	// The setup, every child and final reobservation share this original bound.
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Minute)
+	defer cancel()
+	value, err := execute(ctx, opt)
+	fmt.Printf("x/arch required families: selected=%d native_go_accepted=%d decoder_only_rejected=%d failed=%d inventory_complete=%t verified=%t passed=%t\n",
+		value.Selected, value.Accepted, value.Rejected, value.Failed, value.InventoryComplete, value.Verified, value.Passed)
+	return err
+}
+
+func main() {
+	if err := run(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
diff --git a/cmd/plan9asmgooracle/main_test.go b/cmd/plan9asmgooracle/main_test.go
new file mode 100644
index 000000000..36f9f10b9
--- /dev/null
+++ b/cmd/plan9asmgooracle/main_test.go
@@ -0,0 +1,189 @@
+package main
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestMain(m *testing.M) {
+	mode := os.Getenv("GO_ORACLE_CONTROL")
+	if mode == "" {
+		os.Exit(m.Run())
+	}
+	source, object := os.Args[len(os.Args)-1], os.Args[len(os.Args)-2]
+	switch mode {
+	case "exit1":
+		os.Exit(1)
+	case "exit2":
+		os.Exit(2)
+	case "footer":
+		fmt.Fprintln(os.Stderr, "asm: assembly failed")
+	case "foreign":
+		fmt.Fprintln(os.Stderr, "foreign.s:3: bad operand")
+	case "foreign-prefix":
+		fmt.Fprintln(os.Stderr, "foreign"+source+":3: bad operand")
+	case "wrong-listing":
+		fmt.Fprintln(os.Stderr, "asm: illegal combination: 00000 ("+source+":3) MOVK $65537,R0")
+	case "bad-PC":
+		fmt.Fprintln(os.Stderr, "asm: illegal combination: 000000 ("+source+":3) MOVD R0,R1")
+	case "panic":
+		fmt.Fprintln(os.Stderr, source+":3: bad operand\npanic: compiler bug")
+	case "line":
+		fmt.Fprintln(os.Stderr, source+":9999: bad operand")
+	case "column":
+		fmt.Fprintln(os.Stderr, source+":3:9999: bad operand")
+	case "header":
+		fmt.Fprintln(os.Stderr, source+":1: bad operand")
+	case "blank":
+		fmt.Fprintln(os.Stderr, source+":5: bad operand")
+	case "split":
+		fmt.Fprint(os.Stdout, source+":3:")
+		fmt.Fprintln(os.Stderr, " bad operand")
+	case "missing-object":
+		os.Exit(0)
+	case "empty-object":
+		_ = os.WriteFile(object, nil, 0600)
+		os.Exit(0)
+	case "directory-object":
+		_ = os.Mkdir(object, 0700)
+		os.Exit(0)
+	case "wrong-kind":
+		_ = os.WriteFile(object, []byte("not a Go object"), 0600)
+		os.Exit(0)
+	case "stale-object":
+		data, err := base64.StdEncoding.DecodeString(os.Getenv("GO_ORACLE_OLD_OBJECT"))
+		if err != nil {
+			os.Exit(2)
+		}
+		if err := os.WriteFile(object, data, 0600); err != nil {
+			os.Exit(2)
+		}
+		os.Exit(0)
+	case "timeout":
+		time.Sleep(time.Minute)
+	default:
+		os.Exit(2)
+	}
+	os.Exit(1)
+}
+
+func canonicalTemp(t *testing.T) string {
+	t.Helper()
+	path, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func actualInputs(t *testing.T) (*inputTransaction, options) {
+	t.Helper()
+	dir := canonicalTemp(t)
+	cases, families := filepath.Join(dir, "cases.txt"), filepath.Join(dir, "families.txt")
+	for name, data := range map[string]string{cases: "00000000 | MOVD R0,R1\n", families: "MOVD\n"} {
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	root, err := filepath.EvalSymlinks(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := filepath.Join(root, "bin", "go")
+	if runtime.GOOS == "windows" {
+		driver += ".exe"
+	}
+	opt := options{cases: cases, families: families, driver: driver, goroot: root}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	inputs, err := captureInputs(ctx, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, command := range inputs.record.Commands {
+		data, _ := json.Marshal(command.Observation)
+		t.Logf("ORACLE_CHILD %s", data)
+	}
+	return inputs, opt
+}
+
+func logProbe(t *testing.T, value result) {
+	t.Helper()
+	data, _ := json.Marshal(value)
+	t.Logf("ORACLE_CASE %s", data)
+}
+
+func TestReportCompletenessIsNotCounting(t *testing.T) {
+	item := result{Status: "accepted", Attempted: true, Waited: true, Complete: true, Reported: true}
+	for _, test := range []struct {
+		name     string
+		edit     func(*report)
+		stable   bool
+		deadline error
+		want     bool
+	}{
+		{"complete", func(_ *report) {}, true, nil, true},
+		{"global-change", func(_ *report) {}, false, nil, false},
+		{"case-report", func(r *report) { r.ReportFailures = 1; r.Results[0].Reported = false }, true, nil, false},
+		{"unattempted", func(r *report) { r.Results[0].Attempted = false }, true, nil, false},
+		{"unwaited", func(r *report) { r.Results[0].Waited = false }, true, nil, false},
+		{"unclosed", func(r *report) { r.Results[0].Complete = false }, true, nil, false},
+		{"timeout", func(r *report) { r.Results[0].TimedOut = true }, true, context.DeadlineExceeded, false},
+		{"unrecorded", func(r *report) { r.Results = nil }, true, nil, false},
+		{"failed", func(r *report) { r.Results[0].Status = "failed" }, true, nil, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			r := report{Selected: 1, Results: []result{item}}
+			test.edit(&r)
+			finalize(&r, test.stable, test.deadline)
+			if r.Passed != test.want || r.Verified != test.want {
+				t.Fatalf("false report pass: %+v", r)
+			}
+			if r.Unattempted != 1-r.Attempted {
+				t.Fatal("missing/unattempted denominator lost")
+			}
+		})
+	}
+	dir := canonicalTemp(t)
+	if err := os.Mkdir(filepath.Join(dir, "result.json"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	r := report{Selected: 1}
+	item.directory, _ = os.Lstat(dir)
+	if retainResult(&r, dir, item) == nil {
+		t.Fatal("actual case report write did not fail")
+	}
+	finalize(&r, true, nil)
+	if r.InventoryComplete || r.Passed || r.ReportFailures != 1 {
+		t.Fatalf("write failure became complete: %+v", r)
+	}
+}
+
+func TestWholeFamilySelectorPreservesRows(t *testing.T) {
+	rows := []string{"000 | MOVD R0,R1", "000 | MOVD R0,R1", "001 | MOVD.P R0,8(R1)", "002 | ADD $1,R0", "not a row", "003 | RET"}
+	want := rows[:3]
+	if got := selectedRows([]byte(strings.Join(rows, "\n")), []byte("# source families\nMOVD\n")); !reflect.DeepEqual(got, want) {
+		t.Fatalf("complete selection changed row order/denominator: %q", got)
+	}
+}
+
+func TestRetainResultRefusesUnownedCaseDirectory(t *testing.T) {
+	dir := canonicalTemp(t)
+	r := report{Selected: 1}
+	item := result{Status: "failed", Failure: "case directory never acquired"}
+	if retainResult(&r, dir, item) == nil {
+		t.Fatal("result written into a directory without the case's owned identity")
+	}
+	if _, err := os.Lstat(filepath.Join(dir, "result.json")); !os.IsNotExist(err) {
+		t.Fatalf("unowned result target was accessed/written: %v", err)
+	}
+}
diff --git a/cmd/plan9asmgooracle/probe.go b/cmd/plan9asmgooracle/probe.go
new file mode 100644
index 000000000..214b7bbda
--- /dev/null
+++ b/cmd/plan9asmgooracle/probe.go
@@ -0,0 +1,138 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func probe(ctx context.Context, dir string, inputs *inputTransaction, index int, row string) result {
+	item := result{Index: index, CorpusRow: row, Status: "failed", ExitCode: -1}
+	asm, ok := instruction(row)
+	item.Instruction = asm
+	fail := func(err error) result { item.Failure = err.Error(); return item }
+	if !ok {
+		return fail(fmt.Errorf("invalid selected original row"))
+	}
+	if err := os.Mkdir(dir, 0700); err != nil {
+		return fail(err)
+	}
+	physical, err := sourcepath.Resolve(dir)
+	if err != nil || physical != dir {
+		return fail(fmt.Errorf("owned case directory was redirected"))
+	}
+	directory, err := os.Lstat(dir)
+	if err != nil || !directory.IsDir() {
+		return fail(fmt.Errorf("owned case directory is missing: %v", err))
+	}
+	item.directory = directory
+	item.Source, item.Object = filepath.Join(dir, "probe.s"), filepath.Join(dir, "probe.o")
+	source := []byte(fmt.Sprintf("#include \"textflag.h\"\nTEXT ·probe%d(SB),NOSPLIT,$0-0\n\t%s\n\tRET\n", index, asm))
+	if err := writeNew(item.Source, source); err != nil {
+		return fail(err)
+	}
+	guard := gooriginalsrc.NewSnapshot()
+	item.guard = guard
+	if err := guard.Retain(item.Source); err != nil {
+		return fail(err)
+	}
+	before, err := os.Lstat(item.Source)
+	if err != nil {
+		return fail(err)
+	}
+	initial, valid := goasmoracle.ReadSource(item.Source)
+	if !valid || !bytes.Equal(initial, source) {
+		return fail(fmt.Errorf("created exact fixture changed"))
+	}
+	if _, err := os.Lstat(item.Object); !errors.Is(err, os.ErrNotExist) {
+		return fail(fmt.Errorf("current case object already exists or is inaccessible: %v", err))
+	}
+	item.SourceSHA256 = fmt.Sprintf("%x", sha256.Sum256(source))
+	item.Argv = []string{inputs.driver, "tool", "asm", "-I", filepath.Join(inputs.goroot, "pkg", "include"), "-o", item.Object, item.Source}
+	stage, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	item.Started = time.Now()
+	observed, commandErr := goasmcmd.Observe(stage, dir, inputs.environment, inputs.driver, item.Argv[1:]...)
+	item.Ended = time.Now()
+	item.PID, item.PGID, item.Waited, item.ExitCode = observed.PID, observed.PGID, observed.Waited, observed.ExitCode
+	item.Attempted = observed.PID > 0
+	item.Stdout, item.Stderr = string(observed.Stdout), string(observed.Stderr)
+	item.TimedOut = errors.Is(stage.Err(), context.DeadlineExceeded)
+	item.Complete = item.Attempted && item.Waited && stage.Err() == nil
+	if commandErr != nil {
+		// A joined cleanup/pipe failure never becomes a completed source exit.
+		if _, direct := commandErr.(*exec.ExitError); !direct {
+			item.Complete = false
+		}
+	}
+	endedSource, valid := goasmoracle.ReadSource(item.Source)
+	after, sourceErr := os.Lstat(item.Source)
+	endedDirectory, directoryErr := os.Lstat(dir)
+	endedPhysical, physicalErr := sourcepath.Resolve(dir)
+	if !valid || sourceErr != nil || guard.Verify() != nil || !os.SameFile(before, after) ||
+		!reflect.DeepEqual(generation(before), generation(after)) || !bytes.Equal(endedSource, source) ||
+		directoryErr != nil || !os.SameFile(directory, endedDirectory) || physicalErr != nil || endedPhysical != dir {
+		return fail(fmt.Errorf("actual case source/directory changed"))
+	}
+	entries, _, err := gooriginalsrc.ReadDirectory(dir, 2)
+	if err != nil {
+		return fail(err)
+	}
+	for _, entry := range entries {
+		if !entry.Type().IsRegular() || entry.Name() != "probe.s" && entry.Name() != "probe.o" {
+			return fail(fmt.Errorf("foreign/nonregular case member: %s", entry.Name()))
+		}
+	}
+	if err := goasmoracle.CheckOutcome(item.Source, item.Object, observed.Stdout, observed.Stderr,
+		commandErr, stage.Err(), commandErr == nil, 3, nil); err != nil {
+		return fail(err)
+	}
+	if commandErr == nil {
+		// No -S was requested. Success output cannot silently become a listing.
+		if len(observed.Stdout) != 0 || len(observed.Stderr) != 0 {
+			return fail(fmt.Errorf("unexpected successful Go assembler diagnostics"))
+		}
+		object, ok := goasmoracle.ReadSource(item.Object)
+		if !ok {
+			return fail(fmt.Errorf("complete fresh object observation failed"))
+		}
+		if err := gostaticstorage.ObserveDecoderARM64Object(object, fmt.Sprintf("<unlinkable>.probe%d", index)); err != nil {
+			return fail(fmt.Errorf("actual Go object kind/target/version/probe differs: %w", err))
+		}
+		if err := guard.Retain(item.Object); err != nil {
+			return fail(err)
+		}
+		retained, err := guard.ReadRetained(item.Object)
+		if err != nil || !bytes.Equal(retained, object) || guard.Verify() != nil {
+			return fail(fmt.Errorf("actual new object changed during structural observation: %v", err))
+		}
+		objectInfo, err := os.Lstat(item.Object)
+		if err != nil {
+			return fail(err)
+		}
+		item.ObjectKind, item.ObjectTarget, item.ObjectVersion = "GoAssemblyUnlinkable", "linux/arm64", inputs.record.Identity.Environment["GOVERSION"]
+		if err := gostaticstorage.ValidateObjectVersion(object, item.ObjectTarget, item.ObjectVersion); err != nil {
+			return fail(err)
+		}
+		item.ObjectPhysical = guard.View().Paths[item.Object]
+		item.ObjectIdentity = generation(objectInfo)
+		item.ObjectSHA256 = fmt.Sprintf("%x", sha256.Sum256(object))
+		item.Status = "accepted"
+	} else {
+		item.Status = "rejected"
+	}
+	return item
+}
diff --git a/cmd/plan9asmgooracle/producer_go127_test.go b/cmd/plan9asmgooracle/producer_go127_test.go
new file mode 100644
index 000000000..0456ed190
--- /dev/null
+++ b/cmd/plan9asmgooracle/producer_go127_test.go
@@ -0,0 +1,109 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"encoding/base64"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestActualGoProbeAndCompleteObjectGuards(t *testing.T) {
+	inputs, _ := actualInputs(t)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	dir := canonicalTemp(t)
+	accepted := probe(ctx, filepath.Join(dir, "case0"), inputs, 0, "00000000 | MOVD R0,R1")
+	logProbe(t, accepted)
+	if accepted.Status != "accepted" || accepted.ExitCode != 0 || !accepted.Complete || accepted.ObjectSHA256 == "" {
+		t.Fatalf("actual Go acceptance failed: %+v", accepted)
+	}
+	rejected := probe(ctx, filepath.Join(dir, "case1"), inputs, 1, "00000000 | MOVD (R0),RSP")
+	logProbe(t, rejected)
+	if rejected.Status != "rejected" || rejected.ExitCode != 1 || !rejected.Complete || !strings.Contains(rejected.Stderr, "probe.s:3") {
+		t.Fatalf("actual exact Go source refusal failed: %+v", rejected)
+	}
+	object, ok := goasmoracle.ReadSource(accepted.Object)
+	if !ok {
+		t.Fatal("actual object missing")
+	}
+	for _, test := range []struct {
+		name string
+		edit func([]byte) []byte
+	}{
+		{"native-bytes", func(_ []byte) []byte { return []byte("ELF native object") }},
+		{"wrong-target", func(data []byte) []byte {
+			return []byte(strings.Replace(string(data), "linux arm64", "linux amd64", 1))
+		}},
+		{"wrong-version", func(data []byte) []byte {
+			return []byte(strings.Replace(string(data), accepted.ObjectVersion, "go1.26.1", 1))
+		}},
+		{"truncated", func(data []byte) []byte { return data[:len(data)-1] }},
+		{"extra-EOF", func(data []byte) []byte { return append(data, 0) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if gostaticstorage.ObserveDecoderARM64Object(test.edit(append([]byte(nil), object...)), "<unlinkable>.probe0") == nil {
+				t.Fatal("invalid original object kind/target/version/EOF accepted")
+			}
+		})
+	}
+	if gostaticstorage.ObserveDecoderARM64Object(object, "<unlinkable>.probe1") == nil {
+		t.Fatal("old probe TEXT borrowed by another case")
+	}
+	// Controlled tools are only infrastructure counterexamples, never source
+	// rejection certificates. The real Go object is retained for the stale case.
+	inputs.driver = os.Args[0]
+	inputs.environment = append(inputs.environment, "GO_ORACLE_OLD_OBJECT="+base64.StdEncoding.EncodeToString(object))
+	for _, mode := range []string{"exit1", "exit2", "footer", "foreign", "foreign-prefix", "wrong-listing", "bad-PC", "panic", "line", "column", "header", "blank", "split", "missing-object", "empty-object", "directory-object", "wrong-kind", "stale-object", "timeout"} {
+		t.Run(mode, func(t *testing.T) {
+			local := *inputs
+			local.environment = append(append([]string(nil), inputs.environment...), "GO_ORACLE_CONTROL="+mode)
+			stage, cancel := context.WithTimeout(ctx, 5*time.Second)
+			if mode == "timeout" {
+				cancel()
+				stage, cancel = context.WithTimeout(ctx, 100*time.Millisecond)
+			}
+			defer cancel()
+			item := probe(stage, filepath.Join(dir, mode), &local, 2, "00000000 | MOVD R0,R1")
+			logProbe(t, item)
+			if item.Status != "failed" || item.Failure == "" {
+				t.Fatalf("infrastructure became a source observation: %+v", item)
+			}
+			if mode == "timeout" && (!item.TimedOut || item.Complete) {
+				t.Fatal("timeout counted complete")
+			}
+		})
+	}
+}
+
+func TestInputTransactionAndTrustedDriverGuards(t *testing.T) {
+	inputs, opt := actualInputs(t)
+	if err := inputs.snapshot.Verify(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(opt.families, []byte("MOVK\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if inputs.snapshot.Verify() == nil {
+		t.Fatal("changed complete family input retained authority")
+	}
+	opt.driver = os.Args[0]
+	if _, err := captureInputs(context.Background(), opt); err == nil {
+		t.Fatal("test driver minted trusted Go role")
+	}
+	opt.driver = filepath.Join(opt.goroot, "bin", "go")
+	opt.cases = filepath.Join(filepath.Dir(opt.cases), "alias")
+	if err := os.Symlink(filepath.Join(filepath.Dir(opt.cases), "cases.txt"), opt.cases); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := captureInputs(context.Background(), opt); err == nil {
+		t.Fatal("uncaptured source alias accepted")
+	}
+}
diff --git a/cmd/plan9asmll/.gitignore b/cmd/plan9asmll/.gitignore
index c4fff0229..8c8b20a50 100644
--- a/cmd/plan9asmll/.gitignore
+++ b/cmd/plan9asmll/.gitignore
@@ -1 +1,2 @@
 _out/
+plan9asmll
diff --git a/cmd/plan9asmll/abi0_text_padding_test.go b/cmd/plan9asmll/abi0_text_padding_test.go
new file mode 100644
index 000000000..87194f335
--- /dev/null
+++ b/cmd/plan9asmll/abi0_text_padding_test.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+	"fmt"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestValidateDeclaredTextArgSizesAcceptsOnlyABI0TailPadding(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		for _, size := range []int64{0, 1, 4, 8, 12, 17, 28} {
+			word := int64(wordSize(arch))
+			padded := alignOff(size, word)
+			for _, declared := range []int64{size, padded, padded + 1, padded + word} {
+				t.Run(fmt.Sprintf("%s/%d/%d", arch, size, declared), func(t *testing.T) {
+					file := &plan9asm.File{Funcs: []plan9asm.Func{{
+						Sym: "·Value", ArgSize: declared,
+						Instrs: []plan9asm.Instr{{Op: plan9asm.OpTEXT,
+							Raw: fmt.Sprintf("TEXT ·Value(SB),$0-%d", declared)}},
+					}}}
+					resolve := func(string) string { return "example.com/padded.Value" }
+					err := validateDeclaredTextArgSizes(file, resolve,
+						map[string]int64{"example.com/padded.Value": size}, arch)
+					wantErr := declared != size && declared != padded
+					if (err != nil) != wantErr {
+						t.Fatalf("logical=%d, ABI0=%d, TEXT=%d: %v", size, padded, declared, err)
+					}
+				})
+			}
+		}
+	}
+	for _, test := range []struct{ symbol, arch string }{
+		{"·Value<ABIInternal>", "arm64"},
+		{"·Value", "unknown"},
+	} {
+		file := &plan9asm.File{Funcs: []plan9asm.Func{{
+			Sym: test.symbol, ArgSize: 16,
+			Instrs: []plan9asm.Instr{{Op: plan9asm.OpTEXT, Raw: "TEXT " + test.symbol + "(SB),$0-16"}},
+		}}}
+		resolve := func(string) string { return "example.com/padded.Value" }
+		if err := validateDeclaredTextArgSizes(file, resolve,
+			map[string]int64{"example.com/padded.Value": 12}, test.arch); err == nil {
+			t.Fatalf("invented an ABI0 alignment contract for %s/%s", test.arch, test.symbol)
+		}
+	}
+}
+
+func paddedSqrtPackage(t *testing.T, name string) *packages.Package {
+	t.Helper()
+	path := "example.com/padded"
+	pkg := types.NewPackage(path, "padded")
+	param := types.NewParam(token.NoPos, pkg, "x", types.Typ[types.Float32])
+	result := types.NewParam(token.NoPos, pkg, "r", types.Typ[types.Float32])
+	sig := types.NewSignatureType(nil, nil, nil, types.NewTuple(param), types.NewTuple(result), false)
+	pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, name, sig))
+	return &packages.Package{PkgPath: path, Types: pkg, Imports: map[string]*packages.Package{}}
+}
+
+func TestCompileOnePaddedSqrtUsesOriginalExternalTEXT(t *testing.T) {
+	cfg, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// These are the original TEXT spelling, input offset and result offset of
+	// barnex/fmath.Sqrtf and chran554/go3d/fmath.Sqrt, including the +0 symbol.
+	for _, name := range []string{"Sqrtf", "Sqrt"} {
+		pkg := paddedSqrtPackage(t, name)
+		for _, target := range []struct{ os, triple string }{
+			{"linux", "x86_64-unknown-linux-gnu"},
+			{"darwin", "x86_64-apple-darwin"},
+			{"windows", "x86_64-pc-windows-msvc"},
+		} {
+			t.Run(name+"/"+target.os, func(t *testing.T) {
+				dir := t.TempDir()
+				asm := filepath.Join(dir, "sqrt_amd64.s")
+				source := fmt.Sprintf("TEXT ·%s+0(SB),$0-16\nSQRTSS x+0(FP),X0\nMOVSS X0,r+8(FP)\nRET\n", name)
+				if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				out := filepath.Join(dir, "sqrt.ll")
+				err := compileOne(pkg, plan9asm.ArchAMD64, target.os, "amd64", target.triple,
+					asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out}, false, cfg)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir, err := os.ReadFile(out)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(string(ir), `asm sideeffect "sqrtss $2, $0"`) {
+					t.Fatalf("missing original f32 square root:\n%s", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestCompileOnePaddedSqrtDoesNotPermitUndeclaredFPBytes(t *testing.T) {
+	pkg := paddedSqrtPackage(t, "Sqrt")
+	for _, test := range []struct{ name, body string }{
+		{"input padding", "SQRTSS x+4(FP),X0\nMOVSS X0,r+8(FP)"},
+		{"wrong result offset", "SQRTSS x+0(FP),X0\nMOVSS X0,r+4(FP)"},
+		{"tail padding", "SQRTSS x+0(FP),X0\nMOVSS X0,r+12(FP)"},
+		{"tail padding address", "SQRTSS x+0(FP),X0\nLEAQ r+12(FP),AX\nMOVSS X0,r+8(FP)"},
+		{"wide read", "SQRTSD x+0(FP),X0\nMOVSS X0,r+8(FP)"},
+		{"wide write", "SQRTSS x+0(FP),X0\nMOVSD X0,r+8(FP)"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			asm := filepath.Join(dir, "sqrt_amd64.s")
+			source := "TEXT ·Sqrt+0(SB),$0-16\n" + test.body + "\nRET\n"
+			if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: filepath.Join(dir, "sqrt.ll")}, false, compileConfig{})
+			if err == nil || !strings.Contains(err.Error(), "translate:") {
+				t.Fatalf("want a translation failure for undeclared FP bytes, got %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/accumulator_sign_extend_extraction_test.go b/cmd/plan9asmll/accumulator_sign_extend_extraction_test.go
new file mode 100644
index 000000000..d6f26c6f8
--- /dev/null
+++ b/cmd/plan9asmll/accumulator_sign_extend_extraction_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsAccumulatorSignExtendTypedTable(t *testing.T) {
+	const file = "amd64_accumulator_sign_extend_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", file))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, contents := range map[string][]byte{
+		file:           source,
+		"translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), contents, 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		ops, err := extractSupportedOps(directory, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"CBW", "CWDE", "CDQE", "CWD", "CDQ", "CQO"} {
+			if _, found := ops[op]; !found {
+				t.Fatal("isolated typed table lost an accumulator family member", arch, op)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/aes_family_extraction_test.go b/cmd/plan9asmll/aes_family_extraction_test.go
new file mode 100644
index 000000000..ff25c6878
--- /dev/null
+++ b/cmd/plan9asmll/aes_family_extraction_test.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteAESTypedFamily(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_aes_family_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_aes_family_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST", "VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST", "VAESIMC", "VAESKEYGENASSIST"} {
+			if _, known := supported[name]; !known {
+				t.Fatal("typed AES registry extraction omitted", arch, name)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/amd64_direct_tail_state_test.go b/cmd/plan9asmll/amd64_direct_tail_state_test.go
new file mode 100644
index 000000000..e3159bdc2
--- /dev/null
+++ b/cmd/plan9asmll/amd64_direct_tail_state_test.go
@@ -0,0 +1,191 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+)
+
+const amd64DirectTailDeclarations = `package p
+func First(a uint64) uint64
+func Second(a, b uint64) uint64
+`
+
+func amd64DirectTailSource(helper string, entryEffect, helperBody string) string {
+	return fmt.Sprintf(`TEXT ·First<ABIInternal>(SB),NOSPLIT,$0-16
+ MOVQ AX,SI
+ MOVQ $7,DI
+ %s
+ JMP %s<>(SB)
+TEXT ·Second<ABIInternal>(SB),NOSPLIT,$0-24
+ MOVQ AX,SI
+ MOVQ BX,DI
+ %s
+ JMP %s<>(SB)
+TEXT %s<>(SB),NOSPLIT,$0-0
+ %s
+`, entryEffect, helper, entryEffect, helper, helper, helperBody)
+}
+
+func amd64DirectTailIR(t *testing.T, source, api string) (string, error) {
+	t.Helper()
+	return amd64DirectTailDeclaredIR(t, amd64DirectTailDeclarations, source, api)
+}
+
+func amd64DirectTailDeclaredIR(t *testing.T, declarations, source, api string) (string, error) {
+	t.Helper()
+	pkg, _ := continuationPackage(t, declarations, source)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	before, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve}
+	// A private tail node has no independent callable frame. Start this
+	// complete-source fixture from its actual typed roots and terminals; the
+	// translator still proves every helper edge, input and return obligation.
+	sigs, _, needed, err := x86SDKDirectTailDeclarationInventory(plan9asm.GoPackage{
+		Path: pkg.PkgPath, Types: pkg.Types, Syntax: pkg.Syntax,
+	}, file, options)
+	if err == nil && !needed {
+		sigs, _, err = sigsForAsmFile(pkg, file, resolve, "amd64")
+	}
+	if err != nil {
+		return "", err
+	}
+	options.Sigs = sigs
+	defer func() {
+		if !reflect.DeepEqual(file, before) {
+			t.Error("translation changed original TEXT/instruction/operand/Raw identity")
+		}
+	}()
+	if api == "text" {
+		return plan9asm.Translate(file, options)
+	}
+	var module llvm.Module
+	if api == "module" {
+		module, err = plan9asm.TranslateModule(file, options)
+	} else {
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err = plan9asm.TranslateModuleInContext(context, file, options)
+	}
+	if err != nil {
+		return "", err
+	}
+	defer module.Dispose()
+	return module.String(), nil
+}
+
+// Both real ABI0 roots have result storage at +8, but different input widths
+// and argument lists. The private TEXT has no callable parameter signature.
+// This complete source is also the ordinary original-Go execution fixture;
+// unlike an ABIInternal test probe, it needs no -std or SDK namespace override.
+const amd64DirectTailABI0Declarations = `package p
+func First(a uint64) uint64
+func Second(a, b uint32) uint64
+`
+
+const amd64DirectTailABI0Source = `#include "textflag.h"
+TEXT ·First(SB),NOSPLIT,$0-16
+ MOVQ a+0(FP),SI
+ MOVQ $7,DI
+ JMP shared<>(SB)
+TEXT ·Second(SB),NOSPLIT,$0-16
+ MOVL a+0(FP),SI
+ MOVL b+4(FP),DI
+ JMP shared<>(SB)
+TEXT shared<>(SB),NOSPLIT,$0-0
+ MOVQ SI,AX
+ ADDQ DI,AX
+ MOVQ AX,ret+8(FP)
+ RET
+`
+
+func TestAMD64DirectTailWholeSourceABI0DifferentWidthRoots(t *testing.T) {
+	for _, api := range []string{"text", "module", "context"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := amd64DirectTailDeclaredIR(t, amd64DirectTailABI0Declarations, amd64DirectTailABI0Source, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, `call i64 @"example.com/continuations.shared$local"()`) {
+				t.Fatal("First(a)=a+7 / Second(a,b)=uint64(a)+uint64(b) lost SI/DI at a zero-argument helper call")
+			}
+		})
+	}
+}
+
+func TestAMD64DirectTailWholeSourcePreservesTypedState(t *testing.T) {
+	for _, test := range []struct {
+		name, helper, entryEffect, helperBody string
+	}{
+		{"shared_GP", "shared", "NOP", "MOVQ SI,AX\n ADDQ DI,AX\n RET"},
+		{"renamed_GP", "renamedTransport", "NOP", "MOVQ SI,AX\n ADDQ DI,AX\n RET"},
+		{"shared_FLAGS", "flagTransport", "CMPQ SI,DI", "SETEQ AL\n MOVBLZX AL,AX\n RET"},
+		{"shared_vector_and_FLAGS", "laneTransport", "MOVQ SI,X0\n CMPQ SI,DI", "MOVQ X0,AX\n ADCQ DI,AX\n RET"},
+		{"vector_zero_extension", "zeroLane", "MOVL SI,X0", "MOVQ X0,AX\n ADDQ DI,AX\n RET"},
+		{"chain", "head", "NOP", "JMP last<>(SB)\nTEXT last<>(SB),NOSPLIT,$0-0\n MOVQ SI,AX\n ADDQ DI,AX\n RET"},
+		{"diamond", "fork", "CMPQ SI,DI", "JE left\n ADDQ $3,DI\n JMP joined<>(SB)\nleft:\n ADDQ $5,DI\n JMP joined<>(SB)\nTEXT joined<>(SB),NOSPLIT,$0-0\n MOVQ SI,AX\n ADDQ DI,AX\n RET"},
+	} {
+		for _, api := range []string{"text", "module", "context"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				source := amd64DirectTailSource(test.helper, test.entryEffect, test.helperBody)
+				ir, err := amd64DirectTailIR(t, source, api)
+				if err != nil {
+					t.Fatalf("whole typed root/helper state cannot reach RET: %v", err)
+				}
+				// Every helper reads root-written state. A zero-argument call
+				// to a separately initialized helper loses that state; neither
+				// successful parsing nor object compilation repairs the loss.
+				lost := regexp.MustCompile(`call i64 @"[^"\n]+\$local"\(\)`)
+				if call := lost.FindString(ir); call != "" {
+					t.Fatalf("root GP/vector/FLAGS transport is absent: %s; expected First(a)=a+7 and Second(a,b)=a+b for the shared GP body, not fresh helper state", call)
+				}
+			})
+		}
+	}
+}
+
+func TestAMD64DirectTailWholeSourceRejectsUnclosedRoles(t *testing.T) {
+	base := amd64DirectTailSource("shared", "NOP", "MOVQ SI,AX\n ADDQ DI,AX\n RET")
+	for _, test := range []struct{ name, source string }{
+		{"missing", strings.ReplaceAll(base, "JMP shared<>(SB)", "JMP absent<>(SB)")},
+		{"duplicate", base + "TEXT shared<>(SB),NOSPLIT,$0-0\n RET\n"},
+		{"offset", strings.ReplaceAll(base, "JMP shared<>(SB)", "JMP shared<>+1(SB)")},
+		{"CALL", strings.Replace(base, " MOVQ SI,AX", " CALL foreign(SB)\n MOVQ SI,AX", 1)},
+		{"address_escape", strings.Replace(base, " JMP shared<>(SB)", " LEAQ shared<>(SB),CX\n JMP shared<>(SB)", 1)},
+		{"DATA_escape", base + "DATA address<>+0(SB)/8,$shared<>(SB)\nGLOBL address<>(SB),RODATA,$8\n"},
+		{"raw", strings.Replace(base, " MOVQ SI,AX", " BYTE $0x90\n MOVQ SI,AX", 1)},
+		{"SP", strings.Replace(base, " MOVQ SI,AX", " MOVQ SP,AX", 1)},
+		{"frame", strings.Replace(base, "TEXT shared<>(SB),NOSPLIT,$0-0", "TEXT shared<>(SB),NOSPLIT,$8-0", 1)},
+		{"unknown_GP", strings.Replace(base, " MOVQ SI,AX", " MOVQ R15,AX", 1)},
+		{"unknown_FLAGS", strings.Replace(base, " ADDQ DI,AX", " ADCQ DI,AX", 1)},
+		{"unknown_vector", strings.Replace(base, " MOVQ SI,AX", " MOVQ X0,AX", 1)},
+		{"partial_GP", strings.Replace(base, " MOVQ SI,AX", " MOVB $1,R15\n MOVQ R15,AX", 1)},
+		{"unknown_vector_upper", strings.Replace(base, " MOVQ SI,AX", " MOVQ SI,X0\n VEXTRACTI128 $1,Y0,X1\n MOVQ X1,AX", 1)},
+		{"root_join", strings.Replace(base, " MOVQ AX,SI", " CMPQ AX,AX\n JE joined\n MOVQ AX,SI\njoined:", 1)},
+		{"closure_DX", strings.Replace(base, " MOVQ SI,AX", " MOVQ 8(DX),AX", 1)},
+		{"native_g", strings.Replace(base, " MOVQ SI,AX", " MOVQ 8(R14),AX", 1)},
+		{"foreign_ret_frame", strings.Replace(base, "TEXT shared<>(SB),NOSPLIT,$0-0", "TEXT shared<>(SB),NOSPLIT,$0-8", 1)},
+		{"helper_storage_identity", base + "GLOBL shared<>(SB),RODATA,$8\n"},
+		{"combined_budget", strings.Replace(base, " MOVQ SI,AX", strings.Repeat(" NOP\n", 4097)+" MOVQ SI,AX", 1)},
+	} {
+		for _, api := range []string{"text", "module", "context"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				if _, err := amd64DirectTailIR(t, test.source, api); err == nil {
+					t.Fatal("unclosed whole-source tail role acquired state/continuation permission")
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmll/amd64_downloaded_fixed_local_go127_test.go b/cmd/plan9asmll/amd64_downloaded_fixed_local_go127_test.go
new file mode 100644
index 000000000..2c0ffaa4b
--- /dev/null
+++ b/cmd/plan9asmll/amd64_downloaded_fixed_local_go127_test.go
@@ -0,0 +1,351 @@
+//go:build go1.27
+
+package main
+
+import (
+	"debug/elf"
+	"debug/macho"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// The generated file-proxy module is an owned mechanism fixture, not an
+// authenticated external-library pass. Its original cache source stays intact.
+func amd64DownloadedFixedLocalTargetFixture(t *testing.T, goos string, mirror bool) (*featureInput, string, compileConfig) {
+	t.Helper()
+	_, assembly, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	ctx := config.Context
+	input := &featureInput{
+		Protocol: featureInputProtocol,
+		Module:   "example.invalid/fixedlocal", Version: "v1.0.0",
+		SourceRoot: filepath.Dir(assembly),
+		Sources:    make(map[string]string), Headers: make(map[string]string),
+		Directories: make(map[string][]string), AsmFiles: []string{"value_amd64.s"},
+	}
+	for _, name := range []string{"go.mod", "value.go", "value_amd64.s"} {
+		data, err := os.ReadFile(filepath.Join(input.SourceRoot, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256(data)
+		input.Directories["."] = append(input.Directories["."], name)
+		if name != "go.mod" {
+			input.Headers[name] = string(data)
+		}
+	}
+	sort.Strings(input.Directories["."])
+	// The archive request can differ from the module declaration inside its
+	// unchanged go.mod. Download the exact archive before selecting its package.
+	archiveInput := *input
+	if mirror {
+		archiveInput.Module = "example.invalid/archive-fixedlocal"
+	}
+	modeInput := &gotoolprofile.InstrumentationConsumerInput{Original: &archiveInput}
+	invocation, env := instrumentationVersionedFixture(t, ctx, modeInput)
+	input = modeInput.Original
+	input.Module = "example.invalid/fixedlocal"
+	if mirror {
+		// Match the corpus's independent invocation module and real versioned
+		// replacement. The downstream source observer separately loads the cache
+		// CWD as Main=true/Version=""; neither view is relabeled as the other.
+		caller := "module example.invalid/invocation\n\ngo 1.24\n\nrequire " + input.Module + " " + input.Version + "\n" +
+			"replace " + input.Module + " " + input.Version + " => " + input.SourceModule + " " + input.Version + "\n"
+		if err := os.WriteFile(filepath.Join(invocation, "go.mod"), []byte(caller), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	env = featureEnvironment(env, map[string]string{
+		"GOOS": goos, "GOARCH": "amd64", "GO386": "", "GOARM": "", "GOARM64": "", "GOWASM": "",
+	})
+	for _, value := range env {
+		key, value, valid := strings.Cut(value, "=")
+		if !valid {
+			t.Fatal("malformed exact-download fixture environment")
+		}
+		switch key {
+		case "GOPROXY", "GOSUMDB", "GOPATH", "GOMODCACHE", "GOOS", "GOARCH", "GO386", "GOARM", "GOARM64", "GOWASM":
+			t.Setenv(key, value)
+		}
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root, stderr, err := gotoolprofile.RunBounded(ctx, invocation, env, binary, "env", "GOROOT")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual exact-download Go source root: %v; %s", err, stderr)
+	}
+	textflag, err := gotoolprofile.FileSHA256(filepath.Join(strings.TrimSpace(string(root)), "pkg", "include", "textflag.h"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ToolSources = map[string]string{"pkg/include/textflag.h": textflag}
+	input.Observed, err = gotoolprofile.Capture(ctx, binary, t.TempDir(), env,
+		goos+"/amd64", nil, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ID = gotoolprofile.ProfileID(input.Observed)
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, invocation, env, binary,
+		"list", "-export", "-compiled", "-json", "-mod=readonly", input.Module)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual exact-cache original Go export failed: %v\n%s%s", err, stdout, stderr)
+	}
+	t.Logf("ACTUAL_EXACT_CACHE_ORIGINAL_GO_EXPORT\n%s", stdout)
+	for name, expected := range input.Sources {
+		actual, err := gotoolprofile.FileSHA256(filepath.Join(input.SourceRoot, name))
+		if err != nil || actual != expected {
+			t.Fatalf("original cache source changed before CLI: %s: %v", name, err)
+		}
+	}
+	return input, invocation, config
+}
+
+func TestAMD64DownloadedFixedLocalActualProfileCLI(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, mirror := range []bool{false, true} {
+			role := "declared"
+			if mirror {
+				role = "mirror"
+			}
+			t.Run(goos+"/"+role, func(t *testing.T) {
+				testAMD64DownloadedFixedLocalActualProfileCLI(t, goos, mirror)
+			})
+		}
+	}
+}
+
+func testAMD64DownloadedFixedLocalActualProfileCLI(t *testing.T, goos string, mirror bool) {
+	t.Helper()
+	input, invocation, config := amd64DownloadedFixedLocalTargetFixture(t, goos, mirror)
+	t.Chdir(invocation)
+	config.FeaturePath = writeFeatureInput(t, input)
+	output := t.TempDir()
+	report, _, err := runOneTarget(targetSpec{Goos: goos, Goarch: "amd64"},
+		[]string{input.Module}, nil, input.AsmFiles, input.Module, output,
+		false, 0, true, false, true, "", config)
+	if err != nil || report.Success != 1 || report.Failed != 0 || report.NotApplicable != 0 || report.TotalAsm != 1 {
+		t.Fatalf("actual original Go object compiled, but exact downloaded profile CLI has no fixed-local consumer: %v; %#v", err, report)
+	}
+	if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+		t.Fatal(err)
+	}
+	if len(report.FeatureSelection.CPP) != 1 || len(report.FeatureSelection.Outputs) != 1 ||
+		report.FeatureSelection.Outputs[0].IR == "" || report.FeatureSelection.Outputs[0].Object == "" {
+		t.Fatal("exact downloaded CLI omitted its actual CPP/LLVM object consumption")
+	}
+	if len(report.FeatureSelection.Packages) != 1 {
+		t.Fatal("exact downloaded CLI lost its actual package identity")
+	}
+	selected := report.FeatureSelection.Packages[0]
+	role := "module"
+	if mirror {
+		role = "version_replace"
+	}
+	if selected.SourceRole != role || selected.ModulePath != input.Module ||
+		selected.SourceModule != input.SourceModule || selected.ModuleVersion != input.Version ||
+		selected.SourceVersion != input.Version {
+		t.Fatalf("CLI merged archive and declaration identities: %#v", selected)
+	}
+	object := filepath.Join(output, filepath.FromSlash(input.Module), "value_amd64.s.o")
+	data, err := os.ReadFile(object)
+	if err != nil || len(data) == 0 || featureBytesSHA256(data) != report.FeatureSelection.Outputs[0].Object {
+		t.Fatalf("actual LLVM object differs from the consumer proof: %v", err)
+	}
+	if goos == "darwin" {
+		file, err := macho.Open(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if file.Cpu != macho.CpuAmd64 || file.Type != macho.TypeObj || file.Section("__text") == nil || file.Section("__text").Size == 0 {
+			t.Fatal("LLVM object omitted AMD64 Mach-O text")
+		}
+	} else {
+		file, err := elf.Open(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer file.Close()
+		if file.Machine != elf.EM_X86_64 || file.Type != elf.ET_REL || file.Section(".text") == nil || file.Section(".text").Size == 0 {
+			t.Fatal("LLVM object omitted AMD64 ELF text")
+		}
+	}
+	t.Logf("ACTUAL_DOWNLOADED_FIXED_LOCAL_CLI target=%s/amd64 module=%s source=%s@%s object=%s bytes=%d",
+		goos, input.Module, input.SourceModule, input.Version, report.FeatureSelection.Outputs[0].Object, len(data))
+	for name, expected := range input.Sources {
+		actual, err := gotoolprofile.FileSHA256(filepath.Join(input.SourceRoot, name))
+		if err != nil || actual != expected {
+			t.Fatalf("CLI rewrote original cache source: %s: %v", name, err)
+		}
+	}
+}
+
+func TestAMD64DownloadedFixedLocalCLIRejectsUnboundAndChangedIdentity(t *testing.T) {
+	testAMD64DownloadedFixedLocalIdentityControls(t, "linux", false)
+}
+
+func TestAMD64DownloadedFixedLocalMirrorCLIRejectsUnboundAndChangedIdentity(t *testing.T) {
+	testAMD64DownloadedFixedLocalIdentityControls(t, "darwin", true)
+}
+
+func testAMD64DownloadedFixedLocalIdentityControls(t *testing.T, goos string, mirror bool) {
+	t.Helper()
+	roles := []string{
+		"no-explicit-request", "missing-version", "load-identity",
+		"version-in-resolver", "source-module-in-resolver", "source-root-in-resolver", "input-in-resolver",
+	}
+	if mirror {
+		roles = append(roles, "missing-source-module", "false-source-module", "declaration-in-resolver",
+			"replacement-path-in-resolver", "replacement-version-in-resolver", "replacement-role-in-resolver",
+			"source-bytes-in-resolver", "archive-bytes-in-resolver")
+	}
+	target, triple := goos+"/amd64", targetTriple(goos, "amd64")
+	for _, role := range roles {
+		t.Run(role, func(t *testing.T) {
+			input, invocation, config := amd64DownloadedFixedLocalTargetFixture(t, goos, mirror)
+			t.Chdir(invocation)
+			consumer, err := loadFeatureConsumer(config.Context, writeFeatureInput(t, input), t.TempDir(),
+				target, input.Module, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkgs, err := packages.Load(&packages.Config{
+				Context: config.Context, Dir: invocation, Env: consumer.Env,
+				Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+					packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+					packages.NeedTypes | packages.NeedTypesSizes,
+			}, input.Module)
+			if err != nil || len(pkgs) != 1 || len(pkgs[0].Errors) != 0 {
+				t.Fatalf("actual exact-cache CLI load: %v; %+v", err, pkgs)
+			}
+			pkg := pkgs[0]
+			if pkg.Module == nil || pkg.Module.Main || pkg.Module.Version != input.Version ||
+				(pkg.Module.Replace != nil) != mirror {
+				t.Fatal("fixture did not retain its actual exact imported module role")
+			}
+			if err := consumer.capturePackages(pkgs); err != nil {
+				t.Fatal(err)
+			}
+			config.Feature = consumer
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, target, consumer)
+			assembly := filepath.Join(pkg.Dir, "value_amd64.s")
+			data, err := os.ReadFile(assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64,
+				strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+			if err != nil {
+				t.Fatal(err)
+			}
+			calls := 0
+			resolve := func(name string) string {
+				calls++
+				if calls == 1 {
+					switch role {
+					case "version-in-resolver":
+						consumer.Input.Version = "v1.0.1"
+					case "source-module-in-resolver":
+						consumer.Input.SourceModule = "example.invalid/other"
+					case "source-root-in-resolver":
+						consumer.Input.SourceRoot = invocation
+					case "input-in-resolver":
+						copied := *consumer.Input
+						consumer.Input = &copied
+					case "declaration-in-resolver":
+						consumer.Input.Module = input.SourceModule
+					case "replacement-path-in-resolver":
+						pkg.Module.Replace.Path = "example.invalid/other"
+					case "replacement-version-in-resolver":
+						pkg.Module.Replace.Version = "v1.0.1"
+					case "replacement-role-in-resolver":
+						pkg.Module.Replace = nil
+					case "source-bytes-in-resolver":
+						amd64DownloadedFixtureAppend(t, filepath.Join(input.SourceRoot, "value.go"))
+					case "archive-bytes-in-resolver":
+						archive := filepath.Join(os.Getenv("GOMODCACHE"), "cache", "download", input.SourceModule, "@v", input.Version+".zip")
+						amd64DownloadedFixtureAppend(t, archive)
+					}
+				}
+				return strings.Replace(name, "·", pkg.PkgPath+".", 1)
+			}
+			// Signature inference must not trigger the mutating binding callback.
+			sigs, _, err := sigsForAsmFile(pkg, file,
+				func(name string) string { return strings.Replace(name, "·", pkg.PkgPath+".", 1) }, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch role {
+			case "no-explicit-request":
+				config.Feature = nil
+			case "missing-version":
+				consumer.Input.Version = ""
+			case "load-identity":
+				pkg.Module.Version = "v1.0.1"
+			case "missing-source-module":
+				consumer.Input.SourceModule = ""
+			case "false-source-module":
+				consumer.Input.SourceModule = "example.invalid/other"
+			}
+			bound, source, err := prepareAMD64FixedLocalSource(pkg, file, assembly, target,
+				triple, "amd64", config, resolve, sigs, nil)
+			if source != nil {
+				if closeErr := source.close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if err == nil || source != nil || bound != nil {
+				t.Fatalf("unbound/changed %s retained downloaded frame authority: %v", role, err)
+			}
+			t.Logf("EXACT_SOURCE_IDENTITY_REJECTION %s: %v", role, err)
+			want := "fixed-local explicit download identity changed"
+			switch role {
+			case "no-explicit-request", "missing-version":
+				want = "cached external or SDK source cannot acquire an owned-main role"
+			case "load-identity", "replacement-path-in-resolver", "replacement-version-in-resolver", "replacement-role-in-resolver":
+				want = "fixed-local actual-load identity changed"
+			case "missing-source-module", "false-source-module":
+				want = "actual exact module download failed"
+			case "source-bytes-in-resolver", "archive-bytes-in-resolver":
+				want = "changed"
+			}
+			if !strings.Contains(err.Error(), want) {
+				t.Fatalf("identity control failed for an unrelated reason, want %q: %v", want, err)
+			}
+			if !mirror && !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("ordinary missing identity did not retain Context: %v", err)
+			}
+			if strings.HasSuffix(role, "-in-resolver") && calls == 0 {
+				t.Fatal("identity control failed before its actual binding callback")
+			}
+		})
+	}
+}
+
+func amd64DownloadedFixtureAppend(t *testing.T, name string) {
+	t.Helper()
+	data, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(name, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(name, append(data, []byte("\n// changed owned fixture\n")...), 0600); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/cmd/plan9asmll/amd64_fixed_local_private_leaf_go127_test.go b/cmd/plan9asmll/amd64_fixed_local_private_leaf_go127_test.go
new file mode 100644
index 000000000..809851ca8
--- /dev/null
+++ b/cmd/plan9asmll/amd64_fixed_local_private_leaf_go127_test.go
@@ -0,0 +1,123 @@
+//go:build go1.27
+
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+const amd64FixedLocalCLIPrivateLeaf = `TEXT ·Value(SB),4,$80-16
+ MOVQ a+0(FP),AX
+ MOVQ AX,16(SP)
+ LEAQ 16(SP),BP
+ CALL leaf<>(SB)
+ MOVQ AX,ret+8(FP)
+ RET
+TEXT leaf<>(SB),4,$0
+ ADDQ $7,(BP)
+ MOVQ (BP),AX
+ RET
+`
+
+func TestAMD64FixedLocalCapturedSignaturesKeepProducerIdentity(t *testing.T) {
+	plain := plan9asm.FuncSig{Name: "local", Ret: plan9asm.I64}
+	declared := plan9asm.FuncSig{Name: "Value", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.I64}
+	untouched := plan9asm.FuncSig{Name: "other", Ret: plan9asm.Void}
+	sigs := map[string]plan9asm.FuncSig{"local": plain, "Value": declared, "other": untouched}
+	fallbacks := map[string]plan9asm.FuncSig{"local": plain}
+	actual, err := fixedLocalCapturedSignatures(sigs, fallbacks)
+	if err != nil || len(actual) != 2 || !reflect.DeepEqual(actual["Value"], declared) ||
+		!reflect.DeepEqual(actual["other"], untouched) || !reflect.DeepEqual(sigs["local"], plain) {
+		t.Fatal("projection discarded an unrecorded/declared entry or changed its input", err)
+	}
+	for _, row := range []struct {
+		name string
+		sig  plan9asm.FuncSig
+	}{
+		{"name", plan9asm.FuncSig{Name: "changed", Ret: plan9asm.I64}},
+		{"return", plan9asm.FuncSig{Name: "local", Ret: plan9asm.Void}},
+		{"arguments", plan9asm.FuncSig{Name: "local", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.I64}},
+		{"attributes", plan9asm.FuncSig{Name: "local", Ret: plan9asm.I64, Attrs: "nounwind"}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			if result, err := fixedLocalCapturedSignatures(map[string]plan9asm.FuncSig{"local": row.sig}, fallbacks); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || result != nil {
+				t.Fatal("changed automatic entry was silently discarded", err)
+			}
+		})
+	}
+	if result, err := fixedLocalCapturedSignatures(nil, fallbacks); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || result != nil {
+		t.Fatal("missing original automatic entry was silently discarded", err)
+	}
+}
+
+func TestCompileOneAMD64FixedLocalPrivateLeafDeclarations(t *testing.T) {
+	for _, row := range []struct{ name, assembly, declaration string }{
+		{"static", amd64FixedLocalCLIPrivateLeaf, ""},
+		{"bare", strings.ReplaceAll(amd64FixedLocalCLIPrivateLeaf, "leaf<>", "leaf"), ""},
+		// A separate Go implementation with the same base name does not give
+		// the assembly file's static leaf a callable Go declaration.
+		{"static_namespace", amd64FixedLocalCLIPrivateLeaf, "func leaf() uint64 { return 999 }\n"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, input, config := amd64FixedLocalCLISourceFixture(t, row.assembly,
+				"package fixedlocal\nfunc Value(a uint64) uint64\n"+row.declaration)
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, row.assembly)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			fallback, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil || len(file.Funcs) != 2 {
+				t.Fatal("complete original source signature inventory", err)
+			}
+			if _, found := fallback[resolve(file.Funcs[1].Sym)]; !found {
+				t.Fatal("regression fixture no longer exercises CLI fallback signature selection")
+			}
+			output := filepath.Join(t.TempDir(), "complete.ll")
+			if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", targetTriple("linux", "amd64"),
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatal("actual Go accepted the whole source, but its private leaf acquired a fallback ABI", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || strings.Count(string(ir), "define ") != 1 || !strings.Contains(string(ir), "fixed_local_native") {
+				t.Fatal("original framed root did not retain its sole callable definition", err)
+			}
+			if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatal("complete original source has no LLVM 22 object", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneAMD64FixedLocalPrivateLeafDeclarationBoundaries(t *testing.T) {
+	for _, row := range []struct{ name, assembly, declaration string }{
+		{"uninitialized", strings.Replace(amd64FixedLocalCLIPrivateLeaf, "MOVQ AX,16(SP)", "NOP", 1), ""},
+		{"nonzero_helper", strings.Replace(amd64FixedLocalCLIPrivateLeaf, "TEXT leaf<>(SB),4,$0", "TEXT leaf<>(SB),4,$8", 1), ""},
+		{"extra_sibling", amd64FixedLocalCLIPrivateLeaf + "TEXT unused<>(SB),4,$8\n RET\n", ""},
+		{"bare_false_declaration", strings.ReplaceAll(amd64FixedLocalCLIPrivateLeaf, "leaf<>", "leaf"), "func leaf()\n"},
+		{"foreign_namespace", strings.ReplaceAll(amd64FixedLocalCLIPrivateLeaf, "leaf<>", "other·leaf"), "func leaf() uint64 { return 999 }\n"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg, input, config := amd64FixedLocalCLISourceFixture(t, row.assembly,
+				"package fixedlocal\nfunc Value(a uint64) uint64\n"+row.declaration)
+			dir := t.TempDir()
+			output := filepath.Join(dir, "rejected.ll")
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", targetTriple("linux", "amd64"),
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("declaration selection authorized an unclosed original source", err)
+			}
+			artifacts, readErr := os.ReadDir(dir)
+			if readErr != nil || len(artifacts) != 0 {
+				t.Fatal("rejected whole source published an artifact", artifacts, readErr)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/amd64_fixed_local_source.go b/cmd/plan9asmll/amd64_fixed_local_source.go
new file mode 100644
index 000000000..673c16ad7
--- /dev/null
+++ b/cmd/plan9asmll/amd64_fixed_local_source.go
@@ -0,0 +1,334 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+type amd64FixedLocalCLISource struct {
+	observation *gotoolprofile.AMD64OriginalPackageObservation
+	binding     *gotoolprofile.AMD64OriginalFixedLocalBinding
+	sdkFrame    *plan9asm.GoAMD64FrameSource
+	selection   *x86CallerPackageSelection
+	packageData *packages.Package
+	target      string
+	sources     map[string]string
+	downloaded  *amd64FixedLocalDownloadRequest
+}
+
+// This records only the explicit invocation identity. The independent download
+// observer and object factory, not these fields, establish the source role.
+type amd64FixedLocalDownloadRequest struct {
+	consumer                            *featureConsumer
+	input                               *featureInput
+	module, sourceModule, version, root string
+}
+
+func (source *amd64FixedLocalCLISource) verify(ctx context.Context) (result error) {
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.close())
+		}
+	}()
+	if request := source.downloaded; request != nil {
+		input := request.consumer.Input
+		if input != request.input || input.Module != request.module ||
+			input.SourceModule != request.sourceModule || input.Version != request.version ||
+			input.SourceRoot != request.root {
+			return fmt.Errorf("%w: fixed-local explicit download identity changed", plan9asm.ErrProbeNeedsContext)
+		}
+		if err := request.consumer.verifySources(); err != nil {
+			return err
+		}
+	}
+	if err := verifyAMD64FixedLocalSelection(source.packageData, source.selection, source.target); err != nil {
+		return err
+	}
+	for name, expected := range source.sources {
+		actual, err := gotoolprofile.FileSHA256(name)
+		if err != nil || actual != expected {
+			return fmt.Errorf("%w: fixed-local actual compiled Go source changed", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	if source.sdkFrame != nil {
+		return source.sdkFrame.Verify(ctx)
+	}
+	return source.binding.Verify(ctx)
+}
+
+func verifyAMD64FixedLocalSelection(pkg *packages.Package, selected *x86CallerPackageSelection, target string) error {
+	if pkg == nil || selected == nil || !selected.ready || selected.types != pkg.Types ||
+		selected.target != target || pkg.Types == nil || pkg.TypesSizes == nil || pkg.IllTyped || len(pkg.Errors) != 0 ||
+		selected.identity == "" || selected.identity != x86CallerSelectionIdentity(pkg, selected.env) ||
+		!reflect.DeepEqual(selected.sizes, x86CallerSizes(pkg.TypesSizes)) || len(selected.imports) != len(pkg.Imports) {
+		return fmt.Errorf("%w: fixed-local actual-load identity changed", plan9asm.ErrProbeNeedsContext)
+	}
+	for path, dependency := range pkg.Imports {
+		if dependency == nil || dependency.Types == nil || dependency.Types != selected.imports[path] {
+			return fmt.Errorf("%w: fixed-local actual-load dependency types changed", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	return nil
+}
+
+// packages.Load intentionally omits syntax for ordinary packages. Read every
+// actual compiled Go file only for this candidate; the independent root factory
+// typechecks those original bytes against the actual SDK export graph.
+func amd64FixedLocalActualSyntax(ctx context.Context, pkg *packages.Package) ([]*ast.File, map[string]string, error) {
+	if len(pkg.CompiledGoFiles) == 0 || len(pkg.CompiledGoFiles) > 256 {
+		return nil, nil, fmt.Errorf("%w: fixed-local compiled Go inventory is empty or exceeds its bound", plan9asm.ErrProbeNeedsContext)
+	}
+	set, total := token.NewFileSet(), 0
+	var syntax []*ast.File
+	sources := make(map[string]string, len(pkg.CompiledGoFiles))
+	for _, name := range pkg.CompiledGoFiles {
+		if _, duplicate := sources[name]; duplicate {
+			return nil, nil, fmt.Errorf("%w: fixed-local duplicate compiled Go source", plan9asm.ErrProbeNeedsContext)
+		}
+		data, err := x86CallerReadSource(ctx, name, &total)
+		if err != nil {
+			return nil, nil, err
+		}
+		file, err := parser.ParseFile(set, name, data, parser.ParseComments)
+		if err != nil {
+			return nil, nil, err
+		}
+		syntax = append(syntax, file)
+		sources[name] = featureBytesSHA256(data)
+	}
+	return syntax, sources, nil
+}
+
+func (source *amd64FixedLocalCLISource) close() error {
+	if source.sdkFrame != nil {
+		return source.sdkFrame.Close()
+	}
+	return source.observation.Close()
+}
+
+// Fixed-frame owners independently parse the complete canonical Go CPP output.
+// Use that same representation before any signatures or source contracts are
+// built, once per candidate file rather than once per function. This preserves
+// Raw, DATA and labels in the exact fingerprint; it grants no frame permission.
+func parseCompleteCLIAssembly(arch plan9asm.Arch, source string, defines []string, goarch string,
+	pkg *plan9asm.GoPackage,
+) (*plan9asm.File, error) {
+	file, err := plan9asm.ParseWithDefines(arch, source, defines)
+	if err != nil || !plan9asm.GoAMD64FixedLocalFrameBindingNeeded(file, goarch) {
+		return file, err
+	}
+	options := plan9asm.AssemblyPreprocessOptions{Defines: defines}
+	if pkg != nil {
+		// This supplies syntax from the same selected declarations already used
+		// by ExpandGoAssemblySource. It does not qualify generated CPP for a
+		// frame owner: that owner still verifies its actual source and object.
+		options.ReadInclude = func(_ string, name string) (string, []byte, error) {
+			if name != "go_asm.h" {
+				return "", nil, fmt.Errorf("unresolved active assembly include %q", name)
+			}
+			header, err := plan9asm.GoAssemblyHeader(*pkg, goarch)
+			return "generated/" + pkg.Path + "/go_asm.h", header, err
+		}
+	}
+	expanded, err := plan9asm.PreprocessAssemblySource(source, options)
+	if err != nil {
+		return nil, fmt.Errorf("fixed-local complete source CPP: %w", err)
+	}
+	return plan9asm.Parse(arch, expanded)
+}
+
+// This complete-file seam precedes splitting. The source-role query supplies
+// no permission; the existing independently captured object and numeric-only
+// binder must close the full source, source/normalized CFG and every access.
+func prepareAMD64FixedLocalSource(pkg *packages.Package, file *plan9asm.File, asm, target, triple, goarch string,
+	config compileConfig, resolve func(string) string, sigs, registerFallbacks map[string]plan9asm.FuncSig,
+) (_ map[string]plan9asm.FuncSig, _ *amd64FixedLocalCLISource, result error) {
+	// This preliminary role query uses only the CLI's package-name mapping.
+	// The binding callback runs after source capture: calling it here could
+	// mutate an input before the owner records its original identity.
+	var queryResolve func(string) string
+	if pkg != nil {
+		queryResolve = resolveSymFunc(pkg.PkgPath)
+	}
+	if !plan9asm.GoAMD64FixedLocalFrameBindingNeeded(file, goarch, plan9asm.Options{
+		Goarch: goarch, ResolveSym: queryResolve, Sigs: sigs,
+	}) {
+		return sigs, nil, nil
+	}
+	selection := config.x86CallerSelections[pkg]
+	if err := verifyAMD64FixedLocalSelection(pkg, selection, target); err != nil {
+		return nil, nil, err
+	}
+	ctx := config.Context
+	if ctx == nil || ctx.Err() != nil {
+		return nil, nil, fmt.Errorf("%w: fixed-local needs a bounded live compilation context", plan9asm.ErrProbeNeedsContext)
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, nil, fmt.Errorf("%w: fixed-local compilation context is unbounded", plan9asm.ErrProbeNeedsContext)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	dir, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil {
+		return nil, nil, err
+	}
+	actualAsm, err := sourcepath.Resolve(asm)
+	if err != nil || filepath.Dir(actualAsm) != dir {
+		return nil, nil, fmt.Errorf("%w: fixed-local original assembly origin differs", plan9asm.ErrProbeNeedsContext)
+	}
+	// Execute with the actual captured effective environment. Deduplication
+	// follows exec's last-value rule; no flags, CGO, SDK or cache are replaced.
+	values := make(map[string]string)
+	for _, item := range selection.env {
+		key, value, valid := strings.Cut(item, "=")
+		if !valid || key == "" {
+			return nil, nil, fmt.Errorf("malformed actual fixed-local environment")
+		}
+		values[key] = value
+	}
+	var env []string
+	for key, value := range values {
+		env = append(env, key+"="+value)
+	}
+	sort.Strings(env)
+	syntax, sources, err := amd64FixedLocalActualSyntax(ctx, pkg)
+	if err != nil {
+		return nil, nil, err
+	}
+	original := gotoolprofile.AMD64OriginalObservationRequest{
+		GoBinary: binary, Directory: dir, PackagePath: pkg.PkgPath, Target: target, Environment: env,
+	}
+	// This is only dispatch, not authority: the independent SDK factory must
+	// prove the actual compiler's complete physical SDK selection and native
+	// frame/source identity. Never infer an owned-main or caller role from it.
+	sdkDirectory := filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", filepath.FromSlash(pkg.PkgPath))
+	if pkg.Module == nil && dir == sdkDirectory {
+		frame, err := plan9asm.CaptureGoAMD64SDKFrameSource(ctx,
+			plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Syntax: syntax}, plan9asm.GoAMD64FrameCaptureRequest{
+				GoBinary: binary, Directory: dir, AssemblyFile: filepath.Base(actualAsm), Target: target, Environment: env,
+			})
+		if err != nil {
+			return nil, nil, err
+		}
+		defer func() {
+			if result != nil {
+				result = errors.Join(result, frame.Close())
+			}
+		}()
+		sigs, err = fixedLocalCapturedSignatures(sigs, registerFallbacks)
+		if err != nil {
+			return nil, nil, err
+		}
+		bound, err := frame.BindFixedLocal(ctx, plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Syntax: syntax}, file,
+			plan9asm.Options{Goarch: goarch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs})
+		if err != nil {
+			return nil, nil, err
+		}
+		source := &amd64FixedLocalCLISource{sdkFrame: frame, selection: selection, packageData: pkg,
+			target: target, sources: sources}
+		if err := source.verify(ctx); err != nil {
+			return nil, nil, err
+		}
+		return bound.Sigs, source, nil
+	}
+	var observed *gotoolprofile.AMD64OriginalPackageObservation
+	var downloaded *amd64FixedLocalDownloadRequest
+	if consumer := config.Feature; consumer != nil && consumer.Input != nil && consumer.Input.Version != "" {
+		if err := consumer.verifySources(); err != nil {
+			return nil, nil, err
+		}
+		input := consumer.Input
+		downloaded = &amd64FixedLocalDownloadRequest{consumer: consumer, input: input,
+			module: input.Module, sourceModule: input.SourceModule, version: input.Version, root: input.SourceRoot}
+		module := input.SourceModule
+		if module == "" {
+			module = input.Module
+		}
+		observed, err = gotoolprofile.CaptureAMD64DownloadedPackageObservation(ctx,
+			gotoolprofile.AMD64DownloadedObservationRequest{
+				Original: original, SourceModule: module, SourceVersion: input.Version,
+			}, gotoolprofile.RunBounded)
+	} else {
+		// In particular, Main=true and an empty version from a cache CWD do
+		// not create an owned-source role or infer an exact version.
+		observed, err = gotoolprofile.CaptureAMD64OriginalPackageObservation(ctx, original, gotoolprofile.RunBounded)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+	defer func() {
+		if result != nil {
+			if err := observed.Close(); err != nil {
+				result = errors.Join(result, err)
+			}
+		}
+	}()
+	sigs, err = fixedLocalCapturedSignatures(sigs, registerFallbacks)
+	if err != nil {
+		return nil, nil, err
+	}
+	bind := observed.BindFixedLocal
+	if downloaded != nil {
+		bind = observed.BindDownloadedFixedLocal
+	}
+	bound, binding, err := bind(ctx,
+		plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Syntax: syntax}, file, filepath.Base(actualAsm),
+		plan9asm.Options{Goarch: goarch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs})
+	if err != nil {
+		return nil, nil, err
+	}
+	source := &amd64FixedLocalCLISource{
+		observation: observed, binding: binding, selection: selection, packageData: pkg,
+		target: target, sources: sources, downloaded: downloaded,
+	}
+	if err := source.verify(ctx); err != nil {
+		return nil, nil, err
+	}
+	return bound.Sigs, source, nil
+}
+
+// Only after actual source capture may this CLI discard its own unchanged
+// register-only guesses. Actual declarations and every unrecorded signature
+// remain intact; the public binder still rejects supplied private helper ABIs.
+func fixedLocalCapturedSignatures(sigs, registerFallbacks map[string]plan9asm.FuncSig) (map[string]plan9asm.FuncSig, error) {
+	if len(registerFallbacks) == 0 {
+		return sigs, nil
+	}
+	for name, original := range registerFallbacks {
+		current, present := sigs[name]
+		if !present || !reflect.DeepEqual(current, original) {
+			return nil, fmt.Errorf("%w: CLI inferred entry changed before original frame binding", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	declared := make(map[string]plan9asm.FuncSig, len(sigs)-len(registerFallbacks))
+	for name, sig := range sigs {
+		if _, inferred := registerFallbacks[name]; !inferred {
+			declared[name] = sig
+		}
+	}
+	return declared, nil
+}
diff --git a/cmd/plan9asmll/amd64_fixed_local_source_go127_test.go b/cmd/plan9asmll/amd64_fixed_local_source_go127_test.go
new file mode 100644
index 000000000..5896502f6
--- /dev/null
+++ b/cmd/plan9asmll/amd64_fixed_local_source_go127_test.go
@@ -0,0 +1,103 @@
+//go:build go1.27
+
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCompileOneAMD64FixedLocalCompleteCPPSpelling(t *testing.T) {
+	const operation = `#define MIX(src,dst) PADDL src , dst
+retained:
+	MIX(16(SP), X0)
+DATA literal<>+0(SB)/8, $0x1122334455667788
+GLOBL literal<>(SB), RODATA, $8`
+	pkg, input, config := amd64FixedLocalCLIFixture(t, operation)
+	original, err := os.ReadFile(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	output := filepath.Join(t.TempDir(), "complete-cpp.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatalf("actual Go accepted complete macro/label/DATA source but CLI changed its parsed identity: %v", err)
+	}
+	ir, err := os.ReadFile(output)
+	if err != nil || !strings.Contains(string(ir), "fixed_local_native") || !strings.Contains(string(ir), "literal") {
+		t.Fatalf("complete source lost its fixed frame or original DATA: %v", err)
+	}
+	if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || info.Size() == 0 {
+		t.Fatalf("LLVM 22 original-source object absent: %v", err)
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || string(after) != string(original) {
+		t.Fatal("CLI cropped or rewrote the complete original input", err)
+	}
+
+	// A canonical spelling is not permission to replace the complete input.
+	// Keep the actual owner and reject caller-side instruction/DATA mutations.
+	read, err := readAsmSource(input, pkg.Module.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, string(read), plan9asm.GoAssemblerDefines("linux", "amd64"), "amd64", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFileWithDeclarations(pkg, file, resolve, "amd64", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, owner, err := prepareAMD64FixedLocalSource(pkg, file, input, "linux/amd64", "x86_64-unknown-linux-gnu",
+		"amd64", config, resolve, sigs, nil)
+	if err != nil || owner == nil {
+		t.Fatal("complete unchanged source did not retain its actual owner", err)
+	}
+	defer func() {
+		if err := owner.close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	for _, mutation := range []string{"instruction deleted", "instruction changed", "DATA deleted"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, string(read), plan9asm.GoAssemblerDefines("linux", "amd64"), "amd64", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if mutation == "DATA deleted" {
+				changed.Data = nil
+			} else {
+				found := false
+				for ordinal, ins := range changed.Funcs[0].Instrs {
+					if ins.Op != "PADDL" {
+						continue
+					}
+					found = true
+					if mutation == "instruction deleted" {
+						changed.Funcs[0].Instrs = append(changed.Funcs[0].Instrs[:ordinal], changed.Funcs[0].Instrs[ordinal+1:]...)
+					} else {
+						changed.Funcs[0].Instrs[ordinal].Op = "PADDQ"
+						changed.Funcs[0].Instrs[ordinal].Raw = strings.Replace(ins.Raw, "PADDL", "PADDQ", 1)
+					}
+					break
+				}
+				if !found {
+					t.Fatal("complete-source mutation fixture lost its PADDL instruction")
+				}
+			}
+			ir, err := plan9asm.Translate(changed, plan9asm.Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs,
+			})
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || ir != "" {
+				t.Fatal("canonical CPP bypassed the complete original source fingerprint", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/amd64_fixed_local_source_test.go b/cmd/plan9asmll/amd64_fixed_local_source_test.go
new file mode 100644
index 000000000..e279ab15d
--- /dev/null
+++ b/cmd/plan9asmll/amd64_fixed_local_source_test.go
@@ -0,0 +1,644 @@
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestAMD64FixedLocalSourceRoleQueryDoesNotBindSymbols(t *testing.T) {
+	pkg := &packages.Package{PkgPath: "example.invalid/query"}
+	forward := "CALL ·Callee(SB)\nMOVQ 0(SP),AX\nMOVQ AX,ret+0(FP)\nRET"
+	floatForward := "CALL ·Callee(SB)\nMOVSD 0(SP),X0\nMOVSD X0,ret+0(FP)\nRET"
+	for _, test := range []struct {
+		name, symbol, body string
+		result             plan9asm.LLVMType
+		forwarder          bool
+	}{
+		{"complete outgoing", "·Caller", forward, plan9asm.I64, true},
+		{"escaped package name", "example.invalid∕query·Caller", forward, plan9asm.I64, true},
+		{"linked caller needs binding", "·CallerAlias", forward, plan9asm.I64, false},
+		{"linked callee needs binding", "·Caller", strings.Replace(forward, "·Callee", "·CalleeAlias", 1), plan9asm.I64, false},
+		{"private without call", "·Caller", "MOVQ $1,0(SP)\nRET", plan9asm.I64, false},
+		{"private with call", "·Caller", strings.Replace(forward, "RET", "MOVQ $1,0(SP)\nRET", 1), plan9asm.I64, false},
+		// These scalar-lane sources already use the original untyped route.
+		{"legacy float linked caller", "·CallerAlias", floatForward, "double", true},
+		{"legacy float linked callee", "·Caller", strings.Replace(floatForward, "·Callee", "·CalleeAlias", 1), "double", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			sigs := make(map[string]plan9asm.FuncSig)
+			resultType := types.Typ[types.Uint64]
+			if test.result == "double" {
+				resultType = types.Typ[types.Float64]
+			}
+			for _, name := range []string{"Caller", "Callee", "linkedCaller", "linkedCallee"} {
+				resolved := pkg.PkgPath + "." + name
+				declaration := types.NewFunc(0, nil, name, types.NewSignatureType(nil, nil, nil, nil,
+					types.NewTuple(types.NewVar(0, nil, "", resultType)), false))
+				sig, err := plan9asm.DeriveGoFuncABI0Signature(resolved, declaration, "amd64", types.SizesFor("gc", "amd64"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs[resolved] = sig
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT "+test.symbol+"(SB),4,$8-8\n"+test.body+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !test.forwarder && !plan9asm.GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Fatal("negative control does not require the original private-frame candidate")
+			}
+			if test.result == "double" && plan9asm.GoAMD64FixedLocalFrameBindingNeeded(file, "amd64") {
+				t.Fatal("legacy scalar-lane control lost its original untyped route")
+			}
+			calls := 0
+			resolve := func(name string) string {
+				calls++
+				name = strings.Replace(name, "CallerAlias", "linkedCaller", 1)
+				name = strings.Replace(name, "CalleeAlias", "linkedCallee", 1)
+				return resolveSymFunc(pkg.PkgPath)(name)
+			}
+			bound, source, err := prepareAMD64FixedLocalSource(pkg, file, "", "linux/amd64",
+				targetTriple("linux", "amd64"), "amd64", compileConfig{}, resolve, sigs, nil)
+			if calls != 0 {
+				t.Fatalf("source-role query invoked the binding callback %d times before source capture", calls)
+			}
+			if source != nil {
+				t.Fatal("query created an uncaptured source owner")
+			}
+			if test.forwarder {
+				if err != nil || !reflect.DeepEqual(bound, sigs) {
+					t.Fatalf("complete outgoing source lost its existing route: %v", err)
+				}
+			} else if bound != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("uncaptured private source acquired authority: %v", err)
+			}
+		})
+	}
+}
+
+// The original numeric ABI0 fixture has a real automatic Go frame, explicit
+// complete initialization and restoration. Its local addresses are neither
+// incoming slice extents nor contiguous virtual FP shadow storage.
+func amd64FixedLocalCLIAssembly(operation string) string {
+	return fmt.Sprintf(`#include "textflag.h"
+TEXT ·Value(SB),NOSPLIT,$160-40
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),CX
+MOVQ c+16(FP),DX
+MOVQ d+24(FP),BX
+MOVQ SP,R11
+MOVQ $31,R9
+NOTQ R9
+ANDQ R9,SP
+ADDQ $32,SP
+MOVQ R11,96(SP)
+MOVQ AX,16(SP)
+MOVQ CX,24(SP)
+MOVQ DX,48(SP)
+MOVQ BX,56(SP)
+MOVOU 48(SP),X0
+%s
+MOVQ X0,AX
+MOVQ 96(SP),R11
+MOVQ R11,SP
+MOVQ AX,ret+32(FP)
+RET
+`, operation)
+}
+
+func amd64FixedLocalCLIFixture(t *testing.T, operation string) (*packages.Package, string, compileConfig) {
+	t.Helper()
+	return amd64FixedLocalCLICompleteFixture(t, operation,
+		"package fixedlocal\nfunc Value(a, b, c, d uint64) uint64\n")
+}
+
+func amd64FixedLocalCLICompleteFixture(t *testing.T, operation, declaration string) (*packages.Package, string, compileConfig) {
+	t.Helper()
+	return amd64FixedLocalCLISourceFixture(t, amd64FixedLocalCLIAssembly(operation), declaration)
+}
+
+func amd64FixedLocalCLISourceFixture(t *testing.T, assembly, declaration string) (*packages.Package, string, compileConfig) {
+	t.Helper()
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, source := range map[string]string{
+		"go.mod":        "module example.invalid/fixedlocal\n\ngo 1.20\n",
+		"value.go":      declaration,
+		"value_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	t.Setenv("GOEXPERIMENT", "")
+	t.Setenv("GOAMD64", "v1")
+	// test2json may export the host's CPU settings to the test binary.
+	// This fixture explicitly selects linux/amd64, so no inactive target's
+	// CPU setting belongs in its original compiler observation.
+	for _, key := range []string{"GO386", "GOARM", "GOARM64", "GOWASM"} {
+		t.Setenv(key, "")
+	}
+	t.Setenv("GOPACKAGESDRIVER", "off")
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(os.Getenv(key)) {
+			path, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Setenv(key, path)
+		}
+	}
+	ctx := arm64PrivateCLIContext(t)
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+	pkgs, err := packages.Load(&packages.Config{
+		Context: ctx, Dir: dir, Env: env,
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+			packages.NeedTypes | packages.NeedTypesSizes,
+	}, ".")
+	if err != nil || len(pkgs) != 1 || len(pkgs[0].Errors) != 0 {
+		t.Fatalf("actual original selection: %v; %+v", err, pkgs)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelectionsInEnvironment(pkgs, "linux/amd64", env)
+	input := filepath.Join(dir, "value_amd64.s")
+	// Bind the independent actual Go prologue/object before asserting the CLI.
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go",
+		"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual original export: %v\n%s%s", err, stdout, stderr)
+	}
+	t.Logf("original source SHA=%x; actual Go export:\n%s", sha256.Sum256([]byte(assembly)), stdout)
+	return pkgs[0], input, config
+}
+
+func TestCompileOneAMD64FixedLocalCompleteOrdinaryGoSource(t *testing.T) {
+	for _, fixture := range []struct {
+		name   string
+		source string
+	}{
+		{"body", "func Reference(a uint64) uint64 { return a + 1 }\n"},
+		{"values", "const Bias uint64 = 7\nvar Counter uint64\n"},
+		{"sdk-import", "import \"math/bits\"\nfunc Reference(a uint64) uint64 { return bits.RotateLeft64(a, 7) }\n"},
+		{"combined", "import \"math/bits\"\nconst Bias uint64 = 7\nvar Counter uint64\n" +
+			"func Reference(a uint64) uint64 { return bits.RotateLeft64(a + Bias + Counter, 7) }\n"},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			declaration := "package fixedlocal\n" + fixture.source + "func Value(a, b, c, d uint64) uint64\n"
+			pkg, input, config := amd64FixedLocalCLICompleteFixture(t, "PADDL 16(SP),X0", declaration)
+			output := filepath.Join(t.TempDir(), "complete.ll")
+			if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("actual original Go export succeeded but complete-source CLI failed: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "fixed_local_native") || !strings.Contains(string(ir), "asm sideeffect") {
+				t.Fatalf("complete original source lost sealed native storage: %v", err)
+			}
+			if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("complete original-source LLVM22 object missing: %v", err)
+			}
+		})
+	}
+}
+
+func TestRunOneTargetFixedLocalWithDefaultCacheEnvironment(t *testing.T) {
+	pkg, _, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	// The existing direct compileOne fixtures supply every environment key.
+	// An ordinary CLI invocation does not: its loader must resolve these
+	// defaults before capturing the selection, not repair them afterward.
+	// Keep the fixture's explicit GOENV=off and CGO_ENABLED=0. A source proof
+	// cannot silently replace saved user settings or a native cgo profile.
+	for _, key := range []string{"GOWORK", "GOTOOLCHAIN", "GOCACHE", "GOMODCACHE", "GOPATH", "GOTMPDIR"} {
+		t.Setenv(key, "")
+	}
+	t.Chdir(pkg.Dir)
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"},
+		[]string{"."}, nil, nil, pkg.Module.Path, t.TempDir(), false, 0, false,
+		false, true, "", config)
+	if err != nil || report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("ordinary actual-load/frame environment differs: %v; %+v", err, report)
+	}
+}
+
+func TestRunOneTargetFixedLocalWithFreshModuleCache(t *testing.T) {
+	pkg, _, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	parent, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// A pure-Go local package need not cause cmd/go to create GOPATH or its
+	// default module cache. The ordinary CLI must prepare them before capture.
+	path := filepath.Join(parent, "fresh-gopath")
+	t.Setenv("GOPATH", path)
+	t.Setenv("GOMODCACHE", "")
+	t.Chdir(pkg.Dir)
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"},
+		[]string{"."}, nil, nil, pkg.Module.Path, t.TempDir(), false, 0, false,
+		false, true, "", config)
+	if err != nil || report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("fresh actual-load/frame cache environment differs: %v; %+v", err, report)
+	}
+}
+
+func TestAMD64FixedLocalCompleteSourceRetainsActualLoadIdentity(t *testing.T) {
+	for _, axis := range []string{"dependency-types", "missing-dependency", "extra-captured-import", "target", "source-bytes"} {
+		t.Run(axis, func(t *testing.T) {
+			declaration := "package fixedlocal\nimport \"math/bits\"\n" +
+				"func Reference(a uint64) uint64 { return bits.RotateLeft64(a, 7) }\n" +
+				"func Value(a, b, c, d uint64) uint64\n"
+			pkg, input, config := amd64FixedLocalCLICompleteFixture(t, "PADDL 16(SP),X0", declaration)
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64,
+				strings.Replace(amd64FixedLocalCLIAssembly("PADDL 16(SP),X0"), "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(name string) string { return strings.Replace(name, "·", pkg.PkgPath+".", 1) }
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, source, err := prepareAMD64FixedLocalSource(pkg, file, input, "linux/amd64",
+				"x86_64-unknown-linux-gnu", "amd64", config, resolve, sigs, nil)
+			if err != nil || source == nil {
+				t.Fatalf("actual original full-source binding failed: %v", err)
+			}
+			defer func() {
+				if err := source.close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			switch axis {
+			case "dependency-types":
+				pkg.Imports["math/bits"].Types = types.NewPackage("math/bits", "bits")
+			case "missing-dependency":
+				pkg.Imports["math/bits"] = nil
+			case "extra-captured-import":
+				config.x86CallerSelections[pkg].imports["unselected"] = types.NewPackage("unselected", "unselected")
+			case "target":
+				config.x86CallerSelections[pkg].target = "darwin/amd64"
+			case "source-bytes":
+				if err := os.WriteFile(filepath.Join(filepath.Dir(input), "value.go"),
+					[]byte(strings.Replace(declaration, "a, 7", "a, 9", 1)), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := source.verify(config.Context); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("changed actual-load %s retained the full-source binding: %v", axis, err)
+			}
+			if err := source.binding.Verify(config.Context); err == nil {
+				t.Fatal("failed actual-load verification did not revoke its independent frame binding")
+			}
+		})
+	}
+}
+
+func TestCompileOneAMD64FixedLocalOriginalSource(t *testing.T) {
+	for _, operation := range []string{
+		"PADDB 16(SP),X0", "PADDW 16(SP),X0", "PADDL 16(SP),X0", "PADDQ 16(SP),X0",
+		"PMADDWL 16(SP),X0", "CMPPS 16(SP),X0,$0", "CMPPD 16(SP),X0,$0",
+	} {
+		t.Run(strings.Fields(operation)[0], func(t *testing.T) {
+			pkg, input, config := amd64FixedLocalCLIFixture(t, operation)
+			output := filepath.Join(t.TempDir(), "local.ll")
+			if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("complete original numeric local frame has no CLI consumer: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "fixed_local_native") || !strings.Contains(string(ir), "asm sideeffect") {
+				t.Fatalf("original local source was not consumed by sealed native storage: %v", err)
+			}
+			if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 original-source object missing: %v", err)
+			}
+		})
+	}
+}
+
+func TestParseCompleteCLIAssemblyKeepsSourceRoles(t *testing.T) {
+	const body = "MOVQ   a+0(FP), AX\nMOVOU   0(SP), X0\nlabel:\nMOVQ X0, AX\nRET\n"
+	const data = "DATA literal<>+0(SB)/8, $7\nGLOBL literal<>(SB), 8, $8\n"
+	defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+	for _, frame := range []string{"0", "32"} {
+		source := "TEXT ·Value(SB), 4, $" + frame + "-8\n" + body + data
+		legacy, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, source, defines)
+		if err != nil {
+			t.Fatal(err)
+		}
+		actual, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, source, defines, "amd64", nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		want := legacy
+		if frame == "32" {
+			expanded, err := plan9asm.PreprocessAssemblySource(source, plan9asm.AssemblyPreprocessOptions{Defines: defines})
+			if err != nil {
+				t.Fatal(err)
+			}
+			want, err = plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if want.Funcs[0].Instrs[1].Raw == legacy.Funcs[0].Instrs[1].Raw {
+				t.Fatal("fixture did not distinguish historical and canonical CPP spelling")
+			}
+		}
+		gotJSON, err := json.Marshal(actual)
+		if err != nil {
+			t.Fatal(err)
+		}
+		wantJSON, err := json.Marshal(want)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(gotJSON) != string(wantJSON) || len(actual.Funcs[0].Instrs) != 6 || len(actual.Data) != 1 || len(actual.Globl) != 1 {
+			t.Fatalf("frame=%s changed its complete source representation", frame)
+		}
+	}
+	missing := "#include \"go_asm.h\"\nTEXT ·Value(SB),4,$32-8\n" + body
+	if file, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, missing, defines, "amd64", nil); err == nil || file != nil {
+		t.Fatal("unresolved active include was silently discarded", err)
+	}
+}
+
+func TestParseCompleteCLIAssemblySelectedGeneratedHeader(t *testing.T) {
+	const source = `#include "textflag.h"
+#include "go_asm.h"
+TEXT ·Value(SB),NOSPLIT,$32-16
+MOVQ a+0(FP),AX
+MOVQ AX,0(SP)
+#ifdef const_Offset
+MOVQ $const_Offset,CX
+#else
+MOVQ $0,CX
+#endif
+#ifdef Layout__size
+MOVQ $Layout__size,BX
+MOVQ $Layout_Value,DX
+#else
+MOVQ $0,BX
+MOVQ $0,DX
+#endif
+#ifdef const_Fraction
+MOVQ $1,BX
+#endif
+MOVQ AX,ret+8(FP)
+RET
+`
+	declaration := "package fixedlocal\nconst Offset = 16\nconst Fraction = 0.5\n" +
+		"type Layout struct { First uint8; Value uint64 }\nfunc Value(a uint64) uint64\n"
+	// Go's initial -gensymabis pass uses an empty bootstrap header. Keep its
+	// fallback legal; the final complete CPP must select the nonzero values.
+	pkg, input, _ := amd64FixedLocalCLISourceFixture(t, source, declaration)
+	read, err := readAsmSource(input, pkg.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types}
+	expanded := plan9asm.ExpandGoAssemblySource(selected, read, "amd64")
+	defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+	actual, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, string(expanded), defines, "amd64", &selected)
+	if err != nil {
+		t.Fatal("actual original Go export succeeded but complete CPP failed", err)
+	}
+	wantSource := "TEXT ·Value(SB),4,$32-16\nMOVQ a+0(FP),AX\nMOVQ AX,0(SP)\n" +
+		"MOVQ $16,CX\nMOVQ $16,BX\nMOVQ $8,DX\nMOVQ AX,ret+8(FP)\nRET\n"
+	wantCPP, err := plan9asm.PreprocessAssemblySource(wantSource, plan9asm.AssemblyPreprocessOptions{Defines: defines})
+	if err != nil {
+		t.Fatal(err)
+	}
+	want, err := plan9asm.Parse(plan9asm.ArchAMD64, wantCPP)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(actual, want) {
+		t.Fatalf("constant presence, struct size or field offset changed: %+v\nwant %+v", actual, want)
+	}
+	for _, name := range []string{"./go_asm.h", "../go_asm.h", "missing.h"} {
+		t.Run(name, func(t *testing.T) {
+			changed := strings.Replace(string(expanded), "\"go_asm.h\"", strconv.Quote(name), 1)
+			if file, err := parseCompleteCLIAssembly(plan9asm.ArchAMD64, changed, defines, "amd64", &selected); err == nil || file != nil {
+				t.Fatal("generated-header resolver acquired another include identity", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneAMD64FixedLocalDoesNotHijackOrdinaryNativeSources(t *testing.T) {
+	for _, variant := range []string{"static-data", "incoming-native"} {
+		t.Run(variant, func(t *testing.T) {
+			_, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+			directory := filepath.Dir(input)
+			declaration := "package fixedlocal\nfunc Value(p *[4]uint32) uint64\n"
+			assembly := "#include \"textflag.h\"\nTEXT ·Value(SB),NOSPLIT,$16-16\n" +
+				"MOVQ p+0(FP),AX\nPXOR X0,X0\nPADDL (AX),X0\nMOVQ X0,AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			if variant == "static-data" {
+				declaration = "package fixedlocal\nfunc Value(p uint64) uint64\n"
+				assembly = strings.Replace(assembly, "PADDL (AX),X0", "PADDL constant<>(SB),X0", 1)
+				assembly += "DATA constant<>+0(SB)/8,$1\nDATA constant<>+8(SB)/8,$2\nGLOBL constant<>(SB),RODATA|NOPTR,$16\n"
+			}
+			for name, contents := range map[string]string{"value.go": declaration, "value_amd64.s": assembly} {
+				if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			env := append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+			stdout, stderr, err := gotoolprofile.RunBounded(config.Context, directory, env, "go",
+				"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual ordinary source/export: %v\n%s%s", err, stdout, stderr)
+			}
+			pkgs, err := packages.Load(&packages.Config{Context: config.Context, Dir: directory, Env: env,
+				Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedModule |
+					packages.NeedDeps | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes}, ".")
+			if err != nil || len(pkgs) != 1 || len(pkgs[0].Errors) != 0 {
+				t.Fatalf("actual ordinary selected package: %v; %+v", err, pkgs)
+			}
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/amd64", nil)
+			output := filepath.Join(t.TempDir(), "ordinary.ll")
+			if err := compileOne(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("ordinary native operand was hijacked by narrow local source factory: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || strings.Contains(string(ir), "fixed_local_native") {
+				t.Fatalf("unrelated operand acquired local backing: %v", err)
+			}
+			if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || info.Size() == 0 {
+				t.Fatalf("ordinary LLVM22 object absent: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64FixedLocalActualOrdinaryCLIEntry(t *testing.T) {
+	_, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	output := t.TempDir()
+	report := filepath.Join(t.TempDir(), "report.json")
+	args := []string{"-targets=linux/amd64", "-patterns=.", "-module-path=example.invalid/fixedlocal",
+		"-compile", "-keep-obj", "-out=" + output, "-report=" + report}
+	encoded, err := json.Marshal(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded))
+	stdout, stderr, err := gotoolprofile.RunBounded(config.Context, filepath.Dir(input), env,
+		os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+	if err != nil {
+		t.Fatalf("actual ordinary CLI entry did not consume original backing: %v\n%s%s", err, stdout, stderr)
+	}
+	data, err := os.ReadFile(report)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var decoded matrixReport
+	if err := json.Unmarshal(data, &decoded); err != nil || decoded.Success != 1 || decoded.Failed != 0 ||
+		decoded.NotApplicable != 0 || decoded.TotalAsm != 1 || decoded.TotalTargets != 1 {
+		t.Fatalf("actual complete ordinary CLI result differs: %v\n%s", err, data)
+	}
+}
+
+func TestAMD64FixedLocalOrdinaryCLIDeadlineCannotMintObjects(t *testing.T) {
+	for _, timeout := range []string{"0", "1ns"} {
+		t.Run(timeout, func(t *testing.T) {
+			_, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+			output := t.TempDir()
+			args := []string{"-targets=linux/amd64", "-patterns=.", "-module-path=example.invalid/fixedlocal",
+				"-compile", "-keep-obj", "-out=" + output, "-feature-timeout=" + timeout}
+			encoded, err := json.Marshal(args)
+			if err != nil {
+				t.Fatal(err)
+			}
+			env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded))
+			stdout, stderr, err := gotoolprofile.RunBounded(config.Context, filepath.Dir(input), env,
+				os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+			if err == nil {
+				t.Fatalf("expired/unbounded ordinary source context minted an object:\n%s%s", stdout, stderr)
+			}
+			if err := filepath.WalkDir(output, func(path string, entry os.DirEntry, err error) error {
+				if err != nil {
+					return err
+				}
+				if !entry.IsDir() && (filepath.Ext(path) == ".ll" || filepath.Ext(path) == ".o") {
+					return fmt.Errorf("invalid context emitted %s", path)
+				}
+				return nil
+			}); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestCompileOneAMD64FixedLocalSourceRejectsUnprovedInputs(t *testing.T) {
+	for _, axis := range []string{"missing-selection", "wrong-target", "changed-selection", "flags", "experiment", "CGO", "expired", "nil-context", "unbounded-context",
+		"missing-byte", "unknown-call", "loop", "result-address", "composite"} {
+		t.Run(axis, func(t *testing.T) {
+			pkg, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+			selected := config.x86CallerSelections[pkg]
+			source := amd64FixedLocalCLIAssembly("PADDL 16(SP),X0")
+			switch axis {
+			case "missing-selection":
+				config.x86CallerSelections = nil
+			case "wrong-target":
+				selected.target = "darwin/amd64"
+			case "changed-selection":
+				pkg.Name = "changed"
+			case "flags":
+				selected.env = append(selected.env, "GOFLAGS=-tags=unclosed")
+			case "experiment":
+				selected.env = append(selected.env, "GOEXPERIMENT=arenas")
+			case "CGO":
+				selected.env = append(selected.env, "CGO_ENABLED=1")
+			case "expired":
+				ctx, cancel := context.WithCancel(config.Context)
+				cancel()
+				config.Context = ctx
+			case "nil-context":
+				config.Context = nil
+			case "unbounded-context":
+				config.Context = context.Background()
+			case "missing-byte":
+				source = strings.Replace(source, "MOVQ CX,24(SP)\n", "", 1)
+			case "unknown-call":
+				source = strings.Replace(source, "PADDL 16(SP),X0", "CALL runtime·Gosched(SB)\nPADDL 16(SP),X0", 1)
+			case "loop":
+				source = strings.Replace(source, "PADDL 16(SP),X0", "again:\nPADDL 16(SP),X0\nJMP again", 1)
+			case "result-address":
+				source = strings.Replace(source, "MOVQ X0,AX", "MOVQ SP,AX", 1)
+			case "composite":
+				// The old selected integer types remain deliberately stale.
+				// Actual independent declaration capture must reject the change.
+				if err := os.WriteFile(filepath.Join(filepath.Dir(input), "value.go"), []byte("package fixedlocal\nfunc Value(a *uint64,b,c,d uint64) uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output := filepath.Join(t.TempDir(), "unbound.ll")
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if err == nil {
+				t.Fatal("unproved numeric/source/native contract emitted an object")
+			}
+			// Infra/context failures are both strict nonpass; source-mutated
+			// caller capabilities must never be recovered from frame size.
+			if axis == "missing-byte" || axis == "result-address" || axis == "composite" {
+				if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("expected sealed source Context, got %v", err)
+				}
+			}
+			if _, err := os.Stat(output); !os.IsNotExist(err) {
+				t.Fatalf("rejected source emitted LLVM: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneAMD64FixedLocalWholeFileCannotSplitCertificate(t *testing.T) {
+	pkg, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	config.KeepObj = false
+	config.MaxFunctions, config.MaxInstructions = 1, 1
+	output := filepath.Join(t.TempDir(), "complete.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(output)
+	if err != nil || !strings.Contains(string(data), "fixed_local_native") {
+		t.Fatalf("complete bound source disappeared: %v", err)
+	}
+	if files, err := filepath.Glob(strings.TrimSuffix(output, ".ll") + ".part-*.ll"); err != nil || len(files) != 0 {
+		t.Fatalf("complete-file source was split: %v %v", files, err)
+	}
+	if _, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); !os.IsNotExist(err) {
+		t.Fatalf("owned validation object was not released: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/amd64_fixed_local_unaligned_source_test.go b/cmd/plan9asmll/amd64_fixed_local_unaligned_source_test.go
new file mode 100644
index 000000000..667f677cd
--- /dev/null
+++ b/cmd/plan9asmll/amd64_fixed_local_unaligned_source_test.go
@@ -0,0 +1,80 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCompileOneAMD64FixedLocalScalarSource(t *testing.T) {
+	t.Setenv("GOCACHE", t.TempDir())
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		t.Run(width, func(t *testing.T) {
+			var assembly strings.Builder
+			assembly.WriteString("TEXT ·Value(SB),4,$64-16\nMOVQ a+0(FP),AX\nMOVQ AX,8(SP)\n")
+			for _, operation := range []string{
+				"MOV%s AX,8(SP)", "MOV%s 8(SP),AX", "MOV%s $1,8(SP)",
+				"ADD%s $1,8(SP)", "XOR%s AX,8(SP)", "NOT%s 8(SP)",
+				"ROL%s $1,8(SP)", "CMP%s 8(SP),AX",
+			} {
+				fmt.Fprintf(&assembly, operation+"\n", width)
+			}
+			assembly.WriteString("MOVQ 8(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n")
+			pkg, input, config := amd64FixedLocalCLISourceFixture(t, assembly.String(),
+				"package fixedlocal\nfunc Value(a uint64) uint64\n")
+			output := filepath.Join(t.TempDir(), "scalar.ll")
+			if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("original Go scalar-only scratch source failed: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "fixed_local_native") {
+				t.Fatalf("scalar-only source lost original private-frame backing: %v", err)
+			}
+			info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o")
+			if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 scalar-only source object missing: %v", err)
+			}
+		})
+	}
+}
+
+// These are ordinary complete source programs, not injected frame tokens.
+// The fixture first compiles the original Go assembly; compileOne must then
+// discover its physical scratch requirement and produce a real LLVM22 object.
+func TestCompileOneAMD64FixedLocalUnalignedTransportSource(t *testing.T) {
+	// Share only disposable compiler artifacts, not source captures or Verify
+	// results. Every case still observes and consumes its own complete program.
+	t.Setenv("GOCACHE", t.TempDir())
+	for _, row := range []struct{ opcode, register string }{
+		{"MOVOU", "X0"}, {"MOVUPS", "X0"}, {"MOVUPD", "X0"},
+		{"VMOVDQU", "Y0"}, {"VMOVUPS", "Z0"}, {"VMOVUPD", "Z0"},
+		{"VMOVDQU8", "Z0"}, {"VMOVDQU16", "Z0"},
+		{"VMOVDQU32", "Z0"}, {"VMOVDQU64", "Z0"},
+	} {
+		t.Run(row.opcode, func(t *testing.T) {
+			// Existing fixture cells cover 16..31 and 48..63. Initialize the
+			// remaining wide-source bytes without touching the saved SP at 96.
+			operation := "MOVQ AX,32(SP)\nMOVQ AX,40(SP)\nMOVQ AX,64(SP)\nMOVQ AX,72(SP)\n" +
+				row.opcode + " 16(SP)," + row.register
+			pkg, input, config := amd64FixedLocalCLIFixture(t, operation)
+			output := filepath.Join(t.TempDir(), "unaligned.ll")
+			if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("actual Go physical-scratch source lost its existing fixed-local route: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "fixed_local_native") {
+				t.Fatalf("complete source did not retain original private-frame backing: %v", err)
+			}
+			info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o")
+			if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 complete-source object missing: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/amd64_sdk_fixed_local_go127_test.go b/cmd/plan9asmll/amd64_sdk_fixed_local_go127_test.go
new file mode 100644
index 000000000..45e3b9986
--- /dev/null
+++ b/cmd/plan9asmll/amd64_sdk_fixed_local_go127_test.go
@@ -0,0 +1,116 @@
+//go:build go1.27
+
+package main
+
+import (
+	"bytes"
+	"debug/elf"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestRunOneTargetSDKFixedLocalPreservesActualDefaultProfile(t *testing.T) {
+	runSDKFixedLocalDefaultProfile(t, false)
+}
+
+func TestRunOneTargetSDKFixedLocalCanonicalCommandPaths(t *testing.T) {
+	runSDKFixedLocalDefaultProfile(t, true)
+}
+
+func runSDKFixedLocalDefaultProfile(t *testing.T, commandPaths bool) {
+	t.Helper()
+	for _, profile := range []string{"off", "original-config"} {
+		t.Run(profile, func(t *testing.T) {
+			for key, value := range map[string]string{
+				"GOWORK": "off", "GOTOOLCHAIN": "local", "GOFLAGS": "", "GOEXPERIMENT": "",
+				"GOPACKAGESDRIVER": "off", "GOOS": "linux", "GOARCH": "amd64",
+				"GO386": "", "GOARM": "", "GOARM64": "", "GOWASM": "",
+			} {
+				t.Setenv(key, value)
+			}
+			// Preserve actual compiler defaults, including CGO. An existing
+			// config is a producer input, not a request to replace it with off.
+			for _, key := range []string{"CGO_ENABLED", "GOAMD64", "GOPROXY"} {
+				t.Setenv(key, "")
+				if err := os.Unsetenv(key); err != nil {
+					t.Fatal(err)
+				}
+			}
+			configPath := "off"
+			if profile == "original-config" {
+				parent, err := filepath.EvalSymlinks(t.TempDir())
+				if err != nil {
+					t.Fatal(err)
+				}
+				configPath = filepath.Join(parent, "go-env")
+				if err := os.WriteFile(configPath, []byte("GOPROXY=https://original-config.invalid,direct\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			t.Setenv("GOENV", configPath)
+			if commandPaths {
+				parent := t.TempDir()
+				for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+					// Unlike filepath.Join, this preserves the original command
+					// spelling until the real load-boundary resolver observes it.
+					path := parent + string(filepath.Separator) + "." + string(filepath.Separator) + strings.ToLower(key)
+					if runtime.GOOS == "windows" {
+						path = filepath.ToSlash(path)
+					}
+					if err := os.MkdirAll(path, 0700); err != nil {
+						t.Fatal(err)
+					}
+					t.Setenv(key, path)
+				}
+			}
+			const path = "vendor/golang.org/x/crypto/chacha20poly1305"
+			input := filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(path), "chacha20poly1305_amd64.s")
+			original, err := os.ReadFile(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := arm64PrivateCLIContext(t)
+			defaults, stderr, err := gotoolprofile.RunBounded(ctx, "", os.Environ(), "go", "env", "CGO_ENABLED", "GOENV", "GOPROXY")
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual compiler/default config precondition: %v; %s", err, stderr)
+			}
+			t.Logf("actual original default profile:\n%s", defaults)
+			config, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = ctx
+			output := t.TempDir()
+			report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"},
+				[]string{path}, nil, nil, "", output, false, 0, false, false, true, "../..", config)
+			if err != nil || report.TotalAsm != 1 || len(report.AsmFiles) != 1 || report.Success != 1 ||
+				report.Failed != 0 || report.NotApplicable != 0 || len(report.Fails) != 0 {
+				t.Fatalf("complete actual SDK source failed: %v; %+v", err, report)
+			}
+			irPath := filepath.Join(output, filepath.FromSlash(path), filepath.Base(input)+".ll")
+			ir, err := os.ReadFile(irPath)
+			if err != nil || !bytes.Contains(ir, []byte("define ")) ||
+				!bytes.Contains(ir, []byte(`target triple = "x86_64-unknown-linux-gnu"`)) {
+				t.Fatal("complete original SDK source omitted target LLVM definitions", err)
+			}
+			object, err := elf.Open(strings.TrimSuffix(irPath, ".ll") + ".o")
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer object.Close()
+			if object.Machine != elf.EM_X86_64 || object.Type != elf.ET_REL ||
+				object.Section(".text") == nil || object.Section(".text").Size == 0 {
+				t.Fatal("complete original SDK source omitted AMD64 ELF text")
+			}
+			after, err := os.ReadFile(input)
+			if err != nil || !bytes.Equal(after, original) {
+				t.Fatal("complete original SDK source was cropped or replaced", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/arm64_abi0_tail_member_test.go b/cmd/plan9asmll/arm64_abi0_tail_member_test.go
new file mode 100644
index 000000000..ecd7d1131
--- /dev/null
+++ b/cmd/plan9asmll/arm64_abi0_tail_member_test.go
@@ -0,0 +1,168 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestARM64ABI0TailActualSelectedMemberDirectoryAlias(t *testing.T) {
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	directory, err := sourcepath.Resolve(arm64ABI0TailCLIFixture(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "requested-package")
+	ordinaryLoadDirectoryAlias(t, alias, directory)
+	t.Chdir(directory)
+	pkgs, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("complete original module selection: %v %+v", err, pkgs)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = arm64PrivateCLIContext(t)
+	config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/arm64", nil)
+	input := filepath.Join(alias, "p_arm64.s")
+	expanded, err := readAsmSource(input, asmSourceRoot(pkgs[0], input))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := loadARM64ABI0TailSource(pkgs[0], input, expanded, "linux/arm64", nil, config)
+	if err != nil {
+		t.Fatal("requested directory alias lost its exact actual selected assembly member", err)
+	}
+	if source.asm != input || source.actual == pkgs[0] || source.actual.Types == pkgs[0].Types {
+		t.Fatal("original request or complete independent typed graph was relabelled")
+	}
+	if err := source.verify(config.Context, nil, nil); err != nil {
+		t.Fatal("same original requested member did not retain its live identity", err)
+	}
+	output := filepath.Join(t.TempDir(), "alias.ll")
+	if err := compileOne(pkgs[0], plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal("original alias request did not reach the actual LLVM22 object", err)
+	}
+	info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o")
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("missing complete original-alias LLVM22 object: %v", err)
+	}
+}
+
+type assemblyMemberCallbackContext struct {
+	context.Context
+	callback func()
+}
+
+func (ctx *assemblyMemberCallbackContext) Err() error {
+	if callback := ctx.callback; callback != nil {
+		ctx.callback = nil
+		callback()
+	}
+	return ctx.Context.Err()
+}
+
+func TestARM64ABI0TailOriginalAliasPostGuard(t *testing.T) {
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	directory, err := sourcepath.Resolve(arm64ABI0TailCLIFixture(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "requested-package")
+	ordinaryLoadDirectoryAlias(t, alias, directory)
+	t.Chdir(directory)
+	pkgs, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("complete actual selection: %v", err)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = arm64PrivateCLIContext(t)
+	config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/arm64", nil)
+	input := filepath.Join(alias, "p_arm64.s")
+	expanded, err := readAsmSource(input, asmSourceRoot(pkgs[0], input))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := loadARM64ABI0TailSource(pkgs[0], input, expanded, "linux/arm64", nil, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	other := arm64ABI0TailCLIFixture(t) // Complete, byte-identical but unselected package.
+	called := false
+	ctx := &assemblyMemberCallbackContext{Context: config.Context, callback: func() {
+		called = true
+		if err := os.Rename(alias, alias+".original"); err != nil {
+			t.Fatal(err)
+		}
+		ordinaryLoadDirectoryAlias(t, alias, other)
+	}}
+	if err := source.verify(ctx, nil, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || !called {
+		t.Fatalf("callback-retargeted original request survived complete final source guard: called=%v error=%v", called, err)
+	}
+	if err := os.Remove(alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(alias+".original", alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.verify(config.Context, nil, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("restoring original request revived rejected source: %v", err)
+	}
+}
+
+func TestARM64ABI0TailActualSelectedFinalSymlink(t *testing.T) {
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	directory := arm64ABI0TailCLIFixture(t)
+	input := filepath.Join(directory, "p_arm64.s")
+	if err := os.Rename(input, input+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(input+".original", input); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(directory)
+	pkgs, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual compiler final-symlink selection: %v", err)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = arm64PrivateCLIContext(t)
+	config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/arm64", nil)
+	expanded, err := readAsmSource(input, asmSourceRoot(pkgs[0], input))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := loadARM64ABI0TailSource(pkgs[0], input, expanded, "linux/arm64", nil, config)
+	if err != nil {
+		t.Fatal("selected final symlink lost its original source contract", err)
+	}
+	if err := source.verify(config.Context, nil, nil); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_abi0_tail_source.go b/cmd/plan9asmll/arm64_abi0_tail_source.go
new file mode 100644
index 000000000..00ebc5865
--- /dev/null
+++ b/cmd/plan9asmll/arm64_abi0_tail_source.go
@@ -0,0 +1,220 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// Reuse the immutable actual-load inventory, not the x86 caller permission.
+// Only a genuinely consumed ABI0 private tail needs this second typed graph.
+type arm64ABI0TailTypedSource struct {
+	original  *packages.Package
+	actual    *packages.Package
+	selection *x86CallerPackageSelection
+	goPackage plan9asm.GoPackage
+	sources   map[string]string
+	asm       string
+	expanded  string
+	member    *actualAssemblyMember
+}
+
+func (source *arm64ABI0TailTypedSource) verify(ctx context.Context, defines []string, feature *featureConsumer) (result error) {
+	if err := source.member.verify(); err != nil {
+		return err
+	}
+	defer func() { result = errors.Join(result, source.member.verify()) }()
+	selection, pkg := source.selection, source.original
+	if selection == nil || selection.identity == "" || selection.identity != x86CallerSelectionIdentity(pkg, selection.env) ||
+		selection.types != pkg.Types || !reflect.DeepEqual(selection.sizes, x86CallerSizes(pkg.TypesSizes)) ||
+		len(selection.imports) != len(pkg.Imports) {
+		return fmt.Errorf("%w: ABI0 continuation changed its actual-load selection/layout", plan9asm.ErrProbeNeedsContext)
+	}
+	for path, dependency := range pkg.Imports {
+		if dependency == nil || dependency.Types != selection.imports[path] {
+			return fmt.Errorf("%w: ABI0 continuation changed actual dependency types", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	if err := selection.verifyEffectiveSourceMode(ctx); err != nil {
+		return err
+	}
+	for filename, expected := range source.sources {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		actual, err := gotoolprofile.FileSHA256(filename)
+		if err != nil || actual != expected {
+			return fmt.Errorf("%w: ABI0 continuation changed actual selected source bytes", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	var expanded []byte
+	var err error
+	if feature != nil {
+		expanded, _, err = feature.preprocessCPP(source.asm, pkg.PkgPath, defines)
+	} else {
+		expanded, err = readAsmSource(source.asm, asmSourceRoot(pkg, source.asm))
+	}
+	if err != nil {
+		return err
+	}
+	expanded = plan9asm.ExpandGoAssemblySource(source.goPackage, expanded, "arm64")
+	if featureBytesSHA256(expanded) != source.expanded {
+		return fmt.Errorf("%w: ABI0 continuation changed original CPP/typed expansion", plan9asm.ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+func loadARM64ABI0TailSource(pkg *packages.Package, asm string, expanded []byte,
+	target string, defines []string, config compileConfig,
+) (*arm64ABI0TailTypedSource, error) {
+	selection := config.x86CallerSelections[pkg]
+	if pkg == nil || selection == nil || !selection.ready || selection.target != target ||
+		pkg.Types == nil || pkg.TypesSizes == nil || pkg.IllTyped || len(pkg.Errors) != 0 ||
+		len(pkg.CompiledGoFiles) == 0 || len(pkg.CompiledGoFiles) > 256 || len(pkg.OtherFiles) > 512 {
+		return nil, fmt.Errorf("%w: ABI0 continuation needs complete actual ordinary source selection", plan9asm.ErrProbeNeedsContext)
+	}
+	ctx := config.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	source := &arm64ABI0TailTypedSource{
+		original: pkg, selection: selection, sources: make(map[string]string),
+		asm: asm, expanded: featureBytesSHA256(expanded),
+	}
+	member, err := observeActualAssemblyMember(asm, pkg.OtherFiles)
+	if err != nil {
+		return nil, fmt.Errorf("%w: ABI0 tail assembly is absent from actual Go selection: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	source.member = member
+	if err := selection.verifyEffectiveSourceMode(ctx); err != nil {
+		return nil, err
+	}
+	fset := token.NewFileSet()
+	info := &types.Info{Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object),
+		Types: make(map[ast.Expr]types.TypeAndValue)}
+	selectionSource := &plan9asm.GoSourceSelection{
+		Fset: fset, TypesInfo: info, Sizes: pkg.TypesSizes,
+		SelectedGoFiles: append([]string(nil), pkg.CompiledGoFiles...), GoSources: make(map[string][]byte),
+	}
+	var syntax []*ast.File
+	total := 0
+	for _, filename := range pkg.CompiledGoFiles {
+		if selectionSource.GoSources[filename] != nil {
+			return nil, fmt.Errorf("%w: duplicate actual ABI0 Go source", plan9asm.ErrProbeNeedsContext)
+		}
+		data, err := x86CallerReadSource(ctx, filename, &total)
+		if err != nil {
+			return nil, err
+		}
+		parsed, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		syntax = append(syntax, parsed)
+		selectionSource.GoSources[filename] = data
+		source.sources[filename] = featureBytesSHA256(data)
+	}
+	selectedAsm := false
+	for _, filename := range pkg.OtherFiles {
+		if filepath.Ext(filename) != ".s" && filepath.Ext(filename) != ".h" {
+			return nil, fmt.Errorf("%w: ABI0 continuation has an unbound native source role", plan9asm.ErrProbeNeedsContext)
+		}
+		if _, duplicate := source.sources[filename]; duplicate {
+			return nil, fmt.Errorf("%w: duplicate actual ABI0 native source", plan9asm.ErrProbeNeedsContext)
+		}
+		data, err := x86CallerReadSource(ctx, filename, &total)
+		if err != nil {
+			return nil, err
+		}
+		source.sources[filename] = featureBytesSHA256(data)
+		selectedAsm = selectedAsm || filename == member.selected && filepath.Ext(filename) == ".s"
+	}
+	if !selectedAsm {
+		return nil, fmt.Errorf("%w: ABI0 tail assembly is absent from actual Go selection", plan9asm.ErrProbeNeedsContext)
+	}
+	typeConfig := types.Config{
+		Importer: x86CallerActualImports(pkg.Imports), Sizes: pkg.TypesSizes, GoVersion: pkg.Types.GoVersion(),
+	}
+	typed, err := typeConfig.Check(pkg.PkgPath, fset, syntax, info)
+	if err != nil {
+		return nil, fmt.Errorf("actual selected ABI0 declaration recheck: %w", err)
+	}
+	copyPackage := *pkg
+	copyPackage.Types, copyPackage.Syntax, copyPackage.Fset, copyPackage.TypesInfo = typed, syntax, fset, info
+	source.actual = &copyPackage
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, dependency := range pkg.Imports {
+		imports[path] = dependency.Types
+	}
+	source.goPackage = plan9asm.GoPackage{
+		Path: typed.Path(), Types: typed, Imports: imports, Syntax: syntax, SourceSelection: selectionSource,
+	}
+	if err := source.verify(ctx, defines, config.Feature); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func prepareARM64ABI0TailSource(pkg *packages.Package, file *plan9asm.File, asm string, expanded []byte,
+	target string, defines []string, config compileConfig, resolve func(string) string,
+) (*plan9asm.File, *arm64ABI0TailTypedSource, map[string]plan9asm.FuncSig, error) {
+	if !plan9asm.GoARM64ABI0TailDeclarationBindingNeeded(file) {
+		prepared, err := plan9asm.CoalesceARM64PrivateRegisterHelpers(file)
+		return prepared, nil, nil, err
+	}
+	source, err := loadARM64ABI0TailSource(pkg, asm, expanded, target, defines, config)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	declared := make(map[string]plan9asm.FuncSig)
+	for _, fn := range file.Funcs {
+		if !strings.HasPrefix(fn.Sym, "·") || strings.Contains(fn.Sym, "<") {
+			continue
+		}
+		name := resolve(stripABISuffix(fn.Sym))
+		sig, _, present, err := tryDeclSig(source.actual.Types.Scope(), fn.Sym, name, nil, "arm64", source.actual.TypesSizes, false)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		if present {
+			declared[name] = sig
+		}
+	}
+	bound, err := plan9asm.BindGoARM64ABI0TailDeclarations(source.goPackage, file, resolve, declared)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	prepared, err := plan9asm.PrepareGoARM64ABI0TailContinuations(file, bound, resolve)
+	return prepared, source, bound, err
+}
+
+// Compare the complete public transport before retaining the actual Binder.
+// Serialization is only an equality projection; it never restores a token.
+func rebindARM64ABI0TailSignatures(sigs, bound map[string]plan9asm.FuncSig) error {
+	for name, previous := range bound {
+		current, present := sigs[name]
+		if !present {
+			continue // Removed helpers do not gain a signature or external entry.
+		}
+		before, beforeErr := json.Marshal(previous)
+		after, afterErr := json.Marshal(current)
+		if beforeErr != nil || afterErr != nil || !bytes.Equal(before, after) {
+			return fmt.Errorf("%w: ABI0 continuation changed its complete typed transport", plan9asm.ErrProbeNeedsContext)
+		}
+		sigs[name] = previous
+	}
+	return nil
+}
diff --git a/cmd/plan9asmll/arm64_abi0_tail_source_test.go b/cmd/plan9asmll/arm64_abi0_tail_source_test.go
new file mode 100644
index 000000000..b40bd4ff1
--- /dev/null
+++ b/cmd/plan9asmll/arm64_abi0_tail_source_test.go
@@ -0,0 +1,255 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+const arm64ABI0TailCLIAssembly = `TEXT ·Slots(SB),516,$0-16
+MOVD value+0(FP),R0
+MOVD $out+8(FP),R8
+B resultbody<>(SB)
+TEXT resultbody<>(SB),516,$0
+ADD $7,R0,R11
+MOVD R11,(R8)
+RET
+`
+
+func arm64ABI0TailCLIFixture(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":    "module example.com/abi0tail\n\ngo 1.20\n",
+		"p.go":      "package p\nfunc Slots(value uint64) (out uint64)\n",
+		"p_arm64.s": arm64ABI0TailCLIAssembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func TestCompileOneARM64ABI0TailWholeSourceGuards(t *testing.T) {
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	for _, name := range []string{"no-load", "wrong-target", "overlay", "bodyful", "late-native-use", "late-DATA-use"} {
+		t.Run(name, func(t *testing.T) {
+			dir := arm64ABI0TailCLIFixture(t)
+			t.Chdir(dir)
+			pkgs, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("actual Go selection: packages=%d error=%v", len(pkgs), err)
+			}
+			config, err := resolveCompileConfig(true, "", false, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = arm64PrivateCLIContext(t)
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/arm64", nil)
+			selection := config.x86CallerSelections[pkgs[0]]
+			source := arm64ABI0TailCLIAssembly
+			switch name {
+			case "no-load":
+				config.x86CallerSelections = nil
+			case "wrong-target":
+				selection.target = "linux/amd64"
+			case "overlay":
+				selection.env = append(selection.env, "GOFLAGS=-overlay=unbound.json")
+			case "bodyful":
+				if err := os.WriteFile(filepath.Join(dir, "p.go"), []byte("package p\nfunc Slots(value uint64) (out uint64) { return value }\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "late-native-use":
+				source += "TEXT observer<>(SB),516,$0\nADR resultbody<>(SB),R7\nRET\n"
+			case "late-DATA-use":
+				source += "DATA pointer<>(SB)/8,$resultbody<>(SB)\nGLOBL pointer<>(SB),$8\n"
+			}
+			input := filepath.Join(dir, "p_arm64.s")
+			if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output := filepath.Join(t.TempDir(), "unsafe.ll")
+			err = compileOne(pkgs[0], plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("unbound/changed source role obtained LLVM permission: %v", err)
+			}
+			if _, err := os.Stat(output); !os.IsNotExist(err) {
+				t.Fatalf("rejected original source emitted LLVM: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneARM64ABI0TailCompleteAndChunks(t *testing.T) {
+	dir := arm64ABI0TailCLIFixture(t)
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	declaration := "package p\nfunc Slots(value uint64) (out uint64)\nfunc Other(value uint64) (out uint64)\n"
+	root := arm64ABI0TailCLIAssembly[:strings.Index(arm64ABI0TailCLIAssembly, "TEXT resultbody")]
+	source := arm64ABI0TailCLIAssembly + strings.Replace(root, "·Slots", "·Other", 1)
+	for name, data := range map[string]string{"p.go": declaration, "p_arm64.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	requireARM64PrivateCLIOriginalObject(t, source)
+	for _, target := range []struct{ os, triple string }{
+		{"darwin", "aarch64-apple-darwin"}, {"linux", "aarch64-unknown-linux-gnu"},
+		{"linux", "aarch64-unknown-linux-musl"}, {"freebsd", "aarch64-unknown-freebsd"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		pkgs, err := loadPkgs(target.os, "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+		if err != nil || len(pkgs) != 1 {
+			t.Fatalf("actual complete Go selection: packages=%d error=%v", len(pkgs), err)
+		}
+		for _, keep := range []bool{false, true} {
+			mode := "chunks"
+			if keep {
+				mode = "complete-object"
+			}
+			t.Run(target.triple+"/"+mode, func(t *testing.T) {
+				config, err := resolveCompileConfig(true, "", keep, 2)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.Context = arm64PrivateCLIContext(t)
+				config.MaxFunctions, config.MaxInstructions = 1, 1
+				config.x86CallerSelections = captureX86CallerSelections(pkgs, target.os+"/arm64", nil)
+				output := filepath.Join(t.TempDir(), "tails.ll")
+				if err := compileOne(pkgs[0], plan9asm.ArchARM64, target.os, "arm64", target.triple,
+					asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: filepath.Join(dir, "p_arm64.s"), OutLL: output}, false, config); err != nil {
+					t.Fatal(err)
+				}
+				outputs, definitions := []string{output}, 2
+				if !keep {
+					outputs = append(outputs, strings.TrimSuffix(output, ".ll")+".part-0001.ll")
+					definitions = 1
+				}
+				for _, filename := range outputs {
+					data, err := os.ReadFile(filename)
+					if err != nil || strings.Count(string(data), "define ") != definitions {
+						t.Fatalf("bounded complete source lost a root: %v", err)
+					}
+					object := strings.TrimSuffix(filename, ".ll") + ".o"
+					info, err := os.Stat(object)
+					if keep {
+						if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+							t.Fatalf("no complete LLVM22 object: %v", err)
+						}
+					} else if !os.IsNotExist(err) {
+						t.Fatalf("compiled private chunk object was not released: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestCompileOneARM64ABI0TailSourcePostGuard(t *testing.T) {
+	for _, change := range []string{"Go", "ASM", "selection"} {
+		t.Run(change, func(t *testing.T) {
+			dir := arm64ABI0TailCLIFixture(t)
+			t.Chdir(dir)
+			t.Setenv("GOWORK", "off")
+			t.Setenv("GOENV", "off")
+			t.Setenv("GOTOOLCHAIN", "local")
+			t.Setenv("CGO_ENABLED", "0")
+			t.Setenv("GOFLAGS", "")
+			pkgs, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("actual ordinary Go selection: %v", err)
+			}
+			config, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = arm64PrivateCLIContext(t)
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/arm64", nil)
+			input := filepath.Join(dir, "p_arm64.s")
+			expanded, err := readAsmSource(input, asmSourceRoot(pkgs[0], input))
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound, err := loadARM64ABI0TailSource(pkgs[0], input, expanded, "linux/arm64", nil, config)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if bound.actual == pkgs[0] || bound.actual.Types == pkgs[0].Types {
+				t.Fatal("actual typed recheck was not independently retained")
+			}
+			if change == "selection" {
+				pkgs[0].Imports = map[string]*packages.Package{"unbound": nil}
+			} else {
+				filename := input
+				if change == "Go" {
+					filename = filepath.Join(dir, "p.go")
+				}
+				if err := os.WriteFile(filename, []byte("// replaced actual input\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := bound.verify(config.Context, nil, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("changed actual source/selection survived final consumer: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneARM64ABI0TailActualDeclaration(t *testing.T) {
+	dir := arm64ABI0TailCLIFixture(t)
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	t.Setenv("GOMAXPROCS", "2")
+	requireARM64PrivateCLIOriginalObject(t, arm64ABI0TailCLIAssembly)
+	for _, target := range []struct{ os, triple string }{
+		{"darwin", "aarch64-apple-darwin"}, {"linux", "aarch64-unknown-linux-gnu"},
+		{"linux", "aarch64-unknown-linux-musl"}, {"freebsd", "aarch64-unknown-freebsd"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			pkgs, err := loadPkgs(target.os, "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("actual ordinary Go package selection: packages=%d error=%v", len(pkgs), err)
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = arm64PrivateCLIContext(t)
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, target.os+"/arm64", nil)
+			output := filepath.Join(t.TempDir(), "tail.ll")
+			err = compileOne(pkgs[0], plan9asm.ArchARM64, target.os, "arm64", target.triple,
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: filepath.Join(dir, "p_arm64.s"), OutLL: output}, false, config)
+			if err != nil {
+				t.Fatalf("complete actual ABI0 declaration did not reach the LLVM object: %v", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || strings.Count(string(ir), "define ") != 1 || strings.Contains(string(ir), "resultbody") {
+				t.Fatalf("source tail acquired a fictitious callable helper: %v", err)
+			}
+			object := strings.TrimSuffix(output, ".ll") + ".o"
+			if info, err := os.Stat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 produced no %s object: %v", target.triple, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/arm64_conditional_compare_specs_test.go b/cmd/plan9asmll/arm64_conditional_compare_specs_test.go
new file mode 100644
index 000000000..73d0cecae
--- /dev/null
+++ b/cmd/plan9asmll/arm64_conditional_compare_specs_test.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsARM64ConditionalCompareSpec(t *testing.T) {
+	const filename = "arm64_lower_float_conditional_compare.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(isolated, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, "../.."} {
+		for _, arch := range []string{"arm64", "arm", "amd64", "386", "wasm"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"FCCMPS", "FCCMPD", "FCCMPES", "FCCMPED"} {
+				_, present := supported[operation]
+				if present != (arch == "arm64") {
+					t.Errorf("%s extraction %s present=%t", arch, operation, present)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/arm64_fallback_execution_test.go b/cmd/plan9asmll/arm64_fallback_execution_test.go
new file mode 100644
index 000000000..66410a7f4
--- /dev/null
+++ b/cmd/plan9asmll/arm64_fallback_execution_test.go
@@ -0,0 +1,31 @@
+package main
+
+import "testing"
+
+func TestFallbackARM64OracleExecutionModes(t *testing.T) {
+	for _, row := range []struct {
+		goos, goarch, cross string
+		want                string
+		failure             bool
+	}{
+		{"darwin", "arm64", "", "native", false},
+		{"linux", "arm64", "", "native", false},
+		{"linux", "arm64", "1", "native", false},
+		{"linux", "amd64", "1", "cross", false},
+		{"linux", "amd64", "", "", false},
+		{"linux", "amd64", "0", "", false},
+		{"windows", "arm64", "", "", false},
+		{"windows", "amd64", "", "", false},
+		{"darwin", "arm64", "1", "", true},
+		{"windows", "amd64", "1", "", true},
+		{"linux", "386", "1", "", true},
+		{"linux", "amd64", "true", "", true},
+	} {
+		t.Run(row.goos+"/"+row.goarch+"/cross="+row.cross, func(t *testing.T) {
+			got, err := fallbackARM64OracleExecution(row.goos, row.goarch, row.cross)
+			if got != row.want || (err != nil) != row.failure {
+				t.Fatalf("execution mode=%q, error=%v; want %q, failure=%t", got, err, row.want, row.failure)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/arm64_fallback_frame_span_test.go b/cmd/plan9asmll/arm64_fallback_frame_span_test.go
new file mode 100644
index 000000000..a17951f52
--- /dev/null
+++ b/cmd/plan9asmll/arm64_fallback_frame_span_test.go
@@ -0,0 +1,270 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestFallbackARM64FrameIncludesEveryAccessedWord(t *testing.T) {
+	for _, test := range []struct {
+		name    string
+		body    string
+		params  []int64
+		results []int64
+	}{
+		{
+			name:   "two adjacent load pairs",
+			body:   "LDP res+0(FP), (R0, R1)\nLDP b+16(FP), (R2, R3)\n",
+			params: []int64{0, 8, 16, 24},
+		},
+		{
+			name:   "overlapping scalar and pair reads",
+			body:   "MOVD first+0(FP), R0\nLDP first+0(FP), (R0, R1)\nMOVD second+8(FP), R2\n",
+			params: []int64{0, 8},
+		},
+		{
+			name:   "quad float load",
+			body:   "FMOVQ src+0(FP), F0\n",
+			params: []int64{0, 8},
+		},
+		{
+			name:    "integer pair result",
+			body:    "MOVD $1, R0\nMOVD $2, R1\nSTP (R0, R1), ret+0(FP)\n",
+			results: []int64{0, 8},
+		},
+		{
+			name:    "quad float result",
+			body:    "VMOVQ $1, $2, V0\nFMOVQ F0, ret+0(FP)\n",
+			results: []int64{0, 8},
+		},
+		{
+			name:   "32-bit pair occupies one fallback word",
+			body:   "LDPW src+0(FP), (R0, R1)\nLDPSW src+0(FP), (R2, R3)\nSTPW (R0, R1), ret+8(FP)\n",
+			params: []int64{0}, results: []int64{8},
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT span(SB),4,$0-32\n" + test.body + "RET\n"
+			requireFallbackARM64GoObject(t, source)
+			file, err := plan9asm.Parse(plan9asm.ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := fallbackSigForAsmFunc(file.Funcs[0], "span", "arm64")
+			for _, field := range []struct {
+				name  string
+				slots []plan9asm.FrameSlot
+				want  []int64
+			}{
+				{name: "params", slots: sig.Frame.Params, want: test.params},
+				{name: "results", slots: sig.Frame.Results, want: test.results},
+			} {
+				var offsets []int64
+				for _, slot := range field.slots {
+					offsets = append(offsets, slot.Offset)
+				}
+				if !reflect.DeepEqual(offsets, field.want) {
+					t.Fatalf("%s offsets=%v, want %v", field.name, offsets, field.want)
+				}
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+			} {
+				if _, err := plan9asm.Translate(file, plan9asm.Options{
+					Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]plan9asm.FuncSig{"span": sig},
+				}); err != nil {
+					t.Fatalf("%s: %v", triple, err)
+				}
+			}
+		})
+	}
+}
+
+func TestFallbackARM64PairCannotExpandADeclaredPaddingSlot(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM64,
+		"TEXT ·span(SB),4,$0-16\nLDP first+0(FP), (R0, R1)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	typesPkg := types.NewPackage("example.com/fpspan", "fpspan")
+	params := types.NewTuple(
+		types.NewVar(token.NoPos, typesPkg, "first", types.Typ[types.Uint64]),
+		types.NewVar(token.NoPos, typesPkg, "second", types.Typ[types.Uint32]),
+	)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "span",
+		types.NewSignatureType(nil, nil, nil, params, nil, false)))
+	pkg := &packages.Package{
+		PkgPath: typesPkg.Path(), Types: typesPkg,
+		TypesSizes: types.SizesFor("gc", "arm64"),
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = plan9asm.Translate(file, plan9asm.Options{
+		Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		Sigs: sigs, ResolveSym: resolve,
+	})
+	if err == nil || !strings.Contains(err.Error(), "has no slot at +12(FP)") {
+		t.Fatalf("declared padding must remain unaddressable: %v", err)
+	}
+}
+
+func TestFallbackARM64WideFrameCompilesWithLLVM22(t *testing.T) {
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const source = "TEXT span(SB),4,$0-40\n" +
+		"LDP first+0(FP), (R0, R1)\nLDP third+16(FP), (R2, R3)\n" +
+		"ADD R0, R1, R0\nADD R2, R0, R0\nADD R3, R0, R0\n" +
+		"MOVD R0, ret+32(FP)\nRET\n"
+	requireFallbackARM64GoObject(t, source)
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "span_arm64.s")
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath:    "example.com/fpspan",
+		Types:      types.NewPackage("example.com/fpspan", "fpspan"),
+		TypesSizes: types.SizesFor("gc", "arm64"),
+	}
+	for _, goos := range []string{"darwin", "linux", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			err := compileOne(pkg, plan9asm.ArchARM64, goos, "arm64", targetTriple(goos, "arm64"),
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: filepath.Join(dir, goos+".ll")},
+				false, config)
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	t.Run("native complete-argument oracle", func(t *testing.T) {
+		mode, err := fallbackARM64OracleExecution(runtime.GOOS, runtime.GOARCH, os.Getenv("PLAN9ASM_CROSS_EXEC"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if mode == "" {
+			t.Skip("host-inapplicable; the required Linux cross owner executes this same complete oracle")
+		}
+		const oracle = `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t span(uint64_t, uint64_t, uint64_t, uint64_t);
+int main(void) {
+    for (uint64_t i = 0; i < 512; i++) {
+        uint64_t a = UINT64_C(0xfedcba9876543210) ^ i;
+        uint64_t b = UINT64_C(0x13579bdf2468ace0) + i * 17;
+        uint64_t c = UINT64_C(0xa5a5a5a5a5a5a5a5) - i;
+        uint64_t d = UINT64_C(0x8000000000000001) ^ (i << 12);
+        uint64_t want = a + b + c + d;
+        uint64_t got = span(a, b, c, d);
+        if (got != want) {
+            fprintf(stderr, "four-word frame result differs at %llu\n", (unsigned long long)i);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+		main := filepath.Join(dir, "oracle.c")
+		if err := os.WriteFile(main, []byte(oracle), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		binary := filepath.Join(dir, "oracle")
+		linker, objectOS := "clang", runtime.GOOS
+		var emulator string
+		if mode == "cross" {
+			linker, objectOS = "aarch64-linux-gnu-gcc", "linux"
+			emulator, err = exec.LookPath("qemu-aarch64")
+			if err != nil {
+				t.Fatal("required pinned ARM64 emulator: ", err)
+			}
+			version, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), emulator, "--version")
+			if err != nil || !regexp.MustCompile(`(?m)^qemu-aarch64 version 10\.2\.3\b`).Match(version) {
+				t.Fatalf("required QEMU 10.2.3: %v\n%s%s", err, version, stderr)
+			}
+		}
+		linker, err = exec.LookPath(linker)
+		if err != nil {
+			t.Fatal("required oracle linker: ", err)
+		}
+		arguments := []string{"-O2", main, filepath.Join(dir, objectOS+".o"), "-o", binary}
+		if mode == "native" {
+			version, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), linker, "--version")
+			if err != nil || !regexp.MustCompile(`(?m)\bclang version 22\.`).Match(version) {
+				t.Fatalf("required LLVM 22 clang: %v\n%s%s", err, version, stderr)
+			}
+		}
+		if mode == "native" && runtime.GOOS == "darwin" {
+			flags, err := nativeoracle.DarwinClangFlags(arm64PrivateCLIContext(t), os.Environ())
+			if err != nil {
+				t.Fatal(err)
+			}
+			arguments = append(flags, arguments...)
+		}
+		if stdout, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), linker, arguments...); err != nil {
+			t.Fatalf("link complete inferred-argument oracle: %v\n%s%s", err, stdout, stderr)
+		}
+		executable, runArguments := binary, []string(nil)
+		if mode == "cross" {
+			executable, runArguments = emulator, []string{"-L", "/usr/aarch64-linux-gnu", binary}
+		}
+		if stdout, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), executable, runArguments...); err != nil {
+			t.Fatalf("execute complete inferred-argument oracle: %v\n%s%s", err, stdout, stderr)
+		}
+	})
+}
+
+func fallbackARM64OracleExecution(goos, goarch, cross string) (string, error) {
+	if cross != "" && cross != "0" && cross != "1" {
+		return "", fmt.Errorf("invalid PLAN9ASM_CROSS_EXEC value %q", cross)
+	}
+	if cross == "1" && (goos != "linux" || goarch != "amd64" && goarch != "arm64") {
+		return "", fmt.Errorf("required ARM64 cross execution needs Linux/amd64 or native Linux/arm64")
+	}
+	if goarch == "arm64" && (goos == "darwin" || goos == "linux") {
+		return "native", nil
+	}
+	if cross == "1" {
+		return "cross", nil
+	}
+	return "", nil
+}
+
+func requireFallbackARM64GoObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "span.s"), filepath.Join(dir, "span.o")
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	if stdout, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", "tool", "asm", "-o", object, asm); err != nil {
+		t.Fatalf("independent Go assembler rejected source: %v\n%s%s", err, stdout, stderr)
+	}
+	if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+		t.Fatalf("independent Go assembler did not emit an object: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_fp_padding_test.go b/cmd/plan9asmll/arm64_fp_padding_test.go
new file mode 100644
index 000000000..44ff49774
--- /dev/null
+++ b/cmd/plan9asmll/arm64_fp_padding_test.go
@@ -0,0 +1,82 @@
+package main
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestSigsForAsmFileARM64PaddingUsesActualCompleteDeclaration(t *testing.T) {
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, "p.go", "package p\nfunc Narrow(rhs int16) (res uint64)\n", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "arm64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("test/padding", fset, []*ast.File{parsed}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{PkgPath: typed.Path(), Types: typed, TypesSizes: sizes}
+	for _, observable := range []bool{false, true} {
+		body := "MOVD rhs+0(FP),R2\nMOVH R2,R0\nMOVD R0,res+8(FP)\n"
+		if observable {
+			body = "MOVD rhs+0(FP),R2\nMOVD R2,res+8(FP)\n"
+		}
+		file, err := plan9asm.Parse(plan9asm.ArchARM64, "TEXT ·Narrow(SB),4,$0-16\n"+body+"RET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		resolve := resolveSymFunc(pkg.PkgPath)
+		sigs, declared, err := sigsForAsmFile(pkg, file, resolve, "arm64")
+		if err != nil || declared[typed.Path()+".Narrow"] != 16 {
+			t.Fatalf("complete selected declaration/layout: %v; sizes=%v", err, declared)
+		}
+		_, err = plan9asm.Translate(file, plan9asm.Options{
+			Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", Sigs: sigs, ResolveSym: resolve,
+		})
+		if observable {
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("actual declaration authorized observable native padding: %v", err)
+			}
+		} else if err != nil {
+			t.Fatalf("CLI lost actual typed input for dead padding bits: %v", err)
+		}
+	}
+}
+
+func TestSigsForAsmFileARM64PaddingCannotChangeZeroSizedTransport(t *testing.T) {
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, "p.go", "package p\nfunc Narrow(empty [0]byte, rhs int16) (res uint64)\n", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "arm64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("test/padding", fset, []*ast.File{parsed}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(typed.Path())
+	sig, _, found, err := tryDeclSig(typed.Scope(), "·Narrow", typed.Path()+".Narrow", nil, "arm64", sizes, false)
+	if err != nil || !found || len(sig.Args) != 1 || sig.Args[0] != plan9asm.I16 {
+		t.Fatalf("read certificate changed existing zero-size transport: %#v; %v", sig, err)
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchARM64, "TEXT ·Narrow(SB),4,$0-16\nMOVD rhs+0(FP),R2\nMOVH R2,R0\nMOVD R0,res+8(FP)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = plan9asm.Translate(file, plan9asm.Options{
+		Goarch: "arm64", TargetTriple: "aarch64-unknown-linux-gnu", ResolveSym: resolve,
+		Sigs: map[string]plan9asm.FuncSig{sig.Name: sig},
+	})
+	if err == nil || !strings.Contains(err.Error(), "has no slot") {
+		t.Fatalf("incongruent actual/CLI parameter indexing gained padding authority: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_go_register_abi_test.go b/cmd/plan9asmll/arm64_go_register_abi_test.go
new file mode 100644
index 000000000..ba91fc195
--- /dev/null
+++ b/cmd/plan9asmll/arm64_go_register_abi_test.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestSigsForAsmFileARM64GoInternalSourceContract(t *testing.T) {
+	for _, overflow := range []bool{false, true} {
+		declarations := "package p\nfunc Count([]byte,byte) int\nfunc CountString(string,byte) int\nfunc Classic(uint64) uint64\nfunc Zero() uint64\n"
+		source := "TEXT ·Count<ABIInternal>(SB),4,$0-40\nMOVD R3,R2\nB ·CountString<ABIInternal>(SB)\nTEXT ·CountString<ABIInternal>(SB),4,$0-32\nRET\nTEXT ·Classic(SB),4,$0-16\nCALL ·Zero<ABIInternal>(SB)\nRET\n"
+		if overflow {
+			declarations += "func Spill(" + strings.TrimSuffix(strings.Repeat("uint64,", 17), ",") + ") uint64\n"
+			source += "TEXT ·Forward(SB),4,$0\nCALL ·Spill<ABIInternal>(SB)\nRET\n"
+			declarations += "func Forward()\n"
+		}
+		fset := token.NewFileSet()
+		parsed, err := parser.ParseFile(fset, "p.go", declarations, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		typesPkg, err := new(types.Config).Check("test/internalcontract", fset, []*ast.File{parsed}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		pkg := &packages.Package{PkgPath: typesPkg.Path(), Types: typesPkg, TypesSizes: types.SizesFor("gc", "arm64")}
+		file, err := plan9asm.Parse(plan9asm.ArchARM64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "arm64")
+		if overflow {
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("explicit referenced stack contract lost its error: %v", err)
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		for name, params := range map[string]int{"Count": 4, "CountString": 3, "Zero": 0} {
+			contract := sigs[typesPkg.Path()+"."+name].ARM64GoRegisterABI
+			if contract == nil || len(contract.Params) != params || len(contract.Results) != 1 {
+				t.Fatalf("%s: missing complete source-derived contract: %+v", name, contract)
+			}
+		}
+		if sigs[typesPkg.Path()+".Classic"].ARM64GoRegisterABI != nil {
+			t.Fatal("classic declaration invented an internal entry")
+		}
+	}
+}
diff --git a/cmd/plan9asmll/arm64_named_fields_extraction_test.go b/cmd/plan9asmll/arm64_named_fields_extraction_test.go
new file mode 100644
index 000000000..4d8634030
--- /dev/null
+++ b/cmd/plan9asmll/arm64_named_fields_extraction_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsNamedARM64MoveWideAndBitfield(t *testing.T) {
+	const filename = "arm64_named_gp_fields.go"
+	data, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, contents := range map[string][]byte{filename: data, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(directory, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{directory, "../.."} {
+		for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"MOVZ", "MOVZW", "MOVN", "MOVNW", "BFM", "BFMW", "SBFM", "SBFMW", "UBFM", "UBFMW"} {
+				if _, found := supported[op]; found != (arch == "arm64") {
+					t.Error("named family lost its architecture-scoped opcode", root, arch, op, found)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/arm64_native_scratch_closure_go127_test.go b/cmd/plan9asmll/arm64_native_scratch_closure_go127_test.go
new file mode 100644
index 000000000..bc2a389d9
--- /dev/null
+++ b/cmd/plan9asmll/arm64_native_scratch_closure_go127_test.go
@@ -0,0 +1,175 @@
+//go:build go1.27
+
+package main
+
+import (
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// These are original, first-party ABI0 source bodies, not replacements for a
+// downloaded library. Every positive needs an actual selected-package/native
+// closure producer; a declaration alone is deliberately insufficient.
+func arm64NativeScratchClosureSource(callee string) string {
+	return `#include "textflag.h"
+TEXT ·Scratch(SB),0,$32904-16
+    MOVD n+0(FP),R1
+    MOVD R1,8(RSP)
+    CALL ·Value(SB)
+    MOVD 16(RSP),R2
+    MOVD R2,ret+8(FP)
+    RET
+` + callee
+}
+
+func arm64NativeScratchClosureFixture(t *testing.T, source, declarations string) (*packages.Package, string, compileConfig) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, data := range map[string]string{
+		"go.mod":        "module example.invalid/scratchclosure\n\ngo 1.20\n",
+		"value.go":      "package scratchclosure\n" + declarations + "\nfunc Scratch(n uint64) uint64\n",
+		"value_arm64.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	context := arm64PrivateCLIContext(t)
+	environment, err := ordinaryPackageEnvironment("linux", "arm64", append(os.Environ(), "CGO_ENABLED=0",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=", "GOTOOLCHAIN=local", "GOPACKAGESDRIVER=off"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := gotoolprofile.RunBounded(context, directory, environment, "go",
+		"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual original package export: %v\n%s%s", err, stdout, stderr)
+	}
+	t.Logf("original source SHA256=%x; actual original Go package selection:\n%s", sha256.Sum256([]byte(source)), stdout)
+	selected, err := packages.Load(&packages.Config{
+		Context: context, Dir: directory, Env: environment,
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+			packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax,
+	}, ".")
+	if err != nil || len(selected) != 1 || len(selected[0].Errors) != 0 || selected[0].IllTyped {
+		t.Fatalf("actual complete source load: %v; %+v", err, selected)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = context
+	config.x86CallerSelections = captureX86CallerSelectionsInEnvironment(selected, "linux/arm64", environment)
+	input := filepath.Join(directory, "value_arm64.s")
+	object := filepath.Join(directory, "original.o")
+	listing, stderr, err := gotoolprofile.RunBounded(context, directory, environment, "go",
+		"tool", "asm", "-S", "-p", selected[0].PkgPath, "-I", directory,
+		"-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-o", object, input)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual original native source/object: %v\n%s%s", err, listing, stderr)
+	}
+	t.Logf("actual original Go assembly listing:\n%s", listing)
+	return selected[0], input, config
+}
+
+func TestCompileOneARM64NativeScratchClosedCalleeFamily(t *testing.T) {
+	for _, test := range []struct {
+		name, body, declarations string
+	}{
+		{
+			name: "scalar_gp",
+			body: `TEXT ·Value(SB),NOSPLIT,$0-16
+    MOVD n+0(FP),R1
+    ADD $1,R1
+    MOVD R1,ret+8(FP)
+    RET
+`,
+			declarations: "func Value(n uint64) uint64\n",
+		},
+		{
+			name: "bounded_local_pair",
+			body: `TEXT ·Value(SB),NOSPLIT,$32-16
+    MOVD n+0(FP),R1
+    MOVD $7,R2
+    STP (R1,R2),16(RSP)
+    LDP 16(RSP),(R3,R4)
+    ADD R4,R3
+    MOVD R3,ret+8(FP)
+    RET
+`,
+			declarations: "func Value(n uint64) uint64\n",
+		},
+		{
+			name: "full_cfg",
+			body: `TEXT ·Value(SB),NOSPLIT,$0-16
+    MOVD n+0(FP),R1
+    CBZ R1,zero
+    SUB $1,R1
+    B done
+zero:
+    MOVD $9,R1
+done:
+    MOVD R1,ret+8(FP)
+    RET
+`,
+			declarations: "func Value(n uint64) uint64\n",
+		},
+		{
+			name: "transitive_same_package",
+			body: `TEXT ·Value(SB),NOSPLIT,$24-16
+    MOVD n+0(FP),R1
+    MOVD R1,8(RSP)
+    CALL ·Leaf(SB)
+    MOVD 16(RSP),R2
+    MOVD R2,ret+8(FP)
+    RET
+TEXT ·Leaf(SB),NOSPLIT,$0-16
+    MOVD n+0(FP),R1
+    ADD $3,R1
+    MOVD R1,ret+8(FP)
+    RET
+`,
+			declarations: "func Value(n uint64) uint64\nfunc Leaf(n uint64) uint64\n",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := arm64NativeScratchClosureSource(test.body)
+			pkg, input, config := arm64NativeScratchClosureFixture(t, source, test.declarations)
+			output := filepath.Join(t.TempDir(), "closed.ll")
+			if err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatalf("complete original source/native closure lacks its producer/consumer: %v", err)
+			}
+			if info, err := os.Lstat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("closed callee did not produce its eligible LLVM22 object: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneARM64NativeScratchUnknownExternalRemainsContext(t *testing.T) {
+	source := arm64NativeScratchClosureSource("")
+	pkg, input, config := arm64NativeScratchClosureFixture(t, source, "func Value(n uint64) uint64\n")
+	output := filepath.Join(t.TempDir(), "unbound.ll")
+	err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+	if err == nil || !strings.Contains(err.Error(), "unbound original Go memory scratch") {
+		t.Fatalf("unbound external source borrowed a declaration as a scratch certificate: %v", err)
+	}
+	if _, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); !os.IsNotExist(err) {
+		t.Fatalf("unbound source acquired an eligible LLVM object: %v", err)
+	}
+	t.Logf("retained precise Context: %v", err)
+}
diff --git a/cmd/plan9asmll/arm64_native_scratch_sdk_go127_test.go b/cmd/plan9asmll/arm64_native_scratch_sdk_go127_test.go
new file mode 100644
index 000000000..2a5049234
--- /dev/null
+++ b/cmd/plan9asmll/arm64_native_scratch_sdk_go127_test.go
@@ -0,0 +1,39 @@
+//go:build go1.27
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCompileOneARM64NativeScratchActualSDKWrapperAndBody(t *testing.T) {
+	// This is first-party original source. The SDK dependency is selected by
+	// stock Go, including its real declaration, ABI wrapper and assembly body;
+	// an empty/default external FuncSig cannot describe this three-word call.
+	source := arm64NativeScratchClosureSource(`TEXT ·Value(SB),NOSPLIT,$40-16
+    MOVD $0,R1
+    MOVD R1,8(RSP)
+    MOVD R1,16(RSP)
+    MOVD R1,24(RSP)
+    CALL runtime·memmove(SB)
+    MOVD $11,R1
+    MOVD R1,ret+8(FP)
+    RET
+`)
+	pkg, input, config := arm64NativeScratchClosureFixture(t, source,
+		"import _ \"runtime\"\nfunc Value(n uint64) uint64\n")
+	output := filepath.Join(t.TempDir(), "sdk.ll")
+	if err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatalf("actual whole SDK body must define its scratch before any read and retain its real ABI0 wrapper tuple: %v", err)
+	}
+	object := strings.TrimSuffix(output, ".ll") + ".o"
+	if info, err := os.Lstat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("actual SDK source closure produced no eligible LLVM object: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_native_scratch_source.go b/cmd/plan9asmll/arm64_native_scratch_source.go
new file mode 100644
index 000000000..c1a74e949
--- /dev/null
+++ b/cmd/plan9asmll/arm64_native_scratch_source.go
@@ -0,0 +1,76 @@
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func prepareARM64NativeScratchSource(pkg *packages.Package, file *plan9asm.File, asm, target, triple string,
+	config compileConfig, resolve func(string) string, sigs map[string]plan9asm.FuncSig,
+) (map[string]plan9asm.FuncSig, *plan9asm.GoARM64ScratchSource, error) {
+	if !plan9asm.GoARM64ScratchBindingNeeded(file) {
+		return sigs, nil, nil
+	}
+	selected := config.x86CallerSelections[pkg]
+	if pkg == nil || selected == nil || !selected.ready || selected.target != target || selected.mode != nil ||
+		selected.types != pkg.Types || selected.identity == "" || selected.identity != x86CallerSelectionIdentity(pkg, selected.env) ||
+		!reflect.DeepEqual(selected.sizes, x86CallerSizes(pkg.TypesSizes)) {
+		return nil, nil, fmt.Errorf("%w: native scratch closure needs unchanged ordinary actual package-load identity", plan9asm.ErrProbeNeedsContext)
+	}
+	values := make(map[string]string)
+	for _, item := range selected.env {
+		key, value, valid := strings.Cut(item, "=")
+		if !valid || key == "" {
+			return nil, nil, fmt.Errorf("malformed actual native scratch environment")
+		}
+		values[key] = value
+	}
+	var env []string
+	for key, value := range values {
+		env = append(env, key+"="+value)
+	}
+	sort.Strings(env)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	directory, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil {
+		return nil, nil, err
+	}
+	original, err := sourcepath.Resolve(asm)
+	if err != nil || filepath.Dir(original) != directory {
+		return nil, nil, fmt.Errorf("%w: native scratch original assembly root changed", plan9asm.ErrProbeNeedsContext)
+	}
+	source, err := plan9asm.CaptureGoARM64ScratchSource(config.Context,
+		plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Syntax: pkg.Syntax},
+		plan9asm.GoARM64ScratchCaptureRequest{GoBinary: binary, Directory: directory, AssemblyFile: filepath.Base(original), Target: target, Environment: env})
+	if err != nil {
+		return nil, nil, err
+	}
+	bound, err := source.BindScratchClosure(config.Context, file, plan9asm.Options{Goarch: "arm64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs})
+	if err != nil {
+		closeErr := source.Close()
+		if closeErr != nil {
+			return nil, nil, fmt.Errorf("%w; cleanup: %v", err, closeErr)
+		}
+		return nil, nil, err
+	}
+	return bound.Sigs, source, nil
+}
diff --git a/cmd/plan9asmll/arm64_private_source_go127_test.go b/cmd/plan9asmll/arm64_private_source_go127_test.go
new file mode 100644
index 000000000..790cada15
--- /dev/null
+++ b/cmd/plan9asmll/arm64_private_source_go127_test.go
@@ -0,0 +1,69 @@
+//go:build go1.27
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCompileOneCurrentGoARM64PrivateP256Source(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src", "crypto", "internal", "fips140", "nistec", "p256_asm_arm64.s")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	whole := string(data)
+	first := strings.Index(whole, "TEXT ")
+	if first < 0 {
+		t.Fatal("original Go source has no TEXT")
+	}
+	extract := func(header string) string {
+		start := strings.Index(whole, header)
+		if start < 0 {
+			t.Fatalf("original Go source has no %q", header)
+		}
+		body := whole[start:]
+		if end := strings.Index(body[1:], "\nTEXT "); end >= 0 {
+			body = body[:end+1]
+		}
+		return body
+	}
+	source := whole[:first] + extract("TEXT ·p256Sqr(SB)") + "\n" + extract("TEXT p256SqrInternal<>(SB)")
+	requireARM64PrivateCLIOriginalObject(t, source)
+	pkg, input := arm64PrivateCLIPackage(t,
+		"package p\nfunc p256Sqr(*[4]uint64,*[4]uint64,int)\n", source)
+	for _, target := range []struct{ os, triple string }{
+		{"darwin", "aarch64-apple-darwin"},
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"linux", "aarch64-unknown-linux-musl"},
+		{"freebsd", "aarch64-unknown-freebsd"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			config, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = arm64PrivateCLIContext(t)
+			output := filepath.Join(t.TempDir(), "original-p256.ll")
+			if err := compileOne(pkg, plan9asm.ArchARM64, target.os, "arm64", target.triple,
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatal(err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || strings.Count(string(ir), "define ") != 1 {
+				t.Fatalf("original source continuation did not stay with p256Sqr: %v", err)
+			}
+			object := strings.TrimSuffix(output, ".ll") + ".o"
+			if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+				t.Fatalf("original p256Sqr did not produce a real LLVM22 object: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/arm64_private_source_native_test.go b/cmd/plan9asmll/arm64_private_source_native_test.go
new file mode 100644
index 000000000..db18de3b7
--- /dev/null
+++ b/cmd/plan9asmll/arm64_private_source_native_test.go
@@ -0,0 +1,116 @@
+//go:build arm64 && (darwin || linux)
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+func TestCompileOneARM64PrivateSourceNativeNumericalOracle(t *testing.T) {
+	const declaration = "package p\nfunc Run(uint64) uint64\n"
+	pkg, input := arm64PrivateCLIPackage(t, declaration, arm64PrivateCLISource)
+	dir := t.TempDir()
+	const goMain = `package main
+func Run(uint64) uint64
+func main() {
+    for _, x := range []uint64{0, 1, 123, 0x8000000000000000, ^uint64(0)} {
+        y := x + 1
+        if x == ^uint64(0) { y++ }
+        if Run(x) != (x*y)^7 { panic("original source continuation result differs") }
+    }
+}
+`
+	for name, contents := range map[string]string{
+		"go.mod":  "module originalcontinuation\n\ngo 1.20\n",
+		"main.go": goMain, "original_arm64.s": arm64PrivateCLISource,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	env := append(os.Environ(), "GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0")
+	original := filepath.Join(dir, "original")
+	stdout, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, env,
+		"go", "build", "-p=2", "-o", original, ".")
+	if err != nil {
+		t.Fatalf("build actual original Go source: %v\n%s%s", err, stdout, stderr)
+	}
+	stdout, stderr, err = gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, env, original)
+	if err != nil {
+		t.Fatalf("execute actual original Go source: %v\n%s%s", err, stdout, stderr)
+	}
+
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = arm64PrivateCLIContext(t)
+	output := filepath.Join(dir, "private.ll")
+	if err := compileOne(pkg, plan9asm.ArchARM64, runtime.GOOS, "arm64", targetTriple(runtime.GOOS, "arm64"),
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	clang, err := exec.LookPath("clang")
+	if err != nil {
+		t.Fatal("LLVM22 clang required:", err)
+	}
+	stdout, stderr, err = gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), clang, "--version")
+	if err != nil || !regexp.MustCompile(`\bclang version 22\.`).Match(stdout) {
+		t.Fatalf("LLVM22 clang required: %v\n%s%s", err, stdout, stderr)
+	}
+	label := pkg.PkgPath + ".Run"
+	if runtime.GOOS == "darwin" {
+		label = "_" + label
+	}
+	main := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern uint64_t Source(uint64_t) __asm__(%q);
+int main(void) {
+    uint64_t rows[] = {0, 1, 123, UINT64_C(0x8000000000000000), UINT64_MAX};
+    for (unsigned i = 0; i < sizeof(rows) / sizeof(rows[0]); i++) {
+        uint64_t x = rows[i];
+        uint64_t y = x + 1 + (x == UINT64_MAX);
+        uint64_t want = (x * y) ^ 7;
+        uint64_t got = Source(x);
+        if (got != want) {
+            fprintf(stderr, "source continuation differs at row %%u\n", i);
+            return 1;
+        }
+    }
+    return 0;
+}
+`, label)
+	mainPath, binary := filepath.Join(dir, "oracle.c"), filepath.Join(dir, "translated")
+	if err := os.WriteFile(mainPath, []byte(main), 0600); err != nil {
+		t.Fatal(err)
+	}
+	object := strings.TrimSuffix(output, ".ll") + ".o"
+	arguments := []string{"-O2", mainPath, object, "-o", binary}
+	if runtime.GOOS == "darwin" {
+		flags, err := nativeoracle.DarwinClangFlags(arm64PrivateCLIContext(t), os.Environ())
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(flags, arguments...)
+	}
+	stdout, stderr, err = gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(),
+		clang, arguments...)
+	if err != nil {
+		t.Fatalf("link actual translated source: %v\n%s%s", err, stdout, stderr)
+	}
+	stdout, stderr, err = gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, os.Environ(), binary)
+	if err != nil {
+		t.Fatalf("execute actual translated source: %v\n%s%s", err, stdout, stderr)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_private_source_test.go b/cmd/plan9asmll/arm64_private_source_test.go
new file mode 100644
index 000000000..932e079a2
--- /dev/null
+++ b/cmd/plan9asmll/arm64_private_source_test.go
@@ -0,0 +1,189 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+const arm64PrivateCLISource = `DATA constant<>(SB)/8,$7
+GLOBL constant<>(SB),8,$8
+TEXT ·Run(SB),4,$0-16
+MOVD x+0(FP),R19
+MOVD constant<>(SB),R0
+ADDS $1,R19,R9
+CALL mix<>(SB)
+EOR R0,R20
+MOVD R20,ret+8(FP)
+RET
+TEXT mix<>(SB),4,$0-0
+ADC $0,R9,R20
+MUL R19,R20,R20
+RET
+`
+
+func arm64PrivateCLIPackage(t *testing.T, declaration, source string) (*packages.Package, string) {
+	t.Helper()
+	dir := t.TempDir()
+	goPath, asmPath := filepath.Join(dir, "p.go"), filepath.Join(dir, "p_arm64.s")
+	for path, contents := range map[string]string{goPath: declaration, asmPath: source} {
+		if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, goPath, declaration, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config := types.Config{Sizes: types.SizesFor("gc", "arm64")}
+	typed, err := config.Check("example.com/privatearm64", fset, []*ast.File{parsed}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return &packages.Package{
+		PkgPath: typed.Path(), Types: typed, TypesSizes: config.Sizes,
+		GoFiles: []string{goPath}, CompiledGoFiles: []string{goPath},
+	}, asmPath
+}
+
+func arm64PrivateCLIContext(t *testing.T) context.Context {
+	t.Helper()
+	deadline := time.Now().Add(5 * time.Minute)
+	if testDeadline, present := t.Deadline(); present && testDeadline.Add(-3*time.Second).Before(deadline) {
+		deadline = testDeadline.Add(-3 * time.Second)
+	}
+	ctx, cancel := context.WithDeadline(context.Background(), deadline)
+	t.Cleanup(cancel)
+	return ctx
+}
+
+func requireARM64PrivateCLIOriginalObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "original.s"), filepath.Join(dir, "original.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=arm64", "GOTOOLCHAIN=local")
+	stdout, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), dir, env,
+		"go", "tool", "asm", "-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-o", object, input)
+	if err != nil {
+		t.Fatalf("original Go assembler: %v\n%s%s", err, stdout, stderr)
+	}
+	if info, err := os.Stat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("original Go did not produce a nonempty object: %v", err)
+	}
+}
+
+func TestCompileOneARM64PrivateRegisterSource(t *testing.T) {
+	requireARM64PrivateCLIOriginalObject(t, arm64PrivateCLISource)
+	pkg, input := arm64PrivateCLIPackage(t, "package p\nfunc Run(uint64) uint64\n", arm64PrivateCLISource)
+	for _, target := range []struct{ name, os, triple string }{
+		{"darwin", "darwin", "aarch64-apple-darwin"},
+		{"linux", "linux", "aarch64-unknown-linux-gnu"},
+		{"linux_musl", "linux", "aarch64-unknown-linux-musl"},
+		{"freebsd", "freebsd", "aarch64-unknown-freebsd"},
+		{"windows", "windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			config, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context = arm64PrivateCLIContext(t)
+			output := filepath.Join(t.TempDir(), "private.ll")
+			if err := compileOne(pkg, plan9asm.ArchARM64, target.os, "arm64", target.triple,
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatal(err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(string(ir), "@\""+pkg.PkgPath+".mix$local\"") ||
+				strings.Count(string(ir), "define ") != 1 || !strings.Contains(string(ir), "\nbb__5f_5farm64_5fprivate_5f") {
+				t.Fatalf("private helper was not kept in its source caller's CFG:\n%s", ir)
+			}
+			object := strings.TrimSuffix(output, ".ll") + ".o"
+			if info, err := os.Stat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 did not produce a nonempty %s object: %v", target.name, err)
+			}
+		})
+	}
+}
+
+func TestCompileOneARM64PrivateSourceBeforeModuleSplit(t *testing.T) {
+	source := arm64PrivateCLISource + strings.Replace(arm64PrivateCLISource[strings.Index(arm64PrivateCLISource, "TEXT ·Run"):strings.Index(arm64PrivateCLISource, "TEXT mix")],
+		"·Run", "·Other", 1)
+	requireARM64PrivateCLIOriginalObject(t, source)
+	pkg, input := arm64PrivateCLIPackage(t,
+		"package p\nfunc Run(uint64) uint64\nfunc Other(uint64) uint64\n", source)
+	config, err := resolveCompileConfig(true, "", false, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions, config.MaxInstructions = 1, 1
+	config.Context = arm64PrivateCLIContext(t)
+	output := filepath.Join(t.TempDir(), "private.ll")
+	if err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	for _, filename := range []string{output, strings.TrimSuffix(output, ".ll") + ".part-0001.ll"} {
+		ir, err := os.ReadFile(filename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Count(string(ir), "define ") != 1 || !strings.Contains(string(ir), "\nbb__5f_5farm64_5fprivate_5f") {
+			t.Fatalf("chunk lost its closed private source: %s", filename)
+		}
+		if _, err := os.Stat(strings.TrimSuffix(filename, ".ll") + ".o"); !os.IsNotExist(err) {
+			t.Fatalf("temporary chunk object was not released: %v", err)
+		}
+	}
+}
+
+func TestCompileOneARM64PrivateSourceRejectsHiddenEscape(t *testing.T) {
+	for _, test := range []struct{ name, suffix string }{
+		{"late_address", "TEXT ·Other(SB),4,$0-0\nMOVD $mix<>(SB),R0\nRET\n"},
+		{"data_address", "DATA pointer<>(SB)/8,$mix<>(SB)\nGLOBL pointer<>(SB),8,$8\n"},
+		{"non_call", "TEXT ·Other(SB),4,$0-0\nB mix<>(SB)\n"},
+		{"native_pc", "TEXT ·Other(SB),4,$0-0\nADR 4(PC),R0\nRET\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := arm64PrivateCLISource + test.suffix
+			requireARM64PrivateCLIOriginalObject(t, source)
+			pkg, input := arm64PrivateCLIPackage(t,
+				"package p\nfunc Run(uint64) uint64\nfunc Other()\n", source)
+			config, err := resolveCompileConfig(true, "", false, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.MaxFunctions, config.MaxInstructions = 1, 1
+			config.Context = arm64PrivateCLIContext(t)
+			output := filepath.Join(t.TempDir(), "private.ll")
+			err = compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("unproved private/native source was not rejected: %v", err)
+			}
+			if _, err := os.Stat(output); !os.IsNotExist(err) {
+				t.Fatalf("unsafe full-file contract emitted an earlier chunk: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/arm64_private_tail_source_test.go b/cmd/plan9asmll/arm64_private_tail_source_test.go
new file mode 100644
index 000000000..099a9f2b9
--- /dev/null
+++ b/cmd/plan9asmll/arm64_private_tail_source_test.go
@@ -0,0 +1,97 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+const arm64PrivateTailCLISource = `TEXT ·Read<ABIInternal>(SB),516,$0-16
+B readbody<>(SB)
+TEXT ·Other<ABIInternal>(SB),516,$0-16
+B readbody<>(SB)
+TEXT readbody<>(SB),516,$0
+CBZ R0,empty
+MOVD (R0),R0
+RET
+empty:
+MOVD $0,R0
+RET
+`
+
+func TestCompileOneARM64PrivateTailSource(t *testing.T) {
+	pkg, input := arm64PrivateCLIPackage(t,
+		"package p\nfunc Read(*uint64) uint64\nfunc Other(*uint64) uint64\n", arm64PrivateTailCLISource)
+	for _, target := range []struct{ os, triple string }{
+		{"darwin", "aarch64-apple-darwin"}, {"linux", "aarch64-unknown-linux-gnu"},
+		{"linux", "aarch64-unknown-linux-musl"}, {"freebsd", "aarch64-unknown-freebsd"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, keep := range []bool{false, true} {
+				mode := "chunks"
+				if keep {
+					mode = "complete-object"
+				}
+				t.Run(mode, func(t *testing.T) {
+					config, err := resolveCompileConfig(true, "", keep, 2)
+					if err != nil {
+						t.Fatal(err)
+					}
+					config.MaxFunctions, config.MaxInstructions = 1, 1
+					config.Context = arm64PrivateCLIContext(t)
+					output := filepath.Join(t.TempDir(), "tail.ll")
+					if err := compileOne(pkg, plan9asm.ArchARM64, target.os, "arm64", target.triple,
+						asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+						t.Fatal(err)
+					}
+					files, definitions := []string{output}, 2
+					if !keep {
+						files = append(files, strings.TrimSuffix(output, ".ll")+".part-0001.ll")
+						definitions = 1
+					}
+					for _, filename := range files {
+						ir, err := os.ReadFile(filename)
+						if err != nil || strings.Count(string(ir), "define ") != definitions || !strings.Contains(string(ir), "\nbb__5f_5farm64_5ftail_5f") {
+							t.Fatalf("CLI %s lost the complete typed continuation: %v", mode, err)
+						}
+						object := strings.TrimSuffix(filename, ".ll") + ".o"
+						info, err := os.Stat(object)
+						if keep {
+							if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+								t.Fatalf("LLVM22 did not compile the complete tail %s object: %v", target.triple, err)
+							}
+						} else if !os.IsNotExist(err) {
+							t.Fatalf("compiled temporary chunk object was not removed: %v", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestCompileOneARM64PrivateTailCannotHideNativeUse(t *testing.T) {
+	source := arm64PrivateTailCLISource + "DATA address<>(SB)/8,$readbody<>+4(SB)\nGLOBL address<>(SB),8,$8\n"
+	pkg, input := arm64PrivateCLIPackage(t,
+		"package p\nfunc Read(*uint64) uint64\nfunc Other(*uint64) uint64\n", source)
+	config, err := resolveCompileConfig(true, "", false, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions, config.MaxInstructions = 1, 1
+	config.Context = arm64PrivateCLIContext(t)
+	output := filepath.Join(t.TempDir(), "unsafe.ll")
+	err = compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("a later native address use escaped the complete-file preflight: %v", err)
+	}
+	if _, err := os.Stat(output); !os.IsNotExist(err) {
+		t.Fatalf("failed whole-source proof emitted an earlier chunk: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/arm64_rndr_consumers_test.go b/cmd/plan9asmll/arm64_rndr_consumers_test.go
new file mode 100644
index 000000000..0cfd72b0d
--- /dev/null
+++ b/cmd/plan9asmll/arm64_rndr_consumers_test.go
@@ -0,0 +1,16 @@
+package main
+
+import "testing"
+
+func TestExtractSupportedOpsARM64RandomRegisterCarriers(t *testing.T) {
+	supported, err := extractSupportedOps("../..", "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// RNDR/RNDRRS are system-register operands, not independent mnemonics.
+	for _, operation := range []string{"MRS", "MOVD", "WORD"} {
+		if _, present := supported[operation]; !present {
+			t.Errorf("RNG source carrier lost supported-op extraction: %s", operation)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/arm64_scalar_binary_specs_test.go b/cmd/plan9asmll/arm64_scalar_binary_specs_test.go
new file mode 100644
index 000000000..489df9a3a
--- /dev/null
+++ b/cmd/plan9asmll/arm64_scalar_binary_specs_test.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsARM64ScalarBinarySpec(t *testing.T) {
+	const filename = "arm64_scalar_binary.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, contents := range map[string][]byte{filename: source, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(isolated, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, "../.."} {
+		for _, arch := range []string{"arm64", "arm", "amd64", "386", "wasm"} {
+			// Other architectures may legitimately own the same spelling in
+			// their independent tables. Isolation proves this map cannot leak.
+			if root == "../.." && arch != "arm64" {
+				continue
+			}
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, operation := range []string{"FADDS", "FADDD", "FSUBS", "FSUBD", "FMULS", "FMULD", "FNMULS", "FNMULD", "FDIVS", "FDIVD"} {
+				_, present := supported[operation]
+				if present != (arch == "arm64") {
+					t.Errorf("%s %s extraction %s present=%t", root, arch, operation, present)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/assembly_member.go b/cmd/plan9asmll/assembly_member.go
new file mode 100644
index 000000000..20b68c2a6
--- /dev/null
+++ b/cmd/plan9asmll/assembly_member.go
@@ -0,0 +1,151 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync/atomic"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// actualAssemblyMember joins a request to one already selected source. It does
+// not alter the compiler inventory or grant a declaration/body permission.
+type actualAssemblyMember struct {
+	self          *actualAssemblyMember
+	requested     string
+	selected      string
+	physical      string
+	file          os.FileInfo
+	requestedNode os.FileInfo
+	selectedNode  os.FileInfo
+	directories   []assemblyMemberDirectory
+	revoked       atomic.Bool
+}
+
+type assemblyMemberDirectory struct {
+	path     string
+	physical string
+	info     os.FileInfo
+}
+
+func actualAssemblyMemberError() error {
+	return fmt.Errorf("%w: missing, redirected, or ambiguous actual selected assembly member", plan9asm.ErrProbeNeedsContext)
+}
+
+func observeActualAssemblyMember(requested string, selected []string) (*actualAssemblyMember, error) {
+	// The consuming ARM64 actual-load role already bounds OtherFiles at 512.
+	if requested == "" || filepath.Ext(requested) != ".s" || len(selected) > 512 {
+		return nil, actualAssemblyMemberError()
+	}
+	abs, err := filepath.Abs(requested)
+	if err != nil {
+		return nil, actualAssemblyMemberError()
+	}
+	info, err := sourcepath.Lstat(abs)
+	if err != nil {
+		return nil, actualAssemblyMemberError()
+	}
+	physical, err := sourcepath.Resolve(abs)
+	if err != nil {
+		return nil, actualAssemblyMemberError()
+	}
+	targetInfo, err := sourcepath.Lstat(physical)
+	if err != nil || !targetInfo.Mode().IsRegular() {
+		return nil, actualAssemblyMemberError()
+	}
+	member := &actualAssemblyMember{requested: abs, physical: physical, file: targetInfo, requestedNode: info}
+	for _, filename := range selected {
+		if filepath.Ext(filename) != ".s" {
+			continue
+		}
+		resolved, err := sourcepath.Resolve(filename)
+		if err != nil {
+			return nil, actualAssemblyMemberError()
+		}
+		if resolved != physical {
+			continue
+		}
+		selectedInfo, err := sourcepath.Lstat(filename)
+		if err != nil || member.selected != "" {
+			return nil, actualAssemblyMemberError()
+		}
+		member.selected = filename // Retain the exact compiler-inventory key.
+		member.selectedNode = selectedInfo
+	}
+	if member.selected == "" {
+		return nil, actualAssemblyMemberError()
+	}
+	seen := make(map[string]bool)
+	for _, filename := range []string{abs, member.selected} {
+		for directory := filepath.Dir(filename); ; directory = filepath.Dir(directory) {
+			if !seen[directory] {
+				if len(member.directories) >= 512 {
+					return nil, actualAssemblyMemberError()
+				}
+				info, err := sourcepath.Lstat(directory)
+				if err != nil {
+					return nil, actualAssemblyMemberError()
+				}
+				physical, err := sourcepath.Resolve(directory)
+				if err != nil {
+					return nil, actualAssemblyMemberError()
+				}
+				resolvedInfo, err := sourcepath.Lstat(physical)
+				if err != nil || !resolvedInfo.IsDir() {
+					return nil, actualAssemblyMemberError()
+				}
+				member.directories = append(member.directories, assemblyMemberDirectory{directory, physical, info})
+				seen[directory] = true
+			}
+			if filepath.Dir(directory) == directory {
+				break
+			}
+		}
+	}
+	member.self = member
+	if err := member.verify(); err != nil {
+		return nil, err
+	}
+	return member, nil
+}
+
+func (member *actualAssemblyMember) verify() error {
+	if member == nil || member.self != member || member.revoked.Load() {
+		return actualAssemblyMemberError()
+	}
+	fail := func() error {
+		member.revoked.Store(true)
+		return actualAssemblyMemberError()
+	}
+	for index, filename := range []string{member.requested, member.selected} {
+		physical, err := sourcepath.Resolve(filename)
+		if err != nil || physical != member.physical {
+			return fail()
+		}
+		info, err := sourcepath.Lstat(filename)
+		node := member.requestedNode
+		if index == 1 {
+			node = member.selectedNode
+		}
+		if err != nil || !os.SameFile(info, node) {
+			return fail()
+		}
+		info, err = sourcepath.Lstat(physical)
+		if err != nil || !info.Mode().IsRegular() || !os.SameFile(info, member.file) {
+			return fail()
+		}
+	}
+	for _, directory := range member.directories {
+		info, err := sourcepath.Lstat(directory.path)
+		if err != nil || !os.SameFile(info, directory.info) {
+			return fail()
+		}
+		physical, err := sourcepath.Resolve(directory.path)
+		if err != nil || physical != directory.physical {
+			return fail()
+		}
+	}
+	return nil
+}
diff --git a/cmd/plan9asmll/assembly_member_symlink_test.go b/cmd/plan9asmll/assembly_member_symlink_test.go
new file mode 100644
index 000000000..b1e5e0f47
--- /dev/null
+++ b/cmd/plan9asmll/assembly_member_symlink_test.go
@@ -0,0 +1,64 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestActualAssemblyMemberFinalSymlinkIdentity(t *testing.T) {
+	directory := t.TempDir()
+	physical := filepath.Join(directory, "original.txt")
+	other := filepath.Join(directory, "other.txt")
+	for _, path := range []string{physical, other} {
+		if err := os.WriteFile(path, []byte("TEXT ·F(SB),$0-0\n RET\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	selected := filepath.Join(directory, "p_arm64.s")
+	if err := os.Symlink(physical, selected); err != nil {
+		t.Fatal(err)
+	}
+	member, err := observeActualAssemblyMember(selected, []string{selected})
+	if err != nil || member.verify() != nil {
+		t.Fatalf("unchanged actual selected final symlink: %v", err)
+	}
+	if err := os.Rename(selected, selected+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(other, selected); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(member.verify(), plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("retargeted selected final symlink retained source identity")
+	}
+	if err := os.Remove(selected); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(selected+".original", selected); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(member.verify(), plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("restored selected final symlink revived source identity")
+	}
+	requested := filepath.Join(directory, "requested.s")
+	if err := os.Symlink(selected, requested); err != nil {
+		t.Fatal(err)
+	}
+	member, err = observeActualAssemblyMember(requested, []string{selected})
+	if err != nil || member.verify() != nil {
+		t.Fatalf("final symlink to exact actual selected file: %v", err)
+	}
+	if err := os.Rename(requested, requested+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(selected, requested); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(member.verify(), plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("same-target replacement erased original request node identity")
+	}
+}
diff --git a/cmd/plan9asmll/assembly_member_test.go b/cmd/plan9asmll/assembly_member_test.go
new file mode 100644
index 000000000..6e43363f6
--- /dev/null
+++ b/cmd/plan9asmll/assembly_member_test.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestActualAssemblyMemberExactSelection(t *testing.T) {
+	directory := t.TempDir()
+	selected := filepath.Join(directory, "p_arm64.s")
+	other := filepath.Join(directory, "unselected_arm64.s")
+	for _, path := range []string{selected, other} {
+		if err := os.WriteFile(path, []byte("TEXT ·F(SB),$0-0\n RET\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	alias := filepath.Join(t.TempDir(), "package")
+	ordinaryLoadDirectoryAlias(t, alias, directory)
+	requested := filepath.Join(alias, filepath.Base(selected))
+	member, err := observeActualAssemblyMember(requested, []string{selected})
+	if err != nil || member.selected != selected || member.verify() != nil {
+		t.Fatalf("exact compiler member through original directory alias: %+v %v", member, err)
+	}
+	for _, test := range []struct {
+		name      string
+		request   string
+		selection []string
+	}{
+		{"unselected-equal-bytes", other, []string{selected}},
+		{"missing", filepath.Join(alias, "missing.s"), []string{selected}},
+		{"directory", directory, []string{selected}},
+		{"empty-selection", requested, nil},
+		{"duplicate-selection", requested, []string{selected, selected}},
+		{"aliased-duplicate-selection", requested, []string{selected, requested}},
+		{"oversized-selection", requested, make([]string, 513)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if _, err := observeActualAssemblyMember(test.request, test.selection); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("invalid actual selection gained a member: %v", err)
+			}
+		})
+	}
+	copyMember := &actualAssemblyMember{self: member, requested: member.requested, selected: member.selected, physical: member.physical, file: member.file, directories: member.directories}
+	if !errors.Is(copyMember.verify(), plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("copied observation gained live identity")
+	}
+}
+
+func TestActualAssemblyMemberOriginalAliasLifetime(t *testing.T) {
+	for _, mutation := range []string{"retarget-equal-bytes", "replace-alias-same-target", "replace-file-equal-bytes"} {
+		t.Run(mutation, func(t *testing.T) {
+			directory, other := t.TempDir(), t.TempDir()
+			selected := filepath.Join(directory, "p_arm64.s")
+			bytes := []byte("TEXT ·F(SB),$0-0\n RET\n")
+			for _, path := range []string{selected, filepath.Join(other, "p_arm64.s")} {
+				if err := os.WriteFile(path, bytes, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			alias := filepath.Join(t.TempDir(), "package")
+			ordinaryLoadDirectoryAlias(t, alias, directory)
+			member, err := observeActualAssemblyMember(filepath.Join(alias, "p_arm64.s"), []string{selected})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if mutation == "replace-file-equal-bytes" {
+				if err := os.Rename(selected, selected+".original"); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(selected, bytes, 0600); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				if err := os.Rename(alias, alias+".original"); err != nil {
+					t.Fatal(err)
+				}
+				target := directory
+				if mutation == "retarget-equal-bytes" {
+					target = other
+				}
+				ordinaryLoadDirectoryAlias(t, alias, target)
+			}
+			if !errors.Is(member.verify(), plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("changed original request retained selected-source identity")
+			}
+			if mutation == "replace-file-equal-bytes" {
+				if err := os.Remove(selected); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(selected+".original", selected); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				if err := os.Remove(alias); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(alias+".original", alias); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if !errors.Is(member.verify(), plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("restored request revived a revoked observation")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/bmi2_shift_extraction_test.go b/cmd/plan9asmll/bmi2_shift_extraction_test.go
new file mode 100644
index 000000000..579cc602e
--- /dev/null
+++ b/cmd/plan9asmll/bmi2_shift_extraction_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsBMI2ShiftRotateTypedTable(t *testing.T) {
+	const file = "amd64_lower_bmi2_shift.go"
+	source, err := os.ReadFile(filepath.Join("../..", file))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, contents := range map[string][]byte{
+		file:           source,
+		"translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), contents, 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		ops, err := extractSupportedOps(directory, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ", "RORXL", "RORXQ"} {
+			if _, found := ops[op]; !found {
+				t.Fatal("isolated typed table lost a BMI2 shift/rotate member", arch, op)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/byte_shuffle_extraction_test.go b/cmd/plan9asmll/byte_shuffle_extraction_test.go
new file mode 100644
index 000000000..532157f30
--- /dev/null
+++ b/cmd/plan9asmll/byte_shuffle_extraction_test.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsByteShuffleTypedTable(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_byte_shuffle_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_byte_shuffle_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PSHUFB", "VPSHUFB"} {
+				if _, exists := supported[name]; !exists {
+					t.Fatal("typed opcode missing", arch, name)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/chunk_test.go b/cmd/plan9asmll/chunk_test.go
new file mode 100644
index 000000000..03ce245ae
--- /dev/null
+++ b/cmd/plan9asmll/chunk_test.go
@@ -0,0 +1,181 @@
+//go:build !windows
+
+package main
+
+import (
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCompileOneChecksEveryFunctionInBoundedModules(t *testing.T) {
+	config, err := resolveCompileConfig(true, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions = 1
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "functions_amd64.s")
+	const source = `
+TEXT ·first(SB),$0-0
+	RET
+TEXT ·second(SB),$0-0
+	RET
+TEXT ·third(SB),$0-0
+	RET
+`
+	if err := os.WriteFile(asm, []byte(source), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/chunks",
+		Types:   types.NewPackage("example.com/chunks", "chunks"),
+		Imports: map[string]*packages.Package{},
+	}
+	out := filepath.Join(dir, "functions.ll")
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out}, false, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"functions.ll", "functions.part-0001.ll", "functions.part-0002.ll"} {
+		path := filepath.Join(dir, name)
+		ir, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := strings.Count(string(ir), "define "); got != 1 {
+			t.Fatalf("%s contains %d defined functions, want one", name, got)
+		}
+		object := strings.TrimSuffix(path, ".ll") + ".o"
+		if _, err := os.Stat(object); !os.IsNotExist(err) {
+			t.Fatalf("temporary object %s was not removed: %v", object, err)
+		}
+	}
+}
+
+func TestCompileOneBoundsModuleByInstructionCount(t *testing.T) {
+	config, err := resolveCompileConfig(true, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions = 128
+	config.MaxInstructions = 3
+
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "instructions_amd64.s")
+	const source = `
+TEXT ·first(SB),$0-0
+	NOP
+	RET
+TEXT ·second(SB),$0-0
+	NOP
+	RET
+TEXT ·third(SB),$0-0
+	NOP
+	RET
+`
+	if err := os.WriteFile(asm, []byte(source), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/instructionchunks",
+		Types:   types.NewPackage("example.com/instructionchunks", "instructionchunks"),
+		Imports: map[string]*packages.Package{},
+	}
+	out := filepath.Join(dir, "instructions.ll")
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out}, false, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"instructions.ll", "instructions.part-0001.ll", "instructions.part-0002.ll"} {
+		ir, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := strings.Count(string(ir), "define "); got != 1 {
+			t.Fatalf("%s contains %d functions, want one", name, got)
+		}
+	}
+}
+
+func TestCompileOneBoundedModulesDoNotHideLateFailure(t *testing.T) {
+	config, err := resolveCompileConfig(true, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions = 1
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "functions_amd64.s")
+	const source = `
+TEXT ·first(SB),$0-0
+	RET
+TEXT ·second(SB),$0-0
+	RET
+TEXT ·third(SB),$0-0
+	UNKNOWNINSTRUCTION
+	RET
+`
+	if err := os.WriteFile(asm, []byte(source), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/chunks",
+		Types:   types.NewPackage("example.com/chunks", "chunks"),
+		Imports: map[string]*packages.Package{},
+	}
+	out := filepath.Join(dir, "functions.ll")
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out}, false, config)
+	if err == nil || !strings.Contains(err.Error(), "third") {
+		t.Fatalf("late invalid function was not reported: %v", err)
+	}
+	for _, name := range []string{"functions.ll", "functions.part-0001.ll"} {
+		if _, err := os.Stat(filepath.Join(dir, name)); !os.IsNotExist(err) {
+			t.Fatalf("failed complete attempt published earlier chunk %s: %v", name, err)
+		}
+	}
+}
+
+func TestCompileOneBoundedModulesPreserveCrossChunkRawText(t *testing.T) {
+	config, err := resolveCompileConfig(true, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions = 1
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "raw_amd64.s")
+	const source = `TEXT ·refer(SB),$0-0
+	LEAQ ·blob(SB), AX
+	RET
+TEXT ·blob(SB),$0-0
+	LONG $0xdeadbeef
+`
+	if err := os.WriteFile(asm, []byte(source), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/chunks",
+		Types:   types.NewPackage("example.com/chunks", "chunks"),
+		Imports: map[string]*packages.Package{},
+	}
+	out := filepath.Join(dir, "raw.ll")
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out}, false, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := os.ReadFile(filepath.Join(dir, "raw.part-0001.ll"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(second), `.byte 239, 190, 173, 222`) {
+		t.Fatal("cross-chunk address-sensitive raw TEXT was not preserved byte-for-byte")
+	}
+}
diff --git a/cmd/plan9asmll/cmov_extraction_test.go b/cmd/plan9asmll/cmov_extraction_test.go
new file mode 100644
index 000000000..efa3c9318
--- /dev/null
+++ b/cmd/plan9asmll/cmov_extraction_test.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestExtractSupportedOpsCMOVTypedTable(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_cmov_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_cmov_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, width := range []string{"W", "L", "Q"} {
+				for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+					if _, present := supported["CMOV"+width+condition]; !present {
+						t.Fatal("typed table lost actual source name", arch, width, condition)
+					}
+				}
+			}
+			for _, invalid := range []string{"CMOVLE", "CMOVLLE.Z", "CMOVBNE", "x86ConditionalMoveSpecs", "cmovlle"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("typed table advertised non-source spelling", invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/comi_specs_test.go b/cmd/plan9asmll/comi_specs_test.go
new file mode 100644
index 000000000..f1760e38e
--- /dev/null
+++ b/cmd/plan9asmll/comi_specs_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteCOMISpec(t *testing.T) {
+	filename := "amd64_comi_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"COMISS", "COMISD", "UCOMISS", "UCOMISD", "VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s missing scalar flag comparison %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/conflict_funnel_extraction_test.go b/cmd/plan9asmll/conflict_funnel_extraction_test.go
new file mode 100644
index 000000000..fbbf0f32a
--- /dev/null
+++ b/cmd/plan9asmll/conflict_funnel_extraction_test.go
@@ -0,0 +1,54 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteConflictFunnelTypedFamilies(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, family := range []struct {
+		file  string
+		names []string
+	}{
+		{file: "amd64_lower_conflict.go", names: []string{"VPCONFLICTD", "VPCONFLICTQ"}},
+		{file: "amd64_lower_funnel_shift.go", names: []string{
+			"VPSHLDW", "VPSHLDD", "VPSHLDQ", "VPSHLDVW", "VPSHLDVD", "VPSHLDVQ",
+			"VPSHRDW", "VPSHRDD", "VPSHRDQ", "VPSHRDVW", "VPSHRDVD", "VPSHRDVQ",
+		}},
+	} {
+		source, err := os.ReadFile(filepath.Join(repo, family.file))
+		if err != nil {
+			t.Fatal(err)
+		}
+		isolated := t.TempDir()
+		if err := os.WriteFile(filepath.Join(isolated, family.file), source, 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			for _, root := range []string{isolated, repo} {
+				supported, err := extractSupportedOps(root, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, name := range family.names {
+					if _, present := supported[name]; !present {
+						t.Fatal("complete typed family omitted a source name", arch, name)
+					}
+				}
+				for _, invalid := range []string{"VPCONFLICT", "VPSHLD", "VPSHRD", "VPCONFLICTD.Z", "VPSHRDVQ.BCST", "amd64FunnelShiftSpecs"} {
+					if _, present := supported[invalid]; present {
+						t.Fatal("typed family extraction advertised a non-source spelling", arch, invalid)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/continuation.go b/cmd/plan9asmll/continuation.go
new file mode 100644
index 000000000..ea9a6dd94
--- /dev/null
+++ b/cmd/plan9asmll/continuation.go
@@ -0,0 +1,446 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+// inferX86TailGroups recognizes private threaded dispatchers, not arbitrary
+// tail calls. The direct-jump component must have one framed entry; every
+// other TEXT must be an uncalled, zero-frame helper. Code pointers may only
+// enter complete file-local tables, then be loaded immediately before JMP.
+func inferX86TailGroups(pkg *packages.Package, file *plan9asm.File, asmPath, goarch string,
+	resolve func(string) string, sigs map[string]plan9asm.FuncSig, defines []string, config compileConfig,
+) (groups []plan9asm.X86TailGroup, source *continuationReferenceSource, result error) {
+	if file == nil || file.Arch != plan9asm.ArchAMD64 || goarch != "amd64" {
+		return nil, nil, nil
+	}
+	ctx := config.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	defer func() {
+		if source != nil {
+			result = errors.Join(result, source.verify(ctx, defines, config.Feature))
+			source.releaseQueryBytes()
+		}
+		if result != nil || len(groups) == 0 {
+			groups, source = nil, nil
+		}
+	}()
+	byName := map[string]int{}
+	for i, fn := range file.Funcs {
+		byName[fn.Sym] = i
+	}
+	neighbors := make([][]int, len(file.Funcs))
+	for i, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op != "JMP" || len(ins.Args) != 1 {
+				continue
+			}
+			name, off, ok := continuationSB(ins.Args[0])
+			if j, exists := byName[name]; ok && off == 0 && exists {
+				neighbors[i] = append(neighbors[i], j)
+				neighbors[j] = append(neighbors[j], i)
+			}
+		}
+	}
+	seen := map[int]bool{}
+	for start := range file.Funcs {
+		if seen[start] || len(neighbors[start]) == 0 {
+			continue
+		}
+		component := map[int]bool{}
+		queue := []int{start}
+		for len(queue) != 0 {
+			i := queue[0]
+			queue = queue[1:]
+			if seen[i] {
+				continue
+			}
+			seen[i], component[i] = true, true
+			queue = append(queue, neighbors[i]...)
+		}
+		group, ok := continuationComponent(file, component, resolve, sigs)
+		if !ok || !closedContinuationTables(file, group, sigs, resolve) {
+			continue
+		}
+		if _, eligible := continuationPrivateNames(pkg, group.Helpers); !eligible {
+			continue
+		}
+		if source == nil {
+			selection := config.x86CallerSelections[pkg]
+			if selection == nil || !strings.HasSuffix(selection.target, "/"+goarch) {
+				return nil, nil, continuationSourceError()
+			}
+			var err error
+			source, err = captureContinuationReferenceSource(pkg, asmPath, selection.target, defines, config)
+			if err != nil {
+				return nil, nil, err
+			}
+			observed, beforeErr := json.Marshal(source.selected.goPkg.SourceSelection.Assembly[source.selected.member.selected])
+			input, inputErr := json.Marshal(file)
+			if beforeErr != nil || inputErr != nil || !bytes.Equal(observed, input) {
+				return nil, source, continuationSourceError()
+			}
+			actual, _, err := sigsForAsmFile(source.selected.pkg, file, resolve, goarch)
+			if err != nil {
+				return nil, source, err
+			}
+			for name, previous := range sigs {
+				current, present := actual[name]
+				before, beforeErr := json.Marshal(previous)
+				after, afterErr := json.Marshal(current)
+				if !present || beforeErr != nil || afterErr != nil || !bytes.Equal(before, after) {
+					return nil, source, continuationSourceError()
+				}
+			}
+		}
+		private, err := privateContinuationReferences(source, group.Helpers)
+		if err != nil {
+			return nil, source, err
+		}
+		if private {
+			groups = append(groups, group)
+		}
+	}
+	return groups, source, nil
+}
+
+func continuationComponent(file *plan9asm.File, members map[int]bool,
+	resolve func(string) string, sigs map[string]plan9asm.FuncSig,
+) (plan9asm.X86TailGroup, bool) {
+	var group plan9asm.X86TailGroup
+	borrowedFrame := false
+	for i, fn := range file.Funcs {
+		if !members[i] {
+			continue
+		}
+		sig, ok := sigs[resolve(fn.Sym)]
+		if !ok || fn.FrameSize != 0 {
+			return group, false
+		}
+		if len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+			if group.Root != "" {
+				return group, false
+			}
+			group.Root = fn.Sym
+			continue
+		}
+		if sig.Ret != plan9asm.Void || len(sig.Args) != 0 || fn.ArgSize != 0 {
+			return group, false
+		}
+		group.Helpers = append(group.Helpers, fn.Sym)
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				if arg.Kind == plan9asm.OpFP || arg.Kind == plan9asm.OpFPAddr {
+					borrowedFrame = true
+				}
+			}
+		}
+	}
+	return group, group.Root != "" && len(group.Helpers) != 0 && borrowedFrame
+}
+
+func continuationSB(arg plan9asm.Operand) (string, int64, bool) {
+	if arg.Kind != plan9asm.OpSym || !strings.HasSuffix(arg.Sym, "(SB)") {
+		return "", 0, false
+	}
+	name, off := splitSymPlusOff(strings.TrimSuffix(strings.TrimPrefix(arg.Sym, "$"), "(SB)"))
+	return name, off, name != ""
+}
+
+type continuationTable struct {
+	slots map[int64]bool
+	init  string
+}
+
+func closedContinuationTables(file *plan9asm.File, group plan9asm.X86TailGroup,
+	sigs map[string]plan9asm.FuncSig, resolve func(string) string,
+) bool {
+	members, helpers := map[string]bool{group.Root: true}, map[string]bool{}
+	for _, name := range group.Helpers {
+		members[name], helpers[name] = true, true
+	}
+	tables := map[string]*continuationTable{}
+	initializers := map[string]bool{}
+	for _, fn := range file.Funcs {
+		for i, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				name, off, ok := continuationSB(arg)
+				if !ok || !helpers[name] {
+					continue
+				}
+				if off != 0 {
+					return false
+				}
+				if ins.Op == "JMP" && len(ins.Args) == 1 && members[fn.Sym] {
+					continue
+				}
+				if members[fn.Sym] || ins.Op != "LEAQ" || len(ins.Args) != 2 ||
+					ins.Args[1].Kind != plan9asm.OpReg || i+1 >= len(fn.Instrs) {
+					return false
+				}
+				next := fn.Instrs[i+1]
+				if next.Op != "MOVQ" || len(next.Args) != 2 || !sameContinuationReg(next.Args[0], ins.Args[1]) {
+					return false
+				}
+				table, slot, ok := continuationSB(next.Args[1])
+				if !ok || !strings.HasSuffix(table, "<>") || slot < 0 || slot%8 != 0 {
+					return false
+				}
+				if tables[table] == nil {
+					tables[table] = &continuationTable{slots: map[int64]bool{}, init: fn.Sym}
+				}
+				if tables[table].init != fn.Sym || tables[table].slots[slot] {
+					return false
+				}
+				tables[table].slots[slot] = true
+				initializers[fn.Sym] = true
+			}
+		}
+	}
+	for table, info := range tables {
+		complete := false
+		for _, global := range file.Globl {
+			if global.Sym == table && global.Size == int64(len(info.slots))*8 {
+				complete = true
+				for off := int64(0); off < global.Size; off += 8 {
+					complete = complete && info.slots[off]
+				}
+			}
+		}
+		if !complete {
+			return false
+		}
+	}
+	for _, data := range file.Data {
+		if tables[data.Sym] != nil {
+			return false
+		}
+		name, _, _ := continuationSB(plan9asm.Operand{Kind: plan9asm.OpSym, Sym: data.Addr})
+		if helpers[name] {
+			return false
+		}
+	}
+
+	// Table-base registers cannot be overwritten, copied or exposed. This
+	// permits indexed reads but proves that the addresses remain in the group.
+	tableRegs := map[plan9asm.Reg]bool{}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			for ai, arg := range ins.Args {
+				table, off, ok := continuationSB(arg)
+				if !ok || tables[table] == nil {
+					continue
+				}
+				if initializers[fn.Sym] {
+					continue // The complete initializer is checked below.
+				}
+				if fn.Sym != group.Root || ai != 0 || off != 0 || ins.Op != "LEAQ" ||
+					len(ins.Args) != 2 || ins.Args[1].Kind != plan9asm.OpReg {
+					return false
+				}
+				tableRegs[ins.Args[1].Reg] = true
+				switch ins.Args[1].Reg {
+				case "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+					// These registers have no implicit x86 instruction writes.
+				default:
+					return false
+				}
+			}
+		}
+	}
+	for _, fn := range file.Funcs {
+		if initializers[fn.Sym] {
+			sig := sigs[resolve(fn.Sym)]
+			if sig.Ret != plan9asm.Void || len(sig.Args) != 0 || !continuationInitializer(fn, helpers, tables) {
+				return false
+			}
+		}
+		if members[fn.Sym] && !continuationDispatchBody(fn, members, tables, tableRegs) {
+			return false
+		}
+	}
+	return continuationTableDefinitions(file, group, tables, tableRegs)
+}
+
+func continuationInitializer(fn plan9asm.Func, helpers map[string]bool, tables map[string]*continuationTable) bool {
+	for i := 0; i < len(fn.Instrs); {
+		ins := fn.Instrs[i]
+		if ins.Op == plan9asm.OpTEXT && i == 0 {
+			i++
+			continue
+		}
+		if ins.Op == "RET" && len(ins.Args) == 0 && i == len(fn.Instrs)-1 {
+			return true
+		}
+		if ins.Op != "LEAQ" || len(ins.Args) != 2 || i+1 >= len(fn.Instrs) {
+			return false
+		}
+		name, off, _ := continuationSB(ins.Args[0])
+		next := fn.Instrs[i+1]
+		if !helpers[name] || off != 0 || next.Op != "MOVQ" || len(next.Args) != 2 || !sameContinuationReg(next.Args[0], ins.Args[1]) {
+			return false
+		}
+		table, _, _ := continuationSB(next.Args[1])
+		if tables[table] == nil {
+			return false
+		}
+		i += 2
+	}
+	return false
+}
+
+func continuationDispatchBody(fn plan9asm.Func, members map[string]bool,
+	tables map[string]*continuationTable, tableRegs map[plan9asm.Reg]bool,
+) bool {
+	for i, ins := range fn.Instrs {
+		switch ins.Op {
+		case "SYSCALL", "SYSENTER", "SYSEXIT", "SYSRET", "IRET", "IRETL", "IRETQ", "IRETW",
+			"INT", "INTO", "LCALL", "LJMP", "RETF", "RETFQ", "XBEGIN", "XEND", "XABORT":
+			return false // Exceptional control flow or implicit machine-state changes.
+		}
+		if ins.Op == "RET" && len(ins.Args) != 0 {
+			return false
+		}
+		if ins.Op == "CALL" || ins.Op == "BYTE" || ins.Op == "WORD" || ins.Op == "LONG" || ins.Op == "QUAD" {
+			return false
+		}
+		for ai, arg := range ins.Args {
+			if arg.Kind == plan9asm.OpMem && arg.Mem.Base == plan9asm.PC {
+				return false // No alternate entrance into a load/JMP pair.
+			}
+			if arg.Kind == plan9asm.OpReg && tableRegs[arg.Reg] {
+				if ins.Op != "LEAQ" || ai != 1 || len(ins.Args) != 2 {
+					return false
+				}
+				base, _, _ := continuationSB(ins.Args[0])
+				if tables[base] == nil {
+					return false
+				}
+			}
+			if arg.Kind == plan9asm.OpMem && (tableRegs[arg.Mem.Base] || tableRegs[arg.Mem.Index]) {
+				if !tableRegs[arg.Mem.Base] || tableRegs[arg.Mem.Index] || ai != 0 || ins.Op != "MOVQ" || len(ins.Args) != 2 ||
+					ins.Args[1].Kind != plan9asm.OpReg || i+1 >= len(fn.Instrs) {
+					return false
+				}
+				next := fn.Instrs[i+1]
+				if next.Op != "JMP" || len(next.Args) != 1 || !sameContinuationReg(next.Args[0], ins.Args[1]) {
+					return false
+				}
+			}
+		}
+		if ins.Op != "JMP" || len(ins.Args) != 1 {
+			continue
+		}
+		arg := ins.Args[0]
+		if name, off, ok := continuationSB(arg); ok {
+			if !members[name] || off != 0 {
+				return false
+			}
+			continue
+		}
+		if arg.Kind == plan9asm.OpIdent {
+			continue
+		}
+		if arg.Kind != plan9asm.OpReg || i == 0 {
+			return false
+		}
+		prev := fn.Instrs[i-1]
+		if prev.Op != "MOVQ" || len(prev.Args) != 2 || !sameContinuationReg(prev.Args[1], arg) ||
+			prev.Args[0].Kind != plan9asm.OpMem || !tableRegs[prev.Args[0].Mem.Base] {
+			return false
+		}
+	}
+	return true
+}
+
+func sameContinuationReg(a, b plan9asm.Operand) bool {
+	return a.Kind == plan9asm.OpReg && b.Kind == plan9asm.OpReg && a.Reg == b.Reg
+}
+
+// Inspect all sibling Go sources, including tests and other build variants.
+// A false positive only prevents this optimization. Silently dropping a
+// callable Go symbol would change the program's ABI.
+func continuationPrivateNames(pkg *packages.Package, helpers []string) (map[string]bool, bool) {
+	if pkg == nil || pkg.Types == nil {
+		return nil, false
+	}
+	names := map[string]bool{}
+	for _, symbol := range helpers {
+		if !strings.HasPrefix(symbol, "·") {
+			return nil, false
+		}
+		name := strings.TrimPrefix(symbol, "·")
+		if ast.IsExported(name) || pkg.Types.Scope().Lookup(name) == nil {
+			return nil, false
+		}
+		names[name] = true
+	}
+	return names, true
+}
+
+func privateContinuationReferences(source *continuationReferenceSource, helpers []string) (bool, error) {
+	names, eligible := continuationPrivateNames(source.selected.pkg, helpers)
+	if !eligible {
+		return false, nil
+	}
+	for name, record := range source.files {
+		if name == source.selfName {
+			continue
+		}
+		path := filepath.Join(source.directory, name)
+		ext := filepath.Ext(name)
+		if ext != ".go" {
+			for name := range names {
+				if strings.Contains(string(record.data), name) {
+					return false, nil
+				}
+			}
+			continue
+		}
+		parsed, err := parser.ParseFile(token.NewFileSet(), path, record.data, parser.ParseComments)
+		if err != nil {
+			return false, err
+		}
+		declarations := map[*ast.Ident]bool{}
+		for _, declaration := range parsed.Decls {
+			if fn, ok := declaration.(*ast.FuncDecl); ok && names[fn.Name.Name] && fn.Body == nil {
+				declarations[fn.Name] = true
+			}
+		}
+		private := true
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			if id, ok := node.(*ast.Ident); ok && names[id.Name] && !declarations[id] {
+				private = false
+			}
+			return private
+		})
+		for _, comments := range parsed.Comments {
+			for _, comment := range comments.List {
+				if strings.Contains(comment.Text, "go:linkname") {
+					for name := range names {
+						if strings.Contains(comment.Text, name) {
+							private = false
+						}
+					}
+				}
+			}
+		}
+		if !private {
+			return false, nil
+		}
+	}
+	return true, nil
+}
diff --git a/cmd/plan9asmll/continuation_flow.go b/cmd/plan9asmll/continuation_flow.go
new file mode 100644
index 000000000..8382e7b53
--- /dev/null
+++ b/cmd/plan9asmll/continuation_flow.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Every possible path to a table load must initialize its base. Direct jumps
+// to an exit before initialization are legal; an indirect dispatch is not.
+// Worklist joins intersect definite definitions, including helper backedges.
+func continuationTableDefinitions(file *plan9asm.File, group plan9asm.X86TailGroup,
+	tables map[string]*continuationTable, regs map[plan9asm.Reg]bool,
+) bool {
+	type point struct {
+		function    string
+		instruction int
+	}
+	functions := map[string]plan9asm.Func{}
+	labels := map[string]map[string]int{}
+	members := map[string]bool{group.Root: true}
+	for _, name := range group.Helpers {
+		members[name] = true
+	}
+	for _, fn := range file.Funcs {
+		if !members[fn.Sym] {
+			continue
+		}
+		functions[fn.Sym] = fn
+		labels[fn.Sym] = map[string]int{}
+		for i, ins := range fn.Instrs {
+			if ins.Op == plan9asm.OpLABEL && len(ins.Args) == 1 {
+				labels[fn.Sym][ins.Args[0].Sym] = i
+			}
+		}
+	}
+	bits := map[plan9asm.Reg]uint64{}
+	for r := range regs {
+		bits[r] = uint64(1) << len(bits)
+	}
+	entry := point{function: group.Root}
+	known := map[point]uint64{entry: 0}
+	queue := []point{entry}
+	merge := func(next point, state uint64) bool {
+		if next.instruction < 0 || next.instruction >= len(functions[next.function].Instrs) {
+			return false
+		}
+		old, visited := known[next]
+		if visited {
+			state &= old
+		}
+		if !visited || old != state {
+			known[next] = state
+			queue = append(queue, next)
+		}
+		return true
+	}
+	for len(queue) != 0 {
+		at := queue[0]
+		queue = queue[1:]
+		state := known[at]
+		ins := functions[at.function].Instrs[at.instruction]
+		for _, arg := range ins.Args {
+			if arg.Kind == plan9asm.OpMem && regs[arg.Mem.Base] && state&bits[arg.Mem.Base] == 0 {
+				return false
+			}
+		}
+		if ins.Op == "LEAQ" && len(ins.Args) == 2 {
+			name, _, _ := continuationSB(ins.Args[0])
+			if tables[name] != nil {
+				state |= bits[ins.Args[1].Reg]
+			}
+		}
+		if ins.Op == "RET" {
+			continue
+		}
+		branch := strings.HasPrefix(string(ins.Op), "J") || ins.Op == "LOOP"
+		if branch {
+			if len(ins.Args) == 0 {
+				return false
+			}
+			arg := ins.Args[len(ins.Args)-1]
+			if name, _, ok := continuationSB(arg); ok {
+				if name == group.Root || !merge(point{function: name}, state) {
+					return false
+				}
+			} else if arg.Kind == plan9asm.OpIdent {
+				target, ok := labels[at.function][arg.Ident]
+				if !ok || !merge(point{function: at.function, instruction: target}, state) {
+					return false
+				}
+			} else if ins.Op == "JMP" && arg.Kind == plan9asm.OpReg {
+				for _, helper := range group.Helpers {
+					if !merge(point{function: helper}, state) {
+						return false
+					}
+				}
+			} else {
+				return false
+			}
+			if ins.Op == "JMP" {
+				continue
+			}
+		}
+		if !merge(point{function: at.function, instruction: at.instruction + 1}, state) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/cmd/plan9asmll/continuation_member_test.go b/cmd/plan9asmll/continuation_member_test.go
new file mode 100644
index 000000000..f4d1f48a8
--- /dev/null
+++ b/cmd/plan9asmll/continuation_member_test.go
@@ -0,0 +1,317 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestContinuationActualSelectedOutsideAliasReferenceClosure(t *testing.T) {
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	for _, name := range []string{"unselected-Go", "unselected-ASM", "header"} {
+		t.Run(name, func(t *testing.T) {
+			_, selected := continuationPackage(t, continuationGo, continuationAsm)
+			directory := filepath.Dir(selected)
+			pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, "example.com/continuations", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("actual full original compiler selection: %v", err)
+			}
+			pkg := pkgs[0]
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, continuationAsm)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+			groups, _, err := inferX86TailGroups(pkg, file, selected, "amd64", resolve, sigs, defines, config)
+			if err != nil || len(groups) != 1 {
+				t.Fatalf("actual selected baseline did not identify the private table: %v %+v", err, groups)
+			}
+			reference, source := "reference_windows.go", "//go:build windows\n\npackage p\nfunc external() { step() }\n"
+			if name == "unselected-ASM" {
+				reference, source = "_reference.s", "TEXT ·external(SB),$0-0\nJMP ·step(SB)\n"
+			}
+			if name == "header" {
+				reference, source = "reference.h", "// external reference to step\n"
+			}
+			if err := os.WriteFile(filepath.Join(directory, reference), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			groups, _, err = inferX86TailGroups(pkg, file, selected, "amd64", resolve, sigs, defines, config)
+			if err != nil || len(groups) != 0 {
+				t.Fatalf("physical-directory sibling reference was not rejected: %v %+v", err, groups)
+			}
+			requested := filepath.Join(t.TempDir(), "requested_amd64.s")
+			if err := os.Symlink(selected, requested); err != nil {
+				t.Fatal(err)
+			}
+			groups, _, err = inferX86TailGroups(pkg, file, requested, "amd64", resolve, sigs, defines, config)
+			if err != nil || len(groups) != 0 {
+				t.Fatalf("original alias changed the whole selected-package reference closure: %v %+v", err, groups)
+			}
+		})
+	}
+}
+
+func continuationObservedSource(t *testing.T, extra map[string]string) (*continuationReferenceSource, compileConfig) {
+	return continuationObservedSourceInContext(t, extra, context.Background())
+}
+
+func continuationObservedSourceInContext(t *testing.T, extra map[string]string, ctx context.Context) (*continuationReferenceSource, compileConfig) {
+	t.Helper()
+	pkg, selected := continuationPackageWithSources(t, continuationGo, continuationAsm, extra)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, continuationAsm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	config := compileConfig{Context: ctx, x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	groups, source, err := inferX86TailGroups(pkg, file, selected, "amd64", resolve, sigs, plan9asm.GoAssemblerDefines("linux", "amd64"), config)
+	if err != nil || len(groups) != 1 || source == nil {
+		t.Fatalf("complete unchanged reference source: %v %+v", err, groups)
+	}
+	for _, record := range source.files {
+		if record.data != nil {
+			t.Fatal("privacy query retained a second full plaintext tape after publication")
+		}
+	}
+	return source, config
+}
+
+type continuationFinalCallbackContext struct {
+	context.Context
+	callback func()
+}
+
+func (ctx *continuationFinalCallbackContext) Err() error {
+	if ctx.callback != nil {
+		pcs := make([]uintptr, 32)
+		frames := runtime.CallersFrames(pcs[:runtime.Callers(2, pcs)])
+		for {
+			frame, more := frames.Next()
+			if strings.HasSuffix(frame.Function, "(*continuationReferenceSource).verify.func1") {
+				callback := ctx.callback
+				ctx.callback = nil
+				callback()
+				break
+			}
+			if !more {
+				break
+			}
+		}
+	}
+	return ctx.Context.Err()
+}
+
+func TestContinuationReferenceSourceFinalOriginalCallbackIsGuarded(t *testing.T) {
+	ctx := &continuationFinalCallbackContext{Context: context.Background()}
+	source, _ := continuationObservedSourceInContext(t, nil, ctx)
+	called := false
+	ctx.callback = func() {
+		called = true
+		if err := os.WriteFile(filepath.Join(source.directory, "_late.h"), []byte("// step\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := source.verify(context.Background(), plan9asm.GoAssemblerDefines("linux", "amd64"), nil); !called || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("last original-context callback escaped final inventory validation: called=%v error=%v", called, err)
+	}
+}
+
+func TestContinuationReferenceSourceOriginalCancellationIsPermanent(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	source, _ := continuationObservedSourceInContext(t, nil, ctx)
+	cancel()
+	if err := source.verify(context.Background(), plan9asm.GoAssemblerDefines("linux", "amd64"), nil); !errors.Is(err, context.Canceled) {
+		t.Fatalf("replacement verification context erased original cancellation: %v", err)
+	}
+	if err := source.verify(context.Background(), plan9asm.GoAssemblerDefines("linux", "amd64"), nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("rejected original context revived its reference source: %v", err)
+	}
+	var missing *continuationReferenceSource
+	if err := missing.verify(context.Background(), nil, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("nil source: %v", err)
+	}
+}
+
+func TestContinuationActualSelectedFinalSymlinkUsesPackageDirectory(t *testing.T) {
+	pkg, selected := continuationPackage(t, continuationGo, continuationAsm)
+	other := filepath.Join(pkg.Dir, "native-source")
+	if err := os.Mkdir(other, 0700); err != nil {
+		t.Fatal(err)
+	}
+	physical := filepath.Join(other, "original.s")
+	if err := os.Rename(selected, physical); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(physical, selected); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(other, "reference.go"), []byte("package p\nfunc use() { step() }\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, pkg.PkgPath, true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual selected final-symlink graph: %v", err)
+	}
+	pkg = pkgs[0]
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, continuationAsm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	groups, source, err := inferX86TailGroups(pkg, file, selected, "amd64", resolve, sigs, plan9asm.GoAssemblerDefines("linux", "amd64"), config)
+	if err != nil || len(groups) != 1 || source == nil || source.directory == other {
+		t.Fatalf("selected final target borrowed an unrelated directory's reference role: %v %+v", err, groups)
+	}
+}
+
+func TestContinuationSeparatelyNamedPhysicalSiblingRemainsReference(t *testing.T) {
+	for _, alias := range []string{"symlink", "hardlink"} {
+		t.Run(alias, func(t *testing.T) {
+			pkg, selected := continuationPackage(t, continuationGo, continuationAsm)
+			other := filepath.Join(pkg.Dir, "_separately_named.s")
+			var err error
+			if alias == "symlink" {
+				err = os.Symlink(selected, other)
+			} else {
+				err = os.Link(selected, other)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, continuationAsm)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			groups, source, err := inferX86TailGroups(pkg, file, selected, "amd64", resolve, sigs, plan9asm.GoAssemblerDefines("linux", "amd64"), config)
+			if err != nil || len(groups) != 0 || source != nil {
+				t.Fatalf("physical equality erased a separately named sibling reference: %v %+v", err, groups)
+			}
+		})
+	}
+}
+
+func TestContinuationReferenceSourceLateChangesArePermanent(t *testing.T) {
+	for _, change := range []string{"new-Go", "new-s", "new-S", "new-h", "bytes", "same-byte-node", "selected-directory"} {
+		t.Run(change, func(t *testing.T) {
+			source, config := continuationObservedSource(t, map[string]string{"reference_windows.go": "//go:build windows\n\npackage p\n// no helper reference\n"})
+			filename := filepath.Join(source.directory, "reference_windows.go")
+			var restore func()
+			called := false
+			if change == "selected-directory" {
+				// Go's t.Chdir pins the previous directory until cleanup. On
+				// Windows that handle would prevent the actual rename mutation.
+				// The fixture already owns restoring its original working directory.
+				if err := os.Chdir(filepath.Dir(source.directory)); err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.Chdir(source.directory); err != nil {
+						t.Error("restore selected fixture directory", err)
+					}
+				})
+			}
+			ctx := &assemblyMemberCallbackContext{Context: config.Context, callback: func() {
+				called = true
+				switch change {
+				case "new-Go", "new-s", "new-S", "new-h":
+					extension := map[string]string{"new-Go": ".go", "new-s": ".s", "new-S": ".S", "new-h": ".h"}[change]
+					filename = filepath.Join(source.directory, "_late"+extension)
+					if err := os.WriteFile(filename, []byte("// step\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					restore = func() {
+						if err := os.Remove(filename); err != nil {
+							t.Fatal(err)
+						}
+					}
+				case "bytes":
+					original, err := os.ReadFile(filename)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filename, []byte("//go:build windows\n\npackage p\nfunc external() { step() }\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					restore = func() {
+						if err := os.WriteFile(filename, original, 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+				case "same-byte-node":
+					original, err := os.ReadFile(filename)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Rename(filename, filename+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filename, original, 0600); err != nil {
+						t.Fatal(err)
+					}
+					restore = func() {
+						if err := os.Remove(filename); err != nil {
+							t.Fatal(err)
+						}
+						if err := os.Rename(filename+".original", filename); err != nil {
+							t.Fatal(err)
+						}
+					}
+				case "selected-directory":
+					if err := os.Rename(source.directory, source.directory+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Mkdir(source.directory, 0700); err != nil {
+						t.Fatal(err)
+					}
+					restore = func() {
+						if err := os.Remove(source.directory); err != nil {
+							t.Fatal(err)
+						}
+						if err := os.Rename(source.directory+".original", source.directory); err != nil {
+							t.Fatal(err)
+						}
+					}
+				}
+			}}
+			if err := source.verify(ctx, plan9asm.GoAssemblerDefines("linux", "amd64"), nil); !called || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("late reference mutation survived complete source guard: called=%v error=%v", called, err)
+			}
+			restore()
+			if err := source.verify(config.Context, plan9asm.GoAssemblerDefines("linux", "amd64"), nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("restoring a changed reference closure revived it: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/continuation_output_test.go b/cmd/plan9asmll/continuation_output_test.go
new file mode 100644
index 000000000..6b5c9d512
--- /dev/null
+++ b/cmd/plan9asmll/continuation_output_test.go
@@ -0,0 +1,119 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+type continuationOutputCallbackContext struct {
+	context.Context
+	directory, basename string
+	callback            func()
+}
+
+func (ctx *continuationOutputCallbackContext) Err() error {
+	if ctx.callback != nil {
+		// Observe either the historical direct output or the repaired owned
+		// stage, without arming on an assumed callback count or source line.
+		if data, err := os.ReadFile(filepath.Join(ctx.directory, ctx.basename)); err == nil && strings.Contains(string(data), "define ") {
+			callback := ctx.callback
+			ctx.callback = nil
+			callback()
+		}
+		for _, directory := range []string{ctx.directory, filepath.Dir(ctx.directory)} {
+			entries, err := os.ReadDir(directory)
+			if err != nil {
+				continue
+			}
+			for _, entry := range entries {
+				if !entry.IsDir() || !strings.HasPrefix(entry.Name(), ".plan9asm-output-") {
+					continue
+				}
+				if info, err := os.Stat(filepath.Join(directory, entry.Name(), ctx.basename)); err == nil && info.Mode().IsRegular() {
+					if ctx.callback == nil {
+						break
+					}
+					callback := ctx.callback
+					ctx.callback = nil
+					callback()
+					break
+				}
+			}
+		}
+	}
+	return ctx.Context.Err()
+}
+
+func TestCompileOneContinuationLateReferenceDoesNotPublish(t *testing.T) {
+	for _, change := range []string{"new-reference", "retarget-original-alias"} {
+		t.Run(change, func(t *testing.T) {
+			pkg, selected := continuationPackage(t, continuationGo, continuationAsm)
+			alias := filepath.Join(t.TempDir(), "requested-package")
+			ordinaryLoadDirectoryAlias(t, alias, pkg.Dir)
+			requested := filepath.Join(alias, filepath.Base(selected))
+			output := filepath.Join(pkg.Dir, "published.ll")
+			const retained = "previous verified user output\n"
+			if err := os.WriteFile(output, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			called := false
+			ctx := &continuationOutputCallbackContext{Context: context.Background(), directory: pkg.Dir, basename: filepath.Base(output)}
+			ctx.callback = func() {
+				called = true
+				if change == "new-reference" {
+					if err := os.WriteFile(filepath.Join(pkg.Dir, "_late.s"), []byte("TEXT ·external(SB),$0-0\nJMP ·step(SB)\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					other := t.TempDir()
+					if err := os.WriteFile(filepath.Join(other, "p_amd64.s"), []byte(continuationAsm), 0600); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Rename(alias, alias+".original"); err != nil {
+						t.Fatal(err)
+					}
+					ordinaryLoadDirectoryAlias(t, alias, other)
+				}
+			}
+			config := compileConfig{Context: ctx, x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: requested, OutLL: output}, false, config)
+			if !called || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("late actual reference closure was published: called=%v error=%v", called, err)
+			}
+			if data, err := os.ReadFile(output); err != nil || string(data) != retained {
+				t.Fatalf("failed final source guard overwrote retained output: %v", err)
+			}
+			entries, err := os.ReadDir(filepath.Dir(pkg.Dir))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, entry := range entries {
+				if strings.HasPrefix(entry.Name(), ".plan9asm-output-") {
+					t.Fatal("owned failed output stage was not released")
+				}
+			}
+		})
+	}
+}
+
+func TestCompileOneContinuationPublishesInsideSelectedOwner(t *testing.T) {
+	pkg, selected := continuationPackage(t, continuationGo, continuationAsm)
+	config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	output := filepath.Join(pkg.Dir, "inside-owner.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: selected, OutLL: output}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(output)
+	if err != nil || strings.Count(string(data), "define ") != 2 || !strings.Contains(string(data), "blockaddress") {
+		t.Fatalf("complete verified owner publication: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/continuation_source.go b/cmd/plan9asmll/continuation_source.go
new file mode 100644
index 000000000..eade9090a
--- /dev/null
+++ b/cmd/plan9asmll/continuation_source.go
@@ -0,0 +1,256 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sync/atomic"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// The reference role covers all direct Go/s/S/h siblings, not just the target's
+// build-selected inputs. Its byte bound matches the existing complete x86
+// source role; its file bound is the selected Go/native bounds combined.
+const continuationReferenceFiles = 256 + 512
+const continuationReferenceBytes = 64 << 20
+const continuationDirectoryEntries = 4096
+
+type continuationReferenceFile struct {
+	node, target     os.FileInfo
+	physical, digest string
+	data             []byte // Retained only until the whole-file privacy query finishes.
+}
+
+type continuationReferenceSource struct {
+	self             *continuationReferenceSource
+	pkg              *packages.Package
+	selected         *x86CallerTypedPackage
+	context          context.Context
+	directory        string
+	packageDirectory assemblyMemberDirectory
+	directoryInfo    os.FileInfo
+	files            map[string]continuationReferenceFile
+	selfName         string
+	revoked          atomic.Bool
+}
+
+func continuationSourceError() error {
+	return fmt.Errorf("%w: private continuation reference closure changed or lacks complete actual source", plan9asm.ErrProbeNeedsContext)
+}
+
+func continuationReferenceName(name string) bool {
+	switch filepath.Ext(name) {
+	case ".go", ".s", ".S", ".h":
+		return true
+	}
+	return false
+}
+
+func continuationReferenceNames(directory string) (names []string, result error) {
+	reader, err := os.Open(directory)
+	if err != nil {
+		return nil, err
+	}
+	defer func() { result = errors.Join(result, reader.Close()) }()
+	total := 0
+	for {
+		entries, err := reader.ReadDir(128)
+		total += len(entries)
+		if total > continuationDirectoryEntries {
+			return nil, continuationSourceError()
+		}
+		for _, entry := range entries {
+			if !entry.IsDir() && continuationReferenceName(entry.Name()) {
+				if len(names) >= continuationReferenceFiles {
+					return nil, continuationSourceError()
+				}
+				names = append(names, entry.Name())
+			}
+		}
+		if err == io.EOF {
+			return names, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+	}
+}
+
+func readContinuationReference(filename string, total *int64) (record continuationReferenceFile, result error) {
+	if total == nil || *total < 0 || *total > continuationReferenceBytes {
+		return record, continuationSourceError()
+	}
+	node, err := sourcepath.Lstat(filename)
+	if err != nil {
+		return record, err
+	}
+	physical, err := sourcepath.Resolve(filename)
+	if err != nil {
+		return record, err
+	}
+	info, err := sourcepath.Lstat(physical)
+	if err != nil || !info.Mode().IsRegular() || info.Size() < 0 || info.Size() > continuationReferenceBytes-*total {
+		return record, continuationSourceError()
+	}
+	reader, err := os.Open(filename)
+	if err != nil {
+		return record, err
+	}
+	defer func() { result = errors.Join(result, reader.Close()) }()
+	opened, err := reader.Stat()
+	if err != nil || !os.SameFile(opened, info) {
+		return record, continuationSourceError()
+	}
+	data, err := io.ReadAll(io.LimitReader(reader, continuationReferenceBytes-*total+1))
+	if err != nil || int64(len(data)) > continuationReferenceBytes-*total {
+		return record, continuationSourceError()
+	}
+	*total += int64(len(data))
+	return continuationReferenceFile{node: node, target: info, physical: physical, digest: featureBytesSHA256(data), data: data}, nil
+}
+
+func captureContinuationReferenceSource(pkg *packages.Package, asm, target string, defines []string,
+	config compileConfig,
+) (*continuationReferenceSource, error) {
+	selected, err := loadX86ActualSelectedAssembly(pkg, target, asm, defines, config)
+	if err != nil {
+		return nil, err
+	}
+	directory, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil {
+		return nil, err
+	}
+	parent, err := sourcepath.Resolve(filepath.Dir(selected.member.selected))
+	if err != nil || parent != directory {
+		return nil, continuationSourceError()
+	}
+	packageInfo, err := sourcepath.Lstat(pkg.Dir)
+	if err != nil {
+		return nil, err
+	}
+	directoryInfo, err := sourcepath.Lstat(directory)
+	if err != nil || !directoryInfo.IsDir() {
+		return nil, continuationSourceError()
+	}
+	ctx := config.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	source := &continuationReferenceSource{pkg: pkg, selected: selected, context: ctx,
+		directory: directory, directoryInfo: directoryInfo,
+		packageDirectory: assemblyMemberDirectory{pkg.Dir, directory, packageInfo},
+		files:            make(map[string]continuationReferenceFile), selfName: filepath.Base(selected.member.selected)}
+	names, err := continuationReferenceNames(directory)
+	if err != nil {
+		return nil, err
+	}
+	total := int64(0)
+	for _, name := range names {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		record, err := readContinuationReference(filepath.Join(directory, name), &total)
+		if err != nil {
+			return nil, err
+		}
+		source.files[name] = record
+	}
+	self, present := source.files[source.selfName]
+	if !present || !os.SameFile(self.node, selected.member.selectedNode) || self.digest != selected.sources[selected.member.selected] {
+		return nil, continuationSourceError()
+	}
+	// Every selected input retains its actual compiler key and complete bytes.
+	for filename, expected := range selected.sources {
+		parent, err := sourcepath.Resolve(filepath.Dir(filename))
+		record, present := source.files[filepath.Base(filename)]
+		if err != nil || parent != directory || !present || record.digest != expected {
+			return nil, continuationSourceError()
+		}
+	}
+	source.self = source
+	if err := source.verify(ctx, defines, config.Feature); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func (source *continuationReferenceSource) verifyInventory() error {
+	if source == nil || source.self != source || source.revoked.Load() || source.pkg == nil || source.selected == nil || source.selected.selection == nil || source.context == nil {
+		return continuationSourceError()
+	}
+	selection, pkg := source.selected.selection, source.pkg
+	if selection.identity != x86CallerSelectionIdentity(pkg, selection.env) || selection.types != pkg.Types ||
+		!reflect.DeepEqual(selection.sizes, x86CallerSizes(pkg.TypesSizes)) || len(selection.imports) != len(pkg.Imports) {
+		return continuationSourceError()
+	}
+	for path, dependency := range pkg.Imports {
+		if dependency == nil || dependency.Types != selection.imports[path] {
+			return continuationSourceError()
+		}
+	}
+	if err := source.selected.member.verify(); err != nil {
+		return err
+	}
+	for _, directory := range []assemblyMemberDirectory{source.packageDirectory, {source.directory, source.directory, source.directoryInfo}} {
+		info, err := sourcepath.Lstat(directory.path)
+		if err != nil || !os.SameFile(info, directory.info) {
+			return continuationSourceError()
+		}
+		physical, err := sourcepath.Resolve(directory.path)
+		if err != nil || physical != directory.physical {
+			return continuationSourceError()
+		}
+	}
+	names, err := continuationReferenceNames(source.directory)
+	if err != nil || len(names) != len(source.files) {
+		return continuationSourceError()
+	}
+	total := int64(0)
+	for _, name := range names {
+		expected, present := source.files[name]
+		if !present {
+			return continuationSourceError()
+		}
+		actual, err := readContinuationReference(filepath.Join(source.directory, name), &total)
+		if err != nil || actual.physical != expected.physical || actual.digest != expected.digest ||
+			!os.SameFile(actual.node, expected.node) || !os.SameFile(actual.target, expected.target) {
+			return continuationSourceError()
+		}
+	}
+	return nil
+}
+
+func (source *continuationReferenceSource) verify(ctx context.Context, defines []string, feature *featureConsumer) (result error) {
+	if source == nil {
+		return continuationSourceError()
+	}
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if err := source.verifyInventory(); err != nil {
+		source.revoked.Store(true)
+		return err
+	}
+	defer func() {
+		// Sample caller code before the final callback-free inventory guard.
+		result = errors.Join(result, ctx.Err(), source.context.Err(), source.verifyInventory())
+		if result != nil {
+			source.revoked.Store(true)
+		}
+	}()
+	return source.selected.verify(ctx, defines, feature)
+}
+
+func (source *continuationReferenceSource) releaseQueryBytes() {
+	for name, record := range source.files {
+		record.data = nil
+		source.files[name] = record
+	}
+}
diff --git a/cmd/plan9asmll/continuation_source_budget_test.go b/cmd/plan9asmll/continuation_source_budget_test.go
new file mode 100644
index 000000000..dc66349f1
--- /dev/null
+++ b/cmd/plan9asmll/continuation_source_budget_test.go
@@ -0,0 +1,73 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestContinuationReferenceInventoryBounds(t *testing.T) {
+	t.Run("reference-files", func(t *testing.T) {
+		directory := t.TempDir()
+		for index := 0; index < continuationReferenceFiles; index++ {
+			if err := os.WriteFile(filepath.Join(directory, fmt.Sprintf("reference_%04d.h", index)), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if names, err := continuationReferenceNames(directory); err != nil || len(names) != continuationReferenceFiles {
+			t.Fatalf("exact file boundary: %d %v", len(names), err)
+		}
+		if err := os.WriteFile(filepath.Join(directory, "extra.h"), nil, 0600); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := continuationReferenceNames(directory); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("unbounded reference representation: %v", err)
+		}
+	})
+	t.Run("ignored-directory-entries", func(t *testing.T) {
+		directory := t.TempDir()
+		for index := 0; index < continuationDirectoryEntries; index++ {
+			if err := os.WriteFile(filepath.Join(directory, fmt.Sprintf("ignored_%04d.note", index)), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if names, err := continuationReferenceNames(directory); err != nil || len(names) != 0 {
+			t.Fatalf("exact enumeration boundary: %d %v", len(names), err)
+		}
+		if err := os.WriteFile(filepath.Join(directory, "extra.note"), nil, 0600); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := continuationReferenceNames(directory); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("unbounded directory enumeration: %v", err)
+		}
+	})
+}
+
+func TestContinuationReferenceReadChargesBeforeRetention(t *testing.T) {
+	filename := filepath.Join(t.TempDir(), "reference.h")
+	if err := os.WriteFile(filename, []byte("ab"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, initial := range []int64{-1, continuationReferenceBytes - 1, continuationReferenceBytes + 1} {
+		total := initial
+		record, err := readContinuationReference(filename, &total)
+		if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || record.data != nil || total != initial {
+			t.Fatalf("invalid/oversized representation was retained: initial=%d total=%d error=%v", initial, total, err)
+		}
+	}
+	total := int64(continuationReferenceBytes - 2)
+	if record, err := readContinuationReference(filename, &total); err != nil || total != continuationReferenceBytes || string(record.data) != "ab" {
+		t.Fatalf("exact aggregate boundary: total=%d error=%v", total, err)
+	}
+	if err := os.Truncate(filename, continuationReferenceBytes+1); err != nil {
+		t.Fatal(err)
+	}
+	total = 0
+	if record, err := readContinuationReference(filename, &total); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || record.data != nil || total != 0 {
+		t.Fatalf("oversized actual file allocated a source tape: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/continuation_test.go b/cmd/plan9asmll/continuation_test.go
new file mode 100644
index 000000000..4288c9672
--- /dev/null
+++ b/cmd/plan9asmll/continuation_test.go
@@ -0,0 +1,159 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+const continuationGo = `package p
+func initTable()
+func run(n uint64) (result uint64)
+func step()
+func exit()
+`
+
+const continuationAsm = `
+TEXT ·initTable(SB),$0-0
+ LEAQ ·step(SB),AX
+ MOVQ AX,table<>(SB)
+ RET
+GLOBL table<>(SB),$8
+TEXT ·run(SB),$0-16
+ MOVQ n+0(FP),BX
+ TESTQ BX,BX
+ JNE start
+ JMP ·exit(SB)
+start:
+ LEAQ table<>(SB),R14
+ MOVQ (R14),AX
+ JMP AX
+TEXT ·step(SB),$0-0
+ ADDQ $1,BX
+ JMP ·exit(SB)
+TEXT ·exit(SB),$0-0
+ MOVQ BX,result+8(FP)
+ RET
+`
+
+func continuationPackage(t *testing.T, source, assembly string) (*packages.Package, string) {
+	return continuationPackageWithSources(t, source, assembly, nil)
+}
+
+func continuationPackageWithSources(t *testing.T, source, assembly string, extra map[string]string) (*packages.Package, string) {
+	t.Helper()
+	dir := t.TempDir()
+	goPath, asmPath := filepath.Join(dir, "p.go"), filepath.Join(dir, "p_amd64.s")
+	if strings.Contains(source, "go:linkname") {
+		source = strings.Replace(source, "package p\n", "package p\nimport _ \"unsafe\"\n", 1)
+	}
+	files := map[string]string{goPath: source, asmPath: assembly,
+		filepath.Join(dir, "go.mod"): "module example.com/continuations\n\ngo 1.20\n"}
+	for name, contents := range extra {
+		files[filepath.Join(dir, name)] = contents
+	}
+	for name, contents := range files {
+		if err := os.WriteFile(name, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, "example.com/continuations", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("complete actual continuation module: %v", err)
+	}
+	return pkgs[0], asmPath
+}
+
+func TestInferPrivateX86Continuations(t *testing.T) {
+	for _, test := range []struct {
+		name, goSource, asmSource, otherSource string
+		want                                   bool
+	}{
+		{name: "private_table", want: true},
+		{name: "go_call", goSource: continuationGo + "func use() { step() }"},
+		{name: "go_value", goSource: continuationGo + "var use = step"},
+		{name: "linkname", goSource: continuationGo + "\n//go:linkname step remote.step\n"},
+		{name: "external_asm", otherSource: "TEXT ·other(SB),$0-0\nJMP ·step(SB)\n"},
+		{name: "code_offset", asmSource: strings.Replace(continuationAsm, "LEAQ ·step(SB)", "LEAQ ·step+1(SB)", 1)},
+		{name: "partial_table", asmSource: strings.Replace(continuationAsm, "GLOBL table<>(SB),$8", "GLOBL table<>(SB),$16", 1)},
+		{name: "table_escape", asmSource: strings.Replace(continuationAsm, " MOVQ (R14),AX", " MOVQ R14,CX\n MOVQ (R14),AX", 1)},
+		{name: "table_uninitialized", asmSource: strings.Replace(continuationAsm, "start:\n", "start:\n JMP loaded\n", 1)},
+		{name: "table_overwrite", asmSource: strings.Replace(continuationAsm, " MOVQ (R14),AX", " MOVQ $123,R14\n MOVQ (R14),AX", 1)},
+		{name: "target_escape", asmSource: strings.Replace(continuationAsm, " JMP AX", " MOVQ AX,leak(SB)\n JMP AX", 1)},
+		{name: "label_bypass", asmSource: strings.Replace(continuationAsm, " JMP AX", "bypass:\n JMP AX", 1)},
+		{name: "unknown_jump", asmSource: strings.Replace(continuationAsm, " JMP AX", " JMP CX", 1)},
+		{name: "helper_call", asmSource: strings.Replace(continuationAsm, " JMP ·exit(SB)", " CALL ·exit(SB)\n JMP ·exit(SB)", 1)},
+		{name: "helper_frame", asmSource: strings.Replace(continuationAsm, "TEXT ·step(SB),$0-0", "TEXT ·step(SB),$8-0", 1)},
+		{name: "initializer_escape", asmSource: strings.Replace(continuationAsm, " MOVQ AX,table<>(SB)", " MOVQ AX,table<>(SB)\n MOVQ AX,leak(SB)", 1)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			goSource, asmSource := test.goSource, test.asmSource
+			if goSource == "" {
+				goSource = continuationGo
+			}
+			if asmSource == "" {
+				asmSource = continuationAsm
+			}
+			if test.name == "table_uninitialized" {
+				asmSource = strings.Replace(asmSource, " MOVQ (R14),AX", "loaded:\n MOVQ (R14),AX", 1)
+			}
+			extra := make(map[string]string)
+			if test.otherSource != "" {
+				extra["other.s"] = test.otherSource
+			}
+			pkg, path := continuationPackageWithSources(t, goSource, asmSource, extra)
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, asmSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			groups, _, err := inferX86TailGroups(pkg, file, path, "amd64", resolve, sigs, plan9asm.GoAssemblerDefines("linux", "amd64"), config)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := len(groups) == 1; got != test.want {
+				t.Fatalf("inferred groups %+v, want inference=%v", groups, test.want)
+			}
+		})
+	}
+}
+
+func TestCompileOnePreservesContinuationModule(t *testing.T) {
+	pkg, path := continuationPackage(t, continuationGo, continuationAsm)
+	config, err := resolveCompileConfig(true, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.MaxFunctions, config.MaxInstructions = 1, 1
+	config.x86CallerSelections = captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)
+	out := filepath.Join(filepath.Dir(path), "continuation.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: path, OutLL: out}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Count(string(ir), "define ") != 2 || !strings.Contains(string(ir), "blockaddress") {
+		t.Fatal("root and its table initializer were not retained together")
+	}
+	if _, err := os.Stat(strings.TrimSuffix(out, ".ll") + ".o"); !os.IsNotExist(err) {
+		t.Fatalf("temporary object not released: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/cpp_original_replay_consumer_test.go b/cmd/plan9asmll/cpp_original_replay_consumer_test.go
new file mode 100644
index 000000000..f925f657b
--- /dev/null
+++ b/cmd/plan9asmll/cpp_original_replay_consumer_test.go
@@ -0,0 +1,150 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestFeatureCPPOriginalExpandedOperandsRequireActualStageAndExactSet(t *testing.T) {
+	for _, generated := range []bool{false, true} {
+		name := "empty_active_set"
+		if generated {
+			name = "expanded_outside_operand"
+		}
+		t.Run(name, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, "linux/amd64")
+			assembly := input.AsmFiles[0]
+			source := "TEXT ·Probe(SB),4,$0-0\nRET\n"
+			include, tool := "../../src/runtime/go_tls.h", "src/runtime/go_tls.h"
+			if generated {
+				source = "#define SELECT \\\n#include \"" + include + "\" \\\n\nSELECT\n" + source
+			}
+			if err := os.WriteFile(filepath.Join(dir, assembly), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources[assembly], input.Headers[assembly] = featureBytesSHA256([]byte(source)), source
+			unit := gotoolprofile.CPPOriginalUnit{Includes: map[string]string{}}
+			input.CPPSourceProtocol = gotoolprofile.CPPOriginalReplayProtocol
+			input.CPPOriginals = &gotoolprofile.CPPOriginalReplayInput{
+				Sources:                  map[string]string{"module/" + assembly: source},
+				Units:                    map[string]gotoolprofile.CPPOriginalUnit{assembly: unit},
+				RequiredExpandedOperands: map[string][]gotoolprofile.CPPPackageSearchMiss{},
+			}
+			if generated {
+				data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+				if err != nil {
+					t.Fatal(err)
+				}
+				input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+				input.CPPOriginals.Sources["tool/"+tool] = string(data)
+				unit.Includes[include] = "tool/" + tool
+			}
+			canonical, err := filepath.EvalSymlinks(dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			consumer := &featureConsumer{Input: input, Context: ctx, Dir: canonical, Root: runtime.GOROOT()}
+			file := filepath.Join(canonical, assembly)
+			if _, _, err := consumer.preprocessCPP(file, input.Module, nil); err == nil {
+				t.Fatal("input-only query graph was accepted at actual CPP/object stage")
+			}
+			_, _, required, err := gotoolprofile.ReplayCPPOriginal(input, assembly, input.Module, nil, nil)
+			if err != nil || required == nil {
+				t.Fatalf("actual full original replay did not return an explicit set: %v", err)
+			}
+			input.CPPOriginals.RequiredExpandedOperands[assembly] = required
+			input.CPPIncludeSearchMisses = required
+			if _, _, err := consumer.preprocessCPP(file, input.Module, nil); err != nil {
+				t.Fatalf("complete independently supplied expanded set was rejected: %v", err)
+			}
+			encoded, err := gotoolprofile.MarshalConsumerInput(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutations := map[string]func(*gotoolprofile.ConsumerInput){
+				"missing_set":          func(copy *gotoolprofile.ConsumerInput) { delete(copy.CPPOriginals.RequiredExpandedOperands, assembly) },
+				"null_set":             func(copy *gotoolprofile.ConsumerInput) { copy.CPPOriginals.RequiredExpandedOperands[assembly] = nil },
+				"delete_graph_only":    func(copy *gotoolprofile.ConsumerInput) { copy.CPPOriginals = nil },
+				"delete_protocol_only": func(copy *gotoolprofile.ConsumerInput) { copy.CPPSourceProtocol = "" },
+				"changed_original":     func(copy *gotoolprofile.ConsumerInput) { copy.CPPOriginals.Sources["module/"+assembly] += "\n" },
+				"paired_original_and_hash": func(copy *gotoolprofile.ConsumerInput) {
+					changed := copy.CPPOriginals.Sources["module/"+assembly] + "GLOBL ·forged(SB),$8\n"
+					copy.CPPOriginals.Sources["module/"+assembly] = changed
+					copy.Sources[assembly] = featureBytesSHA256([]byte(changed))
+				},
+				"extra_unconsumed_receipt": func(copy *gotoolprofile.ConsumerInput) {
+					miss := gotoolprofile.CPPPackageSearchMiss{Protocol: gotoolprofile.CPPExpandedPackageSearchMissProtocol,
+						Assembly: assembly, Include: include, PackageCandidate: include, ToolSource: tool}
+					copy.CPPIncludeSearchMisses = append(copy.CPPIncludeSearchMisses, miss)
+				},
+			}
+			if generated {
+				mutations["paired_deleted_receipt"] = func(copy *gotoolprofile.ConsumerInput) {
+					copy.CPPIncludeSearchMisses = nil
+					copy.CPPOriginals.RequiredExpandedOperands[assembly] = []gotoolprofile.CPPPackageSearchMiss{}
+				}
+				mutations["paired_v1_downgrade"] = func(copy *gotoolprofile.ConsumerInput) {
+					copy.CPPIncludeSearchMisses[0].Protocol = gotoolprofile.CPPPackageSearchMissProtocol
+					copy.CPPIncludeSearchMisses[0].Source = "module/" + assembly
+					copy.CPPOriginals.RequiredExpandedOperands[assembly] = copy.CPPIncludeSearchMisses
+				}
+				mutations["fake_physical_source"] = func(copy *gotoolprofile.ConsumerInput) { copy.CPPIncludeSearchMisses[0].Source = "module/" + assembly }
+				mutations["paired_tool_body_hash"] = func(copy *gotoolprofile.ConsumerInput) {
+					changed := copy.CPPOriginals.Sources["tool/"+tool] + "#define FORGED 1\n"
+					copy.CPPOriginals.Sources["tool/"+tool] = changed
+					copy.ToolSources[tool] = featureBytesSHA256([]byte(changed))
+				}
+			}
+			for name, mutate := range mutations {
+				t.Run(name, func(t *testing.T) {
+					var copy gotoolprofile.ConsumerInput
+					if err := json.Unmarshal(encoded, &copy); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&copy)
+					actual := *consumer
+					actual.Input = &copy
+					if _, _, err := actual.preprocessCPP(file, input.Module, nil); err == nil {
+						t.Fatal("changed actual stage/source/absence inputs were accepted")
+					}
+				})
+			}
+			cancel()
+			if _, _, err := consumer.preprocessCPP(file, input.Module, nil); err == nil {
+				t.Fatal("canceled actual CPP read was accepted")
+			}
+		})
+	}
+}
+
+func TestFeatureCPPExpandedOutsidePreferredFileAppearingIsRejected(t *testing.T) {
+	parent := t.TempDir()
+	module := filepath.Join(parent, "owned", "module")
+	if err := os.MkdirAll(module, 0700); err != nil {
+		t.Fatal(err)
+	}
+	miss := gotoolprofile.CPPPackageSearchMiss{Protocol: gotoolprofile.CPPExpandedPackageSearchMissProtocol,
+		Assembly: "probe.s", Include: "../../src/runtime/go_tls.h", PackageCandidate: "../../src/runtime/go_tls.h", ToolSource: "src/runtime/go_tls.h"}
+	if err := gotoolprofile.VerifyCPPPackageSearchMiss(miss, module, runtime.GOROOT()); err != nil {
+		t.Fatal(err)
+	}
+	preferred := filepath.Join(parent, "src", "runtime", "go_tls.h")
+	if err := os.MkdirAll(filepath.Dir(preferred), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(preferred, []byte("#define FORGED 1\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.VerifyCPPPackageSearchMiss(miss, module, runtime.GOROOT()); err == nil {
+		t.Fatal("late preferred original package candidate did not revoke fallback")
+	}
+}
diff --git a/cmd/plan9asmll/cpp_tool_include_eof_test.go b/cmd/plan9asmll/cpp_tool_include_eof_test.go
new file mode 100644
index 000000000..6a7a61d89
--- /dev/null
+++ b/cmd/plan9asmll/cpp_tool_include_eof_test.go
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestFeatureCPPIncludedEOFDoesNotInventTranslationUnitNewline(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const include = "../../src/runtime/go_tls.h"
+	const header = "#include \"" + include + "\""
+	const marker = "TEXT ·Probe(SB),$0-0\nRET\n"
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			file := input.AsmFiles[0]
+			source := "#include \"eof.h\"\n\n" + marker
+			for name, body := range map[string]string{file: source, "eof.h": header} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[name] = featureBytesSHA256([]byte(body))
+			}
+			input.Headers[file] = source
+			input.Directories["."] = append(input.Directories["."], "eof.h")
+			sort.Strings(input.Directories["."])
+			tool := "src/runtime/go_tls.h"
+			data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+			input.CPPIncludeSearchMisses = []gotoolprofile.CPPPackageSearchMiss{{
+				Protocol: gotoolprofile.CPPPackageSearchMissProtocol, Assembly: file, Source: "module/eof.h",
+				Include: include, PackageCandidate: include, ToolSource: tool,
+			}}
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			parts := strings.Split(target, "/")
+			report, _, err := runOneTarget(targetSpec{Goos: parts[0], Goarch: parts[1]}, []string{"."}, nil,
+				input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("original included EOF Go/profile/CPP/LLVM object: %#v %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			canonical, err := json.Marshal(report.FeatureSelection)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+				"drop absence": func(p *gotoolprofile.SelectionProof) { p.CPPIncludeSearchMisses = nil },
+				"wrong parent": func(p *gotoolprofile.SelectionProof) { p.CPPIncludeSearchMisses[0].Source = "module/" + file },
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.SelectionProof
+					if err := json.Unmarshal(canonical, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+						t.Fatal("included EOF consumer proof was downgraded")
+					}
+				})
+			}
+			canonicalDir, err := filepath.EvalSymlinks(dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			consumer := &featureConsumer{Input: input, Context: ctx, Dir: canonicalDir, Root: runtime.GOROOT()}
+			originalMiss := input.CPPIncludeSearchMisses[0]
+			input.CPPIncludeSearchMisses = nil
+			if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err == nil {
+				t.Fatal("deleting the input absence contract downgraded active included EOF")
+			}
+			input.CPPIncludeSearchMisses = []gotoolprofile.CPPPackageSearchMiss{originalMiss}
+			input.CPPIncludeSearchMisses[0].Source = "module/" + file
+			if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err == nil {
+				t.Fatal("translation unit replaced the actual included-EOF operand parent")
+			}
+			input.CPPIncludeSearchMisses[0] = originalMiss
+
+			// Updating the original bytes and hash cannot authorize a newline
+			// that the active translation-unit input stack does not contain.
+			source = marker + header
+			if err := os.WriteFile(filepath.Join(dir, file), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources[file], input.Headers[file] = featureBytesSHA256([]byte(source)), source
+			input.CPPIncludeSearchMisses[0].Source = "module/" + file
+			if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err == nil {
+				t.Fatal("active CPP invented a translation-unit EOF newline")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/cpp_tool_relative_test.go b/cmd/plan9asmll/cpp_tool_relative_test.go
new file mode 100644
index 000000000..e2130f69f
--- /dev/null
+++ b/cmd/plan9asmll/cpp_tool_relative_test.go
@@ -0,0 +1,83 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestFeatureCPPCanonicalToolRelativeFiveArchitectureObjects(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			file := input.AsmFiles[0]
+			source := "#include \"../../src/runtime/go_tls.h\"\nTEXT ·Probe(SB),$0-0\nRET\n"
+			if err := os.WriteFile(filepath.Join(dir, file), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources[file], input.Headers[file] = featureBytesSHA256([]byte(source)), source
+			tool := "src/runtime/go_tls.h"
+			data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+			input.CPPIncludeSearchMisses = []gotoolprofile.CPPPackageSearchMiss{{
+				Protocol: gotoolprofile.CPPPackageSearchMissProtocol, Assembly: file,
+				Source: "module/" + file, Include: "../../src/runtime/go_tls.h",
+				PackageCandidate: "../../src/runtime/go_tls.h", ToolSource: tool,
+			}}
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			parts := strings.Split(target, "/")
+			report, _, err := runOneTarget(targetSpec{Goos: parts[0], Goarch: parts[1]}, []string{"."}, nil,
+				input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("real stock Go/package/CPP/LLVM tool fallback: %#v %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			proofJSON, err := json.Marshal(report.FeatureSelection)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+				"missing absence": func(p *gotoolprofile.SelectionProof) { p.CPPIncludeSearchMisses = nil },
+				"wrong source":    func(p *gotoolprofile.SelectionProof) { p.CPPIncludeSearchMisses[0].Source = "module/layout.go" },
+				"wrong preferred": func(p *gotoolprofile.SelectionProof) {
+					p.CPPIncludeSearchMisses[0].PackageCandidate = "../src/runtime/go_tls.h"
+				},
+				"wrong tool": func(p *gotoolprofile.SelectionProof) { p.CPPIncludeSearchMisses[0].ToolSource = "src/runtime/other.h" },
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.SelectionProof
+					if err := json.Unmarshal(proofJSON, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+						t.Fatal("changed tool-relative search proof was accepted")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/cpp_tool_root_alias_test.go b/cmd/plan9asmll/cpp_tool_root_alias_test.go
new file mode 100644
index 000000000..e6f0bcb3a
--- /dev/null
+++ b/cmd/plan9asmll/cpp_tool_root_alias_test.go
@@ -0,0 +1,76 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestFeatureCPPToolRootAliasRetainsExactSource(t *testing.T) {
+	module, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	root, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "sdk")
+	if err := os.Symlink(root, alias); err != nil {
+		t.Fatal(err)
+	}
+	header := "pkg/include/value.h"
+	filename := filepath.Join(root, filepath.FromSlash(header))
+	if err := os.MkdirAll(filepath.Dir(filename), 0700); err != nil {
+		t.Fatal(err)
+	}
+	contents := "#define VALUE 41\n"
+	if err := os.WriteFile(filename, []byte(contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	source := "#include \"value.h\"\nTEXT ·Value(SB),$0-0\nMOVQ $VALUE, AX\nRET\n"
+	asm := filepath.Join(module, "value.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input := &gotoolprofile.ConsumerInput{
+		Module: "example.invalid/alias", Sources: map[string]string{"value.s": featureBytesSHA256([]byte(source))},
+		ToolSources: map[string]string{header: featureBytesSHA256([]byte(contents))},
+	}
+	consumer := &featureConsumer{Input: input, Dir: module, Root: alias}
+	for _, spelling := range []string{root, alias} {
+		consumer.Root = spelling
+		expanded, inputs, err := consumer.preprocessCPP(asm, input.Module, nil)
+		if err != nil || !strings.Contains(string(expanded), "$41") || inputs["tool/"+header] != input.ToolSources[header] {
+			t.Fatalf("original tool bytes through root alias: %s %v: %v", expanded, inputs, err)
+		}
+	}
+	delete(input.ToolSources, header)
+	if _, _, err := consumer.preprocessCPP(asm, input.Module, nil); err == nil {
+		t.Fatal("unregistered tool header was accepted")
+	}
+	input.ToolSources[header] = featureBytesSHA256([]byte(contents))
+	if err := os.WriteFile(filename, []byte("#define VALUE 99\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := consumer.preprocessCPP(asm, input.Module, nil); err == nil {
+		t.Fatal("changed tool header was accepted")
+	}
+	outside := filepath.Join(t.TempDir(), "value.h")
+	if err := os.WriteFile(outside, []byte(contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Remove(filename); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(outside, filename); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := consumer.preprocessCPP(asm, input.Module, nil); err == nil {
+		t.Fatal("identical bytes redirected outside the tool root were accepted")
+	}
+}
diff --git a/cmd/plan9asmll/cpp_tool_search_downgrade_test.go b/cmd/plan9asmll/cpp_tool_search_downgrade_test.go
new file mode 100644
index 000000000..d9fefc991
--- /dev/null
+++ b/cmd/plan9asmll/cpp_tool_search_downgrade_test.go
@@ -0,0 +1,80 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestFeatureCPPOutsidePackageSearchCannotDowngradeToLegacyToolPrefix(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	file := input.AsmFiles[0]
+	source := "#include \"../../pkg/include/textflag.h\"\nTEXT ·Probe(SB),NOSPLIT,$0-0\nRET\n"
+	if err := os.WriteFile(filepath.Join(dir, file), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources[file], input.Headers[file] = featureBytesSHA256([]byte(source)), source
+	tool := "pkg/include/textflag.h"
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+	canonicalDir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer := &featureConsumer{Input: input, Context: ctx, Dir: canonicalDir, Root: runtime.GOROOT()}
+	if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err == nil {
+		t.Fatal("missing outside-package absence was accepted because the tool retained a legacy prefix")
+	}
+	miss := gotoolprofile.CPPPackageSearchMiss{
+		Protocol: gotoolprofile.CPPPackageSearchMissProtocol, Assembly: file, Source: "module/" + file,
+		Include: "../../pkg/include/textflag.h", PackageCandidate: "../../pkg/include/textflag.h", ToolSource: tool,
+	}
+	input.CPPIncludeSearchMisses = []gotoolprofile.CPPPackageSearchMiss{miss}
+	if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err != nil {
+		t.Fatalf("exact original pkg/include fallback contract was rejected: %v", err)
+	}
+	unused := "#include \"../../pkg/include/textflag.h\"\n"
+	if err := os.WriteFile(filepath.Join(dir, "unused.h"), []byte(unused), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["unused.h"] = featureBytesSHA256([]byte(unused))
+	input.CPPIncludeSearchMisses[0].Source = "module/unused.h"
+	if _, _, err := consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil); err == nil {
+		t.Fatal("matching literal in an unconsumed source substituted for the actual include parent")
+	}
+}
+
+func TestFeatureCPPUnboundOriginIsRejectedBeforeReading(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	file := input.AsmFiles[0]
+	source := "#include \"unbound.h\"\nTEXT ·Probe(SB),$0-0\nRET\n"
+	if err := os.WriteFile(filepath.Join(dir, file), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources[file] = featureBytesSHA256([]byte(source))
+	// Opening a directory succeeds, but reading its data fails. The error must
+	// instead originate from the missing source identity before that read.
+	if err := os.Mkdir(filepath.Join(dir, "unbound.h"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	canonicalDir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{Input: input, Dir: canonicalDir, Root: runtime.GOROOT()}
+	_, _, err = consumer.preprocessCPP(filepath.Join(canonicalDir, file), input.Module, nil)
+	if err == nil || !strings.Contains(err.Error(), "provenance") || strings.Contains(err.Error(), "read contract") {
+		t.Fatalf("unbound source was not rejected before opening/reading it: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/data_only_assembly.go b/cmd/plan9asmll/data_only_assembly.go
new file mode 100644
index 000000000..fa3081ef0
--- /dev/null
+++ b/cmd/plan9asmll/data_only_assembly.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func proveDataOnlyAssembly(pkg *packages.Package, task asmTask, file *plan9asm.File, target string, defines []string, cfg compileConfig) (*gotoolprofile.DataOnlyAssemblyProof, error) {
+	if file == nil || len(file.Funcs) != 0 || len(file.Globl) == 0 {
+		return nil, fmt.Errorf("data-only source requires global declarations and no TEXT")
+	}
+	var symbols []gotoolprofile.DataOnlySymbol
+	native, err := proveAssemblyListing(pkg, task, target, defines, cfg, func(listing []byte, version string) error {
+		var err error
+		symbols, err = gotoolprofile.DataOnlySymbolsFromListingForGoVersion(listing, version)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+	if err := gotoolprofile.ValidateDataOnlySourceSymbols(file, pkg.PkgPath, symbols); err != nil {
+		return nil, err
+	}
+	native.Protocol = gotoolprofile.DataOnlyAssemblyProtocol
+	return &gotoolprofile.DataOnlyAssemblyProof{Native: *native, Symbols: symbols}, nil
+}
+
+// cmd/asm qualifies local symbols with objabi.PathToPrefix, not the logical
+// import path used by LLVM. Keep the original native listing spelling intact.
+// This is Go's byte-level rule; URL escaping changes different characters.
+func nativeGoPackagePrefix(packagePath string) string {
+	return gotoolprofile.NativeGoPackagePrefix(packagePath)
+}
diff --git a/cmd/plan9asmll/data_only_package_prefix_test.go b/cmd/plan9asmll/data_only_package_prefix_test.go
new file mode 100644
index 000000000..538c6f979
--- /dev/null
+++ b/cmd/plan9asmll/data_only_package_prefix_test.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestDataOnlyNativePackagePrefixNames(t *testing.T) {
+	const source = "GLOBL ·payload(SB),$8\nGLOBL ·private<>(SB),$16\nGLOBL external·literal(SB),$4\n"
+	for _, test := range []struct {
+		path, prefix string
+	}{
+		{"example.invalid/asmhdr.dir", "example.invalid/asmhdr%2edir"},
+		{"example.invalid/parent.dir/plain", "example.invalid/parent.dir/plain"},
+		{"example.invalid/percent%name", "example.invalid/percent%25name"},
+		{"example.invalid/é", "example.invalid/%c3%a9"},
+		{"example.invalid/quote\"name", "example.invalid/quote%22name"},
+		{"example.invalid/space name", "example.invalid/space%20name"},
+		{"example.invalid/control\tname", "example.invalid/control%09name"},
+		{"example.invalid/del\x7fname", "example.invalid/del%7fname"},
+	} {
+		t.Run(test.path, func(t *testing.T) {
+			directory := t.TempDir()
+			filename := filepath.Join(directory, "data.s")
+			if err := os.WriteFile(filename, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			proof, err := proveDataOnlyAssembly(&packages.Package{PkgPath: test.path},
+				asmTask{AsmFile: filename}, file, "linux/amd64", nil, compileConfig{Context: ctx})
+			if err != nil {
+				t.Fatalf("original Go data symbol prefix differs from its bound package: %v", err)
+			}
+			want := map[string]int64{
+				test.prefix + ".payload": 8, test.prefix + ".private<>": 16, "external.literal": 4,
+			}
+			if len(proof.Symbols) != len(want) {
+				t.Fatalf("incomplete original symbol inventory: %+v", proof.Symbols)
+			}
+			for _, symbol := range proof.Symbols {
+				if size, found := want[symbol.Key()]; !found || size != symbol.Size {
+					t.Fatalf("native spelling/static identity was rewritten: %+v", symbol)
+				}
+			}
+			replacements := []string{"·other", "external·other"}
+			if test.path != test.prefix {
+				replacements = append(replacements, test.path+"·payload")
+			}
+			for _, replacement := range replacements {
+				changed, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				changed.Globl[0].Sym = replacement
+				if _, err := proveDataOnlyAssembly(&packages.Package{PkgPath: test.path},
+					asmTask{AsmFile: filename}, changed, "linux/amd64", nil, compileConfig{Context: ctx}); err == nil {
+					t.Fatalf("native source name accepted a rewritten symbol: %q", replacement)
+				}
+			}
+		})
+	}
+}
+
+func TestDataOnlyEscapedPackageCurrentSignatureProof(t *testing.T) {
+	repository, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err = filepath.Abs(goBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, directory := featureConsumerFixture(t)
+			input.Module = "example.invalid/asmhdr.dir"
+			module := "module " + input.Module + "\n\ngo 1.24\n"
+			if err := os.WriteFile(filepath.Join(directory, "go.mod"), []byte(module), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["go.mod"] = featureBytesSHA256([]byte(module))
+			if err := os.Remove(filepath.Join(directory, "probe_amd64.s")); err != nil {
+				t.Fatal(err)
+			}
+			delete(input.Sources, "probe_amd64.s")
+			delete(input.Headers, "probe_amd64.s")
+			const source = "DATA ·payload+0(SB)/8,$0x123456789abcdef0\nGLOBL ·payload(SB),$8\nGLOBL ·zero(SB),$16\n"
+			if err := os.WriteFile(filepath.Join(directory, "tables.s"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["tables.s"], input.Headers["tables.s"] = featureBytesSHA256([]byte(source)), source
+			input.AsmFiles = []string{"tables.s"}
+			input.Directories["."] = []string{"fallback.go", "go.mod", "selected.go", "tables.s"}
+			input.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+			input.TestDependencySourceProtocol = gotoolprofile.TestDependencyProtocol
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			input.Observed, err = gotoolprofile.Capture(ctx, goBinary, t.TempDir(), os.Environ(), target, nil, gotoolprofile.RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.ID = gotoolprofile.ProfileID(input.Observed)
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context, config.FeaturePath = ctx, writeFeatureInput(t, input)
+			spec, err := parseTargetSpec(target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Chdir(directory)
+			query := &gotoolprofile.SignatureQueryProof{Protocol: gotoolprofile.SignatureQueryProtocol}
+			queryConfig := config
+			queryConfig.Enabled, queryConfig.SignatureQuery = false, query
+			result, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module,
+				t.TempDir(), false, 0, true, false, true, repository, queryConfig)
+			if err != nil || result.Failed != 0 || result.Success != 0 || len(query.Requests) != 0 {
+				t.Fatalf("data-only metadata query claims failure/signature/object: %+v, %v", result, err)
+			}
+			if err := gotoolprofile.ValidateSignatureQuery(input, query, nil); err != nil {
+				t.Fatal(err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, query.Selection, nil, true); err == nil {
+				t.Fatal("native data-only query was accepted as a final LLVM object proof")
+			}
+			output := t.TempDir()
+			result, _, err = runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module,
+				output, false, 0, true, false, true, repository, config)
+			if err != nil || result.Success != 1 || result.Failed != 0 || result.NotApplicable != 0 {
+				t.Fatalf("escaped package data-only object: %+v, %v", result, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, result.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			checkDataOnlyAssemblyProofMutants(t, input, result.FeatureSelection)
+			object := filepath.Join(output, filepath.FromSlash(input.Module), "tables.s.o")
+			if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+				t.Fatalf("success omitted its actual LLVM object: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/directive_diagnostics_test.go b/cmd/plan9asmll/directive_diagnostics_test.go
new file mode 100644
index 000000000..3b63be571
--- /dev/null
+++ b/cmd/plan9asmll/directive_diagnostics_test.go
@@ -0,0 +1,24 @@
+package main
+
+import "testing"
+
+func TestDirectiveDiagnosticsIncludesCompletePCAlignmentFamily(t *testing.T) {
+	for _, name := range []string{"PCALIGN", "PCALIGNMAX", "PCDATA", "FUNCDATA"} {
+		if !isDirective(name) {
+			t.Errorf("%s is misclassified as a missing machine instruction", name)
+		}
+	}
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			supported, err := extractSupportedOps("../..", arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PCALIGN", "PCALIGNMAX", "PCDATA", "FUNCDATA"} {
+				if _, known := supported[name]; !known {
+					t.Errorf("diagnostic inventory omitted directive %s", name)
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/divide_supported_test.go b/cmd/plan9asmll/divide_supported_test.go
new file mode 100644
index 000000000..33387ac6e
--- /dev/null
+++ b/cmd/plan9asmll/divide_supported_test.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteImplicitDivideTypedFamily(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_implicit_divide.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, contents := range map[string][]byte{
+		"amd64_implicit_divide.go": data,
+		"translate.go":             []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{directory, "../.."} {
+		for _, arch := range []string{"386", "amd64"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"DIVB", "DIVW", "DIVL", "DIVQ", "IDIVB", "IDIVW", "IDIVL", "IDIVQ"} {
+				if _, found := supported[op]; !found {
+					t.Fatal("complete division family disappeared from opcode reporting", arch, op)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/duplicate_move_supported_test.go b/cmd/plan9asmll/duplicate_move_supported_test.go
new file mode 100644
index 000000000..4a3cd6c4a
--- /dev/null
+++ b/cmd/plan9asmll/duplicate_move_supported_test.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteDuplicateMoveTypedFamily(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_duplicate_move_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, contents := range map[string][]byte{
+		"amd64_duplicate_move_forms.go": data,
+		"translate.go":                  []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{directory, "../.."} {
+		for _, arch := range []string{"386", "amd64"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"MOVDDUP", "MOVSHDUP", "MOVSLDUP", "VMOVDDUP", "VMOVSHDUP", "VMOVSLDUP"} {
+				if _, found := supported[op]; !found {
+					t.Fatal("typed duplicate family disappeared from CLI reporting", arch, op)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/dword_product_extraction_test.go b/cmd/plan9asmll/dword_product_extraction_test.go
new file mode 100644
index 000000000..ce53cd3a2
--- /dev/null
+++ b/cmd/plan9asmll/dword_product_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsDwordProductTypedTable(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_dword_product_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_dword_product_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PMULDQ", "PMULULQ", "VPMULDQ", "VPMULUDQ"} {
+				if _, exists := supported[name]; !exists {
+					t.Fatal("typed-table extraction omitted family member", arch, name)
+				}
+			}
+			for _, name := range []string{"PMULUDQ", "PMULDQ.BAD", "pmuludq", "x86PackedLogicalVEXOrEVEX"} {
+				if _, exists := supported[name]; exists {
+					t.Fatal("typed table advertised non-source opcode", arch, name)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/dynamic_frame_diagnostic.go b/cmd/plan9asmll/dynamic_frame_diagnostic.go
new file mode 100644
index 000000000..400bd79c3
--- /dev/null
+++ b/cmd/plan9asmll/dynamic_frame_diagnostic.go
@@ -0,0 +1,73 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func unboundCallerFrameEntry(fn plan9asm.Func, resolve func(string) string,
+	sigs map[string]plan9asm.FuncSig, declaredSizes map[string]int64,
+) (string, bool) {
+	name := resolve(stripABISuffix(fn.Sym))
+	sig, known := sigs[name]
+	size, declared := declaredSizes[name]
+	if !known || !declared || size != 0 || hasExplicitTextArgSize(fn) ||
+		len(sig.Args) != 0 || sig.Ret != plan9asm.Void ||
+		len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0 {
+		return "", false
+	}
+	for _, ins := range fn.Instrs {
+		for _, operand := range ins.Args {
+			if operand.Kind == plan9asm.OpFP || operand.Kind == plan9asm.OpFPAddr {
+				return name, true
+			}
+		}
+	}
+	return "", false
+}
+
+// Source shape only selects a diagnostic probe. Only the complete translator's
+// actual dynamic-entry failure may precede ordinary frame-owner capture. A
+// successful probe, another failure, or an unrelated symbol grants nothing.
+func rejectUnboundCallerFrame(file *plan9asm.File, options plan9asm.Options, declaredSizes map[string]int64) error {
+	for _, fn := range file.Funcs {
+		if _, candidate := unboundCallerFrameEntry(fn, options.ResolveSym, options.Sigs, declaredSizes); !candidate {
+			continue
+		}
+		// Translate owns and releases its temporary LLVM context and module.
+		// Even a successful result is never published or returned to a caller.
+		if _, err := plan9asm.Translate(file, options); err != nil {
+			original := fmt.Errorf("translate: %w", err)
+			if annotated := annotateUnboundCallerFrame(file, options.ResolveSym, options.Sigs, declaredSizes, original); annotated != original {
+				return annotated
+			}
+		}
+		break
+	}
+	return nil
+}
+
+// This is a failed-entry diagnostic, not signature inference or an exception.
+// An omitted TEXT argument size and a zero-argument source declaration do not
+// describe the caller-owned frame addressed by the assembly. Keep the original
+// Context error and every ordinary source/translation applicability decision.
+func annotateUnboundCallerFrame(file *plan9asm.File, resolve func(string) string,
+	sigs map[string]plan9asm.FuncSig, declaredSizes map[string]int64, err error,
+) error {
+	if file == nil || resolve == nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "bound typed frame storage") {
+		return err
+	}
+	for _, fn := range file.Funcs {
+		name, candidate := unboundCallerFrameEntry(fn, resolve, sigs, declaredSizes)
+		if !candidate ||
+			!strings.HasPrefix(err.Error(), "translate: "+name+": ") {
+			continue
+		}
+		return fmt.Errorf("%w; actual source: empty Go declaration does not bind a dynamic caller frame; TEXT argument size is unspecified; local stack size, argument-only length and pointer bitmap are not a complete caller-frame contract", err)
+	}
+	return err
+}
diff --git a/cmd/plan9asmll/dynamic_frame_diagnostic_test.go b/cmd/plan9asmll/dynamic_frame_diagnostic_test.go
new file mode 100644
index 000000000..cfb5fdc90
--- /dev/null
+++ b/cmd/plan9asmll/dynamic_frame_diagnostic_test.go
@@ -0,0 +1,174 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestDynamicFPDiagnosticRequiresActualSourceFacts(t *testing.T) {
+	resolve := resolveSymFunc("example/dynamic")
+	name := "example/dynamic.Stub"
+	contextErr := fmt.Errorf("translate: %s: %w: bound typed frame storage", name, plan9asm.ErrProbeNeedsContext)
+	for _, test := range []struct {
+		name   string
+		text   string
+		source string
+		sig    plan9asm.FuncSig
+		decl   bool
+		size   int64
+		err    error
+		want   bool
+	}{
+		{name: "dynamic", source: "LEAL argframe+0(FP), AX", decl: true, err: contextErr, want: true},
+		{name: "explicit_zero_size", text: "20-0", source: "LEAL argframe+0(FP), AX", decl: true, err: contextErr},
+		{name: "no_FP", source: "MOVL $0, AX", decl: true, err: contextErr},
+		{name: "fallback_not_declaration", source: "LEAL argframe+0(FP), AX", err: contextErr},
+		{name: "nonempty_declaration", source: "LEAL argframe+0(FP), AX", decl: true, size: 4, err: contextErr},
+		{name: "ordinary_argument", source: "LEAL argframe+0(FP), AX", decl: true, sig: plan9asm.FuncSig{Args: []plan9asm.LLVMType{plan9asm.I32}}, err: contextErr},
+		{name: "ordinary_result", source: "LEAL argframe+0(FP), AX", decl: true, sig: plan9asm.FuncSig{Ret: plan9asm.I32}, err: contextErr},
+		{name: "bound_frame", source: "LEAL argframe+0(FP), AX", decl: true, sig: plan9asm.FuncSig{Frame: plan9asm.FrameLayout{Params: []plan9asm.FrameSlot{{Type: plan9asm.I32}}}}, err: contextErr},
+		{name: "different_failed_function", source: "LEAL argframe+0(FP), AX", decl: true, err: fmt.Errorf("translate: other: %w: bound typed frame storage", plan9asm.ErrProbeNeedsContext)},
+		{name: "different_context", source: "LEAL argframe+0(FP), AX", decl: true, err: fmt.Errorf("translate: %s: %w: missing call ABI", name, plan9asm.ErrProbeNeedsContext)},
+		{name: "source_error", source: "LEAL argframe+0(FP), AX", decl: true, err: errors.New("source declaration rejected")},
+		{name: "success", source: "LEAL argframe+0(FP), AX", decl: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			text := test.text
+			if text == "" {
+				text = "20"
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT ·Stub(SB),4,$"+text+"\n"+test.source+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := test.sig
+			sig.Name = name
+			if sig.Ret == "" {
+				sig.Ret = plan9asm.Void
+			}
+			declared := map[string]int64{}
+			if test.decl {
+				declared[name] = test.size
+			}
+			got := annotateUnboundCallerFrame(file, resolve, map[string]plan9asm.FuncSig{name: sig}, declared, test.err)
+			annotated := got != nil && strings.Contains(got.Error(), "empty Go declaration does not bind a dynamic caller frame")
+			if annotated != test.want {
+				t.Fatalf("diagnostic annotation=%v want=%v: %v", annotated, test.want, got)
+			}
+			if test.want {
+				if !errors.Is(got, test.err) || !errors.Is(got, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("diagnostic changed the original failure identity: %v", got)
+				}
+			} else if got != test.err {
+				t.Fatalf("unrelated outcome was rewritten: %v", got)
+			}
+		})
+	}
+}
+
+// A result-only, non-pointer function has argLen=0 and no pointer bits, yet it
+// needs real result storage. Its dynamic stub's separate func() declaration
+// cannot infer that storage from either zero or from TEXT's outgoing locals.
+func TestDynamicFPMetadataCannotSubstituteForCallerFrame(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64", "arm"} {
+		t.Run(goarch, func(t *testing.T) {
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, "contract.go", `package dynamic
+const argLen = 0
+const pointerBitmap = 0
+func Stub()
+func ResultOnly() uint64
+`, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", goarch)
+			config := types.Config{Sizes: sizes}
+			typed, err := config.Check("example/dynamic", fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := &packages.Package{Types: typed, TypesSizes: sizes, Syntax: []*ast.File{syntax}}
+			resolve := resolveSymFunc(typed.Path())
+			arch, err := toPlan9Arch(goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			address := "LEAL argframe+0(FP), AX"
+			if goarch == "amd64" {
+				address = "LEAQ argframe+0(FP), AX"
+			} else if goarch == "arm" {
+				address = "MOVW $argframe+0(FP), R4"
+			}
+			for _, locals := range []int{20, 40, 64} {
+				file, err := plan9asm.Parse(arch, fmt.Sprintf("TEXT ·Stub(SB),4,$%d\n%s\nRET\nTEXT ·ResultOnly(SB),4,$0\nRET\n", locals, address))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs, declared, err := sigsForAsmFile(pkg, file, resolve, goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if declared["example/dynamic.Stub"] != 0 || declared["example/dynamic.ResultOnly"] != 8 ||
+					len(sigs["example/dynamic.ResultOnly"].Frame.Results) == 0 {
+					t.Fatalf("result storage and placeholder declaration were conflated: %v", declared)
+				}
+				options := plan9asm.Options{
+					Goarch: goarch, TargetTriple: targetTriple("linux", goarch), ResolveSym: resolve, Sigs: sigs,
+				}
+				ir, err := plan9asm.Translate(file, options)
+				if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("locals=%d metadata zeros invented caller-frame storage: IR bytes=%d err=%v", locals, len(ir), err)
+				}
+				if err := rejectUnboundCallerFrame(file, options, declared); !errors.Is(err, plan9asm.ErrProbeNeedsContext) ||
+					!strings.Contains(err.Error(), "empty Go declaration does not bind a dynamic caller frame") {
+					t.Fatalf("complete-source preflight lost its real dynamic-entry failure: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestDynamicFPPreflightCannotReplaceOrdinaryOwner(t *testing.T) {
+	resolve := resolveSymFunc("example/dynamic")
+	for _, row := range []struct {
+		name, source     string
+		translationError bool
+	}{
+		// Go's NOP pseudo accepts this operand without reading frame storage.
+		{"unused FP operand", "TEXT ·Stub(SB),4,$0\nNOP argframe+0(FP)\nRET\n", false},
+		{"other failed function", "TEXT ·Other(SB),4,$0-0\nUNKNOWN_OPCODE AX\nRET\nTEXT ·Stub(SB),4,$0\nLEAQ argframe+0(FP),AX\nRET\n", true},
+		{"explicit ordinary frame", "TEXT ·Stub(SB),4,$0-0\nRET\n", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, row.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs := map[string]plan9asm.FuncSig{}
+			declared := map[string]int64{}
+			for _, fn := range file.Funcs {
+				name := resolve(fn.Sym)
+				sigs[name] = plan9asm.FuncSig{Name: name, Ret: plan9asm.Void}
+				declared[name] = 0
+			}
+			options := plan9asm.Options{Goarch: "amd64", TargetTriple: targetTriple("linux", "amd64"), ResolveSym: resolve, Sigs: sigs}
+			_, err = plan9asm.Translate(file, options)
+			if (err != nil) != row.translationError || errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("counterexample did not retain its ordinary outcome", err)
+			}
+			if err := rejectUnboundCallerFrame(file, options, declared); err != nil {
+				t.Fatal("preflight replaced the ordinary owner path", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/empty_assembly.go b/cmd/plan9asmll/empty_assembly.go
new file mode 100644
index 000000000..2020ee51b
--- /dev/null
+++ b/cmd/plan9asmll/empty_assembly.go
@@ -0,0 +1,184 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// A parser's no-TEXT result is not evidence of an empty Go object. In
+// particular, macros, conditional definitions and invalid source still need
+// the actual assembler and its exact package/CPU definitions.
+func proveEmptyAssembly(pkg *packages.Package, task asmTask, target string, defines []string, cfg compileConfig) (_ *gotoolprofile.EmptyAssemblyProof, proofErr error) {
+	return proveAssemblyListing(pkg, task, target, defines, cfg, func(listing []byte, _ string) error {
+		if len(listing) != 0 {
+			return fmt.Errorf("actual Go assembler did not emit an empty symbol/data listing\n%s", listing)
+		}
+		return nil
+	})
+}
+
+// Both empty and data-only proofs require an independently accepted original
+// Go object. Their listing predicates differ; neither replaces LLVM output.
+func proveAssemblyListing(pkg *packages.Package, task asmTask, target string, defines []string, cfg compileConfig, accept func([]byte, string) error) (_ *gotoolprofile.EmptyAssemblyProof, proofErr error) {
+	ctx := cfg.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	ctx, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, err
+	}
+	env := os.Environ()
+	parts := strings.Split(target, "/")
+	if len(parts) != 2 || pkg == nil || pkg.PkgPath == "" {
+		return nil, fmt.Errorf("empty object requires an actual package and target")
+	}
+	env = featureEnvironment(env, map[string]string{"GOOS": parts[0], "GOARCH": parts[1], "CGO_ENABLED": "0"})
+	root, name := "", filepath.Base(task.AsmFile)
+	proof := &gotoolprofile.EmptyAssemblyProof{Protocol: gotoolprofile.EmptyAssemblyProtocol, Target: target, PackagePath: pkg.PkgPath}
+	if cfg.Feature != nil {
+		env, root = cfg.Feature.Env, cfg.Feature.Root
+		proof.ProfileID, proof.GoVersion = cfg.Feature.ID, cfg.Feature.Observed.GoVersion
+		proof.AsmToolSHA256 = cfg.Feature.Observed.ToolBinarySHA256["asm"]
+		name, err = cfg.Feature.sourceName(task.AsmFile)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if mode := cfg.nativeListingMode; mode != nil {
+		if cfg.Feature != nil || mode.Input == nil || mode.Metadata == nil || mode.Source == nil ||
+			mode.Input.Plan.Target != target || mode.Input.Plan.PackagePath != pkg.PkgPath {
+			return nil, fmt.Errorf("native assembly listing has a mixed or missing actual mode scope")
+		}
+		if err := gotoolprofile.ValidateInstrumentationMetadata(mode.Input, mode.Input.Plan.PackageDirectory, mode.Input.Plan.CustomTags, mode.Metadata); err != nil {
+			return nil, err
+		}
+		if err := mode.verifySources(); err != nil {
+			return nil, err
+		}
+		defer func() { proofErr = errors.Join(proofErr, mode.verifySources()) }()
+		env, root = mode.Source.Env, mode.Source.Root
+		proof.ProfileID = mode.Input.ID
+		proof.GoVersion = mode.Input.Observation.Early.BaselineFeatures.GoVersion
+		proof.AsmToolSHA256 = mode.Input.Observation.Early.ModeTools.BinarySHA256["asm"]
+		name, err = mode.Source.sourceName(task.AsmFile)
+		if err != nil {
+			return nil, err
+		}
+		if _, err := gotoolprofile.CPPRegularSource(mode.Source.Dir, name); err != nil {
+			return nil, err
+		}
+	}
+	if root == "" {
+		output, stderr, err := gotoolprofile.RunBounded(ctx, "", env, binary, "env", "GOROOT", "GOVERSION")
+		if err != nil {
+			return nil, err
+		}
+		fields := strings.Split(strings.TrimSpace(string(output)), "\n")
+		if len(stderr) != 0 || len(fields) != 2 {
+			return nil, fmt.Errorf("original assembly listing lacks its actual SDK root/version")
+		}
+		root, proof.GoVersion = strings.TrimSuffix(fields[0], "\r"), fields[1]
+	}
+	if !filepath.IsAbs(root) {
+		return nil, fmt.Errorf("empty object assembler requires the actual absolute GOROOT")
+	}
+	proof.File, proof.SourceSHA256 = name, ""
+	proof.SourceSHA256, err = gotoolprofile.FileSHA256(task.AsmFile)
+	if err != nil {
+		return nil, err
+	}
+	if mode := cfg.nativeListingMode; mode != nil && proof.SourceSHA256 != mode.Input.Original.Sources[name] {
+		return nil, fmt.Errorf("native assembly listing lost the actual original mode source")
+	}
+	defer func() {
+		after, err := gotoolprofile.FileSHA256(task.AsmFile)
+		if err == nil && after != proof.SourceSHA256 {
+			err = fmt.Errorf("empty-object assembly source changed during its actual Go check")
+		}
+		proofErr = errors.Join(proofErr, err)
+	}()
+	owned, err := os.MkdirTemp("", "plan9asm-empty-object-")
+	if err != nil {
+		return nil, err
+	}
+	defer func() { proofErr = errors.Join(proofErr, os.RemoveAll(owned)) }()
+	object := filepath.Join(owned, "source.o")
+	dir := filepath.Dir(task.AsmFile)
+	args := []string{"tool", "asm", "-S", "-p", pkg.PkgPath, "-I", dir}
+	var definitions map[string]string
+	needsHeader := false
+	if cfg.Feature != nil && cfg.Feature.Proof != nil && cfg.Feature.Proof.GeneratedHeaders != nil {
+		needsHeader = true
+		for _, header := range cfg.Feature.Proof.GeneratedHeaders.Headers {
+			if header.PackagePath == pkg.PkgPath {
+				definitions = header.Definitions
+			}
+		}
+	}
+	if mode := cfg.nativeListingMode; mode != nil {
+		definitions = mode.Metadata.Headers[0].Header.Definitions
+		needsHeader = true
+	}
+	if needsHeader {
+		data, err := gotoolprofile.CanonicalGeneratedHeader(definitions)
+		if err != nil {
+			return nil, fmt.Errorf("native empty-object generated header lacks actual selected package origin: %w", err)
+		}
+		headerFile := filepath.Join(owned, "go_asm.h")
+		if err := os.WriteFile(headerFile, data, 0600); err != nil {
+			return nil, err
+		}
+		before := featureBytesSHA256(data)
+		defer func() {
+			after, err := gotoolprofile.FileSHA256(headerFile)
+			if err == nil && before != after {
+				err = fmt.Errorf("actual full generated header changed during native empty-object assembly")
+			}
+			proofErr = errors.Join(proofErr, err)
+		}()
+		// The Go-generated object directory follows the original package CWD
+		// and precedes tool headers. This is the complete independently
+		// compiled header, never cmd/go's earlier empty gensymabis stub.
+		args = append(args, "-I", owned)
+	}
+	args = append(args, "-I", filepath.Join(root, "pkg", "include"), "-o", object)
+	for _, define := range defines {
+		args = append(args, "-D", define)
+	}
+	args = append(args, filepath.Base(task.AsmFile))
+	listing, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, binary, args...)
+	if err != nil {
+		return nil, fmt.Errorf("actual Go empty-object assembly: %w", err)
+	}
+	if len(stderr) != 0 {
+		return nil, fmt.Errorf("actual Go assembler emitted unexpected diagnostics: %s", stderr)
+	}
+	if err := accept(listing, proof.GoVersion); err != nil {
+		return nil, err
+	}
+	if info, err := os.Stat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		return nil, fmt.Errorf("actual Go did not generate a nonempty object: %v", err)
+	}
+	proof.ObjectSHA256, err = gotoolprofile.FileSHA256(object)
+	if err != nil {
+		return nil, err
+	}
+	proof.ListingSHA256 = featureBytesSHA256(listing)
+	return proof, nil
+}
diff --git a/cmd/plan9asmll/explicit_mask_move_supported_ops_test.go b/cmd/plan9asmll/explicit_mask_move_supported_ops_test.go
new file mode 100644
index 000000000..e1be552d3
--- /dev/null
+++ b/cmd/plan9asmll/explicit_mask_move_supported_ops_test.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsIsolatedCompleteExplicitMaskMoveFamily(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_explicit_mask_move_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	if err := os.WriteFile(filepath.Join(directory, "amd64_explicit_mask_move_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(directory, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386", "arm", "arm64", "wasm"} {
+		supported, err := extractSupportedOps(directory, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ"} {
+			_, found := supported[opcode]
+			if found != (arch == "amd64" || arch == "386") {
+				t.Fatal("complete isolated vector-mask table lost its architecture boundary", arch, opcode, found)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/feature_data_object_test.go b/cmd/plan9asmll/feature_data_object_test.go
new file mode 100644
index 000000000..fd0709961
--- /dev/null
+++ b/cmd/plan9asmll/feature_data_object_test.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestDataOnlyAssemblyProducesObjectsAcrossSupportedTargets(t *testing.T) {
+	repoRoot, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var llvmNM string
+	for _, name := range []string{"llvm-nm-22", "llvm-nm"} {
+		tool, err := exec.LookPath(name)
+		if err == nil && requireLLVM22LLC(tool) == nil {
+			llvmNM = tool
+			break
+		}
+	}
+	if llvmNM == "" {
+		t.Fatal("LLVM 22 nm is required for the actual data object oracle")
+	}
+	for _, target := range []string{
+		"darwin/amd64", "linux/amd64", "windows/amd64",
+		"linux/386", "windows/386", "linux/arm",
+		"darwin/arm64", "linux/arm64", "windows/arm64",
+		"js/wasm", "wasip1/wasm",
+	} {
+		for _, profiled := range []bool{false, true} {
+			mode := "ordinary"
+			if profiled {
+				mode = "profiled"
+			}
+			t.Run(target+"/"+mode, func(t *testing.T) {
+				input, dir := featureConsumerFixture(t)
+				if err := os.Remove(filepath.Join(dir, "probe_amd64.s")); err != nil {
+					t.Fatal(err)
+				}
+				const source = "DATA ·payload+0(SB)/8, $0x123456789abcdef\nGLOBL ·payload(SB),$8\n"
+				if err := os.WriteFile(filepath.Join(dir, "data.s"), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				delete(input.Sources, "probe_amd64.s")
+				delete(input.Headers, "probe_amd64.s")
+				input.Sources["data.s"] = featureBytesSHA256([]byte(source))
+				input.Headers["data.s"] = source
+				const bss = "GLOBL ·zero(SB),$8\n"
+				if err := os.WriteFile(filepath.Join(dir, "bss.s"), []byte(bss), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources["bss.s"] = featureBytesSHA256([]byte(bss))
+				input.Headers["bss.s"] = bss
+				input.Directories["."] = []string{"bss.s", "data.s", "fallback.go", "go.mod", "selected.go"}
+				input.AsmFiles = []string{"bss.s", "data.s"}
+				binary, err := exec.LookPath("go")
+				if err != nil {
+					t.Fatal(err)
+				}
+				binary, err = filepath.Abs(binary)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+				defer cancel()
+				input.Observed, err = gotoolprofile.Capture(ctx, binary, t.TempDir(), os.Environ(), target, nil, gotoolprofile.RunBounded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				input.ID = gotoolprofile.ProfileID(input.Observed)
+				env := featureEnvironment(os.Environ(), input.Observed.Environment)
+				_, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, binary, "list", "-export", ".")
+				if err != nil {
+					t.Fatalf("actual Go data-only package: %v\n%s", err, stderr)
+				}
+				// Use the assembler's own symbol/data listing. Go 1.27.1 nm
+				// crashes when enumerating a GLOBL-only archive member; that
+				// separate tool failure is not an assembly rejection or skip.
+				for file, symbol := range map[string]string{"data.s": "payload", "bss.s": "zero"} {
+					goObject := filepath.Join(t.TempDir(), file+".o")
+					listing, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, binary, "tool", "asm", "-S", "-p", input.Module, "-o", goObject, file)
+					if err != nil || !strings.Contains(string(listing)+string(stderr), input.Module+"."+symbol) {
+						t.Fatalf("actual Go assembler lost %s symbol: %v\n%s\n%s", symbol, err, listing, stderr)
+					}
+					if info, err := os.Stat(goObject); err != nil || info.Size() == 0 {
+						t.Fatalf("actual Go assembler must produce a nonempty object: %v", err)
+					}
+				}
+				config, err := resolveCompileConfig(true, "", true, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.Context = ctx
+				if profiled {
+					config.FeaturePath = writeFeatureInput(t, input)
+				}
+				spec, err := parseTargetSpec(target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				output := t.TempDir()
+				t.Chdir(dir)
+				report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, output, false, 0, true, false, true, repoRoot, config)
+				if err != nil || report.Success != 2 || report.Failed != 0 || report.NotApplicable != 0 {
+					t.Fatalf("data-only source did not compile: report=%+v err=%v", report, err)
+				}
+				for file, symbol := range map[string]string{"data.s": "payload", "bss.s": "zero"} {
+					object := filepath.Join(output, filepath.FromSlash(input.Module), file+".o")
+					symbols, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, llvmNM, "--defined-only", object)
+					if err != nil || !strings.Contains(string(symbols), input.Module+"."+symbol) {
+						t.Fatalf("LLVM 22 object lost %s symbol: %v\n%s\n%s", symbol, err, symbols, stderr)
+					}
+				}
+				if profiled {
+					if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+						t.Fatalf("data-only scope lacks actual CPP/LLVM consumer proof: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmll/feature_data_only_test.go b/cmd/plan9asmll/feature_data_only_test.go
new file mode 100644
index 000000000..5c8b75b20
--- /dev/null
+++ b/cmd/plan9asmll/feature_data_only_test.go
@@ -0,0 +1,197 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestDataOnlyAssemblyCurrentSignatureProtocolAcrossTargets(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := featureConsumerFixture(t)
+			if err := os.Remove(filepath.Join(dir, "probe_amd64.s")); err != nil {
+				t.Fatal(err)
+			}
+			const source = "DATA ·payload+0(SB)/8,$0x123456789abcdef0\nGLOBL ·payload(SB),$8\nGLOBL ·zero(SB),$16\n"
+			if err := os.WriteFile(filepath.Join(dir, "tables.s"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			delete(input.Sources, "probe_amd64.s")
+			delete(input.Headers, "probe_amd64.s")
+			input.Sources["tables.s"], input.Headers["tables.s"] = featureBytesSHA256([]byte(source)), source
+			input.AsmFiles = []string{"tables.s"}
+			input.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+			input.TestDependencySourceProtocol = gotoolprofile.TestDependencyProtocol
+			input.Directories["."] = []string{"fallback.go", "go.mod", "selected.go", "tables.s"}
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			input.Observed, err = gotoolprofile.Capture(ctx, binary, t.TempDir(), os.Environ(), target, nil, gotoolprofile.RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.ID = gotoolprofile.ProfileID(input.Observed)
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.Context, config.FeaturePath = ctx, writeFeatureInput(t, input)
+			spec, err := parseTargetSpec(target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			output := t.TempDir()
+			t.Chdir(dir)
+			query := &gotoolprofile.SignatureQueryProof{Protocol: gotoolprofile.SignatureQueryProtocol}
+			queryConfig := config
+			queryConfig.Enabled, queryConfig.SignatureQuery = false, query
+			queryReport, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module,
+				t.TempDir(), false, 0, false, false, true, repo, queryConfig)
+			if err != nil || queryReport.Failed != 0 || queryReport.Success != 0 || query.Selection == nil ||
+				len(query.Selection.Outputs) != 0 || len(query.Selection.TestDeclarations) != 0 || len(query.Requests) != 0 {
+				t.Fatalf("data-only query acquired a final signature or LLVM outcome: report=%+v err=%v", queryReport, err)
+			}
+			if len(query.Selection.CPP) != 1 || query.Selection.CPP[0].Emission != "data_only" ||
+				query.Selection.CPP[0].DataOnlyAssembly == nil {
+				t.Fatal("query omitted the actual data-only source/native role")
+			}
+			if err := gotoolprofile.ValidateSignatureQuery(input, query, nil); err != nil {
+				t.Fatalf("actual data-only metadata query was rejected: %v", err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, query.Selection, nil, true); err == nil {
+				t.Fatal("data-only native query was accepted as an LLVM object outcome")
+			}
+			report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, output, false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("legitimate globals-only assembly must compile: report=%+v err=%v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatalf("globals-only object was rejected by the current signature protocol: %v", err)
+			}
+			if !reflect.DeepEqual(query.Selection.CPP[0].DataOnlyAssembly, report.FeatureSelection.CPP[0].DataOnlyAssembly) {
+				t.Fatal("query and final data-only native identities differ")
+			}
+			checkDataOnlyAssemblyProofMutants(t, input, report.FeatureSelection)
+			object := filepath.Join(output, filepath.FromSlash(input.Module), "tables.s.o")
+			if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+				t.Fatalf("globals-only success lacks a real LLVM object: %v", err)
+			}
+		})
+	}
+}
+
+func TestDataOnlyNativeOracleBindsActualGoGlobalsAndRejectsTEXT(t *testing.T) {
+	dir := t.TempDir()
+	pkg := &packages.Package{PkgPath: "example.invalid/data"}
+	task := asmTask{AsmFile: filepath.Join(dir, "data.s")}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	cfg := compileConfig{Context: ctx}
+	for _, test := range []struct {
+		name, source string
+		mutate       func(*plan9asm.File)
+		wantErr      bool
+	}{
+		{name: "BSS", source: "GLOBL ·zero(SB),$16\n"},
+		{name: "static relocation", source: "DATA local<>+0(SB)/8,$·zero(SB)\nGLOBL local<>(SB),8,$8\nGLOBL ·zero(SB),$16\n"},
+		{name: "TEXT", source: "GLOBL ·zero(SB),$16\nTEXT ·fn(SB),4,$0-0\nRET\n", wantErr: true},
+		{name: "hidden TEXT", source: "GLOBL ·zero(SB),$16\nTEXT ·fn(SB),4,$0-0\nRET\n", mutate: func(f *plan9asm.File) { f.Funcs = nil }, wantErr: true},
+		{name: "changed name", source: "GLOBL ·zero(SB),$16\n", mutate: func(f *plan9asm.File) { f.Globl[0].Sym = "·other" }, wantErr: true},
+		{name: "changed size", source: "GLOBL ·zero(SB),$16\n", mutate: func(f *plan9asm.File) { f.Globl[0].Size++ }, wantErr: true},
+		{name: "missing global", source: "GLOBL ·zero(SB),$16\n", mutate: func(f *plan9asm.File) { f.Globl = nil }, wantErr: true},
+		{name: "duplicate global", source: "GLOBL ·zero(SB),$16\n", mutate: func(f *plan9asm.File) { f.Globl = append(f.Globl, f.Globl[0]) }, wantErr: true},
+		{name: "missing DATA global", source: "DATA orphan<>+0(SB)/8,$1\n", wantErr: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if err := os.WriteFile(task.AsmFile, []byte(test.source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if test.mutate != nil {
+				test.mutate(file)
+			}
+			proof, err := proveDataOnlyAssembly(pkg, task, file, "linux/amd64", nil, cfg)
+			if (err != nil) != test.wantErr || !test.wantErr && (proof == nil || len(proof.Symbols) == 0) {
+				t.Fatalf("native data-only claim differs from Go and translated globals: proof=%+v err=%v", proof, err)
+			}
+		})
+	}
+}
+
+func checkDataOnlyAssemblyProofMutants(t *testing.T, input *featureInput, original *featureSelectionProof) {
+	t.Helper()
+	if len(original.CPP) != 1 || original.CPP[0].Emission != "data_only" || original.CPP[0].DataOnlyAssembly == nil {
+		t.Fatal("missing independently assembled data-only scope witness")
+	}
+	if len(original.CPP[0].DataOnlyAssembly.Symbols) != 2 {
+		t.Fatal("native inventory omitted DATA/BSS symbols")
+	}
+	for name, mutate := range map[string]func(*featureSelectionProof){
+		"missing witness":  func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly = nil },
+		"missing emission": func(p *featureSelectionProof) { p.CPP[0].Emission = "" },
+		"normal emission":  func(p *featureSelectionProof) { p.CPP[0].Emission = "assembly" },
+		"false empty":      func(p *featureSelectionProof) { p.CPP[0].Emission = "symbol_free" },
+		"protocol": func(p *featureSelectionProof) {
+			p.CPP[0].DataOnlyAssembly.Native.Protocol = gotoolprofile.EmptyAssemblyProtocol
+		},
+		"source": func(p *featureSelectionProof) {
+			p.CPP[0].DataOnlyAssembly.Native.SourceSHA256 = featureBytesSHA256(nil)
+		},
+		"package":    func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Native.PackagePath += "/other" },
+		"profile":    func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Native.ProfileID = "wrong" },
+		"target":     func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Native.Target = "linux/other" },
+		"Go version": func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Native.GoVersion = "go1.20.14" },
+		"assembler": func(p *featureSelectionProof) {
+			p.CPP[0].DataOnlyAssembly.Native.AsmToolSHA256 = featureBytesSHA256(nil)
+		},
+		"missing native object": func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Native.ObjectSHA256 = "" },
+		"empty listing": func(p *featureSelectionProof) {
+			p.CPP[0].DataOnlyAssembly.Native.ListingSHA256 = featureBytesSHA256(nil)
+		},
+		"missing symbols": func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Symbols = nil },
+		"TEXT symbol":     func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Symbols[0].Kind = "STEXT" },
+		"negative size":   func(p *featureSelectionProof) { p.CPP[0].DataOnlyAssembly.Symbols[0].Size = -1 },
+		"duplicate symbols": func(p *featureSelectionProof) {
+			p.CPP[0].DataOnlyAssembly.Symbols[1] = p.CPP[0].DataOnlyAssembly.Symbols[0]
+		},
+		"missing LLVM object": func(p *featureSelectionProof) { p.Outputs = nil },
+		"mixed signatures": func(p *featureSelectionProof) {
+			p.CPP[0].Signatures = []gotoolprofile.SignatureSource{{Symbol: "unproved", Role: "asm_fallback", LayoutSHA256: featureBytesSHA256(nil)}}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			proof := *original
+			proof.CPP = append([]featureCPPProof(nil), original.CPP...)
+			dataOnly := *original.CPP[0].DataOnlyAssembly
+			dataOnly.Symbols = append([]gotoolprofile.DataOnlySymbol(nil), dataOnly.Symbols...)
+			proof.CPP[0].DataOnlyAssembly = &dataOnly
+			mutate(&proof)
+			if err := gotoolprofile.ValidateSelection(input, &proof, nil, true); err == nil {
+				t.Fatal("changed data-only scope or missing mandatory object was accepted")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/feature_empty_object_test.go b/cmd/plan9asmll/feature_empty_object_test.go
new file mode 100644
index 000000000..53f33ebc4
--- /dev/null
+++ b/cmd/plan9asmll/feature_empty_object_test.go
@@ -0,0 +1,156 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestMacroOnlyAssemblyProducesRealObjectsAcrossSupportedTargets(t *testing.T) {
+	repoRoot, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		for _, profiled := range []bool{false, true} {
+			mode := "ordinary"
+			if profiled {
+				mode = "profiled"
+			}
+			t.Run(target+"/"+mode, func(t *testing.T) {
+				input, dir := featureConsumerFixture(t)
+				if err := os.Remove(filepath.Join(dir, "probe_amd64.s")); err != nil {
+					t.Fatal(err)
+				}
+				const source = "// Shared macro definitions, with no object symbols.\n#define SHARED(X) MOVQ X, AX\n"
+				if err := os.WriteFile(filepath.Join(dir, "macros.s"), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				delete(input.Sources, "probe_amd64.s")
+				delete(input.Headers, "probe_amd64.s")
+				input.Sources["macros.s"] = featureBytesSHA256([]byte(source))
+				input.Headers["macros.s"] = source
+				input.AsmFiles = []string{"macros.s"}
+				input.Directories["."] = []string{"fallback.go", "go.mod", "macros.s", "selected.go"}
+				ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+				defer cancel()
+				input.Observed, err = gotoolprofile.Capture(ctx, binary, t.TempDir(), os.Environ(), target, nil, gotoolprofile.RunBounded)
+				if err != nil {
+					t.Fatal(err)
+				}
+				input.ID = gotoolprofile.ProfileID(input.Observed)
+				config, err := resolveCompileConfig(true, "", true, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.Context = ctx
+				if profiled {
+					config.FeaturePath = writeFeatureInput(t, input)
+				}
+				spec, err := parseTargetSpec(target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				output := t.TempDir()
+				t.Chdir(dir)
+				report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, output, false, 0, true, false, true, repoRoot, config)
+				if err != nil || report.Success != 1 || report.Failed != 0 {
+					t.Fatalf("macro-only scope must compile, not disappear: report=%+v err=%v", report, err)
+				}
+				object := filepath.Join(output, filepath.FromSlash(input.Module), "macros.s.o")
+				if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+					t.Fatalf("reported success without a real LLVM object: %v", err)
+				}
+				if profiled {
+					if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+						t.Fatalf("empty scope lacks actual CPP/LLVM consumption: %v", err)
+					}
+					checkEmptyAssemblyProofMutants(t, input, report.FeatureSelection)
+				}
+			})
+		}
+	}
+}
+
+func checkEmptyAssemblyProofMutants(t *testing.T, input *featureInput, original *featureSelectionProof) {
+	t.Helper()
+	if len(original.CPP) != 1 || original.CPP[0].Emission != "symbol_free" || original.CPP[0].EmptyAssembly == nil {
+		t.Fatal("no explicit same-scope native emptiness witness")
+	}
+	for name, mutate := range map[string]func(*featureSelectionProof){
+		"missing witness":  func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly = nil },
+		"missing emission": func(p *featureSelectionProof) { p.CPP[0].Emission = "" },
+		"normal emission":  func(p *featureSelectionProof) { p.CPP[0].Emission = "assembly" },
+		"source":           func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.SourceSHA256 = featureBytesSHA256(nil) },
+		"package":          func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.PackagePath += "/other" },
+		"profile":          func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.ProfileID = "wrong" },
+		"target":           func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.Target = "linux/other" },
+		"Go version":       func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.GoVersion = "go1.20.14" },
+		"assembler":        func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.AsmToolSHA256 = featureBytesSHA256(nil) },
+		"missing object":   func(p *featureSelectionProof) { p.CPP[0].EmptyAssembly.ObjectSHA256 = "" },
+		"nonempty listing": func(p *featureSelectionProof) {
+			p.CPP[0].EmptyAssembly.ListingSHA256 = featureBytesSHA256([]byte("symbol"))
+		},
+		"missing LLVM output": func(p *featureSelectionProof) { p.Outputs = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			proof := *original
+			proof.CPP = append([]featureCPPProof(nil), original.CPP...)
+			empty := *original.CPP[0].EmptyAssembly
+			proof.CPP[0].EmptyAssembly = &empty
+			mutate(&proof)
+			if err := gotoolprofile.ValidateSelection(input, &proof, nil, true); err == nil {
+				t.Fatal("changed native empty-object scope or missing LLVM output was accepted")
+			}
+		})
+	}
+}
+
+func TestEmptyAssemblyNativeOracleRejectsSymbolsAndInvalidSource(t *testing.T) {
+	dir := t.TempDir()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	cfg := compileConfig{Context: ctx}
+	pkg := &packages.Package{PkgPath: "example.invalid/empty"}
+	task := asmTask{AsmFile: filepath.Join(dir, "probe.s")}
+	for _, test := range []struct {
+		name    string
+		source  string
+		defines []string
+		wantErr bool
+	}{
+		{name: "macro-only", source: "#define SHARED(X) MOVQ X, AX\n"},
+		{name: "TEXT", source: "TEXT ·Probe(SB),$0-0\nRET\n", wantErr: true},
+		{name: "GLOBL", source: "GLOBL ·zero(SB),$8\n", wantErr: true},
+		{name: "DATA", source: "DATA ·payload+0(SB)/8,$1\nGLOBL ·payload(SB),$8\n", wantErr: true},
+		{name: "invalid source", source: "NOT_A_GO_INSTRUCTION\n", wantErr: true},
+		{name: "missing include", source: "#include \"missing.h\"\n", wantErr: true},
+		{name: "missing final newline", source: "#define INCOMPLETE 1", wantErr: true},
+		{name: "inactive CPU variant", source: "#ifdef GOAMD64_v3\nTEXT ·Probe(SB),$0-0\nRET\n#endif\n"},
+		{name: "active CPU variant", source: "#ifdef GOAMD64_v3\nTEXT ·Probe(SB),$0-0\nRET\n#endif\n", defines: []string{"GOAMD64_v3"}, wantErr: true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if err := os.WriteFile(task.AsmFile, []byte(test.source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			proof, err := proveEmptyAssembly(pkg, task, "linux/amd64", test.defines, cfg)
+			if (err != nil) != test.wantErr || !test.wantErr && proof == nil {
+				t.Fatalf("actual Go emptiness was invented: proof=%+v err=%v", proof, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/feature_environment_test.go b/cmd/plan9asmll/feature_environment_test.go
new file mode 100644
index 000000000..6a8e24c48
--- /dev/null
+++ b/cmd/plan9asmll/feature_environment_test.go
@@ -0,0 +1,95 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestFeatureConsumerFixturePreparesSelectedCache(t *testing.T) {
+	cache := filepath.Join(t.TempDir(), "new-cache")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOCACHE", cache)
+	if _, err := os.Stat(cache); !os.IsNotExist(err) {
+		t.Fatalf("cache fixture already exists: %v", err)
+	}
+	before := os.Environ()
+	input, _ := featureConsumerFixture(t)
+	if input.Observed == nil {
+		t.Fatal("fixture omitted its actual Go observation")
+	}
+	if info, err := os.Stat(cache); err != nil || !info.IsDir() {
+		t.Fatalf("actual selected cache was not prepared: %v", err)
+	}
+	if !reflect.DeepEqual(before, os.Environ()) {
+		t.Fatal("fixture changed the producer's original environment")
+	}
+}
+
+func TestFeatureConsumerResolvesOrdinaryEnvironmentBeforeSelection(t *testing.T) {
+	t.Setenv("GOENV", "off")
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		t.Setenv(key, "")
+	}
+	input, directory := featureConsumerFixture(t)
+	t.Chdir(directory)
+	before := os.Environ()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values := make(map[string]string)
+	for _, entry := range consumer.Env {
+		key, value, _ := strings.Cut(entry, "=")
+		if _, duplicate := values[key]; duplicate {
+			t.Fatalf("duplicate effective environment key %s", key)
+		}
+		values[key] = value
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(values[key]) {
+			t.Errorf("feature selection lacks its actual %s directory: %q", key, values[key])
+			continue
+		}
+		if info, err := os.Stat(values[key]); err != nil || !info.IsDir() {
+			t.Errorf("feature selection %s directory does not exist: %v", key, err)
+		}
+	}
+	for key, want := range map[string]string{
+		"GOENV": "off", "GOWORK": "off", "GOFLAGS": "",
+		"GOAMD64": "v3", "CGO_ENABLED": "0", "GOTOOLCHAIN": "local",
+		"GOOS": "linux", "GOARCH": "amd64",
+	} {
+		if values[key] != want {
+			t.Errorf("feature selection changed %s: got %q, want %q", key, values[key], want)
+		}
+	}
+	if !reflect.DeepEqual(before, os.Environ()) {
+		t.Fatal("feature selection mutated the process environment")
+	}
+	if t.Failed() {
+		return
+	}
+	packages, environment, err := loadPkgsInEnvironment("linux", "amd64", []string{"."}, nil, input.Module, true, false, consumer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(environment, consumer.Env) {
+		t.Fatal("package selection changed the reobserved feature environment")
+	}
+	if err := consumer.capturePackages(packages); err != nil {
+		t.Fatal(err)
+	}
+	if consumer.ID != input.ID || len(consumer.Proof.Packages) != 1 {
+		t.Fatal("resolving execution paths changed the actual feature/source profile")
+	}
+	if files := consumer.Proof.Packages[0].CompiledGoFiles; len(files) != 1 || files[0] != "selected.go" {
+		t.Fatalf("actual v3 source selection changed: %v", files)
+	}
+}
diff --git a/cmd/plan9asmll/feature_profile.go b/cmd/plan9asmll/feature_profile.go
new file mode 100644
index 000000000..000ef0542
--- /dev/null
+++ b/cmd/plan9asmll/feature_profile.go
@@ -0,0 +1,521 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+const featureInputProtocol = gotoolprofile.ConsumerProtocol
+
+type featureInput = gotoolprofile.ConsumerInput
+
+// A consumer is populated only after reobserving the actual driver and its
+// finite marker package. Supplying JSON alone does not create this proof.
+type featureConsumer struct {
+	OrdinaryDependencies      *ordinaryDependencyOwner
+	ID                        string
+	Observed                  *gotoolprofile.Observation
+	Root                      string
+	Env                       []string
+	Context                   context.Context
+	Input                     *featureInput
+	Dir                       string
+	WorkDir                   string
+	Proof                     *featureSelectionProof
+	GeneratedGuard            map[string]string
+	TestDeclarationPackages   map[string]*packages.Package
+	TestDeclarationCandidates map[string]map[string]error
+	TestModuleGuards          map[string]testDependencyModuleGuard
+	TestEmbedGuards           map[string]testDependencyEmbedGuard
+}
+
+type featureSelectionProof = gotoolprofile.SelectionProof
+type featurePackageProof = gotoolprofile.PackageProof
+type featureCPPProof = gotoolprofile.CPPProof
+type featureOutputProof = gotoolprofile.OutputProof
+
+func loadFeatureConsumer(ctx context.Context, filename, output, target, module string, tags []string) (*featureConsumer, error) {
+	if ctx == nil {
+		return nil, fmt.Errorf("explicit feature consumer requires a live deadline context")
+	}
+	reader, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	input, err := gotoolprofile.DecodeConsumerInput(reader)
+	if err != nil {
+		return nil, err
+	}
+	if input.Protocol != featureInputProtocol || module == "" || input.Module != module || input.Observed == nil || input.Observed.Target != target || gotoolprofile.ProfileID(input.Observed) != input.ID {
+		return nil, fmt.Errorf("explicit feature input identity differs from target/module")
+	}
+	if err := gotoolprofile.Validate(input.Observed); err != nil {
+		return nil, err
+	}
+	for _, tag := range tags {
+		if gotoolprofile.ReservedTag(tag) {
+			return nil, fmt.Errorf("custom build tag cannot enable the Go feature namespace: %s", tag)
+		}
+	}
+	if !sort.StringsAreSorted(tags) {
+		return nil, fmt.Errorf("custom profile tags must have canonical ordering")
+	}
+	for index := 1; index < len(tags); index++ {
+		if tags[index] == tags[index-1] {
+			return nil, fmt.Errorf("duplicate custom profile tag")
+		}
+	}
+	dir, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+	workDir, err := sourcepath.Resolve(dir)
+	if err != nil {
+		return nil, err
+	}
+	if !filepath.IsAbs(input.SourceRoot) {
+		return nil, fmt.Errorf("feature consumer requires an explicit absolute source root")
+	}
+	dir, err = sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return nil, err
+	}
+	consumer := &featureConsumer{
+		ID: input.ID, Observed: input.Observed, Context: ctx,
+		Input: input, Dir: dir, WorkDir: workDir,
+		Proof: &featureSelectionProof{
+			Protocol: featureInputProtocol, ProfileID: input.ID,
+			SignatureSourceProtocol:      input.SignatureSourceProtocol,
+			TestDependencySourceProtocol: input.TestDependencySourceProtocol,
+			CPPSourceProtocol:            input.CPPSourceProtocol,
+			CustomTags:                   append([]string(nil), tags...),
+			RegisteredAsmFiles:           append([]string(nil), input.RegisteredAsmFiles...),
+			CPPIncludeSearchMisses:       append([]gotoolprofile.CPPPackageSearchMiss(nil), input.CPPIncludeSearchMisses...),
+		},
+	}
+	if err := consumer.verifySources(); err != nil {
+		return nil, err
+	}
+	env := featureEnvironment(os.Environ(), input.Observed.Environment)
+	// Resolve actual cache/config/temp paths before both reobservation and
+	// package selection. Source observers retain this same environment and
+	// own their separate temporary children until their existing Close calls.
+	goos, goarch, _ := strings.Cut(target, "/")
+	env, err = featurePackageEnvironment(goos, goarch, env)
+	if err != nil {
+		return nil, err
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, err
+	}
+	consumer.Env = env
+	if err := os.MkdirAll(output, 0755); err != nil {
+		return nil, err
+	}
+	if err := consumer.reobserve(binary, output); err != nil {
+		return nil, err
+	}
+	data, _, err := gotoolprofile.RunBounded(ctx, dir, env, binary, "env", "GOROOT")
+	if err != nil {
+		return nil, err
+	}
+	consumer.Root = strings.TrimSpace(string(data))
+	if !filepath.IsAbs(consumer.Root) {
+		return nil, fmt.Errorf("actual feature driver returned an invalid source root")
+	}
+	if err := consumer.verifySources(); err != nil {
+		return nil, err
+	}
+	return consumer, nil
+}
+
+func featureEnvironment(base []string, actual map[string]string) []string {
+	replacements := map[string]string{
+		"GOTOOLCHAIN": "local", "GOWORK": "off", "GOFLAGS": "", "GOPACKAGESDRIVER": "off",
+	}
+	for key, value := range actual {
+		if key != "GOVERSION" {
+			replacements[key] = value
+		}
+	}
+	var result []string
+	for _, item := range base {
+		key, _, _ := strings.Cut(item, "=")
+		if _, replace := replacements[key]; !replace {
+			result = append(result, item)
+		}
+	}
+	for key, value := range replacements {
+		result = append(result, key+"="+value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func (consumer *featureConsumer) reobserve(binary, output string) error {
+	marker, err := os.MkdirTemp(output, ".feature-markers-")
+	if err != nil {
+		return err
+	}
+	// Retain the finite marker artifact with the output proof. It is not a
+	// dependency cache and no caller-owned directory is removed here.
+	observed, err := gotoolprofile.Capture(consumer.Context, binary, marker, consumer.Env, consumer.Observed.Target, nil, gotoolprofile.RunBounded)
+	if err != nil {
+		return fmt.Errorf("reobserve actual feature driver: %w", err)
+	}
+	if gotoolprofile.ProfileID(observed) != consumer.ID {
+		return fmt.Errorf("actual marker/environment/source/tool identity differs from the requested feature profile")
+	}
+	return consumer.verifySources()
+}
+
+func (consumer *featureConsumer) verifySources() error {
+	if consumer.Context != nil && consumer.Context.Err() != nil {
+		return consumer.Context.Err()
+	}
+	if consumer.Input == nil || len(consumer.Input.Directories) == 0 {
+		return fmt.Errorf("feature consumer requires exact pre-load module source hashes")
+	}
+	if proof := consumer.Input.ProxyGoMod; proof != nil {
+		if err := gotoolprofile.ValidateProxyGoMod(proof); err != nil {
+			return err
+		}
+		if consumer.Input.Sources["go.mod"] != "" || consumer.Input.Module != proof.Module ||
+			consumer.Input.SourceModule != proof.Module || consumer.Input.Version != proof.Version ||
+			!filepath.IsAbs(consumer.Input.ProxyGoModPath) {
+			return fmt.Errorf("proxy metadata differs from its exact non-ZIP module role")
+		}
+		if _, err := os.Stat(filepath.Join(consumer.Dir, "go.mod")); !os.IsNotExist(err) {
+			return fmt.Errorf("proxy metadata cannot impersonate original ZIP go.mod")
+		}
+		resolved, err := sourcepath.Resolve(consumer.Input.ProxyGoModPath)
+		if err != nil || resolved != consumer.Input.ProxyGoModPath {
+			return fmt.Errorf("authenticated proxy metadata is missing or redirected")
+		}
+		actual, err := gotoolprofile.FileSHA256(resolved)
+		if err != nil || actual != proof.SHA256 {
+			return fmt.Errorf("authenticated proxy metadata changed before or after package loading")
+		}
+	} else if consumer.Input.Sources["go.mod"] == "" || consumer.Input.ProxyGoModPath != "" {
+		return fmt.Errorf("feature consumer requires exact ZIP go.mod or independently authenticated proxy metadata")
+	}
+	for dir, expected := range consumer.Input.Directories {
+		if filepath.IsAbs(dir) || filepath.ToSlash(filepath.Clean(dir)) != dir || strings.HasPrefix(dir, "../") || strings.Contains(dir, "\\") {
+			return fmt.Errorf("unsafe feature source directory %q", dir)
+		}
+		entries, err := os.ReadDir(filepath.Join(consumer.Dir, filepath.FromSlash(dir)))
+		if err != nil {
+			return err
+		}
+		var actual []string
+		for _, entry := range entries {
+			actual = append(actual, entry.Name())
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			return fmt.Errorf("feature source directory membership changed: %s", dir)
+		}
+	}
+	for file, expected := range consumer.Input.Sources {
+		if consumer.Context != nil && consumer.Context.Err() != nil {
+			return consumer.Context.Err()
+		}
+		if filepath.IsAbs(file) || filepath.ToSlash(filepath.Clean(file)) != file || file == "." || strings.HasPrefix(file, "../") || strings.Contains(file, "\\") {
+			return fmt.Errorf("unsafe feature source identity %q", file)
+		}
+		filename := filepath.Join(consumer.Dir, filepath.FromSlash(file))
+		resolved, err := sourcepath.Resolve(filename)
+		if err != nil || resolved != filename {
+			return fmt.Errorf("feature source cannot be a redirected path: %s", file)
+		}
+		actual, err := gotoolprofile.FileSHA256(filename)
+		if err != nil || actual != expected {
+			return fmt.Errorf("feature source differs from its pre-load proof: %s", file)
+		}
+	}
+	if consumer.Root != "" {
+		if err := gotoolprofile.ValidateCPPIncludeSearch(consumer.Input, nil); err != nil {
+			return err
+		}
+		for _, miss := range consumer.Input.CPPIncludeSearchMisses {
+			if err := gotoolprofile.VerifyCPPPackageSearchMiss(miss, consumer.Dir, consumer.Root); err != nil {
+				return err
+			}
+		}
+		for file, expected := range consumer.Input.ToolSources {
+			name, err := gotoolprofile.CPPRegularSource(consumer.Root, file)
+			if err != nil {
+				return err
+			}
+			actual, err := gotoolprofile.FileSHA256(name)
+			if err != nil || actual != expected {
+				return fmt.Errorf("feature tool header differs from its pre-load proof: %s", file)
+			}
+		}
+	}
+	for file, expected := range consumer.GeneratedGuard {
+		if consumer.Context != nil && consumer.Context.Err() != nil {
+			return consumer.Context.Err()
+		}
+		actual, err := gotoolprofile.FileSHA256(file)
+		if err != nil || actual != expected {
+			return fmt.Errorf("generated-header dependency/export changed before final object proof")
+		}
+	}
+	if err := consumer.verifyOrdinaryOwner(consumer.OrdinaryDependencies); err != nil {
+		return err
+	}
+	return consumer.verifyTestModuleSources()
+}
+
+func (consumer *featureConsumer) capturePackages(pkgs []*packages.Package) error {
+	if err := consumer.verifySources(); err != nil {
+		return err
+	}
+	if len(pkgs) == 0 {
+		return fmt.Errorf("feature consumer has no actual package observation")
+	}
+	for _, pkg := range pkgs {
+		proof, err := consumer.captureSourcePackage(pkg, func(packagePath string) (*gotoolprofile.AssemblerMacros, error) {
+			return gotoolprofile.CaptureAssemblerMacros(consumer.Root, consumer.Observed, packagePath)
+		})
+		if err != nil {
+			return err
+		}
+		consumer.Proof.Packages = append(consumer.Proof.Packages, proof)
+	}
+	if consumer.Input.RegisteredAsmFiles != nil {
+		if err := gotoolprofile.ValidatePackageSelection(consumer.Input, consumer.Proof.Packages, consumer.Proof.CustomTags); err != nil {
+			return fmt.Errorf("actual complete package assembly registration: %w", err)
+		}
+	}
+	return consumer.verifySources()
+}
+
+// Source capture shares exact native Module/Dir/Replace and original byte
+// boundaries, never profile identity. Callers provide their separately
+// validated assembler registration; no result becomes an ordinary proof here.
+func (consumer *featureConsumer) captureSourcePackage(pkg *packages.Package, captureMacros func(string) (*gotoolprofile.AssemblerMacros, error)) (featurePackageProof, error) {
+	var proof featurePackageProof
+	if pkg == nil || pkg.Module == nil || pkg.Module.Path != consumer.Input.Module || pkg.Module.Version != consumer.Input.Version || isTestVariantPackage(pkg) || captureMacros == nil {
+		return proof, fmt.Errorf("actual package role/module differs from the explicit source scope")
+	}
+	moduleDir, err := sourcepath.Resolve(pkg.Module.Dir)
+	if err != nil || moduleDir != consumer.Dir {
+		return proof, fmt.Errorf("actual package module directory differs from the explicit source proof")
+	}
+	if pkg.Module.Replace != nil {
+		replacement, err := sourcepath.Resolve(pkg.Module.Replace.Dir)
+		if err != nil || replacement != consumer.Dir {
+			return proof, fmt.Errorf("actual Go module replacement differs from the exact owned source root")
+		}
+	}
+	macros, err := captureMacros(pkg.PkgPath)
+	if err != nil {
+		return proof, err
+	}
+	if macros == nil || macros.PackageRole == "allow_asm_abi_path" {
+		return proof, fmt.Errorf("source consumer cannot consume an unproved special assembler package role")
+	}
+	proof = featurePackageProof{
+		PackagePath: pkg.PkgPath, ModulePath: pkg.Module.Path, ModuleVersion: pkg.Module.Version,
+		SourceModule: pkg.Module.Path, SourceVersion: pkg.Module.Version, SourceRole: "module",
+		Macros: macros, SourceSHA256: make(map[string]string),
+	}
+	if metadata := consumer.Input.ProxyGoMod; metadata != nil {
+		used := pkg.Module.GoMod
+		if pkg.Module.Replace != nil {
+			used = pkg.Module.Replace.GoMod
+		}
+		resolved, err := sourcepath.Resolve(used)
+		if err != nil || resolved != consumer.Input.ProxyGoModPath {
+			return proof, fmt.Errorf("actual package used different proxy go.mod metadata")
+		}
+		proof.GoModOrigin, proof.GoModSHA256, proof.GoModSum = metadata.Protocol, metadata.SHA256, metadata.GoModSum
+	}
+	if pkg.Module.Main {
+		proof.SourceRole = "main"
+	}
+	if replacement := pkg.Module.Replace; replacement != nil {
+		proof.SourceRole = "owned_local_replace"
+		if replacement.Version != "" {
+			proof.SourceModule, proof.SourceVersion = replacement.Path, replacement.Version
+			proof.SourceRole = "version_replace"
+		}
+	}
+	if err := gotoolprofile.ValidatePackageModule(consumer.Input, proof); err != nil {
+		return proof, err
+	}
+	capture := func(files []string, assemblyOnly bool) ([]string, error) {
+		var names []string
+		for _, filename := range files {
+			if assemblyOnly && filepath.Ext(filename) != ".s" {
+				continue
+			}
+			name, err := consumer.sourceName(filename)
+			if err != nil {
+				return nil, err
+			}
+			proof.SourceSHA256[name] = consumer.Input.Sources[name]
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		return names, nil
+	}
+	if proof.GoFiles, err = capture(pkg.GoFiles, false); err != nil {
+		return proof, err
+	}
+	if proof.CompiledGoFiles, err = capture(pkg.CompiledGoFiles, false); err != nil {
+		return proof, err
+	}
+	if proof.SFiles, err = capture(pkg.OtherFiles, true); err != nil {
+		return proof, err
+	}
+	if len(proof.GoFiles) == 0 || len(proof.CompiledGoFiles) == 0 {
+		return proof, fmt.Errorf("source consumer requires actual non-test Go selection")
+	}
+	return proof, nil
+}
+
+func (consumer *featureConsumer) sourceName(filename string) (string, error) {
+	name, err := consumer.moduleSourceName(filename)
+	if err != nil {
+		return "", err
+	}
+	if _, present := consumer.Input.Directories[filepath.ToSlash(filepath.Dir(name))]; !present {
+		return "", fmt.Errorf("actual selected source lacks complete directory membership proof: %s", name)
+	}
+	return name, nil
+}
+
+// CPP resources have exact registered byte/origin proofs, but a shared header
+// directory need not be a selected Go package or its ancestor. Go package
+// capture still uses sourceName and retains its separate membership check.
+func (consumer *featureConsumer) moduleSourceName(filename string) (string, error) {
+	filename, err := sourcepath.Resolve(filename)
+	if err != nil {
+		return "", err
+	}
+	name, err := filepath.Rel(consumer.Dir, filename)
+	name = filepath.ToSlash(name)
+	if err != nil || strings.HasPrefix(name, "../") || consumer.Input.Sources[name] == "" {
+		return "", fmt.Errorf("actual selected source has no pre-load proof: %s", filename)
+	}
+	return name, nil
+}
+
+func (consumer *featureConsumer) packageMacros(pkg *packages.Package) (*gotoolprofile.AssemblerMacros, error) {
+	actual, err := gotoolprofile.CaptureAssemblerMacros(consumer.Root, consumer.Observed, pkg.PkgPath)
+	if err != nil {
+		return nil, err
+	}
+	if consumer.Proof != nil {
+		for _, proof := range consumer.Proof.Packages {
+			if proof.PackagePath == pkg.PkgPath {
+				if !reflect.DeepEqual(actual, proof.Macros) {
+					return nil, fmt.Errorf("actual assembler registration changed during consumption")
+				}
+				return actual, nil
+			}
+		}
+		return nil, fmt.Errorf("package has no same-load feature selection proof")
+	}
+	return actual, nil // focused unit fixture, never the CLI proof path
+}
+
+var featureIncludeRE = regexp.MustCompile(`^#include[ \t]+"([^"\r\n]+)"[ \t]*(?://.*)?$`)
+
+// The legacy reader resolves nested local includes relative to the including
+// header. Actual Go searches from the original assembly package directory.
+// Until that reader supports the exact policy, reject any differing binding.
+func (consumer *featureConsumer) captureCPPInputs(asm string) (map[string]string, error) {
+	inputs := make(map[string]string)
+	packageDir := filepath.Dir(asm)
+	active := make(map[string]bool)
+	var visit func(string, int) error
+	visit = func(file string, depth int) error {
+		if consumer.Context != nil && consumer.Context.Err() != nil {
+			return consumer.Context.Err()
+		}
+		if depth > 32 || len(inputs) >= 512 || active[file] {
+			return fmt.Errorf("feature CPP input nesting/cycle exceeds its explicit bound")
+		}
+		active[file] = true
+		defer delete(active, file)
+		reader, err := os.Open(file)
+		if err != nil {
+			return err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(reader, 64<<20+1))
+		closeErr := reader.Close()
+		if readErr != nil || closeErr != nil || len(data) > 64<<20 {
+			return fmt.Errorf("read bounded actual feature CPP source: %s: %v (close: %v)", file, readErr, closeErr)
+		}
+		id, err := consumer.moduleSourceName(file)
+		var expected string
+		if err == nil {
+			expected = consumer.Input.Sources[id]
+			id = "module/" + id
+		} else {
+			name, relErr := filepath.Rel(consumer.Root, file)
+			name = filepath.ToSlash(name)
+			if relErr != nil || consumer.Input.ToolSources[name] == "" {
+				return fmt.Errorf("CPP source lacks exact module/tool input proof: %s", file)
+			}
+			id = "tool/" + name
+			expected = consumer.Input.ToolSources[name]
+		}
+		actual := featureBytesSHA256(data)
+		if actual != expected {
+			return fmt.Errorf("consumed CPP bytes differ from exact pre-load source: %s", id)
+		}
+		inputs[id] = actual
+		for _, line := range strings.Split(string(data), "\n") {
+			line = strings.TrimSpace(line)
+			if !strings.HasPrefix(line, "#include") {
+				continue
+			}
+			match := featureIncludeRE.FindStringSubmatch(line)
+			if match == nil || filepath.IsAbs(match[1]) || strings.Contains(match[1], "\\") {
+				return fmt.Errorf("feature CPP include needs exact literal binding: %s", line)
+			}
+			preferred := filepath.Clean(filepath.Join(packageDir, filepath.FromSlash(match[1])))
+			actual := preferred
+			if _, err := os.Stat(actual); os.IsNotExist(err) {
+				actual = filepath.Clean(filepath.Join(consumer.Root, "pkg", "include", filepath.FromSlash(match[1])))
+			}
+			legacy := filepath.Clean(filepath.Join(filepath.Dir(file), filepath.FromSlash(match[1])))
+			if _, err := os.Stat(legacy); os.IsNotExist(err) {
+				legacy = filepath.Clean(filepath.Join(consumer.Root, "pkg", "include", filepath.FromSlash(match[1])))
+			}
+			if actual != legacy {
+				return fmt.Errorf("CPP include binding differs between actual Go and the translator: %s", match[1])
+			}
+			if err := visit(actual, depth+1); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	if err := visit(asm, 0); err != nil {
+		return nil, err
+	}
+	return inputs, consumer.verifySources()
+}
diff --git a/cmd/plan9asmll/feature_profile_bytes_test.go b/cmd/plan9asmll/feature_profile_bytes_test.go
new file mode 100644
index 000000000..b1395546a
--- /dev/null
+++ b/cmd/plan9asmll/feature_profile_bytes_test.go
@@ -0,0 +1,116 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestFeatureConsumerCompleteJSONBeyondLegacyByteLimit(t *testing.T) {
+	input, directory := featureConsumerFixture(t)
+	t.Chdir(directory)
+	data, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Leading JSON whitespace changes no source, profile, closure or role.
+	// The complete input, not a truncated prefix, must reach all normal guards.
+	data = append(bytes.Repeat([]byte(" "), 4<<20), data...)
+	filename := filepath.Join(t.TempDir(), "complete-profile.json")
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer, err := loadFeatureConsumer(ctx, filename, t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatalf("complete source-bound JSON beyond the old transport limit: %v", err)
+	}
+	if !reflect.DeepEqual(consumer.Input, input) {
+		t.Fatal("transport changed the complete input or its source roles")
+	}
+	for name, change := range map[string]func(*featureInput){
+		"module identity": func(input *featureInput) { input.Module = "example.invalid/other" },
+		"source identity": func(input *featureInput) { input.Sources["probe_amd64.s"] = strings.Repeat("0", 64) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed featureInput
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			change(&changed)
+			encoded, err := gotoolprofile.MarshalConsumerInput(&changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			encoded = append(bytes.Repeat([]byte(" "), 4<<20), encoded...)
+			if err := os.WriteFile(filename, encoded, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := loadFeatureConsumer(ctx, filename, t.TempDir(), "linux/amd64", input.Module, nil); err == nil {
+				t.Fatal("larger transport bypassed an unchanged source/profile guard")
+			}
+		})
+	}
+}
+
+func TestFeatureConsumerCLICompleteJSONProducesObjectProof(t *testing.T) {
+	input, directory := featureConsumerFixture(t)
+	filename := writeFeatureInput(t, input)
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data = append(bytes.Repeat([]byte(" "), 4<<20), data...)
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	output, report := t.TempDir(), filepath.Join(t.TempDir(), "report.json")
+	args := []string{"-goos=linux", "-goarch=amd64", "-patterns=.", "-module-path=" + input.Module,
+		"-asm-files=probe_amd64.s", "-feature-profile=" + filename, "-feature-timeout=1m",
+		"-compile", "-keep-obj", "-out=" + output, "-report=" + report}
+	encoded, err := json.Marshal(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded))
+	_, stderr, err := gotoolprofile.RunBounded(ctx, directory, env, os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+	if err != nil {
+		t.Fatalf("actual complete-profile CLI object stage: %v\n%s", err, stderr)
+	}
+	data, err = os.ReadFile(report)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result runReport
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	if result.Success != 1 || result.Failed != 0 || result.FeatureSelection == nil {
+		t.Fatal("CLI did not produce its original object/source-consumption proof")
+	}
+	if err := gotoolprofile.ValidateSelection(input, result.FeatureSelection, nil, true); err != nil {
+		t.Fatalf("independent same-profile object proof readback: %v", err)
+	}
+}
+
+func TestFeatureConsumerCLIOverflowIsExplicitBeforeIdentity(t *testing.T) {
+	filename := filepath.Join(t.TempDir(), "oversized-profile.json")
+	if err := os.WriteFile(filename, bytes.Repeat([]byte(" "), gotoolprofile.ConsumerInputJSONLimit+1), 0600); err != nil {
+		t.Fatal(err)
+	}
+	consumer, err := loadFeatureConsumer(context.Background(), filename, t.TempDir(), "linux/amd64", "example.invalid/x", nil)
+	if consumer != nil || err == nil || !strings.Contains(err.Error(), "byte bound") || strings.Contains(err.Error(), "EOF") {
+		t.Fatalf("oversized profile did not report the real bounded transport failure: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/feature_profile_test.go b/cmd/plan9asmll/feature_profile_test.go
new file mode 100644
index 000000000..990cb9303
--- /dev/null
+++ b/cmd/plan9asmll/feature_profile_test.go
@@ -0,0 +1,397 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCompileOneExplicitCPUProfileUsesActualAssemblerMacros(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := gotoolprofile.Capture(context.Background(), binary, t.TempDir(), os.Environ(), "linux/amd64", map[string]string{"GOAMD64": "v3"}, testFeatureRunner)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rootData, _, err := testFeatureRunner(context.Background(), "", os.Environ(), binary, "env", "GOROOT")
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := strings.TrimSpace(string(rootData))
+	typesPkg := types.NewPackage("example.invalid/cpu", "cpu")
+	for _, name := range []string{"v3Probe", "baselineProbe"} {
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, types.NewSignatureType(nil, nil, nil, nil, nil, false)))
+	}
+	pkg := &packages.Package{PkgPath: typesPkg.Path(), Types: typesPkg, Imports: map[string]*packages.Package{}}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "probe_amd64.s")
+	if err := os.WriteFile(asm, []byte("#ifdef GOAMD64_v3\nTEXT ·v3Probe(SB),$0-0\nRET\n#else\nTEXT ·baselineProbe(SB),$0-0\nRET\n#endif\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	output := filepath.Join(dir, "profile.ll")
+	config := compileConfig{Feature: &featureConsumer{ID: gotoolprofile.ProfileID(observed), Observed: observed, Root: root}}
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: output}, false, config); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(ir), "v3Probe") || strings.Contains(string(ir), "baselineProbe") {
+		t.Fatalf("explicit actual GOAMD64=v3 selected the baseline CPP branch:\n%s", ir)
+	}
+}
+
+func testFeatureRunner(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+	command := exec.CommandContext(ctx, name, args...)
+	command.Dir, command.Env = dir, env
+	var stderr strings.Builder
+	command.Stderr = &stderr
+	stdout, err := command.Output()
+	return stdout, []byte(stderr.String()), err
+}
+
+func TestFeatureConsumerProductionSelectsGoAndCPPUnderSameV3Environment(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	t.Chdir(dir)
+	filename := writeFeatureInput(t, input)
+	output := t.TempDir()
+	tasks, _ := collectAsmTasks([]*packages.Package{{PkgPath: input.Module, OtherFiles: []string{filepath.Join(dir, "probe_amd64.s")}, Module: &packages.Module{Path: input.Module, Dir: dir}}}, output, input.AsmFiles)
+	if len(tasks) != 1 {
+		t.Fatal("own source fixture did not define exactly one task")
+	}
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	config.FeaturePath, config.Context = filename, ctx
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, output, false, 0, true, false, true, "../..", config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if report.Success != 1 || report.Failed != 0 || report.FeatureSelection == nil || report.FeatureSelection.ProfileID != input.ID {
+		t.Fatalf("actual profile consumer report = %#v", report)
+	}
+	proof := report.FeatureSelection
+	if err := gotoolprofile.ValidateSelection(input, proof, nil, true); err != nil {
+		t.Fatal(err)
+	}
+	canonical, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+		"profile ID":        func(proof *gotoolprofile.SelectionProof) { proof.ProfileID = "" },
+		"custom CPU tag":    func(proof *gotoolprofile.SelectionProof) { proof.CustomTags = []string{"amd64.v3"} },
+		"package role":      func(proof *gotoolprofile.SelectionProof) { proof.Packages[0].Macros.PackageRole = "allow_asm_abi_path" },
+		"macro environment": func(proof *gotoolprofile.SelectionProof) { proof.Packages[0].Macros.Defines = []string{"GOAMD64_v1"} },
+		"source SHA": func(proof *gotoolprofile.SelectionProof) {
+			proof.Packages[0].SourceSHA256["selected.go"] = strings.Repeat("0", 64)
+		},
+		"unselected Go source": func(proof *gotoolprofile.SelectionProof) {
+			proof.Packages[0].GoFiles, proof.Packages[0].CompiledGoFiles = []string{"fallback.go"}, []string{"fallback.go"}
+			delete(proof.Packages[0].SourceSHA256, "selected.go")
+			proof.Packages[0].SourceSHA256["fallback.go"] = input.Sources["fallback.go"]
+		},
+		"CPP origin": func(proof *gotoolprofile.SelectionProof) {
+			proof.CPP[0].Inputs["module/probe_amd64.s"] = strings.Repeat("0", 64)
+		},
+		"omitted CPP":    func(proof *gotoolprofile.SelectionProof) { proof.CPP = nil },
+		"omitted LLVM":   func(proof *gotoolprofile.SelectionProof) { proof.Outputs = nil },
+		"omitted object": func(proof *gotoolprofile.SelectionProof) { proof.Outputs[0].Object = "" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.SelectionProof
+			if err := json.Unmarshal(canonical, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+				t.Fatal("mutated or legacy compiler-consumption proof was accepted")
+			}
+		})
+	}
+	if len(proof.Packages) != 1 || len(proof.Packages[0].CompiledGoFiles) != 1 || proof.Packages[0].CompiledGoFiles[0] != "selected.go" || proof.Packages[0].Macros.PackageRole != "ordinary_path" {
+		t.Fatalf("actual Go source/package role selection = %#v", proof.Packages)
+	}
+	if len(proof.CPP) != 1 || len(proof.Outputs) != 1 || proof.Outputs[0].Object == "" {
+		t.Fatalf("missing consumed CPP/LLVM object proof = %#v", proof)
+	}
+	ir, err := os.ReadFile(tasks[0].OutLL)
+	if err != nil || !strings.Contains(string(ir), "v3Probe") || strings.Contains(string(ir), "baselineProbe") {
+		t.Fatalf("actual consumer emitted the wrong CPU branch: %s (%v)", ir, err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := featureEnvironment(os.Environ(), input.Observed.Environment)
+	archive, _, err := gotoolprofile.RunBounded(ctx, dir, env, binary, "list", "-export", "-f", "{{.Export}}", ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	symbols, _, err := gotoolprofile.RunBounded(ctx, dir, env, binary, "tool", "nm", strings.TrimSpace(string(archive)))
+	if err != nil || !strings.Contains(string(symbols), "v3Probe") || strings.Contains(string(symbols), "baselineProbe") {
+		t.Fatalf("actual Go object selected a different CPP branch:\n%s\n%v", symbols, err)
+	}
+	var llvmNM string
+	for _, name := range []string{"llvm-nm-22", "llvm-nm"} {
+		path, err := exec.LookPath(name)
+		if err == nil && requireLLVM22LLC(path) == nil {
+			llvmNM = path
+			break
+		}
+	}
+	if llvmNM == "" {
+		t.Fatal("LLVM 22 nm is required for the actual object symbol oracle")
+	}
+	object := strings.TrimSuffix(tasks[0].OutLL, filepath.Ext(tasks[0].OutLL)) + ".o"
+	symbols, _, err = gotoolprofile.RunBounded(ctx, dir, env, llvmNM, "--defined-only", object)
+	if err != nil || !strings.Contains(string(symbols), "v3Probe") || strings.Contains(string(symbols), "baselineProbe") {
+		t.Fatalf("LLVM 22 object selected a different CPU branch:\n%s\n%v", symbols, err)
+	}
+}
+
+func TestFeatureConsumerRejectsUnboundSourceToolAndReservedTags(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	t.Chdir(dir)
+	for _, tag := range []string{"amd64.v3", "goexperiment.arenas", "linux", "gc", "cgo", "ignore", "race"} {
+		if _, err := loadFeatureConsumer(context.Background(), writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, []string{tag}); err == nil {
+			t.Fatalf("reserved namespace %q became a custom CPU profile", tag)
+		}
+	}
+	copy := *input.Observed
+	copy.DriverSHA256 = strings.Repeat("0", 64)
+	forged := *input
+	forged.Observed, forged.ID = &copy, gotoolprofile.ProfileID(&copy)
+	if _, err := loadFeatureConsumer(context.Background(), writeFeatureInput(t, &forged), t.TempDir(), "linux/amd64", input.Module, nil); err == nil || !strings.Contains(err.Error(), "actual marker/environment/source/tool") {
+		t.Fatalf("JSON-only forged driver identity was accepted: %v", err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "selected.go"), []byte("package cpu\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := loadFeatureConsumer(context.Background(), writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil); err == nil || !strings.Contains(err.Error(), "pre-load proof") {
+		t.Fatalf("changed pre-load source was accepted: %v", err)
+	}
+}
+
+func TestFeatureConsumerDefaultCompilationRemainsUnprofiled(t *testing.T) {
+	t.Setenv("GOAMD64", "v3")
+	typesPkg := types.NewPackage("example.invalid/default", "defaultfixture")
+	for _, name := range []string{"v3Probe", "baselineProbe"} {
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, types.NewSignatureType(nil, nil, nil, nil, nil, false)))
+	}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "default_amd64.s")
+	if err := os.WriteFile(asm, []byte("#ifdef GOAMD64_v3\nTEXT ·v3Probe(SB),$0-0\nRET\n#else\nTEXT ·baselineProbe(SB),$0-0\nRET\n#endif\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{PkgPath: typesPkg.Path(), Types: typesPkg, Imports: map[string]*packages.Package{}}
+	output := filepath.Join(dir, "default.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: output}, false, compileConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(output)
+	if err != nil || !strings.Contains(string(ir), "v3Probe") || strings.Contains(string(ir), "baselineProbe") {
+		t.Fatalf("explicit opt-in changed legacy compilation: %s (%v)", ir, err)
+	}
+}
+
+func TestFeatureConsumerRejectsHeaderMutationAndNewPreferredInclude(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	if err := os.WriteFile(filepath.Join(dir, "settings.h"), []byte("#define CANARY 1\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["settings.h"] = featureBytesSHA256([]byte("#define CANARY 1\n"))
+	input.Directories["."] = append(input.Directories["."], "settings.h")
+	sort.Strings(input.Directories["."])
+	asm := filepath.Join(dir, "probe_amd64.s")
+	data, err := os.ReadFile(asm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data = append([]byte("#include \"settings.h\"\n"), data...)
+	if err := os.WriteFile(asm, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["probe_amd64.s"] = featureBytesSHA256(data)
+	t.Chdir(dir)
+	consumer, err := loadFeatureConsumer(context.Background(), writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs, err := consumer.captureCPPInputs(asm)
+	if err != nil || inputs["module/settings.h"] != input.Sources["settings.h"] {
+		t.Fatalf("original header binding was not captured: %v, %v", inputs, err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "settings.h"), []byte("#define CANARY 2\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := consumer.captureCPPInputs(asm); err == nil {
+		t.Fatal("changed consumed header bytes were accepted")
+	}
+	if err := os.WriteFile(filepath.Join(dir, "new_preferred.h"), []byte("#define CANARY 3\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err == nil {
+		t.Fatal("new preferred source-directory member was accepted")
+	}
+}
+
+func TestFeatureConsumerCLIProducesBoundSelectionReport(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	profile := writeFeatureInput(t, input)
+	output, report := t.TempDir(), filepath.Join(t.TempDir(), "report.json")
+	args := []string{"-goos=linux", "-goarch=amd64", "-patterns=.", "-module-path=" + input.Module,
+		"-asm-files=probe_amd64.s", "-feature-profile=" + profile, "-feature-timeout=1m",
+		"-compile", "-keep-obj", "-out=" + output, "-report=" + report}
+	encoded, err := json.Marshal(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded))
+	_, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+	if err != nil {
+		t.Fatalf("actual CLI failed: %v\n%s", err, stderr)
+	}
+	data, err := os.ReadFile(report)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var decoded runReport
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatal(err)
+	}
+	if decoded.Success != 1 || decoded.Failed != 0 || decoded.FeatureSelection == nil || decoded.FeatureSelection.ProfileID != input.ID || len(decoded.FeatureSelection.Outputs) != 1 || decoded.FeatureSelection.Outputs[0].Object == "" {
+		t.Fatalf("actual CLI did not emit the same-load/CPP/object proof: %s", data)
+	}
+}
+
+func TestFeatureConsumerCLIChild(t *testing.T) {
+	encoded := os.Getenv("PLAN9ASM_CPUCLI_ARGS")
+	if encoded == "" {
+		return
+	}
+	var args []string
+	if err := json.Unmarshal([]byte(encoded), &args); err != nil {
+		t.Fatal(err)
+	}
+	flag.CommandLine = flag.NewFlagSet("own-cpu-fixture", flag.ExitOnError)
+	os.Args = append([]string{"own-cpu-fixture"}, args...)
+	main()
+	os.Exit(0)
+}
+
+func TestFeatureConsumerExactLocalReplacementKeepsSourceRootIdentity(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	input.Version = "v1.0.0"
+	work := t.TempDir()
+	mod := "module example.invalid/wrapper\n\ngo 1.24\n\nrequire " + input.Module + " v1.0.0\nreplace " + input.Module + " => " + filepath.ToSlash(dir) + "\n"
+	if err := os.WriteFile(filepath.Join(work, "go.mod"), []byte(mod), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(work)
+	consumer, err := loadFeatureConsumer(context.Background(), writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkgs, err := loadPkgsForFeature("linux", "amd64", []string{input.Module}, nil, input.Module, true, false, consumer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.capturePackages(pkgs); err != nil {
+		t.Fatal(err)
+	}
+	if len(consumer.Proof.Packages) != 1 || consumer.Proof.Packages[0].CompiledGoFiles[0] != "selected.go" {
+		t.Fatalf("exact owned replacement selection was lost: %#v", consumer.Proof)
+	}
+	pkgs[0].Module.Version = "v2.0.0"
+	if err := consumer.capturePackages(pkgs); err == nil {
+		t.Fatal("different actual selected module version was accepted")
+	}
+	pkgs[0].Module.Version = input.Version
+	pkgs[0].Module.Replace.Dir = t.TempDir()
+	if err := consumer.capturePackages(pkgs); err == nil {
+		t.Fatal("redirected local replacement was accepted")
+	}
+}
+
+func featureConsumerFixture(t *testing.T) (*featureInput, string) {
+	t.Helper()
+	dir := t.TempDir()
+	files := map[string]string{
+		"go.mod":        "module example.invalid/cpu\n\ngo 1.24\n",
+		"selected.go":   "//go:build amd64.v3\n\npackage cpu\nfunc v3Probe()\nfunc baselineProbe()\n",
+		"fallback.go":   "//go:build !amd64.v3\n\npackage cpu\nfunc v3Probe()\nfunc baselineProbe()\n",
+		"probe_amd64.s": "#ifdef GOAMD64_v3\nTEXT ·v3Probe(SB),$0-0\nRET\n#else\nTEXT ·baselineProbe(SB),$0-0\nRET\n#endif\n",
+	}
+	input := &featureInput{Protocol: featureInputProtocol, Module: "example.invalid/cpu", SourceRoot: dir, Sources: make(map[string]string), Headers: make(map[string]string), Directories: make(map[string][]string), AsmFiles: []string{"probe_amd64.s"}}
+	var names []string
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".s") {
+			input.Headers[name] = source
+		}
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	input.Directories["."] = names
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Discovery requires existing actual cache directories. Prepare them, but
+	// retain the producer's original environment to test consumer reobservation.
+	if _, err := ordinaryPackageEnvironment("linux", "amd64", os.Environ()); err != nil {
+		t.Fatal(err)
+	}
+	input.Observed, err = gotoolprofile.Capture(context.Background(), binary, t.TempDir(), os.Environ(), "linux/amd64", map[string]string{"GOAMD64": "v3"}, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ID = gotoolprofile.ProfileID(input.Observed)
+	return input, dir
+}
+
+func writeFeatureInput(t *testing.T, input *featureInput) string {
+	t.Helper()
+	data, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	filename := filepath.Join(t.TempDir(), "profile.json")
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	return filename
+}
diff --git a/cmd/plan9asmll/float_compare_specs_test.go b/cmd/plan9asmll/float_compare_specs_test.go
new file mode 100644
index 000000000..ab5b3a6d1
--- /dev/null
+++ b/cmd/plan9asmll/float_compare_specs_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteFloatingCompareSpec(t *testing.T) {
+	filename := "amd64_float_compare_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	wanted := []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		comparisons := 0
+		for opcode := range supported {
+			if strings.HasPrefix(opcode, "CMP") || strings.HasPrefix(opcode, "VCMP") {
+				comparisons++
+			}
+		}
+		if comparisons != len(wanted) {
+			t.Fatalf("%s complete compare-map extraction differs: %v", arch, supported)
+		}
+		for _, opcode := range wanted {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s missing typed comparison %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/float_minmax_supported_ops_test.go b/cmd/plan9asmll/float_minmax_supported_ops_test.go
new file mode 100644
index 000000000..46ea44dae
--- /dev/null
+++ b/cmd/plan9asmll/float_minmax_supported_ops_test.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func testFloatArithmeticOpcodeExtraction(t *testing.T, opcodes []string) {
+	t.Helper()
+	const filename = "amd64_float_arithmetic_forms.go"
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(filepath.Join(repoRoot, filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, filename), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, source := range []struct{ name, root string }{
+		{"isolated", dir}, {"repository", repoRoot},
+	} {
+		architectures := []string{"amd64", "386"}
+		if source.name == "isolated" {
+			// ARM also names an instruction MULSD. Check catalog exclusion
+			// in isolation, and retain both complete-repository x86 controls.
+			architectures = append(architectures, "arm", "arm64", "wasm")
+		}
+		for _, arch := range architectures {
+			t.Run(source.name+"/"+arch, func(t *testing.T) {
+				supported, err := extractSupportedOps(source.root, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, op := range opcodes {
+					_, found := supported[op]
+					if found != (arch == "amd64" || arch == "386") {
+						t.Errorf("arithmetic catalog extraction changed its architecture boundary: %s %s found=%v", arch, op, found)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsIsolatedCompleteFloatMinMaxFamily(t *testing.T) {
+	testFloatArithmeticOpcodeExtraction(t, []string{
+		"MINPS", "MINPD", "MINSS", "MINSD", "MAXPS", "MAXPD", "MAXSS", "MAXSD",
+		"VMINPS", "VMINPD", "VMINSS", "VMINSD", "VMAXPS", "VMAXPD", "VMAXSS", "VMAXSD",
+	})
+}
diff --git a/cmd/plan9asmll/generated_header.go b/cmd/plan9asmll/generated_header.go
new file mode 100644
index 000000000..ceab336bb
--- /dev/null
+++ b/cmd/plan9asmll/generated_header.go
@@ -0,0 +1,397 @@
+package main
+
+import (
+	"fmt"
+	"go/version"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func queryGeneratedHeaders(spec targetSpec, patterns, tags, asmFiles []string, module, output string, cfg compileConfig) (*gotoolprofile.MetadataProof, error) {
+	consumer, err := loadFeatureConsumer(cfg.Context, cfg.FeaturePath, output, spec.Goos+"/"+spec.Goarch, module, tags)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(asmFiles, consumer.Input.AsmFiles) || len(asmFiles) == 0 {
+		return nil, fmt.Errorf("metadata query requires its exact registered ordinary assembly scope")
+	}
+	pkgs, err := loadGeneratedHeaderPackages(consumer, patterns, tags)
+	if err != nil {
+		return nil, err
+	}
+	if err := consumer.capturePackages(pkgs); err != nil {
+		return nil, err
+	}
+	dependencies, err := consumer.ordinaryDependencyProof()
+	if err != nil {
+		return nil, err
+	}
+	proof := &gotoolprofile.MetadataProof{
+		Protocol: gotoolprofile.MetadataProtocol, ProfileID: consumer.ID,
+		CustomTags: append([]string(nil), tags...), Packages: consumer.Proof.Packages,
+		Dependencies: dependencies,
+	}
+	for index, pkg := range pkgs {
+		header, err := captureGeneratedHeader(consumer, pkg, proof.Packages[index], output)
+		if err != nil {
+			return nil, err
+		}
+		proof.Headers = append(proof.Headers, header)
+	}
+	if err := consumer.verifySources(); err != nil {
+		return nil, err
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, err
+	}
+	if err := consumer.reobserve(binary, output); err != nil {
+		return nil, err
+	}
+	if err := gotoolprofile.ValidateMetadata(consumer.Input, proof, tags); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func loadGeneratedHeaderPackages(consumer *featureConsumer, patterns, tags []string) ([]*packages.Package, error) {
+	return loadGeneratedHeaderPackagesWithLoader(consumer, patterns, tags, packages.Load)
+}
+
+func loadGeneratedHeaderPackagesWithLoader(consumer *featureConsumer, patterns, tags []string, load func(*packages.Config, ...string) ([]*packages.Package, error)) ([]*packages.Package, error) {
+	config := &packages.Config{
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedModule | packages.NeedDeps |
+			packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax |
+			packages.NeedCompiledGoFiles | packages.NeedExportFile | packages.NeedEmbedFiles | packages.NeedEmbedPatterns,
+		Context: consumer.Context, Env: consumer.Env, Dir: consumer.WorkDir,
+		BuildFlags: []string{"-mod=mod"},
+	}
+	if len(tags) != 0 {
+		config.BuildFlags = append(config.BuildFlags, "-tags="+strings.Join(tags, ","))
+	}
+	return loadGeneratedHeaderPackagesForRole(consumer, config, patterns, load, true)
+}
+
+// Config is private, constructed only by the ordinary entry above or an
+// independently validated actual instrumentation source context. Both paths
+// retain identical pre/post source/type/export guards and concrete errors.
+func loadGeneratedHeaderPackagesConfigured(consumer *featureConsumer, config *packages.Config, patterns []string, load func(*packages.Config, ...string) ([]*packages.Package, error)) ([]*packages.Package, error) {
+	return loadGeneratedHeaderPackagesForRole(consumer, config, patterns, load, false)
+}
+
+func loadGeneratedHeaderPackagesForRole(consumer *featureConsumer, config *packages.Config, patterns []string, load func(*packages.Config, ...string) ([]*packages.Package, error), ordinary bool) ([]*packages.Package, error) {
+	// Discover the actual dependency source set without compiling exports,
+	// then pin it before the source/type/export load. Root hashes alone do
+	// not guard stdlib or other dependency modules during that load.
+	preConfig := *config
+	preConfig.Mode &^= packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedExportFile
+	before, err := load(&preConfig, patterns...)
+	if err != nil {
+		return nil, err
+	}
+	captureGuard := func(pkgs []*packages.Package) (*generatedHeaderLoadGuard, error) {
+		if ordinary {
+			return captureTypedSourceLoadGuardWithEmbeds(consumer.Context, pkgs, nil, consumer.verifyOrdinaryEmbedPackage)
+		}
+		return captureGeneratedHeaderLoadGuard(consumer.Context, pkgs)
+	}
+	if ordinary {
+		if err := consumer.captureOrdinaryDependencies(before); err != nil {
+			return nil, err
+		}
+	}
+	guard, err := captureGuard(before)
+	if err != nil {
+		return nil, err
+	}
+	pkgs, err := load(config, patterns...)
+	if err != nil {
+		return nil, err
+	}
+	// Keep concrete compiler/list diagnostics, including dependency errors,
+	// rather than replacing them with an opaque package-loading count.
+	var diagnostics []string
+	packages.Visit(pkgs, nil, func(pkg *packages.Package) {
+		for _, err := range pkg.Errors {
+			diagnostics = append(diagnostics, err.Error())
+		}
+		// NeedSyntax explicitly asks x/tools to typecheck selected source,
+		// not decode Go 1.27's newer binary export format. The actual exports
+		// remain compiler inputs; syntax trees are not retained in this proof.
+		pkg.Syntax = nil
+	})
+	if len(diagnostics) != 0 {
+		sort.Strings(diagnostics)
+		return nil, fmt.Errorf("actual generated-header Go package compilation:\n%s", strings.Join(diagnostics, "\n"))
+	}
+	after, err := captureGuard(pkgs)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(guard, after) {
+		return nil, fmt.Errorf("generated-header dependency/source selection changed during actual Go export/type load")
+	}
+	if ordinary {
+		if err := consumer.finishOrdinaryDependencies(pkgs); err != nil {
+			return nil, err
+		}
+	}
+	if err := consumer.retainGeneratedGuard(guard.Sources); err != nil {
+		return nil, err
+	}
+	pkgs = filterPackagesByModule(pkgs, consumer.Input.Module)
+	if len(pkgs) == 0 {
+		return nil, fmt.Errorf("generated-header query selected no exact ordinary package")
+	}
+	sort.Slice(pkgs, func(i, j int) bool { return pkgs[i].PkgPath < pkgs[j].PkgPath })
+	return pkgs, consumer.verifySources()
+}
+
+func captureGeneratedHeader(consumer *featureConsumer, pkg *packages.Package, selected gotoolprofile.PackageProof, output string) (gotoolprofile.GeneratedHeaderProof, error) {
+	return captureGeneratedHeaderConfigured(consumer, pkg, selected, output, generatedHeaderCaptureContext{
+		protocol: gotoolprofile.GeneratedHeaderProtocol, id: consumer.ID,
+		validate: func(proof gotoolprofile.GeneratedHeaderProof) error {
+			return gotoolprofile.ValidateGeneratedHeader(consumer.Input, proof, selected)
+		},
+	})
+}
+
+type generatedHeaderCaptureContext struct {
+	protocol      string
+	id            string
+	compilerFlags []string
+	validate      func(gotoolprofile.GeneratedHeaderProof) error
+}
+
+func captureGeneratedHeaderConfigured(consumer *featureConsumer, pkg *packages.Package, selected gotoolprofile.PackageProof, output string, context generatedHeaderCaptureContext) (gotoolprofile.GeneratedHeaderProof, error) {
+	var proof gotoolprofile.GeneratedHeaderProof
+	if context.validate == nil || pkg == nil || isTestVariantPackage(pkg) || pkg.Types == nil || len(pkg.EmbedFiles) != 0 || len(pkg.EmbedPatterns) != 0 {
+		return proof, fmt.Errorf("generated-header metadata requires an ordinary typed package without unbound embed/test roles")
+	}
+	if err := consumer.verifySources(); err != nil {
+		return proof, err
+	}
+	owned, err := os.MkdirTemp(output, ".generated-header-")
+	if err != nil {
+		return proof, err
+	}
+	// Retain these owned oracle artifacts. They are not Go dependency cache
+	// files and their existence is not assembly translation evidence.
+	imports, exports, importcfg, sourceGuard, err := generatedHeaderImports(consumer, pkg)
+	if err != nil {
+		return proof, err
+	}
+	for _, guard := range []map[string]string{exports, sourceGuard} {
+		if err := consumer.retainGeneratedGuard(guard); err != nil {
+			return proof, err
+		}
+	}
+	configFile := filepath.Join(owned, "importcfg")
+	if err := os.WriteFile(configFile, []byte(importcfg), 0600); err != nil {
+		return proof, err
+	}
+	configSHA, err := gotoolprofile.FileSHA256(configFile)
+	if err != nil {
+		return proof, err
+	}
+	headerFile, objectFile := filepath.Join(owned, "go_asm.h"), filepath.Join(owned, "go.o")
+	goVersion := "1.16" // The Go command's default for a module without a go directive.
+	if pkg.Module != nil && pkg.Module.GoVersion != "" {
+		goVersion = pkg.Module.GoVersion
+	}
+	lang := version.Lang("go" + goVersion)
+	if lang == "" {
+		return proof, fmt.Errorf("actual selected module has no valid Go language version")
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return proof, err
+	}
+	if err := verifyGeneratedHeaderCompiler(consumer, binary); err != nil {
+		return proof, err
+	}
+	args := []string{"tool", "compile", "-p", pkg.PkgPath, "-lang=" + lang,
+		"-importcfg", configFile, "-asmhdr", headerFile, "-o", objectFile}
+	args = append(args, context.compilerFlags...)
+	args = append(args, pkg.CompiledGoFiles...)
+	if _, _, err := gotoolprofile.RunBounded(consumer.Context, consumer.WorkDir, consumer.Env, binary, args...); err != nil {
+		return proof, fmt.Errorf("actual Go compiler -asmhdr: %w", err)
+	}
+	if err := verifyGeneratedHeaderCompiler(consumer, binary); err != nil {
+		return proof, err
+	}
+	for file, expected := range exports {
+		actual, err := gotoolprofile.FileSHA256(file)
+		if err != nil || actual != expected {
+			return proof, fmt.Errorf("actual dependency export changed during generated-header compilation")
+		}
+	}
+	for file, expected := range sourceGuard {
+		actual, err := gotoolprofile.FileSHA256(file)
+		if err != nil || actual != expected {
+			return proof, fmt.Errorf("actual dependency Go source changed during generated-header compilation")
+		}
+	}
+	actualConfigSHA, err := gotoolprofile.FileSHA256(configFile)
+	if err != nil || actualConfigSHA != configSHA {
+		return proof, fmt.Errorf("actual compiler importcfg changed during generated-header compilation")
+	}
+	if err := consumer.verifySources(); err != nil {
+		return proof, err
+	}
+	data, err := os.ReadFile(headerFile)
+	if err != nil {
+		return proof, err
+	}
+	definitions, err := gotoolprofile.HeaderDefinitions(data)
+	if err != nil {
+		return proof, err
+	}
+	typed, err := plan9asm.GoAssemblyHeader(plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types}, consumer.Observed.Environment["GOARCH"])
+	if err != nil {
+		return proof, err
+	}
+	typedDefinitions, err := gotoolprofile.HeaderDefinitions(typed)
+	if err != nil || !reflect.DeepEqual(definitions, typedDefinitions) {
+		return proof, fmt.Errorf("full generated-header definitions differ from actual Go -asmhdr: actual=%v typed=%v: %v", definitions, typedDefinitions, err)
+	}
+	info, err := os.Stat(objectFile)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		return proof, fmt.Errorf("actual generated-header compiler did not create a nonempty Go object")
+	}
+	objectSHA, err := gotoolprofile.FileSHA256(objectFile)
+	if err != nil {
+		return proof, err
+	}
+	proof = gotoolprofile.GeneratedHeaderProof{
+		Protocol: context.protocol, PackagePath: pkg.PkgPath,
+		ProfileID: context.id, Target: consumer.Observed.Target, GoVersion: consumer.Observed.GoVersion,
+		LanguageVersion:   lang,
+		CompileToolSHA256: consumer.Observed.ToolBinarySHA256["compile"],
+		HeaderSHA256:      featureBytesSHA256(data), ObjectSHA256: objectSHA,
+		Definitions: definitions, DefinitionsSHA256: gotoolprofile.HeaderDefinitionSHA256(definitions),
+		CompiledGoSHA256: make(map[string]string), ImportMap: make(map[string]string), Imports: imports,
+	}
+	for name, dep := range pkg.Imports {
+		proof.ImportMap[name] = dep.PkgPath
+	}
+	for _, file := range selected.CompiledGoFiles {
+		proof.CompiledGoSHA256[file] = selected.SourceSHA256[file]
+	}
+	return proof, context.validate(proof)
+}
+
+func verifyGeneratedHeaderCompiler(consumer *featureConsumer, binary string) error {
+	data, _, err := gotoolprofile.RunBounded(consumer.Context, consumer.WorkDir, consumer.Env, binary, "tool", "-n", "compile")
+	if err != nil {
+		return err
+	}
+	route := strings.TrimSpace(string(data))
+	if !filepath.IsAbs(route) || strings.ContainsAny(route, "\r\n") {
+		return fmt.Errorf("actual generated-header compiler route is not one executable")
+	}
+	actual, err := gotoolprofile.FileSHA256(route)
+	if err != nil || actual != consumer.Observed.ToolBinarySHA256["compile"] {
+		return fmt.Errorf("generated-header compiler differs from the actual registered profile tool")
+	}
+	return nil
+}
+
+func generatedHeaderImports(consumer *featureConsumer, pkg *packages.Package) ([]gotoolprofile.ImportExport, map[string]string, string, map[string]string, error) {
+	return generatedHeaderImportsForRole(consumer, pkg, false)
+}
+
+func generatedHeaderImportsForRole(consumer *featureConsumer, pkg *packages.Package, boundTestEmbeds bool) ([]gotoolprofile.ImportExport, map[string]string, string, map[string]string, error) {
+	var imports []gotoolprofile.ImportExport
+	var config strings.Builder
+	exports, sources := make(map[string]string), make(map[string]string)
+	var names []string
+	for name := range pkg.Imports {
+		if name != "unsafe" {
+			names = append(names, name)
+		}
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		dep := pkg.Imports[name]
+		if dep == nil || dep.ExportFile == "" || strings.ContainsAny(dep.ExportFile, "\r\n") || isTestVariantPackage(dep) || len(dep.CompiledGoFiles) == 0 || strings.ContainsAny(name+dep.PkgPath, "\r\n=\\") {
+			return nil, nil, "", nil, fmt.Errorf("generated header requires actual ordinary same-profile dependency exports")
+		}
+		if len(dep.EmbedFiles) != 0 || len(dep.EmbedPatterns) != 0 {
+			verify := consumer.verifyOrdinaryEmbedPackage
+			if boundTestEmbeds {
+				verify = consumer.verifyTestEmbedPackage
+			}
+			if err := verify(dep); err != nil {
+				return nil, nil, "", nil, err
+			}
+			for _, file := range dep.EmbedFiles {
+				digest, err := gotoolprofile.FileSHA256(file)
+				if err != nil {
+					return nil, nil, "", nil, err
+				}
+				sources[file] = digest
+			}
+		}
+		digest, err := gotoolprofile.FileSHA256(dep.ExportFile)
+		if err != nil {
+			return nil, nil, "", nil, err
+		}
+		imported := gotoolprofile.ImportExport{ImportPath: name, PackagePath: dep.PkgPath, ExportSHA256: digest, GoSHA256: make(map[string]string), SourceRole: "stdlib"}
+		root := filepath.Join(consumer.Root, "src")
+		if dep.Module != nil {
+			root = dep.Module.Dir
+			imported.ModulePath, imported.Version = dep.Module.Path, dep.Module.Version
+			imported.SourceModule, imported.SourceVersion, imported.SourceRole = dep.Module.Path, dep.Module.Version, "module"
+			if dep.Module.Main {
+				imported.SourceRole = "main"
+			}
+			if dep.Module.Replace != nil {
+				root, imported.SourceRole = dep.Module.Replace.Dir, "owned_local_replace"
+				if dep.Module.Replace.Version != "" {
+					imported.SourceModule, imported.SourceVersion = dep.Module.Replace.Path, dep.Module.Replace.Version
+					imported.SourceRole = "version_replace"
+				}
+			}
+		}
+		root, err = sourcepath.Resolve(root)
+		if err != nil {
+			return nil, nil, "", nil, err
+		}
+		for _, file := range dep.CompiledGoFiles {
+			resolved, err := sourcepath.Resolve(file)
+			if err != nil {
+				return nil, nil, "", nil, err
+			}
+			rel, err := filepath.Rel(root, resolved)
+			if err != nil || !filepath.IsLocal(rel) {
+				return nil, nil, "", nil, fmt.Errorf("dependency compiler source has an unbound generated/cgo role")
+			}
+			digest, err := gotoolprofile.FileSHA256(resolved)
+			if err != nil {
+				return nil, nil, "", nil, err
+			}
+			imported.GoSHA256[filepath.ToSlash(rel)], sources[resolved] = digest, digest
+		}
+		if name != dep.PkgPath {
+			fmt.Fprintf(&config, "importmap %s=%s\n", name, dep.PkgPath)
+		}
+		fmt.Fprintf(&config, "packagefile %s=%s\n", dep.PkgPath, dep.ExportFile)
+		exports[dep.ExportFile] = digest
+		imports = append(imports, imported)
+	}
+	return imports, exports, config.String(), sources, nil
+}
diff --git a/cmd/plan9asmll/generated_header_bounds_test.go b/cmd/plan9asmll/generated_header_bounds_test.go
new file mode 100644
index 000000000..e7b659e0f
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_bounds_test.go
@@ -0,0 +1,105 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestGeneratedHeaderLargeMetadataAndIndependentConsumer(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, directory := generatedHeaderFixture(t, target)
+			file := filepath.Join(directory, "layout.go")
+			original, err := os.ReadFile(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var source strings.Builder
+			source.Write(original)
+			for index := 0; index < 5000; index++ {
+				fmt.Fprintf(&source, "const Value%d = %d\n", index, index)
+			}
+			if err := os.WriteFile(file, []byte(source.String()), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["layout.go"] = featureBytesSHA256([]byte(source.String()))
+			input.Headers["layout.go"] = source.String()
+			assembly := "#include \"go_asm.h\"\nTEXT ·Probe(SB),$0-0\nRET\n#ifdef const_Value4999\nDATA ·Late(SB)/8,$const_Value4999\nGLOBL ·Late(SB),8,$8\n#endif\n"
+			if err := os.WriteFile(filepath.Join(directory, input.AsmFiles[0]), []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources[input.AsmFiles[0]] = featureBytesSHA256([]byte(assembly))
+			input.Headers[input.AsmFiles[0]] = assembly
+			t.Chdir(directory)
+			parts := strings.Split(target, "/")
+			spec := targetSpec{Goos: parts[0], Goarch: parts[1]}
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			config := compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx}
+			metadata, err := queryGeneratedHeaders(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), config)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(metadata.Headers) != 1 || len(metadata.Headers[0].Definitions) <= 5000 || metadata.Headers[0].Definitions["const_Value4999"] != "4999" {
+				t.Fatal("actual compiler/selected-types query truncated large definitions")
+			}
+			encoded, err := json.Marshal(metadata)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var replay gotoolprofile.MetadataProof
+			if err := json.Unmarshal(encoded, &replay); err != nil {
+				t.Fatal(err)
+			}
+			if err := gotoolprofile.ValidateMetadata(input, &replay, nil); err != nil {
+				t.Fatal(err)
+			}
+			for name, mutation := range map[string]func(map[string]string){
+				"late value":    func(definitions map[string]string) { definitions["const_Value4999"] = "7" },
+				"late presence": func(definitions map[string]string) { delete(definitions, "const_Value4999") },
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.MetadataProof
+					if err := json.Unmarshal(encoded, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutation(changed.Headers[0].Definitions)
+					changed.Headers[0].DefinitionsSHA256 = gotoolprofile.HeaderDefinitionSHA256(changed.Headers[0].Definitions)
+					if err := gotoolprofile.ValidateGeneratedHeaderAgreement(input, metadata, &changed, nil); err == nil {
+						t.Fatal("self-consistent late definition mutation passed independent compiler agreement")
+					}
+				})
+			}
+			input.GeneratedHeaders = metadata
+			config, err = resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath = writeFeatureInput(t, input)
+			config.Context = ctx
+			report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("large generated header Go/CPP/LLVM object failed: %#v: %v", report, err)
+			}
+			proof := report.FeatureSelection
+			if proof.GeneratedHeaders == nil || len(proof.CPP) != 1 {
+				t.Fatal("large metadata was not independently consumed by an actual LLVM object")
+			}
+			if err := gotoolprofile.ValidateSelection(input, proof, nil, true); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/generated_header_consumer.go b/cmd/plan9asmll/generated_header_consumer.go
new file mode 100644
index 000000000..35c179dcc
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_consumer.go
@@ -0,0 +1,282 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// Retain the actual dependency/source/export snapshots through the final
+// LLVM object and marker checks, not only until -asmhdr returns. These private
+// physical paths never become portable report identities.
+func (consumer *featureConsumer) retainGeneratedGuard(files map[string]string) error {
+	if consumer.GeneratedGuard == nil {
+		consumer.GeneratedGuard = make(map[string]string)
+	}
+	for file, digest := range files {
+		if !filepath.IsAbs(file) || digest == "" {
+			return fmt.Errorf("generated-header dependency has no exact private source identity")
+		}
+		if previous := consumer.GeneratedGuard[file]; previous != "" && previous != digest {
+			return fmt.Errorf("generated-header dependency changed between compiler snapshots")
+		}
+		consumer.GeneratedGuard[file] = digest
+	}
+	return nil
+}
+
+func (consumer *featureConsumer) captureGeneratedMetadata(pkgs []*packages.Package, tags []string, output string) error {
+	dependencies, err := consumer.ordinaryDependencyProof()
+	if err != nil {
+		return err
+	}
+	actual := &gotoolprofile.MetadataProof{
+		Protocol: gotoolprofile.MetadataProtocol, ProfileID: consumer.ID,
+		CustomTags: append([]string(nil), tags...), Packages: consumer.Proof.Packages,
+		Dependencies: dependencies,
+	}
+	for index, pkg := range pkgs {
+		header, err := captureGeneratedHeader(consumer, pkg, actual.Packages[index], output)
+		if err != nil {
+			return err
+		}
+		actual.Headers = append(actual.Headers, header)
+		if err := loadLinknameSyntax(pkg); err != nil {
+			return err
+		}
+	}
+	if err := gotoolprofile.ValidateGeneratedHeaderAgreement(consumer.Input, consumer.Input.GeneratedHeaders, actual, tags); err != nil {
+		return err
+	}
+	consumer.Proof.GeneratedHeaders = actual
+	return consumer.verifySources()
+}
+
+// preprocessCPP uses the actual Go search order from the package working
+// directory, followed by the generated object directory and GOROOT includes.
+// Only active source-order includes enter this consumption graph. Raw branch
+// registration remains a separate producer obligation.
+func (consumer *featureConsumer) preprocessCPP(asm, packagePath string, defines []string) ([]byte, map[string]string, error) {
+	return consumer.preprocessCPPWithHeader(asm, packagePath, defines, func() ([]byte, error) {
+		return consumer.generatedCPPHeader(packagePath)
+	})
+}
+
+// Publication uses the same active include resolver's absence trace, not a
+// guessed path derived from the normalized fallback names or inactive branches.
+func (consumer *featureConsumer) preprocessCPPWithReadReport(asm, packagePath string, defines []string, report *plan9asm.GoAssemblySourceReadReport) ([]byte, map[string]string, error) {
+	return consumer.preprocessCPPSource(asm, packagePath, defines, func() ([]byte, error) {
+		return consumer.generatedCPPHeader(packagePath)
+	}, false, report)
+}
+
+func (consumer *featureConsumer) generatedCPPHeader(packagePath string) ([]byte, error) {
+	if consumer.Proof == nil || consumer.Proof.GeneratedHeaders == nil {
+		return nil, fmt.Errorf("active generated include lacks actual compiler metadata")
+	}
+	for _, header := range consumer.Proof.GeneratedHeaders.Headers {
+		if header.PackagePath == packagePath {
+			return gotoolprofile.CanonicalGeneratedHeader(header.Definitions)
+		}
+	}
+	return nil, fmt.Errorf("active generated include has no selected package origin")
+}
+
+// Only the actual selected caller inventory uses this source-only role. Its
+// companions need exact physical/original replay, not a final object receipt
+// for an assembly file outside this invocation's object request. Requested
+// files retain the ordinary strict object contract. No input/proof is mutated.
+func (consumer *featureConsumer) preprocessCallerCPP(asm, packagePath string, defines []string) ([]byte, map[string]string, error) {
+	assembly, err := consumer.moduleSourceName(asm)
+	if err != nil {
+		return nil, nil, err
+	}
+	sourceOnly := false
+	if consumer.Input.CPPOriginals != nil {
+		sourceOnly = true
+		for _, requested := range consumer.Input.AsmFiles {
+			if requested == assembly {
+				sourceOnly = false
+				break
+			}
+		}
+		if _, present := consumer.Input.CPPOriginals.Units[assembly]; !present {
+			return nil, nil, fmt.Errorf("caller companion lacks its complete original CPP unit")
+		}
+	}
+	return consumer.preprocessCPPSource(asm, packagePath, defines, func() ([]byte, error) {
+		return consumer.generatedCPPHeader(packagePath)
+	}, sourceOnly, nil)
+}
+
+// A mode caller supplies a separately validated native header. This shared
+// source-order search/read path never assigns that header an ordinary role.
+func (consumer *featureConsumer) preprocessCPPWithHeader(asm, packagePath string, defines []string, generatedHeader func() ([]byte, error)) ([]byte, map[string]string, error) {
+	return consumer.preprocessCPPSource(asm, packagePath, defines, generatedHeader, false, nil)
+}
+
+func (consumer *featureConsumer) preprocessCPPSource(asm, packagePath string, defines []string, generatedHeader func() ([]byte, error), sourceOnly bool, report *plan9asm.GoAssemblySourceReadReport) ([]byte, map[string]string, error) {
+	if err := gotoolprofile.ValidateCPPIncludeSearch(consumer.Input, nil); err != nil {
+		return nil, nil, err
+	}
+	for _, miss := range consumer.Input.CPPIncludeSearchMisses {
+		if err := gotoolprofile.VerifyCPPPackageSearchMiss(miss, consumer.Dir, consumer.Root); err != nil {
+			return nil, nil, err
+		}
+	}
+	inputs := make(map[string]string)
+	bytesRead := 0
+	read := func(file string, generated bool) (string, []byte, error) {
+		if consumer.Context != nil && consumer.Context.Err() != nil {
+			return "", nil, consumer.Context.Err()
+		}
+		if len(inputs) >= 512 {
+			return "", nil, fmt.Errorf("active CPP source inventory exceeds its bound")
+		}
+		if generated {
+			if generatedHeader == nil {
+				return "", nil, fmt.Errorf("active generated include lacks actual compiler metadata")
+			}
+			data, err := generatedHeader()
+			id := "generated/" + packagePath + "/go_asm.h"
+			if err == nil {
+				inputs[id] = featureBytesSHA256(data)
+			}
+			return id, data, err
+		}
+		name, sourceErr := consumer.moduleSourceName(file)
+		id, wanted := "module/"+name, consumer.Input.Sources[name]
+		if sourceErr != nil {
+			resolved, err := sourcepath.Resolve(file)
+			if err != nil {
+				return "", nil, err
+			}
+			// Both operands need the same physical root. The driver's GOROOT
+			// may retain an ancestor alias (including a cross-volume junction).
+			root, err := sourcepath.Resolve(consumer.Root)
+			if err != nil {
+				return "", nil, err
+			}
+			name, err = filepath.Rel(root, resolved)
+			name = filepath.ToSlash(name)
+			if err != nil || !gotoolprofile.CPPLocalSource(name) {
+				return "", nil, fmt.Errorf("active CPP include lacks original module/tool provenance")
+			}
+			if _, err := gotoolprofile.CPPRegularSource(consumer.Root, name); err != nil {
+				return "", nil, err
+			}
+			id, wanted = "tool/"+name, consumer.Input.ToolSources[name]
+		} else if _, err := gotoolprofile.CPPRegularSource(consumer.Dir, name); err != nil {
+			return "", nil, err
+		}
+		if wanted == "" {
+			return "", nil, fmt.Errorf("active CPP source has no original bound bytes: %s", id)
+		}
+		reader, err := os.Open(file)
+		if err != nil {
+			return "", nil, err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(reader, 64<<20+1))
+		closeErr := reader.Close()
+		bytesRead += len(data)
+		if readErr != nil || closeErr != nil || bytesRead > 64<<20 {
+			return "", nil, fmt.Errorf("active CPP source exceeds bounded read contract: %v (close: %v)", readErr, closeErr)
+		}
+		actual := featureBytesSHA256(data)
+		if wanted == "" || wanted != actual {
+			return "", nil, fmt.Errorf("active CPP source differs from exact registered bytes: %s", id)
+		}
+		inputs[id] = actual
+		return id, data, nil
+	}
+	file, source, err := read(asm, false)
+	if err != nil {
+		return nil, nil, err
+	}
+	assembly := strings.TrimPrefix(file, "module/")
+	var replay plan9asm.AssemblyCPPObservation
+	var replayInputs map[string]string
+	var required []gotoolprofile.CPPPackageSearchMiss
+	if consumer.Input.CPPOriginals != nil {
+		var header []byte
+		if len(consumer.Input.CPPOriginals.Units[assembly].GeneratedHeaders) != 0 && generatedHeader != nil {
+			header, err = generatedHeader()
+			if err != nil {
+				return nil, nil, err
+			}
+		}
+		replay, replayInputs, required, err = gotoolprofile.ReplayCPPOriginal(consumer.Input, assembly, packagePath, defines, header)
+		if err != nil {
+			return nil, nil, err
+		}
+		if sourceOnly {
+			for _, miss := range required {
+				if err := gotoolprofile.VerifyCPPPackageSearchMiss(miss, consumer.Dir, consumer.Root); err != nil {
+					return nil, nil, err
+				}
+			}
+		} else {
+			if err := gotoolprofile.ValidateCPPExpandedOperands(consumer.Input, assembly, required); err != nil {
+				return nil, nil, err
+			}
+		}
+	}
+	options := plan9asm.AssemblyPreprocessOptions{
+		FileName: file, Defines: defines,
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if name == "" || filepath.IsAbs(name) || strings.ContainsAny(name, "\\\x00") {
+				return "", nil, fmt.Errorf("unsafe active CPP include: %s", name)
+			}
+			if consumer.Input.CPPOriginals == nil {
+				if err := gotoolprofile.RequireCPPPackageSearchMiss(consumer.Input, assembly, parent, name); err != nil {
+					return "", nil, err
+				}
+			}
+			candidate, err := gotoolprofile.CPPPreferredPackageInclude(consumer.Dir, assembly, name)
+			if err != nil {
+				return "", nil, err
+			}
+			if _, err := os.Lstat(candidate); err == nil {
+				return read(candidate, false)
+			} else if !os.IsNotExist(err) {
+				return "", nil, err
+			}
+			if report != nil {
+				report.SearchMisses = append(report.SearchMisses, candidate)
+			}
+			if filepath.Clean(name) == "go_asm.h" {
+				return read("", true)
+			}
+			return read(filepath.Join(consumer.Root, "pkg/include", filepath.FromSlash(name)), false)
+		},
+	}
+	var observation plan9asm.AssemblyCPPObservation
+	if consumer.Input.CPPOriginals == nil {
+		// Historical inputs do not acquire the new observation budgets.
+		observation.Output, err = plan9asm.PreprocessAssemblySource(string(source), options)
+	} else {
+		observation, err = plan9asm.ObserveAssemblyCPP(string(source), options)
+	}
+	if err != nil {
+		return nil, nil, err
+	}
+	expanded := observation.Output
+	if consumer.Input.CPPOriginals != nil {
+		actualOperands, err := gotoolprofile.CPPExpandedOperands(consumer.Input, assembly, observation)
+		if err != nil || !reflect.DeepEqual(actualOperands, required) || expanded != replay.Output || !reflect.DeepEqual(inputs, replayInputs) {
+			return nil, nil, fmt.Errorf("actual physical CPP execution differs from complete original replay: %v", err)
+		}
+	}
+	if len(expanded) > 64<<20 {
+		return nil, nil, fmt.Errorf("active CPP expansion exceeds its bound")
+	}
+	return []byte(expanded), inputs, nil
+}
diff --git a/cmd/plan9asmll/generated_header_consumer_test.go b/cmd/plan9asmll/generated_header_consumer_test.go
new file mode 100644
index 000000000..24515e6e4
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_consumer_test.go
@@ -0,0 +1,384 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestGeneratedHeaderProductionConsumerRecompilesAndConsumesFullHeader(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	source := "#include \"go_asm.h\"\n#ifndef const_Fraction\n#include \"textflag.h\"\n#endif\n#ifdef const_Fraction\n#include \"missing-inactive.h\"\n#endif\nTEXT ·Probe(SB),NOSPLIT,$0-0\nMOVQ $const_Imported, AX\nMOVQ $Layout_Last, CX\nRET\n"
+	file := filepath.Join(dir, input.AsmFiles[0])
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources[input.AsmFiles[0]], input.Headers[input.AsmFiles[0]] = featureBytesSHA256([]byte(source)), source
+	root := runtime.GOROOT()
+	toolFile := "pkg/include/textflag.h"
+	data, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(toolFile)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ToolSources = map[string]string{toolFile: featureBytesSHA256(data)}
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	metadata, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.GeneratedHeaders = metadata
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+	if err != nil || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("real generated-header Go/CPP/LLVM consumption failed: %#v: %v", report, err)
+	}
+	proof := report.FeatureSelection
+	if proof.GeneratedHeaders == nil || len(proof.GeneratedHeaders.Headers) != 1 || proof.CPP[0].Inputs["generated/"+input.Module+"/go_asm.h"] == "" {
+		t.Fatalf("generated consumption lacks its independent actual compiler origin: %#v", proof)
+	}
+	if err := gotoolprofile.ValidateSelection(input, proof, nil, true); err != nil {
+		t.Fatal(err)
+	}
+	canonical, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+		"missing metadata": func(p *gotoolprofile.SelectionProof) { p.GeneratedHeaders = nil },
+		"changed value": func(p *gotoolprofile.SelectionProof) {
+			p.GeneratedHeaders.Headers[0].Definitions["const_Imported"] = "42"
+		},
+		"additional presence": func(p *gotoolprofile.SelectionProof) {
+			p.GeneratedHeaders.Headers[0].Definitions["const_Fraction"] = "1.25"
+		},
+		"missing presence": func(p *gotoolprofile.SelectionProof) {
+			delete(p.GeneratedHeaders.Headers[0].Definitions, "Layout_Last")
+		},
+		"import export": func(p *gotoolprofile.SelectionProof) {
+			p.GeneratedHeaders.Headers[0].Imports[0].ExportSHA256 = strings.Repeat("0", 64)
+		},
+		"generated bytes": func(p *gotoolprofile.SelectionProof) {
+			p.CPP[0].Inputs["generated/"+input.Module+"/go_asm.h"] = strings.Repeat("0", 64)
+		},
+		"source": func(p *gotoolprofile.SelectionProof) {
+			p.GeneratedHeaders.Headers[0].CompiledGoSHA256["layout.go"] = strings.Repeat("0", 64)
+		},
+		"profile": func(p *gotoolprofile.SelectionProof) { p.GeneratedHeaders.ProfileID = strings.Repeat("0", 64) },
+		"role":    func(p *gotoolprofile.SelectionProof) { p.GeneratedHeaders.Packages[0].SourceRole = "stdlib" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.SelectionProof
+			if err := json.Unmarshal(canonical, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if changed.GeneratedHeaders != nil {
+				changed.GeneratedHeaders.Headers[0].DefinitionsSHA256 = gotoolprofile.HeaderDefinitionSHA256(changed.GeneratedHeaders.Headers[0].Definitions)
+			}
+			if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+				t.Fatal("offline reader accepted mutated generated origin")
+			}
+		})
+	}
+	var formatted gotoolprofile.MetadataProof
+	metadataJSON, err := json.Marshal(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(metadataJSON, &formatted); err != nil {
+		t.Fatal(err)
+	}
+	formatted.Headers[0].HeaderSHA256 = strings.Repeat("0", 64)
+	formatted.Headers[0].ObjectSHA256 = strings.Repeat("1", 64)
+	if err := gotoolprofile.ValidateGeneratedHeaderAgreement(input, metadata, &formatted, nil); err != nil {
+		t.Fatalf("independently valid formatting-only compiler outputs disagreed: %v", err)
+	}
+}
+
+func TestGeneratedHeaderProductionConsumerFiveArchitectures(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/amd64", "linux/386", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			// cmd/go's earlier gensymabis invocation has an empty header;
+			// do not require layout presence during that distinct phase.
+			source := "#include \"go_asm.h\"\n#ifdef const_Fraction\n#include \"missing-inactive.h\"\n#endif\nTEXT ·Probe(SB),$0-0\nRET\n"
+			if err := os.WriteFile(filepath.Join(dir, input.AsmFiles[0]), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources[input.AsmFiles[0]], input.Headers[input.AsmFiles[0]] = featureBytesSHA256([]byte(source)), source
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			parts := strings.Split(target, "/")
+			spec := targetSpec{Goos: parts[0], Goarch: parts[1]}
+			input.GeneratedHeaders, err = queryGeneratedHeaders(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+			if err != nil {
+				t.Fatal(err)
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("full target header/object consumption failed: %#v: %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderProductionConsumerRejectsSelfConsistentProducerMutation(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	metadata, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	canonical, err := json.Marshal(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*gotoolprofile.MetadataProof){
+		"unused value":        func(p *gotoolprofile.MetadataProof) { p.Headers[0].Definitions["const_Huge"] = "7" },
+		"missing presence":    func(p *gotoolprofile.MetadataProof) { delete(p.Headers[0].Definitions, "Layout_First") },
+		"additional presence": func(p *gotoolprofile.MetadataProof) { p.Headers[0].Definitions["const_Fraction"] = "1.25" },
+		"dependency export":   func(p *gotoolprofile.MetadataProof) { p.Headers[0].Imports[0].ExportSHA256 = strings.Repeat("0", 64) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.MetadataProof
+			if err := json.Unmarshal(canonical, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			changed.Headers[0].DefinitionsSHA256 = gotoolprofile.HeaderDefinitionSHA256(changed.Headers[0].Definitions)
+			input.GeneratedHeaders = &changed
+			config := compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx}
+			_, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, "unused", config)
+			if err == nil || !strings.Contains(err.Error(), "independent generated-header definitions/imports differ") {
+				t.Fatalf("actual consumer accepted self-consistent altered metadata: %v", err)
+			}
+		})
+	}
+}
+
+func TestFeatureCPPSourceOrderUsesPackageCWDAndOnlyActiveIncludes(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	files := map[string]string{
+		"probe_amd64.s": "#include \"sub/outer.h\"\n#ifdef ABSENT\n#include \"missing-inactive.h\"\n#endif\nTEXT ·Probe(SB),$0-0\nMOVQ $CHOICE,AX\nRET\n",
+		"sub/outer.h":   "#include \"choice.h\"\n",
+		"choice.h":      "#define CHOICE 41\n",
+		"sub/choice.h":  "#define CHOICE 99\n",
+	}
+	for name, source := range files {
+		file := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".s") {
+			input.Headers[name] = source
+		}
+	}
+	input.Directories["."] = append(input.Directories["."], "choice.h", "sub")
+	input.Directories["sub"] = []string{"choice.h", "outer.h"}
+	sort.Strings(input.Directories["."])
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	canonicalDir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{Input: input, Context: ctx, Dir: canonicalDir, Root: runtime.GOROOT()}
+	asm := filepath.Join(dir, input.AsmFiles[0])
+	expanded, sources, err := consumer.preprocessCPP(asm, input.Module, nil)
+	if err != nil || !strings.Contains(string(expanded), "$41") || strings.Contains(string(expanded), "$99") || sources["module/choice.h"] == "" || sources["module/sub/choice.h"] != "" || len(sources) != 3 {
+		t.Fatalf("source-order CPP ignored Go package-CWD or consumed inactive include: %s %v: %v", expanded, sources, err)
+	}
+	// The same original source must also compile under the actual Go driver;
+	// this is not just agreement with a synthetic preprocessor model.
+	t.Chdir(dir)
+	_, err = queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(asm, []byte("#include \"missing-active.h\"\nTEXT ·Probe(SB),$0-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources[input.AsmFiles[0]] = featureBytesSHA256([]byte("#include \"missing-active.h\"\nTEXT ·Probe(SB),$0-0\nRET\n"))
+	if _, _, err := consumer.preprocessCPP(asm, input.Module, nil); err == nil {
+		t.Fatal("missing active include was silently consumed as an empty header")
+	}
+}
+
+func TestFeatureCPPRegisteredHeaderOutsidePackageDirectory(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	files := map[string]string{
+		"pkg/deep/probe_amd64.s": "#include \"../../shared/choice.h\"\nTEXT ·Probe(SB),$0-0\nMOVQ $CHOICE,AX\nRET\n",
+		"pkg/deep/decl.go":       "package deep\nfunc Probe()\n",
+		"shared/choice.h":        "#define CHOICE 41\n",
+	}
+	for name, source := range files {
+		file := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".s") || strings.HasSuffix(name, ".go") {
+			input.Headers[name] = source
+		}
+	}
+	input.Directories["."] = append(input.Directories["."], "pkg", "shared")
+	sort.Strings(input.Directories["."])
+	input.Directories["pkg"] = []string{"deep"}
+	input.Directories["pkg/deep"] = []string{"decl.go", "probe_amd64.s"}
+	// The producer inventories Go package/ancestor membership separately
+	// from exact CPP resources. This registered header is not a Go package.
+	input.AsmFiles = []string{"pkg/deep/probe_amd64.s"}
+	canonicalDir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer := &featureConsumer{Input: input, Context: ctx, Dir: canonicalDir, Root: runtime.GOROOT()}
+	if err := consumer.verifySources(); err != nil {
+		t.Fatal(err)
+	}
+	asm := filepath.Join(dir, input.AsmFiles[0])
+	expanded, sources, err := consumer.preprocessCPP(asm, input.Module+"/pkg/deep", nil)
+	if err != nil || !strings.Contains(string(expanded), "$41") || sources["module/shared/choice.h"] != input.Sources["shared/choice.h"] {
+		t.Fatalf("registered module header was confused with Go package membership: %s %v: %v", expanded, sources, err)
+	}
+	if _, err := consumer.sourceName(filepath.Join(dir, "shared/choice.h")); err == nil {
+		t.Fatal("CPP resource acquired an unproved Go package source role")
+	}
+	legacy, err := consumer.captureCPPInputs(asm)
+	if err != nil || legacy["module/shared/choice.h"] != input.Sources["shared/choice.h"] {
+		t.Fatalf("legacy CPP reader lost the same exact module origin: %v: %v", legacy, err)
+	}
+	// Missing registration and changed bytes must still fail CPP consumption.
+	digest := input.Sources["shared/choice.h"]
+	delete(input.Sources, "shared/choice.h")
+	if _, _, err := consumer.preprocessCPP(asm, input.Module+"/pkg/deep", nil); err == nil {
+		t.Fatal("unregistered header was accepted")
+	}
+	input.Sources["shared/choice.h"] = digest
+	if err := os.WriteFile(filepath.Join(dir, "shared/choice.h"), []byte("#define CHOICE 99\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := consumer.preprocessCPP(asm, input.Module+"/pkg/deep", nil); err == nil {
+		t.Fatal("changed header bytes were accepted")
+	}
+	if err := os.WriteFile(filepath.Join(dir, "shared/choice.h"), []byte(files["shared/choice.h"]), 0600); err != nil {
+		t.Fatal(err)
+	}
+	// Actual stock Go must accept the untouched selected package too.
+	t.Chdir(dir)
+	spec := targetSpec{Goos: "linux", Goarch: "amd64"}
+	input.GeneratedHeaders, err = queryGeneratedHeaders(spec, []string{"./pkg/deep"}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+	report, _, err := runOneTarget(spec, []string{"./pkg/deep"}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+	if err != nil || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("registered shared header lacked a real CPP/LLVM object: %#v: %v", report, err)
+	}
+	if len(report.FeatureSelection.CPP) != 1 || report.FeatureSelection.CPP[0].Inputs["module/shared/choice.h"] != digest {
+		t.Fatalf("LLVM consumer lost original shared-header bytes: %#v", report.FeatureSelection)
+	}
+	if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestGeneratedHeaderConsumerRetainsDependencyGuardUntilFinalObject(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	dep := ordinaryFixtureDependency(t, input, "example.invalid/external", map[string]string{
+		"layout.go": "package external\ntype Layout struct { Word uintptr }\nfunc Body() int { return 1 }\n",
+	})
+	dependency := filepath.Join(dep, "layout.go")
+	for name, source := range map[string]string{
+		"layout.go": "package header\nimport \"example.invalid/external\"\ntype Layout struct { Value external.Layout }\nfunc Probe()\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+	}
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	metadata, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.GeneratedHeaders = metadata
+	consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkgs, err := loadGeneratedHeaderPackages(consumer, []string{"."}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.capturePackages(pkgs); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.captureGeneratedMetadata(pkgs, nil, t.TempDir()); err != nil {
+		t.Fatal(err)
+	}
+	// The -asmhdr oracle has completed, but LLVM objects have not. An
+	// external dependency is outside the root module's source hash map.
+	if err := os.Chmod(dependency, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(dependency, []byte("package external\ntype Layout struct { Word uintptr }\nfunc Body() int { return 2 }\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err == nil || !strings.Contains(err.Error(), "generated-header dependency") {
+		t.Fatalf("dependency mutation between actual header and final object was accepted: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/generated_header_empty_test.go b/cmd/plan9asmll/generated_header_empty_test.go
new file mode 100644
index 000000000..428391768
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_empty_test.go
@@ -0,0 +1,62 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestGeneratedHeaderMacroOnlyActualEmptyObjectsAcrossTargets(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		for _, include := range []string{"go_asm.h", "./go_asm.h"} {
+			t.Run(target+"/"+include, func(t *testing.T) {
+				input, dir := generatedHeaderFixture(t, target)
+				source := "#include \"" + include + "\"\n#ifdef const_Imported\n#define GENERATED_LAYOUT(X) MOVQ X, AX\n#endif\n"
+				file := input.AsmFiles[0]
+				if err := os.WriteFile(filepath.Join(dir, file), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[file], input.Headers[file] = featureBytesSHA256([]byte(source)), source
+				t.Chdir(dir)
+				ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+				defer cancel()
+				spec, err := parseTargetSpec(target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				metadata, err := queryGeneratedHeaders(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(),
+					compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+				if err != nil {
+					t.Fatal(err)
+				}
+				input.GeneratedHeaders = metadata
+				config, err := resolveCompileConfig(true, "", true, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+				report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+				if err != nil || report.Success != 1 || report.Failed != 0 {
+					t.Fatalf("actual full generated header must reach native empty-object oracle and LLVM object: %#v: %v", report, err)
+				}
+				proof := report.FeatureSelection
+				if proof == nil || proof.GeneratedHeaders == nil || len(proof.CPP) != 1 || proof.CPP[0].Emission != "symbol_free" || proof.CPP[0].EmptyAssembly == nil ||
+					proof.CPP[0].Inputs["generated/"+input.Module+"/go_asm.h"] == "" {
+					t.Fatalf("macro-only generated scope disappeared or lost its actual compiler/assembler origin: %#v", proof)
+				}
+				if err := gotoolprofile.ValidateSelection(input, proof, nil, true); err != nil {
+					t.Fatal(err)
+				}
+				checkEmptyAssemblyProofMutants(t, input, proof)
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmll/generated_header_load_guard.go b/cmd/plan9asmll/generated_header_load_guard.go
new file mode 100644
index 000000000..4e15ef9fb
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_load_guard.go
@@ -0,0 +1,119 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// Machine paths stay in this private invocation guard. Portable metadata keeps
+// normalized package/module identities and dependency source/export digests.
+type generatedHeaderLoadGuard struct {
+	Packages map[string]string
+	Sources  map[string]string
+}
+
+type generatedHeaderLoadSelection struct {
+	Name            string
+	PackagePath     string
+	Module          *packages.Module
+	GoFiles         []string
+	CompiledGoFiles []string
+	OtherFiles      []string
+	EmbedFiles      []string
+	EmbedPatterns   []string
+	Imports         map[string]string
+}
+
+func captureGeneratedHeaderLoadGuard(ctx context.Context, pkgs []*packages.Package) (*generatedHeaderLoadGuard, error) {
+	return captureTypedSourceLoadGuard(ctx, pkgs, nil)
+}
+
+// The sole optional test identity is an explicitly requested same-package
+// variant. Generated-header callers continue rejecting every test role.
+func captureTypedSourceLoadGuard(ctx context.Context, pkgs []*packages.Package, allowedTests map[string]bool) (*generatedHeaderLoadGuard, error) {
+	return captureTypedSourceLoadGuardWithEmbeds(ctx, pkgs, allowedTests, nil)
+}
+
+func captureTypedSourceLoadGuardWithEmbeds(ctx context.Context, pkgs []*packages.Package, allowedTests map[string]bool, verifyEmbed func(*packages.Package) error) (*generatedHeaderLoadGuard, error) {
+	guard := &generatedHeaderLoadGuard{Packages: make(map[string]string), Sources: make(map[string]string)}
+	var captureErr error
+	packages.Visit(pkgs, func(pkg *packages.Package) bool {
+		if captureErr != nil {
+			return false
+		}
+		if ctx == nil || ctx.Err() != nil {
+			captureErr = fmt.Errorf("generated-header source guard requires a live candidate context")
+			return false
+		}
+		if len(pkg.Errors) != 0 {
+			var diagnostics []string
+			for _, err := range pkg.Errors {
+				diagnostics = append(diagnostics, err.Error())
+			}
+			captureErr = fmt.Errorf("actual generated-header Go source selection:\n%s", strings.Join(diagnostics, "\n"))
+			return false
+		}
+		if pkg.PkgPath == "unsafe" {
+			return false // Go's builtin singleton has no source or export file.
+		}
+		hasEmbed := len(pkg.EmbedFiles) != 0 || len(pkg.EmbedPatterns) != 0
+		if pkg.ID == "" || len(guard.Packages) >= 4096 || hasEmbed && verifyEmbed == nil || isTestVariantPackage(pkg) && !allowedTests[pkg.ID] {
+			captureErr = fmt.Errorf("generated-header query has an unbound embed/test role or exceeds its package bound: package_id=%q package_path=%q for_test=%q test_variant=%t allowed_test=%t embed_files=%d embed_patterns=%d used_packages=%d package_bound=4096",
+				pkg.ID, pkg.PkgPath, pkg.ForTest, isTestVariantPackage(pkg), allowedTests[pkg.ID],
+				len(pkg.EmbedFiles), len(pkg.EmbedPatterns), len(guard.Packages))
+			return false
+		}
+		if hasEmbed {
+			if err := verifyEmbed(pkg); err != nil {
+				captureErr = err
+				return false
+			}
+		}
+		canonical := func(files []string) []string {
+			result := append([]string(nil), files...)
+			sort.Strings(result)
+			return result
+		}
+		selection := generatedHeaderLoadSelection{
+			Name: pkg.Name, PackagePath: pkg.PkgPath, Module: pkg.Module,
+			GoFiles: canonical(pkg.GoFiles), CompiledGoFiles: canonical(pkg.CompiledGoFiles),
+			OtherFiles: canonical(pkg.OtherFiles), Imports: make(map[string]string),
+			EmbedFiles: canonical(pkg.EmbedFiles), EmbedPatterns: canonical(pkg.EmbedPatterns),
+		}
+		for name, dep := range pkg.Imports {
+			selection.Imports[name] = dep.PkgPath
+		}
+		data, err := json.Marshal(selection)
+		if err != nil {
+			captureErr = err
+			return false
+		}
+		guard.Packages[pkg.ID] = featureBytesSHA256(data)
+		for _, file := range append(append([]string(nil), pkg.CompiledGoFiles...), pkg.EmbedFiles...) {
+			if ctx.Err() != nil || len(guard.Sources) >= 32768 {
+				captureErr = fmt.Errorf("generated-header source guard exceeded its deadline/file bound")
+				return false
+			}
+			info, err := os.Stat(file)
+			if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+				captureErr = fmt.Errorf("generated-header dependency source must be a bounded regular file")
+				return false
+			}
+			digest, err := gotoolprofile.FileSHA256(file)
+			if err != nil {
+				captureErr = err
+				return false
+			}
+			guard.Sources[file] = digest
+		}
+		return true
+	}, nil)
+	return guard, captureErr
+}
diff --git a/cmd/plan9asmll/generated_header_load_guard_test.go b/cmd/plan9asmll/generated_header_load_guard_test.go
new file mode 100644
index 000000000..1050071d9
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_load_guard_test.go
@@ -0,0 +1,117 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func TestTypedSourceLoadGuardRejectsUnboundRolesWithPackageIdentity(t *testing.T) {
+	const path = "example.invalid/query/dep"
+	const variant = path + " [example.invalid/query.test]"
+	for _, tc := range []struct {
+		name         string
+		pkg          *packages.Package
+		allowedTests map[string]bool
+		want         []string
+	}{
+		{
+			name: "missing identity",
+			pkg:  &packages.Package{PkgPath: path},
+			want: []string{
+				`package_id=""`, `package_path="` + path + `"`, `for_test=""`,
+				"test_variant=false", "allowed_test=false", "embed_files=0", "embed_patterns=0",
+				"used_packages=0", "package_bound=4096",
+			},
+		},
+		{
+			name: "embedded files",
+			pkg:  &packages.Package{ID: path, PkgPath: path, EmbedFiles: []string{"private/file.bin"}},
+			want: []string{
+				`package_id="` + path + `"`, `package_path="` + path + `"`,
+				"test_variant=false", "embed_files=1", "embed_patterns=0", "used_packages=0",
+			},
+		},
+		{
+			name: "embedded patterns",
+			pkg:  &packages.Package{ID: path, PkgPath: path, EmbedPatterns: []string{"assets/*", "other/*"}},
+			want: []string{
+				`package_id="` + path + `"`, `package_path="` + path + `"`,
+				"embed_files=0", "embed_patterns=2", "used_packages=0",
+			},
+		},
+		{
+			name: "unregistered test variant",
+			pkg:  &packages.Package{ID: variant, PkgPath: path, ForTest: "example.invalid/query"},
+			want: []string{
+				`package_id="` + variant + `"`, `package_path="` + path + `"`,
+				`for_test="example.invalid/query"`, "test_variant=true", "allowed_test=false",
+				"embed_files=0", "embed_patterns=0", "used_packages=0",
+			},
+		},
+		{
+			name:         "registered test does not permit embed",
+			pkg:          &packages.Package{ID: variant, PkgPath: path, EmbedFiles: []string{"private/file.bin"}},
+			allowedTests: map[string]bool{variant: true},
+			want:         []string{"test_variant=true", "allowed_test=true", "embed_files=1"},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := captureTypedSourceLoadGuard(context.Background(), []*packages.Package{tc.pkg}, tc.allowedTests)
+			if err == nil {
+				t.Fatal("unbound source role was accepted")
+			}
+			for _, want := range tc.want {
+				if !strings.Contains(err.Error(), want) {
+					t.Errorf("diagnostic %q lacks %q", err, want)
+				}
+			}
+			if strings.Contains(err.Error(), "private/file.bin") || strings.Contains(err.Error(), "assets/*") {
+				t.Fatal("diagnostic leaked resource paths instead of compact role counts")
+			}
+		})
+	}
+}
+
+func TestTypedSourceLoadGuardPackageBoundDiagnostic(t *testing.T) {
+	pkgs := make([]*packages.Package, 4097)
+	for i := range pkgs {
+		path := fmt.Sprintf("example.invalid/query/dep%04d", i)
+		pkgs[i] = &packages.Package{ID: path, PkgPath: path}
+	}
+	guard, err := captureTypedSourceLoadGuard(context.Background(), pkgs, nil)
+	if err == nil || len(guard.Packages) != 4096 {
+		t.Fatalf("package bound changed: captured=%d, err=%v", len(guard.Packages), err)
+	}
+	for _, want := range []string{
+		`package_id="example.invalid/query/dep4096"`, `package_path="example.invalid/query/dep4096"`,
+		"used_packages=4096", "package_bound=4096", "test_variant=false", "embed_files=0", "embed_patterns=0",
+	} {
+		if !strings.Contains(err.Error(), want) {
+			t.Errorf("bound diagnostic %q lacks %q", err, want)
+		}
+	}
+}
+
+func TestTypedSourceLoadGuardOrdinaryAndExplicitTestRolesRemainAccepted(t *testing.T) {
+	const path = "example.invalid/query/dep"
+	const variant = path + " [example.invalid/query.test]"
+	for _, tc := range []struct {
+		name         string
+		pkg          *packages.Package
+		allowedTests map[string]bool
+	}{
+		{name: "ordinary", pkg: &packages.Package{ID: path, PkgPath: path}},
+		{name: "explicit same-package test", pkg: &packages.Package{ID: variant, PkgPath: path}, allowedTests: map[string]bool{variant: true}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			guard, err := captureTypedSourceLoadGuard(context.Background(), []*packages.Package{tc.pkg}, tc.allowedTests)
+			if err != nil || len(guard.Packages) != 1 {
+				t.Fatalf("previously permitted role rejected: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/generated_header_test.go b/cmd/plan9asmll/generated_header_test.go
new file mode 100644
index 000000000..b218a091c
--- /dev/null
+++ b/cmd/plan9asmll/generated_header_test.go
@@ -0,0 +1,332 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestGeneratedHeaderMetadataCLIUsesActualImportExports(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "linux/386", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			parts := strings.Split(target, "/")
+			report := filepath.Join(t.TempDir(), "metadata.json")
+			args := []string{
+				"-goos=" + parts[0], "-goarch=" + parts[1], "-patterns=.",
+				"-module-path=" + input.Module, "-asm-files=" + input.AsmFiles[0],
+				"-feature-profile=" + writeFeatureInput(t, input), "-feature-timeout=2m",
+				"-metadata-only", "-out=" + t.TempDir(), "-report=" + report,
+			}
+			encoded, err := json.Marshal(args)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded))
+			stdout, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+			if err != nil {
+				t.Fatalf("actual metadata-only CLI: %v\n%s\n%s", err, stdout, stderr)
+			}
+			data, err := os.ReadFile(report)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var result map[string]json.RawMessage
+			if err := json.Unmarshal(data, &result); err != nil {
+				t.Fatal(err)
+			}
+			for _, forbidden := range []string{"success", "total_asm", "outputs", "targets", "feature_selection"} {
+				if _, present := result[forbidden]; present {
+					t.Fatalf("metadata was reported as translation evidence: %s", data)
+				}
+			}
+			if len(result["headers"]) == 0 || len(result["packages"]) == 0 {
+				t.Fatalf("metadata lacks actual header and package selection: %s", data)
+			}
+			var proof gotoolprofile.MetadataProof
+			if err := json.Unmarshal(data, &proof); err != nil {
+				t.Fatal(err)
+			}
+			if err := gotoolprofile.ValidateMetadata(input, &proof, nil); err != nil {
+				t.Fatal(err)
+			}
+			if len(proof.Headers) != 1 || len(proof.Headers[0].Imports) != 1 || proof.Headers[0].Imports[0].ImportPath != input.Module+"/dep" {
+				t.Fatalf("actual compiler did not bind the imported package export: %s", data)
+			}
+			header := proof.Headers[0]
+			size, last := "56", "48"
+			if parts[1] == "386" || parts[1] == "arm" {
+				size, last = "28", "24"
+			}
+			if header.Definitions["const_Imported"] != "41" || header.Definitions["Layout__size"] != size || header.Definitions["Alias_Last"] != last || header.Definitions["const_Fraction"] != "" {
+				t.Fatalf("actual full definitions have the wrong import/target/presence semantics: %v", header.Definitions)
+			}
+			var translation gotoolprofile.SelectionProof
+			if err := json.Unmarshal(data, &translation); err != nil {
+				t.Fatal(err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, &translation, nil, true); err == nil {
+				t.Fatal("metadata-only output was accepted as an assembly translation PASS")
+			}
+			checkGeneratedHeaderMutations(t, input, data)
+		})
+	}
+}
+
+func TestGeneratedHeaderMetadataRejectsDependencyMutationDuringActualLoad(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	dep := ordinaryFixtureDependency(t, input, "example.invalid/external", map[string]string{
+		"layout.go": "package external\ntype Mixed struct { Word uintptr }\nfunc Body() int { return 1 }\n",
+	})
+	goFile := filepath.Join(dep, "layout.go")
+	for name, source := range map[string]string{
+		"layout.go": "package header\nimport \"example.invalid/external\"\ntype Layout struct { Value external.Mixed }\nfunc Probe()\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+	}
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = loadGeneratedHeaderPackagesWithLoader(consumer, []string{"."}, nil, func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+		if config.Mode&packages.NeedExportFile != 0 {
+			// Mutate only this test's external dependency, after source
+			// selection but before actual Go exports/type checking. Root
+			// pre-load hashes cannot cover a different dependency module.
+			if err := os.Chmod(goFile, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(goFile, []byte("package external\ntype Mixed struct { Word uintptr }\nfunc Body() int { return 2 }\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		return packages.Load(config, patterns...)
+	})
+	if err == nil || !strings.Contains(err.Error(), "dependency/source selection changed") {
+		t.Fatalf("metadata accepted a dependency changed during actual load: %v", err)
+	}
+}
+
+func checkGeneratedHeaderMutations(t *testing.T, input *featureInput, canonical []byte) {
+	t.Helper()
+	for name, mutate := range map[string]func(*gotoolprofile.MetadataProof){
+		"old selection protocol": func(p *gotoolprofile.MetadataProof) { p.Protocol = gotoolprofile.ConsumerProtocol },
+		"missing full header":    func(p *gotoolprofile.MetadataProof) { p.Headers = nil },
+		"target":                 func(p *gotoolprofile.MetadataProof) { p.Headers[0].Target = "linux/mips" },
+		"profile":                func(p *gotoolprofile.MetadataProof) { p.Headers[0].ProfileID = strings.Repeat("0", 64) },
+		"version":                func(p *gotoolprofile.MetadataProof) { p.Headers[0].GoVersion = "go1.26.1" },
+		"language version":       func(p *gotoolprofile.MetadataProof) { p.Headers[0].LanguageVersion = "go1.28" },
+		"compiler":               func(p *gotoolprofile.MetadataProof) { p.Headers[0].CompileToolSHA256 = strings.Repeat("0", 64) },
+		"missing object":         func(p *gotoolprofile.MetadataProof) { p.Headers[0].ObjectSHA256 = "" },
+		"missing header":         func(p *gotoolprofile.MetadataProof) { p.Headers[0].HeaderSHA256 = "" },
+		"definition value":       func(p *gotoolprofile.MetadataProof) { p.Headers[0].Definitions["const_Imported"] = "42" },
+		"definition presence":    func(p *gotoolprofile.MetadataProof) { p.Headers[0].Definitions["const_Fraction"] = "1.25" },
+		"definition omission":    func(p *gotoolprofile.MetadataProof) { delete(p.Headers[0].Definitions, "Layout__size") },
+		"selected source": func(p *gotoolprofile.MetadataProof) {
+			p.Headers[0].CompiledGoSHA256["layout.go"] = strings.Repeat("0", 64)
+		},
+		"package role":          func(p *gotoolprofile.MetadataProof) { p.Packages[0].SourceRole = "module" },
+		"module":                func(p *gotoolprofile.MetadataProof) { p.Packages[0].ModulePath += "/other" },
+		"module version":        func(p *gotoolprofile.MetadataProof) { p.Packages[0].ModuleVersion = "v1.2.3" },
+		"omitted import export": func(p *gotoolprofile.MetadataProof) { p.Headers[0].Imports[0].ExportSHA256 = "" },
+		"omitted exports":       func(p *gotoolprofile.MetadataProof) { p.Headers[0].Imports = nil },
+		"omitted ImportMap":     func(p *gotoolprofile.MetadataProof) { p.Headers[0].ImportMap = nil },
+		"different ImportMap":   func(p *gotoolprofile.MetadataProof) { p.Headers[0].ImportMap[input.Module+"/dep"] += "/other" },
+		"import source role":    func(p *gotoolprofile.MetadataProof) { p.Headers[0].Imports[0].SourceRole = "stdlib" },
+		"import source bytes": func(p *gotoolprofile.MetadataProof) {
+			p.Headers[0].Imports[0].GoSHA256["dep/layout.go"] = strings.Repeat("0", 64)
+		},
+		"duplicate export": func(p *gotoolprofile.MetadataProof) {
+			p.Headers[0].Imports = append(p.Headers[0].Imports, p.Headers[0].Imports[0])
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.MetadataProof
+			if err := json.Unmarshal(canonical, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := gotoolprofile.ValidateMetadata(input, &changed, nil); err == nil {
+				t.Fatal("changed generated-header/source/tool scope was accepted")
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderMetadataWithActualStandardLibraryImport(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	source := []byte("package header\nimport \"time\"\nconst StdSeconds = time.Second\ntype StdLayout struct { First byte; Value time.Time }\nfunc Probe()\n")
+	if err := os.WriteFile(filepath.Join(dir, "layout.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["layout.go"], input.Headers["layout.go"] = featureBytesSHA256(source), string(source)
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	proof, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	header := proof.Headers[0]
+	if header.ImportMap["time"] != "time" || len(header.Imports) != 1 || header.Imports[0].SourceRole != "stdlib" || header.Definitions["const_StdSeconds"] != "1000000000" || header.Definitions["StdLayout__size"] != "32" {
+		t.Fatalf("actual stdlib export/source/typed layout did not bind: %#v", header)
+	}
+}
+
+func TestGeneratedHeaderMetadataPreservesActualGoSourceDiagnostics(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	file := filepath.Join(dir, "layout.go")
+	source, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = append(source, []byte("var Broken = missingActualGoName\n")...)
+	if err := os.WriteFile(file, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["layout.go"] = featureBytesSHA256(source)
+	input.Headers["layout.go"] = string(source)
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	_, err = queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err == nil || !strings.Contains(err.Error(), "layout.go:") || !strings.Contains(err.Error(), "undefined: missingActualGoName") {
+		t.Fatalf("actual Go source rejection lost its concrete location/diagnostic: %v", err)
+	}
+}
+
+func TestGeneratedHeaderMetadataEmptyDefinitionsRoundtrip(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	source := []byte("package header\nfunc Probe()\n")
+	if err := os.WriteFile(filepath.Join(dir, "layout.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["layout.go"], input.Headers["layout.go"] = featureBytesSHA256(source), string(source)
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	proof, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var replay gotoolprofile.MetadataProof
+	if err := json.Unmarshal(data, &replay); err != nil {
+		t.Fatal(err)
+	}
+	if len(replay.Headers[0].Definitions) != 0 || replay.Headers[0].Definitions == nil || replay.Headers[0].ImportMap == nil {
+		t.Fatalf("actual empty complete definition inventory was lost: %s", data)
+	}
+	if err := gotoolprofile.ValidateMetadata(input, &replay, nil); err != nil {
+		t.Fatal(err)
+	}
+	replay.Headers[0].Definitions = nil
+	if err := gotoolprofile.ValidateMetadata(input, &replay, nil); err == nil {
+		t.Fatal("missing header inventory was accepted as an actual empty inventory")
+	}
+}
+
+func TestGeneratedHeaderMetadataCLIRejectsTranslationModes(t *testing.T) {
+	for _, mode := range []string{"missing-profile", "missing-report", "compile", "list-only", "all-targets", "limit=1"} {
+		t.Run(mode, func(t *testing.T) {
+			args := []string{"-metadata-only", "-feature-profile=must-not-be-read", "-report=" + filepath.Join(t.TempDir(), "metadata.json")}
+			switch mode {
+			case "missing-profile":
+				args = []string{"-metadata-only"}
+			case "missing-report":
+				args = args[:2]
+			default:
+				args = append(args, "-"+mode)
+			}
+			data, err := json.Marshal(args)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			_, stderr, err := gotoolprofile.RunBounded(ctx, t.TempDir(), append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(data)), os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+			if err == nil || !strings.Contains(string(stderr), "metadata-only requires one explicit ordinary profile") {
+				t.Fatalf("metadata mixed with translation/list/matrix behavior: %v\n%s", err, stderr)
+			}
+		})
+	}
+}
+
+func generatedHeaderFixture(t *testing.T, target string) (*featureInput, string) {
+	t.Helper()
+	dir := t.TempDir()
+	arch := strings.Split(target, "/")[1]
+	files := map[string]string{
+		"go.mod": "module example.invalid/header\n\ngo 1.24\n",
+		"layout.go": `package header
+import "example.invalid/header/dep"
+const Imported = dep.Value + 1
+const Huge = 1234567890123456789012345678901234567890
+const Quoted = "header\nvalue"
+const Fraction = 1.25
+type Layout struct { First byte; External dep.Mixed; Last uintptr }
+type Alias = Layout
+func Probe()
+`,
+		"dep/layout.go":        "package dep\nconst Value = 40\ntype Mixed struct { Small byte; Word uintptr; Bytes []byte }\n",
+		"probe_" + arch + ".s": "#include \"go_asm.h\"\nTEXT ·Probe(SB),$0-0\nRET\n",
+	}
+	input := &featureInput{
+		Protocol: featureInputProtocol, Module: "example.invalid/header", SourceRoot: dir,
+		Sources: make(map[string]string), Headers: make(map[string]string),
+		Directories: map[string][]string{".": {"dep", "go.mod", "layout.go", "probe_" + arch + ".s"}, "dep": {"layout.go"}},
+		AsmFiles:    []string{"probe_" + arch + ".s"},
+	}
+	for name, source := range files {
+		file := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".s") {
+			input.Headers[name] = source
+		}
+	}
+	for _, names := range input.Directories {
+		sort.Strings(names)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	input.Observed, err = gotoolprofile.Capture(ctx, binary, t.TempDir(), os.Environ(), target, nil, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.ID = gotoolprofile.ProfileID(input.Observed)
+	return input, dir
+}
diff --git a/cmd/plan9asmll/go.mod b/cmd/plan9asmll/go.mod
index 4b47a0b51..32ee7a61a 100644
--- a/cmd/plan9asmll/go.mod
+++ b/cmd/plan9asmll/go.mod
@@ -3,14 +3,16 @@ module github.com/xgo-dev/plan9asm/cmd/plan9asmll
 go 1.24.0
 
 require (
-	github.com/xgo-dev/llvm v0.9.9
+	github.com/xgo-dev/llvm v0.10.1
 	github.com/xgo-dev/plan9asm v0.0.0
 	golang.org/x/tools v0.42.0
 )
 
 require (
+	golang.org/x/arch v0.14.0 // indirect
 	golang.org/x/mod v0.33.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
+	golang.org/x/sys v0.41.0 // indirect
 )
 
 replace github.com/xgo-dev/plan9asm => ../..
diff --git a/cmd/plan9asmll/go.sum b/cmd/plan9asmll/go.sum
index 59f00a204..b9c5683e1 100644
--- a/cmd/plan9asmll/go.sum
+++ b/cmd/plan9asmll/go.sum
@@ -1,10 +1,14 @@
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/xgo-dev/llvm v0.9.9 h1:u4RZvy0vxu8nNt4oTrhttyMSyscYtmiy9geP+Kl/RYg=
-github.com/xgo-dev/llvm v0.9.9/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+github.com/xgo-dev/llvm v0.10.1 h1:GZeoapgSKC1Qgfy+xQmlIAKg0Suvrpg4U3Y3xticjqw=
+github.com/xgo-dev/llvm v0.10.1/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4=
+golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
 golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
 golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
 golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
+golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
 golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
diff --git a/cmd/plan9asmll/ifma_extraction_test.go b/cmd/plan9asmll/ifma_extraction_test.go
new file mode 100644
index 000000000..69dd9e809
--- /dev/null
+++ b/cmd/plan9asmll/ifma_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteIFMATypedFamily(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_lower_ifma.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_lower_ifma.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+				if _, present := supported[name]; !present {
+					t.Fatal("complete typed IFMA registry omitted a source name", arch, name)
+				}
+			}
+			for _, invalid := range []string{"VPMADD52", "VPMADD52LUQ.Z", "VPMADD52HUQ.BCST", "amd64IFMASpecs"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("IFMA extraction advertised a non-source spelling", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/inlane_permute_extraction_test.go b/cmd/plan9asmll/inlane_permute_extraction_test.go
new file mode 100644
index 000000000..e3b495b0e
--- /dev/null
+++ b/cmd/plan9asmll/inlane_permute_extraction_test.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsInLanePermuteIsolatedTypedTable(t *testing.T) {
+	const name = "amd64_permute_inlane_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for file, contents := range map[string][]byte{name: data, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(dir, file), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386", "arm", "arm64", "wasm"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"VPERMILPS", "VPERMILPD"} {
+			_, found := supported[op]
+			if found != (arch == "amd64" || arch == "386") {
+				t.Fatal("isolated typed in-lane family lost its architecture boundary", arch, op, found)
+			}
+		}
+		for _, invalid := range []string{"VPERMILPS.Z", "VPERMILPD.BCST", "x86InLanePermuteBits"} {
+			if _, found := supported[invalid]; found {
+				t.Fatal("isolated table advertised a suffix or Go identifier as an opcode", arch, invalid)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/instruction_diagnostics.go b/cmd/plan9asmll/instruction_diagnostics.go
new file mode 100644
index 000000000..3db62a632
--- /dev/null
+++ b/cmd/plan9asmll/instruction_diagnostics.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"sort"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Supplementary hints from this compilation's complete parsed input. They
+// neither grant support nor change a failed translation into a successful one.
+// In particular, a read/CPP/parse failure has no parsed instruction inventory.
+type instructionDiagnostics struct {
+	supported map[string]struct{}
+	ops       []string
+	hits      []unsupportedHit
+}
+
+func (d *instructionDiagnostics) collect(file *plan9asm.File) {
+	d.ops, d.hits = nil, nil
+	if file == nil || len(d.supported) == 0 {
+		return
+	}
+	seen := make(map[string]struct{})
+	for _, function := range file.Funcs {
+		for ordinal, instruction := range function.Instrs {
+			op := normalizeOp(string(instruction.Op))
+			if op == "" || op == "LABEL" || isDirective(op) {
+				continue
+			}
+			if _, supported := d.supported[op]; supported {
+				continue
+			}
+			seen[op] = struct{}{}
+			d.hits = append(d.hits, unsupportedHit{
+				Op: op, Source: instruction.Raw,
+				Function: function.Sym, Instruction: ordinal + 1,
+			})
+		}
+	}
+	for op := range seen {
+		d.ops = append(d.ops, op)
+	}
+	sort.Strings(d.ops)
+}
diff --git a/cmd/plan9asmll/instrumentation_asmdecl_alias_go127_test.go b/cmd/plan9asmll/instrumentation_asmdecl_alias_go127_test.go
new file mode 100644
index 000000000..df5109478
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_asmdecl_alias_go127_test.go
@@ -0,0 +1,196 @@
+//go:build go1.27
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationMetadataOrdinaryAsmdeclExactVersionReplacement(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	canonical := input.Original.Module
+	input.Original.Module, input.Original.Version = "example.invalid/modearchive", "v1.0.0"
+	invocation, env := instrumentationVersionedFixture(t, ctx, input)
+	input.Original.Module = canonical
+	caller := "module example.invalid/invocation\n\ngo 1.24\n\nrequire " + canonical + " v1.0.0\n" +
+		"replace " + canonical + " v1.0.0 => " + input.Original.SourceModule + " v1.0.0\n"
+	if err := os.WriteFile(filepath.Join(invocation, "go.mod"), []byte(caller), 0600); err != nil {
+		t.Fatal(err)
+	}
+	replanInstrumentationMetadataFixture(t, input)
+	// This actual local fileproxy fixture is not official-SumDB authentication.
+	// It exercises only the existing caller-authenticated version-replace role;
+	// production must still receive that independent original archive trust.
+	consumer, err := captureInstrumentationMetadata(ctx, input, invocation, env, t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := consumer.Metadata.Selection.Packages[0]
+	if selected.SourceRole != "version_replace" || selected.ModulePath != canonical ||
+		selected.SourceModule != input.Original.SourceModule || selected.ModuleVersion != "v1.0.0" ||
+		selected.SourceVersion != "v1.0.0" || consumer.Source.Dir == consumer.Source.WorkDir {
+		t.Fatalf("exact original archive namespace role was replaced or invented: %#v", selected)
+	}
+	if err := gotoolprofile.ValidatePackageModule(input.Original, selected); err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateInstrumentationMetadata(input, ".", nil, consumer.Metadata); err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	exports := map[string]string{selected.PackagePath: consumer.Metadata.OriginalExportSHA256}
+	for _, dependency := range consumer.Metadata.Dependencies {
+		exports[dependency.Source.PackagePath] = dependency.Source.ExportSHA256
+	}
+	modeEnv := featureEnvironment(env, input.Observation.Early.Environment)
+	for _, scenario := range []string{
+		"control", "missing replacement", "replacement path", "replacement version", "replacement main",
+		"nested replacement", "local replacement", "module root", "replacement root", "metadata bytes",
+		"namespace metadata missing", "metadata after tool", "missing export", "extra export",
+	} {
+		t.Run(scenario, func(t *testing.T) {
+			expected := make(map[string]string, len(exports))
+			for name, digest := range exports {
+				expected[name] = digest
+			}
+			if scenario == "missing export" {
+				delete(expected, canonical+"/dep")
+			}
+			if scenario == "extra export" {
+				expected[canonical+"/unselected"] = consumer.Metadata.OriginalExportSHA256
+			}
+			changed := false
+			var metadata string
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, name, args...)
+				if err != nil || len(stderr) != 0 {
+					return stdout, stderr, err
+				}
+				if len(args) > 1 && args[0] == "list" && args[1] == "-deps" {
+					decoder := json.NewDecoder(bytes.NewReader(stdout))
+					var result bytes.Buffer
+					for {
+						var pkg map[string]json.RawMessage
+						if err := decoder.Decode(&pkg); err == io.EOF {
+							break
+						} else if err != nil {
+							t.Fatal(err)
+						}
+						var path string
+						if err := json.Unmarshal(pkg["ImportPath"], &path); err != nil {
+							t.Fatal(err)
+						}
+						if path == canonical {
+							var module, replacement map[string]json.RawMessage
+							if err := json.Unmarshal(pkg["Module"], &module); err != nil {
+								t.Fatal(err)
+							}
+							if err := json.Unmarshal(module["Replace"], &replacement); err != nil {
+								t.Fatal(err)
+							}
+							if err := json.Unmarshal(replacement["GoMod"], &metadata); err != nil {
+								t.Fatal(err)
+							}
+							switch scenario {
+							case "missing replacement":
+								delete(module, "Replace")
+							case "replacement path":
+								replacement["Path"] = json.RawMessage(`"example.invalid/other"`)
+							case "replacement version":
+								replacement["Version"] = json.RawMessage(`"v1.0.1"`)
+							case "replacement main":
+								replacement["Main"] = json.RawMessage(`true`)
+							case "nested replacement":
+								replacement["Replace"] = json.RawMessage(`{"Path":"example.invalid/nested","Version":"v1.0.0"}`)
+							case "local replacement":
+								delete(replacement, "Version")
+							case "module root", "replacement root":
+								root, err := json.Marshal(t.TempDir())
+								if err != nil {
+									t.Fatal(err)
+								}
+								if scenario == "module root" {
+									module["Dir"] = root
+								} else {
+									replacement["Dir"] = root
+								}
+							case "namespace metadata missing":
+								delete(module, "GoMod")
+							case "metadata bytes":
+								file := filepath.Join(t.TempDir(), "go.mod")
+								if err := os.WriteFile(file, []byte("module example.invalid/changed\n"), 0600); err != nil {
+									t.Fatal(err)
+								}
+								replacement["GoMod"], err = json.Marshal(file)
+								if err != nil {
+									t.Fatal(err)
+								}
+							}
+							if scenario != "missing replacement" {
+								module["Replace"], err = json.Marshal(replacement)
+								if err != nil {
+									t.Fatal(err)
+								}
+							}
+							pkg["Module"], err = json.Marshal(module)
+							if err != nil {
+								t.Fatal(err)
+							}
+							changed = true
+						}
+						if err := json.NewEncoder(&result).Encode(pkg); err != nil {
+							t.Fatal(err)
+						}
+					}
+					return result.Bytes(), stderr, err
+				}
+				if scenario == "metadata after tool" && reflect.DeepEqual(args, []string{"tool", "vet", "-asmdecl", "ordinary.cfg"}) {
+					data, err := os.ReadFile(metadata)
+					if err != nil {
+						t.Fatal(err)
+					}
+					t.Cleanup(func() {
+						if err := os.WriteFile(metadata, data, 0600); err != nil {
+							t.Errorf("restore owned fixture metadata: %v", err)
+						}
+					})
+					if err := os.WriteFile(metadata, append(data, []byte("// late mutation\n")...), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return stdout, stderr, err
+			}
+			err := gotoolprofile.RunInstrumentationOrdinaryAsmdecl(ctx, binary, invocation, modeEnv, input.Original,
+				input.Plan, &selected, expected, run)
+			if !changed {
+				t.Fatalf("did not consume fresh actual Go ordinary JSON: %v", err)
+			}
+			if scenario == "control" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil {
+				t.Fatal("changed source/replacement/export binding was accepted")
+			}
+		})
+	}
+	if _, err := gotoolprofile.CaptureInstrumentationOriginalExport(ctx, binary, invocation, env, input.Original,
+		input.Sources, input.Observation, input.Plan, gotoolprofile.RunBounded); err == nil || !strings.Contains(err.Error(), "dependency") {
+		t.Fatalf("dependency-free OriginalExport foundation was broadened: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_asmdecl_scope_go127_test.go b/cmd/plan9asmll/instrumentation_asmdecl_scope_go127_test.go
new file mode 100644
index 000000000..d6692fed9
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_asmdecl_scope_go127_test.go
@@ -0,0 +1,89 @@
+//go:build go1.27
+
+package main
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// The missing dependency is an explicit local replacement, so this genuine
+// cmd/go test-graph failure performs no network fetch. Ordinary compilation
+// and its declaration checks have a separate actual source denominator.
+func TestInstrumentationMetadataAsmdeclKeepsOrdinaryAndTestSourceScopes(t *testing.T) {
+	for _, badAssembly := range []bool{false, true} {
+		t.Run(map[bool]string{false: "ordinary valid", true: "ordinary declaration invalid"}[badAssembly], func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+			dir := input.Original.SourceRoot
+			mod, err := os.ReadFile(filepath.Join(dir, "go.mod"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			files := map[string]string{
+				"go.mod": string(mod) + "\nrequire example.invalid/testonly v0.0.0\n" +
+					"replace example.invalid/testonly => ./test-dependency-missing\n",
+				"poison_test.go": "package modeheader\nimport _ \"example.invalid/testonly\"\n",
+			}
+			if badAssembly {
+				files["probe_arm64.s"] = strings.Replace(input.Original.Headers["probe_arm64.s"],
+					"ret+0(FP)", "misspelled+0(FP)", 1)
+			}
+			for name, source := range files {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Original.Sources[name] = featureBytesSHA256([]byte(source))
+				if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".s") {
+					input.Original.Headers[name] = source
+				}
+			}
+			entries, err := os.ReadDir(dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.Original.Directories["."] = nil
+			for _, entry := range entries {
+				input.Original.Directories["."] = append(input.Original.Directories["."], entry.Name())
+			}
+			sort.Strings(input.Original.Directories["."])
+			replanInstrumentationMetadataFixture(t, input)
+
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			env := featureEnvironment(os.Environ(), input.Observation.Early.Environment)
+			args := []string{"vet", "-asmdecl", "-race", "-tests=true", "-mod=readonly", "-p=1", input.Plan.PackagePath}
+			_, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, binary, args...)
+			if err == nil || !strings.Contains(string(stderr), "test-dependency-missing") {
+				t.Fatalf("actual test-source failure was not reproduced: %v; %s", err, stderr)
+			}
+
+			consumer, err := captureInstrumentationMetadata(ctx, input, dir, os.Environ(), t.TempDir(), packages.Load)
+			if badAssembly {
+				if err == nil || !strings.Contains(err.Error(), "misspelled") || !strings.Contains(err.Error(), "asmdecl") {
+					t.Fatalf("ordinary declaration error lost its own source scope: %v", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("unselected test dependency blocked valid ordinary metadata: %v", err)
+			}
+			if !reflect.DeepEqual(consumer.Metadata.Selection.Packages[0].GoFiles, []string{"base.go", "mode.go"}) ||
+				!reflect.DeepEqual(consumer.Metadata.VetArgs, []string{"tool", "vet", "-asmdecl", "ordinary.cfg"}) {
+				t.Fatal("ordinary compilation/asmdecl changed or lost its explicit source denominator")
+			}
+			if err := gotoolprofile.ValidateInstrumentationMetadata(input, ".", nil, consumer.Metadata); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_cli.go b/cmd/plan9asmll/instrumentation_cli.go
new file mode 100644
index 000000000..840e74bc7
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_cli.go
@@ -0,0 +1,118 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// The explicit mode entry has separate input/result protocols. It never
+// creates an ordinary feature selection, source exclusion or runtime outcome.
+type instrumentationCLIOptions struct {
+	Profile, Directory, Metadata, OrdinaryProfile string
+	Targets                                       []targetSpec
+	Patterns, Tags, AsmFiles                      []string
+	Module, Output, LLC                           string
+	MetadataOnly, SignatureQuery                  bool
+	Compile, KeepObject                           bool
+	OptLevel, Limit                               int
+	AllTargets, ExplicitTargets, ListOnly         bool
+	StrictLoad, KeepGoing, Annotate               bool
+}
+
+func requestedInstrumentationCLI(flags *flag.FlagSet) bool {
+	requested := false
+	flags.Visit(func(option *flag.Flag) {
+		switch option.Name {
+		case "instrumentation-profile", "instrumentation-package-dir", "instrumentation-metadata":
+			requested = true
+		}
+	})
+	return requested
+}
+
+func validateInstrumentationCLIOptions(options instrumentationCLIOptions) error {
+	if options.Profile == "" || options.OrdinaryProfile != "" || options.Output == "" || len(options.Targets) != 1 ||
+		len(options.Patterns) != 1 || options.Module == "" || len(options.AsmFiles) == 0 ||
+		options.AllTargets || options.ExplicitTargets || options.ListOnly || options.SignatureQuery || options.Limit != 0 ||
+		!options.StrictLoad || options.KeepGoing || options.Annotate || options.LLC != "" {
+		return fmt.Errorf("mode entry requires one exact original target/package/module/file scope, not ordinary/query/list/matrix evidence")
+	}
+	if options.MetadataOnly {
+		if options.Metadata != "" || options.Compile || options.KeepObject {
+			return fmt.Errorf("mode metadata query cannot emit or borrow assembly objects")
+		}
+	} else if options.Metadata == "" || !options.Compile || !options.KeepObject || options.OptLevel != 0 {
+		return fmt.Errorf("mode objects require separate actual metadata and complete LLVM22 O0 objects")
+	}
+	return nil
+}
+
+func runInstrumentationCLI(ctx context.Context, options instrumentationCLIOptions) (*gotoolprofile.InstrumentationInvocationProof, error) {
+	if ctx == nil || ctx.Err() != nil {
+		return nil, fmt.Errorf("mode entry requires a live bounded context")
+	}
+	if err := validateInstrumentationCLIOptions(options); err != nil {
+		return nil, err
+	}
+	reader, err := os.Open(options.Profile)
+	if err != nil {
+		return nil, err
+	}
+	input, readErr := gotoolprofile.DecodeInstrumentationConsumerInput(reader, options.Directory, options.Tags)
+	if err := errors.Join(readErr, reader.Close()); err != nil {
+		return nil, err
+	}
+	plan := input.Plan
+	if options.Targets[0].Goos+"/"+options.Targets[0].Goarch != plan.Target || options.Patterns[0] != plan.PackagePath ||
+		options.Module != input.Original.Module || !equalInstrumentationCLIStrings(options.AsmFiles, plan.SFiles) ||
+		!equalInstrumentationCLIStrings(options.Tags, plan.CustomTags) {
+		return nil, fmt.Errorf("mode invocation changed its actual original target/package/module/files/custom tags")
+	}
+	invocation, err := os.Getwd()
+	if err != nil {
+		return nil, err
+	}
+	output, err := filepath.Abs(options.Output)
+	if err != nil {
+		return nil, err
+	}
+	if options.MetadataOnly {
+		consumer, err := captureInstrumentationMetadata(ctx, input, invocation, os.Environ(), output, packages.Load)
+		if err != nil {
+			return nil, err
+		}
+		return gotoolprofile.NewInstrumentationInvocation(input, gotoolprofile.InstrumentationMetadataQuery, consumer.Metadata, nil, nil)
+	}
+	reader, err = os.Open(options.Metadata)
+	if err != nil {
+		return nil, err
+	}
+	producer, readErr := gotoolprofile.DecodeInstrumentationInvocation(reader, input, gotoolprofile.InstrumentationMetadataQuery, nil, nil)
+	if err := errors.Join(readErr, reader.Close()); err != nil {
+		return nil, err
+	}
+	proof, llvm, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, invocation, os.Environ(), output)
+	if err != nil {
+		return nil, err
+	}
+	return gotoolprofile.NewInstrumentationInvocation(input, gotoolprofile.InstrumentationObjectCompile, producer.Metadata, proof, llvm)
+}
+
+func equalInstrumentationCLIStrings(left, right []string) bool {
+	if len(left) != len(right) {
+		return false
+	}
+	for index := range left {
+		if left[index] != right[index] {
+			return false
+		}
+	}
+	return true
+}
diff --git a/cmd/plan9asmll/instrumentation_cli_go127_test.go b/cmd/plan9asmll/instrumentation_cli_go127_test.go
new file mode 100644
index 000000000..6feeb7bb3
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_cli_go127_test.go
@@ -0,0 +1,348 @@
+//go:build go1.27
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationMetadataPrettyJSONLayoutAgreesWithFreshActualSource(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.MarshalIndent(producer.Metadata, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	reported, err := gotoolprofile.DecodeInstrumentationMetadata(bytes.NewReader(data), input, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalize := func(proof *gotoolprofile.InstrumentationMetadataProof) gotoolprofile.InstrumentationMetadataProof {
+		copy := *proof
+		copy.Headers = append([]gotoolprofile.InstrumentationGeneratedHeader(nil), proof.Headers...)
+		for index := range copy.Headers {
+			copy.Headers[index].Header.HeaderSHA256, copy.Headers[index].Header.ObjectSHA256 = "", ""
+		}
+		copy.Declarations = append([]gotoolprofile.InstrumentationDeclarationProof(nil), proof.Declarations...)
+		for index := range copy.Declarations {
+			var compact bytes.Buffer
+			if err := json.Compact(&compact, copy.Declarations[index].Layout); err != nil {
+				t.Fatal(err)
+			}
+			copy.Declarations[index].Layout = compact.Bytes()
+		}
+		return copy
+	}
+	if !reflect.DeepEqual(normalize(reported), normalize(actual.Metadata)) {
+		t.Fatal("actual metadata differs in more than report layout whitespace and the separately bound native header object hashes")
+	}
+	if bytes.Equal(reported.Declarations[0].Layout, actual.Metadata.Declarations[0].Layout) {
+		t.Fatal("fixture did not reproduce pretty-printed RawMessage versus actual compact layout")
+	}
+	t.Log("exact difference: Declaration.Layout JSON whitespace; all other mode/source/selection/export/header/type/ABI fields unchanged")
+	if err := gotoolprofile.ValidateInstrumentationMetadataAgreement(input, reported, actual.Metadata, ".", nil); err != nil {
+		t.Fatalf("strictly decoded pretty layout rejected independently recaptured actual source: %v", err)
+	}
+}
+
+func TestInstrumentationCLIActualMetadataAndObjectInvocation(t *testing.T) {
+	for _, config := range []struct {
+		target string
+		mode   gotoolprofile.InstrumentationMode
+		cgo    string
+	}{
+		{"darwin/arm64", gotoolprofile.InstrumentationRace, "0"},
+		{"darwin/arm64", gotoolprofile.InstrumentationRace, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationMSan, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationASan, "1"},
+	} {
+		t.Run(config.target+"/"+string(config.mode)+"/cgo"+config.cgo, func(t *testing.T) {
+			testInstrumentationCLIActualInvocation(t, config.target, config.mode, config.cgo)
+		})
+	}
+}
+
+func testInstrumentationCLIActualInvocation(t *testing.T, target string, mode gotoolprofile.InstrumentationMode, cgo string) {
+	t.Helper()
+	input, ctx := instrumentationMetadataFixture(t, target, mode, cgo)
+	output := instrumentationObjectFixtureOutput(t, input)
+	profile := filepath.Join(output, "input.json")
+	data, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(profile, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	binary := filepath.Join(output, gotoolchain.HostExecutable("plan9asmll"))
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, ".", os.Environ(), goBinary, "build", "-p=1", "-o", binary, ".")
+	if err != nil {
+		t.Fatalf("build actual current CLI: %v\n%s\n%s", err, stdout, stderr)
+	}
+	goos, goarch, _ := strings.Cut(target, "/")
+	args := []string{
+		"-instrumentation-profile=" + profile,
+		"-instrumentation-package-dir=.",
+		"-goos=" + goos, "-goarch=" + goarch,
+		"-patterns=" + input.Plan.PackagePath,
+		"-module-path=" + input.Original.Module,
+		"-asm-files=" + strings.Join(input.Plan.SFiles, ","),
+		"-strict-load=true", "-keep-going=false",
+		"-out=" + filepath.Join(output, "metadata"),
+		"-report=" + filepath.Join(output, "metadata.json"),
+		"-metadata-only",
+	}
+	stdout, stderr, err = gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, os.Environ(), binary, args...)
+	if err != nil {
+		t.Fatalf("actual mode metadata CLI: %v\n%s\n%s", err, stdout, stderr)
+	}
+	file, err := os.Open(filepath.Join(output, "metadata.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	producer, decodeErr := gotoolprofile.DecodeInstrumentationInvocation(file, input, gotoolprofile.InstrumentationMetadataQuery, nil, nil)
+	closeErr := file.Close()
+	if decodeErr != nil || closeErr != nil {
+		t.Fatalf("independent metadata reader: %v (close: %v)", decodeErr, closeErr)
+	}
+	args = args[:len(args)-3]
+	args = append(args,
+		"-out="+filepath.Join(output, "objects"),
+		"-report="+filepath.Join(output, "objects.json"),
+		"-instrumentation-metadata="+filepath.Join(output, "metadata.json"),
+		"-compile", "-keep-obj", "-llc-opt-level=0")
+	stdout, stderr, err = gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, os.Environ(), binary, args...)
+	if err != nil {
+		t.Fatalf("actual mode CPP/LLVM CLI: %v\n%s\n%s", err, stdout, stderr)
+	}
+	file, err = os.Open(filepath.Join(output, "objects.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	version, stderr, err := gotoolprofile.RunBounded(ctx, ".", os.Environ(), config.LLC, "--version")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("independent actual LLVM22 version: %v; %s", err, stderr)
+	}
+	toolSHA, err := gotoolprofile.FileSHA256(config.LLC)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tools := &gotoolprofile.InstrumentationLLVMTool{Version: string(version), SHA256: toolSHA, Triple: targetTriple(goos, goarch)}
+	encoded, err := os.ReadFile(filepath.Join(output, "objects.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var serialized gotoolprofile.InstrumentationInvocationProof
+	if err := json.Unmarshal(encoded, &serialized); err != nil {
+		t.Fatal(err)
+	}
+	for _, item := range serialized.Consumption.Files {
+		for _, declaration := range item.Declarations {
+			for _, expected := range serialized.Consumption.Metadata.Declarations {
+				if expected.Symbol != declaration.Symbol {
+					continue
+				}
+				compact := func(value gotoolprofile.InstrumentationDeclarationProof) gotoolprofile.InstrumentationDeclarationProof {
+					var layout bytes.Buffer
+					if err := json.Compact(&layout, value.Layout); err != nil {
+						t.Fatal(err)
+					}
+					value.Layout = layout.Bytes()
+					return value
+				}
+				if !reflect.DeepEqual(compact(expected), compact(declaration)) {
+					t.Fatal("serialized LLVM declaration differs from actual source metadata in more than layout whitespace")
+				}
+				if bytes.Equal(expected.Layout, declaration.Layout) {
+					t.Fatal("fixture lacks nested declaration RawMessage indentation difference")
+				}
+				t.Log("exact nested declaration difference: Layout JSON whitespace; symbol/file/AST/type/full ABI tokens unchanged")
+			}
+		}
+	}
+	invocation, decodeErr := gotoolprofile.DecodeInstrumentationInvocation(file, input, gotoolprofile.InstrumentationObjectCompile, producer.Metadata, tools)
+	closeErr = file.Close()
+	if decodeErr != nil || closeErr != nil {
+		t.Fatalf("independent actual object reader: %v (close: %v)", decodeErr, closeErr)
+	}
+	proof := invocation.Consumption
+	if proof.Status != "llvm_objects_only" || len(proof.Files) != 1 || producer.ObjectCount != 0 || invocation.ObjectCount != 1 {
+		t.Fatal("CLI omitted its actual original selected assembly or claimed runtime")
+	}
+	for _, indent := range []string{"    ", "\t"} {
+		var reformatted bytes.Buffer
+		if err := json.Indent(&reformatted, encoded, "", indent); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := gotoolprofile.DecodeInstrumentationInvocation(&reformatted, input, gotoolprofile.InstrumentationObjectCompile, producer.Metadata, tools); err != nil {
+			t.Fatalf("valid whole-report formatting rejected independent source/ABI identity: %v", err)
+		}
+		queryJSON, err := json.MarshalIndent(producer, "", indent)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := gotoolprofile.DecodeInstrumentationInvocation(bytes.NewReader(queryJSON), input, gotoolprofile.InstrumentationMetadataQuery, producer.Metadata, nil); err != nil {
+			t.Fatalf("valid query formatting rejected independent source/ABI identity: %v", err)
+		}
+	}
+	for _, item := range proof.Files {
+		physical := filepath.Join(output, "objects", item.Output.Part)
+		irSHA, err := gotoolprofile.FileSHA256(physical)
+		if err != nil || irSHA != item.Output.IR {
+			t.Fatalf("actual CLI IR changed or is absent: %v", err)
+		}
+		objectSHA, err := gotoolprofile.FileSHA256(strings.TrimSuffix(physical, ".ll") + ".o")
+		if err != nil || objectSHA != item.Output.Object {
+			t.Fatalf("actual CLI LLVM object changed or is absent: %v", err)
+		}
+	}
+	testInstrumentationInvocationMutations(t, input, producer.Metadata, tools, encoded)
+	for name, change := range map[string]func([]string) []string{
+		"ordinary and mode paired": func(args []string) []string { return append(args, "-feature-profile="+profile) },
+		"ordinary query paired":    func(args []string) []string { return append(args, "-signature-source-query") },
+		"mode context deleted":     func(args []string) []string { return args[1:] },
+		"both context and metadata deleted": func(args []string) []string {
+			var result []string
+			for _, arg := range args {
+				if !strings.HasPrefix(arg, "-instrumentation-profile=") && !strings.HasPrefix(arg, "-instrumentation-metadata=") {
+					result = append(result, arg)
+				}
+			}
+			return result
+		},
+		"producer metadata deleted": func(args []string) []string {
+			var result []string
+			for _, arg := range args {
+				if !strings.HasPrefix(arg, "-instrumentation-metadata=") {
+					result = append(result, arg)
+				}
+			}
+			return result
+		},
+		"changed actual target": func(args []string) []string { return append(args, "-goos=windows") },
+		"changed package path":  func(args []string) []string { return append(args, "-patterns=example.invalid/foreign") },
+		"unknown file":          func(args []string) []string { return append(args, "-asm-files=unknown_arm64.s") },
+		"invented mode tags":    func(args []string) []string { return append(args, "-tags=race") },
+		"borrow baseline CGO":   func(args []string) []string { return append(args, "-tags=cgo") },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := change(append([]string(nil), args...))
+			// Never permit a failed child to leave the valid previous report
+			// or object directory available as apparent negative-run evidence.
+			changed = append(changed, "-report="+filepath.Join(t.TempDir(), "rejected.json"), "-out="+t.TempDir())
+			stdout, stderr, err := gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, os.Environ(), binary, changed...)
+			if err == nil {
+				t.Fatalf("mode CLI accepted changed/deleted/ordinary scope: %s\n%s", stdout, stderr)
+			}
+		})
+	}
+}
+
+func testInstrumentationInvocationMutations(t *testing.T, input *gotoolprofile.InstrumentationConsumerInput, producer *gotoolprofile.InstrumentationMetadataProof, tools *gotoolprofile.InstrumentationLLVMTool, original []byte) {
+	t.Helper()
+	for name, change := range map[string]func(*gotoolprofile.InstrumentationInvocationProof){
+		"ordinary wrapper": func(p *gotoolprofile.InstrumentationInvocationProof) { p.Protocol = gotoolprofile.ConsumerProtocol },
+		"missing wrapper":  func(p *gotoolprofile.InstrumentationInvocationProof) { p.Protocol = "" },
+		"borrow query": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.Phase = gotoolprofile.InstrumentationMetadataQuery
+		},
+		"paired mode deletion": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.ModeProfileID = ""
+			p.Consumption.ModeProfileID = ""
+		},
+		"paired metadata deletion": func(p *gotoolprofile.InstrumentationInvocationProof) { p.Metadata = nil; p.Consumption.Metadata = nil },
+		"paired source deletion": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.InputSHA256 = ""
+			p.Consumption.InputSHA256 = ""
+		},
+		"missing complete files": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.AsmFiles = nil
+			p.Consumption.Files = nil
+			p.ObjectCount = 0
+		},
+		"changed exact package":  func(p *gotoolprofile.InstrumentationInvocationProof) { p.PackagePath += "/foreign" },
+		"changed exact target":   func(p *gotoolprofile.InstrumentationInvocationProof) { p.Target = "windows/arm64" },
+		"invented mode tag":      func(p *gotoolprofile.InstrumentationInvocationProof) { p.CustomTags = []string{"race"} },
+		"erased compiler":        func(p *gotoolprofile.InstrumentationInvocationProof) { p.LLVM = nil; p.Consumption.LLVM = nil },
+		"missing physical count": func(p *gotoolprofile.InstrumentationInvocationProof) { p.ObjectCount = 0 },
+		"paired layout deletion": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.Metadata.Declarations[0].Layout = nil
+			p.Consumption.Metadata.Declarations[0].Layout = nil
+			p.Consumption.Files[0].Declarations[0].Layout = nil
+		},
+		"nested layout unknown": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.Consumption.Files[0].Declarations[0].Layout = json.RawMessage(`{"unexpected":true}`)
+		},
+		"nested layout trailing": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.Consumption.Files[0].Declarations[0].Layout = append(p.Consumption.Files[0].Declarations[0].Layout, []byte(` {}`)...)
+		},
+		"nested layout raw null": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			p.Consumption.Files[0].Declarations[0].Layout = json.RawMessage(`null`)
+		},
+		"paired multi-field layout": func(p *gotoolprofile.InstrumentationInvocationProof) {
+			var layout plan9asm.FuncSig
+			if err := json.Unmarshal(p.Metadata.Declarations[0].Layout, &layout); err != nil {
+				t.Fatal(err)
+			}
+			layout.Ret, layout.Frame.Results[0].Type, layout.Frame.Results[0].Offset = plan9asm.I8, plan9asm.I8, 8
+			encoded, err := json.Marshal(layout)
+			if err != nil {
+				t.Fatal(err)
+			}
+			p.Metadata.Declarations[0].Layout = encoded
+			p.Consumption.Metadata.Declarations[0].Layout = encoded
+			p.Consumption.Files[0].Declarations[0].Layout = encoded
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.InstrumentationInvocationProof
+			if err := json.Unmarshal(original, &changed); err != nil {
+				t.Fatal(err)
+			}
+			change(&changed)
+			independent := producer
+			if name == "paired multi-field layout" {
+				independent = changed.Metadata
+				changed.Consumption.MetadataSHA256 = gotoolprofile.InstrumentationMetadataSHA256(independent)
+			}
+			if err := gotoolprofile.ValidateInstrumentationInvocation(input, gotoolprofile.InstrumentationObjectCompile, independent, tools, &changed); err == nil {
+				t.Fatal("mode invocation reader accepted an erased/relabelled/paired-forged proof")
+			}
+		})
+	}
+	for _, data := range [][]byte{
+		append(append([]byte(nil), original...), []byte(` {}`)...),
+		append([]byte(`{"unexpected":true,`), bytes.TrimSpace(original)[1:]...),
+	} {
+		if _, err := gotoolprofile.DecodeInstrumentationInvocation(bytes.NewReader(data), input, gotoolprofile.InstrumentationObjectCompile, producer, tools); err == nil {
+			t.Fatal("invocation reader accepted unknown or trailing JSON")
+		}
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_cli_test.go b/cmd/plan9asmll/instrumentation_cli_test.go
new file mode 100644
index 000000000..e6f1e118d
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_cli_test.go
@@ -0,0 +1,80 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"testing"
+)
+
+func TestInstrumentationCLIExplicitDefaultOrEmptyFlagCannotEraseModeEntry(t *testing.T) {
+	for _, args := range [][]string{
+		nil, {"-instrumentation-package-dir=."}, {"-instrumentation-profile="}, {"-instrumentation-metadata="},
+	} {
+		flags := flag.NewFlagSet("mode", flag.ContinueOnError)
+		flags.String("instrumentation-package-dir", ".", "")
+		flags.String("instrumentation-profile", "", "")
+		flags.String("instrumentation-metadata", "", "")
+		if err := flags.Parse(args); err != nil {
+			t.Fatal(err)
+		}
+		if requestedInstrumentationCLI(flags) != (len(args) != 0) {
+			t.Fatalf("explicit mode entry was erased, or ordinary entry changed: %v", args)
+		}
+	}
+}
+
+func TestInstrumentationCLIOptionsCannotDowngradeToOrdinaryOrPartialOutput(t *testing.T) {
+	base := instrumentationCLIOptions{
+		Profile: "input.json", Directory: ".", Metadata: "metadata.json", Output: "objects",
+		Targets: []targetSpec{{Goos: "linux", Goarch: "amd64"}}, Patterns: []string{"example.invalid/mode"},
+		Module: "example.invalid/mode", AsmFiles: []string{"probe_amd64.s"},
+		Compile: true, KeepObject: true, OptLevel: 0, StrictLoad: true,
+	}
+	if err := validateInstrumentationCLIOptions(base); err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*instrumentationCLIOptions){
+		"missing context":              func(o *instrumentationCLIOptions) { o.Profile = "" },
+		"ordinary pairing":             func(o *instrumentationCLIOptions) { o.OrdinaryProfile = "ordinary.json" },
+		"missing metadata":             func(o *instrumentationCLIOptions) { o.Metadata = "" },
+		"no compiler":                  func(o *instrumentationCLIOptions) { o.Compile = false },
+		"discard physical object":      func(o *instrumentationCLIOptions) { o.KeepObject = false },
+		"different compiler selection": func(o *instrumentationCLIOptions) { o.LLC = "other-llc" },
+		"different optimization":       func(o *instrumentationCLIOptions) { o.OptLevel = 2 },
+		"target erased":                func(o *instrumentationCLIOptions) { o.Targets = nil },
+		"matrix":                       func(o *instrumentationCLIOptions) { o.AllTargets = true },
+		"explicit matrix alias":        func(o *instrumentationCLIOptions) { o.ExplicitTargets = true },
+		"package union":                func(o *instrumentationCLIOptions) { o.Patterns = append(o.Patterns, "std") },
+		"module erased":                func(o *instrumentationCLIOptions) { o.Module = "" },
+		"scope erased":                 func(o *instrumentationCLIOptions) { o.AsmFiles = nil },
+		"output erased":                func(o *instrumentationCLIOptions) { o.Output = "" },
+		"list":                         func(o *instrumentationCLIOptions) { o.ListOnly = true },
+		"signature query":              func(o *instrumentationCLIOptions) { o.SignatureQuery = true },
+		"partial":                      func(o *instrumentationCLIOptions) { o.Limit = 1 },
+		"non-strict loader":            func(o *instrumentationCLIOptions) { o.StrictLoad = false },
+		"partial failures":             func(o *instrumentationCLIOptions) { o.KeepGoing = true },
+		"changed IR policy":            func(o *instrumentationCLIOptions) { o.Annotate = true },
+		"query/object conflation":      func(o *instrumentationCLIOptions) { o.MetadataOnly = true },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := base
+			change(&changed)
+			if err := validateInstrumentationCLIOptions(changed); err == nil {
+				t.Fatal("incomplete/mixed mode request was accepted")
+			}
+		})
+	}
+	query := base
+	query.MetadataOnly, query.Compile, query.KeepObject, query.Metadata = true, false, false, ""
+	if err := validateInstrumentationCLIOptions(query); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := runInstrumentationCLI(nil, base); err == nil {
+		t.Fatal("nil context accepted")
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := runInstrumentationCLI(ctx, base); err == nil {
+		t.Fatal("cancelled context accepted")
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_emission_roles_go127_test.go b/cmd/plan9asmll/instrumentation_emission_roles_go127_test.go
new file mode 100644
index 000000000..ebe13fe4f
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_emission_roles_go127_test.go
@@ -0,0 +1,326 @@
+//go:build go1.27
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationAssemblyEmissionRolesActualObjects(t *testing.T) {
+	for _, test := range []struct {
+		name, source, emission string
+	}{
+		{"comment-only", "// Original nonzero selected source without symbols.\n", "symbol_free"},
+		{"macro-only", "#define UNUSED(X) MOVD X, R0\n", "symbol_free"},
+		{"inactive-TEXT", "#ifdef NEVER_DEFINED\nTEXT ·Probe(SB),$0-8\nMOVD $41,R0\nMOVD R0,ret+0(FP)\nRET\n#endif\n", "symbol_free"},
+		{"zero-byte", "", "symbol_free"},
+		{"DATA-only", "#include \"textflag.h\"\nDATA ·Global+0(SB)/8,$41\nGLOBL ·Global(SB),RODATA|NOPTR,$8\n", "data_only"},
+		{"TEXT-and-DATA", "#include \"textflag.h\"\nTEXT ·Probe(SB),NOSPLIT,$0-8\nMOVD $41,R0\nMOVD R0,ret+0(FP)\nRET\nDATA ·Global+0(SB)/8,$41\nGLOBL ·Global(SB),RODATA|NOPTR,$8\n", "assembly"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "1")
+			input.Original.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+			const name = "probe_arm64.s"
+			if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, name), []byte(test.source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Original.Sources[name] = featureBytesSHA256([]byte(test.source))
+			input.Original.Headers[name] = test.source
+			toolName := "pkg/include/textflag.h"
+			toolBytes, err := os.ReadFile(filepath.Join(runtime.GOROOT(), toolName))
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.Original.ToolSources = map[string]string{toolName: featureBytesSHA256(toolBytes)}
+			replanInstrumentationMetadataFixture(t, input)
+			producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Independent original stock-Go acceptance is not LLVM proof. In
+			// particular, no-TEXT parsing cannot stand in for this real object.
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			object := filepath.Join(t.TempDir(), "original.o")
+			args := []string{"tool", "asm", "-S", "-p", input.Plan.PackagePath,
+				"-I", input.Original.SourceRoot, "-I", filepath.Join(producer.Source.Root, "pkg", "include"), "-o", object}
+			for _, define := range producer.Metadata.Selection.Packages[0].Macros.Defines {
+				args = append(args, "-D", define)
+			}
+			args = append(args, name)
+			listing, stderr, err := gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, producer.Source.Env, binary, args...)
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("original same-mode assembler: %v; %s", err, stderr)
+			}
+			if stat, err := os.Lstat(object); err != nil || !stat.Mode().IsRegular() || stat.Size() == 0 {
+				t.Fatalf("original assembler produced no regular nonempty object: %v", err)
+			}
+			if test.emission == "symbol_free" && len(listing) != 0 {
+				t.Fatalf("symbol-free original has a native listing: %s", listing)
+			}
+			if test.emission == "data_only" {
+				if _, err := gotoolprofile.DataOnlySymbolsFromListing(listing); err != nil {
+					t.Fatal(err)
+				}
+			}
+			t.Logf("actual original same-mode source=%s listingSHA256=%s object=%s", name, featureBytesSHA256(listing), object)
+			output := instrumentationObjectFixtureOutput(t, input)
+			proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), output)
+			if err != nil {
+				t.Fatalf("actual accepted %s role must independently compile an LLVM object: %v", test.emission, err)
+			}
+			if len(proof.Files) != 1 || proof.Files[0].CPP.Emission != test.emission || proof.Files[0].Output.Object == "" {
+				t.Fatalf("emission role/object lost: %#v", proof)
+			}
+			recordInstrumentationObjectFixture(t, output, input, producer.Metadata, tools, proof)
+			data, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := gotoolprofile.DecodeInstrumentationConsumption(strings.NewReader(string(data)), input, producer.Metadata, tools, ".", nil); err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*gotoolprofile.InstrumentationConsumptionProof){
+				"deleted protocol": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Protocol = "" },
+				"old protocol": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+					p.Protocol = "actual_go_instrumentation_llvm_objects_v2"
+				},
+				"deleted object": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Output.Object = "" },
+				"paired role deletion": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+					p.Files[0].CPP.Emission = "assembly"
+					p.Files[0].CPP.EmptyAssembly = nil
+					p.Files[0].CPP.DataOnlyAssembly = nil
+				},
+				"contradictory role": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].CPP.Emission = "unknown" },
+				"paired role and protocol deletion": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+					p.Protocol = ""
+					p.Files[0].CPP.Emission = ""
+					p.Files[0].CPP.EmptyAssembly = nil
+					p.Files[0].CPP.DataOnlyAssembly = nil
+				},
+				"changed complete CPP": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+					p.Files[0].TypedSource = "// forged empty\n"
+					p.Files[0].CPP.TypedExpandedSHA256 = featureBytesSHA256([]byte(p.Files[0].TypedSource))
+				},
+				"added unconsumed declaration": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+					p.Files[0].Declarations = append(p.Files[0].Declarations, gotoolprofile.InstrumentationDeclarationProof{Symbol: "Unknown"})
+				},
+			} {
+				if name == "paired role deletion" && test.emission == "assembly" {
+					continue // This unchanged normal role is the legitimate control.
+				}
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.InstrumentationConsumptionProof
+					if err := json.Unmarshal(data, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, &changed); err == nil {
+						t.Fatal("changed native emission role/object or old consumer was accepted")
+					}
+				})
+			}
+			if test.emission != "assembly" {
+				for name, mutate := range map[string]func(*gotoolprofile.EmptyAssemblyProof){
+					"source":                    func(p *gotoolprofile.EmptyAssemblyProof) { p.SourceSHA256 = strings.Repeat("0", 64) },
+					"file":                      func(p *gotoolprofile.EmptyAssemblyProof) { p.File = "unknown.s" },
+					"package":                   func(p *gotoolprofile.EmptyAssemblyProof) { p.PackagePath += "/foreign" },
+					"ordinary profile":          func(p *gotoolprofile.EmptyAssemblyProof) { p.ProfileID = input.Original.ID },
+					"target":                    func(p *gotoolprofile.EmptyAssemblyProof) { p.Target = "linux/amd64" },
+					"Go version":                func(p *gotoolprofile.EmptyAssemblyProof) { p.GoVersion = "go1.27.999" },
+					"asm tool":                  func(p *gotoolprofile.EmptyAssemblyProof) { p.AsmToolSHA256 = strings.Repeat("0", 64) },
+					"missing native object":     func(p *gotoolprofile.EmptyAssemblyProof) { p.ObjectSHA256 = "" },
+					"known empty native object": func(p *gotoolprofile.EmptyAssemblyProof) { p.ObjectSHA256 = featureBytesSHA256(nil) },
+					"contradictory listing": func(p *gotoolprofile.EmptyAssemblyProof) {
+						if test.emission == "symbol_free" {
+							p.ListingSHA256 = strings.Repeat("0", 64)
+						} else {
+							p.ListingSHA256 = featureBytesSHA256(nil)
+						}
+					},
+				} {
+					t.Run("native "+name, func(t *testing.T) {
+						var changed gotoolprofile.InstrumentationConsumptionProof
+						if err := json.Unmarshal(data, &changed); err != nil {
+							t.Fatal(err)
+						}
+						native := changed.Files[0].CPP.EmptyAssembly
+						if native == nil {
+							native = &changed.Files[0].CPP.DataOnlyAssembly.Native
+						}
+						mutate(native)
+						if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, &changed); err == nil {
+							t.Fatal("foreign or missing native listing/object identity was accepted")
+						}
+					})
+				}
+			}
+			if test.emission == "data_only" {
+				for _, name := range []string{"name", "size", "static", "kind", "missing", "duplicate"} {
+					t.Run("native symbols "+name, func(t *testing.T) {
+						var changed gotoolprofile.InstrumentationConsumptionProof
+						if err := json.Unmarshal(data, &changed); err != nil {
+							t.Fatal(err)
+						}
+						symbols := &changed.Files[0].CPP.DataOnlyAssembly.Symbols
+						switch name {
+						case "name":
+							(*symbols)[0].Name += "Unknown"
+						case "size":
+							(*symbols)[0].Size++
+						case "static":
+							(*symbols)[0].Static = !(*symbols)[0].Static
+						case "kind":
+							(*symbols)[0].Kind = "STEXT"
+						case "missing":
+							*symbols = nil
+						case "duplicate":
+							*symbols = append(*symbols, (*symbols)[0])
+						}
+						if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, &changed); err == nil {
+							t.Fatal("native symbol inventory no longer matches the full original DATA source")
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestInstrumentationAssemblyEmissionRoleModeFamily(t *testing.T) {
+	for _, config := range []struct {
+		target string
+		mode   gotoolprofile.InstrumentationMode
+	}{
+		{"darwin/arm64", gotoolprofile.InstrumentationRace},
+		{"darwin/amd64", gotoolprofile.InstrumentationRace},
+		{"linux/amd64", gotoolprofile.InstrumentationRace},
+		{"linux/arm64", gotoolprofile.InstrumentationMSan},
+		{"linux/arm64", gotoolprofile.InstrumentationASan},
+	} {
+		t.Run(config.target+"/"+string(config.mode), func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, config.target, config.mode, "1")
+			input.Original.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+			assembly := input.Plan.SFiles[0]
+			// One real same-mode selection consumes all four original siblings.
+			// No emission may borrow another file's listing, role or LLVM object.
+			files := map[string]string{
+				assembly:    input.Original.Headers[assembly],
+				"comment.s": "// Nonzero symbol-free sibling.\n",
+				"zero.s":    "",
+				"data.s":    "#include \"textflag.h\"\nDATA local<>+0(SB)/8,$41\nGLOBL local<>(SB),RODATA|NOPTR,$8\n",
+			}
+			input.Original.AsmFiles = nil
+			for name, source := range files {
+				if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Original.Sources[name], input.Original.Headers[name] = featureBytesSHA256([]byte(source)), source
+				input.Original.AsmFiles = append(input.Original.AsmFiles, name)
+			}
+			sort.Strings(input.Original.AsmFiles)
+			entries, err := os.ReadDir(input.Original.SourceRoot)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.Original.Directories["."] = nil
+			for _, entry := range entries {
+				input.Original.Directories["."] = append(input.Original.Directories["."], entry.Name())
+			}
+			toolName := "pkg/include/textflag.h"
+			toolBytes, err := os.ReadFile(filepath.Join(runtime.GOROOT(), toolName))
+			if err != nil {
+				t.Fatal(err)
+			}
+			input.Original.ToolSources = map[string]string{toolName: featureBytesSHA256(toolBytes)}
+			replanInstrumentationMetadataFixture(t, input)
+			producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+			if err != nil {
+				t.Fatal(err)
+			}
+			output := instrumentationObjectFixtureOutput(t, input)
+			proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(proof.Files) != 4 {
+				t.Fatalf("lost real selected role denominator: %d", len(proof.Files))
+			}
+			for _, file := range proof.Files {
+				wanted := "symbol_free"
+				if file.CPP.File == "data.s" {
+					wanted = "data_only"
+				}
+				if file.CPP.File == assembly {
+					wanted = "assembly"
+				}
+				if file.CPP.Emission != wanted || file.Output.Object == "" {
+					t.Fatalf("missing original role/real object: %+v", file)
+				}
+			}
+			recordInstrumentationObjectFixture(t, output, input, producer.Metadata, tools, proof)
+			if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err != nil {
+				t.Fatal(err)
+			}
+			proof.Files[0].CPP.EmptyAssembly = proof.Files[3].CPP.EmptyAssembly
+			if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err == nil {
+				t.Fatal("cross-file emission evidence acquired source/object permission")
+			}
+		})
+	}
+}
+
+func TestInstrumentationEmissionUnacceptedSourceCannotBecomeEmpty(t *testing.T) {
+	for _, source := range []string{"BOGUS unknown\n", "BYTE $300\n", "#include \"missing-original-header.h\"\n"} {
+		t.Run(strings.Fields(source)[0], func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "1")
+			const name = "probe_arm64.s"
+			if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, name), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Original.Sources[name], input.Original.Headers[name] = featureBytesSHA256([]byte(source)), source
+			replanInstrumentationMetadataFixture(t, input)
+			producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+			if err == nil || producer != nil {
+				t.Fatal("unaccepted original source acquired an empty/object role")
+			}
+			t.Logf("actual original source failure retained: %v", err)
+		})
+	}
+}
+
+func TestInstrumentationEmissionNativeListingRejectsLiveSourceReplacement(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "1")
+	input.Original.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+	const name, source = "probe_arm64.s", "// actual nonzero source\n"
+	path := filepath.Join(input.Original.SourceRoot, name)
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Sources[name], input.Original.Headers[name] = featureBytesSHA256([]byte(source)), source
+	replanInstrumentationMetadataFixture(t, input)
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// No source role may be relabeled as the selected zero-byte sibling after
+	// its actual same-mode graph, source bytes and tools have been captured.
+	if err := os.WriteFile(path, nil, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if proof, _, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir()); err == nil || proof != nil {
+		t.Fatal("source-to-empty replacement acquired native/LLVM object permission")
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_foreign_sources_go127_test.go b/cmd/plan9asmll/instrumentation_foreign_sources_go127_test.go
new file mode 100644
index 000000000..3f7422fab
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_foreign_sources_go127_test.go
@@ -0,0 +1,214 @@
+//go:build go1.27
+
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationForeignOriginalSourcesCLIRecaptureAndFinalGuard(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	const dependency = "example.invalid/cli-layout"
+	foreignSources := map[string]string{
+		"go.mod":          "module " + dependency + "\n\ngo 1.20\n",
+		"model/layout.go": "package model\ntype Word uint64\nconst Words=2\ntype Header struct{Lo uint32; Pad [Words]byte; Hi uint16}\n",
+	}
+	proxy, cache := t.TempDir(), t.TempDir()
+	var archive bytes.Buffer
+	w := zip.NewWriter(&archive)
+	for file, contents := range foreignSources {
+		entry, err := w.Create(dependency + "@v1.0.0/" + file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := entry.Write([]byte(contents)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(proxy, dependency, "@v")
+	if err := os.MkdirAll(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for suffix, contents := range map[string][]byte{
+		".zip": archive.Bytes(), ".mod": []byte(foreignSources["go.mod"]),
+		".info": []byte(`{"Version":"v1.0.0","Time":"2026-10-01T00:00:00Z"}`),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, "v1.0.0"+suffix), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Cleanup(func() {
+		if err := filepath.Walk(cache, func(file string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if info.IsDir() {
+				return os.Chmod(file, 0700)
+			}
+			return nil
+		}); err != nil {
+			t.Error(err)
+		}
+	})
+	// Only this owned synthetic file proxy has no SumDB certificate. It does
+	// not substitute for the production original ZIP/mod authentication.
+	proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := featureEnvironment(os.Environ(), map[string]string{
+		"GOPROXY": proxyURL, "GOSUMDB": "off", "GOMODCACHE": cache, "GOPATH": t.TempDir(),
+	})
+	mod := input.Original.SourceRoot + "/go.mod"
+	modBytes, err := os.ReadFile(mod)
+	if err != nil {
+		t.Fatal(err)
+	}
+	modBytes = append(modBytes, []byte("require "+dependency+" v1.0.0\n")...)
+	if err := os.WriteFile(mod, modBytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Sources["go.mod"] = featureBytesSHA256(modBytes)
+	source := strings.Replace(input.Original.Headers["mode.go"], "import \"example.invalid/modeheader/dep\"",
+		"import (\"example.invalid/modeheader/dep\"; shape \""+dependency+"/model\")", 1)
+	source = strings.Replace(source, "func Probe() uint64", "func Probe() shape.Word", 1)
+	if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, "mode.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Sources["mode.go"], input.Original.Headers["mode.go"] = featureBytesSHA256([]byte(source)), source
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, stderr, err := gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, env, binary, "mod", "download", "-json", dependency+"@v1.0.0")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("exact owned dependency: %v; %s", err, stderr)
+	}
+	var actual struct{ Dir, Zip, GoMod, Sum, GoModSum string }
+	if err := json.Unmarshal(data, &actual); err != nil || actual.Dir == "" {
+		t.Fatal("actual stock Go download omitted its physical identity")
+	}
+	for _, name := range []string{"go.mod", "go.sum"} {
+		contents, err := os.ReadFile(filepath.Join(input.Original.SourceRoot, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		input.Original.Sources[name] = featureBytesSHA256(contents)
+	}
+	input.Original.Directories["."] = nil
+	entries, err := os.ReadDir(input.Original.SourceRoot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range entries {
+		input.Original.Directories["."] = append(input.Original.Directories["."], entry.Name())
+	}
+	replanInstrumentationMetadataFixture(t, input)
+	resource := gotoolprofile.TestModuleSource{Protocol: gotoolprofile.TestDependencyModuleProtocol,
+		SourceModule: dependency, SourceVersion: "v1.0.0", ModuleSum: actual.Sum, GoModSum: actual.GoModSum,
+		GoModOrigin: gotoolprofile.TestModuleOriginalGoModOrigin,
+		Sources:     map[string]string{}, Headers: map[string]string{}, Directories: map[string][]gotoolprofile.TestSourceEntry{}}
+	resource.ZipSHA256, err = gotoolprofile.FileSHA256(actual.Zip)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, dir := range []string{".", "model"} {
+		members, err := os.ReadDir(filepath.Join(actual.Dir, dir))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, member := range members {
+			entry := gotoolprofile.TestSourceEntry{Name: member.Name(), Kind: "directory"}
+			if !member.IsDir() {
+				name := filepath.ToSlash(filepath.Join(dir, member.Name()))
+				contents, err := os.ReadFile(filepath.Join(actual.Dir, name))
+				if err != nil {
+					t.Fatal(err)
+				}
+				entry.Kind, entry.SHA256 = "file", featureBytesSHA256(contents)
+				resource.Sources[name] = entry.SHA256
+				if strings.HasSuffix(name, ".go") {
+					header, err := gotoolprofile.TestSelectionHeader(name, contents)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resource.Headers[name] = header
+				}
+			}
+			resource.Directories[dir] = append(resource.Directories[dir], entry)
+		}
+		sort.Slice(resource.Directories[dir], func(i, j int) bool { return resource.Directories[dir][i].Name < resource.Directories[dir][j].Name })
+	}
+	resource.GoModSHA256 = resource.Sources["go.mod"]
+	modeEnv := featureEnvironment(env, input.Observation.Early.Environment)
+	input.TypeSources, err = gotoolprofile.CaptureInstrumentationTypeSourcesWithModules(ctx, binary, input.Original.SourceRoot, modeEnv,
+		input, []gotoolprofile.TestModuleSource{resource}, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The actual consumer uses a physical invocation directory. Re-observing
+	// that same source must preserve all portable fields, including exports.
+	physical, err := sourcepath.Resolve(input.Original.SourceRoot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	recaptured, err := gotoolprofile.CaptureInstrumentationTypeSources(ctx, binary, physical, modeEnv, input, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedJSON, err := json.Marshal(input.TypeSources)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualJSON, err := json.Marshal(recaptured)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(input.TypeSources, recaptured) {
+		t.Fatalf("same-source type recapture changed:\nexpected: %s\nactual: %s", expectedJSON, actualJSON)
+	}
+	consumer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, env, t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if consumer.ForeignSources == nil {
+		t.Fatal("CLI did not independently bind the original foreign resource")
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, consumer.Metadata, input.Original.SourceRoot, env, t.TempDir())
+	if err != nil || gotoolprofile.ValidateInstrumentationConsumption(input, consumer.Metadata, tools, ".", nil, proof) != nil {
+		t.Fatalf("actual same-mode foreign metadata/CPP/LLVM consumption: %v", err)
+	}
+	foreignFile := filepath.Join(actual.Dir, "model", "layout.go")
+	if err := os.Chmod(foreignFile, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(foreignFile, []byte(foreignSources["model/layout.go"]+"\nconst Changed=1\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err == nil {
+		t.Fatal("final CLI boundary accepted mutated foreign original source after successful object consumption")
+	}
+	if err := os.WriteFile(foreignFile, []byte(foreignSources["model/layout.go"]), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_goenv_handoff_go127_test.go b/cmd/plan9asmll/instrumentation_goenv_handoff_go127_test.go
new file mode 100644
index 000000000..163515645
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_goenv_handoff_go127_test.go
@@ -0,0 +1,134 @@
+//go:build go1.27
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationMetadataAndObjectsIgnoreOwnedUserGoEnv(t *testing.T) {
+	// Prepare the actual marker, source inventory and mode plan before making
+	// the caller's private Go configuration hostile. No SDK is copied or edited.
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err = filepath.Abs(goBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	userFile := filepath.Join(t.TempDir(), "go-env")
+	userConfig := []byte("GOFLAGS=-plan9asm-owned-user-env-invalid\n")
+	if err := os.WriteFile(userFile, userConfig, 0600); err != nil {
+		t.Fatal(err)
+	}
+	userEnv := instrumentationGoEnvFixtureEnvironment(os.Environ(), userFile)
+	query := func(t *testing.T, env []string) map[string]string {
+		t.Helper()
+		stdout, stderr, err := gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, env, goBinary, "env", "-json", "GOENV", "GOFLAGS")
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("actual owned Go environment query: %v\n%s\n%s", err, stdout, stderr)
+		}
+		var observed map[string]string
+		if err := json.Unmarshal(stdout, &observed); err != nil || len(observed) != 2 {
+			t.Fatalf("incomplete actual owned Go environment: %v; %s", err, stdout)
+		}
+		return observed
+	}
+	if actual := query(t, userEnv); !reflect.DeepEqual(actual, map[string]string{
+		"GOENV": userFile, "GOFLAGS": "-plan9asm-owned-user-env-invalid",
+	}) {
+		t.Fatalf("the original caller did not consume the real owned go/env: %#v", actual)
+	}
+	stdout, stderr, originalErr := gotoolprofile.RunBounded(ctx, input.Original.SourceRoot, userEnv, goBinary, "list", "-mod=readonly", "./...")
+	if originalErr == nil || !strings.Contains(string(stderr), "unknown flag -plan9asm-owned-user-env-invalid") {
+		t.Fatalf("owned user go/env did not cause the actual stock-Go failure: %v\n%s\n%s", originalErr, stdout, stderr)
+	}
+	t.Logf("original inherited user GOENV failure: %v\n%s\n%s", originalErr, stdout, stderr)
+
+	for _, scenario := range []string{"explicit off control", "inherited owned user config"} {
+		t.Run(scenario, func(t *testing.T) {
+			env := userEnv
+			if scenario == "explicit off control" {
+				env = instrumentationGoEnvFixtureEnvironment(userEnv, "off")
+			}
+			loadCalls := 0
+			loader := func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+				loadCalls++
+				if actual := query(t, config.Env); !reflect.DeepEqual(actual, map[string]string{"GOENV": "", "GOFLAGS": ""}) {
+					t.Fatalf("actual mode package/export loader borrowed the user configuration: %#v", actual)
+				}
+				return packages.Load(config, patterns...)
+			}
+			metadata, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, env, t.TempDir(), loader)
+			if err != nil {
+				t.Fatalf("mode metadata inherited the unrelated user go/env after the original mode proof was prepared: %v", err)
+			}
+			if loadCalls == 0 {
+				t.Fatal("mode metadata did not execute the actual package/export loader")
+			}
+			// The same private environment is handed to generated headers and
+			// ordinary asmdecl, not only to the marker's separate reobserver.
+			if actual := query(t, metadata.Source.Env); !reflect.DeepEqual(actual, map[string]string{"GOENV": "", "GOFLAGS": ""}) {
+				t.Fatalf("mode header/asmdecl consumer retained a different actual context: %#v", actual)
+			}
+			encoded, err := json.Marshal(metadata.Metadata)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := gotoolprofile.DecodeInstrumentationMetadata(strings.NewReader(string(encoded)), input, ".", nil); err != nil {
+				t.Fatal(err)
+			}
+			output := instrumentationObjectFixtureOutput(t, input)
+			proof, tools, err := consumeInstrumentationAssembly(ctx, input, metadata.Metadata, input.Original.SourceRoot, env, output)
+			if err != nil {
+				t.Fatalf("actual mode CPP/LLVM object inherited the user configuration: %v", err)
+			}
+			if proof.Status != "llvm_objects_only" || len(proof.Files) != 1 || proof.Files[0].Output.Object == "" {
+				t.Fatal("mode consumer omitted its original object or claimed runtime")
+			}
+			encoded, err = json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := gotoolprofile.DecodeInstrumentationConsumption(strings.NewReader(string(encoded)), input, metadata.Metadata, tools, ".", nil); err != nil {
+				t.Fatal(err)
+			}
+			for _, file := range proof.Files {
+				ir := filepath.Join(output, file.Output.Part)
+				if actual, err := gotoolprofile.FileSHA256(ir); err != nil || actual != file.Output.IR {
+					t.Fatalf("actual mode IR absent or changed: %v", err)
+				}
+				object := strings.TrimSuffix(ir, ".ll") + ".o"
+				if actual, err := gotoolprofile.FileSHA256(object); err != nil || actual != file.Output.Object {
+					t.Fatalf("actual LLVM22 object absent or changed: %v", err)
+				}
+			}
+			recordInstrumentationObjectFixture(t, output, input, metadata.Metadata, tools, proof)
+		})
+	}
+	if actual, err := os.ReadFile(userFile); err != nil || string(actual) != string(userConfig) {
+		t.Fatalf("mode commands altered the original owned go/env witness: %v", err)
+	}
+}
+
+func instrumentationGoEnvFixtureEnvironment(base []string, file string) []string {
+	var env []string
+	for _, entry := range base {
+		key, _, _ := strings.Cut(entry, "=")
+		if key != "GOENV" && key != "GOFLAGS" {
+			env = append(env, entry)
+		}
+	}
+	return append(env, "GOENV="+file)
+}
diff --git a/cmd/plan9asmll/instrumentation_imported_layout_go127_test.go b/cmd/plan9asmll/instrumentation_imported_layout_go127_test.go
new file mode 100644
index 000000000..0099ce963
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_imported_layout_go127_test.go
@@ -0,0 +1,130 @@
+//go:build go1.27
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationImportedSDKDeclarationActualObjects(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	input = replaceInstrumentationReplaySignature(t, input,
+		"func Probe(values [bits.UintSize / 8]byte) syscall.Errno",
+		strings.Replace(strings.Replace(input.Sources.Contents["probe_arm64.s"], "$0-8", "$0-16", 1), "ret+0(FP)", "ret+8(FP)", 1))
+	source := strings.Replace(input.Sources.Contents["mode.go"], "import \"example.invalid/modeheader/dep\"",
+		"import (\"example.invalid/modeheader/dep\"; \"math/bits\"; \"syscall\")", 1)
+	if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, "mode.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Sources["mode.go"], input.Original.Headers["mode.go"] = featureBytesSHA256([]byte(source)), source
+	replanInstrumentationMetadataFixture(t, input)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.TypeSources, err = gotoolprofile.CaptureInstrumentationTypeSources(ctx, binary, input.Original.SourceRoot,
+		featureEnvironment(os.Environ(), input.Observation.Early.Environment), input, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := gotoolprofile.DecodeInstrumentationConsumption(strings.NewReader(string(data)), input, producer.Metadata, tools, ".", nil); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("actual same-mode SDK constant/type, stock Go header/export/asmdecl and independent LLVM22 object/readback; no external execution")
+}
+
+func TestInstrumentationImportedSameModuleDeclarationActualObjects(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	input = replaceInstrumentationReplaySignature(t, input, "func Probe(values dep.Buffer) uint64",
+		strings.Replace(strings.Replace(input.Sources.Contents["probe_arm64.s"], "$0-8", "$0-16", 1), "ret+0(FP)", "ret+8(FP)", 1))
+	const name = "dep/layout.go"
+	source := input.Original.Headers[name] + `
+type Element uint16
+type Alias = Element
+const (
+	_ = iota
+	Count
+	_ = iota
+	Length
+)
+type Buffer [Length]Alias
+`
+	if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, name), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Headers[name], input.Original.Sources[name] = source, featureBytesSHA256([]byte(source))
+	replanInstrumentationMetadataFixture(t, input)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.TypeSources, err = gotoolprofile.CaptureInstrumentationTypeSources(ctx, binary, input.Original.SourceRoot,
+		featureEnvironment(os.Environ(), input.Observation.Early.Environment), input, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err != nil {
+		t.Fatal(err)
+	}
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*gotoolprofile.InstrumentationConsumerInput){
+		"missing original bytes": func(p *gotoolprofile.InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].Contents = nil },
+		"changed original bytes": func(p *gotoolprofile.InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Contents["dep/layout.go"] += "\nconst Changed=1\n"
+		},
+		"paired selector deletion": func(p *gotoolprofile.InstrumentationConsumerInput) { p.TypeSources = nil },
+		"forged actual export": func(p *gotoolprofile.InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.ExportSHA256 = strings.Repeat("0", 64)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.InstrumentationConsumerInput
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			// Portable readers also fail if both metadata records are unchanged.
+			if change(&changed); gotoolprofile.ValidateInstrumentationConsumption(&changed, producer.Metadata, tools, ".", nil, proof) == nil {
+				t.Fatal("changed original source input was accepted as object evidence")
+			}
+			if changed.TypeSources != nil && !reflect.DeepEqual(changed.TypeSources, input.TypeSources) {
+				actual, err := gotoolprofile.CaptureInstrumentationTypeSources(ctx, binary, input.Original.SourceRoot,
+					featureEnvironment(os.Environ(), input.Observation.Early.Environment), &changed, gotoolprofile.RunBounded)
+				if err == nil && reflect.DeepEqual(actual, changed.TypeSources) {
+					t.Fatal("actual original source/export capture trusted a forged portable input")
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_layout_replay_go127_test.go b/cmd/plan9asmll/instrumentation_layout_replay_go127_test.go
new file mode 100644
index 000000000..670dca77f
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_layout_replay_go127_test.go
@@ -0,0 +1,158 @@
+//go:build go1.27
+
+package main
+
+import (
+	"encoding/json"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationObjectsPairedLayoutChangesRequireOriginalGoTypes(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	producerJSON, err := json.Marshal(producer.Metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proofJSON, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*plan9asm.FuncSig){
+		"return type": func(sig *plan9asm.FuncSig) {
+			sig.Ret, sig.Frame.Results[0].Type = plan9asm.I8, plan9asm.I8
+		},
+		"paired GoType and return": func(sig *plan9asm.FuncSig) {
+			sig.Ret, sig.Frame.Results[0].Type = plan9asm.I8, plan9asm.I8
+		},
+		"result name":      func(sig *plan9asm.FuncSig) { sig.Frame.Results[0].Name = "invented" },
+		"FP result offset": func(sig *plan9asm.FuncSig) { sig.Frame.Results[0].Offset += 8 },
+		"invented parameter": func(sig *plan9asm.FuncSig) {
+			sig.Args = []plan9asm.LLVMType{plan9asm.I8}
+			sig.Frame.Params = []plan9asm.FrameSlot{{Type: plan9asm.I8, Index: 0, Field: -1}}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changedProducer gotoolprofile.InstrumentationMetadataProof
+			var changedProof gotoolprofile.InstrumentationConsumptionProof
+			if err := json.Unmarshal(producerJSON, &changedProducer); err != nil {
+				t.Fatal(err)
+			}
+			if err := json.Unmarshal(proofJSON, &changedProof); err != nil {
+				t.Fatal(err)
+			}
+			var layout plan9asm.FuncSig
+			if err := json.Unmarshal(changedProducer.Declarations[0].Layout, &layout); err != nil {
+				t.Fatal(err)
+			}
+			change(&layout)
+			data, err := json.Marshal(layout)
+			if err != nil {
+				t.Fatal(err)
+			}
+			changedProducer.Declarations[0].Layout = data
+			changedProof.Metadata.Declarations[0].Layout = data
+			changedProof.Files[0].Declarations[0].Layout = data
+			if name == "paired GoType and return" {
+				changedProducer.Declarations[0].GoType = "func() uint8"
+				changedProof.Metadata.Declarations[0].GoType = "func() uint8"
+				changedProof.Files[0].Declarations[0].GoType = "func() uint8"
+			}
+			changedProof.MetadataSHA256 = gotoolprofile.InstrumentationMetadataSHA256(&changedProducer)
+			if err := gotoolprofile.ValidateInstrumentationConsumption(input, &changedProducer, tools, ".", nil, &changedProof); err == nil {
+				t.Fatal("paired metadata/source-layout forgery bypassed independent original Go type replay")
+			}
+		})
+	}
+}
+
+func TestInstrumentationObjectsActualClosedAliasAndConstantSignature(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	input = replaceInstrumentationReplaySignature(t, input,
+		"type Element uint16\ntype Alias = Element\nconst Count = 3\nfunc Probe(values [Count]Alias) uint64",
+		strings.Replace(strings.Replace(input.Sources.Contents["probe_arm64.s"], "$0-8", "$0-16", 1), "ret+0(FP)", "ret+8(FP)", 1))
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstrumentationZeroSizedParameterOriginalGoAcceptedButConsumerUnclosed(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	input = replaceInstrumentationReplaySignature(t, input, "func Probe(values [0]byte) uint64", input.Sources.Contents["probe_arm64.s"])
+	var actual *packages.Package
+	load := func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+		loaded, err := packages.Load(config, patterns...)
+		if err == nil && len(loaded) == 1 && len(loaded[0].Errors) == 0 && loaded[0].Types != nil {
+			actual = loaded[0]
+		}
+		return loaded, err
+	}
+	_, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), load)
+	if err == nil || !strings.Contains(err.Error(), "two-builder zero-sized parameter difference") {
+		t.Fatalf("actual Go zero-sized declaration became source-invalid or claimed consumer proof: %v", err)
+	}
+	if actual == nil || actual.ExportFile == "" {
+		t.Fatal("missing original stock-Go compiled/exported declaration")
+	}
+	if _, err := gotoolprofile.FileSHA256(actual.ExportFile); err != nil {
+		t.Fatal(err)
+	}
+	derived, _, found, err := tryDeclSig(actual.Types.Scope(), "·Probe", input.Plan.PackagePath+".Probe", nil, "arm64", actual.TypesSizes, false)
+	if err != nil || !found || len(derived.Args) != 0 || len(derived.Frame.Params) != 0 {
+		t.Fatalf("actual CLI ABI0 builder did not omit the zero-sized parameter: %#v: %v", derived, err)
+	}
+	root, err := plan9asm.DeriveGoFuncABI0Signature(derived.Name, actual.Types.Scope().Lookup("Probe").(*types.Func), "arm64", actual.TypesSizes)
+	if err != nil || len(root.Args) != 1 || len(root.Frame.Params) != 0 {
+		t.Fatalf("root builder's unchanged zero-sized parameter difference disappeared: %#v: %v", root, err)
+	}
+	t.Logf("actual unchanged root Args=%v, CLI Args=%v", root.Args, derived.Args)
+	t.Log("original same-mode Go export/asmdecl accepted; known root/CLI zero-sized parameter agreement remains consumer F")
+}
+
+func replaceInstrumentationReplaySignature(t *testing.T, input *gotoolprofile.InstrumentationConsumerInput, declaration, assembly string) *gotoolprofile.InstrumentationConsumerInput {
+	t.Helper()
+	source := strings.Replace(input.Sources.Contents["mode.go"], "func Probe() uint64", declaration, 1)
+	for name, text := range map[string]string{"mode.go": source, "probe_arm64.s": assembly} {
+		if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Original.Sources[name] = featureBytesSHA256([]byte(text))
+		input.Original.Headers[name] = text
+	}
+	sources, err := gotoolprofile.CaptureInstrumentationOriginalSourceInventory(input.Original, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := gotoolprofile.PlanInstrumentationOriginalPackage(input.Original, sources, input.Observation.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	result, err := gotoolprofile.NewInstrumentationConsumerInput(input.Original, sources, input.Observation, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return result
+}
diff --git a/cmd/plan9asmll/instrumentation_metadata_consumer.go b/cmd/plan9asmll/instrumentation_metadata_consumer.go
new file mode 100644
index 000000000..7f179f71d
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_metadata_consumer.go
@@ -0,0 +1,289 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// This private adapter is not wired into the ordinary CLI/report. Source uses
+// only its original immutable byte guards; it has no ordinary SelectionProof.
+// All selected/export/header results retain their separate actual mode input.
+type instrumentationMetadataConsumer struct {
+	Input            *gotoolprofile.InstrumentationConsumerInput
+	Source           *featureConsumer
+	Packages         []*packages.Package
+	Metadata         *gotoolprofile.InstrumentationMetadataProof
+	InvocationConfig map[string]string
+	ForeignSources   *gotoolprofile.InstrumentationTypeModuleGuard
+	ArtifactRoot     string
+	Artifacts        []gotoolprofile.InstrumentationLLVMArtifacts
+}
+
+func captureInstrumentationMetadata(ctx context.Context, input *gotoolprofile.InstrumentationConsumerInput, invocation string, env []string, output string, load func(*packages.Config, ...string) ([]*packages.Package, error)) (*instrumentationMetadataConsumer, error) {
+	if ctx == nil || ctx.Err() != nil || input == nil || input.Plan == nil || load == nil || !filepath.IsAbs(invocation) {
+		return nil, fmt.Errorf("mode metadata needs a live actual source/export context")
+	}
+	plan := input.Plan
+	if err := gotoolprofile.ValidateInstrumentationConsumerInput(input, plan.PackageDirectory, plan.CustomTags); err != nil {
+		return nil, err
+	}
+	if len(plan.CgoFiles) != 0 {
+		return nil, fmt.Errorf("mode metadata cannot bind generated cgo compiler inputs without their original source mapping")
+	}
+	dir, err := sourcepath.Resolve(input.Original.SourceRoot)
+	if err != nil {
+		return nil, err
+	}
+	invocation, err = sourcepath.Resolve(invocation)
+	if err != nil {
+		return nil, err
+	}
+	configuration, err := gotoolprofile.CaptureInstrumentationInvocationConfig(invocation)
+	if err != nil {
+		return nil, err
+	}
+	modeActual := make(map[string]string, len(input.Observation.Early.Environment)+1)
+	for key, value := range input.Observation.Early.Environment {
+		modeActual[key] = value
+	}
+	// The independently observed mode disables user go/env. Every metadata,
+	// header, analyzer and object consumer must execute under that same policy.
+	modeActual["GOENV"] = "off"
+	modeEnv := featureEnvironment(env, modeActual)
+	source := &featureConsumer{
+		ID: input.Original.ID, Observed: input.Original.Observed, Input: input.Original,
+		Context: ctx, Dir: dir, WorkDir: invocation, Env: modeEnv,
+	}
+	consumer := &instrumentationMetadataConsumer{Input: input, Source: source, InvocationConfig: configuration}
+	if err := source.verifySources(); err != nil {
+		return nil, err
+	}
+	if err := os.MkdirAll(output, 0700); err != nil {
+		return nil, err
+	}
+	if err := consumer.reobserve(output); err != nil {
+		return nil, err
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	if input.TypeSources != nil {
+		consumer.ForeignSources, err = gotoolprofile.BindInstrumentationTypeModuleSources(ctx, binary, invocation, modeEnv, input.TypeSources.SourceModules, gotoolprofile.RunBounded)
+		if err != nil {
+			return nil, err
+		}
+		actual, err := gotoolprofile.CaptureInstrumentationTypeSources(ctx, binary, invocation, modeEnv, input, gotoolprofile.RunBounded)
+		if err != nil || !reflect.DeepEqual(actual, input.TypeSources) {
+			return nil, fmt.Errorf("original imported type source input differs from independent actual consumption: %v", err)
+		}
+	}
+	root, stderr, err := gotoolprofile.RunBounded(ctx, invocation, modeEnv, binary, "env", "GOROOT")
+	if err != nil || len(stderr) != 0 || !filepath.IsAbs(strings.TrimSpace(string(root))) {
+		return nil, fmt.Errorf("actual mode source root: %v; %s", err, stderr)
+	}
+	source.Root = strings.TrimSpace(string(root))
+	flags, err := gotoolprofile.InstrumentationPackageLoadFlags(input)
+	if err != nil {
+		return nil, err
+	}
+	config := &packages.Config{
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+			packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax | packages.NeedCompiledGoFiles |
+			packages.NeedExportFile | packages.NeedEmbedFiles | packages.NeedEmbedPatterns,
+		Context: ctx, Env: modeEnv, Dir: invocation, BuildFlags: flags,
+	}
+	pkgs, err := loadGeneratedHeaderPackagesConfigured(source, config, []string{plan.PackagePath}, load)
+	if err != nil {
+		return nil, err
+	}
+	if len(pkgs) != 1 || pkgs[0].PkgPath != plan.PackagePath || pkgs[0].Name != plan.PackageName {
+		return nil, fmt.Errorf("mode metadata selected a changed original package scope")
+	}
+	selected, err := source.captureSourcePackage(pkgs[0], func(packagePath string) (*gotoolprofile.AssemblerMacros, error) {
+		return gotoolprofile.CaptureInstrumentationAssemblerMacros(source.Root, input, packagePath)
+	})
+	if err != nil {
+		return nil, err
+	}
+	selection := &gotoolprofile.InstrumentationPackageSelectionProof{
+		Protocol: gotoolprofile.InstrumentationPackageSelectionProtocol, ModeProfileID: input.ID,
+		InputSHA256: gotoolprofile.InstrumentationConsumerInputSHA256(input),
+		CustomTags:  append([]string(nil), plan.CustomTags...), Packages: []gotoolprofile.PackageProof{selected}, Status: "consumer_pending",
+	}
+	if err := gotoolprofile.ValidateInstrumentationPackageSelection(input, plan.PackageDirectory, plan.CustomTags, selection); err != nil {
+		return nil, err
+	}
+	headerFlags, err := gotoolprofile.InstrumentationHeaderCompilerFlags(input)
+	if err != nil {
+		return nil, err
+	}
+	header, err := captureGeneratedHeaderConfigured(source, pkgs[0], selected, output, generatedHeaderCaptureContext{
+		protocol: gotoolprofile.InstrumentationGeneratedHeaderProtocol, id: input.ID, compilerFlags: headerFlags,
+		validate: func(header gotoolprofile.GeneratedHeaderProof) error {
+			return gotoolprofile.ValidateInstrumentationGeneratedHeader(input, gotoolprofile.InstrumentationGeneratedHeader{Header: header, CompilerFlags: headerFlags}, selected)
+		},
+	})
+	if err != nil {
+		return nil, err
+	}
+	dependencies, err := captureInstrumentationMetadataDependencies(source, pkgs)
+	if err != nil {
+		return nil, err
+	}
+	declarations, err := captureInstrumentationPackageDeclarations(input, pkgs[0])
+	if err != nil {
+		return nil, err
+	}
+	exportSHA, err := gotoolprofile.FileSHA256(pkgs[0].ExportFile)
+	if err != nil || pkgs[0].ExportFile == "" {
+		return nil, fmt.Errorf("actual original mode export is absent: %v", err)
+	}
+	if err := source.retainGeneratedGuard(map[string]string{pkgs[0].ExportFile: exportSHA}); err != nil {
+		return nil, err
+	}
+	vetArgs := gotoolprofile.InstrumentationPackageVetArgs(input)
+	exports := map[string]string{selected.PackagePath: exportSHA}
+	for _, dependency := range dependencies {
+		exports[dependency.Source.PackagePath] = dependency.Source.ExportSHA256
+	}
+	if err := gotoolprofile.RunInstrumentationOrdinaryAsmdecl(ctx, binary, invocation, modeEnv, input.Original,
+		plan, &selected, exports, gotoolprofile.RunBounded); err != nil {
+		return nil, err
+	}
+	proof := &gotoolprofile.InstrumentationMetadataProof{
+		Protocol: gotoolprofile.InstrumentationMetadataProtocol, ModeProfileID: input.ID,
+		InputSHA256: gotoolprofile.InstrumentationConsumerInputSHA256(input), Selection: selection,
+		Headers:      []gotoolprofile.InstrumentationGeneratedHeader{{Header: header, CompilerFlags: headerFlags}},
+		Dependencies: dependencies, Status: "consumer_pending",
+		Declarations:         declarations,
+		OriginalExportSHA256: exportSHA, InvocationConfigSHA256: configuration, LoadBuildFlags: flags, VetArgs: vetArgs,
+	}
+	if err := gotoolprofile.ValidateInstrumentationMetadata(input, plan.PackageDirectory, plan.CustomTags, proof); err != nil {
+		return nil, err
+	}
+	consumer.Packages, consumer.Metadata = pkgs, proof
+	if err := consumer.reobserve(output); err != nil {
+		return nil, err
+	}
+	return consumer, consumer.verifySources()
+}
+
+func (consumer *instrumentationMetadataConsumer) reobserve(output string) error {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return err
+	}
+	owned, err := os.MkdirTemp(output, ".instrumentation-markers-")
+	if err != nil {
+		return err
+	}
+	input, source := consumer.Input, consumer.Source
+	early := input.Observation.Early
+	actual, err := gotoolprofile.CaptureInstrumentationExportObservation(source.Context, binary, owned, source.Env, early.Target, early.Mode, early.CGOEnabled, nil, gotoolprofile.RunBounded)
+	if err != nil {
+		return fmt.Errorf("reobserve actual same-mode metadata driver: %w", err)
+	}
+	if gotoolprofile.InstrumentationEarlyProfileID(actual.Early) != input.ID || !reflect.DeepEqual(actual.BuildPlan, input.Observation.BuildPlan) || !reflect.DeepEqual(actual.Routing, input.Observation.Routing) {
+		return fmt.Errorf("mode source/tool/environment/compiler routing changed before or after metadata capture")
+	}
+	return consumer.verifySources()
+}
+
+func (consumer *instrumentationMetadataConsumer) verifySources() error {
+	if err := consumer.Source.verifySources(); err != nil {
+		return err
+	}
+	if consumer.ForeignSources != nil {
+		if err := consumer.ForeignSources.Verify(consumer.Source.Context); err != nil {
+			return err
+		}
+	}
+	budget := &gotoolprofile.InstrumentationLLVMArtifactBudget{}
+	for index := range consumer.Artifacts {
+		if err := consumer.Source.Context.Err(); err != nil {
+			return err
+		}
+		actual, err := gotoolprofile.CaptureInstrumentationLLVMArtifacts(consumer.ArtifactRoot, index, budget)
+		if err != nil || !reflect.DeepEqual(actual, &consumer.Artifacts[index]) {
+			return fmt.Errorf("mode generated LLVM artifact changed before final consumption: %v", err)
+		}
+	}
+	actual, err := gotoolprofile.CaptureInstrumentationInvocationConfig(consumer.Source.WorkDir)
+	if err != nil || !reflect.DeepEqual(actual, consumer.InvocationConfig) {
+		return fmt.Errorf("mode invocation configuration changed before or after consumption: %v", err)
+	}
+	return nil
+}
+
+func captureInstrumentationMetadataDependencies(source *featureConsumer, pkgs []*packages.Package) ([]gotoolprofile.InstrumentationDependencyExport, error) {
+	byPath := make(map[string]gotoolprofile.InstrumentationDependencyExport)
+	var captureErr error
+	packages.Visit(pkgs, func(pkg *packages.Package) bool {
+		if captureErr != nil {
+			return false
+		}
+		if pkg.PkgPath == "unsafe" {
+			return false
+		}
+		imports, exports, _, sources, err := generatedHeaderImports(source, pkg)
+		if err != nil {
+			captureErr = err
+			return false
+		}
+		for _, guard := range []map[string]string{exports, sources} {
+			if err := source.retainGeneratedGuard(guard); err != nil {
+				captureErr = err
+				return false
+			}
+		}
+		for _, imported := range imports {
+			imported.ImportPath = imported.PackagePath
+			dep := pkg.Imports[imported.PackagePath]
+			if dep == nil {
+				for _, candidate := range pkg.Imports {
+					if candidate.PkgPath == imported.PackagePath {
+						dep = candidate
+					}
+				}
+			}
+			if dep == nil || len(byPath) >= 4096 {
+				captureErr = fmt.Errorf("actual mode dependency closure lost its package or exceeded its bound")
+				return false
+			}
+			entry := gotoolprofile.InstrumentationDependencyExport{Source: imported, ImportMap: make(map[string]string)}
+			for name, child := range dep.Imports {
+				entry.ImportMap[name] = child.PkgPath
+			}
+			if prior, found := byPath[imported.PackagePath]; found && !reflect.DeepEqual(prior, entry) {
+				captureErr = fmt.Errorf("actual mode dependency source/export changed between reachable imports")
+				return false
+			}
+			byPath[imported.PackagePath] = entry
+		}
+		return true
+	}, nil)
+	if captureErr != nil {
+		return nil, captureErr
+	}
+	result := make([]gotoolprofile.InstrumentationDependencyExport, 0, len(byPath))
+	for _, dep := range byPath {
+		result = append(result, dep)
+	}
+	sort.Slice(result, func(i, j int) bool { return result[i].Source.PackagePath < result[j].Source.PackagePath })
+	return result, source.verifySources()
+}
diff --git a/cmd/plan9asmll/instrumentation_metadata_go127_test.go b/cmd/plan9asmll/instrumentation_metadata_go127_test.go
new file mode 100644
index 000000000..58fb3e853
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_metadata_go127_test.go
@@ -0,0 +1,390 @@
+//go:build go1.27
+
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"io/fs"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"golang.org/x/tools/go/packages"
+)
+
+func instrumentationMetadataFixture(t *testing.T, target string, mode gotoolprofile.InstrumentationMode, cgo string) (*gotoolprofile.InstrumentationConsumerInput, context.Context) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	t.Cleanup(cancel)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	marker, err := gotoolprofile.CaptureInstrumentationExportObservation(ctx, binary, t.TempDir(), os.Environ(), target, mode, cgo, nil, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	input := &featureInput{
+		Protocol: featureInputProtocol, Module: "example.invalid/modeheader", SourceRoot: dir,
+		Observed: marker.Early.BaselineFeatures, ID: gotoolprofile.ProfileID(marker.Early.BaselineFeatures),
+		Sources: make(map[string]string), Headers: make(map[string]string), Directories: make(map[string][]string),
+	}
+	files := map[string]string{
+		"go.mod":             "module example.invalid/modeheader\n\ngo 1.24\n",
+		"base.go":            "package modeheader\n",
+		"mode.go":            "//go:build race || msan || asan\n\npackage modeheader\nimport \"example.invalid/modeheader/dep\"\nconst Imported = dep.Value + 1\ntype Layout struct { First byte; External dep.Mixed; Last uintptr }\nfunc Probe() uint64\n",
+		"dep/layout.go":      "package dep\ntype Mixed struct { Small byte; Word uintptr; Bytes []byte }\n",
+		"dep/value_plain.go": "//go:build !race && !msan && !asan\n\npackage dep\nconst Value = 1\n",
+		"dep/value_mode.go":  "//go:build race || msan || asan\n\npackage dep\nconst Value = 40\n",
+		"probe_arm64.s":      "//go:build race || msan || asan\n\n#include \"go_asm.h\"\nTEXT ·Probe(SB),$0-8\nMOVD $const_Imported, R0\nMOVD R0, ret+0(FP)\nRET\n",
+	}
+	assembly := "probe_arm64.s"
+	if strings.HasSuffix(target, "/amd64") {
+		assembly = "probe_amd64.s"
+		delete(files, "probe_arm64.s")
+		files[assembly] = "//go:build race || msan || asan\n\n#include \"go_asm.h\"\nTEXT ·Probe(SB),$0-8\nMOVQ $const_Imported, AX\nMOVQ AX, ret+0(FP)\nRET\n"
+	}
+	for name, source := range files {
+		file := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".s") {
+			input.Headers[name] = source
+		}
+	}
+	for _, folder := range []string{".", "dep"} {
+		entries, err := os.ReadDir(filepath.Join(dir, folder))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, entry := range entries {
+			input.Directories[folder] = append(input.Directories[folder], entry.Name())
+		}
+		sort.Strings(input.Directories[folder])
+	}
+	input.AsmFiles = []string{assembly}
+	sources, err := gotoolprofile.CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := gotoolprofile.PlanInstrumentationOriginalPackage(input, sources, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wrapped, err := gotoolprofile.NewInstrumentationConsumerInput(input, sources, marker, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return wrapped, ctx
+}
+
+func TestInstrumentationMetadataActualSameModeDependencyAndHeader(t *testing.T) {
+	for _, config := range []struct {
+		target string
+		mode   gotoolprofile.InstrumentationMode
+		cgo    string
+	}{
+		{"darwin/arm64", gotoolprofile.InstrumentationRace, "0"},
+		{"darwin/arm64", gotoolprofile.InstrumentationRace, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationMSan, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationASan, "1"},
+	} {
+		t.Run(config.target+"/"+string(config.mode)+"/cgo"+config.cgo, func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, config.target, config.mode, config.cgo)
+			consumer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof := consumer.Metadata
+			if len(proof.Headers) != 1 || proof.Status != "consumer_pending" || len(consumer.Packages) != 1 {
+				t.Fatalf("metadata became completion or lost actual packages: %#v", proof)
+			}
+			header := proof.Headers[0]
+			if header.Header.Definitions["const_Imported"] != "41" || header.Header.Definitions["Layout__size"] != "56" ||
+				!reflect.DeepEqual(header.CompilerFlags, append(append([]string(nil), input.Plan.BuildFlags...), input.Observation.BuildPlan.CodegenFlags...)) ||
+				len(header.Header.Imports) != 1 || header.Header.Imports[0].GoSHA256["dep/value_mode.go"] == "" ||
+				header.Header.Imports[0].GoSHA256["dep/value_plain.go"] != "" {
+				t.Fatalf("typed header/exports did not consume the same actual mode: %#v", header)
+			}
+			data, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := gotoolprofile.DecodeInstrumentationMetadata(strings.NewReader(string(data)), input, ".", nil); err != nil {
+				t.Fatal(err)
+			}
+			if err := gotoolprofile.ValidateGeneratedHeader(input.Original, header.Header, proof.Selection.Packages[0]); err == nil {
+				t.Fatal("mode header passed an ordinary reader")
+			}
+			checkInstrumentationMetadataMutations(t, input, data)
+			if err := consumer.Source.verifySources(); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func checkInstrumentationMetadataMutations(t *testing.T, input *gotoolprofile.InstrumentationConsumerInput, data []byte) {
+	t.Helper()
+	for name, mutate := range map[string]func(*gotoolprofile.InstrumentationMetadataProof){
+		"ordinary protocol":       func(p *gotoolprofile.InstrumentationMetadataProof) { p.Protocol = gotoolprofile.MetadataProtocol },
+		"ordinary identity":       func(p *gotoolprofile.InstrumentationMetadataProof) { p.ModeProfileID = input.Original.ID },
+		"missing context":         func(p *gotoolprofile.InstrumentationMetadataProof) { p.InputSHA256 = "" },
+		"missing selection":       func(p *gotoolprofile.InstrumentationMetadataProof) { p.Selection = nil },
+		"missing header":          func(p *gotoolprofile.InstrumentationMetadataProof) { p.Headers = nil },
+		"missing original export": func(p *gotoolprofile.InstrumentationMetadataProof) { p.OriginalExportSHA256 = "" },
+		"missing invocation":      func(p *gotoolprofile.InstrumentationMetadataProof) { p.InvocationConfigSHA256 = nil },
+		"ordinary load flags":     func(p *gotoolprofile.InstrumentationMetadataProof) { p.LoadBuildFlags = []string{"-mod=readonly"} },
+		"ordinary vet flags": func(p *gotoolprofile.InstrumentationMetadataProof) {
+			p.VetArgs = []string{"vet", "-asmdecl", input.Plan.PackagePath}
+		},
+		"missing dependencies": func(p *gotoolprofile.InstrumentationMetadataProof) { p.Dependencies = nil },
+		"changed dependency": func(p *gotoolprofile.InstrumentationMetadataProof) {
+			p.Dependencies[0].Source.ExportSHA256 = strings.Repeat("0", 64)
+		},
+		"ordinary header": func(p *gotoolprofile.InstrumentationMetadataProof) {
+			p.Headers[0].Header.Protocol = gotoolprofile.GeneratedHeaderProtocol
+		},
+		"missing mode flags": func(p *gotoolprofile.InstrumentationMetadataProof) { p.Headers[0].CompilerFlags = nil },
+		"unknown flags": func(p *gotoolprofile.InstrumentationMetadataProof) {
+			p.Headers[0].CompilerFlags = append(p.Headers[0].CompilerFlags, "-N")
+		},
+		"missing import": func(p *gotoolprofile.InstrumentationMetadataProof) { p.Headers[0].Header.Imports = nil },
+		"changed import source": func(p *gotoolprofile.InstrumentationMetadataProof) {
+			p.Headers[0].Header.Imports[0].GoSHA256["dep/value_mode.go"] = strings.Repeat("0", 64)
+		},
+		"claim pass": func(p *gotoolprofile.InstrumentationMetadataProof) { p.Status = "passed" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.InstrumentationMetadataProof
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := gotoolprofile.ValidateInstrumentationMetadata(input, ".", nil, &changed); err == nil {
+				t.Fatal("mode metadata accepted changed or downgraded context/consumption")
+			}
+		})
+	}
+	for _, bad := range []string{string(data) + "{}", strings.Replace(string(data), "\"protocol\":", "\"unknown\":true,\"protocol\":", 1)} {
+		if _, err := gotoolprofile.DecodeInstrumentationMetadata(strings.NewReader(bad), input, ".", nil); err == nil {
+			t.Fatal("mode metadata accepted trailing or unknown JSON")
+		}
+	}
+}
+
+func TestInstrumentationMetadataActualStandardLibraryClosure(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	source := strings.Replace(input.Original.Headers["mode.go"], "import \"example.invalid/modeheader/dep\"", "import (\"example.invalid/modeheader/dep\"; \"math/bits\")", 1)
+	source += "const NativeWord = bits.UintSize\n"
+	if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, "mode.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Headers["mode.go"], input.Original.Sources["mode.go"] = source, featureBytesSHA256([]byte(source))
+	replanInstrumentationMetadataFixture(t, input)
+	consumer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if consumer.Metadata.Headers[0].Header.Definitions["const_NativeWord"] != "64" || len(consumer.Metadata.Dependencies) < 2 {
+		t.Fatal("metadata omitted actual same-mode standard-library dependency exports")
+	}
+	if err := gotoolprofile.ValidateInstrumentationMetadata(input, ".", nil, consumer.Metadata); err != nil {
+		t.Fatal(err)
+	}
+	for _, dep := range consumer.Metadata.Dependencies {
+		if dep.Source.PackagePath == "math/bits" && dep.Source.SourceRole != "stdlib" {
+			t.Fatal("standard-library source was relabeled as an external module")
+		}
+	}
+}
+
+func replanInstrumentationMetadataFixture(t *testing.T, input *gotoolprofile.InstrumentationConsumerInput) {
+	t.Helper()
+	var err error
+	input.Sources, err = gotoolprofile.CaptureInstrumentationOriginalSourceInventory(input.Original, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.Plan, err = gotoolprofile.PlanInstrumentationOriginalPackage(input.Original, input.Sources, input.Observation.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstrumentationMetadataRejectsActualDependencyAndRoutingChanges(t *testing.T) {
+	for _, scenario := range []string{"dependency during load", "ordinary load flags", "missing dependency export", "dependency after capture", "invocation after capture"} {
+		t.Run(scenario, func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+			loader := func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+				if scenario == "dependency during load" && config.Mode&packages.NeedExportFile != 0 {
+					if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, "dep/value_mode.go"), []byte("//go:build race || msan || asan\n\npackage dep\nconst Value = 41\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if scenario == "ordinary load flags" {
+					config.BuildFlags = []string{"-mod=readonly"}
+				}
+				pkgs, err := packages.Load(config, patterns...)
+				if scenario == "missing dependency export" && config.Mode&packages.NeedExportFile != 0 && len(pkgs) != 0 {
+					for _, dep := range pkgs[0].Imports {
+						dep.ExportFile = ""
+					}
+				}
+				return pkgs, err
+			}
+			consumer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), loader)
+			if strings.HasSuffix(scenario, "after capture") {
+				if err != nil {
+					t.Fatal(err)
+				}
+				file := "dep/value_mode.go"
+				if scenario == "invocation after capture" {
+					file = "go.mod"
+				}
+				if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, file), []byte("changed actual original bytes\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				err = consumer.verifySources()
+			}
+			if err == nil {
+				t.Fatal("mode metadata accepted changed source/export/flags or caller configuration")
+			}
+		})
+	}
+}
+
+func TestInstrumentationMetadataKeepsIndependentInvocationAndActualModuleIdentity(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	input.Original.Version = "v1.0.0"
+	if _, err := gotoolprofile.PlanInstrumentationOriginalPackage(input.Original, input.Sources, input.Observation.Early, ".", nil); err == nil {
+		t.Fatal("versioned owned source was accepted as an authenticated external identity")
+	}
+	invocation, env := instrumentationVersionedFixture(t, ctx, input)
+	replanInstrumentationMetadataFixture(t, input)
+	consumer, err := captureInstrumentationMetadata(ctx, input, invocation, env, t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := consumer.Metadata.Selection.Packages[0]
+	if selected.ModulePath != input.Original.Module || selected.ModuleVersion != "v1.0.0" ||
+		selected.SourceRole != "module" || consumer.Source.Dir == consumer.Source.WorkDir ||
+		consumer.Metadata.InvocationConfigSHA256["go.mod"] == input.Original.Sources["go.mod"] {
+		t.Fatal("independent invocation was confused with the actual selected fixture source module")
+	}
+	// This is an explicit synthetic fileproxy fixture, not official-SumDB
+	// evidence. It exercises actual packages.Load Module/Replace boundaries.
+	for _, scenario := range []string{"selected version", "replacement directory"} {
+		t.Run(scenario, func(t *testing.T) {
+			load := func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+				pkgs, err := packages.Load(config, patterns...)
+				if config.Mode&packages.NeedExportFile != 0 && len(pkgs) != 0 {
+					if scenario == "selected version" {
+						pkgs[0].Module.Version = "v1.0.1"
+					} else {
+						pkgs[0].Module.Replace = &packages.Module{Path: input.Original.Module, Dir: t.TempDir()}
+					}
+				}
+				return pkgs, err
+			}
+			if _, err := captureInstrumentationMetadata(ctx, input, invocation, env, t.TempDir(), load); err == nil {
+				t.Fatal("actual mode metadata accepted redirected module/version provenance")
+			}
+		})
+	}
+}
+
+func instrumentationVersionedFixture(t *testing.T, ctx context.Context, input *gotoolprofile.InstrumentationConsumerInput) (string, []string) {
+	t.Helper()
+	proxy, invocation := t.TempDir(), t.TempDir()
+	prefix := input.Original.Module + "@" + input.Original.Version + "/"
+	var archive bytes.Buffer
+	writer := zip.NewWriter(&archive)
+	for name := range input.Original.Sources {
+		data, err := os.ReadFile(filepath.Join(input.Original.SourceRoot, filepath.FromSlash(name)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		member, err := writer.Create(prefix + name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := member.Write(data); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	mod, err := os.ReadFile(filepath.Join(input.Original.SourceRoot, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	versionDir := filepath.Join(proxy, filepath.FromSlash(input.Original.Module), "@v")
+	if err := os.MkdirAll(versionDir, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for suffix, data := range map[string][]byte{
+		".mod": mod, ".zip": archive.Bytes(),
+		".info": []byte(`{"Version":"v1.0.0","Time":"2026-01-01T00:00:00Z"}`),
+	} {
+		if err := os.WriteFile(filepath.Join(versionDir, input.Original.Version+suffix), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	caller := "module example.invalid/invocation\n\ngo 1.24\n\nrequire " + input.Original.Module + " " + input.Original.Version + "\n"
+	if err := os.WriteFile(filepath.Join(invocation, "go.mod"), []byte(caller), 0600); err != nil {
+		t.Fatal(err)
+	}
+	modules := t.TempDir()
+	// Go deliberately makes extracted ZIP directories read-only. Restore only
+	// this owned fixture cache's directory permissions after all source guards,
+	// before testing.TempDir removes it; no shared module cache is touched.
+	t.Cleanup(func() {
+		if err := filepath.WalkDir(modules, func(name string, entry fs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if entry.IsDir() {
+				return os.Chmod(name, 0700)
+			}
+			return nil
+		}); err != nil {
+			t.Errorf("owned fileproxy cache cleanup: %v", err)
+		}
+	})
+	proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := featureEnvironment(os.Environ(), map[string]string{
+		"GOPROXY": proxyURL, "GOSUMDB": "off",
+		"GOMODCACHE": modules, "GOPATH": t.TempDir(),
+	})
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, invocation, env, "go", "mod", "download", "-json", input.Original.Module+"@"+input.Original.Version)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("synthetic exact fileproxy download: %v; %s; %s", err, stdout, stderr)
+	}
+	var downloaded struct{ Dir string }
+	if err := json.Unmarshal(stdout, &downloaded); err != nil || downloaded.Dir == "" {
+		t.Fatalf("synthetic exact extraction: %v", err)
+	}
+	input.Original.SourceRoot, input.Original.SourceModule = downloaded.Dir, input.Original.Module
+	return invocation, env
+}
diff --git a/cmd/plan9asmll/instrumentation_object_consumer.go b/cmd/plan9asmll/instrumentation_object_consumer.go
new file mode 100644
index 000000000..ec0e94bb6
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_object_consumer.go
@@ -0,0 +1,302 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// This standalone bounded consumer deliberately has no ordinary CLI/report
+// adapter. It cannot satisfy a candidate until the complete mode denominator
+// and all external source/context protocols are integrated independently.
+func consumeInstrumentationAssembly(ctx context.Context, input *gotoolprofile.InstrumentationConsumerInput, producer *gotoolprofile.InstrumentationMetadataProof, invocation string, env []string, output string) (*gotoolprofile.InstrumentationConsumptionProof, *gotoolprofile.InstrumentationLLVMTool, error) {
+	if input == nil || input.Plan == nil {
+		return nil, nil, fmt.Errorf("missing original instrumented source scope")
+	}
+	plan := input.Plan
+	if err := gotoolprofile.ValidateInstrumentationMetadata(input, plan.PackageDirectory, plan.CustomTags, producer); err != nil {
+		return nil, nil, err
+	}
+	consumer, err := captureInstrumentationMetadata(ctx, input, invocation, env, output, packages.Load)
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := gotoolprofile.ValidateInstrumentationMetadataAgreement(input, producer, consumer.Metadata, plan.PackageDirectory, plan.CustomTags); err != nil {
+		return nil, nil, err
+	}
+	cfg, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		return nil, nil, err
+	}
+	cfg.Context = ctx
+	version, stderr, err := gotoolprofile.RunBounded(ctx, invocation, consumer.Source.Env, cfg.LLC, "--version")
+	if err != nil || len(stderr) != 0 {
+		return nil, nil, fmt.Errorf("actual LLVM22 tool identity: %v; %s", err, stderr)
+	}
+	toolSHA, err := gotoolprofile.FileSHA256(cfg.LLC)
+	if err != nil {
+		return nil, nil, err
+	}
+	goos, goarch, _ := strings.Cut(plan.Target, "/")
+	triple := targetTriple(goos, goarch)
+	if triple == "" {
+		return nil, nil, fmt.Errorf("actual mode source has no bound LLVM target route")
+	}
+	tools := &gotoolprofile.InstrumentationLLVMTool{Version: string(version), SHA256: toolSHA, Triple: triple}
+	proof := &gotoolprofile.InstrumentationConsumptionProof{
+		Protocol: gotoolprofile.InstrumentationConsumptionProtocol, ModeProfileID: input.ID,
+		InputSHA256: gotoolprofile.InstrumentationConsumerInputSHA256(input), MetadataSHA256: gotoolprofile.InstrumentationMetadataSHA256(producer),
+		Metadata: consumer.Metadata, LLVM: tools, Status: "llvm_objects_only",
+	}
+	arch, err := toPlan9Arch(goarch)
+	if err != nil {
+		return nil, nil, err
+	}
+	pkg, selected := consumer.Packages[0], consumer.Metadata.Selection.Packages[0]
+	resolve := resolveSymFunc(pkg.PkgPath)
+	artifactBudget := &gotoolprofile.InstrumentationLLVMArtifactBudget{}
+	consumer.ArtifactRoot = output
+	cfg.nativeListingMode = consumer
+	for index, name := range plan.SFiles {
+		if err := consumer.verifySources(); err != nil {
+			return nil, nil, err
+		}
+		asm := filepath.Join(consumer.Source.Dir, filepath.FromSlash(name))
+		cppSource := consumer.Source
+		var expandedOperands []gotoolprofile.CPPPackageSearchMiss
+		if consumer.Source.Input.CPPOriginals != nil {
+			header, err := gotoolprofile.CanonicalGeneratedHeader(consumer.Metadata.Headers[0].Header.Definitions)
+			if err != nil {
+				return nil, nil, err
+			}
+			actualInput, required, err := gotoolprofile.CPPOriginalExecutionInput(consumer.Source.Input, name, pkg.PkgPath, selected.Macros.Defines, header)
+			if err != nil {
+				return nil, nil, err
+			}
+			copy := *consumer.Source
+			copy.Input = actualInput
+			cppSource, expandedOperands = &copy, required
+		}
+		expanded, inputs, err := cppSource.preprocessCPPWithHeader(asm, pkg.PkgPath, selected.Macros.Defines, func() ([]byte, error) {
+			return gotoolprofile.CanonicalGeneratedHeader(consumer.Metadata.Headers[0].Header.Definitions)
+		})
+		if err != nil {
+			return nil, nil, err
+		}
+		imports := make(map[string]*types.Package)
+		for path, dep := range pkg.Imports {
+			imports[path] = dep.Types
+		}
+		typed := plan9asm.ExpandGoAssemblySource(plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Imports: imports}, expanded, goarch)
+		if string(typed) != string(expanded) {
+			return nil, nil, fmt.Errorf("mode consumer requires native full-header expansion, not an unproved typed fallback")
+		}
+		ll := filepath.Join(output, fmt.Sprintf("instrumented-%04d.ll", index))
+		task := asmTask{AsmFile: asm, OutLL: ll}
+		fileCfg := cfg
+		cpp := gotoolprofile.CPPProof{File: name, Emission: "assembly", Inputs: inputs,
+			ExpandedSearchMisses: expandedOperands,
+			ExpandedSHA256:       featureBytesSHA256(expanded), TypedExpandedSHA256: featureBytesSHA256(typed)}
+		file, err := plan9asm.ParseWithDefines(arch, string(typed), selected.Macros.Defines)
+		if err != nil {
+			if err.Error() != "no TEXT directive found" {
+				return nil, nil, err
+			}
+			cpp.EmptyAssembly, err = proveEmptyAssembly(pkg, task, plan.Target, selected.Macros.Defines, fileCfg)
+			if err != nil {
+				return nil, nil, err
+			}
+			cpp.Emission = "symbol_free"
+			fileCfg.emptyAssembly = cpp.EmptyAssembly
+			file = &plan9asm.File{Arch: arch}
+		} else if len(file.Funcs) == 0 {
+			cpp.DataOnlyAssembly, err = proveDataOnlyAssembly(pkg, task, file, plan.Target, selected.Macros.Defines, fileCfg)
+			if err != nil {
+				return nil, nil, err
+			}
+			cpp.Emission = "data_only"
+		}
+		sigs, sizes, err := sigsForAsmFile(pkg, file, resolve, goarch)
+		if err != nil {
+			return nil, nil, err
+		}
+		decls, err := captureInstrumentationDeclarations(input, pkg, file, resolve, goarch, sigs)
+		if err != nil {
+			return nil, nil, err
+		}
+		if err := validateDeclaredTextArgSizes(file, resolve, sizes, goarch); err != nil {
+			return nil, nil, err
+		}
+		contents, err := captureInstrumentationCPPContents(consumer, inputs)
+		if err != nil {
+			return nil, nil, err
+		}
+		if err := translateAndCompileModule(file, triple, goarch, task, false, fileCfg, resolve, sigs); err != nil {
+			return nil, nil, err
+		}
+		artifacts, err := gotoolprofile.CaptureInstrumentationLLVMArtifacts(output, index, artifactBudget)
+		if err != nil {
+			return nil, nil, err
+		}
+		irSHA, objectSHA := artifacts.IR.SHA256, artifacts.Object.SHA256
+		consumer.Artifacts = append(consumer.Artifacts, *artifacts)
+		proof.Files = append(proof.Files, gotoolprofile.InstrumentationAssemblyFile{
+			CPP:            cpp,
+			ExpandedSource: string(expanded), TypedSource: string(typed), InputContents: contents, Declarations: decls,
+			Output:    gotoolprofile.OutputProof{File: name, Part: filepath.Base(ll), IR: irSHA, Object: objectSHA},
+			Artifacts: artifacts,
+		})
+		after, afterInputs, err := cppSource.preprocessCPPWithHeader(asm, pkg.PkgPath, selected.Macros.Defines, func() ([]byte, error) {
+			return gotoolprofile.CanonicalGeneratedHeader(consumer.Metadata.Headers[0].Header.Definitions)
+		})
+		if err != nil || string(after) != string(expanded) || !reflect.DeepEqual(afterInputs, inputs) {
+			return nil, nil, fmt.Errorf("mode CPP graph changed during LLVM consumption: %v", err)
+		}
+		if err := consumer.verifySources(); err != nil {
+			return nil, nil, err
+		}
+	}
+	if err := consumer.reobserve(output); err != nil {
+		return nil, nil, err
+	}
+	actualSHA, err := gotoolprofile.FileSHA256(cfg.LLC)
+	if err != nil || actualSHA != tools.SHA256 {
+		return nil, nil, fmt.Errorf("LLVM22 compiler changed during mode consumption")
+	}
+	if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer, tools, plan.PackageDirectory, plan.CustomTags, proof); err != nil {
+		return nil, nil, err
+	}
+	return proof, tools, nil
+}
+
+func captureInstrumentationDeclarations(input *gotoolprofile.InstrumentationConsumerInput, pkg *packages.Package, file *plan9asm.File, resolve func(string) string, goarch string, sigs map[string]plan9asm.FuncSig) ([]gotoolprofile.InstrumentationDeclarationProof, error) {
+	result := make([]gotoolprofile.InstrumentationDeclarationProof, 0, len(file.Funcs))
+	for _, function := range file.Funcs {
+		symbol := resolve(function.Sym)
+		derived, _, found, err := tryDeclSig(pkg.Types.Scope(), function.Sym, symbol, nil, goarch, pkg.TypesSizes, false)
+		if err != nil || !found || strings.Contains(function.Sym, "<") || !reflect.DeepEqual(derived, sigs[symbol]) {
+			return nil, fmt.Errorf("mode entry requires its actual ordinary typed Go declaration: %s: %v", symbol, err)
+		}
+		proof := gotoolprofile.InstrumentationDeclarationProof{Symbol: symbol}
+		name := strings.TrimPrefix(symbol, pkg.PkgPath+".")
+		object, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			return nil, fmt.Errorf("mode declaration is not an actual Go function")
+		}
+		proof.GoType = types.TypeString(object.Type(), func(pkg *types.Package) string { return pkg.Path() })
+		for _, source := range input.Plan.GoFiles {
+			set := token.NewFileSet()
+			parsed, err := parser.ParseFile(set, source, input.Sources.Contents[source], 0)
+			if err != nil {
+				return nil, err
+			}
+			for _, declaration := range parsed.Decls {
+				fn, ok := declaration.(*ast.FuncDecl)
+				if !ok || fn.Name.Name != name {
+					continue
+				}
+				if proof.File != "" || fn.Body != nil || fn.Recv != nil {
+					return nil, fmt.Errorf("mode entry has no unique original bodyless declaration")
+				}
+				proof.File = source
+				proof.DeclarationSHA256, err = gotoolprofile.ASTSHA(set, fn)
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+		proof.Layout, err = json.Marshal(derived)
+		if err != nil || proof.File == "" {
+			return nil, fmt.Errorf("mode layout has no bound selected declaration: %v", err)
+		}
+		result = append(result, proof)
+	}
+	return result, nil
+}
+
+// These are declaration observations, not synthetic TEXT/frame source. The
+// actual Go types/export load supplies every layout; parsed original assembly
+// separately determines which of them the LLVM consumer needs.
+func captureInstrumentationPackageDeclarations(input *gotoolprofile.InstrumentationConsumerInput, pkg *packages.Package) ([]gotoolprofile.InstrumentationDeclarationProof, error) {
+	_, goarch, _ := strings.Cut(input.Plan.Target, "/")
+	file := &plan9asm.File{}
+	sigs := make(map[string]plan9asm.FuncSig)
+	resolve := resolveSymFunc(pkg.PkgPath)
+	for _, name := range input.Plan.GoFiles {
+		parsed, err := parser.ParseFile(token.NewFileSet(), name, input.Sources.Contents[name], 0)
+		if err != nil {
+			return nil, err
+		}
+		for _, declaration := range parsed.Decls {
+			fn, ok := declaration.(*ast.FuncDecl)
+			if !ok || fn.Body != nil || fn.Recv != nil {
+				continue
+			}
+			sym := "·" + fn.Name.Name
+			derived, _, found, err := tryDeclSig(pkg.Types.Scope(), sym, resolve(sym), nil, goarch, pkg.TypesSizes, false)
+			if err != nil || !found {
+				return nil, fmt.Errorf("actual mode declaration has an unproved native/variadic layout: %s: %v", name, err)
+			}
+			file.Funcs = append(file.Funcs, plan9asm.Func{Sym: sym})
+			sigs[resolve(sym)] = derived
+		}
+	}
+	proofs, err := captureInstrumentationDeclarations(input, pkg, file, resolve, goarch, sigs)
+	if err != nil {
+		return nil, err
+	}
+	sort.Slice(proofs, func(i, j int) bool { return proofs[i].Symbol < proofs[j].Symbol })
+	return proofs, nil
+}
+
+func captureInstrumentationCPPContents(consumer *instrumentationMetadataConsumer, inputs map[string]string) (map[string]string, error) {
+	result := make(map[string]string)
+	total := 0
+	for id, digest := range inputs {
+		origin, name, _ := strings.Cut(id, "/")
+		limit := gotoolprofile.InstrumentationCPPInputByteLimit(id)
+		var data []byte
+		var err error
+		if origin == "generated" {
+			data, err = gotoolprofile.CanonicalGeneratedHeader(consumer.Metadata.Headers[0].Header.Definitions)
+		} else {
+			root := consumer.Source.Dir
+			if origin == "tool" {
+				root = consumer.Source.Root
+			}
+			physical, sourceErr := gotoolprofile.CPPRegularSource(root, name)
+			if sourceErr != nil {
+				return nil, sourceErr
+			}
+			opened, openErr := os.Open(physical)
+			if openErr != nil {
+				return nil, openErr
+			}
+			data, err = io.ReadAll(io.LimitReader(opened, int64(limit)+1))
+			closeErr := opened.Close()
+			if err == nil {
+				err = closeErr
+			}
+		}
+		total += len(data)
+		if err != nil || len(data) > limit || total > 16<<20 || featureBytesSHA256(data) != digest {
+			return nil, fmt.Errorf("mode active CPP bytes changed or exceeded their bounded proof: %v", err)
+		}
+		result[id] = string(data)
+	}
+	return result, consumer.verifySources()
+}
diff --git a/cmd/plan9asmll/instrumentation_objects_go127_test.go b/cmd/plan9asmll/instrumentation_objects_go127_test.go
new file mode 100644
index 000000000..79d7c72bf
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_objects_go127_test.go
@@ -0,0 +1,163 @@
+//go:build go1.27
+
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationObjectsRequireIndependentModeMetadataAndActualLLVM(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	output := instrumentationObjectFixtureOutput(t, input)
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proof.Status != "llvm_objects_only" || len(proof.Files) != 1 || proof.Files[0].Output.Object == "" {
+		t.Fatalf("mode proof did not retain its actual object/nonruntime scope: %#v", proof)
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := gotoolprofile.DecodeInstrumentationConsumption(strings.NewReader(string(data)), input, producer.Metadata, tools, ".", nil); err != nil {
+		t.Fatal(err)
+	}
+	recordInstrumentationObjectFixture(t, output, input, producer.Metadata, tools, proof)
+	var ordinary gotoolprofile.SelectionProof
+	if err := json.Unmarshal(data, &ordinary); err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateSelection(input.Original, &ordinary, nil, true); err == nil {
+		t.Fatal("mode object proof was accepted by an ordinary translation reader")
+	}
+	for name, mutate := range map[string]func(*gotoolprofile.InstrumentationConsumptionProof){
+		"old artifact consumer": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			p.Protocol = "actual_go_instrumentation_llvm_objects_v1"
+		},
+		"deleted artifact role": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Artifacts = nil },
+		"paired role downgrade": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			p.Protocol = "actual_go_instrumentation_llvm_objects_v1"
+			p.Files[0].Artifacts = nil
+		},
+		"source artifact role":      func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Artifacts.IR.Role = "module_source" },
+		"changed artifact bytes":    func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Artifacts.IR.Bytes = 0 },
+		"foreign target triple":     func(p *gotoolprofile.InstrumentationConsumptionProof) { p.LLVM.Triple = "aarch64-unknown-linux-gnu" },
+		"ordinary protocol":         func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Protocol = gotoolprofile.ConsumerProtocol },
+		"ordinary ID":               func(p *gotoolprofile.InstrumentationConsumptionProof) { p.ModeProfileID = input.Original.ID },
+		"missing mode and metadata": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.ModeProfileID = ""; p.Metadata = nil },
+		"missing metadata binding":  func(p *gotoolprofile.InstrumentationConsumptionProof) { p.MetadataSHA256 = "" },
+		"missing sibling":           func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files = nil },
+		"missing original CPP": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			delete(p.Files[0].CPP.Inputs, "module/probe_arm64.s")
+		},
+		"missing generated CPP": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			delete(p.Files[0].CPP.Inputs, "generated/"+input.Plan.PackagePath+"/go_asm.h")
+		},
+		"changed typed source":       func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].TypedSource += "\n" },
+		"missing actual declaration": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Declarations = nil },
+		"unknown declaration":        func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Declarations[0].Symbol += "Unknown" },
+		"changed declaration": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			p.Files[0].Declarations[0].DeclarationSHA256 = strings.Repeat("0", 64)
+		},
+		"changed typed layout": func(p *gotoolprofile.InstrumentationConsumptionProof) {
+			p.Files[0].Declarations[0].Layout = json.RawMessage(`{"Name":"example.invalid/modeheader.Probe","Ret":"i8"}`)
+		},
+		"missing object":       func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Output.Object = "" },
+		"changed output scope": func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Files[0].Output.File = "unknown.s" },
+		"changed LLVM":         func(p *gotoolprofile.InstrumentationConsumptionProof) { p.LLVM.SHA256 = strings.Repeat("0", 64) },
+		"claim runtime":        func(p *gotoolprofile.InstrumentationConsumptionProof) { p.Status = "passed" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.InstrumentationConsumptionProof
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, &changed); err == nil {
+				t.Fatal("mode consumer accepted deletion/relabel or missing actual evidence")
+			}
+		})
+	}
+}
+
+func TestInstrumentationObjectsActualModeAndCGOFamily(t *testing.T) {
+	for _, config := range []struct {
+		target string
+		mode   gotoolprofile.InstrumentationMode
+		cgo    string
+	}{
+		{"darwin/arm64", gotoolprofile.InstrumentationRace, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationMSan, "1"},
+		{"linux/arm64", gotoolprofile.InstrumentationASan, "1"},
+	} {
+		t.Run(config.target+"/"+string(config.mode), func(t *testing.T) {
+			input, ctx := instrumentationMetadataFixture(t, config.target, config.mode, config.cgo)
+			producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+			if err != nil {
+				t.Fatal(err)
+			}
+			output := instrumentationObjectFixtureOutput(t, input)
+			proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(proof.Files) != 1 || !strings.Contains(proof.Files[0].TypedSource, "$41") ||
+				proof.ModeProfileID != input.ID || proof.Metadata.Selection.Packages[0].Macros.FeatureID != input.ID {
+				t.Fatal("actual mode/header/layout was not consumed by the same selected original assembly")
+			}
+			if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err != nil {
+				t.Fatal(err)
+			}
+			recordInstrumentationObjectFixture(t, output, input, producer.Metadata, tools, proof)
+		})
+	}
+}
+
+// Optional ignored artifacts retain the actual inputs, object and independently
+// read producer/consumer proofs. This does not change test or proof semantics.
+func instrumentationObjectFixtureOutput(t *testing.T, input *gotoolprofile.InstrumentationConsumerInput) string {
+	t.Helper()
+	root := os.Getenv("PLAN9ASM_INSTRUMENTATION_ARTIFACT_DIR")
+	if root == "" {
+		return t.TempDir()
+	}
+	if !filepath.IsAbs(root) {
+		t.Fatal("instrumentation artifact root must be an explicit absolute owned directory")
+	}
+	if err := os.MkdirAll(root, 0700); err != nil {
+		t.Fatal(err)
+	}
+	early := input.Observation.Early
+	prefix := strings.ReplaceAll(early.Target, "/", "-") + "-" + string(early.Mode) + "-cgo" + early.CGOEnabled + "-"
+	output, err := os.MkdirTemp(root, prefix)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("retained mode object fixture: %s", output)
+	return output
+}
+
+func recordInstrumentationObjectFixture(t *testing.T, output string, input *gotoolprofile.InstrumentationConsumerInput, producer *gotoolprofile.InstrumentationMetadataProof, tools *gotoolprofile.InstrumentationLLVMTool, proof *gotoolprofile.InstrumentationConsumptionProof) {
+	t.Helper()
+	for name, value := range map[string]any{"input.json": input, "producer.json": producer, "llvm.json": tools, "consumption.json": proof} {
+		data, err := json.Marshal(value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(output, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/instrumentation_source_budget_go127_test.go b/cmd/plan9asmll/instrumentation_source_budget_go127_test.go
new file mode 100644
index 000000000..af1012313
--- /dev/null
+++ b/cmd/plan9asmll/instrumentation_source_budget_go127_test.go
@@ -0,0 +1,64 @@
+//go:build go1.27
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestInstrumentationObjectsLargeOriginalAssemblyRetainsCPPBytes(t *testing.T) {
+	input, ctx := instrumentationMetadataFixture(t, "darwin/arm64", gotoolprofile.InstrumentationRace, "0")
+	const assembly = "probe_arm64.s"
+	// Large generated files are legitimate source. Comment padding keeps this
+	// resource-bound regression cheap without inventing instruction coverage.
+	source := input.Sources.Contents[assembly] + strings.Repeat("// generated source padding\n", 120000)
+	if len(source) <= 2<<20 || len(source) >= 8<<20 {
+		t.Fatalf("fixture lost its large-source boundary: %d bytes", len(source))
+	}
+	if err := os.WriteFile(filepath.Join(input.Original.SourceRoot, assembly), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.Sources[assembly] = featureBytesSHA256([]byte(source))
+	inventory, err := gotoolprofile.CaptureInstrumentationOriginalSourceInventory(input.Original, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := gotoolprofile.PlanInstrumentationOriginalPackage(input.Original, inventory, input.Observation.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, err = gotoolprofile.NewInstrumentationConsumerInput(input.Original, inventory, input.Observation, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	producer, err := captureInstrumentationMetadata(ctx, input, input.Original.SourceRoot, os.Environ(), t.TempDir(), packages.Load)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, tools, err := consumeInstrumentationAssembly(ctx, input, producer.Metadata, input.Original.SourceRoot, os.Environ(), t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(proof.Files) != 1 || proof.Files[0].InputContents["module/"+assembly] != source || proof.Files[0].Output.Object == "" {
+		t.Fatal("large original source lost its whole-byte CPP or actual LLVM object witness")
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := gotoolprofile.DecodeInstrumentationConsumption(bytes.NewReader(data), input, producer.Metadata, tools, ".", nil); err != nil {
+		t.Fatal(err)
+	}
+	proof.Files[0].InputContents["module/"+assembly] += "// changed\n"
+	if err := gotoolprofile.ValidateInstrumentationConsumption(input, producer.Metadata, tools, ".", nil, proof); err == nil {
+		t.Fatal("large-source allowance erased independent original CPP byte binding")
+	}
+}
diff --git a/cmd/plan9asmll/llvm22_test.go b/cmd/plan9asmll/llvm22_test.go
index 62c4ddf6e..c30e2805d 100644
--- a/cmd/plan9asmll/llvm22_test.go
+++ b/cmd/plan9asmll/llvm22_test.go
@@ -3,15 +3,51 @@
 package main
 
 import (
+	"go/types"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
 )
 
+func TestCompileOneRejectsLLCWithoutObject(t *testing.T) {
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "asm_amd64.s")
+	if err := os.WriteFile(asm, []byte("TEXT ·run(SB),$0-0\n\tRET\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/fake",
+		Types:   types.NewPackage("example.com/fake", "fake"),
+		Imports: map[string]*packages.Package{},
+	}
+	out := filepath.Join(dir, "asm_amd64.s.ll")
+	object := strings.TrimSuffix(out, ".ll") + ".o"
+	if err := os.WriteFile(object, []byte("stale object"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	err := compileOne(
+		pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: asm, OutLL: out},
+		false, compileConfig{Enabled: true, LLC: fakeLLC(t, "LLVM version 22.1.8")},
+	)
+	if err == nil || !strings.Contains(err.Error(), "did not produce a nonempty object") {
+		t.Fatalf("compileOne() error = %v, want missing object failure", err)
+	}
+	if data, err := os.ReadFile(object); err != nil || string(data) != "stale object" {
+		t.Fatalf("failed attempt changed previous public object: %q, %v", data, err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatalf("failed object compilation published public IR: %v", err)
+	}
+}
+
 func TestResolveCompileConfigRequiresLLVM22(t *testing.T) {
 	llvm22 := fakeLLC(t, "LLVM version 22.1.8")
-	cfg, err := resolveCompileConfig(true, llvm22, false)
+	cfg, err := resolveCompileConfig(true, llvm22, false, 2)
 	if err != nil {
 		t.Fatalf("resolveCompileConfig(LLVM 22): %v", err)
 	}
@@ -20,7 +56,7 @@ func TestResolveCompileConfigRequiresLLVM22(t *testing.T) {
 	}
 
 	llvm23 := fakeLLC(t, "LLVM version 23.0.0")
-	if _, err := resolveCompileConfig(true, llvm23, false); err == nil || !strings.Contains(err.Error(), "requires LLVM 22") {
+	if _, err := resolveCompileConfig(true, llvm23, false, 2); err == nil || !strings.Contains(err.Error(), "requires LLVM 22") {
 		t.Fatalf("resolveCompileConfig(LLVM 23) error = %v, want LLVM 22 requirement", err)
 	}
 }
@@ -29,7 +65,7 @@ func TestResolveCompileConfigDoesNotFallbackToLLVM23(t *testing.T) {
 	dir := t.TempDir()
 	writeFakeLLC(t, filepath.Join(dir, "llc"), "LLVM version 23.0.0")
 	t.Setenv("PATH", dir)
-	if _, err := resolveCompileConfig(true, "", false); err == nil || !strings.Contains(err.Error(), "LLVM 22 llc is not found") {
+	if _, err := resolveCompileConfig(true, "", false, 2); err == nil || !strings.Contains(err.Error(), "LLVM 22 llc is not found") {
 		t.Fatalf("resolveCompileConfig(PATH llc=23) error = %v, want no LLVM 22 error", err)
 	}
 }
diff --git a/cmd/plan9asmll/lock_scalar_rmw_specs_test.go b/cmd/plan9asmll/lock_scalar_rmw_specs_test.go
new file mode 100644
index 000000000..474d47edc
--- /dev/null
+++ b/cmd/plan9asmll/lock_scalar_rmw_specs_test.go
@@ -0,0 +1,39 @@
+package main
+
+import "testing"
+
+func TestExtractSupportedOpsFindsCompleteScalarLOCKRMWFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps("../..", arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		widths := "BWL"
+		if arch == "amd64" {
+			widths += "Q"
+		}
+		count := 0
+		for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR", "INC", "DEC", "NEG", "NOT", "BTC", "BTR", "BTS"} {
+			for _, width := range widths {
+				if width == 'B' && (stem == "BTC" || stem == "BTR" || stem == "BTS") {
+					continue
+				}
+				opcode := stem + string(width)
+				if _, present := supported[opcode]; !present {
+					t.Error("complete typed RMW family omitted from supported-op extraction", arch, opcode)
+				}
+				count++
+			}
+		}
+		want := 39
+		if arch == "amd64" {
+			want = 53
+		}
+		if count != want {
+			t.Fatal("complete independent opcode denominator changed", arch, count)
+		}
+		if _, present := supported["LOCK"]; !present {
+			t.Fatal("source prefix was omitted from extraction", arch)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/madd_typed_specs_test.go b/cmd/plan9asmll/madd_typed_specs_test.go
new file mode 100644
index 000000000..d04023702
--- /dev/null
+++ b/cmd/plan9asmll/madd_typed_specs_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompletePackedMultiplyAddSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_maddword_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, contents := range map[string][]byte{
+		"amd64_maddword_forms.go": data,
+		"translate.go":            []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"PMADDWL", "PMADDUBSW", "VPMADDWD", "VPMADDUBSW"} {
+			if _, exists := supported[opcode]; !exists {
+				t.Fatalf("%s complete packed multiply-add extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/main.go b/cmd/plan9asmll/main.go
index 767c1093f..ab6691327 100644
--- a/cmd/plan9asmll/main.go
+++ b/cmd/plan9asmll/main.go
@@ -1,14 +1,21 @@
 package main
 
 import (
+	"bytes"
+	"context"
+	"crypto/sha256"
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"go/ast"
+	"go/parser"
+	"go/token"
 	"go/types"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"runtime"
 	"sort"
@@ -18,6 +25,10 @@ import (
 
 	"github.com/xgo-dev/llvm"
 	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/asmsig"
+	"github.com/xgo-dev/plan9asm/internal/goabi"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -35,29 +46,58 @@ type failItem struct {
 	UnsupportedHits []unsupportedHit `json:"unsupported_hits,omitempty"`
 }
 
+const targetNotApplicableGoTextArgSize = "go_text_arg_size_mismatch"
+
+type notApplicableItem struct {
+	PkgPath         string `json:"pkg_path"`
+	AsmFile         string `json:"asm_file"`
+	Kind            string `json:"kind"`
+	Symbol          string `json:"symbol"`
+	DeclaredArgSize int64  `json:"declared_arg_size"`
+	ExpectedArgSize int64  `json:"expected_arg_size"`
+	Reason          string `json:"reason"`
+}
+
+type asmABINotApplicableError struct {
+	Symbol          string
+	Goarch          string
+	DeclaredArgSize int64
+	ExpectedArgSize int64
+}
+
+func (e *asmABINotApplicableError) Error() string {
+	return fmt.Sprintf("%s: TEXT argument size is incompatible with the Go declaration on %s: got %d, want %d", e.Symbol, e.Goarch, e.DeclaredArgSize, e.ExpectedArgSize)
+}
+
 type opCount struct {
 	Op    string `json:"op"`
 	Count int    `json:"count"`
 }
 
 type unsupportedHit struct {
-	Op     string `json:"op"`
-	Line   int    `json:"line"`
-	Source string `json:"source"`
+	Op          string `json:"op"`
+	Line        int    `json:"line,omitempty"`
+	Source      string `json:"source"`
+	Function    string `json:"function,omitempty"`
+	Instruction int    `json:"instruction,omitempty"`
 }
 
 type runReport struct {
-	Goos           string     `json:"goos"`
-	Goarch         string     `json:"goarch"`
-	Patterns       []string   `json:"patterns"`
-	TotalPkgs      int        `json:"total_pkgs"`
-	AsmPackages    []string   `json:"asm_packages,omitempty"`
-	TotalAsm       int        `json:"total_asm"`
-	Success        int        `json:"success"`
-	Failed         int        `json:"failed"`
-	Duration       string     `json:"duration"`
-	UnsupportedOps []opCount  `json:"unsupported_ops,omitempty"`
-	Fails          []failItem `json:"fails,omitempty"`
+	Goos               string                 `json:"goos"`
+	Goarch             string                 `json:"goarch"`
+	Patterns           []string               `json:"patterns"`
+	TotalPkgs          int                    `json:"total_pkgs"`
+	AsmPackages        []string               `json:"asm_packages,omitempty"`
+	AsmFiles           []string               `json:"asm_files,omitempty"`
+	TotalAsm           int                    `json:"total_asm"`
+	Success            int                    `json:"success"`
+	NotApplicable      int                    `json:"not_applicable"`
+	Failed             int                    `json:"failed"`
+	Duration           string                 `json:"duration"`
+	UnsupportedOps     []opCount              `json:"unsupported_ops,omitempty"`
+	Fails              []failItem             `json:"fails,omitempty"`
+	NotApplicableItems []notApplicableItem    `json:"not_applicable_items,omitempty"`
+	FeatureSelection   *featureSelectionProof `json:"feature_selection,omitempty"`
 }
 
 type targetSpec struct {
@@ -71,54 +111,129 @@ type targetTasks struct {
 }
 
 type matrixReport struct {
-	Targets      []runReport `json:"targets"`
-	TotalTargets int         `json:"total_targets"`
-	TotalAsm     int         `json:"total_asm"`
-	Success      int         `json:"success"`
-	Failed       int         `json:"failed"`
+	Targets       []runReport `json:"targets"`
+	TotalTargets  int         `json:"total_targets"`
+	TotalAsm      int         `json:"total_asm"`
+	Success       int         `json:"success"`
+	NotApplicable int         `json:"not_applicable"`
+	Failed        int         `json:"failed"`
 }
 
 type compileConfig struct {
-	Enabled bool
-	LLC     string
-	KeepObj bool
+	Enabled  bool
+	LLC      string
+	KeepObj  bool
+	OptLevel int
+	// MaxFunctions bounds LLVM module size when object compilation is used
+	// only as a validation gate. Zero selects the production default.
+	MaxFunctions int
+	// MaxInstructions also bounds generated-source-heavy modules whose few
+	// functions each contain thousands of assembly instructions. A single
+	// oversized function stays intact and is checked on its own.
+	MaxInstructions      int
+	X86TailGroups        []plan9asm.X86TailGroup
+	Feature              *featureConsumer
+	FeaturePath          string
+	Context              context.Context
+	emptyAssembly        *gotoolprofile.EmptyAssemblyProof
+	nativeListingMode    *instrumentationMetadataConsumer
+	SignatureQuery       *gotoolprofile.SignatureQueryProof
+	x86CallerSelections  map[*packages.Package]*x86CallerPackageSelection
+	numericalOptions     *plan9asm.Options
+	ordinaryDeclarations *ordinaryDeclarationSource
+	acquireSDKNumerical  bool
+	diagnostics          *instructionDiagnostics
 }
 
 func main() {
 	var (
-		goos       = flag.String("goos", runtime.GOOS, "target GOOS")
-		goarch     = flag.String("goarch", runtime.GOARCH, "target GOARCH (386/amd64/arm/arm64/wasm)")
-		targets    = flag.String("targets", "", "comma-separated GOOS/GOARCH list (e.g. linux/amd64,windows/arm64)")
-		allTargets = flag.Bool("all-targets", false, "run the complete default Plan 9 target matrix")
-		patterns   = flag.String("patterns", "std", "comma-separated package patterns")
-		modulePath = flag.String("module-path", "", "only include packages owned by this module path")
-		outDir     = flag.String("out", "", "output dir for generated .ll files")
-		annotate   = flag.Bool("annotate", false, "emit source asm lines as IR comments")
-		limit      = flag.Int("limit", 0, "max number of asm files per target (0 means all)")
-		keepGoing  = flag.Bool("keep-going", true, "continue on per-file failures")
-		listOnly   = flag.Bool("list-only", false, "only print asm task list and exit")
-		compile    = flag.Bool("compile", false, "compile generated .ll to .o via llc")
-		llcPath    = flag.String("llc", "", "path to llc executable (auto-detect when empty)")
-		keepObj    = flag.Bool("keep-obj", false, "keep generated .o files when -compile is set")
-		strictLoad = flag.Bool("strict-load", false, "fail when go/packages reports any package loading error")
-		reportOut  = flag.String("report", "", "optional report json path")
-		repoRoot   = flag.String("repo-root", "../..", "repo root for extracting supported instruction set")
+		goos           = flag.String("goos", runtime.GOOS, "target GOOS")
+		goarch         = flag.String("goarch", runtime.GOARCH, "target GOARCH (386/amd64/arm/arm64/wasm)")
+		targets        = flag.String("targets", "", "comma-separated GOOS/GOARCH list (e.g. linux/amd64,windows/arm64)")
+		allTargets     = flag.Bool("all-targets", false, "run the complete default Plan 9 target matrix")
+		patterns       = flag.String("patterns", "std", "comma-separated package patterns")
+		asmFiles       = flag.String("asm-files", "", "comma-separated module-relative assembly files to exercise exactly")
+		buildTags      = flag.String("tags", "", "comma-separated Go build tags used to expose tagged assembly implementations")
+		modulePath     = flag.String("module-path", "", "only include packages owned by this module path")
+		outDir         = flag.String("out", "", "output dir for generated .ll files")
+		annotate       = flag.Bool("annotate", false, "emit source asm lines as IR comments")
+		limit          = flag.Int("limit", 0, "max number of asm files per target (0 means all)")
+		keepGoing      = flag.Bool("keep-going", true, "continue on per-file failures")
+		listOnly       = flag.Bool("list-only", false, "only print asm task list and exit")
+		compile        = flag.Bool("compile", false, "compile generated .ll to .o via llc")
+		llcPath        = flag.String("llc", "", "path to llc executable (auto-detect when empty)")
+		llcOptLevel    = flag.Int("llc-opt-level", 2, "LLVM llc optimization level (0-3)")
+		keepObj        = flag.Bool("keep-obj", false, "keep generated .o files when -compile is set")
+		strictLoad     = flag.Bool("strict-load", false, "fail when go/packages reports any package loading error")
+		reportOut      = flag.String("report", "", "optional report json path")
+		repoRoot       = flag.String("repo-root", "../..", "repo root for extracting supported instruction set")
+		featureProfile = flag.String("feature-profile", "", "explicit actual Go CPU profile and source proof (single target, ordinary external module only)")
+		featureTimeout = flag.Duration("feature-timeout", time.Hour, "deadline for the explicit feature-profile consumer")
+		metadataOnly   = flag.Bool("metadata-only", false, "private actual Go generated-header query; never translates assembly")
+		signatureQuery = flag.Bool("signature-source-query", false, "private ordinary-type/CPP missing-reference query; never emits LLVM")
 	)
+	instrumentationProfile := flag.String("instrumentation-profile", "", "private actual Go instrumentation source context; cannot supply ordinary profile evidence")
+	instrumentationDirectory := flag.String("instrumentation-package-dir", ".", "exact module-relative original instrumentation package directory")
+	instrumentationMetadata := flag.String("instrumentation-metadata", "", "independently captured same-mode metadata required for instrumentation object consumption")
 	flag.Parse()
 
 	pats := splitCSV(*patterns)
 	if len(pats) == 0 {
 		fatalf("empty -patterns")
 	}
+	tags := splitCSV(*buildTags)
+	exactAsmFiles := splitCSV(*asmFiles)
+	if err := validateExactAsmFiles(exactAsmFiles); err != nil {
+		fatalf("%v", err)
+	}
 
 	specs, err := resolveTargets(*goos, *goarch, *targets, *allTargets)
 	if err != nil {
 		fatalf("%v", err)
 	}
-	ccfg, err := resolveCompileConfig(*compile, *llcPath, *keepObj)
+	if requestedInstrumentationCLI(flag.CommandLine) {
+		if *featureTimeout <= 0 || *reportOut == "" {
+			fatalf("instrumentation consumption requires a positive deadline and its separate report")
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), *featureTimeout)
+		defer cancel()
+		result, err := runInstrumentationCLI(ctx, instrumentationCLIOptions{
+			Profile: *instrumentationProfile, Directory: *instrumentationDirectory, Metadata: *instrumentationMetadata,
+			OrdinaryProfile: *featureProfile, Targets: specs, Patterns: pats, Tags: tags, AsmFiles: exactAsmFiles,
+			Module: *modulePath, Output: *outDir, MetadataOnly: *metadataOnly, SignatureQuery: *signatureQuery,
+			Compile: *compile, KeepObject: *keepObj, OptLevel: *llcOptLevel, LLC: *llcPath,
+			AllTargets: *allTargets, ExplicitTargets: *targets != "", ListOnly: *listOnly, Limit: *limit,
+			StrictLoad: *strictLoad, KeepGoing: *keepGoing, Annotate: *annotate,
+		})
+		if err != nil {
+			fatalf("instrumentation consumer: %v", err)
+		}
+		writeReport(*reportOut, result)
+		return
+	}
+	if (*metadataOnly || *signatureQuery) && (*featureProfile == "" || *reportOut == "" || len(specs) != 1 || *compile || *listOnly || *limit != 0 || *allTargets || *metadataOnly && *signatureQuery) {
+		fatalf("metadata-only requires one explicit ordinary profile and cannot emit translation/list/matrix evidence")
+	}
+	ccfg, err := resolveCompileConfig(*compile, *llcPath, *keepObj, *llcOptLevel)
 	if err != nil {
 		fatalf("%v", err)
 	}
+	if *featureProfile == "" {
+		if *featureTimeout <= 0 {
+			fatalf("ordinary source consumption requires a positive deadline")
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), *featureTimeout)
+		defer cancel()
+		ccfg.Context = ctx
+	}
+	if *featureProfile != "" {
+		if len(specs) != 1 || *featureTimeout <= 0 {
+			fatalf("explicit feature profile requires one target and a positive deadline")
+		}
+		ctx, cancel := context.WithTimeout(context.Background(), *featureTimeout)
+		defer cancel()
+		ccfg.FeaturePath, ccfg.Context = *featureProfile, ctx
+	}
 
 	baseOut := *outDir
 	if baseOut == "" {
@@ -128,6 +243,23 @@ func main() {
 			baseOut = filepath.Join("_out", "plan9asmll")
 		}
 	}
+	if *metadataOnly {
+		metadata, err := queryGeneratedHeaders(specs[0], pats, tags, exactAsmFiles, *modulePath, baseOut, ccfg)
+		if err != nil {
+			fatalf("generated-header metadata: %v", err)
+		}
+		writeReport(*reportOut, metadata)
+		return
+	}
+	if *signatureQuery {
+		ccfg.SignatureQuery = &gotoolprofile.SignatureQueryProof{Protocol: gotoolprofile.SignatureQueryProtocol}
+		report, _, err := runOneTarget(specs[0], pats, tags, exactAsmFiles, *modulePath, baseOut, false, 0, false, false, true, *repoRoot, ccfg)
+		if err != nil || report.Failed != 0 {
+			fatalf("missing-signature preflight: %v (failed=%d)", err, report.Failed)
+		}
+		writeReport(*reportOut, ccfg.SignatureQuery)
+		return
+	}
 
 	allReports := make([]runReport, 0, len(specs))
 	taskLists := make([]targetTasks, 0, len(specs))
@@ -139,7 +271,7 @@ func main() {
 			runOutDir = filepath.Join(baseOut, targetID(spec))
 			fmt.Fprintf(os.Stderr, "\n== target %s ==\n", targetID(spec))
 		}
-		rep, tasks, err := runOneTarget(spec, pats, *modulePath, runOutDir, *annotate, *limit, *keepGoing, *listOnly, *strictLoad, *repoRoot, ccfg)
+		rep, tasks, err := runOneTarget(spec, pats, tags, exactAsmFiles, *modulePath, runOutDir, *annotate, *limit, *keepGoing, *listOnly, *strictLoad, *repoRoot, ccfg)
 		if err != nil {
 			fatalf("%s: %v", targetID(spec), err)
 		}
@@ -155,7 +287,7 @@ func main() {
 
 	if *listOnly {
 		var out any
-		if len(taskLists) == 1 {
+		if !useMatrixReport(*allTargets, *targets, len(taskLists)) {
 			out = taskLists[0].Tasks
 		} else {
 			out = taskLists
@@ -166,7 +298,7 @@ func main() {
 		return
 	}
 
-	if len(allReports) == 1 {
+	if !useMatrixReport(*allTargets, *targets, len(allReports)) {
 		writeReport(*reportOut, allReports[0])
 		if exitCode != 0 {
 			os.Exit(exitCode)
@@ -181,18 +313,31 @@ func main() {
 	for _, r := range allReports {
 		mr.TotalAsm += r.TotalAsm
 		mr.Success += r.Success
+		mr.NotApplicable += r.NotApplicable
 		mr.Failed += r.Failed
 	}
 	writeReport(*reportOut, mr)
 	if exitCode != 0 {
-		fmt.Fprintf(os.Stderr, "\nmatrix finished with failures: success=%d failed=%d total=%d\n", mr.Success, mr.Failed, mr.TotalAsm)
+		fmt.Fprintf(os.Stderr, "\nmatrix finished with failures: success=%d not_applicable=%d failed=%d total=%d\n", mr.Success, mr.NotApplicable, mr.Failed, mr.TotalAsm)
 		os.Exit(exitCode)
 	}
-	fmt.Fprintf(os.Stderr, "\nmatrix finished: success=%d total=%d\n", mr.Success, mr.TotalAsm)
+	fmt.Fprintf(os.Stderr, "\nmatrix finished: success=%d not_applicable=%d total=%d\n", mr.Success, mr.NotApplicable, mr.TotalAsm)
+}
+
+func useMatrixReport(allTargets bool, targets string, reportCount int) bool {
+	return allTargets || strings.TrimSpace(targets) != "" || reportCount != 1
 }
 
-func resolveCompileConfig(compile bool, llcPath string, keepObj bool) (compileConfig, error) {
-	cfg := compileConfig{Enabled: compile, LLC: strings.TrimSpace(llcPath), KeepObj: keepObj}
+func resolveCompileConfig(compile bool, llcPath string, keepObj bool, optLevel int) (compileConfig, error) {
+	if optLevel < 0 || optLevel > 3 {
+		return compileConfig{}, fmt.Errorf("-llc-opt-level must be between 0 and 3, got %d", optLevel)
+	}
+	cfg := compileConfig{
+		Enabled:  compile,
+		LLC:      strings.TrimSpace(llcPath),
+		KeepObj:  keepObj,
+		OptLevel: optLevel,
+	}
 	if !cfg.Enabled {
 		return cfg, nil
 	}
@@ -304,22 +449,72 @@ func targetID(t targetSpec) string {
 	return t.Goos + "-" + t.Goarch
 }
 
-func runOneTarget(spec targetSpec, pats []string, modulePath, outDir string, annotate bool, limit int, keepGoing bool, listOnly, strictLoad bool, repoRoot string, ccfg compileConfig) (runReport, []asmTask, error) {
+func runOneTarget(spec targetSpec, pats, buildTags, exactAsmFiles []string, modulePath, outDir string, annotate bool, limit int, keepGoing bool, listOnly, strictLoad bool, repoRoot string, ccfg compileConfig) (runReport, []asmTask, error) {
 	arch, err := toPlan9Arch(spec.Goarch)
 	if err != nil {
 		return runReport{}, nil, err
 	}
-	pkgs, err := loadPkgs(spec.Goos, spec.Goarch, pats, modulePath, strictLoad)
+	if ccfg.FeaturePath != "" {
+		if listOnly || limit != 0 {
+			return runReport{}, nil, fmt.Errorf("feature consumer requires the complete ordinary non-test package scope")
+		}
+		ccfg.Feature, err = loadFeatureConsumer(ccfg.Context, ccfg.FeaturePath, outDir, spec.Goos+"/"+spec.Goarch, modulePath, buildTags)
+		if err != nil {
+			return runReport{}, nil, err
+		}
+		strictLoad = true
+	}
+	var pkgs []*packages.Package
+	var loadEnvironment []string
+	if ccfg.Feature != nil && ccfg.Feature.Input.GeneratedHeaders != nil {
+		pkgs, err = loadGeneratedHeaderPackages(ccfg.Feature, pats, buildTags)
+		loadEnvironment = ccfg.Feature.Env
+	} else {
+		// Go treats _test.go specially, not similarly named assembly files.
+		// An explicit ordinary profile always loads non-test packages and
+		// proves their actual role below. Keep the legacy test-declaration
+		// lookup heuristic separate from that evidence-producing path.
+		includeTests := ccfg.Feature == nil && containsTestAssembly(exactAsmFiles)
+		pkgs, loadEnvironment, err = loadPkgsInEnvironment(spec.Goos, spec.Goarch, pats, buildTags, modulePath, strictLoad, includeTests, ccfg.Feature)
+	}
 	if err != nil {
 		return runReport{}, nil, fmt.Errorf("load packages: %w", err)
 	}
+	ccfg.x86CallerSelections = captureX86CallerSelectionsInEnvironment(pkgs, spec.Goos+"/"+spec.Goarch, loadEnvironment)
+	if ccfg.Feature != nil {
+		if err := ccfg.Feature.capturePackages(pkgs); err != nil {
+			return runReport{}, nil, err
+		}
+		if ccfg.Feature.Input.GeneratedHeaders != nil {
+			if err := ccfg.Feature.captureGeneratedMetadata(pkgs, buildTags, outDir); err != nil {
+				return runReport{}, nil, err
+			}
+		}
+	}
 	pkgByPath := map[string]*packages.Package{}
 	for _, p := range pkgs {
 		if p != nil && p.PkgPath != "" {
-			pkgByPath[p.PkgPath] = p
+			previous := pkgByPath[p.PkgPath]
+			if previous == nil || isTestVariantPackage(p) && !isTestVariantPackage(previous) {
+				pkgByPath[p.PkgPath] = p
+			}
+		}
+	}
+	tasks, asmPackages := collectAsmTasks(pkgs, outDir, exactAsmFiles)
+	if ccfg.Feature != nil {
+		var actual []string
+		for _, task := range tasks {
+			name, err := ccfg.Feature.sourceName(task.AsmFile)
+			if err != nil {
+				return runReport{}, nil, err
+			}
+			actual = append(actual, name)
+		}
+		sort.Strings(actual)
+		if len(actual) == 0 || !reflect.DeepEqual(actual, ccfg.Feature.Input.AsmFiles) {
+			return runReport{}, nil, fmt.Errorf("actual selected assembly differs from the exact profile scope")
 		}
 	}
-	tasks, asmPackages := collectAsmTasks(pkgs, outDir)
 	if limit > 0 && limit < len(tasks) {
 		tasks = tasks[:limit]
 	}
@@ -334,6 +529,15 @@ func runOneTarget(spec targetSpec, pats []string, modulePath, outDir string, ann
 		AsmPackages: asmPackages,
 		TotalAsm:    len(tasks),
 	}
+	if ccfg.Feature != nil {
+		rep.FeatureSelection = ccfg.Feature.Proof
+		if ccfg.SignatureQuery != nil {
+			ccfg.SignatureQuery.Selection = ccfg.Feature.Proof
+		}
+	}
+	for _, task := range tasks {
+		rep.AsmFiles = append(rep.AsmFiles, task.AsmFile)
+	}
 	if len(tasks) == 0 {
 		fmt.Fprintf(os.Stderr, "no asm files found for patterns=%v (%s/%s)\n", pats, spec.Goos, spec.Goarch)
 		return rep, nil, nil
@@ -361,11 +565,30 @@ func runOneTarget(spec targetSpec, pats []string, modulePath, outDir string, ann
 			}
 			continue
 		}
-		err := compileOne(pkg, arch, spec.Goarch, triple, t, annotate, ccfg)
+		diagnostics := instructionDiagnostics{supported: supportedOps}
+		fileConfig := ccfg
+		fileConfig.diagnostics = &diagnostics
+		err := compileOne(pkg, arch, spec.Goos, spec.Goarch, triple, t, annotate, fileConfig)
 		if err != nil {
+			var abiMismatch *asmABINotApplicableError
+			if errors.As(err, &abiMismatch) {
+				fmt.Fprintf(os.Stderr, "[%d/%d] N/A  %s\n", idx, len(tasks), t.AsmFile)
+				printFailureReason(abiMismatch.Error())
+				rep.NotApplicable++
+				rep.NotApplicableItems = append(rep.NotApplicableItems, notApplicableItem{
+					PkgPath:         t.PkgPath,
+					AsmFile:         t.AsmFile,
+					Kind:            targetNotApplicableGoTextArgSize,
+					Symbol:          abiMismatch.Symbol,
+					DeclaredArgSize: abiMismatch.DeclaredArgSize,
+					ExpectedArgSize: abiMismatch.ExpectedArgSize,
+					Reason:          abiMismatch.Error(),
+				})
+				continue
+			}
 			fmt.Fprintf(os.Stderr, "[%d/%d] FAIL %s\n", idx, len(tasks), t.AsmFile)
 			printFailureReason(err.Error())
-			unsupported, hits := unsupportedInAsmFile(t.AsmFile, arch, supportedOps)
+			unsupported, hits := diagnostics.ops, diagnostics.hits
 			if len(unsupported) > 0 {
 				fmt.Fprintf(os.Stderr, "  unsupported: %s\n", strings.Join(unsupported, ", "))
 				for _, op := range unsupported {
@@ -388,56 +611,492 @@ func runOneTarget(spec targetSpec, pats []string, modulePath, outDir string, ann
 			}
 			continue
 		}
-		fmt.Fprintf(os.Stderr, "[%d/%d] OK   %s\n", idx, len(tasks), t.AsmFile)
-		rep.Success++
+		if ccfg.SignatureQuery == nil {
+			fmt.Fprintf(os.Stderr, "[%d/%d] OK   %s\n", idx, len(tasks), t.AsmFile)
+			rep.Success++
+		} else {
+			fmt.Fprintf(os.Stderr, "[%d/%d] QUERY %s (no LLVM output)\n", idx, len(tasks), t.AsmFile)
+		}
 	}
 
 	rep.Duration = time.Since(start).String()
 	rep.UnsupportedOps = flattenUnsupportedAgg(unsupportedAgg)
+	if ccfg.Feature != nil {
+		binary, err := exec.LookPath("go")
+		if err != nil {
+			return rep, nil, err
+		}
+		binary, err = filepath.Abs(binary)
+		if err != nil {
+			return rep, nil, err
+		}
+		if err := ccfg.Feature.reobserve(binary, outDir); err != nil {
+			return rep, nil, err
+		}
+		if ccfg.SignatureQuery != nil {
+			sort.Slice(ccfg.SignatureQuery.Requests, func(i, j int) bool {
+				a, b := ccfg.SignatureQuery.Requests[i], ccfg.SignatureQuery.Requests[j]
+				return a.File+"\x00"+a.Symbol < b.File+"\x00"+b.Symbol
+			})
+			if err := gotoolprofile.ValidateSignatureQuery(ccfg.Feature.Input, ccfg.SignatureQuery, buildTags); err != nil {
+				return rep, nil, err
+			}
+		}
+	}
 	if rep.Failed != 0 {
-		fmt.Fprintf(os.Stderr, "finished with failures: success=%d failed=%d total=%d\n", rep.Success, rep.Failed, rep.TotalAsm)
+		fmt.Fprintf(os.Stderr, "finished with failures: success=%d not_applicable=%d failed=%d total=%d\n", rep.Success, rep.NotApplicable, rep.Failed, rep.TotalAsm)
 	} else {
-		fmt.Fprintf(os.Stderr, "finished: success=%d total=%d\n", rep.Success, rep.TotalAsm)
+		fmt.Fprintf(os.Stderr, "finished: success=%d not_applicable=%d total=%d\n", rep.Success, rep.NotApplicable, rep.TotalAsm)
 	}
 	return rep, nil, nil
 }
 
-func compileOne(pkg *packages.Package, arch plan9asm.Arch, goarch, triple string, t asmTask, annotate bool, ccfg compileConfig) error {
-	src, err := os.ReadFile(t.AsmFile)
+func compileOne(pkg *packages.Package, arch plan9asm.Arch, goos, goarch, triple string, t asmTask, annotate bool, ccfg compileConfig) error {
+	err := compileOneAttempt(pkg, arch, goos, goarch, triple, t, annotate, ccfg)
+	retry, retryable := x86SDKNumericalRetryCause(err)
+	if !retryable {
+		return err
+	}
+	ccfg.acquireSDKNumerical = true
+	if err := compileOneAttempt(pkg, arch, goos, goarch, triple, t, annotate, ccfg); err != nil {
+		return errors.Join(retry, err)
+	}
+	return nil
+}
+
+func compileOneAttempt(pkg *packages.Package, arch plan9asm.Arch, goos, goarch, triple string, t asmTask, annotate bool, ccfg compileConfig) (compileErr error) {
+	var continuationSource *continuationReferenceSource
+	var outputStage *compileOutputStage
+	// Registered first: every source guard and owner Close runs before any
+	// public output changes. Chunk outputs share this attempt's one stage.
+	defer func() {
+		if outputStage != nil {
+			if compileErr == nil && continuationSource != nil {
+				compileErr = continuationSource.verify(ccfg.Context, plan9asm.GoAssemblerDefines(goos, goarch), ccfg.Feature)
+			}
+			if compileErr == nil {
+				compileErr = outputStage.publish()
+			}
+			compileErr = errors.Join(compileErr, outputStage.close())
+		}
+	}()
+	if ccfg.diagnostics != nil {
+		ccfg.diagnostics.ops, ccfg.diagnostics.hits = nil, nil
+	}
+	defines := plan9asm.GoAssemblerDefines(goos, goarch)
+	var cppProof *featureCPPProof
+	var src []byte
+	var originalInputs []string
+	var originalReads *plan9asm.GoAssemblySourceReadReport
+	var originalSearchMisses []string
+	if ccfg.Feature != nil {
+		if ccfg.Feature.Observed == nil || ccfg.Feature.Observed.Target != goos+"/"+goarch || ccfg.Feature.ID != gotoolprofile.ProfileID(ccfg.Feature.Observed) {
+			return fmt.Errorf("assembler profile identity differs from the actual compilation target")
+		}
+		macros, err := ccfg.Feature.packageMacros(pkg)
+		if err != nil {
+			return err
+		}
+		if macros.PackageRole == "allow_asm_abi_path" {
+			return fmt.Errorf("explicit ordinary CPU consumer does not cover special assembler package roles")
+		}
+		defines = macros.Defines
+		if ccfg.Feature.Proof != nil {
+			var inputs map[string]string
+			var readReport plan9asm.GoAssemblySourceReadReport
+			src, inputs, err = ccfg.Feature.preprocessCPPWithReadReport(t.AsmFile, pkg.PkgPath, defines, &readReport)
+			if err != nil {
+				return err
+			}
+			originalInputs, err = compileCPPInputFiles(ccfg.Feature, inputs)
+			if err != nil {
+				return err
+			}
+			originalSearchMisses = readReport.SearchMisses
+			name, err := ccfg.Feature.sourceName(t.AsmFile)
+			if err != nil {
+				return err
+			}
+			cppProof = &featureCPPProof{File: name, Emission: "assembly", Inputs: inputs}
+			if original := ccfg.Feature.Input.CPPOriginals; original != nil {
+				cppProof.ExpandedSearchMisses = append([]gotoolprofile.CPPPackageSearchMiss{}, original.RequiredExpandedOperands[name]...)
+			}
+			expandedSource := append([]byte(nil), src...)
+			defer func() {
+				afterSource, after, err := ccfg.Feature.preprocessCPP(t.AsmFile, pkg.PkgPath, defines)
+				if err == nil && (!reflect.DeepEqual(inputs, after) || !bytes.Equal(expandedSource, afterSource)) {
+					err = fmt.Errorf("actual CPP input graph changed during translation")
+				}
+				_, macroErr := ccfg.Feature.packageMacros(pkg)
+				compileErr = errors.Join(compileErr, err, macroErr)
+			}()
+		}
+	}
+	if src == nil {
+		var err error
+		var inputs *plan9asm.GoAssemblySourceReadReport
+		src, inputs, err = plan9asm.ReadGoAssemblySourceWithReport(t.AsmFile, asmSourceRoot(pkg, t.AsmFile))
+		if err != nil {
+			return fmt.Errorf("read asm: %w", err)
+		}
+		for filename := range inputs.Inputs {
+			originalInputs = append(originalInputs, filename)
+		}
+		originalSearchMisses = inputs.SearchMisses
+		originalReads = inputs
+	}
+	originalSource := append([]byte(nil), src...)
+	if cppProof != nil {
+		cppProof.ExpandedSHA256 = featureBytesSHA256(src)
+	}
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, imported := range pkg.Imports {
+		if imported != nil && imported.Types != nil {
+			imports[path] = imported.Types
+		}
+	}
+	goPackage := plan9asm.GoPackage{
+		Path:    pkg.PkgPath,
+		Types:   pkg.Types,
+		Imports: imports,
+	}
+	src = plan9asm.ExpandGoAssemblySource(goPackage, src, goarch)
+	if cppProof != nil {
+		cppProof.TypedExpandedSHA256 = featureBytesSHA256(src)
+		ccfg.Feature.Proof.CPP = append(ccfg.Feature.Proof.CPP, *cppProof)
+	}
+	file, err := parseCompleteCLIAssembly(arch, string(src), defines, goarch, &goPackage)
+	if err != nil {
+		if err.Error() == "no TEXT directive found" {
+			proof, err := proveEmptyAssembly(pkg, t, goos+"/"+goarch, defines, ccfg)
+			if err != nil {
+				return err
+			}
+			if cppProof != nil {
+				// The CPP entry was appended before parsing; retain the
+				// separate native emptiness witness on that exact entry.
+				ccfg.Feature.Proof.CPP[len(ccfg.Feature.Proof.CPP)-1].EmptyAssembly = proof
+				ccfg.Feature.Proof.CPP[len(ccfg.Feature.Proof.CPP)-1].Emission = "symbol_free"
+			}
+			file = &plan9asm.File{Arch: arch}
+			ccfg.emptyAssembly = proof
+		} else {
+			return fmt.Errorf("parse asm: %w", err)
+		}
+	}
+
+	file, numericalSource, err := captureX86SDKNumericalSource(pkg, file, t.AsmFile, goos+"/"+goarch, ccfg)
 	if err != nil {
-		return fmt.Errorf("read asm: %w", err)
+		return fmt.Errorf("capture actual SDK numerical source: %w", err)
 	}
-	file, err := plan9asm.Parse(arch, string(src))
+	if numericalSource != nil {
+		defer func() {
+			compileErr = errors.Join(compileErr, numericalSource.verify(ccfg.Context), numericalSource.close())
+		}()
+		pkg = numericalSource.pkg
+		ccfg.x86CallerSelections = map[*packages.Package]*x86CallerPackageSelection{pkg: numericalSource.selected}
+	}
+
+	if ccfg.diagnostics != nil {
+		ccfg.diagnostics.collect(file)
+	}
+
+	// Use the Go-module frontend's complete-file continuation proof before
+	// signature queries or bounded modules can discard a helper or its uses.
+	resolve := resolveSymFunc(pkg.PkgPath)
+	if numericalSource != nil {
+		resolve = numericalSource.resolve
+	}
+	file, tailSource, tailSigs, err := prepareARM64ABI0TailSource(pkg, file, t.AsmFile, src,
+		goos+"/"+goarch, defines, ccfg, resolve)
 	if err != nil {
-		if strings.Contains(err.Error(), "no TEXT directive found") {
+		return fmt.Errorf("prove ARM64 private source continuations: %w", err)
+	}
+	if tailSource != nil {
+		defer func() {
+			ctx := ccfg.Context
+			if ctx == nil {
+				ctx = context.Background()
+			}
+			compileErr = errors.Join(compileErr, tailSource.verify(ctx, defines, ccfg.Feature))
+		}()
+	}
+
+	signaturePackage := pkg
+	if tailSource != nil {
+		signaturePackage = tailSource.actual
+	}
+	var testDeclarations asmDeclarationLookup
+	if cppProof != nil {
+		testDeclarations = func(original, symbol string) (plan9asm.FuncSig, int64, bool, error) {
+			return ccfg.Feature.testDeclarationSignature(signaturePackage, filepath.Dir(t.AsmFile), original, symbol, goarch)
+		}
+	}
+	var sigs map[string]plan9asm.FuncSig
+	var declaredArgSizes map[string]int64
+	registerFallbacks := make(map[string]plan9asm.FuncSig)
+	if numericalSource != nil {
+		sigs, declaredArgSizes, _, err = x86SDKDirectTailDeclarationInventory(numericalSource.goPackage, file,
+			plan9asm.Options{Goarch: goarch, ResolveSym: resolve})
+		if err != nil {
+			return fmt.Errorf("collect actual SDK tail declarations: %w", err)
+		}
+	}
+	if sigs == nil {
+		sigs, declaredArgSizes, err = inferSigsForAsmFile(signaturePackage, file, resolve, goarch, testDeclarations, registerFallbacks)
+		if err != nil {
+			return fmt.Errorf("infer signatures: %w", err)
+		}
+	}
+	if err := rebindARM64ABI0TailSignatures(sigs, tailSigs); err != nil {
+		return err
+	}
+	if cppProof != nil {
+		// A missing-signature query shares the exact parsed source role with
+		// final consumption. Authenticate native data symbols before returning
+		// query metadata, but never emit or count an LLVM output for a query.
+		if len(file.Funcs) == 0 && ccfg.emptyAssembly == nil && ccfg.Feature.Input.SignatureSourceProtocol == gotoolprofile.SignatureSourceProtocol {
+			dataOnly, err := proveDataOnlyAssembly(pkg, t, file, goos+"/"+goarch, defines, ccfg)
+			if err != nil {
+				return fmt.Errorf("authenticate data-only assembly: %w", err)
+			}
+			cpp := &ccfg.Feature.Proof.CPP[len(ccfg.Feature.Proof.CPP)-1]
+			cpp.Emission, cpp.DataOnlyAssembly = "data_only", dataOnly
+		}
+		if ccfg.SignatureQuery != nil {
+			requests, err := ccfg.Feature.queryMissingSignatureSources(pkg, file, t.AsmFile, resolve, goarch)
+			if err != nil {
+				return err
+			}
+			ccfg.SignatureQuery.Requests = append(ccfg.SignatureQuery.Requests, requests...)
 			return nil
 		}
-		return fmt.Errorf("parse asm: %w", err)
+		sources, err := ccfg.Feature.bindSignatureSources(pkg, file, t.AsmFile, resolve, goarch, sigs, declaredArgSizes)
+		if err != nil {
+			return fmt.Errorf("authenticate signature sources: %w", err)
+		}
+		ccfg.Feature.Proof.CPP[len(ccfg.Feature.Proof.CPP)-1].Signatures = sources
+		ccfg.Feature.refreshTestDeclarationReferences()
+	}
+	if err := validateDeclaredTextArgSizes(file, resolve, declaredArgSizes, goarch); err != nil {
+		return fmt.Errorf("target applicability: %w", err)
+	}
+	sigs, callerSource, err := bindX86CallerRegions(pkg, file, goos+"/"+goarch, goarch, t.AsmFile, defines, ccfg, resolve, sigs)
+	if err != nil {
+		return fmt.Errorf("prove actual Go raw-return callers: %w", err)
+	}
+	if callerSource != nil {
+		defer func() {
+			ctx := ccfg.Context
+			if ctx == nil {
+				ctx = context.Background()
+			}
+			compileErr = errors.Join(compileErr, callerSource.verify(ctx, defines, ccfg.Feature))
+		}()
+	}
+	ccfg.X86TailGroups, continuationSource, err = inferX86TailGroups(pkg, file, t.AsmFile, goarch, resolve, sigs, defines, ccfg)
+	if err != nil {
+		return fmt.Errorf("prove private continuation entries: %w", err)
+	}
+	if continuationSource != nil {
+		defer func() {
+			ctx := ccfg.Context
+			if ctx == nil {
+				ctx = context.Background()
+			}
+			compileErr = errors.Join(compileErr, continuationSource.verify(ctx, defines, ccfg.Feature))
+		}()
+	}
+	if ccfg.ordinaryDeclarations == nil && ccfg.numericalOptions == nil {
+		options := compileTranslationOptions(triple, goarch, annotate, ccfg, resolve, sigs)
+		if err := rejectUnboundCallerFrame(file, options, declaredArgSizes); err != nil {
+			return err
+		}
+	}
+	sigs, fixedLocalSource, err := prepareAMD64FixedLocalSource(pkg, file, t.AsmFile, goos+"/"+goarch,
+		triple, goarch, ccfg, resolve, sigs, registerFallbacks)
+	if err != nil {
+		return fmt.Errorf("prove original fixed local backing: %w", err)
 	}
-	if len(file.Funcs) == 0 {
+	if fixedLocalSource != nil {
+		defer func() {
+			if err := fixedLocalSource.verify(ccfg.Context); err != nil {
+				compileErr = errors.Join(compileErr, err)
+			}
+			if err := fixedLocalSource.close(); err != nil {
+				compileErr = errors.Join(compileErr, err)
+			}
+		}()
+	}
+	sigs, scratchSource, err := prepareARM64NativeScratchSource(pkg, file, t.AsmFile,
+		goos+"/"+goarch, triple, ccfg, resolve, sigs)
+	if err != nil {
+		return fmt.Errorf("prove actual native scratch closure: %w", err)
+	}
+	if scratchSource != nil {
+		defer func() {
+			compileErr = errors.Join(compileErr, scratchSource.Verify(ccfg.Context), scratchSource.Close())
+		}()
+	}
+	if numericalSource != nil {
+		options, err := numericalSource.bindNumericalReads(ccfg.Context, file,
+			compileTranslationOptions(triple, goarch, annotate, ccfg, resolve, sigs))
+		if err != nil {
+			return fmt.Errorf("bind actual SDK numerical source: %w", err)
+		}
+		ccfg.numericalOptions = &options
+		sigs = options.Sigs
+	}
+	// Ordinary declarations grant only the GoModule frontend's existing typed
+	// read roles. Do not mix them with independently owned native/source roles.
+	if ccfg.Feature == nil && !ccfg.acquireSDKNumerical && numericalSource == nil && tailSource == nil &&
+		callerSource == nil && continuationSource == nil && fixedLocalSource == nil && scratchSource == nil && len(ccfg.X86TailGroups) == 0 {
+		ccfg.ordinaryDeclarations, err = captureOrdinaryDeclarations(pkg, file, originalSource, originalReads, goos, goarch, ccfg)
+		if err != nil {
+			return fmt.Errorf("ordinary declarations: %w", err)
+		}
+		if source := ccfg.ordinaryDeclarations; source != nil {
+			defer func() {
+				compileErr = errors.Join(compileErr, source.verify(ccfg.Context))
+				source.close()
+			}()
+		}
+	}
+	maxFunctions := ccfg.MaxFunctions
+	if maxFunctions <= 0 {
+		maxFunctions = 128
+	}
+	maxInstructions := ccfg.MaxInstructions
+	if maxInstructions <= 0 {
+		maxInstructions = 32768
+	}
+	instructionCount := 0
+	for _, fn := range file.Funcs {
+		instructionCount += len(fn.Instrs)
+	}
+	outputStage, err = newCompileOutputStage(t, pkg, ccfg.Feature)
+	if err != nil {
+		return err
+	}
+	if err := outputStage.protectInputs(pkg, originalInputs, originalSearchMisses); err != nil {
+		return err
+	}
+	// A continuation and the initializer taking its block address must remain
+	// in one LLVM module, just as an oversized ordinary function stays intact.
+	if ccfg.Enabled && !ccfg.KeepObj && len(ccfg.X86TailGroups) == 0 && fixedLocalSource == nil && scratchSource == nil && numericalSource == nil && ccfg.ordinaryDeclarations == nil &&
+		(len(file.Funcs) > maxFunctions || instructionCount > maxInstructions) {
+		// A complete pass is necessary before splitting: an x86 function may
+		// take the byte-exact address of raw TEXT in a different chunk.
+		file, err = plan9asm.NormalizeRawFileForTranslation(file, goarch)
+		if err != nil {
+			return fmt.Errorf("normalize raw file: %w", err)
+		}
+		for first, chunk := 0, 0; first < len(file.Funcs); chunk++ {
+			last := first
+			chunkInstructions := 0
+			for last < len(file.Funcs) && last-first < maxFunctions {
+				next := len(file.Funcs[last].Instrs)
+				if last > first && chunkInstructions+next > maxInstructions {
+					break
+				}
+				chunkInstructions += next
+				last++
+			}
+			part := *file
+			part.Funcs = file.Funcs[first:last]
+			partTask := t
+			if chunk != 0 {
+				stem := strings.TrimSuffix(t.OutLL, filepath.Ext(t.OutLL))
+				partTask.OutLL = fmt.Sprintf("%s.part-%04d.ll", stem, chunk)
+			}
+			stagedTask, err := outputStage.stageTask(partTask, ccfg)
+			if err != nil {
+				return err
+			}
+			if err := translateAndCompileModule(&part, triple, goarch, stagedTask, annotate, ccfg, resolve, sigs); err != nil {
+				err = annotateUnboundCallerFrame(&part, resolve, sigs, declaredArgSizes, err)
+				return fmt.Errorf("functions %d-%d/%d: %w", first+1, last, len(file.Funcs), err)
+			}
+			if err := outputStage.seal(); err != nil {
+				return err
+			}
+			first = last
+		}
 		return nil
 	}
-
-	resolve := resolveSymFunc(pkg.PkgPath)
-	sigs, err := sigsForAsmFile(pkg, file, resolve, goarch)
+	compileTask, err := outputStage.stageTask(t, ccfg)
 	if err != nil {
-		return fmt.Errorf("infer signatures: %w", err)
-	}
-	mod, err := plan9asm.TranslateModule(file, plan9asm.Options{
-		TargetTriple:   triple,
-		ResolveSym:     resolve,
-		Sigs:           sigs,
-		Goarch:         goarch,
-		AnnotateSource: annotate,
-	})
+		return err
+	}
+	err = translateAndCompileModule(file, triple, goarch, compileTask, annotate, ccfg, resolve, sigs)
+	if err == nil {
+		err = outputStage.seal()
+	}
+	// Only a complete-file translation rejected before writing IR/object may
+	// request an independent SDK observation. A partially translated chunked
+	// compilation never reaches this seam, and non-context errors stay errors.
+	if !ccfg.acquireSDKNumerical && ccfg.Feature == nil && errors.Is(err, plan9asm.ErrProbeNeedsContext) &&
+		x86SDKNumericalOwnerRequested(pkg, file, goos+"/"+goarch) {
+		return &x86SDKNumericalRetryError{cause: err}
+	}
+	return annotateUnboundCallerFrame(file, resolve, sigs, declaredArgSizes, err)
+}
+
+func compileTranslationOptions(triple, goarch string, annotate bool, ccfg compileConfig,
+	resolve func(string) string, sigs map[string]plan9asm.FuncSig,
+) plan9asm.Options {
+	return plan9asm.Options{
+		TargetTriple: triple, ResolveSym: resolve, Sigs: sigs, Goarch: goarch,
+		WASMABI: wasmABIForGoPackageTarget(goarch), AnnotateSource: annotate, X86TailGroups: ccfg.X86TailGroups,
+	}
+}
+
+func translateAndCompileModule(file *plan9asm.File, triple, goarch string, t asmTask, annotate bool,
+	ccfg compileConfig, resolve func(string) string, sigs map[string]plan9asm.FuncSig,
+) error {
+	ctx := llvm.NewContext()
+	var mod llvm.Module
+	var err error
+	if ccfg.emptyAssembly != nil {
+		if ccfg.emptyAssembly.Protocol != gotoolprofile.EmptyAssemblyProtocol ||
+			len(file.Funcs) != 0 || len(file.Data) != 0 || len(file.Globl) != 0 {
+			ctx.Dispose()
+			return fmt.Errorf("symbol-free emission contradicts its native proof")
+		}
+		// Do not broaden the public translator's empty-file contract. Only
+		// this CLI's actual successful Go object/listing check grants this.
+		mod = ctx.NewModule("plan9asm-empty-assembly")
+		mod.SetTarget(triple)
+	} else if ccfg.ordinaryDeclarations != nil {
+		mod, err = ccfg.ordinaryDeclarations.translate(ctx, file, triple, goarch, annotate, resolve)
+	} else {
+		options := compileTranslationOptions(triple, goarch, annotate, ccfg, resolve, sigs)
+		if ccfg.numericalOptions != nil {
+			requested, bound := options, *ccfg.numericalOptions
+			requested.ResolveSym, bound.ResolveSym = nil, nil
+			bound.NumericalReads = nil
+			if !reflect.DeepEqual(requested, bound) {
+				ctx.Dispose()
+				return fmt.Errorf("%w: SDK numerical translation options changed after binding", plan9asm.ErrProbeNeedsContext)
+			}
+			options = *ccfg.numericalOptions
+		}
+		mod, err = plan9asm.TranslateModuleInContext(ctx, file, options)
+	}
 	if err != nil {
+		ctx.Dispose()
 		return fmt.Errorf("translate: %w", err)
 	}
-	defer mod.Dispose()
 	if err := llvm.VerifyModule(mod, llvm.ReturnStatusAction); err != nil {
+		mod.Dispose()
+		ctx.Dispose()
 		return fmt.Errorf("verify module: %w", err)
 	}
 	ll := mod.String()
+	// The external llc process may run for a while. Release both the module
+	// and its context before writing files or waiting for it.
+	mod.Dispose()
+	ctx.Dispose()
 	if err := os.MkdirAll(filepath.Dir(t.OutLL), 0755); err != nil {
 		return fmt.Errorf("mkdir out dir: %w", err)
 	}
@@ -446,10 +1105,15 @@ func compileOne(pkg *packages.Package, arch plan9asm.Arch, goarch, triple string
 	}
 	if ccfg.Enabled {
 		objPath := strings.TrimSuffix(t.OutLL, filepath.Ext(t.OutLL)) + ".o"
-		args := []string{"-mtriple=" + triple}
-		args = append(args, llcExtraArgs(goarch)...)
-		args = append(args, "-filetype=obj", t.OutLL, "-o", objPath)
+		if err := os.Remove(objPath); err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("remove stale object: %w", err)
+		}
+		args := llcCompileArgs(triple, goarch, t.OutLL, objPath, ccfg.OptLevel)
 		cmd := exec.Command(ccfg.LLC, args...)
+		if ccfg.Context != nil {
+			cmd = exec.CommandContext(ccfg.Context, ccfg.LLC, args...)
+			cmd.WaitDelay = 2 * time.Second
+		}
 		if out, err := cmd.CombinedOutput(); err != nil {
 			s := strings.TrimSpace(string(out))
 			if s == "" {
@@ -457,13 +1121,72 @@ func compileOne(pkg *packages.Package, arch plan9asm.Arch, goarch, triple string
 			}
 			return fmt.Errorf("llc compile failed: %w\n%s", err, s)
 		}
+		stat, err := os.Lstat(objPath)
+		if err != nil || !stat.Mode().IsRegular() || stat.Size() == 0 {
+			return fmt.Errorf("llc did not produce a nonempty object %s: %v", objPath, err)
+		}
+		if ccfg.Feature != nil && ccfg.Feature.Proof != nil {
+			object, err := gotoolprofile.FileSHA256(objPath)
+			if err != nil {
+				return err
+			}
+			name, err := ccfg.Feature.sourceName(t.AsmFile)
+			if err != nil {
+				return err
+			}
+			ccfg.Feature.Proof.Outputs = append(ccfg.Feature.Proof.Outputs, featureOutputProof{File: name, Part: filepath.Base(t.OutLL), IR: featureBytesSHA256([]byte(ll)), Object: object})
+		}
 		if !ccfg.KeepObj {
-			_ = os.Remove(objPath)
+			if err := os.Remove(objPath); err != nil {
+				return fmt.Errorf("remove generated object: %w", err)
+			}
 		}
 	}
+	if !ccfg.Enabled && ccfg.Feature != nil && ccfg.Feature.Proof != nil {
+		name, err := ccfg.Feature.sourceName(t.AsmFile)
+		if err != nil {
+			return err
+		}
+		ccfg.Feature.Proof.Outputs = append(ccfg.Feature.Proof.Outputs, featureOutputProof{File: name, Part: filepath.Base(t.OutLL), IR: featureBytesSHA256([]byte(ll))})
+	}
 	return nil
 }
 
+func featureBytesSHA256(data []byte) string { return fmt.Sprintf("%x", sha256.Sum256(data)) }
+
+func llcCompileArgs(triple, goarch, input, output string, optLevel int) []string {
+	args := []string{"-mtriple=" + triple, fmt.Sprintf("-O%d", optLevel)}
+	args = append(args, llcExtraArgs(goarch)...)
+	return append(args, "-filetype=obj", input, "-o", output)
+}
+
+// plan9asmll translates Go package assembly, rather than arbitrary native LLVM
+// entry points. Go's wasm assembler therefore always uses the resumable
+// linear-memory stack ABI; other architectures retain the direct convention.
+func wasmABIForGoPackageTarget(goarch string) plan9asm.WASMABI {
+	if goarch == "wasm" {
+		return plan9asm.WASMABIGo
+	}
+	return plan9asm.WASMABIDirect
+}
+
+func asmSourceRoot(pkg *packages.Package, asmFile string) string {
+	if pkg != nil && pkg.Module != nil && pkg.Module.Dir != "" {
+		return pkg.Module.Dir
+	}
+	return filepath.Dir(asmFile)
+}
+
+// readAsmSource expands quoted headers that live inside the package's module.
+// Go assembly commonly keeps large function-like macros in sibling .h files.
+// Toolchain headers such as textflag.h and funcdata.h are resolved from the
+// current GOROOT's pkg/include directory, matching the include path supplied
+// by the Go command. Generated package headers such as go_asm.h remain as
+// directives when they do not exist yet.
+func readAsmSource(asmFile, sourceRoot string) ([]byte, error) {
+	return plan9asm.ReadGoAssemblySource(asmFile, sourceRoot)
+}
+
 func llcExtraArgs(goarch string) []string {
 	switch goarch {
 	case "amd64":
@@ -480,31 +1203,97 @@ func llcExtraArgs(goarch string) []string {
 	}
 }
 
-func loadPkgs(goos, goarch string, patterns []string, modulePath string, strict bool) ([]*packages.Package, error) {
+func loadPkgs(goos, goarch string, patterns, buildTags []string, modulePath string, strict, includeTests bool) ([]*packages.Package, error) {
+	return loadPkgsForFeature(goos, goarch, patterns, buildTags, modulePath, strict, includeTests, nil)
+}
+
+func loadPkgsForFeature(goos, goarch string, patterns, buildTags []string, modulePath string, strict, includeTests bool, feature *featureConsumer) ([]*packages.Package, error) {
+	pkgs, _, err := loadPkgsInEnvironment(goos, goarch, patterns, buildTags, modulePath, strict, includeTests, feature)
+	return pkgs, err
+}
+
+func loadPkgsInEnvironment(goos, goarch string, patterns, buildTags []string, modulePath string, strict, includeTests bool, feature *featureConsumer) ([]*packages.Package, []string, error) {
 	cfg := &packages.Config{
 		Mode: packages.NeedName |
 			packages.NeedFiles |
+			packages.NeedEmbedFiles |
+			packages.NeedCompiledGoFiles |
 			packages.NeedModule |
 			packages.NeedDeps |
 			packages.NeedImports |
 			packages.NeedTypes |
-			packages.NeedTypesInfo |
-			packages.NeedTypesSizes |
-			packages.NeedSyntax,
-		Env: append(os.Environ(),
-			"GOOS="+goos,
-			"GOARCH="+goarch,
-		),
+			packages.NeedTypesSizes,
+		Tests: includeTests,
+	}
+	if feature != nil {
+		cfg.Context, cfg.Env, cfg.Dir = feature.Context, feature.Env, feature.WorkDir
+		cfg.Mode |= packages.NeedCompiledGoFiles
+		// The producer's export/vet gates use this explicit module mode too.
+		// Do not pass it through GOFLAGS, where it could hide selection tags.
+		cfg.BuildFlags = append(cfg.BuildFlags, "-mod=mod")
+	} else {
+		var err error
+		cfg.Env, err = ordinaryPackageEnvironment(goos, goarch, os.Environ())
+		if err != nil {
+			return nil, nil, err
+		}
+		cfg.Dir, err = sdkfrontend.WorkingDirectory("")
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+	if len(buildTags) != 0 {
+		cfg.BuildFlags = append(cfg.BuildFlags, "-tags="+strings.Join(buildTags, ","))
 	}
 	pkgs, err := packages.Load(cfg, patterns...)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	pkgs = filterPackagesByModule(pkgs, modulePath)
 	if count := packages.PrintErrors(pkgs); strict && count != 0 {
-		return nil, fmt.Errorf("%d package loading error(s)", count)
+		return nil, nil, fmt.Errorf("%d package loading error(s)", count)
+	}
+	for _, pkg := range pkgs {
+		if err := loadLinknameSyntax(pkg); err != nil {
+			return nil, nil, err
+		}
+	}
+	return pkgs, append([]string(nil), cfg.Env...), nil
+}
+
+// Only target packages need source comments for go:linkname resolution. Loading
+// syntax and type-info for every transitive dependency retains large AST and
+// types.Info graphs, especially for third-party modules such as Arrow.
+func loadLinknameSyntax(pkg *packages.Package) error {
+	for _, name := range pkg.GoFiles {
+		src, err := os.ReadFile(name)
+		if err != nil {
+			return fmt.Errorf("read Go source %s: %w", name, err)
+		}
+		if !bytes.Contains(src, []byte("go:linkname ")) {
+			continue
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), name, src, parser.ParseComments)
+		if err != nil {
+			return fmt.Errorf("parse Go source %s: %w", name, err)
+		}
+		pkg.Syntax = append(pkg.Syntax, file)
 	}
-	return pkgs, nil
+	return nil
+}
+
+func containsTestAssembly(files []string) bool {
+	for _, name := range files {
+		base := filepath.Base(filepath.FromSlash(name))
+		if strings.Contains(strings.TrimSuffix(base, filepath.Ext(base)), "_test_") || strings.HasSuffix(strings.TrimSuffix(base, filepath.Ext(base)), "_test") {
+			return true
+		}
+	}
+	return false
+}
+
+func isTestVariantPackage(pkg *packages.Package) bool {
+	return pkg != nil && strings.Contains(pkg.ID, " [") && strings.HasSuffix(pkg.ID, ".test]")
 }
 
 func filterPackagesByModule(pkgs []*packages.Package, modulePath string) []*packages.Package {
@@ -520,10 +1309,14 @@ func filterPackagesByModule(pkgs []*packages.Package, modulePath string) []*pack
 	return filtered
 }
 
-func collectAsmTasks(pkgs []*packages.Package, outDir string) ([]asmTask, []string) {
+func collectAsmTasks(pkgs []*packages.Package, outDir string, exactAsmFiles []string) ([]asmTask, []string) {
 	tasks := make([]asmTask, 0)
 	asmPackages := make([]string, 0)
 	seenPkg := map[string]bool{}
+	allow := make(map[string]bool, len(exactAsmFiles))
+	for _, path := range exactAsmFiles {
+		allow[filepath.ToSlash(filepath.Clean(filepath.FromSlash(path)))] = true
+	}
 	for _, p := range pkgs {
 		if p == nil || p.PkgPath == "" {
 			continue
@@ -532,7 +1325,29 @@ func collectAsmTasks(pkgs []*packages.Package, outDir string) ([]asmTask, []stri
 			continue
 		}
 		seenPkg[p.PkgPath] = true
-		files := asmFilesOfPkg(p)
+		var files []string
+		if len(allow) == 0 {
+			files = asmFilesOfPkg(p)
+		} else {
+			// An explicit profile scope must consume selected nonzero original
+			// files even when their only content is whitespace or comments.
+			// Only Go's actual selected OtherFiles can become tasks; the
+			// subsequent profile match and object proof remain mandatory.
+			for _, file := range p.OtherFiles {
+				if !isAsmFile(file) {
+					continue
+				}
+				rel, ok := moduleRelativeAsmPath(p, file)
+				if !ok || !allow[rel] {
+					continue
+				}
+				data, err := os.ReadFile(file)
+				if err != nil || len(data) != 0 {
+					files = append(files, file)
+				}
+			}
+			sort.Strings(files)
+		}
 		if len(files) == 0 {
 			continue
 		}
@@ -552,6 +1367,27 @@ func collectAsmTasks(pkgs []*packages.Package, outDir string) ([]asmTask, []stri
 	return tasks, asmPackages
 }
 
+func validateExactAsmFiles(files []string) error {
+	for _, path := range files {
+		clean := filepath.Clean(filepath.FromSlash(path))
+		if filepath.IsAbs(clean) || clean == "." || clean == ".." || strings.HasPrefix(clean, ".."+string(filepath.Separator)) {
+			return fmt.Errorf("invalid -asm-files entry %q: expect a module-relative path", path)
+		}
+	}
+	return nil
+}
+
+func moduleRelativeAsmPath(pkg *packages.Package, path string) (string, bool) {
+	if pkg == nil || pkg.Module == nil || pkg.Module.Dir == "" {
+		return "", false
+	}
+	rel, err := filepath.Rel(pkg.Module.Dir, path)
+	if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return "", false
+	}
+	return filepath.ToSlash(filepath.Clean(rel)), true
+}
+
 func asmFilesOfPkg(p *packages.Package) []string {
 	if p == nil {
 		return nil
@@ -685,25 +1521,39 @@ func resolveSymFunc(pkgPath string) func(sym string) string {
 }
 
 var abiSuffixRe = regexp.MustCompile(`<ABI[^>]*>$`)
-var (
-	reCaseString = regexp.MustCompile(`case\s+"([A-Za-z0-9_.$]+)"`)
-	reCaseOp     = regexp.MustCompile(`case\s+Op([A-Za-z0-9_]+)`)
-	reQuotedOp   = regexp.MustCompile(`"([A-Za-z0-9_.$]+)"`)
-	reOpToken    = regexp.MustCompile(`Op([A-Za-z0-9_]+)`)
-)
 
 func stripABISuffix(sym string) string {
 	return abiSuffixRe.ReplaceAllString(sym, "")
 }
 
-func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(string) string, goarch string) (map[string]plan9asm.FuncSig, error) {
+type asmDeclarationLookup func(original, symbol string) (plan9asm.FuncSig, int64, bool, error)
+
+func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(string) string, goarch string) (map[string]plan9asm.FuncSig, map[string]int64, error) {
+	return sigsForAsmFileWithDeclarations(pkg, file, resolve, goarch, nil)
+}
+
+func sigsForAsmFileWithDeclarations(pkg *packages.Package, file *plan9asm.File, resolve func(string) string, goarch string, declarations asmDeclarationLookup) (map[string]plan9asm.FuncSig, map[string]int64, error) {
+	return inferSigsForAsmFile(pkg, file, resolve, goarch, declarations, nil)
+}
+
+func inferSigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(string) string, goarch string,
+	declarations asmDeclarationLookup, registerFallbacks map[string]plan9asm.FuncSig,
+) (map[string]plan9asm.FuncSig, map[string]int64, error) {
 	sigs := map[string]plan9asm.FuncSig{}
+	declaredArgSizes := map[string]int64{}
+	declaredSigs := map[string]bool{}
+	knownABISigs := map[string]bool{}
+	fallbackAsmSigs := map[string]bool{}
 	if pkg == nil || pkg.Types == nil || pkg.Types.Scope() == nil {
 		for _, fn := range file.Funcs {
-			fs := fallbackSigForAsmFunc(fn, resolve(stripABISuffix(fn.Sym)))
+			fs := fallbackSigForAsmFunc(fn, resolve(stripABISuffix(fn.Sym)), goarch)
+			if err := validateInferredX86FrameExtent(fn, fs, goarch); err != nil {
+				return nil, nil, err
+			}
 			sigs[fs.Name] = fs
 		}
-		return sigs, nil
+		asmsig.RefineTailForwarders(file, sigs, resolve, nil)
+		return sigs, declaredArgSizes, nil
 	}
 
 	sz := pkg.TypesSizes
@@ -711,7 +1561,7 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		sz = types.SizesFor("gc", goarch)
 	}
 	if sz == nil {
-		return nil, fmt.Errorf("missing type sizes for %q", goarch)
+		return nil, nil, fmt.Errorf("missing type sizes for %q", goarch)
 	}
 
 	scope := pkg.Types.Scope()
@@ -723,48 +1573,122 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 		if resolved == "" {
 			continue
 		}
-		fs, ok, err := tryDeclSig(scope, sym, resolved, linknames, goarch, sz)
+		fs, argSize, ok, err := tryDeclSig(scope, sym, resolved, linknames, goarch, sz, strings.HasSuffix(fn.Sym, "<ABIInternal>"))
+		if err == nil && !ok && declarations != nil {
+			fs, argSize, ok, err = declarations(fn.Sym, resolved)
+		}
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		if !ok {
-			fs = fallbackSigForAsmFunc(fn, resolved)
+			fs = fallbackSigForAsmFunc(fn, resolved, goarch)
+			fallbackAsmSigs[resolved] = true
+		} else {
+			if goarch == "arm64" {
+				inferred := fallbackSigForAsmFunc(fn, resolved, goarch)
+				if borrowed, ok := asmsig.ARM64BorrowedTailFrame(file, fn, fs, inferred, resolve); ok {
+					fs = borrowed
+				}
+			}
+			declaredArgSizes[resolved] = argSize
+			declaredSigs[resolved] = true
+			knownABISigs[resolved] = true
 		}
 		sigs[resolved] = fs
 	}
 
+	// File-local WebAssembly helpers use the native wasm operand stack and
+	// virtual registers rather than Go's stack-frame ABI. They have no Go
+	// declaration, so derive their complete argument and result types from the
+	// instructions before resolving calls. Keeping this generic covers the
+	// standard library's bytealg helpers as they evolve without a name table.
+	if goarch == "wasm" {
+		for _, fn := range file.Funcs {
+			resolved := resolve(stripABISuffix(fn.Sym))
+			fs, ok := plan9asm.LookupGoWASMNativeFuncSig(resolved)
+			if !ok {
+				if !strings.HasSuffix(stripABISuffix(fn.Sym), "<>") || !plan9asm.WASMAssemblyUsesNativeReturn(fn) {
+					continue
+				}
+				var err error
+				fs, err = plan9asm.InferWASMAssemblyFuncSig(fn, resolved)
+				if err != nil {
+					return nil, nil, err
+				}
+			}
+			fs.WASMNative = true
+			sigs[resolved] = fs
+			knownABISigs[resolved] = true
+			delete(fallbackAsmSigs, resolved)
+		}
+	}
+
+	var targetSigErr error
 	addTargetSig := func(sym string, caller plan9asm.FuncSig, tail bool) {
 		if sym == "" {
 			return
 		}
-		sym = stripABISuffix(strings.TrimSuffix(sym, "<>"))
+		internal := goarch == "arm64" && strings.HasSuffix(sym, "<ABIInternal>")
+		sym = stripABISuffix(sym)
 		resolved := resolve(sym)
 		if resolved == "" {
 			return
 		}
-		if _, ok := sigs[resolved]; ok {
+		if existing, ok := sigs[resolved]; ok {
+			if internal && declaredSigs[resolved] && existing.ARM64GoRegisterABI == nil {
+				fs, _, _, err := tryDeclSig(scope, sym, resolved, linknames, goarch, sz, true)
+				if err != nil {
+					targetSigErr = err
+				} else {
+					sigs[resolved] = fs
+				}
+			}
+			return
+		}
+		if goarch == "wasm" {
+			if fs, ok := plan9asm.LookupGoWASMNativeFuncSig(resolved); ok {
+				sigs[resolved] = fs
+				knownABISigs[resolved] = true
+				return
+			}
+		}
+		fs, _, ok, err := tryDeclSig(scope, sym, resolved, linknames, goarch, sz, internal)
+		if err == nil && !ok && declarations != nil {
+			fs, _, ok, err = declarations(sym, resolved)
+			if err != nil {
+				targetSigErr = err
+				return
+			}
+		}
+		if internal && err != nil {
+			targetSigErr = err
 			return
 		}
-		fs, ok, err := tryDeclSig(scope, sym, resolved, linknames, goarch, sz)
 		if err == nil && ok {
 			sigs[resolved] = fs
+			declaredSigs[resolved] = true
+			knownABISigs[resolved] = true
 			return
 		}
 		if tail && caller.Name != "" {
 			copySig := caller
 			copySig.Name = resolved
+			copySig.ARM64GoRegisterABI = nil
 			sigs[resolved] = copySig
 			return
 		}
 		sigs[resolved] = plan9asm.FuncSig{Name: resolved, Ret: plan9asm.I64}
 	}
 
+	declaredTailCallers := make(map[string][]plan9asm.FuncSig)
+	declaredTailCallerFuncs := make(map[string][]plan9asm.Func)
 	for _, fn := range file.Funcs {
-		caller := sigs[resolve(stripABISuffix(fn.Sym))]
+		callerResolved := resolve(stripABISuffix(fn.Sym))
+		caller := sigs[callerResolved]
 		for _, ins := range fn.Instrs {
 			op := strings.ToUpper(string(ins.Op))
-			tail := op == "JMP" || op == "B"
-			if !(tail || op == "CALL" || op == "BL") {
+			tail := op == "JMP" || op == "B" || (op == "RET" && len(ins.Args) == 1)
+			if !(tail || op == "CALL" || op == "CALLNORESUME" || op == "WASMCALL" || op == "BL") {
 				continue
 			}
 			if len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
@@ -780,55 +1704,281 @@ func sigsForAsmFile(pkg *packages.Package, file *plan9asm.File, resolve func(str
 				continue
 			}
 			addTargetSig(base, caller, tail)
+			targetResolved := resolve(stripABISuffix(base))
+			if tail && declaredSigs[callerResolved] && fallbackAsmSigs[targetResolved] {
+				candidate := caller
+				candidate.Name = targetResolved
+				candidate.ARM64GoRegisterABI = nil
+				declaredTailCallers[targetResolved] = append(declaredTailCallers[targetResolved], candidate)
+				declaredTailCallerFuncs[targetResolved] = append(declaredTailCallerFuncs[targetResolved], fn)
+			}
+		}
+	}
+
+	if targetSigErr != nil {
+		return nil, nil, targetSigErr
+	}
+
+	// A declaration-free local helper reached only through tail transfers from
+	// Go-declared functions executes in the caller's frame. Copy the complete
+	// ABI when every caller agrees; this is how 32-bit ARM implements its 64-bit
+	// atomic helpers. Shared register-based bodies such as x86 memeqbody can
+	// have callers with different argument lists, so in that case propagate
+	// only a common return type and retain the helper's own inferred inputs.
+	for targetResolved, callers := range declaredTailCallers {
+		if len(callers) == 0 {
+			continue
+		}
+		inferred := callers[0]
+		fullABIAGrees := true
+		returnTypeAgrees := true
+		for _, caller := range callers[1:] {
+			if !reflect.DeepEqual(inferred, caller) {
+				fullABIAGrees = false
+			}
+			if inferred.Ret != caller.Ret {
+				returnTypeAgrees = false
+			}
+		}
+		if fullABIAGrees {
+			sigs[targetResolved] = inferred
+			knownABISigs[targetResolved] = true
+			continue
+		}
+		if helper, ok := inferSharedABI0ResultPointerHelper(
+			file,
+			resolve,
+			targetResolved,
+			callers,
+			declaredTailCallerFuncs[targetResolved],
+			goarch,
+		); ok {
+			sigs[targetResolved] = helper
+			knownABISigs[targetResolved] = true
+			continue
+		}
+		if returnTypeAgrees {
+			target := sigs[targetResolved]
+			// Explicit FP result slots are part of the helper's frame ABI and
+			// cannot be replaced by return-type evidence alone. With no such
+			// slots, the declared callers are the only reliable return oracle.
+			if len(target.Frame.Results) == 0 {
+				target.Ret = inferred.Ret
+				sigs[targetResolved] = target
+			}
 		}
 	}
 
-	return sigs, nil
+	// A declaration-free TEXT can be a C-ABI entry trampoline that consists of
+	// a direct tail transfer to a Go-declared function. FP-slot heuristics have
+	// no return information for such a function, while the tail target provides
+	// its complete ABI. Inherit that signature only when every external tail
+	// target is declared and agrees, leaving ordinary register-return assembly
+	// on the conservative fallback above.
+	for _, fn := range file.Funcs {
+		callerResolved := resolve(stripABISuffix(fn.Sym))
+		if !fallbackAsmSigs[callerResolved] {
+			continue
+		}
+		var inferred *plan9asm.FuncSig
+		valid := true
+		for _, ins := range fn.Instrs {
+			op := strings.ToUpper(string(ins.Op))
+			if !(op == "JMP" || op == "B" || (op == "RET" && len(ins.Args) == 1)) || len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+				continue
+			}
+			s := strings.TrimSpace(ins.Args[0].Sym)
+			if !strings.HasSuffix(s, "(SB)") {
+				continue
+			}
+			base, off := splitSymPlusOff(strings.TrimSuffix(s, "(SB)"))
+			targetResolved := resolve(stripABISuffix(base))
+			target, ok := sigs[targetResolved]
+			if base == "" || off != 0 || !ok || !knownABISigs[targetResolved] {
+				valid = false
+				break
+			}
+			target.Name = callerResolved
+			if inferred == nil {
+				candidate := target
+				inferred = &candidate
+			} else if !reflect.DeepEqual(*inferred, target) {
+				valid = false
+				break
+			}
+		}
+		if valid && inferred != nil {
+			sigs[callerResolved] = *inferred
+		}
+	}
+
+	asmsig.RefineTailForwarders(file, sigs, resolve, knownABISigs)
+	for _, fn := range file.Funcs {
+		name := resolve(stripABISuffix(fn.Sym))
+		if fallbackAsmSigs[name] && !knownABISigs[name] {
+			if err := validateInferredX86FrameExtent(fn, sigs[name], goarch); err != nil {
+				return nil, nil, err
+			}
+			// Record only this producer's plain register-entry guesses. The
+			// value has no mutable slices or source capabilities to borrow.
+			sig := sigs[name]
+			plain := plan9asm.FuncSig{Name: name, Ret: sig.Ret, Args: sig.Args, Frame: sig.Frame}
+			if registerFallbacks != nil && goarch == "amd64" && len(sig.Args)+len(sig.Frame.Params)+len(sig.Frame.Results) == 0 &&
+				reflect.DeepEqual(sig, plain) {
+				registerFallbacks[name] = plain
+			}
+		}
+	}
+
+	return sigs, declaredArgSizes, nil
+}
+
+// A fallback's observed FP offsets suggest types, not an argument envelope.
+// Only the original explicit TEXT bounds those heuristic words. An actual Go
+// declaration (including an independently established tail ABI) has its own
+// layout and is deliberately not routed through this check.
+func validateInferredX86FrameExtent(fn plan9asm.Func, sig plan9asm.FuncSig, goarch string) error {
+	if goarch != "386" && goarch != "amd64" || len(sig.Frame.Params)+len(sig.Frame.Results) == 0 {
+		return nil
+	}
+	readsFrame := false
+	for _, ins := range fn.Instrs {
+		for _, operand := range ins.Args {
+			readsFrame = readsFrame || operand.Kind == plan9asm.OpFP || operand.Kind == plan9asm.OpFPAddr
+		}
+	}
+	if !readsFrame {
+		return nil // Pure tail forwarders borrow a separately proved ABI, not inferred source slots.
+	}
+	word := int64(8)
+	if goarch == "386" {
+		word = 4
+	}
+	for _, slots := range [][]plan9asm.FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for _, slot := range slots {
+			if !hasExplicitTextArgSize(fn) || slot.Offset < 0 || slot.Offset > fn.ArgSize-word {
+				return fmt.Errorf("%w: %s inferred FP word lacks its original explicit TEXT extent", plan9asm.ErrProbeNeedsContext, fn.Sym)
+			}
+		}
+	}
+	return nil
+}
+
+func validateDeclaredTextArgSizes(file *plan9asm.File, resolve func(string) string, declaredArgSizes map[string]int64, goarch string) error {
+	for _, fn := range file.Funcs {
+		if !hasExplicitTextArgSize(fn) {
+			continue
+		}
+		// Go's own assembly uses the historical $frame-0 spelling for
+		// declaration-backed functions whose arguments are supplied by ABI
+		// wrappers or intentionally unused (for example runtime.procyieldAsm
+		// and exitThread on wasm). The assembler treats that zero as a legacy
+		// wildcard. A nonzero size must match either the declared data end or
+		// the ABI0 allocation; trailing alignment does not create FP slots.
+		if fn.ArgSize == 0 {
+			continue
+		}
+		resolved := resolve(stripABISuffix(fn.Sym))
+		expected, ok := declaredArgSizes[resolved]
+		if !ok || fn.ArgSize == expected {
+			continue
+		}
+		if !strings.Contains(fn.Sym, "<ABIInternal>") && goabi.MatchesABI0TextSize(goarch, fn.ArgSize, expected) {
+			continue
+		}
+		return &asmABINotApplicableError{
+			Symbol:          resolved,
+			Goarch:          goarch,
+			DeclaredArgSize: fn.ArgSize,
+			ExpectedArgSize: expected,
+		}
+	}
+	return nil
+}
+
+func hasExplicitTextArgSize(fn plan9asm.Func) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op != plan9asm.OpTEXT {
+			continue
+		}
+		parts := strings.Split(ins.Raw, ",")
+		if len(parts) < 2 {
+			return false
+		}
+		spec := strings.TrimSpace(parts[len(parts)-1])
+		if !strings.HasPrefix(spec, "$") {
+			return false
+		}
+		return strings.LastIndex(strings.TrimPrefix(spec, "$"), "-") > 0
+	}
+	return false
 }
 
-func fallbackSigForAsmFunc(fn plan9asm.Func, resolved string) plan9asm.FuncSig {
+func fallbackSigForAsmFunc(fn plan9asm.Func, resolved, goarch string) plan9asm.FuncSig {
+	if goarch == "arm" {
+		if native, ok := plan9asm.ARMKernelHelperFuncSig(fn, resolved); ok {
+			return native
+		}
+	}
 	paramOff := map[int64]struct{}{}
 	retOff := map[int64]struct{}{}
 
 	for _, ins := range fn.Instrs {
 		op := strings.ToUpper(string(ins.Op))
 		for i, a := range ins.Args {
-			if a.Kind != plan9asm.OpFP {
+			if a.Kind != plan9asm.OpFP && a.Kind != plan9asm.OpFPAddr {
 				continue
 			}
+			offsets := paramOff
 			if isLikelyResultSlot(op, i, len(ins.Args), a.FPName) {
-				retOff[a.FPOffset] = struct{}{}
-			} else {
-				paramOff[a.FPOffset] = struct{}{}
+				offsets = retOff
+			}
+			offsets[a.FPOffset] = struct{}{}
+			if goarch == "arm64" {
+				// Wide source accesses consume all of their words. This only
+				// supplies the assembly-only fallback; actual Go declarations
+				// retain their exact scalar fields and unaddressable padding.
+				for byteOffset := int64(8); byteOffset < plan9asm.ARM64FPAccessBytes(ins, i); byteOffset += 8 {
+					offsets[a.FPOffset+byteOffset] = struct{}{}
+				}
 			}
 		}
 	}
 
 	paramList := sortOffsets(paramOff)
 	retList := sortOffsets(retOff)
+	word := plan9asm.I64
+	if goarch == "386" || goarch == "arm" {
+		word = plan9asm.I32
+	}
 	params := make([]plan9asm.FrameSlot, 0, len(paramList))
 	for i, off := range paramList {
-		params = append(params, plan9asm.FrameSlot{Offset: off, Type: plan9asm.I64, Index: i, Field: -1})
+		params = append(params, plan9asm.FrameSlot{Offset: off, Type: word, Index: i, Field: -1})
 	}
 	results := make([]plan9asm.FrameSlot, 0, len(retList))
 	for i, off := range retList {
-		results = append(results, plan9asm.FrameSlot{Offset: off, Type: plan9asm.I64, Index: i, Field: -1})
+		results = append(results, plan9asm.FrameSlot{Offset: off, Type: word, Index: i, Field: -1})
 	}
 
 	args := make([]plan9asm.LLVMType, len(params))
 	for i := range args {
-		args[i] = plan9asm.I64
+		args[i] = word
 	}
 	ret := plan9asm.Void
 	switch len(results) {
 	case 0:
-		ret = plan9asm.I64
+		// A fallback with FP parameters follows ABI0, whose results also live
+		// in explicit FP slots. No result slot therefore means void. Keep the
+		// conservative word return only for register-only assembly helpers.
+		if len(params) == 0 {
+			ret = word
+		}
 	case 1:
-		ret = plan9asm.I64
+		ret = word
 	default:
 		parts := make([]string, 0, len(results))
 		for range results {
-			parts = append(parts, string(plan9asm.I64))
+			parts = append(parts, string(word))
 		}
 		ret = plan9asm.LLVMType("{ " + strings.Join(parts, ", ") + " }")
 	}
@@ -866,7 +2016,7 @@ func sortOffsets(m map[int64]struct{}) []int64 {
 	return out
 }
 
-func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]string, goarch string, sz types.Sizes) (plan9asm.FuncSig, bool, error) {
+func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]string, goarch string, sz types.Sizes, internal bool) (plan9asm.FuncSig, int64, bool, error) {
 	declName := strings.TrimPrefix(sym, "·")
 	if strings.ContainsRune(declName, '·') {
 		key := strings.ReplaceAll(sym, "∕", "/")
@@ -874,33 +2024,47 @@ func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]s
 		if local, ok := linknames[key]; ok {
 			declName = local
 		} else {
-			return plan9asm.FuncSig{}, false, nil
+			dot := strings.LastIndexByte(key, '.')
+			if dot < 0 || dot == len(key)-1 {
+				return plan9asm.FuncSig{}, 0, false, nil
+			}
+			candidate := key[dot+1:]
+			obj := scope.Lookup(candidate)
+			if obj == nil || (key != resolved && (obj.Pkg() == nil || resolved != obj.Pkg().Path()+"."+candidate)) {
+				return plan9asm.FuncSig{}, 0, false, nil
+			}
+			declName = candidate
 		}
 	}
 	obj := scope.Lookup(declName)
 	if obj == nil {
-		return plan9asm.FuncSig{}, false, nil
+		return plan9asm.FuncSig{}, 0, false, nil
 	}
 	fn, ok := obj.(*types.Func)
 	if !ok {
-		return plan9asm.FuncSig{}, false, nil
+		return plan9asm.FuncSig{}, 0, false, nil
 	}
 	sig := fn.Type().(*types.Signature)
 	if sig.Recv() != nil || sig.Variadic() {
-		return plan9asm.FuncSig{}, false, nil
+		return plan9asm.FuncSig{}, 0, false, nil
 	}
 
 	args, frameParams, nextOff, err := llvmArgsAndFrameSlotsForTuple(sig.Params(), goarch, sz, 0, false)
 	if err != nil {
-		return plan9asm.FuncSig{}, false, fmt.Errorf("%s: %w", fn.FullName(), err)
+		return plan9asm.FuncSig{}, 0, false, fmt.Errorf("%s: %w", fn.FullName(), err)
 	}
-	nextOff = alignOff(nextOff, int64(wordSize(goarch)))
-	retTys, frameResults, _, err := llvmArgsAndFrameSlotsForTuple(sig.Results(), goarch, sz, nextOff, true)
+	// Go's TEXT argument size ends at the last declared parameter when a
+	// function has no results. The word-aligned gap separates parameters from
+	// results, so it exists only when there is a result section.
+	if sig.Results() != nil && sig.Results().Len() != 0 {
+		nextOff = alignOff(nextOff, int64(wordSize(goarch)))
+	}
+	retTys, frameResults, argSize, err := llvmArgsAndFrameSlotsForTuple(sig.Results(), goarch, sz, nextOff, true)
 	if err != nil {
-		return plan9asm.FuncSig{}, false, fmt.Errorf("%s: %w", fn.FullName(), err)
+		return plan9asm.FuncSig{}, 0, false, fmt.Errorf("%s: %w", fn.FullName(), err)
 	}
 	ret := tupleRetType(retTys)
-	return plan9asm.FuncSig{
+	fs := plan9asm.FuncSig{
 		Name: resolved,
 		Args: args,
 		Ret:  ret,
@@ -908,7 +2072,26 @@ func tryDeclSig(scope *types.Scope, sym, resolved string, linknames map[string]s
 			Params:  frameParams,
 			Results: frameResults,
 		},
-	}, true, nil
+	}
+	if goarch == "arm64" && internal {
+		fs.ARM64GoRegisterABI, err = plan9asm.DeriveARM64GoRegisterABI(fn, fs)
+		if err != nil {
+			return plan9asm.FuncSig{}, 0, false, err
+		}
+	} else if goarch == "arm64" {
+		// The common actual-declaration builder also retains its private FP
+		// bit-use input, but only for an identical existing CLI transport. In
+		// particular the CLI's omitted zero-size inputs remain unclosed; this
+		// read-only proof cannot silently add an argument or change its index.
+		actual, err := plan9asm.DeriveGoFuncABI0Signature(resolved, fn, goarch, sz)
+		if err != nil {
+			return plan9asm.FuncSig{}, 0, false, err
+		}
+		if reflect.DeepEqual(fs.Args, actual.Args) && fs.Ret == actual.Ret && reflect.DeepEqual(fs.Frame, actual.Frame) {
+			fs = actual
+		}
+	}
+	return fs, argSize, true, nil
 }
 
 func tupleRetType(ts []plan9asm.LLVMType) plan9asm.LLVMType {
@@ -927,19 +2110,7 @@ func tupleRetType(ts []plan9asm.LLVMType) plan9asm.LLVMType {
 }
 
 func splitSymPlusOff(s string) (base string, off int64) {
-	s = strings.TrimSpace(s)
-	if s == "" {
-		return "", 0
-	}
-	sep := strings.LastIndexAny(s, "+-")
-	if sep <= 0 || sep == len(s)-1 {
-		return s, 0
-	}
-	n, err := strconv.ParseInt(strings.TrimSpace(s[sep:]), 0, 64)
-	if err != nil {
-		return s, 0
-	}
-	return strings.TrimSpace(s[:sep]), n
+	return plan9asm.SplitSymbolOffset(s)
 }
 
 func linknameRemoteToLocal(files []*ast.File) map[string]string {
@@ -992,15 +2163,25 @@ func llvmArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz types.Siz
 	off := startOff
 	argIdx := 0
 	for i := 0; i < tup.Len(); i++ {
+		name := ""
+		if flattenAgg {
+			name = tup.At(i).Name()
+		}
 		t := tup.At(i).Type()
 		off = align(off, int64(sz.Alignof(t)))
+		if sz.Sizeof(t) == 0 {
+			continue
+		}
 
-		parts, ok := framePartsForType(t, goarch)
+		parts, ok, e := framePartsForType(t, goarch, sz)
+		if e != nil {
+			return nil, nil, 0, e
+		}
 		if ok {
 			if flattenAgg {
 				for _, part := range parts {
 					args = append(args, part.Type)
-					slots = append(slots, plan9asm.FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: -1})
+					slots = append(slots, plan9asm.FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: -1, Name: name})
 					argIdx++
 				}
 			} else {
@@ -1010,7 +2191,7 @@ func llvmArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz types.Siz
 				}
 				args = append(args, ty)
 				for _, part := range parts {
-					slots = append(slots, plan9asm.FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: part.Field})
+					slots = append(slots, plan9asm.FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: part.Field, Fields: part.Fields})
 				}
 				argIdx++
 			}
@@ -1023,7 +2204,7 @@ func llvmArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz types.Siz
 			return nil, nil, 0, e
 		}
 		args = append(args, ty)
-		slots = append(slots, plan9asm.FrameSlot{Offset: off, Type: ty, Index: argIdx, Field: -1})
+		slots = append(slots, plan9asm.FrameSlot{Offset: off, Type: ty, Index: argIdx, Field: -1, Name: name})
 		argIdx++
 		off += int64(sz.Sizeof(t))
 	}
@@ -1034,39 +2215,114 @@ type framePart struct {
 	Offset int64
 	Type   plan9asm.LLVMType
 	Field  int
+	Fields []int
 }
 
-func framePartsForType(t types.Type, goarch string) ([]framePart, bool) {
+func framePartsForType(t types.Type, goarch string, sz types.Sizes) ([]framePart, bool, error) {
 	word := int64(wordSize(goarch))
 	wordTy := plan9asm.I64
 	if word == 4 {
 		wordTy = plan9asm.LLVMType("i32")
 	}
-	switch u := types.Unalias(t).(type) {
+	switch u := types.Unalias(t).Underlying().(type) {
 	case *types.Basic:
-		if u.Kind() == types.String {
+		switch u.Kind() {
+		case types.String:
 			return []framePart{
 				{Offset: 0, Type: plan9asm.Ptr, Field: 0},
 				{Offset: word, Type: wordTy, Field: 1},
-			}, true
+			}, true, nil
+		case types.Complex64:
+			return []framePart{
+				{Offset: 0, Type: plan9asm.LLVMType("float"), Field: 0},
+				{Offset: 4, Type: plan9asm.LLVMType("float"), Field: 1},
+			}, true, nil
+		case types.Complex128:
+			return []framePart{
+				{Offset: 0, Type: plan9asm.LLVMType("double"), Field: 0},
+				{Offset: 8, Type: plan9asm.LLVMType("double"), Field: 1},
+			}, true, nil
 		}
 	case *types.Slice:
 		return []framePart{
 			{Offset: 0, Type: plan9asm.Ptr, Field: 0},
 			{Offset: word, Type: wordTy, Field: 1},
 			{Offset: 2 * word, Type: wordTy, Field: 2},
-		}, true
+		}, true, nil
 	case *types.Interface:
 		// Both empty and non-empty interfaces occupy two pointers in Go ABI.
 		return []framePart{
 			{Offset: 0, Type: plan9asm.Ptr, Field: 0},
 			{Offset: word, Type: plan9asm.Ptr, Field: 1},
-		}, true
+		}, true, nil
+	case *types.Array:
+		elemParts, elemAggregate, err := framePartsForType(u.Elem(), goarch, sz)
+		if err != nil {
+			return nil, false, err
+		}
+		if !elemAggregate {
+			elemType, err := llvmTypeForGo(u.Elem(), goarch)
+			if err != nil {
+				return nil, false, err
+			}
+			elemParts = []framePart{{Type: elemType, Field: -1}}
+		}
+		elemSize := int64(sz.Sizeof(u.Elem()))
+		parts := make([]framePart, 0, int(u.Len())*len(elemParts))
+		for i := int64(0); i < u.Len(); i++ {
+			for _, part := range elemParts {
+				parts = append(parts, nestedFramePart(part, int(i), i*elemSize))
+			}
+		}
+		return parts, true, nil
+	case *types.Struct:
+		fields := make([]*types.Var, u.NumFields())
+		for i := range fields {
+			fields[i] = u.Field(i)
+		}
+		offsets := sz.Offsetsof(fields)
+		var parts []framePart
+		for i, field := range fields {
+			fieldParts, fieldAggregate, err := framePartsForType(field.Type(), goarch, sz)
+			if err != nil {
+				return nil, false, err
+			}
+			if !fieldAggregate {
+				fieldType, err := llvmTypeForGo(field.Type(), goarch)
+				if err != nil {
+					return nil, false, err
+				}
+				fieldParts = []framePart{{Type: fieldType, Field: -1}}
+			}
+			for _, part := range fieldParts {
+				parts = append(parts, nestedFramePart(part, i, offsets[i]))
+			}
+		}
+		return parts, true, nil
 	}
-	return nil, false
+	return nil, false, nil
+}
+
+func nestedFramePart(part framePart, field int, offset int64) framePart {
+	path := make([]int, 0, 1+len(part.Fields)+1)
+	path = append(path, field)
+	if len(part.Fields) != 0 {
+		path = append(path, part.Fields...)
+	} else if part.Field >= 0 {
+		path = append(path, part.Field)
+	}
+	part.Offset += offset
+	part.Field = field
+	if len(path) > 1 {
+		part.Fields = path
+	} else {
+		part.Fields = nil
+	}
+	return part
 }
 
 func llvmTypeForGo(t types.Type, goarch string) (plan9asm.LLVMType, error) {
+	t = types.Unalias(t)
 	switch tt := t.(type) {
 	case *types.Basic:
 		switch tt.Kind() {
@@ -1091,6 +2347,10 @@ func llvmTypeForGo(t types.Type, goarch string) (plan9asm.LLVMType, error) {
 			return plan9asm.LLVMType("float"), nil
 		case types.Float64:
 			return plan9asm.LLVMType("double"), nil
+		case types.Complex64:
+			return plan9asm.LLVMType("{ float, float }"), nil
+		case types.Complex128:
+			return plan9asm.LLVMType("{ double, double }"), nil
 		case types.String:
 			if wordSize(goarch) == 8 {
 				return plan9asm.LLVMType("{ ptr, i64 }"), nil
@@ -1101,6 +2361,8 @@ func llvmTypeForGo(t types.Type, goarch string) (plan9asm.LLVMType, error) {
 		}
 	case *types.Pointer:
 		return plan9asm.Ptr, nil
+	case *types.Signature, *types.Map, *types.Chan:
+		return plan9asm.Ptr, nil
 	case *types.Slice:
 		if wordSize(goarch) == 8 {
 			return plan9asm.LLVMType("{ ptr, i64, i64 }"), nil
@@ -1108,6 +2370,25 @@ func llvmTypeForGo(t types.Type, goarch string) (plan9asm.LLVMType, error) {
 		return plan9asm.LLVMType("{ ptr, i32, i32 }"), nil
 	case *types.Interface:
 		return plan9asm.LLVMType("{ ptr, ptr }"), nil
+	case *types.Array:
+		elem, err := llvmTypeForGo(tt.Elem(), goarch)
+		if err != nil {
+			return "", err
+		}
+		return plan9asm.LLVMType(fmt.Sprintf("[%d x %s]", tt.Len(), elem)), nil
+	case *types.Struct:
+		if tt.NumFields() == 0 {
+			return plan9asm.LLVMType("[0 x i8]"), nil
+		}
+		fields := make([]string, tt.NumFields())
+		for i := range fields {
+			fieldType, err := llvmTypeForGo(tt.Field(i).Type(), goarch)
+			if err != nil {
+				return "", err
+			}
+			fields[i] = string(fieldType)
+		}
+		return plan9asm.LLVMType("{ " + strings.Join(fields, ", ") + " }"), nil
 	case *types.Named:
 		return llvmTypeForGo(tt.Underlying(), goarch)
 	default:
@@ -1117,7 +2398,7 @@ func llvmTypeForGo(t types.Type, goarch string) (plan9asm.LLVMType, error) {
 
 func wordSize(goarch string) int {
 	switch goarch {
-	case "amd64", "arm64", "loong64", "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x":
+	case "amd64", "arm64", "loong64", "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "wasm":
 		return 8
 	default:
 		return 4
@@ -1193,7 +2474,7 @@ func normalizeOp(op string) string {
 
 func isDirective(op string) bool {
 	switch op {
-	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "FUNCDATA", "PCDATA":
+	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "PCALIGNMAX", "FUNCDATA", "PCDATA":
 		return true
 	default:
 		return false
@@ -1202,17 +2483,18 @@ func isDirective(op string) bool {
 
 func extractSupportedOps(repoRoot, goarch string) (map[string]struct{}, error) {
 	supported := map[string]struct{}{
-		"RET":      {},
-		"TEXT":     {},
-		"GLOBL":    {},
-		"DATA":     {},
-		"BYTE":     {},
-		"WORD":     {},
-		"LONG":     {},
-		"QUAD":     {},
-		"PCALIGN":  {},
-		"FUNCDATA": {},
-		"PCDATA":   {},
+		"RET":        {},
+		"TEXT":       {},
+		"GLOBL":      {},
+		"DATA":       {},
+		"BYTE":       {},
+		"WORD":       {},
+		"LONG":       {},
+		"QUAD":       {},
+		"PCALIGN":    {},
+		"PCALIGNMAX": {},
+		"FUNCDATA":   {},
+		"PCDATA":     {},
 	}
 
 	backendArch := goarch
@@ -1225,7 +2507,16 @@ func extractSupportedOps(repoRoot, goarch string) (map[string]struct{}, error) {
 		return nil, err
 	}
 	files = append(files, filepath.Join(repoRoot, "translate.go"))
+	if goarch == "386" || goarch == "amd64" {
+		shared, err := filepath.Glob(filepath.Join(repoRoot, "x86_*.go"))
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, shared...)
+	}
 	sort.Strings(files)
+	var sharedFiles []*ast.File
+	var extractionFiles []*ast.File
 
 	for _, f := range files {
 		if strings.HasSuffix(f, "_test.go") {
@@ -1235,80 +2526,198 @@ func extractSupportedOps(repoRoot, goarch string) (map[string]struct{}, error) {
 		if err != nil {
 			return nil, fmt.Errorf("read %s: %w", f, err)
 		}
-		for _, m := range reCaseString.FindAllSubmatch(src, -1) {
-			nop := normalizeOp(string(m[1]))
-			if nop != "" {
-				supported[nop] = struct{}{}
-			}
+		parsed, err := parser.ParseFile(token.NewFileSet(), f, src, 0)
+		if err != nil {
+			return nil, fmt.Errorf("parse %s for supported instructions: %w", f, err)
 		}
-		for _, m := range reCaseOp.FindAllSubmatch(src, -1) {
-			nop := normalizeOp(string(m[1]))
-			if nop != "" {
-				supported[nop] = struct{}{}
-			}
+		extractionFiles = append(extractionFiles, parsed)
+		if strings.HasPrefix(filepath.Base(f), "x86_") {
+			sharedFiles = append(sharedFiles, parsed)
+			continue
 		}
-		// Handle multi-value case clauses like:
-		// case "A", "B", "C":
-		for _, ln := range strings.Split(string(src), "\n") {
-			if !strings.Contains(ln, "case") {
+		// Package-level opcode specification maps are dispatch tables even when
+		// their variable name does not contain "op" (for example a complete
+		// instruction-family Specs table). Restrict this broader inference to
+		// package declarations so local maps for predicates, registers, and LLVM
+		// spellings cannot accidentally advertise instructions.
+		for _, decl := range parsed.Decls {
+			gen, ok := decl.(*ast.GenDecl)
+			if !ok || gen.Tok != token.VAR {
 				continue
 			}
-			for _, m := range reQuotedOp.FindAllStringSubmatch(ln, -1) {
-				nop := normalizeOp(m[1])
-				if nop != "" {
-					supported[nop] = struct{}{}
+			for _, declared := range gen.Specs {
+				spec, ok := declared.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				for _, value := range spec.Values {
+					literal, ok := value.(*ast.CompositeLit)
+					if !ok {
+						continue
+					}
+					collectSupportedOpcodeMap(supported, literal)
 				}
 			}
-			for _, m := range reOpToken.FindAllStringSubmatch(ln, -1) {
-				nop := normalizeOp(m[1])
-				if nop != "" {
+		}
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			// Family lowerers commonly reject everything except their opcode at
+			// the top of the function (for example `if op != "VDUP"`).  Those
+			// handlers are just as authoritative as switch cases and opcode maps;
+			// include only comparisons whose other operand is literally named op
+			// so unrelated string predicates cannot advertise false support.
+			if comparison, ok := node.(*ast.BinaryExpr); ok &&
+				(comparison.Op == token.EQL || comparison.Op == token.NEQ) {
+				if candidate, ok := opcodeComparedWithOp(comparison.X, comparison.Y); ok {
+					if nop := normalizeOp(candidate); nop != "" {
+						supported[nop] = struct{}{}
+					}
+				}
+			}
+			if spec, ok := node.(*ast.ValueSpec); ok {
+				for i, name := range spec.Names {
+					// Several backends keep their complete opcode tables in a
+					// map[string]spec rather than map[Op]spec. Limit string-key
+					// extraction to declarations explicitly named as opcode maps;
+					// otherwise condition-code and register-name tables would be
+					// mistaken for supported instructions.
+					if !strings.Contains(strings.ToLower(name.Name), "op") || len(spec.Values) == 0 {
+						continue
+					}
+					valueIndex := i
+					if len(spec.Values) == 1 {
+						valueIndex = 0
+					}
+					if valueIndex >= len(spec.Values) {
+						continue
+					}
+					literal, ok := spec.Values[valueIndex].(*ast.CompositeLit)
+					if !ok {
+						continue
+					}
+					mapType, isMap := literal.Type.(*ast.MapType)
+					keyType, stringKeyed := mapTypeKeyIdent(mapType)
+					if !isMap || !stringKeyed || keyType != "string" {
+						continue
+					}
+					for _, elt := range literal.Elts {
+						pair, ok := elt.(*ast.KeyValueExpr)
+						if !ok {
+							continue
+						}
+						key, ok := pair.Key.(*ast.BasicLit)
+						if !ok || key.Kind != token.STRING {
+							continue
+						}
+						candidate, _ := strconv.Unquote(key.Value)
+						if nop := normalizeOp(candidate); nop != "" {
+							supported[nop] = struct{}{}
+						}
+					}
+				}
+			}
+			literal, ok := node.(*ast.CompositeLit)
+			if ok {
+				mapType, isMap := literal.Type.(*ast.MapType)
+				keyType, isOpMap := mapTypeKeyIdent(mapType)
+				if isMap && isOpMap && keyType == "Op" {
+					for _, elt := range literal.Elts {
+						pair, ok := elt.(*ast.KeyValueExpr)
+						if !ok {
+							continue
+						}
+						key, ok := pair.Key.(*ast.BasicLit)
+						if !ok || key.Kind != token.STRING {
+							continue
+						}
+						candidate, _ := strconv.Unquote(key.Value)
+						if nop := normalizeOp(candidate); nop != "" {
+							supported[nop] = struct{}{}
+						}
+					}
+				}
+			}
+			clause, ok := node.(*ast.CaseClause)
+			if !ok {
+				return true
+			}
+			for _, expr := range clause.List {
+				candidate := ""
+				switch value := expr.(type) {
+				case *ast.BasicLit:
+					if value.Kind == token.STRING {
+						candidate, _ = strconv.Unquote(value.Value)
+					}
+				case *ast.Ident:
+					if strings.HasPrefix(value.Name, "Op") {
+						candidate = strings.TrimPrefix(value.Name, "Op")
+					}
+				}
+				if nop := normalizeOp(candidate); nop != "" {
 					supported[nop] = struct{}{}
 				}
 			}
+			return true
+		})
+	}
+	if len(sharedFiles) != 0 {
+		types, err := loadSharedX86OpcodeTypes(repoRoot, extractionFiles)
+		if err != nil {
+			return nil, err
+		}
+		for _, file := range sharedFiles {
+			collectSharedX86OpcodeDispatch(supported, file, types)
 		}
 	}
 	return supported, nil
 }
 
-func unsupportedInAsmFile(path string, arch plan9asm.Arch, supported map[string]struct{}) ([]string, []unsupportedHit) {
-	if len(supported) == 0 {
-		return nil, nil
-	}
-	src, err := os.ReadFile(path)
-	if err != nil {
-		return nil, nil
+func opcodeComparedWithOp(left, right ast.Expr) (string, bool) {
+	if ident, ok := left.(*ast.Ident); ok && ident.Name == "op" {
+		if literal, ok := right.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+			candidate, err := strconv.Unquote(literal.Value)
+			return candidate, err == nil
+		}
 	}
-	hits := scanUnsupportedHits(src, supported)
-	file, err := plan9asm.Parse(arch, string(src))
-	if err != nil {
-		if len(hits) == 0 {
-			return nil, nil
+	if ident, ok := right.(*ast.Ident); ok && ident.Name == "op" {
+		if literal, ok := left.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+			candidate, err := strconv.Unquote(literal.Value)
+			return candidate, err == nil
 		}
-		return uniqueUnsupportedOpsFromHits(hits), hits
 	}
-	seen := map[string]struct{}{}
-	for _, fn := range file.Funcs {
-		for _, ins := range fn.Instrs {
-			nop := normalizeOp(string(ins.Op))
-			if nop == "" || nop == "LABEL" || isDirective(nop) {
-				continue
-			}
-			if _, ok := supported[nop]; !ok {
-				seen[nop] = struct{}{}
-			}
+	return "", false
+}
+
+func collectSupportedOpcodeMap(supported map[string]struct{}, literal *ast.CompositeLit) {
+	mapType, isMap := literal.Type.(*ast.MapType)
+	keyType, supportedKey := mapTypeKeyIdent(mapType)
+	if !isMap || !supportedKey || keyType != "string" && keyType != "Op" {
+		return
+	}
+	for _, elt := range literal.Elts {
+		pair, ok := elt.(*ast.KeyValueExpr)
+		if !ok {
+			continue
+		}
+		key, ok := pair.Key.(*ast.BasicLit)
+		if !ok || key.Kind != token.STRING {
+			continue
+		}
+		candidate, _ := strconv.Unquote(key.Value)
+		if nop := normalizeOp(candidate); nop != "" {
+			supported[nop] = struct{}{}
 		}
 	}
-	if len(seen) == 0 {
-		return nil, hits
+}
+
+func mapTypeKeyIdent(mapType *ast.MapType) (string, bool) {
+	if mapType == nil {
+		return "", false
 	}
-	out := make([]string, 0, len(seen))
-	for op := range seen {
-		out = append(out, op)
+	ident, ok := mapType.Key.(*ast.Ident)
+	if !ok {
+		return "", false
 	}
-	sort.Strings(out)
-	// If parser-based set and line-based scan differ, prefer parser result for
-	// op list but still keep line hits from source scanning.
-	return out, hits
+	return ident.Name, true
 }
 
 func flattenUnsupportedAgg(agg map[string]int) []opCount {
@@ -1328,87 +2737,8 @@ func flattenUnsupportedAgg(agg map[string]int) []opCount {
 	return out
 }
 
-func uniqueUnsupportedOpsFromHits(hits []unsupportedHit) []string {
-	seen := map[string]struct{}{}
-	for _, h := range hits {
-		seen[h.Op] = struct{}{}
-	}
-	out := make([]string, 0, len(seen))
-	for op := range seen {
-		out = append(out, op)
-	}
-	sort.Strings(out)
-	return out
-}
-
-func scanUnsupportedHits(src []byte, supported map[string]struct{}) []unsupportedHit {
-	lines := strings.Split(string(src), "\n")
-	out := make([]unsupportedHit, 0)
-	for i, line := range lines {
-		lineno := i + 1
-		raw := stripLineComment(line)
-		raw = strings.TrimSpace(raw)
-		if raw == "" || strings.HasPrefix(raw, "#") {
-			continue
-		}
-		stmts := strings.Split(raw, ";")
-		for _, stmt := range stmts {
-			stmt = strings.TrimSpace(stmt)
-			if stmt == "" {
-				continue
-			}
-			// Skip labels.
-			if strings.HasSuffix(stmt, ":") {
-				continue
-			}
-			// Handle "label: INSTR ..." on one line.
-			if c := strings.IndexByte(stmt, ':'); c >= 0 {
-				left := strings.TrimSpace(stmt[:c])
-				right := strings.TrimSpace(stmt[c+1:])
-				if left != "" && right != "" && !strings.Contains(left, " ") && !strings.Contains(left, "\t") {
-					stmt = right
-				}
-			}
-			fields := strings.Fields(stmt)
-			if len(fields) == 0 {
-				continue
-			}
-			op := normalizeOp(fields[0])
-			if op == "" || op == "LABEL" || isDirective(op) {
-				continue
-			}
-			if _, ok := supported[op]; ok {
-				continue
-			}
-			out = append(out, unsupportedHit{
-				Op:     op,
-				Line:   lineno,
-				Source: stmt,
-			})
-		}
-	}
-	sort.Slice(out, func(i, j int) bool {
-		if out[i].Line != out[j].Line {
-			return out[i].Line < out[j].Line
-		}
-		if out[i].Op != out[j].Op {
-			return out[i].Op < out[j].Op
-		}
-		return out[i].Source < out[j].Source
-	})
-	return out
-}
-
-func stripLineComment(s string) string {
-	// Plan9 asm comments typically start with //.
-	if i := strings.Index(s, "//"); i >= 0 {
-		return s[:i]
-	}
-	return s
-}
-
 func printUnsupportedHits(hits []unsupportedHit) {
 	for _, h := range hits {
-		fmt.Fprintf(os.Stderr, "    L%-5d %-12s %s\n", h.Line, h.Op, h.Source)
+		fmt.Fprintf(os.Stderr, "    %s instruction %d: %-12s %s\n", h.Function, h.Instruction, h.Op, h.Source)
 	}
 }
diff --git a/cmd/plan9asmll/main_test.go b/cmd/plan9asmll/main_test.go
index 480b5a61a..a7bcc4de5 100644
--- a/cmd/plan9asmll/main_test.go
+++ b/cmd/plan9asmll/main_test.go
@@ -1,17 +1,2168 @@
 package main
 
 import (
+	"errors"
+	"fmt"
+	"go/constant"
 	"go/token"
 	"go/types"
 	"os"
 	"path/filepath"
 	"reflect"
+	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/xgo-dev/plan9asm"
 	"golang.org/x/tools/go/packages"
 )
 
+func TestLoadPkgsAvoidsTransitiveSyntax(t *testing.T) {
+	pkgs, err := loadPkgs(runtime.GOOS, runtime.GOARCH, []string{"crypto/md5"}, nil, "", true, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(pkgs) != 1 || pkgs[0].Types == nil {
+		t.Fatalf("loaded packages = %d, want one typed package", len(pkgs))
+	}
+	if pkgs[0].Types.Scope().Lookup("block") == nil {
+		t.Fatal("unexported assembly declaration was not loaded")
+	}
+
+	if len(pkgs[0].Types.Imports()) == 0 {
+		t.Fatal("package type information lost direct imports")
+	}
+	typedImports := 0
+	for path, imported := range pkgs[0].Imports {
+		if imported.Types != nil {
+			typedImports++
+		}
+		if len(imported.Syntax) != 0 {
+			t.Fatalf("dependency %s retained %d syntax trees", path, len(imported.Syntax))
+		}
+	}
+	if typedImports == 0 {
+		t.Fatal("package imports lost the types needed for assembly constants")
+	}
+}
+
+func TestLoadLinknameSyntaxOnlyForRelevantTargetFiles(t *testing.T) {
+	dir := t.TempDir()
+	plain := filepath.Join(dir, "plain.go")
+	linked := filepath.Join(dir, "linked.go")
+	if err := os.WriteFile(plain, []byte("package p\nfunc plain() {}\n"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	src := "package p\n//go:linkname local example.com/remote.F\nfunc local() {}\n"
+	if err := os.WriteFile(linked, []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{GoFiles: []string{plain, linked}}
+	if err := loadLinknameSyntax(pkg); err != nil {
+		t.Fatal(err)
+	}
+	if len(pkg.Syntax) != 1 {
+		t.Fatalf("retained %d syntax trees, want only the linkname file", len(pkg.Syntax))
+	}
+	if got := linknameRemoteToLocal(pkg.Syntax)["example.com/remote.F"]; got != "local" {
+		t.Fatalf("remote linkname resolves to %q, want local", got)
+	}
+}
+
+func TestWASMABIForGoPackageTarget(t *testing.T) {
+	if got := wasmABIForGoPackageTarget("wasm"); got != plan9asm.WASMABIGo {
+		t.Fatalf("wasmABIForGoPackageTarget(wasm) = %v, want Go stack ABI", got)
+	}
+	for _, goarch := range []string{"amd64", "386", "arm", "arm64"} {
+		if got := wasmABIForGoPackageTarget(goarch); got != plan9asm.WASMABIDirect {
+			t.Fatalf("wasmABIForGoPackageTarget(%s) = %v, want direct ABI", goarch, got)
+		}
+	}
+}
+
+func TestLLCCompileArgsSelectsExplicitOptimizationLevel(t *testing.T) {
+	for _, tc := range []struct {
+		level int
+		want  string
+	}{
+		{level: 0, want: "-O0"},
+		{level: 2, want: "-O2"},
+	} {
+		args := llcCompileArgs("x86_64-unknown-linux-gnu", "amd64", "input.ll", "output.o", tc.level)
+		if !containsArg(args, tc.want) {
+			t.Errorf("level %d args = %v, want %s", tc.level, args, tc.want)
+		}
+	}
+}
+
+func containsArg(args []string, want string) bool {
+	for _, arg := range args {
+		if arg == want {
+			return true
+		}
+	}
+	return false
+}
+
+func TestContainsTestAssembly(t *testing.T) {
+	for _, name := range []string{"pkg/routine_test_amd64.s", "pkg/routine_test.s"} {
+		if !containsTestAssembly([]string{name}) {
+			t.Errorf("containsTestAssembly(%q) = false, want true", name)
+		}
+	}
+	if containsTestAssembly([]string{"pkg/contest_amd64.s", "pkg/routine_amd64.s"}) {
+		t.Fatal("containsTestAssembly accepted non-test assembly")
+	}
+}
+
+func TestIsTestVariantPackage(t *testing.T) {
+	base := &packages.Package{ID: "example.com/p", PkgPath: "example.com/p"}
+	variant := &packages.Package{ID: "example.com/p [example.com/p.test]", PkgPath: "example.com/p"}
+	if isTestVariantPackage(base) || !isTestVariantPackage(variant) {
+		t.Fatalf("test variant classification: base=%v variant=%v", isTestVariantPackage(base), isTestVariantPackage(variant))
+	}
+}
+
+func TestRunOneTargetUsesTestDeclarationForExactTestAssembly(t *testing.T) {
+	report, _, err := runOneTarget(
+		targetSpec{Goos: "linux", Goarch: "amd64"},
+		[]string{"./testdata/testsignature"},
+		nil,
+		[]string{"testdata/testsignature/convert_test_amd64.s"},
+		"github.com/xgo-dev/plan9asm/cmd/plan9asmll",
+		t.TempDir(),
+		false,
+		0,
+		true,
+		false,
+		false,
+		filepath.Join("..", ".."),
+		compileConfig{},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("test assembly report = %#v, want one successful translation", report)
+	}
+}
+
+func TestCompileOneExpandsGoAsmPackageConstants(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/constants", "constants")
+	typesPkg.Scope().Insert(types.NewConst(token.NoPos, typesPkg, "q", types.Typ[types.UntypedInt], constant.MakeUint64(2013265921)))
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "vectorConstant", types.NewSignatureType(nil, nil, nil, nil, nil, false)))
+	pkg := &packages.Package{
+		PkgPath: "example.com/constants",
+		Types:   typesPkg,
+		Imports: map[string]*packages.Package{},
+	}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "constant_arm64.s")
+	if err := os.WriteFile(asm, []byte("TEXT ·vectorConstant(SB),$0-0\n\tVMOVS $const_q, V0\n\tRET\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "constant.ll")
+	if err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu", asmTask{
+		PkgPath: pkg.PkgPath,
+		AsmFile: asm,
+		OutLL:   out,
+	}, false, compileConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(ir), "i32 2013265921") {
+		t.Fatalf("translated package constant is absent from IR:\n%s", ir)
+	}
+}
+
+func TestCompileOneInfersVoidABI0LocalHelperAtTargetWordSize(t *testing.T) {
+	typesPkg := types.NewPackage("runtime", "runtime")
+	voidSignature := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "systemstack", voidSignature))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "386"),
+		Imports:    map[string]*packages.Package{},
+	}
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "asm_386.s")
+	const source = `TEXT runtime·systemstack(SB),NOSPLIT,$0-0
+	CALL gosave_systemstack_switch<>(SB)
+	RET
+
+TEXT gosave_systemstack_switch<>(SB),NOSPLIT,$0
+	LEAL arg+0(FP), AX
+	RET
+`
+	// The assembly-only helper has no Go declaration. Its inferred word must
+	// fit an explicit source extent; omitted args do not mean a four-byte frame.
+	bounded := strings.Replace(source, "NOSPLIT,$0\n", "NOSPLIT,$0-4\n", 1)
+	if err := os.WriteFile(asm, []byte(bounded), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "asm_386.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "386", "i386-unknown-linux-gnu", asmTask{
+		PkgPath: pkg.PkgPath,
+		AsmFile: asm,
+		OutLL:   out,
+	}, false, compileConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`define void @"runtime.gosave_systemstack_switch$local"(i32 %arg0)`,
+		`call void @"runtime.gosave_systemstack_switch$local"(i32 %`,
+	} {
+		if !strings.Contains(string(ir), want) {
+			t.Fatalf("translated ABI0 local helper omitted %q:\n%s", want, ir)
+		}
+	}
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "386", "i386-unknown-linux-gnu", asmTask{
+		PkgPath: pkg.PkgPath,
+		AsmFile: asm,
+		OutLL:   filepath.Join(dir, "unknown.ll"),
+	}, false, compileConfig{}); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("declaration-free helper with unknown args acquired a bounded frame", err)
+	}
+}
+
+func TestTryDeclSigResolvesSamePackageQualifiedPlan9Symbol(t *testing.T) {
+	pkg := types.NewPackage("runtime/internal/atomic", "atomic")
+	params := types.NewTuple(
+		types.NewParam(token.NoPos, pkg, "ptr", types.NewPointer(types.Typ[types.Uint64])),
+		types.NewParam(token.NoPos, pkg, "delta", types.Typ[types.Int64]),
+	)
+	results := types.NewTuple(types.NewParam(token.NoPos, pkg, "ret", types.Typ[types.Uint64]))
+	signature := types.NewSignatureType(nil, nil, nil, params, results, false)
+	pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, "Xadd64", signature))
+
+	got, _, ok, err := tryDeclSig(
+		pkg.Scope(),
+		"runtime∕internal∕atomic·Xadd64",
+		"runtime/internal/atomic.Xadd64",
+		nil,
+		"386",
+		types.SizesFor("gc", "386"),
+		false,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok || got.Ret != plan9asm.I64 || len(got.Args) != 2 || got.Args[0] != plan9asm.Ptr || got.Args[1] != plan9asm.I64 {
+		t.Fatalf("qualified declaration signature = %#v, ok=%v; want (ptr, i64) i64", got, ok)
+	}
+}
+
+func TestTryDeclSigUsesOfficialWASMFrameWordSize(t *testing.T) {
+	pkg := types.NewPackage("internal/bytealg", "bytealg")
+	params := types.NewTuple(
+		types.NewParam(token.NoPos, pkg, "a", types.Typ[types.String]),
+		types.NewParam(token.NoPos, pkg, "b", types.Typ[types.String]),
+	)
+	results := types.NewTuple(types.NewParam(token.NoPos, pkg, "ret", types.Typ[types.Int]))
+	pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, "abigen_runtime_cmpstring", types.NewSignatureType(nil, nil, nil, params, results, false)))
+
+	sig, argSize, ok, err := tryDeclSig(
+		pkg.Scope(),
+		"runtime·cmpstring",
+		"runtime.cmpstring",
+		map[string]string{"runtime.cmpstring": "abigen_runtime_cmpstring"},
+		"wasm",
+		types.SizesFor("gc", "wasm"),
+		false,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !ok {
+		t.Fatal("runtime.cmpstring declaration was not resolved")
+	}
+	var paramOffsets []int64
+	for _, slot := range sig.Frame.Params {
+		paramOffsets = append(paramOffsets, slot.Offset)
+	}
+	if want := []int64{0, 8, 16, 24}; !reflect.DeepEqual(paramOffsets, want) {
+		t.Fatalf("wasm frame parameter offsets = %v, want %v", paramOffsets, want)
+	}
+	if len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 32 || argSize != 40 {
+		t.Fatalf("wasm result frame = %#v, arg size = %d; want result at 32 and size 40", sig.Frame.Results, argSize)
+	}
+}
+
+func TestSigsForAsmFileInfersWASMLocalNativeSignature(t *testing.T) {
+	typesPkg := types.NewPackage("internal/bytealg", "bytealg")
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "wasm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, `TEXT memchr<>(SB), NOSPLIT, $0
+	Get R0
+	I32Load8U $0
+	Get R1
+	I32Eq
+	Get R2
+	Select
+	Return
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantName := pkg.PkgPath + ".memchr$local"
+	got, ok := sigs[wantName]
+	if !ok {
+		t.Fatalf("local wasm signature %q is missing; signatures: %#v", wantName, sigs)
+	}
+	wantArgs := []plan9asm.LLVMType{plan9asm.I32, plan9asm.I32, plan9asm.I32}
+	wantRegs := []plan9asm.Reg{"R0", "R1", "R2"}
+	if !reflect.DeepEqual(got.Args, wantArgs) || !reflect.DeepEqual(got.ArgRegs, wantRegs) || got.Ret != plan9asm.I32 || !got.WASMNative {
+		t.Fatalf("local wasm signature = %#v; want args %v in %v, i32 return, native ABI", got, wantArgs, wantRegs)
+	}
+}
+
+func TestSigsForAsmFileUsesGoWASMSpecialNativeSignature(t *testing.T) {
+	typesPkg := types.NewPackage("runtime", "runtime")
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "wasm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, `TEXT gcWriteBarrier<>(SB), NOSPLIT, $0
+	Get R1
+	Get R0
+	I64Add
+	Set R1
+	Get R1
+	I64Load 0(R2)
+	I64LeU
+	If
+		Get R1
+		Get R0
+		I64Sub
+		Return
+	End
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantName := pkg.PkgPath + ".gcWriteBarrier$local"
+	got := sigs[wantName]
+	if wantArgs := []plan9asm.LLVMType{plan9asm.I64}; !reflect.DeepEqual(got.Args, wantArgs) || !reflect.DeepEqual(got.ArgRegs, []plan9asm.Reg{"R0"}) || got.Ret != plan9asm.I64 || !got.WASMNative {
+		t.Fatalf("special local wasm signature = %#v; want R0:i64 -> i64 native ABI", got)
+	}
+}
+
+func TestSigsForAsmFileUsesGoWASMSpecialReferencedSignature(t *testing.T) {
+	typesPkg := types.NewPackage("runtime", "runtime")
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "wasm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, "TEXT wasm_export_run(SB),NOSPLIT,$0\n\tCall wasm_pc_f_loop(SB)\n\tReturn\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, ok := sigs["wasm_pc_f_loop"]
+	if !ok || len(got.Args) != 0 || got.Ret != plan9asm.Void || !got.WASMNative {
+		t.Fatalf("referenced special wasm signature = %#v, present=%v; want () -> void native ABI", got, ok)
+	}
+}
+
+func TestSigsForAsmFileKeepsWASMLocalRETHelperOnGoABI(t *testing.T) {
+	typesPkg := types.NewPackage("runtime", "runtime")
+	voidSig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "caller", voidSig))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "wasm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, `TEXT ·caller(SB), NOSPLIT, $0-0
+	CALL callRet<>(SB)
+	RET
+TEXT callRet<>(SB), NOSPLIT, $40-0
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := sigs[pkg.PkgPath+".callRet$local"]
+	if got.WASMNative {
+		t.Fatalf("RET-based local helper signature = %#v; want Go WebAssembly ABI", got)
+	}
+}
+
+func TestFallbackSigIncludesAddressedFrameParameters(t *testing.T) {
+	fn := plan9asm.Func{
+		Sym: "kernelCAS64<>",
+		Instrs: []plan9asm.Instr{
+			{Op: "MOVW", Args: []plan9asm.Operand{{Kind: plan9asm.OpFP, FPName: "addr", FPOffset: 0}, {Kind: plan9asm.OpReg, Reg: "R2"}}},
+			{Op: "MOVW", Args: []plan9asm.Operand{{Kind: plan9asm.OpFPAddr, FPName: "oldval", FPOffset: 4}, {Kind: plan9asm.OpReg, Reg: "R0"}}},
+			{Op: "MOVW", Args: []plan9asm.Operand{{Kind: plan9asm.OpFPAddr, FPName: "newval", FPOffset: 12}, {Kind: plan9asm.OpReg, Reg: "R1"}}},
+			{Op: "MOVW", Args: []plan9asm.Operand{{Kind: plan9asm.OpReg, Reg: "R0"}, {Kind: plan9asm.OpFP, FPName: "ret", FPOffset: 20}}},
+		},
+	}
+	sig := fallbackSigForAsmFunc(fn, "example.kernelCAS64$local", "arm")
+	var offsets []int64
+	for _, slot := range sig.Frame.Params {
+		offsets = append(offsets, slot.Offset)
+	}
+	want := []int64{0, 4, 12}
+	if !reflect.DeepEqual(offsets, want) {
+		t.Fatalf("fallback frame parameter offsets = %v, want %v", offsets, want)
+	}
+}
+
+func TestFallbackARMKernelHelperIsNotGuessedIntegerReturn(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM, "TEXT renamed<>(SB),$0\nMOVW $0xffff0fc0,R15\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := fallbackSigForAsmFunc(file.Funcs[0], "example.renamed$local", "arm")
+	if sig.Ret != plan9asm.Void || len(sig.Args)+len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+		t.Fatalf("kernel native entry acquired a guessed Go/C ABI: %#v", sig)
+	}
+}
+
+func TestSigsForAsmFileDiscoversRETTailTarget(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/retjmp", "retjmp")
+	voidSig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "f", voidSig))
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "f2", voidSig))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "wasm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchWASM, "TEXT ·f(SB), NOSPLIT, $0-0\n\tRET ·f2(SB)\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := pkg.PkgPath + ".f2"
+	if sig, ok := sigs[want]; !ok || sig.Name != want || sig.Ret != plan9asm.Void {
+		t.Fatalf("RET tail target signature = %#v, present=%v; want void signature for %q", sig, ok, want)
+	}
+}
+
+func TestSigsForAsmFilePreservesLocalMarkerOnDirectCallTarget(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/caller", "caller")
+	voidSig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "MoreStack", voidSig))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "amd64"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT ·MoreStack(SB),NOSPLIT,$0-0\n\tCALL runtime·morestack_noctxt<>(SB)\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := sigs["runtime.morestack_noctxt$local"]; !ok {
+		t.Fatalf("local direct-call target signature missing; signatures: %#v", sigs)
+	}
+}
+
+func TestSigsForAsmFileDiscoversAllDirectCallOpcodes(t *testing.T) {
+	for _, tc := range []struct {
+		name   string
+		goarch string
+		arch   plan9asm.Arch
+		op     string
+	}{
+		{name: "wasm native call", goarch: "wasm", arch: plan9asm.ArchWASM, op: "Call"},
+		{name: "wasm no-resume call", goarch: "wasm", arch: plan9asm.ArchWASM, op: "CALLNORESUME"},
+		{name: "machine call", goarch: "amd64", arch: plan9asm.ArchAMD64, op: "CALL"},
+		{name: "arm branch-link", goarch: "arm", arch: plan9asm.ArchARM, op: "BL"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			typesPkg := types.NewPackage("example.com/calls", "calls")
+			voidSig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+			typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "caller", voidSig))
+			typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "target", voidSig))
+			pkg := &packages.Package{
+				PkgPath:    typesPkg.Path(),
+				Types:      typesPkg,
+				TypesSizes: types.SizesFor("gc", tc.goarch),
+			}
+			file, err := plan9asm.Parse(tc.arch, "TEXT ·caller(SB),NOSPLIT,$0-0\n\t"+tc.op+" ·target(SB)\n\tRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), tc.goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := pkg.PkgPath + ".target"
+			if sig, ok := sigs[want]; !ok || sig.Name != want || sig.Ret != plan9asm.Void {
+				t.Fatalf("%s target signature = %#v, present=%v; want void signature for %q", tc.op, sig, ok, want)
+			}
+		})
+	}
+}
+
+func TestSigsForAsmFileInfersUndeclaredTailForwarderFromDeclaredTarget(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/fakecgo", "fakecgo")
+	params := types.NewTuple(
+		types.NewParam(token.NoPos, typesPkg, "g", types.NewPointer(types.Typ[types.Uint8])),
+		types.NewParam(token.NoPos, typesPkg, "setg", types.Typ[types.Uintptr]),
+	)
+	voidSig := types.NewSignatureType(nil, nil, nil, params, nil, false)
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "x_cgo_init", voidSig))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "386"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT x_cgo_init_trampoline(SB),NOSPLIT|NOFRAME,$0\n\tJMP ·x_cgo_init(SB)\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	caller := sigs["x_cgo_init_trampoline"]
+	target := sigs[pkg.PkgPath+".x_cgo_init"]
+	if caller.Ret != plan9asm.Void || len(caller.Args) != 2 || caller.Args[0] != plan9asm.Ptr || caller.Args[1] != plan9asm.I32 {
+		t.Fatalf("tail-forwarder signature = %#v, target = %#v; want (ptr, i32) void inherited from declared target", caller, target)
+	}
+}
+
+func TestSigsForAsmFileInfersPureTailForwarderFromABI0Body(t *testing.T) {
+	// The Go declarations may be disabled by build tags while the assembly
+	// remains selected (gomlx/compute uses goexperiment.simd this way).
+	for _, tc := range []struct {
+		arch                      plan9asm.Arch
+		goarch, move, branch, reg string
+		word                      int
+	}{
+		{plan9asm.ArchAMD64, "amd64", "MOVQ", "JMP", "AX", 8},
+		{plan9asm.ArchAMD64, "386", "MOVL", "JMP", "AX", 4},
+		{plan9asm.ArchARM, "arm", "MOVW", "B", "R0", 4},
+		{plan9asm.ArchARM64, "arm64", "MOVD", "B", "R0", 8},
+	} {
+		t.Run(tc.goarch, func(t *testing.T) {
+			typesPkg := types.NewPackage("example.com/forward", "forward")
+			pkg := &packages.Package{PkgPath: typesPkg.Path(), Types: typesPkg, TypesSizes: types.SizesFor("gc", tc.goarch)}
+			for _, body := range []string{
+				"TEXT ·forward(SB),$0-%d\n\t%s ·body(SB)\n",
+				"TEXT ·forward(SB),$0-%d\n\t%s ·middle(SB)\nTEXT ·middle(SB),$0\n\t" + tc.branch + " ·body(SB)\n",
+			} {
+				source := fmt.Sprintf(body, tc.word, tc.branch) + fmt.Sprintf("TEXT ·body(SB),$0-%d\n\t%s arg+0(FP), %s\n\tRET\n", tc.word, tc.move, tc.reg)
+				file, err := plan9asm.Parse(tc.arch, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), tc.goarch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want := sigs[pkg.PkgPath+".body"]
+				got := sigs[pkg.PkgPath+".forward"]
+				want.Name = got.Name
+				if !reflect.DeepEqual(got, want) || got.Ret != plan9asm.Void || len(got.Args) != 1 {
+					t.Fatalf("pure tail forwarder = %#v, want body ABI %#v", got, want)
+				}
+				if _, err := plan9asm.Translate(file, plan9asm.Options{Goarch: tc.goarch, ResolveSym: resolveSymFunc(pkg.PkgPath), Sigs: sigs}); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestSigsForAsmFileInfersLocalTailTargetFromDeclaredCaller(t *testing.T) {
+	typesPkg := types.NewPackage("internal/runtime/atomic", "atomic")
+	params := types.NewTuple(
+		types.NewParam(token.NoPos, typesPkg, "addr", types.NewPointer(types.Typ[types.Uint64])),
+		types.NewParam(token.NoPos, typesPkg, "delta", types.Typ[types.Int64]),
+	)
+	results := types.NewTuple(types.NewParam(token.NoPos, typesPkg, "new", types.Typ[types.Uint64]))
+	typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, "Xadd64", types.NewSignatureType(nil, nil, nil, params, results, false)))
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "arm"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchARM, `TEXT ·Xadd64(SB),NOSPLIT,$-4-20
+	B armXadd64<>(SB)
+TEXT armXadd64<>(SB),NOSPLIT,$0-20
+	MOVW R4, new_lo+12(FP)
+	MOVW R5, new_hi+16(FP)
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "arm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	caller := sigs[pkg.PkgPath+".Xadd64"]
+	target := sigs[pkg.PkgPath+".armXadd64$local"]
+	caller.Name = ""
+	target.Name = ""
+	if !reflect.DeepEqual(target, caller) {
+		t.Fatalf("local tail target signature = %#v, want declared caller signature %#v", target, caller)
+	}
+}
+
+func TestSigsForAsmFileInfersSharedLocalTailTargetReturnFromDeclaredCallers(t *testing.T) {
+	typesPkg := types.NewPackage("internal/bytealg", "bytealg")
+	boolResult := types.NewTuple(types.NewParam(token.NoPos, typesPkg, "equal", types.Typ[types.Bool]))
+	for name, params := range map[string]*types.Tuple{
+		"Equal": types.NewTuple(
+			types.NewParam(token.NoPos, typesPkg, "a", types.NewPointer(types.Typ[types.Uint8])),
+			types.NewParam(token.NoPos, typesPkg, "b", types.NewPointer(types.Typ[types.Uint8])),
+			types.NewParam(token.NoPos, typesPkg, "size", types.Typ[types.Uintptr]),
+		),
+		"EqualVarlen": types.NewTuple(
+			types.NewParam(token.NoPos, typesPkg, "a", types.NewPointer(types.Typ[types.Uint8])),
+			types.NewParam(token.NoPos, typesPkg, "b", types.NewPointer(types.Typ[types.Uint8])),
+		),
+	} {
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, types.NewSignatureType(nil, nil, nil, params, boolResult, false)))
+	}
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "386"),
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, `TEXT ·Equal(SB),NOSPLIT,$0-13
+	JMP memeqbody<>(SB)
+TEXT ·EqualVarlen(SB),NOSPLIT,$0-9
+	JMP memeqbody<>(SB)
+TEXT memeqbody<>(SB),NOSPLIT,$0-0
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	target := sigs[pkg.PkgPath+".memeqbody$local"]
+	if target.Ret != plan9asm.I1 {
+		t.Fatalf("shared local tail target signature = %#v, want common declared return i1", target)
+	}
+	if len(target.Args) != 0 || len(target.Frame.Params) != 0 || len(target.Frame.Results) != 0 {
+		t.Fatalf("shared local tail target inherited incompatible caller frame: %#v", target)
+	}
+}
+
+func TestSigsForAsmFileInfersSharedABI0ResultPointerHelper(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/hash", "hash")
+	hashType := types.NewNamed(
+		types.NewTypeName(token.NoPos, typesPkg, "Hash128", nil),
+		types.NewStruct([]*types.Var{
+			types.NewField(token.NoPos, typesPkg, "Lo", types.Typ[types.Uint64], false),
+			types.NewField(token.NoPos, typesPkg, "Hi", types.Typ[types.Uint64], false),
+		}, nil),
+		nil,
+	)
+	for name, params := range map[string]*types.Tuple{
+		"HashPointerAndSeed": types.NewTuple(
+			types.NewParam(token.NoPos, typesPkg, "p", types.Typ[types.UnsafePointer]),
+			types.NewParam(token.NoPos, typesPkg, "seed", types.Typ[types.Uintptr]),
+		),
+		"HashPointer": types.NewTuple(
+			types.NewParam(token.NoPos, typesPkg, "p", types.Typ[types.UnsafePointer]),
+		),
+	} {
+		results := types.NewTuple(types.NewParam(token.NoPos, typesPkg, "ret", hashType))
+		sig := types.NewSignatureType(nil, nil, nil, params, results, false)
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, sig))
+	}
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "amd64"),
+	}
+	const opaqueSource = `TEXT ·HashPointerAndSeed(SB),NOSPLIT,$0-32
+	MOVQ p+0(FP), AX
+	MOVQ seed+8(FP), CX
+	LEAQ ret+16(FP), DX
+	JMP hashbody<>(SB)
+TEXT ·HashPointer(SB),NOSPLIT,$0-24
+	MOVQ p+0(FP), AX
+	MOVQ $0, CX
+	LEAQ ret+8(FP), DX
+	JMP hashbody<>(SB)
+TEXT hashbody<>(SB),NOSPLIT,$0-0
+	MOVQ AX, (DX)
+	MOVQ CX, 8(DX)
+	RET
+`
+	// This fixture checks shared result-pointer transport, not permission to
+	// expose opaque pointer bits as a numerical hash. Retain AX as an actual
+	// live-in pointer, but derive a numerical predicate through the existing
+	// read-only address comparison and canonical byte/extension grammar.
+	source := strings.Replace(opaqueSource, "\tMOVQ AX, (DX)",
+		"\tTESTQ AX, AX\n\tSETNE AX\n\tMOVBQZX AX, AX\n\tMOVQ AX, (DX)", 1)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	helper := sigs[pkg.PkgPath+".hashbody$local"]
+	if helper.Ret != plan9asm.Void {
+		t.Fatalf("shared output-pointer helper return = %s, want void", helper.Ret)
+	}
+	for _, reg := range []plan9asm.Reg{plan9asm.AX, plan9asm.CX, plan9asm.DX} {
+		found := false
+		for _, got := range helper.ArgRegs {
+			found = found || got == reg
+		}
+		if !found {
+			t.Fatalf("shared output-pointer helper omitted live-in register %s: %+v", reg, helper.ArgRegs)
+		}
+	}
+	if len(helper.Args) != len(helper.ArgRegs) || len(helper.Frame.Results) != 0 {
+		t.Fatalf("shared helper has inconsistent custom ABI: %+v", helper)
+	}
+
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "asm_amd64.s")
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "asm_amd64.ll")
+	if err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", asmTask{
+		PkgPath: pkg.PkgPath,
+		AsmFile: asm,
+		OutLL:   out,
+	}, false, compileConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`@"example.com/hash.HashPointerAndSeed"(`,
+		`@"example.com/hash.HashPointer"(`,
+		`%fp_result_region = alloca [16 x i8], align 8`,
+		`ret { i64, i64 }`,
+	} {
+		if !strings.Contains(string(ir), want) {
+			t.Fatalf("shared output-pointer IR omitted %q", want)
+		}
+	}
+	// The renderer already closes and inlines each private direct-tail graph.
+	// Its inferred custom helper signature is not a standalone callable ABI or
+	// permission to pass one root's result storage to another root.
+	if strings.Count(string(ir), "define ") != 2 || strings.Contains(string(ir), `call void @"example.com/hash.hashbody$local"(`) {
+		t.Fatal("shared private tail graph escaped its two independent roots")
+	}
+	t.Run("opaque pointer bits retain their independent contract", func(t *testing.T) {
+		originalAsm := filepath.Join(dir, "opaque_amd64.s")
+		originalOut := filepath.Join(dir, "opaque_amd64.ll")
+		if err := os.WriteFile(originalAsm, []byte(opaqueSource), 0o600); err != nil {
+			t.Fatal(err)
+		}
+		err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", asmTask{
+			PkgPath: pkg.PkgPath,
+			AsmFile: originalAsm,
+			OutLL:   originalOut,
+		}, false, compileConfig{})
+		if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("opaque pointer acquired numerical result bytes: %v", err)
+		}
+		if _, err := os.Stat(originalOut); !os.IsNotExist(err) {
+			t.Fatalf("failed opaque result observation published output: %v", err)
+		}
+	})
+
+	for _, test := range []struct {
+		name   string
+		source string
+	}{
+		{
+			name: "helper does not write through result pointer",
+			source: strings.NewReplacer(
+				"MOVQ AX, (DX)", "MOVQ AX, BX",
+				"MOVQ CX, 8(DX)", "MOVQ CX, SI",
+			).Replace(source),
+		},
+		{
+			name:   "callers disagree on result pointer register",
+			source: strings.Replace(source, "LEAQ ret+8(FP), DX", "LEAQ ret+8(FP), SI", 1),
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			changed, err := plan9asm.Parse(plan9asm.ArchAMD64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			changedSigs, _, err := sigsForAsmFile(pkg, changed, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if changedSigs[pkg.PkgPath+".hashbody$local"].Ret == plan9asm.Void {
+				t.Fatal("bridged helper without evidence for shared result pointer")
+			}
+		})
+	}
+}
+
+func TestSigsForAsmFileARM64TailHelperBorrowsCallerFrame(t *testing.T) {
+	typesPkg := types.NewPackage("example.com/ring0", "ring0")
+	for _, name := range []string{"El1Sync", "HaltEl1ExceptionAndResume"} {
+		sig := types.NewSignatureType(nil, nil, nil, nil, nil, false)
+		typesPkg.Scope().Insert(types.NewFunc(token.NoPos, typesPkg, name, sig))
+	}
+	pkg := &packages.Package{
+		PkgPath:    typesPkg.Path(),
+		Types:      typesPkg,
+		TypesSizes: types.SizesFor("gc", "arm64"),
+	}
+	const source = `TEXT ·El1Sync(SB),NOSPLIT,$0-0
+	MOVD $7, R3
+	MOVD R3, 8(RSP)
+	B ·HaltEl1ExceptionAndResume(SB)
+TEXT ·HaltEl1ExceptionAndResume(SB),NOSPLIT,$0-0
+	MOVD vector+0(FP), R3
+	RET
+`
+	file, err := plan9asm.Parse(plan9asm.ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs, _, err := sigsForAsmFile(pkg, file, resolveSymFunc(pkg.PkgPath), "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	helper := sigs[pkg.PkgPath+".HaltEl1ExceptionAndResume"]
+	if len(helper.Args) != 1 || helper.Args[0] != plan9asm.I64 ||
+		len(helper.Frame.Params) != 1 || helper.Frame.Params[0].Offset != 0 {
+		t.Fatalf("tail helper did not borrow caller's ABI0 frame: %+v", helper)
+	}
+
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "entry_arm64.s")
+	if err := os.WriteFile(asm, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(dir, "entry_arm64.ll")
+	if err := compileOne(pkg, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu", asmTask{
+		PkgPath: pkg.PkgPath,
+		AsmFile: asm,
+		OutLL:   out,
+	}, false, compileConfig{}); err != nil {
+		t.Fatal(err)
+	}
+	ir, err := os.ReadFile(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		`define void @"example.com/ring0.HaltEl1ExceptionAndResume"(i64 %arg0)`,
+		`call void @"example.com/ring0.HaltEl1ExceptionAndResume"(i64 %`,
+	} {
+		if !strings.Contains(string(ir), want) {
+			t.Fatalf("borrowed-frame IR omitted %q:\n%s", want, ir)
+		}
+	}
+}
+
+func TestValidateDeclaredTextArgSizesClassifiesOnlyExplicitABIMismatches(t *testing.T) {
+	resolve := func(sym string) string { return "example.com/ext." + strings.TrimPrefix(sym, "·") }
+	declared := map[string]int64{"example.com/ext.StructFieldB": 17}
+
+	tests := []struct {
+		name    string
+		text    string
+		argSize int64
+		wantErr bool
+	}{
+		{name: "wrong explicit size", text: "TEXT ·StructFieldB(SB), $0-25", argSize: 25, wantErr: true},
+		{name: "matching explicit size", text: "TEXT ·StructFieldB(SB), $0-17", argSize: 17},
+		{name: "legacy zero size", text: "TEXT ·StructFieldB(SB), $0-0"},
+		{name: "omitted argument size", text: "TEXT ·StructFieldB(SB), $0"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			file := &plan9asm.File{Funcs: []plan9asm.Func{{
+				Sym:     "·StructFieldB",
+				ArgSize: test.argSize,
+				Instrs:  []plan9asm.Instr{{Op: plan9asm.OpTEXT, Raw: test.text}},
+			}}}
+			err := validateDeclaredTextArgSizes(file, resolve, declared, "386")
+			var mismatch *asmABINotApplicableError
+			if test.wantErr {
+				if !errors.As(err, &mismatch) {
+					t.Fatalf("validateDeclaredTextArgSizes() error = %v, want asmABINotApplicableError", err)
+				}
+				if mismatch.Symbol != "example.com/ext.StructFieldB" || mismatch.DeclaredArgSize != test.argSize || mismatch.ExpectedArgSize != 17 || mismatch.Goarch != "386" {
+					t.Fatalf("mismatch = %#v", mismatch)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("validateDeclaredTextArgSizes() error = %v", err)
+			}
+		})
+	}
+}
+
+func TestTryDeclSigDoesNotPadVoidArgumentFrame(t *testing.T) {
+	tests := []struct {
+		name    string
+		goarch  string
+		params  []types.Type
+		results []types.Type
+		want    int64
+	}{
+		{name: "amd64 uint32 void", goarch: "amd64", params: []types.Type{types.Typ[types.Uint32]}, want: 4},
+		{name: "arm64 uint32 void", goarch: "arm64", params: []types.Type{types.Typ[types.Uint32]}, want: 4},
+		{name: "amd64 slice and uint32 void", goarch: "amd64", params: []types.Type{types.NewSlice(types.Typ[types.Byte]), types.Typ[types.Uint32]}, want: 28},
+		{name: "amd64 uint32 result remains word aligned", goarch: "amd64", params: []types.Type{types.Typ[types.Uint32]}, results: []types.Type{types.Typ[types.Uint32]}, want: 12},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			pkg := types.NewPackage("example.com/frame", "frame")
+			vars := func(items []types.Type) *types.Tuple {
+				out := make([]*types.Var, len(items))
+				for i, item := range items {
+					out[i] = types.NewParam(token.NoPos, pkg, "", item)
+				}
+				return types.NewTuple(out...)
+			}
+			sig := types.NewSignatureType(nil, nil, nil, vars(test.params), vars(test.results), false)
+			pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, "frame", sig))
+			_, got, ok, err := tryDeclSig(pkg.Scope(), "·frame", pkg.Path()+".frame", nil, test.goarch, types.SizesFor("gc", test.goarch), false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !ok {
+				t.Fatal("tryDeclSig did not find declaration")
+			}
+			if got != test.want {
+				t.Fatalf("TEXT argument size = %d, want %d", got, test.want)
+			}
+		})
+	}
+}
+
+func TestReadAsmSourceExpandsLocalIncludesRecursively(t *testing.T) {
+	dir := t.TempDir()
+	write := func(name, contents string) {
+		t.Helper()
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("ops.h", "#define STEP(a, b) ADDQ a, b\n")
+	write("macros.h", "#include \"ops.h\"\n#define ROUND(a, b) STEP(a, b)\n")
+	write("macro_amd64.s", "#include \"textflag.h\"\n#include \"macros.h\"\nTEXT ·macro(SB),NOSPLIT,$0-0\nROUND(AX, BX)\nRET\n")
+
+	src, err := readAsmSource(filepath.Join(dir, "macro_amd64.s"), dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(src), `#include "macros.h"`) || !strings.Contains(string(src), "#define STEP") {
+		t.Fatalf("local include was not expanded:\n%s", src)
+	}
+	if strings.Contains(string(src), `#include "textflag.h"`) || !strings.Contains(string(src), "#define NOSPLIT") {
+		t.Fatalf("standard textflag.h was not expanded from GOROOT:\n%s", src)
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, string(src))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Instrs[1].Op; got != plan9asm.Op("ADDQ") {
+		t.Fatalf("expanded opcode = %s, want ADDQ", got)
+	}
+}
+
+func TestReadAsmSourceExpandsStandardFuncdataMacros(t *testing.T) {
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "macro_amd64.s")
+	src := `#include "funcdata.h"
+TEXT ·macro(SB),NOSPLIT,$0-0
+GO_ARGS
+GO_RESULTS_INITIALIZED
+NO_LOCAL_POINTERS
+RET
+`
+	if err := os.WriteFile(asm, []byte(src), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := readAsmSource(asm, dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(expanded), `#include "funcdata.h"`) || !strings.Contains(string(expanded), "#define GO_ARGS") {
+		t.Fatalf("standard funcdata.h was not expanded from GOROOT:\n%s", expanded)
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, string(expanded))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got []plan9asm.Op
+	for _, ins := range file.Funcs[0].Instrs {
+		got = append(got, ins.Op)
+	}
+	want := []plan9asm.Op{"TEXT", "FUNCDATA", "PCDATA", "FUNCDATA", plan9asm.OpRET}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("expanded funcdata ops = %v, want %v", got, want)
+	}
+}
+
+func TestReadAsmSourceResolvesGoIncludePathRelativeToPkgInclude(t *testing.T) {
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "tls_386.s")
+	if err := os.WriteFile(asm, []byte("#include \"../../src/runtime/go_tls.h\"\nTEXT ·tls(SB),NOSPLIT,$0-0\nRET\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	expanded, err := readAsmSource(asm, dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(expanded), `#include "../../src/runtime/go_tls.h"`) || !strings.Contains(string(expanded), "get_tls") {
+		t.Fatalf("GOROOT-relative runtime header was not expanded:\n%s", expanded)
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteMOVQSourceAliasRegistry(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repoRoot, "amd64_movq_source_alias.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, content := range map[string][]byte{
+		"amd64_movq_source_alias.go": source,
+		"translate.go":               []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(isolated, name), content, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// The actual new registry must advertise the aliases on its own, without
+	// borrowing MOVDQ2Q from the old physical MMX helper's narrower map.
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		supported, err := extractSupportedOps(isolated, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+			_, registered := supported[alias]
+			if registered != (arch == "386" || arch == "amd64") {
+				t.Fatalf("actual source alias registry leaked or omitted %s on %s", alias, arch)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsWASMFloatArithmeticFamily(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range strings.Fields("F32ADD F32SUB F32MUL F32DIV F64ADD F64SUB F64MUL F64DIV") {
+		if _, ok := supported[opcode]; !ok {
+			t.Errorf("typed Wasm arithmetic opcode missing from extraction: %s", opcode)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsWASMIntegerCountFamily(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range strings.Fields("I32CLZ I32CTZ I32POPCNT I64CLZ I64CTZ I64POPCNT") {
+		if _, ok := supported[opcode]; !ok {
+			t.Errorf("typed Wasm count opcode missing from extraction: %s", opcode)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteAddedInstructionFamilies(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{
+		"BSWAPL", "BSWAPQ",
+		"MULB", "MULW", "MULL", "MULQ", "IMULB", "IMULW", "IMULL", "IMULQ",
+		"PMOVMSKB", "VPMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VMOVMSKPS", "VMOVMSKPD",
+		"VPMOVM2B", "VPMOVM2W", "VPMOVM2D", "VPMOVM2Q",
+		"VPMOVB2M", "VPMOVW2M", "VPMOVD2M", "VPMOVQ2M",
+		"PADDB", "PADDW", "PADDL", "PADDD", "PADDQ", "PADDSB", "PADDSW", "PADDUSB", "PADDUSW",
+		"PSUBB", "PSUBW", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW",
+		"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD",
+		"ANDPS", "ANDPD", "ANDNPS", "ANDNPD", "ORPS", "ORPD", "XORPS", "XORPD",
+		"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD",
+		"PAND", "PANDN", "POR", "PXOR", "VPAND", "VPANDN", "VPOR", "VPXOR",
+		"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ",
+		"MOVD", "MOVDQ2Q", "VMOVW", "VMOVD", "VMOVQ", "PREFETCHNTA", "PREFETCHT0", "PREFETCHT1", "PREFETCHT2", "UD2",
+		"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "CVTPL2PS", "CVTPL2PD",
+		"VBROADCASTSS", "VBROADCASTSD",
+		"VADDPH", "VSUBPH", "VMULPH", "VDIVPH", "VMINPH", "VMAXPH",
+		"VCVTNEPS2BF16X", "VCVTNEPS2BF16Y", "VCVTNEPS2BF16",
+		"PMULDQ", "PMULULQ", "VPMULDQ", "VPMULUDQ",
+		"MOVDDUP", "MOVSHDUP", "MOVSLDUP",
+		"VMOVDDUP", "VMOVSHDUP", "VMOVSLDUP",
+		"PMULLD", "VPMULLD",
+		"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW",
+		"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW",
+		"PMADDWL", "VPMADDWD", "PMADDUBSW", "VPMADDUBSW",
+		"VPDPBUSD", "VPDPBUSDS", "VPDPWSSD", "VPDPWSSDS",
+		"PAVGB", "PAVGW", "VPAVGB", "VPAVGW",
+		"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ",
+		"PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ",
+		"PSRAW", "PSRAL", "VPSRAW", "VPSRAD", "VPSRAQ",
+		"VPMINSB", "VPMINUB", "VPMAXSB", "VPMAXUB",
+		"VPMINSW", "VPMINUW", "VPMAXSW", "VPMAXUW",
+		"VPMINSD", "VPMINUD", "VPMAXSD", "VPMAXUD",
+		"VPMINSQ", "VPMINUQ", "VPMAXSQ", "VPMAXUQ",
+		"SHUFPS", "SHUFPD", "VSHUFPS", "VSHUFPD",
+		"PBLENDW", "BLENDPS", "BLENDPD", "VPBLENDW", "VPBLENDD", "VBLENDPS", "VBLENDPD",
+		"PUNPCKLBW", "PUNPCKHBW", "PUNPCKLWL", "PUNPCKHWL",
+		"PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PUNPCKHQDQ",
+		"VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLWD", "VPUNPCKHWD",
+		"VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+		"UNPCKLPS", "UNPCKHPS", "UNPCKLPD", "UNPCKHPD",
+		"VUNPCKLPS", "VUNPCKHPS", "VUNPCKLPD", "VUNPCKHPD",
+		"VPERMQ", "VPERMPD",
+		"VPERMILPD", "VPERMILPS",
+		"VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS", "VMOVDQA", "VMOVDQU",
+		"VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64",
+		"MOVNTO", "MOVNTPD", "MOVNTPS", "MOVNTDQA",
+		"VMOVNTDQ", "VMOVNTPD", "VMOVNTPS", "VMOVNTDQA",
+		"MOVNTQ", "MOVNTDQ", "MOVQOZX", "PSHUFW",
+		"VINSERTF128", "VINSERTI128",
+		"VINSERTF32X4", "VINSERTF64X2", "VINSERTI32X4", "VINSERTI64X2",
+		"VINSERTF32X8", "VINSERTF64X4", "VINSERTI32X8", "VINSERTI64X4",
+		"PSHUFB", "VPSHUFB",
+		"ADDSUBPS", "ADDSUBPD", "VADDSUBPS", "VADDSUBPD",
+		"VCVTDQ2PS", "VCVTPS2DQ", "VCVTTPS2DQ", "VSQRTPD", "VSQRTPS", "VSQRTPH", "VSQRTSH",
+		"VDPBF16PS",
+		"VCVTPH2PSX", "VCVTPS2PHX",
+		"VCVTSH2SS", "VCVTSS2SH", "VCVTSH2SD", "VCVTSD2SH",
+		"PMOVSXBW", "PMOVSXBD", "PMOVSXBQ", "PMOVSXWD", "PMOVSXWQ", "PMOVSXDQ",
+		"VPMOVSXBW", "VPMOVSXBD", "VPMOVSXBQ", "VPMOVSXWD", "VPMOVSXWQ", "VPMOVSXDQ",
+		"PMOVZXBW", "PMOVZXBD", "PMOVZXBQ", "PMOVZXWD", "PMOVZXWQ", "PMOVZXDQ",
+		"VPMOVZXBW", "VPMOVZXBD", "VPMOVZXBQ", "VPMOVZXWD", "VPMOVZXWQ", "VPMOVZXDQ",
+		"PHADDD", "PHADDSW", "PHADDW", "PHSUBD", "PHSUBSW", "PHSUBW",
+		"VPHADDD", "VPHADDSW", "VPHADDW", "VPHSUBD", "VPHSUBSW", "VPHSUBW",
+		"PHMINPOSUW", "VPHMINPOSUW",
+		"BLENDVPS", "BLENDVPD", "PBLENDVB", "VBLENDVPS", "VBLENDVPD", "VPBLENDVB",
+		"MASKMOVQ", "MASKMOVOU", "MASKMOVDQU", "VMASKMOVDQU",
+		"JCXZW", "JCXZL", "JCXZQ",
+		"PALIGNR", "VPALIGNR",
+		"PCLMULQDQ", "VPCLMULQDQ",
+		"PSLLO", "PSLLDQ", "PSRLO", "PSRLDQ", "VPSLLDQ", "VPSRLDQ",
+		"RCLB", "RCLW", "RCLL", "RCLQ", "RCRB", "RCRW", "RCRL", "RCRQ",
+		"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW",
+		"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST",
+		"VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST", "VAESIMC", "VAESKEYGENASSIST",
+		"CVTSS2SL", "CVTSS2SQ", "CVTSD2SL", "CVTSD2SQ",
+		"CVTTSS2SL", "CVTTSS2SQ", "CVTTSD2SL", "CVTTSD2SQ",
+		"VCVTSS2SI", "VCVTSS2SIQ", "VCVTSD2SI", "VCVTSD2SIQ",
+		"VCVTTSS2SI", "VCVTTSS2SIQ", "VCVTTSD2SI", "VCVTTSD2SIQ",
+		"VCVTSS2USIL", "VCVTSS2USIQ", "VCVTSD2USIL", "VCVTSD2USIQ",
+		"VCVTTSS2USIL", "VCVTTSS2USIQ", "VCVTTSD2USIL", "VCVTTSD2USIQ",
+		"ROUNDPS", "ROUNDPD", "ROUNDSS", "ROUNDSD",
+		"VROUNDPS", "VROUNDPD", "VROUNDSS", "VROUNDSD",
+		"DPPD", "DPPS", "VDPPD", "VDPPS",
+		"BOUNDW", "BOUNDL",
+		"CLC", "STC", "CMC",
+		"PUSHW", "PUSHL", "PUSHQ", "POPW", "POPL", "POPQ",
+		"PUSHFW", "PUSHFL", "PUSHFQ", "POPFW", "POPFL", "POPFQ",
+		"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ",
+		"VPSLLW", "VPSLLD", "VPSLLQ", "VPSRLW", "VPSRLD", "VPSRLQ",
+		"VPSLLVW", "VPSLLVD", "VPSLLVQ",
+		"VPSRLVW", "VPSRLVD", "VPSRLVQ",
+		"VPSRAVW", "VPSRAVD", "VPSRAVQ",
+		"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW",
+		"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW",
+		"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR",
+		"CVTPS2PL", "CVTTPS2PL", "CVTPS2PD", "VCVTPS2PD",
+		"RCPPS", "RSQRTPS", "VRCPPS", "VRSQRTPS",
+		"RCPSS", "RSQRTSS", "VRCPSS", "VRSQRTSS",
+		"PCMPESTRI", "PCMPESTRM", "PCMPISTRI", "PCMPISTRM",
+		"VPCMPESTRI", "VPCMPESTRM", "VPCMPISTRI", "VPCMPISTRM",
+		"KUNPCKBW", "KUNPCKWD", "KUNPCKDQ",
+		"VRCP14PS", "VRCP14PD", "VRCP14SS", "VRCP14SD",
+		"VRSQRT14PS", "VRSQRT14PD", "VRSQRT14SS", "VRSQRT14SD",
+		"VEXP2PS", "VEXP2PD",
+		"VRCP28PS", "VRCP28PD", "VRCP28SS", "VRCP28SD",
+		"VRSQRT28PS", "VRSQRT28PD", "VRSQRT28SS", "VRSQRT28SD",
+		"V4FMADDPS", "V4FMADDSS", "V4FNMADDPS", "V4FNMADDSS", "VP4DPWSSD", "VP4DPWSSDS",
+		"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ",
+		"VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ",
+		"VPTESTMB", "VPTESTMW", "VPTESTMD", "VPTESTMQ",
+		"VPTESTNMB", "VPTESTNMW", "VPTESTNMD", "VPTESTNMQ",
+		"PTEST", "VPTEST", "VTESTPD", "VTESTPS",
+		"VPCONFLICTD", "VPCONFLICTQ",
+		"VBLENDMPS", "VBLENDMPD",
+		"VEXPANDPD", "VEXPANDPS", "VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ",
+		"PAND", "PANDN", "POR", "PXOR", "VPANDN", "VPANDND", "VPANDNQ",
+		"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ",
+		"VPBROADCASTMB2Q", "VPBROADCASTMW2D",
+		"PADDB", "PADDL", "PADDD", "PADDQ", "PADDSB", "PADDSW", "PADDUSB", "PADDUSW", "PADDW",
+		"VPADDB", "VPADDD", "VPADDQ", "VPADDSB", "VPADDSW", "VPADDUSB", "VPADDUSW", "VPADDW",
+		"PSUBB", "PSUBL", "PSUBQ", "PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW", "PSUBW",
+		"VPSUBB", "VPSUBD", "VPSUBQ", "VPSUBSB", "VPSUBSW", "VPSUBUSB", "VPSUBUSW", "VPSUBW",
+		"PSADBW", "VPSADBW", "MPSADBW", "VMPSADBW", "VDBPSADBW",
+		"PINSRB", "PINSRW", "PINSRD", "PINSRQ",
+		"VPINSRB", "VPINSRW", "VPINSRD", "VPINSRQ",
+		"VPMOVDB", "VPMOVDW", "VPMOVQB", "VPMOVQD", "VPMOVQW", "VPMOVWB",
+		"VPMOVSDB", "VPMOVSDW", "VPMOVSQB", "VPMOVSQD", "VPMOVSQW", "VPMOVSWB",
+		"VPMOVUSDB", "VPMOVUSDW", "VPMOVUSQB", "VPMOVUSQD", "VPMOVUSQW", "VPMOVUSWB",
+		"EXTRACTPS", "VEXTRACTPS", "VEXTRACTF128", "VEXTRACTI128",
+		"VEXTRACTF32X4", "VEXTRACTF64X2", "VEXTRACTI32X4", "VEXTRACTI64X2",
+		"VEXTRACTF32X8", "VEXTRACTF64X4", "VEXTRACTI32X8", "VEXTRACTI64X4",
+		"PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ",
+		"VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ",
+		"MOVHLPS", "MOVLHPS", "VMOVHLPS", "VMOVLHPS",
+		"MOVHPS", "MOVLPS", "MOVHPD", "MOVLPD", "VMOVHPS", "VMOVLPS", "VMOVHPD", "VMOVLPD",
+		"LDDQU", "VLDDQU",
+		"POPCNTW", "POPCNTL", "POPCNTQ",
+		"NOTB", "NOTW", "NOTL", "NOTQ",
+		"PDEPL", "PDEPQ", "PEXTL", "PEXTQ",
+		"BTW", "BTL", "BTQ", "BTCW", "BTCL", "BTCQ",
+		"BTRW", "BTRL", "BTRQ", "BTSW", "BTSL", "BTSQ",
+		"RDMSR", "WRMSR",
+		"ENQCMD", "ENQCMDS",
+		"VMCALL", "VMRUN", "VMMCALL", "VMLOAD", "VMSAVE", "STGI", "CLGI", "SKINIT", "INVLPGA",
+		"LGDT", "LIDT", "SGDT", "SIDT",
+		"LLDT", "LTR", "LMSW",
+		"LARW", "LARL", "LARQ", "LSLW", "LSLL", "LSLQ",
+		"VERR", "VERW",
+		"LFSW", "LFSL", "LFSQ", "LGSW", "LGSL", "LGSQ", "LSSW", "LSSL", "LSSQ",
+		"FXSAVE", "FXSAVE64", "FXRSTOR", "FXRSTOR64",
+		"XSAVE", "XSAVE64", "XSAVEOPT", "XSAVEOPT64", "XSAVEC", "XSAVEC64", "XSAVES", "XSAVES64",
+		"XRSTOR", "XRSTOR64", "XRSTORS", "XRSTORS64",
+		"RDFSBASEL", "RDFSBASEQ", "RDGSBASEL", "RDGSBASEQ",
+		"WRFSBASEL", "WRFSBASEQ", "WRGSBASEL", "WRGSBASEQ",
+		"SLDTW", "SLDTL", "SLDTQ",
+		"SMSWW", "SMSWL", "SMSWQ",
+		"STRW", "STRL", "STRQ",
+		"CLFLUSH", "CLFLUSHOPT", "CLWB",
+		"CLDEMOTE", "INVLPG", "INVPCID",
+		"MONITOR", "MWAIT", "RDPMC", "RDPKRU", "WRPKRU", "XSETBV", "UMONITOR", "UMWAIT", "TPAUSE",
+		"RDTSC", "RDTSCP",
+		"CPUID", "XGETBV",
+		"XBEGIN", "XABORT", "XEND", "XTEST",
+		"CLAC", "CLI", "CLTS", "ENDBR32", "ENDBR64", "ICEBP", "INVD", "RSM", "STAC", "STI", "SWAPGS", "UD1", "WBINVD",
+		"IRETW", "IRETL", "IRETQ", "RETFW", "RETFL", "RETFQ",
+		"SYSENTER", "SYSENTER64", "SYSEXIT", "SYSEXIT64", "SYSRET",
+		"LEAVEW", "LEAVEL", "LEAVEQ", "XLAT",
+		"XADDB", "XADDW", "XADDL", "XADDQ",
+		"XCHGB", "XCHGW", "XCHGL", "XCHGQ",
+		"NEGB", "NEGW", "NEGL", "NEGQ",
+		"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ",
+		"BEXTRL", "BEXTRQ", "BZHIL", "BZHIQ",
+		"CRC32B", "CRC32W", "CRC32L", "CRC32Q",
+		"CMPSB", "CMPSW", "CMPSL", "CMPSQ",
+		"LODSB", "LODSW", "LODSL", "LODSQ",
+		"NOPW", "NOPL",
+		"MOVBEW", "MOVBEL", "MOVBEQ",
+		"MOVNTIL", "MOVNTIQ",
+		"CBW", "CWDE", "CDQE", "CWD", "CDQ", "CQO",
+		"FCMOVCC", "FCMOVCS", "FCMOVEQ", "FCMOVHI", "FCMOVLS",
+		"FCMOVB", "FCMOVBE", "FCMOVNB", "FCMOVNBE", "FCMOVE", "FCMOVNE", "FCMOVNU", "FCMOVU", "FCMOVUN",
+		"LEAW", "LEAL", "LEAQ",
+		"LZCNTW", "LZCNTL", "LZCNTQ",
+		"ADCXL", "ADCXQ", "ADOXL", "ADOXQ",
+		"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHGQ", "CMPXCHG8B", "CMPXCHG16B",
+		"TZCNTW", "TZCNTL", "TZCNTQ",
+		"CMPPD", "CMPPS", "CMPSD", "CMPSS", "VCMPPD", "VCMPPS", "VCMPSD", "VCMPSS",
+		"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB",
+		"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB",
+		"VPERMD", "VPERMPS",
+		"SETCC", "SETCS", "SETEQ", "SETGE", "SETGT", "SETHI", "SETLE", "SETLS",
+		"SETLT", "SETMI", "SETNE", "SETOC", "SETOS", "SETPC", "SETPL", "SETPS",
+		"VMOVSD", "VMOVSS", "VMOVSH",
+		"VADDSH", "VSUBSH", "VMULSH", "VDIVSH", "VMINSH", "VMAXSH",
+		"VCOMISD", "VCOMISS", "VUCOMISD", "VUCOMISS",
+		"INCB", "INCW", "INCL", "INCQ", "DECB", "DECW", "DECL", "DECQ",
+		"MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVBQSX", "MOVBQZX",
+		"MOVWLSX", "MOVWLZX", "MOVWQSX", "MOVWQZX", "MOVLQSX", "MOVLQZX",
+		"MOVSWW", "MOVZWW",
+		"KMOVB", "KMOVW", "KMOVD", "KMOVQ",
+		"KADDB", "KADDW", "KADDD", "KADDQ",
+		"KSHIFTLB", "KSHIFTLW", "KSHIFTLD", "KSHIFTLQ",
+		"KSHIFTRB", "KSHIFTRW", "KSHIFTRD", "KSHIFTRQ",
+		"VGATHERDPS", "VGATHERQPD", "VPGATHERDD", "VPGATHERQQ",
+		"VGATHERDPD", "VPGATHERDQ", "VGATHERQPS", "VPGATHERQD",
+		"VGATHERPF0DPD", "VGATHERPF0DPS", "VGATHERPF0QPD", "VGATHERPF0QPS",
+		"VGATHERPF1DPD", "VGATHERPF1DPS", "VGATHERPF1QPD", "VGATHERPF1QPS",
+		"VSCATTERPF0DPD", "VSCATTERPF0DPS", "VSCATTERPF0QPD", "VSCATTERPF0QPS",
+		"VSCATTERPF1DPD", "VSCATTERPF1DPS", "VSCATTERPF1QPD", "VSCATTERPF1QPS",
+		"VPTERNLOGD", "VPTERNLOGQ",
+		"VALIGND", "VALIGNQ",
+		"VPMADD52HUQ", "VPMADD52LUQ",
+		"VPSHLDW", "VPSHLDD", "VPSHLDQ", "VPSHLDVW", "VPSHLDVD", "VPSHLDVQ",
+		"VPSHRDW", "VPSHRDD", "VPSHRDQ", "VPSHRDVW", "VPSHRDVD", "VPSHRDVQ",
+		"VPROLD", "VPROLQ", "VPROLVD", "VPROLVQ",
+		"VPRORD", "VPRORQ", "VPRORVD", "VPRORVQ",
+		"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ",
+		"VPORD", "VPORQ", "VPXORD", "VPXORQ",
+		"ANDPS", "ANDPD", "ANDNPS", "ANDNPD", "ORPS", "ORPD", "XORPS", "XORPD",
+		"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD",
+		"HADDPS", "HADDPD", "HSUBPS", "HSUBPD", "VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD",
+		"PABSB", "PABSW", "PABSD", "VPABSB", "VPABSW", "VPABSD", "VPABSQ",
+		"PSIGNB", "PSIGNW", "PSIGND", "VPSIGNB", "VPSIGNW", "VPSIGND",
+		"VCVTPH2PS", "VCVTPS2PH",
+		"CVTPD2PL", "CVTTPD2PL", "VCVTDQ2PD",
+		"VCVTPD2DQ", "VCVTPD2DQX", "VCVTPD2DQY",
+		"VCVTTPD2DQ", "VCVTTPD2DQX", "VCVTTPD2DQY",
+		"VSQRTSS", "VSQRTSD",
+		"VCVTSI2SDL", "VCVTSI2SDQ", "VCVTSI2SSL", "VCVTSI2SSQ",
+		"VCVTUSI2SDL", "VCVTUSI2SDQ", "VCVTUSI2SSL", "VCVTUSI2SSQ",
+		"FMOVB", "FMOVBP", "FMOVD", "FMOVDP", "FMOVF", "FMOVFP", "FMOVL", "FMOVLP",
+		"FMOVV", "FMOVVP", "FMOVW", "FMOVWP", "FMOVX", "FMOVXP",
+		"FCOMD", "FCOMDP", "FCOMDPP", "FCOMF", "FCOMFP", "FCOMI", "FCOMIP",
+		"FCOML", "FCOMLP", "FCOMW", "FCOMWP", "FUCOM", "FUCOMI", "FUCOMIP", "FUCOMP", "FUCOMPP",
+		"FBLD", "FBSTP", "FLDCW", "FLDENV", "FRSTOR", "FSAVE", "FSTCW", "FSTENV", "FSTSW",
+		"F2XM1", "FABS", "FCHS", "FCLEX", "FCOS", "FDECSTP", "FINCSTP", "FINIT",
+		"FLD1", "FLDL2E", "FLDL2T", "FLDLG2", "FLDLN2", "FLDPI", "FLDZ", "FNOP",
+		"FPATAN", "FPREM", "FPREM1", "FPTAN", "FRNDINT", "FSCALE", "FSIN", "FSINCOS",
+		"FSQRT", "FTST", "FXAM", "FXTRACT", "FYL2X", "FYL2XP1", "FXCHD", "LAHF", "SAHF",
+	}
+	for _, stem := range []string{"FADD", "FMUL", "FSUB", "FSUBR", "FDIV", "FDIVR"} {
+		for _, suffix := range []string{"W", "L", "F", "D", "DP"} {
+			want = append(want, stem+suffix)
+		}
+	}
+	for _, stem := range []string{"ROL", "ROR", "SAR", "SAL", "SHL", "SHR"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			want = append(want, stem+width)
+		}
+	}
+	for _, stem := range []string{"KAND", "KANDN", "KOR", "KXNOR", "KXOR", "KNOT", "KTEST", "KORTEST"} {
+		for _, width := range []string{"B", "W", "D", "Q"} {
+			want = append(want, stem+width)
+		}
+	}
+	for _, family := range []string{"VFMADD", "VFMSUB", "VFNMADD", "VFNMSUB", "VFMADDSUB", "VFMSUBADD"} {
+		for _, order := range []string{"132", "213", "231"} {
+			for _, element := range []string{"PS", "PD", "PH"} {
+				want = append(want, family+order+element)
+			}
+			if family != "VFMADDSUB" && family != "VFMSUBADD" {
+				for _, element := range []string{"SS", "SD", "SH"} {
+					want = append(want, family+order+element)
+				}
+			}
+		}
+	}
+	for _, family := range []string{"VADD", "VSUB", "VMUL", "VDIV", "VMAX", "VMIN"} {
+		for _, element := range []string{"PS", "PD", "SS", "SD"} {
+			want = append(want, family+element)
+		}
+	}
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, condition := range []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"} {
+			want = append(want, "CMOV"+width+condition)
+		}
+	}
+	for _, op := range want {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("supported opcode extraction omitted %s", op)
+		}
+	}
+	supported386, err := extractSupportedOps(repoRoot, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"VADDPH", "VSUBPH", "VMULPH", "VDIVPH", "VMINPH", "VMAXPH"} {
+		if _, ok := supported386[op]; !ok {
+			t.Errorf("386 supported opcode extraction omitted raw FP16 %s", op)
+		}
+	}
+	for _, op := range []string{
+		"VPOPCNTB", "VPOPCNTW", "VPOPCNTD", "VPOPCNTQ",
+		"VPLZCNTD", "VPLZCNTQ",
+		"VGF2P8MULB", "VGF2P8AFFINEQB", "VGF2P8AFFINEINVQB",
+		"VPERMB", "VPERMW",
+		"VPERMI2B", "VPERMI2W", "VPERMI2D", "VPERMI2Q", "VPERMI2PS", "VPERMI2PD",
+		"VPERMT2B", "VPERMT2W", "VPERMT2D", "VPERMT2Q", "VPERMT2PS", "VPERMT2PD",
+		"VPMULTISHIFTQB", "VPSHUFBITQMB",
+		"VRANGEPS", "VRANGEPD", "VRANGESS", "VRANGESD",
+		"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ",
+		"VFPCLASSPDX", "VFPCLASSPDY", "VFPCLASSPDZ",
+		"VFPCLASSPSX", "VFPCLASSPSY", "VFPCLASSPSZ", "VFPCLASSSD", "VFPCLASSSS",
+		"VGETEXPPS", "VGETEXPPD", "VGETEXPSS", "VGETEXPSD",
+		"VGETMANTPS", "VGETMANTPD", "VGETMANTSS", "VGETMANTSD",
+		"VFIXUPIMMPS", "VFIXUPIMMPD", "VFIXUPIMMSS", "VFIXUPIMMSD",
+		"VRNDSCALEPS", "VRNDSCALEPD", "VRNDSCALESS", "VRNDSCALESD",
+		"VREDUCEPS", "VREDUCEPD", "VREDUCESS", "VREDUCESD",
+		"VSCALEFPS", "VSCALEFPD", "VSCALEFSS", "VSCALEFSD",
+		"VCVTPD2QQ", "VCVTPD2UQQ", "VCVTTPD2QQ", "VCVTTPD2UQQ",
+		"VCVTPS2QQ", "VCVTPS2UQQ", "VCVTTPS2QQ", "VCVTTPS2UQQ",
+		"VCVTPS2UDQ", "VCVTTPS2UDQ", "VCVTUDQ2PS", "VCVTUDQ2PD",
+		"VCVTPD2UDQ", "VCVTPD2UDQX", "VCVTPD2UDQY",
+		"VCVTTPD2UDQ", "VCVTTPD2UDQX", "VCVTTPD2UDQY",
+		"VCVTQQ2PD", "VCVTUQQ2PD", "VCVTQQ2PS", "VCVTQQ2PSX", "VCVTQQ2PSY",
+		"VCVTUQQ2PS", "VCVTUQQ2PSX", "VCVTUQQ2PSY",
+		"VCOMPRESSPS", "VCOMPRESSPD", "VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ",
+		"VBROADCASTF128", "VBROADCASTI128",
+	} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("supported opcode extraction omitted %s", op)
+		}
+	}
+	arm64Supported, err := extractSupportedOps(repoRoot, "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{
+		"ADR", "ADRP",
+		"LDP", "LDPW", "LDPSW", "STP", "STPW",
+		"SMOV", "SMOVW",
+		"VFCVTNS", "VFCVTNU", "VFCVTMS", "VFCVTMU", "VFCVTAS", "VFCVTAU", "VFCVTPS", "VFCVTPU", "VFCVTZS", "VFCVTZU",
+		"VZIP1", "VZIP2", "VUZP1", "VUZP2", "VTRN1", "VTRN2",
+		"VUSHLL", "VUSHLL2", "VSSHLL", "VSSHLL2",
+		"VUXTL", "VUXTL2", "VSXTL", "VSXTL2",
+		"SXTB", "SXTBW", "SXTH", "SXTHW", "SXTW",
+		"UXTB", "UXTBW", "UXTH", "UXTHW", "UXTW",
+		"VCNT",
+		"VUADDW", "VUADDW2",
+	} {
+		if _, ok := arm64Supported[op]; !ok {
+			t.Errorf("ARM64 supported opcode extraction omitted %s", op)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsPackageLevelSpecTableWithoutOpcodeName(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_table.go"), []byte(`package sample
+var packedFamilySpecs = map[string]int{
+	"VTABLEOP": 1,
+}
+`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package sample\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(dir, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := supported["VTABLEOP"]; !ok {
+		t.Fatal("package-level table-driven opcode was not extracted")
+	}
+}
+
+func TestExtractSupportedOpsFindsARMShifterAndMultiplySpecifications(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "arm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"MOVW", "MVN", "AND", "ORR", "EOR", "BIC", "TST", "TEQ", "SLL", "SRL", "SRA", "MUL", "MULU", "MULA", "MULL", "MULLU", "MULAL", "MULALU"} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("ARM typed family omitted supported opcode %s", op)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteADXSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_lower_adx.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_lower_adx.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if _, ok := supported[op]; !ok {
+				t.Errorf("%s typed ADX extraction omitted %s", arch, op)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteTernaryGPTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_ternary_gp_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_ternary_gp_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			if _, ok := supported[op]; !ok {
+				t.Error("isolated complete ternary GP table omitted", arch, op)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteBLSSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_bls_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_bls_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"BLSIL", "BLSIQ", "BLSMSKL", "BLSMSKQ", "BLSRL", "BLSRQ"} {
+			if _, ok := supported[op]; !ok {
+				t.Errorf("%s typed BLS extraction omitted %s", arch, op)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteArithmeticShiftSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_lower_arithmetic_shift.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_lower_arithmetic_shift.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"PSRAW", "PSRAL", "VPSRAW", "VPSRAD", "VPSRAQ"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s typed arithmetic-shift extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteFloatAddSubSpecTable(t *testing.T) {
+	testFloatArithmeticOpcodeExtraction(t, []string{
+		"ADDPS", "ADDPD", "ADDSS", "ADDSD", "SUBPS", "SUBPD", "SUBSS", "SUBSD",
+		"VADDPS", "VADDPD", "VADDSS", "VADDSD", "VSUBPS", "VSUBPD", "VSUBSS", "VSUBSD",
+	})
+}
+
+func TestExtractSupportedOpsFindsCompleteHorizontalIntegerSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_horizontal_integer_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_horizontal_integer_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"PHADDD", "PHADDSW", "PHADDW", "PHSUBD", "PHSUBSW", "PHSUBW", "VPHADDD", "VPHADDSW", "VPHADDW", "VPHSUBD", "VPHSUBSW", "VPHSUBW"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s typed horizontal integer extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteHorizontalFloatSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_lower_horizontal_float.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_lower_horizontal_float.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"HADDPS", "HADDPD", "HSUBPS", "HSUBPD", "VHADDPS", "VHADDPD", "VHSUBPS", "VHSUBPD"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s typed horizontal extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteTypedUnpackSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_packed_unpack_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_packed_unpack_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{
+			"PUNPCKLBW", "PUNPCKHBW", "PUNPCKLWL", "PUNPCKHWL", "PUNPCKLLQ", "PUNPCKHLQ", "PUNPCKLQDQ", "PUNPCKHQDQ",
+			"VPUNPCKLBW", "VPUNPCKHBW", "VPUNPCKLWD", "VPUNPCKHWD", "VPUNPCKLDQ", "VPUNPCKHDQ", "VPUNPCKLQDQ", "VPUNPCKHQDQ",
+			"UNPCKLPS", "UNPCKHPS", "UNPCKLPD", "UNPCKHPD", "VUNPCKLPS", "VUNPCKHPS", "VUNPCKLPD", "VUNPCKHPD",
+		} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s typed interleave extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteWrappingAddSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_packed_arithmetic_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_packed_arithmetic_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"PADDB", "PADDW", "PADDL", "PADDQ", "VPADDB", "VPADDW", "VPADDD", "VPADDQ", "PADDD"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Fatalf("%s complete wrapping add extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteWordMultiplyAddSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_maddword_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_maddword_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"PMADDWL", "VPMADDWD"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Fatalf("%s complete word multiply-add extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteInsertExtractSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_insert_extract_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_insert_extract_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{
+			"EXTRACTPS", "INSERTPS",
+			"VEXTRACTF128", "VEXTRACTI128", "VEXTRACTF32X4", "VEXTRACTI32X4", "VEXTRACTF64X2", "VEXTRACTI64X2",
+			"VEXTRACTF32X8", "VEXTRACTI32X8", "VEXTRACTF64X4", "VEXTRACTI64X4", "VEXTRACTPS",
+			"VINSERTF128", "VINSERTI128", "VINSERTF32X4", "VINSERTI32X4", "VINSERTF64X2", "VINSERTI64X2",
+			"VINSERTF32X8", "VINSERTI32X8", "VINSERTF64X4", "VINSERTI64X4", "VINSERTPS",
+		} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s typed insert/extract extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteVectorZeroSpecTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_vector_zero_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_vector_zero_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"VZEROUPPER", "VZEROALL"} {
+			if _, ok := supported[opcode]; !ok {
+				t.Errorf("%s implicit vector-zero extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsDoesNotAdvertiseSystemRegistersAsOpcodes(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"MRS", "MSR", "WORD"} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("system-register instruction %s not advertised", op)
+		}
+	}
+	for _, register := range []string{"MIDR_EL1", "ID_AA64ISAR0_EL1", "TPIDR_EL0", "ACTLR_EL1"} {
+		if _, ok := supported[register]; ok {
+			t.Errorf("register operand %s was mistaken for an opcode", register)
+		}
+	}
+}
+
+func TestExplicitSingleTargetUsesMatrixReport(t *testing.T) {
+	tests := []struct {
+		name       string
+		allTargets bool
+		targets    string
+		reports    int
+		want       bool
+	}{
+		{name: "legacy-default-single", reports: 1, want: false},
+		{name: "explicit-single", targets: "linux/amd64", reports: 1, want: true},
+		{name: "explicit-multiple", targets: "linux/amd64,windows/amd64", reports: 2, want: true},
+		{name: "all-targets", allTargets: true, reports: 9, want: true},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			if got := useMatrixReport(test.allTargets, test.targets, test.reports); got != test.want {
+				t.Fatalf("useMatrixReport(%v, %q, %d) = %v, want %v", test.allTargets, test.targets, test.reports, got, test.want)
+			}
+		})
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteARM64AddedFamilies(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{
+		"B", "JMP", "BL", "BLR", "CALL", "RET",
+		// A64 UDF encodings reuse Go's operand-free UNDEF semantics.
+		"UNDEF",
+		// NEON SM3/SM4 are WORD-only; the named SM4 forms below are SVE.
+		"WORD",
+		"MADD", "MSUB", "MADDW", "MSUBW", "SMADDL", "SMSUBL", "UMADDL", "UMSUBL",
+		// Scalar division and Go's R27/MSUB remainder share a typed grammar.
+		"SDIV", "SDIVW", "UDIV", "UDIVW",
+		"REM", "REMW", "UREM", "UREMW",
+		"FABSS", "FABSD", "FNEGS", "FNEGD", "FSQRTS", "FSQRTD", "FMOVS", "FMOVD",
+		"FCVTSD", "FCVTDS", "FCVTSH", "FCVTHS", "FCVTDH", "FCVTHD",
+		"FRINTNS", "FRINTND", "FRINTPS", "FRINTPD", "FRINTMS", "FRINTMD",
+		"FRINTZS", "FRINTZD", "FRINTAS", "FRINTAD", "FRINTXS", "FRINTXD", "FRINTIS", "FRINTID",
+		"FMADDS", "FMADDD", "FMSUBS", "FMSUBD", "FNMADDS", "FNMADDD", "FNMSUBS", "FNMSUBD",
+		"SCVTFD", "SCVTFS", "SCVTFWD", "SCVTFWS", "UCVTFD", "UCVTFS", "UCVTFWD", "UCVTFWS",
+		"FADDS", "FADDD", "FSUBS", "FSUBD", "FMULS", "FMULD", "FNMULS", "FNMULD", "FDIVS", "FDIVD",
+		"FMAXS", "FMAXD", "FMINS", "FMIND", "FMAXNMS", "FMAXNMD", "FMINNMS", "FMINNMD",
+		"CASPW", "CASPD",
+		"LDXPW", "LDXP", "LDAXPW", "LDAXP",
+		"STXPW", "STXP", "STLXPW", "STLXP",
+		"VADDV", "VADDP", "VSMAX", "VSMIN", "VUMAX", "VUMIN", "VSMAXP", "VSMINP", "VUMAXP", "VUMINP",
+		"VABS", "VNEG", "VSQABS", "VSQNEG",
+		"VSSHR", "VSSRA", "VSRSHR", "VSRSRA", "VUSHR", "VUSRA", "VURSHR", "VURSRA",
+		"VSQSHRN", "VSQSHRN2", "VSQRSHRN", "VSQRSHRN2",
+		"VSQSHRUN", "VSQSHRUN2", "VSQRSHRUN", "VSQRSHRUN2",
+		"VUQSHRN", "VUQSHRN2", "VUQRSHRN", "VUQRSHRN2",
+		"VXTN", "VXTN2", "VSQXTN", "VSQXTN2", "VSQXTUN", "VSQXTUN2", "VUQXTN", "VUQXTN2",
+		"VSHADD", "VSRHADD", "VUHADD", "VURHADD",
+		"VSQADD", "VUQADD", "VSQSUB", "VUQSUB",
+		"VSMULL", "VSMULL2", "VSMLAL", "VSMLAL2", "VSMLSL", "VSMLSL2",
+		"VUMULL", "VUMULL2", "VUMLAL", "VUMLAL2", "VUMLSL", "VUMLSL2",
+		"VMUL", "VMLA", "VMLS",
+		"VCMHI", "VCMHS",
+		"VSMAXV", "VSMINV", "VUMAXV", "VUMINV",
+		"VFMAXV", "VFMINV", "VFMAXNMV", "VFMINNMV",
+		"VLD1", "VLD2", "VLD3", "VLD4", "VLD1R", "VLD2R", "VLD3R", "VLD4R", "VST1", "VST2", "VST3", "VST4",
+		"VMOV", "VMOVS", "VMOVD", "VMOVQ", "VDUP", "VADD", "VSUB",
+		"VCLS", "VCLZ",
+		"VEXT",
+		"VEOR3", "VBCAX", "VRAX1", "VXAR",
+		"SHA1C", "SHA1P", "SHA1M", "SHA1H", "SHA1SU0", "SHA1SU1",
+		"SHA256H", "SHA256H2", "SHA256SU0", "SHA256SU1",
+		"SHA512H", "SHA512H2", "SHA512SU0", "SHA512SU1",
+		"VSHL", "VSSHL", "VSRSHL", "VUSHL", "VURSHL",
+		"ZAND", "ZBIC", "ZEOR", "ZORR",
+		"ZSUB", "ZSUBR", "ZSQADD", "ZSQSUB", "ZSQSUBR", "ZUQADD", "ZUQSUB", "ZUQSUBR",
+		"ZASR", "ZLSL",
+		"ZFADD", "ZFSUB", "ZFSUBR",
+		"ZCMPEQ", "ZCMPGE", "ZCMPGT", "ZCMPHI", "ZCMPHS", "ZCMPNE",
+		"ZFACGE", "ZFACGT", "ZFCMEQ", "ZFCMGE", "ZFCMGT", "ZFCMLE", "ZFCMLT", "ZFCMNE", "ZFCMUO",
+		"ZSMAX", "ZSMAXP", "ZSMAXQV", "ZSMAXVB", "ZSMAXVH", "ZSMAXVS", "ZSMAXVD",
+		"ZSMIN", "ZSMINP", "ZSMINQV", "ZSMINVB", "ZSMINVH", "ZSMINVS", "ZSMINVD",
+		"ZUMAX", "ZUMAXP", "ZUMAXQV", "ZUMAXVB", "ZUMAXVH", "ZUMAXVS", "ZUMAXVD",
+		"ZUMIN", "ZUMINP", "ZUMINQV", "ZUMINVB", "ZUMINVH", "ZUMINVS", "ZUMINVD",
+		"ZADDQV", "ZANDQV", "ZANDVB", "ZANDVH", "ZANDVS", "ZANDVD",
+		"ZEORQV", "ZEORVB", "ZEORVH", "ZEORVS", "ZEORVD",
+		"ZORQV", "ZORVB", "ZORVH", "ZORVS", "ZORVD",
+		"ZFADDAD", "ZFADDAH", "ZFADDAS", "ZFADDQV", "ZFADDVD", "ZFADDVH", "ZFADDVS",
+		"ZSADDVD", "ZUADDVD",
+		"ZADDHNB", "ZADDHNT", "ZRADDHNB", "ZRADDHNT", "ZSUBHNB", "ZSUBHNT", "ZRSUBHNB", "ZRSUBHNT",
+		"ZSADDLB", "ZSADDLBT", "ZSADDLT", "ZSADDWB", "ZSADDWT",
+		"ZSSUBLB", "ZSSUBLBT", "ZSSUBLT", "ZSSUBLTB", "ZSSUBWB", "ZSSUBWT",
+		"ZUADDLB", "ZUADDLT", "ZUADDWB", "ZUADDWT", "ZUSUBLB", "ZUSUBLT", "ZUSUBWB", "ZUSUBWT",
+		"ZSABA", "ZUABA", "ZSABD", "ZUABD",
+		"ZSABALB", "ZSABALT", "ZUABALB", "ZUABALT",
+		"ZSABDLB", "ZSABDLT", "ZUABDLB", "ZUABDLT", "ZSADALP", "ZUADALP",
+		"ZSHADD", "ZSRHADD", "ZUHADD", "ZURHADD", "ZSHSUB", "ZSHSUBR", "ZUHSUB", "ZUHSUBR",
+		"ZSDIV", "ZSDIVR", "ZUDIV", "ZUDIVR",
+		"ZBCAX", "ZBSL", "ZBSL1N", "ZBSL2N", "ZEOR3", "ZNBSL",
+		"ZBDEP", "ZBEXT", "ZBGRP",
+		"ZADCLB", "ZADCLT", "ZSBCLB", "ZSBCLT",
+		"ZSCLAMP", "ZUCLAMP", "ZFCLAMP", "ZBFCLAMP",
+		"ZSUNPKHI", "ZSUNPKLO", "ZUUNPKHI", "ZUUNPKLO",
+		"ZSQXTNB", "ZSQXTNT", "ZSQXTUNB", "ZSQXTUNT", "ZUQXTNB", "ZUQXTNT",
+		"ZSHRNB", "ZSHRNT", "ZRSHRNB", "ZRSHRNT",
+		"ZSQSHRNB", "ZSQSHRNT", "ZSQRSHRNB", "ZSQRSHRNT",
+		"ZSQSHRUNB", "ZSQSHRUNT", "ZSQRSHRUNB", "ZSQRSHRUNT",
+		"ZUQSHRNB", "ZUQSHRNT", "ZUQRSHRNB", "ZUQRSHRNT",
+		"ZSQRSHL", "ZSQRSHLR", "ZSQSHLR", "ZUQRSHL", "ZUQRSHLR", "ZUQSHLR",
+		"ZSRSHL", "ZSRSHLR", "ZURSHL", "ZURSHLR",
+		"ZFMAX", "ZFMAXP", "ZFMAXQV", "ZFMAXVH", "ZFMAXVS", "ZFMAXVD",
+		"ZFMIN", "ZFMINP", "ZFMINQV", "ZFMINVH", "ZFMINVS", "ZFMINVD",
+		"ZFMAXNM", "ZFMAXNMP", "ZFMAXNMQV", "ZFMAXNMVH", "ZFMAXNMVS", "ZFMAXNMVD",
+		"ZFMINNM", "ZFMINNMP", "ZFMINNMQV", "ZFMINNMVH", "ZFMINNMVS", "ZFMINNMVD",
+		"ZFABS", "ZFNEG", "ZFRECPE", "ZFRECPX", "ZFRSQRTE", "ZFSQRT",
+		"ZFRINT32X", "ZFRINT32Z", "ZFRINT64X", "ZFRINT64Z",
+		"ZFRINTA", "ZFRINTI", "ZFRINTM", "ZFRINTN", "ZFRINTP", "ZFRINTX", "ZFRINTZ",
+		"ZABS", "ZCLS", "ZCLZ", "ZCNOT", "ZCNT", "ZNEG", "ZNOT", "ZRBIT",
+		"ZREV", "ZREVB", "ZREVH", "ZREVW",
+		"PAND", "PANDS", "PBIC", "PBICS", "PEOR", "PEORS", "PNAND", "PNANDS",
+		"PNOR", "PNORS", "PORN", "PORNS", "PORR", "PORRS",
+		"PBRKA", "PBRKAS", "PBRKB", "PBRKBS", "PBRKN", "PBRKNS",
+		"PBRKPA", "PBRKPAS", "PBRKPB", "PBRKPBS",
+		"PREV", "PTRN1", "PTRN2", "PUZP1", "PUZP2", "PZIP1", "PZIP2",
+		"PPUNPKHI", "PPUNPKLO",
+		"PSEL",
+		"PPFALSE", "PPTEST",
+		"PRDFFR", "PRDFFRS", "PWRFFR", "SETFFR",
+		"PPFIRST", "PPNEXT",
+		"PFIRSTP", "PLASTP",
+		"PPTRUE", "PCNTP", "PPEXT",
+		"PWHILEGE", "PWHILEGT", "PWHILEHI", "PWHILEHS",
+		"PWHILELE", "PWHILELO", "PWHILELS", "PWHILELT",
+		"PWHILEGEW", "PWHILEGTW", "PWHILEHIW", "PWHILEHSW",
+		"PWHILELEW", "PWHILELOW", "PWHILELSW", "PWHILELTW",
+		"PWHILERW", "PWHILEWR",
+		"PDECP", "PINCP", "PSQDECP", "PSQDECPW", "PSQINCP", "PSQINCPW",
+		"PUQDECP", "PUQDECPW", "PUQINCP", "PUQINCPW",
+		"PLDR", "PSTR", "PPRFB", "PPRFH", "PPRFW", "PPRFD",
+		"ZLDR", "ZSTR",
+		"ZPRFB", "ZPRFH", "ZPRFW", "ZPRFD",
+		"ZLDNT1B", "ZLDNT1H", "ZLDNT1W", "ZLDNT1D", "ZLDNT1SB", "ZLDNT1SH", "ZLDNT1SW",
+		"ZSTNT1B", "ZSTNT1H", "ZSTNT1W", "ZSTNT1D",
+		"ZLDFF1B", "ZLDFF1H", "ZLDFF1W", "ZLDFF1D", "ZLDFF1SB", "ZLDFF1SH", "ZLDFF1SW",
+		"ZLDNF1B", "ZLDNF1H", "ZLDNF1W", "ZLDNF1D", "ZLDNF1SB", "ZLDNF1SH", "ZLDNF1SW",
+		"ZLD1RB", "ZLD1RH", "ZLD1RW", "ZLD1RD", "ZLD1RSB", "ZLD1RSH", "ZLD1RSW",
+		"ZLD1ROB", "ZLD1ROH", "ZLD1ROW", "ZLD1ROD", "ZLD1RQB", "ZLD1RQH", "ZLD1RQW", "ZLD1RQD",
+		"CTERMEQ", "CTERMEQW", "CTERMNE", "CTERMNEW",
+		"ZLD1B", "ZLD1H", "ZLD1W", "ZLD1D", "ZLD1Q", "ZLD1SB", "ZLD1SH", "ZLD1SW",
+		"ZST1B", "ZST1H", "ZST1W", "ZST1D", "ZST1Q",
+		"ZLD2B", "ZLD2H", "ZLD2W", "ZLD2D", "ZLD2Q",
+		"ZLD3B", "ZLD3H", "ZLD3W", "ZLD3D", "ZLD3Q",
+		"ZLD4B", "ZLD4H", "ZLD4W", "ZLD4D", "ZLD4Q",
+		"ZST2B", "ZST2H", "ZST2W", "ZST2D", "ZST2Q",
+		"ZST3B", "ZST3H", "ZST3W", "ZST3D", "ZST3Q",
+		"ZST4B", "ZST4H", "ZST4W", "ZST4D", "ZST4Q",
+		"ZPMOV",
+		"ZINDEX", "ZINDEXW",
+		"ZINSR", "ZINSRW", "ZINSRB", "ZINSRH", "ZINSRS", "ZINSRD",
+		"ZLASTA", "ZLASTAW", "ZLASTAB", "ZLASTAH", "ZLASTAS", "ZLASTAD",
+		"ZLASTB", "ZLASTBW", "ZLASTBB", "ZLASTBH", "ZLASTBS", "ZLASTBD",
+		"ZCLASTA", "ZCLASTAW", "ZCLASTAB", "ZCLASTAH", "ZCLASTAS", "ZCLASTAD",
+		"ZCLASTB", "ZCLASTBW", "ZCLASTBB", "ZCLASTBH", "ZCLASTBS", "ZCLASTBD",
+		"ZCOMPACT",
+		"ZMOVPRFX",
+		"ZEXT", "ZEXTQ", "ZSPLICE",
+		"ZCPY", "ZCPYW", "ZCPYB", "ZCPYH", "ZCPYS", "ZCPYD",
+		"ZFCVT", "ZFCVTZS", "ZFCVTZU", "ZSCVTF", "ZUCVTF",
+		"ZFCVTLT", "ZFCVTX", "ZFCVTXNT",
+		"ZSQABS", "ZSQNEG", "ZSXTB", "ZSXTH", "ZSXTW",
+		"ZUXTB", "ZUXTH", "ZUXTW", "ZURECPE", "ZURSQRTE",
+		"ZSMULH", "ZUMULH",
+		"ZSDOT", "ZUDOT", "ZSUDOT", "ZUSDOT",
+		"ZSQSHL", "ZUQSHL",
+		"ZFMUL", "ZFMULX", "ZFTMAD", "ZFTSMUL", "ZFTSSEL", "ZFCMLA", "ZFMLA", "ZFMLS", "ZFMAD", "ZFMSB",
+		"ZFNMLA", "ZFNMLS", "ZFNMAD", "ZFNMSB", "ZMLA", "ZMLS",
+		"ZSQDMULH", "ZSQRDMULH",
+		"ZPMUL", "ZPMULL", "ZPMULLB", "ZPMULLT", "ZPMLAL",
+		"ZSMULLB", "ZSMULLT", "ZUMULLB", "ZUMULLT", "ZSQDMULLB", "ZSQDMULLT",
+		"ZSQDMLALB", "ZSQDMLALT", "ZSQDMLALBT", "ZSQDMLSLB", "ZSQDMLSLT", "ZSQDMLSLBT",
+		"ZSMMLA", "ZUMMLA", "ZUSMMLA", "ZBFMMLA", "ZFMMLA",
+		"ZADDP", "ZADDPT", "ZSUBPT",
+		"ZDECP", "ZINCP", "ZSQDECP", "ZSQINCP", "ZUQDECP", "ZUQINCP",
+		"ZSSHLLB", "ZSSHLLT", "ZUSHLLB", "ZUSHLLT",
+		"ZFRECPS", "ZFRSQRTS",
+		"ZFABD", "ZFADDP", "ZFAMAX", "ZFAMIN",
+		"ZMATCH", "ZNMATCH",
+		"ZHISTCNT", "ZHISTSEG",
+		"ZMADPT", "ZMLAPT",
+		"ZCADD", "ZSQCADD",
+		"ZXAR",
+		"ZEXPAND",
+		"ZFEXPA", "ZFLOGB",
+		"ZFCPY", "ZFDUP",
+		"ZFDIV", "ZFDIVR", "ZFSCALE",
+		"ZSUQADD", "ZUSQADD",
+		"ZFCADD",
+		"ZDUP", "ZDUPW",
+		"ZDUPQ",
+		"ZDUPM",
+		"ZFDOT",
+		"ZCDOT",
+		"ZLUTI2", "ZLUTI4",
+		"ZFMLALB", "ZFMLALT", "ZFMLSLB", "ZFMLSLT",
+		"ZFMLALLBB", "ZFMLALLBT", "ZFMLALLTB", "ZFMLALLTT",
+		"ZSQCVTN", "ZSQCVTUN", "ZUQCVTN",
+		"ZSQRSHRN", "ZSQRSHRUN", "ZUQRSHRN",
+		"ZBF1CVT", "ZBF1CVTLT", "ZBF2CVT", "ZBF2CVTLT",
+		"ZF1CVT", "ZF1CVTLT", "ZF2CVT", "ZF2CVTLT",
+		"ZBFCVT", "ZBFCVTN", "ZBFCVTNT", "ZFCVTN", "ZFCVTNB", "ZFCVTNT",
+		"ZBFADD", "ZBFSUB", "ZBFMUL", "ZBFMAX", "ZBFMAXNM", "ZBFMIN", "ZBFMINNM", "ZBFSCALE",
+		"ZBFMLA", "ZBFMLS", "ZBFMLALB", "ZBFMLALT", "ZBFMLSLB", "ZBFMLSLT",
+		"ZAESD", "ZAESDIMC", "ZAESE", "ZAESEMC",
+		"ZRAX1", "ZSM4E", "ZSM4EKEY",
+		"ZASRD", "ZASRR", "ZLSLR", "ZLSRR", "ZSLI", "ZSRI", "ZSRSHR", "ZSRSRA", "ZSSRA", "ZURSHR", "ZURSRA", "ZUSRA", "ZSQSHLU",
+		"ZCMLA", "ZSQRDCMLAH",
+		"ZSQRDMLAH", "ZSQRDMLSH",
+		"ZADR",
+		"RBIT", "RBITW", "CLZ", "CLZW", "CLS", "CLSW",
+		"BIC", "BICW", "BICS", "BICSW", "ADDS", "ADDSW",
+		"FCMPS", "FCMPD", "FCMPES", "FCMPED",
+		"FCCMPS", "FCCMPD", "FCCMPES", "FCCMPED",
+		"DMB", "DSB", "ISB", "DC", "PRFM", "RPRFM", "BRK", "UNDEF", "HINT", "YIELD", "WFE", "WFI", "SEV", "SEVL", "NOP",
+	} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("supported opcode extraction omitted %s", op)
+		}
+	}
+	for _, suboperation := range []string{"IVAC", "CIGDVADP", "PLDL1KEEP", "PSTL3STRM"} {
+		if _, ok := supported[suboperation]; ok {
+			t.Errorf("supported opcode extraction advertised %s suboperation as an instruction", suboperation)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteARMAddedFamilies(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "arm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{
+		"MOVF", "MOVD",
+		"NEGF", "NEGD", "ABSF", "ABSD", "SQRTF", "SQRTD", "MOVFD", "MOVDF", "CMPF", "CMPD",
+		"ADDF", "ADDD", "SUBF", "SUBD", "MULF", "MULD", "NMULF", "NMULD", "DIVF", "DIVD",
+		"MULAF", "MULAD", "MULSF", "MULSD", "NMULAF", "NMULAD", "NMULSF", "NMULSD",
+		"FMULAF", "FMULAD", "FMULSF", "FMULSD", "FNMULAF", "FNMULAD", "FNMULSF", "FNMULSD",
+		"MOVWF", "MOVWD", "MOVFW", "MOVDW", "PLD",
+		"DIV", "DIVU", "MOD", "MODU",
+		"SSAT", "USAT", "SSAT16", "USAT16",
+	} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("supported opcode extraction omitted %s", op)
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteSignedScalarIntegerFloatFamily(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(repoRoot, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+			if _, found := supported[op]; !found {
+				t.Errorf("%s extraction omitted signed conversion %s", arch, op)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteFloatMulDivFamily(t *testing.T) {
+	testFloatArithmeticOpcodeExtraction(t, []string{
+		"MULPS", "MULPD", "MULSS", "MULSD", "DIVPS", "DIVPD", "DIVSS", "DIVSD",
+		"VMULPS", "VMULPD", "VMULSS", "VMULSD", "VDIVPS", "VDIVPD", "VDIVSS", "VDIVSD",
+	})
+}
+
+func TestExtractSupportedOpsFindsCompleteWasmFloatUnaryFamily(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, width := range []string{"F32", "F64"} {
+		for _, operation := range []string{"ABS", "NEG", "CEIL", "FLOOR", "TRUNC", "NEAREST", "SQRT"} {
+			op := width + operation
+			if _, ok := supported[op]; !ok {
+				t.Errorf("supported opcode extraction omitted %s", op)
+			}
+		}
+	}
+}
+
+func TestExtractSupportedOpsFindsCompleteWasmMoveFamily(t *testing.T) {
+	repoRoot, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(repoRoot, "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"MOVB", "MOVH", "MOVW", "MOVD"} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("supported opcode extraction omitted %s", op)
+		}
+	}
+}
+
 func TestAsmFilesOfPkgSkipsCommentOnlyAssembly(t *testing.T) {
 	dir := t.TempDir()
 	comments := filepath.Join(dir, "comments.s")
@@ -34,6 +2185,33 @@ func TestAsmFilesOfPkgSkipsCommentOnlyAssembly(t *testing.T) {
 	}
 }
 
+func TestCollectAsmTasksHonorsExactModuleRelativeAllowlist(t *testing.T) {
+	dir := t.TempDir()
+	pkgDir := filepath.Join(dir, "pkg")
+	if err := os.MkdirAll(pkgDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	amd64File := filepath.Join(pkgDir, "fast.s")
+	arm64File := filepath.Join(pkgDir, "portable.s")
+	for _, path := range []string{amd64File, arm64File} {
+		if err := os.WriteFile(path, []byte("TEXT ·f(SB),0,$0-0\nRET\n"), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	pkg := &packages.Package{
+		PkgPath:    "example.com/root/pkg",
+		OtherFiles: []string{amd64File, arm64File},
+		Module:     &packages.Module{Path: "example.com/root", Dir: dir},
+	}
+	tasks, packages := collectAsmTasks([]*packages.Package{pkg}, "/out", []string{"pkg/portable.s"})
+	if len(tasks) != 1 || tasks[0].AsmFile != arm64File {
+		t.Fatalf("collectAsmTasks() tasks = %#v, want only %s", tasks, arm64File)
+	}
+	if !reflect.DeepEqual(packages, []string{"example.com/root/pkg"}) {
+		t.Fatalf("collectAsmTasks() packages = %#v", packages)
+	}
+}
+
 func TestFilterPackagesByModuleExcludesNestedModules(t *testing.T) {
 	pkgs := []*packages.Package{
 		{PkgPath: "example.com/root/pkg", Module: &packages.Module{Path: "example.com/root"}},
@@ -126,9 +2304,9 @@ func TestLLVMArgsAndFrameSlotsForTupleSliceResultFlatten(t *testing.T) {
 		t.Fatalf("args mismatch: %#v", args)
 	}
 	wantSlots := []plan9asm.FrameSlot{
-		{Offset: 0, Type: plan9asm.Ptr, Index: 0, Field: -1},
-		{Offset: 8, Type: plan9asm.I64, Index: 1, Field: -1},
-		{Offset: 16, Type: plan9asm.I64, Index: 2, Field: -1},
+		{Offset: 0, Type: plan9asm.Ptr, Index: 0, Field: -1, Name: "r"},
+		{Offset: 8, Type: plan9asm.I64, Index: 1, Field: -1, Name: "r"},
+		{Offset: 16, Type: plan9asm.I64, Index: 2, Field: -1, Name: "r"},
 	}
 	if !reflect.DeepEqual(slots, wantSlots) {
 		t.Fatalf("slots mismatch: got=%#v want=%#v", slots, wantSlots)
@@ -161,3 +2339,163 @@ func TestLLVMArgsAndFrameSlotsForTupleInterfaceParam(t *testing.T) {
 		t.Fatalf("nextOff mismatch: got=%d want=16", nextOff)
 	}
 }
+
+func TestLLVMArgsAndFrameSlotsForTupleNamedInterfaceParam(t *testing.T) {
+	iface := types.NewInterfaceType(nil, nil)
+	iface.Complete()
+	named := types.NewNamed(types.NewTypeName(token.NoPos, nil, "Reader", nil), iface, nil)
+	tup := types.NewTuple(types.NewVar(token.NoPos, nil, "v", named))
+	sz := types.SizesFor("gc", "amd64")
+	args, slots, _, err := llvmArgsAndFrameSlotsForTuple(tup, "amd64", sz, 0, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(args, []plan9asm.LLVMType{"{ ptr, ptr }"}) {
+		t.Fatalf("args mismatch: %#v", args)
+	}
+	wantSlots := []plan9asm.FrameSlot{
+		{Offset: 0, Type: plan9asm.Ptr, Index: 0, Field: 0},
+		{Offset: 8, Type: plan9asm.Ptr, Index: 0, Field: 1},
+	}
+	if !reflect.DeepEqual(slots, wantSlots) {
+		t.Fatalf("slots mismatch: got=%#v want=%#v", slots, wantSlots)
+	}
+}
+
+func TestLLVMArgsAndFrameSlotsForNestedAggregateParam(t *testing.T) {
+	slice := types.NewSlice(types.Typ[types.Byte])
+	array := types.NewArray(slice, 2)
+	tup := types.NewTuple(types.NewVar(token.NoPos, nil, "blocks", array))
+	sz := types.SizesFor("gc", "amd64")
+	args, slots, nextOff, err := llvmArgsAndFrameSlotsForTuple(tup, "amd64", sz, 0, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(args, []plan9asm.LLVMType{"[2 x { ptr, i64, i64 }]"}) {
+		t.Fatalf("args mismatch: %#v", args)
+	}
+	wantSlots := []plan9asm.FrameSlot{
+		{Offset: 0, Type: plan9asm.Ptr, Index: 0, Field: 0, Fields: []int{0, 0}},
+		{Offset: 8, Type: plan9asm.I64, Index: 0, Field: 0, Fields: []int{0, 1}},
+		{Offset: 16, Type: plan9asm.I64, Index: 0, Field: 0, Fields: []int{0, 2}},
+		{Offset: 24, Type: plan9asm.Ptr, Index: 0, Field: 1, Fields: []int{1, 0}},
+		{Offset: 32, Type: plan9asm.I64, Index: 0, Field: 1, Fields: []int{1, 1}},
+		{Offset: 40, Type: plan9asm.I64, Index: 0, Field: 1, Fields: []int{1, 2}},
+	}
+	if !reflect.DeepEqual(slots, wantSlots) {
+		t.Fatalf("slots mismatch: got=%#v want=%#v", slots, wantSlots)
+	}
+	if nextOff != 48 {
+		t.Fatalf("nextOff mismatch: got=%d want=48", nextOff)
+	}
+}
+
+func TestLLVMArgsAndFrameSlotsForStructParam(t *testing.T) {
+	st := types.NewStruct([]*types.Var{
+		types.NewVar(token.NoPos, nil, "A", types.NewArray(types.Typ[types.Uint16], 3)),
+		types.NewVar(token.NoPos, nil, "B", types.Typ[types.Byte]),
+		types.NewVar(token.NoPos, nil, "C", types.Typ[types.String]),
+	}, nil)
+	tup := types.NewTuple(types.NewVar(token.NoPos, nil, "v", st))
+	sz := types.SizesFor("gc", "amd64")
+	args, slots, nextOff, err := llvmArgsAndFrameSlotsForTuple(tup, "amd64", sz, 0, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(args, []plan9asm.LLVMType{"{ [3 x i16], i8, { ptr, i64 } }"}) {
+		t.Fatalf("args mismatch: %#v", args)
+	}
+	wantSlots := []plan9asm.FrameSlot{
+		{Offset: 0, Type: plan9asm.I16, Index: 0, Field: 0, Fields: []int{0, 0}},
+		{Offset: 2, Type: plan9asm.I16, Index: 0, Field: 0, Fields: []int{0, 1}},
+		{Offset: 4, Type: plan9asm.I16, Index: 0, Field: 0, Fields: []int{0, 2}},
+		{Offset: 6, Type: plan9asm.I8, Index: 0, Field: 1},
+		{Offset: 8, Type: plan9asm.Ptr, Index: 0, Field: 2, Fields: []int{2, 0}},
+		{Offset: 16, Type: plan9asm.I64, Index: 0, Field: 2, Fields: []int{2, 1}},
+	}
+	if !reflect.DeepEqual(slots, wantSlots) {
+		t.Fatalf("slots mismatch: got=%#v want=%#v", slots, wantSlots)
+	}
+	if nextOff != 24 {
+		t.Fatalf("nextOff mismatch: got=%d want=24", nextOff)
+	}
+}
+
+func TestLLVMArgsAndFrameSlotsFlattensArrayResult(t *testing.T) {
+	array := types.NewArray(types.Typ[types.Byte], 7)
+	tup := types.NewTuple(types.NewVar(token.NoPos, nil, "result", array))
+	sz := types.SizesFor("gc", "amd64")
+	args, slots, nextOff, err := llvmArgsAndFrameSlotsForTuple(tup, "amd64", sz, 0, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantArgs := []plan9asm.LLVMType{
+		plan9asm.I8, plan9asm.I8, plan9asm.I8, plan9asm.I8,
+		plan9asm.I8, plan9asm.I8, plan9asm.I8,
+	}
+	if !reflect.DeepEqual(args, wantArgs) {
+		t.Fatalf("args mismatch: got=%#v want=%#v", args, wantArgs)
+	}
+	for i, slot := range slots {
+		want := plan9asm.FrameSlot{Offset: int64(i), Type: plan9asm.I8, Index: i, Field: -1, Name: "result"}
+		if !reflect.DeepEqual(slot, want) {
+			t.Fatalf("slot %d = %#v, want %#v", i, slot, want)
+		}
+	}
+	if nextOff != 7 {
+		t.Fatalf("nextOff mismatch: got=%d want=7", nextOff)
+	}
+}
+
+func TestLLVMArgsAndFrameSlotsForComplexParamsAndResults(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64", "arm", "arm64"} {
+		t.Run(goarch, func(t *testing.T) {
+			tup := types.NewTuple(
+				types.NewVar(token.NoPos, nil, "c64", types.Typ[types.Complex64]),
+				types.NewVar(token.NoPos, nil, "c128", types.Typ[types.Complex128]),
+			)
+			sz := types.SizesFor("gc", goarch)
+			args, slots, nextOff, err := llvmArgsAndFrameSlotsForTuple(tup, goarch, sz, 0, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantArgs := []plan9asm.LLVMType{"{ float, float }", "{ double, double }"}
+			if !reflect.DeepEqual(args, wantArgs) {
+				t.Fatalf("parameter args mismatch: got=%#v want=%#v", args, wantArgs)
+			}
+			wantSlots := []plan9asm.FrameSlot{
+				{Offset: 0, Type: plan9asm.LLVMType("float"), Index: 0, Field: 0},
+				{Offset: 4, Type: plan9asm.LLVMType("float"), Index: 0, Field: 1},
+				{Offset: 8, Type: plan9asm.LLVMType("double"), Index: 1, Field: 0},
+				{Offset: 16, Type: plan9asm.LLVMType("double"), Index: 1, Field: 1},
+			}
+			if !reflect.DeepEqual(slots, wantSlots) {
+				t.Fatalf("parameter slots mismatch: got=%#v want=%#v", slots, wantSlots)
+			}
+			if nextOff != 24 {
+				t.Fatalf("parameter nextOff = %d, want 24", nextOff)
+			}
+
+			results, resultSlots, resultEnd, err := llvmArgsAndFrameSlotsForTuple(tup, goarch, sz, 0, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			wantResults := []plan9asm.LLVMType{"float", "float", "double", "double"}
+			if !reflect.DeepEqual(results, wantResults) {
+				t.Fatalf("flattened result args mismatch: got=%#v want=%#v", results, wantResults)
+			}
+			wantResultSlots := []plan9asm.FrameSlot{
+				{Offset: 0, Type: plan9asm.LLVMType("float"), Index: 0, Field: -1, Name: "c64"},
+				{Offset: 4, Type: plan9asm.LLVMType("float"), Index: 1, Field: -1, Name: "c64"},
+				{Offset: 8, Type: plan9asm.LLVMType("double"), Index: 2, Field: -1, Name: "c128"},
+				{Offset: 16, Type: plan9asm.LLVMType("double"), Index: 3, Field: -1, Name: "c128"},
+			}
+			if !reflect.DeepEqual(resultSlots, wantResultSlots) {
+				t.Fatalf("result slots mismatch: got=%#v want=%#v", resultSlots, wantResultSlots)
+			}
+			if resultEnd != 24 {
+				t.Fatalf("result nextOff = %d, want 24", resultEnd)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/modern_x86_raw_test.go b/cmd/plan9asmll/modern_x86_raw_test.go
new file mode 100644
index 000000000..d8ee36e62
--- /dev/null
+++ b/cmd/plan9asmll/modern_x86_raw_test.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	plan9asm "github.com/xgo-dev/plan9asm"
+)
+
+func TestModernX86RawAVX2DirectiveStreamDecodesAtInstructionBoundaries(t *testing.T) {
+	// This is the complete AVX2 register-setup sequence used by the BLAKE2b
+	// assembly shared by golang.org/x/crypto and many go-ethereum forks. Each
+	// instruction addresses registers or memory through general registers; none
+	// of them is PC-relative.
+	code := []byte{
+		0xc5, 0x7a, 0x7e, 0x26,
+		0xc5, 0x7a, 0x7e, 0x5e, 0x20,
+		0xc4, 0x63, 0x99, 0x22, 0x66, 0x10, 0x01,
+		0xc4, 0x63, 0xa1, 0x22, 0x5e, 0x30, 0x01,
+	}
+	var source strings.Builder
+	source.WriteString("TEXT rawAVX2(SB), NOSPLIT, $0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "\tBYTE $%#02x\n", value)
+	}
+	source.WriteString("\tRET\n")
+
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := plan9asm.Translate(file, plan9asm.Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]plan9asm.FuncSig{
+			"rawAVX2": {Name: "rawAVX2", Ret: plan9asm.Void},
+		},
+	}); err != nil {
+		t.Fatalf("Translate() error = %v", err)
+	}
+}
+
+func TestModernX86RawCRC32WidthIsPreserved(t *testing.T) {
+	// 66 f2 0f 38 f1 /r is the register/memory 16-bit CRC32 form. The
+	// architecture decoder names every width CRC32, so plan9asm must restore
+	// the Plan 9 width suffix before operand-form validation.
+	const source = `TEXT rawCRC32W(SB), NOSPLIT, $0-0
+	BYTE $0x66
+	BYTE $0xf2
+	BYTE $0x0f
+	BYTE $0x38
+	BYTE $0xf1
+	BYTE $0x06
+	RET
+`
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := plan9asm.Translate(file, plan9asm.Options{
+		Goarch:       "amd64",
+		TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]plan9asm.FuncSig{
+			"rawCRC32W": {Name: "rawCRC32W", Ret: plan9asm.Void},
+		},
+	}); err != nil {
+		t.Fatalf("Translate() error = %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/movbe_supported_test.go b/cmd/plan9asmll/movbe_supported_test.go
new file mode 100644
index 000000000..eecdfea6b
--- /dev/null
+++ b/cmd/plan9asmll/movbe_supported_test.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteMOVBETable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_movbe_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_movbe_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"MOVBEW", "MOVBEWW", "MOVBEL", "MOVBELL", "MOVBEQ", "MOVBEQQ"} {
+			if _, ok := supported[op]; !ok {
+				t.Error("isolated complete MOVBE table omitted Go spelling", arch, op)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/movnti_supported_test.go b/cmd/plan9asmll/movnti_supported_test.go
new file mode 100644
index 000000000..8cfd8e9c2
--- /dev/null
+++ b/cmd/plan9asmll/movnti_supported_test.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteMOVNTITypedFamily(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_movnti_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, contents := range map[string][]byte{
+		"amd64_movnti_forms.go": data,
+		"translate.go":          []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{dir, "../.."} {
+		for _, arch := range []string{"386", "amd64"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"MOVNTIL", "MOVNTIQ"} {
+				if _, found := supported[op]; !found {
+					t.Fatal("complete scalar non-temporal family disappeared from reporting", arch, op)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/nontemporal_extraction_test.go b/cmd/plan9asmll/nontemporal_extraction_test.go
new file mode 100644
index 000000000..29fcc1e5c
--- /dev/null
+++ b/cmd/plan9asmll/nontemporal_extraction_test.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteNonTemporalVectorSpec(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_nontemporal_vector_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, source := range map[string][]byte{
+		"amd64_nontemporal_vector_forms.go": data,
+		"translate.go":                      []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), source, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{
+			"MOVNTO", "MOVNTDQ", "MOVNTPD", "MOVNTPS", "MOVNTDQA",
+			"VMOVNTDQ", "VMOVNTPD", "VMOVNTPS", "VMOVNTDQA",
+		} {
+			if _, found := supported[name]; !found {
+				t.Fatal("complete typed non-temporal registry disappeared from opcode reporting", arch, name)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/ordering_hint_specs_test.go b/cmd/plan9asmll/ordering_hint_specs_test.go
new file mode 100644
index 000000000..06e5e8fd8
--- /dev/null
+++ b/cmd/plan9asmll/ordering_hint_specs_test.go
@@ -0,0 +1,40 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteOrderingHintSpecTable(t *testing.T) {
+	const name = "amd64_ordering_hint_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		baseline, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil || len(supported) != len(baseline)+4 {
+			t.Fatalf("%s complete pure ordering/hint extraction: %v/%v", arch, supported, err)
+		}
+		for _, opcode := range []string{"LFENCE", "MFENCE", "SFENCE", "PAUSE"} {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s typed ordering/hint extraction omitted %s", arch, opcode)
+			}
+		}
+		if err := os.Remove(filepath.Join(dir, name)); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_declarations.go b/cmd/plan9asmll/ordinary_declarations.go
new file mode 100644
index 000000000..747d55d10
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_declarations.go
@@ -0,0 +1,267 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// This attempt-local reader owns declarations, not native storage or a second
+// package selection. packages.Load's actual types and source lists stay intact.
+// The GoModule frontend alone decides whether an instruction may read them.
+type ordinaryDeclarationSource struct {
+	pkg        plan9asm.GoPackage
+	file       *plan9asm.File
+	source     []byte
+	target     string
+	selected   map[*packages.Package]*x86CallerPackageSelection
+	snapshot   *gooriginalsrc.Snapshot
+	identities map[string]os.FileInfo
+	bytes      int64
+	sizes      types.Sizes
+}
+
+// This is only a cost query: a real variable mentioned by an SB operand makes
+// its complete declaration source worth reading. It does not duplicate the
+// translator's operand grammar, access widths, or imported-CMP-only admission.
+func ordinaryDeclarationCandidates(pkg *packages.Package, file *plan9asm.File) map[string]*packages.Package {
+	result := make(map[string]*packages.Package)
+	if pkg == nil || pkg.Types == nil || file == nil {
+		return result
+	}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			for _, operand := range instruction.Args {
+				symbol := operand.Sym
+				if operand.Kind == plan9asm.OpMem {
+					symbol = operand.Mem.Sym
+				}
+				if !strings.HasSuffix(symbol, "(SB)") {
+					continue
+				}
+				symbol = strings.TrimSuffix(symbol, "(SB)")
+				symbol = strings.ReplaceAll(strings.ReplaceAll(symbol, "∕", "/"), "·", ".")
+				separator := strings.LastIndexByte(symbol, '.')
+				path, name := "", symbol
+				if separator >= 0 {
+					path, name = symbol[:separator], symbol[separator+1:]
+				}
+				// Displacements belong to the identifier tail, not a module path
+				// which may itself contain '+' or '-'. Full validation stays below.
+				if index := strings.IndexAny(name, "+-"); index >= 0 {
+					name = name[:index]
+				}
+				owner := pkg
+				if path != "" && path != pkg.PkgPath && path != pkg.Types.Path() {
+					owner = pkg.Imports[path]
+				}
+				if owner == nil || owner.Types == nil || owner.Types.Scope() == nil || !token.IsIdentifier(name) {
+					continue
+				}
+				if variable, ok := owner.Types.Scope().Lookup(name).(*types.Var); ok && !variable.IsField() && variable.Pkg() == owner.Types {
+					if owner == pkg {
+						path = ""
+					}
+					result[path] = owner
+				}
+			}
+		}
+	}
+	return result
+}
+
+func captureOrdinaryDeclarations(pkg *packages.Package, file *plan9asm.File, source []byte,
+	reads *plan9asm.GoAssemblySourceReadReport, goos, goarch string, config compileConfig,
+) (_ *ordinaryDeclarationSource, captureErr error) {
+	if goarch != "386" && goarch != "amd64" {
+		return nil, nil
+	}
+	candidates := ordinaryDeclarationCandidates(pkg, file)
+	if len(candidates) == 0 {
+		return nil, nil
+	}
+	ctx, target := config.Context, goos+"/"+goarch
+	if ctx == nil || ctx.Err() != nil {
+		return nil, fmt.Errorf("ordinary declaration reader needs a live bounded context")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, fmt.Errorf("ordinary declaration reader needs a bounded context")
+	}
+	selection := config.x86CallerSelections[pkg]
+	if err := verifyAMD64FixedLocalSelection(pkg, selection, target); err != nil {
+		return nil, err
+	}
+	// Read the complete current package and only referenced direct imports. The
+	// real dependency export graph is reused, never reloaded or replaced.
+	candidates[""] = pkg
+	paths := make([]string, 0, len(candidates))
+	for path := range candidates {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	owners := make([]*packages.Package, 0, len(paths))
+	for _, path := range paths {
+		owners = append(owners, candidates[path])
+	}
+	actual := &ordinaryDeclarationSource{
+		pkg: plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types,
+			Imports: make(map[string]*types.Package), ImportSyntax: make(map[string][]*ast.File)},
+		file: file, source: append([]byte(nil), source...), target: target,
+		sizes:    pkg.TypesSizes,
+		selected: captureX86CallerSelectionsInEnvironment(owners, target, selection.env),
+		snapshot: gooriginalsrc.NewSnapshot(), identities: make(map[string]os.FileInfo),
+	}
+	// Keep the original load-bound selection, not a fresh copy of the caller.
+	actual.selected[pkg] = selection
+	defer func() {
+		if captureErr != nil {
+			actual.close()
+		}
+	}()
+	for path, dependency := range pkg.Imports {
+		if dependency != nil {
+			actual.pkg.Imports[path] = dependency.Types
+		}
+	}
+	if reads == nil || len(reads.Inputs) == 0 {
+		return nil, fmt.Errorf("ordinary declarations lack the complete original assembly read inventory")
+	}
+	for name, digest := range reads.Inputs {
+		if err := actual.retain(name); err != nil {
+			return nil, err
+		}
+		if actual.snapshot.View().Hashes[name] != digest {
+			return nil, fmt.Errorf("original assembly/header changed before declaration capture")
+		}
+	}
+	set, total := token.NewFileSet(), 0
+	for _, path := range paths {
+		owner := candidates[path]
+		if err := verifyAMD64FixedLocalSelection(owner, actual.selected[owner], target); err != nil {
+			return nil, err
+		}
+		if len(owner.CompiledGoFiles) == 0 || len(owner.CompiledGoFiles) > 256-total {
+			return nil, fmt.Errorf("ordinary declaration source inventory exceeds its shared 256-file bound")
+		}
+		total += len(owner.CompiledGoFiles)
+		if err := actual.snapshot.Directory(owner.Dir, false); err != nil {
+			return nil, err
+		}
+		var syntax []*ast.File
+		seen := make(map[string]bool)
+		for _, name := range owner.CompiledGoFiles {
+			if seen[name] {
+				return nil, fmt.Errorf("duplicate selected ordinary declaration source")
+			}
+			seen[name] = true
+			if err := actual.retain(name); err != nil {
+				return nil, err
+			}
+			data, err := actual.snapshot.ReadRetained(name)
+			if err != nil {
+				return nil, err
+			}
+			parsed, err := parser.ParseFile(set, name, data, parser.ParseComments)
+			if err != nil {
+				return nil, err
+			}
+			syntax = append(syntax, parsed)
+		}
+		if path == "" {
+			actual.pkg.Syntax = syntax
+		} else {
+			actual.pkg.ImportSyntax[path] = syntax
+		}
+	}
+	if err := actual.verify(ctx); err != nil {
+		return nil, err
+	}
+	return actual, nil
+}
+
+func (source *ordinaryDeclarationSource) retain(name string) error {
+	info, err := sourcepath.Lstat(name)
+	if err != nil {
+		return err
+	}
+	if source.identities[name] == nil && (info.Size() < 0 || info.Size() > 64<<20-source.bytes) {
+		return fmt.Errorf("ordinary declaration source exceeds its shared 64 MiB bound")
+	}
+	if err := source.snapshot.Retain(name); err != nil {
+		return err
+	}
+	if source.identities[name] == nil {
+		source.bytes += info.Size()
+	}
+	source.identities[name] = info
+	return nil
+}
+
+func (source *ordinaryDeclarationSource) verify(ctx context.Context) error {
+	if ctx == nil || ctx.Err() != nil || source.snapshot == nil {
+		return fmt.Errorf("ordinary declaration source expired or closed")
+	}
+	for pkg, selection := range source.selected {
+		if err := verifyAMD64FixedLocalSelection(pkg, selection, source.target); err != nil {
+			return err
+		}
+	}
+	for name, before := range source.identities {
+		after, err := sourcepath.Lstat(name)
+		if err != nil || !os.SameFile(before, after) || before.Mode() != after.Mode() ||
+			before.Size() != after.Size() || !before.ModTime().Equal(after.ModTime()) {
+			return fmt.Errorf("ordinary declaration source identity changed: %s", filepath.Base(name))
+		}
+	}
+	return source.snapshot.Verify()
+}
+
+func (source *ordinaryDeclarationSource) translate(ctx llvm.Context, file *plan9asm.File, triple, arch string,
+	annotate bool, resolve func(string) string,
+) (llvm.Module, error) {
+	if file != source.file {
+		return llvm.Module{}, fmt.Errorf("ordinary declaration source cannot be split or substituted")
+	}
+	goos, _, _ := strings.Cut(source.target, "/")
+	result, err := plan9asm.TranslateGoModuleInContext(ctx, source.pkg, source.source, plan9asm.GoModuleOptions{
+		GOOS: goos, GOARCH: arch, Sizes: source.sizes, TargetTriple: triple,
+		ResolveSym: resolve, AnnotateSource: annotate,
+	})
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	// The API above receives the complete immutable source, without KeepFunc.
+	// It audits private tails before coalescing them into public entry bodies;
+	// those source nodes intentionally have no callable/metadata entry. Public
+	// metadata is therefore not a count of consumed original TEXTs. Check only
+	// its namespace/uniqueness here, not the library's private source authority.
+	original, seen := make(map[string]bool), make(map[string]bool)
+	for _, function := range file.Funcs {
+		original[function.Sym] = true
+	}
+	for _, function := range result.Functions {
+		if !original[function.TextSymbol] || seen[function.TextSymbol] {
+			result.Module.Dispose()
+			return llvm.Module{}, fmt.Errorf("ordinary GoModule returned a foreign or duplicate public TEXT entry")
+		}
+		seen[function.TextSymbol] = true
+	}
+	return result.Module, nil
+}
+
+func (source *ordinaryDeclarationSource) close() {
+	*source = ordinaryDeclarationSource{}
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_embeds_go127_test.go b/cmd/plan9asmll/ordinary_dependency_embeds_go127_test.go
new file mode 100644
index 000000000..f20bc5f73
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_embeds_go127_test.go
@@ -0,0 +1,404 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// A normal imported package can own embedded bytes without becoming a test
+// package or an assembly output. Both the actual Go export and the ordinary
+// header/CPP/LLVM consumers must retain that independent input role.
+func TestGeneratedHeaderOrdinaryDependencyEmbedActualConsumer(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			files := map[string]string{
+				"dep/layout.go":    "package dep\nimport _ \"embed\"\nconst Value = 40\ntype Mixed struct { Small byte; Word uintptr; Bytes []byte }\n//go:embed defaults.bin\nvar Defaults []byte\n",
+				"dep/defaults.bin": "ordinary dependency's original asset\n",
+			}
+			for name, contents := range files {
+				if err := os.WriteFile(filepath.Join(dir, filepath.FromSlash(name)), []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[name] = featureBytesSHA256([]byte(contents))
+				if strings.HasSuffix(name, ".go") {
+					input.Headers[name] = contents
+				}
+			}
+			input.Directories["dep"] = append(input.Directories["dep"], "defaults.bin")
+			sort.Strings(input.Directories["dep"])
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, stderr, err := gotoolprofile.RunBounded(ctx, dir, featureEnvironment(os.Environ(), input.Observed.Environment),
+				binary, "list", "-export", "-json", "./dep")
+			if err != nil {
+				t.Fatalf("independent actual Go dependency export: %v\n%s", err, stderr)
+			}
+			var actual struct {
+				ImportPath, Export        string
+				EmbedPatterns, EmbedFiles []string
+			}
+			if err := json.Unmarshal(data, &actual); err != nil || actual.Export == "" ||
+				actual.ImportPath != input.Module+"/dep" || len(actual.EmbedPatterns) != 1 ||
+				len(actual.EmbedFiles) != 1 || actual.EmbedFiles[0] != "defaults.bin" {
+				t.Fatalf("actual Go did not compile the exact original embedded dependency: %+v; %v", actual, err)
+			}
+			parts := strings.Split(target, "/")
+			spec := targetSpec{Goos: parts[0], Goarch: parts[1]}
+			input.GeneratedHeaders, err = queryGeneratedHeaders(spec, []string{"."}, nil, input.AsmFiles, input.Module,
+				t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+			if err != nil {
+				t.Fatalf("ordinary dependency embed role cannot reach the actual header consumer: %v", err)
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module,
+				t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("ordinary embed source/header/CPP/LLVM consumer: %+v; %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderOrdinaryForeignEmbedActualConsumer(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, target)
+			const dependency = "example.invalid/asset-dependency"
+			ordinaryFixtureDependency(t, input, dependency, map[string]string{
+				"model/model.go":       "package model\nimport _ \"embed\"\nconst Value=40\n//go:embed all:assets\nvar Assets string\n",
+				"model/assets/.hidden": "original hidden asset\n",
+			})
+			source := "package dep\nimport \"" + dependency + "/model\"\nconst Value = model.Value\ntype Mixed struct { Small byte; Word uintptr; Bytes []byte }\n"
+			if err := os.WriteFile(filepath.Join(dir, "dep/layout.go"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["dep/layout.go"], input.Headers["dep/layout.go"] = featureBytesSHA256([]byte(source)), source
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			parts := strings.Split(target, "/")
+			spec := targetSpec{Goos: parts[0], Goarch: parts[1]}
+			input.GeneratedHeaders, err = queryGeneratedHeaders(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+			if err != nil {
+				t.Fatal(err)
+			}
+			found := false
+			for _, pkg := range input.GeneratedHeaders.Dependencies.ExternalPackages {
+				if pkg.Package.PackagePath == dependency+"/model" {
+					found = pkg.SourceRootID == dependency+"@v1.0.0" && pkg.Embed.Files["model/assets/.hidden"] != "" && pkg.ExportSHA256 != ""
+				}
+			}
+			if !found {
+				t.Fatal("complete transitive ordinary embed/ZIP/export role missing")
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			report, _, err := runOneTarget(spec, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Success != 1 || report.Failed != 0 {
+				t.Fatalf("foreign embed actual LLVM consumer: %+v; %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			data, err := json.Marshal(input.GeneratedHeaders)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*gotoolprofile.MetadataProof){
+				"missing role":           func(p *gotoolprofile.MetadataProof) { p.Dependencies = nil },
+				"old protocol":           func(p *gotoolprofile.MetadataProof) { p.Protocol = "actual_go_cpu_profile_metadata_v1" },
+				"test role":              func(p *gotoolprofile.MetadataProof) { p.Dependencies.Protocol = gotoolprofile.TestDependencyProtocol },
+				"missing import closure": func(p *gotoolprofile.MetadataProof) { p.Dependencies.ExternalPackages = nil },
+				"missing module owner":   func(p *gotoolprofile.MetadataProof) { p.Dependencies.SourceModules = nil },
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.MetadataProof
+					if err := json.Unmarshal(data, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					if err := gotoolprofile.ValidateMetadata(input, &changed, nil); err == nil {
+						t.Fatal("missing/old/changed ordinary role accepted")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderOrdinaryEmbedLiveMutation(t *testing.T) {
+	for _, axis := range []string{"before bytes", "before directory", "before directive", "after bytes", "after directory", "after cancel"} {
+		t.Run(axis, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, "linux/amd64")
+			source := "package dep\nimport _ \"embed\"\nconst Value=40\ntype Mixed struct { Small byte; Word uintptr; Bytes []byte }\n//go:embed asset.bin\nvar Asset []byte\n"
+			for name, text := range map[string]string{"dep/layout.go": source, "dep/asset.bin": "original"} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[name] = featureBytesSHA256([]byte(text))
+			}
+			input.Headers["dep/layout.go"] = source
+			input.Directories["dep"] = []string{"asset.bin", "layout.go"}
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutate := func() {
+				switch {
+				case strings.HasSuffix(axis, "bytes"):
+					if err := os.WriteFile(filepath.Join(dir, "dep/asset.bin"), []byte("changed"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				case strings.HasSuffix(axis, "directory"):
+					if err := os.WriteFile(filepath.Join(dir, "dep/new.bin"), nil, 0600); err != nil {
+						t.Fatal(err)
+					}
+				case strings.HasSuffix(axis, "directive"):
+					if err := os.WriteFile(filepath.Join(dir, "dep/layout.go"), []byte(strings.Replace(source, "asset.bin", "all:asset.bin", 1)), 0600); err != nil {
+						t.Fatal(err)
+					}
+				case strings.HasSuffix(axis, "cancel"):
+					cancel()
+				}
+			}
+			pkgs, err := loadGeneratedHeaderPackagesWithLoader(consumer, []string{"."}, nil, func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+				if strings.HasPrefix(axis, "before") && config.Mode&packages.NeedExportFile != 0 {
+					mutate()
+				}
+				return packages.Load(config, patterns...)
+			})
+			if strings.HasPrefix(axis, "before") {
+				if err == nil {
+					t.Fatal("dependency mutation before compiler export accepted")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := consumer.capturePackages(pkgs); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := captureGeneratedHeader(consumer, pkgs[0], consumer.Proof.Packages[0], t.TempDir()); err != nil {
+				t.Fatal(err)
+			}
+			mutate()
+			if err := consumer.verifySources(); err == nil {
+				t.Fatal("dependency mutation after compiler header accepted")
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderOrdinaryMetadataRequiresLiveOwner(t *testing.T) {
+	for _, consumer := range []*featureConsumer{nil, {}, {OrdinaryDependencies: &ordinaryDependencyOwner{}}, {OrdinaryDependencies: &ordinaryDependencyOwner{Compiled: true}}} {
+		if _, err := consumer.ordinaryDependencyProof(); err == nil {
+			t.Fatal("metadata acquired absent/incomplete owner")
+		}
+		if consumer != nil {
+			if err := consumer.captureGeneratedMetadata(nil, nil, t.TempDir()); err == nil {
+				t.Fatal("metadata helper accepted missing source owner")
+			}
+		}
+	}
+}
+
+func TestGeneratedHeaderOrdinaryCandidateOwnedLocalReplace(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	input.Version = "v1.0.0"
+	work := t.TempDir()
+	mod := "module example.invalid/workspace\n\ngo 1.24\nrequire " + input.Module + " v1.0.0\nreplace " + input.Module + " => " + filepath.ToSlash(dir) + "\n"
+	if err := os.WriteFile(filepath.Join(work, "go.mod"), []byte(mod), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(work)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	proof, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{input.Module}, nil,
+		input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proof.Packages[0].SourceRole != "owned_local_replace" || proof.Dependencies.Packages[0].SourceRootID != "" {
+		t.Fatal("explicit candidate owner was confused with an unbound foreign local replacement")
+	}
+}
+
+func TestGeneratedHeaderOrdinaryForeignLocalReplaceRejected(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	foreign := t.TempDir()
+	for name, text := range map[string]string{"go.mod": "module example.invalid/unbound\n\ngo 1.20\n", "source.go": "package unbound\nconst Value=40\n"} {
+		if err := os.WriteFile(filepath.Join(foreign, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for name, text := range map[string]string{
+		"go.mod":        "module " + input.Module + "\n\ngo 1.24\nrequire example.invalid/unbound v1.0.0\nreplace example.invalid/unbound => " + filepath.ToSlash(foreign) + "\n",
+		"dep/layout.go": "package dep\nimport \"example.invalid/unbound\"\nconst Value=unbound.Value\ntype Mixed struct{Small byte; Word uintptr; Bytes []byte}\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(text))
+		if strings.HasSuffix(name, ".go") {
+			input.Headers[name] = text
+		}
+	}
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	_, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module, t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err == nil || !strings.Contains(err.Error(), "exact versioned Module/Replace") {
+		t.Fatalf("foreign local replacement acquired ZIP authority: %v", err)
+	}
+}
+
+func TestGeneratedHeaderOrdinaryForeignOwnerFinalGuards(t *testing.T) {
+	for _, axis := range []string{"asset", "new member", "ZIP", "metadata"} {
+		t.Run(axis, func(t *testing.T) {
+			input, dir := generatedHeaderFixture(t, "linux/amd64")
+			const dependency = "example.invalid/foreign-guard"
+			foreign := ordinaryFixtureDependency(t, input, dependency, map[string]string{
+				"source.go": "package external\nimport _ \"embed\"\nconst Value=40\n//go:embed asset.bin\nvar Asset []byte\n",
+				"asset.bin": "original foreign asset",
+			})
+			source := "package dep\nimport external \"" + dependency + "\"\nconst Value=external.Value\ntype Mixed struct{Small byte; Word uintptr; Bytes []byte}\n"
+			if err := os.WriteFile(filepath.Join(dir, "dep/layout.go"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["dep/layout.go"], input.Headers["dep/layout.go"] = featureBytesSHA256([]byte(source)), source
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkgs, err := loadGeneratedHeaderPackages(consumer, []string{"."}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := consumer.capturePackages(pkgs); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := captureGeneratedHeader(consumer, pkgs[0], consumer.Proof.Packages[0], t.TempDir()); err != nil {
+				t.Fatal(err)
+			}
+			owner := consumer.OrdinaryDependencies.Modules[dependency+"@v1.0.0"]
+			if owner == nil {
+				t.Fatal("actual owner absent")
+			}
+			switch axis {
+			case "asset":
+				file := filepath.Join(foreign, "asset.bin")
+				if err := os.Chmod(file, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(file, []byte("changed"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "new member":
+				if err := os.Chmod(foreign, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(foreign, "new.bin"), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "ZIP":
+				file, err := os.OpenFile(owner.ZIP, os.O_WRONLY|os.O_APPEND, 0600)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := file.WriteString("changed archive bytes"); err != nil {
+					t.Fatal(err)
+				}
+				if err := file.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "metadata":
+				if err := os.Chmod(owner.DownloadedGoMod, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(owner.DownloadedGoMod, []byte("module example.invalid/changed\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := consumer.verifySources(); err == nil {
+				t.Fatal("foreign asset/ZIP/metadata mutation survived final source guard")
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderOrdinaryUnsignedLegacyMetadataRejected(t *testing.T) {
+	input, dir := generatedHeaderFixture(t, "linux/amd64")
+	const dependency = "example.invalid/unsigned-legacy"
+	foreign := ordinaryFixtureDependencyOrigin(t, input, dependency, map[string]string{
+		"source.go": "package legacy\nconst Value=40\n",
+	}, false)
+	if _, err := os.Stat(filepath.Join(foreign, "go.mod")); !os.IsNotExist(err) {
+		t.Fatal("actual Go download fixture unexpectedly acquired an original go.mod")
+	}
+	// Deliberately invalid cached public metadata prevents any network repair.
+	// GOSUMDB=off is allowed only for creating the first-party mechanics ZIP;
+	// it must not authorize a legacy ordinary source's independent .mod origin.
+	lookup := filepath.Join(os.Getenv("GOMODCACHE"), "cache/download/sumdb/sum.golang.org/lookup", dependency+"@v1.0.0")
+	if err := os.MkdirAll(filepath.Dir(lookup), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(lookup, []byte("not a signed record\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	source := "package dep\nimport legacy \"" + dependency + "\"\nconst Value=legacy.Value\ntype Mixed struct{Small byte; Word uintptr; Bytes []byte}\n"
+	if err := os.WriteFile(filepath.Join(dir, "dep/layout.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["dep/layout.go"], input.Headers["dep/layout.go"] = featureBytesSHA256([]byte(source)), source
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	_, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, input.AsmFiles, input.Module,
+		t.TempDir(), compileConfig{FeaturePath: writeFeatureInput(t, input), Context: ctx})
+	if err == nil || !strings.Contains(err.Error(), "proxy metadata authentication") {
+		t.Fatalf("unsigned legacy metadata acquired an ordinary source role: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_fixture_test.go b/cmd/plan9asmll/ordinary_dependency_fixture_test.go
new file mode 100644
index 000000000..b0b3af535
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_fixture_test.go
@@ -0,0 +1,111 @@
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// An exact synthetic module served by an owned file proxy exercises the same
+// actual download/ZIP path as production, without fetching external source.
+func ordinaryFixtureDependency(t *testing.T, input *featureInput, module string, files map[string]string) string {
+	return ordinaryFixtureDependencyOrigin(t, input, module, files, true)
+}
+
+func ordinaryFixtureDependencyOrigin(t *testing.T, input *featureInput, module string, files map[string]string, originalGoMod bool) string {
+	t.Helper()
+	proxy, cache := t.TempDir(), t.TempDir()
+	metadata := "module " + module + "\n\ngo 1.20\n"
+	if originalGoMod {
+		files["go.mod"] = metadata
+	}
+	var archive bytes.Buffer
+	writer := zip.NewWriter(&archive)
+	var names []string
+	for name := range files {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		entry, err := writer.Create(module + "@v1.0.0/" + name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := entry.Write([]byte(files[name])); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(proxy, module, "@v")
+	if err := os.MkdirAll(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for suffix, data := range map[string][]byte{
+		".zip": archive.Bytes(), ".mod": []byte(metadata),
+		".info": []byte(`{"Version":"v1.0.0","Time":"2026-10-01T00:00:00Z"}`),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, "v1.0.0"+suffix), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOPROXY", proxyURL)
+	t.Setenv("GOSUMDB", "off")
+	t.Setenv("GOMODCACHE", cache)
+	t.Setenv("GOPATH", t.TempDir())
+	t.Cleanup(func() {
+		if err := filepath.Walk(cache, func(file string, info os.FileInfo, err error) error {
+			if err != nil {
+				return err
+			}
+			if info.IsDir() {
+				return os.Chmod(file, 0700)
+			}
+			return nil
+		}); err != nil {
+			t.Error(err)
+		}
+	})
+	mod := "module " + input.Module + "\n\ngo 1.24\nrequire " + module + " v1.0.0\n"
+	if err := os.WriteFile(filepath.Join(input.SourceRoot, "go.mod"), []byte(mod), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["go.mod"] = featureBytesSHA256([]byte(mod))
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, stderr, err := gotoolprofile.RunBounded(ctx, input.SourceRoot, featureEnvironment(os.Environ(), input.Observed.Environment), binary, "mod", "download", "-json", module+"@v1.0.0")
+	if err != nil {
+		t.Fatalf("actual owned proxy download: %v\n%s", err, stderr)
+	}
+	var actual struct{ Dir, Error string }
+	if err := json.Unmarshal(data, &actual); err != nil || actual.Error != "" || actual.Dir == "" {
+		t.Fatalf("actual proxy identity: %s; %v", data, err)
+	}
+	if data, err := os.ReadFile(filepath.Join(input.SourceRoot, "go.sum")); err != nil {
+		t.Fatal(err)
+	} else {
+		input.Sources["go.sum"] = featureBytesSHA256(data)
+		input.Directories["."] = append(input.Directories["."], "go.sum")
+		sort.Strings(input.Directories["."])
+	}
+	return actual.Dir
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_root.go b/cmd/plan9asmll/ordinary_dependency_root.go
new file mode 100644
index 000000000..9d172f310
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_root.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func ordinaryDependencyActualRoot(consumer *featureConsumer, pkg *packages.Package) string {
+	if pkg.Module == nil {
+		return filepath.Join(consumer.Root, "src")
+	}
+	if pkg.Module.Replace != nil {
+		return pkg.Module.Replace.Dir
+	}
+	return pkg.Module.Dir
+}
+
+// Only the actual driver's module-root spelling may have ancestor aliases.
+// Preserve its relative source identity before resolving anything below it:
+// blindly canonicalizing a selected file would hide source-internal redirects.
+func ordinaryDependencyOriginalPath(observed, root, filename string) (string, error) {
+	// go.mod replacement roots may keep '/' on Windows. Normalize separators
+	// only; Clean below must still reject dot segments and other changed paths.
+	observed = filepath.FromSlash(observed)
+	root = filepath.FromSlash(root)
+	filename = filepath.FromSlash(filename)
+	for _, name := range []string{observed, root, filename} {
+		if !filepath.IsAbs(name) || filepath.Clean(name) != name {
+			return "", fmt.Errorf("ordinary dependency has an unbound original source path")
+		}
+	}
+	resolved, err := sourcepath.Resolve(observed)
+	if err != nil || resolved != root {
+		return "", fmt.Errorf("ordinary dependency observed source root changed")
+	}
+	resolved, err = sourcepath.Resolve(root)
+	if err != nil || resolved != root {
+		return "", fmt.Errorf("ordinary dependency canonical source root changed")
+	}
+	relative, err := filepath.Rel(observed, filename)
+	local := func(name string) bool {
+		return name == "." || gotoolprofile.CPPLocalSource(filepath.ToSlash(name))
+	}
+	if err != nil || !local(relative) {
+		// Some drivers already canonicalize selected filenames. This is not
+		// permission to use another arbitrary alias to the same bytes.
+		relative, err = filepath.Rel(root, filename)
+		if err != nil || !local(relative) {
+			return "", fmt.Errorf("ordinary dependency source escapes its actual module root")
+		}
+	}
+	canonical := filepath.Join(root, relative)
+	resolved, err = sourcepath.Resolve(canonical)
+	if err != nil || resolved != canonical {
+		return "", fmt.Errorf("ordinary dependency source is internally redirected")
+	}
+	resolved, err = sourcepath.Resolve(filename)
+	if err != nil || resolved != canonical {
+		return "", fmt.Errorf("ordinary dependency original source identity changed")
+	}
+	return canonical, nil
+}
+
+func captureOrdinaryPackageEmbedSelection(proof gotoolprofile.PackageProof, observed, root string, pkg *packages.Package) (*gotoolprofile.TestEmbedSelection, error) {
+	copy := *pkg
+	copy.EmbedFiles = make([]string, len(pkg.EmbedFiles))
+	for index, file := range pkg.EmbedFiles {
+		canonical, err := ordinaryDependencyOriginalPath(observed, root, file)
+		if err != nil {
+			return nil, err
+		}
+		copy.EmbedFiles[index] = canonical
+	}
+	// Keep the driver's original GoFiles and pattern spellings paired: glob
+	// syntax is not an existing filename and must not pass through EvalSymlinks.
+	return captureTestPackageEmbedSelection(proof, root, &copy)
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_root_alias_go127_test.go b/cmd/plan9asmll/ordinary_dependency_root_alias_go127_test.go
new file mode 100644
index 000000000..0cd63bdd3
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_root_alias_go127_test.go
@@ -0,0 +1,179 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/tools/go/packages"
+)
+
+// The alias belongs above the module root, not within its source inventory.
+// The actual Go driver keeps this spelling for a local replacement. An owner
+// must accept that original spelling while retaining its canonical identity.
+func ordinaryRootAliasFixture(t *testing.T, target string) (*featureInput, string, string) {
+	t.Helper()
+	input, dir := generatedHeaderFixture(t, target)
+	input.Version = "v1.0.0"
+	source := "package dep\nimport _ \"embed\"\nconst Value=40\ntype Mixed struct{Small byte; Word uintptr; Bytes []byte}\n//go:embed asset.bin\nvar Asset []byte\n"
+	for name, text := range map[string]string{"dep/layout.go": source, "dep/asset.bin": "original asset"} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(text))
+	}
+	input.Headers["dep/layout.go"] = source
+	input.Directories["dep"] = []string{"asset.bin", "layout.go"}
+	parent, err := filepath.EvalSymlinks(filepath.Dir(dir))
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "ancestor")
+	if err := os.Symlink(parent, alias); err != nil {
+		t.Fatal(err)
+	}
+	observed := filepath.Join(alias, filepath.Base(dir))
+	work := t.TempDir()
+	mod := "module example.invalid/workspace\n\ngo 1.24\nrequire " + input.Module + " v1.0.0\nreplace " + input.Module + " => " + filepath.ToSlash(observed) + "\n"
+	if err := os.WriteFile(filepath.Join(work, "go.mod"), []byte(mod), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(work)
+	return input, dir, alias
+}
+
+func TestGeneratedHeaderOrdinaryRootAliasActualLoad(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			input, _, alias := ordinaryRootAliasFixture(t, target)
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), target, input.Module, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed := false
+			pkgs, err := loadGeneratedHeaderPackagesWithLoader(consumer, []string{input.Module}, nil,
+				func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+					pkgs, err := packages.Load(config, patterns...)
+					if err == nil && len(pkgs) != 0 && len(pkgs[0].GoFiles) != 0 {
+						observed = observed || strings.HasPrefix(pkgs[0].GoFiles[0], alias+string(filepath.Separator))
+					}
+					return pkgs, err
+				})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !observed {
+				t.Fatal("actual Go did not exercise the original ancestor-alias spelling")
+			}
+			if err := consumer.capturePackages(pkgs); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := captureGeneratedHeader(consumer, pkgs[0], consumer.Proof.Packages[0], t.TempDir()); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := consumer.ordinaryDependencyProof(); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderOrdinaryRootAliasRetainsIdentity(t *testing.T) {
+	for _, phase := range []string{"before compiler", "after header", "cancelled", "internal source", "internal asset"} {
+		t.Run(phase, func(t *testing.T) {
+			input, dir, alias := ordinaryRootAliasFixture(t, "linux/amd64")
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			consumer, err := loadFeatureConsumer(ctx, writeFeatureInput(t, input), t.TempDir(), "linux/amd64", input.Module, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			repoint := func() {
+				parent := t.TempDir()
+				copyRoot := filepath.Join(parent, filepath.Base(dir))
+				for name := range input.Sources {
+					data, err := os.ReadFile(filepath.Join(dir, name))
+					if err != nil {
+						t.Fatal(err)
+					}
+					file := filepath.Join(copyRoot, name)
+					if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(file, data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := os.Remove(alias); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(parent, alias); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if strings.HasPrefix(phase, "internal") {
+				name := "dep/layout.go"
+				if phase == "internal asset" {
+					name = "dep/asset.bin"
+				}
+				file := filepath.Join(dir, name)
+				outside := filepath.Join(t.TempDir(), "same-bytes")
+				data, err := os.ReadFile(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(outside, data, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Remove(file); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(outside, file); err != nil {
+					t.Fatal(err)
+				}
+			}
+			mutated := false
+			pkgs, err := loadGeneratedHeaderPackagesWithLoader(consumer, []string{input.Module}, nil,
+				func(config *packages.Config, patterns ...string) ([]*packages.Package, error) {
+					if phase == "before compiler" && config.Mode&packages.NeedExportFile != 0 {
+						repoint()
+						mutated = true
+					}
+					return packages.Load(config, patterns...)
+				})
+			if phase == "before compiler" || strings.HasPrefix(phase, "internal") {
+				if phase == "before compiler" && !mutated {
+					t.Fatalf("owner never reached the actual compiler mutation boundary: %v", err)
+				}
+				if err == nil {
+					t.Fatal("changed owner or internal source alias acquired ordinary authority")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := consumer.capturePackages(pkgs); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := captureGeneratedHeader(consumer, pkgs[0], consumer.Proof.Packages[0], t.TempDir()); err != nil {
+				t.Fatal(err)
+			}
+			if phase == "cancelled" {
+				cancel()
+			} else {
+				repoint()
+			}
+			if err := consumer.verifySources(); err == nil {
+				t.Fatal("live root alias or context change survived the final owner guard")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_root_test.go b/cmd/plan9asmll/ordinary_dependency_root_test.go
new file mode 100644
index 000000000..de5888ad6
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_root_test.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestOrdinaryDependencyRootPathRoles(t *testing.T) {
+	parent, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(parent, "module")
+	if err := os.MkdirAll(filepath.Join(root, "pkg"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	file := filepath.Join(root, "pkg", "source.go")
+	if err := os.WriteFile(file, []byte("package pkg\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "ancestor")
+	if err := os.Symlink(parent, alias); err != nil {
+		t.Fatal(err)
+	}
+	observed := filepath.Join(alias, "module")
+	other := filepath.Join(t.TempDir(), "other-alias")
+	if err := os.Symlink(root, other); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(filepath.Join(root, "pkg"), filepath.Join(root, "redirect")); err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []struct {
+		name, filename, want string
+	}{
+		{"observed root", observed, root},
+		{"canonical root", root, root},
+		{"observed file", filepath.Join(observed, "pkg/source.go"), file},
+		{"canonical file", file, file},
+		{"other alias", filepath.Join(other, "pkg/source.go"), ""},
+		{"internal alias", filepath.Join(observed, "redirect/source.go"), ""},
+		{"missing", filepath.Join(observed, "missing.go"), ""},
+		{"relative", "pkg/source.go", ""},
+		{"unclean", observed + "/pkg/../pkg/source.go", ""},
+		{"outside", filepath.Join(parent, "outside.go"), ""},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			for _, spelling := range []struct {
+				name, observed, root, file string
+			}{
+				{"native", observed, root, row.filename},
+				{"module replacement slash", filepath.ToSlash(observed), root, row.filename},
+				{"selected source slash", observed, root, filepath.ToSlash(row.filename)},
+				{"all slash", filepath.ToSlash(observed), filepath.ToSlash(root), filepath.ToSlash(row.filename)},
+			} {
+				t.Run(spelling.name, func(t *testing.T) {
+					got, err := ordinaryDependencyOriginalPath(spelling.observed, spelling.root, spelling.file)
+					if row.want == "" {
+						if err == nil || got != "" {
+							t.Fatalf("unbound source path acquired ownership: %s", got)
+						}
+					} else if err != nil || got != row.want {
+						t.Fatalf("same original root spelling: got %s; %v", got, err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_dependency_sources.go b/cmd/plan9asmll/ordinary_dependency_sources.go
new file mode 100644
index 000000000..367535ea6
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_dependency_sources.go
@@ -0,0 +1,410 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+	"golang.org/x/tools/go/packages"
+)
+
+// An ordinary owner is private to one live load. It is never installed in the
+// test guards and portable records alone cannot manufacture this authority.
+type ordinaryDependencyOwner struct {
+	Compiled bool
+	Proof    *gotoolprofile.OrdinaryDependencyProof
+	Packages map[string]ordinaryDependencyPackage
+	Modules  map[string]*ordinaryDependencyModule
+	Roots    map[string]string
+}
+
+type ordinaryDependencyPackage struct {
+	Source             gotoolprofile.SourcePackageProof
+	Root, ObservedRoot string
+}
+
+type ordinaryDependencyModule struct {
+	Source                     gotoolprofile.ModuleSourceSnapshot
+	Root, ZIP, DownloadedGoMod string
+	Metadata                   map[string]string
+}
+
+func (consumer *featureConsumer) captureOrdinaryDependencies(pkgs []*packages.Package) error {
+	consumer.OrdinaryDependencies = nil
+	owner := &ordinaryDependencyOwner{
+		Proof:    &gotoolprofile.OrdinaryDependencyProof{Protocol: gotoolprofile.OrdinaryDependencyProtocol},
+		Packages: make(map[string]ordinaryDependencyPackage), Modules: make(map[string]*ordinaryDependencyModule),
+		Roots: make(map[string]string),
+	}
+	var captureErr error
+	packages.Visit(pkgs, func(pkg *packages.Package) bool {
+		if captureErr != nil {
+			return false
+		}
+		if len(pkg.Errors) != 0 {
+			var diagnostics []string
+			for _, err := range pkg.Errors {
+				diagnostics = append(diagnostics, err.Error())
+			}
+			captureErr = fmt.Errorf("actual generated-header Go source selection:\n%s", strings.Join(diagnostics, "\n"))
+			return false
+		}
+		if consumer.Context == nil || consumer.Context.Err() != nil || len(owner.Packages) >= 4096 ||
+			pkg.ID != pkg.PkgPath || isTestVariantPackage(pkg) {
+			captureErr = fmt.Errorf("ordinary dependency source requires a live complete ordinary package selection")
+			return false
+		}
+		source, root, err := consumer.captureOrdinaryDependencyPackage(owner, pkg)
+		if err != nil {
+			captureErr = err
+			return false
+		}
+		owner.Packages[pkg.PkgPath] = ordinaryDependencyPackage{Source: source, Root: root, ObservedRoot: ordinaryDependencyActualRoot(consumer, pkg)}
+		return true
+	}, nil)
+	if captureErr != nil {
+		return captureErr
+	}
+	for _, bound := range owner.Packages {
+		if bound.Source.SourceRootID == "" {
+			owner.Proof.Packages = append(owner.Proof.Packages, bound.Source)
+		} else {
+			owner.Proof.ExternalPackages = append(owner.Proof.ExternalPackages, bound.Source)
+		}
+	}
+	for _, module := range owner.Modules {
+		owner.Proof.SourceModules = append(owner.Proof.SourceModules, module.Source)
+	}
+	gotoolprofile.SortTestModuleSources(owner.Proof.SourceModules)
+	for _, sources := range [][]gotoolprofile.SourcePackageProof{owner.Proof.Packages, owner.Proof.ExternalPackages} {
+		sort.Slice(sources, func(i, j int) bool { return sources[i].Package.PackagePath < sources[j].Package.PackagePath })
+	}
+	if err := consumer.verifyOrdinaryOwner(owner); err != nil {
+		return err
+	}
+	consumer.OrdinaryDependencies = owner
+	return nil
+}
+
+func (consumer *featureConsumer) captureOrdinaryDependencyPackage(owner *ordinaryDependencyOwner, actual *packages.Package) (gotoolprofile.SourcePackageProof, string, error) {
+	result := gotoolprofile.SourcePackageProof{VariantID: actual.ID, ImportMap: make(map[string]string)}
+	proof := gotoolprofile.PackageProof{PackagePath: actual.PkgPath, SourceSHA256: make(map[string]string)}
+	root, id, metadata := consumer.Dir, "", ""
+	if actual.Module == nil {
+		root = filepath.Join(consumer.Root, "src")
+		proof.SourceRole, id = "stdlib", "stdlib@"+consumer.Observed.GoVersion
+	} else {
+		m := actual.Module
+		root, metadata = m.Dir, m.GoMod
+		proof.ModulePath, proof.ModuleVersion = m.Path, m.Version
+		proof.SourceModule, proof.SourceVersion, proof.SourceRole = m.Path, m.Version, "module"
+		if m.Main {
+			proof.SourceRole = "main"
+		}
+		if r := m.Replace; r != nil {
+			root, metadata = r.Dir, r.GoMod
+			if r.Version == "" {
+				proof.SourceRole = "owned_local_replace"
+			} else {
+				proof.SourceModule, proof.SourceVersion, proof.SourceRole = r.Path, r.Version, "version_replace"
+			}
+		}
+		if m.Path == consumer.Input.Module {
+			if origin := consumer.Input.ProxyGoMod; origin != nil {
+				proof.GoModOrigin, proof.GoModSHA256, proof.GoModSum = origin.Protocol, origin.SHA256, origin.GoModSum
+			}
+			if err := gotoolprofile.ValidatePackageModule(consumer.Input, proof); err != nil {
+				return result, "", err
+			}
+		} else {
+			if m.Main || module.Check(m.Path, m.Version) != nil || module.Check(proof.SourceModule, proof.SourceVersion) != nil || proof.SourceRole == "owned_local_replace" {
+				return result, "", fmt.Errorf("ordinary dependency lacks an exact versioned Module/Replace source")
+			}
+			id = proof.SourceModule + "@" + proof.SourceVersion
+		}
+	}
+	observedRoot := root
+	var err error
+	root, err = sourcepath.Resolve(root)
+	if err != nil || !filepath.IsAbs(root) || id == "" && root != consumer.Dir {
+		return result, "", fmt.Errorf("ordinary dependency has a different actual source root")
+	}
+	if previous, present := owner.Roots[observedRoot]; present && previous != root {
+		return result, "", fmt.Errorf("ordinary dependency observed source root changed")
+	}
+	owner.Roots[observedRoot] = root
+	var inventory *gotoolprofile.SourceInventory
+	if id == "" {
+		inventory = &owner.Proof.Candidate
+	} else {
+		bound := owner.Modules[id]
+		if bound == nil {
+			bound, err = consumer.captureOrdinaryModule(proof, root, metadata)
+			if err != nil {
+				return result, "", err
+			}
+			owner.Modules[id] = bound
+		} else if root != bound.Root {
+			return result, "", fmt.Errorf("ordinary dependency source identity changed roots")
+		}
+		view := bound.Source.Inventory()
+		inventory = &view
+		defer func() {
+			bound.Source.Sources, bound.Source.Headers, bound.Source.Directories = view.Sources, view.Headers, view.Directories
+		}()
+		if metadata != "" {
+			canonical, err := sourcepath.Resolve(metadata)
+			if err != nil {
+				return result, "", err
+			}
+			bound.Metadata[metadata] = canonical
+		}
+		if bound.Source.SourceModule != "" {
+			proof.GoModOrigin, proof.GoModSHA256, proof.GoModSum = bound.Source.GoModOrigin, bound.Source.GoModSHA256, bound.Source.GoModSum
+		}
+	}
+	if len(actual.GoFiles) == 0 {
+		return result, "", fmt.Errorf("ordinary dependency lacks original Go sources")
+	}
+	directory, err := ordinaryDependencyOriginalPath(observedRoot, root, filepath.Dir(actual.GoFiles[0]))
+	if err != nil {
+		return result, "", err
+	}
+	if err := gotoolprofile.CaptureSourceDirectory(consumer.Context, inventory, root, directory, len(actual.EmbedPatterns) != 0); err != nil {
+		return result, "", err
+	}
+	capture := func(files []string, assembly bool) ([]string, error) {
+		var names []string
+		for _, filename := range files {
+			if assembly && filepath.Ext(filename) != ".s" {
+				continue
+			}
+			filename, err := ordinaryDependencyOriginalPath(observedRoot, root, filename)
+			if err != nil {
+				return nil, err
+			}
+			name, err := filepath.Rel(root, filename)
+			name = filepath.ToSlash(name)
+			if err != nil {
+				return nil, err
+			}
+			if _, err := gotoolprofile.CPPRegularSource(root, name); err != nil {
+				return nil, err
+			}
+			digest, err := gotoolprofile.FileSHA256(filename)
+			if err != nil || inventory.Sources[name] != digest {
+				return nil, fmt.Errorf("ordinary dependency selected unbound original bytes")
+			}
+			proof.SourceSHA256[name] = digest
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		return names, nil
+	}
+	if proof.GoFiles, err = capture(actual.GoFiles, false); err != nil {
+		return result, "", err
+	}
+	if proof.CompiledGoFiles, err = capture(actual.CompiledGoFiles, false); err != nil {
+		return result, "", err
+	}
+	if proof.SFiles, err = capture(actual.OtherFiles, true); err != nil {
+		return result, "", err
+	}
+	if actual.PkgPath == "unsafe" {
+		if actual.Name != "unsafe" || actual.Module != nil || actual.ExportFile != "" || len(actual.Imports) != 0 ||
+			!reflect.DeepEqual(proof.GoFiles, []string{"unsafe/unsafe.go"}) || len(proof.CompiledGoFiles) != 0 || len(proof.SFiles) != 0 {
+			return result, "", fmt.Errorf("ordinary unsafe singleton has a different source role")
+		}
+		result.Builtin = "go_typechecker_unsafe_v1"
+	} else if !reflect.DeepEqual(proof.GoFiles, proof.CompiledGoFiles) {
+		return result, "", fmt.Errorf("ordinary dependency cannot acquire a generated/cgo/overlay source role")
+	}
+	for spelling, dep := range actual.Imports {
+		result.ImportMap[spelling] = dep.PkgPath
+	}
+	result.Package, result.SourceRootID = proof, id
+	result.Embed, err = captureOrdinaryPackageEmbedSelection(proof, observedRoot, root, actual)
+	return result, root, err
+}
+
+func (consumer *featureConsumer) captureOrdinaryModule(pkg gotoolprofile.PackageProof, root, metadata string) (*ordinaryDependencyModule, error) {
+	bound := &ordinaryDependencyModule{Root: root, Metadata: make(map[string]string), Source: gotoolprofile.ModuleSourceSnapshot{
+		Protocol: gotoolprofile.TestDependencyModuleProtocol, SourceModule: pkg.SourceModule, SourceVersion: pkg.SourceVersion,
+	}}
+	if pkg.SourceRole == "stdlib" {
+		bound.Source.GoVersion = consumer.Observed.GoVersion
+		return bound, nil
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	data, _, err := gotoolprofile.RunBounded(consumer.Context, consumer.WorkDir, consumer.Env, binary, "mod", "download", "-json", bound.Source.ID())
+	if err != nil {
+		return nil, err
+	}
+	var download struct{ Path, Version, Dir, Zip, GoMod, Sum, GoModSum, Error string }
+	if err := json.Unmarshal(data, &download); err != nil || download.Error != "" || download.Path != pkg.SourceModule || download.Version != pkg.SourceVersion {
+		return nil, fmt.Errorf("ordinary dependency download has a different exact module identity")
+	}
+	directory, err := sourcepath.Resolve(download.Dir)
+	if err != nil || directory != root {
+		return nil, fmt.Errorf("ordinary dependency download has a different actual source root")
+	}
+	bound.ZIP, bound.DownloadedGoMod = download.Zip, download.GoMod
+	bound.Source.ModuleSum, bound.Source.GoModSum = download.Sum, download.GoModSum
+	bound.Source.ZipSHA256, err = gotoolprofile.FileSHA256(download.Zip)
+	if err != nil {
+		return nil, err
+	}
+	bound.Source.GoModSHA256, err = gotoolprofile.FileSHA256(download.GoMod)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := os.Lstat(filepath.Join(root, "go.mod")); os.IsNotExist(err) {
+		var prior *gotoolprofile.ProxyGoModProof
+		if expected := consumer.Input.GeneratedHeaders; expected != nil && expected.Dependencies != nil {
+			for _, source := range expected.Dependencies.SourceModules {
+				if source.ID() == bound.Source.ID() {
+					prior = source.ProxyGoMod
+				}
+			}
+		}
+		origin, canonical, err := gotoolprofile.CaptureDownloadedProxyGoMod(consumer.Context, binary, consumer.WorkDir, consumer.Env,
+			pkg.SourceModule, pkg.SourceVersion, download.Sum, download.GoModSum, download.GoMod, prior)
+		if err != nil {
+			return nil, fmt.Errorf("ordinary dependency proxy metadata authentication: %w", err)
+		}
+		bound.Source.GoModOrigin, bound.Source.ProxyGoMod = gotoolprofile.ProxyGoModProtocol, origin
+		bound.DownloadedGoMod = canonical
+		return bound, nil
+	} else if err != nil {
+		return nil, err
+	}
+	bound.Source.GoModOrigin = gotoolprofile.TestModuleOriginalGoModOrigin
+	return bound, nil
+}
+
+func (consumer *featureConsumer) verifyOrdinaryOwner(owner *ordinaryDependencyOwner) error {
+	if owner == nil {
+		return nil
+	}
+	if owner.Proof == nil || owner.Proof.Protocol != gotoolprofile.OrdinaryDependencyProtocol || len(owner.Packages) == 0 {
+		return fmt.Errorf("ordinary dependency source owner is incomplete")
+	}
+	if len(owner.Roots) == 0 {
+		return fmt.Errorf("ordinary dependency source owner lacks its actual root identity")
+	}
+	for observed, canonical := range owner.Roots {
+		if _, err := ordinaryDependencyOriginalPath(observed, canonical, observed); err != nil {
+			return err
+		}
+	}
+	if err := gotoolprofile.VerifySourceInventory(consumer.Context, owner.Proof.Candidate, consumer.Dir); err != nil {
+		return err
+	}
+	for _, bound := range owner.Modules {
+		if bound == nil {
+			return fmt.Errorf("ordinary dependency source owner has no bound module")
+		}
+		if err := gotoolprofile.VerifyTestModuleSource(consumer.Context, bound.Source, bound.Root, bound.ZIP); err != nil {
+			return err
+		}
+		for filename, canonical := range bound.Metadata {
+			actual, err := sourcepath.Resolve(filename)
+			if err != nil || actual != canonical {
+				return fmt.Errorf("ordinary dependency metadata path changed")
+			}
+			if err := gotoolprofile.VerifyTestModuleGoModMetadata(bound.Source, bound.Root, filename, bound.DownloadedGoMod); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (consumer *featureConsumer) verifyOrdinaryEmbedPackage(pkg *packages.Package) error {
+	owner := consumer.OrdinaryDependencies
+	if owner == nil || pkg == nil {
+		return fmt.Errorf("ordinary dependency lacks a live independently bound source owner")
+	}
+	bound, present := owner.Packages[pkg.PkgPath]
+	if !present || pkg.ID != pkg.PkgPath || isTestVariantPackage(pkg) {
+		return fmt.Errorf("ordinary dependency embed package changed its role")
+	}
+	if ordinaryDependencyActualRoot(consumer, pkg) != bound.ObservedRoot {
+		return fmt.Errorf("ordinary dependency actual module source root changed")
+	}
+	actual, err := captureOrdinaryPackageEmbedSelection(bound.Source.Package, bound.ObservedRoot, bound.Root, pkg)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(actual, bound.Source.Embed) {
+		return fmt.Errorf("ordinary dependency embed selection changed")
+	}
+	return nil
+}
+
+func (consumer *featureConsumer) finishOrdinaryDependencies(pkgs []*packages.Package) error {
+	owner := consumer.OrdinaryDependencies
+	if owner == nil || len(pkgs) == 0 {
+		return fmt.Errorf("ordinary dependency compiler load lacks a live source owner")
+	}
+	var captureErr error
+	packages.Visit(pkgs, func(pkg *packages.Package) bool {
+		if captureErr != nil {
+			return false
+		}
+		bound, found := owner.Packages[pkg.PkgPath]
+		if !found {
+			captureErr = fmt.Errorf("ordinary source closure changed during compiler loading")
+			return false
+		}
+		if bound.Source.Builtin == "" {
+			digest, err := gotoolprofile.FileSHA256(pkg.ExportFile)
+			if err != nil {
+				captureErr = err
+				return false
+			}
+			if err := consumer.retainGeneratedGuard(map[string]string{pkg.ExportFile: digest}); err != nil {
+				captureErr = err
+				return false
+			}
+			if bound.Source.SourceRootID != "" {
+				bound.Source.ExportSHA256 = digest
+			}
+			owner.Packages[pkg.PkgPath] = bound
+		}
+		return true
+	}, nil)
+	if captureErr != nil {
+		return captureErr
+	}
+	for index, source := range owner.Proof.ExternalPackages {
+		owner.Proof.ExternalPackages[index] = owner.Packages[source.Package.PackagePath].Source
+	}
+	if err := consumer.verifyOrdinaryOwner(owner); err != nil {
+		return err
+	}
+	owner.Compiled = true
+	return nil
+}
+
+func (consumer *featureConsumer) ordinaryDependencyProof() (*gotoolprofile.OrdinaryDependencyProof, error) {
+	if consumer == nil || consumer.Proof == nil || consumer.Input == nil || consumer.OrdinaryDependencies == nil ||
+		!consumer.OrdinaryDependencies.Compiled || consumer.OrdinaryDependencies.Proof == nil {
+		return nil, fmt.Errorf("ordinary compiler metadata lacks its completed live dependency source owner")
+	}
+	if err := consumer.verifyOrdinaryOwner(consumer.OrdinaryDependencies); err != nil {
+		return nil, err
+	}
+	return consumer.OrdinaryDependencies.Proof, nil
+}
diff --git a/cmd/plan9asmll/ordinary_environment.go b/cmd/plan9asmll/ordinary_environment.go
new file mode 100644
index 000000000..5fab853c7
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_environment.go
@@ -0,0 +1,15 @@
+package main
+
+import "github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+
+func ordinaryPackageEnvironment(goos, goarch string, input []string) ([]string, error) {
+	return sdkfrontend.OrdinaryEnvironment(goos, goarch, input)
+}
+
+func featurePackageEnvironment(goos, goarch string, input []string) ([]string, error) {
+	return sdkfrontend.FeatureEnvironment(goos, goarch, input)
+}
+
+func ordinaryGoEnvFile(requested, actual string) (string, error) {
+	return sdkfrontend.GoEnvFile(requested, actual)
+}
diff --git a/cmd/plan9asmll/ordinary_environment_test.go b/cmd/plan9asmll/ordinary_environment_test.go
new file mode 100644
index 000000000..d439825f8
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_environment_test.go
@@ -0,0 +1,201 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestOrdinaryPackageEnvironmentPreservesGoDefaultCGO(t *testing.T) {
+	for _, target := range [][2]string{{runtime.GOOS, runtime.GOARCH}, {"js", "wasm"}} {
+		t.Run(target[0]+"/"+target[1], func(t *testing.T) {
+			input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+				"GOOS="+target[0], "GOARCH="+target[1], "CGO_ENABLED=")
+			stdout, stderr, err := gotoolprofile.RunBounded(arm64PrivateCLIContext(t), "", input,
+				"go", "env", "CGO_ENABLED")
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual Go default CGO: %v; %s", err, stderr)
+			}
+			want := strings.TrimSpace(string(stdout))
+			if want != "0" && want != "1" {
+				t.Fatalf("invalid Go CGO setting %q", want)
+			}
+			env, err := ordinaryPackageEnvironment(target[0], target[1], input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, item := range env {
+				if key, value, _ := strings.Cut(item, "="); key == "CGO_ENABLED" {
+					if value != want {
+						t.Fatalf("package inventory changed: CGO_ENABLED=%s, actual Go default=%s", value, want)
+					}
+					return
+				}
+			}
+			t.Fatal("actual CGO setting was not captured")
+		})
+	}
+}
+
+func TestOrdinaryPackageEnvironmentRetainsExplicitSelection(t *testing.T) {
+	input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"CGO_ENABLED=1", "GOFLAGS=-tags=original", "GOAMD64=v3", "GOPACKAGESDRIVER=custom")
+	before := append([]string(nil), input...)
+	env, err := ordinaryPackageEnvironment("linux", "amd64", input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(before, input) {
+		t.Fatal("package-load setup mutated its caller's environment")
+	}
+	values := make(map[string]string)
+	for _, item := range env {
+		key, value, _ := strings.Cut(item, "=")
+		if _, duplicate := values[key]; duplicate {
+			t.Fatalf("duplicate effective environment key %s", key)
+		}
+		values[key] = value
+	}
+	for key, expected := range map[string]string{
+		"GOOS": "linux", "GOARCH": "amd64", "CGO_ENABLED": "1",
+		"GOFLAGS": "-tags=original", "GOAMD64": "v3", "GOPACKAGESDRIVER": "custom",
+	} {
+		if values[key] != expected {
+			t.Errorf("explicit %s changed: got %q, want %q", key, values[key], expected)
+		}
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(values[key]) {
+			t.Errorf("missing absolute effective %s", key)
+		}
+	}
+}
+
+func TestOrdinaryPackageEnvironmentCreatesSelectedCacheDirectories(t *testing.T) {
+	parent := t.TempDir()
+	input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local")
+	paths := make(map[string]string)
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE"} {
+		paths[key] = filepath.Join(parent, strings.ToLower(key), "fresh")
+		input = append(input, key+"="+paths[key])
+	}
+	env, err := ordinaryPackageEnvironment(runtime.GOOS, runtime.GOARCH, input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for key, path := range paths {
+		physical, err := sourcepath.Resolve(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		for _, entry := range env {
+			found = found || entry == key+"="+physical
+		}
+		if !found {
+			t.Fatalf("selected %s path changed", key)
+		}
+		if info, err := os.Stat(path); err != nil || !info.IsDir() {
+			t.Errorf("selected %s must exist before package/source capture: %v", key, err)
+		}
+	}
+}
+
+func TestOrdinaryPackageEnvironmentRejectsNonDirectoryCache(t *testing.T) {
+	file := filepath.Join(t.TempDir(), "not-a-directory")
+	if err := os.WriteFile(file, []byte("original"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOMODCACHE="+file)
+	if _, err := ordinaryPackageEnvironment(runtime.GOOS, runtime.GOARCH, input); err == nil {
+		t.Fatal("non-directory cache was accepted")
+	}
+	if data, err := os.ReadFile(file); err != nil || string(data) != "original" {
+		t.Fatal("cache setup replaced caller data", err)
+	}
+}
+
+func TestOrdinaryPackageEnvironmentPreservesWorkspaceAndSavedFlags(t *testing.T) {
+	dir := t.TempDir()
+	workspace := filepath.Join(dir, "go.work")
+	goenv := filepath.Join(dir, "goenv")
+	for name, source := range map[string]string{
+		"go.work": "go 1.20\nuse ./module\n",
+		"goenv":   "GOFLAGS=-tags=saved_profile\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.Mkdir(filepath.Join(dir, "module"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "module", "go.mod"),
+		[]byte("module example.invalid/selection\n\ngo 1.20\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(dir)
+	input := append(os.Environ(), "GOENV="+goenv, "GOWORK=", "GOFLAGS=", "GOTOOLCHAIN=local")
+	env, err := ordinaryPackageEnvironment(runtime.GOOS, runtime.GOARCH, input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values := make(map[string]string)
+	for _, item := range env {
+		key, value, _ := strings.Cut(item, "=")
+		values[key] = value
+	}
+	actualWorkspace, err := filepath.EvalSymlinks(values["GOWORK"])
+	wantWorkspace, wantErr := filepath.EvalSymlinks(workspace)
+	if err != nil || wantErr != nil || actualWorkspace != wantWorkspace {
+		t.Errorf("implicit workspace discarded: got %q; %v", values["GOWORK"], err)
+	}
+	physicalConfig, configErr := sourcepath.Resolve(goenv)
+	if values["GOFLAGS"] != "-tags=saved_profile" || configErr != nil || values["GOENV"] != physicalConfig {
+		t.Errorf("actual saved selection was not captured: GOENV=%q GOFLAGS=%q", values["GOENV"], values["GOFLAGS"])
+	}
+}
+
+func TestCallerSelectionRetainsActualLoadEnvironment(t *testing.T) {
+	pkg := &packages.Package{Name: "example", PkgPath: "example.invalid/p"}
+	env := []string{"GOOS=linux", "GOARCH=amd64", "GOFLAGS=", "GOPACKAGESDRIVER=off"}
+	want := append([]string(nil), env...)
+	t.Setenv("GOFLAGS", "-overlay=unrelated.json")
+	selected := captureX86CallerSelectionsInEnvironment([]*packages.Package{pkg}, "linux/amd64", env)[pkg]
+	env[0] = "GOOS=windows"
+	if !reflect.DeepEqual(selected.env, want) {
+		t.Fatal("selection reconstructed ambient defaults or borrowed a mutable environment")
+	}
+}
+
+func TestOrdinaryPackageEnvironmentRetainsDiscoveredDriver(t *testing.T) {
+	dir := t.TempDir()
+	name := "gopackagesdriver"
+	if runtime.GOOS == "windows" {
+		name += ".exe"
+	}
+	driver := filepath.Join(dir, name)
+	// Resolution must not execute this driver while resolving Go's environment.
+	if err := os.WriteFile(driver, []byte("not an executable program\n"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOPACKAGESDRIVER=")
+	env, err := ordinaryPackageEnvironment(runtime.GOOS, runtime.GOARCH, input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, item := range env {
+		if item == "GOPACKAGESDRIVER="+driver {
+			return
+		}
+	}
+	t.Fatal("automatic package driver was disabled or not captured")
+}
diff --git a/cmd/plan9asmll/ordinary_global_declarations_go127_test.go b/cmd/plan9asmll/ordinary_global_declarations_go127_test.go
new file mode 100644
index 000000000..6d17c8e81
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_global_declarations_go127_test.go
@@ -0,0 +1,207 @@
+//go:build go1.27
+
+package main
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// This is the complete actual current SDK file, not a hasADX instruction
+// prototype. Its ordinary declaration route must precede an expensive SDK
+// reload/capture: one attempt suffices without changing any native ABI rules.
+func TestCompileOneOrdinaryGlobalDeclarationsSDKMathBigWholeFile(t *testing.T) {
+	setX86SDKNumericalCLIProfile(t, "explicit")
+	t.Setenv("GOROOT", runtime.GOROOT())
+	directory := filepath.Join(runtime.GOROOT(), "src", "math", "big")
+	t.Chdir(directory)
+	ctx := arm64PrivateCLIContext(t)
+	selected, environment, err := loadPkgsInEnvironment("linux", "amd64", []string{"."}, nil, "", true, false, nil)
+	if err != nil || len(selected) != 1 || selected[0].PkgPath != "math/big" {
+		t.Fatalf("actual selected SDK math/big load failed: %v %+v", err, selected)
+	}
+	pkg := selected[0]
+	variable, ok := pkg.Types.Scope().Lookup("hasADX").(*types.Var)
+	if !ok || variable.Pkg() != pkg.Types || variable.IsField() ||
+		!types.Identical(variable.Type(), types.Typ[types.Bool]) || pkg.TypesSizes.Sizeof(variable.Type()) != 1 {
+		t.Fatal("the selected SDK lacks its real same-package mutable byte feature flag")
+	}
+	input := ""
+	for _, name := range pkg.OtherFiles {
+		if filepath.Base(name) == "arith_amd64.s" {
+			if input != "" {
+				t.Fatal("duplicate selected SDK arithmetic file")
+			}
+			input = name
+		}
+	}
+	if input == "" || filepath.Dir(input) != pkg.Dir {
+		t.Fatal("complete selected SDK arithmetic file is absent")
+	}
+	original, err := os.ReadFile(input)
+	if err != nil || !strings.Contains(string(original), "CMPB") || !strings.Contains(string(original), "hasADX") {
+		t.Fatal("original SDK counterexample is absent", err)
+	}
+	source, reads, err := plan9asm.ReadGoAssemblySourceWithReport(input, pkg.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	parsed, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(source), plan9asm.GoAssemblerDefines("linux", "amd64"))
+	if err != nil {
+		t.Fatal("the complete original SDK source did not parse", err)
+	}
+	wanted := map[string]bool{"·addVV": true, "·subVV": true, "·lshVU": true, "·rshVU": true, "·mulAddVWW": true, "·addMulVVWW": true}
+	if len(parsed.Funcs) != len(wanted) {
+		t.Fatal("the original six-function SDK source inventory changed", len(parsed.Funcs))
+	}
+	seen := make(map[string]bool)
+	for _, function := range parsed.Funcs {
+		if !wanted[function.Sym] || seen[function.Sym] {
+			t.Fatal("unexpected or repeated original SDK TEXT", function.Sym)
+		}
+		seen[function.Sym] = true
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelectionsInEnvironment(selected, "linux/amd64", environment)
+	output := filepath.Join(t.TempDir(), "arith.ll")
+	if err := compileOneAttempt(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal("ordinary complete SDK declarations fell through to SDK capture/retranslation", err)
+	}
+	ir, err := os.ReadFile(output)
+	if err != nil || !strings.Contains(string(ir), `load volatile i8, ptr @"math/big.hasADX"`) ||
+		!strings.Contains(string(ir), `@"math/big.hasADX" = external global `) {
+		t.Fatal("the real mutable flag lost its exact volatile external byte read", err)
+	}
+	for symbol := range wanted {
+		found := false
+		for _, line := range strings.Split(string(ir), "\n") {
+			found = found || strings.HasPrefix(line, "define ") && strings.Contains(line, `@"math/big.`+strings.TrimPrefix(symbol, "·")+`"(`)
+		}
+		if !found {
+			t.Fatal("an original SDK function was omitted from its LLVM object", symbol)
+		}
+	}
+	if info, err := os.Lstat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatal("the complete original SDK LLVM22 object is missing", err)
+	}
+	for name, expected := range reads.Inputs {
+		actual, err := os.ReadFile(name)
+		if err != nil || expected != featureBytesSHA256(actual) {
+			t.Fatal("original SDK source/header bytes changed", name, err)
+		}
+	}
+	if after, err := os.ReadFile(input); err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("the original SDK arithmetic source changed", err)
+	}
+}
+
+// A complete GoModule consumes private tail TEXTs as source graph nodes, not
+// callable/public metadata entries. All four real files formerly passed the
+// raw CLI path; declaration forwarding must preserve their actual objects.
+func TestCompileOneOrdinaryGlobalDeclarationsSDKPrivateTailWholeFiles(t *testing.T) {
+	setX86SDKNumericalCLIProfile(t, "explicit")
+	t.Setenv("GOROOT", runtime.GOROOT())
+	t.Chdir(filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg"))
+	ctx := arm64PrivateCLIContext(t)
+	selected, environment, err := loadPkgsInEnvironment("linux", "amd64", []string{"."}, nil, "", true, false, nil)
+	if err != nil || len(selected) != 1 || selected[0].PkgPath != "internal/bytealg" {
+		t.Fatalf("actual selected SDK bytealg load failed: %v %+v", err, selected)
+	}
+	pkg := selected[0]
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelectionsInEnvironment(selected, "linux/amd64", environment)
+	for _, test := range []struct {
+		file, helper string
+		public       []string
+	}{
+		{"compare_amd64.s", "cmpbody<>", []string{"internal/bytealg.Compare", "runtime.cmpstring"}},
+		{"count_amd64.s", "countbody<>", []string{"internal/bytealg.Count", "internal/bytealg.CountString"}},
+		{"index_amd64.s", "indexbody<>", []string{"internal/bytealg.Index", "internal/bytealg.IndexString"}},
+		{"indexbyte_amd64.s", "indexbytebody<>", []string{"internal/bytealg.IndexByte", "internal/bytealg.IndexByteString"}},
+	} {
+		t.Run(test.file, func(t *testing.T) {
+			input := ""
+			for _, name := range pkg.OtherFiles {
+				if filepath.Base(name) == test.file {
+					if input != "" {
+						t.Fatal("duplicate original SDK assembly member")
+					}
+					input = name
+				}
+			}
+			if input == "" {
+				t.Fatal("selected SDK assembly file missing")
+			}
+			source, reads, err := plan9asm.ReadGoAssemblySourceWithReport(input, pkg.Dir)
+			if err != nil || !strings.Contains(string(source), "TEXT "+test.helper) &&
+				!strings.Contains(string(source), "TEXT\t"+test.helper) {
+				t.Fatal("original complete source lost its private tail TEXT", err)
+			}
+			output := filepath.Join(t.TempDir(), "complete.ll")
+			if err := compileOneAttempt(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatal("complete original source rejected its authenticated private tail", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || len(ir) == 0 {
+				t.Fatal("complete source LLVM IR is absent", err)
+			}
+			objectName := strings.TrimSuffix(output, ".ll") + ".o"
+			if info, err := os.Lstat(objectName); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatal("complete source LLVM22 object is absent", err)
+			}
+			object, err := elf.Open(objectName)
+			if err != nil {
+				t.Fatal("actual Linux/amd64 object is not ELF", err)
+			}
+			symbols, symbolErr := object.Symbols()
+			closeErr := object.Close()
+			if symbolErr != nil || closeErr != nil {
+				t.Fatalf("read actual ELF symbols: %v (close: %v)", symbolErr, closeErr)
+			}
+			// Generated local LLVM helpers are not public source entries. Use
+			// the actual backend's defined GLOBAL/FUNC binding, not IR spelling.
+			public := make(map[string]bool)
+			for _, symbol := range symbols {
+				if symbol.Section == elf.SHN_UNDEF || elf.ST_BIND(symbol.Info) != elf.STB_GLOBAL || elf.ST_TYPE(symbol.Info) != elf.STT_FUNC {
+					continue
+				}
+				if public[symbol.Name] {
+					t.Fatal("duplicate defined public ELF function", symbol.Name)
+				}
+				public[symbol.Name] = true
+			}
+			if len(public) != len(test.public) {
+				t.Fatal("the original public ELF function inventory changed", public)
+			}
+			for _, name := range test.public {
+				if !public[name] {
+					t.Fatal("original public entry has no defined global ELF function", name)
+				}
+			}
+			for name, digest := range reads.Inputs {
+				data, err := os.ReadFile(name)
+				if err != nil || featureBytesSHA256(data) != digest {
+					t.Fatal("original SDK source/header changed", name, err)
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_global_declarations_test.go b/cmd/plan9asmll/ordinary_global_declarations_test.go
new file mode 100644
index 000000000..101474e6f
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_global_declarations_test.go
@@ -0,0 +1,373 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+const ordinaryGlobalDependency = "example.com/declsource/state"
+
+type ordinaryGlobalCLIFixture struct {
+	pkg, dependency *packages.Package
+	task            asmTask
+	config          compileConfig
+	sources         map[string][]byte
+}
+
+func ordinaryGlobalCLIProfile(t *testing.T) {
+	t.Helper()
+	for key, value := range map[string]string{
+		"GOROOT": runtime.GOROOT(), "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOPACKAGESDRIVER": "off", "GOPROXY": "off",
+		"CGO_ENABLED": "0", "GOAMD64": "v1", "GO386": "sse2", "GOARM": "", "GOARM64": "", "GOWASM": "",
+	} {
+		t.Setenv(key, value)
+	}
+}
+
+// The actual loader keeps declarations type-only. The complete local and
+// direct-import syntax must be acquired only for this assembly candidate,
+// without changing the stored package graph or starting another Go selection.
+func ordinaryGlobalCLIActualFixture(t *testing.T, arch string) ordinaryGlobalCLIFixture {
+	t.Helper()
+	return ordinaryGlobalCLIActualFixtureProfile(t, arch, "v1")
+}
+
+func ordinaryGlobalCLIActualFixtureProfile(t *testing.T, arch, profile string) ordinaryGlobalCLIFixture {
+	t.Helper()
+	ordinaryGlobalCLIProfile(t)
+	t.Setenv("GOAMD64", profile)
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	symbol := strings.NewReplacer("/", "∕", ".", "·").Replace(ordinaryGlobalDependency)
+	var assembly strings.Builder
+	for _, row := range []struct{ name, instruction string }{
+		{"Local", "CMPB ·Flags(SB),$1"},
+		{"ImportedByte", "CMPB " + symbol + "·Flags(SB),$1"},
+		{"ImportedWord", "CMPL " + symbol + "·Word(SB),$0x12345678"},
+	} {
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-4\n%s\nJNE different\nMOVL $1,ret+0(FP)\nRET\ndifferent:\nMOVL $0,ret+0(FP)\nRET\n", row.name, row.instruction)
+	}
+	inputs := map[string]string{
+		"go.mod":                        "module example.com/declsource\n\ngo 1.24\n",
+		"state/state.go":                "package state\ntype Byte uint8\nvar Flags Byte = 1\n",
+		"state/word_linux.go":           "//go:build linux\n\npackage state\nvar Word uint32 = 0x12345678\n",
+		"state/word_other.go":           "//go:build !linux\n\npackage state\nvar Word uint64\n",
+		"consumer/consumer.go":          "package consumer\nimport state \"" + ordinaryGlobalDependency + "\"\nvar _ = state.Flags\nvar _ = state.Word\nvar Flags uint8 = 1\nfunc Local() uint32\nfunc ImportedByte() uint32\nfunc ImportedWord() uint32\n",
+		"consumer/profile_v2.go":        "//go:build amd64.v2\n\npackage consumer\nconst SelectedCPUProfile = 2\n",
+		"consumer/profile_baseline.go":  "//go:build !amd64.v2\n\npackage consumer\nconst SelectedCPUProfile = 1\n",
+		"consumer/reads_" + arch + ".s": assembly.String(),
+	}
+	sources := make(map[string][]byte, len(inputs))
+	for name, source := range inputs {
+		file := filepath.Join(directory, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		sources[file] = []byte(source)
+	}
+	t.Chdir(filepath.Join(directory, "consumer"))
+	ctx := arm64PrivateCLIContext(t)
+	selected, environment, err := loadPkgsInEnvironment("linux", arch, []string{"."}, nil, "", true, false, nil)
+	if err != nil || len(selected) != 1 || selected[0].PkgPath != "example.com/declsource/consumer" {
+		t.Fatalf("actual ordinary package load failed: %v %+v", err, selected)
+	}
+	pkg := selected[0]
+	dependency := pkg.Imports[ordinaryGlobalDependency]
+	if pkg.Types == nil || pkg.TypesSizes == nil || dependency == nil || dependency.Types == nil ||
+		len(dependency.CompiledGoFiles) != 2 || len(pkg.Syntax) != 0 || len(dependency.Syntax) != 0 {
+		t.Fatal("fixture lost its real typed, syntax-free package selection")
+	}
+	word, ok := dependency.Types.Scope().Lookup("Word").(*types.Var)
+	if !ok || !types.Identical(word.Type(), types.Typ[types.Uint32]) || pkg.TypesSizes.Sizeof(word.Type()) != 4 {
+		t.Fatal("actual selected Linux declaration is not the original uint32")
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelectionsInEnvironment(selected, "linux/"+arch, environment)
+	return ordinaryGlobalCLIFixture{pkg, dependency,
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: filepath.Join(pkg.Dir, "reads_"+arch+".s"), OutLL: filepath.Join(t.TempDir(), "reads.ll")},
+		config, sources}
+}
+
+func ordinaryGlobalRequireIR(t *testing.T, source, path string) {
+	t.Helper()
+	for _, name := range []string{path + ".Flags", ordinaryGlobalDependency + ".Flags", ordinaryGlobalDependency + ".Word"} {
+		if !strings.Contains(source, `@"`+name+`" = external global `) {
+			t.Fatal("mutable Go global lost its original external namespace", name)
+		}
+	}
+	for _, name := range []string{"Local", "ImportedByte", "ImportedWord"} {
+		if !strings.Contains(source, `define i32 @"`+path+"."+name+`"(`) {
+			t.Fatal("complete original source entry was cropped", name)
+		}
+	}
+	if strings.Count(source, "load volatile i8") != 2 || strings.Count(source, "load volatile i32") != 1 {
+		t.Fatal("ordinary declaration reads lost their complete exact-width effects")
+	}
+}
+
+func TestCompileOneOrdinaryGlobalDeclarationsCompleteSource(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			fixture := ordinaryGlobalCLIActualFixture(t, arch)
+			originalType, importedType := fixture.pkg.Types, fixture.dependency.Types
+			// Retained object compilation must keep the complete source.
+			fixture.config.MaxFunctions, fixture.config.MaxInstructions = 1, 1
+			if err := compileOne(fixture.pkg, plan9asm.ArchAMD64, "linux", arch, targetTriple("linux", arch),
+				fixture.task, false, fixture.config); err != nil {
+				t.Fatal("complete ordinary same-package/imported declaration source failed", err)
+			}
+			ir, err := os.ReadFile(fixture.task.OutLL)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ordinaryGlobalRequireIR(t, string(ir), fixture.pkg.PkgPath)
+			object := strings.TrimSuffix(fixture.task.OutLL, ".ll") + ".o"
+			if info, err := os.Lstat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatal("actual complete-source LLVM22 object is missing", err)
+			}
+			parts, err := filepath.Glob(strings.TrimSuffix(fixture.task.OutLL, ".ll") + ".part-*")
+			if err != nil || len(parts) != 0 {
+				t.Fatal("ordinary complete declaration source was split before binding", parts, err)
+			}
+			if fixture.pkg.Types != originalType || fixture.dependency.Types != importedType ||
+				len(fixture.pkg.Syntax) != 0 || len(fixture.dependency.Syntax) != 0 {
+				t.Fatal("one candidate changed the actual light-load types or retained source ASTs")
+			}
+			// The validation-only path would normally split at these limits.
+			// It must independently bind and emit the same complete GoModule.
+			fixture.config.KeepObj = false
+			fixture.task.OutLL = filepath.Join(filepath.Dir(fixture.task.OutLL), "validation-only.ll")
+			if err := compileOne(fixture.pkg, plan9asm.ArchAMD64, "linux", arch, targetTriple("linux", arch),
+				fixture.task, false, fixture.config); err != nil {
+				t.Fatal("ordinary declarations were split on the validation-only path", err)
+			}
+			ir, err = os.ReadFile(fixture.task.OutLL)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ordinaryGlobalRequireIR(t, string(ir), fixture.pkg.PkgPath)
+			parts, err = filepath.Glob(strings.TrimSuffix(fixture.task.OutLL, ".ll") + ".part-*")
+			if err != nil || len(parts) != 0 {
+				t.Fatal("validation-only ordinary declarations emitted cropped source chunks", parts, err)
+			}
+			for name, expected := range fixture.sources {
+				actual, err := os.ReadFile(name)
+				if err != nil || !bytes.Equal(actual, expected) {
+					t.Fatal("translation changed an original selected source", name, err)
+				}
+			}
+		})
+	}
+}
+
+func TestCompileOneOrdinaryGlobalDeclarationsSelectionGuards(t *testing.T) {
+	for _, mutation := range []string{"missing-source", "wrong-platform-source", "missing-import-types", "output-is-imported-source"} {
+		t.Run(mutation, func(t *testing.T) {
+			fixture := ordinaryGlobalCLIActualFixture(t, "amd64")
+			fixture.config.Enabled = false
+			const retained = "previous verified output\n"
+			if mutation == "output-is-imported-source" {
+				fixture.task.OutLL = filepath.Join(fixture.dependency.Dir, "state.go")
+			} else if err := os.WriteFile(fixture.task.OutLL, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			before, err := os.ReadFile(fixture.task.OutLL)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "missing-source":
+				if err := os.Rename(filepath.Join(fixture.dependency.Dir, "state.go"), filepath.Join(t.TempDir(), "retained-original.go")); err != nil {
+					t.Fatal(err)
+				}
+			case "wrong-platform-source":
+				changed := 0
+				for index, name := range fixture.dependency.CompiledGoFiles {
+					if filepath.Base(name) == "word_linux.go" {
+						fixture.dependency.CompiledGoFiles[index] = filepath.Join(fixture.dependency.Dir, "word_other.go")
+						changed++
+					}
+				}
+				if changed != 1 {
+					t.Fatal("platform source mutation did not apply exactly once")
+				}
+			case "missing-import-types":
+				fixture.dependency.Types = nil
+			}
+			if err := compileOne(fixture.pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				fixture.task, false, fixture.config); err == nil {
+				t.Fatal("missing or mismatched selected declarations acquired read authority")
+			}
+			after, err := os.ReadFile(fixture.task.OutLL)
+			if err != nil || !bytes.Equal(before, after) {
+				t.Fatal("rejected declaration source changed a retained output/input", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneOrdinaryGlobalDeclarationsLateGuard(t *testing.T) {
+	for _, mutation := range []string{"same-size-bytes", "equal-byte-node", "same-package-bytes"} {
+		t.Run(mutation, func(t *testing.T) {
+			fixture := ordinaryGlobalCLIActualFixture(t, "amd64")
+			fixture.config.Enabled = false
+			const retained = "previous verified output\n"
+			if err := os.WriteFile(fixture.task.OutLL, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			called := false
+			fixture.config.Context = &continuationOutputCallbackContext{Context: fixture.config.Context,
+				directory: filepath.Dir(fixture.task.OutLL), basename: filepath.Base(fixture.task.OutLL), callback: func() {
+					called = true
+					file := filepath.Join(fixture.dependency.Dir, "state.go")
+					if mutation == "same-package-bytes" {
+						file = filepath.Join(fixture.pkg.Dir, "consumer.go")
+					}
+					original := fixture.sources[file]
+					if mutation == "equal-byte-node" {
+						if err := os.Rename(file, filepath.Join(t.TempDir(), "retained-original.go")); err != nil {
+							t.Fatal(err)
+						}
+					} else {
+						changed := bytes.Replace(original, []byte("= 1"), []byte("= 2"), 1)
+						if bytes.Equal(changed, original) || len(changed) != len(original) {
+							t.Fatal("same-size source mutation did not apply")
+						}
+						original = changed
+					}
+					if err := os.WriteFile(file, original, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}}
+			err := compileOne(fixture.pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				fixture.task, false, fixture.config)
+			if !called || err == nil {
+				t.Fatalf("late actual imported-source guard was not reached: called=%t error=%v", called, err)
+			}
+			if after, err := os.ReadFile(fixture.task.OutLL); err != nil || string(after) != retained {
+				t.Fatal("late source failure published unverified IR", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneOrdinaryGlobalDeclarationsPrivateTailSourceAudit(t *testing.T) {
+	for _, mutation := range []string{"complete", "unknown-helper-input", "unreferenced-helper-escape"} {
+		t.Run(mutation, func(t *testing.T) {
+			fixture := ordinaryGlobalCLIActualFixture(t, "amd64")
+			fixture.config.Enabled = false
+			original := string(fixture.sources[fixture.task.AsmFile])
+			body := "CMPB ·Flags(SB),$1\nJNE different\nMOVL $1,ret+0(FP)\nRET\ndifferent:\nMOVL $0,ret+0(FP)\nRET\n"
+			if strings.Count(original, body) != 1 {
+				t.Fatal("local root body must be replaced exactly once")
+			}
+			helper := "TEXT value<>(SB),4,$0-0\nJNE different\nMOVL $1,ret+0(FP)\nRET\ndifferent:\nMOVL $0,ret+0(FP)\nRET\n"
+			source := strings.Replace(original, body, "CMPB ·Flags(SB),$1\nJMP value<>(SB)\n", 1) + helper
+			if mutation == "unknown-helper-input" {
+				source = strings.TrimSuffix(source, helper) + strings.Replace(helper, "MOVL $1,ret+0(FP)", "MOVL R15,ret+0(FP)", 1)
+			} else if mutation == "unreferenced-helper-escape" {
+				source += "TEXT unused<>(SB),4,$0-0\nCALL foreign(SB)\nRET\n"
+			}
+			if err := os.WriteFile(fixture.task.AsmFile, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			const retained = "previous verified output\n"
+			if err := os.WriteFile(fixture.task.OutLL, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			err := compileOneAttempt(fixture.pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				fixture.task, false, fixture.config)
+			output, readErr := os.ReadFile(fixture.task.OutLL)
+			if readErr != nil {
+				t.Fatal(readErr)
+			}
+			if mutation == "complete" {
+				if err != nil {
+					t.Fatal("complete private tail source was not consumed", err)
+				}
+				ordinaryGlobalRequireIR(t, string(output), fixture.pkg.PkgPath)
+			} else if err == nil || string(output) != retained {
+				t.Fatal("invalid private helper was dropped or published", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneOrdinaryGlobalDeclarationsLoadEnvironmentIdentity(t *testing.T) {
+	for _, axis := range []string{"actual-v2", "GOAMD64=v2", "GOFLAGS=-tags=unselected", "GOROOT=unselected", "late-CPU-change"} {
+		t.Run(axis, func(t *testing.T) {
+			profile := "v1"
+			if axis == "actual-v2" {
+				profile = "v2"
+			}
+			fixture := ordinaryGlobalCLIActualFixtureProfile(t, "amd64", profile)
+			selectedProfile, ok := fixture.pkg.Types.Scope().Lookup("SelectedCPUProfile").(*types.Const)
+			if !ok || selectedProfile.Val().ExactString() != strings.TrimPrefix(profile, "v") {
+				t.Fatal("actual selected feature-tagged source does not match the load profile", selectedProfile)
+			}
+			fixture.config.Enabled = false
+			selected := *fixture.config.x86CallerSelections[fixture.pkg]
+			selected.env = append([]string(nil), selected.env...)
+			fixture.config.x86CallerSelections = map[*packages.Package]*x86CallerPackageSelection{fixture.pkg: &selected}
+			const retained = "previous verified output\n"
+			if err := os.WriteFile(fixture.task.OutLL, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			called := false
+			if axis == "late-CPU-change" {
+				fixture.config.Context = &continuationOutputCallbackContext{Context: fixture.config.Context,
+					directory: filepath.Dir(fixture.task.OutLL), basename: filepath.Base(fixture.task.OutLL), callback: func() {
+						called = true
+						selected.env = append(selected.env, "GOAMD64=v2")
+					}}
+			} else if axis != "actual-v2" {
+				selected.env = append(selected.env, axis)
+			}
+			err := compileOne(fixture.pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				fixture.task, false, fixture.config)
+			if axis == "actual-v2" {
+				if err != nil {
+					t.Fatal("actual nonbaseline load was mislabeled as an invalid mutation", err)
+				}
+				output, readErr := os.ReadFile(fixture.task.OutLL)
+				if readErr != nil {
+					t.Fatal(readErr)
+				}
+				ordinaryGlobalRequireIR(t, string(output), fixture.pkg.PkgPath)
+				return
+			}
+			if axis == "late-CPU-change" && !called {
+				t.Fatal("late actual load-environment mutation was not reached", err)
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("changed environment borrowed the original package selection", err)
+			}
+			if _, retryable := x86SDKNumericalRetryCause(err); retryable {
+				t.Fatal("changed load environment became a retryable source exclusion", err)
+			}
+			if after, readErr := os.ReadFile(fixture.task.OutLL); readErr != nil || string(after) != retained {
+				t.Fatal("changed load environment published output", readErr)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_goenv_linux_test.go b/cmd/plan9asmll/ordinary_goenv_linux_test.go
new file mode 100644
index 000000000..f61f22e6a
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_goenv_linux_test.go
@@ -0,0 +1,26 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// Exercise the real compiler's implicit configuration location without changing
+// a user's HOME or configuration. Linux cmd/go uses XDG_CONFIG_HOME here.
+func TestRunOneTargetFixedLocalMissingImplicitGoEnv(t *testing.T) {
+	pkg, _, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+	configuration := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", configuration)
+	t.Setenv("GOENV", "")
+	t.Chdir(pkg.Dir)
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"},
+		[]string{"."}, nil, nil, pkg.Module.Path, t.TempDir(), false, 0, false,
+		false, true, "", config)
+	if err != nil || report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 {
+		t.Fatalf("implicit absent compiler configuration prevented actual fixed-local compilation: %v; %+v", err, report)
+	}
+	if _, err := os.Stat(filepath.Join(configuration, "go", "env")); !os.IsNotExist(err) {
+		t.Fatalf("compiler profile preparation wrote a default configuration: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_load_directory_other_test.go b/cmd/plan9asmll/ordinary_load_directory_other_test.go
new file mode 100644
index 000000000..ae3713704
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_load_directory_other_test.go
@@ -0,0 +1,15 @@
+//go:build !windows
+
+package main
+
+import (
+	"os"
+	"testing"
+)
+
+func ordinaryLoadDirectoryAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	if err := os.Symlink(actual, alias); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_load_directory_test.go b/cmd/plan9asmll/ordinary_load_directory_test.go
new file mode 100644
index 000000000..71314c6ca
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_load_directory_test.go
@@ -0,0 +1,153 @@
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestOrdinaryPackageLoadSDKWorkingDirectoryIdentity(t *testing.T) {
+	actualRoot, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "original-sdk")
+	ordinaryLoadDirectoryAlias(t, alias, actualRoot)
+	for _, profile := range []string{"effective-defaults", "saved-config"} {
+		t.Run(profile, func(t *testing.T) {
+			for key, value := range map[string]string{
+				"GOROOT": alias, "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+				"GOOS": "linux", "GOARCH": "amd64", "GOFLAGS": "", "GOPACKAGESDRIVER": "off",
+			} {
+				t.Setenv(key, value)
+			}
+			for _, key := range []string{"CGO_ENABLED", "GOAMD64", "GO386"} {
+				t.Setenv(key, "")
+				if err := os.Unsetenv(key); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if profile == "saved-config" {
+				config := filepath.Join(t.TempDir(), "original-goenv")
+				if err := os.WriteFile(config, []byte("GOPROXY=https://original-config.invalid,direct\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Setenv("GOENV", config)
+			}
+			directory := filepath.Join(alias, "src", "hash", "crc32")
+			if runtime.GOOS == "windows" {
+				directory = filepath.ToSlash(strings.ToLower(filepath.VolumeName(directory)) + strings.TrimPrefix(directory, filepath.VolumeName(directory)))
+			}
+			t.Chdir(directory)
+			t.Setenv("PWD", directory)
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			keys := []string{"CGO_ENABLED", "GOAMD64", "GO386", "GOENV", "GOPROXY", "GOFLAGS"}
+			before, diagnostics, err := gotoolprofile.RunBounded(ctx, directory, os.Environ(), "go", append([]string{"env", "-json"}, keys...)...)
+			if err != nil || len(diagnostics) != 0 {
+				t.Fatalf("original compiler defaults: %v; %s", err, diagnostics)
+			}
+			original, err := packages.Load(&packages.Config{Context: ctx, Dir: directory, Env: os.Environ(),
+				Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedDeps | packages.NeedTypes | packages.NeedTypesSizes}, ".")
+			if err != nil || len(original) != 1 || len(original[0].Errors) != 0 || original[0].PkgPath != "hash/crc32" {
+				t.Fatalf("unmodified original SDK internal-import selection failed: %v %+v", err, original)
+			}
+			selected, environment, err := loadPkgsInEnvironment("linux", "amd64", []string{"."}, nil, "", true, false, nil)
+			if err != nil || len(selected) != 1 || selected[0].PkgPath != original[0].PkgPath || selected[0].Types == nil || selected[0].TypesSizes == nil {
+				t.Fatalf("physical SDK environment lost its original cwd/package/type role: %v %+v", err, selected)
+			}
+			if len(selected[0].GoFiles) != len(original[0].GoFiles) || len(selected[0].CompiledGoFiles) != len(original[0].CompiledGoFiles) || len(selected[0].Imports) != len(original[0].Imports) {
+				t.Fatal("canonical directory changed the complete original compiler source/import inventory")
+			}
+			for index, inventory := range [][]string{original[0].GoFiles, original[0].CompiledGoFiles} {
+				actual := selected[0].GoFiles
+				if index == 1 {
+					actual = selected[0].CompiledGoFiles
+				}
+				if !reflect.DeepEqual(ordinaryLoadSourceIdentity(t, inventory), ordinaryLoadSourceIdentity(t, actual)) {
+					t.Fatal("canonical load changed complete original source identities/bytes")
+				}
+			}
+			for path, imported := range original[0].Imports {
+				actual := selected[0].Imports[path]
+				if imported.Types == nil || actual == nil || actual.Types == nil || actual.PkgPath != imported.PkgPath || actual.Types.Path() != imported.Types.Path() {
+					t.Fatalf("canonical load changed original compiler import/type identity: %s", path)
+				}
+			}
+			for _, name := range append(append([]string(nil), selected[0].GoFiles...), selected[0].CompiledGoFiles...) {
+				physical, err := sourcepath.Resolve(name)
+				if err != nil || physical != name {
+					t.Errorf("selected original SDK source kept an unbound alias: selected=%q physical=%q error=%v", name, physical, err)
+				}
+			}
+			after, diagnostics, err := gotoolprofile.RunBounded(ctx, "", environment, "go", append([]string{"env", "-json"}, keys...)...)
+			var oldProfile, newProfile map[string]string
+			if err != nil || len(diagnostics) != 0 || json.Unmarshal(before, &oldProfile) != nil || json.Unmarshal(after, &newProfile) != nil {
+				t.Fatalf("actual canonical compiler defaults: %v; %s", err, diagnostics)
+			}
+			for _, key := range keys {
+				if key == "GOENV" && oldProfile[key] != "" && oldProfile[key] != "off" {
+					oldProfile[key], err = sourcepath.Resolve(oldProfile[key])
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+				if oldProfile[key] != newProfile[key] {
+					t.Errorf("working-directory identity changed original default/config %s: %q != %q", key, oldProfile[key], newProfile[key])
+				}
+			}
+		})
+	}
+}
+
+func ordinaryLoadSourceIdentity(t *testing.T, names []string) map[string][32]byte {
+	t.Helper()
+	result := make(map[string][32]byte, len(names))
+	for _, name := range names {
+		physical, err := sourcepath.Resolve(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		data, err := os.ReadFile(physical)
+		if err != nil {
+			t.Fatal(err)
+		}
+		result[physical] = sha256.Sum256(data)
+	}
+	return result
+}
+
+func TestOrdinaryPackageLoadOutsideSDKRetainsInternalImportRejection(t *testing.T) {
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":  "module example.invalid/outside-sdk\n\ngo 1.24\n",
+		"main.go": "package outside\nimport _ \"internal/byteorder\"\n",
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOPACKAGESDRIVER", "off")
+	t.Chdir(directory)
+	original, err := packages.Load(&packages.Config{Dir: directory, Env: os.Environ(),
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedImports | packages.NeedDeps | packages.NeedTypes | packages.NeedTypesSizes}, ".")
+	if err != nil || len(original) != 1 || len(original[0].Errors) == 0 || !strings.Contains(original[0].Errors[0].Msg, "use of internal package internal/byteorder not allowed") {
+		t.Fatalf("stock compiler internal-package negative is absent: %v %+v", err, original)
+	}
+	if pkgs, _, err := loadPkgsInEnvironment(runtime.GOOS, runtime.GOARCH, []string{"."}, nil, "", true, false, nil); err == nil || len(pkgs) != 0 || !strings.Contains(err.Error(), "package loading error") {
+		t.Fatalf("physical working directory bypassed stock internal-package rejection: %v %+v", err, pkgs)
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_load_directory_windows_test.go b/cmd/plan9asmll/ordinary_load_directory_windows_test.go
new file mode 100644
index 000000000..788064ebb
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_load_directory_windows_test.go
@@ -0,0 +1,21 @@
+//go:build windows
+
+package main
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func ordinaryLoadDirectoryAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, "", nil, "cmd", "/c", "mklink", "/J", alias, actual)
+	if err != nil {
+		t.Fatalf("create actual Windows SDK junction: %v; %s; %s", err, stdout, stderr)
+	}
+}
diff --git a/cmd/plan9asmll/ordinary_test_named_assembly_test.go b/cmd/plan9asmll/ordinary_test_named_assembly_test.go
new file mode 100644
index 000000000..fa925aa74
--- /dev/null
+++ b/cmd/plan9asmll/ordinary_test_named_assembly_test.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestOrdinaryProfileUsesActualGoRoleForTestNamedAssembly(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		parts := strings.Split(target, "/")
+		for _, name := range []string{"probe_test.s", "probe_test_" + parts[1] + ".s"} {
+			t.Run(target+"/"+name, func(t *testing.T) {
+				input, dir := ordinaryTestNamedFixture(t, target, name, true)
+				t.Chdir(dir)
+				ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+				defer cancel()
+				env := featureEnvironment(os.Environ(), input.Observed.Environment)
+				listed, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", "list", "-export", "-json", ".")
+				if err != nil {
+					t.Fatalf("actual ordinary Go export: %v\n%s", err, stderr)
+				}
+				var actual struct {
+					SFiles      []string
+					TestGoFiles []string
+					Export      string
+				}
+				if err := json.Unmarshal(listed, &actual); err != nil {
+					t.Fatal(err)
+				}
+				if len(actual.SFiles) != 1 || actual.SFiles[0] != name || actual.Export == "" || len(actual.TestGoFiles) != 1 {
+					t.Fatalf("actual Go did not export the exact ordinary/test source roles: %s", listed)
+				}
+
+				metadataPath := filepath.Join(t.TempDir(), "metadata.json")
+				args := []string{
+					"-metadata-only", "-goos=" + parts[0], "-goarch=" + parts[1],
+					"-patterns=.", "-module-path=" + input.Module, "-asm-files=" + name,
+					"-feature-profile=" + writeFeatureInput(t, input),
+					"-out=" + t.TempDir(), "-report=" + metadataPath,
+				}
+				encoded, err := json.Marshal(args)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, stderr, err = gotoolprofile.RunBounded(ctx, dir, append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(encoded)), os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+				if err != nil {
+					t.Fatalf("ordinary Go-selected .s name was incorrectly rejected by metadata CLI: %v\n%s", err, stderr)
+				}
+				data, err := os.ReadFile(metadataPath)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var metadata gotoolprofile.MetadataProof
+				if err := json.Unmarshal(data, &metadata); err != nil {
+					t.Fatal(err)
+				}
+				if err := gotoolprofile.ValidateMetadata(input, &metadata, nil); err != nil {
+					t.Fatal(err)
+				}
+				input.GeneratedHeaders = &metadata
+				config, err := resolveCompileConfig(true, "", true, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+				report, _, err := runOneTarget(
+					targetSpec{Goos: parts[0], Goarch: parts[1]}, []string{"."}, nil,
+					input.AsmFiles, input.Module, t.TempDir(),
+					false, 0, true, false, true, repo, config,
+				)
+				if err != nil || report.Success != 1 || report.Failed != 0 {
+					t.Fatalf("ordinary Go-selected .s must translate and compile: %#v: %v", report, err)
+				}
+				proof := report.FeatureSelection
+				if err := gotoolprofile.ValidateSelection(input, proof, nil, true); err != nil {
+					t.Fatal(err)
+				}
+				if len(proof.Packages) != 1 || len(proof.Outputs) != 1 || proof.Outputs[0].Object == "" {
+					t.Fatal("ordinary name regression lacks complete package/object evidence")
+				}
+				for _, file := range proof.Packages[0].CompiledGoFiles {
+					if strings.HasSuffix(file, "_test.go") {
+						t.Fatal("a filename heuristic loaded a test package into ordinary evidence")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestOrdinaryProfileLoadsNoTestGoForTestNamedAssembly(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		parts := strings.Split(target, "/")
+		for _, name := range []string{"probe_test.s", "probe_test_" + parts[1] + ".s"} {
+			t.Run(target+"/"+name, func(t *testing.T) {
+				input, dir := ordinaryTestNamedFixture(t, target, name, false)
+				t.Chdir(dir)
+				ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+				defer cancel()
+				config, err := resolveCompileConfig(true, "", true, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+				report, _, err := runOneTarget(
+					targetSpec{Goos: parts[0], Goarch: parts[1]}, []string{"."}, nil,
+					input.AsmFiles, input.Module, t.TempDir(),
+					false, 0, true, false, true, repo, config,
+				)
+				if err != nil || report.Success != 1 || report.Failed != 0 {
+					t.Fatalf("ordinary source loader must exclude poison_test.go: %#v: %v", report, err)
+				}
+				if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func ordinaryTestNamedFixture(t *testing.T, target, name string, generated bool) (*featureInput, string) {
+	t.Helper()
+	input, dir := generatedHeaderFixture(t, target)
+	old := input.AsmFiles[0]
+	if err := os.Rename(filepath.Join(dir, old), filepath.Join(dir, name)); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources[name], input.Headers[name] = input.Sources[old], input.Headers[old]
+	delete(input.Sources, old)
+	delete(input.Headers, old)
+	input.AsmFiles = []string{name}
+	if !generated {
+		const source = "TEXT ·Probe(SB),$0-0\nRET\n"
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+	}
+	for index, entry := range input.Directories["."] {
+		if entry == old {
+			input.Directories["."][index] = name
+		}
+	}
+
+	// Go treats _test.go specially, not similarly named .s files. Loading a
+	// test variant here would admit a different declaration/source contract.
+	const testGo = "package header\nvar TestOnly = missingTestOnlyName\n"
+	if err := os.WriteFile(filepath.Join(dir, "poison_test.go"), []byte(testGo), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Sources["poison_test.go"] = featureBytesSHA256([]byte(testGo))
+	input.Headers["poison_test.go"] = testGo
+	input.Directories["."] = append(input.Directories["."], "poison_test.go")
+	sort.Strings(input.Directories["."])
+	return input, dir
+}
diff --git a/cmd/plan9asmll/packed_align_extraction_test.go b/cmd/plan9asmll/packed_align_extraction_test.go
new file mode 100644
index 000000000..41980aa6b
--- /dev/null
+++ b/cmd/plan9asmll/packed_align_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompletePackedAlignTypedFamily(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_packed_align_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_packed_align_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PALIGNR", "VPALIGNR", "VALIGND", "VALIGNQ"} {
+				if _, present := supported[name]; !present {
+					t.Fatal("complete typed align registry omitted a source name", arch, name)
+				}
+			}
+			for _, invalid := range []string{"PALIGN", "VALIGN", "VPALIGNR.Z", "VALIGNQ.BCST", "x86PackedAlignSpecs"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("typed registry advertised a non-source spelling", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_logical_shift_specs_test.go b/cmd/plan9asmll/packed_logical_shift_specs_test.go
new file mode 100644
index 000000000..9ed088f8c
--- /dev/null
+++ b/cmd/plan9asmll/packed_logical_shift_specs_test.go
@@ -0,0 +1,22 @@
+package main
+
+import "testing"
+
+func TestExtractSupportedOpsFindsCompletePackedLogicalShiftFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps("../..", arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{
+			"PSLLW", "PSLLL", "PSLLQ", "PSRLW", "PSRLL", "PSRLQ",
+			"VPSLLW", "VPSLLD", "VPSLLQ", "VPSRLW", "VPSRLD", "VPSRLQ",
+			"VPSLLVW", "VPSLLVD", "VPSLLVQ", "VPSRLVW", "VPSRLVD", "VPSRLVQ",
+			"PSLLO", "PSLLDQ", "PSRLO", "PSRLDQ", "VPSLLDQ", "VPSRLDQ",
+		} {
+			if _, present := supported[op]; !present {
+				t.Errorf("%s logical shift extraction omitted %s", arch, op)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_low_multiply_extraction_test.go b/cmd/plan9asmll/packed_low_multiply_extraction_test.go
new file mode 100644
index 000000000..8641f51bf
--- /dev/null
+++ b/cmd/plan9asmll/packed_low_multiply_extraction_test.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsPackedLowMultiplyTypedTable(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_packed_arithmetic_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_packed_arithmetic_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PMULLD", "VPMULLD", "VPMULLQ"} {
+				if _, exists := supported[name]; !exists {
+					t.Fatal("typed opcode missing", arch, name)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_move_specs_test.go b/cmd/plan9asmll/packed_move_specs_test.go
new file mode 100644
index 000000000..a5e400c92
--- /dev/null
+++ b/cmd/plan9asmll/packed_move_specs_test.go
@@ -0,0 +1,48 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompletePackedMoveSpecTable(t *testing.T) {
+	name := "amd64_packed_vector_move_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for file, content := range map[string][]byte{
+		name: data, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, file), content, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		wanted := []string{
+			"VMOVDQA", "VMOVDQU", "VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS",
+			"VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64",
+		}
+		moves := 0
+		for opcode := range supported {
+			if strings.HasPrefix(opcode, "VMOV") {
+				moves++
+			}
+		}
+		if moves != len(wanted) {
+			t.Fatalf("%s packed-move-only map extraction: %v", arch, supported)
+		}
+		for _, opcode := range wanted {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s typed packed-move extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_narrow_specs_test.go b/cmd/plan9asmll/packed_narrow_specs_test.go
new file mode 100644
index 000000000..6749f0a12
--- /dev/null
+++ b/cmd/plan9asmll/packed_narrow_specs_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompletePackedNarrowSpecTable(t *testing.T) {
+	const name = "amd64_packed_narrow_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for file, content := range map[string][]byte{
+		name: data, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, file), content, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	wanted := []string{"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB",
+		"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB"}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		packs := 0
+		for opcode := range supported {
+			if len(opcode) >= 4 && (opcode[:4] == "PACK" || len(opcode) >= 5 && opcode[:5] == "VPACK") {
+				packs++
+			}
+		}
+		if packs != len(wanted) {
+			t.Fatalf("%s isolated pack specification advertised %d names: %v", arch, packs, supported)
+		}
+		for _, opcode := range wanted {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s typed packed-narrow extraction omitted %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_precision_extraction_test.go b/cmd/plan9asmll/packed_precision_extraction_test.go
new file mode 100644
index 000000000..c2d808884
--- /dev/null
+++ b/cmd/plan9asmll/packed_precision_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompletePackedPrecisionIsolatedSource(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const name = "amd64_packed_precision_forms.go"
+	source, err := os.ReadFile(filepath.Join(repo, name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for file, content := range map[string][]byte{name: source, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(isolated, file), content, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, repo} {
+		for _, arch := range []string{"amd64", "386"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"CVTPS2PD", "CVTPD2PS", "VCVTPS2PD", "VCVTPD2PSX", "VCVTPD2PSY", "VCVTPD2PS"} {
+				if _, found := supported[op]; !found {
+					t.Fatal("isolated packed precision registry omitted an actual source name", arch, op)
+				}
+			}
+			for _, invalid := range []string{"VCVTPS2PD.SAE", "VCVTPD2PS.BCST.Z", "x86PackedPrecisionSpecs"} {
+				if _, found := supported[invalid]; found {
+					t.Fatal("registry advertised a control or Go identifier as a source opcode", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_sign_extend_extraction_test.go b/cmd/plan9asmll/packed_sign_extend_extraction_test.go
new file mode 100644
index 000000000..aace671c5
--- /dev/null
+++ b/cmd/plan9asmll/packed_sign_extend_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsPackedSignExtendIsolatedTypedTable(t *testing.T) {
+	const name = "amd64_packed_sign_extend_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for file, contents := range map[string][]byte{name: source, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(isolated, file), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, "../.."} {
+		for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, suffix := range []string{"BW", "BD", "BQ", "WD", "WQ", "DQ"} {
+				for _, prefix := range []string{"P", "VP"} {
+					op := prefix + "MOVSX" + suffix
+					_, found := supported[op]
+					if found != (arch == "amd64" || arch == "386") {
+						t.Fatal("complete signed widening membership lost its architecture boundary", root, arch, op, found)
+					}
+				}
+			}
+			for _, invalid := range []string{"VPMOVSXBW.Z", "VPMOVSXBD.BCST", "VPMOVSXWD.SAE", "x86PackedSignExtendSpecs"} {
+				if _, found := supported[invalid]; found {
+					t.Fatal("typed map advertised a suffix or Go identifier as an opcode", root, arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_word_multiply_extraction_test.go b/cmd/plan9asmll/packed_word_multiply_extraction_test.go
new file mode 100644
index 000000000..48b3f936d
--- /dev/null
+++ b/cmd/plan9asmll/packed_word_multiply_extraction_test.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsPackedWordMultiplyTypedTable(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_packed_word_multiply_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Isolate the typed dispatch map: an unrelated lowering switch cannot hide
+	// an extraction regression after the old duplicate switch is removed.
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_packed_word_multiply_forms.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	names := []string{"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW", "VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW"}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range names {
+				if _, exists := supported[name]; !exists {
+					t.Fatalf("%s lost typed-table extraction for %s", arch, name)
+				}
+			}
+			for _, nonOpcode := range []string{"M0", "PMULLW.BAD", "amd64PackedWordMultiplyLow", "x86PackedLogicalVEXOrEVEX"} {
+				if _, exists := supported[nonOpcode]; exists {
+					t.Fatalf("%s advertised non-opcode %s", arch, nonOpcode)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/packed_zero_extension_test.go b/cmd/plan9asmll/packed_zero_extension_test.go
new file mode 100644
index 000000000..679dfd57e
--- /dev/null
+++ b/cmd/plan9asmll/packed_zero_extension_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompletePackedZeroExtendSpec(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_packed_zero_extend_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_packed_zero_extend_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		familyCount := 0
+		for name := range supported {
+			if strings.HasPrefix(name, "PMOVZX") || strings.HasPrefix(name, "VPMOVZX") {
+				familyCount++
+			}
+		}
+		if familyCount != 12 {
+			t.Fatalf("%s packed unsigned spec has %d family names, want exact 12", arch, familyCount)
+		}
+		for _, suffix := range []string{"BW", "BD", "BQ", "WD", "WQ", "DQ"} {
+			for _, prefix := range []string{"P", "VP"} {
+				if _, exists := supported[prefix+"MOVZX"+suffix]; !exists {
+					t.Fatalf("%s extraction omitted %sMOVZX%s", arch, prefix, suffix)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/proxy_go_mod_test.go b/cmd/plan9asmll/proxy_go_mod_test.go
new file mode 100644
index 000000000..cfcf83e1a
--- /dev/null
+++ b/cmd/plan9asmll/proxy_go_mod_test.go
@@ -0,0 +1,125 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestFeatureConsumerAllowsAuthenticatedMetadataOutsideOriginalZIP(t *testing.T) {
+	data, err := os.ReadFile("../../gotoolprofile/testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof gotoolprofile.ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateProxyGoMod(&proof); err != nil {
+		t.Fatal(err)
+	}
+	root, metadata := t.TempDir(), filepath.Join(t.TempDir(), "proxy.mod")
+	root, err = filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := []byte("package fixture\n")
+	if err := os.WriteFile(filepath.Join(root, "source.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(metadata, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	metadata, err = filepath.EvalSymlinks(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{Context: context.Background(), Dir: root,
+		Input: &featureInput{Module: proof.Module, SourceModule: proof.Module, Version: proof.Version,
+			Sources: map[string]string{"source.go": featureBytesSHA256(source)}, Directories: map[string][]string{".": {"source.go"}},
+			ProxyGoMod: &proof, ProxyGoModPath: metadata,
+		},
+	}
+	if err := consumer.verifySources(); err != nil {
+		t.Fatalf("signed external metadata is not a ZIP go.mod requirement: %v", err)
+	}
+	if _, err := os.Stat(filepath.Join(root, "go.mod")); !os.IsNotExist(err) {
+		t.Fatal("legacy metadata was injected into the original source tree")
+	}
+	if err := os.WriteFile(metadata, []byte("module example.invalid/changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err == nil {
+		t.Fatal("changed proxy metadata retained its source authentication")
+	}
+}
+
+func TestFeatureConsumerCapturesTheActualProxyMetadataOrigin(t *testing.T) {
+	input, dir := featureConsumerFixture(t)
+	data, err := os.ReadFile("../../gotoolprofile/testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof gotoolprofile.ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	// The ordinary source files are owned fixtures, not executed library code.
+	// Removing this exact t.TempDir member models an original ZIP without it.
+	if err := os.Remove(filepath.Join(dir, "go.mod")); err != nil {
+		t.Fatal(err)
+	}
+	delete(input.Sources, "go.mod")
+	input.Directories["."] = []string{"fallback.go", "probe_amd64.s", "selected.go"}
+	dir, err = filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(t.TempDir(), "proxy.mod")
+	if err := os.WriteFile(metadata, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	metadata, err = filepath.EvalSymlinks(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.Module, input.SourceModule, input.Version = proof.Module, proof.Module, proof.Version
+	input.SourceRoot, input.ProxyGoMod, input.ProxyGoModPath = dir, &proof, metadata
+	consumer := &featureConsumer{
+		Context: context.Background(), Dir: dir,
+		Input: input, Observed: input.Observed, Proof: new(featureSelectionProof),
+	}
+	pkg := &packages.Package{
+		PkgPath: proof.Module,
+		Module:  &packages.Module{Path: proof.Module, Version: proof.Version, Dir: dir, GoMod: metadata},
+		GoFiles: []string{filepath.Join(dir, "selected.go")}, CompiledGoFiles: []string{filepath.Join(dir, "selected.go")},
+		OtherFiles: []string{filepath.Join(dir, "probe_amd64.s")},
+	}
+	// CaptureAssemblerMacros is bound to the actual Go source root observation.
+	root, _, err := testFeatureRunner(context.Background(), "", os.Environ(), "go", "env", "GOROOT")
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer.Root = strings.TrimSpace(string(root))
+	if err := consumer.capturePackages([]*packages.Package{pkg}); err != nil {
+		t.Fatal(err)
+	}
+	actual := consumer.Proof.Packages[0]
+	if actual.GoModOrigin != proof.Protocol || actual.GoModSHA256 != proof.SHA256 || actual.GoModSum != proof.GoModSum {
+		t.Fatalf("actual metadata origin was omitted: %#v", actual)
+	}
+	other := filepath.Join(t.TempDir(), "other.mod")
+	if err := os.WriteFile(other, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	pkg.Module.GoMod = other
+	if err := consumer.capturePackages([]*packages.Package{pkg}); err == nil {
+		t.Fatal("equal bytes at another actual metadata source were accepted")
+	}
+}
diff --git a/cmd/plan9asmll/qword_lookup_extraction_test.go b/cmd/plan9asmll/qword_lookup_extraction_test.go
new file mode 100644
index 000000000..010800a0a
--- /dev/null
+++ b/cmd/plan9asmll/qword_lookup_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteQwordLookupTypedFamily(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_lower_qword_bit_lookup.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_lower_qword_bit_lookup.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"VPMULTISHIFTQB", "VPSHUFBITQMB"} {
+				if _, present := supported[name]; !present {
+					t.Fatal("complete typed qword lookup registry omitted a source name", arch, name)
+				}
+			}
+			for _, invalid := range []string{"VPMULTISHIFTQB.Z", "VPSHUFBITQMB.BCST", "amd64QwordBitLookupSpecs"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("qword lookup extraction advertised a non-source spelling", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/qword_permute_extraction_test.go b/cmd/plan9asmll/qword_permute_extraction_test.go
new file mode 100644
index 000000000..882a918b7
--- /dev/null
+++ b/cmd/plan9asmll/qword_permute_extraction_test.go
@@ -0,0 +1,38 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsQwordPermuteIsolatedTypedTable(t *testing.T) {
+	const name = "amd64_permute_qword_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for file, contents := range map[string][]byte{name: data, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(dir, file), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386", "arm", "arm64", "wasm"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"VPERMQ", "VPERMPD"} {
+			_, found := supported[op]
+			if found != (arch == "amd64" || arch == "386") {
+				t.Fatal("isolated typed qword-permute table lost its architecture boundary", arch, op, found)
+			}
+		}
+		for _, invalid := range []string{"VPERMQ.Z", "VPERMPD.BCST", "x86QwordPermuteBits"} {
+			if _, found := supported[invalid]; found {
+				t.Fatal("typed table advertised a modifier or Go identifier as an opcode", arch, invalid)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/random_extraction_test.go b/cmd/plan9asmll/random_extraction_test.go
new file mode 100644
index 000000000..851f5eaa9
--- /dev/null
+++ b/cmd/plan9asmll/random_extraction_test.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteHardwareRandomSpecTable(t *testing.T) {
+	const filename = "amd64_random_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, data := range map[string][]byte{
+		filename:       source,
+		"translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		supported, err := extractSupportedOps(directory, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"RDRANDW", "RDRANDL", "RDRANDQ", "RDSEEDW", "RDSEEDL", "RDSEEDQ"} {
+			_, present := supported[op]
+			if present != (arch == "386" || arch == "amd64") {
+				t.Error("complete hardware-random inventory changed", arch, op, present)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/reflect_dynamic_entry_test.go b/cmd/plan9asmll/reflect_dynamic_entry_test.go
new file mode 100644
index 000000000..ca071827a
--- /dev/null
+++ b/cmd/plan9asmll/reflect_dynamic_entry_test.go
@@ -0,0 +1,301 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/constant"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+// These stubs have zero declared parameters, but their physical callers have
+// arbitrary signatures. A successful Go object is not an ordinary LLVM entry
+// contract. Keep both original TEXT bodies and the missing-context failures.
+func TestReflectDynamicStubNativeObjectsRetainContext(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64", "arm"} {
+		t.Run(goarch, func(t *testing.T) {
+			pkgs, err := loadPkgs("linux", goarch, []string{"reflect"}, nil, "", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("actual reflect package: count=%d err=%v", len(pkgs), err)
+			}
+			pkg := pkgs[0]
+			sourcePath := filepath.Join(filepath.Dir(pkg.GoFiles[0]), "asm_"+goarch+".s")
+			source, err := readAsmSource(sourcePath, asmSourceRoot(pkg, sourcePath))
+			if err != nil {
+				t.Fatal(err)
+			}
+			imports := make(map[string]*types.Package, len(pkg.Imports))
+			for path, dependency := range pkg.Imports {
+				imports[path] = dependency.Types
+			}
+			source = plan9asm.ExpandGoAssemblySource(plan9asm.GoPackage{
+				Path: pkg.PkgPath, Types: pkg.Types, Imports: imports,
+			}, source, goarch)
+			arch, err := toPlan9Arch(goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.ParseWithDefines(arch, string(source), plan9asm.GoAssemblerDefines("linux", goarch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, argSizes, err := sigsForAsmFile(pkg, file, resolve, goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			listing, actualHeader := reflectDynamicStubGoObject(t, pkg.Types, sourcePath, goarch)
+			if goarch == "amd64" {
+				selected := plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Imports: imports}
+				canonical, err := parseCompleteCLIAssembly(arch, string(source),
+					plan9asm.GoAssemblerDefines("linux", goarch), goarch, &selected)
+				if err != nil {
+					t.Fatal("selected generated header did not reach complete CPP", err)
+				}
+				expanded, err := plan9asm.PreprocessAssemblySource(string(source), plan9asm.AssemblyPreprocessOptions{
+					Defines: plan9asm.GoAssemblerDefines("linux", goarch),
+					ReadInclude: func(_ string, name string) (string, []byte, error) {
+						if name != "go_asm.h" {
+							return "", nil, fmt.Errorf("unexpected remaining SDK include %q", name)
+						}
+						return "actual/go_asm.h", actualHeader, nil
+					},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				original, err := plan9asm.Parse(arch, expanded)
+				if err != nil || !reflect.DeepEqual(canonical, original) {
+					t.Fatal("selected CPP differs from the real compiler-generated header", err)
+				}
+			}
+			unknown := pkg.Imports["internal/abi"].Types.Scope().Lookup("ArgsSizeUnknown").(*types.Const)
+			unknownSize, ok := constant.Int64Val(unknown.Val())
+			if !ok {
+				t.Fatal("actual Go ArgsSizeUnknown is not an int64 constant")
+			}
+			for _, name := range []string{"makeFuncStub", "methodValueCall"} {
+				t.Run(name, func(t *testing.T) {
+					decl, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+					if !ok {
+						t.Fatalf("actual reflect declaration %s not found", name)
+					}
+					declSig := decl.Type().(*types.Signature)
+					if declSig.Params().Len() != 0 || declSig.Results().Len() != 0 {
+						t.Fatalf("%s no longer has the source zero-argument declaration", name)
+					}
+					resolved := pkg.PkgPath + "." + name
+					fs, ok := sigs[resolved]
+					argSize, declared := argSizes[resolved]
+					if !ok || !declared || len(fs.Args) != 0 || fs.Ret != plan9asm.Void || len(fs.Frame.Params) != 0 || len(fs.Frame.Results) != 0 || argSize != 0 {
+						t.Fatalf("invented explicit Go arguments/frame for %s: %+v", resolved, fs)
+					}
+					var function *plan9asm.Func
+					for index := range file.Funcs {
+						if resolve(file.Funcs[index].Sym) == resolved {
+							function = &file.Funcs[index]
+						}
+					}
+					if function == nil || function.FrameSize <= 0 || hasExplicitTextArgSize(*function) {
+						t.Fatalf("original %s TEXT lost its local/dynamic-argument frame", resolved)
+					}
+					reflectDynamicStubCheckArgsSize(t, listing, resolved, unknownSize)
+					original := &plan9asm.File{Arch: arch, Funcs: []plan9asm.Func{*function}}
+					ir, err := plan9asm.Translate(original, plan9asm.Options{
+						Goarch: goarch, TargetTriple: targetTriple("linux", goarch),
+						ResolveSym: resolve, Sigs: sigs,
+					})
+					if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || !strings.Contains(err.Error(), "bound typed frame storage") || ir != "" {
+						t.Fatalf("dynamic caller frame must not become a zero/ordinary FP slot: emitted IR bytes=%d err=%v", len(ir), err)
+					}
+					t.Logf("%s actual Go declaration=func(); native TEXT args=ArgsSizeUnknown; original LLVM translation remains FAILED: %v", resolved, err)
+				})
+			}
+			cfg, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			out := filepath.Join(t.TempDir(), "reflect.ll")
+			err = compileOne(pkg, arch, "linux", goarch, targetTriple("linux", goarch),
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: sourcePath, OutLL: out}, false, cfg)
+			var sourceNA *asmABINotApplicableError
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || errors.As(err, &sourceNA) {
+				t.Fatalf("whole original reflect source must retain its real translation failure, not source N/A: %v", err)
+			}
+			if !strings.Contains(err.Error(), "empty Go declaration does not bind a dynamic caller frame") ||
+				!strings.Contains(err.Error(), "TEXT argument size is unspecified") {
+				t.Fatalf("actual-source failure lost its dynamic-entry diagnostic: %v", err)
+			}
+			for _, artifact := range []string{out, strings.TrimSuffix(out, ".ll") + ".o"} {
+				if _, err := os.Stat(artifact); !os.IsNotExist(err) {
+					t.Fatalf("failed whole-source translation published an artifact: %v", err)
+				}
+			}
+			repoRoot, err := filepath.Abs("../..")
+			if err != nil {
+				t.Fatal(err)
+			}
+			report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: goarch},
+				[]string{"reflect"}, nil, nil, "", t.TempDir(),
+				false, 0, true, false, true, repoRoot, cfg)
+			if err != nil || report.TotalAsm != 1 || report.Success != 0 || report.NotApplicable != 0 || report.Failed != 1 ||
+				len(report.AsmFiles) != 1 || report.AsmFiles[0] != sourcePath || len(report.Fails) != 1 ||
+				!strings.Contains(report.Fails[0].Err, "bound typed frame storage") ||
+				!strings.Contains(report.Fails[0].Err, "empty Go declaration does not bind a dynamic caller frame") ||
+				len(report.UnsupportedOps) != 0 {
+				t.Fatalf("original dynamic-entry failure must remain a failed file: report=%+v err=%v", report, err)
+			}
+			t.Logf("actual whole-file report linux/%s: total=1 success=0 failed=1 source-N/A=0; error=%s", goarch, report.Fails[0].Err)
+		})
+	}
+}
+
+func reflectDynamicStubGoObject(t *testing.T, pkg *types.Package, source, goarch string) (string, []byte) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := append(os.Environ(), "GOOS=linux", "GOARCH="+goarch, "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+	run := func(args ...string) []byte {
+		t.Helper()
+		out, stderr, err := gotoolprofile.RunBounded(ctx, "", env, binary, args...)
+		if err != nil {
+			t.Fatalf("actual Go %v: %v\n%s\n%s", args, err, out, stderr)
+		}
+		return append(out, stderr...)
+	}
+	var importcfg strings.Builder
+	var files []string
+	decoder := json.NewDecoder(strings.NewReader(string(run("list", "-deps", "-export", "-json", "reflect"))))
+	for {
+		var selected struct {
+			ImportPath, Dir, Export string
+			GoFiles, SFiles         []string
+		}
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		// unsafe is intrinsic compiler input, not an export archive. This is
+		// the same omission as Go's generated importcfg, not an assembly skip.
+		if selected.ImportPath == "unsafe" && selected.Export == "" {
+			continue
+		}
+		if selected.Export == "" {
+			t.Fatalf("actual Go export missing for %s", selected.ImportPath)
+		}
+		fmt.Fprintf(&importcfg, "packagefile %s=%s\n", selected.ImportPath, selected.Export)
+		if selected.ImportPath == "reflect" {
+			selectedSource, err := reflectDynamicStubAssemblySelected(selected.Dir, selected.SFiles, source)
+			if err != nil || !selectedSource {
+				t.Fatalf("actual Go linux/%s did not select %s: %v", goarch, source, err)
+			}
+			for _, name := range selected.GoFiles {
+				files = append(files, filepath.Join(selected.Dir, name))
+			}
+		}
+	}
+	if len(files) == 0 {
+		t.Fatal("actual Go selected no reflect source")
+	}
+	dir := t.TempDir()
+	config := filepath.Join(dir, "importcfg")
+	if err := os.WriteFile(config, []byte(importcfg.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	header := filepath.Join(dir, "go_asm.h")
+	typedHeader, err := plan9asm.GoAssemblyHeader(plan9asm.GoPackage{Path: "reflect", Types: pkg}, goarch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Bootstrap symabis with the complete selected typed header, never an
+	// empty placeholder. Compilation then overwrites it with real -asmhdr;
+	// compare every definition before using that real header for the object.
+	if err := os.WriteFile(header, typedHeader, 0600); err != nil {
+		t.Fatal(err)
+	}
+	root := strings.TrimSpace(string(run("env", "GOROOT")))
+	symabis := filepath.Join(dir, "symabis")
+	run("tool", "asm", "-gensymabis", "-p", "reflect", "-I", filepath.Join(root, "pkg", "include"),
+		"-I", dir, "-o", symabis, source)
+	nativeABIs, err := os.ReadFile(symabis)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"makeFuncStub", "methodValueCall"} {
+		if !strings.Contains(string(nativeABIs), "def reflect."+name+" ABI0\n") {
+			t.Fatalf("real selected assembly did not define %s with ABI0: %s", name, nativeABIs)
+		}
+	}
+	args := []string{"tool", "compile", "-std", "-p", "reflect", "-importcfg", config,
+		"-symabis", symabis, "-asmhdr", header, "-o", filepath.Join(dir, "header.o")}
+	run(append(args, files...)...)
+	actualHeader, err := os.ReadFile(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualDefinitions, err := gotoolprofile.HeaderDefinitions(actualHeader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typedDefinitions, err := gotoolprofile.HeaderDefinitions(typedHeader)
+	if err != nil || !reflect.DeepEqual(actualDefinitions, typedDefinitions) {
+		t.Fatalf("actual Go -asmhdr and selected typed reflect layouts differ: %v", err)
+	}
+	object := filepath.Join(dir, "reflect.o")
+	listing := run("tool", "asm", "-S", "-p", "reflect", "-I", filepath.Join(root, "pkg", "include"),
+		"-I", dir, "-o", object, source)
+	info, err := os.Stat(object)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("actual Go assembler produced no nonempty object: %v", err)
+	}
+	t.Logf("actual Go linux/%s object=%d bytes; original source sha256=%s; real generated header sha256=%s\n%s\n%s",
+		goarch, info.Size(), mustReflectContractFileSHA(t, source), featureBytesSHA256(actualHeader), nativeABIs, listing)
+	return string(listing), actualHeader
+}
+
+func reflectDynamicStubCheckArgsSize(t *testing.T, listing, symbol string, unknown int64) {
+	t.Helper()
+	for _, line := range strings.Split(listing, "\n") {
+		if !strings.HasPrefix(line, symbol+" STEXT ") {
+			continue
+		}
+		for _, field := range strings.Fields(line) {
+			if !strings.HasPrefix(field, "args=") {
+				continue
+			}
+			bits, err := strconv.ParseUint(strings.TrimPrefix(field, "args="), 0, 64)
+			if err != nil || int64(int32(bits)) != unknown {
+				t.Fatalf("native %s args is not actual Go ArgsSizeUnknown=%d: %s", symbol, unknown, line)
+			}
+			return
+		}
+	}
+	t.Fatalf("native %s ArgsSizeUnknown metadata is absent", symbol)
+}
+
+func mustReflectContractFileSHA(t *testing.T, name string) string {
+	t.Helper()
+	data, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return featureBytesSHA256(data)
+}
diff --git a/cmd/plan9asmll/reflect_dynamic_selection_test.go b/cmd/plan9asmll/reflect_dynamic_selection_test.go
new file mode 100644
index 000000000..4b6965248
--- /dev/null
+++ b/cmd/plan9asmll/reflect_dynamic_selection_test.go
@@ -0,0 +1,132 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// The independent Go listing and package loader can spell one SDK differently.
+// Bind an actual selected file, not a path string or a same-content substitute.
+func reflectDynamicStubAssemblySelected(directory string, members []string, source string) (bool, error) {
+	physical, requested, err := reflectDynamicStubAssemblyIdentity(source)
+	if err != nil {
+		return false, err
+	}
+	selected := false
+	seen := make(map[string]bool, len(members))
+	for _, member := range members {
+		if filepath.Base(member) != member || filepath.Ext(member) != ".s" {
+			return false, fmt.Errorf("invalid original Go SFiles member %q", member)
+		}
+		candidate, info, err := reflectDynamicStubAssemblyIdentity(filepath.Join(directory, member))
+		if err != nil {
+			return false, err
+		}
+		if seen[candidate] {
+			return false, fmt.Errorf("duplicate original Go assembly member %q", member)
+		}
+		seen[candidate] = true
+		if candidate == physical {
+			if !os.SameFile(requested, info) {
+				return false, fmt.Errorf("original selected assembly changed its file identity")
+			}
+			selected = true
+		}
+	}
+	return selected, nil
+}
+
+func reflectDynamicStubAssemblyIdentity(name string) (string, os.FileInfo, error) {
+	physical, err := sourcepath.Resolve(name)
+	if err != nil {
+		return "", nil, err
+	}
+	info, err := sourcepath.Lstat(physical)
+	if err != nil {
+		return "", nil, err
+	}
+	if !info.Mode().IsRegular() {
+		return "", nil, fmt.Errorf("original assembly is not a regular file: %s", name)
+	}
+	return physical, info, nil
+}
+
+func TestReflectDynamicStubSelectedAssemblyIdentity(t *testing.T) {
+	actual := t.TempDir()
+	const member = "asm_amd64.s"
+	source := filepath.Join(actual, member)
+	if err := os.WriteFile(source, []byte("original assembly\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "original-sdk-directory")
+	ordinaryLoadDirectoryAlias(t, alias, actual)
+	for _, paths := range [][2]string{
+		{actual, source},
+		{alias, source},
+		{actual, filepath.Join(alias, member)},
+	} {
+		t.Run(filepath.Base(paths[0])+"-"+filepath.Base(filepath.Dir(paths[1])), func(t *testing.T) {
+			selected, err := reflectDynamicStubAssemblySelected(paths[0], []string{member}, paths[1])
+			if err != nil || !selected {
+				t.Fatalf("actual selected file lost its opened identity: %v", err)
+			}
+		})
+	}
+}
+
+func TestReflectDynamicStubSelectedAssemblyRejectsUnboundIdentity(t *testing.T) {
+	actual := t.TempDir()
+	const member = "asm_amd64.s"
+	source := filepath.Join(actual, member)
+	other := filepath.Join(actual, "unselected.s")
+	for _, name := range []string{source, other} {
+		if err := os.WriteFile(name, []byte("identical assembly bytes\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, test := range []struct {
+		name    string
+		members []string
+		source  string
+		invalid bool
+	}{
+		{"unselected-equal-bytes", []string{member}, other, false},
+		{"empty-selection", nil, source, false},
+		{"missing-request", []string{member}, filepath.Join(actual, "missing.s"), true},
+		{"missing-selected-member", []string{"missing.s"}, source, true},
+		{"directory-request", []string{member}, actual, true},
+		{"duplicate-selected-member", []string{member, member}, source, true},
+		{"escaped-selected-member", []string{filepath.Join("..", member)}, source, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			selected, err := reflectDynamicStubAssemblySelected(actual, test.members, test.source)
+			if selected || (err != nil) != test.invalid {
+				t.Fatalf("unbound assembly obtained original selection: selected=%t err=%v", selected, err)
+			}
+		})
+	}
+
+	t.Run("retargeted-directory-alias", func(t *testing.T) {
+		replacement := t.TempDir()
+		if err := os.WriteFile(filepath.Join(replacement, member), []byte("identical assembly bytes\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		alias := filepath.Join(t.TempDir(), "original-sdk-directory")
+		ordinaryLoadDirectoryAlias(t, alias, actual)
+		requested := filepath.Join(alias, member)
+		if selected, err := reflectDynamicStubAssemblySelected(actual, []string{member}, requested); err != nil || !selected {
+			t.Fatalf("original alias is not selected: %v", err)
+		}
+		if err := os.Remove(alias); err != nil {
+			t.Fatal(err)
+		}
+		ordinaryLoadDirectoryAlias(t, alias, replacement)
+		if selected, err := reflectDynamicStubAssemblySelected(actual, []string{member}, requested); err != nil || selected {
+			t.Fatalf("retargeted equal-byte alias borrowed original selection: %v", err)
+		}
+	})
+}
diff --git a/cmd/plan9asmll/scalar_bitfield_extraction_test.go b/cmd/plan9asmll/scalar_bitfield_extraction_test.go
new file mode 100644
index 000000000..d85534a20
--- /dev/null
+++ b/cmd/plan9asmll/scalar_bitfield_extraction_test.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteScalarBitFieldSpecTable(t *testing.T) {
+	const filename = "amd64_scalar_bitfield_forms.go"
+	data, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	if err := os.WriteFile(filepath.Join(directory, filename), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(directory, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(directory, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, op := range []string{"BEXTRL", "BEXTRQ", "BZHIL", "BZHIQ"} {
+			if _, present := supported[op]; !present {
+				t.Error("complete scalar bit-field family lost its CLI opcode", arch, op)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/scalar_precision_extraction_test.go b/cmd/plan9asmll/scalar_precision_extraction_test.go
new file mode 100644
index 000000000..e4f92e5a7
--- /dev/null
+++ b/cmd/plan9asmll/scalar_precision_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteScalarPrecisionTypedFamily(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(filepath.Join(repo, "amd64_scalar_precision_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_scalar_precision_forms.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"CVTSS2SD", "CVTSD2SS", "VCVTSS2SD", "VCVTSD2SS"} {
+				if _, present := supported[name]; !present {
+					t.Fatal("complete typed precision registry omitted a source name", arch, name, root)
+				}
+			}
+			for _, invalid := range []string{"CVTSS2SS", "CVTSD2SD", "VCVTSS2SD.SAE", "VCVTSD2SS.RN_SAE", "x86ScalarPrecisionSpecs"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("typed precision registry advertised a non-source spelling", arch, invalid, root)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/selected_nonempty_scope_test.go b/cmd/plan9asmll/selected_nonempty_scope_test.go
new file mode 100644
index 000000000..276df081b
--- /dev/null
+++ b/cmd/plan9asmll/selected_nonempty_scope_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCollectAsmTasksExplicitNonemptyScope(t *testing.T) {
+	dir := t.TempDir()
+	var selected []string
+	for file, body := range map[string]string{
+		"cpu.s": "// original nonempty placeholder\n", "white.s": "\n \t\n", "empty.s": "",
+		"probe.s": "TEXT ·Probe(SB),4,$0-0\nRET\n", "unselected.s": "// not selected by Go\n",
+	} {
+		name := filepath.Join(dir, file)
+		if err := os.WriteFile(name, []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if file != "unselected.s" {
+			selected = append(selected, name)
+		}
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.invalid/scope", OtherFiles: selected,
+		Module: &packages.Module{Path: "example.invalid/scope", Dir: dir},
+	}
+	tasks, _ := collectAsmTasks([]*packages.Package{pkg}, t.TempDir(),
+		[]string{"cpu.s", "white.s", "empty.s", "probe.s", "unselected.s"})
+	var files []string
+	for _, task := range tasks {
+		files = append(files, filepath.Base(task.AsmFile))
+	}
+	if want := []string{"cpu.s", "probe.s", "white.s"}; !reflect.DeepEqual(files, want) {
+		t.Fatalf("explicit scope lost selected nonzero originals or injected an unselected file: %v, want %v", files, want)
+	}
+	tasks, _ = collectAsmTasks([]*packages.Package{pkg}, t.TempDir(), nil)
+	if len(tasks) != 1 || filepath.Base(tasks[0].AsmFile) != "probe.s" {
+		t.Fatalf("legacy unscoped heuristic changed: %#v", tasks)
+	}
+}
diff --git a/cmd/plan9asmll/shared_abi0_helper.go b/cmd/plan9asmll/shared_abi0_helper.go
new file mode 100644
index 000000000..946d2dbce
--- /dev/null
+++ b/cmd/plan9asmll/shared_abi0_helper.go
@@ -0,0 +1,150 @@
+package main
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// A shared ABI0 body can receive its arguments in physical registers while
+// its wrappers pass a pointer to their own result slots. In that case the
+// helper returns void; each wrapper reads its FP results after the call.
+// Require both caller-side address setup and a helper-side memory write so
+// ordinary register-return tail helpers retain their existing inference.
+func inferSharedABI0ResultPointerHelper(
+	file *plan9asm.File,
+	resolve func(string) string,
+	target string,
+	callers []plan9asm.FuncSig,
+	callerFuncs []plan9asm.Func,
+	goarch string,
+) (plan9asm.FuncSig, bool) {
+	if (goarch != "amd64" && goarch != "386") || len(callers) < 2 || len(callers) != len(callerFuncs) {
+		return plan9asm.FuncSig{}, false
+	}
+
+	var pointerReg plan9asm.Reg
+	for i, caller := range callers {
+		if len(caller.Frame.Results) < 2 || !strings.HasPrefix(string(caller.Ret), "{") {
+			return plan9asm.FuncSig{}, false
+		}
+		reg, ok := callerABI0ResultPointerRegister(
+			callerFuncs[i], caller.Frame.Results[0], target, resolve,
+		)
+		if !ok || pointerReg != "" && pointerReg != reg {
+			return plan9asm.FuncSig{}, false
+		}
+		pointerReg = reg
+	}
+
+	var body *plan9asm.Func
+	for i := range file.Funcs {
+		if resolve(stripABISuffix(file.Funcs[i].Sym)) == target {
+			body = &file.Funcs[i]
+			break
+		}
+	}
+	if body == nil || !helperWritesThroughRegister(*body, pointerReg) {
+		return plan9asm.FuncSig{}, false
+	}
+
+	registers := x86HelperRegisterOperands(*body, pointerReg, goarch)
+	word := plan9asm.I64
+	if goarch == "386" {
+		word = plan9asm.I32
+	}
+	args := make([]plan9asm.LLVMType, len(registers))
+	for i := range args {
+		args[i] = word
+	}
+	return plan9asm.FuncSig{
+		Name:    target,
+		Args:    args,
+		ArgRegs: registers,
+		Ret:     plan9asm.Void,
+	}, true
+}
+
+func callerABI0ResultPointerRegister(
+	fn plan9asm.Func,
+	firstResult plan9asm.FrameSlot,
+	target string,
+	resolve func(string) string,
+) (plan9asm.Reg, bool) {
+	for i := 1; i < len(fn.Instrs); i++ {
+		tail := fn.Instrs[i]
+		if strings.ToUpper(string(tail.Op)) != "JMP" || len(tail.Args) != 1 || tail.Args[0].Kind != plan9asm.OpSym {
+			continue
+		}
+		sym := strings.TrimSpace(tail.Args[0].Sym)
+		if !strings.HasSuffix(sym, "(SB)") || resolve(stripABISuffix(strings.TrimSuffix(sym, "(SB)"))) != target {
+			continue
+		}
+		address := fn.Instrs[i-1]
+		if address.Op != "LEAQ" && address.Op != "LEAL" {
+			continue
+		}
+		if len(address.Args) != 2 ||
+			(address.Args[0].Kind != plan9asm.OpFP && address.Args[0].Kind != plan9asm.OpFPAddr) ||
+			address.Args[1].Kind != plan9asm.OpReg {
+			continue
+		}
+		if address.Args[0].FPOffset != firstResult.Offset || firstResult.Name != "" && address.Args[0].FPName != firstResult.Name {
+			continue
+		}
+		return address.Args[1].Reg, true
+	}
+	return "", false
+}
+
+func helperWritesThroughRegister(fn plan9asm.Func, reg plan9asm.Reg) bool {
+	for _, ins := range fn.Instrs {
+		if !strings.HasPrefix(strings.ToUpper(string(ins.Op)), "MOV") || len(ins.Args) < 2 {
+			continue
+		}
+		destination := ins.Args[len(ins.Args)-1]
+		if destination.Kind == plan9asm.OpMem && destination.Mem.Base == reg {
+			return true
+		}
+	}
+	return false
+}
+
+func x86HelperRegisterOperands(fn plan9asm.Func, pointerReg plan9asm.Reg, goarch string) []plan9asm.Reg {
+	used := map[plan9asm.Reg]bool{pointerReg: true}
+	add := func(reg plan9asm.Reg) {
+		if x86HelperGeneralRegister(reg, goarch) {
+			used[reg] = true
+		}
+	}
+	for _, ins := range fn.Instrs {
+		for _, operand := range ins.Args {
+			switch operand.Kind {
+			case plan9asm.OpReg, plan9asm.OpRegExtend, plan9asm.OpRegShift:
+				add(operand.Reg)
+			case plan9asm.OpMem:
+				add(operand.Mem.Base)
+				add(operand.Mem.Index)
+			}
+		}
+	}
+	registers := make([]plan9asm.Reg, 0, len(used))
+	for reg := range used {
+		registers = append(registers, reg)
+	}
+	sort.Slice(registers, func(i, j int) bool { return registers[i] < registers[j] })
+	return registers
+}
+
+func x86HelperGeneralRegister(reg plan9asm.Reg, goarch string) bool {
+	switch reg {
+	case plan9asm.AX, plan9asm.BX, plan9asm.CX, plan9asm.DX,
+		plan9asm.SI, plan9asm.DI, plan9asm.BP:
+		return true
+	case "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15":
+		return goarch == "amd64"
+	default:
+		return false
+	}
+}
diff --git a/cmd/plan9asmll/shared_x86_binding_test.go b/cmd/plan9asmll/shared_x86_binding_test.go
new file mode 100644
index 000000000..fa53513ec
--- /dev/null
+++ b/cmd/plan9asmll/shared_x86_binding_test.go
@@ -0,0 +1,189 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsSharedX86RequiresTypedBinding(t *testing.T) {
+	cases := []struct {
+		name, source string
+		want         bool
+	}{
+		{"typed_parameter", `func f(code Op) { switch code { case "VBOUND": } }`, true},
+		{"string_named_op", `func f(op string) { switch op { case "VBOUND": } }`, false},
+		{"shadowed_op", `func f(op Op, condition string) { { op := condition; switch op { case "VBOUND": } } }`, false},
+		{"var_alias", `func f(code Op) { var name = string(code); switch name { case "VBOUND": } }`, true},
+		{"parallel_alias", `func f(code Op, condition string) { other, name := condition, string(code); _ = other; switch name { case "VBOUND": } }`, true},
+		{"instruction_field", `func f(source Instr) { switch source.Op { case "VBOUND": } }`, true},
+		{"unrelated_field", `func f(source struct{Op string}) { switch source.Op { case "VBOUND": } }`, false},
+		{"typed_conversion", `func f(code Op) { switch Op(string(code)) { case "VBOUND": } }`, true},
+		{"untyped_conversion", `func f(condition string) { switch Op(condition) { case "VBOUND": } }`, false},
+		{"strings_import_alias", `import textstrings "strings"
+func f(code Op) { name, _, _ := textstrings.Cut(textstrings.ToUpper(string(code)), "."); switch name { case "VBOUND": } }`, true},
+		{"cut_suffix", `import "strings"
+func f(op Op) { _, suffix, _ := strings.Cut(string(op), "."); switch suffix { case "VBOUND": } }`, false},
+		{"shadowed_strings", `func f(op Op) { strings := struct{ToUpper func(string) string}{}; switch strings.ToUpper(string(op)) { case "VBOUND": } }`, false},
+		{"operand_comparison", `func f(op string) { if op == "VBOUND" {} }`, false},
+		{"typed_comparison", `func f(code Op) { if code == "VBOUND" {} }`, true},
+		{"reassigned_alias", `func f(op Op, condition string) {
+	name := string(op)
+	name = condition
+	switch name { case "VBOUND": }
+}`, false},
+		{"conditionally_reassigned_alias", `func f(op Op, condition string, replace bool) {
+	name := string(op)
+	if replace { name = condition }
+	switch name { case "VBOUND": }
+}`, false},
+		{"shadowed_opcode_type", `func f(condition string) {
+	type Op string
+	var op Op = Op(condition)
+	switch op { case "VBOUND": }
+}`, false},
+		{"shadowed_instruction_type", `func f() {
+	type Instr struct { Op string }
+	var source Instr
+	switch source.Op { case "VBOUND": }
+}`, false},
+		{"shadowed_string_conversion", `func f(op Op, condition string) {
+	string := func(Op) string { return condition }
+	switch string(op) { case "VBOUND": }
+}`, false},
+		{"shadowed_opcode_conversion", `func f(op Op, condition string) {
+	Op := func(Op) string { return condition }
+	switch Op(op) { case "VBOUND": }
+}`, false},
+		{"foreign_strings_import", `import strings "example.com/conditions"
+func f(op Op) { switch strings.ToUpper(string(op)) { case "VBOUND": } }`, false},
+		{"shadowed_import_parameter", `import "strings"
+func f(op Op, strings struct { ToUpper func(string) string }) {
+	switch strings.ToUpper(string(op)) { case "VBOUND": }
+}`, false},
+		{"parallel_var_alias", `func f(code Op, condition string) {
+	var other, name = condition, string(code)
+	_ = other
+	switch name { case "VBOUND": }
+}`, true},
+		{"local_opcode_map", `func f(code Op) {
+	table := map[string]int{"VBOUND": 1}
+	_ = table[string(code)]
+}`, true},
+		{"parallel_local_opcode_maps", `func f(code Op, condition string) {
+	operand, opcode := map[string]int{"EQ": 1}, map[string]int{"VBOUND": 1}
+	_ = operand[condition]
+	_ = opcode[string(code)]
+}`, true},
+		{"parallel_var_opcode_maps", `func f(code Op, condition string) {
+	var operand, opcode = map[string]int{"EQ": 1}, map[string]int{"VBOUND": 1}
+	_ = operand[condition]
+	_ = opcode[string(code)]
+}`, true},
+		{"opcode_map_alias", `var original = map[string]int{"VBOUND": 1}
+func f(code Op) { table := original; _ = table[string(code)] }`, true},
+		{"typed_opcode_map", `var table = map[Op]int{"VBOUND": 1}
+func f(code Op) { _ = table[Op(string(code))] }`, true},
+		{"shadowed_opcode_map_type", `func f(condition string) {
+	type Op string
+	table := map[Op]int{"VBOUND": 1}
+	_ = table[Op(condition)]
+}`, false},
+		{"mutable_opcode_map", `func f(op Op, other map[string]int) {
+	var table = map[string]int{"VBOUND": 1}
+	table = other
+	_ = table[string(op)]
+}`, false},
+		{"parallel_operand_map", `func f(code Op, condition string) {
+	var operand, opcode = map[string]int{"VBOUND": 1}, map[string]int{"EQ": 1}
+	_ = operand[condition]
+	_ = opcode[string(code)]
+}`, false},
+		{"cut_found_result", `import "strings"
+func f(op Op) { _, _, found := strings.Cut(string(op), "."); if found == true {} }`, false},
+		{"inline_opcode_map", `func f(code Op) { _ = map[string]int{"VBOUND": 1}[string(code)] }`, true},
+		{"reassigned_parallel_alias", `func f(op Op, condition string) {
+	name, other := string(op), condition
+	name, other = other, name
+	switch name { case "VBOUND": }
+}`, false},
+		{"reassigned_map_alias", `var original = map[string]int{"VBOUND": 1}
+func f(op Op, other map[string]int) {
+	table := original
+	table = other
+	_ = table[string(op)]
+}`, false},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			for name, source := range map[string]string{
+				"translate.go":   "package sample\n",
+				"types.go":       sharedX86CanonicalTestTypes,
+				"x86_binding.go": "package sample\n" + test.source,
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			for _, arch := range []string{"386", "amd64"} {
+				t.Run(arch, func(t *testing.T) {
+					supported, err := extractSupportedOps(dir, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, found := supported["VBOUND"]; found != test.want {
+						t.Errorf("opcode role advertised=%t, want %t", found, test.want)
+					}
+				})
+			}
+		})
+	}
+}
+
+const sharedX86CanonicalTestTypes = "package sample\ntype Op string\ntype Instr struct { Op Op }\n"
+
+func TestExtractSupportedOpsSharedX86RequiresCanonicalTypes(t *testing.T) {
+	cases := []struct {
+		name, types, source string
+	}{
+		{"absent_types", "", `func f(op Op) { switch op { case "VBOUND": } }`},
+		{"opcode_alias_of_string", "package sample\ntype Op = string\ntype Instr struct { Op Op }\n",
+			`func f(op Op) { switch op { case "VBOUND": } }`},
+		{"instruction_string_field", "package sample\ntype Op string\ntype Instr struct { Op string }\n",
+			`func f(source Instr) { switch source.Op { case "VBOUND": } }`},
+		{"foreign_types_package", "package foreign\ntype Op string\ntype Instr struct { Op Op }\n",
+			`func f(op Op) { switch op { case "VBOUND": } }`},
+		{"package_opcode_redeclaration", sharedX86CanonicalTestTypes,
+			`type Op string
+func f(op Op) { switch op { case "VBOUND": } }`},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			files := map[string]string{
+				"translate.go":   "package sample\n",
+				"x86_binding.go": "package sample\n" + test.source,
+			}
+			if test.types != "" {
+				files["types.go"] = test.types
+			}
+			for name, source := range files {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			for _, arch := range []string{"386", "amd64"} {
+				t.Run(arch, func(t *testing.T) {
+					supported, err := extractSupportedOps(dir, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if _, found := supported["VBOUND"]; found {
+						t.Fatal("unbound canonical type advertised an opcode")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/shared_x86_extraction.go b/cmd/plan9asmll/shared_x86_extraction.go
new file mode 100644
index 000000000..9510715c9
--- /dev/null
+++ b/cmd/plan9asmll/shared_x86_extraction.go
@@ -0,0 +1,359 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+type sharedX86OpcodeRole uint8
+
+const (
+	sharedX86NoOpcodeRole sharedX86OpcodeRole = iota
+	sharedX86OpcodeValue
+	sharedX86InstructionValue
+)
+
+// The inputs are the repository's actual Op and Instr, not every local type,
+// variable or field with the same spelling. This is diagnostic inventory only.
+type sharedX86OpcodeTypes struct {
+	packageName  string
+	op, instr    *ast.Object
+	packageNames map[string][]*ast.Object
+}
+
+func loadSharedX86OpcodeTypes(root string, files []*ast.File) (*sharedX86OpcodeTypes, error) {
+	index := &sharedX86OpcodeTypes{packageNames: make(map[string][]*ast.Object)}
+	filename := filepath.Join(root, "types.go")
+	source, err := os.ReadFile(filename)
+	if errors.Is(err, os.ErrNotExist) {
+		return index, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("read shared x86 types: %w", err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), filename, source, 0)
+	if err != nil {
+		return nil, fmt.Errorf("parse shared x86 types: %w", err)
+	}
+	index.packageName = file.Name.Name
+	for _, current := range append(files, file) {
+		if current.Name.Name == index.packageName {
+			for name, object := range current.Scope.Objects {
+				index.packageNames[name] = append(index.packageNames[name], object)
+			}
+		}
+	}
+	op := file.Scope.Lookup("Op")
+	declaration, ok := sharedX86TypeDeclaration(op)
+	if !ok || declaration.Assign.IsValid() || len(index.packageNames["Op"]) != 1 ||
+		!sharedX86BuiltinType(declaration.Type, "string", index.packageNames) {
+		return index, nil
+	}
+	index.op = op
+	instr := file.Scope.Lookup("Instr")
+	declaration, ok = sharedX86TypeDeclaration(instr)
+	if !ok || declaration.Assign.IsValid() || len(index.packageNames["Instr"]) != 1 {
+		return index, nil
+	}
+	structure, ok := declaration.Type.(*ast.StructType)
+	if !ok {
+		return index, nil
+	}
+	fields := 0
+	for _, field := range structure.Fields.List {
+		for _, name := range field.Names {
+			if name.Name == "Op" {
+				fields++
+				identifier, valid := field.Type.(*ast.Ident)
+				if !valid || identifier.Obj != op {
+					return index, nil
+				}
+			}
+		}
+	}
+	if fields == 1 {
+		index.instr = instr
+	}
+	return index, nil
+}
+
+func sharedX86TypeDeclaration(object *ast.Object) (*ast.TypeSpec, bool) {
+	if object == nil || object.Kind != ast.Typ {
+		return nil, false
+	}
+	declaration, ok := object.Decl.(*ast.TypeSpec)
+	return declaration, ok
+}
+
+func sharedX86BuiltinType(expression ast.Expr, name string, packageNames map[string][]*ast.Object) bool {
+	identifier, ok := expression.(*ast.Ident)
+	return ok && identifier.Name == name && identifier.Obj == nil && len(packageNames[name]) == 0
+}
+
+type sharedX86OpcodeBindings struct {
+	types   *sharedX86OpcodeTypes
+	imports map[string]string
+	mutable map[*ast.Object]bool
+}
+
+func newSharedX86OpcodeBindings(file *ast.File, types *sharedX86OpcodeTypes) *sharedX86OpcodeBindings {
+	bindings := &sharedX86OpcodeBindings{types: types,
+		imports: make(map[string]string), mutable: make(map[*ast.Object]bool)}
+	for _, spec := range file.Imports {
+		path, err := strconv.Unquote(spec.Path.Value)
+		if err != nil {
+			continue
+		}
+		name := filepath.Base(path)
+		if spec.Name != nil {
+			name = spec.Name.Name
+		}
+		bindings.imports[name] = path
+	}
+	// An initializer cannot establish a later mutable value. Reject the whole
+	// alias rather than inventing a compiler CFG or following stale initializers.
+	mark := func(expression ast.Expr, declaration ast.Node) {
+		if name, ok := expression.(*ast.Ident); ok && name.Obj != nil && name.Obj.Decl != declaration {
+			bindings.mutable[name.Obj] = true
+		}
+	}
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch statement := node.(type) {
+		case *ast.AssignStmt:
+			for _, expression := range statement.Lhs {
+				mark(expression, statement)
+			}
+		case *ast.RangeStmt:
+			mark(statement.Key, statement)
+			mark(statement.Value, statement)
+		case *ast.IncDecStmt:
+			mark(statement.X, nil)
+		}
+		return true
+	})
+	return bindings
+}
+
+func (bindings *sharedX86OpcodeBindings) typeRole(expression ast.Expr, depth int) sharedX86OpcodeRole {
+	if depth > 8 {
+		return sharedX86NoOpcodeRole
+	}
+	switch value := expression.(type) {
+	case *ast.ParenExpr:
+		return bindings.typeRole(value.X, depth+1)
+	case *ast.StarExpr:
+		if bindings.typeRole(value.X, depth+1) == sharedX86InstructionValue {
+			return sharedX86InstructionValue
+		}
+	case *ast.Ident:
+		object := value.Obj
+		if object == nil {
+			objects := bindings.types.packageNames[value.Name]
+			if len(objects) != 1 || bindings.imports[value.Name] != "" {
+				return sharedX86NoOpcodeRole
+			}
+			object = objects[0]
+		}
+		if object == bindings.types.op && object != nil {
+			return sharedX86OpcodeValue
+		}
+		if object == bindings.types.instr && object != nil {
+			return sharedX86InstructionValue
+		}
+		if declaration, ok := sharedX86TypeDeclaration(object); ok && declaration.Assign.IsValid() {
+			return bindings.typeRole(declaration.Type, depth+1)
+		}
+	}
+	return sharedX86NoOpcodeRole
+}
+
+func (bindings *sharedX86OpcodeBindings) builtin(expression ast.Expr, name string) bool {
+	return sharedX86BuiltinType(expression, name, bindings.types.packageNames) && bindings.imports[name] == ""
+}
+
+func (bindings *sharedX86OpcodeBindings) stringsCall(call *ast.CallExpr) (string, bool) {
+	function, ok := call.Fun.(*ast.SelectorExpr)
+	if !ok {
+		return "", false
+	}
+	pkg, ok := function.X.(*ast.Ident)
+	return function.Sel.Name, ok && pkg.Obj == nil && bindings.imports[pkg.Name] == "strings"
+}
+
+func (bindings *sharedX86OpcodeBindings) cutInput(call *ast.CallExpr) (ast.Expr, bool) {
+	name, imported := bindings.stringsCall(call)
+	if !imported || name != "Cut" || len(call.Args) != 2 {
+		return nil, false
+	}
+	separator, ok := call.Args[1].(*ast.BasicLit)
+	if !ok || separator.Kind != token.STRING {
+		return nil, false
+	}
+	text, err := strconv.Unquote(separator.Value)
+	return call.Args[0], err == nil && text == "."
+}
+
+// Match the initializer to its exact declaration slot. For strings.Cut, only
+// the first of three results preserves the opcode; suffix/found do not.
+func (bindings *sharedX86OpcodeBindings) initializer(object *ast.Object) ast.Expr {
+	if object == nil || bindings.mutable[object] {
+		return nil
+	}
+	var names []*ast.Ident
+	var values []ast.Expr
+	switch declaration := object.Decl.(type) {
+	case *ast.ValueSpec:
+		names, values = declaration.Names, declaration.Values
+	case *ast.AssignStmt:
+		values = declaration.Rhs
+		for _, expression := range declaration.Lhs {
+			name, ok := expression.(*ast.Ident)
+			if !ok {
+				return nil
+			}
+			names = append(names, name)
+		}
+	default:
+		return nil
+	}
+	for index, name := range names {
+		if name.Obj != object {
+			continue
+		}
+		if len(values) == len(names) {
+			return values[index]
+		}
+		if index == 0 && len(names) == 3 && len(values) == 1 {
+			if call, ok := values[0].(*ast.CallExpr); ok {
+				if input, valid := bindings.cutInput(call); valid {
+					return input
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (bindings *sharedX86OpcodeBindings) expressionRole(expression ast.Expr, depth int) sharedX86OpcodeRole {
+	if depth > 8 {
+		return sharedX86NoOpcodeRole
+	}
+	switch value := expression.(type) {
+	case *ast.Ident:
+		if value.Obj == nil || bindings.mutable[value.Obj] {
+			return sharedX86NoOpcodeRole
+		}
+		if field, ok := value.Obj.Decl.(*ast.Field); ok {
+			return bindings.typeRole(field.Type, depth+1)
+		}
+		if declaration, ok := value.Obj.Decl.(*ast.ValueSpec); ok &&
+			bindings.typeRole(declaration.Type, depth+1) == sharedX86InstructionValue {
+			return sharedX86InstructionValue
+		}
+		return bindings.expressionRole(bindings.initializer(value.Obj), depth+1)
+	case *ast.ParenExpr:
+		return bindings.expressionRole(value.X, depth+1)
+	case *ast.SelectorExpr:
+		if value.Sel.Name == "Op" && bindings.expressionRole(value.X, depth+1) == sharedX86InstructionValue {
+			return sharedX86OpcodeValue
+		}
+	case *ast.CallExpr:
+		if len(value.Args) == 1 && (bindings.builtin(value.Fun, "string") ||
+			bindings.typeRole(value.Fun, depth+1) == sharedX86OpcodeValue) &&
+			bindings.expressionRole(value.Args[0], depth+1) == sharedX86OpcodeValue {
+			return sharedX86OpcodeValue
+		}
+		if name, imported := bindings.stringsCall(value); imported && len(value.Args) == 1 {
+			switch name {
+			case "ToUpper", "ToLower", "TrimSpace":
+				if bindings.expressionRole(value.Args[0], depth+1) == sharedX86OpcodeValue {
+					return sharedX86OpcodeValue
+				}
+			}
+		}
+	}
+	return sharedX86NoOpcodeRole
+}
+
+func (bindings *sharedX86OpcodeBindings) opcodeMap(expression ast.Expr, depth int) *ast.CompositeLit {
+	if depth > 8 {
+		return nil
+	}
+	switch value := expression.(type) {
+	case *ast.ParenExpr:
+		return bindings.opcodeMap(value.X, depth+1)
+	case *ast.Ident:
+		return bindings.opcodeMap(bindings.initializer(value.Obj), depth+1)
+	case *ast.CompositeLit:
+		if typ, ok := value.Type.(*ast.MapType); ok && (bindings.builtin(typ.Key, "string") ||
+			bindings.typeRole(typ.Key, depth+1) == sharedX86OpcodeValue) {
+			return value
+		}
+	}
+	return nil
+}
+
+// Shared effects also contain operand/condition switches. Only actual typed
+// opcode dispatch can advertise names; unrelated maps and suffixes cannot.
+func collectSharedX86OpcodeDispatch(supported map[string]struct{}, file *ast.File, types *sharedX86OpcodeTypes) {
+	if types.op == nil || file.Name.Name != types.packageName {
+		return
+	}
+	bindings := newSharedX86OpcodeBindings(file, types)
+	add := func(expression ast.Expr) {
+		literal, ok := expression.(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return
+		}
+		name, err := strconv.Unquote(literal.Value)
+		if err == nil {
+			if name = normalizeOp(name); name != "" {
+				supported[name] = struct{}{}
+			}
+		}
+	}
+	addMap := func(literal *ast.CompositeLit) {
+		if literal != nil {
+			for _, element := range literal.Elts {
+				if entry, ok := element.(*ast.KeyValueExpr); ok {
+					add(entry.Key)
+				}
+			}
+		}
+	}
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch value := node.(type) {
+		case *ast.SwitchStmt:
+			if bindings.expressionRole(value.Tag, 0) == sharedX86OpcodeValue {
+				for _, statement := range value.Body.List {
+					for _, expression := range statement.(*ast.CaseClause).List {
+						add(expression)
+					}
+				}
+			}
+		case *ast.BinaryExpr:
+			if value.Op == token.EQL || value.Op == token.NEQ {
+				if bindings.expressionRole(value.X, 0) == sharedX86OpcodeValue {
+					add(value.Y)
+				} else if bindings.expressionRole(value.Y, 0) == sharedX86OpcodeValue {
+					add(value.X)
+				}
+			}
+		case *ast.CompositeLit:
+			if typ, ok := value.Type.(*ast.MapType); ok && bindings.typeRole(typ.Key, 0) == sharedX86OpcodeValue {
+				addMap(value)
+			}
+		case *ast.IndexExpr:
+			if bindings.expressionRole(value.Index, 0) == sharedX86OpcodeValue {
+				addMap(bindings.opcodeMap(value.X, 0))
+			}
+		}
+		return true
+	})
+}
diff --git a/cmd/plan9asmll/shared_x86_extraction_test.go b/cmd/plan9asmll/shared_x86_extraction_test.go
new file mode 100644
index 000000000..1261985d4
--- /dev/null
+++ b/cmd/plan9asmll/shared_x86_extraction_test.go
@@ -0,0 +1,104 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsSharedX86TypedGrammar(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "x86_broadcast_forms.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	types, err := os.ReadFile(filepath.Join(repo, "types.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, data := range map[string][]byte{
+		"x86_broadcast_forms.go": source,
+		"translate.go":           []byte("package plan9asm\n"),
+		"types.go":               types,
+	} {
+		if err := os.WriteFile(filepath.Join(isolated, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	names := []string{
+		"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ",
+		"VBROADCASTSS", "VBROADCASTSD",
+	}
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			supported, err := extractSupportedOps(isolated, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range names {
+				_, found := supported[name]
+				if found != (arch == "386" || arch == "amd64") {
+					t.Errorf("shared typed grammar %s: advertised=%t", name, found)
+				}
+			}
+		})
+	}
+}
+
+func TestExtractSupportedOpsSharedX86DispatchDoesNotAdvertiseConditions(t *testing.T) {
+	dir := t.TempDir()
+	files := map[string]string{
+		"translate.go": "package sample\n",
+		"types.go":     sharedX86CanonicalTestTypes,
+		"x86_shared.go": `package sample
+import "strings"
+var sharedTable = map[string]int{"VTABLEOP": 1}
+var unrelatedNames = map[string]int{"EQ": 1, "NE": 1}
+func dispatch(op Op, condition string) {
+	name, _, _ := strings.Cut(strings.ToUpper(string(op)), ".")
+	_ = sharedTable[name]
+	_ = unrelatedNames[condition]
+	switch name {
+	case "VSHAREDOP":
+	}
+	switch condition {
+	case "EQ", "NE":
+	}
+}
+`,
+		"x86_shared_test.go": `package sample
+func testOnly(op Op) {
+	switch op {
+	case "VTESTONLY":
+	}
+}
+`,
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			supported, err := extractSupportedOps(dir, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"VSHAREDOP", "VTABLEOP"} {
+				if _, found := supported[name]; !found {
+					t.Errorf("shared opcode dispatch %s was not observed", name)
+				}
+			}
+			for _, name := range []string{"EQ", "NE", "VTESTONLY"} {
+				if _, found := supported[name]; found {
+					t.Errorf("non-dispatch string %s was advertised", name)
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/signed_packed_integer_float_test.go b/cmd/plan9asmll/signed_packed_integer_float_test.go
new file mode 100644
index 000000000..9b0fad066
--- /dev/null
+++ b/cmd/plan9asmll/signed_packed_integer_float_test.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsSignedPackedIntegerFloat(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_signed_packed_integer_float.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_signed_packed_integer_float.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		ops, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+			if _, present := ops[name]; !present {
+				t.Fatal(arch, "missing", name)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/source_output.go b/cmd/plan9asmll/source_output.go
new file mode 100644
index 000000000..e49bae69c
--- /dev/null
+++ b/cmd/plan9asmll/source_output.go
@@ -0,0 +1,390 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// One attempt owns every whole-module or chunk output. Nothing reaches a
+// public destination until every deferred source verification and owner Close
+// has succeeded. Multiple renames are not an atomic filesystem transaction:
+// a publication I/O failure rolls back already moved files, reporting every
+// rollback failure. Pure post-commit temporary cleanup has a distinct error.
+type compileOutputStage struct {
+	directory        string
+	info             os.FileInfo
+	outputs          []compileOutputFile
+	names            map[string]bool
+	sealed           int
+	inputs           map[string]bool
+	inputNodes       []compileOutputInput
+	inputMisses      []compileOutputSearchMiss
+	inputDirectories []compileOutputInputDirectory
+	inputNames       []compileOutputInputName
+	inputNameKeys    map[string]bool
+	inputSeenNames   map[string]bool
+	inputSeenDirs    map[string]bool
+	committed        bool
+	rename           func(string, string) error
+	removeAll        func(string) error
+}
+
+type compileOutputFile struct {
+	path, destination, digest string
+	info                      os.FileInfo
+	parent                    assemblyMemberDirectory
+	parentTarget              os.FileInfo
+	previous                  os.FileInfo
+	previousDigest            string
+	backup                    string
+	backupInfo                os.FileInfo
+	published                 bool
+	deletion                  bool
+}
+
+func compileOutputError() error {
+	return fmt.Errorf("missing or redirected compile output transaction")
+}
+
+func outputPathWithin(path, root string) bool {
+	relative, err := filepath.Rel(root, path)
+	return err == nil && (relative == "." || relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)) && !filepath.IsAbs(relative))
+}
+
+func compileOutputParent(task asmTask, pkg *packages.Package, feature *featureConsumer) (string, error) {
+	if task.OutLL == "" {
+		return "", compileOutputError()
+	}
+	parent, err := filepath.Abs(filepath.Dir(task.OutLL))
+	if err != nil {
+		return "", err
+	}
+	if err := os.MkdirAll(parent, 0755); err != nil {
+		return "", err
+	}
+	parent, err = sourcepath.Resolve(parent)
+	if err != nil {
+		return "", err
+	}
+	// Ordinary observations retain the complete module tree, not just selected
+	// sources. Put the same-filesystem stage outside every actual source root;
+	// adding an ignored directory inside that tree would weaken its inventory.
+	var roots []string
+	add := func(path string) {
+		if path == "" || err != nil {
+			return
+		}
+		var root string
+		root, err = sourcepath.Resolve(path)
+		if err == nil {
+			roots = append(roots, root)
+		}
+	}
+	if pkg != nil {
+		packages.Visit([]*packages.Package{pkg}, func(selected *packages.Package) bool {
+			add(selected.Dir)
+			if selected.Module != nil {
+				add(selected.Module.Dir)
+			}
+			return true
+		}, nil)
+	}
+	if feature != nil {
+		add(feature.Root)
+	}
+	if err != nil {
+		return "", err
+	}
+	for {
+		inside := false
+		for _, root := range roots {
+			inside = inside || outputPathWithin(parent, root)
+		}
+		if !inside {
+			return parent, nil
+		}
+		next := filepath.Dir(parent)
+		if next == parent {
+			return "", compileOutputError()
+		}
+		parent = next
+	}
+}
+
+func newCompileOutputStage(task asmTask, pkg *packages.Package, feature *featureConsumer) (*compileOutputStage, error) {
+	parent, err := compileOutputParent(task, pkg, feature)
+	if err != nil {
+		return nil, err
+	}
+	destinationParent, err := sourcepath.Resolve(filepath.Dir(task.OutLL))
+	if err != nil {
+		return nil, err
+	}
+	if err := sameOutputFilesystem(parent, destinationParent); err != nil {
+		return nil, err
+	}
+	directory, err := os.MkdirTemp(parent, ".plan9asm-output-")
+	if err != nil {
+		return nil, err
+	}
+	info, err := sourcepath.Lstat(directory)
+	if err != nil {
+		_ = os.Remove(directory) // Empty, unobserved node: never recursive cleanup.
+		return nil, err
+	}
+	return &compileOutputStage{directory: directory, info: info, names: make(map[string]bool), rename: os.Rename, removeAll: os.RemoveAll}, nil
+}
+
+func (stage *compileOutputStage) verifyDirectory() error {
+	info, err := sourcepath.Lstat(stage.directory)
+	if err != nil || !info.IsDir() || !os.SameFile(info, stage.info) {
+		return compileOutputError()
+	}
+	return nil
+}
+
+func (stage *compileOutputStage) stageTask(task asmTask, config compileConfig) (asmTask, error) {
+	// This is an output-namespace exclusion, not Go's source-selection grammar.
+	// Reserve case variants too: they may name an existing source on a
+	// case-insensitive filesystem, even when no CPP read retained that Go file.
+	if task.OutLL == "" || continuationReferenceName(strings.ToLower(filepath.Base(task.OutLL))) {
+		return asmTask{}, compileOutputError()
+	}
+	if err := stage.verifyDirectory(); err != nil {
+		return asmTask{}, err
+	}
+	staged := task
+	staged.OutLL = filepath.Join(stage.directory, filepath.Base(task.OutLL))
+	files := []compileOutputFile{{path: staged.OutLL, destination: task.OutLL}}
+	if config.Enabled {
+		files = append(files, compileOutputFile{path: strings.TrimSuffix(staged.OutLL, filepath.Ext(staged.OutLL)) + ".o",
+			destination: strings.TrimSuffix(task.OutLL, filepath.Ext(task.OutLL)) + ".o", deletion: !config.KeepObj})
+	}
+	for index := range files {
+		output := &files[index]
+		if stage.names[output.path] || index > 0 && output.path == files[0].path {
+			return asmTask{}, compileOutputError()
+		}
+		absolute, err := filepath.Abs(output.destination)
+		if err != nil {
+			return asmTask{}, err
+		}
+		parent := filepath.Dir(absolute)
+		physical, err := sourcepath.Resolve(parent)
+		if err != nil {
+			return asmTask{}, err
+		}
+		info, err := sourcepath.Lstat(parent)
+		if err != nil {
+			return asmTask{}, err
+		}
+		output.parent = assemblyMemberDirectory{path: parent, physical: physical, info: info}
+		output.parentTarget, err = sourcepath.Lstat(physical)
+		if err != nil || !output.parentTarget.IsDir() {
+			return asmTask{}, compileOutputError()
+		}
+		output.destination = filepath.Join(physical, filepath.Base(absolute))
+		output.previous, err = sourcepath.Lstat(output.destination)
+		if err != nil && !os.IsNotExist(err) {
+			return asmTask{}, err
+		}
+		if err := stage.verifyInputDestination(output.destination, output.previous); err != nil {
+			return asmTask{}, err
+		}
+		if output.previous != nil {
+			if !output.previous.Mode().IsRegular() {
+				return asmTask{}, compileOutputError()
+			}
+			output.previousDigest, err = gotoolprofile.FileSHA256(output.destination)
+			if err != nil {
+				return asmTask{}, err
+			}
+		}
+	}
+	for _, output := range files {
+		stage.names[output.path] = true
+	}
+	stage.outputs = append(stage.outputs, files...)
+	return staged, nil
+}
+
+func verifyOutputFile(path string, info os.FileInfo, digest string) error {
+	actual, err := sourcepath.Lstat(path)
+	if info == nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return compileOutputError()
+	}
+	if err != nil || !actual.Mode().IsRegular() || !os.SameFile(actual, info) {
+		return compileOutputError()
+	}
+	actualDigest, err := gotoolprofile.FileSHA256(path)
+	if err != nil || actualDigest != digest {
+		return compileOutputError()
+	}
+	return nil
+}
+
+func (output *compileOutputFile) verifyParent() error {
+	info, err := sourcepath.Lstat(output.parent.path)
+	if err != nil || !os.SameFile(info, output.parent.info) {
+		return compileOutputError()
+	}
+	physical, err := sourcepath.Resolve(output.parent.path)
+	if err != nil || physical != output.parent.physical {
+		return compileOutputError()
+	}
+	info, err = sourcepath.Lstat(physical)
+	if err != nil || !info.IsDir() || !os.SameFile(info, output.parentTarget) {
+		return compileOutputError()
+	}
+	return nil
+}
+
+func (stage *compileOutputStage) seal() error {
+	if err := stage.verifyDirectory(); err != nil {
+		return err
+	}
+	for index := stage.sealed; index < len(stage.outputs); index++ {
+		output := &stage.outputs[index]
+		if output.deletion {
+			if err := verifyOutputFile(output.path, nil, ""); err != nil {
+				return err
+			}
+			continue
+		}
+		info, err := sourcepath.Lstat(output.path)
+		if err != nil || !info.Mode().IsRegular() {
+			return compileOutputError()
+		}
+		digest, err := gotoolprofile.FileSHA256(output.path)
+		if err != nil {
+			return err
+		}
+		output.info, output.digest = info, digest
+	}
+	stage.sealed = len(stage.outputs)
+	return nil
+}
+
+func (stage *compileOutputStage) publish() error {
+	if err := stage.verifyInputs(); err != nil {
+		return err
+	}
+	if err := stage.verifyDirectory(); err != nil {
+		return err
+	}
+	if len(stage.outputs) == 0 || stage.sealed != len(stage.outputs) || stage.committed {
+		return compileOutputError()
+	}
+	for index := range stage.outputs {
+		output := &stage.outputs[index]
+		if err := errors.Join(stage.verifyInputDestination(output.destination, output.previous),
+			output.verifyParent(), verifyOutputFile(output.path, output.info, output.digest),
+			verifyOutputFile(output.destination, output.previous, output.previousDigest)); err != nil {
+			return err
+		}
+	}
+	for index := range stage.outputs {
+		output := &stage.outputs[index]
+		if err := errors.Join(stage.verifyInputs(), stage.verifyInputDestination(output.destination, output.previous),
+			stage.verifyDirectory(), output.verifyParent(),
+			verifyOutputFile(output.path, output.info, output.digest),
+			verifyOutputFile(output.destination, output.previous, output.previousDigest)); err != nil {
+			return errors.Join(err, stage.rollback())
+		}
+		if output.previous != nil {
+			// An absent backup name in the owned same-FS stage also permits
+			// Windows replacement without relying on overwrite-Rename behavior.
+			output.backup = filepath.Join(stage.directory, fmt.Sprintf("previous-%06d", index))
+			if err := stage.rename(output.destination, output.backup); err != nil {
+				return errors.Join(fmt.Errorf("backup compile output: %w", err), stage.rollback())
+			}
+			output.backupInfo = output.previous
+		}
+		if err := errors.Join(stage.verifyInputs(), stage.verifyInputDestination(output.destination, output.previous),
+			stage.verifyDirectory(), output.verifyParent(),
+			verifyOutputFile(output.path, output.info, output.digest),
+			verifyOutputFile(output.destination, nil, "")); err != nil {
+			return errors.Join(err, stage.rollback())
+		}
+		if output.deletion {
+			continue // Only this actual task's old object; never unrelated parts.
+		}
+		if err := stage.rename(output.path, output.destination); err != nil {
+			return errors.Join(fmt.Errorf("publish verified compile output: %w", err), stage.rollback())
+		}
+		output.published = true
+	}
+	stage.committed = true
+	return nil
+}
+
+func (stage *compileOutputStage) rollback() error {
+	if err := stage.verifyDirectory(); err != nil {
+		return fmt.Errorf("rollback compile output: %w", err)
+	}
+	var result error
+	for index := len(stage.outputs) - 1; index >= 0; index-- {
+		output := &stage.outputs[index]
+		if !output.published && output.backupInfo == nil {
+			continue
+		}
+		if err := output.verifyParent(); err != nil {
+			result = errors.Join(result, fmt.Errorf("rollback compile output: %w", err))
+			continue
+		}
+		if output.published {
+			if err := verifyOutputFile(output.destination, output.info, output.digest); err != nil {
+				result = errors.Join(result, fmt.Errorf("rollback compile output: %w", err))
+				continue
+			}
+			if err := stage.rename(output.destination, output.path); err != nil {
+				result = errors.Join(result, fmt.Errorf("rollback compile output: %w", err))
+				continue
+			}
+			output.published = false
+		}
+		if output.backupInfo != nil {
+			if err := errors.Join(verifyOutputFile(output.backup, output.backupInfo, output.previousDigest),
+				verifyOutputFile(output.destination, nil, "")); err != nil {
+				result = errors.Join(result, fmt.Errorf("restore previous compile output: %w", err))
+				continue
+			}
+			if err := stage.rename(output.backup, output.destination); err != nil {
+				result = errors.Join(result, fmt.Errorf("restore previous compile output: %w", err))
+				continue
+			}
+			output.backupInfo = nil
+		}
+	}
+	return result
+}
+
+func (stage *compileOutputStage) close() error {
+	if err := stage.verifyDirectory(); err != nil {
+		if stage.committed {
+			return fmt.Errorf("compile outputs committed; temporary cleanup failed: %w", err)
+		}
+		return err
+	}
+	// Never erase the only recoverable old output after a failed rollback.
+	for _, output := range stage.outputs {
+		if !stage.committed && output.backupInfo != nil {
+			return fmt.Errorf("unrestored compile output retained in owned stage %s", stage.directory)
+		}
+	}
+	err := stage.removeAll(stage.directory)
+	if err != nil && stage.committed {
+		return fmt.Errorf("compile outputs committed; temporary cleanup failed: %w", err)
+	}
+	return err
+}
diff --git a/cmd/plan9asmll/source_output_cpp_report_test.go b/cmd/plan9asmll/source_output_cpp_report_test.go
new file mode 100644
index 000000000..48b5a0e88
--- /dev/null
+++ b/cmd/plan9asmll/source_output_cpp_report_test.go
@@ -0,0 +1,58 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestFeatureCPPReadReportRetainsOnlyActiveSearchMisses(t *testing.T) {
+	root := t.TempDir()
+	physical, err := sourcepath.Resolve(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const source = "#include \"textflag.h\"\n#include \"local.inc\"\n#include \"go_asm.h\"\n#ifdef MISSING_INACTIVE\n#include \"inactive.inc\"\n#endif\nTEXT ·Leaf(SB),NOSPLIT,$0-0\nRET\n"
+	const local = "#define BIAS 7\n"
+	for name, data := range map[string]string{"p_amd64.s": source, "local.inc": local} {
+		if err := os.WriteFile(filepath.Join(root, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	tool := "pkg/include/textflag.h"
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(tool)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{Dir: physical, Root: runtime.GOROOT(), Input: &featureInput{
+		Sources:     map[string]string{"p_amd64.s": featureBytesSHA256([]byte(source)), "local.inc": featureBytesSHA256([]byte(local))},
+		ToolSources: map[string]string{tool: featureBytesSHA256(data)},
+	}}
+	// This controlled generated callback tests read inventory only. It makes no
+	// generated-header compiler, declaration, object, or native-frame claim.
+	header := func() ([]byte, error) { return []byte("#define Generated 7\n"), nil }
+	var report plan9asm.GoAssemblySourceReadReport
+	observed, inputs, err := consumer.preprocessCPPSource(filepath.Join(physical, "p_amd64.s"), "example.com/readreport", nil, header, false, &report)
+	plain, plainInputs, plainErr := consumer.preprocessCPPWithHeader(filepath.Join(physical, "p_amd64.s"), "example.com/readreport", nil, header)
+	if err != nil || plainErr != nil || !reflect.DeepEqual(observed, plain) || !reflect.DeepEqual(inputs, plainInputs) {
+		t.Fatalf("report altered existing registered CPP expansion: %v %v", err, plainErr)
+	}
+	want := []string{filepath.Join(physical, "textflag.h"), filepath.Join(physical, "go_asm.h")}
+	if !reflect.DeepEqual(report.SearchMisses, want) {
+		t.Fatalf("active actual resolver miss inventory differs: got=%v want=%v", report.SearchMisses, want)
+	}
+	files, err := compileCPPInputFiles(consumer, inputs)
+	if err != nil || len(files) != 3 {
+		t.Fatalf("actual module/tool reads lost or generated file invented: %v %v", files, err)
+	}
+	for _, file := range files {
+		if filepath.Base(file) == "go_asm.h" {
+			t.Fatal("in-memory generated header became a physical input")
+		}
+	}
+}
diff --git a/cmd/plan9asmll/source_output_input_test.go b/cmd/plan9asmll/source_output_input_test.go
new file mode 100644
index 000000000..c2d169c42
--- /dev/null
+++ b/cmd/plan9asmll/source_output_input_test.go
@@ -0,0 +1,542 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCompileOutputRejectsSourceExtensionCaseVariants(t *testing.T) {
+	for _, extension := range []string{".go", ".GO", ".Go", ".s", ".S", ".h", ".H"} {
+		t.Run(extension, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, false)
+			output := filepath.Join(filepath.Dir(task.OutLL), "original"+extension)
+			if _, err := stage.stageTask(asmTask{OutLL: output}, compileConfig{}); err == nil {
+				t.Fatal("reserved source extension became an output resource", output)
+			}
+		})
+	}
+}
+
+func TestCompileOneOutputCannotReplaceCaseVariantSelectedGoSource(t *testing.T) {
+	pkg, input := continuationPackage(t, continuationGo, continuationAsm)
+	if len(pkg.GoFiles) != 1 {
+		t.Fatalf("unexpected actual selected Go source inventory: %v", pkg.GoFiles)
+	}
+	selected := pkg.GoFiles[0]
+	original, err := os.ReadFile(selected)
+	if err != nil {
+		t.Fatal(err)
+	}
+	output := filepath.Join(filepath.Dir(selected), strings.ToUpper(filepath.Base(selected)))
+	config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+	if err == nil {
+		t.Fatal("case-variant Go source name became an output resource")
+	}
+	if after, err := os.ReadFile(selected); err != nil || string(after) != string(original) {
+		t.Fatalf("actual selected Go source was overwritten: %v", err)
+	}
+}
+
+func TestCompileOneOutputCannotReplaceOriginalModuleMetadata(t *testing.T) {
+	for _, name := range []string{"go.mod", "go.sum"} {
+		t.Run(name, func(t *testing.T) {
+			pkg, input := continuationPackage(t, continuationGo, continuationAsm)
+			output := filepath.Join(pkg.Dir, name)
+			if name == "go.sum" {
+				if err := os.WriteFile(output, nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			original, err := os.ReadFile(output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if err == nil {
+				t.Error("successful artifact publication overwrote original module metadata")
+			}
+			if after, err := os.ReadFile(output); err != nil || string(after) != string(original) {
+				t.Fatalf("original module metadata was changed: %q, %v", after, err)
+			}
+		})
+	}
+}
+
+func TestCompileOneOutputCannotCreateAbsentMetadataAlias(t *testing.T) {
+	pkg, selected := continuationPackage(t, continuationGo, continuationAsm)
+	module, err := os.Stat(filepath.Join(pkg.Dir, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias, aliasErr := os.Stat(filepath.Join(pkg.Dir, "GO.MOD"))
+	if aliasErr != nil && !os.IsNotExist(aliasErr) {
+		t.Fatal(aliasErr)
+	}
+	caseInsensitive := aliasErr == nil && os.SameFile(module, alias)
+	t.Logf("actual existing metadata case alias observed: %v", caseInsensitive)
+	missing := filepath.Join(pkg.Dir, "go.sum")
+	if _, err := os.Lstat(missing); !os.IsNotExist(err) {
+		t.Fatalf("fixture metadata was not absent: %v", err)
+	}
+	output := filepath.Join(pkg.Dir, "GO.SUM")
+	config := compileConfig{x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	err = compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: selected, OutLL: output}, false, config)
+	// Even a case-sensitive filesystem keeps a known same-parent metadata
+	// basename out of the artifact namespace. This is an explicit conservative
+	// potential-collision policy, not a claim that the names are OS-equal.
+	if err == nil || !strings.Contains(err.Error(), "potential metadata-name collision") {
+		t.Fatalf("known missing metadata basename became an output role: %v", err)
+	}
+	for _, path := range []string{missing, output} {
+		if _, err := os.Lstat(path); !os.IsNotExist(err) {
+			t.Fatalf("original missing metadata/output changed: %v", err)
+		}
+	}
+}
+
+func TestCompileOutputMetadataNameProtectionUsesActualParent(t *testing.T) {
+	for _, placement := range []string{"same-parent", "directory-alias", "distinct-parent"} {
+		t.Run(placement, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, false)
+			root := filepath.Dir(task.OutLL)
+			goMod := filepath.Join(root, "go.mod")
+			if err := os.WriteFile(goMod, []byte("original module metadata\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			pkg := &packages.Package{Module: &packages.Module{Dir: root, GoMod: goMod}}
+			if err := stage.protectInputs(pkg, nil, nil); err != nil {
+				t.Fatal(err)
+			}
+			parent := root
+			if placement == "directory-alias" {
+				parent = filepath.Join(t.TempDir(), "output-parent")
+				ordinaryLoadDirectoryAlias(t, parent, root)
+			} else if placement == "distinct-parent" {
+				parent = t.TempDir()
+			}
+			_, err := stage.stageTask(asmTask{OutLL: filepath.Join(parent, "GO.SUM")}, compileConfig{})
+			if placement == "distinct-parent" {
+				if err != nil {
+					t.Fatalf("independent actual parent acquired a metadata-name restriction: %v", err)
+				}
+			} else if err == nil || !strings.Contains(err.Error(), "potential metadata-name collision") {
+				t.Fatalf("same actual parent metadata spelling was not excluded: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneOutputCannotReplaceActualSelectedEmbed(t *testing.T) {
+	for _, extension := range []string{"ll", "o"} {
+		t.Run(extension, func(t *testing.T) {
+			const retained = "original actual Go embed contents\n"
+			name := "published." + extension
+			source := strings.Replace(continuationGo, "package p\n", "package p\nimport _ \"embed\"\n//go:embed "+name+"\nvar image string\n", 1)
+			pkg, selected := continuationPackageWithSources(t, source, continuationAsm, map[string]string{name: retained})
+			if pkg.Types.Scope().Lookup("image") == nil {
+				t.Fatal("actual complete Go loader did not typecheck the embedding source")
+			}
+			if len(pkg.EmbedFiles) != 1 || filepath.Base(pkg.EmbedFiles[0]) != name {
+				t.Fatalf("actual compiler selected embed inventory was not retained: %v", pkg.EmbedFiles)
+			}
+			config := compileConfig{Context: arm64PrivateCLIContext(t),
+				x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			if extension == "o" {
+				var err error
+				config, err = resolveCompileConfig(true, "", false, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				config.Context = arm64PrivateCLIContext(t)
+				config.x86CallerSelections = captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)
+			}
+			output := filepath.Join(pkg.Dir, "published.ll")
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: selected, OutLL: output}, false, config)
+			if err == nil {
+				t.Error("artifact publication overwrote/deleted actual Go embed input")
+			}
+			if data, err := os.ReadFile(filepath.Join(pkg.Dir, name)); err != nil || string(data) != retained {
+				t.Fatalf("actual Go embed input changed: %q %v", data, err)
+			}
+		})
+	}
+}
+
+func TestCompileOneLateSelectedEmbedReplacementDoesNotPublish(t *testing.T) {
+	const original = "actual original embedded bytes\n"
+	source := strings.Replace(continuationGo, "package p\n", "package p\nimport _ \"embed\"\n//go:embed image.bin\nvar image string\n", 1)
+	pkg, selected := continuationPackageWithSources(t, source, continuationAsm, map[string]string{"image.bin": original})
+	if len(pkg.EmbedFiles) != 1 || filepath.Base(pkg.EmbedFiles[0]) != "image.bin" {
+		t.Fatalf("actual selected embed was not retained: %v", pkg.EmbedFiles)
+	}
+	output := filepath.Join(pkg.Dir, "published.ll")
+	const previous = "previous verified output\n"
+	if err := os.WriteFile(output, []byte(previous), 0600); err != nil {
+		t.Fatal(err)
+	}
+	called := false
+	ctx := &continuationOutputCallbackContext{Context: context.Background(), directory: pkg.Dir, basename: filepath.Base(output)}
+	ctx.callback = func() {
+		called = true
+		filename := pkg.EmbedFiles[0]
+		if err := os.Rename(filename, filename+".original"); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filename, []byte(original), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	config := compileConfig{Context: ctx, x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+	err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: selected, OutLL: output}, false, config)
+	if !called || err == nil || !strings.Contains(err.Error(), "compile input") {
+		t.Fatalf("same-byte late embedded input replacement was ignored: called=%v error=%v", called, err)
+	}
+	if data, err := os.ReadFile(output); err != nil || string(data) != previous {
+		t.Fatalf("late embedded input replacement published output: %q %v", data, err)
+	}
+}
+
+func TestCompileOutputInputDirectoryAliasLifetime(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	owner := t.TempDir()
+	actual := filepath.Join(owner, "actual.inc")
+	if err := os.WriteFile(actual, []byte("original input"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "include-owner")
+	ordinaryLoadDirectoryAlias(t, alias, owner)
+	if err := stage.protectInputs(nil, []string{filepath.Join(alias, "actual.inc")}, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(alias, alias+".original"); err != nil {
+		t.Fatal(err)
+	}
+	ordinaryLoadDirectoryAlias(t, alias, owner) // Same target and bytes, new requested node.
+	if err := stage.publish(); err == nil || stage.committed {
+		t.Fatal("equal-target replacement of the original input directory alias was ignored")
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputRechecksOriginalInputsDuringPublication(t *testing.T) {
+	stage, task := compileOutputFixture(t, true)
+	root := filepath.Dir(task.OutLL)
+	actual, alias := filepath.Join(root, "actual.inc"), filepath.Join(root, "requested.inc")
+	if err := os.WriteFile(actual, []byte("previous output.o"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(actual, alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.protectInputs(nil, []string{alias, actual}, nil); err != nil {
+		t.Fatal(err)
+	}
+	first, second := &stage.outputs[0], &stage.outputs[1]
+	called := false
+	stage.rename = func(from, to string) error {
+		if from == first.path && to == first.destination && !called {
+			called = true
+			if err := os.Rename(alias, alias+".original"); err != nil {
+				return err
+			}
+			if err := os.Symlink(second.destination, alias); err != nil {
+				return err
+			}
+		}
+		return os.Rename(from, to)
+	}
+	if err := stage.publish(); !called || err == nil || stage.committed {
+		t.Fatalf("later output overwrote a newly redirected original input: called=%v error=%v", called, err)
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputInputIdentityExcludesEquivalentExistingName(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	input := filepath.Join(filepath.Dir(task.OutLL), "actually-read.inc")
+	if err := os.Link(task.OutLL, input); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.protectInputs(nil, []string{input}, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.publish(); err == nil || stage.committed {
+		t.Fatal("same actual input identity was accepted as an existing output resource")
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputInputProtectionAccumulatesAttemptMembers(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	first, second := filepath.Join(filepath.Dir(task.OutLL), "first.inc"), filepath.Join(filepath.Dir(task.OutLL), "second.inc")
+	for _, filename := range []string{first, second} {
+		if err := os.WriteFile(filename, []byte("actual include"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := stage.protectInputs(nil, []string{filename}, nil); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if _, err := stage.stageTask(asmTask{OutLL: first}, compileConfig{}); err == nil {
+		t.Fatal("a later chunk's input observation erased an earlier task's exclusion")
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputSuccessfullyReadInputCannotBecomeMissingRole(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	input := filepath.Join(filepath.Dir(task.OutLL), "original.inc")
+	if err := os.WriteFile(input, []byte("actually read input"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.ReadFile(input); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Remove(input); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.protectInputs(nil, []string{input}, nil); err == nil {
+		t.Fatal("successfully read original input was reclassified as absent metadata")
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputInputAliasLifetime(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	root := filepath.Dir(task.OutLL)
+	actual := filepath.Join(root, "actual.inc")
+	alias := filepath.Join(root, "requested.inc")
+	// Byte-identical to the unchanged, already observed public destination.
+	const retained = "previous output.ll"
+	if err := os.WriteFile(actual, []byte(retained), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(actual, alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.protectInputs(nil, []string{alias, actual}, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(alias, alias+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(task.OutLL, alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.publish(); err == nil || stage.committed {
+		t.Fatal("redirected input acquired an earlier allowed output destination")
+	}
+	requirePreviousCompileOutputs(t, task)
+}
+
+func TestCompileOutputSearchMissProtection(t *testing.T) {
+	for _, change := range []string{"new-preferred", "nested-preferred", "redirect-parent", "unchanged"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixtureWithConfig(t, compileConfig{Enabled: true, KeepObj: false})
+			root := filepath.Dir(task.OutLL)
+			miss := filepath.Join(root, "fallback.inc")
+			if change == "nested-preferred" {
+				miss = filepath.Join(root, "missing", "fallback.inc")
+			} else if change == "redirect-parent" {
+				alias := filepath.Join(t.TempDir(), "include-root")
+				ordinaryLoadDirectoryAlias(t, alias, root)
+				miss = filepath.Join(alias, "fallback.inc")
+			}
+			if err := stage.protectInputs(nil, nil, []string{miss}); err != nil {
+				t.Fatal(err)
+			}
+			if change == "unchanged" {
+				if err := stage.publish(); err != nil || !stage.committed {
+					t.Fatalf("unchanged fallback search incorrectly prevented output: %v", err)
+				}
+				return
+			}
+			if change == "new-preferred" || change == "nested-preferred" {
+				if err := os.MkdirAll(filepath.Dir(miss), 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(miss, []byte("same fallback bytes"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			} else if change == "redirect-parent" {
+				alias := filepath.Dir(miss)
+				if err := os.Rename(alias, alias+".original"); err != nil {
+					t.Fatal(err)
+				}
+				ordinaryLoadDirectoryAlias(t, alias, t.TempDir())
+			}
+			if err := stage.publish(); err == nil || stage.committed {
+				t.Fatal("changed preferred include search was ignored at publication")
+			}
+			requirePreviousCompileOutputs(t, task)
+		})
+	}
+}
+
+func TestCompileOutputSearchMissCannotBePublicDestination(t *testing.T) {
+	for _, test := range []struct {
+		object, alternateCase bool
+		name                  string
+	}{
+		{name: "ir"}, {object: true, name: "nonretained-object"},
+		{alternateCase: true, name: "ir-potential-case-alias"},
+		{object: true, alternateCase: true, name: "object-potential-case-alias"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			root := t.TempDir()
+			task := asmTask{OutLL: filepath.Join(root, "output.ll")}
+			stage, err := newCompileOutputStage(task, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := stage.close(); err != nil {
+					t.Error(err)
+				}
+			})
+			miss := task.OutLL
+			if test.object {
+				miss = filepath.Join(root, "output.o")
+			}
+			if test.alternateCase {
+				miss = filepath.Join(root, strings.ToUpper(filepath.Base(miss)))
+			}
+			if err := stage.protectInputs(nil, nil, []string{miss}); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := stage.stageTask(task, compileConfig{Enabled: test.object, KeepObj: false}); err == nil {
+				t.Fatal("publication could create/remove the preferred missing input")
+			}
+			if _, err := os.Lstat(miss); !os.IsNotExist(err) {
+				t.Fatalf("preferred missing input was changed: %v", err)
+			}
+		})
+	}
+}
+
+func TestCompileOneLateEqualByteIncludeRedirectDoesNotPublish(t *testing.T) {
+	for _, change := range []string{"redirect-output", "same-byte-node"} {
+		t.Run(change, func(t *testing.T) {
+			const retained = "// byte-identical original include and prior output\n"
+			pkg, selected := continuationPackageWithSources(t, continuationGo, "#include \"requested.inc\"\n"+continuationAsm,
+				map[string]string{"actual.inc": retained})
+			include := filepath.Join(pkg.Dir, "requested.inc")
+			actual := filepath.Join(pkg.Dir, "actual.inc")
+			if err := os.Symlink(actual, include); err != nil {
+				t.Fatal(err)
+			}
+			output := filepath.Join(pkg.Dir, "published.ll")
+			if err := os.WriteFile(output, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			called := false
+			ctx := &continuationOutputCallbackContext{Context: context.Background(), directory: pkg.Dir, basename: filepath.Base(output)}
+			ctx.callback = func() {
+				called = true
+				if change == "redirect-output" {
+					if err := os.Rename(include, include+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Symlink(output, include); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					if err := os.Rename(actual, actual+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(actual, []byte(retained), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			config := compileConfig{Context: ctx, x86CallerSelections: captureX86CallerSelections([]*packages.Package{pkg}, "linux/amd64", nil)}
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: selected, OutLL: output}, false, config)
+			if !called || err == nil || !strings.Contains(err.Error(), "compile input") {
+				t.Fatalf("equal-byte final input mutation was ignored: called=%v error=%v", called, err)
+			}
+			if data, err := os.ReadFile(output); err != nil || string(data) != retained {
+				t.Fatalf("input redirect changed old public output: %q %v", data, err)
+			}
+		})
+	}
+}
+
+func TestCompileOneTaskBuilderOutputCannotReplaceActualInclude(t *testing.T) {
+	for _, extension := range []string{"ll", "o"} {
+		for _, aliasOutput := range []bool{false, true} {
+			name := extension + "/physical"
+			if aliasOutput {
+				name = extension + "/directory-alias"
+			}
+			t.Run(name, func(t *testing.T) {
+				root := t.TempDir()
+				const packagePath = "example.com/collision"
+				directory := filepath.Join(root, filepath.FromSlash(packagePath))
+				if err := os.MkdirAll(directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				include := "kernel_amd64.s." + extension
+				const original = "#define BIAS 7\n"
+				assembly := "#include \"" + include + "\"\n" + strings.Replace(x86CallerCLIAssembly, "ADDL $7,AX", "ADDL $BIAS,AX", 1)
+				for filename, data := range map[string]string{
+					"go.mod": "module " + packagePath + "\n\ngo 1.20\n", "caller.go": x86CallerCLISource,
+					"kernel_amd64.s": assembly, include: original,
+				} {
+					if err := os.WriteFile(filepath.Join(directory, filename), []byte(data), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				t.Chdir(directory)
+				t.Setenv("GOENV", "off")
+				t.Setenv("GOWORK", "off")
+				t.Setenv("GOTOOLCHAIN", "local")
+				t.Setenv("CGO_ENABLED", "0")
+				t.Setenv("GOFLAGS", "")
+				selected, err := loadPkgs("linux", "amd64", []string{"."}, nil, packagePath, true, false)
+				if err != nil || len(selected) != 1 || len(selected[0].Errors) != 0 {
+					t.Fatalf("complete actual Go source selection: %v", err)
+				}
+				outputRoot := root
+				if aliasOutput {
+					outputRoot = filepath.Join(t.TempDir(), "output-root")
+					ordinaryLoadDirectoryAlias(t, outputRoot, root)
+				}
+				tasks, _ := collectAsmTasks(selected, outputRoot, nil)
+				if len(tasks) != 1 || filepath.Base(tasks[0].OutLL) != "kernel_amd64.s.ll" {
+					t.Fatalf("original public task builder did not select complete source: %+v", tasks)
+				}
+				config := compileConfig{Context: arm64PrivateCLIContext(t),
+					x86CallerSelections: captureX86CallerSelections(selected, "linux/amd64", nil)}
+				if extension == "o" {
+					config, err = resolveCompileConfig(true, "", false, 0)
+					if err != nil {
+						t.Fatal(err)
+					}
+					config.Context = arm64PrivateCLIContext(t)
+					config.x86CallerSelections = captureX86CallerSelections(selected, "linux/amd64", nil)
+				}
+				err = compileOne(selected[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", tasks[0], false, config)
+				if err == nil {
+					t.Error("public task publication replaced/deleted original assembler include")
+				}
+				if after, err := os.ReadFile(filepath.Join(directory, include)); err != nil || string(after) != original {
+					t.Fatalf("actual include was replaced/deleted: %q %v", after, err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmll/source_output_inputs.go b/cmd/plan9asmll/source_output_inputs.go
new file mode 100644
index 000000000..3517390ec
--- /dev/null
+++ b/cmd/plan9asmll/source_output_inputs.go
@@ -0,0 +1,323 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+type compileOutputInput struct {
+	path, physical string
+	node, target   os.FileInfo
+}
+
+type compileOutputInputDirectory struct {
+	path, physical string
+	node, target   os.FileInfo
+}
+
+type compileOutputInputName struct {
+	path, role string
+}
+
+type compileOutputSearchMiss struct {
+	path, physical, ancestor, ancestorTarget string
+	node, target                             os.FileInfo
+}
+
+// Resolve an absent name through its nearest existing ancestor. A missing
+// intermediate directory is not an error or an invented successfully read file.
+func compileOutputMissingPath(filename string) (physical, ancestor, target string, err error) {
+	filename, err = filepath.Abs(filename)
+	if err != nil {
+		return "", "", "", err
+	}
+	ancestor = filepath.Dir(filename)
+	for {
+		target, err = sourcepath.Resolve(ancestor)
+		if err == nil {
+			var relative string
+			relative, err = filepath.Rel(ancestor, filename)
+			return filepath.Join(target, relative), ancestor, target, err
+		}
+		if !os.IsNotExist(err) || filepath.Dir(ancestor) == ancestor {
+			return "", "", "", err
+		}
+		ancestor = filepath.Dir(ancestor)
+	}
+}
+
+func (stage *compileOutputStage) verifyInputs() error {
+	for _, directory := range stage.inputDirectories {
+		physical, err := sourcepath.Resolve(directory.path)
+		if err != nil || physical != directory.physical {
+			return fmt.Errorf("compile input directory path changed before publication")
+		}
+		node, err := sourcepath.Lstat(directory.path)
+		if err != nil || !os.SameFile(node, directory.node) {
+			return fmt.Errorf("compile input directory node changed before publication")
+		}
+		target, err := sourcepath.Lstat(physical)
+		if err != nil || !os.SameFile(target, directory.target) {
+			return fmt.Errorf("compile input directory target changed before publication")
+		}
+	}
+	for _, input := range stage.inputNodes {
+		physical, err := sourcepath.Resolve(input.path)
+		if err != nil || physical != input.physical {
+			return fmt.Errorf("compile input path changed before publication")
+		}
+		node, err := sourcepath.Lstat(input.path)
+		if err != nil || !os.SameFile(node, input.node) {
+			return fmt.Errorf("compile input node changed before publication")
+		}
+		target, err := sourcepath.Lstat(physical)
+		if err != nil || !os.SameFile(target, input.target) {
+			return fmt.Errorf("compile input target changed before publication")
+		}
+	}
+	for _, miss := range stage.inputMisses {
+		if _, err := sourcepath.Resolve(miss.path); !os.IsNotExist(err) {
+			return fmt.Errorf("compile preferred include is no longer absent")
+		}
+		physical, _, _, err := compileOutputMissingPath(miss.path)
+		if err != nil || physical != miss.physical {
+			return fmt.Errorf("compile preferred include path changed before publication")
+		}
+		target, err := sourcepath.Resolve(miss.ancestor)
+		if err != nil || target != miss.ancestorTarget {
+			return fmt.Errorf("compile include search ancestor changed before publication")
+		}
+		node, err := sourcepath.Lstat(miss.ancestor)
+		if err != nil || !os.SameFile(node, miss.node) {
+			return fmt.Errorf("compile include search node changed before publication")
+		}
+		info, err := sourcepath.Lstat(target)
+		if err != nil || !os.SameFile(info, miss.target) {
+			return fmt.Errorf("compile include search target changed before publication")
+		}
+	}
+	return nil
+}
+
+// Protect actual source and module metadata names, including alternate-extension
+// files consumed by the existing plain/registered CPP producer. This is solely
+// an output exclusion: package fields and input reports confer no source role.
+func (stage *compileOutputStage) protectInputs(pkg *packages.Package, actual, misses []string) error {
+	if stage.inputs == nil {
+		stage.inputs = make(map[string]bool)
+		stage.inputSeenNames = make(map[string]bool)
+		stage.inputSeenDirs = make(map[string]bool)
+	}
+	// A whole attempt owns all chunks. Keep the first identity and deduplicate
+	// repeated observations instead of refreshing a changed node or retaining
+	// another copy of the same complete source graph for every part.
+	seen, seenDirectories := stage.inputSeenNames, stage.inputSeenDirs
+	observeDirectories := func(directory string) error {
+		for ; ; directory = filepath.Dir(directory) {
+			if !seenDirectories[directory] {
+				physical, err := sourcepath.Resolve(directory)
+				if err != nil {
+					return err
+				}
+				node, err := sourcepath.Lstat(directory)
+				if err != nil {
+					return err
+				}
+				target, err := sourcepath.Lstat(physical)
+				if err != nil || !target.IsDir() {
+					return fmt.Errorf("compile input directory is missing or redirected: %v", err)
+				}
+				stage.inputDirectories = append(stage.inputDirectories, compileOutputInputDirectory{directory, physical, node, target})
+				seenDirectories[directory] = true
+			}
+			if filepath.Dir(directory) == directory {
+				break
+			}
+		}
+		return nil
+	}
+	add := func(filename string, allowAbsent bool) error {
+		if filename == "" || seen[filename] {
+			return nil
+		}
+		seen[filename] = true
+		physical, err := sourcepath.Resolve(filename)
+		if os.IsNotExist(err) {
+			if !allowAbsent {
+				return fmt.Errorf("compile original input disappeared before publication: %w", err)
+			}
+			// Metadata may be absent (go.sum); its exact physical parent and
+			// basename are still not an output location for this source task.
+			physical, _, _, err = compileOutputMissingPath(filename)
+			if err != nil {
+				return err
+			}
+		} else if err != nil {
+			return err
+		} else {
+			if err := observeDirectories(filepath.Dir(filename)); err != nil {
+				return err
+			}
+			node, err := sourcepath.Lstat(filename)
+			if err != nil {
+				return err
+			}
+			target, err := sourcepath.Lstat(physical)
+			if err != nil {
+				return err
+			}
+			stage.inputNodes = append(stage.inputNodes, compileOutputInput{filename, physical, node, target})
+		}
+		stage.inputs[physical] = true
+		return nil
+	}
+	for _, filename := range actual {
+		if err := add(filename, false); err != nil {
+			return err
+		}
+	}
+	for _, filename := range misses {
+		if filename == "" || seen[filename] {
+			continue
+		}
+		seen[filename] = true
+		if _, err := sourcepath.Resolve(filename); !os.IsNotExist(err) {
+			return fmt.Errorf("compile preferred include lacks its original search miss")
+		}
+		physical, ancestor, target, err := compileOutputMissingPath(filename)
+		if err != nil {
+			return err
+		}
+		if err := observeDirectories(ancestor); err != nil {
+			return err
+		}
+		node, err := sourcepath.Lstat(ancestor)
+		if err != nil {
+			return err
+		}
+		info, err := sourcepath.Lstat(target)
+		if err != nil {
+			return err
+		}
+		stage.inputs[physical] = true
+		stage.inputMisses = append(stage.inputMisses, compileOutputSearchMiss{filename, physical, ancestor, target, node, info})
+		stage.reserveInputName(filename, "preferred include")
+	}
+	var result error
+	if pkg != nil {
+		packages.Visit([]*packages.Package{pkg}, func(selected *packages.Package) bool {
+			if result != nil {
+				return false
+			}
+			for _, group := range [][]string{selected.GoFiles, selected.CompiledGoFiles, selected.OtherFiles, selected.EmbedFiles} {
+				for _, filename := range group {
+					if continuationReferenceName(filepath.Base(filename)) {
+						continue // Those source names are already unconditionally excluded.
+					}
+					if result = add(filename, false); result != nil {
+						return false
+					}
+				}
+			}
+			if selected.Module != nil {
+				metadata := []string{selected.Module.GoMod}
+				if selected.Module.Dir != "" {
+					metadata = append(metadata, filepath.Join(selected.Module.Dir, "go.sum"))
+				}
+				for _, filename := range metadata {
+					if filename != "" {
+						if result = observeDirectories(filepath.Dir(filename)); result != nil {
+							return false
+						}
+						stage.reserveInputName(filename, "metadata")
+					}
+					if result = add(filename, filepath.Base(filename) == "go.sum"); result != nil {
+						return false
+					}
+				}
+			}
+			return true
+		}, nil)
+	}
+	return result
+}
+
+func (stage *compileOutputStage) reserveInputName(filename, role string) {
+	if stage.inputNameKeys == nil {
+		stage.inputNameKeys = make(map[string]bool)
+	}
+	key := role + "\x00" + filename
+	if !stage.inputNameKeys[key] {
+		stage.inputNames = append(stage.inputNames, compileOutputInputName{filename, role})
+		stage.inputNameKeys[key] = true
+	}
+}
+
+func (stage *compileOutputStage) verifyInputDestination(destination string, previous os.FileInfo) error {
+	conflict := stage.inputs[destination]
+	// Exact observed identity covers an existing filesystem alias as well as
+	// its spelling. Never use case folding to guess a case-insensitive route.
+	// An existing hard-linked input is conservatively not an output resource.
+	if previous != nil {
+		for _, input := range stage.inputNodes {
+			conflict = conflict || os.SameFile(previous, input.target)
+		}
+	}
+	if conflict {
+		return fmt.Errorf("compile output would replace or remove an original input: %s", destination)
+	}
+	for _, name := range stage.inputNames {
+		// This is a conservative output-name policy for known original
+		// metadata/search roles, not a claim that case-equivalent paths are
+		// equal. Only a proved same actual parent can create this conflict.
+		if !strings.EqualFold(filepath.Base(destination), filepath.Base(name.path)) {
+			continue
+		}
+		parent, err := sourcepath.Resolve(filepath.Dir(name.path))
+		if os.IsNotExist(err) {
+			continue // The already existing output parent cannot be this directory.
+		}
+		if err != nil {
+			return err
+		}
+		inputParent, err := sourcepath.Lstat(parent)
+		if err != nil {
+			return err
+		}
+		outputParent, err := sourcepath.Lstat(filepath.Dir(destination))
+		if err != nil {
+			return err
+		}
+		if os.SameFile(inputParent, outputParent) {
+			return fmt.Errorf("potential %s-name collision with original input: %s", name.role, destination)
+		}
+	}
+	return nil
+}
+
+func compileCPPInputFiles(feature *featureConsumer, inputs map[string]string) ([]string, error) {
+	var files []string
+	for name := range inputs {
+		role, relative, found := strings.Cut(name, "/")
+		if !found || !filepath.IsLocal(filepath.FromSlash(relative)) {
+			return nil, fmt.Errorf("compile CPP input has an invalid producer name")
+		}
+		switch role {
+		case "module":
+			files = append(files, filepath.Join(feature.Dir, filepath.FromSlash(relative)))
+		case "tool":
+			files = append(files, filepath.Join(feature.Root, filepath.FromSlash(relative)))
+		case "generated":
+			// The actual generated-header producer returns memory, not a
+			// physical file; it cannot be replaced by an artifact rename.
+		default:
+			return nil, fmt.Errorf("compile CPP input has an unknown producer role")
+		}
+	}
+	return files, nil
+}
diff --git a/cmd/plan9asmll/source_output_other.go b/cmd/plan9asmll/source_output_other.go
new file mode 100644
index 000000000..8a156fa9b
--- /dev/null
+++ b/cmd/plan9asmll/source_output_other.go
@@ -0,0 +1,14 @@
+//go:build !unix
+
+package main
+
+import "path/filepath"
+
+func sameOutputFilesystem(stage, destination string) error {
+	// Both names were resolved through the opened physical-path observer;
+	// junctions cannot hide a different Windows destination volume here.
+	if filepath.VolumeName(stage) != filepath.VolumeName(destination) {
+		return compileOutputError()
+	}
+	return nil
+}
diff --git a/cmd/plan9asmll/source_output_test.go b/cmd/plan9asmll/source_output_test.go
new file mode 100644
index 000000000..dbe6f70db
--- /dev/null
+++ b/cmd/plan9asmll/source_output_test.go
@@ -0,0 +1,125 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCompileOneCallerLateSourceGuardDoesNotPublish(t *testing.T) {
+	pkg, _, config := x86CallerCLILoad(t, nil)
+	output := filepath.Join(pkg.Dir, "published.ll")
+	const retained = "previous verified output\n"
+	if err := os.WriteFile(output, []byte(retained), 0600); err != nil {
+		t.Fatal(err)
+	}
+	called := false
+	ctx := &continuationOutputCallbackContext{Context: context.Background(), directory: pkg.Dir, basename: filepath.Base(output), callback: func() {
+		called = true
+		if err := os.WriteFile(filepath.Join(pkg.Dir, "caller.go"), []byte(x86CallerCLISource+"\n// late source replacement\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}}
+	config.Context = ctx
+	err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkg.PkgPath, AsmFile: filepath.Join(pkg.Dir, "kernel_amd64.s"), OutLL: output}, false, config)
+	if !called || err == nil {
+		t.Fatalf("actual caller guard did not observe late source change: called=%v error=%v", called, err)
+	}
+	if errors.Is(err, context.Canceled) {
+		t.Fatalf("ordinary changed source was mislabeled cancellation: %v", err)
+	}
+	if data, err := os.ReadFile(output); err != nil || string(data) != retained {
+		t.Fatalf("late caller rejection overwrote retained public output: %v", err)
+	}
+}
+
+func TestCompileOneARM64TailLateSourceGuardDoesNotPublish(t *testing.T) {
+	directory := arm64ABI0TailCLIFixture(t)
+	t.Chdir(directory)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	selected, err := loadPkgs("linux", "arm64", []string{"."}, nil, "example.com/abi0tail", true, false)
+	if err != nil || len(selected) != 1 {
+		t.Fatalf("actual complete Go selection: %v", err)
+	}
+	output := filepath.Join(directory, "retained.ll")
+	const retained = "previous verified ARM64 output\n"
+	if err := os.WriteFile(output, []byte(retained), 0600); err != nil {
+		t.Fatal(err)
+	}
+	called := false
+	ctx := &continuationOutputCallbackContext{Context: arm64PrivateCLIContext(t), directory: directory, basename: filepath.Base(output), callback: func() {
+		called = true
+		if err := os.WriteFile(filepath.Join(directory, "p.go"), []byte("package p\nfunc Slots(value uint64) (out uint64)\n// late replacement\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}}
+	config := compileConfig{Context: ctx, x86CallerSelections: captureX86CallerSelections(selected, "linux/arm64", nil)}
+	err = compileOne(selected[0], plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{PkgPath: selected[0].PkgPath, AsmFile: filepath.Join(directory, "p_arm64.s"), OutLL: output}, false, config)
+	if !called || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("late ARM64 source guard not reached: called=%v error=%v", called, err)
+	}
+	if data, err := os.ReadFile(output); err != nil || string(data) != retained {
+		t.Fatalf("late ARM64 guard changed public output: %q %v", data, err)
+	}
+}
+
+func TestCompileOneFixedLocalLateOwnerGuardDoesNotPublish(t *testing.T) {
+	for _, change := range []string{"source", "owned-directory"} {
+		t.Run(change, func(t *testing.T) {
+			private := t.TempDir()
+			t.Setenv("TMPDIR", private)
+			pkg, input, config := amd64FixedLocalCLIFixture(t, "PADDL 16(SP),X0")
+			output := filepath.Join(t.TempDir(), "retained.ll")
+			const retained = "previous verified fixed-local output\n"
+			if err := os.WriteFile(output, []byte(retained), 0600); err != nil {
+				t.Fatal(err)
+			}
+			called := false
+			config.Context = &continuationOutputCallbackContext{Context: config.Context,
+				directory: filepath.Dir(output), basename: filepath.Base(output), callback: func() {
+					called = true
+					if change == "source" {
+						if err := os.WriteFile(filepath.Join(pkg.Dir, "value.go"), []byte("package fixedlocal\nfunc Value(a, b, c, d uint64) uint64\n// late replacement\n"), 0600); err != nil {
+							t.Fatal(err)
+						}
+						return
+					}
+					owned, err := filepath.Glob(filepath.Join(private, "plan9asm-go-frame-object-*"))
+					if err != nil || len(owned) != 1 {
+						t.Fatalf("actual frame artifact owner missing: %v %v", owned, err)
+					}
+					if err := os.Rename(owned[0], owned[0]+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Mkdir(owned[0], 0700); err != nil {
+						t.Fatal(err)
+					}
+				}}
+			// IR-only still consumes the complete original native frame objects;
+			// the external LLVM object axis is covered by the original class.
+			config.Enabled = false
+			err := compileOne(pkg, plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkg.PkgPath, AsmFile: input, OutLL: output}, false, config)
+			if !called || err == nil {
+				t.Fatalf("late fixed-local owner guard not reached: called=%v error=%v", called, err)
+			}
+			if change == "owned-directory" && !strings.Contains(err.Error(), "artifact directory") {
+				t.Fatalf("actual owner cleanup cause lost: %v", err)
+			}
+			if data, err := os.ReadFile(output); err != nil || string(data) != retained {
+				t.Fatalf("late source/owner failure changed public output: %q %v", data, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/source_output_transaction_test.go b/cmd/plan9asmll/source_output_transaction_test.go
new file mode 100644
index 000000000..c7959d6c4
--- /dev/null
+++ b/cmd/plan9asmll/source_output_transaction_test.go
@@ -0,0 +1,422 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func compileOutputFixture(t *testing.T, objects bool) (*compileOutputStage, asmTask) {
+	t.Helper()
+	return compileOutputFixtureWithConfig(t, compileConfig{Enabled: objects, KeepObj: objects})
+}
+
+func compileOutputFixtureWithConfig(t *testing.T, config compileConfig) (*compileOutputStage, asmTask) {
+	t.Helper()
+	owner := t.TempDir()
+	task := asmTask{OutLL: filepath.Join(owner, "output.ll")}
+	for _, name := range []string{"output.ll", "output.o"} {
+		if err := os.WriteFile(filepath.Join(owner, name), []byte("previous "+name), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	stage, err := newCompileOutputStage(task, &packages.Package{Dir: owner, Module: &packages.Module{Dir: owner}}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := stage.close(); err != nil {
+			t.Error(err)
+		}
+	})
+	staged, err := stage.stageTask(task, config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if outputPathWithin(stage.directory, owner) {
+		t.Fatal("output stage entered complete source inventory")
+	}
+	for _, output := range stage.outputs {
+		if output.deletion {
+			continue
+		}
+		if err := os.WriteFile(output.path, []byte("new "+filepath.Base(output.destination)), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if staged.OutLL == task.OutLL {
+		t.Fatal("task did not receive private stage")
+	}
+	if err := stage.seal(); err != nil {
+		t.Fatal(err)
+	}
+	return stage, task
+}
+
+func requirePreviousCompileOutputs(t *testing.T, task asmTask) {
+	t.Helper()
+	for _, name := range []string{"output.ll", "output.o"} {
+		data, err := os.ReadFile(filepath.Join(filepath.Dir(task.OutLL), name))
+		if err != nil || string(data) != "previous "+name {
+			t.Fatalf("retained %s changed: %q, %v", name, data, err)
+		}
+	}
+}
+
+func TestCompileOutputTransactionSealedInputs(t *testing.T) {
+	for _, change := range []string{"bytes", "same-byte-node", "destination-bytes", "destination-node"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, false)
+			filename := stage.outputs[0].path
+			if strings.HasPrefix(change, "destination") {
+				filename = task.OutLL
+			}
+			bytes, err := os.ReadFile(filename)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.HasSuffix(change, "node") {
+				if err := os.Rename(filename, filename+".original"); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				bytes = append(bytes, 'x')
+			}
+			if err := os.WriteFile(filename, bytes, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := stage.publish(); err == nil {
+				t.Fatal("changed output node/bytes was published")
+			}
+			if !strings.HasPrefix(change, "destination") {
+				requirePreviousCompileOutputs(t, task)
+			}
+		})
+	}
+}
+
+func TestCompileOutputTransactionRollbackAndRestoreFailure(t *testing.T) {
+	for _, restoreFailure := range []bool{false, true} {
+		t.Run(map[bool]string{false: "rollback", true: "restore-failure"}[restoreFailure], func(t *testing.T) {
+			stage, task := compileOutputFixture(t, true)
+			publishFault, restoreFault := errors.New("actual second publish failure"), errors.New("actual backup restore failure")
+			first := &stage.outputs[0]
+			second := &stage.outputs[1]
+			stage.rename = func(from, to string) error {
+				if from == second.path && to == second.destination {
+					return publishFault
+				}
+				if restoreFailure && from == first.backup && to == first.destination {
+					return restoreFault
+				}
+				return os.Rename(from, to)
+			}
+			err := stage.publish()
+			if !errors.Is(err, publishFault) || stage.committed {
+				t.Fatalf("partial publication did not fail: %v", err)
+			}
+			if restoreFailure {
+				if !errors.Is(err, restoreFault) || stage.close() == nil {
+					t.Fatalf("unrestored backup was lost/misreported: %v", err)
+				}
+				if data, err := os.ReadFile(first.backup); err != nil || string(data) != "previous output.ll" {
+					t.Fatalf("recoverable old bytes lost: %q, %v", data, err)
+				}
+				stage.rename = os.Rename
+				if err := stage.rollback(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			requirePreviousCompileOutputs(t, task)
+		})
+	}
+}
+
+func TestCompileOutputTransactionCommittedCleanupIsExplicit(t *testing.T) {
+	stage, task := compileOutputFixture(t, true)
+	if err := stage.publish(); err != nil {
+		t.Fatal(err)
+	}
+	cleanupFault := errors.New("owned stage cleanup failure")
+	stage.removeAll = func(string) error { return cleanupFault }
+	err := stage.close()
+	if !errors.Is(err, cleanupFault) || !strings.Contains(err.Error(), "outputs committed") {
+		t.Fatalf("pure committed cleanup failure mislabeled: %v", err)
+	}
+	for _, name := range []string{"output.ll", "output.o"} {
+		data, err := os.ReadFile(filepath.Join(filepath.Dir(task.OutLL), name))
+		if err != nil || string(data) != "new "+name {
+			t.Fatalf("committed output missing: %q %v", data, err)
+		}
+	}
+	stage.removeAll = os.RemoveAll
+}
+
+func TestCompileOutputTransactionDirectoryIdentity(t *testing.T) {
+	for _, change := range []string{"destination-parent", "stage"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, false)
+			directory := filepath.Dir(task.OutLL)
+			if change == "stage" {
+				directory = stage.directory
+			}
+			original := directory + ".original"
+			if err := os.Rename(directory, original); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Mkdir(directory, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if err := stage.publish(); err == nil {
+				t.Fatal("replaced output directory acquired publication")
+			}
+			if change == "stage" && stage.close() == nil {
+				t.Fatal("replacement stage directory recursively cleaned")
+			}
+			if _, err := os.Stat(directory); err != nil {
+				t.Fatalf("replacement directory was removed: %v", err)
+			}
+			if err := os.Remove(directory); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Rename(original, directory); err != nil {
+				t.Fatal(err)
+			}
+			requirePreviousCompileOutputs(t, task)
+		})
+	}
+}
+
+func TestCompileOutputTransactionRechecksLaterMembers(t *testing.T) {
+	for _, change := range []string{"later-stage", "later-destination"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, true)
+			first, second := &stage.outputs[0], &stage.outputs[1]
+			called := false
+			stage.rename = func(from, to string) error {
+				err := os.Rename(from, to)
+				if err == nil && !called && from == first.path && to == first.destination {
+					called = true
+					filename := second.path
+					if change == "later-destination" {
+						filename = second.destination
+					}
+					data, err := os.ReadFile(filename)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Rename(filename, filename+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filename, data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return err
+			}
+			if err := stage.publish(); err == nil || !called || stage.committed {
+				t.Fatalf("later same-byte member replaced after initial validation: called=%v, %v", called, err)
+			}
+			requirePreviousCompileOutputs(t, task)
+		})
+	}
+}
+
+func TestCompileOutputTransactionRejectsRedirectedDestinations(t *testing.T) {
+	for _, change := range []string{"directory", "file-symlink", "directory-alias"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixture(t, false)
+			if change == "directory-alias" {
+				alias := filepath.Join(t.TempDir(), "output-owner")
+				ordinaryLoadDirectoryAlias(t, alias, filepath.Dir(task.OutLL))
+				otherTask := task
+				otherTask.OutLL = filepath.Join(alias, "other.ll")
+				if _, err := stage.stageTask(otherTask, compileConfig{}); err != nil {
+					t.Fatal(err)
+				}
+				other := &stage.outputs[1]
+				if err := os.WriteFile(other.path, []byte("new other.ll"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := stage.seal(); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(alias, alias+".original"); err != nil {
+					t.Fatal(err)
+				}
+				ordinaryLoadDirectoryAlias(t, alias, t.TempDir())
+			} else {
+				if err := os.Rename(task.OutLL, task.OutLL+".original"); err != nil {
+					t.Fatal(err)
+				}
+				if change == "directory" {
+					if err := os.Mkdir(task.OutLL, 0700); err != nil {
+						t.Fatal(err)
+					}
+				} else if err := os.Symlink(task.OutLL+".original", task.OutLL); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := stage.publish(); err == nil || stage.committed {
+				t.Fatal("redirected destination acquired publication")
+			}
+		})
+	}
+}
+
+func TestCompileOutputStageOwnsWholeAndChunkTasks(t *testing.T) {
+	stage, task := compileOutputFixture(t, true)
+	part := task
+	part.OutLL = strings.TrimSuffix(task.OutLL, ".ll") + ".part-0001.ll"
+	staged, err := stage.stageTask(part, compileConfig{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if filepath.Dir(staged.OutLL) != stage.directory || len(stage.outputs) != 3 {
+		t.Fatal("chunk did not borrow the whole attempt transaction")
+	}
+	if err := stage.publish(); err == nil {
+		t.Fatal("unsealed chunk permitted even temporary public changes")
+	}
+	requirePreviousCompileOutputs(t, task)
+	if err := os.WriteFile(staged.OutLL, []byte("new chunk"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.seal(); err != nil {
+		t.Fatal(err)
+	}
+	if err := stage.publish(); err != nil {
+		t.Fatal(err)
+	}
+	if data, err := os.ReadFile(part.OutLL); err != nil || string(data) != "new chunk" {
+		t.Fatalf("sealed whole+chunk not committed: %q %v", data, err)
+	}
+}
+
+func TestCompileOutputStageOutsideCompleteModuleAndDependencyRoots(t *testing.T) {
+	module := t.TempDir()
+	owner := filepath.Join(module, "subpackage")
+	if err := os.Mkdir(owner, 0700); err != nil {
+		t.Fatal(err)
+	}
+	dependency := t.TempDir()
+	pkg := &packages.Package{Dir: owner, Module: &packages.Module{Dir: module},
+		Imports: map[string]*packages.Package{"dependency": {Dir: dependency}}}
+	for _, outputDirectory := range []string{owner, dependency} {
+		task := asmTask{OutLL: filepath.Join(outputDirectory, "output.ll")}
+		stage, err := newCompileOutputStage(task, pkg, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if outputPathWithin(stage.directory, module) || outputPathWithin(stage.directory, dependency) {
+			t.Fatal("private stage entered complete source/foreign dependency tree")
+		}
+		if err := sameOutputFilesystem(filepath.Dir(stage.directory), outputDirectory); err != nil {
+			t.Fatal("same-source filesystem was not preserved", err)
+		}
+		if err := stage.close(); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestCompileOutputTransactionNonretainedObjectPolicy(t *testing.T) {
+	for _, change := range []string{"success", "new-object", "rollback-deletion"} {
+		t.Run(change, func(t *testing.T) {
+			stage, task := compileOutputFixtureWithConfig(t, compileConfig{Enabled: true})
+			future := strings.TrimSuffix(task.OutLL, ".ll") + ".part-9999.o"
+			if err := os.WriteFile(future, []byte("unrelated historical part"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if change == "new-object" {
+				object := stage.outputs[1].destination
+				if err := os.Rename(object, object+".original"); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(object, []byte("new external object"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := stage.publish(); err == nil {
+					t.Fatal("new unobserved object was deleted")
+				}
+				if data, err := os.ReadFile(object); err != nil || string(data) != "new external object" {
+					t.Fatalf("new object not preserved: %q, %v", data, err)
+				}
+			} else if change == "rollback-deletion" {
+				part := task
+				part.OutLL = strings.TrimSuffix(task.OutLL, ".ll") + ".part-0001.ll"
+				staged, err := stage.stageTask(part, compileConfig{})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(staged.OutLL, []byte("new part"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := stage.seal(); err != nil {
+					t.Fatal(err)
+				}
+				fault := errors.New("actual later chunk publish failure")
+				stage.rename = func(from, to string) error {
+					if from == staged.OutLL {
+						return fault
+					}
+					return os.Rename(from, to)
+				}
+				if err := stage.publish(); !errors.Is(err, fault) {
+					t.Fatalf("later failure missing: %v", err)
+				}
+				requirePreviousCompileOutputs(t, task)
+				if _, err := os.Stat(part.OutLL); !os.IsNotExist(err) {
+					t.Fatalf("failed later chunk leaked: %v", err)
+				}
+			} else {
+				if err := stage.publish(); err != nil {
+					t.Fatal(err)
+				}
+				if _, err := os.Stat(stage.outputs[1].destination); !os.IsNotExist(err) {
+					t.Fatalf("successful nonretained object remained: %v", err)
+				}
+			}
+			if data, err := os.ReadFile(future); err != nil || string(data) != "unrelated historical part" {
+				t.Fatalf("unrelated part changed: %q, %v", data, err)
+			}
+		})
+	}
+}
+
+func TestCompileOutputTransactionRollbackDoesNotReplaceConcurrentOutput(t *testing.T) {
+	stage, task := compileOutputFixture(t, false)
+	output := &stage.outputs[0]
+	stage.rename = func(from, to string) error {
+		err := os.Rename(from, to)
+		if err == nil && from == output.destination && to == output.backup {
+			if err := os.WriteFile(output.destination, []byte("new external writer"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		return err
+	}
+	if err := stage.publish(); err == nil || stage.committed || stage.close() == nil {
+		t.Fatalf("concurrent destination overwritten or old backup lost: %v", err)
+	}
+	if data, err := os.ReadFile(task.OutLL); err != nil || string(data) != "new external writer" {
+		t.Fatalf("unobserved external writer overwritten: %q, %v", data, err)
+	}
+	if data, err := os.ReadFile(output.backup); err != nil || string(data) != "previous output.ll" {
+		t.Fatalf("recoverable original bytes missing: %q, %v", data, err)
+	}
+	// Only the test owner removes its own concurrent replacement, then retries
+	// restoration through the original captured identities before cleanup.
+	if err := os.Remove(output.destination); err != nil {
+		t.Fatal(err)
+	}
+	stage.rename = os.Rename
+	if err := stage.rollback(); err != nil {
+		t.Fatal(err)
+	}
+	requirePreviousCompileOutputs(t, task)
+}
diff --git a/cmd/plan9asmll/source_output_unix.go b/cmd/plan9asmll/source_output_unix.go
new file mode 100644
index 000000000..56fa96a9d
--- /dev/null
+++ b/cmd/plan9asmll/source_output_unix.go
@@ -0,0 +1,25 @@
+//go:build unix
+
+package main
+
+import (
+	"os"
+	"syscall"
+)
+
+func sameOutputFilesystem(stage, destination string) error {
+	left, err := os.Stat(stage)
+	if err != nil {
+		return err
+	}
+	right, err := os.Stat(destination)
+	if err != nil {
+		return err
+	}
+	leftStat, leftOK := left.Sys().(*syscall.Stat_t)
+	rightStat, rightOK := right.Sys().(*syscall.Stat_t)
+	if !leftOK || !rightOK || leftStat.Dev != rightStat.Dev {
+		return compileOutputError()
+	}
+	return nil
+}
diff --git a/cmd/plan9asmll/sqrt_specs_test.go b/cmd/plan9asmll/sqrt_specs_test.go
new file mode 100644
index 000000000..46956c867
--- /dev/null
+++ b/cmd/plan9asmll/sqrt_specs_test.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteSqrtSpec(t *testing.T) {
+	filename := "amd64_sqrt_forms.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	wanted := []string{"SQRTSS", "SQRTSD", "SQRTPS", "SQRTPD", "VSQRTSS", "VSQRTSD", "VSQRTPS", "VSQRTPD"}
+	for _, arch := range []string{"amd64", "386"} {
+		supported, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Every extraction also includes generic assembler directives. Count
+		// the complete family independently, then check each expected member.
+		family := 0
+		for opcode := range supported {
+			if strings.HasPrefix(opcode, "SQRT") || strings.HasPrefix(opcode, "VSQRT") {
+				family++
+			}
+		}
+		if family != len(wanted) {
+			t.Fatalf("%s complete sqrt-map extraction differs: %v", arch, supported)
+		}
+		for _, opcode := range wanted {
+			if _, present := supported[opcode]; !present {
+				t.Errorf("%s missing typed sqrt %s", arch, opcode)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/symbol_offset_test.go b/cmd/plan9asmll/symbol_offset_test.go
new file mode 100644
index 000000000..0fe41428f
--- /dev/null
+++ b/cmd/plan9asmll/symbol_offset_test.go
@@ -0,0 +1,23 @@
+package main
+
+import "testing"
+
+func TestSplitSymbolOffsetExpressions(t *testing.T) {
+	tests := []struct {
+		input string
+		name  string
+		off   int64
+	}{
+		{"data+ 8", "data", 8},
+		{"data - 8", "data", -8},
+		{"data+(4*2)", "data", 8},
+		{"data+8-4", "data", 4},
+		{"data-name", "data-name", 0},
+	}
+	for _, tt := range tests {
+		name, off := splitSymPlusOff(tt.input)
+		if name != tt.name || off != tt.off {
+			t.Errorf("splitSymPlusOff(%q) = %q, %d; want %q, %d", tt.input, name, off, tt.name, tt.off)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/test_declaration_role_test.go b/cmd/plan9asmll/test_declaration_role_test.go
new file mode 100644
index 000000000..686fba2de
--- /dev/null
+++ b/cmd/plan9asmll/test_declaration_role_test.go
@@ -0,0 +1,408 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestSupplementalTestDeclarationsUseActualTypedRole(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"darwin/amd64", "linux/amd64", "windows/amd64", "linux/386", "windows/386"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := testDeclarationRoleFixture(t, target)
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			env := featureEnvironment(os.Environ(), input.Observed.Environment)
+			for _, tests := range []bool{false, true} {
+				args := []string{"list", "-export", "-json"}
+				if tests {
+					args = append(args, "-test")
+				}
+				args = append(args, ".")
+				if _, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", args...); err != nil {
+					t.Fatalf("actual stock Go export tests=%v: %v\n%s", tests, err, stderr)
+				}
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			parts := strings.Split(target, "/")
+			report, _, err := runOneTarget(targetSpec{Goos: parts[0], Goarch: parts[1]}, []string{"."}, nil,
+				input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Failed != 0 || report.Success != 1 {
+				t.Fatalf("real bodyless test declaration was replaced by inferred i64: %#v: %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			for _, pkg := range report.FeatureSelection.Packages {
+				for _, name := range pkg.GoFiles {
+					if strings.HasSuffix(name, "_test.go") {
+						t.Fatal("supplemental test declaration was falsely recorded as ordinary source")
+					}
+				}
+			}
+			if len(report.FeatureSelection.TestDeclarations) != 1 || len(report.FeatureSelection.TestDeclarations[0].Declarations) != 3 {
+				t.Fatal("actual typed test signatures were not retained independently")
+			}
+			checkTestDeclarationReaderMutations(t, input, report.FeatureSelection)
+		})
+	}
+}
+
+func checkTestDeclarationReaderMutations(t *testing.T, input *featureInput, proof *gotoolprofile.SelectionProof) {
+	t.Helper()
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+		"missing protocol":   func(p *gotoolprofile.SelectionProof) { p.SignatureSourceProtocol = "" },
+		"missing test proof": func(p *gotoolprofile.SelectionProof) { p.TestDeclarations = nil },
+		"missing use":        func(p *gotoolprofile.SelectionProof) { p.CPP[0].Signatures = nil },
+		"wrong export":       func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].ExportSHA256 = strings.Repeat("a", 64) },
+		"wrong tool": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].CompileToolSHA256 = strings.Repeat("a", 64)
+		},
+		"wrong target":  func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].Target = "js/wasm" },
+		"wrong profile": func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].ProfileID = strings.Repeat("a", 64) },
+		"wrong tags":    func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].CustomTags = []string{"alternate"} },
+		"wrong variant": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].VariantID = p.TestDeclarations[0].PackagePath + ".test"
+		},
+		"wrong type": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].Declarations[0].GoType = "func(uint64) uint64"
+		},
+		"wrong layout": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].Declarations[0].Layout = json.RawMessage(`{"Ret":"i64"}`)
+		},
+		"removed test source": func(p *gotoolprofile.SelectionProof) { delete(p.TestDeclarations[0].SourceSHA256, "decl_test.go") },
+		"changed test source": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].SourceSHA256["decl_test.go"] = strings.Repeat("a", 64)
+		},
+		"removed source selection": func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].GoFiles = p.Packages[0].GoFiles },
+		"ordinary test role": func(p *gotoolprofile.SelectionProof) {
+			p.Packages[0].GoFiles = append(p.Packages[0].GoFiles, "decl_test.go")
+		},
+		"falsely ordinary signature": func(p *gotoolprofile.SelectionProof) { p.CPP[0].Signatures[0].Role = "ordinary_decl" },
+		"unconsumed symbol": func(p *gotoolprofile.SelectionProof) {
+			p.TestDeclarations[0].Declarations[0].Symbol += "Extra"
+		},
+		"missing dependency export": func(p *gotoolprofile.SelectionProof) { p.TestDeclarations[0].Imports = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed gotoolprofile.SelectionProof
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+				t.Fatal("changed/omitted supplemental source proof was accepted")
+			}
+		})
+	}
+}
+
+func TestSupplementalTestDeclarationsRejectUnprovedSourceRole(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, source := range map[string]string{
+		"poison":            "package header\nfunc U8ToF32s(x uint8) float32\nvar Poison = undefinedTestOnly\n",
+		"external":          "package header_test\nfunc U8ToF32s(x uint8) float32\n",
+		"body":              "package header\nfunc U8ToF32s(x uint8) float32 { return float32(x) }\n",
+		"wrong typed width": "package header\nfunc U8ToF32s(x uint8) float64\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			input, dir := testDeclarationRoleFixture(t, "linux/amd64")
+			if err := os.WriteFile(filepath.Join(dir, "decl_test.go"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input.Sources["decl_test.go"], input.Headers["decl_test.go"] = featureBytesSHA256([]byte(source)), source
+			if name == "wrong typed width" {
+				// Keep the true declared frame size so this reaches the typed
+				// float-width check rather than source ABI-size applicability.
+				asm := `TEXT ·U8ToF32s(SB),4,$0-16
+	MOVBLZX x+0(FP), AX
+	CVTSL2SS AX, X0
+	MOVSS X0, ret+8(FP)
+	RET
+`
+				filename := input.AsmFiles[0]
+				if err := os.WriteFile(filepath.Join(dir, filename), []byte(asm), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[filename], input.Headers[filename] = featureBytesSHA256([]byte(asm)), asm
+			}
+			t.Chdir(dir)
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil,
+				input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err == nil && report.Failed == 0 && report.NotApplicable == 0 {
+				t.Fatal("unproved test declaration/type acquired a successful object")
+			}
+		})
+	}
+}
+
+func TestSupplementalTestDeclarationsRejectMissingActualTestDependency(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, dir := testDeclarationRoleFixture(t, "linux/amd64")
+	module, err := os.ReadFile(filepath.Join(dir, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod": string(module) + "\nrequire example.invalid/testonly v0.0.0\n" +
+			"replace example.invalid/testonly => ./test-dependency-missing\n",
+		"poison_test.go": "package header\nimport _ \"example.invalid/testonly\"\n",
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if strings.HasSuffix(name, ".go") {
+			input.Headers[name] = source
+		}
+	}
+	input.Directories["."] = append(input.Directories["."], "poison_test.go")
+	sort.Strings(input.Directories["."])
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	defer cancel()
+	env := featureEnvironment(os.Environ(), input.Observed.Environment)
+	if _, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", "list", "-export", "-json", "."); err != nil {
+		t.Fatalf("ordinary stock Go package unexpectedly required tests: %v; %s", err, stderr)
+	}
+	_, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", "list", "-test", "-export", "-json", ".")
+	if err == nil || !strings.Contains(string(stderr), "test-dependency-missing") {
+		t.Fatalf("actual test dependency failure was not reproduced: %v; %s", err, stderr)
+	}
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil,
+		input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+	if report.Failed != 1 || report.Success != 0 || report.NotApplicable != 0 ||
+		len(report.Fails) != 1 || !strings.Contains(report.Fails[0].Err, "test-dependency-missing") {
+		t.Fatalf("required test declaration became success/N/A or lost its actual missing dependency: %#v; %v", report, err)
+	}
+}
+
+func testDeclarationRoleFixture(t *testing.T, target string) (*featureInput, string) {
+	t.Helper()
+	input, dir := generatedHeaderFixture(t, target)
+	input.SignatureSourceProtocol = gotoolprofile.SignatureSourceProtocol
+	word := 8
+	if strings.HasSuffix(target, "/386") {
+		word = 4
+	}
+	files := map[string]string{
+		"layout.go": "package header\n",
+		"decl_test.go": `package header
+import "example.invalid/header/dep"
+func U8ToF32s(x uint8) float32
+func EchoF32(x dep.F32) dep.F32
+func EchoF64(x float64) float64
+`,
+		"dep/layout.go": "package dep\ntype F32 = float32\n",
+		input.AsmFiles[0]: fmt.Sprintf(`TEXT ·U8ToF32s(SB),4,$0-%d
+	MOVBLZX x+0(FP), AX
+	CVTSL2SS AX, X0
+	MOVSS X0, ret+%d(FP)
+	RET
+TEXT ·EchoF32(SB),4,$0-%d
+	MOVSS x+0(FP), X0
+	MOVSS X0, ret+%d(FP)
+	RET
+TEXT ·EchoF64(SB),4,$0-16
+	MOVSD x+0(FP), X0
+	MOVSD X0, ret+8(FP)
+	RET
+`, word+4, word, word+4, word),
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, filepath.FromSlash(name)), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+	}
+	input.Directories["."] = append(input.Directories["."], "decl_test.go")
+	sort.Strings(input.Directories["."])
+	return input, dir
+}
+
+func TestSupplementalTestCalleeDeclarationsAcrossSourceFiles(t *testing.T) {
+	// Hosted machines need not export temporary roots. Exercise the production
+	// environment setup rather than borrowing a developer's TMPDIR.
+	t.Setenv("GOENV", "off")
+	t.Setenv("TMPDIR", "")
+	t.Setenv("GOTMPDIR", "")
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"darwin/amd64", "linux/amd64", "windows/amd64", "linux/386", "windows/386"} {
+		t.Run(target, func(t *testing.T) {
+			input, dir := testDeclarationRoleFixture(t, target)
+			parts := strings.Split(target, "/")
+			arch := parts[1]
+			word := 8
+			if arch == "386" {
+				word = 4
+			}
+			callee := "callee_" + arch + ".s"
+			sources := map[string]string{
+				"decl_test.go": `package header
+func CallF64(x float64) float64
+func TailF64(x float64) float64
+func CallF32(x uint8) float32
+func TailF32(x uint8) float32
+`,
+				"callee_test.go": `package header
+func ActualF64(x float64) float64
+func ActualF32(x uint8) float32
+func UnusedTestSymbol() uint64
+`,
+				input.AsmFiles[0]: `TEXT ·CallF64(SB),4,$16-16
+	MOVSD x+0(FP), X0
+	MOVSD X0, 0(SP)
+	CALL ·ActualF64(SB)
+	MOVSD 8(SP), X0
+	MOVSD X0, ret+8(FP)
+	RET
+TEXT ·TailF64(SB),4,$0-16
+	JMP ·ActualF64(SB)
+`,
+				callee: `TEXT ·ActualF64(SB),4,$0-16
+	MOVSD x+0(FP), X0
+	MOVSD X0, ret+8(FP)
+	RET
+`,
+			}
+			sources[input.AsmFiles[0]] += fmt.Sprintf(`TEXT ·CallF32(SB),4,$16-%d
+	MOVBLZX x+0(FP), AX
+	MOVB AX, 0(SP)
+	CALL ·ActualF32(SB)
+	MOVSS %d(SP), X0
+	MOVSS X0, ret+%d(FP)
+	RET
+TEXT ·TailF32(SB),4,$0-%d
+	JMP ·ActualF32(SB)
+`, word+4, word, word, word+4)
+			sources[callee] += fmt.Sprintf(`TEXT ·ActualF32(SB),4,$0-%d
+	MOVBLZX x+0(FP), AX
+	CVTSL2SS AX, X0
+	MOVSS X0, ret+%d(FP)
+	RET
+`, word+4, word)
+			for name, source := range sources {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+			}
+			input.AsmFiles = append(input.AsmFiles, callee)
+			input.Directories["."] = append(input.Directories["."], callee, "callee_test.go")
+			sort.Strings(input.AsmFiles)
+			sort.Strings(input.Directories["."])
+			t.Chdir(dir)
+			ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+			defer cancel()
+			env := featureEnvironment(os.Environ(), input.Observed.Environment)
+			if _, stderr, err := gotoolprofile.RunBounded(ctx, dir, env, "go", "list", "-test", "-export", "-json", "."); err != nil {
+				t.Fatalf("actual stock Go caller/callee declarations: %v\n%s", err, stderr)
+			}
+			config, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			config.FeaturePath, config.Context = writeFeatureInput(t, input), ctx
+			report, _, err := runOneTarget(targetSpec{Goos: parts[0], Goarch: arch}, []string{"."}, nil,
+				input.AsmFiles, input.Module, t.TempDir(), false, 0, true, false, true, repo, config)
+			if err != nil || report.Failed != 0 || report.Success != 2 {
+				t.Fatalf("actual same-package test callee was inferred as i64: %#v: %v", report, err)
+			}
+			if err := gotoolprofile.ValidateSelection(input, report.FeatureSelection, nil, true); err != nil {
+				t.Fatal(err)
+			}
+			if len(report.FeatureSelection.TestDeclarations) != 1 || len(report.FeatureSelection.TestDeclarations[0].Declarations) != 6 {
+				t.Fatal("callee declarations were duplicated or unused symbols were registered")
+			}
+			calleeUses := 0
+			for _, cpp := range report.FeatureSelection.CPP {
+				for _, signature := range cpp.Signatures {
+					if signature.Callee {
+						calleeUses++
+						if signature.Symbol != input.Module+".ActualF64" && signature.Symbol != input.Module+".ActualF32" {
+							t.Fatal("a symbol not consumed by this source acquired a callee role")
+						}
+					}
+				}
+			}
+			if calleeUses != 2 {
+				t.Fatal("CALL/JMP uses of one target were not normalized and deduplicated")
+			}
+			canonical, err := json.Marshal(report.FeatureSelection)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*gotoolprofile.SelectionProof){
+				"entry disguised as callee": func(proof *gotoolprofile.SelectionProof) {
+					proof.CPP[0].Signatures[0].Callee = true
+					proof.CPP[0].Signatures[0].Role = "asm_fallback"
+				},
+				"callee disguised as entry": func(proof *gotoolprofile.SelectionProof) {
+					for index := range proof.CPP[1].Signatures {
+						proof.CPP[1].Signatures[index].Callee = false
+					}
+				},
+				"wrong callee width": func(proof *gotoolprofile.SelectionProof) {
+					proof.CPP[1].Signatures[0].LayoutSHA256 = strings.Repeat("a", 64)
+				},
+				"unconsumed callee symbol": func(proof *gotoolprofile.SelectionProof) {
+					proof.CPP[1].Signatures[0].Symbol += "Other"
+				},
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed gotoolprofile.SelectionProof
+					if err := json.Unmarshal(canonical, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					if err := gotoolprofile.ValidateSelection(input, &changed, nil, true); err == nil {
+						t.Fatal("changed entry/callee source identity was accepted")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/test_declarations.go b/cmd/plan9asmll/test_declarations.go
new file mode 100644
index 000000000..0bfdf8192
--- /dev/null
+++ b/cmd/plan9asmll/test_declarations.go
@@ -0,0 +1,459 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/asmsig"
+	"golang.org/x/tools/go/packages"
+)
+
+func (consumer *featureConsumer) bindSignatureSources(pkg *packages.Package, file *plan9asm.File, asm string,
+	resolve func(string) string, goarch string, sigs map[string]plan9asm.FuncSig, sizes map[string]int64,
+) ([]gotoolprofile.SignatureSource, error) {
+	if consumer.Input.SignatureSourceProtocol == "" {
+		return nil, nil // Historical consumer inputs never gain a new source role.
+	}
+	if consumer.Input.SignatureSourceProtocol != gotoolprofile.SignatureSourceProtocol {
+		return nil, fmt.Errorf("unknown signature-source protocol")
+	}
+	requests, err := assemblySignatureRequests(pkg.PkgPath, file, resolve)
+	if err != nil {
+		return nil, err
+	}
+	roles, known := make(map[string]string), make(map[string]bool)
+	for symbol, requested := range requests {
+		role := "asm_fallback"
+		_, _, ordinary, err := tryDeclSig(pkg.Types.Scope(), requested.original, symbol,
+			linknameRemoteToLocal(pkg.Syntax), goarch, pkg.TypesSizes, strings.HasSuffix(requested.original, "<ABIInternal>"))
+		if err != nil {
+			return nil, err
+		}
+		if ordinary {
+			role = "ordinary_decl"
+			known[symbol] = true
+		} else {
+			derived, size, found, err := consumer.testDeclarationSignature(pkg, filepath.Dir(asm), requested.original, symbol, goarch)
+			if err != nil {
+				return nil, err
+			}
+			if found {
+				sigs[symbol], sizes[symbol], role = derived, size, "inpackage_test_decl"
+				known[symbol] = true
+			}
+		}
+		// Existing ordinary callee inference is unchanged. Supplemental proof
+		// records callees only when an actual missing test declaration was used.
+		if !requested.callee || role == "inpackage_test_decl" {
+			roles[symbol] = role
+		}
+	}
+	asmsig.RefineTailForwarders(file, sigs, resolve, known)
+	var sources []gotoolprofile.SignatureSource
+	for symbol, role := range roles {
+		layout, err := json.Marshal(sigs[symbol])
+		if err != nil {
+			return nil, err
+		}
+		sources = append(sources, gotoolprofile.SignatureSource{
+			Symbol: symbol, Role: role, Callee: requests[symbol].callee, ABIInternal: strings.HasSuffix(requests[symbol].original, "<ABIInternal>"), LayoutSHA256: gotoolprofile.SignatureLayoutSHA256(layout),
+		})
+	}
+	sort.Slice(sources, func(i, j int) bool { return sources[i].Symbol < sources[j].Symbol })
+	return sources, nil
+}
+
+// The same actual export/typecheck proof owns early signature selection and
+// final source-role retention. A syntax candidate alone grants no layout.
+func (consumer *featureConsumer) testDeclarationSignature(pkg *packages.Package, dir, original, symbol, goarch string) (plan9asm.FuncSig, int64, bool, error) {
+	var empty plan9asm.FuncSig
+	if consumer.Input.SignatureSourceProtocol == "" {
+		return empty, 0, false, nil
+	}
+	if consumer.Input.SignatureSourceProtocol != gotoolprofile.SignatureSourceProtocol {
+		return empty, 0, false, fmt.Errorf("unknown signature-source protocol")
+	}
+	if strings.Contains(original, "<>") || !strings.HasPrefix(symbol, pkg.PkgPath+".") {
+		return empty, 0, false, nil
+	}
+	name := strings.TrimPrefix(symbol, pkg.PkgPath+".")
+	candidate, err := consumer.testDeclarationCandidate(pkg, dir, name)
+	if err != nil || !candidate {
+		return empty, 0, false, err
+	}
+	testPkg, err := consumer.loadTestDeclarationPackage(pkg)
+	if err != nil {
+		return empty, 0, false, err
+	}
+	decl, err := consumer.typedBodylessTestDeclaration(testPkg, name)
+	if err != nil {
+		return empty, 0, false, err
+	}
+	derived, size, found, err := tryDeclSig(testPkg.Types.Scope(), original, symbol,
+		linknameRemoteToLocal(testPkg.Syntax), goarch, testPkg.TypesSizes, strings.HasSuffix(original, "<ABIInternal>"))
+	if err != nil || !found {
+		return empty, 0, false, fmt.Errorf("derive actual test declaration %s: %v (found=%v)", symbol, err, found)
+	}
+	layout, err := json.Marshal(derived)
+	if err != nil {
+		return empty, 0, false, err
+	}
+	decl.Symbol, decl.Layout = symbol, layout
+	if err := consumer.retainTestDeclaration(pkg.PkgPath, decl); err != nil {
+		return empty, 0, false, err
+	}
+	return derived, size, true, nil
+}
+
+type assemblySignatureRequest struct {
+	original string
+	callee   bool
+}
+
+// Both preflight and final consumption derive requests from the same parsed
+// CPP. Neither follows dynamic, foreign, private or offset/alias targets.
+func assemblySignatureRequests(packagePath string, file *plan9asm.File, resolve func(string) string) (map[string]assemblySignatureRequest, error) {
+	requests := make(map[string]assemblySignatureRequest)
+	for _, fn := range file.Funcs {
+		symbol := resolve(stripABISuffix(fn.Sym))
+		requests[symbol] = assemblySignatureRequest{original: fn.Sym}
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			switch strings.ToUpper(string(ins.Op)) {
+			case "CALL", "BL", "JMP", "B", "WASMCALL", "CALLNORESUME":
+			default:
+				continue
+			}
+			if len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+				continue
+			}
+			target := strings.TrimSpace(ins.Args[0].Sym)
+			if !strings.HasSuffix(target, "(SB)") {
+				continue
+			}
+			base, offset := splitSymPlusOff(strings.TrimSuffix(target, "(SB)"))
+			if offset != 0 || strings.Contains(base, "<>") {
+				continue
+			}
+			symbol := resolve(stripABISuffix(base))
+			name := strings.TrimPrefix(symbol, packagePath+".")
+			if !strings.HasPrefix(symbol, packagePath+".") || !token.IsIdentifier(name) {
+				continue
+			}
+			if previous, exists := requests[symbol]; exists {
+				if strings.HasSuffix(previous.original, "<ABIInternal>") != strings.HasSuffix(base, "<ABIInternal>") {
+					return nil, fmt.Errorf("test declaration has conflicting source ABI selectors: %s", symbol)
+				}
+				continue
+			}
+			requests[symbol] = assemblySignatureRequest{original: base, callee: true}
+		}
+	}
+	return requests, nil
+}
+
+// Parsing here decides only whether an authenticated selected test file has
+// a candidate name. All types/layouts come from the subsequent actual export
+// and typechecked package, never from this syntax prefilter.
+func (consumer *featureConsumer) testDeclarationCandidate(pkg *packages.Package, dir, name string) (bool, error) {
+	if candidates, present := consumer.TestDeclarationCandidates[pkg.PkgPath]; present {
+		issue, found := candidates[name]
+		return found, issue
+	}
+	candidates := make(map[string]error)
+	ctx := build.Default
+	ctx.GOOS, ctx.GOARCH, ctx.CgoEnabled = consumer.Observed.Environment["GOOS"], consumer.Observed.Environment["GOARCH"], false
+	ctx.BuildTags, ctx.ToolTags = consumer.Proof.CustomTags, consumer.Observed.ToolTags
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return false, err
+	}
+	for _, entry := range entries {
+		if !strings.HasSuffix(entry.Name(), "_test.go") {
+			continue
+		}
+		selected, err := ctx.MatchFile(dir, entry.Name())
+		if err != nil {
+			return false, err
+		}
+		if !selected {
+			continue
+		}
+		filename := filepath.Join(dir, entry.Name())
+		if _, err := consumer.sourceName(filename); err != nil {
+			return false, err
+		}
+		syntax, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+		if err != nil {
+			return false, fmt.Errorf("actual selected test declaration syntax: %w", err)
+		}
+		for _, node := range syntax.Decls {
+			decl, ok := node.(*ast.FuncDecl)
+			if !ok {
+				continue
+			}
+			declName := decl.Name.Name
+			if syntax.Name.Name != pkg.Name || decl.Body != nil || decl.Recv != nil {
+				if _, valid := candidates[declName]; !valid {
+					candidates[declName] = fmt.Errorf("missing ordinary declaration %s has no in-package bodyless test role", declName)
+				}
+				continue
+			}
+			candidates[declName] = nil
+		}
+	}
+	if consumer.TestDeclarationCandidates == nil {
+		consumer.TestDeclarationCandidates = make(map[string]map[string]error)
+	}
+	consumer.TestDeclarationCandidates[pkg.PkgPath] = candidates
+	issue, found := candidates[name]
+	return found, issue
+}
+
+func (consumer *featureConsumer) loadTestDeclarationPackage(ordinary *packages.Package) (*packages.Package, error) {
+	if cached := consumer.TestDeclarationPackages[ordinary.PkgPath]; cached != nil {
+		return cached, consumer.verifySources()
+	}
+	config := &packages.Config{
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedModule | packages.NeedDeps |
+			packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes | packages.NeedSyntax |
+			packages.NeedTypesInfo | packages.NeedCompiledGoFiles | packages.NeedExportFile |
+			packages.NeedEmbedFiles | packages.NeedEmbedPatterns,
+		Context: consumer.Context, Env: consumer.Env, Dir: consumer.WorkDir, Tests: true,
+		BuildFlags: []string{"-mod=mod"},
+	}
+	if tags := consumer.Proof.CustomTags; len(tags) != 0 {
+		config.BuildFlags = append(config.BuildFlags, "-tags="+strings.Join(tags, ","))
+	}
+	variantID := ordinary.PkgPath + " [" + ordinary.PkgPath + ".test]"
+	selectVariant := func(pkgs []*packages.Package) (*packages.Package, error) {
+		var selected *packages.Package
+		for _, pkg := range pkgs {
+			if pkg.ID == variantID {
+				if selected != nil {
+					return nil, fmt.Errorf("duplicate actual in-package test variant")
+				}
+				selected = pkg
+			}
+		}
+		if selected == nil || selected.PkgPath != ordinary.PkgPath || selected.Name != ordinary.Name ||
+			!reflect.DeepEqual(selected.Module, ordinary.Module) {
+			return nil, fmt.Errorf("actual Go did not select the original same-module in-package test variant")
+		}
+		return selected, nil
+	}
+	preConfig := *config
+	preConfig.Mode &^= packages.NeedTypes | packages.NeedTypesSizes | packages.NeedTypesInfo | packages.NeedSyntax
+	before, err := packages.Load(&preConfig, ordinary.PkgPath)
+	if err != nil {
+		return nil, err
+	}
+	pre, err := selectVariant(before)
+	if err != nil {
+		return nil, err
+	}
+	if err := consumer.bindActualTestDependencies(ordinary, pre); err != nil {
+		return nil, err
+	}
+	allowed := map[string]bool{variantID: true}
+	guard, err := consumer.captureTestSourceLoadGuard(consumer.Context, []*packages.Package{pre}, allowed)
+	if err != nil {
+		return nil, err
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, err
+	}
+	driverDigest, err := gotoolprofile.FileSHA256(binary)
+	if err != nil || driverDigest != consumer.Observed.DriverSHA256 {
+		return nil, fmt.Errorf("test declaration driver differs from its actual registered tool: %v", err)
+	}
+	guard.Sources[binary] = driverDigest
+	compileOrigin := consumer.Observed.ToolBinaryOrigins["compile"]
+	if !strings.HasPrefix(compileOrigin, "goroot/") {
+		return nil, fmt.Errorf("test declaration lacks an actual GOROOT compiler origin")
+	}
+	compileBinary := filepath.Join(consumer.Root, filepath.FromSlash(strings.TrimPrefix(compileOrigin, "goroot/")))
+	guard.Sources[compileBinary] = consumer.Observed.ToolBinarySHA256["compile"]
+	if err := verifyGeneratedHeaderCompiler(consumer, binary); err != nil {
+		return nil, err
+	}
+	loaded, err := packages.Load(config, ordinary.PkgPath)
+	if err != nil {
+		return nil, err
+	}
+	var diagnostics []string
+	packages.Visit(loaded, nil, func(pkg *packages.Package) {
+		for _, issue := range pkg.Errors {
+			diagnostics = append(diagnostics, issue.Error())
+		}
+	})
+	if len(diagnostics) != 0 {
+		sort.Strings(diagnostics)
+		return nil, fmt.Errorf("actual same-profile Go test export/typecheck:\n%s", strings.Join(diagnostics, "\n"))
+	}
+	if err := verifyGeneratedHeaderCompiler(consumer, binary); err != nil {
+		return nil, err
+	}
+	selected, err := selectVariant(loaded)
+	if err != nil {
+		return nil, err
+	}
+	if err := consumer.bindActualTestDependencies(ordinary, selected); err != nil {
+		return nil, err
+	}
+	after, err := consumer.captureTestSourceLoadGuard(consumer.Context, []*packages.Package{selected}, allowed)
+	if err != nil {
+		return nil, err
+	}
+	after.Sources[binary] = driverDigest
+	after.Sources[compileBinary] = consumer.Observed.ToolBinarySHA256["compile"]
+	if !reflect.DeepEqual(guard, after) {
+		return nil, fmt.Errorf("test declaration dependency/source selection changed during actual export/typecheck")
+	}
+	if selected.Types == nil || selected.TypesSizes == nil || selected.TypesInfo == nil || selected.ExportFile == "" {
+		return nil, fmt.Errorf("actual test variant lacks complete typechecked/export metadata")
+	}
+	proof := gotoolprofile.TestDeclarationProof{
+		Protocol: gotoolprofile.TestDeclarationProtocol, PackagePath: ordinary.PkgPath, VariantID: variantID,
+		ProfileID: consumer.ID, CustomTags: consumer.Proof.CustomTags, Target: consumer.Observed.Target,
+		GoVersion: consumer.Observed.GoVersion, DriverSHA256: consumer.Observed.DriverSHA256,
+		CompileToolSHA256: consumer.Observed.ToolBinarySHA256["compile"], SourceSHA256: make(map[string]string),
+		ImportMap: make(map[string]string),
+	}
+	proof.ExportSHA256, err = gotoolprofile.FileSHA256(selected.ExportFile)
+	if err != nil {
+		return nil, err
+	}
+	guard.Sources[selected.ExportFile] = proof.ExportSHA256
+	capture := func(files []string, assembly bool) ([]string, error) {
+		var result []string
+		for _, filename := range files {
+			if assembly && filepath.Ext(filename) != ".s" {
+				continue
+			}
+			name, err := consumer.sourceName(filename)
+			if err != nil {
+				return nil, err
+			}
+			proof.SourceSHA256[name] = consumer.Input.Sources[name]
+			result = append(result, name)
+		}
+		sort.Strings(result)
+		return result, nil
+	}
+	if proof.GoFiles, err = capture(selected.GoFiles, false); err != nil {
+		return nil, err
+	}
+	if proof.CompiledGoFiles, err = capture(selected.CompiledGoFiles, false); err != nil {
+		return nil, err
+	}
+	if proof.SFiles, err = capture(selected.OtherFiles, true); err != nil {
+		return nil, err
+	}
+	imports, exports, _, sourceGuard, err := generatedHeaderImportsForRole(consumer, selected, true)
+	if err != nil {
+		return nil, err
+	}
+	proof.Imports = imports
+	for name, dep := range selected.Imports {
+		proof.ImportMap[name] = dep.PkgPath
+	}
+	for name, digest := range exports {
+		guard.Sources[name] = digest
+	}
+	for name, digest := range sourceGuard {
+		guard.Sources[name] = digest
+	}
+	if err := consumer.retainGeneratedGuard(guard.Sources); err != nil {
+		return nil, err
+	}
+	if err := consumer.verifySources(); err != nil {
+		return nil, err
+	}
+	consumer.Proof.TestDeclarations = append(consumer.Proof.TestDeclarations, proof)
+	sort.Slice(consumer.Proof.TestDeclarations, func(i, j int) bool {
+		return consumer.Proof.TestDeclarations[i].PackagePath < consumer.Proof.TestDeclarations[j].PackagePath
+	})
+	if consumer.TestDeclarationPackages == nil {
+		consumer.TestDeclarationPackages = make(map[string]*packages.Package)
+	}
+	consumer.TestDeclarationPackages[ordinary.PkgPath] = selected
+	return selected, nil
+}
+
+func (consumer *featureConsumer) typedBodylessTestDeclaration(pkg *packages.Package, name string) (gotoolprofile.TestDeclaration, error) {
+	var result gotoolprofile.TestDeclaration
+	object, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+	if !ok || object.Pkg() != pkg.Types || object.Type() == nil {
+		return result, fmt.Errorf("test variant has no actual typed function %s", name)
+	}
+	for _, syntax := range pkg.Syntax {
+		for _, node := range syntax.Decls {
+			decl, ok := node.(*ast.FuncDecl)
+			if !ok || decl.Name.Name != name {
+				continue
+			}
+			filename := pkg.Fset.PositionFor(decl.Pos(), false).Filename
+			file, err := consumer.sourceName(filename)
+			if err != nil || !strings.HasSuffix(file, "_test.go") || decl.Body != nil || decl.Recv != nil || pkg.TypesInfo.Defs[decl.Name] != object {
+				return result, fmt.Errorf("function %s has no exact selected bodyless test declaration identity: %v", name, err)
+			}
+			return gotoolprofile.TestDeclaration{File: file, GoType: types.TypeString(object.Type(), func(pkg *types.Package) string { return pkg.Path() })}, nil
+		}
+	}
+	return result, fmt.Errorf("typed test declaration %s was not present in the selected original syntax", name)
+}
+
+func (consumer *featureConsumer) retainTestDeclaration(pkg string, decl gotoolprofile.TestDeclaration) error {
+	for index := range consumer.Proof.TestDeclarations {
+		proof := &consumer.Proof.TestDeclarations[index]
+		if proof.PackagePath != pkg {
+			continue
+		}
+		for _, previous := range proof.Declarations {
+			if previous.Symbol == decl.Symbol {
+				if !reflect.DeepEqual(previous, decl) {
+					return fmt.Errorf("test declaration changed across entry/callee consumers: %s", decl.Symbol)
+				}
+				return nil
+			}
+		}
+		proof.Declarations = append(proof.Declarations, decl)
+		sort.Slice(proof.Declarations, func(i, j int) bool { return proof.Declarations[i].Symbol < proof.Declarations[j].Symbol })
+		return nil
+	}
+	return fmt.Errorf("test declaration has no actual stock-Go export proof")
+}
+
+func (consumer *featureConsumer) refreshTestDeclarationReferences() {
+	for cppIndex := range consumer.Proof.CPP {
+		for index := range consumer.Proof.CPP[cppIndex].Signatures {
+			source := &consumer.Proof.CPP[cppIndex].Signatures[index]
+			if source.Role != "inpackage_test_decl" {
+				continue
+			}
+			for _, proof := range consumer.Proof.TestDeclarations {
+				for _, decl := range proof.Declarations {
+					if decl.Symbol == source.Symbol {
+						source.TestProofSHA256 = gotoolprofile.TestDeclarationSHA256(proof)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/test_dependency_embed_test.go b/cmd/plan9asmll/test_dependency_embed_test.go
new file mode 100644
index 000000000..a2f9ccf45
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_embed_test.go
@@ -0,0 +1,119 @@
+package main
+
+import (
+	"context"
+	"go/build"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestTestDependencyEmbedActualOrdinaryRole(t *testing.T) {
+	for _, axis := range []struct {
+		name, directive, file string
+	}{
+		{name: "file", directive: "//go:embed defaults.bin", file: "defaults.bin"},
+		{name: "all directory", directive: "//go:embed all:assets", file: "assets/.defaults.bin"},
+		{name: "Unicode pattern whitespace", directive: "//go:embed \u00a0defaults.bin", file: "defaults.bin"},
+		{name: "Unicode separator", directive: "//go:embed\u00a0defaults.bin", file: "defaults.bin"},
+	} {
+		t.Run(axis.name, func(t *testing.T) {
+			testDependencyEmbedActualOrdinaryRole(t, axis.directive, axis.file)
+		})
+	}
+}
+
+func testDependencyEmbedActualOrdinaryRole(t *testing.T, directive, asset string) {
+	t.Helper()
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sourceText := "package actualembed\nimport _ \"embed\"\n" + directive + "\nvar Defaults []byte\n"
+	for name, contents := range map[string]string{
+		"go.mod":      "module example.invalid/actualembed\n\ngo 1.20\n",
+		"defaults.go": sourceText,
+		asset:         "exact original embedded bytes\n",
+	} {
+		if err := os.MkdirAll(filepath.Dir(filepath.Join(dir, name)), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	selected, err := packages.Load(&packages.Config{
+		Context: ctx, Dir: dir, Env: append(os.Environ(), "GOTOOLCHAIN=local"),
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedEmbedFiles | packages.NeedEmbedPatterns,
+	}, ".")
+	if err != nil || len(selected) != 1 || len(selected[0].Errors) != 0 {
+		t.Fatalf("actual Go embed selection: %v %#v", err, selected)
+	}
+	pkg := selected[0]
+	// Go 1.25 and earlier recognize only space/tab immediately after the
+	// directive name. Compare the actual SDK's independent source reader;
+	// ignored comments must not acquire the newer parser's embedded files.
+	original, err := build.Default.ImportDir(dir, 0)
+	if err != nil {
+		t.Fatal("independent SDK source selection", err)
+	}
+	want := len(original.EmbedPatterns)
+	if want != 1 && !(want == 0 && strings.HasPrefix(directive, "//go:embed\u00a0")) {
+		t.Fatal("unexpected SDK directive selection", original.EmbedPatterns)
+	}
+	if isTestVariantPackage(pkg) || len(pkg.EmbedPatterns) != want || len(pkg.EmbedFiles) != want {
+		t.Fatalf("ordinary exact Go embed selection was not retained: %#v", pkg)
+	}
+	if _, err := captureTypedSourceLoadGuard(ctx, selected, nil); (err != nil) != (want != 0) {
+		t.Fatal("unqualified ordinary load changed its actual embed role", err)
+	}
+	source := gotoolprofile.TestSourcePackage{
+		Package: gotoolprofile.PackageProof{
+			PackagePath: pkg.PkgPath,
+			GoFiles:     []string{"defaults.go"}, CompiledGoFiles: []string{"defaults.go"},
+			SourceSHA256: map[string]string{"defaults.go": featureBytesSHA256([]byte(sourceText))},
+		},
+	}
+	source.Embed, err = captureTestPackageEmbedSelection(source.Package, dir, pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{TestEmbedGuards: map[string]testDependencyEmbedGuard{
+		pkg.ID: {Source: source, Root: dir},
+	}}
+	guard, err := consumer.captureTestSourceLoadGuard(ctx, selected, nil)
+	if err != nil {
+		t.Fatalf("actual ordinary role with explicit bound original sources: %v", err)
+	}
+	if want == 0 {
+		if len(source.Embed.Patterns) != 0 || len(source.Embed.Files) != 0 || guard.Sources[filepath.Join(dir, asset)] != "" {
+			t.Fatal("ignored directive acquired an embedded input")
+		}
+		changed := strings.Replace(sourceText, "//go:embed\u00a0", "//go:embed ", 1)
+		if err := os.WriteFile(filepath.Join(dir, "defaults.go"), []byte(changed), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := consumer.verifyTestEmbedPackage(pkg); err == nil {
+			t.Fatal("changed directive revived the original empty selection")
+		}
+		t.Log("actual SDK ignores the directive boundary; empty selection and source mutation verified")
+		return
+	}
+	if guard.Sources[pkg.EmbedFiles[0]] != source.Embed.Files[asset] {
+		t.Fatal("private pre/post guard omitted the actual embedded bytes")
+	}
+	if err := os.WriteFile(filepath.Join(dir, asset), []byte("mutated embedded bytes"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := consumer.captureTestSourceLoadGuard(ctx, selected, nil); err == nil {
+		t.Fatal("actual embedded source changed after binding without failing")
+	}
+}
diff --git a/cmd/plan9asmll/test_dependency_embeds.go b/cmd/plan9asmll/test_dependency_embeds.go
new file mode 100644
index 000000000..63c7e7e33
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_embeds.go
@@ -0,0 +1,55 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+type testDependencyEmbedGuard struct {
+	Source gotoolprofile.TestSourcePackage
+	Root   string
+}
+
+// go/packages exposes absolute patterns; go list exposes package-relative
+// spelling. Preserve that spelling, including all:, without resolving globs
+// as filesystem paths or changing their grammar.
+func captureTestPackageEmbedSelection(proof gotoolprofile.PackageProof, root string, pkg *packages.Package) (*gotoolprofile.TestEmbedSelection, error) {
+	var patterns []string
+	for _, pattern := range pkg.EmbedPatterns {
+		if len(pkg.GoFiles) == 0 || !filepath.IsAbs(pattern) {
+			return nil, fmt.Errorf("actual typed package has an unbound absolute embed pattern")
+		}
+		rel, err := filepath.Rel(filepath.Dir(pkg.GoFiles[0]), pattern)
+		if err != nil {
+			return nil, err
+		}
+		patterns = append(patterns, filepath.ToSlash(rel))
+	}
+	return gotoolprofile.CaptureTestEmbedSelection(proof, root, patterns, pkg.EmbedFiles)
+}
+
+// Installed only after the producer closure agrees with independently bound
+// actual Module/Go selection. JSON alone never authorizes an embed source role.
+func (consumer *featureConsumer) verifyTestEmbedPackage(pkg *packages.Package) error {
+	bound, found := consumer.TestEmbedGuards[pkg.ID]
+	if !found {
+		return fmt.Errorf("test dependency embed role has no independently bound actual source closure")
+	}
+	actual, err := captureTestPackageEmbedSelection(bound.Source.Package, bound.Root, pkg)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(actual, bound.Source.Embed) {
+		return fmt.Errorf("actual test dependency embed source/pattern/file selection changed")
+	}
+	return nil
+}
+
+func (consumer *featureConsumer) captureTestSourceLoadGuard(ctx context.Context, pkgs []*packages.Package, allowedTests map[string]bool) (*generatedHeaderLoadGuard, error) {
+	return captureTypedSourceLoadGuardWithEmbeds(ctx, pkgs, allowedTests, consumer.verifyTestEmbedPackage)
+}
diff --git a/cmd/plan9asmll/test_dependency_legacy_metadata_test.go b/cmd/plan9asmll/test_dependency_legacy_metadata_test.go
new file mode 100644
index 000000000..eb1f68eee
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_legacy_metadata_test.go
@@ -0,0 +1,64 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestTestModuleConsumerCachedLegacyMetadataCannotDisappear(t *testing.T) {
+	data, err := os.ReadFile("../../gotoolprofile/testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof gotoolprofile.ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(t.TempDir(), "proxy.mod")
+	if err := os.WriteFile(metadata, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	digest := strings.Repeat("a", 64)
+	source := gotoolprofile.TestModuleSource{
+		Protocol: gotoolprofile.TestDependencyModuleProtocol, SourceModule: proof.Module, SourceVersion: proof.Version,
+		ModuleSum: proof.ModuleSum, GoModSum: proof.GoModSum, GoModSHA256: proof.SHA256,
+		GoModOrigin: proof.Protocol, ProxyGoMod: &proof, ZipSHA256: strings.Repeat("b", 64),
+		Sources: map[string]string{"fixture.go": digest}, Headers: map[string]string{"fixture.go": "package fixture\n"},
+		Directories: map[string][]gotoolprofile.TestSourceEntry{
+			".": {{Name: "fixture.go", Kind: "file", SHA256: digest}},
+		},
+	}
+	// This models only an already-bound private guard's repeat transition,
+	// not authenticating the fixture as that public module's original ZIP.
+	consumer := &featureConsumer{TestModuleGuards: map[string]testDependencyModuleGuard{
+		source.ID(): {Source: source, Root: root, GoMod: metadata},
+	}}
+	if err := consumer.bindTestModuleSource(source, root, metadata); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.bindTestModuleSource(source, root, ""); err == nil {
+		t.Fatal("cached source binding authorized an actual Module.GoMod that disappeared")
+	}
+	other := filepath.Join(t.TempDir(), "equal.mod")
+	if err := os.WriteFile(other, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.bindTestModuleSource(source, root, other); err == nil {
+		t.Fatal("cached legacy binding authorized equal metadata at another actual path")
+	}
+	if err := os.WriteFile(metadata, []byte("module example.invalid/changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.bindTestModuleSource(source, root, metadata); err == nil {
+		t.Fatal("cached binding authorized changed actual metadata bytes")
+	}
+}
diff --git a/cmd/plan9asmll/test_dependency_metadata_copy_test.go b/cmd/plan9asmll/test_dependency_metadata_copy_test.go
new file mode 100644
index 000000000..e9af278eb
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_metadata_copy_test.go
@@ -0,0 +1,250 @@
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+func testModuleOriginalMetadataConsumer(t *testing.T) (*featureConsumer, testDependencyModuleGuard) {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := []struct{ name, data string }{
+		{"go.mod", "module example.invalid/metadata\n\ngo 1.20\n"},
+		{"metadata.go", "package metadata\n"},
+	}
+	source := gotoolprofile.TestModuleSource{
+		Protocol:     gotoolprofile.TestDependencyModuleProtocol,
+		SourceModule: "example.invalid/metadata", SourceVersion: "v1.0.0",
+		GoModOrigin: gotoolprofile.TestModuleOriginalGoModOrigin,
+		Sources:     make(map[string]string), Headers: make(map[string]string),
+		Directories: make(map[string][]gotoolprofile.TestSourceEntry),
+	}
+	var contents bytes.Buffer
+	writer := zip.NewWriter(&contents)
+	for _, file := range files {
+		if err := os.WriteFile(filepath.Join(root, file.name), []byte(file.data), 0600); err != nil {
+			t.Fatal(err)
+		}
+		member, err := writer.Create(source.ID() + "/" + file.name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := io.WriteString(member, file.data); err != nil {
+			t.Fatal(err)
+		}
+		digest := featureBytesSHA256([]byte(file.data))
+		source.Sources[file.name] = digest
+		source.Directories["."] = append(source.Directories["."], gotoolprofile.TestSourceEntry{
+			Name: file.name, Kind: "file", SHA256: digest,
+		})
+	}
+	source.Headers["metadata.go"] = files[1].data
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	archive := filepath.Join(t.TempDir(), "original.zip")
+	if err := os.WriteFile(archive, contents.Bytes(), 0600); err != nil {
+		t.Fatal(err)
+	}
+	source.ZipSHA256 = featureBytesSHA256(contents.Bytes())
+	source.ModuleSum, err = dirhash.HashZip(archive, dirhash.Hash1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source.GoModSHA256 = source.Sources["go.mod"]
+	source.GoModSum, err = dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+		return io.NopCloser(bytes.NewBufferString(files[0].data)), nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	download := filepath.Join(t.TempDir(), "download.mod")
+	if err := os.WriteFile(download, []byte(files[0].data), 0600); err != nil {
+		t.Fatal(err)
+	}
+	guard := testDependencyModuleGuard{
+		Source: source, Root: root, ZIP: archive, GoMod: download,
+	}
+	// Independently check this complete owned fixture before modeling an
+	// already-bound private guard. This is not public SumDB authentication.
+	ctx := context.Background()
+	if err := gotoolprofile.VerifyTestModuleSource(ctx, source, root, archive); err != nil {
+		t.Fatal(err)
+	}
+	consumer := &featureConsumer{
+		Context: ctx, TestModuleGuards: map[string]testDependencyModuleGuard{source.ID(): guard},
+	}
+	if err := consumer.bindTestModuleSource(source, root, filepath.Join(root, "go.mod")); err != nil {
+		t.Fatal(err)
+	}
+	return consumer, guard
+}
+
+func TestTestModuleConsumerOriginalMetadataCopyFinalGuard(t *testing.T) {
+	consumer, guard := testModuleOriginalMetadataConsumer(t)
+	data, err := os.ReadFile(guard.GoMod)
+	if err != nil {
+		t.Fatal(err)
+	}
+	copy := filepath.Join(t.TempDir(), "actual-module.mod")
+	if err := os.WriteFile(copy, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.bindTestModuleSource(guard.Source, guard.Root, copy); err != nil {
+		t.Fatal(err)
+	}
+	bound := consumer.TestModuleGuards[guard.Source.ID()]
+	canonical, err := filepath.EvalSymlinks(copy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(bound.MetadataPaths) != 3 || bound.MetadataPaths[copy] != canonical ||
+		consumer.GeneratedGuard[copy] != guard.Source.GoModSHA256 {
+		t.Fatal("actual metadata copy lacks its independent canonical/byte final guards")
+	}
+	if err := consumer.verifyTestModuleSources(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(copy, []byte("module example.invalid/changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifyTestModuleSources(); err == nil {
+		t.Fatal("repeated actual Module.GoMod copy changed after loading without failing final verification")
+	}
+}
+
+func TestTestModuleConsumerOriginalMetadataCopiesRemainGuarded(t *testing.T) {
+	for name, mutate := range map[string]func(*testing.T, string, []byte){
+		"changed": func(t *testing.T, filename string, _ []byte) {
+			if err := os.WriteFile(filename, []byte("changed metadata\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		},
+		"deleted": func(t *testing.T, filename string, _ []byte) {
+			if err := os.Remove(filename); err != nil {
+				t.Fatal(err)
+			}
+		},
+		"equal leaf symlink": func(t *testing.T, filename string, data []byte) {
+			replacement := filepath.Join(t.TempDir(), "equal.mod")
+			if err := os.WriteFile(replacement, data, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Remove(filename); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Symlink(replacement, filename); err != nil {
+				t.Fatal(err)
+			}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			consumer, guard := testModuleOriginalMetadataConsumer(t)
+			data, err := os.ReadFile(guard.GoMod)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var copies []string
+			for _, basename := range []string{"first.mod", "second.mod"} {
+				filename := filepath.Join(t.TempDir(), basename)
+				if err := os.WriteFile(filename, data, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := consumer.bindTestModuleSource(guard.Source, guard.Root, filename); err != nil {
+					t.Fatal(err)
+				}
+				copies = append(copies, filename)
+			}
+			if err := consumer.verifyTestModuleSources(); err != nil {
+				t.Fatal(err)
+			}
+			mutate(t, copies[0], data)
+			if err := consumer.verifyTestModuleSources(); err == nil {
+				t.Fatal("earlier repeated metadata copy lost its final guard after another observation")
+			}
+		})
+	}
+}
+
+func TestTestModuleConsumerOriginalMetadataCanonicalPathCannotChange(t *testing.T) {
+	for _, stage := range []string{"repeat load", "final guard"} {
+		t.Run(stage, func(t *testing.T) {
+			consumer, guard := testModuleOriginalMetadataConsumer(t)
+			data, err := os.ReadFile(guard.GoMod)
+			if err != nil {
+				t.Fatal(err)
+			}
+			parent := t.TempDir()
+			for _, dir := range []string{"first", "second"} {
+				if err := os.Mkdir(filepath.Join(parent, dir), 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(parent, dir, "actual.mod"), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			link := filepath.Join(parent, "selected")
+			if err := os.Symlink(filepath.Join(parent, "first"), link); err != nil {
+				t.Fatal(err)
+			}
+			metadata := filepath.Join(link, "actual.mod")
+			if err := consumer.bindTestModuleSource(guard.Source, guard.Root, metadata); err != nil {
+				t.Fatal(err)
+			}
+			if err := consumer.verifyTestModuleSources(); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Remove(link); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Symlink(filepath.Join(parent, "second"), link); err != nil {
+				t.Fatal(err)
+			}
+			var rejected error
+			if stage == "repeat load" {
+				rejected = consumer.bindTestModuleSource(guard.Source, guard.Root, metadata)
+			} else {
+				rejected = consumer.verifyTestModuleSources()
+			}
+			if rejected == nil {
+				t.Fatal("equal-byte parent redirection changed an observed metadata path without failing")
+			}
+		})
+	}
+}
+
+func TestTestModuleConsumerOriginalMetadataConflictingGuardCannotAuthorizeCopy(t *testing.T) {
+	consumer, guard := testModuleOriginalMetadataConsumer(t)
+	data, err := os.ReadFile(guard.GoMod)
+	if err != nil {
+		t.Fatal(err)
+	}
+	copy := filepath.Join(t.TempDir(), "conflict.mod")
+	if err := os.WriteFile(copy, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	consumer.GeneratedGuard[copy] = featureBytesSHA256([]byte("other observed bytes"))
+	if err := consumer.bindTestModuleSource(guard.Source, guard.Root, copy); err == nil {
+		t.Fatal("actual metadata copy overwrote an incompatible prior byte identity")
+	}
+	if _, found := consumer.TestModuleGuards[guard.Source.ID()].MetadataPaths[copy]; found {
+		t.Fatal("failed copy observation retained an authorized canonical path")
+	}
+	bound := consumer.TestModuleGuards[guard.Source.ID()]
+	bound.MetadataPaths = nil
+	consumer.TestModuleGuards[guard.Source.ID()] = bound
+	if err := consumer.verifyTestModuleSources(); err == nil {
+		t.Fatal("external module final guard accepted missing actual metadata observations")
+	}
+}
diff --git a/cmd/plan9asmll/test_dependency_modules.go b/cmd/plan9asmll/test_dependency_modules.go
new file mode 100644
index 000000000..911f783f2
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_modules.go
@@ -0,0 +1,282 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+	"golang.org/x/tools/go/packages"
+)
+
+type testDependencyModuleGuard struct {
+	Source        gotoolprofile.TestModuleSource
+	Root          string
+	ZIP           string
+	GoMod         string
+	MetadataPaths map[string]string // Each actual path -> its pre-load canonical path.
+}
+
+func (consumer *featureConsumer) foreignTestSourcePackage(actual *packages.Package) (gotoolprofile.TestSourcePackage, error) {
+	proof := gotoolprofile.PackageProof{PackagePath: actual.PkgPath, SourceSHA256: make(map[string]string)}
+	var root, id, goMod string
+	if actual.Module == nil {
+		if consumer.Root == "" {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("test dependency lacks an actual Go source/tool root")
+		}
+		var err error
+		root, err = sourcepath.Resolve(filepath.Join(consumer.Root, "src"))
+		if err != nil {
+			return gotoolprofile.TestSourcePackage{}, err
+		}
+		// Root is obtained from the reobserved driver, never from an input
+		// JSON path or a caller-supplied stdlib@GoVersion source directory.
+		proof.SourceRole, id = "stdlib", "stdlib@"+consumer.Observed.GoVersion
+	} else {
+		metadata := actual.Module
+		if metadata.Main || module.Check(metadata.Path, metadata.Version) != nil || metadata.Path == consumer.Input.Module ||
+			actual.PkgPath != metadata.Path && !strings.HasPrefix(actual.PkgPath, metadata.Path+"/") {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency has a different actual module role")
+		}
+		var err error
+		root, err = sourcepath.Resolve(metadata.Dir)
+		if err != nil || !filepath.IsAbs(root) {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency has an inaccessible actual module directory")
+		}
+		proof.ModulePath, proof.ModuleVersion = metadata.Path, metadata.Version
+		proof.SourceModule, proof.SourceVersion, proof.SourceRole = metadata.Path, metadata.Version, "module"
+		goMod = metadata.GoMod
+		if replacement := metadata.Replace; replacement != nil {
+			if module.Check(replacement.Path, replacement.Version) != nil {
+				return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency has an unsupported local/unknown replacement")
+			}
+			replacedRoot, err := sourcepath.Resolve(replacement.Dir)
+			if err != nil || replacedRoot != root {
+				return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test replacement has a different actual source root")
+			}
+			proof.SourceModule, proof.SourceVersion, proof.SourceRole = replacement.Path, replacement.Version, "version_replace"
+			goMod = replacement.GoMod
+		}
+		id = proof.SourceModule + "@" + proof.SourceVersion
+	}
+	var source *gotoolprofile.TestModuleSource
+	for index := range consumer.Input.TestDependencies.SourceModules {
+		candidate := &consumer.Input.TestDependencies.SourceModules[index]
+		if candidate.ID() == id {
+			source = candidate
+		}
+	}
+	if source == nil {
+		return gotoolprofile.TestSourcePackage{}, fmt.Errorf("actual test dependency lacks its registered foreign source root: %s", actual.PkgPath)
+	}
+	if err := consumer.bindTestModuleSource(*source, root, goMod); err != nil {
+		return gotoolprofile.TestSourcePackage{}, err
+	}
+	if source.SourceModule != "" {
+		proof.GoModOrigin = source.GoModOrigin
+		proof.GoModSHA256, proof.GoModSum = source.GoModSHA256, source.GoModSum
+	}
+	capture := func(files []string, assemblyOnly bool) ([]string, error) {
+		var names []string
+		for _, filename := range files {
+			if assemblyOnly && filepath.Ext(filename) != ".s" {
+				continue
+			}
+			filename, err := sourcepath.Resolve(filename)
+			if err != nil {
+				return nil, err
+			}
+			name, err := filepath.Rel(root, filename)
+			if err != nil {
+				return nil, err
+			}
+			name = filepath.ToSlash(name)
+			if _, err := gotoolprofile.CPPRegularSource(root, name); err != nil {
+				return nil, err
+			}
+			digest, err := gotoolprofile.FileSHA256(filename)
+			if err != nil || digest != source.Sources[name] {
+				return nil, fmt.Errorf("actual test dependency selected an unregistered original source")
+			}
+			proof.SourceSHA256[name] = digest
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		return names, nil
+	}
+	var err error
+	if proof.GoFiles, err = capture(actual.GoFiles, false); err != nil {
+		return gotoolprofile.TestSourcePackage{}, err
+	}
+	if proof.CompiledGoFiles, err = capture(actual.CompiledGoFiles, false); err != nil {
+		return gotoolprofile.TestSourcePackage{}, err
+	}
+	if proof.SFiles, err = capture(actual.OtherFiles, true); err != nil {
+		return gotoolprofile.TestSourcePackage{}, err
+	}
+	builtin := ""
+	if actual.PkgPath == "unsafe" {
+		if actual.ID != "unsafe" || actual.Name != "unsafe" || actual.Module != nil || actual.ExportFile != "" ||
+			len(actual.Imports) != 0 || len(proof.GoFiles) != 1 || proof.GoFiles[0] != "unsafe/unsafe.go" ||
+			len(proof.CompiledGoFiles) != 0 || len(proof.SFiles) != 0 {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("test dependency changed actual Go unsafe typechecker/documentation selection")
+		}
+		builtin = "go_typechecker_unsafe_v1"
+	}
+	if builtin == "" && !reflect.DeepEqual(proof.GoFiles, proof.CompiledGoFiles) {
+		return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency uses unproven generated/overlay/cgo source")
+	}
+	export := ""
+	if builtin == "" {
+		export, err = gotoolprofile.FileSHA256(actual.ExportFile)
+		if err != nil {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency lacks its actual same-profile export: %w", err)
+		}
+		if consumer.GeneratedGuard == nil {
+			consumer.GeneratedGuard = make(map[string]string)
+		}
+		if before, exists := consumer.GeneratedGuard[actual.ExportFile]; exists && before != export {
+			return gotoolprofile.TestSourcePackage{}, fmt.Errorf("foreign test dependency export changed during actual loading")
+		}
+		consumer.GeneratedGuard[actual.ExportFile] = export
+	}
+	imports := make(map[string]string)
+	for spelling, imported := range actual.Imports {
+		imports[spelling] = imported.PkgPath
+	}
+	embed, err := captureTestPackageEmbedSelection(proof, root, actual)
+	if err != nil {
+		return gotoolprofile.TestSourcePackage{}, err
+	}
+	return gotoolprofile.TestSourcePackage{
+		Package: proof, VariantID: actual.ID, ImportMap: imports, SourceRootID: id, ExportSHA256: export,
+		Builtin: builtin,
+		Embed:   embed,
+	}, nil
+}
+
+func (consumer *featureConsumer) bindTestModuleSource(source gotoolprofile.TestModuleSource, root, metadata string) error {
+	if consumer.TestModuleGuards == nil {
+		consumer.TestModuleGuards = make(map[string]testDependencyModuleGuard)
+	}
+	if prior, found := consumer.TestModuleGuards[source.ID()]; found {
+		if prior.Root != root || !reflect.DeepEqual(prior.Source, source) {
+			return fmt.Errorf("actual dependency source root/identity changed during loading")
+		}
+		if source.SourceModule != "" {
+			if err := consumer.bindTestModuleMetadata(&prior, metadata); err != nil {
+				return err
+			}
+			consumer.TestModuleGuards[source.ID()] = prior
+		} else if metadata != "" {
+			return fmt.Errorf("stdlib dependency acquired unexpected module metadata")
+		}
+		return nil // The complete roots/ZIPs are rechecked at each final guard.
+	}
+	guard := testDependencyModuleGuard{Source: source, Root: root}
+	if source.SourceModule != "" {
+		binary, err := exec.LookPath("go")
+		if err != nil {
+			return err
+		}
+		data, _, err := gotoolprofile.RunBounded(consumer.Context, consumer.WorkDir, consumer.Env, binary,
+			"mod", "download", "-json", source.ID())
+		if err != nil {
+			return err
+		}
+		var download struct {
+			Path, Version, Dir, Zip, GoMod, Sum, GoModSum, Error string
+		}
+		if err := json.Unmarshal(data, &download); err != nil || download.Error != "" ||
+			download.Path != source.SourceModule || download.Version != source.SourceVersion ||
+			download.Sum != source.ModuleSum || download.GoModSum != source.GoModSum {
+			return fmt.Errorf("actual foreign dependency download differs from exact pre-load ZIP/mod identity: %v", err)
+		}
+		actualRoot, err := sourcepath.Resolve(download.Dir)
+		if err != nil || actualRoot != root {
+			return fmt.Errorf("actual foreign dependency download has a different module directory")
+		}
+		guard.ZIP = download.Zip
+		guard.GoMod = download.GoMod
+		if err := consumer.bindTestModuleMetadata(&guard, metadata); err != nil {
+			return err
+		}
+	} else {
+		actualRoot, err := sourcepath.Resolve(filepath.Join(consumer.Root, "src"))
+		if err != nil || actualRoot != root || source.GoVersion != consumer.Observed.GoVersion {
+			return fmt.Errorf("stdlib dependency must use the actual reobserved Go source/tool root")
+		}
+	}
+	if err := gotoolprofile.VerifyTestModuleSource(consumer.Context, source, root, guard.ZIP); err != nil {
+		return fmt.Errorf("actual test dependency source root %s: %w", source.ID(), err)
+	}
+	consumer.TestModuleGuards[source.ID()] = guard
+	return nil
+}
+
+func (consumer *featureConsumer) bindTestModuleMetadata(guard *testDependencyModuleGuard, metadata string) error {
+	if err := gotoolprofile.VerifyTestModuleGoModMetadata(guard.Source, guard.Root, metadata, guard.GoMod); err != nil {
+		return err
+	}
+	paths := []string{metadata, guard.GoMod}
+	canonical := make([]string, len(paths))
+	for index, filename := range paths {
+		resolved, err := sourcepath.Resolve(filename)
+		if err != nil {
+			return fmt.Errorf("actual foreign dependency metadata path is inaccessible: %w", err)
+		}
+		if prior, exists := guard.MetadataPaths[filename]; exists && prior != resolved {
+			return fmt.Errorf("actual foreign dependency metadata path changed during loading")
+		}
+		if prior, exists := consumer.GeneratedGuard[filename]; exists && prior != guard.Source.GoModSHA256 {
+			return fmt.Errorf("actual foreign dependency metadata conflicts with earlier source identity")
+		}
+		canonical[index] = resolved
+	}
+	if guard.MetadataPaths == nil {
+		guard.MetadataPaths = make(map[string]string)
+	}
+	if consumer.GeneratedGuard == nil {
+		consumer.GeneratedGuard = make(map[string]string)
+	}
+	// An original ZIP go.mod may legitimately be copied by an actual Go load.
+	// Retain every observed copy, not just the first Module.GoMod path. Legacy
+	// proxy metadata still requires the exact download path in the verifier.
+	for index, filename := range paths {
+		guard.MetadataPaths[filename] = canonical[index]
+		consumer.GeneratedGuard[filename] = guard.Source.GoModSHA256
+	}
+	return nil
+}
+
+func (consumer *featureConsumer) verifyTestModuleSources() error {
+	for _, guard := range consumer.TestModuleGuards {
+		if err := gotoolprofile.VerifyTestModuleSource(consumer.Context, guard.Source, guard.Root, guard.ZIP); err != nil {
+			return fmt.Errorf("final test dependency source root %s: %w", guard.Source.ID(), err)
+		}
+		if guard.Source.SourceModule != "" {
+			if len(guard.MetadataPaths) == 0 {
+				return fmt.Errorf("final test dependency lacks its actual metadata path guards")
+			}
+			for filename, canonical := range guard.MetadataPaths {
+				if err := consumer.Context.Err(); err != nil {
+					return err
+				}
+				resolved, err := sourcepath.Resolve(filename)
+				if err != nil || resolved != canonical {
+					return fmt.Errorf("final test dependency metadata path changed: %s", guard.Source.ID())
+				}
+				if err := gotoolprofile.VerifyTestModuleGoModMetadata(guard.Source, guard.Root, filename, guard.GoMod); err != nil {
+					return fmt.Errorf("final test dependency metadata %s: %w", guard.Source.ID(), err)
+				}
+			}
+		}
+	}
+	return nil
+}
diff --git a/cmd/plan9asmll/test_dependency_modules_test.go b/cmd/plan9asmll/test_dependency_modules_test.go
new file mode 100644
index 000000000..5c3ba03cf
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_modules_test.go
@@ -0,0 +1,117 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestTestModuleConsumerRejectsCallerSuppliedStdlibRoot(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := []byte("package caller\n")
+	if err := os.WriteFile(filepath.Join(root, "caller.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	digest := featureBytesSHA256(data)
+	source := gotoolprofile.TestModuleSource{
+		Protocol: gotoolprofile.TestDependencyModuleProtocol, GoVersion: runtime.Version(),
+		Sources: map[string]string{"caller.go": digest}, Headers: map[string]string{"caller.go": string(data)},
+		Directories: map[string][]gotoolprofile.TestSourceEntry{
+			".": {{Name: "caller.go", Kind: "file", SHA256: digest}},
+		},
+	}
+	// A self-consistent snapshot is not authority to impersonate actual GOROOT.
+	if err := gotoolprofile.VerifyTestModuleSource(ctx, source, root, ""); err != nil {
+		t.Fatal(err)
+	}
+	consumer := featureConsumer{
+		Context: ctx, Root: runtime.GOROOT(), Observed: &gotoolprofile.Observation{GoVersion: runtime.Version()},
+	}
+	if err := consumer.bindTestModuleSource(source, root, ""); err == nil {
+		t.Fatal("caller-supplied stdlib@GoVersion temp root acquired actual Go source/tool authority")
+	}
+	if len(consumer.TestModuleGuards) != 0 {
+		t.Fatal("failed binding retained an authorized source-root guard")
+	}
+}
+
+func TestTestModuleConsumerRejectsActualModuleBoundaryChanges(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	consumer := featureConsumer{Input: &featureInput{Module: "example.invalid/main"}}
+	for name, actual := range map[string]*packages.Package{
+		"candidate reused as foreign": {
+			PkgPath: "example.invalid/main/loader",
+			Module:  &packages.Module{Path: "example.invalid/main", Version: "v1.0.0", Dir: root},
+		},
+		"unversioned owner": {
+			PkgPath: "example.invalid/main/loader",
+			Module:  &packages.Module{Path: "example.invalid/main/loader", Dir: root},
+		},
+		"package owner changed": {
+			PkgPath: "example.invalid/main/loader",
+			Module:  &packages.Module{Path: "example.invalid/other", Version: "v1.0.0", Dir: root},
+		},
+		"local replacement": {
+			PkgPath: "example.invalid/foreign",
+			Module: &packages.Module{
+				Path: "example.invalid/foreign", Version: "v1.0.0", Dir: root,
+				Replace: &packages.Module{Path: "../local", Dir: root},
+			},
+		},
+		"replacement source root changed": {
+			PkgPath: "example.invalid/foreign",
+			Module: &packages.Module{
+				Path: "example.invalid/foreign", Version: "v1.0.0", Dir: root,
+				Replace: &packages.Module{Path: "example.invalid/fork", Version: "v1.0.1", Dir: filepath.Join(root, "missing")},
+			},
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := consumer.foreignTestSourcePackage(actual); err == nil {
+				t.Fatal("unproven actual Module/Replace acquired foreign source authority")
+			}
+		})
+	}
+}
+
+func TestTestModuleConsumerExportGuardThroughFinalVerification(t *testing.T) {
+	input, root := testDeclarationRoleFixture(t, "linux/amd64")
+	root, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	export := filepath.Join(t.TempDir(), "actual-export.a")
+	before := []byte("owned actual export fixture")
+	if err := os.WriteFile(export, before, 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	consumer := featureConsumer{
+		Context: ctx, Input: input, Dir: root,
+		GeneratedGuard: map[string]string{export: featureBytesSHA256(before)},
+	}
+	if err := consumer.verifySources(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(export, []byte("changed after load"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.verifySources(); err == nil {
+		t.Fatal("actual dependency export changed before final object without failing")
+	}
+}
diff --git a/cmd/plan9asmll/test_dependency_query.go b/cmd/plan9asmll/test_dependency_query.go
new file mode 100644
index 000000000..99c17db14
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_query.go
@@ -0,0 +1,157 @@
+package main
+
+import (
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// Reuse the actual packages.Load pre-type/export selection. The private
+// producer inventory must agree before typechecking and again afterwards;
+// ordinary package capture remains untouched.
+func (consumer *featureConsumer) bindActualTestDependencies(ordinary, selected *packages.Package) error {
+	if consumer.Input.TestDependencySourceProtocol == "" {
+		return nil // Historical consumer inputs retain their original contract.
+	}
+	dependency := consumer.Input.TestDependencies
+	if dependency == nil || dependency.Protocol != gotoolprofile.TestDependencyProtocol {
+		return fmt.Errorf("actual test declaration lacks a pre-load source-only closure")
+	}
+	if err := gotoolprofile.ValidateTestDependencyPreload(consumer.Input, dependency, consumer.Proof.CustomTags); err != nil {
+		return err
+	}
+	var actual []gotoolprofile.TestSourcePackage
+	var foreign []gotoolprofile.TestSourcePackage
+	var captureErr error
+	boundEmbeds := make(map[string]testDependencyEmbedGuard)
+	packages.Visit([]*packages.Package{selected}, func(pkg *packages.Package) bool {
+		if captureErr != nil {
+			return false
+		}
+		if pkg.Module == nil || pkg.Module.Path != consumer.Input.Module {
+			source, err := consumer.foreignTestSourcePackage(pkg)
+			if err != nil {
+				captureErr = err
+				return false
+			}
+			foreign = append(foreign, source)
+			boundEmbeds[pkg.ID] = testDependencyEmbedGuard{Source: source, Root: consumer.TestModuleGuards[source.SourceRootID].Root}
+			return true
+		}
+		if !reflect.DeepEqual(pkg.Module, ordinary.Module) || pkg.PkgPath != consumer.Input.Module && !strings.HasPrefix(pkg.PkgPath, consumer.Input.Module+"/") {
+			captureErr = fmt.Errorf("test dependency has a different actual module/version/source identity")
+			return false
+		}
+		var template *gotoolprofile.PackageProof
+		for index := range consumer.Proof.Packages {
+			if consumer.Proof.Packages[index].PackagePath == ordinary.PkgPath {
+				template = &consumer.Proof.Packages[index]
+			}
+		}
+		if template == nil {
+			captureErr = fmt.Errorf("test dependency lacks its actual ordinary source role")
+			return false
+		}
+		proof := *template
+		proof.PackagePath, proof.Macros, proof.SourceSHA256 = pkg.PkgPath, nil, make(map[string]string)
+		capture := func(files []string, assembly bool) []string {
+			var result []string
+			for _, filename := range files {
+				if assembly && filepath.Ext(filename) != ".s" {
+					continue
+				}
+				name, err := consumer.sourceName(filename)
+				if err != nil {
+					captureErr = err
+					return nil
+				}
+				proof.SourceSHA256[name] = consumer.Input.Sources[name]
+				result = append(result, name)
+			}
+			sort.Strings(result)
+			return result
+		}
+		proof.GoFiles = capture(pkg.GoFiles, false)
+		proof.CompiledGoFiles = capture(pkg.CompiledGoFiles, false)
+		proof.SFiles = capture(pkg.OtherFiles, true)
+		imports := make(map[string]string)
+		for spelling, imported := range pkg.Imports {
+			imports[spelling] = imported.PkgPath
+		}
+		embed, err := captureTestPackageEmbedSelection(proof, consumer.Dir, pkg)
+		if err != nil {
+			captureErr = err
+			return false
+		}
+		source := gotoolprofile.TestSourcePackage{Package: proof, VariantID: pkg.ID, ImportMap: imports, Embed: embed}
+		actual = append(actual, source)
+		boundEmbeds[pkg.ID] = testDependencyEmbedGuard{Source: source, Root: consumer.Dir}
+		return true
+	}, nil)
+	if captureErr != nil {
+		return captureErr
+	}
+	sort.Slice(actual, func(i, j int) bool { return actual[i].Package.PackagePath < actual[j].Package.PackagePath })
+	sort.Slice(foreign, func(i, j int) bool { return foreign[i].Package.PackagePath < foreign[j].Package.PackagePath })
+	if !reflect.DeepEqual(actual, dependency.Packages) || !reflect.DeepEqual(foreign, dependency.ExternalPackages) ||
+		len(consumer.TestModuleGuards) != len(dependency.SourceModules) {
+		for _, pair := range []struct {
+			actual, expected []gotoolprofile.TestSourcePackage
+		}{
+			{actual: actual, expected: dependency.Packages},
+			{actual: foreign, expected: dependency.ExternalPackages},
+		} {
+			for index, source := range pair.actual {
+				if index < len(pair.expected) && !reflect.DeepEqual(source.Embed, pair.expected[index].Embed) {
+					return fmt.Errorf("actual same-profile embed inventory differs: package=%s actual=%+v expected=%+v", source.Package.PackagePath, source.Embed, pair.expected[index].Embed)
+				}
+			}
+		}
+		return fmt.Errorf("actual same-profile test dependency selection differs from complete pre-load inventory")
+	}
+	consumer.Proof.TestDependencies = dependency
+	consumer.TestEmbedGuards = boundEmbeds
+	return consumer.verifySources()
+}
+
+func (consumer *featureConsumer) queryMissingSignatureSources(pkg *packages.Package, file *plan9asm.File, asm string,
+	resolve func(string) string, goarch string,
+) ([]gotoolprofile.SignatureRequest, error) {
+	requests, err := assemblySignatureRequests(pkg.PkgPath, file, resolve)
+	if err != nil {
+		return nil, err
+	}
+	filename, err := consumer.sourceName(asm)
+	if err != nil {
+		return nil, err
+	}
+	var result []gotoolprofile.SignatureRequest
+	for symbol, request := range requests {
+		internal := strings.HasSuffix(request.original, "<ABIInternal>")
+		_, _, found, err := tryDeclSig(pkg.Types.Scope(), request.original, symbol,
+			linknameRemoteToLocal(pkg.Syntax), goarch, pkg.TypesSizes, internal)
+		if err != nil {
+			return nil, err
+		}
+		if found || strings.Contains(request.original, "<>") || !strings.HasPrefix(symbol, pkg.PkgPath+".") {
+			continue
+		}
+		name := strings.TrimPrefix(symbol, pkg.PkgPath+".")
+		candidate, err := consumer.testDeclarationCandidate(pkg, filepath.Dir(asm), name)
+		if err != nil {
+			return nil, err
+		}
+		if candidate {
+			result = append(result, gotoolprofile.SignatureRequest{
+				File: filename, Symbol: symbol, Callee: request.callee, ABIInternal: internal,
+			})
+		}
+	}
+	return result, consumer.verifySources()
+}
diff --git a/cmd/plan9asmll/test_dependency_query_test.go b/cmd/plan9asmll/test_dependency_query_test.go
new file mode 100644
index 000000000..e9417da77
--- /dev/null
+++ b/cmd/plan9asmll/test_dependency_query_test.go
@@ -0,0 +1,59 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestSignatureSourceQueryAdequateOrdinaryTypesIgnorePoisonTests(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, dir := testDeclarationRoleFixture(t, "linux/amd64")
+	input.TestDependencySourceProtocol = gotoolprofile.TestDependencyProtocol
+	files := map[string]string{
+		"layout.go": `package header
+func U8ToF32s(x uint8) float32
+func EchoF32(x float32) float32
+func EchoF64(x float64) float64
+`,
+		"decl_test.go": `package header
+import "missing.invalid/poison"
+func UnusedBodyless() float64
+var Poison = undefinedTestOnly
+`,
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = featureBytesSHA256([]byte(source)), source
+	}
+	t.Chdir(dir)
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+	defer cancel()
+	config, err := resolveCompileConfig(false, "", false, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	query := &gotoolprofile.SignatureQueryProof{Protocol: gotoolprofile.SignatureQueryProtocol}
+	config.FeaturePath, config.Context, config.SignatureQuery = writeFeatureInput(t, input), ctx, query
+	report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil,
+		input.AsmFiles, input.Module, t.TempDir(), false, 0, false, false, true, repo, config)
+	if err != nil || report.Failed != 0 || report.Success != 0 || len(query.Requests) != 0 ||
+		query.Selection == nil || len(query.Selection.Outputs) != 0 || len(query.Selection.TestDeclarations) != 0 {
+		t.Fatalf("adequate actual ordinary types loaded poison tests or fabricated object success: %#v, %v", report, err)
+	}
+	if err := gotoolprofile.ValidateSignatureQuery(input, query, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := gotoolprofile.ValidateSelection(input, query.Selection, nil, true); err == nil {
+		t.Fatal("missing-reference query was accepted as final translation/object proof")
+	}
+}
diff --git a/cmd/plan9asmll/testdata/testsignature/convert_test.go b/cmd/plan9asmll/testdata/testsignature/convert_test.go
new file mode 100644
index 000000000..165881761
--- /dev/null
+++ b/cmd/plan9asmll/testdata/testsignature/convert_test.go
@@ -0,0 +1,3 @@
+package testsignature
+
+func convert(byte) float32
diff --git a/cmd/plan9asmll/testdata/testsignature/convert_test_amd64.s b/cmd/plan9asmll/testdata/testsignature/convert_test_amd64.s
new file mode 100644
index 000000000..abea3ba2a
--- /dev/null
+++ b/cmd/plan9asmll/testdata/testsignature/convert_test_amd64.s
@@ -0,0 +1,3 @@
+TEXT ·convert(SB),$0-12
+	MOVSS X0, ret+8(FP)
+	RET
diff --git a/cmd/plan9asmll/testdata/testsignature/package.go b/cmd/plan9asmll/testdata/testsignature/package.go
new file mode 100644
index 000000000..bc9ac3b2d
--- /dev/null
+++ b/cmd/plan9asmll/testdata/testsignature/package.go
@@ -0,0 +1 @@
+package testsignature
diff --git a/cmd/plan9asmll/unsigned_scalar_integer_float_extraction_test.go b/cmd/plan9asmll/unsigned_scalar_integer_float_extraction_test.go
new file mode 100644
index 000000000..daa1d2b92
--- /dev/null
+++ b/cmd/plan9asmll/unsigned_scalar_integer_float_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteUnsignedScalarIntegerFloatIsolatedSource(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const name = "amd64_lower_scalar_integer_float.go"
+	source, err := os.ReadFile(filepath.Join(repo, name))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for file, data := range map[string][]byte{name: source, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(isolated, file), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, repo} {
+		for _, arch := range []string{"amd64", "386"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, op := range []string{"VCVTUSI2SDL", "VCVTUSI2SDQ", "VCVTUSI2SSL", "VCVTUSI2SSQ"} {
+				if _, present := supported[op]; !present {
+					t.Fatal("isolated scalar conversion registry omitted a complete unsigned member", arch, op)
+				}
+			}
+			for _, invalid := range []string{"VCVTUSI2SDL.RN_SAE", "VCVTUSI2SSL.Z", "VCVTUSI2SSQ.BCST", "amd64ScalarIntegerFloatOps"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("unsigned registry advertised a control or Go identifier as an opcode", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/unsupported_diagnostics_test.go b/cmd/plan9asmll/unsupported_diagnostics_test.go
new file mode 100644
index 000000000..acafe8bd8
--- /dev/null
+++ b/cmd/plan9asmll/unsupported_diagnostics_test.go
@@ -0,0 +1,138 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Exercise the real report path. Its hints must describe the same expanded,
+// target-selected instructions that failed, not a second raw-source scan.
+func TestUnsupportedDiagnosticsUseActualCompilationInput(t *testing.T) {
+	repo, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOFLAGS", "")
+	t.Setenv("GOWORK", "off")
+
+	cases := []struct {
+		name, source, failure string
+		ops                   []string
+		hits                  int
+	}{
+		{
+			name:    "supported-multiline-macro-context",
+			source:  "#define SLEEPCALL \\\nMOVD $101,R8; \\\nSVC; \\\nRET\nTEXT ·F(SB),NOSPLIT,$0-0\nSLEEPCALL\n",
+			failure: "instruction probe needs function context",
+		},
+		{
+			name:    "inactive-target-instruction",
+			source:  "TEXT ·F(SB),NOSPLIT,$0-0\n#ifdef GOOS_windows\nHIDDENOP R0,R1\n#else\nMOVD $101,R8\nSVC\n#endif\nRET\n",
+			failure: "instruction probe needs function context",
+		},
+		{
+			name:    "actual-expanded-unknown-instruction",
+			source:  "#define BROKEN \\\nNOTIMPLEMENTED R0,R1; \\\nRET\nTEXT ·F(SB),NOSPLIT,$0-0\nBROKEN\n",
+			failure: "NOTIMPLEMENTED", ops: []string{"NOTIMPLEMENTED"}, hits: 1,
+		},
+		{
+			name:    "parse-failure-has-no-instruction-inventory",
+			source:  "TEXT ·F(SB),NOSPLIT,$invalid-0\n#ifdef GOOS_windows\nHIDDENOP R0,R1\n#endif\nRET\n",
+			failure: "parse asm:",
+		},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			dir := t.TempDir()
+			for name, source := range map[string]string{
+				"go.mod":        "module example.invalid/opdiagnostic\n\ngo 1.24\n",
+				"value.go":      "package opdiagnostic\nfunc F()\n",
+				"value_arm64.s": "#include \"textflag.h\"\n" + test.source,
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			t.Chdir(dir)
+			report, _, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "arm64"},
+				[]string{"."}, nil, nil, "", t.TempDir(), false, 0, true, false, true, repo, compileConfig{})
+			if err != nil || report.TotalAsm != 1 || report.Success != 0 || report.Failed != 1 ||
+				report.NotApplicable != 0 || len(report.Fails) != 1 {
+				t.Fatalf("real failed compilation was lost: report=%+v err=%v", report, err)
+			}
+			failure := report.Fails[0]
+			if !strings.Contains(failure.Err, test.failure) {
+				t.Fatalf("wrong actual failure: %s", failure.Err)
+			}
+			if !reflect.DeepEqual(failure.Unsupported, test.ops) || len(failure.UnsupportedHits) != test.hits {
+				t.Fatalf("hints differ from actual selected instructions: ops=%v hits=%+v", failure.Unsupported, failure.UnsupportedHits)
+			}
+			for _, hit := range failure.UnsupportedHits {
+				if hit.Op != "NOTIMPLEMENTED" || !strings.Contains(hit.Source, "NOTIMPLEMENTED R0,R1") {
+					t.Fatalf("macro text or noninstruction became an opcode hint: %+v", hit)
+				}
+			}
+		})
+	}
+}
+
+func TestInstructionDiagnosticsCollectCompleteParsedFiveArchInputs(t *testing.T) {
+	for _, row := range []struct {
+		name string
+		arch plan9asm.Arch
+	}{
+		{"386", plan9asm.ArchAMD64},
+		{"amd64", plan9asm.ArchAMD64},
+		{"arm", plan9asm.ArchARM},
+		{"arm64", plan9asm.ArchARM64},
+		{"wasm", plan9asm.ArchWASM},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := "DATA text<>+0(SB)/8,$\"a;BOGUS\"\n" +
+				"TEXT first(SB),$0-0\nNOTIMPLEMENTED\nRET\n" +
+				"TEXT second(SB),$0-0\nNOTIMPLEMENTED\nRET\n"
+			goos := "linux"
+			if row.name == "wasm" {
+				goos = "js"
+			}
+			file, err := plan9asm.ParseWithDefines(row.arch, source, plan9asm.GoAssemblerDefines(goos, row.name))
+			if err != nil {
+				t.Fatal(err)
+			}
+			diagnostics := instructionDiagnostics{supported: map[string]struct{}{"RET": {}}}
+			diagnostics.collect(file)
+			if !reflect.DeepEqual(diagnostics.ops, []string{"NOTIMPLEMENTED"}) || len(diagnostics.hits) != 2 {
+				t.Fatalf("lost complete parsed instruction inventory: %+v", diagnostics)
+			}
+			for index, hit := range diagnostics.hits {
+				if hit.Function != file.Funcs[index].Sym || hit.Instruction <= 0 || hit.Line != 0 ||
+					hit.Source != "NOTIMPLEMENTED" || hit.Op != "NOTIMPLEMENTED" {
+					t.Fatalf("hint invented an original line or lost its parsed function: %+v", hit)
+				}
+			}
+			diagnostics.collect(nil)
+			if diagnostics.ops != nil || diagnostics.hits != nil {
+				t.Fatal("absent input retained another file's hints")
+			}
+		})
+	}
+}
+
+func TestInstructionDiagnosticsResetBeforeFailedSourceRead(t *testing.T) {
+	diagnostics := instructionDiagnostics{
+		supported: map[string]struct{}{"RET": {}},
+		ops:       []string{"STALE"},
+		hits:      []unsupportedHit{{Op: "STALE"}},
+	}
+	err := compileOne(nil, plan9asm.ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu",
+		asmTask{AsmFile: filepath.Join(t.TempDir(), "absent_arm64.s")}, false,
+		compileConfig{diagnostics: &diagnostics})
+	if err == nil || !strings.Contains(err.Error(), "read asm:") || diagnostics.ops != nil || diagnostics.hits != nil {
+		t.Fatalf("failed read reused another compilation's hints: %v %+v", err, diagnostics)
+	}
+}
diff --git a/cmd/plan9asmll/vector_test_extraction_test.go b/cmd/plan9asmll/vector_test_extraction_test.go
new file mode 100644
index 000000000..0ccf795a6
--- /dev/null
+++ b/cmd/plan9asmll/vector_test_extraction_test.go
@@ -0,0 +1,43 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsCompleteVectorTestTypedFamily(t *testing.T) {
+	repo, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(repo, "amd64_lower_vecflags.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	if err := os.WriteFile(filepath.Join(isolated, "amd64_lower_vecflags.go"), source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(isolated, "translate.go"), []byte("package plan9asm\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, root := range []string{isolated, repo} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"PTEST", "VPTEST", "VTESTPD", "VTESTPS"} {
+				if _, present := supported[name]; !present {
+					t.Fatal("complete typed vector-test registry omitted a source name", arch, name)
+				}
+			}
+			for _, invalid := range []string{"PTEST.Z", "VTESTPD.BCST", "VTEST", "amd64VectorTestSpecs"} {
+				if _, present := supported[invalid]; present {
+					t.Fatal("vector-test extraction advertised a non-source spelling", arch, invalid)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/wasm_float_binary_specs_test.go b/cmd/plan9asmll/wasm_float_binary_specs_test.go
new file mode 100644
index 000000000..8226cf71e
--- /dev/null
+++ b/cmd/plan9asmll/wasm_float_binary_specs_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteWasmFloatBinarySpec(t *testing.T) {
+	const filename = "wasm_float_binary.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(isolated, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, "../.."} {
+		for _, arch := range []string{"wasm", "386", "amd64", "arm", "arm64"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			count := 0
+			for _, width := range []string{"F32", "F64"} {
+				for _, operation := range []string{"EQ", "NE", "LT", "GT", "LE", "GE", "MIN", "MAX"} {
+					name := width + operation
+					_, present := supported[name]
+					if present != (arch == "wasm") {
+						t.Errorf("%s extraction %s present=%v; architecture-specific map consumer changed", arch, name, present)
+					}
+					count++
+				}
+			}
+			if count != 16 {
+				t.Fatal("complete Wasm comparison/minmax inventory changed", count)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/wasm_v128_core_specs_test.go b/cmd/plan9asmll/wasm_v128_core_specs_test.go
new file mode 100644
index 000000000..c16b7b6e0
--- /dev/null
+++ b/cmd/plan9asmll/wasm_v128_core_specs_test.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestExtractSupportedOpsFindsCompleteWasmV128CoreSpec(t *testing.T) {
+	const filename = "wasm_v128_core.go"
+	source, err := os.ReadFile(filepath.Join("../..", filename))
+	if err != nil {
+		t.Fatal(err)
+	}
+	isolated := t.TempDir()
+	for name, contents := range map[string][]byte{
+		filename: source, "translate.go": []byte("package plan9asm\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(isolated, name), contents, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, root := range []string{isolated, "../.."} {
+		for _, arch := range []string{"wasm", "386", "amd64", "arm", "arm64"} {
+			supported, err := extractSupportedOps(root, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"V128CONST", "V128NOT", "V128AND", "V128ANDNOT", "V128OR", "V128XOR", "V128BITSELECT", "V128ANYTRUE"} {
+				_, present := supported[name]
+				if present != (arch == "wasm") {
+					t.Errorf("%s extraction %s present=%t; V128 core escaped its architecture", arch, name, present)
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/x86_caller_cpp_scope_test.go b/cmd/plan9asmll/x86_caller_cpp_scope_test.go
new file mode 100644
index 000000000..211844c9f
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_cpp_scope_test.go
@@ -0,0 +1,246 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+type x86CallerCPPFixture struct {
+	pkg     *packages.Package
+	file    *plan9asm.File
+	config  compileConfig
+	input   *featureInput
+	root    string
+	defines []string
+	resolve func(string) string
+	sigs    map[string]plan9asm.FuncSig
+}
+
+func makeX86CallerCPPFixture(t *testing.T, companion string, localHeader bool, expandedSDK bool) x86CallerCPPFixture {
+	t.Helper()
+	extra := map[string]string{"other_amd64.s": companion}
+	if localHeader {
+		extra["bias.h"] = "#define BIAS 7\n"
+	}
+	pkg, file, config := x86CallerCLILoad(t, extra)
+	root, err := filepath.EvalSymlinks(pkg.Dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := &featureInput{
+		Module: pkg.PkgPath, AsmFiles: []string{"kernel_amd64.s"},
+		Sources: map[string]string{}, Headers: map[string]string{},
+		CPPSourceProtocol: gotoolprofile.CPPOriginalReplayProtocol,
+		CPPOriginals: &gotoolprofile.CPPOriginalReplayInput{
+			Sources: map[string]string{},
+			Units:   map[string]gotoolprofile.CPPOriginalUnit{},
+			RequiredExpandedOperands: map[string][]gotoolprofile.CPPPackageSearchMiss{
+				"kernel_amd64.s": {},
+			},
+		},
+	}
+	for name := range extra {
+		text := []byte(extra[name])
+		input.Sources[name] = featureBytesSHA256(text)
+		input.Headers[name] = string(text)
+		input.CPPOriginals.Sources["module/"+name] = string(text)
+	}
+	for _, name := range []string{"kernel_amd64.s", "other_amd64.s"} {
+		text, err := os.ReadFile(filepath.Join(root, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = featureBytesSHA256(text)
+		input.Headers[name] = string(text)
+		input.CPPOriginals.Sources["module/"+name] = string(text)
+		input.CPPOriginals.Units[name] = gotoolprofile.CPPOriginalUnit{
+			Includes: map[string]string{},
+		}
+	}
+	unit := input.CPPOriginals.Units["other_amd64.s"]
+	if localHeader {
+		unit.Includes["bias.h"] = "module/bias.h"
+	}
+	if expandedSDK {
+		tool := "src/runtime/go_tls.h"
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+		if err != nil {
+			t.Fatal(err)
+		}
+		input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+		input.CPPOriginals.Sources["tool/"+tool] = string(data)
+		unit.Includes["../../src/runtime/go_tls.h"] = "tool/" + tool
+	}
+	config.Feature = &featureConsumer{
+		Input: input, Context: config.Context, Dir: root, Root: runtime.GOROOT(),
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+	for _, name := range []string{"kernel_amd64.s", "other_amd64.s"} {
+		object := filepath.Join(t.TempDir(), "original.o")
+		args := []string{"tool", "asm", "-p", pkg.PkgPath,
+			"-I", filepath.Join(runtime.GOROOT(), "pkg/include"), "-o", object}
+		for _, define := range defines {
+			args = append(args, "-D", define)
+		}
+		args = append(args, filepath.Join(root, name))
+		env := append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+		stdout, stderr, err := gotoolprofile.RunBounded(config.Context, root, env, "go", args...)
+		if err != nil || len(stdout) != 0 || len(stderr) != 0 {
+			t.Fatalf("actual original companion assembly %s: %v\n%s\n%s", name, err, stdout, stderr)
+		}
+		if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+			t.Fatalf("missing original companion object: %v", err)
+		}
+	}
+	return x86CallerCPPFixture{
+		pkg: pkg, file: file, config: config, input: input, root: root,
+		defines: defines, resolve: resolve, sigs: sigs,
+	}
+}
+
+func (fixture x86CallerCPPFixture) bind() (map[string]plan9asm.FuncSig, *x86CallerTypedPackage, error) {
+	return bindX86CallerRegions(fixture.pkg, fixture.file, "linux/amd64", "amd64",
+		filepath.Join(fixture.root, "kernel_amd64.s"), fixture.defines,
+		fixture.config, fixture.resolve, fixture.sigs)
+}
+
+// The actual package selection is broader than the one-file object request.
+// All companion bytes still enter the caller/exposure closure.
+func TestX86CallerCLICompanionCPPIsSeparateFromObjectConsumption(t *testing.T) {
+	cases := []struct {
+		name        string
+		source      string
+		localHeader bool
+		expandedSDK bool
+	}{
+		{"literal", "TEXT ·other(SB),4,$0-0\nRET\n", false, false},
+		{"local_macro", "#include \"bias.h\"\nTEXT ·other(SB),4,$0-0\nMOVQ $BIAS,AX\nRET\n", true, false},
+		{"expanded_sdk", "#define SELECT \\\n#include \"../../src/runtime/go_tls.h\" \\\n\nSELECT\nTEXT ·other(SB),4,$0-0\nRET\n", false, true},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			fixture := makeX86CallerCPPFixture(t, test.source, test.localHeader, test.expandedSDK)
+			before, err := json.Marshal(fixture.input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound, loaded, err := fixture.bind()
+			if err != nil || loaded == nil {
+				t.Fatalf("actual selected companion must close source exposure without borrowing an object receipt: %v", err)
+			}
+			after, err := json.Marshal(fixture.input)
+			if err != nil || !reflect.DeepEqual(before, after) {
+				t.Fatalf("caller closure mutated the original object input: %v", err)
+			}
+			if _, _, err := fixture.config.Feature.preprocessCPP(
+				filepath.Join(fixture.root, "other_amd64.s"), fixture.pkg.PkgPath, fixture.defines); err == nil {
+				t.Fatal("source-only companion acquired missing final CPP/object authority")
+			}
+
+			ccfg, err := resolveCompileConfig(true, "", true, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ccfg.Context = fixture.config.Context
+			task := asmTask{OutLL: filepath.Join(t.TempDir(), "caller.ll")}
+			if err := translateAndCompileModule(fixture.file, targetTriple("linux", "amd64"),
+				"amd64", task, false, ccfg, fixture.resolve, bound); err != nil {
+				t.Fatalf("closed actual caller failed LLVM 22 object compilation: %v", err)
+			}
+			object := strings.TrimSuffix(task.OutLL, ".ll") + ".o"
+			if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+				t.Fatalf("missing actual LLVM 22 caller object: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLICompanionCPPStillClosesAssemblyExposures(t *testing.T) {
+	for name, source := range map[string]string{
+		"call":    "TEXT ·other(SB),4,$0-0\nCALL ·kernel(SB)\nRET\n",
+		"address": "TEXT ·other(SB),4,$0-0\nLEAQ ·kernel(SB),AX\nRET\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			fixture := makeX86CallerCPPFixture(t, source, false, false)
+			if _, _, err := fixture.bind(); err == nil {
+				t.Fatal("actual companion exposure obtained a raw-return caller region")
+			}
+		})
+	}
+}
+
+func TestX86CallerCLICompanionCPPRejectsChangedProofAndPhysicalInputs(t *testing.T) {
+	for _, axis := range []string{
+		"missing requested set", "null requested set", "missing unit",
+		"changed graph", "paired graph hash", "changed companion", "changed local header",
+	} {
+		t.Run(axis, func(t *testing.T) {
+			fixture := makeX86CallerCPPFixture(t,
+				"#include \"bias.h\"\nTEXT ·other(SB),4,$0-0\nMOVQ $BIAS,AX\nRET\n", true, false)
+			switch axis {
+			case "missing requested set":
+				delete(fixture.input.CPPOriginals.RequiredExpandedOperands, "kernel_amd64.s")
+			case "null requested set":
+				fixture.input.CPPOriginals.RequiredExpandedOperands["kernel_amd64.s"] = nil
+			case "missing unit":
+				delete(fixture.input.CPPOriginals.Units, "other_amd64.s")
+			case "changed graph", "paired graph hash":
+				name := "module/other_amd64.s"
+				changed := fixture.input.CPPOriginals.Sources[name] + "// changed\n"
+				fixture.input.CPPOriginals.Sources[name] = changed
+				if axis == "paired graph hash" {
+					fixture.input.Sources["other_amd64.s"] = featureBytesSHA256([]byte(changed))
+				}
+			case "changed companion", "changed local header":
+				name, text := "other_amd64.s", "TEXT ·other(SB),4,$0-0\nCALL ·kernel(SB)\nRET\n"
+				if axis == "changed local header" {
+					name, text = "bias.h", "#define BIAS 8\n"
+				}
+				if err := os.WriteFile(filepath.Join(fixture.root, name), []byte(text), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if _, _, err := fixture.bind(); err == nil {
+				t.Fatalf("changed %s obtained caller closure", axis)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLICompanionCPPRemainsGuardedThroughFinalObject(t *testing.T) {
+	for _, name := range []string{"other_amd64.s", "bias.h"} {
+		t.Run(name, func(t *testing.T) {
+			fixture := makeX86CallerCPPFixture(t,
+				"#include \"bias.h\"\nTEXT ·other(SB),4,$0-0\nMOVQ $BIAS,AX\nRET\n", true, false)
+			_, loaded, err := fixture.bind()
+			if err != nil || loaded == nil {
+				t.Fatalf("unchanged companion failed source closure: %v", err)
+			}
+			path := filepath.Join(fixture.root, name)
+			original, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(path, append(original, []byte("// changed\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := loaded.verify(fixture.config.Context, fixture.defines, fixture.config.Feature); err == nil {
+				t.Fatalf("changed companion %s survived the final object guard", name)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_caller_cpp_tripwire_test.go b/cmd/plan9asmll/x86_caller_cpp_tripwire_test.go
new file mode 100644
index 000000000..3ac9484af
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_cpp_tripwire_test.go
@@ -0,0 +1,350 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+// Keep the preferred outside-module path inside this fixture's own temporary
+// root. Neither the host TMPDIR nor the selected SDK is changed by these tests.
+func callerCPPDeepFixture(t *testing.T, companion string, generated bool) x86CallerCPPFixture {
+	t.Helper()
+	owned := t.TempDir()
+	dir := filepath.Join(owned, "owned", "module")
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		t.Fatal(err)
+	}
+	dir, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod":         "module example.com/caller\n\ngo 1.20\n",
+		"caller.go":      x86CallerCLISource,
+		"kernel_amd64.s": x86CallerCLIAssembly,
+		"other_amd64.s":  companion,
+	}
+	if generated {
+		files["layout.go"] = "package caller\nconst Bias = 7\n"
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOMAXPROCS", "2")
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	t.Cleanup(cancel)
+	pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, "example.com/caller", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual companion package selection: %v (packages=%d)", err, len(pkgs))
+	}
+	pkg := pkgs[0]
+	root, err := filepath.EvalSymlinks(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := &featureInput{
+		Protocol: featureInputProtocol, Module: pkg.PkgPath, SourceRoot: root,
+		AsmFiles:           []string{"kernel_amd64.s"},
+		RegisteredAsmFiles: []string{"kernel_amd64.s", "other_amd64.s"},
+		Sources:            map[string]string{}, Headers: map[string]string{},
+		Directories:       map[string][]string{".": {}},
+		CPPSourceProtocol: gotoolprofile.CPPOriginalReplayProtocol,
+		CPPOriginals: &gotoolprofile.CPPOriginalReplayInput{
+			Sources: map[string]string{}, Units: map[string]gotoolprofile.CPPOriginalUnit{},
+			RequiredExpandedOperands: map[string][]gotoolprofile.CPPPackageSearchMiss{
+				"kernel_amd64.s": {},
+			},
+		},
+	}
+	for name, source := range files {
+		input.Directories["."] = append(input.Directories["."], name)
+		input.Sources[name] = featureBytesSHA256([]byte(source))
+		if filepath.Ext(name) == ".go" || filepath.Ext(name) == ".s" {
+			input.Headers[name] = source
+		}
+		if filepath.Ext(name) == ".s" {
+			input.CPPOriginals.Sources["module/"+name] = source
+			input.CPPOriginals.Units[name] = gotoolprofile.CPPOriginalUnit{Includes: map[string]string{}}
+		}
+	}
+	sort.Strings(input.Directories["."])
+	unit := input.CPPOriginals.Units["other_amd64.s"]
+	if generated {
+		unit.GeneratedHeaders = []string{"go_asm.h"}
+	} else {
+		tool := "src/runtime/go_tls.h"
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), tool))
+		if err != nil {
+			t.Fatal(err)
+		}
+		input.ToolSources = map[string]string{tool: featureBytesSHA256(data)}
+		input.CPPOriginals.Sources["tool/"+tool] = string(data)
+		unit.Includes["../../src/runtime/go_tls.h"] = "tool/" + tool
+	}
+	input.CPPOriginals.Units["other_amd64.s"] = unit
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, x86CallerCLIAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	config := compileConfig{
+		Context: ctx, x86CallerSelections: captureX86CallerSelections(pkgs, "linux/amd64", nil),
+		Feature: &featureConsumer{Input: input, Context: ctx, Dir: root, Root: runtime.GOROOT()},
+	}
+	return x86CallerCPPFixture{
+		pkg: pkg, file: file, config: config, input: input, root: root,
+		defines: plan9asm.GoAssemblerDefines("linux", "amd64"), resolve: resolve, sigs: sigs,
+	}
+}
+
+func callerCPPOriginalObject(t *testing.T, fixture x86CallerCPPFixture, name, headerDir string) {
+	t.Helper()
+	object := filepath.Join(t.TempDir(), "original.o")
+	args := []string{"tool", "asm", "-p", fixture.pkg.PkgPath,
+		"-I", filepath.Join(runtime.GOROOT(), "pkg/include"), "-o", object}
+	if headerDir != "" {
+		args = append(args, "-I", headerDir)
+	}
+	for _, define := range fixture.defines {
+		args = append(args, "-D", define)
+	}
+	args = append(args, filepath.Join(fixture.root, name))
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+	stdout, stderr, err := gotoolprofile.RunBounded(fixture.config.Context, fixture.root, env, "go", args...)
+	if err != nil || len(stdout) != 0 || len(stderr) != 0 {
+		t.Fatalf("actual Go companion object %s: %v\n%s\n%s", name, err, stdout, stderr)
+	}
+	if info, err := os.Lstat(object); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("actual Go companion produced no regular object: %v", err)
+	}
+	digest, err := gotoolprofile.FileSHA256(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("GO_ORIGINAL_COMPANION_OBJECT file=%s source_sha256=%s object_sha256=%s",
+		name, fixture.input.Sources[name], digest)
+}
+
+func TestX86CallerCLICompanionGeneratedHeaderRetainsActualOrigin(t *testing.T) {
+	fixture := callerCPPDeepFixture(t,
+		"#include \"go_asm.h\"\nTEXT ·other(SB),4,$0-0\nMOVQ $const_Bias,AX\nRET\n", true)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixture.input.Observed, err = gotoolprofile.Capture(fixture.config.Context, binary, t.TempDir(),
+		os.Environ(), "linux/amd64", nil, gotoolprofile.RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixture.input.ID = gotoolprofile.ProfileID(fixture.input.Observed)
+	metadata, err := queryGeneratedHeaders(targetSpec{Goos: "linux", Goarch: "amd64"},
+		[]string{"."}, nil, fixture.input.AsmFiles, fixture.input.Module, t.TempDir(),
+		compileConfig{Context: fixture.config.Context, FeaturePath: writeFeatureInput(t, fixture.input)})
+	if err != nil {
+		t.Fatalf("actual generated-header producer: %v", err)
+	}
+	fixture.input.GeneratedHeaders = metadata
+	consumer, err := loadFeatureConsumer(fixture.config.Context, writeFeatureInput(t, fixture.input),
+		t.TempDir(), "linux/amd64", fixture.input.Module, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkgs, err := loadGeneratedHeaderPackages(consumer, []string{"."}, nil)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual generated-header consumer selection: %v (packages=%d)", err, len(pkgs))
+	}
+	if err := consumer.capturePackages(pkgs); err != nil {
+		t.Fatal(err)
+	}
+	output := t.TempDir()
+	if err := consumer.captureGeneratedMetadata(pkgs, nil, output); err != nil {
+		t.Fatalf("independent actual Go -asmhdr consumer: %v", err)
+	}
+	headers, err := filepath.Glob(filepath.Join(output, ".generated-header-*", "go_asm.h"))
+	if err != nil || len(headers) != 1 {
+		t.Fatalf("actual compiler header artifacts: %v, %v", headers, err)
+	}
+	data, err := os.ReadFile(headers[0])
+	if err != nil || featureBytesSHA256(data) != consumer.Proof.GeneratedHeaders.Headers[0].HeaderSHA256 ||
+		consumer.Proof.GeneratedHeaders.Headers[0].Definitions["const_Bias"] != "7" {
+		t.Fatalf("actual consumed compiler header differs from the sealed definitions: %v", err)
+	}
+	header := consumer.Proof.GeneratedHeaders.Headers[0]
+	t.Logf("GO_ACTUAL_ASMHDR package=%s target=%s compiler_sha256=%s header_sha256=%s object_sha256=%s definitions_sha256=%s",
+		header.PackagePath, header.Target, header.CompileToolSHA256, header.HeaderSHA256,
+		header.ObjectSHA256, header.DefinitionsSHA256)
+	fixture.pkg = pkgs[0]
+	fixture.config.Feature = consumer
+	fixture.config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/amd64", consumer)
+	fixture.sigs, _, err = sigsForAsmFile(fixture.pkg, fixture.file, fixture.resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	callerCPPOriginalObject(t, fixture, "kernel_amd64.s", filepath.Dir(headers[0]))
+	callerCPPOriginalObject(t, fixture, "other_amd64.s", filepath.Dir(headers[0]))
+	before, err := json.Marshal(consumer.Input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, loaded, err := fixture.bind()
+	if err != nil || loaded == nil {
+		t.Fatalf("actual generated companion failed caller source closure: %v", err)
+	}
+	after, err := json.Marshal(consumer.Input)
+	if err != nil || !reflect.DeepEqual(before, after) {
+		t.Fatalf("generated companion mutated the object input: %v", err)
+	}
+	ccfg, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ccfg.Context = fixture.config.Context
+	task := asmTask{OutLL: filepath.Join(t.TempDir(), "caller.ll")}
+	if err := translateAndCompileModule(fixture.file, targetTriple("linux", "amd64"), "amd64",
+		task, false, ccfg, fixture.resolve, bound); err != nil {
+		t.Fatalf("generated-companion caller LLVM 22 object: %v", err)
+	}
+	objectSHA, err := gotoolprofile.FileSHA256(strings.TrimSuffix(task.OutLL, ".ll") + ".o")
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("LLVM22_CALLER_OBJECT target=linux/amd64 object_sha256=%s", objectSHA)
+	if err := loaded.verify(fixture.config.Context, fixture.defines, consumer); err != nil {
+		t.Fatalf("unchanged generated companion failed final object guard: %v", err)
+	}
+	if _, _, err := consumer.preprocessCPP(filepath.Join(fixture.root, "other_amd64.s"),
+		fixture.pkg.PkgPath, fixture.defines); err == nil {
+		t.Fatal("generated companion obtained missing requested-object operand authority")
+	}
+	original := consumer.Proof.GeneratedHeaders
+	encoded, err := json.Marshal(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, axis := range []string{"missing metadata", "wrong package", "consumed definition"} {
+		t.Run(axis, func(t *testing.T) {
+			var changed gotoolprofile.MetadataProof
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			consumer.Proof.GeneratedHeaders = &changed
+			defer func() { consumer.Proof.GeneratedHeaders = original }()
+			switch axis {
+			case "missing metadata":
+				consumer.Proof.GeneratedHeaders = nil
+			case "wrong package":
+				changed.Headers[0].PackagePath += "/wrong"
+			case "consumed definition":
+				changed.Headers[0].Definitions["const_Bias"] = "8"
+				changed.Headers[0].DefinitionsSHA256 = gotoolprofile.HeaderDefinitionSHA256(changed.Headers[0].Definitions)
+			}
+			if _, _, err := fixture.bind(); err == nil || fixture.config.Context.Err() != nil ||
+				!strings.Contains(err.Error(), "actual caller CPP/typed assembly changed") {
+				t.Fatalf("changed generated companion retained bound authority or lacked its precise CPP guard: %v", err)
+			}
+			if err := loaded.verify(fixture.config.Context, fixture.defines, consumer); err == nil ||
+				fixture.config.Context.Err() != nil || !strings.Contains(err.Error(), "actual caller CPP/typed assembly changed") {
+				t.Fatalf("changed generated companion survived the final object guard or lacked its precise diagnostic: %v", err)
+			}
+		})
+	}
+	t.Run("paired producer definitions", func(t *testing.T) {
+		var changed gotoolprofile.MetadataProof
+		if err := json.Unmarshal(encoded, &changed); err != nil {
+			t.Fatal(err)
+		}
+		changed.Headers[0].Definitions["const_Bias"] = "8"
+		changed.Headers[0].DefinitionsSHA256 = gotoolprofile.HeaderDefinitionSHA256(changed.Headers[0].Definitions)
+		previous := consumer.Input.GeneratedHeaders
+		consumer.Input.GeneratedHeaders = &changed
+		defer func() { consumer.Input.GeneratedHeaders = previous }()
+		if err := consumer.captureGeneratedMetadata(pkgs, nil, t.TempDir()); err == nil ||
+			fixture.config.Context.Err() != nil || !strings.Contains(err.Error(), "independent generated-header definitions/imports differ") {
+			t.Fatalf("paired producer metadata replaced actual -asmhdr definitions or failed outside independent agreement: %v", err)
+		}
+	})
+}
+
+func TestX86CallerCLICompanionExpandedSDKPreferredAppearanceRevokesFinalGuard(t *testing.T) {
+	for _, kind := range []string{"regular file", "symlink"} {
+		t.Run(kind, func(t *testing.T) {
+			fixture := callerCPPDeepFixture(t,
+				"#define SELECT \\\n#include \"../../src/runtime/go_tls.h\" \\\n\nSELECT\nTEXT ·other(SB),4,$0-0\nRET\n", false)
+			callerCPPOriginalObject(t, fixture, "kernel_amd64.s", "")
+			callerCPPOriginalObject(t, fixture, "other_amd64.s", "")
+			_, loaded, err := fixture.bind()
+			if err != nil || loaded == nil {
+				t.Fatalf("unchanged exact SDK fallback failed caller closure: %v", err)
+			}
+			if err := loaded.verify(fixture.config.Context, fixture.defines, fixture.config.Feature); err != nil {
+				t.Fatal(err)
+			}
+			preferred, err := gotoolprofile.CPPPreferredPackageInclude(fixture.root,
+				"other_amd64.s", "../../src/runtime/go_tls.h")
+			if err != nil {
+				t.Fatal(err)
+			}
+			owned := filepath.Dir(filepath.Dir(fixture.root))
+			relative, err := filepath.Rel(owned, preferred)
+			if err != nil || !filepath.IsLocal(relative) || relative != filepath.FromSlash("src/runtime/go_tls.h") {
+				t.Fatalf("preferred candidate escaped the exact test-owned root: %s, %v", relative, err)
+			}
+			if _, err := os.Lstat(preferred); !os.IsNotExist(err) {
+				t.Fatalf("preferred candidate was not initially absent: %v", err)
+			}
+			if err := os.MkdirAll(filepath.Dir(preferred), 0700); err != nil {
+				t.Fatal(err)
+			}
+			if kind == "regular file" {
+				if err := os.WriteFile(preferred, []byte("#define FORGED 1\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				local := filepath.Join(owned, "symlink-target.h")
+				if err := os.WriteFile(local, []byte("#define FORGED 1\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(local, preferred); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if _, _, err := fixture.config.Feature.preprocessCallerCPP(filepath.Join(fixture.root, "other_amd64.s"),
+				fixture.pkg.PkgPath, fixture.defines); err == nil || fixture.config.Context.Err() != nil ||
+				!strings.Contains(err.Error(), "preferred CPP candidate exists") {
+				t.Fatalf("late preferred %s did not revoke physical ENOENT: %v", kind, err)
+			}
+			if err := loaded.verify(fixture.config.Context, fixture.defines, fixture.config.Feature); err == nil ||
+				fixture.config.Context.Err() != nil || !strings.Contains(err.Error(), "actual caller CPP/typed assembly changed") {
+				t.Fatalf("late preferred %s survived the final caller CPP guard or failed outside CPP: %v", kind, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_caller_fixture_path_test.go b/cmd/plan9asmll/x86_caller_fixture_path_test.go
new file mode 100644
index 000000000..7c4070966
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_fixture_path_test.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestX86CallerCLIFixtureCapturesCanonicalSelectionBeforeWrites(t *testing.T) {
+	owned, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	physical := filepath.Join(owned, "physical")
+	if err := os.Mkdir(physical, 0700); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(owned, "alias")
+	if err := os.Symlink(physical, alias); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("TMPDIR", alias)
+	t.Setenv("GOTMPDIR", alias)
+	t.Run("actual selection", func(t *testing.T) {
+		pkg, file, config := x86CallerCLILoad(t, map[string]string{
+			"other_amd64.s": "TEXT ·other(SB),4,$0-0\nRET\n",
+		})
+		canonical, err := filepath.EvalSymlinks(pkg.Dir)
+		if err != nil || pkg.Dir != canonical {
+			t.Fatalf("package was selected through a noncanonical fixture path: %s, %v", pkg.Dir, err)
+		}
+		for _, filenames := range [][]string{pkg.GoFiles, pkg.CompiledGoFiles, pkg.OtherFiles} {
+			for _, filename := range filenames {
+				resolved, err := filepath.EvalSymlinks(filename)
+				if err != nil || filename != resolved {
+					t.Fatalf("actual selected source changed path identity: %s, %v", filename, err)
+				}
+			}
+		}
+		resolve := resolveSymFunc(pkg.PkgPath)
+		sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		selected := filepath.Join(pkg.Dir, "kernel_amd64.s")
+		if _, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+			selected, plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs); err != nil || loaded == nil {
+			t.Fatalf("canonical actual selection did not close: %v", err)
+		}
+		relative, err := filepath.Rel(physical, selected)
+		if err != nil || !filepath.IsLocal(relative) {
+			t.Fatalf("fixture source escaped its owned physical parent: %s, %v", relative, err)
+		}
+		if _, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+			filepath.Join(alias, relative), plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs); err != nil || loaded == nil || loaded.member == nil {
+			t.Fatalf("exact alias was not independently observed against the actual selection: %v", err)
+		}
+		unselected := filepath.Join(t.TempDir(), "kernel_amd64.s")
+		if err := os.WriteFile(unselected, []byte(x86CallerCLIAssembly), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+			unselected, plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("unselected equal-byte file acquired actual selection authority: %v", err)
+		}
+	})
+}
diff --git a/cmd/plan9asmll/x86_caller_member_test.go b/cmd/plan9asmll/x86_caller_member_test.go
new file mode 100644
index 000000000..4b58d5140
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_member_test.go
@@ -0,0 +1,199 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func TestX86CallerCLIActualSelectedMemberDirectoryAlias(t *testing.T) {
+	pkg, file, config := x86CallerCLILoad(t, nil)
+	alias := filepath.Join(t.TempDir(), "requested-package")
+	ordinaryLoadDirectoryAlias(t, alias, pkg.Dir)
+	requested := filepath.Join(alias, "kernel_amd64.s")
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", requested,
+		plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs)
+	if err != nil || loaded == nil {
+		t.Fatalf("original directory alias lost its exact actual selected caller member: %v", err)
+	}
+	if loaded.pkg == pkg || loaded.pkg.Types == pkg.Types {
+		t.Fatal("directory alias relabelled the complete independent typed source graph")
+	}
+	if err := loaded.verify(config.Context, plan9asm.GoAssemblerDefines("linux", "amd64"), nil); err != nil {
+		t.Fatal("original request did not retain its live final source guard", err)
+	}
+	if loaded.member.requested != requested || loaded.member.selected == requested ||
+		loaded.goPkg.SourceSelection.Assembly[requested] != nil || config.x86CallerSelections[pkg].loaded == loaded {
+		t.Fatal("request spelling replaced the actual inventory key or leaked into the shared source cache")
+	}
+}
+
+func TestX86CallerCLIOriginalAliasFinalSourceGuard(t *testing.T) {
+	for _, mutation := range []string{"retarget-equal-bytes", "replace-alias-same-target", "replace-selected-equal-bytes"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg, file, config := x86CallerCLILoad(t, nil)
+			alias := filepath.Join(t.TempDir(), "requested-package")
+			ordinaryLoadDirectoryAlias(t, alias, pkg.Dir)
+			requested, selected := filepath.Join(alias, "kernel_amd64.s"), filepath.Join(pkg.Dir, "kernel_amd64.s")
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+			_, aliased, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", requested, defines, config, resolve, sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, physical, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", selected, defines, config, resolve, sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if physical == aliased || physical.member == aliased.member || physical.pkg != aliased.pkg {
+				t.Fatal("per-request guards were shared or the original typed graph was recopied")
+			}
+			other := x86CallerCLIFixture(t)
+			called := false
+			ctx := &assemblyMemberCallbackContext{Context: config.Context, callback: func() {
+				called = true
+				if mutation == "replace-selected-equal-bytes" {
+					if err := os.Rename(selected, selected+".original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(selected, []byte(x86CallerCLIAssembly), 0600); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					if err := os.Rename(alias, alias+".original"); err != nil {
+						t.Fatal(err)
+					}
+					target := pkg.Dir
+					if mutation == "retarget-equal-bytes" {
+						target = other
+					}
+					ordinaryLoadDirectoryAlias(t, alias, target)
+				}
+			}}
+			if err := aliased.verify(ctx, defines, nil); !called || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("callback-mutated original caller request survived complete final guard: called=%v error=%v", called, err)
+			}
+			if mutation == "replace-selected-equal-bytes" {
+				if err := physical.verify(config.Context, defines, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("equal-byte selected-file replacement retained physical caller identity: %v", err)
+				}
+				if err := os.Remove(selected); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(selected+".original", selected); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				if err := physical.verify(config.Context, defines, nil); err != nil {
+					t.Fatal("independent physical request borrowed a different alias lifetime", err)
+				}
+				if err := os.Remove(alias); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(alias+".original", alias); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := aliased.verify(config.Context, defines, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("restoring original caller alias revived old source guard: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLIActualSelectedFinalSymlink(t *testing.T) {
+	pkg, file, config := x86CallerCLILoad(t, nil)
+	selected := filepath.Join(pkg.Dir, "kernel_amd64.s")
+	requested := filepath.Join(t.TempDir(), "requested.s")
+	if err := os.Symlink(selected, requested); err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+	_, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", requested, defines, config, resolve, sigs)
+	if err != nil || loaded == nil {
+		t.Fatalf("final alias to actual selected caller: %v", err)
+	}
+	if err := loaded.verify(config.Context, defines, nil); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(requested, requested+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(selected, requested); err != nil {
+		t.Fatal(err)
+	}
+	if err := loaded.verify(config.Context, defines, nil); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("same-target replacement lost original final caller node identity: %v", err)
+	}
+}
+
+func TestX86CallerCLIOriginalAliasFiveTargetObjects(t *testing.T) {
+	directory := x86CallerCLIFixture(t)
+	t.Chdir(directory)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOFLAGS", "")
+	alias := filepath.Join(t.TempDir(), "requested-package")
+	ordinaryLoadDirectoryAlias(t, alias, directory)
+	requested := filepath.Join(alias, "kernel_amd64.s")
+	for _, target := range []struct{ os, triple string }{
+		{"linux", "x86_64-unknown-linux-gnu"}, {"linux", "x86_64-unknown-linux-musl"},
+		{"darwin", "x86_64-apple-darwin"}, {"freebsd", "x86_64-unknown-freebsd"},
+		{"windows", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			pkgs, err := loadPkgs(target.os, "amd64", []string{"."}, nil, "example.com/caller", true, false)
+			if err != nil || len(pkgs) != 1 {
+				t.Fatalf("complete actual target selection: %v", err)
+			}
+			config, err := resolveCompileConfig(true, "", true, 2)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			config.Context = ctx
+			config.x86CallerSelections = captureX86CallerSelections(pkgs, target.os+"/amd64", nil)
+			output := filepath.Join(t.TempDir(), "alias.ll")
+			originalObject := filepath.Join(filepath.Dir(output), "original-go.o")
+			if stdout, stderr, err := gotoolprofile.RunBounded(ctx, directory,
+				append(os.Environ(), "GOOS="+target.os, "GOARCH=amd64"), "go", "tool", "asm",
+				"-p", pkgs[0].PkgPath, "-o", originalObject, requested); err != nil {
+				t.Fatalf("unchanged original alias Go object: %v\n%s\n%s", err, stdout, stderr)
+			}
+			if err := compileOne(pkgs[0], plan9asm.ArchAMD64, target.os, "amd64", target.triple,
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: requested, OutLL: output}, false, config); err != nil {
+				t.Fatal("original caller request did not reach LLVM22 object", err)
+			}
+			for _, object := range []string{originalObject, strings.TrimSuffix(output, ".ll") + ".o"} {
+				info, err := os.Stat(object)
+				if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+					t.Fatalf("missing actual original/LLVM22 object: %v", err)
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_caller_regions.go b/cmd/plan9asmll/x86_caller_regions.go
new file mode 100644
index 000000000..47e1b0b38
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_regions.go
@@ -0,0 +1,408 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// Created only at the actual packages.Load boundary, never decoded from JSON.
+// Non-candidates retain names/layout only, not transitive syntax graphs.
+type x86CallerPackageSelection struct {
+	identity string
+	target   string
+	types    *types.Package
+	sizes    []int64
+	imports  map[string]*types.Package
+	env      []string
+	ready    bool
+	loaded   *x86CallerTypedPackage
+	mode     *string
+}
+
+type x86CallerTypedPackage struct {
+	pkg       *packages.Package
+	goPkg     plan9asm.GoPackage
+	sources   map[string]string
+	expanded  map[string]string
+	selection *x86CallerPackageSelection
+	member    *actualAssemblyMember
+}
+
+func x86CallerSelectionIdentity(pkg *packages.Package, environment []string) string {
+	canonical := func(files []string) []string {
+		result := append([]string(nil), files...)
+		sort.Strings(result)
+		return result
+	}
+	selection := generatedHeaderLoadSelection{
+		Name: pkg.Name, PackagePath: pkg.PkgPath, Module: pkg.Module,
+		GoFiles: canonical(pkg.GoFiles), CompiledGoFiles: canonical(pkg.CompiledGoFiles),
+		OtherFiles: canonical(pkg.OtherFiles), Imports: make(map[string]string),
+	}
+	for name, dep := range pkg.Imports {
+		if dep == nil {
+			return ""
+		}
+		selection.Imports[name] = dep.PkgPath
+	}
+	// Preserve the exact ordered load environment, including duplicate keys.
+	// A later profile/flag edit cannot borrow the original selected types/files.
+	encoded, err := json.Marshal(struct {
+		ID          string
+		Dir         string
+		Selection   generatedHeaderLoadSelection
+		Environment []string
+	}{ID: pkg.ID, Dir: pkg.Dir, Selection: selection, Environment: environment})
+	if err != nil {
+		return ""
+	}
+	return featureBytesSHA256(encoded)
+}
+
+func x86CallerSizes(sizes types.Sizes) []int64 {
+	if sizes == nil {
+		return nil
+	}
+	var values []int64
+	for _, kind := range []types.BasicKind{
+		types.UnsafePointer, types.Int8, types.Uint8, types.Int16, types.Uint16,
+		types.Int32, types.Uint32, types.Int64, types.Uint64, types.Int, types.Uint,
+		types.Float32, types.Float64,
+	} {
+		values = append(values, sizes.Sizeof(types.Typ[kind]))
+	}
+	return values
+}
+
+func captureX86CallerSelections(pkgs []*packages.Package, target string, feature *featureConsumer) map[*packages.Package]*x86CallerPackageSelection {
+	env := append([]string(nil), os.Environ()...)
+	goos, goarch, _ := strings.Cut(target, "/")
+	env = append(env, "GOOS="+goos, "GOARCH="+goarch)
+	if feature != nil {
+		env = append([]string(nil), feature.Env...)
+	}
+	return captureX86CallerSelectionsInEnvironment(pkgs, target, env)
+}
+
+func captureX86CallerSelectionsInEnvironment(pkgs []*packages.Package, target string, environment []string) map[*packages.Package]*x86CallerPackageSelection {
+	result := make(map[*packages.Package]*x86CallerPackageSelection, len(pkgs))
+	env := append([]string(nil), environment...)
+	var goFlags, driver string
+	for _, value := range env {
+		if strings.HasPrefix(value, "GOFLAGS=") {
+			goFlags = strings.TrimPrefix(value, "GOFLAGS=")
+		}
+		if strings.HasPrefix(value, "GOPACKAGESDRIVER=") {
+			driver = strings.TrimPrefix(value, "GOPACKAGESDRIVER=")
+		}
+	}
+	defaultDriver := false
+	if driver == "" {
+		_, err := exec.LookPath("gopackagesdriver")
+		defaultDriver = err == nil
+	}
+	for _, pkg := range pkgs {
+		if pkg == nil {
+			continue
+		}
+		// Effective overlays/generated/cgo sources need their own mapping.
+		// Reading original paths may not silently impersonate compiled bytes.
+		ready := !isTestVariantPackage(pkg) && !strings.Contains(goFlags, "-overlay") &&
+			(driver == "" || driver == "off") && !defaultDriver && len(pkg.CompiledGoFiles) != 0 &&
+			reflect.DeepEqual(pkg.GoFiles, pkg.CompiledGoFiles)
+		imports := make(map[string]*types.Package, len(pkg.Imports))
+		for path, dependency := range pkg.Imports {
+			if dependency != nil {
+				imports[path] = dependency.Types
+			}
+		}
+		result[pkg] = &x86CallerPackageSelection{
+			identity: x86CallerSelectionIdentity(pkg, env), target: target,
+			types: pkg.Types, sizes: x86CallerSizes(pkg.TypesSizes),
+			imports: imports, env: env, ready: ready,
+		}
+	}
+	return result
+}
+
+func (selection *x86CallerPackageSelection) verifyEffectiveSourceMode(ctx context.Context) error {
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
+	defer cancel()
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, "", selection.env, "go", "env", "-json", "GOFLAGS")
+	if err != nil || len(stderr) != 0 {
+		return fmt.Errorf("observe actual caller source mode: %v (stderr: %s)", err, stderr)
+	}
+	var actual struct {
+		GoFlags string `json:"GOFLAGS"`
+	}
+	if err := json.Unmarshal(stdout, &actual); err != nil {
+		return fmt.Errorf("decode actual caller source mode: %w", err)
+	}
+	if strings.Contains(actual.GoFlags, "-overlay") {
+		return fmt.Errorf("%w: effective overlay bytes require their actual source mapping", plan9asm.ErrProbeNeedsContext)
+	}
+	if selection.mode != nil && *selection.mode != actual.GoFlags {
+		return fmt.Errorf("%w: effective Go source flags changed after actual selection", plan9asm.ErrProbeNeedsContext)
+	}
+	selection.mode = &actual.GoFlags
+	return nil
+}
+
+type x86CallerActualImports map[string]*packages.Package
+
+func (imports x86CallerActualImports) Import(path string) (*types.Package, error) {
+	if path == "unsafe" {
+		return types.Unsafe, nil
+	}
+	pkg := imports[path]
+	if pkg == nil || pkg.Types == nil || !pkg.Types.Complete() {
+		return nil, fmt.Errorf("caller recheck has no actual selected dependency types: %s", path)
+	}
+	return pkg.Types, nil
+}
+
+func x86CallerReadSource(ctx context.Context, filename string, total *int) ([]byte, error) {
+	if ctx.Err() != nil {
+		return nil, ctx.Err()
+	}
+	info, err := os.Stat(filename)
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+		return nil, fmt.Errorf("caller source must be a bounded regular file: %s", filename)
+	}
+	reader, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	data, readErr := io.ReadAll(io.LimitReader(reader, 64<<20+1))
+	closeErr := reader.Close()
+	*total += len(data)
+	if readErr != nil || closeErr != nil || *total > 64<<20 {
+		return nil, fmt.Errorf("caller source read exceeded its bound: %v (close: %v)", readErr, closeErr)
+	}
+	return data, nil
+}
+
+func x86CallerAssemblySource(pkg *packages.Package, asm string, defines []string, feature *featureConsumer) ([]byte, error) {
+	var source []byte
+	var err error
+	if feature != nil {
+		source, _, err = feature.preprocessCallerCPP(asm, pkg.PkgPath, defines)
+	} else {
+		source, err = readAsmSource(asm, asmSourceRoot(pkg, asm))
+	}
+	if err != nil {
+		return nil, err
+	}
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, imported := range pkg.Imports {
+		if imported != nil {
+			imports[path] = imported.Types
+		}
+	}
+	return plan9asm.ExpandGoAssemblySource(plan9asm.GoPackage{
+		Path: pkg.PkgPath, Types: pkg.Types, Imports: imports,
+	}, source, "amd64"), nil
+}
+
+func loadX86CallerTypedPackage(ctx context.Context, pkg *packages.Package, defines []string, feature *featureConsumer) (*x86CallerTypedPackage, error) {
+	if pkg.Types == nil || pkg.TypesSizes == nil || pkg.IllTyped || len(pkg.Errors) != 0 ||
+		len(pkg.CompiledGoFiles) > 256 || len(pkg.OtherFiles) > 512 {
+		return nil, fmt.Errorf("caller package lacks complete actual types/layout or exceeds its source bound")
+	}
+	loaded := &x86CallerTypedPackage{
+		sources: make(map[string]string), expanded: make(map[string]string),
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	selected := &plan9asm.GoSourceSelection{
+		Fset: fset, Sizes: pkg.TypesSizes,
+		SelectedGoFiles: append([]string(nil), pkg.CompiledGoFiles...),
+		GoSources:       make(map[string][]byte), Assembly: make(map[string]*plan9asm.File),
+		TypesInfo: &types.Info{
+			Types: make(map[ast.Expr]types.TypeAndValue),
+			Defs:  make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object),
+		},
+	}
+	total := 0
+	for _, filename := range selected.SelectedGoFiles {
+		if selected.GoSources[filename] != nil {
+			return nil, fmt.Errorf("duplicate actual compiled Go source")
+		}
+		source, err := x86CallerReadSource(ctx, filename, &total)
+		if err != nil {
+			return nil, err
+		}
+		parsed, err := parser.ParseFile(fset, filename, source, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		syntax = append(syntax, parsed)
+		selected.GoSources[filename] = source
+		loaded.sources[filename] = featureBytesSHA256(source)
+	}
+	config := types.Config{
+		Importer: x86CallerActualImports(pkg.Imports), Sizes: pkg.TypesSizes,
+		GoVersion: pkg.Types.GoVersion(),
+	}
+	typed, err := config.Check(pkg.PkgPath, fset, syntax, selected.TypesInfo)
+	if err != nil {
+		return nil, fmt.Errorf("actual selected caller source recheck: %w", err)
+	}
+	copyPkg := *pkg
+	copyPkg.Types, copyPkg.Syntax, copyPkg.Fset, copyPkg.TypesInfo = typed, syntax, fset, selected.TypesInfo
+	loaded.pkg = &copyPkg
+	loaded.goPkg = plan9asm.GoPackage{
+		Path: pkg.PkgPath, Types: typed, Syntax: syntax, SourceSelection: selected,
+	}
+	for _, filename := range pkg.OtherFiles {
+		if filepath.Ext(filename) == ".h" {
+			raw, err := x86CallerReadSource(ctx, filename, &total)
+			if err != nil {
+				return nil, err
+			}
+			loaded.sources[filename] = featureBytesSHA256(raw)
+			continue // Headers have CPP origin, never a Go/ASM declaration role.
+		}
+		if filepath.Ext(filename) != ".s" || selected.Assembly[filename] != nil {
+			return nil, fmt.Errorf("caller closure has unknown native sources or duplicate assembly")
+		}
+		raw, err := x86CallerReadSource(ctx, filename, &total)
+		if err != nil {
+			return nil, err
+		}
+		source, err := x86CallerAssemblySource(loaded.pkg, filename, defines, feature)
+		if err != nil || len(source) > 64<<20 {
+			return nil, fmt.Errorf("actual caller assembly expansion: %v", err)
+		}
+		file, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(source), defines)
+		if len(raw) == 0 {
+			file, err = &plan9asm.File{Arch: plan9asm.ArchAMD64}, nil
+		}
+		if err != nil {
+			return nil, fmt.Errorf("actual caller assembly registration: %w", err)
+		}
+		selected.SelectedAssemblyFiles = append(selected.SelectedAssemblyFiles, filename)
+		selected.Assembly[filename] = file
+		loaded.sources[filename] = featureBytesSHA256(raw)
+		loaded.expanded[filename] = featureBytesSHA256(source)
+	}
+	return loaded, nil
+}
+
+func (loaded *x86CallerTypedPackage) verify(ctx context.Context, defines []string, feature *featureConsumer) (result error) {
+	if err := loaded.member.verify(); err != nil {
+		return err
+	}
+	defer func() { result = errors.Join(result, loaded.member.verify()) }()
+	if loaded.selection != nil {
+		if err := loaded.selection.verifyEffectiveSourceMode(ctx); err != nil {
+			return err
+		}
+	}
+	for filename, expected := range loaded.sources {
+		if ctx.Err() != nil {
+			return ctx.Err()
+		}
+		actual, err := gotoolprofile.FileSHA256(filename)
+		if err != nil || actual != expected {
+			return fmt.Errorf("actual caller source changed before final object: %s", filename)
+		}
+	}
+	for filename, expected := range loaded.expanded {
+		source, err := x86CallerAssemblySource(loaded.pkg, filename, defines, feature)
+		if err != nil || featureBytesSHA256(source) != expected {
+			return fmt.Errorf("actual caller CPP/typed assembly changed before final object: %s", filename)
+		}
+	}
+	return nil
+}
+
+func bindX86CallerRegions(pkg *packages.Package, file *plan9asm.File, target, goarch, asm string, defines []string,
+	config compileConfig, resolve func(string) string, sigs map[string]plan9asm.FuncSig,
+) (map[string]plan9asm.FuncSig, *x86CallerTypedPackage, error) {
+	if !plan9asm.GoX86RawReturnCallerBindingNeeded(file, goarch, resolve, sigs) {
+		return sigs, nil, nil
+	}
+	loaded, err := loadX86ActualSelectedAssembly(pkg, target, asm, defines, config)
+	if err != nil {
+		return nil, nil, err
+	}
+	actual, _, err := sigsForAsmFile(loaded.pkg, file, resolve, "amd64")
+	if err != nil {
+		return nil, nil, err
+	}
+	for name, previous := range sigs {
+		if current, exists := actual[name]; !exists || !reflect.DeepEqual(previous, current) {
+			return nil, nil, fmt.Errorf("%w: caller signatures differ from same-source typed recheck", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	bound, err := plan9asm.BindGoX86RawReturnCallerRegions(loaded.goPkg, file, "amd64", resolve, actual)
+	return bound, loaded, err
+}
+
+// This is a source observation only. The caller binder and continuation
+// reference closure independently choose and prove their body permissions.
+func loadX86ActualSelectedAssembly(pkg *packages.Package, target, asm string, defines []string,
+	config compileConfig,
+) (*x86CallerTypedPackage, error) {
+	selection := config.x86CallerSelections[pkg]
+	if pkg == nil || selection == nil || !selection.ready || selection.target != target || selection.identity == "" ||
+		selection.types != pkg.Types || selection.identity != x86CallerSelectionIdentity(pkg, selection.env) ||
+		!reflect.DeepEqual(selection.sizes, x86CallerSizes(pkg.TypesSizes)) {
+		return nil, fmt.Errorf("%w: proof needs unchanged actual-load source role, inventory and layout", plan9asm.ErrProbeNeedsContext)
+	}
+	for path, dependency := range pkg.Imports {
+		if dependency == nil || dependency.Types != selection.imports[path] {
+			return nil, fmt.Errorf("%w: dependency types differ from actual load", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	ctx := config.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	if selection.loaded == nil {
+		if err := selection.verifyEffectiveSourceMode(ctx); err != nil {
+			return nil, err
+		}
+		var err error
+		selection.loaded, err = loadX86CallerTypedPackage(ctx, pkg, defines, config.Feature)
+		if err != nil {
+			return nil, err
+		}
+		selection.loaded.selection = selection
+	}
+	member, err := observeActualAssemblyMember(asm, selection.loaded.goPkg.SourceSelection.SelectedAssemblyFiles)
+	if err != nil || selection.loaded.goPkg.SourceSelection.Assembly[member.selected] == nil {
+		return nil, fmt.Errorf("%w: translated assembly is absent from actual complete selection: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	// The complete typed graph is cached, but each returned source keeps its
+	// own original request/lifetime. No alias is added to the actual inventory
+	// or accumulated in an unbounded shared cache.
+	loaded := &x86CallerTypedPackage{
+		pkg: selection.loaded.pkg, goPkg: selection.loaded.goPkg,
+		sources: selection.loaded.sources, expanded: selection.loaded.expanded,
+		selection: selection, member: member,
+	}
+	if err := loaded.verify(ctx, defines, config.Feature); err != nil {
+		return nil, err
+	}
+	return loaded, nil
+}
diff --git a/cmd/plan9asmll/x86_caller_regions_test.go b/cmd/plan9asmll/x86_caller_regions_test.go
new file mode 100644
index 000000000..70f2afca1
--- /dev/null
+++ b/cmd/plan9asmll/x86_caller_regions_test.go
@@ -0,0 +1,341 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+const x86CallerCLISource = `package caller
+import "unsafe"
+
+//go:noescape
+func kernel(a, b, res, length unsafe.Pointer)
+
+func Call(x, y []uint64) uint32 {
+	var res uint32
+	length := len(x)
+	kernel(
+		unsafe.Pointer(unsafe.SliceData(x)),
+		unsafe.Pointer(unsafe.SliceData(y)),
+		unsafe.Pointer(&res),
+		unsafe.Pointer(&length))
+	return res
+}
+`
+
+const x86CallerCLIAssembly = `TEXT ·kernel(SB),4,$0-32
+MOVQ a+0(FP),DI
+MOVQ b+8(FP),SI
+MOVQ res+16(FP),DX
+MOVQ length+24(FP),CX
+BYTE $0x55
+WORD $0x8948
+BYTE $0xe5
+LONG $0xf8e48348
+MOVL (DI),AX
+ADDL $7,AX
+MOVL AX,(DX)
+WORD $0x8948
+BYTE $0xec
+BYTE $0x5d
+BYTE $0xc3
+`
+
+func x86CallerCLIFixture(t *testing.T) string {
+	t.Helper()
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, source := range map[string]string{
+		"go.mod":    "module example.com/caller\n\ngo 1.20\n",
+		"caller.go": x86CallerCLISource, "kernel_amd64.s": x86CallerCLIAssembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func TestX86CallerCLIActualSelectedPackage(t *testing.T) {
+	dir := x86CallerCLIFixture(t)
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOMAXPROCS", "2")
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			output := t.TempDir()
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			originalObject := filepath.Join(output, "original-go.o")
+			actualEnv := append(os.Environ(), "GOOS="+goos, "GOARCH=amd64")
+			if stdout, stderr, err := gotoolprofile.RunBounded(ctx, dir, actualEnv, "go", "tool", "asm",
+				"-p", "example.com/caller", "-o", originalObject, filepath.Join(dir, "kernel_amd64.s")); err != nil {
+				t.Fatalf("actual Go object: %v\n%s\n%s", err, stdout, stderr)
+			}
+			if info, err := os.Stat(originalObject); err != nil || info.Size() == 0 {
+				t.Fatalf("actual Go assembler produced no object: %v", err)
+			}
+			report, tasks, err := runOneTarget(targetSpec{Goos: goos, Goarch: "amd64"},
+				[]string{"."}, nil, nil, "example.com/caller", output,
+				false, 0, true, false, true, "", config)
+			if err != nil || report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 || report.NotApplicable != 0 {
+				t.Fatalf("actual selected caller did not reach LLVM object: %+v, %v", report, err)
+			}
+			for _, task := range tasks {
+				object := strings.TrimSuffix(task.OutLL, ".ll") + ".o"
+				info, err := os.Stat(object)
+				if err != nil || info.Size() == 0 {
+					t.Fatalf("missing actual LLVM object: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func x86CallerCLILoad(t *testing.T, extra map[string]string) (*packages.Package, *plan9asm.File, compileConfig) {
+	t.Helper()
+	dir := x86CallerCLIFixture(t)
+	for name, source := range extra {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOMAXPROCS", "2")
+	pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, "example.com/caller", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual package load: %v, packages=%d", err, len(pkgs))
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, x86CallerCLIAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	t.Cleanup(cancel)
+	return pkgs[0], file, compileConfig{
+		Context: ctx, x86CallerSelections: captureX86CallerSelections(pkgs, "linux/amd64", nil),
+	}
+}
+
+func TestX86CallerCLIRejectsAlteredActualLoadAndMissingSources(t *testing.T) {
+	for _, change := range []string{
+		"missing Go", "missing ASM", "wrong sizes", "missing sizes", "wrong role",
+		"module identity", "package types identity", "import types", "unknown effective role", "missing actual snapshot",
+	} {
+		t.Run(change, func(t *testing.T) {
+			pkg, file, config := x86CallerCLILoad(t, map[string]string{
+				"extra.go":      "package caller\nvar marker = 7\n",
+				"other_amd64.s": "TEXT ·other(SB),4,$0-0\nRET\n",
+			})
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch change {
+			case "missing Go":
+				pkg.CompiledGoFiles = pkg.CompiledGoFiles[:1]
+			case "missing ASM":
+				pkg.OtherFiles = pkg.OtherFiles[:1]
+			case "wrong sizes":
+				pkg.TypesSizes = types.SizesFor("gc", "386")
+			case "missing sizes":
+				pkg.TypesSizes = nil
+			case "wrong role":
+				pkg.ID += " [example.com/caller.test]"
+			case "module identity":
+				pkg.Module.Path += "/changed"
+			case "package types identity":
+				pkg.Types = types.NewPackage(pkg.PkgPath, pkg.Name)
+			case "import types":
+				pkg.Imports["unsafe"].Types = types.NewPackage("unsafe", "unsafe")
+			case "unknown effective role":
+				config.x86CallerSelections[pkg].ready = false
+			case "missing actual snapshot":
+				config.x86CallerSelections = nil
+			}
+			_, _, err = bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+				filepath.Join(pkg.Dir, "kernel_amd64.s"), plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("changed %s obtained actual caller authority: %v", change, err)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLIRejectsActualSourceAndAssemblyExposures(t *testing.T) {
+	for name, extra := range map[string]map[string]string{
+		"Go value":    {"extra.go": "package caller\nvar exposed = kernel\n"},
+		"Go alias":    {"caller.go": strings.Replace(x86CallerCLISource, "return res", "_ = &res\nreturn res", 1)},
+		"ASM call":    {"other_amd64.s": "TEXT ·other(SB),4,$0-0\nCALL ·kernel(SB)\nRET\n"},
+		"ASM address": {"other_amd64.s": "TEXT ·other(SB),4,$0-0\nLEAQ ·kernel(SB),AX\nRET\n"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, file, config := x86CallerCLILoad(t, extra)
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _, err = bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+				filepath.Join(pkg.Dir, "kernel_amd64.s"), plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("actual %s exposure acquired caller-region proof: %v", name, err)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLIGuardsSourcesThroughFinalObject(t *testing.T) {
+	for _, change := range []string{"Go bytes", "ASM bytes", "CPP include"} {
+		t.Run(change, func(t *testing.T) {
+			assembly := strings.Replace(x86CallerCLIAssembly, "ADDL $7,AX", "ADDL $BIAS,AX", 1)
+			assembly = "#include \"bias.h\"\n" + assembly
+			pkg, _, config := x86CallerCLILoad(t, map[string]string{
+				"kernel_amd64.s": assembly, "bias.h": "#define BIAS 7\n",
+			})
+			asm := filepath.Join(pkg.Dir, "kernel_amd64.s")
+			defines := plan9asm.GoAssemblerDefines("linux", "amd64")
+			source, err := x86CallerAssemblySource(pkg, asm, defines, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(source), defines)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := resolveSymFunc(pkg.PkgPath)
+			sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", asm, defines, config, resolve, sigs)
+			if err != nil || loaded == nil {
+				t.Fatalf("unchanged actual source failed: %v", err)
+			}
+			filename, replacement := "caller.go", x86CallerCLISource+"\n// changed\n"
+			if change == "ASM bytes" {
+				filename, replacement = "kernel_amd64.s", assembly+"\n// changed\n"
+			}
+			if change == "CPP include" {
+				filename, replacement = "bias.h", "#define BIAS 8\n"
+			}
+			if err := os.WriteFile(filepath.Join(pkg.Dir, filename), []byte(replacement), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := loaded.verify(config.Context, defines, nil); err == nil {
+				t.Fatalf("changed %s survived final source guard", change)
+			}
+		})
+	}
+}
+
+func TestX86CallerCLINonCandidateDoesNotLoadSyntax(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT ·ordinary(SB),4,$0-0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := &packages.Package{
+		PkgPath: "example.com/caller", CompiledGoFiles: []string{"absent.go"}, OtherFiles: []string{"absent.s"},
+	}
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs := map[string]plan9asm.FuncSig{"example.com/caller.ordinary": {
+		Name: "example.com/caller.ordinary", Ret: plan9asm.Void,
+	}}
+	bound, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64", "absent.s", nil,
+		compileConfig{}, resolve, sigs)
+	if err != nil || loaded != nil || len(bound) != 1 {
+		t.Fatalf("ordinary function unnecessarily loaded missing sources: %v", err)
+	}
+}
+
+func TestX86CallerCLIRechecksActualStandardDependencyTypes(t *testing.T) {
+	pkg, file, config := x86CallerCLILoad(t, map[string]string{
+		"extra.go": "package caller\nimport \"math\"\nvar marker = math.Float32bits(0)\n",
+	})
+	resolve := resolveSymFunc(pkg.PkgPath)
+	sigs, _, err := sigsForAsmFile(pkg, file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, loaded, err := bindX86CallerRegions(pkg, file, "linux/amd64", "amd64",
+		filepath.Join(pkg.Dir, "kernel_amd64.s"), plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs)
+	if err != nil || loaded == nil {
+		t.Fatalf("actual standard export types failed the source recheck: %v", err)
+	}
+	if imported := pkg.Imports["math"]; imported == nil || imported.Types != config.x86CallerSelections[pkg].imports["math"] {
+		t.Fatal("recheck did not retain the actual loaded dependency identity")
+	}
+}
+
+func TestX86CallerCLIRejectsEffectiveOverlayFromActualGoEnv(t *testing.T) {
+	dir := x86CallerCLIFixture(t)
+	t.Chdir(dir)
+	metadata := t.TempDir()
+	goenv := filepath.Join(metadata, "goenv")
+	overlaySource := filepath.Join(metadata, "effective.go")
+	overlayPath := filepath.Join(metadata, "overlay.json")
+	if err := os.WriteFile(overlaySource, []byte(x86CallerCLISource+"\nvar escapedEntry = kernel\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	overlay, err := json.Marshal(struct {
+		Replace map[string]string
+	}{Replace: map[string]string{filepath.Join(dir, "caller.go"): overlaySource}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(overlayPath, overlay, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(goenv, []byte("GOFLAGS=-overlay="+overlayPath+"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOENV", goenv)
+	t.Setenv("GOFLAGS", "") // cmd/go falls through an empty value to go/env.
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	pkgs, err := loadPkgs("linux", "amd64", []string{"."}, nil, "example.com/caller", true, false)
+	if err != nil || len(pkgs) != 1 {
+		t.Fatalf("actual overlay package: %v", err)
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, x86CallerCLIAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := resolveSymFunc(pkgs[0].PkgPath)
+	sigs, _, err := sigsForAsmFile(pkgs[0], file, resolve, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	config := compileConfig{x86CallerSelections: captureX86CallerSelections(pkgs, "linux/amd64", nil)}
+	_, _, err = bindX86CallerRegions(pkgs[0], file, "linux/amd64", "amd64", filepath.Join(dir, "kernel_amd64.s"),
+		plan9asm.GoAssemblerDefines("linux", "amd64"), config, resolve, sigs)
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || !strings.Contains(err.Error(), "overlay") {
+		t.Fatalf("original bytes impersonated actual compiled overlay: %v", err)
+	}
+}
diff --git a/cmd/plan9asmll/x86_fallback_frame_extent_test.go b/cmd/plan9asmll/x86_fallback_frame_extent_test.go
new file mode 100644
index 000000000..d53e5e4e7
--- /dev/null
+++ b/cmd/plan9asmll/x86_fallback_frame_extent_test.go
@@ -0,0 +1,51 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestX86InferredFrameRequiresOriginalTextExtent(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := 4, "MOVL"
+		if arch == "amd64" {
+			word, move = 8, "MOVQ"
+		}
+		for _, test := range []struct {
+			header string
+			valid  bool
+		}{
+			{"$0", false},
+			{"$0-0", false},
+			{fmt.Sprintf("$0-%d", word-1), false},
+			{fmt.Sprintf("$0-%d", word), true},
+			{fmt.Sprintf("$0-%d", word*2), true},
+		} {
+			for _, hasPackage := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/package=%t", arch, test.header, hasPackage), func(t *testing.T) {
+					file, err := plan9asm.Parse(plan9asm.ArchAMD64,
+						"TEXT helper(SB),4,"+test.header+"\n"+move+" arg+0(FP),AX\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					var pkg *packages.Package
+					if hasPackage {
+						pkg = &packages.Package{
+							Types:      types.NewPackage("example.com/fixture", "fixture"),
+							TypesSizes: types.SizesFor("gc", arch),
+						}
+					}
+					_, _, err = sigsForAsmFile(pkg, file, func(name string) string { return name }, arch)
+					if test.valid && err != nil || !test.valid && !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("inferred FP words must fit the original explicit TEXT, not their own heuristic", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmll/x86_sad_family_test.go b/cmd/plan9asmll/x86_sad_family_test.go
new file mode 100644
index 000000000..102cf2fbd
--- /dev/null
+++ b/cmd/plan9asmll/x86_sad_family_test.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestExtractSupportedOpsRetainsCompleteSADSpecTable(t *testing.T) {
+	dir := t.TempDir()
+	data, err := os.ReadFile(filepath.Join("../..", "amd64_lower_sad.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, content := range map[string][]byte{"amd64_lower_sad.go": data, "translate.go": []byte("package plan9asm\n")} {
+		if err := os.WriteFile(filepath.Join(dir, name), content, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		ops, err := extractSupportedOps(dir, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{"PSADBW", "VPSADBW", "MPSADBW", "VMPSADBW", "VDBPSADBW"} {
+			if _, present := ops[name]; !present {
+				t.Fatalf("%s typed SAD table omitted %s", arch, name)
+			}
+		}
+	}
+}
+
+func TestX86SADCLIActualSelectedSourceEffects(t *testing.T) {
+	dir := x86CallerCLIFixture(t)
+	// Four uint64 input elements bind one full native Y read. Original
+	// LONG eaf6d5c5 is the retained Weaviate instruction, with this fixture's
+	// independently defined registers and unchanged scalar result envelope.
+	body := "MOVQ (CX),AX\nCMPQ AX,$4\nJL small\nVMOVDQU (DI),Y2\nVMOVDQU (SI),Y5\nLONG $0xeaf6d5c5\nVMOVSS X5,(DX)\nJMP done\nsmall:\nMOVL $0,(DX)\ndone:\n"
+	assembly := strings.Replace(x86CallerCLIAssembly, "MOVL (DI),AX\nADDL $7,AX\nMOVL AX,(DX)\n", body, 1)
+	if err := os.WriteFile(filepath.Join(dir, "kernel_amd64.s"), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Chdir(dir)
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	t.Setenv("CGO_ENABLED", "0")
+	t.Setenv("GOMAXPROCS", "2")
+	config, err := resolveCompileConfig(true, "", true, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	config.Context = ctx
+	report, tasks, err := runOneTarget(targetSpec{Goos: "linux", Goarch: "amd64"}, []string{"."}, nil, nil,
+		"example.com/caller", t.TempDir(), false, 0, true, false, true, "", config)
+	if err != nil || report.TotalAsm != 1 || report.Success != 1 || report.Failed != 0 || report.NotApplicable != 0 {
+		t.Fatalf("complete source SAD did not produce its actual LLVM object: %+v %v", report, err)
+	}
+	for _, task := range tasks {
+		info, err := os.Stat(strings.TrimSuffix(task.OutLL, ".ll") + ".o")
+		if err != nil || info.Size() == 0 {
+			t.Fatalf("missing SAD LLVM object: %v", err)
+		}
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_filter_mask_width_go127_test.go b/cmd/plan9asmll/x86_sdk_filter_mask_width_go127_test.go
new file mode 100644
index 000000000..55a705c8c
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_filter_mask_width_go127_test.go
@@ -0,0 +1,29 @@
+//go:build go1.27
+
+package main
+
+import (
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCompileOneX86SDKGCFilterMaskWidthExistingObjects(t *testing.T) {
+	const packagePath = "internal/runtime/gc/scan"
+	const name = "filter_amd64.s"
+	path := filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(packagePath), name)
+	before, err := os.ReadFile(path)
+	if err != nil || !strings.Contains(string(before), "KMOVW K1, R15") ||
+		!strings.Contains(string(before), "POPCNTL R15, R15") {
+		t.Fatal("complete current-Go mask-word/popcount counterexample is absent", err)
+	}
+	t.Logf("complete original SDK GC filter source SHA256=%x", sha256.Sum256(before))
+	compileX86SDKExistingObject(t, packagePath, name)
+	after, err := os.ReadFile(path)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(before) {
+		t.Fatal("complete original SDK GC filter changed during compilation", err)
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_literal_minimum_go127_test.go b/cmd/plan9asmll/x86_sdk_literal_minimum_go127_test.go
new file mode 100644
index 000000000..9659fefcf
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_literal_minimum_go127_test.go
@@ -0,0 +1,144 @@
+//go:build go1.27
+
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinux(t *testing.T) {
+	compileOneX86SDKOriginalMapsLiteralMinimumSource(t, "linux")
+}
+
+func TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceDarwin(t *testing.T) {
+	compileOneX86SDKOriginalMapsLiteralMinimumSource(t, "darwin")
+}
+
+func TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceWindows(t *testing.T) {
+	compileOneX86SDKOriginalMapsLiteralMinimumSource(t, "windows")
+}
+
+func TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinuxPublicCLI(t *testing.T) {
+	runPublicCLIX86SDKOriginalMapsLiteralMinimumSource(t, "linux")
+}
+
+func compileOneX86SDKOriginalMapsLiteralMinimumSource(t *testing.T, goos string) {
+	t.Helper()
+	setX86SDKNumericalCLIProfile(t, "effective-defaults")
+	t.Setenv("GOOS", goos)
+	ctx := arm64PrivateCLIContext(t)
+	directory, originals := mapsLiteralMinimumOriginalSourceInputs(t)
+	input := filepath.Join(directory, "memhash_amd64.s")
+	original := originals["memhash_amd64.s"]
+	actual, err := packages.Load(&packages.Config{Context: ctx, Dir: directory, Env: os.Environ(), Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles | packages.NeedModule | packages.NeedDeps | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes}, ".")
+	if err != nil || len(actual) != 1 || len(actual[0].Errors) != 0 {
+		t.Fatalf("actual complete SDK load: %v %+v", err, actual)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelections(actual, goos+"/amd64", nil)
+	output := filepath.Join(t.TempDir(), "maps.ll")
+	if err := compileOne(actual[0], plan9asm.ArchAMD64, goos, "amd64", targetTriple(goos, "amd64"), asmTask{PkgPath: actual[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal("whole original SDK source/minimum/LLVM object", err)
+	}
+	ir, err := os.ReadFile(output)
+	if err != nil || strings.Count(string(ir), "define ") != 2 || !strings.Contains(string(ir), "external global [128 x i8]") || strings.Count(string(ir), "internal constant [256 x i8]") != 2 {
+		t.Fatal("whole original TEXT/DATA/runtime mutable source publication differs", err)
+	}
+	if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || info.Size() == 0 {
+		t.Fatal("LLVM22 complete object absent", err)
+	}
+	verifyMapsLiteralMinimumOriginalSourceInputs(t, directory, originals)
+	t.Logf("complete SDK source SHA256=%x; all original TEXT/DATA plus compiler-owned helper, logical LLVM object only, not native SDK entry or execution", sha256.Sum256(original))
+}
+
+func runPublicCLIX86SDKOriginalMapsLiteralMinimumSource(t *testing.T, goos string) {
+	t.Helper()
+	setX86SDKNumericalCLIProfile(t, "effective-defaults")
+	t.Setenv("GOOS", goos)
+	ctx := arm64PrivateCLIContext(t)
+	directory, originals := mapsLiteralMinimumOriginalSourceInputs(t)
+	folder, report := t.TempDir(), filepath.Join(t.TempDir(), "report.json")
+	repository, err := filepath.Abs("../..")
+	if err != nil {
+		t.Fatal(err)
+	}
+	args, err := json.Marshal([]string{"-targets=" + goos + "/amd64", "-patterns=.", "-compile", "-keep-obj", "-strict-load", "-out=" + folder, "-report=" + report, "-repo-root=" + repository})
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, directory, append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(args)), os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+	if err != nil {
+		t.Fatalf("genuine original package public CLI: %v\n%s%s", err, stdout, stderr)
+	}
+	raw, err := os.ReadFile(report)
+	var decoded matrixReport
+	if err != nil || json.Unmarshal(raw, &decoded) != nil || decoded.Success != 2 || decoded.Failed != 0 || decoded.NotApplicable != 0 || decoded.TotalAsm != 2 || decoded.TotalTargets != 1 || len(decoded.Targets) != 1 {
+		t.Fatalf("genuine complete package denominator/result differs: %v\n%s", err, raw)
+	}
+	target := decoded.Targets[0]
+	if target.Goos != goos || target.Goarch != "amd64" || target.Success != 2 || target.TotalAsm != 2 ||
+		target.Failed != 0 || target.NotApplicable != 0 || len(target.AsmFiles) != 2 ||
+		len(target.AsmPackages) != 1 || target.AsmPackages[0] != "internal/runtime/maps" {
+		t.Fatal("public CLI changed its actual complete package/target selection", target)
+	}
+	seen := map[string]bool{}
+	for _, input := range target.AsmFiles {
+		name := filepath.Base(input)
+		if originals[name] == nil || seen[name] {
+			t.Fatal("public CLI omitted, duplicated or replaced a complete original member", input)
+		}
+		seen[name] = true
+		output := filepath.Join(folder, "internal", "runtime", "maps", name+".ll")
+		ir, err := os.ReadFile(output)
+		if err != nil || strings.Count(string(ir), "define ") != 2 {
+			t.Fatal("public CLI complete original definitions/compiler-owned helper differ", name, err)
+		}
+		if name == "memhash_amd64.s" && (!strings.Contains(string(ir), "external global [128 x i8]") || strings.Count(string(ir), "internal constant [256 x i8]") != 2) {
+			t.Fatal("public CLI changed complete original readonly DATA/mutable runtime storage", name)
+		}
+		if info, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+			t.Fatal("public CLI complete LLVM22 object absent", name, err)
+		}
+	}
+	verifyMapsLiteralMinimumOriginalSourceInputs(t, directory, originals)
+	t.Log("genuine public CLI: both original SDK ASM members/all three TEXTs plus compiler-owned helper, all DATA, strict full package denominator, nonempty LLVM22 objects; no native SDK execution claim")
+}
+
+func mapsLiteralMinimumOriginalSourceInputs(t *testing.T) (string, map[string][]byte) {
+	t.Helper()
+	directory := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "maps")
+	originals := map[string][]byte{}
+	for _, name := range []string{"memhash_amd64.s", "memhash_nosimd_amd64.s"} {
+		data, err := os.ReadFile(filepath.Join(directory, name))
+		if err != nil {
+			t.Fatal("complete original SDK member absent", name, err)
+		}
+		originals[name] = data
+	}
+	return directory, originals
+}
+
+func verifyMapsLiteralMinimumOriginalSourceInputs(t *testing.T, directory string, originals map[string][]byte) {
+	t.Helper()
+	for name, original := range originals {
+		after, err := os.ReadFile(filepath.Join(directory, name))
+		if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+			t.Fatal("original complete SDK member changed", name, err)
+		}
+		t.Logf("complete original SDK member=%s SHA256=%x", name, sha256.Sum256(original))
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_literal_minimum_policy_go127_test.go b/cmd/plan9asmll/x86_sdk_literal_minimum_policy_go127_test.go
new file mode 100644
index 000000000..8867eae53
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_literal_minimum_policy_go127_test.go
@@ -0,0 +1,241 @@
+//go:build go1.27
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestMapsLiteralMinimumTargetsHaveIndependentCompleteOwners(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_sdk_literal_minimum_go127_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := mapsLiteralMinimumCompleteOwnerPolicy(file); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func mapsLiteralMinimumCompleteOwnerPolicy(file *ast.File) error {
+	type owner struct{ helper, target string }
+	owners := map[string]owner{
+		"TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinux":          {"compileOneX86SDKOriginalMapsLiteralMinimumSource", "linux"},
+		"TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceDarwin":         {"compileOneX86SDKOriginalMapsLiteralMinimumSource", "darwin"},
+		"TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceWindows":        {"compileOneX86SDKOriginalMapsLiteralMinimumSource", "windows"},
+		"TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinuxPublicCLI": {"runPublicCLIX86SDKOriginalMapsLiteralMinimumSource", "linux"},
+	}
+	functions := map[string]*ast.FuncDecl{}
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		if functions[fn.Name.Name] != nil {
+			return fmt.Errorf("duplicate maps owner/helper: %s", fn.Name.Name)
+		}
+		functions[fn.Name.Name] = fn
+		expected, required := owners[fn.Name.Name]
+		if !required {
+			if strings.HasPrefix(fn.Name.Name, "Test") {
+				duplicated := false
+				ast.Inspect(fn.Body, func(node ast.Node) bool {
+					call, ok := node.(*ast.CallExpr)
+					if !ok {
+						return true
+					}
+					helper, ok := call.Fun.(*ast.Ident)
+					duplicated = duplicated || ok && (helper.Name == "compileOneX86SDKOriginalMapsLiteralMinimumSource" || helper.Name == "runPublicCLIX86SDKOriginalMapsLiteralMinimumSource")
+					return true
+				})
+				if duplicated {
+					return fmt.Errorf("extra duplicated heavy maps owner: %s", fn.Name.Name)
+				}
+			}
+			continue
+		}
+		if fn.Body == nil || len(fn.Body.List) != 1 {
+			return fmt.Errorf("target owner must unconditionally invoke its complete fixture: %s", fn.Name.Name)
+		}
+		expression, ok := fn.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			return fmt.Errorf("target owner contains a conditional or early return: %s", fn.Name.Name)
+		}
+		call, ok := expression.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 2 {
+			return fmt.Errorf("complete target fixture call missing: %s", fn.Name.Name)
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		literal, literalOK := call.Args[1].(*ast.BasicLit)
+		if !ok || helper.Name != expected.helper ||
+			!literalOK || literal.Value != strconv.Quote(expected.target) {
+			return fmt.Errorf("target owner lost its exact independent complete platform/role: %s", fn.Name.Name)
+		}
+		delete(owners, fn.Name.Name)
+	}
+	if len(owners) != 0 {
+		return fmt.Errorf("target owners missing; source and public CLI require separate unchanged deadlines: %v", owners)
+	}
+	for helper, required := range map[string]map[string]int{
+		"compileOneX86SDKOriginalMapsLiteralMinimumSource": {
+			"arm64PrivateCLIContext": 1, "setX86SDKNumericalCLIProfile": 1,
+			"Load": 1, "captureX86CallerSelections": 1, "compileOne": 1, "RunBounded": 0,
+			"mapsLiteralMinimumOriginalSourceInputs": 1, "verifyMapsLiteralMinimumOriginalSourceInputs": 1,
+			"ReadFile": 1, "Stat": 1,
+		},
+		"runPublicCLIX86SDKOriginalMapsLiteralMinimumSource": {
+			"arm64PrivateCLIContext": 1, "setX86SDKNumericalCLIProfile": 1,
+			"Load": 0, "compileOne": 0, "RunBounded": 1,
+			"mapsLiteralMinimumOriginalSourceInputs": 1, "verifyMapsLiteralMinimumOriginalSourceInputs": 1,
+			"ReadFile": 2, "Stat": 1, "Unmarshal": 1,
+		},
+	} {
+		fn := functions[helper]
+		if fn == nil || fn.Body == nil {
+			return fmt.Errorf("complete maps helper missing: %s", helper)
+		}
+		counts := map[string]int{}
+		literals := map[string]bool{}
+		var forbidden string
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			if literal, ok := node.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+				value, _ := strconv.Unquote(literal.Value)
+				literals[value] = true
+			}
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			name := ""
+			switch fun := call.Fun.(type) {
+			case *ast.Ident:
+				name = fun.Name
+			case *ast.SelectorExpr:
+				name = fun.Sel.Name
+			}
+			counts[name]++
+			if name == "Skip" || name == "Skipf" || name == "SkipNow" || name == "WithDeadline" || name == "WithTimeout" ||
+				name == "compileOneX86SDKOriginalMapsLiteralMinimumSource" || name == "runPublicCLIX86SDKOriginalMapsLiteralMinimumSource" {
+				forbidden = name
+			}
+			return true
+		})
+		if forbidden != "" {
+			return fmt.Errorf("maps helper duplicated a heavy role or changed/skipped its budget: %s/%s", helper, forbidden)
+		}
+		for name, count := range required {
+			if counts[name] != count {
+				return fmt.Errorf("maps complete role lost or duplicated: %s/%s count=%d want=%d", helper, name, counts[name], count)
+			}
+		}
+		for _, literal := range []string{"define ", "external global [128 x i8]", "internal constant [256 x i8]"} {
+			if !literals[literal] {
+				return fmt.Errorf("complete maps TEXT/DATA gate missing: %s/%q", helper, literal)
+			}
+		}
+		if helper == "runPublicCLIX86SDKOriginalMapsLiteralMinimumSource" {
+			for _, flag := range []string{"-patterns=.", "-compile", "-keep-obj", "-strict-load"} {
+				if !literals[flag] {
+					return fmt.Errorf("complete public CLI flag missing: %s", flag)
+				}
+			}
+			for literal := range literals {
+				if strings.HasPrefix(literal, "-limit") || strings.HasPrefix(literal, "-asm-files") {
+					return fmt.Errorf("public CLI cropped its complete original source: %s", literal)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func TestMapsLiteralMinimumOwnerPolicyRejectsMissingOrDuplicatedRoles(t *testing.T) {
+	find := func(file *ast.File, name string) *ast.FuncDecl {
+		for _, declaration := range file.Decls {
+			if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == name {
+				return fn
+			}
+		}
+		t.Fatal("required mutation fixture missing", name)
+		return nil
+	}
+	replace := func(file *ast.File, helper, before, after string) {
+		changed := false
+		ast.Inspect(find(file, helper).Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			switch fun := call.Fun.(type) {
+			case *ast.Ident:
+				if fun.Name == before {
+					fun.Name, changed = after, true
+				}
+			case *ast.SelectorExpr:
+				if fun.Sel.Name == before {
+					fun.Sel.Name, changed = after, true
+				}
+			}
+			return true
+		})
+		if !changed {
+			t.Fatal("mutation did not touch its original role", before)
+		}
+	}
+	source, public := "compileOneX86SDKOriginalMapsLiteralMinimumSource", "runPublicCLIX86SDKOriginalMapsLiteralMinimumSource"
+	mutations := map[string]func(*ast.File){
+		"missing independent CLI owner": func(file *ast.File) {
+			find(file, "TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinuxPublicCLI").Name.Name = "missingCLI"
+		},
+		"old duplicated heavy root": func(file *ast.File) {
+			copy := *find(file, "TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinux")
+			copy.Name = ast.NewIdent("TestOldCombinedMapsHeavyRoot")
+			file.Decls = append(file.Decls, &copy)
+		},
+		"CLI owner repeats source object": func(file *ast.File) {
+			replace(file, "TestCompileOneX86SDKOriginalMapsLiteralMinimumSourceLinuxPublicCLI", public, source)
+		},
+		"source role omitted":     func(file *ast.File) { replace(file, source, "compileOne", "missingCompile") },
+		"selection omitted":       func(file *ast.File) { replace(file, source, "Load", "missingLoad") },
+		"typed inventory omitted": func(file *ast.File) { replace(file, source, "captureX86CallerSelections", "missingSelection") },
+		"object gate omitted":     func(file *ast.File) { replace(file, source, "Stat", "missingObject") },
+		"shared source deadline":  func(file *ast.File) { replace(file, source, "arm64PrivateCLIContext", "reusedContext") },
+		"shared CLI deadline":     func(file *ast.File) { replace(file, public, "arm64PrivateCLIContext", "reusedContext") },
+		"real CLI omitted":        func(file *ast.File) { replace(file, public, "RunBounded", "missingCLI") },
+		"CLI object gate omitted": func(file *ast.File) { replace(file, public, "Stat", "missingObject") },
+		"source final hash omitted": func(file *ast.File) {
+			replace(file, source, "verifyMapsLiteralMinimumOriginalSourceInputs", "missingFinalSource")
+		},
+		"CLI final hash omitted": func(file *ast.File) {
+			replace(file, public, "verifyMapsLiteralMinimumOriginalSourceInputs", "missingFinalSource")
+		},
+		"CLI role skipped": func(file *ast.File) {
+			replace(file, public, "Helper", "SkipNow")
+		},
+		"whole DATA gate removed": func(file *ast.File) {
+			ast.Inspect(find(file, source).Body, func(node ast.Node) bool {
+				if literal, ok := node.(*ast.BasicLit); ok && literal.Value == strconv.Quote("internal constant [256 x i8]") {
+					literal.Value = strconv.Quote("missing DATA")
+				}
+				return true
+			})
+		},
+	}
+	for name, mutate := range mutations {
+		t.Run(name, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), "x86_sdk_literal_minimum_go127_test.go", nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutate(file)
+			if err := mapsLiteralMinimumCompleteOwnerPolicy(file); err == nil {
+				t.Fatal("broken independent complete owner policy passed")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_literal_minimum_source.go b/cmd/plan9asmll/x86_sdk_literal_minimum_source.go
new file mode 100644
index 000000000..73ccd2831
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_literal_minimum_source.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Both frontends use the shared actual-owner/context demand planner. This
+// adapter contributes no source role, minimum floor or new signature.
+func (source *x86SDKNumericalCLISource) bindNumericalReads(ctx context.Context, file *plan9asm.File, options plan9asm.Options) (plan9asm.Options, error) {
+	if source == nil || source.frontend == nil {
+		return plan9asm.Options{}, fmt.Errorf("%w: SDK numerical source lacks its original shared handoff", plan9asm.ErrProbeNeedsContext)
+	}
+	var err error
+	options, err = x86SDKDirectTailDeclarationOptions(source.goPackage, file, options)
+	if err != nil {
+		return plan9asm.Options{}, err
+	}
+	return source.frontend.BindNumericalReads(ctx, source.goPackage, file, options)
+}
diff --git a/cmd/plan9asmll/x86_sdk_math_shift_go127_test.go b/cmd/plan9asmll/x86_sdk_math_shift_go127_test.go
new file mode 100644
index 000000000..aa7f999c8
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_math_shift_go127_test.go
@@ -0,0 +1,94 @@
+//go:build go1.27
+
+package main
+
+import (
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+// The complete original function combines initialized scalar shifts, a live
+// Go-defined CPU-choice byte and independently initialized assembly literals.
+// Child package directories do not make its own direct compiler inputs flat.
+func TestCompileOneOriginalSDKMathExpScalarShiftAndNumericalSource(t *testing.T) {
+	compileOriginalSDKX86FamilySource(t, "math", "math", "exp_amd64.s",
+		"CMPB ·useFMA(SB), $1", "exprodata<>")
+}
+
+// Keep the whole original field multiplication source, rather than extracting
+// its first MULQ or substituting a synthetic register-source program.
+func TestCompileOneOriginalSDKFieldImplicitMultiplySource(t *testing.T) {
+	const packagePath = "crypto/internal/fips140/edwards25519/field"
+	compileOriginalSDKX86FamilySource(t, packagePath, packagePath, "fe_amd64.s",
+		"TEXT ·feMul(SB)", "MULQ (BX)", "IMUL3Q")
+}
+
+// Retain all three original bigmod functions and both CPU-choice paths. The
+// FIPS text-kind listing is an observation, not a substituted SB/entry role.
+func TestCompileOneOriginalSDKBigmodNativeListingSource(t *testing.T) {
+	const packagePath = "crypto/internal/fips140/bigmod"
+	compileOriginalSDKX86FamilySource(t, packagePath, packagePath, "nat_amd64.s",
+		"CMPB ·supportADX+0(SB), $0x01", "MULXQ", "ADCXQ", "ADOXQ")
+}
+
+func compileOriginalSDKX86FamilySource(t *testing.T, relativeDirectory, packagePath, assemblyFile string, witnesses ...string) {
+	t.Helper()
+	setX86SDKNumericalCLIProfile(t, "explicit")
+	ctx := arm64PrivateCLIContext(t)
+
+	directory := filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(relativeDirectory))
+	input := filepath.Join(directory, assemblyFile)
+	original, err := os.ReadFile(input)
+	if err != nil {
+		t.Fatal("complete original SDK source is absent", err)
+	}
+	for _, witness := range witnesses {
+		if !strings.Contains(string(original), witness) {
+			t.Fatalf("complete original SDK source %s lacks witness %q", assemblyFile, witness)
+		}
+	}
+	environment := os.Environ()
+	pkgs, err := packages.Load(&packages.Config{
+		Context: ctx, Dir: directory, Env: environment,
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+			packages.NeedTypes | packages.NeedTypesSizes,
+	}, ".")
+	if err != nil || len(pkgs) != 1 || pkgs[0].PkgPath != packagePath || len(pkgs[0].Errors) != 0 {
+		t.Fatalf("actual original SDK selection failed: %v %+v", err, pkgs)
+	}
+	selection, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, "go",
+		"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("stock Go failed the original package: %v\n%s%s", err, selection, stderr)
+	}
+	t.Logf("complete original ASM SHA256=%x; actual stock-Go archive selection SHA256=%x",
+		sha256.Sum256(original), sha256.Sum256(selection))
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/amd64", nil)
+	output := filepath.Join(t.TempDir(), strings.TrimSuffix(assemblyFile, ".s")+".ll")
+	if err := compileOne(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatal("original SDK source did not retain its complete LLVM object", err)
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("original SDK source changed during translation", err)
+	}
+	object, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o")
+	if err != nil || !object.Mode().IsRegular() || object.Size() == 0 {
+		t.Fatal("complete original SDK LLVM22 object is absent", err)
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_cache_go127_test.go b/cmd/plan9asmll/x86_sdk_numerical_cache_go127_test.go
new file mode 100644
index 000000000..83ffdcc7b
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_cache_go127_test.go
@@ -0,0 +1,94 @@
+//go:build go1.27
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// Only Go's content-addressed build artifacts may be shared with the caller.
+// Every source observation, proof, command workspace and output stays private.
+func x86SDKNumericalCLIBuildCache(t *testing.T) string {
+	t.Helper()
+	cache := os.Getenv("GOCACHE")
+	if cache == "" {
+		cache = t.TempDir()
+	}
+	selected, err := x86SDKNumericalCLICanonicalBuildCache(cache)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return selected
+}
+
+func x86SDKNumericalCLICanonicalBuildCache(cache string) (string, error) {
+	if !filepath.IsAbs(cache) {
+		return "", fmt.Errorf("selected GOCACHE must be an absolute existing directory: %q", cache)
+	}
+	selected, err := filepath.EvalSymlinks(cache)
+	if err != nil {
+		return "", fmt.Errorf("resolve selected GOCACHE: %w", err)
+	}
+	info, err := os.Stat(selected)
+	if err != nil || !info.IsDir() {
+		return "", fmt.Errorf("selected GOCACHE is not an existing directory: %q: %v", selected, err)
+	}
+	return selected, nil
+}
+
+func TestX86SDKCLIBuildCacheRetainsCallerSelection(t *testing.T) {
+	cache := t.TempDir()
+	marker := filepath.Join(cache, "independent-build-artifact")
+	if err := os.WriteFile(marker, []byte("caller-owned-content"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOCACHE", cache)
+	want, err := filepath.EvalSymlinks(cache)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for range 2 {
+		if got := x86SDKNumericalCLIBuildCache(t); got != want {
+			t.Fatalf("selected build cache changed: %q want %q", got, want)
+		}
+	}
+	if data, err := os.ReadFile(marker); err != nil || string(data) != "caller-owned-content" {
+		t.Fatalf("cache reuse changed the caller's artifacts: %q %v", data, err)
+	}
+}
+
+func TestX86SDKCLIBuildCacheWithoutSelectionIsPrivate(t *testing.T) {
+	t.Setenv("GOCACHE", "")
+	first := x86SDKNumericalCLIBuildCache(t)
+	second := x86SDKNumericalCLIBuildCache(t)
+	if first == second {
+		t.Fatal("absent caller selection unexpectedly shared independent fallback caches")
+	}
+	for _, selected := range []string{first, second} {
+		info, err := os.Stat(selected)
+		if err != nil || !info.IsDir() || !filepath.IsAbs(selected) {
+			t.Fatalf("private fallback cache is not an existing absolute directory: %q %v", selected, err)
+		}
+	}
+}
+
+func TestX86SDKCLIBuildCacheRejectsInvalidSelection(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "not-a-directory")
+	if err := os.WriteFile(file, []byte("not a cache"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for name, selected := range map[string]string{
+		"empty": "", "disabled": "off", "relative": "relative-cache",
+		"missing": filepath.Join(root, "missing"), "regular-file": file,
+	} {
+		t.Run(name, func(t *testing.T) {
+			if cache, err := x86SDKNumericalCLICanonicalBuildCache(selected); err == nil || cache != "" {
+				t.Fatalf("invalid selected cache passed or became an unrelated fallback: %q %q %v", selected, cache, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_cache_policy_go127_test.go b/cmd/plan9asmll/x86_sdk_numerical_cache_policy_go127_test.go
new file mode 100644
index 000000000..8c809c06b
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_cache_policy_go127_test.go
@@ -0,0 +1,149 @@
+//go:build go1.27
+
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This standalone standard-library policy can run without loading the CLI's
+// LLVM/SDK producers. It protects only tool-cache configuration, never proof.
+func x86SDKNumericalCLICachePolicy(file *ast.File) error {
+	var profile *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == "setX86SDKNumericalCLIProfile" {
+			if profile != nil {
+				return fmt.Errorf("duplicate actual SDK CLI profile")
+			}
+			profile = fn
+		}
+	}
+	if profile == nil || profile.Body == nil {
+		return fmt.Errorf("actual SDK CLI profile missing")
+	}
+	cacheSelections, cacheAssignments, cacheBindings, privateLoops := 0, 0, 0, 0
+	var failure error
+	ast.Inspect(profile.Body, func(node ast.Node) bool {
+		switch value := node.(type) {
+		case *ast.AssignStmt:
+			for _, destination := range value.Lhs {
+				if name, ok := destination.(*ast.Ident); ok && name.Name == "cache" {
+					cacheAssignments++
+					valid := false
+					if len(value.Lhs) == 1 && len(value.Rhs) == 1 {
+						if call, ok := value.Rhs[0].(*ast.CallExpr); ok && len(call.Args) == 1 {
+							fn, named := call.Fun.(*ast.Ident)
+							test, actual := call.Args[0].(*ast.Ident)
+							valid = named && fn.Name == "x86SDKNumericalCLIBuildCache" && actual && test.Name == "t"
+						}
+					}
+					if !valid {
+						failure = fmt.Errorf("selected build cache assignment changed")
+					}
+				}
+			}
+		case *ast.CallExpr:
+			if fn, ok := value.Fun.(*ast.Ident); ok && fn.Name == "x86SDKNumericalCLIBuildCache" {
+				cacheSelections++
+			}
+			if fn, ok := value.Fun.(*ast.SelectorExpr); ok && fn.Sel.Name == "Setenv" && len(value.Args) == 2 {
+				if key, ok := value.Args[0].(*ast.BasicLit); ok && key.Value == strconv.Quote("GOCACHE") {
+					cacheBindings++
+					if selected, ok := value.Args[1].(*ast.Ident); !ok || selected.Name != "cache" {
+						failure = fmt.Errorf("selected build cache was replaced")
+					}
+				}
+			}
+		case *ast.RangeStmt:
+			list, ok := value.X.(*ast.CompositeLit)
+			if !ok {
+				break
+			}
+			if _, stringsList := list.Type.(*ast.ArrayType); !stringsList {
+				break
+			}
+			keys := make(map[string]bool)
+			for _, element := range list.Elts {
+				if literal, ok := element.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+					key, _ := strconv.Unquote(literal.Value)
+					keys[key] = true
+				}
+			}
+			private, unsets := false, false
+			ast.Inspect(value.Body, func(child ast.Node) bool {
+				if call, ok := child.(*ast.CallExpr); ok {
+					if fn, ok := call.Fun.(*ast.SelectorExpr); ok {
+						private = private || fn.Sel.Name == "TempDir"
+						unsets = unsets || fn.Sel.Name == "Unsetenv"
+					}
+				}
+				return true
+			})
+			if private {
+				privateLoops++
+				if len(list.Elts) != 4 || len(keys) != 4 || !keys["GOPATH"] || !keys["GOMODCACHE"] || !keys["TMPDIR"] || !keys["GOTMPDIR"] {
+					failure = fmt.Errorf("build cache was recreated or private command roots changed: %v", keys)
+				}
+			}
+			if unsets && keys["GOCACHE"] {
+				failure = fmt.Errorf("effective defaults discarded the selected build cache")
+			}
+		}
+		return true
+	})
+	if failure != nil {
+		return failure
+	}
+	if cacheSelections != 1 || cacheAssignments != 1 || cacheBindings != 1 || privateLoops != 1 {
+		return fmt.Errorf("actual profile needs one selected cache and independent private roots: select=%d assign=%d bind=%d private=%d", cacheSelections, cacheAssignments, cacheBindings, privateLoops)
+	}
+	return nil
+}
+
+func TestX86SDKCLIProfileRetainsSelectedBuildCache(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_sdk_numerical_source_go127_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86SDKNumericalCLICachePolicy(file); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86SDKCLIProfileCachePolicyRejectsLostRoles(t *testing.T) {
+	data, err := os.ReadFile("x86_sdk_numerical_source_go127_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ name, before, after, failure string }{
+		{"new cache instead of selection", "cache := x86SDKNumericalCLIBuildCache(t)", "cache := t.TempDir()", "assignment changed"},
+		{"wrong selection owner", "cache := x86SDKNumericalCLIBuildCache(t)", "cache := x86SDKNumericalCLIBuildCache(other)", "assignment changed"},
+		{"new cache at binding", `t.Setenv("GOCACHE", cache)`, `t.Setenv("GOCACHE", t.TempDir())`, "cache was replaced"},
+		{"missing cache binding", `t.Setenv("GOCACHE", cache)`, `t.Setenv("OTHER_CACHE", cache)`, "one selected cache"},
+		{"cache in private loop", `[]string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"}`, `[]string{"GOCACHE", "GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"}`, "private command roots changed"},
+		{"missing private module cache", `[]string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"}`, `[]string{"GOPATH", "TMPDIR", "GOTMPDIR"}`, "private command roots changed"},
+		{"shared command workspace", "filepath.EvalSymlinks(t.TempDir())", "filepath.EvalSymlinks(cache)", "one selected cache"},
+		{"default cache unset", `[]string{"GOAMD64", "GO386", "GOPROXY", "GOTMPDIR", "GOMODCACHE", "GOPATH", "CGO_ENABLED"}`, `[]string{"GOCACHE", "GOAMD64", "GO386", "GOPROXY", "GOTMPDIR", "GOMODCACHE", "GOPATH", "CGO_ENABLED"}`, "defaults discarded"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			if strings.Count(string(data), mutation.before) != 1 {
+				t.Fatal("mutation did not identify exactly one original role")
+			}
+			source := strings.Replace(string(data), mutation.before, mutation.after, 1)
+			file, err := parser.ParseFile(token.NewFileSet(), "mutated-profile.go", source, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86SDKNumericalCLICachePolicy(file); err == nil || !strings.Contains(err.Error(), mutation.failure) {
+				t.Fatalf("mutation did not fail its intended role %q: %v", mutation.failure, err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_load.go b/cmd/plan9asmll/x86_sdk_numerical_load.go
new file mode 100644
index 000000000..683d81afc
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_load.go
@@ -0,0 +1,92 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"go/types"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+	"golang.org/x/tools/go/packages"
+)
+
+func sdkPackageView(pkg *packages.Package) *sdkfrontend.Package {
+	seen := make(map[*packages.Package]*sdkfrontend.Package)
+	var visit func(*packages.Package) *sdkfrontend.Package
+	visit = func(pkg *packages.Package) *sdkfrontend.Package {
+		if pkg == nil {
+			return nil
+		}
+		if view := seen[pkg]; view != nil {
+			return view
+		}
+		view := &sdkfrontend.Package{ID: pkg.ID, Name: pkg.Name, Path: pkg.PkgPath, Dir: pkg.Dir,
+			GoFiles: pkg.GoFiles, CompiledGoFiles: pkg.CompiledGoFiles, OtherFiles: pkg.OtherFiles,
+			Module: pkg.Module != nil, Test: isTestVariantPackage(pkg), IllTyped: pkg.IllTyped,
+			Types: pkg.Types, Sizes: pkg.TypesSizes, Imports: make(map[string]*sdkfrontend.Package)}
+		seen[pkg] = view
+		for _, err := range pkg.Errors {
+			view.Errors = append(view.Errors, err.Error())
+		}
+		for path, dependency := range pkg.Imports {
+			view.Imports[path] = visit(dependency)
+		}
+		return view
+	}
+	return visit(pkg)
+}
+
+func loadX86SDKNumericalPackage(ctx context.Context, binary string, pkg *packages.Package,
+	selected *x86CallerPackageSelection,
+) (*packages.Package, *x86CallerPackageSelection, func() error, error) {
+	if selected == nil {
+		return nil, nil, nil, sdkfrontend.Check(sdkPackageView(pkg), nil, "")
+	}
+	if err := verifyAMD64FixedLocalSelection(pkg, selected, selected.target); err != nil {
+		return nil, nil, nil, err
+	}
+	view := sdkPackageView(pkg)
+	selection := sdkfrontend.CaptureSelection(view, selected.target, selected.env, selected.mode)
+	var reloaded *packages.Package
+	_, snapshot, close, err := sdkfrontend.Reload(ctx, binary, view, selection,
+		func(ctx context.Context, directory string, environment []string) (*sdkfrontend.Package, error) {
+			loaded, err := packages.Load(&packages.Config{Context: ctx, Dir: directory, Env: environment,
+				Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+					packages.NeedModule | packages.NeedDeps | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes,
+			}, ".")
+			if err != nil {
+				return nil, err
+			}
+			if len(loaded) != 1 {
+				return nil, fmt.Errorf("SDK numerical reload selected %d packages, want one", len(loaded))
+			}
+			reloaded = loaded[0]
+			return sdkPackageView(reloaded), nil
+		})
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	imports := make(map[string]*types.Package, len(reloaded.Imports))
+	for path, dependency := range reloaded.Imports {
+		imports[path] = dependency.Types
+	}
+	environment := snapshot.Environment()
+	actual := &x86CallerPackageSelection{
+		identity: x86CallerSelectionIdentity(reloaded, environment), target: selected.target, types: reloaded.Types,
+		sizes: x86CallerSizes(reloaded.TypesSizes), imports: imports, env: environment,
+		ready: reflect.DeepEqual(reloaded.GoFiles, reloaded.CompiledGoFiles),
+	}
+	return reloaded, actual, close, nil
+}
+
+func x86SDKLoadGraph(pkg *packages.Package) (map[string]string, error) {
+	return sdkfrontend.Graph(sdkPackageView(pkg))
+}
+
+func x86SDKPhysicalSelectionIdentity(pkg *packages.Package) (string, error) {
+	return sdkfrontend.PhysicalIdentity(sdkPackageView(pkg))
+}
+
+func x86SDKSelectedSourceHashes(pkg *packages.Package) (map[string]string, error) {
+	return sdkfrontend.SourceHashes(sdkPackageView(pkg))
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_load_test.go b/cmd/plan9asmll/x86_sdk_numerical_load_test.go
new file mode 100644
index 000000000..4a94f1942
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_load_test.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestX86SDKNumericalReloadPhysicalSourceIdentity(t *testing.T) {
+	root, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, contents := range map[string]string{
+		"value.go": "package sample\nfunc Value() uint64\n",
+		"value.s":  "TEXT ·Value(SB),4,$0-8\nMOVQ $1,ret+0(FP)\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(root, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	alias := filepath.Join(t.TempDir(), "source-alias")
+	if err := os.Symlink(root, alias); err != nil {
+		t.Fatal(err)
+	}
+	// Metadata unit only: neither projection supplies a live SDK capture,
+	// type certificate, numerical owner or translation permission.
+	selection := func(directory string) *packages.Package {
+		return &packages.Package{
+			ID: "sample", PkgPath: "sample", Name: "sample", Dir: directory,
+			Types:           types.NewPackage("sample", "sample"),
+			GoFiles:         []string{filepath.Join(directory, "value.go")},
+			CompiledGoFiles: []string{filepath.Join(directory, "value.go")},
+			OtherFiles:      []string{filepath.Join(directory, "value.s")},
+		}
+	}
+	physical, logical := selection(root), selection(alias)
+	want, err := x86SDKLoadGraph(physical)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := x86SDKLoadGraph(logical)
+	if err != nil || !reflect.DeepEqual(actual, want) {
+		t.Fatalf("same physical SDK files acquired different source identities: %v", err)
+	}
+	wantFiles, err := x86SDKSelectedSourceHashes(physical)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualFiles, err := x86SDKSelectedSourceHashes(logical)
+	if err != nil || !reflect.DeepEqual(actualFiles, wantFiles) {
+		t.Fatalf("same source bytes acquired different physical keys: %v", err)
+	}
+	if logical.Dir != alias || logical.GoFiles[0] != filepath.Join(alias, "value.go") {
+		t.Fatal("identity projection rewrote the original package selection")
+	}
+	foreign := filepath.Join(t.TempDir(), "value.go")
+	data, err := os.ReadFile(physical.GoFiles[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(foreign, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	logical.CompiledGoFiles[0] = foreign
+	if changed, err := x86SDKLoadGraph(logical); err == nil && reflect.DeepEqual(changed, want) {
+		t.Fatal("equal-byte foreign file borrowed the captured source identity")
+	}
+	if changed, err := x86SDKSelectedSourceHashes(logical); err == nil && reflect.DeepEqual(changed, wantFiles) {
+		t.Fatal("equal-byte foreign file borrowed the original hash inventory")
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_source.go b/cmd/plan9asmll/x86_sdk_numerical_source.go
new file mode 100644
index 000000000..dbb39d19d
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_source.go
@@ -0,0 +1,215 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go/types"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/tools/go/packages"
+)
+
+// This adapter owns one complete-file observation. It never reconstructs a
+// permission from the diagnostic readback and never lends it to file chunks.
+type x86SDKNumericalCLISource struct {
+	frontend  *sdkfrontend.Source
+	selected  *x86CallerPackageSelection
+	pkg       *packages.Package
+	goPackage plan9asm.GoPackage
+	target    string
+	sources   map[string]string
+	cleanup   []func() error
+	original  *packages.Package
+	origin    *x86CallerPackageSelection
+}
+
+type x86SDKNumericalRetryError struct{ cause error }
+
+func (err *x86SDKNumericalRetryError) Error() string { return err.cause.Error() }
+func (err *x86SDKNumericalRetryError) Unwrap() error { return err.cause }
+
+// The independent SDK binder pins native object names, including private <>
+// suffixes. Ordinary CLI $local aliases remain unchanged outside this exact
+// observed complete-file route. This mapping grants no storage/read identity.
+func (source *x86SDKNumericalCLISource) resolve(symbol string) string {
+	return sdkfrontend.Resolve(source.pkg.PkgPath, symbol)
+}
+
+// Deferred source guards may join another error after translation. Such a
+// failure is authoritative: retry must never hide it behind a new source load.
+func x86SDKNumericalRetryCause(err error) (error, bool) {
+	switch value := err.(type) {
+	case *x86SDKNumericalRetryError:
+		return value.cause, true
+	case interface{ Unwrap() []error }:
+		children := value.Unwrap()
+		if len(children) == 1 {
+			return x86SDKNumericalRetryCause(children[0])
+		}
+	case interface{ Unwrap() error }:
+		return x86SDKNumericalRetryCause(value.Unwrap())
+	}
+	return nil, false
+}
+
+func (source *x86SDKNumericalCLISource) close() error {
+	var result error
+	for i := len(source.cleanup) - 1; i >= 0; i-- {
+		result = errors.Join(result, source.cleanup[i]())
+	}
+	source.cleanup = nil
+	return result
+}
+
+func (source *x86SDKNumericalCLISource) verify(ctx context.Context) error {
+	if err := verifyAMD64FixedLocalSelection(source.original, source.origin, source.target); err != nil {
+		return err
+	}
+	if err := verifyAMD64FixedLocalSelection(source.pkg, source.selected, source.target); err != nil {
+		return err
+	}
+	for name, expected := range source.sources {
+		actual, err := gotoolprofile.FileSHA256(name)
+		if err != nil {
+			return err
+		}
+		if actual != expected {
+			return fmt.Errorf("%w: SDK numerical compiled Go source changed", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	return source.frontend.Verify(ctx)
+}
+
+// The symbol query chooses whether to pay for an independent observer. It is
+// not a read-shape, offset, layout, source-role or caller certificate. The
+// supported SDK owner producer, rather than a package-name exemption, checks
+// the complete actual internal/cpu variable and every native read separately.
+func x86SDKCPUOwnerRequested(pkg *packages.Package, file *plan9asm.File, target string) bool {
+	return sdkfrontend.CPUOwnerRequested(sdkPackageView(pkg), file, target)
+}
+
+func x86SDKNumericalOwnerRequested(pkg *packages.Package, file *plan9asm.File, target string) bool {
+	return sdkfrontend.NumericalOwnerRequested(sdkPackageView(pkg), file, target)
+}
+
+func captureX86SDKNumericalSource(pkg *packages.Package, file *plan9asm.File, asm, target string,
+	config compileConfig,
+) (_ *plan9asm.File, _ *x86SDKNumericalCLISource, result error) {
+	if !config.acquireSDKNumerical {
+		return file, nil, nil
+	}
+	if config.Feature != nil || !x86SDKNumericalOwnerRequested(pkg, file, target) {
+		return nil, nil, fmt.Errorf("%w: SDK numerical retry no longer has its original candidate role", plan9asm.ErrProbeNeedsContext)
+	}
+	selected := config.x86CallerSelections[pkg]
+	if err := verifyAMD64FixedLocalSelection(pkg, selected, target); err != nil {
+		return nil, nil, err
+	}
+	ctx := config.Context
+	if ctx == nil {
+		return nil, nil, fmt.Errorf("%w: SDK numerical source requires a bounded context", plan9asm.ErrProbeNeedsContext)
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, nil, err
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, nil, fmt.Errorf("%w: SDK numerical source context is unbounded", plan9asm.ErrProbeNeedsContext)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		return nil, nil, err
+	}
+	original, origin := pkg, selected
+	pkg, selected, release, err := loadX86SDKNumericalPackage(ctx, binary, pkg, selected)
+	if err != nil {
+		return nil, nil, err
+	}
+	source := &x86SDKNumericalCLISource{selected: selected, pkg: pkg, target: target,
+		original: original, origin: origin, cleanup: []func() error{release}}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.close())
+		}
+	}()
+	directory, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil {
+		return nil, nil, err
+	}
+	actualAsm, err := sourcepath.Resolve(asm)
+	if err != nil || filepath.Dir(actualAsm) != directory {
+		return nil, nil, fmt.Errorf("%w: SDK numerical assembly origin differs: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	// Deduplicate only: exec uses the last value. Never replace a loaded
+	// profile with more convenient flags, cache paths or environment defaults.
+	values := make(map[string]string)
+	for _, entry := range selected.env {
+		key, value, valid := strings.Cut(entry, "=")
+		if !valid || key == "" {
+			return nil, nil, fmt.Errorf("malformed SDK numerical actual-load environment")
+		}
+		values[key] = value
+	}
+	var environment []string
+	for key, value := range values {
+		environment = append(environment, key+"="+value)
+	}
+	sort.Strings(environment)
+	root, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, binary, "env", "GOROOT")
+	if err != nil || len(stderr) != 0 {
+		return nil, nil, fmt.Errorf("observe actual SDK root: %w", errors.Join(err, numericalCLIStderr(stderr)))
+	}
+	rootPath, err := sourcepath.Resolve(strings.TrimSpace(string(root)))
+	if err != nil || !filepath.IsAbs(rootPath) {
+		return nil, nil, fmt.Errorf("%w: SDK numerical root is not canonical: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	syntax, sources, err := amd64FixedLocalActualSyntax(ctx, pkg)
+	if err != nil {
+		return nil, nil, err
+	}
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, dependency := range pkg.Imports {
+		imports[path] = dependency.Types
+	}
+	source.sources = sources
+	// Preserve linkname discovery for the newly loaded package as well as the
+	// complete declaration syntax required by the independent numerical binder.
+	pkg.Syntax = syntax
+	source.goPackage = plan9asm.GoPackage{Path: pkg.PkgPath, Types: pkg.Types, Syntax: syntax, Imports: imports}
+	actual, observed, err := sdkfrontend.Capture(ctx, sdkfrontend.CaptureRequest{
+		GoBinary: binary, Root: rootPath, Directory: directory, PackagePath: pkg.PkgPath,
+		AssemblyFile: actualAsm, Target: target, Environment: environment,
+		Package: sdkPackageView(pkg),
+	}, file)
+	if err != nil {
+		return nil, nil, err
+	}
+	source.frontend = observed
+	source.cleanup = append(source.cleanup, observed.Close)
+	if err := source.verify(ctx); err != nil {
+		return nil, nil, err
+	}
+	return actual, source, nil
+}
+
+func numericalCLIStderr(stderr []byte) error {
+	if len(stderr) == 0 {
+		return nil
+	}
+	return fmt.Errorf("actual Go stderr: %s", strings.TrimSpace(string(stderr)))
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_source_go127_test.go b/cmd/plan9asmll/x86_sdk_numerical_source_go127_test.go
new file mode 100644
index 000000000..a911439f3
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_source_go127_test.go
@@ -0,0 +1,288 @@
+//go:build go1.27
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestCompileOneX86SDKOriginalCRC32NumericalDataJoin(t *testing.T) {
+	t.Run("explicit", func(t *testing.T) {
+		compileX86SDKOriginalCRC32NumericalDataJoin(t, "explicit")
+	})
+}
+
+func TestCompileOneX86SDKOriginalCRC32NumericalDataJoinEffectiveDefaults(t *testing.T) {
+	t.Run("effective-defaults", func(t *testing.T) {
+		compileX86SDKOriginalCRC32NumericalDataJoin(t, "effective-defaults")
+	})
+}
+
+func setX86SDKNumericalCLIProfile(t *testing.T, profile string) {
+	t.Helper()
+	cache := x86SDKNumericalCLIBuildCache(t)
+	for key, value := range map[string]string{
+		"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOPACKAGESDRIVER": "off",
+		"GOPROXY": "off", "CGO_ENABLED": "0", "GOAMD64": "v1", "GO386": "sse2",
+		"GOOS": "linux", "GOARCH": "amd64", "GOARM": "", "GOARM64": "", "GOWASM": "",
+	} {
+		t.Setenv(key, value)
+	}
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		path, err := filepath.EvalSymlinks(t.TempDir())
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Setenv(key, path)
+	}
+	t.Setenv("GOCACHE", cache)
+	if profile == "effective-defaults" {
+		for _, key := range []string{"GOAMD64", "GO386", "GOPROXY", "GOTMPDIR", "GOMODCACHE", "GOPATH", "CGO_ENABLED"} {
+			// Setenv owns restoration and prohibits parallel environment users;
+			// the actual load below observes an absent key, not a forged receipt.
+			t.Setenv(key, "")
+			if err := os.Unsetenv(key); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+func compileX86SDKOriginalCRC32NumericalDataJoin(t *testing.T, profile string) {
+	t.Helper()
+	setX86SDKNumericalCLIProfile(t, profile)
+	ctx := arm64PrivateCLIContext(t)
+	directory := filepath.Join(runtime.GOROOT(), "src", "hash", "crc32")
+	input := filepath.Join(directory, "crc32_amd64.s")
+	original, err := os.ReadFile(input)
+	if err != nil || !strings.Contains(string(original), "CMPB internal∕cpu·X86+const_offsetX86HasAVX512VPCLMULQDQL(SB), $1") {
+		t.Fatal("original current SDK counterexample is absent", err)
+	}
+	environment := os.Environ()
+	pkgs, err := packages.Load(&packages.Config{
+		Context: ctx, Dir: directory, Env: environment,
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedModule | packages.NeedDeps | packages.NeedImports |
+			packages.NeedTypes | packages.NeedTypesSizes,
+	}, ".")
+	if err != nil || len(pkgs) != 1 || pkgs[0].PkgPath != "hash/crc32" || len(pkgs[0].Errors) != 0 {
+		t.Fatalf("actual original SDK selection failed: %v %+v", err, pkgs)
+	}
+	selection, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, "go",
+		"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("original stock Go package failed: %v\n%s%s", err, selection, stderr)
+	}
+	t.Logf("original SDK assembly SHA256=%x; actual selection SHA256=%x", sha256.Sum256(original), sha256.Sum256(selection))
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelections(pkgs, "linux/amd64", nil)
+	if profile == "explicit" {
+		t.Run("ordinary-proof-failure-publishes-nothing", func(t *testing.T) {
+			folder := t.TempDir()
+			// Complete actual declarations now legitimately bind these CMP
+			// reads without an SDK reload. A genuinely missing load owner must
+			// still fail before publishing and must not become a source retry.
+			unbound := config
+			unbound.x86CallerSelections = nil
+			err := compileOneAttempt(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: filepath.Join(folder, "ordinary.ll")}, false, unbound)
+			if _, retryable := x86SDKNumericalRetryCause(err); retryable || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("missing actual declaration owner bypassed its pre-publication guard: %v", err)
+			}
+			artifacts, err := os.ReadDir(folder)
+			if err != nil || len(artifacts) != 0 {
+				t.Fatalf("ordinary proof rejection published output: %v, %v", artifacts, err)
+			}
+		})
+		t.Run("ordinary-declarations-complete-object-without-reload", func(t *testing.T) {
+			output := filepath.Join(t.TempDir(), "ordinary.ll")
+			// This one attempt has acquireSDKNumerical=false. Success cannot
+			// borrow compileOne's separate guarded SDK retry or its observations.
+			if err := compileOneAttempt(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+				t.Fatal("complete actual CRC32 declarations still require SDK source authority", err)
+			}
+			ir, err := os.ReadFile(output)
+			if err != nil || !strings.Contains(string(ir), "load volatile i8") ||
+				!strings.Contains(string(ir), `@"internal/cpu.X86" = external global `) {
+				t.Fatal("ordinary CPU declaration lost its real external byte-read role", err)
+			}
+			if object, err := os.Lstat(strings.TrimSuffix(output, ".ll") + ".o"); err != nil || !object.Mode().IsRegular() || object.Size() == 0 {
+				t.Fatal("ordinary complete-source LLVM22 object is missing", err)
+			}
+		})
+		t.Run("actual-reload-has-distinct-types-and-owned-roots", func(t *testing.T) {
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			reloaded, snapshot, release, err := loadX86SDKNumericalPackage(ctx, binary, pkgs[0], config.x86CallerSelections[pkgs[0]])
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := release(); err != nil {
+					t.Error(err)
+				}
+			})
+			if reloaded == pkgs[0] || reloaded.Types == pkgs[0].Types || snapshot.types != reloaded.Types {
+				t.Fatal("reload merely relabelled the original package/types")
+			}
+			var temp string
+			for _, entry := range snapshot.env {
+				if strings.HasPrefix(entry, "GOTMPDIR=") {
+					temp = strings.TrimPrefix(entry, "GOTMPDIR=")
+				}
+			}
+			if !filepath.IsAbs(temp) || temp == os.Getenv("GOTMPDIR") {
+				t.Fatal("reload did not own its temporary root")
+			}
+			if err := release(); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := os.Stat(temp); !os.IsNotExist(err) {
+				t.Fatalf("owned reload workspace survived close: %v", err)
+			}
+		})
+		t.Run("nondefault-CPU-is-not-relabelled", func(t *testing.T) {
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			selected := *config.x86CallerSelections[pkgs[0]]
+			selected.env = append(append([]string(nil), selected.env...), "GOAMD64=v2")
+			reloaded, snapshot, release, err := loadX86SDKNumericalPackage(ctx, binary, pkgs[0], &selected)
+			if reloaded != nil || snapshot != nil || release != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("nonbaseline profile acquired a baseline selection: %v", err)
+			}
+			unbound := config
+			unbound.x86CallerSelections = map[*packages.Package]*x86CallerPackageSelection{pkgs[0]: &selected}
+			folder := t.TempDir()
+			err = compileOne(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+				asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: filepath.Join(folder, "rejected.ll")}, false, unbound)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatalf("unbound CPU profile was not refused: %v", err)
+			}
+			artifacts, err := os.ReadDir(folder)
+			if err != nil || len(artifacts) != 0 {
+				t.Fatalf("failed complete-file proof published output: %v, %v", artifacts, err)
+			}
+		})
+		t.Run("cancellation-is-not-source-exclusion", func(t *testing.T) {
+			cancelled, cancel := context.WithCancel(ctx)
+			cancel()
+			reloaded, snapshot, release, err := loadX86SDKNumericalPackage(cancelled, "go", pkgs[0], config.x86CallerSelections[pkgs[0]])
+			if reloaded != nil || snapshot != nil || release != nil || !errors.Is(err, context.Canceled) {
+				t.Fatalf("cancelled load did not preserve cancellation: %v", err)
+			}
+		})
+	}
+	output := filepath.Join(t.TempDir(), "crc32.ll")
+	if err := compileOne(pkgs[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+		asmTask{PkgPath: pkgs[0].PkgPath, AsmFile: input, OutLL: output}, false, config); err != nil {
+		t.Fatalf("unchanged SDK Go compilation passed but CLI translation/object failed: %v", err)
+	}
+	after, err := os.ReadFile(input)
+	if err != nil || sha256.Sum256(after) != sha256.Sum256(original) {
+		t.Fatal("original SDK assembly changed during CLI consumption", err)
+	}
+	object, err := os.Stat(strings.TrimSuffix(output, ".ll") + ".o")
+	if err != nil || !object.Mode().IsRegular() || object.Size() == 0 {
+		t.Fatal("actual SDK LLVM22 object is missing", err)
+	}
+	if profile == "effective-defaults" {
+		// Exercise the ordinary entry point as well as compileOne: the reload
+		// must consume defaults from the real invocation, not a test-only seam.
+		out := t.TempDir()
+		report := filepath.Join(t.TempDir(), "report.json")
+		repository, err := filepath.Abs("../..")
+		if err != nil {
+			t.Fatal(err)
+		}
+		args, err := json.Marshal([]string{"-targets=linux/amd64", "-patterns=.", "-compile", "-keep-obj",
+			"-strict-load", "-out=" + out, "-report=" + report, "-repo-root=" + repository})
+		if err != nil {
+			t.Fatal(err)
+		}
+		env := append(os.Environ(), "PLAN9ASM_CPUCLI_ARGS="+string(args))
+		stdout, stderr, err := gotoolprofile.RunBounded(ctx, directory, env, os.Args[0], "-test.run=^TestFeatureConsumerCLIChild$")
+		if err != nil {
+			t.Fatalf("ordinary unchanged SDK CLI failed: %v\n%s%s", err, stdout, stderr)
+		}
+		data, err := os.ReadFile(report)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var decoded matrixReport
+		if err := json.Unmarshal(data, &decoded); err != nil || decoded.Success != 1 || decoded.Failed != 0 ||
+			decoded.NotApplicable != 0 || decoded.TotalAsm != 1 || decoded.TotalTargets != 1 {
+			t.Fatalf("original SDK CLI complete result differs: %v\n%s", err, data)
+		}
+	}
+}
+
+func TestCompileOneX86SDKBytealgCountExistingObjects(t *testing.T) {
+	compileX86SDKBytealgExistingObject(t, "count_amd64.s")
+}
+
+func TestCompileOneX86SDKBytealgIndexByteExistingObjects(t *testing.T) {
+	compileX86SDKBytealgExistingObject(t, "indexbyte_amd64.s")
+}
+
+func compileX86SDKBytealgExistingObject(t *testing.T, name string) {
+	t.Helper()
+	compileX86SDKExistingObject(t, "internal/bytealg", name)
+}
+
+func compileX86SDKExistingObject(t *testing.T, packagePath, name string) {
+	t.Helper()
+	setX86SDKNumericalCLIProfile(t, "effective-defaults")
+	ctx := arm64PrivateCLIContext(t)
+	dir := filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(packagePath))
+	actual, err := packages.Load(&packages.Config{Context: ctx, Dir: dir, Env: os.Environ(),
+		Mode: packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles |
+			packages.NeedModule | packages.NeedDeps | packages.NeedImports | packages.NeedTypes | packages.NeedTypesSizes,
+	}, ".")
+	if err != nil || len(actual) != 1 || len(actual[0].Errors) != 0 {
+		t.Fatalf("original SDK %s load: %v, %+v", packagePath, err, actual)
+	}
+	if err := loadLinknameSyntax(actual[0]); err != nil {
+		t.Fatal(err)
+	}
+	config, err := resolveCompileConfig(true, "", true, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	config.Context = ctx
+	config.x86CallerSelections = captureX86CallerSelections(actual, "linux/amd64", nil)
+	t.Run(name, func(t *testing.T) {
+		// Retain each whole original private-continuation program and its
+		// ordinary compileOne path, including the guarded SDK retry.
+		file := filepath.Join(t.TempDir(), "original.ll")
+		if err := compileOne(actual[0], plan9asm.ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu",
+			asmTask{PkgPath: actual[0].PkgPath, AsmFile: filepath.Join(dir, name), OutLL: file}, false, config); err != nil {
+			t.Fatalf("unchanged ordinary SDK %s regressed: %v", packagePath, err)
+		}
+		if object, err := os.Stat(strings.TrimSuffix(file, ".ll") + ".o"); err != nil || object.Size() == 0 {
+			t.Fatalf("ordinary SDK %s object absent: %v", packagePath, err)
+		}
+	})
+}
diff --git a/cmd/plan9asmll/x86_sdk_numerical_source_test.go b/cmd/plan9asmll/x86_sdk_numerical_source_test.go
new file mode 100644
index 000000000..b71ea1f5a
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_numerical_source_test.go
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"golang.org/x/tools/go/packages"
+)
+
+func TestX86SDKNumericalRetryCannotHidePostGuardErrors(t *testing.T) {
+	cause := fmt.Errorf("translate: %w", plan9asm.ErrProbeNeedsContext)
+	retry := &x86SDKNumericalRetryError{cause: cause}
+	guard := errors.New("original input changed")
+	for _, row := range []struct {
+		name string
+		err  error
+		want bool
+	}{
+		{"marker", retry, true},
+		{"nil-guard", errors.Join(retry, nil), true},
+		{"wrapped", fmt.Errorf("whole source: %w", retry), true},
+		{"changed-source", errors.Join(retry, guard), false},
+		{"context-alone", cause, false},
+		{"ordinary-failure", guard, false},
+		{"success", nil, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			got, ok := x86SDKNumericalRetryCause(row.err)
+			if ok != row.want || ok && got != cause || !ok && got != nil {
+				t.Fatalf("retry = (%v, %v), want %v", got, ok, row.want)
+			}
+		})
+	}
+}
+
+func TestX86SDKNumericalCleanupOrderAndErrors(t *testing.T) {
+	first, second := errors.New("numerical close"), errors.New("SDK close")
+	var closed []string
+	source := &x86SDKNumericalCLISource{}
+	for _, item := range []struct {
+		name string
+		err  error
+	}{
+		{"workspace", nil}, {"CPU owner", nil}, {"SDK", second}, {"literal", nil}, {"numerical", first},
+	} {
+		item := item
+		source.cleanup = append(source.cleanup, func() error {
+			closed = append(closed, item.name)
+			return item.err
+		})
+	}
+	err := source.close()
+	if !errors.Is(err, first) || !errors.Is(err, second) {
+		t.Fatalf("cleanup lost an authoritative error: %v", err)
+	}
+	want := []string{"numerical", "literal", "SDK", "CPU owner", "workspace"}
+	if !reflect.DeepEqual(closed, want) {
+		t.Fatalf("close order = %v, want %v", closed, want)
+	}
+	if source.close() != nil || !reflect.DeepEqual(closed, want) {
+		t.Fatal("closed handles were invoked twice")
+	}
+}
+
+func TestX86SDKNumericalPrivateNamespaceRemainsExact(t *testing.T) {
+	source := &x86SDKNumericalCLISource{pkg: &packages.Package{PkgPath: "hash/crc32"}}
+	for input, want := range map[string]string{
+		"·ieeeCLMUL": "hash/crc32.ieeeCLMUL", "internal∕cpu·X86": "internal/cpu.X86",
+		"·r2r1<>": "hash/crc32.r2r1<>", "·r2r1": "hash/crc32.r2r1", "·r2r1$local": "hash/crc32.r2r1$local",
+	} {
+		if actual := source.resolve(input); actual != want {
+			t.Fatalf("resolve(%q) = %q, want %q", input, actual, want)
+		}
+	}
+	if ordinary := resolveSymFunc("hash/crc32")("·r2r1<>"); ordinary != "hash/crc32.r2r1$local" {
+		t.Fatal("ordinary local naming changed", ordinary)
+	}
+}
+
+func TestX86SDKNumericalOwnerQueryIsNotPackageExemption(t *testing.T) {
+	for _, row := range []struct {
+		name, pkg, target, operand string
+		module                     bool
+		want                       bool
+	}{
+		{"amd64", "hash/crc32", "linux/amd64", "internal∕cpu·X86+82(SB)", false, true},
+		{"386", "arbitrary/sdk/package", "linux/386", "internal∕cpu·X86+64(SB)", false, true},
+		{"darwin-amd64", "hash/crc32", "darwin/amd64", "internal∕cpu·X86+82(SB)", false, true},
+		{"windows-amd64", "hash/crc32", "windows/amd64", "internal∕cpu·X86+82(SB)", false, true},
+		{"windows-386", "arbitrary/sdk/package", "windows/386", "internal∕cpu·X86+64(SB)", false, true},
+		{"self", "internal/cpu", "linux/386", "·X86(SB)", false, true},
+		{"substring", "hash/crc32", "linux/amd64", "internal∕cpu·X86Other+82(SB)", false, false},
+		{"local", "hash/crc32", "linux/amd64", "internal∕cpu·X86<>+82(SB)", false, false},
+		{"external", "hash/crc32", "linux/amd64", "internal∕cpu·X86+82(SB)", true, false},
+		{"foreign-target", "hash/crc32", "freebsd/amd64", "internal∕cpu·X86+82(SB)", false, false},
+		{"unavailable-darwin-386", "hash/crc32", "darwin/386", "internal∕cpu·X86+64(SB)", false, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg := &packages.Package{PkgPath: row.pkg}
+			if row.module {
+				pkg.Module = &packages.Module{Path: row.pkg}
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT ·Probe(SB),4,$0-0\nCMPB "+row.operand+",$1\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if actual := x86SDKCPUOwnerRequested(pkg, file, row.target); actual != row.want {
+				t.Fatalf("cost query = %v, want %v", actual, row.want)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmll/x86_sdk_tail_signatures.go b/cmd/plan9asmll/x86_sdk_tail_signatures.go
new file mode 100644
index 000000000..6beeda87f
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_tail_signatures.go
@@ -0,0 +1,147 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/types"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func x86SDKNeedsDirectTailDeclarations(file *plan9asm.File) bool {
+	if file != nil && file.Arch == plan9asm.ArchAMD64 {
+		for _, fn := range file.Funcs {
+			for _, ins := range fn.Instrs {
+				if ins.Op == plan9asm.OpJMP && len(ins.Args) == 1 && strings.Contains(ins.Args[0].Sym, "<>") {
+					return true // Cost query only; the inventory and graph still validate every use.
+				}
+			}
+		}
+	}
+	return false
+}
+
+// The authenticated SDK route starts from actual declarations, not fabricated
+// FP words for private graph nodes. This is only an inventory: the existing
+// live source binder and complete direct-tail graph still own admission.
+func x86SDKDirectTailDeclarationInventory(pkg plan9asm.GoPackage, file *plan9asm.File, options plan9asm.Options) (map[string]plan9asm.FuncSig, map[string]int64, bool, error) {
+	if !x86SDKNeedsDirectTailDeclarations(file) {
+		return nil, nil, false, nil
+	}
+	if pkg.Types == nil || pkg.Types.Path() != pkg.Path || options.ResolveSym == nil ||
+		options.Goarch != "386" && options.Goarch != "amd64" {
+		return nil, nil, true, fmt.Errorf("%w: SDK tail inventory lacks its actual typed package/resolver/mode", plan9asm.ErrProbeNeedsContext)
+	}
+	requests, err := assemblySignatureRequests(pkg.Path, file, options.ResolveSym)
+	if err != nil {
+		return nil, nil, true, err
+	}
+	signatures, sizes := make(map[string]plan9asm.FuncSig), make(map[string]int64)
+	for symbol, request := range requests {
+		if strings.Contains(request.original, "<>") {
+			continue // A private graph node has no independent callable ABI.
+		}
+		actual, size, found, err := tryDeclSig(pkg.Types.Scope(), stripABISuffix(request.original), symbol,
+			linknameRemoteToLocal(pkg.Syntax), options.Goarch, types.SizesFor("gc", options.Goarch),
+			strings.HasSuffix(request.original, "<ABIInternal>"))
+		if err != nil || !found {
+			return nil, nil, true, fmt.Errorf("%w: SDK tail inventory lacks actual declaration %s: %v", plan9asm.ErrProbeNeedsContext, symbol, err)
+		}
+		signatures[symbol], sizes[symbol] = actual, size
+	}
+	options.Sigs = signatures
+	bound, err := x86SDKDirectTailDeclarationOptions(pkg, file, options)
+	if err != nil {
+		return nil, nil, true, err
+	}
+	return bound.Sigs, sizes, true, nil
+}
+
+// This is an inventory adapter, not a source or entry producer. The live SDK
+// binder subsequently authenticates every original declaration/node and the
+// direct-tail graph proves each root's state and terminal compatibility. Generic
+// CLI fallback signatures remain unchanged outside this complete-source route.
+func x86SDKDirectTailDeclarationOptions(pkg plan9asm.GoPackage, file *plan9asm.File, options plan9asm.Options) (plan9asm.Options, error) {
+	if !x86SDKNeedsDirectTailDeclarations(file) {
+		return options, nil
+	}
+	contextError := func(reason string) error {
+		return fmt.Errorf("%w: SDK numerical tail declarations: %s", plan9asm.ErrProbeNeedsContext, reason)
+	}
+	if pkg.Types == nil || pkg.Types.Path() != pkg.Path || options.ResolveSym == nil ||
+		(options.Goarch != "386" && options.Goarch != "amd64") {
+		return plan9asm.Options{}, contextError("missing actual typed package/resolver/mode")
+	}
+	sizes := types.SizesFor("gc", options.Goarch)
+	linknames := linknameRemoteToLocal(pkg.Syntax)
+	declared := make(map[string]plan9asm.FuncSig)
+	helpers := make(map[string]bool)
+	texts := make(map[string]bool)
+	add := func(symbol string) error {
+		logical := stripABISuffix(symbol)
+		name := options.ResolveSym(logical)
+		if name == "" {
+			return contextError("empty original declaration identity")
+		}
+		actual, _, present, err := tryDeclSig(pkg.Types.Scope(), logical, name, linknames, options.Goarch, sizes, false)
+		if err != nil || !present {
+			return contextError("root/ordinary terminal lacks its actual Go declaration: " + logical)
+		}
+		provided, present := options.Sigs[name]
+		// JSON is solely an equality projection. Keep the original value, including
+		// its private caller/local capabilities; never reconstruct one from bytes.
+		before, actualErr := json.Marshal(actual)
+		after, providedErr := json.Marshal(provided)
+		if !present || actualErr != nil || providedErr != nil || !bytes.Equal(before, after) {
+			return contextError("supplied root/terminal transport differs from its actual declaration: " + name)
+		}
+		declared[name] = provided
+		return nil
+	}
+	for _, fn := range file.Funcs {
+		if texts[fn.Sym] {
+			return plan9asm.Options{}, contextError("duplicate original TEXT")
+		}
+		texts[fn.Sym] = true
+		if strings.HasSuffix(fn.Sym, "<>") {
+			helpers[options.ResolveSym(fn.Sym)] = true
+			continue
+		}
+		if err := add(fn.Sym); err != nil {
+			return plan9asm.Options{}, err
+		}
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op != plan9asm.OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+				continue
+			}
+			operand := strings.TrimSpace(ins.Args[0].Sym)
+			if !strings.HasSuffix(operand, "(SB)") {
+				continue // Local source labels retain the graph's separate CFG audit.
+			}
+			symbol, offset := splitSymPlusOff(strings.TrimSuffix(operand, "(SB)"))
+			if symbol == "" || offset != 0 {
+				return plan9asm.Options{}, contextError("offset/unknown ordinary terminal")
+			}
+			if strings.HasSuffix(symbol, "<>") {
+				if !texts[symbol] {
+					return plan9asm.Options{}, contextError("private terminal lacks its complete original TEXT")
+				}
+				continue
+			}
+			if err := add(symbol); err != nil {
+				return plan9asm.Options{}, err
+			}
+		}
+	}
+	for name := range options.Sigs {
+		if _, present := declared[name]; !present && !helpers[name] {
+			return plan9asm.Options{}, contextError("unassociated callable signature: " + name)
+		}
+	}
+	options.Sigs = declared
+	return options, nil
+}
diff --git a/cmd/plan9asmll/x86_sdk_tail_signatures_test.go b/cmd/plan9asmll/x86_sdk_tail_signatures_test.go
new file mode 100644
index 000000000..f8ac5ab3d
--- /dev/null
+++ b/cmd/plan9asmll/x86_sdk_tail_signatures_test.go
@@ -0,0 +1,194 @@
+package main
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sdkfrontend"
+	"golang.org/x/tools/go/packages"
+)
+
+const x86SDKTailDeclarationGo = `package p
+func First(x uint64) (out uint64)
+func Second(a uint32, b uint32) (out uint64)
+func Ordinary(x uint64) (out uint64) { return x }
+func Other(a uint32, b uint32) (out uint64) { return uint64(a)+uint64(b) }
+`
+
+const x86SDKTailDeclarationASM = `TEXT ·First(SB),4,$0-16
+JMP shared<>(SB)
+TEXT ·Second(SB),4,$0-16
+JMP shared<>(SB)
+TEXT shared<>(SB),4,$0
+JMP ·Ordinary(SB)
+`
+
+func x86SDKTailTypedDeclarationFixture(t *testing.T, arch, source, assembly string) (plan9asm.GoPackage, *plan9asm.File, plan9asm.Options) {
+	t.Helper()
+	const path = "example.invalid/taildecl"
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "p.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", arch)
+	typed, err := (&types.Config{Sizes: sizes}).Check(path, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := plan9asm.GoPackage{Path: path, Types: typed, Syntax: []*ast.File{syntax}}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return sdkfrontend.Resolve(path, symbol) }
+	return pkg, file, plan9asm.Options{Goarch: arch, ResolveSym: resolve}
+}
+
+func x86SDKTailDeclarationFixture(t *testing.T, arch, source, assembly string) (plan9asm.GoPackage, *plan9asm.File, plan9asm.Options) {
+	t.Helper()
+	pkg, file, options := x86SDKTailTypedDeclarationFixture(t, arch, source, assembly)
+	sizes := types.SizesFor("gc", arch)
+	loaded := &packages.Package{PkgPath: pkg.Path, Types: pkg.Types, TypesSizes: sizes, Syntax: pkg.Syntax}
+	sigs, _, err := sigsForAsmFile(loaded, file, options.ResolveSym, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options.Sigs = sigs
+	return pkg, file, options
+}
+
+func TestX86SDKDirectTailBoundInventoryRetainsStrictTranslationConsumer(t *testing.T) {
+	const assembly = `TEXT ·First(SB),4,$0-16
+MOVQ x+0(FP),AX
+JMP shared<>(SB)
+TEXT ·Second(SB),4,$0-16
+MOVL a+0(FP),AX
+JMP shared<>(SB)
+TEXT shared<>(SB),4,$0
+MOVQ AX,out+8(FP)
+RET
+`
+	pkg, file, requested := x86SDKTailTypedDeclarationFixture(t, "amd64", x86SDKTailDeclarationGo, assembly)
+	loaded := &packages.Package{PkgPath: pkg.Path, Types: pkg.Types, TypesSizes: types.SizesFor("gc", "amd64"), Syntax: pkg.Syntax}
+	if _, _, err := sigsForAsmFile(loaded, file, requested.ResolveSym, "amd64"); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("unbound private FP words escaped the generic original-extent check", err)
+	}
+	actual, _, needed, err := x86SDKDirectTailDeclarationInventory(pkg, file, requested)
+	if err != nil || !needed || len(actual) != 2 {
+		t.Fatal("actual typed root inventory was replaced by private-node heuristics", needed, err)
+	}
+	requested.Sigs = actual
+	bound, err := x86SDKDirectTailDeclarationOptions(pkg, file, requested)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound.TargetTriple = "x86_64-unknown-linux-gnu"
+	config := compileConfig{numericalOptions: &bound}
+	task := asmTask{OutLL: filepath.Join(t.TempDir(), "complete.ll")}
+	stale := make(map[string]plan9asm.FuncSig)
+	for name, sig := range actual {
+		stale[name] = sig
+	}
+	helper := requested.ResolveSym(file.Funcs[2].Sym)
+	stale[helper] = fallbackSigForAsmFunc(file.Funcs[2], helper, "amd64") // Deliberately unbound; negative control only.
+	// This is the CLI's existing equality handoff, not a numerical source token.
+	// The old local inventory must still fail, and forwarding the exact admitted
+	// root inventory must reach the ordinary complete-file translator.
+	err = translateAndCompileModule(file, bound.TargetTriple, "amd64", task, false, config, requested.ResolveSym, stale)
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || !strings.Contains(err.Error(), "options changed after binding") {
+		t.Fatal("strict consumer stopped detecting the stale helper signature", err)
+	}
+	if err := translateAndCompileModule(file, bound.TargetTriple, "amd64", task, false, config, bound.ResolveSym, bound.Sigs); err != nil {
+		t.Fatal("exact declaration inventory was not transported to complete source lowering", err)
+	}
+	if err := translateAndCompileModule(file, bound.TargetTriple, "amd64", task, true, config, bound.ResolveSym, bound.Sigs); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("consumer equality was relaxed for a different translation option", err)
+	}
+}
+
+func TestX86SDKDirectTailSignaturesUseActualCompleteDeclarations(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, helper := range []string{"shared", "renamed"} {
+			t.Run(arch+"/"+helper, func(t *testing.T) {
+				assembly := strings.ReplaceAll(x86SDKTailDeclarationASM, "shared", helper)
+				pkg, file, options := x86SDKTailDeclarationFixture(t, arch, x86SDKTailDeclarationGo, assembly)
+				original := options.Sigs
+				if len(original) != 4 {
+					t.Fatal("counterexample no longer exercises generic fallback", original)
+				}
+				bound, err := x86SDKDirectTailDeclarationOptions(pkg, file, options)
+				if err != nil || len(bound.Sigs) != 3 {
+					t.Fatalf("actual root/terminal inventory includes fabricated helper: %v, %v", bound.Sigs, err)
+				}
+				for _, name := range []string{"First", "Second", "Ordinary"} {
+					resolved := pkg.Path + "." + name
+					if !reflect.DeepEqual(bound.Sigs[resolved], original[resolved]) {
+						t.Fatal("actual typed role changed", resolved)
+					}
+				}
+				if len(original) != 4 || !reflect.DeepEqual(file.Funcs[2].Sym, helper+"<>") {
+					t.Fatal("adapter mutated caller source/signature inventory")
+				}
+			})
+		}
+	}
+}
+
+func TestX86SDKDirectTailInventoryRetainsOriginalABISelectors(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, selector := range []string{"", "<ABIInternal>"} {
+			t.Run(arch+"/"+selector, func(t *testing.T) {
+				assembly := strings.ReplaceAll(x86SDKTailDeclarationASM, "·First(SB)", "·First"+selector+"(SB)")
+				pkg, file, options := x86SDKTailTypedDeclarationFixture(t, arch, x86SDKTailDeclarationGo, assembly)
+				signatures, sizes, needed, err := x86SDKDirectTailDeclarationInventory(pkg, file, options)
+				if err != nil || !needed || len(signatures) != 3 || len(sizes) != 3 {
+					t.Fatal("original ABI selector hid an actual declaration or invented a private ABI", needed, err)
+				}
+				if file.Funcs[0].Sym != "·First"+selector {
+					t.Fatal("declaration inventory rewrote the original ABI selector")
+				}
+			})
+		}
+	}
+}
+
+func TestX86SDKDirectTailSignaturesNeverBorrowRootForOrdinaryTarget(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, role := range []string{"missing-declaration", "wrong-target-transport", "changed-root", "extra-entry", "missing-root"} {
+			t.Run(arch+"/"+role, func(t *testing.T) {
+				assembly := x86SDKTailDeclarationASM
+				if role == "missing-declaration" {
+					assembly = strings.ReplaceAll(assembly, "·Ordinary(SB)", "·Missing(SB)")
+				}
+				pkg, file, options := x86SDKTailDeclarationFixture(t, arch, x86SDKTailDeclarationGo, assembly)
+				name := pkg.Path + ".Ordinary"
+				switch role {
+				case "wrong-target-transport":
+					candidate := options.Sigs[pkg.Path+".Second"]
+					candidate.Name = name
+					options.Sigs[name] = candidate
+				case "changed-root":
+					candidate := options.Sigs[pkg.Path+".First"]
+					candidate.Frame.Results[0].Offset++
+					options.Sigs[candidate.Name] = candidate
+				case "extra-entry":
+					options.Sigs[pkg.Path+".Extra"] = plan9asm.FuncSig{Name: pkg.Path + ".Extra", Ret: plan9asm.I64}
+				case "missing-root":
+					delete(options.Sigs, pkg.Path+".First")
+				}
+				if _, err := x86SDKDirectTailDeclarationOptions(pkg, file, options); err == nil {
+					t.Fatal("unproved declaration/transport acquired numerical-tail entry inventory")
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/accumulator_extension_context_test.go b/cmd/plan9asmscan/accumulator_extension_context_test.go
new file mode 100644
index 000000000..6c7bfd06a
--- /dev/null
+++ b/cmd/plan9asmscan/accumulator_extension_context_test.go
@@ -0,0 +1,25 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestAccumulatorExtensionCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		names := []string{"CBW", "CWDE", "CWD", "CDQ"}
+		if arch == "amd64" {
+			names = append(names, "CDQE", "CQO")
+		}
+		for _, name := range names {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, name)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "MOVL $7,AX\n"+name)); err != nil {
+					t.Fatal("initialized complete accumulator extension rejected", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/adx_context_test.go b/cmd/plan9asmscan/adx_context_test.go
new file mode 100644
index 000000000..63b368c75
--- /dev/null
+++ b/cmd/plan9asmscan/adx_context_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestADXCoverageRequiresBothOperandsAndSelectedCarry(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				line := op + " AX,BX"
+				valueProbeNeedsContext(t, arch, line)
+				prefix := "MOVL $3,AX\nMOVL $7,BX\nCMPL AX,AX\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+line)); err != nil {
+					t.Fatal("complete initialized ADX sequence rejected", err)
+				}
+				for _, remove := range []string{"MOVL $3,AX\n", "MOVL $7,BX\n", "CMPL AX,AX\n"} {
+					// Use a separate initialized comparison register so missing
+					// AX cannot be hidden by the comparison's own input check.
+					source := "MOVL $1,DX\n" + strings.Replace(prefix, "CMPL AX,AX", "CMPL DX,DX", 1) + line
+					remove = strings.Replace(remove, "CMPL AX,AX", "CMPL DX,DX", 1)
+					valueProbeNeedsContext(t, arch, strings.Replace(source, remove, "", 1))
+				}
+				valueProbeNeedsContext(t, arch, "MOVL $3,AX\nMOVL $7,BX\nCLC\nADOXL AX,BX")
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/bextr_context_test.go b/cmd/plan9asmscan/bextr_context_test.go
new file mode 100644
index 000000000..4a921f8ff
--- /dev/null
+++ b/cmd/plan9asmscan/bextr_context_test.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestBEXTRCoverageRequiresActualControlAndSource(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				row := op + " AX,BX,CX"
+				valueProbeNeedsContext(t, arch, row)
+				valueProbeNeedsContext(t, arch, op+" AX,(BX),CX")
+				for _, prefix := range []string{
+					"MOVW $0x0804,AX\n",
+					"MOVB $4,AL\nMOVL $7,BX\n",
+				} {
+					valueProbeNeedsContext(t, arch, prefix+row)
+				}
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "MOVW $0x0804,AX\nMOVL $7,BX\n"+row)); err != nil {
+					t.Fatal("initialized complete BEXTR form was classified as unsupported", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/block_store_context_test.go b/cmd/plan9asmscan/block_store_context_test.go
new file mode 100644
index 000000000..25b54805a
--- /dev/null
+++ b/cmd/plan9asmscan/block_store_context_test.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBlockExtractStoreCoverageRequiresInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, suffix := range []string{"F128", "I128", "F32X4", "I32X4", "F64X2", "I64X2", "F32X8", "I32X8", "F64X4", "I64X4"} {
+			banks := []string{"Y", "Z"}
+			if strings.HasSuffix(suffix, "128") {
+				banks = []string{"Y"}
+			} else if strings.HasSuffix(suffix, "32X8") || strings.HasSuffix(suffix, "64X4") {
+				banks = []string{"Z"}
+			}
+			for _, bank := range banks {
+				t.Run(arch+"/"+suffix+"/"+bank, func(t *testing.T) {
+					valueProbeNeedsContext(t, arch, "VEXTRACT"+suffix+" $255,"+bank+"1,(BX)")
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/bls_context_test.go b/cmd/plan9asmscan/bls_context_test.go
new file mode 100644
index 000000000..3ceeece38
--- /dev/null
+++ b/cmd/plan9asmscan/bls_context_test.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestBLSCoverageRequiresActualSourceBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BLSIL", "BLSIQ", "BLSMSKL", "BLSMSKQ", "BLSRL", "BLSRQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				row := op + " AX,BX"
+				valueProbeNeedsContext(t, arch, row)
+				valueProbeNeedsContext(t, arch, op+" (AX),BX")
+				valueProbeNeedsContext(t, arch, "MOVB $7,AL\n"+row)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "MOVL $7,AX\n"+row)); err != nil {
+					t.Fatal("initialized BLS source classified as unsupported", arch, op, err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/bzhi_context_test.go b/cmd/plan9asmscan/bzhi_context_test.go
new file mode 100644
index 000000000..d18570a1c
--- /dev/null
+++ b/cmd/plan9asmscan/bzhi_context_test.go
@@ -0,0 +1,28 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestBZHICoverageRequiresActualIndexAndSource(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				for _, source := range []string{
+					op + " AX,BX,CX",
+					op + " AX,(BX),CX",
+					"MOVB $4,AH\nMOVL $7,BX\n" + op + " AX,BX,CX",
+					"MOVB $0,AL\n" + op + " AX,BX,CX",
+				} {
+					valueProbeNeedsContext(t, arch, source)
+				}
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "MOVB $4,AL\nMOVL $7,BX\n"+op+" AX,BX,CX")); err != nil {
+					t.Fatal("initialized low-byte BZHI source classified as unsupported", arch, op, err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/cmov_aes_context_test.go b/cmd/plan9asmscan/cmov_aes_context_test.go
new file mode 100644
index 000000000..3554199f6
--- /dev/null
+++ b/cmd/plan9asmscan/cmov_aes_context_test.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCMOVCoverageRequiresDataAndPredicateInputs(t *testing.T) {
+	conditions := strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS")
+	for _, arch := range []string{"386", "amd64"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			if arch == "386" && width == "Q" {
+				continue
+			}
+			for _, condition := range conditions {
+				op := "CMOV" + width + condition
+				t.Run(arch+"/"+op, func(t *testing.T) {
+					// The existing closed, nontrapping GP domain may leave a
+					// dead named-register result unknown. Consume that result
+					// through TEST/SETcc so missing data/predicate bytes cannot
+					// be mistaken for initialized implementation-slot values.
+					line := op + " AX,BX\nTEST" + width + " BX,BX\nSETEQ CX"
+					prefix := "MOVL $3,AX\nMOVL $7,BX\nMOVL $1,DX\nCMPL DX,DX\n"
+					valueProbeNeedsContext(t, arch, line)
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+line)); err != nil {
+						t.Fatal("initialized complete CMOV sequence rejected", err)
+					}
+					for _, remove := range []string{"MOVL $3,AX\n", "MOVL $7,BX\n", "CMPL DX,DX\n"} {
+						valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, remove, "", 1))
+					}
+					valueProbePairedNumericAddress(t, arch, prefix+op+" (AX),BX")
+				})
+			}
+		}
+	}
+}
+
+func TestAESCoverageRequiresActualVectorInputs(t *testing.T) {
+	names := strings.Fields("AESENC AESENCLAST AESDEC AESDECLAST AESIMC AESKEYGENASSIST " +
+		"VAESENC VAESENCLAST VAESDEC VAESDECLAST VAESIMC VAESKEYGENASSIST")
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range names {
+			banks := []string{"X"}
+			unary := strings.Contains(name, "IMC") || strings.Contains(name, "KEYGEN")
+			if strings.HasPrefix(name, "V") && !unary {
+				banks = append(banks, "Y", "Z")
+			}
+			for _, bank := range banks {
+				t.Run(arch+"/"+name+"/"+bank, func(t *testing.T) {
+					line := name + " " + bank + "0," + bank + "1"
+					if strings.HasPrefix(name, "V") && !unary {
+						line += "," + bank + "2"
+					}
+					if strings.Contains(name, "KEYGEN") {
+						line = name + " $27," + bank + "0," + bank + "1"
+					}
+					destination := "X1"
+					if strings.HasPrefix(name, "V") && !unary {
+						destination = "X2"
+					}
+					// Existing dead register arithmetic may remain unknown;
+					// observing it cannot borrow implementation-slot values.
+					line += "\nMOVL " + destination + ",AX\nTESTL AX,AX\nSETEQ CX"
+					prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+					valueProbeNeedsContext(t, arch, line)
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+line)); err != nil {
+						t.Fatal("initialized complete AES sequence rejected", err)
+					}
+					valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, "VPXORD Z0,Z0,Z0\n", "", 1))
+					if !unary {
+						valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, "VPXORD Z1,Z1,Z1\n", "", 1))
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/compact_context_test.go b/cmd/plan9asmscan/compact_context_test.go
new file mode 100644
index 000000000..3c7c04474
--- /dev/null
+++ b/cmd/plan9asmscan/compact_context_test.go
@@ -0,0 +1,100 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+var compactProbeOpcodes = strings.Fields("VCOMPRESSPS VCOMPRESSPD VPCOMPRESSB VPCOMPRESSW VPCOMPRESSD VPCOMPRESSQ " +
+	"VEXPANDPS VEXPANDPD VPEXPANDB VPEXPANDW VPEXPANDD VPEXPANDQ")
+
+func compactProbeInstructions(t *testing.T, body string) []plan9asm.Instr {
+	t.Helper()
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT probe(SB),4,$0-0\n"+body+"\nRET\n")
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("independent compact probe fixture did not parse", err)
+	}
+	return file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1]
+}
+
+func compactProbeInstruction(op, bank, mode string) string {
+	switch mode {
+	case "unmasked":
+		return fmt.Sprintf("%s %s0,%s1", op, bank, bank)
+	case "merge":
+		return fmt.Sprintf("%s %s0,K1,%s1", op, bank, bank)
+	case "zero":
+		return fmt.Sprintf("%s.Z %s0,K1,%s1", op, bank, bank)
+	default:
+		panic("unknown independent probe mode")
+	}
+}
+
+func TestCompactCoverageProbesRequireSourceInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range compactProbeOpcodes {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				forms := []string{
+					compactProbeInstruction(op, bank, "unmasked"),
+					compactProbeInstruction(op, bank, "merge"),
+					compactProbeInstruction(op, bank, "zero"),
+					fmt.Sprintf("%s %s0,K1,8(AX)", op, bank),
+				}
+				if strings.Contains(op, "EXPAND") {
+					forms[3] = fmt.Sprintf("%s 8(AX),K1,%s1", op, bank)
+				}
+				for _, form := range forms {
+					t.Run(arch+"/"+form, func(t *testing.T) {
+						instruction := compactProbeInstructions(t, form)[0]
+						err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, instruction)
+						if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+							t.Error("isolated compact opcode acquired unknown source, mask, merge or memory inputs", err)
+						}
+						state := &formStat{}
+						classifyFormProbe(state, err)
+						if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+							t.Error("missing inputs were counted as supported or an unknown opcode", state)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestCompactCoverageSequencesKeepCompleteInputRequirements(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range compactProbeOpcodes {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					t.Run(arch+"/"+op+"/"+bank+"/"+mode, func(t *testing.T) {
+						body := "MOVL $7,AX\nKMOVD AX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" +
+							compactProbeInstruction(op, bank, mode)
+						probe := func(source string) error {
+							return plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, source))
+						}
+						if err := probe(body); err != nil {
+							t.Error("complete explicit compact inputs were rejected", err)
+						}
+						if err := probe(strings.Replace(body, "VPXORD Z0,Z0,Z0\n", "", 1)); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+							t.Error("missing source vector became initialized", err)
+						}
+						if mode != "unmasked" {
+							if err := probe(strings.Replace(body, "KMOVD AX,K1\n", "", 1)); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+								t.Error("unknown mask became a complete byte dependency", err)
+							}
+						}
+						err := probe(strings.Replace(body, "VPXORD Z1,Z1,Z1\n", "", 1))
+						if mode == "merge" && !errors.Is(err, plan9asm.ErrProbeNeedsContext) || mode != "merge" && err != nil {
+							t.Error("old destination requirements did not match merge versus overwrite", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/control_identity_test.go b/cmd/plan9asmscan/control_identity_test.go
new file mode 100644
index 000000000..702cf939b
--- /dev/null
+++ b/cmd/plan9asmscan/control_identity_test.go
@@ -0,0 +1,78 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanGoAssemblerKeepsRejectedControlsSeparate(t *testing.T) {
+	const ordinary = "VADDPD X2, X9, X2"
+	// This is the original Go 1.20 amd64enc_extra.s observation. Its
+	// z=1/aaa=0 bytes are invalid; a historical encoder bug is not NUM.
+	const invalid = "VADDPD.Z X30, X1, X0"
+	root := t.TempDir()
+	path := filepath.Join(root, "src/cmd/asm/internal/asm/testdata/amd64enc_extra.s")
+	if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, []byte(ordinary+"\n"+invalid+"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ops, forms, parseErrors, files, err := scanGoAssemblerTestdata(root, plan9asm.ArchAMD64, "amd64")
+	if err != nil || len(parseErrors) != 0 || files != 1 || len(forms) != 2 {
+		t.Fatalf("original probes merged: files=%d forms=%d parse=%v err=%v", files, len(forms), parseErrors, err)
+	}
+	report := buildReport("go-asm", "go1.20.invalid-encoding-fixture", "linux", "amd64",
+		0, 0, files, ops, forms, nil, nil, nil, nil, parseErrors)
+	if report.UniqueForms != 2 || report.SupportedForms != 1 || report.UnsupportedForms != 1 || report.ContextForms != 0 {
+		t.Fatalf("invalid source changed ordinary acceptance or became context: %+v", report.Forms)
+	}
+	if len(report.UnsupportedByForm) != 1 {
+		t.Fatalf("lost the actual failed source: %+v", report.UnsupportedByForm)
+	}
+	failure := report.UnsupportedByForm[0]
+	if failure.Opcode != "VADDPD" || failure.Form != "VADDPD.Z xmm,xmm,xmm" || failure.Count != 1 ||
+		len(failure.Examples) != 1 || failure.Examples[0] != invalid ||
+		len(failure.Files) != 1 || failure.Files[0] != "amd64enc_extra.s" ||
+		len(failure.Errors) != 1 || !strings.Contains(failure.Errors[0], invalid) ||
+		failure.RuntimeVerified || failure.CompileOnly {
+		t.Fatalf("failure lost its exact controls/source/diagnostic or acquired evidence: %+v", failure)
+	}
+}
+
+func TestControlledFormsDoNotInheritBaseEvidence(t *testing.T) {
+	rows := []string{
+		"VADDPD Z0,Z1,K1,Z2", "VADDPD.Z Z0,Z1,K1,Z2",
+		"VADDPD (AX),Z1,K1,Z2", "VADDPD.BCST (AX),Z1,K1,Z2", "VADDPD.BCST.Z (AX),Z1,K1,Z2",
+		"VADDPD.RN_SAE Z0,Z1,K1,Z2", "VADDPD.RD_SAE Z0,Z1,K1,Z2",
+		"VADDPD.RU_SAE Z0,Z1,K1,Z2", "VADDPD.RZ_SAE Z0,Z1,K1,Z2", "VADDPD.RN_SAE.Z Z0,Z1,K1,Z2",
+		"VMAXPD Z0,Z1,K1,Z2", "VMAXPD.SAE Z0,Z1,K1,Z2", "VMAXPD.SAE.Z Z0,Z1,K1,Z2",
+	}
+	forms := map[string]*formStat{}
+	manifest := map[string]struct{}{}
+	for index, row := range rows {
+		ins := compactProbeInstructions(t, row)[0]
+		descriptor := plan9asm.DescribeInstruction(plan9asm.ArchAMD64, "amd64", ins)
+		addFormStat(forms, plan9asm.ArchAMD64, "amd64", ins, "controls.s")
+		if index == 0 {
+			manifest["amd64\x00"+descriptor.Form] = struct{}{}
+		}
+	}
+	if len(forms) != len(rows) {
+		t.Fatalf("distinct memory, rounding, SAE or zeroing controls collapsed: forms=%d rows=%d", len(forms), len(rows))
+	}
+	report := buildReport("go-asm", "go1.test", "linux", "amd64", 0, 0, 1,
+		nil, forms, nil, nil, manifest, manifest, nil)
+	if report.RuntimeVerifiedForms != 1 || report.CompileOnlyForms != 1 {
+		t.Fatalf("a base-form association supplied evidence to other controls: runtime=%d compile=%d", report.RuntimeVerifiedForms, report.CompileOnlyForms)
+	}
+	for _, form := range report.Forms {
+		if strings.Contains(form.Form, ".") && (form.RuntimeVerified || form.CompileOnly) {
+			t.Fatalf("source controls inherited a base-form association: %+v", form)
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/coverage_rule_ci_test.go b/cmd/plan9asmscan/coverage_rule_ci_test.go
new file mode 100644
index 000000000..4ffc3d065
--- /dev/null
+++ b/cmd/plan9asmscan/coverage_rule_ci_test.go
@@ -0,0 +1,220 @@
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Run the actual CI checker, not a duplicate fingerprint comparison. These
+// synthetic reports prove drift detection only, never instruction coverage.
+func TestOfficialCoverageCIChecksCompleteEncodingRuleAttributes(t *testing.T) {
+	script, err := os.ReadFile("../../scripts/check-go-asm-coverage.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, python, ok := strings.Cut(string(script), "<<'PY'\n")
+	if !ok {
+		t.Fatal("official coverage checker is not bound to its script")
+	}
+	python, _, ok = strings.Cut(python, "\nPY\n")
+	if !ok {
+		t.Fatal("official coverage checker has no complete heredoc")
+	}
+	tool, err := exec.LookPath("python3")
+	if err != nil {
+		tool, err = exec.LookPath("python")
+	}
+	if err != nil {
+		t.Fatal("Python 3 is required by the actual official CI checker", err)
+	}
+	original, err := os.ReadFile("../../testdata/coverage/go-asm-baseline.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{
+		"unchanged", "changed-fingerprint", "changed-count", "missing-report",
+		"missing-baseline", "both-missing", "386-fingerprint", "count-zero",
+		"count-bool", "count-string", "malformed-fingerprint", "missing-count", "missing-fingerprint",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			var baseline map[string]interface{}
+			if err := json.Unmarshal(original, &baseline); err != nil {
+				t.Fatal(err)
+			}
+			versions := baseline["versions"].(map[string]interface{})
+			// Every minor and architecture remains present in the real checker.
+			// Add isolated synthetic attributes without changing class buckets.
+			for _, release := range versions {
+				arches := release.(map[string]interface{})
+				for _, arch := range []string{"386", "amd64"} {
+					entry := arches[arch].(map[string]interface{})
+					entry["encoder_rules"] = float64(3)
+					entry["encoder_rule_fingerprint"] = strings.Repeat("a", 64)
+				}
+			}
+			arches := versions["go1.27"].(map[string]interface{})
+			reports := make(map[string]map[string]interface{})
+			for arch, value := range arches {
+				bytes, err := json.Marshal(value)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var report map[string]interface{}
+				if err := json.Unmarshal(bytes, &report); err != nil {
+					t.Fatal(err)
+				}
+				report["go_version"] = "go1.27.1"
+				report["goarch"] = arch
+				reports[arch] = report
+			}
+			families, err := os.ReadFile("../../testdata/coverage/arm64-go-assembler-families.txt")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var catalog []map[string]interface{}
+			for _, line := range strings.Split(string(families), "\n") {
+				line = strings.TrimSpace(line)
+				if line != "" && !strings.HasPrefix(line, "#") {
+					catalog = append(catalog, map[string]interface{}{
+						"opcode": line, "encoder_forms": 1, "observed_in_corpus": true,
+					})
+				}
+			}
+			reports["arm64"]["opcode_catalog"] = catalog
+			entry := arches["amd64"].(map[string]interface{})
+			switch mutation {
+			case "changed-fingerprint":
+				reports["amd64"]["encoder_rule_fingerprint"] = strings.Repeat("b", 64)
+			case "changed-count":
+				reports["amd64"]["encoder_rules"] = float64(4)
+			case "386-fingerprint":
+				reports["386"]["encoder_rule_fingerprint"] = strings.Repeat("b", 64)
+			case "count-zero":
+				reports["amd64"]["encoder_rules"] = 0
+			case "count-bool":
+				reports["amd64"]["encoder_rules"] = true
+			case "count-string":
+				reports["amd64"]["encoder_rules"] = "3"
+			case "malformed-fingerprint":
+				reports["amd64"]["encoder_rule_fingerprint"] = "not-a-rule-hash"
+			case "missing-count":
+				delete(reports["amd64"], "encoder_rules")
+			case "missing-fingerprint":
+				delete(reports["amd64"], "encoder_rule_fingerprint")
+			case "missing-report", "both-missing":
+				delete(reports["amd64"], "encoder_rules")
+				delete(reports["amd64"], "encoder_rule_fingerprint")
+			}
+			if mutation == "missing-baseline" || mutation == "both-missing" {
+				delete(entry, "encoder_rules")
+				delete(entry, "encoder_rule_fingerprint")
+			}
+			dir := t.TempDir()
+			write := func(name string, value interface{}) {
+				bytes, err := json.Marshal(value)
+				if err == nil {
+					err = os.WriteFile(filepath.Join(dir, name), bytes, 0600)
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+			write("baseline.json", baseline)
+			reportDir := filepath.Join(dir, "reports")
+			if err := os.Mkdir(reportDir, 0700); err != nil {
+				t.Fatal(err)
+			}
+			for arch, report := range reports {
+				write(filepath.Join("reports", arch+".json"), report)
+			}
+			familyPath, err := filepath.Abs("../../testdata/coverage/arm64-go-assembler-families.txt")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+			defer cancel()
+			command := exec.CommandContext(ctx, tool, "-", filepath.Join(dir, "baseline.json"), familyPath, reportDir)
+			command.Stdin = strings.NewReader(python)
+			output, err := command.CombinedOutput()
+			if mutation == "unchanged" {
+				if err != nil {
+					t.Fatalf("unchanged complete synthetic inventory rejected: %v\n%s", err, output)
+				}
+			} else if err == nil {
+				t.Fatalf("CI accepted %s with identical historical operand-class fingerprint:\n%s", mutation, output)
+			} else if ctx.Err() != nil || !strings.Contains(string(output), "encoder_rule") {
+				t.Fatalf("CI failure was not an encoding-rule diagnosis: %v\n%s", err, output)
+			}
+		})
+	}
+}
+
+type encodingRuleBaselineEntry struct {
+	EncoderForms           int    `json:"encoder_forms"`
+	EncoderFingerprint     string `json:"encoder_fingerprint"`
+	EncoderRules           int    `json:"encoder_rules"`
+	EncoderRuleFingerprint string `json:"encoder_rule_fingerprint"`
+}
+
+// The optional source roots let maintainers query several installed SDKs in
+// one process. This is table inventory, not an assembler/runtime certificate.
+func TestOfficialCoverageRuleBaselineMatchesSelectedGoTables(t *testing.T) {
+	roots := []string{runtime.GOROOT()}
+	if configured := os.Getenv("PLAN9ASM_ENCODER_RULE_SOURCE_ROOTS"); configured != "" {
+		if err := json.Unmarshal([]byte(configured), &roots); err != nil || len(roots) == 0 || len(roots) > 16 {
+			t.Fatal("invalid bounded SDK-source query", err)
+		}
+	}
+	data, err := os.ReadFile("../../testdata/coverage/go-asm-baseline.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var baseline struct {
+		Versions map[string]map[string]encodingRuleBaselineEntry `json:"versions"`
+	}
+	if err := json.Unmarshal(data, &baseline); err != nil {
+		t.Fatal(err)
+	}
+	for _, root := range roots {
+		version := regexp.MustCompile(`^go[0-9]+\.[0-9]+`).FindString(goVersion(root))
+		if baseline.Versions[version] == nil {
+			t.Fatal("SDK has no versioned table baseline", version)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(version+"/"+arch, func(t *testing.T) {
+				catalog, err := loadEncoderForms(root, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var report report
+				attachEncoderCatalog(&report, nil, catalog)
+				want := baseline.Versions[version][arch]
+				// An attribute update may not bless a changed old class surface.
+				if report.EncoderForms != want.EncoderForms || report.EncoderFingerprint != want.EncoderFingerprint {
+					t.Fatalf("unreviewed historical class inventory change: forms=%d/%d fingerprint=%s/%s",
+						report.EncoderForms, want.EncoderForms, report.EncoderFingerprint, want.EncoderFingerprint)
+				}
+				source, err := os.ReadFile(filepath.Join(root, "src/cmd/internal/obj/x86/avx_optabs.go"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Logf("ENCODER_RULE_TABLE_ONLY version=%s arch=%s rules=%d fingerprint=%s source_sha=%x",
+					version, arch, report.EncoderRules, report.EncoderRuleFingerprint, sha256.Sum256(source))
+				if report.EncoderRules <= 0 || report.EncoderRules != want.EncoderRules ||
+					report.EncoderRuleFingerprint != want.EncoderRuleFingerprint {
+					t.Fatalf("AVX source-rule inventory differs from baseline: rules=%d/%d fingerprint=%s/%s",
+						report.EncoderRules, want.EncoderRules, report.EncoderRuleFingerprint, want.EncoderRuleFingerprint)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/cpu_query_context_test.go b/cmd/plan9asmscan/cpu_query_context_test.go
new file mode 100644
index 000000000..6ff70747a
--- /dev/null
+++ b/cmd/plan9asmscan/cpu_query_context_test.go
@@ -0,0 +1,49 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestCPUQueryCoverageRequiresImplicitInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []string{"CPUID", "XGETBV"} {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				for _, row := range []struct {
+					setup    string
+					rootLeaf bool
+				}{
+					{"", false},
+					{"MOVL $0,AX\n", true},
+					{"MOVL $0,AX\nMOVB $0,CL\n", true},
+					{"MOVL $0x80000000,AX\n", true},
+					{"MOVL $1,AX\n", false},
+					{"MOVL $7,AX\n", false},
+					{"MOVL $7,AX\nMOVB $0,CL\n", false},
+				} {
+					if opcode != "CPUID" || !row.rootLeaf {
+						valueProbeNeedsContext(t, arch, row.setup+opcode)
+						continue
+					}
+					err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, row.setup+opcode))
+					state := &formStat{}
+					classifyFormProbe(state, err)
+					if err != nil || state.SupportedCount != 1 || state.ContextCount != 0 || state.UnsupportedCount != 0 {
+						t.Error("maximum CPUID leaf incorrectly requires an incoming ECX selector", err, state)
+					}
+				}
+				setup := "MOVL $0,CX\n"
+				if opcode == "CPUID" {
+					valueProbeNeedsContext(t, arch, setup+opcode)
+					setup += "MOVL $0,AX\n"
+				}
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, setup+opcode)); err != nil {
+					t.Error("complete low-dword query inputs lost their supported sequence", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/divide_context_test.go b/cmd/plan9asmscan/divide_context_test.go
new file mode 100644
index 000000000..2ee688994
--- /dev/null
+++ b/cmd/plan9asmscan/divide_context_test.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestImplicitDivideCoverageRetainsAllInputsAndNativeFaults(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"DIVB", "DIVW", "DIVL", "DIVQ", "IDIVB", "IDIVW", "IDIVL", "IDIVQ"} {
+			if arch == "386" && (op == "DIVQ" || op == "IDIVQ") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, op+" BX")
+				valueProbeNeedsContext(t, arch, "MOVL $7,AX\nMOVL $3,BX\n"+op+" (SI)")
+				valueProbeNeedsContext(t, arch, "MOVL $3,BX\n"+op+" BX")
+				prefix := "MOVL $7,AX\nMOVL $0,DX\nMOVL $3,BX\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, prefix+op+" BX")); err != nil {
+					t.Fatal("fully initialized named register division lost its actual native opcode", err)
+				}
+				if op == "DIVB" || op == "IDIVB" {
+					valueProbeNeedsContext(t, arch, "MOVB $7,AL\nMOVB $3,BL\n"+op+" BL")
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/duplicate_move_context_test.go b/cmd/plan9asmscan/duplicate_move_context_test.go
new file mode 100644
index 000000000..a3c9984f2
--- /dev/null
+++ b/cmd/plan9asmscan/duplicate_move_context_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestDuplicateMoveCoverageRetainsDataMaskAndMergeInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVDDUP", "MOVSHDUP", "MOVSLDUP", "VMOVDDUP", "VMOVSHDUP", "VMOVSLDUP"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				vector := strings.HasPrefix(op, "V")
+				if !vector && bank != "X" {
+					continue
+				}
+				t.Run(arch+"/"+op+"/"+bank, func(t *testing.T) {
+					instruction := op + " " + bank + "0," + bank + "2"
+					valueProbeNeedsContext(t, arch, instruction)
+					initialized := "VPXORQ Z0,Z0,Z0\nVPXORQ Z2,Z2,Z2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, initialized+instruction)); err != nil {
+						t.Fatal("initialized duplicate source disappeared from scanner", err)
+					}
+					valueProbeNeedsContext(t, arch, op+" (SI),"+bank+"2")
+					if vector {
+						masked := op + " " + bank + "0,K1," + bank + "2"
+						valueProbeNeedsContext(t, arch, initialized+masked)
+						valueProbeNeedsContext(t, arch, "VPXORQ Z0,Z0,Z0\nMOVL $1,AX\nKMOVD AX,K1\n"+masked)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/dword_product_context_test.go b/cmd/plan9asmscan/dword_product_context_test.go
new file mode 100644
index 000000000..b8526413e
--- /dev/null
+++ b/cmd/plan9asmscan/dword_product_context_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestDwordProductCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"PMULDQ", "PMULULQ", "VPMULDQ", "VPMULUDQ"} {
+			banks := []string{"X"}
+			if strings.HasPrefix(name, "V") {
+				banks = append(banks, "Y", "Z")
+			}
+			for _, bank := range banks {
+				instruction := name + " " + bank + "0," + bank + "1"
+				if strings.HasPrefix(name, "V") {
+					instruction += "," + bank + "2"
+				}
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					valueProbeNeedsContext(t, arch, instruction)
+					prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+instruction)); err != nil {
+						t.Fatal("complete initialized product sequence rejected", err)
+					}
+					valueProbeNeedsContext(t, arch, strings.Replace(prefix+instruction, "VPXORD Z0,Z0,Z0\n", "", 1))
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/encoder.go b/cmd/plan9asmscan/encoder.go
index 306edc6b9..492a46ea8 100644
--- a/cmd/plan9asmscan/encoder.go
+++ b/cmd/plan9asmscan/encoder.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"crypto/sha256"
 	"fmt"
 	"go/ast"
 	"go/format"
@@ -11,6 +12,8 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
 )
 
 // encoderFormReport is an architecture encoder-table row, expressed with the
@@ -18,11 +21,12 @@ import (
 // rows enumerate the accepted operand-class surface even when no concrete
 // positive test happens to exercise it.
 type encoderFormReport struct {
-	Opcode         string   `json:"opcode"`
-	OperandClasses []string `json:"operand_classes"`
-	Form           string   `json:"form"`
-	Tables         []string `json:"tables"`
-	AliasedFrom    string   `json:"aliased_from,omitempty"`
+	Opcode         string                  `json:"opcode"`
+	OperandClasses []string                `json:"operand_classes"`
+	Form           string                  `json:"form"`
+	Tables         []string                `json:"tables"`
+	AliasedFrom    string                  `json:"aliased_from,omitempty"`
+	EncodingRules  []goasmrules.X86AVXRule `json:"encoding_rules,omitempty"`
 }
 
 type encoderFormSet struct {
@@ -80,6 +84,38 @@ func (s *encoderFormSet) list() []encoderFormReport {
 	return out
 }
 
+// fingerprintEncoderRules complements, rather than changes, the historical
+// operand-class fingerprint. Canonical rows preserve opcode-specific encoding
+// attributes and source row positions even after class-bucket grouping. Keep
+// duplicates: a repeated matching rule is still part of the original table.
+func fingerprintEncoderRules(catalog []encoderFormReport) (int, string) {
+	var rows []string
+	for _, form := range catalog {
+		for _, rule := range form.EncodingRules {
+			var row strings.Builder
+			fmt.Fprintf(&row, "x86-avx %q %q %q %q %d %d %d",
+				rule.Opcode, rule.Ytab, rule.Prefix, rule.ZCase,
+				rule.RowIndex, rule.ZOffset, rule.EncodingOffset)
+			fmt.Fprintf(&row, " classes:%d", len(rule.Classes))
+			for _, class := range rule.Classes {
+				fmt.Fprintf(&row, " %q", class)
+			}
+			fmt.Fprintf(&row, " bytes:%d", len(rule.OpBytes))
+			for _, value := range rule.OpBytes {
+				fmt.Fprintf(&row, " %q", value)
+			}
+			rows = append(rows, row.String())
+		}
+	}
+	if len(rows) == 0 {
+		// No retained rule metadata means unknown, not an empty-table proof.
+		return 0, ""
+	}
+	sort.Strings(rows)
+	data := "go-encoding-rules-v1\n" + strings.Join(rows, "\n")
+	return len(rows), fmt.Sprintf("%x", sha256.Sum256([]byte(data)))
+}
+
 type parsedEncoderFile struct {
 	name string
 	file *ast.File
@@ -126,6 +162,26 @@ func loadEncoderForms(goroot, goarch string) ([]encoderFormReport, error) {
 	switch goarch {
 	case "386", "amd64":
 		scanX86EncoderTables(files, forms)
+		for _, source := range files {
+			if compositeVars(source.file)["avxOptab"] == nil {
+				continue
+			}
+			rules, err := goasmrules.X86AVXRules(source.file)
+			if err != nil {
+				return nil, fmt.Errorf("read complete AVX rules in %s: %w", source.name, err)
+			}
+			for _, rule := range rules {
+				key := rule.Opcode
+				if len(rule.Classes) > 0 {
+					key += " " + strings.Join(rule.Classes, ",")
+				}
+				item := forms.forms[key]
+				if item == nil {
+					return nil, fmt.Errorf("complete AVX rule %s has no operand-class inventory", key)
+				}
+				item.EncodingRules = append(item.EncodingRules, rule)
+			}
+		}
 	case "arm":
 		scanFixedEncoderTable(files, forms, "optab", []string{"from", "reg", "to"})
 		expandEncoderAliases(files, forms, "opset")
diff --git a/cmd/plan9asmscan/encoder_attributes_test.go b/cmd/plan9asmscan/encoder_attributes_test.go
new file mode 100644
index 000000000..5dc0d3ca8
--- /dev/null
+++ b/cmd/plan9asmscan/encoder_attributes_test.go
@@ -0,0 +1,171 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const x86EncoderAttributeFixture = `package x86
+var shared = []ytab{
+	{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}},
+	{zcase: Zevex_rm_v_r, zoffset: 0, args: argList{Yzm, Yzr, Yzr}},
+	{zcase: Zevex_rm_v_k_r, zoffset: 3, args: argList{Yzm, Yzr, Yknot0, Yzr}},
+}
+var avxOptab = [...]Optab{
+	{as: AVPMULLW, ytab: shared, prefix: Pavx, op: opBytes{
+		avxEscape | vex128 | vex66 | vex0F | vexW0, 0xD5,
+		avxEscape | evex512 | evex66 | evex0F | evexW0,
+		evexN64 | evexZeroingEnabled, 0xD5,
+	}},
+}
+`
+
+var x86EncoderAttributeMutations = []struct {
+	name, before, after string
+}{
+	{"width", "evex512", "evex256"},
+	{"broadcast", "evexN64 | evexZeroingEnabled", "evexN64 | evexBcstN4 | evexZeroingEnabled"},
+	{"zeroing", "evexN64 | evexZeroingEnabled", "evexN64"},
+	{"rounding", "evexN64 | evexZeroingEnabled", "evexN64 | evexRoundingEnabled"},
+	{"sae", "evexN64 | evexZeroingEnabled", "evexN64 | evexSaeEnabled"},
+	{"tuple", "evexN64", "evexN32"},
+	{"w", "evexW0", "evexW1"},
+	{"opcode", "0xD5", "0xE5"},
+	{"prefix", "prefix: Pavx", "prefix: Pq4"},
+	{"zcase", "zcase: Zevex_rm_v_r", "zcase: Zevex_r_v_rm"},
+	{"offset", "zoffset: 2", "zoffset: 3"},
+}
+
+func loadX86EncoderAttributeFixture(t *testing.T, source string) []encoderFormReport {
+	t.Helper()
+	root := t.TempDir()
+	path := filepath.Join(root, "src", "cmd", "internal", "obj", "x86", "avx_optabs.go")
+	writeEncoderFixture(t, path, source)
+	forms, err := loadEncoderForms(root, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(forms) != 3 {
+		t.Fatalf("operand-class denominator changed: %d", len(forms))
+	}
+	return forms
+}
+
+func TestX86EncoderCatalogRetainsEncodingRulesBeyondOperandClasses(t *testing.T) {
+	const source = x86EncoderAttributeFixture
+	before := loadX86EncoderAttributeFixture(t, source)
+	beforeJSON, err := json.Marshal(before)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range x86EncoderAttributeMutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			if !strings.Contains(source, mutation.before) {
+				t.Fatal("mutation must change an original encoding rule")
+			}
+			after := loadX86EncoderAttributeFixture(t, strings.Replace(source, mutation.before, mutation.after, 1))
+			for i := range before {
+				if before[i].Form != after[i].Form {
+					t.Fatal("this regression must retain identical operand classes")
+				}
+			}
+			afterJSON, err := json.Marshal(after)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if bytes.Equal(beforeJSON, afterJSON) {
+				t.Fatal("encoder catalog discarded an encoding rule despite identical operand classes")
+			}
+		})
+	}
+}
+
+func TestX86EncoderEncodingFingerprintRetainsRuleAttributes(t *testing.T) {
+	read := func(source string) (report, string) {
+		var rep report
+		attachEncoderCatalog(&rep, nil, loadX86EncoderAttributeFixture(t, source))
+		data, err := json.Marshal(rep)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var fields map[string]json.RawMessage
+		if err := json.Unmarshal(data, &fields); err != nil {
+			t.Fatal(err)
+		}
+		var fingerprint string
+		if raw := fields["encoder_rule_fingerprint"]; raw != nil {
+			if err := json.Unmarshal(raw, &fingerprint); err != nil {
+				t.Fatal(err)
+			}
+		}
+		return rep, fingerprint
+	}
+	before, fingerprint := read(x86EncoderAttributeFixture)
+	for _, mutation := range x86EncoderAttributeMutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			after, changed := read(strings.Replace(x86EncoderAttributeFixture, mutation.before, mutation.after, 1))
+			if before.EncoderFingerprint != after.EncoderFingerprint {
+				t.Fatal("legacy operand-class fingerprint must remain compatible")
+			}
+			if changed == "" || fingerprint == changed {
+				t.Fatal("rule fingerprint omitted an independent encoding attribute")
+			}
+		})
+	}
+}
+
+func TestX86EncoderCatalogRetainsZeroOffsetRuleOrderAcrossClassBuckets(t *testing.T) {
+	// Zero-offset rows share opcode bytes; their order must survive class
+	// grouping. This is a source-inventory fixture, not accepted Go machine code.
+	source := strings.Replace(x86EncoderAttributeFixture, "zoffset: 2", "zoffset: 0", 1)
+	source = strings.Replace(source, "zoffset: 3", "zoffset: 0", 1)
+	rows := strings.Split(source, "\n")
+	if !strings.Contains(rows[2], "Zvex_rm_v_r") || !strings.Contains(rows[3], "Zevex_rm_v_r") {
+		t.Fatal("independent source fixture layout changed")
+	}
+	rows[2], rows[3] = rows[3], rows[2]
+	before, err := json.Marshal(loadX86EncoderAttributeFixture(t, source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	after, err := json.Marshal(loadX86EncoderAttributeFixture(t, strings.Join(rows, "\n")))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytes.Equal(before, after) {
+		t.Fatal("catalog discarded rule ordering when every encoding offset stayed equal")
+	}
+}
+
+func TestX86EncoderRuleFingerprintCountsAndScopeAreIndependent(t *testing.T) {
+	catalog := loadX86EncoderAttributeFixture(t, x86EncoderAttributeFixture)
+	count, fingerprint := fingerprintEncoderRules(catalog)
+	if count != 3 || len(fingerprint) != 64 {
+		t.Fatalf("retained source rows have no complete fingerprint: %d/%q", count, fingerprint)
+	}
+	// Presentation order and observed corpus hits are not encoding changes.
+	catalog[0], catalog[2] = catalog[2], catalog[0]
+	catalog[0].Tables = []string{"presentation-only"}
+	rep := report{SupportedForms: 17, ContextForms: 4}
+	attachEncoderCatalog(&rep, map[string]*opStat{"VPMULLW": {}}, catalog)
+	if rep.EncoderRules != count || rep.EncoderRuleFingerprint != fingerprint ||
+		rep.SupportedForms != 17 || rep.ContextForms != 4 {
+		t.Fatal("encoding inventory depends on observation or changed tested coverage")
+	}
+	// Repeated rows must not be deduplicated away, and absent metadata is not
+	// a certificate of an empty or completely implemented official table.
+	catalog = append(catalog, catalog[0])
+	duplicateCount, duplicateFingerprint := fingerprintEncoderRules(catalog)
+	if duplicateCount <= count || duplicateFingerprint == fingerprint {
+		t.Fatal("duplicate source rows disappeared from the fingerprint")
+	}
+	for i := range catalog {
+		catalog[i].EncodingRules = nil
+	}
+	if count, fingerprint := fingerprintEncoderRules(catalog); count != 0 || fingerprint != "" {
+		t.Fatal("unretained tables fabricated a rule certificate")
+	}
+}
diff --git a/cmd/plan9asmscan/encoder_legacy.go b/cmd/plan9asmscan/encoder_legacy.go
new file mode 100644
index 000000000..a184ae846
--- /dev/null
+++ b/cmd/plan9asmscan/encoder_legacy.go
@@ -0,0 +1,54 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// legacyEncoderReport inventories declaration rows, not their applicability in
+// a particular x86 mode or successful translation. Keep it independent of the
+// historical operand-class buckets and AVX rule fingerprints.
+type legacyEncoderReport struct {
+	OperandRows    int                         `json:"operand_rows"`
+	MoveRows       int                         `json:"move_rows"`
+	SpecialEntries int                         `json:"special_entries"`
+	Fingerprint    string                      `json:"table_row_fingerprint"`
+	Catalog        goasmrules.X86LegacyCatalog `json:"catalog"`
+}
+
+func attachLegacyEncoderCatalog(rep *report, goroot string) error {
+	if rep.Corpus != "go-asm" || (rep.Goarch != "amd64" && rep.Goarch != "386") {
+		return nil
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(goroot)
+	if err != nil {
+		return err
+	}
+	legacy := &legacyEncoderReport{Catalog: catalog}
+	for _, entry := range catalog.Optab {
+		legacy.OperandRows += len(entry.Rows)
+		if entry.Kind == "special" {
+			legacy.SpecialEntries++
+		}
+	}
+	for _, entry := range catalog.Movtab {
+		if entry.Kind == "encoding" {
+			legacy.MoveRows++
+		}
+	}
+	data, err := json.Marshal(catalog)
+	if err != nil {
+		return fmt.Errorf("marshal legacy table rows: %w", err)
+	}
+	// This hashes normalized table rows, including symbolic attributes. It is
+	// not a fingerprint of constant definitions or the entire Go assembler's
+	// row-selection, mode filtering and encoding semantics.
+	digest := sha256.Sum256(append([]byte("go-x86-legacy-table-rows-v1\n"), data...))
+	legacy.Fingerprint = hex.EncodeToString(digest[:])
+	rep.LegacyEncoder = legacy
+	return nil
+}
diff --git a/cmd/plan9asmscan/encoder_legacy_test.go b/cmd/plan9asmscan/encoder_legacy_test.go
new file mode 100644
index 000000000..5ea753453
--- /dev/null
+++ b/cmd/plan9asmscan/encoder_legacy_test.go
@@ -0,0 +1,158 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const legacyEncoderReportFixture = `package x86
+type opBytes [31]uint8
+var operands = []ytab{
+    {Zm_r, 0, argList{Yml, Yrl}},
+    {Zm_r, 2, argList{Yml, Yrl}},
+}
+var optab = [...]Optab{
+    {obj.AXXX, nil, 0, opBytes{}},
+    {ATEST, operands, Px, opBytes{0x0f, 0x20, 0x30}},
+    {AENTER, nil, 0, opBytes{}},
+    {0, nil, 0, opBytes{}},
+}
+var ymovtab = []movtab{
+    {AMOVW, Yml, Ynone, Ytask, movMemReg2op, [4]uint8{0x0f, 0, 3, 0}},
+    {0, 0, 0, 0, 0, [4]uint8{}},
+}
+`
+
+func TestLegacyEncoderReportRetainsRulesWithoutGrantingCoverage(t *testing.T) {
+	root := t.TempDir()
+	writeEncoderFixture(t, filepath.Join(root, "src/cmd/internal/obj/x86/asm6.go"), legacyEncoderReportFixture)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rep := report{Corpus: "go-asm", Goarch: arch, SupportedForms: 7, ContextForms: 11,
+				EncoderRules: 13, EncoderRuleFingerprint: "existing-avx", EncoderFingerprint: "existing-classes"}
+			before := rep
+			if err := attachLegacyEncoderCatalog(&rep, root); err != nil {
+				t.Fatal(err)
+			}
+			legacy := rep.LegacyEncoder
+			if legacy == nil || legacy.OperandRows != 2 || legacy.MoveRows != 1 || legacy.SpecialEntries != 1 ||
+				len(legacy.Catalog.Optab) != 4 || len(legacy.Catalog.Movtab) != 2 || len(legacy.Fingerprint) != 64 {
+				t.Fatalf("complete source inventory was lost: %+v", legacy)
+			}
+			data, err := json.Marshal(rep)
+			if err != nil || !strings.Contains(string(data), `"legacy_encoder"`) ||
+				!strings.Contains(string(data), `"from3":"Ynone"`) ||
+				!strings.Contains(string(data), `"kind":"sentinel"`) {
+				t.Fatalf("JSON omitted original roles or special rows: %v", err)
+			}
+			if text := string(renderMarkdown(rep)); !strings.Contains(text, "legacy encoding inventory") ||
+				!strings.Contains(text, "not translation or execution evidence") {
+				t.Fatal("Markdown failed to separate inventory and tested coverage")
+			}
+			rep.LegacyEncoder = nil
+			if !reflect.DeepEqual(rep, before) {
+				t.Fatal("legacy inventory changed an existing denominator or granted tested coverage")
+			}
+		})
+	}
+}
+
+func TestLegacyEncoderReportFingerprintKeepsRetainedRowAttributes(t *testing.T) {
+	root := t.TempDir()
+	path := filepath.Join(root, "src/cmd/internal/obj/x86/asm6.go")
+	read := func(source string) string {
+		writeEncoderFixture(t, path, source)
+		rep := report{Corpus: "go-asm", Goarch: "amd64"}
+		if err := attachLegacyEncoderCatalog(&rep, root); err != nil {
+			t.Fatal(err)
+		}
+		return rep.LegacyEncoder.Fingerprint
+	}
+	before := read(legacyEncoderReportFixture)
+	for _, change := range []struct{ old, new string }{
+		{"0x30", "0x31"}, {"operands, Px", "operands, P32"},
+		{"Zm_r, 0", "Zr_m, 0"}, {"Zm_r, 0", "Zm_r, 1"},
+		{"Yml, Yrl", "Yxm, Yxr"}, {"Yml, Ynone, Ytask", "Yml, Yrl, Ytask"},
+		{"movMemReg2op", "movRegMem2op"}, {"[31]uint8", "[32]uint8"},
+	} {
+		if got := read(strings.Replace(legacyEncoderReportFixture, change.old, change.new, 1)); got == before {
+			t.Fatalf("fingerprint discarded %s", change.old)
+		}
+	}
+	if got := read("// comment does not alter encoding\n" + legacyEncoderReportFixture); got != before {
+		t.Fatal("comment changed normalized encoding fingerprint")
+	}
+	// The row hash preserves the symbolic Px reference, not its definition.
+	// Do not let a consumer mistake it for whole-assembler semantic identity.
+	for _, definition := range []string{"const Px = 1\n", "const Px = 2\n"} {
+		if got := read(legacyEncoderReportFixture + definition); got != before {
+			t.Fatal("table-row fingerprint unexpectedly depends on external constant definitions")
+		}
+	}
+}
+
+func TestLegacyEncoderReportMissingSourcesFailAndOtherArchitecturesStayIndependent(t *testing.T) {
+	root := t.TempDir()
+	for _, rep := range []report{
+		{Corpus: "go-asm", Goarch: "amd64"}, {Corpus: "go-asm", Goarch: "386"},
+	} {
+		if err := attachLegacyEncoderCatalog(&rep, root); err == nil || rep.LegacyEncoder != nil {
+			t.Fatal("missing official source was silently reported as an empty complete inventory")
+		}
+	}
+	for _, rep := range []report{
+		{Corpus: "std", Goarch: "amd64"}, {Corpus: "go-asm", Goarch: "arm"},
+		{Corpus: "go-asm", Goarch: "arm64"}, {Corpus: "go-asm", Goarch: "wasm"},
+	} {
+		if err := attachLegacyEncoderCatalog(&rep, root); err != nil || rep.LegacyEncoder != nil {
+			t.Fatal("unrelated corpus acquired x86 source requirements", err)
+		}
+	}
+}
+
+func TestLegacyEncoderReportActualSelectedSDK(t *testing.T) {
+	rep := report{Corpus: "go-asm", Goarch: "amd64"}
+	if err := attachLegacyEncoderCatalog(&rep, runtime.GOROOT()); err != nil {
+		t.Fatal(err)
+	}
+	legacy := rep.LegacyEncoder
+	if legacy == nil || legacy.OperandRows < 1000 || legacy.MoveRows < 100 || legacy.SpecialEntries == 0 {
+		t.Fatalf("actual complete tables missing: %+v", legacy)
+	}
+	t.Logf("legacy inventory: %d operand rows, %d special entries, %d move rows; not translated coverage",
+		legacy.OperandRows, legacy.SpecialEntries, legacy.MoveRows)
+}
+
+func TestLegacyEncoderReportCLIOutput(t *testing.T) {
+	oldArgs, oldFlags := os.Args, flag.CommandLine
+	defer func() {
+		os.Args, flag.CommandLine = oldArgs, oldFlags
+	}()
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "report.json")
+			flag.CommandLine = flag.NewFlagSet("plan9asmscan", flag.ContinueOnError)
+			os.Args = []string{"plan9asmscan", "-corpus=go-asm", "-goos=linux",
+				"-goarch=" + arch, "-format=json", "-repo-root=../..", "-out=" + path}
+			main()
+			data, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var rep report
+			if err := json.Unmarshal(data, &rep); err != nil {
+				t.Fatal(err)
+			}
+			if rep.Goarch != arch || rep.LegacyEncoder == nil || rep.LegacyEncoder.OperandRows < 1000 ||
+				rep.EncoderRules == 0 || rep.EncoderRuleFingerprint == "" {
+				t.Fatal("official CLI output lost its independent legacy or AVX rule inventory")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmscan/evidence_levels_test.go b/cmd/plan9asmscan/evidence_levels_test.go
new file mode 100644
index 000000000..01ce7610c
--- /dev/null
+++ b/cmd/plan9asmscan/evidence_levels_test.go
@@ -0,0 +1,57 @@
+package main
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestReportSeparatesProbeFromObjectAndExecutionEvidence(t *testing.T) {
+	for _, contextual := range []bool{false, true} {
+		form := &formStat{Descriptor: plan9asm.InstructionDescriptor{
+			Arch: plan9asm.ArchAMD64, Goarch: "amd64", Opcode: "MOVQ",
+			Family: "move", Form: "MOVQ immediate,gpr64",
+		}, SupportedCount: 1}
+		if contextual {
+			form.SupportedCount, form.ContextCount = 0, 1
+		}
+		// A manifest entry declares a test association, not a fresh execution.
+		manifest := map[string]struct{}{"amd64\x00MOVQ immediate,gpr64": {}}
+		rep := buildReport("go-asm", "go1.test", "linux", "amd64", 0, 0, 1,
+			nil, map[string]*formStat{"mov": form}, nil, nil, manifest, manifest, nil)
+		data, err := json.Marshal(rep)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var decoded struct {
+			Evidence map[string]struct {
+				Status string `json:"status"`
+				Forms  *int   `json:"forms"`
+			} `json:"evidence_levels"`
+		}
+		if err := json.Unmarshal(data, &decoded); err != nil {
+			t.Fatal(err)
+		}
+		ir := decoded.Evidence["ir_text_generation"]
+		if ir.Status != "probe" || ir.Forms == nil || *ir.Forms != rep.SupportedForms {
+			t.Errorf("IR evidence must count accepted probes only: %+v", ir)
+		}
+		for _, stage := range []string{"llvm_object_compilation", "runtime_execution"} {
+			got, present := decoded.Evidence[stage]
+			if !present || got.Status != "not_run" || got.Forms != nil {
+				t.Errorf("manifest/classification promoted to %s evidence: %+v", stage, got)
+			}
+		}
+		markdown := string(renderMarkdown(rep))
+		for _, want := range []string{
+			"IR text generation", "LLVM 22 object compilation", "Runtime execution",
+			"not run by this scanner", "manifest-registered", "Context is not successful translation",
+		} {
+			if !strings.Contains(markdown, want) {
+				t.Errorf("missing evidence boundary %q", want)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/explicit_mask_move_context_test.go b/cmd/plan9asmscan/explicit_mask_move_context_test.go
new file mode 100644
index 000000000..68486997a
--- /dev/null
+++ b/cmd/plan9asmscan/explicit_mask_move_context_test.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestExplicitMaskMoveCoverageKeepsNativeInputsAndMemoryContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ"} {
+			for _, bank := range []string{"X", "Y"} {
+				for _, row := range []string{
+					fmt.Sprintf("%s (AX),%s1,%s0", op, bank, bank),
+					fmt.Sprintf("%s %s0,%s1,(AX)", op, bank, bank),
+				} {
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						valueProbeNeedsContext(t, arch, row)
+						// Even explicit numerical data/sign bytes and a zero
+						// address are not an incoming native pointer or backing.
+						valueProbeNeedsContext(t, arch,
+							"VXORPS X0,X0,X0\nVXORPS X1,X1,X1\nMOVL $0,AX\n"+row)
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/float_broadcast_context_test.go b/cmd/plan9asmscan/float_broadcast_context_test.go
new file mode 100644
index 000000000..094e08812
--- /dev/null
+++ b/cmd/plan9asmscan/float_broadcast_context_test.go
@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestFloatingCompareCoverageNeedsActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range strings.Fields("CMPPS CMPPD CMPSS CMPSD VCMPPS VCMPPD VCMPSS VCMPSD") {
+			if arch == "386" && strings.HasPrefix(op, "V") {
+				continue // Named V comparisons are absent from Go's 386 frontend.
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				row := op + " X0,X1,$0"
+				if strings.HasPrefix(op, "V") {
+					row = op + " $255,X0,X1,X2"
+				}
+				valueProbeNeedsContext(t, arch, row)
+				prefix := "PXOR X0,X0\nPXOR X1,X1\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+row)); err != nil {
+					t.Fatal("initialized comparison lost its complete input grammar", err)
+				}
+			})
+		}
+	}
+}
+
+func TestBroadcastCoverageNeedsActualInputs(t *testing.T) {
+	// Independent complete family, not the translator's instruction map.
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range strings.Fields("VPBROADCASTB VPBROADCASTW VPBROADCASTD VPBROADCASTQ " +
+			"VBROADCASTSS VBROADCASTSD VBROADCASTF128 VBROADCASTI128 " +
+			"VBROADCASTF32X2 VBROADCASTI32X2 VBROADCASTF32X4 VBROADCASTF64X2 " +
+			"VBROADCASTI32X4 VBROADCASTI64X2 VBROADCASTF32X8 VBROADCASTF64X4 " +
+			"VBROADCASTI32X8 VBROADCASTI64X4 VPBROADCASTMB2Q VPBROADCASTMW2D") {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				input, bank, prefix := "(AX)", "Z", ""
+				switch op {
+				case "VPBROADCASTMB2Q", "VPBROADCASTMW2D":
+					input, prefix = "K0", "MOVL $7,AX\nKMOVD AX,K0\n"
+				case "VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ",
+					"VBROADCASTSS", "VBROADCASTSD", "VBROADCASTF32X2", "VBROADCASTI32X2":
+					input, prefix = "X1", "PXOR X1,X1\n"
+				case "VBROADCASTF128", "VBROADCASTI128":
+					bank = "Y"
+				}
+				row := fmt.Sprintf("%s %s,%s2", op, input, bank)
+				valueProbeNeedsContext(t, arch, row)
+				if prefix != "" {
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+row)); err != nil {
+						t.Fatal("initialized register broadcast became unsupported", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/frontend_inventory.go b/cmd/plan9asmscan/frontend_inventory.go
new file mode 100644
index 000000000..ccd01f2fa
--- /dev/null
+++ b/cmd/plan9asmscan/frontend_inventory.go
@@ -0,0 +1,873 @@
+package main
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// This inventory describes source registration, not operand legality, lowering,
+// LLVM compilation, linking or runtime proof. Sentinels remain explicit entries.
+type frontendInventory struct {
+	SchemaVersion int                   `json:"schema_version"`
+	Scope         string                `json:"scope"`
+	Entries       []frontendName        `json:"entries"`
+	Sources       []frontendSourceProof `json:"sources"`
+}
+
+type frontendName struct {
+	Spelling           string           `json:"spelling"`
+	AsID               *int64           `json:"as_id"`
+	Canonical          string           `json:"canonical"`
+	CanonicalNamespace string           `json:"canonical_namespace"`
+	Sentinel           bool             `json:"sentinel"`
+	Origins            []frontendOrigin `json:"origins"`
+}
+
+type frontendOrigin struct {
+	Role   string `json:"role"`
+	Source string `json:"source"`
+	Line   int    `json:"line"`
+}
+
+type frontendSourceProof struct {
+	Source string `json:"source"`
+	SHA256 string `json:"sha256"`
+}
+
+type frontendConst struct {
+	Expr      ast.Expr
+	Namespace string
+	Iota      int64
+}
+
+type frontendReader struct {
+	Root      string
+	Fset      *token.FileSet
+	Files     map[string]*ast.File
+	Proofs    map[string]string
+	Constants map[string]frontendConst
+	Resolving map[string]bool
+}
+
+func (r *frontendReader) read(relative string, namespace string) (*ast.File, error) {
+	if file := r.Files[relative]; file != nil {
+		return file, nil
+	}
+	data, err := os.ReadFile(filepath.Join(r.Root, filepath.FromSlash(relative)))
+	if err != nil {
+		return nil, err
+	}
+	file, err := parser.ParseFile(r.Fset, relative, data, 0)
+	if err != nil {
+		return nil, err
+	}
+	expectedPackage := namespace
+	if namespace == "asm" {
+		expectedPackage = "arch"
+	} else if namespace == "asmparser" {
+		expectedPackage = "asm"
+	}
+	if file.Name.Name != expectedPackage {
+		return nil, fmt.Errorf("unexpected source package %s in %s", file.Name.Name, relative)
+	}
+	for _, imported := range file.Imports {
+		path, err := strconv.Unquote(imported.Path.Value)
+		if err != nil {
+			return nil, err
+		}
+		name := filepath.Base(path)
+		if imported.Name != nil {
+			name = imported.Name.Name
+		}
+		if name == "obj" || name == "x86" || name == "arm" || name == "arm64" || name == "wasm" {
+			expectedPath := "cmd/internal/obj"
+			if name != "obj" {
+				expectedPath += "/" + name
+			}
+			if path != expectedPath {
+				return nil, fmt.Errorf("opcode namespace %s has unexpected import %s", name, path)
+			}
+		}
+	}
+	r.Files[relative] = file
+	r.Proofs[relative] = fmt.Sprintf("%x", sha256.Sum256(data))
+	for _, decl := range file.Decls {
+		group, ok := decl.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST {
+			continue
+		}
+		var previous []ast.Expr
+		for index, spec := range group.Specs {
+			value := spec.(*ast.ValueSpec)
+			if len(value.Values) != 0 {
+				previous = value.Values
+			}
+			for n, name := range value.Names {
+				if name.Name == "_" {
+					continue
+				}
+				if n >= len(previous) {
+					return nil, fmt.Errorf("unsupported constant declaration %s:%s", relative, name.Name)
+				}
+				key := namespace + "." + name.Name
+				if _, duplicate := r.Constants[key]; duplicate {
+					return nil, fmt.Errorf("duplicate constant %s", key)
+				}
+				r.Constants[key] = frontendConst{previous[n], namespace, int64(index)}
+			}
+		}
+	}
+	return file, nil
+}
+
+func (r *frontendReader) integer(expr ast.Expr, namespace string, iotaValue int64) (int64, error) {
+	value, err := r.eval(expr, namespace, iotaValue)
+	if err != nil {
+		return 0, err
+	}
+	number, ok := constant.Int64Val(constant.ToInt(value))
+	if !ok {
+		return 0, fmt.Errorf("constant %s is not an int64", exprText(expr))
+	}
+	return number, nil
+}
+
+func (r *frontendReader) eval(expr ast.Expr, namespace string, iotaValue int64) (constant.Value, error) {
+	var key string
+	switch value := expr.(type) {
+	case *ast.BasicLit:
+		if value.Kind != token.INT {
+			break
+		}
+		parsed := constant.MakeFromLiteral(value.Value, token.INT, 0)
+		if parsed.Kind() != constant.Unknown {
+			return parsed, nil
+		}
+	case *ast.Ident:
+		if value.Name == "iota" {
+			return constant.MakeInt64(iotaValue), nil
+		}
+		if value.Obj != nil && value.Obj.Kind != ast.Con {
+			break
+		}
+		key = namespace + "." + value.Name
+	case *ast.SelectorExpr:
+		if base, ok := value.X.(*ast.Ident); ok && (base.Obj == nil || base.Obj.Kind == ast.Pkg) {
+			key = base.Name + "." + value.Sel.Name
+		}
+	case *ast.ParenExpr:
+		return r.eval(value.X, namespace, iotaValue)
+	case *ast.UnaryExpr:
+		operand, err := r.eval(value.X, namespace, iotaValue)
+		if err != nil {
+			return nil, err
+		}
+		if value.Op == token.ADD || value.Op == token.SUB || value.Op == token.XOR {
+			return constant.UnaryOp(value.Op, operand, 0), nil
+		}
+	case *ast.BinaryExpr:
+		left, err := r.eval(value.X, namespace, iotaValue)
+		if err != nil {
+			return nil, err
+		}
+		right, err := r.eval(value.Y, namespace, iotaValue)
+		if err != nil {
+			return nil, err
+		}
+		if value.Op == token.SHL || value.Op == token.SHR {
+			shift, ok := constant.Uint64Val(right)
+			if !ok || shift > 63 {
+				return nil, fmt.Errorf("invalid constant shift %s", exprText(expr))
+			}
+			return constant.Shift(left, value.Op, uint(shift)), nil
+		}
+		switch value.Op {
+		case token.ADD, token.SUB, token.MUL, token.AND, token.OR, token.XOR, token.AND_NOT:
+			return constant.BinaryOp(left, value.Op, right), nil
+		}
+	}
+	if key != "" {
+		definition, ok := r.Constants[key]
+		if !ok || r.Resolving[key] {
+			return nil, fmt.Errorf("unknown/cyclic opcode constant %s", key)
+		}
+		r.Resolving[key] = true
+		defer delete(r.Resolving, key)
+		return r.eval(definition.Expr, definition.Namespace, definition.Iota)
+	}
+	return nil, fmt.Errorf("unsupported opcode constant expression %s", exprText(expr))
+}
+
+type frontendTableEntry struct {
+	Name     string
+	Position token.Pos
+}
+
+func (r *frontendReader) table(file *ast.File, name, namespace string) ([]frontendTableEntry, bool, error) {
+	var result []frontendTableEntry
+	found := false
+	for _, decl := range file.Decls {
+		group, ok := decl.(*ast.GenDecl)
+		if !ok || group.Tok != token.VAR {
+			continue
+		}
+		for _, spec := range group.Specs {
+			value := spec.(*ast.ValueSpec)
+			for n, ident := range value.Names {
+				if ident.Name != name {
+					continue
+				}
+				if found || n >= len(value.Values) {
+					return nil, false, fmt.Errorf("duplicate/missing initializer for %s", name)
+				}
+				found = true
+				literal, ok := value.Values[n].(*ast.CompositeLit)
+				if !ok {
+					return nil, false, fmt.Errorf("%s is not a literal array", name)
+				}
+				if _, err := opcodeStringArray(literal); err != nil {
+					return nil, false, err
+				}
+				next := int64(0)
+				for _, element := range literal.Elts {
+					if keyed, ok := element.(*ast.KeyValueExpr); ok {
+						var err error
+						next, err = r.integer(keyed.Key, namespace, 0)
+						if err != nil {
+							return nil, false, err
+						}
+						element = keyed.Value
+					}
+					if next < 0 || next > 32767 {
+						return nil, false, fmt.Errorf("invalid %s array index %d", name, next)
+					}
+					for int64(len(result)) <= next {
+						result = append(result, frontendTableEntry{})
+					}
+					if result[next].Position.IsValid() {
+						return nil, false, fmt.Errorf("duplicate %s array index %d", name, next)
+					}
+					text := element.(*ast.BasicLit)
+					spelling, err := strconv.Unquote(text.Value)
+					if err != nil {
+						return nil, false, err
+					}
+					result[next] = frontendTableEntry{spelling, text.Pos()}
+					next++
+				}
+			}
+		}
+	}
+	return result, found, nil
+}
+
+func frontendSentinel(spelling string) bool {
+	upper := strings.ToUpper(spelling)
+	return upper == "XXX" || upper == "LAST" || upper == "SVESTART" || strings.HasPrefix(upper, "RESERVED")
+}
+
+func (r *frontendReader) origin(role string, position token.Pos) frontendOrigin {
+	location := r.Fset.Position(position)
+	return frontendOrigin{role, filepath.ToSlash(location.Filename), location.Line}
+}
+
+func frontendNodeText(node ast.Node) string {
+	var text strings.Builder
+	if err := printer.Fprint(&text, token.NewFileSet(), node); err != nil {
+		return ""
+	}
+	return strings.Join(strings.Fields(text.String()), " ")
+}
+
+func loadFrontendInventory(goroot, goarch string) (*frontendInventory, error) {
+	dir, base, constructor := goarch, "ARM", "archArm"
+	switch goarch {
+	case "386", "amd64":
+		dir, base, constructor = "x86", "AMD64", "archX86"
+	case "arm":
+	case "arm64":
+		base, constructor = "ARM64", "archArm64"
+	case "wasm":
+		base, constructor = "Wasm", "archWasm"
+	default:
+		return nil, fmt.Errorf("unsupported frontend architecture %q", goarch)
+	}
+	r := &frontendReader{
+		Root:      goroot,
+		Fset:      token.NewFileSet(),
+		Files:     map[string]*ast.File{},
+		Proofs:    map[string]string{},
+		Constants: map[string]frontendConst{},
+		Resolving: map[string]bool{},
+	}
+	enumFile := "a.out.go"
+	if dir == "x86" {
+		enumFile = "aenum.go"
+	}
+	sources := []struct{ path, namespace string }{
+		{"src/cmd/internal/obj/link.go", "obj"},
+		{"src/cmd/internal/obj/" + dir + "/" + enumFile, dir},
+		{"src/cmd/asm/internal/arch/arch.go", "asm"},
+	}
+	for _, source := range sources {
+		if _, err := r.read(source.path, source.namespace); err != nil {
+			return nil, err
+		}
+	}
+	if goarch == "arm" {
+		if _, err := r.read("src/cmd/asm/internal/arch/arm.go", "asm"); err != nil {
+			return nil, err
+		}
+	}
+	commonFile, err := r.read("src/cmd/internal/obj/util.go", "obj")
+	if err != nil {
+		return nil, err
+	}
+	common, found, err := r.table(commonFile, "Anames", "obj")
+	if err != nil || !found || len(common) == 0 {
+		return nil, fmt.Errorf("missing/invalid obj.Anames: %v", err)
+	}
+	minimum, err := r.integer(&ast.Ident{Name: "A_ARCHSPECIFIC"}, "obj", 0)
+	if err != nil {
+		return nil, err
+	}
+	archBase, err := r.integer(&ast.Ident{Name: "ABase" + base}, "obj", 0)
+	if err != nil {
+		return nil, err
+	}
+	paths, err := filepath.Glob(filepath.Join(goroot, "src/cmd/internal/obj", dir, "anames*.go"))
+	if err != nil {
+		return nil, err
+	}
+	var archNames, sveNames []frontendTableEntry
+	baseFound, sveFound, appendCount := false, false, 0
+	for _, path := range paths {
+		relative, err := filepath.Rel(goroot, path)
+		if err != nil {
+			return nil, err
+		}
+		file, err := r.read(filepath.ToSlash(relative), dir)
+		if err != nil {
+			return nil, err
+		}
+		for _, name := range []string{"Anames", "sveAnames"} {
+			if name == "sveAnames" && goarch != "arm64" {
+				continue
+			}
+			table, found, err := r.table(file, name, dir)
+			if err != nil {
+				return nil, err
+			}
+			if !found {
+				continue
+			}
+			if name == "Anames" {
+				if baseFound {
+					return nil, fmt.Errorf("duplicate arch.Anames")
+				}
+				baseFound = true
+				archNames = table
+			} else {
+				if sveFound {
+					return nil, fmt.Errorf("duplicate sveAnames")
+				}
+				sveFound = true
+				sveNames = table
+			}
+		}
+		if goarch == "arm64" && appendsSVEOpcodeNames(file) {
+			appendCount++
+		}
+	}
+	if !baseFound || len(archNames) <= int(minimum) || (sveFound && appendCount != 1) || (!sveFound && appendCount != 0) {
+		return nil, fmt.Errorf("missing/unregistered architecture opcode arrays")
+	}
+	if err := r.verifyArrayUses("src/cmd/internal/obj", "obj", "", false); err != nil {
+		return nil, err
+	}
+	if err := r.verifyArrayUses("src/cmd/internal/obj/"+dir, dir, base, sveFound); err != nil {
+		return nil, err
+	}
+	archNames = append(archNames, sveNames...)
+	entries := map[string]*frontendName{}
+	canonical := map[int64]frontendName{}
+	addTable := func(table []frontendTableEntry, start, offset int64, namespace, role string) error {
+		for index := start; index < int64(len(table)); index++ {
+			item := table[index]
+			if item.Name == "" {
+				return fmt.Errorf("unregistered empty %s namespace slot %d", namespace, index)
+			}
+			id := index + offset
+			if id < 0 || id > 32767 {
+				return fmt.Errorf("obj.As overflow %d", id)
+			}
+			if entries[item.Name] != nil {
+				return fmt.Errorf("duplicate registered spelling %s", item.Name)
+			}
+			entry := &frontendName{Spelling: item.Name, AsID: &id, Canonical: item.Name, CanonicalNamespace: namespace, Sentinel: frontendSentinel(item.Name), Origins: []frontendOrigin{r.origin(role, item.Position)}}
+			if entry.Sentinel {
+				entry.Origins = append(entry.Origins, r.origin("sentinel", item.Position))
+			}
+			entries[item.Name] = entry
+			canonical[id] = *entry
+		}
+		return nil
+	}
+	if err := addTable(common, 0, 0, "obj", "common"); err != nil {
+		return nil, err
+	}
+	if err := addTable(archNames, minimum, archBase, dir, "arch"); err != nil {
+		return nil, err
+	}
+	file := r.Files["src/cmd/asm/internal/arch/arch.go"]
+	if err := validateFrontendDispatch(file, goarch, constructor); err != nil {
+		return nil, err
+	}
+	if err := r.constructor(file, constructor, dir, base, goarch, entries, canonical); err != nil {
+		return nil, err
+	}
+	if err := r.pseudos(entries); err != nil {
+		return nil, err
+	}
+	inventory := &frontendInventory{SchemaVersion: 1, Scope: "go_assembler_frontend_source_registration"}
+	for _, entry := range entries {
+		inventory.Entries = append(inventory.Entries, *entry)
+	}
+	sort.Slice(inventory.Entries, func(i, j int) bool { return inventory.Entries[i].Spelling < inventory.Entries[j].Spelling })
+	for path, hash := range r.Proofs {
+		inventory.Sources = append(inventory.Sources, frontendSourceProof{path, hash})
+	}
+	sort.Slice(inventory.Sources, func(i, j int) bool { return inventory.Sources[i].Source < inventory.Sources[j].Source })
+	return inventory, nil
+}
+
+func validateFrontendDispatch(file *ast.File, goarch, constructor string) error {
+	var fn *ast.FuncDecl
+	for _, decl := range file.Decls {
+		if candidate, ok := decl.(*ast.FuncDecl); ok && candidate.Name.Name == "Set" {
+			if fn != nil {
+				return fmt.Errorf("duplicate arch.Set")
+			}
+			fn = candidate
+		}
+	}
+	if fn == nil || fn.Body == nil || len(fn.Body.List) != 2 || frontendNodeText(fn.Body.List[1]) != "return nil" {
+		return fmt.Errorf("missing/unknown arch.Set dispatch")
+	}
+	selection, ok := fn.Body.List[0].(*ast.SwitchStmt)
+	if !ok || selection.Init != nil || exprText(selection.Tag) != "GOARCH" {
+		return fmt.Errorf("unknown arch.Set selector")
+	}
+	expected := constructor + "()"
+	if goarch == "386" || goarch == "amd64" {
+		expected = constructor + "(&x86.Link" + goarch + ")"
+	}
+	found := 0
+	for _, statement := range selection.Body.List {
+		clause, ok := statement.(*ast.CaseClause)
+		if !ok {
+			return fmt.Errorf("unknown arch.Set branch")
+		}
+		for _, label := range clause.List {
+			literal, ok := label.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return fmt.Errorf("dynamic arch.Set label")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				return err
+			}
+			if name != goarch {
+				continue
+			}
+			if len(clause.List) != 1 || len(clause.Body) != 1 || frontendNodeText(clause.Body[0]) != "return "+expected {
+				return fmt.Errorf("unrecognized %s frontend constructor dispatch", goarch)
+			}
+			found++
+		}
+	}
+	if found != 1 {
+		return fmt.Errorf("missing/duplicate %s frontend dispatch", goarch)
+	}
+	return nil
+}
+
+func (r *frontendReader) constructor(file *ast.File, name, dir, base, goarch string, entries map[string]*frontendName, canonical map[int64]frontendName) error {
+	var fn *ast.FuncDecl
+	for _, decl := range file.Decls {
+		if candidate, ok := decl.(*ast.FuncDecl); ok && candidate.Name.Name == name {
+			if fn != nil {
+				return fmt.Errorf("duplicate constructor %s", name)
+			}
+			fn = candidate
+		}
+	}
+	if fn == nil || fn.Body == nil {
+		return fmt.Errorf("missing constructor %s", name)
+	}
+	allowed := map[token.Pos]bool{}
+	aliasNames := map[string]bool{}
+	initialized, common, arch, returned := 0, 0, 0, 0
+	allow := func(node ast.Node) {
+		ast.Inspect(node, func(node ast.Node) bool {
+			if ident, ok := node.(*ast.Ident); ok && ident.Name == "instructions" {
+				allowed[ident.Pos()] = true
+			}
+			return true
+		})
+	}
+	for _, stmt := range fn.Body.List {
+		switch value := stmt.(type) {
+		case *ast.AssignStmt:
+			if len(value.Lhs) != 1 || len(value.Rhs) != 1 {
+				continue
+			}
+			if ident, ok := value.Lhs[0].(*ast.Ident); ok && ident.Name == "instructions" {
+				if initialized != 0 || common != 0 || arch != 0 || returned != 0 {
+					return fmt.Errorf("out-of-order instruction map initialization")
+				}
+				if value.Tok != token.DEFINE || exprText(value.Rhs[0]) != "make(map[string]obj.As)" {
+					return fmt.Errorf("unknown instruction map initialization")
+				}
+				initialized++
+				allow(value)
+				continue
+			}
+			index, ok := value.Lhs[0].(*ast.IndexExpr)
+			if !ok || exprText(index.X) != "instructions" {
+				continue
+			}
+			if arch != 1 || returned != 0 {
+				return fmt.Errorf("instruction alias outside post-registration phase")
+			}
+			key, ok := index.Index.(*ast.BasicLit)
+			if !ok || key.Kind != token.STRING || value.Tok != token.ASSIGN {
+				return fmt.Errorf("dynamic instruction alias")
+			}
+			spelling, err := strconv.Unquote(key.Value)
+			if err != nil {
+				return err
+			}
+			if spelling == "" || aliasNames[spelling] {
+				return fmt.Errorf("empty/duplicate explicit alias %q", spelling)
+			}
+			aliasNames[spelling] = true
+			_, selector := value.Rhs[0].(*ast.SelectorExpr)
+			if !selector && !(goarch == "arm" && exprText(value.Rhs[0]) == "aMCR") {
+				return fmt.Errorf("unrecognized alias binding %s", exprText(value.Rhs[0]))
+			}
+			id, err := r.integer(value.Rhs[0], "asm", 0)
+			if err != nil {
+				return err
+			}
+			binding, found := canonical[id]
+			if !found && goarch == "arm" && exprText(value.Rhs[0]) == "aMCR" {
+				last, err := r.integer(&ast.SelectorExpr{X: &ast.Ident{Name: "arm"}, Sel: &ast.Ident{Name: "ALAST"}}, "asm", 0)
+				if err != nil || id != last+1 {
+					return fmt.Errorf("invalid private ARM MCR mapping")
+				}
+				binding = frontendName{Canonical: "MCR", CanonicalNamespace: "asm"}
+				found = true
+			}
+			if !found {
+				return fmt.Errorf("alias %s targets unregistered obj.As %d", spelling, id)
+			}
+			entry := entries[spelling]
+			if entry == nil {
+				entry = &frontendName{Spelling: spelling}
+				entries[spelling] = entry
+			}
+			entry.AsID = &id
+			entry.Canonical = binding.Canonical
+			entry.CanonicalNamespace = binding.CanonicalNamespace
+			entry.Sentinel = binding.Sentinel
+			entry.Origins = append(entry.Origins, r.origin("alias", key.Pos()))
+			if entry.Sentinel {
+				entry.Origins = append(entry.Origins, r.origin("sentinel", key.Pos()))
+			}
+			allow(value)
+		case *ast.RangeStmt:
+			if exprText(value.X) != "obj.Anames" && exprText(value.X) != dir+".Anames" {
+				continue
+			}
+			if value.Tok != token.DEFINE || exprText(value.Key) != "i" || exprText(value.Value) != "s" || len(value.Body.List) != 1 {
+				return fmt.Errorf("unknown opcode registration range")
+			}
+			assignment := value.Body.List[0]
+			if exprText(value.X) == "obj.Anames" {
+				if initialized != 1 || common != 0 || arch != 0 || returned != 0 {
+					return fmt.Errorf("out-of-order common opcode registration")
+				}
+				if frontendNodeText(assignment) != "instructions[s] = obj.As(i)" {
+					return fmt.Errorf("unknown common opcode registration")
+				}
+				common++
+			} else {
+				if initialized != 1 || common != 1 || arch != 0 || returned != 0 {
+					return fmt.Errorf("out-of-order arch opcode registration")
+				}
+				guard, ok := assignment.(*ast.IfStmt)
+				if !ok || guard.Init != nil || guard.Else != nil || exprText(guard.Cond) != "obj.As(i) >= obj.A_ARCHSPECIFIC" || len(guard.Body.List) != 1 || frontendNodeText(guard.Body.List[0]) != "instructions[s] = obj.As(i) + obj.ABase"+base {
+					return fmt.Errorf("unknown arch opcode registration")
+				}
+				arch++
+			}
+			allow(value)
+		case *ast.ReturnStmt:
+			if initialized != 1 || common != 1 || arch != 1 || returned != 0 {
+				return fmt.Errorf("return outside completed registration phase")
+			}
+			ast.Inspect(value, func(node ast.Node) bool {
+				if pair, ok := node.(*ast.KeyValueExpr); ok && exprText(pair.Key) == "Instructions" && exprText(pair.Value) == "instructions" {
+					returned++
+					allow(pair.Value)
+				}
+				return true
+			})
+		}
+	}
+	if initialized != 1 || common != 1 || arch != 1 || returned != 1 {
+		return fmt.Errorf("incomplete constructor registration: map=%d common=%d arch=%d result=%d", initialized, common, arch, returned)
+	}
+	var unknown token.Pos
+	var shadowedNamespace token.Pos
+	returnStatements := 0
+	ast.Inspect(fn.Body, func(node ast.Node) bool {
+		if _, ok := node.(*ast.ReturnStmt); ok {
+			returnStatements++
+		}
+		if ident, ok := node.(*ast.Ident); ok && ident.Name == "instructions" && !allowed[ident.Pos()] {
+			unknown = ident.Pos()
+		}
+		if selector, ok := node.(*ast.SelectorExpr); ok {
+			if ident, ok := selector.X.(*ast.Ident); ok && (ident.Name == "obj" || ident.Name == dir) && ident.Obj != nil && ident.Obj.Kind != ast.Pkg {
+				shadowedNamespace = ident.Pos()
+			}
+		}
+		return true
+	})
+	if returnStatements != 1 {
+		return fmt.Errorf("unrecognized constructor return flow")
+	}
+	if shadowedNamespace.IsValid() {
+		return fmt.Errorf("shadowed opcode namespace at %s", r.Fset.Position(shadowedNamespace))
+	}
+	if unknown.IsValid() {
+		return fmt.Errorf("unrecognized instruction map use at %s", r.Fset.Position(unknown))
+	}
+	return nil
+}
+
+func (r *frontendReader) pseudos(entries map[string]*frontendName) error {
+	file, err := r.read("src/cmd/asm/internal/asm/parse.go", "asmparser")
+	if err != nil {
+		return err
+	}
+	var fn *ast.FuncDecl
+	for _, decl := range file.Decls {
+		if candidate, ok := decl.(*ast.FuncDecl); ok && candidate.Name.Name == "pseudo" {
+			if fn != nil {
+				return fmt.Errorf("duplicate Parser.pseudo")
+			}
+			fn = candidate
+		}
+	}
+	if fn == nil || fn.Body == nil || len(fn.Body.List) != 2 {
+		return fmt.Errorf("missing/unknown Parser.pseudo")
+	}
+	selection, ok := fn.Body.List[0].(*ast.SwitchStmt)
+	if !ok || selection.Init != nil || exprText(selection.Tag) != "word" || frontendNodeText(fn.Body.List[1]) != "return true" {
+		return fmt.Errorf("unknown Parser.pseudo dispatch")
+	}
+	seen := map[string]bool{}
+	defaults := 0
+	for _, stmt := range selection.Body.List {
+		clause, ok := stmt.(*ast.CaseClause)
+		if !ok || len(clause.Body) != 1 {
+			return fmt.Errorf("unknown pseudo case")
+		}
+		if len(clause.List) == 0 {
+			defaults++
+			if frontendNodeText(clause.Body[0]) != "return false" {
+				return fmt.Errorf("unknown pseudo default")
+			}
+			continue
+		}
+		if len(clause.List) != 1 {
+			return fmt.Errorf("unknown grouped pseudo case")
+		}
+		literal, ok := clause.List[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return fmt.Errorf("dynamic pseudo name")
+		}
+		spelling, err := strconv.Unquote(literal.Value)
+		if err != nil {
+			return err
+		}
+		if seen[spelling] {
+			return fmt.Errorf("duplicate pseudo %s", spelling)
+		}
+		seen[spelling] = true
+		handler := map[string]string{"DATA": "asmData", "FUNCDATA": "asmFuncData", "GLOBL": "asmGlobl", "PCDATA": "asmPCData", "PCALIGN": "asmPCAlign", "TEXT": "asmText"}[spelling]
+		if handler == "" || frontendNodeText(clause.Body[0]) != "p."+handler+"(operands)" {
+			return fmt.Errorf("unrecognized pseudo handler %s", spelling)
+		}
+		entry := entries[spelling]
+		if entry == nil {
+			entry = &frontendName{Spelling: spelling, Canonical: spelling, CanonicalNamespace: "pseudo"}
+			entries[spelling] = entry
+		}
+		entry.Origins = append(entry.Origins, r.origin("pseudo", literal.Pos()))
+	}
+	if len(seen) != 6 || defaults != 1 {
+		return fmt.Errorf("incomplete required parser pseudo family")
+	}
+	return nil
+}
+
+// Opcode tables are literal initializers with one recognized ARM64 append.
+// Inspect every production file in the selected package, not just anames*.go,
+// so an additional mutation or escaped slice cannot silently change the map.
+func (r *frontendReader) verifyArrayUses(directory, namespace, base string, sve bool) error {
+	paths, err := filepath.Glob(filepath.Join(r.Root, filepath.FromSlash(directory), "*.go"))
+	if err != nil {
+		return err
+	}
+	declarations := map[string]int{}
+	appends := 0
+	for _, path := range paths {
+		if strings.HasSuffix(path, "_test.go") {
+			continue
+		}
+		relative, err := filepath.Rel(r.Root, path)
+		if err != nil {
+			return err
+		}
+		relative = filepath.ToSlash(relative)
+		file := r.Files[relative]
+		if file == nil {
+			data, err := os.ReadFile(path)
+			if err != nil {
+				return err
+			}
+			file, err = parser.ParseFile(r.Fset, relative, data, 0)
+			if err != nil {
+				return err
+			}
+			if file.Name.Name != namespace {
+				continue
+			}
+			r.Files[relative] = file
+			r.Proofs[relative] = fmt.Sprintf("%x", sha256.Sum256(data))
+		}
+		parents := map[ast.Node]ast.Node{}
+		var stack []ast.Node
+		ast.Inspect(file, func(node ast.Node) bool {
+			if node == nil {
+				stack = stack[:len(stack)-1]
+				return false
+			}
+			if len(stack) > 0 {
+				parents[node] = stack[len(stack)-1]
+			}
+			stack = append(stack, node)
+			return true
+		})
+		allowed := map[token.Pos]bool{}
+		for _, decl := range file.Decls {
+			group, ok := decl.(*ast.GenDecl)
+			if !ok || group.Tok != token.VAR {
+				continue
+			}
+			for _, spec := range group.Specs {
+				for _, name := range spec.(*ast.ValueSpec).Names {
+					if name.Name == "Anames" || (sve && name.Name == "sveAnames") {
+						declarations[name.Name]++
+						allowed[name.Pos()] = true
+					}
+				}
+			}
+		}
+		if sve {
+			for _, decl := range file.Decls {
+				fn, ok := decl.(*ast.FuncDecl)
+				if !ok || fn.Name.Name != "init" || fn.Body == nil {
+					continue
+				}
+				for _, stmt := range fn.Body.List {
+					assign, ok := stmt.(*ast.AssignStmt)
+					if !ok || frontendNodeText(assign) != "Anames = append(Anames, sveAnames...)" {
+						continue
+					}
+					appends++
+					ast.Inspect(assign, func(node ast.Node) bool {
+						if ident, ok := node.(*ast.Ident); ok {
+							allowed[ident.Pos()] = true
+						}
+						return true
+					})
+				}
+			}
+		}
+		var invalid token.Pos
+		ast.Inspect(file, func(node ast.Node) bool {
+			ident, ok := node.(*ast.Ident)
+			if !ok || (ident.Name != "Anames" && !(sve && ident.Name == "sveAnames")) || allowed[ident.Pos()] {
+				return true
+			}
+			if ident.Obj != nil {
+				declaration, ok := ident.Obj.Decl.(ast.Node)
+				if ok {
+					group, global := parents[declaration].(*ast.GenDecl)
+					if !global || parents[group] != file {
+						return true
+					} // Local shadow or parameter.
+				}
+			}
+			parent := parents[ident]
+			if index, ok := parent.(*ast.IndexExpr); ok && index.X == ident {
+				grandparent := parents[index]
+				if assignment, ok := grandparent.(*ast.AssignStmt); ok {
+					for _, left := range assignment.Lhs {
+						if left == index {
+							invalid = ident.Pos()
+							return true
+						}
+					}
+				}
+				if unary, ok := grandparent.(*ast.UnaryExpr); ok && unary.Op == token.AND {
+					invalid = ident.Pos()
+					return true
+				}
+				return true // Reading a string element cannot mutate the table.
+			}
+			if call, ok := parent.(*ast.CallExpr); ok {
+				if exprText(call.Fun) == "len" && len(call.Args) == 1 {
+					return true
+				}
+				if base != "" && exprText(call) == "obj.RegisterOpcode(obj.ABase"+base+", Anames)" {
+					return true
+				}
+			}
+			invalid = ident.Pos()
+			return true
+		})
+		if invalid.IsValid() {
+			return fmt.Errorf("unrecognized opcode array use at %s", r.Fset.Position(invalid))
+		}
+	}
+	if declarations["Anames"] != 1 || (sve && (declarations["sveAnames"] != 1 || appends != 1)) {
+		return fmt.Errorf("incomplete literal opcode array registration")
+	}
+	return nil
+}
diff --git a/cmd/plan9asmscan/frontend_inventory_test.go b/cmd/plan9asmscan/frontend_inventory_test.go
new file mode 100644
index 000000000..46fa41611
--- /dev/null
+++ b/cmd/plan9asmscan/frontend_inventory_test.go
@@ -0,0 +1,346 @@
+package main
+
+import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func frontendFixture(t *testing.T, arch string) string {
+	t.Helper()
+	root := t.TempDir()
+	obj := filepath.Join(root, "src/cmd/internal/obj")
+	writeEncoderFixture(t, filepath.Join(obj, "link.go"), `package obj
+const (
+ AXXX As = iota; ACALL; ADUFFCOPY; ADUFFZERO; AEND; AFUNCDATA; AJMP; ANOP
+ APCALIGN; APCALIGNMAX; APCDATA; ARET; AGETCALLERPC; ATEXT; AUNDEF; A_ARCHSPECIFIC
+)
+const (
+ ABase386 = (1+iota)<<11; ABaseARM; ABaseAMD64; ABasePPC64; ABaseARM64
+ ABaseMIPS; ABaseLoong64; ABaseRISCV; ABaseS390X; ABaseWasm
+)
+`)
+	writeEncoderFixture(t, filepath.Join(obj, "util.go"), `package obj
+var Anames = []string{"XXX","CALL","DUFFCOPY","DUFFZERO","END","FUNCDATA","JMP","NOP","PCALIGN","PCALIGNMAX","PCDATA","RET","GETCALLERPC","TEXT","UNDEF"}
+`)
+	dir, base, constructor := arch, "ARM", "archArm"
+	opcodes, enum, extra := `"ADD","MOV","LAST"`, "AADD; AMOV; ALAST", ""
+	aliases := `instructions["B"] = obj.AJMP
+ instructions["BL"] = obj.ACALL
+ instructions["MCR"] = aMCR`
+	switch arch {
+	case "386", "amd64":
+		dir, base, constructor = "x86", "AMD64", "archX86"
+		opcodes, enum = `"ADD","MOVQ","LAST"`, "AADD; AMOVQ; ALAST"
+		aliases = `instructions["MOVD"] = x86.AMOVQ
+ instructions["ADD"] = x86.AADD`
+	case "arm64":
+		base, constructor = "ARM64", "archArm64"
+		opcodes, enum = `"B","BL","MOV"`, "AB; ABL; AMOV"
+		aliases = `instructions["B"] = arm64.AB
+ instructions["BL"] = arm64.ABL`
+		extra = `package arm64
+var sveAnames = []string{"SVESTART","ZADD","LAST"}
+func init() { Anames = append(Anames, sveAnames...) }
+`
+	case "wasm":
+		base, constructor = "Wasm", "archWasm"
+		opcodes, enum = `"Call","Nop","End","Last","ReservedFD00","LAST"`, "ACall; ANop; AEnd; ALast; AReservedFD00; ALAST"
+		aliases = ""
+	}
+	parts := strings.Split(enum, ";")
+	parts[0] += " = obj.ABase" + base + " + obj.A_ARCHSPECIFIC + iota"
+	enumFile := "a.out.go"
+	if dir == "x86" {
+		enumFile = "aenum.go"
+	}
+	writeEncoderFixture(t, filepath.Join(obj, dir, enumFile), "package "+dir+"\nimport \"cmd/internal/obj\"\nconst ("+strings.Join(parts, ";")+")\n")
+	writeEncoderFixture(t, filepath.Join(obj, dir, "anames.go"), "package "+dir+"\nimport \"cmd/internal/obj\"\nvar Anames = []string{obj.A_ARCHSPECIFIC:"+opcodes+"}\nvar cnames = []string{\"REG\",\"FAKE\"}\n")
+	if extra != "" {
+		writeEncoderFixture(t, filepath.Join(obj, dir, "anames_gen.go"), extra)
+	}
+	asmArch := filepath.Join(root, "src/cmd/asm/internal/arch")
+	writeEncoderFixture(t, filepath.Join(asmArch, "arm.go"), "package arch\nimport \"cmd/internal/obj/arm\"\nconst aMCR = arm.ALAST + 1\n")
+	writeEncoderFixture(t, filepath.Join(asmArch, "arch.go"), fmt.Sprintf(`package arch
+import ("cmd/internal/obj"; "cmd/internal/obj/%s")
+func %s() *Arch {
+ instructions := make(map[string]obj.As)
+ for i,s := range obj.Anames { instructions[s] = obj.As(i) }
+ for i,s := range %s.Anames {
+  if obj.As(i) >= obj.A_ARCHSPECIFIC { instructions[s] = obj.As(i) + obj.ABase%s }
+ }
+ %s
+ return &Arch{Instructions:instructions}
+}
+func Set(GOARCH string, shared bool) *Arch {
+ switch GOARCH {
+ case "386": return archX86(&x86.Link386)
+ case "amd64": return archX86(&x86.Linkamd64)
+ case "arm": return archArm()
+ case "arm64": return archArm64()
+ case "wasm": return archWasm()
+ }
+ return nil
+}
+`, dir, constructor, dir, base, aliases))
+	writeEncoderFixture(t, filepath.Join(root, "src/cmd/asm/internal/asm/parse.go"), `package asm
+func (p *Parser) pseudo(word string, operands [][]Token) bool {
+ switch word {
+ case "DATA": p.asmData(operands)
+ case "FUNCDATA": p.asmFuncData(operands)
+ case "GLOBL": p.asmGlobl(operands)
+ case "PCDATA": p.asmPCData(operands)
+ case "PCALIGN": p.asmPCAlign(operands)
+ case "TEXT": p.asmText(operands)
+ default: return false
+ }
+ return true
+}
+`)
+	return root
+}
+
+func frontendEntries(t *testing.T, inventory *frontendInventory) map[string]frontendName {
+	t.Helper()
+	if inventory == nil || inventory.SchemaVersion != 1 || inventory.Scope != "go_assembler_frontend_source_registration" {
+		t.Fatalf("unexpected inventory identity: %+v", inventory)
+	}
+	entries := map[string]frontendName{}
+	sources := map[string]bool{}
+	for _, source := range inventory.Sources {
+		digest, err := hex.DecodeString(source.SHA256)
+		if err != nil || len(digest) != 32 || filepath.IsAbs(source.Source) {
+			t.Fatalf("invalid source hash proof: %+v", source)
+		}
+		sources[source.Source] = true
+	}
+	for _, entry := range inventory.Entries {
+		if _, duplicate := entries[entry.Spelling]; duplicate {
+			t.Fatalf("duplicate exact spelling %q", entry.Spelling)
+		}
+		if entry.Canonical == "" || entry.CanonicalNamespace == "" || len(entry.Origins) == 0 {
+			t.Fatalf("missing canonical/origin proof: %+v", entry)
+		}
+		for _, origin := range entry.Origins {
+			if filepath.IsAbs(origin.Source) || origin.Line < 1 || !sources[origin.Source] {
+				t.Fatalf("source proof must be relative and positioned: %+v", origin)
+			}
+		}
+		entries[entry.Spelling] = entry
+	}
+	return entries
+}
+
+func frontendRoles(entry frontendName) []string {
+	var roles []string
+	for _, origin := range entry.Origins {
+		roles = append(roles, origin.Role)
+	}
+	return roles
+}
+
+func TestFrontendInventoryCompletenessEveryArchitecture(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			inventory, err := loadFrontendInventory(frontendFixture(t, arch), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			entries := frontendEntries(t, inventory)
+			call := entries["CALL"]
+			if call.AsID == nil || *call.AsID != 1 || call.Canonical != "CALL" || call.CanonicalNamespace != "obj" || !reflect.DeepEqual(frontendRoles(call), []string{"common"}) {
+				t.Fatalf("portable CALL mapping = %+v", call)
+			}
+			if !reflect.DeepEqual(frontendRoles(entries["TEXT"]), []string{"common", "pseudo"}) {
+				t.Fatalf("TEXT must retain both registration roles: %+v", entries["TEXT"])
+			}
+			if entries["DATA"].AsID != nil || entries["DATA"].CanonicalNamespace != "pseudo" || !reflect.DeepEqual(frontendRoles(entries["DATA"]), []string{"pseudo"}) {
+				t.Fatalf("DATA has no obj.As and must remain a pseudo: %+v", entries["DATA"])
+			}
+			if !entries["XXX"].Sentinel || !entries["LAST"].Sentinel || !strings.Contains(strings.Join(frontendRoles(entries["LAST"]), ","), "sentinel") {
+				t.Fatal("source sentinels must be explicitly identified, never silently discarded")
+			}
+			if _, leaked := entries["REG"]; leaked {
+				t.Fatal("operand-class strings are not frontend names")
+			}
+			switch arch {
+			case "386", "amd64":
+				if entries["MOVD"].Canonical != "MOVQ" || entries["MOVD"].CanonicalNamespace != "x86" || !reflect.DeepEqual(frontendRoles(entries["ADD"]), []string{"arch", "alias"}) {
+					t.Fatalf("x86 alias/canonical roles were lost: %+v", entries)
+				}
+			case "arm":
+				if *entries["B"].AsID != *entries["JMP"].AsID || entries["B"].CanonicalNamespace != "obj" || entries["MCR"].CanonicalNamespace != "asm" {
+					t.Fatalf("ARM common and private frontend aliases were lost: %+v", entries)
+				}
+			case "arm64":
+				if entries["ZADD"].AsID == nil || !entries["SVESTART"].Sentinel || entries["B"].CanonicalNamespace != "arm64" {
+					t.Fatalf("ARM64 registered append/aliases were lost: %+v", entries)
+				}
+			case "wasm":
+				for _, pair := range [][2]string{{"Call", "CALL"}, {"Nop", "NOP"}, {"End", "END"}, {"Last", "LAST"}} {
+					left, right := entries[pair[0]], entries[pair[1]]
+					if left.AsID == nil || right.AsID == nil || *left.AsID == *right.AsID || left.Spelling == right.Spelling {
+						t.Fatalf("case-sensitive names were collapsed: %s/%s", pair[0], pair[1])
+					}
+				}
+				if !entries["ReservedFD00"].Sentinel {
+					t.Fatal("reserved wasm entry was silently promoted to executable opcode")
+				}
+			}
+		})
+	}
+}
+
+func TestFrontendInventoryFailsClosedForRegistrationChanges(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		for _, mutation := range []struct{ name, old, new string }{
+			{"missing_common", "for i,s := range obj.Anames { instructions[s] = obj.As(i) }", ""},
+			{"altered_common", "instructions[s] = obj.As(i) }", "instructions[s] = obj.As(i)+1 }"},
+			{"altered_arch_guard", ">= obj.A_ARCHSPECIFIC", "> obj.A_ARCHSPECIFIC"},
+			{"map_escape", "return &Arch", "hidden := instructions; _ = hidden; return &Arch"},
+			{"unknown_helper", "return &Arch", "addNames(instructions); return &Arch"},
+			{"delete_name", "return &Arch", "delete(instructions,\"NOP\"); return &Arch"},
+			{"conditional_alias", "return &Arch", "if unknown { instructions[\"HIDDEN\"] = obj.ANOP }; return &Arch"},
+			{"dynamic_alias", "return &Arch", "instructions[unknown] = obj.ANOP; return &Arch"},
+			{"unresolved_alias", "return &Arch", "instructions[\"BAD\"] = obj.UNKNOWN; return &Arch"},
+			{"literal_alias", "return &Arch", "instructions[\"LITERAL\"] = 1; return &Arch"},
+			{"conflicting_alias", "return &Arch", "instructions[\"CONFLICT\"] = obj.ACALL; instructions[\"CONFLICT\"] = obj.ANOP; return &Arch"},
+			{"wrong_import_origin", "\"cmd/internal/obj\"", "obj \"other/obj\""},
+			{"redirected_Set", "case \"" + arch + "\": return", "case \"" + arch + "\": return otherConstructor(); case \"unused\": return"},
+			{"early_alias", "for i,s := range obj.Anames", "instructions[\"EARLY\"] = obj.ACALL; for i,s := range obj.Anames"},
+			{"early_return", "for i,s := range obj.Anames", "if unknown { return nil }; for i,s := range obj.Anames"},
+			{"dead_alias", "return &Arch{Instructions:instructions}", "return &Arch{Instructions:instructions}; instructions[\"DEAD\"] = obj.ACALL"},
+			{"shadowed_namespace", "instructions := make(map[string]obj.As)", "obj := fake; instructions := make(map[string]obj.As)"},
+		} {
+			t.Run(arch+"/"+mutation.name, func(t *testing.T) {
+				root := frontendFixture(t, arch)
+				path := filepath.Join(root, "src/cmd/asm/internal/arch/arch.go")
+				source, err := os.ReadFile(path)
+				if err != nil {
+					t.Fatal(err)
+				}
+				changed := strings.Replace(string(source), mutation.old, mutation.new, 1)
+				if changed == string(source) {
+					t.Fatal("mutation did not alter fixture")
+				}
+				writeEncoderFixture(t, path, changed)
+				if _, err := loadFrontendInventory(root, arch); err == nil {
+					t.Fatal("unknown/incomplete frontend registration was accepted")
+				}
+			})
+		}
+	}
+}
+
+func TestFrontendInventoryRequiresParserPseudosAndRegisteredAppend(t *testing.T) {
+	for _, relative := range []string{"src/cmd/internal/obj/util.go", "src/cmd/asm/internal/asm/parse.go", "src/cmd/asm/internal/arch/arch.go"} {
+		t.Run(relative, func(t *testing.T) {
+			root := frontendFixture(t, "arm64")
+			writeEncoderFixture(t, filepath.Join(root, relative), "package fixture\n")
+			if _, err := loadFrontendInventory(root, "arm64"); err == nil {
+				t.Fatal("missing registration source accepted")
+			}
+		})
+	}
+	root := frontendFixture(t, "arm64")
+	writeEncoderFixture(t, filepath.Join(root, "src/cmd/internal/obj/arm64/anames_gen.go"), "package arm64\nvar sveAnames = []string{\"HIDDEN\"}\n")
+	if _, err := loadFrontendInventory(root, "arm64"); err == nil {
+		t.Fatal("unregistered supplement accepted")
+	}
+}
+
+func TestFrontendInventoryRejectsUnmodeledArrayAndPseudoChanges(t *testing.T) {
+	for _, mutation := range []struct{ name, path, old, replacement string }{
+		{"common_escape", "src/cmd/internal/obj/util.go", "", "\nvar escaped = Anames\n"},
+		{"common_mutation", "src/cmd/internal/obj/util.go", "", "\nfunc init(){ Anames[1] = \"HIDDEN\" }\n"},
+		{"arch_mutation_other_file", "src/cmd/internal/obj/arm64/extra.go", "", "package arm64\nfunc init(){ Anames[15] = \"HIDDEN\" }\n"},
+		{"sve_extra_mutation", "src/cmd/internal/obj/arm64/anames_gen.go", "func init() { Anames = append(Anames, sveAnames...) }", "func init() { Anames = append(Anames, sveAnames...); Anames = Anames[:1] }"},
+		{"pseudo_catch_all", "src/cmd/asm/internal/asm/parse.go", "default: return false", "default: return true"},
+		{"pseudo_missing_default", "src/cmd/asm/internal/asm/parse.go", "default: return false", ""},
+		{"pseudo_missing_DATA", "src/cmd/asm/internal/asm/parse.go", "case \"DATA\": p.asmData(operands)", ""},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			root := frontendFixture(t, "arm64")
+			path := filepath.Join(root, mutation.path)
+			source, err := os.ReadFile(path)
+			if err != nil && !os.IsNotExist(err) {
+				t.Fatal(err)
+			}
+			changed := string(source) + mutation.replacement
+			if mutation.old != "" {
+				changed = strings.Replace(string(source), mutation.old, mutation.replacement, 1)
+			}
+			writeEncoderFixture(t, path, changed)
+			if _, err := loadFrontendInventory(root, "arm64"); err == nil {
+				t.Fatal("unmodeled array/pseudo mutation was accepted")
+			}
+		})
+	}
+}
+
+func TestFrontendInventoryActualGoSourceNamespaces(t *testing.T) {
+	for _, arch := range namespaceArchitectures {
+		t.Run(arch, func(t *testing.T) {
+			count := actualGoNamespaceCounts(t, arch).frontend
+			inventory, err := loadFrontendInventory(runtime.GOROOT(), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			entries := frontendEntries(t, inventory)
+			if len(entries) != count {
+				t.Fatalf("actual frontend source names=%d, want %d including explicit sentinels", len(entries), count)
+			}
+			if arch == "wasm" && (entries["Call"].CanonicalNamespace != "wasm" || entries["CALL"].CanonicalNamespace != "obj") {
+				t.Fatal("wasm/common call identities conflated")
+			}
+			data, err := json.Marshal(inventory)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(string(data), "runtime_verified") || strings.Contains(string(data), "supported_forms") {
+				t.Fatal("registration inventory must not imply semantic proof")
+			}
+		})
+	}
+}
+
+func TestFrontendInventoryJSONDoesNotChangeCoverageFields(t *testing.T) {
+	inventory, err := loadFrontendInventory(frontendFixture(t, "wasm"), "wasm")
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := report{OfficialOpcodes: 463, SupportedForms: 0, ContextForms: 120, CoverageFingerprint: "existing-fingerprint"}
+	data, err := json.Marshal(before)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(data), "frontend_inventory") {
+		t.Fatal("unrequested inventory must remain absent")
+	}
+	after := before
+	after.FrontendInventory = inventory
+	data, err = json.Marshal(after)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var decoded struct {
+		Official  int                `json:"official_opcodes"`
+		Inventory *frontendInventory `json:"frontend_inventory"`
+	}
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatal(err)
+	}
+	if decoded.Official != 463 || decoded.Inventory == nil || len(decoded.Inventory.Entries) != len(inventory.Entries) {
+		t.Fatal("JSON lost separate frontend inventory/architecture-specific denominator")
+	}
+	after.FrontendInventory = nil
+	if !reflect.DeepEqual(before, after) {
+		t.Fatal("inventory attachment modified existing coverage fields")
+	}
+}
diff --git a/cmd/plan9asmscan/gp_simd_store_context_test.go b/cmd/plan9asmscan/gp_simd_store_context_test.go
new file mode 100644
index 000000000..1f52f7760
--- /dev/null
+++ b/cmd/plan9asmscan/gp_simd_store_context_test.go
@@ -0,0 +1,14 @@
+package main
+
+import "testing"
+
+func TestGPSIMDStoreCoverageRequiresInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, opcode+" X0,(BX)")
+				valueProbeNeedsContext(t, arch, "PXOR X0,X0\nMOVL $1,BX\n"+opcode+" X0,(BX)")
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/ifma_context_test.go b/cmd/plan9asmscan/ifma_context_test.go
new file mode 100644
index 000000000..82f4694de
--- /dev/null
+++ b/cmd/plan9asmscan/ifma_context_test.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestIFMACoverageRetainsSourceAccumulatorAndMaskInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				modes := []string{"plain"}
+				if arch == "amd64" {
+					modes = append(modes, "merge", "zero")
+				}
+				for _, mode := range modes {
+					t.Run(arch+"/"+op+"/"+bank+"/"+mode, func(t *testing.T) {
+						name, mask := op, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							name += ".Z"
+						}
+						line := fmt.Sprintf("%s %s0,%s1,%s%s2\nMOVL X2,AX\nTESTL AX,AX\nSETEQ CX",
+							name, bank, bank, mask, bank)
+						prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+						if mode != "plain" {
+							prefix += "MOVL $7,AX\nKMOVD AX,K1\n"
+						}
+						valueProbeNeedsContext(t, arch, line)
+						if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+							compactProbeInstructions(t, prefix+line)); err != nil {
+							t.Fatal("complete initialized IFMA inputs became unsupported", err)
+						}
+						for _, remove := range []string{"VPXORD Z0,Z0,Z0\n", "VPXORD Z1,Z1,Z1\n", "VPXORD Z2,Z2,Z2\n"} {
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, remove, "", 1))
+						}
+						if mode != "plain" {
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, "KMOVD AX,K1\n", "", 1))
+						}
+						// Complete address bits permit only this paired native read.
+						valueProbePairedNumericAddress(t, arch, prefix+"MOVL $1,SI\n"+
+							fmt.Sprintf("%s (SI),%s1,%s%s2", name, bank, mask, bank))
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/include_test.go b/cmd/plan9asmscan/include_test.go
new file mode 100644
index 000000000..466156bd4
--- /dev/null
+++ b/cmd/plan9asmscan/include_test.go
@@ -0,0 +1,106 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanPackagesCountsIncludedMacroInstructions(t *testing.T) {
+	dir := t.TempDir()
+	files := map[string]string{
+		"save.h":  "#define SAVE() PUSHQ BP; MOVQ SP,BP\n#define RESTORE() POPQ BP\n",
+		"probe.s": "#include \"save.h\"\nTEXT probe(SB),4,$0-0\nSAVE()\nXORQ AX,AX\nRESTORE()\nRET\n",
+	}
+	for name, contents := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ops, _, parseErrors, packages, sources, err := scanPackages([]pkgJSON{{
+		ImportPath: "example.invalid/included", Dir: dir, SFiles: []string{"probe.s"},
+	}}, plan9asm.ArchAMD64, "amd64", runtime.GOROOT())
+	if err != nil || len(parseErrors) != 0 || packages != 1 || sources != 1 {
+		t.Fatalf("included source lost: error=%v parse=%v packages=%d sources=%d", err, parseErrors, packages, sources)
+	}
+	for _, opcode := range []string{"PUSHQ", "MOVQ", "XORQ", "POPQ", "RET"} {
+		if ops[opcode] == nil || ops[opcode].Count != 1 {
+			t.Errorf("included macro instruction %s not counted exactly once: %#v", opcode, ops[opcode])
+		}
+	}
+}
+
+func TestScanPackagesUsesSelectedSDKAndTargetMacros(t *testing.T) {
+	dir, sdk := t.TempDir(), t.TempDir()
+	include := filepath.Join(sdk, "pkg", "include")
+	if err := os.MkdirAll(include, 0700); err != nil {
+		t.Fatal(err)
+	}
+	// The header exists only in the explicitly selected SDK, not the host's.
+	header := "#ifdef GOOS_windows\n#define SAVE() PUSHQ BP\n#else\n#define SAVE() PUSHQ BX\n#endif\n"
+	if err := os.WriteFile(filepath.Join(include, "selected.h"), []byte(header), 0600); err != nil {
+		t.Fatal(err)
+	}
+	source := "#include \"selected.h\"\n#include \"go_asm.h\"\nTEXT probe(SB),4,$0-0\nSAVE()\nMOVQ g_stackguard0(BP),BX\nRET\n"
+	if err := os.WriteFile(filepath.Join(dir, "probe.s"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []struct{ goos, register string }{{"windows", "BP"}, {"linux", "BX"}} {
+		t.Run(target.goos, func(t *testing.T) {
+			ops, forms, parseErrors, _, _, err := scanPackages([]pkgJSON{{
+				ImportPath: "example.invalid/selected", Dir: dir, SFiles: []string{"probe.s"},
+			}}, plan9asm.ArchAMD64, "amd64", sdk, plan9asm.GoAssemblerDefines(target.goos, "amd64")...)
+			if err != nil || len(parseErrors) != 0 || ops["PUSHQ"] == nil {
+				t.Fatalf("selected SDK macro was lost: error=%v parse=%v", err, parseErrors)
+			}
+			var push, contextual int
+			for _, form := range forms {
+				if form.Descriptor.Opcode == "PUSHQ" {
+					for _, example := range form.Examples {
+						if example == "PUSHQ "+target.register {
+							push++
+						}
+					}
+				}
+				if form.Descriptor.Opcode == "MOVQ" {
+					contextual += form.ContextCount
+					if form.SupportedCount != 0 || form.UnsupportedCount != 0 {
+						t.Fatal("missing generated layout was certified as a resolved instruction")
+					}
+				}
+			}
+			if push != 1 || contextual != 1 {
+				t.Fatalf("wrong target macro or lost unresolved generated operand: pushes=%d contextual=%d forms=%#v", push, contextual, forms)
+			}
+		})
+	}
+}
+
+func TestScanPackagesRetainsGeneratedGlobalSizeAsContext(t *testing.T) {
+	dir := t.TempDir()
+	source := "GLOBL data(SB),8,$const_tlsSize\nTEXT probe(SB),4,$0-0\nXORQ AX,AX\nRET\n"
+	if err := os.WriteFile(filepath.Join(dir, "probe.s"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ops, forms, parseErrors, _, _, err := scanPackages([]pkgJSON{{
+		ImportPath: "example.invalid/global", Dir: dir, SFiles: []string{"probe.s"},
+	}}, plan9asm.ArchAMD64, "amd64", runtime.GOROOT())
+	if err != nil || len(parseErrors) != 0 || ops["XORQ"] == nil || ops["GLOBL"] == nil {
+		t.Fatalf("global context swallowed later instructions: error=%v parse=%v", err, parseErrors)
+	}
+	var contextual int
+	for _, form := range forms {
+		if form.Descriptor.Opcode == "GLOBL" {
+			contextual += form.ContextCount
+			if form.SupportedCount != 0 || form.UnsupportedCount != 0 {
+				t.Fatal("unresolved global size was reported as a resolved form")
+			}
+		}
+	}
+	if contextual != 1 {
+		t.Fatalf("generated global size disappeared from contextual forms: %d", contextual)
+	}
+}
diff --git a/cmd/plan9asmscan/initialized_context_reprobe.go b/cmd/plan9asmscan/initialized_context_reprobe.go
new file mode 100644
index 000000000..14a68f42c
--- /dev/null
+++ b/cmd/plan9asmscan/initialized_context_reprobe.go
@@ -0,0 +1,269 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"debug/elf"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+type initializedContextSource struct {
+	File             string `json:"file"`
+	Function         string `json:"function"`
+	InstructionIndex int    `json:"instruction_index"`
+	Line             int    `json:"line,omitempty"`
+}
+
+type initializedContextCase struct {
+	OriginalInstruction   plan9asm.Instr           `json:"original_instruction"`
+	OriginalStatus        string                   `json:"original_status"`
+	Source                initializedContextSource `json:"source"`
+	Initialization        []plan9asm.Instr         `json:"initialization"`
+	IRTextGeneration      scanEvidenceStage        `json:"ir_text_generation"`
+	LLVMObjectCompilation scanEvidenceStage        `json:"llvm_object_compilation"`
+	RuntimeExecution      scanEvidenceStage        `json:"runtime_execution"`
+}
+
+type initializedContextObject struct {
+	Status       string   `json:"status"`
+	Error        string   `json:"error,omitempty"`
+	CaseIndexes  []int    `json:"case_indexes"`
+	ObjectSize   int64    `json:"object_size"`
+	ObjectSHA256 string   `json:"object_sha256"`
+	Command      []string `json:"command"`
+}
+
+type initializedContextReport struct {
+	Profile           string                     `json:"profile"`
+	Status            string                     `json:"status"`
+	Error             string                     `json:"error,omitempty"`
+	LLVMVersion       string                     `json:"llvm_version,omitempty"`
+	EligibleCases     int                        `json:"eligible_cases"`
+	Cases             []initializedContextCase   `json:"cases"`
+	UnregisteredCases []initializedContextCase   `json:"unregistered_cases"`
+	ObjectBatches     []initializedContextObject `json:"object_batches"`
+}
+
+// Retain occurrences, not the capped display Examples or form-level status.
+// An isolated successful constant and an unknown-input instruction can share
+// a descriptor; only the actual cached context outcome selects this record.
+func captureContextSource(
+	forms map[string]*formStat, arch plan9asm.Arch, goarch string,
+	ins plan9asm.Instr, source initializedContextSource, probeErr error,
+) {
+	if !errors.Is(probeErr, plan9asm.ErrProbeNeedsContext) {
+		return
+	}
+	descriptor := plan9asm.DescribeInstruction(arch, goarch, ins)
+	st := forms[descriptor.Form]
+	if st == nil {
+		return
+	}
+	ins.Args = append([]plan9asm.Operand(nil), ins.Args...)
+	for i := range ins.Args {
+		if ins.Args[i].RegList != nil {
+			ins.Args[i].RegList = append([]plan9asm.Reg(nil), ins.Args[i].RegList...)
+		}
+	}
+	notRun := scanEvidenceStage{Status: "not_run"}
+	st.contextSources = append(st.contextSources, initializedContextCase{
+		OriginalInstruction: ins, OriginalStatus: "context-required", Source: source,
+		IRTextGeneration: notRun, LLVMObjectCompilation: notRun, RuntimeExecution: notRun,
+	})
+}
+
+func runInitializedContextReprobe(forms map[string]*formStat, goarch, llc string) (result *initializedContextReport, resultErr error) {
+	result = &initializedContextReport{Profile: "mask-logical", Status: "failed",
+		Cases: []initializedContextCase{}, UnregisteredCases: []initializedContextCase{}, ObjectBatches: []initializedContextObject{}}
+	defer func() {
+		if resultErr != nil {
+			result.Error = resultErr.Error()
+		} else if result.EligibleCases == 0 {
+			result.Status = "not_run"
+		} else {
+			result.Status = "pass"
+		}
+	}()
+	var sources []initializedContextCase
+	for _, form := range forms {
+		sources = append(sources, form.contextSources...)
+	}
+	sort.Slice(sources, func(i, j int) bool {
+		a, b := sources[i].Source, sources[j].Source
+		if a.File != b.File {
+			return a.File < b.File
+		}
+		if a.Line != b.Line {
+			return a.Line < b.Line
+		}
+		if a.Function != b.Function {
+			return a.Function < b.Function
+		}
+		return a.InstructionIndex < b.InstructionIndex
+	})
+	for _, source := range sources {
+		sequence, known, err := plan9asm.InitializedMaskLogicalProbeSequence(goarch, source.OriginalInstruction)
+		if !known {
+			result.UnregisteredCases = append(result.UnregisteredCases, source)
+			continue
+		}
+		if err != nil {
+			return result, err
+		}
+		source.Initialization = sequence[:len(sequence)-1]
+		result.Cases = append(result.Cases, source)
+	}
+	result.EligibleCases = len(result.Cases)
+	llc, err := initializedContextLLC(llc)
+	if err != nil {
+		return result, err
+	}
+	version, err := initializedContextCommand(llc, "--version")
+	if err != nil {
+		return result, fmt.Errorf("LLVM22 version observation: %w", err)
+	}
+	result.LLVMVersion = strings.TrimSpace(string(version))
+	match := regexp.MustCompile(`\bLLVM version ([0-9]+)\.`).FindStringSubmatch(result.LLVMVersion)
+	if len(match) != 2 || match[1] != "22" {
+		return result, fmt.Errorf("LLVM22 required, %s reported %q", llc, result.LLVMVersion)
+	}
+	for start := 0; start < len(result.Cases); start += 32 {
+		end := start + 32
+		if end > len(result.Cases) {
+			end = len(result.Cases)
+		}
+		batch, err := compileInitializedContextBatch(result.Cases[start:end], goarch, llc, start)
+		if err != nil {
+			batch.Status, batch.Error = "failed", err.Error()
+			result.ObjectBatches = append(result.ObjectBatches, batch)
+			for i := start; i < end; i++ {
+				if result.Cases[i].IRTextGeneration.Status == "pass" {
+					result.Cases[i].LLVMObjectCompilation = scanEvidenceStage{Status: "failed"}
+				} else {
+					result.Cases[i].IRTextGeneration = scanEvidenceStage{Status: "failed"}
+				}
+			}
+			return result, err
+		}
+		result.ObjectBatches = append(result.ObjectBatches, batch)
+		for i := start; i < end; i++ {
+			one := 1
+			result.Cases[i].IRTextGeneration = scanEvidenceStage{Status: "pass", Forms: &one}
+			result.Cases[i].LLVMObjectCompilation = scanEvidenceStage{Status: "pass", Forms: &one}
+		}
+	}
+	return result, nil
+}
+
+func initializedContextLLC(name string) (string, error) {
+	if name == "" {
+		var err error
+		name, err = exec.LookPath("llc-22")
+		if err != nil {
+			name, err = exec.LookPath("llc")
+		}
+		if err != nil {
+			return "", fmt.Errorf("LLVM22 llc is required: %w", err)
+		}
+	}
+	path, err := exec.LookPath(name)
+	if err != nil {
+		return "", fmt.Errorf("LLVM22 llc %q: %w", name, err)
+	}
+	return filepath.Abs(path)
+}
+
+// Observe owns and joins the actual process tree, preserves separate streams,
+// and bounds each stream at 4 MiB. No retry or compiler-version fallback occurs.
+func initializedContextCommand(command string, args ...string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	return goasmcmd.Run(ctx, "", os.Environ(), command, args...)
+}
+
+func compileInitializedContextBatch(cases []initializedContextCase, goarch, llc string, start int) (batch initializedContextObject, resultErr error) {
+	file := &plan9asm.File{Arch: plan9asm.ArchAMD64}
+	sigs := make(map[string]plan9asm.FuncSig)
+	for index := range cases {
+		batch.CaseIndexes = append(batch.CaseIndexes, start+index)
+	}
+	for index, test := range cases {
+		sequence := append(append([]plan9asm.Instr(nil), test.Initialization...), test.OriginalInstruction)
+		if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, goarch, sequence); err != nil {
+			return batch, fmt.Errorf("initialized context %s/%s/%d: %w", test.Source.File, test.Source.Function, test.Source.InstructionIndex, err)
+		}
+		name := fmt.Sprintf("initialized.mask.%d", start+index)
+		sequence = append(sequence, plan9asm.Instr{Op: "RET", Raw: "RET"})
+		file.Funcs = append(file.Funcs, plan9asm.Func{Sym: name, Instrs: sequence})
+		sigs[name] = plan9asm.FuncSig{Name: name, Ret: plan9asm.Void}
+	}
+	triple, machine, class := "x86_64-unknown-linux-gnu", elf.EM_X86_64, elf.ELFCLASS64
+	if goarch == "386" {
+		triple, machine, class = "i386-unknown-linux-gnu", elf.EM_386, elf.ELFCLASS32
+	}
+	ir, err := plan9asm.Translate(file, plan9asm.Options{Goarch: goarch, TargetTriple: triple, Sigs: sigs})
+	if err != nil {
+		return batch, fmt.Errorf("initialized-context LLVM IR: %w", err)
+	}
+	if len(ir) == 0 || len(ir) > 4<<20 {
+		return batch, fmt.Errorf("initialized-context LLVM IR size %d exceeds nonempty 4 MiB bound", len(ir))
+	}
+	for i := range cases {
+		one := 1
+		cases[i].IRTextGeneration = scanEvidenceStage{Status: "pass", Forms: &one}
+	}
+	dir, err := os.MkdirTemp("", "plan9asmscan-initialized-context-")
+	if err != nil {
+		return batch, err
+	}
+	defer func() { resultErr = errors.Join(resultErr, os.RemoveAll(dir)) }()
+	input, output := filepath.Join(dir, "batch.ll"), filepath.Join(dir, "batch.o")
+	if err := os.WriteFile(input, []byte(ir), 0o600); err != nil {
+		return batch, err
+	}
+	batch.Command = []string{llc, "-O0", "-filetype=obj", "-mtriple=" + triple, input, "-o", output}
+	if _, err := initializedContextCommand(llc, batch.Command[1:]...); err != nil {
+		return batch, fmt.Errorf("initialized-context LLVM object compilation: %w", err)
+	}
+	info, err := os.Lstat(output)
+	if err != nil {
+		return batch, fmt.Errorf("initialized-context LLVM object is missing: %w", err)
+	}
+	if !info.Mode().IsRegular() || info.Size() <= 0 || info.Size() > 16<<20 {
+		return batch, fmt.Errorf("initialized-context LLVM object must be a nonempty regular file within 16 MiB")
+	}
+	object, err := os.Open(output)
+	if err != nil {
+		return batch, err
+	}
+	data, readErr := io.ReadAll(io.LimitReader(object, (16<<20)+1))
+	if err := errors.Join(readErr, object.Close()); err != nil {
+		return batch, err
+	}
+	if len(data) == 0 || len(data) > 16<<20 {
+		return batch, fmt.Errorf("initialized-context LLVM object changed beyond its size bound")
+	}
+	parsed, err := elf.NewFile(bytes.NewReader(data))
+	if err != nil {
+		return batch, fmt.Errorf("initialized-context LLVM output is not an ELF object: %w", err)
+	}
+	if parsed.Type != elf.ET_REL || parsed.Machine != machine || parsed.Class != class {
+		return batch, fmt.Errorf("initialized-context LLVM object has a foreign target/type")
+	}
+	batch.ObjectSize, batch.ObjectSHA256 = int64(len(data)), fmt.Sprintf("%x", sha256.Sum256(data))
+	batch.Status = "pass"
+	return batch, nil
+}
diff --git a/cmd/plan9asmscan/initialized_context_reprobe_test.go b/cmd/plan9asmscan/initialized_context_reprobe_test.go
new file mode 100644
index 000000000..7bce4007d
--- /dev/null
+++ b/cmd/plan9asmscan/initialized_context_reprobe_test.go
@@ -0,0 +1,339 @@
+package main
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// Only go-list transport is synthetic. Parsing, isolated/context probes and
+// LLVM22 object compilation in the positive test are the actual implementations.
+// No fixture below supplies an executed-instruction or original-Go certificate.
+func init() {
+	if os.Getenv("PLAN9ASMSCAN_REPROBE_TEST_PROCESS") != "1" {
+		return
+	}
+	switch strings.TrimSuffix(filepath.Base(os.Args[0]), ".exe") {
+	case "go":
+		if !reflect.DeepEqual(os.Args[1:], []string{"list", "-json", "std"}) {
+			fmt.Fprintln(os.Stderr, "unexpected fixture go command", os.Args[1:])
+			os.Exit(2)
+		}
+		fmt.Println(os.Getenv("PLAN9ASMSCAN_REPROBE_TEST_PACKAGE"))
+		os.Exit(0)
+	case "reprobe-llc-fixture":
+		version := "22.1.8"
+		if os.Getenv("PLAN9ASMSCAN_REPROBE_TEST_LLC") == "wrong-version" {
+			version = "23.1.0"
+		}
+		if len(os.Args) == 2 && os.Args[1] == "--version" {
+			fmt.Println("LLVM version " + version)
+			os.Exit(0)
+		}
+		if os.Getenv("PLAN9ASMSCAN_REPROBE_TEST_LLC") == "nonzero" {
+			fmt.Fprintln(os.Stderr, "deliberate object compiler failure")
+			os.Exit(7)
+		}
+		// A successful exit with no object must not become compilation evidence.
+		os.Exit(0)
+	default:
+		var args []string
+		if err := json.Unmarshal([]byte(os.Getenv("PLAN9ASMSCAN_REPROBE_TEST_ARGS")), &args); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(2)
+		}
+		os.Args = append([]string{"plan9asmscan"}, args...)
+		flag.CommandLine = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
+		main()
+		os.Exit(0)
+	}
+}
+
+type initializedReprobeTestCase struct {
+	OriginalInstruction plan9asm.Instr `json:"original_instruction"`
+	OriginalStatus      string         `json:"original_status"`
+	Source              struct {
+		File             string `json:"file"`
+		Function         string `json:"function"`
+		InstructionIndex int    `json:"instruction_index"`
+	} `json:"source"`
+	Initialization        []plan9asm.Instr  `json:"initialization"`
+	IRTextGeneration      scanEvidenceStage `json:"ir_text_generation"`
+	LLVMObjectCompilation scanEvidenceStage `json:"llvm_object_compilation"`
+	RuntimeExecution      scanEvidenceStage `json:"runtime_execution"`
+}
+
+type initializedReprobeTestReport struct {
+	Profile           string                       `json:"profile"`
+	EligibleCases     int                          `json:"eligible_cases"`
+	Cases             []initializedReprobeTestCase `json:"cases"`
+	UnregisteredCases []initializedReprobeTestCase `json:"unregistered_cases"`
+	ObjectBatches     []struct {
+		CaseIndexes  []int  `json:"case_indexes"`
+		ObjectSize   int64  `json:"object_size"`
+		ObjectSHA256 string `json:"object_sha256"`
+	} `json:"object_batches"`
+}
+
+func initializedReprobeTestFixture(t *testing.T) (string, pkgJSON, map[string]plan9asm.Instr) {
+	t.Helper()
+	root := t.TempDir()
+	dir := filepath.Join(root, "src", "maskfixture")
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	var instructions []string
+	// This independent oracle is the complete existing 8 x 4 typed family.
+	for _, stem := range []string{"KAND", "KANDN", "KOR", "KXNOR", "KXOR", "KNOT", "KTEST", "KORTEST"} {
+		for _, suffix := range []string{"B", "W", "D", "Q"} {
+			args := "K0,K7,K3"
+			if stem == "KNOT" {
+				args = "K0,K3"
+			} else if strings.Contains(stem, "TEST") {
+				args = "K0,K7"
+			}
+			instructions = append(instructions, stem+suffix+" "+args)
+		}
+	}
+	// More concrete cases than the three display Examples, including a repeated
+	// instruction in a distinct owner. Source occurrences must not disappear.
+	instructions = append(instructions,
+		"KANDQ K0,K1,K2", "KANDQ K2,K3,K4", "KANDQ K4,K5,K6",
+		"KANDQ K7,K6,K0", "KANDQ K0,K7,K3",
+	)
+	var source strings.Builder
+	for i, instruction := range instructions {
+		fmt.Fprintf(&source, "TEXT ·Case%02d(SB),4,$0-0\n\t%s\n\tRET\n\n", i, instruction)
+	}
+	// An unrelated context-required family is not initialized by this profile.
+	source.WriteString("TEXT ·Other(SB),4,$0-0\n\tDIVL BX\n\tRET\n")
+	// Same-source constants already have sufficient numerical inputs. A mixed
+	// form-level classification must not hide its other context-required cases.
+	source.WriteString("TEXT ·Constant(SB),4,$0-0\n\tKXORQ K1,K1,K3\n\tRET\n")
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != len(instructions)+2 {
+		t.Fatal("fixture lost a complete source owner", len(file.Funcs))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		other := file.Funcs[len(instructions)].Instrs[1]
+		if err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, other); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("unregistered fixture must need initialized division inputs on %s: %v", arch, err)
+		}
+	}
+	want := make(map[string]plan9asm.Instr)
+	for _, fn := range file.Funcs[:len(instructions)] {
+		if len(fn.Instrs) != 3 || fn.Instrs[0].Op != "TEXT" || fn.Instrs[2].Op != "RET" {
+			t.Fatal("fixture instruction locator changed", fn)
+		}
+		want[fn.Sym] = fn.Instrs[1]
+	}
+	if len(want) != 37 {
+		t.Fatalf("fixture has %d owners, want 32 rows + 5 occurrence controls", len(want))
+	}
+	if err := os.WriteFile(filepath.Join(dir, "fixture.s"), []byte(source.String()), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(root, "VERSION"), []byte("go1.27.2-synthetic-list-fixture\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	goName := "go"
+	if filepath.Ext(os.Args[0]) == ".exe" {
+		goName += ".exe"
+	}
+	initializedReprobeTestLink(t, filepath.Join(root, "bin", goName))
+	return root, pkgJSON{ImportPath: "maskfixture", Dir: dir, SFiles: []string{"fixture.s"}}, want
+}
+
+func initializedReprobeTestLink(t *testing.T, target string) {
+	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(target), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Link(os.Args[0], target); err != nil {
+		t.Fatal("link test-only transport executable", err)
+	}
+}
+
+func initializedReprobeTestRun(t *testing.T, root string, pkg pkgJSON, arch, llc, mode string, profile bool) (map[string]json.RawMessage, []byte, error) {
+	t.Helper()
+	args := []string{"-corpus=std", "-format=json", "-goos=linux", "-goarch=" + arch,
+		"-repo-root=../..", "-goroot=" + root}
+	if profile {
+		args = append(args, "-initialized-context-reprobe=mask-logical", "-llc="+llc)
+	}
+	argsJSON, err := json.Marshal(args)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkgData, err := json.Marshal(pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := append(os.Environ(), "PLAN9ASMSCAN_REPROBE_TEST_PROCESS=1",
+		"PLAN9ASMSCAN_REPROBE_TEST_ARGS="+string(argsJSON),
+		"PLAN9ASMSCAN_REPROBE_TEST_PACKAGE="+string(pkgData),
+		"PLAN9ASMSCAN_REPROBE_TEST_LLC="+mode)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	observed, runErr := goasmcmd.Observe(ctx, "", env, os.Args[0])
+	var report map[string]json.RawMessage
+	if runErr == nil {
+		if err := json.Unmarshal(observed.Stdout, &report); err != nil {
+			t.Fatalf("scanner did not emit a complete JSON report: %v\n%s\n%s", err, observed.Stdout, observed.Stderr)
+		}
+	}
+	return report, observed.Stderr, runErr
+}
+
+func TestInitializedContextReprobeMaskLogicalExactSourcesAndObjects(t *testing.T) {
+	llc, err := exec.LookPath("llc-22")
+	if err != nil {
+		llc, err = exec.LookPath("llc")
+	}
+	if err != nil {
+		t.Fatal("LLVM22 is required for actual initialized-context object evidence", err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			root, pkg, want := initializedReprobeTestFixture(t)
+			baseline, stderr, err := initializedReprobeTestRun(t, root, pkg, arch, "", "", false)
+			if err != nil {
+				t.Fatalf("original classification: %v\n%s", err, stderr)
+			}
+			if _, ok := baseline["initialized_context_reprobe"]; ok {
+				t.Fatal("default scan unexpectedly opted into initialized-context evidence")
+			}
+			actual, stderr, err := initializedReprobeTestRun(t, root, pkg, arch, llc, "", true)
+			if err != nil {
+				t.Fatalf("explicit initialized mask-logical profile: %v\n%s", err, stderr)
+			}
+			var evidence initializedReprobeTestReport
+			if err := json.Unmarshal(actual["initialized_context_reprobe"], &evidence); err != nil {
+				t.Fatal("missing independent initialized-context evidence", err)
+			}
+			delete(actual, "initialized_context_reprobe")
+			if !reflect.DeepEqual(actual, baseline) {
+				t.Fatal("counterfactual reprobe changed original report/classifications/fingerprints")
+			}
+			if evidence.Profile != "mask-logical" || evidence.EligibleCases != len(want) || len(evidence.Cases) != len(want) {
+				t.Fatalf("profile denominator = %s/%d/%d, want mask-logical/%d/%d", evidence.Profile,
+					evidence.EligibleCases, len(evidence.Cases), len(want), len(want))
+			}
+			seen := make(map[string]bool)
+			for _, test := range evidence.Cases {
+				instruction, ok := want[test.Source.Function]
+				if !ok || seen[test.Source.Function] || test.Source.File != "maskfixture/fixture.s" || test.Source.InstructionIndex != 1 {
+					t.Fatalf("missing, duplicate or foreign source locator: %+v", test.Source)
+				}
+				seen[test.Source.Function] = true
+				if !reflect.DeepEqual(test.OriginalInstruction, instruction) || test.OriginalStatus != "context-required" {
+					t.Fatalf("original concrete instruction/status changed: %+v", test)
+				}
+				if err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, instruction); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatal("fixture no longer independently requires context", instruction, err)
+				}
+				sequence := append(append([]plan9asm.Instr(nil), test.Initialization...), instruction)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, sequence); err != nil {
+					t.Fatal("recorded initialization is not actually sufficient", instruction, err)
+				}
+				initializedReprobeTestInputs(t, arch, test)
+				for _, stage := range []scanEvidenceStage{test.IRTextGeneration, test.LLVMObjectCompilation} {
+					if stage.Status != "pass" || stage.Forms == nil || *stage.Forms != 1 {
+						t.Fatalf("missing per-case IR/object evidence: %+v", test)
+					}
+				}
+				if test.RuntimeExecution.Status != "not_run" || test.RuntimeExecution.Forms != nil {
+					t.Fatal("IR/object reprobe invented runtime evidence", test.RuntimeExecution)
+				}
+			}
+			if len(evidence.UnregisteredCases) != 1 {
+				t.Fatal("unregistered precise context source was discarded", evidence.UnregisteredCases)
+			}
+			other := evidence.UnregisteredCases[0]
+			wantOther := compactProbeInstructions(t, "DIVL BX")[0]
+			if other.Source.File != "maskfixture/fixture.s" || other.Source.Function != "·Other" || other.Source.InstructionIndex != 1 ||
+				!reflect.DeepEqual(other.OriginalInstruction, wantOther) || other.OriginalStatus != "context-required" || len(other.Initialization) != 0 {
+				t.Fatalf("unregistered context acquired synthetic input authority: %+v", other)
+			}
+			for _, stage := range []scanEvidenceStage{other.IRTextGeneration, other.LLVMObjectCompilation, other.RuntimeExecution} {
+				if stage.Status != "not_run" || stage.Forms != nil {
+					t.Fatal("unregistered context acquired reprobe evidence", stage)
+				}
+			}
+			covered := make(map[int]bool)
+			for _, batch := range evidence.ObjectBatches {
+				digest, err := hex.DecodeString(batch.ObjectSHA256)
+				if len(batch.CaseIndexes) == 0 || len(batch.CaseIndexes) > 32 || batch.ObjectSize <= 0 || err != nil || len(digest) != 32 {
+					t.Fatalf("missing actual bounded object artifact: %+v", batch)
+				}
+				for _, index := range batch.CaseIndexes {
+					if index < 0 || index >= len(want) || covered[index] {
+						t.Fatalf("duplicate/foreign compiled case index %d", index)
+					}
+					covered[index] = true
+				}
+			}
+			if len(covered) != len(want) {
+				t.Fatalf("compiled %d/%d concrete source occurrences", len(covered), len(want))
+			}
+		})
+	}
+}
+
+func initializedReprobeTestInputs(t *testing.T, arch string, test initializedReprobeTestCase) {
+	t.Helper()
+	inputs := test.OriginalInstruction.Args[:2]
+	if strings.HasPrefix(string(test.OriginalInstruction.Op), "KNOT") {
+		inputs = inputs[:1]
+	}
+	if len(test.Initialization) != 1+len(inputs) || test.Initialization[0].Raw != "MOVL $3,AX" {
+		t.Fatal("profile did not retain a minimal explicit synthetic initialization", test.Initialization)
+	}
+	for i, input := range inputs {
+		setup := test.Initialization[i+1]
+		if setup.Op != "KMOVD" || len(setup.Args) != 2 || setup.Args[0].Reg != "AX" || setup.Args[1].Reg != input.Reg {
+			t.Fatal("initializer broadened or omitted actual mask inputs", setup, input)
+		}
+		missing := append([]plan9asm.Instr(nil), test.Initialization[:i+1]...)
+		missing = append(missing, test.Initialization[i+2:]...)
+		missing = append(missing, test.OriginalInstruction)
+		if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, missing); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatal("removing an actual input initializer must retain context rejection", err)
+		}
+	}
+}
+
+func TestInitializedContextReprobeDoesNotCreditBrokenLLVM(t *testing.T) {
+	for _, mode := range []string{"missing", "wrong-version", "no-object", "nonzero"} {
+		t.Run(mode, func(t *testing.T) {
+			root, pkg, _ := initializedReprobeTestFixture(t)
+			llc := filepath.Join(t.TempDir(), "reprobe-llc-fixture")
+			if filepath.Ext(os.Args[0]) == ".exe" {
+				llc += ".exe"
+			}
+			if mode != "missing" {
+				initializedReprobeTestLink(t, llc)
+			}
+			_, stderr, err := initializedReprobeTestRun(t, root, pkg, "amd64", llc, mode, true)
+			if err == nil || !strings.Contains(strings.ToLower(string(stderr)), "llvm") || strings.Contains(string(stderr), "flag provided but not defined") {
+				t.Fatalf("LLVM %s must fail closed, not report a profile pass: %v\n%s", mode, err, stderr)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmscan/inlane_permute_context_test.go b/cmd/plan9asmscan/inlane_permute_context_test.go
new file mode 100644
index 000000000..47c7b7605
--- /dev/null
+++ b/cmd/plan9asmscan/inlane_permute_context_test.go
@@ -0,0 +1,62 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestInLanePermuteCoverageRetainsActualInputsAndVoidReads(t *testing.T) {
+	testElementPermuteCoverageInputs(t, []string{"VPERMILPS", "VPERMILPD"}, []string{"X", "Y", "Z"})
+}
+
+func TestQwordPermuteCoverageRetainsActualInputsAndVoidReads(t *testing.T) {
+	testElementPermuteCoverageInputs(t, []string{"VPERMQ", "VPERMPD"}, []string{"Y", "Z"})
+}
+
+func testElementPermuteCoverageInputs(t *testing.T, members, banks []string) {
+	t.Helper()
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range members {
+			for _, bank := range banks {
+				for _, immediate := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/immediate=%t", arch, op, bank, immediate), func(t *testing.T) {
+						zero := "VPXOR"
+						if bank == "Z" {
+							zero = "VPXORD"
+						}
+						var prefix strings.Builder
+						for register := 0; register < 3; register++ {
+							fmt.Fprintf(&prefix, "%s %s%d,%s%d,%s%d\n", zero, bank, register, bank, register, bank, register)
+						}
+						operands, memory := bank+"0,"+bank+"1", "(AX),"+bank+"1"
+						if immediate {
+							operands, memory = "$0x1b,"+bank+"1", "$0x1b,(AX)"
+						}
+						row := op + " " + operands + "," + bank + "2"
+						// A dead GP copy may correctly remain unknown. TEST
+						// consumes its value and SETEQ consumes the resulting ZF,
+						// as in the existing IFMA and AES scanner controls.
+						observed := row + "\nMOVL X2,AX\nTESTL AX,AX\nSETEQ CX"
+						valueProbeNeedsContext(t, arch, observed)
+						if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+							compactProbeInstructions(t, prefix.String()+observed)); err != nil {
+							t.Fatal("complete register data/selector input rejected", err)
+						}
+						// Unknown address bits remain Context; a defined zero can
+						// produce only the paired native access and its fault.
+						native := op + " " + memory + "," + bank + "2"
+						valueProbeNeedsContext(t, arch, prefix.String()+native)
+						valueProbePairedNumericAddress(t, arch, prefix.String()+"MOVL $0,AX\n"+native)
+						if arch == "amd64" {
+							masked := op + ".BCST.Z " + memory + ",K1," + bank + "2"
+							valueProbePairedNumericAddress(t, arch, prefix.String()+"MOVL $0,AX\nKMOVD AX,K1\n"+masked)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/logical_compare_context_test.go b/cmd/plan9asmscan/logical_compare_context_test.go
new file mode 100644
index 000000000..d47b2965d
--- /dev/null
+++ b/cmd/plan9asmscan/logical_compare_context_test.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestIntegerSelfCompareCoverageNeedsNoVectorInput(t *testing.T) {
+	comparisons := strings.Fields("PCMPEQB PCMPEQW PCMPEQL PCMPEQQ PCMPGTB PCMPGTW PCMPGTL PCMPGTQ")
+	immediate := strings.Fields("VPCMPB VPCMPW VPCMPD VPCMPQ VPCMPUB VPCMPUW VPCMPUD VPCMPUQ")
+	for _, arch := range []string{"386", "amd64"} {
+		check := func(t *testing.T, row string) {
+			t.Helper()
+			if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+				compactProbeInstructions(t, row)); err != nil {
+				t.Fatal("self-initializing integer comparison requires no incoming vector bits", arch, row, err)
+			}
+		}
+		for _, op := range comparisons {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				check(t, op+" X6,X6")
+				vector := "V" + strings.ReplaceAll(op, "L", "D")
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if bank != "Z" {
+						check(t, fmt.Sprintf("%s %s6,%s6,%s2", vector, bank, bank, bank))
+					}
+					check(t, fmt.Sprintf("%s %s6,%s6,K0", vector, bank, bank))
+					if arch == "amd64" {
+						masked := fmt.Sprintf("%s %s6,%s6,K1,K1", vector, bank, bank)
+						valueProbeNeedsContext(t, arch, masked)
+						check(t, "MOVL $85,AX\nKMOVD AX,K1\n"+masked)
+					}
+				}
+			})
+		}
+		if arch == "amd64" {
+			for _, op := range immediate {
+				t.Run(arch+"/"+op, func(t *testing.T) {
+					for _, bank := range []string{"X", "Y", "Z"} {
+						check(t, fmt.Sprintf("%s $0,%s6,%s6,K0", op, bank, bank))
+						valueProbeNeedsContext(t, arch, fmt.Sprintf("%s $0,%s5,%s6,K0", op, bank, bank))
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestLogicalCompareCoverageRequiresNativeInputContext(t *testing.T) {
+	names := strings.Fields("PCMPEQB PCMPEQW PCMPEQL PCMPEQQ PCMPGTB PCMPGTW PCMPGTL PCMPGTQ " +
+		"VPCMPEQB VPCMPEQW VPCMPEQD VPCMPEQQ VPCMPGTB VPCMPGTW VPCMPGTD VPCMPGTQ " +
+		"ANDPS ANDPD PAND VANDPS VANDPD VPAND VPANDD VPANDQ " +
+		"ANDNPS ANDNPD PANDN VANDNPS VANDNPD VPANDN VPANDND VPANDNQ " +
+		"ORPS ORPD POR VORPS VORPD VPOR VPORD VPORQ " +
+		"XORPS XORPD PXOR VXORPS VXORPD VPXOR VPXORD VPXORQ")
+	if len(names) != 48 {
+		t.Fatal("complete independent logical/compare inventory changed", len(names))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range names {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				memory, registers := op+" 3(AX)(DX*2),X1", op+" X0,X1"
+				if strings.HasPrefix(op, "V") {
+					memory, registers = op+" 3(AX)(DX*2),X1,X2", op+" X0,X1,X2"
+				}
+				valueProbeNeedsContext(t, arch, memory)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "VZEROALL\n"+registers)); err != nil {
+					t.Fatal("initialized registers became unsupported while checking native context", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/main.go b/cmd/plan9asmscan/main.go
index b6bb6c903..e217e162f 100644
--- a/cmd/plan9asmscan/main.go
+++ b/cmd/plan9asmscan/main.go
@@ -7,6 +7,9 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
 	"io"
 	"os"
 	"os/exec"
@@ -14,9 +17,11 @@ import (
 	"regexp"
 	"runtime"
 	"sort"
+	"strconv"
 	"strings"
 
 	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
 )
 
 type pkgJSON struct {
@@ -41,6 +46,8 @@ type formStat struct {
 	UnsupportedCount int
 	Errors           map[string]int
 	ProbeKeys        map[string]struct{}
+	contextResults   map[string]error
+	contextSources   []initializedContextCase
 }
 
 type parseErr struct {
@@ -49,38 +56,72 @@ type parseErr struct {
 }
 
 type report struct {
-	Corpus               string `json:"corpus"`
-	GoVersion            string `json:"go_version"`
-	Goos                 string `json:"goos"`
-	Goarch               string `json:"goarch"`
-	StdPkgs              int    `json:"std_pkgs"`
-	StdPkgsWithSFile     int    `json:"std_pkgs_with_sfile"`
-	AsmFiles             int    `json:"asm_files"`
-	UniqueOps            int    `json:"unique_ops"`
-	ParseErrCount        int    `json:"parse_err_count"`
-	UniqueForms          int    `json:"unique_forms"`
-	SupportedForms       int    `json:"supported_forms"`
-	ContextForms         int    `json:"context_forms"`
-	UnsupportedForms     int    `json:"unsupported_forms"`
-	OfficialOpcodes      int    `json:"official_opcodes"`
-	RuntimeVerifiedForms int    `json:"runtime_verified_forms"`
-	CompileOnlyForms     int    `json:"compile_only_forms,omitempty"`
-	EncoderOpcodes       int    `json:"encoder_opcodes"`
-	EncoderForms         int    `json:"encoder_forms"`
-	EncoderOpsObserved   int    `json:"encoder_opcodes_observed_in_corpus"`
-	CoverageFingerprint  string `json:"coverage_fingerprint"`
-	EncoderFingerprint   string `json:"encoder_fingerprint"`
-
-	OpsByFreq         []opReport            `json:"ops_by_freq"`
-	ClusterStats      []clusterReport       `json:"cluster_stats"`
-	FamilyStats       []familyReport        `json:"unsupported_family_stats"`
-	FormFamilies      []formFamilyReport    `json:"form_family_stats"`
-	Forms             []formReport          `json:"forms"`
-	Unsupported       []opReport            `json:"unsupported"`
-	UnsupportedByForm []formReport          `json:"unsupported_by_form"`
-	OpcodeCatalog     []opcodeCatalogReport `json:"opcode_catalog,omitempty"`
-	EncoderCatalog    []encoderFormReport   `json:"encoder_form_catalog,omitempty"`
-	ParseErrs         []parseErr            `json:"parse_errs,omitempty"`
+	Corpus               string       `json:"corpus"`
+	GoVersion            string       `json:"go_version"`
+	Goos                 string       `json:"goos"`
+	Goarch               string       `json:"goarch"`
+	StdPkgs              int          `json:"std_pkgs"`
+	StdPkgsWithSFile     int          `json:"std_pkgs_with_sfile"`
+	AsmFiles             int          `json:"asm_files"`
+	UniqueOps            int          `json:"unique_ops"`
+	ParseErrCount        int          `json:"parse_err_count"`
+	UniqueForms          int          `json:"unique_forms"`
+	SupportedForms       int          `json:"supported_forms"`
+	ContextForms         int          `json:"context_forms"`
+	UnsupportedForms     int          `json:"unsupported_forms"`
+	OfficialOpcodes      int          `json:"official_opcodes"`
+	RuntimeVerifiedForms int          `json:"runtime_verified_forms"`
+	CompileOnlyForms     int          `json:"compile_only_forms,omitempty"`
+	EncoderOpcodes       int          `json:"encoder_opcodes"`
+	EncoderForms         int          `json:"encoder_forms"`
+	EncoderOpsObserved   int          `json:"encoder_opcodes_observed_in_corpus"`
+	CoverageFingerprint  string       `json:"coverage_fingerprint"`
+	EncoderFingerprint   string       `json:"encoder_fingerprint"`
+	EvidenceLevels       scanEvidence `json:"evidence_levels"`
+	// These fields count/fingerprint only retained encoding rules, currently
+	// x86 AVX. They do not certify all encoder tables or executed coverage.
+	EncoderRules           int    `json:"encoder_rules,omitempty"`
+	EncoderRuleFingerprint string `json:"encoder_rule_fingerprint,omitempty"`
+
+	LegacyEncoder *legacyEncoderReport `json:"legacy_encoder,omitempty"`
+
+	OpsByFreq                 []opReport                `json:"ops_by_freq"`
+	ClusterStats              []clusterReport           `json:"cluster_stats"`
+	FamilyStats               []familyReport            `json:"unsupported_family_stats"`
+	FormFamilies              []formFamilyReport        `json:"form_family_stats"`
+	Forms                     []formReport              `json:"forms"`
+	Unsupported               []opReport                `json:"unsupported"`
+	UnsupportedByForm         []formReport              `json:"unsupported_by_form"`
+	OpcodeCatalog             []opcodeCatalogReport     `json:"opcode_catalog,omitempty"`
+	EncoderCatalog            []encoderFormReport       `json:"encoder_form_catalog,omitempty"`
+	FrontendInventory         *frontendInventory        `json:"frontend_inventory,omitempty"`
+	ParseErrs                 []parseErr                `json:"parse_errs,omitempty"`
+	InitializedContextReprobe *initializedContextReport `json:"initialized_context_reprobe,omitempty"`
+}
+
+// Default scanning runs text-lowering probes, not object or execution tests.
+// An explicitly requested initialized-context profile records separate object
+// evidence; it never changes these original uninitialized-probe evidence levels.
+// The legacy runtime_verified/compile_only fields above are manifest matches,
+// not receipts for this invocation. Keep them for report compatibility.
+type scanEvidence struct {
+	IRTextGeneration      scanEvidenceStage `json:"ir_text_generation"`
+	LLVMObjectCompilation scanEvidenceStage `json:"llvm_object_compilation"`
+	RuntimeExecution      scanEvidenceStage `json:"runtime_execution"`
+}
+
+type scanEvidenceStage struct {
+	Status string `json:"status"`
+	Forms  *int   `json:"forms"` // null means not measured, rather than zero passes.
+}
+
+func probeEvidence(goarch string, accepted int) scanEvidence {
+	notRun := scanEvidenceStage{Status: "not_run"}
+	ir := scanEvidenceStage{Status: "probe", Forms: &accepted}
+	if goarch == "wasm" {
+		ir = notRun // WASM's isolated probe deliberately requires whole functions.
+	}
+	return scanEvidence{ir, notRun, notRun}
 }
 
 type opReport struct {
@@ -143,7 +184,6 @@ type conformanceManifest struct {
 }
 
 var (
-	reCaseClause = regexp.MustCompile(`case\s+([^:]+):`)
 	reOpcodeName = regexp.MustCompile("(?m)^\\s*(?:obj\\.A_ARCHSPECIFIC:\\s*)?\"([A-Z][A-Za-z0-9.]*)\",\\s*$")
 )
 
@@ -155,10 +195,28 @@ func main() {
 		format   = flag.String("format", "md", "output format: md|json")
 		repoRoot = flag.String("repo-root", ".", "plan9asm repository root for lowerers and conformance data")
 		corpus   = flag.String("corpus", "std", "corpus to scan: std|go-asm|arm64-plan9")
-		goroot   = flag.String("goroot", runtime.GOROOT(), "Go root containing official assembler testdata")
+		goroot   = flag.String("goroot", "", "Go root containing official assembler testdata (default: active Go toolchain)")
 		input    = flag.String("input", "", "input file for corpora that require one")
+		reprobe  = flag.String("initialized-context-reprobe", "", "optional counterfactual input profile: mask-logical (not original-source or runtime evidence)")
+		llc      = flag.String("llc", "", "LLVM22 llc executable for an explicitly enabled initialized-context reprobe")
 	)
 	flag.Parse()
+	if *reprobe != "" && (*reprobe != "mask-logical" || (*goarch != "386" && *goarch != "amd64")) {
+		fatalf("initialized-context-reprobe requires profile mask-logical and target 386/amd64")
+	}
+	if *reprobe != "" && *corpus != "std" && *corpus != "go-asm" {
+		fatalf("initialized-context-reprobe requires a std or go-asm corpus with exact x86 sources")
+	}
+	if *llc != "" && *reprobe == "" {
+		fatalf("-llc requires an explicit -initialized-context-reprobe profile")
+	}
+	if *goroot == "" {
+		root, err := gotoolchain.Root()
+		if err != nil {
+			fatalf("resolve active Go toolchain: %v", err)
+		}
+		*goroot = root
+	}
 
 	if *goarch != "386" && *goarch != "amd64" && *goarch != "arm64" && *goarch != "arm" && *goarch != "wasm" {
 		fatalf("unsupported -goarch %q (expect 386/amd64/arm64/arm/wasm)", *goarch)
@@ -181,11 +239,11 @@ func main() {
 	)
 	switch *corpus {
 	case "std":
-		pkgs, err = listStdPackages(*goos, *goarch)
+		pkgs, err = listStdPackagesAtGOROOT(*goos, *goarch, *goroot)
 		if err != nil {
 			fatalf("list std packages: %v", err)
 		}
-		ops, forms, parseErrs, pkgWithSFiles, asmFiles, err = scanPackages(pkgs, arch, *goarch)
+		ops, forms, parseErrs, pkgWithSFiles, asmFiles, err = scanPackagesWithContexts(pkgs, arch, *goarch, *goroot, *reprobe != "", plan9asm.GoAssemblerDefines(*goos, *goarch)...)
 	case "go-asm":
 		if *goarch == "wasm" {
 			// Go has no cmd/asm end-to-end testdata or operand-class encoder
@@ -194,10 +252,10 @@ func main() {
 			// comes from cmd/internal/obj/wasm below.
 			pkgs, err = listStdPackagesAtGOROOT(*goos, *goarch, *goroot)
 			if err == nil {
-				ops, forms, parseErrs, pkgWithSFiles, asmFiles, err = scanPackages(pkgs, arch, *goarch)
+				ops, forms, parseErrs, pkgWithSFiles, asmFiles, err = scanPackages(pkgs, arch, *goarch, *goroot, plan9asm.GoAssemblerDefines(*goos, *goarch)...)
 			}
 		} else {
-			ops, forms, parseErrs, asmFiles, err = scanGoAssemblerTestdata(*goroot, arch, *goarch)
+			ops, forms, parseErrs, asmFiles, err = scanGoAssemblerTestdataWithContexts(*goroot, arch, *goarch, *reprobe != "")
 		}
 	case "arm64-plan9":
 		if strings.TrimSpace(*input) == "" {
@@ -218,7 +276,12 @@ func main() {
 
 	var catalog []opcodeCatalogReport
 	var encoderCatalog []encoderFormReport
+	var frontend *frontendInventory
 	if *corpus == "go-asm" {
+		frontend, err = loadFrontendInventory(*goroot, *goarch)
+		if err != nil {
+			fatalf("load Go assembler frontend inventory: %v", err)
+		}
 		encoderCatalog, err = loadEncoderForms(*goroot, *goarch)
 		if err != nil {
 			fatalf("load official encoder forms: %v", err)
@@ -234,6 +297,14 @@ func main() {
 	}
 	rep := buildReport(*corpus, goVersion(*goroot), *goos, *goarch, len(pkgs), pkgWithSFiles, asmFiles, ops, forms, supported, catalog, verified, compileOnly, parseErrs)
 	attachEncoderCatalog(&rep, ops, encoderCatalog)
+	if err := attachLegacyEncoderCatalog(&rep, *goroot); err != nil {
+		fatalf("load Go legacy encoder inventory: %v", err)
+	}
+	rep.FrontendInventory = frontend
+	var reprobeErr error
+	if *reprobe != "" {
+		rep.InitializedContextReprobe, reprobeErr = runInitializedContextReprobe(forms, *goarch, *llc)
+	}
 
 	var content []byte
 	switch strings.ToLower(strings.TrimSpace(*format)) {
@@ -251,11 +322,17 @@ func main() {
 
 	if *out == "" {
 		_, _ = os.Stdout.Write(content)
+		if reprobeErr != nil {
+			fatalf("initialized context LLVM reprobe: %v", reprobeErr)
+		}
 		return
 	}
 	if err := os.WriteFile(*out, content, 0644); err != nil {
 		fatalf("write %s: %v", *out, err)
 	}
+	if reprobeErr != nil {
+		fatalf("initialized context LLVM reprobe: %v", reprobeErr)
+	}
 }
 
 func validateCorpusTarget(corpus, goarch string) error {
@@ -332,7 +409,11 @@ func listStdPackagesWithCommand(goCommand, goos, goarch string, extraEnv []strin
 	return outPkgs, nil
 }
 
-func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch string) (map[string]*opStat, map[string]*formStat, []parseErr, int, int, error) {
+func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch, goRoot string, defines ...string) (map[string]*opStat, map[string]*formStat, []parseErr, int, int, error) {
+	return scanPackagesWithContexts(pkgs, arch, goarch, goRoot, false, defines...)
+}
+
+func scanPackagesWithContexts(pkgs []pkgJSON, arch plan9asm.Arch, goarch, goRoot string, contexts bool, defines ...string) (map[string]*opStat, map[string]*formStat, []parseErr, int, int, error) {
 	ops := map[string]*opStat{}
 	forms := map[string]*formStat{}
 	var parseErrs []parseErr
@@ -349,14 +430,14 @@ func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch string) (map[string
 		}
 		pkgWithSFiles++
 		for _, path := range sfiles {
-			src, err := os.ReadFile(path)
+			src, err := plan9asm.ReadGoAssemblySourceAtGOROOT(path, p.Dir, goRoot)
 			if err != nil {
 				return nil, nil, nil, 0, 0, fmt.Errorf("read %s: %w", path, err)
 			}
 			asmFiles++
-			rel := shortStdPath(path)
+			rel := shortStdPath(path, goRoot)
 
-			file, err := plan9asm.Parse(arch, string(src))
+			file, err := plan9asm.ParseWithDefines(arch, string(src), defines)
 			if err != nil {
 				if strings.Contains(err.Error(), "no TEXT directive found") {
 					continue
@@ -365,26 +446,42 @@ func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch string) (map[string
 				continue
 			}
 			for _, fn := range file.Funcs {
-				for _, ins := range fn.Instrs {
+				for i := 0; i < len(fn.Instrs); {
+					ins := fn.Instrs[i]
 					if ins.Op == plan9asm.OpLABEL {
+						i++
+						continue
+					}
+					if isX86RawDirective(arch, ins) {
+						end := i + 1
+						for end < len(fn.Instrs) && isX86RawDirective(arch, fn.Instrs[end]) {
+							end++
+						}
+						sequence := fn.Instrs[i:end]
+						probeErr := plan9asm.ProbeInstructionSequence(arch, goarch, sequence)
+						probeKey := instructionSequenceProbeKey(sequence)
+						for offset, raw := range sequence {
+							addFormStatWithProbeResult(forms, arch, goarch, raw, rel, probeKey, probeErr)
+							if contexts {
+								captureContextSource(forms, arch, goarch, raw, initializedContextSource{File: rel, Function: fn.Sym, InstructionIndex: i + offset}, probeErr)
+							}
+							addOpStat(ops, string(raw.Op), rel, p.ImportPath, 1)
+						}
+						i = end
 						continue
 					}
 					nop := normalizeOp(string(ins.Op))
 					if nop == "" {
+						i++
 						continue
 					}
-					addFormStat(forms, arch, goarch, ins, rel)
-					s := ops[nop]
-					if s == nil {
-						s = &opStat{
-							Files: map[string]int{},
-							Pkgs:  map[string]int{},
-						}
-						ops[nop] = s
+					var source *initializedContextSource
+					if contexts {
+						source = &initializedContextSource{File: rel, Function: fn.Sym, InstructionIndex: i}
 					}
-					s.Count++
-					s.Files[rel]++
-					s.Pkgs[p.ImportPath]++
+					addFormStatWithSource(forms, arch, goarch, ins, rel, source)
+					addOpStat(ops, nop, rel, p.ImportPath, 1)
+					i++
 				}
 			}
 			if len(file.Data) > 0 {
@@ -392,6 +489,17 @@ func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch string) (map[string
 			}
 			if len(file.Globl) > 0 {
 				addOpStat(ops, "GLOBL", rel, p.ImportPath, len(file.Globl))
+				for _, global := range file.Globl {
+					if global.SizeRaw != "" {
+						addFormStat(forms, arch, goarch, plan9asm.Instr{
+							Op: "GLOBL", Raw: "GLOBL " + global.Sym + "(SB)," + global.SizeRaw,
+							Args: []plan9asm.Operand{
+								{Kind: plan9asm.OpSym, Sym: global.Sym + "(SB)"},
+								{Kind: plan9asm.OpImm, ImmRaw: global.SizeRaw},
+							},
+						}, rel)
+					}
+				}
 			}
 		}
 	}
@@ -399,9 +507,44 @@ func scanPackages(pkgs []pkgJSON, arch plan9asm.Arch, goarch string) (map[string
 }
 
 func addFormStat(forms map[string]*formStat, arch plan9asm.Arch, goarch string, ins plan9asm.Instr, file string) {
+	addFormStatWithSource(forms, arch, goarch, ins, file, nil)
+}
+
+func addFormStatWithSource(forms map[string]*formStat, arch plan9asm.Arch, goarch string, ins plan9asm.Instr, file string, source *initializedContextSource) {
+	probeKey := fmt.Sprintf("%s %#v", ins.Op, ins.Args)
+	st, fresh := prepareFormStat(forms, arch, goarch, ins, file, probeKey)
+	if st == nil {
+		return
+	}
+	if fresh {
+		probeErr := plan9asm.ProbeInstruction(arch, goarch, ins)
+		classifyFormProbe(st, probeErr)
+		if source != nil {
+			if st.contextResults == nil {
+				st.contextResults = make(map[string]error)
+			}
+			st.contextResults[probeKey] = probeErr
+		}
+	}
+	if source != nil {
+		if probeErr, ok := st.contextResults[probeKey]; ok {
+			captureContextSource(forms, arch, goarch, ins, *source, probeErr)
+		}
+	}
+}
+
+func addFormStatWithProbeResult(forms map[string]*formStat, arch plan9asm.Arch, goarch string, ins plan9asm.Instr, file, probeKey string, probeErr error) {
+	st, fresh := prepareFormStat(forms, arch, goarch, ins, file, probeKey)
+	if st == nil || !fresh {
+		return
+	}
+	classifyFormProbe(st, probeErr)
+}
+
+func prepareFormStat(forms map[string]*formStat, arch plan9asm.Arch, goarch string, ins plan9asm.Instr, file, probeKey string) (*formStat, bool) {
 	desc := plan9asm.DescribeInstruction(arch, goarch, ins)
 	if desc.Opcode == "" || desc.Opcode == string(plan9asm.OpLABEL) {
-		return
+		return nil, false
 	}
 	st := forms[desc.Form]
 	if st == nil {
@@ -421,12 +564,14 @@ func addFormStat(forms map[string]*formStat, arch plan9asm.Arch, goarch string,
 	// Descriptor forms intentionally collapse concrete register numbers and
 	// immediate values. Those values can still select different lowerer paths,
 	// so cache exact instructions and aggregate their outcomes into the form.
-	probeKey := fmt.Sprintf("%s %#v", ins.Op, ins.Args)
 	if _, ok := st.ProbeKeys[probeKey]; ok {
-		return
+		return st, false
 	}
 	st.ProbeKeys[probeKey] = struct{}{}
-	err := plan9asm.ProbeInstruction(arch, goarch, ins)
+	return st, true
+}
+
+func classifyFormProbe(st *formStat, err error) {
 	switch {
 	case err == nil:
 		st.SupportedCount++
@@ -440,7 +585,32 @@ func addFormStat(forms map[string]*formStat, arch plan9asm.Arch, goarch string,
 	}
 }
 
+func isX86RawDirective(arch plan9asm.Arch, ins plan9asm.Instr) bool {
+	if arch != plan9asm.ArchAMD64 {
+		return false
+	}
+	switch normalizeOp(string(ins.Op)) {
+	case "BYTE", "WORD", "LONG", "QUAD":
+		return true
+	default:
+		return false
+	}
+}
+
+func instructionSequenceProbeKey(instrs []plan9asm.Instr) string {
+	var b strings.Builder
+	b.WriteString("sequence")
+	for _, ins := range instrs {
+		fmt.Fprintf(&b, " %s %#v;", ins.Op, ins.Args)
+	}
+	return b.String()
+}
+
 func scanGoAssemblerTestdata(goroot string, arch plan9asm.Arch, goarch string) (map[string]*opStat, map[string]*formStat, []parseErr, int, error) {
+	return scanGoAssemblerTestdataWithContexts(goroot, arch, goarch, false)
+}
+
+func scanGoAssemblerTestdataWithContexts(goroot string, arch plan9asm.Arch, goarch string, contexts bool) (map[string]*opStat, map[string]*formStat, []parseErr, int, error) {
 	files, err := goAssemblerTestdataFiles(goroot, goarch)
 	if err != nil {
 		return nil, nil, nil, 0, err
@@ -478,7 +648,11 @@ func scanGoAssemblerTestdata(goroot string, arch plan9asm.Arch, goarch string) (
 						continue
 					}
 					addOpStat(ops, string(ins.Op), rel, "go-asm-testdata", 1)
-					addFormStat(forms, arch, goarch, ins, rel)
+					var source *initializedContextSource
+					if contexts {
+						source = &initializedContextSource{File: rel, Function: fn.Sym, InstructionIndex: i, Line: lineno + 1}
+					}
+					addFormStatWithSource(forms, arch, goarch, ins, rel, source)
 				}
 			}
 		}
@@ -598,42 +772,16 @@ func buildOpcodeCatalog(
 	forms map[string]*formStat,
 	claimed map[string]struct{},
 ) ([]opcodeCatalogReport, error) {
-	dir := goarch
-	if goarch == "386" || goarch == "amd64" {
-		dir = "x86"
-	}
-	pattern := filepath.Join(goroot, "src", "cmd", "internal", "obj", dir, "anames*.go")
-	files, err := filepath.Glob(pattern)
+	names, err := loadOfficialOpcodeNames(goroot, goarch)
 	if err != nil {
 		return nil, err
 	}
-	if len(files) == 0 {
-		return nil, fmt.Errorf("no official opcode tables match %s", pattern)
-	}
-	sort.Strings(files)
-	var names [][][]byte
-	for _, path := range files {
-		src, err := os.ReadFile(path)
-		if err != nil {
-			return nil, fmt.Errorf("read %s: %w", path, err)
-		}
-		names = append(names, reOpcodeName.FindAllSubmatch(src, -1)...)
-	}
 	out := make([]opcodeCatalogReport, 0, len(names))
-	seen := map[string]struct{}{}
 	formsByOpcode := make(map[string][]*formStat, len(forms))
 	for _, st := range forms {
 		formsByOpcode[st.Descriptor.Opcode] = append(formsByOpcode[st.Descriptor.Opcode], st)
 	}
-	for _, match := range names {
-		op := normalizeOp(string(match[1]))
-		if op == "" || op == "LAST" || strings.HasPrefix(op, "RESERVED") {
-			continue
-		}
-		if _, ok := seen[op]; ok {
-			continue
-		}
-		seen[op] = struct{}{}
+	for _, op := range names {
 		item := opcodeCatalogReport{
 			Opcode:   op,
 			Family:   plan9asm.InstructionFamily(arch, op),
@@ -757,74 +905,189 @@ func normalizeOp(op string) string {
 
 func extractSupportedOps(repoRoot, goarch string) (map[string]struct{}, error) {
 	supported := map[string]struct{}{
-		"RET":      {},
-		"TEXT":     {},
-		"GLOBL":    {},
-		"DATA":     {},
-		"BYTE":     {},
-		"WORD":     {},
-		"LONG":     {},
-		"QUAD":     {},
-		"PCALIGN":  {},
-		"FUNCDATA": {},
-		"PCDATA":   {},
-	}
-
-	seen := map[string]struct{}{}
-	var files []string
+		"RET":        {},
+		"TEXT":       {},
+		"GLOBL":      {},
+		"DATA":       {},
+		"BYTE":       {},
+		"WORD":       {},
+		"LONG":       {},
+		"QUAD":       {},
+		"PCALIGN":    {},
+		"PCALIGNMAX": {},
+		"FUNCDATA":   {},
+		"PCDATA":     {},
+	}
+
 	loweringArch := goarch
 	if loweringArch == "386" {
 		loweringArch = "amd64"
 	}
-	patterns := []string{
-		filepath.Join(repoRoot, loweringArch+"_*.go"),
-		filepath.Join(repoRoot, "parser.go"),
+	files, err := filepath.Glob(filepath.Join(repoRoot, loweringArch+"_*.go"))
+	if err != nil {
+		return nil, err
 	}
-	for _, pattern := range patterns {
-		matches, err := filepath.Glob(pattern)
-		if err != nil {
-			return nil, err
-		}
-		sort.Strings(matches)
-		for _, match := range matches {
-			if strings.HasSuffix(match, "_test.go") {
-				continue
-			}
-			if _, ok := seen[match]; ok {
-				continue
-			}
-			seen[match] = struct{}{}
-			files = append(files, match)
-		}
+	parserPath := filepath.Join(repoRoot, "parser.go")
+	if _, err := os.Stat(parserPath); err == nil {
+		files = append(files, parserPath)
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return nil, fmt.Errorf("stat %s: %w", parserPath, err)
 	}
+	sort.Strings(files)
 	for _, f := range files {
+		if strings.HasSuffix(f, "_test.go") {
+			continue
+		}
 		src, err := os.ReadFile(f)
 		if err != nil {
 			return nil, fmt.Errorf("read %s: %w", f, err)
 		}
-		for _, m := range reCaseClause.FindAllSubmatch(src, -1) {
-			items := strings.Split(string(m[1]), ",")
-			for _, item := range items {
-				item = strings.TrimSpace(item)
-				switch {
-				case strings.HasPrefix(item, "\"") && strings.HasSuffix(item, "\"") && len(item) >= 2:
-					if op := normalizeOp(strings.Trim(item, "\"")); op != "" {
-						supported[op] = struct{}{}
+		parsed, err := parser.ParseFile(token.NewFileSet(), f, src, 0)
+		if err != nil {
+			return nil, fmt.Errorf("parse %s for supported instructions: %w", f, err)
+		}
+		for _, decl := range parsed.Decls {
+			gen, ok := decl.(*ast.GenDecl)
+			if !ok || gen.Tok != token.VAR {
+				continue
+			}
+			for _, declared := range gen.Specs {
+				spec, ok := declared.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				for _, value := range spec.Values {
+					literal, ok := value.(*ast.CompositeLit)
+					if ok {
+						collectSupportedOpcodeMap(supported, literal)
 					}
-				case strings.HasPrefix(item, "Op"):
-					if op := normalizeOp(strings.TrimPrefix(item, "Op")); op != "" {
+				}
+			}
+		}
+		ast.Inspect(parsed, func(node ast.Node) bool {
+			// A single-family lowerer often starts with `if op != "VEXT"` rather
+			// than a switch. This is an implementation-backed support claim just
+			// like an opcode switch case. Only accept a literal compared directly
+			// with an identifier named op so unrelated strings cannot leak into
+			// the supported-instruction inventory.
+			if comparison, ok := node.(*ast.BinaryExpr); ok &&
+				(comparison.Op == token.EQL || comparison.Op == token.NEQ) {
+				if candidate, ok := opcodeComparedWithOp(comparison.X, comparison.Y); ok {
+					if op := normalizeOp(candidate); op != "" {
 						supported[op] = struct{}{}
 					}
 				}
 			}
-		}
+			if spec, ok := node.(*ast.ValueSpec); ok {
+				for i, name := range spec.Names {
+					if !strings.Contains(strings.ToLower(name.Name), "op") || len(spec.Values) == 0 {
+						continue
+					}
+					valueIndex := i
+					if len(spec.Values) == 1 {
+						valueIndex = 0
+					}
+					if valueIndex >= len(spec.Values) {
+						continue
+					}
+					literal, ok := spec.Values[valueIndex].(*ast.CompositeLit)
+					if !ok {
+						continue
+					}
+					mapType, isMap := literal.Type.(*ast.MapType)
+					keyType, stringKeyed := mapTypeKeyIdent(mapType)
+					if !isMap || !stringKeyed || keyType != "string" {
+						continue
+					}
+					collectSupportedOpcodeMap(supported, literal)
+				}
+			}
+			if literal, ok := node.(*ast.CompositeLit); ok {
+				mapType, isMap := literal.Type.(*ast.MapType)
+				keyType, opKeyed := mapTypeKeyIdent(mapType)
+				if isMap && opKeyed && keyType == "Op" {
+					collectSupportedOpcodeMap(supported, literal)
+				}
+			}
+			clause, ok := node.(*ast.CaseClause)
+			if !ok {
+				return true
+			}
+			for _, expr := range clause.List {
+				candidate := ""
+				switch value := expr.(type) {
+				case *ast.BasicLit:
+					if value.Kind == token.STRING {
+						candidate, _ = strconv.Unquote(value.Value)
+					}
+				case *ast.Ident:
+					if strings.HasPrefix(value.Name, "Op") {
+						candidate = strings.TrimPrefix(value.Name, "Op")
+					}
+				}
+				if op := normalizeOp(candidate); op != "" {
+					supported[op] = struct{}{}
+				}
+			}
+			return true
+		})
 	}
 	return supported, nil
 }
 
+func opcodeComparedWithOp(left, right ast.Expr) (string, bool) {
+	if ident, ok := left.(*ast.Ident); ok && ident.Name == "op" {
+		if literal, ok := right.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+			candidate, err := strconv.Unquote(literal.Value)
+			return candidate, err == nil
+		}
+	}
+	if ident, ok := right.(*ast.Ident); ok && ident.Name == "op" {
+		if literal, ok := left.(*ast.BasicLit); ok && literal.Kind == token.STRING {
+			candidate, err := strconv.Unquote(literal.Value)
+			return candidate, err == nil
+		}
+	}
+	return "", false
+}
+
+func collectSupportedOpcodeMap(supported map[string]struct{}, literal *ast.CompositeLit) {
+	mapType, isMap := literal.Type.(*ast.MapType)
+	keyType, supportedKey := mapTypeKeyIdent(mapType)
+	if !isMap || !supportedKey || keyType != "string" && keyType != "Op" {
+		return
+	}
+	for _, elt := range literal.Elts {
+		pair, ok := elt.(*ast.KeyValueExpr)
+		if !ok {
+			continue
+		}
+		key, ok := pair.Key.(*ast.BasicLit)
+		if !ok || key.Kind != token.STRING {
+			continue
+		}
+		candidate, _ := strconv.Unquote(key.Value)
+		if op := normalizeOp(candidate); op != "" {
+			supported[op] = struct{}{}
+		}
+	}
+}
+
+func mapTypeKeyIdent(mapType *ast.MapType) (string, bool) {
+	if mapType == nil {
+		return "", false
+	}
+	ident, ok := mapType.Key.(*ast.Ident)
+	if !ok {
+		return "", false
+	}
+	return ident.Name, true
+}
+
 func attachEncoderCatalog(rep *report, ops map[string]*opStat, catalog []encoderFormReport) {
 	rep.EncoderCatalog = catalog
 	rep.EncoderForms = len(catalog)
+	rep.EncoderRules, rep.EncoderRuleFingerprint = fingerprintEncoderRules(catalog)
 	opcodes := map[string]struct{}{}
 	observed := map[string]struct{}{}
 	byOpcode := map[string]int{}
@@ -885,7 +1148,13 @@ func buildReport(
 
 	all := []opReport{}
 	unsupported := []opReport{}
-	for op, st := range ops {
+	opNames := make([]string, 0, len(ops))
+	for op := range ops {
+		opNames = append(opNames, op)
+	}
+	sort.Strings(opNames)
+	for _, op := range opNames {
+		st := ops[op]
 		cl := clusterOf(goarch, op)
 		files := topFiles(st.Files, 4)
 		item := opReport{
@@ -1043,6 +1312,7 @@ func buildReport(
 	}
 	sort.Strings(fingerprintEntries)
 	rep.CoverageFingerprint = fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(fingerprintEntries, "\n"))))
+	rep.EvidenceLevels = probeEvidence(goarch, rep.SupportedForms)
 	return rep
 }
 
@@ -1056,11 +1326,11 @@ func renderMarkdown(rep report) []byte {
 	fmt.Fprintf(&b, "- asm files scanned: `%d`\n", rep.AsmFiles)
 	fmt.Fprintf(&b, "- unique ops: `%d`\n", rep.UniqueOps)
 	fmt.Fprintf(&b, "- unique operand forms: `%d`\n", rep.UniqueForms)
-	fmt.Fprintf(&b, "- form lowering: `%d` supported, `%d` context-required, `%d` unsupported\n",
+	fmt.Fprintf(&b, "- form probe classification: `%d` accepted, `%d` context-required, `%d` unsupported\n",
 		rep.SupportedForms, rep.ContextForms, rep.UnsupportedForms)
-	fmt.Fprintf(&b, "- executable conformance forms observed in this corpus: `%d`\n", rep.RuntimeVerifiedForms)
+	fmt.Fprintf(&b, "- manifest-registered runtime forms observed in this corpus: `%d` (not executed by this scan)\n", rep.RuntimeVerifiedForms)
 	if rep.CompileOnlyForms > 0 {
-		fmt.Fprintf(&b, "- explicit compile-only forms observed in this corpus: `%d`\n", rep.CompileOnlyForms)
+		fmt.Fprintf(&b, "- manifest-registered compile-only forms observed in this corpus: `%d` (not compiled by this scan)\n", rep.CompileOnlyForms)
 	}
 	if rep.EncoderForms > 0 {
 		if rep.Goarch == "wasm" {
@@ -1071,10 +1341,32 @@ func renderMarkdown(rep report) []byte {
 				rep.EncoderForms, rep.EncoderOpcodes, rep.EncoderOpsObserved)
 		}
 	}
+	if legacy := rep.LegacyEncoder; legacy != nil {
+		fmt.Fprintf(&b, "- legacy encoding inventory: `%d` operand rows, `%d` move rows, `%d` special entries (not translation or execution evidence; mode applicability is not yet resolved)\n",
+			legacy.OperandRows, legacy.MoveRows, legacy.SpecialEntries)
+	}
 	if rep.OfficialOpcodes > 0 {
 		fmt.Fprintf(&b, "- official opcode names: `%d`\n", rep.OfficialOpcodes)
 	}
 	fmt.Fprintf(&b, "- parser failures: `%d`\n\n", rep.ParseErrCount)
+	b.WriteString("## Evidence Levels\n\n")
+	if rep.InitializedContextReprobe != nil {
+		b.WriteString("This table retains the original isolated probes; the counterfactual profile below is separate.\n\n")
+	}
+	b.WriteString("| level | result in this scan |\n|---|---|\n")
+	if rep.Goarch == "wasm" {
+		b.WriteString("| IR text generation | not run by this scanner: isolated WASM probes require whole functions |\n")
+	} else {
+		fmt.Fprintf(&b, "| IR text generation | %d accepted form probes; not LLVM module verification |\n", rep.SupportedForms)
+	}
+	b.WriteString("| LLVM 22 object compilation | not run by this scanner |\n")
+	b.WriteString("| Runtime execution | not run by this scanner |\n\n")
+	b.WriteString("Context is not successful translation. Zero observed unsupported forms does not prove complete instruction, object or runtime coverage. Manifest associations require separate current-head test receipts.\n\n")
+	if reprobe := rep.InitializedContextReprobe; reprobe != nil {
+		fmt.Fprintf(&b, "## Counterfactual initialized-context reprobe\n\nProfile `%s`: `%s`, %d eligible source occurrences, %d object batches; %d other context occurrences retained without reprobe.\n\n",
+			reprobe.Profile, reprobe.Status, reprobe.EligibleCases, len(reprobe.ObjectBatches), len(reprobe.UnregisteredCases))
+		b.WriteString("Explicit synthetic inputs are not evidence about original input availability. Runtime execution: not run. Exact instructions, source locators and separate stage receipts are retained by JSON output.\n\n")
+	}
 
 	if len(rep.OpcodeCatalog) > 0 {
 		type catalogSummary struct {
@@ -1282,7 +1574,7 @@ func familyOf(goarch, op string) string {
 
 func isDirective(op string) bool {
 	switch op {
-	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "FUNCDATA", "PCDATA":
+	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "PCALIGNMAX", "FUNCDATA", "PCDATA":
 		return true
 	default:
 		return false
@@ -1314,12 +1606,11 @@ func topFiles(m map[string]int, n int) []string {
 	return out
 }
 
-func shortStdPath(path string) string {
-	goroot := runtime.GOROOT()
-	if goroot == "" {
+func shortStdPath(path, goRoot string) string {
+	if goRoot == "" {
 		return filepath.ToSlash(path)
 	}
-	root := filepath.ToSlash(filepath.Join(goroot, "src")) + "/"
+	root := filepath.ToSlash(filepath.Join(goRoot, "src")) + "/"
 	p := filepath.ToSlash(path)
 	if strings.HasPrefix(p, root) {
 		return strings.TrimPrefix(p, root)
diff --git a/cmd/plan9asmscan/main_test.go b/cmd/plan9asmscan/main_test.go
index 0d983d8ac..736160970 100644
--- a/cmd/plan9asmscan/main_test.go
+++ b/cmd/plan9asmscan/main_test.go
@@ -83,7 +83,7 @@ func TestNormalizeOpAndDirectiveHelpers(t *testing.T) {
 		}
 	}
 
-	if !isDirective("TEXT") || !isDirective("DATA") {
+	if !isDirective("TEXT") || !isDirective("DATA") || !isDirective("PCALIGN") || !isDirective("PCALIGNMAX") {
 		t.Fatalf("expected directive recognition")
 	}
 	if isDirective("MOVD") {
@@ -127,16 +127,16 @@ func TestClusterOfAndTopFiles(t *testing.T) {
 func TestShortStdPath(t *testing.T) {
 	goroot := runtime.GOROOT()
 	if goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatal("GOROOT not available")
 	}
 
 	inRoot := filepath.Join(goroot, "src", "runtime", "sys_arm64.s")
-	if got := shortStdPath(inRoot); got != "runtime/sys_arm64.s" {
+	if got := shortStdPath(inRoot, goroot); got != "runtime/sys_arm64.s" {
 		t.Fatalf("shortStdPath(inRoot) = %q", got)
 	}
 
 	outside := filepath.Join(t.TempDir(), "local.s")
-	if got := shortStdPath(outside); got != filepath.ToSlash(outside) {
+	if got := shortStdPath(outside, goroot); got != filepath.ToSlash(outside) {
 		t.Fatalf("shortStdPath(outside) = %q", got)
 	}
 }
@@ -164,7 +164,7 @@ func lowerOp(op any) {
 	if err != nil {
 		t.Fatalf("extractSupportedOps: %v", err)
 	}
-	want := []string{"VPXORQ", "VMOVDQU64", "AESENC", "MOVQ", "RET"}
+	want := []string{"VPXORQ", "VMOVDQU64", "AESENC", "MOVQ", "RET", "PCALIGN", "PCALIGNMAX", "PCDATA", "FUNCDATA"}
 	got := make([]string, 0, len(want))
 	for _, op := range want {
 		if _, ok := supported[op]; ok {
@@ -325,7 +325,7 @@ GLOBL foo(SB), RODATA, $8
 		Dir:        dir,
 		SFiles:     []string{"good.s", "bad.s", "data.s"},
 	}}
-	ops, forms, parseErrs, pkgsWithS, asmFiles, err := scanPackages(pkgs, plan9asm.ArchAMD64, "amd64")
+	ops, forms, parseErrs, pkgsWithS, asmFiles, err := scanPackages(pkgs, plan9asm.ArchAMD64, "amd64", runtime.GOROOT())
 	if err != nil {
 		t.Fatalf("scanPackages() error = %v", err)
 	}
@@ -379,15 +379,97 @@ GLOBL foo(SB), RODATA, $8
 	}
 }
 
+func TestScanPackagesProbesContiguousX86RawDirectiveGroups(t *testing.T) {
+	t.Run("complete stream", func(t *testing.T) {
+		dir := t.TempDir()
+		src := `TEXT ·f(SB),NOSPLIT,$0-0
+	BYTE $0xEB
+	BYTE $0x00
+	RET
+`
+		if err := os.WriteFile(filepath.Join(dir, "raw.s"), []byte(src), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		_, forms, parseErrs, _, _, err := scanPackages([]pkgJSON{{
+			ImportPath: "example/raw",
+			Dir:        dir,
+			SFiles:     []string{"raw.s"},
+		}}, plan9asm.ArchAMD64, "amd64", runtime.GOROOT())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(parseErrs) != 0 {
+			t.Fatalf("parse errors = %#v", parseErrs)
+		}
+		stat := forms["BYTE immediate"]
+		if stat == nil {
+			t.Fatalf("missing BYTE immediate form in %#v", forms)
+		}
+		if stat.Count != 2 || stat.SupportedCount != 1 || stat.UnsupportedCount != 0 {
+			t.Fatalf("BYTE stream stats = count %d, supported %d, unsupported %d; want 2, 1, 0",
+				stat.Count, stat.SupportedCount, stat.UnsupportedCount)
+		}
+	})
+
+	t.Run("truncated stream", func(t *testing.T) {
+		dir := t.TempDir()
+		src := `TEXT ·f(SB),NOSPLIT,$0-0
+	BYTE $0xEB
+	RET
+`
+		if err := os.WriteFile(filepath.Join(dir, "raw.s"), []byte(src), 0o644); err != nil {
+			t.Fatal(err)
+		}
+		_, forms, _, _, _, err := scanPackages([]pkgJSON{{
+			ImportPath: "example/raw",
+			Dir:        dir,
+			SFiles:     []string{"raw.s"},
+		}}, plan9asm.ArchAMD64, "amd64", runtime.GOROOT())
+		if err != nil {
+			t.Fatal(err)
+		}
+		stat := forms["BYTE immediate"]
+		if stat == nil || stat.UnsupportedCount != 1 {
+			t.Fatalf("truncated BYTE stream stats = %#v; want one unsupported probe", stat)
+		}
+	})
+}
+
+func TestScanPackagesProbesARMRawUndefinedInstruction(t *testing.T) {
+	dir := t.TempDir()
+	src := `TEXT ·f(SB),NOSPLIT,$0-0
+	WORD $0xe7f001f0
+`
+	if err := os.WriteFile(filepath.Join(dir, "raw.s"), []byte(src), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	_, forms, parseErrs, _, _, err := scanPackages([]pkgJSON{{
+		ImportPath: "example/raw",
+		Dir:        dir,
+		SFiles:     []string{"raw.s"},
+	}}, plan9asm.ArchARM, "arm", runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(parseErrs) != 0 {
+		t.Fatalf("parse errors = %#v", parseErrs)
+	}
+	stat := forms["WORD immediate"]
+	if stat == nil || stat.Count != 1 || stat.SupportedCount != 1 || stat.UnsupportedCount != 0 {
+		t.Fatalf("ARM WORD stats = %#v; want one supported probe", stat)
+	}
+}
+
 func TestAddFormStatCachesConcreteInstructionsWithoutCollapsingValues(t *testing.T) {
 	forms := map[string]*formStat{}
-	for _, imm := range []int64{1, 7, 7} {
+	for _, imm := range []int64{1, 256, 256} {
 		addFormStat(forms, plan9asm.ArchAMD64, "amd64", plan9asm.Instr{
-			Op:  "RCRQ",
-			Raw: "RCRQ immediate, AX",
+			Op:  "PALIGNR",
+			Raw: "PALIGNR immediate, X0, X1",
 			Args: []plan9asm.Operand{
 				{Kind: plan9asm.OpImm, Imm: imm},
-				{Kind: plan9asm.OpReg, Reg: plan9asm.AX},
+				{Kind: plan9asm.OpReg, Reg: "X0"},
+				{Kind: plan9asm.OpReg, Reg: "X1"},
 			},
 		}, "fixture.s")
 	}
@@ -410,10 +492,10 @@ func TestBuildOpcodeCatalogIncludesGeneratedTables(t *testing.T) {
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, "anames.go"), []byte("var Anames = []string{\n\"ADD\",\n\"LAST\",\n}\n"), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "anames.go"), []byte("package arm64\nvar Anames = []string{\n\"ADD\",\n\"LAST\",\n}\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, "anames_gen.go"), []byte("var sveAnames = []string{\n\"ZADD\",\n}\n"), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "anames_gen.go"), []byte("package arm64\nvar sveAnames = []string{\n\"ZADD\",\n}\nfunc init() { Anames = append(Anames, sveAnames...) }\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	ops := map[string]*opStat{"ADD": {Count: 1}}
@@ -432,13 +514,65 @@ func TestBuildOpcodeCatalogIncludesGeneratedTables(t *testing.T) {
 	}
 }
 
+func TestExtractSupportedOpsFindsPackageLevelSpecTableWithoutOpcodeName(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.WriteFile(filepath.Join(dir, "amd64_table.go"), []byte(`package sample
+var packedFamilySpecs = map[string]int{
+	"VTABLEOP": 1,
+}
+`), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "parser.go"), []byte("package sample\n"), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(dir, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := supported["VTABLEOP"]; !ok {
+		t.Fatal("package-level table-driven opcode was not extracted")
+	}
+}
+
+func TestExtractSupportedOpsFindsSingleFamilyOpcodeComparison(t *testing.T) {
+	dir := t.TempDir()
+	src := `package sample
+
+func lowerSingleFamily(op string, unrelated string) bool {
+	if op != "VEXT" {
+		return false
+	}
+	if "PRFM" == op {
+		return true
+	}
+	return unrelated == "NOT_AN_OPCODE"
+}
+`
+	if err := os.WriteFile(filepath.Join(dir, "arm64_lower_single.go"), []byte(src), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	supported, err := extractSupportedOps(dir, "arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"VEXT", "PRFM"} {
+		if _, ok := supported[op]; !ok {
+			t.Errorf("single-family opcode comparison omitted %s", op)
+		}
+	}
+	if _, ok := supported["NOT_AN_OPCODE"]; ok {
+		t.Fatal("unrelated string comparison was advertised as an opcode")
+	}
+}
+
 func TestBuildWASMOpcodeCatalogNormalizesOfficialNames(t *testing.T) {
 	goroot := t.TempDir()
 	dir := filepath.Join(goroot, "src", "cmd", "internal", "obj", "wasm")
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(dir, "anames.go"), []byte("var Anames = []string{\n\"I32Add\",\n\"ReservedFD01\",\n\"LAST\",\n}\n"), 0o644); err != nil {
+	if err := os.WriteFile(filepath.Join(dir, "anames.go"), []byte("package wasm\nvar Anames = []string{\n\"I32Add\",\n\"ReservedFD01\",\n\"LAST\",\n}\n"), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	catalog, err := buildOpcodeCatalog(goroot, plan9asm.ArchWASM, "wasm", map[string]*opStat{"I32ADD": {Count: 1}}, nil, map[string]struct{}{"I32ADD": {}})
@@ -498,6 +632,35 @@ func TestBuildReportAndJSONShape(t *testing.T) {
 	}
 }
 
+func TestBuildReportStableFamilyExampleSelection(t *testing.T) {
+	ops := []string{"ADDQ", "ANDQ", "CMPQ", "DIVQ", "IDIVQ", "ORQ", "SUBQ", "XORQ"}
+	want := append([]string(nil), ops[:6]...)
+	var previous []byte
+	for rotation := 0; rotation < 32; rotation++ {
+		inventory := make(map[string]*opStat, len(ops))
+		for i := range ops {
+			index := (i + rotation) % len(ops)
+			inventory[ops[index]] = &opStat{Count: index + 1,
+				Files: map[string]int{"fixture.s": index + 1},
+				Pkgs:  map[string]int{"fixture": index + 1}}
+		}
+		rep := buildReport("std", "go1.test", "linux", "amd64", 1, 1, 1,
+			inventory, nil, nil, nil, nil, nil, nil)
+		if len(rep.FamilyStats) != 1 || rep.FamilyStats[0].UniqueOps != len(ops) ||
+			rep.FamilyStats[0].Hits != 36 || !reflect.DeepEqual(rep.FamilyStats[0].Examples, want) {
+			t.Fatalf("rotation %d: unstable family sample: %+v; want %v", rotation, rep.FamilyStats, want)
+		}
+		encoded, err := json.Marshal(rep)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if previous != nil && string(encoded) != string(previous) {
+			t.Fatalf("rotation %d: unchanged input produced different JSON", rotation)
+		}
+		previous = encoded
+	}
+}
+
 func TestClusterAndFamilyCoverageMore(t *testing.T) {
 	clusterCases := []struct {
 		goarch string
diff --git a/cmd/plan9asmscan/mask_logical_context_test.go b/cmd/plan9asmscan/mask_logical_context_test.go
new file mode 100644
index 000000000..ecc7d035d
--- /dev/null
+++ b/cmd/plan9asmscan/mask_logical_context_test.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestMaskLogicalCoverageRequiresCompleteInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{"KAND", "KANDN", "KOR", "KXNOR", "KXOR", "KNOT", "KTEST", "KORTEST"} {
+			for _, suffix := range []string{"B", "W", "D", "Q"} {
+				t.Run(arch+"/"+stem+suffix, func(t *testing.T) {
+					operands := "K1,K2,K3"
+					if stem == "KNOT" || strings.Contains(stem, "TEST") {
+						operands = "K1,K2"
+					}
+					instruction := stem + suffix + " " + operands
+					valueProbeNeedsContext(t, arch, instruction)
+					prefix := "MOVL $3,AX\nKMOVD AX,K1\nKMOVD AX,K2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+instruction)); err != nil {
+						t.Error("complete initialized mask logical source rejected", err)
+					}
+					valueProbeNeedsContext(t, arch, strings.Replace(prefix+instruction, "KMOVD AX,K1\n", "", 1))
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/mmx_movemask_context_test.go b/cmd/plan9asmscan/mmx_movemask_context_test.go
new file mode 100644
index 000000000..0a2e73787
--- /dev/null
+++ b/cmd/plan9asmscan/mmx_movemask_context_test.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestMMXMoveMaskCoverageRequiresDefinedSourceAndEMMS(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		registers := []string{"AX", "CX", "DX", "BX", "SI", "DI"}
+		if arch == "amd64" {
+			registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		} else {
+			registers = append(registers, "BP")
+		}
+		for bank := 0; bank < 8; bank++ {
+			for _, destination := range registers {
+				t.Run(fmt.Sprintf("%s/M%d/%s", arch, bank, destination), func(t *testing.T) {
+					line := fmt.Sprintf("PMOVMSKB M%d,%s", bank, destination)
+					instruction := compactProbeInstructions(t, line)[0]
+					err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, instruction)
+					if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("isolated physical MMX input became a zero-valued implementation slot", err)
+					}
+					stat := &formStat{}
+					classifyFormProbe(stat, err)
+					if stat.ContextCount != 1 || stat.SupportedCount != 0 || stat.UnsupportedCount != 0 {
+						t.Fatal("missing MMX context changed the form classification", stat)
+					}
+					valueProbeNeedsContext(t, arch, line+"\nEMMS")
+					// MOVL supplies all eight physical bytes, including its cleared
+					// upper dword. The mask destination is write-only.
+					initialized := fmt.Sprintf("MOVL $129,AX\nMOVL AX,M%d\n%s", bank, line)
+					valueProbeNeedsContext(t, arch, initialized)
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, initialized+"\nEMMS")); err != nil {
+						t.Fatal("defined, closed MMX sequence became unsupported", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/movbe_context_test.go b/cmd/plan9asmscan/movbe_context_test.go
new file mode 100644
index 000000000..d28881502
--- /dev/null
+++ b/cmd/plan9asmscan/movbe_context_test.go
@@ -0,0 +1,25 @@
+package main
+
+import "testing"
+
+func TestMOVBECoverageRequiresActualMemoryAndValueInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVBEW", "MOVBEWW", "MOVBEL", "MOVBELL", "MOVBEQ", "MOVBEQQ"} {
+			if arch == "386" && (op == "MOVBEQ" || op == "MOVBEQQ") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				for index, line := range []string{op + " (AX),BX", op + " BX,(AX)"} {
+					valueProbeNeedsContext(t, arch, line)
+					if index == 0 {
+						valueProbePairedNumericAddress(t, arch, "MOVL $1,AX\nMOVL $7,BX\n"+line)
+					} else {
+						valueProbeNeedsContext(t, arch, "MOVL $1,AX\nMOVL $7,BX\n"+line)
+					}
+				}
+			})
+		}
+	}
+	// Only paired loads consume defined NUM addresses here. Special MOVBE
+	// stores keep their independent role; neither route invents pointer/backing.
+}
diff --git a/cmd/plan9asmscan/movnti_context_test.go b/cmd/plan9asmscan/movnti_context_test.go
new file mode 100644
index 000000000..e3eac549d
--- /dev/null
+++ b/cmd/plan9asmscan/movnti_context_test.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestMOVNTICoverageRetainsValueAddressAndNativeStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"MOVNTIL", "MOVNTIQ"} {
+			if arch == "386" && name == "MOVNTIQ" {
+				continue
+			}
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				for _, line := range []string{
+					name + " AX,(BX)",
+					"MOVL $1,AX\nMOVL $32,BX\n" + name + " AX,(BX)",
+					"MOVL $1,AX\n" + name + " AX,ret+0(FP)",
+					"MOVL $1,AX\n" + name + " AX,tmp-8(SP)",
+				} {
+					valueProbeNeedsContext(t, arch, line)
+				}
+				instruction := compactProbeInstructions(t, name+" AX,BX")[0]
+				if err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, instruction); err != nil {
+					t.Fatal("Go register-destination #UD consumed unknown data", err)
+				}
+				memory := compactProbeInstructions(t, name+" AX,(BX)")[0]
+				err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, memory)
+				if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatal("unbound MOVNTI memory became an unsupported form or a false pass", err)
+				}
+				state := &formStat{}
+				classifyFormProbe(state, err)
+				if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+					t.Fatal("unbound MOVNTI lost its explicit context classification", state)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/multiply_add_context_test.go b/cmd/plan9asmscan/multiply_add_context_test.go
new file mode 100644
index 000000000..53b44d727
--- /dev/null
+++ b/cmd/plan9asmscan/multiply_add_context_test.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestMultiplyAddCoverageRequiresInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []string{"PMADDWL", "PMADDUBSW", "VPMADDWD", "VPMADDUBSW"} {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				register, memory := opcode+" X0,X1", opcode+" (BX),X1"
+				if strings.HasPrefix(opcode, "V") {
+					register, memory = register+",X2", memory+",X2"
+				}
+				valueProbeNeedsContext(t, arch, register)
+				valueProbeNeedsContext(t, arch, memory)
+				prefix := "PXOR X0,X0\nPXOR X1,X1\nMOVL $1,BX\n"
+				valueProbePairedNumericAddress(t, arch, prefix+memory)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+register)); err != nil {
+					t.Fatal("complete initialized register form lost support", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/nontemporal_context_test.go b/cmd/plan9asmscan/nontemporal_context_test.go
new file mode 100644
index 000000000..cd0e6704c
--- /dev/null
+++ b/cmd/plan9asmscan/nontemporal_context_test.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestNonTemporalVectorCoverageRetainsNativeInputsAndTraps(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{
+			"MOVNTO", "MOVNTDQ", "MOVNTPD", "MOVNTPS", "MOVNTDQA",
+			"VMOVNTDQ", "VMOVNTPD", "VMOVNTPS", "VMOVNTDQA",
+		} {
+			banks := []string{"X"}
+			if strings.HasPrefix(name, "V") {
+				banks = []string{"X", "Y", "Z"}
+			}
+			for _, bank := range banks {
+				t.Run(arch+"/"+name+"/"+bank, func(t *testing.T) {
+					instruction := name + " " + bank + "1,(BX)"
+					if strings.HasSuffix(name, "DQA") {
+						instruction = name + " (BX)," + bank + "1"
+					}
+					err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, instruction)[0])
+					if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("unbound non-temporal memory acquired native inputs", err)
+					}
+					state := &formStat{}
+					classifyFormProbe(state, err)
+					if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+						t.Fatal("missing native inputs became support or unknown syntax", state)
+					}
+				})
+			}
+		}
+		for _, name := range []string{"MOVNTO", "MOVNTDQ", "MOVNTPD", "MOVNTPS"} {
+			if err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch,
+				compactProbeInstructions(t, name+" X1,AX")[0]); err != nil {
+				t.Fatal("exact legacy register #UD must precede source-input checks", arch, name, err)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/opcode_names.go b/cmd/plan9asmscan/opcode_names.go
new file mode 100644
index 000000000..f8d518956
--- /dev/null
+++ b/cmd/plan9asmscan/opcode_names.go
@@ -0,0 +1,167 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+// Go's arch constructors and RegisterOpcode calls consume the exported Anames
+// array for x86, ARM, ARM64 and wasm. ARM64 additionally appends sveAnames to
+// Anames in anames_gen.go. The similarly generated cnames5/cnames7 arrays name
+// operand classes, not instructions. Do not select arrays by a name substring
+// or scan every quoted string in anames*.go.
+func loadOfficialOpcodeNames(goroot, goarch string) ([]string, error) {
+	var dir string
+	arrays := map[string]bool{"Anames": true}
+	switch goarch {
+	case "386", "amd64":
+		dir = "x86"
+	case "arm":
+		dir = "arm"
+	case "arm64":
+		dir = "arm64"
+		// Absent before Go introduced the generated SVE namespace.
+		arrays["sveAnames"] = false
+	case "wasm":
+		dir = "wasm"
+	default:
+		return nil, fmt.Errorf("unsupported opcode architecture %q", goarch)
+	}
+	pattern := filepath.Join(goroot, "src", "cmd", "internal", "obj", dir, "anames*.go")
+	paths, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+	if len(paths) == 0 {
+		return nil, fmt.Errorf("no official opcode tables match %s", pattern)
+	}
+	sort.Strings(paths)
+	seenArrays := map[string]bool{}
+	names := map[string]bool{}
+	sveAppended := false
+	for _, path := range paths {
+		file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+		if err != nil {
+			return nil, fmt.Errorf("parse official opcode table %s: %w", path, err)
+		}
+		if goarch == "arm64" && appendsSVEOpcodeNames(file) {
+			sveAppended = true
+		}
+		for _, decl := range file.Decls {
+			gen, ok := decl.(*ast.GenDecl)
+			if !ok || gen.Tok != token.VAR {
+				continue
+			}
+			for _, spec := range gen.Specs {
+				value := spec.(*ast.ValueSpec)
+				for index, name := range value.Names {
+					if _, selected := arrays[name.Name]; !selected {
+						continue
+					}
+					if seenArrays[name.Name] {
+						return nil, fmt.Errorf("duplicate official opcode array %s in %s", name.Name, path)
+					}
+					seenArrays[name.Name] = true
+					if index >= len(value.Values) {
+						return nil, fmt.Errorf("official opcode array %s in %s has no literal initializer", name.Name, path)
+					}
+					entries, err := opcodeStringArray(value.Values[index])
+					if err != nil {
+						return nil, fmt.Errorf("official opcode array %s in %s: %w", name.Name, path, err)
+					}
+					for _, entry := range entries {
+						op := normalizeOp(entry)
+						if op != "" && op != "LAST" && !strings.HasPrefix(op, "RESERVED") {
+							names[op] = true
+						}
+					}
+				}
+			}
+		}
+	}
+	for name, required := range arrays {
+		if required && !seenArrays[name] {
+			return nil, fmt.Errorf("missing official opcode array %s under %s", name, pattern)
+		}
+	}
+	if seenArrays["sveAnames"] != sveAppended {
+		return nil, fmt.Errorf("ARM64 SVE opcode array and Anames registration disagree under %s", pattern)
+	}
+	if len(names) == 0 {
+		return nil, fmt.Errorf("empty official opcode namespace under %s", pattern)
+	}
+	out := make([]string, 0, len(names))
+	for name := range names {
+		out = append(out, name)
+	}
+	sort.Strings(out)
+	return out, nil
+}
+
+func appendsSVEOpcodeNames(file *ast.File) bool {
+	for _, decl := range file.Decls {
+		fn, ok := decl.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != "init" || fn.Body == nil {
+			continue
+		}
+		for _, stmt := range fn.Body.List {
+			assign, ok := stmt.(*ast.AssignStmt)
+			if !ok || assign.Tok != token.ASSIGN || len(assign.Lhs) != 1 || len(assign.Rhs) != 1 {
+				continue
+			}
+			lhs, ok := assign.Lhs[0].(*ast.Ident)
+			if !ok || lhs.Name != "Anames" {
+				continue
+			}
+			call, ok := assign.Rhs[0].(*ast.CallExpr)
+			if !ok || len(call.Args) != 2 || !call.Ellipsis.IsValid() {
+				continue
+			}
+			fun, ok := call.Fun.(*ast.Ident)
+			base, baseOK := call.Args[0].(*ast.Ident)
+			supplement, supplementOK := call.Args[1].(*ast.Ident)
+			if ok && fun.Name == "append" && baseOK && base.Name == "Anames" &&
+				supplementOK && supplement.Name == "sveAnames" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func opcodeStringArray(expr ast.Expr) ([]string, error) {
+	literal, ok := expr.(*ast.CompositeLit)
+	if !ok {
+		return nil, fmt.Errorf("expected a literal string array")
+	}
+	array, ok := literal.Type.(*ast.ArrayType)
+	if !ok {
+		return nil, fmt.Errorf("expected a literal string array")
+	}
+	element, ok := array.Elt.(*ast.Ident)
+	if !ok || element.Name != "string" {
+		return nil, fmt.Errorf("expected string array elements")
+	}
+	entries := make([]string, 0, len(literal.Elts))
+	for _, entry := range literal.Elts {
+		if keyed, ok := entry.(*ast.KeyValueExpr); ok {
+			entry = keyed.Value
+		}
+		value, ok := entry.(*ast.BasicLit)
+		if !ok || value.Kind != token.STRING {
+			return nil, fmt.Errorf("expected a literal opcode string")
+		}
+		name, err := strconv.Unquote(value.Value)
+		if err != nil {
+			return nil, fmt.Errorf("decode opcode string: %w", err)
+		}
+		entries = append(entries, name)
+	}
+	return entries, nil
+}
diff --git a/cmd/plan9asmscan/opcode_names_test.go b/cmd/plan9asmscan/opcode_names_test.go
new file mode 100644
index 000000000..7d8936b38
--- /dev/null
+++ b/cmd/plan9asmscan/opcode_names_test.go
@@ -0,0 +1,143 @@
+package main
+
+import (
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"testing"
+)
+
+func TestOfficialOpcodeNamesExcludeNonOpcodeArraysOnEveryArchitecture(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(goarch, func(t *testing.T) {
+			goroot := t.TempDir()
+			dir := goarch
+			if goarch == "386" || goarch == "amd64" {
+				dir = "x86"
+			}
+			base := filepath.Join(goroot, "src", "cmd", "internal", "obj", dir)
+			writeEncoderFixture(t, filepath.Join(base, "anames.go"), `package arch
+var Anames = []string{
+	"ADD",
+	"MOVD",
+	"LAST",
+	"ReservedFD01",
+}
+var fakeAnames = []string{"NOTANOPCODE"}
+const unrelated = "NOTANOPCODEEITHER"
+`)
+			writeEncoderFixture(t, filepath.Join(base, "anames_classes.go"), `package arch
+var cnames = []string{
+	"REG",
+	"ADDR",
+	"TEXTSIZE",
+}
+var OtherAnames = []string{
+	"NOTANOPCODETHREE",
+}
+`)
+			writeEncoderFixture(t, filepath.Join(base, "anames_gen.go"), `package arch
+var sveAnames = []string{
+	"ZADD",
+}
+func init() { Anames = append(Anames, sveAnames...) }
+`)
+			want := []string{"ADD", "MOVD"}
+			if goarch == "arm64" {
+				want = append(want, "ZADD")
+			}
+			arch, err := toPlan9Arch(goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			catalog, err := buildOpcodeCatalog(goroot, arch, goarch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var got []string
+			for _, item := range catalog {
+				got = append(got, item.Opcode)
+			}
+			if !reflect.DeepEqual(got, want) {
+				t.Fatalf("official opcode names = %v, want only the registered opcode arrays %v", got, want)
+			}
+		})
+	}
+}
+
+func TestOfficialOpcodeNamesRequireRegisteredARM64Supplement(t *testing.T) {
+	goroot := t.TempDir()
+	base := filepath.Join(goroot, "src", "cmd", "internal", "obj", "arm64")
+	writeEncoderFixture(t, filepath.Join(base, "anames.go"), "package arm64\nvar Anames = []string{\"ADD\"}\n")
+	writeEncoderFixture(t, filepath.Join(base, "anames_gen.go"), "package arm64\nvar sveAnames = []string{\"NOTREGISTERED\"}\n")
+	arch, err := toPlan9Arch("arm64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := buildOpcodeCatalog(goroot, arch, "arm64", nil, nil, nil); err == nil {
+		t.Fatal("an unregistered SVE array was accepted as an official opcode namespace")
+	}
+}
+
+func TestOfficialOpcodeNamesFailClosedForMalformedNamespace(t *testing.T) {
+	for _, source := range []string{
+		"package arm\nvar cnames = []string{\"REG\"}\n",
+		"package arm\nvar Anames = []int{1}\n",
+		"package arm\nvar Anames = []string{unknown}\n",
+		"package arm\nvar Anames = []string{\"ADD\"}\nvar Anames = []string{\"SUB\"}\n",
+		"package arm\nvar Anames = []string{\n",
+	} {
+		t.Run(source, func(t *testing.T) {
+			goroot := t.TempDir()
+			writeEncoderFixture(t, filepath.Join(goroot, "src", "cmd", "internal", "obj", "arm", "anames.go"), source)
+			arch, err := toPlan9Arch("arm")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := buildOpcodeCatalog(goroot, arch, "arm", nil, nil, nil); err == nil {
+				t.Fatal("malformed or absent official opcode namespace was accepted")
+			}
+		})
+	}
+}
+
+func TestOfficialOpcodeNamesMatchAuditedGoSourceNamespaces(t *testing.T) {
+	for _, goarch := range namespaceArchitectures {
+		t.Run(goarch, func(t *testing.T) {
+			want := actualGoNamespaceCounts(t, goarch).official
+			arch, err := toPlan9Arch(goarch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			catalog, err := buildOpcodeCatalog(runtime.GOROOT(), arch, goarch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(catalog) != want {
+				t.Fatalf("%s %s opcode namespace = %d, want audited Anames entries %d", runtime.Version(), goarch, len(catalog), want)
+			}
+			for _, item := range catalog {
+				if item.Opcode == "REG" || item.Opcode == "ADDR" || item.Opcode == "TEXTSIZE" || item.Opcode == "NCLASS" {
+					t.Fatalf("operand class %q entered the official opcode namespace", item.Opcode)
+				}
+			}
+		})
+	}
+}
+
+func TestOfficialOpcodeNamesAcceptKeyedAndEscapedStringEntries(t *testing.T) {
+	goroot := t.TempDir()
+	path := filepath.Join(goroot, "src", "cmd", "internal", "obj", "x86", "anames.go")
+	writeEncoderFixture(t, path, "package x86\nvar Anames = []string{obj.A_ARCHSPECIFIC: \"A\\x44D\", \"SUB\", \"ADD\"}\n")
+	arch, err := toPlan9Arch("amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := buildOpcodeCatalog(goroot, arch, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(catalog) != 2 || catalog[0].Opcode != "ADD" || catalog[1].Opcode != "SUB" {
+		t.Fatalf("literal AST opcode entries = %+v, want ADD and SUB once each", catalog)
+	}
+}
diff --git a/cmd/plan9asmscan/packed_addsub_context_test.go b/cmd/plan9asmscan/packed_addsub_context_test.go
new file mode 100644
index 000000000..24a1ebf52
--- /dev/null
+++ b/cmd/plan9asmscan/packed_addsub_context_test.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestPackedAddSubCoverageRequiresNativeInputContext(t *testing.T) {
+	// Independent complete legacy/V inventory, including Go's PADDD alias.
+	names := strings.Fields("PADDB PADDW PADDL PADDD PADDQ PADDSB PADDSW PADDUSB PADDUSW " +
+		"PSUBB PSUBW PSUBL PSUBQ PSUBSB PSUBSW PSUBUSB PSUBUSW " +
+		"VPADDB VPADDW VPADDD VPADDQ VPADDSB VPADDSW VPADDUSB VPADDUSW " +
+		"VPSUBB VPSUBW VPSUBD VPSUBQ VPSUBSB VPSUBSW VPSUBUSB VPSUBUSW")
+	if len(names) != 33 {
+		t.Fatal("complete independent add-sub inventory changed", len(names))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range names {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				memory, registers := op+" 3(AX)(DX*2),X1", op+" X0,X1"
+				if strings.HasPrefix(op, "V") {
+					memory, registers = op+" 3(AX)(DX*2),X1,X2", op+" X0,X1,X2"
+				}
+				valueProbeNeedsContext(t, arch, memory)
+				prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+registers)); err != nil {
+					t.Fatal("initialized registers became unsupported while checking native context", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/packed_sign_extend_context_test.go b/cmd/plan9asmscan/packed_sign_extend_context_test.go
new file mode 100644
index 000000000..fa53e95fd
--- /dev/null
+++ b/cmd/plan9asmscan/packed_sign_extend_context_test.go
@@ -0,0 +1,78 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestPackedSignExtendCoverageRetainsActualInputsAndVoidE5Reads(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, ratio := range []struct {
+			suffix string
+			twice  bool
+		}{{"BW", true}, {"BD", false}, {"BQ", false}, {"WD", true}, {"WQ", false}, {"DQ", true}} {
+			for _, vector := range []bool{false, true} {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if !vector && bank != "X" {
+						continue
+					}
+					input := "X0"
+					if bank == "Z" && ratio.twice {
+						input = "Y0"
+					}
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if !vector && mode != "plain" {
+							continue
+						}
+						op, mask := "PMOVSX"+ratio.suffix, ""
+						if vector {
+							op = "V" + op
+						}
+						if mode != "plain" {
+							mask = "K1,"
+							if mode == "zero" {
+								op += ".Z"
+							}
+						}
+						row := fmt.Sprintf("%s %s,%s%s1", op, input, mask, bank)
+						t.Run(arch+"/"+row, func(t *testing.T) {
+							// Unlike a dead copy, TEST consumes actual result bits and
+							// SETEQ consumes the resulting ZF. A bare/no-input value
+							// therefore cannot become numerical implementation storage.
+							observe := "\nMOVL X1,AX\nTESTL AX,AX\nSETEQ CX"
+							valueProbeNeedsContext(t, arch, row+observe)
+							prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nMOVL $-1,AX\nKMOVD AX,K1\n"
+							probe := func(body string) error {
+								return plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, body))
+							}
+							if err := probe(prefix + row + observe); err != nil {
+								t.Fatal("complete initialized signed input/mask sequence rejected", err)
+							}
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+row+observe, "VPXORD Z0,Z0,Z0\n", "", 1))
+							if mode != "plain" {
+								valueProbeNeedsContext(t, arch, strings.Replace(prefix+row+observe, "KMOVD AX,K1\n", "", 1))
+							}
+							withoutOld := strings.Replace(prefix+row+observe, "VPXORD Z1,Z1,Z1\n", "", 1)
+							if mode == "merge" {
+								valueProbeNeedsContext(t, arch, withoutOld)
+							} else if err := probe(withoutOld); err != nil {
+								t.Fatal("non-merge widening invented an old-destination dependency", err)
+							}
+							// E5 masking retains its original access suppression. A
+							// defined NUM base permits only that paired memory effect.
+							memory := strings.Replace(row, input+",", "(AX),", 1)
+							valueProbeNeedsContext(t, arch, memory)
+							valueProbePairedNumericAddress(t, arch, prefix+"MOVL $0,AX\n"+memory)
+							if mode != "plain" {
+								valueProbePairedNumericAddress(t, arch, prefix+"MOVL $0,AX\nKMOVD AX,K1\n"+memory)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/qword_lookup_context_test.go b/cmd/plan9asmscan/qword_lookup_context_test.go
new file mode 100644
index 000000000..d6b54fccc
--- /dev/null
+++ b/cmd/plan9asmscan/qword_lookup_context_test.go
@@ -0,0 +1,56 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestQwordLookupCoverageRequiresActualInputsAndMaskRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPMULTISHIFTQB", "VPSHUFBITQMB"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				modes := []string{"plain"}
+				if arch == "amd64" {
+					modes = append(modes, "merge")
+					if op == "VPMULTISHIFTQB" {
+						modes = append(modes, "zero")
+					}
+				}
+				for _, mode := range modes {
+					t.Run(arch+"/"+op+"/"+bank+"/"+mode, func(t *testing.T) {
+						name, mask, destination := op, "", bank+"2"
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							name += ".Z"
+						}
+						if op == "VPSHUFBITQMB" {
+							destination = "K3"
+						}
+						line := name + " " + bank + "0," + bank + "1," + mask + destination
+						prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nMOVL $7,AX\nKMOVD AX,K1\n"
+						valueProbeNeedsContext(t, arch, line)
+						if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+							compactProbeInstructions(t, prefix+line)); err != nil {
+							t.Fatal("complete qword lookup inputs became unsupported", err)
+						}
+						for _, remove := range []string{"VPXORD Z0,Z0,Z0\n", "VPXORD Z1,Z1,Z1\n"} {
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, remove, "", 1))
+						}
+						if mode != "plain" {
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, "KMOVD AX,K1\n", "", 1))
+						}
+						if op == "VPMULTISHIFTQB" && mode == "merge" {
+							valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, "VPXORD Z2,Z2,Z2\n", "", 1))
+						}
+						valueProbePairedNumericAddress(t, arch, prefix+"MOVL $1,SI\n"+
+							name+" (SI),"+bank+"1,"+mask+destination)
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/sad_context_test.go b/cmd/plan9asmscan/sad_context_test.go
new file mode 100644
index 000000000..f9db9a7e9
--- /dev/null
+++ b/cmd/plan9asmscan/sad_context_test.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestSADCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, instruction := range []string{
+			"PSADBW X0,X1", "MPSADBW $37,X0,X1", "VPSADBW Z0,Z1,Z2",
+			"VMPSADBW $37,Y0,Y1,Y2", "VDBPSADBW.Z $37,Z0,Z1,K1,Z2",
+		} {
+			if arch == "386" && (strings.HasPrefix(instruction, "VMPS") || strings.HasPrefix(instruction, "VDBPS")) {
+				continue // Go's named mode32 frontend has no four/five-operand row.
+			}
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, instruction)
+				prefix := "MOVL $7,AX\nKMOVD AX,K1\n" +
+					"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+instruction)); err != nil {
+					t.Error("complete initialized SAD sequence rejected", err)
+				}
+				valueProbeNeedsContext(t, arch, strings.Replace(prefix+instruction, "VPXORD Z0,Z0,Z0\n", "", 1))
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/scalar_count_context_test.go b/cmd/plan9asmscan/scalar_count_context_test.go
new file mode 100644
index 000000000..b952a9ae9
--- /dev/null
+++ b/cmd/plan9asmscan/scalar_count_context_test.go
@@ -0,0 +1,51 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScalarCountAndMMXStoreCoverageNeedsActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		check := func(t *testing.T, instruction string) {
+			t.Helper()
+			ins := compactProbeInstructions(t, instruction)[0]
+			err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, ins)
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("isolated memory form invented its pointer or MMX inputs", err)
+			}
+			state := &formStat{}
+			classifyFormProbe(state, err)
+			if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+				t.Fatal("required inputs became support or an unknown instruction", state)
+			}
+		}
+		for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			widths := []string{"W", "L"}
+			if arch == "amd64" {
+				widths = append(widths, "Q")
+			}
+			for _, width := range widths {
+				op := family + width
+				t.Run(arch+"/"+op, func(t *testing.T) {
+					check(t, op+" (BX),DX")
+					body := "MOVL $1,AX\nMOVL $0,CX\n" + op + " AX,CX"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, body)); err != nil {
+						t.Fatal("initialized register counterpart lost its grammar", err)
+					}
+				})
+			}
+		}
+		for register := 0; register < 8; register++ {
+			t.Run(fmt.Sprintf("%s/MOVNTQ/M%d", arch, register), func(t *testing.T) {
+				check(t, fmt.Sprintf("MOVNTQ M%d,(BX)", register))
+			})
+		}
+	}
+	// Typed native-input and object counterparts live in the complete scalar
+	// count and MMX streaming root suites, not in a declaration-free probe.
+}
diff --git a/cmd/plan9asmscan/scalar_lane_store_context_test.go b/cmd/plan9asmscan/scalar_lane_store_context_test.go
new file mode 100644
index 000000000..7ef6b163d
--- /dev/null
+++ b/cmd/plan9asmscan/scalar_lane_store_context_test.go
@@ -0,0 +1,18 @@
+package main
+
+import "testing"
+
+func TestScalarLaneStoreCoverageRequiresSelectedInputsAndAddress(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range []string{"PEXTRB", "PEXTRW", "PEXTRD", "PEXTRQ", "VPEXTRB", "VPEXTRW", "VPEXTRD", "VPEXTRQ", "EXTRACTPS", "VEXTRACTPS"} {
+			if arch == "386" && opcode == "PEXTRQ" {
+				continue // Its actual Go rejection is owned by the independent table oracle.
+			}
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, opcode+" $1,X1,(BX)")
+				// Source initialization alone does not supply a native address.
+				valueProbeNeedsContext(t, arch, "PXOR X1,X1\n"+opcode+" $1,X1,(BX)")
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/scalar_precision_context_test.go b/cmd/plan9asmscan/scalar_precision_context_test.go
new file mode 100644
index 000000000..d395f7836
--- /dev/null
+++ b/cmd/plan9asmscan/scalar_precision_context_test.go
@@ -0,0 +1,65 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScalarPrecisionCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CVTSS2SD", "CVTSD2SS", "VCVTSS2SD", "VCVTSD2SS"} {
+			controls := []string{""}
+			if op == "VCVTSS2SD" {
+				controls = append(controls, ".SAE")
+			} else if op == "VCVTSD2SS" {
+				controls = append(controls, ".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE")
+			}
+			for _, control := range controls {
+				operands := "X0,X2"
+				if strings.HasPrefix(op, "V") {
+					operands = "X0,X1,X2"
+				}
+				row := op + control + " " + operands
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					valueProbeNeedsContext(t, arch, row)
+					prefix := "XORPS X0,X0\nXORPS X1,X1\nXORPS X2,X2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+row)); err != nil {
+						t.Fatal("complete active precision input was not supported", err)
+					}
+					valueProbeNeedsContext(t, arch, strings.TrimPrefix(prefix, "XORPS X0,X0\n")+row)
+					if control == "" {
+						native := strings.Replace(row, "X0,", "(AX),", 1)
+						valueProbePairedNumericAddress(t, arch, prefix+"MOVL $0,AX\n"+native)
+					}
+				})
+			}
+			if arch == "amd64" && strings.HasPrefix(op, "V") {
+				for _, zero := range []bool{false, true} {
+					name := op
+					if zero {
+						name += ".Z"
+					}
+					row := name + " X0,X1,K1,X2"
+					prefix := "MOVL $1,AX\nKMOVD AX,K1\nXORPS X0,X0\nXORPS X1,X1\nXORPS X2,X2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+row)); err != nil {
+						t.Fatal("complete precision mask/merge input rejected", row, err)
+					}
+					valueProbeNeedsContext(t, arch, strings.Replace(prefix+row, "KMOVD AX,K1\n", "", 1))
+					missingOld := strings.Replace(prefix+row, "XORPS X2,X2\n", "", 1)
+					if zero {
+						if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+							compactProbeInstructions(t, missingOld)); err != nil {
+							t.Fatal("zeroing form acquired an old scalar merge dependency", err)
+						}
+					} else {
+						valueProbeNeedsContext(t, arch, missingOld)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/scalar_shift_context_test.go b/cmd/plan9asmscan/scalar_shift_context_test.go
new file mode 100644
index 000000000..e657aa0bd
--- /dev/null
+++ b/cmd/plan9asmscan/scalar_shift_context_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScalarShiftMemoryCoverageRequiresAddressAndInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := []string{"B", "W", "L"}
+		if arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, stem := range []string{"RCL", "RCR", "ROL", "ROR", "SAL", "SAR", "SHL", "SHR"} {
+			for _, width := range widths {
+				t.Run(arch+"/"+stem+width, func(t *testing.T) {
+					for _, count := range []string{"$0", "$1", "CX"} {
+						instruction := stem + width + " " + count + ",(DI)"
+						valueProbeNeedsContext(t, arch, instruction)
+						valueProbeNeedsContext(t, arch, "MOVL $1,DI\nMOVL $1,CX\nCLC\n"+instruction)
+					}
+					positive := "MOVL $1,AX\nMOVL $1,CX\nCLC\n" + stem + width + " CX,AX"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, positive)); err != nil {
+						t.Error("initialized register counterpart lost support", err)
+					}
+				})
+			}
+		}
+		for _, stem := range []string{"SARX", "SHLX", "SHRX", "RORX"} {
+			for _, width := range []string{"L", "Q"} {
+				t.Run(arch+"/"+stem+width, func(t *testing.T) {
+					count := "CX"
+					if stem == "RORX" {
+						count = "$0"
+					}
+					instruction := stem + width + " " + count + ",(DI),AX"
+					valueProbeNeedsContext(t, arch, instruction)
+					valueProbePairedNumericAddress(t, arch, "MOVL $1,DI\nMOVL $1,CX\n"+instruction)
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/sqrt_context_test.go b/cmd/plan9asmscan/sqrt_context_test.go
new file mode 100644
index 000000000..ff675a745
--- /dev/null
+++ b/cmd/plan9asmscan/sqrt_context_test.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestSqrtCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{
+			"SQRTSS X0,X2", "SQRTSD X0,X2", "SQRTPS X0,X2", "SQRTPD X0,X2",
+			"VSQRTSS X0,X1,X2", "VSQRTSD X0,X1,X2", "VSQRTPS.Z Z0,K1,Z2", "VSQRTPD.Z Y0,K1,Y2",
+		} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				valueProbeNeedsContext(t, arch, row)
+				prefix := "MOVL $7,AX\nKMOVD AX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+row)); err != nil {
+					t.Fatal("complete sqrt input rejected", err)
+				}
+				valueProbeNeedsContext(t, arch, strings.Replace(prefix+row, "VPXORD Z0,Z0,Z0\n", "", 1))
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/ternary_gp_context_test.go b/cmd/plan9asmscan/ternary_gp_context_test.go
new file mode 100644
index 000000000..3d51abe10
--- /dev/null
+++ b/cmd/plan9asmscan/ternary_gp_context_test.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestTernaryGPCoverageRequiresBothActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				line := op + " AX,BX,CX"
+				prefix := "MOVL $3,AX\nMOVL $7,BX\n"
+				valueProbeNeedsContext(t, arch, line)
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+line)); err != nil {
+					t.Fatal("initialized complete ternary GP sequence rejected", err)
+				}
+				for _, remove := range []string{"MOVL $3,AX\n", "MOVL $7,BX\n"} {
+					valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, remove, "", 1))
+				}
+				if strings.HasPrefix(op, "ANDN") {
+					valueProbeNeedsContext(t, arch, prefix+line+"\nSETPS AX")
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/unresolved_arm64_symbol_test.go b/cmd/plan9asmscan/unresolved_arm64_symbol_test.go
new file mode 100644
index 000000000..4dc517fb6
--- /dev/null
+++ b/cmd/plan9asmscan/unresolved_arm64_symbol_test.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanPackagesRetainsUnresolvedARM64SymbolAddendsAndLaterInstructions(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"MOVB", "MOVBU", "MOVH", "MOVHU", "MOVW", "MOVWU", "MOVD"} {
+		rows = append(rows, op+" ·memory+OFFSET(SB),R2", op+" R2,·memory-OFFSET(SB)")
+	}
+	rows = append(rows, "MOVD $·memory+(OFFSET+4)(SB),R2",
+		"MOVWU $·memory-OFFSET(SB),R2",
+		"MOVBU internal∕cpu·ARM64+const_offsetARM64HasATOMICS(SB),R4")
+	source := "TEXT one(SB),$0-0\n" + strings.Join(rows, "\n") + "\nADD $7,R2\nRET\n"
+	directory := t.TempDir()
+	input := filepath.Join(directory, "one.s")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ops, forms, parseErrors, packages, files, err := scanPackages([]pkgJSON{{
+		ImportPath: "example.invalid/layout", Dir: directory, SFiles: []string{"one.s"},
+	}}, plan9asm.ArchARM64, "arm64", runtime.GOROOT())
+	if err != nil || len(parseErrors) != 0 || packages != 1 || files != 1 {
+		t.Fatalf("source inventory was lost: error=%v parse=%v packages=%d files=%d", err, parseErrors, packages, files)
+	}
+	if ops["ADD"] == nil || ops["ADD"].Count != 1 || ops["RET"] == nil || ops["RET"].Count != 1 {
+		t.Fatal("an unresolved symbol addend suppressed later instructions")
+	}
+	contexts := 0
+	for _, form := range forms {
+		if !strings.HasPrefix(form.Descriptor.Opcode, "MOV") {
+			continue
+		}
+		contexts += form.ContextCount
+		if form.SupportedCount != 0 || form.UnsupportedCount != 0 || len(form.Errors) != 0 {
+			t.Errorf("unresolved symbol was invented as supported or rejected as an instruction: %+v", form)
+		}
+	}
+	if contexts != len(rows) {
+		t.Errorf("retained %d contexts; want every one of %d original operands", contexts, len(rows))
+	}
+	retained, err := os.ReadFile(input)
+	if err != nil || string(retained) != source {
+		t.Fatal("scanning changed the original generated-constant source", err)
+	}
+}
diff --git a/cmd/plan9asmscan/unresolved_arm_symbol_test.go b/cmd/plan9asmscan/unresolved_arm_symbol_test.go
new file mode 100644
index 000000000..8fa3e2f9b
--- /dev/null
+++ b/cmd/plan9asmscan/unresolved_arm_symbol_test.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanPackagesRetainsUnresolvedARMSymbolAddendsAndLaterInstructions(t *testing.T) {
+	var rows []string
+	for _, op := range []string{"MOVW", "MOVB", "MOVBS", "MOVBU", "MOVH", "MOVHS", "MOVHU"} {
+		rows = append(rows, op+" ·memory+OFFSET(SB),R2", op+" R2,·memory-OFFSET(SB)")
+	}
+	rows = append(rows, "MOVW $·memory+(OFFSET+4)(SB),R2",
+		"MOVB internal∕cpu·ARM+const_offsetARMHasV7Atomics(SB),R11",
+		"MOVBU internal∕cpu·ARM+const_offsetARMHasIDIVA(SB),R11")
+	source := "TEXT one(SB),$0-0\n" + strings.Join(rows, "\n") + "\nADD $7,R2\nRET\n"
+	directory := t.TempDir()
+	input := filepath.Join(directory, "one.s")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ops, forms, parseErrors, packages, files, err := scanPackages([]pkgJSON{{
+		ImportPath: "example.invalid/layout", Dir: directory, SFiles: []string{"one.s"},
+	}}, plan9asm.ArchARM, "arm", runtime.GOROOT())
+	if err != nil || len(parseErrors) != 0 || packages != 1 || files != 1 {
+		t.Fatalf("source inventory was lost: error=%v parse=%v packages=%d files=%d", err, parseErrors, packages, files)
+	}
+	if ops["ADD"] == nil || ops["ADD"].Count != 1 || ops["RET"] == nil || ops["RET"].Count != 1 {
+		t.Fatal("an unresolved symbol addend suppressed later instructions")
+	}
+	contexts := 0
+	for _, form := range forms {
+		if !strings.HasPrefix(form.Descriptor.Opcode, "MOV") {
+			continue
+		}
+		contexts += form.ContextCount
+		if form.SupportedCount != 0 || form.UnsupportedCount != 0 || len(form.Errors) != 0 {
+			t.Errorf("unresolved symbol was invented as supported or rejected as an instruction: %+v", form)
+		}
+	}
+	if contexts != len(rows) {
+		t.Errorf("retained %d contexts; want all %d exact original operands", contexts, len(rows))
+	}
+	retained, err := os.ReadFile(input)
+	if err != nil || string(retained) != source {
+		t.Fatal("scanning changed the original generated-constant source", err)
+	}
+}
diff --git a/cmd/plan9asmscan/unresolved_fp_symbol_test.go b/cmd/plan9asmscan/unresolved_fp_symbol_test.go
new file mode 100644
index 000000000..ce0d31e65
--- /dev/null
+++ b/cmd/plan9asmscan/unresolved_fp_symbol_test.go
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanPackagesRetainsUnresolvedFPSymbolOffsetsAndLaterInstructions(t *testing.T) {
+	for _, target := range []struct {
+		arch   plan9asm.Arch
+		goarch string
+		ops    []string
+	}{
+		{plan9asm.ArchARM, "arm", []string{"MOVF", "MOVD"}},
+		{plan9asm.ArchARM64, "arm64", []string{"FMOVS", "FMOVD", "FMOVQ"}},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			var rows []string
+			for _, op := range target.ops {
+				rows = append(rows, op+" ·memory+OFFSET(SB),F0", op+" F0,·memory+OFFSET(SB)")
+			}
+			source := "TEXT probe(SB),$0-0\n" + strings.Join(rows, "\n") + "\nADD $7,R2\nRET\n"
+			directory := t.TempDir()
+			if err := os.WriteFile(filepath.Join(directory, "probe.s"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ops, forms, parseErrors, packages, files, err := scanPackages([]pkgJSON{{
+				ImportPath: "example.invalid/fplayout", Dir: directory, SFiles: []string{"probe.s"},
+			}}, target.arch, target.goarch, runtime.GOROOT())
+			if err != nil || len(parseErrors) != 0 || packages != 1 || files != 1 {
+				t.Fatalf("FP source inventory was lost: error=%v parse=%v packages=%d files=%d", err, parseErrors, packages, files)
+			}
+			if ops["ADD"] == nil || ops["RET"] == nil {
+				t.Fatal("an unresolved FP symbol suppressed later inventory")
+			}
+			contexts := 0
+			for _, op := range target.ops {
+				if ops[op] == nil || ops[op].Count != 2 {
+					t.Errorf("FP load/store rows were not retained: %s", op)
+				}
+				for _, form := range forms {
+					if form.Descriptor.Opcode != op {
+						continue
+					}
+					contexts += form.ContextCount
+					if form.SupportedCount != 0 || form.UnsupportedCount != 0 || len(form.Errors) != 0 {
+						t.Errorf("FP generated offset was guessed or rejected as unsupported: %+v", form)
+					}
+				}
+			}
+			if contexts != len(rows) {
+				t.Errorf("retained %d contextual operands; want %d", contexts, len(rows))
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmscan/unresolved_memory_test.go b/cmd/plan9asmscan/unresolved_memory_test.go
new file mode 100644
index 000000000..e25181c49
--- /dev/null
+++ b/cmd/plan9asmscan/unresolved_memory_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestScanPackagesRetainsUnresolvedX86MemoryAndLaterInstructions(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			dir := t.TempDir()
+			source := "TEXT one(SB),4,$0-0\nMOVL g_stackguard0(BP),BX\nMOVL g(CX),CX\n" +
+				"CMPB internal∕cpu·X86+const_offsetX86HasERMS(SB),$1\nADDL $7,BX\nRET\n"
+			if err := os.WriteFile(filepath.Join(dir, "one.s"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ops, forms, parseErrs, packages, files, err := scanPackages([]pkgJSON{{
+				ImportPath: "example.invalid/source", Dir: dir, SFiles: []string{"one.s"},
+			}}, plan9asm.ArchAMD64, arch, runtime.GOROOT())
+			if err != nil || len(parseErrs) != 0 || packages != 1 || files != 1 {
+				t.Fatalf("source was lost: err=%v parse=%v packages=%d files=%d", err, parseErrs, packages, files)
+			}
+			if ops["MOVL"] == nil || ops["MOVL"].Count != 2 || ops["ADDL"] == nil || ops["RET"] == nil {
+				t.Fatal("unresolved memory suppressed later instruction inventory")
+			}
+			var contextual int
+			for _, form := range forms {
+				if form.Descriptor.Opcode != "MOVL" && form.Descriptor.Opcode != "CMPB" {
+					continue
+				}
+				contextual += form.ContextCount
+				if form.SupportedCount != 0 || form.UnsupportedCount != 0 {
+					t.Fatalf("unresolved memory was not exclusively contextual: %#v", form)
+				}
+			}
+			if contextual != 3 {
+				t.Fatalf("retained %d contextual probes, want all three exact source operands", contextual)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmscan/value_context_test.go b/cmd/plan9asmscan/value_context_test.go
new file mode 100644
index 000000000..3ffa90968
--- /dev/null
+++ b/cmd/plan9asmscan/value_context_test.go
@@ -0,0 +1,165 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func valueProbeNeedsContext(t *testing.T, arch, body string) {
+	t.Helper()
+	err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+		compactProbeInstructions(t, body))
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Error("unknown input acquired an implementation-slot value", err)
+	}
+	state := &formStat{}
+	classifyFormProbe(state, err)
+	if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+		t.Error("required source context became support or an unknown opcode", state)
+	}
+}
+
+// ProbeInstructionSequence uses real paired lowering, not a standalone pointer
+// query. Defined NUM addresses retain their native faults and memory effects.
+func valueProbePairedNumericAddress(t *testing.T, arch, body string) {
+	t.Helper()
+	err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, compactProbeInstructions(t, body))
+	state := &formStat{}
+	classifyFormProbe(state, err)
+	if err != nil || state.SupportedCount != 1 || state.ContextCount != 0 || state.UnsupportedCount != 0 {
+		t.Fatal("initialized NUM address lost its paired codegen classification", err, state)
+	}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT probe(SB),4,$0-0\n"+body+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := plan9asm.FuncSig{Name: "probe", Ret: plan9asm.Void}
+	if err := plan9asm.CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("paired codegen supplied a standalone pointer/result proof", err)
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	ir, err := plan9asm.Translate(file, plan9asm.Options{Goarch: arch, TargetTriple: triple,
+		Sigs: map[string]plan9asm.FuncSig{"probe": sig}})
+	if err != nil || !(strings.Contains(ir, "load volatile ") || strings.Contains(ir, "store volatile ") ||
+		strings.Contains(ir, "asm sideeffect")) || strings.Contains(ir, "dereferenceable") {
+		t.Fatal("paired NUM probe lost observable native memory or invented backing", err)
+	}
+}
+
+func TestMaskValueCoverageRequiresCompleteInputs(t *testing.T) {
+	// Independent complete KADD/KSHIFT/KUNPCK inventory, not a production map.
+	ops := strings.Fields("KADDB KADDW KADDD KADDQ " +
+		"KSHIFTLB KSHIFTLW KSHIFTLD KSHIFTLQ " +
+		"KSHIFTRB KSHIFTRW KSHIFTRD KSHIFTRQ KUNPCKBW KUNPCKWD KUNPCKDQ")
+	if len(ops) != 15 {
+		t.Fatal("complete mask-value denominator changed")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range ops {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				operands := "K1,K2,K3"
+				if strings.HasPrefix(op, "KSHIFT") {
+					operands = "$255,K1,K3" // An oversized shift still reads K1.
+				}
+				instruction := op + " " + operands
+				valueProbeNeedsContext(t, arch, instruction)
+				prefix := "MOVL $7,AX\nKMOVD AX,K1\nKMOVD AX,K2\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+instruction)); err != nil {
+					t.Error("complete initialized mask sequence rejected", err)
+				}
+				valueProbeNeedsContext(t, arch,
+					strings.Replace(prefix+instruction, "KMOVD AX,K1\n", "", 1))
+			})
+		}
+		for _, width := range []string{"B", "W", "D", "Q"} {
+			t.Run(arch+"/KMOV"+width, func(t *testing.T) {
+				instruction := "KMOV" + width + " K1,K2"
+				valueProbeNeedsContext(t, arch, instruction)
+				prefix := "MOVL $7,AX\nKMOVD AX,K1\n"
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, prefix+instruction)); err != nil {
+					t.Error("complete initialized mask copy rejected", err)
+				}
+			})
+		}
+	}
+}
+
+func TestMaskVectorCoverageRequiresActualData(t *testing.T) {
+	// Independent complete data-move family: K0 is an input, not writemasking.
+	ops := strings.Fields("VPMOVM2B VPMOVM2W VPMOVM2D VPMOVM2Q VPMOVB2M VPMOVW2M VPMOVD2M VPMOVQ2M")
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range ops {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, mask := range []string{"K0", "K7"} {
+					t.Run(arch+"/"+op+"/"+bank+"/"+mask, func(t *testing.T) {
+						instruction := op + " " + bank + "1," + mask
+						prefix := "VPXORD Z1,Z1,Z1\n"
+						if strings.HasPrefix(op, "VPMOVM2") {
+							instruction = op + " " + mask + "," + bank + "1"
+							prefix = "MOVL $7,AX\nKMOVD AX," + mask + "\n"
+						}
+						valueProbeNeedsContext(t, arch, instruction)
+						if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+							compactProbeInstructions(t, prefix+instruction)); err != nil {
+							t.Error("initialized complete mask/vector sequence rejected", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestVectorValueCoverageRequiresCompleteInputs(t *testing.T) {
+	// Register forms independently cover all 14 indexed permutes, three GFNI
+	// operations and six packed bit counts. Public probe execution is Software;
+	// no hardware instruction or native-memory permission is claimed here.
+	ops := strings.Fields("VPERMB VPERMW VPERMI2B VPERMI2W VPERMI2D VPERMI2Q VPERMI2PS VPERMI2PD " +
+		"VPERMT2B VPERMT2W VPERMT2D VPERMT2Q VPERMT2PS VPERMT2PD " +
+		"VGF2P8MULB VGF2P8AFFINEQB VGF2P8AFFINEINVQB " +
+		"VPOPCNTB VPOPCNTW VPOPCNTD VPOPCNTQ VPLZCNTD VPLZCNTQ")
+	if len(ops) != 23 {
+		t.Fatal("complete vector-value denominator changed")
+	}
+	for _, op := range ops {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				t.Run(op+"/"+bank+"/"+mode, func(t *testing.T) {
+					name, immediate, second, mask := op, "", bank+"1,", ""
+					if strings.Contains(op, "AFFINE") {
+						immediate = "$99,"
+					}
+					if strings.HasPrefix(op, "VPOPCNT") || strings.HasPrefix(op, "VPLZCNT") {
+						second = ""
+					}
+					if mode != "plain" {
+						mask = "K1,"
+					}
+					if mode == "zero" {
+						name += ".Z"
+					}
+					instruction := fmt.Sprintf("%s %s%s0,%s%s%s2",
+						name, immediate, bank, second, mask, bank)
+					valueProbeNeedsContext(t, "amd64", instruction)
+					prefix := "MOVL $7,AX\nKMOVD AX,K1\n" +
+						"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, "amd64",
+						compactProbeInstructions(t, prefix+instruction)); err != nil {
+						t.Error("complete initialized vector sequence rejected", err)
+					}
+					valueProbeNeedsContext(t, "amd64",
+						strings.Replace(prefix+instruction, "VPXORD Z0,Z0,Z0\n", "", 1))
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/vector_test_context_test.go b/cmd/plan9asmscan/vector_test_context_test.go
new file mode 100644
index 000000000..44bb2eb7c
--- /dev/null
+++ b/cmd/plan9asmscan/vector_test_context_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestVectorTestCoverageRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"PTEST", "VPTEST", "VTESTPD", "VTESTPS"} {
+			banks := []string{"X"}
+			if name != "PTEST" {
+				banks = append(banks, "Y")
+			}
+			for _, bank := range banks {
+				t.Run(arch+"/"+name+"/"+bank, func(t *testing.T) {
+					line := name + " " + bank + "0," + bank + "1"
+					prefix := "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+					valueProbeNeedsContext(t, arch, line)
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+						compactProbeInstructions(t, prefix+line)); err != nil {
+						t.Fatal("complete vector-test inputs became unsupported", err)
+					}
+					for _, remove := range []string{"VPXORD Z0,Z0,Z0\n", "VPXORD Z1,Z1,Z1\n"} {
+						valueProbeNeedsContext(t, arch, strings.Replace(prefix+line, remove, "", 1))
+					}
+					valueProbePairedNumericAddress(t, arch, prefix+"MOVL $1,AX\n"+name+" (AX),"+bank+"1")
+				})
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/versioned_namespaces_test.go b/cmd/plan9asmscan/versioned_namespaces_test.go
new file mode 100644
index 000000000..677572975
--- /dev/null
+++ b/cmd/plan9asmscan/versioned_namespaces_test.go
@@ -0,0 +1,127 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type auditedNamespaceCounts struct {
+	official, frontend int
+}
+
+var namespaceArchitectures = []string{"386", "amd64", "arm", "arm64", "wasm"}
+
+// These distinct denominators come from the audited original source trees:
+// official is architecture-specific Anames; frontend also retains common,
+// alias, pseudo and sentinel registrations with their case-sensitive spelling.
+// Neither count is a lowering, object or runtime coverage assertion.
+var auditedGoNamespaces = map[string]map[string]auditedNamespaceCounts{
+	"go1.20": {
+		"386":   {official: 1598, frontend: 1655},
+		"amd64": {official: 1598, frontend: 1655},
+		"arm":   {official: 135, frontend: 155},
+		"arm64": {official: 535, frontend: 554},
+		"wasm":  {official: 208, frontend: 226},
+	},
+	"go1.21": {
+		"386":   {official: 1599, frontend: 1656},
+		"amd64": {official: 1599, frontend: 1656},
+		"arm":   {official: 135, frontend: 155},
+		"arm64": {official: 531, frontend: 550},
+		"wasm":  {official: 207, frontend: 225},
+	},
+	"go1.22": {
+		"386":   {official: 1599, frontend: 1656},
+		"amd64": {official: 1599, frontend: 1656},
+		"arm":   {official: 135, frontend: 155},
+		"arm64": {official: 531, frontend: 550},
+		"wasm":  {official: 207, frontend: 225},
+	},
+	"go1.23": {
+		"386":   {official: 1599, frontend: 1657},
+		"amd64": {official: 1599, frontend: 1657},
+		"arm":   {official: 135, frontend: 156},
+		"arm64": {official: 531, frontend: 551},
+		"wasm":  {official: 207, frontend: 226},
+	},
+	"go1.24": {
+		"386":   {official: 1599, frontend: 1657},
+		"amd64": {official: 1599, frontend: 1657},
+		"arm":   {official: 137, frontend: 158},
+		"arm64": {official: 531, frontend: 551},
+		"wasm":  {official: 207, frontend: 226},
+	},
+	"go1.25": {
+		"386":   {official: 1600, frontend: 1658},
+		"amd64": {official: 1600, frontend: 1658},
+		"arm":   {official: 137, frontend: 158},
+		"arm64": {official: 532, frontend: 552},
+		"wasm":  {official: 207, frontend: 226},
+	},
+	"go1.26": {
+		"386":   {official: 1600, frontend: 1658},
+		"amd64": {official: 1600, frontend: 1658},
+		"arm":   {official: 137, frontend: 158},
+		"arm64": {official: 538, frontend: 558},
+		"wasm":  {official: 207, frontend: 226},
+	},
+	"go1.27": {
+		"386":   {official: 1600, frontend: 1658},
+		"amd64": {official: 1600, frontend: 1658},
+		"arm":   {official: 137, frontend: 158},
+		"arm64": {official: 1342, frontend: 1362},
+		"wasm":  {official: 463, frontend: 502},
+	},
+}
+
+var auditedGoRelease = regexp.MustCompile(`^(go1\.[1-9][0-9]*)(?:\.(?:0|[1-9][0-9]*))?$`)
+
+func lookupAuditedGoNamespaces(version, arch string) (auditedNamespaceCounts, error) {
+	match := auditedGoRelease.FindStringSubmatch(version)
+	if match == nil {
+		return auditedNamespaceCounts{}, fmt.Errorf("unaudited Go source version %q", version)
+	}
+	counts, ok := auditedGoNamespaces[match[1]][arch]
+	if !ok {
+		return auditedNamespaceCounts{}, fmt.Errorf("unaudited Go source namespace %s/%s", version, arch)
+	}
+	return counts, nil
+}
+
+func actualGoNamespaceCounts(t *testing.T, arch string) auditedNamespaceCounts {
+	t.Helper()
+	version := runtime.Version()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "VERSION"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if first := strings.Split(string(data), "\n")[0]; first != version {
+		t.Fatalf("actual driver %s differs from GOROOT source VERSION %q", version, first)
+	}
+	counts, err := lookupAuditedGoNamespaces(version, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual source %s/%s: official=%d frontend=%d", version, arch, counts.official, counts.frontend)
+	return counts
+}
+
+func TestAuditedGoSourceNamespacesRejectUnknownVersions(t *testing.T) {
+	for _, arch := range namespaceArchitectures {
+		t.Run(arch, func(t *testing.T) {
+			for _, version := range []string{"", "go1.19.13", "go1.28.1", "go1.270.1", "devel go1.27", "go1.27rc1", "go1.27.1-unknown", "go1.27.01"} {
+				if _, err := lookupAuditedGoNamespaces(version, arch); err == nil {
+					t.Errorf("unknown version %q supplied %s namespace counts", version, arch)
+				}
+			}
+			if _, err := lookupAuditedGoNamespaces("go1.27.1", arch+"-unknown"); err == nil {
+				t.Fatal("unknown architecture supplied namespace counts")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmscan/waitpkg_context_test.go b/cmd/plan9asmscan/waitpkg_context_test.go
new file mode 100644
index 000000000..e9a9e09e4
--- /dev/null
+++ b/cmd/plan9asmscan/waitpkg_context_test.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestWaitPKGCoverageRequiresDeadlineAndControl(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"UMWAIT", "TPAUSE"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				for _, setup := range []string{"", "MOVL $0,AX\nMOVL $0,DX\n", "MOVL $0,BX\n",
+					"MOVL $0,AX\nMOVL $0,BX\nMOVB $0,DL\n"} {
+					valueProbeNeedsContext(t, arch, setup+op+" BX")
+				}
+				if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch,
+					compactProbeInstructions(t, "MOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\n"+op+" BX")); err != nil {
+					t.Error("complete initialized wait rejected", err)
+				}
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmscan/x87_context_test.go b/cmd/plan9asmscan/x87_context_test.go
new file mode 100644
index 000000000..8c858851e
--- /dev/null
+++ b/cmd/plan9asmscan/x87_context_test.go
@@ -0,0 +1,60 @@
+package main
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestX87CoverageProbesRequireSourceInputs(t *testing.T) {
+	// The complete Go conditional family includes six aliases absent from the
+	// current official syntax corpus. Never seed an isolated probe from private
+	// zeroed registers, FLAGS, or an implicit default x87 control word.
+	ops := strings.Fields("FCMOVCC FCMOVCS FCMOVEQ FCMOVHI FCMOVLS FCMOVB FCMOVBE " +
+		"FCMOVNB FCMOVNBE FCMOVE FCMOVNE FCMOVNU FCMOVU FCMOVUN FRNDINT")
+	parse := func(t *testing.T, body string) []plan9asm.Instr {
+		t.Helper()
+		file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT probe(SB),4,$0-0\n"+body+"\nRET\n")
+		if err != nil || len(file.Funcs) != 1 {
+			t.Fatal("independent probe fixture did not parse", err)
+		}
+		return file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1]
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range ops {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				instruction := op + " F1,F0"
+				body := "FINIT\nFLD1\nFLD1\nMOVL $0,AX\nCMPL AX,AX\n" + instruction + "\nFINIT"
+				missing := strings.Replace(body, "CMPL AX,AX\n", "", 1)
+				if op == "FRNDINT" {
+					instruction = op
+					body = "FINIT\nFLD1\nFRNDINT\nFMOVDP F0,F0"
+					missing = strings.Replace(body, "FLD1\n", "", 1)
+				}
+				t.Run("isolated-context", func(t *testing.T) {
+					err := plan9asm.ProbeInstruction(plan9asm.ArchAMD64, arch, parse(t, instruction)[0])
+					if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("isolated opcode acquired an undefined x87 input or predicate", err)
+					}
+					state := &formStat{}
+					classifyFormProbe(state, err)
+					if state.ContextCount != 1 || state.SupportedCount != 0 || state.UnsupportedCount != 0 {
+						t.Fatal("required source context was counted as supported or an unknown opcode", state)
+					}
+				})
+				t.Run("initialized-sequence", func(t *testing.T) {
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, parse(t, body)); err != nil {
+						t.Fatal("complete explicit x87 inputs and predicate did not close the probe", err)
+					}
+				})
+				t.Run("missing-input", func(t *testing.T) {
+					if err := plan9asm.ProbeInstructionSequence(plan9asm.ArchAMD64, arch, parse(t, missing)); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("sequence without its actual input/predicate producer was accepted", err)
+					}
+				})
+			})
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/README.md b/cmd/plan9asmtest/README.md
new file mode 100644
index 000000000..a296a411e
--- /dev/null
+++ b/cmd/plan9asmtest/README.md
@@ -0,0 +1,316 @@
+# Exhaustive package and module test partitions
+
+`plan9asmtest` runs one exact Go package in fresh, owned child processes. It
+discovers the complete current `Test`, runnable `Example` and `Fuzz` inventory
+with actual `go test -list=.`; no checked-in test list is used. Go's separately
+listed benchmarks are retained in the report but not run, matching ordinary
+`go test` without `-bench`. Fuzz targets run their normal seed corpus, not a
+fuzzing campaign. Every emitted subtest and seed must also terminate.
+
+From the repository root, select the required Go/LLVM tools described in
+[validation](../../docs/development/validation.md), then use a new output path:
+
+```sh
+mkdir -p _out
+GOFLAGS= go run ./cmd/plan9asmtest \
+  -out _out/root-partitions-current -shards 32 -timeout 45m
+```
+
+Ordinary mode is serial by default. Add `-workers 2` for bounded parallel
+partitions; the allowed range is 1..32 and cannot exceed `-shards`. Start small
+because each process owns its own LLVM objects and compiler children. The
+report records the actual worker limit. Parallelism does not alter the actual
+inventory, deterministic assignment, build flags, per-child timeout or coverage checks.
+Only one collector publishes reports and counts. A failed shard remains failed
+while other shards run; a failed publication cancels and waits for active owners.
+Selected cross-runtime CI owners remain serial and reject `-workers` above one.
+
+## Complete main-module CI suites
+
+Unix test/race/coverage CI uses `scripts/test-module-ci.sh`. Its three package
+owners share the complete actual `go list -json ./...` package inventory:
+owner zero runs the root, owner one runs `gotoolprofile` and `internal/sdkfrontend`,
+and owner two runs every other package. The two owner-one packages run serially;
+each uses the same exhaustive root partitions and at most two active commands.
+Independent SDK source captures retain their own original budgets and lifetimes,
+while no longer accumulating in a single unfiltered race command.
+CI splits only owner zero into sixteen jobs for test/
+coverage and 32 for race. Part `p` owns global shard indices `i` where
+`i % parts == p`. Test/coverage keep 32 shards; race uses 64 shards. Every
+root owner executes exactly two shards in one two-worker wave. Test/coverage
+retain 45-minute command and 60-minute job budgets; race retains 60-minute
+commands and 75-minute jobs. Shared-profile and other packages execute once;
+they are not repeated for each root part. Only explicit owner two overlaps at
+most `-workers` complete package commands; each package keeps one shard/worker.
+Its single collector retains inventory order, records failures without stopping
+other packages, and joins active commands on cancellation without dispatching
+the remaining packages. The worker and command/job budgets are unchanged.
+Every other package runs complete ordinary `go test` without `-run`, including packages
+with no tests or only benchmarks/TestMain. Every package has its own actual
+`-list=.` receipt, including runnable examples/fuzz targets and separately
+recorded benchmarks. Nested CLI modules are not main-module packages; their
+independent complete-module workflows remain required. Windows uses the same
+strict module protocol with sixteen root parts for the main module and four for
+each CLI, preserving profile/rest ownership and the thirty-minute command budget.
+Linux CLI test and coverage jobs use `scripts/test-linux-cli-module-ci.sh` with
+the same complete eight-shard/four-part layout, two workers and thirty-minute
+commands. Each root part has its own sixty-minute job. Part zero also executes
+the actual profile/rest owners into separate reports; both CLI inventories
+currently contain only their root package, so these roles execute zero tests,
+not additional passing roots. The independent aggregate requires all four root
+fragments and both role reports, including fresh inventory and raw terminals.
+Only complete coverage aggregation creates each CLI's original profile and
+summary; CLI profiles are not merged into main-module coverage.
+The Windows driver selects a minimal Go/LLVM22/Node/Python/jq/Git/system PATH
+before either execution or verification; unrelated hosted-image search paths
+cannot change the cross-owner plan. Raw and normalized environment equality
+remains strict, including PATH.
+
+```sh
+# Each command is a separate CI job, not concurrent local invocations.
+bash scripts/test-module-ci.sh race execute 0 0
+# Run race root parts 1..31 as separate jobs with owner 0 and their exact number.
+bash scripts/test-module-ci.sh race execute 1 -1
+bash scripts/test-module-ci.sh race execute 2 -1
+# Download root-p artifacts into owner-0000/part-000p, and profile/rest into
+# owner-0001 and owner-0002. All 34 race roles are required for completion;
+# test/coverage require their sixteen root parts plus profile/rest.
+bash scripts/test-module-ci.sh race complete
+```
+
+Root fragments use schema 2 `partition.json` and the distinct
+`actual_go_complete_module_root_parts_v2` module protocol. They retain the
+complete root list and all 32 (64 for race) global shard entries. Unassigned shards are
+`not_owned`, with no command, terminal or coverage artifact. A fragment is
+`completed_owned` or `completed_empty`, never a complete package pass. Empty
+assigned shards likewise do not receive executing-test credit.
+
+The completion job uses fresh source/SDK/tool/full-environment, package and
+complete root `-list=.` observations, then rereads every package's original
+inventory, exact command, raw JSON root/child terminals and coverage. It
+recomputes global ownership and requires the complete disjoint 32- or 64-shard union;
+paired report/log deletions cannot shrink the fresh denominator. Artifact directories
+may move; executable/tool/source identities and environment semantics may not.
+Unknown, duplicate, missing, partial or foreign results fail. Tests that skip
+remain explicit skip counters and `completed_with_skips`, never passed roots.
+Any package failure is sticky while all other packages continue. Cancellation
+retains pending/missing entries and owned subprocess cleanup.
+
+A root with no tests or only benchmarks has one actual unfiltered execution,
+owned only by part zero; other parts retain their actual listing observations
+but execute no shard. These package executions do not invent named test passes.
+Go's listing command itself enters package initialization and `TestMain` when
+present, so this is not a claim that `TestMain` runs only once across jobs.
+Benchmarks remain listed but are never executed without `-bench`.
+
+Module scope also binds the actual Node interpreter, independently selected
+LLVM 22 wasm linker, selected SDK's complete wasm runtime directory, and
+`llvm-config --libfiles --link-shared` library files. When the actual selected
+package graph contains the native Go LLVM binding, its selected source files
+and an owned loader query bind the library actually providing
+`LLVMContextCreate`. These are dependency observations, not runtime-test passes.
+Missing dependencies fail. Nonempty `NODE_OPTIONS`, `NODE_PATH` and
+`NODE_ICU_DATA` remain unsupported because their delegated runtime inputs are
+not captured; their absent/empty values are recorded in the environment scope.
+
+Coverage combines the checked profiles of **all** main-module packages, not
+just the root. Mode, statement counts, overlaps and counter overflow are
+validated. Owners never publish the uploadable module coverage file. Each root
+fragment checks its own raw profiles into `partition.cover`; only successful
+complete aggregation checks the full root profile union, combines all packages
+and creates the uploadable module file. The original 45m test/coverage
+and 60m race per-command budgets are unchanged, as are race/coverage flags.
+Independent owners avoid sharing a single job's wall-clock budget. This is
+not evidence that any particular giant test completes within that budget.
+
+For a single local invocation use `-module` without `-module-owner`; it runs
+the same complete inventory serially across packages. Select explicit
+`GOENV=off GOWORK=off GOTOOLCHAIN=local GOFLAGS=` and the required LLVM 22 tools.
+Use a clean checkout, new artifact/coverage paths, and an artifact directory
+outside a nongit first-party fixture's source tree. Source-changing compiler
+flags (`-overlay`, `-modfile`, `-gcflags`, `-asmflags`, `-ldflags`) remain
+available in ordinary package mode but are not source-indexed by module mode.
+
+The large shared-profile test package can use the same complete mechanism:
+
+```sh
+GOFLAGS= go run ./cmd/plan9asmtest \
+  -package github.com/xgo-dev/plan9asm/gotoolprofile \
+  -out _out/profile-test-partitions -shards 32 -workers 2 -timeout 45m -- -race -p=1
+```
+
+This runs the shared-profile package's Go tests, not the discovered-library corpus.
+
+Ordinary single-package mode covers **only its selected package**, not root
+`./...`, the nested CLI modules, strict stdlib/object gates or cross-runtime
+jobs. Module mode covers all main-module packages, but the other independent
+gates remain required. Without module mode, run every other main-module package
+without repeating the root:
+
+```sh
+go list ./... > _out/non-root-packages.txt || exit 1
+suite_status=0
+while IFS= read -r pkg; do
+  if [ "$pkg" != github.com/xgo-dev/plan9asm ]; then
+    go test "$pkg" -count=1 -timeout=45m || suite_status=1
+  fi
+done < _out/non-root-packages.txt
+test "$suite_status" -eq 0
+```
+
+Use the same race/coverage/build flags for those other packages when required.
+Ordinary mode's coverage profile is root-package
+coverage only, not a replacement for the original module-wide profile.
+
+Build/instrumentation flags follow `--`, for example:
+
+```sh
+GOFLAGS= go run ./cmd/plan9asmtest \
+  -out _out/root-partitions-race-cover -shards 64 -timeout 60m -- \
+  -race -covermode=atomic -coverprofile=coverage-root.out -p=1
+```
+
+The tool can be built/run from a separate tool checkout while targeting a
+clean frozen source checkout through `-dir /path/to/frozen-source`. Neither
+checkout is edited. An absolute `-out` separates tool evidence from source.
+
+The actual list and every execution use identical build flags. Each nonempty
+partition has an independently generated coverage profile. Only after all
+children and JSON validations succeed are the profiles merged into a **new**
+destination, checking identical block/statement inventories and modes. `set`
+counters combine by OR; `count`/`atomic` combine by checked uint64 addition.
+Failed runs retain their separate profiles, not a misleading merged result.
+
+Supported flags are `-race`, `-cover`, `-covermode`, `-coverpkg`, `-tags`, `-p`,
+`-gcflags`, `-asmflags`, `-ldflags`, `-mod`, `-modfile`, `-overlay`, `-trimpath`,
+`-asan`, `-msan` and `-work`. Filters, `-count`, `-fuzz`, benchmarks, custom
+executors and test arguments are rejected. `GOFLAGS` must be empty, except that
+Windows may inherit exactly `-tags=byollvm` when the same tag is explicitly
+passed after `--`. This preserves the LLVM binding selection in nested Go
+commands. Missing, conflicting or duplicate tags fail before execution; no
+other inherited flags are accepted. Module scope retains the actual environment.
+The runner forces `-count=1`; successful cached runs cannot replace execution.
+
+## Proof and failure behavior
+
+The sorted inventory hashes newline-separated names with SHA-256. Ordinary
+roots retain the first eight bytes of their name's SHA-256, interpreted
+big-endian modulo the shard count. In every instrumentation mode, complete
+fixed-local object families use fixed semantic ordinals modulo that same count:
+conversion target/batches
+0–35, packed target/batches 36–47, CMOV target/batches 48–59, readonly targets
+60–62, wide Translate/Module/GoModule object owners 63–65, and native-wide
+whole-source batches 66–71, and native-conversion whole-source batches 72–78. Targets keep
+Linux/Darwin/Windows order (CMOV has Linux/Darwin), and batches keep numerical
+order. These roles distribute complete costly sources without moving ordinary
+roots or changing ownership when input order, unrelated roots or a subset
+changes. Plain and coverage runs need the same protection against cumulative
+heavy-family collisions as race runs. Instrumentation flags remain strictly
+validated and recorded; they never change ownership. Execution and both
+independent receipt readers derive the same plan, never an implicit
+host/environment setting.
+An independent source-AST check retains all 79 roles. This is a
+scheduling rule, not runtime qualification: exact current-head execution must
+still fit its original deadlines. No role creates a missing listed test.
+Sorting/sharding never deletes a name. Empty
+partitions are explicitly recorded; an entirely empty inventory fails.
+The exact escaped alternation selects every planned root in its partition.
+A pattern over 16,000 bytes fails and asks for more shards; it is never cut to
+fit command-line limits.
+
+`report.json` retains the complete plan, commands, per-root/subtest/seed
+outcomes, elapsed times, incomplete counts and errors. Raw actual inventory,
+Go version, JSON and stderr logs remain alongside it. Each root must have one
+actual run and one terminal pass/fail/skip; unknown, missing or repeated roots,
+unterminated seeds, malformed JSON, failed package/child exits and timeouts
+fail. Other partitions are still attempted after a failure. Existing Go skips
+are counted separately from assertions passed; they do not prove execution of
+the skipped semantics. Required cross/native counterpart jobs remain required.
+
+The wall deadline also covers compilation; Go receives the same test timeout.
+Combined stdout/stderr capture is bounded at 64 MiB per command. On Unix every
+child owns a process group, terminated on cancellation **and ordinary exit**,
+with a bounded output-pipe wait. Interrupt, TERM and HUP cancel owned groups.
+This releases LLVM contexts between shards on Linux and Darwin.
+Windows ordinary package partitions use a private non-breakaway Job Object.
+The leader starts suspended and joins that job before its initial thread runs;
+cancellation and ordinary exit terminate all descendants, including inherited
+output-pipe holders. Cleanup waits for the actual Job's completion-port exit
+notification, not merely accounting zero, and retains cleanup errors. Unrelated
+processes never belong to that job. Other non-Unix systems still fail explicitly.
+Windows module scope observes the real Go LLVM consumer's imported DLL, exact
+LLVM 22 tools, source inventory and inherited/explicit `byollvm` selection. Only
+the independent complete-module aggregate publishes coverage; partial root
+ownership is `completed_owned`, never a whole-module pass.
+
+Freeze source, environment and tools throughout a real suite run. Reports
+describe the invoked Go tests, not assembly-ledger or external-module coverage.
+The runner never deletes caller caches or modifies baseline/scan inputs.
+
+## Selected cross-runtime CI owners
+
+The required cross-runtime job uses a separate
+`actual_go_selected_ci_partitions_v1` protocol. Its original complete five-prefix
+selector is applied to the complete actual `-list=.` inventory and checked
+against a second actual Go `-list=<selector>` observation with identical build
+flags. Nonselected roots remain in the full inventory; benchmarks remain listed,
+not executed. Ordinary schema-1 reports and full-root behavior are unchanged.
+
+Sixteen jobs own the selected roots exhaustively and disjointly. The exact
+`TestCrossLinuxRuntimeMatrix` root alone belongs to owner zero; the first eight
+SHA-256 bytes of every other selected name, big-endian modulo fifteen plus one,
+assign owners one through fifteen. There is no concurrency cap or fail-fast
+matrix cancellation. Each owned root runs in a fresh bounded child with the
+existing **20-minute** deadline and `-count=1`. Failures stay sticky while later
+roots are attempted. Empty owners are explicitly receipted, not credited as
+executing semantics. This mechanism does not prove the giant root itself fits
+its unchanged deadline.
+
+For example, with the required SDK/LLVM/cross tools already installed:
+
+```sh
+GOFLAGS= GOENV=off GOWORK=off GOTOOLCHAIN=local PLAN9ASM_CROSS_EXEC=1 \
+  go run ./cmd/plan9asmtest -out _out/cross-runtime-owner \
+  -ci-selector '^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance|TestARM64RawSQSHLURuntimeSemantics|TestARMIntegerMemoryRuntimeCross|TestARMRawSaturationRuntimeCross)' \
+  -ci-isolate-root TestCrossLinuxRuntimeMatrix -ci-owner 0 -shards 16 -timeout 20m
+```
+
+All sixteen artifacts are required by `-verify-ci-partitions <directory>`, with
+the identical selector/isolate/shard/timeout/build configuration. It independently
+recaptures both actual inventories and source/SDK/tool/environment scope,
+recomputes ownership, and reads every root's bounded raw Go JSON and actual exit.
+Missing, duplicated, foreign, incomplete, failed or skipped roots/subtests/seeds
+fail completion. Paired plan/receipt deletion cannot shrink the denominator.
+It also checks raw inventory/environment/version/tool-origin observations and
+before/after guards. The required native tool names and bytes are retained;
+cache and workspace spelling are not cross-job source identity. Inherited
+`GOFLAGS`, user `GOENV`, workspace switching and toolchain fallback are forbidden.
+
+The environment scope retains **every actual `go env -json` field**, including
+unknown future fields and the complete compiler flags. Only explicitly named
+SDK/source/storage roots and the Go-generated prefix-map temporary nonce are
+normalized. That nonce must be a direct `go-build<decimal>` child of the observed
+temporary root mapped to exactly `/tmp/go-build`; all other flag bytes, ordering
+and quote spelling stay exact. Raw physical observations remain in artifacts
+and the aggregate reconstructs this comparison independently. Lazy SDK tools
+are resolved with the selected driver's actual `go tool -n`, not guessed paths.
+
+Process controls are a separate explicit boundary: all `PLAN9ASM_*` and
+`QEMU_*` variables, `SELF_BL_SINK`, LLVM/tool search, Go runtime, compiler include,
+loader and sanitizer controls are retained. This does not claim complete ambient
+machine/ISA/sysroot/library identity or copy unrelated CI credentials. Required
+original/native preflights and runtime comparisons still determine those
+semantics; hosted-runner labels are not ISA certificates.
+
+Worker artifacts retain physical paths, failures and logs; matching source and
+SDK content hashes permit separate checkout locations, not different source or
+compiler versions. Test completion is not an assembly-ledger, external-library
+runtime, or unexecuted architecture claim. Coverage-profile merging remains an
+ordinary full-root feature rather than a selected-CI waiver.
+External compiler-input flags (`-overlay`, `-modfile`, `-gcflags`, `-asmflags`,
+`-ldflags`) are not registered in this initial CI protocol: its source guard
+cannot silently authenticate files supplied outside the checkout. Ordinary
+mode keeps its existing support for those flags.
+External cache/package drivers and compound compiler-wrapper commands likewise
+remain unregistered. The native scope binds the actual `CC`, `CXX`, `AR` and
+`PKG_CONFIG` executable bytes as well as the required LLVM/cross/QEMU tools.
diff --git a/cmd/plan9asmtest/build_context.go b/cmd/plan9asmtest/build_context.go
new file mode 100644
index 000000000..e84c5c647
--- /dev/null
+++ b/cmd/plan9asmtest/build_context.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Windows' externally configured LLVM binding also needs its tag in nested
+// Go commands. Preserve that one inherited setting only when the invocation
+// explicitly declares the identical selection. Reports retain the declared
+// flags, and module scopes retain the unchanged actual GOFLAGS observation.
+func validateRunnerGoFlags(goos, inherited string, flags []string) error {
+	if inherited == "" {
+		return nil
+	}
+	if goos != "windows" || inherited != "-tags=byollvm" {
+		return fmt.Errorf("GOFLAGS must be empty except for explicitly declared Windows -tags=byollvm")
+	}
+	forwarded, _, err := validateFlags(flags)
+	if err != nil {
+		return err
+	}
+	tags := 0
+	for i := 0; i < len(forwarded); i++ {
+		name, value, inline := strings.Cut(forwarded[i], "=")
+		if !inline && !runnerBooleanFlag(strings.TrimPrefix(name, "-")) {
+			i++ // validateFlags already checked the value exists.
+			value = forwarded[i]
+		}
+		if name != "-tags" {
+			continue
+		}
+		tags++
+		if tags != 1 || value != "byollvm" {
+			return fmt.Errorf("explicit build tags conflict with inherited GOFLAGS=-tags=byollvm")
+		}
+	}
+	if tags != 1 {
+		return fmt.Errorf("inherited GOFLAGS=-tags=byollvm requires explicit -tags=byollvm")
+	}
+	return nil
+}
diff --git a/cmd/plan9asmtest/build_context_test.go b/cmd/plan9asmtest/build_context_test.go
new file mode 100644
index 000000000..e1a5f430f
--- /dev/null
+++ b/cmd/plan9asmtest/build_context_test.go
@@ -0,0 +1,42 @@
+package main
+
+import "testing"
+
+func TestRunnerInheritedBuildContextIsExplicitAndNarrow(t *testing.T) {
+	for _, flags := range [][]string{
+		{"-tags=byollvm"},
+		{"-tags", "byollvm", "-p=2", "-coverprofile=complete.cover"},
+	} {
+		if err := validateRunnerGoFlags("windows", "-tags=byollvm", flags); err != nil {
+			t.Fatal("declared Windows binding context", err)
+		}
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		if err := validateRunnerGoFlags(goos, "", nil); err != nil {
+			t.Fatal("ordinary empty environment changed", err)
+		}
+		for _, inherited := range []string{
+			"-run=TestOne", "-count=0", "-tags=byollvm -run=TestOne",
+			"-tags=byollvm ", "-tags=byollvm,foreign", "-tags byollvm",
+		} {
+			if err := validateRunnerGoFlags(goos, inherited, []string{"-tags=byollvm"}); err == nil {
+				t.Fatalf("hidden/filtering environment accepted: %s %q", goos, inherited)
+			}
+		}
+		if goos != "windows" {
+			if err := validateRunnerGoFlags(goos, "-tags=byollvm", []string{"-tags=byollvm"}); err == nil {
+				t.Fatal("Windows exception leaked to another host", goos)
+			}
+		}
+	}
+	for _, flags := range [][]string{
+		nil, {"-tags"}, {"-tags=foreign"}, {"-tags=byollvm,foreign"},
+		{"-tags=byollvm", "-tags=byollvm"}, {"-tags=byollvm", "-tags=foreign"},
+		{"-tags=byollvm", "-run=TestOne"}, {"-tags=byollvm", "-count=0"},
+		{"-gcflags", "-tags=byollvm"}, {"-ldflags", "-tags=byollvm"},
+	} {
+		if err := validateRunnerGoFlags("windows", "-tags=byollvm", flags); err == nil {
+			t.Fatalf("undeclared/conflicting/filtered build selection accepted: %v", flags)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/build_context_windows_test.go b/cmd/plan9asmtest/build_context_windows_test.go
new file mode 100644
index 000000000..fb47bad08
--- /dev/null
+++ b/cmd/plan9asmtest/build_context_windows_test.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestWindowsInheritedLLVMBuildContext(t *testing.T) {
+	// The Windows LLVM setup supplies byollvm to nested Go commands as well.
+	// Explicit top-level flags must agree; clearing GOFLAGS would silently
+	// change the source selection of subprocesses invoked by a test.
+	t.Setenv("GOFLAGS", "-tags=byollvm")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":      "module example.org/inherited-build-context\n\ngo 1.20\n",
+		"selected.go": "//go:build byollvm\n\npackage selected\nconst Value = 7\n",
+		"other.go":    "//go:build !byollvm\n\npackage wrong\nconst Value = 9\n",
+		"selected_test.go": `//go:build byollvm
+
+package selected
+import (
+    "os/exec"
+    "strings"
+    "testing"
+)
+func TestSelection(t *testing.T) {
+    if Value != 7 { t.Fatal("outer source selection changed") }
+    command := exec.Command("go", "list", "-f", "{{.Name}}", ".")
+    data, err := command.CombinedOutput()
+    if err != nil || strings.TrimSpace(string(data)) != "selected" {
+        t.Fatalf("nested source selection changed: %s %v", data, err)
+    }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cfg := config{Go: "go", Dir: dir, Package: ".", Out: filepath.Join(t.TempDir(), "suite"),
+		Shards: 2, Workers: 2, Timeout: time.Minute, Flags: []string{"-tags=byollvm"}}
+	if err := runSuite(context.Background(), cfg); err != nil {
+		t.Fatal(err)
+	}
+	var report suiteReport
+	if err := ciReadJSON(filepath.Join(cfg.Out, "report.json"), &report); err != nil {
+		t.Fatal(err)
+	}
+	if report.RootPassed != 1 || report.RootSkipped != 0 || report.RootMissing != 0 ||
+		len(report.Flags) != 1 || report.Flags[0] != "-tags=byollvm" {
+		t.Fatalf("actual inherited/declared build selection missing: %+v", report)
+	}
+	for _, flags := range [][]string{nil, {"-tags=foreign"}, {"-tags=byollvm", "-tags=foreign"}} {
+		cfg.Flags = flags
+		cfg.Out = filepath.Join(t.TempDir(), "rejected")
+		if err := runSuite(context.Background(), cfg); err == nil {
+			t.Fatalf("undeclared/conflicting inherited build selection accepted: %v", flags)
+		}
+		if _, err := os.Stat(cfg.Out); !os.IsNotExist(err) {
+			t.Fatalf("conflicting build selection started a suite: %v", err)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/byte_carrier_cache_test.go b/cmd/plan9asmtest/byte_carrier_cache_test.go
new file mode 100644
index 000000000..fcc742f52
--- /dev/null
+++ b/cmd/plan9asmtest/byte_carrier_cache_test.go
@@ -0,0 +1,134 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func checkByteCarrierParentBuildCache(source []byte, name string) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "carrier_test.go", source, 0)
+	if err != nil {
+		return err
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != name || function.Body == nil {
+			continue
+		}
+		caches := make(map[string]bool)
+		for _, statement := range function.Body.List {
+			assignment, ok := statement.(*ast.AssignStmt)
+			if !ok || assignment.Tok != token.DEFINE || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				continue
+			}
+			variable, variableOK := assignment.Lhs[0].(*ast.Ident)
+			call, callOK := assignment.Rhs[0].(*ast.CallExpr)
+			if !variableOK || !callOK || len(call.Args) != 0 {
+				continue
+			}
+			selector, ok := call.Fun.(*ast.SelectorExpr)
+			if receiver, valid := selectorReceiver(selector); ok && valid && receiver == "t" && selector.Sel.Name == "TempDir" {
+				caches[variable.Name] = true
+			}
+		}
+		requests := 0
+		var requestError error
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			helper, ok := call.Fun.(*ast.Ident)
+			if !ok {
+				return true
+			}
+			switch helper.Name {
+			case "arm64ByteCarrierRequest":
+				requestError = fmt.Errorf("%s recreates a cold builtin-tool cache inside its matrix", name)
+			case "arm64ByteCarrierRequestWithBuildCache":
+				requests++
+				if len(call.Args) != 4 {
+					requestError = fmt.Errorf("%s changed its independent source request", name)
+					break
+				}
+				cache, ok := call.Args[3].(*ast.Ident)
+				if !ok || !caches[cache.Name] {
+					requestError = fmt.Errorf("%s needs a parent-owned build cache", name)
+				}
+			}
+			return true
+		})
+		if requestError != nil {
+			return requestError
+		}
+		if requests != 1 {
+			return fmt.Errorf("%s lost its shared-cache request: %d", name, requests)
+		}
+		return nil
+	}
+	return fmt.Errorf("missing complete carrier matrix %s", name)
+}
+
+func selectorReceiver(selector *ast.SelectorExpr) (string, bool) {
+	if selector == nil {
+		return "", false
+	}
+	receiver, ok := selector.X.(*ast.Ident)
+	if !ok {
+		return "", false
+	}
+	return receiver.Name, true
+}
+
+func TestByteCarrierMatricesReuseOnlyParentBuildCache(t *testing.T) {
+	for name, filename := range map[string]string{
+		"TestARM64ByteCarrierTwoScalarNativeWidthConsumers":        "arm64_byte_carrier_two_scalar_go127_test.go",
+		"TestARM64ByteCarrierSignedCompleteWidthObjects":           "arm64_byte_carrier_signed_matrix_go127_test.go",
+		"TestARM64ByteCarrierConsumersRejectUnclosedNativeEffects": "arm64_byte_carrier_effects_go127_test.go",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source, err := os.ReadFile(filepath.Join("..", "..", filename))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkByteCarrierParentBuildCache(source, name); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestByteCarrierCachePolicyRejectsColdAndChildOwnedCaches(t *testing.T) {
+	const source = `package main
+func TestMatrix(t *testing.T) {
+	buildCache := t.TempDir()
+	for _, row := range rows {
+		t.Run(row.name, func(t *testing.T) {
+			request := arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)
+			consume(request)
+		})
+	}
+}
+`
+	if err := checkByteCarrierParentBuildCache([]byte(source), "TestMatrix"); err != nil {
+		t.Fatal(err)
+	}
+	for name, changed := range map[string]string{
+		"cold":        strings.Replace(source, "arm64ByteCarrierRequestWithBuildCache(t, directory, packagePath, buildCache)", "arm64ByteCarrierRequest(t, directory, packagePath)", 1),
+		"child-owned": strings.Replace(source, "buildCache := t.TempDir()", "", 1),
+		"per-request": strings.Replace(source, "packagePath, buildCache)", "packagePath, t.TempDir())", 1),
+		"wrong-cache": strings.Replace(source, "packagePath, buildCache)", "packagePath, anotherCache)", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := checkByteCarrierParentBuildCache([]byte(changed), "TestMatrix"); err == nil {
+				t.Fatal("unshared or unowned build cache passed matrix policy")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/ci_environment.go b/cmd/plan9asmtest/ci_environment.go
new file mode 100644
index 000000000..5dcbe5000
--- /dev/null
+++ b/cmd/plan9asmtest/ci_environment.go
@@ -0,0 +1,220 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This is an observation, not a trusted index. Both the producer and the
+// independent artifact reader reconstruct the complete normalized environment.
+type ciEnvironmentContext struct {
+	Directory string            `json:"request_directory"`
+	Physical  string            `json:"physical_request_directory"`
+	TempRoot  string            `json:"actual_temp_root"`
+	Process   map[string]string `json:"process_controls"`
+}
+
+var ciProcessControls = []string{
+	"PATH", "GOENV", "GOWORK", "GOTOOLCHAIN", "GODEBUG", "GOGC", "GOMEMLIMIT",
+	"GOMAXPROCS", "GOTRACEBACK", "GORACE", "LLVM_CONFIG", "CC", "CXX",
+	"LD_LIBRARY_PATH", "LD_PRELOAD", "DYLD_LIBRARY_PATH", "DYLD_INSERT_LIBRARIES",
+	"CPATH", "C_INCLUDE_PATH", "CPLUS_INCLUDE_PATH", "OBJC_INCLUDE_PATH",
+	"LIBRARY_PATH", "COMPILER_PATH", "GCC_EXEC_PREFIX", "SDKROOT",
+	"MACOSX_DEPLOYMENT_TARGET", "SOURCE_DATE_EPOCH", "ASAN_OPTIONS", "MSAN_OPTIONS",
+	"TSAN_OPTIONS", "UBSAN_OPTIONS", "LC_ALL", "LANG", "TZ", "SELF_BL_SINK",
+	"TMPDIR", "TMP", "TEMP",
+	"NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA",
+}
+
+func captureCIEnvironmentContext(directory string, environment map[string]string) (ciEnvironmentContext, error) {
+	observation := ciEnvironmentContext{Directory: directory, Process: map[string]string{}}
+	var err error
+	observation.Physical, err = sourcepath.Resolve(directory)
+	if err != nil {
+		return observation, err
+	}
+	observation.TempRoot = environment["GOTMPDIR"]
+	if observation.TempRoot == "" {
+		observation.TempRoot = os.TempDir()
+	}
+	observation.TempRoot = filepath.Clean(observation.TempRoot)
+	for _, key := range ciProcessControls {
+		observation.Process[key] = os.Getenv(key)
+	}
+	// Capture all current and future explicit test/runtime controls, including
+	// pinned QEMU controls. Do not copy unrelated CI credentials into artifacts.
+	for _, entry := range os.Environ() {
+		key, value, _ := strings.Cut(entry, "=")
+		if strings.HasPrefix(key, "PLAN9ASM_") || strings.HasPrefix(key, "QEMU_") {
+			observation.Process[key] = value
+		}
+	}
+	return observation, nil
+}
+
+func ciAbsolutePath(path string) bool {
+	// Windows Go environments can retain forward or mixed separators (for
+	// example setup-go's cache roots). Only separator spelling is equivalent;
+	// dot segments, repeated separators and relative roots still fail.
+	return filepath.IsAbs(path) && filepath.Clean(path) == filepath.FromSlash(path) && !strings.ContainsAny(path, "\x00\r\n")
+}
+
+func normalizeCIEnvironment(environment map[string]string, observation ciEnvironmentContext) (map[string]string, error) {
+	if len(environment) == 0 || len(environment) > 256 || !ciAbsolutePath(observation.Directory) || !ciAbsolutePath(observation.Physical) || !ciAbsolutePath(observation.TempRoot) {
+		return nil, fmt.Errorf("complete bounded actual Go environment and absolute source/temp identities required")
+	}
+	for _, key := range ciProcessControls {
+		if _, present := observation.Process[key]; !present {
+			return nil, fmt.Errorf("process control %s observation missing", key)
+		}
+	}
+	if observation.Process["GOENV"] != "off" || observation.Process["GOWORK"] != "off" || observation.Process["GOTOOLCHAIN"] != "local" {
+		return nil, fmt.Errorf("actual process must disable user environment, workspace and toolchain switching")
+	}
+	root, toolDir := environment["GOROOT"], environment["GOTOOLDIR"]
+	if !ciAbsolutePath(root) || !ciAbsolutePath(toolDir) || filepath.Dir(toolDir) != filepath.Join(root, "pkg", "tool") {
+		return nil, fmt.Errorf("actual SDK/tool directory relationship differs")
+	}
+	module := environment["GOMOD"]
+	if module != filepath.Join(observation.Directory, "go.mod") && module != filepath.Join(observation.Physical, "go.mod") {
+		return nil, fmt.Errorf("actual main module must be the guarded request's go.mod")
+	}
+	if environment["GOTMPDIR"] != "" && filepath.Clean(environment["GOTMPDIR"]) != observation.TempRoot {
+		return nil, fmt.Errorf("actual Go temporary root differs")
+	}
+	if environment["GOCACHEPROG"] != "" || environment["GOPACKAGESDRIVER"] != "" {
+		return nil, fmt.Errorf("external cache/package drivers are not source-bound in this CI protocol")
+	}
+	result := make(map[string]string, len(environment)+len(observation.Process))
+	for key, value := range environment {
+		validKey := key != ""
+		for _, char := range key {
+			validKey = validKey && (char >= 'A' && char <= 'Z' || char >= '0' && char <= '9' || char == '_')
+		}
+		if !validKey || len(key) > 256 || len(value) > 1<<20 || strings.ContainsAny(value, "\x00\r\n") {
+			return nil, fmt.Errorf("invalid actual environment field %q", key)
+		}
+		result[key] = value // Includes unknown future Go fields, never a whitelist.
+	}
+	result["GOROOT"], result["GOTOOLDIR"] = "<sdk>", "<sdk>/pkg/tool/"+filepath.Base(toolDir)
+	result["GOMOD"] = "<source>/go.mod"
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "GOBIN", "GOTMPDIR", "GOTELEMETRYDIR"} {
+		value, present := environment[key]
+		if !present || value == "" {
+			continue // Empty and absent remain different, as observed by Go.
+		}
+		// Multiple GOPATH roots are not registered in this initial CI protocol.
+		if !ciAbsolutePath(value) || (key == "GOPATH" && len(filepath.SplitList(value)) != 1) {
+			return nil, fmt.Errorf("unregistered infrastructure path %s", key)
+		}
+		result[key] = "<" + strings.ToLower(key) + ">"
+	}
+	if _, present := environment["GOGCCFLAGS"]; !present {
+		return nil, fmt.Errorf("actual GOGCCFLAGS observation missing")
+	}
+	flags, err := normalizeCIGCCFlags(environment["GOGCCFLAGS"], observation.TempRoot)
+	if err != nil {
+		return nil, err
+	}
+	result["GOGCCFLAGS"] = flags
+	for key, value := range observation.Process {
+		if len(value) > 1<<20 || strings.ContainsAny(key+value, "\x00\r\n") {
+			return nil, fmt.Errorf("invalid process control %q", key)
+		}
+		if key == "PATH" {
+			parts := filepath.SplitList(value)
+			for index, path := range parts {
+				if filepath.FromSlash(path) == filepath.Join(root, "bin") {
+					parts[index] = "<sdk>/bin"
+				}
+			}
+			value = strings.Join(parts, string(os.PathListSeparator))
+		}
+		if key == "TMPDIR" || key == "TMP" || key == "TEMP" {
+			if value != "" {
+				if !ciAbsolutePath(strings.TrimSuffix(filepath.FromSlash(value), string(filepath.Separator))) && value != string(filepath.Separator) {
+					return nil, fmt.Errorf("invalid process temporary root %s", key)
+				}
+				value = "<" + strings.ToLower(key) + ">"
+			}
+		}
+		result["process/"+key] = value
+	}
+	return result, nil
+}
+
+// cmd/go envcmd uses quoted.Join(GccCmd(...)[3:]); GccCmd's debug/file
+// prefix-map maps the builder's disposable WorkDir to exactly /tmp/go-build.
+// Only that direct go-build<decimal> child changes. Everything else, including
+// flag ordering and original quote spelling, is retained byte-for-byte.
+// The actual SDK's complete source and driver/tool bytes are separately bound.
+func normalizeCIGCCFlags(flags, tempRoot string) (string, error) {
+	count := 0
+	var normalized strings.Builder
+	for cursor := 0; cursor < len(flags); {
+		start := cursor
+		if strings.ContainsRune(" \t", rune(flags[cursor])) {
+			normalized.WriteByte(flags[cursor])
+			cursor++
+			continue
+		}
+		quote := byte(0)
+		if flags[cursor] == '\'' || flags[cursor] == '"' {
+			quote = flags[cursor]
+			cursor++
+		}
+		payloadStart := cursor
+		for cursor < len(flags) && ((quote != 0 && flags[cursor] != quote) || (quote == 0 && !strings.ContainsRune(" \t", rune(flags[cursor])))) {
+			cursor++
+		}
+		payloadEnd := cursor
+		if quote != 0 {
+			if cursor == len(flags) {
+				return "", fmt.Errorf("unterminated actual GOGCCFLAGS quote")
+			}
+			cursor++
+			if cursor < len(flags) && !strings.ContainsRune(" \t", rune(flags[cursor])) {
+				return "", fmt.Errorf("ambiguous actual GOGCCFLAGS quoted token")
+			}
+		}
+		argument := flags[payloadStart:payloadEnd]
+		prefix := ""
+		for _, candidate := range []string{"-fdebug-prefix-map=", "-ffile-prefix-map="} {
+			if strings.HasPrefix(argument, candidate) {
+				prefix = candidate
+			}
+		}
+		if prefix == "" {
+			normalized.WriteString(flags[start:cursor])
+			continue
+		}
+		count++
+		mapped := strings.TrimPrefix(argument, prefix)
+		from, to, found := strings.Cut(mapped, "=")
+		base := filepath.Base(from)
+		digits := strings.TrimPrefix(base, "go-build")
+		if count != 1 || !found || to != "/tmp/go-build" || from != filepath.Join(tempRoot, base) || len(digits) < 1 || len(digits) > 10 || digits == base {
+			return "", fmt.Errorf("unregistered actual GOGCCFLAGS prefix-map")
+		}
+		for _, digit := range digits {
+			if digit < '0' || digit > '9' {
+				return "", fmt.Errorf("actual Go temporary nonce is not decimal")
+			}
+		}
+		// Both selected SDKs derive MkdirTemp's suffix from uint32 and emit
+		// canonical base-10 text (os.nextRandom), not arbitrary decimal input.
+		nonce, err := strconv.ParseUint(digits, 10, 32)
+		if err != nil || strconv.FormatUint(nonce, 10) != digits {
+			return "", fmt.Errorf("actual Go temporary nonce is not canonical uint32")
+		}
+		normalized.WriteString(flags[start:payloadStart])
+		normalized.WriteString(prefix + "<tmp>/go-build<decimal>=/tmp/go-build")
+		normalized.WriteString(flags[payloadEnd:cursor])
+	}
+	return normalized.String(), nil
+}
diff --git a/cmd/plan9asmtest/ci_environment_test.go b/cmd/plan9asmtest/ci_environment_test.go
new file mode 100644
index 000000000..31f66ab77
--- /dev/null
+++ b/cmd/plan9asmtest/ci_environment_test.go
@@ -0,0 +1,148 @@
+//go:build unix
+
+package main
+
+import (
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func ciEnvironmentFixture() (map[string]string, ciEnvironmentContext) {
+	observation := ciEnvironmentContext{Directory: "/source", Physical: "/source", TempRoot: "/temporary", Process: map[string]string{}}
+	for _, key := range ciProcessControls {
+		observation.Process[key] = ""
+	}
+	observation.Process["GOENV"], observation.Process["GOWORK"], observation.Process["GOTOOLCHAIN"] = "off", "off", "local"
+	observation.Process["PATH"] = "/sdk/bin:/usr/bin"
+	environment := map[string]string{
+		"GOROOT": "/sdk", "GOTOOLDIR": "/sdk/pkg/tool/linux_amd64", "GOMOD": "/source/go.mod",
+		"GOTMPDIR": "/temporary", "GOCACHE": "/cache", "GOMODCACHE": "/modules",
+		"GOPATH": "/gopath", "GOBIN": "/gopath/bin", "GOTELEMETRYDIR": "/telemetry",
+		"GOGCCFLAGS": "-m64 -pthread -ffile-prefix-map=/temporary/go-build123=/tmp/go-build -fno-common",
+		"GOARCH":     "amd64", "GOOS": "linux", "GOTOOLCHAIN": "local", "GOENV": "",
+		"GOFLAGS": "", "GOWORK": "off", "GOCACHEPROG": "", "FUTURE_SDK_INPUT": "exact",
+	}
+	return environment, observation
+}
+
+func TestCICompleteEnvironmentPortableRootsAndExactSemantics(t *testing.T) {
+	environment, observation := ciEnvironmentFixture()
+	wanted, err := normalizeCIEnvironment(environment, observation)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if wanted["FUTURE_SDK_INPUT"] != "exact" || wanted["GOCACHEPROG"] != "" {
+		t.Fatal("complete actual Go environment was projected")
+	}
+	portable, context := ciEnvironmentFixture()
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "GOBIN", "GOTELEMETRYDIR"} {
+		portable[key] = filepath.Join("/other", strings.ToLower(key))
+	}
+	portable["GOROOT"], portable["GOTOOLDIR"], portable["GOMOD"] = "/other/sdk", "/other/sdk/pkg/tool/linux_amd64", "/other/source/go.mod"
+	portable["GOTMPDIR"] = "/other/tmp"
+	portable["GOGCCFLAGS"] = strings.Replace(portable["GOGCCFLAGS"], "/temporary/go-build123", "/other/tmp/go-build987654", 1)
+	context.Directory, context.Physical, context.TempRoot = "/other/source", "/other/source", "/other/tmp"
+	context.Process["PATH"] = "/other/sdk/bin:/usr/bin"
+	actual, err := normalizeCIEnvironment(portable, context)
+	if err != nil || !reflect.DeepEqual(wanted, actual) {
+		t.Fatal("same semantics under different SDK/source/cache/temp roots", err, wanted, actual)
+	}
+	context.Process["TMPDIR"] = "/observed/temp/"
+	if _, err := normalizeCIEnvironment(portable, context); err != nil {
+		t.Fatal("actual macOS trailing temp separator", err)
+	}
+	for _, key := range []string{"GOGCCFLAGS", "GOCACHEPROG", "FUTURE_SDK_INPUT", "GOTOOLCHAIN", "GOWORK", "CGO_LDFLAGS"} {
+		t.Run("exact/"+key, func(t *testing.T) {
+			changed, context := ciEnvironmentFixture()
+			changed[key] += " changed"
+			actual, err := normalizeCIEnvironment(changed, context)
+			if err == nil && reflect.DeepEqual(wanted, actual) {
+				t.Fatal("semantic field mutation admitted")
+			}
+		})
+	}
+	for _, key := range []string{"FUTURE_SDK_INPUT", "GOCACHEPROG", "GOGCCFLAGS"} {
+		changed, context := ciEnvironmentFixture()
+		delete(changed, key)
+		actual, err := normalizeCIEnvironment(changed, context)
+		if err == nil && reflect.DeepEqual(wanted, actual) {
+			t.Fatal("paired absence/empty mutation admitted", key)
+		}
+	}
+	for _, key := range []string{"PLAN9ASM_CROSS_EXEC", "QEMU_CPU", "LLVM_CONFIG", "LD_PRELOAD", "PATH", "SELF_BL_SINK", "GOMAXPROCS"} {
+		changed, context := ciEnvironmentFixture()
+		context.Process[key] += " changed"
+		actual, err := normalizeCIEnvironment(changed, context)
+		if err == nil && reflect.DeepEqual(wanted, actual) {
+			t.Fatal("runtime/routing control mutation admitted", key)
+		}
+	}
+}
+
+func TestCIGCCFlagsOnlyDirectDecimalTemporaryNonce(t *testing.T) {
+	for _, prefix := range []string{"-ffile-prefix-map=", "-fdebug-prefix-map="} {
+		for _, quote := range []string{"", "'", "\""} {
+			flags := "-m64 " + quote + prefix + "/tmp/go-build123=/tmp/go-build" + quote + " -fno-common"
+			actual, err := normalizeCIGCCFlags(flags, "/tmp")
+			wanted := "-m64 " + quote + prefix + "<tmp>/go-build<decimal>=/tmp/go-build" + quote + " -fno-common"
+			if err != nil || actual != wanted {
+				t.Fatal(flags, actual, err)
+			}
+		}
+	}
+	spaces := "-m64 '-ffile-prefix-map=/owned tmp/go-build123=/tmp/go-build' -pthread"
+	if _, err := normalizeCIGCCFlags(spaces, "/owned tmp"); err != nil {
+		t.Fatal("actual Go quoted.Join space path", err)
+	}
+	for _, flags := range []string{
+		"-ffile-prefix-map=/other/go-build123=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/child/../go-build123=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build123/child=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build123x=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build12345678901=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build4294967296=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build000123=/tmp/go-build",
+		"-ffile-prefix-map=/tmp/go-build123=/other",
+		"-ffile-prefix-map=/tmp/go-build123=/tmp/go-build=extra",
+		"-ffile-prefix-map=/tmp/go-build123=/tmp/go-build -fdebug-prefix-map=/tmp/go-build456=/tmp/go-build",
+		"'-ffile-prefix-map=/tmp/go-build123=/tmp/go-build'bad",
+		"'-ffile-prefix-map=/tmp/go-build123=/tmp/go-build",
+	} {
+		if _, err := normalizeCIGCCFlags(flags, "/tmp"); err == nil {
+			t.Fatal("foreign/ambiguous nonce normalization admitted", flags)
+		}
+	}
+	unchanged := "-m64  -pthread\t-fno-common"
+	if actual, err := normalizeCIGCCFlags(unchanged, "/tmp"); err != nil || actual != unchanged {
+		t.Fatal("non-nonce flags or whitespace changed", actual, err)
+	}
+	for _, nonce := range []string{"0", "4294967295"} {
+		if _, err := normalizeCIGCCFlags("-ffile-prefix-map=/tmp/go-build"+nonce+"=/tmp/go-build", "/tmp"); err != nil {
+			t.Fatal("actual uint32 nonce boundary", nonce, err)
+		}
+	}
+}
+
+func TestCIEnvironmentContextRejectsMissingAndForeignRoots(t *testing.T) {
+	mutations := []func(map[string]string, *ciEnvironmentContext){
+		func(e map[string]string, c *ciEnvironmentContext) { e["GOMOD"] = "/other/go.mod" },
+		func(e map[string]string, c *ciEnvironmentContext) { e["GOTOOLDIR"] = "/other/pkg/tool/linux_amd64" },
+		func(e map[string]string, c *ciEnvironmentContext) { e["GOTMPDIR"] = "/other" },
+		func(e map[string]string, c *ciEnvironmentContext) { e["GOPATH"] = "/one:/two" },
+		func(e map[string]string, c *ciEnvironmentContext) { e["GOCACHE"] = "relative" },
+		func(e map[string]string, c *ciEnvironmentContext) { e["process/PATH"] = "collision" },
+		func(e map[string]string, c *ciEnvironmentContext) { delete(c.Process, "PATH") },
+		func(e map[string]string, c *ciEnvironmentContext) { c.Process["GOENV"] = "/user/config" },
+		func(e map[string]string, c *ciEnvironmentContext) { c.Directory = "/source/.." },
+	}
+	for index, mutation := range mutations {
+		environment, observation := ciEnvironmentFixture()
+		mutation(environment, &observation)
+		if _, err := normalizeCIEnvironment(environment, observation); err == nil {
+			t.Fatal("foreign/incomplete identity admitted", index)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/ci_environment_windows_test.go b/cmd/plan9asmtest/ci_environment_windows_test.go
new file mode 100644
index 000000000..0f4f1299a
--- /dev/null
+++ b/cmd/plan9asmtest/ci_environment_windows_test.go
@@ -0,0 +1,28 @@
+package main
+
+import "testing"
+
+func TestWindowsCIAbsolutePathSeparatorEquivalence(t *testing.T) {
+	for _, path := range []string{`C:\tools\go`, `C:/tools/go`, `C:\tools/go`, `\\server\share\go`} {
+		if !ciAbsolutePath(path) {
+			t.Fatal("absolute native/Go separator spelling rejected", path)
+		}
+	}
+	for _, path := range []string{
+		`C:tools\go`, `\tools\go`, `C:\tools\..\go`, `C:/tools/./go`,
+		`C:/tools//go`, `C:\tools\\go`, `C:\tools\go\`, "C:\\go\x00", "C:\\go\n",
+	} {
+		if ciAbsolutePath(path) {
+			t.Fatal("relative/unclean/control path acquired source identity", path)
+		}
+	}
+	for _, path := range []string{`C:\llvm\lib\LLVM.dll`, `C:/llvm/lib/LLVM.dll`} {
+		files, err := moduleSharedLibraries([]byte(path + "\n"))
+		if err != nil || len(files) != 1 || files[0] != path {
+			t.Fatalf("actual configured spelling was changed or rejected: %q %v", files, err)
+		}
+	}
+	if _, err := moduleSharedLibraries([]byte("C:\\llvm\\lib\\LLVM.dll C:/llvm/lib/LLVM.dll\n")); err == nil {
+		t.Fatal("separator aliases became two independent library origins")
+	}
+}
diff --git a/cmd/plan9asmtest/ci_llvm_config.go b/cmd/plan9asmtest/ci_llvm_config.go
new file mode 100644
index 000000000..f0b61ec24
--- /dev/null
+++ b/cmd/plan9asmtest/ci_llvm_config.go
@@ -0,0 +1,19 @@
+package main
+
+import (
+	"os"
+	"os/exec"
+)
+
+// Selection only: captureCIScope still observes and verifies the actual version
+// and bindir. An explicit configuration is authoritative and never falls back.
+func resolveCIConfigExecutable() (string, error) {
+	requested := os.Getenv("LLVM_CONFIG")
+	if requested == "" {
+		requested = "llvm-config"
+		if versioned, err := exec.LookPath("llvm-config-22"); err == nil {
+			requested = versioned
+		}
+	}
+	return exec.LookPath(requested)
+}
diff --git a/cmd/plan9asmtest/ci_node_dependency_unix_test.go b/cmd/plan9asmtest/ci_node_dependency_unix_test.go
new file mode 100644
index 000000000..e3f770794
--- /dev/null
+++ b/cmd/plan9asmtest/ci_node_dependency_unix_test.go
@@ -0,0 +1,76 @@
+//go:build !windows
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func ciNodeTransportFixture(t *testing.T, body string) (config, string, string) {
+	t.Helper()
+	directory := t.TempDir()
+	node := filepath.Join(directory, "node")
+	if err := os.WriteFile(node, []byte("#!/bin/sh\n"+body), 0755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", directory)
+	for _, key := range []string{"NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA"} {
+		t.Setenv(key, "")
+	}
+	return config{Dir: directory, Timeout: time.Second}, filepath.Join(directory, "before"), node
+}
+
+// These are independent command-transport controls, not execution evidence for
+// the actual Node interpreter or the ARM64 assembly/C oracle.
+func TestCINodeDependencyRecordsVersionAndOrigin(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		failure    bool
+	}{
+		{"valid", "printf 'v24.10.0\\n'\n", false},
+		{"wrong-version-output", "printf 'not-a-version\\n'\n", true},
+		{"tool-failure", "exit 7\n", true},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			cfg, stem, node := ciNodeTransportFixture(t, row.body)
+			origins := map[string]string{}
+			err := captureCINodeDependency(context.Background(), cfg, stem, origins)
+			if (err != nil) != row.failure {
+				t.Fatalf("observation error=%v; want failure=%t", err, row.failure)
+			}
+			if err != nil {
+				return
+			}
+			if origins["node"] != node {
+				t.Fatal("selected tool origin was not retained")
+			}
+			got, err := ciFileSHA(origins["node"])
+			want := fmt.Sprintf("%x", sha256.Sum256([]byte("#!/bin/sh\n"+row.body)))
+			if err != nil || got != want {
+				t.Fatal("scope hash does not bind actual executable bytes", got, err)
+			}
+		})
+	}
+}
+
+func TestCINodeDependencyRejectsMissingOrDelegatedRuntime(t *testing.T) {
+	for _, key := range []string{"PATH", "NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA"} {
+		t.Run(key, func(t *testing.T) {
+			cfg, stem, _ := ciNodeTransportFixture(t, "printf 'v24.10.0\\n'\n")
+			value := "unobserved-delegation"
+			if key == "PATH" {
+				value = ""
+			}
+			t.Setenv(key, value)
+			if err := captureCINodeDependency(context.Background(), cfg, stem, map[string]string{}); err == nil {
+				t.Fatal("missing/delegated runtime acquired a successful observation")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/ci_plan.go b/cmd/plan9asmtest/ci_plan.go
new file mode 100644
index 000000000..590990386
--- /dev/null
+++ b/cmd/plan9asmtest/ci_plan.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+const ciProtocol = "actual_go_selected_ci_partitions_v1"
+
+type ciScope struct {
+	SourceSHA   string            `json:"source_sha256"`
+	Head        string            `json:"git_head"`
+	SDKSource   string            `json:"sdk_source_sha256"`
+	GoVersion   string            `json:"go_version"`
+	Environment map[string]string `json:"effective_environment"`
+	Tools       map[string]string `json:"tool_sha256"`
+}
+
+type ciPlan struct {
+	Protocol     string   `json:"protocol"`
+	Package      string   `json:"package"`
+	Flags        []string `json:"go_flags"`
+	Timeout      string   `json:"per_root_timeout"`
+	Selector     string   `json:"selector"`
+	Isolate      string   `json:"isolated_root"`
+	Owners       int      `json:"owners"`
+	Inventory    []string `json:"full_inventory"`
+	Benchmarks   []string `json:"benchmarks_not_executed"`
+	InventorySHA string   `json:"full_inventory_sha256"`
+	Selected     []string `json:"selected_inventory"`
+	SelectedSHA  string   `json:"selected_inventory_sha256"`
+	Scope        ciScope  `json:"scope"`
+}
+
+func ciNamesSHA(names []string) string {
+	hash := sha256.Sum256([]byte(strings.Join(names, "\n") + "\n"))
+	return hex.EncodeToString(hash[:])
+}
+
+func ciAssignments(plan ciPlan) ([][]string, error) {
+	if plan.Protocol != ciProtocol || plan.Owners < 2 || plan.Owners > 1024 || plan.Selector == "" || strings.Contains(plan.Selector, "/") {
+		return nil, fmt.Errorf("registered CI protocol, slash-free selector and 2..1024 owners required")
+	}
+	selector, err := regexp.Compile(plan.Selector)
+	if err != nil {
+		return nil, err
+	}
+	if _, err := partition(plan.Inventory, 1); err != nil {
+		return nil, err
+	}
+	if !sort.StringsAreSorted(plan.Inventory) || plan.InventorySHA != ciNamesSHA(plan.Inventory) {
+		return nil, fmt.Errorf("full inventory identity differs")
+	}
+	var selected []string
+	for _, name := range plan.Inventory {
+		if selector.MatchString(name) {
+			selected = append(selected, name)
+		}
+	}
+	if len(selected) == 0 || !reflect.DeepEqual(selected, plan.Selected) || plan.SelectedSHA != ciNamesSHA(selected) {
+		return nil, fmt.Errorf("selected inventory is not the complete selector projection")
+	}
+	isolated := false
+	owners := make([][]string, plan.Owners)
+	for _, name := range selected {
+		owner := 0
+		if name == plan.Isolate {
+			isolated = true
+		} else {
+			hash := sha256.Sum256([]byte(name))
+			owner = 1 + int(binary.BigEndian.Uint64(hash[:8])%uint64(plan.Owners-1))
+		}
+		owners[owner] = append(owners[owner], name)
+	}
+	if !isolated || !validName(plan.Isolate) {
+		return nil, fmt.Errorf("isolated root must exist exactly once in actual selected inventory")
+	}
+	return owners, nil
+}
diff --git a/cmd/plan9asmtest/ci_plan_test.go b/cmd/plan9asmtest/ci_plan_test.go
new file mode 100644
index 000000000..705dcb764
--- /dev/null
+++ b/cmd/plan9asmtest/ci_plan_test.go
@@ -0,0 +1,76 @@
+package main
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func testCIPlan() ciPlan {
+	names := []string{"FuzzSeeds", "TestAlpha", "TestBeta", "TestGiant", "TestOther"}
+	selected := []string{"TestAlpha", "TestBeta", "TestGiant"}
+	return ciPlan{Protocol: ciProtocol, Selector: "^(TestAlpha|TestBeta|TestGiant)$", Isolate: "TestGiant", Owners: 16, Inventory: names, InventorySHA: ciNamesSHA(names), Selected: selected, SelectedSHA: ciNamesSHA(selected)}
+}
+
+func TestCIPlanExhaustiveDisjointOwnership(t *testing.T) {
+	plan := testCIPlan()
+	owners, err := ciAssignments(plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(owners[0], []string{"TestGiant"}) || len(owners) != 16 {
+		t.Fatal("giant root lost its exclusive budget", owners)
+	}
+	var union []string
+	for _, names := range owners {
+		union = append(union, names...)
+	}
+	sort.Strings(union)
+	if !reflect.DeepEqual(union, plan.Selected) || len(plan.Inventory) != 5 {
+		t.Fatal("selected/full denominator changed", union)
+	}
+}
+
+func TestCIPlanRejectsAlteredDenominators(t *testing.T) {
+	for name, mutation := range map[string]func(*ciPlan){
+		"missing":           func(p *ciPlan) { p.Selected = p.Selected[1:]; p.SelectedSHA = ciNamesSHA(p.Selected) },
+		"duplicate":         func(p *ciPlan) { p.Selected[1] = p.Selected[0]; p.SelectedSHA = ciNamesSHA(p.Selected) },
+		"unknown":           func(p *ciPlan) { p.Selected[1] = "TestUnknown"; p.SelectedSHA = ciNamesSHA(p.Selected) },
+		"foreign selector":  func(p *ciPlan) { p.Selector = "^TestGiant$" },
+		"missing isolated":  func(p *ciPlan) { p.Isolate = "TestUnknown" },
+		"too few owners":    func(p *ciPlan) { p.Owners = 1 },
+		"foreign protocol":  func(p *ciPlan) { p.Protocol = "ordinary" },
+		"full hash":         func(p *ciPlan) { p.InventorySHA = "" },
+		"unknown full name": func(p *ciPlan) { p.Inventory[0] = "Unknown"; p.InventorySHA = ciNamesSHA(p.Inventory) },
+		"slash selector":    func(p *ciPlan) { p.Selector += "/sub" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			plan := testCIPlan()
+			mutation(&plan)
+			if _, err := ciAssignments(plan); err == nil {
+				t.Fatal("altered plan admitted")
+			}
+		})
+	}
+}
+
+func TestCIPlanNewPrefixedRootIsNotDropped(t *testing.T) {
+	plan := testCIPlan()
+	plan.Selector = "^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance|TestARM64RawSQSHLURuntimeSemantics|TestARMIntegerMemoryRuntimeCross|TestARMRawSaturationRuntimeCross)"
+	plan.Isolate = "TestCrossLinuxRuntimeMatrix"
+	plan.Inventory = []string{"TestARM64Conformance", "TestCrossLinuxRuntimeMatrix", "TestCrossLinuxRuntimeMatrixQEMUOriginalGoAndCArguments", "TestOther"}
+	plan.Selected = append([]string(nil), plan.Inventory[:3]...)
+	plan.InventorySHA, plan.SelectedSHA = ciNamesSHA(plan.Inventory), ciNamesSHA(plan.Selected)
+	owners, err := ciAssignments(plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var union []string
+	for _, names := range owners {
+		union = append(union, names...)
+	}
+	sort.Strings(union)
+	if !reflect.DeepEqual(union, plan.Selected) || len(owners[0]) != 1 {
+		t.Fatal("new actual prefix root silently omitted or grouped with giant", union)
+	}
+}
diff --git a/cmd/plan9asmtest/ci_scope.go b/cmd/plan9asmtest/ci_scope.go
new file mode 100644
index 000000000..cb20a802c
--- /dev/null
+++ b/cmd/plan9asmtest/ci_scope.go
@@ -0,0 +1,426 @@
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// Scope equality excludes disposable cache/workspace spelling, not compiler,
+// runtime, source or tool identity. Raw go env and actual tool origins remain
+// artifacts. No stored scope can replace a fresh before/after observation.
+func captureCIScope(ctx context.Context, cfg config, stem string) (ciScope, error) {
+	scope := ciScope{Tools: map[string]string{}, Environment: map[string]string{}}
+	query := func(name string, args ...string) ([]byte, error) {
+		if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, args, stem+"-"+name); err != nil {
+			return nil, err
+		}
+		return os.ReadFile(stem + "-" + name + ".stdout")
+	}
+	version, err := query("version", "version")
+	if err != nil {
+		return scope, err
+	}
+	scope.GoVersion = strings.TrimSpace(string(version))
+	data, err := query("env", "env", "-json")
+	if err != nil {
+		return scope, err
+	}
+	var environment map[string]string
+	if err := json.Unmarshal(data, &environment); err != nil {
+		return scope, err
+	}
+	observation, err := captureCIEnvironmentContext(cfg.Dir, environment)
+	if err != nil {
+		return scope, err
+	}
+	scope.Environment, err = normalizeCIEnvironment(environment, observation)
+	if err != nil {
+		return scope, err
+	}
+	if err := ciWriteJSON(stem+"-environment-context.json", observation); err != nil {
+		return scope, err
+	}
+	actualDriver, err := os.Stat(cfg.Go)
+	if err != nil {
+		return scope, err
+	}
+	sdkDriver, err := os.Stat(filepath.Join(environment["GOROOT"], "bin", gotoolchain.HostExecutable("go")))
+	if err != nil || !os.SameFile(actualDriver, sdkDriver) {
+		return scope, fmt.Errorf("selected executable is not actual SDK driver: %v", err)
+	}
+	pathDriver, err := exec.LookPath("go")
+	if err != nil {
+		return scope, err
+	}
+	pathInfo, err := os.Stat(pathDriver)
+	if err != nil || !os.SameFile(actualDriver, pathInfo) {
+		return scope, fmt.Errorf("nested Go test helpers must resolve the same actual SDK driver: %v", err)
+	}
+	if os.Getenv("GOENV") != "off" || os.Getenv("GOWORK") != "off" || os.Getenv("GOTOOLCHAIN") != "local" {
+		return scope, fmt.Errorf("CI scope requires explicit GOENV=off, GOWORK=off and GOTOOLCHAIN=local")
+	}
+	if err := validateRunnerGoFlags(runtime.GOOS, environment["GOFLAGS"], cfg.Flags); err != nil {
+		return scope, err
+	}
+	toolDir := environment["GOTOOLDIR"]
+	root := environment["GOROOT"]
+	if !filepath.IsAbs(root) || !filepath.IsAbs(toolDir) {
+		return scope, fmt.Errorf("actual SDK roots must be absolute")
+	}
+	origins := map[string]string{"go": cfg.Go}
+	for _, name := range []string{"asm", "compile", "link", "vet", "cgo", "cover", "test2json", "nm", "objdump"} {
+		// Go 1.27 builds some official tools on demand; they are not all
+		// physical GOTOOLDIR members. Observe the same driver's real route.
+		path, err := query("tool-"+name, "tool", "-n", name)
+		if err != nil {
+			return scope, err
+		}
+		origins["go/"+name] = strings.TrimSpace(string(path))
+		if !filepath.IsAbs(origins["go/"+name]) {
+			return scope, fmt.Errorf("actual SDK tool %s route is not absolute", name)
+		}
+	}
+	// Whole-module gates bind the same LLVM 22 core used by their tests.
+	// Only the required Linux cross-runtime role demands cross linkers/QEMU.
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" || cfg.Module {
+		cross := os.Getenv("PLAN9ASM_CROSS_EXEC") == "1"
+		if cross {
+			if environment["GOHOSTOS"] != "linux" || environment["GOHOSTARCH"] != "amd64" {
+				return scope, fmt.Errorf("required native cross-runtime driver is Linux/amd64")
+			}
+			for _, name := range []string{"CC", "CXX", "AR", "PKG_CONFIG"} {
+				requested := environment[name]
+				// A wrapper/compound command would need its own delegated-tool
+				// closure. The existing CI uses single official compiler commands.
+				if requested == "" || strings.ContainsAny(requested, " \t'\"") {
+					return scope, fmt.Errorf("unregistered actual %s compiler/tool command", name)
+				}
+				path, err := exec.LookPath(requested)
+				if err != nil {
+					return scope, fmt.Errorf("actual %s tool: %w", name, err)
+				}
+				origins["environment/"+name], err = filepath.Abs(path)
+				if err != nil {
+					return scope, err
+				}
+			}
+		}
+		bindir := ""
+		if os.Getenv("LLVM_CONFIG") != "" || cfg.Module {
+			configPath, err := resolveCIConfigExecutable()
+			if err != nil {
+				return scope, err
+			}
+			origins["llvm-config"] = configPath
+			for _, argument := range []string{"--version", "--bindir"} {
+				path := stem + "-llvm-config" + strings.TrimPrefix(argument, "--")
+				if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, configPath, []string{argument}, path); err != nil {
+					return scope, err
+				}
+				output, err := os.ReadFile(path + ".stdout")
+				if err != nil {
+					return scope, err
+				}
+				text := strings.TrimSpace(string(output))
+				if argument == "--version" && !strings.HasPrefix(text, "22.") {
+					return scope, fmt.Errorf("actual LLVM_CONFIG must select LLVM 22")
+				}
+				if argument == "--bindir" {
+					if !filepath.IsAbs(text) {
+						return scope, fmt.Errorf("actual LLVM bindir must be absolute")
+					}
+					bindir = text
+				}
+			}
+		}
+		names := []string{"llvm-config", "llc", "clang", "llvm-as", "opt", "llvm-dis", "llvm-objdump", "llvm-nm"}
+		if cross {
+			names = append(names, "ld.lld", "i686-linux-gnu-gcc", "arm-linux-gnueabihf-gcc", "aarch64-linux-gnu-gcc", "qemu-i386", "qemu-arm", "qemu-aarch64")
+		}
+		for _, name := range names {
+			if name == "llvm-config" && origins[name] != "" {
+				continue
+			}
+			requested := name
+			llvmTool := name == "clang" || name == "llc" || name == "opt" || name == "ld.lld" || strings.HasPrefix(name, "llvm-")
+			if llvmTool {
+				if bindir != "" {
+					requested = filepath.Join(bindir, name)
+				} else if versioned, err := exec.LookPath(name + "-22"); err == nil {
+					requested = versioned
+				}
+			}
+			if name == "llvm-config" && os.Getenv("LLVM_CONFIG") != "" {
+				requested = os.Getenv("LLVM_CONFIG")
+			}
+			path, err := exec.LookPath(requested)
+			if err != nil {
+				return scope, fmt.Errorf("required runtime tool %s: %w", name, err)
+			}
+			origins[name], err = filepath.Abs(path)
+			if err != nil {
+				return scope, err
+			}
+		}
+	}
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" && !cfg.Module {
+		if err := captureCINodeDependency(ctx, cfg, stem, origins); err != nil {
+			return scope, err
+		}
+	}
+	if cfg.Module {
+		if err := captureModuleDependencies(ctx, cfg, stem, environment, origins); err != nil {
+			return scope, err
+		}
+	}
+	for name, path := range origins {
+		hash, err := ciFileSHA(path)
+		if err != nil {
+			return scope, fmt.Errorf("tool %s: %w", name, err)
+		}
+		scope.Tools[name] = hash
+	}
+	if err := ciWriteJSON(stem+"-origins.json", origins); err != nil {
+		return scope, err
+	}
+	var sdkFiles []string
+	for _, directory := range []string{"src", "pkg/include"} {
+		files, err := ciDirectoryFiles(filepath.Join(root, directory))
+		if err != nil {
+			return scope, err
+		}
+		for _, file := range files {
+			sdkFiles = append(sdkFiles, filepath.Join(directory, file))
+		}
+	}
+	if cfg.Module {
+		// Include the complete actual selected wasm runtime directory, not only
+		// SDK/src (current SDKs keep these consumers under lib/wasm).
+		directory := filepath.Dir(origins["sdk-wasm/wasm_exec.js"])
+		files, err := ciDirectoryFiles(directory)
+		if err != nil {
+			return scope, err
+		}
+		relative, err := filepath.Rel(root, directory)
+		if err != nil {
+			return scope, err
+		}
+		for _, file := range files {
+			sdkFiles = append(sdkFiles, filepath.Join(relative, file))
+		}
+	}
+	for _, name := range []string{"VERSION", "go.env"} {
+		if _, err := os.Lstat(filepath.Join(root, name)); err == nil {
+			sdkFiles = append(sdkFiles, name)
+		} else if !os.IsNotExist(err) {
+			return scope, err
+		}
+	}
+	scope.SDKSource, err = ciFilesSHA(root, sdkFiles)
+	if err != nil {
+		return scope, err
+	}
+	scope.SourceSHA, scope.Head, err = ciSourceSHA(ctx, cfg, stem)
+	return scope, err
+}
+
+func verifyCIScopeArtifacts(directory string, report ciReport) error {
+	for name, wanted := range map[string][]string{"inventory": report.Plan.Inventory, "selected": report.Plan.Selected} {
+		data, err := os.ReadFile(filepath.Join(directory, name+".stdout"))
+		if err != nil {
+			return err
+		}
+		pkg, names, benchmarks, err := parseList(string(data))
+		if err != nil || pkg != report.Plan.Package || !reflect.DeepEqual(names, wanted) || (name == "inventory" && !reflect.DeepEqual(benchmarks, report.Plan.Benchmarks)) {
+			return fmt.Errorf("actual %s inventory observation differs: %v", name, err)
+		}
+	}
+	return verifyScopeArtifacts(directory, report.Go, report.Plan.Scope)
+}
+
+func verifyScopeArtifacts(directory, goBinary string, scope ciScope) error {
+	var beforeOrigins map[string]string
+	for _, phase := range []string{"before", "after"} {
+		stem := filepath.Join(directory, phase)
+		version, err := os.ReadFile(stem + "-version.stdout")
+		if err != nil || strings.TrimSpace(string(version)) != scope.GoVersion {
+			return fmt.Errorf("actual SDK version observation differs: %v", err)
+		}
+		var environment map[string]string
+		if err := ciReadJSON(stem+"-env.stdout", &environment); err != nil {
+			return err
+		}
+		var observation ciEnvironmentContext
+		if err := ciReadJSON(stem+"-environment-context.json", &observation); err != nil {
+			return err
+		}
+		normalized, err := normalizeCIEnvironment(environment, observation)
+		if err != nil || !reflect.DeepEqual(normalized, scope.Environment) {
+			return fmt.Errorf("complete actual environment differs: %v", err)
+		}
+		var origins map[string]string
+		if err := ciReadJSON(stem+"-origins.json", &origins); err != nil {
+			return err
+		}
+		if origins["go"] != goBinary || len(origins) != len(scope.Tools) {
+			return fmt.Errorf("actual SDK/tool origins differ")
+		}
+		if scope.Tools["node"] != "" {
+			if err := validateModuleNodeEnvironment(observation.Process); err != nil {
+				return err
+			}
+			version, err := os.ReadFile(stem + "-node-version.stdout")
+			if err != nil || !ciNodeVersion.Match(version) {
+				return fmt.Errorf("actual Node version observation differs: %v", err)
+			}
+		}
+		for name := range scope.Tools {
+			if !filepath.IsAbs(origins[name]) {
+				return fmt.Errorf("actual tool %s origin missing", name)
+			}
+			if strings.HasPrefix(name, "go/") {
+				observed, err := os.ReadFile(stem + "-tool-" + strings.TrimPrefix(name, "go/") + ".stdout")
+				if err != nil || strings.TrimSpace(string(observed)) != origins[name] {
+					return fmt.Errorf("actual SDK tool %s route differs: %v", name, err)
+				}
+			}
+		}
+		if phase == "before" {
+			beforeOrigins = origins
+		} else if !reflect.DeepEqual(beforeOrigins, origins) {
+			return fmt.Errorf("tool origin changed during worker")
+		}
+	}
+	return nil
+}
+
+func ciFileSHA(path string) (string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	hash := sha256.New()
+	_, copyErr := io.Copy(hash, file)
+	closeErr := file.Close()
+	if copyErr != nil {
+		return "", copyErr
+	}
+	if closeErr != nil {
+		return "", closeErr
+	}
+	return hex.EncodeToString(hash.Sum(nil)), nil
+}
+
+func ciDirectoryFiles(root string) ([]string, error) {
+	var files []string
+	err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			return nil
+		}
+		if !entry.Type().IsRegular() {
+			return fmt.Errorf("source file must be regular: %s", path)
+		}
+		relative, err := filepath.Rel(root, path)
+		if err == nil {
+			files = append(files, relative)
+		}
+		return err
+	})
+	return files, err
+}
+
+func ciFilesSHA(root string, files []string) (string, error) {
+	sort.Strings(files)
+	hash := sha256.New()
+	for _, name := range files {
+		path := filepath.Join(root, name)
+		info, err := os.Lstat(path)
+		if err != nil || !info.Mode().IsRegular() {
+			return "", fmt.Errorf("source identity %s: %v", name, err)
+		}
+		contents, err := ciFileSHA(path)
+		if err != nil {
+			return "", err
+		}
+		fmt.Fprintf(hash, "%s\x00%s\x00", filepath.ToSlash(name), contents)
+	}
+	return hex.EncodeToString(hash.Sum(nil)), nil
+}
+
+func ciSourceSHA(ctx context.Context, cfg config, stem string) (string, string, error) {
+	// Real CI checks a clean complete Git checkout. A local, nongit first-party
+	// fixture binds all files in its source directory; artifacts must be outside.
+	gitRoot := cfg.Dir
+	for {
+		if _, err := os.Lstat(filepath.Join(gitRoot, ".git")); err == nil {
+			break
+		}
+		parent := filepath.Dir(gitRoot)
+		if parent == gitRoot {
+			files, err := ciDirectoryFiles(cfg.Dir)
+			if err != nil {
+				return "", "", err
+			}
+			hash, err := ciFilesSHA(cfg.Dir, files)
+			return hash, "", err
+		}
+		gitRoot = parent
+	}
+	git, err := exec.LookPath("git")
+	if err != nil {
+		return "", "", err
+	}
+	query := func(name string, args ...string) ([]byte, error) {
+		if _, err := captureCommand(ctx, cfg.Timeout, gitRoot, git, args, stem+"-git-"+name); err != nil {
+			return nil, err
+		}
+		return os.ReadFile(stem + "-git-" + name + ".stdout")
+	}
+	relative, err := filepath.Rel(gitRoot, cfg.Dir)
+	if err != nil {
+		return "", "", err
+	}
+	selected, err := query("selected", "ls-files", "-z", "--", relative)
+	if err != nil {
+		return "", "", err
+	}
+	if len(selected) == 0 {
+		files, err := ciDirectoryFiles(cfg.Dir)
+		if err != nil {
+			return "", "", err
+		}
+		hash, err := ciFilesSHA(cfg.Dir, files)
+		return hash, "", err
+	}
+	status, err := query("status", "status", "--porcelain", "--untracked-files=normal")
+	if err != nil || len(status) != 0 {
+		return "", "", fmt.Errorf("CI source must be clean: %s (%v)", status, err)
+	}
+	head, err := query("head", "rev-parse", "HEAD")
+	if err != nil {
+		return "", "", err
+	}
+	listing, err := query("files", "ls-files", "-z")
+	if err != nil {
+		return "", "", err
+	}
+	files := strings.Split(strings.TrimSuffix(string(listing), "\x00"), "\x00")
+	hash, err := ciFilesSHA(gitRoot, files)
+	return hash, strings.TrimSpace(string(head)), err
+}
diff --git a/cmd/plan9asmtest/ci_suite.go b/cmd/plan9asmtest/ci_suite.go
new file mode 100644
index 000000000..1e6d35e51
--- /dev/null
+++ b/cmd/plan9asmtest/ci_suite.go
@@ -0,0 +1,329 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+type ciRootReceipt struct {
+	Name    string   `json:"name"`
+	Command []string `json:"command"`
+	Stem    string   `json:"artifact_stem"`
+	Exit    int      `json:"actual_exit"`
+	Output  string   `json:"stdout_sha256"`
+	Stderr  string   `json:"stderr_sha256"`
+	Status  string   `json:"status"`
+	Error   string   `json:"error"`
+}
+
+type ciReport struct {
+	Plan   ciPlan          `json:"plan"`
+	Go     string          `json:"actual_go_executable"`
+	Owner  int             `json:"owner"`
+	Roots  []ciRootReceipt `json:"owned_root_receipts"`
+	Final  *ciScope        `json:"final_scope"`
+	Status string          `json:"status"`
+	Error  string          `json:"error"`
+}
+
+func ciWriteJSON(path string, value any) error {
+	data, err := json.MarshalIndent(value, "", "  ")
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(path, append(data, '\n'), 0600)
+}
+
+func ciReadJSON(path string, value any) error {
+	info, err := os.Lstat(path)
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+		return fmt.Errorf("bounded regular report required: %v", err)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	decoder := json.NewDecoder(io.LimitReader(file, 64<<20))
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(value); err != nil {
+		return err
+	}
+	var trailing any
+	if err := decoder.Decode(&trailing); err != io.EOF {
+		return fmt.Errorf("trailing report JSON: %v", err)
+	}
+	return nil
+}
+
+func ciPrepare(cfg config) (config, error) {
+	if cfg.Workers < 0 || cfg.Workers > 1 {
+		return cfg, fmt.Errorf("selected-CI owners remain serial; workers must be one")
+	}
+	if cfg.CISelector == "" || cfg.CIIsolate == "" || cfg.Timeout <= 0 || cfg.Shards < 2 || cfg.Shards > 1024 || cfg.Package == "" || strings.ContainsAny(cfg.Package, " \t\r\n*?[") || strings.Contains(cfg.Package, "...") || os.Getenv("GOFLAGS") != "" {
+		return cfg, fmt.Errorf("complete CI selector/isolate/owners, positive timeout, one exact package and empty GOFLAGS required")
+	}
+	if os.Getenv("GOENV") != "off" || os.Getenv("GOWORK") != "off" || os.Getenv("GOTOOLCHAIN") != "local" {
+		return cfg, fmt.Errorf("CI invocation requires explicit GOENV=off, GOWORK=off, GOTOOLCHAIN=local before launching tools")
+	}
+	flags, profile, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return cfg, err
+	}
+	if profile != "" {
+		return cfg, fmt.Errorf("selected-CI coverage merging is not registered; use ordinary exhaustive suite")
+	}
+	for _, flag := range flags {
+		name, _, _ := strings.Cut(flag, "=")
+		switch name {
+		case "-overlay", "-modfile", "-gcflags", "-asmflags", "-ldflags":
+			return cfg, fmt.Errorf("selected-CI external compiler inputs are not source-indexed: %s (ordinary mode unchanged)", name)
+		}
+	}
+	cfg.Flags = flags
+	if cfg.CIVerify == "" {
+		if cfg.CIOwner < 0 || cfg.CIOwner >= cfg.Shards {
+			return cfg, fmt.Errorf("CI owner outside complete plan")
+		}
+	} else if cfg.CIOwner != -1 {
+		return cfg, fmt.Errorf("CI reader cannot also execute an owner")
+	}
+	cfg.Go, err = exec.LookPath(cfg.Go)
+	if err == nil {
+		cfg.Go, err = filepath.Abs(cfg.Go)
+	}
+	if err == nil {
+		cfg.Dir, err = filepath.Abs(cfg.Dir)
+	}
+	if err == nil {
+		cfg.Out, err = filepath.Abs(cfg.Out)
+	}
+	if err == nil {
+		err = os.Mkdir(cfg.Out, 0755)
+	}
+	return cfg, err
+}
+
+func captureCIPlan(ctx context.Context, cfg config) (ciPlan, error) {
+	plan := ciPlan{Protocol: ciProtocol, Flags: cfg.Flags, Timeout: cfg.Timeout.String(), Selector: cfg.CISelector, Isolate: cfg.CIIsolate, Owners: cfg.Shards}
+	scope, err := captureCIScope(ctx, cfg, filepath.Join(cfg.Out, "before"))
+	if err != nil {
+		return plan, err
+	}
+	plan.Scope = scope
+	listing := func(stem, selector string) (string, []string, []string, error) {
+		args := append([]string{"test"}, cfg.Flags...)
+		args = append(args, "-count=1", "-timeout="+cfg.Timeout.String(), "-list="+selector, cfg.Package)
+		path := filepath.Join(cfg.Out, stem)
+		if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, args, path); err != nil {
+			return "", nil, nil, err
+		}
+		data, err := os.ReadFile(path + ".stdout")
+		if err != nil {
+			return "", nil, nil, err
+		}
+		return parseList(string(data))
+	}
+	plan.Package, plan.Inventory, plan.Benchmarks, err = listing("inventory", ".")
+	if err != nil {
+		return plan, err
+	}
+	selectedPackage, selected, _, err := listing("selected", cfg.CISelector)
+	if err != nil {
+		return plan, err
+	}
+	if selectedPackage != plan.Package {
+		return plan, fmt.Errorf("actual full and selected package identities differ")
+	}
+	plan.Selected = selected
+	plan.InventorySHA, plan.SelectedSHA = ciNamesSHA(plan.Inventory), ciNamesSHA(plan.Selected)
+	_, err = ciAssignments(plan)
+	return plan, err
+}
+
+func ciRootCommand(goBinary string, plan ciPlan, name string) ([]string, error) {
+	pattern, err := runPattern([]string{name})
+	if err != nil {
+		return nil, err
+	}
+	command := append([]string{goBinary, "test"}, plan.Flags...)
+	return append(command, "-count=1", "-timeout="+plan.Timeout, "-json", "-run="+pattern, plan.Package), nil
+}
+
+func runCI(ctx context.Context, cfg config) error {
+	cfg, err := ciPrepare(cfg)
+	if err != nil {
+		return err
+	}
+	plan, err := captureCIPlan(ctx, cfg)
+	if err != nil {
+		return err
+	}
+	if cfg.CIVerify != "" {
+		err = verifyCIArtifacts(plan, cfg.CIVerify)
+		final, guardErr := captureCIScope(ctx, cfg, filepath.Join(cfg.Out, "after"))
+		if guardErr == nil && !reflect.DeepEqual(plan.Scope, final) {
+			guardErr = fmt.Errorf("aggregate source/SDK/tool/environment changed")
+		}
+		result := errors.Join(err, guardErr)
+		status := "passed"
+		if result != nil {
+			status = "failed"
+		}
+		return errors.Join(result, ciWriteJSON(filepath.Join(cfg.Out, "aggregate.json"), struct {
+			Plan   ciPlan `json:"plan"`
+			Status string `json:"status"`
+		}{plan, status}))
+	}
+	owners, _ := ciAssignments(plan)
+	report := ciReport{Plan: plan, Go: cfg.Go, Owner: cfg.CIOwner, Status: "failed", Roots: []ciRootReceipt{}}
+	publish := func() error { return ciWriteJSON(filepath.Join(cfg.Out, "report.json"), report) }
+	if err := publish(); err != nil {
+		return err
+	}
+	var failures []error
+	for index, name := range owners[cfg.CIOwner] {
+		command, err := ciRootCommand(cfg.Go, plan, name)
+		if err != nil {
+			return err
+		}
+		root := ciRootReceipt{Name: name, Command: command, Stem: fmt.Sprintf("root-%04d", index), Exit: -1, Status: "failed"}
+		stem := filepath.Join(cfg.Out, root.Stem)
+		_, executionErr := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, command[1:], stem)
+		if executionErr == nil {
+			root.Exit = 0
+		} else {
+			var exit *exec.ExitError
+			if errors.As(executionErr, &exit) {
+				root.Exit = exit.ExitCode()
+			}
+			root.Error = executionErr.Error()
+		}
+		root.Output, err = ciFileSHA(stem + ".stdout")
+		if err == nil {
+			root.Stderr, err = ciFileSHA(stem + ".stderr")
+		}
+		validationErr := validateCIRoot(cfg.Out, plan, root)
+		if err = errors.Join(executionErr, err, validationErr); err != nil {
+			root.Error = err.Error()
+			failures = append(failures, fmt.Errorf("%s: %w", name, err))
+		} else {
+			root.Status = "passed"
+		}
+		report.Roots = append(report.Roots, root)
+		fmt.Printf("CI owner %d root %s: %s\n", cfg.CIOwner, name, root.Status)
+		if err := publish(); err != nil {
+			return err
+		}
+	}
+	final, err := captureCIScope(ctx, cfg, filepath.Join(cfg.Out, "after"))
+	if err == nil && !reflect.DeepEqual(plan.Scope, final) {
+		err = fmt.Errorf("worker source/SDK/tool/environment changed")
+	}
+	if err != nil {
+		failures = append(failures, err)
+	} else {
+		report.Final = &final
+	}
+	if len(failures) == 0 {
+		report.Status = "passed"
+	} else {
+		report.Error = errors.Join(failures...).Error()
+	}
+	return errors.Join(errors.Join(failures...), publish())
+}
+
+func validateCIRoot(directory string, plan ciPlan, root ciRootReceipt) error {
+	if root.Exit != 0 || root.Error != "" {
+		return fmt.Errorf("root actual execution failed (exit %d): %s", root.Exit, root.Error)
+	}
+	if filepath.Base(root.Stem) != root.Stem || !strings.HasPrefix(root.Stem, "root-") {
+		return fmt.Errorf("root artifact must be local")
+	}
+	var bytes int64
+	for suffix, expected := range map[string]string{".stdout": root.Output, ".stderr": root.Stderr} {
+		info, err := os.Lstat(filepath.Join(directory, root.Stem+suffix))
+		if err != nil || !info.Mode().IsRegular() {
+			return fmt.Errorf("actual output must be a regular owned artifact: %v", err)
+		}
+		bytes += info.Size()
+		if bytes > 64<<20 {
+			return fmt.Errorf("actual root output exceeds original capture bound")
+		}
+		hash, err := ciFileSHA(filepath.Join(directory, root.Stem+suffix))
+		if err != nil || expected == "" || hash != expected {
+			return fmt.Errorf("actual root %s identity differs: %v", suffix, err)
+		}
+	}
+	file, err := os.Open(filepath.Join(directory, root.Stem+".stdout"))
+	if err != nil {
+		return err
+	}
+	outcomes, err := validateEvents(file, plan.Package, []string{root.Name})
+	err = errors.Join(err, file.Close())
+	if err != nil {
+		return err
+	}
+	for name, outcome := range outcomes {
+		if outcome != "pass" {
+			return fmt.Errorf("required root/subtest/seed %s did not pass: %s", name, outcome)
+		}
+	}
+	return nil
+}
+
+func verifyCIArtifacts(expected ciPlan, directory string) error {
+	owners, err := ciAssignments(expected)
+	if err != nil {
+		return err
+	}
+	entries, err := os.ReadDir(directory)
+	if err != nil {
+		return err
+	}
+	if len(entries) != len(owners) {
+		return fmt.Errorf("found %d owners, require exactly %d", len(entries), len(owners))
+	}
+	var failures []error
+	for index, names := range owners {
+		path := filepath.Join(directory, fmt.Sprintf("cross-runtime-owner-%d", index))
+		info, err := os.Lstat(path)
+		if err != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
+			failures = append(failures, fmt.Errorf("owner %d directory missing or aliased", index))
+			continue
+		}
+		var report ciReport
+		if err := ciReadJSON(filepath.Join(path, "report.json"), &report); err != nil {
+			failures = append(failures, err)
+			continue
+		}
+		if err := verifyCIScopeArtifacts(path, report); err != nil {
+			failures = append(failures, fmt.Errorf("owner %d observation: %w", index, err))
+			continue
+		}
+		if !reflect.DeepEqual(report.Plan, expected) || report.Owner != index || report.Go == "" || report.Final == nil || !reflect.DeepEqual(*report.Final, expected.Scope) || report.Status != "passed" || report.Error != "" || len(report.Roots) != len(names) {
+			failures = append(failures, fmt.Errorf("owner %d incomplete or foreign source/SDK/config/plan", index))
+			continue
+		}
+		for position, name := range names {
+			root := report.Roots[position]
+			command, err := ciRootCommand(report.Go, expected, name)
+			if err != nil || root.Name != name || root.Stem != fmt.Sprintf("root-%04d", position) || !reflect.DeepEqual(root.Command, command) || root.Status != "passed" {
+				failures = append(failures, fmt.Errorf("owner %d root %s missing/duplicated/foreign command", index, name))
+				continue
+			}
+			if err := validateCIRoot(path, expected, root); err != nil {
+				failures = append(failures, fmt.Errorf("owner %d root %s: %w", index, name, err))
+			}
+		}
+	}
+	return errors.Join(failures...)
+}
diff --git a/cmd/plan9asmtest/ci_suite_unix_test.go b/cmd/plan9asmtest/ci_suite_unix_test.go
new file mode 100644
index 000000000..36b672937
--- /dev/null
+++ b/cmd/plan9asmtest/ci_suite_unix_test.go
@@ -0,0 +1,359 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func ciFixtureConfig(t *testing.T, source string) config {
+	t.Helper()
+	for key, value := range map[string]string{"GOFLAGS": "", "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "PLAN9ASM_CROSS_EXEC": ""} {
+		t.Setenv(key, value)
+	}
+	return config{Go: "go", Dir: fixture(t, source), Package: ".", Shards: 3, Timeout: 4 * time.Minute, CISelector: "^Test", CIIsolate: "TestGiant", CIOwner: -1, Flags: []string{"-p=2"}}
+}
+
+func readCIReport(t *testing.T, directory string) ciReport {
+	t.Helper()
+	var report ciReport
+	if err := ciReadJSON(filepath.Join(directory, "report.json"), &report); err != nil {
+		t.Fatal(err)
+	}
+	return report
+}
+
+func TestActualGoCIAllOwnersAndStrictAggregate(t *testing.T) {
+	cfg := ciFixtureConfig(t, `package fixture
+import "testing"
+func TestGiant(t *testing.T) { t.Run("seed", func(t *testing.T) {}) }
+func TestAlpha(t *testing.T) {}
+func TestBeta(t *testing.T) {}
+func Example() { /* Output: */ }
+`)
+	artifacts := t.TempDir()
+	var expected ciPlan
+	originalCache := os.Getenv("GOCACHE")
+	for owner := 0; owner < cfg.Shards; owner++ {
+		if owner == 1 {
+			// A separate real cache also forces the SDK's lazy-tool route. Its
+			// bytes must agree, not its worker-specific cached filename.
+			t.Setenv("GOCACHE", t.TempDir())
+		} else {
+			t.Setenv("GOCACHE", originalCache)
+		}
+		cfg.CIOwner = owner
+		cfg.Out = filepath.Join(artifacts, ownerDirectory(owner))
+		if err := runCI(context.Background(), cfg); err != nil {
+			t.Fatal(err)
+		}
+		report := readCIReport(t, cfg.Out)
+		if owner == 0 {
+			expected = report.Plan
+			if len(report.Roots) != 1 || report.Roots[0].Name != "TestGiant" {
+				t.Fatal("giant was not isolated", report.Roots)
+			}
+		}
+	}
+	if len(expected.Inventory) != 4 || len(expected.Selected) != 3 {
+		t.Fatal("ordinary nonselected scope erased", expected)
+	}
+	if err := verifyCIArtifacts(expected, artifacts); err != nil {
+		t.Fatal(err)
+	}
+	cfg.CIOwner, cfg.CIVerify = -1, artifacts
+	cfg.Out = filepath.Join(t.TempDir(), "aggregate")
+	if err := runCI(context.Background(), cfg); err != nil {
+		t.Fatal("fresh actual-list aggregate", err)
+	}
+	// Each mutation starts from a fresh decoded actual report, not an in-memory
+	// shared map whose earlier mutation can accidentally make later axes pass.
+	ownerPath := filepath.Join(artifacts, ownerDirectory(0), "report.json")
+	baseline, err := os.ReadFile(ownerPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mutations := map[string]func(*ciReport){
+		"missing root":        func(r *ciReport) { r.Roots = nil },
+		"duplicate root":      func(r *ciReport) { r.Roots = append(r.Roots, r.Roots[0]) },
+		"unknown root":        func(r *ciReport) { r.Roots[0].Name = "TestUnknown" },
+		"partial":             func(r *ciReport) { r.Final = nil },
+		"foreign source":      func(r *ciReport) { r.Plan.Scope.SourceSHA = "foreign"; r.Final.SourceSHA = "foreign" },
+		"foreign SDK":         func(r *ciReport) { r.Plan.Scope.Tools["go"] = "foreign"; r.Final.Tools["go"] = "foreign" },
+		"foreign SDK source":  func(r *ciReport) { r.Plan.Scope.SDKSource = "foreign"; r.Final.SDKSource = "foreign" },
+		"foreign flags":       func(r *ciReport) { r.Plan.Flags = []string{"-race"} },
+		"foreign environment": func(r *ciReport) { r.Plan.Scope.Environment["CGO_ENABLED"] = "foreign" },
+		"reassigned":          func(r *ciReport) { r.Owner = 1 },
+		"short timeout":       func(r *ciReport) { r.Plan.Timeout = "1s" },
+		"paired plan erasure": func(r *ciReport) { r.Plan.Selected = nil; r.Roots = nil },
+		"exit forged":         func(r *ciReport) { r.Roots[0].Exit = 1 },
+		"failed relabel":      func(r *ciReport) { r.Roots[0].Error = "actual failure" },
+		"filtered command":    func(r *ciReport) { r.Roots[0].Command = append(r.Roots[0].Command, "-skip=.") },
+		"raw identity":        func(r *ciReport) { r.Roots[0].Output = "foreign" },
+		"paired tool path": func(r *ciReport) {
+			r.Go = "/foreign/bin/go"
+			r.Roots[0].Command[0] = r.Go
+		},
+		"escaping artifact": func(r *ciReport) { r.Roots[0].Stem = "../root-0000" },
+	}
+	for name, mutation := range mutations {
+		t.Run(name, func(t *testing.T) {
+			var report ciReport
+			if err := json.Unmarshal(baseline, &report); err != nil {
+				t.Fatal(err)
+			}
+			mutation(&report)
+			if err := ciWriteJSON(ownerPath, report); err != nil {
+				t.Fatal(err)
+			}
+			if err := verifyCIArtifacts(expected, artifacts); err == nil {
+				t.Fatal("mutation admitted")
+			}
+		})
+	}
+	if err := os.WriteFile(ownerPath, baseline, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyCIArtifacts(expected, artifacts); err != nil {
+		t.Fatal("mutation control", err)
+	}
+	envPath := filepath.Join(artifacts, ownerDirectory(0), "before-env.stdout")
+	envBytes, err := os.ReadFile(envPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, key := range []string{"GOGCCFLAGS", "GOCACHEPROG", "FUTURE_SEMANTIC_INPUT"} {
+		t.Run("complete actual environment/"+key, func(t *testing.T) {
+			var environment map[string]string
+			if err := json.Unmarshal(envBytes, &environment); err != nil {
+				t.Fatal(err)
+			}
+			environment[key] += " changed"
+			if err := ciWriteJSON(envPath, environment); err != nil {
+				t.Fatal(err)
+			}
+			if err := verifyCIArtifacts(expected, artifacts); err == nil {
+				t.Fatal("uncaptured actual environment field admitted")
+			}
+		})
+	}
+	if err := os.WriteFile(envPath, envBytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyCIArtifacts(expected, artifacts); err != nil {
+		t.Fatal("complete environment mutation control", err)
+	}
+	missing := filepath.Join(artifacts, ownerDirectory(2))
+	if err := os.Rename(missing, missing+"-unknown"); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyCIArtifacts(expected, artifacts); err == nil {
+		t.Fatal("unknown/missing owner accepted")
+	}
+}
+
+func ownerDirectory(owner int) string { return fmt.Sprintf("cross-runtime-owner-%d", owner) }
+
+func TestActualGoCILateSourceMutationRevokesCompletion(t *testing.T) {
+	cfg := ciFixtureConfig(t, `package fixture
+import (
+    "os"
+    "testing"
+)
+func TestGiant(t *testing.T) {
+    if err := os.WriteFile("value.go", []byte("package fixture\nfunc value() int { return 9 }\n"), 0600); err != nil { t.Fatal(err) }
+}
+`)
+	cfg.CIOwner = 0
+	cfg.Out = filepath.Join(t.TempDir(), "late-change")
+	if err := runCI(context.Background(), cfg); err == nil || !strings.Contains(err.Error(), "changed") {
+		t.Fatal("actual late source change accepted", err)
+	}
+	report := readCIReport(t, cfg.Out)
+	if len(report.Roots) != 1 || report.Roots[0].Status != "passed" || report.Status != "failed" || report.Final != nil {
+		t.Fatal("successful raw test substituted for stable provenance", report)
+	}
+}
+
+func TestActualGoCICancellationRetainsIncompleteRoot(t *testing.T) {
+	// Readiness belongs outside the observed source tree: executing the root
+	// must not itself revoke the otherwise unchanged source observation.
+	ready := filepath.Join(t.TempDir(), "root-ready")
+	cfg := ciFixtureConfig(t, fmt.Sprintf(`package fixture
+import (
+    "os"
+    "testing"
+)
+func TestGiant(t *testing.T) {
+    ready := %q
+    if err := os.WriteFile(ready+".pending", []byte("TestGiant started\n"), 0600); err != nil { t.Fatal(err) }
+    if err := os.Rename(ready+".pending", ready); err != nil { t.Fatal(err) }
+    select {}
+}
+`, ready))
+	cfg.CIOwner = 0
+	cfg.Out = filepath.Join(t.TempDir(), "cancelled")
+	ctx, cancel := context.WithCancel(context.Background())
+	done := make(chan error, 1)
+	go func() { done <- runCI(ctx, cfg) }()
+	joined := false
+	defer func() {
+		cancel()
+		if !joined {
+			<-done
+		}
+	}()
+	// Planning and a cold SDK build are not the cancellation under test. Keep
+	// their existing command bound, then begin the original four-second window
+	// only once this exact root has actually entered its body.
+	preparation := time.NewTimer(cfg.Timeout)
+	defer preparation.Stop()
+	poll := time.NewTicker(10 * time.Millisecond)
+	defer poll.Stop()
+	for {
+		data, err := os.ReadFile(ready)
+		if err == nil {
+			if string(data) != "TestGiant started\n" {
+				t.Fatal("unexpected root readiness marker", string(data))
+			}
+			break
+		}
+		if !os.IsNotExist(err) {
+			t.Fatal(err)
+		}
+		select {
+		case err := <-done:
+			joined = true
+			t.Fatal("CI owner ended before its actual root started", err)
+		case <-preparation.C:
+			t.Fatal("actual root did not start within its original command budget")
+		case <-poll.C:
+		}
+	}
+	running := time.NewTimer(4 * time.Second)
+	defer running.Stop()
+	select {
+	case err := <-done:
+		joined = true
+		t.Fatal("actual root ended before cancellation", err)
+	case <-running.C:
+		cancel()
+	}
+	err := <-done
+	joined = true
+	if err == nil {
+		t.Fatal("cancelled child accepted")
+	}
+	report := readCIReport(t, cfg.Out)
+	if report.Status != "failed" || len(report.Roots) != 1 || report.Roots[0].Status != "failed" || report.Roots[0].Exit == 0 || report.Final != nil {
+		t.Fatal("cancellation lost incomplete receipt", report)
+	}
+}
+
+func TestActualGoCIFreshPerRootBudget(t *testing.T) {
+	cfg := ciFixtureConfig(t, `package fixture
+import (
+    "testing"
+    "time"
+)
+func TestGiant(t *testing.T) { time.Sleep(1100*time.Millisecond) }
+func TestAlpha(t *testing.T) { time.Sleep(1100*time.Millisecond) }
+func TestBeta(t *testing.T) { time.Sleep(1100*time.Millisecond) }
+func TestDelta(t *testing.T) { time.Sleep(1100*time.Millisecond) }
+func TestGamma(t *testing.T) { time.Sleep(1100*time.Millisecond) }
+`)
+	// Warm only compilation/listing, not results, so the comparison is the
+	// exact same safe original roots with the same four-second child deadline.
+	warm := filepath.Join(t.TempDir(), "warm")
+	if _, err := captureCommand(context.Background(), cfg.Timeout, cfg.Dir, cfg.Go, []string{"test", "-count=1", "-list=.", "."}, warm); err != nil {
+		t.Fatal(err)
+	}
+	monolithic := filepath.Join(t.TempDir(), "monolithic")
+	if _, err := captureCommand(context.Background(), 4*time.Second, cfg.Dir, cfg.Go, []string{"test", "-count=1", "-timeout=4s", "-json", "-run=^Test", "."}, monolithic); err == nil {
+		t.Fatal("original combined command unexpectedly fit all five roots")
+	} else {
+		t.Logf("original combined command actual deadline rejection: %v", err)
+		output, readErr := os.ReadFile(monolithic + ".stdout")
+		if readErr != nil {
+			t.Fatal(readErr)
+		}
+		t.Logf("original combined raw Go JSON (not complete):\n%s", output)
+	}
+	cfg.Shards, cfg.CIOwner, cfg.Timeout = 2, 1, 4*time.Second
+	cfg.Out = filepath.Join(t.TempDir(), "fresh-budgets")
+	if err := runCI(context.Background(), cfg); err != nil {
+		t.Fatal("same per-child budget was not fresh", err)
+	}
+	report := readCIReport(t, cfg.Out)
+	if report.Plan.Timeout != "4s" || len(report.Roots) != 4 || report.Status != "passed" {
+		t.Fatal("roots/budgets lost", report)
+	}
+}
+
+func TestActualGoCIFailureStickyAndSkipNotPass(t *testing.T) {
+	for name, body := range map[string]string{"failure": `t.Fatal("actual failure")`, "skip": `t.Skip("explicit platform boundary")`} {
+		t.Run(name, func(t *testing.T) {
+			cfg := ciFixtureConfig(t, "package fixture\nimport \"testing\"\nfunc TestGiant(t *testing.T) {}\nfunc TestAlpha(t *testing.T) { "+body+" }\nfunc TestRemaining(t *testing.T) {}\n")
+			cfg.Shards, cfg.CIOwner = 2, 1
+			cfg.Out = filepath.Join(t.TempDir(), "owner")
+			if err := runCI(context.Background(), cfg); err == nil {
+				t.Fatal("failure/Skip promoted")
+			}
+			report := readCIReport(t, cfg.Out)
+			if report.Status != "failed" || len(report.Roots) != 2 || report.Roots[1].Name != "TestRemaining" || report.Roots[1].Status != "passed" || report.Final == nil {
+				t.Fatal("failure lost or later root not executed", report)
+			}
+		})
+	}
+}
+
+func TestCIRawTerminalsRemainIndependent(t *testing.T) {
+	plan := ciPlan{Package: "fixture"}
+	for name, raw := range map[string]string{
+		"missing":          "",
+		"unknown":          `{"Action":"start","Package":"fixture"}` + "\n" + `{"Action":"run","Package":"fixture","Test":"TestOther"}` + "\n",
+		"incomplete child": `{"Action":"start","Package":"fixture"}` + "\n" + `{"Action":"run","Package":"fixture","Test":"TestAlpha"}` + "\n" + `{"Action":"run","Package":"fixture","Test":"TestAlpha/seed"}` + "\n" + `{"Action":"pass","Package":"fixture","Test":"TestAlpha"}` + "\n" + `{"Action":"pass","Package":"fixture"}` + "\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			dir := t.TempDir()
+			os.WriteFile(filepath.Join(dir, "root-0000.stdout"), []byte(raw), 0600)
+			os.WriteFile(filepath.Join(dir, "root-0000.stderr"), nil, 0600)
+			out, _ := ciFileSHA(filepath.Join(dir, "root-0000.stdout"))
+			stderr, _ := ciFileSHA(filepath.Join(dir, "root-0000.stderr"))
+			root := ciRootReceipt{Name: "TestAlpha", Stem: "root-0000", Output: out, Stderr: stderr}
+			if err := validateCIRoot(dir, plan, root); err == nil {
+				t.Fatal("bare exit-zero receipt replaced actual terminals")
+			}
+		})
+	}
+}
+
+func TestCIRejectsHiddenScopeAndUnknownJSON(t *testing.T) {
+	cfg := ciFixtureConfig(t, "package fixture\nimport \"testing\"\nfunc TestGiant(t *testing.T) {}\n")
+	for _, flags := range [][]string{{"-run=."}, {"-skip=."}, {"-coverprofile=x"}, {"-overlay=x"}, {"-modfile=x"}, {"-gcflags=all=@x"}, {"-asmflags=all=@x"}, {"-ldflags=@x"}} {
+		cfg.Flags = flags
+		cfg.Out = filepath.Join(t.TempDir(), "invalid")
+		if _, err := ciPrepare(cfg); err == nil {
+			t.Fatal("hidden selector accepted", flags)
+		}
+	}
+	path := filepath.Join(t.TempDir(), "unknown.json")
+	for _, text := range []string{`{"unexpected":true}`, `{} {}`} {
+		os.WriteFile(path, []byte(text), 0600)
+		var report ciReport
+		if err := ciReadJSON(path, &report); err == nil {
+			t.Fatal("unknown/trailing JSON accepted")
+		}
+	}
+	if !reflect.DeepEqual(testCIPlan().Selected, []string{"TestAlpha", "TestBeta", "TestGiant"}) || strings.Contains(testCIPlan().Selector, "/") {
+		t.Fatal("fixture drift")
+	}
+}
diff --git a/cmd/plan9asmtest/cmov_fixed_local_partition_test.go b/cmd/plan9asmtest/cmov_fixed_local_partition_test.go
new file mode 100644
index 000000000..1d7b6b861
--- /dev/null
+++ b/cmd/plan9asmtest/cmov_fixed_local_partition_test.go
@@ -0,0 +1,117 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestCMOVFixedLocalObjectsHaveIndependentTargetOwners(t *testing.T) {
+	fixedLocalRequireTargetOwners(t, "amd64_cmov_fixed_local_test.go",
+		"TestX86CMOVFamilyFixedLocalAUTOActualObjects", "x86CMOVFixedLocalActualObjects", 6,
+		[]struct{ name, target, triple string }{
+			{"Linux", "linux/amd64", "x86_64-unknown-linux-gnu"},
+			{"Darwin", "darwin/amd64", "x86_64-apple-darwin"},
+		})
+}
+
+func TestCMOVFixedLocalRuntimeHasIndependentBatchOwners(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", "amd64_cmov_fixed_local_runtime_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const prefix = "TestCrossLinuxRuntimeMatrixX86CMOVFixedLocalAUTOWholeBytes"
+	want := make(map[string]int)
+	for batch := 0; batch < 7; batch++ {
+		want[fmt.Sprintf("%sBatch%02d", prefix, batch)] = batch
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || !strings.HasPrefix(function.Name.Name, prefix) {
+			continue
+		}
+		batch, found := want[function.Name.Name]
+		if !found || function.Body == nil || len(function.Body.List) != 1 {
+			t.Fatal("unknown, monolithic or incomplete CMOV runtime owner", function.Name.Name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("runtime owner must call the complete shared plan", function.Name.Name)
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 2 {
+			t.Fatal("runtime owner changed its complete-plan arguments", function.Name.Name)
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != "x86CMOVFixedLocalRuntimeBatch" {
+			t.Fatal("runtime owner substituted its complete-plan helper", function.Name.Name)
+		}
+		receiver, ok := call.Args[0].(*ast.Ident)
+		if !ok || receiver.Name != "t" {
+			t.Fatal("runtime batch must retain its actual test lifetime", function.Name.Name)
+		}
+		literal, ok := call.Args[1].(*ast.BasicLit)
+		if !ok || literal.Kind != token.INT {
+			t.Fatal("runtime batch index must remain literal", function.Name.Name)
+		}
+		actual, err := strconv.Atoi(literal.Value)
+		if err != nil || actual != batch {
+			t.Fatal("runtime owner changed its exact range", function.Name.Name, actual, batch)
+		}
+		delete(want, function.Name.Name)
+	}
+	if len(want) != 0 {
+		t.Fatal("missing complete CMOV runtime owners", want)
+	}
+}
+
+func TestCMOVFixedLocalRuntimePreparesOwnedToolCacheBeforeCapture(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", "amd64_cmov_fixed_local_runtime_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var prepared, captured []token.Pos
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "x86CMOVFixedLocalRuntimeBatch" {
+			continue
+		}
+		for _, statement := range function.Body.List {
+			ast.Inspect(statement, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				helper, ok := call.Fun.(*ast.Ident)
+				if !ok {
+					return true
+				}
+				switch helper.Name {
+				case "goAMD64FramePrepareOwnedToolCache":
+					direct, directOK := statement.(*ast.ExprStmt)
+					if !directOK || direct.X != call || len(call.Args) != 1 {
+						t.Fatal("CMOV tool cache must be prepared by the common runtime owner")
+					}
+					argument, valid := call.Args[0].(*ast.Ident)
+					if !valid || argument.Name != "t" {
+						t.Fatal("CMOV tool cache lost its actual test lifetime")
+					}
+					prepared = append(prepared, call.Pos())
+				case "x86CMOVFixedLocalFixture":
+					captured = append(captured, call.Pos())
+				}
+				return true
+			})
+		}
+	}
+	if len(prepared) != 1 || len(captured) != 1 || prepared[0] >= captured[0] {
+		t.Fatal("CMOV runtime must prepare its process-owned lazy tool cache before independent source capture", prepared, captured)
+	}
+}
diff --git a/cmd/plan9asmtest/coverage.go b/cmd/plan9asmtest/coverage.go
new file mode 100644
index 000000000..4295bea4f
--- /dev/null
+++ b/cmd/plan9asmtest/coverage.go
@@ -0,0 +1,108 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type coverageBlock struct {
+	Statements uint64
+	Count      uint64
+}
+
+var coverageLocation = regexp.MustCompile(`^.+:[1-9][0-9]*\.[1-9][0-9]*,[1-9][0-9]*\.[1-9][0-9]*$`)
+
+func mergeCoverage(inputs []string) ([]byte, error) {
+	return mergeCoverageInventory(inputs, true)
+}
+
+func mergeModuleCoverage(inputs []string) ([]byte, error) {
+	return mergeCoverageInventory(inputs, false)
+}
+
+func mergeCoverageInventory(inputs []string, identical bool) ([]byte, error) {
+	if len(inputs) == 0 {
+		return nil, fmt.Errorf("no coverage inputs")
+	}
+	var mode string
+	var total map[string]coverageBlock
+	for _, path := range inputs {
+		file, err := os.Open(path)
+		if err != nil {
+			return nil, err
+		}
+		currentMode, blocks, readErr := readCoverage(file)
+		closeErr := file.Close()
+		if readErr != nil || closeErr != nil {
+			return nil, fmt.Errorf("coverage %s: read=%v close=%v", path, readErr, closeErr)
+		}
+		if total == nil {
+			mode, total = currentMode, blocks
+			continue
+		}
+		if currentMode != mode || identical && len(blocks) != len(total) {
+			return nil, fmt.Errorf("coverage mode/block inventory changed in %s", path)
+		}
+		for key, block := range blocks {
+			old, exists := total[key]
+			if !exists && !identical {
+				total[key] = block
+				continue
+			}
+			if !exists || old.Statements != block.Statements || math.MaxUint64-old.Count < block.Count {
+				return nil, fmt.Errorf("coverage block changed/counter overflow: %s", key)
+			}
+			if mode == "set" {
+				old.Count |= block.Count
+			} else {
+				old.Count += block.Count
+			}
+			total[key] = old
+		}
+	}
+	var out strings.Builder
+	fmt.Fprintf(&out, "mode: %s\n", mode)
+	keys := make([]string, 0, len(total))
+	for key := range total {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		block := total[key]
+		fmt.Fprintf(&out, "%s %d %d\n", key, block.Statements, block.Count)
+	}
+	return []byte(out.String()), nil
+}
+
+func readCoverage(file *os.File) (string, map[string]coverageBlock, error) {
+	scanner := largeScanner(file)
+	if !scanner.Scan() {
+		return "", nil, fmt.Errorf("missing coverage mode: %v", scanner.Err())
+	}
+	mode := strings.TrimPrefix(scanner.Text(), "mode: ")
+	if scanner.Text() != "mode: "+mode || mode != "set" && mode != "count" && mode != "atomic" {
+		return "", nil, fmt.Errorf("invalid coverage mode")
+	}
+	blocks := make(map[string]coverageBlock)
+	for scanner.Scan() {
+		fields := strings.Fields(scanner.Text())
+		if len(fields) != 3 || !coverageLocation.MatchString(fields[0]) {
+			return "", nil, fmt.Errorf("invalid coverage block %q", scanner.Text())
+		}
+		statements, err1 := strconv.ParseUint(fields[1], 10, 64)
+		count, err2 := strconv.ParseUint(fields[2], 10, 64)
+		if _, duplicate := blocks[fields[0]]; duplicate || err1 != nil || err2 != nil || mode == "set" && count > 1 {
+			return "", nil, fmt.Errorf("invalid/duplicate coverage counters %q", scanner.Text())
+		}
+		blocks[fields[0]] = coverageBlock{statements, count}
+	}
+	if err := scanner.Err(); err != nil {
+		return "", nil, err
+	}
+	return mode, blocks, nil
+}
diff --git a/cmd/plan9asmtest/data_matrix_partition_test.go b/cmd/plan9asmtest/data_matrix_partition_test.go
new file mode 100644
index 000000000..a15f779a8
--- /dev/null
+++ b/cmd/plan9asmtest/data_matrix_partition_test.go
@@ -0,0 +1,77 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Scheduling policy only: actual Go and LLVM objects execute in the three
+// independent target owners. Their union must not become a filtered sample.
+func TestReadonlyDataTargetsHaveIndependentCompleteRootOwners(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join("..", "..", "amd64_fixed_local_data_matrix_go127_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string][2]string{
+		"TestGoAMD64FixedLocalReadonlyDataLinuxRegisteredConsumers":   {"linux/amd64", "x86_64-unknown-linux-gnu"},
+		"TestGoAMD64FixedLocalReadonlyDataDarwinRegisteredConsumers":  {"darwin/amd64", "x86_64-apple-darwin"},
+		"TestGoAMD64FixedLocalReadonlyDataWindowsRegisteredConsumers": {"windows/amd64", "x86_64-pc-windows-msvc"},
+	}
+	var roots []string
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || !strings.HasPrefix(function.Name.Name, "TestGoAMD64FixedLocalReadonlyData") ||
+			!strings.HasSuffix(function.Name.Name, "RegisteredConsumers") {
+			continue
+		}
+		target, exists := wanted[function.Name.Name]
+		if !exists || function.Body == nil || len(function.Body.List) != 1 {
+			t.Fatal("unknown or independently filtered literal-data owner", function.Name.Name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("literal-data owner is not a complete helper dispatch")
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 3 {
+			t.Fatal("literal-data owner changed complete target dispatch")
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != "fixedLocalDataTargetConsumers" {
+			t.Fatal("literal-data owner bypassed the complete shared matrix")
+		}
+		for index, value := range target {
+			literal, ok := call.Args[index+1].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("target must remain an explicit independent role")
+			}
+			actual, err := strconv.Unquote(literal.Value)
+			if err != nil || actual != value {
+				t.Fatal("literal-data target/triple changed", actual, err)
+			}
+		}
+		roots = append(roots, function.Name.Name)
+	}
+	if len(roots) != len(wanted) {
+		t.Fatal("literal-data matrix lost a complete target owner", roots)
+	}
+	shards, err := partition(roots, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	owners := map[int]bool{}
+	for index, names := range shards {
+		if len(names) == 0 {
+			continue
+		}
+		if len(names) != 1 || owners[index%16] {
+			t.Fatal("expensive complete targets share a Windows scheduling owner", names)
+		}
+		owners[index%16] = true
+	}
+}
diff --git a/cmd/plan9asmtest/events.go b/cmd/plan9asmtest/events.go
new file mode 100644
index 000000000..ec33903ef
--- /dev/null
+++ b/cmd/plan9asmtest/events.go
@@ -0,0 +1,119 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+)
+
+type testEvent struct {
+	Action     string
+	Package    string
+	ImportPath string
+	Test       string
+}
+
+func validateEvents(reader io.Reader, pkg string, names []string) (map[string]string, error) {
+	return validateSuiteEvents(reader, pkg, names, false, false)
+}
+
+func validateSuiteEvents(reader io.Reader, pkg string, names []string, allowEmpty, noTestFiles bool) (map[string]string, error) {
+	states := make(map[string]string)
+	planned := make(map[string]bool)
+	for _, name := range names {
+		if !validName(name) || planned[name] {
+			return states, fmt.Errorf("invalid/duplicate JSON plan %q", name)
+		}
+		planned[name] = true
+	}
+	if len(planned) == 0 && !allowEmpty {
+		return states, fmt.Errorf("empty JSON plan")
+	}
+	started, finished, failed := false, false, false
+	scanner := largeScanner(reader)
+	for scanner.Scan() {
+		var event testEvent
+		if err := json.Unmarshal(scanner.Bytes(), &event); err != nil {
+			return states, fmt.Errorf("invalid Go JSON: %w", err)
+		}
+		// Go 1.24+ emits dependency compiler output separately from test2json.
+		if event.Action == "build-output" && event.ImportPath != "" && event.Test == "" {
+			continue
+		}
+		if event.Package != pkg || finished {
+			return states, fmt.Errorf("unexpected package or post-terminal event: %+v", event)
+		}
+		if event.Test == "" {
+			switch event.Action {
+			case "start":
+				if started {
+					return states, fmt.Errorf("duplicate package start")
+				}
+				started = true
+			case "output":
+				if !started {
+					return states, fmt.Errorf("package output before start")
+				}
+			case "pass", "fail":
+				if !started {
+					return states, fmt.Errorf("package terminal before start")
+				}
+				finished = true
+				failed = failed || event.Action == "fail"
+			case "skip":
+				// Go's package-level no-test-files terminal is not a skipped
+				// selected test. This is only allowed by actual go list metadata.
+				if !started || !noTestFiles || len(planned) != 0 {
+					return states, fmt.Errorf("unexpected package skip")
+				}
+				finished = true
+			default:
+				return states, fmt.Errorf("unexpected package action %q", event.Action)
+			}
+			continue
+		}
+		root, _, child := strings.Cut(event.Test, "/")
+		if !started || !planned[root] || child && states[root] != "run" {
+			return states, fmt.Errorf("unplanned/out-of-order test event: %+v", event)
+		}
+		switch event.Action {
+		case "run":
+			if states[event.Test] != "" {
+				return states, fmt.Errorf("duplicate test run: %s", event.Test)
+			}
+			states[event.Test] = "run"
+		case "pass", "fail", "skip":
+			if states[event.Test] != "run" {
+				return states, fmt.Errorf("test terminal without unique run: %s", event.Test)
+			}
+			states[event.Test] = event.Action
+			failed = failed || event.Action == "fail"
+		case "output", "pause", "cont", "attr", "artifacts":
+			// Terminal output can occur before the corresponding terminal event,
+			// but cannot serve as a substitute for an actual run/terminal pair.
+			if states[event.Test] != "run" {
+				return states, fmt.Errorf("test action outside run: %+v", event)
+			}
+		default:
+			return states, fmt.Errorf("unexpected test action %q", event.Action)
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return states, err
+	}
+	for name := range planned {
+		if states[name] != "pass" && states[name] != "skip" && states[name] != "fail" {
+			return states, fmt.Errorf("missing planned test terminal: %s", name)
+		}
+	}
+	for name, state := range states {
+		if state == "run" {
+			return states, fmt.Errorf("missing subtest/seed terminal: %s", name)
+		}
+	}
+	if !finished || failed {
+		return states, fmt.Errorf("missing package pass or actual test/package failure")
+	}
+	return states, nil
+}
diff --git a/cmd/plan9asmtest/fixed_local_conversion_partition_test.go b/cmd/plan9asmtest/fixed_local_conversion_partition_test.go
new file mode 100644
index 000000000..cfc26db5e
--- /dev/null
+++ b/cmd/plan9asmtest/fixed_local_conversion_partition_test.go
@@ -0,0 +1,368 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestFixedLocalConversionObjectsHaveIndependentTargetOwners(t *testing.T) {
+	fixedLocalRequireIndependentTargetOwners(t, "amd64_fixed_local_conversion_test.go",
+		"TestGoAMD64FixedLocalConversionActualObjects", "fixedLocalConversionActualObjects", 12)
+}
+
+func TestFixedLocalConversionNativeHasIndependentCompleteBatchOwners(t *testing.T) {
+	const prefix = "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch"
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", "amd64_fixed_local_conversion_runtime_linux_amd64_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := make(map[int]bool)
+	var roots []string
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		name := function.Name.Name
+		if !strings.HasPrefix(name, prefix) || function.Body == nil || len(function.Body.List) != 1 {
+			t.Fatal("native conversion must retain independently scheduled complete batches", name)
+		}
+		batch, err := strconv.Atoi(strings.TrimPrefix(name, prefix))
+		if err != nil || batch < 0 || batch >= 7 || seen[batch] || name != fmt.Sprintf("%s%02d", prefix, batch) {
+			t.Fatal("unknown or repeated native conversion batch", name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("batch owner must call its native runtime directly", name)
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 4 {
+			t.Fatal("native batch lost its complete source plan", name)
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != "fixedLocalConversionRuntimeBatch" {
+			t.Fatal("native batch substituted the complete runtime", name)
+		}
+		literal, ok := call.Args[3].(*ast.BasicLit)
+		if !ok || literal.Kind != token.INT || literal.Value != strconv.Itoa(batch) {
+			t.Fatal("native runtime lost its independent batch index", name)
+		}
+		seen[batch] = true
+		roots = append(roots, name)
+	}
+	if len(seen) != 7 {
+		t.Fatal("missing native conversion batches", seen)
+	}
+	for _, count := range []int{16, 32, 64} {
+		shards, err := partition(roots, count)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, names := range shards {
+			if len(names) > 2 {
+				t.Fatal("native conversion batches accumulate in one shard", count, index, names)
+			}
+		}
+	}
+}
+
+func TestFixedLocalPackedObjectsHaveIndependentTargetOwners(t *testing.T) {
+	fixedLocalRequireIndependentTargetOwners(t, "amd64_fixed_local_packed_matrix_test.go",
+		"TestGoAMD64FixedLocalPackedCompleteFormsActualObjects", "fixedLocalPackedActualObjects", 4)
+}
+
+func fixedLocalRequireIndependentTargetOwners(t *testing.T, filename, prefix, plan string, batches int) {
+	t.Helper()
+	fixedLocalRequireTargetOwners(t, filename, prefix, plan, batches,
+		[]struct{ name, target, triple string }{
+			{"Linux", "linux/amd64", "x86_64-unknown-linux-gnu"},
+			{"Darwin", "darwin/amd64", "x86_64-apple-darwin"},
+			{"Windows", "windows/amd64", "x86_64-pc-windows-msvc"},
+		})
+}
+
+func fixedLocalRequireTargetOwners(t *testing.T, filename, prefix, plan string, batches int,
+	platforms []struct{ name, target, triple string }) {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", filename), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	type owner struct {
+		target, triple string
+		batch          int
+	}
+	want := make(map[string]owner)
+	for _, platform := range platforms {
+		for batch := 0; batch < batches; batch++ {
+			name := fmt.Sprintf("%s%sBatch%02d", prefix, platform.name, batch)
+			want[name] = owner{platform.target, platform.triple, batch}
+		}
+	}
+	var roots []string
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || !strings.HasPrefix(function.Name.Name, prefix) {
+			continue
+		}
+		target, found := want[function.Name.Name]
+		if !found {
+			t.Fatal("unknown or monolithic fixed-local object owner", function.Name.Name)
+		}
+		if len(function.Body.List) != 1 {
+			t.Fatal("target owner must call the complete shared object plan", function.Name.Name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			t.Fatal("target owner has no direct complete-plan call", function.Name.Name)
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 4 {
+			t.Fatal("target owner changed its complete-plan arguments", function.Name.Name)
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != plan {
+			t.Fatal("target owner substituted its complete-plan helper", function.Name.Name)
+		}
+		receiver, ok := call.Args[0].(*ast.Ident)
+		if !ok || receiver.Name != "t" {
+			t.Fatal("batch owner must retain its actual test lifetime", function.Name.Name)
+		}
+		for index, expected := range []string{target.target, target.triple} {
+			literal, ok := call.Args[index+1].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("target binding must retain its literal platform", function.Name.Name)
+			}
+			actual, err := strconv.Unquote(literal.Value)
+			if err != nil || actual != expected {
+				t.Fatal("target owner changed platform or LLVM triple", function.Name.Name, actual, expected)
+			}
+		}
+		literal, ok := call.Args[3].(*ast.BasicLit)
+		if !ok || literal.Kind != token.INT {
+			t.Fatal("batch owner must retain a literal batch index", function.Name.Name)
+		}
+		batch, err := strconv.Atoi(literal.Value)
+		if err != nil || batch != target.batch {
+			t.Fatal("batch owner changed its exact conversion range", function.Name.Name, batch, target.batch)
+		}
+		delete(want, function.Name.Name)
+		roots = append(roots, function.Name.Name)
+	}
+	if len(want) != 0 {
+		t.Fatal("missing complete target owners", want)
+	}
+	shards, err := partition(roots, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, roots := range shards {
+		if len(roots) > 3 {
+			t.Fatalf("too many conversion object batches share shard %d: %v", index, roots)
+		}
+	}
+}
+
+func TestFixedLocalConversionObjectCacheIsOwnedByTheWholeTarget(t *testing.T) {
+	fixedLocalRequireOwnedObjectCache(t, "amd64_fixed_local_conversion_test.go", "fixedLocalConversionActualObjects")
+}
+
+func TestFixedLocalPackedObjectCacheIsOwnedByTheWholeTarget(t *testing.T) {
+	fixedLocalRequireOwnedObjectCache(t, "amd64_fixed_local_packed_matrix_test.go", "fixedLocalPackedActualObjects")
+}
+
+func fixedLocalRequireOwnedObjectCache(t *testing.T, filename, plan string) {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", filename), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var helper *ast.FuncDecl
+	for _, declaration := range syntax.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == plan {
+			helper = function
+		}
+	}
+	if helper == nil {
+		t.Fatal("missing complete fixed-local object helper")
+	}
+	isCache := func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) != 2 {
+			return false
+		}
+		selector, ok := call.Fun.(*ast.SelectorExpr)
+		if !ok || selector.Sel.Name != "Setenv" {
+			return false
+		}
+		receiver, ok := selector.X.(*ast.Ident)
+		key, literal := call.Args[0].(*ast.BasicLit)
+		return ok && receiver.Name == "t" && literal && key.Value == `"GOCACHE"`
+	}
+	all, parent := 0, 0
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		if isCache(node) {
+			all++
+		}
+		return true
+	})
+	for _, statement := range helper.Body.List {
+		if _, loop := statement.(*ast.ForStmt); loop && parent == 0 {
+			t.Fatal("build cache must be selected before any batch executes")
+		}
+		if expression, ok := statement.(*ast.ExprStmt); ok && isCache(expression.X) {
+			call := expression.X.(*ast.CallExpr)
+			cache, ok := call.Args[1].(*ast.CallExpr)
+			if !ok || len(cache.Args) != 0 {
+				t.Fatal("build cache must be created by the parent test")
+			}
+			selector, ok := cache.Fun.(*ast.SelectorExpr)
+			if !ok || selector.Sel.Name != "TempDir" {
+				t.Fatal("build cache must retain test-owned cleanup")
+			}
+			receiver, ok := selector.X.(*ast.Ident)
+			if !ok || receiver.Name != "t" {
+				t.Fatal("build cache must belong to this parent test")
+			}
+			parent++
+		}
+	}
+	if all != 1 || parent != 1 {
+		t.Fatal("conversion batches must share exactly one parent-owned build cache", all, parent)
+	}
+}
+
+func TestFixedLocalConversionPreparesLazyToolsBeforeSourceCapture(t *testing.T) {
+	fixedLocalRequirePreparedTools(t, "amd64_fixed_local_conversion_test.go", "fixedLocalConversionActualObjects")
+}
+
+func TestFixedLocalConversionRuntimeKeepsOneOwnedCacheAndPreparedTools(t *testing.T) {
+	fixedLocalRequireOwnedObjectCache(t, "amd64_fixed_local_conversion_runtime_unix_test.go", "fixedLocalConversionRuntimeBatch")
+	fixedLocalRequirePreparedTools(t, "amd64_fixed_local_conversion_runtime_unix_test.go", "fixedLocalConversionRuntimeBatch")
+}
+
+func TestFixedLocalConversionObjectsBoundEachIndependentAPISource(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", "amd64_fixed_local_conversion_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	chunks := 0
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "fixedLocalConversionActualObjects" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			loop, ok := node.(*ast.ForStmt)
+			if !ok {
+				return true
+			}
+			increment, ok := loop.Post.(*ast.AssignStmt)
+			if !ok || increment.Tok != token.ADD_ASSIGN || len(increment.Lhs) != 1 || len(increment.Rhs) != 1 {
+				return true
+			}
+			name, ok := increment.Lhs[0].(*ast.Ident)
+			limit, literal := increment.Rhs[0].(*ast.BasicLit)
+			if !ok || name.Name != "chunk" || !literal || limit.Kind != token.INT || limit.Value != "32" {
+				return true
+			}
+			initial, ok := loop.Init.(*ast.AssignStmt)
+			if !ok || initial.Tok != token.DEFINE || len(initial.Lhs) != 1 || len(initial.Rhs) != 1 {
+				t.Fatal("source chunks lost their complete batch start")
+			}
+			left, leftOK := initial.Lhs[0].(*ast.Ident)
+			right, rightOK := initial.Rhs[0].(*ast.Ident)
+			if !leftOK || !rightOK || left.Name != "chunk" || right.Name != "start" {
+				t.Fatal("source chunks cropped the beginning of a batch")
+			}
+			condition, ok := loop.Cond.(*ast.BinaryExpr)
+			if !ok || condition.Op != token.LSS {
+				t.Fatal("source chunks lost their complete batch boundary")
+			}
+			left, leftOK = condition.X.(*ast.Ident)
+			right, rightOK = condition.Y.(*ast.Ident)
+			if !leftOK || !rightOK || left.Name != "chunk" || right.Name != "end" {
+				t.Fatal("source chunks cropped the end of a batch")
+			}
+			captures := 0
+			ast.Inspect(loop.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if ok {
+					if helper, ok := call.Fun.(*ast.Ident); ok && helper.Name == "fixedLocalFreshAPIs" {
+						captures++
+					}
+				}
+				return true
+			})
+			if captures != 1 {
+				t.Fatal("each bounded source must retain all independently captured APIs", captures)
+			}
+			chunks++
+			return false
+		})
+	}
+	if chunks != 1 {
+		t.Fatal("complete conversion object owners still accumulate one unbounded API source", chunks)
+	}
+}
+
+func TestFixedLocalPackedPreparesLazyToolsBeforeSourceCapture(t *testing.T) {
+	fixedLocalRequirePreparedTools(t, "amd64_fixed_local_packed_matrix_test.go", "fixedLocalPackedActualObjects")
+}
+
+func fixedLocalRequirePreparedTools(t *testing.T, filename, helper string) {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", filename), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var prepared, captured []token.Pos
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != helper {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			name, ok := call.Fun.(*ast.Ident)
+			if !ok {
+				return true
+			}
+			switch name.Name {
+			case "fixedLocalConversionPrepareToolCache":
+				if len(call.Args) != 2 {
+					t.Fatal("tool preparation lost its actual fixture request")
+				}
+				for index, expected := range []string{"t", "request"} {
+					actual, ok := call.Args[index].(*ast.Ident)
+					if !ok || actual.Name != expected {
+						t.Fatal("tool preparation substituted its owner or environment")
+					}
+				}
+				prepared = append(prepared, call.Pos())
+			case "fixedLocalFreshAPIs":
+				// Each selected API now captures independently inside this
+				// owner; preparation still precedes every real capture.
+				captured = append(captured, call.Pos())
+			}
+			return true
+		})
+	}
+	if len(prepared) != 1 || len(captured) != 1 || prepared[0] >= captured[0] {
+		t.Fatal("lazy SDK tools must be built before the unchanged bounded source capture", prepared, captured)
+	}
+}
diff --git a/cmd/plan9asmtest/fixed_local_runtime_cache_partition_test.go b/cmd/plan9asmtest/fixed_local_runtime_cache_partition_test.go
new file mode 100644
index 000000000..878228466
--- /dev/null
+++ b/cmd/plan9asmtest/fixed_local_runtime_cache_partition_test.go
@@ -0,0 +1,14 @@
+package main
+
+import "testing"
+
+// Only immutable compiler artifacts may be shared. The existing dynamic
+// SharedCacheKeepsSourcesIndependent regression owns the package/observer
+// separation; these checks bind the wide runtime plan to that same setup.
+func TestFixedLocalPackedRuntimeCacheIsOwnedByTheWholeTarget(t *testing.T) {
+	fixedLocalRequireOwnedObjectCache(t, "amd64_fixed_local_packed_runtime_test.go", "fixedLocalPackedRuntimeAPIs")
+}
+
+func TestFixedLocalPackedRuntimePreparesLazyToolsBeforeSourceCapture(t *testing.T) {
+	fixedLocalRequirePreparedTools(t, "amd64_fixed_local_packed_runtime_test.go", "fixedLocalPackedRuntimeAPIs")
+}
diff --git a/cmd/plan9asmtest/heavy_object_callback_timeout_test.go b/cmd/plan9asmtest/heavy_object_callback_timeout_test.go
new file mode 100644
index 000000000..e2b2f6dca
--- /dev/null
+++ b/cmd/plan9asmtest/heavy_object_callback_timeout_test.go
@@ -0,0 +1,37 @@
+package main
+
+import "testing"
+
+func TestHeavyObjectSchedulingSeparatesCompleteCallbackAndScratchOwners(t *testing.T) {
+	// In race shard 31 these complete roots passed in 1380.06, 907.30 and
+	// 543.21 seconds, leaving too little of the unchanged one-hour budget
+	// for its ordinary roots. Preserve every API, case and object target.
+	witnesses := []string{
+		"TestGoX86NumericalReadRevokeDuringFinalSDKCallback",
+		"TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch07",
+		"TestARM64GPImmediateScratchCompleteObjects",
+	}
+	for _, flags := range [][]string{nil, {"-cover", "-covermode=atomic"}, {"-race"}} {
+		for _, count := range []int{32, 64} {
+			shards, err := partitionForFlags(witnesses, count, flags)
+			if err != nil {
+				t.Fatal(err)
+			}
+			seen := make(map[string]bool)
+			for index, roots := range shards {
+				if len(roots) > 1 {
+					t.Errorf("complete callback/scratch owners collide: flags=%v shards=%d owner=%d roots=%v", flags, count, index, roots)
+				}
+				for _, name := range roots {
+					if seen[name] {
+						t.Fatal("duplicate complete owner", name)
+					}
+					seen[name] = true
+				}
+			}
+			if len(seen) != len(witnesses) {
+				t.Fatal("scheduling dropped complete callback or scratch checks", flags, count)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/heavy_object_partition_test.go b/cmd/plan9asmtest/heavy_object_partition_test.go
new file mode 100644
index 000000000..3c702c5a4
--- /dev/null
+++ b/cmd/plan9asmtest/heavy_object_partition_test.go
@@ -0,0 +1,239 @@
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// Independent complete source domains, not names copied from the scheduler.
+// Runtime, source-observation, API and object checks remain in their owners.
+func heavyObjectSourceFamilies(t *testing.T) map[string]string {
+	t.Helper()
+	want := make(map[string]string)
+	for _, family := range []struct {
+		file, prefix string
+		targets      []string
+		batches      int
+	}{
+		{"amd64_fixed_local_conversion_test.go", "TestGoAMD64FixedLocalConversionActualObjects", []string{"Linux", "Darwin", "Windows"}, 12},
+		{"amd64_fixed_local_packed_matrix_test.go", "TestGoAMD64FixedLocalPackedCompleteFormsActualObjects", []string{"Linux", "Darwin", "Windows"}, 4},
+		{"amd64_cmov_fixed_local_test.go", "TestX86CMOVFamilyFixedLocalAUTOActualObjects", []string{"Linux", "Darwin"}, 6},
+		{"amd64_fixed_local_data_matrix_go127_test.go", "TestGoAMD64FixedLocalReadonlyData", []string{"Linux", "Darwin", "Windows"}, 0},
+		{"amd64_fixed_local_packed_runtime_test.go", "TestGoAMD64FixedLocalPackedWideRuntimeOracle", []string{"", "Module", "GoModule"}, -1},
+		{"amd64_fixed_local_packed_native_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWide", []string{""}, 6},
+		{"amd64_fixed_local_conversion_runtime_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNative", []string{""}, 7},
+	} {
+		expected := make(map[string]bool)
+		for _, target := range family.targets {
+			if family.batches > 0 {
+				for batch := 0; batch < family.batches; batch++ {
+					expected[fmt.Sprintf("%s%sBatch%02d", family.prefix, target, batch)] = true
+				}
+			} else {
+				suffix := "RegisteredConsumers"
+				if family.batches == -1 {
+					suffix = "CompileOnly"
+				}
+				expected[family.prefix+target+suffix] = true
+			}
+		}
+		syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join("..", "..", family.file), nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := make(map[string]bool)
+		for _, declaration := range syntax.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || !strings.HasPrefix(function.Name.Name, family.prefix) {
+				continue
+			}
+			name := function.Name.Name
+			if family.batches == 0 && !strings.HasSuffix(name, "RegisteredConsumers") {
+				continue
+			}
+			if !expected[name] || found[name] || function.Body == nil {
+				t.Fatal("unknown, duplicate or incomplete heavy source owner", family.file, name)
+			}
+			found[name] = true
+			want[name] = family.prefix
+		}
+		if !reflect.DeepEqual(found, expected) {
+			t.Fatal("complete heavy source family changed", family.file, found, expected)
+		}
+	}
+	for _, owner := range []struct{ file, name string }{
+		{"go_x86_numerical_read_revocation_final_go127_test.go", "TestGoX86NumericalReadRevokeDuringFinalSDKCallback"},
+		{"arm64_gp_immediate_runtime_test.go", "TestARM64GPImmediateScratchCompleteObjects"},
+	} {
+		syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join("..", "..", owner.file), nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := 0
+		for _, declaration := range syntax.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if ok && function.Name.Name == owner.name && function.Body != nil {
+				found++
+			}
+		}
+		if found != 1 {
+			t.Fatal("missing complete callback or scratch source owner", owner.file, owner.name, found)
+		}
+		want[owner.name] = owner.name
+	}
+	if len(want) != 81 {
+		t.Fatal("complete independent heavy object denominator changed", len(want))
+	}
+	return want
+}
+
+func heavyObjectNames(families map[string]string) []string {
+	names := make([]string, 0, len(families))
+	for name := range families {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	return names
+}
+
+func independentHashShard(name string, count int) int {
+	hash := sha256.Sum256([]byte(name))
+	return int(binary.BigEndian.Uint64(hash[:8]) % uint64(count))
+}
+
+func heavyObjectOwners(t *testing.T, names []string, count int) ([][]string, map[string]int) {
+	t.Helper()
+	shards, err := partitionForFlags(names, count, []string{"-race"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	owners := make(map[string]int)
+	for index, shard := range shards {
+		if !sort.StringsAreSorted(shard) {
+			t.Fatal("noncanonical shard order", index)
+		}
+		for _, name := range shard {
+			if _, exists := owners[name]; exists {
+				t.Fatal("duplicate complete root owner", name)
+			}
+			owners[name] = index
+		}
+	}
+	if len(owners) != len(names) {
+		t.Fatal("scheduler reduced the complete inventory", count, len(owners), len(names))
+	}
+	for _, name := range names {
+		if _, found := owners[name]; !found {
+			t.Fatal("missing complete root", name)
+		}
+	}
+	return shards, owners
+}
+
+func TestHeavyObjectSchedulingIndependentClosedSourceFamilies(t *testing.T) {
+	heavyObjectSourceFamilies(t)
+}
+
+func TestHeavyObjectSchedulingPreventsCrossFamilyBudgetCollision(t *testing.T) {
+	families := heavyObjectSourceFamilies(t)
+	names := heavyObjectNames(families)
+	// The first CI failure completed these four independent owners in 2725.57
+	// seconds before exhausting the unchanged 3600-second whole-shard limit.
+	// Its reported missing packed-shift root had never started.
+	for _, name := range []string{
+		"TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch01",
+		"TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch00",
+		"TestGoAMD64FixedLocalConversionActualObjectsDarwinBatch09",
+		"TestGoAMD64FixedLocalReadonlyDataLinuxRegisteredConsumers",
+	} {
+		if _, found := families[name]; !found || independentHashShard(name, 32) != 5 {
+			t.Fatal("independent original hash-collision witness changed", name)
+		}
+	}
+	for _, count := range []int{32, 64} {
+		shards, _ := heavyObjectOwners(t, names, count)
+		for index, roots := range shards {
+			conversion, readonly := 0, 0
+			for _, name := range roots {
+				if strings.HasPrefix(name, "TestGoAMD64FixedLocalConversionActualObjects") {
+					conversion++
+				}
+				if strings.HasPrefix(name, "TestGoAMD64FixedLocalReadonlyData") {
+					readonly++
+				}
+			}
+			if readonly > 0 && conversion > 1 {
+				t.Errorf("layout %d shard %d collocates complete readonly and repeated conversions: %v", count, index, roots)
+			}
+			if len(roots) > (len(names)+count-1)/count {
+				t.Errorf("layout %d shard %d accumulates heavy source families: %v", count, index, roots)
+			}
+		}
+	}
+}
+
+func TestHeavyObjectSchedulingStableCompleteLayouts(t *testing.T) {
+	names := heavyObjectNames(heavyObjectSourceFamilies(t))
+	for count := 1; count <= 1024; count++ {
+		shards, owners := heavyObjectOwners(t, names, count)
+		for index, shard := range shards {
+			if len(shard) < len(names)/count || len(shard) > (len(names)+count-1)/count {
+				t.Fatalf("complete heavy family imbalance: layout=%d shard=%d count=%d", count, index, len(shard))
+			}
+		}
+		reversed := append([]string(nil), names...)
+		for left, right := 0, len(reversed)-1; left < right; left, right = left+1, right-1 {
+			reversed[left], reversed[right] = reversed[right], reversed[left]
+		}
+		_, reordered := heavyObjectOwners(t, reversed, count)
+		if !reflect.DeepEqual(owners, reordered) {
+			t.Fatal("heavy ownership depends on input order", count)
+		}
+		extended := append(append([]string(nil), names...), "TestOrdinaryInsertedBefore", "ExampleOrdinary", "FuzzOrdinary")
+		_, extendedOwners := heavyObjectOwners(t, extended, count)
+		for _, name := range names {
+			_, single := heavyObjectOwners(t, []string{name}, count)
+			if owners[name] != extendedOwners[name] || owners[name] != single[name] {
+				t.Fatal("heavy ownership depends on unrelated roots or a filtered inventory", count, name)
+			}
+		}
+		for _, name := range extended[len(names):] {
+			if extendedOwners[name] != independentHashShard(name, count) {
+				t.Fatal("ordinary root lost its original hash role", count, name)
+			}
+		}
+	}
+}
+
+func TestHeavyObjectSchedulingOrdinaryNeighborNamesKeepHashOwnership(t *testing.T) {
+	for _, count := range []int{1, 7, 32, 64, 1024} {
+		for _, name := range []string{
+			"TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch12",
+			"TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch000",
+			"TestX86CMOVFamilyFixedLocalAUTOActualObjectsWindowsBatch00",
+			"TestGoAMD64FixedLocalReadonlyDataLinuxRegisteredConsumersExtra",
+			"TestGoAMD64FixedLocalPackedWideRuntimeOracleUnknownCompileOnly",
+			"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWide",
+			"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch06",
+			"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch000",
+			"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch07",
+			"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch000",
+			"TestGoX86NumericalReadRevokeDuringFinalSDKCallbackExtra",
+			"TestARM64GPImmediateScratchCompleteObjectsExtra",
+		} {
+			_, owners := heavyObjectOwners(t, []string{name}, count)
+			if owners[name] != independentHashShard(name, count) {
+				t.Fatal("a neighboring spelling borrowed another complete family's scheduling role", count, name)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/heavy_object_plain_timeout_test.go b/cmd/plan9asmtest/heavy_object_plain_timeout_test.go
new file mode 100644
index 000000000..5c8c714d9
--- /dev/null
+++ b/cmd/plan9asmtest/heavy_object_plain_timeout_test.go
@@ -0,0 +1,48 @@
+package main
+
+import "testing"
+
+func TestHeavyObjectSchedulingPlainAndCoverageBudgetCollision(t *testing.T) {
+	families := heavyObjectSourceFamilies(t)
+	names := heavyObjectNames(families)
+	// These completed roots consumed 2251.41 seconds in one plain Go 1.20
+	// shard before its unchanged 2700-second deadline. The active min/max
+	// root had run for under a minute; missing later roots had never started.
+	witnesses := []string{
+		"TestGoAMD64FixedLocalConversionActualObjectsLinuxBatch00",
+		"TestGoAMD64FixedLocalConversionActualObjectsWindowsBatch10",
+		"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch03",
+		"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch02",
+		"TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsDarwinBatch01",
+		"TestGoAMD64FixedLocalPackedCompleteFormsActualObjectsWindowsBatch02",
+		"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch05",
+	}
+	for _, name := range witnesses {
+		if _, found := families[name]; !found || independentHashShard(name, 32) != 20 {
+			t.Fatal("original plain-shard collision witness changed", name)
+		}
+	}
+	for _, flags := range [][]string{nil, {"-cover", "-covermode=atomic"}, {"-race=false"}, {"-race"}} {
+		for _, count := range []int{32, 64} {
+			shards, err := partitionForFlags(names, count, flags)
+			if err != nil {
+				t.Fatal(err)
+			}
+			seen := make(map[string]bool)
+			for index, roots := range shards {
+				if len(roots) < len(names)/count || len(roots) > (len(names)+count-1)/count {
+					t.Errorf("complete heavy families collide: flags=%v shards=%d owner=%d roots=%v", flags, count, index, roots)
+				}
+				for _, name := range roots {
+					if seen[name] {
+						t.Fatal("duplicate source owner", name)
+					}
+					seen[name] = true
+				}
+			}
+			if len(seen) != len(names) {
+				t.Fatal("scheduling dropped complete sources", flags, count)
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/heavy_object_race_scope_test.go b/cmd/plan9asmtest/heavy_object_race_scope_test.go
new file mode 100644
index 000000000..9868174dd
--- /dev/null
+++ b/cmd/plan9asmtest/heavy_object_race_scope_test.go
@@ -0,0 +1,93 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestHeavyObjectSchedulingInstrumentationIndependent(t *testing.T) {
+	names := heavyObjectNames(heavyObjectSourceFamilies(t))
+	names = append(names, "TestOrdinaryBefore", "TestOrdinaryAfter")
+	for count := 1; count <= 1024; count++ {
+		plain, err := partition(names, count)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, shard := range plain {
+			for _, name := range shard {
+				if (name == "TestOrdinaryBefore" || name == "TestOrdinaryAfter") && index != independentHashShard(name, count) {
+					t.Fatalf("default layout changed ordinary hash: shards=%d root=%s", count, name)
+				}
+			}
+		}
+		for _, flags := range [][]string{
+			nil,
+			{"-cover", "-covermode=atomic"},
+			{"-tags=byollvm", "-p=2"}, // Existing Windows build context.
+			{"-race=false"},
+			{"-race", "-race=false"},
+			{"-race=true", "-race=false"},
+			{"-race"},
+			{"-race=false", "-race=true"},
+			{"-tags", "-race"},
+			{"-gcflags", "-race"},
+			{"-ldflags=-race"},
+		} {
+			actual, err := partitionForFlags(names, count, flags)
+			if err != nil || !reflect.DeepEqual(actual, plain) {
+				t.Fatalf("instrumentation flags changed complete ownership: shards=%d flags=%v err=%v", count, flags, err)
+			}
+		}
+	}
+}
+
+func TestHeavyObjectRaceScopeExplicitFlagsKeepCompleteBalancedOwners(t *testing.T) {
+	names := heavyObjectNames(heavyObjectSourceFamilies(t))
+	for count := 1; count <= 1024; count++ {
+		var first [][]string
+		for _, flags := range [][]string{
+			{"-race"},
+			{"-race=true"},
+			{"-race=false", "-race"},
+			{"-race=false", "-race=true"},
+			{"-tags", "-race=false", "-race", "-covermode=atomic"},
+		} {
+			actual, err := partitionForFlags(names, count, flags)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if first == nil {
+				first = actual
+			} else if !reflect.DeepEqual(actual, first) {
+				t.Fatalf("equivalent effective race flags changed ownership: %d %v", count, flags)
+			}
+			seen := make(map[string]bool)
+			for _, shard := range actual {
+				if len(shard) < len(names)/count || len(shard) > (len(names)+count-1)/count {
+					t.Fatalf("complete race family is not balanced: %d %v", count, flags)
+				}
+				for _, name := range shard {
+					if seen[name] {
+						t.Fatal("duplicate race object owner", name)
+					}
+					seen[name] = true
+				}
+			}
+			if len(seen) != len(names) {
+				t.Fatal("race layout lost complete roots", count)
+			}
+		}
+	}
+}
+
+func TestHeavyObjectRaceScopeRejectsUnvalidatedSelectors(t *testing.T) {
+	names := heavyObjectNames(heavyObjectSourceFamilies(t))
+	for _, flags := range [][]string{
+		{"-race=TRUE"}, {"-race=1"}, {"-race="}, {"--race"},
+		{"-run=TestOne"}, {"-tags"}, {"-unknown=-race"},
+	} {
+		if _, err := partitionForFlags(names, 64, flags); err == nil {
+			t.Fatal("invalid/unrecordable selector reached scheduling", flags)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/inventory.go b/cmd/plan9asmtest/inventory.go
new file mode 100644
index 000000000..082db29ba
--- /dev/null
+++ b/cmd/plan9asmtest/inventory.go
@@ -0,0 +1,195 @@
+package main
+
+import (
+	"bufio"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"go/token"
+	"regexp"
+	"regexp/syntax"
+	"sort"
+	"strings"
+)
+
+func validName(name string) bool {
+	return token.IsIdentifier(name) && (strings.HasPrefix(name, "Test") || strings.HasPrefix(name, "Example") || strings.HasPrefix(name, "Fuzz"))
+}
+
+var listFooter = regexp.MustCompile(`^ok[ \t]+([^ \t]+)[ \t]+[0-9]+(?:\.[0-9]+)?s(?:[ \t]+(?:\[no tests to run\]|coverage: (?:[0-9]+(?:\.[0-9]+)?% of statements(?: in .+)?|\[no statements\])))?$`)
+
+// go test -list lists top-level tests/examples/fuzz targets, not dynamic
+// subtests or seeds. The execution validator also checks every emitted child.
+func parseList(data string) (string, []string, []string, error) {
+	return parseSuiteList(data, false, false)
+}
+
+var noTestsFooter = regexp.MustCompile(`^\?[ \t]+([^ \t]+)[ \t]+\[no test files\]$`)
+var noTestsCoverageFooter = regexp.MustCompile(`^\t([^ \t]+)\t\tcoverage: (?:[0-9]+(?:\.[0-9]+)?% of statements(?: in .+)?|\[no statements\])$`)
+
+func parseSuiteList(data string, allowEmpty, noTestFiles bool) (string, []string, []string, error) {
+	var pkg string
+	var names []string
+	var benchmarks []string
+	seen := make(map[string]bool)
+	for _, line := range strings.Split(strings.TrimSuffix(data, "\n"), "\n") {
+		line = strings.TrimSuffix(line, "\r")
+		if pkg != "" {
+			return "", nil, nil, fmt.Errorf("output after inventory footer: %q", line)
+		}
+		if allowEmpty && noTestFiles {
+			fields := noTestsFooter.FindStringSubmatch(line)
+			if fields == nil {
+				fields = noTestsCoverageFooter.FindStringSubmatch(line)
+			}
+			if fields != nil {
+				pkg = fields[1]
+				continue
+			}
+		}
+		if strings.HasPrefix(line, "ok\t") || strings.HasPrefix(line, "ok ") {
+			fields := listFooter.FindStringSubmatch(line)
+			if fields == nil {
+				return "", nil, nil, fmt.Errorf("invalid inventory footer: %q", line)
+			}
+			pkg = fields[1]
+			continue
+		}
+		benchmark := token.IsIdentifier(line) && strings.HasPrefix(line, "Benchmark")
+		if !validName(line) && !benchmark || seen[line] {
+			return "", nil, nil, fmt.Errorf("invalid/duplicate listed test: %q", line)
+		}
+		seen[line] = true
+		if benchmark {
+			benchmarks = append(benchmarks, line)
+		} else {
+			names = append(names, line)
+		}
+	}
+	if pkg == "" || len(names) == 0 && !allowEmpty || noTestFiles && len(names)+len(benchmarks) != 0 {
+		return "", nil, nil, fmt.Errorf("empty inventory or missing successful package footer")
+	}
+	sort.Strings(names)
+	sort.Strings(benchmarks)
+	return pkg, names, benchmarks, nil
+}
+
+// The execution and both independent receipt readers pass their recorded
+// instrumentation flags through this boundary.
+func partitionForFlags(names []string, count int, flags []string) ([][]string, error) {
+	_, _, err := validateFlags(flags)
+	if err != nil {
+		return nil, err
+	}
+	return partition(names, count)
+}
+
+func partition(names []string, count int) ([][]string, error) {
+	if len(names) == 0 || count < 1 || count > 1024 {
+		return nil, fmt.Errorf("nonempty inventory and 1..1024 shards required")
+	}
+	shards := make([][]string, count)
+	objectOwners := completeObjectFamilyOwners(count)
+	seen := make(map[string]bool)
+	for _, name := range names {
+		if !validName(name) || seen[name] {
+			return nil, fmt.Errorf("invalid/duplicate planned test: %q", name)
+		}
+		seen[name] = true
+		hash := sha256.Sum256([]byte(name))
+		index := binary.BigEndian.Uint64(hash[:8]) % uint64(count)
+		if owner, exists := objectOwners[name]; exists {
+			index = uint64(owner)
+		}
+		shards[index] = append(shards[index], name)
+	}
+	for _, shard := range shards {
+		sort.Strings(shard)
+	}
+	return shards, nil
+}
+
+func runPattern(names []string) (string, error) {
+	quoted := make([]string, len(names))
+	for i, name := range names {
+		quoted[i] = regexp.QuoteMeta(name)
+	}
+	pattern := "^(" + strings.Join(quoted, "|") + ")$"
+	if len(pattern) > 16000 {
+		// Factor the same finite literal union with Go's own regexp parser.
+		// Keep short selectors unchanged; sort a copy for deterministic output.
+		sort.Strings(quoted)
+		expression, err := syntax.Parse("^("+strings.Join(quoted, "|")+")$", syntax.Perl)
+		if err != nil {
+			return "", fmt.Errorf("factor exact run pattern: %w", err)
+		}
+		pattern = expression.Simplify().String()
+	}
+	// Conservative even on Unix: never truncate a regex to fit a platform's
+	// command-line limit. Irreducible unions still require more shards.
+	if len(names) == 0 || len(pattern) > 16000 {
+		return "", fmt.Errorf("empty/oversized exact run pattern (%d bytes); increase -shards", len(pattern))
+	}
+	return pattern, nil
+}
+
+// Only build/instrumentation flags are forwarded. Test filters, repeats,
+// fuzzing, custom executors and arbitrary test arguments change this protocol.
+func runnerBooleanFlag(name string) bool {
+	switch name {
+	case "race", "cover", "trimpath", "asan", "msan", "work":
+		return true
+	}
+	return false
+}
+
+func validateFlags(args []string) ([]string, string, error) {
+	valueFlags := map[string]bool{"covermode": true, "coverpkg": true, "tags": true, "p": true, "gcflags": true, "asmflags": true, "ldflags": true, "mod": true, "modfile": true, "overlay": true}
+	var forwarded []string
+	var profile string
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		if !strings.HasPrefix(arg, "-") || strings.HasPrefix(arg, "--") {
+			return nil, "", fmt.Errorf("only supported Go flags are allowed: %q", arg)
+		}
+		name, value, hasValue := strings.Cut(strings.TrimPrefix(arg, "-"), "=")
+		if runnerBooleanFlag(name) {
+			if hasValue && value != "true" && value != "false" {
+				return nil, "", fmt.Errorf("invalid boolean flag %q", arg)
+			}
+			forwarded = append(forwarded, arg)
+			continue
+		}
+		if !valueFlags[name] && name != "coverprofile" {
+			return nil, "", fmt.Errorf("scope-changing/unknown Go flag %q", arg)
+		}
+		if !hasValue {
+			i++
+			if i == len(args) {
+				return nil, "", fmt.Errorf("missing value for %q", arg)
+			}
+			value = args[i]
+		}
+		if value == "" {
+			return nil, "", fmt.Errorf("empty value for %q", arg)
+		}
+		if name == "coverprofile" {
+			if profile != "" {
+				return nil, "", fmt.Errorf("duplicate coverage destination")
+			}
+			profile = value
+			continue
+		}
+		forwarded = append(forwarded, arg)
+		if !hasValue {
+			forwarded = append(forwarded, value)
+		}
+	}
+	return forwarded, profile, nil
+}
+
+func largeScanner(reader interface{ Read([]byte) (int, error) }) *bufio.Scanner {
+	scanner := bufio.NewScanner(reader)
+	scanner.Buffer(make([]byte, 4096), 4<<20)
+	return scanner
+}
diff --git a/cmd/plan9asmtest/inventory_pattern_test.go b/cmd/plan9asmtest/inventory_pattern_test.go
new file mode 100644
index 000000000..59051ae2a
--- /dev/null
+++ b/cmd/plan9asmtest/inventory_pattern_test.go
@@ -0,0 +1,69 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestRunPatternCompactsExactInventory(t *testing.T) {
+	prefix := "TestGoAMD64FixedLocal" + strings.Repeat("CompleteOriginalSource", 3)
+	names := []string{prefix, "Example", "FuzzSeeds", "TestUnicode_世界", "TestUnicode_世代"}
+	for index := 0; index < 240; index++ {
+		names = append(names, fmt.Sprintf("%sFamily%03d", prefix, index))
+	}
+	if len(strings.Join(names, "|")) <= 16000 {
+		t.Fatal("fixture no longer reproduces the CI argument bound")
+	}
+	original := append([]string(nil), names...)
+	pattern, err := runPattern(names)
+	if err != nil || len(pattern) > 16000 {
+		t.Fatalf("complete exact inventory did not fit without changing shards: %d bytes, %v", len(pattern), err)
+	}
+	if !reflect.DeepEqual(names, original) {
+		t.Fatal("pattern construction changed the ordered inventory")
+	}
+	matcher, err := regexp.Compile(pattern)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := make(map[string]bool, len(names))
+	for _, name := range names {
+		want[name] = true
+	}
+	// Test every retained root and anchored truncation/extension mutations.
+	// A shorter root may itself be selected; membership decides the oracle.
+	for _, name := range names {
+		for _, candidate := range []string{name, name + "Missing", "Extra" + name, name + "\n", name[:len(name)-1]} {
+			if got := matcher.MatchString(candidate); got != want[candidate] {
+				t.Fatalf("selector membership for %q: got %v, want %v", candidate, got, want[candidate])
+			}
+		}
+	}
+	for _, absent := range []string{"", prefix + "Family240", prefix + "Family999", "TestUnicode_世", "TestUnicode_世界代"} {
+		if matcher.MatchString(absent) {
+			t.Fatalf("factoring invented a root: %q", absent)
+		}
+	}
+	for left, right := 0, len(names)-1; left < right; left, right = left+1, right-1 {
+		names[left], names[right] = names[right], names[left]
+	}
+	reversed, err := runPattern(names)
+	if err != nil || reversed != pattern {
+		t.Fatal("oversized inventory factoring is not deterministic", err)
+	}
+}
+
+func TestRunPatternRetainsSmallSelectorsAndArgumentLimit(t *testing.T) {
+	pattern, err := runPattern([]string{"TestB", "TestA", "Example"})
+	if err != nil || pattern != "^(TestB|TestA|Example)$" {
+		t.Fatal("ordinary selector changed", pattern, err)
+	}
+	for _, names := range [][]string{nil, {"Test" + strings.Repeat("A", 16001)}} {
+		if pattern, err := runPattern(names); err == nil || pattern != "" {
+			t.Fatal("empty or irreducibly oversized selector was admitted", len(pattern), err)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/inventory_pattern_unix_test.go b/cmd/plan9asmtest/inventory_pattern_unix_test.go
new file mode 100644
index 000000000..8be42217a
--- /dev/null
+++ b/cmd/plan9asmtest/inventory_pattern_unix_test.go
@@ -0,0 +1,40 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestActualGoCompactedPatternRetainsEveryShardRoot(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	var source strings.Builder
+	source.WriteString("package fixture\nimport \"testing\"\n")
+	prefix := "TestGoAMD64FixedLocal" + strings.Repeat("CompleteOriginalSource", 3)
+	const count = 480
+	for index := 0; index < count; index++ {
+		fmt.Fprintf(&source, "func %sFamily%03d(t *testing.T) { t.Run(\"child\",func(t *testing.T){}) }\n", prefix, index)
+	}
+	directory := fixture(t, source.String())
+	out := filepath.Join(t.TempDir(), "receipts")
+	err := runSuite(context.Background(), config{Go: "go", Dir: directory, Package: ".",
+		Out: out, Shards: 2, Timeout: time.Minute, Flags: []string{"-p=1"}})
+	if err != nil {
+		t.Fatal("actual Go rejected the exact factored selector", err)
+	}
+	report := readReport(t, out)
+	if report.Status != "passed" || len(report.Names) != count || report.RootPassed != count ||
+		report.ChildPassed != count || report.RootFailed != 0 || report.RootSkipped != 0 || report.RootMissing != 0 {
+		t.Fatalf("compressed selection lost actual roots or child outcomes: %+v", report)
+	}
+	for _, shard := range report.Shards {
+		if len(strings.Join(shard.Names, "|")) <= 16000 || shard.Status != "passed" {
+			t.Fatal("each actual shard must exercise exact selector factoring", shard.Status, len(shard.Names))
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/main.go b/cmd/plan9asmtest/main.go
new file mode 100644
index 000000000..53307a28f
--- /dev/null
+++ b/cmd/plan9asmtest/main.go
@@ -0,0 +1,56 @@
+// plan9asmtest exhaustively runs actual Go package or main-module inventories.
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"time"
+)
+
+func main() {
+	var cfg config
+	flag.StringVar(&cfg.Go, "go", "go", "Go executable")
+	flag.StringVar(&cfg.Dir, "dir", ".", "package working directory")
+	flag.StringVar(&cfg.Package, "package", ".", "one package, not a recursive pattern")
+	flag.StringVar(&cfg.Out, "out", "_out/root-suite", "new, nonexisting artifact directory")
+	flag.IntVar(&cfg.Shards, "shards", 32, "stable exhaustive partitions")
+	flag.IntVar(&cfg.Workers, "workers", 1, "bounded ordinary-suite parallelism (1..32, no more than shards)")
+	flag.DurationVar(&cfg.Timeout, "timeout", 45*time.Minute, "per-command wall deadline and Go test timeout")
+	flag.StringVar(&cfg.CISelector, "ci-selector", "", "explicit selected-CI root inventory (ordinary mode remains exhaustive)")
+	flag.IntVar(&cfg.CIOwner, "ci-owner", -1, "one selected-CI owner; every owned root runs separately")
+	flag.StringVar(&cfg.CIIsolate, "ci-isolate-root", "", "selected root exclusively assigned to owner zero")
+	flag.StringVar(&cfg.CIVerify, "verify-ci-partitions", "", "strictly verify all selected-CI owner artifacts against fresh actual inventory")
+	flag.BoolVar(&cfg.Module, "module", false, "exhaustive ./... main-module inventory; partition root, profile and SDK frontend")
+	flag.IntVar(&cfg.ModuleOwner, "module-owner", -1, "optional module scheduling owner: 0=root, 1=profile and SDK frontend, 2=all remaining packages")
+	flag.StringVar(&cfg.ModuleVerify, "verify-module", "", "verify complete module artifacts against fresh source/tool/package observations")
+	flag.IntVar(&cfg.ModuleRootPartitions, "module-root-partitions", 1, "exhaustive root shard scheduling parts; module owners only")
+	flag.IntVar(&cfg.ModuleRootPartition, "module-root-partition", -1, "one root-only scheduling part; partial execution is not complete module success")
+	flag.Parse()
+	cfg.Flags = flag.Args()
+	if err := validateModuleRootScheduling(cfg); err != nil {
+		fmt.Fprintln(os.Stderr, "plan9asmtest:", err)
+		os.Exit(1)
+	}
+	if cfg.Workers < 1 || cfg.Workers > 32 || cfg.Workers > cfg.Shards {
+		fmt.Fprintln(os.Stderr, "plan9asmtest: workers must be 1..32 and no more than shards")
+		os.Exit(1)
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), cancellationSignals()...)
+	defer stop()
+	var err error
+	if cfg.Module || cfg.ModuleVerify != "" || cfg.ModuleOwner != -1 {
+		err = runModule(ctx, cfg)
+	} else if cfg.CISelector != "" || cfg.CIIsolate != "" || cfg.CIOwner != -1 || cfg.CIVerify != "" {
+		err = runCI(ctx, cfg)
+	} else {
+		err = runSuite(ctx, cfg)
+	}
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "plan9asmtest:", err)
+		os.Exit(1)
+	}
+}
diff --git a/cmd/plan9asmtest/main_test.go b/cmd/plan9asmtest/main_test.go
new file mode 100644
index 000000000..6cac7262c
--- /dev/null
+++ b/cmd/plan9asmtest/main_test.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestInventoryIsActualCompleteAndCanonical(t *testing.T) {
+	const listing = "TestZ\nFuzzSeeds\nExample\nTestA\nBenchmarkIgnored\nok\texample.org/root\t0.003s\n"
+	pkg, names, benchmarks, err := parseList(listing)
+	if err != nil || pkg != "example.org/root" || !reflect.DeepEqual(names, []string{"Example", "FuzzSeeds", "TestA", "TestZ"}) || !reflect.DeepEqual(benchmarks, []string{"BenchmarkIgnored"}) {
+		t.Fatalf("actual inventory: %q %v %v", pkg, names, err)
+	}
+
+	for _, bad := range []string{
+		"", "ok\texample.org/root\t0.003s\n", "TestA\n", "TestA\nTestA\nok\tp\t0s\n",
+		"BenchmarkA\nok\tp\t0s\n", "TestA\nFAIL\tp\t0s\n",
+		"TestA\nok\tp\t0s\nTestB\n", "TestA\nok\tp\t0s\nok\tq\t0s\n",
+		"TestA/sub\nok\tp\t0s\n", "TestA\nunknown diagnostic\nok\tp\t0s\n",
+		"TestA\nok\tp\tgarbage\n", "TestA\nok\tp\t0s trailing corruption\n",
+	} {
+		if _, _, _, err := parseList(bad); err == nil {
+			t.Errorf("accepted damaged/empty inventory %q", bad)
+		}
+	}
+
+	first, err := partition(names, 7)
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := partition([]string{"TestZ", "TestA", "FuzzSeeds", "Example"}, 7)
+	if err != nil || !reflect.DeepEqual(first, second) {
+		t.Fatalf("unstable hash partition: %v %v %v", first, second, err)
+	}
+	seen := make(map[string]int)
+	for _, shard := range first {
+		for _, name := range shard {
+			seen[name]++
+		}
+	}
+	if len(seen) != len(names) {
+		t.Fatalf("partition lost inventory: %v", first)
+	}
+	for _, name := range names {
+		if seen[name] != 1 {
+			t.Fatalf("partition duplicates/omits %s: %v", name, first)
+		}
+	}
+	for _, bad := range [][]string{nil, {"TestA", "TestA"}, {"TestA", "not-a-test"}} {
+		if _, err := partition(bad, 7); err == nil {
+			t.Errorf("partition accepted invalid plan %v", bad)
+		}
+	}
+	if _, err := partition(names, 0); err == nil {
+		t.Fatal("accepted zero shards")
+	}
+}
+
+func events(actions ...string) string {
+	var out strings.Builder
+	for _, action := range actions {
+		fields := strings.SplitN(action, " ", 2)
+		event := map[string]string{"Action": fields[0], "Package": "p"}
+		if len(fields) == 2 {
+			event["Test"] = fields[1]
+		}
+		data, _ := json.Marshal(event)
+		out.Write(data)
+		out.WriteByte('\n')
+	}
+	return out.String()
+}
+
+func TestJSONExactlyMatchesPlanIncludingFuzzSeedsAndSubtests(t *testing.T) {
+	good := events("start", "run TestA", "run TestA/sub", "pass TestA/sub", "pass TestA", "run FuzzSeeds", "run FuzzSeeds/seed#0", "pass FuzzSeeds/seed#0", "pass FuzzSeeds", "run Example", "pass Example", "pass")
+	outcomes, err := validateEvents(strings.NewReader(good), "p", []string{"Example", "FuzzSeeds", "TestA"})
+	if err != nil || len(outcomes) != 5 || outcomes["FuzzSeeds/seed#0"] != "pass" {
+		t.Fatalf("lost actual seed/subtest execution: %v %v", outcomes, err)
+	}
+	for _, bad := range []string{
+		"", good + "{", strings.Replace(good, "\"Package\":\"p\"", "\"Package\":\"q\"", 1),
+		events("start", "run TestA", "pass TestA", "output TestA", "pass"),
+		events("start", "run TestA", "run TestA", "pass TestA", "pass"),
+		events("start", "run TestA", "pass TestA", "pass TestA", "pass"),
+		events("start", "pass TestA", "pass"),
+		events("start", "run TestA", "run TestA/sub", "pass TestA", "pass"),
+		events("start", "run TestUnknown", "pass TestUnknown", "pass"),
+		events("start", "run TestA", "fail TestA", "pass"),
+		events("start", "run TestA", "pass TestA", "fail"),
+		events("start", "run TestA", "pass TestA"),
+		events("start", "run TestA", "pass TestA", "pass", "pass"),
+		events("start", "run TestA", "unknown TestA", "pass"),
+	} {
+		if _, err := validateEvents(strings.NewReader(bad), "p", []string{"TestA"}); err == nil {
+			t.Errorf("accepted incomplete/corrupt JSON %q", bad)
+		}
+	}
+	if _, err := runPattern([]string{strings.Repeat("a", 16001)}); err == nil {
+		t.Fatal("oversized Windows-safe regex silently accepted")
+	}
+	if _, err := validateEvents(strings.NewReader(events("start", "run TestA", "pass TestA", "pass")), "p", []string{"TestA", "Example"}); err == nil {
+		t.Fatal("accepted omitted planned example")
+	}
+	if states, err := validateEvents(strings.NewReader(events("start", "run TestA", "skip TestA", "pass")), "p", []string{"TestA"}); err != nil || states["TestA"] != "skip" {
+		t.Fatalf("must retain existing Go skip distinctly: %v %v", states, err)
+	}
+	// Slashes may be part of one Go subtest name, not a real intermediate
+	// parent. Do not invent missing-parent failures from string spelling.
+	if _, err := validateEvents(strings.NewReader(events("start", "run TestA", "run TestA/path/leaf", "pass TestA/path/leaf", "pass TestA", "pass")), "p", []string{"TestA"}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSelectionAndFuzzingFlagsCannotReduceInventory(t *testing.T) {
+	for _, flag := range []string{"-run=TestA", "-skip=TestA", "-list=.", "-fuzz=FuzzA", "-bench=.", "-count=2", "-exec=echo", "-c", "-args", "./..."} {
+		if _, _, err := validateFlags([]string{flag}); err == nil {
+			t.Errorf("accepted scope-changing flag %q", flag)
+		}
+	}
+	args := []string{"-race", "-covermode=atomic", "-coverpkg=./...", "-tags", "fixture", "-p=1", "-coverprofile=coverage.out"}
+	got, profile, err := validateFlags(args)
+	if err != nil || profile != "coverage.out" || !reflect.DeepEqual(got, args[:len(args)-1]) {
+		t.Fatalf("lost instrumentation/build flags: %v %q %v", got, profile, err)
+	}
+}
+
+func TestCoverageMergeRetainsExactBlocksAndCounters(t *testing.T) {
+	write := func(name, data string) string {
+		t.Helper()
+		path := filepath.Join(t.TempDir(), name)
+		if err := os.WriteFile(path, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+		return path
+	}
+	a := write("a", "mode: atomic\np/a.go:1.1,2.1 2 3\np/a.go:3.1,4.1 1 0\n")
+	b := write("b", "mode: atomic\np/a.go:3.1,4.1 1 2\np/a.go:1.1,2.1 2 4\n")
+	merged, err := mergeCoverage([]string{a, b})
+	if err != nil || string(merged) != "mode: atomic\np/a.go:1.1,2.1 2 7\np/a.go:3.1,4.1 1 2\n" {
+		t.Fatalf("coverage merge: %q %v", merged, err)
+	}
+	for _, bad := range []string{
+		"mode: set\np/a.go:1.1,2.1 2 1\np/a.go:3.1,4.1 1 1\n",
+		"mode: atomic\np/a.go:1.1,2.1 2 1\n",
+		"mode: atomic\np/a.go:1.1,2.1 3 1\np/a.go:3.1,4.1 1 1\n",
+		"mode: atomic\np/a.go:1.1,2.1 2 1\np/a.go:1.1,2.1 2 1\n",
+		"mode: atomic\np/a.go:1.1,2.1 2 18446744073709551615\np/a.go:3.1,4.1 1 1\n",
+		"mode: atomic\np/a.go:1.1,2.1 2 -1\np/a.go:3.1,4.1 1 1\n",
+	} {
+		if _, err := mergeCoverage([]string{a, write("bad", bad)}); err == nil {
+			t.Errorf("accepted damaged/incompatible coverage %q", bad)
+		}
+	}
+}
+
+func TestCoverageSetModeAndZeroStatementBlocks(t *testing.T) {
+	dir := t.TempDir()
+	a, b := filepath.Join(dir, "a"), filepath.Join(dir, "b")
+	for _, path := range []string{a, b} {
+		if err := os.WriteFile(path, []byte("mode: set\np/a.go:1.1,1.1 0 1\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	merged, err := mergeCoverage([]string{a, b})
+	if err != nil || string(merged) != "mode: set\np/a.go:1.1,1.1 0 1\n" {
+		t.Fatalf("set counters must OR, not add: %q %v", merged, err)
+	}
+}
diff --git a/cmd/plan9asmtest/minmax_partition_test.go b/cmd/plan9asmtest/minmax_partition_test.go
new file mode 100644
index 000000000..2405ae769
--- /dev/null
+++ b/cmd/plan9asmtest/minmax_partition_test.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestNativeMinMaxFamiliesOccupyIndependentRootShards(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join("..", "..", "arm64_scalar_minmax_state_test.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var roots []string
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && strings.HasPrefix(function.Name.Name, "TestARM64ScalarMinMaxNative") {
+			roots = append(roots, function.Name.Name)
+		}
+	}
+	if len(roots) != 4 {
+		t.Fatal("native runtime lost its four exhaustive family owners", roots)
+	}
+	shards, err := partition(roots, 32)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, roots := range shards {
+		if len(roots) > 1 {
+			t.Fatalf("expensive native families share shard %d: %v", index+1, roots)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/module.go b/cmd/plan9asmtest/module.go
new file mode 100644
index 000000000..c200bdd72
--- /dev/null
+++ b/cmd/plan9asmtest/module.go
@@ -0,0 +1,369 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const moduleProtocol = "actual_go_complete_module_v1"
+const moduleRootPartsProtocol = "actual_go_complete_module_root_parts_v2"
+const moduleOwners = 3
+
+type modulePackage struct {
+	Package     string `json:"package"`
+	Directory   string `json:"directory"`
+	NoTestFiles bool   `json:"no_test_files"`
+}
+
+type moduleResult struct {
+	Package      string `json:"package"`
+	Shards       int    `json:"shards"`
+	Workers      int    `json:"workers"`
+	Status       string `json:"status"`
+	Error        string `json:"error,omitempty"`
+	RootSkipped  int    `json:"root_skipped"`
+	ChildSkipped int    `json:"subtests_seeds_skipped"`
+	// Only populated by this invocation's complete raw-artifact verifier.
+	// Serialized summaries cannot supply coverage inputs to a later reader.
+	rootCoverage []string
+}
+
+type moduleReport struct {
+	Protocol       string               `json:"protocol"`
+	Go             string               `json:"go_executable"`
+	Directory      string               `json:"request_directory"`
+	Flags          []string             `json:"go_flags"`
+	Coverage       string               `json:"coverage_destination"`
+	Timeout        string               `json:"command_timeout"`
+	Shards         int                  `json:"partition_count"`
+	Workers        int                  `json:"workers"`
+	Owner          int                  `json:"owner"`
+	RootPartitions int                  `json:"root_partition_count,omitempty"`
+	RootPartition  *int                 `json:"root_partition_index,omitempty"`
+	RootInventory  *moduleRootInventory `json:"fresh_root_inventory,omitempty"`
+	Scope          ciScope              `json:"scope"`
+	Inventory      []modulePackage      `json:"full_package_inventory"`
+	Packages       []moduleResult       `json:"packages"`
+	Status         string               `json:"status"`
+	Error          string               `json:"error,omitempty"`
+}
+
+// Build-selection flags are identical to test. Coverage is test instrumentation,
+// not package selection; go list does not accept covermode/coverpkg.
+func moduleListFlags(flags []string) []string {
+	var out []string
+	for i := 0; i < len(flags); i++ {
+		name, _, value := strings.Cut(strings.TrimPrefix(flags[i], "-"), "=")
+		if name == "cover" || name == "covermode" || name == "coverpkg" {
+			if !value && name != "cover" {
+				i++
+			}
+			continue
+		}
+		out = append(out, flags[i])
+	}
+	return out
+}
+
+func readModulePackages(data []byte, dir string) ([]modulePackage, error) {
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	var packages []modulePackage
+	seen := map[string]bool{}
+	modulePath := ""
+	for {
+		var pkg struct {
+			ImportPath, Dir           string
+			TestGoFiles, XTestGoFiles []string
+			Error                     json.RawMessage
+			DepsErrors                []json.RawMessage
+			Module                    *struct {
+				Path, Dir, GoMod string
+				Main             bool
+			}
+		}
+		err := decoder.Decode(&pkg)
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		if pkg.Module == nil || !pkg.Module.Main || pkg.Error != nil || len(pkg.DepsErrors) != 0 ||
+			pkg.Module.Dir != dir || pkg.Module.GoMod != filepath.Join(dir, "go.mod") ||
+			pkg.ImportPath == "" || seen[pkg.ImportPath] {
+			return nil, fmt.Errorf("invalid/foreign/duplicate actual module package: %s", pkg.ImportPath)
+		}
+		if modulePath == "" {
+			modulePath = pkg.Module.Path
+		}
+		if pkg.Module.Path != modulePath || pkg.ImportPath != modulePath && !strings.HasPrefix(pkg.ImportPath, modulePath+"/") {
+			return nil, fmt.Errorf("actual package is outside selected main module")
+		}
+		relative, err := filepath.Rel(dir, pkg.Dir)
+		if err != nil || relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
+			return nil, fmt.Errorf("actual package directory escapes main module")
+		}
+		seen[pkg.ImportPath] = true
+		packages = append(packages, modulePackage{pkg.ImportPath, filepath.ToSlash(relative), len(pkg.TestGoFiles)+len(pkg.XTestGoFiles) == 0})
+	}
+	if len(packages) == 0 {
+		return nil, fmt.Errorf("empty actual module package inventory")
+	}
+	sort.Slice(packages, func(i, j int) bool { return packages[i].Package < packages[j].Package })
+	return packages, nil
+}
+
+func observeModulePackages(ctx context.Context, cfg config, stem string) ([]modulePackage, error) {
+	flags, _, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return nil, err
+	}
+	args := append([]string{"list"}, moduleListFlags(flags)...)
+	args = append(args, "-json", "./...")
+	if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, args, stem); err != nil {
+		return nil, fmt.Errorf("actual complete module package list: %w", err)
+	}
+	data, err := os.ReadFile(stem + ".stdout")
+	if err != nil {
+		return nil, err
+	}
+	return readModulePackages(data, cfg.Dir)
+}
+
+// These are scheduling roles, not package admissions. Every actual package is
+// owned once, including any future package which joins the rest owner.
+func moduleOwner(pkg modulePackage) int {
+	if pkg.Directory == "." {
+		return 0
+	}
+	if pkg.Directory == "gotoolprofile" || pkg.Directory == "internal/sdkfrontend" {
+		return 1
+	}
+	return 2
+}
+
+func modulePackageConfig(cfg config, pkg modulePackage, index int) config {
+	child := cfg
+	child.Package = pkg.Package
+	child.Out = filepath.Join(cfg.Out, fmt.Sprintf("package-%04d", index))
+	child.fullPackage = moduleOwner(pkg) == 2 || pkg.NoTestFiles
+	child.noTestFiles = pkg.NoTestFiles
+	if pkg.Directory == "." && cfg.ModuleRootPartitions > 1 && cfg.ModuleOwner == 0 {
+		child.rootPart = &moduleRootPart{moduleRootFragmentProtocol, cfg.ModuleRootPartition, cfg.ModuleRootPartitions}
+	}
+	if child.fullPackage {
+		child.Shards, child.Workers = 1, 1
+	}
+	flags, profile, _ := validateFlags(cfg.Flags)
+	child.Flags = flags
+	if profile != "" {
+		name := "package.cover"
+		if child.rootPart != nil {
+			name = "partition.cover"
+		}
+		child.Flags = append(child.Flags, "-coverprofile="+filepath.Join(child.Out, name))
+	}
+	return child
+}
+
+func runModule(ctx context.Context, cfg config) error {
+	// Preserve existing internal zero-value callers; the CLI has explicit
+	// defaults and checks its requested values before dispatch.
+	if cfg.ModuleRootPartitions == 0 && cfg.ModuleRootPartition == 0 {
+		cfg.ModuleRootPartitions, cfg.ModuleRootPartition = 1, -1
+	}
+	if err := validateModuleRootScheduling(cfg); err != nil {
+		return err
+	}
+	if !cfg.Module || cfg.Package != "." || cfg.CISelector != "" || cfg.CIIsolate != "" || cfg.CIVerify != "" || cfg.CIOwner != -1 ||
+		cfg.Timeout <= 0 || cfg.Shards < 1 || cfg.Shards > 1024 || cfg.Workers < 1 || cfg.Workers > 32 || cfg.Workers > cfg.Shards ||
+		cfg.ModuleOwner < -1 || cfg.ModuleOwner >= moduleOwners {
+		return fmt.Errorf("module mode requires exhaustive '.', valid bounded scheduling and no selected-CI options")
+	}
+	if err := validateRunnerGoFlags(runtime.GOOS, os.Getenv("GOFLAGS"), cfg.Flags); err != nil {
+		return err
+	}
+	if cfg.ModuleVerify != "" && cfg.ModuleOwner != -1 {
+		return fmt.Errorf("module aggregate cannot also execute an owner")
+	}
+	flags, coverage, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return err
+	}
+	for _, flag := range flags {
+		name, _, _ := strings.Cut(flag, "=")
+		switch name {
+		case "-overlay", "-modfile", "-gcflags", "-asmflags", "-ldflags":
+			return fmt.Errorf("module external compiler inputs are not source-indexed: %s", name)
+		}
+	}
+	cfg.Go, err = exec.LookPath(cfg.Go)
+	if err != nil {
+		return err
+	}
+	cfg.Go, err = filepath.Abs(cfg.Go)
+	if err != nil {
+		return err
+	}
+	cfg.Dir, err = filepath.Abs(cfg.Dir)
+	if err != nil {
+		return err
+	}
+	cfg.Dir, err = sourcepath.Resolve(cfg.Dir)
+	if err != nil {
+		return err
+	}
+	cfg.Out, err = filepath.Abs(cfg.Out)
+	if err != nil {
+		return err
+	}
+	if coverage != "" && (cfg.ModuleOwner == -1 || cfg.ModuleVerify != "") {
+		destination := moduleCoverageDestination(cfg, coverage)
+		if _, err := os.Lstat(destination); !os.IsNotExist(err) {
+			return fmt.Errorf("module coverage destination must not exist: %v", err)
+		}
+	}
+	if err := os.Mkdir(cfg.Out, 0755); err != nil {
+		return err
+	}
+	report := moduleReport{Protocol: moduleProtocol, Go: cfg.Go, Directory: cfg.Dir, Flags: flags, Coverage: coverage,
+		Timeout: cfg.Timeout.String(), Shards: cfg.Shards, Workers: cfg.Workers, Owner: cfg.ModuleOwner, Status: "failed"}
+	if cfg.ModuleRootPartitions > 1 {
+		report.Protocol, report.RootPartitions = moduleRootPartsProtocol, cfg.ModuleRootPartitions
+		if cfg.ModuleOwner == 0 {
+			part := cfg.ModuleRootPartition
+			report.RootPartition = &part
+		}
+	}
+	finish := func(cause error) error {
+		if cause != nil {
+			report.Error = cause.Error()
+		}
+		return errors.Join(cause, ciWriteJSON(filepath.Join(cfg.Out, "module.json"), report))
+	}
+	report.Scope, err = captureCIScope(ctx, cfg, filepath.Join(cfg.Out, "before"))
+	if err != nil {
+		return finish(err)
+	}
+	report.Inventory, err = observeModulePackages(ctx, cfg, filepath.Join(cfg.Out, "packages-before"))
+	if err != nil {
+		return finish(err)
+	}
+	if cfg.ModuleVerify != "" {
+		if report.RootPartitions > 1 {
+			report.RootInventory, err = observeModuleRootInventory(ctx, cfg, report.Inventory)
+			if err != nil {
+				return finish(err)
+			}
+		}
+		report.Packages, err = checkedModuleArtifacts(report, cfg.ModuleVerify)
+		if err != nil && report.RootPartitions == 0 {
+			return finish(err)
+		}
+	} else if cfg.ModuleOwner == 2 {
+		err = runModuleOtherPackages(ctx, cfg, &report)
+	} else {
+		var failures []error
+		for i, pkg := range report.Inventory {
+			if cfg.ModuleOwner != -1 && moduleOwner(pkg) != cfg.ModuleOwner {
+				continue
+			}
+			result, packageErr := runModulePackage(ctx, cfg, pkg, i)
+			failures = append(failures, packageErr)
+			report.Packages = append(report.Packages, result)
+			if err := ciWriteJSON(filepath.Join(cfg.Out, "module.json"), report); err != nil {
+				failures = append(failures, err)
+			}
+		}
+		err = errors.Join(failures...)
+	}
+	postPackages, packagesErr := observeModulePackages(ctx, cfg, filepath.Join(cfg.Out, "packages-after"))
+	postScope, scopeErr := captureCIScope(ctx, cfg, filepath.Join(cfg.Out, "after"))
+	if packagesErr != nil || scopeErr != nil || !reflect.DeepEqual(postPackages, report.Inventory) || !reflect.DeepEqual(postScope, report.Scope) {
+		err = errors.Join(err, packagesErr, scopeErr, fmt.Errorf("complete module/source/SDK/tools/environment changed"))
+	}
+	if cfg.ModuleVerify == "" {
+		// Aggregate from the independent actual list and raw events even when
+		// execution failed. Report success is never a substitute for terminals.
+		err = errors.Join(err, verifyModuleOwner(report, cfg.Out))
+	}
+	if err != nil {
+		return finish(err)
+	}
+	if cfg.ModuleVerify != "" && coverage != "" {
+		if err := writeVerifiedModuleCoverage(report, cfg.ModuleVerify, cfg.Out, moduleCoverageDestination(cfg, coverage)); err != nil {
+			return finish(err)
+		}
+	} else if coverage != "" && len(report.Packages) != 0 && report.RootPartition == nil {
+		profile := filepath.Join(cfg.Out, "owner.cover")
+		if cfg.ModuleOwner == -1 {
+			profile = moduleCoverageDestination(cfg, coverage)
+		}
+		if err := writeModuleCoverage(report, cfg.Out, profile); err != nil {
+			return finish(err)
+		}
+	}
+	report.Status = moduleCompletionStatus(report)
+	return finish(nil)
+}
+
+func runModulePackage(ctx context.Context, cfg config, pkg modulePackage, index int) (moduleResult, error) {
+	child := modulePackageConfig(cfg, pkg, index)
+	result := moduleResult{Package: pkg.Package, Shards: child.Shards, Workers: child.Workers, Status: "passed"}
+	var failures []error
+	if err := runSuite(ctx, child); err != nil {
+		result.Status, result.Error = "failed", err.Error()
+		failures = append(failures, fmt.Errorf("package %s: %w", pkg.Package, err))
+	}
+	var suite suiteReport
+	if err := ciReadJSON(filepath.Join(child.Out, suiteReportName(child)), &suite); err != nil {
+		result.Status, result.Error = "failed", errors.Join(errors.New(result.Error), err).Error()
+		failures = append(failures, err)
+	} else {
+		result.RootSkipped, result.ChildSkipped = suite.RootSkipped, suite.ChildSkipped
+		result.Shards, result.Workers = len(suite.Shards), suite.Workers
+		if result.Status == "passed" && child.rootPart != nil {
+			result.Status = suiteCompletionStatus(suite)
+		}
+	}
+	return result, errors.Join(failures...)
+}
+
+func moduleCompletionStatus(report moduleReport) string {
+	status := "passed"
+	if report.RootPartition != nil {
+		status = "completed_owned"
+		if len(report.Packages) == 1 && report.Packages[0].Status == "completed_empty" {
+			status = "completed_empty"
+		}
+	}
+	for _, pkg := range report.Packages {
+		if pkg.RootSkipped != 0 || pkg.ChildSkipped != 0 {
+			if report.RootPartition != nil {
+				return status + "_with_skips"
+			}
+			return "completed_with_skips"
+		}
+	}
+	return status
+}
+
+func moduleCoverageDestination(cfg config, coverage string) string {
+	if filepath.IsAbs(coverage) {
+		return coverage
+	}
+	return filepath.Join(cfg.Dir, coverage)
+}
diff --git a/cmd/plan9asmtest/module_cli_unix_test.go b/cmd/plan9asmtest/module_cli_unix_test.go
new file mode 100644
index 000000000..74bc88d8b
--- /dev/null
+++ b/cmd/plan9asmtest/module_cli_unix_test.go
@@ -0,0 +1,171 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// This is an actual multi-package Go module, not a script impersonating Go.
+// The nested module must not enter the main module's ./... inventory.
+func moduleFixture(t *testing.T, failing bool) string {
+	t.Helper()
+	dir := t.TempDir()
+	files := map[string]string{
+		"go.mod":   "module example.org/modulefixture\n\ngo 1.20\n",
+		"value.go": "package fixture\nfunc Value() int { return 7 }\n",
+		"value_test.go": `package fixture
+import (
+    "fmt"
+    "testing"
+)
+func TestAlpha(t *testing.T) { t.Run("child", func(t *testing.T) { if Value() != 7 { t.Fatal("value") } }) }
+func TestWorkerOne(t *testing.T) { if Value() != 7 { t.Fatal("value") } }
+func ExampleValue() { fmt.Println(Value()); /* Output: 7 */ }
+func FuzzValue(f *testing.F) { f.Add(1); f.Fuzz(func(t *testing.T, n int) { if Value() != 7 { t.Fatal(n) } }) }
+`,
+		"gotoolprofile/value.go": "package profile\nfunc Value() int { return 9 }\n",
+		"gotoolprofile/value_test.go": `package profile
+import "testing"
+func TestAlpha(t *testing.T) { if Value() != 9 { t.Fatal("value") } }
+func TestWorkerOne(t *testing.T) { if Value() != 9 { t.Fatal("value") } }
+`,
+		"internal/other/value.go": "package other\nfunc Value() int { return 11 }\n",
+		"internal/other/value_test.go": `package other
+import "testing"
+func TestCompletePackage(t *testing.T) { if Value() != 11 { t.Fatal("value") } }
+`,
+		"bench/value.go": "package bench\nfunc Value() int { return 13 }\n",
+		"bench/value_test.go": `package bench
+import "testing"
+func BenchmarkNotExecuted(b *testing.B) { b.Fatal("benchmark ran") }
+`,
+		"empty/value.go":       "package empty\nfunc Value() int { return 17 }\n",
+		"nested/go.mod":        "module example.org/nested\n\ngo 1.20\n",
+		"nested/value_test.go": "package nested\nimport \"testing\"\nfunc TestExcluded(t *testing.T) { t.Fatal(\"nested role is separate\") }\n",
+	}
+	if failing {
+		files["value_test.go"] += "\nfunc TestActualFailure(t *testing.T) { t.Fatal(\"sticky original failure\") }\n"
+	}
+	for name, source := range files {
+		path := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func moduleFixtureEnvironment(t *testing.T) {
+	t.Helper()
+	t.Setenv("GOFLAGS", "")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+}
+
+func runModuleFixtureCLI(t *testing.T, failing bool) (string, string, error) {
+	t.Helper()
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleFixture(t, failing)
+	out := filepath.Join(t.TempDir(), "module")
+	profile := filepath.Join(filepath.Dir(out), "module.cover")
+	stem := filepath.Join(t.TempDir(), "cli")
+	_, err := captureCommand(context.Background(), 5*time.Minute, ".", binary,
+		[]string{"-module", "-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--",
+			"-race", "-covermode=atomic", "-coverprofile=" + profile, "-p=2"}, stem)
+	return dir, out, errorsWithActualOutput(err, stem)
+}
+
+func errorsWithActualOutput(err error, stem string) error {
+	if err == nil {
+		return nil
+	}
+	stderr, _ := os.ReadFile(stem + ".stderr")
+	return fmt.Errorf("%w\n%s", err, stderr)
+}
+
+func TestModuleCLIActualInventoryAndAllPackageCoverage(t *testing.T) {
+	_, out, err := runModuleFixtureCLI(t, false)
+	if err != nil {
+		t.Fatalf("actual exhaustive module CLI: %v", err)
+	}
+	var report struct {
+		Status   string `json:"status"`
+		Packages []struct {
+			Package string `json:"package"`
+			Status  string `json:"status"`
+			Shards  int    `json:"shards"`
+			Workers int    `json:"workers"`
+		} `json:"packages"`
+	}
+	data, err := os.ReadFile(filepath.Join(out, "module.json"))
+	if err != nil || json.Unmarshal(data, &report) != nil || report.Status != "passed" || len(report.Packages) != 5 {
+		t.Fatalf("complete actual module denominator: %s (%v)", data, err)
+	}
+	for _, pkg := range report.Packages {
+		partitioned := pkg.Package == "example.org/modulefixture" || strings.HasSuffix(pkg.Package, "/gotoolprofile")
+		if pkg.Status != "passed" || partitioned && (pkg.Shards != 2 || pkg.Workers != 2) ||
+			!partitioned && (pkg.Shards != 1 || pkg.Workers != 1) {
+			t.Fatalf("package role or complete execution changed: %+v", pkg)
+		}
+	}
+	coverage, err := os.ReadFile(filepath.Join(filepath.Dir(out), "module.cover"))
+	if err != nil || !strings.HasPrefix(string(coverage), "mode: atomic\n") {
+		t.Fatalf("actual module-wide coverage absent: %v\n%s", err, coverage)
+	}
+	for _, name := range []string{"modulefixture/value.go:", "modulefixture/gotoolprofile/value.go:", "modulefixture/internal/other/value.go:", "modulefixture/bench/value.go:"} {
+		if !strings.Contains(string(coverage), name) {
+			t.Errorf("coverage silently became root-only or lost a test-bearing package: %s\n%s", name, coverage)
+		}
+	}
+}
+
+func TestModuleCLIFailureRetainsLaterCompletePackages(t *testing.T) {
+	_, out, err := runModuleFixtureCLI(t, true)
+	if err == nil || !strings.Contains(err.Error(), "package example.org/modulefixture:") {
+		t.Fatalf("actual source failure cause missing: %v", err)
+	}
+	files, globErr := filepath.Glob(filepath.Join(out, "package-0000", "shard-*.stdout"))
+	failureObserved := false
+	for _, path := range files {
+		data, readErr := os.ReadFile(path)
+		if readErr != nil {
+			t.Fatal(readErr)
+		}
+		failureObserved = failureObserved || strings.Contains(string(data), "sticky original failure")
+	}
+	if globErr != nil || !failureObserved {
+		t.Fatalf("actual original source diagnostic lost: %v", globErr)
+	}
+	data, readErr := os.ReadFile(filepath.Join(out, "module.json"))
+	var report struct {
+		Status   string `json:"status"`
+		Packages []struct {
+			Package string `json:"package"`
+			Status  string `json:"status"`
+		} `json:"packages"`
+	}
+	if readErr != nil || json.Unmarshal(data, &report) != nil || report.Status != "failed" || len(report.Packages) != 5 {
+		t.Fatalf("failure lost the complete package plan: %s (%v)", data, readErr)
+	}
+	for _, pkg := range report.Packages {
+		if pkg.Package != "example.org/modulefixture" && pkg.Status != "passed" {
+			t.Errorf("sticky failure prevented another complete package: %+v", pkg)
+		}
+	}
+	if _, err := os.Lstat(filepath.Join(filepath.Dir(out), "module.cover")); !os.IsNotExist(err) {
+		t.Fatalf("failed module published uploadable merged coverage: %v", err)
+	}
+}
diff --git a/cmd/plan9asmtest/module_dependencies.go b/cmd/plan9asmtest/module_dependencies.go
new file mode 100644
index 000000000..875c3216e
--- /dev/null
+++ b/cmd/plan9asmtest/module_dependencies.go
@@ -0,0 +1,476 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+var ciLLVM22Version = regexp.MustCompile(`(?im)(?:\bLLVM|\bclang) version 22(?:\.|$)|\bLLD 22(?:\.|$)`)
+var ciNodeVersion = regexp.MustCompile(`^v[0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?\r?\n$`)
+
+func validateModuleNodeEnvironment(process map[string]string) error {
+	for _, key := range []string{"NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA"} {
+		value, present := process[key]
+		if !present {
+			return fmt.Errorf("required Node environment observation %s missing", key)
+		}
+		if value != "" {
+			return fmt.Errorf("unmodeled nonempty Node consumer environment %s", key)
+		}
+	}
+	return nil
+}
+
+func moduleDependencyCommand(ctx context.Context, cfg config, stem, executable string, args ...string) ([]byte, error) {
+	if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, executable, args, stem); err != nil {
+		return nil, err
+	}
+	info, err := os.Stat(stem + ".stdout")
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+		return nil, fmt.Errorf("bounded dependency observation required: %v", err)
+	}
+	return os.ReadFile(stem + ".stdout")
+}
+
+// Match the root oracle's real separate-LLD search order. A configured compiler
+// never falls back; LLD is separately packaged and independently version checked.
+func moduleWASMLinkerCandidates(bindir string) []string {
+	return []string{filepath.Join(bindir, "wasm-ld"), "wasm-ld-22", "wasm-ld",
+		filepath.Join("/opt/homebrew/opt/lld@22/bin", "wasm-ld"),
+		filepath.Join("/usr/local/opt/lld@22/bin", "wasm-ld")}
+}
+
+func moduleWASMRuntimeFiles(root string) (map[string]string, error) {
+	for _, directory := range []string{"lib", "misc"} {
+		files := map[string]string{}
+		for _, name := range []string{"wasm_exec.js", "wasm_exec_node.js"} {
+			path := filepath.Join(root, directory, "wasm", name)
+			info, err := os.Stat(path)
+			if err != nil || !info.Mode().IsRegular() {
+				break
+			}
+			files["sdk-wasm/"+name] = path
+		}
+		if len(files) == 2 {
+			return files, nil
+		}
+	}
+	return nil, fmt.Errorf("selected Go SDK lacks required lib/misc wasm runtime JavaScript files")
+}
+
+func moduleSharedLibraries(data []byte) ([]string, error) {
+	files := strings.Fields(string(data))
+	if len(files) == 0 || len(files) > 32 || len(data) > 64<<10 {
+		return nil, fmt.Errorf("bounded actual LLVM shared-library list required")
+	}
+	seen := map[string]bool{}
+	for _, file := range files {
+		if !ciAbsolutePath(file) || seen[filepath.FromSlash(file)] || strings.ContainsAny(file, "\"'") {
+			return nil, fmt.Errorf("invalid/duplicate actual LLVM shared-library origin")
+		}
+		seen[filepath.FromSlash(file)] = true
+	}
+	return files, nil
+}
+
+func captureCINodeDependency(ctx context.Context, cfg config, stem string, origins map[string]string) error {
+	process := map[string]string{}
+	for _, key := range []string{"NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA"} {
+		process[key] = os.Getenv(key)
+	}
+	if err := validateModuleNodeEnvironment(process); err != nil {
+		return err
+	}
+	node, err := exec.LookPath("node")
+	if err != nil {
+		return fmt.Errorf("required module node runtime: %w", err)
+	}
+	origins["node"], err = filepath.Abs(node)
+	if err != nil {
+		return err
+	}
+	version, err := moduleDependencyCommand(ctx, cfg, stem+"-node-version", origins["node"], "--version")
+	if err != nil {
+		return fmt.Errorf("actual Node runtime: %w", err)
+	}
+	if !ciNodeVersion.Match(version) {
+		return fmt.Errorf("actual Node runtime returned an unregistered version observation")
+	}
+	return nil
+}
+
+func captureModuleDependencies(ctx context.Context, cfg config, stem string, environment, origins map[string]string) error {
+	if err := captureCINodeDependency(ctx, cfg, stem, origins); err != nil {
+		return err
+	}
+	bindirData, err := os.ReadFile(stem + "-llvm-configbindir.stdout")
+	if err != nil {
+		return err
+	}
+	for index, candidate := range moduleWASMLinkerCandidates(strings.TrimSpace(string(bindirData))) {
+		path, err := exec.LookPath(candidate)
+		if err != nil {
+			continue
+		}
+		versionConfig := cfg
+		if versionConfig.Timeout > 5*time.Second {
+			versionConfig.Timeout = 5 * time.Second
+		}
+		data, err := moduleDependencyCommand(ctx, versionConfig, fmt.Sprintf("%s-wasm-linker-%d", stem, index), path, "--version")
+		if err == nil && ciLLVM22Version.Match(data) {
+			origins["wasm-ld"], err = filepath.Abs(path)
+			if err != nil {
+				return err
+			}
+			if err := ciWriteJSON(stem+"-wasm-linker-selection.json", moduleLoadedLibrary{Index: index, Path: origins["wasm-ld"]}); err != nil {
+				return err
+			}
+			break
+		}
+	}
+	if origins["wasm-ld"] == "" {
+		return fmt.Errorf("required module LLVM 22 wasm-ld is unavailable")
+	}
+	runtimeFiles, err := moduleWASMRuntimeFiles(environment["GOROOT"])
+	if err != nil {
+		return err
+	}
+	for name, path := range runtimeFiles {
+		origins[name] = path
+	}
+	data, err := moduleDependencyCommand(ctx, cfg, stem+"-llvm-shared-files", origins["llvm-config"], "--libfiles", "--link-shared")
+	if err != nil {
+		return err
+	}
+	libraries, err := moduleSharedLibraries(data)
+	if err != nil {
+		return err
+	}
+	for index, path := range libraries {
+		origins[fmt.Sprintf("llvm-shared/%d", index)] = path
+	}
+	return captureModuleLLVMBinding(ctx, cfg, stem, libraries, origins)
+}
+
+type moduleLLVMPackage struct {
+	ImportPath, Dir                             string
+	GoFiles, CgoFiles, CFiles, CXXFiles, HFiles []string
+	Error                                       json.RawMessage
+	DepsErrors                                  []json.RawMessage
+}
+
+type moduleLoadedLibrary struct {
+	Index int    `json:"configured_library_index"`
+	Path  string `json:"actual_loaded_path"`
+	SHA   string `json:"actual_loaded_sha256,omitempty"`
+}
+
+func moduleLLVMBinding(data []byte) (*moduleLLVMPackage, error) {
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	var binding *moduleLLVMPackage
+	seen := map[string]bool{}
+	for {
+		var pkg moduleLLVMPackage
+		err := decoder.Decode(&pkg)
+		if err == io.EOF {
+			if len(seen) == 0 {
+				return nil, fmt.Errorf("complete actual dependency inventory is empty")
+			}
+			return binding, nil
+		}
+		if err != nil || pkg.Error != nil || len(pkg.DepsErrors) != 0 {
+			return nil, fmt.Errorf("actual complete Go dependency selection failed: %v", err)
+		}
+		if pkg.ImportPath == "" || seen[pkg.ImportPath] || len(seen) >= 20000 {
+			return nil, fmt.Errorf("missing/duplicate/unbounded actual Go dependency identity")
+		}
+		seen[pkg.ImportPath] = true
+		if pkg.ImportPath == "github.com/xgo-dev/llvm" {
+			if binding != nil || !filepath.IsAbs(pkg.Dir) || len(pkg.CgoFiles) == 0 {
+				return nil, fmt.Errorf("unique actual native Go LLVM binding required")
+			}
+			binding = &pkg
+		}
+	}
+}
+
+// This is an owned tool-dependency query, not a translated program. The selected
+// Go binding calls LLVMContextCreate; observe that same loader symbol using
+// dladdr or the Windows imported address, never a guessed library basename.
+const moduleLLVMLoaderProbe = `package main
+/*
+#ifdef _WIN32
+#include <stdint.h>
+#include <windows.h>
+// Explicit dllimport obtains the IAT target rather than MinGW's local thunk.
+__declspec(dllimport) void *LLVMContextCreate(void);
+static const char *loadedLLVM(void) {
+    HMODULE module;
+    if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+            (LPCWSTR)(uintptr_t)LLVMContextCreate, &module)) {
+        return 0;
+    }
+    WCHAR wide[32768];
+    DWORD length = GetModuleFileNameW(module, wide, 32768);
+    BOOL released = FreeLibrary(module);
+    if (!released || length == 0 || length >= 32768) {
+        return 0;
+    }
+    static char path[4 * 32768];
+    if (!WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, wide, -1,
+            path, sizeof(path), 0, 0)) {
+        return 0;
+    }
+    return path;
+}
+#else
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#cgo linux LDFLAGS: -ldl
+static const char *loadedLLVM(void) {
+    void *symbol = dlsym(RTLD_DEFAULT, "LLVMContextCreate");
+    Dl_info info;
+    if (symbol == 0 || dladdr(symbol, &info) == 0) {
+        return 0;
+    }
+    return info.dli_fname;
+}
+#endif
+*/
+import "C"
+import (
+    "fmt"
+    "os"
+    "github.com/xgo-dev/llvm"
+)
+func main() {
+    context := llvm.NewContext()
+    defer context.Dispose()
+    path := C.loadedLLVM()
+    if path == nil {
+        os.Exit(2)
+    }
+    fmt.Println(C.GoString(path))
+}
+`
+
+func captureModuleLLVMBinding(ctx context.Context, cfg config, stem string, libraries []string, origins map[string]string) error {
+	flags, _, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return err
+	}
+	args := append([]string{"list"}, moduleListFlags(flags)...)
+	args = append(args, "-deps", "-test", "-json", "./...")
+	data, err := moduleDependencyCommand(ctx, cfg, stem+"-llvm-go-packages", cfg.Go, args...)
+	if err != nil {
+		return err
+	}
+	binding, err := moduleLLVMBinding(data)
+	if err != nil || binding == nil {
+		return err // A first-party module without this consumer has no link probe.
+	}
+	files, err := moduleLLVMBindingFiles(binding)
+	if err != nil {
+		return err
+	}
+	for name, path := range files {
+		origins[name] = path
+	}
+	input, err := prepareModuleLLVMProbeSource(ctx, stem)
+	if err != nil {
+		return err
+	}
+	source, binary := input.source.Path, gotoolchain.HostExecutable(stem+"-llvm-loader")
+	if err := os.WriteFile(input.source.Artifact, []byte(moduleLLVMLoaderProbe), 0600); err != nil {
+		return err
+	}
+	origins["llvm-loader-source"] = source
+	args = append([]string{"build"}, moduleListFlags(flags)...)
+	args = append(args, "-o", binary, source)
+	if _, err := moduleDependencyCommand(ctx, cfg, stem+"-llvm-loader-build", cfg.Go, args...); err != nil {
+		return fmt.Errorf("actual Go LLVM loader query build: %w", err)
+	}
+	loaded, err := moduleDependencyCommand(ctx, cfg, stem+"-llvm-loader-run", binary)
+	if err != nil {
+		return fmt.Errorf("actual Go LLVM loader query: %w", err)
+	}
+	if err := input.verify(ctx); err != nil {
+		return err
+	}
+	if err := ciWriteJSON(stem+"-llvm-loader-source.json", input.source); err != nil {
+		return err
+	}
+	path := strings.TrimSuffix(string(loaded), "\n")
+	info, err := os.Stat(path)
+	if err != nil || !filepath.IsAbs(path) || strings.ContainsAny(path, "\x00\r\n") {
+		return fmt.Errorf("actual LLVM loaded-library path invalid: %v", err)
+	}
+	for index, library := range libraries {
+		candidate, err := os.Stat(library)
+		if err == nil && os.SameFile(info, candidate) {
+			hash, err := ciFileSHA(path)
+			if err != nil {
+				return err
+			}
+			origins["llvm-loaded"] = path
+			return ciWriteJSON(stem+"-llvm-loaded-library.json", moduleLoadedLibrary{Index: index, Path: path, SHA: hash})
+		}
+	}
+	return fmt.Errorf("actual Go LLVM binding loaded a different configured library")
+}
+
+func moduleLLVMBindingFiles(binding *moduleLLVMPackage) (map[string]string, error) {
+	origins := map[string]string{}
+	if binding == nil {
+		return origins, nil
+	}
+	files := append(append(append(append(append([]string{}, binding.GoFiles...), binding.CgoFiles...), binding.CFiles...), binding.CXXFiles...), binding.HFiles...)
+	for _, file := range files {
+		if file == "" || filepath.Base(file) != file || origins["llvm-binding/"+file] != "" || len(origins) >= 10000 {
+			return nil, fmt.Errorf("invalid/duplicate/unbounded selected LLVM binding source")
+		}
+		origins["llvm-binding/"+file] = filepath.Join(binding.Dir, file)
+	}
+	return origins, nil
+}
+
+func verifyModuleDependencyArtifacts(directory string, report moduleReport) error {
+	for _, phase := range []string{"before", "after"} {
+		stem := filepath.Join(directory, phase)
+		var origins, environment map[string]string
+		if err := ciReadJSON(stem+"-origins.json", &origins); err != nil {
+			return err
+		}
+		if err := ciReadJSON(stem+"-env.stdout", &environment); err != nil {
+			return err
+		}
+		var observation ciEnvironmentContext
+		if err := ciReadJSON(stem+"-environment-context.json", &observation); err != nil {
+			return err
+		}
+		if err := validateModuleNodeEnvironment(observation.Process); err != nil {
+			return err
+		}
+		for _, name := range []string{"node", "wasm-ld", "sdk-wasm/wasm_exec.js", "sdk-wasm/wasm_exec_node.js"} {
+			if origins[name] == "" || report.Scope.Tools[name] == "" {
+				return fmt.Errorf("required module dependency %s missing", name)
+			}
+		}
+		version, err := os.ReadFile(stem + "-node-version.stdout")
+		if err != nil || !ciNodeVersion.Match(version) {
+			return fmt.Errorf("actual Node version observation differs: %v", err)
+		}
+		var linker moduleLoadedLibrary
+		if err := ciReadJSON(stem+"-wasm-linker-selection.json", &linker); err != nil {
+			return err
+		}
+		version, err = os.ReadFile(fmt.Sprintf("%s-wasm-linker-%d.stdout", stem, linker.Index))
+		if err != nil || linker.Index < 0 || linker.Index >= len(moduleWASMLinkerCandidates("")) || linker.Path != origins["wasm-ld"] || !ciLLVM22Version.Match(version) {
+			return fmt.Errorf("actual LLVM 22 wasm linker observation differs: %v", err)
+		}
+		for _, name := range []string{"wasm_exec.js", "wasm_exec_node.js"} {
+			path := origins["sdk-wasm/"+name]
+			if path != filepath.Join(environment["GOROOT"], "lib", "wasm", name) && path != filepath.Join(environment["GOROOT"], "misc", "wasm", name) {
+				return fmt.Errorf("wasm runtime belongs to another selected SDK")
+			}
+		}
+		if filepath.Dir(origins["sdk-wasm/wasm_exec.js"]) != filepath.Dir(origins["sdk-wasm/wasm_exec_node.js"]) {
+			return fmt.Errorf("mixed Go wasm runtime directories")
+		}
+		data, err := os.ReadFile(stem + "-llvm-shared-files.stdout")
+		if err != nil {
+			return err
+		}
+		libraries, err := moduleSharedLibraries(data)
+		if err != nil {
+			return err
+		}
+		count := 0
+		for name := range origins {
+			if strings.HasPrefix(name, "llvm-shared/") {
+				count++
+			}
+		}
+		if count != len(libraries) {
+			return fmt.Errorf("LLVM shared-library denominator differs")
+		}
+		for index, library := range libraries {
+			key := fmt.Sprintf("llvm-shared/%d", index)
+			if origins[key] != library || report.Scope.Tools[key] == "" {
+				return fmt.Errorf("actual LLVM shared-library route differs")
+			}
+		}
+		data, err = os.ReadFile(stem + "-llvm-go-packages.stdout")
+		if err != nil {
+			return err
+		}
+		binding, err := moduleLLVMBinding(data)
+		if err != nil {
+			return err
+		}
+		files, err := moduleLLVMBindingFiles(binding)
+		if err != nil {
+			return err
+		}
+		count = 0
+		for name, path := range origins {
+			if strings.HasPrefix(name, "llvm-binding/") {
+				count++
+				if files[name] != path || report.Scope.Tools[name] == "" {
+					return fmt.Errorf("actual LLVM binding source route differs")
+				}
+			}
+		}
+		if count != len(files) {
+			return fmt.Errorf("actual LLVM binding source denominator differs")
+		}
+		if binding == nil {
+			if origins["llvm-loaded"] != "" || origins["llvm-loader-source"] != "" {
+				return fmt.Errorf("unconsumed Go LLVM loader origin")
+			}
+			continue
+		}
+		source, err := os.ReadFile(stem + "-llvm-loader.go")
+		if err != nil || string(source) != moduleLLVMLoaderProbe {
+			return fmt.Errorf("actual LLVM loader query source differs: %v", err)
+		}
+		var compiled moduleLLVMProbeSource
+		if err := ciReadJSON(stem+"-llvm-loader-source.json", &compiled); err != nil {
+			return err
+		}
+		if !filepath.IsAbs(compiled.Parent) || filepath.Clean(compiled.Parent) != compiled.Parent ||
+			compiled.Path != filepath.Join(compiled.Parent, ".llvm-loader-source", "main.go") ||
+			compiled.Artifact != filepath.Join(compiled.Parent, phase+"-llvm-loader.go") ||
+			origins["llvm-loader-source"] != compiled.Path || compiled.SHA != moduleLLVMProbeSHA(source) ||
+			report.Scope.Tools["llvm-loader-source"] != compiled.SHA {
+			return fmt.Errorf("actual LLVM compiled source role/byte identity differs")
+		}
+		var loaded moduleLoadedLibrary
+		if err := ciReadJSON(stem+"-llvm-loaded-library.json", &loaded); err != nil {
+			return err
+		}
+		data, err = os.ReadFile(stem + "-llvm-loader-run.stdout")
+		if err != nil || loaded.Index < 0 || loaded.Index >= len(libraries) || !filepath.IsAbs(loaded.Path) || string(data) != loaded.Path+"\n" {
+			return fmt.Errorf("actual Go LLVM loader observation differs: %v", err)
+		}
+		// Producer capture already proves SameFile on the actual loaded and
+		// configured files. These paths need not exist on an aggregate runner;
+		// retain its byte-bound observation and independently scoped tool hash.
+		configuredHash := report.Scope.Tools[fmt.Sprintf("llvm-shared/%d", loaded.Index)]
+		if len(loaded.SHA) != 64 || loaded.SHA != configuredHash || loaded.Path != origins["llvm-loaded"] || report.Scope.Tools["llvm-loaded"] != loaded.SHA {
+			return fmt.Errorf("actual Go LLVM loader byte identity differs")
+		}
+	}
+	return nil
+}
diff --git a/cmd/plan9asmtest/module_dependencies_portable_unix_test.go b/cmd/plan9asmtest/module_dependencies_portable_unix_test.go
new file mode 100644
index 000000000..fd5ff383e
--- /dev/null
+++ b/cmd/plan9asmtest/module_dependencies_portable_unix_test.go
@@ -0,0 +1,211 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestModuleActualDependencyArtifactsSurviveProducerOriginRemoval(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	configBinary := moduleFixtureLLVMConfig(t)
+	// llvm-config reports its physical relocatable prefix. Keep the fixture's
+	// own installation in that same namespace, including Darwin's /var alias.
+	producerRoot, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	producer := filepath.Join(producerRoot, "producer")
+	for _, directory := range []string{"bin", "lib"} {
+		if err := os.MkdirAll(filepath.Join(producer, directory), 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Copy only the real llvm-config bytes. Its actual relocatable-prefix
+	// query determines the library origins; no script impersonates a tool.
+	localConfig := filepath.Join(producer, "bin", "llvm-config")
+	if err := copyModuleFixtureTool(configBinary, localConfig); err != nil {
+		t.Fatal(err)
+	}
+	cfg := config{Go: goBinary, Module: true, Timeout: 2 * time.Minute}
+	cfg.Dir = moduleLLVMConsumerFixture(t)
+	out := t.TempDir()
+	data, err := moduleDependencyCommand(context.Background(), cfg, filepath.Join(out, "original-libraries"), configBinary, "--libfiles", "--link-shared")
+	if err != nil {
+		t.Fatal(err)
+	}
+	libraries, err := moduleSharedLibraries(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var hostLibraryDirectories []string
+	for _, library := range libraries {
+		if err := copyModuleFixtureTool(library, filepath.Join(producer, "lib", filepath.Base(library))); err != nil {
+			t.Fatal(err)
+		}
+		physical, err := filepath.EvalSymlinks(library)
+		if err != nil {
+			t.Fatal(err)
+		}
+		hostLibraryDirectories = append(hostLibraryDirectories, filepath.Dir(physical))
+		// The selected spelling and the library's actual loader filename may
+		// differ. Keep that alias entirely within the fixture's copied tree.
+		if filepath.Base(physical) != filepath.Base(library) {
+			if err := os.Symlink(filepath.Base(library), filepath.Join(producer, "lib", filepath.Base(physical))); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	bindir, err := moduleDependencyCommand(context.Background(), cfg, filepath.Join(out, "original-bindir"), configBinary, "--bindir")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range moduleFixtureRelocatedLLVMTools(os.Getenv("PLAN9ASM_CROSS_EXEC") == "1") {
+		if err := os.Symlink(filepath.Join(strings.TrimSpace(string(bindir)), name), filepath.Join(producer, "bin", name)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("LLVM_CONFIG", localConfig)
+	// Actual ELF SONAME/Mach-O install-name resolution must consume the copied
+	// library, not a same-byte host inode. These controls are already recorded
+	// completely by the ordinary module dependency producer and reader.
+	t.Setenv("LD_LIBRARY_PATH", filepath.Join(producer, "lib"))
+	t.Setenv("DYLD_LIBRARY_PATH", filepath.Join(producer, "lib"))
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") == "1" {
+		t.Run("reject-missing-required-llvm-tool", func(t *testing.T) {
+			tool := filepath.Join(producer, "bin", "ld.lld")
+			retired := tool + "-retired"
+			if err := os.Rename(tool, retired); err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := os.Rename(retired, tool); err != nil {
+					t.Error("restore exact fixture tool", err)
+				}
+			}()
+			_, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "missing-required-tool"))
+			if err == nil || !strings.Contains(err.Error(), "required runtime tool ld.lld:") {
+				t.Fatal("actual missing relocated LLVM tool did not retain its role rejection", err)
+			}
+			t.Logf("ACTUAL_MISSING_RELOCATED_LLVM_TOOL rejected=%q cause=%q", tool, err)
+		})
+	}
+	t.Run("reject-original-host-loader", func(t *testing.T) {
+		hostPath := strings.Join(hostLibraryDirectories, string(os.PathListSeparator))
+		t.Setenv("LD_LIBRARY_PATH", hostPath)
+		t.Setenv("DYLD_LIBRARY_PATH", hostPath)
+		_, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "host-loader"))
+		if err == nil || !strings.Contains(err.Error(), "actual Go LLVM binding loaded a different configured library") {
+			t.Fatal("real host loader did not retain its selected-inode rejection", err)
+		}
+	})
+	before, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "before"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	after, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "after"))
+	if err != nil || !reflect.DeepEqual(before, after) {
+		t.Fatal("unchanged actual relocated producer scope", err)
+	}
+	report := moduleReport{Scope: before}
+	if err := verifyModuleDependencyArtifacts(out, report); err != nil {
+		t.Fatal("actual producer control", err)
+	}
+	var origins map[string]string
+	if err := ciReadJSON(filepath.Join(out, "before-origins.json"), &origins); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual relocated llvm-config library origin=%q requested producer=%q",
+		origins["llvm-shared/0"], producer)
+	if !strings.HasPrefix(origins["llvm-shared/0"], producer+string(filepath.Separator)) {
+		t.Fatal("real llvm-config did not select the owned producer installation")
+	}
+	var loaded moduleLoadedLibrary
+	if err := ciReadJSON(filepath.Join(out, "before-llvm-loaded-library.json"), &loaded); err != nil {
+		t.Fatal(err)
+	}
+	loadedInfo, err := os.Stat(loaded.Path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range libraries {
+		originalInfo, err := os.Stat(original)
+		if err != nil || os.SameFile(loadedInfo, originalInfo) {
+			t.Fatal("actual Go LLVM native handle still refers to a host library inode", err)
+		}
+		t.Logf("ACTUAL_RELOCATED_LLVM_NATIVE_HANDLE copied=%q original=%q independent_inode=true", loaded.Path, original)
+	}
+	if err := os.Rename(producer, producer+"-closed"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(origins["llvm-shared/0"]); !os.IsNotExist(err) {
+		t.Fatal("producer origin is unexpectedly still available", err)
+	}
+	relocated := filepath.Join(t.TempDir(), "downloaded-owner")
+	if err := os.Rename(out, relocated); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyModuleDependencyArtifacts(relocated, report); err != nil {
+		t.Fatal("portable reader required a retired producer physical path", err)
+	}
+	path := filepath.Join(relocated, "before-llvm-loaded-library.json")
+	if err := ciReadJSON(path, &loaded); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"missing-byte-identity", "changed-byte-identity", "changed-configured-index", "changed-loaded-path"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := loaded
+			switch mutation {
+			case "missing-byte-identity":
+				changed.SHA = ""
+			case "changed-byte-identity":
+				changed.SHA = strings.Repeat("0", 64)
+			case "changed-configured-index":
+				changed.Index = len(libraries)
+			case "changed-loaded-path":
+				changed.Path = goBinary
+			}
+			if err := ciWriteJSON(path, changed); err != nil {
+				t.Fatal(err)
+			}
+			if err := verifyModuleDependencyArtifacts(relocated, report); err == nil {
+				t.Fatal("changed/missing loaded library identity accepted")
+			}
+			if err := ciWriteJSON(path, loaded); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func moduleLLVMConsumerFixture(t *testing.T) string {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":      moduleLLVMFixtureGoMod(t, "example.org/llvmconsumer"),
+		"consumer.go": "package consumer\nimport \"github.com/xgo-dev/llvm\"\nfunc Context() llvm.Context { return llvm.NewContext() }\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	sum, err := os.ReadFile(filepath.Join("..", "..", "go.sum"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "go.sum"), sum, 0600); err != nil {
+		t.Fatal(err)
+	}
+	return dir
+}
diff --git a/cmd/plan9asmtest/module_dependencies_unix_test.go b/cmd/plan9asmtest/module_dependencies_unix_test.go
new file mode 100644
index 000000000..122c05cfc
--- /dev/null
+++ b/cmd/plan9asmtest/module_dependencies_unix_test.go
@@ -0,0 +1,282 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestModuleScopeBindsActualWASMAndLLVMConsumers(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := moduleFixture(t, false)
+	stem := filepath.Join(t.TempDir(), "scope")
+	cfg := config{Go: goBinary, Dir: dir, Module: true, Timeout: 2 * time.Minute}
+	scope, err := captureCIScope(context.Background(), cfg, stem)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"node", "wasm-ld", "llvm-shared/0", "sdk-wasm/wasm_exec.js", "sdk-wasm/wasm_exec_node.js"} {
+		if scope.Tools[name] == "" {
+			t.Errorf("complete module scope omitted actual required consumer %s", name)
+		}
+	}
+	var origins map[string]string
+	if err := ciReadJSON(stem+"-origins.json", &origins); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"wasm_exec.js", "wasm_exec_node.js"} {
+		origin := origins["sdk-wasm/"+name]
+		if !strings.HasPrefix(origin, runtime.GOROOT()+string(filepath.Separator)) {
+			t.Errorf("wasm runtime came from another SDK: %s", origin)
+		}
+	}
+}
+
+func TestModuleActualGoLLVMBindingMatchesConfiguredLibrary(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":      moduleLLVMFixtureGoMod(t, "example.org/llvmconsumer"),
+		"consumer.go": "package consumer\nimport \"github.com/xgo-dev/llvm\"\nfunc Context() llvm.Context { return llvm.NewContext() }\n",
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	sum, err := os.ReadFile(filepath.Join("..", "..", "go.sum"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "go.sum"), sum, 0600); err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	stem := filepath.Join(t.TempDir(), "scope")
+	cfg := config{Go: goBinary, Dir: dir, Module: true, Timeout: 2 * time.Minute}
+	scope, err := captureCIScope(context.Background(), cfg, stem)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if scope.Tools["llvm-binding/ir.go"] == "" {
+		t.Fatal("actual selected native binding source was not captured")
+	}
+	var loaded moduleLoadedLibrary
+	if err := ciReadJSON(stem+"-llvm-loaded-library.json", &loaded); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(stem + "-llvm-loader-run.stdout")
+	if err != nil || string(data) != loaded.Path+"\n" {
+		t.Fatal("actual Go LLVM loader query did not execute", err)
+	}
+	t.Logf("actual selected binding loaded configured shared library index %d", loaded.Index)
+	before := filepath.Join(filepath.Dir(stem), "before")
+	after := filepath.Join(filepath.Dir(stem), "after")
+	first, err := captureCIScope(context.Background(), cfg, before)
+	if err != nil {
+		t.Fatal(err)
+	}
+	last, err := captureCIScope(context.Background(), cfg, after)
+	if err != nil || !reflect.DeepEqual(first, last) {
+		t.Fatal("unchanged actual Go LLVM binding", err)
+	}
+	report := moduleReport{Scope: first}
+	if err := verifyModuleDependencyArtifacts(filepath.Dir(stem), report); err != nil {
+		t.Fatal(err)
+	}
+	var origins map[string]string
+	if err := ciReadJSON(before+"-origins.json", &origins); err != nil {
+		t.Fatal(err)
+	}
+	delete(origins, "llvm-binding/ir.go")
+	if err := ciWriteJSON(before+"-origins.json", origins); err != nil {
+		t.Fatal(err)
+	}
+	delete(report.Scope.Tools, "llvm-binding/ir.go")
+	if err := verifyModuleDependencyArtifacts(filepath.Dir(stem), report); err == nil {
+		t.Fatal("paired binding-source deletion accepted")
+	}
+}
+
+func TestModuleDependencyArtifactDeletionAndChangesFail(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir, out := moduleFixture(t, false), t.TempDir()
+	cfg := config{Go: goBinary, Dir: dir, Module: true, Timeout: 2 * time.Minute}
+	before, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "before"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	after, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "after"))
+	if err != nil || !reflect.DeepEqual(before, after) {
+		t.Fatal("actual unchanged dependency scope control", err)
+	}
+	report := moduleReport{Scope: before}
+	if err := verifyModuleDependencyArtifacts(out, report); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"before-node-version.stdout", "before-wasm-linker-selection.json", "before-llvm-shared-files.stdout", "before-llvm-go-packages.stdout"} {
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(out, name)
+			original, err := os.ReadFile(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, changed := range [][]byte{nil, []byte("foreign\n")} {
+				if err := os.WriteFile(path, changed, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := verifyModuleDependencyArtifacts(out, report); err == nil {
+					t.Fatal("missing/mutated dependency observation was accepted")
+				}
+			}
+			if err := os.WriteFile(path, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestModuleWASMRuntimeSelectionAndSharedLibraryBounds(t *testing.T) {
+	root := t.TempDir()
+	if _, err := moduleWASMRuntimeFiles(root); err == nil {
+		t.Fatal("absent actual SDK wasm runtime accepted")
+	}
+	write := func(directory, name string) {
+		path := filepath.Join(root, directory, "wasm")
+		if err := os.MkdirAll(path, 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(path, name), []byte("runtime identity model"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("lib", "wasm_exec.js")
+	write("misc", "wasm_exec_node.js")
+	if _, err := moduleWASMRuntimeFiles(root); err == nil {
+		t.Fatal("mixed partial directories accepted")
+	}
+	write("misc", "wasm_exec.js")
+	files, err := moduleWASMRuntimeFiles(root)
+	if err != nil || files["sdk-wasm/wasm_exec.js"] != filepath.Join(root, "misc", "wasm", "wasm_exec.js") {
+		t.Fatal("complete historical runtime selection", err)
+	}
+	write("lib", "wasm_exec_node.js")
+	files, err = moduleWASMRuntimeFiles(root)
+	if err != nil || files["sdk-wasm/wasm_exec.js"] != filepath.Join(root, "lib", "wasm", "wasm_exec.js") {
+		t.Fatal("current runtime must win only with its complete pair", err)
+	}
+	for _, data := range []string{"", "relative", "/library /library", "/library\x00", strings.Repeat("/library ", 33)} {
+		if _, err := moduleSharedLibraries([]byte(data)); err == nil {
+			t.Fatal("invalid/unbounded actual shared-library list accepted", data)
+		}
+	}
+}
+
+func TestModuleActualCLIRejectsMissingNodeConsumer(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleFixture(t, false)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	llvmConfig := moduleFixtureLLVMConfig(t)
+	git, err := exec.LookPath("git")
+	if err != nil {
+		t.Fatal(err)
+	}
+	gitDirectory := t.TempDir()
+	if err := os.Symlink(git, filepath.Join(gitDirectory, "git")); err != nil {
+		t.Fatal(err)
+	}
+	// Keep the real SDK and LLVM tools, but no Node interpreter. This is an
+	// actual Go module execution, not a script impersonating a compiler.
+	t.Setenv("LLVM_CONFIG", llvmConfig)
+	t.Setenv("PATH", strings.Join([]string{filepath.Dir(goBinary), filepath.Dir(llvmConfig), gitDirectory}, string(os.PathListSeparator)))
+	if _, err := exec.LookPath("node"); err == nil {
+		t.Fatal("missing-Node fixture still has an interpreter")
+	}
+	stem := filepath.Join(t.TempDir(), "cli")
+	out := filepath.Join(t.TempDir(), "module")
+	_, err = captureCommand(context.Background(), 5*time.Minute, dir, binary,
+		[]string{"-module", "-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--", "-p=2"}, stem)
+	if err == nil {
+		t.Fatal("module completed without its required Node runtime")
+	}
+	data, readErr := os.ReadFile(stem + ".stderr")
+	if readErr != nil || !strings.Contains(string(data), "node") {
+		t.Fatalf("missing runtime did not retain its concrete cause: %v\n%s", readErr, data)
+	}
+}
+
+func TestModuleActualScopeRejectsUnmodeledNodeEnvironment(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := moduleFixture(t, false)
+	cfg := config{Go: goBinary, Dir: dir, Module: true, Timeout: 2 * time.Minute}
+	controls := []string{"NODE_OPTIONS", "NODE_PATH", "NODE_ICU_DATA"}
+	for _, key := range controls {
+		t.Setenv(key, "")
+	}
+	for _, absent := range []bool{false, true} {
+		if absent {
+			for _, key := range controls {
+				if err := os.Unsetenv(key); err != nil {
+					t.Fatal(err)
+				}
+			}
+		}
+		stem := filepath.Join(t.TempDir(), "scope")
+		scope, err := captureCIScope(context.Background(), cfg, stem)
+		if err != nil {
+			t.Fatal("absent/empty actual Node environment control", err)
+		}
+		for _, key := range controls {
+			if value, present := scope.Environment["process/"+key]; !present || value != "" {
+				t.Fatalf("Node consumer control %s was not bound: %q %v", key, value, present)
+			}
+		}
+	}
+	for _, test := range []struct{ key, value string }{
+		{"NODE_OPTIONS", "--enable-source-maps"},
+		{"NODE_PATH", t.TempDir()},
+		{"NODE_ICU_DATA", t.TempDir()},
+	} {
+		t.Run(test.key, func(t *testing.T) {
+			t.Setenv(test.key, test.value)
+			stem := filepath.Join(t.TempDir(), "scope")
+			if _, err := captureCIScope(context.Background(), cfg, stem); err == nil || !strings.Contains(err.Error(), test.key) {
+				t.Fatalf("actual unmodeled %s must fail with its concrete key: %v", test.key, err)
+			}
+		})
+	}
+	process := map[string]string{"NODE_OPTIONS": "", "NODE_PATH": "", "NODE_ICU_DATA": ""}
+	for _, key := range controls {
+		delete(process, key)
+		if err := validateModuleNodeEnvironment(process); err == nil {
+			t.Fatal("missing captured Node control accepted", key)
+		}
+		process[key] = ""
+	}
+}
diff --git a/cmd/plan9asmtest/module_dependencies_windows_test.go b/cmd/plan9asmtest/module_dependencies_windows_test.go
new file mode 100644
index 000000000..84a9d63dc
--- /dev/null
+++ b/cmd/plan9asmtest/module_dependencies_windows_test.go
@@ -0,0 +1,125 @@
+package main
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func windowsModuleDependencyFixture(t *testing.T) (config, string) {
+	t.Helper()
+	t.Setenv("GOFLAGS", "-tags=byollvm")
+	t.Setenv("GOENV", "off")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": moduleLLVMFixtureGoMod(t, "example.org/windows-llvm-consumer"),
+		"consumer.go": `package consumer
+import "github.com/xgo-dev/llvm"
+func Context() llvm.Context { return llvm.NewContext() }
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	sum, err := os.ReadFile(filepath.Join("..", "..", "go.sum"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "go.sum"), sum, 0600); err != nil {
+		t.Fatal(err)
+	}
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	out := t.TempDir()
+	t.Cleanup(func() {
+		if !t.Failed() {
+			return
+		}
+		entries, _ := os.ReadDir(out)
+		for _, entry := range entries {
+			if !strings.HasSuffix(entry.Name(), ".stderr") &&
+				!strings.Contains(entry.Name(), "-node-version.") &&
+				!strings.Contains(entry.Name(), "-llvm-config") &&
+				!strings.Contains(entry.Name(), "-llvm-shared-files.") {
+				continue
+			}
+			data, err := os.ReadFile(filepath.Join(out, entry.Name()))
+			if err == nil && len(data) > 0 {
+				t.Logf("%s: %q", entry.Name(), data)
+			}
+		}
+	})
+	cfg := config{Go: driver, Dir: dir, Module: true, Flags: []string{"-tags=byollvm"}, Timeout: 2 * time.Minute}
+	return cfg, out
+}
+
+func TestWindowsModuleActualLLVMDependencyScope(t *testing.T) {
+	cfg, out := windowsModuleDependencyFixture(t)
+	before, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "before"))
+	if err != nil {
+		t.Fatal("actual Windows module dependency capture", err)
+	}
+	after, err := captureCIScope(context.Background(), cfg, filepath.Join(out, "after"))
+	if err != nil || !reflect.DeepEqual(before, after) {
+		t.Fatal("unchanged Windows source/tool/loader scopes differ", err)
+	}
+	if before.Environment["GOFLAGS"] != "-tags=byollvm" || before.Tools["llvm-loaded"] == "" {
+		t.Fatal("actual inherited selection or loaded DLL identity is missing")
+	}
+	if err := verifyModuleDependencyArtifacts(out, moduleReport{Scope: before}); err != nil {
+		t.Fatal("actual Windows dependency artifact readback", err)
+	}
+	path := filepath.Join(out, "before-llvm-loaded-library.json")
+	var loaded moduleLoadedLibrary
+	if err := ciReadJSON(path, &loaded); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual Go LLVM binding loaded %s", loaded.Path)
+	loaded.Path = filepath.Join(out, "foreign.dll")
+	if err := ciWriteJSON(path, loaded); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyModuleDependencyArtifacts(out, moduleReport{Scope: before}); err == nil {
+		t.Fatal("foreign loaded-library path became valid evidence")
+	}
+}
+
+func TestWindowsModuleActualLLVMLoader(t *testing.T) {
+	// Observe this independent boundary even if an earlier environment or
+	// Node observation prevents the complete-scope test from reaching it.
+	cfg, out := windowsModuleDependencyFixture(t)
+	binary, err := resolveCIConfigExecutable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	stem := filepath.Join(out, "actual")
+	version, err := moduleDependencyCommand(context.Background(), cfg, stem+"-llvm-configversion", binary, "--version")
+	if err != nil || !strings.HasPrefix(strings.TrimSpace(string(version)), "22.") {
+		t.Fatal("actual LLVM 22 configuration required", err)
+	}
+	data, err := moduleDependencyCommand(context.Background(), cfg, stem+"-llvm-shared-files", binary, "--libfiles", "--link-shared")
+	if err != nil {
+		t.Fatal(err)
+	}
+	libraries, err := moduleSharedLibraries(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	origins := map[string]string{}
+	if err := captureModuleLLVMBinding(context.Background(), cfg, stem, libraries, origins); err != nil {
+		t.Fatal("actual Windows Go LLVM loader", err)
+	}
+	if origins["llvm-loaded"] == "" {
+		t.Fatal("selected Go LLVM consumer did not execute its loader query")
+	}
+}
diff --git a/cmd/plan9asmtest/module_dependency_packets_test.go b/cmd/plan9asmtest/module_dependency_packets_test.go
new file mode 100644
index 000000000..630750361
--- /dev/null
+++ b/cmd/plan9asmtest/module_dependency_packets_test.go
@@ -0,0 +1,19 @@
+package main
+
+import "testing"
+
+func TestModuleNodeVersionPacketLineEndings(t *testing.T) {
+	for _, version := range []string{"v22.20.0\n", "v22.20.0\r\n", "v22.20.0-test.1\n"} {
+		if !ciNodeVersion.MatchString(version) {
+			t.Fatalf("complete Node version line rejected: %q", version)
+		}
+	}
+	for _, version := range []string{
+		"", "v22.20.0", "v22.20.0\r", "v22.\r20.0\n", "v22.20.0\n\n",
+		"v22.20.0\r\r\n", "v22.20.0\x00\n", " v22.20.0\n", "v22.20.0\r\nv22.20.0\r\n",
+	} {
+		if ciNodeVersion.MatchString(version) {
+			t.Fatalf("partial/multiple/control Node packet accepted: %q", version)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/module_execution_windows_test.go b/cmd/plan9asmtest/module_execution_windows_test.go
new file mode 100644
index 000000000..2d7a9c219
--- /dev/null
+++ b/cmd/plan9asmtest/module_execution_windows_test.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func windowsModuleExecutionFixture(t *testing.T) config {
+	t.Helper()
+	cfg, _ := windowsModuleDependencyFixture(t)
+	files := map[string]string{
+		"value.go": "package consumer\nfunc Value() int { return 7 }\n",
+		"value_test.go": `package consumer
+import ("fmt"; "testing")
+func TestAlpha(t *testing.T) {
+    t.Run("child", func(t *testing.T) {
+        c := Context()
+        defer c.Dispose()
+        if Value() != 7 { t.Fatal("value") }
+    })
+}
+func TestBeta(t *testing.T) { if Value() != 7 { t.Fatal("value") } }
+func ExampleValue() { fmt.Println(Value()); /* Output: 7 */ }
+func FuzzValue(f *testing.F) {
+    f.Add(1)
+    f.Fuzz(func(t *testing.T, n int) { if Value() != 7 { t.Fatal(n) } })
+}
+`,
+		"gotoolprofile/value.go": "package profile\nfunc Value() int { return 9 }\n",
+		"gotoolprofile/value_test.go": `package profile
+import "testing"
+func TestProfile(t *testing.T) { if Value() != 9 { t.Fatal("value") } }
+`,
+		"internal/other/value.go": "package other\nfunc Value() int { return 11 }\n",
+		"internal/other/value_test.go": `package other
+import "testing"
+func TestCompletePackage(t *testing.T) { if Value() != 11 { t.Fatal("value") } }
+`,
+		"empty/value.go": "package empty\nfunc Value() int { return 13 }\n",
+		"nested/go.mod":  "module example.org/separate\n\ngo 1.20\n",
+		"nested/value_test.go": `package separate
+import "testing"
+func TestNeverInParentInventory(t *testing.T) { t.Fatal("separate module") }
+`,
+	}
+	for name, source := range files {
+		path := filepath.Join(cfg.Dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cfg.Package, cfg.CIOwner, cfg.ModuleOwner = ".", -1, -1
+	cfg.Shards, cfg.Workers = 2, 1
+	cfg.ModuleRootPartitions, cfg.ModuleRootPartition = 2, -1
+	return cfg
+}
+
+func windowsModuleExecutionReport(t *testing.T, cfg config) (moduleReport, error) {
+	t.Helper()
+	err := runModule(context.Background(), cfg)
+	var report moduleReport
+	if readErr := ciReadJSON(filepath.Join(cfg.Out, "module.json"), &report); readErr != nil {
+		t.Fatalf("module report missing after %v: %v", err, readErr)
+	}
+	if err != nil {
+		_ = filepath.WalkDir(cfg.Out, func(path string, entry os.DirEntry, walkErr error) error {
+			if walkErr == nil && !entry.IsDir() && strings.HasSuffix(path, ".stderr") {
+				data, readErr := os.ReadFile(path)
+				if readErr == nil && len(data) != 0 {
+					t.Logf("%s: %q", filepath.Base(path), data)
+				}
+			}
+			return walkErr
+		})
+	}
+	return report, err
+}
+
+func TestWindowsModuleActualPartitionsAndCoverage(t *testing.T) {
+	cfg := windowsModuleExecutionFixture(t)
+	inputs := t.TempDir()
+	if err := os.Mkdir(filepath.Join(inputs, "owner-0000"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	profile := filepath.Join(t.TempDir(), "complete.cover")
+	cfg.Flags = append(cfg.Flags, "-p=2", "-covermode=atomic", "-coverprofile="+profile)
+	for owner := 0; owner < moduleOwners; owner++ {
+		parts := 1
+		if owner == 0 {
+			parts = cfg.ModuleRootPartitions
+		}
+		for part := 0; part < parts; part++ {
+			child := cfg
+			wantStatus := "passed"
+			child.ModuleOwner = owner
+			child.Out = filepath.Join(inputs, fmt.Sprintf("owner-%04d", owner))
+			if owner == 0 {
+				wantStatus = "completed_owned"
+				child.ModuleRootPartition = part
+				child.Out = filepath.Join(child.Out, fmt.Sprintf("part-%04d", part))
+			}
+			report, err := windowsModuleExecutionReport(t, child)
+			if err != nil || report.Status != wantStatus || len(report.Inventory) != 4 {
+				t.Fatalf("Windows module owner %d part %d: status=%s, inventory=%d; %v", owner, part, report.Status, len(report.Inventory), err)
+			}
+		}
+	}
+	if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+		t.Fatalf("owner published incomplete uploadable coverage: %v", err)
+	}
+	cfg.ModuleVerify, cfg.Out = inputs, filepath.Join(t.TempDir(), "aggregate")
+	report, err := windowsModuleExecutionReport(t, cfg)
+	if err != nil || report.Status != "passed" || len(report.Packages) != 4 ||
+		report.RootInventory == nil || len(report.RootInventory.Names) != 4 {
+		t.Fatalf("Windows complete actual package/root union: status=%s, packages=%d, roots=%+v; %v", report.Status, len(report.Packages), report.RootInventory, err)
+	}
+	coverage, err := os.ReadFile(profile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"consumer.go:", "value.go:", "gotoolprofile/value.go:", "internal/other/value.go:"} {
+		if !strings.Contains(string(coverage), name) {
+			t.Fatalf("Windows complete module coverage lost %s", name)
+		}
+	}
+	part := filepath.Join(inputs, "owner-0000", "part-0000")
+	retained := filepath.Join(t.TempDir(), "retained")
+	if err := os.Rename(part, retained); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := checkedModuleArtifacts(report, inputs); err == nil {
+		t.Fatal("missing Windows root partition became complete")
+	}
+	if err := os.Rename(retained, part); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := checkedModuleArtifacts(report, inputs); err != nil {
+		t.Fatalf("restored actual Windows partition union: %v", err)
+	}
+}
+
+func TestWindowsModuleActualFailureKeepsRemainingPackages(t *testing.T) {
+	cfg := windowsModuleExecutionFixture(t)
+	path := filepath.Join(cfg.Dir, "failure_test.go")
+	if err := os.WriteFile(path, []byte("package consumer\nimport \"testing\"\nfunc TestActualFailure(t *testing.T) { t.Fatal(\"original failure\") }\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cfg.ModuleRootPartitions = 1
+	cfg.Out = filepath.Join(t.TempDir(), "failed")
+	profile := filepath.Join(t.TempDir(), "failed.cover")
+	cfg.Flags = append(cfg.Flags, "-p=2", "-coverprofile="+profile)
+	report, err := windowsModuleExecutionReport(t, cfg)
+	if err == nil || report.Status != "failed" || len(report.Packages) != 4 ||
+		report.Packages[0].Status != "failed" {
+		t.Fatalf("actual Windows source failure lost: status=%s, packages=%+v; %v", report.Status, report.Packages, err)
+	}
+	for _, pkg := range report.Packages[1:] {
+		if pkg.Status != "passed" {
+			t.Fatalf("root failure suppressed remaining package: %+v", pkg)
+		}
+	}
+	if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+		t.Fatalf("failed module published uploadable coverage: %v", err)
+	}
+}
diff --git a/cmd/plan9asmtest/module_fixture_host_isolation_unix_test.go b/cmd/plan9asmtest/module_fixture_host_isolation_unix_test.go
new file mode 100644
index 000000000..8c86582a7
--- /dev/null
+++ b/cmd/plan9asmtest/module_fixture_host_isolation_unix_test.go
@@ -0,0 +1,130 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+)
+
+// Access time may change when reading. All other physical metadata, including
+// link count, ownership and change time, belongs to this isolation observation.
+func moduleFixtureStableMetadata(info os.FileInfo) map[string]any {
+	result := map[string]any{
+		"mode": info.Mode(), "size": info.Size(), "mtime": info.ModTime(),
+	}
+	value := reflect.ValueOf(info.Sys()).Elem()
+	for index := 0; index < value.NumField(); index++ {
+		field := value.Type().Field(index)
+		if field.PkgPath != "" {
+			continue
+		}
+		switch field.Name {
+		case "Atim", "Atimespec", "Atime", "Atimensec":
+			continue
+		}
+		result[field.Name] = value.Field(index).Interface()
+	}
+	return result
+}
+
+type moduleFixtureToolObservation struct {
+	Physical string
+	Metadata map[string]any
+	SHA256   string
+}
+
+// This is a fixture-only file extent bound, not a source or proof-role budget.
+const moduleFixtureToolMaxBytes int64 = 512 << 20
+
+func observeModuleFixtureTool(name string) (moduleFixtureToolObservation, error) {
+	var result moduleFixtureToolObservation
+	physical, err := filepath.EvalSymlinks(name)
+	if err != nil {
+		return result, err
+	}
+	before, err := os.Stat(name)
+	if err != nil {
+		return result, err
+	}
+	if !before.Mode().IsRegular() || before.Size() > moduleFixtureToolMaxBytes {
+		return result, fmt.Errorf("fixture tool exceeds its regular bounded role")
+	}
+	file, err := os.Open(name)
+	if err != nil {
+		return result, err
+	}
+	opened, statErr := file.Stat()
+	if statErr != nil || !os.SameFile(before, opened) {
+		return result, fmt.Errorf("fixture tool changed while opening: %v / %v", statErr, file.Close())
+	}
+	digest := sha256.New()
+	n, readErr := io.Copy(digest, io.LimitReader(file, before.Size()+1))
+	end, endErr := file.Stat()
+	closeErr := file.Close()
+	after, afterErr := os.Stat(name)
+	resolved, resolveErr := filepath.EvalSymlinks(name)
+	if readErr != nil || endErr != nil || closeErr != nil || afterErr != nil || resolveErr != nil {
+		return result, fmt.Errorf("fixture tool full read failed: %v / %v / %v / %v / %v",
+			readErr, endErr, closeErr, afterErr, resolveErr)
+	}
+	metadata := moduleFixtureStableMetadata(before)
+	if n != before.Size() || resolved != physical || !os.SameFile(before, end) || !os.SameFile(before, after) ||
+		!reflect.DeepEqual(metadata, moduleFixtureStableMetadata(end)) ||
+		!reflect.DeepEqual(metadata, moduleFixtureStableMetadata(after)) {
+		return result, fmt.Errorf("fixture tool identity, extent or metadata changed during complete read")
+	}
+	return moduleFixtureToolObservation{Physical: physical, Metadata: metadata,
+		SHA256: hex.EncodeToString(digest.Sum(nil))}, nil
+}
+
+func TestModuleRelocatedProducerDoesNotMutateHostTools(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	configBinary := moduleFixtureLLVMConfig(t)
+	cfg := config{Go: goBinary, Timeout: 2 * time.Minute}
+	data, err := moduleDependencyCommand(context.Background(), cfg,
+		filepath.Join(t.TempDir(), "actual-host-libraries"), configBinary, "--libfiles", "--link-shared")
+	if err != nil {
+		t.Fatal(err)
+	}
+	libraries, err := moduleSharedLibraries(data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := append([]string{configBinary}, libraries...)
+	before := make([]moduleFixtureToolObservation, len(names))
+	for index, name := range names {
+		before[index], err = observeModuleFixtureTool(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Run the actual fixture and all its cleanups. An invented copying stub
+	// would not exercise the selected library inode or the real loader route.
+	if !t.Run("actual-producer", TestModuleActualDependencyArtifactsSurviveProducerOriginRemoval) {
+		t.Fatal("actual relocated producer fixture failed")
+	}
+	for index, name := range names {
+		after, err := observeModuleFixtureTool(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !reflect.DeepEqual(before[index], after) {
+			t.Errorf("actual host tool bytes or metadata changed across producer setup/cleanup: %s\nbefore=%+v\nafter=%+v",
+				name, before[index], after)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/module_fixture_llvm_config_unix_test.go b/cmd/plan9asmtest/module_fixture_llvm_config_unix_test.go
new file mode 100644
index 000000000..b37243322
--- /dev/null
+++ b/cmd/plan9asmtest/module_fixture_llvm_config_unix_test.go
@@ -0,0 +1,78 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func moduleFixtureLLVMConfig(t *testing.T) string {
+	t.Helper()
+	binary, err := resolveCIConfigExecutable()
+	if err != nil {
+		t.Fatal("required LLVM 22 configuration:", err)
+	}
+	data, err := moduleDependencyCommand(context.Background(), config{Timeout: time.Minute},
+		filepath.Join(t.TempDir(), "llvm-config-version"), binary, "--version")
+	if err != nil || !strings.HasPrefix(strings.TrimSpace(string(data)), "22.") {
+		t.Fatalf("fixture requires actual LLVM 22: %v\n%s", err, data)
+	}
+	// A distro's /usr/bin/llvm-config-22 is commonly a symlink. Its directory
+	// also contains Node, so it cannot stand in for the isolated LLVM bin in
+	// the missing-Node fixture. Preserve the same selected executable/inode.
+	physical, err := filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return physical
+}
+
+func TestModuleLLVMConfigSelectionMatchesActualScope(t *testing.T) {
+	binary := moduleFixtureLLVMConfig(t)
+	binary, err := filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for _, name := range []string{"llvm-config", "llvm-config-22", "explicit-config"} {
+		if err := os.Symlink(binary, filepath.Join(directory, name)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("PATH", directory)
+	for _, row := range []struct{ requested, selected string }{
+		{"", "llvm-config-22"},
+		{"explicit-config", "explicit-config"},
+		{filepath.Join(directory, "explicit-config"), "explicit-config"},
+	} {
+		t.Run(row.requested, func(t *testing.T) {
+			t.Setenv("LLVM_CONFIG", row.requested)
+			got, err := resolveCIConfigExecutable()
+			if err != nil || got != filepath.Join(directory, row.selected) {
+				t.Fatalf("selected %q, want %q: %v", got, row.selected, err)
+			}
+		})
+	}
+	t.Setenv("LLVM_CONFIG", "missing-explicit-config")
+	if _, err := resolveCIConfigExecutable(); err == nil {
+		t.Fatal("explicit missing config fell back to installed LLVM")
+	}
+	t.Setenv("LLVM_CONFIG", "")
+	if err := os.Remove(filepath.Join(directory, "llvm-config-22")); err != nil {
+		t.Fatal(err)
+	}
+	if got, err := resolveCIConfigExecutable(); err != nil || got != filepath.Join(directory, "llvm-config") {
+		t.Fatal("unversioned actual LLVM 22 is unavailable:", got, err)
+	}
+	if err := os.Remove(filepath.Join(directory, "llvm-config")); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := resolveCIConfigExecutable(); err == nil {
+		t.Fatal("missing required config accepted")
+	}
+}
diff --git a/cmd/plan9asmtest/module_fixture_runtime_tools_unix_test.go b/cmd/plan9asmtest/module_fixture_runtime_tools_unix_test.go
new file mode 100644
index 000000000..4a5484f14
--- /dev/null
+++ b/cmd/plan9asmtest/module_fixture_runtime_tools_unix_test.go
@@ -0,0 +1,139 @@
+//go:build unix
+
+package main
+
+import (
+	"bytes"
+	"go/ast"
+	"go/parser"
+	"go/printer"
+	"go/token"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func moduleFixtureRelocatedLLVMTools(cross bool) []string {
+	names := []string{"llc", "clang", "llvm-as", "opt", "llvm-dis", "llvm-objdump", "llvm-nm"}
+	if cross {
+		names = append(names, "ld.lld")
+	}
+	return names
+}
+
+// This is a fixture maintenance tripwire, not a new tool-selection authority.
+// Actual captureCIScope still selects and checks every runtime tool itself.
+func moduleFixtureActualRuntimeToolRoles(t *testing.T) (base, cross []string) {
+	t.Helper()
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "ci_scope.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var capture *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == "captureCIScope" {
+			if capture != nil {
+				t.Fatal("duplicate scope producer")
+			}
+			capture = function
+		}
+	}
+	if capture == nil {
+		t.Fatal("actual runtime scope producer is absent")
+	}
+	stringsFrom := func(expressions []ast.Expr) []string {
+		var result []string
+		for _, expression := range expressions {
+			literal, ok := expression.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("runtime role table changed from explicit string roles")
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			result = append(result, value)
+		}
+		return result
+	}
+	var predicates int
+	ast.Inspect(capture.Body, func(node ast.Node) bool {
+		assignment, ok := node.(*ast.AssignStmt)
+		if ok && len(assignment.Lhs) == 1 && len(assignment.Rhs) == 1 {
+			name, _ := assignment.Lhs[0].(*ast.Ident)
+			if name != nil && name.Name == "names" && assignment.Tok == token.DEFINE {
+				literal, ok := assignment.Rhs[0].(*ast.CompositeLit)
+				if !ok || base != nil {
+					t.Fatal("actual base runtime role table changed")
+				}
+				base = stringsFrom(literal.Elts)
+			}
+			if name != nil && name.Name == "llvmTool" {
+				var predicate bytes.Buffer
+				if err := printer.Fprint(&predicate, set, assignment.Rhs[0]); err != nil {
+					t.Fatal(err)
+				}
+				if predicate.String() != `name == "clang" || name == "llc" || name == "opt" || name == "ld.lld" || strings.HasPrefix(name, "llvm-")` {
+					t.Fatal("actual LLVM bindir predicate changed; update fixture role observation", predicate.String())
+				}
+				predicates++
+			}
+		}
+		conditional, ok := node.(*ast.IfStmt)
+		if !ok {
+			return true
+		}
+		condition, _ := conditional.Cond.(*ast.Ident)
+		if condition == nil || condition.Name != "cross" {
+			return true
+		}
+		for _, statement := range conditional.Body.List {
+			assignment, ok := statement.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				continue
+			}
+			name, _ := assignment.Lhs[0].(*ast.Ident)
+			if name == nil || name.Name != "names" {
+				continue
+			}
+			call, ok := assignment.Rhs[0].(*ast.CallExpr)
+			if !ok || len(call.Args) < 2 || cross != nil {
+				t.Fatal("actual cross runtime role table changed")
+			}
+			function, _ := call.Fun.(*ast.Ident)
+			first, _ := call.Args[0].(*ast.Ident)
+			if function == nil || function.Name != "append" || first == nil || first.Name != "names" {
+				t.Fatal("actual cross runtime role append changed")
+			}
+			cross = stringsFrom(call.Args[1:])
+		}
+		return true
+	})
+	if len(base) == 0 || len(cross) == 0 || predicates != 1 {
+		t.Fatal("incomplete actual runtime role observation")
+	}
+	return base, cross
+}
+
+func TestModuleFixtureRelocatedLLVMToolsCoverActualRuntimeRoles(t *testing.T) {
+	base, additional := moduleFixtureActualRuntimeToolRoles(t)
+	for _, cross := range []bool{false, true} {
+		t.Run(strconv.FormatBool(cross), func(t *testing.T) {
+			actual := append([]string(nil), base...)
+			if cross {
+				actual = append(actual, additional...)
+			}
+			var required []string
+			for _, name := range actual {
+				if name != "llvm-config" && (name == "clang" || name == "llc" || name == "opt" || name == "ld.lld" || strings.HasPrefix(name, "llvm-")) {
+					required = append(required, name)
+				}
+			}
+			if got := moduleFixtureRelocatedLLVMTools(cross); !reflect.DeepEqual(got, required) {
+				t.Fatalf("relocated fixture omitted or added actual LLVM runtime roles: got=%v required=%v", got, required)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/module_fixture_tool_copy_unix_test.go b/cmd/plan9asmtest/module_fixture_tool_copy_unix_test.go
new file mode 100644
index 000000000..d0edd1c82
--- /dev/null
+++ b/cmd/plan9asmtest/module_fixture_tool_copy_unix_test.go
@@ -0,0 +1,194 @@
+//go:build unix
+
+package main
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// Tools in a relocated fixture must own independent inodes. Hard-linking a
+// host library makes fixture cleanup mutate that library's change time.
+func copyModuleFixtureTool(source, destination string) error {
+	return copyModuleFixtureToolExtent(source, destination, moduleFixtureToolMaxBytes)
+}
+
+func copyModuleFixtureToolExtent(source, destination string, limit int64) (resultErr error) {
+	if limit < 0 || limit > moduleFixtureToolMaxBytes {
+		return fmt.Errorf("invalid fixture tool copy extent bound")
+	}
+	before, err := observeModuleFixtureTool(source)
+	if err != nil {
+		return err
+	}
+	input, err := os.Open(source)
+	if err != nil {
+		return err
+	}
+	defer func() { resultErr = errors.Join(resultErr, input.Close()) }()
+	info, err := input.Stat()
+	if err != nil {
+		return err
+	}
+	if !info.Mode().IsRegular() || info.Size() > limit ||
+		!reflect.DeepEqual(before.Metadata, moduleFixtureStableMetadata(info)) {
+		return fmt.Errorf("fixture source tool role or extent changed")
+	}
+	parentName := filepath.Dir(destination)
+	parent, err := os.Stat(parentName)
+	if err != nil || !parent.IsDir() {
+		return fmt.Errorf("fixture tool destination parent is unavailable: %w", err)
+	}
+	output, err := os.OpenFile(destination, os.O_WRONLY|os.O_CREATE|os.O_EXCL, info.Mode().Perm())
+	if err != nil {
+		return err
+	}
+	outputOpen := true
+	defer func() {
+		if outputOpen {
+			resultErr = errors.Join(resultErr, output.Close())
+		}
+	}()
+	created, err := output.Stat()
+	if err != nil {
+		return err
+	}
+	if !created.Mode().IsRegular() || os.SameFile(info, created) {
+		return fmt.Errorf("fixture copy did not create an independent regular inode")
+	}
+	digest := sha256.New()
+	count, copyErr := io.Copy(io.MultiWriter(output, digest), io.LimitReader(input, info.Size()))
+	var extra [1]byte
+	n, eofErr := input.Read(extra[:])
+	end, statErr := input.Stat()
+	closeErr := output.Close()
+	outputOpen = false
+	if err := errors.Join(copyErr, statErr, closeErr); err != nil {
+		return err
+	}
+	if count != info.Size() || n != 0 || eofErr != io.EOF {
+		return fmt.Errorf("fixture tool copy did not consume its exact extent and complete EOF: %v", eofErr)
+	}
+	if !os.SameFile(info, end) || !reflect.DeepEqual(before.Metadata, moduleFixtureStableMetadata(end)) {
+		return fmt.Errorf("fixture source tool changed during streaming copy")
+	}
+	after, err := observeModuleFixtureTool(source)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(before, after) {
+		return fmt.Errorf("fixture source tool bytes or metadata changed during copy")
+	}
+	parentAfter, err := os.Stat(parentName)
+	if err != nil || !os.SameFile(parent, parentAfter) {
+		return fmt.Errorf("fixture destination parent identity changed: %w", err)
+	}
+	actual, err := os.Stat(destination)
+	if err != nil || !os.SameFile(created, actual) || os.SameFile(info, actual) {
+		return fmt.Errorf("fixture destination tool identity changed: %w", err)
+	}
+	copied, err := observeModuleFixtureTool(destination)
+	if err != nil {
+		return err
+	}
+	if copied.SHA256 != before.SHA256 || copied.SHA256 != hex.EncodeToString(digest.Sum(nil)) || actual.Size() != info.Size() {
+		return fmt.Errorf("fixture destination tool bytes differ from the complete selected source")
+	}
+	return nil
+}
+
+func TestModuleFixtureToolCopyIndependentInodeAndCompleteBytes(t *testing.T) {
+	for _, size := range []int{0, 1, 17, 32768, 32769} {
+		t.Run(fmt.Sprint(size), func(t *testing.T) {
+			directory := t.TempDir()
+			source, destination := filepath.Join(directory, "host"), filepath.Join(directory, "owned")
+			data := make([]byte, size)
+			for index := range data {
+				data[index] = byte(index*73 + index/251)
+			}
+			if err := os.WriteFile(source, data, 0700); err != nil {
+				t.Fatal(err)
+			}
+			before, err := observeModuleFixtureTool(source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := copyModuleFixtureToolExtent(source, destination, int64(size)); err != nil {
+				t.Fatal(err)
+			}
+			copied, err := os.ReadFile(destination)
+			if err != nil || !reflect.DeepEqual(copied, data) {
+				t.Fatal("independent copy omitted source bytes", err)
+			}
+			originalInfo, originalErr := os.Stat(source)
+			copyInfo, copyErr := os.Stat(destination)
+			if originalErr != nil || copyErr != nil || os.SameFile(originalInfo, copyInfo) {
+				t.Fatal("fixture copy still shares the original inode")
+			}
+			if err := os.Remove(destination); err != nil {
+				t.Fatal(err)
+			}
+			after, err := observeModuleFixtureTool(source)
+			if err != nil || !reflect.DeepEqual(before, after) {
+				t.Fatal("owned copy removal changed original tool", err)
+			}
+		})
+	}
+}
+
+func TestModuleFixtureToolCopyRejectsInvalidRolesAndBounds(t *testing.T) {
+	for _, row := range []string{"missing source", "directory source", "over bound", "negative bound", "existing destination", "destination symlink", "missing parent"} {
+		t.Run(row, func(t *testing.T) {
+			directory := t.TempDir()
+			source, destination := filepath.Join(directory, "host"), filepath.Join(directory, "owned")
+			if err := os.WriteFile(source, []byte("actual fixture bytes"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			before, err := observeModuleFixtureTool(source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			limit := moduleFixtureToolMaxBytes
+			switch row {
+			case "missing source":
+				source = filepath.Join(directory, "missing")
+			case "directory source":
+				source = directory
+			case "over bound":
+				limit = 1
+			case "negative bound":
+				limit = -1
+			case "existing destination":
+				if err := os.WriteFile(destination, []byte("foreign destination"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "destination symlink":
+				if err := os.Symlink(source, destination); err != nil {
+					t.Fatal(err)
+				}
+			case "missing parent":
+				destination = filepath.Join(directory, "missing", "owned")
+			}
+			if err := copyModuleFixtureToolExtent(source, destination, limit); err == nil {
+				t.Fatal("invalid source/destination role or bound accepted")
+			}
+			after, err := observeModuleFixtureTool(filepath.Join(directory, "host"))
+			if err != nil || !reflect.DeepEqual(before, after) {
+				t.Fatal("failed copy altered original physical tool", err)
+			}
+			if row == "existing destination" {
+				data, err := os.ReadFile(destination)
+				if err != nil || string(data) != "foreign destination" {
+					t.Fatal("failed exclusive creation altered foreign destination", err)
+				}
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/module_llvm_fixture_test.go b/cmd/plan9asmtest/module_llvm_fixture_test.go
new file mode 100644
index 000000000..c4d736fa7
--- /dev/null
+++ b/cmd/plan9asmtest/module_llvm_fixture_test.go
@@ -0,0 +1,61 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// Keep real consumer fixtures on the same selected binding and checksums as
+// the repository, including an explicitly selected replacement.
+func moduleLLVMFixtureGoMod(t *testing.T, name string) string {
+	t.Helper()
+	root, err := filepath.Abs(filepath.Join("..", ".."))
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "list", "-mod=readonly", "-m", "-json", "github.com/xgo-dev/llvm")
+	command.Dir = root
+	command.WaitDelay = 5 * time.Second
+	data, err := command.CombinedOutput()
+	if err != nil {
+		t.Fatalf("select actual fixture LLVM binding: %v\n%s", err, data)
+	}
+	var selected struct {
+		Path, Version string
+		Replace       *struct{ Path, Version, Dir string }
+	}
+	if err := json.Unmarshal(data, &selected); err != nil {
+		t.Fatal(err)
+	}
+	if selected.Path != "github.com/xgo-dev/llvm" || selected.Version == "" {
+		t.Fatalf("missing selected fixture LLVM binding: %s", data)
+	}
+	module := fmt.Sprintf("module %s\n\ngo 1.20\nrequire %s %s\n", name, selected.Path, selected.Version)
+	if replacement := selected.Replace; replacement != nil {
+		path := replacement.Path
+		if replacement.Version == "" {
+			if replacement.Dir == "" {
+				t.Fatal("local fixture LLVM replacement has no directory")
+			}
+			path = replacement.Dir
+		}
+		module += fmt.Sprintf("replace %s => %s", selected.Path, strconv.Quote(path))
+		if replacement.Version != "" {
+			module += " " + replacement.Version
+		}
+		module += "\n"
+	}
+	return module
+}
diff --git a/cmd/plan9asmtest/module_llvm_loader_source.go b/cmd/plan9asmtest/module_llvm_loader_source.go
new file mode 100644
index 000000000..78dc1fd5d
--- /dev/null
+++ b/cmd/plan9asmtest/module_llvm_loader_source.go
@@ -0,0 +1,168 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type moduleLLVMProbeSource struct {
+	Parent   string `json:"physical_artifact_parent"`
+	Path     string `json:"actual_build_source"`
+	Artifact string `json:"phase_source_artifact"`
+	SHA      string `json:"source_sha256"`
+}
+
+type moduleLLVMProbeInput struct {
+	source moduleLLVMProbeSource
+	roles  []os.FileInfo
+}
+
+func moduleLLVMProbeSHA(data []byte) string {
+	sum := sha256.Sum256(data)
+	return hex.EncodeToString(sum[:])
+}
+
+// Only this request's immutable source filename is shared. Every scope still
+// invokes actual Go build and executes its own output. No binary, observation,
+// source digest, tool route or environment proof is cached here.
+func prepareModuleLLVMProbeSource(ctx context.Context, stem string) (input moduleLLVMProbeInput, resultErr error) {
+	if err := ctx.Err(); err != nil {
+		return input, err
+	}
+	parent := filepath.Dir(stem)
+	info, err := os.Lstat(parent)
+	if err != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 || !filepath.IsAbs(parent) {
+		return input, fmt.Errorf("LLVM probe requires an owned regular artifact parent: %v", err)
+	}
+	physical, err := sourcepath.Resolve(parent)
+	if err != nil {
+		return input, err
+	}
+	actual, err := os.Stat(physical)
+	if err != nil || !os.SameFile(info, actual) {
+		return input, fmt.Errorf("LLVM probe artifact parent identity changed: %v", err)
+	}
+	directory := filepath.Join(physical, ".llvm-loader-source")
+	if err := os.Mkdir(directory, 0700); err != nil && !os.IsExist(err) {
+		return input, err
+	}
+	directoryInfo, err := os.Lstat(directory)
+	if err != nil || !directoryInfo.IsDir() || directoryInfo.Mode()&os.ModeSymlink != 0 {
+		return input, fmt.Errorf("LLVM probe source directory is not its regular owned role: %v", err)
+	}
+	input.source = moduleLLVMProbeSource{Parent: physical, Path: filepath.Join(directory, "main.go"),
+		Artifact: filepath.Join(physical, filepath.Base(stem)+"-llvm-loader.go")}
+	if _, err := os.Lstat(input.source.Path); os.IsNotExist(err) {
+		staged, err := os.CreateTemp(directory, ".pending-*.go")
+		if err != nil {
+			return input, err
+		}
+		stagedInfo, statErr := staged.Stat()
+		if statErr != nil {
+			return input, errors.Join(statErr, staged.Close())
+		}
+		// Every creator owns only this unique staging file. Atomic hard-link
+		// publication exposes complete closed bytes, even to a losing creator.
+		defer func() {
+			if err := verifyModuleLLVMProbeStagingRole(staged.Name(), directoryInfo, stagedInfo); err != nil {
+				// Never follow a replaced role to clean another owner's file.
+				// An unprovable moved temporary remains closed and quarantined.
+				resultErr = errors.Join(resultErr, err)
+				return
+			}
+			resultErr = errors.Join(resultErr, os.Remove(staged.Name()))
+		}()
+		n, writeErr := io.WriteString(staged, moduleLLVMLoaderProbe)
+		closeErr := staged.Close()
+		if writeErr == nil && n != len(moduleLLVMLoaderProbe) {
+			writeErr = io.ErrShortWrite
+		}
+		if err := errors.Join(writeErr, closeErr, ctx.Err()); err != nil {
+			return input, err
+		}
+		if err := verifyModuleLLVMProbeStagingRole(staged.Name(), directoryInfo, stagedInfo); err != nil {
+			return input, err
+		}
+		if err := os.Link(staged.Name(), input.source.Path); err != nil && !os.IsExist(err) {
+			return input, err
+		}
+	} else if err != nil {
+		return input, err
+	}
+	input.roles, input.source.SHA, err = readModuleLLVMProbeSource(input.source)
+	if err != nil {
+		return input, err
+	}
+	if !os.SameFile(info, input.roles[0]) || !os.SameFile(directoryInfo, input.roles[1]) {
+		return input, fmt.Errorf("LLVM probe parent/source directory identity changed during publication")
+	}
+	return input, ctx.Err()
+}
+
+func verifyModuleLLVMProbeStagingRole(name string, directory, staged os.FileInfo) error {
+	for index, role := range []struct {
+		path string
+		info os.FileInfo
+	}{{filepath.Dir(name), directory}, {name, staged}} {
+		actual, err := os.Lstat(role.path)
+		if err != nil || actual.Mode()&os.ModeSymlink != 0 || !os.SameFile(role.info, actual) ||
+			index == 0 && !actual.IsDir() || index == 1 && !actual.Mode().IsRegular() {
+			return fmt.Errorf("LLVM probe original staging role changed: %v", err)
+		}
+	}
+	return nil
+}
+
+func readModuleLLVMProbeSource(source moduleLLVMProbeSource) ([]os.FileInfo, string, error) {
+	var roles []os.FileInfo
+	for index, path := range []string{source.Parent, filepath.Dir(source.Path), source.Path} {
+		info, err := os.Lstat(path)
+		if err != nil || info.Mode()&os.ModeSymlink != 0 ||
+			index < 2 && !info.IsDir() || index == 2 && !info.Mode().IsRegular() {
+			return nil, "", fmt.Errorf("LLVM probe physical source role changed: %v", err)
+		}
+		roles = append(roles, info)
+	}
+	file, err := os.Open(source.Path)
+	if err != nil {
+		return nil, "", err
+	}
+	opened, statErr := file.Stat()
+	data, readErr := io.ReadAll(io.LimitReader(file, int64(len(moduleLLVMLoaderProbe)+1)))
+	closeErr := file.Close()
+	if err := errors.Join(statErr, readErr, closeErr); err != nil {
+		return nil, "", err
+	}
+	if !os.SameFile(opened, roles[2]) || !bytes.Equal(data, []byte(moduleLLVMLoaderProbe)) {
+		return nil, "", fmt.Errorf("LLVM probe actual compiled source bytes/identity differ")
+	}
+	return roles, moduleLLVMProbeSHA(data), nil
+}
+
+func (input moduleLLVMProbeInput) verify(ctx context.Context) error {
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	roles, sha, err := readModuleLLVMProbeSource(input.source)
+	if err != nil {
+		return err
+	}
+	for index, role := range roles {
+		if !os.SameFile(input.roles[index], role) {
+			return fmt.Errorf("LLVM probe original source role replaced")
+		}
+	}
+	if sha != input.source.SHA {
+		return fmt.Errorf("LLVM probe source changed during actual build/loader execution")
+	}
+	return nil
+}
diff --git a/cmd/plan9asmtest/module_llvm_loader_source_unix_test.go b/cmd/plan9asmtest/module_llvm_loader_source_unix_test.go
new file mode 100644
index 000000000..11a4a9f7c
--- /dev/null
+++ b/cmd/plan9asmtest/module_llvm_loader_source_unix_test.go
@@ -0,0 +1,375 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// cmd/go/internal/work/buildid.go defines an executable build ID as
+// linkAction/mainAction/mainContent/binaryContent. Compare the complete build
+// inputs, not the last output hash: external linkers can change Mach-O UUIDs
+// between otherwise identical builds. Source/tool/library scopes and both
+// independently built and executed outputs are still checked below.
+func moduleLLVMLoaderBuildInputs(data []byte) ([3]string, error) {
+	var inputs [3]string
+	parts := strings.Split(strings.TrimSpace(string(data)), "/")
+	if len(parts) != 4 {
+		return inputs, fmt.Errorf("expected four-part Go executable build ID")
+	}
+	for _, part := range parts {
+		hash, err := base64.RawURLEncoding.DecodeString(part)
+		if err != nil || len(hash) != 15 {
+			return inputs, fmt.Errorf("invalid Go executable build ID hash")
+		}
+	}
+	copy(inputs[:], parts[:3])
+	return inputs, nil
+}
+
+func TestModuleLLVMLoaderBuildInputIdentityContract(t *testing.T) {
+	parts := []string{
+		"4Sv_jAoZLEHEiToUJqjp", "Gh9vhQpOPgyFAE1zV7cQ",
+		"54B443LuDoOsCwYlS76d", "d1YRB_sIJnUt9MGYvdNO",
+	}
+	want, err := moduleLLVMLoaderBuildInputs([]byte(strings.Join(parts, "/") + "\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, role := range []string{"link-action", "main-action", "main-content", "binary-content"} {
+		t.Run(role, func(t *testing.T) {
+			changed := append([]string(nil), parts...)
+			changed[index] = "YjHc7jzVQ6eG97PMevqY"
+			got, err := moduleLLVMLoaderBuildInputs([]byte(strings.Join(changed, "/")))
+			if err != nil || (got == want) != (index == 3) {
+				t.Fatalf("input/output identities confused: got=%v want=%v err=%v", got, want, err)
+			}
+		})
+	}
+	for _, malformed := range []string{
+		"", strings.Join(parts[:3], "/"), strings.Join(parts, "/") + "/extra",
+		"!/" + strings.Join(parts[1:], "/"), strings.Join(parts[:3], "/") + "/!",
+	} {
+		if _, err := moduleLLVMLoaderBuildInputs([]byte(malformed)); err == nil {
+			t.Errorf("malformed build ID accepted: %q", malformed)
+		}
+	}
+}
+
+func TestModuleLLVMLoaderRepeatedBuildRetainsIndependentActualScopes(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	out := t.TempDir()
+	physicalParent, err := filepath.EvalSymlinks(out)
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := config{Go: goBinary, Dir: moduleLLVMConsumerFixture(t), Module: true,
+		Timeout: 2 * time.Minute, Flags: []string{"-p=2"}}
+	before := filepath.Join(out, "before")
+	first, err := captureCIScope(context.Background(), cfg, before)
+	if err != nil {
+		t.Fatal("fresh first source/tool/environment/library scope", err)
+	}
+	firstID, err := moduleDependencyCommand(context.Background(), cfg, filepath.Join(out, "first-buildid"), goBinary,
+		"tool", "buildid", before+"-llvm-loader")
+	if err != nil || len(strings.TrimSpace(string(firstID))) == 0 {
+		t.Fatal("actual first Go loader build identity", err)
+	}
+	// The second scope must build and execute its own output; it cannot execute
+	// this first binary or copy the first loader's observation as a new proof.
+	if err := os.Remove(before + "-llvm-loader"); err != nil {
+		t.Fatal(err)
+	}
+	after := filepath.Join(out, "after")
+	last, err := captureCIScope(context.Background(), cfg, after)
+	if err != nil {
+		t.Fatal("fresh second source/tool/environment/library scope", err)
+	}
+	lastID, err := moduleDependencyCommand(context.Background(), cfg, filepath.Join(out, "last-buildid"), goBinary,
+		"tool", "buildid", after+"-llvm-loader")
+	if err != nil {
+		t.Fatal("actual second Go loader build identity", err)
+	}
+	firstInputs, err := moduleLLVMLoaderBuildInputs(firstID)
+	if err != nil {
+		t.Fatal("actual first Go loader build inputs", err)
+	}
+	lastInputs, err := moduleLLVMLoaderBuildInputs(lastID)
+	if err != nil {
+		t.Fatal("actual second Go loader build inputs", err)
+	}
+	if firstInputs != lastInputs {
+		t.Errorf("identical request-owned probe content changes actual Go build inputs: first=%q second=%q", firstID, lastID)
+	}
+	if !reflect.DeepEqual(first, last) {
+		t.Fatal("independent unchanged scopes differ")
+	}
+	if err := verifyModuleDependencyArtifacts(out, moduleReport{Scope: first}); err != nil {
+		t.Fatal("full dependency artifact readback", err)
+	}
+	for _, stem := range []string{before, after} {
+		var origins map[string]string
+		if err := ciReadJSON(stem+"-origins.json", &origins); err != nil {
+			t.Fatal(err)
+		}
+		if origins["llvm-loader-source"] != filepath.Join(physicalParent, ".llvm-loader-source", "main.go") {
+			t.Errorf("actual Go build source not bound to this request: %q", origins["llvm-loader-source"])
+		}
+		var loaded moduleLoadedLibrary
+		if err := ciReadJSON(stem+"-llvm-loaded-library.json", &loaded); err != nil {
+			t.Fatal(err)
+		}
+		run, err := os.ReadFile(stem + "-llvm-loader-run.stdout")
+		if err != nil || string(run) != loaded.Path+"\n" || loaded.SHA != first.Tools["llvm-loaded"] {
+			t.Fatal("fresh actual loader result/byte identity missing", err)
+		}
+	}
+	metadata := before + "-llvm-loader-source.json"
+	original, err := os.ReadFile(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"missing", "foreign-source", "foreign-artifact", "changed-bytes", "missing-tool-origin"} {
+		t.Run(mutation, func(t *testing.T) {
+			var changed moduleLLVMProbeSource
+			if err := ciReadJSON(metadata, &changed); err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "missing":
+				changed = moduleLLVMProbeSource{}
+			case "foreign-source":
+				changed.Path = filepath.Join(changed.Parent, "unconsumed.go")
+			case "foreign-artifact":
+				changed.Artifact = filepath.Join(changed.Parent, "after-llvm-loader.go")
+			case "changed-bytes":
+				changed.SHA = strings.Repeat("0", 64)
+			case "missing-tool-origin":
+				delete(first.Tools, "llvm-loader-source")
+			}
+			if err := ciWriteJSON(metadata, changed); err != nil {
+				t.Fatal(err)
+			}
+			if err := verifyModuleDependencyArtifacts(out, moduleReport{Scope: first}); err == nil {
+				t.Fatal("compiled source role omission/change accepted")
+			}
+			if err := os.WriteFile(metadata, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			first.Tools["llvm-loader-source"] = last.Tools["llvm-loader-source"]
+		})
+	}
+	t.Log("Two fresh actual Go builds and two loader executions; original 2m child budgets and complete source/tool/environment/library captures remain independent.")
+}
+
+func TestModuleLLVMProbeSourceAtomicCreationAndCancellation(t *testing.T) {
+	parent := t.TempDir()
+	physical, err := filepath.EvalSymlinks(parent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var workers sync.WaitGroup
+	results := make(chan moduleLLVMProbeInput, 16)
+	failures := make(chan error, 16)
+	for index := 0; index < 16; index++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			input, err := prepareModuleLLVMProbeSource(context.Background(), filepath.Join(parent, "scope"))
+			if err != nil {
+				failures <- err
+			} else {
+				results <- input
+			}
+		}()
+	}
+	workers.Wait()
+	close(results)
+	close(failures)
+	for err := range failures {
+		t.Error(err)
+	}
+	for input := range results {
+		if input.source.Path != filepath.Join(physical, ".llvm-loader-source", "main.go") || input.verify(context.Background()) != nil {
+			t.Fatal("parallel creator observed incomplete/foreign source", input.source)
+		}
+	}
+	files, err := os.ReadDir(filepath.Join(parent, ".llvm-loader-source"))
+	if err != nil || len(files) != 1 || files[0].Name() != "main.go" {
+		t.Fatalf("creator staging ownership did not close: %v %v", files, err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, err := prepareModuleLLVMProbeSource(ctx, filepath.Join(parent, "cancelled")); !errors.Is(err, context.Canceled) {
+		t.Fatal("cancelled producer acquired a role", err)
+	}
+	input, err := prepareModuleLLVMProbeSource(context.Background(), filepath.Join(parent, "existing"))
+	if err != nil || !errors.Is(input.verify(ctx), context.Canceled) || input.verify(context.Background()) != nil {
+		t.Fatal("cancellation deleted or changed another producer's source role", err)
+	}
+	empty := t.TempDir()
+	if _, err := prepareModuleLLVMProbeSource(ctx, filepath.Join(empty, "cancelled")); !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+	files, err = os.ReadDir(empty)
+	if err != nil || len(files) != 0 {
+		t.Fatal("cancelled first creator wrote artifacts", files, err)
+	}
+}
+
+func TestModuleLLVMProbeSourceRejectsForeignAndReplacedRoles(t *testing.T) {
+	for _, name := range []string{"parent-file", "parent-symlink", "directory-file", "directory-symlink", "source-directory", "source-symlink", "different-bytes", "oversized-prefix"} {
+		t.Run(name, func(t *testing.T) {
+			var err error
+			container := t.TempDir()
+			parent := filepath.Join(container, "parent")
+			foreign := t.TempDir()
+			if name == "parent-file" {
+				if err := os.WriteFile(parent, []byte("foreign parent"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			} else if name == "parent-symlink" {
+				if err := os.Symlink(foreign, parent); err != nil {
+					t.Fatal(err)
+				}
+			} else {
+				if err := os.Mkdir(parent, 0700); err != nil {
+					t.Fatal(err)
+				}
+				directory := filepath.Join(parent, ".llvm-loader-source")
+				if name == "directory-file" {
+					if err := os.WriteFile(directory, []byte("foreign directory"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				} else if name == "directory-symlink" {
+					if err := os.Symlink(foreign, directory); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					if err := os.Mkdir(directory, 0700); err != nil {
+						t.Fatal(err)
+					}
+					source := filepath.Join(directory, "main.go")
+					switch name {
+					case "source-directory":
+						err = os.Mkdir(source, 0700)
+					case "source-symlink":
+						err = os.Symlink(filepath.Join(foreign, "main.go"), source)
+					case "different-bytes":
+						err = os.WriteFile(source, []byte("package foreign\n"), 0600)
+					case "oversized-prefix":
+						err = os.WriteFile(source, []byte(moduleLLVMLoaderProbe+"x"), 0600)
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			if _, err := prepareModuleLLVMProbeSource(context.Background(), filepath.Join(parent, "before")); err == nil {
+				t.Fatal("foreign source role acquired producer authority")
+			}
+			files, err := os.ReadDir(foreign)
+			if err != nil || len(files) != 0 {
+				t.Fatal("rejected alias mutated foreign directory", files, err)
+			}
+		})
+	}
+	parent := t.TempDir()
+	input, err := prepareModuleLLVMProbeSource(context.Background(), filepath.Join(parent, "before"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(input.source.Path, input.source.Path+".original"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(input.source.Path, []byte(moduleLLVMLoaderProbe), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if input.verify(context.Background()) == nil {
+		t.Fatal("same-byte replacement changed the original compiled source identity")
+	}
+}
+
+type moduleLLVMProbeSwapContext struct {
+	context.Context
+	calls int
+	swap  func()
+}
+
+func (ctx *moduleLLVMProbeSwapContext) Err() error {
+	ctx.calls++
+	if ctx.calls == 2 {
+		ctx.swap()
+	}
+	return nil
+}
+
+func TestModuleLLVMProbeSourceCleanupRejectsReplacedDirectory(t *testing.T) {
+	for _, role := range []string{"directory", "same-byte-file"} {
+		t.Run(role, func(t *testing.T) {
+			parent := t.TempDir()
+			directory := filepath.Join(parent, ".llvm-loader-source")
+			var foreignStage, originalStage string
+			canary := []byte("another owner's closed temporary file\n")
+			if role == "same-byte-file" {
+				canary = []byte(moduleLLVMLoaderProbe)
+			}
+			ctx := &moduleLLVMProbeSwapContext{Context: context.Background()}
+			ctx.swap = func() {
+				entries, err := os.ReadDir(directory)
+				if err != nil || len(entries) != 1 || !strings.HasPrefix(entries[0].Name(), ".pending-") {
+					t.Fatalf("expected the creator's complete staged file: %v %v", entries, err)
+				}
+				foreignStage = filepath.Join(directory, entries[0].Name())
+				if role == "directory" {
+					if err := os.Rename(directory, directory+"-original"); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Mkdir(directory, 0700); err != nil {
+						t.Fatal(err)
+					}
+					originalStage = filepath.Join(directory+"-original", entries[0].Name())
+				} else {
+					originalStage = foreignStage + ".original"
+					if err := os.Rename(foreignStage, originalStage); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := os.WriteFile(foreignStage, canary, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if _, err := prepareModuleLLVMProbeSource(ctx, filepath.Join(parent, "before")); err == nil {
+				t.Error("replaced physical role acquired the producer authority")
+			}
+			actual, err := os.ReadFile(foreignStage)
+			if err != nil || !reflect.DeepEqual(actual, canary) {
+				t.Errorf("cleanup deleted or changed another owner's same-named temporary: %q %v", actual, err)
+			}
+			if _, err := os.Lstat(filepath.Join(directory, "main.go")); !os.IsNotExist(err) {
+				t.Error("replaced role published a foreign main.go", err)
+			}
+			// An unprovable moved path is quarantined, not rediscovered or
+			// recursively cleaned. This test owns and retires the whole tree.
+			actual, err = os.ReadFile(originalStage)
+			if err != nil || string(actual) != moduleLLVMLoaderProbe {
+				t.Fatal("the original closed temporary was changed", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/module_root_partition_cli_unix_test.go b/cmd/plan9asmtest/module_root_partition_cli_unix_test.go
new file mode 100644
index 000000000..69d3abac7
--- /dev/null
+++ b/cmd/plan9asmtest/module_root_partition_cli_unix_test.go
@@ -0,0 +1,178 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Use the actual CLI and an actual first-party main module. Invalid split
+// requests must fail at role validation, not because the flags are absent or
+// a missing LLVM/Node/source input happens to stop execution later.
+func TestModuleRootPartitionCLIRejectsInvalidRolesBeforeIO(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleFixture(t, false)
+	cases := []struct {
+		name string
+		args []string
+	}{
+		{"missing-part", []string{"-module", "-module-owner=0", "-module-root-partitions=8"}},
+		{"out-of-range", []string{"-module", "-module-owner=0", "-module-root-partitions=8", "-module-root-partition=8"}},
+		{"profile-part", []string{"-module", "-module-owner=1", "-module-root-partitions=8", "-module-root-partition=0"}},
+		{"other-part", []string{"-module", "-module-owner=2", "-module-root-partitions=8", "-module-root-partition=0"}},
+		{"ordinary-part", []string{"-module-root-partitions=8", "-module-root-partition=0"}},
+		{"local-part", []string{"-module", "-module-root-partitions=8", "-module-root-partition=0"}},
+		{"aggregate-part", []string{"-module", "-verify-module=missing", "-module-root-partitions=8", "-module-root-partition=0"}},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			out := filepath.Join(t.TempDir(), "must-not-exist")
+			stem := filepath.Join(t.TempDir(), "cli")
+			args := append([]string(nil), test.args...)
+			args = append(args, "-dir", dir, "-out", out, "-shards=32", "-workers=2", "-timeout=2m")
+			_, err := captureCommand(context.Background(), 30*time.Second, ".", binary, args, stem)
+			stderr, readErr := os.ReadFile(stem + ".stderr")
+			if err == nil || err.Error() != "exit status 1" || readErr != nil || !strings.Contains(string(stderr), "root partition scheduling") {
+				t.Fatalf("actual invalid role did not reach explicit split validation: %v, read=%v\n%s", err, readErr, stderr)
+			}
+			if strings.Contains(string(stderr), "flag provided but not defined") {
+				t.Fatalf("missing CLI grammar, not the requested role guard:\n%s", stderr)
+			}
+			if _, err := os.Lstat(out); !os.IsNotExist(err) {
+				t.Fatalf("invalid scheduling role performed output IO: %v", err)
+			}
+		})
+	}
+}
+
+// One independent first-party Test root per ordinary hash shard. The selector
+// denominator comes from real Go -list output, not a checked-in library list.
+func moduleRootPartitionFixture(t *testing.T) string {
+	t.Helper()
+	return moduleRootPartitionFixtureForShards(t, 32)
+}
+
+func moduleRootPartitionFixtureForShards(t *testing.T, shards int) string {
+	t.Helper()
+	if shards != 8 && shards != 32 && shards != 64 {
+		t.Fatal("first-party witness fixture requires a complete 8-, 32- or 64-shard plan")
+	}
+	dir := moduleFixture(t, false)
+	path := filepath.Join(dir, "value_test.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := make([]bool, shards)
+	remaining := len(seen)
+	for candidate := 0; remaining != 0; candidate++ {
+		if candidate >= 4096 {
+			t.Fatal("bounded first-party witnesses did not fill the complete shard plan", shards)
+		}
+		name := fmt.Sprintf("TestRootShardWitness%d", candidate)
+		hash := sha256.Sum256([]byte(name))
+		index := binary.BigEndian.Uint64(hash[:8]) % uint64(len(seen))
+		if seen[index] {
+			continue
+		}
+		seen[index] = true
+		remaining--
+		source = append(source, []byte(fmt.Sprintf(
+			"\nfunc %s(t *testing.T) { t.Run(\"child\", func(t *testing.T) { if Value() != 7 { t.Fatal(\"value\") } }) }\n", name))...)
+	}
+	if err := os.WriteFile(path, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	return dir
+}
+
+// Catch witness-generation mistakes without first executing every owner. The
+// complete CLI union below still independently lists and executes these roots.
+func TestModuleRootPartitionWitnessFixturesFillEveryShard(t *testing.T) {
+	for _, shards := range []int{8, 32, 64} {
+		t.Run(fmt.Sprint(shards), func(t *testing.T) {
+			dir := moduleRootPartitionFixtureForShards(t, shards)
+			syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join(dir, "value_test.go"), nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			seen := make([]int, shards)
+			for _, declaration := range syntax.Decls {
+				function, ok := declaration.(*ast.FuncDecl)
+				if !ok || !strings.HasPrefix(function.Name.Name, "TestRootShardWitness") {
+					continue
+				}
+				hash := sha256.Sum256([]byte(function.Name.Name))
+				seen[binary.BigEndian.Uint64(hash[:8])%uint64(shards)]++
+			}
+			for shard, count := range seen {
+				if count != 1 {
+					t.Fatal("each actual shard needs its own complete witness", shard, count)
+				}
+			}
+		})
+	}
+}
+
+func TestModuleRootPartitionCLIActualOwnedSubset(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleRootPartitionFixture(t)
+	out := filepath.Join(t.TempDir(), "fragment")
+	stem := filepath.Join(t.TempDir(), "cli")
+	_, err := captureCommand(context.Background(), 3*time.Minute, ".", binary,
+		[]string{"-module", "-module-owner=0", "-module-root-partitions=8", "-module-root-partition=0",
+			"-dir", dir, "-out", out, "-shards=32", "-workers=2", "-timeout=2m", "--", "-p=1"}, stem)
+	if err != nil {
+		t.Fatal(errorsWithActualOutput(err, stem))
+	}
+	var report struct {
+		Schema int    `json:"schema"`
+		Status string `json:"status"`
+		Part   struct {
+			Protocol string `json:"protocol"`
+			Index    int    `json:"index"`
+			Count    int    `json:"count"`
+		} `json:"root_partition"`
+		Names  []string      `json:"inventory"`
+		Shards []shardResult `json:"shards"`
+	}
+	data, err := os.ReadFile(filepath.Join(out, "package-0000", "partition.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The partial receipt cannot be accepted as an ordinary complete pass.
+	if err := json.Unmarshal(data, &report); err != nil || report.Schema != 2 || report.Status != "completed_owned" ||
+		report.Part.Protocol != "actual_go_root_shard_fragment_v1" || report.Part.Index != 0 || report.Part.Count != 8 ||
+		len(report.Names) != 36 || len(report.Shards) != 32 {
+		t.Fatalf("partial plan lost full inventory/identity: %s (%v)", data, err)
+	}
+	for index, shard := range report.Shards {
+		if shard.Index != index {
+			t.Fatalf("global shard index was renumbered: %+v", shard)
+		}
+		if index%8 == 0 {
+			if shard.Status != "passed" || len(shard.Outcomes) == 0 || len(shard.Command) == 0 {
+				t.Fatalf("assigned shard was not executed: %+v", shard)
+			}
+		} else if shard.Status != "not_owned" || len(shard.Outcomes) != 0 || len(shard.Command) != 0 {
+			t.Fatalf("foreign shard gained execution or pass: %+v", shard)
+		}
+	}
+	if _, err := os.Lstat(filepath.Join(out, "package-0000", "report.json")); !os.IsNotExist(err) {
+		t.Fatalf("partial execution masquerades as schema-1 complete suite: %v", err)
+	}
+}
diff --git a/cmd/plan9asmtest/module_root_plan.go b/cmd/plan9asmtest/module_root_plan.go
new file mode 100644
index 000000000..5738e3067
--- /dev/null
+++ b/cmd/plan9asmtest/module_root_plan.go
@@ -0,0 +1,131 @@
+package main
+
+import "fmt"
+
+const moduleRootFragmentProtocol = "actual_go_root_shard_fragment_v1"
+
+func validateModuleReportScheduling(report moduleReport) error {
+	if report.Protocol == moduleProtocol {
+		if report.RootPartitions != 0 || report.RootPartition != nil || report.RootInventory != nil {
+			return fmt.Errorf("legacy module report contains partial scheduling")
+		}
+		return nil
+	}
+	if report.Protocol != moduleRootPartsProtocol || report.RootPartitions < 2 {
+		return fmt.Errorf("unknown module scheduling protocol")
+	}
+	if report.Owner != -1 && report.RootInventory != nil {
+		return fmt.Errorf("producer report cannot supply the aggregate's fresh inventory")
+	}
+	cfg := config{Module: true, Package: ".", CIOwner: -1, ModuleOwner: report.Owner,
+		Shards: report.Shards, ModuleRootPartitions: report.RootPartitions, ModuleRootPartition: -1}
+	if report.RootPartition != nil {
+		cfg.ModuleRootPartition = *report.RootPartition
+	}
+	if report.Owner == -1 {
+		cfg.ModuleVerify = "aggregate-observation"
+	}
+	return validateModuleRootScheduling(cfg)
+}
+
+// This is scheduling metadata, not executable proof or native authority.
+type moduleRootPart struct {
+	Protocol string `json:"protocol"`
+	Index    int    `json:"index"`
+	Count    int    `json:"count"`
+}
+
+func (part moduleRootPart) owns(index int, fullPackage bool) bool {
+	if fullPackage {
+		// Actual benchmark-only/TestMain and no-test package roles execute
+		// once without a filter, regardless of the requested shard count.
+		return index == 0 && part.Index == 0
+	}
+	return index%part.Count == part.Index
+}
+
+func suiteReportName(cfg config) string {
+	if cfg.rootPart != nil {
+		return "partition.json"
+	}
+	return "report.json"
+}
+
+func suiteExpectedRoots(report suiteReport) int {
+	if report.RootPart == nil {
+		return len(report.Names)
+	}
+	count := 0
+	for _, shard := range report.Shards {
+		if report.RootPart.owns(shard.Index, report.FullPackage) {
+			count += len(shard.Names)
+		}
+	}
+	return count
+}
+
+func suiteCompletionStatus(report suiteReport) string {
+	if report.RootPart == nil {
+		return "passed"
+	}
+	for _, shard := range report.Shards {
+		if len(shard.Command) != 0 {
+			return "completed_owned"
+		}
+	}
+	return "completed_empty"
+}
+
+// A subordinate scheduling role, never a test selector or a package admission.
+// The complete module owner numbers and selected-native protocol stay intact.
+func validateModuleRootScheduling(cfg config) error {
+	fail := func() error {
+		return fmt.Errorf("root partition scheduling requires an explicit module root part or exhaustive aggregate, with unchanged package ownership")
+	}
+	if cfg.ModuleRootPartitions < 1 || cfg.ModuleRootPartitions > cfg.Shards {
+		return fail()
+	}
+	if cfg.ModuleRootPartitions == 1 {
+		if cfg.ModuleRootPartition != -1 {
+			return fail()
+		}
+		return nil
+	}
+	if !cfg.Module || cfg.Package != "." || cfg.CISelector != "" || cfg.CIIsolate != "" ||
+		cfg.CIVerify != "" || cfg.CIOwner != -1 {
+		return fail()
+	}
+	if cfg.ModuleVerify != "" {
+		if cfg.ModuleOwner != -1 || cfg.ModuleRootPartition != -1 {
+			return fail()
+		}
+		return nil
+	}
+	switch cfg.ModuleOwner {
+	case 0:
+		if cfg.ModuleRootPartition < 0 || cfg.ModuleRootPartition >= cfg.ModuleRootPartitions {
+			return fail()
+		}
+	case 1, 2:
+		if cfg.ModuleRootPartition != -1 {
+			return fail()
+		}
+	default:
+		return fail()
+	}
+	return nil
+}
+
+// Reuse the ordinary name-to-shard plan unchanged. Parts own whole global
+// shard indices, so child/seed terminals cannot move between CI jobs.
+func moduleRootShardParts(shards, parts int) ([][]int, error) {
+	if shards < 1 || shards > 1024 || parts < 1 || parts > shards {
+		return nil, fmt.Errorf("root partition scheduling requires 1..1024 shards and 1..shards parts")
+	}
+	result := make([][]int, parts)
+	for index := 0; index < shards; index++ {
+		part := index % parts
+		result[part] = append(result[part], index)
+	}
+	return result, nil
+}
diff --git a/cmd/plan9asmtest/module_root_plan_test.go b/cmd/plan9asmtest/module_root_plan_test.go
new file mode 100644
index 000000000..64a170e34
--- /dev/null
+++ b/cmd/plan9asmtest/module_root_plan_test.go
@@ -0,0 +1,109 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestModuleRootShardPartsAreExhaustiveAndDisjoint(t *testing.T) {
+	for _, shards := range []int{32, 64} {
+		counts := []int{1, 3, 8, 16, 32}
+		if shards == 64 {
+			counts = append(counts, 64)
+		}
+		for _, count := range counts {
+			parts, err := moduleRootShardParts(shards, count)
+			if err != nil || len(parts) != count {
+				t.Fatalf("%d/%d plan: %v %v", shards, count, parts, err)
+			}
+			seen := make([]int, shards)
+			for part, indices := range parts {
+				if len(indices) == 0 {
+					t.Fatalf("part %d has no global shard indices", part)
+				}
+				for _, index := range indices {
+					if index < 0 || index >= shards || index%count != part {
+						t.Fatalf("part %d obtained foreign shard %d", part, index)
+					}
+					seen[index]++
+				}
+			}
+			for index, owners := range seen {
+				if owners != 1 {
+					t.Fatalf("shard %d has %d owners", index, owners)
+				}
+			}
+			if shards == 32 && count == 8 && !reflect.DeepEqual(parts[0], []int{0, 8, 16, 24}) {
+				t.Fatalf("CI root part zero changed original shard indices: %v", parts[0])
+			}
+			if count == 16 {
+				want := []int{1, 17}
+				if shards == 64 {
+					want = append(want, 33, 49)
+				}
+				if !reflect.DeepEqual(parts[1], want) {
+					t.Fatalf("root part changed its complete shard ownership: %v", parts[1])
+				}
+			}
+		}
+	}
+	for _, invalid := range [][2]int{{0, 1}, {1025, 1}, {32, 0}, {32, -1}, {32, 33}} {
+		if _, err := moduleRootShardParts(invalid[0], invalid[1]); err == nil {
+			t.Fatalf("invalid scheduling accepted: %v", invalid)
+		}
+	}
+}
+
+func TestModuleRootSchedulingRolesStaySeparate(t *testing.T) {
+	base := config{Package: ".", Module: true, ModuleOwner: 0, CIOwner: -1,
+		Shards: 32, ModuleRootPartitions: 8, ModuleRootPartition: 0}
+	for _, owner := range []int{0, 1, 2, -1} {
+		cfg := base
+		cfg.ModuleOwner = owner
+		if owner != 0 {
+			cfg.ModuleRootPartition = -1
+		}
+		if owner == -1 {
+			cfg.ModuleVerify = "original-artifacts"
+		}
+		if err := validateModuleRootScheduling(cfg); err != nil {
+			t.Fatalf("registered module role %d: %v", owner, err)
+		}
+	}
+	for part := 0; part < 8; part++ {
+		cfg := base
+		cfg.ModuleRootPartition = part
+		if err := validateModuleRootScheduling(cfg); err != nil {
+			t.Fatalf("root part %d: %v", part, err)
+		}
+	}
+	for _, change := range []func(*config){
+		func(c *config) { c.Module = false },
+		func(c *config) { c.Package = "foreign/package" },
+		func(c *config) { c.ModuleOwner = 1 },
+		func(c *config) { c.ModuleOwner = 2 },
+		func(c *config) { c.ModuleOwner = -1 },
+		func(c *config) { c.ModuleOwner = 3 },
+		func(c *config) { c.ModuleRootPartitions = 0 },
+		func(c *config) { c.ModuleRootPartitions = 33 },
+		func(c *config) { c.ModuleRootPartition = -1 },
+		func(c *config) { c.ModuleRootPartition = 8 },
+		func(c *config) { c.ModuleVerify = "artifacts" },
+		func(c *config) { c.CISelector = "^TestNative$" },
+		func(c *config) { c.CIIsolate = "TestNative" },
+		func(c *config) { c.CIVerify = "native-artifacts" },
+		func(c *config) { c.CIOwner = 0 },
+	} {
+		cfg := base
+		change(&cfg)
+		if err := validateModuleRootScheduling(cfg); err == nil {
+			t.Fatalf("unregistered/mixed partial role accepted: %+v", cfg)
+		}
+	}
+	legacy := base
+	legacy.ModuleRootPartitions, legacy.ModuleRootPartition = 1, -1
+	legacy.Module, legacy.ModuleOwner = false, -1
+	if err := validateModuleRootScheduling(legacy); err != nil {
+		t.Fatalf("default ordinary role changed: %v", err)
+	}
+}
diff --git a/cmd/plan9asmtest/module_root_union_unix_test.go b/cmd/plan9asmtest/module_root_union_unix_test.go
new file mode 100644
index 000000000..884ecb3b0
--- /dev/null
+++ b/cmd/plan9asmtest/module_root_union_unix_test.go
@@ -0,0 +1,590 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func runRootSplitFixture(t *testing.T, binary, dir, out, inputs, profile string, owner, part, count int, race bool) {
+	t.Helper()
+	runRootSplitFixtureWithShards(t, binary, dir, out, inputs, profile, owner, part, count, 64, race)
+}
+
+func runRootSplitFixtureWithShards(t *testing.T, binary, dir, out, inputs, profile string, owner, part, count, shards int, race bool) {
+	t.Helper()
+	args := []string{"-module", fmt.Sprintf("-module-root-partitions=%d", count), "-dir", dir, "-out", out,
+		fmt.Sprintf("-shards=%d", shards), "-workers=2", "-timeout=2m"}
+	if inputs != "" {
+		args = append(args, "-verify-module", inputs)
+	} else {
+		args = append(args, fmt.Sprintf("-module-owner=%d", owner), fmt.Sprintf("-module-root-partition=%d", part))
+	}
+	args = append(args, "--", "-p=1")
+	if race {
+		args = append(args, "-race")
+	}
+	if profile != "" {
+		args = append(args, "-covermode=atomic", "-coverprofile="+profile)
+	}
+	stem := filepath.Join(t.TempDir(), "cli")
+	if _, err := captureCommand(context.Background(), 3*time.Minute, ".", binary, args, stem); err != nil {
+		t.Fatal(errorsWithActualOutput(err, stem))
+	}
+}
+
+func TestLinuxCLIRootPartsActualCompleteModuleUnion(t *testing.T) {
+	for _, coverage := range []bool{false, true} {
+		t.Run(fmt.Sprintf("coverage-%t", coverage), func(t *testing.T) {
+			moduleFixtureEnvironment(t)
+			binary := parallelFixtureCLI(t)
+			dir := moduleRootPartitionFixtureForShards(t, 8)
+			inputs := t.TempDir()
+			if err := os.Mkdir(filepath.Join(inputs, "owner-0000"), 0700); err != nil {
+				t.Fatal(err)
+			}
+			profile := ""
+			if coverage {
+				profile = filepath.Join(t.TempDir(), "complete.cover")
+			}
+			for part := 0; part < 4; part++ {
+				out := filepath.Join(inputs, "owner-0000", fmt.Sprintf("part-%04d", part))
+				runRootSplitFixtureWithShards(t, binary, dir, out, "", profile, 0, part, 4, 8, false)
+			}
+			for owner := 1; owner < moduleOwners; owner++ {
+				out := filepath.Join(inputs, fmt.Sprintf("owner-%04d", owner))
+				runRootSplitFixtureWithShards(t, binary, dir, out, "", profile, owner, -1, 4, 8, false)
+			}
+			if coverage {
+				if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+					t.Fatalf("fragment published incomplete module coverage: %v", err)
+				}
+			}
+			verified := filepath.Join(t.TempDir(), "verified")
+			runRootSplitFixtureWithShards(t, binary, dir, verified, inputs, profile, -1, -1, 4, 8, false)
+			var expected moduleReport
+			if err := ciReadJSON(filepath.Join(verified, "module.json"), &expected); err != nil {
+				t.Fatal(err)
+			}
+			if expected.Status != "passed" || expected.Protocol != moduleRootPartsProtocol ||
+				expected.RootPartitions != 4 || expected.Shards != 8 || expected.Workers != 2 ||
+				expected.RootInventory == nil || len(expected.RootInventory.Names) != 12 || len(expected.Packages) != 5 {
+				t.Fatalf("Linux CLI layout lost complete root/profile/rest inventory: %+v", expected)
+			}
+			if _, err := checkedModuleArtifacts(expected, inputs); err != nil {
+				t.Fatal(err)
+			}
+			if coverage {
+				data, err := os.ReadFile(profile)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, name := range []string{"modulefixture/value.go:", "modulefixture/gotoolprofile/value.go:",
+					"modulefixture/internal/other/value.go:"} {
+					if !strings.Contains(string(data), name) {
+						t.Fatal("complete coverage lost actual module package", name)
+					}
+				}
+			}
+			for _, relative := range []string{"owner-0001", "owner-0002", "owner-0000/part-0000",
+				"owner-0000/part-0001", "owner-0000/part-0002", "owner-0000/part-0003",
+				"owner-0000/part-0000/package-0000/shard-0000.stdout"} {
+				t.Run("missing-"+relative, func(t *testing.T) {
+					original := filepath.Join(inputs, filepath.FromSlash(relative))
+					backup := filepath.Join(t.TempDir(), "retained")
+					if err := os.Rename(original, backup); err != nil {
+						t.Fatal(err)
+					}
+					t.Cleanup(func() {
+						if err := os.Rename(backup, original); err != nil {
+							t.Error(err)
+						}
+					})
+					rootSplitRequireRejected(t, expected, inputs)
+				})
+			}
+			for _, change := range []func(*moduleReport){
+				func(r *moduleReport) { r.Shards = 64 },
+				func(r *moduleReport) { r.RootPartitions = 8 },
+				func(r *moduleReport) { r.Flags = append(r.Flags, "-race") },
+				func(r *moduleReport) { r.Scope.SourceSHA = strings.Repeat("0", 64) },
+			} {
+				changed := expected
+				change(&changed)
+				rootSplitRequireRejected(t, changed, inputs)
+			}
+		})
+	}
+}
+
+func rootSplitRetainFile(t *testing.T, path string) []byte {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := os.WriteFile(path, data, 0600); err != nil {
+			t.Error(err)
+		}
+	})
+	return data
+}
+
+func rootSplitRequireRejected(t *testing.T, expected moduleReport, inputs string) {
+	t.Helper()
+	if _, err := checkedModuleArtifacts(expected, inputs); err == nil {
+		t.Fatal("incomplete/foreign evidence became a complete module pass")
+	}
+}
+
+func TestModuleRootPartitionActualCompleteUnionAndCoverage(t *testing.T) {
+	rootSplitCompleteUnionAndCoverage(t, 16, false)
+}
+
+func TestRaceRootPartitionActualCompleteUnionAndCoverage(t *testing.T) {
+	rootSplitCompleteUnionAndCoverage(t, 32, true)
+}
+
+func rootSplitCompleteUnionAndCoverage(t *testing.T, parts int, race bool) {
+	t.Helper()
+	rootSplitCompleteUnionLayout(t, parts, 64, race, true)
+}
+
+func TestUnixRootPartitionActualCompleteUnionAndCoverage(t *testing.T) {
+	for _, coverage := range []bool{false, true} {
+		t.Run(fmt.Sprintf("coverage-%t", coverage), func(t *testing.T) {
+			rootSplitCompleteUnionLayout(t, 16, 32, false, coverage)
+		})
+	}
+}
+
+func rootSplitCompleteUnionLayout(t *testing.T, parts, shards int, race, coverage bool) {
+	t.Helper()
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleRootPartitionFixtureForShards(t, shards)
+	// Every layout replays the complete independently enumerated source roles.
+	// receipt transport, not instruction execution; those oracles stay separate.
+	file := filepath.Join(dir, "value_test.go")
+	source, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	heavyNames := heavyObjectNames(heavyObjectSourceFamilies(t))
+	for _, name := range heavyNames {
+		source = append(source, []byte(fmt.Sprintf("\nfunc %s(t *testing.T) { t.Run(\"owner-child\", func(t *testing.T) { if Value() != 7 { t.Fatal(\"value\") } }) }\n", name))...)
+	}
+	if err := os.WriteFile(file, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	wantRoots := shards + 4 + len(heavyNames)
+	inputs := t.TempDir()
+	if err := os.Mkdir(filepath.Join(inputs, "owner-0000"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	profile := ""
+	if coverage {
+		profile = filepath.Join(t.TempDir(), "whole.cover")
+	}
+	for part := 0; part < parts; part++ {
+		out := filepath.Join(inputs, "owner-0000", fmt.Sprintf("part-%04d", part))
+		runRootSplitFixtureWithShards(t, binary, dir, out, "", profile, 0, part, parts, shards, race)
+	}
+	for owner := 1; owner < moduleOwners; owner++ {
+		out := filepath.Join(inputs, fmt.Sprintf("owner-%04d", owner))
+		runRootSplitFixtureWithShards(t, binary, dir, out, "", profile, owner, -1, parts, shards, race)
+	}
+	if coverage {
+		if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+			t.Fatalf("an owner published partial uploadable module coverage: %v", err)
+		}
+	}
+	verified := filepath.Join(t.TempDir(), "aggregate")
+	runRootSplitFixtureWithShards(t, binary, dir, verified, inputs, profile, -1, -1, parts, shards, race)
+	var expected moduleReport
+	if err := ciReadJSON(filepath.Join(verified, "module.json"), &expected); err != nil {
+		t.Fatal(err)
+	}
+	if expected.Protocol != moduleRootPartsProtocol || expected.Status != "passed" || expected.RootPartitions != parts ||
+		expected.RootInventory == nil || len(expected.RootInventory.Names) != wantRoots || len(expected.Packages) != 5 ||
+		expected.Shards != shards || expected.Workers != 2 || expected.Packages[0].Shards != shards {
+		t.Fatalf("complete fresh denominator/package union lost: %+v", expected)
+	}
+	if coverage {
+		data, err := os.ReadFile(profile)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{"modulefixture/value.go:", "modulefixture/gotoolprofile/value.go:", "modulefixture/internal/other/value.go:"} {
+			if !strings.Contains(string(data), name) {
+				t.Fatalf("complete module coverage lost %s: %s", name, data)
+			}
+		}
+	}
+	if _, err := os.Lstat(filepath.Join(verified, "root-inventory.stdout")); err != nil {
+		t.Fatalf("aggregate did not retain its own real complete root list: %v", err)
+	}
+	results, err := checkedModuleArtifacts(expected, inputs)
+	wantProfiles := 0
+	if coverage {
+		wantProfiles = shards
+	}
+	if err != nil || len(results) != 5 || len(results[0].rootCoverage) != wantProfiles {
+		t.Fatalf("independent full raw-shard replay: %+v %v", results, err)
+	}
+
+	partPath := filepath.Join(inputs, "owner-0000", "part-0000")
+	modulePath := filepath.Join(partPath, "module.json")
+	var original moduleReport
+	if err := ciReadJSON(modulePath, &original); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func(*moduleReport)
+	}{
+		{"part", func(r *moduleReport) { value := 1; r.RootPartition = &value }},
+		{"count", func(r *moduleReport) { r.RootPartitions = 7 }},
+		{"previous-eight-owner-plan", func(r *moduleReport) { r.RootPartitions = 8 }},
+		{"owner", func(r *moduleReport) { r.Owner = 1 }},
+		{"legacy", func(r *moduleReport) { r.Protocol = moduleProtocol }},
+		{"failed", func(r *moduleReport) { r.Status = "failed" }},
+		{"budget", func(r *moduleReport) { r.Timeout = "3m0s" }},
+		{"workers", func(r *moduleReport) { r.Workers = 3 }},
+		{"flags", func(r *moduleReport) { r.Flags = append(r.Flags, "-race=false") }},
+		{"source", func(r *moduleReport) { r.Scope.SourceSHA = strings.Repeat("0", 64) }},
+		{"sdk", func(r *moduleReport) { r.Scope.SDKSource = strings.Repeat("0", 64) }},
+		{"tools", func(r *moduleReport) { r.Scope.Tools["go"] = strings.Repeat("0", 64) }},
+		{"environment", func(r *moduleReport) { r.Scope.Environment["GOGCCFLAGS"] += " -Dforeign" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			var changed moduleReport
+			if err := ciReadJSON(modulePath, &changed); err != nil {
+				t.Fatal(err)
+			}
+			test.mutate(&changed)
+			if err := ciWriteJSON(modulePath, changed); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := ciWriteJSON(modulePath, original); err != nil {
+					t.Error(err)
+				}
+			})
+			if _, err := checkedModuleArtifacts(expected, inputs); err == nil {
+				t.Fatal("incomplete/foreign root fragment became a full module pass")
+			}
+		})
+	}
+	for _, suffix := range []string{"partition.json", "shard-0000.stdout", "shard-0000.cover"} {
+		if !coverage && strings.HasSuffix(suffix, ".cover") {
+			continue
+		}
+		t.Run("missing-"+suffix, func(t *testing.T) {
+			path := filepath.Join(partPath, "package-0000", suffix)
+			backup := filepath.Join(t.TempDir(), "retained")
+			if err := os.Rename(path, backup); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := os.Rename(backup, path); err != nil {
+					t.Error(err)
+				}
+			})
+			if _, err := checkedModuleArtifacts(expected, inputs); err == nil {
+				t.Fatal("missing original report/raw terminal/profile became pass")
+			}
+		})
+	}
+	t.Run("missing-whole-part", func(t *testing.T) {
+		backup := filepath.Join(t.TempDir(), "retained")
+		if err := os.Rename(partPath, backup); err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(func() {
+			if err := os.Rename(backup, partPath); err != nil {
+				t.Error(err)
+			}
+		})
+		if _, err := checkedModuleArtifacts(expected, inputs); err == nil {
+			t.Fatal("missing whole root part became pass")
+		}
+	})
+	packagePath := filepath.Join(partPath, "package-0000")
+	if parts == 16 && shards == 32 {
+		for _, relative := range []string{"owner-0001", "owner-0002", "owner-0000/part-0008", "owner-0000/part-0015"} {
+			t.Run("missing-new-layout-"+relative, func(t *testing.T) {
+				path := filepath.Join(inputs, filepath.FromSlash(relative))
+				backup := filepath.Join(t.TempDir(), "retained")
+				if err := os.Rename(path, backup); err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.Rename(backup, path); err != nil {
+						t.Error(err)
+					}
+				})
+				rootSplitRequireRejected(t, expected, inputs)
+			})
+		}
+		t.Run("previous-eight-owner-shard-fragment", func(t *testing.T) {
+			file := filepath.Join(packagePath, "partition.json")
+			rootSplitRetainFile(t, file)
+			var changed suiteReport
+			if err := ciReadJSON(file, &changed); err != nil {
+				t.Fatal(err)
+			}
+			changed.RootPart.Count = 8
+			if err := ciWriteJSON(file, changed); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+	}
+	if race {
+		t.Run("foreign-package-instrumentation", func(t *testing.T) {
+			file := filepath.Join(packagePath, "partition.json")
+			rootSplitRetainFile(t, file)
+			var changed suiteReport
+			if err := ciReadJSON(file, &changed); err != nil {
+				t.Fatal(err)
+			}
+			changed.Flags = append(changed.Flags, "-race=false")
+			if err := ciWriteJSON(file, changed); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+		t.Run("previous-race-owner-count", func(t *testing.T) {
+			rootSplitRetainFile(t, modulePath)
+			var changed moduleReport
+			if err := ciReadJSON(modulePath, &changed); err != nil {
+				t.Fatal(err)
+			}
+			changed.RootPartitions = 16
+			if err := ciWriteJSON(modulePath, changed); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+		t.Run("previous-unbalanced-hash-plan", func(t *testing.T) {
+			file := filepath.Join(packagePath, "partition.json")
+			rootSplitRetainFile(t, file)
+			var changed suiteReport
+			if err := ciReadJSON(file, &changed); err != nil {
+				t.Fatal(err)
+			}
+			legacy := make([][]string, 64)
+			for _, name := range changed.Names {
+				index := independentHashShard(name, 64)
+				legacy[index] = append(legacy[index], name)
+			}
+			for index := range changed.Shards {
+				changed.Shards[index].Names = legacy[index]
+			}
+			if err := ciWriteJSON(file, changed); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+	}
+	for _, suffix := range []string{"module.json", filepath.Join("package-0000", "partition.json"),
+		filepath.Join("package-0000", "shard-0000.stdout")} {
+		t.Run("trailing-EOF-"+suffix, func(t *testing.T) {
+			path := filepath.Join(partPath, suffix)
+			data := rootSplitRetainFile(t, path)
+			if err := os.WriteFile(path, append(data, []byte("\n{}\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+	}
+	for _, name := range []string{"unowned-pass", "unowned-command", "unowned-terminal", "missing-child", "duplicate-index"} {
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(packagePath, "partition.json")
+			rootSplitRetainFile(t, path)
+			var suite suiteReport
+			if err := ciReadJSON(path, &suite); err != nil {
+				t.Fatal(err)
+			}
+			switch name {
+			case "unowned-pass":
+				suite.Shards[1].Status = "passed"
+			case "unowned-command":
+				suite.Shards[1].Command = append([]string(nil), suite.Shards[0].Command...)
+			case "unowned-terminal":
+				suite.Shards[1].Outcomes = map[string]string{suite.Shards[1].Names[0]: "pass"}
+			case "missing-child":
+				removed := false
+				for child := range suite.Shards[0].Outcomes {
+					if strings.Contains(child, "/") {
+						delete(suite.Shards[0].Outcomes, child)
+						removed = true
+						break
+					}
+				}
+				if !removed {
+					t.Fatal("actual first-party shard had no child terminal")
+				}
+			case "duplicate-index":
+				suite.Shards[8].Index = 0
+			}
+			if err := ciWriteJSON(path, suite); err != nil {
+				t.Fatal(err)
+			}
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+	}
+	t.Run("paired-list-and-plan-shrink", func(t *testing.T) {
+		// Both stored denominators change together; the independent aggregate
+		// list, not a producer's matching hash, must still reject the deletion.
+		path := filepath.Join(packagePath, "partition.json")
+		rootSplitRetainFile(t, path)
+		var suite suiteReport
+		if err := ciReadJSON(path, &suite); err != nil {
+			t.Fatal(err)
+		}
+		removed := suite.Names[0]
+		suite.Names = suite.Names[1:]
+		suite.InventorySHA = ciNamesSHA(suite.Names)
+		listingPath := filepath.Join(packagePath, "inventory.stdout")
+		listing := rootSplitRetainFile(t, listingPath)
+		listing = []byte(strings.Replace(string(listing), removed+"\n", "", 1))
+		if err := os.WriteFile(listingPath, listing, 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := ciWriteJSON(path, suite); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := checkedModuleArtifacts(expected, inputs); err == nil ||
+			!strings.Contains(err.Error(), "fresh complete root denominator") {
+			t.Fatalf("producer-paired deletion bypassed fresh denominator: %v", err)
+		}
+	})
+	for _, suffix := range []string{"stdout", "stderr", "cover"} {
+		t.Run("unowned-artifact-"+suffix, func(t *testing.T) {
+			path := filepath.Join(packagePath, "shard-0001."+suffix)
+			if err := os.WriteFile(path, []byte("foreign\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := os.Remove(path); err != nil {
+					t.Error(err)
+				}
+			})
+			rootSplitRequireRejected(t, expected, inputs)
+		})
+	}
+	t.Run("extra-part", func(t *testing.T) {
+		path := filepath.Join(inputs, "owner-0000", fmt.Sprintf("part-%04d", parts))
+		if err := os.Mkdir(path, 0700); err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(func() {
+			if err := os.Remove(path); err != nil {
+				t.Error(err)
+			}
+		})
+		rootSplitRequireRejected(t, expected, inputs)
+	})
+	if _, err := checkedModuleArtifacts(expected, inputs); err != nil {
+		t.Fatalf("independent controls changed original evidence: %v", err)
+	}
+}
+
+func TestModuleRootPartitionActualSparseAndEmptyPackageRoles(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	for _, role := range []string{"sparse", "benchmark", "no-test"} {
+		t.Run(role, func(t *testing.T) {
+			dir := moduleFixture(t, false)
+			path := filepath.Join(dir, "value_test.go")
+			if role == "no-test" {
+				if err := os.Remove(path); err != nil {
+					t.Fatal(err)
+				}
+			} else if role == "benchmark" {
+				source := `package fixture
+import ("flag"; "fmt"; "os"; "testing")
+func TestMain(m *testing.M) {
+    flag.Parse()
+    if flag.Lookup("test.list").Value.String() == "" {
+        fmt.Println("ROOT_UNFILTERED_EXECUTION")
+    }
+    os.Exit(m.Run())
+}
+func BenchmarkNotRun(b *testing.B) { b.Fatal("benchmark executed") }
+`
+				if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			inputs := t.TempDir()
+			if err := os.Mkdir(filepath.Join(inputs, "owner-0000"), 0700); err != nil {
+				t.Fatal(err)
+			}
+			executed, empty, passedRoots := 0, 0, 0
+			for part := 0; part < 8; part++ {
+				out := filepath.Join(inputs, "owner-0000", fmt.Sprintf("part-%04d", part))
+				runRootSplitFixture(t, binary, dir, out, "", "", 0, part, 8, false)
+				var suite suiteReport
+				if err := ciReadJSON(filepath.Join(out, "package-0000", "partition.json"), &suite); err != nil {
+					t.Fatal(err)
+				}
+				passedRoots += suite.RootPassed
+				if suite.Status == "completed_empty" {
+					empty++
+				}
+				for _, shard := range suite.Shards {
+					if len(shard.Command) == 0 {
+						continue
+					}
+					executed++
+					if role != "sparse" && (part != 0 || !suite.FullPackage || len(suite.Shards) != 1 ||
+						len(shard.Outcomes) != 0 || strings.Contains(strings.Join(shard.Command, " "), "-run=")) {
+						t.Fatalf("empty inventory gained filtered/foreign/named execution: %+v", suite)
+					}
+					if role == "benchmark" {
+						data, err := os.ReadFile(filepath.Join(out, "package-0000", "shard-0000.stdout"))
+						if err != nil || strings.Count(string(data), "ROOT_UNFILTERED_EXECUTION") != 1 {
+							t.Fatalf("part zero did not execute exactly one actual unfiltered TestMain: %v\n%s", err, data)
+						}
+					}
+				}
+				listing, err := os.ReadFile(filepath.Join(out, "package-0000", "inventory.stdout"))
+				if err != nil || strings.Contains(string(listing), "ROOT_UNFILTERED_EXECUTION") {
+					t.Fatalf("listing observation was mislabeled as execution: %v\n%s", err, listing)
+				}
+			}
+			if role == "sparse" {
+				if empty == 0 || executed > 4 || passedRoots != 4 {
+					t.Fatalf("sparse assignment fabricated execution: commands=%d empty=%d roots=%d", executed, empty, passedRoots)
+				}
+			} else if executed != 1 || empty != 7 || passedRoots != 0 {
+				t.Fatalf("empty package was executed repeatedly or invented test passes: commands=%d empty=%d roots=%d", executed, empty, passedRoots)
+			}
+			for owner := 1; owner < moduleOwners; owner++ {
+				out := filepath.Join(inputs, fmt.Sprintf("owner-%04d", owner))
+				runRootSplitFixture(t, binary, dir, out, "", "", owner, -1, 8, false)
+			}
+			out := filepath.Join(t.TempDir(), "aggregate")
+			runRootSplitFixture(t, binary, dir, out, inputs, "", -1, -1, 8, false)
+			var report moduleReport
+			if err := ciReadJSON(filepath.Join(out, "module.json"), &report); err != nil {
+				t.Fatal(err)
+			}
+			if report.Status != "passed" || report.RootInventory == nil ||
+				report.RootInventory.FullPackage != (role != "sparse") ||
+				report.RootInventory.NoTestFiles != (role == "no-test") {
+				t.Fatalf("fresh full-package role differs: %+v", report)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/module_root_verify.go b/cmd/plan9asmtest/module_root_verify.go
new file mode 100644
index 000000000..370941879
--- /dev/null
+++ b/cmd/plan9asmtest/module_root_verify.go
@@ -0,0 +1,230 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+)
+
+type moduleRootInventory struct {
+	Package      string   `json:"package"`
+	Names        []string `json:"inventory"`
+	Benchmarks   []string `json:"benchmarks_not_executed"`
+	InventorySHA string   `json:"inventory_sha256"`
+	NoTestFiles  bool     `json:"no_test_files"`
+	FullPackage  bool     `json:"full_package"`
+}
+
+func moduleRootPackage(packages []modulePackage) (modulePackage, int, error) {
+	for index, pkg := range packages {
+		if pkg.Directory == "." {
+			return pkg, index, nil
+		}
+	}
+	return modulePackage{}, 0, fmt.Errorf("split module requires an actual root package")
+}
+
+// The aggregate obtains its own complete root list, rather than accepting a
+// producer's stored list/hash as the denominator. No test roots execute here.
+func observeModuleRootInventory(ctx context.Context, cfg config, packages []modulePackage) (*moduleRootInventory, error) {
+	pkg, _, err := moduleRootPackage(packages)
+	if err != nil {
+		return nil, err
+	}
+	flags, profile, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return nil, err
+	}
+	if profile != "" {
+		flags = append(flags, "-cover")
+	}
+	args := append([]string{"test"}, flags...)
+	args = append(args, "-count=1", "-timeout="+cfg.Timeout.String(), "-list=.", pkg.Package)
+	stem := filepath.Join(cfg.Out, "root-inventory")
+	if _, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, args, stem); err != nil {
+		return nil, fmt.Errorf("fresh actual complete root list: %w", err)
+	}
+	data, err := os.ReadFile(stem + ".stdout")
+	if err != nil {
+		return nil, err
+	}
+	actual, names, benchmarks, err := parseSuiteList(string(data), true, pkg.NoTestFiles)
+	if err != nil || actual != pkg.Package {
+		return nil, fmt.Errorf("fresh actual complete root inventory differs: %v", err)
+	}
+	return &moduleRootInventory{actual, names, benchmarks, ciNamesSHA(names), pkg.NoTestFiles,
+		pkg.NoTestFiles || len(names) == 0}, nil
+}
+
+func exactModuleArtifactDirectories(directory string, wanted []string) error {
+	entries, err := os.ReadDir(directory)
+	if err != nil || len(entries) != len(wanted) {
+		return fmt.Errorf("missing/extra module scheduling directories: %v", err)
+	}
+	for index, name := range wanted {
+		if entries[index].Name() != name {
+			return fmt.Errorf("unknown module scheduling directory: %s", entries[index].Name())
+		}
+		info, err := os.Lstat(filepath.Join(directory, name))
+		if err != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
+			return fmt.Errorf("module scheduling directory is not a physical directory: %v", err)
+		}
+	}
+	return nil
+}
+
+func checkedSplitModuleArtifacts(expected moduleReport, directory string) ([]moduleResult, error) {
+	if expected.Owner != -1 || expected.RootPartition != nil || expected.RootInventory == nil {
+		return nil, fmt.Errorf("split aggregate requires its own fresh complete root inventory")
+	}
+	if err := exactModuleArtifactDirectories(directory, []string{"owner-0000", "owner-0001", "owner-0002"}); err != nil {
+		return nil, err
+	}
+	root, err := checkedModuleRootParts(expected, filepath.Join(directory, "owner-0000"))
+	if err != nil {
+		return nil, err
+	}
+	completed := map[string]moduleResult{root.Package: root}
+	for owner := 1; owner < moduleOwners; owner++ {
+		path := filepath.Join(directory, fmt.Sprintf("owner-%04d", owner))
+		var actual moduleReport
+		if err := ciReadJSON(filepath.Join(path, "module.json"), &actual); err != nil {
+			return nil, err
+		}
+		wanted := expected
+		wanted.Owner, wanted.RootInventory = owner, nil
+		if !sameModulePlan(actual, wanted) || actual.Status != moduleCompletionStatus(actual) || actual.Error != "" {
+			return nil, fmt.Errorf("module owner %d has foreign/failed/incomplete split plan", owner)
+		}
+		if err := verifyModuleOwner(actual, path); err != nil {
+			return nil, fmt.Errorf("module owner %d: %w", owner, err)
+		}
+		for _, result := range actual.Packages {
+			if _, duplicate := completed[result.Package]; duplicate {
+				return nil, fmt.Errorf("package assigned to multiple module scheduling owners")
+			}
+			completed[result.Package] = result
+		}
+	}
+	var results []moduleResult
+	for _, pkg := range expected.Inventory {
+		result, exists := completed[pkg.Package]
+		if !exists {
+			return nil, fmt.Errorf("package has no complete scheduling owner")
+		}
+		results = append(results, result)
+	}
+	return results, nil
+}
+
+func checkedModuleRootParts(expected moduleReport, directory string) (moduleResult, error) {
+	fresh := expected.RootInventory
+	pkg, packageIndex, err := moduleRootPackage(expected.Inventory)
+	if err != nil || fresh == nil || fresh.Package != pkg.Package || fresh.NoTestFiles != pkg.NoTestFiles ||
+		fresh.InventorySHA != ciNamesSHA(fresh.Names) || fresh.FullPackage != (pkg.NoTestFiles || len(fresh.Names) == 0) {
+		return moduleResult{}, fmt.Errorf("fresh root denominator is missing/inconsistent: %v", err)
+	}
+	plan := [][]string{fresh.Names}
+	if !fresh.FullPackage {
+		plan, err = partitionForFlags(fresh.Names, expected.Shards, expected.Flags)
+		if err != nil {
+			return moduleResult{}, err
+		}
+	}
+	directories := make([]string, expected.RootPartitions)
+	for index := range directories {
+		directories[index] = fmt.Sprintf("part-%04d", index)
+	}
+	if err := exactModuleArtifactDirectories(directory, directories); err != nil {
+		return moduleResult{}, err
+	}
+	result := moduleResult{Package: pkg.Package, Shards: len(plan), Workers: expected.Workers, Status: "passed"}
+	if fresh.FullPackage {
+		result.Workers = 1
+	}
+	seenShards := make([]bool, len(plan))
+	seenTerminals := make(map[string]bool)
+	for part := 0; part < expected.RootPartitions; part++ {
+		path := filepath.Join(directory, directories[part])
+		var actual moduleReport
+		if err := ciReadJSON(filepath.Join(path, "module.json"), &actual); err != nil {
+			return moduleResult{}, err
+		}
+		wanted := expected
+		wanted.Owner, wanted.RootPartition, wanted.RootInventory = 0, &part, nil
+		if !sameModulePlan(actual, wanted) || actual.Status != moduleCompletionStatus(actual) || actual.Error != "" {
+			return moduleResult{}, fmt.Errorf("root part %d has foreign/failed/incomplete plan", part)
+		}
+		packagePath := filepath.Join(path, fmt.Sprintf("package-%04d", packageIndex))
+		var suite suiteReport
+		if err := ciReadJSON(filepath.Join(packagePath, "partition.json"), &suite); err != nil {
+			return moduleResult{}, err
+		}
+		if !reflect.DeepEqual(suite.Names, fresh.Names) || !reflect.DeepEqual(suite.Benchmarks, fresh.Benchmarks) ||
+			suite.InventorySHA != fresh.InventorySHA || suite.FullPackage != fresh.FullPackage || suite.NoTestFiles != fresh.NoTestFiles ||
+			len(suite.Shards) != len(plan) {
+			return moduleResult{}, fmt.Errorf("root part %d differs from fresh complete root denominator", part)
+		}
+		if err := verifyModuleOwner(actual, path); err != nil {
+			return moduleResult{}, fmt.Errorf("root part %d: %w", part, err)
+		}
+		result.RootSkipped += suite.RootSkipped
+		result.ChildSkipped += suite.ChildSkipped
+		for index, shard := range suite.Shards {
+			if !suite.RootPart.owns(index, fresh.FullPackage) {
+				continue
+			}
+			if seenShards[index] || shard.Index != index || !reflect.DeepEqual(shard.Names, plan[index]) {
+				return moduleResult{}, fmt.Errorf("duplicate/foreign global root shard %d", index)
+			}
+			seenShards[index] = true
+			for name := range shard.Outcomes {
+				if seenTerminals[name] {
+					return moduleResult{}, fmt.Errorf("root/child terminal has multiple scheduling owners: %s", name)
+				}
+				seenTerminals[name] = true
+			}
+			if expected.Coverage != "" && len(shard.Command) != 0 {
+				result.rootCoverage = append(result.rootCoverage,
+					filepath.Join(packagePath, fmt.Sprintf("shard-%04d.cover", index)))
+			}
+		}
+	}
+	for index, present := range seenShards {
+		if !present {
+			return moduleResult{}, fmt.Errorf("global root shard %d has no complete owner", index)
+		}
+	}
+	if expected.Coverage != "" {
+		if _, err := mergeCoverage(result.rootCoverage); err != nil {
+			return moduleResult{}, fmt.Errorf("complete root shard coverage differs: %w", err)
+		}
+	}
+	return result, nil
+}
+
+func writeSplitModuleCoverage(report moduleReport, directory, outputDirectory, destination string) error {
+	var paths []string
+	for index, pkg := range report.Inventory {
+		if pkg.Directory == "." {
+			if index >= len(report.Packages) || report.Packages[index].Package != pkg.Package {
+				return fmt.Errorf("checked complete root coverage result is missing")
+			}
+			data, err := mergeCoverage(report.Packages[index].rootCoverage)
+			if err != nil {
+				return err
+			}
+			rootPath := filepath.Join(outputDirectory, "root.cover")
+			if err := writeNewCoverage(data, rootPath); err != nil {
+				return err
+			}
+			paths = append(paths, rootPath)
+		} else {
+			paths = append(paths, filepath.Join(directory, fmt.Sprintf("owner-%04d", moduleOwner(pkg)),
+				fmt.Sprintf("package-%04d", index), "package.cover"))
+		}
+	}
+	return writeCoverageUnion(paths, destination)
+}
diff --git a/cmd/plan9asmtest/module_sdkfrontend_test.go b/cmd/plan9asmtest/module_sdkfrontend_test.go
new file mode 100644
index 000000000..b5d5bb227
--- /dev/null
+++ b/cmd/plan9asmtest/module_sdkfrontend_test.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestModuleSDKFrontendUsesBoundedRootPartitions(t *testing.T) {
+	cfg := config{Shards: 64, Workers: 2, Timeout: time.Hour, Flags: []string{"-race", "-p=1"}}
+	for _, directory := range []string{"gotoolprofile", "internal/sdkfrontend"} {
+		pkg := modulePackage{Directory: directory, Package: "example.org/complete/" + directory}
+		child := modulePackageConfig(cfg, pkg, 3)
+		if moduleOwner(pkg) != 1 || child.fullPackage || child.rootPart != nil ||
+			child.Shards != 64 || child.Workers != 2 || child.Timeout != cfg.Timeout ||
+			!reflect.DeepEqual(child.Flags, cfg.Flags) {
+			t.Fatalf("source/profile package lost bounded complete-root scheduling: %s %+v", directory, child)
+		}
+	}
+	for _, directory := range []string{"sdkfrontend", "internal/sdkfrontend/child", "future/internal/sdkfrontend", "future"} {
+		pkg := modulePackage{Directory: directory, Package: "example.org/complete/" + directory}
+		child := modulePackageConfig(cfg, pkg, 4)
+		if moduleOwner(pkg) != 2 || !child.fullPackage || child.Shards != 1 || child.Workers != 1 ||
+			!reflect.DeepEqual(child.Flags, cfg.Flags) || child.Timeout != cfg.Timeout {
+			t.Fatalf("remaining package lost one complete unfiltered command: %s %+v", directory, child)
+		}
+	}
+	// An empty package still needs its ordinary unfiltered Go execution.
+	pkg := modulePackage{Directory: "internal/sdkfrontend", NoTestFiles: true}
+	child := modulePackageConfig(cfg, pkg, 5)
+	if !child.fullPackage || !child.noTestFiles || child.Shards != 1 || child.Workers != 1 {
+		t.Fatalf("no-test source package acquired synthetic executing shards: %+v", child)
+	}
+}
diff --git a/cmd/plan9asmtest/module_test.go b/cmd/plan9asmtest/module_test.go
new file mode 100644
index 000000000..ee6344dad
--- /dev/null
+++ b/cmd/plan9asmtest/module_test.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestModuleInventoryRejectsForeignMissingAndDuplicate(t *testing.T) {
+	dir := t.TempDir()
+	pkg := map[string]any{
+		"ImportPath": "example.org/complete",
+		"Dir":        dir,
+		"Module":     map[string]any{"Main": true, "Path": "example.org/complete", "Dir": dir, "GoMod": filepath.Join(dir, "go.mod")},
+	}
+	encode := func(value any) []byte {
+		data, err := json.Marshal(value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return data
+	}
+	if packages, err := readModulePackages(encode(pkg), dir); err != nil || len(packages) != 1 || !packages[0].NoTestFiles || moduleOwner(packages[0]) != 0 {
+		t.Fatalf("actual no-test root inventory: %+v %v", packages, err)
+	}
+	for _, name := range []string{"empty", "duplicate", "dependency", "escape", "loader-error", "truncated"} {
+		t.Run(name, func(t *testing.T) {
+			var value map[string]any
+			if err := json.Unmarshal(encode(pkg), &value); err != nil {
+				t.Fatal(err)
+			}
+			switch name {
+			case "dependency":
+				value["Module"].(map[string]any)["Main"] = false
+			case "escape":
+				value["Dir"] = filepath.Dir(dir)
+			case "loader-error":
+				value["Error"] = map[string]any{"Err": "real loader failure"}
+			}
+			data := encode(value)
+			switch name {
+			case "empty":
+				data = nil
+			case "duplicate":
+				data = append(data, data...)
+			case "truncated":
+				data = data[:len(data)-1]
+			}
+			if _, err := readModulePackages(data, dir); err == nil {
+				t.Fatal("unproved package inventory accepted")
+			}
+		})
+	}
+	if got := moduleListFlags([]string{"-race", "-covermode", "atomic", "-tags=owned", "-p=2", "-coverpkg=./...", "-cover"}); !reflect.DeepEqual(got, []string{"-race", "-tags=owned", "-p=2"}) {
+		t.Fatalf("test build selection changed for package list: %q", got)
+	}
+}
+
+func TestModuleCoverageUnionKeepsAllFilesAndChecksCounters(t *testing.T) {
+	write := func(name, contents string) string {
+		path := filepath.Join(t.TempDir(), name)
+		if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+		return path
+	}
+	a := write("a.cover", "mode: atomic\na.go:1.1,2.1 1 3\nshared.go:1.1,2.1 2 4\n")
+	b := write("b.cover", "mode: atomic\nb.go:1.1,2.1 1 5\nshared.go:1.1,2.1 2 6\n")
+	merged, err := mergeModuleCoverage([]string{a, b})
+	if err != nil || string(merged) != "mode: atomic\na.go:1.1,2.1 1 3\nb.go:1.1,2.1 1 5\nshared.go:1.1,2.1 2 10\n" {
+		t.Fatalf("module union/overlap arithmetic: %s %v", merged, err)
+	}
+	for _, malformed := range []string{
+		"mode: count\nb.go:1.1,2.1 1 5\n",
+		"mode: atomic\nshared.go:1.1,2.1 3 6\n",
+		"mode: atomic\nshared.go:1.1,2.1 2 18446744073709551615\n",
+		"mode: atomic\nb.go:1.1,2.1 1 5\nb.go:1.1,2.1 1 5\n",
+	} {
+		if _, err := mergeModuleCoverage([]string{a, write("invalid.cover", malformed)}); err == nil {
+			t.Fatalf("mode/statements/overflow/duplicate became valid coverage: %s", malformed)
+		}
+	}
+	// Ordinary per-package coverage still requires its exact unchanged blocks.
+	if _, err := mergeCoverage([]string{a, b}); err == nil {
+		t.Fatal("module union weakened existing per-package block equality")
+	}
+}
+
+func TestModuleEmptyPackageEventsRemainStrict(t *testing.T) {
+	valid := "{\"Action\":\"start\",\"Package\":\"p\"}\n{\"Action\":\"skip\",\"Package\":\"p\"}\n"
+	if _, err := validateSuiteEvents(strings.NewReader(valid), "p", nil, true, true); err != nil {
+		t.Fatal(err)
+	}
+	for _, input := range []string{valid, strings.Replace(valid, "skip", "pass", 1), strings.Replace(valid, "skip", "fail", 1), valid + valid} {
+		if _, err := validateEvents(strings.NewReader(input), "p", nil); err == nil {
+			t.Fatal("ordinary empty inventory protocol changed")
+		}
+	}
+	if _, err := validateSuiteEvents(strings.NewReader(valid), "p", nil, true, false); err == nil {
+		t.Fatal("benchmark-only package silently skipped instead of running TestMain")
+	}
+	for _, input := range []string{valid + valid, strings.Replace(valid, "skip", "fail", 1), strings.Split(valid, "\n")[0] + "\n"} {
+		if _, err := validateSuiteEvents(strings.NewReader(input), "p", nil, true, true); err == nil {
+			t.Fatal("unknown/partial no-test package accepted")
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/module_verify.go b/cmd/plan9asmtest/module_verify.go
new file mode 100644
index 000000000..dea961371
--- /dev/null
+++ b/cmd/plan9asmtest/module_verify.go
@@ -0,0 +1,356 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+)
+
+func sameModulePlan(actual, expected moduleReport) bool {
+	// Paths are artifact origins, not cross-machine identities. The complete
+	// selected SDK/source/tool byte hashes and normalized environment must match.
+	return actual.Protocol == expected.Protocol && actual.Owner == expected.Owner &&
+		actual.RootPartitions == expected.RootPartitions && reflect.DeepEqual(actual.RootPartition, expected.RootPartition) &&
+		reflect.DeepEqual(actual.Flags, expected.Flags) && actual.Coverage == expected.Coverage &&
+		actual.Timeout == expected.Timeout && actual.Shards == expected.Shards && actual.Workers == expected.Workers &&
+		reflect.DeepEqual(actual.Scope, expected.Scope) && reflect.DeepEqual(actual.Inventory, expected.Inventory)
+}
+
+func verifyModuleArtifacts(expected moduleReport, directory string) error {
+	_, err := checkedModuleArtifacts(expected, directory)
+	return err
+}
+
+func checkedModuleArtifacts(expected moduleReport, directory string) ([]moduleResult, error) {
+	if err := validateModuleReportScheduling(expected); err != nil {
+		return nil, err
+	}
+	if expected.RootPartitions > 1 {
+		return checkedSplitModuleArtifacts(expected, directory)
+	}
+	if _, err := os.Lstat(filepath.Join(directory, "module.json")); err == nil {
+		var actual moduleReport
+		if err := ciReadJSON(filepath.Join(directory, "module.json"), &actual); err != nil {
+			return nil, err
+		}
+		if actual.Owner != -1 || !sameModulePlan(actual, expected) || actual.Status != moduleCompletionStatus(actual) || actual.Error != "" {
+			return nil, fmt.Errorf("complete module plan/status differs")
+		}
+		return actual.Packages, verifyModuleOwner(actual, directory)
+	}
+	entries, err := os.ReadDir(directory)
+	if err != nil || len(entries) != moduleOwners {
+		return nil, fmt.Errorf("exactly three module owners required: %v", err)
+	}
+	completed := map[string]moduleResult{}
+	for owner := 0; owner < moduleOwners; owner++ {
+		path := filepath.Join(directory, fmt.Sprintf("owner-%04d", owner))
+		var actual moduleReport
+		if err := ciReadJSON(filepath.Join(path, "module.json"), &actual); err != nil {
+			return nil, err
+		}
+		wanted := expected
+		wanted.Owner = owner
+		if !sameModulePlan(actual, wanted) || actual.Status != moduleCompletionStatus(actual) || actual.Error != "" {
+			return nil, fmt.Errorf("module owner %d has foreign/failed/incomplete plan", owner)
+		}
+		if err := verifyModuleOwner(actual, path); err != nil {
+			return nil, fmt.Errorf("module owner %d: %w", owner, err)
+		}
+		for _, result := range actual.Packages {
+			if _, duplicate := completed[result.Package]; duplicate {
+				return nil, fmt.Errorf("package assigned to multiple owners")
+			}
+			completed[result.Package] = result
+		}
+	}
+	var results []moduleResult
+	for _, pkg := range expected.Inventory {
+		result, exists := completed[pkg.Package]
+		if !exists {
+			return nil, fmt.Errorf("package has no completed owner")
+		}
+		results = append(results, result)
+	}
+	return results, nil
+}
+
+func verifyModuleOwner(report moduleReport, directory string) error {
+	if err := validateModuleReportScheduling(report); err != nil {
+		return err
+	}
+	if report.Owner < -1 || report.Owner >= moduleOwners {
+		return fmt.Errorf("unknown module protocol/owner")
+	}
+	if err := verifyScopeArtifacts(directory, report.Go, report.Scope); err != nil {
+		return err
+	}
+	if err := verifyModuleDependencyArtifacts(directory, report); err != nil {
+		return err
+	}
+	for _, phase := range []string{"before", "after"} {
+		data, err := os.ReadFile(filepath.Join(directory, "packages-"+phase+".stdout"))
+		if err != nil {
+			return err
+		}
+		packages, err := readModulePackages(data, report.Directory)
+		if err != nil || !reflect.DeepEqual(packages, report.Inventory) {
+			return fmt.Errorf("actual %s package inventory differs: %v", phase, err)
+		}
+		var environment ciEnvironmentContext
+		if err := ciReadJSON(filepath.Join(directory, phase+"-environment-context.json"), &environment); err != nil || environment.Directory != report.Directory {
+			return fmt.Errorf("actual module CWD differs: %v", err)
+		}
+	}
+	var wanted []modulePackage
+	for _, pkg := range report.Inventory {
+		if report.Owner == -1 || moduleOwner(pkg) == report.Owner {
+			wanted = append(wanted, pkg)
+		}
+	}
+	if len(report.Packages) != len(wanted) {
+		return fmt.Errorf("missing/extra package completion: %d/%d", len(report.Packages), len(wanted))
+	}
+	position := 0
+	var failures []error
+	for index, pkg := range report.Inventory {
+		if report.Owner != -1 && moduleOwner(pkg) != report.Owner {
+			continue
+		}
+		result := report.Packages[position]
+		position++
+		cfg := config{Go: report.Go, Dir: report.Directory, Out: directory, Flags: append([]string(nil), report.Flags...),
+			Shards: report.Shards, Workers: report.Workers, Module: true, ModuleOwner: report.Owner,
+			ModuleRootPartitions: report.RootPartitions, ModuleRootPartition: -1}
+		if report.RootPartition != nil {
+			cfg.ModuleRootPartition = *report.RootPartition
+		}
+		cfg.Timeout, _ = time.ParseDuration(report.Timeout)
+		if report.Coverage != "" {
+			cfg.Flags = append(cfg.Flags, "-coverprofile="+report.Coverage)
+		}
+		child := modulePackageConfig(cfg, pkg, index)
+		listing, err := os.ReadFile(filepath.Join(child.Out, "inventory.stdout"))
+		if err == nil {
+			listedPackage, names, _, parseErr := parseSuiteList(string(listing), true, pkg.NoTestFiles)
+			if parseErr == nil && listedPackage == pkg.Package && len(names) == 0 {
+				child.fullPackage, child.Shards, child.Workers = true, 1, 1
+			}
+		}
+		statusMatches := result.Status == "passed"
+		if child.rootPart != nil {
+			statusMatches = result.Status == "completed_owned" || result.Status == "completed_empty"
+		}
+		if result.Package != pkg.Package || result.Shards != child.Shards || result.Workers != child.Workers || !statusMatches || result.Error != "" {
+			failures = append(failures, fmt.Errorf("package %s incomplete/failed: %s", pkg.Package, result.Error))
+		}
+		if err := verifyModulePackage(child, pkg, report.Coverage != ""); err != nil {
+			failures = append(failures, fmt.Errorf("package %s: %w", pkg.Package, err))
+		}
+		var suite suiteReport
+		if err := ciReadJSON(filepath.Join(child.Out, suiteReportName(child)), &suite); err != nil || suite.GoVersion != report.Scope.GoVersion ||
+			suite.Status != result.Status ||
+			suite.RootSkipped != result.RootSkipped || suite.ChildSkipped != result.ChildSkipped {
+			failures = append(failures, fmt.Errorf("package version/explicit skip counters differ: %v", err))
+		}
+	}
+	return errors.Join(failures...)
+}
+
+func verifyModulePackage(cfg config, pkg modulePackage, covered bool) error {
+	var report suiteReport
+	if err := ciReadJSON(filepath.Join(cfg.Out, suiteReportName(cfg)), &report); err != nil {
+		return err
+	}
+	flags, _, err := validateFlags(cfg.Flags)
+	if covered {
+		flags = append(flags, "-cover")
+	}
+	schema := 1
+	if cfg.rootPart != nil {
+		schema = 2
+	}
+	if err != nil || report.Schema != schema || !reflect.DeepEqual(report.RootPart, cfg.rootPart) ||
+		report.Status != suiteCompletionStatus(report) || report.Error != "" || report.Go != cfg.Go ||
+		report.Package != pkg.Package || report.Timeout != cfg.Timeout.String() || report.Workers != cfg.Workers ||
+		report.FullPackage != cfg.fullPackage || report.NoTestFiles != cfg.noTestFiles || !filepath.IsAbs(report.ArtifactDir) ||
+		!reflect.DeepEqual(report.Flags, flags) {
+		return fmt.Errorf("per-package plan/status differs: %v", err)
+	}
+	listing, err := os.ReadFile(filepath.Join(cfg.Out, "inventory.stdout"))
+	if err != nil {
+		return err
+	}
+	listedPackage, names, benchmarks, err := parseSuiteList(string(listing), cfg.fullPackage, cfg.noTestFiles)
+	if err != nil || listedPackage != pkg.Package || !reflect.DeepEqual(names, report.Names) ||
+		!reflect.DeepEqual(benchmarks, report.Benchmarks) || report.InventorySHA != ciNamesSHA(names) {
+		return fmt.Errorf("actual complete package test inventory differs: %v", err)
+	}
+	plan := [][]string{names}
+	if !cfg.fullPackage {
+		plan, err = partitionForFlags(names, cfg.Shards, flags)
+		if err != nil {
+			return err
+		}
+	}
+	if len(plan) != len(report.Shards) {
+		return fmt.Errorf("missing/extra shard")
+	}
+	counts := suiteReport{}
+	var profiles []string
+	for index, names := range plan {
+		shard := report.Shards[index]
+		if shard.Index != index || !reflect.DeepEqual(shard.Names, names) {
+			return fmt.Errorf("duplicate/foreign shard assignment")
+		}
+		if cfg.rootPart != nil && !cfg.rootPart.owns(index, cfg.fullPackage) {
+			if shard.Status != "not_owned" || len(shard.Command) != 0 || len(shard.Outcomes) != 0 || shard.Error != "" || shard.Seconds != 0 {
+				return fmt.Errorf("unassigned shard gained execution or completion")
+			}
+			if err := verifyUnexecutedShardFiles(cfg.Out, index); err != nil {
+				return err
+			}
+			continue
+		}
+		if !cfg.fullPackage && len(names) == 0 {
+			if shard.Status != "empty" || len(shard.Command) != 0 || len(shard.Outcomes) != 0 || shard.Error != "" {
+				return fmt.Errorf("empty shard gained execution")
+			}
+			if cfg.rootPart != nil {
+				if err := verifyUnexecutedShardFiles(cfg.Out, index); err != nil {
+					return err
+				}
+			}
+			continue
+		}
+		command := append([]string{cfg.Go, "test"}, flags...)
+		if covered {
+			command = append(command, "-coverprofile="+filepath.Join(report.ArtifactDir, fmt.Sprintf("shard-%04d.cover", index)))
+			profiles = append(profiles, filepath.Join(cfg.Out, fmt.Sprintf("shard-%04d.cover", index)))
+		}
+		command = append(command, "-count=1", "-timeout="+cfg.Timeout.String(), "-json")
+		if !cfg.fullPackage {
+			pattern, err := runPattern(names)
+			if err != nil {
+				return err
+			}
+			command = append(command, "-run="+pattern)
+		}
+		command = append(command, pkg.Package)
+		if !reflect.DeepEqual(command, shard.Command) || shard.Status != "passed" || shard.Error != "" {
+			return fmt.Errorf("actual command/flags/deadline or shard status differs")
+		}
+		file, err := os.Open(filepath.Join(cfg.Out, fmt.Sprintf("shard-%04d.stdout", index)))
+		if err != nil {
+			return err
+		}
+		states, validationErr := validateSuiteEvents(file, pkg.Package, names, cfg.fullPackage, cfg.noTestFiles)
+		sameStates := reflect.DeepEqual(states, shard.Outcomes) || len(states) == 0 && len(shard.Outcomes) == 0
+		if err := errors.Join(validationErr, file.Close()); err != nil || !sameStates {
+			return fmt.Errorf("actual raw JSON/terminals differ: %v", err)
+		}
+		for name, state := range states {
+			child := strings.Contains(name, "/")
+			if state == "pass" {
+				if child {
+					counts.ChildPassed++
+				} else {
+					counts.RootPassed++
+				}
+			} else if state == "skip" {
+				if child {
+					counts.ChildSkipped++
+				} else {
+					counts.RootSkipped++
+				}
+			}
+		}
+	}
+	if counts.RootPassed != report.RootPassed || counts.RootSkipped != report.RootSkipped || counts.ChildPassed != report.ChildPassed ||
+		counts.ChildSkipped != report.ChildSkipped || report.RootFailed+report.RootMissing+report.ChildFailed+report.ChildMissing != 0 {
+		return fmt.Errorf("root/child completion counters differ")
+	}
+	if covered {
+		profile := "package.cover"
+		if cfg.rootPart != nil {
+			profile = "partition.cover"
+		}
+		if len(profiles) == 0 && cfg.rootPart != nil {
+			if _, err := os.Lstat(filepath.Join(cfg.Out, profile)); !os.IsNotExist(err) {
+				return fmt.Errorf("empty root fragment gained coverage: %v", err)
+			}
+			return nil
+		}
+		merged, err := mergeCoverage(profiles)
+		actual, readErr := os.ReadFile(filepath.Join(cfg.Out, profile))
+		if err != nil || readErr != nil || !bytes.Equal(merged, actual) {
+			return fmt.Errorf("package coverage is not the complete checked shard merge: %v %v", err, readErr)
+		}
+	}
+	return nil
+}
+
+func verifyUnexecutedShardFiles(directory string, index int) error {
+	for _, suffix := range []string{".stdout", ".stderr", ".cover"} {
+		path := filepath.Join(directory, fmt.Sprintf("shard-%04d%s", index, suffix))
+		if _, err := os.Lstat(path); !os.IsNotExist(err) {
+			return fmt.Errorf("unexecuted root shard has an artifact: %v", err)
+		}
+	}
+	return nil
+}
+
+func writeModuleCoverage(report moduleReport, directory, destination string) error {
+	var paths []string
+	for i, pkg := range report.Inventory {
+		if report.Owner == -1 || moduleOwner(pkg) == report.Owner {
+			paths = append(paths, filepath.Join(directory, fmt.Sprintf("package-%04d", i), "package.cover"))
+		}
+	}
+	return writeCoverageUnion(paths, destination)
+}
+
+func writeVerifiedModuleCoverage(report moduleReport, directory, outputDirectory, destination string) error {
+	if report.RootPartitions > 1 {
+		return writeSplitModuleCoverage(report, directory, outputDirectory, destination)
+	}
+	if _, err := os.Lstat(filepath.Join(directory, "module.json")); err == nil {
+		return writeModuleCoverage(report, directory, destination)
+	}
+	var paths []string
+	for i, pkg := range report.Inventory {
+		paths = append(paths, filepath.Join(directory, fmt.Sprintf("owner-%04d", moduleOwner(pkg)), fmt.Sprintf("package-%04d", i), "package.cover"))
+	}
+	return writeCoverageUnion(paths, destination)
+}
+
+func writeCoverageUnion(paths []string, destination string) error {
+	data, err := mergeModuleCoverage(paths)
+	if err != nil {
+		return err
+	}
+	return writeNewCoverage(data, destination)
+}
+
+func writeNewCoverage(data []byte, destination string) error {
+	file, err := os.OpenFile(destination, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+	if err != nil {
+		return err
+	}
+	_, writeErr := file.Write(data)
+	info, statErr := file.Stat()
+	err = errors.Join(writeErr, statErr, file.Close())
+	if err != nil {
+		current, currentErr := os.Lstat(destination)
+		if currentErr != nil || info == nil || !os.SameFile(info, current) {
+			return errors.Join(err, fmt.Errorf("failed coverage output identity changed: %v", currentErr))
+		}
+		return errors.Join(err, os.Remove(destination))
+	}
+	return nil
+}
diff --git a/cmd/plan9asmtest/module_verify_unix_test.go b/cmd/plan9asmtest/module_verify_unix_test.go
new file mode 100644
index 000000000..d7303b861
--- /dev/null
+++ b/cmd/plan9asmtest/module_verify_unix_test.go
@@ -0,0 +1,320 @@
+//go:build unix
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestModuleThreeOwnersActualGoAndStrictAggregate(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	binary := parallelFixtureCLI(t)
+	dir := moduleFixture(t, false)
+	frontend := filepath.Join(dir, "internal", "sdkfrontend")
+	if err := os.MkdirAll(frontend, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for name, source := range map[string]string{
+		"value.go": "package frontend\nfunc Value() int { return 19 }\n",
+		"value_test.go": `package frontend
+import ("fmt"; "testing")
+func TestCaptureAlpha(t *testing.T) { t.Run("child", func(t *testing.T) { if Value()!=19 { t.Fatal("value") } }) }
+func TestCaptureBeta(t *testing.T) { if Value()!=19 { t.Fatal("value") } }
+func ExampleValue() { fmt.Println(Value()); /* Output: 19 */ }
+func FuzzValue(f *testing.F) { f.Add(19); f.Fuzz(func(t *testing.T, n int) { if Value()!=n { t.Fatal(n) } }) }
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(frontend, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	container := t.TempDir()
+	profile := filepath.Join(t.TempDir(), "whole-module.cover")
+	flags := []string{"-race", "-covermode=atomic", "-coverprofile=" + profile, "-p=2"}
+	var expected moduleReport
+	frontendIndex := -1
+	for owner := 0; owner < moduleOwners; owner++ {
+		out := filepath.Join(container, fmt.Sprintf("owner-%04d", owner))
+		stem := filepath.Join(t.TempDir(), "owner")
+		args := []string{"-module", fmt.Sprintf("-module-owner=%d", owner), "-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--"}
+		args = append(args, flags...)
+		if _, err := captureCommand(context.Background(), 4*time.Minute, ".", binary, args, stem); err != nil {
+			t.Fatal(errorsWithActualOutput(err, stem))
+		}
+		var report moduleReport
+		if err := ciReadJSON(filepath.Join(out, "module.json"), &report); err != nil {
+			t.Fatal(err)
+		}
+		if owner == 0 {
+			expected = report
+			expected.Owner = -1
+		}
+		if len(report.Inventory) != 6 || report.Status != "passed" {
+			t.Fatalf("owner lost actual whole-module inventory: %+v", report)
+		}
+		for index, pkg := range report.Inventory {
+			if pkg.Directory != "internal/sdkfrontend" {
+				continue
+			}
+			frontendIndex = index
+			if moduleOwner(pkg) != 1 {
+				t.Fatal("actual SDK frontend remained a serial whole-package owner")
+			}
+			if owner != 1 {
+				continue
+			}
+			var suite suiteReport
+			packageOut := filepath.Join(out, fmt.Sprintf("package-%04d", index))
+			if err := ciReadJSON(filepath.Join(packageOut, "report.json"), &suite); err != nil {
+				t.Fatal(err)
+			}
+			if suite.FullPackage || suite.Workers != 2 || len(suite.Shards) != 2 ||
+				len(suite.Names) != 4 || suite.RootPassed != 4 || suite.ChildPassed != 2 ||
+				suite.RootSkipped != 0 || suite.ChildSkipped != 0 {
+				t.Fatalf("SDK frontend lost complete Test/Example/Fuzz roots and children: %+v", suite)
+			}
+		}
+	}
+	if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+		t.Fatalf("an owner published partial module coverage: %v", err)
+	}
+	// Downloaded artifacts need not retain their original physical directory.
+	// Only known artifact-root roles move; source/SDK/env/tool fields stay exact.
+	relocated := filepath.Join(t.TempDir(), "downloaded")
+	if err := os.Rename(container, relocated); err != nil {
+		t.Fatal(err)
+	}
+	if err := verifyModuleArtifacts(expected, relocated); err != nil {
+		t.Fatalf("complete actual disjoint owner artifacts: %v", err)
+	}
+	stem := filepath.Join(t.TempDir(), "aggregate")
+	args := []string{"-module", "-dir", dir, "-out", filepath.Join(t.TempDir(), "verified"), "-verify-module", relocated, "-shards=2", "-workers=2", "-timeout=2m", "--"}
+	args = append(args, flags...)
+	if _, err := captureCommand(context.Background(), 3*time.Minute, ".", binary, args, stem); err != nil {
+		t.Fatal(errorsWithActualOutput(err, stem))
+	}
+	data, err := os.ReadFile(profile)
+	if err != nil || !strings.Contains(string(data), "modulefixture/internal/other/value.go:") ||
+		!strings.Contains(string(data), "modulefixture/gotoolprofile/value.go:") ||
+		!strings.Contains(string(data), "modulefixture/internal/sdkfrontend/value.go:") {
+		t.Fatalf("checked cross-owner coverage lost packages: %v\n%s", err, data)
+	}
+
+	ownerPath := filepath.Join(relocated, "owner-0002", "module.json")
+	var original moduleReport
+	if err := ciReadJSON(ownerPath, &original); err != nil {
+		t.Fatal(err)
+	}
+	mutations := []struct {
+		name   string
+		change func(*moduleReport)
+	}{
+		{"missing-package", func(r *moduleReport) { r.Packages = r.Packages[:len(r.Packages)-1] }},
+		{"duplicate-package", func(r *moduleReport) { r.Packages[1] = r.Packages[0] }},
+		{"foreign-package", func(r *moduleReport) { r.Packages[0].Package = "example.org/foreign" }},
+		{"partial", func(r *moduleReport) { r.Packages[0].Status = "pending" }},
+		{"flag", func(r *moduleReport) { r.Flags = append(r.Flags, "-race=false") }},
+		{"source", func(r *moduleReport) { r.Scope.SourceSHA = strings.Repeat("0", 64) }},
+		{"sdk", func(r *moduleReport) { r.Scope.SDKSource = strings.Repeat("0", 64) }},
+		{"tool", func(r *moduleReport) { r.Scope.Tools["go"] = strings.Repeat("0", 64) }},
+		{"environment", func(r *moduleReport) { r.Scope.Environment["GOGCCFLAGS"] += " -Dforeign" }},
+		{"budget", func(r *moduleReport) { r.Timeout = "3m0s" }},
+		{"unknown-protocol", func(r *moduleReport) { r.Protocol = "unregistered" }},
+		{"lost-skip", func(r *moduleReport) { r.Packages[0].RootSkipped++ }},
+	}
+	for _, mutation := range mutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			// A fresh decode gives every mutation independent slices/maps.
+			var changed moduleReport
+			if err := ciReadJSON(ownerPath, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutation.change(&changed)
+			if err := ciWriteJSON(ownerPath, changed); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := ciWriteJSON(ownerPath, original); err != nil {
+					t.Error(err)
+				}
+			})
+			if err := verifyModuleArtifacts(expected, relocated); err == nil {
+				t.Fatal("foreign/incomplete artifact became complete")
+			}
+		})
+	}
+	packagePath := filepath.Join(relocated, "owner-0000", "package-0000", "report.json")
+	var suite suiteReport
+	if err := ciReadJSON(packagePath, &suite); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"missing-root", "unknown-root", "duplicate-shard", "missing-benchmark", "command", "coverage", "raw-incomplete", "raw-foreign"} {
+		t.Run(name, func(t *testing.T) {
+			var changed suiteReport
+			if err := ciReadJSON(packagePath, &changed); err != nil {
+				t.Fatal(err)
+			}
+			switch name {
+			case "missing-root":
+				changed.Names = changed.Names[1:]
+			case "unknown-root":
+				changed.Names = append(changed.Names, "TestForeign")
+			case "duplicate-shard":
+				changed.Shards[1] = changed.Shards[0]
+			case "missing-benchmark":
+				changed.Benchmarks = []string{"BenchmarkForeign"}
+			case "command":
+				changed.Shards[0].Command = append(changed.Shards[0].Command, "-run=TestForeign")
+			case "coverage":
+				path := filepath.Join(filepath.Dir(packagePath), "package.cover")
+				data, err := os.ReadFile(path)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(path, []byte("mode: atomic\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.WriteFile(path, data, 0600); err != nil {
+						t.Error(err)
+					}
+				})
+			case "raw-incomplete", "raw-foreign":
+				path := filepath.Join(filepath.Dir(packagePath), "shard-0000.stdout")
+				data, err := os.ReadFile(path)
+				if err != nil {
+					t.Fatal(err)
+				}
+				changed := []byte{}
+				if name == "raw-foreign" {
+					changed = bytes.ReplaceAll(data, []byte("example.org/modulefixture"), []byte("example.org/foreign"))
+				}
+				if err := os.WriteFile(path, changed, 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.WriteFile(path, data, 0600); err != nil {
+						t.Error(err)
+					}
+				})
+			}
+			if err := ciWriteJSON(packagePath, changed); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := ciWriteJSON(packagePath, suite); err != nil {
+					t.Error(err)
+				}
+			})
+			if err := verifyModuleArtifacts(expected, relocated); err == nil {
+				t.Fatal("missing/foreign raw execution or coverage became complete")
+			}
+		})
+	}
+	frontendOut := filepath.Join(relocated, "owner-0001", fmt.Sprintf("package-%04d", frontendIndex))
+	logs, err := filepath.Glob(filepath.Join(frontendOut, "shard-*.stdout"))
+	if err != nil || len(logs) == 0 {
+		t.Fatal("SDK frontend has no actual executing Go JSON", err)
+	}
+	for _, name := range []string{"sdk-raw-incomplete", "sdk-raw-duplicate"} {
+		t.Run(name, func(t *testing.T) {
+			data, err := os.ReadFile(logs[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+			var changed []byte
+			if name == "sdk-raw-duplicate" {
+				changed = append(append([]byte(nil), data...), data...)
+			}
+			if err := os.WriteFile(logs[0], changed, 0600); err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := os.WriteFile(logs[0], data, 0600); err != nil {
+					t.Error(err)
+				}
+			})
+			if err := verifyModuleArtifacts(expected, relocated); err == nil {
+				t.Fatal("missing or repeated SDK frontend execution became complete")
+			}
+		})
+	}
+	if err := verifyModuleArtifacts(expected, relocated); err != nil {
+		t.Fatalf("negative controls mutated original artifact state: %v", err)
+	}
+	if reflect.DeepEqual(expected.Scope.Tools, original.Scope.Tools) == false {
+		t.Fatal("mutation leaked into immutable expected plan")
+	}
+}
+
+func TestModuleExplicitSkipIsNeverAPassedRoot(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	dir := moduleFixture(t, false)
+	path := filepath.Join(dir, "value_test.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = append(source, []byte("\nfunc TestExistingSkip(t *testing.T) { t.Skip(\"original explicit platform role\") }\n")...)
+	if err := os.WriteFile(path, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	binary := parallelFixtureCLI(t)
+	out := filepath.Join(t.TempDir(), "module")
+	stem := filepath.Join(t.TempDir(), "cli")
+	if _, err := captureCommand(context.Background(), 4*time.Minute, ".", binary,
+		[]string{"-module", "-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--", "-p=2"}, stem); err != nil {
+		t.Fatal(errorsWithActualOutput(err, stem))
+	}
+	var report moduleReport
+	if err := ciReadJSON(filepath.Join(out, "module.json"), &report); err != nil {
+		t.Fatal(err)
+	}
+	var suite suiteReport
+	if err := ciReadJSON(filepath.Join(out, "package-0000", "report.json"), &suite); err != nil {
+		t.Fatal(err)
+	}
+	if report.Status != "completed_with_skips" || report.Packages[0].RootSkipped != 1 || suite.RootSkipped != 1 || suite.RootPassed != 4 {
+		t.Fatalf("explicit original skip was lost or relabeled P: %+v / %+v", report, suite)
+	}
+	results, err := checkedModuleArtifacts(report, out)
+	if err != nil || len(results) != 5 || results[0].RootSkipped != 1 {
+		t.Fatalf("aggregate lost explicit original skip: %+v %v", results, err)
+	}
+}
+
+func TestModuleBenchmarkOnlyRootExecutesActualTestMain(t *testing.T) {
+	moduleFixtureEnvironment(t)
+	dir := moduleFixture(t, false)
+	// Empty root inventories still have real TestMain code, which must run.
+	source := `package fixture
+import ("os"; "testing")
+func TestMain(m *testing.M) { if Value() != 7 { os.Exit(3) }; os.Exit(m.Run()) }
+func BenchmarkNotRun(b *testing.B) { b.Fatal("benchmark executed") }
+`
+	if err := os.WriteFile(filepath.Join(dir, "value_test.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	binary := parallelFixtureCLI(t)
+	out := filepath.Join(t.TempDir(), "module")
+	stem := filepath.Join(t.TempDir(), "cli")
+	if _, err := captureCommand(context.Background(), 4*time.Minute, ".", binary,
+		[]string{"-module", "-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--", "-p=2"}, stem); err != nil {
+		t.Fatal(errorsWithActualOutput(err, stem))
+	}
+	var report suiteReport
+	if err := ciReadJSON(filepath.Join(out, "package-0000", "report.json"), &report); err != nil {
+		t.Fatal(err)
+	}
+	if len(report.Names) != 0 || len(report.Benchmarks) != 1 || !report.FullPackage || len(report.Shards) != 1 || strings.Contains(strings.Join(report.Shards[0].Command, " "), "-run=") {
+		t.Fatalf("benchmark-only root did not execute complete unfiltered package: %+v", report)
+	}
+}
diff --git a/cmd/plan9asmtest/module_worker_state_linux_test.go b/cmd/plan9asmtest/module_worker_state_linux_test.go
new file mode 100644
index 000000000..6ef82ea64
--- /dev/null
+++ b/cmd/plan9asmtest/module_worker_state_linux_test.go
@@ -0,0 +1,33 @@
+//go:build linux
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// Independent kernel assertion, not the production membership parser. kill(0)
+// also succeeds for zombies; they have exited even if PID1 has not reaped them.
+func moduleWorkerKernelTerminal(pid int) (string, bool) {
+	data, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", pid))
+	if os.IsNotExist(err) {
+		return "process disappeared during its terminal observation", true
+	}
+	text := string(data)
+	end := strings.LastIndex(text, ") ")
+	if err != nil || !strings.HasPrefix(text, strconv.Itoa(pid)+" (") || end < 0 {
+		return fmt.Sprint("unavailable kernel process identity: ", err), false
+	}
+	fields := strings.Fields(text[end+2:])
+	if len(fields) < 20 {
+		return "incomplete kernel process state", false
+	}
+	parent, parentErr := strconv.Atoi(fields[1])
+	group, groupErr := strconv.Atoi(fields[2])
+	born, bornErr := strconv.ParseUint(fields[19], 10, 64)
+	evidence := fmt.Sprintf("PID=%d PPID=%d PGID=%d state=%s starttime=%d", pid, parent, group, fields[0], born)
+	return evidence, parentErr == nil && parent > 0 && groupErr == nil && group > 1 && bornErr == nil && fields[0] == "Z"
+}
diff --git a/cmd/plan9asmtest/module_worker_state_other_unix_test.go b/cmd/plan9asmtest/module_worker_state_other_unix_test.go
new file mode 100644
index 000000000..fe6823718
--- /dev/null
+++ b/cmd/plan9asmtest/module_worker_state_other_unix_test.go
@@ -0,0 +1,7 @@
+//go:build unix && !linux
+
+package main
+
+func moduleWorkerKernelTerminal(int) (string, bool) {
+	return "process absence was not established", false
+}
diff --git a/cmd/plan9asmtest/module_workers.go b/cmd/plan9asmtest/module_workers.go
new file mode 100644
index 000000000..791e34afe
--- /dev/null
+++ b/cmd/plan9asmtest/module_workers.go
@@ -0,0 +1,62 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"path/filepath"
+)
+
+// Only the explicit remaining-package owner may overlap whole packages.
+// Root/profile/default module execution retains its original scheduling. Each
+// package still executes one unfiltered suite with one shard and one worker.
+func runModuleOtherPackages(ctx context.Context, cfg config, report *moduleReport) error {
+	if cfg.ModuleOwner != 2 {
+		return fmt.Errorf("whole-package workers require the explicit remaining-package owner")
+	}
+	type execution struct {
+		result moduleResult
+		err    error
+		done   bool
+	}
+	slots := make([]execution, len(report.Inventory))
+	positions := make(map[int]int)
+	var plan []shardResult
+	for index, pkg := range report.Inventory {
+		if moduleOwner(pkg) != 2 {
+			continue
+		}
+		positions[index] = len(report.Packages)
+		report.Packages = append(report.Packages, moduleResult{
+			Package: pkg.Package, Shards: 1, Workers: 1, Status: "pending",
+		})
+		// Reuse only the existing bounded task/owned-process collector. These
+		// indices address whole packages; no synthetic shard receipt is emitted.
+		plan = append(plan, shardResult{Index: index, Status: "pending"})
+	}
+	if err := ciWriteJSON(filepath.Join(cfg.Out, "module.json"), report); err != nil {
+		return err
+	}
+	err := runShardWorkers(ctx, cfg.Workers, plan,
+		func(ctx context.Context, task shardResult) shardResult {
+			result, err := runModulePackage(ctx, cfg, report.Inventory[task.Index], task.Index)
+			// Each executor owns one distinct slot. Publication through the
+			// worker's result channel precedes the collector's read of that slot.
+			slots[task.Index] = execution{result, err, true}
+			return task
+		}, func(task shardResult) error {
+			report.Packages[positions[task.Index]] = slots[task.Index].result
+			return ciWriteJSON(filepath.Join(cfg.Out, "module.json"), report)
+		})
+	// runShardWorkers has joined all executors, including commands cancelled
+	// before channel publication. Only now read their remaining slots. Never
+	// dispatched packages retain pending, rather than acquiring passing credit.
+	var failures []error
+	for _, task := range plan {
+		if slot := slots[task.Index]; slot.done {
+			report.Packages[positions[task.Index]] = slot.result
+			failures = append(failures, slot.err)
+		}
+	}
+	return errors.Join(append(failures, err)...)
+}
diff --git a/cmd/plan9asmtest/module_workers_unix_test.go b/cmd/plan9asmtest/module_workers_unix_test.go
new file mode 100644
index 000000000..cf682a3b7
--- /dev/null
+++ b/cmd/plan9asmtest/module_workers_unix_test.go
@@ -0,0 +1,267 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// The control directory is outside the immutable observed module. Only real
+// unfiltered Go test bodies publish ready; go list/-list cannot open a barrier.
+func moduleWorkerFixture(t *testing.T, failing bool) (config, string) {
+	t.Helper()
+	moduleFixtureEnvironment(t)
+	dir, controls := moduleFixture(t, false), t.TempDir()
+	for _, name := range []string{"a", "b", "c"} {
+		pkg := filepath.Join(dir, "parallel", name)
+		if err := os.MkdirAll(pkg, 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(pkg, "value.go"), []byte("package parallel\nfunc Value() int { return 7 }\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		source := fmt.Sprintf(`package parallel
+import ("flag"; "fmt"; "os"; "path/filepath"; "testing"; "time")
+func TestMain(m *testing.M) {
+    flag.Parse()
+    if flag.Lookup("test.list").Value.String() == "" { fmt.Println("FULL_PACKAGE_MAIN_%s") }
+    os.Exit(m.Run())
+}
+func TestHeld(t *testing.T) {
+    directory, name := %q, %q
+    if err := os.WriteFile(filepath.Join(directory, "pid-"+name), []byte(fmt.Sprint(os.Getpid())), 0600); err != nil { t.Fatal(err) }
+    active := filepath.Join(directory, "active-"+name)
+    if err := os.WriteFile(active, []byte(name), 0600); err != nil { t.Fatal(err) }
+    defer os.Remove(active)
+    ready := filepath.Join(directory, "ready-"+name)
+    if err := os.WriteFile(ready+".pending", []byte(name), 0600); err != nil { t.Fatal(err) }
+    if err := os.Rename(ready+".pending", ready); err != nil { t.Fatal(err) }
+    deadline := time.Now().Add(2*time.Minute)
+    for {
+        if _, err := os.Stat(filepath.Join(directory, "release-"+name)); err == nil { break }
+        if time.Now().After(deadline) { t.Fatal("actual package barrier expired") }
+        time.Sleep(10*time.Millisecond)
+    }
+    if %t && name == "b" { t.Fatal("retained actual package failure") }
+}
+func ExampleValue() { fmt.Println(Value()); /* Output: 7 */ }
+func FuzzValue(f *testing.F) { f.Add(1); f.Fuzz(func(t *testing.T, n int) { if Value()!=7 { t.Fatal(n) } }) }
+func BenchmarkNever(b *testing.B) { b.Fatal("benchmark executed") }
+`, name, controls, name, failing)
+		if err := os.WriteFile(filepath.Join(pkg, "value_test.go"), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return config{Go: "go", Dir: dir, Package: ".", Out: filepath.Join(t.TempDir(), "owner-0002"),
+		Module: true, ModuleOwner: 2, CIOwner: -1, Shards: 2, Workers: 2, Timeout: 3 * time.Minute,
+		Flags: []string{"-p=1"}}, controls
+}
+
+func moduleWorkerWaitReady(t *testing.T, ctx context.Context, controls, name string, done <-chan error) {
+	t.Helper()
+	for {
+		data, err := os.ReadFile(filepath.Join(controls, "ready-"+name))
+		if err == nil {
+			if string(data) != name {
+				t.Fatal("partial or foreign ready publication", name, string(data))
+			}
+			return
+		}
+		if !os.IsNotExist(err) {
+			t.Fatal(err)
+		}
+		select {
+		case <-ctx.Done():
+			t.Fatal("actual package did not become ready", name, ctx.Err())
+		case err := <-done:
+			t.Fatal("module completed before actual package ready", name, err)
+		case <-time.After(10 * time.Millisecond):
+		}
+	}
+}
+
+func moduleWorkerRelease(t *testing.T, controls, name string) {
+	t.Helper()
+	if err := os.WriteFile(filepath.Join(controls, "release-"+name), []byte(name), 0600); err != nil {
+		t.Error(err)
+	}
+}
+
+func moduleWorkerStart(t *testing.T, cfg config, controls string) (context.Context, context.CancelFunc, <-chan error) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
+	done := make(chan error, 1)
+	joined := make(chan struct{})
+	go func() {
+		done <- runModule(ctx, cfg)
+		close(joined)
+	}()
+	t.Cleanup(func() {
+		cancel()
+		for _, name := range []string{"a", "b", "c"} {
+			moduleWorkerRelease(t, controls, name)
+		}
+		<-joined
+	})
+	return ctx, cancel, done
+}
+
+func TestModuleOtherWorkersActualWholePackagesAndStableUnion(t *testing.T) {
+	for _, failing := range []bool{false, true} {
+		t.Run(fmt.Sprintf("failure-%t", failing), func(t *testing.T) {
+			cfg, controls := moduleWorkerFixture(t, failing)
+			ctx, _, done := moduleWorkerStart(t, cfg, controls)
+			moduleWorkerWaitReady(t, ctx, controls, "a", done)
+			moduleWorkerWaitReady(t, ctx, controls, "b", done)
+			if _, err := os.Stat(filepath.Join(controls, "active-a")); err != nil {
+				t.Fatal("whole packages executed serially instead of sharing two bounded workers", err)
+			}
+			if _, err := os.Stat(filepath.Join(controls, "ready-c")); !os.IsNotExist(err) {
+				t.Fatal("third whole package escaped the two-worker limit", err)
+			}
+			moduleWorkerRelease(t, controls, "b")
+			moduleWorkerWaitReady(t, ctx, controls, "c", done)
+			if _, err := os.Stat(filepath.Join(controls, "active-a")); err != nil {
+				t.Fatal("first real package did not remain active until independently released", err)
+			}
+			moduleWorkerRelease(t, controls, "c")
+			moduleWorkerRelease(t, controls, "a")
+			err := <-done
+			if (err != nil) != failing {
+				t.Fatal("actual package failure was lost or invented", err)
+			}
+			var report moduleReport
+			if err := ciReadJSON(filepath.Join(cfg.Out, "module.json"), &report); err != nil {
+				t.Fatal(err)
+			}
+			position := 0
+			for index, pkg := range report.Inventory {
+				if moduleOwner(pkg) != 2 {
+					continue
+				}
+				if position >= len(report.Packages) || report.Packages[position].Package != pkg.Package {
+					t.Fatal("collector replaced actual inventory order with worker completion order", report.Packages)
+				}
+				result := report.Packages[position]
+				position++
+				wantFailure := failing && strings.HasSuffix(pkg.Package, "/parallel/b")
+				wantStatus := "passed"
+				if wantFailure {
+					wantStatus = "failed"
+				}
+				if result.Status != wantStatus || result.Shards != 1 || result.Workers != 1 {
+					t.Fatal("complete-package resource boundary or original failure changed", result)
+				}
+				if strings.Contains(pkg.Package, "/parallel/") {
+					var suite suiteReport
+					out := filepath.Join(cfg.Out, fmt.Sprintf("package-%04d", index))
+					if err := ciReadJSON(filepath.Join(out, "report.json"), &suite); err != nil {
+						t.Fatal(err)
+					}
+					if !suite.FullPackage || len(suite.Shards) != 1 || len(suite.Benchmarks) != 1 ||
+						len(suite.Names) != 3 || len(suite.Shards[0].Command) == 0 ||
+						strings.Contains(strings.Join(suite.Shards[0].Command, " "), "-run=") {
+						t.Fatal("whole-package execution lost Test/Example/Fuzz/Benchmark/TestMain semantics", suite)
+					}
+					for _, root := range []string{"ExampleValue", "FuzzValue", "TestHeld"} {
+						if suite.Shards[0].Outcomes[root] == "" {
+							t.Fatal("actual whole-package root never executed", root)
+						}
+					}
+					data, err := os.ReadFile(filepath.Join(out, "shard-0000.stdout"))
+					if err != nil || strings.Count(string(data), "FULL_PACKAGE_MAIN_") != 1 {
+						t.Fatal("TestMain was missing, filtered or repeated", err)
+					}
+				}
+			}
+			if position != len(report.Packages) || (report.Status == "failed") != failing {
+				t.Fatal("module collector lost packages or original failure", report)
+			}
+			if failing {
+				if err := verifyModuleOwner(report, cfg.Out); err == nil {
+					t.Fatal("failed actual package became complete module success")
+				}
+				return
+			}
+			container := filepath.Dir(cfg.Out)
+			for owner := 0; owner < 2; owner++ {
+				other := cfg
+				other.ModuleOwner, other.Out = owner, filepath.Join(container, fmt.Sprintf("owner-%04d", owner))
+				if err := runModule(ctx, other); err != nil {
+					t.Fatal(err)
+				}
+			}
+			aggregate := cfg
+			aggregate.ModuleOwner, aggregate.ModuleVerify = -1, container
+			aggregate.Out = filepath.Join(t.TempDir(), "aggregate")
+			if err := runModule(ctx, aggregate); err != nil {
+				t.Fatal("fresh strict aggregate rejected full concurrent-package union", err)
+			}
+		})
+	}
+}
+
+func TestModuleOtherWorkersActualCancellationStopsDispatchAndJoins(t *testing.T) {
+	cfg, controls := moduleWorkerFixture(t, false)
+	ctx, cancel, done := moduleWorkerStart(t, cfg, controls)
+	moduleWorkerWaitReady(t, ctx, controls, "a", done)
+	moduleWorkerWaitReady(t, ctx, controls, "b", done)
+	cancel()
+	if err := <-done; err == nil {
+		t.Fatal("cancelled whole packages became success")
+	}
+	if _, err := os.Stat(filepath.Join(controls, "ready-c")); !os.IsNotExist(err) {
+		t.Fatal("cancellation dispatched an unstarted package", err)
+	}
+	for _, name := range []string{"a", "b"} {
+		data, err := os.ReadFile(filepath.Join(controls, "pid-"+name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		pid, err := strconv.Atoi(string(data))
+		if err != nil || pid <= 0 {
+			t.Fatal("invalid actual package process ID", name, string(data), err)
+		}
+		if err := syscall.Kill(pid, 0); err != syscall.ESRCH {
+			if evidence, terminal := moduleWorkerKernelTerminal(pid); terminal {
+				t.Logf("actual package exited; its outside-group parent retains a zombie: %s", evidence)
+			} else {
+				t.Fatal("module returned before actual package process exited", name, pid, err, evidence)
+			}
+		}
+	}
+	var report moduleReport
+	if err := ciReadJSON(filepath.Join(cfg.Out, "module.json"), &report); err != nil {
+		t.Fatal(err)
+	}
+	if report.Status != "failed" || verifyModuleOwner(report, cfg.Out) == nil {
+		t.Fatal("missing or cancelled actual commands became complete success", report)
+	}
+	for index, pkg := range report.Inventory {
+		if strings.HasSuffix(pkg.Package, "/parallel/c") {
+			if _, err := os.Lstat(filepath.Join(cfg.Out, fmt.Sprintf("package-%04d", index))); !os.IsNotExist(err) {
+				t.Fatal("unstarted package acquired command artifacts", err)
+			}
+			found := false
+			for _, result := range report.Packages {
+				if result.Package == pkg.Package {
+					found = true
+					if result.Status != "pending" {
+						t.Fatal("never dispatched package acquired terminal credit", result)
+					}
+				}
+			}
+			if !found {
+				t.Fatal("cancelled module erased its planned unstarted package")
+			}
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/numerical_read_dispatch_test.go b/cmd/plan9asmtest/numerical_read_dispatch_test.go
new file mode 100644
index 000000000..ed7d4cfd6
--- /dev/null
+++ b/cmd/plan9asmtest/numerical_read_dispatch_test.go
@@ -0,0 +1,64 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoweredNumericalReadsDispatchBeforeNativeFamilies(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(),
+		filepath.Join("..", "..", "amd64_scalar_fp_native_read.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var transfer *ast.FuncLit
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "checkLoweredScalarFPResultInitialization" {
+			continue
+		}
+		for _, statement := range function.Body.List {
+			assignment, ok := statement.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				continue
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			if ok && name.Name == "transfer" {
+				transfer, _ = assignment.Rhs[0].(*ast.FuncLit)
+			}
+		}
+	}
+	if transfer == nil {
+		t.Fatal("missing paired lowering transfer")
+	}
+	var first []string
+	for _, statement := range transfer.Body.List {
+		branch, ok := statement.(*ast.IfStmt)
+		if !ok {
+			continue
+		}
+		assignment, ok := branch.Init.(*ast.AssignStmt)
+		if !ok || len(assignment.Rhs) != 1 {
+			t.Fatal("source dispatch lost its explicit checked transfer")
+		}
+		call, ok := assignment.Rhs[0].(*ast.CallExpr)
+		if !ok {
+			t.Fatal("source dispatch lost its direct consumer call")
+		}
+		name, ok := call.Fun.(*ast.Ident)
+		if !ok {
+			t.Fatal("a generic native role preceded authenticated source dispatch")
+		}
+		first = append(first, name.Name)
+		if len(first) == 3 {
+			break
+		}
+	}
+	if len(first) != 3 || first[0] != "goFuncvalReadTransfer" ||
+		first[1] != "x86ResultSDKLiteralStep" || first[2] != "x86ResultNumericalReadStep" {
+		t.Fatal("native families shadow authenticated source consumers", first)
+	}
+}
diff --git a/cmd/plan9asmtest/object_family_partition.go b/cmd/plan9asmtest/object_family_partition.go
new file mode 100644
index 000000000..47e03b2e5
--- /dev/null
+++ b/cmd/plan9asmtest/object_family_partition.go
@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+// These are complete source object/native roles, not a test inventory.
+// Missing roles are never synthesized: the actual Go list still determines
+// every executed root. Fixed domains keep ownership independent of input
+// order, unrelated roots and subset queries. Other names retain their hash.
+func completeObjectFamilyOwners(shards int) map[string]int {
+	owners := make(map[string]int)
+	ordinal := 0
+	for _, family := range []struct {
+		prefix, suffix string
+		roles          []string
+		batches        int
+	}{
+		{"TestGoAMD64FixedLocalConversionActualObjects", "", []string{"Linux", "Darwin", "Windows"}, 12},
+		{"TestGoAMD64FixedLocalPackedCompleteFormsActualObjects", "", []string{"Linux", "Darwin", "Windows"}, 4},
+		{"TestX86CMOVFamilyFixedLocalAUTOActualObjects", "", []string{"Linux", "Darwin"}, 6},
+		{"TestGoAMD64FixedLocalReadonlyData", "RegisteredConsumers", []string{"Linux", "Darwin", "Windows"}, 0},
+		{"TestGoAMD64FixedLocalPackedWideRuntimeOracle", "CompileOnly", []string{"", "Module", "GoModule"}, 0},
+		{"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWide", "", []string{""}, 6},
+		{"TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNative", "", []string{""}, 7},
+		{"TestGoX86NumericalReadRevokeDuringFinalSDKCallback", "", []string{""}, 0},
+		{"TestARM64GPImmediateScratchCompleteObjects", "", []string{""}, 0},
+	} {
+		for _, role := range family.roles {
+			if family.batches == 0 {
+				owners[family.prefix+role+family.suffix] = ordinal % shards
+				ordinal++
+				continue
+			}
+			for batch := 0; batch < family.batches; batch++ {
+				name := fmt.Sprintf("%s%sBatch%02d", family.prefix, role, batch)
+				owners[name] = ordinal % shards
+				ordinal++
+			}
+		}
+	}
+	return owners
+}
diff --git a/cmd/plan9asmtest/parallel_cli_unix_test.go b/cmd/plan9asmtest/parallel_cli_unix_test.go
new file mode 100644
index 000000000..42fed92fe
--- /dev/null
+++ b/cmd/plan9asmtest/parallel_cli_unix_test.go
@@ -0,0 +1,135 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func parallelFixtureCLI(t *testing.T) string {
+	t.Helper()
+	binary := filepath.Join(t.TempDir(), "plan9asmtest")
+	stem := filepath.Join(t.TempDir(), "build")
+	_, err := captureCommand(context.Background(), 2*time.Minute, ".", "go",
+		[]string{"build", "-p=1", "-o", binary, "."}, stem)
+	if err != nil {
+		stderr, _ := os.ReadFile(stem + ".stderr")
+		t.Fatalf("build actual CLI: %v\n%s", err, stderr)
+	}
+	return binary
+}
+
+func TestParallelCLIActualGoInventoryAndCoverage(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	binary := parallelFixtureCLI(t)
+	dir := fixture(t, `package fixture
+
+import (
+    "fmt"
+    "os"
+    "testing"
+    "time"
+)
+
+func peer(t *testing.T, own, other string) {
+    t.Helper()
+    if err := os.WriteFile(own, []byte("started"), 0600); err != nil {
+        t.Fatal(err)
+    }
+    deadline := time.Now().Add(10 * time.Second)
+    for time.Now().Before(deadline) {
+        if _, err := os.Stat(other); err == nil {
+            return
+        }
+        time.Sleep(10 * time.Millisecond)
+    }
+    t.Fatal("the other actual Go shard did not execute concurrently")
+}
+
+// Their first eight SHA-256 bytes have different remainders modulo two.
+func TestWorkerOne(t *testing.T) { peer(t, "one", "two") }
+func TestAlpha(t *testing.T) {
+    t.Run("peer", func(t *testing.T) { peer(t, "two", "one") })
+}
+func TestExistingSkip(t *testing.T) { t.Skip("existing explicit source skip") }
+func Example() { fmt.Println(value()); /* Output: 7 */ }
+func FuzzSeeds(f *testing.F) {
+    f.Add(1)
+    f.Add(2)
+    f.Fuzz(func(t *testing.T, input int) {
+        if value() != 7 { t.Fatal(input) }
+    })
+}
+func BenchmarkNotRun(b *testing.B) { b.Fatal("ordinary suite ran a benchmark") }
+`)
+	out := filepath.Join(t.TempDir(), "report")
+	stem := filepath.Join(t.TempDir(), "cli")
+	_, err := captureCommand(context.Background(), 4*time.Minute, ".", binary,
+		[]string{"-dir", dir, "-out", out, "-shards=2", "-workers=2", "-timeout=2m", "--",
+			"-race", "-covermode=atomic", "-coverprofile=actual.cover", "-p=1"}, stem)
+	if err != nil {
+		stderr, _ := os.ReadFile(stem + ".stderr")
+		t.Fatalf("actual bounded parallel CLI: %v\n%s", err, stderr)
+	}
+	report := readReport(t, out)
+	if report.Status != "passed" || len(report.Names) != 5 || report.RootPassed != 4 ||
+		report.RootSkipped != 1 || report.RootFailed != 0 || report.RootMissing != 0 ||
+		report.ChildPassed != 3 || report.ChildFailed != 0 || report.ChildMissing != 0 ||
+		len(report.Benchmarks) != 1 {
+		t.Fatalf("parallel execution changed the exhaustive denominator: %+v", report)
+	}
+	for _, shard := range report.Shards {
+		command := strings.Join(shard.Command, " ")
+		if shard.Status != "passed" || !strings.Contains(command, "-race") ||
+			!strings.Contains(command, "-timeout=2m0s") || !strings.Contains(command, "-count=1") {
+			t.Fatalf("parallelism changed execution flags: %+v", shard)
+		}
+	}
+	data, err := os.ReadFile(filepath.Join(out, "report.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var metadata struct {
+		Workers int `json:"workers"`
+	}
+	if err := json.Unmarshal(data, &metadata); err != nil || metadata.Workers != 2 {
+		t.Fatalf("actual worker limit was not retained: workers=%d err=%v", metadata.Workers, err)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "actual.cover")); err != nil {
+		t.Fatalf("complete actual parallel coverage absent: %v", err)
+	}
+}
+
+func TestParallelCLIFailureKeepsRemainingRootsAndNoMergedCoverage(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	binary := parallelFixtureCLI(t)
+	dir := fixture(t, `package fixture
+
+import "testing"
+
+func TestWorkerOne(t *testing.T) { t.Fatal("original source failure") }
+func TestAlpha(t *testing.T) { t.Run("remaining", func(t *testing.T) {}) }
+`)
+	out := filepath.Join(t.TempDir(), "report")
+	stem := filepath.Join(t.TempDir(), "cli")
+	_, err := captureCommand(context.Background(), 3*time.Minute, ".", binary,
+		[]string{"-dir", dir, "-out", out, "-shards=8", "-workers=2", "-timeout=2m", "--",
+			"-coverprofile=must-not-exist.cover", "-p=1"}, stem)
+	if err == nil {
+		t.Fatal("actual failed child became success")
+	}
+	report := readReport(t, out)
+	if report.Status != "failed" || report.RootFailed != 1 || report.RootPassed != 1 ||
+		report.RootMissing != 0 || report.ChildPassed != 1 || report.ChildMissing != 0 {
+		t.Fatalf("parallel failure canceled or hid other roots: %+v", report)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "must-not-exist.cover")); !os.IsNotExist(err) {
+		t.Fatalf("failed suite published merged coverage: %v", err)
+	}
+}
diff --git a/cmd/plan9asmtest/process_other.go b/cmd/plan9asmtest/process_other.go
new file mode 100644
index 000000000..682990b54
--- /dev/null
+++ b/cmd/plan9asmtest/process_other.go
@@ -0,0 +1,12 @@
+//go:build !unix && !windows
+
+package main
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func runOwnedCommand(cmd *exec.Cmd) error {
+	return fmt.Errorf("exhaustive runner requires Unix owned-process-group cleanup; this host is not yet supported")
+}
diff --git a/cmd/plan9asmtest/process_unix.go b/cmd/plan9asmtest/process_unix.go
new file mode 100644
index 000000000..88aa77f0e
--- /dev/null
+++ b/cmd/plan9asmtest/process_unix.go
@@ -0,0 +1,13 @@
+//go:build unix
+
+package main
+
+import (
+	"os/exec"
+
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+)
+
+func runOwnedCommand(cmd *exec.Cmd) error {
+	return ownedprocess.Run(cmd)
+}
diff --git a/cmd/plan9asmtest/process_windows.go b/cmd/plan9asmtest/process_windows.go
new file mode 100644
index 000000000..b2d589160
--- /dev/null
+++ b/cmd/plan9asmtest/process_windows.go
@@ -0,0 +1,11 @@
+package main
+
+import (
+	"os/exec"
+
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+)
+
+func runOwnedCommand(cmd *exec.Cmd) error {
+	return ownedprocess.Run(cmd)
+}
diff --git a/cmd/plan9asmtest/process_windows_test.go b/cmd/plan9asmtest/process_windows_test.go
new file mode 100644
index 000000000..5849684e5
--- /dev/null
+++ b/cmd/plan9asmtest/process_windows_test.go
@@ -0,0 +1,194 @@
+//go:build windows
+
+package main
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/sys/windows"
+)
+
+// Use real descendants, including one retaining the parent's output pipe.
+// Neither taskkill by image name nor killing just the immediate child suffices.
+func TestWindowsOwnedCommandTree(t *testing.T) {
+	for _, role := range []string{"exit", "failure", "cancel"} {
+		t.Run(role, func(t *testing.T) {
+			dir := t.TempDir()
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+			cmd := windowsOwnershipHelper(ctx, "parent", dir, role)
+			var output bytes.Buffer
+			cmd.Stdout, cmd.Stderr = &output, &output
+			cmd.WaitDelay = time.Second
+			done := make(chan error, 1)
+			go func() { done <- runOwnedCommand(cmd) }()
+			t.Cleanup(func() {
+				cancel()
+				select {
+				case <-done:
+				case <-time.After(5 * time.Second):
+					t.Error("owned command failed to finish cleanup")
+				}
+			})
+
+			var handles []windows.Handle
+			for _, name := range []string{"parent", "child", "grandchild"} {
+				pid := waitWindowsOwnedPID(t, filepath.Join(dir, name), done)
+				handle, err := windows.OpenProcess(windows.SYNCHRONIZE|windows.PROCESS_TERMINATE, false, pid)
+				if err != nil {
+					t.Fatal(err)
+				}
+				handles = append(handles, handle)
+				t.Cleanup(func() {
+					// Also clean a faulty implementation's actual fixture process.
+					windows.TerminateProcess(handle, 1)
+					windows.CloseHandle(handle)
+				})
+			}
+			if role == "cancel" {
+				cancel()
+			} else if err := os.WriteFile(filepath.Join(dir, "release"), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+			select {
+			case err := <-done:
+				done <- err // Cleanup observes completion too.
+				if role == "exit" && err != nil {
+					t.Fatalf("ordinary parent exit must close inherited pipes: %v\n%s", err, output.String())
+				}
+				if role != "exit" && err == nil {
+					t.Fatal("failed/cancelled command became successful")
+				}
+				if role == "failure" {
+					var exit *exec.ExitError
+					if !errors.As(err, &exit) || exit.ExitCode() != 7 {
+						t.Fatalf("original exit status lost: %v", err)
+					}
+				}
+			case <-time.After(10 * time.Second):
+				t.Fatal("owned command blocked on a descendant or its pipe")
+			}
+			for i, handle := range handles {
+				state, err := windows.WaitForSingleObject(handle, 0)
+				if err != nil || state != windows.WAIT_OBJECT_0 {
+					t.Errorf("process %d still live after Run returned: state=%d error=%v", i, state, err)
+				}
+			}
+		})
+	}
+}
+
+func TestWindowsOwnedCommandDoesNotKillPeer(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	dir := t.TempDir()
+	peer := windowsOwnershipHelper(ctx, "grandchild", dir, "")
+	if err := peer.Start(); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		peer.Process.Kill()
+		peer.Wait()
+	})
+	cmd := windowsOwnershipHelper(ctx, "immediate", t.TempDir(), "")
+	if err := runOwnedCommand(cmd); err != nil {
+		t.Fatal(err)
+	}
+	handle, err := windows.OpenProcess(windows.SYNCHRONIZE, false, uint32(peer.Process.Pid))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer windows.CloseHandle(handle)
+	if state, err := windows.WaitForSingleObject(handle, 0); err != nil || state != uint32(windows.WAIT_TIMEOUT) {
+		t.Fatalf("unowned peer was killed: state=%d error=%v", state, err)
+	}
+}
+
+func TestWindowsOwnedCommandStartFailures(t *testing.T) {
+	plain := exec.Command(os.Args[0], "-test.run=^TestWindowsOwnedCommandHelper$", "--", "immediate", t.TempDir(), "")
+	if err := runOwnedCommand(plain); err != nil {
+		t.Fatalf("ordinary non-context command failed: %v", err)
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	cmd := windowsOwnershipHelper(ctx, "immediate", t.TempDir(), "")
+	if err := runOwnedCommand(cmd); !errors.Is(err, context.Canceled) {
+		t.Fatalf("pre-start cancellation lost: %v", err)
+	}
+	if err := runOwnedCommand(exec.Command(filepath.Join(t.TempDir(), "missing.exe"))); err == nil {
+		t.Fatal("missing executable was successful")
+	}
+}
+
+func windowsOwnershipHelper(ctx context.Context, role, dir, result string) *exec.Cmd {
+	return exec.CommandContext(ctx, os.Args[0], "-test.run=^TestWindowsOwnedCommandHelper$", "--", role, dir, result)
+}
+
+func waitWindowsOwnedPID(t *testing.T, path string, done chan error) uint32 {
+	t.Helper()
+	deadline := time.NewTimer(20 * time.Second)
+	defer deadline.Stop()
+	ticker := time.NewTicker(20 * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		if data, err := os.ReadFile(path); err == nil {
+			if pid, err := strconv.ParseUint(strings.TrimSpace(string(data)), 10, 32); err == nil && pid > 1 {
+				return uint32(pid)
+			}
+		}
+		select {
+		case err := <-done:
+			done <- err
+			t.Fatalf("command ended before descendant readiness: %v", err)
+		case <-deadline.C:
+			t.Fatal("descendant readiness timed out")
+		case <-ticker.C:
+		}
+	}
+}
+
+func TestWindowsOwnedCommandHelper(t *testing.T) {
+	if len(os.Args) != 6 || os.Args[2] != "--" {
+		return
+	}
+	role, dir, result := os.Args[3], os.Args[4], os.Args[5]
+	if role == "immediate" {
+		os.Exit(0)
+	}
+	if err := os.WriteFile(filepath.Join(dir, role), []byte(strconv.Itoa(os.Getpid())), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if role == "parent" || role == "child" {
+		next := "child"
+		if role == "child" {
+			next = "grandchild"
+		}
+		child := windowsOwnershipHelper(context.Background(), next, dir, result)
+		child.Stdout, child.Stderr = os.Stdout, os.Stderr
+		if err := child.Start(); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for {
+		if role == "parent" {
+			if _, err := os.Stat(filepath.Join(dir, "release")); err == nil {
+				fmt.Println("parent completed")
+				if result == "failure" {
+					os.Exit(7)
+				}
+				os.Exit(0)
+			}
+		}
+		time.Sleep(20 * time.Millisecond)
+	}
+}
diff --git a/cmd/plan9asmtest/race_scheduling_layout_test.go b/cmd/plan9asmtest/race_scheduling_layout_test.go
new file mode 100644
index 000000000..87a1c227c
--- /dev/null
+++ b/cmd/plan9asmtest/race_scheduling_layout_test.go
@@ -0,0 +1,42 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRaceSchedulingRetainsTwoWholeShardsPerOwner(t *testing.T) {
+	parts, err := moduleRootShardParts(64, 32)
+	if err != nil || len(parts) != 32 {
+		t.Fatal("complete race root scheduling layout", parts, err)
+	}
+	seen := make([]int, 64)
+	for owner, shards := range parts {
+		if len(shards) != 2 || shards[0] != owner || shards[1] != owner+32 {
+			t.Fatal("race scheduling changed its original two-shard resource boundary", owner, shards)
+		}
+		for _, shard := range shards {
+			seen[shard]++
+		}
+	}
+	for shard, count := range seen {
+		if count != 1 {
+			t.Fatal("missing or duplicate complete race shard", shard, count)
+		}
+	}
+	source, err := os.ReadFile(filepath.Join("..", "..", "scripts", "test-module-ci.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{
+		"race) timeout=60m; flags=(-race); root_partitions=32; shards=64 ;;",
+		"-shards=$shards -workers=2", "-timeout=$timeout", "GOMAXPROCS=2",
+		"-module-root-partitions=$root_partitions", "-module-root-partition=$4",
+	} {
+		if !strings.Contains(string(source), required) {
+			t.Error("actual execution and complete aggregation must retain the race layout/resource contract:", required)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/sdk_bytealg_partition_test.go b/cmd/plan9asmtest/sdk_bytealg_partition_test.go
new file mode 100644
index 000000000..5e5ec0ac1
--- /dev/null
+++ b/cmd/plan9asmtest/sdk_bytealg_partition_test.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func checkSDKBytealgRootOwners(source []byte) error {
+	syntax, err := parser.ParseFile(token.NewFileSet(), "bytealg_test.go", source, 0)
+	if err != nil {
+		return err
+	}
+	wanted := map[string]string{
+		"TestCompileOneX86SDKBytealgCountExistingObjects":     "count_amd64.s",
+		"TestCompileOneX86SDKBytealgIndexByteExistingObjects": "indexbyte_amd64.s",
+	}
+	var roots []string
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || !strings.HasPrefix(function.Name.Name, "TestCompileOneX86SDKBytealg") {
+			continue
+		}
+		filename, exists := wanted[function.Name.Name]
+		if !exists || function.Body == nil || len(function.Body.List) != 1 {
+			return fmt.Errorf("SDK bytealg needs independent complete file owners: %s", function.Name.Name)
+		}
+		statement, ok := function.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			return fmt.Errorf("SDK bytealg owner is not a whole-file dispatch")
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 2 {
+			return fmt.Errorf("SDK bytealg owner changed its complete dispatch")
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != "compileX86SDKBytealgExistingObject" {
+			return fmt.Errorf("SDK bytealg owner bypasses the whole-file helper")
+		}
+		literal, ok := call.Args[1].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return fmt.Errorf("SDK bytealg owner lost its exact original member")
+		}
+		actual, err := strconv.Unquote(literal.Value)
+		if err != nil || actual != filename {
+			return fmt.Errorf("SDK bytealg owner changed its original member: %s", actual)
+		}
+		roots = append(roots, function.Name.Name)
+	}
+	if len(roots) != len(wanted) {
+		return fmt.Errorf("SDK bytealg lost a complete file owner: %v", roots)
+	}
+	shards, err := partition(roots, 8)
+	if err != nil {
+		return err
+	}
+	owners := make(map[int]bool)
+	for index, names := range shards {
+		if len(names) == 0 {
+			continue
+		}
+		if len(names) != 1 || owners[index%4] {
+			return fmt.Errorf("SDK bytealg files share a Windows scheduling owner: %v", names)
+		}
+		owners[index%4] = true
+	}
+	return nil
+}
+
+func TestSDKBytealgFilesHaveIndependentCompleteRootOwners(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join("..", "plan9asmll", "x86_sdk_numerical_source_go127_test.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := checkSDKBytealgRootOwners(source); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestSDKBytealgRootOwnershipRejectsReducedOrSharedMatrix(t *testing.T) {
+	const source = `package main
+func TestCompileOneX86SDKBytealgCountExistingObjects(t *testing.T) {
+	compileX86SDKBytealgExistingObject(t, "count_amd64.s")
+}
+func TestCompileOneX86SDKBytealgIndexByteExistingObjects(t *testing.T) {
+	compileX86SDKBytealgExistingObject(t, "indexbyte_amd64.s")
+}
+`
+	if err := checkSDKBytealgRootOwners([]byte(source)); err != nil {
+		t.Fatal(err)
+	}
+	for name, changed := range map[string]string{
+		"missing-file": strings.Replace(source, "TestCompileOneX86SDKBytealgIndexByteExistingObjects", "disabledIndexByte", 1),
+		"same-file":    strings.Replace(source, "indexbyte_amd64.s", "count_amd64.s", 1),
+		"subset":       strings.Replace(source, "compileX86SDKBytealgExistingObject", "compileOnlySelectedFunctions", 1),
+		"shared-root":  strings.Replace(source, "TestCompileOneX86SDKBytealgCountExistingObjects", "TestCompileOneX86SDKBytealgExistingObjects", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := checkSDKBytealgRootOwners([]byte(changed)); err == nil {
+				t.Fatal("reduced/shared SDK bytealg matrix passed scheduling verification")
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/signals_other.go b/cmd/plan9asmtest/signals_other.go
new file mode 100644
index 000000000..2e7c7ffbf
--- /dev/null
+++ b/cmd/plan9asmtest/signals_other.go
@@ -0,0 +1,7 @@
+//go:build !unix
+
+package main
+
+import "os"
+
+func cancellationSignals() []os.Signal { return []os.Signal{os.Interrupt} }
diff --git a/cmd/plan9asmtest/signals_unix.go b/cmd/plan9asmtest/signals_unix.go
new file mode 100644
index 000000000..235718f7c
--- /dev/null
+++ b/cmd/plan9asmtest/signals_unix.go
@@ -0,0 +1,12 @@
+//go:build unix
+
+package main
+
+import (
+	"os"
+	"syscall"
+)
+
+func cancellationSignals() []os.Signal {
+	return []os.Signal{os.Interrupt, syscall.SIGTERM, syscall.SIGHUP}
+}
diff --git a/cmd/plan9asmtest/suite.go b/cmd/plan9asmtest/suite.go
new file mode 100644
index 000000000..6ec4364ef
--- /dev/null
+++ b/cmd/plan9asmtest/suite.go
@@ -0,0 +1,366 @@
+package main
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+)
+
+type config struct {
+	Go, Dir, Package, Out string
+	Shards                int
+	Workers               int
+	Timeout               time.Duration
+	Flags                 []string
+	CISelector, CIIsolate string
+	CIOwner               int
+	CIVerify              string
+	Module                bool
+	ModuleVerify          string
+	ModuleOwner           int
+	ModuleRootPartitions  int
+	ModuleRootPartition   int
+	// Only the module orchestrator sets these from actual package metadata.
+	fullPackage, noTestFiles bool
+	rootPart                 *moduleRootPart
+}
+
+type shardResult struct {
+	Index    int               `json:"index"`
+	Names    []string          `json:"planned"`
+	Command  []string          `json:"command,omitempty"`
+	Outcomes map[string]string `json:"outcomes,omitempty"`
+	Seconds  float64           `json:"seconds"`
+	Status   string            `json:"status"`
+	Error    string            `json:"error,omitempty"`
+}
+
+type suiteReport struct {
+	Schema       int             `json:"schema"`
+	Go           string          `json:"go_executable"`
+	GoVersion    string          `json:"go_version"`
+	Package      string          `json:"package"`
+	Flags        []string        `json:"go_flags"`
+	Timeout      string          `json:"command_timeout"`
+	Workers      int             `json:"workers"`
+	Names        []string        `json:"inventory"`
+	Benchmarks   []string        `json:"benchmarks_not_run_by_default_go_test,omitempty"`
+	InventorySHA string          `json:"inventory_sha256"`
+	Shards       []shardResult   `json:"shards"`
+	RootPassed   int             `json:"root_passed"`
+	RootSkipped  int             `json:"root_skipped"`
+	RootFailed   int             `json:"root_failed"`
+	RootMissing  int             `json:"root_incomplete"`
+	ChildPassed  int             `json:"subtests_seeds_passed"`
+	ChildSkipped int             `json:"subtests_seeds_skipped"`
+	ChildFailed  int             `json:"subtests_seeds_failed"`
+	ChildMissing int             `json:"subtests_seeds_incomplete"`
+	Status       string          `json:"status"`
+	Error        string          `json:"error,omitempty"`
+	FullPackage  bool            `json:"full_package,omitempty"`
+	NoTestFiles  bool            `json:"no_test_files,omitempty"`
+	ArtifactDir  string          `json:"artifact_directory,omitempty"`
+	RootPart     *moduleRootPart `json:"root_partition,omitempty"`
+}
+
+func runSuite(ctx context.Context, cfg config) error {
+	if cfg.rootPart != nil && (!cfg.Module || cfg.rootPart.Protocol != moduleRootFragmentProtocol ||
+		cfg.rootPart.Count < 2 || cfg.rootPart.Count > 1024 || cfg.rootPart.Index < 0 || cfg.rootPart.Index >= cfg.rootPart.Count ||
+		cfg.rootPart.Count != cfg.ModuleRootPartitions || cfg.rootPart.Index != cfg.ModuleRootPartition) {
+		return fmt.Errorf("root partition scheduling requires its exact module role")
+	}
+	if err := validateRunnerGoFlags(runtime.GOOS, os.Getenv("GOFLAGS"), cfg.Flags); err != nil {
+		return err
+	}
+	if cfg.Timeout <= 0 || cfg.Package == "" || strings.ContainsAny(cfg.Package, " \t\r\n*?[") || strings.Contains(cfg.Package, "...") {
+		return fmt.Errorf("positive timeout and one exact package required")
+	}
+	// Existing programmatic callers use the zero-value config. The CLI has
+	// an explicit default of one and rejects an explicitly requested zero.
+	if cfg.Workers == 0 {
+		cfg.Workers = 1
+	}
+	if cfg.Workers < 1 || cfg.Workers > 32 || cfg.Workers > cfg.Shards {
+		return fmt.Errorf("workers must be 1..32 and no more than shards")
+	}
+	forwarded, profile, err := validateFlags(cfg.Flags)
+	if err != nil {
+		return err
+	}
+	if profile != "" {
+		forwarded = append(forwarded, "-cover")
+	}
+	if cfg.Go, err = exec.LookPath(cfg.Go); err != nil {
+		return err
+	}
+	cfg.Go, err = filepath.Abs(cfg.Go)
+	if err != nil {
+		return err
+	}
+	cfg.Dir, err = filepath.Abs(cfg.Dir)
+	if err != nil {
+		return err
+	}
+	cfg.Out, err = filepath.Abs(cfg.Out)
+	if err != nil {
+		return err
+	}
+	if profile != "" {
+		if !filepath.IsAbs(profile) {
+			profile = filepath.Join(cfg.Dir, profile)
+		}
+		if _, err := os.Lstat(profile); !os.IsNotExist(err) {
+			return fmt.Errorf("coverage destination must not exist: %s (%v)", profile, err)
+		}
+	}
+	if err := os.Mkdir(cfg.Out, 0755); err != nil {
+		return fmt.Errorf("artifact directory must be new (parent must exist): %w", err)
+	}
+	report := suiteReport{Schema: 1, Go: cfg.Go, Flags: forwarded, Timeout: cfg.Timeout.String(), Workers: cfg.Workers, Status: "failed", FullPackage: cfg.fullPackage, NoTestFiles: cfg.noTestFiles}
+	if cfg.rootPart != nil {
+		part := *cfg.rootPart
+		report.Schema, report.RootPart = 2, &part
+	}
+	if cfg.Module {
+		report.ArtifactDir = cfg.Out
+	}
+	publish := func() error {
+		report.RootMissing = suiteExpectedRoots(report) - report.RootPassed - report.RootSkipped - report.RootFailed
+		data, err := json.MarshalIndent(report, "", "  ")
+		if err != nil {
+			return err
+		}
+		return os.WriteFile(filepath.Join(cfg.Out, suiteReportName(cfg)), append(data, '\n'), 0600)
+	}
+	fail := func(err error) error {
+		report.Error = err.Error()
+		return errors.Join(err, publish())
+	}
+	command := func(stem string, args []string) error {
+		_, err := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, args, filepath.Join(cfg.Out, stem))
+		return err
+	}
+	if err := command("version", []string{"version"}); err != nil {
+		return fail(err)
+	}
+	version, err := os.ReadFile(filepath.Join(cfg.Out, "version.stdout"))
+	if err != nil {
+		return fail(err)
+	}
+	report.GoVersion = strings.TrimSpace(string(version))
+	listArgs := append([]string{"test"}, forwarded...)
+	listArgs = append(listArgs, "-count=1", "-timeout="+cfg.Timeout.String(), "-list=.", cfg.Package)
+	if err := command("inventory", listArgs); err != nil {
+		return fail(fmt.Errorf("actual Go inventory failed: %w", err))
+	}
+	listing, err := os.ReadFile(filepath.Join(cfg.Out, "inventory.stdout"))
+	if err != nil {
+		return fail(err)
+	}
+	report.Package, report.Names, report.Benchmarks, err = parseSuiteList(string(listing), cfg.Module || cfg.fullPackage, cfg.noTestFiles)
+	if err != nil {
+		return fail(err)
+	}
+	if cfg.Module && len(report.Names) == 0 {
+		// A benchmark-only package (including a root) still executes TestMain
+		// and ordinary go test without a filter. It cannot become an empty shard.
+		cfg.fullPackage, cfg.Shards, cfg.Workers = true, 1, 1
+		report.FullPackage, report.Workers = true, 1
+	}
+	shards := [][]string{report.Names}
+	if !cfg.fullPackage {
+		shards, err = partitionForFlags(report.Names, cfg.Shards, forwarded)
+		if err != nil {
+			return fail(err)
+		}
+	}
+	hash := sha256.Sum256([]byte(strings.Join(report.Names, "\n") + "\n"))
+	report.InventorySHA = hex.EncodeToString(hash[:])
+	for i, names := range shards {
+		result := shardResult{Index: i, Names: names, Status: "pending"}
+		if cfg.rootPart != nil && !cfg.rootPart.owns(i, cfg.fullPackage) {
+			result.Status = "not_owned"
+		} else if len(names) == 0 && !cfg.fullPackage {
+			result.Status = "empty"
+		} else {
+			result.Command = append([]string{cfg.Go, "test"}, forwarded...)
+			if profile != "" {
+				result.Command = append(result.Command, "-coverprofile="+filepath.Join(cfg.Out, fmt.Sprintf("shard-%04d.cover", i)))
+			}
+			result.Command = append(result.Command, "-count=1", "-timeout="+cfg.Timeout.String(), "-json")
+			if !cfg.fullPackage {
+				pattern, err := runPattern(names)
+				if err != nil {
+					return fail(err)
+				}
+				result.Command = append(result.Command, "-run="+pattern)
+			}
+			result.Command = append(result.Command, cfg.Package)
+		}
+		report.Shards = append(report.Shards, result)
+	}
+	if err := publish(); err != nil {
+		return err
+	}
+	var failures []error
+	var profiles []string
+	// Workers receive immutable plan values. Only this collector updates the
+	// report, counters and coverage inventory; there are no concurrent writes.
+	plan := append([]shardResult(nil), report.Shards...)
+	if cfg.rootPart != nil {
+		plan = nil
+		for _, shard := range report.Shards {
+			if cfg.rootPart.owns(shard.Index, cfg.fullPackage) {
+				plan = append(plan, shard)
+			}
+		}
+	}
+	err = runShardWorkers(ctx, cfg.Workers, plan, func(ctx context.Context, result shardResult) shardResult {
+		return executeShard(ctx, cfg, report.Package, result)
+	}, func(result shardResult) error {
+		report.Shards[result.Index] = result
+		if result.Status != "passed" {
+			failures = append(failures, fmt.Errorf("shard %d: %s", result.Index, result.Error))
+		}
+		for name, state := range result.Outcomes {
+			child := strings.Contains(name, "/")
+			switch state {
+			case "pass":
+				if child {
+					report.ChildPassed++
+				} else {
+					report.RootPassed++
+				}
+			case "skip":
+				if child {
+					report.ChildSkipped++
+				} else {
+					report.RootSkipped++
+				}
+			case "fail":
+				if child {
+					report.ChildFailed++
+				} else {
+					report.RootFailed++
+				}
+			case "run":
+				if child {
+					report.ChildMissing++
+				}
+			}
+		}
+		if profile != "" {
+			profiles = append(profiles, filepath.Join(cfg.Out, fmt.Sprintf("shard-%04d.cover", result.Index)))
+		}
+		fmt.Printf("shard %d/%d: %s (%d roots, %.3fs)\n", result.Index+1, len(shards), result.Status, len(result.Names), result.Seconds)
+		return publish()
+	})
+	if err != nil {
+		return fail(errors.Join(errors.Join(failures...), err))
+	}
+	if len(failures) != 0 {
+		return fail(errors.Join(failures...))
+	}
+	if profile != "" && (cfg.rootPart == nil || len(profiles) != 0) {
+		merged, err := mergeCoverage(profiles)
+		if err != nil {
+			return fail(err)
+		}
+		file, err := os.OpenFile(profile, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+		if err != nil {
+			return fail(err)
+		}
+		_, writeErr := file.Write(merged)
+		if err := errors.Join(writeErr, file.Close()); err != nil {
+			return fail(err)
+		}
+	}
+	report.Status = suiteCompletionStatus(report)
+	label := "complete root inventory"
+	if cfg.rootPart != nil {
+		label = "complete owned root assignment (partial package)"
+	}
+	fmt.Printf("%s: %d passed, %d skipped, %d failed; subtests/seeds: %d passed, %d skipped, %d failed\n", label, report.RootPassed, report.RootSkipped, report.RootFailed, report.ChildPassed, report.ChildSkipped, report.ChildFailed)
+	return publish()
+}
+
+func executeShard(ctx context.Context, cfg config, pkg string, result shardResult) shardResult {
+	stem := filepath.Join(cfg.Out, fmt.Sprintf("shard-%04d", result.Index))
+	seconds, executionErr := captureCommand(ctx, cfg.Timeout, cfg.Dir, cfg.Go, result.Command[1:], stem)
+	result.Seconds = seconds
+	var validationErr error
+	file, openErr := os.Open(stem + ".stdout")
+	if openErr == nil {
+		result.Outcomes, validationErr = validateSuiteEvents(file, pkg, result.Names, cfg.fullPackage, cfg.noTestFiles)
+		validationErr = errors.Join(validationErr, file.Close())
+	} else {
+		validationErr = openErr
+	}
+	if err := errors.Join(executionErr, validationErr); err != nil {
+		result.Status, result.Error = "failed", err.Error()
+	} else {
+		result.Status = "passed"
+	}
+	return result
+}
+
+type boundedOutput struct {
+	mu        sync.Mutex
+	Remaining int64
+	Cancel    context.CancelFunc
+	Err       error
+}
+
+type outputWriter struct {
+	File  *os.File
+	Bound *boundedOutput
+}
+
+func (writer outputWriter) Write(data []byte) (int, error) {
+	writer.Bound.mu.Lock()
+	defer writer.Bound.mu.Unlock()
+	if int64(len(data)) > writer.Bound.Remaining {
+		writer.Bound.Err = fmt.Errorf("command output exceeds 64 MiB capture bound")
+		writer.Bound.Cancel()
+		return 0, writer.Bound.Err
+	}
+	n, err := writer.File.Write(data)
+	writer.Bound.Remaining -= int64(n)
+	return n, err
+}
+
+func captureCommand(parent context.Context, timeout time.Duration, dir, executable string, args []string, stem string) (float64, error) {
+	ctx, cancel := context.WithTimeout(parent, timeout)
+	defer cancel()
+	out, err := os.OpenFile(stem+".stdout", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		return 0, err
+	}
+	defer out.Close()
+	errOut, err := os.OpenFile(stem+".stderr", os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		return 0, err
+	}
+	defer errOut.Close()
+	bound := &boundedOutput{Remaining: 64 << 20, Cancel: cancel}
+	cmd := exec.CommandContext(ctx, executable, args...)
+	cmd.Dir, cmd.WaitDelay = dir, 2*time.Second
+	cmd.Stdout, cmd.Stderr = outputWriter{out, bound}, outputWriter{errOut, bound}
+	started := time.Now()
+	err = runOwnedCommand(cmd)
+	err = errors.Join(err, ctx.Err(), bound.Err, out.Close(), errOut.Close())
+	return time.Since(started).Seconds(), err
+}
+
+var _ io.Writer = outputWriter{}
diff --git a/cmd/plan9asmtest/suite_unix_test.go b/cmd/plan9asmtest/suite_unix_test.go
new file mode 100644
index 000000000..d3dc4d1a7
--- /dev/null
+++ b/cmd/plan9asmtest/suite_unix_test.go
@@ -0,0 +1,237 @@
+//go:build unix
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func fixture(t *testing.T, source string) string {
+	t.Helper()
+	dir := t.TempDir()
+	files := map[string]string{
+		"go.mod":        "module example.org/runnerfixture\n\ngo 1.20\n",
+		"value.go":      "package fixture\nfunc value() int { return 7 }\n",
+		"value_test.go": source,
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return dir
+}
+
+func readReport(t *testing.T, out string) suiteReport {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(out, "report.json"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var report suiteReport
+	if err := json.Unmarshal(data, &report); err != nil {
+		t.Fatal(err)
+	}
+	return report
+}
+
+func TestActualGoSuiteIncludesAllRootsSeedsAndInstrumentation(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	dir := fixture(t, `package fixture
+import (
+    "fmt"
+    "testing"
+)
+func TestAlpha(t *testing.T) {
+    t.Parallel()
+    t.Run("parallel", func(t *testing.T) { t.Parallel(); if value() != 7 { t.Fatal("value") } })
+}
+func TestBeta(t *testing.T) {
+    t.Run("duplicate", func(t *testing.T) {})
+    t.Run("duplicate", func(t *testing.T) {})
+    t.Run("path/leaf", func(t *testing.T) {})
+}
+func TestExistingSkip(t *testing.T) { t.Skip("existing explicit Go skip") }
+func Example() { fmt.Println(value()); /* Output: 7 */ }
+func FuzzSeeds(f *testing.F) {
+    f.Add(1)
+    f.Add(2)
+    f.Fuzz(func(t *testing.T, input int) { if value() != 7 { t.Fatal(input) } })
+}
+func BenchmarkNotRun(b *testing.B) { b.Fatal("benchmarks must not run in ordinary go test") }
+`)
+	// A build-selected test must appear in both the actual list and execution.
+	selected := "//go:build runnerfixture\n\npackage fixture\nimport \"testing\"\nfunc TestSelected(t *testing.T) {}\n"
+	if err := os.WriteFile(filepath.Join(dir, "selected_test.go"), []byte(selected), 0600); err != nil {
+		t.Fatal(err)
+	}
+	out := filepath.Join(t.TempDir(), "artifacts")
+	// Cold race-instrumented standard-library compilation under the required
+	// Linux diagnostic emulator is distinct from execution. Keep it bounded,
+	// but do not confuse a short fixture build budget with a broken decoder.
+	err := runSuite(context.Background(), config{Go: "go", Dir: dir, Package: ".", Out: out, Shards: 5, Timeout: 4 * time.Minute, Flags: []string{"-race", "-covermode=atomic", "-coverprofile=actual.cover", "-tags=runnerfixture", "-p=1"}})
+	if err != nil {
+		listing, _ := os.ReadFile(filepath.Join(out, "inventory.stdout"))
+		t.Fatalf("actual instrumented suite: %v\n%s", err, listing)
+	}
+	report := readReport(t, out)
+	if report.Status != "passed" || len(report.Names) != 6 || report.RootPassed != 5 || report.RootSkipped != 1 || report.RootFailed != 0 || report.RootMissing != 0 || report.ChildPassed != 6 || len(report.Benchmarks) != 1 {
+		t.Fatalf("incomplete or relabeled actual inventory: %+v", report)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "actual.cover")); err != nil {
+		t.Fatalf("actual race/coverage profile absent: %v", err)
+	}
+	for _, shard := range report.Shards {
+		if len(shard.Names) != 0 && (!strings.Contains(strings.Join(shard.Command, " "), "-race") || shard.Status != "passed") {
+			t.Fatalf("lost instrumentation or execution: %+v", shard)
+		}
+	}
+}
+
+func TestActualGoFailureIsRetainedAndRemainingShardsRun(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	dir := fixture(t, "package fixture\nimport \"testing\"\nfunc TestFails(t *testing.T) { t.Fatal(\"actual failure\") }\nfunc TestRemaining(t *testing.T) {}\n")
+	out := filepath.Join(t.TempDir(), "artifacts")
+	err := runSuite(context.Background(), config{Go: "go", Dir: dir, Package: ".", Out: out, Shards: 5, Timeout: 30 * time.Second})
+	if err == nil {
+		t.Fatal("actual Go child failure was promoted")
+	}
+	report := readReport(t, out)
+	if report.Status != "failed" || report.RootFailed != 1 || report.RootPassed != 1 || report.RootMissing != 0 {
+		t.Fatalf("failure lost or remaining shard omitted: %+v", report)
+	}
+}
+
+func TestActualGoTimeoutCannotPassAndRetainsPlan(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	dir := fixture(t, "package fixture\nimport \"testing\"\nfunc TestHang(t *testing.T) { select {} }\n")
+	out := filepath.Join(t.TempDir(), "artifacts")
+	// Both commands have the same real wall deadline. Allow the actual Go
+	// inventory to compile/link before proving the hung test is canceled.
+	err := runSuite(context.Background(), config{Go: "go", Dir: dir, Package: ".", Out: out, Shards: 1, Timeout: 30 * time.Second})
+	if err == nil {
+		t.Fatal("timed out Go child was promoted")
+	}
+	report := readReport(t, out)
+	if len(report.Names) != 1 || report.Names[0] != "TestHang" || report.Status != "failed" || report.Shards[0].Status != "failed" || report.Shards[0].Outcomes["TestHang"] != "run" || !strings.Contains(report.Error, "deadline exceeded") {
+		t.Fatalf("timeout lost original plan: %+v", report)
+	}
+}
+
+func TestExpiredDeadlineCannotInventAnInventory(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	out := filepath.Join(t.TempDir(), "artifacts")
+	err := runSuite(context.Background(), config{Go: "go", Dir: t.TempDir(), Package: ".", Out: out, Shards: 1, Timeout: time.Nanosecond})
+	if err == nil {
+		t.Fatal("expired command was promoted")
+	}
+	report := readReport(t, out)
+	if report.Status != "failed" || len(report.Names) != 0 || len(report.Shards) != 0 || !strings.Contains(report.Error, "deadline exceeded") {
+		t.Fatalf("expired command invented coverage: %+v", report)
+	}
+}
+
+func TestHiddenFiltersAndOutputReuseFailBeforeExecutingGo(t *testing.T) {
+	dir := t.TempDir()
+	out := filepath.Join(dir, "artifacts")
+	t.Setenv("GOFLAGS", "-run=TestSubset")
+	if err := runSuite(context.Background(), config{Go: "missing-go", Dir: dir, Package: ".", Out: out, Shards: 1, Timeout: time.Second}); err == nil || !strings.Contains(err.Error(), "GOFLAGS") {
+		t.Fatalf("inherited filter was not rejected before Go: %v", err)
+	}
+	if _, err := os.Stat(out); !os.IsNotExist(err) {
+		t.Fatalf("invalid flags touched artifacts: %v", err)
+	}
+	t.Setenv("GOFLAGS", "")
+	if err := os.Mkdir(out, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := runSuite(context.Background(), config{Go: "go", Dir: dir, Package: ".", Out: out, Shards: 1, Timeout: time.Second}); err == nil || !strings.Contains(err.Error(), "must be new") {
+		t.Fatalf("existing artifacts could be overwritten: %v", err)
+	}
+}
+
+func TestCaptureOutputBoundCancelsAndPreservesFailure(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	file, err := os.Create(filepath.Join(t.TempDir(), "bounded"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	bound := &boundedOutput{Remaining: 3, Cancel: cancel}
+	if n, err := (outputWriter{file, bound}).Write([]byte("four")); err == nil || n != 0 || ctx.Err() == nil || bound.Err == nil {
+		t.Fatalf("output bound silently discarded data: n=%d err=%v context=%v", n, err, ctx.Err())
+	}
+}
+
+func TestOwnedCommandKillsDescendantsAfterExitAndTimeout(t *testing.T) {
+	const helperEnv = "PLAN9ASM_TEST_PARTITION_CHILD"
+	if mode := os.Getenv(helperEnv); mode != "" {
+		if mode == "writer" {
+			_ = os.WriteFile("ready", []byte("ready"), 0600)
+			deadline := time.Now().Add(5 * time.Second)
+			for time.Now().Before(deadline) {
+				if _, err := os.Stat("release"); err == nil {
+					_ = os.WriteFile("late-write", []byte("unreleased child"), 0600)
+					os.Exit(0)
+				}
+				time.Sleep(5 * time.Millisecond)
+			}
+			os.Exit(0)
+		}
+		child := exec.Command(os.Args[0], "-test.run=^TestOwnedCommandKillsDescendantsAfterExitAndTimeout$")
+		for _, entry := range os.Environ() {
+			if !strings.HasPrefix(entry, helperEnv+"=") {
+				child.Env = append(child.Env, entry)
+			}
+		}
+		child.Env = append(child.Env, helperEnv+"=writer")
+		if err := child.Start(); err != nil {
+			os.Exit(19)
+		}
+		deadline := time.Now().Add(5 * time.Second)
+		for time.Now().Before(deadline) {
+			if _, err := os.Stat("ready"); err == nil {
+				if mode == "timeout" {
+					time.Sleep(5 * time.Second)
+				}
+				os.Exit(0)
+			}
+			time.Sleep(5 * time.Millisecond)
+		}
+		os.Exit(20)
+	}
+	for _, mode := range []string{"success", "timeout"} {
+		t.Run(mode, func(t *testing.T) {
+			t.Setenv(helperEnv, mode)
+			dir := t.TempDir()
+			timeout := time.Second
+			if mode == "success" {
+				// A race-instrumented helper spends one second in its normal
+				// exit grace period. That is not a command cancellation.
+				timeout = 5 * time.Second
+			}
+			_, err := captureCommand(context.Background(), timeout, dir, os.Args[0], []string{"-test.run=^TestOwnedCommandKillsDescendantsAfterExitAndTimeout$"}, filepath.Join(dir, "helper"))
+			if (mode == "timeout") != (err != nil) {
+				t.Fatalf("lost command outcome: %v", err)
+			}
+			if _, err := os.Stat(filepath.Join(dir, "ready")); err != nil {
+				t.Fatalf("owned descendant never started: %v", err)
+			}
+			if err := os.WriteFile(filepath.Join(dir, "release"), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+			time.Sleep(150 * time.Millisecond)
+			if _, err := os.Stat(filepath.Join(dir, "late-write")); !os.IsNotExist(err) {
+				t.Fatalf("descendant survived owned process completion: %v", err)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/suite_windows_test.go b/cmd/plan9asmtest/suite_windows_test.go
new file mode 100644
index 000000000..c36cb3ad1
--- /dev/null
+++ b/cmd/plan9asmtest/suite_windows_test.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestWindowsActualInventoryPartitionsAndCoverage(t *testing.T) {
+	t.Setenv("GOFLAGS", "")
+	t.Setenv("GOWORK", "off")
+	t.Setenv("GOTOOLCHAIN", "local")
+	for _, fail := range []bool{false, true} {
+		name := "complete"
+		if fail {
+			name = "retain-failure"
+		}
+		t.Run(name, func(t *testing.T) {
+			dir := t.TempDir()
+			source := `package fixture
+import (
+    "fmt"
+    "testing"
+)
+func TestAlpha(t *testing.T) {
+    t.Parallel()
+    t.Run("child", func(t *testing.T) { if Value() != 7 { t.Fatal("value") } })
+}
+func TestBeta(t *testing.T) { if Value() != 7 { t.Fatal("value") } }
+func Example() { fmt.Println(Value()); /* Output: 7 */ }
+func FuzzSeeds(f *testing.F) {
+    f.Add(1)
+    f.Add(2)
+    f.Fuzz(func(t *testing.T, input int) { if Value() != 7 { t.Fatal(input) } })
+}
+func BenchmarkNotRun(b *testing.B) { b.Fatal("ordinary suite ran a benchmark") }
+`
+			if fail {
+				source += "\nfunc TestFails(t *testing.T) { t.Fatal(\"actual fixture failure\") }\n"
+			}
+			for file, data := range map[string]string{
+				"go.mod":        "module example.org/windows-runner-fixture\n\ngo 1.20\n",
+				"value.go":      "package fixture\nfunc Value() int { return 7 }\n",
+				"value_test.go": source,
+			} {
+				if err := os.WriteFile(filepath.Join(dir, file), []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			out := filepath.Join(t.TempDir(), "artifacts")
+			cfg := config{Go: "go", Dir: dir, Package: ".", Out: out, Shards: 4, Workers: 2,
+				Timeout: 2 * time.Minute, Flags: []string{"-covermode=atomic", "-coverprofile=complete.cover"}}
+			err := runSuite(context.Background(), cfg)
+			if (err != nil) != fail {
+				t.Fatalf("actual suite failure=%t: %v", fail, err)
+			}
+			data, err := os.ReadFile(filepath.Join(out, "report.json"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			var report suiteReport
+			if err := json.Unmarshal(data, &report); err != nil {
+				t.Fatal(err)
+			}
+			if report.RootPassed != 4 || report.RootSkipped != 0 || report.RootMissing != 0 ||
+				report.ChildPassed != 3 || report.ChildSkipped != 0 || report.ChildMissing != 0 ||
+				report.ChildFailed != 0 || len(report.Benchmarks) != 1 || report.Workers != 2 {
+				t.Fatalf("actual complete roots/seeds/children differ: %+v", report)
+			}
+			profile, profileErr := os.ReadFile(filepath.Join(dir, "complete.cover"))
+			if fail {
+				if report.Status != "failed" || report.RootFailed != 1 || len(report.Names) != 5 || !os.IsNotExist(profileErr) {
+					t.Fatalf("failed suite lost its root or published complete coverage: %+v, %v", report, profileErr)
+				}
+			} else if report.Status != "passed" || report.RootFailed != 0 || len(report.Names) != 4 ||
+				profileErr != nil || !strings.HasPrefix(string(profile), "mode: atomic\n") {
+				t.Fatalf("complete suite/profile missing: %+v, %v", report, profileErr)
+			}
+		})
+	}
+}
diff --git a/cmd/plan9asmtest/transport_api_lease_partition_test.go b/cmd/plan9asmtest/transport_api_lease_partition_test.go
new file mode 100644
index 000000000..9b25e726c
--- /dev/null
+++ b/cmd/plan9asmtest/transport_api_lease_partition_test.go
@@ -0,0 +1,106 @@
+package main
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"testing"
+)
+
+var transportCompleteLeaseOwners = []struct{ filename, function string }{
+	{"amd64_fixed_local_transport_runtime_test.go", "TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalTransportByteValues"},
+	{"amd64_fixed_local_transport_test.go", "TestGoAMD64FixedLocalTransportActualObjects"},
+	{"amd64_fixed_local_nontemporal_test.go", "fixedLocalNonTemporalActualObjects"},
+}
+
+// A complete three-API matrix cannot borrow one owner started before the first
+// API. The real capture/close and source-revocation tests remain independent.
+func TestFixedLocalTransportCompleteConsumersHaveFreshAPILeases(t *testing.T) {
+	for _, owner := range transportCompleteLeaseOwners {
+		t.Run(owner.function, func(t *testing.T) {
+			function := transportLeaseFunction(t, owner.filename, owner.function)
+			fresh := 0
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				name := transportLeaseCallName(call)
+				switch name {
+				case "requireGoAMD64FrameCapture", "CaptureGoAMD64FrameSource", "runtimeOracleStageContext", "runtimeOracleProofContext", "fixedLocalAPIs":
+					t.Errorf("complete consumer still shares an outer %s", name)
+				case "source.BindFixedLocal", "owner.BindFixedLocal", "observer.BindFixedLocal":
+					t.Error("bound options must belong only to the current fresh API")
+				case "fixedLocalFreshAPIs":
+					fresh++
+					if len(call.Args) != 6 {
+						t.Fatal("complete consumer lost its exact source/request/check arguments")
+					}
+					for index, want := range []string{"t", "pkg", "request", "options"} {
+						got, ok := call.Args[index].(*ast.Ident)
+						if !ok || got.Name != want {
+							t.Fatal("fresh owner substituted its original complete source", index)
+						}
+					}
+					apis, ok := call.Args[4].(*ast.CompositeLit)
+					if !ok || len(apis.Elts) != 3 {
+						t.Fatal("complete source must retain all three public APIs")
+					}
+					for index, want := range []string{"Translate", "Module", "GoModule"} {
+						literal, ok := apis.Elts[index].(*ast.BasicLit)
+						if !ok || literal.Kind != token.STRING {
+							t.Fatal("public API inventory must be explicit")
+						}
+						got, err := strconv.Unquote(literal.Value)
+						if err != nil || got != want {
+							t.Fatal("cropped, repeated or substituted public API", got, err)
+						}
+					}
+				}
+				return true
+			})
+			if fresh != 1 {
+				t.Fatal("complete source needs exactly one fresh three-API plan", fresh)
+			}
+		})
+	}
+}
+
+func TestFixedLocalTransportCompleteConsumersOwnPreparedCompilerArtifacts(t *testing.T) {
+	for _, owner := range transportCompleteLeaseOwners {
+		t.Run(owner.function, func(t *testing.T) {
+			fixedLocalRequireOwnedObjectCache(t, owner.filename, owner.function)
+			fixedLocalRequirePreparedTools(t, owner.filename, owner.function)
+		})
+	}
+}
+
+func transportLeaseFunction(t *testing.T, filename, name string) *ast.FuncDecl {
+	t.Helper()
+	syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join("..", "..", filename), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == name {
+			return function
+		}
+	}
+	t.Fatal("missing complete transport/streaming consumer", name)
+	return nil
+}
+
+func transportLeaseCallName(call *ast.CallExpr) string {
+	if name, ok := call.Fun.(*ast.Ident); ok {
+		return name.Name
+	}
+	if selector, ok := call.Fun.(*ast.SelectorExpr); ok {
+		if receiver, ok := selector.X.(*ast.Ident); ok {
+			return receiver.Name + "." + selector.Sel.Name
+		}
+	}
+	return ""
+}
diff --git a/cmd/plan9asmtest/unix_scheduling_layout_test.go b/cmd/plan9asmtest/unix_scheduling_layout_test.go
new file mode 100644
index 000000000..f08fa4444
--- /dev/null
+++ b/cmd/plan9asmtest/unix_scheduling_layout_test.go
@@ -0,0 +1,44 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestUnixSchedulingRetainsTwoWholeShardsPerOwner(t *testing.T) {
+	parts, err := moduleRootShardParts(32, 16)
+	if err != nil || len(parts) != 16 {
+		t.Fatal("complete test/coverage root scheduling layout", parts, err)
+	}
+	seen := make([]int, 32)
+	for owner, shards := range parts {
+		if len(shards) != 2 || shards[0] != owner || shards[1] != owner+16 {
+			t.Fatal("test/coverage must fit one two-worker wave", owner, shards)
+		}
+		for _, shard := range shards {
+			seen[shard]++
+		}
+	}
+	for shard, count := range seen {
+		if count != 1 {
+			t.Fatal("missing or duplicate complete test/coverage shard", shard, count)
+		}
+	}
+	source, err := os.ReadFile(filepath.Join("..", "..", "scripts", "test-module-ci.sh"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{
+		"root_partitions=16\n", "shards=32\n", "test) timeout=45m ;;",
+		"coverage) timeout=45m; flags=(-coverprofile=coverage-root.out) ;;",
+		"race) timeout=60m; flags=(-race); root_partitions=32; shards=64 ;;",
+		"-shards=$shards -workers=2", "-timeout=$timeout", "GOMAXPROCS=2",
+		"-module-root-partitions=$root_partitions", "-module-root-partition=$4",
+	} {
+		if !strings.Contains(string(source), required) {
+			t.Error("execution and completion must retain the exact exhaustive scheduling/resource contract:", required)
+		}
+	}
+}
diff --git a/cmd/plan9asmtest/workers.go b/cmd/plan9asmtest/workers.go
new file mode 100644
index 000000000..5dbb2e07d
--- /dev/null
+++ b/cmd/plan9asmtest/workers.go
@@ -0,0 +1,72 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"sync"
+)
+
+// Each task has its own artifacts and owned child process group. Publication
+// stays on the caller's goroutine. On cancellation or publication failure,
+// wait for every active executor to release its descendants before returning.
+func runShardWorkers(
+	parent context.Context,
+	workers int,
+	plan []shardResult,
+	execute func(context.Context, shardResult) shardResult,
+	record func(shardResult) error,
+) error {
+	if workers < 1 || workers > 32 {
+		return fmt.Errorf("workers must be 1..32")
+	}
+	if err := parent.Err(); err != nil {
+		return err
+	}
+	ctx, cancel := context.WithCancel(parent)
+	defer cancel()
+
+	jobs := make(chan shardResult, len(plan))
+	for _, result := range plan {
+		if result.Status != "empty" {
+			jobs <- result
+		}
+	}
+	close(jobs)
+	results := make(chan shardResult, workers)
+	var owners sync.WaitGroup
+	for worker := 0; worker < workers; worker++ {
+		owners.Add(1)
+		go func() {
+			defer owners.Done()
+			for result := range jobs {
+				if ctx.Err() != nil {
+					return
+				}
+				result = execute(ctx, result)
+				select {
+				case results <- result:
+				case <-ctx.Done():
+					return
+				}
+			}
+		}()
+	}
+	go func() {
+		owners.Wait()
+		close(results)
+	}()
+
+	var publicationErr error
+	for result := range results {
+		if publicationErr == nil {
+			if err := record(result); err != nil {
+				publicationErr = err
+				cancel()
+			}
+		}
+	}
+	if publicationErr != nil {
+		return publicationErr
+	}
+	return parent.Err()
+}
diff --git a/cmd/plan9asmtest/workers_test.go b/cmd/plan9asmtest/workers_test.go
new file mode 100644
index 000000000..9f1b6c888
--- /dev/null
+++ b/cmd/plan9asmtest/workers_test.go
@@ -0,0 +1,118 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+func TestShardWorkersBoundedAndEveryTaskCollected(t *testing.T) {
+	plan := make([]shardResult, 40)
+	for index := range plan {
+		plan[index] = shardResult{Index: index, Status: "pending"}
+	}
+	started := make(chan int, len(plan))
+	release := make(chan struct{})
+	var active, maximum atomic.Int32
+	collected := make(map[int]bool)
+	closed := make(chan error, 1)
+	go func() {
+		closed <- runShardWorkers(context.Background(), 2, plan,
+			func(ctx context.Context, result shardResult) shardResult {
+				count := active.Add(1)
+				defer active.Add(-1)
+				for previous := maximum.Load(); count > previous; previous = maximum.Load() {
+					if maximum.CompareAndSwap(previous, count) {
+						break
+					}
+				}
+				started <- result.Index
+				<-release
+				result.Status = "passed"
+				return result
+			}, func(result shardResult) error {
+				if collected[result.Index] {
+					return fmt.Errorf("task %d collected twice", result.Index)
+				}
+				collected[result.Index] = true
+				return nil
+			})
+	}()
+	for owner := 0; owner < 2; owner++ {
+		select {
+		case <-started:
+		case <-time.After(2 * time.Second):
+			close(release)
+			<-closed
+			t.Fatal("two independent workers did not start")
+		}
+	}
+	close(release)
+	if err := <-closed; err != nil {
+		t.Fatal(err)
+	}
+	if active.Load() != 0 || maximum.Load() != 2 || len(collected) != len(plan) {
+		t.Fatalf("worker ownership changed: active=%d max=%d collected=%d", active.Load(), maximum.Load(), len(collected))
+	}
+	for _, result := range plan {
+		if result.Status != "pending" || !collected[result.Index] {
+			t.Fatal("worker mutated or omitted an immutable plan value", result)
+		}
+	}
+}
+
+func TestShardWorkerPublicationFailureWaitsForActiveOwners(t *testing.T) {
+	plan := []shardResult{{Index: 0}, {Index: 1}}
+	entered := make(chan struct{})
+	cleaned := make(chan struct{})
+	publicationErr := errors.New("original publication failure")
+	err := runShardWorkers(context.Background(), 2, plan,
+		func(ctx context.Context, result shardResult) shardResult {
+			if result.Index == 0 {
+				<-entered
+				return result
+			}
+			close(entered)
+			<-ctx.Done()
+			close(cleaned)
+			return result
+		}, func(result shardResult) error {
+			return publicationErr
+		})
+	if !errors.Is(err, publicationErr) {
+		t.Fatalf("publication failure was hidden: %v", err)
+	}
+	select {
+	case <-cleaned:
+	default:
+		t.Fatal("returned while an active owner retained its resources")
+	}
+}
+
+func TestShardWorkersCanceledScopeNeverExecutes(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	execute := func(context.Context, shardResult) shardResult {
+		t.Error("canceled scope started an executor")
+		return shardResult{}
+	}
+	record := func(shardResult) error {
+		t.Error("canceled scope invented a receipt")
+		return nil
+	}
+	if err := runShardWorkers(ctx, 2, []shardResult{{Index: 0}}, execute, record); !errors.Is(err, context.Canceled) {
+		t.Fatalf("cancellation became success: %v", err)
+	}
+	for _, workers := range []int{-1, 0, 33} {
+		if err := runShardWorkers(context.Background(), workers, nil, execute, record); err == nil {
+			t.Fatalf("unbounded worker count %d accepted", workers)
+		}
+	}
+	if _, err := ciPrepare(config{Workers: 2}); err == nil || !strings.Contains(err.Error(), "serial") {
+		t.Fatalf("selected CI silently acquired a different execution plan: %v", err)
+	}
+}
diff --git a/cross_runtime_test.go b/cross_runtime_test.go
index cad46de08..b5ef9b898 100644
--- a/cross_runtime_test.go
+++ b/cross_runtime_test.go
@@ -1,11 +1,10 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
 	"os"
 	"os/exec"
 	"runtime"
+	"strings"
 	"testing"
 )
 
@@ -21,91 +20,443 @@ func TestCrossLinuxRuntimeMatrix(t *testing.T) {
 	if llc == "" {
 		t.Fatal("llc not found")
 	}
+	t.Run("amd64_text_continuations", func(t *testing.T) {
+		runX86ContinuationGo(t)
+		clang := findLLVM22Tool("clang")
+		if clang == "" {
+			t.Fatal("LLVM 22 clang not found")
+		}
+		ir := x86ContinuationIR(t, "x86_64-unknown-linux-gnu", x86ContinuationSource)
+		runX86Continuation(t, llc, clang, "x86_64-unknown-linux-gnu", ir)
+	})
+	t.Run("386_text_continuations", func(t *testing.T) {
+		ir := x86Continuation386IR(t, "i386-unknown-linux-gnu")
+		main := strings.NewReplacer("uint64_t", "uint32_t", "UINT64_MAX", "UINT32_MAX").Replace(x86ContinuationMain)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"i686-linux-gnu-gcc", "-no-pie"},
+			"continuation386", "i386-unknown-linux-gnu", ir, main, []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"})
+	})
+	t.Run("386_raw_lea_address_width_and_aliases", func(t *testing.T) {
+		testX86RawLEAAddressRuntime(t, "386")
+	})
+	t.Run("amd64_integer_broadcast_views", func(t *testing.T) {
+		clang := findLLVM22Tool("clang")
+		if clang == "" {
+			t.Fatal("LLVM 22 clang not found")
+		}
+		ir, main := integerBroadcastViews(t, "x86_64-unknown-linux-gnu")
+		compileAndRunRuntimeTestForTarget(t, llc, clang, "integer_broadcast", "x86_64-unknown-linux-gnu", ir, main, nil)
+	})
+	t.Run("arm64_raw_sve_count_index", func(t *testing.T) {
+		testARM64RawSVECountIndexRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_float", func(t *testing.T) {
+		testARM64RawSVEFloatRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_float_compare", func(t *testing.T) {
+		testARM64RawSVEFloatCompareRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_predicate_permute", func(t *testing.T) {
+		testARM64RawSVEPredicatePermuteRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_compact", func(t *testing.T) {
+		testARM64RawSVECompactRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_copy", func(t *testing.T) {
+		testARM64RawSVECopyRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_integer_unary", func(t *testing.T) {
+		testARM64RawSVEIntegerUnaryRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_predicate_memory", func(t *testing.T) {
+		testARM64RawSVEPredicateMemoryRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_structured_memory", func(t *testing.T) {
+		testARM64RawSVEStructuredMemoryRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_integer_dot", func(t *testing.T) {
+		testARM64RawSVEIntegerDotRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_xar", func(t *testing.T) {
+		testARM64RawSVEXARRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_splice", func(t *testing.T) {
+		testARM64RawSVESpliceRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_integer_reduction", func(t *testing.T) {
+		testARM64RawSVEIntegerReductionRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_ternary_bitwise", func(t *testing.T) {
+		testARM64RawSVETernaryBitwiseRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_multiply_accumulate", func(t *testing.T) {
+		testARM64RawSVEMultiplyAccumulateRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_extra_shift", func(t *testing.T) {
+		testARM64RawSVEExtraShiftRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_signed_load", func(t *testing.T) {
+		testARM64RawSVESignedLoadRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_unsigned_load", func(t *testing.T) {
+		testARM64RawSVEUnsignedLoadRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_extended_load", func(t *testing.T) {
+		testARM64RawSVEExtendedLoadRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_add_sub_wide", func(t *testing.T) {
+		testARM64RawSVEAddSubWideRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_multiply_high", func(t *testing.T) {
+		testARM64RawSVEMultiplyHighRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_saturating_add_sub", func(t *testing.T) {
+		testARM64RawSVESaturatingAddSubRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_float_arithmetic", func(t *testing.T) {
+		testARM64RawSVEFloatArithmeticRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_float_divide_scale", func(t *testing.T) {
+		testARM64RawSVEFloatDivideScaleRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_float_immediate", func(t *testing.T) {
+		testARM64RawSVEFloatImmediateRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_address_generation", func(t *testing.T) {
+		testARM64RawSVEAddressGenerationRuntime(t, llc)
+	})
+	t.Run("arm64_raw_sve_vector_count", func(t *testing.T) {
+		testARM64RawSVEVectorCountRuntime(t, llc)
+	})
+	t.Run("arm64_sve_ordinary_memory_offset", func(t *testing.T) {
+		testARM64SVEMemoryOffsetRuntime(t, llc, false)
+	})
+	t.Run("arm64_sve_non_faulting_memory_offset", func(t *testing.T) {
+		testARM64SVEMemoryOffsetRuntime(t, llc, true)
+	})
+	t.Run("arm64_raw_pool_control_flow", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolControlFlowIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "branchpool", triple, ir,
+			arm64RawPoolControlFlowMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_void_return", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawVoidPoolIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "voidpool", triple, ir,
+			arm64RawVoidPoolMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_register_effects", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolRegisterEffectsIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_effects", triple, ir,
+			arm64RawPoolRegisterEffectsMain, []string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_result_contract", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolResultIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_result", triple, ir,
+			arm64RawPoolResultMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_bounded_offsets", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolOffsetIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_offset", triple, ir,
+			arm64RawPoolOffsetMain, []string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_bounded_indexes", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolIndexedIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_index", triple, ir,
+			arm64RawPoolIndexedMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_aliases", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolAliasesIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_alias", triple, ir,
+			arm64RawPoolAliasesMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_guarded_indexes", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolGuardIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_guard", triple, ir,
+			arm64RawPoolGuardMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_affine_indexes", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolAffineIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_affine", triple, ir,
+			arm64RawPoolAffineMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_multiply_accumulate", func(t *testing.T) {
+		t.Run("native_go", TestARM64MultiplyAccumulateNativeGo)
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64MultiplyAccumulateIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "multiply", triple, ir,
+			main, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_stack_bounds", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64StackBoundsRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "stack", triple, ir,
+			main, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_text_frame_no_escape", func(t *testing.T) {
+		t.Run("native_go", TestARM64TextFrameNoEscapeNativeGo)
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64TextFrameNoEscapeRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "text_frame", triple, ir,
+			main, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_pool_aliases", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64RawPoolSVEAliasesRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "pool_sve", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_dynamic_stack", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64DynamicStackRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "dynamic", triple, ir,
+			main, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_pool_values", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64RawPoolSVEValuesRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "pool_sve_values", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_pool_memory", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64RawPoolSVEMemoryRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "pool_sve_memory", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_pool_flags", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64RawPoolSVEFlagsRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "pool_sve_flags", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_pool_contiguous", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64RawPoolSVEContiguousRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "pool_sve_contiguous", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_sve_dup_indexed", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64SVEDupIndexedRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+sve"}, "dup_indexed", triple, ir, main,
+			[]string{"qemu-aarch64", "-cpu", "max,sve-max-vq=16", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_masked", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolMaskedIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_masked", triple, ir, arm64RawPoolMaskedMain,
+			[]string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_pool_counter_loops", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir := arm64RawPoolLoopIR(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "pool_loop", triple, ir,
+			arm64RawPoolLoopMain, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_fixed_gp_float", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64FixedGPFloatRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc"}, "fixed_gp", triple, ir,
+			main, []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"})
+	})
+	t.Run("arm64_raw_scalar_abd_mul", func(t *testing.T) {
+		const triple = "aarch64-unknown-linux-gnu"
+		ir, main := arm64ScalarABDMulRuntime(t, triple)
+		compileAndRunRuntimeTestWithCompiler(t, llc, []string{"aarch64-linux-gnu-gcc", "-march=armv8.2-a+fp16"},
+			"scalar_abd_mul", triple, ir, main, []string{"qemu-aarch64", "-cpu", "max", "-L", "/usr/aarch64-linux-gnu"})
+	})
 
-	type target struct {
-		goarch    string
-		arch      Arch
-		triple    string
-		asm       string
-		sig       FuncSig
-		compiler  []string
-		runPrefix []string
-		mainC     string
+	for _, tc := range crossArithmeticTargets() {
+		t.Run(tc.goarch, func(t *testing.T) {
+			tools := []string{tc.compiler[0]}
+			if len(tc.runPrefix) != 0 {
+				tools = append(tools, tc.runPrefix[0])
+			}
+			for _, tool := range tools {
+				if _, err := exec.LookPath(tool); err != nil {
+					t.Fatalf("required cross-execution tool %q not found", tool)
+				}
+			}
+			ll := crossArithmeticIR(t, tc)
+			compileAndRunRuntimeTestWithCompiler(t, llc, tc.compiler, "cross_add2_"+tc.goarch, tc.triple, ll, tc.mainC, tc.runPrefix)
+		})
 	}
-	targets := []target{
+}
+
+type crossArithmeticTarget struct {
+	goarch    string
+	arch      Arch
+	triple    string
+	asm       string
+	sig       FuncSig
+	compiler  []string
+	runPrefix []string
+	mainC     string
+}
+
+func crossArithmeticTargets() []crossArithmeticTarget {
+	return []crossArithmeticTarget{
 		{
-			goarch:   "amd64",
-			arch:     ArchAMD64,
-			triple:   "x86_64-unknown-linux-gnu",
-			asm:      "TEXT add2(SB),NOSPLIT,$0-24\nMOVQ a+0(FP), AX\nADDQ b+8(FP), AX\nMOVQ AX, ret+16(FP)\nRET\n\nTEXT isneg(SB),NOSPLIT,$0-16\nMOVQ x+0(FP), AX\nCMPQ AX, $0\nJL V1\nMOVQ $0, AX\nMOVQ AX, ret+8(FP)\nRET\nV1:\nMOVQ $1, AX\nMOVQ AX, ret+8(FP)\nRET\n",
+			goarch: "amd64",
+			arch:   ArchAMD64,
+			triple: "x86_64-unknown-linux-gnu",
+			asm: `TEXT add2(SB),NOSPLIT,$0-24
+	MOVQ a+0(FP), AX
+	ADDQ b+8(FP), AX
+	MOVQ AX, ret+16(FP)
+	RET
+
+TEXT isneg(SB),NOSPLIT,$0-16
+	MOVQ x+0(FP), AX
+	CMPQ AX, $0
+	JL negative
+	MOVQ $0, AX
+	MOVQ AX, ret+8(FP)
+	RET
+negative:
+	MOVQ $1, AX
+	MOVQ AX, ret+8(FP)
+	RET
+`,
 			sig:      crossAddSig("amd64"),
 			compiler: []string{"cc"},
 			mainC:    "extern long long add2(long long, long long); extern long long isneg(long long); int main(void) { if (add2(19, 23) != 42) return 11; if (isneg(-1) != 1 || isneg(1) != 0) return 21; return 0; }\n",
 		},
 		{
-			goarch:    "386",
-			arch:      ArchAMD64,
-			triple:    "i386-unknown-linux-gnu",
-			asm:       "TEXT add2(SB),NOSPLIT,$0-12\nMOVL a+0(FP), AX\nADDL b+4(FP), AX\nMOVL AX, ret+8(FP)\nRET\n\nTEXT isneg(SB),NOSPLIT,$0-8\nMOVL x+0(FP), AX\nCMPL AX, $0\nJL V1\nMOVL $0, AX\nMOVL AX, ret+4(FP)\nRET\nV1:\nMOVL $1, AX\nMOVL AX, ret+4(FP)\nRET\n",
+			goarch: "386",
+			arch:   ArchAMD64,
+			triple: "i386-unknown-linux-gnu",
+			asm: `TEXT add2(SB),NOSPLIT,$0-12
+	MOVL a+0(FP), AX
+	ADDL b+4(FP), AX
+	MOVL AX, ret+8(FP)
+	RET
+
+TEXT isneg(SB),NOSPLIT,$0-8
+	MOVL x+0(FP), AX
+	CMPL AX, $0
+	JL negative
+	MOVL $0, AX
+	MOVL AX, ret+4(FP)
+	RET
+negative:
+	MOVL $1, AX
+	MOVL AX, ret+4(FP)
+	RET
+`,
 			sig:       crossAddSig("386"),
 			compiler:  []string{"i686-linux-gnu-gcc"},
 			runPrefix: []string{"qemu-i386", "-L", "/usr/i686-linux-gnu"},
 			mainC:     "extern int add2(int, int); extern int isneg(int); int main(void) { if (add2(19, 23) != 42) return 12; if (isneg(-1) != 1 || isneg(1) != 0) return 22; return 0; }\n",
 		},
 		{
-			goarch:    "arm",
-			arch:      ArchARM,
-			triple:    "armv7-unknown-linux-gnueabihf",
-			asm:       "TEXT add2(SB),NOSPLIT,$0-12\nMOVW a+0(FP), R0\nADD b+4(FP), R0\nMOVW R0, ret+8(FP)\nRET\n\nTEXT isneg(SB),NOSPLIT,$0-8\nMOVW x+0(FP), R0\nCMP $0, R0\nBLT V1\nMOVW $0, R0\nMOVW R0, ret+4(FP)\nRET\nV1:\nMOVW $1, R0\nMOVW R0, ret+4(FP)\nRET\n",
+			goarch: "arm",
+			arch:   ArchARM,
+			triple: "armv7-unknown-linux-gnueabihf",
+			asm: `TEXT add2(SB),NOSPLIT,$0-12
+	MOVW a+0(FP), R0
+	MOVW b+4(FP), R1
+	ADD R1, R0
+	MOVW R0, ret+8(FP)
+	RET
+
+TEXT isneg(SB),NOSPLIT,$0-8
+	MOVW x+0(FP), R0
+	CMP $0, R0
+	BLT negative
+	MOVW $0, R0
+	MOVW R0, ret+4(FP)
+	RET
+negative:
+	MOVW $1, R0
+	MOVW R0, ret+4(FP)
+	RET
+`,
 			sig:       crossAddSig("arm"),
 			compiler:  []string{"arm-linux-gnueabihf-gcc"},
 			runPrefix: []string{"qemu-arm", "-L", "/usr/arm-linux-gnueabihf"},
 			mainC:     "extern int add2(int, int); extern int isneg(int); int main(void) { if (add2(19, 23) != 42) return 13; if (isneg(-1) != 1 || isneg(1) != 0) return 23; return 0; }\n",
 		},
 		{
-			goarch:    "arm64",
-			arch:      ArchARM64,
-			triple:    "aarch64-unknown-linux-gnu",
-			asm:       "TEXT add2(SB),NOSPLIT,$0-24\nMOVD a+0(FP), R0\nMOVD b+8(FP), R1\nADD R1, R0\nMOVD R0, ret+16(FP)\nRET\n\nTEXT isneg(SB),NOSPLIT,$0-16\nMOVD x+0(FP), R0\nCMP $0, R0\nBLT V1\nMOVD $0, R0\nMOVD R0, ret+8(FP)\nRET\nV1:\nMOVD $1, R0\nMOVD R0, ret+8(FP)\nRET\n",
+			goarch: "arm64",
+			arch:   ArchARM64,
+			triple: "aarch64-unknown-linux-gnu",
+			asm: `TEXT add2(SB),NOSPLIT,$0-24
+	MOVD a+0(FP), R0
+	MOVD b+8(FP), R1
+	ADD R1, R0
+	MOVD R0, ret+16(FP)
+	RET
+
+TEXT isneg(SB),NOSPLIT,$0-16
+	MOVD x+0(FP), R0
+	CMP $0, R0
+	BLT negative
+	MOVD $0, R0
+	MOVD R0, ret+8(FP)
+	RET
+negative:
+	MOVD $1, R0
+	MOVD R0, ret+8(FP)
+	RET
+`,
 			sig:       crossAddSig("arm64"),
 			compiler:  []string{"aarch64-linux-gnu-gcc"},
 			runPrefix: []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"},
 			mainC:     "extern long long add2(long long, long long); extern long long isneg(long long); int main(void) { if (add2(19, 23) != 42) return 14; if (isneg(-1) != 1 || isneg(1) != 0) return 24; return 0; }\n",
 		},
 	}
+}
 
-	for _, tc := range targets {
+// Validate the runtime inputs on every host, before a Linux cross-runtime
+// owner needs its native toolchain. Both checks consume the same fixtures.
+func TestCrossArithmeticFixtures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, tc := range crossArithmeticTargets() {
 		t.Run(tc.goarch, func(t *testing.T) {
-			tools := []string{tc.compiler[0]}
-			if len(tc.runPrefix) != 0 {
-				tools = append(tools, tc.runPrefix[0])
-			}
-			for _, tool := range tools {
-				if _, err := exec.LookPath(tool); err != nil {
-					t.Fatalf("required cross-execution tool %q not found", tool)
-				}
-			}
-			file, err := Parse(tc.arch, tc.asm)
-			if err != nil {
-				t.Fatal(err)
-			}
-			sigs := map[string]FuncSig{
-				"add2":  tc.sig,
-				"isneg": crossUnarySig(tc.goarch, "isneg"),
-			}
-			ll, err := Translate(file, Options{
-				TargetTriple: tc.triple,
-				Goarch:       tc.goarch,
-				Sigs:         sigs,
+			t.Run("go_assembler", func(t *testing.T) {
+				source := strings.ReplaceAll(tc.asm, "NOSPLIT", "4")
+				goAssemblerOracleOutput(t, tc.goarch, source, "", true)
+			})
+			t.Run("llvm_object", func(t *testing.T) {
+				ll := crossArithmeticIR(t, tc)
+				compileLLVMToObject(t, llc, tc.triple, "arithmetic.ll", "arithmetic.o", ll)
 			})
-			if err != nil {
-				t.Fatal(err)
-			}
-			compileAndRunRuntimeTestWithCompiler(t, llc, tc.compiler, "cross_add2_"+tc.goarch, tc.triple, ll, tc.mainC, tc.runPrefix)
 		})
 	}
 }
 
+func crossArithmeticIR(t *testing.T, tc crossArithmeticTarget) string {
+	t.Helper()
+	file, err := Parse(tc.arch, tc.asm)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ll, err := Translate(file, Options{
+		TargetTriple: tc.triple,
+		Goarch:       tc.goarch,
+		Sigs: map[string]FuncSig{
+			"add2":  tc.sig,
+			"isneg": crossUnarySig(tc.goarch, "isneg"),
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ll
+}
+
 func crossUnarySig(goarch, name string) FuncSig {
 	word := I32
 	result := int64(4)
diff --git a/data_float_literal_test.go b/data_float_literal_test.go
new file mode 100644
index 000000000..9f8478470
--- /dev/null
+++ b/data_float_literal_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Independent source spellings and values, including rounding, subnormal,
+// underflow, signed-zero and finite-f64-to-infinite-f32 transitions.
+var dataFloatLiteralCases = []struct {
+	source string
+	value  float64
+}{
+	{"0.0", 0},
+	{"-0.0", math.Copysign(0, -1)},
+	{"1.25", 1.25},
+	{"-(1.25)", -1.25},
+	{"--1.25", 1.25},
+	{"+(-(+1.25))", -1.25},
+	{"1.000000059604644775390625", 1 + math.Ldexp(1, -24)},
+	{"1.000000178813934326171875", 1 + math.Ldexp(3, -24)},
+	{"0x1p-149", math.Ldexp(1, -149)},
+	{"0x1p-150", math.Ldexp(1, -150)},
+	{"-0x1p-150", -math.Ldexp(1, -150)},
+	{"0x1p-126", math.Ldexp(1, -126)},
+	{"1.7976931348623157e308", math.MaxFloat64},
+	{"0x1p-1074", math.SmallestNonzeroFloat64},
+}
+
+func dataFloatLiteralBytes(value float64, width int) []byte {
+	result := make([]byte, width)
+	if width == 4 {
+		binary.LittleEndian.PutUint32(result, math.Float32bits(float32(value)))
+	} else {
+		binary.LittleEndian.PutUint64(result, math.Float64bits(value))
+	}
+	return result
+}
+
+func TestDataFloatLiteralWidthAndGrammar(t *testing.T) {
+	for _, target := range dataGlobalAlignmentTargets {
+		for _, width := range []int{4, 8} {
+			for _, test := range dataFloatLiteralCases {
+				statement := fmt.Sprintf("value(SB)/%d,$%s", width, test.source)
+				data, err := parseDATAStmt(target.arch, statement)
+				if err != nil {
+					t.Errorf("%s %s: %v", target.goarch, statement, err)
+					continue
+				}
+				got, err := dataStmtPayload(data)
+				want := dataFloatLiteralBytes(test.value, width)
+				if err != nil || !bytes.Equal(got, want) {
+					t.Errorf("%s %s: bytes=%x want=%x err=%v", target.goarch, statement, got, want, err)
+				}
+			}
+		}
+		for _, statement := range []string{
+			"value(SB)/1,$1.0", "value(SB)/2,$1.0", "value(SB)/16,$1.0",
+			"value(SB)/4,$(1.0+2.0)", "value(SB)/8,$(1.0*2.0)",
+			"value(SB)/4,$(1.0", "value(SB)/8,$(1+2.0)",
+			"value(SB)/4,$NaN", "value(SB)/8,$Inf",
+			"value(SB)/16,$1", "value(SB)/4,$(unresolved+1)",
+		} {
+			goAssemblerOracleOutput(t, target.goarch, "DATA "+statement+"\nGLOBL value(SB),24,$32\n", "", false)
+			if _, err := parseDATAStmt(target.arch, statement); err == nil {
+				t.Errorf("%s accepted non-Go float DATA: %s", target.goarch, statement)
+			}
+		}
+	}
+}
+
+func TestDataFloatLiteralActualGoAndLLVMFiveArchitectures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var assembly strings.Builder
+	wants := make(map[string][]byte)
+	for _, width := range []int{4, 8} {
+		for index, test := range dataFloatLiteralCases {
+			name := fmt.Sprintf("float_data_%d_%d", width, index)
+			fmt.Fprintf(&assembly, "DATA %s(SB)/%d,$%s\nGLOBL %s(SB),24,$%d\n", name, width, test.source, name, width)
+			wants[name] = dataFloatLiteralBytes(test.value, width)
+		}
+	}
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			directory := t.TempDir()
+			filename := filepath.Join(directory, "data.s")
+			if err := os.WriteFile(filename, []byte(assembly.String()), 0600); err != nil {
+				t.Fatal(err)
+			}
+			environment := []string{"GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=" + target.goos, "GOARCH=" + target.goarch}
+			listing := dataGlobalAlignmentCommand(t, directory, environment, "go", "tool", "asm", "-S", "-o", filepath.Join(directory, "data.o"), filename)
+			seen := make(map[string]bool)
+			lines := strings.Split(string(listing), "\n")
+			for line, text := range lines {
+				fields := strings.Fields(text)
+				if len(fields) < 3 {
+					continue
+				}
+				want, exists := wants[fields[0]]
+				if !exists {
+					continue
+				}
+				if seen[fields[0]] || fields[1] != "SRODATA" || fields[2] != fmt.Sprintf("size=%d", len(want)) || line+1 >= len(lines) {
+					t.Fatal("actual Go symbol identity/extent changed", text)
+				}
+				row := strings.Fields(lines[line+1])
+				if len(row) < len(want)+1 || row[0] != "0x0000" {
+					t.Fatal("actual Go DATA bytes absent", lines[line+1])
+				}
+				got, err := hex.DecodeString(strings.Join(row[1:len(want)+1], ""))
+				if err != nil || !bytes.Equal(got, want) {
+					t.Fatalf("original Go %s bytes=%x want=%x: %v", fields[0], got, want, err)
+				}
+				seen[fields[0]] = true
+			}
+			if len(seen) != len(wants) {
+				t.Fatalf("original Go DATA inventory %d != %d\n%s", len(seen), len(wants), listing)
+			}
+			file, err := Parse(target.arch, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: dataGlobalAlignmentResolve}
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "")
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var module llvm.Module
+					var err error
+					switch api {
+					case "text":
+						var ir string
+						ir, err = Translate(file, options)
+						if err == nil {
+							module, err = parseIRModuleInContext(ctx, ir)
+						}
+					case "module":
+						module, err = TranslateModuleInContext(ctx, file, options)
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), GoModuleOptions{
+							GOARCH: target.goarch, TargetTriple: target.triple, ResolveSym: dataGlobalAlignmentResolve})
+						if result != nil {
+							module = result.Module
+						}
+					}
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil || module.IsNil() {
+						t.Fatal(err)
+					}
+					for name, want := range wants {
+						global := module.NamedGlobal(name)
+						// LLVM uniques constants within a context, independent of
+						// whether IR prints a byte string or a zero initializer.
+						if global.IsNil() || !global.IsGlobalConstant() || global.Initializer() != ctx.ConstString(string(want), false) {
+							t.Errorf("LLVM initializer differs from actual Go: %s want=%x", name, want)
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "float-data.ll", "float-data.o", module.String())
+				})
+			}
+		})
+	}
+}
diff --git a/data_global_alignment.go b/data_global_alignment.go
new file mode 100644
index 000000000..3aad98763
--- /dev/null
+++ b/data_global_alignment.go
@@ -0,0 +1,17 @@
+package plan9asm
+
+// goAssemblyDataAlignment follows cmd/link/internal/ld.symalign for assembly
+// DATA/GLOBL definitions without an explicit symbol alignment. Go reduces the
+// target's maximum alignment until it fits the size; divisibility is irrelevant.
+// This describes source-owned globals, not external declarations, caller memory
+// or private literal pools synthesized by the translator.
+func goAssemblyDataAlignment(arch Arch, size int64) int64 {
+	alignment := int64(32)
+	if arch == ArchARM {
+		alignment = 8
+	}
+	for alignment > size && alignment > 1 {
+		alignment >>= 1
+	}
+	return alignment
+}
diff --git a/data_global_alignment_link_test.go b/data_global_alignment_link_test.go
new file mode 100644
index 000000000..c64931297
--- /dev/null
+++ b/data_global_alignment_link_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"debug/elf"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func dataGlobalAlignmentCommand(t *testing.T, directory string, environment []string, executable string, arguments ...string) []byte {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, executable, arguments...)
+	command.Dir = directory
+	command.Env = append(os.Environ(), environment...)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("%s %q: %v\n%s", filepath.Base(executable), arguments, err, output)
+	}
+	return output
+}
+
+func dataGlobalAlignmentGoProgram(goarch string, maximum int) (string, string) {
+	var assembly, declarations, checks strings.Builder
+	assembly.WriteString(dataGlobalAlignmentSource())
+	declarations.WriteString("package main\nimport \"unsafe\"\n")
+	ordinal := 0
+	for _, row := range dataGlobalAlignmentSizes {
+		alignment := row.alignment
+		if alignment > maximum {
+			alignment = maximum
+		}
+		for _, role := range []string{"rw", "ro", "local"} {
+			name := fmt.Sprintf("asm_align_%s_n%d", role, row.size)
+			if role == "local" {
+				name += "<>"
+			}
+			word := 8
+			if goarch == "386" || goarch == "arm" {
+				word = 4
+			}
+			if goarch == "wasm" && role == "local" {
+				// Go's wasm Const encoder relocates NAME_EXTERN, not
+				// NAME_STATIC. Observe the real private symbol through a
+				// source DATA relocation instead of a zero Const encoding.
+				fmt.Fprintf(&assembly, "DATA private_address_%d(SB)/8,$%s(SB)\nGLOBL private_address_%d(SB),24,$8\n", ordinal, name, ordinal)
+			}
+			fmt.Fprintf(&assembly, "TEXT ·Address%d(SB),4,$0-%d\n", ordinal, word)
+			switch goarch {
+			case "amd64":
+				fmt.Fprintf(&assembly, "LEAQ %s(SB),AX\nMOVQ AX,ret+0(FP)\n", name)
+			case "386":
+				fmt.Fprintf(&assembly, "MOVL $%s(SB),AX\nMOVL AX,ret+0(FP)\n", name)
+			case "arm":
+				fmt.Fprintf(&assembly, "MOVW $%s(SB),R0\nMOVW R0,ret+0(FP)\n", name)
+			case "arm64":
+				fmt.Fprintf(&assembly, "MOVD $%s(SB),R0\nMOVD R0,ret+0(FP)\n", name)
+			case "wasm":
+				assembly.WriteString("Get SP\n")
+				if role == "local" {
+					fmt.Fprintf(&assembly, "I32Const $private_address_%d(SB)\nI64Load $0\n", ordinal)
+				} else {
+					fmt.Fprintf(&assembly, "I64Const $%s(SB)\n", name)
+				}
+				assembly.WriteString("I64Store ret+0(FP)\n")
+			}
+			assembly.WriteString("RET\n")
+			fmt.Fprintf(&declarations, "func Address%d() uintptr\n", ordinal)
+			fmt.Fprintf(&checks, `{
+    address := Address%d()
+    if address == 0 || address%%%d != 0 { panic("%s alignment") }
+    bytes := (*[%d]byte)(unsafe.Pointer(address))
+    if bytes[0] != 0xa5 { panic("%s first byte") }
+    for _, value := range bytes[1:] { if value != 0 { panic("%s zero tail") } }
+}
+`, ordinal, alignment, name, row.size, name, name)
+			ordinal++
+		}
+	}
+	declarations.WriteString("func main() {\n" + checks.String() + "println(\"actual Go assembly alignment and bytes PASS\")\n}\n")
+	return assembly.String(), declarations.String()
+}
+
+func dataGlobalAlignmentGoBuild(t *testing.T, goarch, goos string, maximum int) string {
+	t.Helper()
+	directory := t.TempDir()
+	assembly, program := dataGlobalAlignmentGoProgram(goarch, maximum)
+	for name, source := range map[string]string{
+		"go.mod": "module alignment_oracle\n\ngo 1.20\n", "main.go": program, "data.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(directory, "original")
+	environment := []string{"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOARCH=" + goarch, "GOOS=" + goos}
+	dataGlobalAlignmentCommand(t, directory, environment, "go", "build", "-p=2", "-o", executable, ".")
+	return executable
+}
+
+func dataGlobalAlignmentELF(t *testing.T, path, goarch string, maximum int, relocated bool) {
+	t.Helper()
+	image, err := elf.Open(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer image.Close()
+	machine := map[string]elf.Machine{"386": elf.EM_386, "amd64": elf.EM_X86_64, "arm": elf.EM_ARM, "arm64": elf.EM_AARCH64}[goarch]
+	if machine == elf.EM_NONE || image.Machine != machine ||
+		!relocated && image.Type != elf.ET_REL || relocated && image.Type != elf.ET_EXEC && image.Type != elf.ET_DYN {
+		t.Fatal("actual object target or link role changed", image.FileHeader)
+	}
+	symbols, err := image.Symbols()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range dataGlobalAlignmentSizes {
+		alignment := row.alignment
+		if alignment > maximum {
+			alignment = maximum
+		}
+		for _, role := range []string{"rw", "ro", "local"} {
+			name := fmt.Sprintf("asm_align_%s_n%d", role, row.size)
+			matches := 0
+			for _, symbol := range symbols {
+				if symbol.Name != name {
+					continue
+				}
+				matches++
+				if symbol.Section == elf.SHN_UNDEF || int(symbol.Section) >= len(image.Sections) || symbol.Size != uint64(row.size) {
+					t.Fatalf("missing complete native definition: %+v", symbol)
+				}
+				section := image.Sections[symbol.Section]
+				if symbol.Value%uint64(alignment) != 0 || relocated && symbol.Value == 0 ||
+					!relocated && section.Addralign < uint64(alignment) {
+					t.Errorf("%s: symbol address=%#x section alignment=%d, Go requires %d", name, symbol.Value, section.Addralign, alignment)
+				}
+				bytes, err := section.Data()
+				start := symbol.Value - section.Addr
+				if err != nil || start > uint64(len(bytes)) || symbol.Size > uint64(len(bytes))-start {
+					t.Fatal("native symbol has no complete section bytes", symbol, err)
+				}
+				for index, value := range bytes[start : start+symbol.Size] {
+					want := byte(0)
+					if index == 0 {
+						want = 0xa5
+					}
+					if value != want {
+						t.Fatalf("%s byte%d=%#x, want %#x", name, index, value, want)
+					}
+				}
+			}
+			if matches != 1 {
+				t.Fatalf("%s has %d native definitions, want one", name, matches)
+			}
+		}
+	}
+}
+
+func TestDataGlobalAlignmentActualGoLinkedFiveArchitectures(t *testing.T) {
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			executable := dataGlobalAlignmentGoBuild(t, target.goarch, target.goos, target.maximum)
+			if target.arch != ArchWASM {
+				dataGlobalAlignmentELF(t, executable, target.goarch, target.maximum, true)
+				return
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command, err := wasmPackedGoRuntimeCommand(ctx, testGOROOT(t), wasmPackedNode(t), executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			if err != nil || strings.TrimSpace(string(output)) != "actual Go assembly alignment and bytes PASS" {
+				t.Fatalf("actual Go wasm linked addresses/bytes: %v\n%s", err, output)
+			}
+		})
+	}
+}
+
+func dataGlobalAlignmentModule(t *testing.T, arch Arch, triple, route string) string {
+	t.Helper()
+	file, err := Parse(arch, dataGlobalAlignmentSource())
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{TargetTriple: triple, ResolveSym: dataGlobalAlignmentResolve}
+	if route == "text" {
+		ir, err := Translate(file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return ir
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := translateModuleDirectInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal("direct emitter must not fall back", err)
+	}
+	return module.String()
+}
+
+func TestDataGlobalAlignmentLLVMObjectsAndLinkedAddresses(t *testing.T) {
+	llc, linker, wasmLinker := findLLVM22Tool("llc"), findLLVM22Tool("ld.lld"), findLLVM22Tool("wasm-ld")
+	if llc == "" || linker == "" || wasmLinker == "" {
+		t.Fatal("LLVM22 llc, ld.lld and wasm-ld required")
+	}
+	for _, target := range dataGlobalAlignmentTargets {
+		for _, route := range []string{"text", "direct"} {
+			t.Run(target.goarch+"/"+route, func(t *testing.T) {
+				ir := dataGlobalAlignmentModule(t, target.arch, target.triple, route)
+				if target.arch == ArchWASM {
+					// Keep private source symbols alive and observable through
+					// exported test consumers; export-all alone excludes them.
+					for _, row := range dataGlobalAlignmentSizes {
+						ir += fmt.Sprintf("define i32 @private_address_%d() {\n %%address = ptrtoint ptr @asm_align_local_n%d to i32\n ret i32 %%address\n}\n", row.size, row.size)
+					}
+				}
+				directory := t.TempDir()
+				input, object, linked := filepath.Join(directory, "data.ll"), filepath.Join(directory, "data.o"), filepath.Join(directory, "linked")
+				if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+					t.Fatal(err)
+				}
+				dataGlobalAlignmentCommand(t, directory, nil, llc, "-O0", "-filetype=obj", input, "-o", object)
+				if target.arch != ArchWASM {
+					dataGlobalAlignmentELF(t, object, target.goarch, target.maximum, false)
+					// MinGW builds default ld.lld to PE unless -m explicitly
+					// selects an ELF emulation. The object and linked symbols
+					// are still independently checked by the ELF reader.
+					emulation := map[string]string{
+						"386": "elf_i386", "amd64": "elf_x86_64",
+						"arm": "armelf_linux_eabi", "arm64": "aarch64linux",
+					}[target.goarch]
+					if emulation == "" {
+						t.Fatal("missing explicit ELF linker target", target.goarch)
+					}
+					dataGlobalAlignmentCommand(t, directory, nil, linker, "-m", emulation, "-shared", object, "-o", linked)
+					dataGlobalAlignmentELF(t, linked, target.goarch, target.maximum, true)
+					return
+				}
+				dataGlobalAlignmentCommand(t, directory, nil, wasmLinker, "--no-entry", "--export-all", object, "-o", linked)
+				var checks strings.Builder
+				for _, row := range dataGlobalAlignmentSizes {
+					for _, role := range []string{"rw", "ro", "local"} {
+						name := fmt.Sprintf("asm_align_%s_n%d", role, row.size)
+						address := fmt.Sprintf("e[%q].value", name)
+						if role == "local" {
+							address = fmt.Sprintf("e.private_address_%d()", row.size)
+						}
+						fmt.Fprintf(&checks, `{
+  const address = %s;
+  if (!address || address%%%d) throw Error(%q + " alignment=" + address);
+  for (let i=0;i<%d;i++) if (bytes[address+i] !== (i ? 0 : 0xa5)) throw Error(%q + " bytes");
+}
+`, address, row.alignment, name, row.size, name)
+					}
+				}
+				script := `const fs=require("fs");
+WebAssembly.instantiate(fs.readFileSync(process.argv[1])).then(({instance})=>{
+const e=instance.exports, bytes=new Uint8Array(e.memory.buffer);
+` + checks.String() + `console.log("LLVM linked wasm alignment and bytes PASS");
+}).catch(error=>{ console.error(error); process.exit(1); });`
+				scriptPath := filepath.Join(directory, "observe.cjs")
+				script = strings.Replace(script, "process.argv[1]", "process.argv[2]", 1)
+				if err := os.WriteFile(scriptPath, []byte(script), 0600); err != nil {
+					t.Fatal(err)
+				}
+				output := dataGlobalAlignmentCommand(t, directory, nil, wasmPackedNode(t), scriptPath, linked)
+				if strings.TrimSpace(string(output)) != "LLVM linked wasm alignment and bytes PASS" {
+					t.Fatal("linked wasm checks did not execute", string(output))
+				}
+			})
+		}
+	}
+}
diff --git a/data_global_alignment_rules.go b/data_global_alignment_rules.go
new file mode 100644
index 000000000..980757bff
--- /dev/null
+++ b/data_global_alignment_rules.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"strconv"
+)
+
+// These complete function shapes describe the registered Go loader/linker rule,
+// not a literal's address. Whole original source bytes are separately retained.
+const goDataSymalignRule = `package ld
+func symalign(ldr *loader.Loader, s loader.Sym) int32 {
+ min := int32(thearch.Minalign)
+ align := ldr.SymAlign(s)
+ if align >= min { return align } else if align != 0 { return min }
+ align = int32(thearch.Maxalign)
+ ssz := ldr.SymSize(s)
+ for int64(align) > ssz && align > min { align >>= 1 }
+ ldr.SetSymAlign(s, align)
+ return align
+}`
+
+const goLoaderSymalignRule = `package loader
+func (l *Loader) SymAlign(i Sym) int32 {
+ if int(i) >= len(l.align) { return 0 }
+ abits := l.align[i]
+ if abits == 0 { return 0 }
+ return int32(1 << (abits - 1))
+}`
+
+const goLiteralDefaultPIERule = `package platform
+func DefaultPIE(goos, goarch string, isRace bool) bool {
+ switch goos {
+ case "android", "ios": return true
+ case "windows": if isRace { return false }; return true
+ case "darwin": return true
+ }
+ return false
+}`
+
+func verifyGoLiteralDefaultPIE(data []byte) error {
+	actual, err := goAlignmentFunctionShape(data, "DefaultPIE")
+	expected, expectedErr := goAlignmentFunctionShape([]byte(goLiteralDefaultPIERule), "DefaultPIE")
+	if err != nil || expectedErr != nil || !bytes.Equal(actual, expected) {
+		return sdkASMDataContext("unregistered complete actual Go default PIE profile")
+	}
+	return nil
+}
+
+func goAlignmentFunctionShape(data []byte, name string) ([]byte, error) {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "original.go", data, 0)
+	if err != nil {
+		return nil, err
+	}
+	var result []byte
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != name {
+			continue
+		}
+		if result != nil {
+			return nil, sdkASMDataContext("duplicate original linker alignment function")
+		}
+		var output bytes.Buffer
+		// Ignore physical blank/comment line positions, but compare the whole
+		// declaration, receiver, expressions and control flow without cropping.
+		if err := format.Node(&output, token.NewFileSet(), function); err != nil {
+			return nil, err
+		}
+		result = output.Bytes()
+	}
+	if result == nil {
+		return nil, sdkASMDataContext("missing original linker alignment function")
+	}
+	return result, nil
+}
+
+func verifyGoAssemblyDataAlignmentRule(data, loader, limits, arch []byte) error {
+	for _, row := range []struct {
+		actual         []byte
+		expected, name string
+	}{
+		{data, goDataSymalignRule, "symalign"}, {loader, goLoaderSymalignRule, "SymAlign"},
+	} {
+		actual, err := goAlignmentFunctionShape(row.actual, row.name)
+		expected, expectedErr := goAlignmentFunctionShape([]byte(row.expected), row.name)
+		if err != nil || expectedErr != nil || !bytes.Equal(actual, expected) {
+			return sdkASMDataContext("unregistered complete original linker/loader alignment rule: %s", row.name)
+		}
+	}
+	fset := token.NewFileSet()
+	constantsFile, err := parser.ParseFile(fset, "l.go", limits, 0)
+	if err != nil {
+		return err
+	}
+	constants := map[string]int{}
+	ast.Inspect(constantsFile, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+			return true
+		}
+		literal, ok := value.Values[0].(*ast.BasicLit)
+		if ok && literal.Kind == token.INT {
+			constants[value.Names[0].Name], _ = strconv.Atoi(literal.Value)
+		}
+		return true
+	})
+	archFile, err := parser.ParseFile(fset, "obj.go", arch, 0)
+	if err != nil {
+		return err
+	}
+	values := map[string]int{}
+	valid := true
+	ast.Inspect(archFile, func(node ast.Node) bool {
+		field, ok := node.(*ast.KeyValueExpr)
+		if !ok {
+			return true
+		}
+		key, ok := field.Key.(*ast.Ident)
+		if !ok || key.Name != "Maxalign" && key.Name != "Minalign" {
+			return true
+		}
+		if _, duplicate := values[key.Name]; duplicate {
+			valid = false
+		}
+		value, ok := field.Value.(*ast.Ident)
+		if !ok {
+			valid = false
+			return true
+		}
+		values[key.Name] = constants[value.Name]
+		return true
+	})
+	if !valid || len(values) != 2 || values["Maxalign"] != 32 || values["Minalign"] != 1 {
+		return sdkASMDataContext("unregistered actual x86 linker minimum/maximum alignment")
+	}
+	return nil
+}
diff --git a/data_global_alignment_rules_test.go b/data_global_alignment_rules_test.go
new file mode 100644
index 000000000..6059e61ac
--- /dev/null
+++ b/data_global_alignment_rules_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestDataGlobalAlignmentCompleteRegisteredLinkerRules(t *testing.T) {
+	root := testGOROOT(t)
+	read := func(name string) []byte {
+		data, err := os.ReadFile(filepath.Join(root, "src", filepath.FromSlash(name)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return data
+	}
+	data, loader := read("cmd/link/internal/ld/data.go"), read("cmd/link/internal/loader/loader.go")
+	for _, arch := range []string{"amd64", "x86"} {
+		limits, dispatch := read("cmd/link/internal/"+arch+"/l.go"), read("cmd/link/internal/"+arch+"/obj.go")
+		if err := verifyGoAssemblyDataAlignmentRule(data, loader, limits, dispatch); err != nil {
+			t.Fatal("complete official linker rule", err)
+		}
+		for name, changed := range map[string][]byte{
+			"lazy-zero-is-not-sixteen":       []byte(strings.Replace(string(loader), "abits == 0 {\n\t\treturn 0", "abits == 0 {\n\t\treturn 16", 1)),
+			"changed-symbol-alignment-shift": []byte(strings.Replace(string(loader), "abits - 1", "abits", 1)),
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				if !errors.Is(verifyGoAssemblyDataAlignmentRule(data, changed, limits, dispatch), ErrProbeNeedsContext) {
+					t.Fatal("changed complete loader rule accepted")
+				}
+			})
+		}
+		for name, changed := range map[string][]byte{
+			"different-size-loop":        []byte(strings.Replace(string(data), "int64(align) > ssz", "int64(align) >= ssz", 1)),
+			"different-minimum":          []byte(strings.Replace(string(data), "min := int32(thearch.Minalign)", "min := int32(16)", 1)),
+			"dropped-recorded-alignment": []byte(strings.Replace(string(data), "ldr.SetSymAlign(s, align)", "ldr.SetSymAlign(s, 1)", 1)),
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				if !errors.Is(verifyGoAssemblyDataAlignmentRule(changed, loader, limits, dispatch), ErrProbeNeedsContext) {
+					t.Fatal("changed complete linker rule accepted")
+				}
+			})
+		}
+		if !errors.Is(verifyGoAssemblyDataAlignmentRule(data, loader, []byte(strings.Replace(string(limits), "maxAlign  = 32", "maxAlign  = 16", 1)), dispatch), ErrProbeNeedsContext) {
+			t.Fatal("changed maximum accepted")
+		}
+	}
+}
diff --git a/data_global_alignment_runtime_unix_test.go b/data_global_alignment_runtime_unix_test.go
new file mode 100644
index 000000000..ddc95e774
--- /dev/null
+++ b/data_global_alignment_runtime_unix_test.go
@@ -0,0 +1,52 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixDataGlobalAlignmentOriginalGoAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	goos := "linux"
+	if strings.Contains(execution.triple, "apple") {
+		goos = "darwin"
+	}
+	original := dataGlobalAlignmentGoBuild(t, "amd64", goos, 32)
+	output := execution.run(t, original)
+	if strings.TrimSpace(string(output)) != "actual Go assembly alignment and bytes PASS" {
+		t.Fatal("original Go program did not execute its alignment/byte checks", string(output))
+	}
+	var consumers, declarations, checks strings.Builder
+	ordinal := 0
+	for _, row := range dataGlobalAlignmentSizes {
+		for _, role := range []string{"rw", "ro", "local"} {
+			name := fmt.Sprintf("asm_align_%s_n%d", role, row.size)
+			fmt.Fprintf(&consumers, "define ptr @address%d() {\n ret ptr @%s\n}\n", ordinal, name)
+			fmt.Fprintf(&declarations, "extern uint8_t *address%d(void);\n", ordinal)
+			fmt.Fprintf(&checks, `{
+    uint8_t *address=address%d();
+    if (!address || (uintptr_t)address%%%d) {
+        fprintf(stderr,"%s address mod32=%%lu\n",(unsigned long)((uintptr_t)address%%32));
+        return 1;
+    }
+    for(int i=0;i<%d;i++) if(address[i]!=(i?0:0xa5)) return 2;
+}
+`, ordinal, row.alignment, name, row.size)
+			ordinal++
+		}
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+	for _, route := range []string{"text", "direct"} {
+		ir := dataGlobalAlignmentModule(t, ArchAMD64, execution.triple, route) + consumers.String()
+		for _, level := range []string{"-O0", "-O2"} {
+			t.Run(route+"/"+level, func(t *testing.T) {
+				execution.compileAndRunLLVM(t, "data-global-alignment", ir, main, level)
+			})
+		}
+	}
+	t.Logf("75 original Go globals and both LLVM emitters: actual pointer residues, first bytes and complete zero tails; transport=%s/%s (non-native execution is diagnostic)", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/data_global_alignment_test.go b/data_global_alignment_test.go
new file mode 100644
index 000000000..18ea1f3c7
--- /dev/null
+++ b/data_global_alignment_test.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Independent Go linker limits, not inferred from the implementation helper.
+var dataGlobalAlignmentTargets = []struct {
+	arch                    Arch
+	goarch, goos, directory string
+	triple                  string
+	maximum                 int
+}{
+	{ArchAMD64, "386", "linux", "x86", "i386-unknown-linux-gnu", 32},
+	{ArchAMD64, "amd64", "linux", "amd64", "x86_64-unknown-linux-gnu", 32},
+	{ArchARM, "arm", "linux", "arm", "armv7-unknown-linux-gnueabihf", 8},
+	{ArchARM64, "arm64", "linux", "arm64", "aarch64-unknown-linux-gnu", 32},
+	{ArchWASM, "wasm", "js", "wasm", "wasm32-unknown-unknown", 32},
+}
+
+// Values immediately on either side of every alignment transition, including
+// the odd/nonmultiple sizes for which the old divisibility heuristic fails.
+var dataGlobalAlignmentSizes = []struct{ size, alignment int }{
+	{1, 1}, {2, 2}, {3, 2}, {4, 4}, {5, 4}, {7, 4},
+	{8, 8}, {9, 8}, {15, 8}, {16, 16}, {17, 16}, {23, 16},
+	{24, 16}, {31, 16}, {32, 32}, {33, 32}, {63, 32}, {64, 32},
+	{65, 32}, {127, 32}, {128, 32}, {129, 32}, {255, 32}, {256, 32}, {257, 32},
+}
+
+func dataGlobalAlignmentSource() string {
+	var source strings.Builder
+	for _, row := range dataGlobalAlignmentSizes {
+		for _, role := range []string{"rw", "ro", "local"} {
+			name, flags := fmt.Sprintf("asm_align_%s_n%d", role, row.size), 16
+			if role == "ro" {
+				flags |= 8
+			} else if role == "local" {
+				name += "<>"
+			}
+			fmt.Fprintf(&source, "DATA %s(SB)/1,$0xa5\nGLOBL %s(SB),%d,$%d\n", name, name, flags, row.size)
+		}
+	}
+	return source.String()
+}
+
+func dataGlobalAlignmentResolve(name string) string {
+	return strings.TrimSuffix(strings.TrimPrefix(name, "·"), "<>")
+}
+
+func TestDataGlobalAlignmentBothEmitters(t *testing.T) {
+	for _, target := range dataGlobalAlignmentTargets {
+		for _, route := range []string{"text", "direct"} {
+			t.Run(target.goarch+"/"+route, func(t *testing.T) {
+				file, err := Parse(target.arch, dataGlobalAlignmentSource())
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				var module llvm.Module
+				if route == "text" {
+					var output strings.Builder
+					err = emitDataGlobals(&output, file, dataGlobalAlignmentResolve)
+					if err == nil {
+						module, err = parseIRModuleInContext(ctx, output.String())
+					}
+				} else {
+					module = ctx.NewModule("assembly-data")
+					err = emitDataGlobalsModule(module, file, dataGlobalAlignmentResolve)
+				}
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, row := range dataGlobalAlignmentSizes {
+					want := row.alignment
+					if want > target.maximum {
+						want = target.maximum
+					}
+					for _, role := range []string{"rw", "ro", "local"} {
+						name := fmt.Sprintf("asm_align_%s_n%d", role, row.size)
+						global := module.NamedGlobal(name)
+						if global.IsNil() {
+							t.Fatal("missing source global", name)
+						}
+						if global.Alignment() != want {
+							t.Errorf("%s: LLVM definition alignment=%d, Go linker requires %d", name, global.Alignment(), want)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestDataGlobalAlignmentDoesNotChangeOtherStorageDomains(t *testing.T) {
+	// Private ARM64 literal pools retain their existing separate heuristic.
+	if bestAlign(17) != 1 || bestAlign(24) != 8 || bestAlign(32) != 16 {
+		t.Fatal("assembly definitions changed private literal-pool alignment")
+	}
+	for _, target := range dataGlobalAlignmentTargets {
+		for _, size := range []int64{1 << 20, 1<<20 + 1, 1<<40 + 17, 1<<63 - 1} {
+			if got := goAssemblyDataAlignment(target.arch, size); got != int64(target.maximum) {
+				t.Errorf("%s large size%d alignment=%d, want %d", target.goarch, size, got, target.maximum)
+			}
+		}
+		width := 8
+		if target.goarch == "386" || target.goarch == "arm" {
+			width = 4
+		}
+		source := fmt.Sprintf("DATA holder<>(SB)/%d,$external(SB)\nGLOBL holder<>(SB),16,$17\nGLOBL empty<>(SB),16,$0\n", width)
+		file, err := Parse(target.arch, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: dataGlobalAlignmentResolve})
+		if err != nil {
+			t.Fatal(err)
+		}
+		func() {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := parseIRModuleInContext(ctx, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			external := module.NamedGlobal("external")
+			if external.IsNil() || !external.IsDeclaration() || external.Alignment() != 0 {
+				t.Fatal("undefined external acquired source-owned alignment")
+			}
+			if !module.NamedGlobal("empty").IsNil() {
+				t.Fatal("empty definition acquired backing")
+			}
+		}()
+	}
+}
+
+// Read the actual selected SDK's complete five-architecture min/max directory.
+// Linked source fixtures below independently exercise the size-dependent rule.
+func TestDataGlobalAlignmentOfficialLinkerLimits(t *testing.T) {
+	root := testGOROOT(t)
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			directory := filepath.Join(root, "src", "cmd", "link", "internal", target.directory)
+			constants := map[string]int{}
+			if target.goarch != "wasm" {
+				syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join(directory, "l.go"), nil, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ast.Inspect(syntax, func(node ast.Node) bool {
+					value, ok := node.(*ast.ValueSpec)
+					if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+						return true
+					}
+					literal, ok := value.Values[0].(*ast.BasicLit)
+					if ok && literal.Kind == token.INT {
+						integer, err := strconv.Atoi(literal.Value)
+						if err == nil {
+							constants[value.Names[0].Name] = integer
+						}
+					}
+					return true
+				})
+			}
+			syntax, err := parser.ParseFile(token.NewFileSet(), filepath.Join(directory, "obj.go"), nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			limits := map[string]int{}
+			ast.Inspect(syntax, func(node ast.Node) bool {
+				field, ok := node.(*ast.KeyValueExpr)
+				if !ok {
+					return true
+				}
+				key, ok := field.Key.(*ast.Ident)
+				if !ok || key.Name != "Maxalign" && key.Name != "Minalign" {
+					return true
+				}
+				if _, found := limits[key.Name]; found {
+					t.Fatal("duplicate linker alignment field", key.Name)
+				}
+				switch value := field.Value.(type) {
+				case *ast.Ident:
+					limits[key.Name] = constants[value.Name]
+				case *ast.BasicLit:
+					limits[key.Name], err = strconv.Atoi(value.Value)
+					if err != nil {
+						t.Fatal(err)
+					}
+				default:
+					t.Fatal("unrecognized actual linker alignment expression")
+				}
+				return true
+			})
+			if limits["Maxalign"] != target.maximum || limits["Minalign"] != 1 || len(limits) != 2 {
+				t.Fatalf("Go linker alignment directory changed: %+v", limits)
+			}
+		})
+	}
+}
diff --git a/data_global_symbol.go b/data_global_symbol.go
new file mode 100644
index 000000000..259fdcad5
--- /dev/null
+++ b/data_global_symbol.go
@@ -0,0 +1,12 @@
+package plan9asm
+
+import "strings"
+
+// Go assembly's unqualified DATA names are package-local. Definitions and SB
+// reads must resolve through this same namespace, including caller aliases.
+func resolveAssemblyDataSymbol(sym string, resolve func(string) string) string {
+	if !strings.ContainsAny(sym, "·/.") {
+		sym = "·" + sym
+	}
+	return resolve(sym)
+}
diff --git a/data_relocation.go b/data_relocation.go
new file mode 100644
index 000000000..354adee62
--- /dev/null
+++ b/data_relocation.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func dataAddress(d DataStmt) (string, int64, error) {
+	if !strings.HasSuffix(d.Addr, "(SB)") {
+		return "", 0, fmt.Errorf("DATA %s: address must name an SB symbol: %q", d.Sym, d.Addr)
+	}
+	base, offset, ok := parseSBRef(d.Addr)
+	if !ok || base == "" || strings.ContainsAny(base, "+- \t\r\n()\"'`") {
+		return "", 0, fmt.Errorf("DATA %s: unresolved or malformed address %q", d.Sym, d.Addr)
+	}
+	return base, offset, nil
+}
+
+func validateDataRelocations(file *File, goarch string) error {
+	hasAddress := false
+	for _, d := range file.Data {
+		hasAddress = hasAddress || d.Addr != ""
+	}
+	if !hasAddress {
+		return nil
+	}
+	if goarch == "" {
+		goarch = string(file.Arch)
+	}
+	sizes := types.SizesFor("gc", goarch)
+	if sizes == nil {
+		return fmt.Errorf("DATA relocation has no Go pointer-size contract for %q", goarch)
+	}
+	pointerSize := sizes.Sizeof(types.Typ[types.Uintptr])
+	last := make(map[string]int64)
+	for _, d := range file.Data {
+		end, err := dataStmtEnd(d)
+		if err != nil {
+			return err
+		}
+		if previous, exists := last[d.Sym]; exists && d.Off < previous {
+			return fmt.Errorf("overlapping DATA entry for %s", d.Sym)
+		}
+		last[d.Sym] = end
+		if d.Addr == "" {
+			continue
+		}
+		if d.Width != pointerSize || d.Payload != nil || d.Value != 0 {
+			return fmt.Errorf("DATA %s: address needs an exclusive %d-byte pointer initializer, got width=%d", d.Sym, pointerSize, d.Width)
+		}
+		if _, _, err := dataAddress(d); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func resolveDataSymbol(symbol string, resolve func(string) string) string {
+	if strings.ContainsAny(symbol, "·/.") {
+		return resolve(symbol)
+	}
+	return resolve("·" + symbol)
+}
+
+func resolveDataAddressSymbol(file *File, symbol string, resolve func(string) string, sigs map[string]FuncSig) string {
+	// A plain TEXT name need not use the data-symbol heuristic, especially
+	// with the standalone API's identity resolver. Bind known code addresses
+	// to the actual LLVM definition, including a caller-supplied symbol alias.
+	for _, fn := range file.Funcs {
+		if fn.Sym == symbol {
+			name := resolve(fn.Sym)
+			return funcSigSymbol(name, sigs[name])
+		}
+	}
+	if sig, known := sigs[resolve(symbol)]; known {
+		return funcSigSymbol(resolve(symbol), sig)
+	}
+	name := resolveDataSymbol(symbol, resolve)
+	if sig, known := sigs[name]; known {
+		return funcSigSymbol(name, sig)
+	}
+	return name
+}
+
+func dataAddressIsFunction(file *File, symbol string, resolve func(string) string, sigs map[string]FuncSig) bool {
+	for _, fn := range file.Funcs {
+		if fn.Sym == symbol {
+			return true
+		}
+	}
+	if _, known := sigs[resolve(symbol)]; known {
+		return true
+	}
+	_, known := sigs[resolveDataSymbol(symbol, resolve)]
+	return known
+}
+
+// Go wasm stores addresses in eight-byte DATA slots, but LLVM wasm32 has
+// four-byte pointers. A widened static ptrtoint is not a legal LLVM constant.
+// The wasm MC assembler can instead emit real MEMORY_ADDR_I64/TABLE_INDEX_I64
+// relocations. Keep the slot opaque to LLVM, preserving all bytes and addends.
+func emitWASMDataRelocations(b *strings.Builder, file *File, name string, buffer []byte, relocations map[int64]DataStmt, resolve func(string) string, sigs map[string]FuncSig, abi WASMABI, readOnly, local bool, align int64) error {
+	emit := func(line string) {
+		b.WriteString("module asm \"")
+		for _, ch := range []byte(line) {
+			if ch < 32 || ch > 126 || ch == '"' || ch == '\\' {
+				fmt.Fprintf(b, "\\%02X", ch)
+			} else {
+				b.WriteByte(ch)
+			}
+		}
+		b.WriteString("\"\n")
+	}
+	symbol := strconv.Quote(name)
+	section := ".data."
+	kind := "global"
+	if readOnly {
+		section, kind = ".rodata.", "constant"
+	}
+	emit(".section " + strconv.Quote(section+name) + ",\"\",@")
+	logAlign := 0
+	for (int64(1) << logAlign) < align {
+		logAlign++
+	}
+	emit(fmt.Sprintf(".p2align %d", logAlign))
+	visibility := ""
+	if local {
+		emit(".hidden " + symbol)
+		visibility = "hidden "
+	} else {
+		emit(".globl " + symbol)
+	}
+	// The real LLVM external-global declaration supplies DATA type. Wasm's
+	// .type directive rejects quoted package/path symbols even though labels
+	// and relocation expressions accept them.
+	emit(symbol + ":")
+	for offset := int64(0); offset < int64(len(buffer)); {
+		if relocation, ok := relocations[offset]; ok {
+			base, addend, err := dataAddress(relocation)
+			if err != nil {
+				return err
+			}
+			name, function, packed, err := wasmFunctionAddress(file, base, addend, resolve, sigs, abi)
+			if err != nil {
+				return err
+			}
+			if packed {
+				// The wasm32 table index occupies PC bits 16..47. Place its
+				// real I32 relocation at byte 2 of the eight-byte Go slot.
+				// This is fully initialized by the linker, even before any
+				// host/function entry, and needs no runtime constructor.
+				emit(fmt.Sprintf(".int16 %d", addend))
+				emit(".int32 " + strconv.Quote(name))
+				emit(".int16 0")
+				offset += relocation.Width
+				continue
+			}
+			if function && addend != 0 {
+				// TABLE_INDEX_I64 has no addend. LLVM MC accepts f+1 but
+				// silently drops +1; accepting that would change the source.
+				return fmt.Errorf("%w: wasm DATA function address %s has an unrepresentable table-index addend %d", ErrProbeNeedsContext, base, addend)
+			}
+			value := strconv.Quote(name)
+			if addend != 0 {
+				value += fmt.Sprintf("%+d", addend)
+			}
+			emit(".int64 " + value)
+			offset += relocation.Width
+			continue
+		}
+		if buffer[offset] == 0 {
+			end := offset + 1
+			for end < int64(len(buffer)) && buffer[end] == 0 {
+				if _, address := relocations[end]; address {
+					break
+				}
+				end++
+			}
+			emit(fmt.Sprintf(".zero %d", end-offset))
+			offset = end
+			continue
+		}
+		bytes := make([]string, 0, 32)
+		for offset < int64(len(buffer)) && buffer[offset] != 0 && len(bytes) < 32 {
+			if _, address := relocations[offset]; address {
+				break
+			}
+			bytes = append(bytes, strconv.Itoa(int(buffer[offset])))
+			offset++
+		}
+		emit(".byte " + strings.Join(bytes, ","))
+	}
+	emit(fmt.Sprintf(".size %s,%d", symbol, len(buffer)))
+	fmt.Fprintf(b, "%s = external %s%s [%d x i8], align %d\n", llvmGlobal(name), visibility, kind, len(buffer), align)
+	return nil
+}
+
+// Module assembly references are invisible to the LLVM optimizer. Retain
+// every referenced symbol (and holder) explicitly, including private targets.
+func emitWASMDataRelocationRoots(b *strings.Builder, file *File, resolve func(string) string, sigs map[string]FuncSig) error {
+	roots := make(map[string]bool)
+	for _, data := range file.Data {
+		if data.Addr == "" {
+			continue
+		}
+		base, _, err := dataAddress(data)
+		if err != nil {
+			return err
+		}
+		roots[resolveDataSymbol(data.Sym, resolve)] = true
+		roots[resolveDataAddressSymbol(file, base, resolve, sigs)] = true
+	}
+	if len(roots) == 0 {
+		return nil
+	}
+	names := make([]string, 0, len(roots))
+	for name := range roots {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	values := make([]string, len(names))
+	for index, name := range names {
+		values[index] = "ptr " + llvmGlobal(name)
+	}
+	fmt.Fprintf(b, "@llvm.used = appending global [%d x ptr] [%s], section \"llvm.metadata\"\n", len(values), strings.Join(values, ", "))
+	return nil
+}
+
+// LLVM cannot express a relocation inside a byte-array constant. A packed
+// aggregate preserves every byte offset while retaining pointer relocations.
+// Integer transport uses Go's pointer width on native targets. GEP is
+// deliberately not inbounds: Go accepts signed
+// symbol addends without asserting an object extent.
+func dataRelocationInitializer(file *File, buffer []byte, relocations map[int64]DataStmt, resolve func(string) string, sigs map[string]FuncSig) (string, string, error) {
+	offsets := make([]int64, 0, len(relocations))
+	for offset := range relocations {
+		offsets = append(offsets, offset)
+	}
+	sort.Slice(offsets, func(i, j int) bool { return offsets[i] < offsets[j] })
+	var fields, values []string
+	appendBytes := func(bytes []byte) {
+		if len(bytes) != 0 {
+			typ := fmt.Sprintf("[%d x i8]", len(bytes))
+			fields = append(fields, typ)
+			values = append(values, typ+" "+llvmI8ArrayInit(bytes))
+		}
+	}
+	cursor := int64(0)
+	for _, offset := range offsets {
+		d := relocations[offset]
+		base, addend, err := dataAddress(d)
+		if err != nil {
+			return "", "", err
+		}
+		end, err := dataStmtEnd(d)
+		if err != nil || offset < cursor || end > int64(len(buffer)) {
+			return "", "", fmt.Errorf("DATA %s: overlapping or out-of-bounds relocation", d.Sym)
+		}
+		appendBytes(buffer[cursor:offset])
+		typ := fmt.Sprintf("i%d", d.Width*8)
+		pointer := llvmGlobal(resolveDataAddressSymbol(file, base, resolve, sigs))
+		if addend != 0 {
+			pointer = fmt.Sprintf("getelementptr (i8, ptr %s, i64 %d)", pointer, addend)
+		}
+		fields = append(fields, typ)
+		values = append(values, fmt.Sprintf("%s ptrtoint (ptr %s to %s)", typ, pointer, typ))
+		cursor = end
+	}
+	appendBytes(buffer[cursor:])
+	return "<{ " + strings.Join(fields, ", ") + " }>", "<{ " + strings.Join(values, ", ") + " }>", nil
+}
diff --git a/data_relocation_test.go b/data_relocation_test.go
new file mode 100644
index 000000000..33e7774ed
--- /dev/null
+++ b/data_relocation_test.go
@@ -0,0 +1,336 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var dataRelocationTargets = []struct {
+	arch                 Arch
+	goos, goarch, triple string
+	width                int
+}{
+	{ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu", 8},
+	{ArchAMD64, "darwin", "amd64", "x86_64-apple-darwin", 8},
+	{ArchAMD64, "windows", "amd64", "x86_64-pc-windows-msvc", 8},
+	{ArchAMD64, "linux", "386", "i386-unknown-linux-gnu", 4},
+	{ArchAMD64, "windows", "386", "i686-pc-windows-msvc", 4},
+	{ArchARM, "linux", "arm", "armv7-unknown-linux-gnueabihf", 4},
+	{ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu", 8},
+	{ArchARM64, "darwin", "arm64", "aarch64-apple-darwin", 8},
+	{ArchARM64, "windows", "arm64", "aarch64-pc-windows-msvc", 8},
+	{ArchWASM, "js", "wasm", "wasm32-unknown-unknown", 8},
+}
+
+func dataRelocationGoObject(t *testing.T, source, goos, goarch string, accepted bool) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "data.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-p", "test", "-o", filepath.Join(dir, "go.o"), path)
+	cmd.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+goarch)
+	out, err := cmd.CombinedOutput()
+	if (err == nil) != accepted {
+		t.Fatalf("actual Go %s/%s, expected accepted=%v: %v\n%s", goos, goarch, accepted, err, out)
+	}
+}
+
+func TestDataRelocationAllArchitectures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range dataRelocationTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := fmt.Sprintf(`DATA payload<>+0(SB)/8,$0x1122334455667788
+GLOBL payload<>(SB),16,$16
+DATA holder<>+0(SB)/1,$0xaa
+DATA holder<>+1(SB)/%d,$payload<>+3(SB)
+DATA holder<>+%d(SB)/%d,$external-1(SB)
+GLOBL holder<>(SB),16,$%d
+`, target.width, 1+target.width, target.width, 1+2*target.width+3)
+			dataRelocationGoObject(t, source, target.goos, target.goarch, true)
+			file, err := Parse(target.arch, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			opt := Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: testResolveSym("test")}
+			ir, err := Translate(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			expectedFragments := []string{"ptrtoint", "test.payload", "test.external", "i64 3", "i64 -1"}
+			if target.arch == ArchWASM {
+				expectedFragments = []string{"module asm", ".int64", "test.payload", "test.external", "+3", "-1", "@llvm.used"}
+			}
+			for _, expected := range expectedFragments {
+				if !strings.Contains(ir, expected) {
+					t.Errorf("DATA relocation lost %q, must not encode a zero placeholder:\n%s", expected, ir)
+				}
+			}
+			compileLLVMToObject(t, llc, target.triple, "relocations.ll", "relocations.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			mod, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer mod.Dispose()
+			if !strings.Contains(mod.String(), expectedFragments[0]) {
+				t.Fatal("direct/module route silently discarded DATA relocation")
+			}
+			compileLLVMToObject(t, llc, target.triple, "module.ll", "module.o", mod.String())
+		})
+	}
+}
+
+func TestDataRelocationWidthMatchesGo(t *testing.T) {
+	for _, target := range dataRelocationTargets {
+		for _, width := range []int{1, 2, 4, 8, 16} {
+			if width == target.width {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%d", target.triple, width), func(t *testing.T) {
+				source := fmt.Sprintf("DATA holder<>(SB)/%d,$payload<>(SB)\nGLOBL holder<>(SB),16,$%d\n", width, width)
+				dataRelocationGoObject(t, source, target.goos, target.goarch, false)
+				file, err := Parse(target.arch, source)
+				if err != nil {
+					return // A parser rejection also matches Go.
+				}
+				opt := Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: testResolveSym("test")}
+				if _, err := Translate(file, opt); err == nil {
+					t.Error("wrong-width address relocation accepted")
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateModuleInContext(ctx, file, opt)
+				if err == nil {
+					mod.Dispose()
+					t.Error("module route accepted wrong-width address relocation")
+				}
+			})
+		}
+	}
+}
+
+func TestDataRelocationFunctionSymbolsAreTypedAndBound(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range dataRelocationTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT target(SB),4,$0-0\nRET\nDATA holder<>(SB)/%d,$target(SB)\nDATA holder<>+%d(SB)/%d,$·foreign(SB)\nGLOBL holder<>(SB),16,$%d\n", target.width, target.width, target.width, target.width*2)
+			dataRelocationGoObject(t, source, target.goos, target.goarch, true)
+			file, err := Parse(target.arch, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := testResolveSym("test")
+			opt := Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: resolve,
+				Sigs: map[string]FuncSig{
+					resolve("target"):   {Name: resolve("target"), Ret: Void},
+					resolve("·foreign"): {Name: "foreign_alias", Ret: Void},
+				},
+			}
+			ir, err := Translate(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, "foreign_alias") || strings.Contains(ir, "@test.foreign = external global") {
+				t.Fatalf("a typed function relocation was bound as data or lost its alias:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "function-relocations.ll", "function-relocations.o", ir)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, target.triple, "module-function-relocations.ll", "module-function-relocations.o", module.String())
+		})
+	}
+}
+
+func TestDataRelocationRejectsAmbiguousAndOverlappingDescriptors(t *testing.T) {
+	for name, data := range map[string][]DataStmt{
+		"malformed offset": {{Sym: "holder", Width: 8, Addr: "target+bad(SB)"}},
+		"wrong base":       {{Sym: "holder", Width: 8, Addr: "target(FP)"}},
+		"empty target":     {{Sym: "holder", Width: 8, Addr: "(SB)"}},
+		"mixed value":      {{Sym: "holder", Width: 8, Addr: "target(SB)", Value: 1}},
+		"mixed bytes":      {{Sym: "holder", Width: 8, Addr: "target(SB)", Payload: []byte{1}}},
+		"scalar overlap":   {{Sym: "holder", Width: 8, Addr: "target(SB)"}, {Sym: "holder", Off: 7, Width: 1, Value: 1}},
+		"address overlap":  {{Sym: "holder", Width: 8}, {Sym: "holder", Off: 1, Width: 8, Addr: "target(SB)"}},
+		"negative offset":  {{Sym: "holder", Off: -1, Width: 8, Addr: "target(SB)"}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			file := &File{Arch: ArchAMD64, Data: data}
+			if _, err := Translate(file, Options{Goarch: "amd64"}); err == nil {
+				t.Fatal("ambiguous DATA address descriptor accepted")
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, Options{Goarch: "amd64"})
+			if err == nil {
+				module.Dispose()
+				t.Fatal("module accepted ambiguous DATA address descriptor")
+			}
+		})
+	}
+	file := &File{Arch: ArchAMD64, Data: []DataStmt{{Sym: "holder", Width: 8, Addr: "target(SB)"}}}
+	if _, err := Translate(file, Options{Goarch: "invented"}); err == nil {
+		t.Fatal("invented Go pointer-size contract accepted")
+	}
+	if _, err := dataStmtPayload(file.Data[0]); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("address descriptor was converted to bytes or mislabeled Context: %v", err)
+	}
+}
+
+func TestDataRelocationUnqualifiedStandaloneFunctionAlias(t *testing.T) {
+	file, err := Parse(ArchAMD64, "DATA holder<>(SB)/8,$foreign(SB)\nGLOBL holder<>(SB),16,$8\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"foreign": {Name: "foreign_alias", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "ptr @foreign_alias") || strings.Contains(ir, "foreign = external global") || strings.Contains(ir, "·foreign") {
+		t.Fatalf("standalone address ignored the explicit typed function alias:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "standalone-function.ll", "standalone-function.o", ir)
+}
+
+func TestWASMDataRelocationPaddingIsCompact(t *testing.T) {
+	const source = "DATA payload<>(SB)/8,$42\nGLOBL payload<>(SB),16,$8\nDATA holder<>(SB)/8,$payload<>(SB)\nGLOBL holder<>(SB),16,$65536\n"
+	dataRelocationGoObject(t, source, "js", "wasm", true)
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: testResolveSym("test")}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, ".zero 65528") || len(ir) > 4096 {
+		t.Fatalf("zero padding must not expand to one assembly directive per byte: %d IR bytes\n%s", len(ir), ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, options.TargetTriple, "compact-padding.ll", "compact-padding.o", ir)
+}
+
+func TestDataRelocationLoadsActualAddressAtRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	var move, register string
+	switch runtime.GOARCH {
+	case "amd64":
+		move, register = "MOVQ", "AX"
+	case "arm64":
+		move, register = "MOVD", "R0"
+	default:
+		t.Fatal("this host requires a matching runtime counterpart for the DATA relocation oracle")
+	}
+	source := fmt.Sprintf(`TEXT ·LoadPtr(SB),4,$0-8
+%s holder<>+8(SB),%s
+%s %s,ret+0(FP)
+RET
+TEXT ·PayloadPtr(SB),4,$0-8
+%s $payload<>+3(SB),%s
+%s %s,ret+0(FP)
+RET
+DATA payload<>(SB)/8,$0x1122334455667788
+GLOBL payload<>(SB),16,$16
+DATA holder<>(SB)/1,$0xaa
+DATA holder<>+8(SB)/8,$payload<>+3(SB)
+DATA holder<>+16(SB)/1,$0xbb
+GLOBL holder<>(SB),16,$24
+`, move, register, move, register, move, register, move, register)
+	dataRelocationGoObject(t, source, runtime.GOOS, runtime.GOARCH, true)
+	dir := t.TempDir()
+	for name, body := range map[string]string{
+		"go.mod": "module test/relocations\n\ngo 1.20\n",
+		"data.s": source,
+		"main.go": `package main
+import "unsafe"
+func LoadPtr() uintptr
+func PayloadPtr() uintptr
+func main() {
+  p:=LoadPtr()
+  if p==0 || p!=PayloadPtr() || *(*byte)(unsafe.Pointer(p))!=0x55 { panic("DATA relocation mismatch") }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goRun := exec.Command("go", "run", ".")
+	goRun.Dir = dir
+	goRun.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local")
+	if out, err := goRun.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go runtime relocation baseline: %v\n%s", err, out)
+	}
+	file, err := Parse(Arch(runtime.GOARCH), source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	resolve := func(symbol string) string {
+		return strings.TrimSuffix(strings.TrimPrefix(symbol, "·"), "<>")
+	}
+	opt := Options{Goarch: runtime.GOARCH, TargetTriple: triple, ResolveSym: resolve,
+		Sigs: map[string]FuncSig{
+			"LoadPtr":    {Name: "LoadPtr", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Field: -1}}}},
+			"PayloadPtr": {Name: "PayloadPtr", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Field: -1}}}},
+		},
+	}
+	ir, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const driver = `#include <stdint.h>
+extern uintptr_t LoadPtr(void), PayloadPtr(void);
+int main(void) {
+  uintptr_t loaded=LoadPtr(), expected=PayloadPtr();
+  if (!loaded || loaded!=expected) return 1;
+  if (*(unsigned char*)loaded!=0x55) return 2;
+  return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "data_relocation_load", triple, ir, driver, nil)
+	pkg := mustGoPackage(t, "test/relocations", "package relocations\nfunc LoadPtr() uintptr\nfunc PayloadPtr() uintptr\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: runtime.GOARCH, TargetTriple: triple, ResolveSym: resolve,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translation.Module.Dispose()
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "data_relocation_go_binding", triple, translation.Module.String(), driver, nil)
+}
diff --git a/data_wasm_go121_test.go b/data_wasm_go121_test.go
new file mode 100644
index 000000000..e0191afdf
--- /dev/null
+++ b/data_wasm_go121_test.go
@@ -0,0 +1,10 @@
+//go:build go1.21
+// +build go1.21
+
+package plan9asm
+
+import "testing"
+
+func TestWASMDataRelocationWasip1SourceOracle(t *testing.T) {
+	wasmDataGoObject(t, wasmDataSource(), "wasip1")
+}
diff --git a/data_wasm_relocation_test.go b/data_wasm_relocation_test.go
new file mode 100644
index 000000000..2b018e5d6
--- /dev/null
+++ b/data_wasm_relocation_test.go
@@ -0,0 +1,431 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These are Go's eight-byte DATA slots, not widened LLVM wasm32 pointers.
+// The address arithmetic oracle below uses independent JavaScript BigInts.
+var wasmDataAddends = []int64{0, 4, -4, 1 << 32, -(1 << 32), 1<<63 - 1, -1 << 63}
+
+func wasmDataResolve(symbol string) string {
+	symbol = strings.TrimSuffix(strings.TrimPrefix(symbol, "·"), "<>")
+	return "wasm_data." + symbol
+}
+
+func wasmDataSource() string {
+	var source strings.Builder
+	source.WriteString(`TEXT return42<>(SB),4,$0-8
+Get SP
+I64Const $42
+I64Store ret+0(FP)
+RET
+DATA payload(SB)/8,$0x1122334455667788
+GLOBL payload(SB),16,$8
+DATA private_target<>(SB)/8,$0x8877665544332211
+GLOBL private_target<>(SB),24,$8
+`)
+	for _, holder := range []struct {
+		name  string
+		start int
+		flags int
+	}{
+		{"public_holder", 1, 16},
+		{"private_holder<>", 3, 16},
+		{"readonly_holder", 3, 24},
+	} {
+		fmt.Fprintf(&source, "DATA %s(SB)/1,$0xa5\n", holder.name)
+		for index, addend := range wasmDataAddends {
+			suffix := ""
+			if addend != 0 {
+				suffix = fmt.Sprintf("%+d", addend)
+			}
+			fmt.Fprintf(&source, "DATA %s+%d(SB)/8,$payload%s(SB)\n", holder.name, holder.start+index*8, suffix)
+		}
+		fmt.Fprintf(&source, "DATA %s+%d(SB)/1,$0x5a\nGLOBL %s(SB),%d,$64\n", holder.name, holder.start+56, holder.name, holder.flags)
+	}
+	source.WriteString(`DATA function_holder<>(SB)/1,$0xa5
+DATA function_holder<>+1(SB)/8,$return42<>(SB)
+DATA function_holder<>+9(SB)/1,$0x5a
+GLOBL function_holder<>(SB),24,$16
+DATA private_target_holder<>(SB)/8,$private_target<>(SB)
+GLOBL private_target_holder<>(SB),24,$8
+`)
+	return source.String()
+}
+
+func wasmDataCommand(t *testing.T, name string, args ...string) string {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	out, err := exec.CommandContext(ctx, name, args...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("%s %q: %v\n%s", filepath.Base(name), args, err, out)
+	}
+	return string(out)
+}
+
+func wasmDataTool(t *testing.T, name string) string {
+	t.Helper()
+	if path := findLLVM22Tool(name); path != "" {
+		return path
+	}
+	t.Fatalf("required LLVM 22 %s is unavailable", name)
+	return ""
+}
+
+func wasmDataGoObject(t *testing.T, source, goos string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "data.s"), filepath.Join(dir, "go.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "wasm_data", "-o", object, input)
+	cmd.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS="+goos, "GOARCH=wasm")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("actual Go %s/wasm rejected source: %v\n%s\n%s", goos, err, out, source)
+	}
+	if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+		t.Fatalf("actual Go %s/wasm produced no object: %v", goos, err)
+	}
+}
+
+// Add ordinary LLVM consumers to the actual translated module. No consumer
+// names return42 or private_target: those definitions are module-asm-only roots.
+func wasmDataConsumers(t *testing.T, ctx llvm.Context, mod llvm.Module) {
+	t.Helper()
+	builder := ctx.NewBuilder()
+	defer builder.Dispose()
+	i32, i64 := ctx.Int32Type(), ctx.Int64Type()
+	for _, name := range []string{"public_holder", "private_holder", "readonly_holder", "function_holder", "private_target_holder"} {
+		global := mod.NamedGlobal(wasmDataResolve(name))
+		if global.IsNil() {
+			t.Fatalf("translated holder %s is absent", name)
+		}
+		address := llvm.AddFunction(mod, name+"_address", llvm.FunctionType(i32, nil, false))
+		builder.SetInsertPointAtEnd(ctx.AddBasicBlock(address, "entry"))
+		builder.CreateRet(builder.CreatePtrToInt(global, i32, "address"))
+
+		load := llvm.AddFunction(mod, name+"_load", llvm.FunctionType(i64, []llvm.Type{i32}, false))
+		builder.SetInsertPointAtEnd(ctx.AddBasicBlock(load, "entry"))
+		pointer := builder.CreateGEP(ctx.Int8Type(), global, []llvm.Value{load.Param(0)}, "slot")
+		value := builder.CreateLoad(i64, pointer, "value")
+		value.SetAlignment(1)
+		builder.CreateRet(value)
+	}
+
+	address := llvm.AddFunction(mod, "payload_address", llvm.FunctionType(i32, nil, false))
+	builder.SetInsertPointAtEnd(ctx.AddBasicBlock(address, "entry"))
+	builder.CreateRet(builder.CreatePtrToInt(mod.NamedGlobal(wasmDataResolve("payload")), i32, "address"))
+
+	call := llvm.AddFunction(mod, "call_from_holder", llvm.FunctionType(i64, nil, false))
+	builder.SetInsertPointAtEnd(ctx.AddBasicBlock(call, "entry"))
+	pointer := builder.CreateGEP(ctx.Int8Type(), mod.NamedGlobal(wasmDataResolve("function_holder")), []llvm.Value{llvm.ConstInt(i32, 1, false)}, "slot")
+	value := builder.CreateLoad(i64, pointer, "table_index")
+	value.SetAlignment(1)
+	index := builder.CreateTrunc(value, i32, "physical_table_index")
+	function := builder.CreateIntToPtr(index, llvm.PointerType(ctx.Int8Type(), 0), "function")
+	builder.CreateRet(builder.CreateCall(llvm.FunctionType(i64, nil, false), function, nil, "result"))
+}
+
+func TestWASMDataRelocationsOptimizeLinkAndExecute(t *testing.T) {
+	opt, llc := wasmDataTool(t, "opt"), wasmDataTool(t, "llc")
+	readobj, linker := wasmDataTool(t, "llvm-readobj"), wasmDataTool(t, "wasm-ld")
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Fatal("required Node WebAssembly runtime is unavailable")
+	}
+	source := wasmDataSource()
+	// js/wasm is shared by the historical Go 1.20 matrix. wasip1 starts in
+	// Go 1.21 and belongs in a separately version-tagged source oracle.
+	wasmDataGoObject(t, source, "js")
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: wasmDataResolve,
+		Sigs: map[string]FuncSig{
+			"wasm_data.return42": {Name: "wasm_data.return42", Ret: I64,
+				Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Field: -1}}}},
+		},
+	}
+	for _, route := range []string{"Translate", "TranslateModule"} {
+		t.Run(route, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			var mod llvm.Module
+			var err error
+			if route == "Translate" {
+				ir, translateErr := Translate(file, options)
+				if translateErr != nil {
+					t.Fatal(translateErr)
+				}
+				mod, err = parseIRModuleInContext(ctx, ir)
+			} else {
+				mod, err = TranslateModuleInContext(ctx, file, options)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer mod.Dispose()
+			for name, readOnly := range map[string]bool{
+				"public_holder": false, "private_holder": false, "readonly_holder": true,
+				"function_holder": true, "private_target_holder": true,
+			} {
+				global := mod.NamedGlobal(wasmDataResolve(name))
+				if global.IsNil() || global.IsGlobalConstant() != readOnly {
+					t.Fatalf("holder %s lost its source readonly/mutable contract", name)
+				}
+			}
+			wasmDataConsumers(t, ctx, mod)
+			ir := mod.String()
+			for _, forbidden := range []string{"blockaddress(", "p:64:", "addrspacecast", "@llvm.global_ctors"} {
+				if strings.Contains(ir, forbidden) {
+					t.Fatalf("wasm DATA must not use %s", forbidden)
+				}
+			}
+			dir := t.TempDir()
+			input, optimized := filepath.Join(dir, "source.ll"), filepath.Join(dir, "optimized.ll")
+			object, partial := filepath.Join(dir, "data.o"), filepath.Join(dir, "partial.o")
+			final := filepath.Join(dir, "linked.wasm")
+			if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			wasmDataCommand(t, opt, "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+			optimizedIR, err := os.ReadFile(optimized)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(string(optimizedIR), "@llvm.used") || !strings.Contains(string(optimizedIR), "internal constant [8 x i8]") {
+				t.Fatalf("module-only private target was lost to DCE:\n%s", optimizedIR)
+			}
+			wasmDataCommand(t, llc, "-O2", "-filetype=obj", optimized, "-o", object)
+			relocations := wasmDataCommand(t, readobj, "--file-headers", "--relocations", "--symbols", object)
+			if !strings.Contains(relocations, "Arch: wasm32") || !strings.Contains(relocations, "AddressSize: 32bit") {
+				t.Fatalf("not a real wasm32 object:\n%s", relocations)
+			}
+			if strings.Count(relocations, "R_WASM_MEMORY_ADDR_I64") != 22 || strings.Count(relocations, "R_WASM_TABLE_INDEX_I64") != 1 {
+				t.Fatalf("missing full-width DATA relocations:\n%s", relocations)
+			}
+			for _, name := range []string{"private_holder", "function_holder", "private_target_holder"} {
+				start := strings.Index(relocations, "Name: "+wasmDataResolve(name))
+				if start < 0 {
+					t.Fatalf("local holder %s absent from object", name)
+				}
+				end := strings.Index(relocations[start:], "\n  }")
+				if end < 0 || !strings.Contains(relocations[start:start+end], "BINDING_LOCAL") || !strings.Contains(relocations[start:start+end], "VISIBILITY_HIDDEN") {
+					t.Fatalf("local holder %s escaped object-local visibility:\n%s", name, relocations)
+				}
+			}
+			for _, addend := range wasmDataAddends {
+				if !strings.Contains(relocations, "wasm_data.payload "+fmt.Sprint(addend)) {
+					t.Fatalf("missing signed64 addend %d:\n%s", addend, relocations)
+				}
+			}
+			wasmDataCommand(t, linker, "-r", object, "-o", partial)
+			partialRelocations := wasmDataCommand(t, readobj, "--relocations", partial)
+			for _, addend := range wasmDataAddends {
+				if !strings.Contains(partialRelocations, "wasm_data.payload "+fmt.Sprint(addend)) {
+					t.Fatalf("partial linking lost signed64 addend %d:\n%s", addend, partialRelocations)
+				}
+			}
+			wasmDataCommand(t, linker, "--no-entry", "--export-all", "--export-memory", "--export-table", "--emit-relocs", partial, "-o", final)
+			out := wasmDataCommand(t, node, "-e", wasmDataNodeOracle, final)
+			if strings.TrimSpace(out) != "wasm32 full64 DATA + LLVM loads + indirect call PASS" {
+				t.Fatalf("unexpected Node result: %q", out)
+			}
+			t.Log(strings.TrimSpace(out))
+		})
+	}
+}
+
+const wasmDataNodeOracle = `
+const fs = require("fs");
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]), {}).then(({instance}) => {
+  const e = instance.exports;
+  const view = new DataView(e.memory.buffer);
+  const target = BigInt(e.payload_address() >>> 0);
+  const addends = [0n, 4n, -4n, 4294967296n, -4294967296n, 9223372036854775807n, -9223372036854775808n];
+  for (const [name, start] of [["public_holder",1], ["private_holder",3], ["readonly_holder",3]]) {
+    const address = e[name + "_address"]() >>> 0;
+    if (address % 16 || view.getUint8(address) !== 165 || view.getUint8(address + start + 56) !== 90) throw Error("holder alignment or guards");
+    for (let i = 1; i < start; i++) if (view.getUint8(address + i) !== 0) throw Error("prefix byte gap");
+    for (let i = start + 57; i < 64; i++) if (view.getUint8(address + i) !== 0) throw Error("tail byte gap");
+    addends.forEach((addend, i) => {
+      const offset = start + i * 8;
+      const want = BigInt.asUintN(64, target + addend);
+      const direct = view.getBigUint64(address + offset, true);
+      const fromLLVM = BigInt.asUintN(64, e[name + "_load"](offset));
+      if (direct !== want || fromLLVM !== want) throw Error(name + " slot" + i + " lost full64 address/addend");
+    });
+  }
+  const functionAddress = e.function_holder_address() >>> 0;
+  if (view.getUint8(functionAddress) !== 165 || view.getUint8(functionAddress + 9) !== 90) throw Error("function guards");
+  const index = view.getBigUint64(functionAddress + 1, true);
+  if (BigInt.asUintN(64, e.function_holder_load(1)) !== index || e.__indirect_function_table.get(Number(index))() !== 42n || e.call_from_holder() !== 42n) throw Error("real function index/LLVM indirect call");
+  const privateAddress = e.private_target_holder_load(0);
+  if (privateAddress <= 0n || privateAddress >= 4294967296n || view.getBigUint64(Number(privateAddress), true) !== 0x8877665544332211n) throw Error("module-only private target DCE/layout");
+  console.log("wasm32 full64 DATA + LLVM loads + indirect call PASS");
+}).catch(error => { console.error(error); process.exitCode = 1; });
+`
+
+func TestWASMDataFunctionAddendsRequireContextAfterGoAcceptance(t *testing.T) {
+	for _, binding := range []string{"source_TEXT", "declared_function"} {
+		for _, addend := range []int64{1, -1, 1 << 32, -(1 << 32), 1<<63 - 1, -1 << 63} {
+			t.Run(binding+"/"+fmt.Sprint(addend), func(t *testing.T) {
+				target, prefix := "target", ""
+				if binding == "source_TEXT" {
+					target, prefix = "target<>", "TEXT target<>(SB),4,$0-0\nRET\n"
+				}
+				source := prefix + fmt.Sprintf("DATA holder<>(SB)/8,$%s%+d(SB)\nGLOBL holder<>(SB),24,$8\n", target, addend)
+				wasmDataGoObject(t, source, "js")
+				file, err := Parse(ArchWASM, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: wasmDataResolve,
+					Sigs: map[string]FuncSig{"wasm_data.target": {Name: "wasm_data.target", Ret: Void}},
+				}
+				if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("Go-accepted function addend must retain Context, got %v", err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateModuleInContext(ctx, file, options)
+				if err == nil {
+					mod.Dispose()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("module route accepted an unrepresentable function addend: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestWASMDataRelocationsRequireLLVM22Tools(t *testing.T) {
+	executable, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, executable, "-test.run=^TestWASMDataRelocationsOptimizeLinkAndExecute$", "-test.v")
+	for _, variable := range os.Environ() {
+		if !strings.HasPrefix(strings.ToUpper(variable), "LLVM_CONFIG=") {
+			cmd.Env = append(cmd.Env, variable)
+		}
+	}
+	cmd.Env = append(cmd.Env, "LLVM_CONFIG="+filepath.Join(t.TempDir(), "missing-llvm-config"))
+	out, err := cmd.CombinedOutput()
+	if err == nil || !strings.Contains(string(out), "required LLVM 22 opt is unavailable") {
+		t.Fatalf("missing required tools must fail, not skip or succeed: %v\n%s", err, out)
+	}
+}
+
+func TestWASMDataFunctionAddressesRespectPhysicalABI(t *testing.T) {
+	opt, llc := wasmDataTool(t, "opt"), wasmDataTool(t, "llc")
+	readobj := wasmDataTool(t, "llvm-readobj")
+	for _, binding := range []string{"source_TEXT", "declared_function_alias", "source_DATA"} {
+		t.Run(binding, func(t *testing.T) {
+			source := "DATA holder<>(SB)/8,$target(SB)\nGLOBL holder<>(SB),24,$8\n"
+			name := "wasm_data.external_alias"
+			if binding == "source_TEXT" {
+				source = "TEXT target(SB),4,$0-0\nRET\n" + source
+				name = "wasm_data.target"
+			} else if binding == "source_DATA" {
+				source = "DATA target(SB)/8,$42\nGLOBL target(SB),16,$8\n" + source
+				name = "wasm_data.target"
+			}
+			wasmDataGoObject(t, source, "js")
+			file, err := Parse(ArchWASM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, abi := range []WASMABI{WASMABIDirect, WASMABIGo} {
+				label := "direct_table_index"
+				if binding == "source_DATA" {
+					label = "direct_linear_data_address"
+				}
+				if abi == WASMABIGo {
+					label = "Go_packed_resume_PC"
+					if binding == "declared_function_alias" {
+						label = "unbound_Go_logical_PC_requires_context"
+					}
+					if binding == "source_DATA" {
+						label = "Go_linear_data_address"
+					}
+				}
+				t.Run(label, func(t *testing.T) {
+					options := Options{Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: wasmDataResolve, WASMABI: abi,
+						Sigs: map[string]FuncSig{"wasm_data.target": {Name: name, Ret: Void}},
+					}
+					if binding == "source_DATA" {
+						options.Sigs = nil
+					}
+					for _, route := range []string{"Translate", "TranslateModule"} {
+						t.Run(route, func(t *testing.T) {
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							var ir string
+							var err error
+							if route == "Translate" {
+								ir, err = Translate(file, options)
+							} else {
+								var mod llvm.Module
+								mod, err = TranslateModuleInContext(ctx, file, options)
+								if err == nil {
+									ir = mod.String()
+									mod.Dispose()
+								}
+							}
+							if abi == WASMABIGo && binding == "declared_function_alias" {
+								// A physical signature alone does not establish the
+								// unknown external function's logical-PC role.
+								if !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatalf("Go function DATA cannot impersonate a direct table index, got %v", err)
+								}
+								return
+							}
+							if err != nil {
+								t.Fatal(err)
+							}
+							dir := t.TempDir()
+							input, optimized := filepath.Join(dir, "source.ll"), filepath.Join(dir, "optimized.ll")
+							object := filepath.Join(dir, "data.o")
+							if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+								t.Fatal(err)
+							}
+							wasmDataCommand(t, opt, "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+							wasmDataCommand(t, llc, "-filetype=obj", optimized, "-o", object)
+							relocations := wasmDataCommand(t, readobj, "--relocations", object)
+							expected, wrong := "R_WASM_TABLE_INDEX_I64", "R_WASM_MEMORY_ADDR_I64"
+							if binding == "source_DATA" {
+								expected, wrong = wrong, expected
+							} else if abi == WASMABIGo {
+								expected = "R_WASM_TABLE_INDEX_I32"
+							}
+							if !strings.Contains(relocations, expected+" "+name) || strings.Contains(relocations, wrong+" "+name) {
+								t.Fatalf("typed data/code target was not retained in its proper address space:\n%s", relocations)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/doc/native-arm64.md b/doc/native-arm64.md
index 8a42983ba..828d22168 100644
--- a/doc/native-arm64.md
+++ b/doc/native-arm64.md
@@ -1,7 +1,7 @@
 # Native physical-register backend
 
 `TranslateNativeModule` takes an LLVM context and explicit `NativeOptions`
-(`GOOS`, `GOARCH`, `PackagePath`, and `Imports`). It lowers each restricted Plan 9
+(`GOOS`, `GOARCH`, `PackagePath`, `Imports`, and optional `CodeEntries`). It lowers each restricted Plan 9
 TEXT to a naked LLVM function containing function-local inline assembly, and
 DATA/GLOBL to LLVM global definitions. Linux and Darwin on amd64 and arm64 are
 supported. The caller owns the returned module. LLGo serializes it as LLVM IR
@@ -30,6 +30,17 @@ Package-visible Go functions remain on the typed LLVM path. An unresolved local
 function on that path now requires `ManualSig` or a supported inferred signature;
 it no longer silently receives `void()`.
 
+An explicit `CodeEntries` binding may instead identify a bare source-native
+TEXT address token. It supplies a distinct object-code symbol, not a Go/C
+signature or a pointer-variable initializer. This bounded role accepts only
+`NOSPLIT|NOFRAME`, `$0`/`$0-0`, and an exact direct `JMP` (`B` also on ARM64) to
+a declared native import, optionally followed by an unreachable operand-free
+`RET`. No data instruction, register operation, local call or implicit frame is
+admitted, even on a dead path. Missing bindings remain errors. Import identities,
+import aliases, DATA and other exported entries cannot collide with the bound
+code symbol. Consumers must bind a real source declaration's address to this
+entry; ordinary Go functions still require their declaration-driven ABI.
+
 ## Source contract
 
 - The output target is explicit and independent of the build host. Unsupported
diff --git a/doc/plan9asm-corpus.md b/doc/plan9asm-corpus.md
index 80ee4bc5c..a52b63d3a 100644
--- a/doc/plan9asm-corpus.md
+++ b/doc/plan9asm-corpus.md
@@ -22,11 +22,14 @@ semi-abstract instruction set, and its accepted language evolves with the Go
 toolchain. Coverage therefore uses the union of Go 1.20 through the latest
 supported release, through these increasingly strong layers:
 
-1. Official opcode namespace
+1. Architecture-specific opcode namespace
    - `cmd/internal/obj/x86/anames*.go`
    - `cmd/internal/obj/arm/anames*.go`
    - `cmd/internal/obj/arm64/anames*.go`
    - `cmd/internal/obj/wasm/anames*.go`
+   - `official_opcodes` counts only normalized names in the registered `Anames`
+     arrays (including the registered ARM64 supplement), not operand classes,
+     portable `obj.Anames`, frontend aliases, or parser pseudo directives
 2. Official architecture encoder tables
    - x86 `optab`, `ytab`, `ymovtab`, and generated AVX/EVEX tables
    - ARM and ARM64 `optab` rows and their alias mappings
@@ -54,11 +57,12 @@ supported release, through these increasingly strong layers:
 6. Reduced real-world issue and pull-request regressions
    - each case links back to its report in the conformance manifest
    - the reduced instruction must first be accepted by the native Go assembler
-7. Public Go module ecosystem assembly
-   - `index.golang.org` supplies the chronological public module-version feed
-   - `proxy.golang.org/cached-only` supplies ZIP metadata without executing code
-   - discovered modules are resolved to `@latest`, then their complete package
-     and target matrix is checked before a version is pinned
+7. Reduced public Go module ecosystem regressions
+   - independent instruction-family cases retain their original report/source
+     provenance here, rather than requiring an external module download
+   - module discovery, version policy, ledgers and complete external-package
+     compatibility batches belong to
+     [llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm)
 8. Executable semantic conformance cases
    - `testdata/conformance`
    - the same assembly is run once with the native Go assembler and once after
@@ -70,6 +74,17 @@ Native assembly of generated concrete cases supplies that mode check. Positive
 testdata is useful but not complete: for example, the Go 1.27 386 corpus
 observes only 21 opcodes from the shared 1,600-name x86 namespace.
 
+The scanner's separate `frontend_inventory` records exact, case-sensitive
+spellings from portable and architecture name arrays, the selected `arch.Set`
+constructor's aliases, and `Parser.pseudo`. Entries carry `common`, `arch`,
+`alias`, `pseudo`, and explicit `sentinel` origins, numeric `obj.As` identities
+(null for directives without one), canonical namespaces, source positions and
+source hashes. WASM `Call` and portable `CALL`, for example, remain distinct.
+Unknown registration patterns fail closed. This is source enumeration only:
+neither presence nor a non-sentinel entry proves operand legality, lowering,
+LLVM object compilation, linking, or execution. Existing form baselines are
+independent of this inventory.
+
 `x/arch` is deliberately not treated as a second assembler specification. Its
 Plan 9 case files originate from instruction decoding and formatting, and can
 therefore contain reserved encodings or printed operands that the Go assembler
@@ -151,111 +166,9 @@ native-Go-accepted family subset:
 
     scripts/check-arm64-plan9-corpus.sh
 
-Discover public modules containing Go assembly from the official index:
-
-    go run ./cmd/plan9asmdiscover \
-      -since 2025-01-01T00:00:00Z \
-      -limit 2000 \
-      -out /tmp/plan9asm-discovery.json
-
-Continue at the exact cursor returned by the previous batch:
-
-    go run ./cmd/plan9asmdiscover \
-      -since "$(jq -r .next_since /tmp/plan9asm-discovery.json)" \
-      -limit 2000 \
-      -out /tmp/plan9asm-discovery-next.json
-
-To resume or deliberately rescan an overlapping range without repeating
-completed work, load every earlier report as scan state:
-
-    go run ./cmd/plan9asmdiscover \
-      -since 2025-01-01T00:00:00Z \
-      -limit 2000 \
-      -seen-report /tmp/plan9asm-discovery.json \
-      -seen-report /tmp/plan9asm-discovery-next.json \
-      -out /tmp/plan9asm-discovery-resumed.json
-
-Each report's `scanned` array records every successfully inspected exact
-`module@version`, including modules with no assembly. `-seen-report` skips only
-those exact versions, so a newly published version is still inspected. Failed
-versions are listed with their version in `failures`, are not added to
-`scanned`, and are retried on a later run. Reports are incremental rather than
-cumulative, hence every earlier report must be passed when ranges overlap.
-
-Use `-limit 0` to continue until the current end of the feed. The discovery
-step reads ZIP directory metadata with ranged requests, retries transient
-index/proxy failures, ignores `testdata`, zero-byte, and comment-only assembly
-placeholders, and requires a `.go` file beside a `.s` file so vendored non-Go
-assembler trees are not reported as packages.
-Its architecture field is a filename-based triage hint; the corpus runner's
-`go list` result is the authoritative source-selection check.
-
-After discovery, run every pinned third-party library suite:
-
-    scripts/check-reported-library-corpus.sh
-
-The machine-readable manifest is
-`testdata/corpus/reported-libraries.json`. Each entry records whether it came
-from an llgo issue or the ecosystem scan, the module version, and the exact
-assembly package/file inventory for every target in the complete 386, amd64,
-ARM, ARM64, and WebAssembly matrix.
-The runner first verifies that the pinned version is still the module's
-`@latest`, then uses `<module>/...` so every package in the module is examined.
-It translates and LLVM-compiles every selected `.s` file. Missing target
-reports, newly added or removed assembly packages/files, package-load errors,
-translation errors, and object-compilation errors all fail the suite.
-Package ownership is matched by exact module path, so a v1 suite cannot
-silently include a nested `/v2` module that happens to share its import prefix.
-
-The currently tracked reports are:
-
-- `xgo-dev/llgo#2464`: `github.com/coder/websocket v1.8.15`
-- `xgo-dev/llgo#2552`: `github.com/klauspost/compress v1.20.0`
-- `xgo-dev/llgo#2576`: `github.com/tmthrgd/go-hex` at its latest pseudo-version
-
-The ecosystem scan also pins these latest modules:
-
-- `github.com/RoaringBitmap/roaring v1.9.4`
-- `github.com/anacrolix/mmsg v1.1.1`
-- `github.com/btcsuite/fastsha256 v0.0.0-20160815193821-637e65642941`
-- `github.com/cespare/xxhash v1.1.0`
-- `github.com/cespare/xxhash/v2 v2.3.0`
-- `github.com/dchest/siphash v1.2.3`
-- `github.com/dgryski/go-bits v0.0.0-20180113010104-bd8a69a71dc2`
-- `github.com/dgryski/go-marvin32 v0.0.0-20240117220238-0d39e8c5a8a9`
-- `github.com/golang/snappy v1.0.0`
-- `github.com/klauspost/cpuid v1.3.1`
-- `github.com/klauspost/cpuid/v2 v2.4.0`
-- `github.com/klauspost/reedsolomon v1.14.2`
-- `github.com/minio/highwayhash v1.0.4`
-- `github.com/modern-go/gls v0.0.0-20250215024828-78308f6bb19d`
-- `github.com/pierrec/lz4/v4 v4.1.30`
-- `github.com/stevvooe/resumable v0.0.0-20180830230917-22b14a53ba50`
-- `github.com/tmthrgd/go-bitwise v0.0.0-20190904053232-1430ee983fca`
-- `github.com/tmthrgd/go-popcount v0.0.0-20190904054823-afb1ace8b04f`
-- `github.com/zeebo/this v1.0.0`
-- `golang.org/x/net v0.59.0`
-- `golang.org/x/sys v0.48.0`
-
-Run one library independently by its manifest id:
-
-    scripts/check-reported-library-corpus.sh coder-websocket
-
-The compatibility wrappers remain available:
-
-    scripts/check-coder-websocket.sh
-    scripts/check-klauspost-compress.sh
-    scripts/check-go-hex.sh
-
-For an offline run against the reproducibly pinned versions, disable only the
-online `@latest` comparison; the complete package and target scan still runs:
-
-    PLAN9ASM_CORPUS_CHECK_LATEST=false \
-      scripts/check-reported-library-corpus.sh
-
-CI derives an independent, non-fail-fast matrix job for every manifest entry,
-so adding an issue-reported or ecosystem-discovered library automatically
-creates its own test suite.
+External module discovery, inventory and compatibility batches are maintained
+in [llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm). Its ledger and
+external-library CI are independent of these official instruction gates.
 
 Select an explicit cross-target subset with `PLAN9ASM_CORPUS_TARGETS`, for
 example:
@@ -324,15 +237,16 @@ union is intentional: operand-class names and generated SVE encoders evolve
 between releases, so using only the newest tree would lose forms that existed
 in earlier supported releases.
 
-The Go 1.27 snapshot currently reports:
+The committed `go1.27` snapshot in
+`testdata/coverage/go-asm-baseline.json` reports:
 
 | GOARCH | official names | encoder forms | observed ops | observed forms | supported | context | unsupported | runtime verified | parse failures |
 |---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
-| 386 | 1600 shared x86 names | 4997 shared x86 forms | 21 | 60 | 41 | 6 | 13 | 0 | 0 |
-| amd64 | 1600 shared x86 names | 4997 shared x86 forms | 1456 | 6742 | 755 | 6 | 5981 | 35 | 0 |
-| arm | 181 | 528 | 135 | 500 | 312 | 34 | 154 | 0 | 0 |
-| arm64 | 1417 including SVE | 2964 | 1281 | 1980 | 457 | 47 | 1476 | 62 | 0 |
-| wasm | 463 | 463 opcode-only rows | 71 | 120 | 0 | 120 | 0 | 0 | 0 |
+| 386 | 1600 shared x86 names | 4997 shared x86 forms | 21 | 57 | 24 | 33 | 0 | 0 | 0 |
+| amd64 | 1600 shared x86 names | 4997 shared x86 forms | 1456 | 6736 | 1455 | 5281 | 0 | 51 | 0 |
+| arm | 137 | 528 | 135 | 499 | 455 | 44 | 0 | 0 | 0 |
+| arm64 | 1342 including SVE | 2964 | 1281 | 2048 | 1979 | 69 | 0 | 64 | 0 |
+| wasm | 463 | 463 opcode-only rows | 72 | 121 | 0 | 121 | 0 | 0 | 0 |
 
 These numbers describe current implementation progress, not completion.
 Encoder forms use Go's internal operand classes and are a complete machine-
@@ -340,10 +254,13 @@ readable inventory of the encoder rows; the wasm count is deliberately an
 opcode-only inventory because its Go backend has no such table. Observed forms
 use plan9asm's concrete shape classification and can outnumber encoder rows
 because generated testdata varies registers, address shapes, and concrete
-encodings. The large amd64 gap is mostly the exhaustive legacy/SIMD/AVX test
-matrix. Go 1.27 adds the ARM64 SVE corpus and encoder tables; SVE register
-lists are parsed and every currently unsupported lowering form is reported
-explicitly instead of being hidden as a parse failure.
+encodings. `supported` records IR generation for the supplied probe inputs;
+it does not establish LLVM object compilation or correct execution. `context`
+forms remain unproven until tested with justified initialized inputs. The
+absence of `unsupported` classifications does not establish complete coverage.
+The WASM probe's context-only result requires its separate complete-source
+and object tests. Go 1.27 also adds the ARM64 SVE corpus and encoder tables;
+parsing an SVE form is distinct from compiling and executing it.
 
 The machine-readable cross-version snapshots are in
 `testdata/coverage/go-asm-baseline.json`. A CI mismatch is blocking and
diff --git a/docs/development/architecture.md b/docs/development/architecture.md
new file mode 100644
index 000000000..8bb341b10
--- /dev/null
+++ b/docs/development/architecture.md
@@ -0,0 +1,169 @@
+# Translator architecture
+
+This is a navigation guide, not a coverage certificate. Start with the
+[family workflow](instructions.md) and [validation commands](validation.md).
+
+The current development order is [amd64 architecture convergence](x86-convergence.md):
+finish one architecture's implementation, efficiency and independent coverage
+before expanding another. Existing cross-architecture regression gates remain.
+
+## Translation path
+
+1. Parsing/preprocessing retains assembly instructions, labels, DATA/GLOBL and
+   the source architecture. GoModule additionally derives signatures and frame
+   fields from Go declarations. Already-preprocessed input is not expanded again.
+2. Source and ABI binding establish any extra facts needed by complete functions:
+   parameter/result roles, private continuations, external storage and special
+   runtime entries. An opcode spelling alone cannot establish these facts.
+3. Architecture-local typed parsers validate complete operand forms. Named and
+   raw-encoded forms should converge on the same numerical lowerer and effects.
+   Effects describe reads, writes, widths, flags and preserved register aliases.
+4. Lowerers emit LLVM IR. ARM64 and x86 fallback declarations are selected from
+   immutable catalogs by the generated module's actual global references, not a second
+   opcode-to-intrinsic table. Comments and string data do not select declarations.
+   X86 keeps ordinary declarations and source helpers on their existing path;
+   direct module success needs no catalog lookup or text scan.
+5. The shared module return path checks backend restrictions for every API,
+   including special early returns, and disposes rejected modules. The caller
+   owns a successful module and must dispose it before its LLVM context.
+
+Generated IR enters LLVM through a copied memory buffer, without temporary
+files. LLVM's parser consumes the buffer on success and error. Default buffer
+identities remain independent through a process prefix and atomic sequence;
+explicit IR `source_filename` values are preserved. These names supply no
+source or memory permissions.
+
+`Goarch` selects source encoding/ABI rules. `TargetTriple` selects the LLVM
+backend. They need not be identical for portable operations. Backend-specific
+requirements remain explicit: SVE needs AArch64; wasm cannot use blockaddress.
+Used LLVM `llvm.x86.*` intrinsics require a matching x86 source mode and target,
+except MXCSR load/store, whose i32 memory operand works in either x86 mode.
+The guard checks LLVM intrinsic IDs, not an opcode list; unused declarations,
+ordinary functions and generic portable intrinsics impose no such restriction.
+Actual native inline-assembly uses and nonempty module assembly also require
+the matching source backend. The guard follows LLVM values rather than source
+mnemonics, comments or unused constants. Empty portable compiler barriers retain
+their independently compiled generic constraints. Matching native requests avoid
+the additional instruction walk.
+
+The separate native-source backend consumes shared typed operand forms and
+explicit physical-register instructions. Its naked carriers do not infer Go/C
+call prototypes, initialized inputs or logical frame permissions. On amd64,
+explicit NOSPLIT fixed TEXT frames follow the current Go assembler's BP/local
+entry and return contract; NOFRAME retains the source's physical stack policy.
+The minimum Go compiler can build and use this contract. That does not reproduce
+historical Go frame sequences: Go 1.20 uses a different BP-save sequence and
+leaves zero-local nonleaf entries frameless. Object observations distinguish
+those epochs; they do not establish equal historical incoming FLAGS. Ordinary
+typed IR and official instruction coverage remain on their existing path.
+
+## Family and format normalization
+
+The implementation should scale with the **sum of legal format groups per
+source family, plus lowering strategies per semantic family**. It must not
+enumerate source opcodes times destination opcodes times operand formats.
+LLVM selects destination instructions for portable IR. Target-specific
+intrinsics or exact native instructions are explicit exceptions.
+
+The existing amd64 implementation can be inventoried by the following groups.
+These are design groups, not a count of supported opcodes or encoding rows.
+
+| Source semantic group | Shared format axes | Existing representation |
+|---|---|---|
+| Scalar integer, bit operations and conditions | Operand width, explicit/implicit roles, immediate interpretation, FLAGS | GP typed forms and `x86TypedByteEffect` |
+| Packed integer arithmetic and comparisons | Element/input/result widths, vector width, saturation, encoding, masks | `x86PackedBinaryForm`; four-family `x86PackedPhysicalForm` |
+| Shifts, shuffles and permutations | Count kind, lane boundaries, selection indices, old destination | Family forms with common vector input/effect records |
+| Floating point and conversions | Input/output kinds, scalar/packed shape, rounding and exceptions | `x86FloatBinaryForm` and conversion forms |
+| Moves and memory operations | Direction, access width, alignment, masked access, alias writes | Move forms and typed memory/effect projections |
+| Control flow and machine state | Branch inputs, implicit registers, ordering, x87/MMX state | Dedicated forms and the existing function CFG |
+
+Inventory the destination by **emission strategy**, not target opcode names:
+ordinary LLVM IR, portable/constrained intrinsics, target intrinsics and exact
+native assembly. A family can share arithmetic across strategies while retaining
+an explicit memory or machine-state contract. Target instruction selection is
+LLVM's job; a new backend should not duplicate every source-format rule.
+
+The work therefore scales with shared format grammars, family-specific semantics
+and exceptional lowering contracts. It need not even be a complete
+family-by-format product: each family declares which shared formats are legal.
+Keep the independent official-row inventory exhaustive for tests, including
+overlapping rows; compact implementation is not a reason to sample away rows.
+
+| Layer | Shared representation | Separate concerns |
+|---|---|---|
+| Source grammar | Semantic operation, legal operand group and original encoding | Named/raw source identity and mode restrictions |
+| Format | Operand roles; element, carrier, active, memory and result widths; immediate interpretation | Only combinations admitted by the official encoder |
+| Machine effects | Ordered inputs/outputs, FLAGS, alias writes, masks, memory access and ordering | Alignment faults, inactive-lane suppression and FP exceptions |
+| Source binding | ABI entry/results, frame layout, actual storage and source lifetime | These facts are not granted by parsing a legal instruction |
+| LLVM lowering | Scalar/vector arithmetic, comparisons, shuffles, conversions, memory/control or intrinsics | Native-only operations require a compatible target |
+
+Widths are parameters, but not interchangeable: a broadcast can read four
+bytes into a 64-byte vector, and an extract can write fewer bytes than its
+register carrier. Likewise, merging a masked result reads the old destination;
+zeroing does not. Represent these distinctions once instead of rediscovering
+them in each consumer. Floating-point and machine-state operations must retain
+their special semantics rather than being grouped solely by operand count.
+
+Use small typed records for semantic groups, reusing existing forms such as
+`x86PackedBinaryForm` and `x86FloatBinaryForm`. Keep the parsed form through
+effect analysis and lowering. A translation-local plan may retain immutable
+syntax; it must not cache mutable source permissions or retain stale operands.
+Do not build a universal optional-field structure, another LLVM-like IR, or a
+second opcode registry beside the existing grammar.
+
+The first complete migration should use a packed binary group: normalize its
+format once, feed effects, memory shape and lowering from that record, then
+delete those families' old consumer selectors in the same batch. Adding a GP
+effect cache alone does not complete this migration. In particular, a numeric
+LEA analyzer may reject a static-symbol LEA accepted by source binding; eager
+analysis must not turn that distinction into a translation regression.
+
+Validate independent official rows and initialized functions, preserve previous
+acceptances and meaningful rejections, compile LLVM 22 objects and retain runtime
+oracles. Measure production line delta, parse/analysis allocations and complete
+translation time separately. Neither a faster rejection nor smaller test scope
+counts as an efficiency improvement.
+
+## Terms used in family notes
+
+| Term | Meaning and limit |
+|---|---|
+| Typed grammar | A validated instruction-family form, including operand roles and widths; not proof that arbitrary inputs are initialized. |
+| Numerical value / NUM | Defined bytes usable as a number. A pointer's frame occupancy alone does not grant this role. |
+| Raw continuation | Lowering of instructions following original encoded bytes, with their exact operands and physical-mode effects retained. Decoding alone does not prove caller, frame or memory contracts. |
+| Producer replay | Checking that the source/tool observation which supplied extra facts still matches the consumed input. It is separate from numerical instruction semantics. |
+| Native backing | Concrete storage with the required extent and access contract. A logical frame field or a pointer-shaped value alone does not establish contiguous storage. |
+| Source owner / lease | The bounded lifetime of a captured source/tool observation. Expiry, mutation or closure invalidates its facts. |
+| Context | A probe lacks facts required to decide or translate the form. This is neither support nor successful validation. |
+
+Paired native reads and ordinary scalar stores can consume a complete machine
+word of initialized numerical address bits, including `uintptr` arguments and
+addresses loaded from memory. The selected emitter retains the original
+volatile access, width and faults. This creates no logical pointer, bounds,
+caller or reusable storage fact; standalone queries keep their existing rules.
+Undefined or partial address registers remain unproved.
+
+An immutable declaration table may be shared. Mutable source verification and
+caller facts must not be cached merely to hide repeated subprocess cost. Move
+capture outside repeated translation when its owner and lifetime can be made
+explicit; measure complete-source performance and retain invalidation tests.
+
+## Evidence levels
+
+| Evidence | What it establishes | What it does not establish |
+|---|---|---|
+| Go opcode/encoding table | Names, forms and machine encodings | Translator implementation |
+| Official-corpus classification | Outcome for observed probe inputs | Unobserved forms or initialized-context success |
+| IR generation and verification | Well-formed LLVM module for supplied inputs | Backend acceptance or correct execution |
+| LLVM 22 object compilation | Backend accepts that module/target | Correct calling convention or values at runtime |
+| Executed differential test | Observed values/effects agree with an independent oracle | Every unexecuted form, target or hardware feature |
+
+Never promote `context`, a hardware skip, or zero observed `unsupported` forms
+to object/runtime coverage. Re-test context forms with justified initialized
+inputs, and retain whole-file regressions independently of instruction probes.
+
+Corpus form identity retains the complete source mnemonic, including condition,
+addressing, zeroing, broadcast and rounding suffixes. Opcode/family frequency
+still uses the base mnemonic. Splitting these controls can increase reported
+form counts without adding an instruction implementation. Manifest associations
+must match the complete form; a base-form match cannot certify its controls.
diff --git a/docs/development/arm-status-transfers.md b/docs/development/arm-status-transfers.md
new file mode 100644
index 000000000..502962e5d
--- /dev/null
+++ b/docs/development/arm-status-transfers.md
@@ -0,0 +1,54 @@
+# ARM status transfer boundary
+
+Go's ARM `asm5` types 35/36/37 encode `MOVW{cond} CPSR,Rn`,
+`MOVW{cond} Rn,CPSR`, and rotated-eight-bit immediate writes. The write
+field mask is `fs` (`0xc`), not `fsxc`. The source frontend excludes the
+`SPSR` register spelling; `checkSuffix` rejects `.S/.P/.W/.U/.F` for these
+forms, even though an internal encoder branch mentions `.F`.
+
+The shared typed grammar covers source spelling and A32 MRS/MSR encodings.
+Raw writes to CPSR `f` and `fs` preserve their distinct fields. Source and
+raw predicates use the same source NZCV state, not LLVM's incidental flags.
+Uninitialized saved status, a conditionally defined GP value, PC operands,
+SPSR, and other CPSR field masks fail closed. Unknown bare status/value names
+cannot become a literal zero. Invalid source operands are checked even in
+source-dead blocks; dead writers never prove live flags.
+
+`arm_status_move_test.go` checks actual Go accepted/rejected forms, Go object
+bytes against LLVM22 MC, and LLVM22 objects for ARMv5 Linux, ARMv7 Linux, and
+Windows Thumb. `TestCrossLinuxRuntimeMatrixARMStatusSaveRestore` independently
+executes native Go and LLVM22/GCC ARM objects under QEMU: 2048 NZCV/Q/GE and
+selector inputs across 105 source/raw conditional lanes. SPSR is encoded by
+the independent LLVM MC oracle but is never executed in user mode.
+
+```sh
+go test . -run 'TestARMStatusMove|TestARMPreemptOriginalSource' -count=1
+PLAN9ASM_CROSS_EXEC=1 go test . \
+  -run TestCrossLinuxRuntimeMatrixARMStatusSaveRestore -count=1 -v
+```
+
+The cross-runtime command requires a Linux driver, Go 1.27, LLVM22,
+`arm-linux-gnueabihf-gcc`, `qemu-arm`, and the ARM sysroot. Missing required
+tools fail the enabled runtime test.
+
+## Original asyncPreempt remains a missing contract
+
+The actual selected Go `preempt_arm.o` witnesses MRS `e10f0000`, MSR
+`e12cf000`, and the source stack-PC resumption. The original first CPSR read
+has no preceding source-defined NZCV. The zero-argument Go declaration is not
+an ordinary LLVM C entry signature. The original source therefore still
+returns `ErrProbeNeedsContext`; this repair does not make the file a pass.
+
+A sufficient extension needs explicit incoming GP/VFP/CPSR/FPSCR state,
+source-owned stack storage and saved-status provenance, and the caller's
+resume-PC/continuation contract. It also needs the real `asyncPreempt2` Go
+call/GC/stack-relocation effects. The current unchanged-LR `ARMMachineEntry`
+cannot justify its SP/LR writes, native Go call, or `MOVW.P 192(R13),R15`.
+Neither function-name guessing, invented ordinary parameters, nor a generic
+late MRS closes that boundary.
+
+Encoding references: Go `cmd/internal/obj/arm/asm5.go`,
+`cmd/asm/internal/arch/arch.go`, and LLVM22
+[`ARMInstrInfo.td`](https://github.com/llvm/llvm-project/blob/llvmorg-22.1.8/llvm/lib/Target/ARM/ARMInstrInfo.td)
+and
+[`basic-arm-instructions.s`](https://github.com/llvm/llvm-project/blob/llvmorg-22.1.8/llvm/test/MC/ARM/basic-arm-instructions.s).
diff --git a/docs/development/arm64-raw-zero-frame.md b/docs/development/arm64-raw-zero-frame.md
new file mode 100644
index 000000000..4e7c4659a
--- /dev/null
+++ b/docs/development/arm64-raw-zero-frame.md
@@ -0,0 +1,46 @@
+# ARM64 raw zero-frame ownership proof
+
+Zero-frame and `NOFRAME` functions do not receive a Go LR/FP prologue merely
+because a raw WORD later decodes to BL. A private raw BL witness records its
+exact same-source PC target; diagnostic comments cannot provide that origin.
+
+The additive whole-source proof tracks a bounded negative-SP envelope, may-frame
+GP aliases and spills, and independent BP/LR reaching values. Every root return
+restores entry SP/BP/LR; a bounded local raw call returns with its call-site SP
+and exact continuation. Unknown/native calls, unallocated stack cells, differing
+SP joins, partial pointer spills, unknown indexing and address escapes fail.
+Dead components are checked too. Existing framed-source and continuation guards
+remain independent. Proof registration is not an object or runtime pass.
+
+After exact root SP/BP/LR/g and OS-reserved R18 restoration, an explicit ordinary ABI0 void signature
+can discard dead virtual GP scratch. It requires complete direct eight-byte
+pointer/integer FP parameters, exact TEXT argument size, no results, register
+ABI, custom assignment, native entry or hidden context. Source-only proofs
+cannot guess this contract. Earlier stores, escapes and calls remain checked;
+void transport is not an all-instruction or frame-address exemption.
+Raw WORDs can name g/R18 even when Go's textual parser cannot. Their complete
+entry identity is checked independently of address taint: partial spill writes,
+constant overwrites, mixed joins and unknown effects cannot inherit restoration.
+
+`TestARM64RawZeroFrame*` retains original Go-accepted minimum RED cases, explicit
+escape/overlap/call-context negatives, and physical-leaf source-origin checks.
+The shared MC matrix adds 132 raw scalar/GP-pair/FP-pair width/sign/offset and
+writeback/local-call variants plus 48 actual Go memory spellings. Required
+ARM64 native/cross runtime tests compare original Go WORD objects and LLVM22
+against independent numeric/full-canary oracles, including two arithmetic
+helper calls whose effects must actually execute. These fixtures do not prove
+that an entire external module translates.
+
+The complete scalar AMUL/AMADD rows share a typed input selector with control
+analysis. Two operands read the destination; three/four operands do not read
+its stale value unless an explicit source aliases it. Every actual PC input
+retains derived-code taint. The 28-form original-Go/LLVM oracle compares
+independent low/high, signed, long and accumulate arithmetic, all four NZCV
+sentinels, unaligned full canaries and real LR-returning callers.
+
+Continuation memory uses the same typed scalar/GP/FP-pair grammar as private
+frame ownership. Each store invalidates only its actual byte range; partial
+loads and floating code bits never restore an exact caller pointer. Unknown
+indexes, malformed writeback and transformed code remain conservative. The
+96-form original-Go/LLVM runtime oracle keeps physical SP aligned and checks
+offset, pre/post and raw-local-call paths adjacent to saved LR/BP cells.
diff --git a/docs/development/current-work.md b/docs/development/current-work.md
new file mode 100644
index 000000000..00e18d2ad
--- /dev/null
+++ b/docs/development/current-work.md
@@ -0,0 +1,76 @@
+# PR40 closeout
+
+Updated 2026-11-04. Finish AMD64 correctness, typed-family convergence and
+translation efficiency while preserving the 386, ARM, ARM64 and WASM gates.
+Read [architecture](architecture.md), [instruction families](instructions.md),
+[convergence](x86-convergence.md) and [validation](validation.md).
+
+The [contribution description](https://github.com/xgo-dev/plan9asm/pull/40)
+records the latest staged revision, CI and remaining work. Check actual Git
+status and contribution heads before continuing; a dated local result cannot
+certify a later head. Run new CI in the allowed fork and prioritize affected
+complete owners before the remaining source/CLI owners.
+
+## Accepted baseline
+
+Product `940dbf7ecef9b32ab6bc96e8fb42519430c45171` completed
+[49/49 fork jobs](https://github.com/cpunion/plan9asm/actions/runs/41794972485),
+with all 56 required artifacts validated. Ordinary source/CLI reports contain
+441,520 PASS and 307 explicit SKIP, zero FAIL. The separate forced-runtime
+component has 535 root and 3,954 child PASS, zero SKIP/FAIL; five required
+rich-CLI ARM64 nodes also RUN/PASS. Node policy 579 and Go policy 484 pass.
+Statement coverage is 88.5% main and 70.5% / 79.1% CLI.
+
+This baseline changes only two consumer-order assertions from `c395df92b7ac`;
+all production blobs remain identical. Its complete SDK declaration, physical
+frame, source-selected native component and Go-funcval contracts remain
+separate from numerical instruction forms. Later local changes need their own
+qualification; baseline results are not silently inherited.
+
+## Tail and syscall batch
+
+External validation exposed two source-contract classes in a complete x/sys
+assembly file. Keep that source unchanged and independently reproduce each
+class in this repository.
+
+- Imported ordinary ABI0 tail stubs join actual caller/import declarations and
+  exact frame layouts through the existing direct-tail graph. Preserve the old
+  same-package path. Check only selected function types with Go's type checker
+  and target sizes; body-only imports absent from export data grant nothing and
+  must not reject an otherwise identical signature. Recheck after resolver
+  callbacks. Manual signatures alone do not supply the imported source role.
+- Named Linux AMD64 `SYSCALL` shares one target/form/effect descriptor with its
+  raw-kernel emitter. Preserve raw negative errno and DX; never substitute
+  libc's errno-changing wrapper. Seven complete numerical inputs are required;
+  logical/private frame addresses, old CX/R11 and FLAGS do not acquire roles.
+- Existing elided scheduler hooks must use the same finite semantic predicate
+  in emission and paired auditing. They do not provide an ordinary Go-call
+  prototype or implement a complete runtime scheduler contract.
+
+Focused regressions live in `x86_go_imported_tail_test.go` and
+`x86_linux_syscall_test.go`. The default Linux/amd64
+`TestCrossLinuxRuntimeMatrixAMD64LinuxRawSyscall` executes original Go plus all
+three translated APIs, both IR optimization levels and both backend levels,
+against the independent C errno/DX/I/O/canary oracle. Other hosts' object or IR
+success does not count as execution of this owner. Qualification requires the
+complete affected current/minimum-SDK union and publication policies, then the
+final fork source/CLI owners and actual LLGo program validation.
+
+## Separate integration boundaries
+
+[LLGo PR2694](https://github.com/xgo-dev/llgo/pull/2694) owns the compiler-side
+adaptation. Its staged `7a956ca4` completed all three adapter/build/CL jobs:
+4,928 PASS, 60 explicit SKIP, zero FAIL. Reported-library full-program checks
+and the next dependency pin retain separate exact source/compiler identities.
+An official fixed upstream plan9asm tag is still required before LLGo merges;
+a public fork pseudo-version does not close that review condition.
+
+The 65 tagged AVX512 owners remain hardware pending. Strict SDK/runtime history
+remains 41/55 PASS and 14 separate gaps in
+[issue47](https://github.com/xgo-dev/plan9asm/issues/47). Do not promote these
+boundaries, classified context forms or cancelled jobs into successful runtime
+coverage. Keep contributions draft until their current tests, CI and review pass.
+
+External scanning, ledgers and compatibility batches belong to
+[llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm). No inventory job
+runs locally. Never restore those workloads to the translator's PR CI.
diff --git a/docs/development/instructions.md b/docs/development/instructions.md
new file mode 100644
index 000000000..ef4f78405
--- /dev/null
+++ b/docs/development/instructions.md
@@ -0,0 +1,1711 @@
+# Instruction-family development
+
+Read the repository [rules](../../AGENTS.md) first. This guide describes the
+workflow, not a list of already completed instruction families.
+The [architecture guide](architecture.md) defines the pipeline, evidence levels
+and terms used below, including raw continuation, producer replay and native backing.
+
+## Sources of truth
+
+- Use the supported Go toolchain's assembler tables under
+  `$(go env GOROOT)/src/cmd/internal/obj/<arch>` as the authority for opcode,
+  operand, register, suffix, masking, broadcast, and rounding forms.
+- For x86 AVX/EVEX instructions, inspect both the referenced `ytab` and every
+  opcode attribute in `avx_optabs.go`. A shared `ytab` does not imply that
+  rounding, SAE, broadcast, or zeroing flags are identical.
+- Confirm uncertain forms with the Go assembler. Do not infer a form solely
+  from Intel syntax or from a third-party source file.
+- Treat `386`, `amd64`, `arm`, `arm64`, and `wasm` as supported architectures.
+  A form must not be classified as unsupported merely because the host has a
+  different architecture.
+
+## Instruction-family workflow
+
+XCHG B/W/L/Q uses the emitter's complete exchange grammar in fixed-frame,
+caller-origin and canonical-byte observers. Scalar MOV and XCHG share value
+reads and writes: snapshot both inputs, preserve full-word pointer identities,
+constants and ranges, and never reinterpret a pointer as NUM. Memory exchanges
+write their original address before changing an aliased base register; private
+RMW requires initialized bytes or an exact pointer spill. Native memory retains
+the existing implicit-lock emitter, faults and ordering, without new extent or
+alignment permission. Narrow writes revoke whole-word facts, while Go's AX/AX
+opcode 90 remains a true NOP. Keep independent original-Go execution alongside
+width/alias proofs and objects; object success alone is not execution evidence.
+CMOV reuses the same scalar values and complete conditional-move grammar.
+Both alternatives and the unconditional memory read remain required. Selection
+preserves identical pointer identities and constants, intersects canonical bytes,
+and takes the hull of known numerical ranges; differing origins stay Context.
+W/L writes retain their architectural upper-byte rules and preserve FLAGS.
+
+ANDNL/Q and PDEPL/Q/PEXTL/Q share Go's complete `_yandnl` operand grammar
+and ordered two-input/one-output byte effect, not their numerical or FLAGS
+operation. Mode32 ignores VEX.W, including Q memory widths. ANDN defines only
+CF/OF/SF/ZF and kills AF/PF knowledge; PDEP/PEXT preserve FLAGS. MULX's
+different input/output roles do not inherit this registration. Lowering shares
+exact-width native GP read emission with ADX, not its carry obligation or memory
+permission. Keep ordinary named register/logical storage in the strict transfer;
+the special adapter consumes only an exact raw origin or independently paired
+native read. Preserve original Go/emitter format objects and public Context,
+initialized objects, original portable values/aliases and live/dead NULL/page
+fault controls. Infrastructure errors are not Go assembler rejection witnesses.
+
+ADCXL/Q and ADOXL/Q share the complete `yml_rl` grammar, encoder offset and
+ordered source/old-destination byte effect. Only the selected CF or OF chain
+is read and written; all other FLAGS and unrelated storage stay unchanged.
+Exact raw opcode, operands and original default address size permit only a
+paired numerical projection. Overrides, physical segments, raw entry and
+caller/frame roles remain independent. Native reads retain their exact width,
+unaligned volatile effect and input requirements even for dead results.
+Keep original uninitialized formats as Go/emitter objects plus public Context;
+initialized public objects and portable carry-chain values are separate from
+required original native execution. The raw continuation guard belongs after
+authenticated numerical readers, not in the physical MMX ownership scan.
+
+The eight BMI2 L/Q shifts and rotates share their complete opcode table,
+source grammar, physical-mode width and count masking with lowering. Exact
+decoded operands permit only a paired numerical continuation. Native sources
+retain their exact volatile reads; no caller, frame or later-read fact follows.
+The existing closed nontrapping GP domain may keep a dead result unknown.
+Do not confuse that with initialized bytes: result, address, store and control
+uses still require their actual numerical inputs. Keep original source replay,
+every-byte/alias negatives, five-target objects and portable value/FLAGS tests.
+
+VZEROUPPER/VZEROALL compose with named native reads only after exact decoded
+zero-operand identity checks. Share that identity check with implicit GP
+extensions, not their distinct effects. Mode32 writes only banks 0-7, amd64
+0-15; upper banks and preserved low bytes retain their original knowledge.
+Full-bank portable execution is separate from native opcode/MXCSR execution.
+
+Raw scalar counts and X/Y move-mask sources compose with native output only
+after their complete existing grammar and exact original operands validate.
+Keep count input widths, W preservation, L zero extension and CF/ZF versus
+all-status availability distinct. Move-mask preserves vector aliases and FLAGS.
+Both reuse existing typed effects; neither grants memory backing or physical
+MMX/x87 state. A numerical address is not an incoming pointer. Preserve exact
+original Void/native-output counterexamples as well as register-return objects;
+the latter alone did not find this routing defect. Original named text flags
+require their real header in the independent Go object, never a rejection guess.
+
+The six implicit accumulator sign extensions share one complete `ynone`
+grammar with lowering and exact GP effects. Zero source operands do not mean
+zero AX inputs: require the actual byte/word/dword/qword source even for Void.
+Word writes preserve unknown upper destination bytes; dword writes zero-extend.
+Named and exact decoded forms preserve FLAGS. Only the lowering continuation
+consumes raw origin; public queries gain no native entry or frame permission.
+Keep isolated named/raw negatives, initialized five-target objects, every-bit
+portable values and original native FLAGS execution as separate axes.
+
+DWORD-to-qword products consume the existing complete binary grammar and
+shared numerical input model. Masks and merge bytes remain required, including
+Void; raw continuations bind their original operands and complete physical mode.
+Original uninitialized format/disp32 probes retain Go/emitter objects plus
+three-API Context controls. Independent initialized objects own public success;
+neither a direct emitter nor a classification change grants caller memory.
+
+The two IFMA names share their complete six-row EVEX grammar and ordered
+numerical inputs. Each qword consumes source bits 51:0 and every accumulator
+byte, even with zero masking. Unknown register results may stay unknown; masks
+and every observable byte remain actual inputs. Memory retains the full E4
+tuple or eight-byte broadcast with guarded volatile reads. Physical mode32
+mask encodings do not inherit Go's named four-operand cap; exact source identity
+and all remaining bank/address checks still apply. Encoding-aware writeback
+clears wider aliases. Preserve independent full Go attributes, every-byte and
+nonzero-upper controls, original unbound formats and initialized public objects.
+Portable integer LLVM execution does not qualify original AVX512 execution.
+
+Qword bit lookup shares complete binary/K-result grammars and EVEX field
+decoding with IFMA, not its numerical or access policy. VPMULTISHIFTQB retains
+the full E4NF tuple or m64 broadcast even with a zero mask; VPSHUFBITQMB uses
+byte-granular E4 suppression and a write-only K result. Bind all Go rows and
+attributes independently. Source data, masks and merging bytes remain required,
+and encoding-aware vector writeback clears wider aliases. See Intel's
+[E4NF reference](https://cdrdv2-public.intel.com/843829/325383-sdm-vol-2abcd-dec-24.pdf)
+and [BITALG encoding/access metadata](https://github.com/intelxed/xed/blob/main/datafiles/bitalg/bitalg-isa.xed.txt).
+
+All eight raw immediate packed compares reuse their existing typed shape and
+numerical transfer. Bind the full original selector and operand identity before
+selecting source index one. Capture the physical form before a lowering-local
+provenance projection: reparsing it afterward must not reapply named mode32
+arity limits. Complete incoming-pointer and E4 input obligations remain; no
+standalone query, caller, physical entry or frame authority follows. Preserve
+original unbound format objects plus Context separately from initialized
+five-target public objects, every predicate and missing-input mutations.
+
+VPERMILPS/PD share all eighteen Go rows with lowering and result definedness.
+Immediate selectors consume only selected bytes within each 128-bit lane;
+variable selectors require the actual data and low control byte for each
+element. Unknown result bytes stay unknown. Masks and merging bytes remain
+inputs; zeroing does not supply a missing pointer or selector. E4NF memory
+reads retain the entire volatile tuple, or exact m32/m64 broadcast, even for
+Void and zero masks. Encoding-aware writeback clears wider aliases while
+preserving independent GP, FLAGS and private state. Complete sealed raw
+producer replay remains a restriction even when only origin metadata is erased;
+neither decoder identity nor private format objects authorize named inputs,
+native memory or raw entry. Keep original unbound Go/public Context controls
+separate from initialized public objects and required runtime execution.
+
+MULXL/Q has its own complete source/implicit-DX/two-output form, not ANDN's
+read/write roles. Capture both inputs before either output, zero-extend L
+results, and preserve FLAGS/DF and unrelated private/caller state. Native
+reads retain exact volatile widths even for Void. Exact raw continuations
+require complete immutable producer replay; a decoder origin is not NUM or
+backing. Physical SP/AMD64 BP outputs and effective memory base/index sources
+need their separate whole-source role; virtual stack storage is not native
+backing. Go386's ignored static-SB base annotation remains a different role.
+Preserve ordinary owned-DATA dead-register controls. Mode32 WIG observation
+does not grant an ordinary qword entry. Keep uninitialized original formats
+as actual Go/LLVM objects plus public Context, separately from initialized
+public programs. Private format units call the same pure emitter after shape
+validation; never set a cached proof flag or invent input/pointer authority.
+
+Conditional moves retain the old destination and actual predicate dependencies;
+their native source read is unconditional, including false predicates and Void.
+The existing nontrapping GP domain may leave a dead named-register result
+unknown, but no later result, address, store or control use may consume it as
+initialized. Exact raw identity permits a lowering-local numerical view, not
+a pointer, frame, standalone-query or native-entry fact.
+
+AES/VAES share complete round, inverse-mix and key-assist forms and byte
+dependencies. Immediate-first key assist selects its data source through the
+typed operand index; bind every original operand, including the selector,
+before using that index. Memory retains its complete physical envelope even
+when only selected register subwords contribute numerically. Preserve original
+legacy alignment faults, VEX/EVEX upper-zeroing, and independent FLAGS/DF/ID.
+The existing nontrapping register domain may propagate unknown result bytes;
+accepting that transfer never initializes them. Later observable data/control
+uses still require their exact bytes. Native reads retain their complete input
+and access obligations even for dead results. No value comes from an
+implementation slot merely initialized to zero.
+
+Physical MMX observers keep the entire source branch-free and their region
+uninterrupted through real EMMS. Seed status and prepare unrelated state before
+entering the region; do not relax that boundary to accommodate an old fixture.
+Architecture-scoped dispatch maps must remain visible to supported-op extraction;
+test the isolated source file as well as whole-repository reporting.
+
+The two ordinary half conversions share their complete eighteen-row Go grammar
+and precision-family carrier/input helpers, not raw-only FP16 permission.
+Preserve VEX/EVEX physical identity, integer-expression imm8 classification,
+mode32 named/raw arity, active bytes, merge and mask inputs, including Void.
+Narrowing memory uses its real masked native opcode, not conversion plus an
+ordinary store. EVEX.z memory faults before source, mask or address evaluation;
+Go's SAE-memory rejection is separate. Matching x86 emission retains original
+MXCSR and exception effects, including dynamic immediate controls 4–7.
+Authenticate the complete raw producer before any continuation. Original Go
+objects, initialized five-target public objects and explicitly private fixed-
+rounding mathematics are separate evidence; the latter is not native execution.
+
+Raw-only FP16 floating conversions distinguish active scalar/lane bytes from
+their X/Y/Z carriers. Decoder identity binds the original operands and vector
+length; actual mask, merge and source inputs stay mandatory for Void. Keep
+scalar passthrough unknown where its source bytes are unknown, and clear wider
+aliases according to EVEX. Matching x86 targets emit the original opcode to
+preserve MXCSR, exceptions and masked access; cross-target numerical execution
+is a separate oracle. Check actual object controls, not just LLVM compilation.
+Dispatch conflicts and malformed addresses must fail before emitting any IR.
+
+Raw FP16 SQRT shares the named SQRT grammar and byte dependency, not its caller
+permission. Exact decoded source identity is required by the lowering-only
+continuation. Scalar upper bytes preserve their actual source knowledge;
+packed Z needs all 32 mask bits. Share the native scalar emitter with FP16
+conversions while retaining each family's memory width and arithmetic opcode.
+Original unbound formats, initialized public objects and portable numerical
+execution are separate axes; none certifies native FP16 hardware execution.
+
+Raw FP16 FMA shares the existing thirty-member typed family. Each order reads
+both explicit sources and the old destination, including .Z. Scalar upper X
+bytes come from the old destination, not the second source; retain unknown
+bytes as unknown. Reuse the three-operand native emitter with scalar
+conversion/SQRT, preserving the actual opcode, memory tuple and full 32-lane
+mask. Exact raw identity only permits the paired lowering result; it grants
+no caller, standalone query, physical entry or memory-backing authority.
+
+Raw FP16 binary arithmetic shares the existing floating binary grammar and
+byte dependencies. Keep all twelve packed/scalar members, full 32-lane masks,
+scalar upper bytes from the second source, and old destination bytes only for
+merging. MIN/MAX SAE and arithmetic ER have distinct native controls. Exact
+decoded identity gates the paired lowering continuation, including Void;
+unbound original format objects remain separate from initialized public objects.
+Portable numerical/guard-page execution does not certify native FP16 execution.
+
+Treat an external-library failure as a counterexample to the systematic
+coverage mechanism, not only as a package-specific regression. Identify where
+the independent Go rules, typed grammar, lowering/effect consumers or executed
+tests diverged; then enumerate and repair the entire affected rule class.
+Add a regression that still finds the defect without that external library.
+Rerun both the complete affected class and the original discovering sample.
+
+REP/REPN SCAS/CMPS does not define status FLAGS when its count is zero. A paired
+whole-source result proof may nevertheless accept a following conditional when
+both bounded zero-count successors write the same complete constant result and
+have no observable memory or call effects. Full-width exact copies can cancel;
+shared pointer origins, changed offsets and partial writes cannot. Keep the
+ordinary nonempty input/access proof, CFG joins and shared work limits intact.
+This rule never grants FLAGS to another consumer or a standalone query. CLD/STD
+always update virtual DF; only matching x86 targets emit the physical instruction.
+Check both incoming native ZF states separately from portable value execution.
+
+Keep the Go-table oracle independent of the implementation spec. Retain each
+encoding row's prefix, zcase, byte offset and opcode-specific attributes as well
+as its operand classes. A shared ytab or a name/row count is not a complete
+format check. Concrete syntax witnesses do not prove which overlapping encoder
+row Go selected, LLVM object success, runtime semantics or an ABI contract.
+
+Non-temporal vector moves share the complete legacy yxr_ml/ylddqu and both
+five-row AVX tables, including MOVNTDQ's MOVNTO alias. Retain actual native
+opcodes: LLVM nontemporal/align metadata cannot preserve dead-access or alignment
+faults. Legacy loads preserve wider aliases; VEX/EVEX loads clear them. Legacy
+Yml register destinations fault before inputs. VEX.WIG is not EVEX.W0/W1;
+masking, zeroing and broadcast remain reserved. Reuse packed fixed-local byte,
+alignment and spill-revocation proofs, not another memory permission. Native
+byte boundaries grant neither raw entry nor symbolic-read authority. Original
+unbound formats need Go objects and public Context controls; initialized
+counterparts own public objects and separately required runtime evidence.
+
+A bound whole-instruction prefix must own dispatch before overlapping generic
+handlers. For scalar LOCK, an emitted correct helper is not evidence that the
+source operation uses it: inspect every original function body through all
+public APIs and both IR levels, then retain actual objects and native execution.
+Keep complete prefix adjacency, carry, frame and address checks unchanged.
+
+Use test-driven development for every instruction change:
+
+1. Reproduce the unsupported instruction or incorrect operand-form behavior in
+   a focused test and run it to observe the expected failure.
+2. Before implementing the opcode, enumerate its complete family and all forms
+   in the current Go assembler tables. Add positive and negative form tests.
+3. Implement a coherent instruction family, not only the single spelling that
+   exposed the gap. Cover every X/Y/Z width, register and memory source,
+   architecture restriction, mask/zero form, broadcast form, and rounding/SAE
+   form present in the Go tables.
+4. Compile generated IR with LLVM 22 for every affected target. Add runtime
+   conformance when an instruction's lane preservation, operand order, flags,
+   masking, NaN behavior, or memory effects are not established by compilation.
+5. Rerun the discovering external-library shard or official corpus that exposed
+   the problem. One fixed mnemonic must not hide another form from the same
+   family.
+
+Prefer typed, table-driven grammars over mnemonic-specific branches. Separate
+orthogonal axes such as operation, lane/stack width, operand class, encoding
+generation, architecture mode, masks/broadcast/rounding, implicit registers,
+and semantic effect. The parser/validator, register-liveness scan, lowering,
+supported-op extraction, and completeness test should consume the same spec
+where practical. A completeness test must compare the whole spec table with
+the current Go encoder family so adding one observed spelling cannot leave
+sibling forms unmodeled.
+
+The twelve compact/expand names share Go's complete `_yvcompresspd` and
+`_yvexpandpd` grammar: X/Y/Z widths, matching banks, optional K1-K7 and masked
+register zeroing. Compressed memory `.Z` encodes an architectural #UD before
+source, mask or address access, not an ordinary store. Keep original Go bytes,
+fault-priority controls and all-five-x86-target objects. Isolated probes lack
+initialized source/mask/merge inputs; complete sequences must establish them
+without borrowing zeroed implementation slots. Logical FP fields are separate
+scalar allocations: gather expand inputs and scatter compact results across
+their actual fields, retaining masked tails and rejecting missing bytes or
+incoming-parameter writes. This grants no contiguous native backing or new
+caller-memory permission. Preserve the independent scanner-input regressions
+when intentionally updating the official classification baseline.
+
+Keep mandatory numerical/result obligations separate from cost-only routing.
+A newly modeled family must not bypass its complete source proof because a
+function has no result store, an unused bool parameter, another storage role,
+or an unused FP address. That role needs its own proof, not an exemption.
+Unknown source/result bytes cannot fall back to zero-initialized implementation
+allocas. Test these boundaries through all public APIs, including default and
+explicit architectures; retain independent canonical-bool and memory contracts.
+The complete SETcc family consumes predicate FLAGS for every named destination,
+including dead register writes in Void functions. Only SETCC/SETCS can consume
+a lone CLC/STC producer; that CF fact does not define other predicates. Neither
+an unused bool parameter nor a native-only routing predicate supplies FLAGS.
+
+Private bool tails retain the source architecture when selecting their consumer.
+AMD64 no-CALL tails belong to the existing whole-source direct-tail proof, not
+the 386 custom-register helper graph. Handoff still verifies live source and
+declaration observations; default mode means AMD64. Keep all 16 SETcc predicates,
+canonical result bytes, independent helper frames and actual 386 helper tests.
+Portable i1-to-i32 value execution is not native entry or C bool ABI evidence.
+
+All four floating x87 moves share their existing F/D, load/store, pop and
+register grammar. Paired native 4/8-byte accesses remain unaligned and volatile;
+reads consume an incoming pointer and numerical indexes, while stores retain
+the stricter pointer-base role. Reuse x87 value/depth effects and require source
+bytes even for Void. W/L/Q PUSH reads use their exact stack-width grammar and
+a transfer-local read view; no later backing or standalone-query fact follows.
+Retain original Go objects, three-mode target objects, portable values/canaries
+and exact dead-access faults. Native x87 environment/exception execution stays
+with its required original-source runtime owners.
+
+Complete 386 x87 rounding leaves may save and restore two control words within
+one physical word below unchanged SP. The closed save/copy/change/FRNDINT/restore
+grammar changes only RC bits, preserves the original zero-frame NOSPLIT source,
+and uses the existing native control-word and byte-initialization effects.
+It grants no named AUTO frame, incoming-SP backing or ambient Software control.
+Keep the complete SDK floor source, all 70 register/control/layout cases,
+mutation boundaries and the required native original-Go/LLVM runtime owner.
+
+Mode32 zero-argument manual I8/I16/I32 returns use the existing logical AX
+transport. Share its CFG and exact-byte return obligation with the distinct
+custom-register bool checker; I1 still needs canonical zero/one. Route absent
+and partial AX writes through that proof even without another numerical effect.
+The role has no FP layout, native frame, raw entry or incoming register bytes.
+
+Mode32 private FLAGS copies retain bounded bit dependencies across W/L PUSHF
+and POPF. Shared B/W/L XOR grammar consumes only original bare SP offsets
+within reaching PUSH depth. An adjacent popped register may cancel identical
+unknown dependencies; it cannot expose an unrelated unknown bit. Clone and
+join those dependencies conservatively, charge them to the shared byte budget,
+and revoke the popped view after one instruction. Complete source replay and
+paired lowering own this storage; standalone queries retain their old boundary.
+Keep negative named AUTO separate from the mutable private SP projection in
+both the proof and emitter. Original source objects and portable numerical
+execution remain separate from native FLAGS/ABI conformance.
+
+Indexed permutes and GFNI share the existing typed EVEX/VEX binary grammar;
+unary vector bit counts project their original two/three operands locally.
+Never mutate source operands to reuse a grammar. I2 old-destination indices
+and T2 old-destination tables remain inputs even with zero masking. Complete
+vector reads use actual X/Y/Z byte views, not the older scalar/legacy-X reader.
+Memory widths come from each opcode's full tuple or independent broadcast
+attribute. Shared numerical dependencies grant no native/caller memory role.
+All VEX/EVEX value writers, including unmasked and masked native expansion,
+must use the encoding-aware vector writeback. A generic legacy X store may
+leave nonzero Y/Z aliases stale even when the source-result model correctly
+marks them zero. Seed the complete old vector with nonzero bytes and observe
+inactive aliases independently; zero-input or low-result-only fixtures cannot
+establish this behavior. Keep legacy SSE's upper-preserving writeback separate.
+Keep the actual architecture when projecting unary mask arity or physical
+decoder operands. Go-accepted non-SIB extended GP bases in mode32 retain their
+missing physical context only after the complete remaining grammar validates;
+invalid SIB/index, scale, suffix or mask syntax cannot borrow that boundary.
+
+Native GFNI and indexed permutes retain complete E4NF source-tuple reads even
+when masks or a dead table make the numerical result independent. Packed bit
+counts retain E4 per-lane access suppression. Reuse exact volatile full/guarded
+read helpers, including independent broadcast widths. The paired lowering
+continuation supplies conditional numerical values only; it never grants
+pointer backing, a declaration-query result or a reusable memory certificate.
+Keep all 23 members, complete object axes, missing-input/Void regressions and
+live/dead guard-page checks. Portable Software execution is not native AVX512.
+
+Native compact arrays advance their offset only for enabled lanes. Paired
+source continuation consumes exactly guarded volatile accesses; masked stores
+do not read old destination bytes or establish future read facts. Keep logical
+FP/AUTO scatter/gather separate. EVEX.z memory compression faults before any
+mask/source/address read, rather than behaving like a zeroing register result.
+
+CRC32B/W/L/Q shares the complete Go source grammar across lowering, liveness
+and numerical effects. Every row reads the old accumulator's low32, uses its
+exact source width, zero-extends its result and preserves FLAGS/DF. Go's
+CRC32B Px encoder has different byte-register/REX aliases from MUL's Pb row;
+retain independent original-Go byte witnesses. Native reads must stay exact,
+unaligned and volatile even when their result is discarded. Only the paired
+lowering continuation may consume their conditional numerical result.
+
+Scalar shifts and rotates share the complete Group2, double-shift and BMI2
+grammar with memory effects. Native RMWs retain exact volatile loads and stores,
+including count zero; BMI2 memory sources retain only their exact volatile read.
+Mode32 BMI2 Q spellings still access four bytes. Check every observable count/data
+byte, address and incoming CF before aliased writes; native accesses retain
+their input obligations even for Void. The closed nontrapping register domain
+may propagate dead unknown values, never use them as initialized outputs.
+Continuing a paired native access defines numerical outputs, not pointer,
+pointee, caller, raw-entry or reusable memory facts. Logical FP/AUTO storage
+retains its separate byte-view contracts. W double shifts with unbounded counts
+remain Context because some counts have undefined architectural results.
+Keep the complete independent Go rows, original conformance programs, portable
+full-count/FLAGS/canary execution and the required native Linux original-Go/LLVM
+guard-page/read-only oracle separate. A zero-count original-opcode hardware
+spot check does not qualify the complete LLVM native counterpart.
+
+A proper low-mask AND projection requires both actual caller-address and
+complete pointer must-facts, never an opaque pointer alone. Its B/W/L/Q write
+defines only the written bytes and revokes every address identity. Native-word
+INC/DEC may preserve an already proved affine caller pointer, including only
+the old knowledge of CF; partial or unknown inputs cannot create one. These
+rules add no memory backing, bounds, raw entry or store permission. A numerical
+family may consume an already checked cached mixed-bool canonical role; it
+cannot manufacture that role from initialized bytes or a bool declaration.
+
+Macro expansion uses complete Go assembler identifier tokens, including middle
+dot and division slash, never prefixes or text inside string/character literals.
+Unresolved constants need context for an isolated instruction probe, but must
+fail full translation before raw decoding. Preserve resolved named stack
+addresses; never replace missing constants or malformed addresses with zero.
+
+X86 branch operands use the original Go case-sensitive register namespace before
+shared aliases: lowercase or foreign register-looking labels stay labels, while
+actual Go registers retain their indirect/register semantics. Apply this to the
+complete jump class, including CALL, LOOP, XBEGIN and conditional hints. A local
+CALL label can pass Go's parser and crash its encoder; parser coverage is not
+an accepted object or ordinary rejection. Preserve independent token, object and
+executed-result controls without relaxing target or callee boundaries.
+
+ARM64's fresh virtual SP allocation is disjoint from incoming pointers only
+when the complete original and normalized source excludes escaping its address
+and entry transport cannot replace SP. A source CFG proof may admit exact
+affine GP temporaries used only for bounded, non-writeback local reads and
+fully overwritten before calls or returns. Mixed/different-offset joins keep
+may-frame taint; unknown effects, indexing, address stores and live call/result
+transport cannot wash it away. Under that bounded proof,
+ordinary pointer stores and pure escaped code-address values cannot corrupt
+saved SP cells. Actual source arithmetic/transforms on a code address must
+retain derived-code taint even after unknown CFG joins; filtering ordinary
+data cannot turn a computed native PC into a pure-code alias proof.
+Explicit/aliased/indexed SP writes, FP contents, unknown callouts,
+raw/native effects and frame-address escape remain conservative. Audited
+same-file register helpers retain the original proof across local-call
+rewriting; a bare source-local call never acquires it. Scalar and paired atomic
+stores must account for their memory operand as well as GP outputs.
+
+Raw-containing framed ARM64 source-leaf functions have a separate bounded
+physical-SP proof, checked on both original and normalized CFGs. Constant SP
+movement must balance on every source RET; different-delta joins fail. R29 and
+the automatic saved-FP cell start as unknown may-frame values. Known scalar and
+GP/FP pair memory forms preserve private eight-byte pointer spills and reject
+partial overlap, unknown indexing/writeback and SIMD pointer transport. Only
+the actual Go framed-leaf RET epilogue consumes R29; continuation/LR checks stay
+independent. External stores, live result aliases, calls, hardware RETs and
+unregistered effects cannot borrow this proof. Go's physical autosize is not
+the LLVM private-allocation size. Runtime oracles must execute original raw
+Go objects as well as LLVM objects with independent references and canaries.
+
+ARM64 VMOV/VDUP availability records the validated source lane span separately
+from implementation loads that merely preserve other destination bytes. Lane
+insertion defines only the written bits; F/V aliases and CFG joins retain the
+unknown remainder, and a full vector consumer still needs all of its bits.
+Scalar/arranged non-preserving transfers clear their architectural inactive
+bits. Typed calls and source scratch invalidation revoke prior lane definitions.
+This is numerical definedness, not caller, pointer or private-frame permission.
+VDUP's arranged case79 derives both source width and index bounds from its
+destination; the source suffix identifies only the ELEM class. VMOV and scalar
+VDUP retain their separate suffix-selected bounds.
+Lane syntax shares Go's single decimal-token rule after CPP expansion: trim
+lexical whitespace, reject signs/expressions/nondecimal or unresolved tokens,
+and retain every instruction's independent physical width/index bound.
+
+CPUID/XGETBV share the complete Go `ynone/Pm` rows with implicit low-dword
+inputs and zero-extended GP outputs. Read all inputs before writing any output;
+retain that obligation for Void and unused-bool signatures. Only actual output
+registers lose caller-address identity. Exact original/normalized query identity
+preserves FLAGS, DF and private numerical storage, not a native entry, source
+stack or caller-memory contract. Keep pointer, partial-byte and CFG negatives,
+original bare-source Context controls, initialized all-target objects and the
+required original-Go/LLVM native AMD64 and IA32 execution owners separate.
+Timestamps reuse the identity boundary but retain their own input/output spec.
+
+RDRAND/RDSEED W/L/Q share all six Go `yrdrand` rows with the result observer.
+Their destination is write-only at the exact width: W preserves unknown upper
+bytes and L zero-extends. NUM means machine bits, not successful entropy or a
+vendor-independent CF=0 value. Only CF reports availability; the other five
+status flags clear. Exact original/raw identity preserves unrelated registers,
+DF/ID and private storage. Physical SP/BP and missing ABI results remain separate
+obligations, even for Void. Retain full encoder attributes, all register codes,
+partial-byte negatives and original format objects; object compilation does not
+qualify native random execution.
+
+ENQCMD/ENQCMDS share exact named/raw operand and address-size grammar. Both
+GP address operands are read-only; an actual native continuation defines ZF
+retry and clears the other five status flags. Preserve the native side-effecting
+64-byte command read, memory clobber and fault/privilege behavior, not memcpy.
+Only independently established incoming addresses supply the public native
+continuation. Raw identity, original mode, initialized inputs and complete ABI
+results remain mandatory, including Void. No submission success, PASID, CPL,
+alignment, backing or later pointee-read fact follows. Check all ModRM/SIB,
+address16 and displacement boundaries before IR. Original unbound/segment/
+address-override formats keep Go/emitter objects and public Context; independent
+initialized programs own public objects. Neither objects nor status simulation
+qualifies native device execution.
+
+UMWAIT/TPAUSE share their existing implicit-system grammar with mandatory
+low-dword control and EDX:EAX inputs. Their native continuation defines CF and
+clears the other five status flags without changing GP, DF or private storage.
+Raw source retains exact original/normalized opcode and operands; it cannot
+borrow address-size, segment, raw-return or monitor-address roles. Input proofs
+remain mandatory for Void, unused bool and every CFG path. Original unbound
+formats retain Go/public-Context/emitter coverage; separate initialized status
+programs own public objects, not a native-execution claim. The other system/RTM
+and hardware-status families retain their independent effect obligations.
+
+RTM's four-name grammar is shared by lowering and XTEST's numerical effect.
+Only the exact zero-operand query defines all six status flags without numerical
+inputs and preserves unrelated GP, DF and private storage. The same identity
+checks apply to decoded raw source; no entry, frame or memory role follows.
+Do not grant transaction begin/end/abort an ordinary straight-line effect.
+XABORT requires a resolved integer in 0..255, not a floating token with an
+integer zero field. Retain dispatch identity and complete byte-domain objects;
+compiling the native RTM opcode is not hardware execution qualification.
+
+The eight mask/vector B/W/D/Q moves share a register-only EVEX grammar with
+X/Y/Z widths and K0-K7 data operands, never writemasking or suffixes. Caller
+and numerical effects require actual mask data or each vector lane's sign
+byte; unrelated lower bytes do not contribute to a reverse result. Forward
+writes clear every wider alias, while reverse writes zero-extend the mask
+remainder. Missing inputs remain obligations for Void and unused-bool entries;
+internal implementation zeros supply neither data nor a named/physical entry
+contract. Use the
+encoding-aware packed writeback even for X destinations: legacy `storeX`
+preserves wider bytes. Independent whole-byte runtime checks must observe both
+directions separately rather than relying only on a round trip.
+
+KMOVB/W/D/Q is a separate grammar. B/W/D-to-GP defines the complete zero-extended
+native word; its FP/native memory effect still uses only the named byte width.
+Logical FP reads gather exact fields, and narrow stores retain untouched bytes.
+KADD, KSHIFT and KUNPCK share two complete typed operand shapes, not numerical
+operations. Every source mask remains required, even for Void and oversized
+shifts; floating/unresolved immediates never become Yu8. A checked normalized
+caller continuation must consume its exact original source/signature/stack
+owner, not impersonate a logical FP proof. Paired native KMOV and all sixteen
+SETcc byte stores retain exact unaligned volatile effects and known inputs or
+FLAGS. They supply no reusable memory, pointee, raw-entry or caller permission.
+Format-only sources keep original Go objects and explicit Context controls;
+separate initialized counterparts own executable and public LLVM coverage.
+
+KAND/KANDN/KOR/KXNOR/KXOR/KNOT/KTEST/KORTEST share the complete B/W/D/Q
+K-register grammar. KNOT never reads its write-only destination; only equal-source
+XOR/XNOR/ANDN is input-independent. TEST variants define all six status flags,
+not DF/ID. Exact original/normalized raw identity may preserve existing GP,
+direction and private-stack facts; it grants no memory, entry or frame role.
+Void and unused-bool signatures retain input obligations. Preserve independent
+Go encoder attributes, named/raw portable values and original unbound formats.
+
+PSADBW/VPSADBW/MPSADBW/VMPSADBW/VDBPSADBW share ordered byte selectors
+across lowering, caller and result analysis. Only corresponding-byte block SAD
+with identical register sources is input-independent; sliding/shuffled forms
+are not. Memory still consumes the complete native tuple, even with zero masks
+or dead outputs, and legacy m128 keeps its original opcode/fault behavior.
+VEX VPSADBW/VMPSADBW and EVEX VPSADBW ignore W; VDBPSADBW requires W0.
+Test physical WIG independently: Go's encoder emits only W0 for these forms.
+
+The eight SQRT names share the floating operand grammar and one caller/result
+byte dependency. Only the first operand supplies numerical input; scalar
+VEX/EVEX copies its second operand's upper X bytes without requiring unused
+low bytes or inventing unknown passthrough bytes. Masks and merging inputs stay
+required even for Void. Retain actual side-effecting native opcodes: default
+MXCSR, dead exceptions, memory faults and explicit ER+SAE are not pure sqrt IR.
+Packed memory requires native backing; logical field addresses authorize only
+exact bounded scalar reads. Caller bounds alone do not establish legacy m128
+alignment. Physical VEX.WIG, scalar EVEX.LIG and low-bank mode32 masks need
+independent LLVM-MC witnesses; scalar VEX.L1 stays rejected as unpredictable.
+Preserve raw EVEX generation through feature inference and native emission.
+Complete initialized named/raw three-API objects on all five x86 targets are
+separate from original unbound Go/emitter formats and native execution. The
+required Linux scalar runtime checks rounding, passthrough, masking and MXCSR;
+the existing native-wide conformance retains packed SQRT. FP16 remains a
+distinct raw-only family, with no inherited caller or entry permission.
+
+The four packed multiply-add names share the existing complete binary grammar
+with mandatory numerical inputs, result definedness and paired native reads.
+MMX keeps its separate closed physical-state owner. Every first/second input,
+mask and merging destination stays required even for Void or an unused bool.
+Zero masking removes only the merge dependency; it supplies no data/address
+permission. Reuse encoding-aware writeback and preserve unrelated GP, FLAGS,
+DF, masks and storage facts. Keep original unbound sources as actual-Go and
+public-Context format controls alongside complete initialized public objects;
+raw objects, caller proofs and native execution remain independent claims.
+
+The eight immediate shuffles share their integer-only source grammar and exact
+byte selectors with lowering, caller definedness and memory shapes. Bind the
+complete legacy and VEX/EVEX rows independently, including signed MMX Yi8,
+unsigned legacy X Yu8, mode32 int32 source classification and raw imm8 signed
+rendering. Float/unresolved operands fail before every consumer. Legacy X
+writes preserve upper aliases; VEX/EVEX clears them. E4NF reads retain the full
+tuple even with dead results or zero masks; dword broadcast reads m32.
+Legacy m128 retains the original observable SSE2 memory opcode, not an align-1
+replacement. Virtual FP/SP/BP and unbound address-size roles remain Context,
+as does caller alignment without a real witness. Execute independent original
+Go opcode bytes and LLVM live/dead boundary controls. Label IR-prepass axes
+separately from backend optimization; MMX objects and Rosetta diagnostics do
+not certify physical x87/MMX state or native AVX512 execution.
+Go 1.20's maskless `.Z` acceptance is a historical encoder defect, not another
+legal format. Observe its exact reserved EVEX.z/aaa=0 bytes and still require
+both named and raw rejection through all APIs; current Go must reject source.
+
+PSHUFB/VPSHUFB use the shared binary grammar without MMX, broadcast or SAE.
+Dynamic control bytes depend on every potentially selected byte in their own
+128-bit data lane; sparse caller/result knowledge must retain that dependency.
+Legacy memory keeps the original m128 opcode and alignment, while vector E4NF
+reads retain the complete tuple even with zero masks or dead outputs. VEX/EVEX
+clears wider aliases and both raw encodings are WIG; Go's W0 emission and named
+386 operand cap do not restrict a validated physical encoding. Feature inference
+must recognize isolated `.Z`, not borrow SSSE3 from a sibling function. Keep the
+bounded raw-literal proof separate from ordinary native reads. See Intel's
+[PSHUFB instruction reference](https://cdrdv2-public.intel.com/789581/325383-sdm-vol-2abcd.pdf)
+and [E4NF exception tables](https://cdrdv2-public.intel.com/858446/253666-088-sdm-vol-2a.pdf).
+
+The main instruction dispatcher and legacy vector entry must both delegate to
+that same complete byte-shuffle lowerer, including handled errors before IR.
+Keep direct-dispatch tests as well as public API tests when extracting a family;
+an old helper entry cannot silently fall through after its switch body moves.
+
+The private x86 raw decoder hands off actual physical memory operands without
+reinterpreting formatter DS/ES/FS/GS or RIP spellings as public Go source
+register groups. Only actual `PrefixIgnored` metadata permits removing a
+printed segment prefix; an unused, nonignored physical prefix remains Context
+before IR. Environment-load aliases additionally bind the complete decoded
+encoding and 32-bit layout. Sixteen-bit environments remain unsupported.
+Environment and packed-BCD consumers preserve the pointer's address space
+through every load, store and GEP. These conversions confer no new caller,
+native-memory, extent, raw-return or source-syntax permissions.
+
+Raw x86 NOP's ModRM/SIB, segment and PC-relative fields encode length, not a
+memory access. Validate the complete instruction and prefixes before consuming
+it as an operand-free NOP, retaining its original length for CFG boundaries.
+The pinned decoder's missing REX.W 0F 1F /0 row has a narrowly scoped width
+adapter; it cannot rewrite another opcode, reserved extension or invalid
+prefix. Keep real-memory handoff failures and XCHG/PAUSE effects unchanged.
+Go NOPW/NOPL rows, original literal bytes, five-target objects and portable LLVM
+state tests are distinct from required native Linux AMD64/386 execution.
+Rosetta rejects some valid register NOPs and cannot certify that native axis.
+The lowering-only result observer may compose this sealed operand-free NOP
+handoff with independently paired named native reads. Check both original and
+normalized NOP identity; another raw opcode, native TEXT, return, address-size,
+source-stack or fixed-local role keeps its original boundary. Inert padding
+does not grant caller memory or a standalone declaration-query permission.
+Current-Go PCALIGN source is a separate producer fixture; the complete literal
+NOP/read matrix still runs on the historical SDK, which lacks that directive.
+
+ENDBR32/64 preserve numerical registers, FLAGS, DF/ID and private storage,
+but update CET tracking. Keep their actual side-effecting native instructions,
+never replace them with NOPs. Share only source-state preservation, requiring
+exact raw origin/opcode/operand identity; ENDBR32 remains raw-only. This creates
+no memory, missing-input, ABI frame or raw-return permission. Retain complete
+current-Go encoder rows, both physical encodings, five-target public objects,
+private-stack checks and the original native GP/FLAGS runtime owner.
+See Intel's [CET specification](https://cdrdv2-public.intel.com/874239/252046-082-sdm-change-document.pdf).
+
+Scalar ADD/SUB/ADC/SBB native memory-to-register reads reuse the existing
+complete B/W/L/Q grammar for widths, carry and physical REX byte aliases. The
+paired lowerer must retain an exact volatile load even for dead data/FLAGS;
+the lowering-only result consumer additionally requires the old destination
+bytes and ADC/SBB's incoming CF. Continued execution does not prove pointer
+validity, extent or alignment. Native writes, unknown or numerical addresses,
+pointer-as-data, physical SP/BP aliases, raw entries and standalone declaration
+queries keep their separate contracts. Execute live/dead, carry/borrow, width,
+status, alias and guard-page controls against actual original Go bytes; portable
+objects and Rosetta execution do not replace the required native Linux owner.
+
+Static scalar RMWs share that numerical grammar but require the actual
+same-module DATA directory, complete access extent and writable destination.
+Readonly address targets are not mutable sinks. Non-shared 386 TYPE_ADDR
+arithmetic consumes a bound relocation value, not a pointee load or pointer
+permission. Missing symbols, CF, result bytes and readonly/short sinks remain
+Context. Keep original unbound formats separate from initialized DATA objects.
+
+Named FS/GS scalar and bit-string RMWs share Go's existing segment normalization.
+The segment supplies its hardware base; each explicit GP offset needs complete
+numerical bytes. Ordinary addresses retain their incoming-pointer rule.
+Exact volatile accesses or the native LOCK opcode remain observable, including
+dead results; continuation creates no memory, TLS or future-read facts.
+Standalone observers cannot borrow this paired rule. Retain all family widths,
+bare/indexed Go bytes, five-target native objects and missing-input controls;
+object compilation does not qualify native segment execution.
+
+The scalar native MOV-store family checks its complete inputs even for Void
+or unused-bool signatures. A separate lowering-only bit-copy scope permits a
+whole native word of actual typed entry-derived address bits in an ordinary
+zero-frame leaf without calls, raw entry or another storage owner. It grants
+no NUM bytes, pointee validity, bounds, GC root, escape-safety or pointer result.
+String cursor updates retain only their existing weaker address-bit facts;
+they revoke the reusable native-read pointer. Keep the complete original
+cursor-comparison sources plus independent positive zero-count and negative
+updated-cursor native read/store controls. The standalone store observer cannot
+borrow this source scope or manufacture it from a pointer type alone.
+
+An x86 raw-return caller-region producer is a separate, bounded source proof,
+not a pointer-type or `noescape` nonalias promise. It requires the same actual
+selected Go/ASM inventory, typed syntax, actual numerical/pointer sizes and
+source bytes, closes every use of
+an unexported bodyless ABI0 entry, and accepts only direct slice-data inputs
+and independent numerical result/length locals. Missing sources, indirect or
+assembly callers, linknames and local-address escape remain Context. A region
+witness alone never admits raw RET: the complete source stack/CFG/effect proof
+must separately consume the exact slots and write envelope. Compiler loaders
+must supply the actual complete selection; an AST subset or self-reported hash
+is not authenticated package-selection evidence.
+
+The bounded AMD64 caller-region consumer covers scalar MOVB/W/L/Q and the
+Go-table MOVSS/SD, VMOVSS/SD and KMOVB/W/D/Q move forms. It tracks exact
+full-word pointer imports/copies, constant affine offsets and numerically
+initialized GP/SIMD bytes. Mask values must be source-defined, not pointer bits;
+legacy lane preservation and VEX/EVEX merge/zero rules remain distinct.
+Floating literals follow the actual Go frontend rewrite: original positive
+zero in X0-X15 becomes legacy XORPS, preserving wider aliases; negative zero,
+float32 rounding/underflow and high-register constants follow their pool-memory
+encoding. Integer/unresolved literals and invalid mask/merge forms remain
+rejected. Legacy scalar ADDSS/ADDSD/SUBSS/SUBSD and MULSS/MULSD/DIVSS/DIVSD
+use their own finite FLOAT constant-pool rewrite, including both signs of zero;
+they do not inherit MOV's positive-zero XORPS rewrite. Their FLOAT leaf may
+have unary signs and parentheses, but not integer or binary-expression source
+syntax. The destination's low scalar bytes must already be numerically defined.
+Raw FP16, packed moves and arithmetic need separate complete effect
+families and do not inherit this permission.
+Inputs and local lengths are read-only;
+only the independently fresh scalar result has a bounded write envelope.
+Instruction-local memory certificates bind the entire operands, direction and
+native width. Every source return must still restore SP/BP, and unknown joins,
+private-stack escape, g-register use, unregistered vector/native effects and stale source or
+signature metadata remain Context. Rosetta fixture execution is diagnostic,
+not evidence that an external AVX/AVX512 library ran on native AMD64 hardware.
+
+The existing <=3, zero-based +1 residue-loop rule composes only across separately
+proved reducible SCCs: one entry, one exact adjacent comparison/latch, no early
+exit, and a DAG after removing that latch's backedge. Each feasible path retains
+its own complete source origins, initialized bytes and numerical versions across
+SCCs. The original shared finite replay budget and independent final replay stay
+unchanged; this does not prove dynamic affine, sentinel or nested loops and never
+uses an acyclic hull join to manufacture a cyclic invariant or allocation bounds.
+MOVQ's named MOVD/MOVDQ2Q aliases retain those same numerical origins,
+versions and complete zero-based partitions through local source-only dispatch.
+Raw physical opcodes never inherit that alias registration. Fixed-local scalar
+constant/boolean knowledge, memory-width observations and carry initialization
+likewise retain MOVQ's exact width without rewriting original source identity.
+The required Linux AMD64 source-alias counted-provenance runtime compares
+original Go and independent LLVM O0/O2 values, immutable lengths and full
+input/output canaries; no new loop, g or native-entry class is admitted.
+
+A scalar GP MOV to static storage needs actual module-owned writable DATA/GLOBL
+extent and every selected input byte. This is mandatory even for an isolated
+Void function; an unrelated result instruction must not accidentally supply
+the input check. Floating, pointer, physical SP/BP and unresolved external
+inputs cannot become numerical store bytes. Reuse the native-width volatile
+emitter and Go's real immediate encoding normalization, including signed imm32
+extension for wide MOV aliases; do not grant storage from an address alone.
+
+Signed packed dword-to-float conversion uses one validated whole native
+CVTDQ2PS/PD opcode, retaining ambient MXCSR rounding, precision, trapping,
+masking and embedded rounding. The same native emitter serves the complete
+38-name FP32/FP64-to-signed/unsigned I32/I64 and remaining integer-to-float
+family. Shared typed shapes distinguish physical vector width, active lane
+count, memory tuple and architectural zero padding. Named, raw, result and
+caller effects consume that grammar; narrowing broadcast counts active lanes,
+not destination carrier lanes. VEX.WIG remains ignored in both x86 modes.
+Pure `fptosi`/rounding IR is not equivalent: it loses MXCSR exceptions and
+out-of-range inputs become poison. Keep each whole conversion `sideeffect`
+even when its numerical result is dead. Its caller effects require every potential
+input byte and merge byte; masks do not authorize a missing memory envelope.
+Packed FP fields and virtual SP/BP lack original native backing and remain
+Context without a separate source-bound storage proof. Mode32 high banks
+likewise cannot borrow a software register view.
+Go's MMX-to-X forms (including GP spellings admitted to Ymm) and X-to-MMX
+destinations remain Context:
+no current producer closes physical MMX identity, x87 Tag/TOS, pending
+exceptions and observations by the caller after RET. They are Go-object and
+format coverage, not successful LLVM objects. The native Linux AMD64 fault
+oracle is a required cross-runtime root; SSE numerical Rosetta observations
+and five-target AVX512 object compilation do not replace it or AVX512 execution.
+Keep independent complete Go table/attribute witnesses and byte-exact raw
+parity. Runtime axes include clean and preset status, NaN/overflow, RC,
+DAZ/FTZ, masks, alias canaries, integer FLAGS, dead memory and unmasked native
+traps. Partition full-family objects and executable fixtures into disjoint
+batches of at most 96 functions; check the union and release each LLVM module
+and context before the next batch. Each batch owns its temporary artifacts
+through a synchronous subtest. Primary references are
+[Intel SDM Vol. 2A](https://cdrdv2-public.intel.com/812383/253666-sdm-vol-2a.pdf)
+(conversion instruction pages and exception classes) and the
+[LLVM 22 LangRef](https://releases.llvm.org/22.1.0/docs/LangRef.html)
+(`fptosi` poison and inline-assembly constraints), not software-value parity alone.
+
+Scalar FP-to-GP conversions likewise retain their complete typed native opcode
+and MXCSR effect. A paired native-read consumer must check all preceding inputs,
+even if the scalar result is dead. Raw continuations bind complete immutable
+producer replay, encoded operands, architecture and physical EVEX generation
+before any strict fast path. The transfer writes only the real GP destination;
+it cannot erase unrelated DF/ID, private storage or caller-address identities.
+Private format objects and initialized public companions are separate evidence
+from the unchanged original native programs.
+
+The AMD64 fixed-local observer consumes those same two typed conversion
+grammars for all 42 names, not another mnemonic list. Its complete original
+Go frame binding may supply only initialized private memory: retain the exact
+source tuple, legacy m128 alignment, active merge bytes, narrowing zero padding
+and legacy versus VEX/EVEX wider aliases. A zero mask cannot excuse missing
+storage. Unbound FP/SP/BP, physical MMX, caller pointers and source escapes keep
+their existing failures; this adds neither a loop nor a floating ABI contract.
+The actual-object boundary observer separately measures complete VEX/EVEX
+conversion encodings, including physical RIP operands. It discards operands
+and supplies no raw-source or scalar-read permission. Keep default raw RIP
+rejection, every truncation and reserved-field controls. Native Linux execution
+owns the full conversion family; original-Go/LLVM SSE value, MXCSR and private
+canary comparisons on Rosetta remain explicitly narrower evidence.
+
+All eight scalar COMI/UCOMI names share Go's twelve complete encoder rows,
+read-only scalar input widths and native MXCSR/FLAGS effects. A pure LLVM
+relation loses signaling-NaN distinctions and dead exceptions. Preserve the
+actual EVEX generation, including low-register raw encodings, and register-only
+SAE; no masks, broadcast or vector writes follow. Source-accepted mode32 high
+registers lack a physical binding and remain Context. A matching explicit x86
+target is required, even for dead source. SSE original-Go/state/guard-page
+oracles do not stand in for required Linux AMD64 native VEX/EVEX, wide-register
+preservation and unmasked IE/DE/SAE execution. Object and runtime reports retain
+those different scopes; typed byte effects grant no new memory ownership.
+The paired COMI/UCOMI native read uses the same exact scalar width and existing
+incoming-pointer identity as lowering. Its continuation defines only status
+FLAGS, never DF/ID, vector writes, memory backing or future read facts. Keep
+declaration-only observers strict and retain both initialized public objects
+and original uninitialized-format Context/emitter checks. Returning all FLAGS
+requires independent DF/ID inputs; a six-status projection cannot create them.
+VEX WIG and EVEX LLIG do not imply portable VEX.L=1 behavior: Intel's SDM
+warns of generation-dependent behavior for that encoding. Keep literal L1
+Context rather than silently emitting L0. Validate all operand/file syntax
+before returning a deferred physical-mode or memory-role Context.
+
+COMI input proof is mandatory for isolated Void instructions as well. The
+four vector names' twelve raw RIP forms use only the existing decoder-owned
+literal consumer: exact decoded relocation, complete DATA extent/payload,
+immutable whole-function replay and original raw RET binding. They still need
+every scalar register byte. Ordinary raw native-pointer reads, legacy forms,
+mode32 literals and SAE memory do not inherit this literal role.
+
+The CLI captures a private inventory at its actual package-load boundary and
+rechecks complete compiled Go sources with that load's dependency types and
+target sizes only for raw-return candidates. All selected assembly and CPP
+inputs are included, with source/expansion checks through the final object.
+Effective overlays, generated/cgo mappings and external package drivers require
+their actual compiled-source mapping; original files cannot impersonate them.
+This private load snapshot cannot be restored from JSON or supplied by an old
+standalone `compileOne` caller. Candidate detection is only a cost predicate.
+
+ARM32's specialized raw-data lowerers and NZCV source proof share one typed
+registration. Only those decoded data forms preserve source-defined APSR
+flags; conditional forms still require their predicate on every CFG path.
+Their GP outputs conservatively kill source-value witnesses, including memory
+writeback. Unknown WORDs, calls and unproved FPSCR-to-APSR transfers do not
+retain flags. Check every registered family and condition against LLVM-MC,
+Go objects and the required ARM Go-WORD/LLVM four-flag execution oracle.
+
+For a newly discovered instruction, update all four layers before calling it
+complete: the family-specific lowerer, positive/negative Go-table form tests,
+LLVM 22 object compilation for every affected supported architecture, and the
+architecture's supported-op extraction test in `cmd/plan9asmll/main_test.go`.
+The external corpus uses that extraction result in its diagnostics, so omitting
+the last layer can make a supported instruction look unsupported.
+
+ARM64 named system registers share the raw encoding grammar. Regenerate their
+encoding/access metadata with current Go using `go generate arm64_sysregs.go`;
+do not edit `arm64_sysregs_generated.go` manually. The completeness regression
+compares the full current Go table and checks every readable register against
+LLVM 22. Use physical system-register names to avoid feature-gated LLVM aliases,
+never fabricated constants for CPU-ID reads. Keep text/direct-module/CFG/raw
+paths observable and require the Linux MRS runtime oracle: only the kernel's
+HWCAP_CPUID-advertised ID-register space is safe for unprivileged execution.
+
+The seven ARM64 scalar GP memory moves share `parseARM64ScalarMemoryForm`:
+signed/unsigned widths, direct/indexed addressing, pre/post writeback, AUTO/FP
+and SB roles. Go's long-offset expansion reads the old effective address,
+materializes R27, then reads the possibly aliased transfer register. Lowering,
+caller-link/code provenance, private-frame bounds, availability and raw-PC width
+must consume that same ordered model. Only actual WORD decoding supplies a
+physical-instruction identity. AUTO/FP classes require the complete source TEXT;
+LLVM shadow slots are not native SP or linked-page identity. Differing old/new
+Go encoders require source context when their scratch value is observed, never
+a guess from the translator's build version. Preserve the independent Go-table,
+byte/state, initialized numerical/canary and complete target-object tests in
+`arm64_scalar_memory_*_test.go`.
+
+Isolated ARM64 coverage probes parse their own explicit zero-frame NOFRAME
+TEXT fixture and retain a real faulting exit. This validates concrete AUTO
+forms without borrowing the original function's frame or encoder identity.
+Foreign TEXT, unbound FP, unresolved offsets and unsafe continuations remain
+rejected; a compile-only probe is never executable semantic coverage.
+
+Compiler/executable/emulator subprocesses in native root oracles should use
+`runtimeOracleCombinedOutput` with their actual `CommandContext` and deadline.
+The helper retains output and failures, bounds pipe waits and cleans its owned
+Unix process group after cancellation or ordinary parent exit. Non-Unix owns
+only the direct child. Extend the lifecycle AST regression when adding a new
+consumer; do not introduce another direct `CombinedOutput` call that bypasses
+the helper. The reusable LLVM compile, C link and executable-run stages each
+receive a fresh five-minute budget, limited by the existing test deadline minus
+three seconds for cleanup; this is not a five-minute whole-suite budget. An
+exhausted budget fails without launching another command. Release LLVM modules
+before their contexts and before each fixture's temporary files are removed.
+Generated C oracles must keep case IDs in diagnostics, never in process exit
+codes: Unix truncates 256 to success. Use fixed nonzero failure status and
+wrong-result mutation tests. Bound large fixture batches, check their complete
+disjoint union, and prevent optimization from recreating one giant C function.
+
+A typical x86 investigation starts with the Go 1.27 tables and an assembler
+probe:
+
+```sh
+goroot=$(go env GOROOT)
+rg -n 'A?VADDPS|yvaddps' "$goroot/src/cmd/internal/obj/x86"
+sed -n '<start>,<end>p' "$goroot/src/cmd/internal/obj/x86/avx_optabs.go"
+GOOS=linux GOARCH=amd64 go tool asm -o _out/form.o _out/form_amd64.s
+GOOS=linux GOARCH=386 go tool asm -o _out/form.o _out/form_386.s
+```
+
+Record the initial failure in test output before adding the lowering. Focused
+form tests normally belong in `amd64_ecosystem_test.go`,
+`amd64_operand_forms_test.go`, or the corresponding ARM file. Add the opcode to
+`TestExtractSupportedOpsFindsCompleteAddedInstructionFamilies` so external
+corpus diagnostics recognize it. Semantic fixtures live under
+`testdata/conformance/<arch>` and must be checked against both native Go and the
+LLVM runtime oracle where supported.
+
+Raw x86 far/interrupt returns must select the existing `IRETW/L/Q` and
+`RETFW/L/Q` grammar from the decoder's actual mode and operand size. A bare
+`CB` remains a 32-bit far return even in amd64 mode; widthless `LRET` is not
+a source-level Go opcode or evidence for a 64-bit return. Preserve encoded
+imm16 operands, reject unregistered prefixes, and compare original Go and
+LLVM object bytes for all five supported x86 targets. Those object checks
+do not prove a privileged kernel's far-return stack or runtime behavior.
+
+Named x86 addresses retain the pseudo-base role separately from subsequent
+physical register groups: `slot(FP)(SI*1)` supplies an index, while
+`slot(FP)(SI)` supplies Reg, which Go rejects on amd64 and ignores on 386.
+Scale spellings are Go's single decimal tokens 1/2/4/8, not arbitrary constant
+expressions. A parsed indexed FP/AUTO operand does not establish a contiguous
+frame, dynamic bounds, or address provenance and remains Context without those
+contracts. Ordinary amd64 SB memory cannot combine RIP with a base/index.
+For 386 SB memory/LEA, Reg is ignored but Index is used; a non-shared relocated
+SB address immediate ignores both. Keep these effects and the decoder's
+physical SP operands distinct. Alternate pseudo-role overwrite forms remain
+explicit Context rather than being misclassified as Go-rejected syntax.
+The complete Go x86 register-name inventory is checked before discarding
+unused 386 SB annotations; this never grants a segment/SIMD register input.
+TLS memory progedit and segment Index operands remain Context without their
+native address/source-encoder contracts. In particular TYPE_ADDR segment Index
+prefixes differ in the actual Go 1.20 and 1.27 encoders; no build-version guess
+selects their meaning.
+`CaptureGoX86TLSMoveSource` independently assembles the complete original and
+expanded source with its actual Go tool, OS, architecture and shared flag.
+It binds every TEXT body, ordered relocation, frame/argument header and original
+source position. `BindTLSMoves` consumes only observed zero-width NOP rewrites
+of MOVL/MOVQ and its MOVD/MOVDQ2Q source aliases' TLS-to-GP rows, including
+Go's complete pre-encoding AX..R15 range on 386. Such a NOP preserves both
+initialized and unknown destination bytes; the complete existing source/result
+proof still runs before lowering.
+The source observer supplies no package selection, signature, native frame,
+thread, TLS address or g identity. ELF LE/IE relocations, Windows/Android runtime
+offsets, Plan 9 private storage and actual TLS memory remain Context without
+their native entry/thread/storage producer. Keep live before/after source,
+object, target and callback guards, and the required native Linux AMD64
+`TestCrossLinuxRuntimeMatrixX86TLSNoopPreservesWideGP` execution counterpart.
+Grouped SB CALL/JMP/RET operands have Go's TYPE_BRANCH role, not a native
+indexed read; they remain Context without a bound branch/entry contract.
+
+Unnamed x86 source register groups preserve a missing second-group scale as
+zero. This is distinct from an explicit invalid multiplier token. MOVL/Q
+address sources become LEAL/Q in Go's progedit before operand classification;
+those derived LEAs and ordinary physical memory must reject unencodable SIB
+indexes/scales. Audited TYPE_CONST rows instead ignore Reg/Index annotations.
+Do not apply the ordinary SIB guard to named, segment/TLS, branch or decoded
+physical roles, or let source normalization repair an original CFG certificate.
+Unnamed address-immediate register groups retain the source `g` spelling until
+the actual source mode is known. Go registers this alias only for amd64; 386
+still accepts explicit `R14` annotations that its TYPE_CONST rows ignore.
+Qualifying the alias grants neither a register input nor a native address.
+For a stack-unobserving raw near-RET leaf, MOVL/Q's numerical LEA adapter
+rechecks both complete source views and their return/memory constraints. It
+cannot inherit stack, caller, fixed-local, raw-text or another instruction's
+decoder certificates. TYPE_CONST arithmetic is a separate rule and remains
+Context in that protected domain. Neither adapter grants pointer provenance.
+
+The main implementation entry points are:
+
+- x86/386/amd64: `amd64_blocks.go`, `amd64_needed.go`, `amd64_translate.go`,
+  then the family-specific `amd64_lower_*.go` file;
+- ARM: `arm_blocks.go`, `arm_needed.go`, `arm_translate_cfg.go`, then
+  `arm_lower_*.go` and frame/register handling in `arm_eval.go`;
+- ARM64: `arm64_translate.go`, `arm64_eval.go`, and `arm64_lower_*.go`;
+- wasm: opcode families in `wasm_ops.go`, lowering in `wasm_translate.go`, and
+  intrinsic declarations in `translate_prelude.go`;
+- command-side package signature, ABI, include, and target handling:
+  `cmd/plan9asmll/main.go` with tests in its nested module.
+
+Supported-opcode reporting scans opcode-keyed package maps as well as explicit
+switches. Every newly introduced opcode map must have an architecture-specific
+extraction regression in `cmd/plan9asmll/main_test.go`; otherwise a real
+translator failure can be misreported as an unknown instruction.
+
+For x86 form tests, cover at least these targets:
+
+- `darwin/amd64` — `x86_64-apple-darwin`
+- `linux/amd64` — `x86_64-unknown-linux-gnu`
+- `windows/amd64` — `x86_64-pc-windows-msvc`
+- `linux/386` — `i386-unknown-linux-gnu`
+- `windows/386` — `i686-pc-windows-msvc`
+
+Do not add an `unsupported_forms` skip for a supported target. Context-dependent
+forms may be classified separately only when translation genuinely requires
+information unavailable to the scanner.
+
+For named ARM64 private data tables, the explicit typed-call transport and
+fresh-frame proof may authorize bounded indexed accesses and counted-loop
+writeback. Track numeric bounds separately from may-frame provenance: joins,
+stale comparisons, unknown transforms and hardware-masked shift counts must
+never restore an erased address or narrow an unknown index incorrectly.
+Certify each store's complete byte envelope within private DATA `[8, frame+8)`;
+the saved caller link at SP+0 and overlapping cells remain protected. This is
+an instruction-local certificate, not a function-wide unknown-store exemption.
+Reject address escape through calls, results, FP, memory or vector banks, raw
+effects, mixed origins and exhausted proof budgets. Exercise the shared scalar
+and GP/FP pair grammar with Go-accepted widths, signed loads, zero aliases,
+indexed and offset/pre/post forms, LLVM objects and initialized runtime
+canaries. An old fixture with undefined data establishes only its explicit
+object contract; never report it as successful runtime coverage.
+
+For ARM64 GP data-processing proof, use the lowerer's typed operand grammar:
+explicit Rd is a full overwrite, but two-operand arithmetic/shift forms and
+BFI/BFXIL read it. W results clear the upper GP half; extracts and extensions
+still consume their actual source. Unknown, aliased or joined frame inputs
+cannot be washed away. Preserve transformed code-address taint and require
+independent exact LR/SP/BP/g/OS-register restoration, even for typed void
+returns. Go optab rows do not automatically establish frontend spellings:
+single-operand NEG is rejected by stock Go, and a cross-bank W bitfield
+accepted by its alias encoder is not an overwrite proof.
+
+Scalar GP moves likewise distinguish their source from the write-only Rd.
+Narrow register copies retain derived code-address bits; resolved MOVW/MOVD
+literals and the seven literal-zero aliases do not read old Rd. MOVK remains
+read-modify-write. Go's inherited nonzero MOVWU literal rows can emit zero
+machine words; stock syntax acceptance alone grants no overwrite witness.
+
+For ARM64 immediate arithmetic, logical and compare forms, follow the complete
+Go constant classes (including MBCON), register classes and reserved row size.
+R27 may be written before an aliased source is read; direct/split forms need
+not write it. Raw decoded instructions must not acquire source-pseudo effects.
+Go-accepted fixed-width expansion can contain a reachable UDF, and different
+Go encoders can produce non-equivalent fallthrough. Preserve exact byte/fault
+oracles and require source-encoder Context when that identity is unavailable.
+
+The bounded raw zero-frame proof may also produce the local-control plan,
+but only after every original and exact normalized source context passes.
+Different helper invocations retain separate incoming/private pointer states;
+their return labels are combined only after exact SP/LR/fixed-register and
+escape checks. No partial certificate survives a failed component, unknown
+effect or exhausted bound. Ordinary/native/unproved functions keep the coarse
+control analysis. Runtime fixtures must execute both helper pointer contexts,
+not just compile a synthetic return dispatcher.
+
+An authenticated current-PC raw BL in a single-instruction block is a terminal
+sink: LLVM still writes its continuation to LR and branches to itself. The
+source proof checks all preceding effects, joins and other returns, and emits
+no return certificate for the sink. Ordinary recursion, multi-instruction
+helpers and actual dead source retain the existing bounds and guards; only an
+empty block-splitter continuation after a final self BL has no source to check.
+Floating immediates never acquire an integer GP MOV overwrite witness, including
+through the legacy MOVD transfer fallback.
+The seven scalar GP MOV lowerers also reject Go's distinct floating-constant
+class before register, memory, symbol or writeback dispatch; FMOV is unchanged.
+
+An ARM64 ABI0 native-width read may overlap the alignment gap after the final
+direct narrow integer parameter only with a complete actual typed declaration
+and independent original/normalized whole-source bit-use proofs. Every use of
+the unspecified bits must remain unobservable across GP and SIMD aliases, CFG
+joins, comparisons, addresses, stores and results. The bounded first contract
+is call-free and rejects unknown effects. A proved read may choose an explicit
+representative for those dead bits; it does not assert that native padding was
+initialized, create a padding slot, or authorize any address or write. Preserve
+the source MOV width, encoder scratch effects and PC identity. Manual sparse
+frames and changed type layouts retain their original missing-slot failure.
+
+A native-width store beyond a narrow declared result is different: its tail
+bytes are observable by an assembly caller after RET. A callee declaration,
+call-free body, or typed numerical oracle cannot authorize discarding them.
+Dropping that caller with `KeepFunc` does not close the original boundary;
+code-address and DATA references likewise grant no typed-entry permission.
+Keep the missing-slot failure until a real caller/backing contract closes the
+complete native effect. Check the independent nine-width native observer and
+all three translation APIs when changing this boundary.
+
+`TestARM64ABI0ResultTailCompilerCallerObservation` independently compiles an
+ordinary Go caller and its ABI wrapper with the original eight-byte ASM store.
+Both SDKs allocate outgoing storage but read only the declared uint32 result.
+This observation is not proof that every caller ignores the tail: the separate
+nine-width ASM observer reads it, and the current SDK's atomic entry has public
+linkname and cross-package ASM tail-call roles. Run the current-source audit as
+well as the cross-SDK fixtures. ABI0's rounded allocation size is not a writable
+FrameSlot and must not erase the missing native caller/backing contract.
+
+The framed raw-leaf proof registers PC-relative WORD branches through the same
+exact source-boundary checker as translation. It independently checks both
+original and normalized CFGs, including dead components; named normalized
+edges must not reclassify skipped executable WORDs as anonymous data. Unknown
+widths, native address/data islands, calls, escapes and unbalanced/fixed-register
+returns remain rejected. This CFG registration supplies neither a callee ABI
+nor permission to clobber Go's reserved R18/g entry identities.
+
+The x/arch decoder corpus is not a Go-accepted instruction list. Its
+`MOVHU.P 107(R13), R13` and `MOVHU.W 192(R2), R2` encodings violate Go's
+base/data writeback-overlap check. The mixed MOVHU decoder form is therefore
+unsupported, not a missing valid Go format. The independent
+`TestARM64DecoderWritebackOverlapRejectedLikeGo` regression checks both
+assemblers' rejection; `check-arm64-plan9-corpus.sh` separately requires every
+Go-accepted selected-family case to remain lowerable.
+
+The decoder also prints reserved ADD/SUB extended-register shifts of five to
+seven. `TestARM64DecoderExtendedShiftBoundariesMatchGo` checks every W/X and
+flags alias, all eight extensions and shifts zero through seven against the
+actual invoked Go assembler, including the older compatibility toolchain.
+Only shifts zero through four are accepted. Native register CALL/JMP forms
+retain function-context classification: a decoder entry supplies neither a
+callee ABI nor its native frame, continuation and result transport.
+
+## Semantic and raw-encoding checks
+
+All fourteen scalar sign/zero-extension moves retain their shared Go grammar
+and native source width, including word-to-word aliases and mode32 MOVLQZX.
+Ordinary native and certified caller/frame reads use exact-width volatile loads,
+even with a dead result. The lowering-only result observer may consume a known
+incoming pointer plus initialized numerical index if the paired load continues;
+it asserts no backing, bounds, alignment or reusable memory authority. W preserves
+unknown high bytes, L clears the upper half and all forms preserve FLAGS. Public
+declaration/raw-return proofs stay independent. Keep actual Go encoder attributes,
+all-five-target objects and original-byte/LLVM numerical and fault oracles paired.
+See [LLVM 22 volatile accesses](https://releases.llvm.org/22.1.0/docs/LangRef.html#volatile-memory-accesses);
+volatile access does not establish validity for a later nonvolatile read.
+
+Ordinary register-addressed native MOVB/W/L/Q and Go's qword MOVD alias use one
+typed load row for lowering and the private result observer. Exact-width
+volatile reads retain dead faults; B/W preserve other bytes and L clears the
+upper half. Continuing the paired load establishes only numerical result bytes,
+not pointee, caller, frame or raw-entry authority. Keep the complete Go MOV
+tables separate from the MMX/X, system, immediate, static-symbol, FP/AUTO and
+store consumers.
+
+The ordinary register-to-native MOV store rows locally reverse that same typed
+GP grammar, including qword aliases and actual REX byte views. Keep native
+stores exact, unaligned and volatile even when their results are dead. A paired
+NUM continuation needs the strict incoming-pointer base and numerical index;
+it changes no logical storage/GP/FLAGS facts and grants no reusable memory,
+pointer-data/GC, caller, raw or frame permission. The complete native BIT
+continuation likewise consumes its shared grammar and exact volatile read/write
+emitter, defines CF and revokes only the ISA's undefined flags. Adjacent popped
+word masking retains only actual known bits, never virtual slot padding. Other
+instructions revoke that transient observation; joins intersect it and its
+logical bytes count toward the unchanged source-flow budget.
+Actual REX changes AH/CH/DH/BH ModRM spellings to SP/BP/SI/DI low bytes;
+register allocation and effects must agree with Go's bytes. An implicit
+physical SP/BP write remains Context without its native contract.
+
+BEXTR and BZHI share Go's complete `_ybextrl` operand grammar, not their
+control bytes or status effects. BEXTR consumes START/LEN; BZHI consumes only
+the index's low byte and defines CF/OF/ZF/SF while killing AF/PF knowledge.
+The Q spelling remains intact in mode32, where VEX.W is ignored and the
+physical operand/read width is 32 bits. Use the common typed descriptor for
+lowering, memory shape and numerical inputs. Void and unused-bool entries
+still require those inputs; exact volatile paired reads survive zero controls
+and dead results without granting reusable pointer/caller authority. Retain
+original Go rows/bytes, public Context controls, initialized five-target
+objects and independent full-control/alias/FLAGS/fault execution. See
+[Intel SDM, BZHI, Vol. 2A §3-138](https://cdrdv2-public.intel.com/825743/325462-sdm-vol-1-2abcd-3abcd-4.pdf).
+
+Packed low-product W/D/Q multiplication consumes the shared binary grammar;
+W retains the word family's separate MMX bank. D/Q shape, lowering, caller
+effects, memory tuples and result definedness must agree. Legacy PMULLD m128
+keeps its observable SSE4.1 opcode and original alignment; virtual FP/SP/BP
+storage cannot supply native backing. VEX/EVEX writes clear wider aliases,
+and E4 masks suppress inactive source reads without shrinking the independently
+proved possible caller envelope. Numerical FP/AUTO observations alone grant
+no native memory permission. Preserve unknown inputs, merge bytes and masks.
+VEX.WIG never selects a qword product; only EVEX.W does. Physical low-bank
+mode32 EVEX masking is distinct from Go's named three-operand limit, and high
+banks remain unbound. Keep complete Go rows/attributes, raw-byte parity,
+five-target three-API objects and independent all-byte/mask/FLAGS execution.
+Portable LLVM execution, including Rosetta, is not original AVX512 execution.
+See Intel SDM Vol. 2B, PMULLD/PMULLQ and E4 exception class:
+[instruction reference](https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-2b-manual.pdf).
+
+Packed integer add/subtract result analysis consumes every Go VEX/EVEX form,
+including signed/unsigned saturation. Reuse the lowerer's typed operation and
+lane widths, not a separate mnemonic allowlist. A numerical lane requires all
+input-lane bytes; merging also requires its old destination bytes. Unknown masks,
+native memory and mode32 physical banks do not gain authority. Complete add
+lowering shares one grammar and read path: retain legacy native m128 alignment,
+conditional volatile E4 reads even for dead results, and coherent VEX/EVEX
+upper-zeroing. Keep caller permissions separate from that numerical observer.
+Check complete Go encoder attributes, sparse byte holes, all aliases, flags,
+mask/fault behavior and five-target three-API objects independently.
+
+The nine scalar POPCNT/LZCNT/TZCNT W/L/Q forms share one Go-table grammar,
+lowerer and typed byte-effect descriptor. Inputs are read before destination
+overwrite; W preserves upper GP bytes and L zero-extends in mode64. POPCNT
+defines all six status flags, whereas LZCNT/TZCNT define only CF/ZF and kill
+knowledge of the others. Numerical result/caller consumers must check source
+bytes independently; a count cannot turn an opaque pointer, unbound native
+read or unknown AUTO byte into numerical knowledge. BSF/BSR's zero-input
+undefined result and packed counts remain separate families. Keep complete
+Go encoder-row checks, original accept/reject witnesses, result/flag negatives,
+five-target objects and runtime regressions together when changing the model.
+
+The six packed byte/floating move-mask names share their complete legacy/VEX
+register grammar across lowering, intrinsic feature inference and result
+definedness. Legacy mode32 X8-X15 is Go-rejected; VEX syntax acceptance does
+not grant that physical bank to the result observer. Initialized X/Y bytes
+produce a zero-extended GP mask without changing vector aliases or FLAGS.
+Unknown/partial inputs and unbound MMX state remain Context. Test each
+function's own LLVM feature requirements: a sibling PMOVMSKB must not supply
+the SSE2 feature needed by an isolated VPMOVMSKB intrinsic on 386.
+
+ARM64 RNDR/RNDRRS reads share the complete MRS/MOVD C_SPR-to-C_ZREG grammar
+and raw Rt/reseed decoder. Named aliases must infer the same `+rand` feature
+and define the same four virtual NZCV bits as WORD, including ZR/dead reads.
+The LLVM intrinsic is side-effecting; never replace it with an untracked MRS.
+Physical platform/g writes remain unbound at typed entries. Required Linux
+tests execute original Go and all four LLVM consumers/optimization axes, using
+independent allowed-value/status invariants rather than comparing random values
+from different executions. Report observed failures honestly: no natural failure
+is not a tested forced-failure path. Complete syntax/object coverage of reserved
+register banks is separate from an executable caller-entry contract.
+
+ARM64 scalar FADD/FSUB/FMUL/FNMUL/FDIV share the complete two-row Go
+case-54 grammar and the raw H/S/D decoder. Their native side effects must
+survive dead values and optimization: ordinary LLVM arithmetic is not an
+FPCR/FPSR contract. FPCR.NEP merges the first source's full V128, not the old
+destination. Copy sparse definedness without inventing upper bits; preserve
+source NZCV and reject missing inputs across CFG joins. Keep original Go
+state/canary oracles, all three translation APIs plus typed Go, bounded batches,
+and required Linux/QEMU NEP/AH execution separate from object-only coverage.
+
+An ordinary typed Void source may omit TEXT's argument-size suffix: `$0` is
+Go's unknown size, not explicit `$0-0`. Recover that distinction from the
+matching retained original header; the actual declaration still bounds every
+input. Omission grants no padding, parameter writes or physical-frame role.
+Explicit mismatches and unknown source bytes remain Context.
+
+Go's original `reflect.makeFuncStub` and `methodValueCall` have empty source
+declarations but physical dynamic callers; their native TEXT retains
+`ArgsSizeUnknown`. Local outgoing-call storage, the argument-only `argLen`,
+and the GC pointer bitmap cannot bound the complete argument/result frame.
+Keep these failures explicit. A real producer would need the actual function
+type/layout, closure-context register and entry identity, caller/result
+transport, lifetime, and the runtime's dynamic stack maps/`retValid` protocol.
+A manual LLVM carrier fixture or ordinary `func()` signature is not that
+producer and cannot make the default benchmark pass.
+
+The Advanced SIMD SM3 family is WORD-only in Go 1.27. Its exact seven forms
+follow [Arm DDI 0602](https://documentation-service.arm.com/static/67e40f3398aa3c3b6eea6a85)
+and LLVM 22's crypto encoder: PARTW1/PARTW2, SS1 and TT1A/B/TT2A/B, with
+four-word vectors and TT indices 0–3. The shared raw-vector registry records no
+GP/SP or memory effects; destructive destination reads and all aliases remain
+explicit. Portable LLVM arithmetic is checked separately from original Go
+WORD execution, which is required on Linux/QEMU CPU=max. Host-only arithmetic
+execution is not evidence that the host implements FEAT_SM3.
+
+- Distinguish physical encoding rules from Go frontend acceptance, especially
+  for 386 VEX/EVEX registers and ignored VEX.W bits. Check primary architecture
+  specifications in addition to Go tables.
+- Validate operand order, implicit inputs/outputs, destination aliases, flags,
+  width extension and lane boundaries. Keep every overlapping X/Y/Z view
+  coherent; preserve legacy upper lanes and clear VEX/EVEX upper lanes.
+- Test dynamic masks, irrelevant high mask bits, unaligned addresses, null
+  inactive sources and guard pages. Consume results so optimization cannot
+  remove the memory access under test.
+- Check count masking versus saturating shifts, signedness, NaNs and
+  out-of-range conversions. Avoid LLVM poison and undefined arithmetic.
+- Native access width is not internal register-slot width. A 386 Q spelling
+  can still require a four-byte memory read.
+- Validate independent frame slots and spans; do not relax ABI checks just to
+  compile an external library.
+- Unknown raw VEX/EVEX instructions must fail closed, never become unrelated
+  legacy instructions. Test truncated and reserved encodings.
+- Demonstrate that the old implementation fails the new runtime oracle where
+  practical. Use an isolated checkout/overlay, not a running frozen tree.
+
+ARM64 literal WORD validates Go's complete `C_LCON` source class before its
+low 32 bits reach any native preflight, decoder, lowerer or PC/data rewrite.
+This is not an int32/uint32 range check: Go also accepts wide MOV and bitmask
+constant classes. Reuse the shared constant classifier and retain actual-Go
+accept/reject controls, exact low-word tests, and live/dead source rejection
+through all four API consumers. A valid decoded opcode cannot repair an
+original `C_VCON` operand; symbolic relocation roles remain separate.
+
+Native-family preflight checks that constant class even for data, then uses a
+private code view for the existing bounded raw-routine/append-pool proof.
+Proved data bytes do not acquire instruction grammar or CPU-target requirements.
+Dead WORDs after a source RET alone remain subject to those requirements.
+The view changes no original source, branch, caller role or memory permission;
+later lowering independently repeats its complete source/layout proof.
+
+Use independent-axis tests for shared operand grammars rather than repeating
+the same huge Cartesian product for every mnemonic. See
+[validation](validation.md) for the required gates.
+
+The packed unpack and logical families share only their binary operand grammar;
+operation effects remain separate. Unpack interleaves bits, including floating
+NaN payloads, within each 128-bit lane and keeps legacy upper aliases distinct
+from VEX/EVEX upper-zeroing. Intel SDM Vol. 2A Tables 2-44/45 classify EVEX
+unpack memory as E4NF: even a zero mask retains the complete native access.
+MMX low unpack reads four bytes; MMX high unpack reads eight. FP spans must
+cover all independent fields before emission. Go-accepted 386 names above
+X7/Y7/Z7 need a real physical mode32 binding; keep their actual Go encodings
+and Context regressions rather than interpreting them as ordinary virtual
+registers. Consult the [Intel SDM](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html)
+and preserve zero-mask/guard-page and complete-byte runtime oracles.
+
+The zero-operand VZEROUPPER/VZEROALL family has implicit SIMD writes, not no-op
+semantics. Its shared grammar/lowerer/caller effect uses registers 0-15 on
+amd64 and 0-7 on 386, preserves registers 16-31, and distinguishes preserved
+low X bytes from known-zero wider bytes. Raw VEX.L selects the two operations;
+reserved pp/vvvv and forbidden prefix combinations must not inherit the pinned
+decoder's incorrect VZEROUPPER spelling. Keep full-bank alias, flags, MXCSR and
+mask canaries. See Intel SDM Vol. 2C VZEROALL/VZEROUPPER in the linked manual;
+portable LLVM execution does not prove native AVX execution.
+
+The six unsigned packed widening ratios have a separate PMOVZX/VPMOVZX typed
+grammar and shared pure caller/result byte dependency; their existence does not
+authorize signed PMOVSX callers. Bind legacy `yxm_q4` and both complete AVX operand tables, the
+shrinking source tuple, K1-K7 and `.Z`; low-bank masked 386 forms are accepted
+by Go, while high named X/Y registers still need a physical mode32 contract.
+Read independent FP fields byte by byte, rejecting any missing byte before
+emission. Legacy writes preserve coherent wider aliases; VEX/EVEX writes zero
+above the destination width. Intel SDM PMOVSX/PMOVZX distinguishes VEX WIG
+from EVEX's DQ-only W0 requirement. Keep complete-byte, NULL/guard-page and
+flags/MXCSR oracles: E5 inactive lanes suppress source reads, but a known mask
+does not itself grant caller memory bounds. Original legacy execution and
+portable LLVM VEX/EVEX semantics are separate from native AVX512 execution.
+The lowering-only result observer may consume its paired conditional native
+read, never invent pointer backing or caller/frame authority. Retain the exact
+shrinking tuple with volatile active reads: even a live low-lane result cannot
+justify removing unobserved native input bytes. Dead outputs and E5 inactive
+lanes need separate fault controls. Public queries, source joins, pointer/index
+identity and raw-entry contracts remain strict. Bound runtime batches and compare
+original legacy Go bytes, independent byte references and LLVM O0/O2 separately.
+
+GP/X scalar bit transfers share one typed grammar for MOVL, MOVQ, Go's MOVD
+and MOVDQ2Q source aliases (64-bit), VMOVD and VMOVQ. Named aliases preserve
+their original `Op` and `Raw` identity and use every MOVQ scalar, memory, GP/X,
+machine register and TLS row; they are not Intel opcode restrictions. Actual raw
+F2 0F D6 remains an X-to-MMX native effect, independent of source-compatible
+formatter spellings, and requires physical MMX/x87 entry and caller state.
+Source normalization cannot wash away that origin or establish initialized
+bytes. Canonicalize only local dispatch copies, not the complete source bound
+by caller, raw-return or frame fingerprints. Go's FLOAT-immediate class has no
+MOVQ or alias row and cannot become a zero integer. The required
+Linux AMD64 `TestCrossLinuxRuntimeMatrixX86MOVQSourceAliasesOriginalAndLLVM`
+counterpart executes original Go bytes and LLVM with separate GP, GP/X,
+X128-clearing, native eight-byte read and address effects.
+The grammar feeds original-source validation,
+CFG routing, lowering, private FP-result initialization and caller byte effects;
+the direct scalar module prototype cannot bypass it. Legacy writes preserve
+upper vector aliases, while VEX/EVEX writes clear them. Mode32 VEX GP transfers
+use 32 bits even for VMOVQ; its memory/X copies remain 64-bit. Raw-only VMOVW
+keeps its decoder-bound 16-bit role and does not authorize named instructions
+or caller state. Bind both complete current and historical legacy tables,
+including the historical signed-imm32 MOVQ row. Keep every-byte FP holes,
+dead volatile memory reads, original-Go NULL/guard-page faults, all register/
+address axes, complete vector/GP canaries and the three-API five-target objects.
+Accepted operand shapes never grant pointer permission or initialized data.
+
+Raw VMOVW's exact original opcode/operands may consume the same GP/X byte
+transfer inside ordinary lowering. Require both source bytes even for Void;
+retain WIG, GP zero extension, complete vector upper clearing and exact volatile
+m16 accesses. Only already-proved incoming pointers supply native addresses.
+RIP literals, address overrides, segments, native returns and frame roles keep
+their separate contracts; declaration-only observers gain no native read.
+Keep unchanged unbound Go/emitter objects and Context controls alongside
+initialized five-target objects, byte/origin mutations and the original portable
+guard-page execution. See Intel's [VMOVW specification, section 5.61](https://cdrdv2-public.intel.com/678970/intel-avx512-fp16.pdf).
+
+For ordinary GP/X native loads, the lowering-only result observer consumes the
+same exact-width volatile read as scalar lane insertion. MOVL/MOVQ/MOVD and
+VMOVD/VMOVQ retain loaded low bytes, known-zero X128 remainder and distinct
+legacy/VEX/EVEX wider aliases. Memory Q remains eight bytes on 386, unlike its
+GP-register WIG form. The paired named native-store continuation separately
+requires every stored low byte and an incoming pointer address, even for Void.
+It keeps the original exact unaligned volatile write without changing numerical
+or storage facts; a masked/logical read rule cannot supply a write envelope.
+These continuations cannot replace public declaration, caller, raw/frame, MMX
+or physical-bank contracts or establish future memory validity. Keep original
+unbound format objects, initialized read/store programs, overwritten-store
+observations and portable byte/canary execution as separate evidence.
+
+Scalar integer lane insert/extract shares `x86ScalarLaneProperties` across the
+original-source validator, lowerer, caller-region effects and ABI0 result-byte
+observer: all PINSRB/W/D/Q and PEXTRB/W/D/Q names, plus their V forms. A lane
+insertion defines only its selected bytes; untouched unknown X bytes stay
+unknown. Extraction needs exactly its selected bytes. Legacy preserves wider
+aliases, while VEX/EVEX clears the bytes above X128. Go's legacy Ymm spellings
+in these tables encode GP ModRM numbers, not physical MMX state. Bind complete
+Go tables and opcode attributes independently. Mode32 VPEXTRQ retains the
+original W1 encoding but uses the physical WIG dword lane and r32/m32 effect;
+its unbound high banks remain Context. Scalar INSERTPS/EXTRACTPS result effects
+reuse their existing typed source/target/zero selectors, not a new wider-vector
+or mask permission.
+
+Block extraction shares its complete insert/extract grammar with paired native
+memory effects and mandatory Void inputs. Require every selected source byte,
+mask and complete incoming pointer/index before continuing; unknown bytes in
+unselected chunks stay unknown. Unmasked stores are exact unaligned volatile
+writes, even when overwritten. Masked E6NF stores retain their original native
+opcode without reading inactive destination bytes. Continuation establishes no
+memory facts or caller/raw/physical permission. Keep logical FP/AUTO ownership
+separate, original unbound format objects intact, and initialized public objects,
+portable byte/canary execution and required native execution distinct.
+
+Scalar PEXTRB/W/D/Q, VPEXTRB/W/D/Q and EXTRACTPS/VEXTRACTPS stores consume
+their existing typed lane selector and the exact selected bytes. The paired
+volatile native write needs an incoming pointer base and numerical index;
+Void and unused bool cannot waive these obligations. A store creates no
+memory or later-read fact. Original uninitialized native/segment formats retain
+Go/emitter objects and public Context, not initialized public success.
+
+Private POPW/L/Q native stores reuse the complete existing stack-width and
+bit-initialization proof. Keep native widths, cell identity, underflow, balance,
+FLAGS/DF/ID correlations and missing-byte checks. Only a paired exact volatile
+store can consume those popped numerical bytes at an incoming-pointer address;
+the standalone observer gains no native memory or physical entry role.
+Rejected paired stores must not mutate the reaching private state.
+
+Any integer-lane instruction with declared integer FP results consumes the
+whole original-function must-initialized byte proof before lowering, including
+later GP-to-FP stores and all RET paths. A final-opcode-only check is inadequate.
+An explicit AMD64 ABIInternal scalar entry uses the same bounded source CFG,
+but initializes only the declared bytes in Go's nine integer argument registers
+and checks its scalar AX result at every RET. It does not initialize ABI0 FP
+fields, spill slots, hidden g/closure state or unspecified upper argument bytes.
+Pointer arguments remain opaque identities; aggregates, floating/boolean
+transport, multiple results and raw/native entries need their separate contracts.
+Narrow byte/word FP views require unique actual numeric field bytes; pointer,
+padding, input stores, partial results and unknown effects remain Context.
+Native memory uses its exact volatile byte width and existing caller bounds;
+no new frame, pointer or native backing is inferred. Keep original Go objects,
+five-target three-API objects, selected/unknown lane mutations, full vector/GP
+alias canaries and flags/MXCSR observations. Portable LLVM execution and Darwin
+Rosetta observations do not establish native Linux or AVX512 execution. An
+unknown AES effect is still unknown even after PINSRD is registered.
+
+The lowering-only result observer additionally consumes the paired native
+PINSRB/W/D/Q, VPINSRB/W/D/Q and INSERTPS/VINSERTPS loads. Continuing past their
+exact-width volatile read defines only the selected bytes, with the existing
+lane/zero-selector and upper-alias rules. Even a dead result or an INSERTPS zero
+selector retains the native access. Incoming pointer identity and numerical
+indexes are not bounds, validity or initialized-pointee facts; declaration-only,
+caller, native-store and raw/frame observers remain strict. Keep the complete
+Go rows, five-target objects and original legacy-Go/LLVM numerical and fault
+oracles separate from a claim of physical VEX/EVEX execution.
+
+`CaptureGoAMD64FrameSource` is an initial, sealed **observation**, not a frame
+permission. It independently selects and exports a flat main module's complete
+ordinary Go sources, retaining only bodyless integer, finite pointer and slice
+assembly declarations. Stock-SDK imports bind the actual compiler-selected
+source/export graph; bodies, values and imports themselves grant no native
+permission. Foreign module dependencies still need their own source handoff.
+SDK dependency macro registrations remain guarded compiler inputs, not ordinary
+target CPP authority. Retain their bounded literal-include closure using Go's
+fixed package-CWD search, including shared fallbacks and directory shadowing.
+Dynamic directives, root escape and changed source fail. Only the actual
+compiler/source/export role supplies a generated header; no expanded CPP or
+private-frame permission is created by this source-only capture.
+The observer then binds
+all selected ASM, headers,
+actual Go tool/source routes, original object bytes and complete source positions.
+The caller selects the trusted stock-Go installation and explicit private command
+caches; a public selection record, manual signature or JSON cannot recreate its
+token. Both conventional BP producers are recognized from actual machine bytes,
+not from a Go version guess. Ordinary conditional CPP additionally binds the
+actual SDK's complete macro-registration ASTs through the shared
+`internal/goasmmacros` reader. Both the independent Go assembler and source
+preprocessor consume that same observed target/profile definition list; header
+changes permanently revoke the source observation. Environment strings alone
+are not macro-source authority. Unknown generated/foreign/test/unwind roles
+remain Context. Closed fixed-local Windows metadata has a separate complete
+object/listing/prologue/source-PC join. Its exact SDK schema binds all eight
+producer inputs: hashed SEH definitions from Go 1.23 onward have different
+symbol/Aux enums, linkname flags and alignment listing syntax. Use the selected
+producer's schema, never optional formatting or global object-version widening.
+Native exception handlers remain outside that observation. Every
+Verify rechecks bytes, complete inventory and actual export/selection before and
+after commands; failure or Close revokes the token. The observer alone has no
+allocator, caller certificate, native-memory grant or compiler adapter.
+Pointer/slice/bool observations retain the independent language type/model and
+object-bound ABI0 data/len/cap slots, including pointee, element, named/alias RHS
+and field identity. A go/types pointee model is not an observed native extent:
+Go1.20 StdSizes omits compiler tail padding/zero-tail storage in some structs.
+These observations grant no input extent, alias or GC contract. The bounded
+fixed-local consumer separately proves scalar/component transport. Its Binder
+re-typechecks the complete original typed declaration and retains that
+language identity; each consumer checks it against the live factory declaration
+and object role/signature before and after translation. The restricted
+transport grammar applies to types reachable from assembly parameters/results,
+not unrelated Go declarations such as an XOF interface or callback type.
+All original Go sources are still independently typechecked; complete scope
+names and local type/alias roles remain bound. Unrelated ordinary types cannot
+create assembly signatures or bypass signedness, alias RHS, pointee or field
+checks on a real assembly signature. By-value aggregates,
+recursive/generic types, noninteger/nonboolean elements and nonordinary roles remain Context.
+Opaque incoming pointers may be copied through full-width GP/private cells
+and pointer results. The separate native-input access role accepts typed FP
+pointer bases with plain displacements and exact typed access widths. It grants
+no pointee extent, alignment or private-frame certificate; preserve native
+accesses and faults even when numerical results are dead. Pointer arithmetic,
+indexed/TLS addresses and pointer escape require their own proven contracts.
+Pointers never become numerical bytes or private-SP addresses. Every overlapping store revokes
+their cell identity, including an unknown or zero mask. Slice data/len/cap and
+multiple results require every exact ABI0 component to be initialized. A bool
+occupies one physical byte but returns LLVM i1: only proved zero/one bytes,
+including complete SETcc and canonical CMOV alternatives, may enter that slot.
+The eight mod64 residues and independent byte-alias replay remain mandatory.
+The complete CFG uses a bounded fixed-point worklist; provisional memory facts
+are published only after convergence. An ordinary same-function branch is not
+an external tail call. Go-generated split-entry checks are recognized from
+exact original code, source positions and relocations; only the ordinary body
+layout is projected. Source-written CALL/TLS and private helpers receive no
+permission from that observation. Keep these contracts distinct from component
+transport and from native-input access.
+Mixed TEXT/DATA requires a separate complete current-Go source/object/listing
+observation on each AMD64 OS. Bind every DATA definition, byte, zero tail,
+relocation and original TEXT position; Windows unwind retains its independent
+complete-object join. Observing mutable/BSS/address DATA grants no memory use.
+SDK DATA reuses the same live complete source/object observation rather than
+recapturing it with standalone producer flags. Ordinary ABI0 global references
+can remain in that inventory without becoming private literals or address roles.
+The fixed-local consumer separately admits bounded private, relocation-free
+readonly literals whose actual Go bytes equal the entire LLVM initializer.
+Retain exact symbol identity, native extent/alignment and live source guards;
+reject coalesced definitions, stores, address escape, and zero-mask out-of-bounds
+reads. Only already registered typed numerical operands consume this proof;
+literal reads never receive private-frame certificates. Complete KMOV/VAES byte
+boundaries use the shared physical decoder without borrowing raw RIP translation
+permission. Original-Go/LLVM execution and all-target objects remain distinct
+from an original external-library replay or ledger pass.
+The runtime oracle independently snapshots original Go ABI0 bool bytes and
+adjacent canaries. Its LLVM caller uses an explicit i1-to-i32 shim: these tests
+do not certify C `_Bool` return attributes or a new foreign-call ABI.
+The fixed-local contract also accepts a typed void return with no result slots.
+Void does not exempt any original or
+normalized DAG, local-byte initialization, native alignment, SP restoration,
+BP/g, escape or source-lifetime check, and cannot authorize an FP input store.
+Compile-only void object tests establish no numerical return or external-library
+runtime coverage; observations alone still have no local-memory permission.
+Factory artifacts use the request's effective explicit TMPDIR, not the parent's
+temporary environment. Verify and Close check the created directory identity;
+replaced or redirected directories are never recursively cleaned. The package
+root is fixed to its resolved canonical source at capture: a later change to
+the caller's original alias does not change that source. Explicit cache roots
+remain caller-owned; capture does not authenticate ownership or delete them.
+
+Exact downloaded frame capture distinguishes the selected package directory
+from its original module root. A flat subpackage may bind its
+declared path only through the independently guarded whole ZIP and original
+go.mod; archive namespace aliases do not replace that declared namespace.
+Actual Go selection must retain the same module root, metadata, language and
+package path. Ancestor metadata or source changes revoke the capability.
+Preserve a missing `go` directive as missing in the original module record.
+Match its actual cmd/go metadata by role: the main module has the fixed 1.16
+default, while a dependency retains an empty GoVersion. Do not rewrite go.mod,
+normalize dependency metadata into a main role, or borrow the current SDK's
+language version. The actual compiler/source/export checks and independent
+main-source typecheck still enforce that language; malformed or changed
+metadata remains rejected. Keep current-Go and Go 1.20 producer regressions.
+SDK imports retain the actual SDK source/export graph. Each foreign module
+requires the frame factory's own exact Go-download/whole-ZIP observation,
+canonical module/package/metadata/language identity and complete compiler
+source/export consumption. Replacements and unobserved version changes fail;
+restoring changed dependency bytes cannot revive a revoked observation.
+An archive without go.mod may retain canonical proxy metadata only through
+the shared public SumDB signature and record-inclusion verifier, bound to the
+actual exact ZIP h1, metadata h1 and bytes. It remains external metadata,
+never an invented ZIP member or a cache-CWD main module. Full ZIP/tree checks
+and permanent mutation revocation remain required. A legacy primary uses a
+separately owned exact-version dependency query, not cache-CWD main inference.
+Its private metadata preparation can resolve only versions already in the
+observed download cache's file-proxy index; disable direct/network fallback.
+Only registered stock-Go resolution progress is permitted during preparation.
+Then freeze that private configuration and repeat the complete actual query
+read-only; unknown diagnostics, changed pins, replacements and query/cleanup
+failures remain errors. Retain the dependency's absent GoVersion metadata and
+the compiler's implicit Go 1.16 language, not the query main's language.
+Both frame factories still independently check every selected exact ZIP,
+original source, compiler export and object. The temporary query provides no
+numerical-command, memory, native-entry or source-exclusion permission.
+The source-role extension grants no new native instruction/memory effects or
+dynamic-frame permission. Keep the original Go objects and three-API LLVM 22
+O0/O2 objects on all AMD64 targets separate from external-library success.
+
+The independent x86 SDK numerical/data observation uses exact Linux x86,
+Darwin/amd64 and Windows x86 profiles. Source macros, baseline CPU settings,
+CGO defaults, LLVM triples and every native member remain target-bound;
+ordinary owned numerical capture retains its separate Linux-only boundary.
+Default Darwin PIE carries exact shared compiler/assembler flags; Windows PIE
+does not. CPU variables' original self-linkname NonpkgDefs remain a CPU-only
+storage role, never a generic-global or external-function permission. SDK
+compiler metadata may include the complete bounded JSON directive prologue
+from the pinned Go writer/linker grammar. Observe its rows without applying
+imports, linker flags or calls; standalone/owned objects retain their old bound.
+Keep full original CRC32 source/object checks on each added platform and
+cross-target, malformed-row, ABI/index and source-lifetime rejection controls.
+
+Ordinary fixed-local capture observes Go's actual AMD64 v1/v2/v3/v4 profiles
+independently. Original feature-tagged source selection, compiler exports,
+target/CPU environment and native objects stay bound to that exact capture;
+changing and restoring a profile cannot revive a revoked observation. The
+owned assembler uses cmd/go's GOOS, GOARCH and GOAMD64 definitions, with ordinary
+conditionals closed by the shared actual-source registration above. Generated
+headers still require their separate source mapping; macro selection grants
+no unregistered numerical, frame or memory effects. A higher profile
+is neither a native CPU execution certificate nor new memory permission.
+The focused profile tests own one disposable build cache per test root so
+Go 1.27's objdump helper is not rebuilt for every case; sources, modules and
+temporary artifacts remain separate, and every case reruns the actual driver.
+
+Broadcast result-byte consumers share the complete scalar/block grammar with
+lowering. Read exactly its source tuple, not the destination width, from existing
+initialized FP/AUTO bytes or the lowering-only same-file DATA directory. The
+mask may preserve unknown destination bytes but cannot authorize missing source
+bytes or native pointer storage. Standalone declaration queries have no DATA
+owner; source/raw address overrides retain their separate contracts. Keep the
+eighteen memory members, full Go rows, five-target objects, mask/extent negatives
+and portable numerical execution together. Historical Go maskless `.Z` objects
+are reserved-encoding observations, not accepted forms or runtime passes.
+
+RIP broadcast constants retain their private decoder role, never a named
+immediate grammar. A bounded whole-source replay may hand exact scalar constants
+or block DATA tuples to those same typed effects. It still requires actual mask
+and merge bytes, independently checked raw RET and complete source/DATA identity;
+frames, conditional native reads and declaration-only queries gain nothing.
+Portable broadcast data values execute on the actual host target; do not hide
+them behind an unrelated x86-only native launcher. Original AVX512 execution
+remains a separate required test axis.
+
+Physical MOVSXD and ordinary dword literal loads share an exact four-byte
+decoder input role. Opcode 63's default dword, REX.W and 66+REX.W forms keep
+their independent zero/sign-extension writes. Supply that fact only to the
+current source-stack numerical transfer, then clear it before saving state.
+It establishes no pointer, later-read or DATA ownership; the whole-source raw
+return guard still verifies actual literal bytes. Keep physical SP/BP/g roles,
+vendor-ambiguous word reads, original encoding identity and stale-proof controls.
+
+VEX/EVEX logical RIP literals reuse the same bounded whole-source consumer and
+existing typed logical effects. Require exact decoder read identity, source
+operand and full/broadcast tuple width; missing source, mask and merge bytes
+remain unknown. The complete original/decoded/normalized source and raw RET
+checks stay independent. This adds no native read, frame, legacy/MMX or
+declaration-query permission. Preserve original unbound Go/emitter objects and
+public Context separately from initialized public objects.
+
+EVEX VPSLLDQ/VPSRLDQ RIP literals use that same bounded source consumer and
+the existing typed shift effect. Read the entire X/Y/Z tuple even when a byte
+count of 16 or more makes every result lane zero. VEX remains register-only;
+mask, broadcast and zeroing fields remain reserved. Preserve all 256 selectors,
+128-bit lane boundaries, wider-alias clearing and original FLAGS without
+granting a standalone DATA query or raw-return frame permission.
+
+VEX/EVEX packed integer EQ/GT literals share the existing complete B/W/D/Q
+comparison grammar and byte effect. Exact source identity and full/broadcast
+tuple width remain mandatory. Vector input bytes and actual masks stay required;
+the EVEX K result is write-only, not a merging vector destination. This adds no
+legacy/MMX, native-read, frame or standalone DATA-query role. Keep original
+uninitialized formats separate from initialized public objects. C-only signal
+and exit-status controls execute on the actual host; they do not require an
+x86 native-instruction launcher or certify native AVX512 execution.
+
+VEX/EVEX floating-compare literals reuse their typed PS/PD/SS/SD input effects
+and existing native emitter. Preserve the entire predicate byte, MXCSR, fault
+behavior, scalar passthrough and write-only K results. Exact decoder/DATA identity
+and full/scalar/broadcast tuples supply only the current instruction's inputs,
+not native-read or frame authority. A CFG state clone deliberately revokes this
+transient DATA scope; instruction-local test oracles must not confuse that
+revocation with the instruction's own effect. Keep original unbound formats
+separate from initialized public objects and native execution.
+
+VEX/EVEX packed add/subtract literals reuse their complete typed wrapping and
+signed/unsigned saturating forms. Exact decoder read identity and full/broadcast
+tuple extent feed the existing lane-byte effect. Unknown source lanes remain
+unknown, merging requires old destination bytes, and zeroing does not invent a
+mask or memory extent. Whole-source/raw-return checks, mode32, native-read,
+legacy/MMX and declaration-only boundaries stay independent. Keep original
+missing-mask formats and independently initialized public programs distinct.
diff --git a/docs/development/packed-average-contract.md b/docs/development/packed-average-contract.md
new file mode 100644
index 000000000..d0a886d55
--- /dev/null
+++ b/docs/development/packed-average-contract.md
@@ -0,0 +1,24 @@
+# Packed unsigned average
+
+`PAVGB/PAVGW/VPAVGB/VPAVGW` share the actual Go `ymm` and `_yvandnpd`
+operand grammar, but retain distinct encoding effects. Named 386 MMX rows are
+rejected by Go's `Py1` selector. Named 386 high X/Y syntax is not proof of a
+physical register; only complete decoded low-bank raw bytes can retain an
+EVEX mask in mode32. Portable JSON cannot restore that private marker.
+
+Each byte/word computes `(unsigned(a) + unsigned(b) + 1) / 2` with a widened
+sum. Legacy X writes preserve upper views; VEX/EVEX writes zero bytes above
+their width. EFLAGS and MXCSR are unchanged. EVEX E4.nb memory reads suppress
+inactive lane faults, while active reads stay observable even with dead results.
+
+Legacy m128 remains the original native instruction (including alignment and
+segment faults); logical FP and unbound SP/BP are not native backing. Logical FP
+values need every declared byte even with an all-zero mask. Registered widths
+and byte effects do not grant caller, pointer, frame, or fixed-local permission.
+
+LLVM objects cover five targets and three APIs. Full translated 64-byte views
+have independent O0/O2 arithmetic, flags, CSR, and canary oracles. Original SSE
+and MMX results are separate observations, not whole physical x87/MMX state.
+Original VEX upper aliases have a required Linux test with actual AVX/AVX2
+preflight and pinned guest transport. Rosetta is diagnostic, not native AMD64;
+original EVEX execution is not claimed by the translated shadow-view oracle.
diff --git a/docs/development/reflect-dynamic-entry.md b/docs/development/reflect-dynamic-entry.md
new file mode 100644
index 000000000..30e274ab4
--- /dev/null
+++ b/docs/development/reflect-dynamic-entry.md
@@ -0,0 +1,103 @@
+# Reflect's dynamic assembly entries
+
+This is a missing physical-entry contract, not permission to extend an ordinary
+zero-argument `FuncSig.Frame`. The original `reflect/asm_{386,amd64,arm}.s`
+files remain translation failures. No corpus, benchmark, CI or ledger result is
+upgraded by the contract regression described below.
+
+## Independent source and object evidence
+
+In the selected Go toolchain, `reflect/makefunc.go` declares `makeFuncStub()`
+and `methodValueCall()` with no parameters or results. `MakeFunc` installs
+`abi.FuncPCABI0(makeFuncStub)` in a function value whose *actual* argument and
+result layout comes from `funcLayout(ftyp, nil)`. A method value follows the
+same construction. The closure context supplies the type, stack map and
+argument length; none is a third explicit Go parameter.
+
+The original TEXT declarations deliberately omit their argument size. Go's
+assembler objects record `internal/abi.ArgsSizeUnknown`, not zero. The runtime
+handles these entries specially in `runtime/stkframe.go`: it obtains the dynamic
+argument bitmap and length from the saved closure and uses `retValid` to decide
+whether the result region is initialized. `NO_LOCAL_POINTERS` is explicitly
+described as a lie in the amd64 source: its local `abi.RegArgs` needs special
+runtime stack-object handling.
+
+The source contract is larger than `argframe+0(FP)`:
+
+| Architecture | Incoming context | Argument/result state | Original locals |
+| --- | --- | --- | --- |
+| 386 | DX | Dynamic caller stack frame | Outgoing helper arguments and retValid |
+| amd64 | DX | Caller frame plus AX/BX/CX/DI/SI/R8–R11 and X0–X14 | retValid and abi.RegArgs |
+| arm | R7 | Dynamic caller stack frame | Outgoing helper arguments and retValid |
+
+On amd64, `runtime.spillArgs` and `runtime.unspillArgs` use R12 for their
+`abi.RegArgs` pointer and preserve/restore a *whole register bank*. The empty
+Go declaration of a helper is not evidence for a plain `call void helper()`.
+The normal `callReflect`/`callMethod` declarations are typed, but their pointer
+parameters still require distinct region, lifetime and memory-effect proofs.
+
+## Reproduce the boundary
+
+After selecting current Go 1.27 and LLVM 22 as documented in [validation](validation.md):
+
+```sh
+(cd cmd/plan9asmll && go test . \
+  -run '^TestReflectDynamicStubNativeObjectsRetainContext$' -count=1 -v)
+
+go test . -run '^(TestX86LEAFPAddressesRequireBoundStorage|TestX86LEAFPAddressCannotInventScalarBacking|TestTranslateARMFPAddressesTypedStorageLLVM22Objects)$' \
+  -count=1 -v
+```
+
+The first test loads actual selected Go declarations, derives the full typed
+`go_asm.h`, obtains `symabis` from the original assembly, and feeds those ABI0
+definitions to the real Go compiler's `-asmhdr`. Every header definition must
+match. It then assembles each original source to a nonempty Go object and checks
+the native `ArgsSizeUnknown` metadata for both entries. It requires isolated and
+whole-file LLVM translation to retain `ErrProbeNeedsContext`, with no output IR
+or source-N/A conversion. This is a passing *guard test*, not successful
+translation of reflect. The second command exercises real bound FP positives
+and LLVM 22 objects independently; it does not supply the missing dynamic entry.
+
+LLGo replaces its reflect package (`runtime/build.go`, `altPkgReplace`) and
+implements dynamic functions through its provider/FFI bridge
+(`runtime/internal/lib/reflect/makefunc*.go`). That replacement does not consume
+these gc assembly entries and cannot establish their translation coverage.
+
+## Proposed next layer, not implemented
+
+Start with one architecture, not a name-triggered cross-architecture special
+case. A possible x86 physical-entry option would be address-only, like the
+existing explicit `ARMMachineEntry`, with an internal typed state carrier.
+The native shim must capture incoming SP/continuation, DX, GP/FP registers and
+the real caller-frame base before any LLVM prologue. An ordinary LLVM argument
+list or a fabricated `argframe` alloca cannot replace that capture.
+
+Keep source local backing and private carrier storage distinct from the borrowed
+caller frame. Preserve every original instruction and PC ordinal. An explicit
+caller bridge must supply the dynamic frame extent/lifetime and closure layout;
+reject missing, inconsistent or escaping context. Ordinary FP lookups retain
+their existing slot and span checks. The private carrier must not be writable
+through source pointers or arbitrary callees.
+
+The amd64 spill/unspill family needs an explicit shared-state call contract,
+checked against the actual source's register reads/writes and RegArgs layout.
+Typed Go declarations alone do not describe this family. `callReflect` and
+`callMethod` require bounded effects on caller arguments/results, retValid and
+RegArgs, with an actual callee/ABI bridge rather than guessed native register
+arguments. Unknown helper, indirect call, frame escape or continuation fails
+closed.
+
+Object acceptance alone leaves GC, stack relocation, panic/recover wrappers
+and native unwind unresolved. A replay harness with independent typed C helpers
+can prove caller-frame/register transport but cannot prove gc's special stack
+maps. Binding the real Go runtime requires a separate source-derived roots and
+stack-map contract; the LLGo FFI replacement is a different implementation.
+Neither must be silently claimed by the other.
+
+The first implementation batch should therefore cover one x86 carrier/shim,
+explicit bounded frame and helper contracts, source replay plus a real caller
+bridge, and positive/negative LLVM 22 objects on that architecture's supported
+targets. Add independent runtime register/frame oracles where authorized.
+Mixed integer/float/stack arguments, multiple results, closure distinction,
+GC-visible pointers, conditional/helper effects and unknown-contract rejection
+are required before expanding to reflect runtime claims or other architectures.
diff --git a/docs/development/validation.md b/docs/development/validation.md
new file mode 100644
index 000000000..73d3f2ff2
--- /dev/null
+++ b/docs/development/validation.md
@@ -0,0 +1,368 @@
+# Validation and contribution completion
+
+## Toolchain
+
+Develop with current Go 1.27 and LLVM 22 exactly. The official compatibility
+matrix retains Go 1.20–1.27. Put the selected Go binary on PATH: subprocesses
+deliberately use `GOTOOLCHAIN=local`.
+
+```sh
+go127_root=$(GOTOOLCHAIN=go1.27.3 go env GOROOT)
+export PATH="$go127_root/bin:$PATH"
+export GOTOOLCHAIN=local
+source scripts/llvm22.sh
+llc_cmd=$(find_llvm22_llc)
+"$llc_cmd" --version
+```
+
+The helper accepts `llc-22`, an unversioned `llc` reporting version 22, or
+`LLVM_CONFIG` pointing to LLVM 22. On Homebrew hosts:
+
+```sh
+llvm22_root=$(brew --prefix llvm@22)
+export PATH="$llvm22_root/bin:$PATH"
+export LLVM_CONFIG="$llvm22_root/bin/llvm-config"
+```
+
+Missing required LLVM tools, linkers or backends fail, never skip.
+Host-inapplicable execution requires its cross-runtime CI counterpart.
+
+Native AVX512 execution has 65 explicit hardware qualification owners in
+[the pending inventory](../../testdata/native/avx512-roots.txt). Default CI
+retains grammar, original Go sources, LLVM 22 objects and available SSE/VEX
+execution. The policy preflight also compiles the tagged test binary and checks
+the complete default/tagged root difference. This is compilation and inventory
+evidence, not native execution. Missing hardware remains pending.
+
+On suitable direct Linux/amd64 hardware, run the complete explicit set:
+
+```sh
+native_roots="$(paste -sd '|' testdata/native/avx512-roots.txt)"
+GOFLAGS= GOENV=off GOWORK=off GOTOOLCHAIN=local \
+  PLAN9ASM_AVX512_RUNTIME=required go run ./cmd/plan9asmtest \
+  -out _out/native-avx512-qualification -ci-selector "^($native_roots)$" \
+  -ci-isolate-root TestAMD64FPClassRuntimeSemantics -ci-owner 0 -shards 16 -timeout 20m \
+  -- -tags=plan9asm_native_avx512
+```
+
+Run partitions 0 through 15 separately with the same source/tools/environment,
+then use the selected-CI verifier described in the runner README. A partition
+alone is not complete qualification. The strict reader still rejects every
+failure, skip or missing child. CPU/OS state and original-opcode preflights are
+unchanged. Full-bank fixtures may need AVX512 even for a low-width mnemonic;
+keep their complete original program pending rather than weakening its preflight.
+COMI's independent VEX owners remain mandatory; only the EVEX axes are tagged.
+ER, BF16 and FP16 need distinct hardware/owners and are not certified by this set.
+
+RCP14/RSQRT14 original-Go bit, MXCSR and masked native-memory owners are part of
+that inventory. For a focused F check (packed X/Y additionally require VL):
+
+```sh
+PLAN9ASM_AVX512_RUNTIME=required go test . -tags=plan9asm_native_avx512 \
+  -run '^TestX86Reciprocal14Native(F|VL)AMD64$' -count=1 -timeout=20m
+```
+
+The tag does not affect ordinary source/trace/actual-Go/three-API object tests.
+Darwin and native Linux/amd64 additionally compile and link the C fixtures
+without executing them; their receipts identify the actual x86_64 target.
+Default CI does not execute these native owners. Missing hardware, tools or
+CPU/OS-state proof fails explicit qualification; `auto` cannot turn it into a
+passing skip. Until successful original-Go and every native pipeline/fault
+receipt exists, native RCP14 acceptance remains pending. These owners do not
+certify native386, AC-enabled faults, raw continuations or the two Context-only
+repeated opaque-pointer-index address constructions.
+
+CI also verifies the actual installed Go against the installer's resolved
+version and uses the shared exact Node22.23.4 action. A successful installer
+outcome without its version output is not a valid tool observation.
+
+Compatibility matrix labels such as `1.26.x` resolve to tracked exact SDK pins
+in `.github/actions/setup-go/action.yml`. Update the shared pins deliberately
+from the official Go release metadata and run the complete publication policy
+suite. Every partition and collector must use the same exact compiler and SDK
+source; a runner cache or a release during CI must not change that identity.
+Explicit stable version inputs retain their requested patch.
+
+The rich CLI's complete ARM64 fallback-frame oracle runs natively on supported
+ARM64 hosts and under pinned QEMU in the required Linux cross job. One outer
+owner runs its exact nested-module root; a fresh strict reader verifies both
+logical partitions and all four required children. Cross scopes bind the actual
+Node auditor through the shared tool observer. Object-only Windows skips do not
+establish execution of its 512 input rows.
+
+Darwin native C oracles query the actual selected macOS SDK with bounded, owned
+`xcrun --sdk macosx --show-sdk-path`, require one complete absolute existing
+directory, and pass `--no-default-config -isysroot` to the independently checked
+LLVM 22 clang. `DEVELOPER_DIR` selects the actual developer tools; `SDKROOT` and
+CGO flags alone cannot override a hard-coded clang default configuration. Do not
+edit global clang configurations, guess an SDK version or substitute another
+LLVM. Missing SDK selection fails. The shared `internal/nativeoracle` helper is
+test-driver configuration, not source/ABI authority; exact downloaded-source
+oracles retain their additional live SDK/tool/file identity observations.
+
+## Local and CI gates
+
+Run focused RED/GREEN tests first; preserve failures under ignored `_out/`.
+
+Derive FP slot offsets from `DeriveGoFuncABI0Signature` before constructing a
+fixture. The result area may start after ABI word padding; successful assembly
+alone does not validate its offsets against the Go declaration. Pair rejection
+controls with a valid initialized source through the same public API.
+
+Before choosing a family selector, enumerate its canonical row/object roots and
+all changed regression owners. Check every name against the selector and the
+actual JSON RUN/terminal inventory; a broad-looking prefix can omit legacy
+owners. When width or alias semantics change, also audit rejection assertions
+in indirect consumers, such as masked broadcasts seeded by KMOV. Keep source-row,
+witness, module-object and executed-case counts separate.
+An object helper's O0 pass does not establish O2: verify the actual compiler
+options for each API/module before reporting either level.
+
+Freeze each qualification snapshot. When only one test owner is strengthened,
+unaffected evidence may be inherited through explicit file/function and tool
+identity; rerun the changed owner and any omitted roots. Identify both revisions
+and never describe inherited evidence as a fresh execution. Preserve erroneous
+scope reports alongside their corrections.
+
+Then run the relevant complete gates:
+
+```sh
+go test ./... -count=1 -timeout=45m
+(cd cmd/plan9asm && go test ./... -count=1 -timeout=30m)
+(cd cmd/plan9asmll && go test ./... -count=1 -timeout=30m)
+go vet ./...
+go build ./...
+test -z "$(git ls-files -z -- '*.go' | xargs -0 gofmt -l)"
+git diff --check
+node --test .github/scripts/priority-*.test.cjs
+
+scripts/check-go-asm-coverage.sh
+scripts/check-arm64-plan9-corpus.sh
+scripts/check-stdlib-corpus.sh --instructions-only
+```
+
+Changes to test helpers, resource ownership or workflows require the complete
+Node policy suite above and the exact Go selector in the `ci_policy` job of
+[go-ci.yml](../../.github/workflows/go-ci.yml) before publication. Use Node22.23.4;
+focused instruction or lifecycle tests do not check these static contracts.
+
+The [exhaustive runner](../../cmd/plan9asmtest/README.md) can partition expensive
+first-party tests without sampling. Its actual inventory, disjoint ownership,
+raw outcomes and strict complete-module aggregate remain required. Owner 0 owns
+the root package, owner 1 `gotoolprofile` and `internal/sdkfrontend`, owner 2
+all remaining packages. The SDK frontend's independent original-source roots
+use the same exhaustive partitions and two-worker bound as the profile package,
+so their repeated captures do not accumulate in one unfiltered race command.
+Both owner-1 packages run serially, with no nested package-worker pool.
+Only explicit owner 2 uses the existing worker limit across whole packages.
+Each package remains an unfiltered one-shard/one-worker command, and the single
+collector preserves inventory order and joins active processes on cancellation.
+Ordinary suites may use `-workers 2`; one collector owns report/coverage writes.
+The runner's own complete regression suite can use the same exhaustive mechanism:
+
+```sh
+go run ./cmd/plan9asmtest -dir=cmd/plan9asmtest -shards=8 -workers=2 \
+  -timeout=15m -out=_out/runner-suite
+```
+
+Require its fresh complete inventory, unique root/child terminals and no failed,
+skipped or incomplete tests. This is a separate partitioned qualification, not
+a pass for a previously timed-out single-binary command. Formal main-module
+ordinary/coverage commands retain45m and race commands60m.
+
+Root scheduling parts do not change the test denominator.
+Unix normal and coverage suites use sixteen root parts over the same32 global
+shards; race uses32 parts over64 shards. Each Unix root job owns exactly two
+whole shards in one two-worker wave, avoiding cumulative multi-wave job limits.
+Command and job budgets are unchanged, and fresh completion requires every
+part plus the original profile/rest owners. Windows keeps all
+three modules independent: sixteen root parts for the main module over
+64 hash shards (four shards per part), four parts per CLI, and one profile/rest
+owner each. Every command retains the thirty-minute budget;
+only complete cross-owner verification publishes the module's coverage. The
+Windows driver binds inherited and explicit `-tags=byollvm` without fallback.
+It selects Go, LLVM22, Node, Python and jq before freezing a minimal tool PATH
+for both execution and aggregation. Ambient hosted Git runtime-bank and WSL
+entries are not inherited. Complete environment equality remains strict; never
+remove PATH from the verifier to accept unrelated execution environments.
+The readonly DATA consumer matrix has three complete target roots, placed in
+different Windows scheduling owners. Each retains all119 operations, all three
+APIs and O0/O2 objects; root splitting is not a reduced test denominator.
+The two current-Go bytealg CLI object owners likewise keep complete Count and
+IndexByte files in separate scheduling owners, each with its own original
+five-minute context. A previous root shared that context across both files;
+the second file's cancellation was a real failure, not source rejection.
+
+Repeated ARM64 byte-carrier matrices share only a parent-test-owned `GOCACHE`.
+Recent Go distributions build builtin observers such as `objdump` there;
+recreating an empty cache for each row repeats that build and can exhaust the
+unchanged one-minute command limit. Each case still captures independent
+original sources, outputs, leases and revocable owners. Do not share those
+mutable observations or increase command budgets to hide cache setup costs.
+
+Static-storage capture retains its actual forced stock-Go compiler prior and
+original command report. Every live Verify still runs a real owned selection
+and export query with the same scope, environment and deadline, but omits only
+the repeated `-a` rebuild. Complete source, tool and archive bytes remain
+checked before and after that command; selected exports and unknown JSON fields
+must still match. This is reuse of Go's compiler cache, never a cached mutable
+observation or capability. Run actual SDKCPU and SDKGlobals target controls,
+source/command mutation, final callback revocation and concurrent Close tests,
+then measure the complete original CLI source before claiming a speedup.
+
+Fixed-local conversion objects keep all741 independent forms on each of three
+AMD64 targets. Twelve top-level batches per target retain64 functions each
+(37 in the last batch), captured as two sources of at most32 functions with
+separate five-minute leases for every API. They retain all three APIs and both
+IR levels. Native execution independently owns all336 cases in seven48-case
+top-level roots with original Go, CPU/OS checks and LLVM O0/O2 execution.
+The inventory policy
+requires every target/batch exactly once and at most three such owners per
+Windows hash shard. A passing batch is not a complete-target receipt: require
+the exact union of all twelve, without skipped or unfinished children.
+
+Each fixed-local API captures, preprocesses, binds and consumes its own complete
+source within the original five-minute stage context, then closes that owner.
+Never reuse another API's lease or cache a mutable Verify result. Wide packed
+objects retain all340 kernels in six complete source packages per API, all three
+optimization paths and independent top-level API owners. Only compiler artifacts
+share a disposable test-process-owned cache; initialize it even when ambient
+GOCACHE is unset. Object-only tool selection checks LLVM22 and the actual
+target SDK/headers without requiring Rosetta, QEMU or a host ISA preflight.
+Original Go compilation, C compilation/linking and native execution remain
+distinct claims; the original native owners keep their real CPU/OS checks.
+
+This lifetime rule also covers complete readonly DATA, AES, transport and
+non-temporal consumers. Keep DATA/GLOBL in the exact preprocessed GoModule input;
+reconstructing only function instructions loses part of that source. Extend the
+existing complete-consumer lease checks when adding a family. Negative tests for
+expired, mutated or closed observations must retain their original binding,
+not silently capture a replacement.
+
+The complete native-wide packed matrix has six required top-level source owners,
+not six children under one shard deadline. Batch selection accepts either no
+selector (the unchanged compile-only/SSE path) or one valid whole source batch;
+empty inventories, invalid indices and multiple selectors fail closed. Keep the
+340-kernel source/C union, original whole Go execution, six values/masks, all64
+result bits, three APIs and three LLVM pipelines. Splitting ownership does not
+raise an API, command or job deadline and is not local native execution proof.
+
+CMOV fixed-local objects likewise retain all384 original kernels per Linux and
+Darwin target in six independently scheduled batches. Runtime keeps all387
+CMOV/GP/SIMD kernels in seven batches, their three optimization paths and actual
+original-Go execution. Require every batch exactly once; a single passing
+batch or structural partition check is not a complete-family runtime receipt.
+
+```sh
+go run ./cmd/plan9asmtest -module -out _out/module-suite \
+  -shards 32 -workers 2 -timeout 45m
+```
+
+Run race tests for changed concurrent code and actual Go 1.20 checks for changed
+root-module code. Current-SDK producer fixtures use explicit `go1.27` build
+roles; historical lanes still test their portable framework. Do not add runtime
+skips or `!llgo` tags to hide incomplete compiler support.
+The rich CLI's separate `cmd/plan9asmll` module declares Go1.24 as its minimum.
+The root's Go1.20 checks and eight-SDK assembler-table audit do not imply that
+this nested module builds with Go1.20; test its declared minimum independently.
+Run the formatting check with the selected current Go toolchain. Limit it to
+tracked sources: ignored `_out/` holds deliberately unchanged historical failures
+and generated observation inputs, not repository formatting targets.
+
+## Native and cross-runtime semantics
+
+The original scalar-precision, unsigned-scalar, FMA-caller and packed-ABS/sign
+native tests support `PLAN9ASM_AVX512_RUNTIME=required|auto`. The default is
+`required`: missing CPU/OS capabilities fail. Windows CI explicitly uses `auto`
+for all execution and completion owners. Only a complete, matching CPUID/XCR0
+receipt with an ordinary capability-unavailable exit78 becomes a reported SKIP.
+Capable hosts still execute the original runtime test. Invalid configuration,
+missing tools, compilation errors, crashes, timeouts, cleanup errors and opcode
+or numerical failures remain failures. Other runtime owners are unchanged.
+
+Instruction-generation, LLVM22 objects and backend-ISA checks stay mandatory
+on every host, independent of this setting. Reports retain skipped roots and
+`completed_with_skips`; object success never certifies skipped native execution.
+Use `PLAN9ASM_AVX512_RUNTIME=required` on a suitable machine for native acceptance.
+
+```sh
+go test . -run '^(TestAMD64ConformanceNativeGo|TestAMD64ConformanceLLVMRuntime)$' -count=1 -v
+PLAN9ASM_CROSS_EXEC=1 go test . \
+  -run '^(TestCrossLinuxRuntimeMatrix|TestARM64Conformance|TestARMIntegerMemoryRuntimeCross)' \
+  -count=1 -v
+```
+
+The cross driver runs on Linux/amd64 with matching cross compilers. Install
+checksum-pinned QEMU 10.2.3 using `bash scripts/install-ci-qemu.sh`, then prepend
+`$PWD/_out/qemu-10.2.3-linux-amd64` to PATH. Ubuntu 24.04's QEMU 8.2 has an SVE
+indexed dot-product bug. For i386 also install `gcc-i686-linux-gnu` and
+`libc6-dev-i386-cross`. Missing tools must fail. Containers need executable
+temporary storage for Go test binaries.
+
+## Official forms and benchmark
+
+An ordinary Go assembler rejection requires actual exit 1 plus a concrete,
+fixture-bound diagnostic. Panic, timeout, signal, unknown output or cleanup
+failure is not rejection evidence. `TestGoAssemblerKnownMalformedInputDefects`
+separately observes known Go assembler bugs without treating them as successful
+form coverage or external-library applicability evidence.
+
+The official gate checks classifications, parse failures and versioned form
+fingerprints. Inspect differences before changing
+`testdata/coverage/go-asm-baseline.json`. Opcode names, observed corpus forms,
+encoder rules, LLVM objects and runtime semantics are distinct coverage claims.
+
+To retry the complete x86 mask-logical family with explicit initialized inputs:
+
+```sh
+go run ./cmd/plan9asmscan -corpus=go-asm -goos=linux -goarch=amd64 \
+  -initialized-context-reprobe=mask-logical -llc="$llc_cmd" -format=json \
+  -out=_out/initialized-mask-logical.json
+```
+
+This opt-in report retains every actual instruction occurrence and its source,
+keeps the original classifications/fingerprint unchanged, and records separate
+IR and LLVM22 object outcomes in batches of at most32 functions. Missing/wrong
+LLVM, failed compilation or missing/wrong-target objects fail the command.
+Synthetic initialized inputs are not original-source or runtime evidence;
+unregistered families and runtime remain explicitly untested. The same profile
+accepts `-goarch=386`, but cannot invent forms absent from that SDK's corpus.
+
+The strict benchmark compiles standard-library assembly for
+`linux/{386,amd64,arm,arm64}` and `js/wasm`. Failures, skips and N/A fail the
+job. Schema-2 summaries retain failed and unattempted counts; missing reports
+remain unknown. Reports under `_out/compile-benchmark/` are never overwritten.
+Default budgets are 300 seconds per target and 900 seconds total. Diagnostic
+overrides use `PLAN9ASM_BENCHMARK_TARGETS`,
+`PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS`,
+`PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS` and `PLAN9ASM_BENCHMARK_REPORT_DIR`.
+Measure before claiming a speedup or changing budgets.
+
+PR Go CI runs `check-stdlib-corpus.sh --instructions-only` with the complete
+SDK/target/profile matrix and official instruction fingerprints. WASM retains
+complete source translation and every LLVM object because its typed stack and
+control flow cannot be checked as isolated instructions. Other architectures
+stop after successful instruction scanning in this mode. Default
+`check-stdlib-corpus.sh` still translates complete source and compiles LLVM
+objects. That same complete matrix and the unchanged strict benchmark run in
+the separate manual/weekly `SDK/runtime integration` workflow. Its failures
+remain failures; this responsibility split does not qualify historical failed
+reports. Required instruction, CLI/object, native, race and coverage owners stay
+in PR CI.
+
+## Frozen verification and PRs
+
+Commit first and keep a tested snapshot unchanged, including documentation.
+Develop in another existing idle worktree while a frozen suite runs. A partial
+suite or older-source pass cannot certify current-head success.
+
+Inspect remotes and upstream divergence before publishing. Push only to the
+allowed fork, create/update the contribution PR, and never directly push,
+merge, approve or close upstream PRs. Batch updates so active frozen runs can
+finish. Keep PRs draft until current-head CI, review and coverage pass.
+
+External scanning, ledgers, exception policies and third-party compatibility
+CI are now owned by [llgo-compat/plan9asm](https://github.com/llgo-compat/plan9asm).
+Do not restore them here or gate instruction tests on their historical pending
+inventory. Independent instruction regressions and required first-party source
+proof tests remain in this repository; moving a workload is not a test pass.
diff --git a/docs/development/x86-asm-text-source-order.md b/docs/development/x86-asm-text-source-order.md
new file mode 100644
index 000000000..53f07c7c3
--- /dev/null
+++ b/docs/development/x86-asm-text-source-order.md
@@ -0,0 +1,34 @@
+# ASM source TEXT and physical object order
+
+Go's assembler `NumberSyms` groups static definitions in the indexed Self bank
+and nonstatic ASM definitions in NonpkgDef. Source TEXT ordinal is therefore not
+the ordinal of the physical TEXT-record array. The observer keeps the original
+namespace/index/relative index, code, PC metadata and relocations unchanged.
+
+`ASMSourceTextOrder` associates every source TEXT exactly once by its normalized
+Go symbol, explicit ABI and registered static/nonstatic namespace role. It
+retains source ordinal separately from physical object ordinal and requires
+unchanged declaration order inside each bank. Unknown namespaces, ABI/kind,
+duplicate/missing records and exchanged physical indices are Context. This is
+metadata only, not entry, caller, register, result or memory authority. Complete
+original/expanded/compiler object and code/PC/relocation equality is still required.
+
+The native listing producer and SDK numerical listing consumer use this mapping
+rather than reordering original records. The numerical consumer replays both
+complete source/member associations, checks the sealed tuple inventory and keeps
+all code, PC and relocation evidence equal before selecting `ObjectOrdinal`.
+Mutation permanently revokes the original numerical source; metadata supplies no
+static-helper or foreign-entry declaration. A downstream frame consumer must
+also use `ObjectOrdinal`;
+its existing ABI0/no-private/no-static declaration restrictions are not relaxed.
+Mixed-namespace/private/ABI-selector frame binding still needs its own complete
+entry and signature model.
+
+The original `equal_amd64.s` has source TEXT order `runtime.memequal`,
+`runtime.memequal_varlen`, `memeqbody<>`, but its physical helper is first. Their
+source-to-object ordinals are `[1,2,0]`. The metadata observation now closes, not
+the complete file translation: the canonical bool must-fact requires a closed
+same-file tail-summary graph, and varlen's real `8(DX)` read needs a separate
+native closure carrier. Numerical capture of a no-DATA source also needs its
+own generated-header/source handoff. These remain explicit Context; no package
+name, target string, metadata mapping or absent initializer supplies those facts.
diff --git a/docs/development/x86-caller-address-compare.md b/docs/development/x86-caller-address-compare.md
new file mode 100644
index 000000000..8de52fb4f
--- /dev/null
+++ b/docs/development/x86-caller-address-compare.md
@@ -0,0 +1,40 @@
+# Caller-address CMP predicates
+
+The ordinary x86 result observer reuses the independent typed caller-address
+must-domain for CMPB/W/L/Q. A register/register row requires two complete
+caller-address origins, including full-word copies of the same input pointer.
+A register/immediate row requires the original caller address and a resolved
+Go immediate in CMP's right-hand position. A numerical register cannot stand
+in for the second address. Numerical-only comparisons retain their old transfer.
+
+The complete `x86ScalarCompareProperties` grammar supplies Go's original
+immediate truncation/sign extension and high-byte/REX physical views. Full actual
+ABI0 pointer imports and ordinary scalar AMD64 register-entry pointers seed the
+domain. Existing validated full-word MOV aliases, address LEA and numerical
+ADD/SUB transforms preserve it. Partial/full overwrites and CFG joins retain
+their existing independent revocation/intersection rules. Unwritten g/DX, raw,
+literal/alignment, opaque non-caller or unknown address state cannot participate.
+An explicitly copied caller address in a scratch register is data provenance,
+not hidden closure/thread/native-entry permission. Physical SP/BP stay Context.
+
+CMP defines original CF/OF/Z/S/P/AF and changes no numerical/canonical GP byte,
+pointer, frame, storage, lifetime, extent, alignment, noalias or native-entry
+fact. The complete must-flow and unchanged canonical zero/one AL requirement
+remain mandatory at every logical bool RET. Source-wide shape validation is
+separate from reaching caller provenance; it never seeds an actual CFG state.
+Other flag consumers retain their own typed effects: LAHF is not newly admitted
+to the whole bool-result proof merely because CMP defines AF.
+
+Independent Go objects cover complete GP byte/native-word views, immediate
+transitions and all existing typed SETcc/CMOV/Jcc consumers. Three LLVM APIs,
+three AMD64 targets and O0/O2 preserve the original typed source. The two required
+Linux/amd64 execution roots compare complete original Go encoder bytes against
+LLVM with the same actual pointer arguments, raw upper-byte/stack/GP/arena
+canaries and an explicit i1-to-i32 shim, and independently exercise genuine
+owned Go ABI0 callers with raw return-word and input-pointer canaries.
+Encoder-fixture selector permission is not SDK/native Go caller ownership.
+Emulated Linux diagnostics and native fork execution are separate evidence;
+host-inapplicable builds or missing tools are not runtime passes.
+
+This class does not close same-file tail helpers, native closure carriers,
+no-DATA SDK observations, numeric index-only LEA or complete equal translation.
diff --git a/docs/development/x86-caller-address-predicates.md b/docs/development/x86-caller-address-predicates.md
new file mode 100644
index 000000000..ce3216ba5
--- /dev/null
+++ b/docs/development/x86-caller-address-predicates.md
@@ -0,0 +1,42 @@
+# Actual caller-address predicates
+
+The bounded x86 result observer retains a separate must-fact for complete actual
+typed pointer arguments, either ABI0 FP imports or the existing ordinary AMD64
+scalar-register entry. This domain is not `pointerGP`: readonly literal addresses,
+mixed OR carriers, native state and partial pointer fields cannot seed it.
+
+Full native-word MOV/copies (including the source-only MOVQ aliases), already
+validated LEA and numerical ADD/SUB address transforms preserve provenance.
+All partial/full typed GP overwrites revoke it; encoder aliases use their actual
+GP destination. Unknown effects revoke all carriers. CFG joins intersect the
+new fact independently of initialized numerical bytes and opaque identities.
+Its sixteen logical state bytes are counted under the unchanged 64-MiB,
+4,096-instruction and 16,384-visit limits.
+
+The complete B/W/L/Q TEST register/immediate grammar reads actual physical
+address bits and defines only original CF/OF/Z/S/P. AF stays undefined. It
+initializes no numerical GP bytes and grants no dereference, extent, alignment,
+escape, GC result or physical native-entry permission. The same typed flag
+consumers and independent canonical bool-byte guard remain mandatory. Native
+compare retries handle only actual memory forms; register-only effects delegate
+to the shared ordinary/caller/literal transfer, with no memory-rule widening.
+
+Independent original Go encoder bytes execute through an explicitly declared
+AX/BX adapter against the same actual pointer supplied to LLVM. Raw upper-byte,
+stack/GP and complete caller-array canaries remain observable; the LLVM caller
+uses only an explicit i1-to-i32 shim, not a C `_Bool` contract. A separate genuine
+owned Go ABI0 caller observes 4,096 actual pointer addresses, raw result words,
+input-pointer identity and adjacent canaries. The standalone `-p runtime`
+encoder fixture is not SDK ownership or native Go ABIInternal caller authority.
+Linux emulated execution and native fork execution remain separate receipts.
+
+The complete unmodified SDK maps source can now compose this domain with the
+authenticated literal minimum and existing conditional native-load/result
+rules. All two TEXTs and DATA remain; mutable AES globals stay genuine external
+runtime loads. Object tests independently compare each LLVM literal definition's
+alignment to the original minimum and existing Go-size rule. No forced align16,
+guessed keys, cropped functions or new loop/bounds promise is introduced.
+Logical LLVM object compilation is not execution of the complete SDK program,
+physical Go entry authorization or benchmark completion. The separate shared
+[frontend handoff](x86-sdk-literal-frontend.md) selects the authentic minimum
+only on typed literal-predicate demand; it does not expand this caller domain.
diff --git a/docs/development/x86-convergence.md b/docs/development/x86-convergence.md
new file mode 100644
index 000000000..e6f8392bb
--- /dev/null
+++ b/docs/development/x86-convergence.md
@@ -0,0 +1,455 @@
+# x86 architecture convergence
+
+The current priority is to finish **amd64** architecture, correctness and
+efficiency before expanding another architecture. Changes to shared x86 code
+must retain 386 regressions. Existing ARM, ARM64 and WASM gates remain enabled;
+this ordering does not remove supported targets or their tests.
+
+## Acceptance, not an opcode-count target
+
+The review of `728520def` found 33/55 selected Linux/amd64 standard-library
+files produced LLVM 22 objects, versus 55/55 at `e2164ac0`. These are historical
+Go 1.27.2 observations, not execution certificates. Retain the original failures
+and repair ordinary-source regressions before declaring this work complete.
+Runtime entry contracts remain a separate integration responsibility; a source
+failure must not be assigned there without identifying its actual cause.
+
+Completion requires all of the following:
+
+- An independent inventory of the selected Go assembler's legacy, AVX and
+  special encoding rows, with their order, attributes and mode restrictions.
+  Opcode names, operand-class buckets and corpus occurrences are different
+  denominators. Neither the production registry nor a changed baseline may
+  define away an unimplemented official row.
+- Explicit ownership of every row: a validated concrete form, an independently
+  observed frontend refusal for that mode, or an unresolved gap. Preserve
+  overlapping rows. A syntax witness alone does not identify its actual VEX or
+  EVEX encoding; compare original bytes when claiming that encoding's coverage.
+- Initialized complete functions through the public APIs, LLVM 22 objects and
+  independent semantic tests. Keep those evidence levels separate. Context,
+  unavailable hardware and unfinished tests never count as successful execution.
+- Whole-source standard-library and independent regression gates alongside
+  family tests. External libraries remain independent checks, not the source
+  from which we enumerate instruction formats.
+- Measured code reduction and translation efficiency for each migrated family,
+  without decreasing its retained format, target or regression inventory.
+
+## Architecture boundary
+
+Normalize named and decoded instructions into architecture-local typed forms.
+Keep encoding identity and original operand roles. Reuse the validated form
+for numerical dependencies, register/FLAGS effects and lowering; do not make
+each consumer rediscover the family and parse its operands again.
+
+Separate the following axes, constraining their legal combinations with the
+official rules rather than constructing an unrestricted Cartesian product:
+
+- Operation and arithmetic mode, including signedness and saturation.
+- Register carrier, active vector, element, source/result and memory widths.
+- Explicit/implicit input roles and old-destination dependencies.
+- Encoding, masks, broadcast and preserved/zeroed register aliases.
+- Memory alignment, access/fault suppression, ordering and machine-state effects.
+- Source mode and the features required by the chosen lowering route.
+
+Portable arithmetic does not automatically require the source opcode's ISA.
+Native memory and floating-point paths may need exact instructions to preserve
+faults, rounding or exceptions. Keep those deliberate exceptions visible.
+
+Grammar and numerical effects describe requirements; they do not establish
+pointer extent, initialized bytes, frame ownership or caller authority. Evolve
+the existing analyses toward shared typed effects with separate numerical and
+address-origin domains. Do not add another instruction whitelist to each proof.
+Physical indexed SP scratch cannot be relabeled as named logical AUTO storage.
+
+Prefer small concrete descriptors and direct dispatch. Avoid a runtime grammar
+interpreter, reflection-based dispatch, or a universal struct of unrelated
+optional fields. Common lowering pipelines retain family-specific operations
+and explicit memory contracts. Delete replaced code in the same coherent batch.
+
+## Work order and measurements
+
+1. Reproduce and repair ordinary-source regressions with independent tests.
+2. Pilot shared packed add/subtract/low-multiply lowering, retaining the complete
+   widths, masks, memory behavior and aliases. Extend only after the pilot
+   demonstrates a smaller implementation and unchanged observations.
+3. Complete the independent rule inventory and initialized-form joins; migrate
+   registration, feature inference and effect consumers family by family.
+4. Move repeated source/tool capture out of numerical lowering using explicitly
+   owned immutable inputs. Do not cache mutable verification results or weaken
+   mutation, expiry, cancellation and Close checks.
+5. Finish all amd64 families and whole-source gates before generalizing the
+   architecture to ARM, ARM64 or WASM.
+
+The first normalization batch covers four existing packed binary families:
+average, word multiply, multiply-add and dword product (20 names). One typed
+spec/form now feeds effects, memory queries, result routing and lowering;
+the replaced consumer selectors are removed. Lowering retains the parsed form,
+while separate analysis invocations still normalize independently. No cache is
+attached to mutable instructions. Input/result widths, pair reductions and
+even-lane products remain explicit: DQ arithmetic uses 32-bit inputs but 64-bit
+memory granules; MADD retains full-tuple reads, distinct from E4 mask suppression.
+Average and word multiply reuse the existing E4 pipeline. Production shrinks by
+65 lines. Both endpoint SDKs pass 101 roots / 10,098 children without skips.
+Paired benchmarks under unrelated host load do not establish acceleration.
+Do not call this whole-translation parse-once completion. A subsequent
+function-local full-form table increased retained memory and slowed the short
+translation comparison, so it was withdrawn before integration. The accepted
+follow-up shares the feature projection without a cache and removes another
+11 production lines. Cross-stage reuse must reduce total complexity and cost;
+do not expand the family scope to justify retaining an unsuccessful abstraction.
+
+The legacy floating dispatcher now loses another 121 unreachable lines after
+its typed owners; FP16 portable lowering remains live and unchanged. Current
+and minimum SDKs pass 168/167 roots and 5,173 children without failures/skips,
+with the Linux/amd64 software-alias runtime owner retained separately. A proposed
+26-line result-routing cleanup regressed paired minimum-SDK measurements and
+was withdrawn. Smaller source alone does not establish faster translation.
+
+The residual binary-floating helpers also drop 43 production lines of obsolete
+f32/f64 input loading. Those families return through their typed owners; the
+remaining portable FP16 and SCALEF paths retain their existing loads and effects.
+Both endpoint SDKs pass all fifty related portable/object roots and 2,183 nodes;
+the current SDK retains the exact executed baseline case IDs. The two original
+host-inapplicable native owners remain separate, without counting their local
+skips as passes. This cleanup adds no registry or cache and claims no speedup.
+
+The next floating normalization joins all 48 named ADD/SUB, MUL/DIV and MIN/MAX
+operations in one typed catalog. Encoding, precision and scalar/packed shape
+select the shared operand grammar; the operation tag selects the existing
+numerical lowerer. Caller admission, operand effects and memory shape consume
+that form. MIN/MAX source identity and guarded result transfer remain distinct
+from numerical arithmetic authority. Three dispatcher chains and the superseded
+f32/f64 binary entries are removed, for a net reduction of 87 production lines.
+Both SDK endpoints retain all 74 local roots and 2,183 case IDs. Paired ABBA
+complete-translation measurements retain allocation counts; median time differs
+by -0.13% on current Go and +1.03% on minimum Go. This is code convergence,
+not an observed speedup. The separate native Linux/amd64 qualification retains
+36 roots / 774 PASS nodes per SDK, with no failures/skips. Full-head CI remains
+a separate gate; native386 and AVX512/ER acceptance are not implied.
+
+The physical mode32 boundary subsequently converges too: ADD/SUB now uses the
+same high-register check as MUL/DIV and MIN/MAX, removing another twelve
+production lines. Independent original-Go spelling and AMD64 positive controls
+cover all 108 operation/width/register-role cases; source acceptance does not
+grant physical IA32 high registers. The original complete-source fixture keeps
+every source row and explicitly partitions 44 contextual high-bank rows on 386.
+The local union passes 93 roots / 2,526 nodes per SDK. Final paired ABBA timing
+changes by -0.23%/-0.73%, with essentially unchanged allocation counts. This
+does not certify native386 execution or establish a measured speedup.
+The separate repair qualification at `a824274f3` retains the same 36 native
+Linux/amd64 roots / 774 PASS nodes per SDK, zero FAIL/SKIP, with the complete
+product source manifest bound to `e97ae1d32`.
+
+For each batch record the exact revision, SDK, LLVM version, source fixture,
+successful/failed counts, production/test line delta and retained case IDs.
+Measure parsing, analysis, feature inference, IR generation and public
+translation separately, including allocations and resource release. Keep
+external commands out of microbenchmarks; measure their cost in the complete
+source/object workload as well. Never report early rejection as a speedup.
+
+Benchmark identical inputs before and after, with repeated samples and unchanged
+tools. Preserve vector IR and independently check generated-program performance.
+Do not clear global compiler caches. Batch LLVM tests with bounded modules and
+prompt disposal; batching must preserve every test case, not sample the suite.
+
+The next packed arithmetic batch joins all 36 add/subtract/D-Q low-product
+spellings (35 canonical opcodes) in one typed catalog. The existing binary
+grammar continues to own operand formats; operation, element width, saturation,
+encoding and broadcast remain separate fields. Add/subtract effects and result
+queries normalize once per invocation instead of probing two family parsers.
+Private wrapping-add admission, legacy MMX projection and raw mode32 low-product
+adaptation retain their separate contracts. Numerical lowerers, E4 handling and
+the base binary grammar are byte-identical to `ab900f0c0`. Replaced catalogs,
+switches and selectors are removed in the same batch: 80 fewer production lines.
+
+Read-only legacy queries avoid a redundant operand copy, and physical GP-to-MMX
+bank projection uses constant register names. TDD first reproduces redundant
+allocations and three query-boundary defects; the corrected queries return empty
+metadata on family misses, preserve bare-name compatibility and reject mismatched
+source identities. Both Go 1.27.3 and Go 1.20.14 retain all 5,751 original local
+case IDs and pass the full 66-root / 5,791-node scope. Native PADDD execution is
+not counted as a local pass. Complete extraction and five-target gates remain.
+
+Three ABBA blocks give six samples per revision and SDK for each of 49 unchanged
+benchmarks: 31 complete translations and 18 feature queries. Across the complete
+translation cases, the geometric mean of median timing ratios changes by -0.58%
+on current Go and -0.07% on minimum Go. Two legacy arithmetic kernels remove
+about 320 allocations per translation; the other translation allocation counts
+remain stable. The twenty neighboring translation cases change by -0.20%/+0.25%.
+These observations support code convergence and lower allocation cost, not a
+statistically established translation speedup or native execution improvement.
+
+The subsequent internal-dispatch cleanup removes 389 more production lines:
+seven vector arms (200 lines) and the old ADC/SBB arms (189). Their complete
+typed owners already intercept success and recognized errors inside the same
+function, including direct private-helper calls. All handler/effect/native code
+and entry prefixes are unchanged. The remaining private-entry duplicates are
+handled by the separate callback migration described below.
+
+Before and after deletion, both endpoint SDKs pass the same 26 local roots /
+357 case IDs. The original wider attempt retains its host-native preflight skip
+separately. Complete CLI extraction retains all 74 roots / 222 nodes; scanner
+context controls pass four roots / 628 nodes on each endpoint. All 574 Node
+policies, 31 preflight roots / 484 nodes and both five-target gates pass.
+This is removal of duplicate code, not a new numerical implementation, native
+execution certificate or measured translation speedup.
+
+Scalar shift/rotate lowering now consumes the existing validated form's width,
+count, source and operand indices through both ordinary and double shifts.
+It removes 49 production lines of repeated mode, arity and operand validation.
+The early Group2 membership gate still excludes every BMI2 spelling, including
+malformed or mismatched instructions, before any value or memory emission.
+The numerical and FLAGS emitters retain count0, carry rotation, W double-shift
+count16 and the finite choice for undefined counts17–31. The existing 32 Group2
+names / 120 rows and six double-shift names / eighteen rows remain unchanged.
+
+Both endpoint SDKs retain every original local case ID and pass 43 roots /
+10,890 nodes, including 49 new family-boundary nodes. Complete CLI extraction
+passes on current Go and its Go1.24.11 minimum; the additional Go1.27 SDK math
+owner is available only on current Go. Node, preflight and five-target gates pass.
+Seven Group2 and one BMI2 benchmark kernels return actual I64 ABI0 results;
+the separate existing GP control retains its Void/control-flow workload.
+The initial local paired rounds disagree, including unchanged controls; retain
+them as inconclusive observations. A subsequent controlled Ubuntu/amd64
+comparison completes three ABBA blocks on both SDKs, six samples per revision
+and kernel. The seven Group2 kernels have a geometric mean of median timing
+ratios of 0.99735 on current Go and 1.00027 on minimum Go, with unchanged
+allocation counts. The BMI2 and GP controls retain their separate workloads.
+These 216 samples observe no material timing change within this narrow scope,
+not a speedup or whole-source/native performance certificate.
+
+The following private-entry cleanup deletes 599 more production lines of
+duplicated INC/DEC, conditional SET/MOVE and Group2 lowering, including the
+superseded double-shift helper. The public dispatcher already reaches the
+complete typed owners first. Five fragment-test callbacks now call those same
+owners; every original operand, signature and numerical/error assertion is
+retained. The only other production entry into the residual arithmetic helper
+is the unchanged LEA projection. No compatibility dispatcher, registry or cache
+is added. Both endpoint SDKs retain the exact 125-root / 22,100-node inventory:
+22,093 PASS and seven host-native SKIPs each. Two additional Linux/amd64 owners
+are outside the local build. These remain separate from execution acceptance.
+The inherited minimum-SDK unsupported form also remains explicit.
+
+## Independent rule inventory
+
+The official scanner includes the selected SDK's ordered `asm6.go` `optab` and
+`ymovtab` under `legacy_encoder` for both amd64 and 386. It retains duplicate
+operand rows, nil-ytab special entries, sentinels, full opcode payloads and
+symbolic attributes separately from the existing AVX inventory. This is a
+declaration inventory, not proof of mode applicability or selected encoding.
+
+```sh
+go run ./cmd/plan9asmscan -corpus=go-asm -goos=linux -goarch=amd64 \
+  -format=json -out=_out/amd64-official-rules.json
+```
+
+`table_row_fingerprint` hashes normalized retained table rows. It deliberately
+does not claim to hash constant definitions or all assembler selection logic.
+No original corpus classifications or AVX fingerprints change when this
+inventory is added. Row-to-initialized-form joins and original-byte selection
+witnesses remain separate work; do not count inventory rows as passing tests.
+
+## First pipeline pilot and next gate
+
+The shared E4 pipeline retains family-specific parsing and storage checks, then
+handles operand reads, arithmetic, masking and encoding-aware writeback once.
+Legacy memory still uses its original faulting opcode. MMX and word low-product
+multiplication retain separate owners. The three migrated lowering files plus
+their helper shrink from 403 to 346 lines; this is not the whole PR's line delta.
+The subsequent cleanup removes another 143 lines of unreachable packed
+arithmetic from the residual vector dispatcher. Its original fixtures now call
+the same typed owners as public lowering; 66 roots / 4,506 children passed with
+no skips at `481291b93`. This is code reduction, not a measured speedup.
+
+Integer min/max now reuses that E4 pipeline and removes another 39 production
+lines. Both endpoint SDKs retain all 34 original owners / 743 children and the
+full rule suite. The initial eager mnemonic conversion added allocations and
+was withdrawn; the accepted version converts only actual legacy memory forms.
+Paired timing directions remain mixed, so no acceleration is claimed.
+
+Uniform and per-128-bit byte shifts extend the existing byte grammar with two
+transport axes: immediate opcode-extension literals use vvvv for destination,
+while uniform counts keep X/m128 independent of data width. The immediate
+rotate family reuses that transport without gaining uniform-count forms. All
+bytes still derive from original SDK payloads; numerical lowerers and memory
+permissions do not follow from these test-format capabilities. Duplicate moves
+reuse the unary transport, preserving DDUP.X's m64 tuple separately from the
+full-width SHDUP/SLDUP tuples. Immediate word/dword shuffle uses the distinct
+`i_rm_r` role format: destination in ModRM.reg, reserved vvvv, and an imm8 tail.
+It cannot inherit the shift/rotate opcode-extension operand role or their
+mandatory prefix. PSHUFL and PSHUFD retain distinct original Go table rows;
+neither spelling is silently deduplicated. Only the dword shuffle admits its
+official broadcast forms. These two additions change no numerical lowerer or
+input initializer. Reciprocal14 then reuses the existing typed native floating
+helper: packed/scalar shape, precision, mask, copied upper bytes and old low
+bytes remain separate fields. The original opcode preserves approximation,
+ambient MXCSR and native fault semantics. Its actual O2 objects retain both
+ordered estimates and dead-result native memory operations; a pure numeric
+intrinsic with an ordinary load did not. The core removes 176 implementation
+lines including format changes; 45 further lines add private boundary and frame
+transfer support, leaving a net reduction of 131 without a new interpreter.
+The boundary-only adapter validates lengths and reserved fields but returns no
+semantic instruction. Frame permissions still require the original envelope,
+byte initialization and owner. Sixty ordinary and six original SP/BP statements
+have actual three-API objects; two pointer-as-index forms retain explicit Context.
+Native numerical/fault
+execution still lacks an independent RCP14 owner and hardware acceptance.
+The unique local union reaches 2,073 rows / 7,758 witnesses,
+with overlapping rotate views
+deduplicated. This is initialized-source/object ownership, not complete amd64
+implementation or native execution coverage.
+
+The selected Go 1.27.2 tables contain the following independent pilot rows:
+
+| Family | Legacy XMM | AVX | Total |
+|---|---:|---:|---:|
+| Wrapping/saturating add | 8 | 64 | 72 |
+| Wrapping/saturating subtract | 8 | 64 | 72 |
+| D/Q low product | 1 | 14 | 15 |
+| Pilot | 17 | 142 | 159 |
+
+Seven PADD MMX rows and ten PMULLW/VPMULLW rows are outside this migration,
+not unsupported or newly verified. PADDD's frontend alias adds no encoder row.
+The initialized join now retains row identity, not deduplicated instruction
+text. High AMD64 registers force EVEX X/Y encoding; the independent original
+Go bytes must match the selected official row. The shared encoder and public
+three-API harness use bounded batches of 32 functions. Current Go 1.27.3 and
+minimum Go 1.20.14 both pass the following Linux/amd64 LLVM22 object scopes:
+
+| Scope | Official rows | Concrete format witnesses |
+|---|---:|---:|
+| Add/subtract/D-Q low product | 159 | 480 |
+| Signed/unsigned integer min/max | 132 | 432 |
+| Rounded average, products and multiply-add | 90 | 258 |
+| Integer and PS/PD logical | 132 | 504 |
+| Integer and PS/PD unpack, low/high | 108 | 360 |
+| Signed/unsigned saturating pack | 36 | 114 |
+| Per-lane logical/arithmetic shifts | 64 | 236 |
+| Conditional sign, B/W/D | 9 | 18 |
+| Packed absolute value, B/W/D/Q | 33 | 108 |
+| Byte-indexed shuffle | 9 | 24 |
+| Integer EQ/GT compare | 72 | 168 |
+| Mask blend | 36 | 144 |
+| Horizontal integer add/subtract | 18 | 36 |
+| FMA3 | 360 | 2,028 |
+| AVX whole-vector moves | 144 | 306 |
+| Ordinary AVX floating binary | 132 | 684 |
+| Local total | 1,534 | 5,900 |
+
+Published `1c54c530e` contains 865 rows / 2,774 witnesses, including all eighteen
+horizontal integer rows. Its complete CI now passes 325/325 jobs and Codecov,
+with 88.0% main statement coverage. The combined local batch adds ABS
+and FMA3 without changing translator production code. Both endpoint SDKs pass
+all prior joins, existing initialized/negative owners and the new complete-row
+objects: current 112 roots / 9,018 children, minimum 111 / 9,018, no failures/skips.
+Previous witness fields and initialized FMA axis sources remain identical.
+See [current work](current-work.md) for exact revisions, native boundaries and
+publication status.
+
+The subsequent AVX move join adds 144 ordered rows and 306 witnesses: 276
+ordinary initialized forms and 30 early terminal faults. Both endpoint SDKs
+pass 114 host-applicable roots / 1,765 children without failures/skips. The
+102 load-register alternatives shadowed by preceding store rows retain explicit
+selection mappings; they reference existing regcopy byte checks and are not
+double-counted. Legacy moves and native execution remain separate owners.
+
+The ordinary AVX floating join at `ff2f14caa` adds all 24 PS/PD/SS/SD
+ADD/SUB/MUL/DIV/MIN/MAX members through the same initializer and object driver.
+It adds 18 shared harness lines for scalar prefixes and register-only SAE;
+no translator rule or native framework changes. Both SDKs pass the complete
+affected scope, 114 roots / 2,004 children, without failures/skips. Previous
+row fields remain identical. Original MIN/MAX NaN, signed-zero, MXCSR and fault
+execution remains separate unfinished work.
+
+Two PADDD alias witnesses are separate from the canonical counts. Min/max
+includes 48 non-Q, unmasked, narrow EVEX forms; low-register VEX objects cannot
+substitute for them. These are initialized named-source/object checks, not raw
+decoder or executed-semantic coverage of every row. Complete legacy/AVX mode
+applicability and remaining family joins are still required; do not divide this
+pilot by unfiltered encoding-table rows to claim an architecture percentage.
+
+The logical join shares the existing row grammar, original-byte verifier and
+three-API object driver. Prefix, carrier width and VEX/EVEX identity are
+orthogonal encoding axes; impossible VEX512 and conflicting prefix forms fail.
+Its 32 names need 19 additional implementation lines, not 504 separate rules.
+The seven average/product and four logical MMX rows keep separate region owners.
+The residual dword-product dispatcher also loses 40 unreachable production lines;
+its original direct fixtures now invoke the same typed owner as public lowering.
+
+The unpack join covers 24 names through the same row grammar and driver, adding
+ten scope-selection lines and no translator rule. All original Go bytes and
+initialized objects pass on both supported endpoint SDKs. Six MMX rows retain
+their independent region owner; this join does not expand native execution
+claims or weaken low-MMX m32 versus high-MMX m64 memory-width distinctions.
+
+Saturating pack reuses that same grammar and driver for eight names, 36 rows
+and 114 witnesses, adding seven scope-selection lines. Dword inputs alone
+admit its 18 broadcast witnesses; three MMX rows remain independent. Both
+endpoint SDKs pass the complete initialized join and rule-reader regression
+at `d17e46d5d`, without expanding the translator or native execution claims.
+
+The pack parser at `25555b5f0` also shares physical normalization with the four
+average/product families, removing 20 production lines. It preserves mode32
+error classification, MMX operand ownership and E4NF memory behavior. Current
+and minimum SDKs each pass 33 roots / 1,211 children; sixteen parser benchmarks
+each remove one allocation and show 9–31% lower median time over five samples.
+This measures parsing, not complete-source translation or native instruction speed.
+
+The per-lane shift join at `376a9f4d0` adds nine names, 64 rows and 236 witnesses
+through the existing binary grammar and object driver, with no translator rule.
+Both endpoint SDKs pass 30 roots / 394 children. A shared test inventory removes
+repeated family loops while preserving independent official membership, literal
+encoding anchors, unique row IDs, width/encoding axes and separate MMX owners.
+The complete batch removes 126 net lines. Its 54 broadcast witnesses and narrow
+EVEX forms are object evidence, not new native execution acceptance.
+
+Conditional sign at `2c2c98295` adds all six B/W/D names: three legacy and six
+VEX rows, 18 register/memory witnesses and six independent byte anchors. Go has
+no MMX, EVEX or broadcast row for this family. Sharing the anchor assertion loop
+with UNPACK and per-lane shifts preserves their original 19 byte anchors. The
+complete rule reader, new object owner and listing-identity negative pass on
+both endpoint SDKs: 25 roots / 88 children each. This adds 17 net lines across
+six files, with no translator rule or new native execution claim.
+
+Packed ABS adds all seven named members, 33 original rows and 108 witnesses.
+The unary adapter retains reserved VEX.vvvv/EVEX.V', width, broadcast, masks and
+zeroing, while typed effects retain the independent old-destination reads.
+It reuses the original ABS/sign initialized source and the bounded byte/API/
+object driver, without changing translator production code or native fixtures.
+At `b5ca7da71`, the full affected scope passes 60 roots / 1,048 children on
+Go1.27.3 and 59 / 1,048 on Go1.20.14, zero failures/skips. The syntax-metadata
+follow-up `65ef2b9bf` passes 4 roots / 43 children on each endpoint SDK and the
+complete Node/Go preflight. Every field of the previous 865 rows / 2,774
+witnesses and the two PADDD aliases remains identical on both SDKs. Existing
+portable numerical execution remains separate from original x86 native evidence.
+
+Fixed-frame GP analysis now consumes the existing typed byte/FLAGS effects
+instead of a second arithmetic opcode list. Its bounded worklist intersects
+numerical definedness across loops while retaining exact address identities.
+All eight original SP residues and the independent final replay remain checked;
+provisional loop accesses are published only after convergence. Numerical LEA
+and sized NOP addresses are not mislabeled as actual memory accesses. Ordinary
+typed-input base/displacement reads now compose with private scratch through
+the existing exact-width faulting scalar path. Full-word affine operations can
+now retain that input's origin without converting its representation to NUM or
+granting a pointee extent. Indexed private scratch retains its separate limits.
+BP/R14 entry bytes stay unknown; a defined value may use the complete GP bank.
+Named LEA and scalar MOV share machine grammar with ordinary consumers, while
+source-role filtering stays separate. An exact native-input access selects the
+fault-preserving scalar emitter even through BP; it is never a private-frame
+certificate. Full-source and native tests remain separate gates.
+
+Fixed-local result consumers now share a call-local independently parsed
+original file and complete ordered feature index. Public module entry/exit
+still perform live source verification; standalone internal consumers retain
+their original guards. This reduces repeated source/tool work without caching
+mutable verification or removing per-function proof replay. The measured
+one/four-function API fixtures keep exactly two verification rounds; complete
+standard-library translation has not yet shown a speedup.
+
+The new result-mask helper emits five vector IR instructions instead of a
+lane-wise sequence. This is not a five-machine-instruction or constant-runtime
+claim: LLVM may split its predicate vectors. Shared splat formatting has constant
+allocation count but necessarily linear output size. Keep the independent
+runtime oracles and measure generated-program performance on actual AMD64
+hardware before claiming that whole-axis improvement.
diff --git a/docs/development/x86-direct-tail-source.md b/docs/development/x86-direct-tail-source.md
new file mode 100644
index 000000000..e7e5671f8
--- /dev/null
+++ b/docs/development/x86-direct-tail-source.md
@@ -0,0 +1,104 @@
+# Whole-source x86 direct-tail continuations
+
+An exact same-file `JMP helper<>(SB)` is a source control-flow edge, not a
+callable helper ABI. In particular, copying a root's signature or giving a
+helper zero arguments loses the root's SI/DI, vector and FLAGS state. Shared
+helpers can be reached by roots with different actual parameters and result
+layouts; each invocation must retain its own root's state and RET contract.
+
+`PrepareX86DirectTailSource` observes the complete parsed file and returns a
+request-local copy with a private continuation graph. Original TEXTs,
+instructions, operands, Raw spelling and source ordinals are not rewritten.
+Each graph point retains its original TEXT/instruction coordinates. Lowering
+places these points in the root's own CFG; it emits neither a callable helper
+function nor manually replayed helper registers.
+
+The graph uses the existing mode-bound instruction effects, numerical and
+opaque-pointer domains, must-state joins, canonical bool proof and FLAGS/vector
+effects. AMD64 explicit ABIInternal roots retain only the existing scalar
+register contract. AMD64/386 ordinary roots retain only their own declared
+logical ABI0 fields. The 386 graph does not inherit AMD64 register-entry facts.
+Root layouts are never merged: identical helper spelling gives no result
+padding, additional parameter bytes or caller/native-frame storage.
+
+Only roots with a private-tail source edge receive graph views. Unrelated
+functions retain their registered lowering, including supported framed/CALL
+consumers. The complete unchanged file is checked through shared lowering
+before KeepFunc or partitioning; an unsupported unrelated function cannot
+silently disappear. All original helper references are audited even when a
+root or instruction will later be dropped.
+
+The first continuation class is call-free and zero-frame. It rejects missing,
+duplicate, aliased, offset and indirect targets, helper CALL/address/DATA
+escapes, unowned helper TEXTs, raw/native instruction roles and physical
+SP/BP/physical-PC/frame addresses. Go's relative Ybr operands instead retain
+their original same-TEXT virtual Prog coordinates: labels do not count, while
+PCDATA/FUNCDATA/PCALIGN do. Hints remain the exact Yi0/Yi1 forms, and malformed,
+overflowing or cross-TEXT targets reject before lowering.
+It adds no Go closure DX, g/thread/TLS, native entry,
+caller extent, alignment, write or numerical pointer-bit permission. Existing
+explicit X86TailGroups keep their independent source contract. Numerical/TLS
+binding composition requires a separate exact original-node association and
+remains Context here. Standalone Func queries without whole-source information
+do not acquire graph authority.
+
+An ordinary external tail has its own terminal role, with an actual declaration
+or explicit signature and exactly compatible mode-bound ABI0 Args, result and
+Frame roles. Descriptive field names supply no layout. Undeclared targets cannot
+borrow the root signature; offsets, ABI selectors, custom registers and changed
+symbol/type/layout identities remain rejected. The LLVM call returns the actual
+callee result rather than inventing initialized root FP bytes.
+
+Graph-local integer result addresses retain an exact scalar slot and interior
+offset, separately from numerical and incoming-pointer domains. Only full-word
+copies, constant same-slot LEA and bounded scalar moves consume them. Different
+joins or overwritten aliases revoke the identity; padding, parameter storage,
+address escape, indexed access, comparison and vector transport do not gain
+permission. Result writes followed by ordinary native memory access or an
+external terminal remain Context, so fresh logical LLVM backing cannot hide a
+native caller alias observation. Original operands/certificates stay unchanged.
+
+The same private integer slot domain also applies to ordinary zero-frame,
+call-free ABI0 roots with their own actual scalar result layout. A named FP LEA
+requires the complete cached source proof even without a later vector probe.
+Mode32 X/m64 moves retain their real eight-byte width through the complete
+GP/X grammar; this gives neither mode32 GP qwords nor MMX any state. Public
+declaration-only queries and independent bool/native-frame roles stay closed.
+Parameter-only source without a result LEA does not acquire this new admission
+trigger or result-slot state; its older missing-result admission gap remains a
+separate unresolved class, not a result-alias success.
+
+Every request keeps independent original-source/signature snapshots and
+verifies source, selected DATA/GLOBL/prelude, TEXT membership, mode and symbol
+mapping before and after callbacks/consumption. A failed graph identity check
+permanently invalidates that prepared graph; restoring public fields cannot
+revive it. Concurrent owned LLVM contexts may read the same unchanged original
+File without mutating it or sharing mutable graph state. Text-only `Translate`
+owns and releases a separate LLVM context per request, so it does not share
+LLVM GlobalContext across concurrent text requests. Module-returning default
+APIs retain their global-context boundary; concurrent module callers must use
+the explicit caller-owned-context APIs and dispose each module before its context.
+
+Combined root/helper work keeps the existing 4096-instruction,
+16384-fixed-point-visit and 64-MiB logical byte-work envelopes. Shared helpers
+count separately for each root's actual state; no per-helper or per-root extra
+budget is introduced. These are work envelopes, not claims about peak RSS.
+
+Independent tests retain whole original-Go files, differently typed roots,
+renaming, chains and diamonds, unknown/partial/overwritten state, canonical
+bool and frame/pointer controls, full-source filtering and mutation controls.
+The object class covers AMD64 Linux/Darwin/Windows and 386 Linux/Windows,
+all three public APIs and O0/O2. Required Linux AMD64 execution owners are
+`TestCrossLinuxRuntimeMatrixAMD64DirectTailWholeSourceOriginalGoAndLLVM` and
+`TestCrossLinuxRuntimeMatrixX86DirectTail386OriginalGoAndLLVM`; i386 uses the
+kernel compatibility ISA and a required static cross compiler. Emulated local
+execution is diagnostic and cannot replace these native counterparts.
+
+The independent follow-up owner
+`TestCrossLinuxRuntimeMatrixX86DirectTailPCResultAliasesAndExternal` executes
+both x86 modes' complete original Go files and three LLVM APIs at O0/O2, with
+independent references and caller canaries for all three roles.
+
+This mechanism does not close the complete equal source's closure/entry
+contract or authenticate an SDK numerical/native handoff. Offline Go objects
+and immutable source graphs do not manufacture those separate permissions.
diff --git a/docs/development/x86-explicit-continuation-results.md b/docs/development/x86-explicit-continuation-results.md
new file mode 100644
index 000000000..398918404
--- /dev/null
+++ b/docs/development/x86-explicit-continuation-results.md
@@ -0,0 +1,52 @@
+# Explicit x86 continuation results
+
+`Options.X86TailGroups` remains an explicit assembly-only closed-target
+contract. It is not the automatic direct-tail producer or a Go declaration
+permission. `GoModuleOptions` has no corresponding producer; an ordinary Go
+binding cannot reconstruct this role from helper `func()` declarations.
+
+The existing coalescer supplies the actual root's instructions, labels and
+indirect destinations. A request-local seal binds the complete original and
+coalesced files, signatures, resolver uses, tables, target and instruction
+ordinals. Every derived instruction retains its entire private tuple as well
+as its exported source spelling. Copied graph/flow tokens, changed source or
+plans fail permanently. Final resolver callbacks are followed by the same
+complete guards; no user File is mutated.
+
+Both x86 modes consume that graph through the shared bounded must-state
+observer. Every indirect edge includes every named helper, retaining root
+GP/vector/FLAGS state and checking all result bytes at every reachable RET.
+Initializers share the same request work budget. Helpers never acquire root
+signatures, callable entry state or another root's logical frame.
+
+Code targets and table addresses are separate opaque identities, never NUM,
+incoming pointers or initialized pointees. Complete private mutable GLOBL
+tables have one ordinary void initializer, optional NOPTR only, and complete
+full-word code writes at every initializer RET. Calling the initializer before
+dispatch remains the existing explicit caller contract, not an inferred fact.
+The table's finite values do not enter the numerical BSS/literal directory.
+Partial/vector reads, arithmetic, FP/native escape, unknown stores and
+unclassified symbol aliases remain Context. A paired ordinary scalar output
+store needs its actual incoming Ptr and defined data; it grants no extent or
+logical result write, and revokes subsequent possibly aliased table loads.
+
+This bounded code-address consumer admits the existing Linux/Darwin/Windows
+AMD64 and Linux/Windows 386 target profiles only. An additional OS/ABI needs
+an actual pointer-width observation, not a mnemonic or target-name exemption.
+x32, unknown profiles and mismatched source/target words remain Context;
+wasm never receives blockaddress. Other numerical translation is unchanged.
+CALL, physical SP/BP, raw/native roles, result bool canonicality and independent
+numerical/TLS owners do not gain a new contract here.
+
+Portable tests retain the original borrowed-frame and LLVM roots, independent
+whole-source negatives, both historical/current Go assemblers and five-target
+three-Options-API LLVM IR/backend O0/O2 objects. Native execution is separately
+owned by `TestCrossLinuxRuntimeMatrixX86ContinuationWholeCFGOriginalGoAndLLVM`
+on Linux/amd64, with original Go and LLVM for both ISAs and memory/register
+dispatch. A missing static i386 compiler or kernel execution support fails.
+Local Darwin qualification does not certify this native axis.
+
+The existing required physical source-stack numerical runtime owner now
+publishes distinct amd64/386 children on native Linux/amd64 without selecting
+the unrelated wider cross-runtime matrix. Explicit cross execution retains
+its original QEMU route; neither route skips missing required tools.
diff --git a/docs/development/x86-numerical-effective-address.md b/docs/development/x86-numerical-effective-address.md
new file mode 100644
index 000000000..e68eb5ca5
--- /dev/null
+++ b/docs/development/x86-numerical-effective-address.md
@@ -0,0 +1,51 @@
+# Numerical x86 effective addresses
+
+Go's LEAW/LEAL/LEAQ share the complete `ym_rl` row (`Zm_r`, byte advance one,
+`Ym, Yrl`) and opcode 0x8d, with Pe/Px/Pw prefixes. Q has no 386 encoding.
+The common LEA grammar retains Go's physical bank, SIB and displacement rules;
+amd64 LEAL truncates its displacement, while W/Q require signed int32 and 386
+also admits uint32. A bare resolved integer expression has NAME_NONE memory
+syntax but LEA computes its displacement without reading memory. Its local
+operand normalization preserves original opcode, Raw and certificate identity.
+
+The typed numerical effect reads only the actual base/index register bytes and
+writes the destination after every read. Modulo-W/L/Q results need only those
+low input bytes; W preserves the remaining destination bytes and L clears its
+upper32. FLAGS are neither read nor changed. Initialization, canonical bool,
+caller-address overwrite and carry consumers share that same effect. Computed
+bytes are not canonical zero/one; unrelated canonical bytes survive and L's
+cleared high bytes remain known zero. Existing complete CFG joins and budgets
+are unchanged.
+
+Decoded physical forms and valid physical SP/BP operands remain delegated to
+their already registered exact source-stack/native consumers. This numerical
+registration supplies none of those facts and does not intercept their FLAGS
+handling. Unbound public paths still require Context.
+
+Only initialized numerical registers participate. FP/AUTO/SP/BP, SB/PC,
+segment/TLS, decoder/address-size overrides, native/opaque/literal addresses,
+unknown register inputs and unknown displacements obtain no numerical value,
+memory extent, alignment, backing, entry or native g/closure permission.
+The separate full-word typed caller-address LEA remains independent; a numeric
+base cannot launder a pointer index. Dead unknown LEA cannot borrow the ordinary
+pure-GP unknown-value fallback. The complete original source is still checked.
+
+ABI0 result queries also require each parameter slot's index and scalar leaf
+type to agree with its supplied argument, including the actual nested struct
+or array extract path. Official flattened scalar parts remain valid. Duplicate
+leaf roles and contradictory pointer/integer metadata grant no entry facts;
+this consistency check supplies no declaration or physical-layout authority.
+
+Tests bind both actual Go SDKs' complete LEA rows and accept/reject forms,
+physical banks, W/L/Q aliases, initialization holes, canonical results, FLAGS,
+source identity and all three APIs/five x86 targets/O0/O2 objects. The required
+Linux AMD64 root is
+`TestCrossLinuxRuntimeMatrixX86NumericalLEAOriginalBytesAndLLVM`.
+It executes original Go bytes through an explicit AX/BX adapter and compares
+independent numerical and six-FLAGS references with LLVM on all three APIs and
+O0/O2. Its LAHF status diagnostic uses the existing scalar lowerer; it does not
+extend LAHF's must-defined or canonical-result contract. Each owned batch has
+at most 64 functions, releases LLVM objects/processes and retains stack/GP
+canaries. Host-inapplicable build selection is not execution evidence; emulated
+local execution is not native ISA certification. This closes no whole SDK
+equal helper graph, hidden DX closure or native-entry contract.
diff --git a/docs/development/x86-register-bool-result.md b/docs/development/x86-register-bool-result.md
new file mode 100644
index 000000000..0197f187e
--- /dev/null
+++ b/docs/development/x86-register-bool-result.md
@@ -0,0 +1,107 @@
+# Canonical x86 bool results
+
+The ordinary scalar-register lowering role accepts one logical `i1` result
+only when the complete explicit ABIInternal source proves AX's physical low
+byte is initialized and exactly zero or one on every path to RET. The actual
+Go logical signature, scalar input register assignment and result field must
+still agree. Bool inputs, tuples, spills, FP/AUTO backing, raw directives and
+hidden/native entry state retain their independent Context boundaries.
+
+Per-byte canonicality is a separate must-fact from initialization. Complete
+typed SETcc, scalar moves (including source-only MOVD/MOVDQ2Q aliases),
+extensions, conditional moves and AND/OR/XOR preserve only proven canonical
+bytes; other writes revoke the affected facts. Reads, FLAGS, source shape and
+memory are first validated by the independent typed transfer. Joins intersect
+both domains, and the existing finite byte-work budget counts the additional
+state without increasing its limit. No known low byte initializes unknown GP
+upper bytes. Arbitrary initialized bytes 2, 3 or 255 cannot gain a logical bool
+by truncation to `i1`.
+
+Execution tests keep two independent axes. The complete actual Go assembler
+ABIInternal instruction bytes execute through an explicit test-only AX/BX
+adapter with raw-u64, stack and GP canaries. Standalone `-p runtime` grants
+encoder-fixture selector permission only: it is not a captured SDK source,
+native Go caller certificate or runtime-path masquerade. LLVM calls the
+translated `i1` function through an explicit `i1` to `i32` shim, with C crossing
+only integer signatures; this is not a C `_Bool` ABI assertion. A separate owned
+Go package executes genuine ABI0 bool callers and observes their original raw
+return byte and canaries, including noncanonical 2/3/255 raw-byte controls that
+are never normalized through a bool call. Linux/amd64 is the required execution
+counterpart when local AMD64/Rosetta execution is unavailable.
+
+This role neither binds the linked SDK literal-minimum-alignment producer nor
+exposes a linked address as a number. Full original maps functions remain
+subject to their linked-low-bit, caller, pointer, loop and native-entry contracts.
+
+## Explicit mode32 logical register result
+
+An independent lowering-only role consumes complete explicit `ArgRegs` with
+one logical I1 return in AX, no ABI selector, zero frame/argument extent and
+no FP slots. Each unique registered word carrier receives only its declared
+I1/I8/I16/I32 bytes; Ptr supplies opaque address identity, never numerical
+bytes or backing. Only an actual I1 input starts canonical. The shared bounded
+CFG and canonical-byte transfer require AX's low byte to be zero/one at every
+RET; unknown upper bytes and initialized 2/3/255 remain distinct.
+
+The existing complete typed mode32 CMPXCHG B/W/L/8B emitter can supply its
+conditional numerical outputs and defined status flags after its preserved
+native memory opcode continues. Every explicit/implicit data input and pointer
+address is checked; LOCK must be adjacent to the complete memory operation.
+No source rewrite, LLVM atomic alignment, reusable memory extent, physical Go
+entry/caller or ABI0 byte slot is inferred. This logical source/IR proof is not
+an original-Go caller, backend-object or executed-semantics certificate.
+
+## Bounded 386 ABI0 byte result
+
+The independent SDK literal-predicate role admits only a complete ordinary 386
+no-argument, zero-frame function with exactly one declared bool result byte
+at FP+0 and original argument size one. Other literal-predicate contexts,
+direct-tail, raw and native roles retain Context; the shape authenticates no source.
+Each declared physical byte has a separate bounded canonical must-fact,
+cloned and intersected across the complete source CFG. Numerical initializedness
+remains independent: raw 2, 3 and 255 may be read or compared and then replaced
+by SETcc or another proved zero/one before RET. Overwrites revoke canonicality,
+and every predecessor must supply a canonical result. The existing shared
+byte-work envelope counts this state without increasing its limit.
+
+The cached whole-source proof is required even without an FP/SIMD probe.
+Intermediate loads and stores retain the physical I8 value; only the final
+proved result is truncated to logical I1. This does not initialize unknown GP
+upper bytes, expand FP storage, permit pointer/frame escapes or establish
+native Go entry. The required Linux AMD64 execution counterpart uses original
+386 Go bool callers and independent raw-byte/canary observers, plus LLVM's
+explicit I1-to-I32 shims; fixture inventory/IR tests alone are not execution.
+
+An independent lowering-only extension handles existing zero-frame logical
+inputs and declared-slot aliases. Only actual I1 parameter leaves start
+canonical; numeric byte inputs remain merely initialized until a typed
+operation proves zero/one. LEAL and full-word copies retain a separate exact
+slot/interior address, never numerical, caller or graph-result pointer facts.
+Scalar/extension reads and SETcc stores stay inside that declared field;
+partial/mixed aliases, escapes and overwritten carriers lose the role. This
+optional alias state is cloned/intersected and charged to the same finite work
+envelope. Intermediate bool parameter reads/writes also preserve I8 bytes.
+Other scalar leaves reuse their existing exact parameter/effect rules: opaque
+pointers and floating values do not become canonical or numerical pointers.
+
+A separate request-local ordinary CALL contract retains the complete original
+File and exact signatures before KeepFunc/normalization. It accepts only a
+same-file zero-frame readonly leaf with one actual I1 input byte at FP+0 and
+one result byte at FP+4. The leaf receives its independent complete canonical
+proof once; recursion, unknown calls, input writes, escapes, raw/source changes
+and native/direct-tail roles retain Context. Original caller and callee source
+tuples are replayed, never relabeled or cropped. Resolve callbacks finish before
+the final source/signature check; all three APIs discard artifacts on late
+mutation. This is logical lowering, not Go-native CALL entry authentication.
+
+Actual positive caller TEXT frame bounds contain only the two declared outgoing
+bytes (SP+0/SP+4); padding and general physical-SP/AUTO storage gain nothing.
+Separate NUM/canonical outgoing facts clone/intersect and share the unchanged
+finite byte/visit envelope with the cached callee proof. A CALL requires the
+actual outgoing parameter byte to be canonical and writes only its declared
+result. All GP/SIMD/mask/FLAGS, pointer and slot-address facts are revoked across
+CALL; no unspecified high GP byte becomes initialized. Intermediate outgoing
+bytes remain I8 until the proved logical call transport. The existing complete
+seven-function bool-frame fixture remains intact; pure/IR tests are not an
+object or execution certificate, and actual 386 SDK/native validation is a
+separate gate.
diff --git a/docs/development/x86-sdk-literal-alignment.md b/docs/development/x86-sdk-literal-alignment.md
new file mode 100644
index 000000000..53ee50125
--- /dev/null
+++ b/docs/development/x86-sdk-literal-alignment.md
@@ -0,0 +1,51 @@
+# Original SDK literal minimum alignment
+
+`CaptureGoX86SDKLiteralAlignment` is an independent, live data-layout observer.
+It borrows a genuine SDK ASM source and its private readonly initializer owner;
+it cannot be constructed from JSON, names, bytes or object alignment alone.
+It has no instruction binding, pointer, numerical address, native entry,
+execution, caller-memory or logical bool-return API.
+
+The first registered profile is the original Go 1.27.2 SDK on Linux x86,
+Darwin AMD64 and Windows x86. The actual CGO setting is retained, including
+CGO=1 when the complete selected SDK graph is independently ordinary/uncgo.
+Default executable/PIE and compiler shared settings are checked against the
+complete original Go profile rule, rather than borrowed from another GOOS.
+
+The observer retains the actual linker/compiler routes, binaries and reported
+versions; complete linker/loader rule sources; the candidate and runtime source/
+export graph; every named object-local definition in every selected archive;
+its generated main, compiler object, import configuration and linked image.
+Internal candidates are not imported by the generated main and receive no
+linkname or `-E` bypass. They must be naturally retained by the ordinary runtime
+link. Public candidates may use a genuine permitted blank import. Linker-native
+dead stripping is only an observation boundary, never a whole-module pass.
+
+Go's `SymAlign=0` means unset. The registered complete `ld.symalign` rule and
+x86 minimum/maximum values are audited before applying the existing
+`goAssemblyDataAlignment` size rule. A uniquely identified private, relocation-
+free readonly object must also match its original linked bytes, extent, section
+permissions and section/symbol placement. Same-named definitions anywhere in the
+selected graph cannot be selected by equal bytes or hashes. Ambiguous or absent
+objects receive no minimum-alignment row. Reports expose only that guaranteed
+minimum, not the observed address or any stronger accidental alignment.
+
+All original source functions and archive members remain bound. The two 256-byte
+original maps tables have independently observed minimum 32 on all five targets.
+The four naturally retained CRC32 tables give minimums 8, 16 and 32 for their
+different extents. This is a data-layout witness, not execution of maps' alignment
+check or a C `_Bool` ABI claim. The existing emitters' alignment rule is unchanged.
+
+The complete producer/alignment cohort passes with Go 1.27.2 and LLVM 22 in
+105.560 seconds, including actual image mutations, duplicate-name controls,
+source/tool/object/profile/generation/deadline rejection, copy/Close disposal
+and all Err/Done/Deadline reentry cases. Go 1.20 portable rule/emit/object/literal
+controls pass in 1.334 seconds. Its complete original five-architecture alignment
+test remains failed: the downloaded Go 1.20.14 SDK lacks both
+`misc/wasm/wasm_exec.js` and `misc/wasm/go_js_wasm_exec` (and the alternate lib
+runtime). No skip, substitute runtime or module-cache change was used.
+
+Masked-low-bit instruction consumers and canonical Go bool-byte/register
+transport require separate TDD batches. Until those consumers genuinely bind
+this live role, the complete original maps source keeps its existing Context;
+the observer does not waive deeper caller, pointer, loop or native-entry needs.
diff --git a/docs/development/x86-sdk-literal-frontend.md b/docs/development/x86-sdk-literal-frontend.md
new file mode 100644
index 000000000..10c60a522
--- /dev/null
+++ b/docs/development/x86-sdk-literal-frontend.md
@@ -0,0 +1,43 @@
+# Shared SDK literal-minimum handoff
+
+Both frontends use `internal/sdkfrontend.Source.BindNumericalReads`. The root
+cost query reuses the complete bounded literal CFG and actual typed source
+grammar: native-word materialization/copies and literal OR carriers leading to
+an immediate B/W/L/Q TEST in a declared ABIInternal bool-result function. It
+produces no address, floor, instruction certificate or numerical initialization.
+Ordinary fixed/indexed literal reads, incoming caller predicates, partial/raw
+carriers and escapes do not request an additional original Go link.
+
+Only a genuine predicate demand captures the existing original-linked minimum
+producer, once, using the same original readonly owner and bounded context.
+The producer retains the actual SDK source, complete graph/archive, linker,
+CGO/profile and lifetime contracts. The explicit core binder still independently
+joins its generation/seal and floor to the exact original source. The default
+core numerical binder continues to refuse address-bit permission.
+
+Successful and failed attempts are cached without replay. Every callback
+boundary checks the original owned handles; a late numerical replacement or
+Close permanently revokes the shared source. Operations reject reentry instead
+of blocking, before invoking caller context methods. Concurrent Close marks
+pending and immediately revokes the original numerical publication token,
+without disposing artifacts or invoking borrowed contexts/owners. Old bound
+Options cannot publish during the still-active callback. Owning cleanup releases
+resources exactly once when that operation unwinds. Errors return zero Options;
+pre-operation component mutation cannot revive after pointer restoration. The
+query preflight retains the existing complete object-symbol inventory bound.
+Cleanup order is minimum, numerical source, literal owner, ASM DATA source,
+Go owners.
+
+Numerical verification checks the publication token again after its final SDK
+context callback. Readback and original Go-input joins also check it under their
+existing source lock. Independent original CRC32 controls revoke at the actual
+last verified callback, including both module and Go-module final guards;
+verification, reports and all three APIs must return Context without output.
+
+Independent command receipts require one actual `tool link` for a cached maps
+minimum, and zero extra link/minimum attempts for repeated ordinary CRC32
+binding. Complete original maps frontend tests retain two TEXTs/all DATA and
+genuine mutable external AES storage; emitted objects are logical translation
+evidence, not physical SDK ABIInternal calling or complete runtime execution.
+The distinct no-DATA metadata-only owner and unsupported caller/entry contracts
+are not added by this handoff.
diff --git a/docs/development/x86-sdk-literal-low-bits.md b/docs/development/x86-sdk-literal-low-bits.md
new file mode 100644
index 000000000..93f49f823
--- /dev/null
+++ b/docs/development/x86-sdk-literal-low-bits.md
@@ -0,0 +1,43 @@
+# SDK literal masked minimum predicates
+
+`BindNumericalReadsWithLiteralAlignment` composes the genuine SDK numerical
+source/native/object join with the same readonly owner's independently observed
+original linked minimum. The ordinary binder still grants no linked-address
+bits. The producer has no binder or numerical-address API of its own.
+
+The complete bounded source proof admits full-word literal materialization and
+copies, register OR of two sealed carriers, and immediate TEST at every typed
+byte/word/dword/qword width only when the mask is wholly covered by the
+guaranteed minimum. Offsets retain only their provable low residue. An OR-combined
+carrier is not an affine memory origin. Claimed higher floors, missing/foreign
+owners, generation changes, closed sources and reentrant Close are rejected.
+The existing original source/native instruction, complete function, initializer,
+namespace/index/member, profile and lifetime checks remain mandatory.
+
+The result transfer defines only original FLAGS and opaque carrier effects; it
+does not initialize numerical GP bytes. The separate canonical bool-byte role
+proves the exact low result byte independently.
+
+An orthogonal path-sensitive FLAGS taint tracks uncovered address dependencies.
+OR's CF/OF are independently zero; Z/S/P cannot flow into SETcc, Jcc, CMOV or
+status readers until a complete covered TEST or independent typed writer clears
+their dependency. AF remains undefined under the existing initialization guard.
+Mixed CFG paths retain taint; original instruction/path/byte budgets do not grow.
+
+Neither general CMP/AND, uncovered high bits, pointer/vector/frame escapes, cyclic carriers nor mixed-OR
+memory reads gain authority. LLVM keeps its existing Go-size alignment rule and
+original instruction lowering; no forced align16, guessed linked address or
+constant replacement keys/initializers is introduced.
+
+The complete original AMD64 maps source keeps both TEXT functions. Its masked
+literal check binds to the authentic minimum; a separately proved
+[caller-address domain](x86-caller-address-predicates.md) now observes the incoming
+`TESTW $0xff0,AX`. Their composition with existing paired native-read and
+must-initialized CFG rules permits logical whole-file translation. Neither
+supplies new memory extent, loop invariants or physical native Go entry.
+AMD64's three OS profiles are source/object evidence, not SDK execution or an
+actual frontend benchmark pass. The frontends still need an explicit authentic
+minimum handoff. The independently bounded 386 consumer uses four-byte literal
+carriers and a separately proved ABI0 canonical bool byte; it does not borrow
+AMD64 register-return transport. Complete original 386 SDK source/object and
+execution gates remain necessary before claiming that discovering file passes.
diff --git a/docs/development/x86-source-address.md b/docs/development/x86-source-address.md
new file mode 100644
index 000000000..360603e2a
--- /dev/null
+++ b/docs/development/x86-source-address.md
@@ -0,0 +1,19 @@
+# x86 source address-immediate roles
+
+Go's source rewrite precedes operand classification. `MOVL/Q $offset(base), reg`
+becomes `LEAL/Q`; the register and index still compute the effective address.
+The audited scalar integer rows instead classify unnamed `TYPE_ADDR` as a
+constant and ignore its register annotations. 386 truncates the offset to
+32 bits; Q arithmetic, comparison, test, multiply and push sign-extend imm32.
+Shift/rotate counts use `Yu8` (not negative `Yi8`), while bit-test counts use
+signed `Yi8`. Tests bind these distinctions to actual stock-Go source and bytes.
+
+The lowering view is immutable and follows original caller/raw/frame proofs.
+It cannot repair or inherit LOCK, raw-return or physical-frame certificates.
+Named SB/AUTO/FP sources retain their separate consumers. Unresolved offsets,
+unbound segment/TLS/address-size roles and unaudited opcode classes fail closed;
+integer annotations never grant x87/SSE memory or float-literal permissions.
+
+The independent byte/math/canary oracles retain O0 and O2. Darwin ARM64/Rosetta
+observations are diagnostic only; their required Linux roots remain a distinct
+execution axis, not something implied by five-target LLVM object acceptance.
diff --git a/ecosystem_forms_test.go b/ecosystem_forms_test.go
index be2125b7e..9f516c90d 100644
--- a/ecosystem_forms_test.go
+++ b/ecosystem_forms_test.go
@@ -1,8 +1,7 @@
-//go:build !llgo
-
 package plan9asm
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
@@ -96,6 +95,10 @@ TEXT lz4(SB),NOSPLIT,$0-0
 func TestTranslateGoBitsScalarForms(t *testing.T) {
 	ir := translateEcosystemScalarForms(t, ArchAMD64, "x86_64-unknown-linux-gnu", "amd64", `
 TEXT bits(SB),NOSPLIT,$0-16
+	MOVQ $0, AX
+	MOVQ $0, BX
+	MOVQ $0, CX
+	MOVQ $0, DX
 	BSFQ x+0(FP), AX
 	BSRQ x+0(FP), BX
 	BSFL x+0(FP), CX
@@ -103,18 +106,39 @@ TEXT bits(SB),NOSPLIT,$0-16
 	MOVQ AX, ret+8(FP)
 	RET
 `)
-	for want, count := range map[string]int{"call i64 @llvm.cttz.i64": 1, "call i64 @llvm.ctlz.i64": 1, "call i32 @llvm.cttz.i32": 1, "call i32 @llvm.ctlz.i32": 1} {
-		if got := strings.Count(ir, want); got != count {
-			t.Fatalf("go-bits %q count = %d, want %d:\n%s", want, got, count, ir)
+	// Zero input observes the original prior destination and native flags.
+	// A poison-producing cttz/ctlz substitution does not establish that contract.
+	for _, instruction := range []string{"bsfq ${3:q}, ${0:q}", "bsrq ${3:q}, ${0:q}", "bsfl ${3:k}, ${0:k}", "bsrl ${3:k}, ${0:k}"} {
+		if got := strings.Count(ir, instruction); got != 1 {
+			t.Fatalf("go-bits native %q count = %d, want 1:\n%s", instruction, got, ir)
 		}
 	}
 }
 
+func TestTranslateGoBitsUnknownPriorResultNeedsContext(t *testing.T) {
+	file, err := Parse(ArchAMD64, `
+TEXT bits(SB),NOSPLIT,$0-16
+	BSFQ x+0(FP), AX
+	BSRQ x+0(FP), BX
+	BSFL x+0(FP), CX
+	BSRL x+0(FP), DX
+	MOVQ AX, ret+8(FP)
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, ecosystemScalarOptions("x86_64-unknown-linux-gnu", "amd64"))
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("zero input acquired an initialized bit-scan destination", err)
+	}
+}
+
 // These vector forms are taken from minio/highwayhash, minio/sha256-simd,
 // and klauspost/reedsolomon respectively. Keep the related unpack spellings
 // together so the source-level aliases cannot drift apart.
 func TestTranslateDiscoveredX86VectorForms(t *testing.T) {
-	ir := translateEcosystemScalarForms(t, ArchAMD64, "x86_64-unknown-linux-gnu", "amd64", `
+	ir := x86UnboundVoidScalarFormatObject(t, `
 TEXT vectors(SB),NOSPLIT,$0-0
 	PMULULQ X2, X8
 	PUNPCKLLQ X1, X2
@@ -125,12 +149,78 @@ TEXT vectors(SB),NOSPLIT,$0-0
 	POPCNTQ -8(SI)(BX*1), R11
 	POPCNTL 4(AX), R10
 	RET
-`)
-	for _, want := range []string{"mul <2 x i64>", "shufflevector <4 x i32>", "shufflevector <8 x i8>", "@llvm.ctpop.i64", "@llvm.ctpop.i32"} {
+`, "vectors", "amd64", "x86_64-unknown-linux-gnu")
+	for _, want := range []string{"mul <2 x i64>", "shufflevector <4 x i32>", "shufflevector <2 x i64>", "@llvm.ctpop.i64", "@llvm.ctpop.i32"} {
 		if !strings.Contains(ir, want) {
 			t.Fatalf("discovered x86 vector forms are missing %q:\n%s", want, ir)
 		}
 	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "discovered-vector-formats.ll", "discovered-vector-formats.o", ir)
+}
+
+// These forms come from github.com/aead/siphash@v1.0.1,
+// github.com/klauspost/crc32@v1.3.0, and github.com/phuslu/log@v1.0.132.
+// The packed min/max forms are tested as a family because the Go assembler
+// accepts the same register-or-memory source shape for every lane width and
+// signedness combination.
+func TestTranslateExpandedEcosystemX86VectorForms(t *testing.T) {
+	ir := x86UnboundVoidScalarFormatObject(t, `
+TEXT vectors(SB),NOSPLIT,$0-0
+	MOVQ $13, AX
+	VMOVQ AX, X0
+	PSLLQ $13, X0
+	PSRLQ $64, X0
+	PMINUB X1, X0
+	PMINSB X1, X0
+	PMINUW X1, X0
+	PMINSW X1, X0
+	PMINUD X1, X0
+	PMINSD X1, X0
+	PMAXUB X1, X0
+	PMAXSB X1, X0
+	PMAXUW X1, X0
+	PMAXSW X1, X0
+	PMAXUD X1, X0
+	PMAXSD 16(BX), X0
+	VMOVQ X0, CX
+	VZEROUPPER
+	RET
+`, "vectors", "amd64", "x86_64-unknown-linux-gnu")
+	for want, count := range map[string]int{
+		"shl <2 x i64>":            1,
+		"icmp ult <16 x i8>":       1,
+		"icmp slt <16 x i8>":       1,
+		"icmp ult <8 x i16>":       1,
+		"icmp slt <8 x i16>":       1,
+		"icmp ult <4 x i32>":       1,
+		"icmp slt <4 x i32>":       1,
+		"icmp ugt <16 x i8>":       1,
+		"icmp sgt <16 x i8>":       1,
+		"icmp ugt <8 x i16>":       1,
+		"icmp sgt <8 x i16>":       1,
+		"icmp ugt <4 x i32>":       1,
+		"icmp sgt <4 x i32>":       0,
+		"extractelement <2 x i64>": 1,
+	} {
+		if got := strings.Count(ir, want); got != count {
+			t.Fatalf("expanded ecosystem form %q count = %d, want %d:\n%s", want, got, count, ir)
+		}
+	}
+	if got := strings.Count(ir, `call <4 x float> asm sideeffect "pmaxsd ($2), $0", "=x,0,r,~{memory}"`); got != 1 {
+		t.Fatalf("original PMAXSD m128 must retain its exact native opcode and memory effect, got %d:\n%s", got, ir)
+	}
+	if !strings.Contains(ir, "store <16 x i8> zeroinitializer") {
+		t.Fatalf("PSRLQ with an oversized count must clear the vector:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "ecosystem-vector-formats.ll", "ecosystem-vector-formats.o", ir)
 }
 
 func translateEcosystemScalarForms(t *testing.T, arch Arch, triple, goarch, src string) string {
@@ -139,7 +229,15 @@ func translateEcosystemScalarForms(t *testing.T, arch Arch, triple, goarch, src
 	if err != nil {
 		t.Fatal(err)
 	}
-	ir, err := Translate(file, Options{
+	ir, err := Translate(file, ecosystemScalarOptions(triple, goarch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return ir
+}
+
+func ecosystemScalarOptions(triple, goarch string) Options {
+	return Options{
 		TargetTriple: triple,
 		Sigs: map[string]FuncSig{
 			"snappy": {Name: "snappy", Ret: Void},
@@ -157,9 +255,5 @@ func translateEcosystemScalarForms(t *testing.T, arch Arch, triple, goarch, src
 			"emitLiteral": {Name: "emitLiteral", Args: []LLVMType{"{ ptr, i64, i64 }", "{ ptr, i64, i64 }"}, Ret: I64},
 		},
 		Goarch: goarch,
-	})
-	if err != nil {
-		t.Fatal(err)
 	}
-	return ir
 }
diff --git a/feature_attrs.go b/feature_attrs.go
index d8b648be9..701b2ad04 100644
--- a/feature_attrs.go
+++ b/feature_attrs.go
@@ -68,23 +68,1554 @@ func inferFuncTargetFeaturesForGOARCH(arch Arch, goarch string, fn Func) string
 		op := strings.ToUpper(string(ins.Op))
 		switch arch {
 		case ArchAMD64:
+			moveArch := goarch
+			if moveArch == "" {
+				moveArch = "amd64"
+			}
+			// These disjoint typed families completely own their feature needs.
+			// Only valid forms bypass unrelated probes; errors keep the original
+			// raw/special-opcode fallback below.
+			if form, known, err := x86PackedLogicalProperties(ins, goarch); known && err == nil {
+				if form.legacy && !form.mmx && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+					// Only the validated native opcode needs the private XMM carrier.
+					if form.spec.encoding == x86PackedLogicalLegacyFP && form.spec.laneBits == 32 {
+						add("+sse")
+					} else {
+						add("+sse2")
+					}
+				}
+				continue
+			}
+			if form, known, err := amd64PackedVectorMoveProperties(ins, moveArch); known && err == nil {
+				if form.spec.aligned && form.memory >= 0 && !form.undefinedOpcode() {
+					if form.nativeEVEX(ins) {
+						add("+avx512f")
+						if form.byteWidth < 64 {
+							add("+avx512vl")
+						}
+					} else {
+						add("+avx")
+					}
+				}
+				continue
+			}
+			if x86BaselineGPFeatureInstruction(Op(op), &ins, moveArch) {
+				continue
+			}
+			if _, terminal, err := x86UndefinedTrapProperties(ins.Op, ins, moveArch); terminal && err == nil {
+				continue // Exact UD2 does not execute this source opcode or require its input ISA.
+			}
+			if form, known, err := x86FourSourceProperties(ins.Op, ins, moveArch); known && err == nil {
+				add("+avx512f") // Exact physical carriers, including scalar SS and isolated mode32.
+				if form.spec.mode == amd64FourSourceFMA {
+					add("+avx5124fmaps")
+				} else {
+					add("+avx5124vnniw")
+				}
+			}
+			if form, known, err := x86ScalarPrecisionProperties(ins.Op, ins, moveArch); known && err == nil {
+				switch {
+				case form.spec.legacy:
+					add("+sse2") // Both scalar precision conversions are SSE2, including CVTSS2SD.
+				case x86ScalarPrecisionNativeEVEX(ins, form):
+					add("+avx512f") // Scalar EVEX needs F, not the packed narrow VL feature.
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86PackedPrecisionProperties(ins.Op, ins, moveArch); known && err == nil {
+				switch {
+				case form.spec.legacy:
+					add("+sse2")
+				case form.evex:
+					add("+avx512f")
+					if form.shape.sourceBytes < 64 && form.shape.destinationBytes < 64 {
+						add("+avx512vl")
+					}
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86NamedHalfProperties(ins.Op, ins, moveArch); known && err == nil {
+				if form.evex {
+					add("+avx512f")
+					if form.sourceBytes < 64 && form.destinationBytes < 64 {
+						add("+avx512vl")
+					}
+				} else {
+					add("+avx", "+f16c")
+				}
+			}
+			if _, known, err := x86UnsignedIntegerFloatProperties(ins, moveArch); known && err == nil {
+				add("+avx512f") // Scalar unsigned EVEX needs F, not packed narrow VL.
+			}
+			if _, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, moveArch); known && err == nil {
+				if strings.HasPrefix(op, "VPMASK") {
+					add("+avx2")
+				} else {
+					add("+avx")
+				}
+			}
+			if form, known, err := x86PackedReductionProperties(ins, moveArch); known && err == nil {
+				if form.dot {
+					add("+sse4.1")
+				} else if form.legacy {
+					add("+sse3")
+				}
+				if !form.legacy {
+					add("+avx")
+				}
+			}
+			if form, known, err := x86UnalignedLoadProperties(ins.Op, ins, moveArch); known && err == nil {
+				if form.spec.vector {
+					add("+avx")
+				} else {
+					add("+sse3")
+				}
+			}
+			if form, known, err := x86DuplicateMoveProperties(ins.Op, ins, moveArch); known && err == nil &&
+				form.legacy && form.spec.laneBytes == 4 && form.memory >= 0 {
+				add("+sse3") // Only the original aligned legacy opcode needs a native carrier.
+			}
+			if form, known, err := x86AlternatingFloatProperties(ins, moveArch); known && err == nil &&
+				form.legacy && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				add("+sse3") // The original ADDSUB memory opcode requires its native XMM carrier.
+			}
+			if form, known, err := amd64FMA3Properties(ins, moveArch); known && err == nil && !form.spec.rawOnly {
+				if x86FMA3NativeEVEX(ins, form) {
+					add("+avx512f")
+					if !form.spec.scalar && form.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				} else {
+					add("+avx", "+fma")
+				}
+			}
+			if form, known, err := x86FloatingHelperProperties(ins, moveArch); known && err == nil {
+				add("+avx512f")
+				if form.spec.dq {
+					add("+avx512dq")
+				}
+				if !form.spec.scalar && form.byteWidth < 64 {
+					add("+avx512vl")
+				}
+				if form.spec.estimate14 {
+					continue // This complete shape already supplies the precise F/VL requirement.
+				}
+			}
+			if form, known, err := x86SqrtProperties(ins, moveArch); known && err == nil {
+				switch {
+				case x86SqrtNativeEVEX(ins, form):
+					add("+avx512f")
+					if !form.scalar && form.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				case !form.legacy:
+					add("+avx")
+				case form.bits == 64:
+					add("+sse2")
+				default:
+					add("+sse")
+				}
+			}
+			if _, known, err := x86ByteShuffleProperties(ins.Op, ins, moveArch); known && err == nil {
+				// Every width lowers through the SSSE3 intrinsic, including
+				// an isolated .Z function with no unsuffixed sibling.
+				add("+ssse3")
+			}
+			if form, known, err := x86PackedAbsSignProperties(ins.Op, ins, moveArch); known && err == nil {
+				// Each original form owns its minimum ISA; an unrelated MOVOU
+				// must not accidentally supply an i386 native XMM carrier.
+				switch {
+				case form.legacy:
+					add("+sse2", "+ssse3")
+				case form.evex(ins):
+					add("+avx512f")
+					if form.spec.laneBits < 32 {
+						add("+avx512bw")
+					}
+					if form.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				case form.byteWidth == 32:
+					add("+avx2")
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86BlendMinposProperties(ins.Op, ins, moveArch); known && err == nil {
+				switch {
+				case form.legacy:
+					add("+sse2", "+sse4.1")
+				case !form.minimum && form.laneBits == 8 && form.byteWidth == 32:
+					add("+avx2")
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86ImmediateBlendProperties(ins.Op, ins, moveArch); known && err == nil {
+				switch {
+				case form.legacy:
+					add("+sse2", "+sse4.1")
+				case ins.Op == "VPBLENDD" || ins.Op == "VPBLENDW" && form.byteWidth == 32:
+					add("+avx2")
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86FloatMinMaxProperties(ins, moveArch); known && err == nil {
+				switch {
+				case x86FloatMinMaxNativeEVEX(ins, form):
+					add("+avx512f")
+					if !form.scalar && form.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				case !form.legacy:
+					add("+avx")
+				case form.bits == 64:
+					add("+sse2")
+				default:
+					add("+sse")
+				}
+			}
+			if form, known, err := x86PackedAlignProperties(ins.Op, ins, moveArch); known && err == nil &&
+				form.legacy && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				add("+sse2", "+ssse3") // The isolated original PALIGNR m128 needs its physical carrier.
+			}
+			if form, known, err := x86VectorTestProperties(ins.Op, ins, moveArch); known && err == nil &&
+				ins.Args[0].Kind != OpReg && ins.Args[0].Kind != OpFP {
+				if form.vector {
+					add("+avx")
+				} else {
+					add("+sse4.1")
+				}
+			}
+			if form, known, err := x86MoveMaskProperties(ins.Op, ins, moveArch); known && err == nil &&
+				moveArch == "386" && form.floatingLaneBits == 0 && form.byteWidth >= 16 {
+				// Both packed byte-mask widths lower through the SSE2 i128
+				// intrinsic, even when no sibling instruction enables SSE2.
+				add("+sse2")
+			}
+			if form, known, err := x86COMIProperties(ins, moveArch); known && err == nil {
+				if form.evex {
+					add("+avx512f")
+				} else if form.spec.vector {
+					add("+avx")
+				} else if form.spec.bits == 64 {
+					add("+sse2")
+				} else {
+					add("+sse")
+				}
+			}
+			if spec, known, err := x86ImplicitMaskMoveProperties(ins.Op, ins, moveArch); known && err == nil {
+				switch {
+				case spec.byteWidth == 8:
+					add("+mmx")
+					add("+sse")
+				case spec.vector:
+					add("+avx")
+				default:
+					add("+sse2")
+				}
+			}
+			if form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, moveArch); known && err == nil && !form.trap {
+				switch {
+				case !form.spec.vector && form.spec.load:
+					add("+sse4.1")
+				case !form.spec.vector && form.spec.native == "movntps":
+					add("+sse")
+				case !form.spec.vector:
+					add("+sse2")
+				case form.move.nativeEVEX(ins):
+					add("+avx512f")
+					if form.move.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				case form.spec.load && form.move.byteWidth == 32:
+					add("+avx2")
+				default:
+					add("+avx")
+				}
+			}
+			if form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, moveArch); known && err == nil &&
+				form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				// Exact native whole128 opcodes need XMM registers on i386.
+				// PS moves are SSE1; a sibling MOVOU must not be needed to
+				// accidentally supply the register class to an isolated move.
+				if op == "MOVUPS" || op == "MOVAPS" {
+					add("+sse")
+				} else {
+					add("+sse2")
+				}
+			}
+			if form, known, err := x86HorizontalIntegerProperties(ins, goarch); known && err == nil &&
+				!form.spec.vector && !form.mmx && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				// The single original legacy m128 opcode needs its physical
+				// SSSE3 carrier on i386 as well. Portable register/VEX arithmetic
+				// does not acquire a native ISA or caller permission.
+				add("+sse2", "+ssse3")
+			}
+			if form, known, err := x86ImmediateShuffleProperties(ins, goarch); known && err == nil &&
+				form.spec.legacy && !form.spec.mmx && form.memory >= 0 && form.source.Kind != OpFP {
+				// Only this validated single native SSE2 memory instruction
+				// needs its private XMM carrier, including the physical i386 path.
+				add("+sse2")
+			}
+			if form, known, err := x86PackedFloatShuffleProperties(ins.Op, ins, moveArch); known && err == nil &&
+				form.legacy && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				if form.bits == 32 {
+					add("+sse")
+				} else {
+					add("+sse2")
+				}
+			}
+			if form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, moveArch); known && err == nil &&
+				form.legacy && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				add("+sse2")
+				if form.spec.mapNumber == 2 {
+					add("+sse4.1")
+				}
+			}
+			if form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, goarch); known && err == nil && form.legacy && !form.mmx && form.memory >= 0 && form.source.Kind != OpFP {
+				add("+sse2")
+				if form.spec.laneBits == 64 {
+					if form.spec.greater {
+						add("+sse4.2")
+					} else {
+						add("+sse4.1")
+					}
+				}
+			}
+			if form, known, err := x86ScalarFloatIntegerProperties(ins, goarch); known && err == nil {
+				if form.evex {
+					add("+avx512f")
+				} else if form.spec.vector {
+					add("+avx")
+				} else if form.spec.inputBits == 32 {
+					add("+sse")
+				} else {
+					add("+sse2")
+				}
+			}
+			// Only the validated native compare form gets its private ISA.
+			// This grants no caller memory or physical register permission.
+			if form, known, err := x86FloatCompareProperties(ins, goarch); known && err == nil {
+				if form.legacy {
+					if form.bits == 32 {
+						add("+sse")
+					} else {
+						add("+sse2")
+					}
+				} else if form.maskResult {
+					add("+avx512f")
+					if !form.scalar && form.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				} else {
+					add("+avx")
+				}
+			}
+			if f, known, err := x86PackedConversionProperties(ins, goarch); known && err == nil {
+				if f.evex {
+					add("+avx512f")
+					if f.spec.sourceBits == 64 && f.spec.sourceKind != amd64PackedNumericFloat ||
+						f.spec.destinationBits == 64 && f.spec.destinationKind != amd64PackedNumericFloat {
+						add("+avx512dq")
+					}
+					if f.shape.sourceBytes < 64 && f.shape.destinationBytes < 64 {
+						add("+avx512vl")
+					}
+				} else if f.spec.legacy {
+					add("+sse2")
+				} else {
+					add("+avx")
+				}
+			}
+			if f, known, err := x86SignedPackedFloatProperties(ins, goarch); known && err == nil {
+				if f.spec.legacy {
+					if f.mmx {
+						add("+mmx", "+sse")
+					}
+					if !f.mmx || f.spec.bits == 64 {
+						add("+sse2")
+					}
+				} else if f.evex {
+					add("+avx512f")
+					if f.byteWidth < 64 {
+						add("+avx512vl")
+					}
+				} else {
+					add("+avx")
+				}
+			}
+			if form, known, err := x86PackedArithmeticProperties(ins.Op, ins, goarch, 0); known && err == nil && form.legacy && !form.mmx && form.memory >= 0 {
+				if form.spec.family == x86PackedArithmeticLowMultiply {
+					add("+sse2", "+sse4.1")
+				} else if ins.Args[form.memory].Kind != OpFP {
+					add("+sse2")
+				}
+			}
+			if form, known, err := x86PackedPhysicalProperties(ins.Op, ins, goarch, ""); known && err == nil && form.legacy && !form.mmx && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				add("+sse2")
+				if form.spec.family == x86PackedMultiplyAdd && form.spec.inputBits == 8 ||
+					form.spec.family == x86PackedWordProduct && form.spec.mode == amd64PackedWordMultiplyRoundedSignedHigh {
+					add("+ssse3")
+				}
+				if form.spec.family == x86PackedDwordProduct && form.spec.signed {
+					add("+sse4.1")
+				}
+			}
+			if form, known, err := x86PackedUnpackProperties(ins, moveArch); known && err == nil &&
+				form.legacy && !form.mmx && form.memory >= 0 && form.source.Kind != OpFP {
+				// The original memory opcode needs its own XMM carrier on
+				// i386; no sibling may supply that native register class.
+				if form.spec.grammar.encoding == x86PackedLogicalLegacyFP && form.spec.laneBits == 32 {
+					add("+sse")
+				} else {
+					add("+sse2")
+				}
+			}
+			if form, known, err := x86PackedNarrowProperties(ins, goarch); known && err == nil && form.legacy && !form.mmx && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				add("+sse2")
+				if op == "PACKUSDW" {
+					add("+sse4.1")
+				}
+			}
+			if form, known, err := x86PackedSADProperties(ins, goarch); known && err == nil &&
+				form.legacy && form.memory >= 0 && ins.Args[form.memory].Kind != OpFP {
+				// The exact legacy m128 opcode needs an XMM carrier on i386.
+				// In particular PSADBW cannot borrow SSE2 from a sibling move.
+				add("+sse2")
+				if form.spec.kind == amd64PackedSADMultiple {
+					add("+sse4.1")
+				}
+			}
+			if goarch == "386" {
+				// The signed default-rounding scalar bridge must use MXCSR,
+				// rather than LLVM's default i386 x87 conversion. Admit only
+				// its validated source form and private SSE result register.
+				if form, known, err := x86SignedIntegerFloatProperties(ins, goarch); known && err == nil && form.rounding == "" {
+					if form.spec.resultBits == 32 {
+						add("+sse")
+					} else {
+						add("+sse2")
+					}
+				}
+				// Only actually validated native legacy m128 forms need an
+				// XMM constraint for their exact original SSE opcode bridge.
+				switch x86LegacyPackedFloatingNativeMemoryBits(ins, goarch) {
+				case 32:
+					add("+sse")
+				case 64:
+					add("+sse2")
+				}
+				// Default i386 floating legalization otherwise uses x87, whose
+				// control/status state is not the source instruction's MXCSR.
+				// Only validated dynamic MUL/DIV forms get this private SSE
+				// baseline; software ER, malformed and high-bank forms do not.
+				if form, known, err := x86FloatMulDivProperties(ins, goarch); known && err == nil && form.rounding == "" {
+					if form.bits == 32 {
+						add("+sse")
+					} else {
+						add("+sse2")
+					}
+				}
+			}
+			if form, recognized, err := x86PackedShiftProperties(ins.Op, ins, goarch); recognized && err == nil && x86PackedShiftHasNativeCount(form) {
+				add("+sse2")
+			}
 			switch {
+			case isAMD64RawFP16Op(op):
+				add("+avx512fp16")
+				if ins.x86VectorBytes == 16 || ins.x86VectorBytes == 32 {
+					add("+avx512vl")
+				}
+				base := strings.SplitN(op, ".", 2)[0]
+				if strings.HasSuffix(base, "PH") && len(ins.Args) != 0 {
+					destination := ins.Args[len(ins.Args)-1]
+					width := amd64VectorByteWidth(destination.Reg)
+					if width == 16 || width == 32 {
+						add("+avx512vl")
+					}
+				}
+			case strings.HasPrefix(op, "VDPBF16PS"):
+				add("+avx512f", "+avx512bf16")
+				if len(ins.Args) != 0 && amd64VectorByteWidth(ins.Args[len(ins.Args)-1].Reg) < 64 {
+					add("+avx512vl")
+				}
+			case strings.HasPrefix(op, "VCVTNEPS2BF16"):
+				add("+avx512f", "+avx512bf16")
+				if strings.HasPrefix(op, "VCVTNEPS2BF16X") || strings.HasPrefix(op, "VCVTNEPS2BF16Y") {
+					add("+avx512vl")
+				}
+			case op == "XBEGIN" || op == "XABORT" || op == "XEND" || op == "XTEST":
+				add("+rtm")
+			case op == "RDPKRU" || op == "WRPKRU":
+				add("+pku")
+			case op == "UMONITOR" || op == "UMWAIT" || op == "TPAUSE":
+				add("+waitpkg")
+			case op == "XSETBV":
+				add("+xsave")
+			case op == "CLDEMOTE":
+				add("+cldemote")
+			case op == "INVPCID":
+				add("+invpcid")
+			case strings.Contains(op, "FSBASE") || strings.Contains(op, "GSBASE"):
+				add("+fsgsbase")
+			case strings.HasPrefix(op, "FXSAVE") || strings.HasPrefix(op, "FXRSTOR"):
+				add("+fxsr")
+			case strings.HasPrefix(op, "XSAVEOPT"):
+				add("+xsave", "+xsaveopt")
+			case strings.HasPrefix(op, "XSAVEC"):
+				add("+xsave", "+xsavec")
+			case strings.HasPrefix(op, "XSAVES") || strings.HasPrefix(op, "XRSTORS"):
+				add("+xsave", "+xsaves")
+			case strings.HasPrefix(op, "XSAVE") || strings.HasPrefix(op, "XRSTOR"):
+				add("+xsave")
+			case strings.HasPrefix(op, "VPCMPESTR") || strings.HasPrefix(op, "VPCMPISTR"):
+				add("+avx", "+sse4.2")
+			case strings.HasPrefix(op, "PCMPESTR") || strings.HasPrefix(op, "PCMPISTR"):
+				add("+sse4.2")
+			case strings.HasPrefix(op, "VEXP2") || strings.HasPrefix(op, "VRCP28") || strings.HasPrefix(op, "VRSQRT28"):
+				// LLVM 22 removed the avx512er feature flag and target intrinsics,
+				// but its x86 assembler still supports these encodings. AVX512F
+				// supplies the Z/K register classes used by the inline assembly.
+				add("+avx512f")
+			case strings.HasPrefix(op, "VRCP14") || strings.HasPrefix(op, "VRSQRT14"):
+				add("+avx512f", "+avx512vl")
+			case op == "VMPSADBW":
+				add("+avx", "+sse4.1")
+				for _, arg := range ins.Args {
+					if arg.Kind == OpReg && isAMD64YReg(arg.Reg) {
+						add("+avx2")
+					}
+				}
+			case op == "MPSADBW":
+				add("+sse4.1")
+			case strings.HasPrefix(op, "RDRAND"):
+				add("+rdrnd")
+			case strings.HasPrefix(op, "LZCNT"):
+				add("+lzcnt")
+			case strings.HasPrefix(op, "ADCX") || strings.HasPrefix(op, "ADOX"):
+				add("+adx")
+			case strings.HasPrefix(op, "RDSEED"):
+				add("+rdseed")
+			case op == "CLFLUSHOPT":
+				add("+clflushopt")
+			case op == "CLWB":
+				add("+clwb")
+			case op == "RDPID":
+				add("+rdpid")
+			case op == "CMPXCHG16B":
+				add("+cx16")
+			case strings.HasPrefix(op, "BLS"):
+				add("+bmi")
+			case op == "ANDNL" || op == "ANDNQ":
+				add("+bmi")
+			case strings.HasPrefix(op, "BEXTR"):
+				add("+bmi")
+			case strings.HasPrefix(op, "MULX") || strings.HasPrefix(op, "RORX") || strings.HasPrefix(op, "SHLX") || strings.HasPrefix(op, "SHRX") || strings.HasPrefix(op, "SARX") || strings.HasPrefix(op, "PDEP") || strings.HasPrefix(op, "PEXT") || strings.HasPrefix(op, "BZHI"):
+				add("+bmi2")
+			case op == "RCPPS" || op == "RSQRTPS" || op == "RCPSS" || op == "RSQRTSS":
+				add("+sse")
+			case goarch == "386" && (op == "CVTPL2PS" || op == "CVTPS2PL" || op == "CVTTPS2PL"):
+				// The Go names share SSE2 X forms and older SSE MMX forms.
+				// LLVM 22 cannot legalize the SSE2 conversion intrinsic for an
+				// i386 function that has no +sse2 target feature.
+				mmxForm := len(ins.Args) == 2 && ins.Args[0].Kind == OpReg && op == "CVTPL2PS"
+				if mmxForm {
+					_, mmxForm = amd64ParseMReg(ins.Args[0].Reg)
+				}
+				if len(ins.Args) == 2 && op != "CVTPL2PS" && ins.Args[1].Kind == OpReg {
+					_, mmxForm = amd64ParseMReg(ins.Args[1].Reg)
+				}
+				if mmxForm {
+					add("+sse")
+				} else {
+					add("+sse2")
+				}
+			case goarch == "386" && (op == "CVTPL2PD" || op == "CVTPD2PL" || op == "CVTTPD2PL"):
+				add("+sse2")
+			case op == "VRCPPS" || op == "VRSQRTPS" || op == "VRCPSS" || op == "VRSQRTSS":
+				add("+avx", "+sse")
+			case strings.HasPrefix(op, "VROUND"):
+				add("+avx")
+			case strings.HasPrefix(op, "ROUND"):
+				add("+sse4.1")
 			case goarch == "386" && (op == "MOVOU" || op == "PCMPEQB" || op == "PCMPEQL" || op == "PMOVMSKB"):
 				add("+sse2")
 			case strings.HasPrefix(op, "CRC32"):
 				add("+crc32", "+sse4.2")
-			case op == "PCLMULQDQ":
+			case op == "MOVNTIL" || op == "MOVNTIQ":
+				add("+sse2")
+			case strings.HasPrefix(op, "MOVBE"):
+				add("+movbe")
+			case x86SHAEncodings[Op(op)] != 0:
+				add("+sha", "+sse2")
+			case op == "PCLMULQDQ" || op == "VPCLMULQDQ":
 				add("+pclmul", "+sse4.1")
-			case op == "PSHUFB" || op == "VPSHUFB":
-				add("+ssse3")
-			case op == "AESENC" || op == "AESENCLAST" || op == "AESDEC" || op == "AESDECLAST" || op == "AESIMC" || op == "AESKEYGENASSIST":
+			case op == "AESENC" || op == "AESENCLAST" || op == "AESDEC" || op == "AESDECLAST" || op == "AESIMC" || op == "AESKEYGENASSIST" ||
+				op == "VAESENC" || op == "VAESENCLAST" || op == "VAESDEC" || op == "VAESDECLAST" || op == "VAESIMC" || op == "VAESKEYGENASSIST":
 				add("+aes")
 			}
 		case ArchARM64:
+			if _, matched, err := parseARM64SVECnt(arm64ControlOp(ins), ins); matched && err == nil {
+				add("+sve")
+			}
+			if _, matched, err := parseARM64RNDR(ins); matched && err == nil {
+				add("+rand")
+			}
+			if op == "SMC" || op == "DCPS3" {
+				add("+el3")
+			}
+			if op == "MSR" && len(ins.Args) == 2 && ins.Args[0].Kind == OpImm &&
+				ins.Args[1].Kind == OpIdent && strings.EqualFold(ins.Args[1].Ident, "DIT") {
+				add("+dit")
+			}
+			if op == "WORD" && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+				if _, ok := decodeARM64RawSVECharacterMatch(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2")
+				}
+				if _, ok := decodeARM64RawSVEPredicateBreak(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVEPredicateCount(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEPredicateCounterNeedsSVE2P1(decoded.Op, decoded) {
+						add("+sve2p1")
+					}
+				}
+				if _, ok := decodeARM64RawSVEPredicateIncDec(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVEFloatMinMax(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					switch arm64SVEFloatMinMaxSpecs[decoded.Op].kind {
+					case arm64SVEFloatMinMaxPairwise:
+						add("+sve2")
+					case arm64SVEFloatMinMaxQuadReduce:
+						add("+sve2p1")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEFloatUnary(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEFloatUnarySpecs[decoded.Op].fptoint {
+						add("+fptoint")
+					}
+				}
+				if _, ok := decodeARM64RawSVEFloatCompare(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEIntegerCompare(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEPredicateLogical(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEPredicatePermute(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVECompact(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVECompactNeedsSVE2P2(decoded) {
+						add("+sve2p2")
+					}
+				}
+				if _, ok := decodeARM64RawSVECopy(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerUnary(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEIntegerUnarySpecs[decoded.Op].sve2 {
+						add("+sve2")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVERevd(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2p1")
+					if arm64SVERevdNeedsSVE2P2(decoded) {
+						add("+sve2p2")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEStructuredMemory(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEStructuredMemorySpecs[decoded.Op].q {
+						add("+sve2p1")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEMultiplyAccumulate(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEMultiplyAccumulateNeedsSVE2(decoded) {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVETernaryBitwise(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2")
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerReduction(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEIntegerReductionSpecs[decoded.Op].quad {
+						add("+sve2p1")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEIntegerDot(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2", arm64SVEIntegerDotFeature(decoded))
+					if arm64SVEIntegerDotSpecs[decoded.Op].mixed {
+						add("+i8mm")
+					}
+				}
+				if _, ok := decodeARM64RawSVEXAR(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2")
+				}
+				if decoded, ok := decodeARM64RawSVEExtraShift(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEImmediateShiftSpecs[decoded.Op].sve2 {
+						add("+sve2")
+					}
+				}
+				if decoded, ok := decodeARM64RawSVEUnsignedLoad(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEOrdinaryMemoryNeedsSVE2P1(decoded) {
+						add("+sve2p1")
+					}
+				}
+				if _, ok := decodeARM64RawSVESignedLoad(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEAddSubWide(uint32(ins.Args[0].Imm)); ok {
+					add("+sve", "+sve2")
+				}
+				if decoded, ok := decodeARM64RawSVEMultiplyHigh(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEMultiplyHighNeedsSVE2(decoded) {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVEAddressGeneration(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatDivideScale(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatReciprocalStep(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVESplice(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if len(decoded.Args) == 3 {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVEReplicateScalar(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVEReplicateBlock(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+					if arm64SVEReplicateMemorySpecs[decoded.Op].blockBytes == 32 {
+						add("+f64mm")
+					}
+				}
+				if form, ok := decodeARM64RawException(uint32(ins.Args[0].Imm)); ok {
+					if form.mnemonic == "smc" {
+						add("+el3")
+					}
+				}
+				if _, ok := decodeARM64RawStreamingModeControl(uint32(ins.Args[0].Imm)); ok {
+					add("+sme")
+				}
+				if _, ok := decodeARM64RawZAZero(uint32(ins.Args[0].Imm)); ok {
+					add("+sme")
+				}
+				if form, ok := decodeARM64RawSMEOuterProduct(uint32(ins.Args[0].Imm)); ok {
+					add("+sme", "+sve")
+					if form.sourceBits == 64 {
+						add("+sme-f64f64")
+					}
+				}
+				if _, ok := decodeARM64RawSMETileRead(uint32(ins.Args[0].Imm)); ok {
+					add("+sme", "+sve")
+				}
+				if _, ok := decodeARM64RawSMETileWrite(uint32(ins.Args[0].Imm)); ok {
+					add("+sme", "+sve")
+				}
+				if _, ok := decodeARM64RawSMETileMemory(uint32(ins.Args[0].Imm)); ok {
+					add("+sme", "+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatImmediate(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEDupM(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatMultiplyAccumulate(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEConvert(uint32(ins.Args[0].Imm)); ok {
+					add("+sve")
+				}
+			}
+			if arm64CTERMOps[Op(op)] {
+				add("+sve")
+			}
+			if op == "VPMULL" || op == "VPMULL2" {
+				add("+aes")
+			}
+			if op == "AESE" || op == "AESD" || op == "AESMC" || op == "AESIMC" {
+				add("+aes")
+			}
+			if strings.HasPrefix(op, "SHA1") || strings.HasPrefix(op, "SHA256") {
+				add("+sha2")
+			}
+			if strings.HasPrefix(op, "SHA512") {
+				add("+sha3")
+			}
 			if strings.HasPrefix(op, "CRC32") {
 				add("+crc")
 			}
+			if op == "ADDVL" || op == "ADDPL" || op == "RDVL" || op == "ZADR" || op == "ZDUP" || op == "ZADD" || op == "ZSEL" || op == "ZMUL" || op == "ZAND" || op == "ZBIC" || op == "ZEOR" || op == "ZORR" || op == "ZTBL" || op == "ZUMULLB" {
+				add("+sve")
+			}
+			if _, ok := arm64SVEShiftSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if spec, ok := arm64SVEImmediateShiftSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.sve2 {
+					add("+sve2")
+				}
+			}
+			if _, ok := arm64SVEReverseShiftIntrinsics[Op(op)]; ok {
+				add("+sve")
+			}
+			add(arm64SVEMatrixMultiplyFeatures(Op(op), ins)...)
+			if op == "ZADDP" {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVETailOps[Op(op)]; ok {
+				add("+sve", "+cpa")
+			}
+			if _, ok := arm64SVEMultiplyAddTailOps[Op(op)]; ok {
+				add("+sve", "+cpa")
+			}
+			if _, ok := arm64SVEVectorPredicateIncDecSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEAddSubSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEFloatAddSubSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if op == "ZFMUL" || op == "ZFMULX" {
+				add("+sve")
+			}
+			if _, ok := arm64SVEFloatTrigIntrinsics[Op(op)]; ok {
+				add("+sve")
+			}
+			if op == "ZFTMAD" || op == "ZFCMLA" {
+				add("+sve")
+			}
+			if _, ok := arm64SVEFloatMultiplyAccumulateSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEMultiplyAccumulateSpecs[Op(op)]; ok {
+				add("+sve")
+				if arm64SVEMultiplyAccumulateNeedsSVE2(ins) {
+					add("+sve2")
+				}
+			}
+			if op == "ZBFDOT" {
+				add("+bf16", "+sve")
+			}
+			if _, ok := arm64SVEIntegerDotSpecs[Op(op)]; ok {
+				add("+sve", "+sve2", arm64SVEIntegerDotFeature(ins))
+				if op == "ZSUDOT" || op == "ZUSDOT" {
+					add("+i8mm")
+				}
+			}
+			if _, ok := arm64SVEAESMixIntrinsics[Op(op)]; ok {
+				add("+sve2-aes")
+			}
+			if _, ok := arm64SVEAESRoundIntrinsics[Op(op)]; ok {
+				if arm64SVEAESRoundIsMulti(ins) {
+					add("+sve", "+sve-aes2")
+				} else {
+					add("+sve2-aes")
+				}
+			}
+			if spec, ok := arm64SVEOptionalCryptoSpecs[Op(op)]; ok {
+				add(spec.feature)
+			}
+			if op == "ZREVD" {
+				add("+sve", "+sve2p1")
+				if arm64SVERevdNeedsSVE2P2(ins) {
+					add("+sve2p2")
+				}
+			}
+			if op == "ZPMUL" {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEPMULLIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+				if arm64SVEPMULLNeedsSVE2AES(ins) {
+					add("+sve2-aes")
+				}
+			}
+			if op == "ZPMULL" || op == "ZPMLAL" {
+				add("+sve", "+sve-aes2")
+			}
+			if _, ok := arm64SVESaturatingMultiplyHighIntrinsics[Op(op)]; ok {
+				add("+sve")
+				add("+sve2")
+			}
+			if _, ok := arm64SVEComplexMultiplyAccumulateIntrinsics[Op(op)]; ok {
+				add("+sve")
+				add("+sve2")
+			}
+			if _, ok := arm64SVEComplexAddIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if op == "ZXAR" {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVESaturatingRoundingMultiplyAccumulateHighIntrinsics[Op(op)]; ok {
+				add("+sve")
+				add("+sve2")
+			}
+			if spec, ok := arm64SVEFloatMinMaxSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.kind == arm64SVEFloatMinMaxPairwise {
+					add("+sve2")
+				}
+				if spec.kind == arm64SVEFloatMinMaxQuadReduce {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVECharacterMatchIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEHistogramOps[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEFloatReciprocalStepIntrinsics[Op(op)]; ok {
+				add("+sve")
+			}
+			if op == "ZFEXPA" {
+				add("+sve")
+			}
+			if op == "ZFLOGB" {
+				add("+sve", "+sve2")
+			}
+			if op == "ZFCPY" || op == "ZFDUP" {
+				add("+sve")
+			}
+			if op == "ZFDIV" || op == "ZFDIVR" || op == "ZFSCALE" {
+				add("+sve")
+			}
+			if op == "ZSUQADD" || op == "ZUSQADD" {
+				add("+sve", "+sve2")
+			}
+			if op == "ZFCADD" {
+				add("+sve", "+sve2")
+			}
+			if op == "ZDUPW" {
+				add("+sve")
+			}
+			if op == "ZDUPQ" {
+				add("+sve", "+sve2p1")
+			}
+			if op == "ZDUPM" {
+				add("+sve")
+			}
+			if op == "ZFDOT" {
+				if sourceBits, destinationBits, ok := arm64SVEFDOTFeatureClass(ins); ok {
+					add("+sve", "+sve2")
+					if sourceBits == 8 {
+						add("+fp8", "+sve2p2")
+						if destinationBits == 16 {
+							add("+ssve-fp8dot2")
+						} else if destinationBits == 32 {
+							add("+ssve-fp8dot4")
+						}
+					} else if sourceBits == 16 && destinationBits == 32 {
+						add("+f16f32dot", "+sve2p1")
+					}
+				}
+			}
+			if op == "ZCDOT" {
+				add("+sve", "+sve2")
+			}
+			if op == "ZLUTI2" || op == "ZLUTI4" {
+				add("+lut", "+sve", "+sve2")
+			}
+			if _, ok := arm64SVEWideningFloatMLASpecs[Op(op)]; ok {
+				if sourceBits, sourceOK := arm64SVEWideningFloatMLAFeatureClass(ins); sourceOK {
+					add("+sve", "+sve2")
+					if sourceBits == 8 {
+						add("+fp8", "+ssve-fp8fma", "+sve2p2")
+					}
+				}
+			}
+			if _, ok := arm64SVEMultiNarrowSpecs[Op(op)]; ok {
+				add("+sve", "+sve2p1")
+			}
+			if arm64SVEFloatNarrowConversionOp(Op(op)) {
+				add("+sve")
+				if Op(op) == "ZFCVTNT" {
+					add("+sve2")
+					if len(ins.Args) == 3 {
+						if _, zeroing := arm64ParseSVEPredicateMode(ins.Args[1], "Z", 7); zeroing {
+							add("+sve2p2")
+						}
+					}
+				}
+				if arm64SVEFloatNarrowConversionUsesFP8(Op(op), ins) {
+					add("+fp8", "+sve2", "+sve2p2")
+				}
+				if Op(op) == "ZBFCVT" || Op(op) == "ZBFCVTNT" {
+					add("+bf16")
+				}
+			}
+			if spec, ok := arm64SVEBFloatArithmeticSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.scale {
+					add("+sve-bfscale")
+				} else {
+					add("+sve-b16b16")
+				}
+			}
+			if spec, ok := arm64SVEBFloatMLASpecs[Op(op)]; ok {
+				add("+sve")
+				switch {
+				case spec.subtractLong:
+					add("+bf16", "+sve2p1")
+				case spec.widening:
+					add("+bf16")
+				default:
+					add("+sve-b16b16")
+				}
+			}
+			if spec, ok := arm64SVEFloatPredicatedPairwiseSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.sve2 {
+					add("+sve2")
+				}
+				if spec.faminmax {
+					add("+faminmax")
+				}
+			}
+			if spec, ok := arm64SVEFloatUnarySpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.fptoint {
+					add("+fptoint")
+				}
+			}
+			if spec, ok := arm64SVEIntegerUnarySpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.sve2 {
+					add("+sve2")
+				}
+			}
+			if _, ok := arm64SVEPredicateLogicalSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicateBreakSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicatePermuteSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicateStateSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicateIterateSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicatePositionIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2p2")
+			}
+			if _, ok := arm64SVEPredicateCounterOps[Op(op)]; ok {
+				add("+sve")
+				if arm64SVEPredicateCounterNeedsSVE2P1(Op(op), ins) {
+					add("+sve2p1")
+				}
+			}
+			if spec, ok := arm64SVEPredicateWhileSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.pointer {
+					add("+sve2")
+				}
+				if arm64SVEPredicateWhileNeedsSVE2P1(ins) {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEPredicateIncDecSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEPredicateMemoryOps[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEWholeVectorMemoryOps[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEVectorPrefetchBits[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVENonTemporalMemorySpecs[Op(op)]; ok {
+				add("+sve")
+				if arm64SVENonTemporalMemoryNeedsSVE2P1(ins) {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEOrdinaryMemorySpecs[Op(op)]; ok {
+				add("+sve")
+				if arm64SVEOrdinaryMemoryNeedsSVE2P1(ins) {
+					add("+sve2p1")
+				}
+			}
+			if spec, ok := arm64SVEStructuredMemorySpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.q {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEFirstFaultMemorySpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVENonFaultingMemorySpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if spec, ok := arm64SVEReplicateMemorySpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.blockBytes == 32 {
+					add("+f64mm")
+				}
+			}
+			if op == "ZPMOV" {
+				add("+sve", "+sve2p1")
+			}
+			if op == "ZINDEX" || op == "ZINDEXW" {
+				add("+sve")
+			}
+			if _, ok := arm64SVEInsertBaseSize[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVELastSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVECLastSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if op == "ZCOMPACT" {
+				add("+sve")
+				if arm64SVECompactNeedsSVE2P2(ins) {
+					add("+sve2p2")
+				}
+			}
+			if op == "ZEXPAND" {
+				add("+sve", "+sve2p2")
+			}
+			if op == "ZMOVPRFX" {
+				add("+sve")
+			}
+			if op == "ZEXT" {
+				add("+sve")
+			}
+			if op == "ZEXTQ" {
+				add("+sve", "+sve2p1")
+			}
+			if op == "ZSPLICE" {
+				add("+sve")
+			}
+			if op == "ZCPY" || op == "ZCPYW" {
+				add("+sve")
+			}
+			if _, ok := arm64SVECopyVectorBaseSize[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVEConvertSpecs[Op(op)]; ok {
+				add("+sve")
+				if op == "ZFCVTLT" || op == "ZFCVTXNT" {
+					add("+sve2p2")
+				}
+			}
+			if _, ok := arm64SVECompareSpecs[Op(op)]; ok {
+				add("+sve")
+			}
+			if spec, ok := arm64SVEMinMaxSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.kind == arm64SVEMinMaxPairwise {
+					add("+sve2")
+				}
+				if spec.kind == arm64SVEMinMaxQuadReduce {
+					add("+sve2p1")
+				}
+			}
+			if spec, ok := arm64SVEIntegerReductionSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.quad {
+					add("+sve2p1")
+				}
+			}
+			if spec, ok := arm64SVEAddReductionSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.kind == arm64SVEFloatAddQuadReduce {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEWideningAddSubSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEShiftLongIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if spec, ok := arm64SVEAbsoluteDifferenceSpecs[Op(op)]; ok {
+				add("+sve")
+				if spec.kind != arm64SVEAbsoluteDifference {
+					add("+sve2")
+				}
+			}
+			if _, ok := arm64SVEHalvingAddSubIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEDivideIntrinsics[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVETernaryBitwiseSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEEORInterleaveIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEBitPermuteIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve-bitperm", "+sve2")
+			}
+			if _, ok := arm64SVECarryLongIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if spec, ok := arm64SVEClampSpecs[Op(op)]; ok {
+				if spec.kind == arm64SVEClampBFloat {
+					add("+sve", "+sve-b16b16")
+				} else {
+					add("+sve", "+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEUnpackIntrinsics[Op(op)]; ok {
+				add("+sve")
+			}
+			if _, ok := arm64SVESaturatingNarrowSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEShiftNarrowSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVESaturatingShiftNarrowSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if op == "ZDUP" && len(ins.Args) == 2 {
+				if _, bits, _, ok := arm64ParseSVEDupElementReg(ins.Args[0]); ok && bits == 128 {
+					add("+sve2p1")
+				}
+			}
+			if op == "ZMUL" && arm64SVEMultiplyNeedsSVE2(ins) {
+				add("+sve2")
+			}
+			if _, ok := arm64SVEMultiplyHighIntrinsics[Op(op)]; ok {
+				add("+sve")
+				if arm64SVEMultiplyHighNeedsSVE2(ins) {
+					add("+sve2")
+				}
+			}
+			if _, ok := arm64SVEVariableShiftSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if op == "ZTBL" && arm64SVETableNeedsSVE2(ins) {
+				add("+sve2")
+			}
+			if _, ok := arm64SVETableExtensionIntrinsics[Op(op)]; ok {
+				add("+sve")
+				if op == "ZTBX" {
+					add("+sve2")
+				} else {
+					add("+sve2p1")
+				}
+			}
+			if _, ok := arm64SVEMultiplyLongSpecs[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEMultiplyAccumulateLongIntrinsics[Op(op)]; ok {
+				add("+sve", "+sve2")
+			}
+			if _, ok := arm64SVEPermuteIntrinsics[Op(op)]; ok {
+				add("+sve")
+				if arm64SVEIsQPermuteOp(Op(op)) {
+					add("+sve2p1")
+				} else if arm64SVEPermuteNeedsF64MM(ins) {
+					add("+f64mm")
+				}
+			}
+			if op == "WORD" && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+				word := uint32(ins.Args[0].Imm)
+				if decoded, err := decodeARM64RawWordInstruction(ins); err == nil {
+					decodedFeatures := inferFuncTargetFeaturesForGOARCH(ArchARM64, goarch, Func{Instrs: []Instr{decoded}})
+					add(strings.Split(decodedFeatures, ",")...)
+				}
+				if _, ok := decodeARM64RawAES(word); ok {
+					add("+aes")
+				}
+				if _, ok := decodeARM64RawSM4(word); ok {
+					add("+sm4")
+				}
+				if _, ok := decodeARM64RawRDMA(word); ok {
+					add("+rdm")
+				}
+				if _, ok := decodeARM64RawFloatMultiplyLong(word); ok {
+					add("+fp16fml")
+				}
+				if _, ok := decodeARM64RawHalfFMA(word); ok {
+					add("+fullfp16")
+				}
+				if _, ok := decodeARM64RawScalarHalfUnary(word); ok {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarVectorFCVTZ(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFMULByElement(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFloatBinary(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawReciprocalEstimate(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFloatImmediate(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarFloatBinary(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarFloatCompare(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawConditionalCompare(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFloatCompare(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFloatMinMaxAcross(word); ok && form.arrangement.elementBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarFloatSelect(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarFloatImmediate(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawScalarIntToFloat(word); ok && form.floatBits == 16 {
+					add("+fullfp16")
+				}
+				if form, ok := decodeARM64RawFloatGPMove(word); ok && form.bits == 16 {
+					add("+fullfp16")
+				}
+				if _, ok := decodeARM64RawBFloatConvert(word); ok {
+					add("+bf16")
+				}
+				if _, ok := decodeARM64RawBFloatDot(word); ok {
+					add("+bf16")
+				}
+				if _, ok := decodeARM64RawBFloatMatrix(word); ok {
+					add("+bf16")
+				}
+				if _, ok := decodeARM64RawSHA3(word); ok {
+					add("+sha3")
+				}
+				if form, ok := decodeARM64RawScalarFCVTToInt(word); ok && form.sourceBits == 16 {
+					add("+fullfp16")
+				}
+				if _, ok := decodeARM64RawSVEAddress(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEIndex(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVECnt(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEPTrue(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVELDST1D(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVELDST1W(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloat(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatReciprocalStep(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEFloatMinMaxReduction(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEIntegerAddReduction(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVELoadStore(word); ok {
+					add("+sve")
+				}
+				if decoded, ok := decodeARM64RawSVEWhile(word); ok {
+					add("+sve")
+					if arm64SVEPredicateWhileNeedsSVE2P1(decoded) {
+						add("+sve2p1")
+					}
+				}
+				if _, ok := decodeARM64RawSVELD1B(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEContiguousMemory(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEUnpack(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEAddPairwiseLong(word); ok {
+					add("+sve", "+sve2")
+				}
+				if _, ok := decodeARM64RawSVEIntegerMinMax(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEIntegerMinMaxReduction(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEPTest(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEMOVPRFX(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVELast(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEDupImmediate(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVEDupGeneral(word); ok {
+					add("+sve")
+				}
+				if form, ok := decodeARM64RawSVEDupElement(word); ok {
+					add("+sve")
+					if form.elementBits == 128 {
+						add("+sve2p1")
+					}
+				}
+				if _, ok := decodeARM64RawSVEAdd(word); ok {
+					add("+sve")
+				}
+				if op, form, ok := decodeARM64RawSVEAddSub(word); ok {
+					add("+sve")
+					if form.mode == arm64SVEAddPredicated && arm64SVEAddSubSpecs[op].intrinsic != "" {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVEShift(word); ok {
+					add("+sve")
+				}
+				if _, ok := decodeARM64RawSVESelect(word); ok {
+					add("+sve")
+				}
+				if form, ok := decodeARM64RawSVEMultiply(word); ok {
+					add("+sve")
+					if form.mode == arm64SVEMultiplyUnpredicated || form.mode == arm64SVEMultiplyLane {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVEEOR(word); ok {
+					add("+sve")
+				}
+				if form, ok := decodeARM64RawSVETable(word); ok {
+					add("+sve")
+					if form.tableCount == 2 {
+						add("+sve2")
+					}
+				}
+				if _, ok := decodeARM64RawSVEUMULLB(word); ok {
+					add("+sve", "+sve2")
+				}
+				if _, ok := decodeARM64RawSVEMultiplyAccumulateLong(word); ok {
+					add("+sve", "+sve2")
+				}
+				if form, ok := decodeARM64RawSVEPermute(word); ok {
+					add("+sve")
+					if form.quad {
+						add("+f64mm")
+					}
+				}
+			}
 		case ArchARM:
+			if op == "WORD" && len(ins.Args) == 1 && ins.Args[0].Kind == OpImm {
+				if _, ok := decodeARMRawVFPMove(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if form, ok := decodeARMRawNEONPairwiseMinMax(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+					if form.floating && form.elementBits == 16 {
+						add("+fullfp16")
+					}
+				}
+				if form, ok := decodeARMRawNEONMinMax(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+					if form.floating && form.elementBits == 16 {
+						add("+fullfp16")
+					}
+				}
+				if _, ok := decodeARMRawVFPStatusTransfer(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if _, ok := decodeARMRawVFPScalarArithmetic(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if form, ok := decodeARMRawNEONMultiplyLane(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+					if form.floating && form.elementBits == 16 {
+						add("+fullfp16")
+					}
+				}
+				if _, ok := decodeARMRawNEONConvertFloat32(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+				if _, ok := decodeARMRawNEONMoveLong(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+				if _, ok := decodeARMRawNEONWideningSubtract(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+				if _, ok := decodeARMRawNEONDup(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+				if decoded, err := decodeARMRawWordInstruction(ins); err == nil {
+					decodedFeatures := inferFuncTargetFeaturesForGOARCH(ArchARM, goarch, Func{Instrs: []Instr{decoded}})
+					add(strings.Split(decodedFeatures, ",")...)
+				}
+				if _, ok := decodeARMRawVFPImmediate(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if _, ok := decodeARMRawVMOVPair(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if _, ok := decodeARMRawVFPMultiple(uint32(ins.Args[0].Imm)); ok {
+					add("+vfp2")
+				}
+				if _, ok := decodeARMRawNEONStructureOne(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+				if _, ok := decodeARMRawNEONEOR(uint32(ins.Args[0].Imm)); ok {
+					add("+neon")
+				}
+			}
 			// Go's ARM runtime keeps VFP save/restore instructions in the
 			// GOARM=5 image and guards their execution with goarmsoftfp. LLVM
 			// still needs VFP enabled while assembling that otherwise-dead path.
@@ -101,7 +1632,7 @@ func inferFuncTargetFeaturesForGOARCH(arch Arch, goarch string, fn Func) string
 				default:
 					continue
 				}
-				if reg == "FPCR" || reg == "FPSR" || strings.HasPrefix(reg, "F") {
+				if reg == "FPCR" || reg == "FPSR" || reg == "FPSCR" || strings.HasPrefix(reg, "F") || strings.HasPrefix(reg, "S") {
 					add("+vfp2")
 					break
 				}
@@ -115,3 +1646,52 @@ func inferFuncTargetFeaturesForGOARCH(arch Arch, goarch string, fn Func) string
 	sort.Strings(featureSet)
 	return strings.Join(featureSet, ",")
 }
+
+// These existing families need no extra ISA. This query supplies no input,
+// storage or source permission; physical forms retain their original route.
+func x86BaselineGPFeatureInstruction(op Op, ins *Instr, arch string) bool {
+	if arch != "amd64" && arch != "386" || ins.Op != op || !x86ResultNamedPredicateInstruction(*ins) {
+		return false
+	}
+	if _, known := x86LockScalarRMWSpecs[op]; known {
+		_, _, err := x86LockScalarRMWProperties(op, *ins, arch)
+		return err == nil
+	}
+	if x86LEAWidth(op, arch) != 0 {
+		_, err := x86LEAOperandWidth(*ins, arch)
+		return err == nil
+	}
+	if !isX86DirectControlTransfer(op) || isAMD64CounterZeroBranch(op) {
+		return false
+	}
+	if op == OpRET {
+		return len(ins.Args) == 0
+	}
+	// Only existing named/PC branch roles qualify. Indirect and external
+	// targets keep the original path; the CFG still owns target binding.
+	branch := *ins
+	branch.Args = x86DirectTailBranchArgs(branch)
+	_, named := fixedLocalBranchLabel(branch)
+	return named || x86DirectTailPCBranch(*ins)
+}
+
+func isAMD64RawFP16Op(op string) bool {
+	base := op
+	if dot := strings.IndexByte(op, '.'); dot >= 0 {
+		base = op[:dot]
+	}
+	if base == "VMOVSH" || base == "VMOVW" {
+		return true
+	}
+	if spec, ok := amd64HalfConversionSpecs[base]; ok {
+		return spec.rawOnly
+	}
+	if spec, ok := amd64FMA3Specs[Op(base)]; ok {
+		return spec.rawOnly && spec.laneBits == 16
+	}
+	if spec, ok := amd64SameWidthConversionSpecs[Op(base)]; ok {
+		return spec.rawOnly && spec.laneBits == 16
+	}
+	spec, ok := amd64BinaryFloatingSpecs[Op(base)]
+	return ok && spec.rawOnly && spec.laneBits == 16
+}
diff --git a/feature_attrs_test.go b/feature_attrs_test.go
index 69547866c..bb380a10a 100644
--- a/feature_attrs_test.go
+++ b/feature_attrs_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -13,6 +10,7 @@ func TestInferFuncTargetFeatures(t *testing.T) {
 		name string
 		arch Arch
 		ops  []Op
+		rows []string
 		want string
 	}{
 		{
@@ -24,25 +22,68 @@ func TestInferFuncTargetFeatures(t *testing.T) {
 		{
 			name: "amd64 pclmul",
 			arch: ArchAMD64,
-			ops:  []Op{"PCLMULQDQ"},
+			ops:  []Op{"PCLMULQDQ", "VPCLMULQDQ"},
 			want: "+pclmul,+sse4.1",
 		},
 		{
 			name: "amd64 pshufb",
 			arch: ArchAMD64,
-			ops:  []Op{"PSHUFB", "VPSHUFB"},
+			rows: []string{"PSHUFB X0,X1", "VPSHUFB X0,X1,X2"},
 			want: "+ssse3",
 		},
 		{
 			name: "amd64 aes",
 			arch: ArchAMD64,
-			ops:  []Op{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST"},
+			ops:  []Op{"AESENC", "AESENCLAST", "AESDEC", "AESDECLAST", "AESIMC", "AESKEYGENASSIST", "VAESENC", "VAESENCLAST", "VAESDEC", "VAESDECLAST", "VAESIMC", "VAESKEYGENASSIST"},
 			want: "+aes",
 		},
+		{
+			name: "amd64 cmpxchg16b",
+			arch: ArchAMD64,
+			ops:  []Op{"CMPXCHG16B"},
+			want: "+cx16",
+		},
+		{
+			name: "x86 cache line writeback",
+			arch: ArchAMD64,
+			ops:  []Op{"CLFLUSH", "CLFLUSHOPT", "CLWB"},
+			want: "+clflushopt,+clwb",
+		},
+		{
+			name: "amd64 round",
+			arch: ArchAMD64,
+			ops:  []Op{"ROUNDPS", "ROUNDPD", "ROUNDSS", "ROUNDSD", "VROUNDPS", "VROUNDPD", "VROUNDSS", "VROUNDSD"},
+			want: "+avx,+sse4.1",
+		},
+		{
+			name: "x86 reciprocal14",
+			arch: ArchAMD64,
+			ops:  []Op{"VRCP14SS", "VRSQRT14PD.Z"},
+			want: "+avx512f,+avx512vl",
+		},
+		{
+			name: "x86 raw fp16",
+			arch: ArchAMD64,
+			ops:  []Op{"VMOVSH", "VADDSH.RU_SAE", "VMAXPH.SAE", "VFMADD213SH", "VFNMADD231PH.Z"},
+			want: "+avx512fp16",
+		},
+		{
+			name: "x86 raw BF16 dot product",
+			arch: ArchAMD64,
+			ops:  []Op{"VDPBF16PS", "VDPBF16PS.BCST.Z"},
+			want: "+avx512bf16,+avx512f",
+		},
+		{
+			name: "x86 single float duplicate is not fp16",
+			arch: ArchAMD64,
+			ops:  []Op{"VMOVSHDUP"},
+			want: "",
+		},
 		{
 			name: "amd64 combined sorted deduped",
 			arch: ArchAMD64,
-			ops:  []Op{"AESENC", "CRC32L", "PCLMULQDQ", "PSHUFB", "CRC32Q", "AESDEC", "VPSHUFB"},
+			ops:  []Op{"AESENC", "CRC32L", "PCLMULQDQ", "CRC32Q", "AESDEC"},
+			rows: []string{"PSHUFB X0,X1", "VPSHUFB X0,X1,X2"},
 			want: "+aes,+crc32,+pclmul,+sse4.1,+sse4.2,+ssse3",
 		},
 		{
@@ -65,13 +106,52 @@ func TestInferFuncTargetFeatures(t *testing.T) {
 			for i, op := range tt.ops {
 				fn.Instrs[i] = Instr{Op: op}
 			}
+			for _, row := range tt.rows {
+				fn.Instrs = append(fn.Instrs, x86ScalarLaneInstruction(t, row))
+			}
 			if got := inferFuncTargetFeatures(tt.arch, fn); got != tt.want {
-				t.Fatalf("inferFuncTargetFeatures(%q, %v) = %q, want %q", tt.arch, tt.ops, got, tt.want)
+				t.Fatalf("inferFuncTargetFeatures(%q, %v, %v) = %q, want %q", tt.arch, tt.ops, tt.rows, got, tt.want)
 			}
 		})
 	}
 }
 
+func TestInferByteShuffleTargetFeaturesRequireCompleteForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ByteShuffleFormatRows(arch) {
+			fn := Func{Instrs: []Instr{x86ScalarLaneInstruction(t, row)}}
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, fn); got != "+ssse3" {
+				t.Fatal("isolated complete form lost its intrinsic feature", arch, row, got)
+			}
+		}
+		for _, row := range []string{
+			"PSHUFB", "VPSHUFB", "VPSHUFB.Z", "PSHUFB Y0,X1",
+			"VPSHUFB X0,Y1,Y2", "VPSHUFB.Z X0,X1,X2",
+			"VPSHUFB.BCST (AX),X1,X2", "VPSHUFB.SAE X0,X1,X2",
+		} {
+			fn := Func{Instrs: []Instr{x86ScalarLaneInstruction(t, row)}}
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, fn); got != "" {
+				t.Fatal("incomplete or rejected form supplied a feature", arch, row, got)
+			}
+		}
+	}
+}
+
+func TestInferFuncTargetFeaturesRawFP16VectorLength(t *testing.T) {
+	for _, op := range []Op{"VFMADD132PH", "VFMSUBADD231PH.Z", "VADDPH"} {
+		for _, reg := range []Reg{"X1", "Y1", "Z1"} {
+			fn := Func{Instrs: []Instr{{Op: op, Args: []Operand{{Kind: OpReg, Reg: reg}}}}}
+			want := "+avx512fp16"
+			if reg != "Z1" {
+				want += ",+avx512vl"
+			}
+			if got := inferFuncTargetFeatures(ArchAMD64, fn); got != want {
+				t.Fatalf("%s %s: features %q, want %q", op, reg, got, want)
+			}
+		}
+	}
+}
+
 func TestFeatureAttrRegistry(t *testing.T) {
 	r := newFeatureAttrRegistry()
 	if got := r.ref(""); got != "" {
diff --git a/floatlit_test.go b/floatlit_test.go
index d5429878e..9caa7479a 100644
--- a/floatlit_test.go
+++ b/floatlit_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
diff --git a/frame_type_size.go b/frame_type_size.go
new file mode 100644
index 000000000..967e2a53d
--- /dev/null
+++ b/frame_type_size.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+// frameTypeSize returns the byte width occupied by a scalar FrameLayout slot.
+// Pointer width is target-specific, so architecture lowerers provide it.
+func frameTypeSize(ty LLVMType, pointerSize int64) int64 {
+	switch ty {
+	case I1, I8:
+		return 1
+	case I16:
+		return 2
+	case Ptr:
+		return pointerSize
+	case I32, LLVMType("float"):
+		return 4
+	case I64, LLVMType("double"):
+		return 8
+	default:
+		// FrameLayout normally contains scalar parts. Keep enough room for an
+		// unexpected aggregate so address formation remains within the alloca.
+		return 16
+	}
+}
diff --git a/framework_child_build_byollvm_test.go b/framework_child_build_byollvm_test.go
new file mode 100644
index 000000000..eb6037661
--- /dev/null
+++ b/framework_child_build_byollvm_test.go
@@ -0,0 +1,5 @@
+//go:build byollvm
+
+package plan9asm
+
+const frameworkChildByoLLVM = true
diff --git a/framework_child_build_default_test.go b/framework_child_build_default_test.go
new file mode 100644
index 000000000..480a6a38f
--- /dev/null
+++ b/framework_child_build_default_test.go
@@ -0,0 +1,5 @@
+//go:build !byollvm
+
+package plan9asm
+
+const frameworkChildByoLLVM = false
diff --git a/framework_child_build_test.go b/framework_child_build_test.go
new file mode 100644
index 000000000..86f5c9dee
--- /dev/null
+++ b/framework_child_build_test.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"reflect"
+	"testing"
+)
+
+// This configures only child harnesses importing the translator/LLVM bindings.
+// Independent original-Go SDK/package observations must not use these flags.
+func frameworkChildGoBuildCommand(arguments ...string) *exec.Cmd {
+	flags := []string{"build", "-tags="}
+	if frameworkChildByoLLVM {
+		flags[1] = "-tags=byollvm"
+	}
+	return exec.Command("go", append(flags, arguments...)...)
+}
+
+func TestFrameworkChildGoBuildRetainsParentLLVMMode(t *testing.T) {
+	for _, flags := range []string{"", "-tags=foreign", "-tags=byollvm"} {
+		t.Run(flags, func(t *testing.T) {
+			t.Setenv("GOFLAGS", flags)
+			arguments := []string{"-trimpath", "-o", "reader", "main.go"}
+			before := append([]string(nil), arguments...)
+			command := frameworkChildGoBuildCommand(arguments...)
+			want := []string{"go", "build", "-tags="}
+			if frameworkChildByoLLVM {
+				want[2] = "-tags=byollvm"
+			}
+			want = append(want, arguments...)
+			if !reflect.DeepEqual(command.Args, want) {
+				t.Fatalf("child lost compiled parent LLVM mode: got=%v want=%v", command.Args, want)
+			}
+			if command.Env != nil || os.Getenv("GOFLAGS") != flags || !reflect.DeepEqual(arguments, before) {
+				t.Fatal("child harness construction changed original SDK environment or caller arguments")
+			}
+		})
+	}
+}
diff --git a/globl_flags.go b/globl_flags.go
new file mode 100644
index 000000000..b3856d654
--- /dev/null
+++ b/globl_flags.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var globlFlagName = regexp.MustCompile(`[A-Za-z_][A-Za-z_0-9]*`)
+
+// Values are defined by Go's runtime/textflag.h and cmd/internal/obj/textflag.go.
+// In particular NOPTR is GC metadata, not a promise that storage is immutable.
+var goTextFlagValues = map[string]string{
+	"NOPROF": "1", "DUPOK": "2", "NOSPLIT": "4", "RODATA": "8",
+	"NOPTR": "16", "WRAPPER": "32", "NEEDCTXT": "64", "TLSBSS": "256",
+	"NOFRAME": "512", "REFLECTMETHOD": "1024", "TOPFRAME": "2048", "ABIWRAPPER": "4096",
+}
+
+func globlReadOnly(flags string) (bool, error) {
+	if strings.TrimSpace(flags) == "" {
+		return false, nil
+	}
+	expression := globlFlagName.ReplaceAllStringFunc(flags, func(name string) string {
+		if value, ok := goTextFlagValues[name]; ok {
+			return value
+		}
+		return name
+	})
+	value, ok := parseImmExpr(expression)
+	if !ok {
+		return false, fmt.Errorf("unresolved GLOBL flags %q", flags)
+	}
+	return value&8 != 0, nil
+}
diff --git a/globl_flags_test.go b/globl_flags_test.go
new file mode 100644
index 000000000..ba29f5ed0
--- /dev/null
+++ b/globl_flags_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestGlobalMutabilityMatchesGoFlags(t *testing.T) {
+	for _, test := range []struct {
+		flags    string
+		constant bool
+	}{
+		{"", false}, {"0", false}, {"NOPTR", false}, {"(NOPTR|DUPOK)", false},
+		{"RODATA", true}, {"8", true}, {"(RODATA|NOPTR)", true}, {"24", true},
+		{"RODATA & ~RODATA", false}, {"1 << 3", true},
+	} {
+		t.Run(test.flags, func(t *testing.T) {
+			source := "DATA ·data(SB)/8,$42\nGLOBL ·data(SB),"
+			if test.flags != "" {
+				source += test.flags + ","
+			}
+			source += "$8\n"
+			requireX86GoAssemblerResult(t, "amd64", "#define RODATA 8\n#define NOPTR 16\n#define DUPOK 2\n"+source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, textual := range []bool{false, true} {
+				ir, err := Translate(file, Options{Goarch: "amd64", AnnotateSource: textual,
+					ResolveSym: func(s string) string { return strings.TrimPrefix(s, "·") }})
+				if err != nil {
+					t.Fatal(err)
+				}
+				kind := "global"
+				if test.constant {
+					kind = "constant"
+				}
+				if !strings.Contains(ir, fmt.Sprintf("@data = %s [8 x i8]", kind)) {
+					t.Fatalf("textual=%v: GLOBL %q did not retain mutability", textual, test.flags)
+				}
+			}
+		})
+	}
+}
+
+func TestFileLocalDataLinkage(t *testing.T) {
+	for _, flags := range []string{"16", "8"} {
+		file, err := Parse(ArchAMD64, "DATA table<>(SB)/8,$42\nGLOBL table<>(SB),"+flags+",$8\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, textual := range []bool{false, true} {
+			ir, err := Translate(file, Options{Goarch: "amd64", AnnotateSource: textual})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, " = internal ") {
+				t.Fatalf("file-local data must not collide when separately translated files are linked: %s", ir)
+			}
+		}
+	}
+}
diff --git a/globl_unresolved_size_test.go b/globl_unresolved_size_test.go
new file mode 100644
index 000000000..ec50f32fe
--- /dev/null
+++ b/globl_unresolved_size_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGloblUnresolvedSizeNeverCreatesGuessedStorage(t *testing.T) {
+	for _, expression := range []string{
+		"$const_tlsSize", "$(machTimebaseInfo__size)", "$(16 + callbackArgs__size)",
+	} {
+		t.Run(expression, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "GLOBL ·data(SB),8,"+expression+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			global := file.Globl[0]
+			if global.Size != 0 || global.SizeRaw != expression {
+				t.Errorf("unresolved global acquired guessed storage: %#v", global)
+			}
+			// A caller-supplied numeric field cannot override unresolved source.
+			file.Globl[0].Size = 64
+			for _, direct := range []bool{false, true} {
+				ctx := llvm.NewContext()
+				var module llvm.Module
+				if direct {
+					module, err = translateModuleDirectInContext(ctx, file, Options{Goarch: "amd64"})
+				} else {
+					module, err = TranslateModuleInContext(ctx, file, Options{Goarch: "amd64"})
+				}
+				created := !module.IsNil()
+				if created {
+					module.Dispose()
+				}
+				ctx.Dispose()
+				if created || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("unresolved global produced a module: direct=%t created=%t error=%v", direct, created, err)
+				}
+			}
+			var output strings.Builder
+			if err := emitDataGlobals(&output, file, func(s string) string { return s }); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != 0 {
+				t.Errorf("text emitter guessed storage: output=%q error=%v", output.String(), err)
+			}
+		})
+	}
+}
+
+func TestGloblSizeRejectsNonintegerOrMalformedExpressions(t *testing.T) {
+	for _, expression := range []string{
+		"$1.5", "$(1.5)", "$-1", "$(missing +)", "$(missing())",
+		"$(missing[0])", "$()", "$\"size\"", "$(4 / 0)", "$(missing 8)",
+	} {
+		if _, err := parseGLOBLStmt("·data(SB),8," + expression); err == nil {
+			t.Errorf("invalid storage size accepted: %s", expression)
+		}
+	}
+}
+
+func TestGloblResolvedSizesCompileAcrossArchitectures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	var source strings.Builder
+	source.WriteString("#define COUNT 4\n")
+	for index, expression := range []string{"$32", "$0x20", "$(1<<5)", "$(64/2)", "$(-(-32))", "$(COUNT*8)"} {
+		fmt.Fprintf(&source, "GLOBL data%d(SB),8,%s\n", index, expression)
+	}
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+		triple string
+	}{
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu"},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			goAssemblerOracleOutput(t, target.goarch, source.String(), "", true)
+			file, err := Parse(target.arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, global := range file.Globl {
+				if global.Size != 32 || global.SizeRaw != "" {
+					t.Fatalf("resolved integer expression changed: %#v", global)
+				}
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, Options{Goarch: target.goarch, TargetTriple: target.triple})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer module.Dispose()
+			compileLLVMToObject(t, llc, target.triple, "globals.ll", "globals.o", module.String())
+		})
+	}
+}
diff --git a/go.mod b/go.mod
index cdfd5ad38..9ad556aa9 100644
--- a/go.mod
+++ b/go.mod
@@ -2,4 +2,10 @@ module github.com/xgo-dev/plan9asm
 
 go 1.20
 
-require github.com/xgo-dev/llvm v0.9.9
+require github.com/xgo-dev/llvm v0.10.1
+
+require (
+	golang.org/x/arch v0.14.0
+	golang.org/x/mod v0.20.0
+	golang.org/x/sys v0.20.0
+)
diff --git a/go.sum b/go.sum
index b04bd084e..81df9fc68 100644
--- a/go.sum
+++ b/go.sum
@@ -1,2 +1,8 @@
-github.com/xgo-dev/llvm v0.9.9 h1:u4RZvy0vxu8nNt4oTrhttyMSyscYtmiy9geP+Kl/RYg=
-github.com/xgo-dev/llvm v0.9.9/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+github.com/xgo-dev/llvm v0.10.1 h1:GZeoapgSKC1Qgfy+xQmlIAKg0Suvrpg4U3Y3xticjqw=
+github.com/xgo-dev/llvm v0.10.1/go.mod h1:42vav2/cI5BAIcL543DZSMO9do8/aCK2z7JERH+AE+M=
+golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4=
+golang.org/x/arch v0.14.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/mod v0.20.0 h1:utOm6MM3R3dnawAiJgn0y+xvuYRsm1RKM/4giyfDgV0=
+golang.org/x/mod v0.20.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
diff --git a/go_abi0_issue44_test.go b/go_abi0_issue44_test.go
new file mode 100644
index 000000000..d36d9a4dd
--- /dev/null
+++ b/go_abi0_issue44_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These wrappers exercise the public Go binding, not only hand-built FuncSigs
+// or the command's independent signature inference. See issue #44.
+var issue44Cases = []struct {
+	name, declarations, assembly, main string
+}{
+	{
+		name: "scalar",
+		declarations: `func Y(a, b uint64) uint64
+func X(a, b uint64) uint64`,
+		assembly: `TEXT ·Y(SB),$24-24
+	MOVQ a+0(FP), AX
+	MOVQ AX, 0(SP)
+	MOVQ b+8(FP), AX
+	MOVQ AX, 8(SP)
+	CALL ·X(SB)
+	MOVQ 16(SP), AX
+	MOVQ AX, ret+16(FP)
+	RET
+`,
+		main: `extern uint64_t Y(uint64_t, uint64_t);
+uint64_t X(uint64_t a, uint64_t b) { return a * 11 + b * 3; }
+int main(void) { return Y(17, 29) == 274 ? 0 : 1; }
+`,
+	},
+	{
+		name: "result_only",
+		declarations: `func Y() uint64
+func X() uint64`,
+		assembly: `TEXT ·Y(SB),$8-8
+	CALL ·X(SB)
+	MOVQ 0(SP), AX
+	MOVQ AX, ret+0(FP)
+	RET
+`,
+		main: `extern uint64_t Y(void);
+uint64_t X(void) { return UINT64_C(0x123456789abcdef0); }
+int main(void) { return Y() == X() ? 0 : 2; }
+`,
+	},
+	{
+		name: "frame_pointer_local",
+		declarations: `func Y(a uint64) uint64
+func X(a uint64) uint64`,
+		assembly: `TEXT ·Y(SB),$24-16
+	MOVQ a+0(FP), AX
+	MOVQ AX, -8(BP)
+	MOVQ AX, 0(SP)
+	CALL ·X(SB)
+	MOVQ -8(BP), BX
+	MOVQ 8(SP), AX
+	ADDQ BX, AX
+	MOVQ AX, ret+8(FP)
+	RET
+`,
+		main: `extern uint64_t Y(uint64_t);
+uint64_t X(uint64_t a) { return a * 7; }
+int main(void) { return Y(19) == 152 ? 0 : 3; }
+`,
+	},
+	{
+		name:         "callback",
+		declarations: `func Y(a, b uint64, code uintptr) uint64`,
+		assembly: `TEXT ·Y(SB),$24-32
+	MOVQ a+0(FP), AX
+	MOVQ AX, 0(SP)
+	MOVQ b+8(FP), AX
+	MOVQ AX, 8(SP)
+	MOVQ code+16(FP), AX
+	CALL *AX
+	MOVQ 16(SP), AX
+	MOVQ AX, ret+24(FP)
+	RET
+`,
+		main: `extern uint64_t Y(uint64_t, uint64_t, uintptr_t);
+uint64_t callback(uint64_t a, uint64_t b) { return a * 11 + b * 3; }
+int main(void) { return Y(17, 29, (uintptr_t)callback) == 274 ? 0 : 4; }
+`,
+	},
+	{
+		name: "uint128",
+		declarations: `type Uint128 struct { Lo, Hi uint64 }
+func Y(t *byte, a, b Uint128, out uintptr) int32
+func X(t *byte, a, b Uint128, out uintptr) int32`,
+		assembly: `TEXT ·Y(SB),$56-52
+	MOVQ t+0(FP), AX
+	MOVQ AX, 0(SP)
+	MOVQ a_Lo+8(FP), AX
+	MOVQ AX, 8(SP)
+	MOVQ a_Hi+16(FP), AX
+	MOVQ AX, 16(SP)
+	MOVQ b_Lo+24(FP), AX
+	MOVQ AX, 24(SP)
+	MOVQ b_Hi+32(FP), AX
+	MOVQ AX, 32(SP)
+	MOVQ out+40(FP), AX
+	MOVQ AX, 40(SP)
+	CALL ·X(SB)
+	MOVL 48(SP), AX
+	MOVL AX, ret+48(FP)
+	RET
+`,
+		// LLVM literal structs and C structs have different physical ABI rules
+		// on some targets. A scalar LLVM harness below avoids conflating them.
+		main: `extern int32_t check_uint128(void);
+int main(void) { return check_uint128() == 1 ? 0 : 5; }
+`,
+	},
+}
+
+func issue44IR(t *testing.T, index int, triple string) string {
+	t.Helper()
+	tc := issue44Cases[index]
+	pkg := mustGoPackage(t, "test/issue44", "package issue44\n"+tc.declarations)
+	tr, err := TranslateGoModule(pkg, []byte(tc.assembly), GoModuleOptions{
+		GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	if err := llvm.VerifyModule(tr.Module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	ir := tr.Module.String()
+	if tc.name == "uint128" {
+		// Replace only the external declaration with an independent value oracle.
+		start := strings.Index(ir, "declare i32 @X(")
+		if start < 0 {
+			t.Fatal("missing X declaration")
+		}
+		end := start + strings.IndexByte(ir[start:], '\n')
+		ir = ir[:start] + ir[end:] + issue44Uint128Oracle
+	}
+	return ir
+}
+
+func TestIssue44ABI0Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for i, tc := range issue44Cases {
+		for _, triple := range []string{
+			"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc",
+		} {
+			t.Run(tc.name+"/"+triple, func(t *testing.T) {
+				requireX86GoAssemblerResult(t, "amd64", tc.assembly, true)
+				ir := issue44IR(t, i, triple)
+				compileLLVMToObject(t, llc, triple, "issue44.ll", "issue44.o", ir)
+			})
+		}
+	}
+}
+
+func TestIssue44ABI0Runtime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var prefix []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		triple = "x86_64-apple-macosx"
+		prefix = []string{"/usr/bin/arch", "-x86_64"}
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("executed by the required amd64 CI jobs; all target objects are checked separately")
+	}
+	for i, tc := range issue44Cases {
+		t.Run(tc.name, func(t *testing.T) {
+			ir := issue44IR(t, i, triple)
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "issue44", triple,
+				ir, "#include <stdint.h>\n"+tc.main, prefix)
+		})
+	}
+}
+
+const issue44Uint128Oracle = `
+define i32 @X(ptr %t, { i64, i64 } %a, { i64, i64 } %b, i64 %out) {
+  %a0 = extractvalue { i64, i64 } %a, 0
+  %a1 = extractvalue { i64, i64 } %a, 1
+  %b0 = extractvalue { i64, i64 } %b, 0
+  %b1 = extractvalue { i64, i64 } %b, 1
+  %c0 = icmp eq i64 %a0, 11
+  %c1 = icmp eq i64 %a1, 13
+  %c2 = icmp eq i64 %b0, 17
+  %c3 = icmp eq i64 %b1, 19
+  %c4 = icmp eq i64 %out, 23
+  %c5 = icmp eq ptr %t, null
+  %v0 = and i1 %c0, %c1
+  %v1 = and i1 %c2, %c3
+  %v2 = and i1 %c4, %c5
+  %v3 = and i1 %v0, %v1
+  %v4 = and i1 %v2, %v3
+  %result = zext i1 %v4 to i32
+  ret i32 %result
+}
+define i32 @check_uint128() {
+  %r = call i32 @Y(ptr null, { i64, i64 } { i64 11, i64 13 },
+                  { i64, i64 } { i64 17, i64 19 }, i64 23)
+  ret i32 %r
+}
+`
diff --git a/go_abi0_text_padding_test.go b/go_abi0_text_padding_test.go
new file mode 100644
index 000000000..d7ccc9d07
--- /dev/null
+++ b/go_abi0_text_padding_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const abi0PaddedSqrtDeclarations = `package padded
+func Sqrtf(x float32) float32
+func Sqrt(x float32) float32
+func SqrtByAddress(x float32) float32
+`
+
+// Keep the original TEXT and FP spellings of barnex/fmath.Sqrtf and
+// chran554/go3d/fmath.Sqrt. Logical data ends at 12; ABI0 allocates 16 bytes.
+const abi0PaddedSqrtAssembly = `TEXT ·Sqrtf+0(SB),$0-16
+	SQRTSS x+0(FP), X0
+	MOVSS X0,r+8(FP)
+	RET
+TEXT ·Sqrt+0(SB),$0-16
+	SQRTSS x+0(FP), X0
+	MOVSS X0,r+8(FP)
+	RET
+// A regression for LEA's address-of-storage semantics, not a library fixture.
+TEXT ·SqrtByAddress(SB),4,$0-16
+	LEAQ x+0(FP), AX
+	SQRTSS (AX), X0
+	LEAQ r+8(FP), BX
+	MOVSS X0,(BX)
+	RET
+`
+
+func abi0PaddedSqrtIR(t *testing.T, triple string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "example.com/padded", abi0PaddedSqrtDeclarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(abi0PaddedSqrtAssembly), GoModuleOptions{
+		GOARCH: "amd64", TargetTriple: triple,
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(sym, "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer translated.Module.Dispose()
+	if err := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	return translated.Module.String()
+}
+
+func TestGoABI0PaddedSqrtObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	requireX86GoAssemblerResult(t, "amd64", abi0PaddedSqrtAssembly, true)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "padded-sqrt.ll", "padded-sqrt.o", abi0PaddedSqrtIR(t, triple))
+		})
+	}
+}
+
+func TestGoABI0PaddedSqrtRuntime(t *testing.T) {
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable() {
+		triple, runPrefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	} else if runtime.GOARCH != "amd64" {
+		t.Skip("requires an amd64 execution host; the required Linux/amd64 suite runs this oracle")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	inputs := []uint32{
+		0, 0x80000000, 1, 0x007fffff, 0x00800000, 0x3f000000,
+		0x3f800000, 0x40000000, 0x40800000, 0x41100000, 0x7f7fffff,
+		0x7f800000, 0xbf800000, 0xff800000, 0x7fc12345, 0x7f800123,
+	}
+	var goInputs, cCases strings.Builder
+	for _, bits := range inputs {
+		fmt.Fprintf(&goInputs, "0x%08x,\n", bits)
+	}
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod":       "module example.com/padded\n\ngo 1.20\n",
+		"sqrt_amd64.s": abi0PaddedSqrtAssembly,
+		"main.go": `package main
+import "fmt"
+import "math"
+` + strings.TrimPrefix(abi0PaddedSqrtDeclarations, "package padded\n") + `
+func main() {
+    for _, bits := range []uint32{` + goInputs.String() + `} {
+        x := math.Float32frombits(bits)
+        fmt.Println(math.Float32bits(Sqrtf(x)), math.Float32bits(Sqrt(x)), math.Float32bits(SqrtByAddress(x)))
+    }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	args := []string{"run"}
+	if len(runPrefix) != 0 {
+		args = append(args, "-exec", strings.Join(runPrefix, " "))
+	}
+	args = append(args, ".")
+	cmd := exec.Command("go", args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOARCH=amd64", "CGO_ENABLED=0", "GOWORK=off", "GOTOOLCHAIN=local")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("actual Go source runtime oracle: %v\n%s", err, output)
+	}
+	fields := strings.Fields(string(output))
+	if len(fields) != len(inputs)*3 {
+		t.Fatalf("unexpected Go runtime output: %s", output)
+	}
+	for i, input := range inputs {
+		want := math.Float32bits(float32(math.Sqrt(float64(math.Float32frombits(input)))))
+		for fn, name := range []string{"Sqrtf", "Sqrt", "SqrtByAddress"} {
+			got, err := strconv.ParseUint(fields[3*i+fn], 10, 32)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !math.IsNaN(float64(math.Float32frombits(want))) && uint32(got) != want {
+				t.Fatalf("Go %s(%08x) = %08x, want %08x", name, input, got, want)
+			}
+			if math.IsNaN(float64(math.Float32frombits(want))) && !math.IsNaN(float64(math.Float32frombits(uint32(got)))) {
+				t.Fatalf("Go %s(%08x) did not produce NaN", name, input)
+			}
+			fmt.Fprintf(&cCases, "{ UINT32_C(%d), UINT32_C(%d), %s },\n", input, got, name)
+		}
+	}
+	main := `#include <stdint.h>
+#include <string.h>
+#include <math.h>
+extern float Sqrtf(float), Sqrt(float), SqrtByAddress(float);
+int main(void) {
+    struct { uint32_t input, expected; float (*call)(float); } cases[] = {
+` + cCases.String() + `
+    };
+    for (unsigned repeat = 0; repeat < 64; repeat++) {
+        for (unsigned i = 0; i < sizeof(cases)/sizeof(cases[0]); i++) {
+            float input, result, expected;
+            uint32_t actual;
+            volatile uint64_t canary = UINT64_C(0x123456789abcdef0);
+            memcpy(&input, &cases[i].input, 4);
+            memcpy(&expected, &cases[i].expected, 4);
+            result = cases[i].call(input);
+            memcpy(&actual, &result, 4);
+            if (isnan(expected) ? !isnan(result) : actual != cases[i].expected) return 1;
+            if (canary != UINT64_C(0x123456789abcdef0)) return 2;
+        }
+    }
+    return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "padded-sqrt", triple, abi0PaddedSqrtIR(t, triple), main, runPrefix)
+}
+
+func requireStaleNamedFPGoDiagnostic(t *testing.T, original string) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module example.com/legacy\n\ngo 1.20\n",
+		"legacy.go": `package legacy
+func legacyresults(a, b, c, d, e, f, g uint32) (retax, retbx, retcx, retdx, retsi, retdi, retbp uint32)
+`,
+		// Bind only the fixture's standalone TEXT symbol into a Go package;
+		// keep its original body, declared frame and all FP displacements.
+		"legacy_386.s": "#include \"textflag.h\"\n" + strings.Replace(original, "TEXT legacyresults(SB)", "TEXT ·legacyresults(SB)", 1),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	env := append(os.Environ(), "GOOS=linux", "GOARCH=386", "CGO_ENABLED=0", "GOWORK=off", "GOTOOLCHAIN=local")
+	build := exec.Command("go", "list", "-export", ".")
+	build.Dir, build.Env = dir, env
+	if output, err := build.CombinedOutput(); err != nil {
+		t.Fatalf("Go assembler rejected the independently encodable fixture: %v\n%s", err, output)
+	}
+	vet := exec.Command("go", "vet", "-asmdecl", ".")
+	vet.Dir, vet.Env = dir, env
+	output, err := vet.CombinedOutput()
+	if err == nil || !strings.Contains(string(output), "invalid offset retcx+40(FP); expected retcx+36(FP)") ||
+		!strings.Contains(string(output), "invalid offset retbp+56(FP); expected retbp+52(FP)") {
+		t.Fatalf("actual Go did not establish the original stale FP offsets: %v\n%s", err, output)
+	}
+}
+
+func TestX86NamedFPDisplacementsRemainAuthoritative(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		resultOffset, triple := int64(8), "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			resultOffset, triple = 4, "i386-unknown-linux-gnu"
+		}
+		for _, test := range []struct {
+			name, operand string
+			wantErr       bool
+		}{
+			{"correct offset", fmt.Sprintf("r+%d(FP)", resultOffset), false},
+			{"different descriptive name", fmt.Sprintf("other+%d(FP)", resultOffset), false},
+			{"tail padding", fmt.Sprintf("r+%d(FP)", resultOffset+4), true},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT Copy(SB),4,$0-%d\nMOVL x+0(FP),AX\nMOVL AX,%s\nRET\n", resultOffset+4, test.operand)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{
+					"Copy": {Name: "Copy", Args: []LLVMType{I32}, Ret: I32,
+						Frame: FrameLayout{
+							Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1, Name: "x"}},
+							Results: []FrameSlot{{Offset: resultOffset, Type: I32, Index: 0, Field: -1, Name: "r"}},
+						}},
+				}}
+				// Repeat on the same parsed file; lowering must not mutate the
+				// source operand or depend on a prior signature's name mapping.
+				for repeat := 0; repeat < 2; repeat++ {
+					_, err := Translate(file, opt)
+					if (err != nil) != test.wantErr {
+						t.Fatalf("text API accepted/changed displacement: %v", err)
+					}
+					ctx := llvm.NewContext()
+					module, err := TranslateModuleInContext(ctx, file, opt)
+					if err == nil {
+						module.Dispose()
+					}
+					ctx.Dispose()
+					if (err != nil) != test.wantErr {
+						t.Fatalf("module API accepted/changed displacement: %v", err)
+					}
+				}
+				if got := file.Funcs[0].Instrs[2].Args[1].String(); got != test.operand {
+					t.Fatalf("lowering changed original FP operand: %s", got)
+				}
+			})
+		}
+	}
+}
diff --git a/go_arm64_byte_carrier_native.go b/go_arm64_byte_carrier_native.go
new file mode 100644
index 000000000..aefd276a8
--- /dev/null
+++ b/go_arm64_byte_carrier_native.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func (source *GoARM64ByteCarrierSource) bindNative(ctx context.Context, environment map[string]string) error {
+	guard := source.guard
+	// This is an observation of the actual ordinary driver namespace, not a
+	// request-controlled alias or an entry capability. Both tools use pkgPath.
+	driver, err := guard.read(filepath.Join(guard.env["GOROOT"], "src/cmd/go/internal/work/gc.go"))
+	if err != nil {
+		return err
+	}
+	const ordinaryPackageRule = `func pkgPath(a *Action) string {
+	p := a.Package
+	ppath := p.ImportPath
+	if cfg.BuildBuildmode == "plugin" {
+		ppath = pluginPath(a)
+	} else if p.Name == "main" && !p.Internal.ForceLibrary {
+		ppath = "main"
+	}
+	return ppath
+}`
+	if !bytes.Contains(driver, []byte(ordinaryPackageRule)) ||
+		!bytes.Contains(driver, []byte("defaultGcFlags := []string{\"-p\", pkgpath}")) ||
+		!bytes.Contains(driver, []byte("base.Tool(\"asm\"), \"-p\", pkgpath")) {
+		return arm64ByteCarrierContext("ordinary compiler/assembler package namespace rule differs")
+	}
+	nativePackage := source.request.PackagePath
+	if guard.selection.Name == "main" {
+		nativePackage = "main"
+	}
+	source.report.NativePackagePath = nativePackage
+	builtins, err := guard.read(filepath.Join(guard.env["GOROOT"], "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		return err
+	}
+	source.report.OriginalArchive, err = guard.read(guard.selection.Export)
+	if err != nil {
+		return err
+	}
+	source.report.Archive, err = gostaticstorage.ObserveARM64AssemblyArchive(source.report.OriginalArchive, builtins, source.request.Target, guard.selection.SFiles)
+	if err != nil {
+		return arm64ByteCarrierContext("complete actual compiler/archive role: %v", err)
+	}
+	goos, _, _ := strings.Cut(source.request.Target, "/")
+	output := filepath.Join(guard.owned, "original.o")
+	arguments := []string{"tool", "asm", "-S", "-p", nativePackage,
+		"-I", source.request.Directory, "-I", filepath.Join(guard.env["GOROOT"], "pkg/include")}
+	for _, define := range GoAssemblerDefinesWithEnv(goos, "arm64", environment) {
+		arguments = append(arguments, "-D", define)
+	}
+	arguments = append(arguments, "-o", output, filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	source.report.OriginalListing, err = guard.run(ctx, arguments...)
+	if err != nil {
+		return arm64ByteCarrierContext("actual original assembler command: %v", err)
+	}
+	source.record(source.report.OriginalListing, arguments...)
+	source.report.OriginalObject, err = guard.read(output)
+	if err != nil {
+		return err
+	}
+	source.report.Standalone, err = gostaticstorage.ObserveARM64AssemblyText(source.report.OriginalObject, builtins, source.request.Target)
+	if err != nil || len(source.report.Standalone) != len(source.file.Funcs) {
+		return arm64ByteCarrierContext("complete original TEXT source inventory differs: %v", err)
+	}
+	archived := source.report.Archive[2].Texts
+	if len(archived) != len(source.report.Standalone) {
+		return arm64ByteCarrierContext("archive/standalone TEXT inventory differs")
+	}
+	texts := make(map[string]gostaticstorage.TextRecord)
+	functions := make(map[string]Func)
+	for ordinal, fn := range source.file.Funcs {
+		text, prior := source.report.Standalone[ordinal], archived[ordinal]
+		name := numericalNativeName(fn.Sym, nativePackage)
+		if text.Name != name || text.ABI != 0 || text.Name != prior.Name || text.ABI != prior.ABI ||
+			text.Size != prior.Size || !bytes.Equal(text.Code, prior.Code) || !numericalRelocationEqual(text.Relocations, prior.Relocations) ||
+			len(text.Code)%4 != 0 || len(text.Positions) == 0 || len(prior.Positions) == 0 {
+			return arm64ByteCarrierContext("complete original source/standalone/archive instruction join differs")
+		}
+		texts[name], functions[name] = text, fn
+	}
+	// Retain every original compiler entry, not just the hand-written callee.
+	// Requiring the actual ABIInternal wrapper does not assert that arbitrary
+	// future callers or code-address entry paths are supported by LLVM.
+	entries := make(map[string]bool)
+	for _, text := range source.report.Archive[1].Texts {
+		if text.ABI == 1 {
+			entries[text.Name] = true
+		}
+	}
+	for name := range source.report.Declarations {
+		if !entries[nativePackage+"."+name] {
+			return arm64ByteCarrierContext("original complete compiler entry is missing: %s", name)
+		}
+	}
+	for _, fn := range source.file.Funcs {
+		callerName := numericalNativeName(fn.Sym, nativePackage)
+		caller := texts[callerName]
+		var calls []struct {
+			ordinal int
+			name    string
+		}
+		for ordinal, instruction := range fn.Instrs {
+			if instruction.Op == "TEXT" {
+				continue
+			}
+			if instruction.Op == "CALL" {
+				if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpSym {
+					return arm64ByteCarrierContext("indirect/native-address call lacks a closed source target")
+				}
+				base, offset, valid := parseSBRef(instruction.Args[0].Sym)
+				name := numericalNativeName(base, nativePackage)
+				if !valid || offset != 0 || texts[name].Name == "" {
+					return arm64ByteCarrierContext("external/offset call lacks a same-file source target")
+				}
+				calls = append(calls, struct {
+					ordinal int
+					name    string
+				}{ordinal, name})
+				continue
+			}
+			if instruction.Op != "RET" {
+				if bits, _ := arm64ScalarMemoryBits(instruction.Op); bits == 0 {
+					return arm64ByteCarrierContext("first observation requires the complete scalar move/call source role: %s", instruction.Op)
+				}
+			}
+			for _, operand := range instruction.Args {
+				if operand.Kind == OpSym || operand.Kind == OpFPAddr || operand.Kind == OpImm && (operand.ImmRaw != "" || operand.ImmIsFloat) ||
+					operand.Kind == OpMem && (operand.Mem.Sym != "" || operand.Mem.Index != "" || operand.Mem.Base != "RSP") ||
+					operand.Kind == OpReg && (operand.Reg == "RSP" || operand.Reg == "R29" || operand.Reg == "R30" || operand.Reg == "g") {
+					return arm64ByteCarrierContext("code/storage/frame-address escape requires a separate producer")
+				}
+			}
+		}
+		if len(caller.Relocations) != len(calls) {
+			return arm64ByteCarrierContext("original call/source relocation inventory differs")
+		}
+		for ordinal, relocation := range caller.Relocations {
+			call := calls[ordinal]
+			callee := texts[call.name]
+			if relocation.Type != 9 || relocation.Size != 4 || relocation.Add != 0 || relocation.Offset < 0 || relocation.Offset%4 != 0 ||
+				relocation.Offset+8 > int64(len(caller.Code)) || relocation.Target.Name != callee.Name ||
+				!relocation.Target.ABIKnown || relocation.Target.ABI != 0 ||
+				binary.LittleEndian.Uint32(caller.Code[relocation.Offset:])&0xfc000000 != 0x94000000 {
+				return arm64ByteCarrierContext("actual original direct-call/ABI/continuation record differs")
+			}
+			position, err := source.callPosition(caller, relocation.Offset, fn.Instrs[call.ordinal].Raw)
+			if err != nil {
+				return err
+			}
+			// The initial native-width result class is a leaf ABI0 callee. Its
+			// unchanged SP is the original caller's SP at this exact call. Keep
+			// actual memory effects as observations, not allocated padding fields.
+			calleeFn := functions[callee.Name]
+			if calleeFn.FrameSize != 0 || len(callee.Relocations) != 0 {
+				return arm64ByteCarrierContext("callee native frame/calls need a separate SP transition observation")
+			}
+			reads, writes, err := arm64ByteCarrierLeafMemory(callee)
+			if err != nil {
+				return err
+			}
+			declaration := source.declarations[strings.TrimPrefix(callee.Name, nativePackage+".")]
+			for _, read := range reads {
+				matched := false
+				for _, field := range declaration.Frame.Params {
+					matched = matched || read.Offset == field.Offset+8 && read.Bytes == frameTypeSize(field.Type, 8)
+				}
+				if !matched {
+					return arm64ByteCarrierContext("native parameter bytes need a separate initialized caller observation")
+				}
+			}
+			for _, write := range writes {
+				matched := false
+				for _, field := range declaration.Frame.Results {
+					matched = matched || write.Offset == field.Offset+8 && write.Bytes >= frameTypeSize(field.Type, 8)
+				}
+				if !matched {
+					return arm64ByteCarrierContext("native store is not the declared-result-start rule class")
+				}
+			}
+			source.report.Calls = append(source.report.Calls, arm64ByteCarrierCall{
+				Caller: caller.Name, Callee: callee.Name, SourceInstruction: call.ordinal,
+				CallPC: relocation.Offset, ContinuationPC: relocation.Offset + 4,
+				CallerCode: sha256.Sum256(caller.Code), CalleeCode: sha256.Sum256(callee.Code),
+				OriginalCall: relocation, Position: position, CalleeSPReads: reads, SPWrites: writes,
+			})
+		}
+		physicalCalls := 0
+		for pc := 0; pc < len(caller.Code); pc += 4 {
+			if binary.LittleEndian.Uint32(caller.Code[pc:])&0xfc000000 == 0x94000000 {
+				physicalCalls++
+			}
+		}
+		if physicalCalls != len(calls) {
+			return arm64ByteCarrierContext("native direct calls are not exhausted by original source relocations")
+		}
+	}
+	if len(source.report.Calls) == 0 {
+		return arm64ByteCarrierContext("source has no actual same-file caller/callee region to observe")
+	}
+	return nil
+}
+
+func (source *GoARM64ByteCarrierSource) callPosition(text gostaticstorage.TextRecord, pc int64, raw string) (gostaticstorage.TextPosition, error) {
+	filename := filepath.Join(source.request.Directory, source.request.AssemblyFile)
+	lines := strings.Split(string(source.report.Sources[source.request.AssemblyFile]), "\n")
+	for _, position := range text.Positions {
+		// The original Go object uses slash spelling on Windows. Decode only
+		// that spelling, without granting an SDK alias or cleaning source paths.
+		physical, valid := originalGoObjectSourcePath(position.File, "")
+		if valid && position.Start <= pc && position.End >= pc+4 && physical == filename && position.Line > 0 && int(position.Line) <= len(lines) &&
+			strings.TrimSpace(lines[position.Line-1]) == raw {
+			return position, nil
+		}
+	}
+	return gostaticstorage.TextPosition{}, arm64ByteCarrierContext("actual call/source ordinal/physical PC mapping differs")
+}
+
+func arm64ByteCarrierLeafMemory(text gostaticstorage.TextRecord) (reads, writes []arm64ByteCarrierMemory, result error) {
+	returned := false
+	for pc := 0; pc < len(text.Code); pc += 4 {
+		word := binary.LittleEndian.Uint32(text.Code[pc:])
+		if returned && word == 0 {
+			continue // retained original alignment bytes, never executable authority
+		}
+		if word == 0xd65f03c0 && !returned {
+			returned = true
+			continue
+		}
+		// Original scalar unsigned-offset loads/stores only. A leaf has no SP
+		// adjustment, writeback, aliases, hidden call or arbitrary native entry.
+		if returned || word&0x3b000000 != 0x39000000 || word&(1<<26) != 0 || (word>>5)&31 != 31 || (word>>22)&3 > 1 {
+			return nil, nil, arm64ByteCarrierContext("native leaf contains an unobserved SP transition/effect")
+		}
+		width := int64(1) << (word >> 30)
+		memory := arm64ByteCarrierMemory{PC: int64(pc), Offset: int64(word>>10&4095) * width, Bytes: width, Instruction: word}
+		if word&(1<<22) != 0 {
+			reads = append(reads, memory)
+		} else {
+			writes = append(writes, memory)
+		}
+	}
+	if !returned || len(reads) == 0 || len(writes) == 0 {
+		return nil, nil, arm64ByteCarrierContext("native caller region lacks a complete input/store/return observation")
+	}
+	return reads, writes, nil
+}
diff --git a/go_arm64_byte_carrier_source.go b/go_arm64_byte_carrier_source.go
new file mode 100644
index 000000000..837a0e49f
--- /dev/null
+++ b/go_arm64_byte_carrier_source.go
@@ -0,0 +1,617 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type GoARM64ByteCarrierCaptureRequest struct {
+	GoBinary, Directory, PackagePath, AssemblyFile, Target string
+	Environment                                            []string
+}
+
+// GoARM64ByteCarrierSource observes a complete private numeric source, original
+// compiler entries and same-file ABI0 caller/callee objects. Capture and its
+// portable readback do not provide Options, writable padding or entry authority.
+type GoARM64ByteCarrierSource struct {
+	mu           sync.Mutex
+	identity     *GoARM64ByteCarrierSource
+	ready        bool
+	lease        context.Context // the original bounded capture lease, never supplied by a report or later Options
+	request      GoARM64ByteCarrierCaptureRequest
+	guard        *GoAMD64FrameSource // physical inputs/commands/cleanup only; no frame factory
+	dirs         map[string]os.FileInfo
+	files        map[string]os.FileInfo
+	file         *File
+	declarations map[string]FuncSig
+	report       arm64ByteCarrierReport
+	raw          []byte
+	seal         [32]byte
+	stateSeal    [32]byte
+}
+
+type arm64ByteCarrierReport struct {
+	Protocol                     string
+	NativePackagePath            string
+	Request                      GoARM64ByteCarrierCaptureRequest
+	RawSelection, RawEnvironment []byte
+	Sources                      map[string][]byte
+	Inputs                       map[string][32]byte
+	OriginalArchive              []byte
+	OriginalObject               []byte
+	OriginalListing              []byte
+	Archive                      []gostaticstorage.TextMember
+	Standalone                   []gostaticstorage.TextRecord
+	Declarations                 map[string]string
+	Calls                        []arm64ByteCarrierCall
+	Commands                     []numericalSBCommand
+}
+
+// A call observation binds exact original bytes and its physical continuation.
+// It is deliberately not a writable extent, native-state lease or FrameLayout.
+type arm64ByteCarrierCall struct {
+	Caller, Callee          string
+	SourceInstruction       int
+	CallPC, ContinuationPC  int64
+	CallerCode, CalleeCode  [32]byte
+	OriginalCall            gostaticstorage.TextRelocation
+	Position                gostaticstorage.TextPosition
+	CalleeSPReads, SPWrites []arm64ByteCarrierMemory
+}
+
+type arm64ByteCarrierMemory struct {
+	PC, Offset, Bytes int64
+	Instruction       uint32
+}
+
+func arm64ByteCarrierContext(format string, arguments ...any) error {
+	return fmt.Errorf("%w: actual ARM64 byte-carrier source: %s", ErrProbeNeedsContext, fmt.Sprintf(format, arguments...))
+}
+
+func arm64ByteCarrierLive(ctx context.Context) error {
+	if ctx == nil {
+		return arm64ByteCarrierContext("requires a bounded live context")
+	}
+	if ctx.Err() != nil {
+		return errors.Join(arm64ByteCarrierContext("context expired"), ctx.Err(), context.Cause(ctx))
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return arm64ByteCarrierContext("requires a bounded live context")
+	}
+	return nil
+}
+
+func CaptureGoARM64ByteCarrierSource(ctx context.Context, request GoARM64ByteCarrierCaptureRequest) (_ *GoARM64ByteCarrierSource, captureErr error) {
+	if err := arm64ByteCarrierLive(ctx); err != nil {
+		return nil, err
+	}
+	goos, arch, valid := strings.Cut(request.Target, "/")
+	if !valid || arch != "arm64" || !arm64ByteCarrierOS(goos) || request.PackagePath == "" ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || !strings.HasSuffix(request.AssemblyFile, ".s") {
+		return nil, arm64ByteCarrierContext("requires actual ARM64 source/tool/profile inputs")
+	}
+	request.Environment = append([]string(nil), request.Environment...)
+	provided := make(map[string]string)
+	for _, pair := range request.Environment {
+		key, value, valid := strings.Cut(pair, "=")
+		if !valid || key == "" {
+			return nil, arm64ByteCarrierContext("malformed command environment")
+		}
+		if _, duplicate := provided[key]; duplicate {
+			return nil, arm64ByteCarrierContext("duplicate command environment")
+		}
+		provided[key] = value
+	}
+	for key, value := range map[string]string{
+		"GOOS": goos, "GOARCH": "arm64", "GOARM64": "v8.0", "GOAMD64": "v1",
+		"CGO_ENABLED": "0", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOPROXY": "off",
+	} {
+		if provided[key] != value {
+			return nil, arm64ByteCarrierContext("unbound command profile: %s", key)
+		}
+	}
+	if provided["GOPACKAGESDRIVER"] != "" && provided["GOPACKAGESDRIVER"] != "off" {
+		return nil, arm64ByteCarrierContext("external package driver has no original-source mapping")
+	}
+	source := &GoARM64ByteCarrierSource{
+		request: request, lease: ctx, dirs: make(map[string]os.FileInfo), files: make(map[string]os.FileInfo),
+		declarations: make(map[string]FuncSig),
+	}
+	source.identity = source
+	source.guard = newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: request.AssemblyFile,
+		Target: request.Target, Environment: request.Environment,
+	})
+	for _, name := range []string{request.Directory, provided["GOCACHE"], provided["GOMODCACHE"], provided["GOPATH"], provided["TMPDIR"], provided["GOTMPDIR"]} {
+		physical, err := sourcepath.Resolve(name)
+		info, statErr := sourcepath.Lstat(name)
+		if !filepath.IsAbs(name) || err != nil || physical != name || statErr != nil || !info.IsDir() {
+			return nil, arm64ByteCarrierContext("missing or redirected source/command root")
+		}
+		source.dirs[name] = info
+	}
+	if err := source.guard.snapshotDirectory(); err != nil {
+		return nil, err
+	}
+	owned, err := os.MkdirTemp(provided["TMPDIR"], "plan9asm-arm64-byte-carrier-")
+	if err != nil {
+		return nil, err
+	}
+	source.guard.owned, source.guard.ownedInfo = owned, nil
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if captureErr != nil {
+			captureErr = errors.Join(captureErr, source.Close())
+			if ctx.Err() != nil {
+				captureErr = errors.Join(captureErr, ctx.Err(), context.Cause(ctx))
+			}
+		}
+	}()
+	if err := source.observe(ctx); err != nil {
+		return nil, err
+	}
+	if err := gostaticstorage.ValidateOwnedSourceDirectory(request.Directory, source.guard.env["GOROOT"], provided["GOMODCACHE"]); err != nil {
+		return nil, arm64ByteCarrierContext("original source owner role: %v", err)
+	}
+	// TMPDIR itself is not an external-source role: private first-party fixtures
+	// may live there. Only the actual build cache and this factory's artifact
+	// directory are forbidden here; no public Main metadata can override them.
+	for _, root := range []string{provided["GOCACHE"], owned} {
+		inside, err := gostaticstorage.SourceDirectoryWithinRoot(request.Directory, root)
+		if err != nil || inside {
+			return nil, arm64ByteCarrierContext("source occupies a cache/artifact role: %v", err)
+		}
+	}
+	selected, raw, err := source.guard.loadWithRaw(ctx)
+	if err != nil {
+		return nil, arm64ByteCarrierContext("actual complete source export: %v", err)
+	}
+	source.guard.selection = selected
+	if selected.ImportPath != request.PackagePath || selected.Dir != request.Directory || selected.Standard || selected.ForTest != "" ||
+		selected.Module == nil || !selected.Module.Main || selected.Module.Dir != request.Directory || selected.Module.Path != request.PackagePath ||
+		selected.Module.Version != "" || len(selected.Module.Replace) != 0 && string(selected.Module.Replace) != "null" ||
+		selected.Module.GoMod != filepath.Join(request.Directory, "go.mod") || selected.nonordinaryRole() || len(selected.Imports) != 0 ||
+		len(selected.GoFiles) == 0 || len(selected.SFiles) != 1 || selected.SFiles[0] != request.AssemblyFile {
+		return nil, arm64ByteCarrierContext("requires a complete flat private numeric owned-main selection")
+	}
+	source.report = arm64ByteCarrierReport{
+		Protocol: "actual_go_arm64_byte_carrier_observation_v1", Request: request,
+		RawSelection: append([]byte(nil), raw...), RawEnvironment: source.report.RawEnvironment,
+		Sources: make(map[string][]byte), Declarations: make(map[string]string), Commands: source.report.Commands,
+	}
+	source.record(raw, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+	if err := source.bindDeclarations(); err != nil {
+		return nil, err
+	}
+	if err := source.bindNative(ctx, provided); err != nil {
+		return nil, err
+	}
+	source.report.Inputs = source.guard.inputs
+	for name := range source.guard.inputs {
+		info, err := sourcepath.Lstat(name)
+		if err != nil || !info.Mode().IsRegular() {
+			return nil, arm64ByteCarrierContext("original input identity changed before sealing")
+		}
+		source.files[name] = info
+	}
+	source.raw, err = json.Marshal(source.report)
+	if err != nil || len(source.raw) > 64<<20 {
+		return nil, arm64ByteCarrierContext("bounded complete observation: %v", err)
+	}
+	source.seal, source.ready = sha256.Sum256(source.raw), true
+	state, err := source.stateBytes()
+	if err != nil {
+		return nil, err
+	}
+	source.stateSeal = sha256.Sum256(state)
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func arm64ByteCarrierOS(goos string) bool {
+	switch goos {
+	case "darwin", "linux", "windows", "freebsd", "openbsd":
+		return true
+	}
+	return false
+}
+
+func (source *GoARM64ByteCarrierSource) record(stdout []byte, arguments ...string) {
+	source.report.Commands = append(source.report.Commands, numericalSBCommand{
+		Directory: source.request.Directory, Binary: source.request.GoBinary,
+		Arguments: append([]string(nil), arguments...), Stdout: append([]byte(nil), stdout...),
+	})
+}
+
+func (source *GoARM64ByteCarrierSource) observe(ctx context.Context) error {
+	if err := source.guard.observe(ctx); err != nil {
+		return err
+	}
+	if !gotoolchain.AuditedGo127(source.guard.env["GOVERSION"]) {
+		return arm64ByteCarrierContext("unobserved original SDK version")
+	}
+	for _, name := range []string{source.guard.env["GOROOT"], source.guard.env["GOTOOLDIR"], filepath.Join(source.guard.env["GOROOT"], "pkg/include")} {
+		physical, err := sourcepath.Resolve(name)
+		info, statErr := sourcepath.Lstat(name)
+		if err != nil || physical != name || statErr != nil || !info.IsDir() {
+			return arm64ByteCarrierContext("actual SDK root is redirected or unavailable")
+		}
+		if before, exists := source.dirs[name]; exists {
+			if !os.SameFile(before, info) {
+				return arm64ByteCarrierContext("actual SDK root identity changed")
+			}
+		} else {
+			source.dirs[name] = info
+		}
+	}
+	for _, name := range []string{
+		"src/cmd/internal/obj/arm64/asm7.go", "src/cmd/internal/obj/arm64/obj7.go",
+		"src/cmd/internal/goobj/builtinlist.go", "src/cmd/internal/objabi/reloctype.go",
+		"src/cmd/compile/internal/abi/abiutils.go", "src/cmd/compile/internal/ssa/config.go",
+		"src/cmd/go/internal/load/pkg.go",
+		"src/cmd/go/internal/list/list.go",
+		"src/cmd/go/internal/work/init.go",
+		"src/cmd/go/internal/work/gc.go",
+		"src/internal/platform/supported.go",
+	} {
+		if _, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(name))); err != nil {
+			return err
+		}
+	}
+	raw, err := source.guard.run(ctx, "env", "-json", "GOROOT", "GOVERSION", "GOOS", "GOARCH", "GOARM64", "CGO_ENABLED", "GOTOOLCHAIN", "GOFLAGS", "GOEXPERIMENT", "GOCACHE", "GOMODCACHE", "GOTMPDIR", "GOPATH")
+	if err != nil {
+		return err
+	}
+	var actual map[string]string
+	if json.Unmarshal(raw, &actual) != nil || actual["GOARM64"] != "v8.0" || actual["CGO_ENABLED"] != "0" || actual["GOTOOLCHAIN"] != "local" {
+		return arm64ByteCarrierContext("actual original ARM64 profile differs")
+	}
+	for key, value := range source.guard.env {
+		if observed, exists := actual[key]; exists && observed != value {
+			return arm64ByteCarrierContext("actual original environment differs: %s", key)
+		}
+	}
+	if source.report.RawEnvironment == nil {
+		source.report.RawEnvironment = append([]byte(nil), raw...)
+		source.record(raw, "env", "-json", "GOROOT", "GOVERSION", "GOOS", "GOARCH", "GOARM64", "CGO_ENABLED", "GOTOOLCHAIN", "GOFLAGS", "GOEXPERIMENT", "GOCACHE", "GOMODCACHE", "GOTMPDIR", "GOPATH")
+	} else if !bytes.Equal(source.report.RawEnvironment, raw) {
+		return arm64ByteCarrierContext("complete original environment changed")
+	}
+	return nil
+}
+
+func (source *GoARM64ByteCarrierSource) bindDeclarations() error {
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	var compiled []string
+	bodyless := make(map[string]bool)
+	for _, name := range source.guard.selection.GoFiles {
+		data, err := source.guard.read(filepath.Join(source.request.Directory, name))
+		if err != nil {
+			return err
+		}
+		source.report.Sources[name] = data
+		file, err := parser.ParseFile(fset, name, data, parser.ParseComments)
+		if err != nil {
+			return arm64ByteCarrierContext("original Go syntax: %v", err)
+		}
+		for _, comment := range file.Comments {
+			for _, line := range comment.List {
+				if strings.Contains(line.Text, "go:") {
+					return arm64ByteCarrierContext("linkname/directive source needs separate entry ownership")
+				}
+			}
+		}
+		for _, declaration := range file.Decls {
+			fn, valid := declaration.(*ast.FuncDecl)
+			if !valid || fn.Recv != nil || ast.IsExported(fn.Name.Name) || fn.Type.TypeParams != nil {
+				return arm64ByteCarrierContext("source is not a closed private numeric function set")
+			}
+			if fn.Body == nil {
+				bodyless[fn.Name.Name] = true
+			}
+		}
+		syntax = append(syntax, file)
+		compiled = append(compiled, filepath.Join(source.request.Directory, name))
+	}
+	sort.Strings(compiled)
+	actual := append([]string(nil), source.guard.selection.CompiledGoFiles...)
+	for index, name := range actual {
+		if !filepath.IsAbs(name) {
+			actual[index] = filepath.Join(source.request.Directory, name)
+		}
+	}
+	sort.Strings(actual)
+	if !reflect.DeepEqual(compiled, actual) || len(bodyless) == 0 {
+		return arm64ByteCarrierContext("effective source mapping omits the original declarations")
+	}
+	info := &types.Info{Uses: make(map[*ast.Ident]types.Object)}
+	sizes := types.SizesFor("gc", "arm64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(source.request.PackagePath, fset, syntax, info)
+	if err != nil || typed.Name() != source.guard.selection.Name {
+		return arm64ByteCarrierContext("complete original numeric typecheck: %v", err)
+	}
+	for _, name := range typed.Scope().Names() {
+		fn, valid := typed.Scope().Lookup(name).(*types.Func)
+		if !valid {
+			return arm64ByteCarrierContext("nonfunction global role")
+		}
+		signature := fn.Type().(*types.Signature)
+		if signature.Variadic() || signature.TypeParams().Len() != 0 || signature.Recv() != nil {
+			return arm64ByteCarrierContext("custom/generic numeric entry transport")
+		}
+		for _, tuple := range []*types.Tuple{signature.Params(), signature.Results()} {
+			if tuple.Len() > 32 {
+				return arm64ByteCarrierContext("numeric transport tuple exceeds its bound")
+			}
+			for index := 0; index < tuple.Len(); index++ {
+				basic, valid := tuple.At(index).Type().(*types.Basic)
+				if !valid || basic.Info()&types.IsInteger == 0 {
+					return arm64ByteCarrierContext("pointer/aggregate/noninteger transport needs a separate producer")
+				}
+			}
+		}
+		source.report.Declarations[name] = types.TypeString(signature, nil)
+		if bodyless[name] {
+			derived, err := DeriveGoFuncABI0Signature(source.request.PackagePath+"."+name, fn, "arm64", sizes)
+			if err != nil {
+				return arm64ByteCarrierContext("actual original typed ABI0 declaration: %v", err)
+			}
+			source.declarations[name] = derived
+		}
+	}
+	// Every reference to a function is an original direct call. Copying a
+	// function into a variable, returning it or taking its code address must not
+	// silently open the otherwise private entry boundary.
+	called := make(map[*ast.Ident]bool)
+	for _, file := range syntax {
+		ast.Inspect(file, func(node ast.Node) bool {
+			if call, valid := node.(*ast.CallExpr); valid {
+				if name, direct := call.Fun.(*ast.Ident); direct {
+					called[name] = true
+				}
+			}
+			return true
+		})
+	}
+	for name, object := range info.Uses {
+		if _, function := object.(*types.Func); function && !called[name] {
+			return arm64ByteCarrierContext("original Go function address escapes the closed direct-call set")
+		}
+	}
+	data, err := source.guard.read(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil {
+		return err
+	}
+	source.report.Sources[source.request.AssemblyFile] = data
+	// This first producer accepts literal complete source only. CPP/raw data,
+	// private-address entries and external SB references need separate joins.
+	if strings.Contains(string(data), "#") {
+		return arm64ByteCarrierContext("CPP source requires actual origin binding")
+	}
+	source.file, err = Parse(ArchARM64, string(data))
+	if err != nil || len(source.file.Data) != 0 || len(source.file.Globl) != 0 || len(source.file.UnlinkedPrelude) != 0 || len(source.file.Funcs) != len(bodyless) {
+		return arm64ByteCarrierContext("complete literal assembly source differs: %v", err)
+	}
+	seen := make(map[string]bool)
+	for _, fn := range source.file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		if !bodyless[name] || seen[name] || fn.Sym != "·"+name || fn.FrameSize < 0 || fn.FrameSize > 4096 || fn.ArgSize < 0 || fn.ArgSize > 4096 {
+			return arm64ByteCarrierContext("assembly declaration/entry identity differs")
+		}
+		seen[name] = true
+		declared := source.declarations[name]
+		var end int64
+		for _, fields := range [][]FrameSlot{declared.Frame.Params, declared.Frame.Results} {
+			for _, field := range fields {
+				if next := field.Offset + frameTypeSize(field.Type, 8); next > end {
+					end = next
+				}
+			}
+		}
+		if fn.ArgSize != end {
+			return arm64ByteCarrierContext("original TEXT args differs from the complete declared fields")
+		}
+		for _, instruction := range fn.Instrs {
+			for _, operand := range instruction.Args {
+				if operand.Kind != OpFP {
+					continue
+				}
+				found := false
+				for _, fields := range [][]FrameSlot{declared.Frame.Params, declared.Frame.Results} {
+					for _, field := range fields {
+						found = found || operand.FPOffset == field.Offset
+					}
+				}
+				if !found {
+					return arm64ByteCarrierContext("FP source lacks an exact original declared field start")
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (source *GoARM64ByteCarrierSource) Readback(ctx context.Context) ([]byte, error) {
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready || source.identity != source {
+		return nil, arm64ByteCarrierContext("source closed after verification")
+	}
+	if err := arm64ByteCarrierLive(source.lease); err != nil {
+		source.ready = false
+		return nil, err
+	}
+	return append([]byte(nil), source.raw...), nil
+}
+
+func (source *GoARM64ByteCarrierSource) Verify(ctx context.Context) (verifyErr error) {
+	if source == nil {
+		return arm64ByteCarrierContext("missing live source observation")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if source.identity != source {
+		return arm64ByteCarrierContext("copied or uninitialized source identity")
+	}
+	defer func() {
+		if verifyErr != nil {
+			source.ready = false
+			if source.lease != nil && source.lease.Err() != nil {
+				verifyErr = errors.Join(verifyErr, source.lease.Err(), context.Cause(source.lease))
+			}
+			if ctx != nil && ctx.Err() != nil {
+				verifyErr = errors.Join(verifyErr, ctx.Err(), context.Cause(ctx))
+			}
+		}
+	}()
+	if !source.ready {
+		return arm64ByteCarrierContext("closed or revoked source")
+	}
+	runContext, release, err := source.executionContext(ctx)
+	if err != nil {
+		return err
+	}
+	defer release()
+	state, err := source.stateBytes()
+	if err != nil || sha256.Sum256(state) != source.stateSeal || sha256.Sum256(source.raw) != source.seal {
+		return arm64ByteCarrierContext("sealed complete original observation changed")
+	}
+	for name, before := range source.dirs {
+		physical, err := sourcepath.Resolve(name)
+		after, statErr := os.Lstat(name)
+		if err != nil || physical != name || statErr != nil || !after.IsDir() || !os.SameFile(before, after) {
+			return arm64ByteCarrierContext("source/cache/temporary root identity changed")
+		}
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return err
+	}
+	if err := source.verifyFileIdentities(); err != nil {
+		return err
+	}
+	before := source.guard.env
+	if err := source.observe(runContext); err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(before, source.guard.env) {
+		return arm64ByteCarrierContext("actual original tool/profile changed")
+	}
+	selected, raw, err := source.guard.loadWithRaw(runContext)
+	// Reuse the existing exact original-Go selection comparator. Only the
+	// pinned SDK's typed Stale/StaleReason display fields can change after the
+	// first -export builds its cache entry; every semantic field and both whole
+	// stdout records stay bound. A fresh cache is not a source change.
+	if err != nil || !reflect.DeepEqual(selected, source.guard.selection) || !numericalSameRawSelection(raw, source.report.RawSelection) {
+		return arm64ByteCarrierContext("actual complete compiler selection/export changed: %v", err)
+	}
+	return errors.Join(source.guard.verifyInputs(), source.verifyFileIdentities(),
+		arm64ByteCarrierLive(source.lease), arm64ByteCarrierLive(ctx))
+}
+
+// executionContext obeys both the later operation context and the actual
+// original capture owner. It cannot renew the lease. The small watcher is
+// joined on release; this works on Go 1.20 without context.AfterFunc.
+func (source *GoARM64ByteCarrierSource) executionContext(ctx context.Context) (context.Context, func(), error) {
+	if err := errors.Join(arm64ByteCarrierLive(source.lease), arm64ByteCarrierLive(ctx)); err != nil {
+		return nil, nil, err
+	}
+	deadline, _ := source.lease.Deadline()
+	base, cancelCause := context.WithCancelCause(ctx)
+	bounded, cancelDeadline := context.WithDeadline(base, deadline)
+	closed := make(chan struct{})
+	lease := source.lease
+	go func() {
+		defer close(closed)
+		select {
+		case <-lease.Done():
+			cancelCause(context.Cause(lease))
+		case <-bounded.Done():
+		}
+	}()
+	release := func() {
+		cancelDeadline()
+		cancelCause(context.Canceled)
+		<-closed
+	}
+	return bounded, release, nil
+}
+
+func (source *GoARM64ByteCarrierSource) verifyFileIdentities() error {
+	if len(source.files) != len(source.guard.inputs) {
+		return arm64ByteCarrierContext("complete input identity inventory changed")
+	}
+	for name, before := range source.files {
+		after, err := os.Lstat(name)
+		if err != nil || !after.Mode().IsRegular() || !os.SameFile(before, after) {
+			return arm64ByteCarrierContext("original file identity changed: %s", filepath.Base(name))
+		}
+	}
+	return nil
+}
+
+func (source *GoARM64ByteCarrierSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if source.identity != source {
+		return arm64ByteCarrierContext("copied source cannot release another factory's artifacts")
+	}
+	source.ready = false
+	if source.guard == nil {
+		return nil
+	}
+	return source.guard.Close()
+}
+
+func (source *GoARM64ByteCarrierSource) stateBytes() ([]byte, error) {
+	identities := make(map[string]string)
+	for name, info := range source.dirs {
+		identities["directory:"+name] = fmt.Sprintf("%#v", info.Sys())
+	}
+	for name, info := range source.files {
+		identities["file:"+name] = fmt.Sprintf("%#v", info.Sys())
+	}
+	return json.Marshal(struct {
+		Report       arm64ByteCarrierReport
+		Request      GoARM64ByteCarrierCaptureRequest
+		GuardRequest GoAMD64FrameCaptureRequest
+		Selection    goAMD64FrameSelection
+		Environment  map[string]string
+		Entries      []string
+		File         *File
+		Declarations map[string]FuncSig
+		Owned        string
+		Identities   map[string]string
+	}{source.report, source.request, source.guard.request, source.guard.selection, source.guard.env, source.guard.entries, source.file, source.declarations, source.guard.owned, identities})
+}
diff --git a/go_assembler_defect_go127_test.go b/go_assembler_defect_go127_test.go
new file mode 100644
index 000000000..2e27ffe3e
--- /dev/null
+++ b/go_assembler_defect_go127_test.go
@@ -0,0 +1,157 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+type goAssemblerDefectObservation struct {
+	source, original, object string
+	output                   []byte
+	commandErr, contextErr   error
+}
+
+func observeGoAssemblerMalformedInput(t *testing.T, original, experiment string) goAssemblerDefectObservation {
+	t.Helper()
+	dir := t.TempDir()
+	observation := goAssemblerDefectObservation{
+		source: filepath.Join(dir, "forms.s"), original: original,
+		object: filepath.Join(dir, "forms.o"),
+	}
+	if err := os.WriteFile(observation.source, []byte(original), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "example.com/forms", "-o", observation.object, observation.source)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64")
+	if experiment != "" {
+		command.Env = append(command.Env, "GOEXPERIMENT="+experiment)
+	}
+	observation.output, observation.commandErr = runtimeOracleCombinedOutput(ctx, command)
+	observation.contextErr = ctx.Err()
+	return observation
+}
+
+// This recognizes an observed compiler defect, not a successful compilation
+// or a Go operand-rejection certificate. Ordinary form oracles still reject
+// every panic and exit 2. Only these separately named regression tests may
+// observe the exact panic/stack pairs, and no resulting object is consumed.
+func goAssemblerMalformedInputOutcome(observation goAssemblerDefectObservation, panicText, stackFrame string) (bool, error) {
+	if panicText == "" || stackFrame == "" {
+		return false, fmt.Errorf("known-defect observation requires its exact panic and stack")
+	}
+	data, ok := goAssemblerOracleFixture(observation.source)
+	if !ok || string(data) != observation.original {
+		return false, fmt.Errorf("known-defect observation lost its original source")
+	}
+	if err := goAssemblerOracleOutcome(observation.source, observation.object, observation.output,
+		observation.commandErr, observation.contextErr, false, "arm64"); err == nil {
+		return false, nil // A future assembler may diagnose this source normally.
+	}
+	if observation.contextErr != nil {
+		return false, fmt.Errorf("known-defect observation canceled: %w", observation.contextErr)
+	}
+	exit, ok := observation.commandErr.(*exec.ExitError)
+	if !ok || exit.ProcessState == nil || !exit.ProcessState.Exited() || exit.ExitCode() != 2 {
+		return false, fmt.Errorf("known-defect observation has an unexpected process outcome: %v", observation.commandErr)
+	}
+	output := string(observation.output)
+	for _, marker := range []string{"fatal error:", "runtime: failed to", "runtime: out of memory", "executable file not found"} {
+		if strings.Contains(output, marker) {
+			return false, fmt.Errorf("known-defect observation infrastructure failure: %s", marker)
+		}
+	}
+	if !strings.Contains(output, "panic: "+panicText) || !strings.Contains(output, stackFrame) {
+		return false, fmt.Errorf("known-defect observation has an unknown panic or stack")
+	}
+	return true, nil
+}
+
+func TestGoAssemblerKnownMalformedInputDefects(t *testing.T) {
+	tests := []struct {
+		name, source, experiment, panicText, stackFrame string
+	}{
+		{"missing-vector-constant-operand", "TEXT badvectorconstant(SB),$0-0\n\tVMOVQ $1, V1\n\tRET\n", "",
+			"runtime error: invalid memory address or nil pointer dereference", "cmd/internal/obj/arm64.progedit("},
+		{"neon-register-in-sve-index", "TEXT badsveindex(SB),$0-0\n\tZINDEX R0, R1, V0.D\n\tRET\n", "simd",
+			"unknown AClass, addr =", "cmd/internal/obj/arm64.aclass("},
+		{"cross-text-target", arm64PrivateRegisterHelperSource("4,$0-0", "CALL mix<>(SB)") +
+			"TEXT ·Escape(SB),4,$0-0\nB -3(PC)\n", "",
+			"setting branch target when type is not TYPE_BRANCH", "cmd/internal/obj.(*Addr).SetTarget("},
+	}
+	for _, op := range arm64NamedPCBranchOps {
+		for _, target := range []string{"999(PC)", "-999(PC)", "9223372036854775807(PC)", "-9223372036854775808(PC)"} {
+			tests = append(tests, struct {
+				name, source, experiment, panicText, stackFrame string
+			}{
+				op + "/" + target,
+				"TEXT pcInvalid(SB),$0-24\n" + arm64NamedPCBranchInstruction(op, target) + "\nRET\n", "",
+				"setting branch target when type is not TYPE_BRANCH", "cmd/internal/obj.(*Addr).SetTarget(",
+			})
+		}
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			observation := observeGoAssemblerMalformedInput(t, test.source, test.experiment)
+			defect, err := goAssemblerMalformedInputOutcome(observation, test.panicText, test.stackFrame)
+			if err != nil {
+				t.Fatalf("%v\n%s\noriginal source:\n%s", err, observation.output, test.source)
+			}
+			if defect {
+				t.Logf("GO_ASSEMBLER_DEFECT_OBSERVATION: %s; not Go form-rejection or object-compilation evidence\n%s", test.panicText, observation.output)
+			}
+		})
+	}
+}
+
+func TestGoAssemblerMalformedInputObservationRejectsInfrastructure(t *testing.T) {
+	const source = "TEXT badvectorconstant(SB),$0-0\n\tVMOVQ $1, V1\n\tRET\n"
+	actual := observeGoAssemblerMalformedInput(t, source, "")
+	const panicText = "runtime error: invalid memory address or nil pointer dereference"
+	const stack = "cmd/internal/obj/arm64.progedit("
+	if _, err := goAssemblerMalformedInputOutcome(actual, "", ""); err == nil {
+		t.Fatal("empty known-defect identity accepted")
+	}
+	accepted := observeGoAssemblerMalformedInput(t, "TEXT valid(SB),$0-0\nRET\n", "")
+	if _, err := goAssemblerMalformedInputOutcome(accepted, panicText, stack); err == nil {
+		t.Fatal("a successful object became a source-defect observation")
+	}
+	for _, change := range []string{"no output", "unrelated panic", "missing stack", "changed source", "joined cleanup", "deadline", "launch", "late infrastructure"} {
+		t.Run(change, func(t *testing.T) {
+			observation := actual
+			switch change {
+			case "no output":
+				observation.output = nil
+			case "unrelated panic":
+				observation.output = []byte("panic: unknown compiler error\n" + stack)
+			case "missing stack":
+				observation.output = []byte("panic: " + panicText)
+			case "changed source":
+				observation.original += "RET\n"
+			case "joined cleanup":
+				observation.commandErr = errors.Join(actual.commandErr, errors.New("owned cleanup failure"))
+			case "deadline":
+				observation.contextErr = context.DeadlineExceeded
+			case "launch":
+				observation.commandErr = errors.New("compiler launch failed")
+			case "late infrastructure":
+				observation.output = append(append([]byte(nil), actual.output...), []byte("fatal error: out of memory\n")...)
+			}
+			if _, err := goAssemblerMalformedInputOutcome(observation, panicText, stack); err == nil {
+				t.Fatal("unknown tool/infrastructure outcome became a known source-defect observation")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_arm64_branch_listing_test.go b/go_assembler_oracle_arm64_branch_listing_test.go
new file mode 100644
index 000000000..5d41403cc
--- /dev/null
+++ b/go_assembler_oracle_arm64_branch_listing_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleActualARM64BranchAliasListings(t *testing.T) {
+	for _, test := range []struct{ name, instruction string }{
+		{"branch-register", "B R0"},
+		{"branch-vector", "B V0"},
+		{"branch-vector-address", "B (V0)"},
+		{"call-displaced-address", "BL 8(R1)"},
+		{"call-stack-register", "BL RSP"},
+		{"call-vector", "BL V0"},
+		{"call-immediate", "BL $1"},
+		{"call-suffix", "BL.P R1"},
+		{"call-writeback-suffix", "BL.W R1"},
+		{"call-mixed-suffix", "BL.W.P R1"},
+		{"call-repeated-suffix", "BL.P.P R1"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, test.instruction)
+			object := filepath.Join(filepath.Dir(source), "forms.o")
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, time.Minute)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil ||
+				!strings.Contains(string(observed.Stderr), "illegal combination:") {
+				t.Fatalf("actual original branch-family refusal absent: %+v %v", observed, err)
+			}
+			if failure := goAssemblerOracleOutcome(source, object, append(observed.Stdout, observed.Stderr...),
+				err, ctx.Err(), false, "arm64"); failure != nil {
+				t.Fatalf("actual original branch alias refusal lost: %v\n%s", failure, observed.Stderr)
+			}
+			if goasmoracle.SourceDiagnosticLine(source, string(observed.Stderr), 2) {
+				t.Fatal("default diagnostic parser acquired architecture aliases")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_arm64_directory_go127_test.go b/go_assembler_oracle_arm64_directory_go127_test.go
new file mode 100644
index 000000000..3fc9e043a
--- /dev/null
+++ b/go_assembler_oracle_arm64_directory_go127_test.go
@@ -0,0 +1,90 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestGoAssemblerOracleARM64CompleteActualClassDirectory(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm64/anames7.go")
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := make(map[string]bool)
+	ast.Inspect(file, func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || declaration.Names[0].Name != "cnames7" {
+			return true
+		}
+		if len(declaration.Values) != 1 {
+			t.Fatal("original complete class directory shape changed")
+		}
+		array, ok := declaration.Values[0].(*ast.CompositeLit)
+		if !ok {
+			t.Fatal("original complete class directory is not a literal")
+		}
+		for _, value := range array.Elts {
+			literal, ok := value.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("original class entry is not a lexical name")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if name != "" {
+				if names[name] {
+					t.Fatal("duplicate original class name")
+				}
+				names[name] = true
+			}
+		}
+		return false
+	})
+	if !reflect.DeepEqual(names, goAssemblerOracleARM64Classes) {
+		t.Fatalf("complete actual DRconv namespace differs: %v / %v", names, goAssemblerOracleARM64Classes)
+	}
+}
+
+func TestGoAssemblerOracleARM64CompleteActualAddrTypes(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/link.go")
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	ast.Inspect(file, func(node ast.Node) bool {
+		entry, ok := node.(*ast.ValueSpec)
+		if !ok || len(entry.Names) != 1 || !strings.HasPrefix(entry.Names[0].Name, "TYPE_") {
+			return true
+		}
+		if entry.Names[0].Name == "TYPE_NONE" {
+			if len(entry.Values) != 1 {
+				t.Fatal("original address-type ordinal initializer changed")
+			}
+			initial, ok := entry.Values[0].(*ast.Ident)
+			if !ok || initial.Name != "iota" {
+				t.Fatal("original address-type ordinals do not start at zero")
+			}
+		} else if len(entry.Values) != 0 {
+			t.Fatal("original address-type ordinal overridden")
+		}
+		names = append(names, entry.Names[0].Name)
+		return false
+	})
+	want := strings.Fields(`TYPE_NONE TYPE_BRANCH TYPE_TEXTSIZE TYPE_MEM TYPE_CONST TYPE_FCONST
+		TYPE_SCONST TYPE_REG TYPE_ADDR TYPE_SHIFT TYPE_REGREG TYPE_REGREG2 TYPE_INDIR TYPE_REGLIST TYPE_SPECIAL`)
+	if !reflect.DeepEqual(names, want) {
+		t.Fatalf("complete actual AddrType directory changed: %v", names)
+	}
+}
diff --git a/go_assembler_oracle_arm64_listing_roles_test.go b/go_assembler_oracle_arm64_listing_roles_test.go
new file mode 100644
index 000000000..1e66a0e55
--- /dev/null
+++ b/go_assembler_oracle_arm64_listing_roles_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func arm64BranchDiagnostic(source, listing, classes string) string {
+	return "asm: illegal combination: 00000 (" + source + ":2) " + listing + " " + classes + "\n"
+}
+
+func TestGoAssemblerOracleARM64CompleteBranchListingRoles(t *testing.T) {
+	for _, alias := range []struct{ source, listing string }{{"B", "JMP"}, {"BL", "CALL"}} {
+		t.Run(alias.source, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, alias.source+" R0")
+			for class := range goAssemblerOracleARM64Classes {
+				for position := 0; position < 5; position++ {
+					classes := []string{"NONE", "NONE", "NONE", "REG", "NONE"}
+					classes[position] = class
+					output := arm64BranchDiagnostic(source, alias.listing+" R0", strings.Join(classes, " ")+", 0 7")
+					if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64", output) {
+						t.Fatalf("complete DRconv class %s/%d lost", class, position)
+					}
+					if goasmoracle.SourceDiagnosticLine(source, output, 2) {
+						t.Fatal("default diagnostic acquired ARM64 aliases")
+					}
+				}
+			}
+			for kind := 0; kind <= 14; kind++ {
+				for _, types := range []string{fmt.Sprintf("%d 7", kind), fmt.Sprintf("0 %d", kind)} {
+					if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64",
+						arm64BranchDiagnostic(source, alias.listing+" R0", "NONE NONE NONE REG NONE, "+types)) {
+						t.Fatalf("complete AddrType ordinal lost: %s", types)
+					}
+				}
+			}
+			for _, suffix := range []struct{ source, listing string }{
+				{"", ""}, {".P", ".P"}, {".W", ".W"}, {".P.W", ".P.W"},
+				{".W.P", ".P.W"}, {".P.P", ".P"}, {".W.P.W", ".P.W"},
+			} {
+				for _, args := range []string{"", "R0", "(V0)", "$1", "8(R1)", "R0,R1", "R0,R1,R2", "R0,R1,R2,R3"} {
+					fixture := x86DiagnosticFixture(t, strings.TrimSpace(alias.source+suffix.source+" "+args))
+					if !goAssemblerOracleARM64SourceDiagnostic(fixture, "arm64", arm64BranchDiagnostic(fixture,
+						strings.TrimSpace(alias.listing+suffix.listing+" "+args), "NONE NONE NONE REG NONE, 0 7")) {
+						t.Fatalf("complete alias suffix/cardinality lost: %s %s", suffix.source, args)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleARM64BranchListingRejectsUnboundMetadata(t *testing.T) {
+	source := x86DiagnosticFixture(t, "BL R0")
+	// Go 1.20 prints four complete DRconv classes; current Go prints five.
+	// Both are diagnostic schemas, not accepted instruction or ABI authority.
+	for _, schema := range []struct{ name, tail string }{
+		{"historical_four", "NONE NONE NONE REG, 0 7"},
+		{"historical_four_reg_third", "NONE NONE REG NONE, 0 7"},
+		{"current_five", "NONE NONE NONE REG NONE, 0 7"},
+	} {
+		t.Run(schema.name, func(t *testing.T) {
+			if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source, "CALL R0", schema.tail)) {
+				t.Fatalf("complete diagnostic schema lost: %q", schema.tail)
+			}
+		})
+	}
+
+	for _, tail := range []string{
+		"", "NONE NONE REG, 0 7", "NONE NONE NONE REG NONE NONE, 0 7",
+		"NONE NONE NONE C_?? NONE, 0 7", "NONE NONE NONE UNKNOWN NONE, 0 7",
+		"NONE NONE NONE REG NONE, -1 7", "NONE NONE NONE REG NONE, 15 7",
+		"NONE NONE NONE REG NONE, 0 15", "NONE NONE NONE REG NONE, 00 7",
+		"NONE NONE NONE REG NONE, +0 7", "NONE NONE NONE REG NONE, 0 7 extra",
+	} {
+		if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source, "CALL R0", tail)) {
+			t.Errorf("malformed/unmodeled metadata bound: %q", tail)
+		}
+	}
+	output := arm64BranchDiagnostic(source, "CALL R0", "NONE NONE NONE REG NONE, 0 7")
+	for _, changed := range []string{
+		strings.Replace(output, "CALL R0", "CALL R1", 1),
+		strings.Replace(output, "CALL R0", "CALL", 1),
+		strings.Replace(output, "CALL R0", "JMP R0", 1),
+		strings.Replace(output, "CALL R0", "CALL.P R0", 1),
+		strings.Replace(output, "illegal combination:", "invalid instruction:", 1),
+		strings.Replace(output, "00000", "0", 1),
+		strings.Replace(output, source+":2", source+":3", 1),
+		strings.Replace(output, source+":2", "foreign"+source+":2", 1),
+	} {
+		if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", changed) {
+			t.Errorf("alias escaped exact source/backend/operand boundary: %q", changed)
+		}
+	}
+	for _, arch := range []string{"386", "amd64", "arm", "wasm", ""} {
+		if goAssemblerOracleARM64SourceDiagnostic(source, arch, output) {
+			t.Errorf("alias escaped target: %q", arch)
+		}
+	}
+}
diff --git a/go_assembler_oracle_arm64_listing_test.go b/go_assembler_oracle_arm64_listing_test.go
new file mode 100644
index 000000000..f334da23a
--- /dev/null
+++ b/go_assembler_oracle_arm64_listing_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// This namespace describes DRconv's diagnostic metadata, not accepted operand
+// forms or ISA support. AUTO/OREG share the complete Go displacement directory.
+var goAssemblerOracleARM64Classes = func() map[string]bool {
+	result := make(map[string]bool)
+	for _, name := range strings.Fields(`
+		NONE REG ZREG RSP FREG VREG PAIR SHIFT EXTREG SPR COND SPOP ARNG ELEM LIST
+		ZCON ABCON0 ADDCON0 ABCON AMCON ADDCON MBCON MOVCON BITCON ADDCON2 LCON
+		MOVCON2 MOVCON3 VCON FCON VCONADDR AACON AACON2 LACON AECON SBRA LBRA
+		SEXT1 SEXT2 SEXT4 SEXT8 SEXT16 LEXT ADDR GOTADDR TLS_LE TLS_IE ROFF GOK TEXTSIZE NCLASS
+	`) {
+		result[name] = true
+	}
+	for _, address := range []string{"AUTO", "OREG"} {
+		for _, form := range strings.Fields(`
+			Z@ NS@ NS@_16 NS@_8 NS@_4 NP@ NP@_16 NQ@_16 N@4K
+			PS@ PS@_16 PS@_8 PS@_4 PP@ PP@_16 PQ@_16
+			U@4K U@4K_16 U@4K_8 U@4K_4 U@4K_2
+			U@8K U@8K_16 U@8K_8 U@8K_4 U@16K U@16K_16 U@16K_8
+			U@32K U@32K_16 U@64K L@POOL L@
+		`) {
+			result[strings.Replace(form, "@", address, 1)] = true
+		}
+	}
+	return result
+}()
+
+// Go 1.22-1.23 already print five classes and pool names, but retain the
+// UAUTO32K_8 spelling. Class spelling and diagnostic arity changed separately.
+var goAssemblerOracleARM64TransitionalClasses = func() map[string]bool {
+	result := make(map[string]bool, len(goAssemblerOracleARM64Classes))
+	for name := range goAssemblerOracleARM64Classes {
+		result[name] = true
+	}
+	delete(result, "UAUTO32K_16")
+	result["UAUTO32K_8"] = true
+	return result
+}()
+
+var goAssemblerOracleARM64HistoricalClasses = func() map[string]bool {
+	result := make(map[string]bool, len(goAssemblerOracleARM64TransitionalClasses))
+	for name := range goAssemblerOracleARM64TransitionalClasses {
+		result[name] = true
+	}
+	delete(result, "LAUTOPOOL")
+	delete(result, "LOREGPOOL")
+	return result
+}()
+
+func goAssemblerOracleARM64SourceDiagnostic(source, arch, output string) bool {
+	if arch != "arm64" {
+		return false
+	}
+	for _, line := range strings.Split(output, "\n") {
+		if strings.HasPrefix(line, "asm: illegal combination: ") &&
+			goasmoracle.SourceDiagnosticLineWithListing(source, line, 0, goAssemblerOracleARM64Listing) {
+			return true
+		}
+	}
+	return false
+}
+
+func goAssemblerOracleARM64Suffix(suffix string) (string, bool) {
+	if suffix == "" {
+		return "", true
+	}
+	post, pre := false, false
+	for _, part := range strings.Split(strings.TrimPrefix(suffix, "."), ".") {
+		switch part {
+		case "P":
+			post = true
+		case "W":
+			pre = true
+		default:
+			return "", false
+		}
+	}
+	canonical := ""
+	if post {
+		canonical += ".P"
+	}
+	if pre {
+		canonical += ".W"
+	}
+	return canonical, true
+}
+
+func goAssemblerOracleARM64Listing(original, listing []string) bool {
+	for _, schema := range []struct {
+		slots   int
+		classes map[string]bool
+	}{
+		{5, goAssemblerOracleARM64Classes},
+		{5, goAssemblerOracleARM64TransitionalClasses},
+		{4, goAssemblerOracleARM64HistoricalClasses},
+	} {
+		if goAssemblerOracleARM64ListingSchema(original, listing, schema.slots, schema.classes) {
+			return true
+		}
+	}
+	return false
+}
+
+func goAssemblerOracleARM64ListingSchema(original, listing []string, slots int, classes map[string]bool) bool {
+	tailSize := slots + 3 // Complete class directory, comma, From.Type, To.Type.
+	if len(listing) <= tailSize {
+		return false
+	}
+	tail := listing[len(listing)-tailSize:]
+	for _, class := range tail[:slots] {
+		if !classes[class] {
+			return false
+		}
+	}
+	if tail[slots] != "," {
+		return false
+	}
+	for _, text := range tail[slots+1:] {
+		kind, err := strconv.Atoi(text)
+		if err != nil || kind < 0 || kind > 14 || strconv.Itoa(kind) != text {
+			return false
+		}
+	}
+	sourceOp, sourceSuffix, args, sourceOK := goAssemblerOracleX86Statement(original)
+	listedOp, listedSuffix, listedArgs, listedOK := goAssemblerOracleX86Statement(listing[:len(listing)-tailSize])
+	if !sourceOK || !listedOK {
+		return false
+	}
+	canonical, valid := goAssemblerOracleARM64Suffix(sourceSuffix)
+	if !valid || listedSuffix != canonical {
+		return false
+	}
+	alias := ""
+	switch sourceOp {
+	case "B":
+		alias = "JMP"
+	case "BL":
+		alias = "CALL"
+	}
+	if alias == "" || listedOp != alias {
+		return false
+	}
+	if reflect.DeepEqual(args, listedArgs) {
+		return true
+	}
+	// asmJump's two-operand form puts the first operand in From. A bare
+	// symbol is TYPE_MEM/NAME_NONE with zero offset, not a To TYPE_BRANCH
+	// label. Dconv prints only that offset; no label-PC rewrite is allowed.
+	return len(args) == 2 && len(listedArgs) == 2 && len(args[0]) == 1 &&
+		goAssemblerOracleARM64BareSymbol(args[0][0]) &&
+		len(args[1]) == 1 && goAssemblerOracleARM64Register(args[1][0]) &&
+		reflect.DeepEqual(listedArgs[0], []string{"0"}) &&
+		reflect.DeepEqual(args[1], listedArgs[1]) &&
+		tail[0] == "ZOREG" && tail[slots+1] == "3" && tail[slots+2] == "7"
+}
diff --git a/go_assembler_oracle_arm64_namespace_roles_test.go b/go_assembler_oracle_arm64_namespace_roles_test.go
new file mode 100644
index 000000000..76f316a03
--- /dev/null
+++ b/go_assembler_oracle_arm64_namespace_roles_test.go
@@ -0,0 +1,205 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleARM64SelectedRegisterNamespace(t *testing.T) {
+	expected := map[string]bool{"RSP": true, "ZR": true, "LR": true, "R18_PLATFORM": true,
+		"g": true, "SB": true, "FP": true, "PC": true, "SP": true}
+	for number := 0; number < 32; number++ {
+		if number < 31 && number != 18 && number != 28 {
+			expected["R"+strconv.Itoa(number)] = true
+		}
+		expected["F"+strconv.Itoa(number)] = true
+		expected["V"+strconv.Itoa(number)] = true
+	}
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go")
+	data, valid := goasmoracle.ReadSource(path)
+	if !valid {
+		t.Fatal("original selected arch namespace unavailable")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "archArm64" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || arm64OracleASTText(assignment.Lhs[0]) != "registerPrefix" {
+				return true
+			}
+			literal := assignment.Rhs[0].(*ast.CompositeLit)
+			for _, element := range literal.Elts {
+				pair := element.(*ast.KeyValueExpr)
+				prefix, err := strconv.Unquote(pair.Key.(*ast.BasicLit).Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+				maximum := 0
+				switch prefix {
+				case "Z":
+					maximum = 32
+				case "P", "PN":
+					maximum = 16
+				case "F", "R", "V":
+				default:
+					t.Fatalf("unmodeled original namespace bank %s", prefix)
+				}
+				for number := 0; number < maximum; number++ {
+					expected[prefix+strconv.Itoa(number)] = true
+				}
+			}
+			return false
+		})
+	}
+	ast.Inspect(arm64OracleOriginalSDKFile(t, "sysRegEnc.go"), func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || value.Names[0].Name != "SystemReg" {
+			return true
+		}
+		for _, element := range value.Values[0].(*ast.CompositeLit).Elts {
+			name, err := strconv.Unquote(element.(*ast.CompositeLit).Elts[0].(*ast.BasicLit).Value)
+			if err != nil || expected[name] {
+				t.Fatal("duplicate or malformed original system-register name")
+			}
+			expected[name] = true
+		}
+		return false
+	})
+	arm64OracleLoadLexicalNames()
+	if !reflect.DeepEqual(expected, arm64OracleLexicalNames.registers) {
+		t.Fatalf("complete actual cmd/asm namespace differs: %v / %v", expected, arm64OracleLexicalNames.registers)
+	}
+	for name := range expected {
+		if goAssemblerOracleARM64BareSymbol(name) {
+			t.Fatalf("registered name %s borrowed bare symbol formatting", name)
+		}
+	}
+}
+
+func TestGoAssemblerOracleARM64SelectedSpecialNamespace(t *testing.T) {
+	file := arm64OracleOriginalSDKFile(t, "specialoperand_string.go")
+	var names string
+	var offsets []int
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+			return true
+		}
+		switch value.Names[0].Name {
+		case "_SpecialOperand_name":
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING || names != "" {
+				t.Fatal("original complete special string directory changed")
+			}
+			var err error
+			names, err = strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+		case "_SpecialOperand_index":
+			array, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok || len(offsets) != 0 {
+				t.Fatal("original complete special index directory changed")
+			}
+			for _, element := range array.Elts {
+				literal, ok := element.(*ast.BasicLit)
+				if !ok || literal.Kind != token.INT {
+					t.Fatal("original special index is not a literal")
+				}
+				offset, err := strconv.Atoi(literal.Value)
+				if err != nil || len(offsets) > 0 && offset <= offsets[len(offsets)-1] {
+					t.Fatal("original special index is not increasing")
+				}
+				offsets = append(offsets, offset)
+			}
+		}
+		return false
+	})
+	if len(offsets) < 3 || offsets[0] != 0 || offsets[len(offsets)-1] != len(names) ||
+		names[offsets[len(offsets)-2]:] != "END" {
+		t.Fatal("complete original special directory bounds absent")
+	}
+	arm64OracleLoadLexicalNames()
+	expected := make(map[string]bool)
+	for name := range arm64OracleLexicalNames.registers {
+		expected[name] = true
+	}
+	expected["CS"], expected["CC"] = true, true
+	for index := 0; index < len(offsets)-2; index++ {
+		name := names[offsets[index]:offsets[index+1]]
+		if expected[name] {
+			t.Fatal("duplicate original lexical name")
+		}
+		expected[name] = true
+		t.Run(name, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, "BL "+name+",R1")
+			if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+				"CALL 0,R1", "ZOREG NONE NONE REG NONE, 3 7")) {
+				t.Fatal("actual special name borrowed bare symbol formatting")
+			}
+		})
+	}
+	if !reflect.DeepEqual(expected, arm64OracleLexicalNames.reserved) {
+		t.Fatalf("complete original special namespace differs: %v / %v", expected, arm64OracleLexicalNames.reserved)
+	}
+}
+
+func TestGoAssemblerOracleARM64SelectedBareSpellingsActual(t *testing.T) {
+	for _, name := range []string{"R18", "R28", "R31", "BEGIN", "END", "F", "Z0", "P0", "PN0"} {
+		t.Run(name, func(t *testing.T) {
+			directory := t.TempDir()
+			source := filepath.Join(directory, "forms.s")
+			object := filepath.Join(directory, "forms.o")
+			if err := os.WriteFile(source, []byte("TEXT bad(SB),$0-0\n\tBL "+name+",R1\n\tRET\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, 5*time.Second)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, directory,
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil || len(observed.Stdout) != 0 {
+				t.Fatalf("actual source kind oracle failed: %+v %v", observed, err)
+			}
+			bare := strings.Contains(string(observed.Stderr), source+":2)\tCALL\t0, R1 ZOREG NONE NONE REG") &&
+				strings.Contains(string(observed.Stderr), ", 3 7\n")
+			if bare != goAssemblerOracleARM64BareSymbol(name) {
+				t.Fatalf("selected original operand role differs for %s:\n%s", name, observed.Stderr)
+			}
+			if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+				err, ctx.Err(), false, 2, func(source, diagnostic string) bool {
+					return goAssemblerOracleARM64SourceDiagnostic(source, "arm64", diagnostic)
+				}); failure != nil {
+				t.Fatalf("actual namespace diagnostic join lost: %v\n%s", failure, observed.Stderr)
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_arm64_namespace_test.go b/go_assembler_oracle_arm64_namespace_test.go
new file mode 100644
index 000000000..094b5afdb
--- /dev/null
+++ b/go_assembler_oracle_arm64_namespace_test.go
@@ -0,0 +1,339 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// This is the selected cmd/asm lexical namespace, not this library's register
+// grammar. In particular R18/R28/R31 and old SDK Z/P/PN names can be symbols.
+var arm64OracleLexicalNames struct {
+	once      sync.Once
+	registers map[string]bool
+	reserved  map[string]bool
+}
+
+func arm64OracleIdentifier(name string) bool {
+	if name == "" {
+		return false
+	}
+	for index, ch := range name {
+		if !unicode.IsLetter(ch) && ch != '_' && ch != '·' && ch != '∕' &&
+			!(index > 0 && unicode.IsDigit(ch)) {
+			return false
+		}
+	}
+	return true
+}
+
+func goAssemblerOracleARM64BareSymbol(name string) bool {
+	arm64OracleLoadLexicalNames()
+	return arm64OracleIdentifier(name) && arm64OracleLexicalNames.reserved != nil &&
+		!arm64OracleLexicalNames.reserved[name]
+}
+
+func goAssemblerOracleARM64Register(name string) bool {
+	arm64OracleLoadLexicalNames()
+	return name != "SB" && name != "FP" && name != "PC" && name != "SP" &&
+		arm64OracleLexicalNames.registers[name]
+}
+
+func arm64OracleLoadLexicalNames() {
+	arm64OracleLexicalNames.once.Do(func() {
+		files := make(map[string]*ast.File)
+		for key, relative := range map[string]string{
+			"arch":    "cmd/asm/internal/arch/arch.go",
+			"aliases": "cmd/asm/internal/arch/arm64.go",
+			"system":  "cmd/internal/obj/arm64/sysRegEnc.go",
+			"special": "cmd/internal/obj/arm64/a.out.go",
+		} {
+			path := filepath.Join(runtime.GOROOT(), "src", relative)
+			data, valid := goasmoracle.ReadSource(path)
+			if !valid {
+				return
+			}
+			file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+			if err != nil {
+				return
+			}
+			files[key] = file
+		}
+		registers, reserved, valid := arm64OracleLexicalNamespace(files)
+		if valid {
+			arm64OracleLexicalNames.registers = registers
+			arm64OracleLexicalNames.reserved = reserved
+		}
+	})
+}
+
+func arm64OracleASTText(node ast.Node) string {
+	var output bytes.Buffer
+	if format.Node(&output, token.NewFileSet(), node) != nil {
+		return ""
+	}
+	return strings.Join(strings.Fields(output.String()), " ")
+}
+
+func arm64OracleLiteralNames(file *ast.File, name string, firstColumn bool) ([]string, bool) {
+	var result []string
+	declarations := 0
+	valid := true
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || value.Names[0].Name != name {
+			return true
+		}
+		declarations++
+		if len(value.Values) != 1 {
+			valid = false
+			return false
+		}
+		array, ok := value.Values[0].(*ast.CompositeLit)
+		if !ok || len(array.Elts) == 0 {
+			valid = false
+			return false
+		}
+		if firstColumn && arm64OracleASTText(array.Type) != "[]struct { Name string Reg int16 Enc uint32 AccessFlags uint8 }" {
+			valid = false
+			return false
+		}
+		for _, element := range array.Elts {
+			if firstColumn {
+				row, ok := element.(*ast.CompositeLit)
+				if !ok || len(row.Elts) != 4 {
+					valid = false
+					return false
+				}
+				element = row.Elts[0]
+			}
+			literal, ok := element.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				valid = false
+				return false
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil || !arm64OracleIdentifier(name) {
+				valid = false
+				return false
+			}
+			result = append(result, name)
+		}
+		return false
+	})
+	return result, valid && declarations == 1
+}
+
+func arm64OracleLexicalNamespace(files map[string]*ast.File) (map[string]bool, map[string]bool, bool) {
+	for _, key := range []string{"arch", "aliases", "system", "special"} {
+		if files[key] == nil {
+			return nil, nil, false
+		}
+	}
+	registers := make(map[string]bool)
+	var factory *ast.FuncDecl
+	for _, declaration := range files["arch"].Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == "archArm64" {
+			if factory != nil || function.Body == nil {
+				return nil, nil, false
+			}
+			factory = function
+		}
+	}
+	if factory == nil {
+		return nil, nil, false
+	}
+	banks := make(map[string]bool)
+	processedWrites, actualWrites := 0, 0
+	ast.Inspect(factory.Body, func(node ast.Node) bool {
+		if assignment, ok := node.(*ast.AssignStmt); ok {
+			for _, left := range assignment.Lhs {
+				if index, ok := left.(*ast.IndexExpr); ok && arm64OracleASTText(index.X) == "register" {
+					actualWrites++
+				}
+			}
+		}
+		return true
+	})
+	prefixes, system, finished := false, false, false
+	for _, statement := range factory.Body.List {
+		text := arm64OracleASTText(statement)
+		if text == "instructions := make(map[string]obj.As)" {
+			finished = true
+			break
+		}
+		switch text {
+		case "register := make(map[string]int16)":
+		case "register[obj.Rconv(arm64.REGSP)] = int16(arm64.REGSP)":
+			registers["RSP"] = true
+			processedWrites++
+		case `register["R18_PLATFORM"] = register["R18"]`:
+			registers["R18_PLATFORM"] = true
+			processedWrites++
+		case `delete(register, "R18")`:
+			delete(registers, "R18")
+		case `delete(register, "R28")`:
+			delete(registers, "R28")
+		case `register["LR"] = arm64.REGLINK`, `register["SB"] = RSB`,
+			`register["FP"] = RFP`, `register["PC"] = RPC`, `register["SP"] = RSP`,
+			`register["g"] = arm64.REG_R28`:
+			index := statement.(*ast.AssignStmt).Lhs[0].(*ast.IndexExpr)
+			name, _ := strconv.Unquote(index.Index.(*ast.BasicLit).Value)
+			registers[name] = true
+			processedWrites++
+		case "for i := 0; i < len(arm64.SystemReg); i++ { register[arm64.SystemReg[i].Name] = arm64.SystemReg[i].Reg }":
+			if system {
+				return nil, nil, false
+			}
+			names, valid := arm64OracleLiteralNames(files["system"], "SystemReg", true)
+			if !valid {
+				return nil, nil, false
+			}
+			for _, name := range names {
+				if registers[name] {
+					return nil, nil, false
+				}
+				registers[name] = true
+			}
+			system = true
+			processedWrites++
+		default:
+			bank := ""
+			for prefix, maximum := range map[string]int{"R": 31, "F": 31, "V": 31, "Z": 31, "P": 15, "PN": 15} {
+				if text == fmt.Sprintf("for i := arm64.REG_%s0; i <= arm64.REG_%s%d; i++ { register[obj.Rconv(i)] = int16(i) }", prefix, prefix, maximum) {
+					bank = prefix
+					if banks[bank] {
+						return nil, nil, false
+					}
+					banks[bank] = true
+					for number := 0; number <= maximum; number++ {
+						name := fmt.Sprintf("%s%d", bank, number)
+						if bank == "R" && number == 31 {
+							name = "ZR"
+						}
+						registers[name] = true
+					}
+					processedWrites++
+				}
+			}
+			if bank != "" {
+				continue
+			}
+			assignment, ok := statement.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 ||
+				arm64OracleASTText(assignment.Lhs[0]) != "registerPrefix" || prefixes {
+				return nil, nil, false
+			}
+			literal, ok := assignment.Rhs[0].(*ast.CompositeLit)
+			if !ok || len(literal.Elts) != len(banks) {
+				return nil, nil, false
+			}
+			seen := make(map[string]bool)
+			for _, element := range literal.Elts {
+				pair, ok := element.(*ast.KeyValueExpr)
+				if !ok {
+					return nil, nil, false
+				}
+				name, err := strconv.Unquote(arm64OracleASTText(pair.Key))
+				if err != nil || !banks[name] || seen[name] || arm64OracleASTText(pair.Value) != "true" {
+					return nil, nil, false
+				}
+				seen[name] = true
+			}
+			prefixes = true
+		}
+	}
+	if !finished || !prefixes || !system || processedWrites != actualWrites ||
+		!banks["R"] || !banks["F"] || !banks["V"] || registers["R18"] || registers["R28"] {
+		return nil, nil, false
+	}
+	reserved := make(map[string]bool, len(registers))
+	for name := range registers {
+		reserved[name] = true
+	}
+	groups := 0
+	specials := make(map[string]bool)
+	for _, declaration := range files["special"].Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST {
+			continue
+		}
+		var names []string
+		for _, spec := range group.Specs {
+			value := spec.(*ast.ValueSpec)
+			for _, name := range value.Names {
+				if strings.HasPrefix(name.Name, "SPOP_") {
+					names = append(names, name.Name)
+				}
+			}
+		}
+		if len(names) == 0 {
+			continue
+		}
+		groups++
+		if len(names) != len(group.Specs) || len(names) < 3 ||
+			names[0] != "SPOP_PLDL1KEEP" || names[1] != "SPOP_BEGIN" || names[len(names)-1] != "SPOP_END" {
+			return nil, nil, false
+		}
+		for _, name := range names {
+			if name != "SPOP_BEGIN" && name != "SPOP_END" {
+				word := strings.TrimPrefix(name, "SPOP_")
+				if reserved[word] || !arm64OracleIdentifier(word) {
+					return nil, nil, false
+				}
+				reserved[word] = true
+				specials[word] = true
+			}
+		}
+	}
+	aliases := 0
+	valid := true
+	ast.Inspect(files["aliases"], func(node ast.Node) bool {
+		assignment, ok := node.(*ast.AssignStmt)
+		if !ok || len(assignment.Lhs) != 1 || arm64OracleASTText(assignment.Lhs[0]) != "specialMapping" {
+			return true
+		}
+		aliases++
+		if len(assignment.Rhs) != 1 {
+			valid = false
+			return false
+		}
+		literal, ok := assignment.Rhs[0].(*ast.CompositeLit)
+		if !ok || len(literal.Elts) == 0 {
+			valid = false
+			return false
+		}
+		for _, element := range literal.Elts {
+			pair, ok := element.(*ast.KeyValueExpr)
+			if !ok {
+				valid = false
+				return false
+			}
+			name, err := strconv.Unquote(arm64OracleASTText(pair.Key))
+			selector, selected := pair.Value.(*ast.SelectorExpr)
+			if !selected || arm64OracleASTText(selector.X) != "arm64" || !strings.HasPrefix(selector.Sel.Name, "SPOP_") {
+				valid = false
+				return false
+			}
+			target := strings.TrimPrefix(selector.Sel.Name, "SPOP_")
+			if err != nil || !arm64OracleIdentifier(name) || reserved[name] || !specials[target] {
+				valid = false
+				return false
+			}
+			reserved[name] = true
+		}
+		return false
+	})
+	return registers, reserved, valid && groups == 1 && aliases == 1
+}
diff --git a/go_assembler_oracle_arm64_schema_test.go b/go_assembler_oracle_arm64_schema_test.go
new file mode 100644
index 000000000..0d1c0f505
--- /dev/null
+++ b/go_assembler_oracle_arm64_schema_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func arm64OracleOriginalSDKFile(t *testing.T, name string) *ast.File {
+	t.Helper()
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/arm64", name)
+	data, valid := goasmoracle.ReadSource(path)
+	if !valid {
+		t.Fatalf("original bounded SDK source unavailable: %s", name)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file
+}
+
+// This independently reads the selected SDK's complete namespace and Diag
+// argument schema. These are diagnostic roles, not accepted instruction forms.
+func TestGoAssemblerOracleARM64ActualSelectedDiagnosticSchema(t *testing.T) {
+	var names []string
+	ast.Inspect(arm64OracleOriginalSDKFile(t, "anames7.go"), func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || declaration.Names[0].Name != "cnames7" {
+			return true
+		}
+		if len(declaration.Values) != 1 {
+			t.Fatal("complete original class directory shape changed")
+		}
+		array, ok := declaration.Values[0].(*ast.CompositeLit)
+		if !ok {
+			t.Fatal("complete original class directory is not a literal")
+		}
+		seen := make(map[string]bool)
+		for _, value := range array.Elts {
+			literal, ok := value.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("original class name is not a literal")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil || name != "" && seen[name] {
+				t.Fatal("original class name is invalid or duplicated")
+			}
+			if name != "" {
+				seen[name] = true
+				names = append(names, name)
+			}
+		}
+		return false
+	})
+	if len(names) == 0 || names[0] != "NONE" || names[len(names)-1] != "NCLASS" {
+		t.Fatal("complete original class bounds absent")
+	}
+
+	var slots, formats int
+	ast.Inspect(arm64OracleOriginalSDKFile(t, "asm7.go"), func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) == 0 {
+			return true
+		}
+		method, ok := call.Fun.(*ast.SelectorExpr)
+		if !ok || method.Sel.Name != "Diag" {
+			return true
+		}
+		literal, ok := call.Args[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		format, err := strconv.Unquote(literal.Value)
+		if err != nil || !strings.HasPrefix(format, "illegal combination: %v %v ") {
+			return true
+		}
+		current := len(call.Args) - 4 // format, Prog, From.Type and To.Type.
+		if current != 4 && current != 5 || format != "illegal combination: %v"+strings.Repeat(" %v", current)+", %d %d" {
+			t.Fatal("unmodeled original DRconv schema")
+		}
+		for position := 0; position < current; position++ {
+			convert, ok := call.Args[position+2].(*ast.CallExpr)
+			if !ok || len(convert.Args) != 1 {
+				t.Fatal("original class conversion shape changed")
+			}
+			function, ok := convert.Fun.(*ast.Ident)
+			argument, argOK := convert.Args[0].(*ast.Ident)
+			if !ok || !argOK || function.Name != "DRconv" || argument.Name != fmt.Sprintf("a%d", position+1) {
+				t.Fatal("original diagnostic class order changed")
+			}
+		}
+		for position, field := range []string{"From", "To"} {
+			kind, ok := call.Args[current+2+position].(*ast.SelectorExpr)
+			if !ok || kind.Sel.Name != "Type" {
+				t.Fatal("original address-type field changed")
+			}
+			address, ok := kind.X.(*ast.SelectorExpr)
+			if !ok || address.Sel.Name != field {
+				t.Fatal("original address-type order changed")
+			}
+			prog, ok := address.X.(*ast.Ident)
+			if !ok || prog.Name != "p" {
+				t.Fatal("original address-type owner changed")
+			}
+		}
+		slots, formats = current, formats+1
+		return false
+	})
+	if formats != 1 {
+		t.Fatal("complete original diagnostic schema is not unique")
+	}
+	t.Logf("ORIGINAL_ARM64_DIAGNOSTIC_SCHEMA classes=%d slots=%d", len(names), slots)
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, "BL R0")
+			for position := 0; position < slots; position++ {
+				classes := make([]string, slots)
+				for i := range classes {
+					classes[i] = "NONE"
+				}
+				classes[position] = name
+				if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+					"CALL R0", strings.Join(classes, " ")+", 0 7")) {
+					t.Errorf("complete original class/slot lost: %s/%d", name, position)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleARM64HistoricalDiagnosticMetadata(t *testing.T) {
+	for _, alias := range []struct{ source, listing string }{{"B", "JMP"}, {"BL", "CALL"}} {
+		t.Run(alias.source, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, alias.source+" R0")
+			for _, class := range []string{"NONE", "REG", "UAUTO32K_8", "LAUTO", "LOREG"} {
+				for position := 0; position < 4; position++ {
+					classes := []string{"NONE", "NONE", "NONE", "REG"}
+					classes[position] = class
+					if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+						alias.listing+" R0", strings.Join(classes, " ")+", 0 7")) {
+						t.Errorf("original four-class metadata lost: %s/%d", class, position)
+					}
+				}
+			}
+			for _, tail := range []string{
+				"NONE NONE REG, 0 7", "NONE NONE NONE REG NONE NONE, 0 7",
+				"NONE NONE UNKNOWN REG, 0 7", "NONE NONE LAUTOPOOL REG, 0 7",
+				"NONE NONE LOREGPOOL REG, 0 7", "NONE NONE UAUTO32K_16 REG, 0 7",
+				"NONE NONE REG REG, -1 7", "NONE NONE REG REG, 0 15",
+				"NONE NONE REG REG, 00 7", "NONE NONE REG REG, 0 7 extra",
+			} {
+				if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+					alias.listing+" R0", tail)) {
+					t.Errorf("unmodeled historical metadata accepted: %q", tail)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleARM64TransitionalDiagnosticMetadata(t *testing.T) {
+	source := x86DiagnosticFixture(t, "BL R0")
+	for _, test := range []struct {
+		tail string
+		want bool
+	}{
+		{"NONE NONE NONE UAUTO32K_8 REG, 0 7", true},
+		{"LAUTOPOOL LOREGPOOL NONE UAUTO32K_8 REG, 0 7", true},
+		{"LAUTOPOOL LOREGPOOL NONE UAUTO32K_16 REG, 0 7", true},
+		{"UAUTO32K_8 UAUTO32K_16 NONE NONE REG, 0 7", false},
+		{"LAUTOPOOL NONE UAUTO32K_8 REG, 0 7", false},
+		{"NONE NONE NONE UAUTO32K_8 REG NONE, 0 7", false},
+	} {
+		got := goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source, "CALL R0", test.tail))
+		if got != test.want {
+			t.Errorf("complete producer schema %q: got %t, want %t", test.tail, got, test.want)
+		}
+	}
+}
diff --git a/go_assembler_oracle_arm64_symbol_go127_test.go b/go_assembler_oracle_arm64_symbol_go127_test.go
new file mode 100644
index 000000000..0405f91bd
--- /dev/null
+++ b/go_assembler_oracle_arm64_symbol_go127_test.go
@@ -0,0 +1,19 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+// These banks are registered by the actual current SDK, but are bare symbol
+// names in Go 1.20. The historical test inventory must not invent their role.
+func TestGoAssemblerOracleARM64CurrentSVEFromRegisterRoles(t *testing.T) {
+	for _, name := range []string{"Z0", "P0", "PN0"} {
+		t.Run(name, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, "BL "+name+",R1")
+			if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+				"CALL 0,R1", "ZOREG NONE NONE REG NONE, 3 7")) {
+				t.Fatal("registered current-SDK bank borrowed a bare-symbol role")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_arm64_symbol_test.go b/go_assembler_oracle_arm64_symbol_test.go
new file mode 100644
index 000000000..2fca67dc4
--- /dev/null
+++ b/go_assembler_oracle_arm64_symbol_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleARM64ActualBareFromSymbolFamily(t *testing.T) {
+	for _, opcode := range []string{"B", "BL"} {
+		for _, name := range []string{"target", "_target2", "世界", "pkg·target", "path∕target"} {
+			for _, definition := range []string{"defined", "undefined"} {
+				t.Run(opcode+"/"+name+"/"+definition, func(t *testing.T) {
+					directory := t.TempDir()
+					source := filepath.Join(directory, "forms.s")
+					object := filepath.Join(directory, "forms.o")
+					body := "TEXT bad(SB),$0-0\n\t" + opcode + " " + name + ",R1\n"
+					if definition == "defined" {
+						body += name + ":\n"
+					}
+					body += "\tRET\n"
+					if err := os.WriteFile(source, []byte(body), 0600); err != nil {
+						t.Fatal(err)
+					}
+
+					stage, cancelStage := runtimeOracleStageContext(t)
+					defer cancelStage()
+					ctx, cancel := context.WithTimeout(stage, 5*time.Second)
+					defer cancel()
+					observed, err := goasmcmd.Observe(ctx, directory,
+						append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+						"go", "tool", "asm", "-o", object, source)
+					encoded, encodeErr := json.Marshal(observed)
+					if encodeErr != nil {
+						t.Fatal(encodeErr)
+					}
+					t.Logf("ORACLE_CHILD %s", encoded)
+					listing := "JMP"
+					if opcode == "BL" {
+						listing = "CALL"
+					}
+					if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil || len(observed.Stdout) != 0 ||
+						!strings.Contains(string(observed.Stderr), source+":2)\t"+listing+"\t0, R1 ZOREG NONE NONE REG") ||
+						!strings.Contains(string(observed.Stderr), ", 3 7\n") {
+						t.Fatalf("actual From TYPE_MEM/NameNone/zero-offset refusal absent: %+v %v", observed, err)
+					}
+					failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+						err, ctx.Err(), false, 2, func(source, diagnostic string) bool {
+							return goAssemblerOracleARM64SourceDiagnostic(source, "arm64", diagnostic)
+						})
+					if failure != nil {
+						t.Fatalf("actual From symbol diagnostic join lost: %v\n%s", failure, observed.Stderr)
+					}
+					if goasmoracle.SourceDiagnosticLine(source, string(observed.Stderr), 2) {
+						t.Fatal("default diagnostic acquired an operand rewrite")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoAssemblerOracleARM64BareFromSymbolRoles(t *testing.T) {
+	for _, alias := range []struct{ original, listed string }{{"B", "JMP"}, {"BL", "CALL"}} {
+		for _, suffix := range []struct{ original, listed string }{
+			{"", ""}, {".P", ".P"}, {".W", ".W"}, {".W.P", ".P.W"}, {".P.P", ".P"},
+		} {
+			t.Run(alias.original+suffix.original, func(t *testing.T) {
+				source := x86DiagnosticFixture(t, alias.original+suffix.original+" target,R1")
+				output := arm64BranchDiagnostic(source, alias.listed+suffix.listed+" 0,R1",
+					"ZOREG NONE NONE REG NONE, 3 7")
+				if !goAssemblerOracleARM64SourceDiagnostic(source, "arm64", output) {
+					t.Error("complete zero-offset From symbol role was lost")
+				}
+				for _, changed := range []string{
+					strings.Replace(output, "0,R1", "1,R1", 1),
+					strings.Replace(output, "0,R1", "0,R2", 1),
+					strings.Replace(output, "0,R1", "$0,R1", 1),
+					strings.Replace(output, "ZOREG", "SBRA", 1),
+					strings.Replace(output, ", 3 7", ", 1 7", 1),
+					strings.Replace(output, ", 3 7", ", 8 7", 1),
+					strings.Replace(output, ", 3 7", ", 3 3", 1),
+					strings.Replace(output, source+":2", source+":3", 1),
+					strings.Replace(output, source+":2", "foreign"+source+":2", 1),
+					strings.Replace(output, "00000", "0", 1),
+				} {
+					if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", changed) {
+						t.Errorf("From symbol borrowed a different role: %q", changed)
+					}
+				}
+			})
+		}
+	}
+	for _, instruction := range []string{
+		"BL R0,R1", "BL V0,R1", "BL NZCV,R1", "BL EQ,R1",
+		"BL PLDL1KEEP,R1", "BL $target,R1", "BL *target,R1", "BL target+1,R1",
+		"BL target(SB),R1", "BL target(FP),R1", "BL (R0),R1", "BL R(0),R1",
+		"BL $0,R0,target", "BL target", "BL", "MOVD target,R1",
+	} {
+		t.Run("wrong-role/"+instruction, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, instruction)
+			if goAssemblerOracleARM64SourceDiagnostic(source, "arm64", arm64BranchDiagnostic(source,
+				"CALL 0,R1", "ZOREG NONE NONE REG NONE, 3 7")) {
+				t.Fatal("non-bare-From source borrowed symbol erasure")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_arm64_text_listing_test.go b/go_assembler_oracle_arm64_text_listing_test.go
new file mode 100644
index 000000000..1d5cb54ef
--- /dev/null
+++ b/go_assembler_oracle_arm64_text_listing_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// PKGINIT is a source flag only in newer SDKs. Determine its actual projection
+// from that SDK's InitTextSym, not from the translator build version.
+func goAssemblerOracleTextPKGInit() (present, valid bool) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/plist.go")
+	data, valid := goasmoracle.ReadSource(path)
+	if !valid {
+		return false, false
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		return false, false
+	}
+	functions, projections := 0, 0
+	valid = true
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "InitTextSym" {
+			continue
+		}
+		functions++
+		ast.Inspect(function, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok || len(call.Args) != 2 {
+				return true
+			}
+			method, ok := call.Fun.(*ast.SelectorExpr)
+			attribute, attrOK := call.Args[0].(*ast.Ident)
+			if !ok || !attrOK || method.Sel.Name != "Set" || attribute.Name != "AttrPkgInit" {
+				return true
+			}
+			projections++
+			condition, ok := call.Args[1].(*ast.BinaryExpr)
+			if !ok || condition.Op != token.NEQ {
+				valid = false
+				return true
+			}
+			mask, ok := condition.X.(*ast.BinaryExpr)
+			zero, zeroOK := condition.Y.(*ast.BasicLit)
+			if !ok || !zeroOK || mask.Op != token.AND || zero.Kind != token.INT || zero.Value != "0" {
+				valid = false
+				return true
+			}
+			flag, flagOK := mask.X.(*ast.Ident)
+			name, nameOK := mask.Y.(*ast.Ident)
+			present = flagOK && nameOK && flag.Name == "flag" && name.Name == "PKGINIT"
+			valid = valid && present
+			return true
+		})
+	}
+	return present, valid && functions == 1 && projections <= 1
+}
+
+func goAssemblerOracleARM64TextListing(original, listing []string, detail string) bool {
+	opcode, suffix, args, valid := goAssemblerOracleX86Statement(original)
+	listedOpcode, listedSuffix, listedArgs, listedValid := goAssemblerOracleX86Statement(listing)
+	if !valid || !listedValid || opcode != "TEXT" || listedOpcode != "TEXT" ||
+		suffix != "" || listedSuffix != "" || len(args) < 2 || len(args) > 3 ||
+		len(listedArgs) < 2 || len(listedArgs) > 3 || !reflect.DeepEqual(args[0], listedArgs[0]) {
+		return false
+	}
+	flags := int64(0)
+	if len(args) == 3 {
+		if len(args[1]) != 1 {
+			return false
+		}
+		var err error
+		flags, err = strconv.ParseInt(args[1][0], 0, 32)
+		if err != nil || flags < 0 || flags >= 1<<14 {
+			return false
+		}
+	}
+	frameTokens := args[len(args)-1]
+	if len(frameTokens) < 2 || frameTokens[0] != "$" {
+		return false
+	}
+	position, sign := 1, int64(1)
+	if frameTokens[position] == "-" {
+		position, sign = position+1, -1
+	}
+	if position >= len(frameTokens) {
+		return false
+	}
+	frame, err := strconv.ParseInt(frameTokens[position], 0, 32)
+	if err != nil || frame < 0 {
+		return false
+	}
+	frame *= sign
+	position++
+	wantSize := "$" + strconv.FormatInt(frame, 10)
+	if position < len(frameTokens) {
+		if len(frameTokens)-position != 2 || frameTokens[position] != "-" {
+			return false
+		}
+		argc, err := strconv.ParseInt(frameTokens[position+1], 0, 32)
+		if err != nil || argc < 0 {
+			return false
+		}
+		wantSize += "-" + strconv.FormatInt(argc, 10)
+	}
+	if strings.Join(listedArgs[len(listedArgs)-1], "") != wantSize || frame == -8 {
+		return false
+	}
+	autosize := frame
+	if flags&512 == 0 {
+		if frame > 1<<31-1-8 {
+			return false
+		}
+		autosize += 8
+	}
+	if autosize == 0 || autosize%16 == 8 || autosize&15 == 0 {
+		return false
+	}
+	wantError := "unaligned frame size " + strconv.FormatInt(autosize-8, 10) + " - must be 16 aligned"
+	if detail != wantError {
+		return false
+	}
+	var attributes []string
+	for _, attribute := range []struct {
+		bit  int64
+		name string
+	}{
+		{2, "DUPOK"}, {4, "NOSPLIT"}, {1024, "REFLECTMETHOD"}, {32, "WRAPPER"},
+		{64, "NEEDCTXT"}, {512, "NOFRAME"}, {4096, "ABIWRAPPER"},
+	} {
+		if flags&attribute.bit != 0 {
+			attributes = append(attributes, attribute.name)
+		}
+	}
+	if flags&8192 != 0 {
+		present, valid := goAssemblerOracleTextPKGInit()
+		if !valid {
+			return false
+		}
+		if present {
+			attributes = append(attributes, "PKGINIT")
+		}
+	}
+	if flags&2048 != 0 {
+		attributes = append(attributes, "TOPFRAME")
+	}
+	if len(attributes) == 0 {
+		return len(listedArgs) == 2
+	}
+	return len(listedArgs) == 3 && strings.Join(listedArgs[1], "") == strings.Join(attributes, "|")
+}
diff --git a/go_assembler_oracle_arm64_text_test.go b/go_assembler_oracle_arm64_text_test.go
new file mode 100644
index 000000000..abbd8d674
--- /dev/null
+++ b/go_assembler_oracle_arm64_text_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func arm64TextFrameDiagnostic(source, listing string, frame int) string {
+	return fmt.Sprintf("asm: 00001 (%s:1)\t%s: unaligned frame size %d - must be 16 aligned\nasm: assembly failed\n",
+		source, listing, frame)
+}
+
+func TestGoAssemblerOracleARM64TextFrameTrailingDiagnostic(t *testing.T) {
+	// These are the complete common TEXT flag bits, including bits which
+	// InitTextSym deliberately does not project into a printed attribute.
+	for _, test := range []struct {
+		flag int
+		attr string
+	}{
+		{0, ""}, {1, ""}, {2, "DUPOK"}, {4, "NOSPLIT"}, {8, ""}, {16, ""},
+		{32, "WRAPPER"}, {64, "NEEDCTXT"}, {128, ""}, {256, ""},
+		{512, "NOFRAME"}, {1024, "REFLECTMETHOD"}, {2048, "TOPFRAME"}, {4096, "ABIWRAPPER"},
+		{2 | 4 | 32 | 64 | 1024 | 2048 | 4096, "DUPOK|NOSPLIT|REFLECTMETHOD|WRAPPER|NEEDCTXT|ABIWRAPPER|TOPFRAME"},
+	} {
+		t.Run(fmt.Sprint(test.flag), func(t *testing.T) {
+			directory := t.TempDir()
+			source := filepath.Join(directory, "forms.s")
+			body := fmt.Sprintf("TEXT badWidth(SB),%d,$3-0\nRET\n", test.flag)
+			if err := os.WriteFile(source, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			listing := "TEXT badWidth(SB), "
+			if test.attr != "" {
+				listing += test.attr + ", "
+			}
+			listing += "$3-0"
+			frame := 3
+			if test.flag&512 != 0 {
+				frame -= 8 // Go's NOFRAME autosize omits the saved LR.
+			}
+			output := arm64TextFrameDiagnostic(source, listing, frame)
+			if !goAssemblerOraclePositionlessDiagnostic(source, "arm64", output) {
+				t.Error("complete TEXT/flag/frame trailing diagnostic lost")
+			}
+			if goasmoracle.SourceDiagnosticLine(source, output, 1) {
+				t.Fatal("strict default acquired a bare backend listing")
+			}
+			for _, changed := range []string{
+				strings.Replace(output, source+":1", source+":2", 1),
+				strings.Replace(output, source+":1", "foreign"+source+":1", 1),
+				strings.Replace(output, "00001", "1", 1),
+				strings.Replace(output, "badWidth(SB)", "other(SB)", 1),
+				strings.Replace(output, "$3-0", "$4-0", 1),
+				strings.Replace(output, "$3-0", "$3-8", 1),
+				strings.Replace(output, ": unaligned", ": unknown unaligned", 1),
+				strings.Replace(output, "16 aligned", "8 aligned", 1),
+				strings.Replace(output, fmt.Sprintf("frame size %d", frame), "frame size 33", 1),
+				strings.Replace(output, " aligned\n", " aligned extra\n", 1),
+				"asm: 00001 (" + source + ":1) TEXT badWidth(SB), $3-0\n",
+				"asm: unaligned frame size 3 - must be 16 aligned\n",
+			} {
+				if goAssemblerOraclePositionlessDiagnostic(source, "arm64", changed) {
+					t.Errorf("changed complete diagnostic borrowed TEXT: %q", changed)
+				}
+			}
+			if goAssemblerOraclePositionlessDiagnostic(source, "amd64", output) ||
+				goAssemblerOraclePositionlessDiagnostic(source, "386", output) {
+				t.Fatal("ARM64 trailing diagnostic leaked into x86")
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleARM64ActualTextFrameFlagFamily(t *testing.T) {
+	for _, flag := range []int{0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 7270} {
+		t.Run(fmt.Sprint(flag), func(t *testing.T) {
+			directory := t.TempDir()
+			source, object := filepath.Join(directory, "forms.s"), filepath.Join(directory, "forms.o")
+			body := fmt.Sprintf("TEXT badWidth(SB),%d,$3-0\nRET\n", flag)
+			if err := os.WriteFile(source, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, time.Minute)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, directory,
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil || len(observed.Stdout) != 0 {
+				t.Fatalf("actual frame refusal missing: %+v %v", observed, err)
+			}
+			var diagnostic []byte
+			for _, line := range strings.Split(string(observed.Stderr), "\n") {
+				if strings.Contains(line, ": unaligned frame size ") {
+					if diagnostic != nil {
+						t.Fatal("ambiguous actual trailing diagnostic")
+					}
+					diagnostic = []byte(line + "\n")
+				}
+			}
+			if diagnostic == nil {
+				t.Fatalf("actual unaligned-frame line absent:\n%s", observed.Stderr)
+			}
+			// Probe this exact real diagnostic line, not a separate NOFRAME
+			// message which may coexist with it. Full original streams remain
+			// above; this is diagnostic-join evidence, never object success.
+			failure := goasmoracle.CheckOutcome(source, object, nil, diagnostic, err, ctx.Err(), false, 1,
+				func(source, output string) bool {
+					return goAssemblerOraclePositionlessDiagnostic(source, "arm64", output)
+				})
+			if failure != nil {
+				t.Fatalf("actual trailing TEXT diagnostic unbound: %v\n%s", failure, observed.Stderr)
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_backend_test.go b/go_assembler_oracle_backend_test.go
new file mode 100644
index 000000000..f8a121721
--- /dev/null
+++ b/go_assembler_oracle_backend_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"math"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func goAssemblerOracleFixture(source string) ([]byte, bool) {
+	return goasmoracle.ReadSource(source)
+}
+
+func goAssemblerOracleListingBindsSource(source, position, pc, instruction string) bool {
+	return goasmoracle.ListingBindsSource(source, position, pc, instruction)
+}
+
+// Go's backends also have a few positionless source diagnostics. Do not
+// accept the prefix alone: bind its exact values to an independently invalid
+// operand/frame in this regular, bounded fixture. Unknown errors stay fatal.
+func goAssemblerOraclePositionlessDiagnostic(source, arch, output string) bool {
+	if arch == "arm64" && goasmoracle.SourceDiagnosticLineWithTrailingListing(source, output, 0,
+		goAssemblerOracleARM64TextListing) {
+		return true
+	}
+	data, ok := goAssemblerOracleFixture(source)
+	if !ok {
+		return false
+	}
+	parseArch := ArchAMD64
+	if arch == "arm64" {
+		parseArch = ArchARM64
+	} else if arch != "amd64" && arch != "386" {
+		return false
+	}
+	file, err := Parse(parseArch, string(data))
+	if err != nil {
+		return false
+	}
+	for _, line := range strings.Split(output, "\n") {
+		const framePrefix = "asm: NOFRAME functions must have a frame size of 0, not "
+		if arch == "arm64" && strings.HasPrefix(line, framePrefix) {
+			number := strings.TrimPrefix(line, framePrefix)
+			frame, err := strconv.ParseInt(number, 10, 32)
+			if err != nil || strconv.FormatInt(frame, 10) != number || frame == 0 || frame == -8 {
+				continue
+			}
+			for _, fn := range file.Funcs {
+				if fn.FrameSize == frame && arm64SourceFrameFlagsKnown(fn) && !arm64SourceGoFrame(fn).present {
+					return true
+				}
+			}
+		}
+
+		const addressPrefix = "asm: asmidx: bad address "
+		if arch == "386" && strings.HasPrefix(line, addressPrefix) {
+			parts := strings.Split(strings.TrimPrefix(line, addressPrefix), "/")
+			if len(parts) != 3 {
+				continue
+			}
+			scale, err := strconv.Atoi(parts[0])
+			base := Reg(parts[2])
+			if err != nil || strconv.Itoa(scale) != parts[0] ||
+				!isX86YrlRegisterForArch(base, "amd64") || isX86YrlRegisterForArch(base, "386") {
+				continue
+			}
+			for _, fn := range file.Funcs {
+				for _, ins := range fn.Instrs {
+					for _, arg := range ins.Args {
+						if arg.Kind == OpMem && arg.Mem.Base == base && string(arg.Mem.Index) == parts[1] && arg.Mem.Scale == int64(scale) {
+							return true
+						}
+					}
+				}
+			}
+		}
+
+		const floatPrefix = "asm: unexpected addr1: type=5 $("
+		if (arch == "amd64" || arch == "386") && strings.HasPrefix(line, floatPrefix) && strings.HasSuffix(line, ")") {
+			value, err := strconv.ParseFloat(strings.TrimSuffix(strings.TrimPrefix(line, floatPrefix), ")"), 64)
+			if err != nil {
+				continue
+			}
+			for _, fn := range file.Funcs {
+				for _, ins := range fn.Instrs {
+					switch ins.Op {
+					case "IRETW", "IRETL", "IRETQ", "RETFW", "RETFL", "RETFQ":
+						if len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmIsFloat &&
+							uint64(ins.Args[0].Imm) == math.Float64bits(value) {
+							return true
+						}
+					}
+				}
+			}
+		}
+	}
+	return false
+}
diff --git a/go_assembler_oracle_binding_guards_test.go b/go_assembler_oracle_binding_guards_test.go
new file mode 100644
index 000000000..f09d086b9
--- /dev/null
+++ b/go_assembler_oracle_binding_guards_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGoAssemblerOracleSourcePositionAndStatementGuards(t *testing.T) {
+	source := filepath.Join(t.TempDir(), "probe.s")
+	if err := os.WriteFile(source, []byte("#include \"textflag.h\"\nTEXT probe(SB),$0-0\n\tMOVD R0,R1\n\tRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, diagnostic string
+	}{
+		{"foreign-prefix", "foreign" + source + ":3: bad operand\n"},
+		{"out-of-range-line", source + ":9999: bad operand\n"},
+		{"blank-line", source + ":5: bad operand\n"},
+		{"preprocessor-header", source + ":1: bad operand\n"},
+		{"out-of-range-column", source + ":3:9999: bad operand\n"},
+		{"wrong-listing-opcode", "asm: illegal combination: 00000 (" + source + ":3) MOVK $65537,R0\n"},
+		{"noncanonical-listing-PC", "asm: illegal combination: 000000 (" + source + ":3) MOVD R0,R1\n"},
+		{"foreign-listing-prefix", "foreign asm: illegal combination: 00000 (" + source + ":3) MOVD R0,R1\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if goAssemblerOracleSourceDiagnostic(source, test.diagnostic) {
+				t.Fatalf("unbound source diagnostic accepted: %q", test.diagnostic)
+			}
+		})
+	}
+	if !goAssemblerOracleSourceDiagnostic(source, "asm: illegal combination: 00000 ("+source+":3) MOVD R0,R1\n") {
+		t.Fatal("exact Go listing lost its source statement")
+	}
+}
diff --git a/go_assembler_oracle_infrastructure_go127_unix_test.go b/go_assembler_oracle_infrastructure_go127_unix_test.go
new file mode 100644
index 000000000..2b453a4f5
--- /dev/null
+++ b/go_assembler_oracle_infrastructure_go127_unix_test.go
@@ -0,0 +1,69 @@
+//go:build go1.27 && unix
+
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestGoAssemblerOraclesRejectInfrastructure(t *testing.T) {
+	if arch := os.Getenv("PLAN9ASM_ASSEMBLER_ORACLE_CHILD_ARCH"); arch != "" {
+		source := "TEXT ·bad(SB),$0-0\n\tNOT_AN_INSTRUCTION\n\tRET\n"
+		wantSuccess := os.Getenv("PLAN9ASM_ASSEMBLER_ORACLE_CHILD_SUCCESS") == "1"
+		if arch == "arm64" {
+			requireARM64GoAssemblerResult(t, source, wantSuccess)
+		} else {
+			requireX86GoAssemblerResult(t, arch, source, wantSuccess)
+		}
+		return
+	}
+
+	// Each child owns a private PATH. Its deliberately broken tool must fail
+	// the original test helper, not masquerade as an expected source rejection.
+	for _, arch := range []string{"arm64", "amd64", "386"} {
+		for _, test := range []struct {
+			name        string
+			script      string
+			wantSuccess bool
+		}{
+			{name: "missing tool"},
+			{name: "unknown exit", script: "exit 1\n"},
+			{name: "assembler footer only", script: "printf 'asm: assembly failed\\n' >&2\nexit 1\n"},
+			{name: "killed process", script: "kill -TERM \"$$\"\n"},
+			{name: "success without object", script: "exit 0\n", wantSuccess: true},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				dir := t.TempDir()
+				if test.script != "" {
+					if err := os.WriteFile(filepath.Join(dir, "go"), []byte("#!/bin/sh\n"+test.script), 0700); err != nil {
+						t.Fatal(err)
+					}
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+				defer cancel()
+				command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestGoAssemblerOraclesRejectInfrastructure$")
+				command.Env = append(os.Environ(),
+					"PATH="+dir,
+					"PLAN9ASM_ASSEMBLER_ORACLE_CHILD_ARCH="+arch,
+					"PLAN9ASM_ASSEMBLER_ORACLE_CHILD_SUCCESS=0",
+				)
+				if test.wantSuccess {
+					command.Env = append(command.Env, "PLAN9ASM_ASSEMBLER_ORACLE_CHILD_SUCCESS=1")
+				}
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				if ctx.Err() != nil {
+					t.Fatalf("failure probe exceeded its owned deadline: %v\n%s", ctx.Err(), output)
+				}
+				if err == nil || !strings.Contains(string(output), "Go assembler oracle infrastructure failure") {
+					t.Fatalf("broken tool was accepted as source/assembly evidence: %v\n%s", err, output)
+				}
+			})
+		}
+	}
+}
diff --git a/go_assembler_oracle_listing_test.go b/go_assembler_oracle_listing_test.go
new file mode 100644
index 000000000..c8b72a022
--- /dev/null
+++ b/go_assembler_oracle_listing_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestGoAssemblerOracleBackendListingsBindTheFixture(t *testing.T) {
+	dir := t.TempDir()
+	source := filepath.Join(dir, "forms.s")
+	if err := os.WriteFile(source, []byte("TEXT bad(SB),$0-0\nMOVK $65537,R0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, diagnostic := range []string{
+		"asm: bad constant for MOVK: 0x10001\n00000 (" + source + ":2)\tMOVK\t$65537, R0\nasm: assembly failed\n",
+		"asm: illegal SYS argument\n00000 (" + source + ":2)\tSYS\t$1\nasm: assembly failed\n",
+	} {
+		// SYS deliberately points at a MOVK source line: a listing is not a
+		// bound source diagnostic merely because its filename matches.
+		want := strings.HasPrefix(diagnostic, "asm: bad constant")
+		if got := goAssemblerOracleSourceDiagnostic(source, diagnostic); got != want {
+			t.Fatalf("backend listing binding = %v, want %v: %s", got, want, diagnostic)
+		}
+	}
+	for _, diagnostic := range []string{
+		"00000 (" + source + ":2)\tMOVK\t$65537,R0\nasm: assembly failed\n",
+		"asm: bad constant for MOVK\n00000 (" + source + ":0)\tMOVK\t$65537,R0\n",
+		"asm: bad constant for MOVK\n00000 (" + source + ":4)\tMOVK\t$65537,R0\n",
+		"asm: bad constant for MOVK\nnot-a-pc (" + source + ":2)\tMOVK\t$65537,R0\n",
+		"asm: bad constant for MOVK\n999999999999999999999999 (" + source + ":2)\tMOVK\t$65537,R0\n",
+		"asm: bad constant for MOVK\n000000 (" + source + ":2)\tMOVK\t$65537,R0\n",
+		"asm: assembly failed\n00000 (" + source + ":2)\tMOVK\t$65537,R0\n",
+	} {
+		if goAssemblerOracleSourceDiagnostic(source, diagnostic) {
+			t.Fatalf("unbound backend listing accepted: %s", diagnostic)
+		}
+	}
+}
+
+func TestGoAssemblerOracleActualPositionlessFrameRejection(t *testing.T) {
+	for _, source := range []string{
+		"TEXT bad(SB),516,$8-0\nRET\n",
+		"TEXT bad(SB),512,$16-0\nRET\n",
+	} {
+		// This is an actual source error on both current and older Go, not an
+		// expected tool crash, footer-only error or missing compiler.
+		goAssemblerOracleOutput(t, "arm64", source, "", false)
+	}
+	goAssemblerOracleOutput(t, "arm64", "TEXT valid(SB),516,$0-0\nRET\n", "", true)
+}
+
+func TestGoAssemblerOraclePositionlessDiagnosticsRequireExactSource(t *testing.T) {
+	source := filepath.Join(t.TempDir(), "forms.s")
+	for _, test := range []struct {
+		name, arch, assembly, diagnostic string
+		want                             bool
+	}{
+		{"frame", "arm64", "TEXT bad(SB),516,$8-0\nRET\n", "NOFRAME functions must have a frame size of 0, not 8", true},
+		{"different-frame", "arm64", "TEXT bad(SB),516,$16-0\nRET\n", "NOFRAME functions must have a frame size of 0, not 8", false},
+		{"framed", "arm64", "TEXT valid(SB),4,$8-0\nRET\n", "NOFRAME functions must have a frame size of 0, not 8", false},
+		{"zero-frame", "arm64", "TEXT valid(SB),516,$0-0\nRET\n", "NOFRAME functions must have a frame size of 0, not 8", false},
+		{"unknown-flags", "arm64", "TEXT bad(SB),UNKNOWN_FLAGS,$8-0\nRET\n", "NOFRAME functions must have a frame size of 0, not 8", false},
+		{"address", "386", "TEXT bad(SB),$0-0\nVSCATTERPF0DPD K1,(R8)(Y2*8)\nRET\n", "asmidx: bad address 8/Y2/R8", true},
+		{"different-base", "386", "TEXT bad(SB),$0-0\nVSCATTERPF0DPD K1,(R9)(Y2*8)\nRET\n", "asmidx: bad address 8/Y2/R8", false},
+		{"different-scale", "386", "TEXT bad(SB),$0-0\nVSCATTERPF0DPD K1,(R8)(Y2*4)\nRET\n", "asmidx: bad address 8/Y2/R8", false},
+		{"different-mode", "amd64", "TEXT valid(SB),$0-0\nVSCATTERPF0DPD K1,(R8)(Y2*8)\nRET\n", "asmidx: bad address 8/Y2/R8", false},
+		{"float-return", "amd64", "TEXT bad(SB),$0-0\nIRETW $0.0\nRET\n", "unexpected addr1: type=5 $(0.0)", true},
+		{"different-float", "amd64", "TEXT bad(SB),$0-0\nIRETW $1.5\nRET\n", "unexpected addr1: type=5 $(0.0)", false},
+		{"integer-return", "amd64", "TEXT bad(SB),$0-0\nIRETW $0\nRET\n", "unexpected addr1: type=5 $(0.0)", false},
+		{"float-move", "amd64", "TEXT valid(SB),$0-0\nMOVSS $0.0,X0\nRET\n", "unexpected addr1: type=5 $(0.0)", false},
+		{"unknown-diagnostic", "arm64", "TEXT bad(SB),516,$8-0\nRET\n", "unclassified tool failure", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if err := os.WriteFile(source, []byte(test.assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output := "asm: " + test.diagnostic + "\nasm: assembly failed\n"
+			if got := goAssemblerOraclePositionlessDiagnostic(source, test.arch, output); got != test.want {
+				t.Fatalf("source-bound backend diagnostic=%v, want %v", got, test.want)
+			}
+		})
+	}
+	if goAssemblerOraclePositionlessDiagnostic(source+".missing", "arm64", "asm: NOFRAME functions must have a frame size of 0, not 8\n") {
+		t.Fatal("missing original fixture certified a backend refusal")
+	}
+}
diff --git a/go_assembler_oracle_package_symbol_test.go b/go_assembler_oracle_package_symbol_test.go
new file mode 100644
index 000000000..e9f6c20eb
--- /dev/null
+++ b/go_assembler_oracle_package_symbol_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"bytes"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func goAssemblerOracleX86PackageDiagnostic(source, arch, output, packagePrefix string) bool {
+	if arch != "386" && arch != "amd64" || packagePrefix == "" {
+		return false
+	}
+	return goasmoracle.SourceDiagnosticLineWithListing(source, output, 0,
+		func(original, listing []string) bool {
+			if len(original) == 0 {
+				return false
+			}
+			canonical := append([]string(nil), original...)
+			if alias, present := goAssemblerOracleX86Aliases[canonical[0]]; present {
+				canonical[0] = alias
+			}
+			return goasmoracle.PackageQualifiedListing(canonical, listing, packagePrefix)
+		})
+}
+
+func goAssemblerOracleX86ObservedPackageDiagnostic(source, arch, output, packagePrefix string) bool {
+	if packagePrefix == "" {
+		return false
+	}
+	if goAssemblerOracleLegacyPackageSymbol() {
+		packagePrefix = `""`
+	}
+	return goAssemblerOracleX86PackageDiagnostic(source, arch, output, packagePrefix)
+}
+
+// Historical Go's lexer rewrites the local prefix to "" before parsing,
+// independently of -p. Bind that exact selected producer, not a Go-version
+// guess or an arbitrary package suffix in an error message.
+func goAssemblerOracleLegacyPackageSymbol() bool {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/lex/lex.go")
+	data, valid := goasmoracle.ReadSource(path)
+	if !valid {
+		return false
+	}
+	files := token.NewFileSet()
+	actual, err := parser.ParseFile(files, path, data, 0)
+	if err != nil {
+		return false
+	}
+	expected, err := parser.ParseFile(files, "expected.go", `package lex
+func Make(token ScanToken, text string) Token {
+ if token == scanner.Ident && strings.HasPrefix(text, "\u00B7") {
+  text = `+"`\"\"`"+` + text
+ }
+ text = strings.Replace(text, "\u00B7", ".", -1)
+ text = strings.Replace(text, "\u2215", "/", -1)
+ return Token{ScanToken: token, text: text}
+}`, 0)
+	if err != nil {
+		return false
+	}
+	// Ignore source positions and parser symbol-table pointers, but retain
+	// every AST node, operation and literal byte. Comment layout is not a
+	// producer difference; changing a string literal still is.
+	semanticField := func(name string, value reflect.Value) bool {
+		return name != "Obj" && value.Type() != reflect.TypeOf(token.NoPos)
+	}
+	var want bytes.Buffer
+	if ast.Fprint(&want, nil, expected.Decls[0], semanticField) != nil {
+		return false
+	}
+	matched := 0
+	for _, declaration := range actual.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "Make" {
+			continue
+		}
+		var got bytes.Buffer
+		if ast.Fprint(&got, nil, function, semanticField) != nil || got.String() != want.String() {
+			return false
+		}
+		matched++
+	}
+	return matched == 1
+}
+
+func TestGoAssemblerOracleX86BoundPackageQualification(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		for _, suffix := range []string{"", "+3", "-1"} {
+			source := x86DiagnosticFixture(t, alias+" $·value"+suffix+"(SB),AX")
+			listing := "MOVQ $example.com/forms.value" + suffix + "(SB),AX"
+			output := x86DiagnosticListing(source, listing)
+			if !goAssemblerOracleX86PackageDiagnostic(source, "386", output, "example.com/forms") {
+				t.Fatal("exact source/command package qualification lost")
+			}
+			for _, changed := range []string{
+				"MOVQ $other.example/forms.value" + suffix + "(SB),AX",
+				"MOVQ $example.com/forms.other" + suffix + "(SB),AX",
+				"MOVQ $example.com/forms.value+9(SB),AX",
+				"MOVQ $example.com/forms.value" + suffix + "(SB),BX",
+				"MOVQ $example.com/forms.value" + suffix + "(SB)",
+				"MOVL $example.com/forms.value" + suffix + "(SB),AX",
+			} {
+				if goAssemblerOracleX86PackageDiagnostic(source, "386", x86DiagnosticListing(source, changed), "example.com/forms") {
+					t.Fatal("changed complete listing acquired package role", changed)
+				}
+			}
+			if goAssemblerOracleX86PackageDiagnostic(source, "386", output, "") ||
+				goAssemblerOracleX86PackageDiagnostic(source, "arm64", output, "example.com/forms") {
+				t.Fatal("missing command package or foreign architecture borrowed qualification")
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_test.go b/go_assembler_oracle_test.go
new file mode 100644
index 000000000..54a4571a8
--- /dev/null
+++ b/go_assembler_oracle_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func goAssemblerOracleOutput(t *testing.T, arch, source, experiment string, wantSuccess bool) {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "forms.s"), filepath.Join(dir, "forms.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	// Includes belong to the selected SDK, not the temporary source directory
+	// or an ambient installation. Preserve source literals such as NOSPLIT.
+	include := filepath.Join(runtime.GOROOT(), "pkg", "include")
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-I", include, "-p", "example.com/forms", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	if experiment != "" {
+		command.Env = append(command.Env, "GOEXPERIMENT="+experiment)
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), wantSuccess, arch, "example.com/forms"); failure != nil {
+		t.Fatalf("%v\n%s\noriginal source:\n%s", failure, output, source)
+	}
+}
+
+func goAssemblerOracleOutcome(source, object string, output []byte, commandErr, contextErr error, wantSuccess bool, arch string, packagePrefix ...string) error {
+	return goasmoracle.CheckOutcome(source, object, output, nil, commandErr, contextErr,
+		wantSuccess, 0, func(source, diagnostic string) bool {
+			return arch == "wasm" && goasmoracle.WasmSourceDiagnosticLine(source, diagnostic, 0) ||
+				goAssemblerOracleX86SourceDiagnostic(source, arch, diagnostic) ||
+				goAssemblerOracleARM64SourceDiagnostic(source, arch, diagnostic) ||
+				goAssemblerOraclePositionlessDiagnostic(source, arch, diagnostic) ||
+				len(packagePrefix) == 1 && goAssemblerOracleX86ObservedPackageDiagnostic(source, arch, diagnostic, packagePrefix[0])
+		})
+}
+
+func goAssemblerOracleSourceDiagnostic(source, output string) bool {
+	return goasmoracle.SourceDiagnostic(source, output)
+}
+
+func TestGoAssemblerOracleActualCommonForms(t *testing.T) {
+	for _, arch := range []string{"arm64", "amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			// These common forms deliberately invoke every actual compatibility
+			// assembler, unlike a current-table oracle on an older toolchain.
+			goAssemblerOracleOutput(t, arch, "TEXT ·valid(SB),$0-0\n\tRET\n", "", true)
+			goAssemblerOracleOutput(t, arch, "TEXT ·invalid(SB),$0-0\n\tNOT_AN_INSTRUCTION\n\tRET\n", "", false)
+			invalid := "MOVD (R0),RSP"
+			if arch == "amd64" {
+				invalid = "MOVQ (AX),(BX)"
+			} else if arch == "386" {
+				invalid = "MOVL (AX),(BX)"
+			}
+			goAssemblerOracleOutput(t, arch, "TEXT ·invalid(SB),$0-0\n\t"+invalid+"\n\tRET\n", "", false)
+		})
+	}
+}
+
+func TestGoAssemblerOracleOutcomeRejectsUnboundRejections(t *testing.T) {
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "forms.s"), filepath.Join(dir, "forms.o")
+	if err := os.WriteFile(source, []byte("TEXT ·invalid(SB),$0-0\n\tNOT_AN_INSTRUCTION\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-o", object, source)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(source, object, output, err, ctx.Err(), false, "arm64"); failure != nil {
+		t.Fatalf("actual source rejection lost: %v\n%s", failure, output)
+	}
+	for _, test := range []struct {
+		name    string
+		output  string
+		err     error
+		context error
+	}{
+		{name: "no diagnostic", err: err},
+		{name: "footer only", output: "asm: assembly failed\n", err: err},
+		{name: "foreign source", output: "other.s:2: bad operand\n", err: err},
+		{name: "zero line", output: source + ":0: bad operand\n", err: err},
+		{name: "negative line", output: source + ":-2: bad operand\n", err: err},
+		{name: "overflow line", output: source + ":999999999999999999999999999999: bad operand\n", err: err},
+		{name: "zero column", output: source + ":2:0: bad operand\n", err: err},
+		{name: "negative column", output: source + ":2:-1: bad operand\n", err: err},
+		{name: "empty column", output: source + ":2:: bad operand\n", err: err},
+		{name: "empty message", output: source + ":2: \n", err: err},
+		{name: "joined cleanup", output: string(output), err: errors.Join(err, errors.New("owned cleanup failure"))},
+		{name: "canceled", output: string(output), err: err, context: context.Canceled},
+		{name: "deadline", output: string(output), err: err, context: context.DeadlineExceeded},
+		{name: "late infrastructure", output: string(output) + "fatal error: out of memory\n", err: err},
+		{name: "panic with source diagnostic", output: string(output) + "panic: internal assembler failure\n", err: err},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			failure := goAssemblerOracleOutcome(source, object, []byte(test.output), test.err, test.context, false, "arm64")
+			if failure == nil || !strings.Contains(failure.Error(), "infrastructure failure") {
+				t.Fatalf("unbound rejection accepted: %v", failure)
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_wasm_suffix_test.go b/go_assembler_oracle_wasm_suffix_test.go
new file mode 100644
index 000000000..20cc6983b
--- /dev/null
+++ b/go_assembler_oracle_wasm_suffix_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleWasmSuffixLabelActualLexicalFamily(t *testing.T) {
+	probe := func(t *testing.T, arch, word, suffix string) {
+		t.Helper()
+		directory := t.TempDir()
+		source, object := filepath.Join(directory, "forms.s"), filepath.Join(directory, "forms.o")
+		body := "TEXT Probe(SB),4,$0-0\n" + word + suffix + ": NOP\nRET\n"
+		if err := os.WriteFile(source, []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+		stage, cancelStage := runtimeOracleStageContext(t)
+		defer cancelStage()
+		ctx, cancel := context.WithTimeout(stage, 5*time.Second)
+		defer cancel()
+		observed, err := goasmcmd.Observe(ctx, directory,
+			append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+			"go", "tool", "asm", "-o", object, source)
+		encoded, encodeErr := json.Marshal(observed)
+		if encodeErr != nil {
+			t.Fatal(encodeErr)
+		}
+		t.Logf("ORACLE_CHILD %s", encoded)
+		accepted := arch != "wasm" || suffix == ""
+		if !observed.Waited || observed.ExitCode != map[bool]int{true: 0, false: 1}[accepted] || len(observed.Stdout) != 0 {
+			t.Fatalf("actual Go lexical outcome differs: %+v %v", observed, err)
+		}
+		if !accepted {
+			message := source + ":2: unrecognized instruction " + strconv.Quote(word) + "\n"
+			if !strings.Contains(string(observed.Stderr), message) {
+				t.Fatalf("actual first lexical word diagnostic absent: %s", observed.Stderr)
+			}
+		}
+		if failure := goAssemblerOracleOutcome(source, object, observed.Stderr, err, ctx.Err(), accepted, arch); failure != nil {
+			t.Errorf("source-bound suffix-label observation lost: %v\n%s", failure, observed.Stderr)
+		}
+	}
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		for _, suffix := range []string{"", ".EQ", ".S", ".EQ.S"} {
+			t.Run(arch+"_first"+suffix, func(t *testing.T) {
+				probe(t, arch, "first", suffix)
+			})
+		}
+	}
+	// These are the Go identifier lexer roles, not mnemonic-name guesses.
+	for _, word := range []string{"_first2", "世界", "pkg·first", "path∕first"} {
+		t.Run("wasm_"+word, func(t *testing.T) {
+			probe(t, "wasm", word, ".EQ.S")
+		})
+	}
+}
+
+func TestGoAssemblerOracleWasmSuffixLabelPositionControls(t *testing.T) {
+	source := filepath.Join(t.TempDir(), "forms.s")
+	if err := os.WriteFile(source, []byte("TEXT Probe(SB),4,$0-0\nfirst.EQ.S: NOP\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, output string
+		focus        int
+	}{
+		{"default-has-no-wasm-role", source + ":2: unrecognized instruction \"first\"\n", 2},
+		{"wrong-word", source + ":2: unrecognized instruction \"other\"\n", 2},
+		{"whole-suffix-is-not-word", source + ":2: unrecognized instruction \"first.EQ.S\"\n", 2},
+		{"wrong-physical-line", source + ":3: unrecognized instruction \"first\"\n", 0},
+		{"wrong-focus", source + ":2: unrecognized instruction \"first\"\n", 3},
+		{"foreign-prefix", "foreign-" + source + ":2: unrecognized instruction \"first\"\n", 2},
+		{"noncanonical-line", source + ":02: unrecognized instruction \"first\"\n", 2},
+		{"zero-column", source + ":2:0: unrecognized instruction \"first\"\n", 2},
+		{"out-of-range-column", source + ":2:999: unrecognized instruction \"first\"\n", 2},
+		{"malformed-quote", source + ":2: unrecognized instruction first\n", 2},
+		{"message-extension", source + ":2: unrecognized instruction \"first\" extra\n", 2},
+		{"footer-only", "asm: assembly failed\n", 2},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if goasmoracle.SourceDiagnosticLine(source, test.output, test.focus) {
+				t.Fatal("default observer borrowed an unbound or target-only frontend role")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_x86_actual_go127_test.go b/go_assembler_oracle_x86_actual_go127_test.go
new file mode 100644
index 000000000..fb15ff822
--- /dev/null
+++ b/go_assembler_oracle_x86_actual_go127_test.go
@@ -0,0 +1,138 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86AliasTableCompleteActualSDK(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "asm", "internal", "arch", "arch.go")
+	data, ok := goasmoracle.ReadSource(path)
+	if !ok {
+		t.Fatal("complete original Go alias source unavailable")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == "archX86" {
+			if body != nil {
+				t.Fatal("duplicate original archX86 declaration")
+			}
+			body = function.Body
+		}
+	}
+	if body == nil {
+		t.Fatal("original archX86 declaration absent")
+	}
+	aliases, identities := make(map[string]string), make(map[string]string)
+	ast.Inspect(body, func(node ast.Node) bool {
+		assignment, ok := node.(*ast.AssignStmt)
+		if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+			return true
+		}
+		index, ok := assignment.Lhs[0].(*ast.IndexExpr)
+		if !ok {
+			return true
+		}
+		mapName, ok := index.X.(*ast.Ident)
+		key, literal := index.Index.(*ast.BasicLit)
+		if !ok || mapName.Name != "instructions" || !literal || key.Kind != token.STRING {
+			return true
+		}
+		value, ok := assignment.Rhs[0].(*ast.SelectorExpr)
+		if !ok {
+			t.Fatalf("unmodeled original explicit alias assignment: %#v", assignment)
+		}
+		owner, ok := value.X.(*ast.Ident)
+		name, err := strconv.Unquote(key.Value)
+		if !ok || owner.Name != "x86" || err != nil || !strings.HasPrefix(value.Sel.Name, "A") {
+			t.Fatal("unmodeled original alias identity")
+		}
+		canonical := strings.TrimPrefix(value.Sel.Name, "A")
+		if _, duplicate := aliases[name]; duplicate {
+			t.Fatal("duplicate original nonidentity alias")
+		}
+		if _, duplicate := identities[name]; duplicate {
+			t.Fatal("duplicate original identity alias")
+		}
+		if name == canonical {
+			identities[name] = canonical
+		} else {
+			aliases[name] = canonical
+		}
+		return true
+	})
+	wantIdentity := map[string]string{}
+	for _, name := range []string{"JCC", "JCS", "JEQ", "JGE", "JGT", "JHI", "JLE", "JLS", "JLT", "JMI", "JNE", "JOC", "JOS", "JPC", "JPL", "JPS"} {
+		wantIdentity[name] = name
+	}
+	if !reflect.DeepEqual(aliases, goAssemblerOracleX86Aliases) || !reflect.DeepEqual(identities, wantIdentity) {
+		t.Fatalf("complete original 40 nonidentity/16 identity aliases differ: %v / %v", aliases, identities)
+	}
+}
+
+func TestGoAssemblerOracleActualX86ScalarZeroListingFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+			for _, test := range []struct{ name, operand string }{
+				{"zero", "$0.0,X0"},
+				{"negative-zero", "$-0.0,X0"},
+				{"mask-zero", "$0.0,K1,X0"},
+				{"unary-zero", "$+(-( -0.0)),K1,X0"},
+			} {
+				t.Run(arch+"_"+opcode+"_"+test.name, func(t *testing.T) {
+					source := x86DiagnosticFixture(t, opcode+" "+test.operand)
+					object := filepath.Join(filepath.Dir(source), "forms.o")
+					stage, cancelStage := runtimeOracleStageContext(t)
+					defer cancelStage()
+					ctx, cancel := context.WithTimeout(stage, time.Minute)
+					defer cancel()
+					observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+						append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+						"go", "tool", "asm", "-S", "-o", object, source)
+					encoded, encodeErr := json.Marshal(observed)
+					if encodeErr != nil {
+						t.Fatal(encodeErr)
+					}
+					t.Logf("ORACLE_CHILD %s", encoded)
+					accepted := test.name == "zero" || test.name == "negative-zero"
+					if !observed.Waited || observed.ExitCode != map[bool]int{true: 0, false: 1}[accepted] {
+						t.Fatalf("actual scalar outcome differs: %+v %v", observed, err)
+					}
+					additional := func(source, output string) bool {
+						return goAssemblerOracleX86SourceDiagnostic(source, arch, output)
+					}
+					if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+						err, ctx.Err(), accepted, 2, additional); failure != nil {
+						t.Fatalf("actual complete scalar observation lost: %v\n%s\n%s", failure, observed.Stdout, observed.Stderr)
+					}
+					if test.name != "negative-zero" && !strings.Contains(string(observed.Stdout)+string(observed.Stderr), "XORPS") {
+						t.Fatal("actual Go positive-zero rewrite absent")
+					}
+					if test.name == "negative-zero" && strings.Contains(string(observed.Stdout)+string(observed.Stderr), "XORPS") {
+						t.Fatal("actual Go negative zero borrowed the positive-zero rewrite")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_address_listing_test.go b/go_assembler_oracle_x86_address_listing_test.go
new file mode 100644
index 000000000..41b0cf5b5
--- /dev/null
+++ b/go_assembler_oracle_x86_address_listing_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"unicode"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// This directory identifies lexical registers in the selected Go frontend.
+// It grants neither a valid memory addressing form nor instruction support.
+var goAssemblerOracleX86AddressRegisters struct {
+	sync.Once
+	names map[string]bool
+}
+
+func goAssemblerOracleX86AddressRegister(name, arch string) bool {
+	goAssemblerOracleX86AddressRegisters.Do(func() {
+		path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/list6.go")
+		data, valid := goasmoracle.ReadSource(path)
+		if !valid {
+			return
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+		if err != nil {
+			return
+		}
+		var arrays []*ast.CompositeLit
+		ast.Inspect(file, func(node ast.Node) bool {
+			entry, ok := node.(*ast.ValueSpec)
+			if !ok || len(entry.Names) != 1 || entry.Names[0].Name != "Register" || len(entry.Values) != 1 {
+				return true
+			}
+			if array, ok := entry.Values[0].(*ast.CompositeLit); ok {
+				arrays = append(arrays, array)
+			}
+			return false
+		})
+		if len(arrays) != 1 {
+			return
+		}
+		names := make(map[string]bool)
+		for _, entry := range arrays[0].Elts {
+			literal, ok := entry.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil || names[name] {
+				return
+			}
+			names[name] = true
+		}
+		if names["AX"] && names["SP"] && names["X0"] {
+			goAssemblerOracleX86AddressRegisters.names = names
+		}
+	})
+	return goAssemblerOracleX86AddressRegisters.names[name] || name == "g" && arch == "amd64"
+}
+
+func goAssemblerOracleX86AddressRole(tokens []string, arch string) (external, valid bool) {
+	first := -1
+	for index, text := range tokens {
+		if text == "(" {
+			first = index
+			break
+		}
+	}
+	if first < 0 || first+2 >= len(tokens) {
+		return false, false
+	}
+	base := tokens[first+1]
+	pseudo := base == "SB" || base == "FP" || base == "SP"
+	if first > 0 {
+		for index, text := range tokens[:first] {
+			if index == 0 && pseudo && !goAssemblerOracleX86AddressRegister(text, arch) &&
+				len(text) > 0 && (unicode.IsLetter([]rune(text)[0]) || strings.HasPrefix(text, "_")) {
+				continue
+			}
+			if text == "+" || text == "-" || text == "<" || text == ">" {
+				continue
+			}
+			if _, err := strconv.ParseUint(text, 0, 64); err != nil {
+				return false, false
+			}
+		}
+	}
+	for position := first; position < len(tokens); {
+		if position+2 >= len(tokens) || tokens[position] != "(" {
+			return false, false
+		}
+		register := tokens[position+1]
+		if !(position == first && pseudo) && !goAssemblerOracleX86AddressRegister(register, arch) {
+			return false, false
+		}
+		end := position + 2
+		if tokens[end] == "*" {
+			if end+2 >= len(tokens) || position == first && pseudo {
+				return false, false
+			}
+			switch tokens[end+1] {
+			case "1", "2", "4", "8":
+			default:
+				return false, false
+			}
+			end += 2
+		}
+		if tokens[end] != ")" {
+			return false, false
+		}
+		position = end + 1
+	}
+	return base == "SB", true
+}
+
+func goAssemblerOracleX86AddressListing(original, listing []string, arch string) bool {
+	sourceOp, suffix, args, sourceOK := goAssemblerOracleX86Statement(original)
+	listedOp, listedSuffix, listedArgs, listedOK := goAssemblerOracleX86Statement(listing)
+	if !sourceOK || !listedOK || suffix != "" || listedSuffix != "" ||
+		len(args) != 2 || len(listedArgs) != 2 || len(args[0]) < 4 || args[0][0] != "$" {
+		return false
+	}
+	if canonical, alias := goAssemblerOracleX86Aliases[sourceOp]; alias {
+		sourceOp = canonical
+	}
+	want := map[string]string{"MOVL": "LEAL", "MOVQ": "LEAQ"}[sourceOp]
+	if want == "" || listedOp != want {
+		return false
+	}
+	address := args[0][1:]
+	external, valid := goAssemblerOracleX86AddressRole(address, arch)
+	// Go excludes EXTERN and STATIC TYPE_ADDR only on I386. It is the source
+	// mode, not host architecture or LLVM's interpretation of an LEA.
+	return valid && !(arch == "386" && external) &&
+		reflect.DeepEqual(address, listedArgs[0]) && reflect.DeepEqual(args[1], listedArgs[1])
+}
diff --git a/go_assembler_oracle_x86_address_test.go b/go_assembler_oracle_x86_address_test.go
new file mode 100644
index 000000000..c4c435cba
--- /dev/null
+++ b/go_assembler_oracle_x86_address_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86AddressRewriteSourceRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ"} {
+			lea := map[string]string{"MOVL": "LEAL", "MOVQ": "LEAQ"}[op]
+			for _, address := range []string{
+				"slot+8(FP)(CX*2)", "slot-8(SP)(CX*2)",
+				"slot+8(SB)(CX*2)", "slot<>+8(SB)(CX*2)",
+				"8(AX)(CX*2)", "(AX)(X1*2)",
+			} {
+				t.Run(arch+"/"+op+"/"+address, func(t *testing.T) {
+					source := x86DiagnosticFixture(t, op+" $"+address+",AX")
+					output := x86DiagnosticListing(source, lea+" "+address+",AX")
+					want := arch == "amd64" || !strings.Contains(address, "(SB)")
+					if got := goAssemblerOracleX86SourceDiagnostic(source, arch, output); got != want {
+						t.Fatalf("exact progedit source role=%v, want %v", got, want)
+					}
+					if goasmoracle.SourceDiagnosticLine(source, output, 2) {
+						t.Fatal("address rewrite escaped the explicit x86 diagnostic adapter")
+					}
+					for _, changed := range []string{
+						lea + " " + address + ",BX", lea + " " + address,
+						lea + " " + address + ",AX,BX", lea + ".Z " + address + ",AX",
+					} {
+						if goAssemblerOracleX86SourceDiagnostic(source, arch, x86DiagnosticListing(source, changed)) {
+							t.Fatalf("changed complete address listing borrowed the source: %q", changed)
+						}
+					}
+				})
+			}
+		}
+	}
+	for _, original := range []string{
+		"MOVB $8(AX),AX", "MOVW $8(AX),AX", "MOVL 8(AX),AX", "MOVL $8,AX",
+		"MOVL $(8),AX", "MOVL $0.0,AX", "MOVL.Z $8(AX),AX", "MOVL $8(AX),AX,BX",
+	} {
+		source := x86DiagnosticFixture(t, original)
+		if goAssemblerOracleX86SourceDiagnostic(source, "amd64", x86DiagnosticListing(source, "LEAL 8(AX),AX")) {
+			t.Fatalf("non-address or unrelated opcode acquired a progedit role: %q", original)
+		}
+	}
+}
+
+func TestGoAssemblerOracleActualX86AddressRewriteFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		ops := []string{"MOVL"}
+		if arch == "amd64" {
+			ops = append(ops, "MOVQ")
+		}
+		for _, op := range ops {
+			for _, test := range []struct {
+				name, address string
+				accepted      bool
+			}{
+				{"external-index", "slot+8(SB)(CX*2)", arch == "386"},
+				{"static-index", "slot<>+8(SB)(CX*2)", arch == "386"},
+				{"physical-index", "8(AX)(CX*2)", true},
+				{"vector-index", "8(AX)(X1*2)", false},
+			} {
+				t.Run(arch+"/"+op+"/"+test.name, func(t *testing.T) {
+					source := x86DiagnosticFixture(t, op+" $"+test.address+",AX")
+					object := filepath.Join(filepath.Dir(source), "forms.o")
+					stage, cancelStage := runtimeOracleStageContext(t)
+					defer cancelStage()
+					ctx, cancel := context.WithTimeout(stage, time.Minute)
+					defer cancel()
+					observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+						append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+						"go", "tool", "asm", "-o", object, source)
+					encoded, encodeErr := json.Marshal(observed)
+					if encodeErr != nil {
+						t.Fatal(encodeErr)
+					}
+					t.Logf("ORACLE_CHILD %s", encoded)
+					wantExit := 1
+					if test.accepted {
+						wantExit = 0
+					}
+					if !observed.Waited || observed.ExitCode != wantExit || ctx.Err() != nil {
+						t.Fatalf("original Go address outcome differs: %+v %v", observed, err)
+					}
+					additional := func(source, output string) bool {
+						return goAssemblerOracleX86SourceDiagnostic(source, arch, output)
+					}
+					if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+						err, ctx.Err(), test.accepted, 2, additional); failure != nil {
+						t.Fatalf("actual complete address observation lost: %v\n%s", failure, observed.Stderr)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_alias_zero_go127_test.go b/go_assembler_oracle_x86_alias_zero_go127_test.go
new file mode 100644
index 000000000..4d67f6409
--- /dev/null
+++ b/go_assembler_oracle_x86_alias_zero_go127_test.go
@@ -0,0 +1,49 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleActualX86ZeroOperandAliasListings(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, suffix := range []string{"", ".Z"} {
+			t.Run(arch+"_MOVD"+suffix, func(t *testing.T) {
+				source := x86DiagnosticFixture(t, "MOVD"+suffix)
+				object := filepath.Join(filepath.Dir(source), "forms.o")
+				stage, cancelStage := runtimeOracleStageContext(t)
+				defer cancelStage()
+				ctx, cancel := context.WithTimeout(stage, 5*time.Second)
+				defer cancel()
+				observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+					append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+					"go", "tool", "asm", "-o", object, source)
+				encoded, encodeErr := json.Marshal(observed)
+				if encodeErr != nil {
+					t.Fatal(encodeErr)
+				}
+				t.Logf("ORACLE_CHILD %s", encoded)
+				if !observed.Waited || observed.ExitCode != 1 ||
+					!strings.Contains(string(observed.Stderr), "("+source+":2)\tMOVQ"+suffix+"\n") {
+					t.Fatalf("actual zero-operand canonical alias listing absent: %+v %v", observed, err)
+				}
+				if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+					err, ctx.Err(), false, 2, func(source, output string) bool {
+						return goAssemblerOracleX86SourceDiagnostic(source, arch, output)
+					}); failure != nil {
+					t.Fatalf("complete zero-operand alias observation lost: %v", failure)
+				}
+			})
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_float_listing_test.go b/go_assembler_oracle_x86_float_listing_test.go
new file mode 100644
index 000000000..e36566a58
--- /dev/null
+++ b/go_assembler_oracle_x86_float_listing_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Match Go's TYPE_CONST and TYPE_FCONST Prog formatting without converting
+// integer source tokens into FLOAT or granting instruction/lowering permission.
+// The FLOAT frontend consumes one leaf with only unary signs and parentheses.
+func goAssemblerOracleX86OperandListing(original, listing []string) bool {
+	if reflect.DeepEqual(original, listing) {
+		return true
+	}
+	if len(original) < 2 || original[0] != "$" {
+		return goAssemblerOracleX86MemoryLiteralListing(original, listing)
+	}
+	// TYPE_CONST is rendered as signed decimal, independently of an opcode
+	// alias. Bind exactly one integer token and its optional unary sign;
+	// FLOAT, expressions, symbols and another constant cannot borrow it.
+	if value, valid := goAssemblerOracleX86IntegerLiteral(original[1:]); valid {
+		printed := strconv.FormatInt(value, 10)
+		want := []string{"$"}
+		if strings.HasPrefix(printed, "-") {
+			want, printed = append(want, "-"), strings.TrimPrefix(printed, "-")
+		}
+		return reflect.DeepEqual(append(want, printed), listing)
+	}
+	leaves := 0
+	for _, token := range original[1:] {
+		switch token {
+		case "+", "-", "(", ")":
+		default:
+			if _, valid := parseGoFloatLiteral(token); !valid {
+				return false
+			}
+			leaves++
+		}
+	}
+	value, valid := parseGoFloatLiteral(strings.Join(original[1:], ""))
+	if leaves != 1 || !valid {
+		return false
+	}
+	// obj.Dconv uses 17 significant digits and forces a decimal point for
+	// integral values, including negative zero. Require the exact canonical
+	// token sequence, rather than accepting numerically equivalent output.
+	printed := fmt.Sprintf("%.17g", value)
+	if !strings.ContainsAny(printed, ".e") {
+		printed += ".0"
+	}
+	want := []string{"$", "("}
+	if strings.HasPrefix(printed, "-") {
+		want = append(want, "-")
+		printed = strings.TrimPrefix(printed, "-")
+	}
+	want = append(want, printed, ")")
+	return reflect.DeepEqual(want, listing)
+}
diff --git a/go_assembler_oracle_x86_float_test.go b/go_assembler_oracle_x86_float_test.go
new file mode 100644
index 000000000..0a742282f
--- /dev/null
+++ b/go_assembler_oracle_x86_float_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// Go's TYPE_FCONST formatter preserves the float64 value, not its source
+// spelling. These independent expected strings include signed zero, rounding,
+// exponent normalization and unary/parenthesized frontend expressions.
+var x86OracleFloatListingCases = []struct{ source, printed string }{
+	{"0.0", "0.0"},
+	{"-0.0", "-0.0"},
+	{"1.25", "1.25"},
+	{"1e-50", "1e-50"},
+	{"0x1.fp+2", "7.75"},
+	{"+(-(-1.25))", "1.25"},
+	{"1.0000000000000002", "1.0000000000000002"},
+	{"1e20", "1e+20"},
+}
+
+func TestGoAssemblerOracleX86AliasFloatCompleteOperandRoles(t *testing.T) {
+	for alias, canonical := range goAssemblerOracleX86Aliases {
+		t.Run(alias, func(t *testing.T) {
+			for _, pair := range [][2]string{
+				{"$1.25", "$(1.25)"},
+				{"$1.25,X1", "$(1.25),X1"},
+				{"X0,$1.25", "X0,$(1.25)"},
+				{"$1.25,X1,K1,$-0.0", "$(1.25),X1,K1,$(-0.0)"},
+			} {
+				source := x86DiagnosticFixture(t, alias+" "+pair[0])
+				output := x86DiagnosticListing(source, canonical+" "+pair[1])
+				for _, arch := range []string{"amd64", "386"} {
+					if !goAssemblerOracleX86SourceDiagnostic(source, arch, output) {
+						t.Errorf("%s complete FLOAT alias listing lost: %s %s", arch, alias, pair[0])
+					}
+				}
+				if goasmoracle.SourceDiagnosticLine(source, output, 2) ||
+					goAssemblerOracleX86SourceDiagnostic(source, "arm64", output) {
+					t.Fatal("FLOAT alias join escaped its explicit x86 observation role")
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleX86AliasFloatValueAndLexicalBoundaries(t *testing.T) {
+	for _, test := range x86OracleFloatListingCases {
+		t.Run(test.source, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, "MOVD $"+test.source+",X1")
+			output := x86DiagnosticListing(source, "MOVQ $("+test.printed+"),X1")
+			if !goAssemblerOracleX86SourceDiagnostic(source, "amd64", output) {
+				t.Fatal("complete source FLOAT value lost", test)
+			}
+			for _, changed := range []string{
+				"MOVQ $(2.5),X1", "MOVQ $(" + test.printed + "),X2",
+				"MOVQ $(" + test.printed + ")", "MOVQ $(" + test.printed + "),X1,K1",
+				"MOVQ.Z $(" + test.printed + "),X1", "MOVL $(" + test.printed + "),X1",
+			} {
+				if goAssemblerOracleX86SourceDiagnostic(source, "amd64", x86DiagnosticListing(source, changed)) {
+					t.Fatal("FLOAT join discarded a complete source axis", changed)
+				}
+			}
+		})
+	}
+	for _, sourceFloat := range []string{"1", "0 . 0", "1.0+0.25", "1.25*1", "NaN", "Inf", "1e309"} {
+		source := x86DiagnosticFixture(t, "MOVD $"+sourceFloat+",X1")
+		if goAssemblerOracleX86SourceDiagnostic(source, "amd64", x86DiagnosticListing(source, "MOVQ $(1.25),X1")) {
+			t.Fatal("non-FLOAT or unresolved expression borrowed TYPE_FCONST", sourceFloat)
+		}
+	}
+	source := x86DiagnosticFixture(t, "MOVD $-0.0,X1")
+	for _, printed := range []string{"0.0", "-0", "-0.00", "(-0.0)", "-0.0+0.0"} {
+		if goAssemblerOracleX86SourceDiagnostic(source, "amd64", x86DiagnosticListing(source, "MOVQ $("+printed+"),X1")) {
+			t.Fatal("noncanonical or sign-changing FLOAT listing accepted", printed)
+		}
+	}
+}
+
+func TestGoAssemblerOracleActualX86AliasFloatFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, alias := range []string{"MOVD", "MOVDQ2Q", "MOVOA"} {
+			for _, test := range x86OracleFloatListingCases {
+				for _, destination := range []bool{false, true} {
+					name := arch + "/" + alias + "/" + test.source + "/from"
+					operands := "$" + test.source + ",X1"
+					if destination {
+						name = strings.TrimSuffix(name, "from") + "to"
+						operands = "X0,$" + test.source
+					}
+					t.Run(name, func(t *testing.T) {
+						source := x86DiagnosticFixture(t, alias+" "+operands)
+						object := filepath.Join(filepath.Dir(source), "forms.o")
+						stage, cancelStage := runtimeOracleStageContext(t)
+						defer cancelStage()
+						ctx, cancel := context.WithTimeout(stage, time.Minute)
+						defer cancel()
+						observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+							append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+							"go", "tool", "asm", "-o", object, source)
+						encoded, encodeErr := json.Marshal(observed)
+						if encodeErr != nil {
+							t.Fatal(encodeErr)
+						}
+						t.Logf("ORACLE_CHILD %s", encoded)
+						if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil {
+							t.Fatalf("actual original FLOAT refusal absent: %+v %v", observed, err)
+						}
+						additional := func(source, output string) bool {
+							return goAssemblerOracleX86SourceDiagnostic(source, arch, output)
+						}
+						if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+							err, ctx.Err(), false, 2, additional); failure != nil {
+							t.Fatalf("actual complete FLOAT alias observation lost: %v\n%s", failure, observed.Stderr)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_frame_actual_go127_test.go b/go_assembler_oracle_x86_frame_actual_go127_test.go
new file mode 100644
index 000000000..504bfcf1a
--- /dev/null
+++ b/go_assembler_oracle_x86_frame_actual_go127_test.go
@@ -0,0 +1,106 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86FrameRebaseActualSDKRules(t *testing.T) {
+	source := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "obj6.go")
+	data, ok := goasmoracle.ReadSource(source)
+	if !ok {
+		t.Fatal("complete actual selected SDK preprocess source unavailable")
+	}
+	for _, rule := range []string{
+		"autoffset := int32(p.To.Offset)",
+		"if autoffset < 0 {\n\t\tautoffset = 0\n\t}",
+		"if ctxt.Arch.Family == sys.AMD64 &&",
+		"p.From.Offset += int64(deltasp) - int64(bpsize)",
+		"p.From.Offset += int64(deltasp) + int64(pcsize)",
+		"p.GetFrom3().Offset += int64(deltasp) - int64(bpsize)",
+		"p.GetFrom3().Offset += int64(deltasp) + int64(pcsize)",
+		"p.To.Offset += int64(deltasp) - int64(bpsize)",
+		"p.To.Offset += int64(deltasp) + int64(pcsize)",
+		"pcsize := ctxt.Arch.RegSize",
+		"case APUSHL, APUSHFL:\n\t\t\tdeltasp += 4",
+		"case APUSHQ, APUSHFQ:\n\t\t\tdeltasp += 8",
+		"case APUSHW, APUSHFW:\n\t\t\tdeltasp += 2",
+		"case APOPL, APOPFL:\n\t\t\tdeltasp -= 4",
+		"case APOPQ, APOPFQ:\n\t\t\tdeltasp -= 8",
+		"case APOPW, APOPFW:\n\t\t\tdeltasp -= 2",
+		"deltasp += int32(p.From.Offset)",
+		"p.Spadj = +autoffset",
+	} {
+		if !bytes.Contains(data, []byte(rule)) {
+			t.Fatalf("actual SDK source-stack diagnostic rule changed: %q", rule)
+		}
+	}
+}
+
+func TestGoAssemblerOracleActualX86Mode32FrameRebase(t *testing.T) {
+	for _, test := range []struct{ name, frame, prefix, suffix, operand string }{
+		{"param-zero", "$0-32", "", "", "a+0(FP)"},
+		{"param-frame", "$16-32", "", "", "renamed+8(FP)"},
+		{"param-negative", "$16-32", "", "", "a-8(FP)"},
+		{"negative-frame", "$-4-32", "", "", "a+0(FP)"},
+		{"auto-zero", "$16-32", "", "", "local-16(SP)"},
+		{"auto-bare", "$16-32", "", "", "tmp(SP)"},
+		{"push-long", "$16-32", "PUSHL AX\n", "POPL AX\n", "a+0(FP)"},
+		{"push-word", "$0-32", "PUSHW AX\n", "POPW AX\n", "a+0(FP)"},
+		{"push-flags", "$0-32", "PUSHFL\n", "POPFL\n", "a+0(FP)"},
+		{"adj-positive", "$0-32", "ADJSP $8\n", "ADJSP $-8\n", "a+0(FP)"},
+		{"adj-negative", "$16-32", "ADJSP $-8\n", "ADJSP $8\n", "a+0(FP)"},
+		{"index-param", "$16-32", "", "", "a+0(FP)(SI*2)"},
+	} {
+		for _, op := range []string{"MOVOA", "MOVD"} {
+			for _, store := range []bool{false, true} {
+				direction, operands := "read", test.operand+",X8"
+				if store {
+					direction, operands = "write", "X15,"+test.operand
+				}
+				t.Run(test.name+"/"+op+"/"+direction, func(t *testing.T) {
+					text := "TEXT probe(SB),4," + test.frame + "\n" + test.prefix + op + " " + operands + "\n" + test.suffix + "RET\n"
+					source := x86FrameDiagnosticFixture(t, text)
+					object := filepath.Join(filepath.Dir(source), "frame.o")
+					stage, cancelStage := runtimeOracleStageContext(t)
+					defer cancelStage()
+					ctx, cancel := context.WithTimeout(stage, time.Minute)
+					defer cancel()
+					observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+						append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386"),
+						"go", "tool", "asm", "-o", object, source)
+					encoded, encodeErr := json.Marshal(observed)
+					if encodeErr != nil {
+						t.Fatal(encodeErr)
+					}
+					t.Logf("ORACLE_CHILD %s", encoded)
+					focus := 2 + strings.Count(test.prefix, "\n")
+					if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil ||
+						!bytes.Contains(observed.Stderr, []byte("("+source+":"+strconv.Itoa(focus)+")")) ||
+						!bytes.Contains(observed.Stderr, []byte("asmins: illegal in mode 32:")) {
+						t.Fatalf("actual complete high-bank/frame diagnostic prerequisite absent: %+v %v", observed, err)
+					}
+					if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+						err, ctx.Err(), false, focus, func(source, output string) bool {
+							return goAssemblerOracleX86SourceDiagnostic(source, "386", output)
+						}); failure != nil {
+						t.Errorf("actual original source/frame rewrite did not bind: %v\n%s", failure, observed.Stderr)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_frame_listing_test.go b/go_assembler_oracle_x86_frame_listing_test.go
new file mode 100644
index 000000000..c69f9fc50
--- /dev/null
+++ b/go_assembler_oracle_x86_frame_listing_test.go
@@ -0,0 +1,277 @@
+package plan9asm
+
+import (
+	"bytes"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"text/scanner"
+	"unicode"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// This is only an original-Go diagnostic join, not a frame/operand permission.
+// The selected SDK source and actual commands independently check obj6.go's
+// preprocess rule: I386 has bpsize0, AUTO += deltasp and PARAM += deltasp+4.
+// Its bounded context is literal NOSPLIT TEXT, one focused instruction, NOP
+// and explicit W/L stack steps, ending at RET. Branches, calls, CPP, other
+// writes to SP and post-RET source are deliberately not modeled as a CFG.
+func goAssemblerOracleX86Mode32FrameListing(source, diagnostic string, original, listing []string) bool {
+	data, ok := goasmoracle.ReadSource(source)
+	if !ok {
+		return false
+	}
+	marker := "(" + source + ":"
+	_, position, found := strings.Cut(diagnostic, marker)
+	number, _, ended := strings.Cut(position, ")")
+	focus, err := strconv.Atoi(number)
+	lines := strings.Split(string(data), "\n")
+	if !found || !ended || err != nil || focus < 1 || strconv.Itoa(focus) != number || focus > len(lines) || len(lines) > 4096 {
+		return false
+	}
+	statements := make([][]string, len(lines))
+	start, end := -1, len(lines)
+	for index, line := range lines {
+		if strings.HasPrefix(strings.TrimSpace(line), "#") {
+			return false
+		}
+		tokens, valid := goAssemblerOracleX86FrameTokens(line)
+		if !valid {
+			return false
+		}
+		statements[index] = tokens
+		if len(tokens) != 0 && tokens[0] == "TEXT" {
+			if index < focus-1 {
+				start = index
+			} else if end == len(lines) {
+				end = index
+			}
+		}
+	}
+	if start < 0 || !reflect.DeepEqual(statements[focus-1], original) {
+		return false
+	}
+	frame, valid := goAssemblerOracleX86FrameText(statements[start])
+	if !valid {
+		return false
+	}
+	delta, atFocus := frame, int64(0)
+	returned := false
+	for index := start + 1; index < end; index++ {
+		tokens := statements[index]
+		if len(tokens) == 0 {
+			continue
+		}
+		if returned {
+			return false
+		}
+		if index == focus-1 {
+			atFocus = delta
+			continue
+		}
+		switch {
+		case reflect.DeepEqual(tokens, []string{"NOP"}):
+			continue
+		case reflect.DeepEqual(tokens, []string{"RET"}):
+			if index < focus-1 || delta != frame {
+				return false
+			}
+			returned = true
+		default:
+			step, known := goAssemblerOracleX86FrameStep(tokens)
+			if !known || delta+step < math.MinInt32 || delta+step > math.MaxInt32 {
+				return false
+			}
+			delta += step
+		}
+	}
+	if !returned {
+		return false
+	}
+	opcode, suffix, args, valid := goAssemblerOracleX86Statement(original)
+	if !valid {
+		return false
+	}
+	rewritten := []string{opcode}
+	for _, part := range strings.Split(strings.TrimPrefix(suffix, "."), ".") {
+		if part != "" {
+			rewritten = append(rewritten, ".", part)
+		}
+	}
+	changed := false
+	for index, operand := range args {
+		adjusted, role, accepted := goAssemblerOracleX86FrameOperand(operand, atFocus)
+		if !accepted {
+			return false
+		}
+		if index != 0 {
+			rewritten = append(rewritten, ",")
+		}
+		rewritten = append(rewritten, adjusted...)
+		changed = changed || role
+	}
+	after, stable := goasmoracle.ReadSource(source)
+	return changed && stable && bytes.Equal(data, after) && goAssemblerOracleX86Mode32Listing(rewritten, listing)
+}
+
+func goAssemblerOracleX86FrameTokens(line string) ([]string, bool) {
+	var lex scanner.Scanner
+	lex.Init(strings.NewReader(line))
+	lex.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanComments | scanner.SkipComments
+	lex.IsIdentRune = func(r rune, index int) bool {
+		return r == '_' || r == '·' || r == '∕' || unicode.IsLetter(r) || index > 0 && unicode.IsDigit(r)
+	}
+	valid := true
+	lex.Error = func(*scanner.Scanner, string) { valid = false }
+	var tokens []string
+	for token := lex.Scan(); token != scanner.EOF; token = lex.Scan() {
+		if len(tokens) == 256 {
+			return nil, false
+		}
+		tokens = append(tokens, lex.TokenText())
+	}
+	return tokens, valid
+}
+
+func goAssemblerOracleX86FrameInteger(tokens []string) (int64, bool) {
+	if len(tokens) == 0 || len(tokens) > 2 {
+		return 0, false
+	}
+	if len(tokens) == 2 && tokens[0] != "+" && tokens[0] != "-" {
+		return 0, false
+	}
+	value, err := strconv.ParseInt(strings.Join(tokens, ""), 0, 64)
+	return value, err == nil
+}
+
+func goAssemblerOracleX86FrameText(tokens []string) (int64, bool) {
+	opcode, suffix, args, ok := goAssemblerOracleX86Statement(tokens)
+	if !ok || opcode != "TEXT" || suffix != "" || len(args) != 3 ||
+		len(args[0]) != 4 || args[0][1] != "(" || args[0][2] != "SB" || args[0][3] != ")" ||
+		!goAssemblerOracleX86FrameIdentifier(args[0][0]) ||
+		!reflect.DeepEqual(args[1], []string{"4"}) || len(args[2]) < 4 || args[2][0] != "$" {
+		return 0, false
+	}
+	size := args[2][1:]
+	separator := 1
+	if size[0] == "+" || size[0] == "-" {
+		separator++
+	}
+	if len(size) != separator+2 || size[separator] != "-" {
+		return 0, false
+	}
+	frame, frameOK := goAssemblerOracleX86FrameInteger(size[:separator])
+	arguments, argsOK := goAssemblerOracleX86FrameInteger(size[separator+1:])
+	if !frameOK || !argsOK || frame < math.MinInt32 || frame > math.MaxInt32 || arguments < 0 || arguments > math.MaxInt32 {
+		return 0, false
+	}
+	if frame < 0 {
+		frame = 0
+	}
+	return frame, frame%4 == 0
+}
+
+func goAssemblerOracleX86FrameStep(tokens []string) (int64, bool) {
+	opcode, suffix, args, ok := goAssemblerOracleX86Statement(tokens)
+	if !ok || suffix != "" {
+		return 0, false
+	}
+	if opcode == "ADJSP" {
+		if len(args) != 1 || len(args[0]) < 2 || args[0][0] != "$" {
+			return 0, false
+		}
+		step, valid := goAssemblerOracleX86FrameInteger(args[0][1:])
+		return step, valid && step >= math.MinInt32 && step <= math.MaxInt32
+	}
+	var step int64
+	switch opcode {
+	case "PUSHL", "PUSHFL":
+		step = 4
+	case "PUSHW", "PUSHFW":
+		step = 2
+	case "POPL", "POPFL":
+		step = -4
+	case "POPW", "POPFW":
+		step = -2
+	default:
+		return 0, false
+	}
+	if strings.HasSuffix(opcode, "FL") || strings.HasSuffix(opcode, "FW") {
+		return step, len(args) == 0
+	}
+	if len(args) != 1 || len(args[0]) != 1 {
+		return 0, false
+	}
+	switch args[0][0] {
+	case "AX", "BX", "CX", "DX", "BP", "SI", "DI":
+		return step, true
+	}
+	return 0, false
+}
+
+func goAssemblerOracleX86FrameIdentifier(name string) bool {
+	for _, first := range name {
+		return first == '_' || first == '·' || first == '∕' || unicode.IsLetter(first)
+	}
+	return false
+}
+
+func goAssemblerOracleX86FrameOperand(operand []string, delta int64) ([]string, bool, bool) {
+	start := 0
+	if len(operand) != 0 && operand[0] == "$" {
+		start++
+	}
+	open := start + 1
+	for open < len(operand) && operand[open] != "(" {
+		open++
+	}
+	if open+2 >= len(operand) || operand[open+2] != ")" || operand[open+1] != "FP" && operand[open+1] != "SP" {
+		return operand, false, true
+	}
+	// A bare physical (SP) is not NAME_AUTO. Only an original identifier
+	// before the pseudo-base may acquire the independently checked bias.
+	name, valid := goAssemblerOracleX86FrameTokens(operand[start])
+	if !valid || len(name) != 1 || name[0] != operand[start] || !goAssemblerOracleX86FrameIdentifier(name[0]) {
+		return nil, false, false
+	}
+	offset := int64(0)
+	if open > start+1 {
+		offset, valid = goAssemblerOracleX86FrameInteger(operand[start+1 : open])
+		if !valid {
+			return nil, false, false
+		}
+	}
+	tail := operand[open+3:]
+	if len(tail) != 0 {
+		if len(tail) != 5 || tail[0] != "(" || tail[2] != "*" || tail[4] != ")" {
+			return nil, false, false
+		}
+		switch tail[1] {
+		case "AX", "BX", "CX", "DX", "BP", "SI", "DI":
+		default:
+			return nil, false, false
+		}
+		if tail[3] != "1" && tail[3] != "2" && tail[3] != "4" && tail[3] != "8" {
+			return nil, false, false
+		}
+	}
+	if operand[open+1] == "FP" {
+		delta += 4
+	}
+	if delta > 0 && offset > math.MaxInt64-delta || delta < 0 && offset < math.MinInt64-delta {
+		return nil, false, false
+	}
+	offset += delta
+	result := append([]string(nil), operand[:start+1]...)
+	if offset != 0 {
+		sign, digits := "+", strconv.FormatInt(offset, 10)
+		if offset < 0 {
+			sign, digits = "-", strings.TrimPrefix(digits, "-")
+		}
+		result = append(result, sign, digits)
+	}
+	result = append(result, operand[open:]...)
+	return result, true, true
+}
diff --git a/go_assembler_oracle_x86_frame_rebase_test.go b/go_assembler_oracle_x86_frame_rebase_test.go
new file mode 100644
index 000000000..1bbe06cd7
--- /dev/null
+++ b/go_assembler_oracle_x86_frame_rebase_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86FrameDiagnosticFixture(t *testing.T, source string) string {
+	t.Helper()
+	file := filepath.Join(t.TempDir(), "frame.s")
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return file
+}
+
+func TestGoAssemblerOracleX86FrameRebaseCompleteContext(t *testing.T) {
+	for _, test := range []struct {
+		name, source, listing string
+		line                  int
+	}{
+		{"param-zero", "TEXT probe(SB),4,$0-32\nMOVOA a+0(FP),X8\nRET\n", "MOVO a+4(FP),X8", 2},
+		{"param-frame", "TEXT probe(SB),4,$16-32\nMOVOA renamed+8(FP),X8\nRET\n", "MOVO renamed+28(FP),X8", 2},
+		{"param-negative", "TEXT probe(SB),4,$16-32\nMOVOA a-8(FP),X8\nRET\n", "MOVO a+12(FP),X8", 2},
+		{"param-negative-frame", "TEXT probe(SB),4,$-4-32\nMOVOA a+0(FP),X8\nRET\n", "MOVO a+4(FP),X8", 2},
+		{"auto-zero", "TEXT probe(SB),4,$16-32\nMOVOA local-16(SP),X8\nRET\n", "MOVO local(SP),X8", 2},
+		{"auto-bare", "TEXT probe(SB),4,$16-32\nMOVOA tmp(SP),X8\nRET\n", "MOVO tmp+16(SP),X8", 2},
+		{"auto-negative", "TEXT probe(SB),4,$0-32\nMOVOA tmp-16(SP),X8\nRET\n", "MOVO tmp-16(SP),X8", 2},
+		{"store-param", "TEXT probe(SB),4,$16-32\nMOVOA X15,result+8(FP)\nRET\n", "MOVO X15,result+28(FP)", 2},
+		{"store-auto", "TEXT probe(SB),4,$16-32\nMOVOA X15,local-8(SP)\nRET\n", "MOVO X15,local+8(SP)", 2},
+		{"push-long", "TEXT probe(SB),4,$16-32\nPUSHL AX\nMOVOA a+0(FP),X8\nPOPL AX\nRET\n", "MOVO a+24(FP),X8", 3},
+		{"push-word", "TEXT probe(SB),4,$0-32\nPUSHW AX\nMOVOA a+0(FP),X8\nPOPW AX\nRET\n", "MOVO a+6(FP),X8", 3},
+		{"push-flags", "TEXT probe(SB),4,$0-32\nPUSHFL\nMOVOA a+0(FP),X8\nPOPFL\nRET\n", "MOVO a+8(FP),X8", 3},
+		{"adj-positive", "TEXT probe(SB),4,$0-32\nADJSP $8\nMOVOA a+0(FP),X8\nADJSP $-8\nRET\n", "MOVO a+12(FP),X8", 3},
+		{"adj-negative", "TEXT probe(SB),4,$16-32\nADJSP $-8\nMOVOA a+0(FP),X8\nADJSP $8\nRET\n", "MOVO a+12(FP),X8", 3},
+		{"other-alias", "TEXT probe(SB),4,$16-32\nMOVD a+0(FP),X8\nRET\n", "MOVQ a+20(FP),X8", 2},
+		{"address-role", "TEXT probe(SB),4,$16-32\nMOVOA $a+0(FP),X8\nRET\n", "MOVO $a+20(FP),X8", 2},
+		{"index-param", "TEXT probe(SB),4,$16-32\nMOVOA a+0(FP)(SI*2),X8\nRET\n", "MOVO a+20(FP)(SI*2),X8", 2},
+		{"index-auto", "TEXT probe(SB),4,$16-32\nMOVOA tmp-8(SP)(SI*4),X8\nRET\n", "MOVO tmp+8(SP)(SI*4),X8", 2},
+		{"later-text", "TEXT earlier(SB),4,$64-32\nMOVOA a+0(FP),X8\nRET\nTEXT probe(SB),4,$0-32\nMOVOA a+0(FP),X8\nRET\n", "MOVO a+4(FP),X8", 5},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := x86FrameDiagnosticFixture(t, test.source)
+			listing := "asm: asmins: illegal in mode 32: 00000 (" + source + ":" + strconv.Itoa(test.line) + ") " + test.listing + " (24 66)\n"
+			if !goAssemblerOracleX86SourceDiagnostic(source, "386", listing) {
+				t.Errorf("complete original TEXT/stack role did not bind the exact rewritten listing: %s", test.listing)
+			}
+			if goAssemblerOracleX86SourceDiagnostic(source, "amd64", listing) {
+				t.Fatal("mode32 stack rewrite borrowed the AMD64 target")
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleX86FrameRebaseRejectsInventedContext(t *testing.T) {
+	valid := "TEXT probe(SB),4,$16-32\nMOVOA a+0(FP),X8\nRET\n"
+	for _, test := range []struct{ name, source, instruction string }{
+		{"wrong-frame", strings.Replace(valid, "$16-32", "$0-32", 1), "MOVO a+20(FP),X8"},
+		{"wrong-slot", valid, "MOVO b+20(FP),X8"},
+		{"wrong-offset", valid, "MOVO a+19(FP),X8"},
+		{"wrong-register", valid, "MOVO a+20(FP),X9"},
+		{"wrong-role", valid, "MOVO a+20(SP),X8"},
+		{"invented-index", valid, "MOVO a+20(FP)(SI*2),X8"},
+		{"invented-address", valid, "MOVO $a+20(FP),X8"},
+		{"truncated", valid, "MOVO a+20(FP)"},
+		{"missing-text", "MOVOA a+0(FP),X8\nRET\n", "MOVO a+4(FP),X8"},
+		{"unknown-frame", strings.Replace(valid, "$16-32", "$FRAME-32", 1), "MOVO a+20(FP),X8"},
+		{"expression-frame", strings.Replace(valid, "$16-32", "$(8+8)-32", 1), "MOVO a+20(FP),X8"},
+		{"unknown-flags", strings.Replace(valid, ",4,", ",FLAGS,", 1), "MOVO a+20(FP),X8"},
+		{"overflow-frame", strings.Replace(valid, "$16-32", "$2147483648-32", 1), "MOVO a+20(FP),X8"},
+		{"unaligned-frame", strings.Replace(valid, "$16-32", "$15-32", 1), "MOVO a+19(FP),X8"},
+		{"unknown-offset", strings.Replace(valid, "a+0", "a+UNKNOWN", 1), "MOVO a+20(FP),X8"},
+		{"expression-offset", strings.Replace(valid, "a+0", "a+(0+0)", 1), "MOVO a+20(FP),X8"},
+		{"invalid-scale", strings.Replace(valid, "a+0(FP)", "a+0(FP)(SI*3)", 1), "MOVO a+20(FP)(SI*3),X8"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := x86FrameDiagnosticFixture(t, test.source)
+			line := 2
+			if test.name == "missing-text" {
+				line = 1
+			}
+			listing := "asm: asmins: illegal in mode 32: 00000 (" + source + ":" + strconv.Itoa(line) + ") " + test.instruction + " (24 66)\n"
+			if goAssemblerOracleX86SourceDiagnostic(source, "386", listing) {
+				t.Fatal("unbound or changed complete stack role acquired a diagnostic join")
+			}
+		})
+	}
+	for _, prefix := range []string{
+		"JMP after\nafter:\n", "JEQ after\nafter:\n", "CALL helper(SB)\n", "MOVL AX,SP\n",
+		"ADJSP $UNKNOWN\n", "ADJSP $2147483648\n", "PUSHQ AX\n", "#include \"frame.h\"\n",
+		"RET\n", "MOVL $0,SP\n", "LEAL 4(SP),SP\n",
+	} {
+		t.Run("unknown-prefix/"+strings.TrimSpace(prefix), func(t *testing.T) {
+			text := strings.Replace(valid, "MOVOA", prefix+"MOVOA", 1)
+			source := x86FrameDiagnosticFixture(t, text)
+			line := 2 + strings.Count(prefix, "\n")
+			listing := "asm: asmins: illegal in mode 32: 00000 (" + source + ":" + strconv.Itoa(line) + ") MOVO a+20(FP),X8 (24 66)\n"
+			if goAssemblerOracleX86SourceDiagnostic(source, "386", listing) {
+				t.Fatal("unknown flow/CPP/stack delta was guessed as a frame relocation")
+			}
+		})
+	}
+	for _, mutation := range []string{
+		"asm: asmins: illegal in mode 64: ", "asm: invalid instruction: ",
+		"(24 66) extra", "(24 90)", "(024 66)", "(24,66)",
+	} {
+		t.Run("backend-boundary/"+mutation, func(t *testing.T) {
+			source := x86FrameDiagnosticFixture(t, valid)
+			listing := x86Mode32Diagnostic(source, "MOVO a+20(FP),X8", "(24 66)")
+			if strings.HasPrefix(mutation, "asm:") {
+				listing = strings.Replace(listing, "asm: asmins: illegal in mode 32: ", mutation, 1)
+			} else {
+				listing = strings.Replace(listing, "(24 66)", mutation, 1)
+			}
+			if goAssemblerOracleX86SourceDiagnostic(source, "386", listing) {
+				t.Fatal("stack join lost its complete class-tail/backend role")
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_x86_integer_listing_test.go b/go_assembler_oracle_x86_integer_listing_test.go
new file mode 100644
index 000000000..20b923270
--- /dev/null
+++ b/go_assembler_oracle_x86_integer_listing_test.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86IntegerAliasCompleteDiagnostic(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		for _, row := range []struct{ original, printed string }{
+			{"0x0123456789abcdef", "81985529216486895"},
+			{"-0x80000001", "-2147483649"},
+			{"0xffffffffffffffff", "-1"},
+			{"+0xff", "255"},
+		} {
+			source := x86DiagnosticFixture(t, alias+" $"+row.original+",(DI)")
+			output := x86DiagnosticListing(source, "MOVQ $"+row.printed+",(DI)")
+			for _, arch := range []string{"386", "amd64"} {
+				if !goAssemblerOracleX86SourceDiagnostic(source, arch, output) {
+					t.Fatal("complete original alias/integer listing lost its exact source", alias, row, arch)
+				}
+				for _, changed := range []string{"MOVQ $7,(DI)", "MOVQ $" + row.printed + ",(SI)",
+					"MOVQ $(" + row.printed + "),(DI)", "MOVQ $" + row.printed + ",(DI),AX"} {
+					if goAssemblerOracleX86SourceDiagnostic(source, arch, x86DiagnosticListing(source, changed)) {
+						t.Fatal("changed integer/address/cardinality acquired a diagnostic join", changed)
+					}
+				}
+			}
+			if goasmoracle.SourceDiagnosticLine(source, output, 2) ||
+				goAssemblerOracleX86SourceDiagnostic(source, "arm64", output) {
+				t.Fatal("integer alias escaped the selected x86 adapter")
+			}
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_listing_roles_test.go b/go_assembler_oracle_x86_listing_roles_test.go
new file mode 100644
index 000000000..9039c3104
--- /dev/null
+++ b/go_assembler_oracle_x86_listing_roles_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func x86DiagnosticFixture(t *testing.T, statement string) string {
+	t.Helper()
+	source := filepath.Join(t.TempDir(), "forms.s")
+	if err := os.WriteFile(source, []byte("TEXT probe(SB),$0-0\n"+statement+"\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return source
+}
+
+func x86DiagnosticListing(source, listing string) string {
+	return "asm: bad: invalid instruction: 00000 (" + source + ":2)\t" + listing + "\n"
+}
+
+// These fabricated-output joins test the diagnostic adapter, not Go acceptance.
+func TestGoAssemblerOracleX86CompleteAliasListingRoles(t *testing.T) {
+	for alias, canonical := range goAssemblerOracleX86Aliases {
+		t.Run(alias, func(t *testing.T) {
+			for _, arch := range []string{"amd64", "386"} {
+				for _, suffix := range []string{"", ".Z", ".SAE", ".SAE.Z", ".RN_SAE", ".RZ_SAE", ".RD_SAE", ".RU_SAE",
+					".RN_SAE.Z", ".RZ_SAE.Z", ".RD_SAE.Z", ".RU_SAE.Z", ".BCST", ".BCST.Z"} {
+					source := x86DiagnosticFixture(t, alias+suffix+" 8(AX)(CX*2), X1")
+					listing := x86DiagnosticListing(source, canonical+suffix+" 8(AX)(CX*2), X1")
+					if !goAssemblerOracleX86SourceDiagnostic(source, arch, listing) {
+						t.Fatalf("complete alias lost for %s/%s%s", arch, alias, suffix)
+					}
+					if goasmoracle.SourceDiagnosticLine(source, listing, 2) {
+						t.Fatal("default parser acquired a global alias role")
+					}
+					for _, changed := range []string{canonical + suffix + " 8(AX)(CX*2), X2", canonical + " 8(AX)(CX*2), X1, X2", canonical + suffix} {
+						if goAssemblerOracleX86SourceDiagnostic(source, arch, x86DiagnosticListing(source, changed)) {
+							t.Fatalf("changed/truncated complete alias listing acquired a role: %q", changed)
+						}
+					}
+					for _, other := range []string{"", "arm", "arm64", "wasm", "AMD64"} {
+						if goAssemblerOracleX86SourceDiagnostic(source, other, listing) {
+							t.Fatalf("alias acquired unknown/foreign target %q", other)
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleX86CompleteAliasOperandCardinality(t *testing.T) {
+	for alias, canonical := range goAssemblerOracleX86Aliases {
+		t.Run(alias, func(t *testing.T) {
+			for _, suffix := range []string{"", ".Z", ".BCST.Z"} {
+				for _, operands := range []string{"", "AX", "M0,X1", "X0,K1,X1", "X0,X1,K1,X2"} {
+					source := x86DiagnosticFixture(t, strings.TrimSpace(alias+suffix+" "+operands))
+					listing := x86DiagnosticListing(source, strings.TrimSpace(canonical+suffix+" "+operands))
+					for _, arch := range []string{"amd64", "386"} {
+						if !goAssemblerOracleX86SourceDiagnostic(source, arch, listing) {
+							t.Errorf("complete %s alias lost at operand cardinality %q: %s", arch, operands, alias+suffix)
+						}
+						if operands != "" && goAssemblerOracleX86SourceDiagnostic(source, arch,
+							x86DiagnosticListing(source, canonical+suffix)) {
+							t.Fatal("operand-bearing original borrowed a zero-operand listing")
+						}
+						if operands == "" && goAssemblerOracleX86SourceDiagnostic(source, arch,
+							x86DiagnosticListing(source, canonical+suffix+" AX")) {
+							t.Fatal("zero-operand original borrowed an invented operand")
+						}
+					}
+					if goasmoracle.SourceDiagnosticLine(source, listing, 2) {
+						t.Fatal("zero/rest-operand alias escaped into the strict default")
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleX86ScalarZeroCompleteListingRoles(t *testing.T) {
+	for _, opcode := range []string{"MOVSS", "MOVSD", "VMOVSS", "VMOVSD"} {
+		t.Run(opcode, func(t *testing.T) {
+			for _, test := range []struct {
+				name, suffix, operands, listing string
+				want                            bool
+			}{
+				{"two", "", "$0.0,X0", "X0,X0", true},
+				{"three", "", "$0.0,K1,X0", "X0,K1,X0", true},
+				{"four", "", "$0.0,X1,K1,X0", "X0,X1,K1,X0", true},
+				{"suffix", ".Z", "$0.0,X1,K7,X15", "X15,X1,K7,X15", true},
+				{"unary-parentheses", "", "$+(-( -0.0)),K1,X0", "X0,K1,X0", true},
+				{"negative-zero", "", "$-0.0,K1,X0", "X0,K1,X0", false},
+				{"nonzero", "", "$1.0,K1,X0", "X0,K1,X0", false},
+				{"float32-underflow", "", "$1e-50,K1,X0", "X0,K1,X0", false},
+				{"integer-zero", "", "$0,K1,X0", "X0,K1,X0", false},
+				{"invented-float-token", "", "$0 . 0,K1,X0", "X0,K1,X0", false},
+				{"binary-expression", "", "$0.0+0.0,K1,X0", "X0,K1,X0", false},
+				{"high-destination", "", "$0.0,K1,X16", "X16,K1,X16", false},
+				{"noncanonical-register", "", "$0.0,K1,X00", "X00,K1,X00", false},
+				{"memory-destination", "", "$0.0,K1,(AX)", "(AX),K1,(AX)", false},
+				{"changed-mask", "", "$0.0,K1,X0", "X0,K2,X0", false},
+				{"changed-merge", "", "$0.0,X1,K1,X0", "X0,X2,K1,X0", false},
+				{"missing-from", "", "$0.0,K1,X0", "K1,X0", false},
+				{"missing-restarg", "", "$0.0,K1,X0", "X0,X0", false},
+				{"extra-restarg", "", "$0.0,K1,X0", "X0,K1,K2,X0", false},
+				{"wrong-from", "", "$0.0,K1,X0", "X1,K1,X0", false},
+				{"unknown-suffix", ".UNKNOWN", "$0.0,K1,X0", "X0,K1,X0", false},
+				{"misordered-suffix", ".Z.SAE", "$0.0,K1,X0", "X0,K1,X0", false},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					source := x86DiagnosticFixture(t, opcode+test.suffix+" "+test.operands)
+					output := x86DiagnosticListing(source, "XORPS"+test.suffix+" "+test.listing)
+					for _, arch := range []string{"amd64", "386"} {
+						if got := goAssemblerOracleX86SourceDiagnostic(source, arch, output); got != test.want {
+							t.Fatalf("%s scalar source/listing join=%t, want %t", arch, got, test.want)
+						}
+					}
+					if goasmoracle.SourceDiagnosticLine(source, output, 2) ||
+						goAssemblerOracleX86SourceDiagnostic(source, "arm64", output) {
+						t.Fatal("positive-zero rewrite escaped its explicit x86 adapter")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoAssemblerOracleRewrittenListingPreservesSourceBoundary(t *testing.T) {
+	source := x86DiagnosticFixture(t, "PADDD M0,X1")
+	output := x86DiagnosticListing(source, "PADDL M0,X1")
+	for _, control := range []string{
+		strings.Replace(output, "("+source+":2)", "(foreign"+source+":2)", 1),
+		strings.Replace(output, ":2)", ":3)", 1),
+		strings.Replace(output, "00000", "0", 1),
+		strings.Replace(output, "00000", "000000", 1),
+		strings.Replace(output, "asm: bad: invalid instruction: ", "foreign ", 1),
+		"asm: assembly failed\n",
+	} {
+		if goAssemblerOracleX86SourceDiagnostic(source, "amd64", control) {
+			t.Fatalf("rewritten listing bypassed source/PC/backend boundary: %q", control)
+		}
+	}
+	called := false
+	if goasmoracle.SourceDiagnosticLineWithListing(source, output, 3, func(_, _ []string) bool { called = true; return true }) || called {
+		t.Fatal("matcher ran before the exact focus check")
+	}
+	for _, statement := range []string{"", "// PADDD M0,X1", "label:", "label: PADDD M0,X1", "PADDD M0,X1 /*"} {
+		badSource := x86DiagnosticFixture(t, statement)
+		called = false
+		if goasmoracle.SourceDiagnosticLineWithListing(badSource, x86DiagnosticListing(badSource, "PADDL M0,X1"), 2,
+			func(_, _ []string) bool { called = true; return true }) || called {
+			t.Fatalf("matcher received an unbound original statement: %q", statement)
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_listing_test.go b/go_assembler_oracle_x86_listing_test.go
new file mode 100644
index 000000000..ce327d9f5
--- /dev/null
+++ b/go_assembler_oracle_x86_listing_test.go
@@ -0,0 +1,186 @@
+package plan9asm
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+// These 40 nonidentity entries are the complete explicit archX86 aliases.
+// They are diagnostic spellings, never a lowering or ISA-support table.
+var goAssemblerOracleX86Aliases = map[string]string{
+	"JA": "JHI", "JAE": "JCC", "JB": "JCS", "JBE": "JLS", "JC": "JCS",
+	"JE": "JEQ", "JG": "JGT", "JHS": "JCC", "JL": "JLT", "JLO": "JCS",
+	"JNA": "JLS", "JNAE": "JCS", "JNB": "JCC", "JNBE": "JHI", "JNC": "JCC",
+	"JNG": "JLE", "JNGE": "JLT", "JNL": "JGE", "JNLE": "JGT", "JNO": "JOC",
+	"JNP": "JPC", "JNS": "JPL", "JNZ": "JNE", "JO": "JOS", "JP": "JPS",
+	"JPE": "JPS", "JPO": "JPC", "JS": "JMI", "JZ": "JEQ",
+	"MASKMOVDQU": "MASKMOVOU", "MOVD": "MOVQ", "MOVDQ2Q": "MOVQ",
+	"MOVNTDQ": "MOVNTO", "MOVOA": "MOVO", "PSLLDQ": "PSLLO", "PSRLDQ": "PSRLO",
+	"PADDD": "PADDL", "MOVBELL": "MOVBEL", "MOVBEQQ": "MOVBEQ", "MOVBEWW": "MOVBEW",
+}
+
+func goAssemblerOracleX86SourceDiagnostic(source, arch, output string) bool {
+	if arch != "amd64" && arch != "386" {
+		return false
+	}
+	// asmins appends two operand-class numbers after the complete Prog.
+	// Consume that metadata only in its exact backend/mode diagnostic, never
+	// as an arbitrary instruction suffix or an amd64 instruction permission.
+	const mode32 = "asm: asmins: illegal in mode 32: "
+	var ordinary []string
+	for _, line := range strings.Split(output, "\n") {
+		if strings.HasPrefix(line, mode32) {
+			if arch == "386" && goasmoracle.SourceDiagnosticLineWithListing(source, line, 0,
+				func(original, listing []string) bool {
+					return goAssemblerOracleX86Mode32Listing(original, listing) ||
+						goAssemblerOracleX86Mode32FrameListing(source, line, original, listing)
+				}) {
+				return true
+			}
+			continue
+		}
+		ordinary = append(ordinary, line)
+	}
+	return goasmoracle.SourceDiagnosticLineWithListing(source, strings.Join(ordinary, "\n"), 0,
+		func(original, listing []string) bool {
+			return goAssemblerOracleX86Listing(original, listing) ||
+				goAssemblerOracleX86AddressListing(original, listing, arch)
+		})
+}
+
+func goAssemblerOracleX86Mode32Listing(original, listing []string) bool {
+	if len(listing) < 5 {
+		return false
+	}
+	tail := listing[len(listing)-4:]
+	if tail[0] != "(" || tail[3] != ")" {
+		return false
+	}
+	for _, token := range tail[1:3] {
+		class, err := strconv.Atoi(token)
+		// Go's complete Yxxx..Yindir directory is [0,Ymax), not an ISA
+		// acceptance table. The current SDK test checks every directory entry.
+		if err != nil || class < 0 || class >= 90 || strconv.Itoa(class) != token {
+			return false
+		}
+	}
+	instruction := listing[:len(listing)-4]
+	return reflect.DeepEqual(original, instruction) || goAssemblerOracleX86Listing(original, instruction) ||
+		goAssemblerOracleX86AddressListing(original, instruction, "386")
+}
+
+func goAssemblerOracleX86Statement(tokens []string) (opcode, suffix string, args [][]string, ok bool) {
+	if len(tokens) == 0 {
+		return "", "", nil, false
+	}
+	opcode, next := tokens[0], 1
+	for next < len(tokens) && tokens[next] == "." {
+		if next+1 >= len(tokens) {
+			return "", "", nil, false
+		}
+		suffix += "." + tokens[next+1]
+		next += 2
+	}
+	if next == len(tokens) {
+		return opcode, suffix, nil, true
+	}
+	var delimiters []string
+	start := next
+	for i := next; i < len(tokens); i++ {
+		switch tokens[i] {
+		case ";", "\n", ":":
+			return "", "", nil, false
+		case "(", "[":
+			delimiters = append(delimiters, tokens[i])
+		case ")", "]":
+			if len(delimiters) == 0 ||
+				(tokens[i] == ")" && delimiters[len(delimiters)-1] != "(") ||
+				(tokens[i] == "]" && delimiters[len(delimiters)-1] != "[") {
+				return "", "", nil, false
+			}
+			delimiters = delimiters[:len(delimiters)-1]
+		case ",":
+			if len(delimiters) == 0 {
+				if i == start {
+					return "", "", nil, false
+				}
+				args = append(args, tokens[start:i])
+				start = i + 1
+			}
+		}
+	}
+	if len(delimiters) != 0 || start == len(tokens) {
+		return "", "", nil, false
+	}
+	args = append(args, tokens[start:])
+	return opcode, suffix, args, true
+}
+
+func goAssemblerOracleX86Listing(original, listing []string) bool {
+	sourceOp, suffix, args, sourceOK := goAssemblerOracleX86Statement(original)
+	listedOp, listedSuffix, listedArgs, listingOK := goAssemblerOracleX86Statement(listing)
+	if !sourceOK || !listingOK || suffix != listedSuffix || len(args) != len(listedArgs) {
+		return false
+	}
+	switch suffix {
+	case "", ".Z", ".SAE", ".SAE.Z", ".RN_SAE", ".RZ_SAE", ".RD_SAE", ".RU_SAE",
+		".RN_SAE.Z", ".RZ_SAE.Z", ".RD_SAE.Z", ".RU_SAE.Z", ".BCST", ".BCST.Z":
+	default:
+		return false
+	}
+	if canonical, alias := goAssemblerOracleX86Aliases[sourceOp]; alias && canonical == listedOp {
+		for i := range args {
+			if !goAssemblerOracleX86OperandListing(args[i], listedArgs[i]) {
+				return false
+			}
+		}
+		return true
+	}
+	switch sourceOp {
+	case "MOVSS", "MOVSD", "VMOVSS", "VMOVSD":
+	default:
+		return false
+	}
+	if listedOp != "XORPS" || len(args) < 2 || len(args[0]) < 2 || args[0][0] != "$" {
+		return false
+	}
+	// Preserve the original lexical FLOAT leaf. Joining integer/dot tokens
+	// must not invent a FLOAT that Go never read, such as `$0 . 0`.
+	leaves := 0
+	for _, token := range args[0][1:] {
+		switch token {
+		case "+", "-", "(", ")":
+		default:
+			if _, valid := parseGoFloatLiteral(token); !valid {
+				return false
+			}
+			leaves++
+		}
+	}
+	if leaves != 1 {
+		return false
+	}
+	value, valid := parseGoFloatLiteral(strings.Join(args[0][1:], ""))
+	if !valid || math.Float64bits(value) != 0 {
+		return false
+	}
+	destination := args[len(args)-1]
+	if len(destination) != 1 || !strings.HasPrefix(destination[0], "X") {
+		return false
+	}
+	index, err := strconv.Atoi(strings.TrimPrefix(destination[0], "X"))
+	if err != nil || index < 0 || index > 15 || "X"+strconv.Itoa(index) != destination[0] ||
+		!reflect.DeepEqual(destination, listedArgs[0]) {
+		return false
+	}
+	for i := 1; i < len(args); i++ {
+		if !reflect.DeepEqual(args[i], listedArgs[i]) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/go_assembler_oracle_x86_memory_literal_join_test.go b/go_assembler_oracle_x86_memory_literal_join_test.go
new file mode 100644
index 000000000..7ee68893f
--- /dev/null
+++ b/go_assembler_oracle_x86_memory_literal_join_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+func goAssemblerOracleX86IntegerLiteral(tokens []string) (int64, bool) {
+	negative := len(tokens) == 2 && tokens[0] == "-"
+	if len(tokens) == 2 && (tokens[0] == "+" || negative) {
+		tokens = tokens[1:]
+	}
+	if len(tokens) != 1 {
+		return 0, false
+	}
+	value, err := strconv.ParseUint(tokens[0], 0, 64)
+	if negative {
+		value = -value
+	}
+	return int64(value), err == nil
+}
+
+// obj.Addr.writeNameTo renders NAME_NONE literal offsets as signed decimal.
+// Zero is omitted only with a base, not for an absolute/index-only address.
+// This diagnostic join grants no address, frame, instruction or ABI role.
+func goAssemblerOracleX86MemoryLiteralListing(original, listing []string) bool {
+	open := len(original)
+	for index, text := range original {
+		if text == "(" {
+			open = index
+			break
+		}
+	}
+	value, valid := goAssemblerOracleX86IntegerLiteral(original[:open])
+	if !valid {
+		return false
+	}
+	address, base := original[open:], false
+	if len(address) != 0 {
+		if len(address) < 3 || address[1] == "SB" || address[1] == "FP" || address[1] == "SP" {
+			return false // Symbolic and AUTO/PARAM rebasing retain separate observations.
+		}
+		if _, valid := goAssemblerOracleX86AddressRole(address, ""); !valid {
+			return false
+		}
+		base = address[2] == ")"
+		if !base && len(address) != 5 {
+			return false
+		}
+	}
+	var want []string
+	if value != 0 || !base {
+		printed := strconv.FormatInt(value, 10)
+		if strings.HasPrefix(printed, "-") {
+			want, printed = append(want, "-"), strings.TrimPrefix(printed, "-")
+		}
+		want = append(want, printed)
+	}
+	return reflect.DeepEqual(append(want, address...), listing)
+}
diff --git a/go_assembler_oracle_x86_memory_literal_test.go b/go_assembler_oracle_x86_memory_literal_test.go
new file mode 100644
index 000000000..02f989230
--- /dev/null
+++ b/go_assembler_oracle_x86_memory_literal_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86AliasMemoryDisplacementListing(t *testing.T) {
+	// Complete alias directory, literal displacement rendering and both SIB
+	// shapes. These fabricated observations are not instruction acceptance.
+	for alias, canonical := range goAssemblerOracleX86Aliases {
+		t.Run(alias, func(t *testing.T) {
+			for _, displacement := range []struct{ original, printed string }{
+				{"0", ""}, {"+0", ""}, {"-0", ""}, {"0x0", ""},
+				{"0x10", "16"}, {"-0x10", "-16"}, {"017", "15"},
+				{"0xffffffffffffffff", "-1"}, {"0b101", "5"}, {"1_024", "1024"},
+			} {
+				for _, address := range []string{"", "(AX)", "(AX)(CX*2)", "(CX*2)"} {
+					source := x86DiagnosticFixture(t, alias+" "+displacement.original+address+",X1")
+					printed := displacement.printed
+					if printed == "" && (address == "" || address == "(CX*2)") {
+						printed = "0"
+					}
+					instruction := canonical + " " + printed + address + ",X1"
+					for _, arch := range []string{"386", "amd64"} {
+						output := x86DiagnosticListing(source, instruction)
+						if !goAssemblerOracleX86SourceDiagnostic(source, arch, output) {
+							t.Fatal("complete alias and displacement rendering lost its exact source", arch, displacement, address)
+						}
+						if goasmoracle.SourceDiagnosticLine(source, output, 2) {
+							t.Fatal("target-free parser acquired an x86 alias/displacement role")
+						}
+						for _, changed := range []string{
+							canonical + " 7" + address + ",X1",
+							canonical + " " + displacement.printed + "(DX),X1",
+							canonical + " " + displacement.printed + address + ",X2",
+							canonical + " " + displacement.printed + address + ",X1,X2",
+						} {
+							if goAssemblerOracleX86SourceDiagnostic(source, arch, x86DiagnosticListing(source, changed)) {
+								t.Fatal("changed address, value or cardinality borrowed the displacement role", changed)
+							}
+						}
+					}
+					if !goAssemblerOracleX86SourceDiagnostic(source, "386", x86Mode32Diagnostic(source, instruction, "(24 21)")) ||
+						goAssemblerOracleX86SourceDiagnostic(source, "arm64", x86DiagnosticListing(source, instruction)) {
+						t.Fatal("displacement rendering lost its explicit mode/target boundary")
+					}
+				}
+			}
+		})
+	}
+	for _, original := range []string{
+		"0(FP)", "0(SP)", "0(SB)", "local+0(SP)", "value(AX)", "0+0(AX)",
+		"0.0(AX)", "0(UNKNOWN)", "0(AX)(CX*3)", "0(AX)(CX*2)(DX*4)", "$0(AX)",
+	} {
+		source := x86DiagnosticFixture(t, "MOVBEQQ "+original+",BX")
+		for _, arch := range []string{"386", "amd64"} {
+			if goAssemblerOracleX86SourceDiagnostic(source, arch, x86DiagnosticListing(source, "MOVBEQ (AX),BX")) {
+				t.Fatal("literal displacement joined a symbol, expression, pseudo-frame or unknown address", original)
+			}
+		}
+	}
+}
+
+func TestGoAssemblerOracleActualMOVBEAliasMemoryRejections(t *testing.T) {
+	for _, alias := range []string{"MOVBEWW", "MOVBELL", "MOVBEQQ"} {
+		for _, operands := range []string{"0(AX),X0", "X0,0(AX)"} {
+			t.Run(alias+"/"+operands, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "386", "TEXT bad(SB),4,$0-0\n"+alias+" "+operands+"\nRET\n", "", false)
+			})
+		}
+	}
+}
diff --git a/go_assembler_oracle_x86_mode_tail_go127_test.go b/go_assembler_oracle_x86_mode_tail_go127_test.go
new file mode 100644
index 000000000..938ba0156
--- /dev/null
+++ b/go_assembler_oracle_x86_mode_tail_go127_test.go
@@ -0,0 +1,96 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func TestGoAssemblerOracleX86Mode32CompleteActualClassDirectory(t *testing.T) {
+	path := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go")
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, declaration := range file.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST || len(group.Specs) == 0 {
+			continue
+		}
+		first := group.Specs[0].(*ast.ValueSpec)
+		if len(first.Names) != 1 || first.Names[0].Name != "Yxxx" {
+			continue
+		}
+		if len(first.Values) != 1 {
+			t.Fatal("original operand-class initializer changed")
+		}
+		initial, ok := first.Values[0].(*ast.Ident)
+		if !ok || initial.Name != "iota" {
+			t.Fatal("original operand-class ordinal rule changed")
+		}
+		for index, raw := range group.Specs {
+			entry := raw.(*ast.ValueSpec)
+			if len(entry.Names) != 1 || index > 0 && len(entry.Values) != 0 {
+				t.Fatal("original operand-class ordinal overridden")
+			}
+			names = append(names, entry.Names[0].Name)
+		}
+	}
+	if len(names) != 91 || names[len(names)-1] != "Ymax" || names[len(names)-2] != "Yindir" {
+		t.Fatalf("complete actual operand-class directory changed: %v", names)
+	}
+}
+
+func TestGoAssemblerOracleActualX86Mode32ClassTails(t *testing.T) {
+	for _, test := range []struct{ name, instruction string }{
+		{"alias-high-destination", "PADDD X0,X8"},
+		{"alias-high-source", "PADDD X8,X0"},
+		{"alias-high-address", "PADDD 8(R9),X0"},
+		{"scalar-single", "MOVSS $0.0,X8"},
+		{"scalar-double", "MOVSD $0.0,X8"},
+		{"vector-single", "VMOVSS $0.0,X8"},
+		{"vector-double", "VMOVSD $0.0,X8"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := x86DiagnosticFixture(t, test.instruction)
+			object := filepath.Join(filepath.Dir(source), "forms.o")
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, time.Minute)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 || ctx.Err() != nil ||
+				!strings.Contains(string(observed.Stderr), "asmins: illegal in mode 32:") {
+				t.Fatalf("actual mode-32 source refusal absent: %+v %v", observed, err)
+			}
+			additional := func(source, output string) bool {
+				return goAssemblerOracleX86SourceDiagnostic(source, "386", output)
+			}
+			if failure := goasmoracle.CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+				err, ctx.Err(), false, 2, additional); failure != nil {
+				t.Fatalf("actual original class-tail refusal lost: %v\n%s", failure, observed.Stderr)
+			}
+		})
+	}
+}
diff --git a/go_assembler_oracle_x86_mode_tail_test.go b/go_assembler_oracle_x86_mode_tail_test.go
new file mode 100644
index 000000000..ead2c9d14
--- /dev/null
+++ b/go_assembler_oracle_x86_mode_tail_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func x86Mode32Diagnostic(source, listing, classes string) string {
+	return "asm: asmins: illegal in mode 32: 00000 (" + source + ":2) " + listing + " " + classes + "\n"
+}
+
+func TestGoAssemblerOracleX86Mode32ClassTailRoles(t *testing.T) {
+	source := x86DiagnosticFixture(t, "PADDD X0,X8")
+	for class := 0; class < 90; class++ {
+		for _, pair := range []string{fmt.Sprintf("(%d 66)", class), fmt.Sprintf("(64 %d)", class)} {
+			output := x86Mode32Diagnostic(source, "PADDL X0,X8", pair)
+			if !goAssemblerOracleX86SourceDiagnostic(source, "386", output) {
+				t.Errorf("complete class-tail listing lost: %s", pair)
+			}
+			if goasmoracle.SourceDiagnosticLine(source, output, 2) {
+				t.Fatal("default diagnostic parser acquired x86 alias/class-tail authority")
+			}
+		}
+	}
+
+	for _, tail := range []string{
+		"", "(64)", "(64 66 0)", "(64,66)", "(64 66", "64 66)",
+		"(-1 66)", "(90 66)", "(64 90)", "(+64 66)", "(064 66)",
+		"(0x40 66)", "(64 6.6)", "(64 66) extra", "(64 66) (64 66)",
+	} {
+		if goAssemblerOracleX86SourceDiagnostic(source, "386", x86Mode32Diagnostic(source, "PADDL X0,X8", tail)) {
+			t.Errorf("malformed/unknown class tail accepted: %q", tail)
+		}
+	}
+	output := x86Mode32Diagnostic(source, "PADDL X0,X8", "(64 66)")
+	for _, changed := range []string{
+		strings.Replace(output, "illegal in mode 32", "illegal in mode 64", 1),
+		strings.Replace(output, "asmins: illegal in mode 32", "invalid instruction", 1),
+		strings.Replace(output, "(64 66)", "(64 66); NOP", 1),
+		strings.Replace(output, "PADDL X0,X8", "PADDL X0,X9", 1),
+		strings.Replace(output, "PADDL X0,X8", "PADDL X0", 1),
+		strings.Replace(output, "00000", "0", 1),
+		strings.Replace(output, source+":2", source+":3", 1),
+		strings.Replace(output, source+":2", "foreign"+source+":2", 1),
+	} {
+		if goAssemblerOracleX86SourceDiagnostic(source, "386", changed) {
+			t.Errorf("class tail escaped original source/backend boundary: %q", changed)
+		}
+	}
+	for _, arch := range []string{"amd64", "arm", "arm64", "wasm", ""} {
+		if goAssemblerOracleX86SourceDiagnostic(source, arch, output) {
+			t.Errorf("386 mode diagnostic borrowed another architecture: %q", arch)
+		}
+	}
+}
diff --git a/go_assembly_header.go b/go_assembly_header.go
new file mode 100644
index 000000000..ed975d844
--- /dev/null
+++ b/go_assembly_header.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/constant"
+	"go/types"
+)
+
+// GoAssemblyHeader supplies cmd/compile's go_asm.h definitions from the actual
+// selected package declarations and the target's gc layout. As in cmd/compile,
+// float/complex constants, non-struct types, blank fields, and uninstantiated
+// generic types have no definitions. Concrete generic instances and aliases
+// retain their actual layout; a missing package/target/layout is an error.
+func GoAssemblyHeader(pkg GoPackage, goarch string) ([]byte, error) {
+	if pkg.Types == nil || pkg.Types.Scope() == nil {
+		return nil, fmt.Errorf("generated go_asm.h requires actual package types")
+	}
+	sizes := types.SizesFor("gc", goarch)
+	if sizes == nil {
+		return nil, fmt.Errorf("generated go_asm.h: unknown gc target layout %q", goarch)
+	}
+	var out bytes.Buffer
+	fmt.Fprintf(&out, "// generated from selected Go declarations for %s\n", pkg.Types.Path())
+	for _, name := range pkg.Types.Scope().Names() {
+		if name == "_" {
+			continue
+		}
+		switch obj := pkg.Types.Scope().Lookup(name).(type) {
+		case *types.Const:
+			if obj.Val() == nil || obj.Val().Kind() == constant.Unknown {
+				return nil, fmt.Errorf("generated go_asm.h: unknown constant %s", name)
+			}
+			if obj.Val().Kind() == constant.Float || obj.Val().Kind() == constant.Complex {
+				continue
+			}
+			fmt.Fprintf(&out, "#define const_%s %s\n", name, obj.Val().ExactString())
+		case *types.TypeName:
+			st, ok := obj.Type().Underlying().(*types.Struct)
+			if !ok || goTypeHasUnboundTypeParams(obj.Type()) {
+				continue
+			}
+			size := sizes.Sizeof(obj.Type())
+			if size < 0 {
+				return nil, fmt.Errorf("generated go_asm.h: unbound size of %s", name)
+			}
+			fmt.Fprintf(&out, "#define %s__size %d\n", name, size)
+			fields := make([]*types.Var, st.NumFields())
+			for i := range fields {
+				fields[i] = st.Field(i)
+			}
+			for i, offset := range sizes.Offsetsof(fields) {
+				field := fields[i]
+				if field.Name() == "_" {
+					continue
+				}
+				if offset < 0 {
+					return nil, fmt.Errorf("generated go_asm.h: unbound offset of %s.%s", name, field.Name())
+				}
+				fmt.Fprintf(&out, "#define %s_%s %d\n", name, field.Name(), offset)
+			}
+		}
+	}
+	return out.Bytes(), nil
+}
diff --git a/go_assembly_header_go124_test.go b/go_assembly_header_go124_test.go
new file mode 100644
index 000000000..97db9f829
--- /dev/null
+++ b/go_assembly_header_go124_test.go
@@ -0,0 +1,23 @@
+//go:build go1.24
+
+package plan9asm
+
+import "testing"
+
+// Generic aliases became a Go source-language feature in 1.24. The common
+// oracle still runs every supported architecture on Go 1.20; this additional
+// source fixture belongs only to toolchains that actually accept its syntax.
+func TestGoAssemblyHeaderGenericAliasCompileOracle(t *testing.T) {
+	// The module retains Go 1.20 defaults. Go 1.24-1.26's go/types otherwise
+	// defaults to gotypesalias=0 even though their compiler accepts aliases.
+	// This fixture explicitly exercises the source language's alias objects.
+	t.Setenv("GODEBUG", "gotypesalias=1")
+	testGoAssemblyHeaderCompileOracle(t, `package header
+const Huge = 1234567890123456789012345678901234567890
+const Fraction = 1.25
+type Generic[T any] struct { first byte; Value T }
+type GenericAlias[T any] = Generic[T]
+type Concrete = GenericAlias[uint64]
+type Alias = Concrete
+`)
+}
diff --git a/go_assembly_header_test.go b/go_assembly_header_test.go
new file mode 100644
index 000000000..b49f04cc9
--- /dev/null
+++ b/go_assembly_header_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoAssemblyHeaderCompileOracle(t *testing.T) {
+	const source = `package header
+const (
+	Small = 42
+	Large = 18446744073709551615
+	Huge = 1234567890123456789012345678901234567890
+	Truth = true
+	Falsehood = false
+	Quoted = "header\nvalue"
+	Rune = 'é'
+	Fraction = 1.25
+	Imaginary = 1+2i
+	_ = 17
+)
+type embedded struct { byteValue byte; wide uint64 }
+type Mixed struct {
+	first byte
+	_ uint16
+	embedded
+	*Other
+	view []byte
+	text string
+	callback func()
+	last uint64
+}
+type Other struct { value uintptr }
+type Alias = Mixed
+type Named Mixed
+type Array [2]uint64
+type Generic[T any] struct { Value T }
+type Concrete = Generic[uint64]
+type ConcreteNamed Generic[uint64]
+`
+	testGoAssemblyHeaderCompileOracle(t, source)
+}
+
+func testGoAssemblyHeaderCompileOracle(t *testing.T, source string) {
+	t.Helper()
+	pkg := mustGoPackage(t, "oracle/header", source)
+	for _, target := range []struct{ arch, goos string }{
+		{"amd64", "linux"}, {"386", "linux"}, {"arm", "linux"}, {"arm64", "linux"}, {"wasm", "js"},
+	} {
+		t.Run(target.arch, func(t *testing.T) {
+			dir := t.TempDir()
+			goFile := filepath.Join(dir, "header.go")
+			if err := os.WriteFile(goFile, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			goHeader := filepath.Join(dir, "go_asm.h")
+			command := exec.Command("go", "tool", "compile", "-p", pkg.Path, "-asmhdr", goHeader, "-o", filepath.Join(dir, "go.o"), goFile)
+			command.Env = append(os.Environ(), "GOOS="+target.goos, "GOARCH="+target.arch)
+			if out, err := command.CombinedOutput(); err != nil {
+				t.Fatalf("actual Go compile -asmhdr: %v\n%s", err, out)
+			}
+			original, err := os.ReadFile(goHeader)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("actual Go header:\n%s", original)
+			generated, err := GoAssemblyHeader(pkg, target.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			definitions := func(header []byte) map[string]string {
+				out := map[string]string{}
+				for _, line := range strings.Split(string(header), "\n") {
+					fields := strings.Fields(line)
+					if len(fields) >= 3 && fields[0] == "#define" {
+						name := fields[1]
+						out[name] = strings.TrimSpace(strings.TrimPrefix(line, "#define "+name))
+					}
+				}
+				return out
+			}
+			if want, got := definitions(original), definitions(generated); !reflect.DeepEqual(got, want) {
+				t.Fatalf("generated definitions differ from actual Go:\ngot %v\nwant %v", got, want)
+			}
+			// Existence itself is source semantics: eagerly replacing operands
+			// after ignoring this header cannot reproduce these conditionals.
+			conditional := "#include \"go_asm.h\"\n#ifdef const_Huge\n#ifdef Alias__size\n#ifdef Concrete_Value\nGOOD\n#endif\n#endif\n#endif\n" +
+				"#ifdef const_Fraction\nBAD_FLOAT\n#endif\n#ifdef Generic__size\nBAD_GENERIC\n#endif\n#ifdef GenericAlias__size\nBAD_ALIAS\n#endif\n"
+			got, err := PreprocessAssemblySource(conditional, AssemblyPreprocessOptions{
+				FileName: "generated.s", ReadInclude: func(parent, name string) (string, []byte, error) {
+					return name, generated, nil
+				},
+			})
+			if err != nil || strings.TrimSpace(got) != "GOOD" {
+				t.Fatalf("generated header conditional semantics = %q, %v", got, err)
+			}
+		})
+	}
+}
+
+func TestGoAssemblyHeaderMissingContext(t *testing.T) {
+	for _, pkg := range []GoPackage{{}, {Types: nil, Path: "missing"}} {
+		if _, err := GoAssemblyHeader(pkg, "arm64"); err == nil {
+			t.Fatal("missing package types accepted")
+		}
+	}
+	if _, err := GoAssemblyHeader(mustGoPackage(t, "oracle", "package oracle"), "unknown"); err == nil {
+		t.Fatal("unknown target layout accepted")
+	}
+}
diff --git a/go_assembly_listing.go b/go_assembly_listing.go
new file mode 100644
index 000000000..239c7bf32
--- /dev/null
+++ b/go_assembly_listing.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Go's objfile printer emits sixteen three-character byte columns, two spaces,
+// then ASCII. Splitting the whole line into words confuses ASCII such as "A2"
+// with another byte. Keep the original line, including trailing ASCII spaces.
+func goAssemblyListingByteRow(line string) (int, []byte, error) {
+	fail := func() (int, []byte, error) {
+		return 0, nil, fmt.Errorf("invalid Go assembly listing byte columns")
+	}
+	line = strings.TrimLeft(line, "\t ")
+	separator := strings.IndexByte(line, ' ')
+	if separator < 3 || !strings.HasPrefix(line, "0x") {
+		return fail()
+	}
+	offset, err := strconv.ParseUint(line[2:separator], 16, 31)
+	body := line[separator:]
+	if err != nil || len(body) < 51 || body[48:50] != "  " {
+		return fail()
+	}
+	code, ascii := make([]byte, 0, 16), make([]byte, 0, 16)
+	padding := false
+	for index := 0; index < 48; index += 3 {
+		column := body[index : index+3]
+		if column == "   " {
+			padding = true
+			continue
+		}
+		value, err := strconv.ParseUint(column[1:], 16, 8)
+		if padding || column[0] != ' ' || err != nil {
+			return fail()
+		}
+		code = append(code, byte(value))
+		if value < ' ' || value > '~' {
+			value = '.'
+		}
+		ascii = append(ascii, byte(value))
+	}
+	if len(code) == 0 || body[50:] != string(ascii) {
+		return fail()
+	}
+	return int(offset), code, nil
+}
diff --git a/go_assembly_listing_test.go b/go_assembly_listing_test.go
new file mode 100644
index 000000000..2552c414f
--- /dev/null
+++ b/go_assembly_listing_test.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestGoAssemblyListingByteColumns(t *testing.T) {
+	const tail = "  A2 ."
+	row := "\t0x0000 41 32 20 c3" + strings.Repeat("   ", 12) + tail
+	for _, test := range []struct {
+		name, line string
+		offset     int
+		want       []byte
+	}{
+		{"hex ASCII", row, 0, []byte{0x41, 0x32, 0x20, 0xc3}},
+		{"nonzero offset", strings.Replace(row, "0x0000", "0x12340", 1), 0x12340, []byte{0x41, 0x32, 0x20, 0xc3}},
+		{"trailing space", "\t0x0010 20" + strings.Repeat("   ", 15) + "   ", 16, []byte{' '}},
+		{"full row", "\t0x0000" + strings.Repeat(" 41", 16) + "  " + strings.Repeat("A", 16), 0, bytes.Repeat([]byte{'A'}, 16)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			offset, code, err := goAssemblyListingByteRow(test.line)
+			if err != nil || offset != test.offset || !bytes.Equal(code, test.want) {
+				t.Fatalf("offset=%d bytes=%x error=%v", offset, code, err)
+			}
+		})
+	}
+	for _, bad := range []string{
+		"", "\t0x0000 41 32 A2", strings.Replace(row, "0x0000", "bad", 1),
+		strings.Replace(row, " 32", "   ", 1), strings.Replace(row, " 32", " zz", 1),
+		strings.Replace(row, " 32", "032", 1), strings.TrimSuffix(row, tail),
+		strings.TrimSuffix(row, tail) + "  A2 . ", row + "41", strings.Replace(row, "A2", "A3", 1),
+	} {
+		if _, code, err := goAssemblyListingByteRow(bad); err == nil || code != nil {
+			t.Fatalf("malformed byte columns accepted: %q (%x)", bad, code)
+		}
+	}
+}
diff --git a/go_float_literal.go b/go_float_literal.go
new file mode 100644
index 000000000..cb61ad994
--- /dev/null
+++ b/go_float_literal.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+// cmd/asm floatExpr is a FLOAT leaf wrapped in unary +/- or parentheses,
+// not the wider binary constant-expression grammar accepted by our parser.
+func parseGoFloatLiteral(text string) (float64, bool) {
+	var lexer scanner.Scanner
+	lexer.Init(strings.NewReader(text))
+	lexer.Mode = scanner.ScanInts | scanner.ScanFloats
+	valid := true
+	lexer.Error = func(*scanner.Scanner, string) { valid = false }
+	negative, depth := false, 0
+	for next := lexer.Scan(); ; next = lexer.Scan() {
+		switch next {
+		case '+':
+		case '-':
+			negative = !negative
+		case '(':
+			depth++
+		case scanner.Float:
+			value, err := strconv.ParseFloat(lexer.TokenText(), 64)
+			if err != nil {
+				return 0, false
+			}
+			for depth > 0 {
+				if lexer.Scan() != ')' {
+					return 0, false
+				}
+				depth--
+			}
+			if negative {
+				value = -value
+			}
+			return value, valid && lexer.Scan() == scanner.EOF
+		default:
+			return 0, false
+		}
+	}
+}
diff --git a/go_float_literal_test.go b/go_float_literal_test.go
new file mode 100644
index 000000000..575e60d85
--- /dev/null
+++ b/go_float_literal_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"math"
+	"testing"
+)
+
+func TestGoFloatLiteralUnaryAssemblyTokens(t *testing.T) {
+	for _, row := range []struct {
+		text string
+		bits uint64
+	}{
+		{"--0.0", 0}, {"++0.0", 0}, {"+-0.0", 1 << 63},
+		{"-+(0.0)", 1 << 63}, {"(--1.0)", 0x3ff0000000000000},
+		{"++(-1.0)", 0xbff0000000000000}, {"-(+(-0x1p-4))", 0x3fb0000000000000},
+	} {
+		operand, err := parseOperand("$" + row.text)
+		if err != nil || operand.Kind != OpImm || !operand.ImmIsFloat || operand.ImmRaw != "" || uint64(operand.Imm) != row.bits {
+			t.Fatalf("assembly FLOAT tokens %s: %+v / %v", row.text, operand, err)
+		}
+		value, valid := parseGoFloatLiteral(row.text)
+		if !valid || math.Float64bits(value) != row.bits {
+			t.Fatalf("typed FLOAT identity mismatch: %s", row.text)
+		}
+	}
+}
+
+func TestGoFloatLiteralDoesNotAuthorizeOtherConstantClasses(t *testing.T) {
+	for _, text := range []string{"1", "--1", "0x3ff0000000000000", "name", "1.0+2.0", "(1.0/2.0)", "(1.0", "1.0)", "NaN", "Inf", "1e999"} {
+		if _, valid := parseGoFloatLiteral(text); valid {
+			t.Fatalf("nonliteral acquired assembly FLOAT identity: %s", text)
+		}
+	}
+	for _, text := range []string{"1", "0", "0x3ff0000000000000", "(1+2)"} {
+		operand, err := parseOperand("$" + text)
+		if err != nil || operand.ImmIsFloat || operand.ImmRaw != "" {
+			t.Fatalf("integer constant changed class: %s / %+v / %v", text, operand, err)
+		}
+	}
+	for _, arch := range []Arch{ArchARM, ArchARM64, ArchWASM, ArchAMD64} {
+		file, err := Parse(arch, "TEXT f(SB),4,$0-0\nMOVD $--1.0,R0\nRET\n")
+		if err != nil || !file.Funcs[0].Instrs[1].Args[0].ImmIsFloat {
+			t.Fatalf("shared frontend lost FLOAT class on %s: %v", arch, err)
+		}
+		// Parsing is not an opcode, native register or source-frame grant.
+		// Existing architecture validators still own acceptance and effects.
+		for _, text := range []string{"--1", "--(1.0+2.0)", "--(1.0/2.0)", "NaN", "Inf", "1e999", "(1.0", "1.0)"} {
+			file, err := Parse(arch, "TEXT f(SB),4,$0-0\nMOVD $"+text+",R0\nRET\n")
+			if err == nil && file.Funcs[0].Instrs[1].Args[0].ImmIsFloat {
+				t.Fatalf("invalid unary FLOAT grammar acquired a resolved FLOAT on %s: %s", arch, text)
+			}
+		}
+	}
+}
diff --git a/go_funcval_global.go b/go_funcval_global.go
new file mode 100644
index 000000000..af7a701d4
--- /dev/null
+++ b/go_funcval_global.go
@@ -0,0 +1,295 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/types"
+	"reflect"
+	"strings"
+)
+
+// Positions are immutable original-source ordinals, not a register domain or
+// callable ABI. No descriptor byte is added to numerical global spans.
+type goFuncvalReadPlan struct {
+	fingerprint [32]byte
+	reads       map[int]goFuncvalRead
+}
+
+type goFuncvalRead struct {
+	instruction Instr
+	descriptor  bool
+}
+
+func goReadOnlyDeclarationLayout(typ types.Type, sizes types.Sizes) (size int64, spans [][2]int64, shape string, err error) {
+	signature, function := typ.Underlying().(*types.Signature)
+	if !function {
+		return goReadOnlyLayout(typ, sizes)
+	}
+	defer func() {
+		if recover() != nil {
+			size, spans, shape, err = 0, nil, "", goReadOnlyContext("incomplete function-value target layout")
+		}
+	}()
+	size = sizes.Sizeof(typ)
+	if size != sizes.Sizeof(types.Typ[types.Uintptr]) || size != 4 && size != 8 {
+		return 0, nil, "", goReadOnlyContext("function value is not one target word")
+	}
+	qualify := func(pkg *types.Package) string { return pkg.Path() }
+	shape = "funcval:" + types.TypeString(typ, qualify) + "/" + types.TypeString(signature, qualify)
+	if len(shape) > 64<<10 {
+		return 0, nil, "", goReadOnlyContext("function-value type description exceeds its bound")
+	}
+	return size, nil, shape, nil
+}
+
+func (source *goReadOnlyStorage) funcvalGlobalRead(ins Instr, arch string) bool {
+	if source == nil {
+		return false
+	}
+	operand, _, candidate := goReadOnlyOperand(ins, arch)
+	address, valid := x86StaticSBReadAddress(operand, arch)
+	if !candidate || !valid {
+		return false
+	}
+	object := source.object(address.symbol)
+	if object.variable == nil || object.imported {
+		return false
+	}
+	_, function := object.variable.Type().Underlying().(*types.Signature)
+	return function
+}
+
+func (source *goReadOnlyStorage) bindFuncvalReads(file *File, arch string) error {
+	if !goFuncvalObjects(source.objects) {
+		return nil // Numerical-only declarations need no second instruction scan.
+	}
+	word := x86ResultPointerWord(arch)
+	for _, fn := range file.Funcs {
+		wanted := make(map[int]bool)
+		for ordinal, ins := range fn.Instrs {
+			if source.funcvalGlobalRead(ins, arch) {
+				wanted[ordinal] = true
+			}
+		}
+		if len(wanted) == 0 {
+			continue
+		}
+		edges, positions, err := fixedLocalEdges(fn)
+		if err != nil {
+			return goReadOnlyContext("function-value read needs a closed ordinary source CFG: %v", err)
+		}
+		predecessors := make([]int, len(positions))
+		for _, targets := range edges {
+			for _, target := range targets {
+				if target >= 0 && target < len(positions) {
+					predecessors[target]++
+				}
+			}
+		}
+		plan := goFuncvalReadPlan{reads: make(map[int]goFuncvalRead)}
+		for pc, ordinal := range positions {
+			if !wanted[ordinal] {
+				continue
+			}
+			first := fn.Instrs[ordinal]
+			load, valid := x86ScalarStaticLoadProperties(first, arch)
+			address, _ := x86StaticSBReadAddress(load.source, arch)
+			if !valid || load.extension || load.bytes != word || address.offset != 0 || source.object(address.symbol).size != word ||
+				pc+1 >= len(positions) || positions[pc+1] != ordinal+1 || predecessors[pc+1] != 1 ||
+				!reflect.DeepEqual(edges[pc], []int{pc + 1}) {
+				return goReadOnlyContext("function value requires an exact word/code-word read pair")
+			}
+			second := fn.Instrs[ordinal+1]
+			code, known, err := x86ScalarRegisterLoadProperties(second.Op, second, arch)
+			_, _, firstGP := x86ResultGP(load.destination, word, arch)
+			_, _, secondGP := x86ResultGP(code.destination, word, arch)
+			if !known || err != nil || !x86ResultNamedPredicateInstruction(second) || !firstGP || !secondGP ||
+				code.bytes != word || !reflect.DeepEqual(code.source.Mem, MemRef{Base: load.destination}) {
+				return goReadOnlyContext("function value supplies only its exact offset-zero code word")
+			}
+			plan.reads[ordinal] = goFuncvalRead{first, true}
+			plan.reads[ordinal+1] = goFuncvalRead{second, false}
+		}
+		plan.fingerprint, err = x86CallerSourceFingerprint(fn)
+		if err != nil {
+			return err
+		}
+		if source.funcvalReads == nil {
+			source.funcvalReads = make(map[string]goFuncvalReadPlan)
+		}
+		if _, duplicate := source.funcvalReads[fn.Sym]; duplicate {
+			return goReadOnlyContext("duplicate function-value source owner")
+		}
+		source.funcvalReads[fn.Sym] = plan
+	}
+	return nil
+}
+
+func goFuncvalObjects(objects map[string]goReadOnlyObject) bool {
+	for _, object := range objects {
+		if _, function := object.variable.Type().Underlying().(*types.Signature); function {
+			return true
+		}
+	}
+	return false
+}
+
+// Only the callback's outer type supplies its representation. Parameter and
+// result types do not change a Go function value into a native function pointer.
+func goFuncvalCheckConvention(files []*ast.File, typed *types.Package, objects map[string]goReadOnlyObject) error {
+	typesByName := make(map[*types.TypeName]*ast.TypeSpec)
+	docs := make(map[*types.TypeName]*ast.CommentGroup)
+	variableTypes := make(map[*types.Var]ast.Expr)
+	functions := make(map[string]*ast.FuncDecl)
+	for _, file := range files {
+		for _, declaration := range file.Decls {
+			if function, ok := declaration.(*ast.FuncDecl); ok && function.Recv == nil {
+				functions[function.Name.Name] = function
+			}
+			group, ok := declaration.(*ast.GenDecl)
+			if !ok {
+				continue
+			}
+			for _, spec := range group.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					name, _ := typed.Scope().Lookup(spec.Name.Name).(*types.TypeName)
+					typesByName[name], docs[name] = spec, group.Doc
+				case *ast.ValueSpec:
+					for index, identifier := range spec.Names {
+						variable, _ := typed.Scope().Lookup(identifier.Name).(*types.Var)
+						variableTypes[variable] = spec.Type
+						if spec.Type == nil && index < len(spec.Values) {
+							variableTypes[variable] = spec.Values[index]
+						}
+					}
+				}
+			}
+		}
+	}
+	var check func(*types.TypeName, ast.Expr, int) error
+	check = func(name *types.TypeName, expr ast.Expr, depth int) error {
+		if depth > 64 {
+			return goReadOnlyContext("function-value type source exceeds its bound")
+		}
+		for {
+			parentheses, ok := expr.(*ast.ParenExpr)
+			if !ok {
+				break
+			}
+			expr = parentheses.X
+		}
+		switch expr := expr.(type) {
+		case nil:
+			if name == nil {
+				return goReadOnlyContext("function representation has no closed source type")
+			}
+		case *ast.Ident:
+			if referenced, ok := typed.Scope().Lookup(expr.Name).(*types.TypeName); ok {
+				name = referenced
+			} else if name == nil && (functions[expr.Name] == nil || functions[expr.Name].Body == nil) {
+				return goReadOnlyContext("inferred function representation needs its actual Go type source")
+			}
+		case *ast.SelectorExpr:
+			return goReadOnlyContext("imported function convention needs its actual source owner")
+		case *ast.CallExpr:
+			if identifier, ok := expr.Fun.(*ast.Ident); ok {
+				if converted, ok := typed.Scope().Lookup(identifier.Name).(*types.TypeName); ok {
+					return check(converted, nil, depth+1)
+				}
+				function := functions[identifier.Name]
+				if function != nil && function.Body != nil && function.Type.Results != nil && len(function.Type.Results.List) == 1 {
+					if _, ordinary := function.Type.Results.List[0].Type.(*ast.FuncType); ordinary {
+						return nil
+					}
+				}
+			}
+			return goReadOnlyContext("inferred call result needs an explicit ordinary Go function type")
+		}
+		if name == nil {
+			return nil
+		}
+		spec := typesByName[name]
+		if name.Pkg() != typed || spec == nil {
+			return goReadOnlyContext("function-value type needs its actual local Go convention source")
+		}
+		for _, doc := range []*ast.CommentGroup{docs[name], spec.Doc} {
+			if doc == nil {
+				continue
+			}
+			for _, comment := range doc.List {
+				text := comment.Text
+				switch {
+				case strings.HasPrefix(text, "//llgo:"):
+					text = strings.TrimPrefix(text, "//llgo:")
+				case strings.HasPrefix(text, "// llgo:"):
+					text = strings.TrimPrefix(text, "// llgo:")
+				default:
+					continue
+				}
+				words := strings.Fields(text)
+				if len(words) != 0 && (words[0] == "cdecl" || words[0] == "stdcall" ||
+					words[0] == "type" && len(words) > 1 && (words[1] == "C" || words[1] == "stdcall")) {
+					return goReadOnlyContext("native function type is not Go descriptor storage")
+				}
+			}
+		}
+		// Following only an outer type reference preserves Go1.20 aliases,
+		// without walking a callback's unrelated parameter/result types.
+		return check(nil, spec.Type, depth+1)
+	}
+	for name := range objects {
+		variable := typed.Scope().Lookup(name).(*types.Var)
+		if _, function := variable.Type().Underlying().(*types.Signature); function {
+			var name *types.TypeName
+			// Obj is shared by Named and newer Alias types, without needing
+			// a newer SDK API in the Go1.20 translator build.
+			if named, ok := variable.Type().(interface{ Obj() *types.TypeName }); ok {
+				name = named.Obj()
+			}
+			if err := check(name, variableTypes[variable], 0); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// Called once at the existing whole-function audit entry, not per instruction.
+func (source *goReadOnlyStorage) funcvalReadsFor(fn Func) (map[int]goFuncvalRead, error) {
+	if source == nil {
+		return nil, nil
+	}
+	plan, known := source.funcvalReads[fn.Sym]
+	if !known {
+		return nil, nil
+	}
+	actual, err := x86CallerSourceFingerprint(fn)
+	if err != nil || actual != plan.fingerprint || fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil {
+		return nil, goReadOnlyContext("function-value source/CFG owner changed before consumption")
+	}
+	return plan.reads, nil
+}
+
+func goFuncvalReadTransfer(reads map[int]goFuncvalRead, ordinal int, ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	read, known := reads[ordinal]
+	if !known {
+		return false, false
+	}
+	if !reflect.DeepEqual(ins, read.instruction) {
+		return false, true
+	}
+	index, _, valid := x86ResultGP(ins.Args[1].Reg, x86ResultPointerWord(arch), arch)
+	if !valid {
+		return false, true
+	}
+	state.gp[index], state.canonicalGP[index] = 0, 0
+	state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = false, false, 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	if state.boolFrameGP != nil {
+		state.boolFrameGP[index] = x86ResultSlotAddress{}
+	}
+	if !read.descriptor {
+		state.gp[index] = 0xff // The code word, never the descriptor/environment or a callable ABI.
+	}
+	return true, true
+}
diff --git a/go_funcval_global_runtime_unix_test.go b/go_funcval_global_runtime_unix_test.go
new file mode 100644
index 000000000..369321979
--- /dev/null
+++ b/go_funcval_global_runtime_unix_test.go
@@ -0,0 +1,105 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoModuleFunctionValueCodeWord(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	// A caller-selected, version-checked C compiler may carry an explicitly
+	// observed SDK selection. Otherwise retain the shared native SDK reader.
+	if compiler := os.Getenv("CC"); compiler != "" {
+		version, err := llvm22ToolOutput(compiler, "--version")
+		if err != nil || !llvm22ToolVersionRE.Match(version) {
+			t.Fatal("configured portable C compiler must be LLVM22", err)
+		}
+		execution.compiler = []string{compiler, "-target", execution.triple}
+	}
+	arch, move := "amd64", "MOVQ"
+	if strconv.IntSize == 32 {
+		arch, move = "386", "MOVL"
+	}
+	assembly := string(goFuncvalGlobalSource(arch, move+" ·callback(SB),DI\n"+move+" (DI),AX"))
+	dead := string(goFuncvalGlobalSource(arch, move+" ·callback(SB),DI\n"+move+" (DI),AX\n"+move+" $7,AX"))
+	assembly += strings.ReplaceAll(dead, "view", "dead")
+	declarations := goFuncvalGlobalDeclarations("var callback func(uintptr) uintptr") + "func dead() uintptr\n"
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	driver := fmt.Sprintf(`
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+extern uintptr_t view(void) __asm__("%[1]sordinaryglobals.view");
+extern uintptr_t dead(void) __asm__("%[1]sordinaryglobals.dead");
+uintptr_t *callback __asm__("%[1]sordinaryglobals.callback");
+static void target0(void) {}
+static void target1(void) {}
+static void target2(void) {}
+static int null_fault(uintptr_t (*run)(void)) {
+    pid_t child = fork();
+    if (child < 0) return 1;
+    if (child == 0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        alarm(5);
+        callback = 0;
+        (void)run();
+        _exit(121);
+    }
+    int status = 0;
+    if (waitpid(child, &status, 0) != child) return 2;
+    return !WIFSIGNALED(status) || (WTERMSIG(status) != SIGSEGV && WTERMSIG(status) != SIGBUS);
+}
+int main(void) {
+    uintptr_t headers[3][2] = {
+        {(uintptr_t)target0, 0}, {(uintptr_t)target1, 123}, {(uintptr_t)target2, UINTPTR_MAX}
+    };
+    for (unsigned i = 0; i < 3; ++i) {
+        callback = headers[i];
+        if (view() != headers[i][0] || dead() != 7) return 3;
+        headers[i][1] ^= UINTPTR_MAX;
+        if (view() != headers[i][0]) return 4;
+    }
+    if (null_fault(view) || null_fault(dead)) return 5;
+    return 0;
+}
+`, prefix)
+	for _, api := range []string{"GoModule", "GoModuleInContext"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, declarations)
+			pkg.Path = "ordinaryglobals"
+			ir, err := goFuncvalGlobalRequest(t, pkg, []byte(assembly), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				if strings.Count(text, "load volatile ") != 4 {
+					t.Fatal("mutable/nil/dead-result reads disappeared", text)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, execution.llc, execution.compiler,
+							"go-funcval-code-word", execution.triple, text, driver, nil, level)
+					})
+				}
+			}
+		})
+	}
+	t.Log("8 actual-host portable C executions, 72 code-word/value checks and 16 nil-fault signals; not original Go/native-x86 execution or callable ABI proof")
+}
diff --git a/go_funcval_global_test.go b/go_funcval_global_test.go
new file mode 100644
index 000000000..0559c074f
--- /dev/null
+++ b/go_funcval_global_test.go
@@ -0,0 +1,474 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+var goFuncvalGlobalCases = []struct{ name, declaration string }{
+	{"static", "var callback = target"},
+	{"named", "type Callback func(uintptr) uintptr\nvar callback Callback = target"},
+	{"mutable", "var callback = target\nfunc replace(f func(uintptr) uintptr) { callback = f }"},
+	{"captured", "var callback = capture(7)\nfunc capture(n uintptr) func(uintptr) uintptr { return func(x uintptr) uintptr { return x+n } }"},
+	{"nil-is-not-proven-nonnull", "var callback func(uintptr) uintptr"},
+}
+
+func goFuncvalGlobalDeclarations(declaration string) string {
+	return "package ordinaryglobals\nfunc target(x uintptr) uintptr { return x+1 }\n" +
+		declaration + "\nfunc view() uintptr\n"
+}
+
+func goFuncvalGlobalSource(arch, body string) []byte {
+	word, move, extract := 8, "MOVQ", "PEXTRQ"
+	if arch == "386" {
+		word, move, extract = 4, "MOVL", "PEXTRD"
+	}
+	// The exact two source loads stay independent of this identity bit view.
+	// The latter makes the complete ordinary input audit observable, including
+	// when testing a malformed source whose value would otherwise be unused.
+	return []byte(fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\n%s AX,X0\n%s $0,X0,AX\n%s AX,ret+0(FP)\nRET\n",
+		word, body, move, extract, move))
+}
+
+func goFuncvalGlobalRequest(t *testing.T, pkg GoPackage, source []byte, arch, triple, api string) (string, error) {
+	t.Helper()
+	if api == "GoModule" {
+		return ordinaryGlobalReadRequest(t, pkg, source, arch, triple, "public")
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translated, err := TranslateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+		GOOS: "linux", GOARCH: arch, Sizes: types.SizesFor("gc", arch),
+		TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path),
+	})
+	if translated == nil {
+		return "", err
+	}
+	defer translated.Module.Dispose()
+	return translated.Module.String(), err
+}
+
+func TestGoModuleFunctionValueCodeWordOriginalGo(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move := "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range goFuncvalGlobalCases {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				dir := t.TempDir()
+				declarations := goFuncvalGlobalDeclarations(row.declaration)
+				declarations = strings.Replace(declarations, "package ordinaryglobals\n", "package ordinaryglobals\nimport \"unsafe\"\n", 1)
+				// The actual compiler, rather than go/types or translator
+				// metadata, must agree that function storage is one native word.
+				declarations += "var _ [unsafe.Sizeof(callback)-unsafe.Sizeof(uintptr(0))]byte\n" +
+					"var _ [unsafe.Sizeof(uintptr(0))-unsafe.Sizeof(callback)]byte\n"
+				assembly := goFuncvalGlobalSource(arch, move+" ·callback(SB),DI\n"+move+" (DI),AX")
+				for name, data := range map[string][]byte{
+					"go.mod":   []byte("module " + ordinaryGlobalReadPackage + "\n\ngo 1.20\n"),
+					"value.go": []byte(declarations), "value_" + arch + ".s": assembly,
+				} {
+					if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				archive := filepath.Join(t.TempDir(), "original.a")
+				env := append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0",
+					"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+				output, err := goasmcmd.Run(ctx, dir, env, filepath.Join(runtime.GOROOT(), "bin/go"),
+					"build", "-p=1", "-o", archive, ".")
+				if err != nil {
+					t.Fatalf("actual Go source/variable/assembly compilation: %v\n%s", err, output)
+				}
+				if info, err := os.Stat(archive); err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+					t.Fatal("actual Go produced no complete package archive", err)
+				}
+				t.Log("complete original Go package archive; no runtime execution claimed")
+			})
+		}
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordReads(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple, word := "MOVQ", "x86_64-unknown-linux-gnu", 8
+		if arch == "386" {
+			move, triple, word = "MOVL", "i386-unknown-linux-gnu", 4
+		}
+		for _, row := range goFuncvalGlobalCases {
+			for _, api := range []string{"GoModule", "GoModuleInContext"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage, goFuncvalGlobalDeclarations(row.declaration))
+					assembly := goFuncvalGlobalSource(arch, move+" ·callback(SB),DI\n"+move+" (DI),AX")
+					ir, err := goFuncvalGlobalRequest(t, pkg, assembly, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("exact typed Go-funcval code-word extraction: output=%t err=%v", ir != "", err)
+					}
+					if strings.Count(ir, "load volatile ") != 2 ||
+						!strings.Contains(ir, fmt.Sprintf("load volatile i%d,", word*8)) {
+						t.Fatalf("mutable global/code-word read or nil fault was folded/widened:\n%s", ir)
+					}
+					compileLLVMToObject(t, llc, triple, "funcval-code-word.ll", "funcval-code-word.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordDoesNotGrantStorage(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"pointer", "var callback *byte", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"},
+		{"header", "var callback []byte", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"},
+		{"function-symbol", "func callback() {}", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"},
+		{"descriptor-is-not-NUM", "var callback func()", "MOVQ ·callback(SB),AX"},
+		{"global-offset", "var callback func()", "MOVQ ·callback+1(SB),DI\nMOVQ (DI),AX"},
+		{"partial-global", "var callback func()", "MOVL ·callback(SB),DI\nMOVQ (DI),AX"},
+		{"partial-code-word", "var callback func()", "MOVQ ·callback(SB),DI\nMOVB (DI),AX"},
+		{"environment-is-not-storage", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ 8(DI),AX"},
+		{"index-is-not-proved", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ (DI)(SI*1),AX"},
+		{"unknown-overwrite", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ SI,DI\nMOVQ (DI),AX"},
+		{"partial-alias-overwrite", "var callback func()", "MOVQ ·callback(SB),DI\nMOVB AL,DI\nMOVQ (DI),AX"},
+		{"label-before-code", "var callback func()", "MOVQ ·callback(SB),DI\ncode:\nMOVQ (DI),AX"},
+		{"alternate-label-entry", "var callback func()", "MOVL $0,CX\nCMPL CX,$0\nJE code\nMOVQ ·callback(SB),DI\ncode:\nMOVQ (DI),AX"},
+		{"numeric-PC-entry", "var callback func()", "MOVL $0,CX\nCMPL CX,$0\nJE 2(PC)\nMOVQ ·callback(SB),DI\nMOVQ (DI),AX"},
+		{"dead-unpaired-value", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ $7,AX"},
+		{"descriptor-stays-opaque", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX\nMOVQ DI,AX"},
+		{"no-global-store", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX\nMOVQ AX,·callback(SB)"},
+		{"no-environment-read", "var callback func()", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX\nMOVQ 8(DI),AX"},
+	} {
+		for _, api := range []string{"GoModule", "GoModuleInContext"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+row.declaration+"\nfunc view() uintptr\n")
+				ir, err := goFuncvalGlobalRequest(t, pkg, goFuncvalGlobalSource("amd64", row.body),
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("descriptor read lent a different storage/input role: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordNeedsSourceOwner(t *testing.T) {
+	source := goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX")
+	declaration := "package ordinaryglobals\nvar callback func()\nfunc view() uintptr\n"
+	for _, mutation := range []string{"missing-types", "missing-syntax", "wrong-type", "wrong-package"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, declaration)
+			switch mutation {
+			case "missing-types":
+				pkg.Types = nil
+			case "missing-syntax":
+				pkg.Syntax = nil
+			case "wrong-type":
+				pkg.Syntax = mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\nvar callback *byte\nfunc view() uintptr\n").Syntax
+			case "wrong-package":
+				pkg.Syntax[0].Name.Name = "different"
+			}
+			ir, err := goFuncvalGlobalRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "GoModule")
+			if mutation == "missing-types" {
+				if ir != "" || err == nil || !strings.Contains(err.Error(), "missing types") {
+					t.Fatal("missing actual type declaration was accepted", err, ir)
+				}
+			} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound descriptor source: output=%t err=%v", ir != "", err)
+			}
+		})
+	}
+	for _, api := range []string{"text", "module"} {
+		t.Run("raw-"+api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, declaration)
+			ir, err := x86ScalarFPBitViewPackageAPI(t, string(source), pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("raw API borrowed typed global declaration: output=%t err=%v", ir != "", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordRequiresGoConvention(t *testing.T) {
+	var directives []string
+	for _, prefix := range []string{"//llgo:", "// llgo:"} {
+		for _, padding := range []string{"", " ", "\t"} {
+			for _, marker := range []string{"cdecl", "stdcall", "type C", "type stdcall"} {
+				directives = append(directives, prefix+padding+marker)
+			}
+		}
+	}
+	for _, directive := range directives {
+		for _, alias := range []bool{false, true} {
+			for _, api := range []string{"GoModule", "GoModuleInContext"} {
+				t.Run(fmt.Sprintf("%s/alias=%t/%s", directive, alias, api), func(t *testing.T) {
+					typeName := "Native"
+					declarations := directive + "\ntype Native func()\n"
+					if alias {
+						declarations += "type Alias = Native\n"
+						typeName = "Alias"
+					}
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+						"package ordinaryglobals\n"+declarations+"var callback "+typeName+"\nfunc view() uintptr\n")
+					ir, err := goFuncvalGlobalRequest(t, pkg,
+						goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"),
+						"amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("native function type inherited Go descriptor layout: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+	for _, comment := range []string{"//   llgo:cdecl", "//\tllgo:stdcall", "/*llgo:cdecl*/", "//llgointernal:cdecl"} {
+		t.Run("inactive-comment/"+comment, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+				"package ordinaryglobals\n"+comment+"\ntype Callback func()\nvar callback Callback\nfunc view() uintptr\n")
+			ir, err := goFuncvalGlobalRequest(t, pkg,
+				goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"),
+				"amd64", "x86_64-unknown-linux-gnu", "GoModule")
+			if err != nil || ir == "" {
+				t.Fatal("inactive comment was mistaken for a native type directive", err)
+			}
+		})
+	}
+	for _, origin := range []string{"call", "variable"} {
+		t.Run("erased-alias/"+origin, func(t *testing.T) {
+			declarations := "package ordinaryglobals\n//llgo:cdecl\ntype Native = func()\n" +
+				"var other Native\nfunc acquire() Native { return nil }\n"
+			initializer := "acquire()"
+			if origin == "variable" {
+				initializer = "other"
+			}
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, declarations+"var callback = "+initializer+"\nfunc view() uintptr\n")
+			ir, err := goFuncvalGlobalRequest(t, pkg,
+				goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"),
+				"amd64", "x86_64-unknown-linux-gnu", "GoModule")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("erased native alias acquired Go representation: output=%t err=%v", ir != "", err)
+			}
+		})
+	}
+	t.Run("ordinary-Go-alias", func(t *testing.T) {
+		pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+			"package ordinaryglobals\ntype Callback = func()\nvar callback Callback\nfunc view() uintptr\n")
+		ir, err := goFuncvalGlobalRequest(t, pkg,
+			goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"),
+			"amd64", "x86_64-unknown-linux-gnu", "GoModule")
+		if err != nil || ir == "" {
+			t.Fatal("ordinary Go alias lost its source convention", err)
+		}
+	})
+}
+
+func TestGoModuleFunctionValueCodeWordBindingRevocation(t *testing.T) {
+	for _, mutation := range []string{"operand", "alias", "label", "owner", "syntax", "resolver"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+				goFuncvalGlobalDeclarations("var callback = target"))
+			assembly := goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX")
+			file, err := Parse(ArchAMD64, string(assembly))
+			if err != nil {
+				t.Fatal(err)
+			}
+			changed := false
+			resolve := func(symbol string) string {
+				if changed && strings.Contains(symbol, "callback") {
+					return "different.callback"
+				}
+				return testResolveSym(pkg.Path)(symbol)
+			}
+			binding, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", "amd64"), "amd64", resolve)
+			if err != nil || binding == nil || binding.verify() != nil {
+				t.Fatal("valid independent source owner did not bind", err)
+			}
+			fn := x86DirectTailSnapshot(file).Funcs[0]
+			reads, err := binding.funcvalReadsFor(fn)
+			if err != nil || len(reads) != 2 || binding.readFor(fn.Instrs[0], "amd64") != nil {
+				t.Fatal("pair absent or descriptor acquired numerical spans", err)
+			}
+			sig, err := DeriveGoFuncABI0Signature(fn.Sym, pkg.Types.Scope().Lookup("view").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("paired codegen fact leaked into public source query", err)
+			}
+			switch mutation {
+			case "operand":
+				fn.Instrs[1].Args[0].Mem.Off = 8
+			case "alias":
+				fn.Instrs[1].Args[1].Reg = "BX"
+			case "label":
+				fn.Instrs = append(fn.Instrs, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: "other"}}})
+			case "owner":
+				fn.Sym = "other"
+			case "syntax":
+				pkg.Syntax[0].Name.Name = "changed"
+			case "resolver":
+				changed = true
+			}
+			if mutation == "syntax" || mutation == "resolver" {
+				if err := binding.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed source owner retained its binding", err)
+				}
+			} else if reads, err := binding.funcvalReadsFor(fn); mutation == "owner" {
+				if err != nil || len(reads) != 0 {
+					t.Fatal("another function inherited source roles", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed instruction/CFG retained pair roles", err)
+			}
+		})
+	}
+	t.Run("convention-association", func(t *testing.T) {
+		pkg := mustGoPackage(t, ordinaryGlobalReadPackage, `package ordinaryglobals
+//llgo:cdecl
+type Other func()
+type Callback func()
+var callback Callback
+func view() uintptr
+`)
+		file, err := Parse(ArchAMD64, string(goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX")))
+		if err != nil {
+			t.Fatal(err)
+		}
+		binding, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", "amd64"), "amd64", testResolveSym(pkg.Path))
+		if err != nil || binding == nil || binding.verify() != nil {
+			t.Fatal("ordinary Go representation did not bind", err)
+		}
+		first := pkg.Syntax[0].Decls[0].(*ast.GenDecl)
+		second := pkg.Syntax[0].Decls[1].(*ast.GenDecl)
+		first.Doc, second.Doc = second.Doc, first.Doc
+		if err := binding.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed convention association retained Go descriptor permission", err)
+		}
+	})
+}
+
+func TestGoModuleFunctionValueCodeWordImportedTypeAndNestedBoundary(t *testing.T) {
+	for _, alias := range []string{"", " ="} {
+		for _, nested := range []bool{false, true} {
+			t.Run(fmt.Sprintf("alias=%t/nested=%t", alias != "", nested), func(t *testing.T) {
+				dependency := importedGlobalPackage(t, "example.com/callbacktypes", "amd64",
+					[]string{"package callbacktypes\n//llgo:cdecl\ntype Callback" + alias + " func()\n"}, nil)
+				typ := "dep.Callback"
+				if nested {
+					typ = "func(dep.Callback) dep.Callback"
+				}
+				pkg := importedGlobalPackage(t, ordinaryGlobalReadPackage, "amd64",
+					[]string{"package ordinaryglobals\nimport dep \"example.com/callbacktypes\"\nvar callback " + typ + "\nfunc view() uintptr\n"},
+					map[string]*types.Package{dependency.Path: dependency.Types})
+				ir, err := goFuncvalGlobalRequest(t, pkg,
+					goFuncvalGlobalSource("amd64", "MOVQ ·callback(SB),DI\nMOVQ (DI),AX"),
+					"amd64", "x86_64-unknown-linux-gnu", "GoModule")
+				if nested {
+					if err != nil || ir == "" {
+						t.Fatal("nested callback parameter changed the outer Go representation", err)
+					}
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unobserved imported function convention accepted: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordRevokesAdjacentAddressBits(t *testing.T) {
+	const declarations = `package ordinaryglobals
+var callback func()
+func view(dst, src *byte) uintptr
+`
+	const source = `TEXT ·view(SB),4,$0-24
+MOVQ dst+0(FP),BX
+MOVQ src+8(FP),SI
+LEAL 1(SI),DI
+MOVQ ·callback(SB),DI
+MOVQ (DI),AX
+MOVL DI,(BX)
+MOVQ AX,X0
+PEXTRQ $0,X0,AX
+MOVQ AX,ret+16(FP)
+RET
+`
+	for _, api := range []string{"GoModule", "GoModuleInContext"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, declarations)
+			ir, err := goFuncvalGlobalRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("overwritten descriptor borrowed earlier LEA address bits: output=%t err=%v", ir != "", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordDoesNotGrantCalls(t *testing.T) {
+	for _, result := range []bool{false, true} {
+		for _, opcode := range []string{"CALL", "JMP"} {
+			for _, api := range []string{"GoModule", "GoModuleInContext"} {
+				t.Run(fmt.Sprintf("result=%t/%s/%s", result, opcode, api), func(t *testing.T) {
+					declaration, frame, tail := "func view()", 0, "RET\n"
+					if result {
+						declaration, frame, tail = "func view() uintptr", 8, "MOVQ AX,ret+0(FP)\nRET\n"
+					}
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+						"package ordinaryglobals\nvar callback func()\n"+declaration+"\n")
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVQ ·callback(SB),DI\nMOVQ (DI),AX\n"+
+						"MOVQ $1,DI\nMOVQ $2,SI\nMOVQ $3,DX\nMOVQ $4,CX\nMOVQ $5,R8\nMOVQ $6,R9\n%s AX\n%s", frame, opcode, tail)
+					ir, err := goFuncvalGlobalRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("code word acquired guessed indirect ABI: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoModuleFunctionValueCodeWordRejectsConflictingWordLayout(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, api := range []string{"GoModule", "GoModuleInContext"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				word, move, result, triple := int64(4), "MOVQ", "uint64", "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					word, move, result, triple = 8, "MOVL", "uint32", "i386-unknown-linux-gnu"
+				}
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\nvar callback func()\nfunc view() "+result+"\n")
+				options := GoModuleOptions{GOOS: "linux", GOARCH: arch, TargetTriple: triple,
+					Sizes: &types.StdSizes{WordSize: word, MaxAlign: word}, ResolveSym: testResolveSym(pkg.Path)}
+				source := goFuncvalGlobalSource(arch, move+" ·callback(SB),DI\n"+move+" (DI),AX")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				var translated *GoModuleTranslation
+				var err error
+				if api == "GoModule" {
+					translated, err = TranslateGoModule(pkg, source, options)
+				} else {
+					translated, err = TranslateGoModuleInContext(ctx, pkg, source, options)
+				}
+				if translated != nil {
+					defer translated.Module.Dispose()
+				}
+				if translated != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("partial/oversized descriptor layout accepted: output=%t err=%v", translated != nil, err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_imported_global_read_execution_test.go b/go_imported_global_read_execution_test.go
new file mode 100644
index 000000000..aa1a1da35
--- /dev/null
+++ b/go_imported_global_read_execution_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const importedCompareOwner = "example.com/globalconsumer/state"
+
+type importedCompareCase struct {
+	bits int
+	form string
+}
+
+func importedCompareCases(arch string) []importedCompareCase {
+	var rows []importedCompareCase
+	for _, bits := range []int{8, 16, 32, 64} {
+		if arch == "386" && bits == 64 {
+			continue
+		}
+		for _, form := range []string{"memory-register", "register-memory", "memory-immediate"} {
+			rows = append(rows, importedCompareCase{bits: bits, form: form})
+		}
+	}
+	return rows
+}
+
+// Exercise every scalar comparison width and memory operand position. The
+// unaligned address is an actual imported declaration, not emitted DATA or an
+// SDK capability. Existing scalar-family tests separately observe every flag.
+func importedCompareSource(arch string) (assembly, declarations string) {
+	var source, decls strings.Builder
+	for index, row := range importedCompareCases(arch) {
+		name := fmt.Sprintf("compare%d", index)
+		fmt.Fprintf(&decls, "func %s() uint32\n", name)
+		address := importedGlobalOperand(importedCompareOwner, "Words", 1)
+		args := address + ",AX"
+		switch row.form {
+		case "register-memory":
+			args = "AX," + address
+		case "memory-immediate":
+			args = address + ",$42"
+		}
+		op := map[int]string{8: "CMPB", 16: "CMPW", 32: "CMPL", 64: "CMPQ"}[row.bits]
+		body := ordinaryGlobalReadAssembly("MOVL $42,AX\n", op+" "+args+"\n")
+		source.WriteString(strings.Replace(string(body), "·view", "·"+name, 1))
+	}
+	return source.String(), decls.String()
+}
+
+func importedComparePackage(t *testing.T, arch, declarations string) GoPackage {
+	t.Helper()
+	owner := importedGlobalPackage(t, importedCompareOwner, arch,
+		[]string{"package state\nvar Words [40]byte\n"}, nil)
+	pkg := importedGlobalPackage(t, "example.com/globalconsumer", arch,
+		[]string{"package globalconsumer\nimport state " + fmt.Sprintf("%q", owner.Path) +
+			"\nvar _ = state.Words\n" + declarations},
+		map[string]*types.Package{owner.Path: owner.Types})
+	pkg.ImportSyntax = map[string][]*ast.File{owner.Path: owner.Syntax}
+	pkg.Path = "main"
+	return pkg
+}
+
+func TestGoModuleImportedGlobalReadCompleteComparisonObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := importedCompareSource(target.arch)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"public", "owned-context"} {
+				t.Run(api, func(t *testing.T) {
+					pkg := importedComparePackage(t, target.arch, declarations)
+					ir, err := importedGlobalReadRequest(t, pkg, []byte(source), target.arch, target.triple, api, true, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if got := strings.Count(ir, "load volatile "); got != len(importedCompareCases(target.arch)) {
+						t.Fatalf("imported reads disappeared or multiplied: got %d", got)
+					}
+					for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "imported-compare.ll", "imported-compare.o", input)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixGoModuleImportedGlobalComparisons(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, declarations := importedCompareSource("amd64")
+	rows := importedCompareCases("amd64")
+	// The bytes beyond each narrower view distinguish an exact-width read
+	// from a wider load. Reassign between calls to catch folded initializers.
+	patterns := []uint64{0, 42 << 8, 43 << 8, 42<<8 | 1<<16, 42<<8 | 1<<24,
+		42<<8 | 1<<40, 1 << 63, ^uint64(0), 0x0123456789abcdef}
+	var goChecks, cChecks, cDeclarations strings.Builder
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	for index := range rows {
+		fmt.Fprintf(&cDeclarations, "extern uint32_t compare%d(void) __asm__(\"%smain.compare%d\");\n", index, prefix, index)
+	}
+	for pattern, seed := range patterns {
+		fmt.Fprintf(&goChecks, "for i:=range state.Words { state.Words[i]=byte(uint64(%d)>>uint(8*(i%%8))) }\n", seed)
+		fmt.Fprintf(&cChecks, "for(unsigned i=0;i<40;++i) words[i]=(uint8_t)(UINT64_C(%d)>>(8*(i%%8)));\n", seed)
+		for index, row := range rows {
+			// The unaligned 64-bit view wraps around to the seed's first byte.
+			value := seed>>8 | seed<<56
+			if row.bits < 64 {
+				value &= uint64(1)<<uint(row.bits) - 1
+			}
+			want := 7
+			if value == 42 {
+				want = 0
+			}
+			fmt.Fprintf(&goChecks, "if got:=compare%d(); got!=%d { panic(fmt.Sprintf(\"pattern=%d case=%d got=%%d\",got)) }\n", index, want, pattern, index)
+			fmt.Fprintf(&cChecks, "if(compare%d()!=%d) { fprintf(stderr,\"pattern=%d case=%d mismatch\\n\");return 1; }\n", index, want, pattern, index)
+		}
+	}
+	want := fmt.Sprintf("%d imported comparisons x %d mutable patterns\n", len(rows), len(patterns))
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "state"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	for name, contents := range map[string]string{
+		"go.mod":           "module example.com/globalconsumer\n\ngo 1.20\n",
+		"state/state.go":   "package state\nvar Words [40]byte\n",
+		"original_amd64.s": source,
+		"main.go": "package main\nimport (\"fmt\"; state " + fmt.Sprintf("%q", importedCompareOwner) + ")\n" +
+			declarations + "func main(){\n" + goChecks.String() + fmt.Sprintf("fmt.Print(%q)\n}\n", want),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original")
+	if runtime.GOOS == "windows" {
+		executable += ".exe"
+	}
+	command := exec.Command("go", "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	if output := execution.run(t, executable); string(output) != want {
+		t.Fatalf("original Go imported-storage oracle: %q", output)
+	}
+	cSource := "#include <stdint.h>\n#include <stdio.h>\n" + cDeclarations.String() +
+		fmt.Sprintf("uint8_t words[40] __asm__(\"%s%s.Words\");\n", prefix, importedCompareOwner) +
+		"int main(void){\n" + cChecks.String() + fmt.Sprintf("printf(%q);return 0;\n}\n", want)
+	for _, api := range []string{"public", "owned-context"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := importedComparePackage(t, "amd64", declarations)
+			ir, err := importedGlobalReadRequest(t, pkg, []byte(source), "amd64", execution.triple, api, true, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"},
+				{"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "imported-compare", pipeline.ir, cSource, pipeline.level)
+					if string(output) != want {
+						t.Fatalf("imported mutable comparison execution: %q", output)
+					}
+					t.Log(strings.TrimSpace(want))
+				})
+			}
+		})
+	}
+}
diff --git a/go_imported_global_read_guard_test.go b/go_imported_global_read_guard_test.go
new file mode 100644
index 000000000..2ffedab4b
--- /dev/null
+++ b/go_imported_global_read_guard_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func importedGlobalRequireContext(t *testing.T, ir string, err error) {
+	t.Helper()
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("imported declaration expanded its numerical-read role: output=%t err=%v", ir != "", err)
+	}
+}
+
+func TestGoModuleImportedGlobalReadNeedsActualDeclarations(t *testing.T) {
+	for _, mutation := range []string{
+		"missing-syntax", "wrong-syntax-key", "nil-file", "missing-import", "foreign-import-pointer",
+		"incomplete-import", "wrong-package", "missing-variable", "different-type", "missing-type-file",
+		"external-alias", "duplicate-self-linkname", "other-aliases-native", "malformed-linkname", "self-linkname-without-unsafe",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{
+				"package state\nvar Flags Bit\n", "package state\ntype Bit bool\n",
+			}, nil)
+			pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+			switch mutation {
+			case "missing-syntax":
+				pkg.ImportSyntax = nil
+			case "wrong-syntax-key":
+				pkg.ImportSyntax = map[string][]*ast.File{"example.com/foreign": owner.Syntax}
+			case "nil-file":
+				pkg.ImportSyntax[owner.Path] = []*ast.File{nil}
+			case "missing-import":
+				delete(pkg.Imports, owner.Path)
+			case "foreign-import-pointer":
+				// Equal paths and layouts are not the caller's actual import identity.
+				other := importedGlobalPackage(t, owner.Path, "amd64", []string{
+					"package state\nvar Flags Bit\ntype Bit bool\n",
+				}, nil)
+				pkg.Imports[owner.Path] = other.Types
+			case "incomplete-import":
+				pkg.Imports[owner.Path] = types.NewPackage(owner.Path, "state")
+			case "wrong-package", "missing-variable", "different-type", "external-alias",
+				"duplicate-self-linkname", "other-aliases-native", "malformed-linkname", "self-linkname-without-unsafe":
+				source := map[string]string{
+					"wrong-package":                "package foreign\ntype Bit bool\nvar Flags Bit\n",
+					"missing-variable":             "package state\ntype Bit bool\n",
+					"different-type":               "package state\ntype Bit uint64\nvar Flags Bit\n",
+					"external-alias":               "package state\nimport _ \"unsafe\"\ntype Bit bool\n//go:linkname Flags foreign.Flags\nvar Flags Bit\n",
+					"duplicate-self-linkname":      "package state\nimport _ \"unsafe\"\ntype Bit bool\n//go:linkname Flags\n//go:linkname Flags\nvar Flags Bit\n",
+					"other-aliases-native":         "package state\nimport _ \"unsafe\"\ntype Bit bool\nvar Flags Bit\n//go:linkname Shadow example.com/state.Flags\nvar Shadow Bit\n",
+					"malformed-linkname":           "package state\nimport _ \"unsafe\"\ntype Bit bool\n//go:linkname Flags example.com/state.Flags extra\nvar Flags Bit\n",
+					"self-linkname-without-unsafe": "package state\ntype Bit bool\n//go:linkname Flags\nvar Flags Bit\n",
+				}[mutation]
+				other := importedGlobalPackage(t, owner.Path, "amd64", []string{source}, map[string]*types.Package{"unsafe": types.Unsafe})
+				pkg.ImportSyntax[owner.Path] = other.Syntax
+			case "missing-type-file":
+				pkg.ImportSyntax[owner.Path] = owner.Syntax[:1]
+			}
+			source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 0)+",$0\n")
+			ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			importedGlobalRequireContext(t, ir, err)
+		})
+	}
+}
+
+func TestGoModuleImportedGlobalReadDoesNotLendOtherStorage(t *testing.T) {
+	for _, row := range []struct{ name, declaration, prefix, comparison string }{
+		{"wider-than-bool", "var Flags bool", "", "CMPW %s,$0\n"},
+		{"past-bool", "var Flags bool", "", "CMPB %s+1(SB),$0\n"},
+		{"negative-offset", "var Flags bool", "", "CMPB %s-1(SB),$0\n"},
+		{"unknown-symbol", "var Flags bool", "", "CMPB example.com∕state·Missing(SB),$0\n"},
+		{"pointer-storage", "var Flags *byte", "", "CMPB %s,$0\n"},
+		{"string-header", "var Flags string", "", "CMPB %s,$0\n"},
+		{"slice-header", "var Flags []byte", "", "CMPB %s,$0\n"},
+		{"blank-field", "var Flags struct { _ byte; Ready bool }", "", "CMPB %s,$0\n"},
+		{"padding", "var Flags struct { Ready bool; Word uint64 }", "", "CMPB %s+1(SB),$0\n"},
+		{"cross-padding", "var Flags struct { Ready bool; Word uint64 }", "", "CMPW %s,$0\n"},
+		{"mov-not-compare", "var Flags bool", "MOVB %s,CL\n", "CMPB %s,$0\n"},
+		{"test-not-cmp", "var Flags bool", "TESTB $1,%s\n", "CMPB %s,$0\n"},
+		{"write-not-read", "var Flags bool", "MOVB $1,%s\n", "CMPB %s,$0\n"},
+		{"rmw-not-read", "var Flags bool", "INCB %s\n", "CMPB %s,$0\n"},
+		{"address-not-pointer", "var Flags bool", "LEAQ %s,DX\nMOVB (DX),CL\n", "CMPB %s,$0\n"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{
+				"package state\n" + row.declaration + "\n",
+			}, nil)
+			pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+			operand := importedGlobalOperand(owner.Path, "Flags", 0)
+			expand := func(pattern string) string {
+				if strings.Contains(pattern, "%s+") || strings.Contains(pattern, "%s-") {
+					return strings.ReplaceAll(pattern, "%s", strings.TrimSuffix(operand, "+0(SB)"))
+				}
+				return strings.ReplaceAll(pattern, "%s", operand)
+			}
+			source := ordinaryGlobalReadAssembly(expand(row.prefix), expand(row.comparison))
+			ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			importedGlobalRequireContext(t, ir, err)
+		})
+	}
+}
+
+func TestGoModuleImportedGlobalReadCannotLendToRawAPI(t *testing.T) {
+	owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{"package state\nvar Flags bool\n"}, nil)
+	pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+	source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 0)+",$0\n")
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t, string(source), pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			importedGlobalRequireContext(t, ir, err)
+		})
+	}
+}
+
+func TestGoModuleImportedGlobalReadRechecksAfterCallbacks(t *testing.T) {
+	for _, mutation := range []string{"control", "syntax", "imports", "typed-dependencies", "import-syntax-map", "resolver", "original-assembly"} {
+		t.Run(mutation, func(t *testing.T) {
+			owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{"package state\nvar Flags bool\n"}, nil)
+			pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+			other := importedGlobalPackage(t, owner.Path, "amd64", []string{"package state\nvar Flags bool\n"}, nil)
+			source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 0)+",$0\n")
+			called := false
+			ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true, func(options *GoModuleOptions) {
+				resolve := options.ResolveSym
+				options.ResolveSym = func(symbol string) string {
+					native := resolve(symbol)
+					if mutation == "resolver" && called && native == owner.Path+".Flags" {
+						return "foreign.Flags"
+					}
+					return native
+				}
+				options.KeepFunc = func(_, _ string) bool {
+					called = true
+					switch mutation {
+					case "syntax":
+						ast.Inspect(owner.Syntax[0], func(node ast.Node) bool {
+							if ident, ok := node.(*ast.Ident); ok && ident.Name == "bool" {
+								ident.Name = "uint8"
+							}
+							return true
+						})
+					case "imports":
+						pkg.Imports[owner.Path] = other.Types
+					case "typed-dependencies":
+						owner.Types.SetImports([]*types.Package{types.Unsafe})
+					case "import-syntax-map":
+						delete(pkg.ImportSyntax, owner.Path)
+					case "original-assembly":
+						source[len(source)-1] = ' '
+					}
+					return true // A callback may not hide the requested function.
+				}
+			})
+			if !called {
+				t.Fatal("the source callback did not execute")
+			}
+			if mutation == "control" {
+				if err != nil || ir == "" {
+					t.Fatal("unmodified imported declaration callback was rejected", err)
+				}
+				importedGlobalRequireMutable(t, ir, owner.Path+".Flags")
+			} else {
+				importedGlobalRequireContext(t, ir, err)
+			}
+		})
+	}
+}
diff --git a/go_imported_global_read_test.go b/go_imported_global_read_test.go
new file mode 100644
index 000000000..9b42a4c45
--- /dev/null
+++ b/go_imported_global_read_test.go
@@ -0,0 +1,263 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func importedGlobalPackage(t *testing.T, path, arch string, sources []string, imports map[string]*types.Package) GoPackage {
+	t.Helper()
+	set := token.NewFileSet()
+	files := make([]*ast.File, len(sources))
+	for index, source := range sources {
+		file, err := parser.ParseFile(set, fmt.Sprintf("input%d.go", index), source, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		files[index] = file
+	}
+	config := types.Config{Importer: goReadOnlyImporter(imports), Sizes: types.SizesFor("gc", arch)}
+	typed, err := config.Check(path, set, files, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualImports := make(map[string]*types.Package)
+	for _, dependency := range typed.Imports() {
+		actualImports[dependency.Path()] = dependency
+	}
+	return GoPackage{Path: path, Types: typed, Syntax: files, Imports: actualImports}
+}
+
+func importedGlobalConsumer(t *testing.T, owner GoPackage, name, arch string) GoPackage {
+	t.Helper()
+	consumer := importedGlobalPackage(t, "example.com/globalconsumer", arch, []string{
+		"package globalconsumer\nimport dep " + fmt.Sprintf("%q", owner.Path) +
+			"\nvar _ = dep." + name + "\nvar Flags bool\nfunc view() uint32\n",
+	}, map[string]*types.Package{owner.Path: owner.Types})
+	consumer.ImportSyntax = map[string][]*ast.File{owner.Path: owner.Syntax}
+	return consumer
+}
+
+func importedGlobalOperand(path, name string, offset int64) string {
+	// Stock Go's assembler spells package-path punctuation as identifier
+	// characters; a literal dot would terminate the symbol token.
+	path = strings.NewReplacer("/", "∕", ".", "·").Replace(path)
+	return fmt.Sprintf("%s·%s+%d(SB)", path, name, offset)
+}
+
+func importedGlobalReadRequest(t *testing.T, pkg GoPackage, source []byte, arch, triple, api string, preprocessed bool,
+	configure func(*GoModuleOptions),
+) (string, error) {
+	t.Helper()
+	options := GoModuleOptions{GOOS: "linux", GOARCH: arch, TargetTriple: triple,
+		Sizes: types.SizesFor("gc", arch), FrameSizes: types.SizesFor("gc", arch),
+		SourcePreprocessed: preprocessed, ResolveSym: testResolveSym(pkg.Path)}
+	if configure != nil {
+		configure(&options)
+	}
+	var result *GoModuleTranslation
+	var err error
+	if api == "public" {
+		result, err = TranslateGoModule(pkg, source, options)
+	} else {
+		if api != "owned-context" {
+			t.Fatal("unknown imported global test API", api)
+		}
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		result, err = translateGoModuleInContext(ctx, pkg, source, options)
+		if result != nil {
+			defer result.Module.Dispose()
+			if err == nil {
+				if verify := llvm.VerifyModule(result.Module, llvm.ReturnStatusAction); verify != nil {
+					t.Fatal("invalid imported-global LLVM module", verify)
+				}
+			}
+			return result.Module.String(), err
+		}
+		return "", err
+	}
+	if result == nil {
+		return "", err
+	}
+	defer result.Module.Dispose()
+	if err == nil {
+		if verify := llvm.VerifyModule(result.Module, llvm.ReturnStatusAction); verify != nil {
+			t.Fatal("invalid imported-global LLVM module", verify)
+		}
+	}
+	return result.Module.String(), err
+}
+
+func importedGlobalRequireMutable(t *testing.T, ir, native string) {
+	t.Helper()
+	if !strings.Contains(ir, "load volatile i8") || !strings.Contains(ir, "br i1") {
+		t.Fatal("imported comparison lost its exact mutable read or observable predicate", ir)
+	}
+	for _, line := range strings.Split(ir, "\n") {
+		if strings.HasPrefix(line, "@\""+native+"\" = ") || strings.HasPrefix(line, "@"+native+" = ") {
+			if !strings.Contains(line, " = external global ") {
+				t.Fatal("Go-owned numerical storage became DATA, a definition or a constant", line)
+			}
+			return
+		}
+	}
+	t.Fatal("missing actual imported native declaration", native, ir)
+}
+
+// ImportDir selects files directly using go/build, not a subprocess or go list.
+// Recheck every selected CPU Go file, including real self-linkname directives;
+// do not manufacture a struct from the assembly's observed offsets.
+func importedGlobalSelectedCPU(t *testing.T) GoPackage {
+	t.Helper()
+	context := build.Default
+	context.GOROOT, context.GOOS, context.GOARCH = runtime.GOROOT(), "linux", "amd64"
+	context.CgoEnabled = false
+	context.ToolTags = nil
+	for _, tag := range build.Default.ToolTags {
+		if !strings.HasPrefix(tag, build.Default.GOARCH+".") && !strings.HasPrefix(tag, "amd64.") {
+			context.ToolTags = append(context.ToolTags, tag) // Preserve selected Go experiments and other non-ISA tags.
+		}
+	}
+	context.ToolTags = append(context.ToolTags, "amd64.v1")
+	directory := filepath.Join(context.GOROOT, "src", "internal", "cpu")
+	selected, err := context.ImportDir(directory, 0)
+	if err != nil || len(selected.GoFiles) == 0 {
+		t.Fatal("missing actual selected SDK CPU source", err)
+	}
+	var sources []string
+	for _, name := range selected.GoFiles {
+		data, err := os.ReadFile(filepath.Join(directory, name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sources = append(sources, string(data))
+	}
+	return importedGlobalPackage(t, "internal/cpu", "amd64", sources, map[string]*types.Package{"unsafe": types.Unsafe})
+}
+
+func TestGoModuleImportedGlobalReadSelectedCPU(t *testing.T) {
+	owner := importedGlobalSelectedCPU(t)
+	variable, ok := owner.Types.Scope().Lookup("X86").(*types.Var)
+	if !ok {
+		t.Fatal("selected CPU source lacks its actual X86 variable")
+	}
+	structure, ok := variable.Type().Underlying().(*types.Struct)
+	if !ok {
+		t.Fatal("selected CPU X86 is not its actual struct")
+	}
+	fields := make([]*types.Var, structure.NumFields())
+	for index := range fields {
+		fields[index] = structure.Field(index)
+	}
+	offsets := types.SizesFor("gc", "amd64").Offsetsof(fields)
+	for _, candidate := range []struct{ file, field string }{
+		{"count_amd64.s", "HasPOPCNT"}, {"index_amd64.s", "HasSSE42"},
+		{"indexbyte_amd64.s", "HasAVX2"}, {"equal_amd64.s", "HasAVX2"},
+	} {
+		offset := int64(-1)
+		for index, field := range fields {
+			if field.Name() == candidate.field && types.Identical(field.Type(), types.Typ[types.Bool]) {
+				offset = offsets[index]
+			}
+		}
+		if offset < 0 {
+			t.Fatal("missing actual selected numerical CPU field", candidate.field)
+		}
+		for _, api := range []string{"public", "owned-context"} {
+			for _, preprocessed := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/preprocessed=%t", candidate.file, api, preprocessed), func(t *testing.T) {
+					pkg := importedGlobalConsumer(t, owner, "X86", "amd64")
+					source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "X86", offset)+",$1\n")
+					ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", api, preprocessed, nil)
+					if err != nil || ir == "" {
+						t.Fatal("actual loaded CPU declarations did not establish the bounded numeric read", err)
+					}
+					importedGlobalRequireMutable(t, ir, "internal/cpu.X86")
+				})
+			}
+		}
+	}
+	t.Log("four CPU comparison sites with actual selected SDK types/syntax; independent ABI0 regression, not successful whole-bytealg/ABIInternal execution")
+}
+
+func TestGoModuleImportedGlobalReadOrdinaryPackages(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, self := range []bool{false, true} {
+			declarations := "package state\nvar Flags bool\n"
+			if self {
+				declarations = "package state\nimport _ \"unsafe\"\n//go:linkname Flags\nvar Flags bool\n"
+			}
+			owner := importedGlobalPackage(t, "example.com/state", arch, []string{declarations}, map[string]*types.Package{"unsafe": types.Unsafe})
+			for _, api := range []string{"public", "owned-context"} {
+				t.Run(fmt.Sprintf("%s/self=%t/%s", arch, self, api), func(t *testing.T) {
+					pkg := importedGlobalConsumer(t, owner, "Flags", arch)
+					source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 0)+",$0\n")
+					triple := "x86_64-unknown-linux-gnu"
+					if arch == "386" {
+						triple = "i386-unknown-linux-gnu"
+					}
+					ir, err := importedGlobalReadRequest(t, pkg, source, arch, triple, api, true, nil)
+					if err != nil || ir == "" {
+						t.Fatal("ordinary imported numerical declaration was treated as a CPU whitelist", err)
+					}
+					importedGlobalRequireMutable(t, ir, owner.Path+".Flags")
+				})
+			}
+		}
+	}
+}
+
+func TestGoModuleImportedGlobalReadDistinctNamespaces(t *testing.T) {
+	owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{
+		"package state\nvar Flags struct { _ [3]byte; Ready bool }\n",
+	}, nil)
+	for _, main := range []bool{false, true} {
+		t.Run(fmt.Sprint("linked-main=", main), func(t *testing.T) {
+			pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+			if main {
+				pkg.Path = "main" // Legitimate linked namespace distinct from Types.Path().
+			}
+			source := ordinaryGlobalReadAssembly("CMPB ·Flags(SB),$0\n", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 3)+",$0\n")
+			ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+			if err != nil || ir == "" {
+				t.Fatal("local/imported variables with equal names were conflated", err)
+			}
+			importedGlobalRequireMutable(t, ir, owner.Path+".Flags")
+			importedGlobalRequireMutable(t, ir, pkg.Path+".Flags")
+			if strings.Count(ir, "load volatile i8") != 2 {
+				t.Fatal("the two actual numerical reads did not remain distinct", ir)
+			}
+		})
+	}
+}
+
+func TestGoModuleImportedGlobalReadTypedDependencies(t *testing.T) {
+	dependency := importedGlobalPackage(t, "example.com/numeric", "amd64", []string{
+		"package numeric\ntype Byte uint8\n",
+	}, nil)
+	owner := importedGlobalPackage(t, "example.com/state", "amd64", []string{
+		"package state\nimport \"example.com/numeric\"\nvar Flags numeric.Byte\n",
+	}, map[string]*types.Package{dependency.Path: dependency.Types})
+	pkg := importedGlobalConsumer(t, owner, "Flags", "amd64")
+	if len(pkg.Imports) != 1 || pkg.Imports[dependency.Path] != nil {
+		t.Fatal("fixture accidentally flattened imported-package dependencies into the caller")
+	}
+	source := ordinaryGlobalReadAssembly("", "CMPB "+importedGlobalOperand(owner.Path, "Flags", 0)+",$0\n")
+	ir, err := importedGlobalReadRequest(t, pkg, source, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true, nil)
+	if err != nil || ir == "" {
+		t.Fatal("import syntax did not use its own actual complete typed dependencies", err)
+	}
+	importedGlobalRequireMutable(t, ir, owner.Path+".Flags")
+}
diff --git a/go_integer_expression.go b/go_integer_expression.go
new file mode 100644
index 000000000..5fb28d98d
--- /dev/null
+++ b/go_integer_expression.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+	"text/scanner"
+	"unicode/utf8"
+)
+
+const (
+	goIntegerExpressionMaxBytes  = 64 << 10
+	goIntegerExpressionMaxTokens = 4096
+	goIntegerExpressionMaxDepth  = 128
+)
+
+// Integer immediates use cmd/asm's expr/term/factor grammar, not Go's AST
+// grammar. In particular, SHR consumes a term, whereas SHL consumes a factor
+// and finishes its term. The caller must consume the complete expression.
+func parseImmExpr(text string) (uint64, bool) {
+	if len(text) > goIntegerExpressionMaxBytes {
+		return 0, false
+	}
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return 0, false
+	}
+	if value, err := strconv.ParseUint(text, 0, 64); err == nil {
+		return value, true
+	}
+	parser := goIntegerExpression{reader: newPPGoReader("<integer-expression>", text), valid: true}
+	parser.next()
+	value := parser.expression()
+	return value.bits, parser.valid && parser.token.kind == scanner.EOF && value.known
+}
+
+// A generated-header expression can be syntactically complete without a
+// numerical value. This query uses the same bounded assembler grammar, but
+// never exposes its placeholder arithmetic as a resolved immediate.
+func goIntegerExpressionNeedsContext(text string) bool {
+	if len(text) > goIntegerExpressionMaxBytes {
+		return false
+	}
+	parser := goIntegerExpression{reader: newPPGoReader("<symbolic-expression>", text),
+		valid: true, allowUnknown: true}
+	parser.next()
+	value := parser.expression()
+	return parser.valid && parser.token.kind == scanner.EOF && !value.known
+}
+
+type goIntegerValue struct {
+	bits  uint64
+	known bool
+}
+
+type goIntegerExpression struct {
+	reader       *ppGoReader
+	token        ppGoToken
+	tokens       int
+	depth        int
+	valid        bool
+	allowUnknown bool
+}
+
+func (parser *goIntegerExpression) next() {
+	if !parser.valid {
+		return
+	}
+	parser.tokens++
+	if parser.tokens > goIntegerExpressionMaxTokens {
+		parser.valid = false
+		return
+	}
+	token, err := parser.reader.next()
+	parser.token = token
+	parser.valid = err == nil
+}
+
+func (parser *goIntegerExpression) enter() bool {
+	if !parser.valid || parser.depth >= goIntegerExpressionMaxDepth {
+		parser.valid = false
+		return false
+	}
+	parser.depth++
+	return true
+}
+
+func (parser *goIntegerExpression) expression() goIntegerValue {
+	value := parser.term()
+	for parser.valid {
+		switch parser.token.text {
+		case "+", "-", "|", "^":
+			operator := parser.token.text
+			parser.next()
+			right := parser.term()
+			value.known = value.known && right.known
+			switch operator {
+			case "+":
+				value.bits += right.bits
+			case "-":
+				value.bits -= right.bits
+			case "|":
+				value.bits |= right.bits
+			case "^":
+				value.bits ^= right.bits
+			}
+		default:
+			return value
+		}
+	}
+	return goIntegerValue{}
+}
+
+func (parser *goIntegerExpression) term() goIntegerValue {
+	if !parser.enter() {
+		return goIntegerValue{}
+	}
+	defer func() { parser.depth-- }()
+	value := parser.factor()
+	for parser.valid {
+		operator := parser.token.text
+		switch operator {
+		case "*", "/", "%", "&":
+			parser.next()
+			right := parser.factor()
+			switch operator {
+			case "*":
+				value.bits *= right.bits
+			case "/", "%":
+				if value.known && int64(value.bits) < 0 || right.known && right.bits == 0 {
+					parser.valid = false
+					return goIntegerValue{}
+				}
+				if !value.known || !right.known {
+					value.bits = 0
+				} else if operator == "/" {
+					value.bits /= right.bits
+				} else {
+					value.bits %= right.bits
+				}
+			case "&":
+				value.bits &= right.bits
+			}
+			value.known = value.known && right.known
+		case "<<", ">>":
+			parser.next()
+			var shift goIntegerValue
+			if operator == "<<" {
+				shift = parser.factor()
+			} else {
+				shift = parser.term()
+			}
+			if !parser.valid || shift.known && int64(shift.bits) < 0 ||
+				operator == ">>" && value.known && int64(value.bits) < 0 {
+				parser.valid = false
+				return goIntegerValue{}
+			}
+			value.known = value.known && shift.known
+			if operator == "<<" {
+				value.bits <<= shift.bits
+				return value
+			}
+			value.bits >>= shift.bits
+		default:
+			return value
+		}
+	}
+	return goIntegerValue{}
+}
+
+func (parser *goIntegerExpression) factor() goIntegerValue {
+	if !parser.enter() {
+		return goIntegerValue{}
+	}
+	defer func() { parser.depth-- }()
+	token := parser.token
+	parser.next()
+	switch token.kind {
+	case scanner.Ident:
+		_, register := parseReg(token.text)
+		if parser.allowUnknown && !register && token.text != "g" {
+			return goIntegerValue{} // Unknown, never a resolved numerical zero.
+		}
+		parser.valid = false
+		return goIntegerValue{}
+	case scanner.Int:
+		value, err := strconv.ParseUint(token.text, 0, 64)
+		parser.valid = parser.valid && err == nil
+		return goIntegerValue{bits: value, known: true}
+	case scanner.Char:
+		text, err := strconv.Unquote(token.text)
+		value, width := utf8.DecodeRuneInString(text)
+		parser.valid = parser.valid && err == nil && text != "" && width == len(text) &&
+			!(value == utf8.RuneError && width == 1)
+		return goIntegerValue{bits: uint64(value), known: true}
+	case '+':
+		return parser.factor()
+	case '-':
+		value := parser.factor()
+		value.bits = -value.bits
+		return value
+	case '~':
+		value := parser.factor()
+		value.bits = ^value.bits
+		return value
+	case '(':
+		value := parser.expression()
+		if parser.token.kind != ')' {
+			parser.valid = false
+			return goIntegerValue{}
+		}
+		parser.next()
+		return value
+	default:
+		parser.valid = false
+		return goIntegerValue{}
+	}
+}
diff --git a/go_module_explicit_context_api_test.go b/go_module_explicit_context_api_test.go
new file mode 100644
index 000000000..14da3d663
--- /dev/null
+++ b/go_module_explicit_context_api_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+// The explicit public context entry is separate from the retained legacy
+// wrapper/private-context regressions in go_translate_context_test.go.
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const goModuleOwnedContextSource = "TEXT ·Value(SB),4,$0-4\nMOVL $7,ret+0(FP)\nRET\n"
+
+func goModuleOwnedContextOptions(pkg GoPackage) GoModuleOptions {
+	return GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: testResolveSym(pkg.Path)}
+}
+
+func goModuleRequireOwnedContext(t *testing.T, ctx llvm.Context, result *GoModuleTranslation, err error) {
+	t.Helper()
+	if err != nil || result == nil || result.Module.IsNil() {
+		t.Fatalf("complete caller-context GoModule translation failed: %v", err)
+	}
+	if result.Module.Context() != ctx {
+		t.Fatal("GoModule ignored the explicit caller-owned LLVM context")
+	}
+	if err := llvm.VerifyModule(result.Module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal("caller-context module does not verify", err)
+	}
+	if len(result.Functions) != 1 {
+		t.Fatal("complete original source function inventory changed")
+	}
+	function := result.Module.NamedFunction(result.Functions[0].ResolvedSymbol)
+	if function.IsNil() || function.FirstBasicBlock().IsNil() || function.Type().Context() != ctx {
+		t.Fatal("translated body/type does not belong to the explicit context")
+	}
+}
+
+func TestTranslateGoModuleInContextIdentity(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/contextowner", "package contextowner\nfunc Value() uint32\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	result, err := TranslateGoModuleInContext(ctx, pkg, []byte(goModuleOwnedContextSource), goModuleOwnedContextOptions(pkg))
+	if result != nil && !result.Module.IsNil() {
+		defer result.Module.Dispose() // The returned module precedes its owner's context.
+	}
+	goModuleRequireOwnedContext(t, ctx, result, err)
+}
+
+func TestTranslateGoModuleInContextIndependentLifetimes(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/contextowner", "package contextowner\nfunc Value() uint32\n")
+	second := llvm.NewContext()
+	defer second.Dispose()
+	retained, err := TranslateGoModuleInContext(second, pkg, []byte(goModuleOwnedContextSource), goModuleOwnedContextOptions(pkg))
+	if retained != nil && !retained.Module.IsNil() {
+		defer retained.Module.Dispose()
+	}
+	goModuleRequireOwnedContext(t, second, retained, err)
+	func() {
+		first := llvm.NewContext()
+		defer first.Dispose()
+		temporary, err := TranslateGoModuleInContext(first, pkg, []byte(goModuleOwnedContextSource), goModuleOwnedContextOptions(pkg))
+		if temporary != nil && !temporary.Module.IsNil() {
+			defer temporary.Module.Dispose()
+		}
+		goModuleRequireOwnedContext(t, first, temporary, err)
+		if first == second || temporary.Module.Context() == retained.Module.Context() ||
+			temporary.Module.NamedFunction(temporary.Functions[0].ResolvedSymbol).Type() ==
+				retained.Module.NamedFunction(retained.Functions[0].ResolvedSymbol).Type() {
+			t.Fatal("independent requests shared LLVM context/type ownership")
+		}
+	}()
+	// The first module and its complete context have actually been destroyed.
+	// The second caller's original module must remain valid and usable.
+	goModuleRequireOwnedContext(t, second, retained, nil)
+	again, err := TranslateGoModuleInContext(second, pkg, []byte(goModuleOwnedContextSource), goModuleOwnedContextOptions(pkg))
+	if again != nil && !again.Module.IsNil() {
+		defer again.Module.Dispose()
+	}
+	goModuleRequireOwnedContext(t, second, again, err)
+}
+
+func TestTranslateGoModuleInContextErrorOwnership(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/contextowner", "package contextowner\nfunc Value() uint32\n")
+	for _, failure := range []string{"missing-architecture", "uninitialized-result", "unknown-instruction"} {
+		t.Run(failure, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			// This separate valid module belongs to the caller before the API
+			// is invoked. Failure must not dispose the surrounding context.
+			sentinel := ctx.NewModule("caller-owned-before-error")
+			defer sentinel.Dispose()
+			builder := ctx.NewBuilder()
+			function := llvm.AddFunction(sentinel, "sentinel", llvm.FunctionType(ctx.Int32Type(), nil, false))
+			builder.SetInsertPointAtEnd(ctx.AddBasicBlock(function, "entry"))
+			builder.CreateRet(llvm.ConstInt(ctx.Int32Type(), 19, false))
+			builder.Dispose()
+			options, source := goModuleOwnedContextOptions(pkg), goModuleOwnedContextSource
+			switch failure {
+			case "missing-architecture":
+				options.GOARCH = ""
+			case "uninitialized-result":
+				source = "TEXT ·Value(SB),4,$0-4\nMOVL AX,ret+0(FP)\nRET\n"
+			case "unknown-instruction":
+				source = "TEXT ·Value(SB),4,$0-4\nUNKNOWN\nRET\n"
+			}
+			result, err := TranslateGoModuleInContext(ctx, pkg, []byte(source), options)
+			if result != nil && !result.Module.IsNil() {
+				defer result.Module.Dispose()
+			}
+			if err == nil || result != nil {
+				t.Fatal("failed GoModule request published a result", err)
+			}
+			if failure == "uninitialized-result" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("failure lost its original missing-input classification", err)
+			}
+			if sentinel.Context() != ctx {
+				t.Fatal("failed request changed the caller's existing module ownership")
+			}
+			if err := llvm.VerifyModule(sentinel, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("failed request invalidated the caller's existing module", err)
+			}
+			valid, err := TranslateGoModuleInContext(ctx, pkg, []byte(goModuleOwnedContextSource), goModuleOwnedContextOptions(pkg))
+			if valid != nil && !valid.Module.IsNil() {
+				defer valid.Module.Dispose()
+			}
+			goModuleRequireOwnedContext(t, ctx, valid, err)
+		})
+	}
+}
diff --git a/go_numerical_storage.go b/go_numerical_storage.go
new file mode 100644
index 000000000..ee7edf170
--- /dev/null
+++ b/go_numerical_storage.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// GoNumericalStorageReference requests an actual variable, not a storage span.
+type GoNumericalStorageReference struct{ PackagePath, Name string }
+
+type GoNumericalStorageCaptureRequest struct {
+	GoBinary, Directory, PackagePath, Target string
+	Environment                              []string
+	Variables                                []GoNumericalStorageReference
+	// SDKCPU requests the separate exact original Go1.27.1 internal/cpu role.
+	// It does not admit another Standard or Module=nil package.
+	SDKCPU bool
+	// SDKGlobals requests independently selected original SDK Go variables.
+	// It is separate from the exact CPU producer and creates no read permission.
+	SDKGlobals bool
+}
+
+// GoNumericalStorageOwner is an opaque live typed data observation. It is not
+// a pointer, caller, initialization-completion, constant or memory permission.
+// Its zero value and JSON cannot reconstruct the underlying private seal.
+type GoNumericalStorageOwner struct{ observation *gostaticstorage.Observation }
+
+func CaptureGoNumericalStorageOwner(ctx context.Context, request GoNumericalStorageCaptureRequest) (*GoNumericalStorageOwner, error) {
+	if ctx != nil && ctx.Err() != nil {
+		return nil, fmt.Errorf("capture numerical storage owner: %w", ctx.Err())
+	}
+	actual := gostaticstorage.Request{GoBinary: request.GoBinary, Directory: request.Directory,
+		PackagePath: request.PackagePath, Target: request.Target, Environment: append([]string(nil), request.Environment...)}
+	for _, reference := range request.Variables {
+		actual.Variables = append(actual.Variables, gostaticstorage.Reference{PackagePath: reference.PackagePath, Name: reference.Name})
+	}
+	var observation *gostaticstorage.Observation
+	var err error
+	if request.SDKCPU && request.SDKGlobals {
+		return nil, numericalSBContext("storage producer roles are mutually exclusive")
+	}
+	if request.SDKGlobals {
+		observation, err = gostaticstorage.CaptureSDKGlobals(ctx, actual)
+	} else if request.SDKCPU {
+		observation, err = gostaticstorage.CaptureSDKCPU(ctx, actual)
+	} else {
+		observation, err = gostaticstorage.Capture(ctx, actual)
+	}
+	if err != nil {
+		return nil, numericalStorageFailure(ctx, "capture numerical storage owner", err)
+	}
+	return &GoNumericalStorageOwner{observation: observation}, nil
+}
+
+func (owner *GoNumericalStorageOwner) Verify(ctx context.Context) error {
+	if owner == nil || owner.observation == nil {
+		return numericalSBContext("missing live numerical storage owner")
+	}
+	if err := owner.observation.Verify(ctx); err != nil {
+		owner.Close()
+		return numericalStorageFailure(ctx, "verify numerical storage owner", err)
+	}
+	return nil
+}
+
+// Only the producer's explicit missing-proof classification becomes Context.
+// Command, I/O and cancellation failures retain their actual infrastructure
+// cause; in particular a canceled command is not source-exclusion evidence.
+func numericalStorageFailure(ctx context.Context, stage string, err error) error {
+	if ctx != nil && ctx.Err() != nil {
+		return fmt.Errorf("%s: %w", stage, errors.Join(ctx.Err(), err))
+	}
+	if errors.Is(err, gostaticstorage.ErrContext) {
+		return fmt.Errorf("%w: %s: %w", ErrProbeNeedsContext, stage, err)
+	}
+	return fmt.Errorf("%s: %w", stage, err)
+}
+
+func (owner *GoNumericalStorageOwner) Close() {
+	if owner != nil && owner.observation != nil {
+		owner.observation.Close()
+	}
+}
+
+func numericalSBContext(format string, args ...any) error {
+	return fmt.Errorf("%w: actual numerical SB read: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
diff --git a/go_numerical_storage_sdk_globals_go127_test.go b/go_numerical_storage_sdk_globals_go127_test.go
new file mode 100644
index 000000000..fcd9f04fe
--- /dev/null
+++ b/go_numerical_storage_sdk_globals_go127_test.go
@@ -0,0 +1,170 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoNumericalStorageOriginalSDKMutableGlobals(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, profile, _, _ := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleProofContext(t)
+			defer cancel()
+			request := GoNumericalStorageCaptureRequest{
+				GoBinary: profile.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(profile.GoBinary)), "src", "internal", "runtime", "maps"),
+				PackagePath: "internal/runtime/maps", Target: profile.Target, Environment: profile.Environment,
+				Variables: []GoNumericalStorageReference{{PackagePath: "internal/runtime/maps", Name: "aeskeysched"}},
+			}
+			for _, cpu := range []bool{false, true} {
+				request.SDKCPU = cpu
+				owner, err := CaptureGoNumericalStorageOwner(ctx, request)
+				if owner != nil {
+					owner.Close()
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("maps data borrowed ordinary/CPU producer authority", cpu, err)
+				}
+			}
+			request.SDKCPU, request.SDKGlobals = false, true
+			owner, err := CaptureGoNumericalStorageOwner(ctx, request)
+			if err != nil {
+				t.Fatal("independent SDK Go-defined mutable storage producer absent", err)
+			}
+			defer owner.Close()
+			report, err := owner.observation.Readback(ctx)
+			if err != nil || len(report.Variables) != 1 {
+				t.Fatal("actual source/object/type readback", err)
+			}
+			variable := report.Variables[0]
+			extent := int64(128)
+			if arch == "386" {
+				extent = 64
+			}
+			if variable.NativeName != "internal/runtime/maps.aeskeysched" || variable.GoType != fmt.Sprintf("[%d]byte", extent) || variable.Size != extent ||
+				variable.Kind != 10 || !numericalOwnerContains(variable, 0, extent) || numericalOwnerContains(variable, extent-16, 17) ||
+				variable.DefinitionMember != "_go_.o" ||
+				report.Protocol == gostaticstorage.SDKCPUProtocol {
+				t.Fatal("mutable object original identity/layout/extent differs", variable)
+			}
+		})
+	}
+}
+
+func TestGoNumericalStorageSDKGlobalGeneralTypedClass(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			_, profile, _, _ := numericalSBFixture(t, "amd64")
+			ctx, cancel := runtimeOracleProofContext(t)
+			defer cancel()
+			request := GoNumericalStorageCaptureRequest{GoBinary: profile.GoBinary,
+				Directory:   filepath.Join(filepath.Dir(filepath.Dir(profile.GoBinary)), "src", "math", "bits"),
+				PackagePath: "math/bits", Target: target, Environment: profile.Environment, SDKGlobals: true,
+				Variables: []GoNumericalStorageReference{{PackagePath: "math/bits", Name: "deBruijn32tab"}},
+			}
+			owner, err := CaptureGoNumericalStorageOwner(ctx, request)
+			if err != nil {
+				t.Fatal("independent numerical-array DATA family", err)
+			}
+			defer owner.Close()
+			report, err := owner.observation.Readback(ctx)
+			if err != nil || len(report.Variables) != 1 {
+				t.Fatal(err)
+			}
+			variable := report.Variables[0]
+			if variable.Size != 32 || variable.Kind != 5 || variable.GoType != "[32]byte" ||
+				variable.NativeName != "math/bits.deBruijn32tab" || variable.DefinitionMember != "_go_.o" ||
+				!numericalOwnerContains(variable, 0, 32) {
+				t.Fatal("complete numerical DATA/source/object role differs", variable)
+			}
+		})
+	}
+}
+
+func TestGoNumericalStorageSDKGlobalExactProfileAndGuards(t *testing.T) {
+	_, profile, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	for index, pair := range profile.Environment {
+		if strings.HasPrefix(pair, "CGO_ENABLED=") {
+			profile.Environment[index] = "CGO_ENABLED=1"
+		}
+	}
+	request := GoNumericalStorageCaptureRequest{GoBinary: profile.GoBinary,
+		Directory:   filepath.Join(filepath.Dir(filepath.Dir(profile.GoBinary)), "src", "internal", "runtime", "maps"),
+		PackagePath: "internal/runtime/maps", Target: profile.Target, Environment: profile.Environment, SDKGlobals: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/runtime/maps", Name: "hashkey"}},
+	}
+	owner, err := CaptureGoNumericalStorageOwner(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	report, err := owner.observation.Readback(ctx)
+	if err != nil || report.Environment["CGO_ENABLED"] != "1" || report.CommandEnvironment["CGO_ENABLED"] != "1" ||
+		report.Variables[0].GoType != "[4]uintptr" || !numericalOwnerContains(report.Variables[0], 0, 32) {
+		t.Fatal("SDK producer replaced actual cgo/uintptr numerical profile", err)
+	}
+	for name, mutation := range map[string]func(*gostaticstorage.Report){
+		"extent":          func(report *gostaticstorage.Report) { report.Variables[0].Size++ },
+		"object index":    func(report *gostaticstorage.Report) { report.Variables[0].DefinitionIndex++ },
+		"member identity": func(report *gostaticstorage.Report) { report.Variables[0].DefinitionMember = "memhash_amd64.o" },
+		"CPU role":        func(report *gostaticstorage.Report) { report.Protocol = gostaticstorage.SDKCPUProtocol },
+		"dependency source": func(report *gostaticstorage.Report) {
+			for name := range report.Source {
+				if strings.HasPrefix(name, "_sdk/") {
+					delete(report.Source, name)
+					delete(report.SourceSHA256, name)
+					return
+				}
+			}
+		},
+		"missing export": func(report *gostaticstorage.Report) {
+			delete(report.Archives, "internal/abi")
+			delete(report.ArchiveSHA256, "internal/abi")
+		},
+		"cgo profile": func(report *gostaticstorage.Report) { report.Environment["CGO_ENABLED"] = "0" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			raw, err := json.Marshal(report)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var changed gostaticstorage.Report
+			if err := json.Unmarshal(raw, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutation(&changed)
+			if !errors.Is(gostaticstorage.ValidateReport(changed), gostaticstorage.ErrContext) ||
+				!errors.Is(owner.observation.CheckReport(ctx, changed), gostaticstorage.ErrContext) {
+				t.Fatal("edited original SDK report acquired live storage authority")
+			}
+		})
+	}
+	request.Variables = []GoNumericalStorageReference{{PackagePath: "internal/runtime/maps", Name: "zeroVal"}}
+	bad, err := CaptureGoNumericalStorageOwner(ctx, request)
+	if bad != nil {
+		bad.Close()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("aliased SDK storage acquired ordinary global identity", err)
+	}
+	canceled, stop := context.WithCancel(ctx)
+	stop()
+	if err := owner.Verify(canceled); !errors.Is(err, context.Canceled) {
+		// The public storage wrapper preserves its caller cancellation cause.
+		t.Fatal("cancellation lost its original infrastructure cause", err)
+	}
+	if err := owner.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restored caller context revived a failed SDK owner")
+	}
+}
diff --git a/go_object_source_path.go b/go_object_source_path.go
new file mode 100644
index 000000000..0218ea121
--- /dev/null
+++ b/go_object_source_path.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"strings"
+)
+
+// originalGoObjectSourcePath decodes spelling only. Callers must separately
+// bind this path to their captured physical source and exact original bytes.
+// objabi.AbsFile emits forward slashes on Windows, including $GOROOT names.
+func originalGoObjectSourcePath(name, root string) (string, bool) {
+	if strings.HasPrefix(name, "$GOROOT/") {
+		tail := strings.TrimPrefix(name, "$GOROOT/")
+		native := filepath.FromSlash(tail)
+		// Check the metadata before Join can erase dot segments or repeated
+		// separators. An SDK prefix must not give aliases source authority.
+		if !filepath.IsLocal(native) || filepath.ToSlash(filepath.Clean(native)) != tail {
+			return "", false
+		}
+		name = filepath.Join(root, native)
+	}
+	name = filepath.FromSlash(name)
+	if !filepath.IsAbs(name) || filepath.Clean(name) != name {
+		return "", false
+	}
+	return name, true
+}
diff --git a/go_object_source_path_test.go b/go_object_source_path_test.go
new file mode 100644
index 000000000..87e58a825
--- /dev/null
+++ b/go_object_source_path_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"testing"
+)
+
+func TestOriginalGoObjectSourcePathSpelling(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "source.s")
+	for _, spelling := range []string{file, filepath.ToSlash(file)} {
+		if actual, ok := originalGoObjectSourcePath(spelling, ""); !ok || actual != file {
+			t.Fatalf("actual Go object spelling %q: got %q, valid %v", spelling, actual, ok)
+		}
+	}
+	for _, spelling := range []string{
+		"source.s", "$GOROOT/source.s", file + "/../source.s",
+		filepath.ToSlash(root) + "//source.s", filepath.ToSlash(root) + "/./source.s",
+	} {
+		if actual, ok := originalGoObjectSourcePath(spelling, ""); ok {
+			t.Fatalf("noncanonical object spelling %q accepted as %q", spelling, actual)
+		}
+	}
+}
diff --git a/go_ordinary_global_arithmetic_runtime_linux_amd64_test.go b/go_ordinary_global_arithmetic_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..0d193928b
--- /dev/null
+++ b/go_ordinary_global_arithmetic_runtime_linux_amd64_test.go
@@ -0,0 +1,20 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+// The actual IA32 oracle uses the Linux amd64 kernel's direct 32-bit execution
+// route, whose host checks are deliberately not compiled on other platforms.
+func TestCrossLinuxRuntimeMatrixGoModuleOrdinaryGlobalArithmetic386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("LLVM22 and actual IA32 compiler required", err)
+	}
+	ordinaryGlobalArithmeticRuntime(t, "386", x86FloatCompareExecution{
+		llc: llc, triple: "i386-unknown-linux-gnu", compiler: []string{compiler, "-static", "-no-pie"},
+	}, true)
+}
diff --git a/go_ordinary_global_arithmetic_runtime_test.go b/go_ordinary_global_arithmetic_runtime_test.go
new file mode 100644
index 000000000..3a9402d5e
--- /dev/null
+++ b/go_ordinary_global_arithmetic_runtime_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math/big"
+	"math/bits"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Numerical oracle independent of the opcode/effect directories and emitted
+// LLVM. A big signed product supplies overflow without host-width truncation.
+func ordinaryGlobalArithmeticExpected(row ordinaryGlobalArithmeticCase, arch string, seed uint64) [16]byte {
+	var storage [40]byte
+	for index := 0; index < 5; index++ {
+		binary.LittleEndian.PutUint64(storage[8*index:], seed^(uint64(index)*0x9e3779b97f4a7c15))
+	}
+	var source uint64
+	for index := 0; index < row.bits/8; index++ {
+		source |= uint64(storage[1+index]) << uint(8*index)
+	}
+	prior := uint64(0x1234567889abcdef)
+	if arch == "386" {
+		prior = uint64(0x89abcdef)
+	}
+	shift := 0
+	if row.highByte {
+		shift = 8
+	}
+	mask := ^uint64(0) >> uint(64-row.bits)
+	sign := uint64(1) << uint(row.bits-1)
+	left := prior >> uint(shift) & mask
+	carry := uint64(0)
+	if row.carry {
+		carry = 1
+	}
+	var value uint64
+	cf, of := false, false
+	switch row.stem {
+	case "ADD", "ADC":
+		var high uint64
+		value, high = bits.Add64(left, source, carry)
+		cf = high != 0 || value > mask
+		value &= mask
+		of = ^(left^source)&(left^value)&sign != 0
+	case "SUB", "SBB":
+		var borrow uint64
+		value, borrow = bits.Sub64(left, source, carry)
+		cf = borrow != 0
+		value &= mask
+		of = (left^source)&(left^value)&sign != 0
+	case "AND":
+		value = left & source
+	case "OR":
+		value = left | source
+	case "XOR":
+		value = left ^ source
+	case "IMUL":
+		if row.three {
+			// The encoder uses an imm32, sign-extended to Q, and truncated
+			// to W/L; this is not the unbounded source integer spelling.
+			left = uint64(int64(int32(row.immediate))) & mask
+		}
+		signed := func(value uint64) *big.Int {
+			result := new(big.Int).SetUint64(value)
+			if value&sign != 0 {
+				result.Sub(result, new(big.Int).Lsh(big.NewInt(1), uint(row.bits)))
+			}
+			return result
+		}
+		product := new(big.Int).Mul(signed(left), signed(source))
+		value = new(big.Int).Mod(product, new(big.Int).Lsh(big.NewInt(1), uint(row.bits))).Uint64()
+		cf = product.Cmp(signed(value)) != 0
+		of = cf
+	default:
+		panic("unknown independent arithmetic oracle member")
+	}
+	register := prior&^(mask<<uint(shift)) | value<<uint(shift)
+	if row.bits == 32 {
+		register = value // A dword destination zeroes the upper half.
+	}
+	var output [16]byte
+	for index := range output {
+		output[index] = 0xa5
+	}
+	binary.LittleEndian.PutUint64(output[:8], register)
+	boolean := func(value bool) byte {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	output[8], output[9] = boolean(cf), boolean(of)
+	if row.stem != "IMUL" {
+		zf, sf, pf := value == 0, value&sign != 0, bits.OnesCount8(uint8(value))%2 == 0
+		output[10], output[11], output[12] = boolean(zf), boolean(sf), boolean(pf)
+		if row.stem != "AND" && row.stem != "OR" && row.stem != "XOR" {
+			af := (left^source^value)&0x10 != 0
+			output[13] = 2 | boolean(cf) | boolean(pf)<<2 | boolean(af)<<4 | boolean(zf)<<6 | boolean(sf)<<7
+		}
+	}
+	return output
+}
+
+func TestCrossLinuxRuntimeMatrixGoModuleOrdinaryGlobalArithmeticAMD64(t *testing.T) {
+	ordinaryGlobalArithmeticRuntime(t, "amd64", x86FloatCompareExecutionTools(t), true)
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticPortableExecution(t *testing.T) {
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	ordinaryGlobalArithmeticRuntime(t, arch, x86ScalarCountHostExecution(t), false)
+	t.Log("actual-host portable numerical/FLAGS/canary execution; not native original x86 execution")
+}
+
+func ordinaryGlobalArithmeticRuntime(t *testing.T, arch string, execution x86FloatCompareExecution, originalGo bool) {
+	t.Helper()
+	assembly, declarations := ordinaryGlobalArithmeticSource(arch)
+	rows := ordinaryGlobalArithmeticCases(arch)
+	patterns := []uint64{0, 0x7f00, 0x8000, 0xff00, 0x7fff00, 0x800000,
+		0x7fffffff00, 0x8000000000, 0x95, 0xffffffffffffff6a, 0xffffffffffffffea, ^uint64(0)}
+	var goChecks, cChecks, cDeclarations strings.Builder
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	const linkedPackage = "ordinaryglobals"
+	for index := range rows {
+		fmt.Fprintf(&cDeclarations, "extern void arithmetic%d(uint8_t*) __asm__(\"%s%s.arithmetic%d\");\n",
+			index, prefix, linkedPackage, index)
+	}
+	for pattern, seed := range patterns {
+		fmt.Fprintf(&goChecks, "for i:=range words { words[i]=uint64(%d)^(uint64(i)*0x9e3779b97f4a7c15) }\n", seed)
+		fmt.Fprintf(&cChecks, "for(unsigned i=0;i<5;++i) storage[i]=UINT64_C(%d)^((uint64_t)i*UINT64_C(0x9e3779b97f4a7c15));\n", seed)
+		for index, row := range rows {
+			want := ordinaryGlobalArithmeticExpected(row, arch, seed)
+			var values []string
+			for _, value := range want {
+				values = append(values, fmt.Sprint(value))
+			}
+			bytes := strings.Join(values, ",")
+			fmt.Fprintf(&goChecks, "{ var box struct{ before byte; data [16]byte; after byte }; box.before=55;box.after=146;for i:=range box.data { box.data[i]=165 }; arithmetic%d(&box.data); if box.before!=55||box.after!=146||box.data!=([16]byte{%s}) { panic(fmt.Sprintf(\"pattern=%d row=%d got=%%x\",box.data)) } }\n",
+				index, bytes, pattern, index)
+			fmt.Fprintf(&cChecks, "{ struct { uint8_t before,data[16],after; } box; box.before=55;box.after=146;memset(box.data,165,16); arithmetic%d(box.data); const uint8_t want[16]={%s}; if(box.before!=55||box.after!=146||memcmp(box.data,want,16)) {fprintf(stderr,\"pattern=%d row=%d mismatch\\n\");return 1;} }\n",
+				index, bytes, pattern, index)
+		}
+	}
+	want := fmt.Sprintf("%d readonly arithmetic programs x %d data/FLAGS/canary patterns\n", len(rows), len(patterns))
+	driver := "package main\nimport \"fmt\"\nfunc main(){\n" + goChecks.String() + fmt.Sprintf("fmt.Print(%q)\n}\n", want)
+	if originalGo {
+		original := x86OrderingHintBuildOriginal(t, t.TempDir(), runtime.GOOS, arch,
+			"package main\n"+declarations, assembly, driver)
+		if output := execution.run(t, original); string(output) != want {
+			t.Fatalf("original complete Go source disagrees with independent arithmetic: %q", output)
+		}
+	} else {
+		goAssemblerOracleOutput(t, arch, assembly, "", true)
+	}
+	cSource := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + cDeclarations.String() +
+		fmt.Sprintf("uint64_t storage[5] __asm__(\"%s%s.words\");\n", prefix, linkedPackage) +
+		"int main(void){\n" + cChecks.String() + fmt.Sprintf("printf(%q);return 0;\n}\n", want)
+	for _, api := range []string{"public", "owned-context"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			pkg.Path = linkedPackage
+			ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(assembly), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"},
+				{"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					if output := execution.compileAndRunLLVM(t, "ordinary-global-arithmetic", pipeline.ir, cSource, pipeline.level); string(output) != want {
+						t.Fatalf("arithmetic numerical/FLAGS/canary receipt: %q", output)
+					}
+					t.Log(strings.TrimSpace(want))
+				})
+			}
+		})
+	}
+}
diff --git a/go_ordinary_global_arithmetic_test.go b/go_ordinary_global_arithmetic_test.go
new file mode 100644
index 000000000..1d33b4a79
--- /dev/null
+++ b/go_ordinary_global_arithmetic_test.go
@@ -0,0 +1,265 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+type ordinaryGlobalArithmeticCase struct {
+	op, stem        string
+	bits            int
+	carry, highByte bool
+	three           bool
+	immediate       int64
+}
+
+// Independent closed inventory. Unary/implicit multiply/divide, bit strings,
+// ADX and memory destinations are not this read-only mem-to-GP role.
+func ordinaryGlobalArithmeticCases(arch string) []ordinaryGlobalArithmeticCase {
+	var rows []ordinaryGlobalArithmeticCase
+	for width, suffix := range []string{"B", "W", "L", "Q"} {
+		if arch == "386" && suffix == "Q" {
+			continue
+		}
+		bits := []int{8, 16, 32, 64}[width]
+		for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+			row := ordinaryGlobalArithmeticCase{op: stem + suffix, stem: stem, bits: bits}
+			rows = append(rows, row)
+			if stem == "ADC" || stem == "SBB" {
+				row.carry = true
+				rows = append(rows, row)
+				row.carry = false
+			}
+			if bits == 8 {
+				row.highByte = true
+				rows = append(rows, row)
+			}
+		}
+		if bits == 8 {
+			continue
+		}
+		rows = append(rows, ordinaryGlobalArithmeticCase{op: "IMUL" + suffix, stem: "IMUL", bits: bits})
+		// Both Yi8/Yi32 rows, positive/negative signed values, W truncation,
+		// and Q's real sign extension of the encoded imm32 are independent.
+		for _, immediate := range []int64{-128, 128, 0x80000000, 0xffffffff} {
+			rows = append(rows, ordinaryGlobalArithmeticCase{
+				op: "IMUL3" + suffix, stem: "IMUL", bits: bits, three: true, immediate: immediate,
+			})
+		}
+	}
+	return rows
+}
+
+func ordinaryGlobalArithmeticInstruction(row ordinaryGlobalArithmeticCase) string {
+	register := "AX"
+	if row.highByte {
+		register = "AH"
+	}
+	if row.three {
+		return fmt.Sprintf("%s $%d,·words+1(SB),%s", row.op, row.immediate, register)
+	}
+	return row.op + " ·words+1(SB)," + register
+}
+
+func ordinaryGlobalArithmeticSource(arch string) (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("var words [5]uint64\n")
+	word, move, seed := 8, "MOVQ", "0x1234567889abcdef"
+	if arch == "386" {
+		word, move, seed = 4, "MOVL", "0x89abcdef"
+	}
+	for index, row := range ordinaryGlobalArithmeticCases(arch) {
+		fmt.Fprintf(&declarations, "func arithmetic%d(out *[16]byte)\n", index)
+		fmt.Fprintf(&source, "TEXT ·arithmetic%d(SB),4,$0-%d\n%s out+0(FP),DI\n%s $%s,AX\n",
+			index, word, move, move, seed)
+		if row.stem == "ADC" || row.stem == "SBB" {
+			if row.carry {
+				source.WriteString("STC\n")
+			} else {
+				source.WriteString("CLC\n")
+			}
+		}
+		source.WriteString(ordinaryGlobalArithmeticInstruction(row) + "\n")
+		if arch == "386" {
+			source.WriteString("MOVL AX,0(DI)\nMOVL $0,4(DI)\n")
+		} else {
+			source.WriteString("MOVQ AX,0(DI)\n")
+		}
+		source.WriteString("SETCS 8(DI)\nSETOS 9(DI)\n")
+		if row.stem != "IMUL" {
+			source.WriteString("SETEQ 10(DI)\nSETMI 11(DI)\nSETPS 12(DI)\n")
+			if row.stem != "AND" && row.stem != "OR" && row.stem != "XOR" {
+				source.WriteString("LAHF\nMOVB AH,13(DI)\n")
+			}
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticOfficialRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	for _, arch := range []string{"amd64", "386"} {
+		names := make(map[string]bool)
+		for _, row := range ordinaryGlobalArithmeticCases(arch) {
+			names[row.op] = true
+		}
+		want := 34
+		if arch == "386" {
+			want = 25
+		}
+		if len(names) != want {
+			t.Fatal("independent opcode inventory changed", arch, len(names), want)
+		}
+		for name := range names {
+			table := "yaddl"
+			if strings.HasPrefix(name, "IMUL3") {
+				table = "yimul3"
+			} else if strings.HasPrefix(name, "IMUL") {
+				table = "yimul"
+			} else if strings.HasSuffix(name, "B") {
+				table = "yxorb"
+			}
+			pattern := `(?m)^\s*\{A` + name + `,\s*` + table + `,`
+			if len(regexp.MustCompile(pattern).FindAllString(source, -1)) != 1 {
+				t.Fatal("actual official opcode/table role changed", name, table)
+			}
+		}
+		assembly, _ := ordinaryGlobalArithmeticSource(arch)
+		goAssemblerOracleOutput(t, arch, assembly, "", true)
+	}
+	for table, row := range map[string]string{
+		"yxorb":  "{Zm_r,1,argList{Ymb,Yrb}}",
+		"yaddl":  "{Zm_r,1,argList{Yml,Yrl}}",
+		"yimul":  "{Zm_r,2,argList{Yml,Yrl}}",
+		"yimul3": "{Zibm_r,2,argList{Yi8,Yml,Yrl}}",
+	} {
+		block := regexp.MustCompile(`(?ms)^var ` + table + ` = \[\]ytab\{(.*?)^\}`).FindStringSubmatch(source)
+		if len(block) != 2 || !strings.Contains(strings.Join(strings.Fields(block[1]), ""), row+",") {
+			t.Fatal("complete official read-only source row disappeared", table, row)
+		}
+		if table == "yimul3" && !strings.Contains(strings.Join(strings.Fields(block[1]), ""), "{Zibm_r,2,argList{Yi32,Yml,Yrl}},") {
+			t.Fatal("IMUL3 Yi32 source row disappeared")
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			assembly, declarations := ordinaryGlobalArithmeticSource(target.arch)
+			for _, api := range []string{"public", "owned-context"} {
+				t.Run(api, func(t *testing.T) {
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+					ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(assembly), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("typed read-only ALU/IMUL source needs no SDK capture", err)
+					}
+					count := len(ordinaryGlobalArithmeticCases(target.arch))
+					if got := strings.Count(ir, "load volatile i"); got != count {
+						t.Fatalf("not every exact mutable source load remains observable: got %d, want %d", got, count)
+					}
+					compileLLVMToObject(t, llc, target.triple, "ordinary-arithmetic.ll", "ordinary-arithmetic.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticRejectsOtherAuthority(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"unknown-destination", "var words [5]uint64", "ADDQ ·words(SB),DX"},
+		{"unknown-CF", "var words [5]uint64", "ADCQ ·words(SB),AX"},
+		{"header", "var words []uint64", "ADDQ ·words(SB),AX"},
+		{"pointer", "var words *uint64", "IMULQ ·words(SB),AX"},
+		{"past-extent", "var words [5]uint64", "ADDQ ·words+33(SB),AX"},
+		{"padding", "var words struct { B byte; Q uint64 }", "ADDL ·words+1(SB),AX"},
+		{"memory-destination", "var words [5]uint64", "ADDQ AX,·words(SB)"},
+		{"unary-memory-RMW", "var words [5]uint64", "INCQ ·words(SB)"},
+		{"memory-memory", "var words [5]uint64", "ADDQ ·words(SB),·words+8(SB)"},
+		{"logic-AF", "var words [5]uint64", "ANDQ ·words(SB),AX\nLAHF"},
+		{"IMUL-ZF", "var words [5]uint64", "IMULQ ·words(SB),AX\nSETEQ CL"},
+		{"IMUL-PF", "var words [5]uint64", "IMULQ ·words(SB),AX\nSETPS CL"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+row.declaration+"\nfunc view() uint32\n")
+				ir, err := ordinaryGlobalReadRequest(t, pkg, ordinaryGlobalLoadBoundarySource(row.body), "amd64", "x86_64-unknown-linux-gnu", api)
+				if row.name == "memory-memory" {
+					// Encoder grammar rejection is distinct from missing NUM/context.
+					if ir != "" || err == nil || !strings.Contains(err.Error(), "operands do not match Go 1.27's register/memory rows") {
+						t.Fatal("invalid ALU memory-memory form was not rejected", err)
+					}
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("arithmetic read supplied unrelated authority", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticDeadReadStaysVolatile(t *testing.T) {
+	for _, row := range []string{"ADDQ ·words(SB),AX", "ANDQ ·words(SB),AX", "IMUL3Q $0,·words(SB),AX"} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\nvar words [5]uint64\nfunc view() uint32\n")
+				assembly := []byte("TEXT ·view(SB),4,$0-4\nMOVQ $7,AX\n" + row + "\nMOVL $0,ret+0(FP)\nRET\n")
+				goAssemblerOracleOutput(t, "amd64", string(assembly), "", true)
+				ir, err := ordinaryGlobalReadRequest(t, pkg, assembly, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if strings.Count(ir, "load volatile i64") != 1 ||
+					strings.Count(x86MulDivRoundOptimize(t, ir), "load volatile i64") != 1 {
+					t.Fatal("discarded arithmetic/zero product suppressed the actual global read")
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalArithmeticReadShapeGuards(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range ordinaryGlobalArithmeticCases(arch) {
+			for _, mutation := range []string{"raw", "origin", "return", "address", "unbound", "segment", "write"} {
+				t.Run(arch+"/"+ordinaryGlobalArithmeticInstruction(row)+"/"+mutation, func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, ordinaryGlobalArithmeticInstruction(row))
+					switch mutation {
+					case "raw":
+						ins.x86Encoded = true
+					case "origin":
+						ins.x86SourceRaw = &x86SourceRawInstruction{}
+					case "return":
+						ins.x86RawNearReturn = &x86RawNearReturnForm{}
+					case "address":
+						ins.x86AddressBits = 16
+					case "unbound":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "write":
+						ins.Args[len(ins.Args)-1] = Operand{Kind: OpSym, Sym: "·words(SB)"}
+					}
+					if _, _, known := goReadOnlyOperand(ins, arch); known {
+						t.Fatal("raw/override/write instruction acquired a named read role", mutation)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/go_ordinary_global_line_map_test.go b/go_ordinary_global_line_map_test.go
new file mode 100644
index 000000000..53ea39722
--- /dev/null
+++ b/go_ordinary_global_line_map_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func ordinaryGlobalLineMapPackage(t *testing.T, source, arch string, imported bool) (GoPackage, GoPackage, string) {
+	t.Helper()
+	owner := importedGlobalPackage(t, "example.com/linemapped", arch,
+		[]string{source, "package state\nfunc view() uint32\n"}, map[string]*types.Package{"unsafe": types.Unsafe})
+	if imported {
+		return importedGlobalConsumer(t, owner, "Flags", arch), owner, importedGlobalOperand(owner.Path, "Flags", 0)
+	}
+	return owner, owner, "·Flags(SB)"
+}
+
+func ordinaryGlobalLineMapObjects(t *testing.T, source string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, ownerKind := range []string{"same-package", "direct-import"} {
+			for _, api := range []string{"public", "owned-context"} {
+				t.Run(arch+"/"+ownerKind+"/"+api, func(t *testing.T) {
+					pkg, owner, operand := ordinaryGlobalLineMapPackage(t, source, arch, ownerKind == "direct-import")
+					assembly := ordinaryGlobalReadAssembly("", "CMPB "+operand+",$0\n")
+					ir, err := importedGlobalReadRequest(t, pkg, assembly, arch, triple, api, true, nil)
+					if err != nil || ir == "" {
+						t.Fatal("diagnostic line mapping changed actual Go storage ownership", err)
+					}
+					importedGlobalRequireMutable(t, ir, owner.Path+".Flags")
+					if strings.Contains(ir, "@foreign.Flags") || strings.Contains(ir, "@\"foreign.Flags\"") {
+						t.Fatal("diagnostic filename became the native storage namespace")
+					}
+					compileLLVMToObject(t, llc, triple, "line-map.ll", "line-map.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalSourceLineMaps(t *testing.T) {
+	// cmd/compile's Line Directives specify diagnostic coordinates only.
+	// Both forms retain their actual complete syntax and typed package owner.
+	for name, directive := range map[string]string{"slash": "//line imaginary/foreign.go:71:9\n", "block": "/*line imaginary/foreign.go:71:9*/"} {
+		t.Run(name, func(t *testing.T) {
+			ordinaryGlobalLineMapObjects(t, "package state\n"+directive+"var Flags bool\n")
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalActualCoverSource(t *testing.T) {
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "original.go"), filepath.Join(dir, "instrumented.go")
+	source := "package state\nvar Flags bool\nfunc Flip(value bool) bool { Flags = value; return Flags }\n"
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"),
+		"tool", "cover", "-mode=count", "-var=LineMapCoverage", "-o", output, input)
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local")
+	if diagnostics, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual selected Go coverage instrumentation failed: %v\n%s", err, diagnostics)
+	}
+	generated, err := os.ReadFile(output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasPrefix(string(generated), "//line ") || !strings.Contains(string(generated), "LineMapCoverage.Count") {
+		t.Fatal("actual cover output lacks its source mapping or executed-statement counters")
+	}
+	owner := importedGlobalPackage(t, "example.com/linemapped", "amd64", []string{string(generated)}, nil)
+	if owner.Types.Scope().Lookup("LineMapCoverage") == nil {
+		t.Fatal("the generated coverage declaration was removed before type checking")
+	}
+	ordinaryGlobalLineMapObjects(t, string(generated))
+}
+
+func TestGoModuleOrdinaryGlobalLineMapRetainsOwnerBoundaries(t *testing.T) {
+	const directive = "//line imaginary/foreign.go:71:9\n"
+	for _, mutation := range []string{"linkname", "typed-import", "layout", "filename-as-symbol", "resolver", "invalid-line"} {
+		t.Run(mutation, func(t *testing.T) {
+			source := "package state\n" + directive + "var Flags bool\n"
+			if mutation == "linkname" {
+				source = "package state\nimport _ \"unsafe\"\n" + directive + "//go:linkname Flags foreign.Flags\nvar Flags bool\n"
+			}
+			pkg, owner, operand := ordinaryGlobalLineMapPackage(t, source, "amd64", true)
+			switch mutation {
+			case "typed-import":
+				_, other, _ := ordinaryGlobalLineMapPackage(t, source, "amd64", true)
+				pkg.Imports[owner.Path] = other.Types
+			case "layout":
+				_, other, _ := ordinaryGlobalLineMapPackage(t, strings.Replace(source, "bool", "uint64", 1), "amd64", true)
+				pkg.ImportSyntax[owner.Path] = other.Syntax
+			case "filename-as-symbol":
+				operand = "foreign·Flags(SB)"
+			case "invalid-line":
+				comment := owner.Syntax[0].Comments[0].List[0]
+				comment.Text = "//line imaginary/foreign.go:0"
+				formatted, err := goReadOnlySyntax(owner)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, parseErr := parser.ParseFile(token.NewFileSet(), "snapshot.go", formatted[0], parser.ParseComments)
+				t.Logf("post-parse slash comment: formatted=%q parse error=%v", formatted[0], parseErr)
+				// An AST comment has no retained physical line coordinates here:
+				// a formatted //line may no longer start a line. The block form
+				// remains a directive at any position; prove the actual snapshot
+				// is invalid before asking the binder to reject it.
+				comment.Text = "/*line imaginary/foreign.go:0*/"
+				formatted, err = goReadOnlySyntax(owner)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, parseErr = parser.ParseFile(token.NewFileSet(), "snapshot.go", formatted[0], parser.ParseComments)
+				if parseErr == nil || !strings.Contains(parseErr.Error(), "invalid line number: 0") {
+					t.Fatalf("negative snapshot lacks an active invalid directive: %q: %v", formatted[0], parseErr)
+				}
+			}
+			assembly := ordinaryGlobalReadAssembly("", "CMPB "+operand+",$0\n")
+			ir, err := importedGlobalReadRequest(t, pkg, assembly, "amd64", "x86_64-unknown-linux-gnu", "owned-context", true,
+				func(options *GoModuleOptions) {
+					if mutation == "resolver" {
+						resolve := options.ResolveSym
+						options.ResolveSym = func(symbol string) string {
+							if resolve(symbol) == owner.Path+".Flags" {
+								return "foreign.Flags"
+							}
+							return resolve(symbol)
+						}
+					}
+				})
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("line mapping lent alias, import, layout or symbol authority", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalLineMapInvalidOriginalSource(t *testing.T) {
+	for name, directive := range map[string]string{"slash": "//line imaginary/foreign.go:0\n", "block": "/*line imaginary/foreign.go:0*/"} {
+		t.Run(name, func(t *testing.T) {
+			// Original invalid directives fail before a typed package exists;
+			// this is distinct from a subsequently mutated AST comment.
+			source := "package state\n" + directive + "var Flags bool\n"
+			_, err := parser.ParseFile(token.NewFileSet(), "original.go", source, parser.ParseComments)
+			if err == nil || !strings.Contains(err.Error(), "invalid line number: 0") {
+				t.Fatal("original source parser accepted an invalid line directive", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalLineMapMutationRevokesBinding(t *testing.T) {
+	for form, directive := range map[string]string{"slash": "//line imaginary/foreign.go:71:9\n", "block": "/*line imaginary/foreign.go:71:9*/"} {
+		for _, imported := range []bool{false, true} {
+			name := "same-package"
+			if imported {
+				name = "direct-import"
+			}
+			t.Run(form+"/"+name, func(t *testing.T) {
+				pkg, owner, operand := ordinaryGlobalLineMapPackage(t, "package state\n"+directive+"var Flags bool\n", "amd64", imported)
+				file, err := Parse(ArchAMD64, string(ordinaryGlobalReadAssembly("", "CMPB "+operand+",$0\n")))
+				if err != nil {
+					t.Fatal(err)
+				}
+				binding, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", "amd64"), "amd64", testResolveSym(pkg.Path))
+				if err != nil || binding == nil {
+					t.Fatal("actual source-mapped declaration did not bind", err)
+				}
+				changed := false
+				for _, group := range owner.Syntax[0].Comments {
+					for _, comment := range group.List {
+						if strings.Contains(comment.Text, "imaginary/foreign.go") {
+							comment.Text = strings.Replace(comment.Text, "foreign.go", "changed.go", 1)
+							changed = true
+						}
+					}
+				}
+				if !changed {
+					t.Fatal("source mapping was dropped from the original syntax snapshot")
+				}
+				if err := binding.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed source-mapping comment retained its old binding", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_ordinary_global_load_runtime_test.go b/go_ordinary_global_load_runtime_test.go
new file mode 100644
index 000000000..7bea8d6f3
--- /dev/null
+++ b/go_ordinary_global_load_runtime_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func ordinaryGlobalLoadExpected(row ordinaryGlobalLoadCase, seed uint64) uint64 {
+	var storage [40]byte
+	for index := 0; index < 5; index++ {
+		binary.LittleEndian.PutUint64(storage[8*index:], seed^(uint64(index)*0x9e3779b97f4a7c15))
+	}
+	var value uint64
+	for index := 0; index < row.readBits/8; index++ {
+		value |= uint64(storage[1+index]) << uint(8*index)
+	}
+	if row.signed && value&(uint64(1)<<uint(row.readBits-1)) != 0 && row.readBits < 64 {
+		value |= ^uint64(0) << uint(row.readBits)
+	}
+	if row.highByte {
+		return 0x1234567889abcdef&^uint64(0xff00) | (value&255)<<8
+	}
+	switch row.writeBits {
+	case 8:
+		return 0x1234567889abcdef&^uint64(255) | value&255
+	case 16:
+		return 0x1234567889abcdef&^uint64(65535) | value&65535
+	case 32:
+		return uint64(uint32(value))
+	default:
+		return value
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixGoModuleOrdinaryGlobalLoads(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	assembly, declarations := ordinaryGlobalLoadSource("amd64")
+	rows := ordinaryGlobalLoadCases("amd64")
+	patterns := []uint64{0, 1, 0x7f00, 0x8000, 0xff00, 0x7fff00, 0x800000,
+		0xffff00, 0x7fffffff00, 0x8000000000, 0xffffffff00, ^uint64(0), 0x0123456789abcdef}
+	var goChecks, cChecks, cDeclarations strings.Builder
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	// Use a simple linked namespace while retaining the real checked Types
+	// package. No SDK/native-storage owner or initializer is substituted.
+	const linkedPackage = "ordinaryglobals"
+	for index := range rows {
+		fmt.Fprintf(&cDeclarations, "extern uint64_t load%d(void) __asm__(\"%s%s.load%d\");\n",
+			index, prefix, linkedPackage, index)
+	}
+	for pattern, seed := range patterns {
+		fmt.Fprintf(&goChecks, "for i:=range words { words[i]=uint64(%d)^(uint64(i)*0x9e3779b97f4a7c15) }\n", seed)
+		fmt.Fprintf(&cChecks, "for(unsigned i=0;i<5;++i) storage[i]=UINT64_C(%d)^((uint64_t)i*UINT64_C(0x9e3779b97f4a7c15));\n", seed)
+		for index, row := range rows {
+			want := ordinaryGlobalLoadExpected(row, seed)
+			fmt.Fprintf(&goChecks, "if got:=load%d(); got!=uint64(%d) { panic(fmt.Sprintf(\"pattern=%d load=%d got=%%x\",got)) }\n",
+				index, want, pattern, index)
+			fmt.Fprintf(&cChecks, "if(load%d()!=UINT64_C(%d)) { fprintf(stderr,\"pattern=%d load=%d mismatch\\n\");return 1; }\n",
+				index, want, pattern, index)
+		}
+	}
+	want := fmt.Sprintf("%d mutable global loads x %d patterns\n", len(rows), len(patterns))
+	goSource := "package main\nimport \"fmt\"\n" + declarations +
+		"func main(){\n" + goChecks.String() + fmt.Sprintf("fmt.Print(%q)\n}\n", want)
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module originalglobalload\n\ngo 1.20\n", "main.go": goSource, "original_amd64.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	executable := filepath.Join(dir, "original")
+	if runtime.GOOS == "windows" {
+		executable += ".exe"
+	}
+	command := exec.Command("go", "build", "-p=2", "-o", executable, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOOS="+runtime.GOOS, "GOARCH=amd64", "CGO_ENABLED=0",
+		"GOWORK=off", "GOENV=off", "GOTOOLCHAIN=local")
+	x86FloatCompareCaptureCommand(t, command)
+	if output := execution.run(t, executable); string(output) != want {
+		t.Fatalf("original complete Go-source numerical oracle: %q", output)
+	}
+	cSource := "#include <stdint.h>\n#include <stdio.h>\n" + cDeclarations.String() +
+		fmt.Sprintf("uint64_t storage[5] __asm__(\"%s%s.words\");\n", prefix, linkedPackage) +
+		"int main(void){\n" + cChecks.String() + fmt.Sprintf("printf(%q);return 0;\n}\n", want)
+	for _, api := range []string{"public", "owned-context"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			pkg.Path = linkedPackage
+			ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(assembly), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"},
+				{"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "ordinary-global-load", pipeline.ir, cSource, pipeline.level)
+					if string(output) != want {
+						t.Fatalf("mutable global numerical receipt: %q", output)
+					}
+					t.Log(strings.TrimSpace(want))
+				})
+			}
+		})
+	}
+}
diff --git a/go_ordinary_global_load_test.go b/go_ordinary_global_load_test.go
new file mode 100644
index 000000000..f515bfcd7
--- /dev/null
+++ b/go_ordinary_global_load_test.go
@@ -0,0 +1,252 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type ordinaryGlobalLoadCase struct {
+	op                       string
+	readBits, writeBits      int
+	signed, mode64, highByte bool
+}
+
+// Independent complete scalar MOV/extension inventory, not a production-spec
+// iteration. MOVD/MOVDQ2Q are Go source aliases for the MOVQ GP grammar.
+func ordinaryGlobalLoadCases(arch string) []ordinaryGlobalLoadCase {
+	var result []ordinaryGlobalLoadCase
+	for _, row := range []ordinaryGlobalLoadCase{
+		{op: "MOVB", readBits: 8, writeBits: 8},
+		{op: "MOVW", readBits: 16, writeBits: 16},
+		{op: "MOVL", readBits: 32, writeBits: 32},
+		{op: "MOVQ", readBits: 64, writeBits: 64, mode64: true},
+		{op: "MOVD", readBits: 64, writeBits: 64, mode64: true},
+		{op: "MOVDQ2Q", readBits: 64, writeBits: 64, mode64: true},
+		{op: "MOVBWSX", readBits: 8, writeBits: 16, signed: true},
+		{op: "MOVBWZX", readBits: 8, writeBits: 16},
+		{op: "MOVBLSX", readBits: 8, writeBits: 32, signed: true},
+		{op: "MOVBLZX", readBits: 8, writeBits: 32},
+		{op: "MOVBQSX", readBits: 8, writeBits: 64, signed: true, mode64: true},
+		{op: "MOVBQZX", readBits: 8, writeBits: 64, mode64: true},
+		{op: "MOVWLSX", readBits: 16, writeBits: 32, signed: true},
+		{op: "MOVWLZX", readBits: 16, writeBits: 32},
+		{op: "MOVWQSX", readBits: 16, writeBits: 64, signed: true, mode64: true},
+		{op: "MOVWQZX", readBits: 16, writeBits: 64, mode64: true},
+		{op: "MOVLQSX", readBits: 32, writeBits: 64, signed: true, mode64: true},
+		{op: "MOVLQZX", readBits: 32, writeBits: 64},
+		{op: "MOVSWW", readBits: 16, writeBits: 16, signed: true},
+		{op: "MOVZWW", readBits: 16, writeBits: 16},
+		{op: "MOVB", readBits: 8, writeBits: 8, highByte: true},
+	} {
+		if arch == "386" && row.mode64 {
+			continue
+		}
+		if arch == "386" && row.op == "MOVLQZX" {
+			row.writeBits = 32
+		}
+		result = append(result, row)
+	}
+	return result
+}
+
+func ordinaryGlobalLoadSource(arch string) (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("var words [5]uint64\n")
+	for index, row := range ordinaryGlobalLoadCases(arch) {
+		name := fmt.Sprintf("load%d", index)
+		fmt.Fprintf(&declarations, "func %s() uint64\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\n", name)
+		if arch == "386" {
+			source.WriteString("MOVL $0x89abcdef,AX\n")
+		} else {
+			source.WriteString("MOVQ $0x1234567889abcdef,AX\n")
+		}
+		register := "AX"
+		if row.highByte {
+			register = "AH"
+		}
+		// Deliberately unaligned and spanning adjacent array elements. The
+		// declaration supplies numerical bytes, never an alignment assertion.
+		fmt.Fprintf(&source, "%s ·words+1(SB),%s\n", row.op, register)
+		if arch == "386" {
+			source.WriteString("MOVL AX,ret+0(FP)\nMOVL $0,ret+4(FP)\nRET\n")
+		} else {
+			source.WriteString("MOVQ AX,ret+0(FP)\nRET\n")
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func TestGoModuleOrdinaryGlobalLoadCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := ordinaryGlobalLoadSource(target.arch)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"public", "owned-context"} {
+				t.Run(api, func(t *testing.T) {
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+					ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete typed integer loads need no SDK capture", err)
+					}
+					if got := strings.Count(ir, "load volatile "); got != len(ordinaryGlobalLoadCases(target.arch)) {
+						t.Fatalf("lost exact mutable reads: got %d, want %d", got, len(ordinaryGlobalLoadCases(target.arch)))
+					}
+					for _, row := range ordinaryGlobalLoadCases(target.arch) {
+						if !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", row.readBits)) {
+							t.Fatal("source width widened or disappeared", row.op, row.readBits)
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "ordinary-global-load.ll", "ordinary-global-load.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func ordinaryGlobalLoadBoundarySource(body string) []byte {
+	// The SIMD extraction makes the complete source observer mandatory even
+	// when the attempted load's value is overwritten before the final return.
+	return []byte("TEXT ·view(SB),4,$0-4\nMOVL $7,AX\n" + body +
+		"\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n")
+}
+
+func TestGoModuleOrdinaryGlobalLoadRejectsOtherAuthority(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"past-object", "var words [5]uint64", "MOVQ ·words+33(SB),AX"},
+		{"negative-offset", "var words [5]uint64", "MOVB ·words-1(SB),AX"},
+		{"padding", "var words struct { A byte; B uint64 }", "MOVB ·words+1(SB),AX"},
+		{"cross-padding", "var words struct { A byte; B uint64 }", "MOVW ·words(SB),AX"},
+		{"blank-field", "var words struct { _ uint64; B uint64 }", "MOVQ ·words(SB),AX"},
+		{"pointer", "var words *uint64", "MOVQ ·words(SB),AX"},
+		{"pointer-array", "var words [5]*uint64", "MOVQ ·words(SB),AX"},
+		{"slice", "var words []uint64", "MOVQ ·words(SB),AX"},
+		{"string", "var words string", "MOVQ ·words(SB),AX"},
+		{"function", "var words func()", "MOVQ ·words(SB),AX"},
+		{"unknown", "var words [5]uint64", "MOVQ ·missing(SB),AX"},
+		{"foreign", "var words [5]uint64", "MOVQ foreign.words(SB),AX"},
+		{"write", "var words [5]uint64", "MOVQ ·words(SB),AX\nMOVQ AX,·words(SB)"},
+		{"rmw", "var words [5]uint64", "MOVQ ·words(SB),AX\nINCQ ·words(SB)"},
+		{"address", "var words [5]uint64", "LEAQ ·words(SB),DX\nMOVQ (DX),AX"},
+		{"raw", "var words [5]uint64", "BYTE $0x48\nBYTE $0x8b\nBYTE $0x05\nLONG $0\nMOVQ ·words(SB),AX"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+row.declaration+"\nfunc view() uint32\n")
+				ir, err := ordinaryGlobalReadRequest(t, pkg, ordinaryGlobalLoadBoundarySource(row.body),
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				rejected := errors.Is(err, ErrProbeNeedsContext)
+				if row.name == "raw" {
+					// This is invalid literal placement, rejected by the decoder
+					// before any named storage role, not missing caller context.
+					rejected = err != nil && strings.Contains(err.Error(), "RIP-relative literal [7,15) is outside directive group")
+				}
+				if ir != "" || !rejected {
+					t.Fatalf("load declaration lent other authority: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalLoadRetainsDeclarationAndRawAPIBoundaries(t *testing.T) {
+	source, declarations := ordinaryGlobalLoadSource("amd64")
+	for _, mutation := range []string{"missing-types", "missing-syntax", "changed-type", "missing-variable"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			switch mutation {
+			case "missing-types":
+				pkg.Types = nil
+			case "missing-syntax":
+				pkg.Syntax = nil
+			case "changed-type":
+				pkg.Syntax = mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+strings.Replace(declarations, "[5]uint64", "[5]*uint64", 1)).Syntax
+			case "missing-variable":
+				pkg.Syntax = mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+strings.Replace(declarations, "var words [5]uint64", "", 1)).Syntax
+			}
+			ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", "public")
+			if ir != "" || err == nil {
+				t.Fatal("unmatched typed declarations acquired numerical storage", err)
+			}
+		})
+	}
+	pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+	for _, api := range []string{"text", "module"} {
+		t.Run("raw-"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("raw API inherited GoModule global declarations", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalLoadBindingRemainsLive(t *testing.T) {
+	source, declarations := ordinaryGlobalLoadSource("amd64")
+	for _, mutation := range []string{"source", "syntax", "resolver", "raw-read", "write-read", "grouped-source"} {
+		t.Run(mutation, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			wrongResolver := false
+			resolve := func(symbol string) string {
+				if wrongResolver && strings.Contains(symbol, "words") {
+					return "foreign.words"
+				}
+				return testResolveSym(pkg.Path)(symbol)
+			}
+			binding, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", "amd64"), "amd64", resolve)
+			if err != nil || binding == nil {
+				t.Fatal("complete load did not bind its real declared storage", err)
+			}
+			ins := file.Funcs[0].Instrs[2]
+			if binding.readFor(ins, "amd64") == nil {
+				t.Fatal("exact typed source read has no per-instruction fact")
+			}
+			switch mutation {
+			case "grouped-source":
+				ins.Args = append([]Operand(nil), ins.Args...)
+				ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Sym: "·words(SB)", Off: 1}}
+				read := binding.readFor(ins, "amd64")
+				if read == nil || !reflect.DeepEqual(read.operand, ins.Args[0]) || read.width != 1 {
+					t.Fatal("grouped SB source lost its exact operand/width")
+				}
+				return
+			case "source":
+				binding.file.Funcs[0].Instrs[2].Args[0].Sym = "·words+39(SB)"
+			case "syntax":
+				pkg.Syntax[0].Name.Name = "foreign"
+			case "resolver":
+				wrongResolver = true
+			case "raw-read":
+				ins.x86Encoded = true
+				if binding.readFor(ins, "amd64") != nil {
+					t.Fatal("raw instruction borrowed a named read")
+				}
+				return
+			case "write-read":
+				ins.Args[0], ins.Args[1] = ins.Args[1], ins.Args[0]
+				if binding.readFor(ins, "amd64") != nil {
+					t.Fatal("write borrowed a read fact")
+				}
+				return
+			}
+			if err := binding.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed producer remained usable", err)
+			}
+		})
+	}
+}
diff --git a/go_ordinary_global_read.go b/go_ordinary_global_read.go
new file mode 100644
index 000000000..50f25bf60
--- /dev/null
+++ b/go_ordinary_global_read.go
@@ -0,0 +1,610 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// This declaration-only directory describes numerical reads of Go-defined
+// variables. It is deliberately separate from emitted DATA, writable objects,
+// address values and the SDK's native compiler-record/source capabilities.
+type goReadOnlyStorage struct {
+	pkg          GoPackage
+	sizes        types.Sizes
+	file         *File
+	original     [32]byte
+	declarations map[string]*goReadOnlyDeclaration
+	objects      map[string]goReadOnlyObject
+	symbols      map[string]string
+	resolve      func(string) string
+	failure      error
+	funcvalReads map[string]goFuncvalReadPlan
+}
+
+// An empty path denotes the current package; other keys are its actual direct
+// imports. Each translation rechecks these declarations without capturing an
+// SDK, reloading a package, or retaining observations beyond this call.
+type goReadOnlyDeclaration struct {
+	path    string
+	pkg     GoPackage
+	syntax  []string
+	objects map[string]goReadOnlyObject
+}
+
+type goReadOnlyObject struct {
+	variable *types.Var
+	native   string
+	imported bool
+	size     int64
+	spans    [][2]int64 // half-open numerical byte intervals; padding is absent
+	shape    string
+}
+
+type goReadOnlyRead struct {
+	operand Operand
+	width   int64
+}
+
+func (read *goReadOnlyRead) allows(operand Operand, width int64) bool {
+	return read != nil && width == read.width && reflect.DeepEqual(operand, read.operand)
+}
+
+// These complete named rows have paired exact-width volatile emitters. This
+// query describes a read role only; it cannot establish storage or NUM itself.
+func goReadOnlyOperand(ins Instr, arch string) (Operand, int64, bool) {
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil {
+		return Operand{}, 0, false
+	}
+	if form, known := x86ScalarStaticLoadProperties(ins, arch); known {
+		return form.source, form.bytes, true
+	}
+	if operand, width, known := goReadOnlyArithmeticOperand(ins, arch); known {
+		return operand, width, true
+	}
+	if form, known := x86NumericalSBVectorReadProperties(ins, arch); known {
+		return ins.Args[form.operand], form.spec.sourceBytes, true
+	}
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.memory < 0 {
+		return Operand{}, 0, false
+	}
+	return form.args[form.memory], int64(form.bits / 8), true
+}
+
+// Reuse the complete ALU and explicit IMUL grammars. A source declaration
+// establishes neither a memory destination nor an implicit accumulator pair.
+func goReadOnlyArithmeticOperand(ins Instr, arch string) (Operand, int64, bool) {
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil &&
+		!form.spec.unary && !form.spec.bitString && form.destination.Kind == OpReg {
+		if _, valid := x86StaticSBReadAddress(form.source, arch); valid {
+			return form.source, int64(form.spec.bits / 8), true
+		}
+	}
+	if form, known, err := x86ExplicitIMULProperties(ins.Op, ins, arch); known && err == nil {
+		if _, valid := x86StaticSBReadAddress(form.source, arch); valid {
+			return form.source, int64(form.bits / 8), true
+		}
+	}
+	return Operand{}, 0, false
+}
+
+func (source *goReadOnlyStorage) readFor(ins Instr, arch string) *goReadOnlyRead {
+	if source == nil {
+		return nil
+	}
+	operand, width, valid := goReadOnlyOperand(ins, arch)
+	if !valid || !source.allows(operand, width, arch) {
+		return nil
+	}
+	address, _ := x86StaticSBSourceAddress(operand, arch)
+	if source.object(address.symbol).imported && !goReadOnlyImportedComparison(ins, arch) {
+		return nil
+	}
+	return &goReadOnlyRead{operand: operand, width: width}
+}
+
+func goReadOnlyImportedComparison(ins Instr, arch string) bool {
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	return known && err == nil && form.memory >= 0 && !form.test
+}
+
+func goReadOnlyContext(format string, args ...any) error {
+	return fmt.Errorf("%w: ordinary Go global read: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func goReadOnlyName(pkgPath, symbol string) string {
+	if strings.HasPrefix(symbol, "·") {
+		symbol = strings.TrimPrefix(symbol, "·")
+	} else if strings.HasPrefix(symbol, pkgPath+".") {
+		symbol = strings.TrimPrefix(symbol, pkgPath+".")
+	}
+	if !token.IsIdentifier(symbol) || symbol == "_" {
+		return ""
+	}
+	return symbol
+}
+
+func goReadOnlyLocalName(pkg GoPackage, symbol string) string {
+	if name := goReadOnlyName(pkg.Path, symbol); name != "" {
+		return name
+	}
+	return goReadOnlyName(pkg.Types.Path(), symbol)
+}
+
+func goReadOnlyImportedName(symbol string) (path, name string) {
+	symbol = strings.ReplaceAll(strings.ReplaceAll(symbol, "∕", "/"), "·", ".")
+	separator := strings.LastIndexByte(symbol, '.')
+	if separator <= 0 || !token.IsIdentifier(symbol[separator+1:]) || symbol[separator+1:] == "_" {
+		return "", ""
+	}
+	return symbol[:separator], symbol[separator+1:]
+}
+
+func goReadOnlyImportedPackage(pkg GoPackage, path string) (GoPackage, error) {
+	dependency := pkg.Imports[path]
+	if dependency == nil || dependency == pkg.Types || dependency.Path() != path || !dependency.Complete() || dependency.Scope() == nil {
+		return GoPackage{}, goReadOnlyContext("missing complete typed import %q", path)
+	}
+	found := false
+	for _, actual := range pkg.Types.Imports() {
+		if actual == dependency {
+			found = true
+		}
+	}
+	if !found {
+		return GoPackage{}, goReadOnlyContext("import %q differs from the actual typed dependency", path)
+	}
+	imports := make(map[string]*types.Package)
+	for _, actual := range dependency.Imports() {
+		if actual == nil || !actual.Complete() || actual.Scope() == nil || actual.Path() == "" || imports[actual.Path()] != nil {
+			return GoPackage{}, goReadOnlyContext("import %q has incomplete or duplicate dependencies", path)
+		}
+		imports[actual.Path()] = actual
+	}
+	return GoPackage{Path: path, Types: dependency, Imports: imports, Syntax: pkg.ImportSyntax[path]}, nil
+}
+
+func (source *goReadOnlyStorage) object(symbol string) goReadOnlyObject {
+	if name := goReadOnlyLocalName(source.pkg, symbol); name != "" {
+		return source.objects[gosym.PackagePrefix(source.pkg.Path)+"."+name]
+	}
+	path, name := goReadOnlyImportedName(symbol)
+	if path != "" && source.declarations[path] != nil {
+		return source.objects[gosym.PackagePrefix(path)+"."+name]
+	}
+	return goReadOnlyObject{}
+}
+
+func goReadOnlySyntax(pkg GoPackage) ([]string, error) {
+	if len(pkg.Syntax) == 0 || len(pkg.Syntax) > 256 {
+		return nil, goReadOnlyContext("missing or excessive declaration syntax")
+	}
+	result := make([]string, len(pkg.Syntax))
+	for index, file := range pkg.Syntax {
+		if file == nil || file.Name == nil || file.Name.Name != pkg.Types.Name() {
+			return nil, goReadOnlyContext("declaration package differs")
+		}
+		var b bytes.Buffer
+		if err := format.Node(&b, token.NewFileSet(), file); err != nil || b.Len() > 16<<20 {
+			return nil, goReadOnlyContext("declaration syntax is invalid or excessive")
+		}
+		result[index] = b.String()
+	}
+	return result, nil
+}
+
+type goReadOnlyImporter map[string]*types.Package
+
+func (imports goReadOnlyImporter) Import(path string) (*types.Package, error) {
+	if path == "unsafe" {
+		return types.Unsafe, nil
+	}
+	if pkg := imports[path]; pkg != nil && pkg.Path() == path && pkg.Complete() {
+		return pkg, nil
+	}
+	return nil, goReadOnlyContext("missing actual typed import %q", path)
+}
+
+// Recheck already supplied syntax and imports, never go list, an ambient
+// importer, a compiler archive capture or the execution of an initializer.
+func goReadOnlyTypedSyntax(pkg GoPackage, syntax []string, sizes types.Sizes, objects map[string]goReadOnlyObject) (*types.Package, error) {
+	set := token.NewFileSet()
+	files := make([]*ast.File, len(syntax))
+	for index, source := range syntax {
+		file, err := parser.ParseFile(set, fmt.Sprintf("global-source-%d.go", index), source, parser.ParseComments)
+		if err != nil {
+			return nil, goReadOnlyContext("declaration syntax cannot be rechecked")
+		}
+		files[index] = file
+	}
+	typed, err := (&types.Config{Importer: goReadOnlyImporter(pkg.Imports), Sizes: sizes}).Check(pkg.Types.Path(), set, files, nil)
+	if err != nil {
+		return nil, goReadOnlyContext("syntax does not match a complete typed package: %v", err)
+	}
+	if err := goReadOnlyCheckAliases(files, typed, objects); err != nil {
+		return nil, err
+	}
+	if goFuncvalObjects(objects) {
+		if err := goFuncvalCheckConvention(pkg.Syntax, typed, objects); err != nil {
+			return nil, err
+		}
+	}
+	return typed, nil
+}
+
+// This source-only identity check is shared with the actual frame typecheck;
+// reusing it must not trigger a second package typecheck or tool invocation.
+func goReadOnlyCheckAliases(files []*ast.File, typed *types.Package, objects map[string]goReadOnlyObject) error {
+	selfLinknames := make(map[string]bool)
+	for _, file := range files {
+		for _, comments := range file.Comments {
+			for _, comment := range comments.List {
+				// Line directives change diagnostic positions, not package or
+				// linker identity. Retain them in the complete syntax snapshot
+				// and parser/type check; linkname aliases remain separate below.
+				words := strings.Fields(comment.Text)
+				if len(words) >= 2 && words[0] == "//go:linkname" {
+					if objects[words[1]].variable != nil {
+						if len(words) != 2 || selfLinknames[words[1]] {
+							return goReadOnlyContext("aliased or duplicate global declaration needs its own binding")
+						}
+						selfLinknames[words[1]] = true
+					}
+					if len(words) >= 3 {
+						for _, object := range objects {
+							if words[2] == object.native {
+								return goReadOnlyContext("another declaration aliases the requested global")
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	if len(selfLinknames) != 0 {
+		unsafeImported := false
+		for _, dependency := range typed.Imports() {
+			unsafeImported = unsafeImported || dependency == types.Unsafe
+		}
+		if !unsafeImported {
+			return goReadOnlyContext("self-linkname declaration lacks its actual unsafe import")
+		}
+	}
+	return nil
+}
+
+func goReadOnlyLayout(typ types.Type, sizes types.Sizes) (size int64, spans [][2]int64, shape string, resultErr error) {
+	defer func() {
+		if recover() != nil {
+			size, spans, shape, resultErr = 0, nil, "", goReadOnlyContext("incomplete target type layout")
+		}
+	}()
+	size = sizes.Sizeof(typ)
+	if size <= 0 || size > 1<<20 {
+		return 0, nil, "", goReadOnlyContext("global numerical extent is empty or excessive")
+	}
+	var description strings.Builder
+	visits := 0
+	var visit func(types.Type, int64, int) error
+	visit = func(current types.Type, base int64, depth int) error {
+		visits++
+		if visits > 4096 || description.Len() > 64<<10 {
+			return goReadOnlyContext("global layout traversal/description budget exceeded")
+		}
+		width := sizes.Sizeof(current)
+		if depth > 64 || width < 0 || base < 0 || base > size || width > size-base {
+			return goReadOnlyContext("global type layout exceeds its numerical extent")
+		}
+		fmt.Fprintf(&description, "[%T:%d:%d]", current, base, width)
+		if named, ok := current.(*types.Named); ok {
+			path := ""
+			if named.Obj().Pkg() != nil {
+				path = named.Obj().Pkg().Path()
+			}
+			if len(path) > 4096 || len(named.Obj().Name()) > 4096 || description.Len()+len(path)+len(named.Obj().Name())+32 > 64<<10 {
+				return goReadOnlyContext("global layout description budget exceeded")
+			}
+			fmt.Fprintf(&description, "named:%s:%s;", path, named.Obj().Name())
+		}
+		switch underlying := current.Underlying().(type) {
+		case *types.Basic:
+			if underlying.Info()&(types.IsInteger|types.IsFloat|types.IsBoolean) == 0 || underlying.Info()&types.IsUntyped != 0 {
+				return goReadOnlyContext("global contains pointer/header or nonnumerical storage")
+			}
+			fmt.Fprintf(&description, "basic:%d;", underlying.Kind())
+			if width != 0 {
+				end := base + width
+				if len(spans) != 0 && spans[len(spans)-1][1] == base {
+					spans[len(spans)-1][1] = end
+				} else {
+					spans = append(spans, [2]int64{base, end})
+				}
+			}
+		case *types.Array:
+			fmt.Fprintf(&description, "array:%d;", underlying.Len())
+			if underlying.Len() > 1<<20 {
+				return goReadOnlyContext("global array exceeds its type bound")
+			}
+			stride := sizes.Sizeof(underlying.Elem())
+			if stride == 0 || underlying.Len() == 0 {
+				return nil // Repeated zero-width elements supply no bytes or permission.
+			}
+			for index := int64(0); index < underlying.Len(); index++ {
+				if err := visit(underlying.Elem(), base+index*stride, depth+1); err != nil {
+					return err
+				}
+			}
+		case *types.Struct:
+			fields := make([]*types.Var, underlying.NumFields())
+			for index := range fields {
+				fields[index] = underlying.Field(index)
+			}
+			for index, offset := range sizes.Offsetsof(fields) {
+				if len(fields[index].Name()) > 4096 || len(underlying.Tag(index)) > 4096 ||
+					description.Len()+len(fields[index].Name())+6*len(underlying.Tag(index))+64 > 64<<10 {
+					return goReadOnlyContext("global layout description budget exceeded")
+				}
+				fmt.Fprintf(&description, "field:%s:%d:%q;", fields[index].Name(), offset, underlying.Tag(index))
+				if fields[index].Name() != "_" {
+					if err := visit(fields[index].Type(), base+offset, depth+1); err != nil {
+						return err
+					}
+				}
+			}
+		default:
+			return goReadOnlyContext("global contains pointer/header or nonnumerical storage")
+		}
+		return nil
+	}
+	if err := visit(typ, 0, 0); err != nil {
+		return 0, nil, "", err
+	}
+	if description.Len() > 64<<10 {
+		return 0, nil, "", goReadOnlyContext("global layout description budget exceeded")
+	}
+	return size, spans, description.String(), nil
+}
+
+func bindGoReadOnlyStorage(pkg GoPackage, file *File, sizes types.Sizes, arch string, resolve func(string) string) (*goReadOnlyStorage, error) {
+	if file == nil || file.Arch != ArchAMD64 || arch != "amd64" && arch != "386" || pkg.Types == nil || pkg.Types.Scope() == nil {
+		return nil, nil
+	}
+	// Cost-query only complete named numerical-read roles. Other
+	// instructions and emitted DATA/GLOBL keep their existing consumers.
+	assemblyNames := make(map[string]bool)
+	for _, global := range file.Globl {
+		assemblyNames[goReadOnlyLocalName(pkg, global.Sym)] = true
+	}
+	for _, datum := range file.Data {
+		assemblyNames[goReadOnlyLocalName(pkg, datum.Sym)] = true
+	}
+	var emitted map[string]bool
+	emittedOwns := func(native string) bool {
+		if emitted == nil {
+			emitted = make(map[string]bool)
+			for _, global := range file.Globl {
+				emitted[resolveAssemblyDataSymbol(global.Sym, resolve)] = true
+			}
+			for _, datum := range file.Data {
+				emitted[resolveAssemblyDataSymbol(datum.Sym, resolve)] = true
+			}
+		}
+		return emitted[native]
+	}
+	source := &goReadOnlyStorage{pkg: pkg, sizes: sizes, resolve: resolve, declarations: make(map[string]*goReadOnlyDeclaration),
+		objects: make(map[string]goReadOnlyObject), symbols: make(map[string]string)}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			operand, _, known := goReadOnlyOperand(instruction, arch)
+			if !known {
+				continue
+			}
+			{
+				address, valid := x86StaticSBSourceAddress(operand, arch)
+				if !valid {
+					continue
+				}
+				owner, path := pkg, ""
+				name := goReadOnlyLocalName(pkg, address.symbol)
+				if name == "" {
+					path, name = goReadOnlyImportedName(address.symbol)
+					if path == "" || pkg.Imports[path] == nil || len(pkg.ImportSyntax[path]) == 0 || !goReadOnlyImportedComparison(instruction, arch) {
+						continue // Imported storage supplies only the named CMP role.
+					}
+					var err error
+					owner, err = goReadOnlyImportedPackage(pkg, path)
+					if err != nil {
+						return nil, err
+					}
+				}
+				variable, declared := owner.Types.Scope().Lookup(name).(*types.Var)
+				if !declared || variable.IsField() || variable.Pkg() != owner.Types || path == "" && assemblyNames[name] {
+					continue // Unknown symbols never inherit another variable's type.
+				}
+				native := gosym.PackagePrefix(owner.Path) + "." + name
+				if emittedOwns(native) {
+					continue // A resolved alias definition is still the emitted module's owner.
+				}
+				if object, present := source.objects[native]; present {
+					if object.variable != variable {
+						return nil, goReadOnlyContext("different declarations share a native global")
+					}
+					continue
+				}
+				if sizes == nil {
+					sizes = types.SizesFor("gc", arch)
+					source.sizes = sizes
+				}
+				if sizes == nil {
+					return nil, goReadOnlyContext("missing target sizes for a candidate read")
+				}
+				size, spans, shape, err := goReadOnlyDeclarationLayout(variable.Type(), sizes)
+				if err != nil {
+					return nil, err
+				}
+				object := goReadOnlyObject{variable: variable, native: native, imported: path != "",
+					size: size, spans: spans, shape: shape}
+				source.objects[native] = object
+				declarations := source.declarations[path]
+				if declarations == nil {
+					// Snapshot maps rather than retaining aliases to caller mutations.
+					imports := make(map[string]*types.Package, len(owner.Imports))
+					for path, dependency := range owner.Imports {
+						imports[path] = dependency
+					}
+					owner.Imports = imports
+					declarations = &goReadOnlyDeclaration{path: path, pkg: owner, objects: make(map[string]goReadOnlyObject)}
+					source.declarations[path] = declarations
+				}
+				declarations.objects[name] = object
+			}
+		}
+	}
+	if len(source.objects) == 0 {
+		return nil, nil
+	}
+	if len(source.objects) > 32 {
+		return nil, goReadOnlyContext("global declaration inventory exceeds its bound")
+	}
+	if err := source.bindFuncvalReads(file, arch); err != nil {
+		return nil, err
+	}
+	source.file = x86DirectTailSnapshot(file)
+	var err error
+	for _, declarations := range source.declarations {
+		declarations.syntax, err = goReadOnlySyntax(declarations.pkg)
+		if err != nil {
+			return nil, err
+		}
+		typed, err := goReadOnlyTypedSyntax(declarations.pkg, declarations.syntax, sizes, declarations.objects)
+		if err != nil {
+			return nil, err
+		}
+		for name, object := range declarations.objects {
+			actual, present := typed.Scope().Lookup(name).(*types.Var)
+			if !present {
+				return nil, goReadOnlyContext("global %q has no actual variable declaration", name)
+			}
+			size, spans, shape, err := goReadOnlyDeclarationLayout(actual.Type(), sizes)
+			if err != nil || size != object.size || shape != object.shape || !reflect.DeepEqual(spans, object.spans) {
+				return nil, goReadOnlyContext("global %q type and syntax layouts differ", name)
+			}
+		}
+	}
+	source.original, err = x86CallerSourceFingerprint(file)
+	if err != nil {
+		return nil, err
+	}
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			for _, operand := range instruction.Args {
+				address, valid := x86StaticSBSourceAddress(operand, arch)
+				object := source.object(address.symbol)
+				if !valid || object.variable == nil {
+					continue
+				}
+				// Match the exact declaration's native symbol, not an arbitrary
+				// resolver alias with a conveniently named Go declaration.
+				symbol := address.symbol
+				if !strings.ContainsAny(symbol, "·./") {
+					symbol = "·" + symbol
+				}
+				source.symbols[symbol] = object.native
+			}
+		}
+	}
+	if err := source.verify(); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func (source *goReadOnlyStorage) verify() error {
+	if source == nil {
+		return nil
+	}
+	if source.failure != nil {
+		return source.failure
+	}
+	check := func() error {
+		actual, err := x86CallerSourceFingerprint(source.file)
+		if err != nil || actual != source.original {
+			return goReadOnlyContext("original assembly changed during binding")
+		}
+		for _, declarations := range source.declarations {
+			pkg := source.pkg
+			if declarations.path != "" {
+				pkg, err = goReadOnlyImportedPackage(source.pkg, declarations.path)
+				if err != nil || pkg.Types != declarations.pkg.Types {
+					return goReadOnlyContext("actual typed import changed during binding")
+				}
+			}
+			if len(pkg.Imports) != len(declarations.pkg.Imports) {
+				return goReadOnlyContext("typed declaration dependencies changed during binding")
+			}
+			for path, dependency := range declarations.pkg.Imports {
+				if pkg.Imports[path] != dependency {
+					return goReadOnlyContext("actual typed declaration dependency changed during binding")
+				}
+			}
+			syntax, err := goReadOnlySyntax(pkg)
+			if err != nil || !reflect.DeepEqual(syntax, declarations.syntax) {
+				return goReadOnlyContext("declaration syntax changed during binding")
+			}
+			for name, object := range declarations.objects {
+				variable, _ := pkg.Types.Scope().Lookup(name).(*types.Var)
+				if variable != object.variable {
+					return goReadOnlyContext("global declaration identity changed during binding")
+				}
+				size, spans, shape, err := goReadOnlyDeclarationLayout(variable.Type(), source.sizes)
+				if err != nil || size != object.size || shape != object.shape || !reflect.DeepEqual(spans, object.spans) {
+					return goReadOnlyContext("global target layout changed during binding")
+				}
+			}
+		}
+		return nil
+	}
+	if err := check(); err != nil {
+		return err
+	}
+	for symbol, expected := range source.symbols {
+		if source.resolve(symbol) != expected {
+			return goReadOnlyContext("global resolver differs from its actual declaration")
+		}
+	}
+	return check() // Resolvers are user callbacks and may have changed source.
+}
+
+func (source *goReadOnlyStorage) resolveSymbol(symbol string) string {
+	actual := source.resolve(symbol)
+	if expected, known := source.symbols[symbol]; known && actual != expected {
+		source.failure = goReadOnlyContext("global resolver changed during consumption")
+	}
+	return actual
+}
+
+func (source *goReadOnlyStorage) allows(operand Operand, width int64, arch string) bool {
+	if source == nil || source.failure != nil || width <= 0 {
+		return false
+	}
+	address, valid := x86StaticSBReadAddress(operand, arch)
+	object := source.object(address.symbol)
+	if !valid || object.variable == nil || width > object.size || address.offset > object.size-width {
+		return false
+	}
+	for _, span := range object.spans {
+		if address.offset >= span[0] && address.offset <= span[1]-width {
+			return true
+		}
+	}
+	return false
+}
diff --git a/go_ordinary_global_read_test.go b/go_ordinary_global_read_test.go
new file mode 100644
index 000000000..b4598b51b
--- /dev/null
+++ b/go_ordinary_global_read_test.go
@@ -0,0 +1,262 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const ordinaryGlobalReadPackage = "example.com/ordinaryglobals"
+
+func ordinaryGlobalReadAssembly(prefix, comparison string) []byte {
+	// PEXTRD makes the ordinary result observer consume the comparison's
+	// numerical input. Neither branch may be discarded from source evidence.
+	return []byte("TEXT ·view(SB),4,$0-4\n" + prefix + comparison + `
+	JNZ enabled
+	PXOR X0,X0
+	JMP done
+enabled:
+	MOVL $7,AX
+	MOVL AX,X0
+done:
+	PEXTRD $0,X0,AX
+	MOVL AX,ret+0(FP)
+	RET
+`)
+}
+
+func ordinaryGlobalReadRequest(t *testing.T, pkg GoPackage, assembly []byte, arch, triple, api string) (string, error) {
+	t.Helper()
+	options := GoModuleOptions{GOOS: "linux", GOARCH: arch, Sizes: types.SizesFor("gc", arch),
+		TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path)}
+	var translated *GoModuleTranslation
+	var err error
+	if api == "public" {
+		translated, err = TranslateGoModule(pkg, assembly, options)
+	} else {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		translated, err = translateGoModuleInContext(ctx, pkg, assembly, options)
+		if translated != nil {
+			defer translated.Module.Dispose()
+			return translated.Module.String(), err
+		}
+		return "", err
+	}
+	if translated == nil {
+		return "", err
+	}
+	defer translated.Module.Dispose()
+	return translated.Module.String(), err
+}
+
+func TestGoModuleOrdinaryGlobalReadMutableBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				for _, initial := range []string{"false", "true"} {
+					// Like math/big.hasADX, initialization calls Go code and is not
+					// an assembly DATA declaration or permission to fold a value.
+					pkg := mustGoPackage(t, ordinaryGlobalReadPackage, `package ordinaryglobals
+var hasADX = feature()
+func feature() bool { return `+initial+` }
+func view() uint32
+`)
+					ir, err := ordinaryGlobalReadRequest(t, pkg,
+						ordinaryGlobalReadAssembly("", "CMPB ·hasADX(SB),$0\n"), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("real same-package mutable bool needs no SDK capture: initial=%s output=%t err=%v", initial, ir != "", err)
+					}
+					if !strings.Contains(ir, "load volatile i8, ptr @\""+ordinaryGlobalReadPackage+".hasADX\"") ||
+						!strings.Contains(ir, "icmp eq i8") || !strings.Contains(ir, "br i1") {
+						t.Fatalf("typed global lost its exact mutable byte read or conditional branches:\n%s", ir)
+					}
+					declaration := false
+					for _, line := range strings.Split(ir, "\n") {
+						if strings.HasPrefix(line, "@\""+ordinaryGlobalReadPackage+".hasADX\" = ") {
+							declaration = strings.Contains(line, " = external global ")
+						}
+					}
+					if !declaration {
+						t.Fatalf("Go-defined storage was replaced by a local DATA/constant or lost its external declaration:\n%s", ir)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalReadDoesNotGrantOtherStorage(t *testing.T) {
+	for _, row := range []struct {
+		name, declaration, prefix, comparison string
+	}{
+		{"wider-than-bool", "var hasADX bool", "", "CMPW ·hasADX(SB),$0\n"},
+		{"past-bool", "var hasADX bool", "", "CMPB ·hasADX+1(SB),$0\n"},
+		{"negative-offset", "var hasADX bool", "", "CMPB ·hasADX-1(SB),$0\n"},
+		{"unknown-symbol", "var hasADX bool", "", "CMPB ·unknown(SB),$0\n"},
+		{"pointer-storage", "var hasADX *byte", "", "CMPB ·hasADX(SB),$0\n"},
+		{"string-header", "var hasADX string", "", "CMPB ·hasADX(SB),$0\n"},
+		{"slice-header", "var hasADX []byte", "", "CMPB ·hasADX(SB),$0\n"},
+		{"function-value", "var hasADX func()", "", "CMPB ·hasADX(SB),$0\n"},
+		{"function-symbol", "func hasADX()", "", "CMPB ·hasADX(SB),$0\n"},
+		{"blank-field", "var hasADX struct { _ byte; flag bool }", "", "CMPB ·hasADX(SB),$0\n"},
+		{"struct-padding", "var hasADX struct { flag bool; word uint64 }", "", "CMPB ·hasADX+1(SB),$0\n"},
+		{"cross-padding", "var hasADX struct { flag bool; word uint64 }", "", "CMPW ·hasADX(SB),$0\n"},
+		{"write-not-read", "var hasADX bool", "MOVB $1,·hasADX(SB)\n", "CMPB ·hasADX(SB),$0\n"},
+		{"rmw-not-read", "var hasADX bool", "INCB ·hasADX(SB)\n", "CMPB ·hasADX(SB),$0\n"},
+		{"address-not-pointer", "var hasADX bool", "LEAQ ·hasADX(SB),DX\nMOVB (DX),CL\n", "CMPB ·hasADX(SB),$0\n"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+row.declaration+"\nfunc view() uint32\n")
+				ir, err := ordinaryGlobalReadRequest(t, pkg, ordinaryGlobalReadAssembly(row.prefix, row.comparison),
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("ordinary read declaration expanded storage authority: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalReadNeedsRealDeclarations(t *testing.T) {
+	for _, mutation := range []string{"missing-types", "missing-syntax", "missing-var-declaration", "different-var-type"} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(mutation+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\nvar hasADX bool\nfunc view() uint32\n")
+				switch mutation {
+				case "missing-types":
+					pkg.Types = nil
+				case "missing-syntax":
+					pkg.Syntax = nil
+				case "missing-var-declaration":
+					pkg.Syntax = mustGoPackage(t, ordinaryGlobalReadPackage,
+						"package ordinaryglobals\nfunc view() uint32\n").Syntax
+				case "different-var-type":
+					pkg.Syntax = mustGoPackage(t, ordinaryGlobalReadPackage,
+						"package ordinaryglobals\nvar hasADX *byte\nfunc view() uint32\n").Syntax
+				}
+				ir, err := ordinaryGlobalReadRequest(t, pkg, ordinaryGlobalReadAssembly("", "CMPB ·hasADX(SB),$0\n"),
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || err == nil {
+					t.Fatalf("unmatched/absent typed source acquired a read extent: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalReadDoesNotLendToRawAPI(t *testing.T) {
+	pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+		"package ordinaryglobals\nvar hasADX bool\nfunc view() uint32\n")
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t,
+				string(ordinaryGlobalReadAssembly("", "CMPB ·hasADX(SB),$0\n")), pkg,
+				"amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("raw API borrowed a GoModule storage declaration: output=%t err=%v", ir != "", err)
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalReadKeepsLogicalNamespaceSeparate(t *testing.T) {
+	for _, candidate := range []bool{false, true} {
+		for _, api := range []string{"public", "owned-context"} {
+			name := "no-global-candidate"
+			assembly := []byte("TEXT ·view(SB),4,$0-4\nMOVL $7,AX\nMOVL AX,ret+0(FP)\nRET\n")
+			if candidate {
+				name = "typed-global-candidate"
+				assembly = ordinaryGlobalReadAssembly("", "CMPB ·hasADX(SB),$0\n")
+			}
+			t.Run(name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\nvar hasADX bool\nfunc view() uint32\n")
+				pkg.Path = "main" // LLGo's linked namespace, not Types.Path().
+				ir, err := ordinaryGlobalReadRequest(t, pkg, assembly, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" || !strings.Contains(ir, "@main.view(") {
+					t.Fatalf("typed package ownership was confused with its linked namespace: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalReadCostQueryPreservesOtherOwners(t *testing.T) {
+	for _, row := range []struct {
+		name, declarations, source string
+		unboundWrite               bool
+	}{
+		{"ordinary-write", "var cell uint64\nfunc view()",
+			"TEXT ·view(SB),4,$0-0\nMOVQ $7,·cell(SB)\nRET\n", true},
+		{"emitted-globl", "var cell uint64\nfunc view() uint32",
+			"GLOBL ·cell(SB),8,$8\n" + string(ordinaryGlobalReadAssembly("", "CMPQ ·cell(SB),$0\n")), false},
+		{"emitted-data", "var cell uint64\nfunc view() uint32",
+			"DATA ·cell(SB)/8,$7\nGLOBL ·cell(SB),8,$8\n" + string(ordinaryGlobalReadAssembly("", "CMPQ ·cell(SB),$0\n")), false},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+row.declarations+"\n")
+				if row.unboundWrite {
+					file, err := Parse(ArchAMD64, row.source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					query := pkg
+					query.Syntax = nil // A noncandidate needs no new declaration audit.
+					sizes := &ordinaryGlobalReadCountingSizes{Sizes: types.SizesFor("gc", "amd64")}
+					binding, err := bindGoReadOnlyStorage(query, file, sizes, "amd64", testResolveSym(pkg.Path))
+					if binding != nil || err != nil || sizes.visits != 0 {
+						t.Fatalf("noncandidate acquired storage or inspected its layout: binding=%t visits=%d err=%v", binding != nil, sizes.visits, err)
+					}
+				}
+				ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(row.source), "amd64", "x86_64-unknown-linux-gnu", api)
+				if row.unboundWrite {
+					// Native emission is not numerical-source authority. The old
+					// whole-function checker must still reject this unowned SB write.
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("cost query lent authority to an unowned MOV write: output=%t err=%v", ir != "", err)
+					}
+					return
+				}
+				if err != nil || ir == "" {
+					t.Fatalf("a noncandidate or existing storage owner was intercepted: output=%t err=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+type ordinaryGlobalReadCountingSizes struct {
+	types.Sizes
+	visits int
+}
+
+func (sizes *ordinaryGlobalReadCountingSizes) Sizeof(typ types.Type) int64 {
+	sizes.visits++
+	if sizes.visits > 256 {
+		panic("test stopped an unbounded layout traversal")
+	}
+	return sizes.Sizes.Sizeof(typ)
+}
+
+func TestGoModuleOrdinaryGlobalReadZeroWidthLayoutIsBounded(t *testing.T) {
+	// The physical object is one byte. Traversing each zero-width element
+	// would take 2^40 visits; the counting Sizes stops the old implementation
+	// deterministically without turning this regression into a timeout test.
+	typ := types.NewStruct([]*types.Var{
+		types.NewVar(0, nil, "Z", types.NewArray(types.NewArray(types.NewStruct(nil, nil), 1<<20), 1<<20)),
+		types.NewVar(0, nil, "Flag", types.Typ[types.Bool]),
+	}, nil)
+	sizes := &ordinaryGlobalReadCountingSizes{Sizes: types.SizesFor("gc", "amd64")}
+	size, spans, _, err := goReadOnlyLayout(typ, sizes)
+	if err != nil || size != 1 || len(spans) != 1 || spans[0] != [2]int64{0, 1} || sizes.visits > 128 {
+		t.Fatalf("zero-width repetitions were expanded: size=%d spans=%v visits=%d err=%v", size, spans, sizes.visits, err)
+	}
+}
diff --git a/go_ordinary_global_vector_read_test.go b/go_ordinary_global_vector_read_test.go
new file mode 100644
index 000000000..d244ca458
--- /dev/null
+++ b/go_ordinary_global_vector_read_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+)
+
+type ordinaryGlobalVectorCase struct {
+	instruction, bank string
+	destination       int
+}
+
+func ordinaryGlobalLogicalCases(t *testing.T, arch string) []ordinaryGlobalVectorCase {
+	t.Helper()
+	// Independent mnemonic inventory; the existing complete Go-table oracle
+	// checks every row and opcode attribute behind the shared form fixtures.
+	names := strings.Fields(`
+		ANDPS ANDPD ANDNPS ANDNPD ORPS ORPD XORPS XORPD PAND PANDN POR PXOR
+		VANDPS VANDPD VANDNPS VANDNPD VORPS VORPD VXORPS VXORPD
+		VPAND VPANDN VPOR VPXOR VPANDD VPANDQ VPANDND VPANDNQ
+		VPORD VPORQ VPXORD VPXORQ
+	`)
+	actual := make([]string, 0, len(x86PackedLogicalSpecs))
+	for name := range x86PackedLogicalSpecs {
+		actual = append(actual, string(name))
+	}
+	sort.Strings(names)
+	sort.Strings(actual)
+	if !reflect.DeepEqual(names, actual) {
+		t.Fatal("the complete independent logical namespace changed", names, actual)
+	}
+	var result []ordinaryGlobalVectorCase
+	for _, name := range names {
+		for _, instruction := range x86LogicalAcceptedForms(Op(name), arch) {
+			if !strings.Contains(instruction, "8(AX)") || strings.Contains(instruction, ",M") {
+				continue // Physical MMX remains a separate entry/state contract.
+			}
+			instruction = strings.Replace(instruction, "8(AX)", "·words+16(SB)", 1)
+			// Grammar fixtures independently exercise high banks. This fixture
+			// keeps every target physically bound and observes the low result.
+			instruction = regexp.MustCompile(`\b([XYZ])(?:7|15|31)\b`).ReplaceAllString(instruction, "${1}2")
+			args := strings.Split(strings.Fields(instruction)[1], ",")
+			destination := args[len(args)-1]
+			result = append(result, ordinaryGlobalVectorCase{instruction, destination[:1], 2})
+		}
+	}
+	return result
+}
+
+func ordinaryGlobalAESCases() []ordinaryGlobalVectorCase {
+	var result []ordinaryGlobalVectorCase
+	for index, name := range x86AESOracleNames {
+		widths := []string{"X"}
+		if index >= 6 && index%6 < 4 {
+			widths = append(widths, "Y", "Z")
+		}
+		for _, bank := range widths {
+			instruction, destination := x86AESOracleRow(name, "·words+16(SB)", bank)
+			result = append(result, ordinaryGlobalVectorCase{instruction, bank, destination})
+		}
+	}
+	return result
+}
+
+func ordinaryGlobalVectorZero(bank string, index int) string {
+	register := fmt.Sprintf("%s%d", bank, index)
+	switch bank {
+	case "X":
+		return fmt.Sprintf("PXOR %s,%s\n", register, register)
+	case "Y":
+		return fmt.Sprintf("VPXOR %s,%s,%s\n", register, register, register)
+	default:
+		return fmt.Sprintf("VPXORD %s,%s,%s\n", register, register, register)
+	}
+}
+
+func ordinaryGlobalVectorSource(rows []ordinaryGlobalVectorCase) (string, string) {
+	var source, declarations strings.Builder
+	declarations.WriteString("var words [96]byte\n")
+	for index, row := range rows {
+		name := fmt.Sprintf("vector%d", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n", name)
+		fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+		source.WriteString(ordinaryGlobalVectorZero(row.bank, 1))
+		source.WriteString(ordinaryGlobalVectorZero(row.bank, 2))
+		source.WriteString("MOVL $0xa55a,AX\nKMOVW AX,K1\nKMOVW AX,K7\n")
+		source.WriteString(row.instruction + "\n")
+		fmt.Fprintf(&source, "PEXTRD $0,X%d,AX\nMOVL AX,ret+0(FP)\nRET\n", row.destination)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestGoModuleOrdinaryGlobalVectorReadCompleteFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, family := range []string{"logical", "AES"} {
+			t.Run(target.triple+"/"+family, func(t *testing.T) {
+				rows := ordinaryGlobalAESCases()
+				if family == "logical" {
+					rows = ordinaryGlobalLogicalCases(t, target.arch)
+				}
+				want := 20 // Six legacy AES rows, four wide rounds, two AVX unary rows.
+				if family == "logical" {
+					want = 308 // 12 legacy + 4 VEX x2 widths + 16 EVEX x3 widths x6 memory forms.
+					if target.arch == "386" {
+						want = 116 // The original Go mode32 grammar has no named K operand.
+					}
+				}
+				if len(rows) != want {
+					t.Fatalf("complete memory-source denominator changed: got %d, want %d", len(rows), want)
+				}
+				// Keep source verification and object generation bounded without
+				// dropping a format, width, broadcast or masked source row.
+				for start := 0; start < len(rows); start += 32 {
+					end := start + 32
+					if end > len(rows) {
+						end = len(rows)
+					}
+					t.Run(fmt.Sprintf("batch-%02d", start/32), func(t *testing.T) {
+						source, declarations := ordinaryGlobalVectorSource(rows[start:end])
+						goAssemblerOracleOutput(t, target.arch, source, "", true)
+						for _, api := range []string{"public", "owned-context"} {
+							t.Run(api, func(t *testing.T) {
+								pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+								ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), target.arch, target.triple, api)
+								if err != nil || ir == "" {
+									t.Fatal("complete named vector reads need ordinary declarations, not an SDK capability", err)
+								}
+								compileLLVMToObject(t, llc, target.triple, "ordinary-vector.ll", "ordinary-vector.o", ir)
+							})
+						}
+						for _, row := range rows[start:end] {
+							instruction := x86YMMReadSource(t, row.instruction)
+							operand, width, known := goReadOnlyOperand(instruction, target.arch)
+							form, valid := x86NumericalSBVectorReadProperties(instruction, target.arch)
+							if !known || !valid || width != form.spec.sourceBytes || !reflect.DeepEqual(operand, instruction.Args[form.operand]) {
+								t.Fatal("ordinary storage did not use the existing complete typed read shape", row.instruction)
+							}
+						}
+					})
+				}
+				t.Logf("complete %s numerical-global source union: %d forms", family, len(rows))
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalVectorReadRetainsAuthorityBoundaries(t *testing.T) {
+	for _, test := range []struct{ name, declaration, prefix, instruction string }{
+		{"past-object", "var words [31]byte", "PXOR X0,X0\n", "PXOR ·words+16(SB),X0"},
+		{"negative-offset", "var words [96]byte", "PXOR X0,X0\n", "PXOR ·words-1(SB),X0"},
+		{"padding", "var words struct { A byte; B [16]uint64 }", "PXOR X0,X0\n", "PXOR ·words+1(SB),X0"},
+		{"blank-field", "var words struct { _ [16]byte; A [16]byte }", "PXOR X0,X0\n", "PXOR ·words(SB),X0"},
+		{"pointer-array", "var words [16]*byte", "PXOR X0,X0\n", "PXOR ·words(SB),X0"},
+		{"slice", "var words []byte", "PXOR X0,X0\n", "PXOR ·words(SB),X0"},
+		{"foreign", "var words [96]byte", "PXOR X0,X0\n", "PXOR other.words(SB),X0"},
+		{"unknown-register", "var words [96]byte", "", "PXOR ·words(SB),X0"},
+		{"unknown-AES-state", "var words [96]byte", "", "AESENC ·words(SB),X0"},
+		{"unknown-mask", "var words [96]byte", "PXOR X0,X0\n", "VPXORD ·words(SB),X0,K1,X0"},
+		{"unknown-merge", "var words [96]byte", "PXOR X1,X1\nMOVL $1,AX\nKMOVW AX,K1\n", "VPXORD ·words(SB),X1,K1,X0"},
+		{"zero-mask-missing-extent", "var words [3]byte", "PXOR X0,X0\nMOVL $0,AX\nKMOVW AX,K1\n", "VPXORD.BCST.Z ·words(SB),X0,K1,X0"},
+		{"write", "var words [96]byte", "PXOR X0,X0\nMOVOU X0,·words(SB)\n", "PXOR ·words(SB),X0"},
+		{"address", "var words [96]byte", "PXOR X0,X0\nLEAQ ·words(SB),DX\nMOVL (DX),AX\n", "PXOR ·words(SB),X0"},
+		// This negative only preserves the separate physical MMX contract; it
+		// is not a complete MMX family acceptance/execution certificate.
+		{"physical-MMX", "var words [96]byte", "PXOR M0,M0\n", "PXOR ·words(SB),M0"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(test.name+"/"+api, func(t *testing.T) {
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage,
+					"package ordinaryglobals\n"+test.declaration+"\nfunc view() uint32\n")
+				source := "TEXT ·view(SB),4,$0-4\n" + test.prefix + test.instruction +
+					"\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", api)
+				switch test.name {
+				case "unknown-register", "unknown-AES-state", "unknown-merge":
+					x86VectorScratchCodegenPackageControl(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					return
+				}
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("a numerical-global read lent another authority or missing input", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoModuleOrdinaryGlobalVectorReadRejectsRawAndStaleBindings(t *testing.T) {
+	row := ordinaryGlobalVectorCase{"PXOR ·words+16(SB),X2", "X", 2}
+	source, declarations := ordinaryGlobalVectorSource([]ordinaryGlobalVectorCase{row})
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an unbound API borrowed typed Go storage", ir != "", err)
+			}
+		})
+	}
+	for _, change := range []string{"raw-origin", "address-size", "segment", "syntax", "assembly"} {
+		t.Run(change, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			storage, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", "amd64"), "amd64", testResolveSym(pkg.Path))
+			if err != nil || storage == nil {
+				t.Fatal("ordinary vector storage was not actually bound", err)
+			}
+			instruction := x86YMMReadSource(t, row.instruction)
+			switch change {
+			case "raw-origin":
+				instruction.x86Encoded = true
+			case "address-size":
+				instruction.x86AddressBits = 32
+			case "segment":
+				instruction.x86SegmentPrefix = 'F'
+			case "syntax":
+				pkg.Syntax[0].Name.Name = "changed"
+			case "assembly":
+				storage.file.Funcs[0].Instrs[1].Op = "NOP"
+			}
+			if change == "syntax" || change == "assembly" {
+				if err := storage.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed complete source did not revoke its read binding", err)
+				}
+			} else if storage.readFor(instruction, "amd64") != nil {
+				t.Fatal("a named declaration lent raw/physical override authority")
+			}
+		})
+	}
+}
+
+func TestGoModuleOrdinaryGlobalVectorReadObservableSources(t *testing.T) {
+	for _, test := range []struct {
+		instruction, bank, access string
+		loads                     int
+		masked                    bool
+	}{
+		{"PXOR ·words+16(SB),X2", "X", `asm sideeffect "pxor `, 1, false},
+		{"AESENC ·words+16(SB),X2", "X", `asm sideeffect "aesenc `, 1, false},
+		{"VPXOR ·words+16(SB),Y1,Y2", "Y", "load volatile <32 x i8>", 1, false},
+		{"VXORPD.BCST ·words+16(SB),Z1,Z2", "Z", "load volatile <8 x i8>", 1, false},
+		{"VPXORD ·words+16(SB),Z1,K1,Z2", "Z", "load volatile i32", 16, true},
+		{"VPXORD.BCST.Z ·words+16(SB),Z1,K1,Z2", "Z", "load volatile i32", 1, true},
+		{"VAESENC ·words+16(SB),Z1,Z2", "Z", "load volatile <64 x i8>", 1, false},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			source, declarations := ordinaryGlobalVectorSource([]ordinaryGlobalVectorCase{{test.instruction, test.bank, 2}})
+			// Discard the numerical result. Observable native reads must not
+			// disappear merely because an independent scalar value is returned.
+			source = strings.Replace(source, "MOVL AX,ret+0(FP)", "MOVL $7,ret+0(FP)", 1)
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", "public")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got := strings.Count(ir, test.access); got != test.loads {
+				t.Fatalf("source access changed: got %d %q, want %d", got, test.access, test.loads)
+			}
+			if test.masked && !strings.Contains(ir, "br i1") {
+				t.Fatal("masked source lost its actual conditional access")
+			}
+			if strings.Contains(test.access, "asm sideeffect") && !strings.Contains(ir, "~{memory}") {
+				t.Fatal("legacy native memory opcode lost its observable access")
+			}
+			optimized := x86MulDivRoundOptimize(t, ir)
+			if !strings.Contains(optimized, test.access) {
+				t.Fatal("IR optimization removed the dead-result native/volatile source access")
+			}
+		})
+	}
+}
diff --git a/go_ordinary_global_vector_runtime_test.go b/go_ordinary_global_vector_runtime_test.go
new file mode 100644
index 000000000..5b5d77f18
--- /dev/null
+++ b/go_ordinary_global_vector_runtime_test.go
@@ -0,0 +1,200 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixGoModuleOrdinaryGlobalVectorReads(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	t.Run("logical", func(t *testing.T) {
+		ordinaryGlobalLogicalRuntime(t, execution)
+	})
+	t.Run("AES", func(t *testing.T) {
+		ordinaryGlobalAESRuntime(t, execution)
+	})
+}
+
+func ordinaryGlobalLogicalRuntimeFixtures(t *testing.T) []x86LogicalRuntimeFixture {
+	t.Helper()
+	var fixtures []x86LogicalRuntimeFixture
+	for _, fixture := range x86LogicalRuntimeFixtures(t) {
+		// Register-source fixtures also load their setup value from (BX).
+		// Select the logical operation itself, never that unrelated load.
+		lines := strings.Split(fixture.assembly, "\n")
+		selected := -1
+		for index, line := range lines {
+			fields := strings.Fields(line)
+			if len(fields) != 2 {
+				continue
+			}
+			opcode := Op(strings.Split(fields[0], ".")[0])
+			if _, logical := x86PackedLogicalSpecs[opcode]; !logical || !strings.HasPrefix(fields[1], "(BX),") {
+				continue
+			}
+			if selected >= 0 {
+				t.Fatal("fixture contains more than one logical source", fixture.name)
+			}
+			selected = index
+		}
+		if selected < 0 {
+			continue
+		}
+		lines[selected] = strings.Replace(lines[selected], "(BX)", "·words+64(SB)", 1)
+		fixture.assembly = strings.Join(lines, "\n")
+		fixture.assembly = strings.Replace(fixture.assembly,
+			"TEXT "+fixture.name+"(SB)", "TEXT ·"+fixture.name+"(SB)", 1)
+		call := "  " + fixture.name + "(output+1,a,b,mask);"
+		if strings.Count(fixture.checks, call) != 1 {
+			t.Fatal("the complete independent logical oracle call changed", fixture.name)
+		}
+		fixture.checks = strings.Replace(fixture.checks, call, `
+  memset(globalWords, 0xc7, sizeof(globalWords));
+  memcpy(globalWords + 64, a, 64);
+`+call+`
+  if (memcmp(globalWords + 64, a, 64)) return 1;
+  for (int i = 0; i < 64; i++) {
+      if (globalWords[i] != 0xc7 || globalWords[128 + i] != 0xc7) return 1;
+  }
+`, 1)
+		fixtures = append(fixtures, fixture)
+	}
+	if len(fixtures) != 308 {
+		t.Fatal("complete logical memory-source execution union changed", len(fixtures))
+	}
+	return fixtures
+}
+
+func TestGoModuleOrdinaryGlobalLogicalRuntimeFixtureSelection(t *testing.T) {
+	for _, fixture := range ordinaryGlobalLogicalRuntimeFixtures(t) {
+		if strings.Contains(fixture.assembly, "(BX)") ||
+			strings.Count(fixture.assembly, "·words+64(SB)") != 1 ||
+			!strings.HasPrefix(fixture.assembly, "TEXT ·"+fixture.name+"(SB)") {
+			t.Fatal("global runtime fixture changed setup memory or lost its Go declaration", fixture.name)
+		}
+	}
+}
+
+func ordinaryGlobalLogicalRuntime(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	fixtures := ordinaryGlobalLogicalRuntimeFixtures(t)
+	// Retain the existing independent all-byte, mask, FLAGS and alias oracle.
+	// Only its first numerical input is now the same mutable Go global across
+	// repeated calls; no source observation or SDK capability is fabricated.
+	for start := 0; start < len(fixtures); start += 32 {
+		end := start + 32
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		t.Run(fmt.Sprintf("batch-%02d", start/32), func(t *testing.T) {
+			batch := fixtures[start:end]
+			var source, declarations, wrappers strings.Builder
+			declarations.WriteString("var words [192]byte\n")
+			for _, fixture := range batch {
+				source.WriteString(fixture.assembly)
+				fmt.Fprintf(&declarations, "func %s(out *[65]byte,a,b *[64]byte,mask uint64)\n", fixture.name)
+				fmt.Fprintf(&wrappers, `
+define void @%s(ptr %%out, ptr %%a, ptr %%b, i64 %%mask) {
+  call void %s(ptr %%out, ptr %%a, ptr %%b, i64 %%mask)
+  ret void
+}
+`, fixture.name, llvmGlobal("ordinaryglobals."+fixture.name))
+			}
+			goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+			global := fmt.Sprintf("_Alignas(64) unsigned char globalWords[192] __asm__(%q);\n",
+				ordinaryGlobalVectorNativeSymbol("words"))
+			driver := global + x86LogicalRuntimeC(batch)
+			ordinaryGlobalVectorExecute(t, execution, source.String(), declarations.String(), wrappers.String(), driver)
+		})
+	}
+	t.Log("308 logical global-source functions x16 independent full-byte/mask inputs; preserved inputs, FLAGS, wider aliases and global canaries")
+}
+
+func ordinaryGlobalAESRuntime(t *testing.T, execution x86FloatCompareExecution) {
+	t.Helper()
+	rows := ordinaryGlobalAESCases()
+	if len(rows) != 20 {
+		t.Fatal("complete AES memory-source execution union changed", len(rows))
+	}
+	source, declarations := ordinaryGlobalVectorSource(rows)
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	var prototypes, table strings.Builder
+	for index, row := range rows {
+		name := strings.Fields(row.instruction)[0]
+		operation := -1
+		for candidate, original := range x86AESOracleNames {
+			if name == original {
+				operation = candidate % 6
+			}
+		}
+		if operation < 0 {
+			t.Fatal("unknown independent AES operation", row.instruction)
+		}
+		fmt.Fprintf(&prototypes, "extern uint32_t vector%d(void) __asm__(%q);\n", index,
+			ordinaryGlobalVectorNativeSymbol(fmt.Sprintf("vector%d", index)))
+		fmt.Fprintf(&table, "    {vector%d, %d},\n", index, operation)
+	}
+	driver := x86AESIndependentC + prototypes.String() + fmt.Sprintf(`
+_Alignas(64) unsigned char globalWords[96] __asm__(%q);
+struct kernel { uint32_t (*run)(void); unsigned operation; };
+static const struct kernel kernels[] = {
+%s};
+
+int main(void) {
+    for (unsigned sample = 0; sample < 37; sample++) {
+        for (unsigned i = 0; i < sizeof(globalWords); i++)
+            globalWords[i] = (uint8_t)(sample * 19 + i * 37);
+        uint8_t before[96];
+        memcpy(before, globalWords, sizeof(before));
+        for (unsigned k = 0; k < sizeof(kernels) / sizeof(kernels[0]); k++) {
+            uint8_t state[16] = {0}, expected[16];
+            aes(expected, state, globalWords + 16, kernels[k].operation, 27);
+            uint32_t want;
+            memcpy(&want, expected, sizeof(want));
+            if (kernels[k].run() != want || memcmp(before, globalWords, sizeof(before))) {
+                fprintf(stderr, "mutable AES global mismatch sample=%%u kernel=%%u\n", sample, k);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`, ordinaryGlobalVectorNativeSymbol("words"), table.String())
+	ordinaryGlobalVectorExecute(t, execution, source, declarations, "", driver)
+	t.Log("20 AES/VAES memory-source functions x37 mutable inputs; independent FIPS byte oracle and complete source immutability")
+}
+
+func ordinaryGlobalVectorNativeSymbol(name string) string {
+	prefix := ""
+	if runtime.GOOS == "darwin" {
+		prefix = "_"
+	}
+	return prefix + "ordinaryglobals." + name
+}
+
+func ordinaryGlobalVectorExecute(t *testing.T, execution x86FloatCompareExecution,
+	source, declarations, wrappers, driver string,
+) {
+	t.Helper()
+	for _, api := range []string{"public", "owned-context"} {
+		t.Run(api, func(t *testing.T) {
+			pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+			pkg.Path = "ordinaryglobals"
+			ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir += wrappers
+			for _, pipeline := range []struct{ name, text, level string }{
+				{"backend_O0", ir, "-O0"},
+				{"IR_O2/backend_O2", x86MulDivRoundOptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "ordinary-global-vector", pipeline.text, driver, pipeline.level)
+				})
+			}
+		})
+	}
+}
diff --git a/go_owned_indexed_vector_read_test.go b/go_owned_indexed_vector_read_test.go
new file mode 100644
index 000000000..865c2feeb
--- /dev/null
+++ b/go_owned_indexed_vector_read_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func ownedIndexedVectorCases(t *testing.T, arch string) []ordinaryGlobalVectorCase {
+	t.Helper()
+	rows := ordinaryGlobalLogicalCases(t, arch)
+	// Reuse the independently Go-table-checked shuffle family. Its source is
+	// a complete control tuple; byte selection never shrinks the access width.
+	for _, instruction := range x86ByteShuffleFormatRows(arch) {
+		if !strings.Contains(instruction, "·data(SB)") {
+			continue
+		}
+		instruction = strings.Replace(instruction, "·data(SB)", "·words+16(SB)", 1)
+		args := strings.Split(strings.Fields(instruction)[1], ",")
+		destination := args[len(args)-1]
+		rows = append(rows, ordinaryGlobalVectorCase{instruction, destination[:1], int(destination[1] - '0')})
+	}
+	want := 318 // The 308 logical rows plus legacy PSHUFB and nine VPSHUFB rows.
+	if arch == "386" {
+		want = 120 // Existing named mode32 grammar excludes masked forms.
+	}
+	if len(rows) != want {
+		t.Fatal("complete indexed vector source union changed", len(rows), want)
+	}
+	return rows
+}
+
+func ownedIndexedVectorTable() string {
+	var source strings.Builder
+	for offset := 0; offset < 256; offset += 8 {
+		fmt.Fprintf(&source, "DATA numericBytes<>+%d(SB)/8,$0x%016x\n", offset,
+			uint64(0x719283a4b5c6d7e8)^uint64(offset)*0x0102030405060708)
+	}
+	source.WriteString("GLOBL numericBytes<>(SB),8,$256\n")
+	return source.String()
+}
+
+func ownedIndexedVectorSource(t *testing.T, rows []ordinaryGlobalVectorCase, arch string) (string, string) {
+	t.Helper()
+	move, compare, test, add, word := "MOVQ", "CMPQ", "TESTQ", "ADDQ", 8
+	if arch == "386" {
+		move, compare, test, add, word = "MOVL", "CMPL", "TESTL", "ADDL", 4
+	}
+	var source, declarations strings.Builder
+	source.WriteString(ownedIndexedVectorTable())
+	for index, row := range rows {
+		instruction := strings.Replace(row.instruction, "·words+16(SB)", "(AX)(CX*8)", 1)
+		parsed := x86YMMReadSource(t, instruction)
+		width, write, known := x86InstructionMemoryShape(parsed, 0, arch)
+		if !known || write || width <= 0 || width > 64 {
+			t.Fatal("missing complete typed memory-source width", instruction, width, write, known)
+		}
+		// The source computes a 16-byte table stride using two real integer
+		// operations. Its CFG proves the complete source width stays in 256B.
+		limit := (256-width)/16 + 1
+		name := fmt.Sprintf("indexed%d", index)
+		fmt.Fprintf(&declarations, "func %s(n uintptr) uintptr\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s n+0(FP),CX\n%s CX,$%d\nJAE outside%d\n%s CX,CX\nJE outside%d\n%s CX,CX\n",
+			name, 2*word, move, compare, limit, index, test, index, add)
+		source.WriteString(ordinaryGlobalVectorZero(row.bank, 1))
+		source.WriteString(ordinaryGlobalVectorZero(row.bank, 2))
+		source.WriteString("MOVL $0xa55a,AX\nKMOVW AX,K1\nKMOVW AX,K7\n")
+		fmt.Fprintf(&source, "%s $numericBytes<>(SB),AX\n%s\nPEXTRD $0,X%d,AX\n%s AX,ret+%d(FP)\nRET\noutside%d:\n%s $0,AX\n%s AX,ret+%d(FP)\nRET\n",
+			move, instruction, row.destination, move, word, index, move, move, word)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestGoModuleOwnedReadonlyIndexedVectorSourceFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, _ := ownedIndexedVectorSource(t,
+				[]ordinaryGlobalVectorCase{{"ANDNPD ·words+16(SB),X2", "X", 2}}, arch)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := testResolveSym(ordinaryGlobalReadPackage)
+			values := x86LoweredStaticAddressValues(file, resolve, nil, arch)
+			if values == nil || values.numericLiterals["numericBytes<>"] != 256 {
+				t.Fatal("complete private RODATA directory missing", values)
+			}
+			typ := I64
+			if arch == "386" {
+				typ = I32
+			}
+			word := x86ResultPointerWord(arch)
+			sig := FuncSig{Name: resolve(file.Funcs[0].Sym), Args: []LLVMType{typ}, Ret: typ,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: word, Type: typ, Index: 0, Field: -1}},
+				}}
+			facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, arch, values.numericLiterals)
+			if err != nil {
+				t.Fatal("bounded typed source lost its range proof", err)
+			}
+			if len(facts) != 2 || !facts[0].Address || facts[1].Address ||
+				facts[1].Width != 16 || facts[1].Minimum != 0 || facts[1].Maximum != 240 {
+				t.Fatal("complete exact source range changed", facts)
+			}
+			c := &amd64Ctx{fpStaticAddressValues: values}
+			reads := c.ownedIndexedVectorReads(file.Funcs[0], sig, arch)
+			if len(reads) != 1 {
+				t.Fatal("proved exact indexed operand was not handed off", facts, reads)
+			}
+		})
+	}
+}
+
+func TestGoModuleOwnedReadonlyIndexedVectorCompleteFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := ownedIndexedVectorCases(t, target.arch)
+			for start := 0; start < len(rows); start += 32 {
+				end := start + 32
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch-%02d", start/32), func(t *testing.T) {
+					source, declarations := ownedIndexedVectorSource(t, rows[start:end], target.arch)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"public", "owned-context"} {
+						t.Run(api, func(t *testing.T) {
+							pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+							ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("the complete bounded owned RODATA source needs no SDK capture", err)
+							}
+							compileLLVMToObject(t, llc, target.triple, "owned-indexed.ll", "owned-indexed.o", ir)
+						})
+					}
+				})
+			}
+			t.Logf("complete owned numeric table read union: %d logical/shuffle memory forms", len(rows))
+		})
+	}
+}
+
+func TestGoModuleOwnedReadonlyIndexedVectorRejectsOtherAuthority(t *testing.T) {
+	base, declarations := ownedIndexedVectorSource(t,
+		[]ordinaryGlobalVectorCase{{"PAND ·words+16(SB),X2", "X", 2}}, "amd64")
+	read := "PAND (AX)(CX*8),X2"
+	for _, mutation := range []struct{ name, before, after string }{
+		{"no bound", "CMPQ CX,$16\nJAE outside0\n", ""},
+		{"wrong edge", "JAE outside0", "JB outside0"},
+		{"stale flags", "JAE outside0", "ADDQ $1,CX\nJAE outside0"},
+		{"past extent", "CMPQ CX,$16", "CMPQ CX,$17"},
+		{"unknown index", "MOVQ n+0(FP),CX", "NOP"},
+		{"partial address", read, "MOVB $0,AL\n" + read},
+		{"literal index", read, "PAND (AX)(AX*8),X2"},
+		{"mutable table", "GLOBL numericBytes<>(SB),8,$256", "GLOBL numericBytes<>(SB),0,$256"},
+		{"relocation", "DATA numericBytes<>+0(SB)/8,$0x719283a4b5c6d7e8", "DATA numericBytes<>+0(SB)/8,$external(SB)"},
+		{"write", read, "MOVOU X2,(AX)(CX*8)\n" + read},
+		{"escape", read, "MOVQ AX,ret+8(FP)\n" + read},
+		{"raw", "ADDQ CX,CX", "BYTE $0x90\nADDQ CX,CX"},
+		{"mixed origin", "MOVQ $numericBytes<>(SB),AX", "CMPQ CX,$4\nJB incoming\nMOVQ $numericBytes<>(SB),AX\nJMP joined\nincoming:\nMOVQ n+0(FP),AX\njoined:"},
+		{"unknown source", read, "PAND (DX)(CX*8),X2"},
+		{"unregistered store", read, "MOVQ AX,(DX)\n" + read},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(mutation.name+"/"+api, func(t *testing.T) {
+				if strings.Count(base, mutation.before) != 1 {
+					t.Fatal("negative control did not select one real source boundary", mutation.name)
+				}
+				source := strings.Replace(base, mutation.before, mutation.after, 1)
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+				ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "amd64", "x86_64-unknown-linux-gnu", api)
+				switch mutation.name {
+				case "no bound", "wrong edge", "stale flags", "past extent", "partial address", "literal index",
+					"mutable table", "relocation", "escape", "raw", "mixed origin":
+					// A failed readonly-table proof does not erase initialized machine
+					// address bits. The paired fallback owns an observable native read,
+					// not table bounds or reusable pointee/storage permissions. An
+					// overwritten result write does not invalidate the bounded read.
+					if err != nil || ir == "" {
+						t.Fatal("initialized table address lost its paired source continuation", err)
+					}
+					if mutation.name != "escape" && x86NumericNativeVolatileReadBytes(t, ir) != 16 &&
+						!(strings.Contains(ir, `asm sideeffect "pand `) && strings.Contains(ir, "~{memory}")) {
+						t.Fatal("unproved table bounds were used without an observable full-width native read")
+					}
+					x86RequireNumericNativeSourceContext(t, source, declarations, "amd64")
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					return
+				}
+				if ir != "" || err == nil {
+					t.Fatal("owned table lent unbounded/mutable/non-numerical/raw authority", ir != "", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_owned_packed_arithmetic_native_linux_amd64_test.go b/go_owned_packed_arithmetic_native_linux_amd64_test.go
new file mode 100644
index 000000000..fd227edc3
--- /dev/null
+++ b/go_owned_packed_arithmetic_native_linux_amd64_test.go
@@ -0,0 +1,16 @@
+//go:build go1.27
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86OwnedPackedArithmetic(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	if len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("owned arithmetic differential execution requires native AMD64")
+	}
+	t.Logf("%s", execution.run(t, ownedPackedArithmeticRuntimePreflight(t, execution)))
+	assembly, declarations, inputs, expected := ownedPackedArithmeticRuntimeProgram(t)
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
diff --git a/go_owned_packed_arithmetic_runtime_go127_test.go b/go_owned_packed_arithmetic_runtime_go127_test.go
new file mode 100644
index 000000000..e601625f4
--- /dev/null
+++ b/go_owned_packed_arithmetic_runtime_go127_test.go
@@ -0,0 +1,217 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func ownedPackedArithmeticRuntimeProgram(t *testing.T) (string, string, []uint64, [][]string) {
+	t.Helper()
+	var data [512]byte
+	var source, declarations strings.Builder
+	for offset := 0; offset < len(data); offset += 8 {
+		value := uint64(0x719283a4b5c6d7e8) ^ uint64(offset)*0x0102030405060708
+		binary.LittleEndian.PutUint64(data[offset:], value)
+		fmt.Fprintf(&source, "DATA numericBytes<>+%d(SB)/8,$0x%016x\n", offset, value)
+	}
+	source.WriteString("GLOBL numericBytes<>(SB),8,$512\n")
+	inputs := []uint64{1, 2, 3, 7}
+	expected := make([][]string, len(inputs))
+	count := 0
+	for _, opcode := range ownedPackedArithmeticNames() {
+		for half := 0; half < 2; half++ {
+			assembly, declaration := ownedPackedArithmeticFunction(fmt.Sprintf("Value%d", count), opcode, "amd64", "lea", true)
+			// Nonzero asymmetric initial lanes and a fully initialized tail
+			// keep low products observable; every loop performs three m128 reads.
+			assembly = strings.Replace(assembly, "PXOR X0,X0", "MOVOU numericBytes<>+32(SB),X0", 1)
+			assembly = strings.Replace(assembly, "MOVQ X0,AX", fmt.Sprintf("PEXTRQ $%d,X0,AX", half), 1)
+			source.WriteString(assembly)
+			declarations.WriteString(strings.ReplaceAll(declaration, "uintptr", "uint64"))
+			for index, iterations := range inputs {
+				value := ownedPackedArithmeticRuntimeOracle(opcode, data, iterations)
+				expected[index] = append(expected[index], fmt.Sprintf("%016x", binary.LittleEndian.Uint64(value[half*8:])))
+			}
+			count++
+		}
+	}
+	if count != 38 {
+		t.Fatal("complete arithmetic/full128 runtime inventory changed", count)
+	}
+	return source.String(), declarations.String(), inputs, expected
+}
+
+// Independent scalar arithmetic: no production forms, lane helpers or LLVM
+// expressions participate. Original Go must agree before it becomes an oracle.
+func ownedPackedArithmeticRuntimeOracle(opcode string, data [512]byte, iterations uint64) [16]byte {
+	var output [16]byte
+	copy(output[:], data[32:48])
+	bytes := 4
+	switch opcode[len(opcode)-1] {
+	case 'B':
+		bytes = 1
+	case 'W':
+		bytes = 2
+	case 'Q':
+		bytes = 8
+	}
+	read := func(p []byte) uint64 {
+		var value uint64
+		for index := bytes - 1; index >= 0; index-- {
+			value = value<<8 | uint64(p[index])
+		}
+		return value
+	}
+	subtract := strings.HasPrefix(opcode, "PSUB")
+	for round := uint64(0); round < iterations; round++ {
+		for _, offset := range []int{0, 16, 480} {
+			for lane := 0; lane < 16; lane += bytes {
+				a, b := read(output[lane:]), read(data[offset+lane:])
+				value := a + b
+				if subtract {
+					value = a - b
+				}
+				switch opcode {
+				case "PMULLW", "PMULLD":
+					value = a * b
+				case "PADDSB", "PADDSW", "PSUBSB", "PSUBSW":
+					shift := uint(64 - bytes*8)
+					x, y := int64(a<<shift)>>shift, int64(b<<shift)>>shift
+					signed := x + y
+					if subtract {
+						signed = x - y
+					}
+					minimum, maximum := -int64(1)<<uint(bytes*8-1), int64(1)<<uint(bytes*8-1)-1
+					if signed < minimum {
+						signed = minimum
+					} else if signed > maximum {
+						signed = maximum
+					}
+					value = uint64(signed)
+				case "PADDUSB", "PADDUSW", "PSUBUSB", "PSUBUSW":
+					maximum := uint64(1)<<uint(bytes*8) - 1
+					if subtract && a < b {
+						value = 0
+					} else if !subtract && value > maximum {
+						value = maximum
+					}
+				}
+				for index := 0; index < bytes; index++ {
+					output[lane+index] = byte(value >> uint(index*8))
+				}
+			}
+		}
+	}
+	return output
+}
+
+func ownedPackedArithmeticRuntimePreflight(t *testing.T, execution x86FloatCompareExecution) string {
+	t.Helper()
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "sse41.c"), filepath.Join(directory, "sse41")
+	const program = `#include <stdio.h>
+__attribute__((target("sse4.1"))) static int actual_product(void) {
+    typedef int V __attribute__((vector_size(16)));
+    V a={2,3,4,5}, b={7,11,13,17};
+    __asm__ volatile("pmulld %1,%0" : "+x"(a) : "x"(b));
+    return a[0]==14 && a[1]==33 && a[2]==52 && a[3]==85;
+}
+int main(void) {
+    __builtin_cpu_init();
+    int available=!!__builtin_cpu_supports("sse4.1");
+    printf("owned packed arithmetic native SSE4.1=%d\n",available);
+    return available && actual_product() ? 0 : 1;
+}
+`
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	return executable
+}
+
+func TestX86OwnedPackedArithmeticRuntimeObjects(t *testing.T) {
+	assembly, declarations, _, _ := ownedPackedArithmeticRuntimeProgram(t)
+	ownedPackedArithmeticRuntimePreflight(t, fixedLocalPackedCompileOnlyTools(t))
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly)
+			goos := "linux"
+			if strings.Contains(target.triple, "apple") {
+				goos = "darwin"
+			} else if strings.Contains(target.triple, "windows") {
+				goos = "windows"
+			}
+			pkg, request, file, options := fixedLocalTransportFixture(t, assembly, declarations, goos+"/amd64", target.triple)
+			fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly,
+				func(t *testing.T, ir string, err error) {
+					operations := strings.Count(ir, "asm sideeffect ")
+					initial := strings.Count(ir, "asm sideeffect \"movdqu ")
+					if err != nil || operations != 152 || initial != 38 {
+						t.Fatal("38 kernels require 38 initial reads and 114 arithmetic m128 reads", operations, initial, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+		})
+	}
+}
+
+func TestX86RuntimeOrdinarySourceCannotBypassFrameBinding(t *testing.T) {
+	for _, row := range []struct {
+		name    string
+		file    *File
+		options Options
+		want    bool
+	}{
+		{"ordinary", &File{Arch: ArchAMD64, Funcs: []Func{{}}}, Options{}, false},
+		{"nil", nil, Options{}, true},
+		{"empty", &File{Arch: ArchAMD64}, Options{}, true},
+		{"other arch", &File{Arch: ArchARM64, Funcs: []Func{{}}}, Options{}, true},
+		{"private", &File{Arch: ArchAMD64, Funcs: []Func{{FrameSize: 16}}}, Options{}, true},
+		{"mixed", &File{Arch: ArchAMD64, Funcs: []Func{{}, {FrameSize: 16}}}, Options{}, true},
+		{"negative frame", &File{Arch: ArchAMD64, Funcs: []Func{{FrameSize: -1}}}, Options{}, true},
+		{"untrusted proof", &File{Arch: ArchAMD64, Funcs: []Func{{x86FixedLocal: &x86FixedLocalProof{}}}}, Options{}, true},
+		{"source stack", &File{Arch: ArchAMD64, Funcs: []Func{{x86SourceStack: &x86SourceStackProof{}}}}, Options{}, true},
+		{"invalid binding", &File{Arch: ArchAMD64, Funcs: []Func{{}}},
+			Options{Sigs: map[string]FuncSig{"value": {x86FixedLocal: &x86FixedLocalBinding{}}}}, true},
+		{"numerical owner", &File{Arch: ArchAMD64, Funcs: []Func{{}}},
+			Options{NumericalReads: &GoX86NumericalReadBinding{}}, true},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			if got := fixedLocalResultsRuntimeNeedsBinding(row.file, row.options); got != row.want {
+				t.Fatal("ordinary test driver selected the wrong source/owner route", got, row.want)
+			}
+		})
+	}
+	t.Run("private-driver", func(t *testing.T) {
+		goAMD64FramePrepareOwnedToolCache(t)
+		assembly := fixedLocalConstantIndexFunction("Value0", "MOVQ 0(SP),AX")
+		triple := "x86_64-unknown-linux-gnu"
+		pkg, request, file, options := fixedLocalTransportFixture(t, assembly, "func Value0(a uint64) uint64", "linux/amd64", triple)
+		llc := findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM22 required")
+		}
+		fixedLocalResultsRuntimeAPIs(t, pkg, request, file, options, assembly,
+			func(t *testing.T, ir string, err error) {
+				if err != nil || !strings.Contains(ir, "%fixed_local_native = alloca") {
+					t.Fatal("private source lost its independent fresh frame binding", err)
+				}
+				x86PackedStringCompileObject(t, llc, triple, ir, "-O2")
+			})
+	})
+}
diff --git a/go_owned_packed_arithmetic_test.go b/go_owned_packed_arithmetic_test.go
new file mode 100644
index 000000000..560502eba
--- /dev/null
+++ b/go_owned_packed_arithmetic_test.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func ownedPackedArithmeticNames() []string {
+	// The independent complete Go add/subtract inventory includes PADDD's
+	// PADDL alias. The existing word and low-product tables own PMULLW/D.
+	return append(append([]string(nil), x86LegacyIntegerArithmeticTestNames...), "PMULLW", "PMULLD")
+}
+
+func ownedPackedArithmeticTable() string {
+	return strings.Replace(ownedIndexedVectorTable(), "8,$256", "8,$512", 1)
+}
+
+func ownedPackedArithmeticFunction(name, opcode, arch, address string, loop bool) (string, string) {
+	move, lea, subtract, word := "MOVQ", "LEAQ", "SUBQ", 8
+	if arch == "386" {
+		move, lea, subtract, word = "MOVL", "LEAL", "SUBL", 4
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s n+0(FP),CX\nPXOR X0,X0\n", name, word*2, move)
+	base := "AX"
+	switch address {
+	case "lea":
+		fmt.Fprintf(&source, "%s numericBytes<>(SB),AX\n", lea)
+	case "move", "copy":
+		fmt.Fprintf(&source, "%s $numericBytes<>(SB),AX\n", move)
+		if address == "copy" {
+			fmt.Fprintf(&source, "%s AX,BX\n", move)
+			base = "BX"
+		}
+	}
+	if loop {
+		fmt.Fprintf(&source, "again%s:\n", name)
+	}
+	for _, offset := range []int{0, 16, 480} {
+		memory := fmt.Sprintf("%d(%s)", offset, base)
+		if address == "direct" {
+			memory = fmt.Sprintf("numericBytes<>+%d(SB)", offset)
+		}
+		fmt.Fprintf(&source, "%s %s,X0\n", opcode, memory)
+	}
+	if loop {
+		// The count is not a literal index. The literal-only abstract state
+		// retains an unknown word before/after SUB; the result CFG owns NUM.
+		fmt.Fprintf(&source, "%s $1,CX\nJNE again%s\n", subtract, name)
+	}
+	fmt.Fprintf(&source, "%s X0,AX\n%s AX,ret+%d(FP)\nRET\n", move, move, word)
+	return source.String(), fmt.Sprintf("func %s(n uintptr) uintptr\n", name)
+}
+
+func TestX86OwnedPackedArithmeticSourceFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, address := range []string{"lea", "move", "copy"} {
+			for _, loop := range []bool{false, true} {
+				var assembly strings.Builder
+				assembly.WriteString(ownedPackedArithmeticTable())
+				for index, op := range ownedPackedArithmeticNames() {
+					source, _ := ownedPackedArithmeticFunction(fmt.Sprintf("Value%d", index), op, arch, address, loop)
+					assembly.WriteString(source)
+				}
+				goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+				file, err := Parse(ArchAMD64, assembly.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := testResolveSym(ordinaryGlobalReadPackage)
+				values := x86LoweredStaticAddressValues(file, resolve, nil, arch)
+				if len(file.Funcs) != 19 || values == nil || values.numericLiterals["numericBytes<>"] != 512 {
+					t.Fatal("complete arithmetic family or readonly numerical object changed", values)
+				}
+				for index, fn := range file.Funcs {
+					t.Run(fmt.Sprintf("%s/%s/loop%t/%s", arch, address, loop, ownedPackedArithmeticNames()[index]), func(t *testing.T) {
+						typ, word := I64, int64(8)
+						if arch == "386" {
+							typ, word = I32, 4
+						}
+						sig := FuncSig{Name: resolve(fn.Sym), Args: []LLVMType{typ}, Ret: typ, Frame: FrameLayout{
+							Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+							Results: []FrameSlot{{Offset: word, Type: typ, Index: 0, Field: -1}},
+						}}
+						facts, err := proveX86SDKLiteralAccesses(fn, sig, arch, values.numericLiterals)
+						if err != nil || len(facts) != 4 {
+							t.Fatal("literal base or invariant loop lost its independent complete-source proof", facts, err)
+						}
+						c := &amd64Ctx{fpStaticAddressValues: values}
+						reads := c.ownedIndexedVectorReads(fn, sig, arch)
+						if len(reads) != 3 {
+							t.Fatal("complete owned DATA arithmetic reads were not handed off", len(reads))
+						}
+						for ordinal, fact := range reads {
+							operand, width, valid := x86OwnedIndexedVectorReadAt(reads, ordinal, fn.Instrs[ordinal])
+							if !valid || width != 16 || fact.Symbol != "numericBytes<>" || fact.Minimum != fact.Maximum ||
+								!reflect.DeepEqual(operand, fn.Instrs[ordinal].Args[0]) {
+								t.Fatal("exact instruction/operand/extent identity changed", fact)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86OwnedPackedArithmeticFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			source.WriteString(ownedPackedArithmeticTable())
+			count := 0
+			for _, address := range []string{"direct", "lea", "move", "copy"} {
+				for _, loop := range []bool{false, true} {
+					for _, opcode := range ownedPackedArithmeticNames() {
+						assembly, declaration := ownedPackedArithmeticFunction(fmt.Sprintf("Value%d", count), opcode, target.arch, address, loop)
+						source.WriteString(assembly)
+						declarations.WriteString(declaration)
+						count++
+					}
+				}
+			}
+			if count != 152 {
+				t.Fatal("complete family/address/loop inventory changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete owned readonly arithmetic failed public translation", err)
+					}
+					if strings.Count(ir, "asm sideeffect ") != count*3 {
+						t.Fatal("legacy full-m128 opcode/fault inventory changed")
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86OwnedPackedArithmeticRetainsAuthorityBoundaries(t *testing.T) {
+	function, declaration := ownedPackedArithmeticFunction("Value", "PADDD", "amd64", "lea", true)
+	base := ownedPackedArithmeticTable() + function
+	for _, change := range []struct{ name, before, after string }{
+		{"extent", "8,$512", "8,$495"},
+		{"mutable", "8,$512", "0,$512"},
+		{"relocation", "$0x719283a4b5c6d7e8", "$external(SB)"},
+		{"unknown vector", "PXOR X0,X0\n", ""},
+		{"numerical base", "LEAQ numericBytes<>(SB),AX", "MOVQ $512,AX"},
+		{"pointer as index", "PADDD 0(AX),X0", "PADDD 0(AX)(AX*1),X0"},
+		{"partial pointer", "againValue:\n", "againValue:\nMOVB $0,AL\n"},
+		{"changed origin", "SUBQ $1,CX", "LEAQ other<>(SB),AX\nSUBQ $1,CX"},
+		{"cleared origin", "SUBQ $1,CX", "MOVQ $0,AX\nSUBQ $1,CX"},
+		{"vector clobber", "SUBQ $1,CX", "MOVQ X0,AX\nSUBQ $1,CX"},
+		{"pointer write", "PADDD 0(AX),X0", "MOVOU X0,0(AX)\nPADDD 0(AX),X0"},
+		{"pointer escape", "PADDD 0(AX),X0", "MOVQ AX,ret+8(FP)\nPADDD 0(AX),X0"},
+		{"raw", "SUBQ $1,CX", "BYTE $0x90\nSUBQ $1,CX"},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			if strings.Count(base, change.before) != 1 {
+				t.Fatal("negative control lost its exact source location", change.name)
+			}
+			source := strings.Replace(base, change.before, change.after, 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if change.name == "numerical base" {
+					x86RequireNumericNativeSourceContext(t, source, declaration, "amd64")
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					if err != nil || !strings.Contains(ir, "call <4 x float> asm sideeffect \"paddd ") || !strings.Contains(ir, "~{memory}") {
+						t.Fatal("numerical base lost the original m128 PADDD access", api, err)
+					}
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+				} else if change.name == "unknown vector" {
+					x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				} else if err == nil || ir != "" {
+					t.Fatal("owned DATA arithmetic borrowed a different input/extent/origin contract", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86OwnedPackedArithmeticFactsCannotMove(t *testing.T) {
+	ins := x86PureGPUnknownInstruction(t, "PADDD 16(AX),X0")
+	reads := map[int]x86SDKLiteralAccess{3: {Operand: 0, Width: 16, Original: ins}}
+	if operand, width, valid := x86OwnedIndexedVectorReadAt(reads, 3, ins); !valid || width != 16 || !reflect.DeepEqual(operand, ins.Args[0]) {
+		t.Fatal("positive exact instruction-local fact was not consumed")
+	}
+	for _, change := range []struct {
+		name    string
+		ordinal int
+		ins     Instr
+	}{
+		{"ordinal", 4, ins},
+		{"opcode", 3, x86PureGPUnknownInstruction(t, "PSUBL 16(AX),X0")},
+		{"offset", 3, x86PureGPUnknownInstruction(t, "PADDD 17(AX),X0")},
+		{"base", 3, x86PureGPUnknownInstruction(t, "PADDD 16(BX),X0")},
+		{"destination", 3, x86PureGPUnknownInstruction(t, "PADDD 16(AX),X1")},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			if _, _, valid := x86OwnedIndexedVectorReadAt(reads, change.ordinal, change.ins); valid {
+				t.Fatal("owned read was reused after instruction/ordinal mutation")
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralCompleteStoreAndPackedMoveEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var original strings.Builder
+		original.WriteString("TEXT ·effects(SB),4,$0-16\n")
+		for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+			if arch == "386" && op == "MOVQ" {
+				continue
+			}
+			for _, destination := range []string{"ret+0(FP)", "0(CX)"} {
+				for _, source := range []string{"AX", "$1"} {
+					text := op + " " + source + "," + destination
+					original.WriteString(text + "\n")
+					t.Run(arch+"/"+text, func(t *testing.T) {
+						state := x86SDKLiteralState{}
+						state.gp[3] = x86SDKLiteralValue{symbol: "numericBytes<>"}
+						before := state
+						if err := x86SDKLiteralTransfer(x86PureGPUnknownInstruction(t, text), &state, FuncSig{}, arch, nil); err != nil || state != before {
+							t.Fatal("ordinary typed store changed an unrelated literal origin", err)
+						}
+						if source == "AX" {
+							state.gp[0] = state.gp[3]
+							if err := x86SDKLiteralTransfer(x86PureGPUnknownInstruction(t, text), &state, FuncSig{}, arch, nil); err == nil {
+								t.Fatal("literal source escaped through a numerical scalar store")
+							}
+						}
+					})
+				}
+			}
+		}
+		original.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+	}
+	var original strings.Builder
+	original.WriteString("TEXT ·moves(SB),4,$0-0\n")
+	for _, row := range fixedLocalPackedMoveOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if bank == "Z" && !row.evex {
+				continue
+			}
+			for _, operands := range []string{"0(CX)," + bank + "0", bank + "0," + bank + "1", bank + "0,0(CX)"} {
+				text := row.name + " " + operands
+				original.WriteString(text + "\n")
+				t.Run(text, func(t *testing.T) {
+					state := x86SDKLiteralState{}
+					state.gp[3] = x86SDKLiteralValue{symbol: "numericBytes<>"}
+					before := state
+					if err := x86SDKLiteralTransfer(x86PureGPUnknownInstruction(t, text), &state, FuncSig{}, "amd64", nil); err != nil || state != before {
+						t.Fatal("complete packed move changed an unrelated literal origin", err)
+					}
+				})
+			}
+		}
+	}
+	original.WriteString("RET\n")
+	goAssemblerOracleOutput(t, "amd64", original.String(), "", true)
+}
+
+func TestGoX86SDKLiteralLoopEntryCannotBorrowAnotherPath(t *testing.T) {
+	source := `TEXT ·entry<ABIInternal>(SB),4,$0-16
+CMPQ AX,$0
+JE incoming
+MOVQ $numericBytes<>(SB),BX
+JMP selected
+incoming:
+MOVQ DI,BX
+selected:
+TESTQ CX,CX
+join:
+MOVOU 0(BX),X0
+SUBQ $1,CX
+JNE join
+MOVQ X0,AX
+RET
+`
+	sig := FuncSig{Name: "example.invalid/owner.entry", Args: []LLVMType{I64, I64, I64, Ptr}, Ret: I64}
+	for _, sameOwner := range []bool{true, false} {
+		t.Run(fmt.Sprintf("same-owner=%t", sameOwner), func(t *testing.T) {
+			text := source
+			if sameOwner {
+				text = strings.Replace(text, "MOVQ DI,BX", "MOVQ $numericBytes<>(SB),BX", 1)
+			}
+			file, err := Parse(ArchAMD64, text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericBytes<>": 512})
+			if sameOwner {
+				if err != nil || len(facts) != 3 {
+					t.Fatal("both independent stable literal loop entries must succeed", facts, err)
+				}
+			} else if err == nil || facts != nil || !strings.Contains(err.Error(), "mixed origin") {
+				t.Fatal("a prior branch's stable label state authorized an unrelated incoming origin", facts, err)
+			}
+		})
+	}
+}
diff --git a/go_owned_symbol_indexed_vector_read_test.go b/go_owned_symbol_indexed_vector_read_test.go
new file mode 100644
index 000000000..661f77d09
--- /dev/null
+++ b/go_owned_symbol_indexed_vector_read_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func ownedSymbolIndexedVectorSource(t *testing.T, rows []ordinaryGlobalVectorCase) (string, string) {
+	t.Helper()
+	source, declarations := ownedIndexedVectorSource(t, rows, "386")
+	const materialize = "MOVL $numericBytes<>(SB),AX\n"
+	const indirect = "(AX)(CX*8)"
+	if strings.Count(source, materialize) != len(rows) || strings.Count(source, indirect) != len(rows) {
+		t.Fatal("complete source fixture lost its exact address/read pairs")
+	}
+	// Mode32 directly encodes a static symbol plus an index. There is no GP
+	// address materialization to borrow, and CX keeps its actual bounded ADDL.
+	source = strings.ReplaceAll(source, materialize, "")
+	source = strings.ReplaceAll(source, indirect, "numericBytes<>(SB)(CX*8)")
+	return source, declarations
+}
+
+func TestGoModuleOwnedReadonlySymbolIndexedVectorSourceFacts(t *testing.T) {
+	for _, opcode := range []string{"PAND", "PSHUFB"} {
+		t.Run(opcode, func(t *testing.T) {
+			source, _ := ownedSymbolIndexedVectorSource(t,
+				[]ordinaryGlobalVectorCase{{opcode + " ·words+16(SB),X2", "X", 2}})
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := testResolveSym(ordinaryGlobalReadPackage)
+			values := x86LoweredStaticAddressValues(file, resolve, nil, "386")
+			if values == nil || values.numericLiterals["numericBytes<>"] != 256 {
+				t.Fatal("complete private RODATA directory missing", values)
+			}
+			sig := FuncSig{Name: resolve(file.Funcs[0].Sym), Args: []LLVMType{I32}, Ret: I32,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+				}}
+			facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "386", values.numericLiterals)
+			if err != nil || len(facts) != 1 || facts[0].Address || facts[0].Width != 16 ||
+				facts[0].Minimum != 0 || facts[0].Maximum != 240 {
+				t.Fatal("direct symbol/index lost its complete pure CFG range proof", facts, err)
+			}
+			c := &amd64Ctx{fpStaticAddressValues: values}
+			reads := c.ownedIndexedVectorReads(file.Funcs[0], sig, "386")
+			if len(reads) != 1 || !reflect.DeepEqual(reads[facts[0].Instruction], facts[0]) {
+				t.Fatal("proved direct symbol/index read was not handed off unchanged", facts, reads)
+			}
+		})
+	}
+}
+
+func TestGoModuleOwnedReadonlySymbolIndexedVectorCompleteFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := ownedIndexedVectorCases(t, "386") // All 116 logical plus four shuffle forms.
+	for _, target := range []string{"i386-unknown-linux-gnu", "i386-pc-windows-gnu", "i686-pc-windows-msvc"} {
+		t.Run(target, func(t *testing.T) {
+			for start := 0; start < len(rows); start += 32 {
+				end := start + 32
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch-%02d", start/32), func(t *testing.T) {
+					source, declarations := ownedSymbolIndexedVectorSource(t, rows[start:end])
+					goAssemblerOracleOutput(t, "386", source, "", true)
+					for _, api := range []string{"public", "owned-context"} {
+						t.Run(api, func(t *testing.T) {
+							pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+							ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "386", target, api)
+							if err != nil || ir == "" {
+								t.Fatal("bounded direct-symbol table read needs no SDK or GP-address capture", err)
+							}
+							compileLLVMToObject(t, llc, target, "owned-symbol-indexed.ll", "owned-symbol-indexed.o", ir)
+						})
+					}
+				})
+			}
+			t.Logf("complete mode32 direct-symbol union: %d logical/shuffle memory forms", len(rows))
+		})
+	}
+}
+
+func TestGoModuleOwnedReadonlySymbolIndexedVectorRetainsBounds(t *testing.T) {
+	base, declarations := ownedSymbolIndexedVectorSource(t,
+		[]ordinaryGlobalVectorCase{{"PAND ·words+16(SB),X2", "X", 2}})
+	const read = "PAND numericBytes<>(SB)(CX*8),X2"
+	for _, mutation := range []struct{ name, before, after string }{
+		{"no-bound", "CMPL CX,$16\nJAE outside0\n", ""},
+		{"wrong-edge", "JAE outside0", "JB outside0"},
+		{"stale-flags", "JAE outside0", "ADDL $1,CX\nJAE outside0"},
+		{"past-extent", "CMPL CX,$16", "CMPL CX,$17"},
+		{"unknown-index", "MOVL n+0(FP),CX", "NOP"},
+		{"partial-index", "ADDL CX,CX", "MOVB $255,CL\nADDL CX,CX"},
+		{"overflowing-index", "ADDL CX,CX", "ADDL $0x7ffffff0,CX\nADDL CX,CX"},
+		{"literal-index", "ADDL CX,CX", "MOVL $numericBytes<>(SB),CX"},
+		{"displaced-outside", read, "PAND numericBytes<>+16(SB)(CX*8),X2"},
+		{"mutable-table", "GLOBL numericBytes<>(SB),8,$256", "GLOBL numericBytes<>(SB),0,$256"},
+		{"relocation", "DATA numericBytes<>+0(SB)/8,$0x719283a4b5c6d7e8", "DATA numericBytes<>+0(SB)/8,$external(SB)"},
+		{"write", read, "MOVOU X2,numericBytes<>(SB)(CX*8)\n" + read},
+		{"raw", "ADDL CX,CX", "BYTE $0x90\nADDL CX,CX"},
+		{"unowned-symbol", read, "PAND foreignBytes<>(SB)(CX*8),X2"},
+		{"unknown-vector", "PXOR X2,X2\n", ""},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(mutation.name+"/"+api, func(t *testing.T) {
+				if strings.Count(base, mutation.before) != 1 {
+					t.Fatal("negative control did not select one actual source boundary", mutation.name)
+				}
+				source := strings.Replace(base, mutation.before, mutation.after, 1)
+				pkg := mustGoPackage(t, ordinaryGlobalReadPackage, "package ordinaryglobals\n"+declarations)
+				ir, err := ordinaryGlobalReadRequest(t, pkg, []byte(source), "386", "i386-pc-windows-gnu", api)
+				if err == nil || ir != "" {
+					t.Fatal("direct-symbol table read gained unbounded, mutable or uninitialized authority", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_preprocessed_source_test.go b/go_preprocessed_source_test.go
new file mode 100644
index 000000000..d1a0333a2
--- /dev/null
+++ b/go_preprocessed_source_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoModulePreprocessedSourceDoesNotInventDefinitions(t *testing.T) {
+	t.Setenv("GOAMD64", "v4")
+	pkg := mustGoPackage(t, "example.com/preprocessed", "package preprocessed\nconst Value = 42\nfunc Read() uint64\n")
+	for _, definition := range []struct {
+		name, source, value string
+	}{
+		{"ambient feature", "GOAMD64_v4", "1"},
+		{"unincluded generated constant", "const_Value", "42"},
+	} {
+		t.Run(definition.name, func(t *testing.T) {
+			source := []byte("TEXT ·Read(SB),4,$0-8\nMOVQ $" + definition.source + ",AX\nMOVQ AX,ret+0(FP)\nRET\n")
+			options := GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: testResolveSym(pkg.Path)}
+			// The default API keeps its historical expansion contract. It is
+			// not the entry used by an independently preprocessed compiler.
+			legacy, err := TranslateGoModule(pkg, source, options)
+			if err != nil {
+				t.Fatal("default GoModule expansion changed", err)
+			}
+			ir := legacy.Module.String()
+			legacy.Module.Dispose()
+			if !strings.Contains(ir, "i64 "+definition.value) {
+				t.Fatal("default control did not expand its definition", ir)
+			}
+			options.SourcePreprocessed = true
+			if result, err := TranslateGoModule(pkg, source, options); err == nil || result != nil {
+				if result != nil {
+					result.Module.Dispose()
+				}
+				t.Fatal("preprocessed source borrowed an ambient/generated definition", err)
+			}
+			resolved := []byte(strings.Replace(string(source), definition.source, definition.value, 1))
+			result, err := TranslateGoModule(pkg, resolved, options)
+			if err != nil {
+				t.Fatal("complete independently expanded source rejected", err)
+			}
+			result.Module.Dispose()
+		})
+	}
+}
+
+func TestGoModulePreprocessedSourceRejectsResidualCPP(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/preprocessed", "package preprocessed\nfunc Read() uint64\n")
+	const body = "TEXT ·Read(SB),4,$0-8\nMOVQ $42,AX\nMOVQ AX,ret+0(FP)\nRET\n"
+	for _, source := range []string{
+		"#include \"missing.h\"\n" + body,
+		"#define UNUSED 1\n" + body,
+		"#ifdef GOARCH_amd64\n" + body + "#endif\n",
+		"#line 1 \"other.s\"\n" + body,
+	} {
+		result, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOOS: "linux", GOARCH: "amd64",
+			TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path), SourcePreprocessed: true})
+		if err == nil || result != nil {
+			if result != nil {
+				result.Module.Dispose()
+			}
+			t.Fatal("preprocessed input silently reprocessed a remaining directive", source, err)
+		}
+	}
+}
+
+func TestGoModulePreprocessedSourceCannotReplaceCapturedAuthorities(t *testing.T) {
+	for _, authority := range []string{"numerical", "TLS", "ARM64 byte carrier", "mixed"} {
+		t.Run(authority, func(t *testing.T) {
+			options := GoModuleOptions{SourcePreprocessed: true,
+				ResolveSym: func(string) string { t.Fatal("incompatible authority reached resolver"); return "" },
+				KeepFunc:   func(string, string) bool { t.Fatal("incompatible authority reached filter"); return true },
+				ManualSig: func(string) (FuncSig, bool) {
+					t.Fatal("incompatible authority reached signature callback")
+					return FuncSig{}, false
+				}}
+			if authority == "numerical" || authority == "mixed" {
+				options.NumericalReads = new(GoX86NumericalReadBinding)
+			}
+			if authority == "TLS" || authority == "mixed" {
+				options.X86TLSMoves = new(GoX86TLSMoveBinding)
+			}
+			if authority == "ARM64 byte carrier" || authority == "mixed" {
+				options.ARM64ByteCarrierSource = new(GoARM64ByteCarrierSource)
+			}
+			result, err := TranslateGoModule(GoPackage{}, nil, options)
+			if !errors.Is(err, ErrProbeNeedsContext) || result != nil {
+				if result != nil {
+					result.Module.Dispose()
+				}
+				t.Fatal("preprocessed flag replaced or consumed a captured source authority", result, err)
+			}
+		})
+	}
+}
diff --git a/go_signature_replay_test.go b/go_signature_replay_test.go
new file mode 100644
index 000000000..84fa6aad9
--- /dev/null
+++ b/go_signature_replay_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"testing"
+)
+
+func TestDeriveGoFuncABI0SignatureUsesActualTargetGCSizes(t *testing.T) {
+	const source = `package replay
+type Value uint16
+type Alias = Value
+const (
+	_ = iota
+	Width
+	Count = Width + 2
+)
+type Row struct {
+	Pad byte
+	Payload [Count]Alias
+	Tail uintptr
+}
+func Probe(a uint8, r Row) (answer uintptr, ok bool)
+`
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			set := token.NewFileSet()
+			file, err := parser.ParseFile(set, "replay.go", source, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sizes := types.SizesFor("gc", arch)
+			pkg, err := (&types.Config{Sizes: sizes}).Check("example.invalid/replay", set, []*ast.File{file}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := pkg.Scope().Lookup("Probe").(*types.Func)
+			actual, err := DeriveGoFuncABI0Signature("example.invalid/replay.Probe", function, arch, sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			word, wordType := int64(4), I32
+			rowType := LLVMType("{ i8, [3 x i16], i32 }")
+			if arch == "amd64" || arch == "arm64" || arch == "wasm" {
+				word, wordType = 8, I64
+				rowType = "{ i8, [3 x i16], i64 }"
+			}
+			result := word + 8 + word
+			want := FuncSig{
+				Name: "example.invalid/replay.Probe",
+				Args: []LLVMType{I8, rowType},
+				Ret:  LLVMType("{ " + string(wordType) + ", i1 }"),
+				Frame: FrameLayout{
+					Params: []FrameSlot{
+						{Offset: 0, Type: I8, Index: 0, Field: -1},
+						{Offset: word, Type: I8, Index: 1, Field: 0},
+						{Offset: word + 2, Type: I16, Index: 1, Field: 1, Fields: []int{1, 0}},
+						{Offset: word + 4, Type: I16, Index: 1, Field: 1, Fields: []int{1, 1}},
+						{Offset: word + 6, Type: I16, Index: 1, Field: 1, Fields: []int{1, 2}},
+						{Offset: word + 8, Type: wordType, Index: 1, Field: 2},
+					},
+					Results: []FrameSlot{
+						{Offset: result, Type: wordType, Index: 0, Field: -1, Name: "answer"},
+						{Offset: result + word, Type: I1, Index: 1, Field: -1, Name: "ok"},
+					},
+				},
+			}
+			if !reflect.DeepEqual(actual, want) {
+				t.Fatalf("actual typed %s ABI0 signature:\n%#v\nwant:\n%#v", arch, actual, want)
+			}
+			ordinary, err := goFuncSigForDeclaredFunc(want.Name, function, arch, sizes, sizes, true)
+			if err != nil || !reflect.DeepEqual(actual, ordinary) {
+				t.Fatalf("thin replay API changed the ordinary builder: %v", err)
+			}
+		})
+	}
+}
+
+func TestDeriveGoFuncABI0SignatureRejectsMissingOrUnsupportedDeclaration(t *testing.T) {
+	if _, err := DeriveGoFuncABI0Signature("", nil, "arm64", nil); err == nil {
+		t.Fatal("missing actual declaration supplied an ABI")
+	}
+	if _, err := DeriveGoFuncABI0Signature("Probe", types.NewFunc(token.NoPos, nil, "Probe", nil), "arm64", nil); err == nil {
+		t.Fatal("untyped function supplied an ABI")
+	}
+	pkg := mustGoPackage(t, "example.invalid/replay", "package replay\nfunc Probe(args ...uint64)\n")
+	if _, err := DeriveGoFuncABI0Signature("example.invalid/replay.Probe", pkg.Types.Scope().Lookup("Probe").(*types.Func), "arm64", nil); err == nil {
+		t.Fatal("variadic declaration supplied an ordinary assembly ABI")
+	}
+	pkg = mustGoPackage(t, "example.invalid/replay", "package replay\nfunc Probe()\n")
+	if _, err := DeriveGoFuncABI0Signature("example.invalid/replay.Probe", pkg.Types.Scope().Lookup("Probe").(*types.Func), "unknown", nil); err == nil {
+		t.Fatal("unknown target supplied a Go gc ABI")
+	}
+}
diff --git a/go_source_context_terminal.go b/go_source_context_terminal.go
new file mode 100644
index 000000000..7ec44164a
--- /dev/null
+++ b/go_source_context_terminal.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"time"
+)
+
+// This is only an existing source role's frozen lifetime, not a source token.
+// Ordinary frames additionally bind the original Done channel and may have no
+// deadline; SDK roles retain their independently required bounded deadline.
+type goSourceContextLifetime struct {
+	deadline  time.Time
+	bounded   bool
+	done      <-chan struct{}
+	checkDone bool
+}
+
+type goSourceContextSample struct {
+	callerDeadline           time.Time
+	callerBounded            bool
+	callerDone, originalDone <-chan struct{}
+}
+
+// Context methods are arbitrary caller callbacks. All Err/Done callbacks and
+// any caller deadline sample precede the terminal original Deadline. A
+// potentially successful return invokes no user callback after that sample.
+// Captured channels can still reveal cancellation caused by Deadline itself.
+func sampleGoSourceContext(caller, original context.Context, lifetime goSourceContextLifetime, callerDeadline bool, changed error) (sample goSourceContextSample, result error) {
+	if caller == nil || original == nil {
+		return sample, changed
+	}
+	if err := errors.Join(caller.Err(), original.Err()); err != nil {
+		return sample, err
+	}
+	if callerDeadline {
+		sample.callerDeadline, sample.callerBounded = caller.Deadline()
+	}
+	if err := errors.Join(caller.Err(), original.Err()); err != nil {
+		return sample, err
+	}
+	sample.callerDone, sample.originalDone = caller.Done(), original.Done()
+	deadline, bounded := original.Deadline()
+	if bounded != lifetime.bounded || bounded && !deadline.Equal(lifetime.deadline) ||
+		lifetime.checkDone && sample.originalDone != lifetime.done {
+		result = changed
+	}
+	if goSourceContextDone(sample.callerDone) || goSourceContextDone(sample.originalDone) {
+		// This branch cannot succeed. Err is read only to preserve the actual
+		// cancellation cause; an inconsistent closed-Done/Err-nil context
+		// still fails, without retrying or taking another lifetime snapshot.
+		if err := errors.Join(caller.Err(), original.Err()); err != nil {
+			return sample, errors.Join(result, err)
+		}
+		return sample, changed
+	}
+	return sample, result
+}
+
+func goSourceContextDone(done <-chan struct{}) bool {
+	select {
+	case <-done:
+		return true
+	default:
+		return false
+	}
+}
diff --git a/go_source_context_terminal_test.go b/go_source_context_terminal_test.go
new file mode 100644
index 000000000..a198ac26b
--- /dev/null
+++ b/go_source_context_terminal_test.go
@@ -0,0 +1,386 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+type sourceTerminalTestContext struct {
+	context.Context
+	errCalls, deadlineCalls, doneCalls int
+	shift                              time.Duration
+	lost                               bool
+	callback                           func(string, int)
+	additionalCause                    error
+	doneOverride                       <-chan struct{}
+	useDoneOverride                    bool
+}
+
+func (ctx *sourceTerminalTestContext) Err() error {
+	ctx.errCalls++
+	if ctx.callback != nil {
+		ctx.callback("Err", ctx.errCalls)
+	}
+	err := ctx.Context.Err()
+	if err != nil {
+		return errors.Join(err, ctx.additionalCause)
+	}
+	return nil
+}
+
+func (ctx *sourceTerminalTestContext) Deadline() (time.Time, bool) {
+	ctx.deadlineCalls++
+	if ctx.callback != nil {
+		ctx.callback("Deadline", ctx.deadlineCalls)
+	}
+	deadline, bounded := ctx.Context.Deadline()
+	return deadline.Add(ctx.shift), bounded && !ctx.lost
+}
+
+func (ctx *sourceTerminalTestContext) Done() <-chan struct{} {
+	ctx.doneCalls++
+	if ctx.callback != nil {
+		ctx.callback("Done", ctx.doneCalls)
+	}
+	if ctx.useDoneOverride {
+		return ctx.doneOverride
+	}
+	return ctx.Context.Done()
+}
+
+// These are lifetime predicates only. None of these zero-ready values is
+// passed to a source/owner constructor, Verify, Bind or publication API.
+func sourceTerminalTestRoutes() map[string]func(context.Context, *sourceTerminalTestContext, time.Time) error {
+	return map[string]func(context.Context, *sourceTerminalTestContext, time.Time) error{
+		"SDK-metadata": func(caller context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			return (&GoX86SDKASMDataSource{context: original, originalContext: original, originalDeadline: frozen}).liveContext(caller)
+		},
+		"SDK-readonly": func(caller context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			return (&GoX86SDKReadonlyLiteralDataOwner{context: original, originalContext: original, originalDeadline: frozen}).liveContext(caller)
+		},
+		"SDK-minimum": func(caller context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			return (&GoX86SDKLiteralAlignment{context: original, originalContext: original, deadline: frozen}).liveContext(caller)
+		},
+		"SDK-private-bridge": func(caller context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			_, stop, err := sdkASMDataPrivateContext(caller, original, frozen)
+			if stop != nil {
+				stop()
+			}
+			return err
+		},
+		"ordinary-frame": func(_ context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			return (&goAMD64FramePrivateContext{Context: context.Background(), original: original, deadline: frozen,
+				bounded: true, done: original.Context.Done(), cancel: func() {}}).verify()
+		},
+		"SDK-numerical-join": func(caller context.Context, original *sourceTerminalTestContext, frozen time.Time) error {
+			owner := &GoX86SDKReadonlyLiteralDataOwner{context: original.Context, originalContext: original.Context, originalDeadline: frozen}
+			return (&numericalSDKLiteralJoin{context: original, Deadline: frozen, owner: owner}).liveContext(caller)
+		},
+	}
+}
+
+func TestGoSourceContextTerminalSuccessHasNoLaterCallbacks(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		t.Run(name, func(t *testing.T) {
+			base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			frozen, _ := base.Deadline()
+			original := &sourceTerminalTestContext{Context: base}
+			terminal, later := false, 0
+			original.callback = func(method string, _ int) {
+				if terminal {
+					later++
+				}
+				if method == "Deadline" {
+					terminal = true
+				}
+			}
+			err := invoke(context.Background(), original, frozen)
+			t.Logf("Err=%d Deadline=%d Done=%d later=%d error=%v", original.errCalls, original.deadlineCalls, original.doneCalls, later, err)
+			if err != nil || !terminal || later != 0 {
+				t.Fatal("successful terminal deadline was followed by user callbacks", err)
+			}
+		})
+	}
+}
+
+func TestGoSourceContextTerminalLostBound(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		t.Run(name, func(t *testing.T) {
+			base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			frozen, _ := base.Deadline()
+			original := &sourceTerminalTestContext{Context: base}
+			original.callback = func(method string, count int) {
+				if method == "Err" && count == 2 {
+					original.lost = true
+				}
+			}
+			if err := invoke(context.Background(), original, frozen); !original.lost || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("last Err removed the original bound", err)
+			}
+		})
+	}
+}
+
+func TestGoSourceContextTerminalCaptureCannotFreezeStaleLifetime(t *testing.T) {
+	base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	original := &sourceTerminalTestContext{Context: base}
+	original.callback = func(method string, count int) {
+		if method == "Err" && count == 2 {
+			original.shift = time.Minute
+		}
+	}
+	private, err := captureGoAMD64FramePrivateContext(original)
+	if private != nil {
+		private.stop()
+	}
+	t.Logf("Err=%d Deadline=%d Done=%d shift=%s error=%v", original.errCalls, original.deadlineCalls, original.doneCalls, original.shift, err)
+	if original.shift == 0 || !errors.Is(err, ErrProbeNeedsContext) || private != nil {
+		t.Fatal("frame capture published an already stale lifetime", err)
+	}
+}
+
+func TestGoSourceContextTerminalOriginalErrCannotChangeLifetime(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		for _, shift := range []time.Duration{-time.Minute, time.Minute} {
+			t.Run(name+"/"+shift.String(), func(t *testing.T) {
+				base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+				defer cancel()
+				frozen, _ := base.Deadline()
+				original := &sourceTerminalTestContext{Context: base}
+				original.callback = func(method string, count int) {
+					if method == "Err" && count == 2 {
+						original.shift = shift
+					}
+				}
+				err := invoke(context.Background(), original, frozen)
+				t.Logf("Err=%d Deadline=%d Done=%d shift=%s error=%v", original.errCalls, original.deadlineCalls, original.doneCalls, original.shift, err)
+				if original.shift != shift || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("late original Err changed lifetime after the accepted snapshot", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoSourceContextTerminalJoinedOwnerCallbackCannotChangeLifetime(t *testing.T) {
+	base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	frozen, _ := base.Deadline()
+	original := &sourceTerminalTestContext{Context: base}
+	original.callback = func(method string, count int) {
+		if method == "Err" && count == 4 {
+			original.shift = time.Minute
+		}
+	}
+	owner := &GoX86SDKReadonlyLiteralDataOwner{context: base, originalContext: base, originalDeadline: frozen}
+	joined := &numericalSDKLiteralJoin{context: original, Deadline: frozen, owner: owner}
+	err := joined.liveContext(original)
+	t.Logf("Err=%d Deadline=%d Done=%d shift=%s error=%v", original.errCalls, original.deadlineCalls, original.doneCalls, original.shift, err)
+	if original.shift == 0 || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("joined context changed during the owner's last callback", err)
+	}
+}
+
+func TestGoSourceContextTerminalCancellationSignalsAndCauses(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		for _, method := range []string{"Err", "Done", "Deadline", "Deadline-and-change"} {
+			t.Run(name+"/"+method, func(t *testing.T) {
+				base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+				defer cancel()
+				frozen, _ := base.Deadline()
+				cause := errors.New("original caller cancellation cause")
+				original := &sourceTerminalTestContext{Context: base, additionalCause: cause}
+				reached := false
+				original.callback = func(sampled string, count int) {
+					if method == "Err" && sampled == "Err" && count == 2 || method == "Done" && sampled == "Done" && count == 1 ||
+						(method == "Deadline" || method == "Deadline-and-change") && sampled == "Deadline" && count == 1 {
+						reached = true
+						cancel()
+						if method == "Deadline-and-change" {
+							original.shift = time.Minute
+						}
+					}
+				}
+				err := invoke(context.Background(), original, frozen)
+				if !reached || !errors.Is(err, context.Canceled) || !errors.Is(err, cause) {
+					t.Fatal("callback cancellation lost the actual cause", err)
+				}
+				if method == "Deadline-and-change" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed lifetime lost its independent classification", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoSourceContextTerminalClosedDoneCannotReturnSuccess(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		t.Run(name, func(t *testing.T) {
+			base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			frozen, _ := base.Deadline()
+			done := make(chan struct{})
+			original := &sourceTerminalTestContext{Context: base, doneOverride: done, useDoneOverride: true}
+			original.callback = func(method string, count int) {
+				if method == "Deadline" && count == 1 {
+					close(done)
+				}
+			}
+			err := invoke(context.Background(), original, frozen)
+			if !errors.Is(err, ErrProbeNeedsContext) || base.Err() != nil {
+				t.Fatal("closed Done with nil Err acquired a successful lifetime", err)
+			}
+			if original.errCalls > 4 || original.deadlineCalls != 1 || original.doneCalls > 2 {
+				t.Fatal("closed-Done failure resampled or retried user callbacks")
+			}
+		})
+	}
+}
+
+func TestGoSourceContextTerminalSameContextRolesAreBounded(t *testing.T) {
+	for name, invoke := range sourceTerminalTestRoutes() {
+		t.Run(name, func(t *testing.T) {
+			base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			frozen, _ := base.Deadline()
+			original := &sourceTerminalTestContext{Context: base}
+			if err := invoke(original, original, frozen); err != nil {
+				t.Fatal("one unchanged context could not occupy both existing roles", err)
+			}
+			if original.errCalls > 6 || original.deadlineCalls > 2 || original.doneCalls > 3 {
+				t.Fatal("duplicate roles caused an unbounded sampling loop")
+			}
+			if original.errCalls == 0 || original.deadlineCalls == 0 || original.doneCalls == 0 {
+				t.Fatal("context lifetime was not observed")
+			}
+		})
+	}
+}
+
+func TestGoSourceContextTerminalFrameDoneCannotChangeInLastErr(t *testing.T) {
+	base, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	original := &sourceTerminalTestContext{Context: base}
+	private, err := captureGoAMD64FramePrivateContext(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer private.stop()
+	original.errCalls, original.deadlineCalls, original.doneCalls = 0, 0, 0
+	original.callback = func(method string, count int) {
+		if method == "Err" && count == 2 {
+			original.doneOverride, original.useDoneOverride = make(chan struct{}), true
+		}
+	}
+	err = private.verify()
+	if !original.useDoneOverride || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("last Err changed the original frame Done channel after sampling", err)
+	}
+}
+
+func TestGoSourceContextTerminalPrivateBridgeOnlyTightensAndStops(t *testing.T) {
+	for _, axis := range []string{"earlier", "later", "background"} {
+		t.Run(axis, func(t *testing.T) {
+			original, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			frozen, _ := original.Deadline()
+			caller, stopCaller := context.Context(context.Background()), context.CancelFunc(func() {})
+			want := frozen
+			if axis == "earlier" {
+				want = frozen.Add(-30 * time.Second)
+				caller, stopCaller = context.WithDeadline(caller, want)
+			} else if axis == "later" {
+				caller, stopCaller = context.WithDeadline(caller, frozen.Add(time.Minute))
+			}
+			defer stopCaller()
+			private, stop, err := sdkASMDataPrivateContext(caller, original, frozen)
+			if err != nil || private == nil || stop == nil {
+				t.Fatal("unchanged private bridge did not capture actual lifetimes", err)
+			}
+			got, bounded := private.Deadline()
+			stop()
+			if !bounded || !got.Equal(want) || !errors.Is(private.Err(), context.Canceled) || original.Err() != nil || caller.Err() != nil {
+				t.Fatal("private bridge extended a deadline or cleanup changed caller lifetime")
+			}
+		})
+	}
+	for _, axis := range []string{"original", "caller"} {
+		t.Run("signal/"+axis, func(t *testing.T) {
+			original, cancelOriginal := context.WithTimeout(context.Background(), time.Minute)
+			defer cancelOriginal()
+			caller, cancelCaller := context.WithCancel(context.Background())
+			defer cancelCaller()
+			frozen, _ := original.Deadline()
+			private, stop, err := sdkASMDataPrivateContext(caller, original, frozen)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer stop()
+			if axis == "original" {
+				cancelOriginal()
+			} else {
+				cancelCaller()
+			}
+			select {
+			case <-private.Done():
+				if !errors.Is(private.Err(), context.Canceled) {
+					t.Fatal("captured Done did not cancel the private command context")
+				}
+			case <-time.After(2 * time.Second):
+				t.Fatal("private command context lost the captured cancellation signal")
+			}
+		})
+	}
+}
+
+func TestGoSourceContextTerminalIdentityAndBoundedRoleGuards(t *testing.T) {
+	base, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	frozen, _ := base.Deadline()
+	original, replacement := &sourceTerminalTestContext{Context: base}, &sourceTerminalTestContext{Context: base}
+	checks := map[string]func() error{
+		"SDK-metadata": func() error {
+			return (&GoX86SDKASMDataSource{context: replacement, originalContext: original, originalDeadline: frozen}).liveContext(base)
+		},
+		"SDK-readonly": func() error {
+			return (&GoX86SDKReadonlyLiteralDataOwner{context: replacement, originalContext: original, originalDeadline: frozen}).liveContext(base)
+		},
+		"SDK-minimum": func() error {
+			return (&GoX86SDKLiteralAlignment{context: replacement, originalContext: original, deadline: frozen}).liveContext(base)
+		},
+	}
+	for name, check := range checks {
+		t.Run(name, func(t *testing.T) {
+			if err := check(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("shared lifetime sampling replaced the original context identity guard", err)
+			}
+		})
+	}
+	if original.errCalls+replacement.errCalls+original.doneCalls+replacement.doneCalls != 0 {
+		t.Fatal("foreign context identity was sampled before its role rejected it")
+	}
+	for name, invoke := range sourceTerminalTestRoutes() {
+		if name == "ordinary-frame" {
+			continue // Its unchanged unbounded role is independently tested below.
+		}
+		t.Run(name+"/unbounded", func(t *testing.T) {
+			unbounded := &sourceTerminalTestContext{Context: context.Background()}
+			if err := invoke(context.Background(), unbounded, frozen); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("SDK source acquired an unbounded original lifetime", err)
+			}
+		})
+	}
+	private, err := captureGoAMD64FramePrivateContext(context.Background())
+	if err != nil {
+		t.Fatal("ordinary frame lost its distinct unbounded role", err)
+	}
+	defer private.stop()
+	if err := private.verify(); err != nil {
+		t.Fatal("ordinary unbounded lifetime did not verify", err)
+	}
+}
diff --git a/go_translate.go b/go_translate.go
index 40e781d34..3103ef4ce 100644
--- a/go_translate.go
+++ b/go_translate.go
@@ -2,6 +2,8 @@ package plan9asm
 
 import (
 	"bytes"
+	"crypto/sha256"
+	"errors"
 	"fmt"
 	"go/ast"
 	"go/constant"
@@ -10,6 +12,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"text/scanner"
 
 	"github.com/xgo-dev/llvm"
 )
@@ -21,6 +24,16 @@ type GoPackage struct {
 	Types   *types.Package
 	Imports map[string]*types.Package
 	Syntax  []*ast.File
+	// ImportSyntax is the complete selected declaration syntax for entries in
+	// Imports, from the same load/profile as their actual types.Package values.
+	// It supplies only ordinary numerical global-read declarations, never
+	// caller, native-entry, pointer, writable storage or captured SDK authority.
+	ImportSyntax map[string][]*ast.File
+
+	// SourceSelection is the compiler's complete same-profile typed selection.
+	// Nil keeps the existing conservative raw-return pointer contract. Supplying
+	// source data does not itself certify a stack, memory effect or continuation.
+	SourceSelection *GoSourceSelection
 }
 
 // GoModuleOptions configures TranslateGoModule.
@@ -31,6 +44,13 @@ type GoModuleOptions struct {
 	FileName string
 	GOOS     string
 	GOARCH   string
+	// SourcePreprocessed means src is the complete output of the caller's
+	// selected package/target preprocessor, including its generated headers.
+	// Do not expand generated identifiers or apply ambient Go feature macros
+	// again. This supplies no source or native authority and cannot accompany
+	// NumericalReads, X86TLSMoves or ARM64ByteCarrierSource bindings, which
+	// retain their own complete original-source preprocessing contracts.
+	SourcePreprocessed bool
 	// Sizes is the type layout used to type-check the package. When nil,
 	// TranslateGoModule uses the standard gc layout for GOARCH. Callers with a
 	// custom data model, such as Emscripten wasm32 versus Memory64, must pass
@@ -45,10 +65,20 @@ type GoModuleOptions struct {
 	WASMABI        WASMABI
 	X87Mode        X87Mode
 	AnnotateSource bool
+	NumericalReads *GoX86NumericalReadBinding
+	X86TLSMoves    *GoX86TLSMoveBinding
+
+	// ARM64ByteCarrierSource retains the original bounded capture lease.
+	// LLVM Context controls resources, not cancellation or native authority.
+	ARM64ByteCarrierSource *GoARM64ByteCarrierSource
 
 	ResolveSym func(sym string) string
 	KeepFunc   func(textSym, resolved string) bool
 	ManualSig  func(resolved string) (FuncSig, bool)
+
+	// ARM64ClosureABIs supplies producer-proven hidden carriers after binding
+	// actual Go declarations. It neither invents Go args nor infers R26 input.
+	ARM64ClosureABIs map[string]ARM64ClosureABI
 }
 
 // GoFunction records the original TEXT symbol and its resolved LLVM symbol.
@@ -72,6 +102,128 @@ type GoModuleTranslation struct {
 // The package must provide go/types information for the declarations referenced
 // by the assembly. Methods and variadic functions are not supported.
 func TranslateGoModule(pkg GoPackage, src []byte, opt GoModuleOptions) (*GoModuleTranslation, error) {
+	return translateGoModuleInContext(llvm.GlobalContext(), pkg, src, opt)
+}
+
+// TranslateGoModuleInContext binds and translates the complete Go assembly
+// source in the supplied LLVM context. The caller retains context ownership,
+// including on error, and must dispose a successful module before its context.
+func TranslateGoModuleInContext(ctx llvm.Context, pkg GoPackage, src []byte, opt GoModuleOptions) (*GoModuleTranslation, error) {
+	return translateGoModuleInContext(ctx, pkg, src, opt)
+}
+
+// Internal high-volume callers can own the context without changing the public
+// binding contract. Dispose the returned module before disposing ctx.
+func translateGoModuleInContext(ctx llvm.Context, pkg GoPackage, src []byte, opt GoModuleOptions) (result *GoModuleTranslation, resultErr error) {
+	if opt.SourcePreprocessed && (opt.NumericalReads != nil || opt.X86TLSMoves != nil || opt.ARM64ByteCarrierSource != nil) {
+		return nil, fmt.Errorf("%w: preprocessed Go assembly cannot replace a captured source authority", ErrProbeNeedsContext)
+	}
+	if err := rejectMixedNativeAuthorities(opt.NumericalReads, opt.ARM64ByteCarrierSource); err != nil {
+		return nil, err
+	}
+	if source := opt.ARM64ByteCarrierSource; source != nil {
+		var callbackFailure error
+		if err := source.Verify(source.lease); err != nil {
+			return nil, err
+		}
+		original, err := arm64ByteCarrierGoView(source, pkg)
+		if err != nil {
+			source.revokeCarrier()
+			return nil, err
+		}
+		defer func() {
+			final := finishARM64ByteCarrierGoSource(source, pkg, original, result)
+			if resultErr != nil || callbackFailure != nil || final != nil {
+				source.revokeCarrier()
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				result, resultErr = nil, errors.Join(resultErr, callbackFailure, final)
+			}
+		}()
+		goos, _, _ := strings.Cut(source.request.Target, "/")
+		if opt.GOOS != goos || opt.ManualSig != nil || len(opt.ARM64ClosureABIs) != 0 {
+			return nil, arm64ByteCarrierContext("Go profile/custom declaration/closure mapping differs from the closed source")
+		}
+		// Go binding calls user resolvers before reaching the LLVM consumer.
+		// Retain the original capture owner through every such callback; a
+		// failed callback must not be followed by another invocation or output.
+		live := func() bool {
+			if callbackFailure == nil {
+				callbackFailure = source.liveCarrier()
+			}
+			return callbackFailure == nil
+		}
+		resolve := opt.ResolveSym
+		if resolve == nil {
+			resolve = goStripABISuffix
+		}
+		opt.ResolveSym = func(symbol string) string {
+			if !live() {
+				return ""
+			}
+			resolved := resolve(symbol)
+			if !live() {
+				return ""
+			}
+			return resolved
+		}
+		if keep := opt.KeepFunc; keep != nil {
+			opt.KeepFunc = func(symbol, resolved string) bool {
+				if !live() {
+					return false
+				}
+				retained := keep(symbol, resolved)
+				return live() && retained
+			}
+		}
+	}
+	originalSource := src
+	originalSourceDigest := sha256.Sum256(src)
+	if binding := opt.X86TLSMoves; binding != nil {
+		var err error
+		src, err = tlsGoAssemblyInput(binding, pkg, src, opt)
+		if err != nil {
+			return nil, err
+		}
+		defer func() {
+			if err := finishTLSGoInput(binding, pkg, originalSource, originalSourceDigest, opt); err != nil {
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				result, resultErr = nil, errors.Join(resultErr, err)
+			}
+		}()
+	}
+	if binding := opt.NumericalReads; binding != nil {
+		if err := verifyGoNumericalReadInputs(binding, pkg, opt); err != nil {
+			return nil, err
+		}
+		expanded, err := numericalGoAssemblyInput(binding, src)
+		if err != nil {
+			return nil, err
+		}
+		src = []byte(expanded)
+		defer func() {
+			err := verifyGoNumericalReadInputs(binding, pkg, opt)
+			if _, sourceErr := numericalGoAssemblyInput(binding, originalSource); sourceErr != nil {
+				err = errors.Join(err, sourceErr)
+			}
+			if sha256.Sum256(originalSource) != originalSourceDigest {
+				err = errors.Join(err, numericalSBContext("Go wrapper source bytes changed during consumption"))
+				binding.source.mu.Lock()
+				binding.source.ready = false
+				binding.source.mu.Unlock()
+			}
+			if err != nil {
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				result = nil
+				resultErr = errors.Join(resultErr, err)
+			}
+		}()
+	}
 	pkgPath := pkg.Path
 	if pkgPath == "" && pkg.Types != nil {
 		pkgPath = pkg.Types.Path()
@@ -99,19 +251,131 @@ func TranslateGoModule(pkg GoPackage, src []byte, opt GoModuleOptions) (*GoModul
 		resolve = func(sym string) string { return goStripABISuffix(sym) }
 	}
 
-	if bytes.Contains(src, []byte("const_")) {
-		src = goExpandConsts(src, pkg.Types, pkg.Imports)
-	}
-	// Struct layout macros only exist when the assembly includes go_asm.h.
-	// Keep the common path cheap: building them walks every package-scope type.
-	if bytes.Contains(src, []byte("go_asm.h")) {
-		src = goExpandAsmHeaderTypes(src, pkg.Types, opt.GOARCH)
+	var file *File
+	if opt.SourcePreprocessed {
+		file, err = parsePreprocessedAssembly(arch, string(src))
+	} else {
+		if opt.NumericalReads == nil && opt.X86TLSMoves == nil {
+			src = ExpandGoAssemblySource(pkg, src, opt.GOARCH)
+		}
+		file, err = ParseWithDefines(arch, string(src), GoAssemblerDefines(opt.GOOS, opt.GOARCH))
 	}
-
-	file, err := Parse(arch, string(src))
 	if err != nil {
 		return nil, fmt.Errorf("%s: parse %s: %w", pkgPath, asmName, err)
 	}
+	virtualPackage := pkg
+	virtualPackage.Path = pkgPath
+	virtualArguments, err := bindAMD64GoVirtualArguments(virtualPackage, file, originalSource, originalSourceDigest, opt, resolve)
+	if err != nil {
+		return nil, err
+	}
+	if virtualArguments != nil {
+		resolve = virtualArguments.resolveSymbol
+		defer func() {
+			final := virtualArguments.verify()
+			virtualArguments.close()
+			if final != nil {
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				result, resultErr = nil, errors.Join(resultErr, final)
+			}
+		}()
+	}
+	var readOnlyStorage *goReadOnlyStorage
+	if opt.NumericalReads == nil && opt.X86TLSMoves == nil && opt.ARM64ByteCarrierSource == nil {
+		storagePackage := pkg
+		storagePackage.Path = pkgPath
+		readOnlyStorage, err = bindGoReadOnlyStorage(storagePackage, file, opt.Sizes, opt.GOARCH, resolve)
+		if err != nil {
+			return nil, err
+		}
+		if readOnlyStorage != nil {
+			resolve = readOnlyStorage.resolveSymbol
+			defer func() {
+				final := readOnlyStorage.verify()
+				if sha256.Sum256(originalSource) != originalSourceDigest {
+					final = errors.Join(final, goReadOnlyContext("original Go assembly input changed during consumption"))
+				}
+				if final != nil {
+					if result != nil && !result.Module.IsNil() {
+						result.Module.Dispose()
+					}
+					result, resultErr = nil, errors.Join(resultErr, final)
+				}
+			}()
+		}
+	}
+	closureSource := *file
+	closureSource.Funcs = append([]Func(nil), file.Funcs...)
+	tailSigs, err := goBindARM64ABI0TailDeclarations(pkg, file, resolve, opt)
+	if err != nil {
+		return nil, err
+	}
+	file, err = PrepareGoARM64ABI0TailContinuations(file, tailSigs, resolve)
+	if err != nil {
+		return nil, fmt.Errorf("%s: private source contract %s: %w", pkgPath, asmName, err)
+	}
+	var virtualSignatures map[string]FuncSig
+	if virtualArguments != nil {
+		virtualSignatures, err = goSigsForAsmFile(pkg, file, resolve, opt.GOARCH, opt.Sizes, opt.FrameSizes, opt.ManualSig)
+		if err != nil {
+			return nil, err
+		}
+		if err := virtualArguments.attach(virtualSignatures); err != nil {
+			return nil, err
+		}
+	}
+	var tailPackage *GoPackage
+	// Numerical reads already bind the actual package and retain sealed Options.
+	// The separate imported-tail source must not change that consumer profile.
+	if opt.NumericalReads == nil {
+		tailPackage = &pkg
+	}
+	var registerBoolCalls *x86ABI0BoolCallSource
+	if (opt.GOARCH == "amd64" || opt.GOARCH == "386") &&
+		(x86DirectTailSourceNeeded(file) || len(goFixedLocalLeafSymbols(file, resolve, opt.ManualSig)) != 0) {
+		completeSigs, err := goSigsForAsmFile(pkg, file, resolve, opt.GOARCH, opt.Sizes, opt.FrameSizes, opt.ManualSig)
+		if err != nil {
+			return nil, err
+		}
+		if err := virtualArguments.attach(completeSigs); err != nil {
+			return nil, err
+		}
+		if binding := opt.NumericalReads; binding != nil {
+			// The complete graph consumes the same independently bound private
+			// identities as lowering, not just fresh language signature shapes.
+			completeSigs, err = numericalGoSignatures(binding, completeSigs)
+			if err != nil {
+				return nil, err
+			}
+		}
+		request := Options{Goarch: opt.GOARCH, TargetTriple: opt.TargetTriple,
+			ResolveSym: resolve, Sigs: completeSigs, NumericalReads: opt.NumericalReads, X86TLSMoves: opt.X86TLSMoves,
+			WASMABI: opt.WASMABI, X87Mode: opt.X87Mode, AnnotateSource: opt.AnnotateSource, goReadOnlyStorage: readOnlyStorage, goPackage: tailPackage}
+		calls, err := prepareX86ABI0BoolCalls(file, request)
+		if err != nil {
+			return nil, err
+		}
+		if calls != nil && calls.customGraph != nil {
+			registerBoolCalls = calls // One original graph and one shared flow budget.
+			request.x86BoolCallSource = calls
+		}
+		file, err = PrepareX86DirectTailSource(file, request)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if err := virtualArguments.audit(file, virtualSignatures, opt, resolve, readOnlyStorage); err != nil {
+		return nil, err
+	}
+	completeFile := file
+	potentialBoolCalls := x86ABI0BoolCallsNeeded(completeFile, opt.GOARCH)
+	boolCallSource := false
+	if file.x86DirectTails != nil || potentialBoolCalls || virtualArguments != nil {
+		filtered := *file
+		file = &filtered // KeepFunc cannot crop the complete graph origin/signatures.
+	}
 	if opt.KeepFunc != nil {
 		keep := make([]Func, 0, len(file.Funcs))
 		for _, fn := range file.Funcs {
@@ -123,31 +387,201 @@ func TranslateGoModule(pkg GoPackage, src []byte, opt GoModuleOptions) (*GoModul
 		file.Funcs = keep
 	}
 
-	sigs, err := goSigsForAsmFile(pkg, file, resolve, opt.GOARCH, opt.Sizes, opt.FrameSizes, opt.ManualSig)
+	signatureFile := file
+	if file.x86DirectTails != nil || registerBoolCalls != nil || virtualArguments != nil {
+		signatureFile = completeFile // Recheck every root after caller callbacks.
+	}
+	sigs, err := goSigsForAsmFile(pkg, signatureFile, resolve, opt.GOARCH, opt.Sizes, opt.FrameSizes, opt.ManualSig)
 	if err != nil {
 		return nil, fmt.Errorf("%s: sigs %s: %w", pkgPath, asmName, err)
 	}
-	mod, err := TranslateModule(file, Options{
-		TargetTriple:   opt.TargetTriple,
-		ResolveSym:     resolve,
-		Sigs:           sigs,
-		Goarch:         opt.GOARCH,
-		WASMABI:        opt.WASMABI,
-		X87Mode:        opt.X87Mode,
-		AnnotateSource: opt.AnnotateSource,
+	if potentialBoolCalls {
+		for _, fn := range file.Funcs {
+			if !x86ABI0BoolFunctionControlNeeded(fn) {
+				continue
+			}
+			if sig, declared := sigs[resolve(goTextSymbolForResolution(fn.Sym))]; declared && sig.Ret == I1 {
+				// Actual selected I1 CALLs/terminals require complete original types;
+				// unrelated nonbool/unused TEXTs need no new declaration query.
+				// With no dropped function, this first signature inventory is
+				// already complete. No temporary callee proof is built here.
+				if len(file.Funcs) != len(completeFile.Funcs) && signatureFile != completeFile {
+					sigs, err = goSigsForAsmFile(pkg, completeFile, resolve, opt.GOARCH, opt.Sizes, opt.FrameSizes, opt.ManualSig)
+					if err != nil {
+						return nil, err
+					}
+				}
+				boolCallSource = true
+				break
+			}
+		}
+	}
+	if binding := opt.NumericalReads; binding != nil {
+		sigs, err = numericalGoSignatures(binding, sigs)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if err := virtualArguments.attach(sigs); err != nil {
+		return nil, err
+	}
+	if graph := file.x86DirectTails; graph != nil {
+		request, signatures := file, sigs
+		defer func() {
+			final := graph.verify(request, Options{Goarch: opt.GOARCH, TargetTriple: opt.TargetTriple, ResolveSym: resolve, Sigs: signatures,
+				NumericalReads: opt.NumericalReads, WASMABI: opt.WASMABI, X87Mode: opt.X87Mode, AnnotateSource: opt.AnnotateSource, goReadOnlyStorage: readOnlyStorage, goPackage: tailPackage})
+			if sha256.Sum256(originalSource) != originalSourceDigest {
+				final = errors.Join(final, x86DirectTailContext("original Go assembly input changed during consumption"))
+			}
+			if final != nil {
+				if result != nil && !result.Module.IsNil() {
+					result.Module.Dispose()
+				}
+				result = nil
+				resultErr = errors.Join(resultErr, final)
+			}
+		}()
+	}
+	for name, sourceSig := range tailSigs {
+		if sourceSig.arm64ABI0TailDeclaration != nil {
+			sig, present := sigs[name]
+			if !present {
+				continue // Whole-file audit ran before dropping this unused root.
+			}
+			if !reflect.DeepEqual(arm64ABI0SignatureSnapshot(sig), arm64ABI0SignatureSnapshot(sourceSig)) {
+				return nil, arm64GoABIContext("ABI0 tail changed its declaration during signature inference")
+			}
+			sigs[name] = sourceSig
+		}
+	}
+	if err := bindGoARM64ClosureABIs(pkg, &closureSource, sigs, opt, resolve); err != nil {
+		return nil, err
+	}
+	var boolCalls *x86ABI0BoolCallSource
+	var callOriginal *File
+	if boolCallSource || registerBoolCalls != nil {
+		callOriginal = completeFile
+		boolCalls = registerBoolCalls
+		if boolCalls == nil {
+			boolCalls, err = prepareX86ABI0BoolCalls(completeFile, Options{Goarch: opt.GOARCH, TargetTriple: opt.TargetTriple, ResolveSym: resolve, Sigs: sigs, goReadOnlyStorage: readOnlyStorage, goPackage: tailPackage})
+			if err != nil {
+				return nil, err
+			}
+		}
+		if boolCalls != nil {
+			defer func() {
+				final := boolCalls.verify()
+				if sha256.Sum256(originalSource) != originalSourceDigest {
+					final = errors.Join(final, x86ABI0BoolCallContext("original Go input changed during complete call consumption"))
+				}
+				if final != nil {
+					if result != nil && !result.Module.IsNil() {
+						result.Module.Dispose()
+					}
+					result = nil
+					resultErr = errors.Join(resultErr, final)
+				}
+			}()
+		}
+	}
+	mod, err := TranslateModuleInContext(ctx, file, Options{
+		goReadOnlyStorage:      readOnlyStorage,
+		goPackage:              tailPackage,
+		x86OriginalFile:        callOriginal,
+		x86BoolCallSource:      boolCalls,
+		TargetTriple:           opt.TargetTriple,
+		ResolveSym:             resolve,
+		Sigs:                   sigs,
+		Goarch:                 opt.GOARCH,
+		WASMABI:                opt.WASMABI,
+		X87Mode:                opt.X87Mode,
+		AnnotateSource:         opt.AnnotateSource,
+		NumericalReads:         opt.NumericalReads,
+		X86TLSMoves:            opt.X86TLSMoves,
+		ARM64ByteCarrierSource: opt.ARM64ByteCarrierSource,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("%s: translate %s: %w", pkgPath, asmName, err)
 	}
 
 	funcs := make([]GoFunction, 0, len(file.Funcs))
+	metadataResolve := resolve
+	if opt.NumericalReads != nil {
+		metadataResolve = opt.NumericalReads.resolve
+	}
 	for _, fn := range file.Funcs {
-		funcs = append(funcs, GoFunction{TextSymbol: fn.Sym, ResolvedSymbol: resolve(goTextSymbolForResolution(fn.Sym))})
+		if file.x86DirectTailHelper(fn.Sym) {
+			continue // The private node is not a Go/LLVM entry or callable ABI.
+		}
+		funcs = append(funcs, GoFunction{TextSymbol: fn.Sym, ResolvedSymbol: metadataResolve(goTextSymbolForResolution(fn.Sym))})
 	}
 
 	return &GoModuleTranslation{Module: mod, Signatures: sigs, Functions: funcs}, nil
 }
 
+func bindGoARM64ClosureABIs(pkg GoPackage, original *File, sigs map[string]FuncSig, opt GoModuleOptions, resolve func(string) string) error {
+	if len(opt.ARM64ClosureABIs) == 0 {
+		return nil
+	}
+	linknames := goLinknameRemoteToLocal(pkg.Syntax)
+	pkgPath := pkg.Path
+	if pkgPath == "" {
+		pkgPath = pkg.Types.Path()
+	}
+	for name, abi := range opt.ARM64ClosureABIs {
+		sig, ok := sigs[name]
+		if !ok {
+			return arm64GoABIContext("closure carrier %q has no declaration-bound assembly signature", name)
+		}
+		var declaration *types.Func
+		for _, fn := range original.Funcs {
+			if resolve(goTextSymbolForResolution(fn.Sym)) != name {
+				continue
+			}
+			if !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+				return arm64GoABIContext("closure entry %q needs its actual source ABIInternal identity", name)
+			}
+			declName := strings.TrimPrefix(name, pkgPath+".")
+			if declName == name {
+				var err error
+				declName, err = goDeclNameForSymbol(goStripABISuffix(fn.Sym), linknames)
+				if err != nil {
+					return arm64GoABIContext("closure entry %q has no source Go declaration: %v", name, err)
+				}
+			}
+			declaration, _ = pkg.Types.Scope().Lookup(declName).(*types.Func)
+		}
+		if _, err := DeriveARM64GoRegisterABI(declaration, sig); err != nil {
+			return err
+		}
+		carrier := abi
+		sig.ARM64ClosureABI = &carrier
+		sigs[name] = sig
+	}
+	// KeepFunc may omit a sibling, but it may not hide the original entry's
+	// address or an ordinary direct call which never supplied a carrier.
+	return validateARM64ClosureFile(original, Options{
+		Goarch: opt.GOARCH, TargetTriple: opt.TargetTriple, Sigs: sigs,
+	}, resolve)
+}
+
+// ExpandGoAssemblySource resolves the constants and type-layout identifiers
+// that cmd/compile writes to a package's generated go_asm.h. Callers that parse
+// package assembly themselves must run this before Parse; leaving a $const_X
+// token unresolved can otherwise be mistaken for a successfully translated
+// zero value or rejected only after unrelated lowering has begun.
+func ExpandGoAssemblySource(pkg GoPackage, src []byte, goarch string) []byte {
+	if bytes.Contains(src, []byte("const_")) {
+		src = goExpandConsts(src, pkg.Types, pkg.Imports)
+	}
+	// Struct layout macros only exist when the assembly includes go_asm.h.
+	// Keep the common path cheap: building them walks every package-scope type.
+	if bytes.Contains(src, []byte("go_asm.h")) {
+		src = goExpandAsmHeaderTypes(src, pkg.Types, goarch)
+	}
+	return src
+}
+
 var goABISuffixRe = regexp.MustCompile(`<ABI[^>]*>$`)
 var goConstRefRe = regexp.MustCompile(`\bconst_[A-Za-z0-9_]+\b`)
 var goConstPlusRefRe = regexp.MustCompile(`([\pL\pN_∕·./]+)\+const_([A-Za-z0-9_]+)`)
@@ -188,16 +622,22 @@ func goSigsForAsmFile(pkg GoPackage, file *File, resolve func(sym string) string
 		frameSz = sz
 	}
 	b := goSigBuilder{
-		sigs:      make(map[string]FuncSig, len(file.Funcs)),
-		localSigs: make(map[string]bool),
-		scope:     pkg.Types.Scope(),
-		sz:        sz,
-		frameSz:   frameSz,
-		linknames: goLinknameRemoteToLocal(pkg.Syntax),
-		pkgPath:   pkg.Path,
-		resolve:   resolve,
-		goarch:    goarch,
-		manualSig: manualSig,
+		sigs:        make(map[string]FuncSig, len(file.Funcs)),
+		localSigs:   make(map[string]bool),
+		scope:       pkg.Types.Scope(),
+		sz:          sz,
+		frameSz:     frameSz,
+		linknames:   goLinknameRemoteToLocal(pkg.Syntax),
+		pkgPath:     pkg.Path,
+		resolve:     resolve,
+		goarch:      goarch,
+		manualSig:   manualSig,
+		packageData: pkg,
+		directTail:  (goarch == "amd64" || goarch == "386") && x86DirectTailSourceNeeded(file),
+	}
+	if goarch == "amd64" {
+		b.fixedLocalLeaves = goFixedLocalLeafSymbols(file, resolve, manualSig)
+		b.directTail = b.directTail || len(b.fixedLocalLeaves) != 0
 	}
 	if b.pkgPath == "" {
 		b.pkgPath = pkg.Types.Path()
@@ -205,6 +645,7 @@ func goSigsForAsmFile(pkg GoPackage, file *File, resolve func(sym string) string
 	if err := b.addDeclaredFuncSigs(file); err != nil {
 		return nil, err
 	}
+	b.addCustomBoolHelperTransports(file)
 	if err := b.addReferencedFuncSigs(file); err != nil {
 		return nil, err
 	}
@@ -237,12 +678,51 @@ func goSigsForAsmFile(pkg GoPackage, file *File, resolve func(sym string) string
 	// or ManualSig; raw register entry points require the native backend.
 	for resolved := range b.localSigs {
 		if _, ok := b.sigs[resolved]; !ok {
+			if b.directTail {
+				continue // The whole-source graph must close this non-callable node.
+			}
+			if goarch == "arm64" {
+				return nil, arm64GoABIContext("missing signature for file-local assembly %q; supply an explicit entry or closed source continuation contract", resolved)
+			}
 			return nil, fmt.Errorf("missing signature for file-local assembly %q; supply ManualSig or use the native backend", resolved)
 		}
 	}
+	if pkg.SourceSelection != nil && GoX86RawReturnCallerBindingNeeded(file, goarch, resolve, b.sigs) {
+		if !x86CallerTargetSizesValid(sz) {
+			return nil, fmt.Errorf("%w: bounded raw-return callers need the actual AMD64 numerical/pointer data layout", ErrProbeNeedsContext)
+		}
+		return BindGoX86RawReturnCallerRegions(pkg, file, goarch, resolve, b.sigs)
+	}
 	return b.sigs, nil
 }
 
+// Observe explicit custom transports only for an actual ordinary I1 root.
+// This does not make a private node callable or give it the caller's frame:
+// the complete register-tail graph must independently prove its result writes.
+func (b *goSigBuilder) addCustomBoolHelperTransports(file *File) {
+	if b.goarch != "386" || !b.directTail || b.manualSig == nil {
+		return
+	}
+	needed := false
+	for _, fn := range file.Funcs {
+		if !strings.HasSuffix(fn.Sym, "<>") && x86DirectTailRootNeeded(fn) {
+			sig, declared := b.sigs[b.resolve(goTextSymbolForResolution(fn.Sym))]
+			needed = needed || declared && x86ABI0BoolDeclarationRole(sig, b.goarch)
+		}
+	}
+	if !needed {
+		return
+	}
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			name := b.resolve(goTextSymbolForResolution(fn.Sym))
+			if sig, supplied := goLookupManualSig(b.manualSig, name); supplied {
+				b.sigs[name] = sig
+			}
+		}
+	}
+}
+
 func wasmUsesNativeReturn(fn Func) bool {
 	for _, ins := range fn.Instrs {
 		if normalizeInstructionOpcode(ins.Op) == "WASMRETURN" {
@@ -252,17 +732,27 @@ func wasmUsesNativeReturn(fn Func) bool {
 	return false
 }
 
+// WASMAssemblyUsesNativeReturn reports whether fn contains Go's WebAssembly
+// Return pseudo-instruction. Unlike RET, Return exchanges a result through the
+// native wasm operand stack and therefore requires a native wasm signature.
+func WASMAssemblyUsesNativeReturn(fn Func) bool {
+	return wasmUsesNativeReturn(fn)
+}
+
 type goSigBuilder struct {
-	sigs      map[string]FuncSig
-	localSigs map[string]bool
-	scope     *types.Scope
-	sz        types.Sizes
-	frameSz   types.Sizes
-	linknames map[string]string
-	pkgPath   string
-	resolve   func(sym string) string
-	goarch    string
-	manualSig func(string) (FuncSig, bool)
+	sigs             map[string]FuncSig
+	localSigs        map[string]bool
+	scope            *types.Scope
+	sz               types.Sizes
+	frameSz          types.Sizes
+	linknames        map[string]string
+	pkgPath          string
+	resolve          func(sym string) string
+	goarch           string
+	manualSig        func(string) (FuncSig, bool)
+	directTail       bool            // source-cost detection only; the graph must prove every node
+	fixedLocalLeaves map[string]bool // Observed non-callable source roles, not helper signatures.
+	packageData      GoPackage
 }
 
 func (b *goSigBuilder) addDeclaredFuncSigs(file *File) error {
@@ -270,20 +760,33 @@ func (b *goSigBuilder) addDeclaredFuncSigs(file *File) error {
 		textSym := file.Funcs[i].Sym
 		sym := goStripABISuffix(textSym)
 		resolved := b.resolve(goTextSymbolForResolution(textSym))
+		if b.directTail && (strings.HasSuffix(textSym, "<>") || b.fixedLocalLeaves[textSym]) {
+			if !b.fixedLocalLeaves[textSym] {
+				if sig, found := goLookupManualSig(b.manualSig, resolved); found &&
+					x86BoundedVoidABI0Declaration(file.Funcs[i], sig, b.goarch) {
+					b.sigs[resolved] = sig
+					continue // Keep this real bounded ABI; never invent one for a graph node.
+				}
+			}
+			b.localSigs[resolved] = true
+			continue // No ManualSig/zero-arg/caller signature becomes a helper ABI.
+		}
 		if ms, ok := goLookupManualSig(b.manualSig, resolved); ok {
+			if amd64RegisterTupleResultNeedsProof(file.Funcs[i], ms, b.goarch) {
+				name, err := b.declaredAsmFuncName(sym, resolved)
+				if err == nil {
+					if fn, known := b.scope.Lookup(name).(*types.Func); known && !goAMD64NumericalRegisterResults(fn) {
+						return fmt.Errorf("%w: %s Go result assignment is outside the modeled numerical register tuple", ErrProbeNeedsContext, resolved)
+					}
+				}
+			}
 			b.sigs[resolved] = ms
 			continue
 		}
 
-		declName := ""
-		if strings.HasPrefix(resolved, b.pkgPath+".") {
-			declName = strings.TrimPrefix(resolved, b.pkgPath+".")
-		} else {
-			var err error
-			declName, err = goDeclNameForSymbol(sym, b.linknames)
-			if err != nil {
-				return err
-			}
+		declName, err := b.declaredAsmFuncName(sym, resolved)
+		if err != nil {
+			return err
 		}
 		obj := b.scope.Lookup(declName)
 		if obj == nil {
@@ -292,6 +795,11 @@ func (b *goSigBuilder) addDeclaredFuncSigs(file *File) error {
 					b.localSigs = make(map[string]bool)
 				}
 				b.localSigs[resolved] = true
+				if b.goarch == "arm" {
+					if native, ok := ARMKernelHelperFuncSig(file.Funcs[i], resolved); ok {
+						b.sigs[resolved] = native
+					}
+				}
 				continue
 			}
 			return fmt.Errorf("missing Go declaration for asm symbol %q", sym)
@@ -304,11 +812,27 @@ func (b *goSigBuilder) addDeclaredFuncSigs(file *File) error {
 		if err != nil {
 			return err
 		}
+		if amd64RegisterTupleResultNeedsProof(file.Funcs[i], fs, b.goarch) && !goAMD64NumericalRegisterResults(fn) {
+			return fmt.Errorf("%w: %s Go result assignment is outside the modeled numerical register tuple", ErrProbeNeedsContext, resolved)
+		}
+		if b.goarch == "arm64" && strings.HasSuffix(textSym, "<ABIInternal>") {
+			fs.ARM64GoRegisterABI, err = DeriveARM64GoRegisterABI(fn, fs)
+			if err != nil {
+				return err
+			}
+		}
 		b.sigs[resolved] = fs
 	}
 	return nil
 }
 
+func (b *goSigBuilder) declaredAsmFuncName(sym, resolved string) (string, error) {
+	if strings.HasPrefix(resolved, b.pkgPath+".") {
+		return strings.TrimPrefix(resolved, b.pkgPath+"."), nil
+	}
+	return goDeclNameForSymbol(sym, b.linknames)
+}
+
 func wasmGoNativeFuncSig(name string) (FuncSig, bool) {
 	local := strings.HasSuffix(name, "$local")
 	base := strings.TrimSuffix(name, "$local")
@@ -358,15 +882,46 @@ func wasmGoNativeFuncSig(name string) (FuncSig, bool) {
 	return FuncSig{}, false
 }
 
+// LookupGoWASMNativeFuncSig returns the native WebAssembly ABI used by Go
+// assembly entry points whose signatures are not described by Go declarations.
+// These functions are part of the Go runtime/standard-library assembly
+// contract and intentionally exchange values through wasm registers or the
+// operand stack instead of the ordinary Go stack ABI.
+func LookupGoWASMNativeFuncSig(name string) (FuncSig, bool) {
+	return wasmGoNativeFuncSig(name)
+}
+
 func (b *goSigBuilder) addReferencedFuncSigs(file *File) error {
 	for _, fn := range file.Funcs {
 		callerResolved := b.resolve(goTextSymbolForResolution(fn.Sym))
 		callerSig, hasCallerSig := b.sigs[callerResolved]
+		tailTarget, pureTail := x86OrdinaryExternalTailTarget(fn)
 		for _, ins := range fn.Instrs {
 			base, tailJump, ok := goReferencedFunc(ins)
 			if !ok {
 				continue
 			}
+			if b.directTail && (strings.HasSuffix(base, "<>") || b.fixedLocalLeaves[base]) {
+				continue // Bound only by complete source nodes and root must-state.
+			}
+			if b.directTail && pureTail && tailJump && tailTarget == base && hasCallerSig &&
+				!x86DirectTailSigNeedsOwnBoolFrame(callerSig, fn, b.goarch) &&
+				goReadOnlyLocalName(b.packageData, b.resolve(base)) == "" {
+				path, _ := goReadOnlyImportedName(b.resolve(base))
+				// Missing imports are deferred to the complete consumer. Source-only
+				// declaration collection must preserve independent bool/alias checks.
+				if b.packageData.Imports[path] != nil {
+					fs, err := goX86ImportedTailSignature(b.packageData, b.resolve(base), b.goarch, b.sz, b.frameSz)
+					if err != nil {
+						return err
+					}
+					if manual, ok := goLookupManualSig(b.manualSig, b.resolve(base)); ok && !reflect.DeepEqual(manual, fs) {
+						return x86DirectTailContext("manual signature differs from actual imported Go declaration")
+					}
+					b.sigs[b.resolve(base)] = fs
+					continue
+				}
+			}
 			if err := b.addGoDeclSig(base); err != nil {
 				return err
 			}
@@ -380,12 +935,22 @@ func (b *goSigBuilder) addReferencedFuncSigs(file *File) error {
 					continue
 				}
 			}
+			if b.directTail && tailJump && !pureTail {
+				return x86DirectTailContext("ordinary external terminal lacks an actual declaration or explicit signature: %s", base)
+			}
 			if tailJump && hasCallerSig {
+				if b.goarch == "arm64" && arm64PrivateTailSymbol(base+"(SB)") {
+					return arm64GoABIContext("private tail %q has no declaration or explicit register transport; caller Frame cannot supply it", base)
+				}
 				// Best-effort fallback for helper<> tail-jumps where the callee is an
 				// internal asm label with no Go declaration. Callers can override this
 				// via ManualSig when the inferred signature is not identical.
 				fs := callerSig
 				fs.Name = targetResolved
+				fs.x86BorrowedBoolTail = (b.goarch == "386" || b.goarch == "amd64") && fs.Ret == I1
+				// A borrowed scalar signature is not a declaration-backed Go
+				// register-entry proof for the unresolved helper.
+				fs.ARM64GoRegisterABI = nil
 				b.sigs[targetResolved] = fs
 				continue
 			}
@@ -403,12 +968,13 @@ func (b *goSigBuilder) addReferencedFuncSigs(file *File) error {
 }
 
 func (b *goSigBuilder) addGoDeclSig(sym string) error {
+	internal := b.goarch == "arm64" && strings.HasSuffix(sym, "<ABIInternal>")
 	sym = goStripABISuffix(sym)
 	resolved := b.resolve(sym)
 	if resolved == "" {
 		return nil
 	}
-	if _, ok := b.sigs[resolved]; ok {
+	if _, ok := b.sigs[resolved]; ok && !internal {
 		return nil
 	}
 	if ms, ok := goLookupManualSig(b.manualSig, resolved); ok {
@@ -438,17 +1004,28 @@ func (b *goSigBuilder) addGoDeclSig(sym string) error {
 	if !ok {
 		return nil
 	}
-	fs, err := goFuncSigForDeclaredFunc(resolved, fn, b.goarch, b.sz, b.frameSz, false)
+	// A Go declaration does not make a plain CALL/BL register-ABI. On x86
+	// and ARM64 assembly calls its ABI0 wrapper unless the instruction says
+	// ABIInternal. Keep result-only frame metadata too. ARM's outgoing-stack
+	// bridge is separate; do not claim it merely by adding signature slots.
+	withFrame := b.goarch == "amd64" || b.goarch == "386" || b.goarch == "arm64"
+	fs, err := goFuncSigForDeclaredFunc(resolved, fn, b.goarch, b.sz, b.frameSz, withFrame)
 	if err != nil {
 		return err
 	}
+	if internal {
+		fs.ARM64GoRegisterABI, err = DeriveARM64GoRegisterABI(fn, fs)
+		if err != nil {
+			return err
+		}
+	}
 	b.sigs[resolved] = fs
 	return nil
 }
 
 func goReferencedFunc(ins Instr) (base string, tailJump bool, ok bool) {
 	switch string(ins.Op) {
-	case "JMP", "B":
+	case "JMP", "B", "RET":
 		tailJump = true
 	case "CALL", "CALLNORESUME", "WASMCALL", "BL":
 	default:
@@ -512,6 +1089,20 @@ func goDeclNameForSymbol(sym string, linknames map[string]string) (string, error
 	return declName, nil
 }
 
+// DeriveGoFuncABI0Signature derives the complete ordinary signature and classic
+// FP layout from an actual typed Go declaration. It supplies no native entry,
+// hidden register, caller-memory or closure contract. Source authentication and
+// source ABI selection remain the caller's separate obligations.
+func DeriveGoFuncABI0Signature(name string, fn *types.Func, goarch string, sz types.Sizes) (FuncSig, error) {
+	if name == "" || fn == nil {
+		return FuncSig{}, fmt.Errorf("missing actual Go declaration for ABI0 layout")
+	}
+	if signature, ok := fn.Type().(*types.Signature); !ok || signature == nil {
+		return FuncSig{}, fmt.Errorf("missing actual typed Go signature for ABI0 layout")
+	}
+	return goFuncSigForDeclaredFunc(name, fn, goarch, sz, sz, true)
+}
+
 func goFuncSigForDeclaredFunc(name string, fn *types.Func, goarch string, sz, frameSz types.Sizes, withFrame bool) (FuncSig, error) {
 	if sz == nil {
 		sz = types.SizesFor("gc", goarch)
@@ -539,7 +1130,12 @@ func goFuncSigForDeclaredFunc(name string, fn *types.Func, goarch string, sz, fr
 		if err != nil {
 			return FuncSig{}, fmt.Errorf("%s: %w", fn.FullName(), err)
 		}
-		return FuncSig{Name: name, Args: args, Ret: goTupleRetType(retTys), Frame: FrameLayout{Params: frameParams, Results: frameResults}}, nil
+		result := FuncSig{Name: name, Args: args, Ret: goTupleRetType(retTys), Frame: FrameLayout{Params: frameParams, Results: frameResults}}
+		if goarch == "arm64" {
+			result.arm64FPReadDeclaration = arm64FPReadDeclarationForGo(result, sig, sz, frameSz)
+			result.arm64ABI0Declaration = arm64ABI0DeclarationForGo(result, fn, sz, frameSz)
+		}
+		return result, nil
 	}
 	args, _, _, err := goLLVMArgsAndFrameSlotsForTuple(sig.Params(), goarch, sz, frameSz, 0, false)
 	if err != nil {
@@ -632,44 +1228,47 @@ func goExpandConsts(src []byte, pkgTypes *types.Package, imports map[string]*typ
 		return "", false
 	}
 
-	src = goConstPlusRefRe.ReplaceAllFunc(src, func(m []byte) []byte {
-		sub := goConstPlusRefRe.FindSubmatch(m)
-		if len(sub) != 3 {
-			return m
-		}
-		prefix := string(sub[1])
-		name := string(sub[2])
-		if i := strings.LastIndex(prefix, "/"); i >= 0 {
-			path := prefix[:i]
-			sym := prefix[i+1:]
-			if tp := typeByPath[path]; tp != nil {
-				if val, ok := lookupConst(tp, name); ok {
-					return []byte(path + "/" + sym + "+" + val)
+	expand := func(fragment []byte) []byte {
+		fragment = goConstPlusRefRe.ReplaceAllFunc(fragment, func(m []byte) []byte {
+			sub := goConstPlusRefRe.FindSubmatch(m)
+			if len(sub) != 3 {
+				return m
+			}
+			prefix := string(sub[1])
+			name := string(sub[2])
+			if i := strings.LastIndex(prefix, "/"); i >= 0 {
+				path := prefix[:i]
+				sym := prefix[i+1:]
+				if tp := typeByPath[path]; tp != nil {
+					if val, ok := lookupConst(tp, name); ok {
+						return []byte(path + "/" + sym + "+" + val)
+					}
 				}
 			}
-		}
-		if j := strings.LastIndex(prefix, "."); j >= 0 {
-			path := prefix[:j]
-			sym := prefix[j+1:]
-			if tp := typeByPath[path]; tp != nil {
-				if val, ok := lookupConst(tp, name); ok {
-					return []byte(path + "." + sym + "+" + val)
+			if j := strings.LastIndex(prefix, "."); j >= 0 {
+				path := prefix[:j]
+				sym := prefix[j+1:]
+				if tp := typeByPath[path]; tp != nil {
+					if val, ok := lookupConst(tp, name); ok {
+						return []byte(path + "." + sym + "+" + val)
+					}
 				}
 			}
-		}
-		if val, ok := lookupConst(pkgTypes, name); ok {
-			return []byte(prefix + "+" + val)
-		}
-		return m
-	})
+			if val, ok := lookupConst(pkgTypes, name); ok {
+				return []byte(prefix + "+" + val)
+			}
+			return m
+		})
 
-	return goConstRefRe.ReplaceAllFunc(src, func(m []byte) []byte {
-		name := strings.TrimPrefix(string(m), "const_")
-		if val, ok := lookupConst(pkgTypes, name); ok {
-			return []byte(val)
-		}
-		return m
-	})
+		return goConstRefRe.ReplaceAllFunc(fragment, func(m []byte) []byte {
+			name := strings.TrimPrefix(string(m), "const_")
+			if val, ok := lookupConst(pkgTypes, name); ok {
+				return []byte(val)
+			}
+			return m
+		})
+	}
+	return goExpandAssemblyMacroUses(src, expand)
 }
 
 // goExpandAsmHeaderTypes expands the struct size and field offset macros that
@@ -685,6 +1284,13 @@ func goExpandAsmHeaderTypes(src []byte, pkgTypes *types.Package, goarch string)
 	if sizes == nil {
 		return src
 	}
+	referenced := make(map[string]bool)
+	goExpandAssemblyMacroUses(src, func(fragment []byte) []byte {
+		for _, ident := range goAsmHeaderIdentRe.FindAll(fragment, -1) {
+			referenced[string(ident)] = true
+		}
+		return fragment
+	})
 	macros := make(map[string]string)
 	for _, name := range pkgTypes.Scope().Names() {
 		obj, ok := pkgTypes.Scope().Lookup(name).(*types.TypeName)
@@ -695,34 +1301,139 @@ func goExpandAsmHeaderTypes(src []byte, pkgTypes *types.Package, goarch string)
 		if !ok {
 			continue
 		}
-		size := sizes.Sizeof(obj.Type())
-		if size < 0 {
+		needSize := referenced[name+"__size"]
+		needOffsets := false
+		for i := 0; i < st.NumFields(); i++ {
+			field := st.Field(i)
+			if field.Name() != "_" && referenced[name+"_"+field.Name()] {
+				needOffsets = true
+				break
+			}
+		}
+		if !needSize && !needOffsets {
+			continue
+		}
+		if goTypeHasUnboundTypeParams(obj.Type()) {
+			continue
+		}
+		if needSize {
+			size := sizes.Sizeof(obj.Type())
+			if size >= 0 {
+				macros[name+"__size"] = strconv.FormatInt(size, 10)
+			}
+		}
+		if !needOffsets {
 			continue
 		}
-		macros[name+"__size"] = strconv.FormatInt(size, 10)
 		fields := make([]*types.Var, st.NumFields())
 		for i := range fields {
 			fields[i] = st.Field(i)
 		}
 		for i, offset := range sizes.Offsetsof(fields) {
 			field := fields[i]
-			if field.Name() == "_" || offset < 0 {
+			macro := name + "_" + field.Name()
+			if field.Name() == "_" || !referenced[macro] || offset < 0 {
 				continue
 			}
-			macros[name+"_"+field.Name()] = strconv.FormatInt(offset, 10)
+			macros[macro] = strconv.FormatInt(offset, 10)
 		}
 	}
 	if len(macros) == 0 {
 		return src
 	}
-	return goAsmHeaderIdentRe.ReplaceAllFunc(src, func(ident []byte) []byte {
-		if value, ok := macros[string(ident)]; ok {
-			return []byte(value)
-		}
-		return ident
+	return goExpandAssemblyMacroUses(src, func(fragment []byte) []byte {
+		return goAsmHeaderIdentRe.ReplaceAllFunc(fragment, func(ident []byte) []byte {
+			if value, ok := macros[string(ident)]; ok {
+				return []byte(value)
+			}
+			return ident
+		})
 	})
 }
 
+func goTypeHasUnboundTypeParams(typ types.Type) bool {
+	generic, ok := typ.(interface {
+		TypeParams() *types.TypeParamList
+		TypeArgs() *types.TypeList
+	})
+	return ok && generic.TypeParams().Len() != 0 && generic.TypeArgs().Len() == 0
+}
+
+// Keep CPP control operands and macro parameters as identifiers. Only free
+// replacement-list references and ordinary assembly use generated values.
+// The preprocessor still owns directive validity and conditional evaluation.
+func goExpandAssemblyMacroUses(src []byte, expand func([]byte) []byte) []byte {
+	lastControl := bytes.LastIndexByte(src, '#')
+	if lastControl < 0 {
+		return expand(src)
+	}
+	reader := newPPGoReader("<generated-header-expansion>", string(src))
+	var tokens []AssemblyCPPToken
+	readLine := func() error {
+		for {
+			physical, err := reader.next()
+			if err != nil {
+				return err
+			}
+			tokens = append(tokens, assemblyCPPPhysicalToken(reader, physical))
+			if physical.kind == '\n' || physical.kind == scanner.EOF {
+				return nil
+			}
+		}
+	}
+	var out bytes.Buffer
+	start := 0
+	finish := func() []byte {
+		out.Write(expand(src[start:]))
+		return out.Bytes()
+	}
+	for {
+		tokens = tokens[:0]
+		if err := readLine(); err != nil {
+			return finish()
+		}
+		directive := len(tokens) > 1 && tokens[0].Text == "#"
+		definition := directive && tokens[1].Kind == "identifier" && tokens[1].Text == "define"
+		for definition && assemblyCPPContinuedLine(tokens) {
+			if err := readLine(); err != nil {
+				return finish()
+			}
+		}
+		last := tokens[len(tokens)-1]
+		if directive {
+			out.Write(expand(src[start:tokens[0].Start]))
+			protected := last.End
+			var macro *AssemblyCPPMacroDefinition
+			if definition {
+				macro, _ = assemblyCPPPhysicalDefinition(tokens)
+				if macro != nil && len(macro.Replacement) != 0 {
+					protected = macro.Replacement[0].Start
+				}
+			}
+			out.Write(src[tokens[0].Start:protected])
+			start = protected
+			if macro != nil && len(macro.Parameters) != 0 {
+				parameters := make(map[string]bool, len(macro.Parameters))
+				for _, name := range macro.Parameters {
+					parameters[name] = true
+				}
+				for _, token := range macro.Replacement {
+					if token.Kind == "identifier" && parameters[token.Text] {
+						out.Write(expand(src[start:token.Start]))
+						out.Write(src[token.Start:token.End])
+						start = token.End
+					}
+				}
+			}
+			out.Write(expand(src[start:last.End]))
+			start = last.End
+		}
+		if last.Kind == "eof" || last.End > lastControl {
+			return finish()
+		}
+	}
+}
+
 func goLLVMTypeForType(t types.Type, goarch string) (LLVMType, error) {
 	return goLLVMTypeForTypeWithSizes(t, goarch, types.SizesFor("gc", goarch))
 }
@@ -753,6 +1464,10 @@ func goLLVMTypeForTypeWithSizes(t types.Type, goarch string, sz types.Sizes) (LL
 			return LLVMType("float"), nil
 		case types.Float64:
 			return LLVMType("double"), nil
+		case types.Complex64:
+			return LLVMType("{ float, float }"), nil
+		case types.Complex128:
+			return LLVMType("{ double, double }"), nil
 		case types.String:
 			if wordSize == 8 {
 				return LLVMType("{ ptr, i64 }"), nil
@@ -775,11 +1490,25 @@ func goLLVMTypeForTypeWithSizes(t types.Type, goarch string, sz types.Sizes) (LL
 		return LLVMType("{ ptr, i32, i32 }"), nil
 	case *types.Interface:
 		return LLVMType("{ ptr, ptr }"), nil
+	case *types.Array:
+		elem, err := goLLVMTypeForTypeWithSizes(tt.Elem(), goarch, sz)
+		if err != nil {
+			return "", err
+		}
+		return LLVMType(fmt.Sprintf("[%d x %s]", tt.Len(), elem)), nil
 	case *types.Struct:
 		if tt.NumFields() == 0 {
 			return LLVMType("[0 x i8]"), nil
 		}
-		return "", fmt.Errorf("unsupported struct type %s", tt.String())
+		fields := make([]string, tt.NumFields())
+		for i := range fields {
+			field, err := goLLVMTypeForTypeWithSizes(tt.Field(i).Type(), goarch, sz)
+			if err != nil {
+				return "", err
+			}
+			fields[i] = string(field)
+		}
+		return LLVMType("{ " + strings.Join(fields, ", ") + " }"), nil
 	case *types.Named:
 		return goLLVMTypeForTypeWithSizes(tt.Underlying(), goarch, sz)
 	default:
@@ -803,6 +1532,10 @@ func goLLVMArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz, frameS
 	off := startOff
 	argIdx := 0
 	for i := 0; i < tup.Len(); i++ {
+		name := ""
+		if flattenAgg {
+			name = tup.At(i).Name()
+		}
 		t := tup.At(i).Type()
 		a := int64(frameSz.Alignof(t))
 		off = goAlignOff(off, a)
@@ -812,7 +1545,7 @@ func goLLVMArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz, frameS
 			if flattenAgg {
 				for _, part := range parts {
 					args = append(args, part.Type)
-					slots = append(slots, FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: -1})
+					slots = append(slots, FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: -1, Name: name})
 					argIdx++
 				}
 			} else {
@@ -822,7 +1555,7 @@ func goLLVMArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz, frameS
 				}
 				args = append(args, ty)
 				for _, part := range parts {
-					slots = append(slots, FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: part.Field})
+					slots = append(slots, FrameSlot{Offset: off + part.Offset, Type: part.Type, Index: argIdx, Field: part.Field, Fields: part.Fields})
 				}
 				argIdx++
 			}
@@ -835,7 +1568,7 @@ func goLLVMArgsAndFrameSlotsForTuple(tup *types.Tuple, goarch string, sz, frameS
 			return nil, nil, 0, e
 		}
 		args = append(args, ty)
-		slots = append(slots, FrameSlot{Offset: off, Type: ty, Index: argIdx, Field: -1})
+		slots = append(slots, FrameSlot{Offset: off, Type: ty, Index: argIdx, Field: -1, Name: name})
 		argIdx++
 		off += int64(frameSz.Sizeof(t))
 	}
@@ -846,6 +1579,7 @@ type goFramePart struct {
 	Offset int64
 	Type   LLVMType
 	Field  int
+	Fields []int
 }
 
 func goFramePartsForType(t types.Type, goarch string) ([]goFramePart, bool) {
@@ -861,17 +1595,73 @@ func goFramePartsForTypeWithSizes(t types.Type, goarch string, sz, frameSz types
 	}
 	switch u := t.Underlying().(type) {
 	case *types.Basic:
-		if u.Kind() == types.String {
+		switch u.Kind() {
+		case types.String:
 			return []goFramePart{{Offset: 0, Type: Ptr, Field: 0}, {Offset: word, Type: wordTy, Field: 1}}, true
+		case types.Complex64:
+			return []goFramePart{{Offset: 0, Type: "float", Field: 0}, {Offset: 4, Type: "float", Field: 1}}, true
+		case types.Complex128:
+			return []goFramePart{{Offset: 0, Type: "double", Field: 0}, {Offset: 8, Type: "double", Field: 1}}, true
 		}
 	case *types.Slice:
 		return []goFramePart{{Offset: 0, Type: Ptr, Field: 0}, {Offset: word, Type: wordTy, Field: 1}, {Offset: 2 * word, Type: wordTy, Field: 2}}, true
 	case *types.Interface:
 		return []goFramePart{{Offset: 0, Type: Ptr, Field: 0}, {Offset: word, Type: Ptr, Field: 1}}, true
+	case *types.Struct:
+		fields := make([]*types.Var, u.NumFields())
+		for i := range fields {
+			fields[i] = u.Field(i)
+		}
+		offsets := frameSz.Offsetsof(fields)
+		var parts []goFramePart
+		for i, field := range fields {
+			children, ok := goNestedFrameParts(field.Type(), goarch, sz, frameSz, i, offsets[i])
+			if !ok {
+				return nil, false
+			}
+			parts = append(parts, children...)
+		}
+		return parts, true
+	case *types.Array:
+		var parts []goFramePart
+		for i := int64(0); i < u.Len(); i++ {
+			children, ok := goNestedFrameParts(u.Elem(), goarch, sz, frameSz, int(i), i*frameSz.Sizeof(u.Elem()))
+			if !ok {
+				return nil, false
+			}
+			parts = append(parts, children...)
+		}
+		return parts, true
 	}
 	return nil, false
 }
 
+func goNestedFrameParts(t types.Type, goarch string, sz, frameSz types.Sizes, field int, offset int64) ([]goFramePart, bool) {
+	parts, aggregate := goFramePartsForTypeWithSizes(t, goarch, sz, frameSz)
+	if !aggregate {
+		typ, err := goLLVMTypeForTypeWithSizes(t, goarch, sz)
+		if err != nil {
+			return nil, false
+		}
+		parts = []goFramePart{{Type: typ, Field: -1}}
+	}
+	for i := range parts {
+		part := &parts[i]
+		path := []int{field}
+		if len(part.Fields) != 0 {
+			path = append(path, part.Fields...)
+		} else if part.Field >= 0 {
+			path = append(path, part.Field)
+		}
+		part.Offset += offset
+		part.Field = field
+		if len(path) > 1 {
+			part.Fields = path
+		}
+	}
+	return parts, true
+}
+
 func goWordSize(goarch string) int {
 	switch goarch {
 	case "amd64", "arm64", "wasm":
diff --git a/go_translate_context_test.go b/go_translate_context_test.go
new file mode 100644
index 000000000..b53e87c18
--- /dev/null
+++ b/go_translate_context_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoBindingInContextUsesOwnedContextAndPreservesPublicWrapper(t *testing.T) {
+	pkg := mustGoPackage(t, "test/ownedcontext", "package ownedcontext\nfunc Pass(uint64) uint64\n")
+	for _, target := range []struct {
+		goarch, triple, source string
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", "TEXT ·Pass(SB),4,$0-16\nMOVQ x+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n"},
+		{"arm64", "aarch64-unknown-linux-gnu", "TEXT ·Pass<ABIInternal>(SB),4,$0-16\nRET\n"},
+	} {
+		for _, annotate := range []bool{false, true} {
+			for repeat := 0; repeat < 3; repeat++ {
+				func() {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					options := GoModuleOptions{
+						GOARCH: target.goarch, TargetTriple: target.triple,
+						AnnotateSource: annotate,
+						ResolveSym:     func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+					}
+					tr, err := translateGoModuleInContext(ctx, pkg, []byte(target.source), options)
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer tr.Module.Dispose() // Module must die before its context.
+					if tr.Module.Context() != ctx {
+						t.Fatal("Go-bound module escaped the supplied context")
+					}
+					if err := llvm.VerifyModule(tr.Module, llvm.ReturnStatusAction); err != nil {
+						t.Fatal(err)
+					}
+					public, err := TranslateGoModule(pkg, []byte(target.source), options)
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer public.Module.Dispose()
+					if public.Module.Context() != llvm.GlobalContext() {
+						t.Fatal("public Go binding wrapper changed its default context")
+					}
+					// Textual parsing records its unique owned temporary path as
+					// module identity. Compare actual function IR, not that path.
+					if public.Module.NamedFunction("Pass").String() != tr.Module.NamedFunction("Pass").String() {
+						t.Fatalf("public Go binding wrapper changed the translated body:\n%s\n%s", public.Module.String(), tr.Module.String())
+					}
+				}()
+			}
+		}
+	}
+}
+
+func TestGoBindingInContextErrorDoesNotAcquireContextOwnership(t *testing.T) {
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if _, err := translateGoModuleInContext(ctx, GoPackage{}, nil, GoModuleOptions{}); err == nil {
+		t.Fatal("missing package accepted")
+	}
+	// A rejected translation cannot destroy its caller's still-live context.
+	pkg := mustGoPackage(t, "test/ownedcontext", "package ownedcontext\nfunc Pass(uint64) uint64\n")
+	tr, err := translateGoModuleInContext(ctx, pkg, []byte("TEXT ·Pass<ABIInternal>(SB),4,$0-16\nRET\n"), GoModuleOptions{
+		GOARCH: "arm64", TargetTriple: "aarch64-unknown-linux-gnu",
+		ResolveSym: func(sym string) string { return strings.TrimPrefix(goStripABISuffix(sym), "·") },
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer tr.Module.Dispose()
+	if tr.Module.Context() != ctx {
+		t.Fatal("successful retry did not use the still-owned context")
+	}
+}
diff --git a/go_translate_deep_test.go b/go_translate_deep_test.go
index a788b26c7..6a488e550 100644
--- a/go_translate_deep_test.go
+++ b/go_translate_deep_test.go
@@ -1,11 +1,13 @@
 package plan9asm
 
 import (
+	"errors"
 	"go/ast"
 	"go/constant"
 	"go/parser"
 	"go/token"
 	"go/types"
+	"reflect"
 	"strings"
 	"testing"
 )
@@ -133,9 +135,9 @@ func TestGoTranslateTypeCoverage(t *testing.T) {
 		{types.NewInterfaceType(nil, nil), "amd64", LLVMType("{ ptr, ptr }"), true},
 		{named, "amd64", I32, true},
 		{alias, "arm64", I64, true},
-		{types.Typ[types.Complex64], "amd64", "", false},
+		{types.Typ[types.Complex64], "amd64", "{ float, float }", true},
 		{types.NewStruct(nil, nil), "amd64", LLVMType("[0 x i8]"), true},
-		{types.NewStruct([]*types.Var{types.NewVar(token.NoPos, nil, "x", types.Typ[types.Int])}, nil), "amd64", "", false},
+		{types.NewStruct([]*types.Var{types.NewVar(token.NoPos, nil, "x", types.Typ[types.Int])}, nil), "amd64", "{ i64 }", true},
 	} {
 		got, err := goLLVMTypeForType(tc.typ, tc.goarch)
 		if (err == nil) != tc.ok || got != tc.want {
@@ -179,6 +181,56 @@ func TestGoTranslateTypeCoverage(t *testing.T) {
 	}
 }
 
+func TestModerncUint128ABI0Signature(t *testing.T) {
+	pkg := mustGoPackageWithImports(t, "modernc.org/libc", map[string]string{
+		"abi0_linux_amd64.go": `package libc
+			type TLS struct{}
+			type Uint128 struct { Lo, Hi uint64 }
+			func Y__builtin_mul_overflowUint128(t *TLS, a, b Uint128, res uintptr) (result int32)`,
+	})
+	fn, ok := pkg.Types.Scope().Lookup("Y__builtin_mul_overflowUint128").(*types.Func)
+	if !ok {
+		t.Fatal("missing assembly declaration")
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	sig, err := goFuncSigForDeclaredFunc("modernc.org/libc.Y__builtin_mul_overflowUint128", fn, "amd64", sizes, sizes, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := sig.Args, []LLVMType{Ptr, "{ i64, i64 }", "{ i64, i64 }", I64}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("Args = %v, want %v", got, want)
+	}
+	if sig.Ret != I32 {
+		t.Fatalf("Ret = %s, want %s", sig.Ret, I32)
+	}
+	for _, slot := range []struct {
+		index  int
+		offset int64
+		field  int
+	}{
+		{0, 0, -1},
+		{1, 8, 0},
+		{1, 16, 1},
+		{2, 24, 0},
+		{2, 32, 1},
+		{3, 40, -1},
+	} {
+		found := false
+		for _, got := range sig.Frame.Params {
+			if got.Index == slot.index && got.Offset == slot.offset && got.Field == slot.field {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Fatalf("missing ABI0 parameter slot %+v in %+v", slot, sig.Frame.Params)
+		}
+	}
+	if len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 48 {
+		t.Fatalf("Results = %+v, want one slot at offset 48", sig.Frame.Results)
+	}
+}
+
 func TestGoTranslateSignatureCoverage(t *testing.T) {
 	pkg := mustGoPackage(t, "test/pkg", `package testpkg
 type S struct{}
@@ -209,21 +261,47 @@ func cmp(a, b int) int { return a }
 	file := &File{
 		Arch: ArchARM64,
 		Funcs: []Func{
-			{Sym: "·Plain", Instrs: []Instr{{Op: OpTEXT}, {Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: "runtime·cmp(SB)"}}}, {Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: "undeclared_call(SB)"}}}, {Op: "B", Args: []Operand{{Kind: OpSym, Sym: "localtarget<>(SB)"}}}, {Op: OpRET}}},
-			{Sym: "localhelper<>", Instrs: []Instr{{Op: OpTEXT}, {Op: "B", Args: []Operand{{Kind: OpSym, Sym: "helper<>(SB)"}}}, {Op: OpRET}}},
+			{
+				Sym: "·Plain",
+				Instrs: []Instr{
+					{Op: OpTEXT},
+					{Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: "runtime·cmp(SB)"}}},
+					{Op: "CALL", Args: []Operand{{Kind: OpSym, Sym: "undeclared_call(SB)"}}},
+					{Op: "B", Args: []Operand{{Kind: OpSym, Sym: "localtarget<>(SB)"}}},
+					{Op: OpRET},
+				},
+			},
+			{
+				Sym: "localhelper<>",
+				Instrs: []Instr{
+					{Op: OpTEXT},
+					{Op: "B", Args: []Operand{{Kind: OpSym, Sym: "helper<>(SB)"}}},
+					{Op: OpRET},
+				},
+			},
 			{Sym: "localtarget<>"},
 		},
 	}
-	sigs, err := goSigsForAsmFile(pkg, file, testResolveSym("test/pkg"), "arm64", nil, nil, func(resolved string) (FuncSig, bool) {
+	manual := func(resolved string) (FuncSig, bool) {
 		if resolved == "test/pkg.localhelper" {
 			return FuncSig{Name: resolved, Args: []LLVMType{I64}, Ret: I64}, true
 		}
 		return FuncSig{}, false
-	})
+	}
+	if _, err := goSigsForAsmFile(pkg, file, testResolveSym("test/pkg"), "arm64", nil, nil, manual); !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "no declaration or explicit register transport") {
+		t.Fatalf("unbound private tail inherited its caller's signature: %v", err)
+	}
+
+	// Ordinary unresolved calls remain untyped. Changing the query fixture's
+	// edge does not supply a declaration, register ABI or executable contract.
+	file.Funcs[0].Instrs[3].Op = "CALL"
+	file.Funcs = file.Funcs[:2]
+	sigs, err := goSigsForAsmFile(pkg, file, testResolveSym("test/pkg"), "arm64", nil, nil, manual)
 	if err != nil {
 		t.Fatalf("goSigsForAsmFile() error = %v", err)
 	}
-	for _, want := range []string{"test/pkg.Plain", "runtime.cmp", "test/pkg.localhelper", "test/pkg.localtarget"} {
+	for _, want := range []string{"test/pkg.Plain", "runtime.cmp", "test/pkg.localhelper"} {
 		if _, ok := sigs[want]; !ok {
 			t.Fatalf("missing signature %q", want)
 		}
@@ -231,6 +309,9 @@ func cmp(a, b int) int { return a }
 	if _, ok := sigs["test/pkg.undeclared_call"]; ok {
 		t.Fatalf("ordinary unresolved CALL unexpectedly received a synthesized signature")
 	}
+	if _, ok := sigs["test/pkg.localtarget"]; ok {
+		t.Fatal("unresolved local helper CALL unexpectedly received a synthesized signature")
+	}
 
 	builder := goSigBuilder{
 		sigs:      map[string]FuncSig{},
diff --git a/go_translate_helpers_test.go b/go_translate_helpers_test.go
index 9e9a8106a..c8866c7ed 100644
--- a/go_translate_helpers_test.go
+++ b/go_translate_helpers_test.go
@@ -141,6 +141,14 @@ MOVD $const_Bool, R5
 
 func TestGoAsmHeaderDataConstants(t *testing.T) {
 	pkg := types.NewPackage("test/pkg", "pkg")
+	genericName := types.NewTypeName(token.NoPos, pkg, "generic", nil)
+	typeParamName := types.NewTypeName(token.NoPos, pkg, "T", nil)
+	typeParam := types.NewTypeParam(typeParamName, types.NewInterfaceType(nil, nil).Complete())
+	generic := types.NewNamed(genericName, types.NewStruct([]*types.Var{
+		types.NewField(token.NoPos, pkg, "value", typeParam, false),
+	}, nil), nil)
+	generic.SetTypeParams([]*types.TypeParam{typeParam})
+	pkg.Scope().Insert(genericName)
 	pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, "smallInt", types.Typ[types.UntypedInt], constant.MakeInt64(42)))
 	pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, "bigInt", types.Typ[types.UntypedInt], constant.MakeUint64(^uint64(0))))
 	pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, "stringVal", types.Typ[types.UntypedString], constant.MakeString("test")))
@@ -166,6 +174,10 @@ func TestGoAsmHeaderDataConstants(t *testing.T) {
 	if got := goExpandAsmHeaderTypes(unchanged, pkg, "unsupported"); !bytes.Equal(got, unchanged) {
 		t.Fatalf("unsupported-arch expansion changed source: %q", got)
 	}
+	genericRef := []byte("MOVD $generic__size, R0")
+	if got := goExpandAsmHeaderTypes(genericRef, pkg, "arm64"); !bytes.Equal(got, genericRef) {
+		t.Fatalf("uninstantiated generic struct macro unexpectedly expanded: %q", got)
+	}
 	nonStructPkg := types.NewPackage("test/nonstruct", "nonstruct")
 	nonStructPkg.Scope().Insert(types.NewVar(token.NoPos, nonStructPkg, "value", types.Typ[types.Int]))
 	if got := goExpandAsmHeaderTypes(unchanged, nonStructPkg, "arm64"); !bytes.Equal(got, unchanged) {
diff --git a/go_translate_test.go b/go_translate_test.go
index 56deff0b8..66fff71c9 100644
--- a/go_translate_test.go
+++ b/go_translate_test.go
@@ -1,10 +1,15 @@
 package plan9asm
 
 import (
+	"errors"
 	"go/ast"
+	"go/constant"
 	"go/parser"
 	"go/token"
 	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"strings"
 	"testing"
 )
@@ -76,6 +81,111 @@ TEXT ·gogo(SB),NOSPLIT,$0-8
 	}
 }
 
+func TestExpandGoAssemblySourcePreservesIncludedMacroDefinitionNames(t *testing.T) {
+	pkg := mustGoPackage(t, "example.com/ffi", `package ffi
+const type64 = 0
+type frame struct { value uintptr }
+func asmcall()
+`)
+	source := []byte(`// runtime has #include "go_asm.h"
+#define const_type64 0x0
+#define frame__size 8
+TEXT ·asmcall(SB),NOSPLIT,$0-0
+	CMPB AX, $const_type64
+	MOVQ $frame__size, BX
+	RET
+`)
+	expanded := ExpandGoAssemblySource(pkg, source, "amd64")
+	if strings.Contains(string(expanded), "#define 0 ") {
+		t.Fatalf("constant expansion rewrote the macro definition name:\n%s", expanded)
+	}
+	if !strings.Contains(string(expanded), "#define const_type64 0x0") {
+		t.Fatalf("constant expansion did not preserve the macro definition:\n%s", expanded)
+	}
+	if !strings.Contains(string(expanded), "#define frame__size 8") {
+		t.Fatalf("type-layout expansion did not preserve the macro definition:\n%s", expanded)
+	}
+	if _, err := ParseWithDefines(ArchAMD64, string(expanded), GoAssemblerDefines("linux", "amd64")); err != nil {
+		t.Fatalf("ParseWithDefines(expanded) error = %v\n%s", err, expanded)
+	}
+}
+
+func TestExpandGoAssemblySourcePreservesDirectiveOperands(t *testing.T) {
+	pkg := mustGoPackage(t, "example/directives", `package directives
+const Count = 16
+const Free = 7
+type frame struct { value uintptr }
+`)
+	for _, row := range []struct{ source, want string }{
+		{"#ifdef const_Count\n", "#ifdef const_Count\n"},
+		{"/* lead */ #ifdef const_Count\n", "/* lead */ #ifdef const_Count\n"},
+		{"/* lead\n*/ #ifdef const_Count\n", "/* lead\n*/ #ifdef const_Count\n"},
+		{"#ifndef frame__size\n", "#ifndef frame__size\n"},
+		{"#undef const_Count\n", "#undef const_Count\n"},
+		{"#include \"const_Count/frame__size.h\"\n", "#include \"const_Count/frame__size.h\"\n"},
+		{"#line 17 \"const_Count.s\"\n", "#line 17 \"const_Count.s\"\n"},
+		{"#else\n#endif\n", "#else\n#endif\n"},
+		// These controls are not supported by Go's assembler. Leave their
+		// syntax intact for the preprocessor to reject, including defined().
+		{"#if defined(const_Count)\n", "#if defined(const_Count)\n"},
+		{"#if const_Count\n", "#if const_Count\n"},
+		{"#elif frame__size\n", "#elif frame__size\n"},
+		{"#define const_Count const_Free\n", "#define const_Count 7\n"},
+		{" \t# define frame__size const_Free\n", " \t# define frame__size 7\n"},
+		{"# /* keyword */ define const_Count const_Free\n", "# /* keyword */ define const_Count 7\n"},
+		{"#define /* name */ VALUE const_Free\n", "#define /* name */ VALUE 7\n"},
+		{"#define /* name\n*/ const_Count const_Free\n", "#define /* name\n*/ const_Count 7\n"},
+		{"#define F(const_Count/* ) */,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX\n",
+			"#define F(const_Count/* ) */,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX\n"},
+		{"#define F(const_Count /* )\n*/,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX\n",
+			"#define F(const_Count /* )\n*/,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX\n"},
+		{"#define F(const_Count) MOVQ $const_Count,AX /* body\n*/; MOVQ $const_Count,BX; MOVQ $const_Free,CX\n",
+			"#define F(const_Count) MOVQ $const_Count,AX /* body\n*/; MOVQ $const_Count,BX; MOVQ $7,CX\n"},
+		{"#define F(const_Count,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX; MOVQ $const_Free,CX\n",
+			"#define F(const_Count,frame__size) MOVQ $const_Count,AX; MOVQ $frame__size,BX; MOVQ $7,CX\n"},
+		{"#define F(const_Count) MOVQ $const_Count,AX; \\\nMOVQ $const_Count,BX; MOVQ $const_Free,CX\n",
+			"#define F(const_Count) MOVQ $const_Count,AX; \\\nMOVQ $const_Count,BX; MOVQ $7,CX\n"},
+		{"#define F(const_Count) MOVQ $const_Count,AX; \\ \t\nMOVQ $const_Count,BX; MOVQ $const_Free,CX\n",
+			"#define F(const_Count) MOVQ $const_Count,AX; \\ \t\nMOVQ $const_Count,BX; MOVQ $7,CX\n"},
+		{"#define F(const_Count) MOVQ $const_Count,AX; \\ // continued\nMOVQ $const_Count,BX\n",
+			"#define F(const_Count) MOVQ $const_Count,AX; \\ // continued\nMOVQ $const_Count,BX\n"},
+		{"#define F(const_Count) \\ /* pair */ \\\nMOVQ $const_Count,BX\n",
+			"#define F(const_Count) \\ /* pair */ \\\nMOVQ $16,BX\n"},
+		{"MOVQ $const_Count,AX; MOVQ $frame__size,BX\n", "MOVQ $16,AX; MOVQ $8,BX\n"},
+		{"MOVQ $const_Count,AX // # is not a directive\n", "MOVQ $16,AX // # is not a directive\n"},
+	} {
+		t.Run(strings.TrimSpace(row.source), func(t *testing.T) {
+			// Keep the existing generated-type expansion path active.
+			prefix := "// #include \"go_asm.h\"\n"
+			got := ExpandGoAssemblySource(pkg, []byte(prefix+row.source), "amd64")
+			if string(got) != prefix+row.want {
+				t.Fatalf("expanded %q, want %q", got, prefix+row.want)
+			}
+		})
+	}
+}
+
+func BenchmarkExpandGoAssemblySource(b *testing.B) {
+	typed := types.NewPackage("example/expand", "expand")
+	typed.Scope().Insert(types.NewConst(token.NoPos, typed, "Value", types.Typ[types.UntypedInt], constant.MakeInt64(7)))
+	pkg := GoPackage{Path: typed.Path(), Types: typed}
+	for _, row := range []struct{ name, source string }{
+		{"plain", strings.Repeat("MOVQ $const_Value,AX\n", 256)},
+		{"directives", "#define LOAD(const_Value) MOVQ $const_Value,AX\n" + strings.Repeat("LOAD(const_Value)\n", 256)},
+	} {
+		b.Run(row.name, func(b *testing.B) {
+			source := []byte(row.source)
+			b.SetBytes(int64(len(source)))
+			b.ReportAllocs()
+			for i := 0; i < b.N; i++ {
+				if len(ExpandGoAssemblySource(pkg, source, "amd64")) == 0 {
+					b.Fatal("generated assembly disappeared")
+				}
+			}
+		})
+	}
+}
+
 func TestTranslateGoModule_UsesCallerWasmTypeSizes(t *testing.T) {
 	pkg := mustGoPackage(t, "example.com/wasm32", `package wasm32
 func Consume(value int, data []byte) int
@@ -114,7 +224,9 @@ func Consume(value int, data []byte) int
 	}
 }
 
-func TestTranslateGoModule_UsesManualSigForPlainLocalHelper(t *testing.T) {
+// A manual signature resolves a name and type. It does not provide the
+// original Go declaration/caller evidence required by an ABI0 tail.
+func TestTranslateGoModule_ManualSigCannotInventABI0TailDeclaration(t *testing.T) {
 	pkg := mustGoPackage(t, "test/pkg", `package testpkg
 func IndexByte(b []byte, c byte) int
 `)
@@ -140,15 +252,100 @@ TEXT indexbytebody<>(SB),NOSPLIT,$0
 			return FuncSig{Name: resolved, Args: []LLVMType{"{ ptr, i64, i64 }", "i8"}, Ret: I64}, true
 		},
 	})
-	if err != nil {
-		t.Fatal(err)
+	if tr != nil {
+		tr.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "actual selected bodyless declaration") {
+		t.Fatalf("manual signature supplied an unbound ABI0 tail: %v", err)
 	}
-	defer tr.Module.Dispose()
 	if !manualCalled {
 		t.Fatalf("manual signature callback was not used")
 	}
-	if _, ok := tr.Signatures["test/pkg.indexbytebody"]; !ok {
-		t.Fatalf("missing manual helper signature")
+}
+
+func TestTranslateGoModule_UsesManualSigForPlainLocalHelper(t *testing.T) {
+	pkg := mustGoPackage(t, "test/pkg", `package testpkg
+func Call()
+`)
+	// This fixture isolates signature resolution with an ordinary no-argument
+	// call. It does not invent slice transport or a result stored only in R0.
+	asm := []byte(`TEXT ·Call(SB),4,$0-0
+	CALL localbody(SB)
+	RET
+
+TEXT localbody(SB),4,$0-0
+	MOVD $0, R0
+	RET
+`)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{
+		"aarch64-unknown-linux-gnu", "aarch64-apple-darwin", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			requireManualHelperGoObject(t, triple, asm)
+			manualCalled := false
+			tr, err := TranslateGoModule(pkg, asm, GoModuleOptions{
+				FileName:     "call_arm64.s",
+				GOARCH:       "arm64",
+				TargetTriple: triple,
+				ResolveSym:   testResolveSym("test/pkg"),
+				ManualSig: func(resolved string) (FuncSig, bool) {
+					if resolved != "test/pkg.localbody" {
+						return FuncSig{}, false
+					}
+					manualCalled = true
+					return FuncSig{Name: resolved, Ret: Void}, true
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer tr.Module.Dispose()
+			if !manualCalled {
+				t.Fatal("manual signature callback was not used")
+			}
+			sig, ok := tr.Signatures["test/pkg.localbody"]
+			if !ok || len(sig.Args) != 0 || sig.Ret != Void {
+				t.Fatalf("manual helper signature = %+v, present = %v", sig, ok)
+			}
+			compileLLVMToObject(t, llc, triple, "manual-helper.ll", "manual-helper.o", tr.Module.String())
+		})
+	}
+}
+
+func requireManualHelperGoObject(t *testing.T, triple string, source []byte) {
+	t.Helper()
+	goos := "linux"
+	if strings.Contains(triple, "apple") {
+		goos = "darwin"
+	} else if strings.Contains(triple, "windows") {
+		goos = "windows"
+	}
+	dir := t.TempDir()
+	input := filepath.Join(dir, "call_arm64.s")
+	object := filepath.Join(dir, "call.o")
+	if err := os.WriteFile(input, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-p", "test/pkg", "-o", object, input)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=arm64", "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go local helper object: %v\n%s", err, output)
+	} else if len(output) != 0 {
+		t.Fatalf("unexpected original Go object diagnostic: %s", output)
+	}
+	info, err := os.Lstat(object)
+	if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+		t.Fatalf("missing regular original Go object: %v", err)
+	}
+	data, err := os.ReadFile(object)
+	if err != nil || !strings.HasPrefix(string(data), "go object "+goos+" arm64 ") {
+		t.Fatalf("original Go object target mismatch: %v", err)
 	}
 }
 
@@ -156,8 +353,10 @@ func TestTranslateGoModule_UsesManualSigExternalName(t *testing.T) {
 	pkg := mustGoPackage(t, "test/pkg", `package testpkg
 func Call()
 `)
+	// This checks external-name resolution, not runtime.memmove's ABI. An
+	// uninitialized pointer call cannot prove that the saved caller LR survives.
 	asm := []byte(`TEXT ·Call(SB),NOSPLIT,$0-0
-	CALL runtime·memmove(SB)
+	CALL external·namedSink(SB)
 	RET
 `)
 
@@ -168,10 +367,10 @@ func Call()
 				GOARCH:     goarch,
 				ResolveSym: testResolveSym("test/pkg"),
 				ManualSig: func(resolved string) (FuncSig, bool) {
-					if resolved != "runtime.memmove" {
+					if resolved != "external.namedSink" {
 						return FuncSig{}, false
 					}
-					return FuncSig{Name: "memmove", Args: []LLVMType{Ptr, Ptr, I64}, Ret: Ptr}, true
+					return FuncSig{Name: "namedSink", Ret: Void}, true
 				},
 			})
 			if err != nil {
@@ -179,7 +378,7 @@ func Call()
 			}
 			defer tr.Module.Dispose()
 			ir := tr.Module.String()
-			if !strings.Contains(ir, "@memmove") || strings.Contains(ir, "runtime.memmove") {
+			if !strings.Contains(ir, "@namedSink") || strings.Contains(ir, "external.namedSink") {
 				t.Fatalf("manual external name not applied:\n%s", ir)
 			}
 		})
@@ -197,13 +396,26 @@ func Round(x float64) int64
 	RET
 `)
 
-	tr, err := TranslateGoModule(pkg, asm, GoModuleOptions{
+	options := GoModuleOptions{
 		FileName:     "round_386.s",
 		GOARCH:       "386",
 		TargetTriple: "i386-unknown-linux-gnu",
 		X87Mode:      X87Software,
 		ResolveSym:   testResolveSym("test/pkg"),
-	})
+	}
+	goAssemblerOracleOutput(t, "386", strings.ReplaceAll(string(asm), ",NOSPLIT,", ",4,"), "", true)
+	original, err := TranslateGoModule(pkg, asm, options)
+	if original != nil {
+		original.Module.Dispose()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original source invented an entry control word", err)
+	}
+	// A separately initialized counterpart still exercises the same three
+	// original numerical instructions and actual Software option propagation.
+	initialized := strings.Replace(string(asm), "\n\tFMOVD", "\n\tFINIT\n\tFMOVD", 1)
+	goAssemblerOracleOutput(t, "386", strings.ReplaceAll(initialized, ",NOSPLIT,", ",4,"), "", true)
+	tr, err := TranslateGoModule(pkg, []byte(initialized), options)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/go_x86_imported_tail.go b/go_x86_imported_tail.go
new file mode 100644
index 000000000..f36f419e6
--- /dev/null
+++ b/go_x86_imported_tail.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goabi"
+)
+
+// Ordinary Go declarations retain their source convention. A structurally
+// identical C/custom function or a renamed entry cannot supply an ABI0 tail.
+func goX86TailFunction(pkg GoPackage, name string, bodyless bool, sizes types.Sizes) (*types.Func, error) {
+	if pkg.Types == nil || pkg.Types.Scope() == nil || pkg.Types.Name() == "C" {
+		return nil, x86DirectTailContext("tail declaration lacks an ordinary Go package")
+	}
+	fn, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+	if !ok || fn.Pkg() != pkg.Types || fn.Parent() != pkg.Types.Scope() {
+		return nil, x86DirectTailContext("tail lacks its actual Go function declaration: %s", name)
+	}
+	sig, ok := fn.Type().(*types.Signature)
+	if !ok || sig.Recv() != nil || sig.Variadic() || sig.TypeParams().Len() != 0 {
+		return nil, x86DirectTailContext("tail excludes methods, variadic and generic declarations")
+	}
+	if len(pkg.Syntax) == 0 || len(pkg.Syntax) > 256 {
+		return nil, x86DirectTailContext("tail lacks bounded selected declaration syntax")
+	}
+	found := false
+	for _, file := range pkg.Syntax {
+		if file == nil || file.Name == nil || file.Name.Name != pkg.Types.Name() {
+			return nil, x86DirectTailContext("tail syntax differs from its actual package")
+		}
+		for _, node := range file.Decls {
+			declaration, ok := node.(*ast.FuncDecl)
+			if !ok || declaration == nil || declaration.Name == nil || declaration.Recv != nil || declaration.Name.Name != name {
+				continue
+			}
+			if found {
+				return nil, x86DirectTailContext("tail declaration is duplicated")
+			}
+			if bodyless && declaration.Body != nil {
+				return nil, x86DirectTailContext("tail caller is not a bodyless assembly declaration")
+			}
+			if err := goX86TailSyntaxType(pkg, file, declaration, sig, sizes); err != nil {
+				return nil, err
+			}
+			found = true
+			if declaration.Doc != nil {
+				for _, comment := range declaration.Doc.List {
+					text := strings.TrimSpace(strings.TrimPrefix(comment.Text, "//"))
+					if strings.HasPrefix(text, "llgo:") {
+						return nil, x86DirectTailContext("tail cannot borrow a native/custom declaration")
+					}
+				}
+			}
+		}
+	}
+	for remote, local := range goLinknameRemoteToLocal(pkg.Syntax) {
+		if local == name && remote != pkg.Types.Path()+"."+name {
+			return nil, x86DirectTailContext("tail declaration has a renamed entry")
+		}
+	}
+	if !found {
+		return nil, x86DirectTailContext("tail lacks its selected declaration syntax: %s", name)
+	}
+	return fn, nil
+}
+
+// Recheck only the selected function type against its actual package objects
+// and imports. This uses Go's type checker with the requested architecture's
+// sizes; it neither rechecks bodies nor formats/reloads a complete package.
+func goX86TailSyntaxType(pkg GoPackage, file *ast.File, declaration *ast.FuncDecl,
+	expected *types.Signature, sizes types.Sizes) error {
+	if declaration.Type == nil || sizes == nil {
+		return x86DirectTailContext("tail lacks a target-sized declaration type")
+	}
+	owner := types.NewPackage(pkg.Types.Path(), pkg.Types.Name())
+	referenced := make(map[string]bool)
+	ast.Inspect(declaration.Type, func(node ast.Node) bool {
+		if identifier, ok := node.(*ast.Ident); ok {
+			referenced[identifier.Name] = true
+			if object := pkg.Types.Scope().Lookup(identifier.Name); object != nil {
+				owner.Scope().Insert(object)
+			}
+		}
+		return true
+	})
+	for _, specification := range file.Imports {
+		if specification == nil || specification.Path == nil {
+			return x86DirectTailContext("tail declaration has an invalid import")
+		}
+		path, err := strconv.Unquote(specification.Path.Value)
+		if err != nil {
+			return x86DirectTailContext("tail declaration has an invalid import path")
+		}
+		var dependency *types.Package
+		for _, imported := range pkg.Types.Imports() {
+			if imported.Path() == path {
+				dependency = imported
+				break
+			}
+		}
+		if dependency == nil {
+			// Export data may omit imports used only by a function body.
+			// Add no guessed object: a signature which actually needs this
+			// import still fails the type check below as an unresolved name.
+			continue
+		}
+		name := dependency.Name()
+		if specification.Name != nil {
+			name = specification.Name.Name
+		}
+		if name == "." {
+			for identifier := range referenced {
+				if object := dependency.Scope().Lookup(identifier); object != nil && object.Exported() {
+					if previous := owner.Scope().Insert(object); previous != nil && previous != object {
+						return x86DirectTailContext("tail declaration has ambiguous imported types")
+					}
+				}
+			}
+		} else if referenced[name] {
+			if path == "C" || owner.Scope().Insert(types.NewPkgName(token.NoPos, owner, name, dependency)) != nil {
+				return x86DirectTailContext("tail declaration has a native or ambiguous import")
+			}
+		}
+	}
+	information := &types.Info{Types: make(map[ast.Expr]types.TypeAndValue)}
+	syntax := &ast.File{Name: ast.NewIdent(owner.Name()), Decls: []ast.Decl{
+		&ast.GenDecl{Tok: token.VAR, Specs: []ast.Spec{
+			&ast.ValueSpec{Names: []*ast.Ident{ast.NewIdent("_")}, Type: declaration.Type},
+		}},
+	}}
+	checker := types.NewChecker(&types.Config{Sizes: sizes}, token.NewFileSet(), owner, information)
+	if err := checker.Files([]*ast.File{syntax}); err != nil {
+		return x86DirectTailContext("tail selected declaration cannot be checked: %v", err)
+	}
+	actual, ok := information.Types[declaration.Type].Type.(*types.Signature)
+	if !ok || !types.Identical(actual, expected) {
+		return x86DirectTailContext("tail selected declaration differs from its actual Go type")
+	}
+	for index, tuple := range []*types.Tuple{actual.Params(), actual.Results()} {
+		wanted := []*types.Tuple{expected.Params(), expected.Results()}[index]
+		for field := 0; field < tuple.Len(); field++ {
+			if tuple.At(field).Name() != wanted.At(field).Name() {
+				return x86DirectTailContext("tail selected declaration field names differ from its actual Go type")
+			}
+		}
+	}
+	return nil
+}
+
+func goX86ImportedTailSignature(pkg GoPackage, resolved, arch string, sizes, frames types.Sizes) (FuncSig, error) {
+	path, name := goReadOnlyImportedName(resolved)
+	if path == "" || path == "C" || path == pkg.Path || pkg.Types == nil {
+		return FuncSig{}, x86DirectTailContext("tail needs its exact ordinary selected import: %s", resolved)
+	}
+	dependency := pkg.Imports[path]
+	if dependency == nil || dependency == pkg.Types || dependency.Path() != path || !dependency.Complete() || dependency.Scope() == nil {
+		return FuncSig{}, x86DirectTailContext("tail lacks its complete selected typed import: %s", path)
+	}
+	found := false
+	for _, imported := range pkg.Types.Imports() {
+		found = found || imported == dependency
+	}
+	if !found {
+		return FuncSig{}, x86DirectTailContext("tail import differs from actual typed dependency: %s", path)
+	}
+	owner := GoPackage{Path: path, Types: dependency, Syntax: pkg.ImportSyntax[path]}
+	if sizes == nil {
+		sizes = types.SizesFor("gc", arch)
+	}
+	fn, err := goX86TailFunction(owner, name, false, sizes)
+	if err != nil {
+		return FuncSig{}, err
+	}
+	return goFuncSigForDeclaredFunc(resolved, fn, arch, sizes, frames, true)
+}
+
+// Only the newly admitted pure external stubs need this declaration join.
+// Existing private continuation/CALL graphs keep their independent contracts.
+func (graph *x86DirectTailGraph) verifyPureGoTails() error {
+	for _, fn := range graph.original.Funcs {
+		target, pure := x86OrdinaryExternalTailTarget(fn)
+		if !pure || x86ABI0BoolResultNeedsProof(graph.signatures[graph.symbols[fn.Sym]], graph.goarch) {
+			continue
+		}
+		if graph.goPackage == nil {
+			return x86DirectTailContext("pure external tail needs its actual GoModule declaration source")
+		}
+		pkg := *graph.goPackage
+		calleeName := graph.externalSymbols[target]
+		if goReadOnlyLocalName(pkg, calleeName) != "" {
+			continue // Same-package Go tails keep their pre-existing declaration path.
+		}
+		name := goReadOnlyLocalName(pkg, fn.Sym)
+		declaration, err := goX86TailFunction(pkg, name, true, types.SizesFor("gc", graph.goarch))
+		if err != nil {
+			return err
+		}
+		resolved := graph.symbols[fn.Sym]
+		if resolved != pkg.Path+"."+name {
+			return x86DirectTailContext("tail caller resolver differs from its actual declaration")
+		}
+		caller, err := goFuncSigForDeclaredFunc(resolved, declaration, graph.goarch, nil, nil, true)
+		if err != nil {
+			return err
+		}
+		word := int64(8)
+		if graph.goarch == "386" {
+			word = 4
+		}
+		end := int64(0)
+		for _, slots := range [][]FrameSlot{caller.Frame.Params, caller.Frame.Results} {
+			for _, slot := range slots {
+				if next := slot.Offset + frameTypeSize(slot.Type, word); next > end {
+					end = next
+				}
+			}
+		}
+		op, rest := splitOpcode(fn.Instrs[0].Raw)
+		frame, err := parseTEXTFrameSpec(strings.Split(rest, ","))
+		if err != nil || !strings.EqualFold(op, "TEXT") || frame.frameSize != fn.FrameSize || frame.argSize != fn.ArgSize ||
+			!x86ABI0FrameLayout(caller, end, graph.goarch) ||
+			!x86TEXTArgumentsUnspecified(fn) && !goabi.MatchesABI0TextSize(graph.goarch, fn.ArgSize, end) {
+			return x86DirectTailContext("tail TEXT extent differs from actual ordinary Go ABI0 declaration")
+		}
+		callee, err := goX86ImportedTailSignature(pkg, calleeName, graph.goarch, nil, nil)
+		if err != nil {
+			return err
+		}
+		if !reflect.DeepEqual(caller, graph.signatures[resolved]) || !reflect.DeepEqual(callee, graph.signatures[calleeName]) {
+			return x86DirectTailContext("pure tail signatures differ from actual ordinary Go ABI0 declarations")
+		}
+	}
+	return nil
+}
diff --git a/go_x86_numerical_read_argument_capture.go b/go_x86_numerical_read_argument_capture.go
new file mode 100644
index 000000000..600949fc9
--- /dev/null
+++ b/go_x86_numerical_read_argument_capture.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"path/filepath"
+	"strings"
+)
+
+// These exact selected Go1.27 rules derive an ABI assignment; this is not an
+// assertion that an absent wrapper physically contains an assignment table.
+// Every role is retained by the same live source/tool input guard.
+var amd64GoArgumentCompilerSchema = map[string]string{
+	"src/cmd/compile/internal/abi/abiutils.go": "35b17262580c3c9e180a5f7c03e26813678fad8b50bac090c68b8f3ade57d030",
+	"src/cmd/compile/internal/types/size.go":   "d32090d796ae53dc8d1430e206b9e98aee8e1e1b2407f952aa7fdd64b8fb9ad5",
+	"src/cmd/compile/internal/ssa/config.go":   "064c69f9217f704adf726980edb6cb7fd1fda99a9204f573db54a620ba891746",
+	"src/cmd/compile/internal/ssa/opGen.go":    "4d0aab8c3eb9b1d438c38ced71852f7f3d3ffc25e2c57efa9f36d7d00cb86f32",
+	"src/cmd/compile/internal/ssagen/ssa.go":   "c4049961202dbfdf8b281b857a55e62ddbab04e109c1722aecbbf0a794983f81",
+	"src/cmd/compile/internal/ssagen/abi.go":   "35b5cea74c417723ff4778cea5175d3a7bdd9c58584af163229e9624a1ee709c",
+	"src/internal/buildcfg/exp.go":             "5825d40b47471bca28a00c0c19215930efef22b758120b6d972da1a955f21fa0",
+	"src/internal/abi/abi_amd64.go":            "b8d763278ba88322c8a7eb1b0aec4ec04063e0a86c2940eeee865a04b12b78c7",
+}
+
+func (source *GoX86NumericalReadSource) captureAMD64GoArgumentRules() error {
+	if source.role != numericalSBSDKSource || source.sdkAssemblyJoin() == nil || source.guard.env["GOARCH"] != "amd64" {
+		return nil
+	}
+	needed := false
+	for _, fn := range source.file.Funcs {
+		needed = needed || strings.HasSuffix(fn.Sym, "<ABIInternal>")
+	}
+	if !needed {
+		return nil
+	}
+	rules := make(map[string]string, len(amd64GoArgumentCompilerSchema))
+	for role, expected := range amd64GoArgumentCompilerSchema {
+		data, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role)))
+		if err != nil {
+			return err
+		}
+		digest := sha256.Sum256(data)
+		if hex.EncodeToString(digest[:]) != expected {
+			return numericalSBContext("selected argument ABI compiler rule differs: %s", role)
+		}
+		rules[role] = expected
+	}
+	source.native.ArgumentRules = rules
+	return nil
+}
diff --git a/go_x86_numerical_read_arguments.go b/go_x86_numerical_read_arguments.go
new file mode 100644
index 000000000..cb7f040d5
--- /dev/null
+++ b/go_x86_numerical_read_arguments.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func amd64GoArgumentNeedsBinding(sig FuncSig) bool {
+	for _, arg := range sig.Args {
+		switch arg {
+		case I8, I16, I32, I64, Ptr:
+		default:
+			return true
+		}
+	}
+	return false
+}
+
+func (binding *GoX86NumericalReadBinding) bindAMD64GoArguments() error {
+	source := binding.source
+	if source.role != numericalSBSDKSource || binding.options.Goarch != "amd64" || source.sdkAssemblyJoin() == nil {
+		return nil
+	}
+	needed := false
+	for _, fn := range source.file.Funcs {
+		needed = needed || strings.HasSuffix(fn.Sym, "<ABIInternal>") && amd64GoArgumentNeedsBinding(binding.options.Sigs[binding.resolve(fn.Sym)])
+	}
+	if !needed {
+		return nil
+	}
+	if !reflect.DeepEqual(source.native.ArgumentRules, amd64GoArgumentCompilerSchema) {
+		return amd64GoArgumentContext("source did not retain the complete selected compiler argument ABI rules")
+	}
+	joined := source.sdkAssemblyJoin()
+	generated, err := gostaticstorage.ObserveX86SDKCompilerText(joined.Observation.Header.CompilerObject,
+		joined.Observation.ObjectInputs.BuiltinSource, source.request.Target, joined.Observation.ObjectInputs.Referenced)
+	if err != nil || joined.Observation.Objects == nil || len(joined.Observation.Objects.Members) < 2 || len(source.native.ArchiveMembers) < 2 {
+		return amd64GoArgumentContext("missing complete original compiler/assembly archive")
+	}
+	member := joined.Observation.Objects.Members[1]
+	originalMember := source.native.ArchiveMembers[1]
+	if member.Name != "_go_.o" || originalMember.Name != member.Name || originalMember.Offset != member.Offset ||
+		originalMember.Size != member.Size || originalMember.Flags != member.Flags || !reflect.DeepEqual(originalMember.Texts, member.Texts) {
+		return amd64GoArgumentContext("selected compiler member differs from complete original archive")
+	}
+	aliases, err := numericalCompilerAliasIndex(joined.Observation.Header.SymABI, generated, member.Texts)
+	if err != nil {
+		return err
+	}
+	pkg := binding.packageInput
+	names, err := numericalGoDeclarationLinknames(pkg.Syntax, pkg.Types)
+	if err != nil {
+		return err
+	}
+	entries, _, err := numericalTypedSourceDeclarations(source.file, pkg.Path, "amd64", source.role, names, source.native.CompilerAliases)
+	if err != nil {
+		return err
+	}
+	for _, fn := range source.file.Funcs {
+		native := binding.resolve(fn.Sym)
+		sig, found := binding.options.Sigs[native]
+		if !found || !strings.HasSuffix(fn.Sym, "<ABIInternal>") || !amd64GoArgumentNeedsBinding(sig) {
+			continue
+		}
+		if sig.x86CallerRegions != nil || sig.x86FixedLocal != nil || sig.amd64GoArguments != nil || fn.FrameSize != 0 {
+			return amd64GoArgumentContext("argument carriers cannot borrow a caller/frame/native role")
+		}
+		declaration := entries[native]
+		actual, valid := pkg.Types.Scope().Lookup(declaration.local).(*types.Func)
+		if !valid || !declaration.entry || declaration.abi != 1 {
+			return amd64GoArgumentContext("argument carrier lacks its original typed entry declaration")
+		}
+		index := -1
+		for ordinal, text := range source.native.OriginalText {
+			if text.Name == native && text.ABI == 1 {
+				if index != -1 {
+					return amd64GoArgumentContext("repeated actual source TEXT")
+				}
+				index = ordinal
+			}
+		}
+		if index < 0 || index >= len(source.native.ExpandedText) {
+			return amd64GoArgumentContext("argument entry lacks complete original/expanded TEXT")
+		}
+		plan, err := amd64GoArgumentEntryPlan(amd64GoArgumentEntryInput{
+			Package: pkg.Types, Declaration: actual, Signature: sig, Native: native,
+			Target: source.request.Target, Goarch: source.guard.env["GOARCH"], GOAMD64: source.guard.env["GOAMD64"],
+			GOEXPERIMENT: source.guard.env["GOEXPERIMENT"], GOFLAGS: source.guard.env["GOFLAGS"],
+			SymABI: joined.Observation.Header.SymABI, Original: source.native.OriginalText[index], Expanded: source.native.ExpandedText[index],
+			Aliases: aliases, Standard: source.native.CompilerAliases[native].Standard,
+		})
+		if err != nil {
+			return err
+		}
+		entry := &amd64GoArgumentBinding{owner: binding, declaration: actual, symbol: fn.Sym, signature: sig, plan: plan}
+		entry.identity = entry
+		entry.seal, err = entry.digest()
+		if err != nil {
+			return err
+		}
+		sig.amd64GoArguments = entry
+		binding.options.Sigs[native] = sig
+	}
+	return nil
+}
diff --git a/go_x86_numerical_read_assembly_go127_test.go b/go_x86_numerical_read_assembly_go127_test.go
new file mode 100644
index 000000000..985cdd98d
--- /dev/null
+++ b/go_x86_numerical_read_assembly_go127_test.go
@@ -0,0 +1,289 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestGoX86NumericalAssemblyOriginalCompleteThreeOS(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			ctx, profile := sdkASMDataRequest(t, "amd64", "internal/bytealg")
+			profile.Target = target
+			goos, _, _ := strings.Cut(target, "/")
+			for index, pair := range profile.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					profile.Environment[index] = "GOOS=" + goos
+				}
+			}
+			metadata, err := CaptureGoX86SDKASMDataSource(ctx, profile)
+			if err != nil {
+				t.Fatal("complete selected SDK source/object precondition", err)
+			}
+			t.Cleanup(func() {
+				if err := metadata.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+				GoBinary: profile.GoBinary, Directory: filepath.Join(filepath.Dir(profile.Directory), "cpu"),
+				PackagePath: "internal/cpu", Target: target, Environment: profile.Environment, SDKCPU: true,
+				Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+			})
+			if err != nil {
+				t.Fatal("independent actual target CPU storage precondition", err)
+			}
+			t.Cleanup(owner.Close)
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+				GoBinary: profile.GoBinary, Directory: profile.Directory, PackagePath: profile.PackagePath,
+				AssemblyFile: "count_amd64.s", Target: target, Environment: profile.Environment,
+				AssemblySource: metadata, Owners: []*GoNumericalStorageOwner{owner},
+			})
+			if err != nil {
+				t.Fatal("actual target source/NUM original-node join", err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			if source.assembly == nil || source.literals != nil || len(source.file.Funcs) != 3 || len(source.reads) == 0 {
+				t.Fatal("complete original nodes were replaced by an initializer or cropped source")
+			}
+			for _, read := range source.reads {
+				if read.instruction < 0 || read.pc < 0 || read.variable.NativeName != "internal/cpu.X86" {
+					t.Fatal("original instruction/native storage association was lost", read)
+				}
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("whole selected source no longer authenticates its original nodes", err)
+			}
+		})
+	}
+}
+
+func numericalSDKAssemblyFixture(t *testing.T) (context.Context, GoX86NumericalReadCaptureRequest, *GoX86SDKASMDataSource, *GoNumericalStorageOwner) {
+	t.Helper()
+	ctx, request, owner := numericalSDKCPURequest(t, "amd64")
+	request.Directory = filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "bytealg")
+	request.PackagePath, request.AssemblyFile = "internal/bytealg", "count_amd64.s"
+	metadata, err := CaptureGoX86SDKASMDataSource(ctx, GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("actual whole SDK source/CPP/object precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := metadata.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	request.AssemblySource = metadata
+	return ctx, request, metadata, owner
+}
+
+func TestGoX86NumericalAssemblyOriginalMetadataRequestAndLifetime(t *testing.T) {
+	ctx, request, metadata, owner := numericalSDKAssemblyFixture(t)
+	for name, mutate := range map[string]func(*GoX86NumericalReadCaptureRequest){
+		"target":    func(r *GoX86NumericalReadCaptureRequest) { r.Target = "windows/amd64" },
+		"mode":      func(r *GoX86NumericalReadCaptureRequest) { r.Target = "linux/386" },
+		"tool":      func(r *GoX86NumericalReadCaptureRequest) { r.GoBinary += ".different" },
+		"directory": func(r *GoX86NumericalReadCaptureRequest) { r.Directory = filepath.Dir(r.Directory) },
+		"package":   func(r *GoX86NumericalReadCaptureRequest) { r.PackagePath = "internal/cpu" },
+		"environment": func(r *GoX86NumericalReadCaptureRequest) {
+			r.Environment = append(append([]string(nil), r.Environment...), "GOAMD64=v3")
+		},
+		"member": func(r *GoX86NumericalReadCaptureRequest) { r.AssemblyFile = "unselected_amd64.s" },
+		"copied source": func(r *GoX86NumericalReadCaptureRequest) {
+			copy := new(GoX86SDKASMDataSource)
+			reflect.ValueOf(copy).Elem().Set(reflect.ValueOf(metadata).Elem())
+			r.AssemblySource = copy
+		},
+		"manual source": func(r *GoX86NumericalReadCaptureRequest) { r.AssemblySource = &GoX86SDKASMDataSource{} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := request
+			mutate(&changed)
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, changed)
+			if source != nil {
+				t.Cleanup(func() { source.Close() })
+			}
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("another profile/member/public value borrowed original metadata", err)
+			}
+			if err := metadata.Verify(ctx); err != nil {
+				t.Fatal("request rejection revoked independent original metadata", err)
+			}
+		})
+	}
+	if source, err := CaptureGoX86NumericalReadSource(ctx, request); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		if source != nil {
+			t.Cleanup(func() { source.Close() })
+		}
+		t.Fatal("owned-main route inherited SDK metadata permission", err)
+	}
+	for _, borrowed := range []bool{false, true} {
+		source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+		if err != nil {
+			t.Fatal("actual metadata-only numerical source", err)
+		}
+		t.Cleanup(func() {
+			if err := source.Close(); err != nil {
+				t.Error(err)
+			}
+		})
+		if source.assembly == nil || source.literals != nil || source.assembly.source != metadata ||
+			len(source.file.Funcs) != 3 || len(source.file.Data)+len(source.file.Globl) != 0 {
+			t.Fatal("metadata-only route manufactured initializer/helper state or cropped source")
+		}
+		if !borrowed {
+			if err := source.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if err := metadata.Verify(ctx); err != nil {
+				t.Fatal("numerical Close closed its borrowed metadata", err)
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("numerical Close closed its independent storage owner", err)
+			}
+			continue
+		}
+		if err := metadata.Close(); err != nil {
+			t.Fatal(err)
+		}
+		if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+			t.Fatal("closed metadata revived a numerical original-node observation")
+		}
+		if err := owner.Verify(ctx); err != nil {
+			t.Fatal("metadata Close revoked independent numerical storage", err)
+		}
+	}
+}
+
+func TestGoX86NumericalAssemblyOriginalContextsCannotRevive(t *testing.T) {
+	for _, kind := range []string{"nil", "canceled", "deadline", "original canceled"} {
+		t.Run(kind, func(t *testing.T) {
+			ctx, request, metadata, owner := numericalSDKAssemblyFixture(t)
+			original, cancel := context.WithCancel(ctx)
+			defer cancel()
+			source, err := CaptureGoX86SDKNumericalReadSource(original, request)
+			if err != nil {
+				t.Fatal("actual joined source precondition", err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			var verify context.Context
+			want := ErrProbeNeedsContext
+			switch kind {
+			case "canceled":
+				var stop context.CancelFunc
+				verify, stop = context.WithCancel(ctx)
+				stop()
+				want = context.Canceled
+			case "deadline":
+				var stop context.CancelFunc
+				verify, stop = context.WithDeadline(ctx, time.Now().Add(-time.Second))
+				defer stop()
+				want = context.DeadlineExceeded
+			case "original canceled":
+				cancel()
+				verify, want = ctx, context.Canceled
+			}
+			if err := source.Verify(verify); !errors.Is(err, want) || want != ErrProbeNeedsContext && errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("joined source lost its genuine context cause", kind, err)
+			}
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("new context revived revoked numerical source")
+			}
+			if err := metadata.Verify(ctx); err != nil {
+				t.Fatal("consumer context revoked independent metadata", err)
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("consumer context revoked independent storage", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalAssemblyCallbacksRemainOutsideNumericalLock(t *testing.T) {
+	for _, route := range []string{"original", "verification"} {
+		for _, method := range []string{"Err", "Deadline", "Done"} {
+			t.Run(route+"/"+method, func(t *testing.T) {
+				ctx, request, metadata, owner := numericalSDKAssemblyFixture(t)
+				callback := &sdkASMDataReentrantContext{Context: ctx, method: method}
+				captureContext, verifyContext := ctx, ctx
+				if route == "original" {
+					captureContext = callback
+				} else {
+					verifyContext = callback
+				}
+				source, err := CaptureGoX86SDKNumericalReadSource(captureContext, request)
+				if err != nil {
+					t.Fatal("actual metadata join precondition", err)
+				}
+				defer closeNumericalConsumerSource(t, source)
+				called, locked := false, false
+				var nested error
+				callback.callback = func() {
+					called = true
+					if !source.mu.TryLock() {
+						locked = true
+						return
+					}
+					source.mu.Unlock()
+					nested = source.Close()
+				}
+				callback.armed.Store(true)
+				if err := source.Verify(verifyContext); !called || locked || nested != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("metadata join called user context under lock or published after Close", called, locked, nested, err)
+				}
+				if err := metadata.Verify(ctx); err != nil {
+					t.Fatal("reentrant Close disposed borrowed metadata", err)
+				}
+				if err := owner.Verify(ctx); err != nil {
+					t.Fatal("reentrant Close disposed independent numerical owner", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86NumericalAssemblyConcurrentVerifyCloseHasNoRevival(t *testing.T) {
+	ctx, request, metadata, owner := numericalSDKAssemblyFixture(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual metadata-only numerical join", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	var workers sync.WaitGroup
+	for index := 0; index < 2; index++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			if err := source.Verify(ctx); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Error(err)
+			}
+		}()
+	}
+	workers.Add(1)
+	go func() {
+		defer workers.Done()
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	workers.Wait()
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("concurrent Close revived numerical source")
+	}
+	if err := metadata.Verify(ctx); err != nil {
+		t.Fatal("concurrent Close revoked borrowed metadata", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("concurrent Close revoked independent storage", err)
+	}
+}
diff --git a/go_x86_numerical_read_binding.go b/go_x86_numerical_read_binding.go
new file mode 100644
index 000000000..117087365
--- /dev/null
+++ b/go_x86_numerical_read_binding.go
@@ -0,0 +1,757 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// GoX86NumericalReadBinding is a live factory token, not a serializable report.
+// Its capture context and every source/storage owner must remain live until
+// translation completes. Failure/Close revokes the originating source.
+type GoX86NumericalReadBinding struct {
+	originalBinding *GoX86NumericalReadBinding
+	source          *GoX86NumericalReadSource
+	originalSource  *GoX86NumericalReadSource
+	context         context.Context
+	originalContext context.Context
+	packageInput    GoPackage
+	originalTypes   *types.Package
+	originalImports map[string]*types.Package
+	file            [32]byte
+	options         Options
+	symbols         map[string]string
+	declarations    map[string]goAMD64FrameDeclaration
+	reads           []numericalSBReadFact
+	literalAccesses []x86SDKLiteralAccess
+	literalMinimum  *numericalSDKLiteralMinimumJoin
+	capabilities    map[string]numericalSignatureCapabilities
+	seal            [32]byte
+}
+
+type numericalSignatureCapabilities struct {
+	caller    *x86GoCallerRegionProof
+	local     *x86FixedLocalBinding
+	arguments *amd64GoArgumentBinding
+}
+
+func numericalCapabilities(sigs map[string]FuncSig) map[string]numericalSignatureCapabilities {
+	result := make(map[string]numericalSignatureCapabilities, len(sigs))
+	for name, sig := range sigs {
+		result[name] = numericalSignatureCapabilities{sig.x86CallerRegions, sig.x86FixedLocal, sig.amd64GoArguments}
+	}
+	return result
+}
+
+// BindNumericalReads joins complete caller declarations/options to the sealed
+// original source and actual native reads. It returns independent Options;
+// declarations alone, JSON, pointer types and a numerical owner cannot bind.
+func (source *GoX86NumericalReadSource) BindNumericalReads(ctx context.Context, pkg GoPackage, file *File, options Options) (Options, error) {
+	return source.bindNumericalReads(ctx, pkg, file, options, nil)
+}
+
+func (source *GoX86NumericalReadSource) bindNumericalReads(ctx context.Context, pkg GoPackage, file *File, options Options, minimum *GoX86SDKLiteralAlignment) (Options, error) {
+	if carrier := options.ARM64ByteCarrierSource; carrier != nil {
+		source.revokeNumericalSource()
+		carrier.revokeCarrier()
+		return Options{}, mixedNativeAuthorityContext()
+	}
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	if file == nil || options.ResolveSym == nil || pkg.Types == nil || pkg.Path != source.request.PackagePath || pkg.Types.Path() != pkg.Path || pkg.SourceSelection != nil {
+		return Options{}, numericalSBContext("binding lacks complete original declarations/source/resolver")
+	}
+	_, arch, _ := strings.Cut(source.request.Target, "/")
+	triple := numericalSDKTargetTriple(source.request.Target)
+	if options.Goarch != arch || options.TargetTriple != triple || options.WASMABI != WASMABIDirect || len(options.X86TailGroups) != 0 || options.NumericalReads != nil {
+		return Options{}, numericalSBContext("binding profile or existing authority differs")
+	}
+	provided, err := x86CallerSourceFingerprint(file)
+	if err != nil {
+		return Options{}, err
+	}
+	actual, err := x86CallerSourceFingerprint(source.file)
+	if err != nil || provided != actual {
+		return Options{}, numericalSBContext("binding requires the exact complete original parsed file")
+	}
+	if source.role == numericalSBSDKSource {
+		names, err := numericalGoDeclarationLinknames(pkg.Syntax, pkg.Types)
+		if err != nil {
+			return Options{}, err
+		}
+		entries, _, err := numericalTypedSourceDeclarations(file, pkg.Path, arch, source.role, names, source.native.CompilerAliases)
+		if err != nil || len(entries) != len(options.Sigs) {
+			return Options{}, numericalSBContext("binding typed entry/terminal inventory differs: %v", err)
+		}
+	} else if len(file.Funcs) != len(options.Sigs) {
+		return Options{}, numericalSBContext("binding ordinary declaration inventory differs")
+	}
+	// Resolve outside observer locks, then verify the complete live source again.
+	symbols := make(map[string]string)
+	for index, fn := range file.Funcs {
+		symbols[fn.Sym] = options.ResolveSym(fn.Sym)
+		name, _, valid := source.numericalSourceTextIdentity(index, fn, arch)
+		if strings.HasSuffix(fn.Sym, "<>") && valid {
+			name = numericalNativeName(fn.Sym, pkg.Path)
+			if _, fake := options.Sigs[name]; fake {
+				return Options{}, numericalSBContext("private continuation cannot acquire a callable signature")
+			}
+		}
+		if !valid || symbols[fn.Sym] != name {
+			return Options{}, numericalSBContext("function resolver differs from actual original source/object ABI symbol")
+		}
+		logical := goTextSymbolForResolution(fn.Sym)
+		if options.ResolveSym(logical) != name || symbols[logical] != "" && symbols[logical] != name {
+			return Options{}, numericalSBContext("logical declaration resolver differs from its exact source/native entry")
+		}
+		symbols[logical] = name
+	}
+	tailRoles, err := numericalDirectTailRoles(file)
+	if err != nil {
+		return Options{}, err
+	}
+	for _, symbol := range tailRoles {
+		name := numericalNativeName(symbol, pkg.Path)
+		if options.ResolveSym(symbol) != name {
+			return Options{}, numericalSBContext("continuation/terminal resolver changed exact source identity")
+		}
+		symbols[symbol] = name
+	}
+	for _, read := range source.reads {
+		base, _, valid := parseSBRef(read.original.Args[read.operand].Sym)
+		if !valid || options.ResolveSym(base) != read.variable.NativeName {
+			return Options{}, numericalSBContext("storage resolver differs from actual typed data symbol")
+		}
+		symbols[base] = read.variable.NativeName
+		if _, collision := options.Sigs[read.variable.NativeName]; collision {
+			return Options{}, numericalSBContext("typed data symbol collides with a function")
+		}
+	}
+	if source.literals != nil {
+		if err := source.bindSDKLiteralSymbols(file, options, symbols); err != nil {
+			return Options{}, err
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	provided, err = x86CallerSourceFingerprint(file)
+	if err != nil || provided != actual {
+		return Options{}, numericalSBContext("binding resolver changed the complete original file")
+	}
+	declarationContext, stop, err := source.numericalDeclarationContext(ctx)
+	if err != nil {
+		return Options{}, err
+	}
+	defer stop()
+	source.mu.Lock()
+	declarations, err := source.numericalDeclarations(declarationContext, pkg, arch)
+	if err == nil {
+		err = numericalDeclarationSyntax(source, pkg)
+	}
+	source.mu.Unlock()
+	if err != nil {
+		return Options{}, err
+	}
+	sigs, err := numericalCloneSignatures(options.Sigs)
+	if err != nil {
+		return Options{}, err
+	}
+	for name, sig := range sigs {
+		declaration, found := declarations[name]
+		if !found || sig.amd64GoArguments != nil || sig.arm64FPReadDeclaration != nil || sig.arm64ABI0Declaration != nil || sig.arm64ABI0TailDeclaration != nil || sig.arm64NativeScratch != nil ||
+			!reflect.DeepEqual(numericalSignatureShape(sig), declaration.signature) {
+			return Options{}, numericalSBContext("signature is not the actual source declaration: %s", name)
+		}
+		if local := sig.x86FixedLocal; local != nil {
+			original := local.numericalReads
+			if original == nil || original.source != source || original.context != ctx ||
+				original.originalTypes != pkg.Types || !numericalSameImports(pkg.Imports, original.originalImports) ||
+				local.file != actual || local.target != triple || local.context != ctx {
+				return Options{}, numericalSBContext("local capability has a foreign numerical source/declaration generation")
+			}
+			if err := local.verify(); err != nil {
+				return Options{}, err
+			}
+		}
+	}
+	joinedMinimum, err := captureNumericalSDKLiteralMinimum(ctx, source, minimum)
+	if err != nil {
+		return Options{}, err
+	}
+	literalAccesses, err := source.bindSDKLiteralAccessesAtMinimum(file, sigs, symbols, arch, joinedMinimum)
+	if err != nil {
+		return Options{}, err
+	}
+	options.Sigs, options.ResolveSym = sigs, nil
+	binding := &GoX86NumericalReadBinding{source: source, originalSource: source, context: ctx, originalContext: ctx, packageInput: pkg,
+		originalTypes: pkg.Types, originalImports: numericalImportIdentities(pkg.Imports), file: actual,
+		options: options, symbols: symbols, declarations: declarations, reads: source.readFacts(), literalAccesses: literalAccesses,
+		capabilities: numericalCapabilities(sigs), literalMinimum: joinedMinimum}
+	binding.originalBinding = binding
+	if err := binding.bindAMD64GoArguments(); err != nil {
+		return Options{}, err
+	}
+	binding.capabilities = numericalCapabilities(binding.options.Sigs)
+	binding.seal, err = binding.digest()
+	if err != nil {
+		return Options{}, err
+	}
+	if err := binding.verify(); err != nil {
+		return Options{}, err
+	}
+	bound := options
+	bound.Sigs, err = numericalCloneSignatures(options.Sigs)
+	if err != nil {
+		return Options{}, err
+	}
+	bound.ResolveSym = binding.resolve
+	bound.NumericalReads = binding
+	return bound, nil
+}
+
+func numericalImportIdentities(imports map[string]*types.Package) map[string]*types.Package {
+	if imports == nil {
+		return nil
+	}
+	identities := make(map[string]*types.Package, len(imports))
+	for name, pkg := range imports {
+		identities[name] = pkg
+	}
+	return identities
+}
+
+func numericalSameImports(imports, expected map[string]*types.Package) bool {
+	if (imports == nil) != (expected == nil) || len(imports) != len(expected) {
+		return false
+	}
+	for name, pkg := range imports {
+		if original, found := expected[name]; !found || pkg != original {
+			return false
+		}
+	}
+	return true
+}
+
+func numericalSignatureShape(sig FuncSig) FuncSig {
+	sig.x86CallerRegions, sig.x86FixedLocal = nil, nil
+	sig.amd64GoArguments = nil
+	sig.arm64FPReadDeclaration, sig.arm64ABI0Declaration, sig.arm64ABI0TailDeclaration, sig.arm64NativeScratch = nil, nil, nil, nil
+	return sig
+}
+
+func numericalCloneSignatures(input map[string]FuncSig) (map[string]FuncSig, error) {
+	result, err := cloneFixedLocalSigs(input)
+	if err != nil {
+		return nil, err
+	}
+	// Preserve separately established private contracts, not reconstructed JSON.
+	for name, old := range input {
+		sig := result[name]
+		sig.x86CallerRegions, sig.x86FixedLocal = old.x86CallerRegions, old.x86FixedLocal
+		sig.arm64FPReadDeclaration, sig.arm64ABI0Declaration, sig.arm64ABI0TailDeclaration, sig.arm64NativeScratch = old.arm64FPReadDeclaration, old.arm64ABI0Declaration, old.arm64ABI0TailDeclaration, old.arm64NativeScratch
+		sig.x86BorrowedBoolTail = old.x86BorrowedBoolTail
+		sig.amd64GoArguments = old.amd64GoArguments
+		result[name] = sig
+	}
+	return result, nil
+}
+
+func numericalDeclarationSyntax(source *GoX86NumericalReadSource, pkg GoPackage) error {
+	if len(pkg.Syntax) != len(source.guard.selection.GoFiles) {
+		return numericalSBContext("declaration syntax inventory differs")
+	}
+	wanted := make(map[string]int)
+	for _, name := range source.guard.selection.GoFiles {
+		data, err := source.guard.read(filepath.Join(source.request.Directory, name))
+		if err != nil {
+			return err
+		}
+		actual, err := parser.ParseFile(token.NewFileSet(), name, data, parser.ParseComments)
+		if err != nil {
+			return numericalSBContext("declaration syntax is missing or unparseable")
+		}
+		var a bytes.Buffer
+		if format.Node(&a, token.NewFileSet(), actual) != nil {
+			return numericalSBContext("original declaration syntax cannot be formatted")
+		}
+		wanted[a.String()]++
+	}
+	// File order and absolute token.Pos bases are not declaration semantics.
+	// Compare the complete multiset, including comments/directives and bodies.
+	for _, supplied := range pkg.Syntax {
+		var b bytes.Buffer
+		if supplied == nil || format.Node(&b, token.NewFileSet(), supplied) != nil || wanted[b.String()] == 0 {
+			return numericalSBContext("supplied complete declaration syntax differs from original source")
+		}
+		wanted[b.String()]--
+	}
+	return nil
+}
+
+func (binding *GoX86NumericalReadBinding) resolve(symbol string) string {
+	if name, found := binding.symbols[symbol]; found {
+		return name
+	}
+	return symbol // No address/call role is created for unknown symbols.
+}
+
+func (binding *GoX86NumericalReadBinding) digest() ([32]byte, error) {
+	arguments := make(map[string][32]byte)
+	for name, sig := range binding.options.Sigs {
+		if entry := sig.amd64GoArguments; entry != nil {
+			digest, err := entry.digest()
+			if err != nil {
+				return [32]byte{}, err
+			}
+			arguments[name] = digest
+		}
+	}
+	data, err := json.Marshal(struct {
+		File         [32]byte
+		Target, Arch string
+		WASM         WASMABI
+		X87          X87Mode
+		Annotate     bool
+		Sigs         map[string]FuncSig
+		TailGroups   []X86TailGroup
+		Symbols      map[string]string
+		Reads        []numericalSBReadFact
+		Literals     []x86SDKLiteralAccess
+		Minimum      *numericalSDKLiteralMinimumJoin
+		Arguments    map[string][32]byte
+	}{binding.file, binding.options.TargetTriple, binding.options.Goarch, binding.options.WASMABI, binding.options.X87Mode,
+		binding.options.AnnotateSource, binding.options.Sigs, binding.options.X86TailGroups, binding.symbols, binding.reads, binding.literalAccesses, binding.literalMinimum, arguments})
+	return sha256.Sum256(data), err
+}
+
+func (binding *GoX86NumericalReadBinding) verify() error {
+	if binding == nil || binding.source == nil || binding.source != binding.originalSource {
+		return numericalSBContext("missing live factory binding")
+	}
+	fail := func(err error) error {
+		binding.source.mu.Lock()
+		binding.source.ready = false
+		binding.source.mu.Unlock()
+		return err
+	}
+	if binding.originalBinding != binding {
+		return fail(numericalSBContext("copied or foreign numerical binding is not the original factory token"))
+	}
+	if err := rejectMixedNativeAuthorities(binding, binding.options.ARM64ByteCarrierSource); err != nil {
+		return err
+	}
+	if binding.context == nil || reflect.TypeOf(binding.context) != reflect.TypeOf(binding.originalContext) ||
+		!reflect.TypeOf(binding.context).Comparable() || binding.context != binding.originalContext {
+		return fail(numericalSBContext("binding live context identity changed"))
+	}
+	if binding.packageInput.Types == nil || binding.packageInput.Types != binding.originalTypes ||
+		binding.packageInput.SourceSelection != nil || !numericalSameImports(binding.packageInput.Imports, binding.originalImports) {
+		return fail(numericalSBContext("binding private declaration/import identity changed"))
+	}
+	if err := binding.source.Verify(binding.context); err != nil {
+		return err
+	}
+	if binding.literalMinimum != nil {
+		if err := binding.literalMinimum.verify(binding.context, binding.source); err != nil {
+			return fail(err)
+		}
+	}
+	sum, err := binding.digest()
+	if err != nil || sum != binding.seal || !numericalSameCapabilities(binding.options.Sigs, binding.capabilities) {
+		return fail(numericalSBContext("private binding shape changed"))
+	}
+	for _, sig := range binding.options.Sigs {
+		if entry := sig.amd64GoArguments; entry != nil {
+			matches := 0
+			for _, fn := range binding.source.file.Funcs {
+				if fn.Sym == entry.symbol && entry.valid(fn, sig, binding.options.Goarch) {
+					matches++
+				}
+			}
+			if matches != 1 {
+				return fail(amd64GoArgumentContext("binding lost its unique live original typed argument entry"))
+			}
+		}
+	}
+	declarationContext, stop, err := binding.source.numericalDeclarationContext(binding.context)
+	if err != nil {
+		return fail(err)
+	}
+	defer stop()
+	binding.source.mu.Lock()
+	declarations, err := binding.source.numericalDeclarations(declarationContext, binding.packageInput, binding.options.Goarch)
+	if err == nil {
+		err = numericalDeclarationSyntax(binding.source, binding.packageInput)
+	}
+	valid := binding.source.ready && reflect.DeepEqual(binding.declarations, declarations) && reflect.DeepEqual(binding.reads, binding.source.readFacts())
+	binding.source.mu.Unlock()
+	if err != nil {
+		return fail(err)
+	}
+	if !valid {
+		return fail(numericalSBContext("declaration/source/owner read join changed"))
+	}
+	return binding.source.Verify(binding.context)
+}
+
+// Imports are obtained only from the same live, already authenticated owner
+// selections. A temporary typecheck guard cannot add new files to the original
+// source seal or treat the CPU's assembly namespace as a Go import certificate.
+func (source *GoX86NumericalReadSource) numericalDeclarations(ctx context.Context, pkg GoPackage, arch string) (map[string]goAMD64FrameDeclaration, error) {
+	// This is only an independent declaration query. Do not copy the mutex,
+	// ready generation, artifact owner, Frame token or private factory fields.
+	guard := &GoAMD64FrameSource{request: source.guard.request, selection: source.guard.selection,
+		env: source.guard.env, inputs: make(map[string][32]byte), imports: make(map[string]goAMD64FrameSelection)}
+	if source.role == numericalSBSDKSource {
+		for path, dependency := range source.guard.imports {
+			guard.imports[path] = dependency
+		}
+	}
+	for _, owner := range source.originalOwners {
+		if source.sdkAssemblyJoin() != nil {
+			// Joined SDK capture accepts only independent SDK CPU owners.
+			// Its complete declaration graph is the separately sealed SDK graph;
+			// owner callbacks run before/after, never under source.mu here.
+			continue
+		}
+		report, err := owner.observation.Readback(ctx)
+		if err != nil {
+			return nil, numericalStorageFailure(ctx, "declaration owner readback", err)
+		}
+		if report.Protocol == gostaticstorage.SDKCPUProtocol || report.Protocol == gostaticstorage.SDKGlobalsProtocol {
+			continue
+		}
+		decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+		for decoder.More() {
+			var dependency goAMD64FrameSelection
+			if err := decoder.Decode(&dependency); err != nil {
+				return nil, err
+			}
+			if dependency.Export != "" {
+				guard.imports[dependency.ImportPath] = dependency
+			}
+		}
+	}
+	var entries map[string]numericalSourceDeclaration
+	var terminals map[string]numericalSourceDeclaration
+	var localEntries map[string]bool
+	foreignEntry := false
+	if source.role == numericalSBSDKSource {
+		names, err := numericalGoDeclarationLinknames(pkg.Syntax, pkg.Types)
+		if err != nil {
+			return nil, err
+		}
+		entries, terminals, err = numericalTypedSourceDeclarations(source.file, pkg.Path, arch, source.role, names, source.native.CompilerAliases)
+		if err != nil {
+			return nil, err
+		}
+		localEntries = make(map[string]bool, len(entries))
+		for name, declaration := range entries {
+			localEntries[declaration.local] = true
+			foreignEntry = foreignEntry || name != gosym.PackagePrefix(pkg.Path)+"."+declaration.local
+		}
+	}
+	if source.sdkAssemblyJoin() != nil && (foreignEntry || x86DirectTailSourceNeeded(source.file) || len(source.native.ArgumentRules) != 0) {
+		return source.numericalSDKOrdinaryTailDeclarations(ctx, pkg, arch, entries)
+	}
+	declarations, err := guard.typedNumericalDeclarationsForArchRole(pkg, arch, source.role == numericalSBSDKSource, localEntries)
+	if err != nil {
+		return nil, err
+	}
+	ordinary, err := source.numericalSDKOrdinaryTailDeclarations(ctx, pkg, arch, terminals)
+	if err != nil {
+		return nil, err
+	}
+	for name, declaration := range ordinary {
+		if _, present := declarations[name]; !present {
+			declarations[name] = declaration
+		}
+	}
+	return declarations, nil
+}
+
+type x86NumericalReadCertificate struct {
+	binding     *GoX86NumericalReadBinding
+	read        int
+	instruction [32]byte
+}
+
+func verifyNumericalReadInputs(file *File, options Options) (result error) {
+	for _, sig := range options.Sigs {
+		if entry := sig.amd64GoArguments; entry != nil && entry.virtual != nil {
+			if entry.owner != nil || entry.virtual.entries[sig.Name] != entry || entry.virtual.live() != nil {
+				return amd64GoArgumentContext("virtual arguments require their live GoModule call")
+			}
+			continue
+		}
+		if entry := sig.amd64GoArguments; entry != nil && (options.NumericalReads == nil || entry.owner != options.NumericalReads) {
+			return amd64GoArgumentContext("typed arguments require their complete live source binding")
+		}
+	}
+	if err := rejectMixedNativeAuthorities(options.NumericalReads, options.ARM64ByteCarrierSource); err != nil {
+		return err
+	}
+	binding := options.NumericalReads
+	if binding == nil {
+		return nil
+	}
+	defer func() {
+		if result != nil && binding.source != nil {
+			binding.source.mu.Lock()
+			binding.source.ready = false
+			binding.source.mu.Unlock()
+		}
+	}()
+	if err := binding.verify(); err != nil {
+		return err
+	}
+	check := func() error {
+		if file == nil || options.ResolveSym == nil {
+			return numericalSBContext("consumer lost complete source/resolver")
+		}
+		shape := options
+		shape.ResolveSym, shape.NumericalReads = nil, nil
+		fingerprint, err := x86CallerSourceFingerprint(file)
+		if err != nil || fingerprint != binding.file || !reflect.DeepEqual(shape, binding.options) || !numericalSameCapabilities(options.Sigs, binding.capabilities) {
+			return numericalSBContext("consumer original file/declarations/options changed")
+		}
+		return nil
+	}
+	if err := check(); err != nil {
+		return err
+	}
+	for symbol, expected := range binding.symbols {
+		if options.ResolveSym(symbol) != expected {
+			return numericalSBContext("consumer resolver changed exact storage/function identity")
+		}
+	}
+	if err := check(); err != nil {
+		return err
+	}
+	return binding.verify() // Resolver callbacks cannot mutate a live source/owner.
+}
+
+func freezeNumericalReadInputs(file *File, options Options) (*File, Options, error) {
+	if err := verifyNumericalReadInputs(file, options); err != nil {
+		return nil, Options{}, err
+	}
+	binding := options.NumericalReads
+	if binding == nil {
+		return file, options, nil
+	}
+	encoded, err := json.Marshal(file)
+	if err != nil {
+		return nil, Options{}, err
+	}
+	var frozen File
+	if err := json.Unmarshal(encoded, &frozen); err != nil {
+		return nil, Options{}, err
+	}
+	options = binding.options
+	options.Sigs, err = numericalCloneSignatures(binding.options.Sigs)
+	if err != nil {
+		return nil, Options{}, err
+	}
+	options.ResolveSym, options.NumericalReads = binding.resolve, binding
+	if err := joinNumericalReadCertificates(&frozen, options); err != nil {
+		return nil, Options{}, err
+	}
+	if err := preserveX86DirectTailNumericalGraph(file, &frozen, options); err != nil {
+		return nil, Options{}, err
+	}
+	return &frozen, options, nil
+}
+
+// Join only an independently parsed complete sealed source. Reparse intentionally
+// drops all private certificates; neither a copied Instr nor its spelling can
+// supply the original source/ordinal/native-read identity.
+func joinNumericalReadCertificates(file *File, options Options) error {
+	binding := options.NumericalReads
+	if binding == nil {
+		return nil
+	}
+	fingerprint, err := x86CallerSourceFingerprint(file)
+	if err != nil || fingerprint != binding.file {
+		return numericalSBContext("numerical certificate join requires the whole sealed source")
+	}
+	for i, read := range binding.reads {
+		matches := 0
+		for f := range file.Funcs {
+			fn := &file.Funcs[f]
+			if binding.resolve(fn.Sym) != read.Function || read.Instruction < 0 || read.Instruction >= len(fn.Instrs) {
+				continue
+			}
+			ins := &fn.Instrs[read.Instruction]
+			if !reflect.DeepEqual(*ins, read.Original) || ins.x86NumericalRead != nil {
+				return numericalSBContext("original read ordinal/instruction differs")
+			}
+			digest, err := fixedLocalInstructionDigest(*ins)
+			if err != nil {
+				return err
+			}
+			ins.x86NumericalRead = &x86NumericalReadCertificate{binding, i, digest}
+			matches++
+		}
+		if matches != 1 {
+			return numericalSBContext("original read has no unique complete source function")
+		}
+	}
+	if err := joinSDKLiteralCertificates(file, binding); err != nil {
+		return err
+	}
+	return verifyNormalizedNumericalReads(file, options)
+}
+
+func numericalCertifiedRead(ins Instr, arch string) (numericalSBReadFact, x86NumericalSBReadForm, bool) {
+	cert := ins.x86NumericalRead
+	if cert == nil || cert.binding == nil || cert.binding.source == nil || cert.binding.source.revoked.Load() || cert.read < 0 || cert.read >= len(cert.binding.reads) || arch != cert.binding.options.Goarch {
+		return numericalSBReadFact{}, x86NumericalSBReadForm{}, false
+	}
+	read := cert.binding.reads[cert.read]
+	digest, err := fixedLocalInstructionDigest(ins)
+	form, valid := x86NumericalSBReadProperties(ins, arch)
+	if err != nil || digest != cert.instruction || !valid || form.operand != read.Operand || form.spec.sourceBytes != read.Width || !numericalOwnerContains(read.Variable, read.Offset, read.Width) {
+		return numericalSBReadFact{}, x86NumericalSBReadForm{}, false
+	}
+	return read, form, true
+}
+
+func verifyNormalizedNumericalReads(file *File, options Options) error {
+	if options.NumericalReads == nil {
+		return nil
+	}
+	seen := make(map[int]bool)
+	for _, fn := range file.Funcs {
+		for ordinal, ins := range fn.Instrs {
+			if ins.x86NumericalRead == nil {
+				continue
+			}
+			cert := ins.x86NumericalRead
+			read, _, valid := numericalCertifiedRead(ins, options.Goarch)
+			if !valid || cert.binding != options.NumericalReads || seen[cert.read] || options.ResolveSym(fn.Sym) != read.Function || ordinal != read.Instruction {
+				return numericalSBContext("normalized function/ordinal/operand/native read identity changed")
+			}
+			seen[cert.read] = true
+		}
+	}
+	if len(seen) != len(options.NumericalReads.reads) {
+		return numericalSBContext("normalized read inventory changed or storage collides with local data")
+	}
+	if err := verifyNormalizedSDKLiteralAccesses(file, options); err != nil {
+		return err
+	}
+	if source := options.NumericalReads.source; source.literals != nil {
+		return source.literals.verifyFile(file, source.request.PackagePath)
+	}
+	if len(file.Data)+len(file.Globl) != 0 {
+		return numericalSBContext("normalized read inventory changed or storage collides with local data")
+	}
+	return nil
+}
+
+func numericalSameCapabilities(sigs map[string]FuncSig, expected map[string]numericalSignatureCapabilities) bool {
+	if len(sigs) != len(expected) {
+		return false
+	}
+	for name, sig := range sigs {
+		cap, found := expected[name]
+		if !found || sig.x86CallerRegions != cap.caller || sig.x86FixedLocal != cap.local || sig.amd64GoArguments != cap.arguments {
+			return false
+		}
+	}
+	return true
+}
+
+func finishNumericalReads(file *File, options Options) error {
+	if err := verifyNumericalReadInputs(file, options); err != nil {
+		return fmt.Errorf("numerical read post-consumption guard: %w", err)
+	}
+	return nil
+}
+
+func verifyGoNumericalReadInputs(binding *GoX86NumericalReadBinding, pkg GoPackage, opt GoModuleOptions) (result error) {
+	if err := rejectMixedNativeAuthorities(binding, opt.ARM64ByteCarrierSource); err != nil {
+		return err
+	}
+	defer func() {
+		if result != nil && binding != nil && binding.source != nil {
+			binding.source.mu.Lock()
+			binding.source.ready = false
+			binding.source.mu.Unlock()
+		}
+	}()
+	if err := binding.verify(); err != nil {
+		return err
+	}
+	if pkg.Path != binding.packageInput.Path || pkg.Types != binding.originalTypes || pkg.SourceSelection != nil ||
+		!numericalSameImports(pkg.Imports, binding.originalImports) ||
+		opt.GOOS+"/"+opt.GOARCH != binding.source.request.Target || opt.GOARCH != binding.options.Goarch || opt.TargetTriple != binding.options.TargetTriple ||
+		opt.WASMABI != binding.options.WASMABI || opt.X87Mode != binding.options.X87Mode || opt.AnnotateSource != binding.options.AnnotateSource ||
+		opt.Sizes != nil || opt.FrameSizes != nil ||
+		opt.ResolveSym == nil || opt.KeepFunc != nil || opt.ManualSig != nil || len(opt.ARM64ClosureABIs) != 0 ||
+		opt.FileName != binding.source.request.AssemblyFile && opt.FileName != filepath.Join(binding.source.request.Directory, binding.source.request.AssemblyFile) {
+		return numericalSBContext("Go wrapper declaration/profile/source role differs")
+	}
+	binding.source.mu.Lock()
+	err := numericalDeclarationSyntax(binding.source, pkg)
+	binding.source.mu.Unlock()
+	if err != nil {
+		return err
+	}
+	for symbol, expected := range binding.symbols {
+		if opt.ResolveSym(symbol) != expected {
+			return numericalSBContext("Go wrapper resolver changed exact source/storage identity")
+		}
+	}
+	return binding.verify()
+}
+
+func numericalGoSignatures(binding *GoX86NumericalReadBinding, supplied map[string]FuncSig) (map[string]FuncSig, error) {
+	if len(supplied) != len(binding.options.Sigs) {
+		return nil, numericalSBContext("Go wrapper signature inventory differs from sealed declarations")
+	}
+	for name, signature := range supplied {
+		original, found := binding.options.Sigs[name]
+		if !found || !reflect.DeepEqual(numericalSignatureShape(signature), numericalSignatureShape(original)) {
+			return nil, numericalSBContext("Go wrapper signature differs from sealed original declaration")
+		}
+	}
+	// Only the opaque factory transports separately verified private contracts;
+	// a ManualSig callback or a new source selection cannot recreate them.
+	return numericalCloneSignatures(binding.options.Sigs)
+}
+
+// Original caller bytes and sealed CPP are different roles. Only this exact
+// selected raw source may consume the already independently assembled CPP;
+// equal parsed instructions cannot substitute another source or header set.
+func numericalGoAssemblyInput(binding *GoX86NumericalReadBinding, input []byte) (string, error) {
+	if binding == nil || binding.source == nil || binding.originalBinding != binding {
+		return "", numericalSBContext("Go wrapper has no original numerical source token")
+	}
+	source := binding.source
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	name := filepath.Join(source.request.Directory, source.request.AssemblyFile)
+	original, retained := source.native.Sources[name]
+	expected, selected := source.guard.inputs[name]
+	if !source.ready || source.revoked.Load() || source.identity != source || !retained || !selected ||
+		sha256.Sum256(original) != expected || !bytes.Equal(input, original) {
+		source.ready = false
+		return "", numericalSBContext("Go wrapper original selected ASM bytes changed")
+	}
+	return source.cpp.Output, nil
+}
diff --git a/go_x86_numerical_read_cause_test.go b/go_x86_numerical_read_cause_test.go
new file mode 100644
index 000000000..f8e09369f
--- /dev/null
+++ b/go_x86_numerical_read_cause_test.go
@@ -0,0 +1,64 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestGoX86NumericalSBReadCaptureCancellationCause(t *testing.T) {
+	for _, sdkCPU := range []bool{false, true} {
+		for _, cause := range []error{context.Canceled, context.DeadlineExceeded} {
+			t.Run(cause.Error()+map[bool]string{false: "/ordinary", true: "/SDK"}[sdkCPU], func(t *testing.T) {
+				var ctx context.Context
+				var cancel context.CancelFunc
+				if cause == context.Canceled {
+					ctx, cancel = context.WithCancel(context.Background())
+					cancel()
+				} else {
+					ctx, cancel = context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
+					defer cancel()
+				}
+				owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{SDKCPU: sdkCPU})
+				if owner != nil || !errors.Is(err, cause) || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("cancelled infrastructure lost its cause or became source Context: owner=%v error=%v", owner, err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86NumericalSBReadSourceCancellationCauseAndPermanentRevocation(t *testing.T) {
+	_, _, _, create := numericalConsumerFactory(t, "amd64")
+	for _, cause := range []error{context.Canceled, context.DeadlineExceeded} {
+		t.Run(cause.Error(), func(t *testing.T) {
+			source, options := create(t)
+			var invalid context.Context
+			var cancel context.CancelFunc
+			if cause == context.Canceled {
+				invalid, cancel = context.WithCancel(options.NumericalReads.context)
+				cancel()
+			} else {
+				invalid, cancel = context.WithDeadline(options.NumericalReads.context, time.Now().Add(-time.Second))
+				defer cancel()
+			}
+			t.Run("capture", func(t *testing.T) {
+				result, err := CaptureGoX86NumericalReadSource(invalid, source.request)
+				if result != nil || !errors.Is(err, cause) || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("cancelled source capture was classified as a proof exclusion", cause, err)
+				}
+			})
+			t.Run("verify", func(t *testing.T) {
+				if err := source.Verify(invalid); !errors.Is(err, cause) || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("cancelled verification lost its infrastructure cause", cause, err)
+				}
+				if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+					t.Fatal("fresh context revived a source after failed verification")
+				}
+			})
+		})
+	}
+}
diff --git a/go_x86_numerical_read_compiler_alias.go b/go_x86_numerical_read_compiler_alias.go
new file mode 100644
index 000000000..1998d2c96
--- /dev/null
+++ b/go_x86_numerical_read_compiler_alias.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"bytes"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This is a private comparison model, not a source, declaration or ABI token.
+// The live numerical factory must obtain both inventories from its existing
+// complete SDK producer before a declaration may consume the comparison.
+type numericalCompilerAliasInput struct {
+	Native    string
+	ABI       uint16
+	Standard  bool
+	SymABI    []byte
+	Generated []gostaticstorage.TextRecord
+	Selected  []gostaticstorage.TextRecord
+}
+
+func numericalCompilerAliasAssociation(input numericalCompilerAliasInput) error {
+	index, err := numericalCompilerAliasIndex(input.SymABI, input.Generated, input.Selected)
+	if err != nil {
+		return err
+	}
+	return index.association(input.Native, input.ABI, input.Standard)
+}
+
+type numericalCompilerAliasDirectory struct {
+	definitions map[string]uint16
+	generated   map[string][]gostaticstorage.TextRecord
+	selected    map[string][]gostaticstorage.TextRecord
+}
+
+// Index the complete retained inventories once. The live capture reuses this
+// directory for all original TEXTs rather than rescanning SymABI per symbol.
+func numericalCompilerAliasIndex(symABI []byte, generated, selected []gostaticstorage.TextRecord) (*numericalCompilerAliasDirectory, error) {
+	if len(symABI) == 0 || len(symABI) > 16<<20 || len(generated) == 0 || len(selected) == 0 ||
+		len(generated) > gostaticstorage.ObjectSymbolInventoryLimit || len(selected) > gostaticstorage.ObjectSymbolInventoryLimit {
+		return nil, numericalSBContext("foreign declaration lacks its complete compiler objects/SymABI")
+	}
+	result := &numericalCompilerAliasDirectory{definitions: make(map[string]uint16),
+		generated: make(map[string][]gostaticstorage.TextRecord), selected: make(map[string][]gostaticstorage.TextRecord)}
+	for _, line := range strings.Split(string(symABI), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) != 3 || fields[0] != "def" && fields[0] != "ref" ||
+			fields[2] != "ABI0" && fields[2] != "ABIInternal" {
+			return nil, numericalSBContext("compiler SymABI has an unregistered complete row")
+		}
+		if fields[0] == "def" {
+			if _, duplicate := result.definitions[fields[1]]; duplicate {
+				return nil, numericalSBContext("compiler SymABI repeats its native definition")
+			}
+			abi := uint16(0)
+			if fields[2] == "ABIInternal" {
+				abi = 1
+			}
+			result.definitions[fields[1]] = abi
+		}
+	}
+	for _, member := range []struct {
+		texts []gostaticstorage.TextRecord
+		index map[string][]gostaticstorage.TextRecord
+	}{{generated, result.generated}, {selected, result.selected}} {
+		for _, text := range member.texts {
+			member.index[text.Name] = append(member.index[text.Name], text)
+		}
+	}
+	return result, nil
+}
+
+func (index *numericalCompilerAliasDirectory) association(native string, abi uint16, standard bool) error {
+	fail := func() error {
+		return numericalSBContext("foreign declaration/compiler wrapper/native ABI association differs")
+	}
+	if index == nil || native == "" || len(native) > 4096 || strings.ContainsAny(native, "\x00\r\n\t ") || abi != 1 {
+		return fail()
+	}
+	if observed, found := index.definitions[native]; !found || observed != abi {
+		return fail()
+	}
+	flag := uint8(16) // The separately authenticated Go1.27 Flag2 schema.
+	if standard {
+		flag = 32
+	}
+	wrapper := func(records []gostaticstorage.TextRecord) (gostaticstorage.TextRecord, bool) {
+		var result gostaticstorage.TextRecord
+		found := false
+		for _, record := range records {
+			if record.ABI != 0 {
+				continue
+			}
+			if found || record.Name != native || record.Namespace != gostaticstorage.TextSymbolNonpkgDefinition ||
+				record.Kind != 1 || record.Flags2 != flag|64 || record.Size <= 0 || record.Size != int64(len(record.Code)) {
+				return result, false
+			}
+			result, found = record, true
+		}
+		return result, found
+	}
+	first, firstOK := wrapper(index.generated[native])
+	second, secondOK := wrapper(index.selected[native])
+	if !firstOK || !secondOK || first.Flags != second.Flags || first.Flags2 != second.Flags2 ||
+		first.Size != second.Size || !bytes.Equal(first.Code, second.Code) || !reflect.DeepEqual(first.Relocations, second.Relocations) {
+		return fail()
+	}
+	refs := 0
+	for _, relocation := range first.Relocations {
+		if relocation.Target.Name == native {
+			if !relocation.Target.ABIKnown || relocation.Target.ABI != abi {
+				return fail()
+			}
+			refs++
+		}
+	}
+	if refs != 1 {
+		return fail()
+	}
+	return nil
+}
diff --git a/go_x86_numerical_read_compiler_alias_capture.go b/go_x86_numerical_read_compiler_alias_capture.go
new file mode 100644
index 000000000..a4a8393b1
--- /dev/null
+++ b/go_x86_numerical_read_compiler_alias_capture.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// These are the selected Go1.27 directive/export, ABI-wrapper and object-flag
+// rules. They do not register an older SDK producer or infer semantics from
+// the translator's build version. Every byte becomes a normal live input.
+var numericalCompilerAliasSchema = map[string]string{
+	"src/cmd/compile/internal/noder/noder.go":  "2aa3493281bfced8419994a553606fe074f3dbde6a46cf7a66cff0519cb68e83",
+	"src/cmd/compile/internal/noder/writer.go": "53550393cf60bd31892e18a4a79715670a7243289445b57919faa69163a256e0",
+	"src/cmd/compile/internal/noder/reader.go": "10051996ac541466c4f0f3ccfb3ca7181c38726050d49d2c113ab784119d8be6",
+	"src/cmd/compile/internal/ssagen/abi.go":   "35b5cea74c417723ff4778cea5175d3a7bdd9c58584af163229e9624a1ee709c",
+	"src/cmd/internal/goobj/objfile.go":        "caf835a17e23aa02cae9bda6e8723d8be359846fc4453bd53f3a3947744b938a",
+	"src/cmd/internal/obj/objfile.go":          "803546227c02cf46bfa4158be3dfd8067e7457f4e4f78349cb6d42c700b2fcb7",
+	"src/cmd/internal/objabi/path.go":          "ff1e056f2f2b3aa1f757bf7be3da769f1f5241da65438e5ebb9f65a6716c8343",
+}
+
+func (source *GoX86NumericalReadSource) captureCompilerAliases() error {
+	if source.role != numericalSBSDKSource {
+		return nil
+	}
+	joined := source.sdkAssemblyJoin()
+	var syntax []*ast.File
+	for _, name := range source.guard.selection.GoFiles {
+		filename := filepath.Join(source.request.Directory, name)
+		data, err := source.guard.read(filename)
+		if err != nil {
+			return err
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), filename, data, parser.ParseComments)
+		if err != nil {
+			return err
+		}
+		syntax = append(syntax, file)
+	}
+	names, err := numericalGoLinknameSpellings(syntax, source.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	wanted := numericalCompilerAliasDemand(source.file, source.request.PackagePath, names)
+	if len(wanted) == 0 {
+		return nil
+	}
+	if joined == nil || source.guard.env["GOARCH"] != "amd64" || joined.Observation.Objects == nil ||
+		len(joined.Observation.Objects.Members) < 2 || len(source.native.ArchiveMembers) < 2 {
+		return numericalSBContext("foreign declarations need the complete registered compiler/assembly join")
+	}
+	for role, expected := range numericalCompilerAliasSchema {
+		data, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role)))
+		if err != nil {
+			return err
+		}
+		digest := sha256.Sum256(data)
+		if hex.EncodeToString(digest[:]) != expected {
+			return numericalSBContext("foreign declaration selected compiler schema differs: %s", role)
+		}
+	}
+	header := joined.Observation.Header
+	generated, err := gostaticstorage.ObserveX86SDKCompilerText(header.CompilerObject,
+		joined.Observation.ObjectInputs.BuiltinSource, source.request.Target, joined.Observation.ObjectInputs.Referenced)
+	if err != nil {
+		return numericalSBContext("actual complete header compiler object: %v", err)
+	}
+	selected := joined.Observation.Objects.Members[1]
+	nativeMember := source.native.ArchiveMembers[1]
+	if selected.Name != "_go_.o" || nativeMember.Name != selected.Name || nativeMember.Offset != selected.Offset ||
+		nativeMember.Size != selected.Size || nativeMember.Flags != selected.Flags || !reflect.DeepEqual(nativeMember.Texts, selected.Texts) {
+		return numericalSBContext("foreign declaration lost the actual compiler archive member")
+	}
+	index, err := numericalCompilerAliasIndex(header.SymABI, generated, selected.Texts)
+	if err != nil {
+		return err
+	}
+	aliases := make(map[string]numericalCompilerAliasWitness)
+	for ordinal, fn := range source.file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			continue
+		}
+		name, abi, valid := source.numericalSourceTextIdentity(ordinal, fn, source.guard.env["GOARCH"])
+		if !valid {
+			return numericalSBContext("foreign declaration has no complete original native TEXT")
+		}
+		if !wanted[name] {
+			continue
+		}
+		accepted := 0
+		for _, standard := range []bool{false, true} {
+			if index.association(name, abi, standard) == nil {
+				aliases[name] = numericalCompilerAliasWitness{ABI: abi, Standard: standard}
+				accepted++
+			}
+		}
+		if accepted != 1 {
+			return numericalSBContext("foreign TEXT lacks its unique original compiler alias/ABI witness")
+		}
+	}
+	source.native.CompilerAliases = aliases
+	return nil
+}
+
+func numericalCompilerAliasDemand(file *File, pkg string, names numericalGoLinknames) map[string]bool {
+	prefix := gosym.PackagePrefix(pkg) + "."
+	wanted := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			continue
+		}
+		native := numericalNativeName(goTextSymbolForResolution(fn.Sym), pkg)
+		local, aliased := names.nativeToLocal[native]
+		if !strings.HasPrefix(native, prefix) || aliased && native != prefix+local {
+			wanted[native] = true
+		}
+	}
+	return wanted
+}
diff --git a/go_x86_numerical_read_compiler_alias_test.go b/go_x86_numerical_read_compiler_alias_test.go
new file mode 100644
index 000000000..b501f5541
--- /dev/null
+++ b/go_x86_numerical_read_compiler_alias_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These deliberately synthetic records exercise comparison rules only. They
+// do not create a ready Source, compiler capture, binding or LLVM permission.
+func numericalCompilerAliasModel(standard bool) numericalCompilerAliasInput {
+	flag := uint8(16) // Go1.27's separately registered ordinary linkname bit.
+	if standard {
+		flag = 32
+	}
+	text := gostaticstorage.TextRecord{Name: "example.invalid/remote.Entry", ABI: 0,
+		Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Kind: 1,
+		Flags2: flag | 64, Size: 6, Code: []byte{0xe8, 0, 0, 0, 0, 0xc3},
+		Relocations: []gostaticstorage.TextRelocation{{Offset: 1, Size: 4, Type: 7,
+			Target: gostaticstorage.TextReference{Name: "example.invalid/remote.Entry", ABI: 1, ABIKnown: true}}}}
+	return numericalCompilerAliasInput{Native: text.Name, ABI: 1, Standard: standard,
+		SymABI:    []byte("def example.invalid/remote.Entry ABIInternal\n"),
+		Generated: []gostaticstorage.TextRecord{text}, Selected: []gostaticstorage.TextRecord{text}}
+}
+
+func TestNumericalSDKCompilerAliasCompleteComparisonModel(t *testing.T) {
+	for _, standard := range []bool{false, true} {
+		if err := numericalCompilerAliasAssociation(numericalCompilerAliasModel(standard)); err != nil {
+			t.Fatal("complete modeled compiler/selected native association did not join", standard, err)
+		}
+	}
+}
+
+func TestNumericalSDKCompilerAliasCannotBorrowDirectiveOrPartialObject(t *testing.T) {
+	for _, standard := range []bool{false, true} {
+		for name, change := range map[string]func(*numericalCompilerAliasInput){
+			"directive-only":      func(v *numericalCompilerAliasInput) { v.Generated, v.Selected = nil, nil },
+			"no-generated-object": func(v *numericalCompilerAliasInput) { v.Generated = nil },
+			"no-selected-object":  func(v *numericalCompilerAliasInput) { v.Selected = nil },
+			"no-symabi":           func(v *numericalCompilerAliasInput) { v.SymABI = nil },
+			"foreign-symabi": func(v *numericalCompilerAliasInput) {
+				v.SymABI = []byte("def example.invalid/remote.Other ABIInternal\n")
+			},
+			"wrong-symabi-ABI": func(v *numericalCompilerAliasInput) {
+				v.SymABI = []byte("def example.invalid/remote.Entry ABI0\n")
+			},
+			"duplicate-symabi":         func(v *numericalCompilerAliasInput) { v.SymABI = append(v.SymABI, v.SymABI...) },
+			"unknown-native-ABI":       func(v *numericalCompilerAliasInput) { v.ABI = 65535 },
+			"foreign-generated-name":   func(v *numericalCompilerAliasInput) { v.Generated[0].Name += "Other" },
+			"missing-linkname-bit":     func(v *numericalCompilerAliasInput) { v.Generated[0].Flags2 = 64 },
+			"swapped-directive-kind":   func(v *numericalCompilerAliasInput) { v.Standard = !v.Standard },
+			"not-ABI-wrapper":          func(v *numericalCompilerAliasInput) { v.Generated[0].Flags2 &^= 64 },
+			"wrong-wrapper-ABI":        func(v *numericalCompilerAliasInput) { v.Generated[0].ABI = 1 },
+			"static-wrapper":           func(v *numericalCompilerAliasInput) { v.Generated[0].Namespace = gostaticstorage.TextSymbolSelf },
+			"duplicate-wrapper":        func(v *numericalCompilerAliasInput) { v.Generated = append(v.Generated, v.Generated[0]) },
+			"unknown-code":             func(v *numericalCompilerAliasInput) { v.Generated[0].Code = nil },
+			"different-selected-code":  func(v *numericalCompilerAliasInput) { v.Selected[0].Code = []byte{0xcc} },
+			"missing-native-reference": func(v *numericalCompilerAliasInput) { v.Generated[0].Relocations = nil },
+			"foreign-native-reference": func(v *numericalCompilerAliasInput) {
+				v.Generated[0].Relocations = append([]gostaticstorage.TextRelocation(nil), v.Generated[0].Relocations...)
+				v.Generated[0].Relocations[0].Target.Name += "Other"
+			},
+			"unknown-reference-ABI": func(v *numericalCompilerAliasInput) {
+				v.Generated[0].Relocations = append([]gostaticstorage.TextRelocation(nil), v.Generated[0].Relocations...)
+				v.Generated[0].Relocations[0].Target.ABIKnown = false
+			},
+		} {
+			t.Run(name+map[bool]string{false: "/linkname", true: "/linknamestd"}[standard], func(t *testing.T) {
+				input := numericalCompilerAliasModel(standard)
+				change(&input)
+				if err := numericalCompilerAliasAssociation(input); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("directive or incomplete compiler object became declaration authority", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_numerical_read_consumer_guard_test.go b/go_x86_numerical_read_consumer_guard_test.go
new file mode 100644
index 000000000..b69be3191
--- /dev/null
+++ b/go_x86_numerical_read_consumer_guard_test.go
@@ -0,0 +1,479 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestGoX86NumericalSBReadGoWrapperSealedFunctionMetadata(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "amd64")
+	source, options := create(t)
+	resolve := options.ResolveSym
+	metadataCallback := false
+	stateful := func(symbol string) string {
+		if symbol == "·Feature" {
+			// A caller may change only one answer and restore all later
+			// answers. Select the direct wrapper metadata call, not the
+			// nested declaration or pre/post guard consumers.
+			pc, _, _, ok := runtime.Caller(1)
+			if ok && strings.HasSuffix(runtime.FuncForPC(pc).Name(), ".translateGoModuleInContext") {
+				metadataCallback = true
+				return "foreign.Feature"
+			}
+		}
+		return resolve(symbol)
+	}
+	result, err := TranslateGoModule(pkg, numericalWrapperOriginal(t, source), GoModuleOptions{
+		FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: "amd64",
+		TargetTriple: options.TargetTriple, NumericalReads: options.NumericalReads, ResolveSym: stateful,
+	})
+	if err != nil {
+		// A guard that rejects the changed callback is also valid; it must
+		// return no module or partially inconsistent metadata.
+		if result != nil || !errors.Is(err, ErrProbeNeedsContext) || !metadataCallback {
+			t.Fatal("wrapper failed outside the actual metadata TOCTOU", metadataCallback, err)
+		}
+		return
+	}
+	if result == nil || result.Module.IsNil() {
+		t.Fatal("successful wrapper lost its real translated module")
+	}
+	defer result.Module.Dispose()
+	want := pkg.Path + ".Feature"
+	if len(result.Functions) != 1 || result.Functions[0].ResolvedSymbol != want ||
+		result.Module.NamedFunction(want).IsNil() || len(result.Signatures) != 1 || result.Signatures[want].Name != want {
+		t.Fatal("wrapper module, signatures and function metadata disagree", metadataCallback, result.Functions, result.Signatures)
+	}
+}
+
+func TestGoX86NumericalSBReadGoWrapperKeepsSealedPackageProfile(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg, _, _, create := numericalConsumerFactory(t, arch)
+			source, options := create(t)
+			binding := options.NumericalReads
+			if binding.options.goPackage != nil {
+				t.Fatal("numerical binding acquired an external-tail package role")
+			}
+			result, err := TranslateGoModule(pkg, numericalWrapperOriginal(t, source), GoModuleOptions{
+				FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: arch,
+				TargetTriple: options.TargetTriple, NumericalReads: binding, ResolveSym: options.ResolveSym,
+			})
+			if result != nil && !result.Module.IsNil() {
+				defer result.Module.Dispose()
+			}
+			if err != nil || result == nil || result.Module.IsNil() || len(result.Functions) != 1 ||
+				result.Functions[0].ResolvedSymbol != pkg.Path+".Feature" {
+				t.Fatal("unchanged numerical Go wrapper lost its sealed package profile", err)
+			}
+			if binding.options.goPackage != nil {
+				t.Fatal("Go wrapper changed the sealed numerical options")
+			}
+			if err := source.Verify(binding.context); err != nil {
+				t.Fatal("successful Go wrapper revoked the unchanged source", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadGoWrapperCompleteProfileGuards(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "amd64")
+	for _, test := range []struct {
+		name   string
+		mutate func(*GoModuleOptions)
+	}{
+		{"GOOS", func(o *GoModuleOptions) { o.GOOS = "darwin" }},
+		{"GOARCH", func(o *GoModuleOptions) { o.GOARCH = "386" }},
+		{"target", func(o *GoModuleOptions) { o.TargetTriple = "x86_64-apple-darwin" }},
+		{"value sizes", func(o *GoModuleOptions) { o.Sizes = types.SizesFor("gc", "amd64") }},
+		{"frame sizes", func(o *GoModuleOptions) { o.FrameSizes = types.SizesFor("gc", "amd64") }},
+		{"foreign source path", func(o *GoModuleOptions) { o.FileName = filepath.Join(t.TempDir(), o.FileName) }},
+		{"WASM", func(o *GoModuleOptions) { o.WASMABI = WASMABIGo }},
+		{"x87", func(o *GoModuleOptions) { o.X87Mode = X87Software }},
+		{"annotation", func(o *GoModuleOptions) { o.AnnotateSource = true }},
+		{"resolver", func(o *GoModuleOptions) { o.ResolveSym = nil }},
+		{"filter", func(o *GoModuleOptions) { o.KeepFunc = func(string, string) bool { return true } }},
+		{"ARM64 carriers", func(o *GoModuleOptions) { o.ARM64ClosureABIs = map[string]ARM64ClosureABI{"foreign": {}} }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, options := create(t)
+			opt := GoModuleOptions{FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: "amd64",
+				TargetTriple: options.TargetTriple, NumericalReads: options.NumericalReads, ResolveSym: options.ResolveSym}
+			test.mutate(&opt)
+			result, err := TranslateGoModule(pkg, numericalWrapperOriginal(t, source), opt)
+			if result != nil {
+				result.Module.Dispose()
+			}
+			if result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("different wrapper profile/source role published translated output", err)
+			}
+			if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+				t.Fatal("wrapper profile failure did not permanently revoke the source")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadGoWrapperOriginalBytesPostGuard(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "386")
+	source, options := create(t)
+	input := numericalWrapperOriginal(t, source)
+	resolve := options.ResolveSym
+	mutated := false
+	callback := func(symbol string) string {
+		pc, _, _, ok := runtime.Caller(1)
+		if ok && strings.HasSuffix(runtime.FuncForPC(pc).Name(), ".addDeclaredFuncSigs") && !mutated {
+			// Alter caller-owned bytes only after parsing, not the frozen
+			// object/source producer or the callback's returned symbol.
+			input[len(input)-1] ^= 1
+			mutated = true
+		}
+		return resolve(symbol)
+	}
+	result, err := TranslateGoModule(pkg, input, GoModuleOptions{
+		FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: "386",
+		TargetTriple: options.TargetTriple, NumericalReads: options.NumericalReads, ResolveSym: callback,
+	})
+	if result != nil {
+		result.Module.Dispose()
+	}
+	if !mutated || result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("wrapper caller-owned source bytes escaped the final guard", mutated, err)
+	}
+	if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+		t.Fatal("wrapper byte mutation did not permanently revoke the source")
+	}
+}
+
+func numericalWrapperOriginal(t *testing.T, source *GoX86NumericalReadSource) []byte {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data
+}
+
+func TestGoX86NumericalSBReadGoWrapperExactOriginalBytesAndLifetime(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "amd64")
+	for _, name := range []string{"same parse different bytes", "raw rewrite", "copied token", "foreign source", "revoked source"} {
+		t.Run(name, func(t *testing.T) {
+			source, options := create(t)
+			input := numericalWrapperOriginal(t, source)
+			binding := options.NumericalReads
+			switch name {
+			case "same parse different bytes":
+				changed := append(append([]byte(nil), input...), []byte("// not selected original bytes\n")...)
+				a, aErr := Parse(ArchAMD64, string(input))
+				b, bErr := Parse(ArchAMD64, string(changed))
+				aHash, _ := x86CallerSourceFingerprint(a)
+				bHash, _ := x86CallerSourceFingerprint(b)
+				if aErr != nil || bErr != nil || aHash != bHash {
+					t.Fatal("different-bytes/same-parse fixture precondition failed", aErr, bErr)
+				}
+				input = changed
+			case "raw rewrite":
+				input = []byte(strings.Replace(string(input), "CMPB", "MOVB", 1))
+			case "copied token":
+				copied := *binding
+				binding = &copied
+			case "foreign source":
+				foreign, _ := create(t)
+				binding.source = foreign
+			case "revoked source":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			result, err := TranslateGoModule(pkg, input, GoModuleOptions{
+				FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: "amd64",
+				TargetTriple: options.TargetTriple, NumericalReads: binding, ResolveSym: options.ResolveSym,
+			})
+			if result != nil {
+				result.Module.Dispose()
+			}
+			if result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("foreign/raw/lifetime input published a Go module", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadGoWrapperHeaderTOCTOU(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "amd64")
+	first, _ := create(t)
+	dir := first.request.Directory
+	if err := first.Close(); err != nil {
+		t.Fatal(err)
+	}
+	header := filepath.Join(dir, "textflag.h")
+	if err := os.WriteFile(header, []byte("#define NOSPLIT 4\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	source, options := create(t)
+	resolve := options.ResolveSym
+	mutated := false
+	callback := func(symbol string) string {
+		pc, _, _, ok := runtime.Caller(1)
+		if ok && strings.HasSuffix(runtime.FuncForPC(pc).Name(), ".addDeclaredFuncSigs") && !mutated {
+			if err := os.WriteFile(header, []byte("#define NOSPLIT 4\n// changed sealed header bytes\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			mutated = true
+		}
+		return resolve(symbol)
+	}
+	result, err := TranslateGoModule(pkg, numericalWrapperOriginal(t, source), GoModuleOptions{
+		FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: "amd64",
+		TargetTriple: options.TargetTriple, NumericalReads: options.NumericalReads, ResolveSym: callback,
+	})
+	if result != nil {
+		result.Module.Dispose()
+	}
+	if !mutated || result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed actual owned header published a Go module", mutated, err)
+	}
+	if err := os.WriteFile(header, []byte("#define NOSPLIT 4\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+		t.Fatal("header restoration could revive a revoked source")
+	}
+}
+
+func numericalConsumerFactory(t *testing.T, arch string) (GoPackage, *File, Options, func(*testing.T) (*GoX86NumericalReadSource, Options)) {
+	t.Helper()
+	pkg, request, file, options := numericalSBFixture(t, arch)
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: request.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: request.Target, Environment: request.Environment, SDKCPU: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(owner.Close)
+	create := func(t *testing.T) (*GoX86NumericalReadSource, Options) {
+		t.Helper()
+		source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+			GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: pkg.Path,
+			AssemblyFile: request.AssemblyFile, Target: request.Target, Environment: request.Environment,
+			Owners: []*GoNumericalStorageOwner{owner},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(func() {
+			if err := source.Close(); err != nil {
+				t.Error(err)
+			}
+		})
+		bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+		if err != nil {
+			t.Fatal("actual source/object/owner binding precondition", err)
+		}
+		return source, bound
+	}
+	return pkg, file, options, create
+}
+
+func TestGoX86NumericalSBReadConsumerCompleteOptionAndSignatureGuards(t *testing.T) {
+	pkg, file, _, create := numericalConsumerFactory(t, "amd64")
+	for _, test := range []struct {
+		name   string
+		mutate func(*Options)
+	}{
+		{"target", func(o *Options) { o.TargetTriple = "x86_64-apple-darwin" }},
+		{"arch", func(o *Options) { o.Goarch = "386" }},
+		{"wasm", func(o *Options) { o.WASMABI = WASMABIGo }},
+		{"x87", func(o *Options) { o.X87Mode = X87Software }},
+		{"annotation", func(o *Options) { o.AnnotateSource = true }},
+		{"tail groups", func(o *Options) { o.X86TailGroups = []X86TailGroup{{}} }},
+		{"private Go package", func(o *Options) { o.goPackage = &pkg }},
+		{"foreign private Go package", func(o *Options) { o.goPackage = &GoPackage{Path: "foreign"} }},
+		{"missing resolver", func(o *Options) { o.ResolveSym = nil }},
+		{"foreign resolver", func(o *Options) { o.ResolveSym = func(s string) string { return s } }},
+		{"missing signatures", func(o *Options) { o.Sigs = nil }},
+		{"additional signature", func(o *Options) { o.Sigs["foreign"] = FuncSig{Name: "foreign", Ret: Void} }},
+		{"result type", func(o *Options) {
+			for name, sig := range o.Sigs {
+				sig.Ret = I32
+				o.Sigs[name] = sig
+			}
+		}},
+		{"result slot", func(o *Options) {
+			for name, sig := range o.Sigs {
+				sig.Frame.Results[0].Offset++
+				o.Sigs[name] = sig
+			}
+		}},
+		{"private caller identity", func(o *Options) {
+			for name, sig := range o.Sigs {
+				sig.x86CallerRegions = &x86GoCallerRegionProof{}
+				o.Sigs[name] = sig
+			}
+		}},
+		{"private local identity", func(o *Options) {
+			for name, sig := range o.Sigs {
+				sig.x86FixedLocal = &x86FixedLocalBinding{}
+				o.Sigs[name] = sig
+			}
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, options := create(t)
+			test.mutate(&options)
+			if err := verifyNumericalReadInputs(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed consumer shape retained a live read binding", err)
+			}
+			if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+				t.Fatal("failed consumer guard did not permanently revoke its source")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadConsumerResolverMutationGuard(t *testing.T) {
+	pkg, file, originalOptions, create := numericalConsumerFactory(t, "386")
+	for _, mutation := range []string{"source", "AST", "resolver", "signature"} {
+		t.Run(mutation, func(t *testing.T) {
+			_, options := create(t)
+			resolve := options.ResolveSym
+			called := false
+			options.ResolveSym = func(symbol string) string {
+				if !called {
+					called = true
+					switch mutation {
+					case "source":
+						file.Funcs[0].Instrs[2].Args[1].Imm++
+						t.Cleanup(func() { file.Funcs[0].Instrs[2].Args[1].Imm-- })
+					case "AST":
+						pkg.Syntax[0].Name.Name += "changed"
+						t.Cleanup(func() { pkg.Syntax[0].Name.Name = "numericalfixture" })
+					case "resolver":
+						options.ResolveSym = originalOptions.ResolveSym
+						return "foreign"
+					case "signature":
+						for name, sig := range options.Sigs {
+							sig.Attrs = "#77"
+							options.Sigs[name] = sig
+						}
+					}
+				}
+				return resolve(symbol)
+			}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !called {
+				t.Fatal("resolver TOCTOU published translated output", called, err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadBindingDeclarationIdentityAndWrapperGuards(t *testing.T) {
+	pkg, _, _, create := numericalConsumerFactory(t, "amd64")
+	t.Run("private types identity", func(t *testing.T) {
+		_, options := create(t)
+		binding := options.NumericalReads
+		fset := token.NewFileSet()
+		syntax, err := parser.ParseFile(fset, "value.go", "package numericalfixture\nfunc Feature() byte\n", parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		replacement, err := (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		binding.packageInput.Types = replacement
+		if !errors.Is(binding.verify(), ErrProbeNeedsContext) {
+			t.Fatal("same-shaped foreign private type package replaced the live declaration owner")
+		}
+	})
+	for _, mutation := range []string{"changed types", "changed imports", "missing syntax", "changed syntax", "source selection", "manual signature"} {
+		t.Run(mutation, func(t *testing.T) {
+			_, options := create(t)
+			binding := options.NumericalReads
+			wrapperPkg := pkg
+			opt := GoModuleOptions{FileName: binding.source.request.AssemblyFile, GOOS: "linux", GOARCH: "amd64",
+				TargetTriple: options.TargetTriple, NumericalReads: binding, ResolveSym: options.ResolveSym}
+			switch mutation {
+			case "changed types":
+				wrapperPkg.Types = types.NewPackage(pkg.Path, pkg.Types.Name())
+			case "changed imports":
+				wrapperPkg.Imports = map[string]*types.Package{"foreign": types.NewPackage("example.invalid/foreign", "foreign")}
+			case "missing syntax":
+				wrapperPkg.Syntax = nil
+			case "changed syntax":
+				fset := token.NewFileSet()
+				changed, err := parser.ParseFile(fset, "value.go", "package other\nfunc Feature() byte\n", parser.ParseComments)
+				if err != nil {
+					t.Fatal(err)
+				}
+				wrapperPkg.Syntax = []*ast.File{changed}
+			case "source selection":
+				wrapperPkg.SourceSelection = &GoSourceSelection{}
+			case "manual signature":
+				opt.ManualSig = func(name string) (FuncSig, bool) { return options.Sigs[name], true }
+			}
+			result, err := TranslateGoModule(wrapperPkg, numericalWrapperOriginal(t, binding.source), opt)
+			if result != nil && !result.Module.IsNil() {
+				result.Module.Dispose()
+			}
+			if result != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound Go wrapper declaration/source role survived the precondition", mutation, err)
+			}
+			if !errors.Is(binding.source.Verify(binding.context), ErrProbeNeedsContext) {
+				t.Fatal("failed wrapper guard did not permanently revoke its source")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadNormalizedOrdinalAndCertificateGuards(t *testing.T) {
+	_, file, _, create := numericalConsumerFactory(t, "386")
+	for _, mutation := range []string{"removed", "duplicate", "operand", "ordinal", "function", "foreign binding", "data collision"} {
+		t.Run(mutation, func(t *testing.T) {
+			_, options := create(t)
+			frozen, bound, err := freezeNumericalReadInputs(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := &frozen.Funcs[0]
+			read := &fn.Instrs[2]
+			if read.x86NumericalRead == nil {
+				t.Fatal("actual original CMP read ordinal changed")
+			}
+			switch mutation {
+			case "removed":
+				read.x86NumericalRead = nil
+			case "duplicate":
+				fn.Instrs = append(fn.Instrs, *read)
+			case "operand":
+				read.Args[0].Sym = strings.Replace(read.Args[0].Sym, "+64", "+65", 1)
+			case "ordinal":
+				fn.Instrs[1], fn.Instrs[2] = fn.Instrs[2], fn.Instrs[1]
+			case "function":
+				fn.Sym = "·Foreign"
+			case "foreign binding":
+				copyBinding := *bound.NumericalReads
+				read.x86NumericalRead.binding = &copyBinding
+			case "data collision":
+				frozen.Globl = append(frozen.Globl, GloblStmt{})
+			}
+			if !errors.Is(verifyNormalizedNumericalReads(frozen, bound), ErrProbeNeedsContext) {
+				t.Fatal("normalized native read identity changed without rejection")
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_consumer_test.go b/go_x86_numerical_read_consumer_test.go
new file mode 100644
index 000000000..33407d4f5
--- /dev/null
+++ b/go_x86_numerical_read_consumer_test.go
@@ -0,0 +1,221 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestGoX86NumericalSBReadBoundConsumer(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg, original, file, options := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+				GoBinary: original.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(original.GoBinary)), "src", "internal", "cpu"),
+				PackagePath: "internal/cpu", Target: original.Target, Environment: original.Environment, SDKCPU: true,
+				Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+				GoBinary: original.GoBinary, Directory: original.Directory, PackagePath: pkg.Path,
+				AssemblyFile: original.AssemblyFile, Target: original.Target, Environment: original.Environment,
+				Owners: []*GoNumericalStorageOwner{owner},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("successful actual source/object/owner precondition failed at binding", err)
+			}
+			for _, api := range []string{"text", "module", "context"} {
+				t.Run(api, func(t *testing.T) {
+					var ir string
+					var err error
+					if api == "text" {
+						ir, err = Translate(file, bound)
+					} else {
+						context := llvm.NewContext()
+						var module llvm.Module
+						if api == "module" {
+							module, err = TranslateModule(file, bound)
+						} else {
+							module, err = TranslateModuleInContext(context, file, bound)
+						}
+						if !module.IsNil() {
+							ir = module.String()
+							module.Dispose()
+						}
+						context.Dispose()
+					}
+					if err != nil {
+						t.Fatal("live exact numerical read still lacks coherent consumer effects", err)
+					}
+					if !strings.Contains(ir, "load volatile i8") || !strings.Contains(ir, "external global [") || strings.Contains(ir, "constant [") {
+						t.Fatal("mutable numerical read lost exact live-load/global role", ir)
+					}
+				})
+			}
+		})
+	}
+}
+
+func closeNumericalConsumerSource(reporter interface{ Error(...any) }, source *GoX86NumericalReadSource) error {
+	err := source.Close()
+	if err != nil {
+		reporter.Error(err)
+	}
+	return err
+}
+
+type numericalConsumerCleanupRecorder struct {
+	errors []error
+}
+
+func (recorder *numericalConsumerCleanupRecorder) Error(values ...any) {
+	if len(values) != 1 {
+		panic("numerical consumer cleanup must report its one original error")
+	}
+	err, ok := values[0].(error)
+	if !ok {
+		panic("numerical consumer cleanup must preserve its error object")
+	}
+	recorder.errors = append(recorder.errors, err)
+}
+
+func TestGoX86NumericalConsumerCleanupReportsActualCloseOutcome(t *testing.T) {
+	pkg, original, _, _ := numericalSBFixture(t, "amd64")
+	// Both directories and every factory artifact belong to this fixture.
+	temporary, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, pair := range original.Environment {
+		if strings.HasPrefix(pair, "TMPDIR=") {
+			original.Environment[index] = "TMPDIR=" + temporary
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: original.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(original.GoBinary)), "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: original.Target, Environment: original.Environment, SDKCPU: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+
+	for _, replacement := range []bool{false, true} {
+		name := "normal"
+		if replacement {
+			name = "directory-identity-changed"
+		}
+		t.Run(name, func(t *testing.T) {
+			source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+				GoBinary: original.GoBinary, Directory: original.Directory, PackagePath: pkg.Path,
+				AssemblyFile: original.AssemblyFile, Target: original.Target, Environment: original.Environment,
+				Owners: []*GoNumericalStorageOwner{owner},
+			})
+			if err != nil {
+				t.Fatal("actual capture precondition", err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if !source.ready || source.guard == nil || source.guard.owned == "" {
+				t.Fatal("actual capture did not establish its live artifact owner")
+			}
+
+			if replacement {
+				owned := source.guard.owned
+				identity, err := sourcepath.Lstat(owned)
+				if err != nil {
+					t.Fatal(err)
+				}
+				spare := t.TempDir()
+				displaced := filepath.Join(spare, "original-owned-directory")
+				foreign := filepath.Join(spare, "replacement-directory")
+				if err := os.Mkdir(foreign, 0700); err != nil {
+					t.Fatal(err)
+				}
+				foreignIdentity, err := sourcepath.Lstat(foreign)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(foreign, "fixture-canary"), []byte("replacement fixture owner\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(owned, displaced); err != nil {
+					t.Fatal(err)
+				}
+				defer func() {
+					if info, err := os.Lstat(displaced); err != nil || !os.SameFile(identity, info) {
+						t.Error("cannot restore the fixture's original owned directory identity", err)
+						return
+					}
+					if info, err := os.Lstat(owned); err == nil {
+						if !os.SameFile(foreignIdentity, info) {
+							t.Error("refuse to move an unexpected replacement directory")
+							return
+						}
+						if err := os.Rename(owned, foreign); err != nil {
+							t.Error("restore replacement directory", err)
+							return
+						}
+					} else if !errors.Is(err, os.ErrNotExist) {
+						t.Error("inspect original owned-directory path", err)
+						return
+					}
+					if err := os.Rename(displaced, owned); err != nil {
+						t.Error("restore original owned-directory identity", err)
+					}
+				}()
+				if err := os.Rename(foreign, owned); err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			recorder := &numericalConsumerCleanupRecorder{}
+			err = closeNumericalConsumerSource(recorder, source)
+			if !replacement {
+				if err != nil || len(recorder.errors) != 0 {
+					t.Fatalf("normal successful Close reported an error: %v, %v", err, recorder.errors)
+				}
+				if source.ready || source.guard.owned != "" {
+					t.Fatal("normal successful Close retained its ready/artifact role")
+				}
+				return
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("actual changed-directory Close did not reject its owned identity", err)
+			}
+			if source.ready {
+				t.Fatal("failed Close retained the source's ready authority")
+			}
+			canary, readErr := os.ReadFile(filepath.Join(source.guard.owned, "fixture-canary"))
+			if readErr != nil || string(canary) != "replacement fixture owner\n" {
+				t.Fatal("failed Close changed the replacement fixture owner's canary", readErr)
+			}
+			if len(recorder.errors) != 1 || recorder.errors[0] != err {
+				t.Fatalf("successful producer cleanup discarded the actual Close error: returned %v, reported %v", err, recorder.errors)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_entry_test.go b/go_x86_numerical_read_entry_test.go
new file mode 100644
index 000000000..04638b3a4
--- /dev/null
+++ b/go_x86_numerical_read_entry_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoX86NumericalReadOriginalSourceABIIdentity(t *testing.T) {
+	for _, role := range []numericalSBSourceRole{numericalSBOwnedSource, numericalSBSDKSource} {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, selector := range []string{"", "<ABI0>", "<ABIInternal>", "<ABI99>", "<>"} {
+				name, abi, valid := numericalFunctionSourceIdentity("·entry"+selector, "example.invalid/owner", arch, role)
+				want := selector == "" || selector == "<ABI0>" || selector == "<ABIInternal>" && arch == "amd64" && role == numericalSBSDKSource
+				if valid != want || valid && name != "example.invalid/owner.entry" || valid && (abi == 1) != (selector == "<ABIInternal>") {
+					t.Fatal("source selector changed its genuine owner/mode/native ABI", role, arch, selector, name, abi, valid)
+				}
+			}
+		}
+	}
+}
+
+func TestGoX86NumericalReadSDKOpaquePointerLanguageIdentity(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		sizes := types.SizesFor("gc", arch)
+		unsafePointer := types.Typ[types.UnsafePointer]
+		if _, err := goAMD64FrameLanguageType(unsafePointer, sizes); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("opaque SDK declaration identity widened ordinary frame transport", err)
+		}
+		opaque, err := goAMD64FrameLanguageTypeRole(unsafePointer, sizes, true)
+		if err != nil || !strings.Contains(opaque, "opaque_unsafe_pointer") {
+			t.Fatal("SDK observer discarded the actual unsafe.Pointer language role", err)
+		}
+		for _, other := range []types.Type{types.Typ[types.Uintptr], types.NewPointer(types.Typ[types.Uint8]), types.NewPointer(unsafePointer)} {
+			identity, err := goAMD64FrameLanguageTypeRole(other, sizes, true)
+			if err != nil || identity == opaque {
+				t.Fatal("equal-size numerical/pointee types replaced opaque pointer identity", identity, err)
+			}
+		}
+	}
+}
+
+func TestGoX86NumericalReadExactEmptyLiteralMember(t *testing.T) {
+	joined := &numericalSDKLiteralJoin{SourceOrdinal: 0,
+		Observation:  sdkASMDataLiveObservation{Objects: &gostaticstorage.SDKASMDataObservation{Sources: []gostaticstorage.ASMDataSourceObservation{{}}}},
+		Initializers: sdkReadonlyLiteralDataReport{Initializers: []gostaticstorage.ReadonlyLiteralDataImage{{SourceOrdinal: 1}}},
+	}
+	file := &File{Arch: ArchAMD64}
+	if err := joined.verifyFile(file, "example.invalid/owner"); err != nil {
+		t.Fatal("complete empty member borrowed another member's DATA inventory", err)
+	}
+	for _, source := range []string{
+		"GLOBL empty<>(SB),8,$0\n", "DATA local<>+0(SB)/1,$7\n", "GLOBL local<>(SB),8,$1\nDATA local<>+0(SB)/1,$7\n",
+	} {
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := joined.verifyFile(file, "example.invalid/owner"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unobserved DATA appeared in an empty source member", source, err)
+		}
+	}
+}
diff --git a/go_x86_numerical_read_family_test.go b/go_x86_numerical_read_family_test.go
new file mode 100644
index 000000000..7278ae9d8
--- /dev/null
+++ b/go_x86_numerical_read_family_test.go
@@ -0,0 +1,337 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type numericalExecutionCase struct {
+	name, instruction, predicate string
+	register                     string
+	source, gp                   int64
+	signed, compare              bool
+	reversed, immediate          bool
+	high, cpu, dead              bool
+	partnerHigh                  bool
+}
+
+// Widths and formats come from the independent complete Go encoder inventory,
+// not the consumer's typed grammar. Every compare direction/predicate remains
+// separately observable, as do partial/high-byte and zero-extending writes.
+func numericalExecutionCases(arch string) []numericalExecutionCase {
+	var cases []numericalExecutionCase
+	for _, row := range numericalSBOracleRows {
+		if arch == "386" && row.rejected386 {
+			continue
+		}
+		if strings.HasPrefix(row.op, "CMP") {
+			for _, predicate := range []string{"LT", "CS", "EQ"} {
+				for _, partner := range []string{"$4294967295", "AX", "reversed"} {
+					instruction := row.op + " ·Mutable+3(SB)," + partner
+					if partner == "reversed" {
+						instruction = row.op + " AX,·Mutable+3(SB)"
+					}
+					cases = append(cases, numericalExecutionCase{
+						instruction: instruction, predicate: predicate, source: row.source, gp: row.gp,
+						compare: true, reversed: partner == "reversed", immediate: partner[0] == '$',
+					})
+				}
+			}
+			continue
+		}
+		gp := row.gp
+		if arch == "386" && row.op == "MOVLQZX" {
+			gp = 4
+		}
+		signed := strings.HasSuffix(row.op, "SX") || row.op == "MOVSWW"
+		cases = append(cases, numericalExecutionCase{instruction: row.op + " ·Mutable+3(SB),AX",
+			source: row.source, gp: gp, signed: signed})
+		if arch == "amd64" {
+			cases = append(cases, numericalExecutionCase{instruction: row.op + " ·Mutable+3(SB),R8",
+				register: "R8", source: row.source, gp: gp, signed: signed})
+		}
+	}
+	for _, predicate := range []string{"LT", "CS", "EQ"} {
+		cases = append(cases, numericalExecutionCase{instruction: "CMPB AH,·Mutable+3(SB)",
+			predicate: predicate, source: 1, gp: 1, compare: true, reversed: true, partnerHigh: true})
+	}
+	cases = append(cases,
+		numericalExecutionCase{instruction: "MOVB ·Mutable+3(SB),AH", source: 1, gp: 1, high: true},
+		numericalExecutionCase{instruction: "MOVB internal∕cpu·X86+64(SB),AL", source: 1, gp: 1, cpu: true},
+		numericalExecutionCase{instruction: "MOVB ·Mutable+3(SB),AL", source: 1, gp: 1, dead: true},
+	)
+	for index := range cases {
+		cases[index].name = fmt.Sprintf("Read%02d", index)
+	}
+	return cases
+}
+
+func numericalExecutionFixture(t *testing.T, arch string) (GoPackage, *File, Options, []numericalExecutionCase) {
+	t.Helper()
+	_, profile, _, _ := numericalSBFixture(t, arch)
+	ownerDirectory := profile.Directory
+	if err := os.Remove(filepath.Join(ownerDirectory, profile.AssemblyFile)); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(ownerDirectory, "value.go"), []byte("package numericalfixture\nvar Mutable [32]byte\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	profile.Directory = filepath.Join(ownerDirectory, "consumer")
+	if err := os.Mkdir(profile.Directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	cases := numericalExecutionCases(arch)
+	move, word, seed := "MOVQ", "uint64", "0x8877665544332211"
+	if arch == "386" {
+		move, word, seed = "MOVL", "uint32", "0x44332211"
+	}
+	var declarations, assembly strings.Builder
+	declarations.WriteString("package consumer\nimport owner \"example.invalid/numericalfixture\"\nvar _ = owner.Mutable\n")
+	assembly.WriteString("#include \"textflag.h\"\n")
+	for _, test := range cases {
+		instruction := strings.ReplaceAll(test.instruction, "·Mutable", "example·invalid∕numericalfixture·Mutable")
+		register := test.register
+		if register == "" {
+			register = "AX"
+		}
+		fmt.Fprintf(&declarations, "func %s() %s\n", test.name, word)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),NOSPLIT,$0-%d\n%s $%s,%s\n%s\n",
+			test.name, goWordSize(arch), move, seed, register, instruction)
+		if register != "AX" {
+			fmt.Fprintf(&assembly, "%s %s,AX\n", move, register)
+		}
+		if test.compare {
+			fmt.Fprintf(&assembly, "SET%s CL\nMOVBLZX CL,AX\n", test.predicate)
+		}
+		if test.dead {
+			assembly.WriteString("MOVL $7,AX\n")
+		}
+		fmt.Fprintf(&assembly, "%s AX,ret+0(FP)\nRET\n", move)
+	}
+	goSources := map[string]string{
+		"value.go": declarations.String(),
+		"other.go": "package consumer\nvar Sentinel = byte(0x5a)\n",
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range []string{"value.go", "other.go"} {
+		filename := filepath.Join(profile.Directory, name)
+		data := []byte(goSources[name])
+		if err := os.WriteFile(filename, data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		file, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	if err := os.WriteFile(filepath.Join(profile.Directory, profile.AssemblyFile), []byte(assembly.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	// All fixture bytes, including the consumer, exist before the owned module's
+	// complete-source inventory is captured. Later work is read-only.
+	var owners []*GoNumericalStorageOwner
+	exports := make(map[string]string)
+	for _, request := range []GoNumericalStorageCaptureRequest{
+		{GoBinary: profile.GoBinary, Directory: ownerDirectory, PackagePath: "example.invalid/numericalfixture", Target: profile.Target,
+			Environment: profile.Environment, Variables: []GoNumericalStorageReference{{PackagePath: "example.invalid/numericalfixture", Name: "Mutable"}}},
+		{GoBinary: profile.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(profile.GoBinary)), "src", "internal", "cpu"),
+			PackagePath: "internal/cpu", Target: profile.Target, Environment: profile.Environment, SDKCPU: true,
+			Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}}},
+	} {
+		owner, err := CaptureGoNumericalStorageOwner(ctx, request)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(owner.Close)
+		owners = append(owners, owner)
+		observation, err := owner.observation.Readback(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+		decoder := json.NewDecoder(bytes.NewReader(observation.RawSelection))
+		for decoder.More() {
+			var selected goAMD64FrameSelection
+			if err := decoder.Decode(&selected); err != nil {
+				t.Fatal(err)
+			}
+			if selected.Export != "" {
+				exports[selected.ImportPath] = selected.Export
+			}
+		}
+	}
+	importer := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		filename, found := exports[path]
+		if !found {
+			return nil, fmt.Errorf("actual selected owner export missing for %s", path)
+		}
+		return os.Open(filename)
+	})
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch), Importer: importer}).Check("example.invalid/numericalfixture/consumer", fset, syntax, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax, Imports: make(map[string]*types.Package)}
+	for _, dependency := range typed.Imports() {
+		pkg.Imports[dependency.Path()] = dependency
+	}
+	file, err := Parse(ArchAMD64, strings.Replace(assembly.String(), "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: arch, TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: make(map[string]FuncSig), ResolveSym: func(symbol string) string { return numericalNativeName(symbol, pkg.Path) }}
+	if arch == "386" {
+		options.TargetTriple = "i386-unknown-linux-gnu"
+	}
+	for _, test := range cases {
+		name := pkg.Path + "." + test.name
+		sig, err := DeriveGoFuncABI0Signature(name, typed.Scope().Lookup(test.name).(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[name] = sig
+	}
+	source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+		GoBinary: profile.GoBinary, Directory: profile.Directory, PackagePath: pkg.Path, AssemblyFile: profile.AssemblyFile,
+		Target: profile.Target, Environment: profile.Environment, Owners: owners,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil || len(source.reads) != len(cases) {
+		t.Fatal("complete actual two-Go-file family did not bind", err, len(source.reads))
+	}
+	return pkg, file, bound, cases
+}
+
+func numericalFamilyTranslate(t *testing.T, api string, pkg GoPackage, file *File, options Options) string {
+	t.Helper()
+	if api == "text" {
+		ir, err := Translate(file, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return ir
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	var module llvm.Module
+	var err error
+	switch api {
+	case "module":
+		module, err = TranslateModule(file, options)
+	case "context":
+		module, err = TranslateModuleInContext(context, file, options)
+	case "go-module":
+		source := options.NumericalReads.source
+		data, readErr := os.ReadFile(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+		if readErr != nil {
+			t.Fatal(readErr)
+		}
+		goos, _, target := strings.Cut(source.request.Target, "/")
+		if !target {
+			t.Fatal("actual numerical source target has no OS/architecture", source.request.Target)
+		}
+		result, translateErr := translateGoModuleInContext(context, pkg, data, GoModuleOptions{
+			GOARCH: options.Goarch, GOOS: goos, TargetTriple: options.TargetTriple,
+			FileName: source.request.AssemblyFile, NumericalReads: options.NumericalReads, ResolveSym: options.ResolveSym,
+		})
+		err = translateErr
+		if result != nil {
+			module = result.Module
+			for _, fn := range result.Functions {
+				if _, found := result.Signatures[fn.ResolvedSymbol]; !found || module.NamedFunction(fn.ResolvedSymbol).IsNil() {
+					module.Dispose()
+					t.Fatal("Go wrapper function/signature/module identities disagree", fn)
+				}
+			}
+		}
+	default:
+		t.Fatal("unknown numerical family API", api)
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if module.IsNil() {
+		t.Fatal("successful numerical family returned no module")
+	}
+	defer module.Dispose()
+	return module.String()
+}
+
+func numericalLLVM22Axes(t *testing.T, ir, triple string, run func(*testing.T, string, string)) {
+	t.Helper()
+	llc, opt := findLLVM22Tool("llc"), findLLVM22Tool("opt")
+	if llc == "" || opt == "" {
+		t.Fatal("LLVM22 llc and opt required")
+	}
+	for _, passes := range []string{"none", "O2"} {
+		t.Run("IR-"+passes, func(t *testing.T) {
+			dir := t.TempDir()
+			input := filepath.Join(dir, "input.ll")
+			if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if passes == "O2" {
+				optimized := filepath.Join(dir, "optimized.ll")
+				x86FloatCompareCaptureCommand(t, exec.Command(opt, "-passes=default<O2>", "-S", input, "-o", optimized))
+				input = optimized
+			}
+			for _, backend := range []string{"-O0", "-O2"} {
+				t.Run("backend"+backend, func(t *testing.T) {
+					object := filepath.Join(t.TempDir(), "numerical.o")
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, backend, "-mtriple="+triple, "-filetype=obj", input, "-o", object))
+					if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+						t.Fatal("LLVM22 produced no real object", err)
+					}
+					if run != nil {
+						run(t, object, triple)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadCompleteFamilyLLVM22Objects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg, file, options, cases := numericalExecutionFixture(t, arch)
+			for _, api := range []string{"text", "module", "context", "go-module"} {
+				t.Run(api, func(t *testing.T) {
+					ir := numericalFamilyTranslate(t, api, pkg, file, options)
+					if strings.Count(ir, "load volatile") != len(cases) || strings.Contains(ir, "constant [") {
+						t.Fatal("complete numerical family lost mutable/dead reads")
+					}
+					numericalLLVM22Axes(t, ir, options.TargetTriple, nil)
+				})
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_fault_resources_test.go b/go_x86_numerical_read_fault_resources_test.go
new file mode 100644
index 000000000..5992d60f0
--- /dev/null
+++ b/go_x86_numerical_read_fault_resources_test.go
@@ -0,0 +1,120 @@
+//go:build go1.27 && unix
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Exercise the complete generated carriers, not isolated resource-policy text.
+// Every fault child must disable both core limits before mprotect or a call;
+// an expected SIGSEGV is an oracle result, not permission to create core files.
+func TestGoX86NumericalSBReadRuntimeFaultCorePolicy(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		cases := numericalExecutionCases(arch)
+		carriers := []struct {
+			name   string
+			source string
+		}{
+			{"mutable", numericalRuntimeC(cases, arch)},
+			{"width", numericalRuntimeWidthFaultC(cases, arch)},
+		}
+		if arch == "amd64" {
+			carriers = append(carriers, struct {
+				name   string
+				source string
+			}{"local", numericalLocalRuntimeC(0x8877665544332211)})
+		}
+		for _, carrier := range carriers {
+			t.Run(arch+"/"+carrier.name, func(t *testing.T) {
+				if !strings.Contains(carrier.source, "#include <sys/resource.h>") {
+					t.Error("complete C carrier must include its actual resource declarations")
+				}
+				if err := runtimeOracleFaultCorePolicy(carrier.source); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+// The same handler used by every carrier must observe a real synchronous fault
+// in its protected range. Raised signals, another range, normal returns and
+// malformed signal metadata are independently rejected by the compiled helper.
+func TestGoX86NumericalSBReadRuntimeFaultObservation(t *testing.T) {
+	_, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 clang required for the actual fault observation")
+	}
+	source := `#include <stdint.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + numericalRuntimeFaultObservationC + `
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<=0) return 10;
+    unsigned char *region=mmap(0,page*2,PROT_READ|PROT_WRITE,
+        MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+    if(region==MAP_FAILED) return 11;
+    for(unsigned mode=0;mode<7;mode++) {
+        pid_t child=fork();
+        if(child<0) return 12;
+        if(!child) {
+            struct rlimit no_core={0,0};
+            if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+            numerical_fault_begin(mode==1 ? region+page : region,page);
+            struct rlimit observed;
+            if(getrlimit(RLIMIT_CORE,&observed) || observed.rlim_cur ||
+                observed.rlim_max) _exit(124);
+            if(mode==2) {
+                raise(SIGSEGV);
+                _exit(125);
+            }
+            if(mode==3) _exit(0);
+            if(mode>=4) {
+                siginfo_t info;
+                memset(&info,0,sizeof(info));
+                info.si_signo=mode==4 ? SIGBUS : SIGSEGV;
+                info.si_code=mode==5 ? 0 : 1;
+                info.si_addr=mode==6 ? region+page : region;
+                numerical_fault_observe(SIGSEGV,&info,0);
+                _exit(126);
+            }
+            if(mprotect(region,page,PROT_NONE)) _exit(127);
+            volatile unsigned char value=*region;
+            _exit(value);
+        }
+        int status=0;
+        if(waitpid(child,&status,0)!=child) return 13;
+        if(!WIFEXITED(status)) return 14;
+        int expected=mode==0 ? 123 : mode==3 ? 0 : 121;
+        if(WEXITSTATUS(status)!=expected) return 15;
+        if(numerical_fault_status(status)!=(mode==0)) return 16;
+    }
+    return munmap(region,page*2)!=0;
+}
+`
+	directory := t.TempDir()
+	input, executable := filepath.Join(directory, "fault.c"), filepath.Join(directory, "fault")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			x86FloatCompareCaptureCommand(t, runtimeOracleNativeCCommand(t, ctx, clang, level, input, "-o", executable))
+			if output := x86FloatCompareCaptureCommand(t, exec.Command(executable)); len(output) != 0 {
+				t.Fatal("unexpected numerical fault-observation output", string(output))
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_floating_declaration_test.go b/go_x86_numerical_read_floating_declaration_test.go
new file mode 100644
index 000000000..fcfbe83d0
--- /dev/null
+++ b/go_x86_numerical_read_floating_declaration_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const numericalFloatingDeclarations = `
+type Small float32
+type Wide float64
+type SmallAlias = float32
+type WideAlias = float64
+func Direct32(x float32) float32
+func Direct64(x float64) float64
+func Named32(x Small) Small
+func Named64(x Wide) Wide
+func Alias32(x SmallAlias) SmallAlias
+func Alias64(x WideAlias) WideAlias
+`
+
+// This independent type/source model is deliberately not a live factory.
+// It exercises the bounded declaration adapter on every supported Go version;
+// the separate current-SDK tests own actual compiler/archive/source evidence.
+func numericalFloatingDeclarationModel(t *testing.T, arch, declarations string) (*GoX86NumericalReadSource, GoPackage) {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	filename := filepath.Join(directory, "source.go")
+	data := []byte("package floatingmodel\n" + declarations)
+	if err := os.WriteFile(filename, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	pkg := numericalFloatingDeclarationPackage(t, arch, "example.invalid/floatingmodel", string(data))
+	guard := &GoAMD64FrameSource{request: GoAMD64FrameCaptureRequest{Directory: directory},
+		selection: goAMD64FrameSelection{GoFiles: []string{"source.go"}, CompiledGoFiles: []string{filename}},
+		inputs:    map[string][32]byte{filename: sha256.Sum256(data)}, imports: make(map[string]goAMD64FrameSelection)}
+	return &GoX86NumericalReadSource{guard: guard, role: numericalSBOwnedSource,
+		request: GoX86NumericalReadCaptureRequest{Directory: directory, PackagePath: pkg.Path}}, pkg
+}
+
+func numericalFloatingDeclarationPackage(t *testing.T, arch, path, source string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "supplied.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check(path, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: path, Types: typed, Syntax: []*ast.File{syntax}}
+}
+
+func TestGoX86NumericalFloatingScalarDeclarationFramework(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, pkg := numericalFloatingDeclarationModel(t, arch, numericalFloatingDeclarations)
+			declarations, err := source.numericalDeclarations(context.Background(), pkg, arch)
+			if err != nil || len(declarations) != 6 {
+				t.Fatal("bounded numerical declaration adapter excludes ordinary scalar F32/F64", err, len(declarations))
+			}
+			for name, declaration := range declarations {
+				floating, result := LLVMType("float"), int64(4)
+				if strings.HasSuffix(name, "64") {
+					floating, result = LLVMType("double"), 8
+				} else if arch == "amd64" {
+					result = 8
+				}
+				sig := declaration.signature
+				if declaration.transport == goAMD64FrameNumericTransport || !strings.Contains(declaration.languageType, "float") ||
+					!reflect.DeepEqual(sig.Args, []LLVMType{floating}) || sig.Ret != floating || len(sig.ArgRegs) != 0 ||
+					len(sig.Frame.Params) != 1 || sig.Frame.Params[0].Offset != 0 || sig.Frame.Params[0].Type != floating ||
+					len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != result || sig.Frame.Results[0].Type != floating ||
+					sig.amd64GoArguments != nil || sig.x86FixedLocal != nil || sig.x86CallerRegions != nil {
+					t.Fatal("scalar language/layout identity became NUM or native/caller/entry authority", name, declaration)
+				}
+			}
+			for _, numericOnly := range []bool{false, true} {
+				if observed, err := source.guard.typedDeclarationsForArchRole(pkg, numericOnly, arch, false, nil); observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("numerical-only floating observer widened the ordinary frame issuer", numericOnly, err)
+				}
+			}
+			for _, change := range []struct{ from, to string }{{"float64", "uint64"}, {"float32", "float64"}} {
+				changed := numericalFloatingDeclarationPackage(t, arch, pkg.Path, "package floatingmodel\n"+
+					strings.ReplaceAll(numericalFloatingDeclarations, change.from, change.to))
+				if observed, err := source.numericalDeclarations(context.Background(), changed, arch); observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("equal-width integer/precision mutation retained actual floating language identity", change, err)
+				}
+			}
+			if err := source.Verify(context.Background()); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("pure declaration model manufactured a live source/archive capability", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalFloatingScalarFrameworkKeepsOtherLanguageRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, spelling := range []string{"string", "complex64", "complex128", "[2]float32", "struct { X float64 }", "*float64", "[]float32"} {
+			t.Run(arch+"/"+spelling, func(t *testing.T) {
+				source, pkg := numericalFloatingDeclarationModel(t, arch, "func Feature(x "+spelling+") uint32\n")
+				if observed, err := source.numericalDeclarations(context.Background(), pkg, arch); observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("ordinary scalar observer borrowed composite/argument-carrier/pointee roles", spelling, err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_numerical_read_floating_source_go127_test.go b/go_x86_numerical_read_floating_source_go127_test.go
new file mode 100644
index 000000000..d55a5e192
--- /dev/null
+++ b/go_x86_numerical_read_floating_source_go127_test.go
@@ -0,0 +1,322 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This is an actual ordinary owned module and complete original Go archive,
+// not a fabricated SDK token or an ABIInternal argument-carrier observation.
+func numericalFloatingSourceFixture(t *testing.T, arch, declarations, body string, functions int) (
+	context.Context, *GoX86NumericalReadSource, GoPackage, *File, Options,
+) {
+	t.Helper()
+	ownerRequest, readRequest := numericalMutableFixture(t, arch, "MOVB DATA+3(SB),AL")
+	goSource := "package consumer\n" + declarations
+	if err := os.WriteFile(filepath.Join(readRequest.Directory, "value.go"), []byte(goSource), 0600); err != nil {
+		t.Fatal(err)
+	}
+	assembly := "#include \"textflag.h\"\n#include \"local.h\"\n" + body
+	if err := os.WriteFile(filepath.Join(readRequest.Directory, readRequest.AssemblyFile), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	actual, err := goasmcmd.Run(ctx, readRequest.Directory, readRequest.Environment, readRequest.GoBinary,
+		"list", "-export", "-compiled", "-mod=readonly", "-json", ".")
+	var selected goAMD64FrameSelection
+	if err != nil || json.Unmarshal(actual, &selected) != nil || selected.Export == "" ||
+		selected.ImportPath != readRequest.PackagePath || !reflect.DeepEqual(selected.SFiles, []string{readRequest.AssemblyFile}) {
+		t.Fatal("independent actual original Go package/archive prerequisite failed", err, selected)
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil || len(archive) == 0 {
+		t.Fatal("actual original compiler/ASM archive is absent", err)
+	}
+	builtins, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(readRequest.GoBinary)),
+		"src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	members, err := gostaticstorage.ObserveX86AssemblyArchive(archive, builtins, readRequest.Target, selected.SFiles)
+	if err != nil || len(members) != 3 || len(members[2].Texts) != functions {
+		t.Fatal("independent complete original archive/ABI0 TEXT prerequisite failed", err, len(members))
+	}
+	for _, text := range members[2].Texts {
+		if text.ABI != 0 || len(text.Code) == 0 || text.Size != int64(len(text.Code)) {
+			t.Fatal("ordinary scalar source acquired a different native ABI", text)
+		}
+	}
+	t.Logf("original %s sourceSHA=%x archiveSHA=%x ASMentries=%d", arch,
+		sha256.Sum256([]byte(goSource+assembly)), sha256.Sum256(archive), functions)
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal("actual independent mutable numerical owner prerequisite failed", err)
+	}
+	t.Cleanup(owner.Close)
+	readRequest.Owners = []*GoNumericalStorageOwner{owner}
+	source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+	if err != nil {
+		t.Fatal("complete original Go/source/native/numerical-read observation failed", err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	if len(source.file.Funcs) != functions || len(source.reads) != functions {
+		t.Fatal("the complete original source/read inventory was cropped", len(source.file.Funcs), len(source.reads), functions)
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filepath.Join(readRequest.Directory, "value.go"), goSource, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check(readRequest.PackagePath, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal("independent original scalar typecheck failed", err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}
+	options := Options{Goarch: arch, TargetTriple: numericalSDKTargetTriple(readRequest.Target),
+		Sigs: make(map[string]FuncSig), ResolveSym: func(symbol string) string { return numericalNativeName(symbol, pkg.Path) }}
+	for _, fn := range source.file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		declared, ok := typed.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			t.Fatal("complete actual declaration is absent", name)
+		}
+		sig, err := DeriveGoFuncABI0Signature(pkg.Path+"."+name, declared, arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	return ctx, source, pkg, source.file, options
+}
+
+func numericalFloatingSourceBody(arch string) string {
+	var body strings.Builder
+	for _, name := range []string{"Direct32", "Direct64", "Named32", "Named64", "Alias32", "Alias64"} {
+		move, width := "MOVSS", int64(4)
+		if strings.HasSuffix(name, "64") {
+			move, width = "MOVSD", 8
+		}
+		result := width
+		if arch == "amd64" && result == 4 {
+			result = 8
+		}
+		fmt.Fprintf(&body, "TEXT ·%s(SB),NOSPLIT,$0-%d\nMOVB DATA+3(SB),AL\n%s x+0(FP),X0\n%s X0,ret+%d(FP)\nRET\n",
+			name, result+width, move, move, result)
+	}
+	return body.String()
+}
+
+func TestGoX86NumericalReadOrdinaryFloatingScalarSourceDeclarations(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, source, pkg, file, options := numericalFloatingSourceFixture(t, arch,
+				numericalFloatingDeclarations, numericalFloatingSourceBody(arch), 6)
+			for name, sig := range options.Sigs {
+				floating, width, result := LLVMType("float"), int64(4), int64(4)
+				if strings.HasSuffix(name, "64") {
+					floating, width, result = LLVMType("double"), 8, 8
+				} else if arch == "amd64" {
+					result = 8
+				}
+				if !reflect.DeepEqual(sig.Args, []LLVMType{floating}) || sig.Ret != floating ||
+					len(sig.Frame.Params) != 1 || sig.Frame.Params[0].Type != floating || sig.Frame.Params[0].Offset != 0 ||
+					len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Type != floating || sig.Frame.Results[0].Offset != result ||
+					frameTypeSize(floating, int64(goWordSize(arch))) != width {
+					t.Fatal("ordinary actual F32/F64 ABI0 slots were replaced by integer bits", name, sig)
+				}
+			}
+			declarations, err := source.numericalDeclarations(ctx, pkg, arch)
+			if err != nil || len(declarations) != 6 {
+				t.Fatal("ordinary numerical source cannot observe the complete actual floating declarations", err, len(declarations))
+			}
+			for name, declaration := range declarations {
+				if !reflect.DeepEqual(declaration.signature, options.Sigs[name]) ||
+					declaration.transport == goAMD64FrameNumericTransport || !strings.Contains(declaration.languageType, "float") {
+					t.Fatal("floating language identity became integer transport or changed its actual layout", name, declaration)
+				}
+			}
+			bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+			if err != nil || bound.NumericalReads == nil {
+				t.Fatal("actual floating source declaration did not join its independent numerical read", err)
+			}
+			for name, sig := range bound.Sigs {
+				if !reflect.DeepEqual(sig, options.Sigs[name]) || len(sig.ArgRegs) != 0 ||
+					sig.amd64GoArguments != nil || sig.x86FixedLocal != nil || sig.x86CallerRegions != nil {
+					t.Fatal("ordinary floating declaration gained register/caller/native-frame authority", name)
+				}
+			}
+			numericalFloatingSourceDriftGuards(t, ctx, source, pkg, file, options)
+		})
+	}
+}
+
+func numericalFloatingSourceDriftGuards(t *testing.T, ctx context.Context, source *GoX86NumericalReadSource,
+	pkg GoPackage, file *File, options Options,
+) {
+	t.Helper()
+	for _, numericOnly := range []bool{false, true} {
+		if declarations, err := source.guard.typedDeclarationsForArchRole(pkg, numericOnly, options.Goarch, false, nil); declarations != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("numerical scalar observation widened the ordinary/native fixed-local frame issuer", numericOnly, err)
+		}
+	}
+	for _, change := range []struct{ name, from, to string }{
+		{"same-width integer", "float64", "uint64"},
+		{"precision", "float32", "float64"},
+	} {
+		fset := token.NewFileSet()
+		syntax, err := parser.ParseFile(fset, "supplied.go", "package consumer\n"+
+			strings.ReplaceAll(numericalFloatingDeclarations, change.from, change.to), 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		typed, err := (&types.Config{Sizes: types.SizesFor("gc", options.Goarch)}).Check(pkg.Path, fset, []*ast.File{syntax}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		changed := GoPackage{Path: pkg.Path, Types: typed, Syntax: []*ast.File{syntax}}
+		if declarations, err := source.numericalDeclarations(ctx, changed, options.Goarch); declarations != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed same-size/precision language source retained the observed declaration", change.name, err)
+		}
+	}
+	for _, change := range []string{"integer signature", "slot", "register ABI"} {
+		changed := options
+		var err error
+		changed.Sigs, err = numericalCloneSignatures(options.Sigs)
+		if err != nil {
+			t.Fatal(err)
+		}
+		name := pkg.Path + ".Direct64"
+		sig := changed.Sigs[name]
+		switch change {
+		case "integer signature":
+			sig.Args[0], sig.Ret = I64, I64
+			sig.Frame.Params[0].Type, sig.Frame.Results[0].Type = I64, I64
+		case "slot":
+			sig.Frame.Params[0].Offset++
+		case "register ABI":
+			sig.ArgRegs = []Reg{"X0"}
+		}
+		changed.Sigs[name] = sig
+		if bound, err := source.BindNumericalReads(ctx, pkg, file, changed); bound.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed floating ABI/layout acquired the observed source binding", change, err)
+		}
+	}
+	changedFile := *file
+	changedFile.Funcs = append([]Func(nil), file.Funcs...)
+	changedFile.Funcs[0].Sym += "<ABIInternal>"
+	if bound, err := source.BindNumericalReads(ctx, pkg, &changedFile, options); bound.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("ordinary floating ABI0 source changed to an unobserved ABIInternal entry", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("negative supplied declarations changed the actual immutable source", err)
+	}
+}
+
+func TestGoX86NumericalReadFloatingScalarDoesNotAdmitCompositeSourceRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, typ := range []struct {
+			name, spelling string
+			bytes          int64
+		}{
+			{"string", "string", 2 * int64(goWordSize(arch))},
+			{"complex", "complex64", 8},
+			{"aggregate", "[2]uint32", 8},
+			{"floating-pointee", "*float64", int64(goWordSize(arch))},
+			{"floating-slice", "[]float32", 3 * int64(goWordSize(arch))},
+		} {
+			t.Run(arch+"/"+typ.name, func(t *testing.T) {
+				body := fmt.Sprintf("TEXT ·Feature(SB),NOSPLIT,$0-%d\nMOVB DATA+3(SB),AL\nMOVL $0,ret+%d(FP)\nRET\n",
+					typ.bytes+4, typ.bytes)
+				ctx, source, pkg, _, _ := numericalFloatingSourceFixture(t, arch,
+					"func Feature(x "+typ.spelling+") uint32\n", body, 1)
+				if declarations, err := source.numericalDeclarations(ctx, pkg, arch); declarations != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("ordinary floating scalar role admitted actual string/complex/aggregate source", typ.name, err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86NumericalReadOriginalSDKMathExpFloatingABI0(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "math")
+	original, err := os.ReadFile(filepath.Join(request.Directory, "exp_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("complete original SDK math/exp ASM SHA256=%x", sha256.Sum256(original))
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment, SDKGlobals: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "math", Name: "useFMA"}},
+	})
+	if err != nil {
+		t.Fatal("independent actual SDK choice-byte owner prerequisite failed", err)
+	}
+	t.Cleanup(owner.Close)
+	data, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete actual original SDK source/archive/layout prerequisite failed", err)
+	}
+	t.Cleanup(func() {
+		if err := data.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	literals, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, data)
+	if err != nil {
+		t.Fatal("complete original SDK literal owner prerequisite failed", err)
+	}
+	t.Cleanup(func() {
+		if err := literals.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	pkg, file, options := numericalSDKLiteralPackage(t, data, "exp_amd64.s")
+	sig := options.Sigs["math.archExp"]
+	if len(file.Funcs) != 1 || !reflect.DeepEqual(sig.Args, []LLVMType{"double"}) || sig.Ret != "double" ||
+		len(sig.Frame.Params) != 1 || sig.Frame.Params[0].Type != "double" || sig.Frame.Params[0].Offset != 0 ||
+		len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Type != "double" || sig.Frame.Results[0].Offset != 8 {
+		t.Fatal("original SDK ordinary float64 declaration/ABI0 layout changed", sig)
+	}
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment, AssemblyFile: "exp_amd64.s",
+		Owners: []*GoNumericalStorageOwner{owner}, ReadonlyLiterals: literals,
+	})
+	if err != nil {
+		t.Fatal("complete original SDK native/numerical-read capture failed", err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	if len(source.reads) != 1 || source.reads[0].width != 1 || source.reads[0].variable.NativeName != "math.useFMA" {
+		t.Fatal("float64 parameters or literal pools acquired numerical global-read identity", source.reads)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil || bound.NumericalReads == nil {
+		t.Fatal("ordinary original SDK float64 declaration cannot bind its actual choice-byte read", err)
+	}
+	if !reflect.DeepEqual(bound.Sigs["math.archExp"], sig) || len(sig.ArgRegs) != 0 ||
+		sig.amd64GoArguments != nil || sig.x86FixedLocal != nil || sig.x86CallerRegions != nil {
+		t.Fatal("ordinary SDK floating ABI0 source acquired another entry/caller/frame role")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete original SDK source/read binding changed its live source", err)
+	}
+}
diff --git a/go_x86_numerical_read_forms_test.go b/go_x86_numerical_read_forms_test.go
new file mode 100644
index 000000000..71b31c048
--- /dev/null
+++ b/go_x86_numerical_read_forms_test.go
@@ -0,0 +1,150 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This directory is independent of the production spec and shared extension
+// grammar. Width/mode expectations come from complete stock-Go encoder rows.
+var numericalSBOracleRows = []struct {
+	op, table, prefix, bytes string
+	source, gp               int64
+	rejected386              bool
+}{
+	{"MOVB", "ymovb", "Pb", "0x88, 0x8a, 0xb0, 0xc6, 00", 1, 1, false},
+	{"MOVW", "ymovw", "Pe", "0x89, 0x8b, 0xb8, 0xc7, 00, 0", 2, 2, false},
+	{"MOVL", "ymovl", "Px", "0x89, 0x8b, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0", 4, 4, false},
+	{"MOVQ", "ymovq", "Pw8", "0x6f, 0x7f, Pf2, 0xd6, Pf3, 0x7e, Pe, 0xd6, 0x89, 0x8b, 0xb8, 0xc7, 00, 0x6e, 0x7e, Pe, 0x6e, Pe, 0x7e, 0", 8, 8, true},
+	{"MOVBWSX", "ymb_rl", "Pq", "0xbe", 1, 2, false},
+	{"MOVBWZX", "ymb_rl", "Pq", "0xb6", 1, 2, false},
+	{"MOVBLSX", "ymb_rl", "Pm", "0xbe", 1, 4, false},
+	{"MOVBLZX", "ymb_rl", "Pm", "0xb6", 1, 4, false},
+	{"MOVBQSX", "ymb_rl", "Pw", "0x0f, 0xbe", 1, 8, true},
+	{"MOVBQZX", "ymb_rl", "Pw", "0x0f, 0xb6", 1, 8, true},
+	{"MOVWLSX", "yml_rl", "Pm", "0xbf", 2, 4, false},
+	{"MOVWLZX", "yml_rl", "Pm", "0xb7", 2, 4, false},
+	{"MOVWQSX", "yml_rl", "Pw", "0x0f, 0xbf", 2, 8, true},
+	{"MOVWQZX", "yml_rl", "Pw", "0x0f, 0xb7", 2, 8, true},
+	{"MOVLQSX", "yml_rl", "Pw", "0x63", 4, 8, true},
+	{"MOVLQZX", "yml_rl", "Px", "0x8b", 4, 8, false},
+	{"MOVSWW", "ymb_rl", "Pe", "0x0f, 0xbf", 2, 2, false},
+	{"MOVZWW", "ymb_rl", "Pe", "0x0f, 0xb7", 2, 2, false},
+	{"CMPB", "ycmpb", "Pb", "0x3c, 0x80, 07, 0x38, 0x3a", 1, 1, false},
+	{"CMPW", "ycmpl", "Pe", "0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b", 2, 2, false},
+	{"CMPL", "ycmpl", "Px", "0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b", 4, 4, false},
+	{"CMPQ", "ycmpl", "Pw", "0x83, 07, 0x3d, 0x81, 07, 0x39, 0x3b", 8, 8, true},
+}
+
+func TestGoX86NumericalSBReadCompleteIndependentGoEncoderAttributes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, body := range map[string]string{
+		"ymovb": `{Zr_m, 1, argList{Yrb, Ymb}}, {Zm_r, 1, argList{Ymb, Yrb}},
+{Zib_rp, 1, argList{Yi32, Yrb}}, {Zibo_m, 2, argList{Yi32, Ymb}},`,
+		"ymovw": `{Zr_m, 1, argList{Yrl, Yml}}, {Zm_r, 1, argList{Yml, Yrl}},
+{Zil_rp, 1, argList{Yi32, Yrl}}, {Zilo_m, 2, argList{Yi32, Yml}}, {Zaut_r, 2, argList{Yiauto, Yrl}},`,
+		"ymovl": `{Zr_m, 1, argList{Yrl, Yml}}, {Zm_r, 1, argList{Yml, Yrl}},
+{Zil_rp, 1, argList{Yi32, Yrl}}, {Zilo_m, 2, argList{Yi32, Yml}},
+{Zm_r_xm, 1, argList{Yml, Ymr}}, {Zr_m_xm, 1, argList{Ymr, Yml}},
+{Zm_r_xm, 2, argList{Yml, Yxr}}, {Zr_m_xm, 2, argList{Yxr, Yml}}, {Zaut_r, 2, argList{Yiauto, Yrl}},`,
+		"ymovq": `{Zm_r_xm_nr, 1, argList{Ym, Ymr}}, {Zr_m_xm_nr, 1, argList{Ymr, Ym}},
+{Zm_r_xm_nr, 2, argList{Yxr, Ymr}}, {Zm_r_xm_nr, 2, argList{Yxm, Yxr}}, {Zr_m_xm_nr, 2, argList{Yxr, Yxm}},
+{Zr_m, 1, argList{Yrl, Yml}}, {Zm_r, 1, argList{Yml, Yrl}}, {Ziq_rp, 1, argList{Yi64, Yrl}},
+{Zilo_m, 2, argList{Yi32, Yml}}, {Zm_r_xm, 1, argList{Ymm, Ymr}}, {Zr_m_xm, 1, argList{Ymr, Ymm}},
+{Zm_r_xm, 2, argList{Yml, Yxr}}, {Zr_m_xm, 2, argList{Yxr, Yml}}, {Zaut_r, 1, argList{Yiauto, Yrl}},`,
+		"ymb_rl": `{Zmb_r, 1, argList{Ymb, Yrl}},`,
+		"yml_rl": `{Zm_r, 1, argList{Yml, Yrl}},`,
+		"ycmpb": `{Z_ib, 1, argList{Yal, Yi32}}, {Zm_ibo, 2, argList{Ymb, Yi32}},
+{Zm_r, 1, argList{Ymb, Yrb}}, {Zr_m, 1, argList{Yrb, Ymb}},`,
+		"ycmpl": `{Zm_ibo, 2, argList{Yml, Yi8}}, {Z_il, 1, argList{Yax, Yi32}},
+{Zm_ilo, 2, argList{Yml, Yi32}}, {Zm_r, 1, argList{Yml, Yrl}}, {Zr_m, 1, argList{Yrl, Yml}},`,
+	} {
+		start := strings.Index(string(data), "var "+table+" = []ytab{")
+		if start < 0 {
+			t.Fatal("actual Go omitted complete scalar table", table)
+		}
+		actual := strings.SplitN(strings.SplitN(string(data)[start:], "\n}", 2)[0], "[]ytab{", 2)[1]
+		actualTokens, err := x86SignedPackedFloatGoOpcodeTokens(actual)
+		wantTokens, expectedErr := x86SignedPackedFloatGoOpcodeTokens(body)
+		if err != nil || expectedErr != nil || !reflect.DeepEqual(actualTokens, wantTokens) {
+			t.Fatal("actual Go complete scalar zcase/zoffset/operand classes changed", table)
+		}
+	}
+	if len(x86NumericalSBReadSpecs) != len(numericalSBOracleRows) {
+		t.Fatal("typed numerical read inventory differs from complete independent scalar rows")
+	}
+	for _, row := range numericalSBOracleRows {
+		attribute := fmt.Sprintf("{A%s, %s, %s, opBytes{%s}}", row.op, row.table, row.prefix, row.bytes)
+		if !strings.Contains(string(data), attribute) {
+			t.Fatal("actual Go opcode prefix/attributes changed", attribute)
+		}
+	}
+}
+
+func TestGoX86NumericalSBReadTypedModeWidthAndLegalPartners(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range numericalSBOracleRows {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				instruction := row.op + " global+4(SB),AX"
+				source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+				accepted := arch != "386" || !row.rejected386
+				goAssemblerOracleOutput(t, arch, source, "", accepted)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				form, valid := x86NumericalSBReadProperties(file.Funcs[0].Instrs[1], arch)
+				gp := row.gp
+				if arch == "386" && row.op == "MOVLQZX" {
+					gp = 4
+				}
+				if valid != accepted || valid && (form.operand != 0 || form.partner != 1 || form.spec.sourceBytes != row.source || form.spec.gpBytes != gp) {
+					t.Fatalf("actual scalar memory/GP bytes or mode differ: %+v valid=%v", form, valid)
+				}
+			})
+		}
+		for _, row := range []struct {
+			instruction               string
+			goAccepted, shapeAccepted bool
+		}{
+			{"MOVB global(SB),AL", true, true},
+			{"MOVB global(SB),AH", true, true},
+			{"MOVB global(SB),R8B", arch == "amd64", arch == "amd64"},
+			{"MOVW global(SB),R8", arch == "amd64", arch == "amd64"},
+			{"CMPB global(SB),AH", true, true},
+			{"CMPB AH,global(SB)", true, true},
+			{"CMPL global(SB),$4294967295", true, true},
+			{"MOVW global(SB),AL", false, false},
+			{"MOVL global(SB),AH", false, false},
+			{"CMPW global(SB),AH", false, false},
+			{"CMPL $1,global(SB)", false, false},
+			{"MOVL global(SB),X0", true, false},
+			{"MOVQ global(SB),M0", true, false},
+			{"MOVL $global(SB),AX", true, false},
+			{"MOVL AX,global(SB)", true, false},
+		} {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\n" + row.instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", row.goAccepted)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, _, valid := x86NumericalSBReadShape(file.Funcs[0].Instrs[1], arch)
+				if valid != row.shapeAccepted {
+					t.Fatal("non-GP/address/store/illegal partner acquired observation shape", valid)
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_numerical_read_frame_guard_test.go b/go_x86_numerical_read_frame_guard_test.go
new file mode 100644
index 000000000..9ea9a89dd
--- /dev/null
+++ b/go_x86_numerical_read_frame_guard_test.go
@@ -0,0 +1,433 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func numericalFrameCopies(t *testing.T, source *GoX86NumericalReadSource) ([]gostaticstorage.TextRecord, []gostaticstorage.TextRecord, []numericalSBReadFact) {
+	t.Helper()
+	copyValue := func(value, result any) {
+		data, err := json.Marshal(value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := json.Unmarshal(data, result); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var observed, expected []gostaticstorage.TextRecord
+	var reads []numericalSBReadFact
+	copyValue(source.native.OriginalText, &observed)
+	copyValue(source.native.OriginalText, &expected)
+	copyValue(source.readFacts(), &reads)
+	return observed, expected, reads
+}
+
+type numericalFrameReentryContext struct {
+	context.Context
+	mu         sync.Mutex
+	once       sync.Once
+	closeFrame func()
+}
+
+type numericalFrameObserverCancelContext struct {
+	context.Context
+	cancel context.CancelFunc
+	once   sync.Once
+	method string
+	frame  *GoAMD64FrameSource
+	called atomic.Bool
+	locked atomic.Bool
+}
+
+func TestGoX86NumericalSBReadSourceCopyCannotBorrowGeneration(t *testing.T) {
+	pkg, file, options, create := numericalConsumerFactory(t, "amd64")
+	for _, operation := range []string{"Verify", "Bind", "Close"} {
+		t.Run(operation, func(t *testing.T) {
+			source, bound := create(t)
+			ctx := bound.NumericalReads.context
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("original live source precondition", err)
+			}
+			copySource := new(GoX86NumericalReadSource)
+			reflect.ValueOf(copySource).Elem().Set(reflect.ValueOf(source).Elem())
+			var err error
+			switch operation {
+			case "Verify":
+				err = copySource.Verify(ctx)
+			case "Bind":
+				var copied Options
+				copied, err = copySource.BindNumericalReads(ctx, pkg, file, options)
+				if copied.NumericalReads != nil {
+					t.Error("copied source issued a new self-identifying numerical read token")
+				}
+			case "Close":
+				err = copySource.Close()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("copied source borrowed the original generation for %s: %v", operation, err)
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Error("rejecting a copied source revoked or removed the original owner's artifacts", err)
+			}
+		})
+	}
+}
+
+func numericalFrameObserverRoute(owner string) bool {
+	// The public owner may sample through a private lifetime helper. Follow
+	// the complete route, including inlined frames, while retaining the exact
+	// observer role: an unrelated or outer numerical callback cannot trigger it.
+	var callers [32]uintptr
+	count := runtime.Callers(2, callers[:])
+	frames := runtime.CallersFrames(callers[:count])
+	for {
+		frame, more := frames.Next()
+		if strings.HasSuffix(frame.Function, owner) {
+			return true
+		}
+		if !more {
+			return false
+		}
+	}
+}
+
+func (ctx *numericalFrameObserverCancelContext) observe(method string) {
+	if method != ctx.method || !numericalFrameObserverRoute("(*GoAMD64FrameSource).verifyFrameOnly") {
+		return
+	}
+	ctx.once.Do(func() {
+		ctx.called.Store(true)
+		if !ctx.frame.mu.TryLock() {
+			ctx.locked.Store(true)
+		} else {
+			ctx.frame.mu.Unlock()
+		}
+		ctx.cancel()
+	})
+}
+
+func (ctx *numericalFrameObserverCancelContext) Err() error {
+	ctx.observe("Err")
+	return ctx.Context.Err()
+}
+
+func (ctx *numericalFrameObserverCancelContext) Deadline() (time.Time, bool) {
+	ctx.observe("Deadline")
+	return ctx.Context.Deadline()
+}
+
+func (ctx *numericalFrameObserverCancelContext) Done() <-chan struct{} {
+	ctx.observe("Done")
+	return ctx.Context.Done()
+}
+
+func TestGoX86NumericalSBReadFrameProducerCopiedFrameCannotBorrowGeneration(t *testing.T) {
+	ctx, pkg, request, _, bound, _, _ := numericalLocalFactory(t)
+	request.NumericalReads = bound.NumericalReads
+	frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer frame.Close()
+	copyFrame := new(GoAMD64FrameSource)
+	// This copies the whole opaque public value while its mutex is unlocked;
+	// neither serialization nor reconstruction of a certificate is involved.
+	reflect.ValueOf(copyFrame).Elem().Set(reflect.ValueOf(frame).Elem())
+	if err := copyFrame.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("a whole-value frame copy borrowed an independently owned generation", err)
+	}
+	if err := copyFrame.Close(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("a foreign frame generation could remove original owned artifacts", err)
+	}
+	if err := frame.Verify(ctx); err != nil {
+		t.Fatal("rejecting a copied frame invalidated the original generation", err)
+	}
+}
+
+func TestGoX86NumericalSBReadFrameProducerObserverCancellationCause(t *testing.T) {
+	for _, method := range []string{"Err", "Deadline", "Done"} {
+		t.Run(method, func(t *testing.T) {
+			ctx, pkg, request, _, bound, _, _ := numericalLocalFactory(t)
+			request.NumericalReads = bound.NumericalReads
+			frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer frame.Close()
+			inner, cancel := context.WithCancel(ctx)
+			defer cancel()
+			wrapped := &numericalFrameObserverCancelContext{Context: inner, cancel: cancel, method: method, frame: frame}
+			if err := wrapped.Err(); err != nil {
+				t.Fatal("ordinary context sample was cancelled", err)
+			}
+			wrapped.Deadline()
+			wrapped.Done()
+			if wrapped.called.Load() {
+				t.Fatal("ordinary context samples reached an unrelated frame observer")
+			}
+			if err := frame.Verify(wrapped); !errors.Is(err, context.Canceled) || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("joined observer cancellation was relabeled as a source exclusion", err)
+			}
+			if !wrapped.called.Load() || wrapped.locked.Load() {
+				t.Fatal("actual inner observer callback was absent or sampled under the frame lock")
+			}
+			if !errors.Is(frame.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("fresh context revived the cancelled frame generation")
+			}
+		})
+	}
+}
+
+func (ctx *numericalFrameReentryContext) Err() error {
+	ctx.mu.Lock()
+	callback := ctx.closeFrame
+	ctx.mu.Unlock()
+	if callback != nil && numericalFrameObserverRoute("(*GoX86NumericalReadSource).Verify") {
+		ctx.once.Do(callback)
+	}
+	return ctx.Context.Err()
+}
+
+func TestGoX86NumericalSBReadFrameProducerReentryAndContextCauses(t *testing.T) {
+	t.Run("reentry", func(t *testing.T) {
+		var wrapped *numericalFrameReentryContext
+		ctx, pkg, request, _, bound, _, _ := numericalLocalFactoryWithContext(t, func(parent context.Context) context.Context {
+			wrapped = &numericalFrameReentryContext{Context: parent}
+			return wrapped
+		})
+		request.NumericalReads = bound.NumericalReads
+		frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer frame.Close()
+		callbackReached := make(chan struct{}, 1)
+		wrapped.mu.Lock()
+		wrapped.closeFrame = func() {
+			callbackReached <- struct{}{}
+			// Check the lock at the callback, not the duration of the full
+			// source/object replay. Race instrumentation can make that replay
+			// exceed ten seconds even after this reentrant Close succeeded.
+			if !frame.mu.TryLock() {
+				t.Error("Frame lock survived an external numerical verification callback")
+				return
+			}
+			frame.mu.Unlock()
+			if err := frame.Close(); err != nil {
+				t.Error(err)
+			}
+		}
+		wrapped.mu.Unlock()
+		if err := wrapped.Err(); err != nil || len(callbackReached) != 0 {
+			t.Fatal("ordinary context observation invoked the reentry callback", err)
+		}
+		err = frame.Verify(ctx)
+		if len(callbackReached) != 1 {
+			t.Fatal("reentry fixture never reached the numerical owner callback", err)
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(frame.Verify(context.Background()), ErrProbeNeedsContext) {
+			t.Fatal("reentrant owner guard published or revived the frame", err)
+		}
+	})
+	for _, cause := range []string{"cancelled", "deadline"} {
+		t.Run(cause, func(t *testing.T) {
+			ctx, pkg, request, _, bound, _, _ := numericalLocalFactory(t)
+			request.NumericalReads = bound.NumericalReads
+			frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer frame.Close()
+			invalid, stop := context.WithCancel(ctx)
+			want := context.Canceled
+			if cause == "deadline" {
+				stop()
+				invalid, stop = context.WithDeadline(ctx, time.Now().Add(-time.Second))
+				want = context.DeadlineExceeded
+			} else {
+				stop()
+			}
+			defer stop()
+			if err := frame.Verify(invalid); !errors.Is(err, want) || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("public joined frame Verify lost actual context cause", err)
+			}
+			if !errors.Is(frame.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("fresh context revived a failed numerical frame generation")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadFrameProducerCompleteBijectionGuards(t *testing.T) {
+	_, pkg, _, file, _, numerical, _ := numericalLocalFactory(t)
+	observed, expected, reads := numericalFrameCopies(t, numerical)
+	if err := goAMD64FrameNumericalObjectJoin(observed, expected, reads); err != nil {
+		t.Fatal("actual independent original-object guard precondition", err)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func([]gostaticstorage.TextRecord, []gostaticstorage.TextRecord, *[]numericalSBReadFact)
+	}{
+		{"whole code", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Code[0] ^= 1 }},
+		{"whole source PC", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Positions[0].Line++ }},
+		{"TEXT ABI", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].ABI = 1 }},
+		{"field PC", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Relocations[0].Offset++ }},
+		{"field width", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Relocations[0].Size = 8 }},
+		{"relocation type", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Relocations[0].Type = 1 }},
+		{"target symbol", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) {
+			o[0].Relocations[0].Target.Name += "foreign"
+		}},
+		{"target ABI", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Relocations[0].Target.ABI = 1 }},
+		{"addend", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { o[0].Relocations[0].Add++ }},
+		{"missing read", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { *r = (*r)[1:] }},
+		{"duplicate read", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { *r = append(*r, (*r)[0]) }},
+		{"reordered reads", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { (*r)[0], (*r)[1] = (*r)[1], (*r)[0] }},
+		{"read instruction PC", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { (*r)[0].PC++ }},
+		{"read code", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { (*r)[0].Code[0] ^= 1 }},
+		{"read owner", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) {
+			(*r)[0].Variable.NativeName += "foreign"
+		}},
+		{"read offset", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { (*r)[0].Offset++ }},
+		{"read width", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) { (*r)[0].Width++ }},
+		{"instruction order", func(o, e []gostaticstorage.TextRecord, r *[]numericalSBReadFact) {
+			(*r)[1].Instruction = (*r)[0].Instruction
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			o, e, r := numericalFrameCopies(t, numerical)
+			test.mutate(o, e, &r)
+			if !errors.Is(goAMD64FrameNumericalObjectJoin(o, e, r), ErrProbeNeedsContext) {
+				t.Fatal("changed complete original relocation/read bijection was accepted")
+			}
+		})
+	}
+	listing := string(numerical.native.OriginalListing)
+	relocation := goAMD64FrameNumericalRelocationLine(observed[0].Relocations[0])
+	for _, mutation := range []string{"missing", "duplicate", "foreign", "reordered"} {
+		t.Run("listing "+mutation, func(t *testing.T) {
+			changed := listing
+			switch mutation {
+			case "missing":
+				changed = strings.Replace(changed, relocation, "", 1)
+			case "duplicate":
+				changed = strings.Replace(changed, relocation, relocation+"\n\t"+relocation, 1)
+			case "foreign":
+				changed = strings.Replace(changed, relocation, relocation+"foreign", 1)
+			case "reordered":
+				second := goAMD64FrameNumericalRelocationLine(observed[0].Relocations[1])
+				changed = strings.Replace(changed, relocation, "RELOCATION_PLACEHOLDER", 1)
+				changed = strings.Replace(changed, second, relocation, 1)
+				changed = strings.Replace(changed, "RELOCATION_PLACEHOLDER", second, 1)
+			}
+			origins := make(map[string]int)
+			for _, source := range numerical.cpp.Sources {
+				data, exists := numerical.native.Sources[source.File]
+				if !exists {
+					t.Fatal("actual source bytes absent from original native proof", source.File)
+				}
+				origins[source.File] = len(strings.Split(string(data), "\n"))
+			}
+			if _, err := goAMD64FrameListingWithNumericalObject([]byte(changed), file, pkg, origins, observed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed complete actual listing relocation was accepted", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadFrameProducerCopiedTokenIsNotFactoryIdentity(t *testing.T) {
+	ctx, pkg, request, _, bound, _, _ := numericalLocalFactory(t)
+	copyBinding := *bound.NumericalReads
+	request.NumericalReads = &copyBinding
+	frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if frame != nil {
+		frame.Close()
+	}
+	if frame != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("copied opaque numerical token replaced the exact live factory identity", err)
+	}
+}
+
+func numericalFrameDuringVerify(t *testing.T, frame *GoAMD64FrameSource, ctx context.Context, invalidate func()) error {
+	t.Helper()
+	finished := make(chan error, 1)
+	go func() { finished <- frame.Verify(ctx) }()
+	deadline := time.NewTimer(10 * time.Second)
+	defer deadline.Stop()
+	for {
+		select {
+		case err := <-finished:
+			t.Fatal("verification ended before the real observer round", err)
+		case <-deadline.C:
+			t.Fatal("no real locked independent frame observer round")
+		default:
+		}
+		if !frame.mu.TryLock() {
+			// The immutable metadata snapshot is brief. Require the real
+			// observer lock to remain held across a scheduling interval.
+			time.Sleep(5 * time.Millisecond)
+			if !frame.mu.TryLock() {
+				invalidate()
+				select {
+				case err := <-finished:
+					return err
+				case <-time.After(10 * time.Second):
+					t.Fatal("invalidated independent observer did not terminate")
+				}
+			}
+			frame.mu.Unlock()
+		} else {
+			frame.mu.Unlock()
+		}
+		time.Sleep(time.Millisecond)
+	}
+}
+
+func TestGoX86NumericalSBReadFrameProducerConcurrentRevocation(t *testing.T) {
+	for _, role := range []string{"owner", "source", "frame", "capture context"} {
+		t.Run(role, func(t *testing.T) {
+			ctx, pkg, request, _, bound, numerical, cancel := numericalLocalFactory(t)
+			request.NumericalReads = bound.NumericalReads
+			frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer frame.Close()
+			err = numericalFrameDuringVerify(t, frame, ctx, func() {
+				switch role {
+				case "owner":
+					numerical.originalOwners[0].Close()
+				case "source":
+					if err := numerical.Close(); err != nil {
+						t.Error(err)
+					}
+				case "frame":
+					if err := frame.Close(); err != nil {
+						t.Error(err)
+					}
+				case "capture context":
+					cancel()
+				}
+			})
+			if role == "capture context" && (!errors.Is(err, context.Canceled) || errors.Is(err, ErrProbeNeedsContext)) {
+				t.Fatal("actual capture cancellation was classified as source exclusion", err)
+			}
+			if err == nil || !errors.Is(frame.Verify(context.Background()), ErrProbeNeedsContext) {
+				t.Fatal("concurrent source/owner/frame failure revived or published an observation", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_guard_test.go b/go_x86_numerical_read_guard_test.go
new file mode 100644
index 000000000..4fe6db786
--- /dev/null
+++ b/go_x86_numerical_read_guard_test.go
@@ -0,0 +1,318 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+)
+
+func TestGoX86NumericalSBReadCompleteCommandAndReadbackReceipts(t *testing.T) {
+	ownerRequest, request := numericalMutableFixture(t, "amd64", "READ(4,AX)\nCMPB DATA+8(SB),$1")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	request.Owners = []*GoNumericalStorageOwner{owner}
+	source, err := CaptureGoX86NumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	raw, err := source.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var report struct {
+		RawSelection, RawEnvironment []byte
+		Commands                     []numericalSBCommand
+		Reads                        []numericalSBReadFact
+	}
+	if err := json.Unmarshal(raw, &report); err != nil || len(report.Commands) != 6 || len(report.Reads) != 2 {
+		t.Fatal("incomplete actual command/source/native read receipts", err)
+	}
+	for index, receipt := range report.Commands {
+		if receipt.Directory != request.Directory || receipt.Binary != request.GoBinary || len(receipt.Arguments) == 0 || len(receipt.Stdout) == 0 {
+			t.Fatal("actual command role/output was not retained", index)
+		}
+	}
+	for index, expected := range map[int][]byte{0: source.rawEnvironment, 3: source.rawSelection,
+		4: source.native.OriginalListing, 5: source.native.ExpandedListing} {
+		if !bytes.Equal(report.Commands[index].Stdout, expected) {
+			t.Fatal("retained actual whole command stdout changed", index)
+		}
+	}
+	if !bytes.Equal(report.RawSelection, source.rawSelection) || !bytes.Equal(report.RawEnvironment, source.rawEnvironment) {
+		t.Fatal("whole actual selection/environment bytes were substituted")
+	}
+	for _, read := range report.Reads {
+		if read.Owner != 0 || read.Variable.NativeName != "example.invalid/numericalfixture.Mutable" {
+			t.Fatal("portable owner ordinal/typed identity was not retained")
+		}
+	}
+	retainNumericalRead(t, source, "receipts")
+}
+
+func TestGoX86NumericalSBReadInvalidVerificationContextPermanentlyRevokes(t *testing.T) {
+	ownerRequest, request := numericalMutableFixture(t, "386", "MOVB DATA+0(SB),AL")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	request.Owners = []*GoNumericalStorageOwner{owner}
+	for _, kind := range []string{"nil", "cancelled"} {
+		t.Run(kind, func(t *testing.T) {
+			source, err := CaptureGoX86NumericalReadSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			var invalid context.Context
+			if kind == "cancelled" {
+				cancelled, stop := context.WithCancel(ctx)
+				stop()
+				invalid = cancelled
+			}
+			first := source.Verify(invalid)
+			invalidCause := ErrProbeNeedsContext
+			if kind == "cancelled" {
+				invalidCause = context.Canceled
+				if errors.Is(first, ErrProbeNeedsContext) {
+					t.Fatal("cancelled verification was classified as a source exclusion")
+				}
+			}
+			if !errors.Is(first, invalidCause) || !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("fresh context revived a failed live source verification")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadSealedOwnerOrderAndJoinMutations(t *testing.T) {
+	ownerRequest, readRequest := numericalMutableFixture(t, "amd64", "MOVB DATA+0(SB),AL")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	cpuRequest := ownerRequest
+	cpuRequest.Directory = filepath.Join(filepath.Dir(filepath.Dir(cpuRequest.GoBinary)), "src", "internal", "cpu")
+	cpuRequest.PackagePath, cpuRequest.SDKCPU = "internal/cpu", true
+	cpuRequest.Variables = []GoNumericalStorageReference{{"internal/cpu", "X86"}}
+	cpu, err := CaptureGoNumericalStorageOwner(ctx, cpuRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer cpu.Close()
+	readRequest.Owners = []*GoNumericalStorageOwner{owner, cpu}
+	for _, test := range []struct {
+		name   string
+		mutate func(*GoX86NumericalReadSource) func()
+	}{
+		{"owner order", func(s *GoX86NumericalReadSource) func() {
+			s.request.Owners[0], s.request.Owners[1] = s.request.Owners[1], s.request.Owners[0]
+			return func() { s.request.Owners[0], s.request.Owners[1] = s.request.Owners[1], s.request.Owners[0] }
+		}},
+		{"read owner rebind", func(s *GoX86NumericalReadSource) func() {
+			s.reads[0].owner = cpu
+			return func() { s.reads[0].owner = owner }
+		}},
+		{"read owner ordinal", func(s *GoX86NumericalReadSource) func() {
+			s.reads[0].ownerOrdinal++
+			return func() { s.reads[0].ownerOrdinal-- }
+		}},
+		{"source package", func(s *GoX86NumericalReadSource) func() {
+			old := s.request.PackagePath
+			s.request.PackagePath += "/other"
+			return func() { s.request.PackagePath = old }
+		}},
+		{"target profile", func(s *GoX86NumericalReadSource) func() {
+			s.request.Target = "linux/386"
+			return func() { s.request.Target = "linux/amd64" }
+		}},
+		{"actual command environment", func(s *GoX86NumericalReadSource) func() {
+			old := s.request.Environment
+			s.request.Environment = append(append([]string(nil), old...), "GOOS=darwin")
+			return func() { s.request.Environment = old }
+		}},
+		{"whole selection stdout", func(s *GoX86NumericalReadSource) func() {
+			s.rawSelection[0] ^= 1
+			return func() { s.rawSelection[0] ^= 1 }
+		}},
+		{"whole environment stdout", func(s *GoX86NumericalReadSource) func() {
+			s.rawEnvironment[0] ^= 1
+			return func() { s.rawEnvironment[0] ^= 1 }
+		}},
+		{"CPP output", func(s *GoX86NumericalReadSource) func() {
+			old := s.cpp.Output
+			s.cpp.Output += "\n"
+			return func() { s.cpp.Output = old }
+		}},
+		{"whole original native code", func(s *GoX86NumericalReadSource) func() {
+			s.native.OriginalText[0].Code[0] ^= 1
+			return func() { s.native.OriginalText[0].Code[0] ^= 1 }
+		}},
+		{"complete relocation Add", func(s *GoX86NumericalReadSource) func() {
+			s.reads[0].relocation.Add++
+			return func() { s.reads[0].relocation.Add-- }
+		}},
+		{"source read width", func(s *GoX86NumericalReadSource) func() {
+			s.reads[0].width++
+			return func() { s.reads[0].width-- }
+		}},
+		{"command directory receipt", func(s *GoX86NumericalReadSource) func() {
+			old := s.commands[0].Directory
+			s.commands[0].Directory = filepath.Dir(old)
+			return func() { s.commands[0].Directory = old }
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			restore := test.mutate(source)
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("mutated source/native/owner join kept its live seal")
+			}
+			restore()
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restoration resurrected revoked source")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadOriginalInputAndDirectoryMutations(t *testing.T) {
+	for _, kind := range []string{"assembly bytes", "active header bytes", "preferred include miss", "selected Go addition", "physical directory"} {
+		t.Run(kind, func(t *testing.T) {
+			ownerRequest, readRequest := numericalMutableFixture(t, "386", "MOVB DATA+0(SB),AL")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			readRequest.Owners = []*GoNumericalStorageOwner{owner}
+			source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			var restore func()
+			switch kind {
+			case "assembly bytes", "active header bytes":
+				name := filepath.Join(readRequest.Directory, readRequest.AssemblyFile)
+				if kind == "active header bytes" {
+					name = filepath.Join(readRequest.Directory, "local.h")
+				}
+				old, err := os.ReadFile(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(name, append(append([]byte(nil), old...), '\n'), 0600); err != nil {
+					t.Fatal(err)
+				}
+				restore = func() {
+					if err := os.WriteFile(name, old, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			case "preferred include miss", "selected Go addition":
+				name := filepath.Join(readRequest.Directory, "textflag.h")
+				data := []byte("#define NOSPLIT 4\n")
+				if kind == "selected Go addition" {
+					name = filepath.Join(readRequest.Directory, "added.go")
+					data = []byte("package consumer\nvar Added byte\n")
+				}
+				if err := os.WriteFile(name, data, 0600); err != nil {
+					t.Fatal(err)
+				}
+				restore = func() {
+					if err := os.Remove(name); err != nil {
+						t.Fatal(err)
+					}
+				}
+			case "physical directory":
+				old := readRequest.Directory + ".retained"
+				if err := os.Rename(readRequest.Directory, old); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(readRequest.Directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				restore = func() {
+					if err := os.Remove(readRequest.Directory); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Rename(old, readRequest.Directory); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("changed original source role retained the read join")
+			}
+			restore()
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restored source role resurrected revoked read join")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadConcurrentCloseAndNilOwners(t *testing.T) {
+	ownerRequest, readRequest := numericalMutableFixture(t, "amd64", "MOVB DATA+0(SB),AL")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	readRequest.Owners = []*GoNumericalStorageOwner{nil}
+	if source, err := CaptureGoX86NumericalReadSource(ctx, readRequest); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("nil owner did not return exact Context", err)
+	}
+	readRequest.Owners = []*GoNumericalStorageOwner{owner}
+	source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	var wait sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			_, _ = source.Readback(ctx)
+		}()
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	wait.Wait()
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("closed source remained live")
+	}
+	var absent *GoX86NumericalReadSource
+	if !errors.Is(absent.Verify(ctx), ErrProbeNeedsContext) || absent.Close() != nil {
+		t.Fatal("nil source was not safely rejected/closed")
+	}
+}
diff --git a/go_x86_numerical_read_linkname.go b/go_x86_numerical_read_linkname.go
new file mode 100644
index 000000000..d0148b757
--- /dev/null
+++ b/go_x86_numerical_read_linkname.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// Candidates are source spellings, not compiler or entry authority. A foreign
+// mapping is usable only with the existing live factory's compiler witness.
+type numericalGoLinknames struct {
+	localToNative map[string]string
+	nativeToLocal map[string]string
+	standard      map[string]bool
+	functions     map[string]bool
+}
+
+func numericalGoDeclarationLinknames(syntax []*ast.File, typed *types.Package) (numericalGoLinknames, error) {
+	if typed == nil || typed.Scope() == nil {
+		return numericalGoLinknames{}, numericalSBContext("linkname candidate lacks its actual Go package")
+	}
+	names, err := numericalGoLinknameSpellings(syntax, typed.Path())
+	if err != nil {
+		return names, err
+	}
+	names.functions = make(map[string]bool)
+	for local := range names.localToNative {
+		switch object := typed.Scope().Lookup(local).(type) {
+		case *types.Func:
+			if object.Pkg() != typed {
+				return names, numericalSBContext("linkname function has a foreign Go owner")
+			}
+			names.functions[local] = true
+		case *types.Var:
+			if object.Pkg() != typed {
+				return names, numericalSBContext("linkname variable has a foreign Go owner")
+			}
+		default:
+			return names, numericalSBContext("linkname candidate lacks its actual declaration")
+		}
+	}
+	prefix := gosym.PackagePrefix(typed.Path()) + "."
+	for native, local := range names.nativeToLocal {
+		if strings.HasPrefix(native, prefix) {
+			ordinary := strings.TrimPrefix(native, prefix)
+			if ordinary != local && typed.Scope().Lookup(ordinary) != nil {
+				names.nativeToLocal[native] = "" // An alias cannot shadow an independent ordinary declaration.
+			}
+		}
+	}
+	return names, nil
+}
+
+// The spelling pass is also a cost query at capture time. Its output is not
+// a declaration or compiler witness; the typed pass above remains mandatory.
+func numericalGoLinknameSpellings(syntax []*ast.File, pkg string) (numericalGoLinknames, error) {
+	names := numericalGoLinknames{localToNative: make(map[string]string),
+		nativeToLocal: make(map[string]string), standard: make(map[string]bool)}
+	for _, file := range syntax {
+		if file == nil {
+			return names, numericalSBContext("linkname candidate omitted an original Go file")
+		}
+		unsafeImported := false
+		for _, spec := range file.Imports {
+			if spec == nil || spec.Path == nil {
+				return names, numericalSBContext("linkname candidate has incomplete import syntax")
+			}
+			path, err := strconv.Unquote(spec.Path.Value)
+			unsafeImported = unsafeImported || err == nil && path == "unsafe"
+		}
+		for _, group := range file.Comments {
+			if group == nil {
+				return names, numericalSBContext("linkname candidate has incomplete comment syntax")
+			}
+			for _, comment := range group.List {
+				if comment == nil {
+					return names, numericalSBContext("linkname candidate omitted a directive")
+				}
+				text := strings.TrimPrefix(comment.Text, "//")
+				if !strings.HasPrefix(text, "go:linkname ") && !strings.HasPrefix(text, "go:linknamestd ") {
+					continue
+				}
+				fields := strings.Fields(text)
+				if !unsafeImported || len(fields) < 2 || len(fields) > 3 || !token.IsIdentifier(fields[1]) {
+					return names, numericalSBContext("linkname candidate lacks exact fields/file unsafe import")
+				}
+				local := fields[1]
+				if _, duplicate := names.localToNative[local]; duplicate {
+					return names, numericalSBContext("linkname repeats its local declaration")
+				}
+				remote := gosym.PackagePrefix(pkg) + "." + local
+				if len(fields) == 3 {
+					remote = fields[2]
+				}
+				if strings.Contains(remote, "[") && strings.Contains(remote, "]") {
+					return names, numericalSBContext("linkname instantiation needs a separate compiler role")
+				}
+				names.localToNative[local], names.standard[local] = remote, fields[0] == "go:linknamestd"
+				if _, exists := names.nativeToLocal[remote]; exists {
+					names.nativeToLocal[remote] = ""
+				} else {
+					names.nativeToLocal[remote] = local
+				}
+			}
+		}
+	}
+	return names, nil
+}
+
+type numericalSourceDeclaration struct {
+	local string
+	abi   uint16
+	entry bool
+}
+
+type numericalCompilerAliasWitness struct {
+	ABI      uint16
+	Standard bool
+}
+
+func (names numericalGoLinknames) declaration(native, pkg string, abi uint16, aliases map[string]numericalCompilerAliasWitness) (string, bool) {
+	if local, found := names.nativeToLocal[native]; found {
+		if local == "" || !names.functions[local] {
+			return "", false
+		}
+		if native != gosym.PackagePrefix(pkg)+"."+local {
+			witness, observed := aliases[native]
+			return local, observed && witness.ABI == abi && witness.Standard == names.standard[local]
+		}
+		return local, true
+	}
+	if !strings.HasPrefix(native, gosym.PackagePrefix(pkg)+".") {
+		return "", false
+	}
+	local := strings.TrimPrefix(native, gosym.PackagePrefix(pkg)+".")
+	if remote, renamed := names.localToNative[local]; renamed && remote != native {
+		return "", false
+	}
+	return local, true
+}
+
+func numericalTypedSourceDeclarations(file *File, pkg, arch string, role numericalSBSourceRole,
+	names numericalGoLinknames, aliases map[string]numericalCompilerAliasWitness,
+) (map[string]numericalSourceDeclaration, map[string]numericalSourceDeclaration, error) {
+	controls, err := numericalDirectTailRoles(file)
+	if err != nil {
+		return nil, nil, err
+	}
+	entries, terminals := make(map[string]numericalSourceDeclaration), make(map[string]numericalSourceDeclaration)
+	add := func(symbol string, terminal bool) error {
+		native, abi, valid := numericalFunctionSourceIdentity(symbol, pkg, arch, role)
+		local, declared := names.declaration(native, pkg, abi, aliases)
+		if !valid || !declared {
+			return numericalSBContext("numerical source lacks its exact Go declaration/compiler/native association")
+		}
+		declaration := numericalSourceDeclaration{local: local, abi: abi, entry: !terminal}
+		if prior, exists := entries[native]; exists {
+			if !terminal || prior.local != local || prior.abi != abi {
+				return numericalSBContext("numerical source repeats or changes its native declaration")
+			}
+			declaration.entry = prior.entry
+		}
+		if terminal {
+			terminals[native] = declaration
+		}
+		entries[native] = declaration
+		return nil
+	}
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") && len(controls) != 0 {
+			continue
+		}
+		if err := add(fn.Sym, false); err != nil {
+			return nil, nil, err
+		}
+	}
+	for _, symbol := range controls {
+		if !strings.HasSuffix(symbol, "<>") {
+			if err := add(symbol, true); err != nil {
+				return nil, nil, err
+			}
+		}
+	}
+	return entries, terminals, nil
+}
diff --git a/go_x86_numerical_read_linkname_go127_test.go b/go_x86_numerical_read_linkname_go127_test.go
new file mode 100644
index 000000000..cfd0bbab8
--- /dev/null
+++ b/go_x86_numerical_read_linkname_go127_test.go
@@ -0,0 +1,149 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Each owner retains the complete original selected Go/import/compiler graph
+// and all three unchanged assembly TEXTs. A private helper receives no fake
+// declaration or signature. This tests declaration association, not native
+// entry transport, closure storage, a complete translation or execution.
+func numericalSDKForeignDeclarationAssociation(t *testing.T, member string) {
+	t.Helper()
+	ctx, request, metadata, _ := numericalSDKAssemblyFixture(t)
+	request.AssemblyFile = member
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete original compiler/source/CPU observation", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	pkg, file, options := numericalSDKOriginalTypedPackage(t, metadata, member)
+	if len(file.Funcs) != 3 || len(file.Data) != 0 || len(file.Globl) != 0 || len(source.reads) != 1 {
+		t.Fatal("original complete member or exact CPU-read inventory changed")
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	options.Sigs, err = goSigsForAsmFile(pkg, file, options.ResolveSym, "amd64", sizes, sizes, nil)
+	if err != nil || len(options.Sigs) != 2 {
+		t.Fatal("actual two bodyless declarations/private helper inventory", err)
+	}
+	before, err := x86CallerSourceFingerprint(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil || bound.NumericalReads == nil {
+		t.Fatal("complete original local declaration/foreign TEXT association", err)
+	}
+	after, err := x86CallerSourceFingerprint(file)
+	if err != nil || before != after {
+		t.Fatal("declaration association replaced an original TEXT or instruction", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete original declaration/source observation no longer live", err)
+	}
+	if err := metadata.Verify(ctx); err != nil {
+		t.Fatal("association changed the borrowed whole compiler observation", err)
+	}
+}
+
+func TestGoX86SDKNumericalEqualForeignDeclarationAssociation(t *testing.T) {
+	numericalSDKForeignDeclarationAssociation(t, "equal_amd64.s")
+}
+
+func TestGoX86SDKNumericalCompareForeignDeclarationAssociation(t *testing.T) {
+	numericalSDKForeignDeclarationAssociation(t, "compare_amd64.s")
+}
+
+func TestGoX86SDKNumericalForeignCompilerAssociationLiveSeal(t *testing.T) {
+	for _, mutation := range []string{"witness", "symabi", "header-object", "selected-object-flags"} {
+		t.Run(mutation, func(t *testing.T) {
+			ctx, request, metadata, _ := numericalSDKAssemblyFixture(t)
+			request.AssemblyFile = "equal_amd64.s"
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			pkg, file, options := numericalSDKOriginalTypedPackage(t, metadata, request.AssemblyFile)
+			sizes := types.SizesFor("gc", "amd64")
+			options.Sigs, err = goSigsForAsmFile(pkg, file, options.ResolveSym, "amd64", sizes, sizes, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+			if err != nil || len(source.native.CompilerAliases) != 2 {
+				t.Fatal("complete compiler association precondition", err)
+			}
+			for name := range numericalCompilerAliasSchema {
+				if _, sealed := source.guard.inputs[filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(name))]; !sealed {
+					t.Fatal("selected compiler schema source was not live sealed", name)
+				}
+			}
+			original, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+			if err != nil {
+				t.Fatal(err)
+			}
+			var restore func()
+			switch mutation {
+			case "witness":
+				before := source.native.CompilerAliases["runtime.memequal"]
+				delete(source.native.CompilerAliases, "runtime.memequal")
+				restore = func() { source.native.CompilerAliases["runtime.memequal"] = before }
+			case "symabi", "header-object":
+				data := metadata.observation.Header.SymABI
+				if mutation == "header-object" {
+					data = metadata.observation.Header.CompilerObject
+				}
+				before := data[0]
+				data[0] ^= 1
+				restore = func() { data[0] = before }
+			case "selected-object-flags":
+				text := &source.native.ArchiveMembers[1].Texts[0]
+				before := text.Flags2
+				text.Flags2 ^= 16
+				restore = func() { text.Flags2 = before }
+			}
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("mutated source/compiler association stayed live", err)
+			}
+			restore()
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("restoring bytes revived a revoked compiler association", err)
+			}
+			if ir, err := Translate(file, bound); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("old text options survived compiler association revocation", err)
+			}
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := TranslateModuleInContext(context, file, bound)
+			if !module.IsNil() {
+				module.Dispose()
+				t.Fatal("revoked compiler association published a module")
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("old module options survived compiler association revocation", err)
+			}
+			translated, err := translateGoModuleInContext(context, pkg, original, GoModuleOptions{
+				GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple,
+				FileName: request.AssemblyFile, ResolveSym: bound.ResolveSym, NumericalReads: bound.NumericalReads,
+			})
+			if translated != nil {
+				if !translated.Module.IsNil() {
+					translated.Module.Dispose()
+				}
+				t.Fatal("revoked compiler association published a Go module")
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("old Go options survived compiler association revocation", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_linkname_test.go b/go_x86_numerical_read_linkname_test.go
new file mode 100644
index 000000000..3fc4cf7dc
--- /dev/null
+++ b/go_x86_numerical_read_linkname_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+const numericalAliasGoModel = `package local
+import _ "unsafe"
+//go:linkname alias example.invalid/remote.Entry
+func alias(value uint32) uint32
+`
+
+func numericalAliasLanguageModel(t *testing.T, text, packagePath string) ([]*ast.File, *types.Package) {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "decl.go", text, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := []*ast.File{file}
+	pkg, err := (&types.Config{Importer: importer.Default()}).Check(packagePath, fset, files, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return files, pkg
+}
+
+func TestNumericalSDKSelfLinknameKeepsOrdinaryABI0Role(t *testing.T) {
+	for _, directive := range []string{"//go:linkname alias", "//go:linkname alias example.invalid/local.alias", "//go:linknamestd alias"} {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+directive, func(t *testing.T) {
+				text := "package local\nimport _ \"unsafe\"\n" + directive + "\nfunc alias(value uint32) uint32\n"
+				files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+				names, err := numericalGoDeclarationLinknames(files, pkg)
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, "TEXT ·alias(SB),4,$0-8\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(numericalCompilerAliasDemand(file, pkg.Path(), names)) != 0 {
+					t.Fatal("ordinary self-linkname acquired a new compiler-wrapper requirement")
+				}
+				entries, _, err := numericalTypedSourceDeclarations(file, pkg.Path(), arch, numericalSBSDKSource, names, nil)
+				if err != nil || len(entries) != 1 || entries[pkg.Path()+".alias"].local != "alias" {
+					t.Fatal("ordinary ABI0 declaration lost its existing source role", entries, err)
+				}
+				model := numericalCompilerAliasModel(false)
+				model.ABI = 0
+				if err := numericalCompilerAliasAssociation(model); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("ordinary role was confused with the new foreign ABI1 wrapper witness", err)
+				}
+			})
+		}
+	}
+}
+
+func TestNumericalSDKVariableAliasCannotDeclareTEXT(t *testing.T) {
+	text := strings.Replace(numericalAliasGoModel, "func alias(value uint32) uint32", "var alias uint32", 1)
+	files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+	names, err := numericalGoDeclarationLinknames(files, pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := names.declaration("example.invalid/remote.Entry", pkg.Path(), 1,
+		map[string]numericalCompilerAliasWitness{"example.invalid/remote.Entry": {ABI: 1}}); ok {
+		t.Fatal("a variable directive acquired a TEXT declaration")
+	}
+}
+
+func TestNumericalSDKCompilerAliasCompleteInventoryBounds(t *testing.T) {
+	for _, which := range []string{"generated", "selected"} {
+		model := numericalCompilerAliasModel(false)
+		over := make([]gostaticstorage.TextRecord, gostaticstorage.ObjectSymbolInventoryLimit+1)
+		if which == "generated" {
+			model.Generated = over
+		} else {
+			model.Selected = over
+		}
+		if err := numericalCompilerAliasAssociation(model); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("oversized complete object inventory was retained", which, err)
+		}
+	}
+}
+
+func TestNumericalSDKLinknameCandidatesNeedCompilerAssociation(t *testing.T) {
+	for _, directive := range []string{"go:linkname", "go:linknamestd"} {
+		t.Run(directive, func(t *testing.T) {
+			text := strings.Replace(numericalAliasGoModel, "go:linkname", directive, 1)
+			files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+			names, err := numericalGoDeclarationLinknames(files, pkg)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, "TEXT example.invalid∕remote·Entry<ABIInternal>(SB),4,$0-12\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, aliases := range []map[string]numericalCompilerAliasWitness{
+				nil,
+				{"example.invalid/remote.Other": {ABI: 1}},
+				{"example.invalid/remote.Entry": {ABI: 0}},
+				{"example.invalid/remote.Entry": {ABI: 1, Standard: directive != "go:linknamestd"}},
+			} {
+				if _, _, err := numericalTypedSourceDeclarations(file, pkg.Path(), "amd64", numericalSBSDKSource, names, aliases); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("candidate directive borrowed an absent/different compiler association", aliases, err)
+				}
+			}
+			// This is only the private model's name-comparison output, not a
+			// factory witness. No ready source or public binding is created.
+			aliases := map[string]numericalCompilerAliasWitness{"example.invalid/remote.Entry": {ABI: 1, Standard: directive == "go:linknamestd"}}
+			entries, _, err := numericalTypedSourceDeclarations(file, pkg.Path(), "amd64", numericalSBSDKSource, names, aliases)
+			if err != nil || len(entries) != 1 || entries["example.invalid/remote.Entry"].local != "alias" {
+				t.Fatal("matching model association lost its distinct local/native names", entries, err)
+			}
+		})
+	}
+}
+
+func TestNumericalSDKLinknameCandidateCompleteOriginalScope(t *testing.T) {
+	for name, change := range map[string]func(string) string{
+		"unsafe-absent":   func(s string) string { return strings.Replace(s, "import _ \"unsafe\"\n", "", 1) },
+		"unknown-local":   func(s string) string { return strings.Replace(s, "linkname alias ", "linkname missing ", 1) },
+		"duplicate-local": func(s string) string { return s + "//go:linkname alias example.invalid/remote.Other\n" },
+		"extra-field":     func(s string) string { return strings.Replace(s, "remote.Entry", "remote.Entry extra", 1) },
+		"instantiation":   func(s string) string { return strings.Replace(s, "remote.Entry", "remote.Entry[int]", 1) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			files, pkg := numericalAliasLanguageModel(t, change(numericalAliasGoModel), "example.invalid/local")
+			if _, err := numericalGoDeclarationLinknames(files, pkg); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("malformed candidate acquired a declaration role", err)
+			}
+		})
+	}
+	t.Run("duplicate-remote", func(t *testing.T) {
+		text := numericalAliasGoModel + "//go:linkname other example.invalid/remote.Entry\nfunc other(value uint32) uint32\n"
+		files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+		names, err := numericalGoDeclarationLinknames(files, pkg)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, valid := names.declaration("example.invalid/remote.Entry", pkg.Path(), 1,
+			map[string]numericalCompilerAliasWitness{"example.invalid/remote.Entry": {ABI: 1}}); valid {
+			t.Fatal("two local declarations selected one native winner")
+		}
+	})
+	t.Run("shadowed-ordinary", func(t *testing.T) {
+		text := strings.Replace(numericalAliasGoModel, "example.invalid/remote.Entry", "example.invalid/local.Ordinary", 1) + "func Ordinary(value uint32) uint32\n"
+		files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+		names, err := numericalGoDeclarationLinknames(files, pkg)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, valid := names.declaration("example.invalid/local.Ordinary", pkg.Path(), 1,
+			map[string]numericalCompilerAliasWitness{"example.invalid/local.Ordinary": {ABI: 1}}); valid {
+			t.Fatal("an alias shadowed an independent ordinary declaration")
+		}
+	})
+	t.Run("file-level-not-doc-attachment", func(t *testing.T) {
+		text := strings.Replace(numericalAliasGoModel, "func alias", "var unrelated uint32\n\nfunc alias", 1)
+		files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+		names, err := numericalGoDeclarationLinknames(files, pkg)
+		if err != nil || names.nativeToLocal["example.invalid/remote.Entry"] != "alias" {
+			t.Fatal("compiler file-level candidate became a doc attachment", err)
+		}
+	})
+	t.Run("one-argument-native-prefix", func(t *testing.T) {
+		text := strings.Replace(numericalAliasGoModel, "alias example.invalid/remote.Entry", "alias", 1)
+		files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/a.b")
+		names, err := numericalGoDeclarationLinknames(files, pkg)
+		if err != nil || names.localToNative["alias"] != "example.invalid/a%2eb.alias" {
+			t.Fatal("one-argument candidate guessed a logical rather than native package prefix", names, err)
+		}
+	})
+	t.Run("unused-alias-does-not-rename-ordinary", func(t *testing.T) {
+		text := numericalAliasGoModel + "func Ordinary(value uint32) uint32\n"
+		files, pkg := numericalAliasLanguageModel(t, text, "example.invalid/local")
+		names, err := numericalGoDeclarationLinknames(files, pkg)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if local, valid := names.declaration("example.invalid/local.Ordinary", pkg.Path(), 1, nil); !valid || local != "Ordinary" {
+			t.Fatal("unrelated ordinary declaration inherited an unused alias", local, valid)
+		}
+	})
+}
diff --git a/go_x86_numerical_read_listing_kind_go127_test.go b/go_x86_numerical_read_listing_kind_go127_test.go
new file mode 100644
index 000000000..2c6445560
--- /dev/null
+++ b/go_x86_numerical_read_listing_kind_go127_test.go
@@ -0,0 +1,154 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The independent SDK raw-kind/archive oracle remains
+// internal/gostaticstorage.TestGoSDKFIPSTextKindOriginalArchive. Here the
+// complete original source, mapped source and binary records are established
+// before testing the listing consumer. No numerical owner is constructed.
+func TestGoX86NumericalNativeListingOriginalFIPSProducer(t *testing.T) {
+	const pkg = "crypto/internal/fips140/bigmod"
+	ctx, request := sdkASMDataRequest(t, "amd64", pkg)
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete actual Go FIPS source/header/archive prior", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	inputs := source.observation.ObjectInputs
+	if len(inputs.Sources) != 1 || inputs.Sources[0].Name != "nat_amd64.s" {
+		t.Fatal("original FIPS package source selection changed")
+	}
+	input := inputs.Sources[0]
+	original, err := os.ReadFile(filepath.Join(request.Directory, input.Name))
+	if err != nil || !bytes.Equal(input.Original, original) || len(original) == 0 {
+		t.Fatal("actual original assembly source was cropped or replaced", err)
+	}
+	archive, err := os.ReadFile(source.guard.selection.Export)
+	if err != nil || !bytes.Equal(archive, inputs.Archive) || len(archive) == 0 {
+		t.Fatal("actual compiler archive differs from the source observation", err)
+	}
+	stems := []string{"addMulVVW1024", "addMulVVW1536", "addMulVVW2048"}
+	for _, stem := range stems {
+		seen := make(map[uint16]bool)
+		for _, member := range source.observation.Objects.Members {
+			for _, text := range member.Texts {
+				if text.Name != pkg+"."+stem {
+					continue
+				}
+				if text.Kind != 2 || text.Size == 0 || text.ABI > 1 || seen[text.ABI] {
+					t.Fatal("actual compiler/archive raw Kind2 ABI inventory differs", text)
+				}
+				seen[text.ABI] = true
+			}
+		}
+		if len(seen) != 2 || !seen[0] || !seen[1] {
+			t.Fatal("complete original archive lost its assembly and compiler wrapper entries", stem, seen)
+		}
+	}
+	// Separate original and position-mapped invocations match the producer's
+	// exact SDK arguments and do not modify its retained commands or seal.
+	directory := t.TempDir()
+	expanded := filepath.Join(directory, "mapped.s")
+	if err := os.WriteFile(expanded, []byte(source.observation.Positions[0].Mapped), 0600); err != nil {
+		t.Fatal(err)
+	}
+	var listings [2][]byte
+	var objects [2][]byte
+	for index, assembly := range []string{filepath.Join(request.Directory, input.Name), expanded} {
+		object := filepath.Join(directory, fmt.Sprintf("listing-%d.o", index))
+		arguments := append([]string(nil), source.asmArguments(source.guard.owned)...)
+		arguments = append(arguments, "-S", "-o", object, assembly)
+		stage, cancel := runtimeOracleStageContext(t)
+		listings[index], err = goasmcmd.Run(stage, request.Directory, request.Environment, request.GoBinary, arguments...)
+		cancel()
+		if err != nil {
+			t.Fatal("actual complete original/mapped Go listing prior", index, err)
+		}
+		objects[index], err = os.ReadFile(object)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// This prior deliberately does not use numericalListingHeader.
+		// It observes the actual selected writer's explicit kind token.
+		headers := make(map[string]bool)
+		for _, line := range strings.Split(string(listings[index]), "\n") {
+			fields := strings.Fields(line)
+			if len(fields) >= 2 && fields[1] == "STEXTFIPS" {
+				if headers[fields[0]] {
+					t.Fatal("actual Go repeated an original FIPS listing header", line)
+				}
+				headers[fields[0]] = true
+			}
+		}
+		if len(headers) != len(stems) {
+			t.Fatal("actual complete Go listing lacks three explicit STEXTFIPS producers", index, headers)
+		}
+		for _, stem := range stems {
+			if !headers[pkg+"."+stem] {
+				t.Fatal("actual listing header changed its complete native identity", stem)
+			}
+		}
+	}
+	originalText, expandedText, err := gostaticstorage.ObserveX86SDKASMDataListingObjects(inputs, 0, objects[0], objects[1])
+	if err != nil || len(originalText) != len(stems) || len(expandedText) != len(stems) {
+		t.Fatal("original/mapped actual listing objects differ from the complete archive", err)
+	}
+	for index, text := range originalText {
+		other := expandedText[index]
+		if text.Kind != 2 || other.Kind != 2 || text.ABI != 0 || other.ABI != 0 ||
+			text.Name != other.Name || text.Size <= 0 || !bytes.Equal(text.Code, other.Code) {
+			t.Fatal("actual Kind2 listing/object identity differs before consumer validation", text.Name)
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete source/archive prior changed before listing consumption", err)
+	}
+	t.Log("actual original and mapped bigmod source/listings/Kind2 objects and full ABI0+ABI1 archive priors passed before listing consumer")
+	for index, listing := range listings {
+		t.Run([]string{"original", "mapped"}[index], func(t *testing.T) {
+			rows, err := numericalListingRows(listing)
+			if err != nil || len(rows) != len(stems) {
+				t.Fatal("complete actual STEXTFIPS listing lost native instruction ownership", err)
+			}
+			for _, text := range originalText {
+				body := rows[text.Name]
+				if len(body) < 2 {
+					t.Fatal("complete native body disappeared from its original listing owner", text.Name)
+				}
+				reads := 0
+				for pc, candidates := range body {
+					if pc < 0 || pc >= text.Size {
+						t.Fatal("listing PC lies outside its actual original text", text.Name, pc, text.Size)
+					}
+					for _, row := range candidates {
+						if row.ins.Op == "CMPB" && len(row.ins.Args) == 2 && strings.Contains(row.ins.Args[0].Sym, "supportADX") {
+							reads++
+						}
+					}
+				}
+				if reads != 1 {
+					t.Fatal("original numerical read was assigned to another native owner", text.Name, reads)
+				}
+			}
+		})
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("listing consumer changed its independent original observation", err)
+	}
+}
diff --git a/go_x86_numerical_read_listing_kind_test.go b/go_x86_numerical_read_listing_kind_test.go
new file mode 100644
index 000000000..644c1cd07
--- /dev/null
+++ b/go_x86_numerical_read_listing_kind_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const numericalListingKindTestRow = "\t0x0000 00000 (original.s:4)\tRET\n"
+
+// cmd/internal/obj/objfile.go emits these flags in this exact order for any
+// IsText kind. This is display ownership only, never an instruction, storage
+// or ABI permission. Real current-SDK producer priors live in the paired test.
+func TestGoX86NumericalNativeListingCompleteTextKindHeaders(t *testing.T) {
+	flags := []string{"static", "dupok", "cfunc", "nosplit", "topframe", "asm", "leaf"}
+	for _, kind := range []string{"STEXT", "STEXTFIPS"} {
+		for bits := 0; bits < 1<<len(flags); bits++ {
+			t.Run(fmt.Sprintf("%s/flags%02x", kind, bits), func(t *testing.T) {
+				var attributes []string
+				for index, flag := range flags[:len(flags)-1] {
+					if bits&(1<<index) != 0 {
+						attributes = append(attributes, flag)
+					}
+				}
+				header := "sample.owner " + kind + " "
+				if len(attributes) != 0 {
+					header += strings.Join(attributes, " ") + " "
+				}
+				header += "size=1 align=0x0 args=0xffffffff locals=0x0 funcid=0x0"
+				if bits&(1<<(len(flags)-1)) != 0 {
+					header += " leaf"
+				}
+				rows, err := numericalListingRows([]byte(header + "\n" + numericalListingKindTestRow))
+				if err != nil || len(rows) != 1 || len(rows["sample.owner"][0]) != 1 ||
+					rows["sample.owner"][0][0].ins.Op != OpRET {
+					t.Fatal("complete writer-ordered text header lost its own native PC", header, rows, err)
+				}
+			})
+		}
+	}
+	for _, header := range []string{
+		"sample.owner STEXT nosplit size=1 args=0x0 locals=0x0",
+		"sample.owner STEXT nosplit asm size=1 args=0x0 locals=0x0 funcid=0x0 align=0x0",
+		"sample.owner STEXT static nosplit size=1 args=0xffffffff locals=0x0",
+	} {
+		if rows, err := numericalListingRows([]byte(header + "\n" + numericalListingKindTestRow)); err != nil || len(rows["sample.owner"][0]) != 1 {
+			t.Fatal("original historical writer grammar regressed", header, rows, err)
+		}
+	}
+}
+
+func TestGoX86NumericalNativeListingUnknownOwnersFailClosed(t *testing.T) {
+	const first = "sample.first STEXT nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0\n"
+	const second = "sample.second STEXTFIPS nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0\n"
+	rows, err := numericalListingRows([]byte(first + numericalListingKindTestRow + second + numericalListingKindTestRow))
+	if err != nil || len(rows) != 2 || len(rows["sample.first"][0]) != 1 || len(rows["sample.second"][0]) != 1 {
+		t.Error("mixed legitimate text kinds did not retain separate complete owners", rows, err)
+	}
+	for _, kind := range []string{"STEXT", "STEXTFIPS"} {
+		base := "foreign.owner " + kind + " nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0"
+		for name, changed := range map[string]string{
+			"unknown-kind":   strings.Replace(base, kind, kind+"UNKNOWN", 1),
+			"foreign-kind":   strings.Replace(base, kind, "MYSTERY", 1),
+			"unknown-flag":   strings.Replace(base, "nosplit", "mystery nosplit", 1),
+			"duplicate-kind": strings.Replace(base, kind, kind+" "+kind, 1),
+			"duplicate-flag": strings.Replace(base, "nosplit", "nosplit nosplit", 1),
+			"flag-order":     strings.Replace(base, "nosplit asm", "asm nosplit", 1),
+			"size":           strings.Replace(base, "size=1", "size=x", 1),
+			"missing-size":   strings.Replace(base, "size=1 ", "", 1),
+			"args":           strings.Replace(base, "args=0x0", "args=unknown", 1),
+			"missing-args":   strings.Replace(base, "args=0x0 ", "", 1),
+			"locals":         strings.Replace(base, "locals=0x0", "locals=0x", 1),
+			"funcid":         strings.Replace(base, "funcid=0x0", "funcid=0xg", 1),
+			"align":          strings.Replace(base, "align=0x0", "align=unknown", 1),
+			"trailing":       base + " foreign",
+			"missing-name":   strings.TrimPrefix(base, "foreign.owner "),
+		} {
+			t.Run(kind+"/"+name, func(t *testing.T) {
+				// Check both the first header and a header after a valid owner:
+				// the latter must not silently append a foreign PC to that owner.
+				for _, prefix := range []string{"", first + numericalListingKindTestRow} {
+					rows, err := numericalListingRows([]byte(prefix + changed + "\n" + numericalListingKindTestRow))
+					if rows != nil || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unknown complete listing header borrowed the preceding owner", changed, rows, err)
+					}
+				}
+			})
+		}
+	}
+	for name, listing := range map[string]string{
+		"duplicate":  first + numericalListingKindTestRow + first + numericalListingKindTestRow,
+		"mixed-kind": first + numericalListingKindTestRow + strings.Replace(second, "sample.second", "sample.first", 1) + numericalListingKindTestRow,
+		"data-owner": first + numericalListingKindTestRow + "sample.data SRODATA size=1 align=0x1\n" + numericalListingKindTestRow,
+		"unbound":    numericalListingKindTestRow,
+	} {
+		t.Run(name, func(t *testing.T) {
+			if rows, err := numericalListingRows([]byte(listing)); rows != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("duplicate, mixed-kind or non-text owner supplied a native PC", rows, err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalNativeListingTruncatedNonTextCannotBorrowOwner(t *testing.T) {
+	const text = "sample.first STEXT nosplit asm size=1 align=0x0 args=0x0 locals=0x0 funcid=0x0\n"
+	for name, header := range map[string]string{
+		"rodata":       "sample.data SRODATA",
+		"data":         "sample.data SDATA align=0x1",
+		"bss":          "sample.data SNOPTRBSS dupok",
+		"unknown-kind": "sample.future SFUTURE",
+		"foreign-kind": "sample.future MYSTERY",
+	} {
+		for _, previous := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/previous=%t", name, previous), func(t *testing.T) {
+				prefix := ""
+				if previous {
+					prefix = text + numericalListingKindTestRow
+				}
+				listing := prefix + header + "\n" + numericalListingKindTestRow
+				if rows, err := numericalListingRows([]byte(listing)); rows != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("truncated non-text header borrowed the preceding native owner", header, rows, err)
+				}
+			})
+		}
+	}
+	// A real non-text display has data bytes, not Prog rows. It terminates the
+	// previous body without preventing a later complete TEXT from owning PCs.
+	listing := text + numericalListingKindTestRow + "sample.data SRODATA size=1 align=0x1\n\t0x0000 00 .\n" +
+		strings.Replace(text, "sample.first", "sample.second", 1) + numericalListingKindTestRow
+	if rows, err := numericalListingRows([]byte(listing)); err != nil || len(rows) != 2 ||
+		len(rows["sample.first"][0]) != 1 || len(rows["sample.second"][0]) != 1 {
+		t.Fatal("non-text display changed the two independent native body owners", rows, err)
+	}
+}
diff --git a/go_x86_numerical_read_local_runtime_test.go b/go_x86_numerical_read_local_runtime_test.go
new file mode 100644
index 000000000..e17567234
--- /dev/null
+++ b/go_x86_numerical_read_local_runtime_test.go
@@ -0,0 +1,267 @@
+//go:build go1.27 && unix
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"syscall"
+	"testing"
+	"time"
+)
+
+// Retain this fixture's actual inputs, outputs and bounded command terminal.
+// This is not another process runner: runtimeOracleCombinedOutput still owns
+// the fresh group, cancellation, pipe EOF and cleanup under its original budget.
+func numericalLocalRuntimeCommand(t *testing.T, command *exec.Cmd, sources ...string) []byte {
+	t.Helper()
+	paths := append(append([]string(nil), sources...), command.Args[1:]...)
+	capture := func() map[string][]byte {
+		files := make(map[string][]byte)
+		for _, name := range paths {
+			if !filepath.IsAbs(name) {
+				continue
+			}
+			if info, err := os.Stat(name); err == nil && info.Mode().IsRegular() {
+				data, err := os.ReadFile(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				files[name] = data
+			}
+		}
+		return files
+	}
+	before := capture()
+	tool, err := os.ReadFile(command.Path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bounded := exec.CommandContext(ctx, command.Path, command.Args[1:]...)
+	bounded.Dir, bounded.Env = command.Dir, command.Env
+	started := time.Now()
+	output, runErr := runtimeOracleCombinedOutput(ctx, bounded)
+	after := capture()
+	pid, exitCode, exited, groupGone := 0, -1, false, false
+	if bounded.Process != nil {
+		pid = bounded.Process.Pid
+		groupGone = errors.Is(syscall.Kill(-pid, 0), syscall.ESRCH)
+	}
+	if bounded.ProcessState != nil {
+		exitCode, exited = bounded.ProcessState.ExitCode(), bounded.ProcessState.Exited()
+	}
+	if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+		folder := filepath.Join(artifact, "numerical-local-runtime", fmt.Sprintf("%x", sha256.Sum256([]byte(t.Name()))))
+		if err := os.MkdirAll(folder, 0700); err != nil {
+			t.Fatal(err)
+		}
+		file, err := os.CreateTemp(folder, "command-*.json")
+		if err != nil {
+			t.Fatal(err)
+		}
+		data, encodeErr := json.MarshalIndent(struct {
+			Binary, Directory, Error string
+			Args, Environment        []string
+			ToolSHA256               [32]byte
+			PID, PGID, ExitCode      int
+			Exited, GroupGone        bool
+			Started                  time.Time
+			ElapsedMS                int64
+			Before, After            map[string][]byte
+			Output                   []byte
+		}{bounded.Path, bounded.Dir, fmt.Sprint(runErr), bounded.Args, bounded.Env, sha256.Sum256(tool),
+			pid, pid, exitCode, exited, groupGone, started, time.Since(started).Milliseconds(), before, after, output}, "", "  ")
+		if encodeErr == nil {
+			_, encodeErr = file.Write(data)
+		}
+		if closeErr := file.Close(); encodeErr != nil || closeErr != nil {
+			t.Fatal("retain actual numerical runtime command", encodeErr, closeErr)
+		}
+	}
+	for name, input := range before {
+		if !bytes.Equal(input, after[name]) {
+			t.Fatal("runtime command changed an input", name)
+		}
+	}
+	if runErr != nil || !exited || exitCode != 0 || !groupGone {
+		t.Fatalf("actual numerical runtime command %q: %v (exit=%d groupGone=%v)\n%s", bounded.Args, runErr, exitCode, groupGone, output)
+	}
+	return output
+}
+
+func numericalLocalRuntimeC(snapshot uint64) string {
+	return fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+%s
+%s
+_Alignas(4096) unsigned char cpu[4096];
+NUMERICAL_STORAGE_ALIAS("internal/cpu.X86", cpu);
+extern uint64_t numericalLocal(uint64_t,uint64_t,uint64_t,uint64_t);
+int main(void) {
+    memset(cpu,0xa5,sizeof(cpu));
+    uint64_t snapshot=UINT64_C(0x%016x);
+    for(unsigned i=0;i<8;i++) cpu[64+i]=(unsigned char)(snapshot>>(8*i));
+    const uint64_t values[]={0,UINT64_MAX,UINT64_C(0x8877665544332211)};
+    for(unsigned round=0;round<2;round++) {
+        cpu[64]=(unsigned char)round;
+        uint64_t word=0;
+        for(unsigned i=0;i<4;i++) word|=(uint64_t)cpu[64+i]<<(8*i);
+        for(unsigned i=0;i<3;i++) {
+            uint64_t got=numericalLocal(UINT64_C(0x1122334455667788),17,values[i],29);
+            uint64_t want=values[i]+word;
+            if(got!=want) {
+                fprintf(stderr,"local round/row=%%u/%%u got=%%llx want=%%llx\n",round,i,
+                        (unsigned long long)got,(unsigned long long)want);
+                return 1;
+            }
+            printf("%%016llx\n",(unsigned long long)got);
+        }
+        for(unsigned i=0;i<sizeof(cpu);i++) {
+            unsigned char want=0xa5;
+            if(i>=64&&i<72) want=(unsigned char)(snapshot>>(8*(i-64)));
+            if(i==64) want=(unsigned char)round;
+            if(cpu[i]!=want) return 2;
+        }
+    }
+    pid_t child=fork();
+    if(child<0) return 3;
+    if(!child) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        numerical_fault_begin(cpu,sizeof(cpu));
+        if(mprotect(cpu,sizeof(cpu),PROT_NONE)) _exit(4);
+        (void)numericalLocal(1,2,3,4);
+        _exit(5);
+    }
+    int status=0;
+    if(waitpid(child,&status,0)!=child) return 6;
+    if(!numerical_fault_status(status)) return 7;
+    return 0;
+}
+`, numericalRuntimeStorageAliases, numericalRuntimeFaultObservationC, snapshot)
+}
+
+func numericalLocalOriginalGoRuntime(t *testing.T, pkg GoPackage, options Options, execution x86FloatCompareExecution) (uint64, []byte) {
+	t.Helper()
+	request := options.NumericalReads.source.request
+	dir := t.TempDir()
+	main := fmt.Sprintf(`package main
+import (
+    "fmt"
+    frame %q
+)
+func cpuWord() uint64
+func cpuSet(value byte)
+func main() {
+    snapshot:=cpuWord()
+    old:=byte(snapshot)
+    defer cpuSet(old)
+    fmt.Printf("CPU %%016x\n",snapshot)
+    values:=[]uint64{0,^uint64(0),0x8877665544332211}
+    for round:=byte(0);round<2;round++ {
+        cpuSet(round)
+        word:=uint64(uint32(cpuWord()))
+        results:=make([]uint64,len(values))
+        for i,value:=range values {
+            results[i]=frame.Value(0x1122334455667788,17,value,29)
+            if results[i]!=value+word { panic("original local numerical oracle mismatch") }
+        }
+        cpuSet(old)
+        for _,value:=range results { fmt.Printf("%%016x\n",value) }
+    }
+}
+`, pkg.Path)
+	assembly := "#include \"textflag.h\"\nTEXT ·cpuWord(SB),NOSPLIT,$0-8\nMOVQ internal∕cpu·X86+64(SB),AX\nMOVQ AX,ret+0(FP)\nRET\nTEXT ·cpuSet(SB),NOSPLIT,$0-1\nMOVB value+0(FP),AL\nMOVB AL,internal∕cpu·X86+64(SB)\nRET\n"
+	var sources []string
+	for name, data := range map[string]string{
+		"go.mod":  "module localnumericaloracle\ngo 1.27\nrequire " + pkg.Path + " v0.0.0\nreplace " + pkg.Path + " => " + strconv.Quote(filepath.ToSlash(request.Directory)) + "\n",
+		"main.go": main, "cpu_amd64.s": assembly,
+	} {
+		name = filepath.Join(dir, name)
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+		sources = append(sources, name)
+	}
+	executable := filepath.Join(dir, "original")
+	command := exec.Command(request.GoBinary, "build", "-p=1", "-mod=mod", "-o", executable, ".")
+	command.Dir, command.Env = dir, request.Environment
+	numericalLocalRuntimeCommand(t, command, sources...)
+	args := execution.command(executable)
+	output := numericalLocalRuntimeCommand(t, exec.Command(args[0], args[1:]...))
+	lines := bytes.SplitN(output, []byte("\n"), 2)
+	if len(lines) != 2 || !bytes.HasPrefix(lines[0], []byte("CPU ")) {
+		t.Fatal("actual original local oracle did not return CPU snapshot and values")
+	}
+	snapshot, err := strconv.ParseUint(string(lines[0][4:]), 16, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return snapshot, lines[1]
+}
+
+func numericalLocalMutableRuntime(t *testing.T, execution x86FloatCompareExecution, original bool) {
+	t.Helper()
+	_, pkg, file, bound, source, frame := numericalLocalJoinedFactory(t)
+	ir := numericalFamilyTranslate(t, "context", pkg, file, bound)
+	ir += fmt.Sprintf("define i64 @numericalLocal(i64 %%a,i64 %%b,i64 %%c,i64 %%d) {\n %%value=call i64 %s(i64 %%a,i64 %%b,i64 %%c,i64 %%d)\n ret i64 %%value\n}\n", llvmGlobal(pkg.Path+".Value"))
+	snapshot, expected := uint64(0), []byte(nil)
+	if original {
+		snapshot, expected = numericalLocalOriginalGoRuntime(t, pkg, bound, execution)
+	}
+	opt := findLLVM22Tool("opt")
+	if opt == "" || execution.llc == "" {
+		t.Fatal("LLVM22 opt and llc required")
+	}
+	for _, passes := range []string{"none", "O2"} {
+		t.Run("IR-"+passes, func(t *testing.T) {
+			dir := t.TempDir()
+			input, c := filepath.Join(dir, "input.ll"), filepath.Join(dir, "main.c")
+			for name, data := range map[string]string{input: ir, c: numericalLocalRuntimeC(snapshot)} {
+				if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if passes == "O2" {
+				optimized := filepath.Join(dir, "optimized.ll")
+				numericalLocalRuntimeCommand(t, exec.Command(opt, "-passes=default<O2>", "-S", input, "-o", optimized))
+				input = optimized
+			}
+			for _, backend := range []string{"-O0", "-O2"} {
+				t.Run("backend"+backend, func(t *testing.T) {
+					dir := t.TempDir()
+					object, executable := filepath.Join(dir, "local.o"), filepath.Join(dir, "local")
+					numericalLocalRuntimeCommand(t, exec.Command(execution.llc, backend, "-mtriple="+execution.triple, "-filetype=obj", input, "-o", object))
+					args := append(append([]string(nil), execution.compiler...), "-O2", object, c, "-o", executable)
+					numericalLocalRuntimeCommand(t, exec.Command(args[0], args[1:]...))
+					args = execution.command(executable)
+					output := numericalLocalRuntimeCommand(t, exec.Command(args[0], args[1:]...))
+					if original && !bytes.Equal(output, expected) {
+						t.Fatalf("composed LLVM/C and actual original Go results differ\ngot: %s\nwant: %s", output, expected)
+					}
+				})
+			}
+		})
+	}
+	if err := source.Verify(bound.NumericalReads.context); err != nil {
+		t.Fatal("runtime changed original numerical source/owner", err)
+	}
+	if err := frame.Verify(bound.NumericalReads.context); err != nil {
+		t.Fatal("runtime changed independent original frame observation", err)
+	}
+}
diff --git a/go_x86_numerical_read_local_test.go b/go_x86_numerical_read_local_test.go
new file mode 100644
index 000000000..a348d404a
--- /dev/null
+++ b/go_x86_numerical_read_local_test.go
@@ -0,0 +1,387 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoX86NumericalSBReadComposesOnlyWithActualFixedLocalOwner(t *testing.T) {
+	ctx, pkg, request, file, bound, _, _ := numericalLocalFactory(t)
+	request.NumericalReads = bound.NumericalReads
+	local, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("independent actual Go framed object precondition failed", err)
+	}
+	defer local.Close()
+	bound, err = local.BindFixedLocal(ctx, pkg, file, bound)
+	if err != nil {
+		t.Fatal("certified numerical reads did not compose with complete actual local proof", err)
+	}
+	numericalLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+		if err != nil || !strings.Contains(ir, "fixed_local_native") || strings.Count(ir, "load volatile") < 22 {
+			t.Fatal("complete frozen local/read consumer lost an independent owner or native read", err)
+		}
+		numericalLLVM22Axes(t, ir, bound.TargetTriple, nil)
+	})
+}
+
+func TestGoAMD64FixedLocalFrameCopiedCapabilityCannotBorrowGeneration(t *testing.T) {
+	pkg, request, file, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	frame := requireGoAMD64FrameCapture(t, pkg, request)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bound, err := frame.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("default actual local binding precondition", err)
+	}
+	original := bound.Sigs[pkg.Path+".Value"].x86FixedLocal
+	if original == nil {
+		t.Fatal("default factory did not issue a private local capability")
+	}
+	copied := *original
+	if !errors.Is(copied.verify(), ErrProbeNeedsContext) {
+		t.Fatal("default whole-value copy borrowed original frame generation")
+	}
+	if err := original.verify(); err != nil {
+		t.Fatal("copy rejection revoked default original generation", err)
+	}
+	for name, sig := range bound.Sigs {
+		sig.x86FixedLocal = &copied
+		bound.Sigs[name] = sig
+	}
+	fixedLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("default consumer accepted whole-value copied local capability", err)
+		}
+	})
+}
+
+func numericalLocalJoinedFactory(t *testing.T) (context.Context, GoPackage, *File, Options, *GoX86NumericalReadSource, *GoAMD64FrameSource) {
+	t.Helper()
+	ctx, pkg, request, file, bound, source, _ := numericalLocalFactory(t)
+	request.NumericalReads = bound.NumericalReads
+	frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("complete original frame/read producer precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := frame.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	bound, err = frame.BindFixedLocal(ctx, pkg, file, bound)
+	if err != nil {
+		t.Fatal("complete independent local/read consumer precondition", err)
+	}
+	return ctx, pkg, file, bound, source, frame
+}
+
+func TestGoX86NumericalSBReadLocalCapabilityCannotBeCopiedAndRebound(t *testing.T) {
+	ctx, pkg, file, bound, source, _ := numericalLocalJoinedFactory(t)
+	var original *x86FixedLocalBinding
+	for _, sig := range bound.Sigs {
+		if sig.x86FixedLocal == nil || original != nil && original != sig.x86FixedLocal {
+			t.Fatal("fixture did not retain one complete actual local capability")
+		}
+		original = sig.x86FixedLocal
+	}
+	if original == nil {
+		t.Fatal("fixture has no actual local capability")
+	}
+	copied := *original
+	for name, sig := range bound.Sigs {
+		sig.x86FixedLocal = &copied
+		bound.Sigs[name] = sig
+	}
+	bound.NumericalReads = nil
+	changed, err := source.BindNumericalReads(ctx, pkg, file, bound)
+	if changed.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("whole-value copied local capability issued a fresh numerical token", err)
+	}
+	if err := original.verify(); err != nil {
+		t.Fatal("copy rejection revoked the independent original local capability", err)
+	}
+}
+
+func TestGoX86NumericalSBReadLocalCapabilityDifferentActualOwner(t *testing.T) {
+	ctx, pkg, file, bound, source, frame := numericalLocalJoinedFactory(t)
+	foreign, err := CaptureGoAMD64FrameSource(ctx, pkg, frame.request)
+	if err != nil {
+		t.Fatal("different actual frame owner precondition", err)
+	}
+	defer foreign.Close()
+	for _, sig := range bound.Sigs {
+		sig.x86FixedLocal.source = foreign
+	}
+	bound.NumericalReads = nil
+	changed, err := source.BindNumericalReads(ctx, pkg, file, bound)
+	if changed.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("different actual owner replaced the original local capability generation", err)
+	}
+}
+
+func TestGoX86NumericalSBReadLocalCapabilityConsumerGuards(t *testing.T) {
+	for _, name := range []string{"wrong capability", "copied capability", "revoked frame", "missing local capability", "missing numerical token"} {
+		t.Run(name, func(t *testing.T) {
+			_, pkg, file, bound, _, frame := numericalLocalJoinedFactory(t)
+			switch name {
+			case "wrong capability", "copied capability", "missing local capability":
+				var replacement *x86FixedLocalBinding
+				if name == "wrong capability" {
+					replacement = &x86FixedLocalBinding{}
+				} else if name == "copied capability" {
+					for _, sig := range bound.Sigs {
+						copied := *sig.x86FixedLocal
+						replacement = &copied
+						break
+					}
+				}
+				for symbol, sig := range bound.Sigs {
+					sig.x86FixedLocal = replacement
+					bound.Sigs[symbol] = sig
+				}
+			case "revoked frame":
+				if err := frame.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "missing numerical token":
+				bound.NumericalReads = nil
+			}
+			numericalLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed independent capability published native local/read output", err)
+				}
+			})
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadUnboundNativeLocalRemainsContext(t *testing.T) {
+	_, pkg, _, file, bound, _, _ := numericalLocalFactory(t)
+	numericalLocalAPIs(t, pkg, file, bound, func(t *testing.T, ir string, err error) {
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("numerical read token alone authorized native local frame memory", err)
+		}
+	})
+}
+
+func numericalLocalAPIs(t *testing.T, pkg GoPackage, file *File, options Options, check func(*testing.T, string, error)) {
+	t.Helper()
+	for _, api := range []string{"text", "module", "context", "go-module"} {
+		t.Run(api, func(t *testing.T) {
+			if api == "text" {
+				ir, err := Translate(file, options)
+				check(t, ir, err)
+				return
+			}
+			context := llvm.NewContext()
+			defer context.Dispose()
+			var module llvm.Module
+			var err error
+			switch api {
+			case "module":
+				module, err = TranslateModule(file, options)
+			case "context":
+				module, err = TranslateModuleInContext(context, file, options)
+			case "go-module":
+				var directory, assemblyFile string
+				if options.NumericalReads != nil {
+					source := options.NumericalReads.source
+					directory, assemblyFile = source.request.Directory, source.request.AssemblyFile
+				} else {
+					for _, sig := range options.Sigs {
+						if sig.x86FixedLocal != nil && sig.x86FixedLocal.source != nil {
+							source := sig.x86FixedLocal.source
+							directory, assemblyFile = source.request.Directory, source.request.AssemblyFile
+							break
+						}
+					}
+				}
+				if directory == "" || assemblyFile == "" {
+					t.Fatal("wrapper fixture lost its original input path")
+				}
+				data, readErr := os.ReadFile(filepath.Join(directory, assemblyFile))
+				if readErr != nil {
+					t.Fatal(readErr)
+				}
+				result, translateErr := TranslateGoModule(pkg, data, GoModuleOptions{
+					GOARCH: options.Goarch, GOOS: "linux", TargetTriple: options.TargetTriple,
+					FileName: assemblyFile, NumericalReads: options.NumericalReads,
+					ResolveSym: options.ResolveSym,
+				})
+				err = translateErr
+				if result != nil {
+					module = result.Module
+				}
+			}
+			ir := ""
+			if !module.IsNil() {
+				ir = module.String()
+				module.Dispose()
+			}
+			check(t, ir, err)
+		})
+	}
+}
+
+func numericalLocalFactory(t *testing.T) (context.Context, GoPackage, GoAMD64FrameCaptureRequest, *File, Options, *GoX86NumericalReadSource, context.CancelFunc) {
+	return numericalLocalFactoryWithContext(t, nil)
+}
+
+func numericalLocalFactoryWithContext(t *testing.T, wrap func(context.Context) context.Context) (context.Context, GoPackage, GoAMD64FrameCaptureRequest, *File, Options, *GoX86NumericalReadSource, context.CancelFunc) {
+	t.Helper()
+	pkg, request, initial, options := fixedLocalFrameFixture(t, "PADDQ 16(SP),X0")
+	_, numericalProfile, _, _ := numericalSBFixture(t, "amd64")
+	request.GoBinary, request.Environment = numericalProfile.GoBinary, numericalProfile.Environment
+	options.ResolveSym = func(symbol string) string { return numericalNativeName(symbol, pkg.Path) }
+	var err error
+	request.Directory, err = filepath.EvalSymlinks(request.Directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var reads strings.Builder
+	for _, row := range numericalSBOracleRows {
+		partner := "AX"
+		if strings.HasPrefix(row.op, "CMP") {
+			partner = "$1"
+		}
+		fmt.Fprintf(&reads, "%s internal∕cpu·X86+64(SB),%s\n", row.op, partner)
+	}
+	assembly := strings.Replace(fixedLocalVoidAssembly(initial), "MOVQ AX,16(SP)", reads.String()+"MOVQ AX,16(SP)", 1)
+	if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	if wrap != nil {
+		ctx = wrap(ctx)
+	}
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: request.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: request.Target, Environment: request.Environment, SDKCPU: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(owner.Close)
+	numerical, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: pkg.Path,
+		AssemblyFile: request.AssemblyFile, Target: request.Target, Environment: request.Environment,
+		Owners: []*GoNumericalStorageOwner{owner},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := numerical.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if len(numerical.reads) != 22 {
+		t.Fatal("actual complete original family did not bind all numerical reads", len(numerical.reads))
+	}
+	bound, err := numerical.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("independent original numerical read precondition failed", err)
+	}
+	return ctx, pkg, request, file, bound, numerical, cancel
+}
+
+func TestGoX86NumericalSBReadFrameProducerExactObjectJoin(t *testing.T) {
+	ctx, pkg, request, file, bound, numerical, _ := numericalLocalFactory(t)
+	unbound, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil || unbound == nil {
+		t.Fatal("complete original relocation observation was rejected", err)
+	}
+	defer unbound.Close()
+	// Recording original bytes/relocations does not bind their numerical
+	// consumer. Keep both the missing-owner and foreign-owner boundaries.
+	withoutNumerical := bound
+	withoutNumerical.NumericalReads = nil
+	for _, options := range []Options{withoutNumerical, bound} {
+		if _, err := unbound.BindFixedLocal(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("default frame observation acquired a numerical read binding", err)
+		}
+	}
+	request.NumericalReads = bound.NumericalReads
+	frame, err := CaptureGoAMD64FrameSource(ctx, pkg, request)
+	if err != nil {
+		t.Fatal("independent complete original frame/numerical object join", err)
+	}
+	defer frame.Close()
+	if err := frame.Verify(ctx); err != nil || len(frame.functions) != len(numerical.native.OriginalText) {
+		t.Fatal("complete joined actual frame observation failed verification", err)
+	}
+	retainNumericalRead(t, numerical, "frame-join")
+	retainNumericalFrame(t, frame)
+}
+
+func retainNumericalFrame(t *testing.T, frame *GoAMD64FrameSource) {
+	t.Helper()
+	artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR")
+	if artifact == "" {
+		return
+	}
+	frame.mu.Lock()
+	defer frame.mu.Unlock()
+	folder := filepath.Join(artifact, "linux-amd64", "numerical-read-frame-join")
+	if err := os.MkdirAll(folder, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for _, suffix := range []string{".o", ".o.listing"} {
+		data, err := os.ReadFile(filepath.Join(frame.owned, frame.request.AssemblyFile+suffix))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(folder, "frame-original"+suffix), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	type function struct {
+		ObjectSymbol, ListingSymbol string
+		Locals, Args                int64
+		Code                        []byte
+		Positions                   map[int]string
+		Signature                   FuncSig
+		Transport                   goAMD64FrameTransport
+		LanguageType                string
+	}
+	functions := make(map[string]function, len(frame.functions))
+	for name, fn := range frame.functions {
+		functions[name] = function{fn.objectSymbol, fn.listingSymbol, fn.locals, fn.args, fn.code,
+			fn.positions, fn.signature, fn.transport, fn.languageType}
+	}
+	data, err := json.MarshalIndent(struct {
+		Directory, GoBinary, AssemblyFile, Target string
+		Environment                               []string
+		ActualEnvironment                         map[string]string
+		Selection                                 goAMD64FrameSelection
+		Inputs                                    map[string][32]byte
+		Functions                                 map[string]function
+		Commands                                  []numericalSBCommand
+		NumericalSeal                             [32]byte
+	}{frame.request.Directory, frame.request.GoBinary, frame.request.AssemblyFile, frame.request.Target,
+		frame.request.Environment, frame.env, frame.selection, frame.inputs, functions,
+		frame.numericalCommands, frame.numericalSeal}, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(folder, "frame-observation.json"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/go_x86_numerical_read_maps_go127_test.go b/go_x86_numerical_read_maps_go127_test.go
new file mode 100644
index 000000000..973bd91d8
--- /dev/null
+++ b/go_x86_numerical_read_maps_go127_test.go
@@ -0,0 +1,165 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func numericalSDKMapsReadCapture(t *testing.T, arch, name string) (*GoX86NumericalReadSource, error) {
+	t.Helper()
+	goos, selectedArch, target := "linux", arch, "linux/"+arch
+	if os, architecture, paired := strings.Cut(arch, "/"); paired {
+		goos, selectedArch, target = os, architecture, arch
+	}
+	ctx, request := sdkASMDataRequest(t, selectedArch, "internal/runtime/maps")
+	request.Target = target
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "GOOS=") {
+			request.Environment[index] = "GOOS=" + goos
+		}
+	}
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath, Target: request.Target,
+		Environment: request.Environment, SDKGlobals: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: request.PackagePath, Name: "aeskeysched"}},
+	})
+	if err != nil {
+		t.Fatal("actual selected mutable SDK global precondition", err)
+	}
+	t.Cleanup(owner.Close)
+	data, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual complete SDK maps source/object/DATA precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := data.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	literals, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, data)
+	if err != nil {
+		t.Fatal("independent actual private readonly initializer precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := literals.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath, Target: request.Target,
+		Environment: request.Environment, AssemblyFile: name, Owners: []*GoNumericalStorageOwner{owner}, ReadonlyLiterals: literals,
+	})
+	if err != nil {
+		return source, err
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	return source, nil
+}
+
+func TestGoX86NumericalReadOriginalSDKMapsScalarRegisterEntry(t *testing.T) {
+	source, err := numericalSDKMapsReadCapture(t, "amd64", "memhash_nosimd_amd64.s")
+	if err != nil {
+		t.Fatal("complete SDK source/native/read join", err)
+	}
+	if len(source.file.Funcs) != 2 || len(source.reads) != 6 {
+		t.Fatal("actual complete scalar maps source/native read inventory changed")
+	}
+	pkg, _, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+	file := source.file
+	for name, args := range map[string][]LLVMType{"memHash32AES": {I32, I64}, "memHash64AES": {I64, I64}} {
+		sig := options.Sigs[pkg.Path+"."+name]
+		declaration := pkg.Types.Scope().Lookup(name).(*types.Func).Type().(*types.Signature)
+		if !reflect.DeepEqual(sig.Args, args) || sig.Ret != I64 || len(sig.ArgRegs) != 0 ||
+			len(sig.Frame.Params) != 2 || sig.Frame.Params[0].Type != args[0] || sig.Frame.Params[1].Type != I64 ||
+			declaration.Params().At(0).Name() != "k" || declaration.Params().At(1).Name() != "h" {
+			t.Fatal("original integer language declarations were replaced by native comments or pointer transport", name, sig)
+		}
+	}
+	for _, fn := range file.Funcs {
+		if !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+			t.Fatal("original SDK entry selector is absent")
+		}
+	}
+	bound, err := source.BindNumericalReads(source.sdk.originalContext, pkg, file, options)
+	if err != nil {
+		t.Fatal("complete original register declaration binding", err)
+	}
+	for _, api := range []string{"text", "module", "context", "go-module"} {
+		t.Run(api, func(t *testing.T) {
+			ir := numericalFamilyTranslate(t, api, pkg, file, bound)
+			if !strings.Contains(ir, "external global [128 x i8]") || strings.Contains(ir, "constant [128") ||
+				strings.Count(ir, "aesenc ($2), $0") != 6 {
+				t.Fatal("original mutable SDK AES read/entry behavior lost", ir)
+			}
+			numericalLLVM22Axes(t, ir, options.TargetTriple, nil)
+		})
+	}
+	for _, selected := range []string{"original-selector", "canonical-declaration"} {
+		t.Run(selected+"-resolver-guard", func(t *testing.T) {
+			changed := options
+			changed.ResolveSym = func(symbol string) string {
+				if symbol == "·memHash32AES<ABIInternal>" && selected == "original-selector" ||
+					symbol == "·memHash32AES" && selected == "canonical-declaration" {
+					return pkg.Path + ".foreignEntry"
+				}
+				return options.ResolveSym(symbol)
+			}
+			if _, err := source.BindNumericalReads(source.sdk.originalContext, pkg, file, changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("different source/logical resolver acquired the original native ABI entry", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalReadOriginalSDKMapsRemainingMemoryContracts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, err := numericalSDKMapsReadCapture(t, arch, "memhash_"+arch+".s")
+			if err != nil {
+				t.Fatal("complete original literal/source/native observation", err)
+			}
+			pkg, _, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+			want := 4
+			functions := 2
+			if arch == "386" {
+				want = 2
+				functions = 4
+			}
+			if len(source.file.Funcs) != functions {
+				t.Fatal("complete original function inventory changed", len(source.file.Funcs))
+			}
+			literals := make(map[string]int64)
+			for _, global := range source.file.Globl {
+				literals[global.Sym] = global.Size
+			}
+			accesses, addressBitObservers := 0, 0
+			for _, fn := range source.file.Funcs {
+				// Query every original function, including the alignment observer.
+				// No subset is translated, rebound, or given a public certificate.
+				sig := options.Sigs[options.ResolveSym(fn.Sym)]
+				facts, err := proveX86SDKLiteralAccesses(fn, sig, arch, literals)
+				if err != nil {
+					if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "linked address-bit observation requires independent native alignment or physical identity") {
+						t.Fatal("original literal-only analysis reached another unclosed source role", err)
+					}
+					addressBitObservers++
+					continue
+				}
+				accesses += len(facts)
+			}
+			if accesses != want || addressBitObservers != 1 {
+				t.Fatal("original readonly envelopes or address observer inventory changed", accesses, addressBitObservers)
+			}
+			bound, err := source.BindNumericalReads(source.sdk.originalContext, pkg, source.file, options)
+			if bound.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "linked address-bit observation requires independent native alignment or physical identity") {
+				t.Fatal("full original file acquired an unauthenticated linked-address/boolean contract", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_mutable_test.go b/go_x86_numerical_read_mutable_test.go
new file mode 100644
index 000000000..2874c8a57
--- /dev/null
+++ b/go_x86_numerical_read_mutable_test.go
@@ -0,0 +1,226 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func numericalMutableFixture(t *testing.T, arch, body string) (GoNumericalStorageCaptureRequest, GoX86NumericalReadCaptureRequest) {
+	t.Helper()
+	_, original, _, _ := numericalSBFixture(t, arch)
+	if err := os.Remove(filepath.Join(original.Directory, original.AssemblyFile)); err != nil {
+		t.Fatal(err)
+	}
+	goSource := `package numericalfixture
+var Mutable [32]byte
+var Initial = [4]byte{1,2,3,4}
+var Relocated = struct { N uint32; P *byte }{7, &Mutable[0]}
+var Mixed struct {
+	N byte
+	_ [3]byte
+	P *byte
+	Bytes [16]byte
+}
+`
+	if err := os.WriteFile(filepath.Join(original.Directory, "value.go"), []byte(goSource), 0600); err != nil {
+		t.Fatal(err)
+	}
+	consumer := filepath.Join(original.Directory, "consumer")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goConsumer := `package consumer
+import owner "example.invalid/numericalfixture"
+var _ = owner.Mutable
+func Feature() byte
+`
+	assembly := "#include \"textflag.h\"\n#include \"local.h\"\nTEXT ·Feature(SB),NOSPLIT,$0-1\n" + body + "\nMOVB AL,ret+0(FP)\nRET\n"
+	header := `#define DATA example·invalid∕numericalfixture·Mutable
+#define READ(off,dst) MOVL DATA+off(SB),dst
+`
+	for name, data := range map[string][]byte{
+		"value.go":            []byte(goConsumer),
+		original.AssemblyFile: []byte(assembly),
+		"local.h":             []byte(header),
+	} {
+		if err := os.WriteFile(filepath.Join(consumer, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	owner := GoNumericalStorageCaptureRequest{GoBinary: original.GoBinary, Directory: original.Directory, PackagePath: "example.invalid/numericalfixture",
+		Target: original.Target, Environment: original.Environment,
+		Variables: []GoNumericalStorageReference{{"example.invalid/numericalfixture", "Mutable"}, {"example.invalid/numericalfixture", "Initial"},
+			{"example.invalid/numericalfixture", "Mixed"}, {"example.invalid/numericalfixture", "Relocated"}}}
+	read := GoX86NumericalReadCaptureRequest{GoBinary: original.GoBinary, Directory: consumer, PackagePath: "example.invalid/numericalfixture/consumer",
+		AssemblyFile: original.AssemblyFile, Target: original.Target, Environment: original.Environment}
+	return owner, read
+}
+
+func TestGoX86NumericalSBReadActualMutableWidthsAndCPP(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			forms := []string{"MOVB", "MOVW", "MOVL", "MOVBWSX", "MOVBWZX", "MOVBLSX", "MOVBLZX", "MOVWLSX", "MOVWLZX", "MOVLQZX", "MOVSWW", "MOVZWW"}
+			if arch == "amd64" {
+				forms = append(forms, "MOVQ", "MOVBQSX", "MOVBQZX", "MOVWQSX", "MOVWQZX", "MOVLQSX")
+			}
+			var body strings.Builder
+			for _, form := range forms {
+				fmt.Fprintf(&body, "%s DATA+(2*4)(SB),AX\n", form)
+			}
+			body.WriteString("MOVB DATA+1(SB),AH\nMOVB DATA+2(SB),AL\nCMPB AH,DATA+3(SB)\n")
+			if arch == "amd64" {
+				body.WriteString("MOVB DATA+1(SB),R8\nMOVW DATA+2(SB),R8\nMOVL DATA+4(SB),R8\nMOVQ DATA+8(SB),R8\n")
+			}
+			for _, width := range []string{"B", "W", "L"} {
+				fmt.Fprintf(&body, "CMP%s DATA+16(SB),$1\nCMP%s DATA+16(SB),AX\nCMP%s AX,DATA+16(SB)\n", width, width, width)
+			}
+			if arch == "amd64" {
+				body.WriteString("CMPQ DATA+16(SB),$1\nCMPQ DATA+16(SB),AX\nCMPQ AX,DATA+16(SB)\n")
+			}
+			body.WriteString("READ(4,AX)\nMOVL example·invalid∕numericalfixture·Relocated+0(SB),AX\nMOVB example·invalid∕numericalfixture·Initial+3(SB),AL\n")
+			ownerRequest, readRequest := numericalMutableFixture(t, arch, body.String())
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			original, err := goasmcmd.Run(ctx, readRequest.Directory, readRequest.Environment, readRequest.GoBinary, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			if err != nil {
+				t.Fatalf("independent actual original mutable export failed: %v\n%s", err, original)
+			}
+			readRequest.Owners = []*GoNumericalStorageOwner{owner}
+			source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			expected := len(forms) + 9 + 6
+			if arch == "amd64" {
+				expected += 7
+			}
+			if len(source.reads) != expected {
+				t.Fatalf("full read shape count = %d, want %d", len(source.reads), expected)
+			}
+			raw, err := source.Readback(ctx)
+			if err != nil || source.CheckReadback(ctx, raw) != nil {
+				t.Fatalf("sealed mutable readback failed: %v", err)
+			}
+			retainNumericalRead(t, source, "mutable")
+			mutated := append([]byte(nil), raw...)
+			mutated[len(mutated)/2] ^= 1
+			if !errors.Is(source.CheckReadback(ctx, mutated), ErrProbeNeedsContext) {
+				t.Fatal("edited portable readback gained authority")
+			}
+			for _, read := range source.reads {
+				if read.original.Op == "MOVLQZX" && read.width != 4 {
+					t.Fatal("Go's mode32-compatible MOVLQZX acquired a qword source width")
+				}
+			}
+			// The numerical BSS observation is mutable storage, not a folded zero.
+			// Restoring an altered join cannot undo permanent revocation.
+			originalOffset := source.reads[0].offset
+			source.reads[0].offset++
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("changed native/read offset retained live seal")
+			}
+			source.reads[0].offset = originalOffset
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restored offset resurrected revoked source")
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadActualOwnerSpanAndAddressNegatives(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, test := range []struct{ name, body string }{
+			{"cross end", "MOVL DATA+30(SB),AX"},
+			{"negative offset", "MOVB DATA-1(SB),AL"},
+			{"blank field", "MOVB example·invalid∕numericalfixture·Mixed+1(SB),AL"},
+			{"pointer field", "MOVL example·invalid∕numericalfixture·Mixed+4(SB),AX"},
+			{"relocated pointer field", "MOVL example·invalid∕numericalfixture·Relocated+4(SB),AX"},
+			{"address", "MOVL $DATA(SB),AX"},
+			{"LEA", "LEAL DATA(SB),AX"},
+			{"store", "MOVL $1,DATA(SB)"},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				if arch == "amd64" && test.name == "pointer field" {
+					test.body = "MOVL example·invalid∕numericalfixture·Mixed+8(SB),AX"
+				} else if arch == "amd64" && test.name == "relocated pointer field" {
+					test.body = "MOVL example·invalid∕numericalfixture·Relocated+8(SB),AX"
+				}
+				ownerRequest, readRequest := numericalMutableFixture(t, arch, test.body)
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer owner.Close()
+				original, err := goasmcmd.Run(ctx, readRequest.Directory, readRequest.Environment, readRequest.GoBinary, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+				if err != nil {
+					t.Fatalf("independent actual original negative fixture failed: %v\n%s", err, original)
+				}
+				readRequest.Owners = []*GoNumericalStorageOwner{owner}
+				source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+				if source != nil {
+					source.Close()
+					t.Fatal("non-numerical/address/write bytes obtained source read join")
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("expected exact Context rejection, not infrastructure: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86NumericalSBReadActualRepeatedSourceOrdinals(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			body := "MOVB DATA+0(SB),AL\nMOVB AL,ret+0(FP)\nRET\n" +
+				"TEXT ·Other(SB),NOSPLIT,$0-1\nMOVB DATA+0(SB),AL"
+			ownerRequest, readRequest := numericalMutableFixture(t, arch, body)
+			goFile := filepath.Join(readRequest.Directory, "value.go")
+			data, err := os.ReadFile(goFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(goFile, append(data, []byte("func Other() byte\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			original, err := goasmcmd.Run(ctx, readRequest.Directory, readRequest.Environment, readRequest.GoBinary,
+				"list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			if err != nil {
+				t.Fatalf("actual two-TEXT original export failed: %v\n%s", err, original)
+			}
+			readRequest.Owners = []*GoNumericalStorageOwner{owner}
+			source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			if len(source.reads) != 2 || source.reads[0].function == source.reads[1].function {
+				t.Fatal("repeated source read borrowed another TEXT's ordinal")
+			}
+			retainNumericalRead(t, source, "repeated")
+		})
+	}
+}
diff --git a/go_x86_numerical_read_namespace_test.go b/go_x86_numerical_read_namespace_test.go
new file mode 100644
index 000000000..7975a3f34
--- /dev/null
+++ b/go_x86_numerical_read_namespace_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import "testing"
+
+func TestNumericalRawSelectionPreservesActualPackageQuery(t *testing.T) {
+	logical := []byte(`{"ImportPath":"hash/crc32","Match":["hash/crc32"]}`)
+	directory := []byte(`{"ImportPath":"hash/crc32","Match":["."]}`)
+	if numericalSameRawSelection(logical, directory) {
+		t.Fatal("different original command selectors were discarded from the raw selection")
+	}
+	if !numericalSameRawSelection(logical, logical) || !numericalSameRawSelection(directory, directory) {
+		t.Fatal("unchanged original package selectors were rejected")
+	}
+}
+
+func TestNumericalSourcePackageQueryKeepsSourceRolesDistinct(t *testing.T) {
+	for _, entry := range []struct {
+		role numericalSBSourceRole
+		path string
+		want string
+	}{
+		{numericalSBOwnedSource, "example.invalid/owned", "."},
+		{numericalSBSDKSource, "hash/crc32", "hash/crc32"},
+		{numericalSBSDKSource, "vendor/golang.org/x/crypto/chacha20poly1305", "vendor/golang.org/x/crypto/chacha20poly1305"},
+	} {
+		source := &GoX86NumericalReadSource{role: entry.role, request: GoX86NumericalReadCaptureRequest{PackagePath: entry.path}}
+		if actual := source.packageQuery(); actual != entry.want {
+			t.Errorf("role=%d path=%q: query=%q, want %q", entry.role, entry.path, actual, entry.want)
+		}
+	}
+}
diff --git a/go_x86_numerical_read_native.go b/go_x86_numerical_read_native.go
new file mode 100644
index 000000000..9771fa602
--- /dev/null
+++ b/go_x86_numerical_read_native.go
@@ -0,0 +1,441 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type numericalSBNativeProof struct {
+	Archive, OriginalObject, ExpandedObject []byte
+	OriginalListing, ExpandedListing        []byte
+	OriginalText, ExpandedText              []gostaticstorage.TextRecord
+	ArchiveMembers                          []gostaticstorage.TextMember
+	Sources                                 map[string][]byte
+	CompilerAliases                         map[string]numericalCompilerAliasWitness
+	ArgumentRules                           map[string]string
+}
+
+func (source *GoX86NumericalReadSource) bindNative(ctx context.Context, variables map[string]numericalSBRead, environment map[string]string) error {
+	if err := source.preprocess(); err != nil {
+		return err
+	}
+	tailRoles, err := numericalDirectTailRoles(source.file)
+	if err != nil {
+		return err
+	}
+	guard := source.guard
+	selected := guard.selection
+	_, arch, _ := strings.Cut(source.request.Target, "/")
+	builtin, err := guard.read(filepath.Join(guard.env["GOROOT"], "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		return err
+	}
+	proof := &source.native
+	assembly := source.sdkAssemblyJoin()
+	proof.Archive, err = guard.read(selected.Export)
+	if err != nil {
+		return err
+	}
+	if source.role == numericalSBSDKSource {
+		if source.sdk == nil || source.sdk.origin != source || source.sdk.closed {
+			return numericalSBContext("native observation lacks the live exact SDK input graph")
+		}
+		if assembly != nil {
+			if !bytes.Equal(proof.Archive, assembly.Observation.ObjectInputs.Archive) {
+				return numericalSBContext("literal native archive changed")
+			}
+			proof.ArchiveMembers = source.sdk.ArchiveMembers
+		} else {
+			proof.ArchiveMembers, err = gostaticstorage.ObserveX86SDKAssemblyArchiveReferences(proof.Archive, builtin, source.request.Target,
+				selected.SFiles, source.sdk.Referenced)
+		}
+	} else {
+		proof.ArchiveMembers, err = gostaticstorage.ObserveX86AssemblyArchive(proof.Archive, builtin, source.request.Target, selected.SFiles)
+	}
+	if err != nil {
+		return numericalSBContext("complete actual compiler/archive role: %v", err)
+	}
+	found := false
+	for _, name := range selected.SFiles {
+		found = found || name == source.request.AssemblyFile
+	}
+	if !found {
+		return numericalSBContext("assembly is not actually selected")
+	}
+	expanded := filepath.Join(guard.owned, "expanded.s")
+	expandedProgram := source.cpp.Output
+	var sourcePositions [][]string
+	if assembly != nil {
+		positioned := assembly.Observation.Positions[assembly.SourceOrdinal]
+		expandedProgram = positioned.Mapped
+		sourcePositions, err = numericalSDKLiteralSourcePositions(source.file, source.cpp.Output, positioned)
+		if err != nil {
+			return err
+		}
+	}
+	if err := os.WriteFile(expanded, []byte(expandedProgram), 0600); err != nil {
+		return err
+	}
+	if _, err := guard.read(expanded); err != nil {
+		return err
+	}
+	assemble := func(input, output string) ([]byte, []byte, error) {
+		arguments := []string{"tool", "asm", "-S", "-p", source.request.PackagePath, "-I", source.request.Directory, "-I", filepath.Join(guard.env["GOROOT"], "pkg", "include")}
+		if assembly != nil {
+			// Match the independent SDK header producer's complete source and
+			// generated-header route; no user header or substituted constant.
+			arguments = []string{"tool", "asm", "-S", "-p", source.request.PackagePath, "-std",
+				"-I", assembly.source.guard.owned, "-I", filepath.Join(guard.env["GOROOT"], "pkg", "include")}
+		}
+		if source.role == numericalSBSDKSource && environment["GOOS"] == "darwin" {
+			arguments = append(arguments, "-shared")
+		}
+		for _, define := range GoAssemblerDefinesWithEnv(environment["GOOS"], arch, environment) {
+			arguments = append(arguments, "-D", define)
+		}
+		arguments = append(arguments, "-o", output, input)
+		listing, err := source.run(ctx, arguments...)
+		if err != nil {
+			return nil, listing, err
+		}
+		object, err := guard.read(output)
+		return object, listing, err
+	}
+	proof.OriginalObject, proof.OriginalListing, err = assemble(filepath.Join(source.request.Directory, source.request.AssemblyFile), filepath.Join(guard.owned, "original.o"))
+	if err != nil {
+		return err
+	}
+	proof.ExpandedObject, proof.ExpandedListing, err = assemble(expanded, filepath.Join(guard.owned, "expanded.o"))
+	if err != nil {
+		return err
+	}
+	if assembly != nil {
+		proof.OriginalText, proof.ExpandedText, err = gostaticstorage.ObserveX86SDKASMDataListingObjects(
+			assembly.Observation.ObjectInputs, assembly.SourceOrdinal, proof.OriginalObject, proof.ExpandedObject)
+	} else {
+		proof.OriginalText, err = gostaticstorage.ObserveX86AssemblyText(proof.OriginalObject, builtin, source.request.Target)
+		if err == nil {
+			proof.ExpandedText, err = gostaticstorage.ObserveX86AssemblyText(proof.ExpandedObject, builtin, source.request.Target)
+		}
+	}
+	if err != nil || len(proof.OriginalText) != len(proof.ExpandedText) || len(proof.OriginalText) != len(source.file.Funcs) {
+		return numericalSBContext("original/expanded complete TEXT differs: %v", err)
+	}
+	originalRows, err := numericalListingRows(proof.OriginalListing)
+	if err != nil {
+		return err
+	}
+	expandedRows, err := numericalListingRows(proof.ExpandedListing)
+	if err != nil {
+		return err
+	}
+	var textOrder []int
+	if assembly != nil {
+		observed := assembly.Observation.Objects.Sources[assembly.SourceOrdinal]
+		textOrder, err = numericalSDKNativeTextOrder(source.cpp.Output, source.request.PackagePath,
+			observed, proof.OriginalText, proof.ExpandedText)
+		if err != nil {
+			return err
+		}
+	}
+	for index, fn := range source.file.Funcs {
+		objectOrdinal := index
+		if textOrder != nil {
+			objectOrdinal = textOrder[index]
+		}
+		text, expandedText := proof.OriginalText[objectOrdinal], proof.ExpandedText[objectOrdinal]
+		name, abi, valid := source.numericalSourceTextIdentity(index, fn, arch)
+		if !valid || text.Name != name || text.ABI != abi || expandedText.Name != name || expandedText.ABI != abi ||
+			!bytes.Equal(text.Code, expandedText.Code) || text.Size != expandedText.Size || !numericalRelocationEqual(text.Relocations, expandedText.Relocations) {
+			return numericalSBContext("whole original/expanded TEXT/ABI/code/relocations differ")
+		}
+		memberMatches := 0
+		memberOrdinal := -1
+		for ordinal, name := range selected.SFiles {
+			if name == source.request.AssemblyFile {
+				if memberOrdinal >= 0 {
+					return numericalSBContext("selected assembly repeats its native member identity")
+				}
+				memberOrdinal = ordinal + 2 // Actual work/gc.go compiler then selected ASM order.
+			}
+		}
+		if memberOrdinal < 2 || memberOrdinal >= len(proof.ArchiveMembers) {
+			return numericalSBContext("selected source has no original archive member ordinal")
+		}
+		for ordinal, member := range proof.ArchiveMembers {
+			if ordinal != memberOrdinal {
+				continue
+			}
+			for _, record := range member.Texts {
+				if record.Name == text.Name && record.ABI == text.ABI && record.Size == text.Size && bytes.Equal(record.Code, text.Code) && numericalRelocationEqual(record.Relocations, text.Relocations) {
+					memberMatches++
+				}
+			}
+		}
+		if memberMatches != 1 {
+			return numericalSBContext("original assembler TEXT does not match its actual selected archive member")
+		}
+		lines := strings.Split(source.cpp.Output, "\n")
+		textLine := 0
+		for line, physical := range lines {
+			if strings.TrimSpace(physical) == fn.Instrs[0].Raw {
+				if textLine != 0 {
+					return numericalSBContext("ambiguous expanded physical TEXT identity")
+				}
+				textLine = line + 1
+			}
+		}
+		if textLine == 0 {
+			return numericalSBContext("missing expanded physical TEXT identity")
+		}
+		textEnd := len(lines) + 1
+		for line, physical := range lines[textLine:] {
+			for _, other := range source.file.Funcs {
+				if strings.TrimSpace(physical) == other.Instrs[0].Raw {
+					textEnd = textLine + line + 1
+					break
+				}
+			}
+			if textEnd != len(lines)+1 {
+				break
+			}
+		}
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		// The full native stream must have trusted instruction boundaries,
+		// including vector instructions and unreachable bytes. Only the
+		// independent scalar decoder map can supply a numerical read below.
+		decoded, err := numericalNativeReads(text.Code, mode)
+		if err != nil {
+			return err
+		}
+		for ordinal, ins := range fn.Instrs {
+			if _, terminal := tailRoles[x86DirectTailPoint{index, ordinal}]; terminal {
+				continue // Exact source control role; no data/entry/state authority.
+			}
+			containsSymbol := false
+			for operandIndex, operand := range ins.Args {
+				local, err := source.sdkLiteralRead(ins, operandIndex, arch)
+				if err != nil {
+					return err
+				}
+				containsSymbol = containsSymbol || operand.Kind == OpSym && !local
+				if operand.Kind == OpMem && operand.Mem.Sym != "" && !local {
+					return numericalSBContext("indexed/alternate SB memory role needs separate binding")
+				}
+			}
+			if !containsSymbol {
+				continue
+			}
+			operandIndex, width, valid := x86NumericalSBReadShape(ins, arch)
+			if !valid {
+				return numericalSBContext("symbol address/write/unregistered numerical read form")
+			}
+			base, offset, valid := parseSBRef(ins.Args[operandIndex].Sym)
+			if !valid || strings.Contains(base, "<") {
+				return numericalSBContext("unknown source SB storage identity")
+			}
+			owner, exists := variables[numericalNativeName(base, source.request.PackagePath)]
+			if !exists || !numericalOwnerContains(owner.variable, offset, width) {
+				return numericalSBContext("read bytes lack exact numerical owner span")
+			}
+			matches := 0
+			for pc, native := range decoded {
+				for _, row := range expandedRows[name][pc] {
+					if !numericalSameInstruction(ins, row.ins, source.request.PackagePath, arch) {
+						continue
+					}
+					if assembly != nil {
+						if !numericalSDKLiteralReadOrdinal(fn, ordinal, sourcePositions[index], pc, row,
+							expandedRows[name], source.request.PackagePath, arch) {
+							continue
+						}
+					} else {
+						// The expanded physical line must select this exact ordinal;
+						// repeated identical instructions cannot borrow another row.
+						separator := strings.LastIndexByte(row.position, ':')
+						if separator < 0 || row.position[:separator] != expanded {
+							return numericalSBContext("expanded listing source role differs")
+						}
+						line, err := strconv.Atoi(row.position[separator+1:])
+						if err != nil || line <= textLine || line >= textEnd || strings.TrimSpace(lines[line-1]) != ins.Raw {
+							return numericalSBContext("expanded source ordinal/physical line differs")
+						}
+						priorCount := 0
+						for _, prior := range fn.Instrs[:ordinal] {
+							if prior.Raw == ins.Raw {
+								priorCount++
+							}
+						}
+						physicalCount := 0
+						for _, physical := range lines[textLine : line-1] {
+							if strings.TrimSpace(physical) == ins.Raw {
+								physicalCount++
+							}
+						}
+						if priorCount != physicalCount {
+							continue
+						}
+					}
+					originalMatches := 0
+					for _, original := range originalRows[name][pc] {
+						if numericalSameInstruction(ins, original.ins, source.request.PackagePath, arch) {
+							for _, position := range text.Positions {
+								path := original.position
+								objectFile := position.File
+								if assembly != nil {
+									var valid bool
+									path, valid = numericalSDKListingLogicalPosition(path)
+									if !valid {
+										return numericalSBContext("unknown SDK original source-position display")
+									}
+									objectFile, valid = source.sdkLiteralObjectSource(objectFile)
+									if !valid {
+										continue
+									}
+								} else {
+									// Go's object writer uses forward slashes on Windows.
+									// Decode spelling only; the exact CPP input join below
+									// still establishes source identity and PC ownership.
+									var valid bool
+									objectFile, valid = originalGoObjectSourcePath(objectFile, "")
+									if !valid {
+										continue
+									}
+								}
+								colon := strings.LastIndexByte(path, ':')
+								line, err := strconv.Atoi(path[colon+1:])
+								if colon >= 0 && err == nil && position.Start <= pc && pc < position.End && objectFile == path[:colon] && int32(line) == position.Line {
+									for _, input := range source.cpp.Sources {
+										if input.File == objectFile {
+											originalMatches++
+										}
+									}
+								}
+							}
+						}
+					}
+					if originalMatches != 1 || native.width != int(width) || native.addressBits != mode {
+						var locations []string
+						for _, position := range text.Positions {
+							if position.Start <= pc && pc < position.End {
+								locations = append(locations, fmt.Sprintf("%s:%d", position.File, position.Line))
+							}
+						}
+						return numericalSBContext("native read width/source-PC role differs: source matches=%d width=%d/%d address=%d/%d listing=%s binary=%v", originalMatches, native.width, width, native.addressBits, mode, row.position, locations)
+					}
+					if !native.matchesSource(ins, operandIndex, arch) {
+						return numericalSBContext("read has unbound native opcode/segment/index/base role")
+					}
+					relocation, physicalOffset, err := native.relocation(text, pc, arch)
+					if err != nil || physicalOffset != offset || relocation.Target.Name != owner.variable.NativeName {
+						return numericalSBContext("whole native address/addend/owner differs: source=%s code=%x field=%d offset=%d/%d: %v", ins.Raw,
+							text.Code[pc:pc+int64(native.length)], native.addressField, physicalOffset, offset, err)
+					}
+					matches++
+					read := owner
+					function := name
+					if strings.HasSuffix(fn.Sym, "<>") {
+						function = numericalNativeName(fn.Sym, source.request.PackagePath)
+					}
+					read.function, read.instruction, read.original = function, ordinal, ins
+					read.operand = operandIndex
+					read.pc, read.offset, read.width, read.relocation = pc, offset, width, relocation
+					read.code = append([]byte(nil), text.Code[pc:pc+int64(native.length)]...)
+					source.reads = append(source.reads, read)
+				}
+			}
+			if matches != 1 {
+				if assembly != nil {
+					var positions []string
+					for pc, rows := range expandedRows[name] {
+						for _, row := range rows {
+							if numericalSameInstruction(ins, row.ins, source.request.PackagePath, arch) {
+								positions = append(positions, fmt.Sprintf("%d@%s", pc, row.position))
+							}
+						}
+					}
+					return numericalSBContext("missing/ambiguous mapped source/native read: %s; expected %s, observed %v", ins.Raw, sourcePositions[index][ordinal], positions)
+				}
+				return numericalSBContext("missing/ambiguous whole source instruction/native read join: %s", ins.Raw)
+			}
+		}
+	}
+	if len(source.reads) == 0 {
+		return numericalSBContext("source has no certified numerical SB reads")
+	}
+	if err := source.captureCompilerAliases(); err != nil {
+		return err
+	}
+	if err := source.captureAMD64GoArgumentRules(); err != nil {
+		return err
+	}
+	proof.Sources = make(map[string][]byte)
+	for name := range guard.inputs {
+		if goAssemblyPathWithinRoot(source.request.Directory, name) || strings.HasPrefix(name, filepath.Join(guard.env["GOROOT"], "pkg", "include")+string(filepath.Separator)) {
+			proof.Sources[name], err = guard.read(name)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// A source ordinal and a physical goobj ordinal are separate identities. This
+// consumes the already authenticated complete SDK member, retaining every native
+// code/PC/relocation record in its original order. It supplies no entry, helper,
+// closure, declaration or numerical read authority.
+func numericalSDKNativeTextOrder(program, packagePath string, observed gostaticstorage.ASMDataSourceObservation,
+	original, expanded []gostaticstorage.TextRecord,
+) ([]int, error) {
+	if len(original) == 0 || !reflect.DeepEqual(original, observed.Original.Texts) ||
+		!reflect.DeepEqual(expanded, observed.Expanded.Texts) {
+		return nil, numericalSBContext("native TEXT records differ from the complete original SDK member")
+	}
+	first, second := observed.Original, observed.Expanded
+	first.Texts, second.Texts = original, expanded
+	actual, err := gostaticstorage.ASMSourceTextOrder([]byte(program), packagePath, first)
+	if err != nil {
+		return nil, numericalSBContext("original native source TEXT association differs: %v", err)
+	}
+	replayed, err := gostaticstorage.ASMSourceTextOrder([]byte(program), packagePath, second)
+	if err != nil || !reflect.DeepEqual(actual, replayed) || !reflect.DeepEqual(actual, observed.TextOrder) {
+		return nil, numericalSBContext("complete source/original/expanded TEXT association differs: %v", err)
+	}
+	order := make([]int, len(original))
+	for ordinal, association := range actual {
+		order[ordinal] = association.ObjectOrdinal
+	}
+	return order, nil
+}
+
+// This binds an explicit source ABI selector to the original native object.
+// It creates no entry, frame or initialization permission. AMD64 scalar
+// register transport must independently pass its complete source/result proof.
+func numericalFunctionSourceIdentity(symbol, pkg, arch string, role numericalSBSourceRole) (string, uint16, bool) {
+	abi := uint16(0)
+	if strings.HasSuffix(symbol, "<ABIInternal>") {
+		if role != numericalSBSDKSource || arch != "amd64" {
+			return "", 0, false
+		}
+		abi = 1
+		symbol = strings.TrimSuffix(symbol, "<ABIInternal>")
+	} else if strings.HasSuffix(symbol, "<ABI0>") {
+		symbol = strings.TrimSuffix(symbol, "<ABI0>")
+	}
+	if strings.ContainsAny(symbol, "<>") {
+		return "", 0, false
+	}
+	return numericalNativeName(symbol, pkg), abi, true
+}
diff --git a/go_x86_numerical_read_object.go b/go_x86_numerical_read_object.go
new file mode 100644
index 000000000..85b096e9f
--- /dev/null
+++ b/go_x86_numerical_read_object.go
@@ -0,0 +1,309 @@
+package plan9asm
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"math"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// These typed shapes observe scalar integer MOV/CMP source bytes only. They
+// create no load, pointer, frame, caller or entry permission. Extensions share
+// the established scalar grammar, including MOVSWW/MOVZWW and mode32 MOVLQZX.
+type x86NumericalSBReadSpec struct {
+	sourceBytes, gpBytes int64
+	compare, extension   bool
+	rejectedOn386        bool
+	vector               x86NumericalSBVectorKind
+}
+
+type x86NumericalSBReadForm struct {
+	spec             x86NumericalSBReadSpec
+	operand, partner int
+}
+
+var x86NumericalSBReadSpecs = func() map[Op]x86NumericalSBReadSpec {
+	result := map[Op]x86NumericalSBReadSpec{
+		"MOVB": {sourceBytes: 1, gpBytes: 1},
+		"MOVW": {sourceBytes: 2, gpBytes: 2},
+		"MOVL": {sourceBytes: 4, gpBytes: 4},
+		"MOVQ": {sourceBytes: 8, gpBytes: 8, rejectedOn386: true},
+		"CMPB": {sourceBytes: 1, gpBytes: 1, compare: true},
+		"CMPW": {sourceBytes: 2, gpBytes: 2, compare: true},
+		"CMPL": {sourceBytes: 4, gpBytes: 4, compare: true},
+		"CMPQ": {sourceBytes: 8, gpBytes: 8, compare: true, rejectedOn386: true},
+	}
+	for opcode, spec := range amd64ScalarExtensionMoveSpecs {
+		result[opcode] = x86NumericalSBReadSpec{sourceBytes: int64(spec.sourceBits / 8), gpBytes: int64(spec.destinationBits / 8),
+			extension: true, rejectedOn386: spec.rejectedOn386}
+	}
+	return result
+}()
+
+func x86NumericalSBReadProperties(ins Instr, arch string) (x86NumericalSBReadForm, bool) {
+	if form, known := x86NumericalSBVectorReadProperties(ins, arch); known {
+		return form, true
+	}
+	spec, known := x86NumericalSBReadSpecs[ins.Op]
+	if !known || len(ins.Args) != 2 || arch != "amd64" && arch != "386" || arch == "386" && spec.rejectedOn386 {
+		return x86NumericalSBReadForm{}, false
+	}
+	form := x86NumericalSBReadForm{spec: spec, partner: 1}
+	if spec.extension {
+		extension, recognized, err := x86ScalarExtensionProperties(ins.Op, ins, arch)
+		if !recognized || err != nil {
+			return x86NumericalSBReadForm{}, false
+		}
+		form.spec.sourceBytes = int64(extension.spec.sourceBits / 8)
+		form.spec.gpBytes = int64(extension.spec.destinationBits / 8)
+	} else if spec.compare {
+		comparison, recognized, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+		if !recognized || err != nil || comparison.memory < 0 {
+			return x86NumericalSBReadForm{}, false
+		}
+		form.operand, form.partner = comparison.memory, 1-comparison.memory
+	} else {
+		partner := ins.Args[form.partner]
+		switch partner.Kind {
+		case OpReg:
+			valid := isX86YrlRegisterForArch(partner.Reg, arch)
+			if spec.gpBytes == 1 {
+				valid = isGoYmbRegisterForArch(partner.Reg, arch)
+			}
+			if !valid {
+				return x86NumericalSBReadForm{}, false
+			}
+		default:
+			return x86NumericalSBReadForm{}, false
+		}
+	}
+	operand := ins.Args[form.operand]
+	if operand.Kind != OpSym || strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+		return x86NumericalSBReadForm{}, false
+	}
+	return form, true
+}
+
+func x86NumericalSBReadShape(ins Instr, arch string) (int, int64, bool) {
+	form, valid := x86NumericalSBReadProperties(ins, arch)
+	return form.operand, form.spec.sourceBytes, valid
+}
+
+type numericalSBRead struct {
+	function          string
+	instruction       int
+	operand           int
+	original          Instr
+	pc, offset, width int64
+	code              []byte
+	relocation        gostaticstorage.TextRelocation
+	variable          gostaticstorage.Variable
+	owner             *GoNumericalStorageOwner
+	ownerOrdinal      int
+}
+
+func numericalNativeName(name, pkg string) string {
+	name = strings.ReplaceAll(strings.ReplaceAll(name, "∕", "/"), "·", ".")
+	if strings.HasPrefix(name, ".") {
+		name = pkg + name
+	}
+	return name
+}
+
+func numericalSameInstruction(a, b Instr, pkg, arch string) bool {
+	if a.Op != b.Op || len(a.Args) != len(b.Args) {
+		return false
+	}
+	form, valid := x86NumericalSBReadProperties(a, arch)
+	otherForm, otherValid := x86NumericalSBReadProperties(b, arch)
+	if !valid || !otherValid || form != otherForm {
+		return false
+	}
+	for i, operand := range a.Args {
+		other := b.Args[i]
+		if operand.Kind == OpReg && other.Kind == OpReg && form.spec.vector == x86NumericalSBScalar {
+			width := form.spec.gpBytes
+			root, valid := amd64FullRegBase(operand.Reg)
+			otherRoot, otherValid := amd64FullRegBase(other.Reg)
+			if !valid || !otherValid || root != otherRoot || x86CallerByteMask(operand.Reg, width) != x86CallerByteMask(other.Reg, width) {
+				return false
+			}
+			// Actual cmd/asm byte-register rewriting may print AL for source
+			// AX. Compare the exact byte lane, never just the wider GP alias.
+			operand.Reg, other.Reg = root, root
+		}
+		if operand.Kind == OpSym {
+			base, offset, ok := parseSBRef(operand.Sym)
+			otherBase, otherOffset, otherOK := parseSBRef(other.Sym)
+			if !ok || !otherOK {
+				return false
+			}
+			operand.Sym = fmt.Sprintf("%s%+d(SB)", numericalNativeName(base, pkg), offset)
+			other.Sym = fmt.Sprintf("%s%+d(SB)", numericalNativeName(otherBase, pkg), otherOffset)
+		}
+		if !reflect.DeepEqual(operand, other) {
+			return false
+		}
+	}
+	return true
+}
+
+// Both listings are actual assembler output. The expanded listing's physical
+// line associates a unique original expanded instruction with a native PC;
+// original listing and binary PC tables retain its original CPP source role.
+// No line-only mapping or relocation name can independently create a read.
+type numericalListingRow struct {
+	position string
+	ins      Instr
+}
+
+// cmd/internal/obj's writer emits the same ordered flags and PC rows for both
+// IsText kinds. Historical writers put align after the frame; current writers
+// put it before. Neither this display nor ArgsSizeUnknown creates a Go entry:
+// complete original/expanded/compiler objects still bind kind, ABI and bytes.
+const numericalListingFlags = `(?: static)?(?: dupok)?(?: cfunc)?(?: nosplit)?(?: topframe)?(?: asm)?`
+const numericalListingFrame = `args=0x[0-9a-f]+ locals=0x[0-9a-f]+(?: funcid=0x[0-9a-f]+)?`
+
+var numericalListingHeader = regexp.MustCompile(`^(\S+) STEXT(?:FIPS)?` + numericalListingFlags +
+	` size=[0-9]+ (?:align=0x[0-9a-f]+ ` + numericalListingFrame + `|` +
+	numericalListingFrame + `(?: align=0x[0-9a-f]+)?)(?: leaf)?$`)
+
+func numericalListingRows(raw []byte) (map[string]map[int64][]numericalListingRow, error) {
+	rows := make(map[string]map[int64][]numericalListingRow)
+	scanner := bufio.NewScanner(bytes.NewReader(raw))
+	scanner.Buffer(nil, 4<<20)
+	name := ""
+	for scanner.Scan() {
+		line := scanner.Text()
+		if header := numericalListingHeader.FindStringSubmatch(line); header != nil {
+			name = header[1]
+			if rows[name] != nil {
+				return nil, numericalSBContext("duplicate listing TEXT")
+			}
+			rows[name] = make(map[int64][]numericalListingRow)
+			continue
+		}
+		match := goAMD64FrameRow.FindStringSubmatch(line)
+		if match == nil {
+			fields := strings.Fields(line)
+			for index, field := range fields {
+				if index > 0 && strings.HasPrefix(field, "STEXT") ||
+					strings.HasPrefix(field, "args=") || strings.HasPrefix(field, "locals=") {
+					return nil, numericalSBContext("unknown complete native listing TEXT role")
+				}
+			}
+			if len(fields) != 0 {
+				// The writer emits Prog rows before byte/relocation displays.
+				// No other display, including a truncated or unknown header,
+				// can carry the previous TEXT's PC ownership forward.
+				name = ""
+			}
+			continue // Complete binary records, not this display parser, validate objects.
+		}
+		pc, err := strconv.ParseInt(match[1], 16, 64)
+		if err != nil || rows[name] == nil {
+			return nil, numericalSBContext("unbound native listing PC")
+		}
+		parsed, err := Parse(ArchAMD64, "TEXT ·row(SB),4,$0\n"+match[3]+"\n")
+		if err != nil || len(parsed.Funcs) != 1 || len(parsed.Funcs[0].Instrs) != 2 || parsed.Funcs[0].Instrs[1].Op == OpTEXT {
+			continue // TEXT/FUNCDATA/PCDATA are not a machine read.
+		}
+		rows[name][pc] = append(rows[name][pc], numericalListingRow{match[2], parsed.Funcs[0].Instrs[1]})
+	}
+	return rows, scanner.Err()
+}
+
+func numericalRelocationEqual(a, b []gostaticstorage.TextRelocation) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		x, y := a[i], b[i]
+		if x.Offset != y.Offset || x.Size != y.Size || x.Type != y.Type || x.Add != y.Add ||
+			x.Target.Name != y.Target.Name || x.Target.ABI != y.Target.ABI || x.Target.ABIKnown != y.Target.ABIKnown || x.Target.Package != y.Target.Package {
+			return false
+		}
+	}
+	return true
+}
+
+func numericalInstructionRelocation(text gostaticstorage.TextRecord, pc int64, native x86asm.Inst, arch string) (gostaticstorage.TextRelocation, int64, error) {
+	var selected []gostaticstorage.TextRelocation
+	for _, relocation := range text.Relocations {
+		if relocation.Offset < pc+int64(native.Len) && relocation.Offset+relocation.Size > pc {
+			selected = append(selected, relocation)
+		}
+	}
+	if len(selected) != 1 || selected[0].Size != 4 || !selected[0].Target.ABIKnown || selected[0].Target.ABI != 0 {
+		return gostaticstorage.TextRelocation{}, 0, numericalSBContext("read needs one exact numerical storage relocation/ABI")
+	}
+	r := selected[0]
+	field := native.PCRelOff
+	offset := r.Add
+	if arch == "amd64" {
+		if native.PCRel != 4 || r.Type != 14 || native.AddrSize != 64 {
+			return r, 0, numericalSBContext("unknown AMD64 PC-relative read rule")
+		}
+		tail := int64(native.Len - native.PCRelOff - native.PCRel)
+		if tail < 0 || offset > math.MaxInt64-tail {
+			return r, 0, numericalSBContext("PC-relative read addend overflow")
+		}
+		offset += tail
+	} else {
+		if native.PCRel != 0 || r.Type != 1 || native.AddrSize != 32 {
+			return r, 0, numericalSBContext("unknown 386 absolute read rule")
+		}
+		// These complete scalar forms use mod=00/rm=101's absolute disp32.
+		// Locate that physical field from the opcode/ModRM, not from Add or
+		// the listing. No SIB/index or address-size-prefix permission is given.
+		code := text.Code[pc : pc+int64(native.Len)]
+		prefix := 0
+		for prefix < len(code) && code[prefix] == 0x66 {
+			prefix++
+		}
+		if prefix >= len(code) {
+			return r, 0, numericalSBContext("truncated absolute read opcode")
+		}
+		modrm := prefix + 1
+		if code[prefix] == 0x0f {
+			modrm++
+			if prefix+1 < len(code) && (code[prefix+1] == 0x38 || code[prefix+1] == 0x3a) {
+				modrm++
+			}
+		}
+		if modrm >= len(code) || code[modrm]&0xc7 != 5 {
+			return r, 0, numericalSBContext("unbound absolute scalar ModRM")
+		}
+		field = modrm + 1
+	}
+	if r.Offset != pc+int64(field) || field < 0 || field+4 > native.Len {
+		return r, 0, numericalSBContext("relocation does not bind the decoded address field")
+	}
+	return r, offset, nil
+}
+
+func numericalOwnerContains(variable gostaticstorage.Variable, offset, width int64) bool {
+	if offset < 0 || width <= 0 || offset > variable.Size || width > variable.Size-offset {
+		return false
+	}
+	for byteOffset := offset; byteOffset < offset+width; byteOffset++ {
+		found := false
+		for _, span := range variable.Numerical {
+			if span.Offset <= byteOffset && byteOffset-span.Offset < span.Length {
+				found = true
+				break
+			}
+		}
+		if !found {
+			return false
+		}
+	}
+	return true
+}
diff --git a/go_x86_numerical_read_owned_role_test.go b/go_x86_numerical_read_owned_role_test.go
new file mode 100644
index 000000000..4b8d8bf7e
--- /dev/null
+++ b/go_x86_numerical_read_owned_role_test.go
@@ -0,0 +1,236 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// The proxy contains only generated first-party fixture code. Actual Go
+// download/extraction and go list, not invented selection JSON, select its role.
+func numericalCachedFixture(t *testing.T, assembly bool) GoX86NumericalReadCaptureRequest {
+	return numericalCachedFixtureWithAlias(t, assembly, false)
+}
+
+func numericalCachedFixtureWithAlias(t *testing.T, assembly, alias bool) GoX86NumericalReadCaptureRequest {
+	t.Helper()
+	pkg, template, _, _ := numericalSBFixture(t, "amd64")
+	proxy, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// A comma is a GOPROXY separator unless the local path is escaped. The
+	// suffix deliberately says "off", so a broken fixture cannot use network
+	// fallback while this regression reproduces the parsing failure.
+	proxy = filepath.Join(proxy, "proxy,off")
+	if err := os.Mkdir(proxy, 0700); err != nil {
+		t.Fatal(err)
+	}
+	cache, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		// This exact cache was freshly allocated by this fixture. Go makes
+		// extracted module directories read-only; restore only our own tree.
+		if err := filepath.WalkDir(cache, func(name string, entry os.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if entry.IsDir() {
+				return os.Chmod(name, 0700)
+			}
+			return nil
+		}); err != nil {
+			t.Error(err)
+		}
+	})
+	version := "v1.0.0"
+	goSource := "package numericalfixture\nvar Mutable [32]byte\n"
+	files := map[string][]byte{
+		"go.mod": []byte("module " + pkg.Path + "\ngo 1.27\n"), "value.go": []byte(goSource),
+	}
+	if assembly {
+		version = "v1.0.1"
+		files["value.go"] = append(files["value.go"], []byte("func Feature() byte\n")...)
+		files[template.AssemblyFile], err = os.ReadFile(filepath.Join(template.Directory, template.AssemblyFile))
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	var archive bytes.Buffer
+	writer := zip.NewWriter(&archive)
+	for _, name := range []string{"go.mod", "value.go", template.AssemblyFile} {
+		data, exists := files[name]
+		if !exists {
+			continue
+		}
+		member, err := writer.Create(pkg.Path + "@" + version + "/" + name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := member.Write(data); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	versions := filepath.Join(proxy, filepath.FromSlash(pkg.Path), "@v")
+	if err := os.MkdirAll(versions, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for suffix, data := range map[string][]byte{
+		".mod": files["go.mod"], ".zip": archive.Bytes(),
+		".info": []byte(`{"Version":"` + version + `","Time":"2026-01-01T00:00:00Z"}`),
+	} {
+		if err := os.WriteFile(filepath.Join(versions, version+suffix), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var environment []string
+	for _, pair := range template.Environment {
+		key, _, _ := strings.Cut(pair, "=")
+		if key != "GOMODCACHE" && key != "GOSUMDB" {
+			environment = append(environment, pair)
+		}
+	}
+	environment = append(environment, "GOMODCACHE="+cache, "GOSUMDB=off")
+	downloadEnvironment := append([]string(nil), environment...)
+	proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, pair := range downloadEnvironment {
+		if strings.HasPrefix(pair, "GOPROXY=") {
+			downloadEnvironment[index] = "GOPROXY=" + proxyURL
+		}
+	}
+	run := func(directory string, env []string, arguments ...string) []byte {
+		t.Helper()
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		command := exec.CommandContext(ctx, template.GoBinary, arguments...)
+		command.Dir, command.Env = directory, env
+		output, diagnostics, err := runtimeOracleMachineOutput(ctx, command)
+		if err != nil {
+			t.Fatalf("actual first-party cache fixture command %q: %v\n%s\n%s", arguments, err, output, diagnostics)
+		}
+		t.Logf("ACTUAL_FIRST_PARTY_CACHE_COMMAND directory=%q binary=%q argv=%q stdout=%q stderr=%q", directory, template.GoBinary, arguments, output, diagnostics)
+		return output
+	}
+	data := run(template.Directory, downloadEnvironment, "mod", "download", "-json", pkg.Path+"@"+version)
+	var downloaded struct{ Path, Version, Dir, Error string }
+	if err := json.Unmarshal(data, &downloaded); err != nil || downloaded.Error != "" ||
+		downloaded.Path != pkg.Path || downloaded.Version != version || downloaded.Dir == "" {
+		t.Fatal("actual first-party Go download did not select exact original cache source", err)
+	}
+	if alias {
+		alternate := strings.ToUpper(cache)
+		original, err := os.Stat(cache)
+		if err != nil {
+			t.Fatal(err)
+		}
+		other, err := os.Stat(alternate)
+		if err != nil || !os.SameFile(original, other) {
+			t.Log("physical cache has no case alias on this filesystem; distinct-case directory control covers it")
+			return GoX86NumericalReadCaptureRequest{}
+		}
+		if alternate == cache {
+			t.Fatal("case-alias fixture has no spelling difference")
+		}
+		for index, pair := range environment {
+			if strings.HasPrefix(pair, "GOMODCACHE=") {
+				environment[index] = "GOMODCACHE=" + alternate
+			}
+		}
+		t.Logf("ACTUAL_FIRST_PARTY_CACHE_ALIAS source=%q cache=%q alias=%q same_file=true", downloaded.Dir, cache, alternate)
+	}
+	selection := run(downloaded.Dir, environment, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+	var selected goAMD64FrameSelection
+	if err := json.Unmarshal(selection, &selected); err != nil || selected.Dir != downloaded.Dir ||
+		selected.Module == nil || !selected.Module.Main || selected.Module.Version != "" || selected.Module.Dir != downloaded.Dir {
+		t.Fatal("real cached-CWD Main=true/empty-version precondition differs", err)
+	}
+	return GoX86NumericalReadCaptureRequest{GoBinary: template.GoBinary, Directory: downloaded.Dir, PackagePath: pkg.Path,
+		AssemblyFile: template.AssemblyFile, Target: template.Target, Environment: environment}
+}
+
+func TestGoX86NumericalSBReadCachedSourceCannotAcquireOwnedRole(t *testing.T) {
+	testNumericalCachedSourceCannotAcquireOwnedRole(t, false)
+}
+
+func TestGoX86NumericalSBReadCachedSourceCaseAliasCannotAcquireOwnedRole(t *testing.T) {
+	testNumericalCachedSourceCannotAcquireOwnedRole(t, true)
+}
+
+func testNumericalCachedSourceCannotAcquireOwnedRole(t *testing.T, alias bool) {
+	t.Run("ordinary data owner", func(t *testing.T) {
+		request := numericalCachedFixtureWithAlias(t, false, alias)
+		if request.GoBinary == "" {
+			return
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+			GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+			Target: request.Target, Environment: request.Environment,
+			Variables: []GoNumericalStorageReference{{PackagePath: request.PackagePath, Name: "Mutable"}},
+		})
+		if owner != nil {
+			owner.Close()
+		}
+		if owner != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("downloaded cache acquired an ordinary owned storage role", err)
+		}
+	})
+	t.Run("numerical original source", func(t *testing.T) {
+		request := numericalCachedFixtureWithAlias(t, true, alias)
+		if request.GoBinary == "" {
+			return
+		}
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		// The separate positive SDK owner requires canonical command roots.
+		// Preserve the alias in request itself: that is the negative source
+		// admission input, not a reason to break this independent control.
+		ownerEnvironment := append([]string(nil), request.Environment...)
+		for index, pair := range ownerEnvironment {
+			if strings.HasPrefix(pair, "GOMODCACHE=") {
+				physical, err := sourcepath.Resolve(strings.TrimPrefix(pair, "GOMODCACHE="))
+				if err != nil {
+					t.Fatal(err)
+				}
+				ownerEnvironment[index] = "GOMODCACHE=" + physical
+			}
+		}
+		owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+			GoBinary: request.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "cpu"),
+			PackagePath: "internal/cpu", Target: request.Target, Environment: ownerEnvironment, SDKCPU: true,
+			Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+		})
+		if err != nil {
+			t.Fatal("separate actual SDK numerical owner precondition", err)
+		}
+		defer owner.Close()
+		request.Owners = []*GoNumericalStorageOwner{owner}
+		source, err := CaptureGoX86NumericalReadSource(ctx, request)
+		if source != nil {
+			source.Close()
+		}
+		if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("downloaded cache acquired an owned numerical original source role", err)
+		}
+	})
+}
diff --git a/go_x86_numerical_read_revocation.go b/go_x86_numerical_read_revocation.go
new file mode 100644
index 000000000..5fa437171
--- /dev/null
+++ b/go_x86_numerical_read_revocation.go
@@ -0,0 +1,13 @@
+package plan9asm
+
+// Revoke permanently invalidates this original source's read bindings without
+// disposing any artifact or invoking borrowed contexts/owners. Owning adapters
+// can revoke publication immediately while deferring Close until callbacks end.
+// It creates no source, numerical read, linked minimum or entry permission.
+func (source *GoX86NumericalReadSource) Revoke() error {
+	if source == nil || source.identity != source {
+		return numericalSBContext("foreign numerical source cannot revoke original bindings")
+	}
+	source.revoked.Store(true)
+	return nil
+}
diff --git a/go_x86_numerical_read_revocation_final_go127_test.go b/go_x86_numerical_read_revocation_final_go127_test.go
new file mode 100644
index 000000000..cb7e6e3e8
--- /dev/null
+++ b/go_x86_numerical_read_revocation_final_go127_test.go
@@ -0,0 +1,271 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The callback route is observed only by this regression. It grants no source,
+// caller, entry or read authority; all inputs come from the complete SDK owner.
+type numericalRevokeCallbackContext struct {
+	context.Context
+	mu       sync.Mutex
+	callback func()
+}
+
+func (ctx *numericalRevokeCallbackContext) Err() error {
+	ctx.mu.Lock()
+	callback := ctx.callback
+	ctx.mu.Unlock()
+	if callback != nil {
+		callback()
+	}
+	return ctx.Context.Err()
+}
+
+func TestGoX86NumericalReadRevokeDuringFinalSDKCallback(t *testing.T) {
+	for _, api := range []string{"Verify", "Readback", "CheckReadback", "text", "module", "go-module"} {
+		t.Run(api, func(t *testing.T) { numericalRevokeDuringFinalSDKCallback(t, api) })
+	}
+}
+
+func numericalRevokeDuringFinalSDKCallback(t *testing.T, api string) {
+	base, request := sdkASMDataRequest(t, "amd64", "hash/crc32")
+	ctx := &numericalRevokeCallbackContext{Context: base}
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary:    request.GoBinary,
+		Directory:   filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: request.Target, Environment: request.Environment, SDKCPU: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(owner.Close)
+	data, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := data.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	literal, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := literal.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment, AssemblyFile: "crc32_amd64.s", ReadonlyLiterals: literal,
+		Owners: []*GoNumericalStorageOwner{owner},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	pkg, file, options := numericalSDKLiteralPackage(t, data, "crc32_amd64.s")
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	report, err := source.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := os.ReadFile(filepath.Join(request.Directory, "crc32_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	invoke := func() (bool, error) {
+		switch api {
+		case "Verify":
+			return false, source.Verify(ctx)
+		case "Readback":
+			raw, err := source.Readback(ctx)
+			return len(raw) != 0, err
+		case "CheckReadback":
+			return false, source.CheckReadback(ctx, report)
+		case "text":
+			ir, err := Translate(file, bound)
+			return ir != "", err
+		case "module":
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := TranslateModuleInContext(context, file, bound)
+			published := !module.IsNil()
+			if published {
+				module.Dispose()
+			}
+			return published, err
+		case "go-module":
+			result, err := TranslateGoModule(pkg, original, GoModuleOptions{GOARCH: "amd64", GOOS: "linux", TargetTriple: bound.TargetTriple,
+				FileName: "crc32_amd64.s", NumericalReads: bound.NumericalReads, ResolveSym: bound.ResolveSym})
+			published := result != nil && !result.Module.IsNil()
+			if published {
+				result.Module.Dispose()
+			}
+			return published, err
+		}
+		return false, fmt.Errorf("unknown API %s", api)
+	}
+	var mu sync.Mutex
+	recording, reached, finalCallback := true, false, ""
+	var goSites numericalFinalSDKCallbackSites
+	ctx.mu.Lock()
+	ctx.callback = func() {
+		key := numericalFinalSDKCallbackKey(api)
+		if key == "" {
+			return
+		}
+		mu.Lock()
+		if api == "go-module" {
+			// Observe the complete actual outer final guard in one API call:
+			// two binding verifies, each with entry and final source verifies.
+			// Repeated Err samples within a source defer are the same site.
+			if !goSites.observe(key) {
+				mu.Unlock()
+				return
+			}
+			reached, finalCallback = true, key
+			mu.Unlock()
+			if err := source.Revoke(); err != nil {
+				t.Error(err)
+			}
+			return
+		}
+		if recording {
+			finalCallback = key
+			mu.Unlock()
+			return
+		}
+		if reached || key != finalCallback {
+			mu.Unlock()
+			return
+		}
+		reached = true
+		mu.Unlock()
+		if err := source.Revoke(); err != nil {
+			t.Error(err)
+		}
+	}
+	ctx.mu.Unlock()
+	if api != "go-module" {
+		baselineArtifact, err := invoke()
+		wantsArtifact := api == "Readback" || api == "text" || api == "module"
+		if err != nil || wantsArtifact && !baselineArtifact {
+			t.Fatal("complete original baseline API failed or lost its artifact", baselineArtifact, err)
+		}
+		mu.Lock()
+		if finalCallback == "" {
+			mu.Unlock()
+			t.Fatal("actual final SDK callback route was not observed")
+		}
+		recording = false
+		mu.Unlock()
+	}
+	published, err := invoke()
+	mu.Lock()
+	observed := reached
+	goCount := len(goSites.seen)
+	mu.Unlock()
+	if !observed {
+		t.Fatal("actual final callback was not reached")
+	}
+	if api == "go-module" && goCount != 4 {
+		t.Fatal("complete actual outer Go-module final guard lost a source-verification site", goCount)
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) || published {
+		t.Fatal("revocation during the last genuine SDK callback published", api, published, err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("final callback revocation was not permanent", err)
+	}
+}
+
+// Test-only route accounting: a repeated context sample is not a new source
+// verification. These keys never grant source or binding authority.
+type numericalFinalSDKCallbackSites struct {
+	seen map[string]bool
+}
+
+func (sites *numericalFinalSDKCallbackSites) observe(key string) bool {
+	if key == "" || len(sites.seen) == 4 || sites.seen[key] {
+		return false
+	}
+	if sites.seen == nil {
+		sites.seen = make(map[string]bool)
+	}
+	sites.seen[key] = true
+	return len(sites.seen) == 4
+}
+
+func TestGoX86NumericalReadFinalSDKCallbackSiteControl(t *testing.T) {
+	var sites numericalFinalSDKCallbackSites
+	if sites.observe("") || len(sites.seen) != 0 {
+		t.Fatal("an unrelated callback acquired a final-guard site")
+	}
+	for _, key := range []string{"binding-one/source-entry", "binding-one/source-final", "binding-two/source-entry"} {
+		if sites.observe(key) || sites.observe(key) {
+			t.Fatal("an early or repeated context sample triggered late revocation", key)
+		}
+	}
+	if len(sites.seen) != 3 || !sites.observe("binding-two/source-final") {
+		t.Fatal("the fourth distinct final-guard site was not reached", len(sites.seen))
+	}
+	for _, key := range []string{"binding-two/source-final", "unexpected-extra-site", ""} {
+		if sites.observe(key) || len(sites.seen) != 4 {
+			t.Fatal("a repeated or excess sample changed the one-shot bounded route", key)
+		}
+	}
+}
+
+func numericalFinalSDKCallbackKey(api string) string {
+	var pcs [64]uintptr
+	frames := runtime.CallersFrames(pcs[:runtime.Callers(2, pcs[:])])
+	var key strings.Builder
+	joined, finish, goFinish := false, false, false
+	for {
+		frame, more := frames.Next()
+		if strings.HasSuffix(frame.Function, ".verifySDKLiteralNumericalSource.func1") {
+			joined = true
+		}
+		if joined {
+			fmt.Fprintf(&key, "%s:%x/", frame.Function, frame.PC)
+		}
+		if api == "go-module" && strings.Contains(frame.Function, ".translateGoModuleInContext.func") {
+			goFinish = true
+			break
+		}
+		if api != "go-module" && strings.HasSuffix(frame.Function, ".finishNumericalReads") {
+			finish = true
+			break
+		}
+		if joined && (api == "Verify" || api == "Readback" || api == "CheckReadback") && strings.HasSuffix(frame.Function, ").Verify") {
+			break
+		}
+		if !more {
+			break
+		}
+	}
+	if !joined || (api == "text" || api == "module") && !finish || api == "go-module" && !goFinish {
+		return ""
+	}
+	return key.String()
+}
diff --git a/go_x86_numerical_read_revocation_go127_test.go b/go_x86_numerical_read_revocation_go127_test.go
new file mode 100644
index 000000000..53e4c7710
--- /dev/null
+++ b/go_x86_numerical_read_revocation_go127_test.go
@@ -0,0 +1,59 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"testing"
+)
+
+func TestGoX86NumericalReadRevokePreservesArtifactLifetime(t *testing.T) {
+	source, err := numericalSDKMapsReadCapture(t, "amd64", "memhash_nosimd_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := source.sdk.originalContext
+	pkg, file, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	owned := source.guard.owned
+	foreign := &GoX86NumericalReadSource{identity: source}
+	if err := foreign.Revoke(); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("foreign source revoked original publication", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("foreign revoke affected original source", err)
+	}
+	if err := source.Revoke(); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Revoke(); err != nil {
+		t.Fatal("revoke was not idempotent", err)
+	}
+	if info, err := os.Stat(owned); err != nil || !info.IsDir() {
+		t.Fatal("revoke disposed active artifacts", err)
+	}
+	for _, api := range []string{"Verify", "Bind", "Translate"} {
+		var err error
+		switch api {
+		case "Verify":
+			err = source.Verify(ctx)
+		case "Bind":
+			_, err = source.BindNumericalReads(ctx, pkg, file, options)
+		case "Translate":
+			_, err = Translate(file, bound)
+		}
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("revoked original source retained publication", api, err)
+		}
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("owning Close did not release deferred artifacts", err)
+	}
+}
diff --git a/go_x86_numerical_read_runtime_darwin_test.go b/go_x86_numerical_read_runtime_darwin_test.go
new file mode 100644
index 000000000..945179d99
--- /dev/null
+++ b/go_x86_numerical_read_runtime_darwin_test.go
@@ -0,0 +1,25 @@
+//go:build go1.27 && darwin && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestGoX86NumericalSBReadMutableHostDiagnostic(t *testing.T) {
+	if runtime.GOARCH == "arm64" && !rosettaAvailable() {
+		t.Fatal("required AMD64 host diagnostic needs Rosetta")
+	}
+	execution := x86FloatCompareExecutionTools(t)
+	t.Log("retargeted host numerical/volatile/canary/fault diagnostic, not Linux native Go ABI execution")
+	numericalRuntimeExecute(t, "amd64", execution, false)
+}
+
+func TestGoX86NumericalSBReadMutableLocalHostDiagnostic(t *testing.T) {
+	if runtime.GOARCH == "arm64" && !rosettaAvailable() {
+		t.Fatal("required AMD64 local host diagnostic needs Rosetta")
+	}
+	t.Log("retargeted composed local numerical/canary/fault diagnostic, not Linux native Go ABI execution")
+	numericalLocalMutableRuntime(t, x86FloatCompareExecutionTools(t), false)
+}
diff --git a/go_x86_numerical_read_runtime_linux_test.go b/go_x86_numerical_read_runtime_linux_test.go
new file mode 100644
index 000000000..37980aa8d
--- /dev/null
+++ b/go_x86_numerical_read_runtime_linux_test.go
@@ -0,0 +1,28 @@
+//go:build go1.27 && linux && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableAMD64(t *testing.T) {
+	numericalRuntimeExecute(t, "amd64", x86FloatCompareExecutionTools(t), true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutableLocalAMD64(t *testing.T) {
+	numericalLocalMutableRuntime(t, x86FloatCompareExecutionTools(t), true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86NumericalSBReadMutable386(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	compiler, compilerErr := exec.LookPath("i686-linux-gnu-gcc")
+	qemu, qemuErr := exec.LookPath("qemu-i386")
+	if llc == "" || compilerErr != nil || qemuErr != nil {
+		t.Fatal("LLVM22, i686 Linux compiler and QEMU required", compilerErr, qemuErr)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-no-pie"}, prefix: []string{qemu, "-L", "/usr/i686-linux-gnu"}}
+	numericalRuntimeExecute(t, "386", execution, true)
+}
diff --git a/go_x86_numerical_read_runtime_test.go b/go_x86_numerical_read_runtime_test.go
new file mode 100644
index 000000000..ef01d19ac
--- /dev/null
+++ b/go_x86_numerical_read_runtime_test.go
@@ -0,0 +1,280 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// C compilers must only refer to ordinary C storage labels. GCC emits an
+// asm-label spelling verbatim, so a Go-qualified name containing '/' is not
+// portable as a C __asm__ name. Quoted assembler aliases bind the exact LLVM
+// names without changing the storage, read widths or fault/canary oracles.
+const numericalRuntimeStorageAliases = `
+#ifdef __APPLE__
+#define NUMERICAL_STORAGE_ALIAS(name, storage) \
+    __asm__(".globl \"_" name "\"\n\"_" name "\" = _" #storage "\n")
+#else
+#define NUMERICAL_STORAGE_ALIAS(name, storage) \
+    __asm__(".globl \"" name "\"\n.set \"" name "\", " #storage "\n")
+#endif
+`
+
+// This carrier provides actual mutable linked numerical storage. It is not a
+// Go native-entry/ABI0 permission: the required Linux oracle separately executes
+// the original Go-linked declarations. A retargeted host run is diagnostic only.
+func numericalRuntimeC(cases []numericalExecutionCase, arch string) string {
+	word, seed := "uint64_t", "UINT64_C(0x8877665544332211)"
+	if arch == "386" {
+		word, seed = "uint32_t", "UINT64_C(0x44332211)"
+	}
+	var c strings.Builder
+	c.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+`)
+	c.WriteString(numericalRuntimeStorageAliases)
+	c.WriteString(numericalRuntimeFaultObservationC)
+	c.WriteString(`
+_Alignas(4096) unsigned char mutable[4096];
+_Alignas(4096) unsigned char cpu[4096];
+NUMERICAL_STORAGE_ALIAS("example.invalid/numericalfixture.Mutable", mutable);
+NUMERICAL_STORAGE_ALIAS("internal/cpu.X86", cpu);
+static uint64_t mask(unsigned n) {
+ if(n==8) return UINT64_MAX;
+ return (UINT64_C(1)<<(n*8))-1;
+}
+static uint64_t load(unsigned n) {
+ uint64_t value=0;
+ for(unsigned i=0;i<n;i++) value|=(uint64_t)mutable[3+i]<<(8*i);
+ return value;
+}
+`)
+	for index := range cases {
+		fmt.Fprintf(&c, "extern %s numerical%d(void);\n", word, index)
+	}
+	c.WriteString("int main(void) {\n memset(mutable,0xa5,sizeof(mutable));\n memset(cpu,0x6b,sizeof(cpu));\n")
+	c.WriteString(" for(unsigned round=0;round<3;round++) {\n  for(unsigned i=0;i<32;i++) mutable[i]=(unsigned char)(i*37+round*71);\n  cpu[64]=round&1;\n")
+	dead := -1
+	for index, test := range cases {
+		fmt.Fprintf(&c, "  { uint64_t want=%s, value=load(%d);\n", seed, test.source)
+		switch {
+		case test.dead:
+			dead = index
+			c.WriteString("   want=7;\n")
+		case test.cpu:
+			c.WriteString("   want=(want&~UINT64_C(255))|cpu[64];\n")
+		case test.compare:
+			partner := seed
+			if test.partnerHigh {
+				partner = "(" + seed + ">>8)"
+			}
+			if test.immediate {
+				partner = "UINT64_C(4294967295)"
+				if test.source == 8 {
+					partner = "UINT64_MAX" // Actual CMPQ sign-extended imm32.
+				}
+			}
+			fmt.Fprintf(&c, "   uint64_t a=value, b=%s&mask(%d);\n", partner, test.source)
+			if test.reversed {
+				c.WriteString("   uint64_t swap=a; a=b; b=swap;\n")
+			}
+			switch test.predicate {
+			case "LT":
+				fmt.Fprintf(&c, "   uint64_t sign=UINT64_C(1)<<%d; want=(a^sign)<(b^sign);\n", test.source*8-1)
+			case "CS":
+				c.WriteString("   want=a<b;\n")
+			case "EQ":
+				c.WriteString("   want=a==b;\n")
+			}
+		default:
+			if test.signed {
+				fmt.Fprintf(&c, "   if(value&(UINT64_C(1)<<%d)) value|=~mask(%d);\n", test.source*8-1, test.source)
+			}
+			if test.high {
+				c.WriteString("   want=(want&~UINT64_C(0xff00))|(value<<8);\n")
+			} else if test.gp == 4 || test.gp == 8 {
+				fmt.Fprintf(&c, "   want=value&mask(%d);\n", test.gp)
+			} else {
+				fmt.Fprintf(&c, "   want=(want&~mask(%d))|(value&mask(%d));\n", test.gp, test.gp)
+			}
+		}
+		fmt.Fprintf(&c, "   uint64_t got=numerical%d();\n   if(got!=want) { fprintf(stderr,\"round/row=%%u/%d got=%%llx want=%%llx\\n\",round,(unsigned long long)got,(unsigned long long)want); return 1; }\n   printf(\"%%016llx\\n\",(unsigned long long)got);\n  }\n", index, index)
+	}
+	c.WriteString("  for(unsigned i=32;i<sizeof(mutable);i++) if(mutable[i]!=0xa5) return 2;\n  for(unsigned i=0;i<sizeof(cpu);i++) if(i!=64&&cpu[i]!=0x6b) return 3;\n }\n")
+	// A volatile read must still happen after both IR and backend optimization,
+	// even when its result is overwritten. The source is inside the valid extent;
+	// PROT_NONE, not an out-of-bounds source, creates this independent fault axis.
+	if dead >= 0 {
+		fmt.Fprintf(&c, `
+ pid_t child=fork();
+ if(child<0) return 4;
+ if(!child) {
+  struct rlimit no_core={0,0};
+  if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+  numerical_fault_begin(mutable,sizeof(mutable));
+  if(mprotect(mutable,sizeof(mutable),PROT_NONE)) _exit(5);
+  (void)numerical%d();
+  _exit(6);
+ }
+ int status=0;
+ if(waitpid(child,&status,0)!=child) return 7;
+ if(!numerical_fault_status(status)) return 8;
+`, dead)
+	}
+	c.WriteString(" return 0;\n}\n")
+	return c.String()
+}
+
+func numericalRuntimeWidthFaultC(cases []numericalExecutionCase, arch string) string {
+	word := "uint64_t"
+	if arch == "386" {
+		word = "uint32_t"
+	}
+	var c strings.Builder
+	c.WriteString(`#include <stdint.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+`)
+	c.WriteString(numericalRuntimeStorageAliases)
+	c.WriteString(numericalRuntimeFaultObservationC)
+	c.WriteString(`
+_Alignas(4096) unsigned char carrier[8192];
+unsigned char cpu[164];
+NUMERICAL_STORAGE_ALIAS("internal/cpu.X86", cpu);
+#ifdef __APPLE__
+__asm__(".globl \"_example.invalid/numericalfixture.Mutable\"\n"
+        "\"_example.invalid/numericalfixture.Mutable\" = _carrier + 4092\n");
+#else
+__asm__(".globl \"example.invalid/numericalfixture.Mutable\"\n"
+        ".set \"example.invalid/numericalfixture.Mutable\", carrier + 4092\n");
+#endif
+`)
+	for index := range cases {
+		fmt.Fprintf(&c, "extern %s numerical%d(void);\n", word, index)
+	}
+	c.WriteString("int main(void) {\n memset(carrier,0x83,sizeof(carrier));\n")
+	for index, test := range cases {
+		fault := test.source > 1 && !test.cpu
+		fmt.Fprintf(&c, `
+ { pid_t child=fork();
+  if(child<0) return 1;
+  if(!child) {
+   struct rlimit no_core={0,0};
+   if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+   numerical_fault_begin(carrier+4096,4096);
+   if(mprotect(carrier+4096,4096,PROT_NONE)) _exit(2);
+   (void)numerical%d();
+   _exit(0);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return 3;
+`, index)
+		if fault {
+			c.WriteString("  if(!numerical_fault_status(status)) return 4;\n")
+		} else {
+			c.WriteString("  if(!WIFEXITED(status)||WEXITSTATUS(status)) return 5;\n")
+		}
+		c.WriteString(" }\n")
+	}
+	c.WriteString(" return 0;\n}\n")
+	return c.String()
+}
+
+func numericalRuntimeIR(ir string, pkg GoPackage, cases []numericalExecutionCase, arch string) string {
+	word := "i64"
+	if arch == "386" {
+		word = "i32"
+	}
+	var wrappers strings.Builder
+	wrappers.WriteString(ir)
+	for index, test := range cases {
+		fmt.Fprintf(&wrappers, "define %s @numerical%d() {\n %%value=call %s %s()\n ret %s %%value\n}\n",
+			word, index, word, llvmGlobal(pkg.Path+"."+test.name), word)
+	}
+	return wrappers.String()
+}
+
+func numericalRuntimeExecute(t *testing.T, arch string, execution x86FloatCompareExecution, original bool) {
+	t.Helper()
+	pkg, file, options, cases := numericalExecutionFixture(t, arch)
+	ir := numericalFamilyTranslate(t, "context", pkg, file, options)
+	ir = numericalRuntimeIR(ir, pkg, cases, arch)
+	main := numericalRuntimeC(cases, arch)
+	var expected []byte
+	if original {
+		expected = numericalOriginalGoRuntime(t, options, cases, execution)
+	}
+	numericalLLVM22Axes(t, ir, execution.triple, func(t *testing.T, object, _ string) {
+		dir := t.TempDir()
+		source, executable := filepath.Join(dir, "main.c"), filepath.Join(dir, "mutable")
+		if err := os.WriteFile(source, []byte(main), 0600); err != nil {
+			t.Fatal(err)
+		}
+		compiler := append([]string(nil), execution.compiler...)
+		compiler = append(compiler, "-O2", object, source, "-o", executable)
+		x86FloatCompareCaptureCommand(t, exec.Command(compiler[0], compiler[1:]...))
+		output := execution.run(t, executable)
+		if original && !bytes.Equal(output, expected) {
+			t.Fatalf("actual original Go/LLVM mutable results differ:\nGo=%s\nLLVM=%s", expected, output)
+		}
+		widthSource, widthExecutable := filepath.Join(dir, "width.c"), filepath.Join(dir, "width")
+		if err := os.WriteFile(widthSource, []byte(numericalRuntimeWidthFaultC(cases, arch)), 0600); err != nil {
+			t.Fatal(err)
+		}
+		compiler = append([]string(nil), execution.compiler...)
+		compiler = append(compiler, "-O2", object, widthSource, "-o", widthExecutable)
+		x86FloatCompareCaptureCommand(t, exec.Command(compiler[0], compiler[1:]...))
+		if output := execution.run(t, widthExecutable); len(output) != 0 {
+			t.Fatal("unexpected width/fault oracle output", string(output))
+		}
+	})
+}
+
+func numericalOriginalGoRuntime(t *testing.T, options Options, cases []numericalExecutionCase, execution x86FloatCompareExecution) []byte {
+	t.Helper()
+	root := filepath.Dir(options.NumericalReads.source.request.Directory)
+	dir := t.TempDir()
+	var main strings.Builder
+	main.WriteString("package main\nimport (\"fmt\"; data \"example.invalid/numericalfixture\"; asm \"example.invalid/numericalfixture/consumer\")\nfunc cpuGet() byte\nfunc cpuSet(value byte)\nfunc main() {\n old:=cpuGet(); defer cpuSet(old)\n")
+	fmt.Fprintf(&main, " values:=make([]uint64,%d)\n for round:=0;round<3;round++ {\n  for i:=range data.Mutable { data.Mutable[i]=byte(i*37+round*71) }\n  cpuSet(byte(round&1))\n", len(cases))
+	for index, test := range cases {
+		fmt.Fprintf(&main, "  values[%d]=uint64(asm.%s())\n", index, test.name)
+	}
+	main.WriteString("  cpuSet(old)\n  for _,value:=range values { fmt.Printf(\"%016x\\n\",value) }\n  if asm.Sentinel!=0x5a { panic(\"read changed source sentinel\") }\n }\n}\n")
+	assembly := "#include \"textflag.h\"\nTEXT ·cpuGet(SB),NOSPLIT,$0-1\nMOVB internal∕cpu·X86+64(SB),AL\nMOVB AL,ret+0(FP)\nRET\nTEXT ·cpuSet(SB),NOSPLIT,$0-1\nMOVB value+0(FP),AL\nMOVB AL,internal∕cpu·X86+64(SB)\nRET\n"
+	for name, data := range map[string]string{
+		"go.mod":  "module numericaloracle\ngo 1.27\nrequire example.invalid/numericalfixture v0.0.0\nreplace example.invalid/numericalfixture => " + strconv.Quote(filepath.ToSlash(root)) + "\n",
+		"main.go": main.String(), "cpu_" + options.Goarch + ".s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	request := options.NumericalReads.source.request
+	executable := filepath.Join(dir, "original")
+	command := exec.Command(request.GoBinary, "build", "-p=1", "-mod=mod", "-o", executable, ".")
+	command.Dir, command.Env = dir, request.Environment
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, executable)
+	if err := options.NumericalReads.source.Verify(options.NumericalReads.context); err != nil {
+		t.Fatal("original Go execution changed a sealed source or owner", err)
+	}
+	return output
+}
diff --git a/go_x86_numerical_read_sdk.go b/go_x86_numerical_read_sdk.go
new file mode 100644
index 000000000..e68b1fe7f
--- /dev/null
+++ b/go_x86_numerical_read_sdk.go
@@ -0,0 +1,350 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type numericalSBSourceRole uint8
+
+const (
+	numericalSBOwnedSource numericalSBSourceRole = iota + 1
+	numericalSBSDKSource
+)
+
+// Owned sources retain their actual directory query. All SDK observers use
+// the same original logical package selector, including its raw Match field;
+// a directory query can otherwise select a different module/vendor namespace.
+func (source *GoX86NumericalReadSource) packageQuery() string {
+	if source.role == numericalSBSDKSource {
+		return source.request.PackagePath
+	}
+	return "."
+}
+
+// This is input/object observation, not an instruction certificate. It cannot
+// create a numerical source by deserialization, Standard, or a matching hash.
+type numericalSBSDKObservation struct {
+	Graph           []byte
+	Archive         []byte
+	ArchiveMembers  []gostaticstorage.TextMember
+	Imports         map[string]goAMD64FrameSelection
+	Referenced      map[string]gostaticstorage.SDKReferencedArchive
+	Inputs          map[string][32]byte
+	origin          *GoX86NumericalReadSource
+	seal            [32]byte
+	closed          bool
+	context         context.Context
+	originalContext context.Context
+}
+
+// CaptureGoX86SDKNumericalReadSource is an explicit SDK source entry point.
+// SDK source identity is separate from the SDK CPU numerical storage owner;
+// neither a Standard flag nor an assembly symbol supplies that identity.
+func CaptureGoX86SDKNumericalReadSource(ctx context.Context, request GoX86NumericalReadCaptureRequest) (*GoX86NumericalReadSource, error) {
+	return captureGoX86NumericalReadSource(ctx, request, numericalSBSDKSource, false)
+}
+
+func (source *GoX86NumericalReadSource) verifySDKDirectory(root string) error {
+	path := source.request.PackagePath
+	if source.role != numericalSBSDKSource || !filepath.IsLocal(filepath.FromSlash(path)) ||
+		filepath.ToSlash(filepath.Clean(filepath.FromSlash(path))) != path {
+		return numericalSBContext("SDK source needs an exact canonical package path")
+	}
+	wanted := filepath.Join(root, "src", filepath.FromSlash(path))
+	resolved, err := sourcepath.Resolve(wanted)
+	actual, actualErr := os.Lstat(source.request.Directory)
+	physical, physicalErr := os.Lstat(wanted)
+	if err != nil || resolved != wanted || actualErr != nil || physicalErr != nil ||
+		!actual.IsDir() || !physical.IsDir() || !os.SameFile(actual, physical) || source.request.Directory != wanted {
+		return numericalSBContext("SDK source is not this invoked installation's exact physical package")
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) captureSourceRole(ctx context.Context) error {
+	selected := source.guard.selection
+	if source.role == numericalSBOwnedSource {
+		if selected.Standard || selected.Module == nil || !selected.Module.Main || selected.Module.Version != "" || selected.Module.Path == "" ||
+			len(selected.Module.Replace) != 0 && string(selected.Module.Replace) != "null" ||
+			selected.Module.GoMod != filepath.Join(selected.Module.Dir, "go.mod") ||
+			!goAssemblyPathWithinRoot(selected.Module.Dir, source.request.Directory) {
+			return numericalSBContext("consumer needs complete original owned-main module/source role")
+		}
+		_, err := source.guard.read(selected.Module.GoMod)
+		return err
+	}
+	if source.role != numericalSBSDKSource || !selected.Standard || selected.Module != nil {
+		return numericalSBContext("SDK source must independently retain its actual standard/no-module selection")
+	}
+	if err := source.verifySDKDirectory(source.guard.env["GOROOT"]); err != nil {
+		return err
+	}
+	compiled := append([]string(nil), selected.CompiledGoFiles...)
+	for index, name := range compiled {
+		if filepath.IsAbs(name) {
+			relative, err := filepath.Rel(selected.Dir, name)
+			if err != nil || filepath.Base(relative) != relative {
+				return numericalSBContext("SDK effective/generated compiler sources need a separate mapping")
+			}
+			compiled[index] = relative
+		}
+	}
+	if !reflect.DeepEqual(compiled, selected.GoFiles) {
+		return numericalSBContext("SDK selection omitted complete ordinary compiler sources")
+	}
+	matched := 0
+	for _, name := range selected.SFiles {
+		if name == source.request.AssemblyFile {
+			matched++
+		}
+	}
+	if matched != 1 {
+		return numericalSBContext("SDK assembly is not uniquely selected by the actual target")
+	}
+	if source.sdkAssemblyJoin() != nil {
+		return source.captureSDKAssemblySourceRole(ctx)
+	}
+	graph, err := source.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", source.packageQuery())
+	if err != nil {
+		return err
+	}
+	imports, err := source.guard.bindOriginalDeclarationImports(graph)
+	if err != nil {
+		return err
+	}
+	source.guard.imports = imports
+	referenced := make(map[string]gostaticstorage.SDKReferencedArchive)
+	paths := make([]string, 0, len(imports))
+	for path := range imports {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	for _, path := range paths {
+		dependency := imports[path]
+		if path == "unsafe" {
+			continue // Builtin package; no compiler export or foreign SymbolDefs.
+		}
+		data, err := source.guard.read(dependency.Export)
+		if err != nil {
+			return err
+		}
+		referenced[path] = gostaticstorage.SDKReferencedArchive{PackagePath: path,
+			Sources: append([]string(nil), dependency.SFiles...), Archive: data}
+	}
+	archive, err := source.guard.read(selected.Export)
+	if err != nil {
+		return err
+	}
+	builtin, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		return err
+	}
+	members, err := gostaticstorage.ObserveX86SDKAssemblyArchiveReferences(archive, builtin, source.request.Target, selected.SFiles, referenced)
+	if err != nil {
+		return numericalSBContext("SDK actual selected compiler/archive members differ: %v", err)
+	}
+	inputs := make(map[string][32]byte, len(source.guard.inputs))
+	for name, digest := range source.guard.inputs {
+		inputs[name] = digest
+	}
+	source.sdk = &numericalSBSDKObservation{Graph: graph, Archive: archive, ArchiveMembers: members,
+		Imports: imports, Referenced: referenced, Inputs: inputs, origin: source, context: ctx, originalContext: ctx}
+	source.sdk.seal, err = source.sdkDigest()
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) sdkDigest() ([32]byte, error) {
+	raw, err := json.Marshal(struct {
+		Request      GoX86NumericalReadCaptureRequest
+		GuardRequest GoAMD64FrameCaptureRequest
+		Role         numericalSBSourceRole
+		Selection    goAMD64FrameSelection
+		Env          map[string]string
+		Entries      []string
+		SDK          *numericalSBSDKObservation
+	}{source.request, source.guard.request, source.role, source.guard.selection, source.guard.env, source.guard.entries, source.sdk})
+	return sha256.Sum256(raw), err
+}
+
+// The caller owns source.mu during a published Verify. Capture has not
+// published this source. This method invokes no caller resolver or callback.
+func (source *GoX86NumericalReadSource) verifySDKObservation(ctx context.Context) (result error) {
+	defer func() {
+		if source != nil && source.identity == source && source.sdk != nil && !source.sdk.closed {
+			if err := source.verifySDKCaptureContext(); err != nil {
+				result = errors.Join(result, err)
+			}
+			if ctx != nil && ctx.Err() != nil {
+				result = errors.Join(result, fmt.Errorf("verify SDK source postcheck: %w", ctx.Err()))
+			}
+		}
+		if result != nil && source != nil && source.identity == source && source.sdk != nil {
+			source.sdk.closed = true
+		}
+	}()
+	if ctx != nil && ctx.Err() != nil {
+		return fmt.Errorf("verify SDK numerical source observation: %w", ctx.Err())
+	}
+	if ctx == nil || source == nil || source.identity != source || source.role != numericalSBSDKSource ||
+		source.sdk == nil || source.sdk.origin != source || source.sdk.closed {
+		return numericalSBContext("missing live independent SDK source observation")
+	}
+	if err := source.verifySDKCaptureContext(); err != nil {
+		return err
+	}
+	if source.guard == nil || source.guard.request.NumericalReads != nil {
+		return numericalSBContext("SDK source observer cannot borrow a frame/numerical token")
+	}
+	before, err := source.sdkDigest()
+	if err != nil || before != source.sdk.seal {
+		return numericalSBContext("sealed independent SDK source/object graph changed")
+	}
+	if len(source.request.Owners) != len(source.originalOwners) {
+		return numericalSBContext("SDK source owner inventory changed")
+	}
+	for ordinal, owner := range source.originalOwners {
+		if owner != source.request.Owners[ordinal] {
+			return numericalSBContext("SDK source owner identity/order changed")
+		}
+		if source.sdkAssemblyJoin() == nil {
+			if err := owner.Verify(ctx); err != nil {
+				return err
+			}
+		}
+	}
+	for name, input := range source.sdk.Inputs {
+		if source.guard.inputs[name] != input {
+			return numericalSBContext("SDK original source/tool/export input identity changed")
+		}
+	}
+	if err := source.verifySDKDirectory(source.guard.env["GOROOT"]); err != nil {
+		return err
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return err
+	}
+	graph, err := source.guard.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", source.packageQuery())
+	if err != nil {
+		return err
+	}
+	raw, err := numericalSDKGraphRoot(graph, source.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	selected, _, err := source.guard.readRawPackageSelection(raw)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(selected, source.guard.selection) || !numericalSameRawSelection(source.rawSelection, raw) {
+		return numericalSBContext("actual consumer selection/export changed")
+	}
+	imports, err := source.guard.bindOriginalDeclarationImports(graph)
+	if err != nil {
+		return numericalSBContext("complete SDK source/export graph cannot be rebound: %v", err)
+	}
+	if !reflect.DeepEqual(imports, source.sdk.Imports) || !reflect.DeepEqual(imports, source.guard.imports) {
+		return numericalSBContext("complete SDK declaration import bindings changed")
+	}
+	if !numericalSameRawSDKGraph(source.sdk.Graph, graph) {
+		return numericalSBContext("complete SDK source/export/selection graph changed")
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return err
+	}
+	after, err := source.sdkDigest()
+	if err != nil || after != source.sdk.seal {
+		return numericalSBContext("SDK source/object identity changed during observation")
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) verifySDKCaptureContext() error {
+	if joined := source.sdkAssemblyJoin(); joined != nil {
+		// The joined route samples both original contexts outside source.mu.
+		// The serialized portion can only consume the already sampled lease.
+		if source.sdk.context != joined.context || source.sdk.originalContext != joined.context {
+			return numericalSBContext("joined SDK capture context identity changed")
+		}
+		return source.verifySDKAssemblyIdentity()
+	}
+	if source.sdk.context == nil || source.sdk.originalContext == nil ||
+		reflect.TypeOf(source.sdk.context) != reflect.TypeOf(source.sdk.originalContext) ||
+		!reflect.TypeOf(source.sdk.context).Comparable() || source.sdk.context != source.sdk.originalContext {
+		return numericalSBContext("SDK capture context identity changed")
+	}
+	if err := source.sdk.context.Err(); err != nil {
+		return fmt.Errorf("original SDK numerical capture context: %w", err)
+	}
+	return nil
+}
+
+func numericalRawSDKGraph(data []byte) ([]json.RawMessage, bool) {
+	if len(data) == 0 || len(data) > 16<<20 {
+		return nil, false
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	var values []json.RawMessage
+	for {
+		var value json.RawMessage
+		if err := decoder.Decode(&value); err == io.EOF {
+			return values, len(values) != 0
+		} else if err != nil || len(values) >= 4096 {
+			return nil, false
+		}
+		values = append(values, value)
+	}
+}
+
+func numericalSDKGraphRoot(graph []byte, path string) ([]byte, error) {
+	values, valid := numericalRawSDKGraph(graph)
+	if !valid {
+		return nil, numericalSBContext("incomplete or oversized SDK selection graph")
+	}
+	var root json.RawMessage
+	for _, raw := range values {
+		var selected struct{ ImportPath string }
+		if json.Unmarshal(raw, &selected) != nil {
+			return nil, numericalSBContext("malformed SDK selection graph record")
+		}
+		if selected.ImportPath == path {
+			if root != nil {
+				return nil, numericalSBContext("SDK selection graph repeats the original root")
+			}
+			root = raw
+		}
+	}
+	if root == nil {
+		return nil, numericalSBContext("SDK selection graph omitted the original root")
+	}
+	return root, nil
+}
+
+func numericalSameRawSDKGraph(first, second []byte) bool {
+	a, validA := numericalRawSDKGraph(first)
+	b, validB := numericalRawSDKGraph(second)
+	if !validA || !validB || len(a) != len(b) {
+		return false
+	}
+	for index := range a {
+		if !numericalSameRawSelection(a[index], b[index]) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/go_x86_numerical_read_sdk_assembly.go b/go_x86_numerical_read_sdk_assembly.go
new file mode 100644
index 000000000..e2c80956d
--- /dev/null
+++ b/go_x86_numerical_read_sdk_assembly.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"time"
+)
+
+// This joins only the complete source/native observation. It supplies no DATA
+// initializer, numerical owner, helper ABI or entry state.
+type numericalSDKAssemblyJoin struct {
+	Observation   sdkASMDataLiveObservation
+	SourceOrdinal int
+	source        *GoX86SDKASMDataSource
+	generation    uint64
+	seal          [32]byte
+	stateSeal     [32]byte
+	context       context.Context
+	Deadline      time.Time
+}
+
+func captureNumericalSDKAssemblyJoin(ctx context.Context, request GoX86NumericalReadCaptureRequest, role numericalSBSourceRole) (*numericalSDKAssemblyJoin, error) {
+	actual := request.AssemblySource
+	if actual == nil {
+		return nil, nil
+	}
+	if role != numericalSBSDKSource || actual.identity != actual {
+		return nil, numericalSBContext("assembly join requires its independent live SDK source")
+	}
+	profile := actual.request
+	if request.GoBinary != profile.GoBinary || request.Directory != profile.Directory ||
+		request.PackagePath != profile.PackagePath || request.Target != profile.Target ||
+		!reflect.DeepEqual(request.Environment, profile.Environment) {
+		return nil, numericalSBContext("assembly observation source/tool/profile differs")
+	}
+	if request.ReadonlyLiterals != nil {
+		if request.ReadonlyLiterals.source != actual {
+			return nil, numericalSBContext("assembly and initializer have different original sources")
+		}
+		return nil, nil // Existing literal join owns the same source observation.
+	}
+	raw, err := actual.Readback(ctx)
+	if err != nil {
+		return nil, err
+	}
+	deadline, bounded := ctx.Deadline()
+	if !bounded || !reflect.TypeOf(ctx).Comparable() {
+		return nil, numericalSBContext("assembly numerical join requires one bounded original context")
+	}
+	joined := &numericalSDKAssemblyJoin{source: actual, context: ctx, Deadline: deadline}
+	actual.mu.Lock()
+	joined.generation, joined.seal, joined.stateSeal = actual.generation, actual.seal, actual.stateSeal
+	actual.mu.Unlock()
+	if json.Unmarshal(raw, &joined.Observation) != nil || sha256.Sum256(raw) != joined.seal {
+		return nil, numericalSBContext("assembly join lost its authenticated complete readback")
+	}
+	file, ordinal, err := sdkASMMetadataSelectedMember(joined.Observation, request.AssemblyFile)
+	if err != nil {
+		return nil, err
+	}
+	joined.SourceOrdinal = ordinal
+	if len(file.Funcs) == 0 || len(file.Data)+len(file.Globl)+len(file.UnlinkedPrelude) != 0 {
+		return nil, numericalSBContext("metadata-only numerical member must retain its complete TEXT-only role")
+	}
+	return joined, joined.verifyIdentity(request)
+}
+
+// Literal and metadata routes share only immutable observation coordinates.
+// The initializer's own owner/generation checks stay independent.
+func (source *GoX86NumericalReadSource) sdkAssemblyJoin() *numericalSDKAssemblyJoin {
+	if source.literals != nil {
+		literal := source.literals
+		return &numericalSDKAssemblyJoin{Observation: literal.Observation, SourceOrdinal: literal.SourceOrdinal,
+			source: literal.source, context: literal.context, Deadline: literal.Deadline}
+	}
+	return source.assembly
+}
+
+func (joined *numericalSDKAssemblyJoin) verifyIdentity(request GoX86NumericalReadCaptureRequest) error {
+	if joined == nil || joined.source == nil || joined.source.identity != joined.source || request.AssemblySource != joined.source {
+		return numericalSBContext("assembly source identity changed")
+	}
+	actual := joined.source
+	actual.mu.Lock()
+	valid := actual.ready && actual.generation == joined.generation && actual.seal == joined.seal &&
+		actual.stateSeal == joined.stateSeal && sha256.Sum256(actual.report) == joined.seal
+	actual.mu.Unlock()
+	if !valid {
+		return numericalSBContext("assembly source generation changed or closed")
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) verifySDKAssemblyIdentity() error {
+	if source.literals != nil {
+		return source.literals.verifyIdentity(source.request)
+	}
+	return source.assembly.verifyIdentity(source.request)
+}
+
+func (joined *numericalSDKAssemblyJoin) liveContext(ctx context.Context) error {
+	if joined == nil || joined.source == nil {
+		return numericalSBContext("assembly numerical join lost its original context")
+	}
+	if err := joined.source.liveContext(ctx); err != nil {
+		return err
+	}
+	_, err := sampleGoSourceContext(ctx, joined.context,
+		goSourceContextLifetime{deadline: joined.Deadline, bounded: true}, false,
+		numericalSBContext("assembly numerical join original deadline changed or canceled without a cause"))
+	return err
+}
+
+func (joined *numericalSDKAssemblyJoin) privateContext(ctx context.Context) (context.Context, func(), error) {
+	if err := joined.liveContext(ctx); err != nil {
+		return nil, nil, err
+	}
+	return sdkASMDataPrivateContext(ctx, joined.context, joined.Deadline)
+}
+
+func (source *GoX86NumericalReadSource) verifySDKAssemblyNumericalSource(ctx context.Context) (result error) {
+	joined := source.assembly
+	if source.identity != source || joined == nil {
+		return numericalSBContext("copied or missing assembly numerical source")
+	}
+	defer func() {
+		result = errors.Join(result, joined.liveContext(ctx), joined.verifyIdentity(source.request))
+		source.mu.Lock()
+		ready := source.ready
+		source.mu.Unlock()
+		if !ready {
+			result = errors.Join(result, numericalSBContext("assembly numerical source closed during verification"))
+		}
+		if result != nil {
+			source.revokeNumericalSource()
+		}
+	}()
+	if err := errors.Join(joined.verifyIdentity(source.request), joined.liveContext(ctx)); err != nil {
+		return err
+	}
+	if err := joined.source.Verify(ctx); err != nil {
+		return err
+	}
+	for _, owner := range source.originalOwners {
+		if err := owner.Verify(ctx); err != nil {
+			return err
+		}
+	}
+	private, stop, err := joined.privateContext(ctx)
+	if err != nil {
+		return err
+	}
+	defer stop()
+	if err := errors.Join(source.verifyNumericalSource(private), private.Err()); err != nil {
+		return err
+	}
+	for _, owner := range source.originalOwners {
+		if err := owner.Verify(ctx); err != nil {
+			return err
+		}
+	}
+	return joined.source.Verify(ctx)
+}
+
+func (source *GoX86NumericalReadSource) preprocessSDKAssembly() error {
+	joined := source.sdkAssemblyJoin()
+	if err := source.verifySDKAssemblyIdentity(); err != nil {
+		return err
+	}
+	file, ordinal, err := sdkASMMetadataSelectedMember(joined.Observation, source.request.AssemblyFile)
+	if err != nil || ordinal != joined.SourceOrdinal || len(file.Funcs) == 0 || len(file.UnlinkedPrelude) != 0 {
+		return numericalSBContext("assembly numerical source lost its complete selected member: %v", err)
+	}
+	input := joined.Observation.ObjectInputs.Sources[ordinal]
+	raw, err := source.guard.read(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil || !bytes.Equal(raw, input.Original) {
+		return numericalSBContext("assembly numerical original source bytes changed: %v", err)
+	}
+	source.cpp, source.file = joined.Observation.CPP[ordinal], file
+	if !bytes.Equal([]byte(source.cpp.Output), input.Expanded) {
+		return numericalSBContext("assembly numerical complete CPP differs")
+	}
+	if source.literals != nil {
+		return source.literals.verifyFile(file, source.request.PackagePath)
+	}
+	if len(file.Data)+len(file.Globl) != 0 {
+		return numericalSBContext("assembly observation grants no initializer authority")
+	}
+	return nil
+}
diff --git a/go_x86_numerical_read_sdk_data.go b/go_x86_numerical_read_sdk_data.go
new file mode 100644
index 000000000..7a33be03a
--- /dev/null
+++ b/go_x86_numerical_read_sdk_data.go
@@ -0,0 +1,404 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The exported fields participate in the numerical source seal. The private
+// identities cannot be reconstructed from those diagnostic bytes. This join
+// keeps initializer authority separate from the external mutable Go variables.
+type numericalSDKLiteralJoin struct {
+	Observation     sdkASMDataLiveObservation
+	Initializers    sdkReadonlyLiteralDataReport
+	SourceOrdinal   int
+	owner           *GoX86SDKReadonlyLiteralDataOwner
+	source          *GoX86SDKASMDataSource
+	ownerGeneration uint64
+	ownerSeal       [32]byte
+	context         context.Context
+	Deadline        time.Time
+}
+
+func captureNumericalSDKLiteralJoin(ctx context.Context, request GoX86NumericalReadCaptureRequest, role numericalSBSourceRole) (*numericalSDKLiteralJoin, error) {
+	owner := request.ReadonlyLiterals
+	if owner == nil {
+		return nil, nil
+	}
+	if role != numericalSBSDKSource || owner.identity != owner {
+		return nil, numericalSBContext("literal initializer needs its independent live SDK role")
+	}
+	if err := owner.Verify(ctx); err != nil {
+		return nil, err
+	}
+	owner.mu.Lock()
+	actual, generation, seal := owner.source, owner.generation, owner.seal
+	owner.mu.Unlock()
+	if actual == nil || actual.identity != actual {
+		return nil, numericalSBContext("literal initializer lost its original SDK source")
+	}
+	profile := actual.request
+	if request.GoBinary != profile.GoBinary || request.Directory != profile.Directory ||
+		request.PackagePath != profile.PackagePath || request.Target != profile.Target ||
+		!reflect.DeepEqual(request.Environment, profile.Environment) {
+		return nil, numericalSBContext("literal initializer source/tool/profile differs")
+	}
+	raw, err := actual.Readback(ctx)
+	if err != nil {
+		return nil, err
+	}
+	deadline, bounded := ctx.Deadline()
+	if !bounded || !reflect.TypeOf(ctx).Comparable() {
+		return nil, numericalSBContext("literal numerical join needs one original bounded context")
+	}
+	joined := &numericalSDKLiteralJoin{owner: owner, source: actual, ownerGeneration: generation, ownerSeal: seal,
+		SourceOrdinal: -1, context: ctx, Deadline: deadline}
+	if json.Unmarshal(raw, &joined.Observation) != nil || joined.Observation.Objects == nil {
+		return nil, numericalSBContext("literal source retained invalid whole observation bytes")
+	}
+	initializers, err := owner.Readback(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if json.Unmarshal(initializers, &joined.Initializers) != nil || sha256.Sum256(initializers) != seal ||
+		joined.Initializers.SourceReportSHA256 != sha256.Sum256(raw) ||
+		joined.Initializers.Protocol != sdkReadonlyLiteralDataProtocol ||
+		joined.Initializers.PackagePath != request.PackagePath || joined.Initializers.Target != request.Target {
+		return nil, numericalSBContext("literal initializer differs from its complete live SDK observation")
+	}
+	for index, selected := range joined.Observation.Objects.Sources {
+		if selected.Name == request.AssemblyFile {
+			if joined.SourceOrdinal >= 0 {
+				return nil, numericalSBContext("literal source repeats its selected assembly identity")
+			}
+			joined.SourceOrdinal = index
+		}
+	}
+	if joined.SourceOrdinal < 0 || joined.SourceOrdinal >= len(joined.Observation.CPP) ||
+		joined.SourceOrdinal >= len(joined.Observation.Positions) ||
+		joined.SourceOrdinal >= len(joined.Observation.ObjectInputs.Sources) {
+		return nil, numericalSBContext("literal initializer does not own this selected assembly")
+	}
+	if err := joined.verifyIdentity(request); err != nil {
+		return nil, err
+	}
+	return joined, nil
+}
+
+// No context callback or producer operation runs under a numerical source lock.
+// This check samples only immutable identities and guarded generation state.
+func (joined *numericalSDKLiteralJoin) verifyIdentity(request GoX86NumericalReadCaptureRequest) error {
+	if joined == nil || joined.owner == nil || joined.owner.identity != joined.owner ||
+		joined.source == nil || joined.source.identity != joined.source || request.ReadonlyLiterals != joined.owner {
+		return numericalSBContext("literal owner identity changed")
+	}
+	owner := joined.owner
+	owner.mu.Lock()
+	valid := owner.ready && owner.generation == joined.ownerGeneration && owner.seal == joined.ownerSeal &&
+		sha256.Sum256(owner.report) == joined.ownerSeal && owner.source == joined.source && owner.originalSource == joined.source
+	owner.mu.Unlock()
+	if !valid {
+		return numericalSBContext("literal initializer generation changed or closed")
+	}
+	return owner.verifySourceGeneration()
+}
+
+func (source *GoX86NumericalReadSource) verifySDKLiteralNumericalSource(ctx context.Context) (result error) {
+	joined := source.literals
+	if source.identity != source || joined == nil || joined.owner == nil {
+		return numericalSBContext("copied or missing joined numerical source")
+	}
+	defer func() {
+		result = errors.Join(result, joined.liveContext(ctx), joined.verifyIdentity(source.request))
+		source.mu.Lock()
+		ready := source.ready
+		source.mu.Unlock()
+		if !ready {
+			result = errors.Join(result, numericalSBContext("joined numerical source closed during verification"))
+		}
+		if result != nil {
+			source.revokeNumericalSource()
+		}
+	}()
+	if err := joined.verifyIdentity(source.request); err != nil {
+		return err
+	}
+	if err := joined.liveContext(ctx); err != nil {
+		return err
+	}
+	if err := joined.owner.Verify(ctx); err != nil {
+		return err
+	}
+	for _, owner := range source.originalOwners {
+		if err := owner.Verify(ctx); err != nil {
+			return err
+		}
+	}
+	private, stop, err := joined.privateContext(ctx)
+	if err != nil {
+		return err
+	}
+	defer stop()
+	if err := joined.verifyIdentity(source.request); err != nil {
+		return err
+	}
+	if err := errors.Join(source.verifyNumericalSource(private), private.Err()); err != nil {
+		return err
+	}
+	for _, owner := range source.originalOwners {
+		if err := owner.Verify(ctx); err != nil {
+			return err
+		}
+	}
+	return joined.owner.Verify(ctx)
+}
+
+func (joined *numericalSDKLiteralJoin) liveContext(ctx context.Context) error {
+	if ctx == nil || joined.context == nil || joined.owner == nil {
+		return numericalSBContext("joined numerical source lost its original context")
+	}
+	if err := joined.owner.liveContext(ctx); err != nil {
+		return err
+	}
+	_, err := sampleGoSourceContext(ctx, joined.context,
+		goSourceContextLifetime{deadline: joined.Deadline, bounded: true}, false,
+		numericalSBContext("joined numerical source original deadline changed or canceled without a cause"))
+	return err
+}
+
+func (joined *numericalSDKLiteralJoin) privateContext(ctx context.Context) (context.Context, func(), error) {
+	if err := joined.liveContext(ctx); err != nil {
+		return nil, nil, err
+	}
+	return sdkASMDataPrivateContext(ctx, joined.context, joined.Deadline)
+}
+
+func (source *GoX86NumericalReadSource) numericalDeclarationContext(ctx context.Context) (context.Context, func(), error) {
+	if source.literals != nil {
+		return source.literals.privateContext(ctx)
+	}
+	if source.assembly != nil {
+		return source.assembly.privateContext(ctx)
+	}
+	return ctx, func() {}, nil
+}
+
+func (source *GoX86NumericalReadSource) bindSDKLiteralSymbols(file *File, options Options, symbols map[string]string) error {
+	if err := source.literals.verifyFile(file, source.request.PackagePath); err != nil {
+		return err
+	}
+	used := make(map[string]bool)
+	for _, name := range symbols {
+		used[name] = true
+	}
+	for _, global := range file.Globl {
+		qualified := global.Sym
+		if !strings.ContainsAny(qualified, "·/.") {
+			qualified = "·" + qualified
+		}
+		name := options.ResolveSym(qualified)
+		if name == "" || name != numericalNativeName(qualified, source.request.PackagePath) || used[name] {
+			return numericalSBContext("private literal resolver changed or collapsed its namespace")
+		}
+		if _, collision := options.Sigs[name]; collision {
+			return numericalSBContext("private literal resolver collides with a function declaration")
+		}
+		used[name] = true
+		symbols[qualified], symbols[global.Sym] = name, name
+	}
+	return nil
+}
+
+// This is a bounded access to this translation's own emitted literal, not an
+// external Go-variable certificate. The shared complete typed memory shape
+// supplies the native width. An observed full-word address or indexed source
+// additionally requires the separate complete literal provenance/range proof
+// at binding; this role query alone supplies neither bytes nor pointer backing.
+func (source *GoX86NumericalReadSource) sdkLiteralRead(ins Instr, index int, arch string) (bool, error) {
+	if source.literals == nil || index < 0 || index >= len(ins.Args) {
+		return false, nil
+	}
+	operand := ins.Args[index]
+	if operand.Kind == OpSym {
+		operand.Sym = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(operand.Sym), "$"))
+		if parsed, err := parseOperandForArch(ArchAMD64, operand.Sym); err == nil {
+			operand = parsed
+		}
+	}
+	memory, valid := x86SBMemoryAddressRole(operand, arch)
+	if !valid {
+		return false, nil
+	}
+	base, _, valid := parseSBRef(memory.Sym)
+	if !valid || !strings.HasSuffix(base, "<>") {
+		return false, nil
+	}
+	name := numericalNativeName(strings.TrimSuffix(base, "<>"), source.request.PackagePath)
+	for _, image := range source.literals.Initializers.Initializers {
+		if image.SourceOrdinal != source.literals.SourceOrdinal || image.Definition.Name != name {
+			continue
+		}
+		form, known := x86SDKLiteralOperandProperties(ins, index, arch)
+		if !known || form.offset < 0 || form.offset > int64(len(image.Initial))-form.width {
+			return true, numericalSBContext("private literal read has an unbound shape/direction/whole-byte extent")
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+func (source *GoX86NumericalReadSource) captureSDKAssemblySourceRole(ctx context.Context) error {
+	joined := source.sdkAssemblyJoin()
+	if err := source.verifySDKAssemblyIdentity(); err != nil {
+		return err
+	}
+	observation := joined.Observation
+	var selected goAMD64FrameSelection
+	if json.Unmarshal(observation.RawSelection, &selected) != nil || !reflect.DeepEqual(selected, source.guard.selection) ||
+		!numericalSameRawSelection(observation.RawSelection, source.rawSelection) {
+		return numericalSBContext("literal/source complete actual selection differs")
+	}
+	var environment map[string]string
+	if json.Unmarshal(observation.RawEnvironment, &environment) != nil || !reflect.DeepEqual(environment, source.guard.env) {
+		return numericalSBContext("literal/source actual compiler environment differs")
+	}
+	for name, digest := range observation.Inputs {
+		data, err := source.guard.read(name)
+		if err != nil || sha256.Sum256(data) != digest {
+			return numericalSBContext("literal/source input bytes differ: %s: %v", name, err)
+		}
+	}
+	// Rebind the actual driver graph, not its diagnostic JSON projection.
+	// A nil json.RawMessage is serialized as null and decodes as the bytes
+	// "null"; that report round trip must not impersonate a driver Error field.
+	imports, err := source.guard.bindOriginalDeclarationImports(observation.Graph)
+	if err != nil {
+		return err
+	}
+	actualImports, actualErr := json.Marshal(imports)
+	observedImports, observedErr := json.Marshal(observation.Imports)
+	if actualErr != nil || observedErr != nil || !bytes.Equal(actualImports, observedImports) {
+		return numericalSBContext("literal source graph differs from its complete observed declaration imports")
+	}
+	source.guard.imports = imports
+	members := make([]gostaticstorage.TextMember, len(observation.Objects.Members))
+	for index, member := range observation.Objects.Members {
+		members[index] = gostaticstorage.TextMember{Name: member.Name, Offset: member.Offset, Size: member.Size,
+			Flags: member.Flags, Texts: member.Texts}
+	}
+	source.sdk = &numericalSBSDKObservation{Graph: observation.Graph, Archive: observation.ObjectInputs.Archive,
+		ArchiveMembers: members, Imports: imports, Referenced: observation.ObjectInputs.Referenced,
+		Inputs: cloneSDKASMDataInputs(source.guard.inputs), origin: source, context: ctx, originalContext: ctx}
+	source.sdk.seal, err = source.sdkDigest()
+	return err
+}
+
+func (source *GoX86NumericalReadSource) preprocessSDKLiterals() error {
+	joined := source.literals
+	if err := joined.verifyIdentity(source.request); err != nil {
+		return err
+	}
+	ordinal := joined.SourceOrdinal
+	input := joined.Observation.ObjectInputs.Sources[ordinal]
+	raw, err := source.guard.read(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil || !bytes.Equal(raw, input.Original) {
+		return numericalSBContext("literal source original assembly bytes changed: %v", err)
+	}
+	source.cpp = joined.Observation.CPP[ordinal]
+	if !bytes.Equal([]byte(source.cpp.Output), input.Expanded) {
+		return numericalSBContext("literal source complete CPP program differs")
+	}
+	source.file, err = Parse(ArchAMD64, source.cpp.Output)
+	if err != nil || len(source.file.Funcs) == 0 || len(source.file.UnlinkedPrelude) != 0 {
+		return numericalSBContext("literal source lacks its complete parsed program: %v", err)
+	}
+	return joined.verifyFile(source.file, source.request.PackagePath)
+}
+
+// Compare the byte image the ordinary emitter will actually create, not only
+// the DATA source values. This also catches GLOBL shrink/order differences,
+// sparse tails, narrow float encodings and any unregistered relocation role.
+func (joined *numericalSDKLiteralJoin) verifyFile(file *File, pkg string) error {
+	if file == nil || file.Arch != ArchAMD64 {
+		return numericalSBContext("literal initializer lacks its original x86 file")
+	}
+	images := make(map[string]gostaticstorage.ReadonlyLiteralDataImage)
+	flags := make(map[string]uint64)
+	if joined.Observation.Objects == nil || joined.SourceOrdinal < 0 ||
+		joined.SourceOrdinal >= len(joined.Observation.Objects.Sources) {
+		return numericalSBContext("literal initializer lost its source layout inventory")
+	}
+	for _, layout := range joined.Observation.Objects.Sources[joined.SourceOrdinal].ExpandedLayouts {
+		flags[layout.Definition.Name] = layout.Flags
+	}
+	for _, image := range joined.Initializers.Initializers {
+		if image.SourceOrdinal == joined.SourceOrdinal {
+			if _, duplicate := images[image.Definition.Name]; duplicate {
+				return numericalSBContext("literal source repeats an object-local DATA name")
+			}
+			images[image.Definition.Name] = image
+		}
+	}
+	if len(images) == 0 {
+		// An independently observed SDK archive may place readonly DATA in
+		// another selected member. This complete TEXT-only member receives
+		// no initializer or literal-read authority from those other images.
+		if len(flags) != 0 || len(file.Globl) != 0 || len(file.Data) != 0 {
+			return numericalSBContext("literal source complete empty-member DATA inventory differs")
+		}
+		return nil
+	}
+	if len(file.Globl) != len(images) {
+		return numericalSBContext("literal source complete DATA/GLOBL inventory differs")
+	}
+	initial := make(map[string][]byte)
+	for _, global := range file.Globl {
+		name := numericalNativeName(strings.TrimSuffix(global.Sym, "<>"), pkg)
+		image, found := images[name]
+		readOnly, err := globlReadOnly(global.Flags)
+		expression := globlFlagName.ReplaceAllStringFunc(global.Flags, func(flag string) string {
+			if value, known := goTextFlagValues[flag]; known {
+				return value
+			}
+			return flag
+		})
+		value, validFlags := parseImmExpr(expression)
+		if !found || !strings.HasSuffix(global.Sym, "<>") || initial[name] != nil || global.SizeRaw != "" ||
+			global.Size != image.DeclaredSize || err != nil || !readOnly || !validFlags || value != flags[name] {
+			return numericalSBContext("literal GLOBL identity/extent/readonly role differs")
+		}
+		initial[name] = make([]byte, len(image.Initial))
+	}
+	fragments := make(map[string]int)
+	for _, datum := range file.Data {
+		name := numericalNativeName(strings.TrimSuffix(datum.Sym, "<>"), pkg)
+		image, found := images[name]
+		index := fragments[name]
+		if !found || !strings.HasSuffix(datum.Sym, "<>") || datum.Addr != "" || index >= len(image.Fragments) {
+			return numericalSBContext("literal DATA lost its private numerical fragment identity")
+		}
+		fragment := image.Fragments[index]
+		payload, err := dataStmtPayload(datum)
+		if err != nil || datum.Off != fragment.Offset || datum.Width != fragment.Width ||
+			datum.Off < 0 || datum.Off > int64(len(image.Initial))-datum.Width {
+			return numericalSBContext("literal DATA fragment width/offset differs")
+		}
+		copy(initial[name][datum.Off:], payload)
+		fragments[name]++
+	}
+	for name, image := range images {
+		if fragments[name] != len(image.Fragments) || !bytes.Equal(initial[name], image.Initial) {
+			return numericalSBContext("emitted literal byte image differs from the actual initializer")
+		}
+	}
+	return nil
+}
diff --git a/go_x86_numerical_read_sdk_data_test.go b/go_x86_numerical_read_sdk_data_test.go
new file mode 100644
index 000000000..b7de464bc
--- /dev/null
+++ b/go_x86_numerical_read_sdk_data_test.go
@@ -0,0 +1,636 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The source, generated header, assembly, object, CPU variable and initializer
+// are actual independently captured SDK inputs. No instruction, DATA, feature
+// offset, package declaration or original byte is replaced for this witness.
+func numericalSDKLiteralFixture(t *testing.T) (context.Context, GoX86NumericalReadCaptureRequest, *GoX86SDKASMDataSource) {
+	t.Helper()
+	ctx, request, _ := numericalSDKCRC32Request(t)
+	source, err := CaptureGoX86SDKASMDataSource(ctx, GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		t.Fatal("actual complete SDK source/header/CPP/object precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if err != nil {
+		t.Fatal("actual complete SDK literal initializer precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := owner.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	request.ReadonlyLiterals = owner
+	return ctx, request, source
+}
+
+func numericalSDKLiteralPackage(t *testing.T, source *GoX86SDKASMDataSource, name string) (GoPackage, *File, Options) {
+	t.Helper()
+	pkg, file, options := numericalSDKOriginalTypedPackage(t, source, name)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(goStripABISuffix(fn.Sym), "·")
+		declaration, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			t.Fatal("original TEXT lacks its actual Go function declaration", fn.Sym)
+		}
+		name = numericalNativeName(goStripABISuffix(fn.Sym), pkg.Path)
+		sig, err := DeriveGoFuncABI0Signature(name, declaration, options.Goarch, types.SizesFor("gc", options.Goarch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[name] = sig
+	}
+	return pkg, file, options
+}
+
+// Retain one complete actual source/export/type importer for declaration-only
+// members and whole-source graphs. This supplies no private helper signature.
+func numericalSDKOriginalTypedPackage(t *testing.T, source *GoX86SDKASMDataSource, name string) (GoPackage, *File, Options) {
+	t.Helper()
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range source.guard.selection.GoFiles {
+		filename := filepath.Join(source.request.Directory, name)
+		file, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal("original complete selected SDK Go source", err)
+		}
+		syntax = append(syntax, file)
+	}
+	imports := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if mapped, found := source.guard.selection.ImportMap[path]; found {
+			path = mapped
+		}
+		selected, found := source.guard.imports[path]
+		if !found || selected.Export == "" {
+			return nil, fmt.Errorf("missing actual SDK dependency export: %s", path)
+		}
+		return os.Open(selected.Export)
+	})
+	_, arch, paired := strings.Cut(source.request.Target, "/")
+	if !paired || numericalSDKTargetTriple(source.request.Target) == "" {
+		t.Fatal("missing actual SDK target", source.request.Target)
+	}
+	sizes := types.SizesFor("gc", arch)
+	typed, err := (&types.Config{Sizes: sizes, Importer: imports, GoVersion: "go1.27"}).Check(source.request.PackagePath, fset, syntax, nil)
+	if err != nil {
+		t.Fatal("independently typed original complete SDK package", err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax, Imports: make(map[string]*types.Package)}
+	for _, dependency := range typed.Imports() {
+		pkg.Imports[dependency.Path()] = dependency
+	}
+	ordinal := -1
+	for index, selected := range source.guard.selection.SFiles {
+		if selected == name {
+			if ordinal != -1 {
+				t.Fatal("ambiguous original selected SDK assembly")
+			}
+			ordinal = index
+		}
+	}
+	if ordinal < 0 || ordinal >= len(source.observation.CPP) {
+		t.Fatal("missing complete SDK assembly CPP observation")
+	}
+	file, err := Parse(ArchAMD64, source.observation.CPP[ordinal].Output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: arch, TargetTriple: numericalSDKTargetTriple(source.request.Target),
+		Sigs: make(map[string]FuncSig), ResolveSym: func(symbol string) string {
+			return numericalNativeName(goTextSymbolForResolution(symbol), pkg.Path)
+		}}
+	return pkg, file, options
+}
+
+func TestGoX86SDKNumericalReadLiteralOriginalCRC32LLVM22(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	pkg, file, options := numericalSDKLiteralPackage(t, observed, request.AssemblyFile)
+	if len(file.Funcs) != 3 || len(file.Globl) != 4 {
+		t.Fatal("original complete CRC assembly changed; update the independent inventory")
+	}
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("live initializer and CPU owner do not compose through the original SDK source", err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("complete original SDK numerical/data binding", err)
+	}
+	if len(source.reads) != 1 || source.reads[0].variable.NativeName != "internal/cpu.X86" || source.reads[0].width != 1 {
+		t.Fatal("private literals acquired numerical Go variable authority")
+	}
+	for _, api := range []string{"text", "module", "go-module"} {
+		t.Run(api, func(t *testing.T) {
+			ir := numericalFamilyTranslate(t, api, pkg, file, bound)
+			requireCRC32TargetFeatures(t, ir)
+			if !strings.Contains(ir, "load volatile i8") || !strings.Contains(ir, "external global [") ||
+				strings.Count(ir, "internal constant [") != 4 || !strings.Contains(ir, "align 32") {
+				t.Fatal("original mutable CPU read/private literal roles differ", ir)
+			}
+			numericalLLVM22Axes(t, ir, options.TargetTriple, nil)
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralRequestBoundaries(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	for _, test := range []struct {
+		name   string
+		mutate func(*GoX86NumericalReadCaptureRequest)
+	}{
+		{"different package", func(r *GoX86NumericalReadCaptureRequest) { r.PackagePath = "internal/chacha8rand" }},
+		{"different directory", func(r *GoX86NumericalReadCaptureRequest) { r.Directory = filepath.Dir(r.Directory) }},
+		{"different target", func(r *GoX86NumericalReadCaptureRequest) { r.Target = "linux/386" }},
+		{"unselected assembly", func(r *GoX86NumericalReadCaptureRequest) { r.AssemblyFile = "unselected_amd64.s" }},
+		{"different tool", func(r *GoX86NumericalReadCaptureRequest) { r.GoBinary += ".foreign" }},
+		{"different profile", func(r *GoX86NumericalReadCaptureRequest) {
+			r.Environment = append(append([]string(nil), r.Environment...), "GOFLAGS=-N")
+		}},
+		{"copied literal owner", func(r *GoX86NumericalReadCaptureRequest) {
+			copy := reflect.New(reflect.TypeOf(r.ReadonlyLiterals).Elem())
+			copy.Elem().Set(reflect.ValueOf(r.ReadonlyLiterals).Elem())
+			r.ReadonlyLiterals = copy.Interface().(*GoX86SDKReadonlyLiteralDataOwner)
+		}},
+		{"uncaptured literal owner", func(r *GoX86NumericalReadCaptureRequest) {
+			r.ReadonlyLiterals = new(GoX86SDKReadonlyLiteralDataOwner)
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			changed := request
+			test.mutate(&changed)
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, changed)
+			if source != nil {
+				closeNumericalConsumerSource(t, source)
+			}
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("foreign source/profile/owner published a numerical token", err)
+			}
+			if err := request.ReadonlyLiterals.Verify(ctx); err != nil {
+				t.Fatal("failed join revoked the independent original initializer", err)
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal("failed join changed the independent SDK source", err)
+			}
+		})
+	}
+	if source, err := CaptureGoX86NumericalReadSource(ctx, request); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		if source != nil {
+			closeNumericalConsumerSource(t, source)
+		}
+		t.Fatal("ordinary owned-main factory borrowed an SDK literal role", err)
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralCompleteBindingBoundaries(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	pkg, original, originalOptions := numericalSDKLiteralPackage(t, observed, request.AssemblyFile)
+	// These cases mutate only caller-owned file/options copies, not the SDK
+	// source, owners or capture profile. Keep one live observation and actually
+	// reverify it per case instead of recapturing the complete SDK each time.
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual joined SDK source precondition", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	for _, test := range []struct {
+		name   string
+		mutate func(*File, *Options)
+	}{
+		{"missing DATA", func(f *File, _ *Options) { f.Data = f.Data[1:] }},
+		{"missing GLOBL", func(f *File, _ *Options) { f.Globl = f.Globl[1:] }},
+		{"extra DATA", func(f *File, _ *Options) { f.Data = append(f.Data, f.Data[0]) }},
+		{"extra GLOBL", func(f *File, _ *Options) { f.Globl = append(f.Globl, f.Globl[0]) }},
+		{"DATA bytes", func(f *File, _ *Options) { f.Data[0].Value ^= 1 }},
+		{"DATA offset", func(f *File, _ *Options) { f.Data[0].Off++ }},
+		{"DATA width", func(f *File, _ *Options) { f.Data[0].Width-- }},
+		{"DATA pointer", func(f *File, _ *Options) { f.Data[0].Addr = "internal∕cpu·X86(SB)" }},
+		{"DATA namespace", func(f *File, _ *Options) { f.Data[0].Sym = strings.TrimSuffix(f.Data[0].Sym, "<>") }},
+		{"GLOBL extent", func(f *File, _ *Options) { f.Globl[0].Size++ }},
+		{"GLOBL mutability", func(f *File, _ *Options) { f.Globl[0].Flags = "0" }},
+		{"missing TEXT", func(f *File, _ *Options) { f.Funcs = f.Funcs[1:] }},
+		{"DATA function alias", func(_ *File, o *Options) {
+			resolve := o.ResolveSym
+			o.ResolveSym = func(symbol string) string {
+				if strings.HasSuffix(symbol, "<>") {
+					return "hash/crc32.ieeeCLMUL"
+				}
+				return resolve(symbol)
+			}
+		}},
+		{"DATA numerical alias", func(_ *File, o *Options) {
+			resolve := o.ResolveSym
+			o.ResolveSym = func(symbol string) string {
+				if strings.HasSuffix(symbol, "<>") {
+					return "internal/cpu.X86"
+				}
+				return resolve(symbol)
+			}
+		}},
+		{"DATA identity collapse", func(_ *File, o *Options) {
+			resolve := o.ResolveSym
+			o.ResolveSym = func(symbol string) string {
+				if strings.HasSuffix(symbol, "<>") {
+					return "hash/crc32.collapsed<>"
+				}
+				return resolve(symbol)
+			}
+		}},
+		{"function DATA alias", func(_ *File, o *Options) {
+			resolve := o.ResolveSym
+			o.ResolveSym = func(symbol string) string {
+				if symbol == "·ieeeCLMUL" {
+					return "hash/crc32.r2r1<>"
+				}
+				return resolve(symbol)
+			}
+		}},
+		{"numerical DATA alias", func(_ *File, o *Options) {
+			resolve := o.ResolveSym
+			o.ResolveSym = func(symbol string) string {
+				if numericalNativeName(symbol, "hash/crc32") == "internal/cpu.X86" {
+					return "hash/crc32.r2r1<>"
+				}
+				return resolve(symbol)
+			}
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file := *original
+			file.Data = append([]DataStmt(nil), original.Data...)
+			file.Globl = append([]GloblStmt(nil), original.Globl...)
+			file.Funcs = append([]Func(nil), original.Funcs...)
+			options := originalOptions
+			test.mutate(&file, &options)
+			bound, err := source.BindNumericalReads(ctx, pkg, &file, options)
+			// Bind already performs the complete live Verify. A failed Verify
+			// permanently revokes the source; distinguish that failure from
+			// rejecting this caller-only mutation without duplicating the I/O.
+			source.mu.Lock()
+			live := source.ready && source.identity == source
+			source.mu.Unlock()
+			if !live || ctx.Err() != nil {
+				t.Fatal("actual joined SDK source expired or was revoked", err, ctx.Err())
+			}
+			if bound.NumericalReads != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed complete source/initializer/namespace acquired a binding", err)
+			}
+		})
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, original, originalOptions)
+	if err != nil || bound.NumericalReads == nil {
+		t.Fatal("unchanged original must still bind after all caller-only rejections", err)
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralOwnerLifetime(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	pkg, file, options := numericalSDKLiteralPackage(t, observed, request.AssemblyFile)
+	for _, change := range []string{"initializer close", "initializer report", "source owner replacement", "source owner removed"} {
+		t.Run(change, func(t *testing.T) {
+			owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, observed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			local := request
+			local.ReadonlyLiterals = owner
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, local)
+			if err != nil {
+				t.Fatal("actual joined SDK source precondition", err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+			if err != nil {
+				t.Fatal("actual complete SDK binding precondition", err)
+			}
+			switch change {
+			case "initializer close":
+				if err := owner.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "initializer report":
+				owner.report[0] ^= 1
+			case "source owner replacement":
+				source.request.ReadonlyLiterals = request.ReadonlyLiterals
+			case "source owner removed":
+				source.request.ReadonlyLiterals = nil
+			}
+			if ir, err := Translate(file, bound); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("closed or foreign initializer published numerical IR", err)
+			}
+			source.request.ReadonlyLiterals = owner
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restoring the initializer revived a revoked numerical source")
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal("derived-token failure revoked the independent original SDK observation", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralOriginalContextAndReentry(t *testing.T) {
+	// Each bounded fixture belongs to one lifecycle role. Reusing a single
+	// five-minute producer across every race-instrumented recapture couples
+	// independent tests to accumulated work, not the contract under test.
+	t.Run("invalid verification context", func(t *testing.T) {
+		ctx, request, _ := numericalSDKLiteralFixture(t)
+		for _, invalid := range []string{"nil", "canceled"} {
+			t.Run(invalid, func(t *testing.T) {
+				source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+				if err != nil {
+					t.Fatal("actual joined SDK source precondition", err)
+				}
+				defer closeNumericalConsumerSource(t, source)
+				var verification context.Context
+				if invalid == "canceled" {
+					canceled, cancel := context.WithCancel(ctx)
+					cancel()
+					verification = canceled
+				}
+				if err := source.Verify(verification); err == nil {
+					t.Fatal("invalid verification context retained the numerical source")
+				}
+				if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("fresh context revived the revoked numerical source")
+				}
+				if err := request.ReadonlyLiterals.Verify(ctx); err != nil {
+					t.Fatal("invalid consumer context revoked the independent initializer", err)
+				}
+			})
+		}
+	})
+	for _, route := range []string{"original", "verification"} {
+		t.Run(route, func(t *testing.T) {
+			ctx, request, observed := numericalSDKLiteralFixture(t)
+			for _, method := range []string{"Err", "Deadline", "Done"} {
+				t.Run(method, func(t *testing.T) {
+					callback := &sdkASMDataReentrantContext{Context: ctx, method: method}
+					captureContext, verifyContext := ctx, ctx
+					if route == "original" {
+						captureContext = callback
+					} else {
+						verifyContext = callback
+					}
+					source, err := CaptureGoX86SDKNumericalReadSource(captureContext, request)
+					if err != nil {
+						t.Fatal("actual joined SDK source precondition", err)
+					}
+					defer closeNumericalConsumerSource(t, source)
+					called, underLock := false, false
+					var nested error
+					callback.callback = func() {
+						called = true
+						// Detect the forbidden callback-under-lock without allowing
+						// a broken implementation to strand a deadlocked test worker.
+						if !source.mu.TryLock() {
+							underLock = true
+							return
+						}
+						source.mu.Unlock()
+						nested = source.Close()
+					}
+					callback.armed.Store(true)
+					err = source.Verify(verifyContext)
+					if !called || underLock || nested != nil || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("joined numerical lifecycle borrowed a callback lock or published after Close", called, underLock, nested, err)
+					}
+					if err := observed.Verify(ctx); err != nil {
+						t.Fatal("closing the numerical consumer disposed its independent SDK source", err)
+					}
+				})
+			}
+		})
+	}
+	t.Run("original numerical cancellation", func(t *testing.T) {
+		ctx, request, _ := numericalSDKLiteralFixture(t)
+		original, cancel := context.WithCancel(ctx)
+		defer cancel()
+		source, err := CaptureGoX86SDKNumericalReadSource(original, request)
+		if err != nil {
+			t.Fatal("actual joined SDK source precondition", err)
+		}
+		defer closeNumericalConsumerSource(t, source)
+		cancel()
+		if err := source.Verify(ctx); !errors.Is(err, context.Canceled) {
+			t.Fatal("fresh verification context revived the canceled original numerical capture", err)
+		}
+		if err := request.ReadonlyLiterals.Verify(ctx); err != nil {
+			t.Fatal("numerical context cancellation revoked the independent initializer", err)
+		}
+	})
+}
+
+func TestGoX86SDKNumericalReadLiteralConcurrentClose(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	for _, role := range []string{"numerical source", "literal owner"} {
+		t.Run(role, func(t *testing.T) {
+			owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, observed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			local := request
+			local.ReadonlyLiterals = owner
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, local)
+			if err != nil {
+				t.Fatal("actual joined SDK source precondition", err)
+			}
+			defer closeNumericalConsumerSource(t, source)
+			start := make(chan struct{})
+			var workers sync.WaitGroup
+			for worker := 0; worker < 4; worker++ {
+				workers.Add(1)
+				go func() {
+					defer workers.Done()
+					<-start
+					if err := source.Verify(ctx); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error("concurrent joined verification returned an unclassified error", err)
+					}
+				}()
+			}
+			workers.Add(1)
+			go func() {
+				defer workers.Done()
+				<-start
+				var err error
+				if role == "numerical source" {
+					err = source.Close()
+				} else {
+					err = owner.Close()
+				}
+				if err != nil {
+					t.Error("close joined lifecycle role", err)
+				}
+			}()
+			close(start)
+			workers.Wait()
+			if raw, err := source.Readback(ctx); raw != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("concurrent close retained or revived a joined source", err)
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal("consumer close revoked the independent SDK source", err)
+			}
+		})
+	}
+}
+
+// Exercise the initializer/shape checks directly, without allowing the outer
+// full-file fingerprint to be the only reason a changed initializer fails.
+func TestGoX86SDKNumericalReadLiteralInitializerAndReadBoundaries(t *testing.T) {
+	ctx, request, observed := numericalSDKLiteralFixture(t)
+	joined, err := captureNumericalSDKLiteralJoin(ctx, request, numericalSBSDKSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, original, _ := numericalSDKLiteralPackage(t, observed, request.AssemblyFile)
+	if err := joined.verifyFile(original, request.PackagePath); err != nil {
+		t.Fatal("original complete initializer precondition", err)
+	}
+	for _, test := range []struct {
+		name   string
+		change func(*File)
+	}{
+		{"missing initializer", func(f *File) { f.Data = f.Data[1:] }},
+		{"duplicate initializer", func(f *File) { f.Data = append(f.Data, f.Data[0]) }},
+		{"changed payload", func(f *File) { f.Data[0].Value ^= 1 }},
+		{"payload takes precedence", func(f *File) { f.Data[0].Payload = []byte{0xff} }},
+		{"initializer relocation", func(f *File) { f.Data[0].Addr = "internal∕cpu·X86(SB)" }},
+		{"fragment reordering", func(f *File) { f.Data[0], f.Data[1] = f.Data[1], f.Data[0] }},
+		{"fragment width", func(f *File) { f.Data[0].Width++ }},
+		{"fragment offset", func(f *File) { f.Data[0].Off++ }},
+		{"missing extent", func(f *File) { f.Globl = f.Globl[1:] }},
+		{"duplicate extent", func(f *File) { f.Globl = append(f.Globl, f.Globl[0]) }},
+		{"unresolved extent", func(f *File) { f.Globl[0].SizeRaw = "unknown" }},
+		{"extent shrink", func(f *File) { f.Globl[0].Size-- }},
+		{"readonly extra flag", func(f *File) { f.Globl[0].Flags = "10" }},
+		{"global private identity", func(f *File) { f.Globl[0].Sym = strings.TrimSuffix(f.Globl[0].Sym, "<>") }},
+		{"fragment private identity", func(f *File) { f.Data[0].Sym = strings.TrimSuffix(f.Data[0].Sym, "<>") }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file := *original
+			file.Data = append([]DataStmt(nil), original.Data...)
+			file.Globl = append([]GloblStmt(nil), original.Globl...)
+			test.change(&file)
+			if err := joined.verifyFile(&file, request.PackagePath); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unbound initializer image was accepted", err)
+			}
+		})
+	}
+	source := &GoX86NumericalReadSource{request: request, literals: joined}
+	for _, test := range []struct {
+		instruction string
+		operand     int
+		admitted    bool
+	}{
+		{"MOVOU r2r1<>(SB), X0", 0, true},
+		{"MOVOU r2r1<>+48(SB), X0", 0, true},
+		{"VMOVDQU64 r2r1<>(SB), Z0", 0, true},
+		{"PCLMULQDQ $1, r2r1<>(SB), X0", 1, true},
+		{"PSRLQ r2r1<>(SB), X0", 0, true},
+		{"MOVOU r2r1<>+49(SB), X0", 0, false},
+		{"VMOVDQU64 r2r1<>+1(SB), Z0", 0, false},
+		{"MOVOU r2r1<>-1(SB), X0", 0, false},
+		{"VMOVDQU64 r4r3<>(SB), Z0", 0, false},
+		{"MOVOU X0, r2r1<>(SB)", 1, false},
+		{"LEAQ r2r1<>(SB), AX", 0, true},
+		{"CALL r2r1<>(SB)", 0, false},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·fixture(SB),4,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			local, err := source.sdkLiteralRead(file.Funcs[0].Instrs[1], test.operand, "amd64")
+			if !local || test.admitted && err != nil || !test.admitted && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("private initializer read shape/direction/whole extent differs", local, err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralListingObjectBoundaries(t *testing.T) {
+	ctx, request, _ := numericalSDKLiteralFixture(t)
+	joined, err := captureNumericalSDKLiteralJoin(ctx, request, numericalSBSDKSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs := joined.Observation.ObjectInputs
+	selected := inputs.Sources[joined.SourceOrdinal]
+	for _, route := range []string{"original", "expanded"} {
+		for _, mutation := range []string{"valid", "truncated", "private namespace", "text code", "DATA bytes"} {
+			t.Run(route+"/"+mutation, func(t *testing.T) {
+				original := append([]byte(nil), selected.OriginalObject...)
+				expanded := append([]byte(nil), selected.ExpandedObject...)
+				object := &original
+				if route == "expanded" {
+					object = &expanded
+				}
+				switch mutation {
+				case "truncated":
+					*object = (*object)[:len(*object)-1]
+				case "private namespace":
+					index := bytes.Index(*object, []byte("r2r1"))
+					if index < 0 {
+						t.Fatal("actual object lacks its original private namespace")
+					}
+					(*object)[index+3] = '2'
+				case "text code":
+					code := joined.Observation.Objects.Sources[joined.SourceOrdinal].Original.Texts[0].Code
+					index := bytes.Index(*object, code)
+					if index < 0 || len(code) == 0 {
+						t.Fatal("actual object lacks its complete original text")
+					}
+					(*object)[index] ^= 1
+				case "DATA bytes":
+					image := joined.Initializers.Initializers[0].Initial
+					index := bytes.Index(*object, image)
+					if index < 0 || len(image) == 0 {
+						t.Fatal("actual object lacks its complete literal payload")
+					}
+					(*object)[index] ^= 1
+				}
+				first, second, err := gostaticstorage.ObserveX86SDKASMDataListingObjects(inputs, joined.SourceOrdinal, original, expanded)
+				if mutation == "valid" {
+					if err != nil || len(first) != 3 || len(second) != 3 {
+						t.Fatal("actual complete listing object join", err)
+					}
+				} else if first != nil || second != nil || err == nil {
+					t.Fatal("changed whole listing object was accepted", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_numerical_read_sdk_guard_test.go b/go_x86_numerical_read_sdk_guard_test.go
new file mode 100644
index 000000000..a995c8e39
--- /dev/null
+++ b/go_x86_numerical_read_sdk_guard_test.go
@@ -0,0 +1,265 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+func numericalSDKInputSource(t *testing.T, ctx context.Context, request GoX86NumericalReadCaptureRequest) *GoX86NumericalReadSource {
+	t.Helper()
+	source, err := captureGoX86NumericalReadSource(ctx, request, numericalSBSDKSource, true)
+	if err != nil {
+		t.Fatal("actual independent SDK input observation precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	return source
+}
+
+func TestGoX86SDKNumericalReadSealedRoleGraphAndObjectMutations(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	for _, test := range []struct {
+		name   string
+		mutate func(*GoX86NumericalReadSource) func()
+	}{
+		{"role", func(s *GoX86NumericalReadSource) func() {
+			s.role = numericalSBOwnedSource
+			return func() { s.role = numericalSBSDKSource }
+		}},
+		{"package", func(s *GoX86NumericalReadSource) func() {
+			original := s.request.PackagePath
+			s.request.PackagePath = "hash/crc32"
+			return func() { s.request.PackagePath = original }
+		}},
+		{"standard selection", func(s *GoX86NumericalReadSource) func() {
+			s.guard.selection.Standard = false
+			return func() { s.guard.selection.Standard = true }
+		}},
+		{"selected source", func(s *GoX86NumericalReadSource) func() {
+			original := s.guard.selection.SFiles
+			s.guard.selection.SFiles = nil
+			return func() { s.guard.selection.SFiles = original }
+		}},
+		{"export route", func(s *GoX86NumericalReadSource) func() {
+			original := s.guard.selection.Export
+			s.guard.selection.Export = filepath.Join(s.guard.owned, "foreign.a")
+			return func() { s.guard.selection.Export = original }
+		}},
+		{"whole graph", func(s *GoX86NumericalReadSource) func() {
+			original := s.sdk.Graph
+			s.sdk.Graph = append(append([]byte(nil), original...), []byte("{}")...)
+			return func() { s.sdk.Graph = original }
+		}},
+		{"whole archive", func(s *GoX86NumericalReadSource) func() {
+			s.sdk.Archive[0] ^= 1
+			return func() { s.sdk.Archive[0] ^= 1 }
+		}},
+		{"member ordinal", func(s *GoX86NumericalReadSource) func() {
+			s.sdk.ArchiveMembers[1].Offset++
+			return func() { s.sdk.ArchiveMembers[1].Offset-- }
+		}},
+		{"compiled request environment", func(s *GoX86NumericalReadSource) func() {
+			original := s.guard.request.Environment
+			s.guard.request.Environment = append(append([]string(nil), original...), "GOAMD64=v3")
+			return func() { s.guard.request.Environment = original }
+		}},
+		{"borrowed read token", func(s *GoX86NumericalReadSource) func() {
+			s.guard.request.NumericalReads = new(GoX86NumericalReadBinding)
+			return func() { s.guard.request.NumericalReads = nil }
+		}},
+		{"original input hash", func(s *GoX86NumericalReadSource) func() {
+			name := filepath.Join(s.request.Directory, s.request.AssemblyFile)
+			original := s.guard.inputs[name]
+			changed := original
+			changed[0] ^= 1
+			s.guard.inputs[name] = changed
+			return func() { s.guard.inputs[name] = original }
+		}},
+		{"same-shaped foreign owner", func(s *GoX86NumericalReadSource) func() {
+			original := s.request.Owners[0]
+			s.request.Owners[0] = &GoNumericalStorageOwner{observation: original.observation}
+			return func() { s.request.Owners[0] = original }
+		}},
+		{"original context identity", func(s *GoX86NumericalReadSource) func() {
+			original := s.sdk.context
+			s.sdk.context = context.Background()
+			return func() { s.sdk.context = original }
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := numericalSDKInputSource(t, ctx, request)
+			restore := test.mutate(source)
+			err := source.verifySDKObservation(ctx)
+			restore()
+			if !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(source.verifySDKObservation(ctx), ErrProbeNeedsContext) {
+				t.Fatal("mutated/restored SDK observation became valid again", err)
+			}
+			if err := request.Owners[0].Verify(ctx); err != nil {
+				t.Fatal("SDK source rejection revoked an independent data owner", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadCopiedSourceCannotBorrowOrCloseOriginal(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	for _, operation := range []string{"input verify", "public verify", "bind", "close"} {
+		t.Run(operation, func(t *testing.T) {
+			source := numericalSDKInputSource(t, ctx, request)
+			copied := new(GoX86NumericalReadSource)
+			reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(source).Elem())
+			var err error
+			switch operation {
+			case "input verify":
+				err = copied.verifySDKObservation(ctx)
+			case "public verify":
+				err = copied.Verify(ctx)
+			case "bind":
+				var options Options
+				options, err = copied.BindNumericalReads(ctx, GoPackage{}, nil, Options{})
+				if options.NumericalReads != nil {
+					t.Fatal("copied SDK source produced a numerical token")
+				}
+			case "close":
+				err = copied.Close()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("copied SDK source borrowed the original generation", err)
+			}
+			if err := source.verifySDKObservation(ctx); err != nil {
+				t.Fatal("rejecting a SDK source copy revoked the original", err)
+			}
+			if _, err := os.Stat(source.guard.owned); err != nil {
+				t.Fatal("copied SDK source removed the original owned artifacts", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadInvalidVerificationCauseAndCloseRemainFinal(t *testing.T) {
+	ctx, request, owner := numericalSDKCPURequest(t, "amd64")
+	for _, kind := range []string{"nil", "cancelled", "deadline", "closed"} {
+		t.Run(kind, func(t *testing.T) {
+			source := numericalSDKInputSource(t, ctx, request)
+			var invalid context.Context
+			want := ErrProbeNeedsContext
+			switch kind {
+			case "cancelled":
+				var stop context.CancelFunc
+				invalid, stop = context.WithCancel(ctx)
+				stop()
+				want = context.Canceled
+			case "deadline":
+				var stop context.CancelFunc
+				invalid, stop = context.WithDeadline(ctx, time.Now().Add(-time.Second))
+				defer stop()
+				want = context.DeadlineExceeded
+			case "closed":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+				invalid = ctx
+			}
+			first := source.verifySDKObservation(invalid)
+			if !errors.Is(first, want) || want != ErrProbeNeedsContext && errors.Is(first, ErrProbeNeedsContext) {
+				t.Fatal("SDK verification lost its original cause", first)
+			}
+			if !errors.Is(source.verifySDKObservation(ctx), ErrProbeNeedsContext) {
+				t.Fatal("SDK lease was revived after failure/Close")
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("invalid SDK verification revoked the independent CPU owner", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadConcurrentVerifyAndCloseHaveNoPermission(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	source := numericalSDKInputSource(t, ctx, request)
+	var workers sync.WaitGroup
+	for ordinal := 0; ordinal < 4; ordinal++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			// Published verification uses this same source lock. The input-only
+			// observation has no public ready/source/LLVM certificate to publish.
+			source.mu.Lock()
+			err := source.verifySDKObservation(ctx)
+			source.mu.Unlock()
+			if err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Error("unexpected concurrent SDK verification error", err)
+			}
+		}()
+	}
+	workers.Add(1)
+	go func() {
+		defer workers.Done()
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	workers.Wait()
+	if source.ready || !source.sdk.closed || !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("concurrent SDK input observation acquired or revived numerical permission")
+	}
+}
+
+func TestGoX86SDKNumericalReadExplicitFactoryCannotBorrowOwnedOrAliasSource(t *testing.T) {
+	ctx, request, owner := numericalSDKCPURequest(t, "amd64")
+	_, owned, _, _ := numericalSBFixture(t, "amd64")
+	for _, kind := range []string{"owned-main", "physical SDK alias"} {
+		t.Run(kind, func(t *testing.T) {
+			changed := request
+			if kind == "owned-main" {
+				changed.Directory, changed.PackagePath, changed.AssemblyFile = owned.Directory, "example.invalid/numericalfixture", owned.AssemblyFile
+			} else {
+				alias := filepath.Join(t.TempDir(), "sdk-alias")
+				if err := os.Symlink(request.Directory, alias); err != nil {
+					t.Fatal(err)
+				}
+				changed.Directory = alias
+			}
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, changed)
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("SDK factory borrowed a non-SDK or aliased physical source role", err)
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("non-SDK source rejection revoked the actual SDK CPU owner", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadCompleteRawGraphRejectsMissingAndUnknownMetadata(t *testing.T) {
+	first := []byte(`{"ImportPath":"unsafe","Stale":true,"StaleReason":"initial"}
+{"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true}`)
+	if !numericalSameRawSDKGraph(first, []byte(`{"ImportPath":"unsafe","Stale":false}
+{"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true}`)) {
+		t.Fatal("official typed stale-display difference changed source identity")
+	}
+	for _, changed := range []string{
+		`{"ImportPath":"unsafe"}`,
+		`{"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true} {"ImportPath":"unsafe"}`,
+		`{"ImportPath":"unsafe"} {"ImportPath":"internal/cpu","Export":"foreign.a","Standard":true}`,
+		`{"ImportPath":"unsafe"} {"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true,"FutureRole":true}`,
+		`{"ImportPath":"unsafe","Stale":null} {"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true}`,
+		`{"ImportPath":"unsafe"} {"ImportPath":"internal/cpu","Export":"cpu.a","Standard":true} garbage`,
+	} {
+		if numericalSameRawSDKGraph(first, []byte(changed)) {
+			t.Fatal("partial/reordered/foreign/unknown complete graph was normalized away", strings.TrimSpace(changed))
+		}
+	}
+}
diff --git a/go_x86_numerical_read_sdk_list_go127_test.go b/go_x86_numerical_read_sdk_list_go127_test.go
new file mode 100644
index 000000000..630189f2c
--- /dev/null
+++ b/go_x86_numerical_read_sdk_list_go127_test.go
@@ -0,0 +1,37 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestGoX86SDKNumericalReadFreshGraphVerification(t *testing.T) {
+	ctx, request, metadata, owner := numericalSDKAssemblyFixture(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual complete SDK numerical source precondition", err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	for index := 0; index < 2; index++ {
+		begin := time.Now().UnixNano()
+		if err := source.Verify(ctx); err != nil {
+			t.Fatal("fresh complete SDK verification", err)
+		}
+		t.Logf("SDK_VERIFY_WINDOW index=%d begin=%d end=%d", index, begin, time.Now().UnixNano())
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("closed SDK source revived", err)
+	}
+	if err := metadata.Verify(ctx); err != nil {
+		t.Fatal("numerical Close closed independent assembly source", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("numerical Close closed independent numerical storage", err)
+	}
+}
diff --git a/go_x86_numerical_read_sdk_list_test.go b/go_x86_numerical_read_sdk_list_test.go
new file mode 100644
index 000000000..06a41e0f9
--- /dev/null
+++ b/go_x86_numerical_read_sdk_list_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// This real-driver comparison also runs on the minimum SDK. It checks list
+// output semantics, independently of the Go 1.27 numerical owner contract.
+func TestGoX86SDKListRootMatchesWholeGraph(t *testing.T) {
+	_, request := goAMD64FrameSourceFixture(t)
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	for _, arch := range []string{"386", "amd64"} {
+		for _, path := range []string{"internal/cpu", "internal/bytealg", "hash/crc32"} {
+			t.Run(arch+"/"+path, func(t *testing.T) {
+				env := append([]string(nil), request.Environment...)
+				for key, value := range map[string]string{
+					"GOOS": "linux", "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2",
+					"GOFLAGS": "", "GOEXPERIMENT": "", "GOTOOLCHAIN": "local",
+					"CGO_ENABLED": "0", "GOWORK": "off", "GOENV": "off", "GOPROXY": "off",
+				} {
+					for index := len(env) - 1; index >= 0; index-- {
+						if strings.HasPrefix(env[index], key+"=") {
+							env = append(env[:index], env[index+1:]...)
+						}
+					}
+					env = append(env, key+"="+value)
+				}
+				dir := filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", filepath.FromSlash(path))
+				var outputs [][]byte
+				for _, deps := range []bool{false, true} {
+					args := []string{"list", "-json", "-compiled", "-export", "-mod=readonly"}
+					if deps {
+						args = append(args, "-deps")
+					}
+					args = append(args, path)
+					observed, err := goasmcmd.Observe(ctx, dir, env, request.GoBinary, args...)
+					if err != nil || observed.PID <= 0 || !observed.Waited || observed.ExitCode != 0 || len(observed.Stderr) != 0 {
+						t.Fatalf("actual Go list deps=%v: %+v, %v", deps, observed, err)
+					}
+					outputs = append(outputs, observed.Stdout)
+					if root := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); root != "" {
+						name := fmt.Sprintf("list-%s-%s-deps-%v.json", arch, strings.ReplaceAll(path, "/", "-"), deps)
+						if err := os.MkdirAll(root, 0700); err != nil {
+							t.Fatal(err)
+						}
+						if err := os.WriteFile(filepath.Join(root, name), observed.Stdout, 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+				}
+				decoder := json.NewDecoder(bytes.NewReader(outputs[1]))
+				matches := 0
+				for {
+					var raw json.RawMessage
+					if err := decoder.Decode(&raw); err == io.EOF {
+						break
+					} else if err != nil {
+						t.Fatal(err)
+					}
+					var selected struct{ ImportPath string }
+					if err := json.Unmarshal(raw, &selected); err != nil {
+						t.Fatal(err)
+					}
+					if selected.ImportPath == path {
+						matches++
+						if !numericalSameRawSelection(outputs[0], raw) {
+							t.Fatal("complete root metadata changed between actual list commands")
+						}
+					}
+				}
+				if matches != 1 {
+					t.Fatalf("dependency output has %d original roots", matches)
+				}
+			})
+		}
+	}
+}
+
+func TestNumericalSDKGraphRootKeepsCompleteSelection(t *testing.T) {
+	root := `{"ImportPath":"internal/cpu","Match":["internal/cpu"],"Export":"cpu.a","FutureRole":{"Value":1}}`
+	graph := []byte("{\"ImportPath\":\"unsafe\"}\n" + root)
+	raw, err := numericalSDKGraphRoot(graph, "internal/cpu")
+	if err != nil || !bytes.Equal(raw, []byte(root)) || !numericalSameRawSDKGraph(graph, graph) {
+		t.Fatal("whole root or dependency metadata was lost", err)
+	}
+	for _, change := range []struct{ name, graph string }{
+		{"missing", `{"ImportPath":"unsafe"}`},
+		{"duplicate", root + "\n" + root},
+		{"malformed", string(graph) + " garbage"},
+		{"wrong shape", `[]`},
+		{"wrong path type", `{"ImportPath":1}`},
+		{"empty", ""},
+		{"too many records", strings.Repeat("{}\n", 4096) + root},
+		{"too many bytes", strings.Repeat(" ", 16<<20) + root},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			if _, err := numericalSDKGraphRoot([]byte(change.graph), "internal/cpu"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("incomplete root acquired a selection", err)
+			}
+		})
+	}
+	for _, change := range []struct{ name, root string }{
+		{"match", strings.Replace(root, `"Match":["internal/cpu"]`, `"Match":["."]`, 1)},
+		{"dependency role", strings.Replace(root, `"Export"`, `"DepOnly":true,"Export"`, 1)},
+		{"unknown field", strings.Replace(root, `"Value":1`, `"Value":2`, 1)},
+		{"export", strings.Replace(root, `"cpu.a"`, `"foreign.a"`, 1)},
+		{"source addition", strings.Replace(root, `"Export"`, `"GoFiles":["new.go"],"Export"`, 1)},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			changed := bytes.Replace(graph, []byte(root), []byte(change.root), 1)
+			raw, err := numericalSDKGraphRoot(changed, "internal/cpu")
+			if err != nil {
+				t.Fatal("valid changed JSON must reach the complete identity comparison", err)
+			}
+			if numericalSameRawSelection([]byte(root), raw) || numericalSameRawSDKGraph(graph, changed) {
+				t.Fatal("changed complete metadata was normalized away")
+			}
+		})
+	}
+}
+
+func TestGoAMD64RawPackageSelectionReadsActualExport(t *testing.T) {
+	_, request := goAMD64FrameSourceFixture(t)
+	cache, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The archive below is produced in this test's cache, never a shared SDK or
+	// user's cache. Only negative parser controls alter these owned bytes.
+	for _, key := range []string{"GOCACHE", "GOOS", "GOARCH"} {
+		for index := len(request.Environment) - 1; index >= 0; index-- {
+			if strings.HasPrefix(request.Environment[index], key+"=") {
+				request.Environment = append(request.Environment[:index], request.Environment[index+1:]...)
+			}
+		}
+	}
+	request.Environment = append(request.Environment, "GOCACHE="+cache, "GOOS=linux", "GOARCH=amd64")
+	source := newGoOriginalInputGuard(request)
+	source.env = map[string]string{"GOCACHE": cache}
+	ctx, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	selected, raw, err := source.loadWithRawPackage(ctx, ".")
+	if err != nil {
+		t.Fatal("real original package/export precondition", err)
+	}
+	if _, found := source.inputs[selected.Export]; !found {
+		t.Fatal("actual export read was not retained")
+	}
+	for _, name := range []string{"missing export", "empty export", "outside cache", "absent file", "error", "dependency error", "extra record", "changed bytes"} {
+		t.Run(name, func(t *testing.T) {
+			var value map[string]json.RawMessage
+			if err := json.Unmarshal(raw, &value); err != nil {
+				t.Fatal(err)
+			}
+			setExport := func(path string) { value["Export"], _ = json.Marshal(path) }
+			switch name {
+			case "missing export":
+				delete(value, "Export")
+			case "empty export", "outside cache":
+				dir := cache
+				var data []byte
+				if name == "outside cache" {
+					dir = t.TempDir()
+					data = []byte("not this cache's compiler output")
+				}
+				path := filepath.Join(dir, "invalid.a")
+				if err := os.WriteFile(path, data, 0600); err != nil {
+					t.Fatal(err)
+				}
+				setExport(path)
+			case "absent file":
+				setExport(filepath.Join(cache, "missing.a"))
+			case "error":
+				value["Error"] = json.RawMessage(`{"Err":"invalid root"}`)
+			case "dependency error":
+				value["DepsErrors"] = json.RawMessage(`[{"Err":"invalid dependency"}]`)
+			case "changed bytes":
+				original, err := os.ReadFile(selected.Export)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Chmod(selected.Export, 0600); err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.WriteFile(selected.Export, original, 0600); err != nil {
+						t.Error(err)
+					}
+				})
+				if err := os.WriteFile(selected.Export, append(original, '\n'), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			changed, err := json.Marshal(value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if name == "extra record" {
+				changed = append(changed, []byte("\n{}")...)
+			}
+			if _, _, err := source.readRawPackageSelection(changed); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed actual root/export accepted", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_sdk_namespace_go127_test.go b/go_x86_numerical_read_sdk_namespace_go127_test.go
new file mode 100644
index 000000000..e63a19731
--- /dev/null
+++ b/go_x86_numerical_read_sdk_namespace_go127_test.go
@@ -0,0 +1,37 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+)
+
+func TestGoX86SDKNumericalReadPackageQueryMatchesOriginalLiteralSource(t *testing.T) {
+	ctx, request, literalSource := numericalSDKLiteralFixture(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("independent numerical/literal SDK observers selected different packages", err)
+	}
+	defer source.Close()
+
+	var selected struct{ Match []string }
+	if json.Unmarshal(source.rawSelection, &selected) != nil ||
+		!reflect.DeepEqual(selected.Match, []string{request.PackagePath}) ||
+		!numericalSameRawSelection(source.rawSelection, literalSource.observation.RawSelection) {
+		t.Fatal("exact original logical SDK selector was replaced or ignored", selected.Match)
+	}
+	for _, command := range source.commands {
+		args := command.Arguments
+		if len(args) > 0 && args[0] == "list" && args[len(args)-1] != request.PackagePath {
+			t.Fatal("numerical SDK command receipt borrowed the owned-directory selector", args)
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("live numerical SDK selection used a different query", err)
+	}
+	if err := literalSource.Verify(ctx); err != nil {
+		t.Fatal("numerical observer changed its original borrowed SDK source", err)
+	}
+}
diff --git a/go_x86_numerical_read_sdk_positions.go b/go_x86_numerical_read_sdk_positions.go
new file mode 100644
index 000000000..38f9978ed
--- /dev/null
+++ b/go_x86_numerical_read_sdk_positions.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Bind every parsed instruction ordinal to the sealed SDK lexer tape, not a
+// guessed line in a newly flattened file. DATA/GLOBL stay in the authenticated
+// complete program but are not TEXT instructions. Labels retain their order.
+func numericalSDKLiteralSourcePositions(file *File, output string, observed sdkCPPPositionObservation) ([][]string, error) {
+	if file == nil || file.Arch != ArchAMD64 || len(file.UnlinkedPrelude) != 0 {
+		return nil, numericalSBContext("mapped numerical source lacks its complete parsed TEXT")
+	}
+	mapped, err := sdkCPPMappedAssembly(observed.Tokens, ppGoObservationBytes)
+	if err != nil || mapped != observed.Mapped {
+		return nil, numericalSBContext("mapped numerical source changed its complete SDK position tape")
+	}
+	replayed, err := preprocessGoAssembly(mapped, AssemblyPreprocessOptions{})
+	if err != nil || replayed != output {
+		return nil, numericalSBContext("mapped numerical source changed its complete CPP program")
+	}
+	var statements []numericalListingRow
+	var tokens []sdkCPPPositionToken
+	for _, token := range observed.Tokens {
+		if token.Kind != '\n' {
+			tokens = append(tokens, token)
+		}
+		if token.Kind != '\n' && token.Kind != ';' && token.Kind != ':' || len(tokens) == 0 {
+			continue
+		}
+		var text strings.Builder
+		for _, item := range tokens {
+			text.WriteString(item.Text)
+			text.WriteByte(' ')
+		}
+		canonical, err := preprocessGoAssembly(text.String()+"\n", AssemblyPreprocessOptions{})
+		if err != nil {
+			return nil, numericalSBContext("mapped numerical statement cannot be replayed")
+		}
+		canonical = strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(canonical), ";"))
+		base := token.Position.FinalBase
+		line := sdkCPPClampLine(tokens[0].Position.Line)
+		if base.Line == 0 {
+			line = 0
+		} else {
+			line = base.Line + (line - base.Anchor)
+		}
+		position := fmt.Sprintf("%s:%d", base.File, line)
+		statements = append(statements, numericalListingRow{position: position, ins: Instr{Raw: canonical}})
+		tokens = nil
+	}
+	if len(tokens) != 0 {
+		return nil, numericalSBContext("mapped numerical source has unterminated tokens")
+	}
+	var instructions []numericalListingRow
+	for _, statement := range statements {
+		head, err := parseAssemblyOpcode(ArchAMD64, statement.ins.Raw)
+		if err != nil {
+			return nil, err
+		}
+		if head.name != "DATA" && head.name != "GLOBL" {
+			instructions = append(instructions, statement)
+		}
+	}
+	positions := make([][]string, len(file.Funcs))
+	index := 0
+	for f, fn := range file.Funcs {
+		positions[f] = make([]string, len(fn.Instrs))
+		for ordinal, ins := range fn.Instrs {
+			if index >= len(instructions) || instructions[index].ins.Raw != ins.Raw {
+				return nil, numericalSBContext("mapped numerical source ordinal differs from complete parsed instructions")
+			}
+			positions[f][ordinal] = instructions[index].position
+			index++
+		}
+	}
+	if index != len(instructions) {
+		return nil, numericalSBContext("mapped numerical source omitted parsed instruction ordinals")
+	}
+	return positions, nil
+}
+
+// Repeated macro expansions or semicolon statements can have the same logical
+// source position. Their complete source order and actual native PC order must
+// agree too; a filename/line or a matching relocation alone is not a join.
+func numericalSDKLiteralReadOrdinal(fn Func, ordinal int, positions []string, pc int64, row numericalListingRow,
+	rows map[int64][]numericalListingRow, pkg, arch string,
+) bool {
+	logical, valid := numericalSDKListingLogicalPosition(row.position)
+	if !valid || ordinal < 0 || ordinal >= len(fn.Instrs) || len(positions) != len(fn.Instrs) || logical != positions[ordinal] {
+		return false
+	}
+	ins := fn.Instrs[ordinal]
+	if !numericalSameInstruction(ins, row.ins, pkg, arch) {
+		return false
+	}
+	sourceRank := 0
+	for index, prior := range fn.Instrs[:ordinal] {
+		if positions[index] == logical && numericalSameInstruction(ins, prior, pkg, arch) {
+			sourceRank++
+		}
+	}
+	nativeRank := 0
+	for before, previous := range rows {
+		if before >= pc {
+			continue
+		}
+		for _, previous := range previous {
+			before, valid := numericalSDKListingLogicalPosition(previous.position)
+			if valid && before == logical && numericalSameInstruction(ins, previous.ins, pkg, arch) {
+				nativeRank++
+			}
+		}
+	}
+	return sourceRank == nativeRank
+}
+
+// Go's Pos.Format(true,true) prints a #line position as logical[original].
+// Keep the complete listing in the native proof; only the logical projection
+// can be compared with Go's binary PC tables and the authenticated lexer tape.
+// The bracket annotation is not an authenticated physical-file lookup route.
+func numericalSDKListingLogicalPosition(display string) (string, bool) {
+	validPosition := func(position string) bool {
+		colon := strings.LastIndexByte(position, ':')
+		if colon <= 0 || strings.ContainsAny(position, "[]\r\n") {
+			return false
+		}
+		line := position[colon+1:]
+		if line == "" {
+			return false
+		}
+		for _, digit := range line {
+			if digit < '0' || digit > '9' {
+				return false
+			}
+		}
+		_, err := strconv.ParseUint(line, 10, 32)
+		return err == nil
+	}
+	logical := display
+	if bracket := strings.IndexByte(display, '['); bracket >= 0 {
+		if !strings.HasSuffix(display, "]") || !validPosition(display[bracket+1:len(display)-1]) {
+			return "", false
+		}
+		logical = display[:bracket]
+	}
+	return logical, validPosition(logical)
+}
+
+// Native SDK PC tables use $GOROOT metadata while -S uses absolute names.
+// Resolve only against this invocation's captured root and existing exact CPP
+// input inventory. A logical name never authorizes opening an arbitrary file.
+func (source *GoX86NumericalReadSource) sdkLiteralObjectSource(name string) (string, bool) {
+	if source.sdkAssemblyJoin() == nil {
+		return "", false
+	}
+	name, valid := originalGoObjectSourcePath(name, source.guard.env["GOROOT"])
+	if !valid {
+		return "", false
+	}
+	digest, captured := source.guard.inputs[name]
+	if !captured {
+		return "", false
+	}
+	for _, input := range source.cpp.Sources {
+		if input.File == name && input.SHA256 == fmt.Sprintf("%x", digest) {
+			return name, true
+		}
+	}
+	return "", false
+}
diff --git a/go_x86_numerical_read_sdk_positions_test.go b/go_x86_numerical_read_sdk_positions_test.go
new file mode 100644
index 000000000..627f5fbf4
--- /dev/null
+++ b/go_x86_numerical_read_sdk_positions_test.go
@@ -0,0 +1,193 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestGoX86SDKNumericalReadLiteralMappedRepeatedPositions(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg, profile, _, _ := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			filename := filepath.Join(profile.Directory, "positions.s")
+			original := fmt.Sprintf(`#define READ CMPB ·Flag(SB), $1
+#define PAIR READ; READ
+DATA table<>+0(SB)/8, $1
+GLOBL table<>(SB), 8, $8
+TEXT ·positions(SB), 4, $0-0
+READ; READ
+PAIR
+#line 50 %q
+READ
+#line 50 %q
+READ
+RET
+`, filename, filename)
+			observed, tape, err := observeSDKAssemblyCPP(original, AssemblyPreprocessOptions{FileName: filename})
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, observed.Output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			positions, err := numericalSDKLiteralSourcePositions(file, observed.Output, tape)
+			if err != nil || len(positions) != 1 || len(positions[0]) != 8 {
+				t.Fatal("complete original source position tape", err, positions)
+			}
+			for _, mutation := range []string{"token text", "token position", "mapped stream", "CPP program", "parsed ordinal"} {
+				t.Run(mutation, func(t *testing.T) {
+					changed := tape
+					changed.Tokens = append([]sdkCPPPositionToken(nil), tape.Tokens...)
+					program := observed.Output
+					parsed := *file
+					parsed.Funcs = append([]Func(nil), file.Funcs...)
+					switch mutation {
+					case "token text":
+						changed.Tokens[0].Text += "foreign"
+					case "token position":
+						changed.Tokens[0].Position.Line++
+					case "mapped stream":
+						changed.Mapped += "RET\n"
+					case "CPP program":
+						program += "RET\n"
+					case "parsed ordinal":
+						parsed.Funcs[0].Instrs = append([]Instr(nil), file.Funcs[0].Instrs[1:]...)
+					}
+					if _, err := numericalSDKLiteralSourcePositions(&parsed, program, changed); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed complete source/tape/ordinal was accepted", err)
+					}
+				})
+			}
+			for _, route := range []string{"original", "mapped"} {
+				t.Run(route, func(t *testing.T) {
+					path, program := filename, original
+					if route == "mapped" {
+						path, program = filepath.Join(profile.Directory, "mapped.asm"), tape.Mapped
+					}
+					if err := os.WriteFile(path, []byte(program), 0600); err != nil {
+						t.Fatal(err)
+					}
+					listing, err := goasmcmd.Run(ctx, profile.Directory, profile.Environment, profile.GoBinary,
+						"tool", "asm", "-S", "-p", pkg.Path, "-o", filepath.Join(profile.Directory, route+".o"), path)
+					if err != nil {
+						t.Fatal("actual original/mapped Go assembler", err)
+					}
+					all, err := numericalListingRows(listing)
+					if err != nil {
+						t.Fatal(err)
+					}
+					rows := all[pkg.Path+".positions"]
+					for ordinal := 1; ordinal <= 6; ordinal++ {
+						matches := 0
+						for pc, candidates := range rows {
+							for _, row := range candidates {
+								if !numericalSDKLiteralReadOrdinal(file.Funcs[0], ordinal, positions[0], pc, row, rows, pkg.Path, arch) {
+									continue
+								}
+								matches++
+								changed := row
+								changed.position += ".foreign"
+								if numericalSDKLiteralReadOrdinal(file.Funcs[0], ordinal, positions[0], pc, changed, rows, pkg.Path, arch) {
+									t.Fatal("foreign source position borrowed a read ordinal")
+								}
+								for other := 1; other <= 6; other++ {
+									if other != ordinal && numericalSDKLiteralReadOrdinal(file.Funcs[0], other, positions[0], pc, row, rows, pkg.Path, arch) {
+										t.Fatal("repeated macro/source line borrowed another native PC")
+									}
+								}
+							}
+						}
+						if matches != 1 {
+							t.Fatalf("source ordinal %d has %d native matches, expected %s; actual listing:\n%s", ordinal, matches, positions[0][ordinal], listing)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralPositionDisplayGrammar(t *testing.T) {
+	for _, input := range []string{"source.s:0", "source.s:12", "source.s:12[source.s:20]", "source.s:12[generated.s:20]"} {
+		if _, valid := numericalSDKListingLogicalPosition(input); !valid {
+			t.Fatal("valid Go position display rejected", input)
+		}
+	}
+	for _, input := range []string{"", ":1", "source.s", "source.s:-1", "source.s:+1", "source.s:1x",
+		"source.s:4294967296", "source.s:1[", "source.s:1[]", "source.s:1[other.s:x]",
+		"source.s:1[other.s:2]tail", "source.s:1[other.s:2[third.s:3]]", "source.s:1]", "source.s:1\n"} {
+		if _, valid := numericalSDKListingLogicalPosition(input); valid {
+			t.Fatal("unknown/malformed Go position display accepted", input)
+		}
+	}
+}
+
+func TestGoX86SDKNumericalReadLiteralObjectSourceNames(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "sdk")
+	assembly := filepath.Join(root, "src", "sample", "input.s")
+	goSource := filepath.Join(root, "src", "sample", "input.go")
+	digest := sha256.Sum256([]byte("captured source"))
+	newSource := func() *GoX86NumericalReadSource {
+		return &GoX86NumericalReadSource{
+			literals: &numericalSDKLiteralJoin{},
+			guard: &GoAMD64FrameSource{
+				env: map[string]string{"GOROOT": root},
+				inputs: map[string][32]byte{
+					assembly: digest,
+					goSource: digest,
+				},
+			},
+			cpp: AssemblyCPPObservation{Sources: []AssemblyCPPObservedSource{
+				{File: assembly, SHA256: fmt.Sprintf("%x", digest)},
+			}},
+		}
+	}
+	for _, name := range []string{assembly, filepath.ToSlash(assembly), "$GOROOT/src/sample/input.s"} {
+		if actual, valid := newSource().sdkLiteralObjectSource(name); !valid || actual != assembly {
+			t.Fatal("exact captured SDK/CPP source spelling rejected", name, actual, valid)
+		}
+	}
+	for _, name := range []string{
+		"", "input.s", "src/sample/input.s", "$GOROOT", "$GOROOT/../input.s",
+		"$GOROOT/src/../src/sample/input.s", "$GOROOT//src/sample/input.s",
+		"$GOROOT/src/sample/./input.s", "$GOROOT/src/sample/missing.s",
+		"$GOROOT/src/sample/input.go", goSource, assembly + ".foreign",
+	} {
+		if actual, valid := newSource().sdkLiteralObjectSource(name); valid {
+			t.Fatal("unbound source spelling supplied a native PC identity", name, actual)
+		}
+	}
+	for _, mutation := range []string{"ordinary source", "missing captured input", "missing CPP input", "stale captured hash", "stale CPP hash", "different SDK root"} {
+		t.Run(mutation, func(t *testing.T) {
+			source := newSource()
+			switch mutation {
+			case "ordinary source":
+				source.literals = nil
+			case "missing captured input":
+				delete(source.guard.inputs, assembly)
+			case "missing CPP input":
+				source.cpp.Sources = nil
+			case "stale captured hash":
+				source.guard.inputs[assembly] = sha256.Sum256([]byte("changed source"))
+			case "stale CPP hash":
+				source.cpp.Sources[0].SHA256 = "changed"
+			case "different SDK root":
+				source.guard.env["GOROOT"] = filepath.Join(root, "other")
+			}
+			if actual, valid := source.sdkLiteralObjectSource("$GOROOT/src/sample/input.s"); valid {
+				t.Fatal("changed captured SDK/CPP identity supplied a native PC", actual)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_sdk_reference_test.go b/go_x86_numerical_read_sdk_reference_test.go
new file mode 100644
index 000000000..788c943ac
--- /dev/null
+++ b/go_x86_numerical_read_sdk_reference_test.go
@@ -0,0 +1,149 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func numericalSDKReferencedInputSource(t *testing.T, arch string) *GoX86NumericalReadSource {
+	t.Helper()
+	ctx, request, _ := numericalSDKCPURequest(t, arch)
+	root := filepath.Dir(filepath.Dir(request.GoBinary))
+	request.Directory = filepath.Join(root, "src", "internal", "bytealg")
+	request.PackagePath = "internal/bytealg"
+	request.AssemblyFile = "compare_" + arch + ".s"
+	return numericalSDKInputSource(t, ctx, request)
+}
+
+func TestGoX86SDKNumericalReadReferencedArchiveSealAndSourceIdentity(t *testing.T) {
+	for _, kind := range []string{"missing target", "wrong package", "different same-SDK archive", "changed byte", "member source", "foreign export route", "copied source"} {
+		t.Run(kind, func(t *testing.T) {
+			source := numericalSDKReferencedInputSource(t, "amd64")
+			ctx := source.sdk.originalContext
+			original, present := source.sdk.Referenced["internal/cpu"]
+			if !present || len(original.Archive) == 0 {
+				t.Fatal("actual retained SDK reference precondition")
+			}
+			if kind == "copied source" {
+				copied := new(GoX86NumericalReadSource)
+				reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(source).Elem())
+				if !errors.Is(copied.verifySDKObservation(ctx), ErrProbeNeedsContext) ||
+					!errors.Is(copied.Close(), ErrProbeNeedsContext) {
+					t.Fatal("copied source borrowed SDK indexed metadata or removed original resources")
+				}
+				if err := source.verifySDKObservation(ctx); err != nil {
+					t.Fatal("rejecting copied SDK referenced source revoked original", err)
+				}
+				return
+			}
+			changed := original
+			restore := func() { source.sdk.Referenced["internal/cpu"] = original }
+			switch kind {
+			case "missing target":
+				delete(source.sdk.Referenced, "internal/cpu")
+			case "wrong package":
+				changed.PackagePath = "internal/bytealg"
+				source.sdk.Referenced["internal/cpu"] = changed
+			case "different same-SDK archive":
+				changed.Archive = append([]byte(nil), source.sdk.Archive...)
+				source.sdk.Referenced["internal/cpu"] = changed
+			case "changed byte":
+				changed.Archive = append([]byte(nil), original.Archive...)
+				changed.Archive[len(changed.Archive)/2] ^= 1
+				source.sdk.Referenced["internal/cpu"] = changed
+			case "member source":
+				changed.Sources = []string{"foreign.s"}
+				source.sdk.Referenced["internal/cpu"] = changed
+			case "foreign export route":
+				selection := source.sdk.Imports["internal/cpu"]
+				originalSelection := selection
+				selection.Export = source.guard.selection.Export
+				source.sdk.Imports["internal/cpu"] = selection
+				restore = func() { source.sdk.Imports["internal/cpu"] = originalSelection }
+			}
+			err := source.verifySDKObservation(ctx)
+			restore()
+			if !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(source.verifySDKObservation(ctx), ErrProbeNeedsContext) {
+				t.Fatal("foreign/restored SDK referenced metadata revived its source lease", err)
+			}
+			if err := source.request.Owners[0].Verify(ctx); err != nil {
+				t.Fatal("rejecting source metadata revoked unrelated SDK CPU numerical storage owner", err)
+			}
+		})
+	}
+}
+
+type numericalSDKReferencedMutationContext struct {
+	context.Context
+	once   sync.Once
+	mutate func()
+}
+
+func (ctx *numericalSDKReferencedMutationContext) Err() error {
+	pc, _, _, valid := runtime.Caller(1)
+	if valid && strings.HasSuffix(runtime.FuncForPC(pc).Name(), "(*GoAMD64FrameSource).run") {
+		ctx.once.Do(ctx.mutate)
+	}
+	return ctx.Context.Err()
+}
+
+func TestGoX86SDKNumericalReadReferencedArchiveCommandTOCTOU(t *testing.T) {
+	source := numericalSDKReferencedInputSource(t, "amd64")
+	ctx := source.sdk.originalContext
+	original := source.sdk.Referenced["internal/cpu"]
+	called := false
+	wrapped := &numericalSDKReferencedMutationContext{Context: ctx, mutate: func() {
+		called = true
+		changed := original
+		changed.Archive = append([]byte(nil), original.Archive...)
+		changed.Archive[0] ^= 1
+		source.sdk.Referenced["internal/cpu"] = changed
+	}}
+	err := source.verifySDKObservation(wrapped)
+	source.sdk.Referenced["internal/cpu"] = original
+	if !called || !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(source.verifySDKObservation(ctx), ErrProbeNeedsContext) {
+		t.Fatal("SDK input pre/post guard published or revived changed metadata around an actual command", called, err)
+	}
+	if source.ready || len(source.reads) != 0 || source.file != nil {
+		t.Fatal("SDK metadata TOCTOU left a numerical/native certificate")
+	}
+	if err := source.request.Owners[0].Verify(ctx); err != nil {
+		t.Fatal("SDK metadata postcheck revoked the independent CPU numerical owner", err)
+	}
+}
+
+func TestGoX86SDKNumericalReadActualReferencedArchiveHandoff(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source := numericalSDKReferencedInputSource(t, arch)
+			selected, exists := source.sdk.Imports["internal/cpu"]
+			archive, retained := source.sdk.Referenced["internal/cpu"]
+			if !exists || !retained || selected.Export == "" || archive.PackagePath != selected.ImportPath ||
+				!reflect.DeepEqual(archive.Sources, selected.SFiles) || len(archive.Archive) == 0 {
+				t.Fatal("actual SDK graph did not hand off the exact referenced compiler archive")
+			}
+			actual, err := os.ReadFile(selected.Export)
+			if err != nil || !bytes.Equal(actual, archive.Archive) ||
+				source.sdk.Inputs[selected.Export] != sha256.Sum256(actual) {
+				t.Fatal("referenced SDK compiler bytes escaped their complete original input seal", err)
+			}
+			if source.ready || source.file != nil || len(source.reads) != 0 {
+				t.Fatal("SDK indexed metadata handed off a numerical/native permission")
+			}
+			if err := source.verifySDKObservation(source.sdk.originalContext); err != nil {
+				t.Fatal("actual same-SDK referenced graph cannot verify", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_sdk_test.go b/go_x86_numerical_read_sdk_test.go
new file mode 100644
index 000000000..51681361f
--- /dev/null
+++ b/go_x86_numerical_read_sdk_test.go
@@ -0,0 +1,273 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func numericalSDKCRC32Request(t *testing.T) (context.Context, GoX86NumericalReadCaptureRequest, *GoNumericalStorageOwner) {
+	t.Helper()
+	_, profile, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	root := filepath.Dir(filepath.Dir(profile.GoBinary))
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: profile.GoBinary, Directory: filepath.Join(root, "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: profile.Target, Environment: profile.Environment,
+		SDKCPU: true, Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal("actual SDK CPU owner precondition", err)
+	}
+	t.Cleanup(owner.Close)
+	request := GoX86NumericalReadCaptureRequest{
+		GoBinary: profile.GoBinary, Directory: filepath.Join(root, "src", "hash", "crc32"),
+		PackagePath: "hash/crc32", AssemblyFile: "crc32_amd64.s", Target: profile.Target,
+		Environment: profile.Environment, Owners: []*GoNumericalStorageOwner{owner},
+	}
+	data, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil || !strings.Contains(string(data), "CMPB internal∕cpu·X86+const_offsetX86HasAVX512VPCLMULQDQL(SB), $1") {
+		t.Fatal("actual unchanged SDK crc32 counterexample is absent", err)
+	}
+	actual, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary,
+		"list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+	if err != nil {
+		t.Fatal("stock Go failed the original complete CRC32 package", err)
+	}
+	var selected goAMD64FrameSelection
+	if err := json.Unmarshal(actual, &selected); err != nil || !selected.Standard || selected.Module != nil ||
+		selected.ImportPath != request.PackagePath || selected.Dir != request.Directory || selected.Export == "" {
+		t.Fatal("actual SDK selection differs from the exact package", err)
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil || len(archive) == 0 {
+		t.Fatal("actual selected SDK compiler archive is absent", err)
+	}
+	if artifacts := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifacts != "" {
+		folder := filepath.Join(artifacts, "sdk-crc32-original")
+		if err := os.MkdirAll(folder, 0700); err != nil {
+			t.Fatal(err)
+		}
+		for name, bytes := range map[string][]byte{"source.s": data, "selection.json": actual, "original.a": archive} {
+			if err := os.WriteFile(filepath.Join(folder, name), bytes, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	return ctx, request, owner
+}
+
+func numericalSDKCPURequest(t *testing.T, arch string) (context.Context, GoX86NumericalReadCaptureRequest, *GoNumericalStorageOwner) {
+	t.Helper()
+	_, profile, _, _ := numericalSBFixture(t, arch)
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	root := filepath.Dir(filepath.Dir(profile.GoBinary))
+	directory := filepath.Join(root, "src", "internal", "cpu")
+	owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+		GoBinary: profile.GoBinary, Directory: directory, PackagePath: "internal/cpu",
+		Target: profile.Target, Environment: profile.Environment, SDKCPU: true,
+		Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+	})
+	if err != nil {
+		t.Fatal("actual independent SDK CPU owner precondition", err)
+	}
+	t.Cleanup(owner.Close)
+	return ctx, GoX86NumericalReadCaptureRequest{GoBinary: profile.GoBinary, Directory: directory,
+		PackagePath: "internal/cpu", AssemblyFile: "cpu_x86.s", Target: profile.Target,
+		Environment: profile.Environment, Owners: []*GoNumericalStorageOwner{owner}}, owner
+}
+
+func TestGoX86SDKNumericalReadOriginalArchiveFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, request, owner := numericalSDKCPURequest(t, arch)
+			report, err := owner.observation.Readback(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var selected gostaticstorage.Package
+			decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+			for {
+				var candidate gostaticstorage.Package
+				if err := decoder.Decode(&candidate); err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				if candidate.ImportPath == request.PackagePath {
+					if selected.ImportPath != "" {
+						t.Fatal("duplicate selected SDK CPU package")
+					}
+					selected = candidate
+				}
+			}
+			if selected.ImportPath != request.PackagePath || len(selected.SFiles) == 0 {
+				t.Fatal("complete actual SDK CPU source selection is absent")
+			}
+			archive := report.Archives[request.PackagePath]
+			observed, err := gostaticstorage.ObserveX86SDKAssemblyArchive(archive, report.TextBuiltinSource,
+				request.Target, selected.SFiles)
+			if err != nil || !reflect.DeepEqual(observed, report.TextArchives[request.PackagePath]) {
+				t.Fatal("explicit SDK observation differs from complete original SDK owner metadata", err)
+			}
+			if _, err := gostaticstorage.ObserveX86AssemblyArchive(archive, report.TextBuiltinSource,
+				request.Target, selected.SFiles); !errors.Is(err, gostaticstorage.ErrContext) {
+				t.Fatal("owned observer admitted SDK Std flags", err)
+			}
+			for _, member := range observed[1:] {
+				body := archive[member.Offset : member.Offset+member.Size]
+				header := bytes.Index(body, []byte("\x00go120ld"))
+				if header < 0 || header+20 > len(body) || binary.LittleEndian.Uint32(body[header+16:]) != member.Flags {
+					t.Fatal("actual SDK object flags have no complete member-bound header")
+				}
+				for _, flags := range []uint32{member.Flags ^ 16, member.Flags ^ 4, member.Flags | 1, member.Flags | 8} {
+					changed := append([]byte(nil), archive...)
+					binary.LittleEndian.PutUint32(changed[int(member.Offset)+header+16:], flags)
+					if _, err := gostaticstorage.ObserveX86SDKAssemblyArchive(changed, report.TextBuiltinSource,
+						request.Target, selected.SFiles); !errors.Is(err, gostaticstorage.ErrContext) {
+						t.Fatal("SDK decoder accepted changed Std/assembly/shared/unlinkable object flags", flags, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadOriginalInputObservationNoAuthority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, request, _ := numericalSDKCPURequest(t, arch)
+			source, err := captureGoX86NumericalReadSource(ctx, request, numericalSBSDKSource, true)
+			if err != nil {
+				t.Fatal("complete actual SDK input observation is absent", err)
+			}
+			t.Cleanup(func() { source.Close() })
+			if source.ready || source.file != nil || len(source.reads) != 0 || source.sdk == nil {
+				t.Fatal("SDK input-only observation created numerical permission")
+			}
+			if err := source.verifySDKObservation(ctx); err != nil {
+				t.Fatal("actual independent SDK observation does not verify", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadCompleteOriginalSelectedSource(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	source, err := captureGoX86NumericalReadSource(ctx, request, numericalSBSDKSource, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	for _, files := range [][]string{source.guard.selection.GoFiles, source.guard.selection.SFiles, source.guard.selection.HFiles} {
+		for _, name := range files {
+			file := filepath.Join(request.Directory, name)
+			if _, present := source.sdk.Inputs[file]; !present {
+				t.Errorf("SDK source role omitted complete selected original bytes: %s", name)
+			}
+		}
+	}
+}
+
+func TestGoX86SDKNumericalReadOriginalCaptureContextCannotRevive(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	captured, cancel := context.WithCancel(ctx)
+	source, err := captureGoX86NumericalReadSource(captured, request, numericalSBSDKSource, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	cancel()
+	if err := source.verifySDKObservation(ctx); !errors.Is(err, context.Canceled) || errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("fresh context revived the original cancelled SDK capture", err)
+	}
+	if err := source.verifySDKObservation(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("failed SDK source lease did not remain revoked", err)
+	}
+}
+
+func TestGoX86SDKNumericalReadOriginalCommandRequestSealed(t *testing.T) {
+	ctx, request, _ := numericalSDKCPURequest(t, "amd64")
+	for _, field := range []string{"target", "assembly"} {
+		t.Run(field, func(t *testing.T) {
+			source, err := captureGoX86NumericalReadSource(ctx, request, numericalSBSDKSource, true)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			original := source.guard.request
+			if field == "target" {
+				source.guard.request.Target = "linux/386"
+			} else {
+				source.guard.request.AssemblyFile = "foreign.s"
+			}
+			err = source.verifySDKObservation(ctx)
+			source.guard.request = original
+			if !errors.Is(err, ErrProbeNeedsContext) || !errors.Is(source.verifySDKObservation(ctx), ErrProbeNeedsContext) {
+				t.Fatal("mutated/restored actual SDK command request revived the source role", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalReadDefaultOwnedRemainsContext(t *testing.T) {
+	ctx, request, owner := numericalSDKCRC32Request(t)
+	source, err := CaptureGoX86NumericalReadSource(ctx, request)
+	if source != nil {
+		source.Close()
+	}
+	if source != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "owned source role") {
+		t.Fatal("default owned factory borrowed SDK source identity", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("refusing SDK source revoked the independent data owner", err)
+	}
+}
+
+func TestGoX86SDKNumericalReadOriginalCRC32KeepsUnadmittedArchiveContext(t *testing.T) {
+	ctx, request, owner := numericalSDKCRC32Request(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if source != nil {
+		source.Close()
+	}
+	if source != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "assembly DATA definition needs an independent role: r2r1") {
+		t.Fatal("explicit SDK source authentication lost its exact unadmitted private DATA boundary", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("unadmitted archive Context revoked the independent SDK CPU data owner", err)
+	}
+	t.Logf("ACTUAL_SDK_CRC32_FIRST_BLOCK %v", err)
+}
+
+func TestGoX86SDKNumericalReadCompleteCPPAssemblerWithoutNumericalReadRemainsContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, request, owner := numericalSDKCPURequest(t, arch)
+			source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+			if source != nil {
+				source.Close()
+			}
+			if source != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "no certified numerical SB reads") {
+				t.Fatal("complete actual SDK CPP/native program acquired an uncertified read", err)
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("unrelated SDK source Context revoked the CPU numerical owner", err)
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_source.go b/go_x86_numerical_read_source.go
new file mode 100644
index 000000000..3a1839eb8
--- /dev/null
+++ b/go_x86_numerical_read_source.go
@@ -0,0 +1,649 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"sync/atomic"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type GoX86NumericalReadCaptureRequest struct {
+	GoBinary, Directory, PackagePath, AssemblyFile, Target string
+	Environment                                            []string
+	Owners                                                 []*GoNumericalStorageOwner
+
+	// ReadonlyLiterals explicitly selects the same live SDK assembly source's
+	// independent private literal initializer role. Nil retains the TEXT-only
+	// boundary. Ordinary owned-main capture cannot consume this SDK role.
+	// This is not a numerical variable, pointer, caller or native-entry owner.
+	// The borrowed owner and its original SDK source must remain live through
+	// binding and translation; closing this numerical source never closes them.
+	ReadonlyLiterals *GoX86SDKReadonlyLiteralDataOwner
+
+	// AssemblySource observes complete original/expanded/compiler source nodes
+	// independently of DATA initialization. It grants no numerical storage or
+	// entry state. Nil preserves the existing ordinary TEXT-only route.
+	AssemblySource *GoX86SDKASMDataSource
+}
+
+// GoX86NumericalReadSource is a sealed source/native-instruction/numerical-owner
+// join. Capture alone supplies no Options, LLVM load, caller or entry authority.
+// Ordinary owned-main and explicit independently observed SDK sources retain
+// separate roles. External sources and generated headers without an explicit
+// independent SDK source observation remain Context.
+type GoX86NumericalReadSource struct {
+	mu                           sync.Mutex
+	revoked                      atomic.Bool
+	identity                     *GoX86NumericalReadSource
+	ready                        bool
+	request                      GoX86NumericalReadCaptureRequest
+	guard                        *GoAMD64FrameSource // private reuse of file/command guards, NOT its factory or frame role
+	dirs                         map[string]os.FileInfo
+	misses                       map[string]bool
+	file                         *File
+	cpp                          AssemblyCPPObservation
+	reads                        []numericalSBRead
+	native                       numericalSBNativeProof
+	report                       []byte
+	seal                         [32]byte
+	stateSeal                    [32]byte
+	rawSelection, rawEnvironment []byte
+	originalOwners               []*GoNumericalStorageOwner
+	commands                     []numericalSBCommand
+	role                         numericalSBSourceRole
+	sdk                          *numericalSBSDKObservation
+	literals                     *numericalSDKLiteralJoin
+	assembly                     *numericalSDKAssemblyJoin
+}
+
+type numericalSBCommand struct {
+	Directory, Binary string
+	Arguments         []string
+	Stdout            []byte
+}
+
+func CaptureGoX86NumericalReadSource(ctx context.Context, request GoX86NumericalReadCaptureRequest) (*GoX86NumericalReadSource, error) {
+	return captureGoX86NumericalReadSource(ctx, request, numericalSBOwnedSource, false)
+}
+
+func captureGoX86NumericalReadSource(ctx context.Context, request GoX86NumericalReadCaptureRequest,
+	role numericalSBSourceRole, inputsOnly bool,
+) (_ *GoX86NumericalReadSource, result error) {
+	if ctx != nil && ctx.Err() != nil {
+		return nil, fmt.Errorf("capture numerical read source: %w", ctx.Err())
+	}
+	if role != numericalSBOwnedSource && role != numericalSBSDKSource || inputsOnly && role != numericalSBSDKSource ||
+		ctx == nil || !gostaticstorage.X86SDKTarget(request.Target) ||
+		role == numericalSBOwnedSource && request.Target != "linux/386" && request.Target != "linux/amd64" ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) || request.PackagePath == "" ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || !strings.HasSuffix(request.AssemblyFile, ".s") ||
+		len(request.Owners) == 0 || len(request.Owners) > 8 {
+		return nil, numericalSBContext("needs bounded actual x86 source/tool/owner inputs")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, numericalSBContext("requires bounded live context")
+	}
+	request.Environment = append([]string(nil), request.Environment...)
+	request.Owners = append([]*GoNumericalStorageOwner(nil), request.Owners...)
+	literals, err := captureNumericalSDKLiteralJoin(ctx, request, role)
+	if err != nil {
+		return nil, err
+	}
+	assembly, err := captureNumericalSDKAssemblyJoin(ctx, request, role)
+	if err != nil {
+		return nil, err
+	}
+	provided := make(map[string]string)
+	for _, pair := range request.Environment {
+		key, value, valid := strings.Cut(pair, "=")
+		if !valid || key == "" {
+			return nil, numericalSBContext("malformed actual command environment")
+		}
+		if _, duplicate := provided[key]; duplicate {
+			return nil, numericalSBContext("duplicate actual command environment")
+		}
+		provided[key] = value
+	}
+	goos, arch, _ := strings.Cut(request.Target, "/")
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2",
+		"CGO_ENABLED": "0", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOEXPERIMENT": "", "GOPROXY": "off"} {
+		if key == "CGO_ENABLED" && role == numericalSBSDKSource && (provided[key] == "0" || provided[key] == "1") {
+			continue // Complete selected SDK graph still rejects every cgo/generated source.
+		}
+		if provided[key] != value {
+			return nil, numericalSBContext("unbound actual command profile: %s", key)
+		}
+	}
+	if provided["GOPACKAGESDRIVER"] != "" && provided["GOPACKAGESDRIVER"] != "off" {
+		return nil, numericalSBContext("external package driver needs independent mapping")
+	}
+	source := &GoX86NumericalReadSource{request: request, role: role, literals: literals, assembly: assembly, dirs: make(map[string]os.FileInfo), misses: make(map[string]bool),
+		originalOwners: append([]*GoNumericalStorageOwner(nil), request.Owners...)}
+	source.identity = source
+	source.guard = newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary, Directory: request.Directory,
+		AssemblyFile: request.AssemblyFile, Target: request.Target, Environment: request.Environment})
+	for _, directory := range append([]string{request.Directory}, provided["GOCACHE"], provided["GOMODCACHE"], provided["GOPATH"], provided["TMPDIR"], provided["GOTMPDIR"]) {
+		if err := source.retainDirectory(directory); err != nil {
+			return nil, err
+		}
+	}
+	snapshot := source.guard.snapshotDirectory
+	if role == numericalSBSDKSource {
+		snapshot = func() error {
+			return captureSDKPackageDirectoryInputs(source.guard, source.retainDirectory)
+		}
+	}
+	if err := snapshot(); err != nil {
+		return nil, err
+	}
+	owned, err := os.MkdirTemp(provided["TMPDIR"], "plan9asm-numerical-read-")
+	if err != nil {
+		return nil, err
+	}
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		return nil, err
+	}
+	source.guard.owned = owned
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	// Canonicalize only the freshly factory-created directory, never caller inputs.
+	canonicalOwned, err := sourcepath.Resolve(owned)
+	info, statErr := os.Lstat(canonicalOwned)
+	if err != nil || statErr != nil || !info.IsDir() || !os.SameFile(source.guard.ownedInfo, info) || !goAssemblyPathWithinRoot(provided["TMPDIR"], canonicalOwned) {
+		return nil, numericalSBContext("new factory artifact role changed during canonicalization")
+	}
+	source.guard.owned = canonicalOwned
+	if err := source.observe(ctx, provided); err != nil {
+		return nil, err
+	}
+	selected, rawSelection, err := source.guard.loadWithRawPackage(ctx, source.packageQuery())
+	if err != nil {
+		return nil, err
+	}
+	source.guard.selection = selected
+	source.rawSelection = append([]byte(nil), rawSelection...)
+	source.recordCommand(rawSelection, "list", "-json", "-compiled", "-export", "-mod=readonly", source.packageQuery())
+	if selected.ImportPath != request.PackagePath || selected.Dir != request.Directory || selected.ForTest != "" || selected.nonordinaryRole() ||
+		len(selected.GoFiles) == 0 || len(selected.SFiles) == 0 || len(selected.SFiles) > 32 {
+		return nil, numericalSBContext("consumer needs complete original source selection")
+	}
+	if err := source.captureSourceRole(ctx); err != nil {
+		return nil, err
+	}
+	var reports []gostaticstorage.Report
+	variables := make(map[string]numericalSBRead)
+	mainRootBound := role == numericalSBOwnedSource && selected.Module.Dir == request.Directory
+	for ordinal, owner := range request.Owners {
+		if err := owner.Verify(ctx); err != nil {
+			return nil, err
+		}
+		report, err := owner.observation.Readback(ctx)
+		if err != nil {
+			return nil, numericalStorageFailure(ctx, "capture numerical read owner readback", err)
+		}
+		if report.Target != request.Target || report.Tools["go"] != source.toolHash(request.GoBinary) ||
+			report.Tools["compile"] != source.toolHash(filepath.Join(source.guard.env["GOTOOLDIR"], gotoolchain.HostExecutable("compile"))) {
+			return nil, numericalSBContext("owner source/tool/profile differs")
+		}
+		if report.Protocol == gostaticstorage.SDKGlobalsProtocol {
+			if role != numericalSBSDKSource || report.PackagePath != request.PackagePath || report.CommandDirectory != request.Directory ||
+				report.CommandBinary != request.GoBinary || report.Environment["CGO_ENABLED"] != provided["CGO_ENABLED"] {
+				return nil, numericalSBContext("SDK Go global owner differs from this complete original selected package/profile")
+			}
+		} else if report.Protocol != gostaticstorage.SDKCPUProtocol {
+			if role != numericalSBOwnedSource || report.CommandDirectory != selected.Module.Dir || report.PackagePath != selected.Module.Path {
+				return nil, numericalSBContext("numerical owner is not the actual same main module")
+			}
+			mainRootBound = true
+		} else if report.CommandDirectory != filepath.Join(source.guard.env["GOROOT"], "src", "internal", "cpu") {
+			return nil, numericalSBContext("SDK numerical owner is not this selected original installation")
+		}
+		for _, variable := range report.Variables {
+			if _, duplicate := variables[variable.NativeName]; duplicate {
+				return nil, numericalSBContext("duplicate numerical owner identity")
+			}
+			variables[variable.NativeName] = numericalSBRead{variable: variable, owner: owner, ownerOrdinal: ordinal}
+		}
+		reports = append(reports, report)
+	}
+	if role == numericalSBOwnedSource && !mainRootBound {
+		return nil, numericalSBContext("nested consumer lacks complete original module inventory owner")
+	}
+	// Imports cannot borrow a CPU assembly reference as a Go graph certificate.
+	// Same-main dependencies must be present in an actual owner selection/export.
+	if role == numericalSBOwnedSource {
+		if err := source.bindImports(reports); err != nil {
+			return nil, err
+		}
+	} else if err := source.verifySDKObservation(ctx); err != nil {
+		return nil, err
+	}
+	// This private observation stop has no public request flag and no ready
+	// numerical source, binding, instruction certificate or LLVM permission.
+	if inputsOnly {
+		return source, nil
+	}
+	if err := source.bindNative(ctx, variables, provided); err != nil {
+		return nil, err
+	}
+	source.report, err = json.Marshal(struct {
+		Request                      GoX86NumericalReadCaptureRequest
+		CPP                          AssemblyCPPObservation
+		File                         *File
+		Selection                    goAMD64FrameSelection
+		Inputs                       map[string][32]byte
+		Owners                       []gostaticstorage.Report
+		Native                       numericalSBNativeProof
+		RawSelection, RawEnvironment []byte
+		Commands                     []numericalSBCommand
+		Reads                        []numericalSBReadFact
+		Role                         numericalSBSourceRole
+		SDK                          *numericalSBSDKObservation
+		Literals                     *numericalSDKLiteralJoin
+		Assembly                     *numericalSDKAssemblyJoin
+	}{request, source.cpp, source.file, selected, source.guard.inputs, reports, source.native, source.rawSelection, source.rawEnvironment, source.commands, source.readFacts(), role, source.sdk, source.literals, source.assembly})
+	if err != nil {
+		return nil, err
+	}
+	source.seal, source.ready = sha256.Sum256(source.report), true
+	source.stateSeal, err = source.stateDigest()
+	if err != nil {
+		return nil, err
+	}
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func (source *GoX86NumericalReadSource) retainDirectory(directory string) error {
+	resolved, err := sourcepath.Resolve(directory)
+	info, statErr := sourcepath.Lstat(directory)
+	if !filepath.IsAbs(directory) || err != nil || resolved != directory || statErr != nil || !info.IsDir() {
+		return numericalSBContext("redirected or missing command/source root")
+	}
+	source.dirs[directory] = info
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) recordCommand(stdout []byte, arguments ...string) {
+	source.commands = append(source.commands, numericalSBCommand{source.request.Directory, source.request.GoBinary,
+		append([]string(nil), arguments...), append([]byte(nil), stdout...)})
+}
+
+func (source *GoX86NumericalReadSource) run(ctx context.Context, arguments ...string) ([]byte, error) {
+	stdout, err := source.guard.run(ctx, arguments...)
+	if err == nil {
+		source.recordCommand(stdout, arguments...)
+	}
+	return stdout, err
+}
+
+func (source *GoX86NumericalReadSource) toolHash(file string) string {
+	digest := source.guard.inputs[file]
+	return hex.EncodeToString(digest[:])
+}
+
+func (source *GoX86NumericalReadSource) observe(ctx context.Context, provided map[string]string) error {
+	if _, err := source.guard.read(source.request.GoBinary); err != nil {
+		return err
+	}
+	raw, err := source.run(ctx, "env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOOS", "GOARCH", "GOAMD64", "GO386", "GOFLAGS", "GOEXPERIMENT", "GOCACHE", "GOMODCACHE", "CGO_ENABLED")
+	if err != nil {
+		return err
+	}
+	var env map[string]string
+	if json.Unmarshal(raw, &env) != nil || !gotoolchain.AuditedGo127(env["GOVERSION"]) || env["GOOS"]+"/"+env["GOARCH"] != source.request.Target ||
+		filepath.Join(env["GOROOT"], "bin", gotoolchain.HostExecutable("go")) != source.request.GoBinary || env["GOAMD64"] != "v1" ||
+		env["GOARCH"] == "386" && env["GO386"] != "sse2" || env["GOFLAGS"] != "" || env["GOEXPERIMENT"] != "" ||
+		env["GOCACHE"] != provided["GOCACHE"] || env["GOMODCACHE"] != provided["GOMODCACHE"] {
+		return numericalSBContext("actual SDK/tool/profile differs")
+	}
+	if env["CGO_ENABLED"] != provided["CGO_ENABLED"] {
+		return numericalSBContext("actual selected SDK cgo profile differs from the original command")
+	}
+	if source.role == numericalSBOwnedSource {
+		if err := gostaticstorage.ValidateOwnedSourceDirectory(source.request.Directory, env["GOROOT"], env["GOMODCACHE"]); err != nil {
+			return numericalStorageFailure(ctx, "numerical original owned source role", err)
+		}
+	} else if err := source.verifySDKDirectory(env["GOROOT"]); err != nil {
+		return err
+	}
+	source.guard.env = env
+	source.rawEnvironment = append([]byte(nil), raw...)
+	for _, directory := range []string{env["GOROOT"], env["GOTOOLDIR"], filepath.Join(env["GOROOT"], "pkg", "include")} {
+		resolved, err := sourcepath.Resolve(directory)
+		info, statErr := sourcepath.Lstat(directory)
+		if err != nil || resolved != directory || statErr != nil || !info.IsDir() {
+			return numericalSBContext("SDK directory role is missing or redirected")
+		}
+		source.dirs[directory] = info
+	}
+	for _, tool := range []string{"asm", "compile"} {
+		route, err := source.run(ctx, "tool", "-n", tool)
+		if err != nil {
+			return err
+		}
+		if strings.TrimSpace(string(route)) != filepath.Join(env["GOTOOLDIR"], gotoolchain.HostExecutable(tool)) {
+			return numericalSBContext("unknown actual %s route", tool)
+		}
+		if _, err := source.guard.read(strings.TrimSpace(string(route))); err != nil {
+			return err
+		}
+	}
+	for _, role := range []string{"VERSION", "src/cmd/internal/goobj/builtinlist.go", "src/cmd/internal/obj/x86/asm6.go", "src/cmd/internal/obj/x86/obj6.go",
+		"src/cmd/go/internal/work/gc.go", "src/cmd/go/internal/load/pkg.go", "src/cmd/asm/main.go", "src/cmd/asm/internal/lex/input.go", "src/cmd/asm/internal/lex/stack.go", "src/cmd/asm/internal/lex/tokenizer.go"} {
+		if _, err := source.guard.read(filepath.Join(env["GOROOT"], filepath.FromSlash(role))); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) bindImports(reports []gostaticstorage.Report) error {
+	selected := source.guard.selection
+	for _, path := range selected.Imports {
+		if path == "unsafe" {
+			continue
+		}
+		mapped := path
+		if selected.ImportMap[path] != "" {
+			mapped = selected.ImportMap[path]
+		}
+		found := false
+		for _, report := range reports {
+			if report.Protocol == gostaticstorage.SDKCPUProtocol {
+				continue
+			}
+			decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+			for decoder.More() {
+				var pkg gostaticstorage.Package
+				if decoder.Decode(&pkg) != nil {
+					return numericalSBContext("invalid live owner selection")
+				}
+				found = found || pkg.ImportPath == mapped && pkg.Module != nil && pkg.Module.Main && pkg.Module.Dir == selected.Module.Dir
+			}
+		}
+		if !found || mapped != path {
+			return numericalSBContext("unbound consumer import/namespace role")
+		}
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) preprocess() error {
+	if source.sdkAssemblyJoin() != nil {
+		return source.preprocessSDKAssembly()
+	}
+	guard := source.guard
+	original, err := guard.read(filepath.Join(source.request.Directory, source.request.AssemblyFile))
+	if err != nil {
+		return err
+	}
+	source.cpp, err = ObserveAssemblyCPP(string(original), AssemblyPreprocessOptions{FileName: filepath.Join(source.request.Directory, source.request.AssemblyFile),
+		Defines: GoAssemblerDefinesWithEnv(guard.env["GOOS"], guard.env["GOARCH"], guard.env),
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if filepath.Base(name) != name || name == "go_asm.h" {
+				return "", nil, numericalSBContext("generated/relative header needs separate actual compiler agreement")
+			}
+			candidate := filepath.Join(source.request.Directory, name)
+			_, statErr := os.Lstat(candidate)
+			if os.IsNotExist(statErr) {
+				source.misses[candidate] = true
+				candidate = filepath.Join(guard.env["GOROOT"], "pkg", "include", name)
+			} else if statErr != nil {
+				return "", nil, statErr
+			}
+			data, err := guard.read(candidate)
+			return candidate, data, err
+		}})
+	if err != nil {
+		return err
+	}
+	source.file, err = Parse(ArchAMD64, source.cpp.Output)
+	if err != nil || len(source.file.Funcs) == 0 || len(source.file.Data) != 0 || len(source.file.Globl) != 0 || len(source.file.UnlinkedPrelude) != 0 {
+		return numericalSBContext("source is not a bounded TEXT-only program: %v", err)
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) Verify(ctx context.Context) error {
+	if source != nil && source.revoked.Load() {
+		return numericalSBContext("read source publication is permanently revoked")
+	}
+	var result error
+	if source != nil && source.literals != nil {
+		result = source.verifySDKLiteralNumericalSource(ctx)
+	} else if source != nil && source.assembly != nil {
+		result = source.verifySDKAssemblyNumericalSource(ctx)
+	} else {
+		result = source.verifyNumericalSource(ctx)
+	}
+	// SDK verification also samples the original caller context in its final
+	// defer. Revoke is lock-free and changes no ready/owner generation, so
+	// authenticate its publication token after every such callback has returned.
+	if source != nil && source.revoked.Load() {
+		result = errors.Join(result, numericalSBContext("read source publication revoked during verification"))
+	}
+	return result
+}
+
+func (source *GoX86NumericalReadSource) verifyNumericalSource(ctx context.Context) error {
+	if source == nil {
+		return numericalSBContext("missing live read source")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready || source.identity != source || source.revoked.Load() {
+		source.ready = false
+		return numericalSBContext("read source is closed/revoked")
+	}
+	fail := func(err error) error { source.ready = false; return err }
+	// Any failed live Verify permanently revokes this source, including an
+	// invalid caller context. A fresh context cannot revive a failed lease.
+	if ctx != nil && ctx.Err() != nil {
+		return fail(fmt.Errorf("verify numerical read source: %w", ctx.Err()))
+	}
+	if ctx == nil {
+		return fail(numericalSBContext("live verification requires an unexpired context"))
+	}
+	if len(source.request.Owners) != len(source.originalOwners) {
+		return fail(numericalSBContext("sealed owner identity/order changed"))
+	}
+	for ordinal, owner := range source.request.Owners {
+		if owner != source.originalOwners[ordinal] {
+			return fail(numericalSBContext("sealed owner identity/order changed"))
+		}
+	}
+	if sha256.Sum256(source.report) != source.seal {
+		return fail(numericalSBContext("sealed read report changed"))
+	}
+	state, err := source.stateDigest()
+	if err != nil || state != source.stateSeal {
+		return fail(numericalSBContext("sealed source/native/read join changed"))
+	}
+	for directory, before := range source.dirs {
+		resolved, err := sourcepath.Resolve(directory)
+		now, statErr := os.Lstat(directory)
+		if err != nil || resolved != directory || statErr != nil || !now.IsDir() || !os.SameFile(before, now) {
+			return fail(numericalSBContext("source/cache/temp directory role changed"))
+		}
+	}
+	for name := range source.misses {
+		if _, err := os.Lstat(name); !os.IsNotExist(err) {
+			return fail(numericalSBContext("CPP preferred-search miss changed"))
+		}
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return fail(err)
+	}
+	if source.sdkAssemblyJoin() == nil {
+		for _, owner := range source.request.Owners {
+			if err := owner.Verify(ctx); err != nil {
+				return fail(err)
+			}
+		}
+	}
+	for _, read := range source.reads {
+		if read.ownerOrdinal < 0 || read.ownerOrdinal >= len(source.originalOwners) || read.owner != source.originalOwners[read.ownerOrdinal] {
+			return fail(numericalSBContext("joined read owner identity changed"))
+		}
+	}
+	if source.role == numericalSBSDKSource {
+		if err := source.verifySDKObservation(ctx); err != nil {
+			return fail(err)
+		}
+	} else {
+		selected, raw, err := source.guard.loadWithRawPackage(ctx, source.packageQuery())
+		if err != nil {
+			return fail(err)
+		}
+		if !reflect.DeepEqual(selected, source.guard.selection) || !numericalSameRawSelection(source.rawSelection, raw) {
+			return fail(numericalSBContext("actual consumer selection/export changed"))
+		}
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return fail(err)
+	}
+	return nil
+}
+
+func (source *GoX86NumericalReadSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	source.ready = false
+	if source.guard == nil {
+		return nil
+	}
+	if source.identity != source {
+		return numericalSBContext("copied numerical source cannot close the original artifact owner")
+	}
+	if source.sdk != nil {
+		source.sdk.closed = true
+	}
+	return source.guard.Close()
+}
+
+// Readback returns retained portable whole bytes for inspection only. Neither
+// this JSON nor any edited/copy report can reconstruct a source or Options.
+func (source *GoX86NumericalReadSource) Readback(ctx context.Context) ([]byte, error) {
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready || source.revoked.Load() {
+		return nil, numericalSBContext("read source closed after verification")
+	}
+	return append([]byte(nil), source.report...), nil
+}
+
+// CheckReadback compares complete retained bytes with the live factory seal.
+// This is not a constructor or a permission derived from self-consistent JSON.
+func (source *GoX86NumericalReadSource) CheckReadback(ctx context.Context, raw []byte) error {
+	if err := source.Verify(ctx); err != nil {
+		return err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready || source.revoked.Load() || sha256.Sum256(raw) != source.seal {
+		return numericalSBContext("readback differs from actual sealed source/object/owner outputs")
+	}
+	return nil
+}
+
+type numericalSBReadFact struct {
+	Function             string
+	Instruction, Operand int
+	Owner                int // portable ordinal; private exact identity/order is checked separately
+	Original             Instr
+	PC, Offset, Width    int64
+	Code                 []byte
+	Relocation           gostaticstorage.TextRelocation
+	Variable             gostaticstorage.Variable
+}
+
+func (source *GoX86NumericalReadSource) readFacts() []numericalSBReadFact {
+	facts := make([]numericalSBReadFact, 0, len(source.reads))
+	for _, read := range source.reads {
+		facts = append(facts, numericalSBReadFact{read.function, read.instruction, read.operand, read.ownerOrdinal, read.original, read.pc, read.offset, read.width, read.code, read.relocation, read.variable})
+	}
+	return facts
+}
+
+func (source *GoX86NumericalReadSource) stateDigest() ([32]byte, error) {
+	raw, err := json.Marshal(struct {
+		Request                      GoX86NumericalReadCaptureRequest
+		CPP                          AssemblyCPPObservation
+		File                         *File
+		Native                       numericalSBNativeProof
+		Selection                    goAMD64FrameSelection
+		Inputs                       map[string][32]byte
+		Reads                        []numericalSBReadFact
+		RawSelection, RawEnvironment []byte
+		Commands                     []numericalSBCommand
+		Role                         numericalSBSourceRole
+		SDK                          *numericalSBSDKObservation
+		Literals                     *numericalSDKLiteralJoin
+		Assembly                     *numericalSDKAssemblyJoin
+	}{source.request, source.cpp, source.file, source.native, source.guard.selection, source.guard.inputs, source.readFacts(), source.rawSelection, source.rawEnvironment, source.commands, source.role, source.sdk, source.literals, source.assembly})
+	return sha256.Sum256(raw), err
+}
+
+// As in the numerical owner's selection reader, SDK load/pkg.go reports
+// Stale/StaleReason before list -export builds the archive. The sealed factory
+// retains that SDK source and both whole stdout roles; only these official
+// bool/string display fields may differ on a repeated actual command.
+func numericalSameRawSelection(first, second []byte) bool {
+	decode := func(raw []byte) (map[string]json.RawMessage, bool) {
+		var value map[string]json.RawMessage
+		if len(raw) > 4<<20 || json.Unmarshal(raw, &value) != nil || value == nil {
+			return nil, false
+		}
+		for key, data := range value {
+			if key == "Stale" {
+				var display bool
+				if string(data) == "null" || json.Unmarshal(data, &display) != nil {
+					return nil, false
+				}
+				delete(value, key)
+			} else if key == "StaleReason" {
+				var display string
+				if string(data) == "null" || json.Unmarshal(data, &display) != nil {
+					return nil, false
+				}
+				delete(value, key)
+			} else {
+				var compact bytes.Buffer
+				if json.Compact(&compact, data) != nil {
+					return nil, false
+				}
+				value[key] = compact.Bytes()
+			}
+		}
+		return value, true
+	}
+	a, validA := decode(first)
+	b, validB := decode(second)
+	return validA && validB && reflect.DeepEqual(a, b)
+}
diff --git a/go_x86_numerical_read_tail.go b/go_x86_numerical_read_tail.go
new file mode 100644
index 000000000..ecd21f2e4
--- /dev/null
+++ b/go_x86_numerical_read_tail.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Pure source-role audit only. Actual typed root state is checked by the
+// continuation consumer after exact original-node numerical certificates join.
+func numericalDirectTailRoles(file *File) (map[x86DirectTailPoint]string, error) {
+	roles := make(map[x86DirectTailPoint]string)
+	if !x86DirectTailSourceNeeded(file) {
+		return roles, nil
+	}
+	helpers := make(map[string]bool)
+	names := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		if names[fn.Sym] {
+			return nil, numericalSBContext("continuation repeats an original TEXT identity")
+		}
+		names[fn.Sym] = true
+		if strings.HasSuffix(fn.Sym, "<>") {
+			helpers[fn.Sym] = true
+		}
+	}
+	graph := &x86DirectTailGraph{original: file, helpers: helpers}
+	if err := graph.auditReferences(); err != nil {
+		return nil, err
+	}
+	for text, fn := range file.Funcs {
+		for ordinal, ins := range fn.Instrs {
+			if ins.Op != OpJMP && ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			if ins.Op == OpCALL && !helpers[name] {
+				continue // Ordinary external calls retain their separate declaration/ABI owner.
+			}
+			if !valid || offset != 0 || strings.ContainsAny(name, "<>") && !helpers[name] {
+				return nil, numericalSBContext("continuation has an unknown/offset/selector terminal")
+			}
+			if strings.HasSuffix(name, "<>") && !names[name] {
+				return nil, numericalSBContext("continuation target lacks its complete original TEXT")
+			}
+			roles[x86DirectTailPoint{text, ordinal}] = name
+		}
+	}
+	return roles, nil
+}
+
+func numericalTypedSourceEntries(file *File, pkg, arch string, role numericalSBSourceRole) (map[string]bool, map[string]bool, error) {
+	observed, ordinary, err := numericalTypedSourceDeclarations(file, pkg, arch, role, numericalGoLinknames{}, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	entries, terminals := make(map[string]bool), make(map[string]bool)
+	for _, declaration := range observed {
+		entries[declaration.local] = true
+	}
+	for _, declaration := range ordinary {
+		terminals[declaration.local] = true
+	}
+	return entries, terminals, nil
+}
+
+// Ordinary terminal callees may have an actual Go body. They remain separate
+// declarations, not private continuations. Independently re-typecheck every
+// original selected Go file/import and compare both complete language roles
+// before deriving its ABI0 layout; a supplied root signature grants nothing.
+func (source *GoX86NumericalReadSource) numericalSDKOrdinaryTailDeclarations(ctx context.Context, pkg GoPackage, arch string,
+	terminals map[string]numericalSourceDeclaration,
+) (map[string]goAMD64FrameDeclaration, error) {
+	result := make(map[string]goAMD64FrameDeclaration)
+	if len(terminals) == 0 {
+		return result, nil
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	bodyless := make(map[string]bool)
+	for _, name := range source.guard.selection.GoFiles {
+		filename := filepath.Join(source.request.Directory, name)
+		data, err := source.guard.read(filename)
+		if err != nil {
+			return nil, err
+		}
+		file, err := parser.ParseFile(fset, filename, data, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		syntax = append(syntax, file)
+		for _, declaration := range file.Decls {
+			if fn, valid := declaration.(*ast.FuncDecl); valid && fn.Recv == nil && fn.Body == nil {
+				bodyless[fn.Name.Name] = true
+			}
+		}
+	}
+	imports := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if mapped, found := source.guard.selection.ImportMap[path]; found {
+			path = mapped
+		}
+		selected, found := source.guard.imports[path]
+		if !found || selected.Export == "" {
+			return nil, numericalSBContext("ordinary terminal lacks its actual compiler import")
+		}
+		data, err := source.guard.read(selected.Export)
+		return io.NopCloser(bytes.NewReader(data)), err
+	})
+	sizes := types.SizesFor("gc", arch)
+	typed, err := (&types.Config{Sizes: sizes, Importer: imports}).Check(pkg.Path, fset, syntax, nil)
+	if err != nil || !reflect.DeepEqual(typed.Scope().Names(), pkg.Types.Scope().Names()) {
+		return nil, numericalSBContext("ordinary terminal complete Go declaration graph differs: %v", err)
+	}
+	names, err := numericalGoDeclarationLinknames(syntax, typed)
+	if err != nil {
+		return nil, err
+	}
+	observed, _, err := numericalTypedSourceDeclarations(source.file, pkg.Path, arch, source.role, names, source.native.CompilerAliases)
+	if err != nil {
+		return nil, err
+	}
+	for name, declaration := range terminals {
+		if original, found := observed[name]; !found || original != declaration {
+			return nil, numericalSBContext("original declaration/compiler/native association differs")
+		}
+	}
+	for name, declaration := range terminals {
+		local := declaration.local
+		actual, found := typed.Scope().Lookup(local).(*types.Func)
+		provided, supplied := pkg.Types.Scope().Lookup(local).(*types.Func)
+		if !found || !supplied || actual.Pkg() != typed || provided.Pkg() != pkg.Types {
+			return nil, numericalSBContext("ordinary terminal lacks an actual source declaration")
+		}
+		// A selected source TEXT remains bodyless; only an actual ordinary
+		// external terminal may have a Go body. Helpers never enter this set.
+		if declaration.entry && !bodyless[local] {
+			return nil, numericalSBContext("source TEXT lacks its actual bodyless entry declaration")
+		}
+		arguments := arch == "amd64" && declaration.entry && declaration.abi == 1 &&
+			reflect.DeepEqual(source.native.ArgumentRules, amd64GoArgumentCompilerSchema)
+		first, err := numericalSDKDeclarationLanguage(actual, sizes, arguments)
+		second, priorErr := numericalSDKDeclarationLanguage(provided, sizes, arguments)
+		if err != nil || priorErr != nil || first != second {
+			return nil, numericalSBContext("ordinary terminal original complete language graph differs")
+		}
+		if arguments {
+			for _, function := range []*types.Func{actual, provided} {
+				plan, err := planAMD64GoArguments(function.Type().(*types.Signature))
+				if err != nil || plan.requireRegisters() != nil {
+					return nil, amd64GoArgumentContext("typed source declaration has unsupported register/stack grouping")
+				}
+			}
+		}
+		sig, abiErr := DeriveGoFuncABI0Signature(name, actual, arch, sizes)
+		prior, priorABIError := DeriveGoFuncABI0Signature(name, provided, arch, sizes)
+		if abiErr != nil || priorABIError != nil || !reflect.DeepEqual(sig, prior) {
+			return nil, numericalSBContext("ordinary terminal original language/ABI0 layout differs")
+		}
+		result[name] = goAMD64FrameDeclaration{signature: sig, transport: goAMD64FrameCompositeTransport, languageType: first}
+	}
+	return result, ctx.Err()
+}
+
+// This is the existing issuer's bounded language comparison, not a source,
+// compiler, entry, frame or result-transport certificate.
+func numericalSDKDeclarationLanguage(fn *types.Func, sizes types.Sizes, arguments bool) (string, error) {
+	sig, valid := fn.Type().(*types.Signature)
+	if !valid || sig.Recv() != nil || sig.Variadic() || sig.TypeParams().Len() != 0 {
+		return "", numericalSBContext("ordinary terminal is not a monomorphic direct function")
+	}
+	var value strings.Builder
+	resultBuilder := amd64GoArgumentBuilder{sizes: sizes}
+	for role, tuple := range []*types.Tuple{sig.Params(), sig.Results()} {
+		if tuple.Len() > 4096 {
+			return "", numericalSBContext("ordinary terminal tuple bound exceeded")
+		}
+		value.WriteString("[")
+		for index := 0; index < tuple.Len(); index++ {
+			var leaf string
+			var err error
+			if arguments && role == 0 {
+				leaf, err = goAMD64LanguageTypeRole(tuple.At(index).Type(), sizes, true, true)
+			} else {
+				if arguments {
+					// The old string adapter samples Underlying. First reject
+					// non-source nodes and unresolved alias RHSs without invoking
+					// caller callbacks; this layout grants no result transport.
+					if _, err := resultBuilder.shape(tuple.At(index).Type(), 0); err != nil {
+						return "", err
+					}
+				}
+				// Argument carriers do not extend the old result-language
+				// role. Their single integer/I1 result transport is checked
+				// independently when the real entry binding is issued.
+				leaf, err = numericalTailLanguageType(tuple.At(index).Type(), sizes)
+			}
+			if err != nil {
+				return "", err
+			}
+			value.WriteString(leaf + ";")
+			if value.Len() > 64<<10 {
+				return "", numericalSBContext("ordinary terminal language bound exceeded")
+			}
+		}
+		value.WriteString("]")
+	}
+	return value.String(), nil
+}
+
+// The existing Go signature builder transports string as an opaque data
+// identity plus numerical length. This source-only comparison does not widen
+// the generic frame/native observer or grant pointee/extent/pointer-bit facts.
+func numericalTailLanguageType(typ types.Type, sizes types.Sizes) (string, error) {
+	if basic, valid := typ.Underlying().(*types.Basic); valid && basic.Kind() == types.String {
+		return "string:" + types.TypeString(typ, func(pkg *types.Package) string { return pkg.Path() }), nil
+	}
+	return goAMD64FrameLanguageTypeRole(typ, sizes, true)
+}
+
+func (source *GoX86NumericalReadSource) numericalSourceTextIdentity(ordinal int, fn Func, arch string) (string, uint16, bool) {
+	if !strings.HasSuffix(fn.Sym, "<>") {
+		return numericalFunctionSourceIdentity(fn.Sym, source.request.PackagePath, arch, source.role)
+	}
+	joined := source.sdkAssemblyJoin()
+	if joined == nil || source.role != numericalSBSDKSource || !x86DirectTailSourceNeeded(source.file) ||
+		joined.Observation.Objects == nil || joined.SourceOrdinal < 0 || joined.SourceOrdinal >= len(joined.Observation.Objects.Sources) {
+		return "", 0, false
+	}
+	observed := joined.Observation.Objects.Sources[joined.SourceOrdinal]
+	if ordinal < 0 || ordinal >= len(observed.TextOrder) || len(observed.TextOrder) != len(source.file.Funcs) {
+		return "", 0, false
+	}
+	association := observed.TextOrder[ordinal]
+	if association.SourceOrdinal != ordinal || association.Namespace != gostaticstorage.TextSymbolSelf || association.ABI != 65535 ||
+		association.ObjectOrdinal < 0 || association.ObjectOrdinal >= len(observed.Original.Texts) {
+		return "", 0, false
+	}
+	record := observed.Original.Texts[association.ObjectOrdinal]
+	name := numericalNativeName(strings.TrimSuffix(fn.Sym, "<>"), source.request.PackagePath)
+	if association.Name != name || record.Name != association.Name || record.ABI != association.ABI || record.Namespace != association.Namespace ||
+		record.Relative != association.Relative || record.Index != association.Index ||
+		!reflect.DeepEqual(record, observed.Expanded.Texts[association.ObjectOrdinal]) {
+		return "", 0, false
+	}
+	return name, record.ABI, true
+}
diff --git a/go_x86_numerical_read_tail_model_test.go b/go_x86_numerical_read_tail_model_test.go
new file mode 100644
index 000000000..0ec195348
--- /dev/null
+++ b/go_x86_numerical_read_tail_model_test.go
@@ -0,0 +1,166 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoX86NumericalDirectTailTypedInventoryKeepsHelperSeparate(t *testing.T) {
+	const source = "TEXT ·entry(SB),4,$0-0\nJMP helper<>(SB)\nTEXT helper<>(SB),4,$0\nJMP ·ordinary(SB)\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		entries, terminals, err := numericalTypedSourceEntries(file, "example", arch, numericalSBSDKSource)
+		if err != nil || !reflect.DeepEqual(entries, map[string]bool{"entry": true, "ordinary": true}) ||
+			!reflect.DeepEqual(terminals, map[string]bool{"ordinary": true}) {
+			t.Fatal("helper became a declared entry or ordinary terminal lost its own role", arch, entries, terminals, err)
+		}
+		for _, changed := range []string{
+			strings.Replace(source, "JMP helper<>(SB)", "JMP missing<>(SB)", 1),
+			strings.Replace(source, "JMP helper<>(SB)", "JMP helper<>+1(SB)", 1),
+			strings.Replace(source, "JMP ·ordinary(SB)", "JMP ·ordinary+1(SB)", 1),
+			strings.Replace(source, "JMP ·ordinary(SB)", "CALL helper<>+1(SB)\nRET", 1),
+			strings.Replace(source, "JMP ·ordinary(SB)", "MOVQ $helper<>(SB),AX\nRET", 1),
+			source + "TEXT helper<>(SB),4,$0\nRET\n",
+			source + "DATA escape<>+0(SB)/8,$helper<>(SB)\nGLOBL escape<>(SB),8,$8\n",
+		} {
+			parsed, err := Parse(ArchAMD64, changed)
+			if err != nil {
+				t.Fatal("independent whole-source role fixture", err)
+			}
+			if entries, terminals, err := numericalTypedSourceEntries(parsed, "example", arch, numericalSBSDKSource); entries != nil || terminals != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown/escaped/duplicate original helper acquired a source entry", arch, changed, entries, terminals, err)
+			}
+		}
+	}
+}
+
+func TestGoX86NumericalPrivateCallSourceRolesRemainObservationOnly(t *testing.T) {
+	// Retain the earlier self-CALL source: its original control relocation can
+	// now be associated, but neither a helper declaration nor a recursive
+	// continuation is thereby authorized.
+	const source = "TEXT ·entry(SB),4,$0-0\nJMP helper<>(SB)\nTEXT helper<>(SB),4,$0\nCALL helper<>(SB)\nRET\n"
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			entries, terminals, err := numericalTypedSourceEntries(file, "example", arch, numericalSBSDKSource)
+			if err != nil || !reflect.DeepEqual(entries, map[string]bool{"entry": true}) || len(terminals) != 0 {
+				t.Fatal("CALL source association invented a private helper declaration", entries, terminals, err)
+			}
+			roles, err := numericalDirectTailRoles(file)
+			if err != nil || len(roles) != 2 || roles[x86DirectTailPoint{1, 1}] != "helper<>" {
+				t.Fatal("CALL did not retain its actual original TEXT/ordinal association", roles, err)
+			}
+			resolve := testResolveSym("example")
+			pkg := mustGoPackage(t, "example", "package p\nfunc entry()")
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if prepared, err := PrepareX86DirectTailSource(file, Options{Goarch: arch, ResolveSym: resolve, Sigs: sigs}); prepared != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "recursive") {
+				t.Fatal("observed private CALL supplied recursive execution authority", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalDirectTailStaticTupleMatchesOriginalNode(t *testing.T) {
+	// This is only an independent association model, never a live source token.
+	for _, arch := range []string{"386", "amd64"} {
+		makeSource := func() *GoX86NumericalReadSource {
+			program, observed := numericalNativeOrderFixture(t)
+			program = strings.Replace(program, "RET", "JMP helper<>(SB)", 1)
+			file, err := Parse(ArchAMD64, program)
+			if err != nil {
+				t.Fatal(err)
+			}
+			return &GoX86NumericalReadSource{file: file, role: numericalSBSDKSource,
+				request: GoX86NumericalReadCaptureRequest{PackagePath: "example"},
+				assembly: &numericalSDKAssemblyJoin{Observation: sdkASMDataLiveObservation{
+					Objects: &gostaticstorage.SDKASMDataObservation{Sources: []gostaticstorage.ASMDataSourceObservation{observed}}}}}
+		}
+		original := makeSource()
+		if name, abi, valid := original.numericalSourceTextIdentity(2, original.file.Funcs[2], arch); !valid || name != "helper" || abi != 65535 {
+			t.Fatal("exact original source ordinal lost its physical static tuple", arch, name, abi, valid)
+		}
+		for name, mutate := range map[string]func(*GoX86NumericalReadSource){
+			"ordinary role": func(s *GoX86NumericalReadSource) { s.role = numericalSBOwnedSource },
+			"no metadata":   func(s *GoX86NumericalReadSource) { s.assembly = nil },
+			"no tail":       func(s *GoX86NumericalReadSource) { s.file.Funcs[0].Instrs = s.file.Funcs[0].Instrs[:1] },
+			"source ordinal": func(s *GoX86NumericalReadSource) {
+				s.assembly.Observation.Objects.Sources[0].TextOrder[2].SourceOrdinal--
+			},
+			"object ordinal": func(s *GoX86NumericalReadSource) {
+				s.assembly.Observation.Objects.Sources[0].TextOrder[2].ObjectOrdinal++
+			},
+			"source name": func(s *GoX86NumericalReadSource) {
+				s.assembly.Observation.Objects.Sources[0].TextOrder[2].Name = "other"
+			},
+			"source ABI": func(s *GoX86NumericalReadSource) { s.assembly.Observation.Objects.Sources[0].TextOrder[2].ABI = 0 },
+			"source bank": func(s *GoX86NumericalReadSource) {
+				s.assembly.Observation.Objects.Sources[0].TextOrder[2].Namespace = gostaticstorage.TextSymbolNonpkgDefinition
+			},
+			"relative index": func(s *GoX86NumericalReadSource) { s.assembly.Observation.Objects.Sources[0].TextOrder[2].Relative++ },
+			"physical index": func(s *GoX86NumericalReadSource) { s.assembly.Observation.Objects.Sources[0].TextOrder[2].Index++ },
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				changed := makeSource()
+				mutate(changed)
+				if name, abi, valid := changed.numericalSourceTextIdentity(2, changed.file.Funcs[2], arch); valid {
+					t.Fatal("changed original static tuple retained an instruction association", name, abi)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86NumericalTailStringLanguageKeepsActualABI0Identity(t *testing.T) {
+	pkg := mustGoPackage(t, "example.invalid/stringrole", `package stringrole
+type Named string
+type Other string
+type Fake struct { Data *byte; Length int }
+func String(x string) uintptr
+func NamedString(x Named) uintptr
+func OtherString(x Other) uintptr
+func Slice(x []byte) uintptr
+func Struct(x Fake) uintptr
+`)
+	for _, arch := range []string{"386", "amd64"} {
+		sizes := types.SizesFor("gc", arch)
+		word, numerical := int64(8), I64
+		if arch == "386" {
+			word, numerical = 4, I32
+		}
+		identities := make(map[string]string)
+		for _, name := range []string{"String", "NamedString", "OtherString", "Slice", "Struct"} {
+			fn := pkg.Types.Scope().Lookup(name).(*types.Func)
+			typ := fn.Type().(*types.Signature).Params().At(0).Type()
+			identity, err := numericalTailLanguageType(typ, sizes)
+			if err != nil || identities[identity] != "" {
+				t.Fatal("same-sized string/named/slice/struct language identities were conflated", arch, name, identity, err)
+			}
+			identities[identity] = name
+			if !strings.Contains(name, "String") {
+				continue
+			}
+			if _, err := goAMD64FrameLanguageTypeRole(typ, sizes, true); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("source-only string role widened generic frame observation", err)
+			}
+			sig, err := DeriveGoFuncABI0Signature(name, fn, arch, sizes)
+			if err != nil || len(sig.Frame.Params) != 2 || sig.Frame.Params[0].Type != Ptr ||
+				sig.Frame.Params[0].Offset != 0 || sig.Frame.Params[1].Type != numerical || sig.Frame.Params[1].Offset != word {
+				t.Fatal("actual string transport lost separate opaque data and numerical length", arch, name, sig, err)
+			}
+		}
+	}
+}
diff --git a/go_x86_numerical_read_tail_test.go b/go_x86_numerical_read_tail_test.go
new file mode 100644
index 000000000..88c8bcdc0
--- /dev/null
+++ b/go_x86_numerical_read_tail_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoX86NumericalDirectTailStaticListingOriginalGo(t *testing.T) {
+	// The owned assembler already supplies -p oracle. Historical Go listing
+	// formatting leaves a leading-middle-dot symbol's package blank despite
+	// that flag; explicit source qualification retains one exact identity on
+	// both tools without guessing or rewriting their native listing names.
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			listing := x86InsertExtractGoListing(t, arch, "TEXT oracle·entry(SB),4,$0-0\nJMP worker<>(SB)\nTEXT worker<>(SB),4,$0\nCMPB feature+7(SB),$1\nRET\n")
+			rows, err := numericalListingRows(listing)
+			if err != nil || len(rows) != 2 || len(rows["worker"]) != 2 || len(rows["oracle.entry"]) != 1 {
+				for _, line := range bytes.Split(listing, []byte("\n")) {
+					if bytes.Contains(line, []byte("STEXT")) {
+						t.Log(string(line))
+					}
+				}
+				t.Fatal("static source body was assigned to another TEXT listing", err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalDirectTailSplitStaticListingOriginalGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			// A large ordinary static frame cannot be silently converted to a
+			// small leaf's automatic nosplit role by the assembler.
+			listing := x86InsertExtractGoListing(t, arch, "TEXT worker<>(SB),0,$1024-0\nRET\n")
+			headers := 0
+			for _, line := range strings.Split(string(listing), "\n") {
+				fields := strings.Fields(line)
+				if len(fields) < 2 || fields[0] != "worker" || fields[1] != "STEXT" {
+					continue
+				}
+				static := false
+				for _, field := range fields[2:] {
+					if field == "nosplit" {
+						t.Fatal("actual large-frame prior unexpectedly has nosplit", line)
+					}
+					static = static || field == "static"
+				}
+				if !static {
+					t.Fatal("actual static function lost its independent listing attribute", line)
+				}
+				headers++
+				t.Log("actual split static producer: " + line)
+			}
+			if headers != 1 || !strings.Contains(string(listing), "runtime.morestack") {
+				t.Fatal("actual Go did not emit one complete split static function", headers, string(listing))
+			}
+			// Only after the actual Go header and stack-split priors pass does
+			// the consumer observe the unchanged original listing.
+			rows, err := numericalListingRows(listing)
+			if err != nil || len(rows) != 1 || len(rows["worker"]) < 2 {
+				t.Fatal("valid split static listing lost its native PC owner", rows, err)
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalDirectTailListingUnknownHeadersFailClosed(t *testing.T) {
+	const header = "example.entry STEXT nosplit asm size=1 args=0x0 locals=0x0 funcid=0x0 align=0x0\n"
+	const row = "\t0x0000 00000 (source.s:4)\tRET\n"
+	for _, bad := range []string{
+		"worker STEXT mystery nosplit size=1 args=0x0 locals=0x0",
+		"worker STEXT static asm asm size=1 args=0x0 locals=0x0",
+		"worker STEXT nosplit size=x args=0x0 locals=0x0",
+		"worker STEXT nosplit size=1 args=0x0",
+		"worker STEXT STEXT nosplit size=1 args=0x0 locals=0x0",
+		"STEXT static nosplit size=1 args=0x0 locals=0x0",
+	} {
+		t.Run(strings.Fields(bad)[0]+"/"+bad, func(t *testing.T) {
+			rows, err := numericalListingRows([]byte(header + row + bad + "\n" + row))
+			if rows != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown header attributed instructions to the preceding TEXT", rows, err)
+			}
+		})
+	}
+	for _, raw := range []string{row, header + row + header + row} {
+		if rows, err := numericalListingRows([]byte(raw)); rows != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unbound or ambiguous native instruction ownership was accepted", rows, err)
+		}
+	}
+}
diff --git a/go_x86_numerical_read_target.go b/go_x86_numerical_read_target.go
new file mode 100644
index 000000000..87a5ec43c
--- /dev/null
+++ b/go_x86_numerical_read_target.go
@@ -0,0 +1,19 @@
+package plan9asm
+
+// These exact triples join the selected SDK source profile to the translator.
+// A target spelling alone never creates a numerical source or native ABI lease.
+func numericalSDKTargetTriple(target string) string {
+	switch target {
+	case "linux/386":
+		return "i386-unknown-linux-gnu"
+	case "linux/amd64":
+		return "x86_64-unknown-linux-gnu"
+	case "darwin/amd64":
+		return "x86_64-apple-macosx"
+	case "windows/386":
+		return "i686-pc-windows-msvc"
+	case "windows/amd64":
+		return "x86_64-pc-windows-msvc"
+	}
+	return ""
+}
diff --git a/go_x86_numerical_read_test.go b/go_x86_numerical_read_test.go
new file mode 100644
index 000000000..505072a4d
--- /dev/null
+++ b/go_x86_numerical_read_test.go
@@ -0,0 +1,288 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func numericalSBFixture(t testing.TB, arch string) (GoPackage, GoAMD64FrameCaptureRequest, *File, Options) {
+	t.Helper()
+	dir, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goSource := []byte("package numericalfixture\nfunc Feature() byte\n")
+	assembly := `#include "textflag.h"
+TEXT ·Feature(SB),NOSPLIT,$0-1
+MOVL $0,AX
+CMPB internal∕cpu·X86+64(SB),$1
+SETEQ AL
+PINSRD $0,AX,X0
+PEXTRD $0,X0,AX
+MOVB AL,ret+0(FP)
+RET
+`
+	for name, data := range map[string][]byte{
+		"go.mod":               []byte("module example.invalid/numericalfixture\ngo 1.27\n"),
+		"value.go":             goSource,
+		"value_" + arch + ".s": []byte(assembly),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filepath.Join(dir, "value.go"), goSource, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch)}).Check("example.invalid/numericalfixture", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := make(map[string]string)
+	for _, pair := range os.Environ() {
+		key, value, _ := strings.Cut(pair, "=")
+		env[key] = value
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(env[key]) {
+			env[key] = t.TempDir()
+		}
+		env[key], err = filepath.EvalSymlinks(env[key])
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	for key, value := range map[string]string{
+		"GOOS": "linux", "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2",
+		"GOFLAGS": "", "GOEXPERIMENT": "", "GOTOOLCHAIN": "local", "GOENV": "off",
+		"GOWORK": "off", "CGO_ENABLED": "0", "GOPROXY": "off",
+	} {
+		env[key] = value
+	}
+	var environment []string
+	for key, value := range env {
+		environment = append(environment, key+"="+value)
+	}
+	request := GoAMD64FrameCaptureRequest{GoBinary: binary, Directory: dir, AssemblyFile: "value_" + arch + ".s", Target: "linux/" + arch, Environment: environment}
+	file, err := Parse(ArchAMD64, strings.Replace(assembly, "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration := typed.Scope().Lookup("Feature").(*types.Func)
+	sig, err := DeriveGoFuncABI0Signature(typed.Path()+".Feature", declaration, arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	opt := Options{Goarch: arch, TargetTriple: triple, ResolveSym: func(sym string) string {
+		if strings.HasPrefix(sym, "·") {
+			return typed.Path() + "." + strings.TrimPrefix(sym, "·")
+		}
+		return strings.ReplaceAll(strings.ReplaceAll(sym, "∕", "/"), "·", ".")
+	}, Sigs: map[string]FuncSig{sig.Name: sig}}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}, request, file, opt
+}
+
+func TestGoX86NumericalSBReadActualSealedSDKJoin(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, original, _, _ := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+				GoBinary: original.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(original.GoBinary)), "src", "internal", "cpu"),
+				PackagePath: "internal/cpu", Target: original.Target, Environment: original.Environment, SDKCPU: true,
+				Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+				GoBinary: original.GoBinary, Directory: original.Directory, PackagePath: "example.invalid/numericalfixture",
+				AssemblyFile: original.AssemblyFile, Target: original.Target, Environment: original.Environment,
+				Owners: []*GoNumericalStorageOwner{owner},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if len(source.reads) != 1 {
+				t.Fatalf("wrong actual numerical reads: %d", len(source.reads))
+			}
+			read := source.reads[0]
+			add := int64(64)
+			if arch == "amd64" {
+				add = 63
+			}
+			if read.offset != 64 || read.width != 1 || read.relocation.Add != add || read.variable.NativeName != "internal/cpu.X86" {
+				t.Fatalf("whole native CMP trailing-immediate/source offset join differs: %+v", read)
+			}
+			data, err := source.Readback(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("actual %s read sealed; source64/read1 nativeAdd%d reportBytes%d", arch, add, len(data))
+			retainNumericalRead(t, source, "cpu")
+			var restored GoX86NumericalReadSource
+			if err := json.Unmarshal([]byte("{}"), &restored); err != nil || !errors.Is(restored.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("JSON recreated source permission")
+			}
+			owner.Close()
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("closed numerical owner retained source join")
+			}
+		})
+	}
+}
+
+func retainNumericalRead(t *testing.T, source *GoX86NumericalReadSource, role string) {
+	t.Helper()
+	if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+		folder := filepath.Join(artifact, strings.ReplaceAll(source.request.Target, "/", "-"), "numerical-read-"+role)
+		if err := os.MkdirAll(folder, 0700); err != nil {
+			t.Fatal(err)
+		}
+		for name, data := range map[string][]byte{
+			"sealed-report.json":   source.report,
+			"archive-original.a":   source.native.Archive,
+			"object-original.o":    source.native.OriginalObject,
+			"object-expanded.o":    source.native.ExpandedObject,
+			"listing-original.txt": source.native.OriginalListing,
+			"listing-expanded.txt": source.native.ExpandedListing,
+			"source-expanded.s":    []byte(source.cpp.Output),
+		} {
+			if err := os.WriteFile(filepath.Join(folder, name), data, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+func TestGoX86NumericalSBReadActualSDKBlankAndExtentNegatives(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, original, _, _ := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			owner, err := CaptureGoNumericalStorageOwner(ctx, GoNumericalStorageCaptureRequest{
+				GoBinary: original.GoBinary, Directory: filepath.Join(filepath.Dir(filepath.Dir(original.GoBinary)), "src", "internal", "cpu"),
+				PackagePath: "internal/cpu", Target: original.Target, Environment: original.Environment, SDKCPU: true,
+				Variables: []GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			for _, test := range []struct{ name, instruction string }{
+				{"leading CacheLinePad", "MOVB internal∕cpu·X86+63(SB),AL"},
+				{"cross numerical span", "MOVW internal∕cpu·X86+99(SB),AX"},
+				{"trailing CacheLinePad", "MOVB internal∕cpu·X86+100(SB),AL"},
+				{"outside native extent", "MOVB internal∕cpu·X86+164(SB),AL"},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					assembly := "#include \"textflag.h\"\nTEXT ·Feature(SB),NOSPLIT,$0-1\n" + test.instruction + "\nMOVB AL,ret+0(FP)\nRET\n"
+					if err := os.WriteFile(filepath.Join(original.Directory, original.AssemblyFile), []byte(assembly), 0600); err != nil {
+						t.Fatal(err)
+					}
+					actual, err := goasmcmd.Run(ctx, original.Directory, original.Environment, original.GoBinary,
+						"list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+					if err != nil {
+						t.Fatalf("actual original Go accepted negative precondition failed: %v\n%s", err, actual)
+					}
+					source, err := CaptureGoX86NumericalReadSource(ctx, GoX86NumericalReadCaptureRequest{
+						GoBinary: original.GoBinary, Directory: original.Directory, PackagePath: "example.invalid/numericalfixture",
+						AssemblyFile: original.AssemblyFile, Target: original.Target, Environment: original.Environment,
+						Owners: []*GoNumericalStorageOwner{owner},
+					})
+					if source != nil {
+						source.Close()
+						t.Fatal("blank/cross-span/out-of-extent CPU bytes obtained a read join")
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("negative did not produce exact Context", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoX86NumericalSBReadOriginalContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, request, file, opt := numericalSBFixture(t, arch)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			selection, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			if err != nil {
+				t.Fatalf("actual original Go export failed: %v\n%s", err, selection)
+			}
+			listing, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary, "tool", "asm", "-S", "-p", "example.invalid/numericalfixture", "-I", filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "pkg", "include"), "-o", filepath.Join(t.TempDir(), "original.o"), request.AssemblyFile)
+			if err != nil {
+				t.Fatalf("actual original Go asm failed: %v\n%s", err, listing)
+			}
+			t.Logf("actual %s original Go export succeeded; source64/read1 listing:\n%s", arch, listing)
+			for _, api := range []string{"text", "module", "context"} {
+				t.Run(api, func(t *testing.T) {
+					var err error
+					if api == "text" {
+						_, err = Translate(file, opt)
+					} else if api == "module" {
+						mod, failure := TranslateModule(file, opt)
+						err = failure
+						if !mod.IsNil() {
+							mod.Dispose()
+						}
+					} else {
+						llvmContext := llvm.NewContext()
+						mod, failure := TranslateModuleInContext(llvmContext, file, opt)
+						err = failure
+						if !mod.IsNil() {
+							mod.Dispose()
+						}
+						llvmContext.Dispose()
+					}
+					if os.Getenv("PLAN9ASM_NUMERICAL_SB_EXPECT_ACCEPT") == "1" {
+						if err != nil {
+							t.Fatalf("actual-Go accepted numerical SB read not closed: %v", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("declaration-only SB read acquired authority: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/go_x86_numerical_read_text_order_go127_test.go b/go_x86_numerical_read_text_order_go127_test.go
new file mode 100644
index 000000000..e643626b0
--- /dev/null
+++ b/go_x86_numerical_read_text_order_go127_test.go
@@ -0,0 +1,86 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This consumes real complete source/header/compiler objects, not a fabricated
+// numerical source or an entry token. Physical records must remain unchanged.
+func TestGoX86SDKNumericalNativeOriginalMixedTextOrder(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, "amd64", "internal/bytealg")
+			request.Target = target
+			goos, _, _ := strings.Cut(target, "/")
+			for index, entry := range request.Environment {
+				if strings.HasPrefix(entry, "GOOS=") {
+					request.Environment[index] = "GOOS=" + goos
+				}
+			}
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal("complete actual original SDK precondition", err)
+			}
+			defer source.Close()
+			found := false
+			for ordinal, observed := range source.observation.Objects.Sources {
+				input := source.observation.ObjectInputs.Sources[ordinal]
+				original, expanded, err := gostaticstorage.ObserveX86SDKASMDataListingObjects(source.observation.ObjectInputs,
+					ordinal, input.OriginalObject, input.ExpandedObject)
+				if err != nil {
+					t.Fatal("complete actual native listing/object replay", err)
+				}
+				beforeOriginal, beforeExpanded := append([]byte(nil), original[0].Code...), append([]byte(nil), expanded[0].Code...)
+				order, err := numericalSDKNativeTextOrder(source.observation.CPP[ordinal].Output,
+					request.PackagePath, observed, original, expanded)
+				if err != nil || len(order) != len(original) {
+					t.Fatal("complete native consumer association", observed.Name, err)
+				}
+				if observed.Name == "equal_amd64.s" {
+					found = true
+					if !reflect.DeepEqual(order, []int{1, 2, 0}) || original[0].Name != "memeqbody" || original[0].ABI != 65535 {
+						t.Error("consumer confused source ordinal with unchanged physical order", order)
+					}
+				}
+				if !reflect.DeepEqual(beforeOriginal, original[0].Code) || !reflect.DeepEqual(beforeExpanded, expanded[0].Code) {
+					t.Fatal("association rewrote physical native evidence")
+				}
+			}
+			if !found {
+				t.Fatal("original equal source was cropped")
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("consumer changed the live original observation", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKNumericalNativeTextOrderLiveRevocation(t *testing.T) {
+	ctx, request, _ := numericalSDKLiteralFixture(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual complete numerical/source native precondition", err)
+	}
+	defer source.Close()
+	order := source.literals.Observation.Objects.Sources[source.literals.SourceOrdinal].TextOrder
+	if len(order) == 0 {
+		t.Fatal("native numerical join omitted its complete source mapping")
+	}
+	before := order[0]
+	order[0].ObjectOrdinal++
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed native source association retained a numerical certificate", err)
+	}
+	order[0] = before
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restoring changed metadata revived its revoked numerical source", err)
+	}
+}
diff --git a/go_x86_numerical_read_text_order_test.go b/go_x86_numerical_read_text_order_test.go
new file mode 100644
index 000000000..b72150a02
--- /dev/null
+++ b/go_x86_numerical_read_text_order_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func numericalNativeOrderFixture(t *testing.T) (string, gostaticstorage.ASMDataSourceObservation) {
+	t.Helper()
+	const program = "TEXT foreign·first<ABIInternal>(SB),4,$0-9\nRET\nTEXT ·second(SB),4,$0-8\nRET\nTEXT helper<>(SB),4,$0-0\nRET\n"
+	member := gostaticstorage.ASMDataMember{Flags: 4, Texts: []gostaticstorage.TextRecord{
+		{Name: "helper", ABI: 65535, Kind: 1, Namespace: gostaticstorage.TextSymbolSelf, Code: []byte{0xc3}, Size: 1},
+		{Name: "foreign.first", ABI: 1, Kind: 1, Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 1, Code: []byte{0x90, 0xc3}, Size: 2},
+		{Name: "example.second", Kind: 1, Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 2, Relative: 1, Code: []byte{0x90, 0x90, 0xc3}, Size: 3},
+	}}
+	order, err := gostaticstorage.ASMSourceTextOrder([]byte(program), "example", member)
+	if err != nil {
+		t.Fatal("independent metadata grammar fixture", err)
+	}
+	return program, gostaticstorage.ASMDataSourceObservation{Original: member, Expanded: member, TextOrder: order}
+}
+
+func TestGoX86NumericalNativeTextOrderCompleteIdentity(t *testing.T) {
+	program, observed := numericalNativeOrderFixture(t)
+	order, err := numericalSDKNativeTextOrder(program, "example", observed, observed.Original.Texts, observed.Expanded.Texts)
+	if err != nil || !reflect.DeepEqual(order, []int{1, 2, 0}) {
+		t.Fatal("native consumer needs an exact complete source-to-object association", order, err)
+	}
+	order[0] = 0
+	if observed.TextOrder[0].ObjectOrdinal != 1 {
+		t.Fatal("consumer aliases the original mapping")
+	}
+}
+
+func TestGoX86NumericalNativeTextOrderRejectsChangedEvidence(t *testing.T) {
+	for name, mutate := range map[string]func(*gostaticstorage.ASMDataSourceObservation){
+		"missing source":    func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder = o.TextOrder[:2] },
+		"source ordinal":    func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].SourceOrdinal++ },
+		"object ordinal":    func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].ObjectOrdinal = 0 },
+		"duplicate ordinal": func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[1] = o.TextOrder[0] },
+		"symbol":            func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].Name += ".other" },
+		"ABI":               func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].ABI = 0 },
+		"namespace": func(o *gostaticstorage.ASMDataSourceObservation) {
+			o.TextOrder[0].Namespace = gostaticstorage.TextSymbolSelf
+		},
+		"relative index":    func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].Relative++ },
+		"physical index":    func(o *gostaticstorage.ASMDataSourceObservation) { o.TextOrder[0].Index++ },
+		"expanded code":     func(o *gostaticstorage.ASMDataSourceObservation) { o.Expanded.Texts[0].Code[0] ^= 1 },
+		"expanded position": func(o *gostaticstorage.ASMDataSourceObservation) { o.Expanded.Texts[0].PCLine = []byte{1} },
+		"expanded relocation": func(o *gostaticstorage.ASMDataSourceObservation) {
+			o.Expanded.Texts[0].Relocations = []gostaticstorage.TextRelocation{{Offset: 0, Size: 1, Type: 1}}
+		},
+		"expanded namespace": func(o *gostaticstorage.ASMDataSourceObservation) {
+			o.Expanded.Texts[0].Namespace = gostaticstorage.TextSymbolNonpkgDefinition
+		},
+		"not assembler":     func(o *gostaticstorage.ASMDataSourceObservation) { o.Original.Flags = 0 },
+		"unknown namespace": func(o *gostaticstorage.ASMDataSourceObservation) { o.Original.Texts[0].Namespace = 255 },
+		"wrong bank ABI":    func(o *gostaticstorage.ASMDataSourceObservation) { o.Original.Texts[0].ABI = 0 },
+		"exchanged records": func(o *gostaticstorage.ASMDataSourceObservation) {
+			o.Original.Texts[0], o.Original.Texts[1] = o.Original.Texts[1], o.Original.Texts[0]
+		},
+		"missing object TEXT": func(o *gostaticstorage.ASMDataSourceObservation) { o.Original.Texts = o.Original.Texts[:2] },
+	} {
+		t.Run(name, func(t *testing.T) {
+			program, observed := numericalNativeOrderFixture(t)
+			raw, err := json.Marshal(observed)
+			var changed gostaticstorage.ASMDataSourceObservation
+			if err != nil || json.Unmarshal(raw, &changed) != nil {
+				t.Fatal("independent mutation snapshot", err)
+			}
+			mutate(&changed)
+			order, err := numericalSDKNativeTextOrder(program, "example", changed, observed.Original.Texts, observed.Expanded.Texts)
+			if order != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed source/physical identity was accepted", order, err)
+			}
+		})
+	}
+	program, observed := numericalNativeOrderFixture(t)
+	for _, changed := range []string{
+		strings.Replace(program, "foreign·first", "foreign·other", 1),
+		strings.Replace(program, "<ABIInternal>", "<ABI0>", 1),
+		program + "TEXT missing<>(SB),4,$0-0\nRET\n",
+	} {
+		if order, err := numericalSDKNativeTextOrder(changed, "example", observed, observed.Original.Texts, observed.Expanded.Texts); order != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed complete source TEXT inventory was accepted", order, err)
+		}
+	}
+}
+
+func TestGoX86NumericalNativeTextOrderGrantsNoEntryRole(t *testing.T) {
+	for _, symbol := range []string{"helper<>", "foreign·first<ABIInternal>"} {
+		_, _, accepted := numericalFunctionSourceIdentity(symbol, "example", "amd64", numericalSBOwnedSource)
+		if accepted {
+			t.Fatal("source order metadata granted an owned/native entry", symbol)
+		}
+	}
+	if _, _, accepted := numericalFunctionSourceIdentity("helper<>", "example", "amd64", numericalSBSDKSource); accepted {
+		t.Fatal("static helper acquired a numerical entry declaration")
+	}
+}
diff --git a/go_x86_numerical_read_vector.go b/go_x86_numerical_read_vector.go
new file mode 100644
index 000000000..9635b4398
--- /dev/null
+++ b/go_x86_numerical_read_vector.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import "strings"
+
+type x86NumericalSBVectorKind uint8
+
+const (
+	x86NumericalSBScalar x86NumericalSBVectorKind = iota
+	x86NumericalSBAES
+	x86NumericalSBLogical
+)
+
+// Consume the complete existing Go operand grammars, including all vector
+// widths, immediate positions, masks and broadcasts. This selects numerical
+// read operands only; a private source/native/owner join still supplies every
+// exact byte and confers no permission to store or escape the global address.
+func x86NumericalSBVectorReadProperties(ins Instr, arch string) (x86NumericalSBReadForm, bool) {
+	form := x86NumericalSBReadForm{}
+	if aes, known, err := x86AESProperties(ins.Op, ins, arch); known {
+		if err != nil || aes.memory < 0 {
+			return form, false
+		}
+		form.operand, form.partner = aes.memory, aes.destination
+		form.spec.sourceBytes, form.spec.vector = int64(aes.byteWidth), x86NumericalSBAES
+	} else if logical, known, err := x86PackedLogicalProperties(ins, arch); known {
+		if err != nil || logical.memory < 0 || logical.mmx || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return form, false
+		}
+		form.operand, form.partner = logical.memory, logical.destination
+		form.spec.sourceBytes, form.spec.vector = int64(logical.memoryBytes), x86NumericalSBLogical
+	} else {
+		return form, false
+	}
+	operand := ins.Args[form.operand]
+	if operand.Kind != OpSym || strings.HasPrefix(strings.TrimSpace(operand.Sym), "$") {
+		return x86NumericalSBReadForm{}, false
+	}
+	if _, _, valid := parseSBRef(operand.Sym); !valid {
+		return x86NumericalSBReadForm{}, false
+	}
+	return form, true
+}
+
+// Use the existing byte dependencies with precisely this operand's certified
+// numerical bytes. No incoming vector byte, mask or merge destination is
+// manufactured. The temporary state receives no reusable SB memory authority.
+func numericalVectorByteUpdate(ins Instr, arch string, form x86NumericalSBReadForm,
+	vector func(Reg) uint64, mask func(Reg) bool,
+) (destination Reg, width int, known uint64, legacy, valid bool) {
+	switch form.spec.vector {
+	case x86NumericalSBAES:
+		aes, recognized, err := x86AESProperties(ins.Op, ins, arch)
+		if !recognized || err != nil {
+			return "", 0, 0, false, false
+		}
+		input := uint64(0)
+		if aes.state >= 0 {
+			input = vector(ins.Args[aes.state].Reg)
+		}
+		return ins.Args[aes.destination].Reg, aes.byteWidth,
+			x86AESDefinedBytes(aes, x86CallerVectorByteMask(int64(aes.byteWidth)), input), !aes.spec.vector, true
+	case x86NumericalSBLogical:
+		logical, recognized, err := x86PackedLogicalProperties(ins, arch)
+		if !recognized || err != nil || logical.mmx || logical.mask >= 0 && !mask(ins.Args[logical.mask].Reg) {
+			return "", 0, 0, false, false
+		}
+		destination = ins.Args[logical.destination].Reg
+		known = x86PackedLogicalDefinedBytes(ins, logical, x86CallerVectorByteMask(int64(logical.byteWidth)),
+			vector(ins.Args[logical.second].Reg), vector(destination))
+		return destination, logical.byteWidth, known, logical.legacy, true
+	}
+	return "", 0, 0, false, false
+}
+
+func x86ResultNumericalVectorStep(ins Instr, state *x86ResultState, arch string, form x86NumericalSBReadForm) (bool, bool) {
+	destination, width, known, legacy, valid := numericalVectorByteUpdate(ins, arch, form,
+		func(reg Reg) uint64 {
+			index, valid := amd64VectorRegisterIndex(reg, amd64VectorByteWidth(reg))
+			if !valid || index >= len(state.xmm) {
+				return 0
+			}
+			return state.vectorBytes(index)
+		}, func(reg Reg) bool {
+			index, valid := amd64ParseKReg(reg)
+			return valid && state.masks[index]
+		})
+	if !valid {
+		return false, true
+	}
+	index, _ := amd64VectorRegisterIndex(destination, width)
+	state.writeVector(index, width, known, legacy)
+	return true, true
+}
+
+func numericalVectorMapStep(ins Instr, arch string, form x86NumericalSBReadForm, vectors map[Reg]uint64, masks map[Reg]bool) bool {
+	destination, width, known, legacy, valid := numericalVectorByteUpdate(ins, arch, form,
+		func(reg Reg) uint64 { return vectors[x86CallerVectorRoot(reg)] }, func(reg Reg) bool { return masks[reg] })
+	if !valid || vectors == nil {
+		return false
+	}
+	root := x86CallerVectorRoot(destination)
+	bytes := x86CallerVectorByteMask(int64(width))
+	if legacy {
+		vectors[root] = vectors[root]&^bytes | known
+	} else {
+		vectors[root] = ^bytes | known
+	}
+	return true
+}
diff --git a/go_x86_numerical_read_vector_go127_test.go b/go_x86_numerical_read_vector_go127_test.go
new file mode 100644
index 000000000..79deaafad
--- /dev/null
+++ b/go_x86_numerical_read_vector_go127_test.go
@@ -0,0 +1,184 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func numericalVectorReadRows(arch string) []string {
+	var rows []string
+	for _, name := range x86AESOracleNames {
+		widths := []int{16}
+		if strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+			widths = []int{16, 32, 64}
+		}
+		for _, width := range widths {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			row, _ := x86AESOracleRow(name, "DATA+0(SB)", bank)
+			// The independent oracle selects X1/X2; keep every numerical state
+			// source/destination in the fixture's initialized register zero.
+			row = strings.ReplaceAll(strings.ReplaceAll(row, bank+"1", bank+"0"), bank+"2", bank+"0")
+			rows = append(rows, row)
+		}
+	}
+	for _, opcode := range x86LogicalOpcodeNames() {
+		spec := x86PackedLogicalSpecs[opcode]
+		legacy := spec.encoding <= x86PackedLogicalLegacyInteger
+		widths := []int{16}
+		if !legacy {
+			widths = append(widths, 32)
+			if spec.encoding != x86PackedLogicalVEX {
+				widths = append(widths, 64)
+			}
+		}
+		for _, width := range widths {
+			reg := map[int]string{16: "X0", 32: "Y0", 64: "Z0"}[width]
+			args := " DATA+0(SB)," + reg
+			if !legacy {
+				args += "," + reg
+			}
+			rows = append(rows, string(opcode)+args)
+		}
+		if spec.broadcastBytes != 0 && arch == "amd64" {
+			rows = append(rows, string(opcode)+".BCST DATA+0(SB),Z0,Z0",
+				string(opcode)+".BCST.Z DATA+0(SB),Z0,K1,Z0",
+				string(opcode)+" DATA+0(SB),Z0,K1,Z0")
+		}
+	}
+	return rows
+}
+
+func numericalVectorFixture(t *testing.T, arch string, rows []string) (GoPackage, *File, Options, *GoX86NumericalReadSource) {
+	t.Helper()
+	body := "MOVL $65535,AX\nKMOVW AX,K1\nVPXORD Z0,Z0,Z0\n" + strings.Join(rows, "\n") + "\nPEXTRD $0,X0,AX"
+	ownerRequest, readRequest := numericalMutableFixture(t, arch, body)
+	name := filepath.Join(ownerRequest.Directory, "value.go")
+	data, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data = bytes.Replace(data, []byte("var Mutable [32]byte"), []byte("var Mutable [128]byte"), 1)
+	if err := os.WriteFile(name, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	owner, err := CaptureGoNumericalStorageOwner(ctx, ownerRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(owner.Close)
+	readRequest.Owners = []*GoNumericalStorageOwner{owner}
+	source, err := CaptureGoX86NumericalReadSource(ctx, readRequest)
+	if err != nil {
+		t.Fatal("actual complete source/native/vector mutable read join", err)
+	}
+	t.Cleanup(func() { closeNumericalConsumerSource(t, source) })
+	report, err := owner.observation.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	exports := make(map[string]string)
+	decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+	for decoder.More() {
+		var pkg gostaticstorage.Package
+		if err := decoder.Decode(&pkg); err != nil {
+			t.Fatal(err)
+		}
+		exports[pkg.ImportPath] = pkg.Export
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range source.guard.selection.GoFiles {
+		file, err := parser.ParseFile(fset, filepath.Join(readRequest.Directory, name), nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	imports := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) { return os.Open(exports[path]) })
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", arch), Importer: imports}).Check(readRequest.PackagePath, fset, syntax, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax, Imports: make(map[string]*types.Package)}
+	for _, dependency := range typed.Imports() {
+		pkg.Imports[dependency.Path()] = dependency
+	}
+	sig, err := DeriveGoFuncABI0Signature(pkg.Path+".Feature", typed.Scope().Lookup("Feature").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: arch, TargetTriple: map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch],
+		ResolveSym: func(symbol string) string { return numericalNativeName(symbol, pkg.Path) }, Sigs: map[string]FuncSig{sig.Name: sig}}
+	file, err := Parse(ArchAMD64, source.cpp.Output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("full original typed declarations/vector read binding", err)
+	}
+	return pkg, file, bound, source
+}
+
+func TestGoX86NumericalSBVectorReadOriginalObjectsAndLLVM22(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := numericalVectorReadRows(arch)
+			pkg, file, options, source := numericalVectorFixture(t, arch, rows)
+			if len(source.reads) != len(rows) {
+				t.Fatal("complete original family lost a read", len(source.reads), len(rows))
+			}
+			for _, api := range []string{"text", "module", "context", "go-module"} {
+				t.Run(api, func(t *testing.T) {
+					ir := numericalFamilyTranslate(t, api, pkg, file, options)
+					if !strings.Contains(ir, "external global [128 x i8]") || strings.Contains(ir, "constant [128") ||
+						!strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "load volatile") {
+						t.Fatal("mutable vector read lost original storage/native alignment/dead-read behavior")
+					}
+					triples := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+					if arch == "386" {
+						triples = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+					}
+					for _, triple := range triples {
+						t.Run(triple, func(t *testing.T) { numericalLLVM22Axes(t, ir, triple, nil) })
+					}
+				})
+			}
+			t.Logf("complete Go vector rows=%d target=%s original object bytes=%d", len(rows), arch, len(source.native.OriginalObject))
+		})
+	}
+}
+
+func TestGoX86NumericalSBVectorReadUnboundValuesRemainContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{"AESENC ·mutable(SB),X0", "PXOR ·mutable(SB),X0", "VAESENC ·mutable(SB),Y0,Y0", "VPXORD ·mutable(SB),Z0,Z0"} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-4\nPXOR X0,X0\n"+row+"\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Args: nil, Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Name: "ret", Offset: 0, Type: I32, Index: 0, Field: -1}}}}
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err == nil {
+					t.Fatal("symbol spelling alone created initialized mutable bytes", fmt.Sprint(row))
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_numerical_read_vector_native.go b/go_x86_numerical_read_vector_native.go
new file mode 100644
index 000000000..57375bd9b
--- /dev/null
+++ b/go_x86_numerical_read_vector_native.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"math"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// This separate physical-vector observation cannot enter the generic scalar
+// decoder map or raw translation. A source read must additionally join its
+// exact instruction ordinal, original/expanded objects, relocation and owner.
+type numericalNativeRead struct {
+	length, width, addressBits, addressField int
+	pcRelative                               bool
+	memory                                   MemRef
+	vector                                   *Instr
+	scalar                                   *x86asm.Inst
+}
+
+func numericalNativeReads(code []byte, mode int) (map[int64]numericalNativeRead, error) {
+	boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+	if err != nil {
+		return nil, err
+	}
+	reads := make(map[int64]numericalNativeRead)
+	for pc, native := range scalar {
+		memories := 0
+		for _, argument := range native.Args {
+			if _, valid := argument.(x86asm.Mem); valid {
+				memories++
+			}
+		}
+		if memories != 1 {
+			continue // A source SB read still needs one unique native memory operand.
+		}
+		original := native // Root Go 1.20 range variables are reused.
+		reads[pc] = numericalNativeRead{length: native.Len, width: native.MemBytes, addressBits: native.AddrSize,
+			addressField: native.PCRelOff, pcRelative: native.PCRel == 4, scalar: &original}
+	}
+	decoders := [...]func([]byte, int, x86RawMemoryDecoder) (Instr, int, bool, error){
+		decodedX86AESInstructionWithMemory,
+		decodedX86VEXPackedFloatLogicalInstructionWithMemory,
+		decodedX86VEXPackedIntegerLogicalInstructionWithMemory,
+		decodedX86EVEXPackedLogicalInstructionWithMemory,
+		decodedX86RawEVEXFloatLogicalInstructionWithMemory,
+	}
+	for _, boundary := range boundaries {
+		physical := code[boundary.PC : boundary.PC+int64(boundary.Length)]
+		if !x86NumericalVectorPrefix(physical, mode) {
+			continue
+		}
+		for _, decode := range decoders {
+			ins, length, known, err := decode(physical, mode, x86RawMemoryDecoder{physicalPC: true})
+			if !known && err == nil {
+				continue
+			}
+			if err != nil || length != boundary.Length {
+				return nil, numericalSBContext("physical vector read differs from complete native boundary: %v", err)
+			}
+			shape := ins
+			shape.Args = append([]Operand(nil), ins.Args...)
+			for index, operand := range shape.Args {
+				if operand.Kind == OpMem {
+					// The complete physical decoder retains RIP independently.
+					// Public source grammar receives a symbolic read shape only;
+					// this temporary view supplies no raw translation permission.
+					shape.Args[index] = Operand{Kind: OpSym, Sym: "·observed(SB)"}
+				}
+			}
+			memory, width := -1, 0
+			if aes, known, err := x86AESProperties(shape.Op, shape, map[int]string{32: "386", 64: "amd64"}[mode]); known && err == nil {
+				memory, width = aes.memory, aes.byteWidth
+			} else if logical, known, err := x86PackedLogicalProperties(shape, map[int]string{32: "386", 64: "amd64"}[mode]); known && err == nil {
+				memory, width = logical.memory, logical.memoryBytes
+			}
+			if memory < 0 {
+				break // No physical memory; this can never supply an SB-read candidate.
+			}
+			p, valid := decodeX86RawVectorEncoding(physical)
+			if !valid || p.addressOverride || p.segment != "" || p.modRM >= len(physical) || physical[p.modRM]&0xc7 != 5 ||
+				p.x != 0 || p.b != 0 || ins.Args[memory].Kind != OpMem {
+				break // Ordinary native addresses cannot provide a symbolic-read candidate.
+			}
+			reads[boundary.PC] = numericalNativeRead{length: length, width: width, addressBits: mode,
+				addressField: p.modRM + 1, pcRelative: mode == 64, memory: ins.Args[memory].Mem, vector: &ins}
+			break
+		}
+	}
+	return reads, nil
+}
+
+func (native numericalNativeRead) matchesSource(ins Instr, operand int, arch string) bool {
+	if native.scalar != nil {
+		for _, prefix := range native.scalar.Prefix {
+			value := uint8(prefix)
+			if value != 0 && value != 0x66 && !(arch == "amd64" && value >= 0x40 && value <= 0x4f) {
+				return false
+			}
+		}
+		memory := x86asm.Mem{}
+		for _, argument := range native.scalar.Args {
+			if value, valid := argument.(x86asm.Mem); valid {
+				memory = value
+			}
+		}
+		return memory.Segment == 0 && memory.Index == 0 && memory.Scale == 0 &&
+			(arch == "amd64" && memory.Base == x86asm.RIP || arch == "386" && memory.Base == 0)
+	}
+	if native.vector == nil || operand < 0 || operand >= len(ins.Args) || len(native.vector.Args) != len(ins.Args) {
+		return false
+	}
+	if native.memory.Index != "" || native.memory.Scale != 0 || native.memory.Segment != "" ||
+		arch == "amd64" && native.memory.Base != "RIP" || arch == "386" && native.memory.Base != "" {
+		return false
+	}
+	physical := *native.vector
+	physical.Args = append([]Operand(nil), physical.Args...)
+	physical.Args[operand] = ins.Args[operand]
+	// VAESKEYGENASSIST's source signed imm8 and decoded byte have identical
+	// hardware bits. Both were independently validated by the complete grammar.
+	if strings.HasSuffix(string(ins.Op), "KEYGENASSIST") {
+		if uint8(physical.Args[0].Imm) != uint8(ins.Args[0].Imm) {
+			return false
+		}
+		physical.Args[0].Imm = ins.Args[0].Imm
+	}
+	return numericalSameInstruction(ins, physical, "", arch)
+}
+
+func (native numericalNativeRead) relocation(text gostaticstorage.TextRecord, pc int64, arch string) (gostaticstorage.TextRelocation, int64, error) {
+	if native.scalar != nil {
+		return numericalInstructionRelocation(text, pc, *native.scalar, arch)
+	}
+	var selected []gostaticstorage.TextRelocation
+	for _, relocation := range text.Relocations {
+		if relocation.Offset < pc+int64(native.length) && relocation.Offset+relocation.Size > pc {
+			selected = append(selected, relocation)
+		}
+	}
+	if native.vector == nil || len(selected) != 1 || native.addressField < 0 || native.addressField+4 > native.length {
+		return gostaticstorage.TextRelocation{}, 0, numericalSBContext("vector read lacks its complete displacement relocation")
+	}
+	r := selected[0]
+	if r.Offset != pc+int64(native.addressField) || r.Size != 4 || !r.Target.ABIKnown || r.Target.ABI != 0 ||
+		arch == "amd64" && (!native.pcRelative || native.addressBits != 64 || r.Type != 14) ||
+		arch == "386" && (native.pcRelative || native.addressBits != 32 || r.Type != 1) {
+		return r, 0, numericalSBContext("vector read native displacement/ABI/target role differs")
+	}
+	offset := r.Add
+	if native.pcRelative {
+		tail := int64(native.length - native.addressField - 4)
+		if offset > math.MaxInt64-tail {
+			return r, 0, numericalSBContext("vector PC-relative addend overflow")
+		}
+		offset += tail
+	}
+	return r, offset, nil
+}
diff --git a/go_x86_numerical_read_vector_test.go b/go_x86_numerical_read_vector_test.go
new file mode 100644
index 000000000..4035e2ecc
--- /dev/null
+++ b/go_x86_numerical_read_vector_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestGoX86NumericalSBVectorReadCompleteTypedFamily(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for op, spec := range x86AESSpecs {
+			widths := []int{16}
+			if spec.vector && spec.operation < x86AESInverseMix && arch == "amd64" {
+				widths = []int{16, 32, 64}
+			}
+			for _, width := range widths {
+				args := "·mutable+16(SB), X0"
+				if spec.operation == x86AESKeyAssist {
+					args = "$7, " + args
+				} else if spec.vector && spec.operation < x86AESInverseMix {
+					reg := map[int]string{16: "X0", 32: "Y0", 64: "Z0"}[width]
+					args = "·mutable+16(SB), " + reg + ", " + reg
+				}
+				t.Run(arch+"/"+string(op)+"/"+args, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-0\n"+string(op)+" "+args+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					operand, bytes, valid := x86NumericalSBReadShape(file.Funcs[0].Instrs[1], arch)
+					wantOperand := 0
+					if spec.operation == x86AESKeyAssist {
+						wantOperand = 1
+					}
+					if !valid || operand != wantOperand || bytes != int64(width) {
+						t.Fatal("typed mutable AES read is absent", operand, bytes, valid)
+					}
+				})
+			}
+		}
+		for op, spec := range x86PackedLogicalSpecs {
+			legacy := spec.encoding == x86PackedLogicalLegacyFP || spec.encoding == x86PackedLogicalLegacyInteger
+			widths := []int{16}
+			if !legacy {
+				widths = []int{16, 32}
+				if spec.encoding != x86PackedLogicalVEX {
+					widths = append(widths, 64)
+				}
+			}
+			for _, width := range widths {
+				reg := map[int]string{16: "X0", 32: "Y0", 64: "Z0"}[width]
+				args := "·mutable(SB), " + reg
+				if !legacy {
+					args += ", " + reg
+				}
+				t.Run(arch+"/"+string(op)+"/"+args, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-0\n"+string(op)+" "+args+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					operand, bytes, valid := x86NumericalSBReadShape(file.Funcs[0].Instrs[1], arch)
+					if !valid || operand != 0 || bytes != int64(width) {
+						t.Fatal("typed mutable logical read is absent", operand, bytes, valid)
+					}
+				})
+			}
+		}
+		for _, source := range []string{
+			"AESENC $·mutable(SB), X0", "AESENC ·mutable(SB), M0", "AESENC ·mutable(SB), X8",
+			"PXOR X0, ·mutable(SB)", "PXOR ·mutable(SB), M0", "VAESENC.Z ·mutable(SB), X0, X0",
+			"VPXORD.Z ·mutable(SB), X0, X0", "VPXORD.BCST X0, X0, X0",
+		} {
+			if arch == "amd64" && strings.HasSuffix(source, "X8") {
+				continue
+			}
+			file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-0\n"+source+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, _, valid := x86NumericalSBReadShape(file.Funcs[0].Instrs[1], arch); valid {
+				t.Fatal("unbound/invalid vector role acquired a numerical read", arch, source)
+			}
+		}
+	}
+}
diff --git a/go_x86_sdk_asm_data_capture.go b/go_x86_sdk_asm_data_capture.go
new file mode 100644
index 000000000..a6cc99cbb
--- /dev/null
+++ b/go_x86_sdk_asm_data_capture.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func (source *GoX86SDKASMDataSource) verifySDKDirectory() error {
+	root := source.guard.env["GOROOT"]
+	wanted := filepath.Join(root, "src", filepath.FromSlash(source.request.PackagePath))
+	resolved, err := sourcepath.Resolve(wanted)
+	actual, actualErr := os.Lstat(source.request.Directory)
+	physical, physicalErr := os.Lstat(wanted)
+	if err != nil || resolved != wanted || actualErr != nil || physicalErr != nil ||
+		!actual.IsDir() || !physical.IsDir() || !os.SameFile(actual, physical) || source.request.Directory != wanted {
+		return sdkASMDataContext("source is not the invoked SDK's exact physical package")
+	}
+	return nil
+}
+
+// This pure predicate validates a command's observed profile. Only capture's
+// independent live source/tool/selection guards can authenticate that command.
+func (source *GoX86SDKASMDataSource) validateObservedEnvironment(raw []byte, provided map[string]string) (map[string]string, error) {
+	var env map[string]string
+	if json.Unmarshal(raw, &env) != nil {
+		return nil, sdkASMDataContext("actual SDK/compiler environment is not a complete string observation")
+	}
+	amd64Profile := env["GOAMD64"] == "v1"
+	if source.captureRole == sdkASMDataOriginalSourceRole && env["GOARCH"] == "386" {
+		// cmd/go reports this inactive setting verbatim (including empty).
+		// Retain it in the sealed observation, never invent a v1 environment.
+		_, amd64Profile = env["GOAMD64"]
+	}
+	if !strings.HasPrefix(env["GOVERSION"], "go1.27.") ||
+		env["GOOS"]+"/"+env["GOARCH"] != source.request.Target ||
+		filepath.Join(env["GOROOT"], "bin", gotoolchain.HostExecutable("go")) != source.request.GoBinary ||
+		!amd64Profile || env["GOARCH"] == "386" && env["GO386"] != "sse2" ||
+		env["GOFLAGS"] != "" || env["GOEXPERIMENT"] != "" ||
+		env["GOCACHE"] != provided["GOCACHE"] || env["GOMODCACHE"] != provided["GOMODCACHE"] ||
+		env["CGO_ENABLED"] != provided["CGO_ENABLED"] {
+		return nil, sdkASMDataContext("actual SDK/compiler/profile is outside this registered observation")
+	}
+	if source.originalProfile {
+		wanted := provided["GOENV"]
+		if wanted == "off" {
+			wanted = "" // cmd/go reports an explicitly disabled config as empty.
+		}
+		if env["GOENV"] != wanted || env["GOWORK"] != provided["GOWORK"] || env["GOTOOLCHAIN"] != provided["GOTOOLCHAIN"] {
+			return nil, sdkASMDataContext("actual SDK-primary original default/config profile differs")
+		}
+	}
+	return env, nil
+}
+
+func (source *GoX86SDKASMDataSource) capture(ctx context.Context, provided map[string]string) error {
+	source.observation.Protocol = "actual_go_sdk_asm_data_live_observation_v1"
+	source.observation.Request = source.request
+	if _, err := source.guard.read(source.request.GoBinary); err != nil {
+		return err
+	}
+	arguments := []string{"env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOOS", "GOARCH",
+		"GOAMD64", "GO386", "GOFLAGS", "GOEXPERIMENT", "GOCACHE", "GOMODCACHE", "CGO_ENABLED"}
+	if source.originalProfile {
+		arguments = append(arguments, "GOENV", "GOWORK", "GOTOOLCHAIN", "GOPROXY")
+		source.observation.Protocol = "actual_go_sdk_primary_frame_source_observation_v1"
+		if source.captureRole == sdkASMDataOriginalSourceRole {
+			source.observation.Protocol = "actual_go_sdk_original_source_observation_v1"
+		}
+	}
+	raw, err := source.run(ctx, arguments...)
+	if err != nil {
+		return err
+	}
+	env, err := source.validateObservedEnvironment(raw, provided)
+	if err != nil {
+		return err
+	}
+	source.guard.env = env
+	source.observation.RawEnvironment = raw
+	if err := source.verifySDKDirectory(); err != nil {
+		return err
+	}
+	for _, directory := range []string{env["GOROOT"], env["GOTOOLDIR"], filepath.Join(env["GOROOT"], "pkg", "include")} {
+		if err := source.retainDirectory(directory); err != nil {
+			return err
+		}
+	}
+	version, err := source.guard.read(filepath.Join(env["GOROOT"], "VERSION"))
+	if err != nil || strings.Split(string(version), "\n")[0] != env["GOVERSION"] {
+		return sdkASMDataContext("invoked compiler differs from its SDK source VERSION: %v", err)
+	}
+	tools := []string{"asm", "compile"}
+	if source.captureRole == sdkASMDataOriginalSourceRole && env["GOARCH"] == "386" {
+		tools = append(tools, "link")
+	}
+	for _, tool := range tools {
+		route, err := source.run(ctx, "tool", "-n", tool)
+		if err != nil {
+			return err
+		}
+		if strings.TrimSpace(string(route)) != filepath.Join(env["GOTOOLDIR"], gotoolchain.HostExecutable(tool)) {
+			return sdkASMDataContext("actual %s route differs from the invoked SDK", tool)
+		}
+		if _, err := source.guard.read(strings.TrimSpace(string(route))); err != nil {
+			return err
+		}
+	}
+	for _, role := range []string{"src/cmd/internal/goobj/builtinlist.go", "src/cmd/internal/obj/x86/asm6.go",
+		"src/cmd/internal/obj/x86/obj6.go", "src/cmd/go/internal/work/gc.go", "src/cmd/go/internal/load/pkg.go",
+		"src/cmd/go/internal/work/init.go", "src/internal/platform/supported.go",
+		"src/cmd/compile/internal/gc/obj.go", "src/cmd/link/internal/ld/go.go",
+		"src/cmd/asm/main.go", "src/cmd/asm/internal/lex/input.go", "src/cmd/asm/internal/lex/stack.go",
+		"src/cmd/asm/internal/lex/tokenizer.go", "src/cmd/compile/internal/typecheck/subr.go"} {
+		if _, err := source.guard.read(filepath.Join(env["GOROOT"], filepath.FromSlash(role))); err != nil {
+			return err
+		}
+	}
+	if source.captureRole == sdkASMDataOriginalSourceRole && env["GOARCH"] == "386" {
+		// Retain source bytes as observations only. Schema admission belongs to
+		// the distinct private compiler-association query, not this observer;
+		// public strict DATA and unrelated source profiles remain unchanged.
+		for role := range x86GoPanicTerminalCompilerSourceRoles() {
+			if _, err := source.guard.read(filepath.Join(env["GOROOT"], filepath.FromSlash(role))); err != nil {
+				return err
+			}
+		}
+	}
+	raw, err = source.run(ctx, "list", "-json", "-compiled", "-export", "-mod=readonly", source.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	var selected goAMD64FrameSelection
+	var extra any
+	if decoder.Decode(&selected) != nil || decoder.Decode(&extra) != io.EOF ||
+		selected.ImportPath != source.request.PackagePath || selected.Dir != source.request.Directory ||
+		!selected.Standard || selected.Module != nil || selected.ForTest != "" || selected.nonordinaryRole() ||
+		len(selected.Error)+len(selected.DepsErrors) != 0 || len(selected.GoFiles) == 0 ||
+		len(selected.SFiles) == 0 || len(selected.SFiles) > 62 {
+		return sdkASMDataContext("actual selection is not one complete ordinary SDK assembly package")
+	}
+	compiled := append([]string(nil), selected.CompiledGoFiles...)
+	for index, name := range compiled {
+		if filepath.IsAbs(name) {
+			if filepath.Dir(name) != selected.Dir {
+				return sdkASMDataContext("effective compiler source escaped its original directory")
+			}
+			compiled[index] = filepath.Base(name)
+		}
+	}
+	if !reflect.DeepEqual(compiled, selected.GoFiles) {
+		return sdkASMDataContext("generated compiler source mapping is not original SDK Go")
+	}
+	export, exportErr := sourcepath.Resolve(selected.Export)
+	if exportErr != nil || selected.Export != export || !goAssemblyPathWithinRoot(env["GOCACHE"], export) {
+		return sdkASMDataContext("actual selected export is not its canonical compiler cache object")
+	}
+	source.guard.selection = selected
+	source.observation.RawSelection = raw
+	graph, err := source.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", source.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	imports, err := source.guard.bindOriginalDeclarationImports(graph)
+	if err != nil {
+		return err
+	}
+	source.guard.imports = imports
+	source.observation.Graph, source.observation.Imports = graph, imports
+	referenced := make(map[string]gostaticstorage.SDKReferencedArchive)
+	paths := make([]string, 0, len(imports))
+	for path := range imports {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	for _, path := range paths {
+		if path == "unsafe" {
+			continue
+		}
+		dependency := imports[path]
+		archive, err := source.guard.read(dependency.Export)
+		if err != nil {
+			return err
+		}
+		referenced[path] = gostaticstorage.SDKReferencedArchive{PackagePath: path,
+			Sources: append([]string(nil), dependency.SFiles...), Archive: archive}
+	}
+	archive, err := source.guard.read(export)
+	if err != nil {
+		return err
+	}
+	builtin, err := source.guard.read(filepath.Join(env["GOROOT"], "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		return err
+	}
+	if err := source.captureHeader(ctx); err != nil {
+		return err
+	}
+	objectInputs := gostaticstorage.SDKASMDataObservationRequest{PackagePath: source.request.PackagePath,
+		Target: source.request.Target, Archive: archive, BuiltinSource: builtin, Referenced: referenced}
+	for ordinal, name := range selected.SFiles {
+		observed, cpp, err := source.captureAssembly(ctx, ordinal, name)
+		if err != nil {
+			return err
+		}
+		objectInputs.Sources = append(objectInputs.Sources, observed)
+		source.observation.CPP = append(source.observation.CPP, cpp)
+	}
+	source.observation.ObjectInputs = objectInputs
+	objects, err := gostaticstorage.ObserveX86SDKCPPASMData(objectInputs)
+	if err != nil {
+		return sdkASMDataContext("complete original/expanded/compiler DATA/TEXT join differs: %v", err)
+	}
+	source.observation.ObjectInputs, source.observation.Objects = objectInputs, objects
+	readProducer := func(role string) ([]byte, error) {
+		return source.guard.read(filepath.Join(env["GOROOT"], filepath.FromSlash(role)))
+	}
+	funcdataChecked, floatPoolsChecked := false, false
+	for _, observed := range objects.Sources {
+		if !funcdataChecked && len(observed.GeneratedFuncdata) != 0 {
+			if err := gostaticstorage.GeneratedFuncdataSources(env["GOVERSION"], readProducer); err != nil {
+				return sdkASMDataContext("generated metadata lacks its exact original producer source: %v", err)
+			}
+			funcdataChecked = true
+		}
+		if !floatPoolsChecked && len(observed.GeneratedFloatPools) != 0 {
+			if err := gostaticstorage.GeneratedFloatPoolSources(env["GOVERSION"], readProducer); err != nil {
+				return sdkASMDataContext("generated float pools lack their exact original producer source: %v", err)
+			}
+			floatPoolsChecked = true
+		}
+	}
+	if source.captureRole == sdkASMDataOriginalFrameRole {
+		return source.captureSDKFrameListings(ctx)
+	}
+	return nil
+}
diff --git a/go_x86_sdk_asm_data_context.go b/go_x86_sdk_asm_data_context.go
new file mode 100644
index 000000000..3ee59a83e
--- /dev/null
+++ b/go_x86_sdk_asm_data_context.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"context"
+	"time"
+)
+
+// Context implementations are caller-controlled callbacks. Sample their
+// methods before taking operation locks, then bridge only the captured Done
+// channels/deadlines to a standard private command context. The caller's actual
+// cancellation cause is still checked outside locks before and after the work.
+func sdkASMDataPrivateContext(caller, original context.Context, frozenDeadline time.Time) (context.Context, func(), error) {
+	if caller == nil || original == nil {
+		return nil, nil, sdkASMDataContext("missing verification/capture context")
+	}
+	sample, err := sampleGoSourceContext(caller, original,
+		goSourceContextLifetime{deadline: frozenDeadline, bounded: true}, true,
+		sdkASMDataContext("original capture context deadline changed or canceled without a cause"))
+	if err != nil {
+		return nil, nil, err
+	}
+	deadline := frozenDeadline
+	if sample.callerBounded && sample.callerDeadline.Before(deadline) {
+		deadline = sample.callerDeadline
+	}
+	private, cancel := context.WithDeadline(context.Background(), deadline)
+	finished, stopped := make(chan struct{}), make(chan struct{})
+	go func() {
+		defer close(stopped)
+		select {
+		case <-sample.callerDone:
+			cancel()
+		case <-sample.originalDone:
+			cancel()
+		case <-private.Done():
+		case <-finished:
+		}
+	}()
+	return private, func() {
+		close(finished)
+		cancel()
+		<-stopped
+	}, nil
+}
diff --git a/go_x86_sdk_asm_data_cpp.go b/go_x86_sdk_asm_data_cpp.go
new file mode 100644
index 000000000..df17ce515
--- /dev/null
+++ b/go_x86_sdk_asm_data_cpp.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func (source *GoX86SDKASMDataSource) captureAssembly(ctx context.Context, ordinal int, name string) (gostaticstorage.SDKASMDataSource, AssemblyCPPObservation, error) {
+	var result gostaticstorage.SDKASMDataSource
+	var cpp AssemblyCPPObservation
+	if filepath.Base(name) != name {
+		return result, cpp, sdkASMDataContext("selected ASM escaped its exact package-local route")
+	}
+	file := filepath.Join(source.request.Directory, name)
+	raw, err := source.guard.read(file)
+	if err != nil {
+		return result, cpp, err
+	}
+	cpp, positions, err := observeSDKAssemblyCPP(string(raw), AssemblyPreprocessOptions{FileName: file,
+		Defines:     GoAssemblerDefinesWithEnv(source.guard.env["GOOS"], source.guard.env["GOARCH"], source.guard.env),
+		ReadInclude: source.readAssemblyInclude})
+	if err != nil {
+		return result, cpp, err
+	}
+	source.observation.Positions = append(source.observation.Positions, positions)
+	expanded, err := source.artifact(fmt.Sprintf("expanded-%d.s", ordinal), []byte(positions.Mapped))
+	if err != nil {
+		return result, cpp, err
+	}
+	originalObject := filepath.Join(source.guard.owned, fmt.Sprintf("original-%d.o", ordinal))
+	expandedObject := filepath.Join(source.guard.owned, fmt.Sprintf("expanded-%d.o", ordinal))
+	for _, command := range [][2]string{{file, originalObject}, {expanded, expandedObject}} {
+		args := append(source.asmArguments(source.guard.owned), "-o", command[1], command[0])
+		if _, err := source.run(ctx, args...); err != nil {
+			return result, cpp, err
+		}
+	}
+	originalBytes, err := source.guard.read(originalObject)
+	if err != nil {
+		return result, cpp, err
+	}
+	expandedBytes, err := source.guard.read(expandedObject)
+	if err != nil {
+		return result, cpp, err
+	}
+	return gostaticstorage.SDKASMDataSource{Name: name, Original: raw, Expanded: []byte(cpp.Output),
+		OriginalObject: originalBytes, ExpandedObject: expandedBytes}, cpp, nil
+}
+
+// cmd/asm keeps its original CWD and fixed include roots for nested headers;
+// the including header's directory does not become a new lookup origin.
+func (source *GoX86SDKASMDataSource) readAssemblyInclude(_ string, header string) (string, []byte, error) {
+	if source.closePending || source.generation != 0 {
+		return "", nil, sdkASMDataContext("include input query is outside its unpublished capture lifetime")
+	}
+	relative := filepath.Base(header) != header
+	if relative {
+		if !sourcepath.CPPLocalSource(header) {
+			return "", nil, sdkASMDataContext("relative/foreign include escaped its canonical SDK source route")
+		}
+		if err := source.verifySDKDirectory(); err != nil {
+			return "", nil, sdkASMDataContext("relative/foreign include needs its exact SDK package: %v", err)
+		}
+		if err := source.verifyDirectories(); err != nil {
+			return "", nil, err
+		}
+	}
+	for _, directory := range []string{source.request.Directory, source.guard.owned,
+		filepath.Join(source.guard.env["GOROOT"], "pkg", "include")} {
+		candidate := filepath.Join(directory, filepath.FromSlash(header))
+		_, err := os.Lstat(candidate)
+		if os.IsNotExist(err) {
+			source.misses[candidate] = true
+			continue
+		}
+		if err != nil {
+			return "", nil, err
+		}
+		if header == "go_asm.h" && directory != source.guard.owned {
+			return "", nil, sdkASMDataContext("generated header is not the observed compiler artifact")
+		}
+		if relative {
+			inventory := source.guard.directoryInventory
+			if directory == source.guard.owned || inventory == nil {
+				return "", nil, sdkASMDataContext("relative/foreign include has no selected SDK source origin")
+			}
+			physical, err := sourcepath.CPPRegularSource(directory, header)
+			if err != nil || physical != candidate {
+				return "", nil, sdkASMDataContext("relative SDK include identity: %v", err)
+			}
+			for parent := filepath.Dir(candidate); ; parent = filepath.Dir(parent) {
+				before := source.directories[parent]
+				after, err := os.Lstat(parent)
+				if err != nil || before != nil && !os.SameFile(before, after) {
+					return "", nil, sdkASMDataContext("relative SDK include parent identity changed")
+				}
+				// Observe membership without reading unrelated child contents.
+				// The existing source graph owns all file/directory/byte budgets.
+				if err := inventory.Directory(parent, false); err != nil {
+					return "", nil, sdkASMDataContext("relative SDK include directory: %v", err)
+				}
+				if err := source.retainDirectory(parent); err != nil {
+					return "", nil, err
+				}
+				if parent == directory {
+					break
+				}
+			}
+			if err := inventory.Retain(candidate); err != nil {
+				return "", nil, sdkASMDataContext("relative SDK header source: %v", err)
+			}
+		}
+		data, err := source.guard.read(candidate)
+		return candidate, data, err
+	}
+	return "", nil, sdkASMDataContext("active header has no exact SDK/compiler source route")
+}
diff --git a/go_x86_sdk_asm_data_diagnostic_test.go b/go_x86_sdk_asm_data_diagnostic_test.go
new file mode 100644
index 000000000..1b4810d09
--- /dev/null
+++ b/go_x86_sdk_asm_data_diagnostic_test.go
@@ -0,0 +1,87 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func sdkASMDataDiagnosticRetain(t *testing.T, source *GoX86SDKASMDataSource) {
+	sdkASMDataDiagnosticRetainNamed(t, "", source)
+}
+
+func sdkASMDataDiagnosticRetainNamed(t *testing.T, suffix string, source *GoX86SDKASMDataSource) {
+	t.Helper()
+	folder := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR")
+	if folder == "" {
+		return
+	}
+	if err := os.MkdirAll(folder, 0700); err != nil {
+		t.Fatal(err)
+	}
+	raw, err := json.Marshal(source.observation)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if suffix == "" {
+		if err := os.WriteFile(filepath.Join(folder, "sdk-data-live-diagnostic.json"), raw, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	name := "sdk-data-observation-inputs-" + strings.ReplaceAll(t.Name(), "/", "-") + suffix + ".json"
+	if err := os.WriteFile(filepath.Join(folder, name), raw, 0600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// This unpublished test scratch has no ready generation or public source
+// token. Retain actual failed inputs so an independent SDK reader can explain
+// a complete object mismatch rather than discarding it at factory cleanup.
+func TestGoX86SDKASMDataLiveCRC32ObjectDiagnostic(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "hash/crc32")
+	provided, err := sdkASMDataEnvironment(request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	deadline, bounded := ctx.Deadline()
+	if !bounded {
+		t.Fatal("diagnostic lacks an original bounded context")
+	}
+	source := &GoX86SDKASMDataSource{request: request, context: ctx, originalContext: ctx,
+		originalDeadline: deadline,
+		directories:      make(map[string]os.FileInfo), misses: make(map[string]bool)}
+	source.identity = source
+	source.guard = newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, Target: request.Target, Environment: request.Environment})
+	source.originalGuard = source.guard
+	for _, directory := range []string{request.Directory, provided["GOCACHE"], provided["GOMODCACHE"],
+		provided["GOPATH"], provided["TMPDIR"], provided["GOTMPDIR"]} {
+		if err := source.retainDirectory(directory); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := source.guard.snapshotDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	source.guard.owned, err = filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	source.guard.ownedInfo, err = os.Stat(source.guard.owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	err = source.capture(ctx, provided)
+	sdkASMDataDiagnosticRetain(t, source)
+	if err != nil {
+		t.Fatal("actual complete SDK object diagnostic", err)
+	}
+	if source.ready || source.generation != 0 {
+		t.Fatal("diagnostic scratch gained public lifetime authority")
+	}
+}
diff --git a/go_x86_sdk_asm_data_digest.go b/go_x86_sdk_asm_data_digest.go
new file mode 100644
index 000000000..d862b7f4f
--- /dev/null
+++ b/go_x86_sdk_asm_data_digest.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"hash"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+)
+
+// The state seal is private, not a serialized observation protocol. Stream the
+// complete current state instead of making base64/JSON copies of object and
+// listing payloads on every live check. No observation or payload digest is
+// cached. Kind tags, field names and length frames keep the encoding unambiguous.
+func digestSDKASMDataState(state any) ([32]byte, error) {
+	encoder := sdkASMDataDigestEncoder{hash: sha256.New()}
+	encoder.text("plan9asm.sdk-asm-data-state.v1")
+	if err := encoder.value(reflect.ValueOf(state), 0); err != nil {
+		return [32]byte{}, err
+	}
+	encoder.flush()
+	var sum [32]byte
+	copy(sum[:], encoder.hash.Sum(sum[:0]))
+	return sum, nil
+}
+
+type sdkASMDataDigestEncoder struct {
+	hash    hash.Hash
+	scratch [4096]byte
+	used    int
+	structs map[reflect.Type]sdkASMDataDigestStruct
+}
+
+type sdkASMDataDigestStruct struct {
+	name   string
+	fields []sdkASMDataDigestField
+}
+
+type sdkASMDataDigestField struct {
+	index int
+	name  string
+}
+
+// Plans contain immutable, direct type metadata and live for one digest only.
+// Every value, payload and validity check still reads the current state; plans
+// do not retain reflect.Values or recursively build plans for field types.
+func (encoder *sdkASMDataDigestEncoder) structPlan(typ reflect.Type) sdkASMDataDigestStruct {
+	if plan, ok := encoder.structs[typ]; ok {
+		return plan
+	}
+	plan := sdkASMDataDigestStruct{name: typ.String()}
+	for i := 0; i < typ.NumField(); i++ {
+		field := typ.Field(i)
+		if field.PkgPath != "" {
+			continue
+		}
+		name, _, _ := strings.Cut(field.Tag.Get("json"), ",")
+		if name != "-" {
+			plan.fields = append(plan.fields, sdkASMDataDigestField{index: i, name: field.Name})
+		}
+	}
+	if encoder.structs == nil {
+		encoder.structs = make(map[reflect.Type]sdkASMDataDigestStruct)
+	}
+	encoder.structs[typ] = plan
+	return plan
+}
+
+func (encoder *sdkASMDataDigestEncoder) flush() {
+	_, _ = encoder.hash.Write(encoder.scratch[:encoder.used]) // SHA256 writes cannot fail.
+	encoder.used = 0
+}
+
+func (encoder *sdkASMDataDigestEncoder) number(value uint64) {
+	if len(encoder.scratch)-encoder.used < 8 {
+		encoder.flush()
+	}
+	binary.LittleEndian.PutUint64(encoder.scratch[encoder.used:encoder.used+8], value)
+	encoder.used += 8
+}
+
+func (encoder *sdkASMDataDigestEncoder) text(value string) {
+	encoder.number(uint64(len(value)))
+	for len(value) != 0 {
+		if encoder.used == len(encoder.scratch) {
+			encoder.flush()
+		}
+		count := copy(encoder.scratch[encoder.used:], value)
+		encoder.used += count
+		value = value[count:]
+	}
+}
+
+func (encoder *sdkASMDataDigestEncoder) bytes(value []byte) {
+	// Large existing payloads go directly to SHA256; only metadata is buffered.
+	if len(value) > len(encoder.scratch) {
+		encoder.flush()
+		_, _ = encoder.hash.Write(value)
+		return
+	}
+	for len(value) != 0 {
+		if encoder.used == len(encoder.scratch) {
+			encoder.flush()
+		}
+		count := copy(encoder.scratch[encoder.used:], value)
+		encoder.used += count
+		value = value[count:]
+	}
+}
+
+var sdkASMDataDigestTime = reflect.TypeOf(time.Time{})
+var sdkASMDataDigestRawJSON = reflect.TypeOf(json.RawMessage{})
+
+func (encoder *sdkASMDataDigestEncoder) value(value reflect.Value, depth int) error {
+	if depth > 64 || !value.IsValid() {
+		return fmt.Errorf("SDK ASM DATA digest has an invalid or recursive state")
+	}
+	encoder.number(uint64(value.Kind()))
+	if value.Type() == sdkASMDataDigestTime {
+		// Keep time's original JSON role, including its range validation and
+		// exclusion of process-local monotonic clock metadata.
+		raw, err := value.Interface().(time.Time).MarshalJSON()
+		if err != nil {
+			return err
+		}
+		encoder.text(string(raw))
+		return nil
+	}
+	if value.Type() == sdkASMDataDigestRawJSON && !value.IsNil() && !json.Valid(value.Bytes()) {
+		return fmt.Errorf("SDK ASM DATA digest has invalid retained JSON")
+	}
+	switch value.Kind() {
+	case reflect.Bool:
+		var bit uint64
+		if value.Bool() {
+			bit = 1
+		}
+		encoder.number(bit)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		encoder.number(uint64(value.Int()))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		encoder.number(value.Uint())
+	case reflect.String:
+		encoder.text(value.String())
+	case reflect.Ptr, reflect.Map, reflect.Slice:
+		if value.IsNil() {
+			encoder.number(0)
+			return nil
+		}
+		encoder.number(1)
+		if value.Kind() == reflect.Ptr {
+			return encoder.value(value.Elem(), depth+1)
+		}
+		encoder.number(uint64(value.Len()))
+		if value.Kind() == reflect.Slice {
+			if value.Type().Elem().Kind() == reflect.Uint8 {
+				encoder.bytes(value.Bytes())
+				return nil
+			}
+			return encoder.elements(value, depth)
+		}
+		if value.Type().Key().Kind() != reflect.String {
+			return fmt.Errorf("SDK ASM DATA digest has a non-string map key")
+		}
+		keys := value.MapKeys()
+		sort.Slice(keys, func(i, j int) bool { return keys[i].String() < keys[j].String() })
+		for _, key := range keys {
+			encoder.text(key.String())
+			if err := encoder.value(value.MapIndex(key), depth+1); err != nil {
+				return err
+			}
+		}
+	case reflect.Array:
+		encoder.number(uint64(value.Len()))
+		return encoder.elements(value, depth)
+	case reflect.Struct:
+		plan := encoder.structPlan(value.Type())
+		encoder.text(plan.name)
+		for _, field := range plan.fields {
+			encoder.text(field.name)
+			if err := encoder.value(value.Field(field.index), depth+1); err != nil {
+				return err
+			}
+		}
+		encoder.text("") // End this struct independently of its parent's next field.
+	default:
+		return fmt.Errorf("SDK ASM DATA digest has an unsupported state kind: %s", value.Kind())
+	}
+	return nil
+}
+
+func (encoder *sdkASMDataDigestEncoder) elements(value reflect.Value, depth int) error {
+	for i := 0; i < value.Len(); i++ {
+		if err := encoder.value(value.Index(i), depth+1); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/go_x86_sdk_asm_data_digest_bench_go127_test.go b/go_x86_sdk_asm_data_digest_bench_go127_test.go
new file mode 100644
index 000000000..13539f267
--- /dev/null
+++ b/go_x86_sdk_asm_data_digest_bench_go127_test.go
@@ -0,0 +1,92 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"testing"
+	"time"
+)
+
+// Measure only complete encoder calls on one unchanged, real SDK capture per
+// package. Capture, live Verify and teardown are outside all timed intervals.
+// A is the frozen buffered legacy encoder; B is the current production encoder.
+// The ABBA order and shared state avoid recapture paths/timestamps as confounders.
+// This is not a full Verify/translation benchmark or a cached-source fast path.
+func BenchmarkGoX86SDKASMDataDigestActualEncoder(b *testing.B) {
+	for _, pkg := range []string{"internal/cpu", "hash/crc32", "internal/runtime/maps"} {
+		b.Run(pkg, func(b *testing.B) {
+			ctx, request := sdkASMDataRequest(b, "amd64", pkg)
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				b.Fatal("real SDK capture failed before benchmark", err)
+			}
+			b.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					b.Error(err)
+				}
+			})
+			if err := source.Verify(ctx); err != nil {
+				b.Fatal("real SDK preflight verification failed", err)
+			}
+			state := sdkASMDataDigestBenchmarkState(source)
+			want, err := source.digest()
+			if err != nil {
+				b.Fatal(err)
+			}
+			for _, encoder := range []func(any) ([32]byte, error){sdkASMDataDigestLegacy, digestSDKASMDataState} {
+				if got, err := encoder(state); err != nil || got != want {
+					b.Fatal("benchmark state differs from complete live source digest", err)
+				}
+			}
+			b.Logf("package=%s captured-state-sha256=%x", pkg, want)
+			for _, sample := range []struct {
+				name   string
+				encode func(any) ([32]byte, error)
+			}{
+				{"A1-legacy", sdkASMDataDigestLegacy},
+				{"B1-current", digestSDKASMDataState},
+				{"B2-current", digestSDKASMDataState},
+				{"A2-legacy", sdkASMDataDigestLegacy},
+			} {
+				b.Run(sample.name, func(b *testing.B) {
+					b.ReportAllocs()
+					b.ResetTimer()
+					for iteration := 0; iteration < b.N; iteration++ {
+						got, err := sample.encode(state)
+						if err != nil || got != want {
+							b.Fatal("complete current state hash changed", err)
+						}
+					}
+				})
+			}
+			if err := source.Verify(ctx); err != nil {
+				b.Fatal("real SDK postflight verification failed", err)
+			}
+		})
+	}
+}
+
+// Preserve the exact anonymous root type/field order of source.digest. The
+// preflight compares its hash with source.digest, so future schema additions
+// fail instead of quietly shrinking the measured state. Only the wrapper is
+// copied; all current map/slice contents remain the actual capture's contents.
+func sdkASMDataDigestBenchmarkState(source *GoX86SDKASMDataSource) any {
+	return struct {
+		Request           GoX86SDKASMDataCaptureRequest
+		Guard             GoAMD64FrameCaptureRequest
+		Selection         goAMD64FrameSelection
+		Env               map[string]string
+		Imports           map[string]goAMD64FrameSelection
+		Inputs            map[string][32]byte
+		Entries           []string
+		Misses            map[string]bool
+		Observation       sdkASMDataLiveObservation
+		OriginalDeadline  time.Time
+		OriginalProfile   bool
+		CaptureRole       sdkASMDataCaptureRole
+		OriginalConfig    string
+		FrameListingBytes int
+	}{source.request, source.guard.request, source.guard.selection, source.guard.env, source.guard.imports,
+		source.guard.inputs, source.guard.entries, source.misses, source.observation, source.originalDeadline,
+		source.originalProfile, source.captureRole, source.originalConfig, source.frameListingBytes}
+}
diff --git a/go_x86_sdk_asm_data_digest_framing_test.go b/go_x86_sdk_asm_data_digest_framing_test.go
new file mode 100644
index 000000000..4f236616a
--- /dev/null
+++ b/go_x86_sdk_asm_data_digest_framing_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestGoX86SDKASMDataDigestLargeStringTemporaryBytes(t *testing.T) {
+	state, source := sdkASMDataDigestFixture(t)
+	payload := strings.Repeat("MOVQ", 1<<19) // An existing 2 MiB mapped-source role.
+	state.Observation.Positions[0].Mapped = payload
+	state.publish(source)
+	runtime.GC()
+	want, err := source.digest()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var before, after runtime.MemStats
+	runtime.ReadMemStats(&before)
+	var sums [3][32]byte
+	for i := range sums {
+		sums[i], err = source.digest()
+		if err != nil {
+			break
+		}
+	}
+	runtime.ReadMemStats(&after)
+	runtime.KeepAlive(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, sum := range sums {
+		if sum != want {
+			t.Fatal("unchanged mapped source has a nondeterministic digest")
+		}
+	}
+	if allocated := after.TotalAlloc - before.TotalAlloc; allocated > 3<<20 {
+		t.Errorf("three complete digests allocate %d temporary bytes for a string; want <= %d",
+			allocated, uint64(3<<20))
+	}
+	changed := []byte(payload)
+	for _, index := range []int{0, len(payload) / 2, len(payload) - 1} {
+		changed[index] ^= 0x20
+		state.Observation.Positions[0].Mapped = string(changed)
+		state.publish(source)
+		got, digestErr := source.digest()
+		if digestErr != nil || got == want {
+			t.Fatal("current mapped-source mutation escaped the digest", index, digestErr)
+		}
+		changed[index] ^= 0x20
+	}
+}
+
+func TestGoX86SDKASMDataDigestFramingAndMapOrder(t *testing.T) {
+	type fields struct {
+		First, Second string
+		Bytes         []byte
+	}
+	for _, test := range []struct {
+		name          string
+		first, second any
+	}{
+		{"string-partitions", fields{First: "a", Second: "bc"}, fields{First: "ab", Second: "c"}},
+		{"binary-delimiters", fields{First: "a\x00", Bytes: []byte("b")}, fields{First: "a", Bytes: []byte{0, 'b'}}},
+		{"nil-and-empty-bytes", fields{}, fields{Bytes: []byte{}}},
+		{"nil-and-empty-maps", map[string]string(nil), map[string]string{}},
+		{"nil-and-empty-slices", []string(nil), []string{}},
+		{"map-key-value-partitions", map[string]string{"a": "bc"}, map[string]string{"ab": "c"}},
+		{"scalar-kinds", uint64(1), int64(1)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			first, err := digestSDKASMDataState(test.first)
+			if err != nil {
+				t.Fatal(err)
+			}
+			second, err := digestSDKASMDataState(test.second)
+			if err != nil || first == second {
+				t.Fatal("different complete state has an ambiguous digest encoding", err)
+			}
+		})
+	}
+	t.Run("map-order", func(t *testing.T) {
+		first := map[string][]byte{"a": {0, 1}, "b": {2, 3}}
+		second := make(map[string][]byte)
+		second["b"], second["a"] = []byte{2, 3}, []byte{0, 1}
+		want, err := digestSDKASMDataState(first)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for i := 0; i < 8; i++ {
+			got, err := digestSDKASMDataState(second)
+			if err != nil || got != want {
+				t.Fatal("map iteration or insertion order changed the complete state digest", err)
+			}
+		}
+	})
+	t.Run("invalid-state", func(t *testing.T) {
+		type node struct{ Next *node }
+		cycle := &node{}
+		cycle.Next = cycle
+		for _, value := range []any{
+			json.RawMessage("{"), time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC),
+			map[int]string{1: "value"}, func() {}, cycle,
+		} {
+			if _, err := digestSDKASMDataState(value); err == nil {
+				t.Fatal("invalid or unsupported state was silently omitted")
+			}
+		}
+	})
+}
diff --git a/go_x86_sdk_asm_data_digest_reference_test.go b/go_x86_sdk_asm_data_digest_reference_test.go
new file mode 100644
index 000000000..41cfcbfa8
--- /dev/null
+++ b/go_x86_sdk_asm_data_digest_reference_test.go
@@ -0,0 +1,326 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"hash"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+// Freeze the pre-field-plan encoder as an independent test-only reference.
+// Keep its original buffering and per-occurrence reflection for paired encoder
+// benchmarks. It must not call current encoder methods or reuse its field plans.
+// This oracle authenticates serialization bytes, never a live source or lease.
+func sdkASMDataDigestLegacy(state any) ([32]byte, error) {
+	encoder := sdkASMDataDigestLegacyEncoder{hash: sha256.New()}
+	encoder.text("plan9asm.sdk-asm-data-state.v1")
+	if err := encoder.value(reflect.ValueOf(state), 0); err != nil {
+		return [32]byte{}, err
+	}
+	encoder.flush()
+	var sum [32]byte
+	copy(sum[:], encoder.hash.Sum(sum[:0]))
+	return sum, nil
+}
+
+type sdkASMDataDigestLegacyEncoder struct {
+	hash    hash.Hash
+	scratch [4096]byte
+	used    int
+}
+
+func (encoder *sdkASMDataDigestLegacyEncoder) flush() {
+	_, _ = encoder.hash.Write(encoder.scratch[:encoder.used])
+	encoder.used = 0
+}
+
+func (encoder *sdkASMDataDigestLegacyEncoder) number(value uint64) {
+	if len(encoder.scratch)-encoder.used < 8 {
+		encoder.flush()
+	}
+	binary.LittleEndian.PutUint64(encoder.scratch[encoder.used:encoder.used+8], value)
+	encoder.used += 8
+}
+
+func (encoder *sdkASMDataDigestLegacyEncoder) text(value string) {
+	encoder.number(uint64(len(value)))
+	for len(value) != 0 {
+		if encoder.used == len(encoder.scratch) {
+			encoder.flush()
+		}
+		count := copy(encoder.scratch[encoder.used:], value)
+		encoder.used += count
+		value = value[count:]
+	}
+}
+
+func (encoder *sdkASMDataDigestLegacyEncoder) bytes(value []byte) {
+	if len(value) > len(encoder.scratch) {
+		encoder.flush()
+		_, _ = encoder.hash.Write(value)
+		return
+	}
+	for len(value) != 0 {
+		if encoder.used == len(encoder.scratch) {
+			encoder.flush()
+		}
+		count := copy(encoder.scratch[encoder.used:], value)
+		encoder.used += count
+		value = value[count:]
+	}
+}
+
+var sdkASMDataDigestLegacyTime = reflect.TypeOf(time.Time{})
+var sdkASMDataDigestLegacyRawJSON = reflect.TypeOf(json.RawMessage{})
+
+func (encoder *sdkASMDataDigestLegacyEncoder) value(value reflect.Value, depth int) error {
+	if depth > 64 || !value.IsValid() {
+		return fmt.Errorf("SDK ASM DATA digest has an invalid or recursive state")
+	}
+	encoder.number(uint64(value.Kind()))
+	if value.Type() == sdkASMDataDigestLegacyTime {
+		raw, err := value.Interface().(time.Time).MarshalJSON()
+		if err != nil {
+			return err
+		}
+		encoder.text(string(raw))
+		return nil
+	}
+	if value.Type() == sdkASMDataDigestLegacyRawJSON && !value.IsNil() && !json.Valid(value.Bytes()) {
+		return fmt.Errorf("SDK ASM DATA digest has invalid retained JSON")
+	}
+	switch value.Kind() {
+	case reflect.Bool:
+		var bit uint64
+		if value.Bool() {
+			bit = 1
+		}
+		encoder.number(bit)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		encoder.number(uint64(value.Int()))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		encoder.number(value.Uint())
+	case reflect.String:
+		encoder.text(value.String())
+	case reflect.Ptr, reflect.Map, reflect.Slice:
+		if value.IsNil() {
+			encoder.number(0)
+			return nil
+		}
+		encoder.number(1)
+		if value.Kind() == reflect.Ptr {
+			return encoder.value(value.Elem(), depth+1)
+		}
+		encoder.number(uint64(value.Len()))
+		if value.Kind() == reflect.Slice {
+			if value.Type().Elem().Kind() == reflect.Uint8 {
+				encoder.bytes(value.Bytes())
+				return nil
+			}
+			return encoder.elements(value, depth)
+		}
+		if value.Type().Key().Kind() != reflect.String {
+			return fmt.Errorf("SDK ASM DATA digest has a non-string map key")
+		}
+		keys := value.MapKeys()
+		sort.Slice(keys, func(i, j int) bool { return keys[i].String() < keys[j].String() })
+		for _, key := range keys {
+			encoder.text(key.String())
+			if err := encoder.value(value.MapIndex(key), depth+1); err != nil {
+				return err
+			}
+		}
+	case reflect.Array:
+		encoder.number(uint64(value.Len()))
+		return encoder.elements(value, depth)
+	case reflect.Struct:
+		typ := value.Type()
+		encoder.text(typ.String())
+		for i := 0; i < value.NumField(); i++ {
+			field := typ.Field(i)
+			if field.PkgPath != "" || strings.Split(field.Tag.Get("json"), ",")[0] == "-" {
+				continue
+			}
+			encoder.text(field.Name)
+			if err := encoder.value(value.Field(i), depth+1); err != nil {
+				return err
+			}
+		}
+		encoder.text("")
+	default:
+		return fmt.Errorf("SDK ASM DATA digest has an unsupported state kind: %s", value.Kind())
+	}
+	return nil
+}
+
+func (encoder *sdkASMDataDigestLegacyEncoder) elements(value reflect.Value, depth int) error {
+	for i := 0; i < value.Len(); i++ {
+		if err := encoder.value(value.Index(i), depth+1); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type sdkASMDataDigestRecordedHash struct {
+	hash.Hash
+	stream bytes.Buffer
+}
+
+func (record *sdkASMDataDigestRecordedHash) Write(data []byte) (int, error) {
+	_, _ = record.stream.Write(data)
+	return record.Hash.Write(data)
+}
+
+func sdkASMDataDigestReferenceBytes(t *testing.T, state any) ([]byte, [32]byte) {
+	t.Helper()
+	oldRecord := &sdkASMDataDigestRecordedHash{Hash: sha256.New()}
+	old := sdkASMDataDigestLegacyEncoder{hash: oldRecord}
+	old.text("plan9asm.sdk-asm-data-state.v1")
+	if err := old.value(reflect.ValueOf(state), 0); err != nil {
+		t.Fatal("old reference rejected fixture", err)
+	}
+	old.flush()
+	newRecord := &sdkASMDataDigestRecordedHash{Hash: sha256.New()}
+	current := sdkASMDataDigestEncoder{hash: newRecord}
+	current.text("plan9asm.sdk-asm-data-state.v1")
+	if err := current.value(reflect.ValueOf(state), 0); err != nil {
+		t.Fatal("current encoder rejected reference fixture", err)
+	}
+	current.flush()
+	if !bytes.Equal(oldRecord.stream.Bytes(), newRecord.stream.Bytes()) {
+		t.Fatal("current encoder changed complete serialized bytes")
+	}
+	want := sha256.Sum256(oldRecord.stream.Bytes())
+	for _, digest := range []func(any) ([32]byte, error){sdkASMDataDigestLegacy, digestSDKASMDataState} {
+		got, err := digest(state)
+		if err != nil || got != want {
+			t.Fatal("digest disagrees with complete reference stream", err)
+		}
+	}
+	return oldRecord.stream.Bytes(), want
+}
+
+type sdkASMDataDigestGoldenRecord struct {
+	Name    string `json:"renamed,omitempty"`
+	Raw     json.RawMessage
+	Count   *uint32
+	Flags   [2]bool
+	Values  map[string][]byte
+	Ignored string `json:"-,omitempty"`
+	private func()
+}
+
+func TestGoX86SDKASMDataDigestReferenceBytes(t *testing.T) {
+	state, _ := sdkASMDataDigestFixture(t)
+	for _, test := range []struct {
+		name  string
+		value any
+	}{
+		{"complete-schema", *state},
+		{"large-bytes", bytes.Repeat([]byte{0, 0xff, 7}, 3000)},
+		{"large-string", strings.Repeat("MOVQ\x00", 1600)},
+		{"repeated-schema", []sdkCPPPositionToken{{Text: "one"}, {Text: "two"}, {Text: "three"}}},
+		{"time", time.Date(2030, 1, 2, 3, 4, 5, 6, time.UTC)},
+		{"map-nil", map[int]string(nil)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			sdkASMDataDigestReferenceBytes(t, test.value)
+		})
+	}
+}
+
+func TestGoX86SDKASMDataDigestReferenceRejectsInvalidState(t *testing.T) {
+	type node struct{ Next *node }
+	cycle := &node{}
+	cycle.Next = cycle
+	depth64 := reflect.ValueOf(uint8(3))
+	for i := 0; i < 64; i++ {
+		pointer := reflect.New(depth64.Type())
+		pointer.Elem().Set(depth64)
+		depth64 = pointer
+	}
+	sdkASMDataDigestReferenceBytes(t, depth64.Interface())
+	depth65 := reflect.New(depth64.Type())
+	depth65.Elem().Set(depth64)
+	for _, value := range []any{
+		nil, json.RawMessage("{"), time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC),
+		map[int]string{}, func() {}, cycle, depth65.Interface(),
+	} {
+		for _, digest := range []func(any) ([32]byte, error){sdkASMDataDigestLegacy, digestSDKASMDataState} {
+			if _, err := digest(value); err == nil {
+				t.Errorf("invalid state accepted: %T", value)
+			}
+		}
+	}
+}
+
+// Golden streams are literal protocol fixtures, independently framed with
+// little-endian uint64 tags/lengths. They are not regenerated from either Go
+// encoder. Keep the compound Go type and declaration order stable.
+func TestGoX86SDKASMDataDigestGoldenBytes(t *testing.T) {
+	count := uint32(7)
+	compound := sdkASMDataDigestGoldenRecord{
+		Name: "a\x00", Raw: json.RawMessage(`{"k":1}`), Count: &count,
+		Flags: [2]bool{true, false}, Values: map[string][]byte{"b": {}, "a": nil},
+		Ignored: "excluded", private: func() {},
+	}
+	for _, test := range []struct {
+		name, encoded, sum string
+		value              any
+	}{
+		{
+			name: "bool-true", value: true,
+			encoded: "1e00000000000000706c616e3961736d2e73646b2d61736d2d646174612d7374" +
+				"6174652e763101000000000000000100000000000000",
+			sum: "a7ca0cf50980801b48cfde05316093a73ba349f84a1580529cb77e85165e7732",
+		},
+		{
+			name: "nil-bytes", value: []byte(nil),
+			encoded: "1e00000000000000706c616e3961736d2e73646b2d61736d2d646174612d7374" +
+				"6174652e763117000000000000000000000000000000",
+			sum: "1283314f719a9d8efdbe11714dcffeb3e243caa2fdfd8ad0640bb81c08bc0ab6",
+		},
+		{
+			name: "empty-bytes", value: []byte{},
+			encoded: "1e00000000000000706c616e3961736d2e73646b2d61736d2d646174612d7374" +
+				"6174652e7631170000000000000001000000000000000000000000000000",
+			sum: "efd01bacb8219cb04227a6770ed3cd64ee98acc9e302336b93020df80ceb04e2",
+		},
+		{
+			name: "compound", value: compound,
+			encoded: "1e00000000000000706c616e3961736d2e73646b2d61736d2d646174612d7374" +
+				"6174652e763119000000000000002500000000000000706c616e3961736d2e73" +
+				"646b41534d44617461446967657374476f6c64656e5265636f72640400000000" +
+				"0000004e616d6518000000000000000200000000000000610003000000000000" +
+				"005261771700000000000000010000000000000007000000000000007b226b22" +
+				"3a317d0500000000000000436f756e7416000000000000000100000000000000" +
+				"0a0000000000000007000000000000000500000000000000466c616773110000" +
+				"0000000000020000000000000001000000000000000100000000000000010000" +
+				"00000000000000000000000000060000000000000056616c7565731500000000" +
+				"0000000100000000000000020000000000000001000000000000006117000000" +
+				"0000000000000000000000000100000000000000621700000000000000010000" +
+				"000000000000000000000000000000000000000000",
+			sum: "1c6fba47b7b9ab2601df8bcff515c93c9355cda8090e5f1519cddc7888ac6648",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			want, err := hex.DecodeString(test.encoded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			got, sum := sdkASMDataDigestReferenceBytes(t, test.value)
+			if !bytes.Equal(got, want) || fmt.Sprintf("%x", sum) != test.sum {
+				t.Fatal("serialization differs from fixed independent golden")
+			}
+		})
+	}
+}
diff --git a/go_x86_sdk_asm_data_digest_test.go b/go_x86_sdk_asm_data_digest_test.go
new file mode 100644
index 000000000..dc04bd379
--- /dev/null
+++ b/go_x86_sdk_asm_data_digest_test.go
@@ -0,0 +1,272 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"reflect"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// These are pure digest fixtures, not actual SDK captures or authority tokens.
+// None calls Verify, invokes a tool, supplies an initializer or grants memory.
+// The independent state mirrors the complete existing digest input, not just
+// selected large blobs, so an optimization cannot silently omit small fields.
+type sdkASMDataDigestTestState struct {
+	Request           GoX86SDKASMDataCaptureRequest
+	Guard             GoAMD64FrameCaptureRequest
+	Selection         goAMD64FrameSelection
+	Env               map[string]string
+	Imports           map[string]goAMD64FrameSelection
+	Inputs            map[string][32]byte
+	Entries           []string
+	Misses            map[string]bool
+	Observation       sdkASMDataLiveObservation
+	OriginalDeadline  time.Time
+	OriginalProfile   bool
+	CaptureRole       sdkASMDataCaptureRole
+	OriginalConfig    string
+	FrameListingBytes int
+}
+
+func (state *sdkASMDataDigestTestState) publish(source *GoX86SDKASMDataSource) {
+	source.request = state.Request
+	source.guard.request = state.Guard
+	source.guard.selection = state.Selection
+	source.guard.env = state.Env
+	source.guard.imports = state.Imports
+	source.guard.inputs = state.Inputs
+	source.guard.entries = state.Entries
+	source.misses = state.Misses
+	source.observation = state.Observation
+	source.originalDeadline = state.OriginalDeadline
+	source.originalProfile = state.OriginalProfile
+	source.captureRole = state.CaptureRole
+	source.originalConfig = state.OriginalConfig
+	source.frameListingBytes = state.FrameListingBytes
+}
+
+func sdkASMDataDigestSeed(t *testing.T, typ reflect.Type, depth int) reflect.Value {
+	t.Helper()
+	if depth > 32 {
+		t.Fatal("digest fixture schema unexpectedly recurses")
+	}
+	value := reflect.New(typ).Elem()
+	if typ == reflect.TypeOf(time.Time{}) {
+		value.Set(reflect.ValueOf(time.Date(2030, 1, 2, 3, 4, 5, 6, time.UTC)))
+		return value
+	}
+	if typ == reflect.TypeOf(json.RawMessage{}) {
+		value.SetBytes([]byte("{\"fixture\":1}"))
+		return value
+	}
+	if typ == reflect.TypeOf((*GoX86NumericalReadBinding)(nil)) {
+		return value // The input guard must not borrow a numerical capability.
+	}
+	switch typ.Kind() {
+	case reflect.String:
+		value.SetString("seed")
+	case reflect.Bool:
+		value.SetBool(true)
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		value.SetInt(1)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		value.SetUint(1)
+	case reflect.Struct:
+		for i := 0; i < typ.NumField(); i++ {
+			field := typ.Field(i)
+			if field.PkgPath == "" && strings.Split(field.Tag.Get("json"), ",")[0] != "-" {
+				value.Field(i).Set(sdkASMDataDigestSeed(t, field.Type, depth+1))
+			}
+		}
+	case reflect.Ptr:
+		value.Set(reflect.New(typ.Elem()))
+		value.Elem().Set(sdkASMDataDigestSeed(t, typ.Elem(), depth+1))
+	case reflect.Slice:
+		if typ.Elem().Kind() == reflect.Uint8 {
+			value.SetBytes([]byte{0, 1, 2, 254, 255})
+			break
+		}
+		value.Set(reflect.MakeSlice(typ, 1, 1))
+		value.Index(0).Set(sdkASMDataDigestSeed(t, typ.Elem(), depth+1))
+	case reflect.Array:
+		for i := 0; i < typ.Len(); i++ {
+			value.Index(i).Set(sdkASMDataDigestSeed(t, typ.Elem(), depth+1))
+		}
+	case reflect.Map:
+		if typ.Key().Kind() != reflect.String {
+			t.Fatal("unexpected non-string observation map key", typ)
+		}
+		value.Set(reflect.MakeMap(typ))
+		for _, name := range []string{"first", "second"} {
+			key := reflect.New(typ.Key()).Elem()
+			key.SetString(name)
+			value.SetMapIndex(key, sdkASMDataDigestSeed(t, typ.Elem(), depth+1))
+		}
+	default:
+		t.Fatal("unexpected digest fixture field type", typ)
+	}
+	return value
+}
+
+func sdkASMDataDigestFixture(t *testing.T) (*sdkASMDataDigestTestState, *GoX86SDKASMDataSource) {
+	t.Helper()
+	state := sdkASMDataDigestSeed(t, reflect.TypeOf(sdkASMDataDigestTestState{}), 0).
+		Interface().(sdkASMDataDigestTestState)
+	source := &GoX86SDKASMDataSource{guard: newGoOriginalInputGuard(state.Guard)}
+	state.publish(source)
+	return &state, source
+}
+
+func TestGoX86SDKASMDataDigestCompleteMutableState(t *testing.T) {
+	state, source := sdkASMDataDigestFixture(t)
+	original, err := json.Marshal(state)
+	if err != nil {
+		t.Fatal("independent complete fixture is not JSON-representable", err)
+	}
+	want, err := source.digest()
+	if err != nil {
+		t.Fatal("initial complete state digest failed", err)
+	}
+	var document any
+	if err := json.Unmarshal(original, &document); err != nil {
+		t.Fatal(err)
+	}
+	mutations := 0
+	check := func(name string, replace func(any), before any, alternatives []any) {
+		t.Run(name, func(t *testing.T) {
+			defer replace(before)
+			var changed sdkASMDataDigestTestState
+			found := false
+			for _, after := range alternatives {
+				replace(after)
+				raw, encodeErr := json.Marshal(document)
+				if encodeErr != nil {
+					t.Fatal(encodeErr)
+				}
+				changed = sdkASMDataDigestTestState{}
+				if json.Unmarshal(raw, &changed) != nil {
+					continue // Try the actual nullable field's independent JSON kind.
+				}
+				complete, encodeErr := json.Marshal(changed)
+				if encodeErr != nil {
+					t.Fatal(encodeErr)
+				}
+				if !bytes.Equal(complete, original) {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Fatal("mutation did not change a complete typed state field")
+			}
+			changed.publish(source) // Keep the exact same source object: no cached digest.
+			got, digestErr := source.digest()
+			if digestErr != nil || got == want {
+				t.Fatal("complete mutable state was omitted or reused", digestErr)
+			}
+			state.publish(source)
+			restored, digestErr := source.digest()
+			if digestErr != nil || restored != want {
+				t.Fatal("pure digest is not deterministic after restoration", digestErr)
+			}
+			mutations++
+		})
+	}
+	var visit func(string, any, func(any))
+	visit = func(name string, value any, replace func(any)) {
+		switch typed := value.(type) {
+		case map[string]any:
+			check(name+"/empty-object", replace, value, []any{map[string]any{}})
+			keys := make([]string, 0, len(typed))
+			for key := range typed {
+				keys = append(keys, key)
+			}
+			sort.Strings(keys)
+			for _, key := range keys {
+				key := key
+				visit(name+"/"+key, typed[key], func(next any) { typed[key] = next })
+			}
+		case []any:
+			check(name+"/empty-array", replace, value, []any{[]any{}})
+			for i, item := range typed {
+				i := i
+				visit(name+"/"+strconv.Itoa(i), item, func(next any) { typed[i] = next })
+			}
+		case string:
+			next := "QUJD" // Valid base64 for byte fields as well as a new string value.
+			if typed == next {
+				next = "REVG"
+			}
+			if stamp, parseErr := time.Parse(time.RFC3339Nano, typed); parseErr == nil {
+				next = stamp.Add(time.Second).Format(time.RFC3339Nano)
+			}
+			check(name, replace, value, []any{next})
+		case float64:
+			check(name, replace, value, []any{typed + 1})
+		case bool:
+			check(name, replace, value, []any{!typed})
+		case nil:
+			check(name+"/non-null", replace, value,
+				[]any{"QUJD", []any{}, map[string]any{}, float64(1), true})
+		default:
+			t.Fatal("unexpected independent JSON field", name)
+		}
+	}
+	visit("state", document, func(next any) { document = next })
+	if mutations < 100 {
+		t.Fatal("complete observation/schema mutation matrix was not traversed", mutations)
+	}
+}
+
+func TestGoX86SDKASMDataDigestLargePayloadTemporaryBytes(t *testing.T) {
+	state, source := sdkASMDataDigestFixture(t)
+	payload := bytes.Repeat([]byte{0x97, 0x31, 0x00, 0xff}, 1<<19) // One existing 2 MiB compiler-object role.
+	state.Observation.Header.CompilerObject = payload
+	state.publish(source)
+	runtime.GC()
+	want, err := source.digest() // Warm reusable encoder/buffer state outside the measurement.
+	if err != nil {
+		t.Fatal(err)
+	}
+	var before, after runtime.MemStats
+	runtime.ReadMemStats(&before)
+	var sums [3][32]byte
+	for i := range sums {
+		sums[i], err = source.digest()
+		if err != nil {
+			break
+		}
+	}
+	runtime.ReadMemStats(&after)
+	runtime.KeepAlive(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, sum := range sums {
+		if sum != want {
+			t.Fatal("unchanged complete state has a nondeterministic digest")
+		}
+	}
+	// This is an allocation-size regression, not a throughput benchmark or an
+	// execution certificate. Every call must still inspect the current bytes.
+	// Three MiB of total slack allows bounded metadata work and runtime noise,
+	// but not three fresh base64/JSON copies of this single 2 MiB byte field.
+	allocated := after.TotalAlloc - before.TotalAlloc
+	if allocated > 3<<20 {
+		t.Errorf("three complete digests allocate %d temporary bytes; want <= %d without payload-sized JSON copies",
+			allocated, uint64(3<<20))
+	}
+	for _, index := range []int{0, len(payload) / 2, len(payload) - 1} {
+		payload[index] ^= 0x80
+		got, digestErr := source.digest()
+		if digestErr != nil || got == want {
+			t.Fatal("in-place current payload mutation escaped the digest", index, digestErr)
+		}
+		payload[index] ^= 0x80
+	}
+}
diff --git a/go_x86_sdk_asm_data_header.go b/go_x86_sdk_asm_data_header.go
new file mode 100644
index 000000000..e623cef9c
--- /dev/null
+++ b/go_x86_sdk_asm_data_header.go
@@ -0,0 +1,272 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmheader"
+)
+
+type sdkASMDataHeaderObservation struct {
+	LanguageVersion string
+	Definitions     map[string]string
+	Actual, Typed   []byte
+	Canonical       []byte
+	CompilerObject  []byte
+	ImportConfig    []byte
+	SymABI          []byte
+}
+
+func (source *GoX86SDKASMDataSource) artifact(name string, data []byte) (string, error) {
+	file := filepath.Join(source.guard.owned, name)
+	if !filepath.IsLocal(name) || !goAssemblyPathWithinRoot(source.guard.owned, file) {
+		return "", sdkASMDataContext("artifact escaped the private factory directory")
+	}
+	if err := os.WriteFile(file, data, 0600); err != nil {
+		return "", err
+	}
+	if _, err := source.guard.read(file); err != nil {
+		return "", err
+	}
+	return file, nil
+}
+
+func (source *GoX86SDKASMDataSource) asmArguments(include string) []string {
+	args := []string{"tool", "asm", "-p", source.request.PackagePath, "-std", "-I", include,
+		"-I", filepath.Join(source.guard.env["GOROOT"], "pkg", "include")}
+	if source.guard.env["GOOS"] == "darwin" {
+		args = append(args, "-shared")
+	}
+	for _, define := range GoAssemblerDefinesWithEnv(source.guard.env["GOOS"], source.guard.env["GOARCH"], source.guard.env) {
+		args = append(args, "-D", define)
+	}
+	return args
+}
+
+func (source *GoX86SDKASMDataSource) captureHeader(ctx context.Context) error {
+	guard := source.guard
+	stubDirectory := filepath.Join(guard.owned, "symabis-input")
+	if err := os.Mkdir(stubDirectory, 0700); err != nil {
+		return err
+	}
+	if err := source.retainDirectory(stubDirectory); err != nil {
+		return err
+	}
+	if _, err := source.artifact(filepath.Join("symabis-input", "go_asm.h"), nil); err != nil {
+		return err
+	}
+	symabis := filepath.Join(guard.owned, "symabis")
+	args := append(source.asmArguments(stubDirectory), "-gensymabis", "-o", symabis)
+	for _, name := range guard.selection.SFiles {
+		args = append(args, filepath.Join(source.request.Directory, name))
+	}
+	if _, err := source.run(ctx, args...); err != nil {
+		return err
+	}
+	symABI, err := guard.read(symabis)
+	if err != nil {
+		return err
+	}
+
+	config, err := sdkASMDataImportConfig(guard.selection, guard.imports)
+	if err != nil {
+		return err
+	}
+	configFile, err := source.artifact("importcfg", config)
+	if err != nil {
+		return err
+	}
+	headerFile, objectFile := filepath.Join(guard.owned, "go_asm.h"), filepath.Join(guard.owned, "go-header.o")
+	// Stock SDK packages use the invoked toolchain language, not a caller's
+	// go.mod or a self-reported Standard bit. The full actual SDK was bound above.
+	language := "go1.27"
+	args = []string{"tool", "compile", "-p", source.request.PackagePath, "-std", "-lang=" + language,
+		"-goversion", guard.env["GOVERSION"], "-symabis", symabis, "-importcfg", configFile,
+		"-asmhdr", headerFile, "-o", objectFile}
+	if guard.env["GOOS"] == "darwin" {
+		args = append(args, "-shared")
+	}
+	for _, name := range guard.selection.GoFiles {
+		args = append(args, filepath.Join(source.request.Directory, name))
+	}
+	if _, err := source.run(ctx, args...); err != nil {
+		return err
+	}
+	actual, err := guard.read(headerFile)
+	if err != nil {
+		return err
+	}
+	compilerObject, err := guard.read(objectFile)
+	if err != nil || len(compilerObject) == 0 {
+		return sdkASMDataContext("header compiler did not produce a complete object: %v", err)
+	}
+	definitions, err := goasmheader.Definitions(actual)
+	if err != nil {
+		return sdkASMDataContext("actual full generated header is invalid: %v", err)
+	}
+	typed, err := source.typedHeader(language)
+	if err != nil {
+		return err
+	}
+	typedDefinitions, err := goasmheader.Definitions(typed)
+	if err != nil || !reflect.DeepEqual(definitions, typedDefinitions) {
+		return sdkASMDataContext("complete actual and independently typed header definitions differ: %v", err)
+	}
+	canonical, err := goasmheader.Canonical(definitions)
+	if err != nil {
+		return err
+	}
+	source.observation.Header = sdkASMDataHeaderObservation{LanguageVersion: language, Definitions: definitions,
+		Actual: actual, Typed: typed, Canonical: canonical, CompilerObject: compilerObject, ImportConfig: config, SymABI: symABI}
+	return nil
+}
+
+func sdkASMDataImportConfig(selected goAMD64FrameSelection, imports map[string]goAMD64FrameSelection) ([]byte, error) {
+	var config strings.Builder
+	resolved := make(map[string]goAMD64FrameSelection)
+	validPath := func(path string) bool {
+		return path != "" && !strings.ContainsAny(path, "\x00\r\n=\\ \t")
+	}
+	for _, path := range selected.Imports {
+		if path == "unsafe" {
+			continue
+		}
+		mapped := path
+		if target, present := selected.ImportMap[path]; present {
+			mapped = target
+		}
+		dependency, present := imports[mapped]
+		// cmd/compile's readImportCfg splits only at the first '='. The
+		// filename is literal, not a quoted Go string or import path: native
+		// Windows separators, embedded spaces and '=' must remain unchanged.
+		// TrimSpace applies to the whole line, so a trailing filename space
+		// cannot be represented faithfully; newlines/NUL cannot be inputs.
+		if !present || !validPath(path) || !validPath(mapped) ||
+			dependency.Export == "" || strings.ContainsAny(dependency.Export, "\x00\r\n") ||
+			strings.TrimSpace(dependency.Export) != dependency.Export {
+			return nil, sdkASMDataContext("header compiler lacks an exact actual dependency export")
+		}
+		resolved[mapped] = dependency
+	}
+	// cmd/go's Imports can already contain resolved vendored paths while
+	// ImportMap retains the source spellings needed by cmd/compile. Consume
+	// every actual map edge, not only maps keyed by an Imports list entry.
+	var aliases []string
+	for path := range selected.ImportMap {
+		aliases = append(aliases, path)
+	}
+	sort.Strings(aliases)
+	for _, path := range aliases {
+		mapped := selected.ImportMap[path]
+		if !validPath(path) || !validPath(mapped) || resolved[mapped].Export == "" {
+			return nil, sdkASMDataContext("source import-map edge lacks its selected actual export")
+		}
+		if path != mapped {
+			fmt.Fprintf(&config, "importmap %s=%s\n", path, mapped)
+		}
+	}
+	var paths []string
+	for path := range resolved {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	for _, path := range paths {
+		fmt.Fprintf(&config, "packagefile %s=%s\n", path, resolved[path].Export)
+	}
+	return []byte(config.String()), nil
+}
+
+func (source *GoX86SDKASMDataSource) typedHeader(language string) ([]byte, error) {
+	pkg, _, err := source.typecheckPackage(language, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return GoAssemblyHeader(pkg, source.guard.env["GOARCH"])
+}
+
+// Each query constructs private syntax and type objects from the same sealed
+// complete Go bytes and compiler imports. Nothing is accepted from a caller AST.
+func (source *GoX86SDKASMDataSource) typedPackage(language string) (GoPackage, error) {
+	selected := &GoSourceSelection{GoSources: make(map[string][]byte), Assembly: make(map[string]*File),
+		TypesInfo: &types.Info{Types: make(map[ast.Expr]types.TypeAndValue), Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)}}
+	pkg, fset, err := source.typecheckPackage(language, selected.TypesInfo, func(name string, data []byte) {
+		selected.SelectedGoFiles = append(selected.SelectedGoFiles, name)
+		selected.GoSources[name] = append([]byte(nil), data...)
+	})
+	if err != nil {
+		return GoPackage{}, err
+	}
+	selected.Fset, selected.Sizes = fset, types.SizesFor("gc", source.guard.env["GOARCH"])
+	for ordinal, cpp := range source.observation.CPP {
+		if ordinal >= len(source.guard.selection.SFiles) {
+			return GoPackage{}, sdkASMDataContext("observed assembly exceeds its exact selected inventory")
+		}
+		file, err := ParseWithDefines(ArchAMD64, cpp.Output, nil)
+		if err != nil {
+			return GoPackage{}, sdkASMDataContext("complete observed SDK assembly lost its parsed source: %v", err)
+		}
+		name := filepath.Join(source.request.Directory, source.guard.selection.SFiles[ordinal])
+		selected.SelectedAssemblyFiles = append(selected.SelectedAssemblyFiles, name)
+		selected.Assembly[name] = file
+	}
+	pkg.SourceSelection = selected
+	return pkg, nil
+}
+
+// Header observation keeps its original typechecking cost and facts: it does
+// not allocate TypesInfo/source inventories or parse assembly. The distinct
+// typed-body query above collects only the additional facts its consumer needs.
+func (source *GoX86SDKASMDataSource) typecheckPackage(language string, info *types.Info, observeSource func(string, []byte)) (GoPackage, *token.FileSet, error) {
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range source.guard.selection.GoFiles {
+		file := filepath.Join(source.request.Directory, name)
+		data, err := source.guard.read(file)
+		if err != nil {
+			return GoPackage{}, nil, err
+		}
+		parsed, err := parser.ParseFile(fset, file, data, parser.ParseComments)
+		if err != nil {
+			return GoPackage{}, nil, err
+		}
+		syntax = append(syntax, parsed)
+		if observeSource != nil {
+			observeSource(file, data)
+		}
+	}
+	actualImporter := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		if target, mapped := source.guard.selection.ImportMap[path]; mapped {
+			path = target
+		}
+		dependency, present := source.guard.imports[path]
+		if !present || dependency.Export == "" {
+			return nil, sdkASMDataContext("typed header lacks its actual sealed SDK export: %s", path)
+		}
+		data, err := source.guard.read(dependency.Export)
+		if err != nil {
+			return nil, err
+		}
+		return io.NopCloser(bytes.NewReader(data)), nil
+	})
+	sizes := types.SizesFor("gc", source.guard.env["GOARCH"])
+	if sizes == nil {
+		return GoPackage{}, nil, sdkASMDataContext("unknown target compiler layout")
+	}
+	typed, err := (&types.Config{Sizes: sizes, Importer: actualImporter, GoVersion: language}).Check(source.request.PackagePath, fset, syntax, info)
+	if err != nil {
+		return GoPackage{}, nil, sdkASMDataContext("complete original SDK Go sources cannot be independently typed: %v", err)
+	}
+	return GoPackage{Path: source.request.PackagePath, Types: typed, Syntax: syntax}, fset, nil
+}
diff --git a/go_x86_sdk_asm_data_header_test.go b/go_x86_sdk_asm_data_header_test.go
new file mode 100644
index 000000000..a6f4c95be
--- /dev/null
+++ b/go_x86_sdk_asm_data_header_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoX86SDKASMDataImportConfigNativePaths(t *testing.T) {
+	selected := goAMD64FrameSelection{
+		Imports: []string{"unsafe", "old/path"}, ImportMap: map[string]string{"old/path": "actual/path"},
+	}
+	for _, filename := range []string{
+		"/cache with spaces/object.a", `/cache\name/object.a`,
+		`C:\cache with spaces\object.a`, `C:\cache=root\object.a`,
+	} {
+		imports := map[string]goAMD64FrameSelection{"actual/path": {Export: filename}}
+		config, err := sdkASMDataImportConfig(selected, imports)
+		want := "importmap old/path=actual/path\npackagefile actual/path=" + filename + "\n"
+		if err != nil || string(config) != want {
+			t.Fatalf("native export filename %q was not preserved: %q, %v", filename, config, err)
+		}
+	}
+	for _, filename := range []string{"", "missing\npackagefile forged=object.a", "carriage\rreturn", "nul\x00byte", "trailing "} {
+		imports := map[string]goAMD64FrameSelection{"actual/path": {Export: filename}}
+		if _, err := sdkASMDataImportConfig(selected, imports); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("ambiguous or injected config filename %q accepted: %v", filename, err)
+		}
+	}
+	if _, err := sdkASMDataImportConfig(selected, nil); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("missing actual export acquired an import config: %v", err)
+	}
+	for _, path := range []string{"", "wrong=path", "wrong\\path", "wrong\npath", "wrong\x00path", "wrong path"} {
+		selected.Imports = []string{path}
+		imports := map[string]goAMD64FrameSelection{path: {Export: "/cache/object.a"}}
+		if _, err := sdkASMDataImportConfig(selected, imports); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("invalid import path %q accepted: %v", path, err)
+		}
+	}
+}
+
+func TestGoX86SDKASMDataImportConfigResolvedSourceAliases(t *testing.T) {
+	selected := goAMD64FrameSelection{
+		Imports:   []string{"encoding/binary", "vendor/golang.org/x/crypto/internal/alias"},
+		ImportMap: map[string]string{"golang.org/x/crypto/internal/alias": "vendor/golang.org/x/crypto/internal/alias"},
+	}
+	imports := map[string]goAMD64FrameSelection{
+		"encoding/binary": {Export: "/cache/binary.a"},
+		"vendor/golang.org/x/crypto/internal/alias": {Export: "/cache/alias.a"},
+	}
+	config, err := sdkASMDataImportConfig(selected, imports)
+	if err != nil || !strings.Contains(string(config), "importmap golang.org/x/crypto/internal/alias=vendor/golang.org/x/crypto/internal/alias\n") ||
+		!strings.Contains(string(config), "packagefile vendor/golang.org/x/crypto/internal/alias=/cache/alias.a\n") {
+		t.Fatal("compiler lost its original source import after actual Go resolved the selected dependency", string(config), err)
+	}
+	for _, target := range []string{"missing/dependency", "bad\nnamespace", "bad=namespace"} {
+		selected.ImportMap["golang.org/x/crypto/internal/alias"] = target
+		if _, err := sdkASMDataImportConfig(selected, imports); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unobserved source import alias acquired a compiler route", target, err)
+		}
+	}
+}
diff --git a/go_x86_sdk_asm_data_lifecycle_test.go b/go_x86_sdk_asm_data_lifecycle_test.go
new file mode 100644
index 000000000..af69852b7
--- /dev/null
+++ b/go_x86_sdk_asm_data_lifecycle_test.go
@@ -0,0 +1,361 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"regexp"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type sdkASMDataReentrantContext struct {
+	context.Context
+	armed    atomic.Bool
+	callback func()
+	method   string
+	lost     atomic.Bool
+	shift    atomic.Int64
+}
+
+func (ctx *sdkASMDataReentrantContext) Err() error {
+	ctx.call("Err")
+	return ctx.Context.Err()
+}
+
+func (ctx *sdkASMDataReentrantContext) Deadline() (time.Time, bool) {
+	ctx.call("Deadline")
+	if ctx.lost.Load() {
+		return time.Time{}, false
+	}
+	deadline, bounded := ctx.Context.Deadline()
+	return deadline.Add(time.Duration(ctx.shift.Load())), bounded
+}
+
+func (ctx *sdkASMDataReentrantContext) Done() <-chan struct{} {
+	ctx.call("Done")
+	return ctx.Context.Done()
+}
+
+func (ctx *sdkASMDataReentrantContext) call(method string) {
+	if (ctx.method == "" && method == "Err" || ctx.method == method) && ctx.armed.CompareAndSwap(true, false) {
+		ctx.callback()
+	}
+}
+
+func TestGoX86SDKASMDataLiveValidationAPIReentry(t *testing.T) {
+	for _, route := range []string{"verification", "original"} {
+		for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+			t.Run(route+"/"+api, func(t *testing.T) {
+				sdkASMDataCheckIsolatedReentry(t, route, "Err", api)
+			})
+		}
+	}
+}
+
+func TestGoX86SDKASMDataLiveContextMethodReentry(t *testing.T) {
+	for _, route := range []string{"verification", "original"} {
+		for _, method := range []string{"Deadline", "Done"} {
+			for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+				t.Run(route+"/"+method+"/"+api, func(t *testing.T) {
+					sdkASMDataCheckIsolatedReentry(t, route, method, api)
+				})
+			}
+		}
+	}
+}
+
+func sdkASMDataCheckIsolatedReentry(t *testing.T, route, method, api string) {
+	t.Helper()
+	const childKey = "PLAN9ASM_SDK_DATA_REENTRY_CHILD"
+	receipt := "sdk-data-reentry-ok:" + t.Name() + "\n"
+	if os.Getenv(childKey) != t.Name() {
+		// A context cannot interrupt a synchronous callback holding a mutex.
+		// Own a child instead of mistaking slow source verification for deadlock
+		// or leaving an in-process worker blocked during source.Close cleanup.
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		deadline, _ := ctx.Deadline()
+		parts := strings.Split(t.Name(), "/")
+		for index, part := range parts {
+			parts[index] = "^" + regexp.QuoteMeta(part) + "$"
+		}
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run="+strings.Join(parts, "/"),
+			"-test.count=1", "-test.timeout="+(time.Until(deadline)+runtimeOracleStageCleanupReserve).String())
+		command.Env = append(os.Environ(), childKey+"="+t.Name())
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		if err != nil || strings.Count(string(output), receipt) != 1 {
+			t.Fatalf("bounded actual SDK reentry child failed or did not complete: %v\n%s", err, output)
+		}
+		return
+	}
+
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+	reentrant := &sdkASMDataReentrantContext{Context: ctx, method: method}
+	captureContext := ctx
+	if route == "original" {
+		captureContext = reentrant
+	}
+	source, err := CaptureGoX86SDKASMDataSource(captureContext, request)
+	if err != nil {
+		t.Fatal("actual SDK source precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	raw, err := source.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var nested error
+	reentrant.callback = func() {
+		_, nested = sdkASMDataInvoke(t, api, source, ctx, raw)
+	}
+	reentrant.armed.Store(true)
+	if err := errors.Join(source.Verify(reentrant), nested); err != nil {
+		t.Fatal("live original/nested observation failed", err)
+	}
+	if reentrant.armed.Load() {
+		t.Fatal("actual verification did not invoke the context reentry callback")
+	}
+	fmt.Print(receipt)
+}
+
+func TestGoX86SDKASMDataLiveLostOriginalDeadline(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+	original := &sdkASMDataReentrantContext{Context: ctx}
+	source, err := CaptureGoX86SDKASMDataSource(original, request)
+	if err != nil {
+		t.Fatal("actual bounded original source precondition", err)
+	}
+	defer source.Close()
+	original.lost.Store(true)
+	// A fresh caller with a deadline must not restore the original capture
+	// context's lost bounded lifecycle or turn it into a new generation.
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("fresh bounded caller restored a lost original deadline", err)
+	}
+	original.lost.Store(false)
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("restored original deadline revived the failed source")
+	}
+}
+
+func sdkASMDataInvoke(t *testing.T, api string, source *GoX86SDKASMDataSource, ctx context.Context, raw []byte) ([]byte, error) {
+	t.Helper()
+	switch api {
+	case "Verify":
+		return nil, source.Verify(ctx)
+	case "Readback":
+		return source.Readback(ctx)
+	case "CheckReadback":
+		return nil, source.CheckReadback(ctx, raw)
+	default:
+		t.Fatal("unknown observation API", api)
+		return nil, nil
+	}
+}
+
+func TestGoX86SDKASMDataLiveOriginalDeadlineCannotChange(t *testing.T) {
+	for _, change := range []struct {
+		name  string
+		shift time.Duration
+	}{
+		{"earlier", -time.Minute},
+		{"later", time.Minute},
+	} {
+		for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+			t.Run(change.name+"/"+api, func(t *testing.T) {
+				ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+				original := &sdkASMDataReentrantContext{Context: ctx}
+				source, err := CaptureGoX86SDKASMDataSource(original, request)
+				if err != nil {
+					t.Fatal("actual bounded original source precondition", err)
+				}
+				defer source.Close()
+				raw, err := source.Readback(ctx)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				original.shift.Store(int64(change.shift))
+				returned, err := sdkASMDataInvoke(t, api, source, ctx, raw)
+				if !errors.Is(err, ErrProbeNeedsContext) || len(returned) != 0 {
+					t.Fatal("changed bounded original deadline kept its captured generation", err)
+				}
+				original.shift.Store(0)
+				if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("restoring the original deadline revived a revoked source")
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKASMDataLiveOriginalDeadlineCallbackCannotPublish(t *testing.T) {
+	for _, route := range []string{"original", "verification"} {
+		for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+			t.Run(route+"/"+api, func(t *testing.T) {
+				ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+				original := &sdkASMDataReentrantContext{Context: ctx}
+				source, err := CaptureGoX86SDKASMDataSource(original, request)
+				if err != nil {
+					t.Fatal("actual bounded original source precondition", err)
+				}
+				defer source.Close()
+				raw, err := source.Readback(ctx)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				callback := &sdkASMDataReentrantContext{Context: ctx}
+				verification := context.Context(callback)
+				if route == "original" {
+					callback, verification = original, ctx
+				}
+				callback.method = "Done"
+				callback.callback = func() { original.shift.Store(int64(time.Minute)) }
+				callback.armed.Store(true)
+				returned, err := sdkASMDataInvoke(t, api, source, verification, raw)
+				if !errors.Is(err, ErrProbeNeedsContext) || len(returned) != 0 {
+					t.Fatal("context callback published a changed original generation", err)
+				}
+				original.shift.Store(0)
+				if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("restoring callback-mutated deadline revived the source")
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKASMDataLiveCallerDeadlineOnlyTightens(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	for _, kind := range []string{"earlier", "same", "later", "unbounded"} {
+		t.Run(kind, func(t *testing.T) {
+			caller := context.Background()
+			wanted := source.originalDeadline
+			if kind != "unbounded" {
+				deadline := wanted
+				if kind == "earlier" {
+					deadline = deadline.Add(-time.Minute)
+					wanted = deadline
+				} else if kind == "later" {
+					deadline = deadline.Add(time.Minute)
+				}
+				bounded, cancel := context.WithDeadline(caller, deadline)
+				defer cancel()
+				caller = bounded
+			}
+			private, stop, err := sdkASMDataPrivateContext(caller, ctx, source.originalDeadline)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer stop()
+			actual, bounded := private.Deadline()
+			if !bounded || !actual.Equal(wanted) {
+				t.Fatal("caller extended or replaced the captured deadline", actual, wanted)
+			}
+			if err := source.Verify(caller); err != nil {
+				t.Fatal("unchanged original generation rejected a caller deadline", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKASMDataLiveCloseDuringContextCallback(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	owned := source.guard.owned
+	var nested error
+	reentrant := &sdkASMDataReentrantContext{Context: ctx, callback: func() {
+		nested = source.Close()
+		if _, err := os.Stat(owned); err != nil {
+			nested = errors.Join(nested, fmt.Errorf("active lease lost its artifact owner: %w", err))
+		}
+	}}
+	reentrant.armed.Store(true)
+	if err := source.Verify(reentrant); !errors.Is(err, ErrProbeNeedsContext) || nested != nil {
+		t.Fatal("reentrant Close published a stale observation or lost active artifacts", err, nested)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("last active lease did not dispose closed artifacts", err)
+	}
+}
+
+func TestGoX86SDKASMDataLiveConcurrentVerifyAndClose(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	var group sync.WaitGroup
+	errorsOut := make(chan error, 4)
+	for range 4 {
+		group.Add(1)
+		go func() {
+			defer group.Done()
+			errorsOut <- source.Verify(ctx)
+		}()
+	}
+	group.Wait()
+	close(errorsOut)
+	for err := range errorsOut {
+		if err != nil {
+			t.Fatal("ordinary concurrent Verify was spuriously revoked", err)
+		}
+	}
+	entered, resume := make(chan struct{}), make(chan struct{})
+	reentrant := &sdkASMDataReentrantContext{Context: ctx, callback: func() {
+		close(entered)
+		<-resume
+	}}
+	reentrant.armed.Store(true)
+	done := make(chan error, 1)
+	go func() { done <- source.Verify(reentrant) }()
+	<-entered
+	owned := source.guard.owned
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); err != nil {
+		t.Fatal("concurrent Close disposed active callback inputs", err)
+	}
+	close(resume)
+	if err := <-done; !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("concurrent Close published a source from a stale generation", err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("concurrent Close retained its closed artifact directory", err)
+	}
+}
+
+func TestGoX86SDKASMDataLiveContextCauses(t *testing.T) {
+	for _, cause := range []string{"cancel", "deadline", "nil"} {
+		t.Run(cause, func(t *testing.T) {
+			ctx, source := sdkASMDataCapture(t)
+			verification := context.Context(nil)
+			want := ErrProbeNeedsContext
+			if cause == "cancel" {
+				cancelled, cancel := context.WithCancel(ctx)
+				cancel()
+				verification, want = cancelled, context.Canceled
+			} else if cause == "deadline" {
+				expired, cancel := context.WithDeadline(ctx, time.Now().Add(-time.Second))
+				defer cancel()
+				verification, want = expired, context.DeadlineExceeded
+			}
+			if err := source.Verify(verification); !errors.Is(err, want) ||
+				cause != "nil" && errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("verification lost actual context cause", err)
+			}
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("fresh context revived a permanently failed observation")
+			}
+		})
+	}
+}
diff --git a/go_x86_sdk_asm_data_live_test.go b/go_x86_sdk_asm_data_live_test.go
new file mode 100644
index 000000000..95b436c45
--- /dev/null
+++ b/go_x86_sdk_asm_data_live_test.go
@@ -0,0 +1,273 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This test-only RED asks the existing producer to observe the complete real
+// SDK package. Its r2r1 Context is the class boundary the separate observation
+// producer must cross, without granting the existing producer read authority.
+func TestGoX86SDKASMDataLiveOriginalCRC32Red(t *testing.T) {
+	ctx, request, _ := numericalSDKCRC32Request(t)
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if source != nil {
+		defer source.Close()
+	}
+	if source != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "r2r1") {
+		t.Fatal("existing read producer lost its independent DATA boundary", err)
+	}
+	live, err := CaptureGoX86SDKASMDataSource(ctx, GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment})
+	if err != nil {
+		t.Fatal("actual original SDK DATA observation is not closed", err)
+	}
+	t.Cleanup(func() { live.Close() })
+	if len(live.observation.Objects.Sources) != 1 || len(live.observation.Objects.Sources[0].ExpandedLayouts) != 4 {
+		t.Fatal("complete real CRC32 private DATA observation is absent")
+	}
+	sdkASMDataRetain(t, live)
+}
+
+func sdkASMDataRequest(t testing.TB, arch, pkg string) (context.Context, GoX86SDKASMDataCaptureRequest) {
+	t.Helper()
+	_, profile, _, _ := numericalSBFixture(t, arch)
+	ctx, cancel := runtimeOracleProofContext(t)
+	t.Cleanup(cancel)
+	return ctx, GoX86SDKASMDataCaptureRequest{GoBinary: profile.GoBinary,
+		Directory:   filepath.Join(filepath.Dir(filepath.Dir(profile.GoBinary)), "src", filepath.FromSlash(pkg)),
+		PackagePath: pkg, Target: profile.Target, Environment: profile.Environment}
+}
+
+func sdkASMDataCapture(t *testing.T) (context.Context, *GoX86SDKASMDataSource) {
+	t.Helper()
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual finite SDK observation precondition", err)
+	}
+	t.Cleanup(func() { source.Close() })
+	return ctx, source
+}
+
+func sdkASMDataRetain(t *testing.T, source *GoX86SDKASMDataSource) {
+	t.Helper()
+	raw, err := source.Readback(source.context)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if folder := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); folder != "" {
+		name := strings.ReplaceAll(t.Name(), "/", "-")
+		if err := os.MkdirAll(folder, 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(folder, name+".sdk-data-live.json"), raw, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestGoX86SDKASMDataLiveTwoTargets(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, arch, "internal/cpu")
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			if source.guard.ready || source.guard.request.NumericalReads != nil ||
+				source.observation.Objects.Protocol != gostaticstorage.ASMDataCPPProtocol ||
+				len(source.observation.Header.Definitions) == 0 || len(source.observation.CPP) != len(source.guard.selection.SFiles) {
+				t.Fatal("live observation omitted complete SDK/header inputs or granted another role")
+			}
+			for index, observed := range source.observation.Objects.Sources {
+				input := source.observation.ObjectInputs.Sources[index]
+				if observed.OriginalProgramSHA256 != "" || observed.Layouts != nil ||
+					!bytes.Equal(input.Expanded, []byte(source.observation.CPP[index].Output)) || bytes.Equal(input.Original, input.Expanded) {
+					t.Fatal("raw bytes were presented as a token-program certificate")
+				}
+			}
+			if _, err := gostaticstorage.ObserveX86SDKASMData(source.observation.ObjectInputs); !errors.Is(err, gostaticstorage.ErrContext) {
+				t.Fatal("old offline token-equal API admitted CPP/header input", err)
+			}
+			for _, name := range []string{"BindNumericalReads", "Bind", "Options", "GoPackage", "Owners"} {
+				if _, present := reflect.TypeOf(source).MethodByName(name); present {
+					t.Fatal("observation API gained an authority handoff", name)
+				}
+			}
+			sdkASMDataRetain(t, source)
+		})
+	}
+}
+
+func TestGoX86SDKASMDataLiveSealedInputs(t *testing.T) {
+	cases := []struct {
+		name   string
+		mutate func(*GoX86SDKASMDataSource)
+	}{
+		{"target", func(s *GoX86SDKASMDataSource) { s.request.Target = "linux/386" }},
+		{"package", func(s *GoX86SDKASMDataSource) { s.request.PackagePath = "hash/crc32" }},
+		{"guard target", func(s *GoX86SDKASMDataSource) { s.guard.request.Target = "linux/386" }},
+		{"environment", func(s *GoX86SDKASMDataSource) { s.request.Environment = append(s.request.Environment, "GOFLAGS=-N") }},
+		{"source selection", func(s *GoX86SDKASMDataSource) { s.guard.selection.GoFiles = s.guard.selection.GoFiles[:1] }},
+		{"member ordinal", func(s *GoX86SDKASMDataSource) { s.observation.Objects.Members[2].Ordinal++ }},
+		{"object index", func(s *GoX86SDKASMDataSource) {
+			members := s.observation.Objects.Members
+			members[len(members)-1].Texts[0].Index++
+		}},
+		{"original ASM", func(s *GoX86SDKASMDataSource) { s.observation.ObjectInputs.Sources[0].Original[0] ^= 1 }},
+		{"expanded ASM", func(s *GoX86SDKASMDataSource) {
+			inputs := s.observation.ObjectInputs.Sources
+			inputs[len(inputs)-1].Expanded[0] ^= 1
+		}},
+		{"original object", func(s *GoX86SDKASMDataSource) { s.observation.ObjectInputs.Sources[0].OriginalObject[0] ^= 1 }},
+		{"expanded object", func(s *GoX86SDKASMDataSource) { s.observation.ObjectInputs.Sources[0].ExpandedObject[0] ^= 1 }},
+		{"header", func(s *GoX86SDKASMDataSource) { s.observation.Header.Actual[0] ^= 1 }},
+		{"unused definition", func(s *GoX86SDKASMDataSource) { s.observation.Header.Definitions["unused_foreign"] = "17" }},
+		{"CPP event", func(s *GoX86SDKASMDataSource) {
+			cpp := s.observation.CPP
+			cpp[len(cpp)-1].Events[0].Ordinal++
+		}},
+		{"position physical source", func(s *GoX86SDKASMDataSource) {
+			positions := s.observation.Positions
+			positions[len(positions)-1].Tokens[0].Position.File += ".foreign"
+		}},
+		{"position logical filename", func(s *GoX86SDKASMDataSource) {
+			positions := s.observation.Positions
+			positions[len(positions)-1].Tokens[0].Position.FinalBase.File += ".foreign"
+		}},
+		{"position raw line", func(s *GoX86SDKASMDataSource) {
+			positions := s.observation.Positions
+			positions[len(positions)-1].Tokens[0].Position.Line++
+		}},
+		{"position pragma line", func(s *GoX86SDKASMDataSource) {
+			positions := s.observation.Positions
+			positions[len(positions)-1].Tokens[0].Position.Base.Line++
+		}},
+		{"position lineage", func(s *GoX86SDKASMDataSource) {
+			positions := s.observation.Positions
+			positions[len(positions)-1].Tokens[0].Position.Include++
+		}},
+		{"mapped bytes", func(s *GoX86SDKASMDataSource) { s.observation.Positions[0].Mapped += "\n" }},
+		{"ImportMap", func(s *GoX86SDKASMDataSource) { s.guard.selection.ImportMap = map[string]string{"unsafe": "foreign"} }},
+		{"export", func(s *GoX86SDKASMDataSource) { s.guard.selection.Export += ".foreign" }},
+		{"archive", func(s *GoX86SDKASMDataSource) { s.observation.ObjectInputs.Archive[0] ^= 1 }},
+		{"report", func(s *GoX86SDKASMDataSource) { s.report[0] ^= 1 }},
+		{"context identity", func(s *GoX86SDKASMDataSource) { s.context = context.Background() }},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			ctx, source := sdkASMDataCapture(t)
+			test.mutate(source)
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed source/header/CPP/object role verified", err)
+			}
+			if source.ready || !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("failed observation revived")
+			}
+		})
+	}
+}
+
+func TestGoX86SDKASMDataLivePhysicalHeaderTOCTOU(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	file := filepath.Join(source.guard.owned, "go_asm.h")
+	original, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(file, append(original, []byte("#define unused_foreign 17\n")...), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("actual physical header mutation verified", err)
+	}
+	if err := os.WriteFile(file, original, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restored physical input revived revoked source", err)
+	}
+}
+
+func TestGoX86SDKASMDataLiveCopyCloseAndReadback(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	copy := reflect.New(reflect.TypeOf(source).Elem())
+	copy.Elem().Set(reflect.ValueOf(source).Elem())
+	copied := copy.Interface().(*GoX86SDKASMDataSource)
+	owned := source.guard.owned
+	if !errors.Is(copied.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(copied.Close(), ErrProbeNeedsContext) {
+		t.Fatal("copied source borrowed live identity or deleted original artifacts")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("copy failure revoked the actual original", err)
+	}
+	if _, err := os.Stat(owned); err != nil {
+		t.Fatal("copy disposed original artifacts", err)
+	}
+	raw, err := source.Readback(ctx)
+	if err != nil || source.CheckReadback(ctx, raw) != nil {
+		t.Fatal("actual original report cannot be checked", err)
+	}
+	if source.CheckReadback(ctx, append(raw, ' ')) == nil || source.ready {
+		t.Fatal("modified readback verified or failed verification was not permanent")
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("original Close did not dispose its own artifact directory", err)
+	}
+}
+
+func TestGoX86SDKASMDataLiveOriginalCancellation(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/cpu")
+	captured, cancel := context.WithCancel(ctx)
+	source, err := CaptureGoX86SDKASMDataSource(captured, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	cancel()
+	if err := source.Verify(ctx); !errors.Is(err, context.Canceled) || errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("fresh context revived original cancelled capture or lost cause", err)
+	}
+	if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("cancelled source revived")
+	}
+	expired, stop := context.WithDeadline(ctx, time.Now().Add(-time.Second))
+	defer stop()
+	if source, err := CaptureGoX86SDKASMDataSource(expired, request); source != nil || !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatal("expired capture launched or lost deadline cause", err)
+	}
+}
+
+func TestGoX86SDKASMDataLiveOwnedAndTargetRoles(t *testing.T) {
+	_, owned, _, _ := numericalSBFixture(t, "amd64")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	request := GoX86SDKASMDataCaptureRequest{GoBinary: owned.GoBinary, Directory: owned.Directory,
+		PackagePath: "example.invalid/numericalfixture", Target: owned.Target, Environment: owned.Environment}
+	if source, err := CaptureGoX86SDKASMDataSource(ctx, request); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("owned-main source borrowed the explicit SDK role", err)
+	}
+	for _, target := range []string{"windows/amd64", "darwin/amd64", "linux/arm64", "linux/arm", "js/wasm"} {
+		request.Target = target
+		if source, err := CaptureGoX86SDKASMDataSource(ctx, request); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unregistered SDK object target admitted", target, err)
+		}
+	}
+}
diff --git a/go_x86_sdk_asm_data_namespace_go127_test.go b/go_x86_sdk_asm_data_namespace_go127_test.go
new file mode 100644
index 000000000..e5b32e276
--- /dev/null
+++ b/go_x86_sdk_asm_data_namespace_go127_test.go
@@ -0,0 +1,88 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestGoX86SDKASMDataOriginalVendorPackageNamespace(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "vendor/golang.org/x/crypto/chacha20poly1305")
+	const assembly = "chacha20poly1305_amd64.s"
+	filename := filepath.Join(request.Directory, assembly)
+	original, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete original vendored SDK namespace", err)
+	}
+	defer data.Close()
+	cpp, positions := data.observation.CPP[0], data.observation.Positions[0]
+	var eventTokens, positionBytes, eventBytes, sourceBytes, pathBytes int
+	paths := make(map[string]bool)
+	path := func(file string) {
+		if !paths[file] {
+			paths[file] = true
+			pathBytes += len(file)
+		}
+	}
+	for _, event := range cpp.Events {
+		path(event.Position.File)
+		path(event.Included)
+		eventTokens += len(event.Tokens)
+		for _, token := range event.Tokens {
+			eventBytes += len(token.Text) + len(token.RecordedValue)
+			path(token.Position.File)
+		}
+	}
+	for _, token := range positions.Tokens {
+		positionBytes += len(token.Text)
+		path(token.Position.File)
+		path(token.Position.Base.File)
+		path(token.Position.FinalBase.File)
+	}
+	for _, source := range cpp.Sources {
+		sourceBytes += source.Bytes
+		path(source.File)
+	}
+	used := eventBytes + positionBytes + pathBytes + len(positions.Mapped)
+	t.Logf("complete CPP payload bytes: original=%d sources=%d event=%d position=%d paths=%d mapped=%d used=%d/%d; tokens=%d+%d/%d",
+		len(original), sourceBytes, eventBytes, positionBytes, pathBytes, len(positions.Mapped), used, ppGoObservationBytes,
+		eventTokens, len(positions.Tokens), ppGoObservationTokens)
+	if used > ppGoObservationBytes || eventTokens+len(positions.Tokens) > ppGoObservationTokens {
+		t.Fatal("complete SDK position observation escaped its unchanged shared budget")
+	}
+	if data.guard.selection.ImportPath != request.PackagePath || !data.guard.selection.Standard ||
+		data.guard.selection.Module != nil || len(data.observation.ObjectInputs.Sources) != 1 ||
+		data.observation.ObjectInputs.Sources[0].Name != assembly ||
+		!bytes.Equal(data.observation.ObjectInputs.Sources[0].Original, original) ||
+		len(data.observation.Objects.Sources[0].Original.Texts) != 3 {
+		t.Fatal("selected original Go/whole ASM namespace changed or cropped")
+	}
+	for _, command := range data.observation.Commands {
+		if len(command.Arguments) > 0 && command.Arguments[0] == "list" && command.Arguments[len(command.Arguments)-1] != request.PackagePath {
+			t.Fatal("SDK package query borrowed a CWD module namespace", command.Arguments)
+		}
+	}
+	if err := data.Verify(ctx); err != nil {
+		t.Fatal("live complete original vendor source", err)
+	}
+	request.PackagePath = "std/" + request.PackagePath
+	bad, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if bad != nil {
+		bad.Close()
+	}
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("SDK-looking namespace alias acquired actual original source", err)
+	}
+	after, err := os.ReadFile(filename)
+	if err != nil || !bytes.Equal(after, original) {
+		t.Fatal("original SDK source was changed", err)
+	}
+}
diff --git a/go_x86_sdk_asm_data_positions_test.go b/go_x86_sdk_asm_data_positions_test.go
new file mode 100644
index 000000000..b456d247c
--- /dev/null
+++ b/go_x86_sdk_asm_data_positions_test.go
@@ -0,0 +1,243 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Explicit -std flags here exercise the offline decoder only. This owned
+// first-party fixture is never passed off as a live authenticated SDK source.
+func TestGoX86SDKASMDataCPPPositionFirstParty(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			sdkASMDataPositionFirstParty(t, arch, nil, nil)
+		})
+	}
+}
+
+func sdkASMDataPositionFirstParty(t *testing.T, arch string, replacement, headerSource []byte) {
+	t.Helper()
+	pkg, profile, _, _ := numericalSBFixture(t, arch)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	raw := []byte(`#include "textflag.h"
+#include "go_asm.h"
+#include "position.h"
+
+// Discarding this line changes compiler debug metadata, not just diagnostics.
+TEXT ·Feature(SB),NOSPLIT,$0-1
+INNER(const_Value)
+#line 73 "logical-one.s"
+MOVB AX,ret+0(FP)
+#ifdef ABSENT
+#line 137 "logical-inactive.s"
+#endif
+RET
+DATA table<>(SB)/4,$const_Value
+GLOBL table<>(SB),RODATA,$4
+`)
+	if replacement != nil {
+		raw = replacement
+	}
+	if headerSource == nil {
+		headerSource = []byte("#define INNER(v) MOVL $v,AX\n")
+	}
+	goSource := []byte("package numericalfixture\nconst Value=7\nfunc Feature() byte\n")
+	for name, data := range map[string][]byte{"value.go": goSource, profile.AssemblyFile: raw,
+		"position.h": headerSource} {
+		if err := os.WriteFile(filepath.Join(profile.Directory, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	selection, err := goasmcmd.Run(ctx, profile.Directory, profile.Environment, profile.GoBinary,
+		"list", "-compiled", "-export", "-json", "-gcflags=-std", "-asmflags=-std", ".")
+	if err != nil {
+		t.Fatal("actual complete first-party Go/ASM", err)
+	}
+	var selected goAMD64FrameSelection
+	if json.Unmarshal(selection, &selected) != nil || selected.Standard || len(selected.SFiles) != 1 {
+		t.Fatal("test -std flags changed source identity or complete member selection")
+	}
+	read := func(file string) []byte {
+		data, err := os.ReadFile(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return data
+	}
+	root := filepath.Dir(filepath.Dir(profile.GoBinary))
+	header := filepath.Join(profile.Directory, "go_asm.h")
+	if _, err := goasmcmd.Run(ctx, profile.Directory, profile.Environment, profile.GoBinary,
+		"tool", "compile", "-std", "-p", pkg.Path, "-asmhdr", header,
+		"-o", filepath.Join(profile.Directory, "header.o"), filepath.Join(profile.Directory, "value.go")); err != nil {
+		t.Fatal(err)
+	}
+	cpp, positions, err := observeSDKAssemblyCPP(string(raw), AssemblyPreprocessOptions{
+		FileName: filepath.Join(profile.Directory, profile.AssemblyFile),
+		Defines:  GoAssemblerDefinesWithEnv("linux", arch, map[string]string{"GO386": "sse2", "GOAMD64": "v1"}),
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			file := filepath.Join(profile.Directory, name)
+			if _, err := os.Stat(file); os.IsNotExist(err) {
+				file = filepath.Join(root, "pkg", "include", name)
+			}
+			return file, read(file), nil
+		}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded := filepath.Join(profile.Directory, "expanded.asm")
+	if err := os.WriteFile(expanded, []byte(positions.Mapped), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input := gostaticstorage.SDKASMDataSource{Name: profile.AssemblyFile, Original: raw, Expanded: []byte(cpp.Output)}
+	for _, role := range []string{"original", "expanded"} {
+		file := filepath.Join(profile.Directory, profile.AssemblyFile)
+		if role == "expanded" {
+			file = expanded
+		}
+		object := filepath.Join(profile.Directory, role+".o")
+		args := []string{"tool", "asm", "-std", "-p", pkg.Path, "-I", profile.Directory,
+			"-I", filepath.Join(root, "pkg", "include"), "-o", object, file}
+		if _, err := goasmcmd.Run(ctx, profile.Directory, profile.Environment, profile.GoBinary, args...); err != nil {
+			t.Fatal(err)
+		}
+		if role == "original" {
+			input.OriginalObject = read(object)
+		} else {
+			input.ExpandedObject = read(object)
+		}
+	}
+	request := gostaticstorage.SDKASMDataObservationRequest{PackagePath: pkg.Path, Target: profile.Target,
+		Archive: read(selected.Export), BuiltinSource: read(filepath.Join(root, "src", "cmd", "internal", "goobj", "builtinlist.go")),
+		Sources: []gostaticstorage.SDKASMDataSource{input}}
+	scratch := &GoX86SDKASMDataSource{observation: sdkASMDataLiveObservation{Request: GoX86SDKASMDataCaptureRequest{
+		GoBinary: profile.GoBinary, Directory: profile.Directory, PackagePath: pkg.Path,
+		Target: profile.Target, Environment: profile.Environment}, ObjectInputs: request,
+		CPP: []AssemblyCPPObservation{cpp}, Positions: []sdkCPPPositionObservation{positions},
+		Header: sdkASMDataHeaderObservation{Actual: read(header), CompilerObject: read(filepath.Join(profile.Directory, "header.o"))}}}
+	sdkASMDataDiagnosticRetain(t, scratch)
+	if folder := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); folder != "" {
+		// Actual first-party physical inputs outlive t.TempDir only as query
+		// evidence. They do not construct or impersonate a live SDK source.
+		inputs := map[string][]byte{filepath.Join(profile.Directory, "value.go"): goSource}
+		for _, source := range cpp.Sources {
+			inputs[source.File] = read(source.File)
+		}
+		raw, err := json.Marshal(inputs)
+		if err != nil {
+			t.Fatal(err)
+		}
+		name := "sdk-data-first-party-inputs-" + strings.ReplaceAll(t.Name(), "/", "-") + ".json"
+		if err := os.WriteFile(filepath.Join(folder, name), raw, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if _, err := gostaticstorage.ObserveX86SDKCPPASMData(request); err != nil {
+		t.Fatal("complete first-party source/header/macro/lineage object join is not closed", err)
+	}
+	if replacement == nil {
+		for _, mutation := range []string{"filename", "line"} {
+			mapped := positions.Mapped
+			if mutation == "filename" {
+				// Logical metadata must remain part of complete object equality,
+				// even when the emitted machine grammar is byte-identical.
+				mapped = strings.ReplaceAll(mapped, profile.AssemblyFile, "foreign-logical.s")
+			} else {
+				var changed strings.Builder
+				for _, line := range strings.Split(mapped, "\n") {
+					if strings.HasPrefix(line, "#line ") {
+						var value uint
+						if _, err := fmt.Sscanf(line, "#line %d", &value); err != nil {
+							t.Fatal(err)
+						}
+						line = strings.Replace(line, fmt.Sprint(value), fmt.Sprint(value+1), 1)
+					}
+					changed.WriteString(line)
+					changed.WriteByte('\n')
+				}
+				mapped = changed.String()
+			}
+			replay, err := preprocessGoAssembly(mapped, AssemblyPreprocessOptions{})
+			if err != nil || replay != cpp.Output {
+				t.Fatal("metadata-only mutation changed machine grammar", mutation, err)
+			}
+			file := filepath.Join(profile.Directory, "changed-"+mutation+".asm")
+			if err := os.WriteFile(file, []byte(mapped), 0600); err != nil {
+				t.Fatal(err)
+			}
+			object := filepath.Join(profile.Directory, "changed-"+mutation+".o")
+			if _, err := goasmcmd.Run(ctx, profile.Directory, profile.Environment, profile.GoBinary,
+				"tool", "asm", "-std", "-p", pkg.Path, "-o", object, file); err != nil {
+				t.Fatal(err)
+			}
+			changed := request
+			changed.Sources = append([]gostaticstorage.SDKASMDataSource(nil), request.Sources...)
+			changed.Sources[0].ExpandedObject = read(object)
+			changedObservation := scratch.observation
+			changedObservation.ObjectInputs = changed
+			changedObservation.Positions = []sdkCPPPositionObservation{{Mapped: mapped}}
+			sdkASMDataDiagnosticRetainNamed(t, "-mutation-"+mutation,
+				&GoX86SDKASMDataSource{observation: changedObservation})
+			if _, err := gostaticstorage.ObserveX86SDKCPPASMData(changed); !errors.Is(err, gostaticstorage.ErrContext) {
+				t.Fatal("anonymous DATA/TEXT metadata mutation was normalized away", mutation, err)
+			}
+		}
+	}
+}
+
+func TestGoX86SDKASMDataCPPPositionObjectFamilies(t *testing.T) {
+	cases := []struct {
+		name, raw, header string
+	}{
+		{"labels and semicolons", `#include "textflag.h"
+TEXT ·Feature(SB),NOSPLIT,$0-1
+start: NOP; MOVL $7,AX
+MOVB AX,ret+0(FP)
+RET
+`, ""},
+		{"included body and parent final base", `#include "textflag.h"
+#include "position.h"
+
+`, "TEXT ·Feature(SB),NOSPLIT,$0-1\nMOVL $7,AX\nMOVB AX,ret+0(FP)\nRET"},
+		{"nested macro invocation", `#include "textflag.h"
+#include "position.h"
+/* multi-line
+   physical comment */
+TEXT ·Feature(SB),NOSPLIT,$0-1
+OUTER(7)
+MOVB AX,ret+0(FP)
+RET
+`, "#define INNER(v) MOVL $v,AX\n#define OUTER(v) INNER(v)\n"},
+		{"active and inactive filename line", `#include "textflag.h"
+#line 17 "active-logical.s"
+TEXT ·Feature(SB),NOSPLIT,$0-1
+MOVL $7,AX
+#ifdef ABSENT
+#line 131 "inactive-logical.s"
+#endif
+MOVB AX,ret+0(FP)
+RET
+`, ""},
+		{"zero statements", "#include \"textflag.h\"\n// no machine statements\n", ""},
+		{"empty TEXT body", "#include \"textflag.h\"\nTEXT ·Feature(SB),NOSPLIT,$0-1\n", ""},
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			for _, test := range cases {
+				t.Run(test.name, func(t *testing.T) {
+					sdkASMDataPositionFirstParty(t, arch, []byte(test.raw), []byte(test.header))
+				})
+			}
+		})
+	}
+}
diff --git a/go_x86_sdk_asm_data_relative_include_go127_test.go b/go_x86_sdk_asm_data_relative_include_go127_test.go
new file mode 100644
index 000000000..c395fb445
--- /dev/null
+++ b/go_x86_sdk_asm_data_relative_include_go127_test.go
@@ -0,0 +1,338 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This is an unpublished CPP-stage query of original SDK bytes. The owned
+// empty go_asm.h is explicitly NOT a compiler artifact or a Go layout proof.
+// Missing live context stops captureAssembly before it can run any Go tool.
+// Complete real generated-header/object validation remains a separate gate.
+func TestSDKX86RelativeIncludeActualRuntimeCPPQuery(t *testing.T) {
+	root, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	version, err := os.ReadFile(filepath.Join(root, "VERSION"))
+	if err != nil {
+		t.Fatal("actual SDK version is required", err)
+	}
+	header := filepath.Join(root, "src", "runtime", "cgo", "abi_amd64.h")
+	headerBytes, err := os.ReadFile(header)
+	if err != nil {
+		t.Fatalf("this CPP owner requires the actual SDK header; version=%q: %v", version, err)
+	}
+	owned, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(owned, "go_asm.h"),
+		[]byte("// CPP query placeholder; never compiler-generated layout evidence.\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	request := GoX86SDKASMDataCaptureRequest{
+		Directory:   filepath.Join(root, "src", "runtime"),
+		PackagePath: "runtime", Target: "linux/amd64",
+	}
+	source := &GoX86SDKASMDataSource{
+		request:     request,
+		guard:       newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: request.Directory}),
+		directories: make(map[string]os.FileInfo), misses: make(map[string]bool),
+	}
+	source.identity, source.originalGuard = source, source.guard
+	source.guard.env = map[string]string{
+		"GOROOT": root, "GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v1",
+	}
+	if err := source.verifySDKDirectory(); err != nil {
+		t.Fatal("query must use the exact physical SDK package", err)
+	}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	source.guard.owned = owned
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, cpp, err := source.captureAssembly(context.Background(), 0, "sys_linux_amd64.s")
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("unpublished query must stop without a live execution context", err)
+	}
+	if len(source.observation.Positions) != 1 || cpp.Output == "" {
+		t.Fatal("actual runtime relative include did not close the CPP stage", err)
+	}
+	wantDigest := sha256.Sum256(headerBytes)
+	if got, exists := source.guard.inputs[header]; !exists || got != wantDigest {
+		t.Fatal("actual relative header bytes were not retained as guarded inputs")
+	}
+	found := false
+	for _, observed := range cpp.Sources {
+		if observed.File == header {
+			found = observed.Bytes == len(headerBytes) && observed.SHA256 == fmt.Sprintf("%x", wantDigest)
+		}
+	}
+	if !found || source.directories[filepath.Dir(header)] == nil {
+		t.Fatal("actual header source or its physical parent identity was omitted")
+	}
+	if source.ready || source.guard.ready || source.generation != 0 ||
+		len(source.observation.Commands) != 0 || source.observation.Objects != nil {
+		t.Fatal("partial CPP query acquired a source, command, object or frame certificate")
+	}
+}
+
+// This exercises actual header macros under explicit target definitions; it
+// does not authenticate SDK selection or claim that a Windows runtime file
+// was compiled on the host. In this amd64 owner, -shared and the special
+// runtime/386 -dynlink GOBUILDMODE_shared macro are distinct inputs.
+func TestSDKX86RelativeIncludeHeaderTargetProfileQuery(t *testing.T) {
+	root, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	header := filepath.Join(root, "src", "runtime", "cgo", "abi_amd64.h")
+	headerBytes, err := os.ReadFile(header)
+	if err != nil {
+		t.Fatal("actual SDK header is required for this version-bound owner", err)
+	}
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		t.Run(goos, func(t *testing.T) {
+			const query = "#include \"cgo/abi_amd64.h\"\nTEXT ·Probe(SB),4,$0-0\nMOVQ $REGS_HOST_TO_ABI0_STACK,AX\nRET\n"
+			cpp, _, err := observeSDKAssemblyCPP(query, AssemblyPreprocessOptions{
+				FileName: "profile-query.s",
+				Defines:  GoAssemblerDefinesWithEnv(goos, "amd64", map[string]string{"GOAMD64": "v1"}),
+				ReadInclude: func(parent, name string) (string, []byte, error) {
+					if parent != "profile-query.s" || name != "cgo/abi_amd64.h" {
+						return "", nil, fmt.Errorf("unbound query include %q from %q", name, parent)
+					}
+					return header, headerBytes, nil
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := Parse(ArchAMD64, cpp.Output)
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatal("actual target macro expression did not parse", err)
+			}
+			want := int64(6 * 8)
+			if goos == "windows" {
+				want = 28*8 + 8
+			}
+			moves := 0
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Op == "MOVQ" {
+					moves++
+					if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[0].Imm != want {
+						t.Fatal("actual target header selected the wrong saved-stack extent", ins)
+					}
+				}
+			}
+			if moves != 1 {
+				t.Fatal("query lost its one observable macro result")
+			}
+			scratch := &GoX86SDKASMDataSource{request: GoX86SDKASMDataCaptureRequest{PackagePath: "runtime"},
+				guard: newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{})}
+			scratch.guard.env = map[string]string{
+				"GOROOT": root, "GOOS": goos, "GOARCH": "amd64", "GOAMD64": "v1",
+			}
+			args := scratch.asmArguments("owned-query")
+			shared := false
+			for _, arg := range args {
+				shared = shared || arg == "-shared"
+			}
+			if shared != (goos == "darwin") || strings.Contains(strings.Join(args, " "), "GOBUILDMODE_shared") {
+				t.Fatal("amd64 profile conflated target -shared with runtime/386 -dynlink", args)
+			}
+		})
+	}
+}
+
+// An owned SDK-shaped tree permits physical mutation tests without changing
+// the installed SDK. This is only an unpublished input query: no Go driver,
+// generated header, commands, source certificate or ready state is supplied.
+func sdkRelativeIncludeQuerySource(t *testing.T, fallback bool) (*GoX86SDKASMDataSource, string) {
+	t.Helper()
+	base, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(base, "sdk")
+	directory := filepath.Join(root, "src", "runtime")
+	owned := filepath.Join(base, "owned")
+	for _, name := range []string{filepath.Join(directory, "headers"), filepath.Join(root, "pkg", "include", "headers"), owned} {
+		if err := os.MkdirAll(name, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	header := filepath.Join(directory, "headers", "value.h")
+	contents := "#include \"second.h\"\n"
+	if fallback {
+		header = filepath.Join(root, "pkg", "include", "headers", "value.h")
+		contents = "#define VALUE 41\n"
+	}
+	for name, data := range map[string]string{
+		filepath.Join(directory, "source.s"):            "#include \"headers/value.h\"\nTEXT ·Probe(SB),4,$0-0\nMOVL $VALUE,AX\nRET\n",
+		filepath.Join(directory, "second.h"):            "#define VALUE 41\n",
+		filepath.Join(directory, "headers", "second.h"): "#define VALUE 99\n",
+		header: contents,
+	} {
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	request := GoX86SDKASMDataCaptureRequest{Directory: directory, PackagePath: "runtime", Target: "linux/amd64"}
+	source := &GoX86SDKASMDataSource{request: request,
+		guard:       newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{Directory: directory}),
+		directories: make(map[string]os.FileInfo), misses: make(map[string]bool)}
+	source.identity, source.originalGuard = source, source.guard
+	source.guard.env = map[string]string{"GOROOT": root, "GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v1"}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		t.Fatal(err)
+	}
+	source.guard.owned = owned
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { source.Close() })
+	return source, header
+}
+
+func TestSDKX86RelativeIncludeQueryMutationAndLifetime(t *testing.T) {
+	for _, change := range []string{"bytes", "same-byte-parent", "symlink", "nonregular", "oversize", "closed"} {
+		t.Run(change, func(t *testing.T) {
+			source, header := sdkRelativeIncludeQuerySource(t, false)
+			_, original, err := source.readAssemblyInclude("source.s", "headers/value.h")
+			if err != nil {
+				t.Fatal("initial bounded input query", err)
+			}
+			for repeat := 0; repeat < 3; repeat++ {
+				if _, _, err := source.readAssemblyInclude("unrelated-parent.h", "headers/value.h"); err != nil {
+					t.Fatal("repeated selected header gained a new lookup origin", err)
+				}
+			}
+			if len(source.guard.directoryInventory.View().Hashes) != 1 {
+				t.Fatal("repeated include consumed duplicate source-budget entries")
+			}
+			switch change {
+			case "bytes":
+				err = os.WriteFile(header, []byte("#define VALUE 42\n"), 0600)
+			case "same-byte-parent":
+				parent := filepath.Dir(header)
+				saved := filepath.Join(t.TempDir(), "original")
+				err = os.Rename(parent, saved)
+				if err == nil {
+					err = os.Mkdir(parent, 0700)
+				}
+				if err == nil {
+					// Keep both original file inodes and complete membership;
+					// only the containing directory's identity changes.
+					err = os.Link(filepath.Join(saved, "value.h"), header)
+				}
+				if err == nil {
+					err = os.Link(filepath.Join(saved, "second.h"), filepath.Join(parent, "second.h"))
+				}
+			case "symlink":
+				err = os.Remove(header)
+				if err == nil {
+					err = os.Symlink(filepath.Join(source.request.Directory, "second.h"), header)
+				}
+			case "nonregular":
+				err = os.Remove(header)
+				if err == nil {
+					err = os.Mkdir(header, 0700)
+				}
+			case "oversize":
+				err = os.Truncate(header, 16<<20+1)
+			case "closed":
+				err = source.Close()
+			}
+			if err != nil {
+				t.Fatal("owned mutation setup", err)
+			}
+			if _, _, err := source.readAssemblyInclude("source.s", "headers/value.h"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed or closed include input query remained usable", change, err)
+			}
+			if change == "bytes" {
+				// A failed factory capture closes its owned generation. Restoring
+				// physical bytes must not reopen that aborted input lifetime.
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(header, original, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if _, _, err := source.readAssemblyInclude("source.s", "headers/value.h"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("restored bytes reopened an aborted include lifetime", err)
+				}
+			}
+			if source.ready || source.guard.ready || len(source.observation.Commands) != 0 {
+				t.Fatal("input query manufactured a compiler/source certificate")
+			}
+		})
+	}
+}
+
+func TestSDKX86RelativeIncludeFixedOriginsAndMisses(t *testing.T) {
+	t.Run("nested-fixed-CWD", func(t *testing.T) {
+		source, _ := sdkRelativeIncludeQuerySource(t, false)
+		raw, err := os.ReadFile(filepath.Join(source.request.Directory, "source.s"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		cpp, _, err := observeSDKAssemblyCPP(string(raw), AssemblyPreprocessOptions{
+			FileName: filepath.Join(source.request.Directory, "source.s"), ReadInclude: source.readAssemblyInclude,
+		})
+		if err != nil || !strings.Contains(cpp.Output, "$41") || strings.Contains(cpp.Output, "$99") {
+			t.Fatal("nested header switched the actual fixed CWD lookup to its parent", err, cpp.Output)
+		}
+	})
+	t.Run("preferred-miss-appears", func(t *testing.T) {
+		source, header := sdkRelativeIncludeQuerySource(t, true)
+		selected, _, err := source.readAssemblyInclude("source.s", "headers/value.h")
+		if err != nil || selected != header || len(source.misses) != 2 {
+			t.Fatal("fallback lost its two preferred fixed-origin absences", selected, err, len(source.misses))
+		}
+		preferred := filepath.Join(source.request.Directory, "headers", "value.h")
+		if err := os.WriteFile(preferred, []byte("#define VALUE 99\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := source.readAssemblyInclude("source.s", "headers/value.h"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("new preferred candidate changed an already observed fallback", err)
+		}
+	})
+	for _, header := range []string{"../second.h", "headers/../second.h", "headers//value.h", "headers\\value.h"} {
+		t.Run(header, func(t *testing.T) {
+			source, _ := sdkRelativeIncludeQuerySource(t, false)
+			if _, _, err := source.readAssemblyInclude("source.s", header); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("noncanonical/escaping include acquired a selected SDK route", err)
+			}
+		})
+	}
+	t.Run("absolute", func(t *testing.T) {
+		source, header := sdkRelativeIncludeQuerySource(t, false)
+		if _, _, err := source.readAssemblyInclude("source.s", header); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("absolute header borrowed a selected SDK relative route", err)
+		}
+	})
+	t.Run("unverified-package", func(t *testing.T) {
+		source, _ := sdkRelativeIncludeQuerySource(t, false)
+		source.request.PackagePath = "other"
+		if _, _, err := source.readAssemblyInclude("source.s", "headers/value.h"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("a child directory identity replaced the exact SDK package route", err)
+		}
+	})
+}
diff --git a/go_x86_sdk_asm_data_runtime_large_go127_test.go b/go_x86_sdk_asm_data_runtime_large_go127_test.go
new file mode 100644
index 000000000..18356a050
--- /dev/null
+++ b/go_x86_sdk_asm_data_runtime_large_go127_test.go
@@ -0,0 +1,70 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestSDKX86RelativeIncludeActualRuntimeFactory(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, arch, "runtime")
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal("complete actual SDK factory/compiler/original-expanded objects", err)
+			}
+			defer source.Close()
+			header := filepath.Join(source.guard.env["GOROOT"], "src", "runtime", "go_tls.h")
+			if arch == "amd64" {
+				header = filepath.Join(source.guard.env["GOROOT"], "src", "runtime", "cgo", "abi_amd64.h")
+			}
+			if _, present := source.guard.inputs[header]; !present || source.observation.Objects == nil ||
+				len(source.observation.CPP) != len(source.guard.selection.SFiles) || source.guard.ready {
+				t.Fatal("actual factory lost selected headers, full original-object join or role separation")
+			}
+			if arch == "386" {
+				// go_tls.h is also in the direct primary inventory. Require its
+				// actual CPP source record, not just the inventory's prior read.
+				wantSHA256 := fmt.Sprintf("%x", source.guard.inputs[header])
+				observedHeader := false
+				for _, cpp := range source.observation.CPP {
+					for _, observed := range cpp.Sources {
+						if observed.File == header && observed.SHA256 == wantSHA256 && observed.Bytes > 0 {
+							observedHeader = true
+						}
+					}
+				}
+				if !observedHeader {
+					t.Fatal("actual 386 CPP execution did not observe its exact SDK TLS header")
+				}
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("actual complete SDK capture did not verify", err)
+			}
+			// Mutate only this factory's owned expanded program, never installed SDK
+			// files. The same published-generation guard owns every selected input.
+			program := filepath.Join(source.guard.owned, "expanded-0.s")
+			original, err := os.ReadFile(program)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(program, append(append([]byte(nil), original...), []byte("\n// changed owned input\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("changed actual input kept its published source generation")
+			}
+			if err := os.WriteFile(program, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if !errors.Is(source.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restoring owned bytes revived a revoked SDK source")
+			}
+		})
+	}
+}
diff --git a/go_x86_sdk_asm_data_source.go b/go_x86_sdk_asm_data_source.go
new file mode 100644
index 000000000..61748b192
--- /dev/null
+++ b/go_x86_sdk_asm_data_source.go
@@ -0,0 +1,482 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// GoX86SDKASMDataCaptureRequest selects one physical package in the invoked
+// stock-Go SDK. It accepts no caller AST, Types, header, object or owner token.
+type GoX86SDKASMDataCaptureRequest struct {
+	GoBinary, Directory, PackagePath, Target string
+	Environment                              []string
+}
+
+type sdkASMDataCaptureRole uint8
+
+const (
+	sdkASMDataStrictRole sdkASMDataCaptureRole = iota
+	sdkASMDataOriginalFrameRole
+	sdkASMDataOriginalSourceRole
+)
+
+// GoX86SDKASMDataSource authenticates source/header/CPP/object observations
+// only. It has no Bind, Options, initializer, numerical or native-body API.
+type GoX86SDKASMDataSource struct {
+	mu, operation    sync.Mutex
+	identity         *GoX86SDKASMDataSource
+	ready            bool
+	active           int
+	closePending     bool
+	generation       uint64
+	request          GoX86SDKASMDataCaptureRequest
+	guard            *GoAMD64FrameSource
+	originalGuard    *GoAMD64FrameSource
+	context          context.Context
+	originalContext  context.Context
+	originalDeadline time.Time
+	// Only distinct private SDK-primary observation factories select an
+	// original profile. Public DATA/numerical producers remain strict.
+	originalProfile   bool
+	captureRole       sdkASMDataCaptureRole
+	originalConfig    string
+	originalConfigID  os.FileInfo
+	frameListingBytes int
+	directories       map[string]os.FileInfo
+	misses            map[string]bool
+	observation       sdkASMDataLiveObservation
+	report            []byte
+	seal              [32]byte
+	stateSeal         [32]byte
+}
+
+type sdkASMDataLiveObservation struct {
+	Protocol                     string
+	Request                      GoX86SDKASMDataCaptureRequest
+	RawEnvironment, RawSelection []byte
+	Graph                        []byte
+	Imports                      map[string]goAMD64FrameSelection
+	Inputs                       map[string][32]byte
+	Header                       sdkASMDataHeaderObservation
+	CPP                          []AssemblyCPPObservation
+	Positions                    []sdkCPPPositionObservation
+	ObjectInputs                 gostaticstorage.SDKASMDataObservationRequest
+	Objects                      *gostaticstorage.SDKASMDataObservation
+	Frames                       []sdkAMD64FrameNativeObservation `json:",omitempty"`
+	FrameListingBytes            int                              `json:",omitempty"`
+	Commands                     []numericalSBCommand
+}
+
+func sdkASMDataContext(format string, args ...any) error {
+	return fmt.Errorf("%w: actual SDK ASM DATA observation: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+// CaptureGoX86SDKASMDataSource is an explicit live SDK observation producer.
+// Successful capture does not make DATA initialized storage or authorize any
+// instruction to read it. Existing owned and numerical factories stay strict.
+func CaptureGoX86SDKASMDataSource(ctx context.Context, request GoX86SDKASMDataCaptureRequest) (_ *GoX86SDKASMDataSource, result error) {
+	return captureGoX86SDKASMDataSource(ctx, request, false)
+}
+
+func captureGoX86SDKASMDataSource(ctx context.Context, request GoX86SDKASMDataCaptureRequest, originalProfile bool) (_ *GoX86SDKASMDataSource, result error) {
+	role := sdkASMDataStrictRole
+	if originalProfile {
+		role = sdkASMDataOriginalFrameRole
+	}
+	return captureGoX86SDKASMDataSourceRole(ctx, request, role)
+}
+
+// A distinct private source-only role observes the same original profile but
+// never captures AMD64 native frames or constructs their observation owner.
+func captureGoX86SDKASMDataSourceRole(ctx context.Context, request GoX86SDKASMDataCaptureRequest, role sdkASMDataCaptureRole) (_ *GoX86SDKASMDataSource, result error) {
+	if role > sdkASMDataOriginalSourceRole {
+		return nil, sdkASMDataContext("unknown private SDK source observation role")
+	}
+	originalProfile := role != sdkASMDataStrictRole
+	if ctx != nil && ctx.Err() != nil {
+		return nil, fmt.Errorf("capture SDK ASM DATA: %w", ctx.Err())
+	}
+	if ctx == nil || !gostaticstorage.X86SDKTarget(request.Target) ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		!filepath.IsLocal(filepath.FromSlash(request.PackagePath)) ||
+		filepath.ToSlash(filepath.Clean(filepath.FromSlash(request.PackagePath))) != request.PackagePath {
+		return nil, sdkASMDataContext("requires exact SDK source/tool/target inputs")
+	}
+	deadline, bounded := ctx.Deadline()
+	if !bounded {
+		return nil, sdkASMDataContext("requires a bounded original capture context")
+	}
+	request.Environment = append([]string(nil), request.Environment...)
+	var provided map[string]string
+	var err error
+	if role == sdkASMDataOriginalFrameRole {
+		provided, err = sdkAMD64FrameEnvironment(request)
+	} else if role == sdkASMDataOriginalSourceRole {
+		provided, err = sdkX86OriginalSourceEnvironment(request)
+	} else {
+		provided, err = sdkASMDataEnvironment(request)
+	}
+	if err != nil {
+		return nil, err
+	}
+	source := &GoX86SDKASMDataSource{request: request, context: ctx, originalContext: ctx, originalProfile: originalProfile, captureRole: role,
+		originalDeadline: deadline,
+		directories:      make(map[string]os.FileInfo), misses: make(map[string]bool)}
+	source.identity = source
+	source.guard = newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, Target: request.Target, Environment: request.Environment})
+	source.originalGuard = source.guard
+	for _, directory := range []string{request.Directory, provided["GOCACHE"], provided["GOMODCACHE"],
+		provided["GOPATH"], provided["TMPDIR"], provided["GOTMPDIR"]} {
+		if err := source.retainDirectory(directory); err != nil {
+			return nil, err
+		}
+	}
+	if err := source.snapshotSDKPrimaryDirectory(); err != nil {
+		return nil, err
+	}
+	owned, err := os.MkdirTemp(provided["TMPDIR"], "plan9asm-sdk-asm-data-")
+	if err != nil {
+		return nil, err
+	}
+	source.guard.owned = owned
+	source.guard.ownedInfo, err = sourcepath.Lstat(owned)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	canonical, err := sourcepath.Resolve(owned)
+	info, statErr := os.Lstat(canonical)
+	if err != nil || statErr != nil || !info.IsDir() || !os.SameFile(info, source.guard.ownedInfo) ||
+		!goAssemblyPathWithinRoot(provided["TMPDIR"], canonical) {
+		return nil, sdkASMDataContext("factory artifact identity changed")
+	}
+	source.guard.owned = canonical
+	if originalProfile && provided["GOENV"] != "off" {
+		if err := source.captureSDKFrameConfig(provided["GOENV"]); err != nil {
+			return nil, err
+		}
+	}
+	if err := source.capture(ctx, provided); err != nil {
+		return nil, err
+	}
+	source.observation.Inputs = cloneSDKASMDataInputs(source.guard.inputs)
+	source.report, err = json.Marshal(source.observation)
+	if err != nil {
+		return nil, err
+	}
+	source.seal = sha256.Sum256(source.report)
+	source.stateSeal, err = source.digest()
+	if err != nil {
+		return nil, err
+	}
+	source.ready, source.generation = true, 1
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return source, nil
+}
+
+func sdkASMDataEnvironment(request GoX86SDKASMDataCaptureRequest) (map[string]string, error) {
+	provided := make(map[string]string)
+	for _, pair := range request.Environment {
+		key, value, valid := strings.Cut(pair, "=")
+		if _, duplicate := provided[key]; !valid || key == "" || duplicate {
+			return nil, sdkASMDataContext("malformed or duplicate command environment")
+		}
+		provided[key] = value
+	}
+	goos, arch, _ := strings.Cut(request.Target, "/")
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2",
+		"CGO_ENABLED": "0", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOEXPERIMENT": "", "GOPROXY": "off"} {
+		if key == "CGO_ENABLED" && (provided[key] == "0" || provided[key] == "1") {
+			continue // Actual SDK graph still requires complete ordinary uncgo sources.
+		}
+		if actual, present := provided[key]; !present || actual != value {
+			return nil, sdkASMDataContext("unbound command profile: %s", key)
+		}
+	}
+	if provided["GOPACKAGESDRIVER"] != "" && provided["GOPACKAGESDRIVER"] != "off" {
+		return nil, sdkASMDataContext("external package driver needs its own source role")
+	}
+	return provided, nil
+}
+
+func (source *GoX86SDKASMDataSource) retainDirectory(directory string) error {
+	resolved, err := sourcepath.Resolve(directory)
+	info, statErr := sourcepath.Lstat(directory)
+	if !filepath.IsAbs(directory) || err != nil || resolved != directory || statErr != nil || !info.IsDir() {
+		return sdkASMDataContext("missing or redirected source/command directory")
+	}
+	source.directories[directory] = info
+	return nil
+}
+
+func (source *GoX86SDKASMDataSource) verifyDirectories() error {
+	if source.originalConfig != "" {
+		resolved, err := sourcepath.Resolve(source.originalConfig)
+		info, statErr := sourcepath.Lstat(source.originalConfig)
+		if err != nil || resolved != source.originalConfig || statErr != nil || !info.Mode().IsRegular() || info.Size() > sdkAMD64FrameConfigBytes ||
+			source.originalConfigID == nil || !os.SameFile(source.originalConfigID, info) {
+			return sdkASMDataContext("SDK-primary original GOENV identity changed")
+		}
+	}
+	for directory, before := range source.directories {
+		resolved, err := sourcepath.Resolve(directory)
+		after, statErr := sourcepath.Lstat(directory)
+		if err != nil || resolved != directory || statErr != nil || !after.IsDir() || !os.SameFile(before, after) {
+			return sdkASMDataContext("source/command directory identity changed")
+		}
+	}
+	for name := range source.misses {
+		if _, err := os.Lstat(name); !os.IsNotExist(err) {
+			return sdkASMDataContext("CPP preferred search miss changed")
+		}
+	}
+	return nil
+}
+
+func (source *GoX86SDKASMDataSource) liveContext(ctx context.Context) error {
+	if ctx == nil || source.context == nil {
+		return sdkASMDataContext("missing original or verification context")
+	}
+	if source.originalContext == nil || reflect.TypeOf(source.context) != reflect.TypeOf(source.originalContext) ||
+		!reflect.TypeOf(source.context).Comparable() || source.context != source.originalContext {
+		return sdkASMDataContext("original capture context identity changed")
+	}
+	_, err := sampleGoSourceContext(ctx, source.context,
+		goSourceContextLifetime{deadline: source.originalDeadline, bounded: true}, false,
+		sdkASMDataContext("original capture context deadline changed or canceled without a cause"))
+	return err
+}
+
+func (source *GoX86SDKASMDataSource) run(ctx context.Context, arguments ...string) ([]byte, error) {
+	if err := source.liveContext(ctx); err != nil {
+		return nil, err
+	}
+	stdout, err := source.runCommand(ctx, arguments...)
+	return stdout, errors.Join(err, source.liveContext(ctx))
+}
+
+// Verification supplies only a private standard context here. Never invoke a
+// caller context while the operation lock protects private input maps.
+func (source *GoX86SDKASMDataSource) runCommand(ctx context.Context, arguments ...string) ([]byte, error) {
+	if err := source.verifyDirectories(); err != nil {
+		return nil, err
+	}
+	if err := source.guard.verifyInputs(); err != nil {
+		return nil, err
+	}
+	commandContext, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	stdout, err := goasmcmd.Run(commandContext, source.request.Directory, source.request.Environment, source.request.GoBinary, arguments...)
+	err = errors.Join(err, commandContext.Err(), source.guard.verifyInputs(), source.verifyDirectories())
+	if err == nil && source.originalProfile && len(arguments) > 1 && arguments[0] == "tool" && arguments[1] == "asm" {
+		for _, argument := range arguments[2:] {
+			if argument == "-S" {
+				err = source.retainSDKFrameListingBytes(len(stdout))
+				break
+			}
+		}
+	}
+	if err == nil {
+		source.observation.Commands = append(source.observation.Commands, numericalSBCommand{
+			Directory: source.request.Directory, Binary: source.request.GoBinary,
+			Arguments: append([]string(nil), arguments...), Stdout: append([]byte(nil), stdout...),
+		})
+	}
+	return stdout, err
+}
+
+func cloneSDKASMDataInputs(inputs map[string][32]byte) map[string][32]byte {
+	result := make(map[string][32]byte, len(inputs))
+	for name, digest := range inputs {
+		result[name] = digest
+	}
+	return result
+}
+
+func (source *GoX86SDKASMDataSource) digest() ([32]byte, error) {
+	return digestSDKASMDataState(struct {
+		Request           GoX86SDKASMDataCaptureRequest
+		Guard             GoAMD64FrameCaptureRequest
+		Selection         goAMD64FrameSelection
+		Env               map[string]string
+		Imports           map[string]goAMD64FrameSelection
+		Inputs            map[string][32]byte
+		Entries           []string
+		Misses            map[string]bool
+		Observation       sdkASMDataLiveObservation
+		OriginalDeadline  time.Time
+		OriginalProfile   bool
+		CaptureRole       sdkASMDataCaptureRole
+		OriginalConfig    string
+		FrameListingBytes int
+	}{source.request, source.guard.request, source.guard.selection, source.guard.env, source.guard.imports,
+		source.guard.inputs, source.guard.entries, source.misses, source.observation, source.originalDeadline,
+		source.originalProfile, source.captureRole, source.originalConfig, source.frameListingBytes})
+}
+
+// Verify samples every caller context outside both locks. A lifetime lease
+// protects artifacts during reentrant Verify/Readback/Close callbacks; only a
+// private standard context enters the serialized command/guard operation.
+// Every postcheck must still match the exact original generation.
+func (source *GoX86SDKASMDataSource) Verify(ctx context.Context) (result error) {
+	if source == nil || source.identity != source {
+		return sdkASMDataContext("copied, missing or uninitialized source")
+	}
+	source.mu.Lock()
+	generation, ready := source.generation, source.ready
+	if ready {
+		source.active++
+	}
+	source.mu.Unlock()
+	if !ready {
+		return sdkASMDataContext("source is closed or revoked")
+	}
+	defer func() {
+		result = errors.Join(result, source.liveContext(ctx))
+		source.mu.Lock()
+		if source.generation != generation || !source.ready {
+			result = errors.Join(result, sdkASMDataContext("source closed or revoked during verification"))
+		}
+		if result != nil {
+			source.ready = false
+			source.generation++
+		}
+		source.active--
+		cleanup := source.closePending && source.active == 0
+		source.mu.Unlock()
+		if cleanup {
+			source.operation.Lock()
+			result = errors.Join(result, source.guard.Close())
+			source.operation.Unlock()
+		}
+	}()
+	if err := source.liveContext(ctx); err != nil {
+		return err
+	}
+	private, stop, err := sdkASMDataPrivateContext(ctx, source.context, source.originalDeadline)
+	if err != nil {
+		return err
+	}
+	defer stop()
+	source.operation.Lock()
+	defer source.operation.Unlock()
+	source.mu.Lock()
+	current := source.ready && source.generation == generation
+	source.mu.Unlock()
+	if !current {
+		return sdkASMDataContext("source closed or revoked during context callbacks")
+	}
+	return errors.Join(source.verifyState(private), private.Err())
+}
+
+func (source *GoX86SDKASMDataSource) verifyState(ctx context.Context) error {
+	if source.guard != source.originalGuard || source.guard == nil || source.guard.identity != source.guard ||
+		source.guard.ready || source.guard.request.NumericalReads != nil || source.guard.numericalOrigin != nil || source.guard.downloadedOrigin != nil {
+		return sdkASMDataContext("source borrowed a foreign frame, origin or numerical capability")
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	before, err := source.digest()
+	if err != nil || before != source.stateSeal || sha256.Sum256(source.report) != source.seal {
+		return sdkASMDataContext("sealed source/header/CPP/object state changed")
+	}
+	if err := source.verifySDKDirectory(); err != nil {
+		return err
+	}
+	// Verification commands are not new capture observations. Retain the exact
+	// original command inventory while checking current actual graph bytes.
+	commands := source.observation.Commands
+	defer func() { source.observation.Commands = commands }()
+	raw, err := source.runCommand(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", source.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	imports, err := source.guard.bindOriginalDeclarationImports(raw)
+	if err != nil || !reflect.DeepEqual(imports, source.observation.Imports) ||
+		!numericalSameRawSDKGraph(raw, source.observation.Graph) {
+		return sdkASMDataContext("complete SDK source/export/selection graph changed: %v", err)
+	}
+	source.observation.Commands = commands
+	if err := source.guard.verifyInputs(); err != nil {
+		return err
+	}
+	after, err := source.digest()
+	if err != nil || after != source.stateSeal {
+		return sdkASMDataContext("inputs or observation changed during verification")
+	}
+	return nil
+}
+
+// Close cannot dispose a copied source's shared artifacts. It never deletes
+// the SDK, original source, dependency exports or caller cache directories.
+func (source *GoX86SDKASMDataSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	if source.identity != source {
+		return sdkASMDataContext("copied observation cannot close its original artifact owner")
+	}
+	if source.guard == nil || source.guard != source.originalGuard || source.guard.identity != source.guard {
+		return sdkASMDataContext("foreign artifact guard cannot dispose its owner's directory")
+	}
+	source.mu.Lock()
+	source.ready = false
+	source.generation++
+	source.closePending = true
+	active := source.active
+	source.mu.Unlock()
+	if active != 0 {
+		return nil
+	}
+	source.operation.Lock()
+	defer source.operation.Unlock()
+	return source.guard.Close()
+}
+
+func (source *GoX86SDKASMDataSource) Readback(ctx context.Context) ([]byte, error) {
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready {
+		return nil, sdkASMDataContext("source closed after verification")
+	}
+	return append([]byte(nil), source.report...), nil
+}
+
+// CheckReadback compares actual retained whole bytes. It is not a constructor.
+func (source *GoX86SDKASMDataSource) CheckReadback(ctx context.Context, raw []byte) error {
+	if err := source.Verify(ctx); err != nil {
+		return err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready || sha256.Sum256(raw) != source.seal {
+		source.ready = false
+		source.generation++
+		return sdkASMDataContext("readback differs from retained original observations")
+	}
+	return nil
+}
diff --git a/go_x86_sdk_asm_metadata.go b/go_x86_sdk_asm_metadata.go
new file mode 100644
index 000000000..073e719f5
--- /dev/null
+++ b/go_x86_sdk_asm_metadata.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Assembly returns the complete parsed CPP of one exact selected member.
+// It does not bind Options or certify an initializer, numerical read, frame,
+// native entry or caller. The independently supplied live source remains the
+// sole owner; returned diagnostic values cannot restore that owner.
+func (source *GoX86SDKASMDataSource) Assembly(ctx context.Context, assemblyFile string) (file *File, result error) {
+	if source == nil || source.identity != source {
+		return nil, sdkASMDataContext("metadata requires its original live source")
+	}
+	raw, err := source.Readback(ctx)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		result = errors.Join(result, source.Verify(ctx))
+		if result != nil {
+			file = nil
+		}
+	}()
+	var observation sdkASMDataLiveObservation
+	if json.Unmarshal(raw, &observation) != nil || !reflect.DeepEqual(observation.Request, source.request) {
+		return nil, sdkASMDataContext("metadata readback lost its exact source/tool/profile")
+	}
+	// The live source's sealed Readback already includes the existing complete
+	// object frontend's join and retained input bytes. Do not decode those whole
+	// objects again or turn an empty DATA inventory into an initializer owner.
+	file, _, err = sdkASMMetadataSelectedMember(observation, assemblyFile)
+	return file, err
+}
+
+// This is a pure complete-inventory selector, not a live-source constructor.
+// The SDK graph consumer can reuse its original member ordinal without
+// reordering physical records or relabeling helper instructions as roots.
+func sdkASMMetadataSelectedMember(observation sdkASMDataLiveObservation, assemblyFile string) (*File, int, error) {
+	fail := func(message string) (*File, int, error) {
+		return nil, -1, sdkASMDataContext("metadata %s", message)
+	}
+	if assemblyFile == "" || filepath.Base(assemblyFile) != assemblyFile || !strings.HasSuffix(assemblyFile, ".s") {
+		return fail("requires an exact package-local selected assembly name")
+	}
+	objects, inputs := observation.Objects, observation.ObjectInputs
+	if observation.Protocol != "actual_go_sdk_asm_data_live_observation_v1" || objects == nil ||
+		objects.Protocol != gostaticstorage.ASMDataCPPProtocol || !gostaticstorage.X86SDKTarget(observation.Request.Target) ||
+		objects.PackagePath != observation.Request.PackagePath || objects.Target != observation.Request.Target ||
+		inputs.PackagePath != objects.PackagePath || inputs.Target != objects.Target {
+		return fail("lost its independent complete CPP/source role")
+	}
+	var selected goAMD64FrameSelection
+	if json.Unmarshal(observation.RawSelection, &selected) != nil || !selected.Standard || selected.Module != nil ||
+		selected.ImportPath != objects.PackagePath || selected.nonordinaryRole() ||
+		len(selected.Error)+len(selected.DepsErrors) != 0 {
+		return fail("differs from its actual ordinary SDK selection")
+	}
+	count := len(selected.SFiles)
+	if count == 0 || count > gostaticstorage.ArchiveMemberInventoryLimit-2 || len(objects.Sources) != count || len(observation.CPP) != count ||
+		len(observation.Positions) != count || len(inputs.Sources) != count || len(objects.Members) != count+2 {
+		return fail("omits or adds a complete selected source/member/CPP/position inventory")
+	}
+	digest := func(data []byte) string {
+		value := sha256.Sum256(data)
+		return hex.EncodeToString(value[:])
+	}
+	if objects.ArchiveSHA256 != digest(inputs.Archive) {
+		return fail("changed its complete compiler archive bytes")
+	}
+	ordinal := -1
+	names := make(map[string]bool, count)
+	for index, name := range selected.SFiles {
+		observed, input, cpp := objects.Sources[index], inputs.Sources[index], observation.CPP[index]
+		member := objects.Members[index+2]
+		if filepath.Base(name) != name || !strings.HasSuffix(name, ".s") || names[name] ||
+			observed.Name != name || input.Name != name || member.Ordinal != index+2 ||
+			member.Name == "" || !bytes.Equal(member.NameBytes, []byte(member.Name)) ||
+			member.Flags != observed.Original.Flags || !reflect.DeepEqual(member.Texts, observed.Original.Texts) ||
+			!reflect.DeepEqual(observed.Original.Texts, observed.Expanded.Texts) {
+			return fail("changed a source/compiler ordinal or complete native TEXT tuple")
+		}
+		names[name] = true
+		if observed.OriginalSHA256 != digest(input.Original) || observed.ExpandedSHA256 != digest(input.Expanded) ||
+			observed.OriginalObjectSHA256 != digest(input.OriginalObject) || observed.ExpandedObjectSHA256 != digest(input.ExpandedObject) ||
+			cpp.Output != string(input.Expanded) {
+			return fail("changed whole original/CPP/object input bytes")
+		}
+		// The common association grammar admits complete comments-only members;
+		// unlike a numerical native consumer, metadata requires no nonempty body.
+		grammar := []byte(cpp.Output)
+		if len(grammar) == 0 {
+			// Match the existing CPP observer's zero-statement lexer view,
+			// without changing any retained or returned source bytes.
+			grammar = []byte("\n")
+		}
+		order, err := gostaticstorage.ASMSourceTextOrder(grammar, objects.PackagePath, observed.Original)
+		if err != nil || !reflect.DeepEqual(order, observed.TextOrder) {
+			return fail("changed its complete original source/physical TEXT association")
+		}
+		replayed, err := gostaticstorage.ASMSourceTextOrder(grammar, objects.PackagePath, observed.Expanded)
+		if err != nil || !reflect.DeepEqual(order, replayed) {
+			return fail("changed its complete expanded source/physical TEXT association")
+		}
+		if name == assemblyFile {
+			ordinal = index
+		}
+	}
+	if ordinal < 0 {
+		return fail("does not contain that exact selected member")
+	}
+	if observation.CPP[ordinal].Output == "" {
+		// A real comments-only member may have zero expanded statements. This
+		// is its complete empty file, not a replacement for an unsupported body.
+		return &File{Arch: ArchAMD64}, ordinal, nil
+	}
+	file, err := Parse(ArchAMD64, observation.CPP[ordinal].Output)
+	if err != nil {
+		return fail("selected complete CPP cannot be parsed: " + err.Error())
+	}
+	return file, ordinal, nil
+}
diff --git a/go_x86_sdk_asm_metadata_test.go b/go_x86_sdk_asm_metadata_test.go
new file mode 100644
index 000000000..b7bf07d64
--- /dev/null
+++ b/go_x86_sdk_asm_metadata_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These are independent selector values, never a live SDK source/owner.
+func sdkASMMetadataModel(t *testing.T) sdkASMDataLiveObservation {
+	t.Helper()
+	program, first := numericalNativeOrderFixture(t)
+	first.Name = "mixed.s"
+	second := gostaticstorage.ASMDataSourceObservation{Name: "empty.s",
+		Original: gostaticstorage.ASMDataMember{Flags: 4}, Expanded: gostaticstorage.ASMDataMember{Flags: 4}}
+	observation := sdkASMDataLiveObservation{Protocol: "actual_go_sdk_asm_data_live_observation_v1",
+		Request: GoX86SDKASMDataCaptureRequest{PackagePath: "example", Target: "linux/amd64"},
+		CPP:     []AssemblyCPPObservation{{Output: program}, {}}, Positions: make([]sdkCPPPositionObservation, 2),
+		ObjectInputs: gostaticstorage.SDKASMDataObservationRequest{PackagePath: "example", Target: "linux/amd64", Archive: []byte("model archive")},
+		Objects: &gostaticstorage.SDKASMDataObservation{Protocol: gostaticstorage.ASMDataCPPProtocol,
+			PackagePath: "example", Target: "linux/amd64", Sources: []gostaticstorage.ASMDataSourceObservation{first, second},
+			Members: []gostaticstorage.ASMDataMember{{Name: "__.PKGDEF"}, {Name: "_go_.o"}, first.Original, second.Original}}}
+	observation.RawSelection, _ = json.Marshal(map[string]any{"ImportPath": "example", "Standard": true,
+		"SFiles": []string{"mixed.s", "empty.s"}})
+	digest := func(data []byte) string {
+		value := sha256.Sum256(data)
+		return hex.EncodeToString(value[:])
+	}
+	observation.Objects.ArchiveSHA256 = digest(observation.ObjectInputs.Archive)
+	for index, source := range observation.Objects.Sources {
+		input := gostaticstorage.SDKASMDataSource{Name: source.Name, Original: []byte("original model " + source.Name),
+			Expanded: []byte(observation.CPP[index].Output), OriginalObject: []byte("original object " + source.Name),
+			ExpandedObject: []byte("expanded object " + source.Name)}
+		observation.ObjectInputs.Sources = append(observation.ObjectInputs.Sources, input)
+		value := &observation.Objects.Sources[index]
+		value.OriginalSHA256, value.ExpandedSHA256 = digest(input.Original), digest(input.Expanded)
+		value.OriginalObjectSHA256, value.ExpandedObjectSHA256 = digest(input.OriginalObject), digest(input.ExpandedObject)
+		member := &observation.Objects.Members[index+2]
+		member.Ordinal, member.Name = index+2, source.Name[:len(source.Name)-2]+".o"
+		member.NameBytes = []byte(member.Name)
+	}
+	return observation
+}
+
+func TestGoX86SDKASMMetadataSelectorCompletePairing(t *testing.T) {
+	observation := sdkASMMetadataModel(t)
+	before, _ := json.Marshal(observation)
+	file, ordinal, err := sdkASMMetadataSelectedMember(observation, "mixed.s")
+	if err != nil || ordinal != 0 || file == nil || len(file.Funcs) != 3 ||
+		file.Funcs[0].Sym != "foreign·first<ABIInternal>" || file.Funcs[2].Sym != "helper<>" ||
+		len(file.Data) != 0 || len(file.Globl) != 0 {
+		t.Fatal("complete source-order member selection", ordinal, err)
+	}
+	if !reflect.DeepEqual(observation.Objects.Sources[0].TextOrder, []gostaticstorage.ASMSourceText{
+		{SourceOrdinal: 0, ObjectOrdinal: 1, Name: "foreign.first", ABI: 1, Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 1},
+		{SourceOrdinal: 1, ObjectOrdinal: 2, Name: "example.second", Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 2, Relative: 1},
+		{SourceOrdinal: 2, ObjectOrdinal: 0, Name: "helper", ABI: 65535, Namespace: gostaticstorage.TextSymbolSelf},
+	}) {
+		t.Fatal("source/physical ordinal association was reordered")
+	}
+	empty, ordinal, err := sdkASMMetadataSelectedMember(observation, "empty.s")
+	if err != nil || empty == nil || ordinal != 1 || len(empty.Funcs)+len(empty.Data)+len(empty.Globl) != 0 {
+		t.Fatal("complete empty selected member was invented or omitted", ordinal, err)
+	}
+	after, _ := json.Marshal(observation)
+	if !bytes.Equal(before, after) {
+		t.Fatal("selector mutated original physical records")
+	}
+	if _, err := gostaticstorage.ReadonlyLiteralDataInitializers(observation.Objects); !errors.Is(err, gostaticstorage.ErrContext) {
+		t.Fatal("metadata acquired a readonly initializer", err)
+	}
+}
+
+func TestGoX86SDKASMMetadataSelectorRejectsIncompleteTuples(t *testing.T) {
+	for name, mutate := range map[string]func(*sdkASMDataLiveObservation){
+		"missing-source":          func(o *sdkASMDataLiveObservation) { o.Objects.Sources = o.Objects.Sources[:1] },
+		"missing-CPP":             func(o *sdkASMDataLiveObservation) { o.CPP = o.CPP[:1] },
+		"missing-positions":       func(o *sdkASMDataLiveObservation) { o.Positions = o.Positions[:1] },
+		"missing-object-input":    func(o *sdkASMDataLiveObservation) { o.ObjectInputs.Sources = o.ObjectInputs.Sources[:1] },
+		"missing-compiler-member": func(o *sdkASMDataLiveObservation) { o.Objects.Members = o.Objects.Members[:3] },
+		"duplicate-selected-name": func(o *sdkASMDataLiveObservation) { o.Objects.Sources[1].Name = "mixed.s" },
+		"reordered-members": func(o *sdkASMDataLiveObservation) {
+			o.Objects.Members[2], o.Objects.Members[3] = o.Objects.Members[3], o.Objects.Members[2]
+		},
+		"reordered-CPP":   func(o *sdkASMDataLiveObservation) { o.CPP[0], o.CPP[1] = o.CPP[1], o.CPP[0] },
+		"expanded-source": func(o *sdkASMDataLiveObservation) { o.ObjectInputs.Sources[0].Expanded[0] ^= 1 },
+		"original-source": func(o *sdkASMDataLiveObservation) { o.ObjectInputs.Sources[0].Original[0] ^= 1 },
+		"original-object": func(o *sdkASMDataLiveObservation) { o.ObjectInputs.Sources[0].OriginalObject[0] ^= 1 },
+		"archive":         func(o *sdkASMDataLiveObservation) { o.ObjectInputs.Archive[0] ^= 1 },
+		"compiler-code":   func(o *sdkASMDataLiveObservation) { o.Objects.Members[2].Texts[0].Code[0] ^= 1 },
+		"compiler-PC":     func(o *sdkASMDataLiveObservation) { o.Objects.Members[2].Texts[0].PCLine = []byte{1} },
+		"compiler-relocation": func(o *sdkASMDataLiveObservation) {
+			o.Objects.Members[2].Texts[0].Relocations = []gostaticstorage.TextRelocation{{Offset: 0, Size: 1}}
+		},
+		"expanded-PC":   func(o *sdkASMDataLiveObservation) { o.Objects.Sources[0].Expanded.Texts[0].PCFile = []byte{1} },
+		"physical-name": func(o *sdkASMDataLiveObservation) { o.Objects.Sources[0].Original.Texts[0].Name += "foreign" },
+		"physical-ABI":  func(o *sdkASMDataLiveObservation) { o.Objects.Sources[0].Original.Texts[0].ABI = 0 },
+		"physical-namespace": func(o *sdkASMDataLiveObservation) {
+			o.Objects.Sources[0].Original.Texts[0].Namespace = gostaticstorage.TextSymbolHashed
+		},
+		"physical-index":   func(o *sdkASMDataLiveObservation) { o.Objects.Sources[0].TextOrder[0].Index++ },
+		"physical-ordinal": func(o *sdkASMDataLiveObservation) { o.Objects.Sources[0].TextOrder[0].ObjectOrdinal = 0 },
+		"unselected-sibling-PC": func(o *sdkASMDataLiveObservation) {
+			o.Objects.Members[3].Texts = []gostaticstorage.TextRecord{{Name: "omitted"}}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			original := sdkASMMetadataModel(t)
+			raw, _ := json.Marshal(original)
+			var changed sdkASMDataLiveObservation
+			if err := json.Unmarshal(raw, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			file, ordinal, err := sdkASMMetadataSelectedMember(changed, "mixed.s")
+			if file != nil || ordinal != -1 || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("incomplete/mutated complete metadata was selected", ordinal, err)
+			}
+		})
+	}
+	for _, name := range []string{"missing.s", "../mixed.s", "mixed.s/child", "", "mixed.o"} {
+		if file, ordinal, err := sdkASMMetadataSelectedMember(sdkASMMetadataModel(t), name); file != nil || ordinal != -1 || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unselected member acquired original-source metadata", name, ordinal, err)
+		}
+	}
+}
+
+func TestGoX86SDKASMMetadataCannotRestoreLiveSource(t *testing.T) {
+	raw, err := json.Marshal(sdkASMMetadataModel(t))
+	var restored GoX86SDKASMDataSource
+	if err != nil || json.Unmarshal(raw, &restored) != nil {
+		t.Fatal("diagnostic serialization", err)
+	}
+	for _, source := range []*GoX86SDKASMDataSource{nil, {}, {identity: &GoX86SDKASMDataSource{}}, &restored} {
+		if file, err := source.Assembly(context.Background(), "mixed.s"); file != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("public values restored a live source", err)
+		}
+	}
+}
+
+func TestGoX86SDKASMMetadataArchiveCountBound(t *testing.T) {
+	// Complete independent values test the existing bound; none is a live SDK.
+	for _, count := range []int{gostaticstorage.ArchiveMemberInventoryLimit - 2, gostaticstorage.ArchiveMemberInventoryLimit - 1} {
+		observation := sdkASMMetadataModel(t)
+		var names []string
+		for _, source := range observation.Objects.Sources {
+			names = append(names, source.Name)
+		}
+		for index := len(names); index < count; index++ {
+			name := fmt.Sprintf("empty-%d.s", index)
+			names = append(names, name)
+			observed := observation.Objects.Sources[1]
+			observed.Name = name
+			input := observation.ObjectInputs.Sources[1]
+			input.Name = name
+			member := observation.Objects.Members[3]
+			member.Ordinal, member.Name = index+2, fmt.Sprintf("empty-%d.o", index)
+			member.NameBytes = []byte(member.Name)
+			observation.Objects.Sources = append(observation.Objects.Sources, observed)
+			observation.ObjectInputs.Sources = append(observation.ObjectInputs.Sources, input)
+			observation.Objects.Members = append(observation.Objects.Members, member)
+			observation.CPP = append(observation.CPP, AssemblyCPPObservation{})
+			observation.Positions = append(observation.Positions, sdkCPPPositionObservation{})
+		}
+		observation.RawSelection, _ = json.Marshal(map[string]any{"ImportPath": "example", "Standard": true, "SFiles": names})
+		file, ordinal, err := sdkASMMetadataSelectedMember(observation, "mixed.s")
+		if count == gostaticstorage.ArchiveMemberInventoryLimit-2 {
+			if file == nil || ordinal != 0 || err != nil {
+				t.Fatal("existing complete archive bound shrank", err)
+			}
+		} else if file != nil || ordinal != -1 || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("complete archive member bound grew", err)
+		}
+	}
+}
diff --git a/go_x86_sdk_asm_text_source_order_go127_test.go b/go_x86_sdk_asm_text_source_order_go127_test.go
new file mode 100644
index 000000000..c77981ce1
--- /dev/null
+++ b/go_x86_sdk_asm_text_source_order_go127_test.go
@@ -0,0 +1,92 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoX86SDKASMDataOriginalBytealgTextSourceOrder(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/bytealg")
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete actual original SDK DATA/TEXT metadata", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	observed := source.observation.Objects
+	if len(observed.Sources) != len(source.guard.selection.SFiles) || len(observed.Sources) < 5 {
+		t.Fatal("metadata dropped an original selected source")
+	}
+	found := false
+	for ordinal, original := range observed.Sources {
+		if len(original.TextOrder) != len(original.Original.Texts) ||
+			!reflect.DeepEqual(original.Original.Texts, original.Expanded.Texts) ||
+			!reflect.DeepEqual(original.Original.Texts, observed.Members[ordinal+2].Texts) {
+			t.Fatal("association replaced complete original/expanded/compiler code/PC/relocation evidence")
+		}
+		if original.Name != "equal_amd64.s" {
+			continue
+		}
+		found = true
+		if len(original.TextOrder) != 3 || original.Original.Texts[0].Name != "memeqbody" ||
+			original.Original.Texts[0].ABI != 65535 || original.Original.Texts[0].Namespace != gostaticstorage.TextSymbolSelf {
+			t.Fatal("the actual private helper was moved out of its original physical bank")
+		}
+		var order []int
+		var names []string
+		for _, association := range original.TextOrder {
+			order = append(order, association.ObjectOrdinal)
+			names = append(names, association.Name)
+		}
+		if !reflect.DeepEqual(order, []int{1, 2, 0}) ||
+			!reflect.DeepEqual(names, []string{"runtime.memequal", "runtime.memequal_varlen", "memeqbody"}) {
+			t.Fatal("complete source TEXT ordinal mapping differs", order, names)
+		}
+	}
+	if !found || source.guard.ready || source.guard.request.NumericalReads != nil {
+		t.Fatal("TEXT association omitted source or granted numerical/native authority")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("live original source/code/PC/relocation observation changed", err)
+	}
+	// A source-ordinal association cannot replace original code equality.
+	for _, role := range []string{"original", "expanded"} {
+		var changed gostaticstorage.SDKASMDataObservationRequest
+		raw, err := json.Marshal(source.observation.ObjectInputs)
+		if err != nil || json.Unmarshal(raw, &changed) != nil {
+			t.Fatal("clone complete original observation", err)
+		}
+		for index, original := range observed.Sources {
+			if original.Name != "equal_amd64.s" {
+				continue
+			}
+			code := original.Original.Texts[0].Code
+			object := &changed.Sources[index].OriginalObject
+			if role == "expanded" {
+				object = &changed.Sources[index].ExpandedObject
+			}
+			start := bytes.Index(*object, code)
+			if start < 0 || len(code) == 0 || bytes.Index((*object)[start+1:], code) >= 0 {
+				t.Fatal("actual complete helper code lacks a unique physical interval")
+			}
+			(*object)[start] ^= 1
+		}
+		if value, err := gostaticstorage.ObserveX86SDKCPPASMData(changed); value != nil || !errors.Is(err, gostaticstorage.ErrContext) {
+			t.Fatal("source mapping disguised changed original/expanded machine code", role, err)
+		}
+	}
+	source.observation.Objects.Sources[0].TextOrder[0].SourceOrdinal++
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("mutated source/object ordinal association survived live verification", err)
+	}
+}
diff --git a/go_x86_sdk_literal_address_test.go b/go_x86_sdk_literal_address_test.go
new file mode 100644
index 000000000..168c13e3f
--- /dev/null
+++ b/go_x86_sdk_literal_address_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This is an operand-role query, not a live factory or memory certificate.
+// The unrelated package/name counterexample keeps the class independent of maps.
+func TestGoX86SDKLiteralObservedAddressAndIndexedGrammar(t *testing.T) {
+	source := &GoX86NumericalReadSource{request: GoX86NumericalReadCaptureRequest{PackagePath: "example.invalid/tableowner"},
+		literals: &numericalSDKLiteralJoin{SourceOrdinal: 0,
+			Initializers: sdkReadonlyLiteralDataReport{Initializers: []gostaticstorage.ReadonlyLiteralDataImage{{
+				SourceOrdinal: 0, Definition: gostaticstorage.ASMDataDefinition{Name: "numericTable"},
+				Initial: make([]byte, 256),
+			}}},
+		},
+	}
+	for _, test := range []struct {
+		arch, instruction string
+		admitted          bool
+	}{
+		{"amd64", "MOVQ $numericTable<>(SB), AX", true},
+		{"amd64", "LEAQ numericTable<>(SB), AX", true},
+		{"amd64", "LEAQ numericTable<>+256(SB), AX", true},
+		{"386", "MOVL $numericTable<>(SB), AX", true},
+		{"386", "LEAL numericTable<>(SB), AX", true},
+		{"386", "PAND numericTable<>(SB)(CX*8), X0", true},
+		{"386", "PSHUFB numericTable<>(SB)(CX*8), X0", true},
+		{"386", "MOVL numericTable<>+4(SB)(BP)(CX*4), AX", true},
+		{"amd64", "LEAL numericTable<>(SB), AX", false},
+		{"amd64", "MOVL $numericTable<>(SB), AX", false},
+		{"amd64", "LEAQ numericTable<>-1(SB), AX", false},
+		{"amd64", "LEAQ numericTable<>+257(SB), AX", false},
+		{"amd64", "MOVQ $numericTable<>(SB), SP", false},
+		{"amd64", "MOVQ $numericTable<>(SB), X0", false},
+		{"386", "MOVL AX, numericTable<>(SB)(CX*8)", false},
+		{"386", "CALL numericTable<>(SB)(CX*8)", false},
+	} {
+		t.Run(test.arch+"/"+test.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			operand := 0
+			if test.instruction == "MOVL AX, numericTable<>(SB)(CX*8)" {
+				operand = 1
+			}
+			local, err := source.sdkLiteralRead(file.Funcs[0].Instrs[1], operand, test.arch)
+			if !local || test.admitted && err != nil || !test.admitted && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("observed private address/read role changed", local, err)
+			}
+			if source.ready || source.identity != nil {
+				t.Fatal("an operand query forged source or numerical-memory authority")
+			}
+		})
+	}
+}
diff --git a/go_x86_sdk_literal_alias_test.go b/go_x86_sdk_literal_alias_test.go
new file mode 100644
index 000000000..e773c541f
--- /dev/null
+++ b/go_x86_sdk_literal_alias_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestGoX86SDKLiteralCompleteOriginalMOVQAliases(t *testing.T) {
+	registration, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := make(map[Op]Op)
+	functions := 0
+	for _, declaration := range registration.Decls {
+		function, valid := declaration.(*ast.FuncDecl)
+		if !valid || function.Name.Name != "archX86" {
+			continue
+		}
+		functions++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, valid := node.(*ast.AssignStmt)
+			if !valid || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			selector, valid := assignment.Rhs[0].(*ast.SelectorExpr)
+			if !valid || selector.Sel.Name != "AMOVQ" {
+				return true
+			}
+			index, indexed := assignment.Lhs[0].(*ast.IndexExpr)
+			owner, owned := selector.X.(*ast.Ident)
+			if !indexed || !owned || owner.Name != "x86" {
+				t.Fatal("unknown original MOVQ source registration")
+			}
+			bank, registered := index.X.(*ast.Ident)
+			literal, named := index.Index.(*ast.BasicLit)
+			if !registered || bank.Name != "instructions" || !named || literal.Kind != token.STRING {
+				t.Fatal("unknown original MOVQ source alias name")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil || actual[Op(name)] != "" {
+				t.Fatal("duplicate or unbound original MOVQ alias", name, err)
+			}
+			actual[Op(name)] = "MOVQ"
+			return true
+		})
+	}
+	if functions != 1 || !reflect.DeepEqual(actual, x86GoMOVQSourceAliases) || !reflect.DeepEqual(actual, map[Op]Op{"MOVD": "MOVQ", "MOVDQ2Q": "MOVQ"}) {
+		t.Fatal("complete Go MOVQ source registrations changed", actual)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operands := range []string{"$numericTable<>(SB),BX", "BX,DX", "AX,CX", "numericTable<>(SB)(CX*8),X0"} {
+			accepted := arch == "amd64" && operands != "numericTable<>(SB)(CX*8),X0" || arch == "386" && operands == "numericTable<>(SB)(CX*8),X0"
+			for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+				t.Run(arch+"/"+alias+"/"+operands, func(t *testing.T) {
+					source := "TEXT native(SB),4,$0-0\n" + alias + " " + operands + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", accepted)
+					if accepted {
+						canonical := strings.Replace(source, alias+" ", "MOVQ ", 1)
+						if !bytes.Equal(x86OrderingHintGoBytes(t, arch, source), x86OrderingHintGoBytes(t, arch, canonical)) {
+							t.Fatal("original private/address/register alias bytes differ from Go MOVQ")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestGoX86SDKLiteralAliasesPreserveAddressCopiesAndIndices(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		for name, body := range map[string]string{
+			"materialization": strings.Replace(x86SDKLiteralBoundedFixture, "MOVQ $numericTable<>(SB),BX", alias+" $numericTable<>(SB),BX", 1),
+			"pointer copy":    strings.Replace(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", alias+" BX,DX\nMOVOU (DX)(AX*8),X0", 1),
+			"index copy":      strings.Replace(strings.Replace(x86SDKLiteralBoundedFixture, "ADDQ AX,AX", alias+" AX,CX\nADDQ CX,CX", 1), "(AX*8)", "(CX*8)", 1),
+			"read":            strings.Replace(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", alias+" (BX)(AX*8),X0", 1),
+			"unwritten index": strings.Replace(x86SDKLiteralBoundedFixture, "ADDQ AX,AX", alias+" AX,X0\nADDQ AX,AX", 1),
+		} {
+			t.Run(alias+"/"+name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, body)
+				if err != nil {
+					t.Fatal(err)
+				}
+				original := append([]Instr(nil), file.Funcs[0].Instrs...)
+				sig := FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64}, Ret: I64}
+				facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericTable<>": 256})
+				width := int64(16)
+				if name == "read" {
+					width = 8
+				}
+				if err != nil || len(facts) != 2 || !facts[0].Address || facts[1].Address || facts[1].Minimum != 0 || facts[1].Maximum != 240 || facts[1].Width != width {
+					t.Fatal("complete Go alias lost its bounded literal address/read class", facts, err)
+				}
+				if !reflect.DeepEqual(original, file.Funcs[0].Instrs) {
+					t.Fatal("local alias dispatch rewrote original source Op/Raw")
+				}
+				for _, fact := range facts {
+					if !reflect.DeepEqual(fact.Original, original[fact.Instruction]) {
+						t.Fatal("literal fact seals a canonical replacement, not the original source")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKLiteralAliasesCannotGrantRawOrMode32Pointers(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-0\n"+alias+" $numericTable<>(SB),BX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, valid := x86SDKLiteralOperandProperties(file.Funcs[0].Instrs[1], 0, "386"); valid {
+			t.Fatal("Go's pre-Pw8 mode32 alias rows granted a full-word GP pointer", alias)
+		}
+		for _, mark := range []func(*Instr){
+			func(ins *Instr) { ins.x86Encoded = true },
+			func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{} },
+		} {
+			original := file.Funcs[0]
+			original.Instrs = append([]Instr(nil), original.Instrs...)
+			mark(&original.Instrs[1])
+			facts, err := proveX86SDKLiteralAccesses(original, FuncSig{Name: "example.invalid/tableowner.entry", Ret: Void}, "amd64", map[string]int64{"numericTable<>": 256})
+			if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a source alias changed raw/native origin into literal authority", alias, facts, err)
+			}
+		}
+	}
+}
+
+func TestGoX86SDKLiteralAliasesMode32BoundedReadonlyRead(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		body := "MOVL n+0(FP),CX\nCMPL CX,$16\nJAE done\nADDL CX,CX\n" + alias +
+			" numericTable<>(SB)(CX*8),X0\ndone:\nMOVL $0,ret0+4(FP)\nRET"
+		_, file, sig, source := x86ResultInitializationFixture(t, "386", "func Value(n uint32) uint32", body)
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "386", map[string]int64{"numericTable<>": 256})
+		if err != nil || len(facts) != 1 || facts[0].Address || facts[0].Minimum != 0 || facts[0].Maximum != 240 || facts[0].Width != 8 || facts[0].Original.Op != Op(alias) {
+			t.Fatal("mode32 source alias lost its actual pre-Pw8 bounded XMM memory row", alias, facts, err)
+		}
+	}
+}
+
+func TestGoX86SDKLiteralRawBeforeMaterializationRemainsContext(t *testing.T) {
+	for _, directive := range []string{"BYTE", "WORD", "LONG", "QUAD"} {
+		file, err := Parse(ArchAMD64, "TEXT ·entry<ABIInternal>(SB),4,$0-0\n"+directive+" $0x90\nMOVQ $numericTable<>(SB),BX\nMOVQ (BX),AX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], FuncSig{Name: "example.invalid/tableowner.entry", Ret: I64}, "amd64", map[string]int64{"numericTable<>": 256})
+		if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("raw source before a literal carrier escaped the separate native CFG contract", directive, facts, err)
+		}
+	}
+}
+
+func TestGoX86SDKLiteralAliasesRetainIndependentContracts(t *testing.T) {
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		for _, alteration := range []struct{ before, after string }{
+			{"CMPQ AX,$16\nJAE done\n", ""},
+			{"JAE done", "MOVQ $32,AX\nJAE done"},
+			{"MOVOU (BX)(AX*8),X0", "MOVOU X0,(BX)(AX*8)"},
+			{"MOVOU (BX)(AX*8),X0", alias + " BX,X0"},
+			{"MOVOU (BX)(AX*8),X0", "MOVB $0,BL\nMOVOU (BX)(AX*8),X0"},
+			{"MOVOU (BX)(AX*8),X0", "TESTQ $15,BX"},
+			{"MOVQ X0,AX", alias + " BX,AX"},
+		} {
+			body := strings.Replace(x86SDKLiteralBoundedFixture, "MOVQ $numericTable<>(SB),BX", alias+" $numericTable<>(SB),BX", 1)
+			body = strings.Replace(body, alteration.before, alteration.after, 1)
+			file, err := Parse(ArchAMD64, body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64}, Ret: I64}, "amd64", map[string]int64{"numericTable<>": 256})
+			if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("MOVQ source alias granted another pointer/index/FLAGS/address-bit contract", alias, body, facts, err)
+			}
+		}
+	}
+}
diff --git a/go_x86_sdk_literal_alignment.go b/go_x86_sdk_literal_alignment.go
new file mode 100644
index 000000000..a7bfcfb11
--- /dev/null
+++ b/go_x86_sdk_literal_alignment.go
@@ -0,0 +1,520 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// GoX86SDKLiteralAlignment observes original linked literal layout only.
+// It supplies neither a numerical address nor execution, ABI or read authority.
+// Its original source and independent initializer owner remain borrowed/live.
+type GoX86SDKLiteralAlignment struct {
+	mu, operation            sync.Mutex
+	identity                 *GoX86SDKLiteralAlignment
+	ready                    bool
+	generation               uint64
+	active                   int
+	closePending             bool
+	owner, originalOwner     *GoX86SDKReadonlyLiteralDataOwner
+	ownerGeneration          uint64
+	ownerSeal                [32]byte
+	guard, originalGuard     *GoAMD64FrameSource
+	directories              map[string]os.FileInfo
+	context, originalContext context.Context
+	deadline                 time.Time
+	report                   []byte
+	seal, stateSeal          [32]byte
+	observation              sdkLiteralAlignmentReport
+}
+
+type sdkLiteralMinimumAlignment struct {
+	SourceOrdinal, MemberOrdinal int
+	Namespace                    gostaticstorage.TextSymbolNamespace
+	Index                        uint32
+	Name                         string
+	Size, MinimumAlignment       uint32
+}
+
+type sdkLiteralAlignmentReport struct {
+	Protocol, PackagePath, Target, CGOEnabled, BuildMode string
+	InitializerSHA256                                    [32]byte
+	Graph                                                []byte
+	Inputs                                               map[string][32]byte
+	Commands                                             []numericalSBCommand
+	Minima                                               []sdkLiteralMinimumAlignment
+}
+
+const sdkLiteralAlignmentProtocol = "actual_go_sdk_linked_literal_minimum_alignment_v1"
+
+// CaptureGoX86SDKLiteralAlignment links untouched original SDK archives through
+// an ordinary generated empty main. It never imports an internal package, uses
+// linkname/-E, changes SDK source, or invents a callable ABI. Internal candidates
+// must already be natural dependencies of runtime; otherwise they stay Context.
+// Dead-stripped or ambiguously named objects receive no minimum-alignment row.
+func CaptureGoX86SDKLiteralAlignment(ctx context.Context, owner *GoX86SDKReadonlyLiteralDataOwner) (_ *GoX86SDKLiteralAlignment, result error) {
+	if ctx == nil || owner == nil || owner.identity != owner {
+		return nil, sdkASMDataContext("minimum alignment requires its original live literal owner")
+	}
+	if err := owner.Verify(ctx); err != nil {
+		return nil, err
+	}
+	deadline, bounded := ctx.Deadline()
+	if !bounded || !reflect.TypeOf(ctx).Comparable() {
+		return nil, sdkASMDataContext("minimum alignment requires one bounded original context")
+	}
+	owner.mu.Lock()
+	source, generation, seal := owner.source, owner.generation, owner.seal
+	owner.mu.Unlock()
+	if source == nil || source.identity != source {
+		return nil, sdkASMDataContext("minimum alignment requires its original SDK source")
+	}
+	// The selected linker/layout inputs are byte-identical in these patches.
+	// Actual input, compiler, linker and image checks below remain mandatory.
+	version := source.guard.env["GOVERSION"]
+	if version != "go1.27.2" && version != "go1.27.3" {
+		return nil, sdkASMDataContext("minimum alignment requires the registered original Go 1.27.2 or Go 1.27.3 SDK")
+	}
+	request := source.request
+	guard := newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, Target: request.Target, Environment: append([]string(nil), request.Environment...)})
+	guard.env = make(map[string]string, len(source.guard.env))
+	for key, value := range source.guard.env {
+		guard.env[key] = value
+	}
+	guard.selection = source.guard.selection
+	observed := &GoX86SDKLiteralAlignment{owner: owner, originalOwner: owner, ownerGeneration: generation,
+		ownerSeal: seal, guard: guard, originalGuard: guard, context: ctx, originalContext: ctx, deadline: deadline,
+		directories: make(map[string]os.FileInfo)}
+	observed.identity = observed
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, observed.Close())
+		}
+	}()
+	provided, err := sdkASMDataEnvironment(request)
+	if err != nil {
+		return nil, err
+	}
+	guard.owned, err = os.MkdirTemp(provided["TMPDIR"], "plan9asm-sdk-literal-alignment-")
+	if err != nil {
+		return nil, err
+	}
+	guard.owned, err = sourcepath.Resolve(guard.owned)
+	if err != nil {
+		return nil, err
+	}
+	guard.ownedInfo, err = sourcepath.Lstat(guard.owned)
+	if err != nil {
+		return nil, err
+	}
+	if err := captureSDKPackageDirectoryInputs(guard, observed.retainDirectory); err != nil {
+		return nil, err
+	}
+	for _, dir := range []string{request.Directory, guard.env["GOROOT"], guard.env["GOTOOLDIR"], guard.env["GOCACHE"], guard.owned} {
+		if err := observed.retainDirectory(dir); err != nil {
+			return nil, err
+		}
+	}
+	observed.observation = sdkLiteralAlignmentReport{Protocol: sdkLiteralAlignmentProtocol,
+		PackagePath: request.PackagePath, Target: request.Target, CGOEnabled: provided["CGO_ENABLED"],
+		BuildMode: "exe", InitializerSHA256: seal}
+	if guard.env["GOOS"] == "darwin" || guard.env["GOOS"] == "windows" {
+		observed.observation.BuildMode = "pie"
+	}
+	if err := observed.capture(ctx); err != nil {
+		return nil, err
+	}
+	observed.observation.Inputs = cloneSDKASMDataInputs(guard.inputs)
+	observed.report, err = json.Marshal(observed.observation)
+	if err != nil {
+		return nil, err
+	}
+	observed.seal = sha256.Sum256(observed.report)
+	observed.stateSeal, err = observed.digest()
+	if err != nil {
+		return nil, err
+	}
+	observed.ready, observed.generation = true, 1
+	if err := observed.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return observed, nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) capture(ctx context.Context) error {
+	guard, root := observed.guard, observed.guard.env["GOROOT"]
+	for _, tool := range []string{"link", "compile"} {
+		route, err := observed.run(ctx, "tool", "-n", tool)
+		if err != nil {
+			return err
+		}
+		name := strings.TrimSpace(string(route))
+		if name != filepath.Join(guard.env["GOTOOLDIR"], gotoolchain.HostExecutable(tool)) {
+			return sdkASMDataContext("minimum alignment lost actual %s tool route", tool)
+		}
+		if _, err := guard.read(name); err != nil {
+			return err
+		}
+		version, err := observed.run(ctx, "tool", tool, "-V")
+		if err != nil {
+			return err
+		}
+		if strings.TrimSpace(string(version)) != tool+" version "+guard.env["GOVERSION"] {
+			return sdkASMDataContext("minimum alignment actual %s binary version differs from its SDK", tool)
+		}
+	}
+	directory := guard.env["GOARCH"]
+	if directory == "386" {
+		directory = "x86"
+	}
+	var rule [][]byte
+	for _, name := range []string{"src/cmd/link/internal/ld/data.go", "src/cmd/link/internal/loader/loader.go",
+		"src/cmd/link/internal/" + directory + "/l.go", "src/cmd/link/internal/" + directory + "/obj.go",
+		"src/cmd/link/internal/ld/lib.go", "src/cmd/link/internal/ld/deadcode.go", "src/cmd/link/internal/ld/elf.go",
+		"src/cmd/link/internal/ld/macho.go", "src/cmd/link/internal/ld/pe.go", "src/cmd/link/internal/ld/main.go",
+		"src/internal/platform/supported.go", "src/cmd/go/internal/work/build.go", "src/cmd/go/internal/work/gc.go"} {
+		data, err := guard.read(filepath.Join(root, filepath.FromSlash(name)))
+		if err != nil {
+			return err
+		}
+		rule = append(rule, data)
+	}
+	if err := verifyGoAssemblyDataAlignmentRule(rule[0], rule[1], rule[2], rule[3]); err != nil {
+		return err
+	}
+	if err := verifyGoLiteralDefaultPIE(rule[10]); err != nil {
+		return err
+	}
+	graph, err := observed.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", "runtime", observed.observation.PackagePath)
+	if err != nil {
+		return err
+	}
+	imports, err := observed.bindLinkGraph(graph)
+	if err != nil {
+		return err
+	}
+	guard.imports, observed.observation.Graph = imports, graph
+	for _, selected := range append([]goAMD64FrameSelection{guard.selection}, frameImportGraphValues(imports)...) {
+		if !selected.Standard || selected.Module != nil {
+			return sdkASMDataContext("minimum alignment graph is not the invoked SDK")
+		}
+		if err := observed.retainDirectory(selected.Dir); err != nil {
+			return err
+		}
+	}
+	archives := make(map[string]gostaticstorage.SDKReferencedArchive)
+	var config strings.Builder
+	selected := make(map[string]goAMD64FrameSelection, len(imports)+1)
+	for path, dependency := range imports {
+		selected[path] = dependency
+	}
+	selected[guard.selection.ImportPath] = guard.selection
+	paths := make([]string, 0, len(selected))
+	for path := range selected {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	for _, path := range paths {
+		dependency := selected[path]
+		if path == "unsafe" {
+			continue
+		}
+		if strings.ContainsAny(path, "\x00\r\n=\\ \t") || strings.ContainsAny(dependency.Export, "\x00\r\n") || strings.TrimSpace(dependency.Export) != dependency.Export {
+			return sdkASMDataContext("minimum alignment importcfg is not exact")
+		}
+		archive, err := guard.read(dependency.Export)
+		if err != nil {
+			return err
+		}
+		archives[path] = gostaticstorage.SDKReferencedArchive{PackagePath: path, Sources: dependency.SFiles, Archive: archive}
+		fmt.Fprintf(&config, "packagefile %s=%s\n", path, dependency.Export)
+	}
+	inventory, err := gostaticstorage.SDKArchiveDefinitionInventory(archives, observed.observation.Target)
+	if err != nil {
+		return err
+	}
+	program := "package main\nfunc main() {}\n"
+	pkg := observed.observation.PackagePath
+	if !strings.HasPrefix(pkg, "internal/") && !strings.Contains(pkg, "/internal/") {
+		program = "package main\nimport _ " + strconv.Quote(pkg) + "\nfunc main() {}\n"
+	}
+	// No internal import bypass: a direct compile has no such import at all.
+	// Only the ordinary runtime link can naturally retain internal candidates.
+	main, err := observed.artifact("main.go", []byte(program))
+	if err != nil {
+		return err
+	}
+	configPath, err := observed.artifact("importcfg", []byte(config.String()))
+	if err != nil {
+		return err
+	}
+	object, image := filepath.Join(guard.owned, "main.a"), filepath.Join(guard.owned, "original-linked")
+	args := []string{"tool", "compile", "-p", "main", "-lang=go1.27", "-goversion", guard.env["GOVERSION"], "-importcfg", configPath, "-o", object}
+	if guard.env["GOOS"] == "darwin" {
+		args = append(args, "-shared")
+	}
+	args = append(args, main)
+	if _, err := observed.run(ctx, args...); err != nil {
+		return err
+	}
+	if _, err := guard.read(object); err != nil {
+		return err
+	}
+	args = []string{"tool", "link", "-buildmode=" + observed.observation.BuildMode, "-importcfg", configPath, "-o", image, object}
+	if _, err := observed.run(ctx, args...); err != nil {
+		return err
+	}
+	linked, err := guard.read(image)
+	if err != nil {
+		return err
+	}
+	observed.owner.mu.Lock()
+	initializerBytes := append([]byte(nil), observed.owner.report...)
+	observed.owner.mu.Unlock()
+	var initializer sdkReadonlyLiteralDataReport
+	if json.Unmarshal(initializerBytes, &initializer) != nil {
+		return sdkASMDataContext("minimum alignment lost exact initializers")
+	}
+	minima, err := sdkLiteralLinkedMinima(linked, observed.observation.Target, pkg, initializer.Initializers, inventory)
+	if err != nil {
+		return err
+	}
+	if len(minima) == 0 {
+		return sdkASMDataContext("no uniquely retained original literal has observed minimum alignment")
+	}
+	observed.observation.Minima = minima
+	return nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) artifact(name string, data []byte) (string, error) {
+	path := filepath.Join(observed.guard.owned, name)
+	if err := os.WriteFile(path, data, 0600); err != nil {
+		return "", err
+	}
+	_, err := observed.guard.read(path)
+	return path, err
+}
+
+func (observed *GoX86SDKLiteralAlignment) retainDirectory(name string) error {
+	resolved, err := sourcepath.Resolve(name)
+	info, statErr := sourcepath.Lstat(name)
+	if err != nil || statErr != nil || resolved != name || !filepath.IsAbs(name) || !info.IsDir() {
+		return sdkASMDataContext("minimum alignment directory is redirected or unavailable")
+	}
+	observed.directories[name] = info
+	return nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) verifyDirectories() error {
+	for name, before := range observed.directories {
+		resolved, err := sourcepath.Resolve(name)
+		after, statErr := sourcepath.Lstat(name)
+		if err != nil || statErr != nil || resolved != name || !after.IsDir() || !os.SameFile(before, after) {
+			return sdkASMDataContext("minimum alignment input directory identity changed")
+		}
+	}
+	return nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) run(ctx context.Context, args ...string) ([]byte, error) {
+	if err := errors.Join(observed.guard.verifyInputs(), observed.verifyDirectories(), ctx.Err()); err != nil {
+		return nil, err
+	}
+	commandContext, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	output, err := goasmcmd.Run(commandContext, observed.guard.request.Directory, observed.guard.request.Environment, observed.guard.request.GoBinary, args...)
+	err = errors.Join(err, commandContext.Err(), observed.guard.verifyInputs(), observed.verifyDirectories())
+	if err == nil {
+		observed.observation.Commands = append(observed.observation.Commands, numericalSBCommand{
+			Directory: observed.guard.request.Directory, Binary: observed.guard.request.GoBinary,
+			Arguments: append([]string(nil), args...), Stdout: append([]byte(nil), output...)})
+	}
+	return output, err
+}
+
+func (observed *GoX86SDKLiteralAlignment) liveContext(ctx context.Context) error {
+	if ctx == nil || observed.context == nil || observed.originalContext == nil ||
+		reflect.TypeOf(observed.context) != reflect.TypeOf(observed.originalContext) || !reflect.TypeOf(observed.context).Comparable() || observed.context != observed.originalContext {
+		return sdkASMDataContext("minimum alignment original context identity changed")
+	}
+	_, err := sampleGoSourceContext(ctx, observed.context,
+		goSourceContextLifetime{deadline: observed.deadline, bounded: true}, false,
+		sdkASMDataContext("minimum alignment original deadline changed or canceled without a cause"))
+	return err
+}
+
+func (observed *GoX86SDKLiteralAlignment) verifyOwner() error {
+	owner := observed.owner
+	if owner == nil || owner != observed.originalOwner || owner.identity != owner {
+		return sdkASMDataContext("minimum alignment borrowed another initializer")
+	}
+	owner.mu.Lock()
+	valid := owner.ready && owner.generation == observed.ownerGeneration && owner.seal == observed.ownerSeal && sha256.Sum256(owner.report) == observed.ownerSeal
+	owner.mu.Unlock()
+	if !valid {
+		return sdkASMDataContext("minimum alignment initializer is closed, stale or changed")
+	}
+	return owner.verifySourceGeneration()
+}
+
+func (observed *GoX86SDKLiteralAlignment) digest() ([32]byte, error) {
+	raw, err := json.Marshal(struct {
+		Observation sdkLiteralAlignmentReport
+		Request     GoAMD64FrameCaptureRequest
+		Inputs      map[string][32]byte
+		Environment map[string]string
+		Selection   goAMD64FrameSelection
+		Imports     map[string]goAMD64FrameSelection
+		Deadline    time.Time
+	}{observed.observation, observed.guard.request, observed.guard.inputs, observed.guard.env, observed.guard.selection, observed.guard.imports, observed.deadline})
+	return sha256.Sum256(raw), err
+}
+
+// Verify invokes caller contexts/borrowed owners outside locks. A lease protects
+// only the factory's own artifacts during callback reentry and Close.
+func (observed *GoX86SDKLiteralAlignment) Verify(ctx context.Context) (result error) {
+	if observed == nil || observed.identity != observed {
+		return sdkASMDataContext("copied or missing minimum alignment observation")
+	}
+	observed.mu.Lock()
+	ready, generation := observed.ready, observed.generation
+	if ready {
+		observed.active++
+	}
+	observed.mu.Unlock()
+	if !ready {
+		return sdkASMDataContext("minimum alignment observation is closed or revoked")
+	}
+	defer func() {
+		result = errors.Join(result, observed.liveContext(ctx), observed.verifyOwner())
+		observed.mu.Lock()
+		if observed.generation != generation || !observed.ready {
+			result = errors.Join(result, sdkASMDataContext("minimum alignment closed during verification"))
+		}
+		if result != nil {
+			observed.ready = false
+			observed.generation++
+		}
+		observed.active--
+		cleanup := observed.closePending && observed.active == 0
+		observed.mu.Unlock()
+		if cleanup {
+			observed.operation.Lock()
+			result = errors.Join(result, observed.guard.Close())
+			observed.operation.Unlock()
+		}
+	}()
+	if err := observed.liveContext(ctx); err != nil {
+		return err
+	}
+	if err := observed.verifyOwner(); err != nil {
+		return err
+	}
+	if err := observed.owner.Verify(ctx); err != nil {
+		return err
+	}
+	private, stop, err := sdkASMDataPrivateContext(ctx, observed.context, observed.deadline)
+	if err != nil {
+		return err
+	}
+	defer stop()
+	observed.operation.Lock()
+	result = observed.verifyState(private)
+	observed.operation.Unlock()
+	if result != nil {
+		return result
+	}
+	return observed.owner.Verify(ctx)
+}
+
+func (observed *GoX86SDKLiteralAlignment) verifyState(ctx context.Context) error {
+	guard := observed.guard
+	if guard == nil || guard != observed.originalGuard || guard.identity != guard || guard.ready || guard.request.NumericalReads != nil || guard.numericalOrigin != nil || guard.downloadedOrigin != nil {
+		return sdkASMDataContext("minimum alignment guard acquired a foreign authority")
+	}
+	before, err := observed.digest()
+	if err != nil || before != observed.stateSeal || sha256.Sum256(observed.report) != observed.seal {
+		return sdkASMDataContext("minimum alignment sealed source/linker/profile/object state changed")
+	}
+	commands := observed.observation.Commands
+	defer func() { observed.observation.Commands = commands }()
+	graph, err := observed.run(ctx, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", "runtime", observed.observation.PackagePath)
+	if err != nil {
+		return err
+	}
+	imports, err := observed.bindLinkGraph(graph)
+	if err != nil || !reflect.DeepEqual(imports, guard.imports) || !numericalSameRawSDKGraph(graph, observed.observation.Graph) {
+		return sdkASMDataContext("minimum alignment complete original SDK graph changed: %v", err)
+	}
+	observed.observation.Commands = commands
+	after, err := observed.digest()
+	if err != nil || after != observed.stateSeal {
+		return sdkASMDataContext("minimum alignment source/linker inputs changed during verification")
+	}
+	return errors.Join(guard.verifyInputs(), observed.verifyDirectories(), ctx.Err())
+}
+
+func (observed *GoX86SDKLiteralAlignment) Readback(ctx context.Context) ([]byte, error) {
+	if err := observed.Verify(ctx); err != nil {
+		return nil, err
+	}
+	observed.mu.Lock()
+	defer observed.mu.Unlock()
+	if !observed.ready {
+		return nil, sdkASMDataContext("minimum alignment closed after verification")
+	}
+	return append([]byte(nil), observed.report...), nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) CheckReadback(ctx context.Context, raw []byte) error {
+	actual, err := observed.Readback(ctx)
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(actual, raw) {
+		observed.mu.Lock()
+		observed.ready = false
+		observed.generation++
+		observed.mu.Unlock()
+		return sdkASMDataContext("minimum alignment public report bytes differ")
+	}
+	return nil
+}
+
+func (observed *GoX86SDKLiteralAlignment) Close() error {
+	if observed == nil {
+		return nil
+	}
+	if observed.identity != observed || observed.guard == nil || observed.guard != observed.originalGuard || observed.guard.identity != observed.guard {
+		return sdkASMDataContext("copied minimum alignment cannot dispose original artifacts")
+	}
+	observed.mu.Lock()
+	observed.ready = false
+	observed.generation++
+	observed.closePending = true
+	active := observed.active
+	observed.mu.Unlock()
+	if active != 0 {
+		return nil
+	}
+	observed.operation.Lock()
+	defer observed.operation.Unlock()
+	return observed.guard.Close()
+}
diff --git a/go_x86_sdk_literal_alignment_controls_go127_test.go b/go_x86_sdk_literal_alignment_controls_go127_test.go
new file mode 100644
index 000000000..c62184119
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_controls_go127_test.go
@@ -0,0 +1,158 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"debug/elf"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoX86SDKLiteralAlignmentIndependentArchiveAndImageGuards(t *testing.T) {
+	ctx, _, owner, observed := sdkLiteralAlignmentCapture(t)
+	var initializers sdkReadonlyLiteralDataReport
+	if json.Unmarshal(owner.report, &initializers) != nil {
+		t.Fatal("actual initializer report")
+	}
+	archives := make(map[string]gostaticstorage.SDKReferencedArchive)
+	for path, selection := range observed.guard.imports {
+		if path == "unsafe" {
+			continue
+		}
+		data, err := os.ReadFile(selection.Export)
+		if err != nil {
+			t.Fatal(err)
+		}
+		archives[path] = gostaticstorage.SDKReferencedArchive{PackagePath: path, Sources: selection.SFiles, Archive: data}
+	}
+	inventory, err := gostaticstorage.SDKArchiveDefinitionInventory(archives, observed.observation.Target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	image, err := os.ReadFile(filepath.Join(observed.guard.owned, "original-linked"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	minima, err := sdkLiteralLinkedMinima(image, observed.observation.Target, observed.observation.PackagePath, initializers.Initializers, inventory)
+	if err != nil || len(minima) != 2 {
+		t.Fatal("independent original source/object/image replay", err)
+	}
+	duplicated := append([]gostaticstorage.SDKArchiveDefinitionIdentity(nil), inventory...)
+	for _, definition := range inventory {
+		for _, literal := range initializers.Initializers {
+			if definition.Name == literal.Definition.Name {
+				definition.PackagePath = "independent/other/source"
+				duplicated = append(duplicated, definition)
+			}
+		}
+	}
+	if minima, err := sdkLiteralLinkedMinima(image, observed.observation.Target, observed.observation.PackagePath, initializers.Initializers, duplicated); err != nil || len(minima) != 0 {
+		t.Fatal("equal source/name/bytes selected a winner from distinct object namespaces", len(minima), err)
+	}
+	if minima, err := sdkLiteralLinkedMinima(image, "windows/amd64", observed.observation.PackagePath, initializers.Initializers, inventory); minima != nil || err == nil {
+		t.Fatal("cross-target linked bytes borrowed a layout role")
+	}
+	file, err := elf.NewFile(bytes.NewReader(image))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	symbols, err := file.Symbols()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"misaligned-symbol", "writable-section", "insufficient-section-alignment", "changed-initializer"} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := append([]byte(nil), image...)
+			index, sectionIndex := -1, -1
+			for ordinal, symbol := range symbols {
+				if symbol.Name == initializers.Initializers[0].Definition.Name {
+					index, sectionIndex = ordinal, int(symbol.Section)
+					break
+				}
+			}
+			if index < 0 || sectionIndex < 0 {
+				t.Fatal("independent original ELF symbol")
+			}
+			section := file.Sections[sectionIndex]
+			symbol := symbols[index]
+			header := binary.LittleEndian.Uint64(changed[40:]) + uint64(sectionIndex)*uint64(binary.LittleEndian.Uint16(changed[58:]))
+			switch mutation {
+			case "misaligned-symbol":
+				position := file.Section(".symtab").Offset + uint64(index+1)*24 + 8
+				binary.LittleEndian.PutUint64(changed[position:], symbol.Value+1)
+			case "writable-section":
+				binary.LittleEndian.PutUint64(changed[header+8:], uint64(section.Flags|elf.SHF_WRITE))
+			case "insufficient-section-alignment":
+				binary.LittleEndian.PutUint64(changed[header+48:], 16)
+			case "changed-initializer":
+				changed[section.Offset+symbol.Value-section.Addr] ^= 1
+			}
+			if minima, err := sdkLiteralLinkedMinima(changed, observed.observation.Target, observed.observation.PackagePath, initializers.Initializers, inventory); minima != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed actual linked identity/bytes/permissions/placement supplied minimum alignment", len(minima), err)
+			}
+		})
+	}
+	var restored GoX86SDKLiteralAlignment
+	if json.Unmarshal(observed.report, &restored) != nil || !errors.Is(restored.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("public report reconstructed a private producer")
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("offline controls changed the real original producer", err)
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentContextReentry(t *testing.T) {
+	ctx, source, owner, _ := sdkLiteralAlignmentCapture(t)
+	for _, method := range []string{"Err", "Done", "Deadline"} {
+		for _, action := range []string{"Verify", "Readback", "Close"} {
+			t.Run(method+"/"+action, func(t *testing.T) {
+				callback := &sdkASMDataReentrantContext{Context: ctx, method: method}
+				observed, err := CaptureGoX86SDKLiteralAlignment(callback, owner)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer observed.Close()
+				var nested error
+				callback.callback = func() {
+					switch action {
+					case "Verify":
+						nested = observed.Verify(ctx)
+					case "Readback":
+						_, nested = observed.Readback(ctx)
+					case "Close":
+						nested = observed.Close()
+					}
+				}
+				callback.armed.Store(true)
+				finished := make(chan error, 1)
+				go func() { finished <- errors.Join(observed.Verify(callback), nested) }()
+				select {
+				case err := <-finished:
+					if action == "Close" {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("reentrant close published minimum alignment", err)
+						}
+					} else if err != nil {
+						t.Fatal("link observation callback deadlocked/rejected genuine independent replay", err)
+					}
+				case <-ctx.Done():
+					// The existing original producer budget is unchanged. Join the
+					// worker before ending, rather than hiding a leaked command.
+					err := <-finished
+					t.Fatal("linker callback exceeded its original bounded context", ctx.Err(), err)
+				}
+				if err := source.Verify(ctx); err != nil {
+					t.Fatal("reentry disposed the independent original SDK source", err)
+				}
+			})
+		}
+	}
+}
diff --git a/go_x86_sdk_literal_alignment_go127_test.go b/go_x86_sdk_literal_alignment_go127_test.go
new file mode 100644
index 000000000..937ac146a
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_go127_test.go
@@ -0,0 +1,299 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestGoX86SDKLiteralAlignmentActualOriginalSource(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "linux/386", "darwin/amd64", "windows/amd64", "windows/386"} {
+		t.Run(target, func(t *testing.T) {
+			const pkg = "internal/runtime/maps"
+			goos, arch, _ := strings.Cut(target, "/")
+			ctx, request := sdkASMDataRequest(t, arch, pkg)
+			request.Target = target
+			for index, pair := range request.Environment {
+				if strings.HasPrefix(pair, "GOOS=") {
+					request.Environment[index] = "GOOS=" + goos
+				}
+			}
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal("complete actual SDK source precondition", err)
+			}
+			defer source.Close()
+			owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+			if err != nil {
+				t.Fatal("independent literal initializer precondition", err)
+			}
+			defer owner.Close()
+			observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+			if err != nil || observed == nil {
+				t.Fatal("real original linker cannot establish a separate minimum alignment role", err)
+			}
+			defer observed.Close()
+			raw, err := observed.Readback(ctx)
+			if err != nil || !json.Valid(raw) || !bytes.Contains(raw, []byte("MinimumAlignment")) {
+				t.Fatal("linked rule omitted minimum alignment", err)
+			}
+			if bytes.Contains(raw, []byte("Address\"")) {
+				t.Fatal("alignment report exports a numerical linked address")
+			}
+			var report sdkLiteralAlignmentReport
+			if json.Unmarshal(raw, &report) != nil || report.Protocol != sdkLiteralAlignmentProtocol || report.Target != target ||
+				report.InitializerSHA256 != owner.seal || len(report.Minima) != 2 {
+				t.Fatal("link producer lost original exact complete table join", report)
+			}
+			for _, minimum := range report.Minima {
+				if minimum.MinimumAlignment != 32 || minimum.Size != 256 || minimum.Namespace != gostaticstorage.TextSymbolSelf {
+					t.Fatal("original source/linker rule minimum differs", minimum)
+				}
+			}
+			program, err := os.ReadFile(filepath.Join(observed.guard.owned, "main.go"))
+			if err != nil || string(program) != "package main\nfunc main() {}\n" {
+				t.Fatal("link witness bypassed internal imports", err, string(program))
+			}
+			for _, name := range []string{"Bind", "BindNumericalReads", "Options", "Pointer", "Read", "Execute", "Variable"} {
+				if _, exists := reflect.TypeOf(observed).MethodByName(name); exists {
+					t.Fatal("alignment observation granted another role", name)
+				}
+			}
+			if source.guard.ready || source.guard.request.NumericalReads != nil {
+				t.Fatal("link observation created frame/read permission")
+			}
+			if err := owner.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if !errors.Is(observed.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("closed initializer retained link authority")
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("link token borrowed ownership of its original source", err)
+			}
+		})
+	}
+}
+
+func sdkLiteralAlignmentCapture(t *testing.T) (context.Context, *GoX86SDKASMDataSource, *GoX86SDKReadonlyLiteralDataOwner, *GoX86SDKLiteralAlignment) {
+	t.Helper()
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/runtime/maps")
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { source.Close() })
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { owner.Close() })
+	observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { observed.Close() })
+	return ctx, source, owner, observed
+}
+
+func TestGoX86SDKLiteralAlignmentCGOProfileAndCopyClose(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "internal/runtime/maps")
+	for index, pair := range request.Environment {
+		if strings.HasPrefix(pair, "CGO_ENABLED=") {
+			request.Environment[index] = "CGO_ENABLED=1"
+		}
+	}
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer source.Close()
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer owner.Close()
+	observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+	if err != nil {
+		t.Fatal("actual CGO=1 pure SDK graph/link precondition", err)
+	}
+	defer observed.Close()
+	if observed.observation.CGOEnabled != "1" {
+		t.Fatal("link producer forced a diagnostic CGO=0 profile")
+	}
+	copy := reflect.New(reflect.TypeOf(observed).Elem())
+	copy.Elem().Set(reflect.ValueOf(observed).Elem())
+	cloned := copy.Interface().(*GoX86SDKLiteralAlignment)
+	if !errors.Is(cloned.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(cloned.Close(), ErrProbeNeedsContext) {
+		t.Fatal("copied linker token disposed/borrowed original artifacts")
+	}
+	owned, originalOwned := observed.guard.owned, source.guard.owned
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("linker-owned artifacts were not released", err)
+	}
+	if _, err := os.Stat(originalOwned); err != nil {
+		t.Fatal("linker Close disposed original source", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("linker close revoked initializer", err)
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentSealedIdentityAndLifetime(t *testing.T) {
+	for name, mutate := range map[string]func(*GoX86SDKLiteralAlignment){
+		"public-report":     func(o *GoX86SDKLiteralAlignment) { o.report[0] ^= 1 },
+		"minimum-injection": func(o *GoX86SDKLiteralAlignment) { o.observation.Minima[0].MinimumAlignment = 64 },
+		"source-ordinal":    func(o *GoX86SDKLiteralAlignment) { o.observation.Minima[0].SourceOrdinal++ },
+		"object-index":      func(o *GoX86SDKLiteralAlignment) { o.observation.Minima[0].Index++ },
+		"link-binary-digest": func(o *GoX86SDKLiteralAlignment) {
+			o.guard.inputs[filepath.Join(o.guard.env["GOTOOLDIR"], "link")] = sha256.Sum256([]byte("forged tool"))
+		},
+		"input-profile":          func(o *GoX86SDKLiteralAlignment) { o.guard.env["CGO_ENABLED"] = "0-unobserved" },
+		"initializer-generation": func(o *GoX86SDKLiteralAlignment) { o.ownerGeneration++ },
+		"initializer-closed":     func(o *GoX86SDKLiteralAlignment) { o.owner.Close() },
+		"source-closed":          func(o *GoX86SDKLiteralAlignment) { o.owner.source.Close() },
+		"guard-role":             func(o *GoX86SDKLiteralAlignment) { o.guard.ready = true },
+		"linked-object-bytes": func(o *GoX86SDKLiteralAlignment) {
+			name := filepath.Join(o.guard.owned, "original-linked")
+			data, err := os.ReadFile(name)
+			if err != nil {
+				panic(err)
+			}
+			data[len(data)-1] ^= 1
+			if err := os.WriteFile(name, data, 0600); err != nil {
+				panic(err)
+			}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			ctx, _, _, observed := sdkLiteralAlignmentCapture(t)
+			mutate(observed)
+			if raw, err := observed.Readback(ctx); raw != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed link source/tool/object/profile/lifetime published minima", err)
+			}
+			if !errors.Is(observed.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restored/changed link token revived")
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentOriginalContextDeadline(t *testing.T) {
+	ctx, source, owner, _ := sdkLiteralAlignmentCapture(t)
+	for _, change := range []string{"earlier", "later", "lost", "cancel"} {
+		t.Run(change, func(t *testing.T) {
+			original, cancel := context.WithCancel(ctx)
+			defer cancel()
+			mutable := &sdkASMDataReentrantContext{Context: original}
+			observed, err := CaptureGoX86SDKLiteralAlignment(mutable, owner)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			want := ErrProbeNeedsContext
+			switch change {
+			case "earlier":
+				mutable.shift.Store(-int64(time.Minute))
+			case "later":
+				mutable.shift.Store(int64(time.Minute))
+			case "lost":
+				mutable.lost.Store(true)
+			case "cancel":
+				cancel()
+				want = context.Canceled
+			}
+			if raw, err := observed.Readback(ctx); raw != nil || !errors.Is(err, want) {
+				t.Fatal("changed original context published alignment facts", err)
+			}
+			mutable.shift.Store(0)
+			mutable.lost.Store(false)
+			if !errors.Is(observed.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("restored deadline revived revoked alignment")
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("link lifetime revoked original source", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentNoInventedRetainedWinner(t *testing.T) {
+	for _, pkg := range []string{"internal/chacha8rand"} {
+		t.Run(pkg, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, "amd64", pkg)
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer owner.Close()
+			observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+			if observed != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "uniquely retained") {
+				if observed != nil {
+					observed.Close()
+				}
+				t.Fatal("deadstripped/ambiguous original literals acquired a linked winner", observed != nil, err)
+			}
+			if err := owner.Verify(ctx); err != nil {
+				t.Fatal("failed independent link role revoked its initializer", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentPublicPackageDifferentExtents(t *testing.T) {
+	ctx, source, owner := readonlyLiteralCapture(t)
+	observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+	if err != nil {
+		t.Fatal("real ordinary public SDK import/link precondition", err)
+	}
+	defer observed.Close()
+	if len(observed.observation.Minima) != 4 {
+		t.Fatal("naturally initialized public SDK literals omitted", len(observed.observation.Minima))
+	}
+	alignments := make(map[uint32]bool)
+	for _, minimum := range observed.observation.Minima {
+		want := goAssemblyDataAlignment(ArchAMD64, int64(minimum.Size))
+		if int64(minimum.MinimumAlignment) != want {
+			t.Fatal("public source's actual size-dependent minimum differs", minimum)
+		}
+		alignments[minimum.MinimumAlignment] = true
+	}
+	if !alignments[8] || !alignments[16] || !alignments[32] {
+		t.Fatal("minimum alignment was hardcoded to the maps tables")
+	}
+	program, err := os.ReadFile(filepath.Join(observed.guard.owned, "main.go"))
+	if err != nil || string(program) != "package main\nimport _ \"hash/crc32\"\nfunc main() {}\n" {
+		t.Fatal("public SDK link changed its permitted original import", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentBytesAreNotProducer(t *testing.T) {
+	if result, err := CaptureGoX86SDKLiteralAlignment(nil, nil); result != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "alignment") {
+		t.Fatal("public bytes/empty token supplied linked address facts", result, err)
+	}
+}
diff --git a/go_x86_sdk_literal_alignment_graph.go b/go_x86_sdk_literal_alignment_graph.go
new file mode 100644
index 000000000..b773f1b48
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_graph.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// The linker graph's genuine root is runtime, not the candidate's package.
+// Unlike a declaration-only graph it may naturally contain the candidate as
+// a dependency. Preserve every original row/edge, including that dependency;
+// neither synthesize a package selection nor delete imports to fit the older
+// declaration-root assumption. This private guard never gains a Frame role.
+func (observed *GoX86SDKLiteralAlignment) bindLinkGraph(graph []byte) (map[string]goAMD64FrameSelection, error) {
+	if len(graph) > 16<<20 {
+		return nil, sdkASMDataContext("complete literal linker graph exceeds its bound")
+	}
+	decoder := json.NewDecoder(bytes.NewReader(graph))
+	var root goAMD64FrameSelection
+	seen := make(map[string]bool)
+	matched := false
+	candidateReferenced := false
+	for {
+		var selected goAMD64FrameSelection
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		if selected.ImportPath == "" || seen[selected.ImportPath] || len(seen) >= 4096 {
+			return nil, sdkASMDataContext("literal linker graph has duplicate/empty/excessive original selections")
+		}
+		seen[selected.ImportPath] = true
+		for _, path := range selected.Imports {
+			if mapped, exists := selected.ImportMap[path]; exists {
+				path = mapped
+			}
+			if path == observed.guard.selection.ImportPath {
+				candidateReferenced = true
+			}
+		}
+		if selected.ImportPath == "runtime" {
+			root = selected
+		}
+		if selected.ImportPath == observed.guard.selection.ImportPath {
+			if !reflect.DeepEqual(selected, observed.guard.selection) {
+				return nil, sdkASMDataContext("literal linker graph replaced its original SDK candidate")
+			}
+			matched = true
+		}
+	}
+	if !matched || root.ImportPath != "runtime" || !root.Standard || root.Module != nil || root.nonordinaryRole() ||
+		root.ForTest != "" || len(root.Error)+len(root.DepsErrors) != 0 || len(root.GoFiles) == 0 {
+		return nil, sdkASMDataContext("literal linker graph lacks its actual ordinary runtime/candidate selections")
+	}
+	rootDirectory := filepath.Join(observed.guard.env["GOROOT"], "src", "runtime")
+	physical, err := sourcepath.Resolve(root.Dir)
+	if err != nil || root.Dir != rootDirectory || physical != rootDirectory {
+		return nil, sdkASMDataContext("literal linker runtime source origin differs")
+	}
+	compiled := append([]string(nil), root.CompiledGoFiles...)
+	for index, name := range compiled {
+		if filepath.IsAbs(name) {
+			if filepath.Dir(name) != rootDirectory {
+				return nil, sdkASMDataContext("literal linker runtime generated-source mapping is unbound")
+			}
+			compiled[index] = filepath.Base(name)
+		}
+	}
+	if !reflect.DeepEqual(compiled, root.GoFiles) {
+		return nil, sdkASMDataContext("literal linker runtime omitted complete original compiler sources")
+	}
+	for _, files := range [][]string{root.GoFiles, root.SFiles, root.HFiles} {
+		for _, name := range files {
+			if filepath.Base(name) != name {
+				return nil, sdkASMDataContext("literal linker runtime source is not an exact package-local file")
+			}
+			if _, err := observed.guard.read(filepath.Join(rootDirectory, name)); err != nil {
+				return nil, err
+			}
+		}
+	}
+	original := observed.guard.selection
+	// Select a genuine top-level row, never a synthetic package. A candidate
+	// already imported by runtime cannot be the root of the declaration helper;
+	// a public candidate that itself imports runtime must instead be its root.
+	selectedRoot := original
+	if candidateReferenced {
+		selectedRoot = root
+	}
+	observed.guard.selection = selectedRoot
+	defer func() { observed.guard.selection = original }()
+	imports, err := observed.guard.bindOriginalDeclarationImports(graph)
+	if err != nil {
+		return nil, err
+	}
+	imports[selectedRoot.ImportPath] = selectedRoot
+	return imports, nil
+}
diff --git a/go_x86_sdk_literal_alignment_image.go b/go_x86_sdk_literal_alignment_image.go
new file mode 100644
index 000000000..83f589881
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_image.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"bytes"
+	"debug/elf"
+	"debug/macho"
+	"debug/pe"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type sdkLiteralLinkedSymbol struct {
+	name                                        string
+	value, size, sectionStart, sectionAlignment uint64
+	data                                        []byte
+	readonly, sized                             bool
+}
+
+// The observed address is used only to reject mismatches in this actual image.
+// It is never exported as a number or used to infer additional address bits.
+func sdkLiteralLinkedMinima(image []byte, target, pkg string, initializers []gostaticstorage.ReadonlyLiteralDataImage,
+	inventory []gostaticstorage.SDKArchiveDefinitionIdentity) ([]sdkLiteralMinimumAlignment, error) {
+	symbols, err := sdkLiteralImageSymbols(image, target)
+	if err != nil {
+		return nil, err
+	}
+	var result []sdkLiteralMinimumAlignment
+	for _, literal := range initializers {
+		definition := literal.Definition
+		if definition.Name == "" || definition.Namespace != gostaticstorage.TextSymbolSelf || definition.ABI != 65535 ||
+			definition.Kind != 3 || definition.Flags != 0 || definition.Flags2 != 0 || definition.Align != 0 ||
+			len(definition.Hash) != 0 || len(definition.Relocations) != 0 || definition.Size == 0 || len(literal.Initial) != int(definition.Size) {
+			return nil, sdkASMDataContext("minimum alignment requires exact private readonly unset-alignment object storage")
+		}
+		count, exact := 0, false
+		for _, item := range inventory {
+			if item.Name != definition.Name {
+				continue
+			}
+			count++
+			if item.PackagePath == pkg && item.MemberOrdinal == literal.MemberOrdinal && item.MemberName == literal.MemberName &&
+				item.Namespace == definition.Namespace && item.Index == definition.Index && item.ABI == definition.ABI &&
+				item.Kind == definition.Kind && item.Flags == definition.Flags && item.Flags2 == definition.Flags2 &&
+				item.Size == definition.Size && item.Align == definition.Align {
+				exact = true
+			}
+		}
+		if !exact {
+			return nil, sdkASMDataContext("minimum alignment lost original complete archive definition identity")
+		}
+		if count != 1 {
+			continue
+		} // No byte-identical/name-identical winner selection.
+		var linked *sdkLiteralLinkedSymbol
+		matches := 0
+		for index := range symbols {
+			if symbols[index].name == definition.Name {
+				linked = &symbols[index]
+				matches++
+			}
+		}
+		if matches != 1 {
+			continue
+		} // Linker-native dead stripping/ambiguity is not permission.
+		_, arch, _ := strings.Cut(target, "/")
+		minimum := uint64(goAssemblyDataAlignment(Arch(arch), int64(definition.Size)))
+		if !linked.readonly || linked.sized && linked.size != uint64(definition.Size) || linked.value < linked.sectionStart ||
+			linked.value%minimum != 0 || linked.sectionAlignment < minimum || linked.sectionAlignment%minimum != 0 {
+			return nil, sdkASMDataContext("original linked literal violates its registered section/symbol minimum alignment")
+		}
+		offset := linked.value - linked.sectionStart
+		if offset > uint64(len(linked.data)) || uint64(definition.Size) > uint64(len(linked.data))-offset ||
+			!bytes.Equal(linked.data[offset:offset+uint64(definition.Size)], literal.Initial) {
+			return nil, sdkASMDataContext("original linked literal bytes/extent differ from its exact source/object initializer")
+		}
+		result = append(result, sdkLiteralMinimumAlignment{SourceOrdinal: literal.SourceOrdinal, MemberOrdinal: literal.MemberOrdinal,
+			Namespace: definition.Namespace, Index: definition.Index, Name: definition.Name,
+			Size: definition.Size, MinimumAlignment: uint32(minimum)})
+	}
+	return result, nil
+}
+
+func sdkLiteralImageSymbols(image []byte, target string) ([]sdkLiteralLinkedSymbol, error) {
+	if len(image) == 0 || len(image) > 64<<20 || !gostaticstorage.X86SDKTarget(target) {
+		return nil, sdkASMDataContext("minimum alignment linked image is unavailable or outside its exact target/byte bound")
+	}
+	_, arch, _ := strings.Cut(target, "/")
+	var result []sdkLiteralLinkedSymbol
+	switch {
+	case strings.HasPrefix(target, "linux/"):
+		file, err := elf.NewFile(bytes.NewReader(image))
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+		if file.Type != elf.ET_EXEC || file.Data != elf.ELFDATA2LSB ||
+			arch == "amd64" && (file.Class != elf.ELFCLASS64 || file.Machine != elf.EM_X86_64) ||
+			arch == "386" && (file.Class != elf.ELFCLASS32 || file.Machine != elf.EM_386) {
+			return nil, sdkASMDataContext("minimum alignment ELF target/default executable profile differs")
+		}
+		symbols, err := file.Symbols()
+		if err != nil {
+			return nil, err
+		}
+		sections := make(map[*elf.Section][]byte)
+		for _, symbol := range symbols {
+			if symbol.Name == "" || symbol.Section == elf.SHN_UNDEF || int(symbol.Section) >= len(file.Sections) {
+				continue
+			}
+			section := file.Sections[symbol.Section]
+			readonly := section.Type == elf.SHT_PROGBITS && section.Flags == elf.SHF_ALLOC && elf.ST_TYPE(symbol.Info) == elf.STT_OBJECT
+			data := sections[section]
+			if readonly && data == nil {
+				if section.Size > 64<<20 {
+					return nil, sdkASMDataContext("literal linker ELF section exceeds its byte bound")
+				}
+				data, err = section.Data()
+				if err != nil {
+					return nil, err
+				}
+				sections[section] = data
+			}
+			result = append(result, sdkLiteralLinkedSymbol{name: symbol.Name, value: symbol.Value, size: symbol.Size,
+				sectionStart: section.Addr, sectionAlignment: section.Addralign, data: data, sized: true,
+				readonly: readonly})
+		}
+	case target == "darwin/amd64":
+		file, err := macho.NewFile(bytes.NewReader(image))
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+		if file.Cpu != macho.CpuAmd64 || file.Type != macho.TypeExec || file.Flags&macho.FlagPIE == 0 || file.Symtab == nil {
+			return nil, sdkASMDataContext("minimum alignment Mach-O target/default PIE profile differs")
+		}
+		sections := make(map[*macho.Section][]byte)
+		for _, symbol := range file.Symtab.Syms {
+			if symbol.Name == "" || symbol.Sect == 0 || int(symbol.Sect) > len(file.Sections) {
+				continue
+			}
+			section := file.Sections[int(symbol.Sect)-1]
+			readonly := symbol.Type&0x0e == 0x0e && section.Seg == "__TEXT" && section.Name == "__rodata"
+			data := sections[section]
+			if readonly && data == nil {
+				if section.Size > 64<<20 {
+					return nil, sdkASMDataContext("literal linker Mach-O section exceeds its byte bound")
+				}
+				data, err = section.Data()
+				if err != nil {
+					return nil, err
+				}
+				sections[section] = data
+			}
+			if section.Align > 31 {
+				return nil, sdkASMDataContext("minimum alignment Mach-O section bound differs")
+			}
+			result = append(result, sdkLiteralLinkedSymbol{name: strings.TrimPrefix(symbol.Name, "_"), value: symbol.Value,
+				sectionStart: section.Addr, sectionAlignment: uint64(1) << section.Align, data: data,
+				readonly: readonly})
+		}
+	case strings.HasPrefix(target, "windows/"):
+		file, err := pe.NewFile(bytes.NewReader(image))
+		if err != nil {
+			return nil, err
+		}
+		defer file.Close()
+		if arch == "amd64" && file.Machine != pe.IMAGE_FILE_MACHINE_AMD64 || arch == "386" && file.Machine != pe.IMAGE_FILE_MACHINE_I386 || file.Characteristics&0x2002 != 2 {
+			return nil, sdkASMDataContext("minimum alignment PE target/executable profile differs")
+		}
+		var base, alignment uint64
+		switch header := file.OptionalHeader.(type) {
+		case *pe.OptionalHeader64:
+			if arch != "amd64" || header.DllCharacteristics&0x40 == 0 {
+				return nil, sdkASMDataContext("minimum alignment PE64 default PIE profile differs")
+			}
+			base, alignment = header.ImageBase, uint64(header.SectionAlignment)
+		case *pe.OptionalHeader32:
+			if arch != "386" || header.DllCharacteristics&0x40 == 0 {
+				return nil, sdkASMDataContext("minimum alignment PE32 default PIE profile differs")
+			}
+			base, alignment = uint64(header.ImageBase), uint64(header.SectionAlignment)
+		default:
+			return nil, sdkASMDataContext("minimum alignment PE optional header is absent")
+		}
+		if alignment < 32 || alignment&(alignment-1) != 0 || base%alignment != 0 {
+			return nil, sdkASMDataContext("minimum alignment PE image base/section placement differs")
+		}
+		sections := make(map[*pe.Section][]byte)
+		for _, symbol := range file.Symbols {
+			if symbol.SectionNumber <= 0 || int(symbol.SectionNumber) > len(file.Sections) || symbol.Name == "" {
+				continue
+			}
+			section := file.Sections[int(symbol.SectionNumber)-1]
+			readonly := section.Characteristics&0x20 == 0 && section.Characteristics&0x40 != 0 && section.Characteristics&0xc0000000 == 0x40000000
+			data := sections[section]
+			if readonly && data == nil {
+				if section.Size > 64<<20 {
+					return nil, sdkASMDataContext("literal linker PE section exceeds its byte bound")
+				}
+				data, err = section.Data()
+				if err != nil {
+					return nil, err
+				}
+				sections[section] = data
+			}
+			start := base + uint64(section.VirtualAddress)
+			result = append(result, sdkLiteralLinkedSymbol{name: symbol.Name, value: start + uint64(symbol.Value),
+				sectionStart: start, sectionAlignment: alignment, data: data,
+				readonly: readonly})
+		}
+	}
+	return result, nil
+}
diff --git a/go_x86_sdk_literal_alignment_namespace_go127_test.go b/go_x86_sdk_literal_alignment_namespace_go127_test.go
new file mode 100644
index 000000000..efb835fa0
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_namespace_go127_test.go
@@ -0,0 +1,43 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestGoX86SDKLiteralAlignmentOriginalVendorPackageNamespace(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "amd64", "vendor/golang.org/x/crypto/chacha20poly1305")
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("complete original vendored SDK source", err)
+	}
+	defer source.Close()
+
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if err != nil {
+		t.Fatal("independent original literal initializer", err)
+	}
+	defer owner.Close()
+
+	observed, err := CaptureGoX86SDKLiteralAlignment(ctx, owner)
+	if observed != nil {
+		defer observed.Close()
+		t.Fatal("unused vendored assembly unexpectedly acquired retained literal alignment")
+	}
+	// The ordinary empty-main link does not call this package's assembly.
+	// Reaching that real dead-stripping boundary is distinct from failing a
+	// cmd/go query through the package directory's unrelated module namespace.
+	if !errors.Is(err, ErrProbeNeedsContext) ||
+		!strings.Contains(err.Error(), "no uniquely retained original literal has observed minimum alignment") {
+		t.Fatal("vendored alignment observation did not reach its genuine linker boundary", err)
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("rejected alignment disposed its borrowed original initializer", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("rejected alignment changed its complete original SDK source", err)
+	}
+}
diff --git a/go_x86_sdk_literal_alignment_request.go b/go_x86_sdk_literal_alignment_request.go
new file mode 100644
index 000000000..437c3b9f6
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_request.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"errors"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+var sdkLiteralAlignmentRequested = errors.New("typed literal-address masked predicate requests an independent minimum")
+
+// GoX86SDKLiteralAlignmentRequested is a bounded cost query, not a source,
+// layout, result or address permission. Only the independent live producer
+// and BindNumericalReadsWithLiteralAlignment may authorize a masked predicate.
+func GoX86SDKLiteralAlignmentRequested(file *File, options Options) bool {
+	if file == nil || file.Arch != ArchAMD64 || options.Goarch != "amd64" && options.Goarch != "386" || len(file.Funcs) > 256 || len(file.Globl) > gostaticstorage.ObjectSymbolInventoryLimit {
+		return false
+	}
+	literals := make(map[string]int64)
+	for _, global := range file.Globl {
+		readonly, err := globlReadOnly(global.Flags)
+		if err == nil && readonly && global.Size > 0 && global.SizeRaw == "" {
+			literals[global.Sym] = global.Size
+		}
+	}
+	if len(literals) == 0 {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		name := fn.Sym
+		if options.ResolveSym != nil {
+			name = options.ResolveSym(name)
+		}
+		sig, found := options.Sigs[name]
+		if !found || !x86SDKLiteralBoolPredicateRole(fn, sig, options.Goarch) {
+			continue
+		}
+		// Reuse the complete bounded literal CFG, physical source aliases,
+		// origin/escape checks and cycle budget. The query has no fake floor,
+		// linked address, minimum certificate or initialized numerical bytes.
+		_, err := proveX86SDKLiteralAccessesAtMinimumRequest(fn, sig, options.Goarch, literals, nil, true)
+		if errors.Is(err, sdkLiteralAlignmentRequested) {
+			return true
+		}
+	}
+	return false
+}
+
+func x86SDKLiteralAlignmentRequestStep(ins Instr, state *x86SDKLiteralState, arch string) (bool, error) {
+	word := x86ResultPointerWord(arch)
+	read := func(operand Operand) (int, x86SDKLiteralValue, bool) {
+		root, _, valid := x86ResultGP(operand.Reg, word, arch)
+		return root, state.gp[root], operand.Kind == OpReg && valid
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil && form.spec.stem == "OR" {
+		_, first, validSource := read(form.source)
+		destination, previous, validDestination := read(form.destination)
+		if int64(form.spec.bits/8) != word || !validSource || !validDestination || first.symbol == "" || previous.symbol == "" ||
+			first.bad && !first.bitsOnly || previous.bad && !previous.bitsOnly {
+			return false, nil
+		}
+		// This is only may-demand propagation to a later TEST. It does not
+		// set hasMinimum/lowMask/lowValue, or emit any instruction fact.
+		previous.bad, previous.bitsOnly = true, true
+		state.gp[destination], state.compared = previous, false
+		return true, nil
+	}
+	if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil && form.test {
+		root, _, valid := x86ResultGP(form.args[1].Reg, int64(form.bits/8), arch)
+		value := state.gp[root]
+		if valid && form.args[1].Kind == OpReg && form.args[0].Kind == OpImm && value.symbol != "" && (!value.bad || value.bitsOnly) {
+			return true, sdkLiteralAlignmentRequested
+		}
+	}
+	return false, nil
+}
diff --git a/go_x86_sdk_literal_alignment_request_test.go b/go_x86_sdk_literal_alignment_request_test.go
new file mode 100644
index 000000000..179b2bc27
--- /dev/null
+++ b/go_x86_sdk_literal_alignment_request_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestGoX86SDKLiteralAlignmentRequestGlobalInventoryBound(t *testing.T) {
+	file, options := sdkLiteralAlignmentRequestFixture(t, "MOVQ $one<>(SB),AX\nTESTQ $15,AX\nSETEQ AX", I1)
+	globals := make([]GloblStmt, gostaticstorage.ObjectSymbolInventoryLimit+1)
+	copy(globals, file.Globl)
+	for index := len(file.Globl); index < len(globals); index++ {
+		globals[index] = GloblStmt{Sym: fmt.Sprintf("extra%d<>", index), Flags: "RODATA", Size: 32}
+	}
+	file.Globl = globals[:gostaticstorage.ObjectSymbolInventoryLimit]
+	if !GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("existing object-symbol inventory boundary was rejected")
+	}
+	file.Globl = globals
+	options.ResolveSym = func(string) string { t.Error("oversized inventory reached the resolver"); return "arbitrary/sdk.view" }
+	if GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("unbounded global inventory requested a Go link")
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentRequestTypedPredicateOnly(t *testing.T) {
+	for _, move := range []string{"MOVQ", "MOVD", "MOVDQ2Q", "LEAQ"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			materialize := move + " $one<>(SB),BX"
+			if move == "LEAQ" {
+				materialize = "LEAQ one<>(SB),BX"
+			}
+			body := materialize + "\nMOVQ BX,DX\nMOVQ $two<>(SB),CX\nORQ CX,DX\nTEST" + width + " $15,DX\nSETEQ AX"
+			file, options := sdkLiteralAlignmentRequestFixture(t, body, I1)
+			original := append([]Instr(nil), file.Funcs[0].Instrs...)
+			if !GoX86SDKLiteralAlignmentRequested(file, options) {
+				t.Errorf("%s/TEST%s lost the typed literal-address predicate cost", move, width)
+			}
+			if !reflect.DeepEqual(original, file.Funcs[0].Instrs) || options.NumericalReads != nil {
+				t.Fatal("cost query changed original instructions or manufactured a binding")
+			}
+		}
+	}
+	file, options := sdkLiteralAlignmentRequestFixture(t, "MOVQ $one<>+3(SB),AX\nTESTB $15,AX\nSETEQ AX", I1)
+	if !GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("direct displaced literal predicate did not request its independent minimum")
+	}
+}
+
+func TestGoX86SDKLiteralAlignmentRequestDoesNotLinkOrdinaryReads(t *testing.T) {
+	for name, body := range map[string]string{
+		"readonly-scalar":   "MOVQ one<>(SB),AX\nTESTQ $15,AX\nSETEQ AX",
+		"readonly-vector":   "MOVOU one<>(SB),X0\nTESTQ AX,AX\nSETEQ AX",
+		"incoming-pointer":  "TESTW $0xff0,AX\nSETEQ AX",
+		"unrelated-address": "MOVQ $one<>(SB),BX\nTESTW $15,AX\nSETEQ AX",
+		"partial-carrier":   "MOVQ $one<>(SB),BX\nMOVW $0,BX\nTESTW $15,BX\nSETEQ AX",
+		"numeric-OR":        "MOVQ $one<>(SB),BX\nORQ AX,BX\nTESTQ $15,BX\nSETEQ AX",
+		"no-predicate":      "MOVQ $one<>(SB),BX\nMOVQ (BX),AX",
+		"escaped-address":   "MOVQ $one<>(SB),BX\nMOVQ BX,X0\nTESTQ $15,BX\nSETEQ AX",
+		"raw":               "BYTE $0x90\nMOVQ $one<>(SB),BX\nTESTQ $15,BX\nSETEQ AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, options := sdkLiteralAlignmentRequestFixture(t, body, I1)
+			if GoX86SDKLiteralAlignmentRequested(file, options) {
+				t.Fatal("unrelated/unsupported source requested an additional Go link")
+			}
+		})
+	}
+	file, options := sdkLiteralAlignmentRequestFixture(t, "MOVQ $one<>(SB),AX\nTESTQ $15,AX\nSETEQ AX", I64)
+	if GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("a non-bool logical result borrowed the masked predicate class")
+	}
+	file.Globl[0].Flags = "NOPTR"
+	options.Sigs["arbitrary/sdk.view"] = FuncSig{Name: "arbitrary/sdk.view", Ret: I1}
+	if GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("mutable pointer-free data requested the readonly linked-layout role")
+	}
+}
+
+func sdkLiteralAlignmentRequestFixture(t *testing.T, body string, result LLVMType) (*File, Options) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT ·view<ABIInternal>(SB),4,$0-1\n"+body+"\nRET\nGLOBL one<>(SB),RODATA,$32\nGLOBL two<>(SB),8,$64\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, Options{Goarch: "amd64", ResolveSym: func(symbol string) string {
+		return "arbitrary/sdk." + strings.TrimPrefix(strings.TrimSuffix(symbol, "<ABIInternal>"), "·")
+	}, Sigs: map[string]FuncSig{"arbitrary/sdk.view": {Name: "arbitrary/sdk.view", Args: []LLVMType{Ptr}, Ret: result}}}
+}
diff --git a/go_x86_sdk_literal_binding.go b/go_x86_sdk_literal_binding.go
new file mode 100644
index 000000000..eeaeef76f
--- /dev/null
+++ b/go_x86_sdk_literal_binding.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+type x86SDKLiteralCertificate struct {
+	binding     *GoX86NumericalReadBinding
+	access      int
+	instruction [32]byte
+}
+
+func (source *GoX86NumericalReadSource) bindSDKLiteralAccesses(file *File, sigs map[string]FuncSig, symbols map[string]string, arch string) ([]x86SDKLiteralAccess, error) {
+	return source.bindSDKLiteralAccessesAtMinimum(file, sigs, symbols, arch, nil)
+}
+
+func (source *GoX86NumericalReadSource) bindSDKLiteralAccessesAtMinimum(file *File, sigs map[string]FuncSig, symbols map[string]string, arch string, minimum *numericalSDKLiteralMinimumJoin) ([]x86SDKLiteralAccess, error) {
+	if source.literals == nil {
+		return nil, nil
+	}
+	literals := make(map[string]int64)
+	for _, global := range file.Globl {
+		literals[global.Sym] = global.Size
+	}
+	var result []x86SDKLiteralAccess
+	for _, fn := range file.Funcs {
+		candidate := false
+		for _, ins := range fn.Instrs {
+			for index := range ins.Args {
+				if form, valid := x86SDKLiteralOperandProperties(ins, index, arch); valid && literals[form.symbol] > 0 &&
+					(form.address || form.memory.Index != "") {
+					candidate = true
+				}
+			}
+		}
+		if !candidate {
+			continue // Existing fixed-offset consumers retain their own byte proof.
+		}
+		var floors map[string]uint32
+		if minimum != nil {
+			floors = minimum.Minima
+		}
+		facts, err := proveX86SDKLiteralAccessesWithMinima(fn, sigs[symbols[fn.Sym]], arch, literals, floors)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, facts...)
+	}
+	return result, nil
+}
+
+func joinSDKLiteralCertificates(file *File, binding *GoX86NumericalReadBinding) error {
+	for index, fact := range binding.literalAccesses {
+		matches := 0
+		for f := range file.Funcs {
+			fn := &file.Funcs[f]
+			if binding.resolve(fn.Sym) != fact.Function || fact.Instruction < 0 || fact.Instruction >= len(fn.Instrs) {
+				continue
+			}
+			ins := &fn.Instrs[fact.Instruction]
+			if !reflect.DeepEqual(*ins, fact.Original) || ins.x86SDKLiteral != nil {
+				return numericalSBContext("original private literal access/ordinal differs")
+			}
+			digest, err := fixedLocalInstructionDigest(*ins)
+			if err != nil {
+				return err
+			}
+			ins.x86SDKLiteral = &x86SDKLiteralCertificate{binding: binding, access: index, instruction: digest}
+			matches++
+		}
+		if matches != 1 {
+			return numericalSBContext("private literal access lacks its unique complete source function")
+		}
+	}
+	return nil
+}
+
+func certifiedSDKLiteralAccess(ins Instr, arch string) (x86SDKLiteralAccess, bool) {
+	cert := ins.x86SDKLiteral
+	if cert == nil || cert.binding == nil || cert.binding.originalBinding != cert.binding ||
+		cert.binding.source == nil || cert.binding.source.identity != cert.binding.source ||
+		cert.binding.source.revoked.Load() ||
+		cert.binding.source.role != numericalSBSDKSource || cert.binding.source.literals == nil ||
+		arch != cert.binding.options.Goarch || cert.access < 0 || cert.access >= len(cert.binding.literalAccesses) {
+		return x86SDKLiteralAccess{}, false
+	}
+	fact := cert.binding.literalAccesses[cert.access]
+	joined := cert.binding.source.literals
+	if joined.owner == nil || joined.owner.identity != joined.owner || joined.source == nil || joined.source.identity != joined.source {
+		return x86SDKLiteralAccess{}, false
+	}
+	digest, err := fixedLocalInstructionDigest(ins)
+	if err != nil || digest != cert.instruction || fact.Operand < 0 || fact.Operand >= len(ins.Args) || fact.Minimum < 0 || fact.Maximum < fact.Minimum {
+		return x86SDKLiteralAccess{}, false
+	}
+	name := numericalNativeName(strings.TrimSuffix(fact.Symbol, "<>"), cert.binding.source.request.PackagePath)
+	extent := int64(-1)
+	for _, image := range joined.Initializers.Initializers {
+		if image.SourceOrdinal == joined.SourceOrdinal && image.Definition.Name == name {
+			if extent >= 0 {
+				return x86SDKLiteralAccess{}, false
+			}
+			extent = int64(len(image.Initial))
+		}
+	}
+	if extent < 0 || fact.Width < 0 || fact.LowBits == nil && (fact.Width > extent || fact.Maximum > extent-fact.Width) {
+		return x86SDKLiteralAccess{}, false
+	}
+	if fact.LowBits != nil {
+		if !cert.binding.literalMinimum.live() || fact.LowBits.Symbol != fact.Symbol ||
+			fact.Width != fact.LowBits.Bytes || fact.LowBits.Operation != ins.Op || !validSDKLiteralLowBitForm(ins, fact.LowBits, arch) {
+			return x86SDKLiteralAccess{}, false
+		}
+	} else if fact.Address {
+		form, valid := x86SDKLiteralOperandProperties(ins, fact.Operand, arch)
+		if !valid || !form.address || form.symbol != fact.Symbol || fact.Width != 0 {
+			return x86SDKLiteralAccess{}, false
+		}
+	} else {
+		width, write, valid := x86InstructionMemoryShape(x86SourceMoveInstruction(ins, arch), fact.Operand, arch)
+		if !valid || write || width != fact.Width || width <= 0 {
+			return x86SDKLiteralAccess{}, false
+		}
+	}
+	return fact, true
+}
+
+func verifyNormalizedSDKLiteralAccesses(file *File, options Options) error {
+	binding := options.NumericalReads
+	seen := make(map[int]bool)
+	for _, fn := range file.Funcs {
+		for ordinal, ins := range fn.Instrs {
+			if ins.x86SDKLiteral == nil {
+				continue
+			}
+			cert := ins.x86SDKLiteral
+			fact, valid := certifiedSDKLiteralAccess(ins, options.Goarch)
+			if !valid || cert.binding != binding || seen[cert.access] || options.ResolveSym(fn.Sym) != fact.Function || ordinal != fact.Instruction {
+				return numericalSBContext("normalized private literal function/ordinal/operand differs")
+			}
+			seen[cert.access] = true
+		}
+	}
+	if len(seen) != len(binding.literalAccesses) {
+		return numericalSBContext("normalized private literal access inventory differs")
+	}
+	return nil
+}
+
+func x86ResultSDKLiteralStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if ins.x86SDKLiteral == nil {
+		return false, false
+	}
+	fact, valid := certifiedSDKLiteralAccess(ins, arch)
+	if !valid {
+		return false, true
+	}
+	if fact.LowBits != nil {
+		return x86ResultSDKLiteralLowBitStep(ins, fact.LowBits, state, arch), true
+	}
+	if fact.Address {
+		root, _, valid := x86ResultGP(ins.Args[1].Reg, x86ResultPointerWord(arch), arch)
+		if valid {
+			state.gp[root], state.pointerGP[root] = 0, true // Opaque address, not numerical bits.
+		}
+		return valid, true
+	}
+	next := state.clone()
+	next.loweredStaticReads = state.loweredStaticReads
+	next.literalMemoryOperand, next.literalMemoryBytes = &ins.Args[fact.Operand], fact.Width
+	ins.x86SDKLiteral = nil
+	accepted := x86ScalarFPResultTransfer(x86SourceMoveInstruction(ins, arch), &next, owned, resultOffset, arch)
+	next.literalMemoryOperand, next.literalMemoryBytes = nil, 0
+	if accepted {
+		*state = next
+	}
+	return accepted, true
+}
diff --git a/go_x86_sdk_literal_bool_role.go b/go_x86_sdk_literal_bool_role.go
new file mode 100644
index 000000000..05f12b4e4
--- /dev/null
+++ b/go_x86_sdk_literal_bool_role.go
@@ -0,0 +1,12 @@
+package plan9asm
+
+// Predicate selection is not canonicality, source, frame or entry permission.
+// AMD64 keeps its independent explicit register-result role. The 386 role is
+// an ordinary zero-frame/no-argument ABI0 function with one declared bool byte;
+// its complete typed result initialization/canonicality is checked separately.
+func x86SDKLiteralBoolPredicateRole(fn Func, sig FuncSig, arch string) bool {
+	if arch == "amd64" {
+		return sig.Ret == I1 && x86RegisterBoolResultNeedsProof(fn, sig, arch)
+	}
+	return x86ABI0SingleByteBoolResultRole(fn, sig, arch)
+}
diff --git a/go_x86_sdk_literal_forms.go b/go_x86_sdk_literal_forms.go
new file mode 100644
index 000000000..91ea28a3b
--- /dev/null
+++ b/go_x86_sdk_literal_forms.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "strings"
+
+type x86SDKLiteralOperand struct {
+	memory  MemRef
+	symbol  string
+	offset  int64
+	width   int64
+	address bool
+}
+
+// Go's obj6 progedit rewrites AMD64 MOVL/Q TYPE_ADDR to LEAL/Q;
+// non-shared 386 named MOVL TYPE_ADDR is an absolute relocation, ignoring
+// both source Reg and Index. Named 386 LEA/memory ignores Reg but uses Index.
+// This grammar supplies no bounds, numerical bytes or address permission.
+func x86SDKLiteralOperandProperties(ins Instr, index int, arch string) (x86SDKLiteralOperand, bool) {
+	var form x86SDKLiteralOperand
+	if index < 0 || index >= len(ins.Args) || arch != "386" && arch != "amd64" ||
+		ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return form, false
+	}
+	ins = x86SourceMoveInstruction(ins, arch) // Local grammar dispatch, never original Op/Raw.
+	operand := ins.Args[index]
+	immediate := operand.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(operand.Sym), "$")
+	if immediate {
+		parsed, err := parseOperandForArch(ArchAMD64, strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(operand.Sym), "$")))
+		if err != nil {
+			return form, false
+		}
+		operand = parsed
+	}
+	memory, valid := x86SBMemoryAddressRole(operand, arch)
+	if !valid {
+		return form, false
+	}
+	base, offset, valid := parseSBRef(memory.Sym)
+	if !valid || !strings.HasSuffix(base, "<>") || memory.OffRaw != "" || memory.Segment != "" || memory.IndexExt != "" {
+		return form, false
+	}
+	// The shared parser preserves the symbolic displacement separately from
+	// an AST memory displacement. Reject overflow before composing them.
+	combined := offset + memory.Off
+	if memory.Off > 0 && combined < offset || memory.Off < 0 && combined > offset {
+		return form, false
+	}
+	form.memory, form.symbol, form.offset = memory, base, combined
+	form.address = immediate || ins.Op == "LEAL" || ins.Op == "LEAQ"
+	if form.address {
+		word, move, lea := x86ResultPointerWord(arch), Op("MOVQ"), Op("LEAQ")
+		if arch == "386" {
+			move, lea = "MOVL", "LEAL"
+		}
+		if index != 0 || len(ins.Args) != 2 || ins.Op != lea && !(immediate && ins.Op == move) ||
+			ins.Args[1].Kind != OpReg {
+			return form, false
+		}
+		_, _, valid := x86ResultGP(ins.Args[1].Reg, word, arch)
+		if !valid || ins.Args[1].Reg == "R14" {
+			return form, false // Native SP/BP/g storage remains a separate role.
+		}
+		if arch == "386" && immediate {
+			form.memory.Index, form.memory.Scale = "", 0
+		}
+		return form, true
+	}
+	width, write, known := x86InstructionMemoryShape(ins, index, arch)
+	form.width = width
+	return form, known && !write && width > 0
+}
diff --git a/go_x86_sdk_literal_low_bits.go b/go_x86_sdk_literal_low_bits.go
new file mode 100644
index 000000000..f5514b4a9
--- /dev/null
+++ b/go_x86_sdk_literal_low_bits.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import "strings"
+
+type x86SDKLiteralLowBits struct {
+	Operation   Op
+	Mask, Value uint64
+	Bytes       int64
+	Symbol      string
+}
+
+// Minima are supplied only by the independent original-linked layout binder.
+// This private proof itself creates no source, storage or LLVM authority.
+func proveX86SDKLiteralAccessesWithMinima(fn Func, sig FuncSig, arch string, literals map[string]int64, minima map[string]uint32) ([]x86SDKLiteralAccess, error) {
+	for symbol, floor := range minima {
+		if floor == 0 || floor&(floor-1) != 0 || literals[symbol] <= 0 ||
+			uint64(floor) > uint64(goAssemblyDataAlignment(Arch(arch), literals[symbol])) {
+			return nil, numericalSBContext("private literal minimum exceeds its registered emitted floor")
+		}
+	}
+	return proveX86SDKLiteralAccessesAtMinimum(fn, sig, arch, literals, minima)
+}
+
+func x86SDKLiteralLowBitStep(ins Instr, state *x86SDKLiteralState, fn Func, sig FuncSig, arch string) (*x86SDKLiteralLowBits, bool, error) {
+	word := x86ResultPointerWord(arch)
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil &&
+		form.destination.Kind == OpFP && arch == "386" && x86SDKLiteralBoolPredicateRole(fn, sig, arch) && form.destination.FPOffset == 0 {
+		return nil, true, nil // No literal GP/FLAGS effect; the separate typed bool-byte role owns this result.
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil && form.destination.Kind == OpReg {
+		root, mask, valid := x86ResultGP(form.destination.Reg, 1, arch)
+		if valid && state.gp[root].symbol != "" {
+			value := state.gp[root]
+			value.bad, value.bitsOnly = true, false
+			value.lowMask, value.lowValue = 0, 0
+			value.hasMinimum = false
+			value.lowIndependent = value.lowIndependent || mask&1 != 0
+			state.gp[root] = value
+			return nil, true, nil // Canonicality/FLAGS are proved independently.
+		}
+	}
+	read := func(operand Operand) (int, x86SDKLiteralValue, bool) {
+		if operand.Kind != OpReg {
+			return 0, x86SDKLiteralValue{}, false
+		}
+		root, _, valid := x86ResultGP(operand.Reg, word, arch)
+		return root, state.gp[root], valid
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil && form.spec.stem == "OR" {
+		_, first, validSource := read(form.source)
+		destination, previous, validDestination := read(form.destination)
+		if first.symbol == "" && previous.symbol == "" {
+			return nil, false, nil
+		}
+		if !x86SDKLiteralBoolPredicateRole(fn, sig, arch) ||
+			int64(form.spec.bits/8) != word || !validSource || !validDestination || first.symbol == "" || previous.symbol == "" ||
+			!first.hasMinimum || !previous.hasMinimum || first.bad && !first.bitsOnly || previous.bad && !previous.bitsOnly {
+			return nil, true, numericalSBContext("private literal OR needs two sealed minimum-floor bool-predicate carriers")
+		}
+		mask := first.lowMask & previous.lowMask
+		value := (first.lowValue | previous.lowValue) & mask
+		previous.lowMask, previous.lowValue, previous.bitsOnly, previous.bad, previous.lowIndependent = mask, value, true, true, false
+		state.gp[destination], state.compared = previous, false
+		// Register OR proves CF=OF=0 independently of any address. Z/S/P
+		// still depend on uncovered full-address bits; AF is undefined and
+		// remains rejected by the separate typed initialization domain.
+		state.opaqueFlags = x86ByteFlagZF | x86ByteFlagSF | x86ByteFlagPF
+		return &x86SDKLiteralLowBits{Operation: ins.Op, Mask: mask, Value: value, Bytes: word, Symbol: previous.symbol}, true, nil
+	}
+	if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil && form.test {
+		root, _, valid := x86ResultGP(form.args[1].Reg, int64(form.bits/8), arch)
+		if form.args[1].Kind != OpReg || !valid {
+			return nil, false, nil
+		}
+		previous := state.gp[root]
+		if previous.symbol == "" {
+			return nil, false, nil
+		}
+		if !x86SDKLiteralBoolPredicateRole(fn, sig, arch) || form.args[0].Kind != OpImm ||
+			!previous.hasMinimum || previous.bad && !previous.bitsOnly {
+			return nil, true, numericalSBContext("private literal TEST needs its complete sealed minimum-floor bool predicate")
+		}
+		mask := uint64(form.args[0].Imm)
+		if form.bits < 64 {
+			mask &= (uint64(1) << uint(form.bits)) - 1
+		}
+		shift := uint(8 * fixedLocalBooleanShift(form.args[1].Reg))
+		if mask&^(previous.lowMask>>shift) != 0 {
+			return nil, true, numericalSBContext("private literal TEST observes bits outside its guaranteed minimum")
+		}
+		state.compared = false
+		state.opaqueFlags = 0 // Only a completely covered mask clears its address taint.
+		return &x86SDKLiteralLowBits{Operation: ins.Op, Mask: mask, Value: previous.lowValue >> shift & mask, Bytes: int64(form.bits / 8), Symbol: previous.symbol}, true, nil
+	}
+	return nil, false, nil
+}
+
+// Every typed reader shares this orthogonal provenance query. This does not
+// initialize FLAGS or numerical bytes; ordinary source/result transfer remains
+// responsible for the complete instruction and its defined input effects.
+func x86SDKLiteralFlagReads(ins Instr, arch string) uint8 {
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil {
+		return x86ByteConditionFlags(form.condition)
+	}
+	if isAMD64ConditionalBranch(ins.Op) {
+		return x86ByteBranchFlags(ins.Op)
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		return effect.flagsRead
+	}
+	if len(ins.Args) == 0 {
+		switch strings.ToUpper(string(ins.Op)) {
+		case "LAHF":
+			return x86ByteFlagCF | x86ByteFlagPF | x86ByteFlagAF | x86ByteFlagZF | x86ByteFlagSF
+		case "PUSHF", "PUSHFL", "PUSHFQ":
+			return x86ByteFlagsAll
+		case "CMC":
+			return x86ByteFlagCF
+		}
+	}
+	return 0
+}
+
+func x86SDKLiteralIndependentFlagWrites(ins Instr, state *x86SDKLiteralState, arch string) {
+	if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil {
+		state.opaqueFlags = 0 // Its numerical operands were independently checked.
+		return
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		state.opaqueFlags &^= effect.flagsDefined | effect.flagsKilled
+	}
+}
diff --git a/go_x86_sdk_literal_low_bits_test.go b/go_x86_sdk_literal_low_bits_test.go
new file mode 100644
index 000000000..d36312760
--- /dev/null
+++ b/go_x86_sdk_literal_low_bits_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86SDKLiteralLowBitFixture = `TEXT ·entry<ABIInternal>(SB),4,$0-1
+MOVQ $first<>(SB),AX
+MOVQ $second<>(SB),BX
+ORQ BX,AX
+TESTQ $15,AX
+SETEQ AX
+RET
+`
+
+func TestGoX86SDKLiteralGuaranteedMinimumMaskedPredicate(t *testing.T) {
+	sig := FuncSig{Name: "example.invalid/independent.entry", Ret: I1,
+		Frame: FrameLayout{Results: []FrameSlot{{Type: I1, Index: 0, Field: -1}}}}
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		for _, offset := range []string{"", "+1"} {
+			source := strings.ReplaceAll(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "MOVQ", alias), "$first<>(SB)", "$first<>"+offset+"(SB)")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+			if err != nil || len(facts) != 4 || !reflect.DeepEqual(file, original) {
+				t.Fatalf("sealed minimum low bits did not close complete unchanged predicate (%s/%s): %v %+v", alias, offset, err, facts)
+			}
+			if _, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ordinary literal bytes acquired a linked minimum", err)
+			}
+		}
+	}
+	for _, op := range []string{"TESTB", "TESTW", "TESTL", "TESTQ"} {
+		for _, condition := range amd64RegisterBoolConditions {
+			source := strings.ReplaceAll(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ", op), "SETEQ", condition)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32}); err != nil || len(facts) != 4 {
+				t.Fatal("complete TEST width/SETcc predicate row rejected", op, condition, err)
+			}
+		}
+	}
+	for _, floor := range []uint32{1, 2, 4, 8, 16, 32} {
+		text := strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", fmt.Sprintf("TESTQ $%d,AX", floor-1))
+		file, err := Parse(ArchAMD64, text)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": int64(floor), "second<>": int64(floor)}, map[string]uint32{"first<>": floor, "second<>": floor}); err != nil {
+			t.Fatal("genuine finite minimum including mask-zero floor rejected", floor, err)
+		}
+	}
+}
+
+func TestGoX86SDKLiteralMinimumDoesNotGrantGeneralAddressBits(t *testing.T) {
+	sig := FuncSig{Name: "example.invalid/independent.entry", Ret: I1,
+		Frame: FrameLayout{Results: []FrameSlot{{Type: I1, Index: 0, Field: -1}}}}
+	for name, changed := range map[string]string{
+		"high mask":            strings.ReplaceAll(x86SDKLiteralLowBitFixture, "$15,AX", "$32,AX"),
+		"arbitrary comparison": strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "CMPQ AX,$15"),
+		"general and":          strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "ANDQ $15,AX"),
+		"mixed incoming OR":    strings.ReplaceAll(x86SDKLiteralLowBitFixture, "MOVQ $second<>(SB),BX", "MOVQ $123,BX"),
+		"vector escape":        strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "MOVQ AX,X0\nTESTQ $15,AX"),
+		"frame escape":         strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "MOVQ AX,ret+0(FP)\nTESTQ $15,AX"),
+		"mixed OR memory":      strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "MOVOU (AX),X0\nTESTQ $15,AX"),
+		"partial carrier":      strings.ReplaceAll(x86SDKLiteralLowBitFixture, "ORQ BX,AX", "MOVB $0,AL\nORQ BX,AX"),
+		"cyclic carrier":       strings.ReplaceAll(x86SDKLiteralLowBitFixture, "ORQ BX,AX", "again:\nORQ BX,AX\nJMP again"),
+		"arbitrary raw":        strings.ReplaceAll(x86SDKLiteralLowBitFixture, "ORQ BX,AX", "BYTE $0x90\nORQ BX,AX"),
+		"address return":       strings.ReplaceAll(x86SDKLiteralLowBitFixture, "SETEQ AX", ""),
+		"ABI0 context":         strings.ReplaceAll(x86SDKLiteralLowBitFixture, "<ABIInternal>", ""),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+			if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("minimum-floor predicate invented other address/entry/memory permission", facts, err)
+			}
+		})
+	}
+	file, err := Parse(ArchAMD64, x86SDKLiteralLowBitFixture)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, minima := range []map[string]uint32{
+		nil, {"first<>": 32}, {"first<>": 32, "second<>": 8}, {"first<>": 31, "second<>": 32}, {"first<>": 64, "second<>": 32},
+	} {
+		facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}, minima)
+		if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("missing, insufficient or claimed-higher floor granted a predicate", minima, facts, err)
+		}
+	}
+}
+
+func TestGoX86SDKLiteralMinimumAddressFLAGSReaders(t *testing.T) {
+	sig := FuncSig{Name: "example.invalid/independent.entry", Ret: I1, Frame: FrameLayout{Results: []FrameSlot{{Type: I1, Index: 0, Field: -1}}}}
+	check := func(body string, accepted bool) {
+		t.Helper()
+		file, err := Parse(ArchAMD64, body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], sig, "amd64", map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+		if accepted && err != nil || !accepted && (facts != nil || !errors.Is(err, ErrProbeNeedsContext)) {
+			t.Errorf("full address FLAG reader accepted=%v: %s: %v", accepted, body, err)
+		}
+	}
+	for _, op := range amd64RegisterBoolConditions {
+		body := strings.ReplaceAll(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX\n", ""), "SETEQ", op)
+		check(body, op == "SETCC" || op == "SETCS" || op == "SETOC" || op == "SETOS")
+	}
+	for _, op := range []string{"JCC", "JCS", "JO", "JNO", "JE", "JNE", "JS", "JNS", "JP", "JNP", "JGE", "JL", "JG", "JLE", "JHI", "JLS"} {
+		body := strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX\nSETEQ AX\nRET", op+" alternative\nSETCC AX\nRET\nalternative:\nSETCS AX\nRET")
+		check(body, op == "JCC" || op == "JCS" || op == "JO" || op == "JNO")
+	}
+	for op, spec := range x86ConditionalMoveSpecs {
+		body := strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX\nSETEQ AX", "MOVQ $0,DX\nMOVQ $1,CX\n"+string(op)+" CX,DX\nMOVQ DX,AX")
+		check(body, spec.condition == "CC" || spec.condition == "CS" || spec.condition == "OC" || spec.condition == "OS")
+	}
+	check(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "MOVQ $0,CX\nMOVQ $1,DX\nCMPQ CX,DX"), true)
+	check(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "MOVQ $0,CX\nMOVQ $1,DX\nCMPQ CX,DX\nJCC skipped\nTESTQ $15,AX\nskipped:"), true)
+	check(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "JCC skipped\nTESTQ $15,AX\nskipped:"), false)
+	check(strings.ReplaceAll(x86SDKLiteralLowBitFixture, "TESTQ $15,AX", "LAHF\nTESTQ $15,AX"), false)
+}
diff --git a/go_x86_sdk_literal_minimum_binding.go b/go_x86_sdk_literal_minimum_binding.go
new file mode 100644
index 000000000..8ef4b103c
--- /dev/null
+++ b/go_x86_sdk_literal_minimum_binding.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"context"
+	"reflect"
+	"strings"
+)
+
+type numericalSDKLiteralMinimumJoin struct {
+	alignment, originalAlignment *GoX86SDKLiteralAlignment
+	Generation                   uint64
+	Seal                         [32]byte
+	Minima                       map[string]uint32
+}
+
+// BindNumericalReadsWithLiteralAlignment borrows the same original SDK literal
+// owner's independent linked-minimum observer. It permits only sealed masked
+// low-bit predicates, not general numerical addresses or memory/entry authority.
+// All borrowed sources, owners and the original bounded context remain live.
+func (source *GoX86NumericalReadSource) BindNumericalReadsWithLiteralAlignment(ctx context.Context, pkg GoPackage, file *File, options Options, minimum *GoX86SDKLiteralAlignment) (Options, error) {
+	if minimum == nil {
+		return Options{}, numericalSBContext("masked literal predicate needs its live linked minimum")
+	}
+	return source.bindNumericalReads(ctx, pkg, file, options, minimum)
+}
+
+func captureNumericalSDKLiteralMinimum(ctx context.Context, source *GoX86NumericalReadSource, minimum *GoX86SDKLiteralAlignment) (*numericalSDKLiteralMinimumJoin, error) {
+	if minimum == nil {
+		return nil, nil // Ordinary numerical/literal binding grants no address bits.
+	}
+	if source == nil || source.identity != source || source.role != numericalSBSDKSource || source.literals == nil ||
+		minimum.identity != minimum || minimum.owner != source.literals.owner || minimum.owner.source != source.literals.source ||
+		minimum.context != ctx || source.sdk == nil || source.sdk.originalContext != ctx {
+		return nil, numericalSBContext("linked minimum has a foreign original source/owner/context")
+	}
+	if err := minimum.Verify(ctx); err != nil {
+		return nil, err
+	}
+	minimum.mu.Lock()
+	joined := &numericalSDKLiteralMinimumJoin{alignment: minimum, originalAlignment: minimum,
+		Generation: minimum.generation, Seal: minimum.seal, Minima: make(map[string]uint32)}
+	rows := append([]sdkLiteralMinimumAlignment(nil), minimum.observation.Minima...)
+	profile := minimum.observation
+	minimum.mu.Unlock()
+	if profile.Target != source.request.Target || profile.PackagePath != source.request.PackagePath ||
+		profile.InitializerSHA256 != source.literals.owner.seal || profile.CGOEnabled != source.guard.env["CGO_ENABLED"] {
+		return nil, numericalSBContext("linked minimum actual SDK target/profile/initializer differs")
+	}
+	_, arch, _ := strings.Cut(source.request.Target, "/")
+	if arch != "386" && arch != "amd64" {
+		return nil, numericalSBContext("linked minimum lost its actual x86 target width")
+	}
+	for _, global := range source.file.Globl {
+		name := numericalNativeName(strings.TrimSuffix(global.Sym, "<>"), source.request.PackagePath)
+		for _, row := range rows {
+			if row.Name != name || row.SourceOrdinal != source.literals.SourceOrdinal {
+				continue
+			}
+			if _, duplicate := joined.Minima[global.Sym]; duplicate {
+				return nil, numericalSBContext("linked minimum has ambiguous original object identity")
+			}
+			matches := 0
+			for _, image := range source.literals.Initializers.Initializers {
+				definition := image.Definition
+				if image.SourceOrdinal == row.SourceOrdinal && image.MemberOrdinal == row.MemberOrdinal &&
+					definition.Namespace == row.Namespace && definition.Index == row.Index && definition.Name == row.Name &&
+					definition.Size == row.Size && int64(row.Size) == global.Size && int64(len(image.Initial)) == global.Size {
+					matches++
+				}
+			}
+			if matches != 1 || row.MinimumAlignment == 0 || row.MinimumAlignment&(row.MinimumAlignment-1) != 0 ||
+				int64(row.MinimumAlignment) > goAssemblyDataAlignment(Arch(arch), global.Size) {
+				return nil, numericalSBContext("linked minimum lost its exact original object/extent/emitted floor")
+			}
+			joined.Minima[global.Sym] = row.MinimumAlignment
+		}
+	}
+	if len(joined.Minima) == 0 {
+		return nil, numericalSBContext("no unique retained original linked minimum for this complete source")
+	}
+	return joined, nil
+}
+
+func (joined *numericalSDKLiteralMinimumJoin) live() bool {
+	if joined == nil || joined.alignment == nil || joined.alignment != joined.originalAlignment || joined.alignment.identity != joined.alignment {
+		return false
+	}
+	observed := joined.alignment
+	observed.mu.Lock()
+	defer observed.mu.Unlock()
+	return observed.ready && !observed.closePending && observed.generation == joined.Generation && observed.seal == joined.Seal
+}
+
+func (joined *numericalSDKLiteralMinimumJoin) verify(ctx context.Context, source *GoX86NumericalReadSource) error {
+	if !joined.live() {
+		return numericalSBContext("linked minimum factory generation is closed, changed or foreign")
+	}
+	actual, err := captureNumericalSDKLiteralMinimum(ctx, source, joined.alignment)
+	if err != nil {
+		return err
+	}
+	if actual.Generation != joined.Generation || actual.Seal != joined.Seal || !reflect.DeepEqual(actual.Minima, joined.Minima) {
+		return numericalSBContext("linked minimum retained projection changed")
+	}
+	return nil
+}
+
+func validSDKLiteralLowBitForm(ins Instr, bits *x86SDKLiteralLowBits, arch string) bool {
+	if bits == nil || arch != "amd64" && arch != "386" || bits.Mask >= uint64(goAssemblyDataAlignment(Arch(arch), 1<<32)) || bits.Value&^bits.Mask != 0 {
+		return false
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil && form.spec.stem == "OR" {
+		return int64(form.spec.bits/8) == x86ResultPointerWord(arch) && bits.Bytes == x86ResultPointerWord(arch) && form.source.Kind == OpReg && form.destination.Kind == OpReg
+	}
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil || !form.test || bits.Bytes != int64(form.bits/8) || form.args[0].Kind != OpImm || form.args[1].Kind != OpReg {
+		return false
+	}
+	mask := uint64(form.args[0].Imm)
+	if form.bits < 64 {
+		mask &= uint64(1)<<uint(form.bits) - 1
+	}
+	return mask == bits.Mask
+}
+
+func x86ResultSDKLiteralLowBitStep(ins Instr, bits *x86SDKLiteralLowBits, state *x86ResultState, arch string) bool {
+	if !validSDKLiteralLowBitForm(ins, bits, arch) {
+		return false
+	}
+	read := func(operand Operand, width int64) bool {
+		root, _, valid := x86ResultGP(operand.Reg, width, arch)
+		return operand.Kind == OpReg && valid && (state.shapeOnly || state.pointerGP[root])
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil {
+		if !read(form.source, x86ResultPointerWord(arch)) || !read(form.destination, x86ResultPointerWord(arch)) {
+			return false
+		}
+		root, _, _ := x86ResultGP(form.destination.Reg, x86ResultPointerWord(arch), arch)
+		state.gp[root], state.pointerGP[root] = 0, true
+	} else if !read(ins.Args[1], bits.Bytes) {
+		return false
+	}
+	state.flags = state.flags&^x86ByteFlagAF | (x86ByteFlagsAll &^ x86ByteFlagAF)
+	return true // Only FLAGS/opaque carrier effects, never full GP bytes.
+}
diff --git a/go_x86_sdk_literal_minimum_binding_go127_test.go b/go_x86_sdk_literal_minimum_binding_go127_test.go
new file mode 100644
index 000000000..dfedd81cf
--- /dev/null
+++ b/go_x86_sdk_literal_minimum_binding_go127_test.go
@@ -0,0 +1,200 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestGoX86SDKLiteralMinimumOriginalCompleteMapsBinding(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) { sdkLiteralMinimumCompleteMapsBinding(t, target) })
+	}
+}
+
+func sdkLiteralMinimumCompleteMapsBinding(t *testing.T, target string) {
+	source, err := numericalSDKMapsReadCapture(t, target, "memhash_amd64.s")
+	if err != nil {
+		t.Fatal("complete actual SDK source/native/owner precondition", err)
+	}
+	ctx := source.sdk.originalContext
+	minimum, err := CaptureGoX86SDKLiteralAlignment(ctx, source.literals.owner)
+	if err != nil {
+		t.Fatal("independent original-linked minimum precondition", err)
+	}
+	t.Cleanup(func() { minimum.Close() })
+	pkg, file, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "linked address-bit observation") {
+		t.Fatal("ordinary bytes gained original linked address bits", err)
+	}
+	bound, err := source.BindNumericalReadsWithLiteralAlignment(ctx, pkg, file, options, minimum)
+	if err != nil {
+		t.Fatal("complete original source/minimum/declaration binding", err)
+	}
+	if len(bound.Sigs) != len(file.Funcs) || len(file.Funcs) != len(source.file.Funcs) ||
+		bound.NumericalReads.literalMinimum == nil || len(bound.NumericalReads.literalMinimum.Minima) != 2 {
+		t.Fatal("minimum binding omitted original functions or inventories")
+	}
+	seen := 0
+	for _, fact := range bound.NumericalReads.literalAccesses {
+		if fact.LowBits != nil {
+			if fact.LowBits.Mask != 31 && fact.LowBits.Mask != 15 || fact.LowBits.Value != 0 || fact.Function != pkg.Path+".checkMasksAndShiftsAlignment" {
+				t.Fatal("address predicate exceeded actual original minimum", fact)
+			}
+			seen++
+		}
+	}
+	if seen != 2 {
+		t.Fatal("complete original OR/TEST predicate inventory", seen)
+	}
+	frozen, frozenOptions, err := freezeNumericalReadInputs(file, bound)
+	if err != nil || len(frozen.Funcs) != len(file.Funcs) || len(frozen.Data) != len(file.Data) || len(frozen.Globl) != len(file.Globl) {
+		t.Fatal("whole original normalized source/initializer inventories changed", err)
+	}
+	proved := 0
+	for _, fn := range frozen.Funcs {
+		name := frozenOptions.ResolveSym(fn.Sym)
+		if name != pkg.Path+".checkMasksAndShiftsAlignment" {
+			continue
+		}
+		consumer := &amd64Ctx{fpScalarSource: fn, sig: frozenOptions.Sigs[name], goarch: "amd64", targetTriple: options.TargetTriple}
+		if err := consumer.checkLoweredScalarFPResultInitialization(); err != nil {
+			t.Fatal("complete original masked predicate/canonical bool result proof", err)
+		}
+		proved++
+	}
+	if proved != 1 {
+		t.Fatal("full source lost its actual declared predicate", proved)
+	}
+	// The separately tested caller-address rule now composes with this minimum
+	// and the existing paired native-read/result observer. Translate the whole
+	// inventory, never a cropped predicate; this is not native SDK execution.
+	_, err = Translate(file, bound)
+	if err != nil {
+		t.Fatal("complete original maps logical translation", err)
+	}
+	t.Logf("complete original %d TEXT/maps binding retained; logical translation only, not native SDK entry/execution or benchmark completion", len(file.Funcs))
+}
+
+func TestGoX86SDKLiteralMinimumJoinFactoryIdentityAndLifetime(t *testing.T) {
+	for _, mutation := range []string{"copy", "generation", "owner", "source", "higher-floor", "closed", "owner-closed", "source-closed"} {
+		t.Run(mutation, func(t *testing.T) {
+			source, err := numericalSDKMapsReadCapture(t, "amd64", "memhash_amd64.s")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := source.sdk.originalContext
+			minimum, err := CaptureGoX86SDKLiteralAlignment(ctx, source.literals.owner)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() { minimum.Close() })
+			joined, err := captureNumericalSDKLiteralMinimum(ctx, source, minimum)
+			if err != nil || len(joined.Minima) != 2 {
+				t.Fatal("genuine same-source producer join", err)
+			}
+			switch mutation {
+			case "copy":
+				joined.alignment = &GoX86SDKLiteralAlignment{identity: minimum.identity} // No copied mutex/state.
+			case "generation":
+				joined.Generation++
+			case "owner":
+				original := minimum.owner
+				minimum.owner = nil
+				t.Cleanup(func() { minimum.owner = original })
+			case "source":
+				original := source.literals.source
+				source.literals.source = nil
+				t.Cleanup(func() { source.literals.source = original })
+			case "higher-floor":
+				for name := range joined.Minima {
+					joined.Minima[name] *= 2
+				}
+			case "closed":
+				if err := minimum.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "owner-closed":
+				if err := source.literals.owner.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "source-closed":
+				if err := source.literals.source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := joined.verify(ctx, source); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("foreign/changed/closed factory or claimed higher floor retained authority", mutation, err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralMinimumResolverReentry(t *testing.T) {
+	for _, action := range []string{"Readback", "Close"} {
+		t.Run(action, func(t *testing.T) {
+			source, err := numericalSDKMapsReadCapture(t, "amd64", "memhash_amd64.s")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := source.sdk.originalContext
+			minimum, err := CaptureGoX86SDKLiteralAlignment(ctx, source.literals.owner)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() { minimum.Close() })
+			pkg, file, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+			resolve := options.ResolveSym
+			var once sync.Once
+			var nested error
+			options.ResolveSym = func(symbol string) string {
+				once.Do(func() {
+					if action == "Close" {
+						nested = minimum.Close()
+					} else {
+						_, nested = minimum.Readback(ctx)
+					}
+				})
+				return resolve(symbol)
+			}
+			bound, err := source.BindNumericalReadsWithLiteralAlignment(ctx, pkg, file, options, minimum)
+			if nested != nil {
+				t.Fatal("independent callback replay/close failed", nested)
+			}
+			if action == "Close" {
+				if !errors.Is(err, ErrProbeNeedsContext) || bound.NumericalReads != nil {
+					t.Fatal("reentrant close published a minimum predicate", err)
+				}
+			} else if err != nil {
+				t.Fatal("resolver replay held a producer/source lock", err)
+			}
+			if err := source.literals.source.Verify(ctx); err != nil {
+				t.Fatal("borrower callback disposed original source", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralMinimumOpaqueEffectsDoNotInitializeGP(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86SDKLiteralLowBitFixture)
+	if err != nil {
+		t.Fatal(err)
+	}
+	state := x86ResultState{}
+	state.pointerGP[0], state.pointerGP[3] = true, true
+	before := state.gp
+	for _, ordinal := range []int{3, 4} {
+		ins := file.Funcs[0].Instrs[ordinal]
+		bits := &x86SDKLiteralLowBits{Operation: ins.Op, Mask: 15, Bytes: 8}
+		if !x86ResultSDKLiteralLowBitStep(ins, bits, &state, "amd64") || !reflect.DeepEqual(state.gp, before) {
+			t.Fatal("low-bit predicate manufactured full initialized GP bytes", ins, state)
+		}
+	}
+	if state.flags&x86ByteFlagZF == 0 || state.flags&x86ByteFlagAF != 0 {
+		t.Fatal("TEST defined/killed FLAGS changed", state.flags)
+	}
+}
diff --git a/go_x86_sdk_literal_mode32_test.go b/go_x86_sdk_literal_mode32_test.go
new file mode 100644
index 000000000..b9e75e9d8
--- /dev/null
+++ b/go_x86_sdk_literal_mode32_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86SDKLiteral386Predicate = `TEXT ·entry(SB),4,$0-1
+MOVL $first<>(SB),AX
+MOVL $second<>(SB),BX
+ORL BX,AX
+TESTL $15,AX
+SETEQ ret+0(FP)
+RET
+`
+
+func x86SDKLiteral386Signature() FuncSig {
+	return FuncSig{Name: "example.invalid/independent.entry", Ret: I1,
+		Frame: FrameLayout{Results: []FrameSlot{{Type: I1, Index: 0, Field: -1}}}}
+}
+
+func TestGoX86SDKLiteral386MinimumMaskedABI0Predicate(t *testing.T) {
+	for _, view := range []string{"TESTB $15,AX", "TESTB $15,AL", "TESTB $0,AH", "TESTW $15,AX", "TESTL $15,AX"} {
+		for _, condition := range amd64RegisterBoolConditions {
+			t.Run(view+"/"+condition, func(t *testing.T) {
+				text := strings.ReplaceAll(strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX", view), "SETEQ", condition)
+				file, err := Parse(ArchAMD64, text)
+				if err != nil {
+					t.Fatal(err)
+				}
+				before, err := Parse(ArchAMD64, text)
+				if err != nil {
+					t.Fatal(err)
+				}
+				facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], x86SDKLiteral386Signature(), "386",
+					map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+				if err != nil || len(facts) != 4 || !reflect.DeepEqual(file, before) {
+					t.Fatal("complete 32-bit minimum/ABI0 predicate did not retain original source", facts, err)
+				}
+				if _, err := proveX86SDKLiteralAccesses(file.Funcs[0], x86SDKLiteral386Signature(), "386",
+					map[string]int64{"first<>": 256, "second<>": 256}); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("ordinary literal binder gained a linked minimum", err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKLiteral386MinimumDoesNotGrantOtherRoles(t *testing.T) {
+	for name, text := range map[string]string{
+		"high-mask":   strings.ReplaceAll(x86SDKLiteral386Predicate, "$15,AX", "$32,AX"),
+		"high-byte":   strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX", "TESTB $1,AH"),
+		"qword":       strings.ReplaceAll(x86SDKLiteral386Predicate, "ORL BX,AX", "ORQ BX,AX"),
+		"partial":     strings.ReplaceAll(x86SDKLiteral386Predicate, "ORL BX,AX", "MOVB $0,AL\nORL BX,AX"),
+		"vector":      strings.ReplaceAll(x86SDKLiteral386Predicate, "ORL BX,AX", "MOVL AX,X0\nORL BX,AX"),
+		"memory":      strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX", "MOVOU (AX),X0\nTESTL $15,AX"),
+		"escape":      strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX", "MOVL AX,ret+0(FP)\nTESTL $15,AX"),
+		"mixed":       strings.ReplaceAll(x86SDKLiteral386Predicate, "MOVL $second<>(SB),BX", "MOVL $1,BX"),
+		"raw":         strings.ReplaceAll(x86SDKLiteral386Predicate, "ORL BX,AX", "BYTE $0x90\nORL BX,AX"),
+		"stale-flags": strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX\n", ""),
+		"loop":        strings.ReplaceAll(x86SDKLiteral386Predicate, "ORL BX,AX", "again:\nORL BX,AX\nJMP again"),
+		"internal":    strings.ReplaceAll(x86SDKLiteral386Predicate, "·entry(SB)", "·entry<ABIInternal>(SB)"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], x86SDKLiteral386Signature(), "386",
+				map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+			if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("32-bit linked minimum invented a different source/address/result role", facts, err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteral386MinimumTypedEffectsAndCost(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86SDKLiteral386Predicate+"GLOBL first<>(SB),8,$256\nGLOBL second<>(SB),8,$256\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "386", Sigs: map[string]FuncSig{file.Funcs[0].Sym: x86SDKLiteral386Signature()}}
+	if !GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("typed 32-bit original masked predicate did not request its independent producer")
+	}
+	for _, view := range []string{"TESTB $15,AX", "TESTB $15,AL", "TESTB $0,AH", "TESTW $15,AX", "TESTL $15,AX"} {
+		text := strings.ReplaceAll(x86SDKLiteral386Predicate, "TESTL $15,AX", view)
+		candidate, err := Parse(ArchAMD64, text+"GLOBL first<>(SB),8,$256\nGLOBL second<>(SB),8,$256\n")
+		if err != nil || !GoX86SDKLiteralAlignmentRequested(candidate, options) {
+			t.Fatal("original typed view did not request its independent producer", view, err)
+		}
+	}
+	state := x86ResultState{}
+	state.pointerGP[0], state.pointerGP[3] = true, true
+	for _, row := range []struct {
+		op    Op
+		bytes int64
+	}{{"ORL", 4}, {"TESTB", 1}, {"TESTW", 2}, {"TESTL", 4}} {
+		text := string(row.op) + " $15,AX"
+		if row.op == "ORL" {
+			text = "ORL BX,AX"
+		}
+		parsed, err := Parse(ArchAMD64, "TEXT ·probe(SB),4,$0-0\n"+text+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		bits := &x86SDKLiteralLowBits{Operation: row.op, Mask: 15, Bytes: row.bytes, Symbol: "first<>"}
+		if !x86ResultSDKLiteralLowBitStep(parsed.Funcs[0].Instrs[1], bits, &state, "386") {
+			t.Fatal("typed 32-bit low-bit effect rejected", row.op)
+		}
+		if state.gp != [16]uint8{} || !state.pointerGP[0] {
+			t.Fatal("minimum effect initialized numerical GP bytes or lost opaque identity")
+		}
+	}
+}
+
+func TestGoX86SDKLiteral386MinimumCopiesResiduesAndFloors(t *testing.T) {
+	for name, materialize := range map[string]string{
+		"MOVL":    "MOVL $first<>(SB),AX",
+		"LEAL":    "LEAL first<>(SB),AX",
+		"copy":    "MOVL $first<>(SB),CX\nMOVL CX,AX",
+		"residue": "MOVL $first<>+3(SB),AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			text := strings.ReplaceAll(x86SDKLiteral386Predicate, "MOVL $first<>(SB),AX", materialize)
+			file, err := Parse(ArchAMD64, text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], x86SDKLiteral386Signature(), "386",
+				map[string]int64{"first<>": 256, "second<>": 256}, map[string]uint32{"first<>": 32, "second<>": 32})
+			if err != nil || len(facts) != 4 {
+				t.Fatal("complete dword carrier lost its original minimum/residue", facts, err)
+			}
+			if name == "residue" && facts[3].LowBits.Value != 3 {
+				t.Fatal("literal displacement lost guaranteed masked low bits")
+			}
+		})
+	}
+	file, err := Parse(ArchAMD64, x86SDKLiteral386Predicate)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, floors := range []map[string]uint32{nil, {"first<>": 32}, {"first<>": 32, "second<>": 8}, {"first<>": 31, "second<>": 32}, {"first<>": 64, "second<>": 32}} {
+		facts, err := proveX86SDKLiteralAccessesWithMinima(file.Funcs[0], x86SDKLiteral386Signature(), "386",
+			map[string]int64{"first<>": 256, "second<>": 256}, floors)
+		if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("missing/insufficient/invented 32-bit floor created an address fact", facts, err)
+		}
+	}
+}
diff --git a/go_x86_sdk_literal_proof.go b/go_x86_sdk_literal_proof.go
new file mode 100644
index 000000000..8bed8b13a
--- /dev/null
+++ b/go_x86_sdk_literal_proof.go
@@ -0,0 +1,672 @@
+package plan9asm
+
+import (
+	"math"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+type x86SDKLiteralAccess struct {
+	Function    string
+	Instruction int
+	Operand     int
+	Original    Instr
+	Symbol      string
+	Minimum     int64
+	Maximum     int64
+	Width       int64
+	Address     bool
+	LowBits     *x86SDKLiteralLowBits
+}
+
+type x86SDKLiteralValue struct {
+	width                    int64
+	minimum                  uint64
+	maximum                  uint64
+	symbol                   string // A literal identity is never numerical register data.
+	bad                      bool   // A partial write retains may-literal taint, not authority.
+	lowMask, lowValue        uint64 // Only the guaranteed minimum's address bits.
+	hasMinimum               bool
+	bitsOnly, lowIndependent bool // Neither state is a dereferenceable origin.
+}
+
+type x86SDKLiteralState struct {
+	gp          [16]x86SDKLiteralValue
+	comparison  int
+	constant    uint64
+	compared    bool
+	opaqueFlags uint8 // May depend on uncovered address bits, not merely undefined.
+}
+
+// This is a path-sensitive, literal-only proof. It neither runs a caller proof
+// nor invents an invariant for a cycle. A literal loop closes only when its
+// complete typed state repeats at the same active label. Other literal cycles
+// remain Context; cycles unrelated to literals belong to the result proof.
+func proveX86SDKLiteralAccesses(fn Func, sig FuncSig, arch string, literals map[string]int64) ([]x86SDKLiteralAccess, error) {
+	return proveX86SDKLiteralAccessesAtMinimum(fn, sig, arch, literals, nil)
+}
+
+func proveX86SDKLiteralAccessesAtMinimum(fn Func, sig FuncSig, arch string, literals map[string]int64, minima map[string]uint32) ([]x86SDKLiteralAccess, error) {
+	return proveX86SDKLiteralAccessesAtMinimumRequest(fn, sig, arch, literals, minima, false)
+}
+
+func proveX86SDKLiteralAccessesAtMinimumRequest(fn Func, sig FuncSig, arch string, literals map[string]int64, minima map[string]uint32, requestOnly bool) ([]x86SDKLiteralAccess, error) {
+	fail := func(reason string) ([]x86SDKLiteralAccess, error) {
+		return nil, numericalSBContext("private literal source proof: %s", reason)
+	}
+	n := len(fn.Instrs)
+	if n == 0 || n > 4096 || arch != "amd64" && arch != "386" || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil {
+		return fail("requires complete bounded ordinary source")
+	}
+	labels := make(map[string]int)
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+				return fail("malformed source label")
+			}
+			if _, present := labels[ins.Args[0].Sym]; present {
+				return fail("duplicate source label")
+			}
+			labels[ins.Args[0].Sym] = ordinal
+		}
+	}
+	edges := make([][]int, n)
+	named := make([]bool, n)
+	for ordinal, ins := range fn.Instrs {
+		if isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return fail("raw/native/address-size source needs its separate contract")
+		}
+		for index := range ins.Args {
+			if form, valid := x86SDKLiteralOperandProperties(ins, index, arch); valid && literals[form.symbol] > 0 {
+				named[ordinal] = true
+			}
+		}
+		if ins.Op == OpRET {
+			if len(ins.Args) != 0 {
+				return fail("nonordinary source return")
+			}
+			continue
+		}
+		edges[ordinal] = []int{ordinal + 1}
+		if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+			if len(ins.Args) != 1 {
+				return fail("unbound source branch")
+			}
+			arg := ins.Args[0]
+			label := arg.Sym
+			if arg.Kind == OpIdent {
+				label = arg.Ident
+			}
+			target, found := labels[label]
+			if !found || arg.Kind != OpLabel && arg.Kind != OpIdent {
+				return fail("external or indirect source branch")
+			}
+			if ins.Op == OpJMP {
+				edges[ordinal] = []int{target}
+			} else {
+				edges[ordinal] = append(edges[ordinal], target)
+			}
+		}
+		for _, successor := range edges[ordinal] {
+			if successor < 0 || successor >= n {
+				return fail("source continuation leaves complete function")
+			}
+		}
+	}
+	// Backwards reachability is scope, never an index or cycle invariant.
+	future := append([]bool(nil), named...)
+	for changed := true; changed; {
+		changed = false
+		for pc := n - 1; pc >= 0; pc-- {
+			for _, target := range edges[pc] {
+				if !future[pc] && future[target] {
+					future[pc], changed = true, true
+				}
+			}
+		}
+	}
+	word := x86ResultPointerWord(arch)
+	initial := x86SDKLiteralState{}
+	if strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		if arch != "amd64" || len(sig.ArgRegs) != 0 || len(sig.Args) > 9 {
+			return fail("requires the independent ordinary scalar register contract")
+		}
+		for index, reg := range []Reg{AX, BX, CX, DI, SI, "R8", "R9", "R10", "R11"} {
+			if index >= len(sig.Args) {
+				break
+			}
+			width := x86ResultScalarBytes(sig.Args[index], arch)
+			root, _, valid := x86ResultGP(reg, width, arch)
+			if valid {
+				initial.gp[root] = x86SDKLiteralUnknownNumber(width)
+			}
+		}
+	}
+	facts := make(map[int]x86SDKLiteralAccess)
+	nonliteral := make(map[int]bool)
+	path := make([]bool, n)
+	entries := make(map[int]x86SDKLiteralState, len(labels))
+	visits := 0
+	var walk func(int, x86SDKLiteralState) error
+	walk = func(pc int, state x86SDKLiteralState) error {
+		visits++
+		if visits > 16384 {
+			return numericalSBContext("private literal source path budget exhausted")
+		}
+		if path[pc] {
+			if entry, present := entries[pc]; present {
+				if entry == state {
+					return nil
+				}
+				for _, value := range entry.gp {
+					if value.symbol != "" {
+						return numericalSBContext("private literal cyclic carrier changed its entry state")
+					}
+				}
+			}
+			for _, value := range state.gp {
+				if value.symbol != "" {
+					return numericalSBContext("private literal cyclic carrier needs its separate loop contract")
+				}
+			}
+			if future[pc] {
+				return numericalSBContext("private literal cyclic access needs its separate loop contract")
+			}
+			return nil
+		}
+		path[pc] = true
+		defer func() { path[pc] = false }()
+		ins := fn.Instrs[pc]
+		if ins.Op == OpLABEL {
+			// One snapshot per active label, charged to the same path budget.
+			// No historical branch state or weakened range can close a cycle.
+			entries[pc] = state
+			defer delete(entries, pc)
+		}
+		if minima != nil && state.opaqueFlags&x86SDKLiteralFlagReads(ins, arch) != 0 {
+			return numericalSBContext("private literal FLAG reader observes uncovered linked address bits: %s", ins.Raw)
+		}
+		if ins.Op == OpRET {
+			if arch == "amd64" && strings.HasSuffix(fn.Sym, "<ABIInternal>") && sig.Ret != Void && state.gp[0].symbol != "" &&
+				!(minima != nil && sig.Ret == I1 && state.gp[0].lowIndependent) {
+				return numericalSBContext("private literal pointer escapes through the logical result")
+			}
+			return nil
+		}
+		if ins.Op == OpTEXT || ins.Op == OpLABEL || ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+			for edge, target := range edges[pc] {
+				next := state
+				if isAMD64ConditionalBranch(ins.Op) && !x86SDKLiteralRefineEdge(ins.Op, edge == 1, &next) {
+					continue
+				}
+				if err := walk(target, next); err != nil {
+					return err
+				}
+			}
+			return nil
+		}
+		for index, operand := range ins.Args {
+			form, private := x86SDKLiteralOperandProperties(ins, index, arch)
+			if private && literals[form.symbol] == 0 {
+				private = false
+			}
+			if !private && operand.Kind == OpMem && operand.Mem.Sym == "" {
+				root, _, valid := x86ResultGP(operand.Mem.Base, word, arch)
+				if valid && state.gp[root].symbol != "" {
+					value := state.gp[root]
+					if value.bad || value.minimum != value.maximum || value.maximum > math.MaxInt64 ||
+						operand.Mem.OffRaw != "" || operand.Mem.Segment != "" || operand.Mem.IndexExt != "" {
+						return numericalSBContext("private literal derived address lost its exact origin")
+					}
+					width, write, valid := x86InstructionMemoryShape(x86SourceMoveInstruction(ins, arch), index, arch)
+					if !valid || write || width <= 0 {
+						return numericalSBContext("private literal derived access has an unbound read-only shape")
+					}
+					form = x86SDKLiteralOperand{memory: operand.Mem, symbol: value.symbol,
+						offset: int64(value.maximum) + operand.Mem.Off, width: width}
+					private = true
+				}
+			}
+			if operand.Kind == OpMem && operand.Mem.Index != "" {
+				root, _, valid := x86ResultGP(operand.Mem.Index, word, arch)
+				if valid && state.gp[root].symbol != "" {
+					return numericalSBContext("private literal address is not a numerical index")
+				}
+			}
+			if !private {
+				if width, write, known := x86InstructionMemoryShape(x86SourceMoveInstruction(ins, arch), index, arch); known && !write && width > 0 {
+					nonliteral[pc] = true
+				}
+				continue
+			}
+			minimum, maximum := form.offset, form.offset
+			if form.memory.Index != "" {
+				root, _, valid := x86ResultGP(form.memory.Index, word, arch)
+				value := state.gp[root]
+				if !valid || value.symbol != "" || value.width < word || form.memory.Scale != 1 && form.memory.Scale != 2 && form.memory.Scale != 4 && form.memory.Scale != 8 ||
+					value.maximum > math.MaxInt64/uint64(form.memory.Scale) || form.offset < 0 ||
+					int64(value.maximum*uint64(form.memory.Scale)) > math.MaxInt64-form.offset {
+					return numericalSBContext("private literal index lacks a closed numerical envelope at %q: %s %+v", ins.Raw, form.memory.Index, value)
+				}
+				minimum += int64(value.minimum * uint64(form.memory.Scale))
+				maximum += int64(value.maximum * uint64(form.memory.Scale))
+			}
+			if minimum < 0 || maximum < minimum || maximum > literals[form.symbol]-form.width {
+				return numericalSBContext("private literal complete access exceeds its observed byte extent")
+			}
+			fact := x86SDKLiteralAccess{Function: sig.Name, Instruction: pc, Operand: index, Original: ins,
+				Symbol: form.symbol, Minimum: minimum, Maximum: maximum, Width: form.width, Address: form.address}
+			if previous, present := facts[pc]; present {
+				if previous.Symbol != fact.Symbol || previous.Operand != fact.Operand || previous.Address != fact.Address || previous.Width != fact.Width || !reflect.DeepEqual(previous.Original, ins) {
+					return numericalSBContext("private literal has mixed source origins")
+				}
+				fact.Minimum, fact.Maximum = minSDKLiteral(previous.Minimum, fact.Minimum), maxSDKLiteral(previous.Maximum, fact.Maximum)
+			}
+			facts[pc] = fact
+			if form.address {
+				if minimum != maximum {
+					return numericalSBContext("indexed literal materialization needs an affine address contract")
+				}
+				root, _, _ := x86ResultGP(ins.Args[1].Reg, word, arch)
+				state.gp[root] = x86SDKLiteralValue{symbol: form.symbol, minimum: uint64(minimum), maximum: uint64(maximum)}
+				if floor := minima[form.symbol]; floor != 0 {
+					state.gp[root].hasMinimum = true
+					state.gp[root].lowMask = uint64(floor - 1)
+					state.gp[root].lowValue = uint64(minimum) & uint64(floor-1)
+				}
+				if state.comparison == root {
+					state.compared = false
+				}
+				for _, target := range edges[pc] {
+					if err := walk(target, state); err != nil {
+						return err
+					}
+				}
+				return nil
+			}
+		}
+		if requestOnly {
+			known, err := x86SDKLiteralAlignmentRequestStep(ins, &state, arch)
+			if err != nil {
+				return err
+			}
+			if known {
+				for _, target := range edges[pc] {
+					if err := walk(target, state); err != nil {
+						return err
+					}
+				}
+				return nil
+			}
+		}
+		if minima != nil {
+			lowBits, known, err := x86SDKLiteralLowBitStep(ins, &state, fn, sig, arch)
+			if err != nil {
+				return err
+			}
+			if known {
+				if lowBits != nil {
+					fact := x86SDKLiteralAccess{Function: sig.Name, Instruction: pc, Operand: 1, Original: ins,
+						Symbol: lowBits.Symbol, Width: lowBits.Bytes, LowBits: lowBits}
+					if previous, found := facts[pc]; found && !reflect.DeepEqual(previous, fact) {
+						return numericalSBContext("private literal low-bit operation has mixed path guarantees")
+					}
+					facts[pc] = fact
+				}
+				for _, target := range edges[pc] {
+					if err := walk(target, state); err != nil {
+						return err
+					}
+				}
+				return nil
+			}
+		}
+		var literalRead *x86SDKLiteralAccess
+		if fact, found := facts[pc]; found && !fact.Address {
+			literalRead = &fact
+		}
+		if err := x86SDKLiteralTransfer(ins, &state, sig, arch, literalRead); err != nil {
+			return err
+		}
+		if minima != nil {
+			x86SDKLiteralIndependentFlagWrites(ins, &state, arch)
+		}
+		for _, target := range edges[pc] {
+			if err := walk(target, state); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	if err := walk(0, initial); err != nil {
+		return nil, err
+	}
+	ordinals := make([]int, 0, len(facts))
+	for ordinal := range facts {
+		if !facts[ordinal].Address && facts[ordinal].LowBits == nil && nonliteral[ordinal] {
+			return fail("private literal read has an incoming/mixed origin on another feasible path")
+		}
+		ordinals = append(ordinals, ordinal)
+	}
+	sort.Ints(ordinals)
+	result := make([]x86SDKLiteralAccess, 0, len(facts))
+	for _, ordinal := range ordinals {
+		result = append(result, facts[ordinal])
+	}
+	return result, nil
+}
+
+func minSDKLiteral(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}
+func maxSDKLiteral(a, b int64) int64 {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func x86SDKLiteralUnknownNumber(width int64) x86SDKLiteralValue {
+	maximum := ^uint64(0)
+	if width > 0 && width < 8 {
+		maximum = uint64(1)<<(uint(width)*8) - 1
+	}
+	return x86SDKLiteralValue{width: width, maximum: maximum}
+}
+
+func x86SDKLiteralRefineEdge(op Op, taken bool, state *x86SDKLiteralState) bool {
+	if !state.compared {
+		return true
+	}
+	value := &state.gp[state.comparison]
+	next, feasible := (x86UnsignedRange{value.minimum, value.maximum}).refine(op, taken, state.constant)
+	value.minimum, value.maximum = next.minimum, next.maximum
+	return feasible
+}
+
+func x86SDKLiteralTransfer(ins Instr, state *x86SDKLiteralState, sig FuncSig, arch string, literalRead *x86SDKLiteralAccess) error {
+	ins = x86SourceMoveInstruction(ins, arch) // Facts retain the complete original instruction.
+	word := x86ResultPointerWord(arch)
+	op := string(ins.Op)
+	width := int64(0)
+	if strings.HasSuffix(op, "Q") {
+		width = 8
+	} else if strings.HasSuffix(op, "L") {
+		width = 4
+	}
+	read := func(operand Operand, width int64) x86SDKLiteralValue {
+		if literalRead != nil && width > 0 && width <= literalRead.Width && reflect.DeepEqual(operand, ins.Args[literalRead.Operand]) {
+			return x86SDKLiteralUnknownNumber(width)
+		}
+		switch operand.Kind {
+		case OpImm:
+			if operand.ImmRaw == "" && !operand.ImmIsFloat {
+				value := uint64(operand.Imm)
+				if width == 4 {
+					value = uint64(uint32(value))
+				}
+				return x86SDKLiteralValue{width: width, minimum: value, maximum: value}
+			}
+		case OpReg:
+			if root, _, valid := x86ResultGP(operand.Reg, width, arch); valid {
+				value := state.gp[root]
+				if value.symbol == "" && value.width >= width {
+					limit := x86SDKLiteralUnknownNumber(width).maximum
+					if value.maximum > limit {
+						return x86SDKLiteralUnknownNumber(width)
+					}
+					value.width = width
+				}
+				return value
+			}
+		case OpFP:
+			for _, slot := range sig.Frame.Params {
+				if slot.Offset == operand.FPOffset && x86ResultScalarBytes(slot.Type, arch) >= width {
+					return x86SDKLiteralUnknownNumber(width)
+				}
+			}
+		}
+		return x86SDKLiteralValue{}
+	}
+	if (ins.Op == "LEAL" || ins.Op == "LEAQ") && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		// The complete Go LEA row overwrites only its destination and does
+		// not read memory or change flags. An unrelated FP/native address is
+		// still unknown here: no frame/address/backing permission is created.
+		root, _, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+		if valid {
+			state.gp[root] = x86SDKLiteralValue{}
+			if state.comparison == root {
+				state.compared = false
+			}
+			return nil
+		}
+	}
+	if (ins.Op == "CMPQ" || ins.Op == "CMPL") && len(ins.Args) == 2 && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpImm {
+		form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+		if !known || err != nil {
+			return numericalSBContext("private literal comparison has no complete original Go row")
+		}
+		root, _, valid := x86ResultGP(ins.Args[0].Reg, width, arch)
+		value, constant := read(form.args[0], width), read(form.args[1], width)
+		if value.symbol != "" {
+			return numericalSBContext("private literal linked address-bit observation requires independent native alignment or physical identity")
+		}
+		state.compared = valid && value.symbol == "" && value.width >= width && constant.width == width &&
+			(width == word || state.gp[root].maximum <= x86SDKLiteralUnknownNumber(width).maximum)
+		state.comparison, state.constant = root, constant.minimum
+		return nil
+	}
+	if len(ins.Args) == 2 && width > 0 && (strings.HasPrefix(op, "MOV") || strings.HasPrefix(op, "ADD") || strings.HasPrefix(op, "SUB") || strings.HasPrefix(op, "AND")) && ins.Args[1].Kind == OpReg {
+		root, _, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+		if valid {
+			if !strings.HasPrefix(op, "MOV") {
+				form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+				if !known || err != nil || form.spec.unary || form.source.Kind != ins.Args[0].Kind {
+					return numericalSBContext("private literal numerical transform has no complete Go row")
+				}
+				ins.Args = append([]Operand(nil), ins.Args...)
+				ins.Args[0] = form.source // Exact truncated/sign-extended original immediate.
+			}
+			first, previous := read(ins.Args[0], width), read(ins.Args[1], width)
+			if strings.HasPrefix(op, "MOV") {
+				if first.symbol != "" {
+					if width != word || ins.Args[0].Kind != OpReg {
+						return numericalSBContext("private literal partial pointer copy is not numerical data")
+					}
+					state.gp[root] = first
+					if state.comparison == root {
+						state.compared = false
+					}
+					return nil
+				}
+				if first.width < width {
+					first = x86SDKLiteralValue{}
+				}
+				if width == 4 && arch == "amd64" && first.width != 0 {
+					first.width = 8
+				}
+				state.gp[root] = first
+				if state.comparison == root {
+					state.compared = false
+				}
+				return nil
+			}
+			state.compared = false
+			if first.symbol != "" || previous.symbol != "" {
+				if strings.HasPrefix(op, "AND") {
+					return numericalSBContext("private literal linked address-bit observation requires independent native alignment or physical identity")
+				}
+				return numericalSBContext("private literal address transform needs a separate affine contract")
+			}
+			result := x86SDKLiteralValue{}
+			if first.width >= width && previous.width >= width {
+				result = x86SDKLiteralUnknownNumber(width)
+				if strings.HasPrefix(op, "ADD") && first.maximum <= result.maximum-previous.maximum {
+					result.minimum, result.maximum = first.minimum+previous.minimum, first.maximum+previous.maximum
+				} else if strings.HasPrefix(op, "SUB") && previous.minimum >= first.maximum {
+					result.minimum, result.maximum = previous.minimum-first.maximum, previous.maximum-first.minimum
+				} else if strings.HasPrefix(op, "AND") && ins.Args[0].Kind == OpImm {
+					result.maximum = first.maximum
+				}
+				if width == 4 && arch == "amd64" {
+					result.width = 8
+				}
+			}
+			state.gp[root] = result
+			return nil
+		}
+	}
+	if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known {
+		if err != nil {
+			return numericalSBContext("private literal comparison has an invalid complete operand form")
+		}
+		for _, operand := range form.args {
+			if operand.Kind == OpReg {
+				root, _, valid := x86ResultGP(operand.Reg, int64(form.bits/8), arch)
+				if valid && state.gp[root].symbol != "" {
+					return numericalSBContext("private literal linked address-bit observation requires independent native alignment or physical identity")
+				}
+			}
+		}
+		state.compared = false
+		return nil // Compare/test writes FLAGS, never a GP value.
+	}
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+		if err != nil || form.mmx {
+			return numericalSBContext("private literal GP/vector transfer needs its actual typed bank")
+		}
+		if ins.Args[0].Kind == OpReg && !form.sourceX {
+			root, _, valid := x86ResultGP(ins.Args[0].Reg, int64(form.bits/8), arch)
+			if valid && state.gp[root].symbol != "" {
+				return numericalSBContext("private literal address escapes through a vector transfer")
+			}
+		}
+		if ins.Args[1].Kind == OpReg && !form.destinationX {
+			root, _, valid := x86ResultGP(ins.Args[1].Reg, int64(form.bits/8), arch)
+			if valid {
+				state.gp[root] = x86SDKLiteralValue{} // No vector numerical range is imported.
+				if state.comparison == root {
+					state.compared = false
+				}
+			}
+		}
+		return nil
+	}
+	if form, known, err := x86ScalarLaneProperties(ins, arch); known {
+		if err != nil {
+			return numericalSBContext("private literal scalar lane transfer has an invalid typed form")
+		}
+		operand := ins.Args[form.source]
+		if !form.insert {
+			operand = ins.Args[form.destination]
+		}
+		if operand.Kind == OpReg {
+			root, _, valid := x86ResultGP(form.transferReg, int64(form.gpBits/8), arch)
+			if valid && form.insert && state.gp[root].symbol != "" {
+				return numericalSBContext("private literal address escapes through a scalar lane")
+			}
+			if valid && !form.insert {
+				state.gp[root] = x86SDKLiteralValue{}
+				if state.comparison == root {
+					state.compared = false
+				}
+			}
+		}
+		return nil
+	}
+	if x86SDKLiteralVectorOnlyEffect(ins, arch) {
+		return nil // Shared complete forms prove there are no GP/FLAGS outputs.
+	}
+	store := ins
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpFP {
+		// Project only the logical destination to check the existing machine
+		// row. This observes register effects, never FP or native ownership.
+		store.Args = []Operand{ins.Args[0], {Kind: OpMem, Mem: MemRef{Base: AX}}}
+	}
+	if form, known, err := x86ScalarRegisterStoreProperties(store.Op, store, arch); known {
+		if err != nil {
+			return numericalSBContext("private literal scalar store has an invalid typed form")
+		}
+		if form.source.Kind == OpReg {
+			root, _, valid := x86ResultGP(form.source.Reg, form.bytes, arch)
+			if valid && state.gp[root].symbol != "" {
+				return numericalSBContext("private literal address escapes through a scalar store")
+			}
+		}
+		return nil // No GP/FLAGS output; every memory role is proved separately.
+	}
+	effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		for _, value := range state.gp {
+			if value.symbol != "" {
+				return numericalSBContext("private literal live address reaches unknown effect: %s", ins.Raw)
+			}
+		}
+		state.gp, state.compared = [16]x86SDKLiteralValue{}, false
+		return nil // No literal permission follows; final source/result proof remains strict.
+	}
+	if effect.flagsKilled != 0 || effect.flagsDefined != 0 {
+		state.compared = false
+	}
+	for _, operand := range effect.operands {
+		if operand.operand.Kind != OpReg {
+			continue
+		}
+		root, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+		if !valid {
+			continue
+		}
+		value := state.gp[root]
+		if operand.read && value.symbol != "" {
+			if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil &&
+				(form.spec.stem == "OR" || form.spec.stem == "XOR") {
+				return numericalSBContext("private literal linked address-bit observation requires independent native alignment or physical identity")
+			}
+			return numericalSBContext("private literal address escapes as numerical/FP/vector data: %s", ins.Raw)
+		}
+		if operand.write {
+			if operand.width < word && value.symbol != "" {
+				value.bad = true
+				state.gp[root] = value
+			} else {
+				state.gp[root] = x86SDKLiteralValue{}
+			}
+			if state.comparison == root {
+				state.compared = false
+			}
+		}
+	}
+	return nil
+}
+
+func x86SDKLiteralVectorOnlyEffect(ins Instr, arch string) bool {
+	valid := false
+	if _, known, err := x86PackedLogicalProperties(ins, arch); known {
+		valid = err == nil
+	} else if _, known, err := x86AESProperties(ins.Op, ins, arch); known {
+		valid = err == nil
+	} else if _, known, err := x86ImmediateShuffleProperties(ins, arch); known {
+		valid = err == nil
+	} else if _, known, err := x86ByteShuffleProperties(ins.Op, ins, arch); known {
+		valid = err == nil
+	} else if _, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch); known {
+		valid = err == nil
+	} else if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known {
+		valid = err == nil && !form.undefinedOpcode()
+	}
+	if !valid {
+		return false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg {
+			if _, gp := x86CallerGP(operand.Reg); gp {
+				return false // An encoder's GP/MMX alias cannot hide an address observation.
+			}
+		}
+	}
+	return true
+}
diff --git a/go_x86_sdk_literal_proof_test.go b/go_x86_sdk_literal_proof_test.go
new file mode 100644
index 000000000..709d42598
--- /dev/null
+++ b/go_x86_sdk_literal_proof_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+const x86SDKLiteralBoundedFixture = `TEXT ·entry<ABIInternal>(SB),4,$0-16
+CMPQ AX,$16
+JAE done
+ADDQ AX,AX
+MOVQ $numericTable<>(SB),BX
+MOVOU (BX)(AX*8),X0
+MOVQ X0,AX
+RET
+done:
+MOVQ $0,AX
+RET
+`
+
+func TestGoX86SDKLiteralIndependentBoundedAddressProof(t *testing.T) {
+	sig := FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64}, Ret: I64}
+	file, err := Parse(ArchAMD64, x86SDKLiteralBoundedFixture)
+	if err != nil {
+		t.Fatal(err)
+	}
+	facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericTable<>": 256})
+	if err != nil || len(facts) != 2 || !facts[0].Address || facts[1].Address ||
+		facts[1].Width != 16 || facts[1].Minimum != 0 || facts[1].Maximum != 240 {
+		t.Fatal("literal-only complete source did not close its exact index envelope", facts, err)
+	}
+}
+
+func TestGoX86SDKLiteralPreservesOnlyTypedUnwrittenRegisters(t *testing.T) {
+	for _, inserted := range []string{
+		"MOVQ AX,X0", "PINSRW $0,AX,X0", "PSHUFHW $0,X0,X0", "TESTW $15,AX", "PXOR X0,X0",
+	} {
+		t.Run(inserted, func(t *testing.T) {
+			text := strings.Replace(x86SDKLiteralBoundedFixture, "ADDQ AX,AX", inserted+"\nADDQ AX,AX", 1)
+			file, err := Parse(ArchAMD64, text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64}, Ret: I64}
+			if _, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericTable<>": 256}); err != nil {
+				t.Fatal("shared complete operand effect lost an unrelated numerical register", err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralBoundedAddressCannotGrantAnotherContract(t *testing.T) {
+	for name, source := range map[string]string{
+		"no bound":                   strings.ReplaceAll(x86SDKLiteralBoundedFixture, "CMPQ AX,$16\nJAE done\n", ""),
+		"wrong edge":                 strings.ReplaceAll(x86SDKLiteralBoundedFixture, "JAE done", "JB done"),
+		"stale flags":                strings.ReplaceAll(x86SDKLiteralBoundedFixture, "JAE done", "ADDQ $1,AX\nJAE done"),
+		"underflow":                  strings.ReplaceAll(x86SDKLiteralBoundedFixture, "ADDQ AX,AX", "SUBQ $1,AX"),
+		"write":                      strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVOU X0,(BX)(AX*8)"),
+		"pointer to numerical index": strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVOU (BX)(BX*8),X0"),
+		"vector escape":              strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVQ BX,X0"),
+		"pointer return":             strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVQ X0,AX", "MOVQ BX,AX"),
+		"partial pointer overwrite":  strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVB $0,BL\nMOVOU (BX)(AX*8),X0"),
+		"cyclic use":                 strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "again:\nMOVOU (BX)(AX*8),X0\nCMPQ AX,$1\nJE again"),
+		"narrow comparison":          strings.ReplaceAll(x86SDKLiteralBoundedFixture, "CMPQ AX,$16", "CMPL AX,$16"),
+		"native raw source":          strings.ReplaceAll(x86SDKLiteralBoundedFixture, "ADDQ AX,AX", "BYTE $0x90\nADDQ AX,AX"),
+		"source address escape":      strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVQ BX,(CX)"),
+		"source FP escape":           strings.ReplaceAll(x86SDKLiteralBoundedFixture, "MOVOU (BX)(AX*8),X0", "MOVQ BX,ret+8(FP)"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64}, Ret: I64}
+			facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericTable<>": 256})
+			if facts != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("literal address supplied unproved caller/pointer/index/escape/loop authority", facts, err)
+			}
+		})
+	}
+}
+
+func TestGoX86SDKLiteralMixedOriginCannotBorrowAnotherPath(t *testing.T) {
+	text := strings.Replace(x86SDKLiteralBoundedFixture, "MOVQ $numericTable<>(SB),BX\nMOVOU (BX)(AX*8),X0", `CMPQ BX,$0
+JE incoming
+MOVQ $numericTable<>(SB),DX
+JMP join
+incoming:
+MOVQ CX,DX
+join:
+MOVOU (DX)(AX*8),X0`, 1)
+	file, err := Parse(ArchAMD64, text)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "example.invalid/tableowner.entry", Args: []LLVMType{I64, I64, Ptr}, Ret: I64}
+	facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], sig, "amd64", map[string]int64{"numericTable<>": 256})
+	if facts != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "mixed origin") {
+		t.Fatal("literal path authorized another path's incoming pointer", facts, err)
+	}
+}
+
+func TestGoX86SDKLiteralBytesCannotSupplyLinkedAddressBits(t *testing.T) {
+	for _, target := range []struct {
+		arch Arch
+		word string
+	}{
+		{ArchAMD64, "Q"}, {Arch("386"), "L"},
+	} {
+		for _, operation := range []string{
+			"CMP%s BX,$16", "TEST%s $15,BX", "AND%s $15,BX", "OR%s BX,BX", "XOR%s $15,BX",
+		} {
+			text := "TEXT ·entry(SB),4,$0-0\nMOV" + target.word + " $numericTable<>(SB),BX\n" +
+				strings.Replace(operation, "%s", target.word, 1) + "\nRET\n"
+			t.Run(string(target.arch)+"/"+operation, func(t *testing.T) {
+				file, err := Parse(target.arch, text)
+				if err != nil {
+					t.Fatal(err)
+				}
+				facts, err := proveX86SDKLiteralAccesses(file.Funcs[0], FuncSig{Name: "example.invalid/tableowner.entry", Ret: Void},
+					string(target.arch), map[string]int64{"numericTable<>": 256})
+				if facts != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "linked address-bit observation") {
+					t.Fatal("readonly bytes or a 256-byte extent supplied original linked address bits", facts, err)
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKLiteralTemporaryReaderDoesNotEscapeTransfer(t *testing.T) {
+	operand := Operand{Kind: OpMem, Mem: MemRef{Base: BX, Index: AX, Scale: 8}}
+	state := x86ResultState{literalMemoryOperand: &operand, literalMemoryBytes: 16}
+	if !x86ResultRead(operand, 16, &state, nil, "amd64") || x86ResultRead(operand, 17, &state, nil, "amd64") {
+		t.Fatal("instruction-local reader changed its exact native byte width")
+	}
+	changed := operand
+	changed.Mem.Off = 1
+	if x86ResultRead(changed, 16, &state, nil, "amd64") {
+		t.Fatal("another displacement borrowed the literal reader")
+	}
+	cloned := state.clone()
+	if cloned.literalMemoryOperand != nil || cloned.literalMemoryBytes != 0 || x86ResultRead(operand, 16, &cloned, nil, "amd64") {
+		t.Fatal("temporary literal memory authority escaped through a CFG clone")
+	}
+}
diff --git a/go_x86_sdk_readonly_literal_data.go b/go_x86_sdk_readonly_literal_data.go
new file mode 100644
index 000000000..3e776f0d6
--- /dev/null
+++ b/go_x86_sdk_readonly_literal_data.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"sync"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// GoX86SDKReadonlyLiteralDataOwner is an opaque, explicit initializer owner.
+// It is distinct from a Go numerical variable and supplies no pointer, read,
+// native body, Frame, Options or ABI permission.
+type GoX86SDKReadonlyLiteralDataOwner struct {
+	mu               sync.Mutex
+	identity         *GoX86SDKReadonlyLiteralDataOwner
+	ready            bool
+	generation       uint64
+	source           *GoX86SDKASMDataSource
+	originalSource   *GoX86SDKASMDataSource
+	sourceGeneration uint64
+	sourceSeal       [32]byte
+	sourceStateSeal  [32]byte
+	context          context.Context
+	originalContext  context.Context
+	originalDeadline time.Time
+	report           []byte
+	seal             [32]byte
+}
+
+type sdkReadonlyLiteralDataReport struct {
+	Protocol, PackagePath, Target string
+	SourceReportSHA256            [32]byte
+	SourceGeneration              uint64
+	Initializers                  []gostaticstorage.ReadonlyLiteralDataImage
+}
+
+const sdkReadonlyLiteralDataProtocol = "actual_go_sdk_private_readonly_literal_initializer_v1"
+
+// CaptureGoX86SDKReadonlyLiteralDataOwner requires an actual live SDK ASM
+// observation. Public reports, names, hashes and types are not constructors.
+func CaptureGoX86SDKReadonlyLiteralDataOwner(ctx context.Context, source *GoX86SDKASMDataSource) (*GoX86SDKReadonlyLiteralDataOwner, error) {
+	if ctx == nil || source == nil || source.identity != source {
+		return nil, sdkASMDataContext("missing actual SDK literal DATA source")
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	deadline, bounded := ctx.Deadline()
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	if !bounded || !reflect.TypeOf(ctx).Comparable() {
+		return nil, sdkASMDataContext("literal initializer requires one bounded original capture context")
+	}
+	source.mu.Lock()
+	generation, seal, stateSeal, ready := source.generation, source.seal, source.stateSeal, source.ready
+	source.mu.Unlock()
+	if !ready {
+		return nil, sdkASMDataContext("literal DATA source is closed or revoked")
+	}
+	raw, err := source.Readback(ctx)
+	if err != nil {
+		return nil, err
+	}
+	// These bytes came only from this exact live source's authenticated retained
+	// inputs. Neither the public report nor this decoder is a constructor.
+	var observation sdkASMDataLiveObservation
+	if sha256.Sum256(raw) != seal || json.Unmarshal(raw, &observation) != nil {
+		return nil, sdkASMDataContext("literal DATA source readback changed")
+	}
+	images, err := gostaticstorage.ReadonlyLiteralDataInitializers(observation.Objects)
+	if err != nil {
+		return nil, sdkASMDataContext("private readonly literal DATA initialization: %v", err)
+	}
+	report, err := json.Marshal(sdkReadonlyLiteralDataReport{Protocol: sdkReadonlyLiteralDataProtocol,
+		PackagePath: observation.Objects.PackagePath, Target: observation.Objects.Target,
+		SourceReportSHA256: seal, SourceGeneration: generation, Initializers: images})
+	if err != nil {
+		return nil, err
+	}
+	owner := &GoX86SDKReadonlyLiteralDataOwner{source: source, originalSource: source,
+		sourceGeneration: generation, sourceSeal: seal, sourceStateSeal: stateSeal,
+		context: ctx, originalContext: ctx, originalDeadline: deadline,
+		report: report, seal: sha256.Sum256(report), ready: true, generation: 1}
+	owner.identity = owner
+	if err := owner.Verify(ctx); err != nil {
+		owner.Close()
+		return nil, err
+	}
+	return owner, nil
+}
+
+func (owner *GoX86SDKReadonlyLiteralDataOwner) liveContext(ctx context.Context) error {
+	if ctx == nil || owner.context == nil || owner.originalContext == nil ||
+		reflect.TypeOf(owner.context) != reflect.TypeOf(owner.originalContext) ||
+		!reflect.TypeOf(owner.context).Comparable() || owner.context != owner.originalContext {
+		return sdkASMDataContext("literal initializer original context identity changed")
+	}
+	_, err := sampleGoSourceContext(ctx, owner.context,
+		goSourceContextLifetime{deadline: owner.originalDeadline, bounded: true}, false,
+		sdkASMDataContext("literal initializer original deadline changed or canceled without a cause"))
+	return err
+}
+
+func (owner *GoX86SDKReadonlyLiteralDataOwner) verifySourceGeneration() error {
+	source := owner.source
+	if source == nil || source != owner.originalSource || source.identity != source {
+		return sdkASMDataContext("literal initializer borrowed a foreign or copied source")
+	}
+	source.mu.Lock()
+	current := source.ready && source.generation == owner.sourceGeneration &&
+		source.seal == owner.sourceSeal && source.stateSeal == owner.sourceStateSeal
+	source.mu.Unlock()
+	if !current {
+		return sdkASMDataContext("literal initializer source generation is closed, stale or changed")
+	}
+	return nil
+}
+
+// Verify rechecks the actual complete source/object producer, not a hash-only
+// restored observation. All caller callbacks and source operations run outside
+// this owner's mutex. Failure permanently revokes only this initializer token.
+func (owner *GoX86SDKReadonlyLiteralDataOwner) Verify(ctx context.Context) (result error) {
+	if owner == nil || owner.identity != owner {
+		return sdkASMDataContext("copied, missing or uninitialized literal owner")
+	}
+	owner.mu.Lock()
+	generation, ready := owner.generation, owner.ready
+	owner.mu.Unlock()
+	if !ready {
+		return sdkASMDataContext("literal initializer is closed or revoked")
+	}
+	defer func() {
+		result = errors.Join(result, owner.liveContext(ctx), owner.verifySourceGeneration())
+		owner.mu.Lock()
+		if owner.generation != generation || !owner.ready || sha256.Sum256(owner.report) != owner.seal {
+			result = errors.Join(result, sdkASMDataContext("literal initializer closed or changed during verification"))
+		}
+		if result != nil {
+			owner.ready = false
+			owner.generation++
+		}
+		owner.mu.Unlock()
+	}()
+	if err := errors.Join(owner.liveContext(ctx), owner.verifySourceGeneration()); err != nil {
+		return err
+	}
+	private, stop, err := sdkASMDataPrivateContext(ctx, owner.context, owner.originalDeadline)
+	if err != nil {
+		return err
+	}
+	defer stop()
+	owner.mu.Lock()
+	current := owner.ready && owner.generation == generation && sha256.Sum256(owner.report) == owner.seal
+	owner.mu.Unlock()
+	if !current {
+		return sdkASMDataContext("literal initializer revoked during caller callbacks")
+	}
+	return errors.Join(owner.source.Verify(private), private.Err())
+}
+
+// Close revokes this owner only. Source artifacts belong to the independently
+// supplied source and are never removed by a copied or ordinary initializer.
+func (owner *GoX86SDKReadonlyLiteralDataOwner) Close() error {
+	if owner == nil {
+		return nil
+	}
+	if owner.identity != owner {
+		return sdkASMDataContext("copied literal initializer cannot close its original owner")
+	}
+	owner.mu.Lock()
+	owner.ready = false
+	owner.generation++
+	owner.mu.Unlock()
+	return nil
+}
+
+// Readback returns immutable diagnostic bytes, not storage or read authority.
+func (owner *GoX86SDKReadonlyLiteralDataOwner) Readback(ctx context.Context) ([]byte, error) {
+	if err := owner.Verify(ctx); err != nil {
+		return nil, err
+	}
+	owner.mu.Lock()
+	defer owner.mu.Unlock()
+	if !owner.ready {
+		return nil, sdkASMDataContext("literal initializer closed after verification")
+	}
+	return append([]byte(nil), owner.report...), nil
+}
+
+// CheckReadback checks exact retained bytes. Public JSON cannot recreate the
+// owner or turn an initial byte image into an initialized Go Variable.
+func (owner *GoX86SDKReadonlyLiteralDataOwner) CheckReadback(ctx context.Context, raw []byte) error {
+	if err := owner.Verify(ctx); err != nil {
+		return err
+	}
+	owner.mu.Lock()
+	defer owner.mu.Unlock()
+	if !owner.ready || !bytes.Equal(raw, owner.report) {
+		owner.ready = false
+		owner.generation++
+		return sdkASMDataContext("literal initializer readback differs from retained original bytes")
+	}
+	return nil
+}
diff --git a/go_x86_sdk_readonly_literal_data_go127_test.go b/go_x86_sdk_readonly_literal_data_go127_test.go
new file mode 100644
index 000000000..13492796e
--- /dev/null
+++ b/go_x86_sdk_readonly_literal_data_go127_test.go
@@ -0,0 +1,481 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These are two different actual SDK packages, not library-name allowlists.
+// Complete source/header/CPP/object observation must close before the new
+// initializer factory is asked to establish its independent role.
+func TestGoX86SDKReadonlyLiteralDataActualSources(t *testing.T) {
+	for _, selected := range []struct{ arch, pkg string }{
+		{"amd64", "hash/crc32"},
+		{"amd64", "internal/chacha8rand"},
+		{"386", "internal/runtime/maps"},
+	} {
+		t.Run(selected.pkg+"/"+selected.arch, func(t *testing.T) {
+			pkg := selected.pkg
+			ctx, request := sdkASMDataRequest(t, selected.arch, pkg)
+			source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+			if err != nil {
+				t.Fatal("actual complete SDK observation precondition", err)
+			}
+			t.Cleanup(func() { source.Close() })
+			sdkASMDataRetain(t, source)
+			owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+			if err != nil || owner == nil {
+				t.Fatal("actual SDK private readonly literal initializer is not certified", err)
+			}
+			t.Cleanup(func() { owner.Close() })
+			raw, err := owner.Readback(ctx)
+			if err != nil || owner.CheckReadback(ctx, raw) != nil {
+				t.Fatal("live exact initializer readback is not closed", err)
+			}
+			var report sdkReadonlyLiteralDataReport
+			if json.Unmarshal(raw, &report) != nil || report.Protocol != sdkReadonlyLiteralDataProtocol ||
+				report.Target != request.Target || report.PackagePath != pkg || report.SourceReportSHA256 != source.seal ||
+				report.SourceGeneration != source.generation || len(report.Initializers) == 0 {
+				t.Fatal("initializer omitted the whole actual SDK source identity")
+			}
+			count := 0
+			for _, observed := range source.observation.Objects.Sources {
+				count += len(observed.ExpandedLayouts)
+			}
+			if len(report.Initializers) != count {
+				t.Fatal("initializer omitted selected source private DATA")
+			}
+			for _, image := range report.Initializers {
+				member := source.observation.Objects.Members[image.MemberOrdinal]
+				found := false
+				for _, definition := range member.Definitions {
+					if definition.Namespace == image.Definition.Namespace && definition.Index == image.Definition.Index {
+						found = true
+						if !reflect.DeepEqual(definition, image.Definition) || int(definition.Size) != len(image.Initial) ||
+							!bytes.Equal(definition.Data, image.Initial[:len(definition.Data)]) {
+							t.Fatal("initializer selected another source/object-local definition")
+						}
+						for _, value := range image.Initial[len(definition.Data):] {
+							if value != 0 {
+								t.Fatal("initializer tail is not exact Go zero padding")
+							}
+						}
+					}
+				}
+				if !found {
+					t.Fatal("initializer object identity is absent from the whole archive")
+				}
+			}
+			for _, name := range []string{"Bind", "BindNumericalReads", "Options", "Pointer", "Read", "Variable", "Owners", "GoPackage"} {
+				if _, present := reflect.TypeOf(owner).MethodByName(name); present {
+					t.Fatal("literal initialization borrowed another authority", name)
+				}
+			}
+			if folder := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); folder != "" {
+				name := strings.ReplaceAll(t.Name(), "/", "-")
+				if err := os.WriteFile(filepath.Join(folder, name+".readonly-literal.json"), raw, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func readonlyLiteralCapture(t *testing.T) (context.Context, *GoX86SDKASMDataSource, *GoX86SDKReadonlyLiteralDataOwner) {
+	t.Helper()
+	ctx, request := sdkASMDataRequest(t, "amd64", "hash/crc32")
+	source, err := CaptureGoX86SDKASMDataSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual SDK source precondition", err)
+	}
+	t.Cleanup(func() { source.Close() })
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if err != nil {
+		t.Fatal("actual literal owner precondition", err)
+	}
+	t.Cleanup(func() { owner.Close() })
+	return ctx, source, owner
+}
+
+func readonlyLiteralInvoke(t *testing.T, api string, owner *GoX86SDKReadonlyLiteralDataOwner, ctx context.Context, raw []byte) ([]byte, error) {
+	t.Helper()
+	switch api {
+	case "Verify":
+		return nil, owner.Verify(ctx)
+	case "Readback":
+		return owner.Readback(ctx)
+	case "CheckReadback":
+		return nil, owner.CheckReadback(ctx, raw)
+	}
+	t.Fatal("unknown initializer API")
+	return nil, nil
+}
+
+func TestGoX86SDKReadonlyLiteralDataCopyCloseAndBytes(t *testing.T) {
+	ctx, source, owner := readonlyLiteralCapture(t)
+	copy := reflect.New(reflect.TypeOf(owner).Elem())
+	copy.Elem().Set(reflect.ValueOf(owner).Elem())
+	copied := copy.Interface().(*GoX86SDKReadonlyLiteralDataOwner)
+	if !errors.Is(copied.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(copied.Close(), ErrProbeNeedsContext) {
+		t.Fatal("copied initializer borrowed or revoked its original token")
+	}
+	if err := owner.Verify(ctx); err != nil {
+		t.Fatal("copied initializer affected its original owner", err)
+	}
+	raw, err := owner.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if owner.CheckReadback(ctx, append(raw, ' ')) == nil || !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("public bytes recreated an initializer or restoration revived it")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("initializer byte mismatch revoked its independently owned source", err)
+	}
+	if err := owner.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(source.guard.owned); err != nil {
+		t.Fatal("initializer cleanup deleted the source artifacts", err)
+	}
+	if source.guard.ready || source.guard.request.NumericalReads != nil {
+		t.Fatal("literal initializer granted frame or numerical-read permission")
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataSourceAndOwnerMutations(t *testing.T) {
+	for name, mutate := range map[string]func(*GoX86SDKASMDataSource, *GoX86SDKReadonlyLiteralDataOwner){
+		"source-close":            func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) { s.Close() },
+		"owner-close":             func(_ *GoX86SDKASMDataSource, o *GoX86SDKReadonlyLiteralDataOwner) { o.Close() },
+		"source-generation":       func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) { s.generation++ },
+		"owner-source-generation": func(_ *GoX86SDKASMDataSource, o *GoX86SDKReadonlyLiteralDataOwner) { o.sourceGeneration++ },
+		"source-bytes":            func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) { s.report[0] ^= 1 },
+		"object-index": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) {
+			s.observation.Objects.Members[2].Definitions[0].Index++
+		},
+		"object-data": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) {
+			s.observation.Objects.Members[2].Definitions[0].Data[0] ^= 1
+		},
+		"original-ASM": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) {
+			s.observation.ObjectInputs.Sources[0].Original[0] ^= 1
+		},
+		"header": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) {
+			s.observation.Header.Actual[0] ^= 1
+		},
+		"source-selection": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) { s.guard.selection.SFiles = nil },
+		"archive": func(s *GoX86SDKASMDataSource, _ *GoX86SDKReadonlyLiteralDataOwner) {
+			s.observation.ObjectInputs.Archive[0] ^= 1
+		},
+		"foreign-source": func(_ *GoX86SDKASMDataSource, o *GoX86SDKReadonlyLiteralDataOwner) {
+			o.source = &GoX86SDKASMDataSource{}
+		},
+		"owner-bytes":   func(_ *GoX86SDKASMDataSource, o *GoX86SDKReadonlyLiteralDataOwner) { o.report[0] ^= 1 },
+		"owner-context": func(_ *GoX86SDKASMDataSource, o *GoX86SDKReadonlyLiteralDataOwner) { o.context = context.Background() },
+	} {
+		t.Run(name, func(t *testing.T) {
+			ctx, source, owner := readonlyLiteralCapture(t)
+			mutate(source, owner)
+			if err := owner.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed whole source or exact initializer verified", err)
+			}
+			if owner.ready || !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+				t.Fatal("revoked literal initializer revived")
+			}
+		})
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataContextReentry(t *testing.T) {
+	for _, route := range []string{"original", "verification"} {
+		for _, method := range []string{"Err", "Deadline", "Done"} {
+			t.Run(route+"/"+method, func(t *testing.T) {
+				// Bound one independent callback role, not the cumulative
+				// race-instrumented work of all 24 owner/API combinations.
+				ctx, source, _ := readonlyLiteralCapture(t)
+				for _, api := range []string{"Verify", "Readback", "CheckReadback", "Close"} {
+					t.Run(api, func(t *testing.T) {
+						verification, cancel := context.WithCancel(ctx)
+						defer cancel()
+						callback := &sdkASMDataReentrantContext{Context: verification, method: method}
+						captureContext := verification
+						if route == "original" {
+							captureContext = callback
+						}
+						owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(captureContext, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						defer owner.Close()
+						raw, err := owner.Readback(ctx)
+						if err != nil {
+							t.Fatal(err)
+						}
+						var nested error
+						callback.callback = func() {
+							if api == "Close" {
+								nested = owner.Close()
+							} else {
+								_, nested = readonlyLiteralInvoke(t, api, owner, verification, raw)
+							}
+						}
+						callback.armed.Store(true)
+						finished := make(chan error, 1)
+						go func() { finished <- errors.Join(owner.Verify(callback), nested) }()
+						select {
+						case err := <-finished:
+							if api == "Close" {
+								if !errors.Is(err, ErrProbeNeedsContext) || owner.ready {
+									t.Fatal("reentrant Close published a revoked initializer", err)
+								}
+							} else if err != nil {
+								t.Fatal("initializer validation callback deadlocked or rejected its actual owner", err)
+							}
+						case <-ctx.Done():
+							// Actual SDK validation can take longer under the race
+							// detector. Use the existing producer/test deadline,
+							// cancel and join this worker before ending the case.
+							cancel()
+							err := <-finished
+							t.Fatal("initializer callback exceeded its existing bounded context", ctx.Err(), err)
+						}
+						if err := source.Verify(ctx); err != nil {
+							t.Fatal("initializer callback disposed its source", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataOriginalDeadlineAndCancellation(t *testing.T) {
+	ctx, source, _ := readonlyLiteralCapture(t)
+	for _, change := range []string{"earlier", "later", "lost", "cancel", "expired"} {
+		for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+			t.Run(change+"/"+api, func(t *testing.T) {
+				original, cancel := context.WithCancel(ctx)
+				defer cancel()
+				mutable := &sdkASMDataReentrantContext{Context: original}
+				owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(mutable, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer owner.Close()
+				raw, err := owner.Readback(ctx)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want := ErrProbeNeedsContext
+				verification := ctx
+				switch change {
+				case "earlier":
+					mutable.shift.Store(-int64(time.Minute))
+				case "later":
+					mutable.shift.Store(int64(time.Minute))
+				case "lost":
+					mutable.lost.Store(true)
+				case "cancel":
+					cancel()
+					want = context.Canceled
+				case "expired":
+					verification, cancel = context.WithDeadline(ctx, time.Now().Add(-time.Second))
+					defer cancel()
+					want = context.DeadlineExceeded
+				}
+				returned, err := readonlyLiteralInvoke(t, api, owner, verification, raw)
+				if !errors.Is(err, want) || len(returned) != 0 {
+					t.Fatal("changed lifecycle published initialized bytes or lost actual cause", err)
+				}
+				mutable.shift.Store(0)
+				mutable.lost.Store(false)
+				if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("restoring the original deadline revived the initializer")
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataConcurrentClose(t *testing.T) {
+	ctx, source, owner := readonlyLiteralCapture(t)
+	var workers sync.WaitGroup
+	for index := 0; index < 4; index++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			if err := owner.Verify(ctx); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Error(err)
+			}
+		}()
+	}
+	if err := owner.Close(); err != nil {
+		t.Fatal(err)
+	}
+	workers.Wait()
+	if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) || source.Verify(ctx) != nil {
+		t.Fatal("concurrent initializer close revived it or deleted independent source")
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataNoJSONOrOtherRole(t *testing.T) {
+	ctx, source := sdkASMDataCapture(t)
+	owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, source)
+	if owner != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("SDK source without literal DATA acquired initializer permission", err)
+	}
+	var zero GoX86SDKReadonlyLiteralDataOwner
+	if !errors.Is(zero.Verify(ctx), ErrProbeNeedsContext) || !errors.Is(zero.Close(), ErrProbeNeedsContext) {
+		t.Fatal("zero public token recreated a private initializer owner")
+	}
+	for _, input := range []*GoX86SDKASMDataSource{nil, {}} {
+		if owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, input); owner != nil || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unbound source or public JSON could construct a live literal owner", err)
+		}
+	}
+	// Go storage types are still observations, not substitutes for this token.
+	if _, present := reflect.TypeOf((*gostaticstorage.Variable)(nil)).MethodByName("Initializers"); present {
+		t.Fatal("literal initialization replaced the original Go Variable role")
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataExactSourceIdentity(t *testing.T) {
+	ctx, source, owner := readonlyLiteralCapture(t)
+	other, err := CaptureGoX86SDKASMDataSource(ctx, source.request)
+	if err != nil {
+		t.Fatal("second independent actual SDK source", err)
+	}
+	defer other.Close()
+	owner.source = other
+	if err := owner.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("another real same-package source replaced the exact original owner", err)
+	}
+	owner.source = source
+	if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) || other.Verify(ctx) != nil || source.Verify(ctx) != nil {
+		t.Fatal("source restoration revived the initializer or affected the independent owners")
+	}
+	copy := reflect.New(reflect.TypeOf(source).Elem())
+	copy.Elem().Set(reflect.ValueOf(source).Elem())
+	copied := copy.Interface().(*GoX86SDKASMDataSource)
+	if owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, copied); owner != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("whole copied real source minted a fresh initializer identity", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("copied factory input revoked its original source", err)
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataPhysicalHeaderTOCTOU(t *testing.T) {
+	ctx, source, owner := readonlyLiteralCapture(t)
+	file := filepath.Join(source.guard.owned, "go_asm.h")
+	original, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(file, append(original, []byte("#define initializer_foreign 7\n")...), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := owner.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed physical original compiler header preserved initialized bytes", err)
+	}
+	if err := os.WriteFile(file, original, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+		t.Fatal("physical header restoration revived the initializer")
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataCallbackCannotPublish(t *testing.T) {
+	ctx, source, _ := readonlyLiteralCapture(t)
+	for _, route := range []string{"original", "verification"} {
+		for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+			t.Run(route+"/"+api, func(t *testing.T) {
+				original := &sdkASMDataReentrantContext{Context: ctx}
+				owner, err := CaptureGoX86SDKReadonlyLiteralDataOwner(original, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer owner.Close()
+				raw, err := owner.Readback(ctx)
+				if err != nil {
+					t.Fatal(err)
+				}
+				callback := &sdkASMDataReentrantContext{Context: ctx, method: "Done"}
+				verification := context.Context(callback)
+				if route == "original" {
+					callback, verification = original, ctx
+					callback.method = "Done"
+				}
+				callback.callback = func() { original.shift.Store(int64(time.Minute)) }
+				callback.armed.Store(true)
+				returned, err := readonlyLiteralInvoke(t, api, owner, verification, raw)
+				if !errors.Is(err, ErrProbeNeedsContext) || len(returned) != 0 {
+					t.Fatal("caller callback published a changed original initializer generation", err)
+				}
+				original.shift.Store(0)
+				if !errors.Is(owner.Verify(ctx), ErrProbeNeedsContext) {
+					t.Fatal("callback deadline restoration revived the initializer")
+				}
+			})
+		}
+	}
+}
+
+func TestGoX86SDKReadonlyLiteralDataConcurrentSourceRevocation(t *testing.T) {
+	for _, api := range []string{"Verify", "Readback", "CheckReadback"} {
+		t.Run(api, func(t *testing.T) {
+			ctx, source, owner := readonlyLiteralCapture(t)
+			verification, cancel := context.WithCancel(ctx)
+			defer cancel()
+			raw, err := owner.Readback(ctx)
+			if err != nil {
+				t.Fatal(err)
+			}
+			entered, resume := make(chan struct{}), make(chan struct{})
+			callback := &sdkASMDataReentrantContext{Context: verification, method: "Done"}
+			callback.callback = func() { close(entered); <-resume }
+			callback.armed.Store(true)
+			finished := make(chan error, 1)
+			go func() {
+				returned, err := readonlyLiteralInvoke(t, api, owner, callback, raw)
+				if len(returned) != 0 {
+					err = errors.Join(err, errors.New("revoked source published an initializer report"))
+				}
+				finished <- err
+			}()
+			select {
+			case <-entered:
+			case <-ctx.Done():
+				cancel()
+				close(resume)
+				err := <-finished
+				t.Fatal("source revocation control exceeded its existing context before caller callback", ctx.Err(), err)
+			}
+			closed := source.Close()
+			close(resume)
+			select {
+			case err := <-finished:
+				if closed != nil || !errors.Is(err, ErrProbeNeedsContext) || owner.ready {
+					t.Fatal("concurrent source Close published a stale initializer", err, closed)
+				}
+			case <-ctx.Done():
+				cancel()
+				err := <-finished
+				t.Fatal("source Close and initializer callback exceeded their existing context", ctx.Err(), err)
+			}
+		})
+	}
+}
diff --git a/go_x86_tls_move_binding.go b/go_x86_tls_move_binding.go
new file mode 100644
index 000000000..577895d80
--- /dev/null
+++ b/go_x86_tls_move_binding.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"errors"
+	"strings"
+)
+
+// GoX86TLSMoveBinding consumes a live source-encoder observation. Its sole
+// permission is substituting the independently observed zero-width NOPs.
+// In particular it cannot define the original destination GP bytes.
+type GoX86TLSMoveBinding struct {
+	identity        *GoX86TLSMoveBinding
+	source          *GoX86TLSMoveSource
+	originalSource  *GoX86TLSMoveSource
+	context         context.Context
+	originalContext context.Context
+	file            [32]byte
+	arch            string
+	triple          string
+	seal            [32]byte
+}
+
+func (source *GoX86TLSMoveSource) BindTLSMoves(ctx context.Context, file *File, options Options) (Options, error) {
+	if err := source.Verify(ctx); err != nil {
+		return Options{}, err
+	}
+	_, arch, _ := strings.Cut(source.request.Target, "/")
+	if options.Goarch != arch || options.TargetTriple != x86TLSExpectedTriple(source.request.Target) || options.TargetTriple == "" ||
+		options.X86TLSMoves != nil || options.NumericalReads != nil || options.ARM64ByteCarrierSource != nil || len(options.X86TailGroups) != 0 {
+		return Options{}, x86TLSMoveContext("binding source/profile or independent native authority differs")
+	}
+	actual, err := x86CallerSourceFingerprint(source.file)
+	provided, sourceErr := x86CallerSourceFingerprint(file)
+	if err != nil || sourceErr != nil || file == nil || provided != actual || len(source.noops) == 0 {
+		return Options{}, x86TLSMoveContext("binding needs the complete original file and an actual NOP effect")
+	}
+	binding := &GoX86TLSMoveBinding{source: source, originalSource: source, context: ctx, originalContext: ctx,
+		file: actual, arch: arch, triple: options.TargetTriple}
+	binding.identity = binding
+	binding.seal = binding.digest()
+	options.X86TLSMoves = binding
+	return options, nil
+}
+
+// Target equality is an explicit code-generation contract. This mapping does
+// not choose a TLS rewrite; only the actual source/object/listing producer does.
+func x86TLSExpectedTriple(target string) string {
+	return map[string]string{
+		"linux/amd64": "x86_64-unknown-linux-gnu", "linux/386": "i386-unknown-linux-gnu",
+		"darwin/amd64": "x86_64-apple-darwin", "windows/amd64": "x86_64-pc-windows-msvc",
+		"windows/386": "i686-pc-windows-msvc", "freebsd/386": "i386-unknown-freebsd",
+		"freebsd/amd64": "x86_64-unknown-freebsd",
+	}[target]
+}
+
+func (binding *GoX86TLSMoveBinding) digest() [32]byte {
+	return sha256.Sum256([]byte(string(binding.file[:]) + "\x00" + binding.arch + "\x00" + binding.triple))
+}
+
+func (binding *GoX86TLSMoveBinding) verify(file *File, options Options) (result error) {
+	defer func() {
+		if result != nil && binding != nil {
+			binding.originalSource.revoke()
+		}
+	}()
+	if binding == nil || binding.identity != binding || binding.source == nil || binding.context == nil ||
+		binding.source != binding.originalSource || binding.context != binding.originalContext ||
+		binding.seal != binding.digest() || binding.context.Err() != nil ||
+		options.Goarch != binding.arch || options.TargetTriple != binding.triple || options.X86TLSMoves != binding ||
+		options.NumericalReads != nil || options.ARM64ByteCarrierSource != nil || len(options.X86TailGroups) != 0 {
+		return x86TLSMoveContext("binding identity, source, context or target differs")
+	}
+	actual, err := x86CallerSourceFingerprint(file)
+	if err != nil || file == nil || actual != binding.file {
+		return x86TLSMoveContext("complete original file changed during consumption")
+	}
+	return binding.source.Verify(binding.context)
+}
+
+func freezeTLSMoveInputs(file *File, options Options) (*File, Options, error) {
+	binding := options.X86TLSMoves
+	if binding == nil {
+		return file, options, nil
+	}
+	if err := binding.verify(file, options); err != nil {
+		return nil, Options{}, err
+	}
+	// Reparse the independently guarded source, so caller-owned slices and
+	// decoder certificates cannot change or supplement the native NOP fact.
+	normalized, err := Parse(ArchAMD64, binding.source.expanded)
+	if err != nil {
+		return nil, Options{}, err
+	}
+	changed := make(map[int]bool)
+	for _, site := range binding.source.noops {
+		original := normalized.Funcs[site.Function].Instrs[site.Instruction]
+		form, known, err := x86TLSMoveProperties(original, binding.arch)
+		if err != nil || !known || form.memory >= 0 {
+			return nil, Options{}, x86TLSMoveContext("observed NOP source role changed")
+		}
+		normalized.Funcs[site.Function].Instrs[site.Instruction] = Instr{Op: "NOP", Raw: original.Raw}
+		changed[site.Function] = true
+	}
+	options.Sigs, err = numericalCloneSignatures(options.Sigs)
+	if err != nil {
+		return nil, Options{}, err
+	}
+	resolve := options.ResolveSym
+	if resolve == nil {
+		resolve = func(symbol string) string { return symbol }
+	}
+	for index := range changed {
+		function := normalized.Funcs[index]
+		name := resolve(function.Sym)
+		if err := binding.verify(file, options); err != nil {
+			return nil, Options{}, err
+		}
+		signature, present := options.Sigs[name]
+		if !present {
+			return nil, Options{}, x86TLSMoveContext("NOP consumer lacks its independent signature")
+		}
+		// The observed NOP preserves unknown as well as initialized GP state.
+		// Consume the existing complete lowering result/effect proof before
+		// generic register allocas can choose implementation representatives.
+		consumer := &amd64Ctx{sig: signature, fpScalarSource: function, goarch: binding.arch}
+		if err := consumer.checkLoweredScalarFPResultInitialization(); err != nil {
+			return nil, Options{}, err
+		}
+	}
+	return normalized, options, nil
+}
+
+func finishTLSMoves(file *File, options Options) error {
+	if options.X86TLSMoves == nil {
+		return nil
+	}
+	return options.X86TLSMoves.verify(file, options)
+}
+
+func tlsGoAssemblyInput(binding *GoX86TLSMoveBinding, pkg GoPackage, source []byte, options GoModuleOptions) (_ []byte, result error) {
+	defer func() {
+		if result != nil && binding != nil {
+			binding.originalSource.revoke()
+		}
+	}()
+	if binding == nil || binding.identity != binding || binding.source == nil {
+		return nil, x86TLSMoveContext("missing Go source binding")
+	}
+	owner := binding.source
+	goos, arch, _ := strings.Cut(owner.request.Target, "/")
+	if pkg.Path != owner.request.PackagePath || pkg.Types == nil || pkg.Types.Path() != pkg.Path ||
+		options.GOOS != goos || options.GOARCH != arch || options.TargetTriple != binding.triple ||
+		options.NumericalReads != nil || options.ARM64ByteCarrierSource != nil || options.KeepFunc != nil {
+		return nil, x86TLSMoveContext("Go source/package/profile or complete-file role differs")
+	}
+	if !bytes.Equal(source, owner.original) && !bytes.Equal(source, []byte(owner.expanded)) {
+		return nil, x86TLSMoveContext("Go wrapper needs the exact captured original or expanded source")
+	}
+	if err := owner.Verify(binding.context); err != nil {
+		return nil, err
+	}
+	return []byte(owner.expanded), nil
+}
+
+func finishTLSGoInput(binding *GoX86TLSMoveBinding, pkg GoPackage, source []byte, originalDigest [32]byte, options GoModuleOptions) error {
+	_, err := tlsGoAssemblyInput(binding, pkg, source, options)
+	if sha256.Sum256(source) != originalDigest {
+		err = errors.Join(err, x86TLSMoveContext("original Go wrapper source changed during consumption"))
+	}
+	return err
+}
diff --git a/go_x86_tls_move_native.go b/go_x86_tls_move_native.go
new file mode 100644
index 000000000..44bcc8480
--- /dev/null
+++ b/go_x86_tls_move_native.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"bufio"
+	"bytes"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// File/line auxiliaries legitimately differ between the original source and
+// the owned expanded source. Preserve both whole objects, while independently
+// joining every physical TEXT identity, byte and ordered relocation.
+func x86TLSOriginalExpandedObjects(original, expanded []gostaticstorage.TextRecord) error {
+	if len(original) == 0 || len(original) != len(expanded) {
+		return x86TLSMoveContext("complete original/expanded TEXT inventories differ")
+	}
+	for index, first := range original {
+		second := expanded[index]
+		if first.Name != second.Name || first.ABI != second.ABI || first.Kind != second.Kind ||
+			first.Flags != second.Flags || first.Flags2 != second.Flags2 || first.Size != second.Size ||
+			!bytes.Equal(first.Code, second.Code) || !reflect.DeepEqual(first.Relocations, second.Relocations) {
+			return x86TLSMoveContext("original expansion changed native TEXT bytes, identity or relocations")
+		}
+	}
+	return nil
+}
+
+type x86TLSListingRow struct {
+	pc        int64
+	file      string
+	line      int
+	operation string
+}
+
+func x86TLSListingTextHeaders(listing []byte) []string {
+	var result []string
+	for _, line := range strings.Split(string(listing), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[1] == "STEXT" {
+			result = append(result, strings.Join(fields, " "))
+		}
+	}
+	return result
+}
+
+func x86TLSObservedNoops(expanded string, file *File, texts []gostaticstorage.TextRecord, listing []byte,
+	packagePath, expandedPath, arch string,
+) ([]x86TLSNoopSite, error) {
+	if len(file.Funcs) != len(texts) {
+		return nil, x86TLSMoveContext("source/object TEXT inventories differ")
+	}
+	rows := make(map[string][]x86TLSListingRow)
+	var symbol string
+	scanner := bufio.NewScanner(bytes.NewReader(listing))
+	scanner.Buffer(nil, 4<<20)
+	for scanner.Scan() {
+		line := scanner.Text()
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && fields[1] == "STEXT" {
+			symbol = fields[0]
+			if _, duplicate := rows[symbol]; duplicate {
+				return nil, x86TLSMoveContext("duplicate native listing TEXT")
+			}
+			rows[symbol] = nil
+			continue
+		}
+		if row := goAMD64FrameRow.FindStringSubmatch(line); row != nil {
+			pc, err := strconv.ParseInt(row[1], 16, 64)
+			separator := strings.LastIndexByte(row[2], ':')
+			if err != nil || pc < 0 || symbol == "" || separator < 0 {
+				return nil, x86TLSMoveContext("unbound native listing source position")
+			}
+			sourceLine, err := strconv.Atoi(row[2][separator+1:])
+			if err != nil || sourceLine <= 0 {
+				return nil, x86TLSMoveContext("invalid native listing source line")
+			}
+			rows[symbol] = append(rows[symbol], x86TLSListingRow{pc, row[2][:separator], sourceLine, strings.TrimSpace(row[3])})
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+	if len(rows) != len(texts) {
+		return nil, x86TLSMoveContext("complete listing/object TEXT inventories differ")
+	}
+	lines := strings.Split(expanded, "\n")
+	lineCursor := 0
+	var sites []x86TLSNoopSite
+	for functionIndex, function := range file.Funcs {
+		name := numericalNativeName(function.Sym, packagePath)
+		text := texts[functionIndex]
+		if name != text.Name || text.ABI != 0 {
+			return nil, x86TLSMoveContext("source/object TEXT symbol or ABI differs")
+		}
+		observed, present := rows[name]
+		if !present {
+			return nil, x86TLSMoveContext("listing lacks exact source TEXT")
+		}
+		for index, row := range observed {
+			physical, valid := originalGoObjectSourcePath(row.file, "")
+			if !valid || physical != expandedPath || row.line > len(lines) || row.pc > text.Size ||
+				index != 0 && row.pc < observed[index-1].pc {
+				return nil, x86TLSMoveContext("native listing PC/file extent differs")
+			}
+		}
+		for instructionIndex, instruction := range function.Instrs {
+			// DATA/GLOBL declarations are not function instructions. The complete
+			// object equality still checks their effect on every native body.
+			for lineCursor < len(lines) && strings.TrimSpace(lines[lineCursor]) != instruction.Raw {
+				lineCursor++
+			}
+			if lineCursor >= len(lines) {
+				return nil, x86TLSMoveContext("parsed instruction lacks its exact expanded statement")
+			}
+			line := lineCursor + 1
+			lineCursor++
+			form, known, err := x86TLSMoveProperties(instruction, arch)
+			if err != nil {
+				return nil, err
+			}
+			if !known || form.memory >= 0 {
+				continue
+			}
+			var matching []int
+			for index, row := range observed {
+				if row.line == line {
+					matching = append(matching, index)
+				}
+			}
+			// Initial-exec and runtime-indirection rows remain observed source,
+			// but never become a NOP certificate. No OS-name decision is used.
+			if len(matching) != 1 || observed[matching[0]].operation != "NOP" {
+				continue
+			}
+			index := matching[0]
+			end := text.Size
+			if index+1 < len(observed) {
+				end = observed[index+1].pc
+			}
+			if observed[index].pc != end {
+				return nil, x86TLSMoveContext("source NOP has an unexpected native byte extent")
+			}
+			for _, relocation := range text.Relocations {
+				if relocation.Size != 0 && relocation.Offset < end && relocation.Offset+relocation.Size > observed[index].pc {
+					return nil, x86TLSMoveContext("source NOP intersects a native relocation")
+				}
+			}
+			sites = append(sites, x86TLSNoopSite{functionIndex, instructionIndex, line, observed[index].pc})
+		}
+	}
+	return sites, nil
+}
diff --git a/go_x86_tls_move_runtime_linux_amd64_go127_test.go b/go_x86_tls_move_runtime_linux_amd64_go127_test.go
new file mode 100644
index 000000000..c038027b5
--- /dev/null
+++ b/go_x86_tls_move_runtime_linux_amd64_go127_test.go
@@ -0,0 +1,87 @@
+//go:build go1.27 && linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is the required native Linux AMD64 owner. Other hosts retain portable
+// source/object coverage and this explicit cross-runtime counterpart. Missing
+// tools on the selected native owner fail rather than skipping execution.
+func TestCrossLinuxRuntimeMatrixX86TLSNoopPreservesWideGP(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 runtime tools required")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	pkg, file, options, original, request := x86TLSMoveSourceFixture(t, "linux/amd64", false,
+		"func Value(a uint64) uint64", "MOVQ a+0(FP),CX\nMOVL TLS,CX\nMOVQ TLS,CX\nMOVD TLS,CX\nMOVDQ2Q TLS,CX\nMOVQ CX,ret+8(FP)\nRET")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	if len(observed.noops) != 4 || len(observed.texts[0]) != 1 || len(observed.texts[0][0].Relocations) != 0 {
+		t.Fatal("runtime oracle lacks its complete relocation-free original NOP body")
+	}
+	bound, err := observed.BindTLSMoves(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var encoded []string
+	for _, value := range observed.texts[0][0].Code {
+		encoded = append(encoded, fmt.Sprintf("0x%02x", value))
+	}
+	core, shim := "tls_original_body", "tls_original"
+	if strings.Contains(execution.triple, "apple") {
+		core, shim = "_"+core, "_"+shim
+	}
+	// The independent SysV shim allocates actual Go ABI0 input/result cells.
+	// The bytes inside core come directly from the original source object;
+	// they are not reconstructed from the normalized LLVM or a mnemonic list.
+	assembly := ".text\n.globl " + core + "\n" + core + ":\n.byte " + strings.Join(encoded, ",") + "\n" +
+		".globl " + shim + "\n" + shim + ":\nsubq $24,%rsp\nmovq %rdi,0(%rsp)\ncallq " + core +
+		"\nmovq 8(%rsp),%rax\naddq $24,%rsp\nretq\n"
+	main := fmt.Sprintf("__asm__(%q);\n", assembly) + `
+#include <stdint.h>
+#include <stdio.h>
+extern uint64_t Value(uint64_t);
+extern uint64_t tls_original(uint64_t);
+int main(void) {
+    const uint64_t patterns[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0xffffffff00000000),UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210)};
+    for(unsigned i=0;i<sizeof(patterns)/sizeof(*patterns);++i) {
+        uint64_t native=tls_original(patterns[i]),translated=Value(patterns[i]);
+        if(native!=patterns[i] || translated!=native) {
+            fprintf(stderr,"TLS NOP case=%u native=%llx LLVM=%llx expected=%llx\n",
+                i,(unsigned long long)native,(unsigned long long)translated,(unsigned long long)patterns[i]);
+            return 1;
+        }
+    }
+    puts("7 original Go/LLVM TLS NOP wide-register patterns");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86TLSMoveBoundAPI(t, pkg, file, original, bound, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, optimization := range []string{"-O0", "-O2"} {
+			executable := execution.compileLLVM(t, "tls-nop-"+api, ir, main, optimization)
+			output := x86FloatCompareCaptureCommand(t, exec.Command(executable))
+			if string(output) != "7 original Go/LLVM TLS NOP wide-register patterns\n" {
+				t.Fatalf("incomplete native/LLVM runtime receipt: %s", output)
+			}
+		}
+	}
+	t.Logf("actual original Go ABI0 bytes and LLVM NOP consumer; execution host=%s/%s", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/go_x86_tls_move_source.go b/go_x86_tls_move_source.go
new file mode 100644
index 000000000..15add82b4
--- /dev/null
+++ b/go_x86_tls_move_source.go
@@ -0,0 +1,391 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmmacros"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// GoX86TLSMoveCaptureRequest selects an actual standalone assembler invocation.
+// PackagePath is its explicit -p identity, not a claim of package selection,
+// declaration, caller or runtime ownership. Shared is the actual -shared flag.
+type GoX86TLSMoveCaptureRequest struct {
+	GoBinary, Directory, PackagePath, AssemblyFile, Target string
+	Environment                                            []string
+	Shared                                                 bool
+}
+
+// GoX86TLSMoveSource observes source-encoder effects only. Its first consumer
+// accepts actual zero-width NOP rewrites; it does not bind native TLS addresses,
+// g, segment-register state, storage, entry registers or a callable ABI.
+// Reports and parsed files cannot recreate this live observation.
+type GoX86TLSMoveSource struct {
+	mu            sync.Mutex
+	identity      *GoX86TLSMoveSource
+	ready         bool
+	lease         context.Context
+	originalLease context.Context
+	request       GoX86TLSMoveCaptureRequest
+	guard         *GoAMD64FrameSource
+	originalGuard *GoAMD64FrameSource
+	original      []byte
+	expanded      string
+	file          *File
+	noops         []x86TLSNoopSite
+	objects       [2][]byte
+	listings      [2][]byte
+	texts         [2][]gostaticstorage.TextRecord
+	builtin       []byte
+	seal          [32]byte
+}
+
+type x86TLSNoopSite struct {
+	Function, Instruction, Line int
+	PC                          int64
+}
+
+func x86TLSMoveContext(format string, args ...any) error {
+	return fmt.Errorf("%w: actual Go TLS move source: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func CaptureGoX86TLSMoveSource(ctx context.Context, request GoX86TLSMoveCaptureRequest) (_ *GoX86TLSMoveSource, result error) {
+	_, arch, valid := strings.Cut(request.Target, "/")
+	if ctx == nil || !valid || arch != "386" && arch != "amd64" ||
+		!filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		filepath.Base(request.AssemblyFile) != request.AssemblyFile || !strings.HasSuffix(request.AssemblyFile, ".s") {
+		return nil, x86TLSMoveContext("needs explicit bounded x86 source/tool inputs")
+	}
+	if _, bounded := ctx.Deadline(); !bounded || ctx.Err() != nil {
+		return nil, errors.Join(x86TLSMoveContext("requires a bounded live capture context"), ctx.Err())
+	}
+	values := make(map[string]string)
+	for _, entry := range request.Environment {
+		key, value, valid := strings.Cut(entry, "=")
+		if !valid || key == "" {
+			return nil, x86TLSMoveContext("malformed assembler environment")
+		}
+		values[key] = value // Match exec's actual last-value semantics.
+	}
+	for key, value := range map[string]string{"GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOEXPERIMENT": ""} {
+		if actual, present := values[key]; !present || actual != value {
+			return nil, x86TLSMoveContext("unbound actual assembler environment: %s", key)
+		}
+	}
+	request.Environment = nil
+	for key, value := range values {
+		request.Environment = append(request.Environment, key+"="+value)
+	}
+	sort.Strings(request.Environment)
+	source := &GoX86TLSMoveSource{lease: ctx, originalLease: ctx, request: request}
+	source.identity = source
+	source.guard = newGoOriginalInputGuard(GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+		Directory: request.Directory, AssemblyFile: request.AssemblyFile, Target: request.Target, Environment: request.Environment})
+	source.originalGuard = source.guard
+	resolved, err := sourcepath.Resolve(request.Directory)
+	entries, directory, inventoryErr := gooriginalsrc.ReadDirectory(request.Directory, 4096)
+	if err != nil || resolved != request.Directory || inventoryErr != nil || len(entries) == 0 {
+		return nil, x86TLSMoveContext("original source directory identity/inventory differs")
+	}
+	source.guard.directoryInfo = directory
+	for _, entry := range entries {
+		source.guard.entries = append(source.guard.entries, entry.Name())
+	}
+	if err := source.guard.observe(ctx); err != nil {
+		return nil, err
+	}
+	if !gotoolchain.AuditedGo127(source.guard.env["GOVERSION"]) {
+		return nil, x86TLSMoveContext("object observation needs its exact audited Go 1.27 producer")
+	}
+	go386, err := source.guard.run(ctx, "env", "GO386")
+	if err != nil {
+		return nil, err
+	}
+	source.guard.env["GO386"] = strings.TrimSpace(string(go386))
+	if _, err := goasmmacros.Capture(source.guard.env["GOROOT"], source.guard.env["GOVERSION"], request.PackagePath, source.guard.read); err != nil {
+		return nil, x86TLSMoveContext("actual assembler macro registration: %v", err)
+	}
+	source.guard.assemblerDefines, err = GoAssemblerDefinesForEnvironment(source.guard.env["GOOS"], arch, source.guard.env)
+	if err != nil {
+		return nil, err
+	}
+	for role, hash := range gostaticstorage.DecoderObjectFormatSourceHashes() {
+		data, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role)))
+		if err != nil || fmt.Sprintf("%x", sha256.Sum256(data)) != hash {
+			return nil, x86TLSMoveContext("actual object-format source differs: %s", role)
+		}
+		if role == "src/cmd/internal/goobj/builtinlist.go" {
+			source.builtin = data
+		}
+	}
+	source.original, err = source.guard.read(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		return nil, err
+	}
+	expanded, err := source.guard.preprocess(request.AssemblyFile, source.original)
+	if err != nil {
+		return nil, err
+	}
+	source.expanded, err = x86TLSCanonicalSource(expanded)
+	if err != nil {
+		return nil, err
+	}
+	source.file, err = Parse(ArchAMD64, source.expanded)
+	if err != nil || len(source.file.Funcs) == 0 || len(source.file.UnlinkedPrelude) != 0 {
+		return nil, x86TLSMoveContext("complete original parsed source differs: %v", err)
+	}
+	for _, function := range source.file.Funcs {
+		for _, instruction := range function.Instrs {
+			if _, _, err := x86TLSMoveProperties(instruction, arch); err != nil {
+				return nil, err
+			}
+		}
+	}
+	temporary := values["TMPDIR"]
+	canonicalTemporary, err := sourcepath.Resolve(temporary)
+	if !filepath.IsAbs(temporary) || err != nil || canonicalTemporary != temporary {
+		return nil, x86TLSMoveContext("requires an explicit canonical assembler artifact root")
+	}
+	source.guard.owned, err = os.MkdirTemp(temporary, "plan9asm-tls-move-")
+	if err != nil {
+		return nil, err
+	}
+	source.guard.ownedInfo, err = sourcepath.Lstat(source.guard.owned)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	if err := os.WriteFile(filepath.Join(source.guard.owned, "expanded.s"), []byte(source.expanded), 0600); err != nil {
+		return nil, err
+	}
+	if _, err := source.guard.read(filepath.Join(source.guard.owned, "expanded.s")); err != nil {
+		return nil, err
+	}
+	for index := range source.objects {
+		source.objects[index], source.listings[index], source.texts[index], err = source.assemble(ctx, index)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if err := x86TLSOriginalExpandedObjects(source.texts[0], source.texts[1]); err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(x86TLSListingTextHeaders(source.listings[0]), x86TLSListingTextHeaders(source.listings[1])) {
+		return nil, x86TLSMoveContext("complete original/expanded TEXT frame and argument metadata differs")
+	}
+	source.noops, err = x86TLSObservedNoops(source.expanded, source.file, source.texts[1], source.listings[1], request.PackagePath,
+		filepath.Join(source.guard.owned, "expanded.s"), arch)
+	if err != nil {
+		return nil, err
+	}
+	if err := source.verifyInputs(); err != nil {
+		return nil, err
+	}
+	source.seal, err = source.digest()
+	if err != nil {
+		return nil, err
+	}
+	source.ready = true
+	return source, nil
+}
+
+// Canonicalize statement boundaries, without altering tokens. The actual
+// assembler independently checks this complete expansion against the original
+// object; each observed candidate then owns one unambiguous physical line.
+func x86TLSCanonicalSource(expanded string) (string, error) {
+	var result strings.Builder
+	for _, line := range strings.Split(expanded, "\n") {
+		for _, statement := range splitSemicolons(strings.TrimSpace(line)) {
+			for {
+				label, found := statementLabelPrefix(ArchAMD64, statement)
+				if !found {
+					break
+				}
+				result.WriteString(label.raw + "\n")
+				statement = label.rest
+			}
+			if statement != "" {
+				result.WriteString(statement + "\n")
+			}
+		}
+	}
+	if result.Len() == 0 || result.Len() > 16<<20 {
+		return "", x86TLSMoveContext("empty or oversized expanded source")
+	}
+	return result.String(), nil
+}
+
+func (source *GoX86TLSMoveSource) assemble(ctx context.Context, index int) ([]byte, []byte, []gostaticstorage.TextRecord, error) {
+	input := filepath.Join(source.request.Directory, source.request.AssemblyFile)
+	if index == 1 {
+		input = filepath.Join(source.guard.owned, "expanded.s")
+	}
+	output := filepath.Join(source.guard.owned, fmt.Sprintf("original-%d.o", index))
+	args := []string{"tool", "asm", "-S", "-p", source.request.PackagePath, "-I", source.request.Directory,
+		"-I", filepath.Join(source.guard.env["GOROOT"], "pkg", "include"), "-o", output}
+	if source.request.Shared {
+		args = append(args, "-shared")
+	}
+	for _, define := range source.guard.assemblerDefines {
+		args = append(args, "-D", define)
+	}
+	args = append(args, input)
+	listing, err := source.guard.run(ctx, args...)
+	if err != nil {
+		return nil, nil, nil, errors.Join(x86TLSMoveContext("actual assembler command failed"), err)
+	}
+	object, err := source.guard.read(output)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	if err := gostaticstorage.ValidateObjectVersion(object, source.request.Target, source.guard.env["GOVERSION"]); err != nil {
+		return nil, nil, nil, err
+	}
+	texts, err := gostaticstorage.ObserveX86TLSAssemblyText(object, source.builtin, source.request.Target, source.request.Shared)
+	return object, listing, texts, err
+}
+
+func (source *GoX86TLSMoveSource) digest() ([32]byte, error) {
+	encoded, err := json.Marshal(struct {
+		Request  GoX86TLSMoveCaptureRequest
+		Original []byte
+		Expanded string
+		File     *File
+		Noops    []x86TLSNoopSite
+		Objects  [2][]byte
+		Listings [2][]byte
+		Texts    [2][]gostaticstorage.TextRecord
+		Builtin  []byte
+		Inputs   map[string][32]byte
+		Env      map[string]string
+		Defines  []string
+		Owned    string
+	}{source.request, source.original, source.expanded, source.file, source.noops, source.objects, source.listings,
+		source.texts, source.builtin, source.guard.inputs, source.guard.env, source.guard.assemblerDefines, source.guard.owned})
+	return sha256.Sum256(encoded), err
+}
+
+func (source *GoX86TLSMoveSource) verifyInputs() error {
+	if err := source.guard.verifyOwned(); err != nil {
+		return err
+	}
+	entries, directory, err := gooriginalsrc.ReadDirectory(source.request.Directory, 4096)
+	if err != nil || !os.SameFile(directory, source.guard.directoryInfo) {
+		return x86TLSMoveContext("original directory identity differs")
+	}
+	var names []string
+	for _, entry := range entries {
+		names = append(names, entry.Name())
+	}
+	if !reflect.DeepEqual(names, source.guard.entries) {
+		return x86TLSMoveContext("original directory inventory differs")
+	}
+	for name, expected := range source.guard.inputs {
+		actual, err := goAMD64FrameRead(name)
+		if err != nil || sha256.Sum256(actual) != expected {
+			return x86TLSMoveContext("source/tool/object input changed: %s", filepath.Base(name))
+		}
+	}
+	return nil
+}
+
+func (source *GoX86TLSMoveSource) Verify(ctx context.Context) (result error) {
+	if source == nil || source.identity != source {
+		return x86TLSMoveContext("copied or missing source observation")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	defer func() {
+		if result != nil {
+			source.ready = false
+		}
+	}()
+	if ctx == nil || source.lease == nil || source.lease != source.originalLease || source.guard == nil ||
+		source.guard != source.originalGuard || !source.ready || ctx.Err() != nil || source.lease.Err() != nil {
+		return x86TLSMoveContext("capture/binding context or source is closed")
+	}
+	digest, err := source.digest()
+	if err != nil || digest != source.seal {
+		return x86TLSMoveContext("complete source observation seal differs")
+	}
+	if err := source.verifyInputs(); err != nil {
+		return err
+	}
+	before := source.guard.env
+	if err := source.guard.observe(ctx); err != nil {
+		return err
+	}
+	go386, err := source.guard.run(ctx, "env", "GO386")
+	if err != nil {
+		return err
+	}
+	source.guard.env["GO386"] = strings.TrimSpace(string(go386))
+	if !reflect.DeepEqual(source.guard.env, before) {
+		return x86TLSMoveContext("actual driver/target/profile/tool routes differ")
+	}
+	for index := range source.objects {
+		object, listing, texts, err := source.assemble(ctx, index)
+		if err != nil || !bytes.Equal(object, source.objects[index]) || !bytes.Equal(listing, source.listings[index]) ||
+			!reflect.DeepEqual(texts, source.texts[index]) {
+			return errors.Join(x86TLSMoveContext("complete actual source/object/listing changed"), err)
+		}
+	}
+	return source.verifyInputs()
+}
+
+// Close revokes the source before cleaning only its identity-checked artifacts.
+func (source *GoX86TLSMoveSource) Close() error {
+	if source == nil {
+		return nil
+	}
+	if source.identity != source {
+		return x86TLSMoveContext("copied or missing source cannot dispose original artifacts")
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	source.ready = false
+	if source.guard == nil || source.guard != source.originalGuard {
+		return x86TLSMoveContext("original artifact owner changed")
+	}
+	return source.guard.Close()
+}
+
+func (source *GoX86TLSMoveSource) revoke() {
+	if source != nil && source.identity == source {
+		source.mu.Lock()
+		source.ready = false
+		source.mu.Unlock()
+	}
+}
+
+// AssemblySource returns the independently object-checked complete expansion.
+// It is ordinary source data; BindTLSMoves still needs this live owner.
+func (source *GoX86TLSMoveSource) AssemblySource(ctx context.Context) (string, error) {
+	if err := source.Verify(ctx); err != nil {
+		return "", err
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.ready {
+		return "", x86TLSMoveContext("source closed before expanded-source readback")
+	}
+	return source.expanded, nil
+}
diff --git a/go_x86_tls_move_source_go127_test.go b/go_x86_tls_move_source_go127_test.go
new file mode 100644
index 000000000..4c5e58dac
--- /dev/null
+++ b/go_x86_tls_move_source_go127_test.go
@@ -0,0 +1,395 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func x86TLSMoveSourceFixture(t *testing.T, target string, shared bool, declaration, body string) (GoPackage, *File, Options, []byte, GoX86TLSMoveCaptureRequest) {
+	t.Helper()
+	_, frame := goAMD64FrameSourceFixture(t)
+	goos, arch, _ := strings.Cut(target, "/")
+	pkg, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+	if err := os.WriteFile(filepath.Join(frame.Directory, frame.AssemblyFile), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	values := make(map[string]string)
+	for _, entry := range frame.Environment {
+		key, value, _ := strings.Cut(entry, "=")
+		values[key] = value
+	}
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2",
+		"GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOEXPERIMENT": ""} {
+		values[key] = value
+	}
+	temporary, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	values["TMPDIR"], values["GOTMPDIR"] = temporary, temporary
+	var environment []string
+	for key, value := range values {
+		environment = append(environment, key+"="+value)
+	}
+	options := Options{Goarch: arch, TargetTriple: x86TLSExpectedTriple(target), Sigs: map[string]FuncSig{"Value": sig},
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+	return pkg, file, options, []byte(source), GoX86TLSMoveCaptureRequest{GoBinary: frame.GoBinary, Directory: frame.Directory,
+		PackagePath: pkg.Path, AssemblyFile: frame.AssemblyFile, Target: target, Shared: shared, Environment: environment}
+}
+
+func x86TLSMoveBoundAPI(t *testing.T, pkg GoPackage, file *File, source []byte, options Options, api string) (string, error) {
+	t.Helper()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+			return module.String(), err
+		}
+		return "", err
+	}
+	goos, _, _ := strings.Cut(options.X86TLSMoves.source.request.Target, "/")
+	module, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{GOOS: goos, GOARCH: options.Goarch,
+		TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym, X86TLSMoves: options.X86TLSMoves})
+	if module != nil && !module.Module.IsNil() {
+		defer module.Module.Dispose()
+		return module.Module.String(), err
+	}
+	return "", err
+}
+
+func TestGoX86TLSMoveActualNOPBindingThreeAPIsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "freebsd/386"} {
+		t.Run(target, func(t *testing.T) {
+			pkg, file, options, original, request := x86TLSMoveSourceFixture(t, target, false, "func Value(a uint32) uint32",
+				"MOVL a+0(FP),CX\nMOVL TLS,CX\nMOVQ TLS,CX\nMOVD TLS,CX\nMOVDQ2Q TLS,CX\nMOVL CX,ret+8(FP)\nRET")
+			if options.Goarch == "386" {
+				original = bytes.ReplaceAll(original, []byte("ret+8"), []byte("ret+4"))
+				var err error
+				file, err = Parse(ArchAMD64, string(original))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), original, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound public source acquired TLS permission: %v", err)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if len(observed.noops) != 4 {
+				t.Fatalf("native direct-TLS rewrite inventory: %+v", observed.noops)
+			}
+			bound, err := observed.BindTLSMoves(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			before, _ := x86CallerSourceFingerprint(file)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86TLSMoveBoundAPI(t, pkg, file, original, bound, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				if strings.Contains(ir, "reg_TLS") || strings.Contains(ir, "runtime.tls_g") {
+					t.Fatalf("NOP invented native TLS state: %s", ir)
+				}
+				x86ResultInitializationObject(t, llc, bound.TargetTriple, ir, api)
+			}
+			after, _ := x86CallerSourceFingerprint(file)
+			if before != after {
+				t.Fatal("consumer mutated the original source")
+			}
+		})
+	}
+}
+
+func TestGoX86TLSMoveActualProfilesRemainDistinct(t *testing.T) {
+	for _, profile := range []struct {
+		target string
+		shared bool
+	}{
+		{"linux/amd64", false}, {"linux/amd64", true}, {"darwin/amd64", true},
+		{"freebsd/amd64", false}, {"freebsd/amd64", true}, {"freebsd/386", true},
+		{"android/amd64", false}, {"android/386", false}, {"solaris/amd64", false},
+		{"plan9/amd64", false}, {"plan9/386", false},
+		{"windows/amd64", false}, {"linux/386", false}, {"linux/386", true}, {"windows/386", false},
+	} {
+		t.Run(fmt.Sprintf("%s/shared=%v", profile.target, profile.shared), func(t *testing.T) {
+			_, file, options, _, request := x86TLSMoveSourceFixture(t, profile.target, profile.shared, "func Value() uint32",
+				"MOVL $1,AX\nMOVQ TLS,CX\nMOVL AX,ret+0(FP)\nRET")
+			if options.Goarch == "386" {
+				original, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+				if err != nil {
+					t.Fatal(err)
+				}
+				original = bytes.ReplaceAll(original, []byte("MOVQ TLS"), []byte("MOVL TLS"))
+				file, err = Parse(ArchAMD64, string(original))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), original, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			_, err = observed.BindTLSMoves(ctx, file, options)
+			wantNOP := (profile.target == "linux/amd64" || profile.target == "freebsd/amd64") && !profile.shared ||
+				profile.target == "darwin/amd64" || profile.target == "freebsd/386"
+			if (len(observed.noops) != 0) != wantNOP {
+				t.Fatalf("original Go TLS source effect confused profile: noops=%+v", observed.noops)
+			}
+			if wantNOP && err != nil || !wantNOP && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("actual native rewrite confused profile: %v; noops=%+v", err, observed.noops)
+			}
+			for _, text := range observed.texts[0] {
+				t.Logf("original %s shared=%v code=%x relocations=%+v", profile.target, profile.shared, text.Code, text.Relocations)
+			}
+		})
+	}
+}
+
+func TestGoX86TLSMoveNOPPreservesUnknownResultBytes(t *testing.T) {
+	for _, body := range []string{
+		"MOVQ TLS,AX\nMOVL AX,ret+0(FP)\nRET",
+		"MOVB $1,AL\nMOVL TLS,AX\nMOVL AX,ret+0(FP)\nRET",
+		"MOVQ TLS,AX\nCMPL AX,$0\nSETEQ AL\nMOVL AX,ret+0(FP)\nRET",
+	} {
+		t.Run(body, func(t *testing.T) {
+			pkg, file, options, original, request := x86TLSMoveSourceFixture(t, "linux/amd64", false, "func Value() uint32", body)
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			bound, err := observed.BindTLSMoves(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86TLSMoveBoundAPI(t, pkg, file, original, bound, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("%s NOP initialized unknown GP bytes: %v\n%s", api, err, ir)
+				}
+			}
+		})
+	}
+}
+
+func TestGoX86TLSMoveSourceMutationAndCloseRevoke(t *testing.T) {
+	for _, mutation := range []string{"source", "shared", "object", "close"} {
+		t.Run(mutation, func(t *testing.T) {
+			_, file, options, original, request := x86TLSMoveSourceFixture(t, "linux/amd64", false,
+				"func Value() uint32", "MOVL $7,AX\nMOVQ TLS,AX\nMOVL AX,ret+0(FP)\nRET")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			bound, err := observed.BindTLSMoves(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "source":
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), append(original, '\n'), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "shared":
+				observed.request.Shared = true
+			case "object":
+				observed.objects[0][len(observed.objects[0])-1] ^= 1
+			case "close":
+				if err := observed.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			ir, err := Translate(file, bound)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("revoked NOP observation escaped: %v\n%s", err, ir)
+			}
+			if mutation == "source" {
+				if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), original, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(observed.Verify(context.Background()), ErrProbeNeedsContext) {
+					t.Fatal("restored source revived revoked observation")
+				}
+			}
+		})
+	}
+}
+
+func TestGoX86TLSMoveNOPCompleteSourceRegisterRange(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "freebsd/386"} {
+		t.Run(target, func(t *testing.T) {
+			var body strings.Builder
+			for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q"} {
+				for _, register := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+					fmt.Fprintf(&body, "%s TLS,%s\n", op, register)
+				}
+			}
+			body.WriteString("RET")
+			pkg, file, options, original, request := x86TLSMoveSourceFixture(t, target, false, "func Value()", body.String())
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			if len(observed.noops) != 64 || !bytes.Equal(observed.texts[0][0].Code, []byte{0xc3}) {
+				t.Fatalf("complete native NOP register range changed: noops=%d native=%x", len(observed.noops), observed.texts[0][0].Code)
+			}
+			bound, err := observed.BindTLSMoves(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86TLSMoveBoundAPI(t, pkg, file, original, bound, api); err != nil {
+					t.Fatal(api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestGoX86TLSMoveOriginalCPPJoinAndRevocation(t *testing.T) {
+	pkg, _, options, original, request := x86TLSMoveSourceFixture(t, "linux/amd64", false, "func Value() uint32",
+		"MOVL $7,AX\nget_tls(AX)\nMOVL AX,ret+0(FP)\nRET")
+	original = append([]byte("#include \"tls.h\"\n"), original...)
+	for name, data := range map[string][]byte{
+		request.AssemblyFile: original,
+		"tls.h":              []byte("#define get_tls(r) MOVL TLS,r\n"),
+	} {
+		if err := os.WriteFile(filepath.Join(request.Directory, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	expanded, err := observed.AssemblySource(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bound, err := observed.BindTLSMoves(ctx, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		if _, err := x86TLSMoveBoundAPI(t, pkg, file, original, bound, api); err != nil {
+			t.Fatal(api, err)
+		}
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, "tls.h"), []byte("#define get_tls(r) MOVQ TLS,r\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if ir, err := Translate(file, bound); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatalf("changed original include revived an equivalent NOP rewrite: %v\n%s", err, ir)
+	}
+}
+
+func TestGoX86TLSMoveConsumerCallbacksAndCopiedTokensFailClosed(t *testing.T) {
+	for _, mutation := range []string{"close-callback", "source-callback", "file-callback", "target", "copy", "json"} {
+		t.Run(mutation, func(t *testing.T) {
+			_, file, options, original, request := x86TLSMoveSourceFixture(t, "linux/amd64", false,
+				"func Value() uint32", "MOVL $7,AX\nMOVQ TLS,AX\nMOVL AX,ret+0(FP)\nRET")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			observed, err := CaptureGoX86TLSMoveSource(ctx, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			bound, err := observed.BindTLSMoves(ctx, file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch mutation {
+			case "close-callback", "source-callback", "file-callback":
+				bound.ResolveSym = func(symbol string) string {
+					switch mutation {
+					case "close-callback":
+						if err := observed.Close(); err != nil {
+							t.Error(err)
+						}
+					case "source-callback":
+						if err := os.WriteFile(filepath.Join(request.Directory, request.AssemblyFile), append(original, '\n'), 0600); err != nil {
+							t.Error(err)
+						}
+					case "file-callback":
+						file.Funcs[0].Instrs[1].Args[0].Imm = 9
+					}
+					return strings.TrimPrefix(symbol, "·")
+				}
+			case "target":
+				bound.TargetTriple = "x86_64-pc-windows-msvc"
+			case "copy":
+				copy := *bound.X86TLSMoves
+				bound.X86TLSMoves = &copy
+			case "json":
+				encoded, err := json.Marshal(bound.X86TLSMoves)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var restored GoX86TLSMoveBinding
+				if err := json.Unmarshal(encoded, &restored); err != nil {
+					t.Fatal(err)
+				}
+				bound.X86TLSMoves = &restored
+			}
+			if ir, err := Translate(file, bound); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("changed consumer generation emitted IR: %v\n%s", err, ir)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_dependency_query_test.go b/gotoolprofile/amd64_dependency_query_test.go
new file mode 100644
index 000000000..9710f16b7
--- /dev/null
+++ b/gotoolprofile/amd64_dependency_query_test.go
@@ -0,0 +1,76 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// These ordinary first-party archives exercise the actual query/role consumer.
+// They deliberately do not claim signed legacy origins or a frame capability.
+func TestAMD64DownloadedDependencyQueryActualGo(t *testing.T) {
+	for _, variant := range []string{"fixed-local-no-go", "fixed-local-nested-no-go"} {
+		t.Run(variant, func(t *testing.T) {
+			request, module, version := amd64DownloadedObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			originalDir := request.Directory
+			root := originalDir
+			if variant == "fixed-local-nested-no-go" {
+				root = filepath.Dir(filepath.Dir(root))
+			}
+			before, err := os.ReadFile(filepath.Join(root, "go.mod"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			metadata := filepath.Join(originalObservationEnvironment(request.Environment, "GOMODCACHE"),
+				"cache", "download", module, "@v", version+".mod")
+			source := &amd64DownloadedModule{sourceModule: module, sourceVersion: version,
+				root: root, goMod: metadata, modulePath: module, goModOrigin: ProxyGoModProtocol}
+			sources := &amd64DownloadedSources{primary: source}
+			var packages map[string]amd64OriginalListPackage
+			for query := 0; query < 2; query++ {
+				data, diagnostics, err := sources.runList(ctx, request, RunBounded,
+					"list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", request.PackagePath)
+				if err != nil || len(diagnostics) != 0 {
+					t.Fatalf("actual independent dependency query: %v; %s", err, diagnostics)
+				}
+				decoder := json.NewDecoder(bytes.NewReader(data))
+				actual := make(map[string]amd64OriginalListPackage)
+				for {
+					var selected amd64OriginalListPackage
+					if err := decoder.Decode(&selected); err == io.EOF {
+						break
+					} else if err != nil {
+						t.Fatal(err)
+					}
+					actual[selected.ImportPath] = selected
+				}
+				if query > 0 && !reflect.DeepEqual(actual, packages) {
+					t.Fatal("new temporary query changed original selection or compiler-export identity")
+				}
+				packages = actual
+			}
+			selected := packages[request.PackagePath]
+			if selected.Dir != originalDir || selected.Export == "" || !source.matchesPrimary(selected.Module) ||
+				selected.Module.Main || selected.Module.Version != version || selected.Module.GoVersion != "" {
+				t.Fatal("query changed original source, exact version, dependency language or compiler export")
+			}
+			declarations, err := checkAMD64OriginalDeclarations(packages, request.PackagePath)
+			if err != nil || len(declarations) == 0 {
+				t.Fatal("actual dependency export lost its complete source typecheck", err)
+			}
+			after, err := os.ReadFile(filepath.Join(root, "go.mod"))
+			if err != nil || !bytes.Equal(before, after) {
+				t.Fatal("query rewrote original archive metadata", err)
+			}
+			if sources.verify() == nil {
+				t.Fatal("a successful query manufactured authenticated original-source authority")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_boundary_go127_test.go b/gotoolprofile/amd64_downloaded_boundary_go127_test.go
new file mode 100644
index 000000000..f449b7512
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_boundary_go127_test.go
@@ -0,0 +1,125 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAMD64DownloadedObservationCommandBoundaryForeignGuards(t *testing.T) {
+	for _, role := range []string{"control", "foreign member", "same-inode bytes", "file replacement", "directory replacement"} {
+		t.Run(role, func(t *testing.T) {
+			request, path, version := amd64DownloadedObservationFixture(t, "fixed-local")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			var marker, canary string
+			var originalBytes []byte
+			var originalInfo os.FileInfo
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				data, diagnostic, err := RunBounded(ctx, dir, env, binary, args...)
+				if err != nil || changed || len(args) < 2 || args[0] != "mod" || args[1] != "download" {
+					return data, diagnostic, err
+				}
+				changed, marker = true, dir
+				name := filepath.Join(marker, "go.mod")
+				original, err := os.ReadFile(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				originalBytes = original
+				originalInfo, err = os.Lstat(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				switch role {
+				case "foreign member":
+					canary = filepath.Join(marker, "foreign.txt")
+					err = os.WriteFile(canary, []byte("foreign owner"), 0600)
+				case "same-inode bytes":
+					canary = name
+					before, statErr := os.Lstat(name)
+					if statErr != nil {
+						t.Fatal(statErr)
+					}
+					err = os.WriteFile(name, append(original, '\n'), 0600)
+					after, statErr := os.Lstat(name)
+					if statErr != nil || !os.SameFile(before, after) {
+						t.Fatal("marker mutation did not preserve inode", statErr)
+					}
+				case "file replacement":
+					canary = name
+					if err := os.Rename(name, filepath.Join(t.TempDir(), "original-marker")); err != nil {
+						t.Fatal(err)
+					}
+					err = os.WriteFile(name, original, 0600)
+				case "directory replacement":
+					if err := os.Rename(marker, filepath.Join(t.TempDir(), "original-boundary")); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Mkdir(marker, 0700); err != nil {
+						t.Fatal(err)
+					}
+					canary = filepath.Join(marker, "foreign.txt")
+					err = os.WriteFile(canary, []byte("replacement owner"), 0600)
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				return data, diagnostic, nil
+			}
+			observed, err := CaptureAMD64DownloadedPackageObservation(ctx, AMD64DownloadedObservationRequest{
+				Original: request, SourceModule: path, SourceVersion: version,
+			}, run)
+			if observed != nil {
+				if closeErr := observed.Close(); closeErr != nil {
+					t.Error(closeErr)
+				}
+			}
+			if !changed {
+				t.Fatal("actual command boundary was not reached")
+			}
+			if role == "control" {
+				if err != nil || observed == nil {
+					t.Fatal("actual unmodified original download control failed", err)
+				}
+				if _, err := os.Stat(marker); !os.IsNotExist(err) {
+					t.Fatal("control retained its own boundary", err)
+				}
+				return
+			}
+			if err == nil || observed != nil {
+				t.Error("changed command boundary was accepted as an unchanged original observation", err)
+			}
+			if _, err := os.Stat(canary); err != nil {
+				t.Error("download marker cleanup removed foreign bytes/member/identity", err)
+			} else {
+				// Every canary is created by this first-party test. Remove only
+				// that exact known fixture file and its now-empty replacement.
+				if err := os.Remove(canary); err != nil {
+					t.Fatal(err)
+				}
+				if role == "foreign member" {
+					// Remove only the test's unchanged original metadata, not an
+					// arbitrary member left behind by the refused production cleanup.
+					name := filepath.Join(marker, "go.mod")
+					info, statErr := os.Lstat(name)
+					data, readErr := os.ReadFile(name)
+					if statErr != nil || readErr != nil || !os.SameFile(info, originalInfo) || !bytes.Equal(data, originalBytes) {
+						t.Fatal("original fixture metadata changed", statErr, readErr)
+					}
+					if err := os.Remove(name); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := os.Remove(marker); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_default_language_go127_test.go b/gotoolprofile/amd64_downloaded_default_language_go127_test.go
new file mode 100644
index 000000000..2ed96d40d
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_default_language_go127_test.go
@@ -0,0 +1,35 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import "testing"
+
+func TestAMD64DownloadedDefaultLanguageLLVM22Objects(t *testing.T) {
+	t.Setenv("GOCACHE", t.TempDir())
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "x86_64-unknown-linux-gnu"},
+		{"darwin", "x86_64-apple-macosx"},
+		{"windows", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			fixture := captureAMD64DownloadedLLVMVariantFixture(t, ctx, target.goos, target.triple, "fixed-local-no-go")
+			if fixture.observed.state.packages[fixture.pkg.Path].Module.GoVersion != "1.16" {
+				t.Fatal("object consumer lost the actual implicit main-module language")
+			}
+			llc := amd64DownloadedLLVM22Tool(t, ctx, fixture, "llc")
+			for _, api := range []string{"Translate", "Module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir := fixture.ir(t, api)
+					for _, level := range []string{"-O0", "-O2"} {
+						fixture.object(t, ctx, llc, ir, level)
+					}
+				})
+			}
+			if err := fixture.binding.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_default_language_test.go b/gotoolprofile/amd64_downloaded_default_language_test.go
new file mode 100644
index 000000000..0e4dc1bd4
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_default_language_test.go
@@ -0,0 +1,105 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// Stock Go reports the implicit 1.16 language for a main module, but preserves
+// the absent GoVersion field on a dependency. Neither role rewrites go.mod.
+func TestAMD64DownloadedDefaultLanguageActualGo(t *testing.T) {
+	t.Setenv("GOCACHE", t.TempDir())
+	for _, variant := range []string{"fixed-local-no-go", "foreign-no-go"} {
+		t.Run(variant, func(t *testing.T) {
+			request, module, version := amd64DownloadedObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			data, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+				"list", "-export", "-json", "-mod=readonly", ".")
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual default-language Go export failed: %v; %s", err, stderr)
+			}
+			var actual amd64OriginalListPackage
+			if err := json.Unmarshal(data, &actual); err != nil || actual.Module == nil ||
+				actual.Module.GoVersion != "1.16" || actual.Export == "" {
+				t.Fatalf("actual main-module language/export not observed: %v; %s", err, data)
+			}
+			observed, err := captureAMD64DownloadedForTest(ctx, request, module, version)
+			if err != nil {
+				t.Fatal("Go-accepted absent language directive lost original source observation", err)
+			}
+			defer func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			for _, wrong := range []string{"", "1.20", "1.27.1"} {
+				changed := *actual.Module
+				changed.GoVersion = wrong
+				if observed.downloaded.primary.matches(&changed, true) {
+					t.Fatalf("implicit main language accepted foreign metadata %q", wrong)
+				}
+			}
+			if variant == "foreign-no-go" {
+				foreign := observed.state.packages["example.invalid/foreign-observation"]
+				if foreign.Module == nil || foreign.Module.Main || foreign.Module.GoVersion != "" || foreign.Export == "" {
+					t.Fatal("missing-language dependency was changed to a main-module role")
+				}
+				changed := *foreign.Module
+				changed.GoVersion = "1.16"
+				if _, err := observed.downloaded.module(&changed); err == nil {
+					t.Fatal("dependency borrowed the main-module default metadata")
+				}
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(request.Directory, "go.mod")
+			before, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chmod(name, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(name, append(append([]byte(nil), before...), []byte("\ngo 1.20\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("a new language directive retained the old observation")
+			}
+			if err := os.WriteFile(name, before, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("restoring absent language revived a revoked observation")
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalDefaultLanguageActualGo(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "numeric")
+	if err := os.WriteFile(filepath.Join(request.Directory, "go.mod"), []byte("module "+request.PackagePath+"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal("owned original module lost actual implicit language", err)
+	}
+	defer func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	if observed.state.packages[request.PackagePath].Module.GoVersion != "1.16" {
+		t.Fatal("original observation did not retain actual Go main language")
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_fixed_local_handoff_go127_test.go b/gotoolprofile/amd64_downloaded_fixed_local_handoff_go127_test.go
new file mode 100644
index 000000000..f5e960caf
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_fixed_local_handoff_go127_test.go
@@ -0,0 +1,188 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// The owned-only BindFixedLocal route must not gain downloaded authority.
+// This test-only interface lets the missing independent route fail at runtime
+// without adding a production stub or manufacturing a frame capability.
+type amd64DownloadedFixedLocalIndependentBinder interface {
+	BindDownloadedFixedLocal(
+		context.Context,
+		plan9asm.GoPackage,
+		*plan9asm.File,
+		string,
+		plan9asm.Options,
+	) (plan9asm.Options, *AMD64OriginalFixedLocalBinding, error)
+}
+
+// This generated file-proxy module is a first-party mechanism fixture, not a
+// signed external module or an external runtime. The original cache directory
+// and Go's actual cached-CWD module role are never copied or relabeled.
+func TestAMD64DownloadedFixedLocalIndependentObjectHandoff(t *testing.T) {
+	request, sourceModule, sourceVersion := amd64DownloadedObservationFixture(t, "fixed-local")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := captureAMD64DownloadedForTest(ctx, request, sourceModule, sourceVersion)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	actual := observed.state.packages[request.PackagePath]
+	if actual.Dir != request.Directory || actual.Module == nil || !actual.Module.Main ||
+		actual.Module.Version != "" || observed.downloaded.primary.sourceModule != sourceModule ||
+		observed.downloaded.primary.sourceVersion != sourceVersion ||
+		!strings.HasSuffix(request.Directory, filepath.FromSlash(sourceModule+"@"+sourceVersion)) {
+		t.Fatal("exact source identity or Go's actual cached-CWD role was lost")
+	}
+	set := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range actual.GoFiles {
+		file, err := parser.ParseFile(set, filepath.Join(request.Directory, name), nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(request.PackagePath, set, syntax, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := plan9asm.DeriveGoFuncABI0Signature(request.PackagePath+".Value",
+		typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := plan9asm.GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax}
+	assembly, err := os.ReadFile(filepath.Join(request.Directory, "value_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded := strings.Replace(string(assembly), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+	expanded = strings.Replace(expanded, "#include \"local.h\"", "#define ADVANCE 32", 1)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+		Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig}}
+
+	t.Run("OriginalGoObject", func(t *testing.T) {
+		output, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+			"list", "-compiled", "-export", "-json", "-mod=readonly", ".")
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("actual original export failed: %v\n%s%s", err, output, stderr)
+		}
+		decoder := json.NewDecoder(bytes.NewReader(output))
+		var selected amd64OriginalListPackage
+		var extra any
+		if err := decoder.Decode(&selected); err != nil || decoder.Decode(&extra) != io.EOF ||
+			!reflect.DeepEqual(selected, actual) || selected.Export == "" {
+			t.Fatalf("actual original export/selection was not completely bound: %v", err)
+		}
+		t.Logf("ORIGINAL_GO_EXPORT_JSON\n%s", output)
+		object := filepath.Join(t.TempDir(), "original.o")
+		include := filepath.Join(observed.state.environment["GOROOT"], "pkg", "include")
+		listing, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+			"tool", "asm", "-S", "-p", pkg.Path, "-I", request.Directory, "-I", include,
+			"-o", object, "value_amd64.s")
+		if err != nil || len(stderr) != 0 || !bytes.Contains(listing, []byte(pkg.Path+".Value STEXT")) ||
+			!bytes.Contains(listing, []byte("PADDL")) {
+			t.Fatalf("actual original ASM failed: %v\n%s%s", err, listing, stderr)
+		}
+		data, err := os.ReadFile(object)
+		if err != nil || len(data) == 0 {
+			t.Fatalf("actual original object missing: %v", err)
+		}
+		t.Logf("ORIGINAL_GO_LISTING\n%s\nORIGINAL_GO_OBJECT_HEX %s", listing, hex.EncodeToString(data))
+		for _, name := range []string{"go.mod", "value.go", "value_amd64.s", "local.h"} {
+			data, err := os.ReadFile(filepath.Join(request.Directory, name))
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("ORIGINAL_SOURCE %s SHA256 %s\n%s", name, bytesSHA256(data), data)
+		}
+		prefix := filepath.Join(originalObservationEnvironment(request.Environment, "GOMODCACHE"),
+			"cache", "download", sourceModule, "@v", sourceVersion)
+		for _, suffix := range []string{".zip", ".mod", ".info"} {
+			data, err := os.ReadFile(prefix + suffix)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("FIRST_PARTY_PROXY_ASSET %s%s bytes=%d SHA256=%s HEX=%s",
+				sourceModule+"@"+sourceVersion, suffix, len(data), bytesSHA256(data), hex.EncodeToString(data))
+		}
+	})
+	if t.Failed() {
+		return // A failed Go control cannot certify the handoff counterexample.
+	}
+	t.Run("UnboundAPIs", func(t *testing.T) {
+		amd64OriginalFixedLocalAPIs(t, pkg, file, options, expanded, true)
+	})
+	t.Run("OwnedFactoryRejectsDownloadedCWD", func(t *testing.T) {
+		source, err := plan9asm.CaptureGoAMD64FrameSource(ctx, pkg, plan9asm.GoAMD64FrameCaptureRequest{
+			GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: "value_amd64.s",
+			Target: request.Target, Environment: request.Environment,
+		})
+		if source != nil {
+			if err := source.Close(); err != nil {
+				t.Error(err)
+			}
+		}
+		if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("actual downloaded CWD Main/empty-version was accepted by the owned public factory: %v", err)
+		}
+	})
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	t.Run("ActualObjectHandoff", func(t *testing.T) {
+		handoff, exists := any(observed).(amd64DownloadedFixedLocalIndependentBinder)
+		if !exists {
+			t.Fatal("real original Go numeric frame compiled, but the separate BindDownloadedFixedLocal object handoff route is unimplemented")
+		}
+		bound, binding, err := handoff.BindDownloadedFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+		if binding != nil {
+			defer func() {
+				if err := binding.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+		}
+		if errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatalf("real original Go numeric frame compiled, but independent downloaded object handoff is unimplemented: %v", err)
+		}
+		if err != nil || binding == nil {
+			t.Fatalf("actual object capture/binding failed: %v", err)
+		}
+		if err := binding.Verify(ctx); err != nil {
+			t.Fatal(err)
+		}
+		amd64OriginalFixedLocalAPIs(t, pkg, file, bound, expanded, false)
+	})
+}
diff --git a/gotoolprofile/amd64_downloaded_frame_imports_go127_test.go b/gotoolprofile/amd64_downloaded_frame_imports_go127_test.go
new file mode 100644
index 000000000..1793f932b
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_frame_imports_go127_test.go
@@ -0,0 +1,139 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Imported declarations must come from independently selected/exported Go
+// sources. The outer observer's JSON/types are not a frame capability.
+func TestAMD64DownloadedFrameOriginalImportGraphs(t *testing.T) {
+	for _, variant := range []string{"import", "nested-import", "foreign", "nested-foreign"} {
+		t.Run(variant, func(t *testing.T) {
+			request, module, version := amd64DownloadedObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := captureAMD64DownloadedForTest(ctx, request, module, version)
+			if err != nil {
+				t.Fatal("actual original Go source/export control failed", err)
+			}
+			defer func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			actual := observed.state.packages[request.PackagePath]
+			set := token.NewFileSet()
+			var syntax []*ast.File
+			for _, name := range actual.GoFiles {
+				file, err := parser.ParseFile(set, filepath.Join(request.Directory, name), nil, parser.ParseComments)
+				if err != nil {
+					t.Fatal(err)
+				}
+				syntax = append(syntax, file)
+			}
+			imports := importer.ForCompiler(set, "gc", func(path string) (io.ReadCloser, error) {
+				if mapped, exists := actual.ImportMap[path]; exists {
+					path = mapped
+				}
+				return os.Open(observed.state.packages[path].Export)
+			})
+			typed, err := (&types.Config{Importer: imports, Sizes: types.SizesFor("gc", "amd64")}).Check(
+				request.PackagePath, set, syntax, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := plan9asm.GoPackage{Path: request.PackagePath, Types: typed, Syntax: syntax}
+			source, err := plan9asm.CaptureGoAMD64DownloadedFrameSource(ctx, pkg, plan9asm.GoAMD64DownloadedFrameCaptureRequest{
+				Original: plan9asm.GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+					Directory: request.Directory, AssemblyFile: "value_amd64.s", Target: request.Target,
+					Environment: request.Environment},
+				SourceModule: module, SourceVersion: version,
+			})
+			if err != nil {
+				t.Fatal("actual original Go import graph lost independent frame capture", err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			data, err := os.ReadFile(filepath.Join(request.Directory, "value_amd64.s"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			expanded := strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path+".Value",
+				typed.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			bound, err := source.BindFixedLocal(ctx, pkg, file, plan9asm.Options{
+				Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: func(name string) string { return strings.Replace(name, "·", pkg.Path+".", 1) },
+				Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig},
+			})
+			if err != nil {
+				t.Fatal("independent imported source did not bind its actual frame", err)
+			}
+			fixture := amd64DownloadedLLVMFixture{request: request, pkg: pkg, file: file, options: bound, assembly: expanded}
+			llc := amd64DownloadedLLVM22Tool(t, ctx, fixture, "llc")
+			for _, api := range []string{"Translate", "Module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir := fixture.ir(t, api)
+					for _, level := range []string{"-O0", "-O2"} {
+						fixture.object(t, ctx, llc, ir, level)
+					}
+				})
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(variant, "foreign") {
+				return
+			}
+			// Change bytes in a different module after successful capture. A
+			// still-matching selected export or supplied type cannot hide them.
+			foreign := observed.state.packages["example.invalid/foreign-observation"]
+			name := filepath.Join(foreign.Dir, "shape.go")
+			before, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chmod(name, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(name, append(append([]byte(nil), before...), '\n'), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := source.Verify(ctx); err == nil {
+				t.Fatal("changed foreign original source retained its frame observation")
+			}
+			if err := os.WriteFile(name, before, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := source.Verify(ctx); err == nil {
+				t.Fatal("restored foreign bytes revived a revoked observation")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_frame_public_go127_test.go b/gotoolprofile/amd64_downloaded_frame_public_go127_test.go
new file mode 100644
index 000000000..6beee2411
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_frame_public_go127_test.go
@@ -0,0 +1,318 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func amd64DownloadedFramePublicFixture(t *testing.T, variant string) (AMD64OriginalObservationRequest, plan9asm.GoPackage, plan9asm.GoAMD64DownloadedFrameCaptureRequest) {
+	t.Helper()
+	request, path, version := amd64DownloadedObservationFixture(t, variant)
+	set := token.NewFileSet()
+	syntax, err := parser.ParseFile(set, filepath.Join(request.Directory, "value.go"), nil, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed := types.NewPackage(request.PackagePath, "observation")
+	if len(syntax.Imports) == 0 {
+		typed, err = (&types.Config{Sizes: types.SizesFor("gc", "amd64")}).Check(request.PackagePath, set, []*ast.File{syntax}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Import negatives deliberately supply no imported type authority. The
+	// public factory must reject their actual Go import graph before admission.
+	pkg := plan9asm.GoPackage{Path: request.PackagePath, Types: typed, Syntax: []*ast.File{syntax}}
+	capture := plan9asm.GoAMD64DownloadedFrameCaptureRequest{
+		Original: plan9asm.GoAMD64FrameCaptureRequest{GoBinary: request.GoBinary,
+			Directory: request.Directory, AssemblyFile: "value_amd64.s", Target: request.Target,
+			Environment: append([]string(nil), request.Environment...)},
+		SourceModule: path, SourceVersion: version,
+	}
+	return request, pkg, capture
+}
+
+func TestAMD64DownloadedFramePublicFactoryAndIdentity(t *testing.T) {
+	for _, operation := range []string{"Verify", "Close", "archive namespace alias", "nested package"} {
+		t.Run(operation, func(t *testing.T) {
+			variant := "fixed-local"
+			if operation == "archive namespace alias" {
+				variant = "alias"
+			} else if operation == "nested package" {
+				variant = "nested"
+			}
+			request, pkg, capture := amd64DownloadedFramePublicFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			source, err := plan9asm.CaptureGoAMD64DownloadedFrameSource(ctx, pkg, capture)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("actual exact original source/object did not verify", err)
+			}
+			if operation == "nested package" {
+				return
+			}
+			if operation == "archive namespace alias" {
+				if pkg.Path == capture.SourceModule {
+					t.Fatal("first-party ZIP namespace alias control was lost")
+				}
+				return
+			}
+			copied := new(plan9asm.GoAMD64FrameSource)
+			reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(source).Elem())
+			if operation == "Verify" {
+				err = copied.Verify(ctx)
+			} else {
+				err = copied.Close()
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("whole-value copy borrowed exact original frame role", err)
+			}
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal("copied operation revoked or deleted original artifacts", err)
+			}
+			if _, err := os.Stat(request.Directory); err != nil {
+				t.Fatal("factory changed its original cache directory", err)
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedFramePublicSourceRevocation(t *testing.T) {
+	for _, role := range []string{"source", "ZIP", "metadata", "close", "canceled"} {
+		t.Run(role, func(t *testing.T) {
+			request, pkg, capture := amd64DownloadedFramePublicFixture(t, "fixed-local")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			source, err := plan9asm.CaptureGoAMD64DownloadedFrameSource(ctx, pkg, capture)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			if err := source.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			switch role {
+			case "close":
+				if err := source.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "canceled":
+				canceled, stop := context.WithCancel(ctx)
+				stop()
+				err := source.Verify(canceled)
+				if !errors.Is(err, context.Canceled) || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatal("verification discarded cancellation cause", err)
+				}
+			default:
+				name := filepath.Join(request.Directory, "value.go")
+				if role != "source" {
+					cache := originalObservationEnvironment(request.Environment, "GOMODCACHE")
+					suffix := ".zip"
+					if role == "metadata" {
+						suffix = ".mod"
+					}
+					name = filepath.Join(cache, "cache", "download", capture.SourceModule, "@v", capture.SourceVersion+suffix)
+				}
+				before, err := os.ReadFile(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Chmod(name, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(name, append(append([]byte(nil), before...), '\n'), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(source.Verify(ctx), plan9asm.ErrProbeNeedsContext) {
+					t.Fatal("changed original bytes retained a frame capability")
+				}
+				if err := os.WriteFile(name, before, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if !errors.Is(source.Verify(ctx), plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("restoring bytes or context revived a revoked original source")
+			}
+			if _, err := os.Stat(request.Directory); err != nil {
+				t.Fatal("revocation removed original source cache", err)
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedFramePublicRejectedRoles(t *testing.T) {
+	for _, variant := range []string{"import", "foreign", "data"} {
+		t.Run(variant, func(t *testing.T) {
+			_, pkg, capture := amd64DownloadedFramePublicFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			source, err := plan9asm.CaptureGoAMD64DownloadedFrameSource(ctx, pkg, capture)
+			if variant == "data" {
+				if err != nil || source == nil {
+					t.Fatal("unrequested DATA sibling blocked the numerical member", err)
+				}
+				defer func() {
+					if err := source.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+				if err := source.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				data, err := os.ReadFile(filepath.Join(capture.Original.Directory, "value_amd64.s"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				assembly := strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+				file, err := plan9asm.Parse(plan9asm.ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path+".Value",
+					pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+					ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+					Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig}}
+				// This simple source already has valid ordinary logical AUTO
+				// storage; observing it adds no native fixed-frame permission.
+				amd64OriginalFixedLocalAPIs(t, pkg, file, options, assembly, false, false)
+				bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				amd64OriginalFixedLocalAPIs(t, pkg, file, bound, assembly, false)
+				dataOnly, err := plan9asm.Parse(plan9asm.ArchAMD64,
+					"DATA ·constant<>+0(SB)/8,$1\nGLOBL ·constant<>(SB),24,$8\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := source.BindFixedLocal(ctx, pkg, dataOnly, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatal("DATA sibling borrowed the selected member's frame", err)
+				}
+				amd64OriginalDataSiblingRevocation(t, ctx, capture.Original.Directory, func(ctx context.Context) error {
+					err := source.Verify(ctx)
+					if err != nil && !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+						t.Fatal("core frame source failed outside its Context contract", err)
+					}
+					return err
+				})
+				return
+			}
+			if source != nil {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || source != nil {
+				t.Fatal("broader source role acquired a downloaded frame", err)
+			}
+			if (variant == "import" || variant == "foreign") && !strings.Contains(err.Error(), "actual selected declarations differ") {
+				t.Fatal("unbound supplied types were not rejected by the independent source typecheck", err)
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedFramePublicInputIdentityAndCancellation(t *testing.T) {
+	_, pkg, capture := amd64DownloadedFramePublicFixture(t, "fixed-local")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	for _, role := range []string{"latest", "wrong original root", "canceled"} {
+		t.Run(role, func(t *testing.T) {
+			request, current := capture, ctx
+			switch role {
+			case "latest":
+				request.SourceVersion = "latest"
+			case "wrong original root":
+				owned, _, _, _, _ := amd64OriginalFixedLocalFixture(t)
+				request.Original.Directory = owned.Directory
+			case "canceled":
+				canceled, stop := context.WithCancel(ctx)
+				stop()
+				current = canceled
+			}
+			source, err := plan9asm.CaptureGoAMD64DownloadedFrameSource(current, pkg, request)
+			if source != nil {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || source != nil {
+				t.Fatal("wrong exact original input acquired a frame", err)
+			}
+			if role == "canceled" && !errors.Is(err, context.Canceled) {
+				t.Fatal("capture lost the actual cancellation cause", err)
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedFixedLocalRejectsOwnedAndResolverRevokes(t *testing.T) {
+	t.Run("owned-only observation", func(t *testing.T) {
+		request, pkg, file, options, _ := amd64OriginalFixedLocalFixture(t)
+		ctx, cancel := amd64OriginalObservationContext(t)
+		defer cancel()
+		observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer observed.Close()
+		_, lease, err := observed.BindDownloadedFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+		if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || lease != nil {
+			t.Fatal("owned-only query acquired an exact downloaded route", err)
+		}
+		if err := observed.Verify(ctx); err != nil {
+			t.Fatal("rejected route revoked unchanged original query", err)
+		}
+	})
+	t.Run("resolver closes original owner", func(t *testing.T) {
+		request, pkg, capture := amd64DownloadedFramePublicFixture(t, "fixed-local")
+		ctx, cancel := amd64OriginalObservationContext(t)
+		defer cancel()
+		observed, err := captureAMD64DownloadedForTest(ctx, request, capture.SourceModule, capture.SourceVersion)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer observed.Close()
+		_, _, file, options, _ := amd64OriginalFixedLocalFixture(t)
+		resolve := options.ResolveSym
+		options.ResolveSym = func(symbol string) string {
+			if err := observed.Close(); err != nil {
+				t.Error(err)
+			}
+			return resolve(symbol)
+		}
+		_, lease, err := observed.BindDownloadedFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+		if err == nil || lease != nil {
+			t.Fatal("resolver close did not revoke eventual independent handoff", err)
+		}
+	})
+}
diff --git a/gotoolprofile/amd64_downloaded_llvm22_go127_test.go b/gotoolprofile/amd64_downloaded_llvm22_go127_test.go
new file mode 100644
index 000000000..6592ea205
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_llvm22_go127_test.go
@@ -0,0 +1,211 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+)
+
+type amd64DownloadedLLVMFixture struct {
+	request               AMD64OriginalObservationRequest
+	sourceModule, version string
+	pkg                   plan9asm.GoPackage
+	file                  *plan9asm.File
+	options               plan9asm.Options
+	assembly              string
+	observed              *AMD64OriginalPackageObservation
+	binding               *AMD64OriginalFixedLocalBinding
+}
+
+func captureAMD64DownloadedLLVMFixture(t *testing.T, ctx context.Context, goos, triple string) amd64DownloadedLLVMFixture {
+	t.Helper()
+	return captureAMD64DownloadedLLVMVariantFixture(t, ctx, goos, triple, "fixed-local")
+}
+
+func captureAMD64DownloadedLLVMVariantFixture(t *testing.T, ctx context.Context, goos, triple, variant string) amd64DownloadedLLVMFixture {
+	t.Helper()
+	request, pkg, exact := amd64DownloadedFramePublicFixture(t, variant)
+	request.Target = goos + "/amd64"
+	request.Environment = replaceEnv(request.Environment, map[string]string{"GOOS": goos})
+	observed, err := captureAMD64DownloadedForTest(ctx, request, exact.SourceModule, exact.SourceVersion)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	sig, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path+".Value",
+		pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := os.ReadFile(filepath.Join(request.Directory, "value_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded := strings.Replace(string(actual), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+	expanded = strings.Replace(expanded, "#include \"local.h\"", "#define ADVANCE 32", 1)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: triple,
+		ResolveSym: func(name string) string { return strings.Replace(name, "·", pkg.Path+".", 1) },
+		Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig},
+	}
+	bound, binding, err := observed.BindDownloadedFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+	if err != nil || binding == nil {
+		t.Fatal("actual exact downloaded object binding failed", err)
+	}
+	t.Cleanup(func() {
+		if err := binding.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if err := binding.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	return amd64DownloadedLLVMFixture{request, exact.SourceModule, exact.SourceVersion,
+		pkg, file, bound, expanded, observed, binding}
+}
+
+func (fixture amd64DownloadedLLVMFixture) ir(t *testing.T, api string) string {
+	t.Helper()
+	var ir string
+	var err error
+	switch api {
+	case "Translate":
+		ir, err = plan9asm.Translate(fixture.file, fixture.options)
+	case "Module":
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, translateErr := plan9asm.TranslateModuleInContext(context, fixture.file, fixture.options)
+		err = translateErr
+		if !module.IsNil() {
+			defer module.Dispose()
+			ir = module.String()
+		}
+	case "GoModule":
+		module, translateErr := plan9asm.TranslateGoModule(fixture.pkg, []byte(fixture.assembly), plan9asm.GoModuleOptions{
+			GOOS: strings.Split(fixture.request.Target, "/")[0], GOARCH: "amd64",
+			TargetTriple: fixture.options.TargetTriple, ResolveSym: fixture.options.ResolveSym,
+			Sizes: types.SizesFor("gc", "amd64"),
+			ManualSig: func(name string) (plan9asm.FuncSig, bool) {
+				sig, found := fixture.options.Sigs[name]
+				return sig, found
+			},
+		})
+		err = translateErr
+		if module != nil && !module.Module.IsNil() {
+			defer module.Module.Dispose()
+			ir = module.Module.String()
+		}
+	default:
+		t.Fatal("unknown actual consumer API", api)
+	}
+	if err != nil || !strings.Contains(ir, "fixed_local_native") {
+		t.Fatal("downloaded LLVM consumer did not retain actual local proof", err)
+	}
+	return ir
+}
+
+func amd64DownloadedLLVM22Tool(t *testing.T, ctx context.Context, fixture amd64DownloadedLLVMFixture, name string) string {
+	t.Helper()
+	config := os.Getenv("LLVM_CONFIG")
+	if config == "" {
+		var err error
+		config, err = exec.LookPath("llvm-config-22")
+		if err != nil {
+			// Some supported installations use unversioned binary names.
+			// The selected configuration must still prove LLVM 22 below;
+			// an incompatible tool never falls through to another release.
+			config, err = exec.LookPath("llvm-config")
+		}
+		if err != nil {
+			t.Fatal("required LLVM22 llvm-config missing", err)
+		}
+	}
+	version, stderr, err := RunBounded(ctx, fixture.request.Directory, fixture.request.Environment, config, "--version")
+	if err != nil || len(stderr) != 0 || !strings.HasPrefix(strings.TrimSpace(string(version)), "22.") {
+		t.Fatalf("required LLVM22 configuration: %v; %s%s", err, version, stderr)
+	}
+	directory, stderr, err := RunBounded(ctx, fixture.request.Directory, fixture.request.Environment, config, "--bindir")
+	if err != nil || len(stderr) != 0 || !filepath.IsAbs(strings.TrimSpace(string(directory))) {
+		t.Fatalf("required LLVM22 tool directory: %v; %s%s", err, directory, stderr)
+	}
+	tool := filepath.Join(strings.TrimSpace(string(directory)), name)
+	version, stderr, err = RunBounded(ctx, fixture.request.Directory, fixture.request.Environment, tool, "--version")
+	if err != nil || len(stderr) != 0 || !strings.Contains(string(version), "version 22.") {
+		t.Fatalf("required LLVM22 %s: %v; %s%s", name, err, version, stderr)
+	}
+	return tool
+}
+
+func (fixture amd64DownloadedLLVMFixture) object(t *testing.T, ctx context.Context, llc, ir, level string) string {
+	t.Helper()
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "kernel.ll"), filepath.Join(directory, "kernel.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	output, stderr, err := RunBounded(ctx, directory, fixture.request.Environment, llc,
+		level, "-mtriple="+fixture.backendTriple(), "-filetype=obj", input, "-o", object)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual LLVM22 downloaded object failed: %v; %s%s", err, output, stderr)
+	}
+	data, err := os.ReadFile(object)
+	if err != nil || len(data) == 0 {
+		t.Fatal("actual downloaded object is empty or unavailable", err)
+	}
+	t.Logf("ACTUAL_DOWNLOADED_LLVM22_OBJECT target=%s backend=%s level=%s bytes=%d sha256=%s",
+		fixture.request.Target, fixture.backendTriple(), level, len(data), bytesSHA256(data))
+	return object
+}
+
+// The proof's canonical target remains unchanged. A concrete macOS deployment
+// version tells both actual tools to emit the Mach-O platform load command.
+func (fixture amd64DownloadedLLVMFixture) backendTriple() string {
+	if fixture.options.TargetTriple == "x86_64-apple-darwin" {
+		return "x86_64-apple-macosx11.0.0"
+	}
+	return fixture.options.TargetTriple
+}
+
+// Every host must compile all three admitted AMD64 target formats. Numerical
+// execution is separately required by the exact Linux/amd64 CI fixture below.
+func TestAMD64DownloadedFixedLocalLLVM22Objects(t *testing.T) {
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "x86_64-unknown-linux-gnu"},
+		{"darwin", "x86_64-apple-darwin"},
+		{"windows", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			fixture := captureAMD64DownloadedLLVMFixture(t, ctx, target.goos, target.triple)
+			llc := amd64DownloadedLLVM22Tool(t, ctx, fixture, "llc")
+			for _, api := range []string{"Translate", "Module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir := fixture.ir(t, api)
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) { fixture.object(t, ctx, llc, ir, level) })
+					}
+				})
+			}
+			if err := fixture.binding.Verify(ctx); err != nil {
+				t.Fatal("object compilation changed original downloaded inputs", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_nested_frame_go127_test.go b/gotoolprofile/amd64_downloaded_nested_frame_go127_test.go
new file mode 100644
index 000000000..333945651
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_nested_frame_go127_test.go
@@ -0,0 +1,119 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"errors"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// A package is not its module root. The original archive must authenticate
+// both, without copying the subpackage into a synthetic main module.
+func TestAMD64DownloadedNestedFrameOriginalObjects(t *testing.T) {
+	testAMD64DownloadedNestedFrameObjects(t, "fixed-local-nested")
+}
+
+func TestAMD64DownloadedLargeModuleOriginalObjects(t *testing.T) {
+	for _, variant := range []string{"fixed-local-nested-large-archive", "fixed-local-nested-large-payload"} {
+		t.Run(variant, func(t *testing.T) {
+			testAMD64DownloadedNestedFrameObjects(t, variant)
+		})
+	}
+}
+
+func testAMD64DownloadedNestedFrameObjects(t *testing.T, variant string) {
+	t.Helper()
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "x86_64-unknown-linux-gnu"},
+		{"darwin", "x86_64-apple-darwin"},
+		{"windows", "x86_64-pc-windows-msvc"},
+	} {
+		t.Run(target.goos, func(t *testing.T) {
+			request, pkg, capture := amd64DownloadedFramePublicFixture(t, variant)
+			request.Target = target.goos + "/amd64"
+			request.Environment = replaceEnv(request.Environment, map[string]string{"GOOS": target.goos})
+			capture.Original.Target = request.Target
+			capture.Original.Environment = request.Environment
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := captureAMD64DownloadedForTest(ctx, request, capture.SourceModule, capture.SourceVersion)
+			if err != nil {
+				t.Fatal("original Go subpackage must compile before the handoff", err)
+			}
+			defer func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			}()
+			selected := observed.state.packages[request.PackagePath]
+			if selected.Module == nil || selected.Module.Dir == selected.Dir || selected.Dir != request.Directory {
+				t.Fatal("fixture did not retain distinct actual package/module identities")
+			}
+			sig, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path+".Value",
+				pkg.Types.Scope().Lookup("Value").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := os.ReadFile(filepath.Join(request.Directory, "value_amd64.s"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			expanded := strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+			expanded = strings.Replace(expanded, "#include \"local.h\"", "#define ADVANCE 32", 1)
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := plan9asm.Options{Goarch: "amd64", TargetTriple: target.triple,
+				ResolveSym: func(name string) string { return strings.Replace(name, "·", pkg.Path+".", 1) },
+				Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig},
+			}
+			bound, binding, err := observed.BindDownloadedFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+			if err != nil || binding == nil {
+				t.Fatal("actual original nested package lost its frame/object handoff", err)
+			}
+			fixture := amd64DownloadedLLVMFixture{request, capture.SourceModule, capture.SourceVersion,
+				pkg, file, bound, expanded, observed, binding}
+			llc := amd64DownloadedLLVM22Tool(t, ctx, fixture, "llc")
+			for _, api := range []string{"Translate", "Module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ir := fixture.ir(t, api)
+					for _, level := range []string{"-O0", "-O2"} {
+						fixture.object(t, ctx, llc, ir, level)
+					}
+				})
+			}
+			if err := binding.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			// Ancestor module bytes remain part of the live original archive,
+			// even though they are not in the package's direct file inventory.
+			metadata := filepath.Join(selected.Module.Dir, "go.mod")
+			before, err := os.ReadFile(metadata)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chmod(metadata, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(metadata, append(append([]byte(nil), before...), '\n'), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := binding.Verify(ctx); err == nil {
+				t.Fatal("changed ancestor module retained its nested frame capability")
+			}
+			if err := os.WriteFile(metadata, before, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := plan9asm.Translate(file, bound); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("restoring ancestor metadata revived the revoked nested binding", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_numerical_go127_test.go b/gotoolprofile/amd64_downloaded_numerical_go127_test.go
new file mode 100644
index 000000000..2995900a2
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_numerical_go127_test.go
@@ -0,0 +1,286 @@
+//go:build go1.27 && ((linux && amd64) || (darwin && (amd64 || arm64)))
+
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// This exact fixture is a required Linux/amd64 CI counterpart to numerical
+// observations on Darwin/Rosetta. Rosetta is not native alignment/fault proof.
+func TestAMD64DownloadedFixedLocalLLVM22Numerical(t *testing.T) {
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	goos, triple := "linux", "x86_64-unknown-linux-gnu"
+	var prefix []string
+	if runtime.GOOS == "darwin" {
+		goos, triple = "darwin", "x86_64-apple-darwin"
+		if runtime.GOARCH == "arm64" {
+			prefix = []string{"/usr/bin/arch", "-x86_64"}
+		}
+	}
+	fixture := captureAMD64DownloadedLLVMFixture(t, ctx, goos, triple)
+	llc := amd64DownloadedLLVM22Tool(t, ctx, fixture, "llc")
+	clang := amd64DownloadedLLVM22Tool(t, ctx, fixture, "clang")
+	if len(prefix) != 0 {
+		output, stderr, err := RunBounded(ctx, fixture.request.Directory, fixture.request.Environment,
+			prefix[0], append(prefix[1:], "/usr/bin/true")...)
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("required Rosetta numerical transport unavailable: %v; %s%s", err, output, stderr)
+		}
+		t.Log("ROSETTA_NUMERICAL_OBSERVATION_ONLY: no native alignment, fault or runtime-matrix claim")
+	}
+	if !t.Run("OriginalGoExactImport", func(t *testing.T) {
+		fixture.originalGoNumerical(t, ctx, prefix)
+	}) {
+		return // An unsuccessful Go control cannot certify this numerical kernel.
+	}
+	for _, api := range []string{"Translate", "Module", "GoModule"} {
+		t.Run(api, func(t *testing.T) {
+			ir := fixture.ir(t, api)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					object := fixture.object(t, ctx, llc, ir, level)
+					fixture.llvmNumerical(t, ctx, clang, object, prefix)
+				})
+			}
+		})
+	}
+	if err := fixture.binding.Verify(ctx); err != nil {
+		t.Fatal("runtime driver changed the original source/frame inputs", err)
+	}
+}
+
+func (fixture amd64DownloadedLLVMFixture) runNumerical(t *testing.T, ctx context.Context, directory, executable string, prefix []string) {
+	t.Helper()
+	command := append(append([]string(nil), prefix...), executable)
+	output, stderr, err := RunBounded(ctx, directory, fixture.request.Environment, command[0], command[1:]...)
+	if err != nil || len(stderr) != 0 || string(output) != "DOWNLOADED_NUMERICAL_PASS 4096\n" {
+		t.Fatalf("actual downloaded numerical execution: %v; %s%s", err, output, stderr)
+	}
+	t.Logf("ACTUAL_DOWNLOADED_NUMERICAL target=%s transport=%q %s", fixture.request.Target, prefix, strings.TrimSpace(string(output)))
+}
+
+func (fixture amd64DownloadedLLVMFixture) originalGoNumerical(t *testing.T, ctx context.Context, prefix []string) {
+	t.Helper()
+	directory := t.TempDir()
+	metadata := "module example.invalid/downloaded-driver\ngo 1.20\nrequire " + fixture.sourceModule + " " + fixture.version + "\n"
+	for name, source := range map[string]string{
+		"go.mod":  metadata,
+		"main.go": fmt.Sprintf(amd64DownloadedGoNumericalDriver, fixture.sourceModule),
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// Only the independent driver is owned main. Its imported module must be
+	// the exact original cache tree, never a replace or a copied source module.
+	environment := replaceEnv(fixture.request.Environment, map[string]string{"GOPROXY": "off"})
+	data, stderr, err := RunBounded(ctx, directory, environment, fixture.request.GoBinary,
+		"list", "-compiled", "-export", "-json", "-mod=mod", fixture.sourceModule)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual exact driver import failed: %v; %s%s", err, data, stderr)
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	var selected amd64OriginalListPackage
+	var extra any
+	if err := decoder.Decode(&selected); err != nil || decoder.Decode(&extra) != io.EOF ||
+		selected.Dir != fixture.request.Directory || selected.ImportPath != fixture.pkg.Path || selected.Export == "" ||
+		selected.Module == nil || selected.Module.Main || selected.Module.Replace != nil ||
+		selected.Module.Path != fixture.sourceModule || selected.Module.Version != fixture.version {
+		t.Fatal("driver import did not retain the exact original downloaded identity", err)
+	}
+	t.Logf("ACTUAL_DRIVER_EXACT_IMPORT\n%s", data)
+	executable := filepath.Join(directory, "original-go")
+	output, stderr, err := RunBounded(ctx, directory, environment, fixture.request.GoBinary,
+		"build", "-mod=readonly", "-o", executable, ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("stock Go exact import driver build: %v; %s%s", err, output, stderr)
+	}
+	fixture.runNumerical(t, ctx, directory, executable, prefix)
+	if err := fixture.observed.Verify(ctx); err != nil {
+		t.Fatal("Go import driver changed original downloaded source bytes", err)
+	}
+}
+
+func (fixture amd64DownloadedLLVMFixture) llvmNumerical(t *testing.T, ctx context.Context, clang, object string, prefix []string) {
+	t.Helper()
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "main.c"), filepath.Join(directory, "translated")
+	symbol := fixture.pkg.Path + ".Value"
+	if strings.HasPrefix(fixture.request.Target, "darwin/") {
+		symbol = "_" + symbol
+	}
+	if err := os.WriteFile(source, []byte(fmt.Sprintf(amd64DownloadedCNumericalDriver, symbol)), 0600); err != nil {
+		t.Fatal(err)
+	}
+	arguments := []string{"-target", fixture.backendTriple()}
+	var macInputs *amd64DownloadedMacLinkInputs
+	if strings.HasPrefix(fixture.request.Target, "darwin/") {
+		macInputs = fixture.macLinkInputs(t, ctx, directory)
+		// A version-specific clang default config can silently override the
+		// linker sysroot. Select every SDK input explicitly instead.
+		arguments = append(arguments, "--no-default-config", "-isysroot", macInputs.root,
+			"-nostdlib", macInputs.systemLibrary)
+	}
+	arguments = append(arguments, object, source, "-O2", "-o", executable)
+	t.Logf("ACTUAL_DOWNLOADED_LINK_ARGS binary=%q argv=%q", clang, arguments)
+	output, stderr, err := RunBounded(ctx, directory, fixture.request.Environment, clang, arguments...)
+	if macInputs != nil {
+		macInputs.verify(t)
+	}
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("LLVM22 actual downloaded numerical link: %v; %s%s", err, output, stderr)
+	}
+	fixture.runNumerical(t, ctx, directory, executable, prefix)
+}
+
+// These retained IO observations prove only the numerical link's real inputs.
+// They never enter the downloaded factory, Source, signatures or Frame roles.
+type amd64DownloadedMacLinkInputs struct {
+	root, systemLibrary string
+	info                os.FileInfo
+	names               []string
+	files               map[string]string
+	snapshot            *gooriginalsrc.Snapshot
+}
+
+func (fixture amd64DownloadedLLVMFixture) macLinkInputs(t *testing.T, ctx context.Context, directory string) *amd64DownloadedMacLinkInputs {
+	t.Helper()
+	inputs := &amd64DownloadedMacLinkInputs{snapshot: gooriginalsrc.NewSnapshot(), files: make(map[string]string)}
+	inputs.retain(t, "/usr/bin/xcrun")
+	inputs.retain(t, "/usr/bin/ld")
+	arguments := []string{"--sdk", "macosx", "--show-sdk-path"}
+	data, stderr, err := RunBounded(ctx, directory, fixture.request.Environment, "/usr/bin/xcrun", arguments...)
+	if err != nil || len(stderr) != 0 || !bytes.HasSuffix(data, []byte("\n")) {
+		t.Fatalf("required actual macOS linker SDK: %v; %s%s", err, data, stderr)
+	}
+	requested := strings.TrimSuffix(string(data), "\n")
+	if !filepath.IsAbs(requested) || strings.ContainsAny(requested, "\r\n") {
+		t.Fatal("actual SDK path output is not one complete absolute path")
+	}
+	inputs.root, err = filepath.EvalSymlinks(requested)
+	if err != nil {
+		t.Fatal(err)
+	}
+	entries, info, err := gooriginalsrc.ReadDirectory(inputs.root, 256)
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs.info = info
+	for _, entry := range entries {
+		inputs.names = append(inputs.names, entry.Name())
+	}
+	inputs.systemLibrary = inputs.retain(t, filepath.Join(inputs.root, "usr", "lib", "libSystem.tbd"))
+	for _, name := range []string{"SDKSettings.json", "SDKSettings.plist"} {
+		inputs.retain(t, filepath.Join(inputs.root, name))
+	}
+	t.Logf("ACTUAL_MAC_SDK_SELECTION argv=%q stdout_hex=%x stderr_hex=%x requested=%q physical=%q identity=%+v members=%q",
+		arguments, data, stderr, requested, inputs.root, info.Sys(), inputs.names)
+	inputs.verify(t)
+	return inputs
+}
+
+func (inputs *amd64DownloadedMacLinkInputs) retain(t *testing.T, name string) string {
+	t.Helper()
+	physical, err := filepath.EvalSymlinks(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := inputs.snapshot.Retain(physical); err != nil {
+		t.Fatal(err)
+	}
+	data, err := inputs.snapshot.ReadRetained(physical)
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs.files[physical] = bytesSHA256(data)
+	t.Logf("ACTUAL_MAC_LINK_INPUT_BEFORE path=%q bytes=%d sha256=%s", physical, len(data), inputs.files[physical])
+	return physical
+}
+
+func (inputs *amd64DownloadedMacLinkInputs) verify(t *testing.T) {
+	t.Helper()
+	entries, info, err := gooriginalsrc.ReadDirectory(inputs.root, 256)
+	var names []string
+	for _, entry := range entries {
+		names = append(names, entry.Name())
+	}
+	if err != nil || !os.SameFile(inputs.info, info) || !reflect.DeepEqual(inputs.names, names) {
+		t.Fatal("actual macOS SDK identity or inventory changed", err)
+	}
+	if err := inputs.snapshot.Verify(); err != nil {
+		t.Fatal("actual macOS linker tool/SDK input changed", err)
+	}
+	for name, expected := range inputs.files {
+		data, err := inputs.snapshot.ReadRetained(name)
+		if err != nil || bytesSHA256(data) != expected {
+			t.Fatal("actual macOS linker input bytes changed", err)
+		}
+		t.Logf("ACTUAL_MAC_LINK_INPUT_AFTER path=%q bytes=%d sha256=%s", name, len(data), expected)
+	}
+}
+
+// Go and C independently compute two lane-wise uint32 additions. uint64 carry
+// across lane boundaries is deliberately wrong; inputs include both overflow
+// directions, all-zero/all-one values and 4,096 deterministic mixed bit patterns.
+const amd64DownloadedGoNumericalDriver = `package main
+import (
+    "fmt"
+    original %q
+)
+func main() {
+    seed := uint64(0x9e3779b97f4a7c15)
+    next := func() uint64 { seed ^= seed << 13; seed ^= seed >> 7; seed ^= seed << 17; return seed }
+    edges := []uint64{0, 1, 0xffffffff, 0x100000000, 0xffffffff00000000, 0x7fffffff80000000, 0x800000007fffffff, ^uint64(0)}
+    for i := 0; i < 4096; i++ {
+        a, b, c, d := next(), next(), next(), next()
+        if i < 64 { a, c = edges[i / 8], edges[i %% 8] }
+        want := uint64(uint32(a) + uint32(c)) | uint64(uint32(a >> 32) + uint32(c >> 32)) << 32
+        if got := original.Value(a, b, c, d); got != want { panic(fmt.Sprintf("case=%%d got=%%#x want=%%#x", i, got, want)) }
+    }
+    fmt.Println("DOWNLOADED_NUMERICAL_PASS 4096")
+}
+`
+
+const amd64DownloadedCNumericalDriver = `typedef unsigned long long word;
+extern int printf(const char *, ...);
+extern word kernel(word, word, word, word) __asm__(%q);
+static word seed = 0x9e3779b97f4a7c15ULL;
+static word next(void) {
+    seed ^= seed << 13;
+    seed ^= seed >> 7;
+    seed ^= seed << 17;
+    return seed;
+}
+int main(void) {
+    const word edges[] = {0, 1, 0xffffffffULL, 0x100000000ULL, 0xffffffff00000000ULL,
+                         0x7fffffff80000000ULL, 0x800000007fffffffULL, ~0ULL};
+    for (unsigned i = 0; i < 4096; ++i) {
+        word a = next(), b = next(), c = next(), d = next();
+        if (i < 64) { a = edges[i / 8]; c = edges[i %% 8]; }
+        word low = (unsigned)a + (unsigned)c;
+        word high = (unsigned)(a >> 32) + (unsigned)(c >> 32);
+        word want = (low & 0xffffffffULL) | ((high & 0xffffffffULL) << 32);
+        word got = kernel(a, b, c, d);
+        if (got != want) {
+            printf("case=%%u got=%%llx want=%%llx\n", i, got, want);
+            return 1;
+        }
+    }
+    printf("DOWNLOADED_NUMERICAL_PASS 4096\n");
+    return 0;
+}
+`
diff --git a/gotoolprofile/amd64_downloaded_observation.go b/gotoolprofile/amd64_downloaded_observation.go
new file mode 100644
index 000000000..5a2195e0e
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_observation.go
@@ -0,0 +1,255 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+// AMD64DownloadedObservationRequest names an exact actual Go download, never
+// an owned-main role, signature, frame or verification token. The ZIP's module
+// path may differ from its original go.mod declaration (a historical mirror).
+type AMD64DownloadedObservationRequest struct {
+	Original                    AMD64OriginalObservationRequest
+	SourceModule, SourceVersion string
+}
+
+type amd64DownloadedModule struct {
+	sourceModule, sourceVersion string
+	root, goMod, modulePath     string
+	goVersion, goModOrigin      string
+}
+
+type amd64DownloadedSources struct {
+	primary *amd64DownloadedModule
+	modules map[string]*amd64DownloadedModule
+	origins *gooriginalsrc.OriginSet
+}
+
+// CaptureAMD64DownloadedPackageObservation retains the original cache bytes.
+// Every nonstandard dependency gets its own exact Go-download/ZIP observation.
+// Hash agreement proves byte consistency with that configured Go download, not
+// a standalone SumDB/signature certificate. Its environment and actual tools
+// remain part of the ordinary observation; no external initialization runs.
+func CaptureAMD64DownloadedPackageObservation(ctx context.Context, request AMD64DownloadedObservationRequest, run Runner) (*AMD64OriginalPackageObservation, error) {
+	if err := validateAMD64OriginalObservationRequest(ctx, request.Original, run); err != nil {
+		return nil, err
+	}
+	sources, err := captureAMD64DownloadedSources(ctx, request, run)
+	if err != nil {
+		return nil, err
+	}
+	return captureAMD64OriginalPackageObservation(ctx, request.Original, sources, run)
+}
+
+func captureAMD64DownloadedSources(ctx context.Context, request AMD64DownloadedObservationRequest, run Runner) (_ *amd64DownloadedSources, result error) {
+	original := request.Original
+	cache, err := sourcepath.Resolve(originalObservationEnvironment(original.Environment, "GOMODCACHE"))
+	if err != nil {
+		return nil, err
+	}
+	boundary, err := gooriginalsrc.NewDownloadBoundary(originalObservationEnvironment(original.Environment, "GOTMPDIR"),
+		"amd64-original-download-", "example.invalid/plan9asm-original-download")
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		result = errors.Join(result, boundary.Close())
+	}()
+	// An empty directory can still inherit an ancestor module. Give the
+	// download command its own module boundary, without changing source inputs.
+	if err := boundary.Prepare(); err != nil {
+		return nil, err
+	}
+	marker := boundary.Directory()
+	origins, err := gooriginalsrc.NewOriginSet(cache, original.GoBinary)
+	if err != nil {
+		return nil, err
+	}
+	sources := &amd64DownloadedSources{modules: make(map[string]*amd64DownloadedModule), origins: origins}
+	primary, err := sources.captureModule(ctx, original, request.SourceModule, request.SourceVersion, marker, run)
+	if err != nil {
+		return nil, err
+	}
+	sources.primary = primary
+	data, stderr, err := sources.runList(ctx, original, run,
+		"list", "-deps", "-compiled", "-json", "-mod=readonly", original.PackagePath)
+	if err != nil || len(stderr) != 0 || len(data) == 0 || len(data) > commandOutputLimit {
+		return nil, fmt.Errorf("actual downloaded source graph failed: %v; %s", err, stderr)
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	seen := make(map[string]bool)
+	selected := false
+	for {
+		var pkg amd64OriginalListPackage
+		err := decoder.Decode(&pkg)
+		if err == io.EOF {
+			break
+		}
+		if err != nil || len(seen) >= 4096 || pkg.ImportPath == "" || seen[pkg.ImportPath] {
+			return nil, fmt.Errorf("invalid, repeated or over-bound downloaded source graph: %v", err)
+		}
+		seen[pkg.ImportPath] = true
+		if pkg.ImportPath == original.PackagePath {
+			selected = true
+			if !primary.matchesPrimary(pkg.Module) {
+				return nil, fmt.Errorf("downloaded primary source differs from actual original package role")
+			}
+		}
+		if pkg.Module == nil {
+			if !pkg.Standard {
+				return nil, fmt.Errorf("%w: downloaded dependency has no stock SDK/module role", plan9asm.ErrProbeNeedsContext)
+			}
+			continue
+		}
+		if pkg.Module.Main {
+			if !primary.matches(pkg.Module, true) {
+				return nil, fmt.Errorf("downloaded graph acquired a different main source")
+			}
+			continue
+		}
+		if pkg.Module.Replace != nil || pkg.Standard {
+			return nil, fmt.Errorf("%w: replaced/foreign dependency needs a separate exact source role", plan9asm.ErrProbeNeedsContext)
+		}
+		source, err := sources.captureModule(ctx, original, pkg.Module.Path, pkg.Module.Version, marker, run)
+		if err != nil || !source.matches(pkg.Module, false) {
+			return nil, fmt.Errorf("downloaded dependency differs from its independently observed source: %v", err)
+		}
+	}
+	if !selected {
+		return nil, fmt.Errorf("downloaded graph omitted the requested original assembly package")
+	}
+	return sources, sources.verify()
+}
+
+func (sources *amd64DownloadedSources) captureModule(ctx context.Context, request AMD64OriginalObservationRequest, path, version, marker string, run Runner) (*amd64DownloadedModule, error) {
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	if module.Check(path, version) != nil || module.CanonicalVersion(version) != version {
+		return nil, fmt.Errorf("downloaded source requires a canonical exact module version")
+	}
+	key := path + "@" + version
+	if source := sources.modules[key]; source != nil {
+		return source, sources.verify()
+	}
+	if len(sources.modules) >= 64 {
+		return nil, fmt.Errorf("downloaded source module graph exceeds its explicit bound")
+	}
+	if err := sources.verify(); err != nil {
+		return nil, err
+	}
+	data, stderr, err := run(ctx, marker, request.Environment, request.GoBinary, "mod", "download", "-json", key)
+	if err != nil {
+		return nil, fmt.Errorf("actual exact module download failed: %w; %s", err, stderr)
+	}
+	if len(stderr) != 0 || len(data) == 0 || len(data) > commandOutputLimit {
+		return nil, fmt.Errorf("actual exact module download returned incomplete output: %s", stderr)
+	}
+	var receipt gooriginalsrc.DownloadReceipt
+	if err := json.Unmarshal(data, &receipt); err != nil {
+		return nil, fmt.Errorf("actual module download returned malformed exact identity: %w", err)
+	}
+	var proxyMetadata *ProxyGoModProof
+	if _, err := os.Lstat(filepath.Join(receipt.Dir, "go.mod")); os.IsNotExist(err) {
+		proxyMetadata, _, err = CaptureDownloadedProxyGoMod(ctx, request.GoBinary,
+			marker, request.Environment, path, version, receipt.Sum, receipt.GoModSum, receipt.GoMod, nil)
+		if err != nil {
+			return nil, err
+		}
+	}
+	original, err := sources.origins.ObserveLegacy(ctx, path, version, receipt, proxyMetadata)
+	if errors.Is(err, gooriginalsrc.ErrUnclosedModuleDeclaration) {
+		return nil, fmt.Errorf("%w: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	if err != nil {
+		return nil, err
+	}
+	source := &amd64DownloadedModule{sourceModule: original.SourceModule, sourceVersion: original.SourceVersion,
+		root: original.Root, goMod: original.GoMod, modulePath: original.ModulePath,
+		goVersion: original.GoVersion, goModOrigin: original.GoModOrigin}
+	sources.modules[key] = source
+	return source, sources.verify()
+}
+
+func (sources *amd64DownloadedSources) verify() error {
+	if sources == nil {
+		return fmt.Errorf("missing exact downloaded source observation")
+	}
+	return sources.origins.Verify()
+}
+
+func (source *amd64DownloadedModule) legacy() bool {
+	return source != nil && source.goModOrigin == ProxyGoModProtocol
+}
+
+func (source *amd64DownloadedModule) matchesPrimary(actual *amd64OriginalListModule) bool {
+	return source.matches(actual, !source.legacy())
+}
+
+func (sources *amd64DownloadedSources) runList(ctx context.Context, request AMD64OriginalObservationRequest,
+	run Runner, args ...string,
+) (stdout, stderr []byte, result error) {
+	if sources == nil || !sources.primary.legacy() {
+		return run(ctx, request.Directory, request.Environment, request.GoBinary, args...)
+	}
+	if len(args) == 0 || args[0] != "list" {
+		return nil, nil, fmt.Errorf("legacy source query must retain its actual list command")
+	}
+	env, err := gooriginalsrc.DependencyQueryEnvironment(request.Environment)
+	if err != nil {
+		return nil, nil, err
+	}
+	stdout, result = gooriginalsrc.RunDependencyList(ctx,
+		originalObservationEnvironment(request.Environment, "GOTMPDIR"),
+		sources.primary.sourceModule, sources.primary.sourceVersion, args, func(directory string, arguments []string) ([]byte, []byte, error) {
+			return run(ctx, directory, env, request.GoBinary, arguments...)
+		})
+	return stdout, stderr, result
+}
+
+func (source *amd64DownloadedModule) matches(actual *amd64OriginalListModule, primary bool) bool {
+	if source == nil || actual == nil || actual.Replace != nil || actual.Main != primary ||
+		actual.Path != source.modulePath || actual.GoVersion != gooriginalsrc.SelectedGoVersion(source.goVersion, primary) {
+		return false
+	}
+	if source.goModOrigin == ProxyGoModProtocol && primary {
+		// Metadata outside a ZIP cannot supply the cache-CWD main role.
+		// A legacy primary needs a separately owned exact-version query.
+		return false
+	}
+	wantedVersion := source.sourceVersion
+	if primary {
+		wantedVersion = "" // Preserve Go's actual cached-CWD main role, not a version fiction.
+	}
+	root, err := sourcepath.Resolve(actual.Dir)
+	goMod, modErr := sourcepath.Resolve(actual.GoMod)
+	if source.goModOrigin == ProxyGoModProtocol && goMod != source.goMod {
+		return false
+	}
+	return err == nil && modErr == nil && root == source.root && actual.Version == wantedVersion &&
+		(goMod == source.goMod || goMod == filepath.Join(source.root, "go.mod"))
+}
+
+func (sources *amd64DownloadedSources) module(actual *amd64OriginalListModule) (*amd64DownloadedModule, error) {
+	if actual != nil && actual.Main && sources.primary.matches(actual, true) {
+		return sources.primary, nil
+	}
+	if actual != nil && !actual.Main {
+		source := sources.modules[actual.Path+"@"+actual.Version]
+		if source.matches(actual, false) {
+			return source, nil
+		}
+	}
+	return nil, fmt.Errorf("%w: module source lacks its separate exact original download handoff", plan9asm.ErrProbeNeedsContext)
+}
diff --git a/gotoolprofile/amd64_downloaded_observation_guards_test.go b/gotoolprofile/amd64_downloaded_observation_guards_test.go
new file mode 100644
index 000000000..63ea868f7
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_observation_guards_test.go
@@ -0,0 +1,427 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestAMD64DownloadedObservationRejectsUnprovedInputs(t *testing.T) {
+	for _, name := range []string{"latest", "different version", "different module", "owned copy", "changed source", "added ignored source", "changed ZIP", "changed metadata"} {
+		t.Run(name, func(t *testing.T) {
+			request, path, version := amd64DownloadedObservationFixture(t, "data")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			prefix := filepath.Join(originalObservationEnvironment(request.Environment, "GOMODCACHE"), "cache", "download", path, "@v", version)
+			switch name {
+			case "latest":
+				version = "latest"
+			case "different version":
+				version = "v1.0.1"
+			case "different module":
+				path = "example.invalid/unobserved"
+			case "owned copy":
+				request.Directory = amd64OriginalObservationFixture(t, "data").Directory
+			case "changed source":
+				mutateAMD64DownloadedFile(t, filepath.Join(request.Directory, "value.go"), "\nconst Changed = 1\n")
+			case "added ignored source":
+				if err := os.Chmod(request.Directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(request.Directory, "ignored_windows.go"), []byte("package observation\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "changed ZIP":
+				mutateAMD64DownloadedFile(t, prefix+".zip", "different exact archive encoding")
+				// HashZip alone intentionally ignores trailing ZIP encoding bytes.
+				// Go's actual complete download format must still validate first.
+				if err := os.WriteFile(prefix+".zip", []byte("not a ZIP"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "changed metadata":
+				mutateAMD64DownloadedFile(t, prefix+".mod", "\nrequire example.invalid/unobserved v1.0.0\n")
+			}
+			if observed, err := captureAMD64DownloadedForTest(ctx, request, path, version); err == nil {
+				observed.Close()
+				t.Fatal("unobserved or different original source acquired a download observation")
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedObservationRejectsDownloadJSONForgery(t *testing.T) {
+	for _, field := range []string{"Path", "Version", "Dir", "Zip", "GoMod", "Sum", "GoModSum", "Error", "Dir as ZIP", "ZIP as metadata"} {
+		t.Run(field, func(t *testing.T) {
+			request, path, version := amd64DownloadedObservationFixture(t, "data")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				data, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+				if err != nil || len(args) < 2 || args[0] != "mod" || args[1] != "download" {
+					return data, stderr, err
+				}
+				var object map[string]json.RawMessage
+				if err := json.Unmarshal(data, &object); err != nil {
+					return nil, nil, err
+				}
+				switch field {
+				case "Dir as ZIP":
+					object["Dir"] = object["Zip"]
+				case "ZIP as metadata":
+					object["Zip"] = object["GoMod"]
+				default:
+					object[field], err = json.Marshal("unobserved")
+					if err != nil {
+						return nil, nil, err
+					}
+				}
+				changed = true
+				data, err = json.Marshal(object)
+				return data, stderr, err
+			}
+			observed, err := CaptureAMD64DownloadedPackageObservation(ctx, AMD64DownloadedObservationRequest{
+				Original: request, SourceModule: path, SourceVersion: version,
+			}, run)
+			if err == nil {
+				observed.Close()
+				t.Fatal("portable JSON impersonated an actual exact original source")
+			}
+			if !changed {
+				t.Fatal("negative never reached its actual download seam")
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedObservationMarkerCannotInheritCallerModule(t *testing.T) {
+	request, path, version := amd64DownloadedObservationFixture(t, "data")
+	parent, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goMod := []byte("module example.invalid/caller-canary\ngo 1.20\nrequire " + path + " " + version + "\n")
+	if err := os.WriteFile(filepath.Join(parent, "go.mod"), goMod, 0600); err != nil {
+		t.Fatal(err)
+	}
+	// A caller-owned checksum file is a source input, not the factory's scratch.
+	goSum := []byte("\n")
+	if err := os.WriteFile(filepath.Join(parent, "go.sum"), goSum, 0600); err != nil {
+		t.Fatal(err)
+	}
+	tmp := filepath.Join(parent, "tmp")
+	if err := os.Mkdir(tmp, 0700); err != nil {
+		t.Fatal(err)
+	}
+	request.Environment = replaceEnv(request.Environment, map[string]string{"GOTMPDIR": tmp})
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, captureErr := captureAMD64DownloadedForTest(ctx, request, path, version)
+	if observed != nil {
+		defer observed.Close()
+	}
+	for name, expected := range map[string][]byte{"go.mod": goMod, "go.sum": goSum} {
+		actual, err := os.ReadFile(filepath.Join(parent, name))
+		if err != nil || string(actual) != string(expected) {
+			t.Errorf("factory download inherited and modified caller's %s: %v", name, err)
+		}
+	}
+	if captureErr != nil {
+		t.Fatal(captureErr)
+	}
+}
+
+func TestAMD64DownloadedObservationQueryOnlyCannotBindFixedLocal(t *testing.T) {
+	request, path, version := amd64DownloadedObservationFixture(t, "fixed-local")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := captureAMD64DownloadedForTest(ctx, request, path, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	set := token.NewFileSet()
+	syntax, err := parser.ParseFile(set, filepath.Join(request.Directory, "value.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(request.PackagePath, set, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := plan9asm.DeriveGoFuncABI0Signature(request.PackagePath+".Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(filepath.Join(request.Directory, "value_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	expanded := strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+	expanded = strings.Replace(expanded, "#include \"local.h\"", "#define ADVANCE 32", 1)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := plan9asm.GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", typed.Path()+".", 1) },
+		Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig},
+	}
+	_, binding, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+	if binding != nil {
+		defer binding.Close()
+	}
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || binding != nil {
+		t.Fatalf("query-only downloaded observation silently exposed an owned-main frame/object consumer: %v", err)
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("rejecting unimplemented consumer must not revoke an unchanged source observation", err)
+	}
+}
+
+func TestAMD64DownloadedObservationImmutableSourceAndRevocation(t *testing.T) {
+	for _, role := range []string{"source", "unselected source", "foreign source", "ZIP", "metadata", "module directory", "close"} {
+		t.Run(role, func(t *testing.T) {
+			variant := "data"
+			if role == "foreign source" {
+				variant = "foreign"
+			}
+			request, path, version := amd64DownloadedObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := captureAMD64DownloadedForTest(ctx, request, path, version)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			prefix := filepath.Join(originalObservationEnvironment(request.Environment, "GOMODCACHE"), "cache", "download", path, "@v", version)
+			name, suffix := filepath.Join(request.Directory, "value.go"), "\nconst Changed = 1\n"
+			switch role {
+			case "unselected source":
+				name, suffix = filepath.Join(request.Directory, "local.h"), "\n#define UNUSED 1\n"
+			case "foreign source":
+				foreign := observed.downloaded.modules["example.invalid/foreign-observation@"+version]
+				if foreign == nil {
+					t.Fatal("test lacks its actual separately observed foreign module")
+				}
+				name = filepath.Join(foreign.root, "shape.go")
+			case "ZIP":
+				name, suffix = prefix+".zip", "same h1, different retained original encoding"
+			case "metadata":
+				name = prefix + ".mod"
+			case "module directory":
+				moved := request.Directory + "-moved"
+				if err := os.Chmod(request.Directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Chmod(filepath.Dir(request.Directory), 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(request.Directory, moved); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(request.Directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := observed.Verify(ctx); err == nil {
+					t.Fatal("changed original source directory identity was accepted")
+				}
+				if err := os.Remove(request.Directory); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(moved, request.Directory); err != nil {
+					t.Fatal(err)
+				}
+				if err := observed.Verify(ctx); err == nil {
+					t.Fatal("restoring the original cache directory resurrected a revoked observation")
+				}
+				return
+			case "close":
+				if err := observed.Close(); err != nil {
+					t.Fatal(err)
+				}
+				if _, err := os.Stat(name); err != nil {
+					t.Fatal("Close removed caller/Go-owned original module source", err)
+				}
+				if err := observed.Verify(ctx); err == nil {
+					t.Fatal("closed source observation was usable")
+				}
+				return
+			}
+			original, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutateAMD64DownloadedFile(t, name, suffix)
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("mutated source/archive was recaptured as a new blessed baseline")
+			}
+			if err := os.WriteFile(name, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("restored bytes resurrected a revoked download observation")
+			}
+		})
+	}
+}
+
+func TestAMD64DownloadedObservationCacheRootContinuity(t *testing.T) {
+	request, path, version := amd64DownloadedObservationFixture(t, "data")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := captureAMD64DownloadedForTest(ctx, request, path, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	cache := originalObservationEnvironment(request.Environment, "GOMODCACHE")
+	moved, replacement := cache+"-original", cache+"-replacement"
+	if err := os.Mkdir(replacement, 0700); err != nil {
+		t.Fatal(err)
+	}
+	members, err := os.ReadDir(cache)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Retain every module and metadata subtree inode, byte and path role. Only
+	// the actual cache root directory's identity changes at the same pathname.
+	for _, member := range members {
+		if err := os.Rename(filepath.Join(cache, member.Name()), filepath.Join(replacement, member.Name())); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.Rename(cache, moved); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(replacement, cache); err != nil {
+		t.Fatal(err)
+	}
+	// Restore the fixture-owned cache even if the current implementation fails
+	// this regression. Never remove a Go/caller-owned module subtree.
+	defer func() {
+		for _, member := range members {
+			if err := os.Rename(filepath.Join(cache, member.Name()), filepath.Join(moved, member.Name())); err != nil {
+				t.Error(err)
+				return
+			}
+		}
+		if err := os.Remove(cache); err != nil {
+			t.Error(err)
+			return
+		}
+		if err := os.Rename(moved, cache); err != nil {
+			t.Error(err)
+			return
+		}
+		if err := observed.Verify(ctx); err == nil {
+			t.Error("restoring the original cache root resurrected a revoked observation")
+		}
+	}()
+	if err := observed.Verify(ctx); err == nil {
+		t.Fatal("replacement cache root preserved all module bytes/inodes but acquired the original cache role")
+	}
+}
+
+func TestAMD64DownloadedObservationRejectsSameBytesFileReplacement(t *testing.T) {
+	for _, role := range []string{"source", "ZIP", "metadata"} {
+		t.Run(role, func(t *testing.T) {
+			request, modulePath, version := amd64DownloadedObservationFixture(t, "data")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := captureAMD64DownloadedForTest(ctx, request, modulePath, version)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			prefix := filepath.Join(originalObservationEnvironment(request.Environment, "GOMODCACHE"),
+				"cache", "download", modulePath, "@v", version)
+			name := filepath.Join(request.Directory, "value.go")
+			if role == "ZIP" {
+				name = prefix + ".zip"
+			} else if role == "metadata" {
+				name = prefix + ".mod"
+			}
+			original, err := os.ReadFile(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			before, err := os.Lstat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Windows Lstat defers the file ID lookup until SameFile. Bind it
+			// before replacement, while this path still names the original.
+			if !os.SameFile(before, before) {
+				t.Fatal("original physical identity could not be observed")
+			}
+			if err := os.Chmod(filepath.Dir(name), 0700); err != nil {
+				t.Fatal(err)
+			}
+			backup := filepath.Join(t.TempDir(), "original")
+			if err := os.Rename(name, backup); err != nil {
+				t.Fatal(err)
+			}
+			restored := false
+			defer func() {
+				if !restored {
+					if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
+						t.Error(err)
+					}
+					if err := os.Rename(backup, name); err != nil {
+						t.Error(err)
+					}
+				}
+			}()
+			if err := os.WriteFile(name, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			after, err := os.Lstat(name)
+			if err != nil || os.SameFile(before, after) {
+				t.Fatal("negative did not change the original physical file identity", err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("same source bytes at a replacement inode acquired the original source role")
+			}
+			if err := os.Remove(name); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Rename(backup, name); err != nil {
+				t.Fatal(err)
+			}
+			restored = true
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("restoring the original file resurrected the revoked observation")
+			}
+		})
+	}
+}
+
+func mutateAMD64DownloadedFile(t *testing.T, name, suffix string) {
+	t.Helper()
+	if err := os.Chmod(name, 0600); err != nil {
+		t.Fatal(err)
+	}
+	data, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.ContainsRune(suffix, '\x00') {
+		t.Fatal("fixture source mutation must be explicit readable bytes")
+	}
+	if err := os.WriteFile(name, append(data, []byte(suffix)...), 0600); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/gotoolprofile/amd64_downloaded_observation_test.go b/gotoolprofile/amd64_downloaded_observation_test.go
new file mode 100644
index 000000000..b0abdac0e
--- /dev/null
+++ b/gotoolprofile/amd64_downloaded_observation_test.go
@@ -0,0 +1,273 @@
+package gotoolprofile
+
+import (
+	"archive/zip"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// The file proxy contains only this repository's generated first-party code.
+// GOSUMDB=off here is not a production source-authentication certificate.
+func amd64DownloadedObservationFixture(t *testing.T, variant string) (AMD64OriginalObservationRequest, string, string) {
+	t.Helper()
+	withoutGo := strings.HasSuffix(variant, "-no-go")
+	variant = strings.TrimSuffix(variant, "-no-go")
+	baseVariant := variant
+	if variant == "nested-import" || variant == "nested-foreign" {
+		baseVariant = "nested"
+	}
+	request := amd64OriginalObservationFixture(t, baseVariant)
+	fixedNested := strings.HasPrefix(variant, "fixed-local-nested")
+	if variant == "fixed-local" || fixedNested {
+		request, _, _, _, _ = amd64OriginalFixedLocalFixture(t)
+	}
+	modulePath, version := "example.invalid/observation", "v1.0.0"
+	if variant == "incompatible" {
+		version = "v1.0.0+incompatible"
+	}
+	if variant == "alias" {
+		modulePath = "example.invalid/archive-observation"
+	}
+	proxy, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	cache, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := request.Directory
+	if fixedNested {
+		request.Directory = filepath.Join(root, "internal", "kernel")
+		request.PackagePath += "/internal/kernel"
+		if err := os.MkdirAll(request.Directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+		for _, name := range []string{"value.go", "value_amd64.s", "local.h"} {
+			if err := os.Rename(filepath.Join(root, name), filepath.Join(request.Directory, name)); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if baseVariant == "nested" {
+		root = filepath.Dir(filepath.Dir(root))
+	}
+	if strings.HasSuffix(variant, "-large-archive") || strings.HasSuffix(variant, "-large-payload") {
+		directory := filepath.Join(root, "payload")
+		if err := os.Mkdir(directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+		members, extent := 3, int64(8<<20)
+		if strings.HasSuffix(variant, "-large-payload") {
+			members, extent = 1, 17<<20
+		}
+		for index := 0; index < members; index++ {
+			file, err := os.Create(filepath.Join(directory, string(rune('a'+index))+".bin"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			// A sparse zero-filled first-party payload needs no large allocation.
+			if err := errors.Join(file.Truncate(extent), file.Close()); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	if variant == "nested-import" {
+		data := "package observation\nimport \"math/bits\"\nfunc Value(a uint64) uint64\n" +
+			"func Reference(a uint64) uint64 { return bits.RotateLeft64(a, 1) }\n"
+		if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Cleanup(func() {
+		if err := filepath.WalkDir(cache, func(name string, entry os.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if entry.IsDir() {
+				return os.Chmod(name, 0700)
+			}
+			return nil
+		}); err != nil {
+			t.Error(err)
+		}
+	})
+	proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+	if err != nil {
+		t.Fatal(err)
+	}
+	request.Environment = replaceEnv(request.Environment, map[string]string{
+		"GOPROXY": proxyURL, "GOMODCACHE": cache,
+	})
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	if variant == "foreign" || variant == "nested-foreign" {
+		foreignRoot := t.TempDir()
+		foreignModule := "example.invalid/foreign-observation"
+		foreignGoMod := "module " + foreignModule + "\ngo 1.20\n"
+		if withoutGo {
+			foreignGoMod = "module " + foreignModule + "\n"
+		}
+		for name, data := range map[string]string{
+			"go.mod":   foreignGoMod,
+			"shape.go": "package shape\ntype Word uint64\n",
+		} {
+			if err := os.WriteFile(filepath.Join(foreignRoot, name), []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		writeAMD64ObservationModuleProxy(t, proxy, foreignModule, version, foreignRoot)
+		if err := os.WriteFile(filepath.Join(root, "go.mod"),
+			[]byte("module example.invalid/observation\ngo 1.20\nrequire "+foreignModule+" "+version+"\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(request.Directory, "value.go"),
+			[]byte("package observation\nimport shape \""+foreignModule+"\"\nfunc Value(a shape.Word) uint64\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		_, stderr, err := RunBounded(ctx, root, request.Environment, request.GoBinary,
+			"mod", "download", "-json", foreignModule+"@"+version)
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("actual generated foreign module download: %v; %s", err, stderr)
+		}
+	}
+	if withoutGo {
+		name := filepath.Join(root, "go.mod")
+		data, err := os.ReadFile(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(string(data), "\ngo 1.20\n") {
+			t.Fatal("first-party fixture lost its explicit language control")
+		}
+		data = []byte(strings.Replace(string(data), "\ngo 1.20\n", "\n", 1))
+		if err := os.WriteFile(name, data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	method := uint16(zip.Deflate)
+	if strings.HasSuffix(variant, "-large-archive") {
+		method = zip.Store
+	}
+	writeAMD64ObservationModuleProxyWithMethod(t, proxy, modulePath, version, root, method)
+	data, stderr, err := RunBounded(ctx, root, request.Environment, request.GoBinary,
+		"mod", "download", "-json", modulePath+"@"+version)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual generated module download: %v; %s", err, stderr)
+	}
+	var downloaded struct{ Path, Version, Dir, Error string }
+	if err := json.Unmarshal(data, &downloaded); err != nil || downloaded.Error != "" ||
+		downloaded.Path != modulePath || downloaded.Version != version || downloaded.Dir == "" {
+		t.Fatalf("actual Go omitted its exact downloaded source identity: %v", err)
+	}
+	request.Directory = downloaded.Dir
+	if baseVariant == "nested" || fixedNested {
+		request.Directory = filepath.Join(downloaded.Dir, "internal", "kernel")
+	}
+	return request, modulePath, version
+}
+
+func writeAMD64ObservationModuleProxy(t *testing.T, proxy, modulePath, version, root string) {
+	t.Helper()
+	writeAMD64ObservationModuleProxyWithMethod(t, proxy, modulePath, version, root, zip.Deflate)
+}
+
+func writeAMD64ObservationModuleProxyWithMethod(t *testing.T, proxy, modulePath, version, root string, method uint16) {
+	t.Helper()
+	dir := filepath.Join(proxy, modulePath, "@v")
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		t.Fatal(err)
+	}
+	archive, err := os.Create(filepath.Join(dir, version+".zip"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	w := zip.NewWriter(archive)
+	err = filepath.WalkDir(root, func(name string, entry os.DirEntry, err error) error {
+		if err != nil || entry.IsDir() {
+			return err
+		}
+		relative, err := filepath.Rel(root, name)
+		if err != nil {
+			return err
+		}
+		member, err := w.CreateHeader(&zip.FileHeader{
+			Name: modulePath + "@" + version + "/" + filepath.ToSlash(relative), Method: method,
+		})
+		if err != nil {
+			return err
+		}
+		input, err := os.Open(name)
+		if err != nil {
+			return err
+		}
+		_, copyErr := io.Copy(member, input)
+		return errors.Join(copyErr, input.Close())
+	})
+	if err := errors.Join(err, w.Close(), archive.Close()); err != nil {
+		t.Fatal(err)
+	}
+	goMod, err := os.ReadFile(filepath.Join(root, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for suffix, data := range map[string][]byte{
+		".mod":  goMod,
+		".info": []byte(`{"Version":"` + version + `","Time":"2026-10-01T00:00:00Z"}`),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, version+suffix), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+// Keep the source/download identity separate from Go's actual cached-CWD role.
+func captureAMD64DownloadedForTest(ctx context.Context, request AMD64OriginalObservationRequest, modulePath, version string) (*AMD64OriginalPackageObservation, error) {
+	return CaptureAMD64DownloadedPackageObservation(ctx, AMD64DownloadedObservationRequest{
+		Original: request, SourceModule: modulePath, SourceVersion: version,
+	}, RunBounded)
+}
+
+func TestAMD64DownloadedObservationActualOriginalCache(t *testing.T) {
+	for _, variant := range []string{"nested", "data", "sibling", "alias", "foreign", "incompatible"} {
+		t.Run(variant, func(t *testing.T) {
+			request, modulePath, version := amd64DownloadedObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			if old, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded); err == nil {
+				old.Close()
+				t.Fatal("downloaded source acquired an owned-main role without an authenticated handoff")
+			}
+			observed, err := captureAMD64DownloadedForTest(ctx, request, modulePath, version)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			pkg := observed.state.packages[request.PackagePath]
+			declaration := "func(a uint64) uint64"
+			if variant == "foreign" {
+				declaration = "func(a example.invalid/foreign-observation.Word) uint64"
+				if len(observed.downloaded.modules) != 2 || observed.state.packages["example.invalid/foreign-observation"].Export == "" {
+					t.Fatal("foreign source did not get its separate exact download/export handoff")
+				}
+			}
+			if pkg.Module == nil || !pkg.Module.Main || pkg.Module.Version != "" || observed.state.declarations["Value"] != declaration {
+				t.Fatal("actual original cache selection or complete checked declaration was lost")
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(pkg.Dir, "@"+version) {
+				t.Fatal("source was copied into a synthetic owned main instead of observing original cache bytes")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_legacy_metadata_roles_test.go b/gotoolprofile/amd64_legacy_metadata_roles_test.go
new file mode 100644
index 000000000..45d00dd42
--- /dev/null
+++ b/gotoolprofile/amd64_legacy_metadata_roles_test.go
@@ -0,0 +1,41 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAMD64LegacyDownloadMetadataKeepsDependencyRole(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(t.TempDir(), "legacy.mod")
+	member := filepath.Join(root, "go.mod")
+	for _, name := range []string{metadata, member} {
+		if err := os.WriteFile(name, []byte("module example.invalid/legacy\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	metadata, err = filepath.EvalSymlinks(metadata)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This checks only the role predicate, not authenticated ZIP observation.
+	source := &amd64DownloadedModule{root: root, modulePath: "example.invalid/legacy",
+		sourceModule: "example.invalid/legacy", sourceVersion: "v1.0.0", goMod: metadata,
+		goModOrigin: ProxyGoModProtocol}
+	actual := &amd64OriginalListModule{Path: source.modulePath, Version: source.sourceVersion, Dir: root, GoMod: metadata}
+	if !source.matches(actual, false) {
+		t.Fatal("exact dependency metadata was lost")
+	}
+	actual.GoMod = member
+	if source.matches(actual, false) {
+		t.Fatal("external proxy metadata was relabeled as an original ZIP member")
+	}
+	actual.GoMod, actual.Main, actual.Version, actual.GoVersion = metadata, true, "", "1.16"
+	if source.matches(actual, true) {
+		t.Fatal("legacy dependency borrowed a cache-CWD main role")
+	}
+}
diff --git a/gotoolprofile/amd64_original_budget_actual_test.go b/gotoolprofile/amd64_original_budget_actual_test.go
new file mode 100644
index 000000000..c55f4a18f
--- /dev/null
+++ b/gotoolprofile/amd64_original_budget_actual_test.go
@@ -0,0 +1,153 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// A normal first-party numeric package imports these SDK packages without
+// requiring native/generated code or granting a private frame capability.
+func TestAMD64OriginalObservationActualSDKGraphBudget(t *testing.T) {
+	for _, crypto := range []bool{false, true} {
+		name := "driver-collision"
+		if crypto {
+			name = "recursive-sdk"
+		}
+		t.Run(name, func(t *testing.T) {
+			amd64OriginalActualSDKGraphBudget(t, crypto, "linux")
+		})
+	}
+}
+
+func TestAMD64OriginalObservationCrossTargetSDKGraphBudget(t *testing.T) {
+	amd64OriginalActualSDKGraphBudget(t, true, "darwin")
+}
+
+func amd64OriginalActualSDKGraphBudget(t *testing.T, crypto bool, goos string) {
+	t.Helper()
+	request := amd64OriginalObservationFixture(t, "sdk-import")
+	request.Target = goos + "/amd64"
+	request.Environment = replaceEnv(request.Environment, map[string]string{"GOOS": goos})
+	source := `package observation
+import (
+ "encoding/binary"
+ "fmt"
+)
+func Value(a uint64) uint64
+func Decode(p []byte) (uint64,error) {
+ if len(p)<8 {
+  return 0,fmt.Errorf("short input: %d",len(p))
+ }
+ return binary.LittleEndian.Uint64(p),nil
+}
+`
+	if crypto {
+		source = strings.Replace(source, "import (", "import (\n _ \"crypto\"", 1)
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	output, diagnostic, err := RunBounded(ctx, request.Directory, request.Environment,
+		request.GoBinary, "list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", request.PackagePath)
+	if err != nil || len(diagnostic) != 0 {
+		t.Fatalf("actual Go SDK graph: %v\n%s", err, diagnostic)
+	}
+	// Independent accounting of the actual graph, not a replacement for the
+	// producer's role/lifetime checks. Macro-source inputs can add further bytes.
+	seen := make(map[string]bool)
+	var sourceBytes, packageLocalBytes, exportBytes int64
+	packages := 0
+	decoder := json.NewDecoder(bytes.NewReader(output))
+	for {
+		var pkg amd64OriginalListPackage
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		packages++
+		entries, err := os.ReadDir(pkg.Dir)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, entry := range entries {
+			if entry.IsDir() {
+				continue
+			}
+			info, err := entry.Info()
+			if err != nil {
+				t.Fatal(err)
+			}
+			packageLocalBytes += info.Size()
+		}
+		var packageBytes int64
+		if err := filepath.WalkDir(pkg.Dir, func(path string, entry fs.DirEntry, err error) error {
+			if err != nil || entry.IsDir() || seen[path] {
+				return err
+			}
+			info, err := entry.Info()
+			if err != nil {
+				return err
+			}
+			if !info.Mode().IsRegular() {
+				t.Fatalf("nonregular original SDK fixture member: %s", path)
+			}
+			seen[path] = true
+			packageBytes += info.Size()
+			return nil
+		}); err != nil {
+			t.Fatal(err)
+		}
+		sourceBytes += packageBytes
+		var compiledBytes int64
+		if pkg.Export != "" && !seen[pkg.Export] {
+			info, err := os.Stat(pkg.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			seen[pkg.Export] = true
+			compiledBytes = info.Size()
+			exportBytes += compiledBytes
+		}
+		if packageBytes+compiledBytes >= 1<<20 {
+			t.Logf("actual package=%s complete-source=%d export=%d", pkg.ImportPath, packageBytes, compiledBytes)
+		}
+	}
+	driver, err := os.Stat(request.GoBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual graph packages=%d complete-source=%d exports=%d driver=%d total-floor=%d (registered macro sources additional)",
+		packages, sourceBytes, exportBytes, driver.Size(), sourceBytes+exportBytes+driver.Size())
+	t.Logf("actual graph direct package members=%d; local-members/exports/driver floor=%d (SDK include closure additional)",
+		packageLocalBytes, packageLocalBytes+exportBytes+driver.Size())
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatalf("original-Go accepted SDK graph must retain a complete bounded observation: %v", err)
+	}
+	defer func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	}()
+	if crypto {
+		if _, exists := observed.state.packages["crypto/tls"]; exists {
+			t.Fatal("fixture unexpectedly imports the unrelated descendant package")
+		}
+		root := observed.state.environment["GOROOT"]
+		if observed.state.files.hashes[filepath.Join(root, "src", "crypto", "tls", "tls.go")] != "" {
+			t.Fatal("SDK ancestor imported an unrelated descendant's contents")
+		}
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/gotoolprofile/amd64_original_cpp_alias_test.go b/gotoolprofile/amd64_original_cpp_alias_test.go
new file mode 100644
index 000000000..62d34609b
--- /dev/null
+++ b/gotoolprofile/amd64_original_cpp_alias_test.go
@@ -0,0 +1,58 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAMD64OriginalCPPUsesVerifiedPhysicalPackageDirectory(t *testing.T) {
+	for _, role := range []string{"root", "nested"} {
+		t.Run(role, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, role)
+			physical := request.Directory
+			root := physical
+			if role == "nested" {
+				root = filepath.Dir(filepath.Dir(physical))
+			}
+			alias := filepath.Join(t.TempDir(), "selected")
+			if err := os.Symlink(root, alias); err != nil {
+				t.Fatal(err)
+			}
+			request.Directory = alias
+			if role == "nested" {
+				request.Directory = filepath.Join(alias, "internal", "kernel")
+			}
+			request.Environment = replaceEnv(request.Environment, map[string]string{"PWD": request.Directory})
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			selected := observed.state.packages[request.PackagePath]
+			resolved, err := filepath.EvalSymlinks(selected.Dir)
+			if err != nil || resolved != physical {
+				t.Fatalf("actual package lost its verified physical identity: %q; %v", selected.Dir, err)
+			}
+			assembly := filepath.Join(physical, "value_amd64.s")
+			proof, present := observed.state.files.cpp[assembly]
+			if !present || len(proof.Inputs) != 2 || proof.Inputs[0] != assembly || proof.Expanded == "" {
+				t.Fatalf("CPP did not retain the actual assembly and active tool header: %#v", proof)
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Remove(alias); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Symlink(t.TempDir(), alias); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("redirected package alias retained the old source observation")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_original_driver_unix_test.go b/gotoolprofile/amd64_original_driver_unix_test.go
new file mode 100644
index 000000000..23c4500cc
--- /dev/null
+++ b/gotoolprofile/amd64_original_driver_unix_test.go
@@ -0,0 +1,31 @@
+//go:build unix
+
+package gotoolprofile
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestAMD64OriginalObservationFixtureCanonicalDriver(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	if err := os.Symlink(binary, filepath.Join(dir, "go")); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("PATH", dir+string(os.PathListSeparator)+os.Getenv("PATH"))
+	request := amd64OriginalObservationFixture(t, "numeric")
+	physical, err := filepath.EvalSymlinks(request.GoBinary)
+	if err != nil || physical != request.GoBinary {
+		t.Fatalf("fixture supplied a redirected driver to the strict actual-object factory: %v", err)
+	}
+}
diff --git a/gotoolprofile/amd64_original_fixed_local.go b/gotoolprofile/amd64_original_fixed_local.go
new file mode 100644
index 000000000..e99f4fa22
--- /dev/null
+++ b/gotoolprofile/amd64_original_fixed_local.go
@@ -0,0 +1,154 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// AMD64OriginalFixedLocalBinding owns a separate actual Go object capability.
+// The query-only observation does not become a frame certificate: the existing
+// root factory and binder independently check every source/declaration/object
+// and all native initialization, address, CFG and relocation requirements.
+// The owned-main route retains its existing source domain. The distinct
+// downloaded route independently binds complete exact module/ZIP origins,
+// imported sources and compiler exports. Neither route grants new DATA,
+// dynamic-frame, native-entry or pointee permissions.
+type AMD64OriginalFixedLocalBinding struct {
+	mu         sync.Mutex
+	owner      *AMD64OriginalPackageObservation
+	generation uint64
+	source     *plan9asm.GoAMD64FrameSource
+	closed     bool
+}
+
+func (observed *AMD64OriginalPackageObservation) BindFixedLocal(ctx context.Context, pkg plan9asm.GoPackage,
+	file *plan9asm.File, assembly string, options plan9asm.Options,
+) (plan9asm.Options, *AMD64OriginalFixedLocalBinding, error) {
+	return observed.bindFixedLocal(ctx, pkg, file, assembly, options, false)
+}
+
+// BindDownloadedFixedLocal uses a separate independent exact-source object
+// factory. Query observations and caller metadata cannot supply its frame role.
+func (observed *AMD64OriginalPackageObservation) BindDownloadedFixedLocal(ctx context.Context, pkg plan9asm.GoPackage,
+	file *plan9asm.File, assembly string, options plan9asm.Options,
+) (plan9asm.Options, *AMD64OriginalFixedLocalBinding, error) {
+	return observed.bindFixedLocal(ctx, pkg, file, assembly, options, true)
+}
+
+func (observed *AMD64OriginalPackageObservation) bindFixedLocal(ctx context.Context, pkg plan9asm.GoPackage,
+	file *plan9asm.File, assembly string, options plan9asm.Options, exact bool,
+) (_ plan9asm.Options, _ *AMD64OriginalFixedLocalBinding, result error) {
+	if err := observed.Verify(ctx); err != nil {
+		return plan9asm.Options{}, nil, err
+	}
+	observed.mu.Lock()
+	request, generation, ready := observed.request, observed.generation, observed.ready
+	downloaded := observed.downloaded != nil
+	var sourceModule, sourceVersion string
+	if downloaded && observed.downloaded.primary != nil {
+		sourceModule = observed.downloaded.primary.sourceModule
+		sourceVersion = observed.downloaded.primary.sourceVersion
+	}
+	observed.mu.Unlock()
+	if downloaded && !exact {
+		return plan9asm.Options{}, nil, fmt.Errorf("%w: downloaded source needs a separately reviewed actual frame/object handoff", plan9asm.ErrProbeNeedsContext)
+	}
+	if exact && (!downloaded || sourceModule == "" || sourceVersion == "") {
+		return plan9asm.Options{}, nil, fmt.Errorf("%w: exact downloaded binding requires its private original source identity", plan9asm.ErrProbeNeedsContext)
+	}
+	if !ready || pkg.Path != request.PackagePath {
+		return plan9asm.Options{}, nil, fmt.Errorf("original fixed-local package identity differs")
+	}
+	capture := plan9asm.GoAMD64FrameCaptureRequest{
+		GoBinary: request.GoBinary, Directory: request.Directory, AssemblyFile: assembly,
+		Target: request.Target, Environment: append([]string(nil), request.Environment...),
+	}
+	var source *plan9asm.GoAMD64FrameSource
+	var err error
+	if exact {
+		source, err = plan9asm.CaptureGoAMD64DownloadedFrameSource(ctx, pkg, plan9asm.GoAMD64DownloadedFrameCaptureRequest{
+			Original: capture, SourceModule: sourceModule, SourceVersion: sourceVersion,
+		})
+	} else {
+		source, err = plan9asm.CaptureGoAMD64FrameSource(ctx, pkg, capture)
+	}
+	if err != nil {
+		return plan9asm.Options{}, nil, err
+	}
+	// Neither a resolver nor any other external command runs under owner.mu.
+	// A callback closing this observation must revoke the eventual handoff.
+	defer func() {
+		if result != nil {
+			if err := source.Close(); err != nil {
+				result = errors.Join(result, err)
+			}
+		}
+	}()
+	bound, err := source.BindFixedLocal(ctx, pkg, file, options)
+	if err != nil {
+		return plan9asm.Options{}, nil, err
+	}
+	if err := observed.Verify(ctx); err != nil {
+		return plan9asm.Options{}, nil, err
+	}
+	lease := &AMD64OriginalFixedLocalBinding{owner: observed, generation: generation, source: source}
+	observed.mu.Lock()
+	defer observed.mu.Unlock()
+	if !observed.ready || observed.generation != generation {
+		return plan9asm.Options{}, nil, fmt.Errorf("original observation was revoked during actual frame capture")
+	}
+	observed.fixedLocal = append(observed.fixedLocal, lease)
+	return bound, lease, nil
+}
+
+// Verify closes over both independent observations. A failed owner Verify
+// permanently revokes every attached actual-object capability as well.
+func (binding *AMD64OriginalFixedLocalBinding) Verify(ctx context.Context) error {
+	if binding == nil {
+		return fmt.Errorf("missing original fixed-local binding")
+	}
+	binding.mu.Lock()
+	owner, source, generation, closed := binding.owner, binding.source, binding.generation, binding.closed
+	binding.mu.Unlock()
+	if closed || owner == nil || source == nil {
+		return fmt.Errorf("original fixed-local binding is closed")
+	}
+	if err := owner.Verify(ctx); err != nil {
+		return err
+	}
+	owner.mu.Lock()
+	ready := owner.ready && owner.generation == generation
+	owner.mu.Unlock()
+	if !ready {
+		return fmt.Errorf("original fixed-local owner generation changed")
+	}
+	return source.Verify(ctx)
+}
+
+func (binding *AMD64OriginalFixedLocalBinding) Close() error {
+	if binding == nil {
+		return nil
+	}
+	binding.mu.Lock()
+	binding.closed = true
+	source := binding.source
+	binding.mu.Unlock()
+	if source == nil {
+		return nil
+	}
+	return source.Close()
+}
+
+func closeAMD64OriginalFixedLocal(bindings []*AMD64OriginalFixedLocalBinding) error {
+	var result error
+	for _, binding := range bindings {
+		if err := binding.Close(); err != nil {
+			result = errors.Join(result, err)
+		}
+	}
+	return result
+}
diff --git a/gotoolprofile/amd64_original_fixed_local_test.go b/gotoolprofile/amd64_original_fixed_local_test.go
new file mode 100644
index 000000000..d37f3b269
--- /dev/null
+++ b/gotoolprofile/amd64_original_fixed_local_test.go
@@ -0,0 +1,470 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+)
+
+func amd64OriginalFixedLocalFixture(t *testing.T) (AMD64OriginalObservationRequest, plan9asm.GoPackage, *plan9asm.File, plan9asm.Options, string) {
+	t.Helper()
+	request := amd64OriginalObservationFixture(t, "numeric")
+	declaration := "package observation\nfunc Value(a,b,c,d uint64) uint64\n"
+	assembly := `#include "textflag.h"
+#include "local.h"
+TEXT ·Value(SB),NOSPLIT,$160-40
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),CX
+MOVQ c+16(FP),DX
+MOVQ d+24(FP),BX
+MOVQ SP,R11
+MOVQ $31,R9
+NOTQ R9
+ANDQ R9,SP
+ADDQ $ADVANCE,SP
+MOVQ R11,96(SP)
+MOVQ AX,16(SP)
+MOVQ CX,24(SP)
+MOVQ DX,48(SP)
+MOVQ BX,56(SP)
+MOVOU 48(SP),X0
+PADDL 16(SP),X0
+MOVQ X0,AX
+MOVQ 96(SP),R11
+MOVQ R11,SP
+MOVQ AX,ret+32(FP)
+RET
+`
+	for name, source := range map[string]string{"value.go": declaration, "value_amd64.s": assembly, "local.h": "#define ADVANCE 32\n"} {
+		if err := os.WriteFile(filepath.Join(request.Directory, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, filepath.Join(request.Directory, "value.go"), declaration, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check(request.PackagePath, fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := plan9asm.DeriveGoFuncABI0Signature(request.PackagePath+".Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The existing root factory independently reconstructs the same actual CPP.
+	expanded := strings.Replace(assembly, "#include \"textflag.h\"", "#define NOSPLIT 4", 1)
+	expanded = strings.Replace(expanded, "#include \"local.h\"", "#define ADVANCE 32", 1)
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, expanded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := plan9asm.GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{syntax}}
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", typed.Path()+".", 1) },
+		Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig},
+	}
+	return request, pkg, file, options, expanded
+}
+
+func amd64OriginalFixedLocalAPIs(t *testing.T, pkg plan9asm.GoPackage, file *plan9asm.File, options plan9asm.Options, assembly string, wantContext bool, nativeBacking ...bool) {
+	t.Helper()
+	if len(nativeBacking) > 1 {
+		t.Fatal("ambiguous expected frame backing")
+	}
+	wantNative := len(nativeBacking) == 0 || nativeBacking[0]
+	check := func(t *testing.T, ir string, err error) {
+		t.Helper()
+		if wantContext {
+			if err == nil || ir != "" {
+				t.Fatalf("revoked or unbound original source retained permission: %v", err)
+			}
+		} else if err != nil || ir == "" || strings.Contains(ir, "fixed_local_native") != wantNative {
+			t.Fatalf("original source backing native=%t differs: %v", wantNative, err)
+		}
+	}
+	t.Run("Translate", func(t *testing.T) {
+		ir, err := plan9asm.Translate(file, options)
+		check(t, ir, err)
+	})
+	t.Run("Module", func(t *testing.T) {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := plan9asm.TranslateModuleInContext(ctx, file, options)
+		ir := ""
+		if !module.IsNil() {
+			defer module.Dispose()
+			ir = module.String()
+		}
+		check(t, ir, err)
+	})
+	t.Run("GoModule", func(t *testing.T) {
+		translated, err := plan9asm.TranslateGoModule(pkg, []byte(assembly), plan9asm.GoModuleOptions{
+			GOOS: "linux", GOARCH: "amd64", TargetTriple: options.TargetTriple,
+			ResolveSym: options.ResolveSym, Sizes: types.SizesFor("gc", "amd64"),
+			ManualSig: func(name string) (plan9asm.FuncSig, bool) { sig, found := options.Sigs[name]; return sig, found },
+		})
+		ir := ""
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+			ir = translated.Module.String()
+		}
+		check(t, ir, err)
+	})
+}
+
+func TestAMD64OriginalFixedLocalIndependentFactoryAndRevocation(t *testing.T) {
+	for _, axis := range []string{"close-owner", "close-binding", "source", "export", "selection", "metadata", "include", "expired"} {
+		t.Run(axis, func(t *testing.T) {
+			request, pkg, file, options, assembly := amd64OriginalFixedLocalFixture(t)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			amd64OriginalFixedLocalAPIs(t, pkg, file, options, assembly, true)
+			bound, binding, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := binding.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			amd64OriginalFixedLocalAPIs(t, pkg, file, bound, assembly, false)
+			switch axis {
+			case "close-owner":
+				if err := observed.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "close-binding":
+				if err := binding.Close(); err != nil {
+					t.Fatal(err)
+				}
+			case "expired":
+				cancel()
+			case "export":
+				export := observed.state.packages[request.PackagePath].Export
+				cache := originalObservationEnvironment(request.Environment, "GOCACHE")
+				relative, err := filepath.Rel(cache, export)
+				if err != nil || !filepath.IsLocal(relative) {
+					t.Fatal("export mutation is not in the explicitly owned fixture cache")
+				}
+				original, err := os.ReadFile(export)
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Cleanup(func() {
+					if err := os.WriteFile(export, original, 0600); err != nil {
+						t.Error(err)
+					}
+				})
+				if err := os.WriteFile(export, append(append([]byte(nil), original...), 0), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "source":
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package observation\nfunc Value(a,b,c,d int64) uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "selection":
+				if err := os.WriteFile(filepath.Join(request.Directory, "late.go"), []byte("package observation\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "metadata":
+				if err := os.WriteFile(filepath.Join(request.Directory, "go.mod"), []byte("module example.invalid/changed\ngo 1.20\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "include":
+				if err := os.WriteFile(filepath.Join(request.Directory, "local.h"), []byte("#define ADVANCE 64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := binding.Verify(ctx); err == nil {
+				t.Fatal("changed/closed observation retained its owning actual-object binding")
+			}
+			amd64OriginalFixedLocalAPIs(t, pkg, file, bound, assembly, true)
+		})
+	}
+}
+
+func TestAMD64OriginalFixedLocalQueryAndJSONCannotMintPermission(t *testing.T) {
+	request, pkg, file, options, assembly := amd64OriginalFixedLocalFixture(t)
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	bound, _, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, axis := range []string{"options", "owner", "binding", "different-file", "changed-layout"} {
+		t.Run(axis, func(t *testing.T) {
+			switch axis {
+			case "options":
+				data, err := json.Marshal(bound.Sigs)
+				if err != nil {
+					t.Fatal(err)
+				}
+				changed := options
+				if err := json.Unmarshal(data, &changed.Sigs); err != nil {
+					t.Fatal(err)
+				}
+				amd64OriginalFixedLocalAPIs(t, pkg, file, changed, assembly, true)
+			case "owner":
+				var unbound AMD64OriginalPackageObservation
+				if _, _, err := unbound.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options); err == nil {
+					t.Fatal("zero owner minted a source capability")
+				}
+			case "binding":
+				var unbound AMD64OriginalFixedLocalBinding
+				if err := unbound.Verify(ctx); err == nil {
+					t.Fatal("zero binding became ready")
+				}
+			case "different-file":
+				changed, err := plan9asm.Parse(plan9asm.ArchAMD64, strings.Replace(assembly, "PADDL", "PADDQ", 1))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, _, err := observed.BindFixedLocal(ctx, pkg, changed, "value_amd64.s", options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("source mutation accepted: %v", err)
+				}
+			case "changed-layout":
+				changed := options
+				changed.Sigs = make(map[string]plan9asm.FuncSig)
+				for name, sig := range options.Sigs {
+					sig.Frame.Params = append([]plan9asm.FrameSlot(nil), sig.Frame.Params...)
+					sig.Frame.Params[0].Offset++
+					changed.Sigs[name] = sig
+				}
+				if _, _, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", changed); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("layout mutation accepted: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalFixedLocalResolverMayCloseOwner(t *testing.T) {
+	if os.Getenv("PLAN9ASM_ORIGINAL_FIXED_LOCAL_REENTRANT") != "1" {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+		defer cancel()
+		stdout, stderr, err := RunBounded(ctx, "", replaceEnv(os.Environ(), map[string]string{"PLAN9ASM_ORIGINAL_FIXED_LOCAL_REENTRANT": "1"}),
+			os.Args[0], "-test.run=^TestAMD64OriginalFixedLocalResolverMayCloseOwner$", "-test.timeout=50s", "-test.v")
+		if err != nil {
+			t.Fatalf("actual reentrant observer child failed: %v\n%s%s", err, stdout, stderr)
+		}
+		return
+	}
+	request, pkg, file, options, _ := amd64OriginalFixedLocalFixture(t)
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	resolve := options.ResolveSym
+	options.ResolveSym = func(symbol string) string {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+		return resolve(symbol)
+	}
+	if _, binding, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options); err == nil || binding != nil {
+		t.Fatalf("reentrant Close was ignored: %v", err)
+	}
+}
+
+func TestAMD64OriginalFixedLocalBroaderObservationRetainsFactoryContext(t *testing.T) {
+	for _, role := range []string{"nested", "bodyful", "import", "sdk-import", "data", "sibling", "pointer"} {
+		t.Run(role, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, role)
+			if role == "pointer" {
+				if err := os.WriteFile(filepath.Join(request.Directory, "value.go"),
+					[]byte("package observation\nfunc Value(a *uint64) uint64\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			actual := observed.state.packages[request.PackagePath]
+			set := token.NewFileSet()
+			var syntax []*ast.File
+			for _, name := range actual.GoFiles {
+				file, err := parser.ParseFile(set, filepath.Join(actual.Dir, name), nil, 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				syntax = append(syntax, file)
+			}
+			imports := importer.ForCompiler(set, "gc", func(path string) (io.ReadCloser, error) {
+				if mapped, found := actual.ImportMap[path]; found {
+					path = mapped
+				}
+				return os.Open(observed.state.packages[path].Export)
+			})
+			sizes := types.SizesFor("gc", "amd64")
+			typed, err := (&types.Config{Importer: imports, Sizes: sizes}).Check(request.PackagePath, set, syntax, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := plan9asm.GoPackage{Path: typed.Path(), Types: typed, Syntax: syntax}
+			sig, err := plan9asm.DeriveGoFuncABI0Signature(pkg.Path+".Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := os.ReadFile(filepath.Join(actual.Dir, "value_amd64.s"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1))
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", pkg.Path+".", 1) },
+				Sigs:       map[string]plan9asm.FuncSig{sig.Name: sig}}
+			bound, binding, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+			if role == "bodyful" || role == "import" || role == "sdk-import" || role == "data" {
+				// Complete ordinary declarations are independently compiled and
+				// rechecked. They add no native permission beyond this actual
+				// numeric frame and its existing full-source proof.
+				if err != nil || binding == nil {
+					t.Fatalf("original numeric source lost complete %s handoff: %v", role, err)
+				}
+				if err := binding.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				amd64OriginalFixedLocalAPIs(t, pkg, file, bound,
+					strings.Replace(string(data), "#include \"textflag.h\"", "#define NOSPLIT 4", 1), false)
+				if role == "data" {
+					amd64OriginalDataSiblingRevocation(t, ctx, request.Directory, binding.Verify)
+					if _, lease, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options); err == nil || lease != nil {
+						t.Fatal("restored DATA sibling revived the revoked frame", err)
+					}
+				}
+				return
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || binding != nil {
+				t.Fatalf("query-only %s role expanded numeric factory admission: %v", role, err)
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalFixedLocalOwnedArtifactReplacementFailsCleanupAndRevokes(t *testing.T) {
+	request, pkg, file, options, assembly := amd64OriginalFixedLocalFixture(t)
+	private, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	request.Environment = replaceEnv(request.Environment, map[string]string{"TMPDIR": private})
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	bound, _, err := observed.BindFixedLocal(ctx, pkg, file, "value_amd64.s", options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directories, err := filepath.Glob(filepath.Join(private, "plan9asm-go-frame-object-*"))
+	if err != nil || len(directories) != 1 {
+		t.Fatalf("actual factory-owned artifact identity not unique: %v %v", directories, err)
+	}
+	original := directories[0]
+	if err := os.Rename(original, original+".saved"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(original, 0700); err != nil {
+		t.Fatal(err)
+	}
+	marker := filepath.Join(original, "replacement-must-survive")
+	if err := os.WriteFile(marker, []byte("not the observer-owned directory"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Close(); err == nil {
+		t.Fatal("changed owned artifact identity suppressed cleanup failure")
+	}
+	if _, err := os.Stat(marker); err != nil {
+		t.Fatalf("cleanup deleted a replacement directory: %v", err)
+	}
+	amd64OriginalFixedLocalAPIs(t, pkg, file, bound, assembly, true)
+}
+
+// DATA in an unrequested sibling adds no frame or storage authority, but its
+// bytes remain part of the complete live source owner.
+func amd64OriginalDataSiblingRevocation(t *testing.T, ctx context.Context, directory string, verify func(context.Context) error) {
+	t.Helper()
+	if err := ctx.Err(); err != nil {
+		t.Fatal("source-revocation context expired before its positive control", err)
+	}
+	if err := verify(ctx); err != nil {
+		t.Fatal("DATA sibling mutation needs an initially valid source lease", err)
+	}
+	name := filepath.Join(directory, "data_amd64.s")
+	before, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info, err := os.Stat(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chmod(name, 0600); err != nil {
+		t.Fatal(err)
+	}
+	restore := func() {
+		if err := os.Chmod(name, 0600); err != nil {
+			t.Error(err)
+			return
+		}
+		if err := os.WriteFile(name, before, 0600); err != nil {
+			t.Error(err)
+		}
+		if err := os.Chmod(name, info.Mode().Perm()); err != nil {
+			t.Error(err)
+		}
+	}
+	defer restore()
+	if err := os.WriteFile(name, append(append([]byte(nil), before...), '\n'), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := ctx.Err(); err != nil {
+		t.Fatal("source-revocation context expired", err)
+	}
+	if err := verify(ctx); err == nil || ctx.Err() != nil {
+		t.Fatal("changed DATA sibling did not revoke its live frame lease", err, ctx.Err())
+	}
+	restore()
+	if err := verify(ctx); err == nil || ctx.Err() != nil {
+		t.Fatal("restoring DATA sibling bytes did not retain its live revocation", err, ctx.Err())
+	}
+}
diff --git a/gotoolprofile/amd64_original_module_dependency_test.go b/gotoolprofile/amd64_original_module_dependency_test.go
new file mode 100644
index 000000000..92be47a31
--- /dev/null
+++ b/gotoolprofile/amd64_original_module_dependency_test.go
@@ -0,0 +1,139 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func amd64OriginalModuleDependencyFixture(t *testing.T, target string) (AMD64OriginalObservationRequest, string) {
+	t.Helper()
+	request := amd64OriginalObservationFixture(t, "nested")
+	goos, _, _ := strings.Cut(target, "/")
+	request.Target = target
+	request.Environment = replaceEnv(request.Environment, map[string]string{"GOOS": goos})
+	root := filepath.Dir(filepath.Dir(request.Directory))
+	dependency := filepath.Join(root, "internal", "dependency")
+	if err := os.Mkdir(dependency, 0700); err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		filepath.Join(request.Directory, "value.go"): `package observation
+import dependency "example.invalid/observation/internal/dependency"
+type Pair struct { Padding [3]uint64; High uint64 }
+func Value(a uint64) uint64
+func Reference(p *dependency.Pair) uint64 { return dependency.Read(p) }
+`,
+		filepath.Join(dependency, "dependency.go"): `package dependency
+type Pair struct { Low, High uint64 }
+func Read(p *Pair) uint64
+`,
+		filepath.Join(dependency, "local.h"): "#define DEPENDENCY_BIAS 7\n",
+		filepath.Join(dependency, "read_amd64.s"): `#include "textflag.h"
+#include "go_asm.h"
+#include "local.h"
+#ifdef Pair_Padding
+WRONG_PACKAGE_HEADER_NAMESPACE
+#endif
+TEXT ·Read(SB),NOSPLIT,$0-16
+MOVQ p+0(FP),AX
+MOVQ Pair_High(AX),AX
+ADDQ $DEPENDENCY_BIAS,AX
+MOVQ AX,ret+8(FP)
+RET
+`,
+	}
+	for name, source := range files {
+		if err := os.WriteFile(name, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return request, dependency
+}
+
+// The dependency's generated header belongs to its actual compiler export,
+// not to the root's ordinary CPP or private local frame. A same-named root
+// layout deliberately has a different offset; stock Go must select the
+// dependency's own namespace before the observation can be accepted.
+func TestAMD64OriginalObservationActualModuleDependencyRoles(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			request, dependency := amd64OriginalModuleDependencyFixture(t, target)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			stdout, diagnostic, err := RunBounded(ctx, request.Directory, request.Environment,
+				request.GoBinary, "list", "-export", "-mod=readonly", ".")
+			if err != nil || strings.TrimSpace(string(stdout)) != request.PackagePath || len(diagnostic) != 0 {
+				t.Fatalf("stock Go rejects the dependency's original generated header: %v\n%s\n%s", err, stdout, diagnostic)
+			}
+			t.Logf("ORIGINAL_MODULE_DEPENDENCY_EXPORT target=%s package=%s", target, request.PackagePath)
+
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil || observed == nil {
+				t.Fatalf("dependency CPP was confused with the ordinary root: %v", err)
+			}
+			t.Cleanup(func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			state := observed.state
+			dep := state.packages["example.invalid/observation/internal/dependency"]
+			if dep.Standard || dep.Module == nil || dep.Export == "" || dep.Dir != dependency {
+				t.Fatalf("actual dependency source/export role was lost: %+v", dep)
+			}
+			assembly := filepath.Join(dependency, "read_amd64.s")
+			if _, exists := state.files.cpp[assembly]; exists {
+				t.Fatal("dependency acquired ordinary root CPP authority")
+			}
+			if _, exists := state.files.cpp[filepath.Join(request.Directory, "value_amd64.s")]; !exists {
+				t.Fatal("root lost its independent ordinary CPP observation")
+			}
+			if _, exists := state.declarations["Read"]; exists {
+				t.Fatal("dependency declaration became a root frame declaration")
+			}
+
+			// Corrupt only private witness hashes, never the shared toolchain or
+			// compiler cache. Every retained role must participate in verification.
+			for role, name := range map[string]string{
+				"Go source": filepath.Join(dependency, "dependency.go"),
+				"ASM":       assembly,
+				"header":    filepath.Join(dependency, "local.h"),
+				"export":    dep.Export,
+			} {
+				prior := state.files.hashes[name]
+				if prior == "" {
+					t.Fatalf("dependency %s lacks its original-byte guard", role)
+				}
+				state.files.hashes[name] = strings.Repeat("0", 64)
+				err := state.files.verify()
+				state.files.hashes[name] = prior
+				if err == nil {
+					t.Fatalf("dependency %s mutation escaped verification", role)
+				}
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatalf("complete unchanged source/export graph failed independent recheck: %v", err)
+			}
+
+			// Exercise real private source changes as well as witness mutation.
+			// Never overwrite an actual compiler-cache export or SDK file.
+			changed := map[string]string{
+				"linux/amd64":   filepath.Join(dependency, "dependency.go"),
+				"darwin/amd64":  assembly,
+				"windows/amd64": filepath.Join(dependency, "local.h"),
+			}[target]
+			original, err := os.ReadFile(changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(changed, append(original, '\n'), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("changed dependency source retained its public original observation")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_original_observation.go b/gotoolprofile/amd64_original_observation.go
new file mode 100644
index 000000000..7e9cbd09f
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation.go
@@ -0,0 +1,276 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// AMD64OriginalObservationRequest observes an owned main module, not a signed
+// external archive. It has no signatures, frames, pointer bounds or permission
+// inputs. External/foreign and instrumentation roles require a separate sealed
+// source handoff; this initial producer never silently uses their baseline.
+type AMD64OriginalObservationRequest struct {
+	GoBinary, Directory, PackagePath, Target string
+	Environment                              []string
+}
+
+// AMD64OriginalPackageObservation is only an actual source/export observation.
+// No JSON representation, public Options or FrameSource conversion exists.
+// In particular, it grants no local backing, incoming frame, caller, alias,
+// allocation, initialization, native-memory or ABI authority.
+type AMD64OriginalPackageObservation struct {
+	mu         sync.Mutex
+	ready      bool
+	generation uint64
+	request    AMD64OriginalObservationRequest
+	run        Runner
+	state      *amd64OriginalObservationState
+	downloaded *amd64DownloadedSources
+	fixedLocal []*AMD64OriginalFixedLocalBinding
+}
+
+type amd64OriginalObservationState struct {
+	profile              *Observation
+	environment, context map[string]string
+	packages             map[string]amd64OriginalListPackage
+	declarations         map[string]string
+	files                *amd64OriginalObservationFiles
+}
+
+// CaptureAMD64OriginalPackageObservation compiles exports only. It never runs
+// package initialization or any third-party program. Runner is the existing
+// trusted bounded actual-command seam, not a user-supplied verification token.
+func CaptureAMD64OriginalPackageObservation(ctx context.Context, request AMD64OriginalObservationRequest, run Runner) (*AMD64OriginalPackageObservation, error) {
+	return captureAMD64OriginalPackageObservation(ctx, request, nil, run)
+}
+
+func captureAMD64OriginalPackageObservation(ctx context.Context, request AMD64OriginalObservationRequest, downloaded *amd64DownloadedSources, run Runner) (*AMD64OriginalPackageObservation, error) {
+	if err := validateAMD64OriginalObservationRequest(ctx, request, run); err != nil {
+		return nil, err
+	}
+	request.Environment = append([]string(nil), request.Environment...)
+	state, err := captureAMD64OriginalObservationState(ctx, request, downloaded, run)
+	if err != nil {
+		return nil, err
+	}
+	observed := &AMD64OriginalPackageObservation{ready: true, generation: 1, request: request, run: run, state: state, downloaded: downloaded}
+	if err := observed.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return observed, nil
+}
+
+// Verify releases the lock before every external callback. Close or a failed
+// verification permanently revokes this generation, including a verification
+// already in flight; restoring bytes cannot restore the observation.
+func (observed *AMD64OriginalPackageObservation) Verify(ctx context.Context) error {
+	if observed == nil {
+		return fmt.Errorf("missing original package observation")
+	}
+	observed.mu.Lock()
+	ready, generation := observed.ready, observed.generation
+	request, run, expected := observed.request, observed.run, observed.state
+	downloaded := observed.downloaded
+	observed.mu.Unlock()
+	if !ready || expected == nil {
+		return fmt.Errorf("original package observation is closed or revoked")
+	}
+	err := validateAMD64OriginalObservationRequest(ctx, request, run)
+	if err == nil {
+		err = expected.files.verify()
+	}
+	var actual *amd64OriginalObservationState
+	if err == nil {
+		actual, err = captureAMD64OriginalObservationState(ctx, request, downloaded, run)
+	}
+	if err == nil && !equalAMD64OriginalObservationStates(expected, actual) {
+		err = fmt.Errorf("original package source/selection/export/profile changed")
+	}
+	observed.mu.Lock()
+	if !observed.ready || generation != observed.generation {
+		observed.mu.Unlock()
+		return fmt.Errorf("original package observation was revoked during verification")
+	}
+	var revoked []*AMD64OriginalFixedLocalBinding
+	if err != nil {
+		observed.ready = false
+		observed.generation++
+		revoked, observed.fixedLocal = observed.fixedLocal, nil
+	}
+	observed.mu.Unlock()
+	if closeErr := closeAMD64OriginalFixedLocal(revoked); closeErr != nil {
+		err = errors.Join(err, closeErr)
+	}
+	return err
+}
+
+func (observed *AMD64OriginalPackageObservation) Close() error {
+	if observed == nil {
+		return nil
+	}
+	observed.mu.Lock()
+	observed.ready = false
+	observed.generation++
+	bindings := observed.fixedLocal
+	observed.fixedLocal = nil
+	observed.mu.Unlock()
+	return closeAMD64OriginalFixedLocal(bindings)
+}
+
+func validateAMD64OriginalObservationRequest(ctx context.Context, request AMD64OriginalObservationRequest, run Runner) error {
+	if ctx == nil || ctx.Err() != nil || run == nil || !filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) {
+		return fmt.Errorf("original observation needs a live bounded actual Go invocation")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return fmt.Errorf("original observation needs a bounded context")
+	}
+	if request.Target != "linux/amd64" && request.Target != "darwin/amd64" && request.Target != "windows/amd64" ||
+		request.PackagePath == "" || strings.ContainsAny(request.PackagePath, "@ \\\t\r\n") {
+		return fmt.Errorf("invalid original AMD64 package/target")
+	}
+	env := make(map[string]string)
+	for _, item := range request.Environment {
+		key, value, valid := strings.Cut(item, "=")
+		if !valid || key == "" || strings.ContainsRune(item, '\x00') {
+			return fmt.Errorf("incomplete original command environment")
+		}
+		if _, duplicate := env[key]; duplicate {
+			return fmt.Errorf("duplicate original command environment: %s", key)
+		}
+		env[key] = value
+	}
+	goos, _, _ := strings.Cut(request.Target, "/")
+	for key, wanted := range map[string]string{"GOOS": goos, "GOARCH": "amd64", "CGO_ENABLED": "0", "GOFLAGS": "", "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local"} {
+		if value, present := env[key]; !present || value != wanted {
+			return fmt.Errorf("%w: ordinary observation requires exact %s=%q", plan9asm.ErrProbeNeedsContext, key, wanted)
+		}
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(env[key]) {
+			return fmt.Errorf("original observation needs explicit owned %s", key)
+		}
+	}
+	return nil
+}
+
+func captureAMD64OriginalObservationState(ctx context.Context, request AMD64OriginalObservationRequest, downloaded *amd64DownloadedSources, run Runner) (_ *amd64OriginalObservationState, result error) {
+	if downloaded != nil {
+		if err := downloaded.verify(); err != nil {
+			return nil, err
+		}
+	}
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, request.GoBinary, request.Directory, request.Environment, run)
+	if err != nil {
+		return nil, err
+	}
+	if actual["GOOS"]+"/"+actual["GOARCH"] != request.Target || actual["CGO_ENABLED"] != "0" || commandContext["GOFLAGS"] != "" {
+		return nil, fmt.Errorf("actual original environment differs from its ordinary profile")
+	}
+	tmp := originalObservationEnvironment(request.Environment, "GOTMPDIR")
+	marker, err := os.MkdirTemp(tmp, "amd64-original-observation-")
+	if err != nil {
+		return nil, err
+	}
+	owned, err := os.Lstat(marker)
+	if err != nil {
+		return nil, err
+	}
+	created := marker
+	defer func() {
+		info, err := os.Lstat(created)
+		if err != nil || !info.IsDir() || !os.SameFile(owned, info) {
+			result = errors.Join(result, fmt.Errorf("owned observation marker directory identity changed"))
+		} else if err := os.RemoveAll(created); err != nil {
+			result = errors.Join(result, err)
+		}
+	}()
+	marker, err = sourcepath.Resolve(created)
+	if err != nil {
+		return nil, err
+	}
+	profile, err := Capture(ctx, request.GoBinary, marker, request.Environment, request.Target, map[string]string{"GOAMD64": actual["GOAMD64"], "GOEXPERIMENT": actual["GOEXPERIMENT"]}, run)
+	if err != nil {
+		return nil, err
+	}
+	if err := Validate(profile); err != nil {
+		return nil, err
+	}
+	state := &amd64OriginalObservationState{profile: profile, environment: actual, context: commandContext, files: newAMD64OriginalObservationFiles()}
+	before, err := captureAMD64OriginalGraph(ctx, request, actual, profile, state.files, downloaded, false, run)
+	if err != nil {
+		return nil, err
+	}
+	after, err := captureAMD64OriginalGraph(ctx, request, actual, profile, state.files, downloaded, true, run)
+	if err != nil {
+		return nil, fmt.Errorf("capture original package selection after export: %w", err)
+	}
+	if !equalAMD64OriginalSelections(before, after) {
+		return nil, fmt.Errorf("original package selection changed during export")
+	}
+	state.packages = after
+	state.declarations, err = checkAMD64OriginalDeclarations(after, request.PackagePath)
+	if err != nil {
+		return nil, err
+	}
+	now, nowContext, err := instrumentationObserverEnvironment(ctx, request.GoBinary, request.Directory, request.Environment, run)
+	if err != nil {
+		return nil, fmt.Errorf("recapture original package environment: %w", err)
+	}
+	if !reflect.DeepEqual(now, actual) || !reflect.DeepEqual(nowContext, commandContext) {
+		return nil, fmt.Errorf("original package environment changed during capture")
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, request.GoBinary, request.Environment, actual, run)
+	if err != nil {
+		return nil, fmt.Errorf("recapture original Go tools: %w", err)
+	}
+	if tools.directory != profile.ToolDirectory || tools.routing != profile.ToolRoutingSHA256 || tools.dispatcher != profile.ToolDispatcherSHA256 ||
+		!reflect.DeepEqual(tools.digests, profile.ToolBinarySHA256) || !reflect.DeepEqual(tools.origins, profile.ToolBinaryOrigins) {
+		return nil, fmt.Errorf("actual Go tool routing/bytes changed during export")
+	}
+	for file, digest := range profile.ToolSourceSHA256 {
+		path := filepath.Join(actual["GOROOT"], filepath.FromSlash(file))
+		if err := state.files.retain(path); err != nil {
+			return nil, fmt.Errorf("retain registered SDK source %s: %w", file, err)
+		}
+		if state.files.hashes[path] != digest {
+			return nil, fmt.Errorf("registered SDK source changed: %s", file)
+		}
+	}
+	if err := state.files.retainTool(request.GoBinary); err != nil {
+		return nil, fmt.Errorf("retain actual Go driver: %w", err)
+	}
+	if state.files.hashes[request.GoBinary] != profile.DriverSHA256 {
+		return nil, fmt.Errorf("actual Go driver changed during capture")
+	}
+	if downloaded != nil {
+		if err := downloaded.verify(); err != nil {
+			return nil, err
+		}
+	}
+	return state, state.files.verify()
+}
+
+func equalAMD64OriginalObservationStates(a, b *amd64OriginalObservationState) bool {
+	if a == nil || b == nil || len(a.files.directories) != len(b.files.directories) {
+		return false
+	}
+	for name, info := range a.files.directories {
+		other, present := b.files.directories[name]
+		if !present || !os.SameFile(info, other) {
+			return false
+		}
+	}
+	return reflect.DeepEqual(a.profile, b.profile) && reflect.DeepEqual(a.environment, b.environment) &&
+		reflect.DeepEqual(a.context, b.context) && reflect.DeepEqual(a.packages, b.packages) && reflect.DeepEqual(a.declarations, b.declarations) &&
+		reflect.DeepEqual(a.files.hashes, b.files.hashes) && reflect.DeepEqual(a.files.paths, b.files.paths) &&
+		reflect.DeepEqual(a.files.entries, b.files.entries) && reflect.DeepEqual(a.files.cpp, b.files.cpp)
+}
diff --git a/gotoolprofile/amd64_original_observation_budget_test.go b/gotoolprofile/amd64_original_observation_budget_test.go
new file mode 100644
index 000000000..de8352820
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_budget_test.go
@@ -0,0 +1,52 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAMD64OriginalObservationLargeAssemblyRetainsSourceGuard(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "nested")
+	assembly := filepath.Join(request.Directory, "value_amd64.s")
+	original, err := os.ReadFile(assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(original) + strings.Repeat("// generated source padding\n", 120000)
+	if len(source) <= 2<<20 || len(source) >= 8<<20 {
+		t.Fatalf("fixture lost its large-source boundary: %d bytes", len(source))
+	}
+	if err := os.WriteFile(assembly, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	stdout, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+		"list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", request.PackagePath)
+	if err != nil || len(stdout) == 0 || len(stderr) != 0 {
+		t.Fatalf("actual Go rejected large original assembly: %v; %s", err, stderr)
+	}
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if observed.state.files.hashes[assembly] != bytesSHA256([]byte(source)) || observed.state.files.cpp[assembly].Expanded == "" {
+		t.Fatal("large-source allowance lost actual original bytes or CPP consumption")
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(assembly, []byte(source+"// changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Verify(ctx); err == nil {
+		t.Fatal("large original source mutation did not revoke its observation")
+	}
+}
diff --git a/gotoolprofile/amd64_original_observation_cpp.go b/gotoolprofile/amd64_original_observation_cpp.go
new file mode 100644
index 000000000..1c4bd1481
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_cpp.go
@@ -0,0 +1,116 @@
+package gotoolprofile
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// This is an observation of the actual active input stack, not a list of
+// possible includes and not a generated-header or frame authority. The fixed
+// original package search and registered ordinary cmd/asm defines are shared
+// with the existing CPP consumer. Unclosed roles remain needs-context.
+func captureAMD64OriginalCPP(pkg amd64OriginalListPackage, root, goRoot string, profile *Observation, files *amd64OriginalObservationFiles) error {
+	if len(pkg.SFiles) == 0 {
+		return nil
+	}
+	macros, err := CaptureAssemblerMacros(goRoot, profile, pkg.ImportPath)
+	if err != nil {
+		return err
+	}
+	if err := ValidateOrdinaryAssemblerMacros(macros, profile, pkg.ImportPath); err != nil {
+		return fmt.Errorf("%w: original CPP package role is not closed: %v", plan9asm.ErrProbeNeedsContext, err)
+	}
+	for file, digest := range macros.ToolSourceSHA256 {
+		name, err := CPPRegularSource(goRoot, file)
+		if err != nil {
+			return err
+		}
+		if err := files.retain(name); err != nil || files.hashes[name] != digest {
+			return fmt.Errorf("original CPP assembler registration changed: %s", file)
+		}
+	}
+	for _, file := range pkg.SFiles {
+		assembly, err := filepath.Rel(root, filepath.Join(pkg.Dir, file))
+		if err != nil || !CPPLocalSource(filepath.ToSlash(assembly)) {
+			return fmt.Errorf("original selected CPP assembly has no closed source origin")
+		}
+		assembly = filepath.ToSlash(assembly)
+		source, err := CPPRegularSource(root, assembly)
+		if err != nil {
+			return err
+		}
+		opened, err := os.Open(source)
+		if err != nil {
+			return err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(opened, AssemblySourceByteLimit+1))
+		if err := errors.Join(readErr, opened.Close()); err != nil {
+			return fmt.Errorf("read bounded original CPP assembly: %w", err)
+		}
+		if len(data) > AssemblySourceByteLimit {
+			return fmt.Errorf("original CPP assembly is missing or exceeds its byte bound")
+		}
+		used, bytes := []string{source}, len(data)
+		expanded, err := plan9asm.PreprocessAssemblySource(string(data), plan9asm.AssemblyPreprocessOptions{
+			FileName: source, Defines: macros.Defines,
+			ReadInclude: func(parent, include string) (string, []byte, error) {
+				module, tool, err := CPPIncludeCandidates(assembly, include)
+				if err != nil || !CPPLocalSource(module) || path.Clean(include) == "go_asm.h" {
+					return "", nil, fmt.Errorf("%w: active CPP include is escaping, generated or unknown", plan9asm.ErrProbeNeedsContext)
+				}
+				name := filepath.Join(root, filepath.FromSlash(module))
+				if err := files.directory(filepath.Dir(name), false); err != nil {
+					return "", nil, fmt.Errorf("%w: active CPP search directory is not closed: %v", plan9asm.ErrProbeNeedsContext, err)
+				}
+				if _, err := os.Lstat(name); os.IsNotExist(err) {
+					if !CPPLocalSource(tool) {
+						return "", nil, fmt.Errorf("%w: active CPP tool search escapes its source origin", plan9asm.ErrProbeNeedsContext)
+					}
+					name, err = CPPRegularSource(goRoot, tool)
+					if err != nil {
+						return "", nil, err
+					}
+					if err := files.directory(filepath.Dir(name), false); err != nil {
+						return "", nil, err
+					}
+				} else if err != nil {
+					return "", nil, err
+				} else {
+					name, err = CPPRegularSource(root, module)
+					if err != nil {
+						return "", nil, err
+					}
+				}
+				if err := files.retain(name); err != nil {
+					return "", nil, err
+				}
+				data, err := os.ReadFile(name)
+				bytes += len(data)
+				if err != nil || len(data) > 2<<20 || bytes > 16<<20 || len(used) >= 4096 {
+					return "", nil, fmt.Errorf("original active CPP inputs exceed their bound or cannot be read")
+				}
+				used = append(used, name)
+				return name, data, nil
+			},
+		})
+		if err != nil {
+			return fmt.Errorf("%w: actual original CPP cannot be closed: %v", plan9asm.ErrProbeNeedsContext, err)
+		}
+		if len(expanded) > 16<<20 {
+			return fmt.Errorf("original expanded CPP exceeds its byte bound")
+		}
+		proof := amd64OriginalCPPObservation{Expanded: bytesSHA256([]byte(expanded)), Inputs: used}
+		if prior, present := files.cpp[source]; present && !reflect.DeepEqual(prior, proof) {
+			return fmt.Errorf("actual original active CPP input/expansion changed during export")
+		}
+		files.cpp[source] = proof
+	}
+	return nil
+}
diff --git a/gotoolprofile/amd64_original_observation_files.go b/gotoolprofile/amd64_original_observation_files.go
new file mode 100644
index 000000000..b354150c3
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_files.go
@@ -0,0 +1,49 @@
+package gotoolprofile
+
+import (
+	"os"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// The shared snapshot owns filesystem validation. This adapter retains only
+// the existing observation views and this producer's distinct CPP records.
+type amd64OriginalObservationFiles struct {
+	snapshot      *gooriginalsrc.Snapshot
+	hashes, paths map[string]string
+	entries       map[string][]string
+	directories   map[string]os.FileInfo
+	cpp           map[string]amd64OriginalCPPObservation
+}
+
+type amd64OriginalCPPObservation struct {
+	Expanded string
+	Inputs   []string
+}
+
+func newAMD64OriginalObservationFiles() *amd64OriginalObservationFiles {
+	snapshot := gooriginalsrc.NewSnapshot()
+	view := snapshot.View()
+	return &amd64OriginalObservationFiles{snapshot: snapshot, hashes: view.Hashes,
+		paths: view.Paths, entries: view.Entries, directories: view.Directories,
+		cpp: make(map[string]amd64OriginalCPPObservation)}
+}
+
+func (files *amd64OriginalObservationFiles) retain(name string) error {
+	return files.snapshot.Retain(name)
+}
+
+func (files *amd64OriginalObservationFiles) retainTool(name string) error {
+	return files.snapshot.RetainTool(name)
+}
+
+func (files *amd64OriginalObservationFiles) directory(name string, recursive bool) error {
+	return files.snapshot.Directory(name, recursive)
+}
+
+func (files *amd64OriginalObservationFiles) verify() error {
+	if files == nil {
+		return (*gooriginalsrc.Snapshot)(nil).Verify()
+	}
+	return files.snapshot.Verify()
+}
diff --git a/gotoolprofile/amd64_original_observation_graph.go b/gotoolprofile/amd64_original_observation_graph.go
new file mode 100644
index 000000000..1cc5f5568
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_graph.go
@@ -0,0 +1,329 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/modfile"
+)
+
+type amd64OriginalListModule struct {
+	Path, Version, Dir, GoMod, GoVersion string
+	Main                                 bool
+	Replace                              *amd64OriginalListModule
+}
+
+type amd64OriginalListPackage struct {
+	instrumentationTypeListPackage
+	Standard bool
+	Module   *amd64OriginalListModule
+}
+
+func captureAMD64OriginalGraph(ctx context.Context, request AMD64OriginalObservationRequest, actual map[string]string, profile *Observation, files *amd64OriginalObservationFiles, downloaded *amd64DownloadedSources, export bool, run Runner) (map[string]amd64OriginalListPackage, error) {
+	args := []string{"list", "-deps", "-compiled", "-json", "-mod=readonly"}
+	if export {
+		args = append(args, "-export")
+	}
+	stdout, stderr, err := downloaded.runList(ctx, request, run, append(args, request.PackagePath)...)
+	if err != nil || len(stderr) != 0 || len(stdout) == 0 || len(stdout) > commandOutputLimit {
+		return nil, fmt.Errorf("actual original Go graph failed: %v; %s", err, stderr)
+	}
+	packages := make(map[string]amd64OriginalListPackage)
+	decoder := json.NewDecoder(bytes.NewReader(stdout))
+	for {
+		var pkg amd64OriginalListPackage
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		if len(packages) >= 4096 || pkg.ImportPath == "" || !token.IsIdentifier(pkg.Name) || pkg.Name == "_" {
+			return nil, fmt.Errorf("invalid or over-bound original package graph")
+		}
+		if _, duplicate := packages[pkg.ImportPath]; duplicate {
+			return nil, fmt.Errorf("duplicate original package graph member")
+		}
+		if pkg.Incomplete || len(pkg.Error)+len(pkg.DepsErrors) != 0 || pkg.ForTest != "" ||
+			len(pkg.CgoFiles)+len(pkg.CFiles)+len(pkg.CXXFiles)+len(pkg.FFiles)+len(pkg.SwigFiles)+len(pkg.SwigCXXFiles)+len(pkg.EmbedFiles)+len(pkg.EmbedPatterns) != 0 {
+			return nil, fmt.Errorf("%w: original observation has unknown/native/generated/test/embed roles", plan9asm.ErrProbeNeedsContext)
+		}
+		packages[pkg.ImportPath] = pkg
+	}
+	selected, present := packages[request.PackagePath]
+	legacy := downloaded != nil && downloaded.primary.legacy()
+	if !present || selected.Standard || selected.Module == nil || selected.Module.Replace != nil ||
+		!legacy && (!selected.Module.Main || selected.Module.Version != "") {
+		return nil, fmt.Errorf("%w: original observation needs an owned main, not external/foreign/SDK source identity", plan9asm.ErrProbeNeedsContext)
+	}
+	module := selected.Module
+	root, err := sourcepath.Resolve(module.Dir)
+	if err != nil {
+		return nil, err
+	}
+	for _, forbidden := range []string{actual["GOROOT"], originalObservationEnvironment(request.Environment, "GOMODCACHE")} {
+		physical, err := sourcepath.Resolve(forbidden)
+		if err != nil {
+			return nil, err
+		}
+		if relative, err := filepath.Rel(physical, root); err == nil && filepath.IsLocal(relative) {
+			if downloaded != nil && forbidden != actual["GOROOT"] && downloaded.primary.matchesPrimary(module) {
+				continue
+			}
+			return nil, fmt.Errorf("%w: cached external or SDK source cannot acquire an owned-main role", plan9asm.ErrProbeNeedsContext)
+		}
+	}
+	if downloaded != nil && !downloaded.primary.matchesPrimary(module) {
+		return nil, fmt.Errorf("actual primary source differs from the exact original download handoff")
+	}
+	goMod, err := sourcepath.Resolve(module.GoMod)
+	wantedGoMod := filepath.Join(root, "go.mod")
+	if legacy {
+		wantedGoMod = downloaded.primary.goMod
+	}
+	if err != nil || goMod != wantedGoMod {
+		return nil, fmt.Errorf("actual main module lost its original go.mod")
+	}
+	if err := files.retain(goMod); err != nil {
+		return nil, err
+	}
+	data, err := os.ReadFile(goMod)
+	if err != nil {
+		return nil, err
+	}
+	parsed, err := modfile.Parse(goMod, data, nil)
+	if err != nil || parsed.Module == nil || parsed.Module.Mod.Path != module.Path {
+		return nil, fmt.Errorf("actual main module declaration differs from Go selection")
+	}
+	declaredVersion := ""
+	if parsed.Go != nil {
+		declaredVersion = parsed.Go.Version
+	}
+	if gooriginalsrc.SelectedGoVersion(declaredVersion, !legacy) != module.GoVersion {
+		return nil, fmt.Errorf("%w: actual module language is not closed by its original go.mod", plan9asm.ErrProbeNeedsContext)
+	}
+	if err := files.directory(root, false); err != nil {
+		return nil, err
+	}
+	if _, err := os.Lstat(filepath.Join(root, "go.sum")); !os.IsNotExist(err) {
+		if err := files.retain(filepath.Join(root, "go.sum")); err != nil {
+			return nil, err
+		}
+	}
+	for path, pkg := range packages {
+		base, relative := filepath.Join(actual["GOROOT"], "src"), path
+		if pkg.Module != nil {
+			if pkg.Standard {
+				return nil, fmt.Errorf("SDK package acquired a module source role")
+			}
+			base = root
+			if downloaded != nil {
+				source, err := downloaded.module(pkg.Module)
+				if err != nil {
+					return nil, err
+				}
+				base = source.root
+			} else if !reflect.DeepEqual(pkg.Module, module) {
+				return nil, fmt.Errorf("%w: foreign/replaced module source needs authenticated handoff", plan9asm.ErrProbeNeedsContext)
+			}
+			relative = strings.TrimPrefix(path, pkg.Module.Path+"/")
+			if path == pkg.Module.Path {
+				relative = "."
+			} else if relative == path {
+				return nil, fmt.Errorf("main package path does not match its actual module directory")
+			}
+		} else if !pkg.Standard {
+			return nil, fmt.Errorf("%w: dependency has no actual stock-stdlib/module role", plan9asm.ErrProbeNeedsContext)
+		}
+		if !filepath.IsLocal(filepath.FromSlash(relative)) {
+			return nil, fmt.Errorf("original package path escapes its actual source root")
+		}
+		dir, err := sourcepath.Resolve(pkg.Dir)
+		wanted, wantedErr := sourcepath.Resolve(filepath.Join(base, filepath.FromSlash(relative)))
+		if err != nil || wantedErr != nil || dir != wanted {
+			return nil, fmt.Errorf("original package physical directory does not match actual source identity")
+		}
+		goFiles := instrumentationTypeNames(pkg.GoFiles, dir, base)
+		compiled := instrumentationTypeNames(pkg.CompiledGoFiles, dir, base)
+		if path == "unsafe" && pkg.Module == nil && pkg.Name == "unsafe" {
+			compiled = goFiles // cmd/go does not compile the builtin package.
+		}
+		if goFiles == nil || len(goFiles) == 0 || !reflect.DeepEqual(goFiles, compiled) || len(goFiles) > 32768 {
+			return nil, fmt.Errorf("%w: original graph lacks complete ordinary compiler files", plan9asm.ErrProbeNeedsContext)
+		}
+		if err := retainAMD64OriginalPackageDirectory(pkg, dir, files); err != nil {
+			return nil, err
+		}
+		if err := replayAMD64OriginalSelection(pkg, dir, profile); err != nil {
+			return nil, err
+		}
+		if pkg.Standard {
+			if err := captureAMD64OriginalSDKDependency(pkg, actual["GOROOT"], profile, files); err != nil {
+				return nil, err
+			}
+		} else {
+			// Use the verified physical directory for relative CPP paths. The
+			// packages map retains Go's original spelling for later replay.
+			pkg.Dir = dir
+			if path != request.PackagePath && reflect.DeepEqual(pkg.Module, module) {
+				if err := captureAMD64OriginalModuleDependency(pkg, base, actual["GOROOT"], profile, files); err != nil {
+					return nil, err
+				}
+			} else if err := captureAMD64OriginalCPP(pkg, base, actual["GOROOT"], profile, files); err != nil {
+				return nil, err
+			}
+		}
+		if export && path != "unsafe" {
+			cache, cacheErr := sourcepath.Resolve(actual["GOCACHE"])
+			resolved, resolveErr := sourcepath.Resolve(pkg.Export)
+			rel, relErr := filepath.Rel(cache, resolved)
+			if cacheErr != nil || resolveErr != nil || relErr != nil || !filepath.IsLocal(rel) {
+				return nil, fmt.Errorf("original actual export is missing or outside its bound cache")
+			}
+			if err := files.retain(pkg.Export); err != nil {
+				return nil, err
+			}
+		}
+		for _, imported := range pkg.Imports {
+			if _, present := packages[imported]; !present {
+				return nil, fmt.Errorf("original graph omitted an actual import/export")
+			}
+		}
+		for _, imported := range pkg.ImportMap {
+			if _, present := packages[imported]; !present {
+				return nil, fmt.Errorf("original graph has an unbound ImportMap target")
+			}
+		}
+	}
+	selectedDir, err := sourcepath.Resolve(selected.Dir)
+	requestedDir, requestErr := sourcepath.Resolve(request.Directory)
+	if err != nil || requestErr != nil || selectedDir != requestedDir || len(selected.SFiles) == 0 {
+		return nil, fmt.Errorf("original selected assembly package differs from the requested directory")
+	}
+	return packages, nil
+}
+
+func equalAMD64OriginalSelections(a, b map[string]amd64OriginalListPackage) bool {
+	withoutExports := make(map[string]amd64OriginalListPackage, len(b))
+	for path, pkg := range b {
+		pkg.Export = ""
+		withoutExports[path] = pkg
+	}
+	return reflect.DeepEqual(a, withoutExports)
+}
+
+func checkAMD64OriginalDeclarations(packages map[string]amd64OriginalListPackage, path string) (map[string]string, error) {
+	pkg := packages[path]
+	set := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range pkg.CompiledGoFiles {
+		if !filepath.IsAbs(name) {
+			name = filepath.Join(pkg.Dir, name)
+		}
+		file, err := parser.ParseFile(set, name, nil, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		syntax = append(syntax, file)
+	}
+	actualImporter := importer.ForCompiler(set, "gc", func(path string) (io.ReadCloser, error) {
+		if target, mapped := pkg.ImportMap[path]; mapped {
+			path = target
+		}
+		dependency, present := packages[path]
+		if !present || dependency.Export == "" {
+			return nil, fmt.Errorf("missing actual selected compiler export: %s", path)
+		}
+		return os.Open(dependency.Export)
+	})
+	version := "go" + pkg.Module.GoVersion // Independently matched to original go.mod.
+	if pkg.Module.GoVersion == "" {
+		version = "go1.16" // Actual dependency default, not the query main's language.
+	}
+	typed, err := (&types.Config{Importer: actualImporter, Sizes: types.SizesFor("gc", "amd64"), GoVersion: version}).Check(path, set, syntax, nil)
+	if err != nil {
+		return nil, fmt.Errorf("original full compiler-source typecheck failed: %w", err)
+	}
+	declarations := make(map[string]string)
+	for _, file := range syntax {
+		for _, declaration := range file.Decls {
+			if function, ok := declaration.(*ast.FuncDecl); ok && function.Recv == nil && function.Body == nil {
+				object := typed.Scope().Lookup(function.Name.Name)
+				if object == nil {
+					return nil, fmt.Errorf("original assembly declaration lacks its actual checked type")
+				}
+				declarations[function.Name.Name] = types.TypeString(object.Type(), func(p *types.Package) string { return p.Path() })
+			}
+		}
+	}
+	return declarations, nil
+}
+
+func originalObservationEnvironment(env []string, key string) string {
+	for _, item := range env {
+		if strings.HasPrefix(item, key+"=") {
+			return strings.TrimPrefix(item, key+"=")
+		}
+	}
+	return ""
+}
+
+func replayAMD64OriginalSelection(pkg amd64OriginalListPackage, directory string, profile *Observation) error {
+	selection, err := ordinaryPackageSelectionContext(&ConsumerInput{Observed: profile}, nil)
+	if err != nil {
+		return err
+	}
+	selection.OpenFile = nil // MatchFile consumes the guarded actual source.
+	entries, err := os.ReadDir(directory)
+	if err != nil {
+		return err
+	}
+	var goFiles, asmFiles []string
+	for _, entry := range entries {
+		name := entry.Name()
+		if entry.IsDir() || filepath.Ext(name) != ".go" && filepath.Ext(name) != ".s" || strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		selected, err := selection.MatchFile(directory, name)
+		if err != nil {
+			return err
+		}
+		if !selected {
+			continue
+		}
+		if filepath.Ext(name) == ".s" {
+			asmFiles = append(asmFiles, name)
+			continue
+		}
+		source, err := parser.ParseFile(token.NewFileSet(), filepath.Join(directory, name), nil, parser.ImportsOnly)
+		if err != nil || source.Name.Name != pkg.Name {
+			return fmt.Errorf("original package clause/import source differs from actual Go")
+		}
+		for _, imported := range source.Imports {
+			path, err := strconv.Unquote(imported.Path.Value)
+			if err != nil || path == "C" {
+				return fmt.Errorf("%w: original source has an unclosed CGO import role", plan9asm.ErrProbeNeedsContext)
+			}
+		}
+		goFiles = append(goFiles, name)
+	}
+	if !equalDiscoveryStrings(goFiles, pkg.GoFiles) || !equalDiscoveryStrings(asmFiles, pkg.SFiles) {
+		return fmt.Errorf("actual original Go/ASM selection differs from independent full-directory replay")
+	}
+	return nil
+}
diff --git a/gotoolprofile/amd64_original_observation_test.go b/gotoolprofile/amd64_original_observation_test.go
new file mode 100644
index 000000000..4076de0b0
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_test.go
@@ -0,0 +1,586 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func amd64OriginalObservationFixture(t *testing.T, variant string) AMD64OriginalObservationRequest {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir, path := root, "example.invalid/observation"
+	if variant == "nested" {
+		dir, path = filepath.Join(root, "internal", "kernel"), path+"/internal/kernel"
+		if err := os.MkdirAll(dir, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	source := "package observation\nfunc Value(a uint64) uint64\n"
+	if variant == "bodyful" {
+		source += "func Reference(a uint64) uint64 { return a + 1 }\n"
+	} else if variant == "import" {
+		source = "package observation\nimport _ \"math/bits\"\nfunc Value(a uint64) uint64\n"
+	} else if variant == "sdk-import" {
+		source = "package observation\nimport \"errors\"\nfunc Value(a uint64) uint64\n" +
+			"func Error() error { return errors.New(\"first-party witness\") }\n"
+	}
+	files := map[string]string{
+		filepath.Join(root, "go.mod"):  "module example.invalid/observation\ngo 1.20\n",
+		filepath.Join(dir, "value.go"): source,
+		filepath.Join(dir, "value_amd64.s"): "#include \"textflag.h\"\nTEXT ·Value(SB),NOSPLIT,$160-16\n" +
+			"MOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nMOVQ 16(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n",
+	}
+	if variant == "data" {
+		files[filepath.Join(dir, "local.h")] = "#define VALUE 1\n"
+		files[filepath.Join(dir, "data_amd64.s")] = "#include \"textflag.h\"\n#include \"local.h\"\nDATA ·constant<>+0(SB)/8,$VALUE\nGLOBL ·constant<>(SB),RODATA|NOPTR,$8\n"
+	}
+	if variant == "sibling" {
+		helper := filepath.Join(root, "helper")
+		if err := os.Mkdir(helper, 0700); err != nil {
+			t.Fatal(err)
+		}
+		files[filepath.Join(helper, "helper.go")] = "package helper\nfunc Reference(a uint64) uint64 { return a + 1 }\n"
+		files[filepath.Join(dir, "value.go")] = "package observation\nimport _ \"example.invalid/observation/helper\"\nfunc Value(a uint64) uint64\n"
+	}
+	for name, data := range files {
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.Abs(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The actual-object factory retains this exact physical input path.
+	// PATH may contain symlinks or noncanonical Windows path casing.
+	binary, err = filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := os.Environ()
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "GOCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(os.Getenv(key)) {
+			env = replaceEnv(env, map[string]string{key: t.TempDir()})
+		}
+	}
+	env = replaceEnv(env, map[string]string{"GOOS": "linux", "GOARCH": "amd64", "CGO_ENABLED": "0", "GOFLAGS": "",
+		"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOPROXY": "off", "GOSUMDB": "off",
+		"GOAMD64": "v1", "GO386": "", "GOARM": "", "GOARM64": "", "GOWASM": "", "GOEXPERIMENT": ""})
+	return AMD64OriginalObservationRequest{GoBinary: binary, Directory: dir, PackagePath: path, Target: "linux/amd64", Environment: env}
+}
+
+func amd64OriginalObservationContext(t *testing.T) (context.Context, context.CancelFunc) {
+	t.Helper()
+	return context.WithTimeout(context.Background(), 5*time.Minute)
+}
+
+func TestAMD64OriginalObservationActualFourRoles(t *testing.T) {
+	for _, variant := range []string{"nested", "bodyful", "import", "data", "sibling"} {
+		t.Run(variant, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			pkg := observed.state.packages[request.PackagePath]
+			if pkg.Module == nil || !pkg.Module.Main || pkg.Module.Version != "" || observed.state.declarations["Value"] != "func(a uint64) uint64" {
+				t.Fatalf("missing actual main/checked declaration identity: %+v, %v", pkg, observed.state.declarations)
+			}
+			if variant == "nested" && pkg.Dir == pkg.Module.Dir || variant == "data" && len(pkg.SFiles) != 2 ||
+				variant == "import" && observed.state.packages["math/bits"].Export == "" {
+				t.Fatalf("original role was lost: %+v", pkg)
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("actual ordinary %s source/export graph: %d packages, %d bound files; observation only", variant, len(observed.state.packages), len(observed.state.files.hashes))
+		})
+	}
+}
+
+func TestAMD64OriginalObservationActualSelectionNegatives(t *testing.T) {
+	for _, name := range []string{"roundtrip control", "paired ASM deletion", "paired Go deletion", "module version", "module language", "module replacement", "foreign dependency", "nonstandard dependency", "wrong physical root", "missing export", "unknown ImportMap", "Cgo", "test", "embed", "unknown diagnostic",
+		"SDK roundtrip control", "SDK nonstandard", "SDK module", "SDK physical root", "SDK Go deletion", "SDK ASM deletion", "SDK missing export"} {
+		t.Run(name, func(t *testing.T) {
+			variant := "data"
+			if strings.HasPrefix(name, "SDK ") {
+				variant = "sdk-import"
+			}
+			request := amd64OriginalObservationFixture(t, variant)
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+				if err != nil || len(args) == 0 || args[0] != "list" || !containsString(args, "-deps") {
+					return stdout, stderr, err
+				}
+				var output bytes.Buffer
+				decoder := json.NewDecoder(bytes.NewReader(stdout))
+				for {
+					var original map[string]json.RawMessage
+					var pkg amd64OriginalListPackage
+					if err := decoder.Decode(&original); err == io.EOF {
+						break
+					} else if err != nil {
+						return nil, nil, err
+					}
+					encoded, err := json.Marshal(original)
+					if err != nil {
+						return nil, nil, err
+					}
+					if err := json.Unmarshal(encoded, &pkg); err != nil {
+						return nil, nil, err
+					}
+					before, err := json.Marshal(pkg)
+					if err != nil {
+						return nil, nil, err
+					}
+					target := request.PackagePath
+					if strings.HasPrefix(name, "SDK ") {
+						target = "runtime"
+					}
+					if pkg.ImportPath == target {
+						changed = true
+						switch name {
+						case "paired ASM deletion":
+							pkg.SFiles = []string{"value_amd64.s"}
+						case "paired Go deletion":
+							pkg.GoFiles, pkg.CompiledGoFiles = nil, nil
+						case "module version":
+							pkg.Module.Version = "v1.0.0"
+						case "module language":
+							pkg.Module.GoVersion = "1.22"
+						case "module replacement":
+							pkg.Module.Replace = &amd64OriginalListModule{Path: "example.invalid/other", Version: "v1.0.0", Dir: request.Directory}
+						case "foreign dependency":
+							pkg.Module.Main = false
+						case "nonstandard dependency":
+							pkg.Module = nil
+						case "wrong physical root":
+							pkg.Dir = filepath.Dir(pkg.Dir)
+						case "missing export":
+							pkg.Export = ""
+						case "unknown ImportMap":
+							pkg.ImportMap = map[string]string{"math/bits": "example.invalid/missing"}
+						case "Cgo":
+							pkg.CgoFiles = []string{"value.go"}
+						case "test":
+							pkg.ForTest = request.PackagePath
+						case "embed":
+							pkg.EmbedFiles = []string{"value.go"}
+						case "unknown diagnostic":
+							stderr = []byte("unregistered successful diagnostic\n")
+						case "SDK nonstandard":
+							pkg.Standard = false
+						case "SDK module":
+							pkg.Module = &amd64OriginalListModule{Path: "runtime", Dir: pkg.Dir, Main: true}
+						case "SDK physical root":
+							pkg.Dir = request.Directory
+						case "SDK Go deletion":
+							pkg.GoFiles, pkg.CompiledGoFiles = nil, nil
+						case "SDK ASM deletion":
+							pkg.SFiles = nil
+						case "SDK missing export":
+							pkg.Export = ""
+						}
+					}
+					// Preserve the actual Go fields/omissions. Encoding the modeled
+					// struct alone would add Error:null, invalidating every axis for
+					// an unrelated reason. The control proves exact semantic replay.
+					after, err := json.Marshal(pkg)
+					if err != nil {
+						return nil, nil, err
+					}
+					var oldFields, newFields map[string]json.RawMessage
+					if err := json.Unmarshal(before, &oldFields); err != nil {
+						return nil, nil, err
+					}
+					if err := json.Unmarshal(after, &newFields); err != nil {
+						return nil, nil, err
+					}
+					for key, value := range newFields {
+						if !bytes.Equal(oldFields[key], value) {
+							original[key] = value
+						}
+					}
+					if err := json.NewEncoder(&output).Encode(original); err != nil {
+						return nil, nil, err
+					}
+				}
+				return output.Bytes(), stderr, nil
+			}
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, run)
+			if observed != nil {
+				defer observed.Close()
+			}
+			if name == "roundtrip control" || name == "SDK roundtrip control" {
+				if err != nil || observed == nil || !changed {
+					t.Fatalf("actual Go JSON no-change replay failed: %v", err)
+				}
+			} else if err == nil || observed != nil || !changed {
+				t.Fatalf("changed actual source identity/selection was accepted: %v; fixture=%v", err, changed)
+			} else {
+				t.Logf("exact actual-list %s rejection: %v", name, err)
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalObservationMutationAndRevocation(t *testing.T) {
+	for _, name := range []string{"source", "ASM", "header", "go.mod", "absent go.sum", "late file", "export", "source symlink", "directory replacement"} {
+		t.Run(name, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "data")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer observed.Close()
+			file := filepath.Join(request.Directory, "value.go")
+			switch name {
+			case "ASM":
+				file = filepath.Join(request.Directory, "data_amd64.s")
+			case "header":
+				file = filepath.Join(request.Directory, "local.h")
+			case "go.mod":
+				file = filepath.Join(request.Directory, "go.mod")
+			case "absent go.sum":
+				file = filepath.Join(request.Directory, "go.sum")
+			case "late file":
+				file = filepath.Join(request.Directory, "late.go")
+			case "export":
+				// Preserve the cache artifact after this actual mutation test.
+				file = observed.state.packages[request.PackagePath].Export
+			}
+			prior, readErr := os.ReadFile(file)
+			if readErr != nil && !os.IsNotExist(readErr) {
+				t.Fatal(readErr)
+			}
+			if name == "source symlink" {
+				other := filepath.Join(t.TempDir(), "same.go")
+				if err := os.WriteFile(other, prior, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Remove(file); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(other, file); err != nil {
+					t.Fatal(err)
+				}
+			} else if name == "directory replacement" {
+				if err := os.Rename(request.Directory, request.Directory+"-original"); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(request.Directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+			} else if err := os.WriteFile(file, append(prior, []byte("\nchanged\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := observed.Verify(ctx); err == nil {
+				t.Fatal("original input mutation did not revoke the observation")
+			}
+			if name == "export" {
+				if err := os.WriteFile(file, prior, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if observed.ready || observed.Verify(ctx) == nil {
+				t.Fatal("a revoked observation was restored")
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalObservationCloseJSONAndReentrancy(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "bodyful")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	var observed *AMD64OriginalPackageObservation
+	armed := false
+	run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+		if armed {
+			armed = false
+			if err := observed.Close(); err != nil {
+				return nil, nil, err
+			}
+		}
+		return RunBounded(ctx, dir, env, binary, args...)
+	}
+	var err error
+	observed, err = CaptureAMD64OriginalPackageObservation(ctx, request, run)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	data, err := json.Marshal(observed)
+	if err != nil || string(data) != "{}" {
+		t.Fatalf("private observation leaked JSON authority: %s, %v", data, err)
+	}
+	var restored AMD64OriginalPackageObservation
+	if err := json.Unmarshal(data, &restored); err != nil || restored.Verify(ctx) == nil {
+		t.Fatalf("JSON restored observation authority: %v", err)
+	}
+	armed = true
+	if err := observed.Verify(ctx); err == nil || !strings.Contains(err.Error(), "revoked") {
+		t.Fatalf("reentrant Close did not revoke the in-flight verification: %v", err)
+	}
+}
+
+func TestAMD64OriginalObservationRejectsUnboundProfiles(t *testing.T) {
+	for _, value := range []string{"-race", "-msan", "-asan", "-tags=custom"} {
+		t.Run(value, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "bodyful")
+			request.Environment = replaceEnv(request.Environment, map[string]string{"GOFLAGS": value})
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			if observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || observed != nil {
+				t.Fatalf("unbound mode was relabeled ordinary: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalObservationActualForeignSourceNeedsContext(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "bodyful")
+	foreign := t.TempDir()
+	for name, data := range map[string]string{"go.mod": "module example.invalid/foreign\ngo 1.20\n", "foreign.go": "package foreign\nfunc Value() uint64 { return 1 }\n"} {
+		if err := os.WriteFile(filepath.Join(foreign, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	mod := "module example.invalid/observation\ngo 1.20\nrequire example.invalid/foreign v1.0.0\nreplace example.invalid/foreign => " + filepath.ToSlash(foreign) + "\n"
+	if err := os.WriteFile(filepath.Join(request.Directory, "go.mod"), []byte(mod), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(request.Directory, "value.go"), []byte("package observation\nimport _ \"example.invalid/foreign\"\nfunc Value(a uint64) uint64\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	if observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || observed != nil {
+		t.Fatalf("actual foreign/local replacement became a main source or signed identity: %v", err)
+	}
+}
+
+func TestAMD64OriginalObservationRejectsLateSourceAndEnvironment(t *testing.T) {
+	for _, name := range []string{"source", "environment"} {
+		t.Run(name, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "bodyful")
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+				if err != nil {
+					return stdout, stderr, err
+				}
+				if !changed && len(args) > 0 && args[0] == "list" && containsString(args, "-deps") && containsString(args, "-export") {
+					changed = true
+					if name == "source" {
+						file := filepath.Join(request.Directory, "value.go")
+						data, err := os.ReadFile(file)
+						if err != nil {
+							return nil, nil, err
+						}
+						if err := os.WriteFile(file, append(data, []byte("\n// late source mutation\n")...), 0600); err != nil {
+							return nil, nil, err
+						}
+					}
+				}
+				if changed && name == "environment" && len(args) > 0 && args[0] == "env" {
+					var actual map[string]string
+					if err := json.Unmarshal(stdout, &actual); err != nil {
+						return nil, nil, err
+					}
+					actual["CGO_ENABLED"] = "1"
+					stdout, err = json.Marshal(actual)
+				}
+				return stdout, stderr, err
+			}
+			if observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, run); err == nil || observed != nil || !changed {
+				t.Fatalf("late original source/environment mutation was accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalObservationEnvironmentCopyAndConcurrentClose(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "bodyful")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer observed.Close()
+	for index, item := range request.Environment {
+		if strings.HasPrefix(item, "GOFLAGS=") {
+			request.Environment[index] = "GOFLAGS=-race"
+		}
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatalf("caller environment slice mutated the sealed invocation: %v", err)
+	}
+	finished := make(chan error, 1)
+	go func() { finished <- observed.Verify(ctx) }()
+	if err := observed.Close(); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case err := <-finished:
+		if err == nil {
+			t.Fatal("concurrent Close did not revoke verification")
+		}
+	case <-ctx.Done():
+		t.Fatal("concurrent verification/Close did not terminate")
+	}
+}
+
+func TestAMD64OriginalObservationActiveIncludeNeedsClosedOrigin(t *testing.T) {
+	for _, inactive := range []bool{false, true} {
+		name := "active"
+		if inactive {
+			name = "inactive control"
+		}
+		t.Run(name, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "data")
+			outside := filepath.Join(filepath.Dir(request.Directory), "outside.h")
+			if err := os.WriteFile(outside, []byte("#define VALUE 1\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			include := "#include \"../outside.h\"\n"
+			if inactive {
+				include = "#ifdef UNDEFINED\n" + include + "#endif\n#define VALUE 1\n"
+			}
+			source := "#include \"textflag.h\"\n" + include + "DATA ·constant<>+0(SB)/8,$VALUE\nGLOBL ·constant<>(SB),RODATA|NOPTR,$8\n"
+			if err := os.WriteFile(filepath.Join(request.Directory, "data_amd64.s"), []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			// Actual original compiler accepts both; outside active inputs are
+			// nevertheless not a closed source origin for this observation.
+			stdout, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+				"list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", request.PackagePath)
+			if err != nil || len(stdout) == 0 || len(stderr) != 0 {
+				t.Fatalf("actual original Go include compilation failed: %v; %s", err, stderr)
+			}
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if observed != nil {
+				defer observed.Close()
+			}
+			if inactive {
+				if err != nil || observed == nil {
+					t.Fatalf("inactive include was treated as actual consumption: %v", err)
+				}
+			} else if !errors.Is(err, plan9asm.ErrProbeNeedsContext) || observed != nil {
+				t.Fatalf("unclosed active source include acquired a complete observation: %v", err)
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalObservationActiveIncludeGuards(t *testing.T) {
+	for _, name := range []string{"same-module control", "header bytes", "paired input deletion", "late header", "generated header"} {
+		t.Run(name, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "nested")
+			root := filepath.Dir(filepath.Dir(request.Directory))
+			header := filepath.Join(root, "shared.h")
+			if err := os.WriteFile(header, []byte("#define VALUE 1\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			include := "#include \"../../shared.h\"\n"
+			if name == "generated header" {
+				include = "#include \"go_asm.h\"\n#define VALUE 1\n"
+			}
+			assembly := filepath.Join(request.Directory, "data_amd64.s")
+			source := "#include \"textflag.h\"\n" + include +
+				"DATA ·constant<>+0(SB)/8,$VALUE\nGLOBL ·constant<>(SB),RODATA|NOPTR,$8\n"
+			if err := os.WriteFile(assembly, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			stdout, stderr, err := RunBounded(ctx, request.Directory, request.Environment, request.GoBinary,
+				"list", "-deps", "-compiled", "-export", "-json", "-mod=readonly", request.PackagePath)
+			if err != nil || len(stdout) == 0 || len(stderr) != 0 {
+				t.Fatalf("actual original Go include export failed: %v; %s", err, stderr)
+			}
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+				if name == "late header" && !changed && err == nil && len(args) != 0 && args[0] == "list" && containsString(args, "-export") {
+					changed = true
+					err = os.WriteFile(header, []byte("#define VALUE 2\n"), 0600)
+				}
+				return stdout, stderr, err
+			}
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, run)
+			if observed != nil {
+				defer observed.Close()
+			}
+			if name == "generated header" {
+				if observed != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Fatalf("unproved generated include acquired observation: %v", err)
+				}
+				return
+			}
+			if name == "late header" {
+				if observed != nil || err == nil || !changed {
+					t.Fatalf("actual active header changed across export without revocation: %v, %v", err, changed)
+				}
+				return
+			}
+			if err != nil || observed == nil {
+				t.Fatal(err)
+			}
+			proof := observed.state.files.cpp[assembly]
+			if proof.Expanded == "" || !containsString(proof.Inputs, header) || len(proof.Inputs) != 3 || observed.state.files.hashes[header] == "" {
+				t.Fatalf("actual active module/tool input sequence was not bound: %+v", proof)
+			}
+			switch name {
+			case "same-module control":
+				if err := observed.Verify(ctx); err != nil {
+					t.Fatal(err)
+				}
+				return
+			case "header bytes":
+				if err := os.WriteFile(header, []byte("#define VALUE 2\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "paired input deletion":
+				proof.Inputs = proof.Inputs[:2]
+				observed.state.files.cpp[assembly] = proof
+				delete(observed.state.files.hashes, header)
+				delete(observed.state.files.paths, header)
+			}
+			if err := observed.Verify(ctx); err == nil || observed.ready {
+				t.Fatalf("active input mutation/deletion did not revoke the observation: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_original_observation_tool_test.go b/gotoolprofile/amd64_original_observation_tool_test.go
new file mode 100644
index 000000000..ed120cd6e
--- /dev/null
+++ b/gotoolprofile/amd64_original_observation_tool_test.go
@@ -0,0 +1,37 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestAMD64OriginalObservationSelectedToolRole(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := filepath.Join(root, "go")
+	file, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	truncateErr := file.Truncate(17 << 20)
+	closeErr := file.Close()
+	if truncateErr != nil || closeErr != nil {
+		t.Fatal(truncateErr, closeErr)
+	}
+	files := newAMD64OriginalObservationFiles()
+	if err := files.retainTool(name); err != nil {
+		t.Fatal("actual Go/export observation did not retain its selected tool role", err)
+	}
+	if err := files.verify(); err != nil {
+		t.Fatal(err)
+	}
+	if err := newAMD64OriginalObservationFiles().retain(name); err == nil {
+		t.Fatal("selected tool bound leaked into original SDK/source/export retention")
+	}
+	if err := files.retain(name); err == nil {
+		t.Fatal("selected original tool was relabeled as source/export")
+	}
+}
diff --git a/gotoolprofile/amd64_original_package_scope_test.go b/gotoolprofile/amd64_original_package_scope_test.go
new file mode 100644
index 000000000..ee178b8e6
--- /dev/null
+++ b/gotoolprofile/amd64_original_package_scope_test.go
@@ -0,0 +1,85 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAMD64OriginalObservationUnimportedDescendantIsNotACompilerInput(t *testing.T) {
+	request, dependency := amd64OriginalModuleDependencyFixture(t, "linux/amd64")
+	header := filepath.Join(request.Directory, "headers", "value.h")
+	if err := os.MkdirAll(filepath.Dir(header), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(header, []byte("#define SOURCE_DELTA 7\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	assembly := filepath.Join(request.Directory, "value_amd64.s")
+	source, err := os.ReadFile(assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = []byte("#include \"headers/value.h\"\n" + strings.Replace(string(source), "MOVQ AX,ret+8(FP)", "ADDQ $SOURCE_DELTA,AX\nMOVQ AX,ret+8(FP)", 1))
+	if err := os.WriteFile(assembly, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	// The actual compiler does not recursively consume testdata or an
+	// unimported package. Every sparse member remains below the existing
+	// 16 MiB file limit; together they exceed the unchanged 128 MiB graph.
+	unselected := filepath.Join(request.Directory, "testdata", "unused")
+	if err := os.MkdirAll(unselected, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for index := 0; index < 9; index++ {
+		file, err := os.Create(filepath.Join(unselected, fmt.Sprintf("member-%d.dat", index)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		truncateErr := file.Truncate(16 << 20)
+		closeErr := file.Close()
+		if truncateErr != nil || closeErr != nil {
+			t.Fatal(truncateErr, closeErr)
+		}
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	stdout, diagnostic, err := RunBounded(ctx, request.Directory, request.Environment,
+		request.GoBinary, "list", "-export", "-mod=readonly", ".")
+	if err != nil || strings.TrimSpace(string(stdout)) != request.PackagePath || len(diagnostic) != 0 {
+		t.Fatalf("stock Go rejected the complete original source graph: %v\n%s\n%s", err, stdout, diagnostic)
+	}
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if err != nil || observed == nil {
+		t.Fatalf("unconsumed descendants enlarged the actual package source graph: %v", err)
+	}
+	t.Cleanup(func() {
+		if err := observed.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	for _, selected := range []string{assembly, header, filepath.Join(dependency, "dependency.go"), filepath.Join(dependency, "read_amd64.s"), filepath.Join(dependency, "local.h")} {
+		if observed.state.files.hashes[selected] == "" {
+			t.Fatalf("actual source/import/include lost its original guard: %s", selected)
+		}
+	}
+	unused := filepath.Join(unselected, "member-0.dat")
+	if observed.state.files.hashes[unused] != "" {
+		t.Fatal("unconsumed testdata acquired a compiler-input role")
+	}
+	if err := os.WriteFile(unused, []byte("unrelated descendant change\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Verify(ctx); err != nil {
+		t.Fatal("unconsumed descendant change revoked the actual source graph", err)
+	}
+	if err := os.WriteFile(header, []byte("#define SOURCE_DELTA 9\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := observed.Verify(ctx); err == nil {
+		t.Fatal("changed active nested include escaped source verification")
+	}
+}
diff --git a/gotoolprofile/amd64_original_retention_diagnostic_test.go b/gotoolprofile/amd64_original_retention_diagnostic_test.go
new file mode 100644
index 000000000..f8e02a26d
--- /dev/null
+++ b/gotoolprofile/amd64_original_retention_diagnostic_test.go
@@ -0,0 +1,58 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestAMD64OriginalObservationDriverBudgetPreservesCause(t *testing.T) {
+	request := amd64OriginalObservationFixture(t, "driver-budget-cause")
+	// These complete, inert package members fit the original source budget.
+	// The separately selected real Go executable takes the combined graph
+	// over its existing limit. No source, tool bytes or identity are changed.
+	const graphLimit = int64(128 << 20)
+	info, err := os.Stat(request.GoBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sourceBytes := graphLimit - info.Size() + 1
+	if sourceBytes <= 0 {
+		t.Fatal("actual driver exceeds the complete source/tool fixture budget", info.Size())
+	}
+	for index, remaining := 0, sourceBytes; remaining > 0; index++ {
+		extent := int64(16 << 20)
+		if remaining < extent {
+			extent = remaining
+		}
+		file, err := os.Create(filepath.Join(request.Directory, fmt.Sprintf("padding-%d.dat", index)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = file.Truncate(extent)
+		closeErr := file.Close()
+		if err != nil || closeErr != nil {
+			t.Fatal(err, closeErr)
+		}
+		remaining -= extent
+	}
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	stdout, stderr, err := RunBounded(ctx, request.Directory, request.Environment,
+		request.GoBinary, "list", "-export", "-json", "-mod=readonly", request.PackagePath)
+	if err != nil || len(stdout) == 0 || len(stderr) != 0 {
+		t.Fatalf("actual Go must accept unchanged first-party source: %v\n%s", err, stderr)
+	}
+	observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+	if observed != nil {
+		_ = observed.Close()
+		t.Fatal("over-budget observation acquired a source token")
+	}
+	if err == nil || !strings.Contains(err.Error(), "retain actual Go driver") ||
+		!strings.Contains(err.Error(), "byte bound: retained=") || !strings.Contains(err.Error(), "limit=134217728") ||
+		strings.Contains(err.Error(), "driver changed") {
+		t.Fatalf("retention limit must not impersonate a driver identity mutation: %v", err)
+	}
+}
diff --git a/gotoolprofile/amd64_original_sdk_dependency.go b/gotoolprofile/amd64_original_sdk_dependency.go
new file mode 100644
index 000000000..8e8a501a5
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_dependency.go
@@ -0,0 +1,74 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// SDK dependencies supply actual compiler exports and their complete guarded
+// source graph, just as the independent GoAMD64FrameSource declaration-import
+// owner does. They are not ordinary target CPP units: cmd/asm may use special
+// ABI experiment macros and compiler-generated headers in these packages.
+// No expanded source or frame capability is produced for them here.
+func captureAMD64OriginalSDKDependency(pkg amd64OriginalListPackage, goRoot string,
+	profile *Observation, files *amd64OriginalObservationFiles,
+) error {
+	if !pkg.Standard || pkg.Module != nil || !CPPLocalSource(pkg.ImportPath) {
+		return fmt.Errorf("original SDK dependency lacks its actual standard package role")
+	}
+	wanted, err := sourcepath.Resolve(filepath.Join(goRoot, "src", filepath.FromSlash(pkg.ImportPath)))
+	directory, dirErr := sourcepath.Resolve(pkg.Dir)
+	if err != nil || dirErr != nil || directory != wanted || files.directories[directory] == nil {
+		return fmt.Errorf("original SDK dependency lacks its complete bound source directory")
+	}
+	if len(pkg.SFiles) == 0 {
+		return nil
+	}
+	return captureAMD64OriginalDependencyInputs(pkg, goRoot, goRoot, profile, files)
+}
+
+// The graph has already joined this package to the selected root's complete
+// module identity and authenticated source directory. Its assembler contributes
+// only to its own compiler export, never ordinary root CPP or frame authority.
+func captureAMD64OriginalModuleDependency(pkg amd64OriginalListPackage, sourceRoot, goRoot string,
+	profile *Observation, files *amd64OriginalObservationFiles,
+) error {
+	if pkg.Standard || pkg.Module == nil || files.directories[pkg.Dir] == nil {
+		return fmt.Errorf("original module dependency lacks its bound package role")
+	}
+	if len(pkg.SFiles) == 0 {
+		return nil
+	}
+	return captureAMD64OriginalDependencyInputs(pkg, sourceRoot, goRoot, profile, files)
+}
+
+func captureAMD64OriginalDependencyInputs(pkg amd64OriginalListPackage, sourceRoot, goRoot string,
+	profile *Observation, files *amd64OriginalObservationFiles,
+) error {
+	// Capture, rather than broaden the ordinary validator: the registered
+	// actual SDK sources derive any special package macros for this exact
+	// observed environment. Unknown compiler registrations still fail.
+	macros, err := CaptureAssemblerMacros(goRoot, profile, pkg.ImportPath)
+	if err != nil {
+		return err
+	}
+	for file, digest := range macros.ToolSourceSHA256 {
+		name, err := CPPRegularSource(goRoot, file)
+		if err != nil {
+			return err
+		}
+		if err := files.retain(name); err != nil || files.hashes[name] != digest {
+			return fmt.Errorf("original SDK assembler registration changed: %s", file)
+		}
+	}
+	// Package-local source/header inventories were already retained in full.
+	// Also bind the actual shared SDK header directory. Generated go_asm.h is
+	// an input to the independently executed original export, not a fabricated
+	// header/CPP or frame grant to the ordinary module being translated.
+	if err := files.directory(filepath.Join(goRoot, "pkg", "include"), true); err != nil {
+		return err
+	}
+	return captureAMD64DependencyIncludeSources(pkg, sourceRoot, goRoot, files)
+}
diff --git a/gotoolprofile/amd64_original_sdk_dependency_test.go b/gotoolprofile/amd64_original_sdk_dependency_test.go
new file mode 100644
index 000000000..ecdf80cba
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_dependency_test.go
@@ -0,0 +1,101 @@
+package gotoolprofile
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// SDK dependencies are actual source/export inputs, not ordinary third-party
+// ASM packages or owners of the requested function's private local frame.
+// A routine import must not make their special macros impersonate an ordinary
+// package role. The unchanged original Go compiler accepts this complete graph.
+func TestAMD64OriginalObservationActualSDKDependencyRoles(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			request := amd64OriginalObservationFixture(t, "sdk-import")
+			request.Target = target
+			goos, _, _ := strings.Cut(target, "/")
+			request.Environment = replaceEnv(request.Environment, map[string]string{"GOOS": goos})
+			ctx, cancel := amd64OriginalObservationContext(t)
+			defer cancel()
+			output, diagnostic, err := RunBounded(ctx, request.Directory, request.Environment,
+				request.GoBinary, "list", "-export", "-mod=readonly", ".")
+			if err != nil {
+				t.Fatalf("original Go rejects SDK-dependent first-party source: %v\n%s\n%s", err, output, diagnostic)
+			}
+			t.Logf("ORIGINAL_SDK_DEPENDENCY_EXPORT target=%s package=%s", target, strings.TrimSpace(string(output)))
+			observed, err := CaptureAMD64OriginalPackageObservation(ctx, request, RunBounded)
+			if err != nil {
+				t.Fatalf("ordinary root must retain SDK dependencies under their own source/export role: %v", err)
+			}
+			t.Cleanup(func() {
+				if err := observed.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if observed.state.packages["runtime"].Export == "" || observed.state.packages["errors"].Export == "" {
+				t.Fatal("SDK graph vanished instead of retaining its actual compiler exports")
+			}
+			state := observed.state
+			for _, pkg := range state.packages {
+				if !pkg.Standard || pkg.ImportPath == "unsafe" {
+					continue
+				}
+				for _, file := range append(append([]string(nil), pkg.GoFiles...), pkg.SFiles...) {
+					name := filepath.Join(pkg.Dir, file)
+					if state.files.hashes[name] == "" {
+						t.Fatalf("SDK source lost original byte guard: %s", name)
+					}
+					if _, exists := state.files.cpp[name]; exists {
+						t.Fatalf("SDK dependency acquired ordinary target CPP authority: %s", name)
+					}
+				}
+			}
+			if _, exists := state.files.cpp[filepath.Join(request.Directory, "value_amd64.s")]; !exists {
+				t.Fatal("ordinary target lost its independent CPP proof")
+			}
+			goRoot := state.environment["GOROOT"]
+			macros, err := CaptureAssemblerMacros(goRoot, state.profile, "runtime")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if macros.PackageRole == "allow_asm_abi_path" && ValidateOrdinaryAssemblerMacros(macros, state.profile, "runtime") == nil {
+				t.Fatal("special SDK macros became an ordinary target macro permission")
+			}
+			for file, digest := range macros.ToolSourceSHA256 {
+				name, err := CPPRegularSource(goRoot, file)
+				if err != nil || state.files.hashes[name] != digest {
+					t.Fatalf("SDK special macro registration lost exact source guard: %s: %v", file, err)
+				}
+			}
+			if state.files.hashes[filepath.Join(goRoot, "pkg", "include", "textflag.h")] == "" {
+				t.Fatal("actual SDK shared headers lost their lifetime guard")
+			}
+			// Corrupt the private witness, never the shared SDK or Go cache.
+			// Each retained role must participate in the same live byte check.
+			runtimePackage := state.packages["runtime"]
+			for role, name := range map[string]string{
+				"source": filepath.Join(runtimePackage.Dir, runtimePackage.GoFiles[0]),
+				"ASM":    filepath.Join(runtimePackage.Dir, runtimePackage.SFiles[0]),
+				"export": runtimePackage.Export,
+				"tool":   filepath.Join(goRoot, "src", "cmd", "go", "internal", "work", "gc.go"),
+				"header": filepath.Join(goRoot, "pkg", "include", "textflag.h"),
+			} {
+				prior := state.files.hashes[name]
+				if prior == "" {
+					t.Fatalf("missing SDK %s witness", role)
+				}
+				state.files.hashes[name] = strings.Repeat("0", 64)
+				err := state.files.verify()
+				state.files.hashes[name] = prior
+				if err == nil {
+					t.Fatalf("SDK %s witness mutation escaped original-byte verification", role)
+				}
+			}
+			if err := observed.Verify(ctx); err != nil {
+				t.Fatalf("independent SDK source/export/tool recapture: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/amd64_original_sdk_include.go b/gotoolprofile/amd64_original_sdk_include.go
new file mode 100644
index 000000000..9bce9605f
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_include.go
@@ -0,0 +1,134 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// Retain an overapproximation of physical include sources, not a CPP
+// expansion. Every selected SDK assembly uses cmd/asm's fixed package CWD.
+// Literal includes in both conditional branches remain guarded; unclosed
+// dynamic directives fail. Actual Go independently compiles the final export.
+func captureAMD64SDKIncludeSources(pkg amd64OriginalListPackage, goRoot string, files *amd64OriginalObservationFiles) error {
+	return captureAMD64DependencyIncludeSources(pkg, goRoot, goRoot, files)
+}
+
+func captureAMD64DependencyIncludeSources(pkg amd64OriginalListPackage, sourceRoot, goRoot string,
+	files *amd64OriginalObservationFiles,
+) error {
+	var pending []string
+	scheduled := make(map[string]bool)
+	enqueue := func(name string) error {
+		if scheduled[name] {
+			return nil
+		}
+		if len(scheduled) >= 4096 {
+			return fmt.Errorf("SDK include source closure exceeds its file bound")
+		}
+		scheduled[name] = true
+		pending = append(pending, name)
+		return nil
+	}
+	for _, file := range pkg.SFiles {
+		if err := enqueue(filepath.Join(pkg.Dir, file)); err != nil {
+			return err
+		}
+	}
+	bytes := 0
+	for len(pending) != 0 {
+		name := pending[0]
+		pending = pending[1:]
+		data, err := files.snapshot.ReadRetained(name)
+		if err != nil {
+			return err
+		}
+		bytes += len(data)
+		if bytes > 16<<20 {
+			return fmt.Errorf("SDK include source closure exceeds its byte bound")
+		}
+		inventory, err := plan9asm.InspectAssemblyCPPSource(string(data), name, nil)
+		if err != nil {
+			return fmt.Errorf("SDK physical CPP source cannot be closed: %w", err)
+		}
+		for _, record := range inventory.Records {
+			tokens := record.Tokens
+			for index, token := range tokens {
+				if token.Text == "#" && (index != 0 || record.Kind != "directive") {
+					return fmt.Errorf("SDK macro-generated directive has no closed include-source role")
+				}
+			}
+			if len(tokens) < 2 || tokens[0].Text != "#" || tokens[1].Text != "include" {
+				continue
+			}
+			if len(tokens) != 4 || tokens[2].Kind != "string" ||
+				tokens[3].Kind != "newline" && tokens[3].Kind != "eof" {
+				return fmt.Errorf("SDK nonliteral include has no closed source role")
+			}
+			include, err := strconv.Unquote(tokens[2].Text)
+			if err != nil {
+				return err
+			}
+			included, err := retainAMD64DependencyInclude(pkg, sourceRoot, goRoot, include, files)
+			if err != nil {
+				return fmt.Errorf("SDK include %q in %s: %w", include, name, err)
+			}
+			if included != "" {
+				if err := enqueue(included); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func retainAMD64DependencyInclude(pkg amd64OriginalListPackage, sourceRoot, goRoot, include string, files *amd64OriginalObservationFiles) (string, error) {
+	// cmd/asm searches from the package CWD even for nested headers. The
+	// selected source supplies that directory, not the including header.
+	assembly := filepath.ToSlash(filepath.Join("src", pkg.ImportPath, pkg.SFiles[0]))
+	if !pkg.Standard {
+		relative, err := filepath.Rel(sourceRoot, filepath.Join(pkg.Dir, pkg.SFiles[0]))
+		if err != nil || !CPPLocalSource(filepath.ToSlash(relative)) {
+			return "", fmt.Errorf("dependency assembly escapes its actual source root")
+		}
+		assembly = filepath.ToSlash(relative)
+	}
+	preferred, shared, err := CPPIncludeCandidates(assembly, include)
+	if err != nil || !CPPLocalSource(preferred) || !CPPLocalSource(shared) {
+		return "", fmt.Errorf("SDK include escapes its actual source root")
+	}
+	name := filepath.Join(sourceRoot, filepath.FromSlash(preferred))
+	if err := files.directory(filepath.Dir(name), false); err != nil {
+		return "", fmt.Errorf("SDK preferred include directory is not closed: %w", err)
+	}
+	if _, err := os.Lstat(name); os.IsNotExist(err) {
+		// Only this exact compiler-generated header may lack a physical
+		// SDK file. Its properties come from the complete original Go
+		// sources/tools and actual export, never a fabricated CPP header.
+		if include == "go_asm.h" {
+			return "", nil
+		}
+		name, err = CPPRegularSource(goRoot, shared)
+		if err != nil {
+			return "", err
+		}
+	} else if err != nil {
+		return "", err
+	} else {
+		name, err = CPPRegularSource(sourceRoot, preferred)
+		if err != nil {
+			return "", err
+		}
+	}
+	if err := files.directory(filepath.Dir(name), false); err != nil {
+		return "", err
+	}
+	if err := files.retain(name); err != nil {
+		return "", err
+	}
+	return name, nil
+}
diff --git a/gotoolprofile/amd64_original_sdk_include_test.go b/gotoolprofile/amd64_original_sdk_include_test.go
new file mode 100644
index 000000000..4a8e387ad
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_include_test.go
@@ -0,0 +1,294 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This low-level source-retention fixture copies only the original driver
+// registration source files. It is not a public SDK observation or frame owner.
+func sdkDependencyIncludeFixture(t *testing.T, assembly string) (amd64OriginalListPackage, string, *Observation, *amd64OriginalObservationFiles) {
+	t.Helper()
+	request := amd64OriginalObservationFixture(t, "bodyful")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	profile, err := Capture(ctx, request.GoBinary, t.TempDir(), request.Environment, request.Target, nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	macros, err := CaptureAssemblerMacros(runtime.GOROOT(), profile, "fixture/sdk")
+	if err != nil {
+		t.Fatal(err)
+	}
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for source := range macros.ToolSourceSHA256 {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(source)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		writeSDKIncludeFixture(t, root, source, string(data))
+	}
+	writeSDKIncludeFixture(t, root, "src/fixture/sdk/value_amd64.s", assembly)
+	writeSDKIncludeFixture(t, root, "src/fixture/sibling/value.h", "#define VALUE 7\n")
+	writeSDKIncludeFixture(t, root, "pkg/include/shared.h", "#define SHARED 11\n")
+	pkg := amd64OriginalListPackage{Standard: true}
+	pkg.ImportPath, pkg.Dir, pkg.SFiles = "fixture/sdk", filepath.Join(root, "src", "fixture", "sdk"), []string{"value_amd64.s"}
+	files := newAMD64OriginalObservationFiles()
+	if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, files); err != nil {
+		t.Fatal(err)
+	}
+	return pkg, root, profile, files
+}
+
+// These source-only tests do not mint an SDK package or compiler-export role.
+// Actual selected SDK packages and the ordinary consumer are exercised by the
+// independent three-platform observation and factory tests.
+func sdkIncludeSourceFixture(t *testing.T, assembly string, sources map[string]string) (amd64OriginalListPackage, string, *amd64OriginalObservationFiles) {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	writeSDKIncludeFixture(t, root, "src/fixture/sdk/value_amd64.s", assembly)
+	writeSDKIncludeFixture(t, root, "pkg/include/shared.h", "#define SHARED 11\n")
+	for name, source := range sources {
+		writeSDKIncludeFixture(t, root, name, source)
+	}
+	pkg := amd64OriginalListPackage{Standard: true}
+	pkg.ImportPath, pkg.Dir = "fixture/sdk", filepath.Join(root, "src", "fixture", "sdk")
+	pkg.SFiles = []string{"value_amd64.s"}
+	files := newAMD64OriginalObservationFiles()
+	if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, files); err != nil {
+		t.Fatal(err)
+	}
+	if err := files.directory(filepath.Join(root, "pkg", "include"), true); err != nil {
+		t.Fatal(err)
+	}
+	return pkg, root, files
+}
+
+func TestAMD64OriginalSDKIncludeSearchAndMutation(t *testing.T) {
+	for _, test := range []struct {
+		name, assembly string
+		sources        map[string]string
+		retained       []string
+		mutation       string
+	}{
+		{
+			name: "nested package CWD, not including directory",
+			assembly: "#include \"../sibling/outer.h\"\nTEXT ·Value(SB),4,$0-0\n" +
+				"MOVQ $VALUE,AX\nRET\n",
+			sources: map[string]string{
+				"src/fixture/sibling/outer.h":  "#include \"chosen.h\"\n",
+				"src/fixture/sdk/chosen.h":     "#define VALUE 7\n",
+				"src/fixture/sibling/chosen.h": "not valid assembly\n",
+			},
+			retained: []string{"src/fixture/sibling/outer.h", "src/fixture/sdk/chosen.h"},
+			mutation: "src/fixture/sibling/outer.h",
+		},
+		{
+			name:     "shared fallback and late package shadow",
+			assembly: "#include \"shared.h\"\n",
+			retained: []string{"pkg/include/shared.h"},
+			mutation: "src/fixture/sdk/shared.h",
+		},
+		{
+			name:     "package header shadows shared",
+			assembly: "#include \"shared.h\"\n",
+			sources:  map[string]string{"src/fixture/sdk/shared.h": "#define SHARED 13\n"},
+			retained: []string{"src/fixture/sdk/shared.h"},
+			mutation: "src/fixture/sdk/shared.h",
+		},
+		{
+			name:     "both physical branches guarded",
+			assembly: "#ifdef CONDITIONAL\n#include \"../sibling/yes.h\"\n#else\n#include \"../sibling/no.h\"\n#endif\n",
+			sources: map[string]string{
+				"src/fixture/sibling/yes.h": "#define VALUE 7\n",
+				"src/fixture/sibling/no.h":  "#define VALUE 9\n",
+			},
+			retained: []string{"src/fixture/sibling/yes.h", "src/fixture/sibling/no.h"},
+			mutation: "src/fixture/sibling/no.h",
+		},
+		{
+			name:     "checked-in generated-header spelling is traversed",
+			assembly: "#include \"go_asm.h\"\n",
+			sources: map[string]string{
+				"src/fixture/sdk/go_asm.h":   "#include \"../sibling/size.h\"\n",
+				"src/fixture/sibling/size.h": "#define Type__size 8\n",
+			},
+			retained: []string{"src/fixture/sdk/go_asm.h", "src/fixture/sibling/size.h"},
+			mutation: "src/fixture/sibling/size.h",
+		},
+		{
+			name:     "compiler-generated header absence is guarded",
+			assembly: "#include \"go_asm.h\"\n",
+			mutation: "src/fixture/sdk/go_asm.h",
+		},
+		{
+			name:     "escaped literal and repeated include",
+			assembly: "#include \"../sibling/\\x76alue.h\" // comment\n#include \"../sibling/value.h\"\n",
+			sources:  map[string]string{"src/fixture/sibling/value.h": "#define VALUE 7\n"},
+			retained: []string{"src/fixture/sibling/value.h"},
+			mutation: "src/fixture/sibling/new.h",
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			pkg, root, files := sdkIncludeSourceFixture(t, test.assembly, test.sources)
+			if err := captureAMD64SDKIncludeSources(pkg, root, files); err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range test.retained {
+				if files.hashes[filepath.Join(root, filepath.FromSlash(name))] == "" {
+					t.Errorf("missing guarded header %s", name)
+				}
+			}
+			if len(files.cpp) != 0 {
+				t.Fatal("source closure minted ordinary CPP permission")
+			}
+			if err := files.verify(); err != nil {
+				t.Fatal(err)
+			}
+			if strings.HasPrefix(test.name, "nested package") {
+				request := amd64OriginalObservationFixture(t, "bodyful")
+				ctx, cancel := amd64OriginalObservationContext(t)
+				defer cancel()
+				output, diagnostic, err := RunBounded(ctx, pkg.Dir, request.Environment, request.GoBinary,
+					"tool", "asm", "-p", pkg.ImportPath, "-o", filepath.Join(t.TempDir(), "original.o"), pkg.SFiles[0])
+				if err != nil {
+					t.Fatalf("original Go fixed-CWD nested include: %v\n%s\n%s", err, output, diagnostic)
+				}
+				if files.hashes[filepath.Join(root, "src", "fixture", "sibling", "chosen.h")] != "" {
+					t.Fatal("nested include resolved relative to including header")
+				}
+			}
+			writeSDKIncludeFixture(t, root, test.mutation, "// changed original source or search membership\n")
+			if err := files.verify(); err == nil {
+				t.Fatal("changed source/search closure escaped verification")
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalSDKIncludeUnclosedSourcesFail(t *testing.T) {
+	for _, test := range []struct{ name, source string }{
+		{"dynamic", "#define HEADER \"shared.h\"\n#include HEADER\n"},
+		{"macro-generated directive", "#define LOAD #include \"shared.h\"\nLOAD\n"},
+		{"embedded directive", "MOVQ #include \"shared.h\"\n"},
+		{"absolute path", "#include \"/outside.h\"\n"},
+		{"root escape", "#include \"../../../../outside.h\"\n"},
+		{"missing header", "#include \"missing.h\"\n"},
+		{"missing directory", "#include \"missing/header.h\"\n"},
+		{"extra operand", "#include \"shared.h\" extra\n"},
+		{"angle operand", "#include <shared.h>\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			pkg, root, files := sdkIncludeSourceFixture(t, test.source, nil)
+			if err := captureAMD64SDKIncludeSources(pkg, root, files); err == nil {
+				t.Fatal("unclosed include source accepted")
+			}
+		})
+	}
+	for _, kind := range []string{"symlink", "directory", "changed selected source"} {
+		t.Run(kind, func(t *testing.T) {
+			pkg, root, files := sdkIncludeSourceFixture(t, "#include \"../sibling/value.h\"\n", map[string]string{
+				"src/fixture/sibling/neighbor.h": "// retain sibling directory\n",
+			})
+			name := filepath.Join(root, "src", "fixture", "sibling", "value.h")
+			var err error
+			switch kind {
+			case "symlink":
+				err = os.Symlink(filepath.Join(root, "pkg", "include", "shared.h"), name)
+			case "directory":
+				err = os.Mkdir(name, 0700)
+			default:
+				err = os.WriteFile(filepath.Join(pkg.Dir, pkg.SFiles[0]), []byte("// changed\n"), 0600)
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := captureAMD64SDKIncludeSources(pkg, root, files); err == nil {
+				t.Fatal("unbound source role accepted")
+			}
+		})
+	}
+}
+
+func TestAMD64OriginalSDKIncludeSourceBounds(t *testing.T) {
+	t.Run("distinct file limit", func(t *testing.T) {
+		pkg, root, files := sdkIncludeSourceFixture(t, "// original source\n", nil)
+		// The same enqueue bound covers initial selection and recursive
+		// includes. Check it before any path can acquire a source role.
+		for index := 0; index < 4096; index++ {
+			pkg.SFiles = append(pkg.SFiles, fmt.Sprintf("unretained-%04d.s", index))
+		}
+		if err := captureAMD64SDKIncludeSources(pkg, root, files); err == nil || !strings.Contains(err.Error(), "file bound") {
+			t.Fatalf("missing explicit file bound: %v", err)
+		}
+	})
+	t.Run("duplicate paths do not consume the distinct limit", func(t *testing.T) {
+		pkg, root, files := sdkIncludeSourceFixture(t, "#include \"shared.h\"\n", nil)
+		for index := 0; index < 4096; index++ {
+			pkg.SFiles = append(pkg.SFiles, pkg.SFiles[0])
+		}
+		if err := captureAMD64SDKIncludeSources(pkg, root, files); err != nil {
+			t.Fatal(err)
+		}
+	})
+	t.Run("total byte limit", func(t *testing.T) {
+		pkg, root, files := sdkIncludeSourceFixture(t, "#include \"large.h\"\n", map[string]string{
+			"src/fixture/sdk/large.h": "//" + strings.Repeat("x", (16<<20)-2),
+		})
+		if err := captureAMD64SDKIncludeSources(pkg, root, files); err == nil || !strings.Contains(err.Error(), "byte bound") {
+			t.Fatalf("missing explicit byte bound: %v", err)
+		}
+	})
+}
+
+func writeSDKIncludeFixture(t *testing.T, root, name, source string) {
+	t.Helper()
+	file := filepath.Join(root, filepath.FromSlash(name))
+	if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestAMD64OriginalSDKIncludeSiblingSourceClosure(t *testing.T) {
+	assembly := "#include \"../sibling/value.h\"\nTEXT ·Value(SB),4,$0-0\nMOVQ $VALUE,AX\nRET\n"
+	pkg, root, profile, files := sdkDependencyIncludeFixture(t, assembly)
+	request := amd64OriginalObservationFixture(t, "bodyful")
+	ctx, cancel := amd64OriginalObservationContext(t)
+	defer cancel()
+	object := filepath.Join(t.TempDir(), "original.o")
+	output, diagnostic, err := RunBounded(ctx, pkg.Dir, request.Environment, request.GoBinary,
+		"tool", "asm", "-p", pkg.ImportPath, "-o", object, "value_amd64.s")
+	if err != nil {
+		t.Fatalf("original Go sibling include: %v\n%s\n%s", err, output, diagnostic)
+	}
+	if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+		t.Fatalf("original Go did not produce the sibling-include object: %v", err)
+	}
+	if err := captureAMD64OriginalSDKDependency(pkg, root, profile, files); err != nil {
+		t.Fatal(err)
+	}
+	header := filepath.Join(root, "src", "fixture", "sibling", "value.h")
+	if files.hashes[header] == "" {
+		t.Fatal("actual original Go include outside package/shared roots has no byte guard")
+	}
+	if len(files.cpp) != 0 {
+		t.Fatal("dependency include retention minted ordinary CPP authority")
+	}
+	writeSDKIncludeFixture(t, root, "src/fixture/sibling/value.h", "#define VALUE 9\n")
+	if err := files.verify(); err == nil {
+		t.Fatal("changed SDK sibling include escaped original source verification")
+	}
+}
diff --git a/gotoolprofile/amd64_original_sdk_package.go b/gotoolprofile/amd64_original_sdk_package.go
new file mode 100644
index 000000000..feae7df45
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_package.go
@@ -0,0 +1,41 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// The actual import graph owns each package separately. Descendant package
+// contents are not compiler inputs merely because an ancestor is imported.
+// Retain every direct member, including inactive Go,
+// assembly and header candidates, and the complete directory membership. Actual
+// imported descendants have their own package capture; literal assembly includes
+// have their separate bounded include closure and shadow-directory guards.
+func retainAMD64OriginalPackageDirectory(pkg amd64OriginalListPackage, directory string, files *amd64OriginalObservationFiles) error {
+	if pkg.Standard && pkg.Module != nil {
+		return fmt.Errorf("SDK package source cannot acquire a module identity")
+	}
+	if err := files.directory(directory, false); err != nil {
+		return err
+	}
+	// Match Snapshot's shared 65,536-file / 4,096-directory member bound.
+	entries, info, err := gooriginalsrc.ReadDirectory(directory, 65536+4096)
+	if err != nil {
+		return err
+	}
+	if !os.SameFile(info, files.directories[directory]) {
+		return fmt.Errorf("package directory identity changed during capture")
+	}
+	for _, entry := range entries {
+		if entry.IsDir() {
+			continue
+		}
+		if err := files.retain(filepath.Join(directory, entry.Name())); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/amd64_original_sdk_package_test.go b/gotoolprofile/amd64_original_sdk_package_test.go
new file mode 100644
index 000000000..83bea4c85
--- /dev/null
+++ b/gotoolprofile/amd64_original_sdk_package_test.go
@@ -0,0 +1,164 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func originalSDKPackageMemberFixture(t *testing.T) (amd64OriginalListPackage, string, *amd64OriginalObservationFiles) {
+	t.Helper()
+	return sdkIncludeSourceFixture(t, "// original assembly\n", map[string]string{
+		"src/fixture/sdk/value.go":          "package sdk\n",
+		"src/fixture/sdk/inactive.go":       "//go:build inactive\n\npackage sdk\n",
+		"src/fixture/sdk/value_test.go":     "package sdk\n",
+		"src/fixture/sdk/value.h":           "#define VALUE 7\n",
+		"src/fixture/sdk/descendant/dep.go": "package descendant\n",
+	})
+}
+
+func TestAMD64OriginalSDKPackageMembersAreComplete(t *testing.T) {
+	pkg, _, files := originalSDKPackageMemberFixture(t)
+	for _, name := range []string{"value.go", "inactive.go", "value_test.go", "value_amd64.s", "value.h"} {
+		if files.hashes[filepath.Join(pkg.Dir, name)] == "" {
+			t.Fatalf("direct source/selection member is unguarded: %s", name)
+		}
+	}
+	nested := filepath.Join(pkg.Dir, "descendant", "dep.go")
+	if files.hashes[nested] != "" {
+		t.Fatal("unimported descendant acquired a package-input role")
+	}
+	if err := os.WriteFile(nested, []byte("package descendant\n// unrelated edit\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := files.verify(); err != nil {
+		t.Fatal("an unconsumed descendant is not a parent-package source input", err)
+	}
+	// When the actual graph selects a descendant, its own package role closes
+	// every direct member independently. A parent observation cannot replace it.
+	selected := amd64OriginalListPackage{Standard: true}
+	selected.ImportPath, selected.Dir = pkg.ImportPath+"/descendant", filepath.Dir(nested)
+	if err := retainAMD64OriginalPackageDirectory(selected, selected.Dir, files); err != nil {
+		t.Fatal(err)
+	}
+	if files.hashes[nested] == "" {
+		t.Fatal("separately selected descendant lost its actual source")
+	}
+	if err := os.WriteFile(nested, []byte("package descendant\n// selected edit\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := files.verify(); err == nil {
+		t.Fatal("changed selected descendant escaped source verification")
+	}
+}
+
+func TestAMD64OriginalSDKPackageMemberMutationGuards(t *testing.T) {
+	for _, name := range []string{"value.go", "inactive.go", "value_test.go", "value_amd64.s", "value.h", "added.go", "added.h"} {
+		t.Run(name, func(t *testing.T) {
+			pkg, _, files := originalSDKPackageMemberFixture(t)
+			if err := os.WriteFile(filepath.Join(pkg.Dir, name), []byte("// changed member\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := files.verify(); err == nil {
+				t.Fatal("changed/new package source member escaped verification")
+			}
+		})
+	}
+	t.Run("new directory", func(t *testing.T) {
+		pkg, _, files := originalSDKPackageMemberFixture(t)
+		if err := os.Mkdir(filepath.Join(pkg.Dir, "new"), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := files.verify(); err == nil {
+			t.Fatal("new source directory escaped complete member verification")
+		}
+	})
+	t.Run("directory identity", func(t *testing.T) {
+		pkg, root, files := originalSDKPackageMemberFixture(t)
+		if err := os.Rename(pkg.Dir, pkg.Dir+".old"); err != nil {
+			t.Fatal(err)
+		}
+		writeSDKIncludeFixture(t, root, "src/fixture/sdk/value.go", "package sdk\n")
+		if err := files.verify(); err == nil {
+			t.Fatal("replaced original SDK directory escaped identity verification")
+		}
+	})
+}
+
+func TestAMD64OriginalSDKPackageAncestorAlias(t *testing.T) {
+	pkg, root, _ := originalSDKPackageMemberFixture(t)
+	_, otherRoot, _ := originalSDKPackageMemberFixture(t)
+	alias := filepath.Join(t.TempDir(), "sdk-root")
+	if err := os.Symlink(root, alias); err != nil {
+		t.Fatal(err)
+	}
+	pkg.Dir = filepath.Join(alias, "src", "fixture", "sdk")
+	files := newAMD64OriginalObservationFiles()
+	if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, files); err != nil {
+		t.Fatal("stable SDK ancestor alias failed source observation", err)
+	}
+	if err := files.verify(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Rename(alias, alias+".old"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(otherRoot, alias); err != nil {
+		t.Fatal(err)
+	}
+	if err := files.verify(); err == nil {
+		t.Fatal("changed ancestor alias escaped original SDK identity checks")
+	}
+}
+
+func TestAMD64OriginalSDKPackageDoesNotRelaxOtherRoles(t *testing.T) {
+	t.Run("ordinary module tree", func(t *testing.T) {
+		pkg, _, _ := originalSDKPackageMemberFixture(t)
+		pkg.Standard = false
+		files := newAMD64OriginalObservationFiles()
+		if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, files); err != nil {
+			t.Fatal(err)
+		}
+		nested := filepath.Join(pkg.Dir, "descendant", "dep.go")
+		if files.hashes[nested] != "" {
+			t.Fatal("unimported ordinary descendant acquired a package-input role")
+		}
+		selected := pkg
+		selected.ImportPath += "/descendant"
+		selected.Dir = filepath.Dir(nested)
+		if err := retainAMD64OriginalPackageDirectory(selected, selected.Dir, files); err != nil {
+			t.Fatal(err)
+		}
+		if files.hashes[nested] == "" {
+			t.Fatal("selected ordinary descendant lost its actual source guard")
+		}
+		if err := os.WriteFile(nested, []byte("package descendant\n// selected edit\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := files.verify(); err == nil {
+			t.Fatal("changed selected ordinary descendant escaped source verification")
+		}
+	})
+	t.Run("foreign module SDK", func(t *testing.T) {
+		pkg, _, _ := originalSDKPackageMemberFixture(t)
+		pkg.Module = &amd64OriginalListModule{Path: "example.invalid/foreign"}
+		if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, newAMD64OriginalObservationFiles()); err == nil {
+			t.Fatal("module source impersonated the SDK package role")
+		}
+	})
+	for _, directory := range []bool{false, true} {
+		t.Run(map[bool]string{false: "file symlink", true: "directory symlink"}[directory], func(t *testing.T) {
+			pkg, _, _ := originalSDKPackageMemberFixture(t)
+			target := filepath.Join(pkg.Dir, "value.go")
+			if directory {
+				target = filepath.Join(pkg.Dir, "descendant")
+			}
+			if err := os.Symlink(target, filepath.Join(pkg.Dir, "alias")); err != nil {
+				t.Fatal(err)
+			}
+			if err := retainAMD64OriginalPackageDirectory(pkg, pkg.Dir, newAMD64OriginalObservationFiles()); err == nil {
+				t.Fatal("source-internal symlink acquired a regular member role")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/api.go b/gotoolprofile/api.go
new file mode 100644
index 000000000..34ea8f6f9
--- /dev/null
+++ b/gotoolprofile/api.go
@@ -0,0 +1,78 @@
+package gotoolprofile
+
+import (
+	"context"
+	"fmt"
+)
+
+// Capture and Validate share the complete actual-driver marker protocol.
+// Observe the same environment/cache/routing before and after consuming it;
+// a caller-provided ID is never sufficient on its own.
+func Capture(ctx context.Context, binary, ownedDir string, env []string, target string, overrides map[string]string, run Runner) (*Observation, error) {
+	if ctx == nil || run == nil {
+		return nil, fmt.Errorf("feature capture requires a live context and bounded command runner")
+	}
+	return captureDiscoveryTargetFeatures(ctx, binary, ownedDir, env, target, overrides, run)
+}
+
+func Validate(observed *Observation) error { return validateDiscoveryTargetFeatures(observed) }
+func CPUEnvironment(arch, value string, minor int) error {
+	return validateDiscoveryCPUEnvironment(arch, value, minor)
+}
+func CPUCandidates() []string { return discoveryCPUFeatureCandidates() }
+func BuiltinCandidates(root string, versions ...string) ([]string, map[string]string, error) {
+	return discoveryBuiltinFeatureCandidates(root, versions...)
+}
+func ValidateRegistration(data []byte, minors ...int) error {
+	return validateDiscoveryFeatureRegistration(data, minors...)
+}
+func ExperimentCandidates(data []byte) ([]string, error) {
+	return discoveryExperimentFeatureCandidates(data)
+}
+func MarkerFiles(tags []string) map[string][]byte { return discoveryFeatureMarkerFiles(tags) }
+func DecodeMarkers(data []byte, dir string, tags []string) (map[string]bool, error) {
+	return decodeDiscoveryFeatureMarkers(data, dir, tags)
+}
+func TagNamespace(tag string) bool { return discoveryFeatureTagNamespace(tag) }
+
+// ReservedTag covers the frontend's target/compiler namespace in addition to
+// CPU, experiment and instrumentation tags. These cannot be user CPU profiles.
+func ReservedTag(tag string) bool {
+	if TagNamespace(tag) {
+		return true
+	}
+	for _, reserved := range []string{
+		"ignore", "cgo", "gc", "gccgo", "unix",
+		"aix", "android", "darwin", "dragonfly", "freebsd", "hurd", "illumos", "ios", "js", "linux", "netbsd", "openbsd", "plan9", "solaris", "wasip1", "windows", "zos",
+		"386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "loong64", "mips", "mipsle", "mips64", "mips64le", "mips64p32", "mips64p32le", "ppc", "ppc64", "ppc64le", "riscv", "riscv64", "s390", "s390x", "sparc", "sparc64", "wasm",
+	} {
+		if tag == reserved {
+			return true
+		}
+	}
+	return false
+}
+func FileSHA256(name string) (string, error)      { return discoveryFeatureFileSHA256(name) }
+func MarkerSHA256(files map[string][]byte) string { return discoveryFeatureMarkerSHA256(files) }
+func EnvironmentKeys() []string                   { return append([]string(nil), discoveryFeatureEnvKeys...) }
+func CPUFeatures(tags []string, arch, value string, minor int) []string {
+	return discoveryModeledCPUFeatures(tags, arch, value, minor)
+}
+
+type ToolState struct {
+	Directory  string
+	Digests    map[string]string
+	Origins    map[string]string
+	Routing    string
+	Dispatcher string
+}
+
+func CaptureSubtools(ctx context.Context, binary string, env []string, actual map[string]string, run Runner) (*ToolState, error) {
+	state, err := captureDiscoveryFeatureSubtools(ctx, binary, env, actual, run)
+	if err != nil {
+		return nil, err
+	}
+	return &ToolState{Directory: state.directory, Digests: state.digests, Origins: state.origins, Routing: state.routing, Dispatcher: state.dispatcher}, nil
+}
+
+func ValidToolDirectory(directory string) bool { return validDiscoveryFeatureToolDirectory(directory) }
diff --git a/gotoolprofile/assembler.go b/gotoolprofile/assembler.go
new file mode 100644
index 000000000..36d06fdb2
--- /dev/null
+++ b/gotoolprofile/assembler.go
@@ -0,0 +1,114 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"os"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/goasmmacros"
+)
+
+type AssemblerMacros struct {
+	Protocol           string            `json:"protocol"`
+	FeatureID          string            `json:"feature_id"`
+	Target             string            `json:"target"`
+	GoVersion          string            `json:"go_version"`
+	PackagePath        string            `json:"package_path"`
+	PackageRole        string            `json:"package_role"`
+	Defines            []string          `json:"defines"`
+	ToolSourceSHA256   map[string]string `json:"tool_source_sha256"`
+	RegistrationSHA256 map[string]string `json:"registration_ast_sha256"`
+}
+
+// ValidateOrdinaryAssemblerMacros checks portable frozen producer evidence.
+// It does not authenticate Go source bytes without the original source tree;
+// the compiler consumer separately captures and rechecks those actual bytes.
+func ValidateOrdinaryAssemblerMacros(proof *AssemblerMacros, observed *Observation, packagePath string) error {
+	if err := Validate(observed); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != "go_source_assembler_macros_v1" || proof.FeatureID != ProfileID(observed) || proof.Target != observed.Target || proof.GoVersion != observed.GoVersion || proof.PackagePath != packagePath {
+		return fmt.Errorf("assembler macro evidence differs from actual profile/package identity")
+	}
+	minor, err := goMinor(observed.GoVersion)
+	if err != nil {
+		return err
+	}
+	defines, err := plan9asm.GoAssemblerDefinesForEnvironment(observed.Environment["GOOS"], observed.Environment["GOARCH"], observed.Environment)
+	if err != nil || !reflect.DeepEqual(defines, proof.Defines) {
+		return fmt.Errorf("ordinary assembler macros differ from the actual target environment")
+	}
+	wantedRegistration := map[string]string{"asmArgs": goasmmacros.ArgsFingerprint(minor)}
+	wantedSources := []string{"VERSION", "src/cmd/go/internal/work/gc.go", "src/cmd/asm/main.go"}
+	if minor < 22 {
+		if proof.PackageRole != "legacy_no_experiment_macros" {
+			return fmt.Errorf("unverified legacy ordinary assembler package role")
+		}
+		wantedRegistration["experiment_registration_absent"] = bytesSHA256(nil)
+	} else {
+		if proof.PackageRole != "ordinary_path" {
+			return fmt.Errorf("special assembler package role is outside ordinary CPU coverage")
+		}
+		wantedRegistration["experiment_registration"] = "32995e3cdb0c0ab1499abc494906e85ec47b639f2ebeac6b4c049d6d676a8b0f"
+		wantedRegistration["package_special_registration"] = goasmmacros.SpecialFingerprint(minor)
+		wantedSources = append(wantedSources, "src/cmd/internal/objabi/pkgspecial.go")
+	}
+	if !reflect.DeepEqual(wantedRegistration, proof.RegistrationSHA256) || len(proof.ToolSourceSHA256) != len(wantedSources) {
+		return fmt.Errorf("incomplete or unknown actual assembler source registration")
+	}
+	for _, file := range wantedSources {
+		if !discoverySHA256Pattern.MatchString(proof.ToolSourceSHA256[file]) {
+			return fmt.Errorf("actual assembler registration lacks source hash: %s", file)
+		}
+	}
+	if proof.ToolSourceSHA256["VERSION"] != observed.ToolSourceSHA256["VERSION"] {
+		return fmt.Errorf("assembler macros and actual feature driver used different Go source versions")
+	}
+	return nil
+}
+
+// This derives package-role macros from actual registered Go sources. It is
+// not a package source-selection observation: production must separately bind
+// packagePath to the actual go list package being checked under this profile.
+func CaptureAssemblerMacros(root string, observed *Observation, packagePath string) (*AssemblerMacros, error) {
+	if observed == nil || observed.Protocol != "go_driver_builtin_features_v2" || observed.GoVersion != observed.Environment["GOVERSION"] {
+		return nil, fmt.Errorf("missing or inconsistent observed assembler environment")
+	}
+	rules, err := goasmmacros.Capture(root, observed.GoVersion, packagePath, os.ReadFile)
+	if err != nil {
+		return nil, err
+	}
+	defines, err := plan9asm.GoAssemblerDefinesForEnvironment(observed.Environment["GOOS"], observed.Environment["GOARCH"], observed.Environment)
+	if err != nil {
+		return nil, err
+	}
+	proof := &AssemblerMacros{
+		Protocol: "go_source_assembler_macros_v1", FeatureID: ProfileID(observed),
+		Target: observed.Target, GoVersion: observed.GoVersion, PackagePath: packagePath,
+		PackageRole: rules.PackageRole, Defines: defines,
+		ToolSourceSHA256: rules.ToolSourceSHA256, RegistrationSHA256: rules.RegistrationSHA256,
+	}
+	if rules.PackageRole == "allow_asm_abi_path" {
+		for _, tag := range observed.ToolTags {
+			if strings.HasPrefix(tag, "goexperiment.") {
+				if !observed.MarkerSelection[tag] {
+					return nil, fmt.Errorf("unobserved enabled experiment %s", tag)
+				}
+				proof.Defines = append(proof.Defines, "GOEXPERIMENT_"+strings.TrimPrefix(tag, "goexperiment."))
+			}
+		}
+	}
+	return proof, nil
+}
+
+func discoveryAssemblerSourceFunction(file *ast.File, name string) (*ast.FuncDecl, error) {
+	return goasmmacros.SourceFunction(file, name)
+}
+
+func ASTSHA(fset *token.FileSet, node ast.Node) (string, error) {
+	return goasmmacros.ASTSHA(fset, node)
+}
diff --git a/gotoolprofile/assembly_source_budget.go b/gotoolprofile/assembly_source_budget.go
new file mode 100644
index 000000000..1e0ebc530
--- /dev/null
+++ b/gotoolprofile/assembly_source_budget.go
@@ -0,0 +1,30 @@
+package gotoolprofile
+
+import (
+	"path"
+	"strings"
+)
+
+// AssemblySourceByteLimit bounds a complete generated assembly file or its
+// expansion. It is a resource budget, not source, ABI or object authority.
+// Go files and ordinary headers retain their smaller existing byte bounds.
+const AssemblySourceByteLimit = 8 << 20
+
+func instrumentationOriginalSourceByteLimit(name string) int {
+	if path.Ext(name) == ".s" {
+		return AssemblySourceByteLimit
+	}
+	return instrumentationOriginalFileLimit
+}
+
+// InstrumentationCPPInputByteLimit shares the producer/replay byte bound.
+// Only original module assembly gets the larger allowance; tool, generated
+// and module headers retain their independent limit. Origin authentication,
+// complete input accounting and hash agreement are still required separately.
+func InstrumentationCPPInputByteLimit(origin string) int {
+	kind, name, present := strings.Cut(origin, "/")
+	if present && kind == "module" {
+		return instrumentationOriginalSourceByteLimit(name)
+	}
+	return instrumentationOriginalFileLimit
+}
diff --git a/gotoolprofile/command.go b/gotoolprofile/command.go
new file mode 100644
index 000000000..e7b006576
--- /dev/null
+++ b/gotoolprofile/command.go
@@ -0,0 +1,54 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"time"
+)
+
+const commandOutputLimit = 4 << 20
+
+type boundedOutput struct {
+	buffer   bytes.Buffer
+	overflow bool
+}
+
+func (output *boundedOutput) Bytes() []byte  { return output.buffer.Bytes() }
+func (output *boundedOutput) String() string { return output.buffer.String() }
+
+func (output *boundedOutput) Write(data []byte) (int, error) {
+	count := len(data)
+	remaining := commandOutputLimit - output.buffer.Len()
+	if len(data) > remaining {
+		output.overflow = true
+		data = data[:remaining]
+	}
+	_, _ = output.buffer.Write(data)
+	return count, nil
+}
+
+// RunBounded preserves machine-readable stdout, stderr and the actual exit.
+// Only this invocation's fresh process group is subject to cancellation.
+func RunBounded(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+	if ctx == nil {
+		return nil, nil, fmt.Errorf("machine command requires a live context")
+	}
+	command := exec.CommandContext(ctx, name, args...)
+	command.Dir, command.Env, command.WaitDelay = dir, env, 2*time.Second
+	var stdout, stderr boundedOutput
+	command.Stdout, command.Stderr = &stdout, &stderr
+	err := runOwnedCommand(command)
+	if ctx.Err() != nil {
+		err = errors.Join(err, ctx.Err())
+	}
+	if stdout.overflow || stderr.overflow {
+		err = errors.Join(err, fmt.Errorf("machine command exceeded the explicit output bound"))
+	}
+	if err != nil {
+		err = fmt.Errorf("%s: %w\nstdout:\n%s\nstderr:\n%s", name, err, stdout.String(), stderr.String())
+	}
+	return stdout.Bytes(), stderr.Bytes(), err
+}
diff --git a/gotoolprofile/command_other.go b/gotoolprofile/command_other.go
new file mode 100644
index 000000000..0b9944c58
--- /dev/null
+++ b/gotoolprofile/command_other.go
@@ -0,0 +1,7 @@
+//go:build !unix
+
+package gotoolprofile
+
+import "os/exec"
+
+func runOwnedCommand(command *exec.Cmd) error { return command.Run() }
diff --git a/gotoolprofile/command_test.go b/gotoolprofile/command_test.go
new file mode 100644
index 000000000..450077029
--- /dev/null
+++ b/gotoolprofile/command_test.go
@@ -0,0 +1,98 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestBoundedMachineCommandPreservesStdoutStderrAndExit(t *testing.T) {
+	stdout, stderr, err := runCommandFixture(context.Background(), "json")
+	if err != nil || string(stdout) != "{\"selected\":true}" || string(stderr) != "go: downloading fixture\n" {
+		t.Fatalf("machine output stdout=%q stderr=%q err=%v", stdout, stderr, err)
+	}
+	stdout, stderr, err = runCommandFixture(context.Background(), "exit")
+	var exit *exec.ExitError
+	if !errors.As(err, &exit) || exit.ExitCode() != 7 || string(stdout) != "machine partial" || string(stderr) != "actual diagnostic" || !strings.Contains(err.Error(), "actual diagnostic") {
+		t.Fatalf("actual exit/output was lost: stdout=%q stderr=%q err=%v", stdout, stderr, err)
+	}
+}
+
+func TestBoundedMachineCommandRejectsOverflowAndDeadline(t *testing.T) {
+	stdout, _, err := runCommandFixture(context.Background(), "overflow")
+	if err == nil || !strings.Contains(err.Error(), "output bound") || len(stdout) != commandOutputLimit {
+		t.Fatalf("overflow was accepted: length=%d err=%v", len(stdout), err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+	_, _, err = runCommandFixture(ctx, "deadline")
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("deadline was lost: %v", err)
+	}
+}
+
+func runCommandFixture(ctx context.Context, mode string) ([]byte, []byte, error) {
+	return RunBounded(ctx, "", append(os.Environ(), "PLAN9ASM_MACHINE_FIXTURE="+mode), os.Args[0], "-test.run=^TestBoundedMachineFixture$")
+}
+
+func TestBoundedMachineFixture(t *testing.T) {
+	switch os.Getenv("PLAN9ASM_MACHINE_FIXTURE") {
+	case "":
+		return
+	case "json":
+		fmt.Fprint(os.Stdout, "{\"selected\":true}")
+		fmt.Fprint(os.Stderr, "go: downloading fixture\n")
+	case "exit":
+		fmt.Fprint(os.Stdout, "machine partial")
+		fmt.Fprint(os.Stderr, "actual diagnostic")
+		os.Exit(7)
+	case "overflow":
+		fmt.Fprint(os.Stdout, strings.Repeat("x", commandOutputLimit+1))
+	case "deadline":
+		time.Sleep(time.Second)
+	default:
+		os.Exit(9)
+	}
+	os.Exit(0)
+}
+
+func TestCaptureRejectsMissingCommandLifetime(t *testing.T) {
+	if _, err := Capture(nil, "", "", nil, "linux/amd64", nil, RunBounded); err == nil {
+		t.Fatal("nil lifetime was accepted")
+	}
+	if _, err := Capture(context.Background(), "", "", nil, "linux/amd64", nil, nil); err == nil {
+		t.Fatal("nil command runner was accepted")
+	}
+}
+
+func TestBoundedMachineActualGoToolRoutes(t *testing.T) {
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range [][2]string{{"darwin", "amd64"}, {"linux", "386"}} {
+		env := append(os.Environ(), "GOOS="+target[0], "GOARCH="+target[1], "CGO_ENABLED=0", "GOTOOLCHAIN=local")
+		for _, tool := range []string{"vet", "nm"} {
+			t.Run(target[0]+"-"+target[1]+"/"+tool, func(t *testing.T) {
+				for repeat := 0; repeat < 16; repeat++ {
+					ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+					stdout, stderr, err := RunBounded(ctx, "", env, goBinary, "tool", "-n", tool)
+					cancel()
+					path := strings.TrimSpace(string(stdout))
+					if err != nil || len(stderr) != 0 || !filepath.IsAbs(path) || strings.Contains(path, "\n") {
+						t.Fatalf("actual route %d: stdout=%q stderr=%q err=%v", repeat, stdout, stderr, err)
+					}
+					if _, err := os.Stat(path); err != nil {
+						t.Fatalf("actual subtool route is absent: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/gotoolprofile/command_unix.go b/gotoolprofile/command_unix.go
new file mode 100644
index 000000000..4c75fdb11
--- /dev/null
+++ b/gotoolprofile/command_unix.go
@@ -0,0 +1,13 @@
+//go:build unix
+
+package gotoolprofile
+
+import (
+	"os/exec"
+
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+)
+
+func runOwnedCommand(command *exec.Cmd) error {
+	return ownedprocess.Run(command)
+}
diff --git a/gotoolprofile/consumer.go b/gotoolprofile/consumer.go
new file mode 100644
index 000000000..30f134b1e
--- /dev/null
+++ b/gotoolprofile/consumer.go
@@ -0,0 +1,104 @@
+package gotoolprofile
+
+const ConsumerProtocol = "actual_go_cpu_profile_consumer_v1"
+
+// ConsumerInput is a private invocation artifact, not a portable report. The
+// source root binds an actual replacement/module directory; all selected bytes
+// must match the producer's pre-load hashes. Only SelectionProof is published.
+type ConsumerInput struct {
+	Protocol                     string                  `json:"protocol"`
+	SignatureSourceProtocol      string                  `json:"signature_source_protocol,omitempty"`
+	TestDependencySourceProtocol string                  `json:"test_dependency_source_protocol,omitempty"`
+	ID                           string                  `json:"id"`
+	Observed                     *Observation            `json:"observed"`
+	Module                       string                  `json:"module"`
+	Version                      string                  `json:"version"`
+	SourceModule                 string                  `json:"source_module,omitempty"`
+	SourceRoot                   string                  `json:"source_root"`
+	Sources                      map[string]string       `json:"sources"`
+	Headers                      map[string]string       `json:"selection_headers"`
+	ToolSources                  map[string]string       `json:"tool_sources,omitempty"`
+	CPPSourceProtocol            string                  `json:"cpp_source_protocol,omitempty"`
+	CPPOriginals                 *CPPOriginalReplayInput `json:"cpp_originals,omitempty"`
+	CPPIncludeSearchMisses       []CPPPackageSearchMiss  `json:"cpp_include_search_misses,omitempty"`
+	Directories                  map[string][]string     `json:"directories"`
+	OrdinaryAsmPackages          []string                `json:"ordinary_asm_packages,omitempty"`
+	AsmFiles                     []string                `json:"asm_files"`
+	// RegisteredAsmFiles is the complete selected nonempty assembly in the
+	// loaded packages when a concrete source exclusion narrows AsmFiles.
+	// Registration is source-role evidence, never an IR/object or exclusion.
+	RegisteredAsmFiles []string             `json:"registered_asm_files,omitempty"`
+	ProxyGoMod         *ProxyGoModProof     `json:"proxy_go_mod,omitempty"`
+	ProxyGoModPath     string               `json:"proxy_go_mod_path,omitempty"`
+	GeneratedHeaders   *MetadataProof       `json:"generated_headers,omitempty"`
+	TestDependencies   *TestDependencyProof `json:"test_declaration_dependencies,omitempty"`
+}
+
+type SelectionProof struct {
+	Protocol                     string                 `json:"protocol"`
+	SignatureSourceProtocol      string                 `json:"signature_source_protocol,omitempty"`
+	TestDependencySourceProtocol string                 `json:"test_dependency_source_protocol,omitempty"`
+	TestDeclarations             []TestDeclarationProof `json:"test_declarations,omitempty"`
+	ProfileID                    string                 `json:"profile_id"`
+	CustomTags                   []string               `json:"custom_tags,omitempty"`
+	Packages                     []PackageProof         `json:"packages"`
+	RegisteredAsmFiles           []string               `json:"registered_asm_files,omitempty"`
+	CPPSourceProtocol            string                 `json:"cpp_source_protocol,omitempty"`
+	CPPIncludeSearchMisses       []CPPPackageSearchMiss `json:"cpp_include_search_misses,omitempty"`
+	CPP                          []CPPProof             `json:"cpp"`
+	Outputs                      []OutputProof          `json:"outputs"`
+	GeneratedHeaders             *MetadataProof         `json:"generated_headers,omitempty"`
+	TestDependencies             *TestDependencyProof   `json:"test_declaration_dependencies,omitempty"`
+}
+
+type PackageProof struct {
+	PackagePath     string            `json:"package_path"`
+	ModulePath      string            `json:"module_path"`
+	ModuleVersion   string            `json:"module_version"`
+	SourceModule    string            `json:"source_module"`
+	SourceVersion   string            `json:"source_version"`
+	SourceRole      string            `json:"source_role"`
+	GoFiles         []string          `json:"go_files"`
+	CompiledGoFiles []string          `json:"compiled_go_files"`
+	SFiles          []string          `json:"s_files"`
+	SourceSHA256    map[string]string `json:"source_sha256"`
+	Macros          *AssemblerMacros  `json:"macros"`
+	GoModOrigin     string            `json:"go_mod_origin,omitempty"`
+	GoModSHA256     string            `json:"go_mod_sha256,omitempty"`
+	GoModSum        string            `json:"go_mod_sum,omitempty"`
+}
+
+type CPPProof struct {
+	File                 string                 `json:"file"`
+	Emission             string                 `json:"emission"`
+	ExpandedSHA256       string                 `json:"expanded_sha256"`
+	TypedExpandedSHA256  string                 `json:"typed_expanded_sha256"`
+	Inputs               map[string]string      `json:"inputs"`
+	ExpandedSearchMisses []CPPPackageSearchMiss `json:"expanded_include_search_misses"`
+	EmptyAssembly        *EmptyAssemblyProof    `json:"empty_assembly,omitempty"`
+	DataOnlyAssembly     *DataOnlyAssemblyProof `json:"data_only_assembly,omitempty"`
+	Signatures           []SignatureSource      `json:"signature_sources,omitempty"`
+}
+
+// EmptyAssemblyProof witnesses a real Go object and an empty assembler -S
+// symbol/data listing. It is not a source exclusion: LLVM must also produce
+// a real object for this same selected CPP scope.
+type EmptyAssemblyProof struct {
+	Protocol      string `json:"protocol"`
+	File          string `json:"file"`
+	SourceSHA256  string `json:"source_sha256"`
+	PackagePath   string `json:"package_path"`
+	ProfileID     string `json:"profile_id"`
+	Target        string `json:"target"`
+	GoVersion     string `json:"go_version"`
+	AsmToolSHA256 string `json:"asm_tool_sha256"`
+	ObjectSHA256  string `json:"object_sha256"`
+	ListingSHA256 string `json:"listing_sha256"`
+}
+
+type OutputProof struct {
+	File   string `json:"file"`
+	Part   string `json:"part"`
+	IR     string `json:"ir_sha256"`
+	Object string `json:"object_sha256,omitempty"`
+}
diff --git a/gotoolprofile/consumer_json.go b/gotoolprofile/consumer_json.go
new file mode 100644
index 000000000..b16282b3b
--- /dev/null
+++ b/gotoolprofile/consumer_json.go
@@ -0,0 +1,54 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// ConsumerInputJSONLimit bounds one complete private invocation artifact.
+// Test-declaration inputs retain their full original dependency/source closure;
+// the old 4 MiB reader truncated valid inputs that the producer had written.
+// This transport bound grants no source, signature, object or profile proof.
+const ConsumerInputJSONLimit = 32 << 20
+
+func MarshalConsumerInput(input *ConsumerInput) ([]byte, error) {
+	if input == nil {
+		return nil, fmt.Errorf("missing explicit feature profile input")
+	}
+	data, err := json.Marshal(input)
+	if err != nil {
+		return nil, fmt.Errorf("encode explicit feature profile: %w", err)
+	}
+	if len(data) > ConsumerInputJSONLimit {
+		return nil, fmt.Errorf("explicit feature profile JSON has %d bytes, exceeds its %d-byte bound", len(data), ConsumerInputJSONLimit)
+	}
+	return data, nil
+}
+
+func DecodeConsumerInput(reader io.Reader) (*ConsumerInput, error) {
+	if reader == nil {
+		return nil, fmt.Errorf("missing explicit feature profile reader")
+	}
+	data, err := io.ReadAll(io.LimitReader(reader, ConsumerInputJSONLimit+1))
+	if err != nil {
+		return nil, fmt.Errorf("read explicit feature profile JSON: %w", err)
+	}
+	if len(data) > ConsumerInputJSONLimit {
+		return nil, fmt.Errorf("explicit feature profile JSON exceeds its %d-byte bound", ConsumerInputJSONLimit)
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	decoder.DisallowUnknownFields()
+	var input *ConsumerInput
+	if err := decoder.Decode(&input); err != nil {
+		return nil, fmt.Errorf("decode explicit feature profile: %w", err)
+	}
+	if input == nil {
+		return nil, fmt.Errorf("missing explicit feature profile input")
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return nil, fmt.Errorf("explicit feature profile contains trailing input")
+	}
+	return input, nil
+}
diff --git a/gotoolprofile/consumer_json_test.go b/gotoolprofile/consumer_json_test.go
new file mode 100644
index 000000000..7e714beec
--- /dev/null
+++ b/gotoolprofile/consumer_json_test.go
@@ -0,0 +1,172 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"io"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func largeConsumerJSONFixture() *ConsumerInput {
+	input := &ConsumerInput{
+		Protocol: ConsumerProtocol, SignatureSourceProtocol: SignatureSourceProtocol,
+		TestDependencySourceProtocol: TestDependencyProtocol, Module: "example.invalid/complete",
+		Sources:          map[string]string{"probe.go": strings.Repeat("a", 64)},
+		Headers:          map[string]string{"probe.go": "package complete\n"},
+		Directories:      map[string][]string{".": {"probe.go", "probe_amd64.s"}},
+		AsmFiles:         []string{"probe_amd64.s"},
+		GeneratedHeaders: &MetadataProof{Protocol: MetadataProtocol},
+		TestDependencies: &TestDependencyProof{
+			Protocol: TestDependencyProtocol,
+			Query: &SignatureQueryProof{
+				Protocol: SignatureQueryProtocol,
+				Requests: []SignatureRequest{{File: "probe_amd64.s", Symbol: "example.invalid/complete.probe"}},
+			},
+		},
+	}
+	// Transport tests preserve every field, not just a byte count or digest.
+	// Source/layout authentication remains the separate consumer's job.
+	for index := 0; index < 100; index++ {
+		input.TestDependencies.SourceModules = append(input.TestDependencies.SourceModules, TestModuleSource{
+			Protocol: TestDependencyModuleProtocol, SourceModule: "example.invalid/dependency",
+			Headers: map[string]string{"bound.go": strings.Repeat(" ", 52<<10) + "package dependency\n"},
+		})
+	}
+	return input
+}
+
+func TestConsumerJSONCompleteSourceClosureRoundTrip(t *testing.T) {
+	input := largeConsumerJSONFixture()
+	data, err := MarshalConsumerInput(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(data) <= 4<<20 || len(data) >= ConsumerInputJSONLimit {
+		t.Fatalf("fixture does not exercise the old and new limits: %d", len(data))
+	}
+	canonical, err := json.Marshal(input)
+	if err != nil || !bytes.Equal(data, canonical) {
+		t.Fatal("bounded writer pruned or rewrote canonical source/type/closure bytes")
+	}
+	decoded, err := DecodeConsumerInput(bytes.NewReader(data))
+	if err != nil || !reflect.DeepEqual(decoded, input) {
+		t.Fatalf("complete closure changed in bounded transport: %v", err)
+	}
+}
+
+func TestConsumerJSONExactReadByteBound(t *testing.T) {
+	const object = `{"module":"exact"}`
+	for _, size := range []int{ConsumerInputJSONLimit - 1, ConsumerInputJSONLimit, ConsumerInputJSONLimit + 1} {
+		reader := io.MultiReader(strings.NewReader(object), io.LimitReader(consumerJSONSpaces{}, int64(size-len(object))))
+		decoded, err := DecodeConsumerInput(reader)
+		if size <= ConsumerInputJSONLimit {
+			if err != nil || decoded.Module != "exact" {
+				t.Fatalf("complete JSON at %d bytes: %#v, %v", size, decoded, err)
+			}
+		} else if decoded != nil || err == nil || !strings.Contains(err.Error(), "byte bound") || strings.Contains(err.Error(), "EOF") {
+			t.Fatalf("overflow was not an explicit resource failure: %#v, %v", decoded, err)
+		}
+	}
+	// A limited reader must not consume an unbounded suffix or mistake the
+	// first valid JSON object for proof that the entire artifact fits.
+	counted := &consumerJSONCountingReader{reader: consumerJSONSpaces{}}
+	if _, err := DecodeConsumerInput(counted); err == nil || !strings.Contains(err.Error(), "byte bound") {
+		t.Fatalf("infinite input did not fail at the resource bound: %v", err)
+	}
+	if counted.bytes != ConsumerInputJSONLimit+1 {
+		t.Fatalf("reader consumed %d bytes rather than its bounded witness", counted.bytes)
+	}
+}
+
+func TestConsumerJSONWriterOverflowAndNil(t *testing.T) {
+	if data, err := MarshalConsumerInput(nil); data != nil || err == nil {
+		t.Fatal("nil producer input became a valid artifact")
+	}
+	input := &ConsumerInput{Headers: map[string]string{"too-large.go": strings.Repeat(" ", ConsumerInputJSONLimit)}}
+	if data, err := MarshalConsumerInput(input); data != nil || err == nil || !strings.Contains(err.Error(), "bytes, exceeds its") {
+		t.Fatalf("writer did not reject its own complete oversized output: %v", err)
+	}
+}
+
+func TestConsumerJSONWriterExactByteBound(t *testing.T) {
+	input := &ConsumerInput{}
+	base, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, size := range []int{ConsumerInputJSONLimit, ConsumerInputJSONLimit + 1} {
+		input.Module = strings.Repeat("x", size-len(base))
+		data, err := MarshalConsumerInput(input)
+		if size == ConsumerInputJSONLimit {
+			if err != nil || len(data) != size {
+				t.Fatalf("canonical writer at its exact byte bound: %d, %v", len(data), err)
+			}
+		} else if data != nil || err == nil || !strings.Contains(err.Error(), "bytes, exceeds its") {
+			t.Fatalf("writer at bound+1 lost its explicit resource failure: %v", err)
+		}
+	}
+}
+
+func TestConsumerJSONRejectsMalformedUnknownAndReaderFailures(t *testing.T) {
+	for name, source := range map[string]string{
+		"empty": "", "null": "null", "truncated": `{"module":"x"`,
+		"unknown outer": `{"unbound":true}`, "unknown dependency": `{"test_declaration_dependencies":{"unbound":true}}`,
+		"second object": `{}` + `{}`, "trailing garbage": `{}` + `!`,
+	} {
+		t.Run(name, func(t *testing.T) {
+			if input, err := DecodeConsumerInput(strings.NewReader(source)); input != nil || err == nil {
+				t.Fatal("malformed or unknown proof input was accepted")
+			}
+		})
+	}
+	if input, err := DecodeConsumerInput(nil); input != nil || err == nil {
+		t.Fatal("nil reader was accepted")
+	}
+	witness := errors.New("owned read failed")
+	reader := io.MultiReader(strings.NewReader(`{}`), consumerJSONErrorReader{err: witness})
+	if input, err := DecodeConsumerInput(reader); input != nil || !errors.Is(err, witness) {
+		t.Fatalf("valid prefix masked the underlying source read failure: %v", err)
+	}
+}
+
+func BenchmarkConsumerJSONCompleteClosure(b *testing.B) {
+	data, err := MarshalConsumerInput(largeConsumerJSONFixture())
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(data)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for iteration := 0; iteration < b.N; iteration++ {
+		if _, err := DecodeConsumerInput(bytes.NewReader(data)); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+type consumerJSONSpaces struct{}
+
+func (consumerJSONSpaces) Read(buffer []byte) (int, error) {
+	for index := range buffer {
+		buffer[index] = ' '
+	}
+	return len(buffer), nil
+}
+
+type consumerJSONCountingReader struct {
+	reader io.Reader
+	bytes  int
+}
+
+func (reader *consumerJSONCountingReader) Read(buffer []byte) (int, error) {
+	count, err := reader.reader.Read(buffer)
+	reader.bytes += count
+	return count, err
+}
+
+type consumerJSONErrorReader struct{ err error }
+
+func (reader consumerJSONErrorReader) Read([]byte) (int, error) { return 0, reader.err }
diff --git a/gotoolprofile/consumer_proof.go b/gotoolprofile/consumer_proof.go
new file mode 100644
index 000000000..ccd7f13ff
--- /dev/null
+++ b/gotoolprofile/consumer_proof.go
@@ -0,0 +1,316 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/build"
+	"io"
+	"path"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+// ValidateSelection checks the compact compiler-consumption evidence against
+// the producer's original source/profile inputs. Actual reobservation and ZIP
+// byte comparison happen in production, not in this offline replay.
+func ValidateSelection(input *ConsumerInput, proof *SelectionProof, tags []string, requireObject bool) error {
+	return ValidateSelectionWithABI(input, proof, tags, requireObject, nil)
+}
+
+// Only a caller which independently validated exact target ABI exclusions may
+// permit their missing LLVM outputs. Default consumers never grant this path.
+func ValidateSelectionWithABI(input *ConsumerInput, proof *SelectionProof, tags []string, requireObject bool, abi map[string]bool) error {
+	if input == nil || input.Protocol != ConsumerProtocol || input.ID != ProfileID(input.Observed) {
+		return fmt.Errorf("missing canonical compiler feature input")
+	}
+	if err := Validate(input.Observed); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != ConsumerProtocol || proof.ProfileID != input.ID || !equalDiscoveryStrings(proof.CustomTags, tags) || len(proof.Packages) == 0 {
+		return fmt.Errorf("compiler consumption differs from the source-required profile/tag scope")
+	}
+	if !reflect.DeepEqual(input.RegisteredAsmFiles, proof.RegisteredAsmFiles) {
+		return fmt.Errorf("actual package registration differs from the complete selected assembly scope")
+	}
+	if err := ValidateCPPIncludeSearch(input, proof); err != nil {
+		return err
+	}
+	selectedFiles, filePackages, err := validatePackageSelection(input, proof.Packages, tags)
+	if err != nil {
+		return err
+	}
+	if input.GeneratedHeaders != nil || proof.GeneratedHeaders != nil {
+		if err := ValidateGeneratedHeaderAgreement(input, input.GeneratedHeaders, proof.GeneratedHeaders, tags); err != nil {
+			return err
+		}
+		if !reflect.DeepEqual(proof.Packages, proof.GeneratedHeaders.Packages) {
+			return fmt.Errorf("actual generated header was compiled from a different package selection")
+		}
+	}
+	if err := ValidateSignatureSources(input, proof, tags); err != nil {
+		return err
+	}
+	return validateAssemblyConsumption(input, proof, selectedFiles, filePackages, requireObject, abi)
+}
+
+// ValidatePackageSelection checks actual package selection before CPP or LLVM
+// emission. It establishes no translation outcome: the report reader must
+// separately discharge every source-required scope with an output or a concrete
+// same-scope source diagnostic.
+func ValidatePackageSelection(input *ConsumerInput, packages []PackageProof, tags []string) error {
+	if input == nil || input.Protocol != ConsumerProtocol || input.Observed == nil || input.ID != ProfileID(input.Observed) || len(packages) == 0 {
+		return fmt.Errorf("missing canonical actual package-selection input")
+	}
+	if err := Validate(input.Observed); err != nil {
+		return err
+	}
+	_, _, err := validatePackageSelection(input, packages, tags)
+	return err
+}
+
+// Metadata-only queries reuse source selection without manufacturing CPP or
+// LLVM outputs. Their separate protocol can never satisfy ValidateSelection.
+func validatePackageSelection(input *ConsumerInput, packages []PackageProof, tags []string) (map[string]bool, map[string]PackageProof, error) {
+	ctx, err := ordinaryPackageSelectionContext(input, tags)
+	if err != nil {
+		return nil, nil, err
+	}
+	macros := func(pkg PackageProof) error {
+		return ValidateOrdinaryAssemblerMacros(pkg.Macros, input.Observed, pkg.PackagePath)
+	}
+	return validatePackageSelectionContext(input, packages, input.AsmFiles, input.RegisteredAsmFiles, ctx, macros)
+}
+
+// Both public protocol readers retain their own validated scope/context. This
+// common replay does not choose a mode or turn an ordinary observation into one.
+func validatePackageSelectionContext(input *ConsumerInput, packages []PackageProof, assembly, registered []string, ctx build.Context, validateMacros func(PackageProof) error) (map[string]bool, map[string]PackageProof, error) {
+	selectedFiles, seenPackages := make(map[string]bool), make(map[string]bool)
+	filePackages := make(map[string]PackageProof)
+	requiredAssembly := make(map[string]bool)
+	for _, file := range assembly {
+		requiredAssembly[file] = true
+	}
+	if registered != nil {
+		if len(registered) == 0 || !sort.StringsAreSorted(registered) {
+			return nil, nil, fmt.Errorf("noncanonical complete package assembly registration")
+		}
+		requiredAssembly = make(map[string]bool)
+		for _, file := range registered {
+			if requiredAssembly[file] || path.Ext(file) != ".s" || input.Sources[file] == "" ||
+				input.Sources[file] == bytesSHA256(nil) {
+				return nil, nil, fmt.Errorf("duplicate, empty or unhashed package assembly registration: %s", file)
+			}
+			requiredAssembly[file] = true
+		}
+		for _, file := range assembly {
+			if !requiredAssembly[file] {
+				return nil, nil, fmt.Errorf("translation file lies outside the complete package registration: %s", file)
+			}
+		}
+	}
+	for _, pkg := range packages {
+		if err := ValidatePackageModule(input, pkg); err != nil {
+			return nil, nil, err
+		}
+		if pkg.PackagePath != input.Module && !strings.HasPrefix(pkg.PackagePath, input.Module+"/") || seenPackages[pkg.PackagePath] {
+			return nil, nil, fmt.Errorf("actual selected package has a different or duplicate module role")
+		}
+		seenPackages[pkg.PackagePath] = true
+		if err := validateMacros(pkg); err != nil {
+			return nil, nil, err
+		}
+		if len(pkg.GoFiles) == 0 || len(pkg.CompiledGoFiles) == 0 || len(pkg.SFiles) == 0 {
+			return nil, nil, fmt.Errorf("compiler consumption lacks actual ordinary Go/ASM selection")
+		}
+		usedSources := make(map[string]string)
+		for _, files := range [][]string{pkg.GoFiles, pkg.CompiledGoFiles, pkg.SFiles} {
+			if !sort.StringsAreSorted(files) {
+				return nil, nil, fmt.Errorf("noncanonical actual selected source order")
+			}
+			for index, file := range files {
+				if index > 0 && file == files[index-1] || input.Sources[file] == "" || input.Sources[file] != pkg.SourceSHA256[file] {
+					return nil, nil, fmt.Errorf("actual selected source has no exact original SHA: %s", file)
+				}
+				usedSources[file] = pkg.SourceSHA256[file]
+				wantedPath := input.Module
+				if path.Dir(file) != "." {
+					wantedPath += "/" + path.Dir(file)
+				}
+				if pkg.PackagePath != wantedPath {
+					return nil, nil, fmt.Errorf("actual package role differs from the original source directory: %s", file)
+				}
+				if path.Ext(file) == ".go" || path.Ext(file) == ".s" {
+					selected, err := ctx.MatchFile(path.Dir(file), path.Base(file))
+					if err != nil || !selected || strings.HasSuffix(file, "_test.go") {
+						return nil, nil, fmt.Errorf("actual source selection contradicts its original feature constraints: %s: %v", file, err)
+					}
+				}
+			}
+		}
+		if !reflect.DeepEqual(usedSources, pkg.SourceSHA256) {
+			return nil, nil, fmt.Errorf("actual package source hash map has missing/extra consumption")
+		}
+		for _, file := range pkg.SFiles {
+			if selectedFiles[file] || path.Ext(file) != ".s" {
+				return nil, nil, fmt.Errorf("duplicate/non-ASM actual selected file")
+			}
+			// Go-selected zero-byte siblings have no translation count.
+			if !requiredAssembly[file] && (input.Sources[file] != bytesSHA256(nil) || input.Headers[file] != "") {
+				return nil, nil, fmt.Errorf("nonempty Go-selected assembly lies outside the tested scope: %s", file)
+			}
+			selectedFiles[file] = true
+			filePackages[file] = pkg
+		}
+	}
+	for file := range requiredAssembly {
+		if !selectedFiles[file] {
+			return nil, nil, fmt.Errorf("registered assembly lacks actual same-profile package selection: %s", file)
+		}
+	}
+	return selectedFiles, filePackages, nil
+}
+
+func ordinaryPackageSelectionContext(input *ConsumerInput, tags []string) (build.Context, error) {
+	minor, err := goMinor(input.Observed.GoVersion)
+	if err != nil {
+		return build.Context{}, err
+	}
+	ctx := build.Default
+	ctx.JoinPath = path.Join
+	ctx.GOOS, ctx.GOARCH = input.Observed.Environment["GOOS"], input.Observed.Environment["GOARCH"]
+	ctx.Compiler, ctx.CgoEnabled, ctx.BuildTags = "gc", false, tags
+	ctx.ToolTags, ctx.ReleaseTags = input.Observed.ToolTags, nil
+	for version := 1; version <= minor; version++ {
+		ctx.ReleaseTags = append(ctx.ReleaseTags, fmt.Sprintf("go1.%d", version))
+	}
+	ctx.OpenFile = func(name string) (io.ReadCloser, error) {
+		header, found := input.Headers[name]
+		if !found {
+			return nil, fmt.Errorf("actual Go file has no original selection header: %s", name)
+		}
+		return io.NopCloser(strings.NewReader(header)), nil
+	}
+	return ctx, nil
+}
+
+func validateAssemblyConsumption(input *ConsumerInput, proof *SelectionProof, selectedFiles map[string]bool, filePackages map[string]PackageProof, requireObject bool, abi map[string]bool) error {
+	consumed, err := validateCPPConsumption(input, proof, selectedFiles, filePackages)
+	if err != nil {
+		return err
+	}
+	outputs := make(map[string]bool)
+	seenParts := make(map[string]bool)
+	for _, output := range proof.Outputs {
+		key := output.File + "\x00" + output.Part
+		if !consumed[output.File] || abi[output.File] || seenParts[key] || path.Base(output.Part) != output.Part || !strings.HasSuffix(output.Part, ".ll") || !discoverySHA256Pattern.MatchString(output.IR) || requireObject && !discoverySHA256Pattern.MatchString(output.Object) {
+			return fmt.Errorf("missing, duplicate or unselected LLVM IR/object consumption")
+		}
+		seenParts[key], outputs[output.File] = true, true
+	}
+	for _, file := range input.AsmFiles {
+		if !selectedFiles[file] || !consumed[file] || !outputs[file] && !abi[file] {
+			return fmt.Errorf("source-required file lacks actual package/CPP/LLVM consumption: %s", file)
+		}
+	}
+	if len(consumed) != len(input.AsmFiles) || len(outputs)+len(abi) != len(input.AsmFiles) {
+		return fmt.Errorf("compiler consumption differs from the exact file/profile scope")
+	}
+	return nil
+}
+
+// Preflight reuses only the source/CPP portion. It never manufactures an LLVM
+// output or satisfies the separate translation consumption gate.
+func validateCPPConsumption(input *ConsumerInput, proof *SelectionProof, selectedFiles map[string]bool, filePackages map[string]PackageProof) (map[string]bool, error) {
+	if err := ValidateCPPIncludeSearch(input, proof); err != nil {
+		return nil, err
+	}
+	consumed := make(map[string]bool)
+	for _, cpp := range proof.CPP {
+		if consumed[cpp.File] || !selectedFiles[cpp.File] || !discoverySHA256Pattern.MatchString(cpp.ExpandedSHA256) || !discoverySHA256Pattern.MatchString(cpp.TypedExpandedSHA256) || len(cpp.Inputs) == 0 {
+			return nil, fmt.Errorf("missing, duplicate or unselected actual CPP consumption")
+		}
+		consumed[cpp.File] = true
+		if input.CPPOriginals != nil {
+			pkg := filePackages[cpp.File]
+			var header []byte
+			if proof.GeneratedHeaders != nil {
+				for _, actual := range proof.GeneratedHeaders.Headers {
+					if actual.PackagePath == pkg.PackagePath {
+						var err error
+						header, err = CanonicalGeneratedHeader(actual.Definitions)
+						if err != nil {
+							return nil, err
+						}
+					}
+				}
+			}
+			actual, used, required, err := ReplayCPPOriginal(input, cpp.File, pkg.PackagePath, pkg.Macros.Defines, header)
+			if err != nil || ValidateCPPExpandedOperands(input, cpp.File, required) != nil ||
+				cpp.ExpandedSearchMisses == nil || !reflect.DeepEqual(cpp.ExpandedSearchMisses, required) ||
+				cpp.ExpandedSHA256 != bytesSHA256([]byte(actual.Output)) || !reflect.DeepEqual(used, cpp.Inputs) {
+				return nil, fmt.Errorf("actual CPP differs from the independent original graph/expanded operands: %v", err)
+			}
+		}
+		for id, digest := range cpp.Inputs {
+			origin, file, present := strings.Cut(id, "/")
+			wanted := input.Sources[file]
+			if origin == "tool" {
+				wanted = input.ToolSources[file]
+			}
+			if origin == "generated" {
+				wanted = generatedCPPSourceSHA(proof.GeneratedHeaders, filePackages[cpp.File].PackagePath, file)
+			}
+			if !present || origin != "module" && origin != "tool" && origin != "generated" || wanted == "" || digest != wanted {
+				return nil, fmt.Errorf("actual CPP source differs from exact original input: %s", id)
+			}
+		}
+		if cpp.Inputs["module/"+cpp.File] != input.Sources[cpp.File] {
+			return nil, fmt.Errorf("actual CPP proof omits its assembly source")
+		}
+		if err := ValidateEmptyAssembly(input, cpp, filePackages[cpp.File]); err != nil {
+			return nil, err
+		}
+	}
+	for _, file := range input.AsmFiles {
+		if !selectedFiles[file] || !consumed[file] {
+			return nil, fmt.Errorf("source-required file lacks actual package/CPP consumption: %s", file)
+		}
+	}
+	if len(consumed) != len(input.AsmFiles) {
+		return nil, fmt.Errorf("CPP consumption differs from the exact file/profile scope")
+	}
+	return consumed, nil
+}
+
+func ValidatePackageModule(input *ConsumerInput, pkg PackageProof) error {
+	if input == nil || pkg.ModulePath != input.Module || pkg.ModuleVersion != input.Version {
+		return fmt.Errorf("actual Go package module/version differs from the explicit consumer input")
+	}
+	if metadata := input.ProxyGoMod; metadata != nil {
+		if err := ValidateProxyGoMod(metadata); err != nil {
+			return err
+		}
+		if input.Sources["go.mod"] != "" || input.Module != metadata.Module || input.SourceModule != metadata.Module || input.Version != metadata.Version ||
+			pkg.GoModOrigin != metadata.Protocol || pkg.GoModSHA256 != metadata.SHA256 || pkg.GoModSum != metadata.GoModSum {
+			return fmt.Errorf("actual package lacks the independent authenticated proxy metadata origin")
+		}
+	} else if pkg.GoModOrigin != "" || pkg.GoModSHA256 != "" || pkg.GoModSum != "" {
+		return fmt.Errorf("package proxy metadata has no independently authenticated source proof")
+	}
+	module := input.SourceModule
+	if module == "" {
+		module = input.Module
+	}
+	if pkg.SourceModule != module || pkg.SourceVersion != input.Version {
+		return fmt.Errorf("actual Go replacement source module/version differs from exact original inputs")
+	}
+	if input.SourceModule != "" {
+		if pkg.SourceRole != "module" && pkg.SourceRole != "version_replace" {
+			return fmt.Errorf("original exact-module proof cannot be relabeled from main/owned-local sources")
+		}
+	} else if (pkg.SourceRole != "main" && pkg.SourceRole != "owned_local_replace") ||
+		(pkg.SourceRole == "main" && input.Version != "") {
+		return fmt.Errorf("explicit own-source consumer lacks an exact main/local role")
+	}
+	return nil
+}
diff --git a/gotoolprofile/cpp_generated_header_suspension.go b/gotoolprofile/cpp_generated_header_suspension.go
new file mode 100644
index 000000000..5141c4b1b
--- /dev/null
+++ b/gotoolprofile/cpp_generated_header_suspension.go
@@ -0,0 +1,36 @@
+package gotoolprofile
+
+import "fmt"
+
+// Only the actual active include callback can construct this requirement.
+// Candidate resources, malformed controls and unknown includes do not suspend
+// planning, and no successful execution or header permission is implied.
+type cppGeneratedHeaderRequirement struct {
+	assembly string
+	operand  string
+}
+
+func (e *cppGeneratedHeaderRequirement) Error() string {
+	return fmt.Sprintf("active CPP operand has no independently registered original: %s", e.operand)
+}
+
+func (e *cppGeneratedHeaderRequirement) CPPGeneratedHeaderRequirement() (assembly, operand string) {
+	return e.assembly, e.operand
+}
+
+// CPPOriginalNeedsGeneratedHeader accepts only a single wrapped callback
+// requirement for this exact assembly. A joined or unrelated error must never
+// be swallowed while the producer obtains its actual compiler header.
+func CPPOriginalNeedsGeneratedHeader(err error, assembly string) bool {
+	for depth := 0; err != nil && depth < 32; depth++ {
+		if requirement, ok := err.(*cppGeneratedHeaderRequirement); ok {
+			return requirement.assembly == assembly && requirement.operand == "go_asm.h"
+		}
+		wrapped, ok := err.(interface{ Unwrap() error })
+		if !ok {
+			return false
+		}
+		err = wrapped.Unwrap()
+	}
+	return false
+}
diff --git a/gotoolprofile/cpp_generated_header_suspension_test.go b/gotoolprofile/cpp_generated_header_suspension_test.go
new file mode 100644
index 000000000..5153bb0f6
--- /dev/null
+++ b/gotoolprofile/cpp_generated_header_suspension_test.go
@@ -0,0 +1,89 @@
+package gotoolprofile
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCPPOriginalActiveGeneratedHeaderHasTypedRequirement(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		source string
+		active bool
+	}{
+		{"active", "#include \"go_asm.h\"\nTEXT ·Probe(SB),4,$0-0\nRET\n", true},
+		{"macro_generated", "#define INCLUDE(file) \\\n#include file \\\n\nINCLUDE(\"go_asm.h\")\nTEXT ·Probe(SB),4,$0-0\nRET\n", true},
+		{"inactive", "#ifdef absent\n#include \"go_asm.h\"\n#endif\nTEXT ·Probe(SB),4,$0-0\nRET\n", false},
+		{"candidate_only", "TEXT ·Probe(SB),4,$0-0\nRET\nDATA ·name(SB)/8,$\"go_asm.h\"\n", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			input := generatedHeaderSuspensionInput(test.source)
+			_, _, _, err := ReplayCPPOriginal(input, "probe.s", "example.invalid/header", nil, nil)
+			var requirement interface {
+				CPPGeneratedHeaderRequirement() (assembly, operand string)
+			}
+			if !test.active {
+				if err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			if err == nil || !strings.Contains(err.Error(), "active CPP operand has no independently registered original: go_asm.h") {
+				t.Fatalf("missing real active-include failure: %v", err)
+			}
+			if !errors.As(err, &requirement) {
+				t.Fatalf("actual active generated-header callback lacks a typed requirement: %v", err)
+			}
+			assembly, operand := requirement.CPPGeneratedHeaderRequirement()
+			if assembly != "probe.s" || operand != "go_asm.h" {
+				t.Fatalf("typed requirement lost actual assembly/operand: %q %q", assembly, operand)
+			}
+			if !CPPOriginalNeedsGeneratedHeader(err, "probe.s") || CPPOriginalNeedsGeneratedHeader(err, "other.s") ||
+				CPPOriginalNeedsGeneratedHeader(errors.Join(err, fmt.Errorf("independent source guard failure")), "probe.s") {
+				t.Fatal("generated-header suspension accepted a foreign or combined error")
+			}
+			_, _, _, err = ReplayCPPOriginal(input, "probe.s", "example.invalid/header", nil, []byte("#define Record__size 8\n"))
+			if err != nil {
+				t.Fatalf("actual supplied native-header control: %v", err)
+			}
+		})
+	}
+}
+
+func TestCPPOriginalUnregisteredOperandIsNotGeneratedHeaderRequirement(t *testing.T) {
+	for _, source := range []string{
+		"#include \"unknown.h\"\n",
+		"#include FILE\n",
+		"#unknown control\n",
+	} {
+		input := generatedHeaderSuspensionInput(source)
+		_, _, _, err := ReplayCPPOriginal(input, "probe.s", "example.invalid/header", nil, nil)
+		var requirement interface {
+			CPPGeneratedHeaderRequirement() (assembly, operand string)
+		}
+		if err == nil || errors.As(err, &requirement) {
+			t.Fatalf("unrelated original CPP error acquired header suspension: %v", err)
+		}
+		if CPPOriginalNeedsGeneratedHeader(err, "probe.s") {
+			t.Fatal("unregistered operand entered actual-header planning")
+		}
+	}
+}
+
+func generatedHeaderSuspensionInput(source string) *ConsumerInput {
+	return &ConsumerInput{
+		CPPSourceProtocol: CPPOriginalReplayProtocol,
+		AsmFiles:          []string{"probe.s"},
+		Sources:           map[string]string{"probe.s": bytesSHA256([]byte(source))},
+		ToolSources:       map[string]string{},
+		CPPOriginals: &CPPOriginalReplayInput{
+			Sources: map[string]string{"module/probe.s": source},
+			Units: map[string]CPPOriginalUnit{
+				"probe.s": {Includes: map[string]string{}, GeneratedHeaders: []string{"go_asm.h"}},
+			},
+			RequiredExpandedOperands: map[string][]CPPPackageSearchMiss{},
+		},
+	}
+}
diff --git a/gotoolprofile/cpp_include.go b/gotoolprofile/cpp_include.go
new file mode 100644
index 000000000..111ad4609
--- /dev/null
+++ b/gotoolprofile/cpp_include.go
@@ -0,0 +1,219 @@
+package gotoolprofile
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"text/scanner"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const CPPPackageSearchMissProtocol = "actual_go_fixed_include_search_miss_v1"
+const CPPExpandedPackageSearchMissProtocol = "actual_go_fixed_include_expanded_search_miss_v2"
+
+// CPPPackageSearchMiss records an unavailable package-directory candidate.
+// Only the independently bound canonical GOROOT fallback may replace it. The
+// producer and consumer recheck ENOENT before and after their compiler phases.
+type CPPPackageSearchMiss struct {
+	Protocol         string `json:"protocol"`
+	Assembly         string `json:"assembly"`
+	Source           string `json:"source"`
+	Include          string `json:"include"`
+	PackageCandidate string `json:"package_candidate"`
+	ToolSource       string `json:"tool_source"`
+}
+
+func CPPLocalSource(file string) bool {
+	return sourcepath.CPPLocalSource(file)
+}
+
+// CPPIncludeCandidates follows cmd/asm's fixed original package directory and
+// GOROOT/pkg/include search. A candidate may escape one origin but not both;
+// callers must not read an escaping candidate or accept its existence.
+func CPPIncludeCandidates(assembly, include string) (module, tool string, err error) {
+	if !CPPLocalSource(assembly) || include == "" || path.IsAbs(include) || strings.ContainsAny(include, ":\\\x00\r\n") {
+		return "", "", fmt.Errorf("unsafe fixed Go CPP include")
+	}
+	module = path.Clean(path.Join(path.Dir(assembly), include))
+	tool = path.Clean(path.Join("pkg/include", include))
+	if !CPPLocalSource(module) && !CPPLocalSource(tool) {
+		return "", "", fmt.Errorf("CPP include escapes both exact source origins")
+	}
+	return module, tool, nil
+}
+
+func ValidateCPPPackageSearchMiss(miss CPPPackageSearchMiss) error {
+	module, tool, err := CPPIncludeCandidates(miss.Assembly, miss.Include)
+	origin, source, present := strings.Cut(miss.Source, "/")
+	physical := miss.Protocol == CPPPackageSearchMissProtocol && present &&
+		(origin == "module" || origin == "tool") && CPPLocalSource(source)
+	expanded := miss.Protocol == CPPExpandedPackageSearchMissProtocol && miss.Source == ""
+	if err != nil || !physical && !expanded ||
+		CPPLocalSource(module) || !CPPLocalSource(tool) ||
+		miss.PackageCandidate != module || miss.ToolSource != tool {
+		return fmt.Errorf("missing exact outside-package search absence witness")
+	}
+	return nil
+}
+
+func VerifyCPPPackageSearchMiss(miss CPPPackageSearchMiss, moduleRoot, goRoot string) error {
+	if err := ValidateCPPPackageSearchMiss(miss); err != nil {
+		return err
+	}
+	preferred, err := CPPPreferredPackageInclude(moduleRoot, miss.Assembly, miss.Include)
+	if err != nil {
+		return err
+	}
+	if _, err := os.Lstat(preferred); err == nil {
+		return fmt.Errorf("outside-module preferred CPP candidate exists")
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return fmt.Errorf("outside-module preferred CPP candidate has no ENOENT proof: %w", err)
+	}
+	if miss.Protocol == CPPExpandedPackageSearchMissProtocol {
+		// This verifies only physical ENOENT. The full original graph and
+		// actual execution must separately bind the v2 expanded operand.
+		return nil
+	}
+	origin, source, _ := strings.Cut(miss.Source, "/")
+	root := moduleRoot
+	if origin == "tool" {
+		root = goRoot
+	}
+	name, err := CPPRegularSource(root, source)
+	if err != nil {
+		return err
+	}
+	data, err := os.ReadFile(name)
+	if err != nil {
+		return err
+	}
+	if !cppLiteralInclude(data, miss.Include) {
+		return fmt.Errorf("CPP search absence has no original literal source operand")
+	}
+	return nil
+}
+
+func CPPPreferredPackageInclude(moduleRoot, assembly, include string) (string, error) {
+	if _, _, err := CPPIncludeCandidates(assembly, include); err != nil {
+		return "", err
+	}
+	root, err := sourcepath.Resolve(moduleRoot)
+	if err != nil || !filepath.IsAbs(root) {
+		return "", fmt.Errorf("CPP search has no actual canonical module origin")
+	}
+	packageDir := filepath.Join(root, filepath.FromSlash(path.Dir(assembly)))
+	physicalDir, err := sourcepath.Resolve(packageDir)
+	if err != nil || physicalDir != packageDir {
+		return "", fmt.Errorf("CPP package directory is missing or redirected")
+	}
+	return filepath.Join(physicalDir, filepath.FromSlash(include)), nil
+}
+
+// Active consumption derives this from the actual including source, even
+// when the fallback still has the historical pkg/include prefix. A caller
+// cannot delete the witness and borrow that older tool-header allowance.
+func RequireCPPPackageSearchMiss(input *ConsumerInput, assembly, source, include string) error {
+	module, tool, err := CPPIncludeCandidates(assembly, include)
+	if err != nil {
+		return err
+	}
+	if CPPLocalSource(module) {
+		return nil
+	}
+	expected := CPPPackageSearchMiss{
+		Protocol: CPPPackageSearchMissProtocol, Assembly: assembly, Source: source,
+		Include: include, PackageCandidate: module, ToolSource: tool,
+	}
+	for _, miss := range input.CPPIncludeSearchMisses {
+		if miss == expected {
+			return nil
+		}
+	}
+	return fmt.Errorf("active outside-package CPP include lacks its original fixed-search absence")
+}
+
+func ValidateCPPIncludeSearch(input *ConsumerInput, proof *SelectionProof) error {
+	if input == nil || proof != nil && !reflect.DeepEqual(input.CPPIncludeSearchMisses, proof.CPPIncludeSearchMisses) {
+		return fmt.Errorf("actual CPP package search absence differs from its original input")
+	}
+	if err := ValidateCPPOriginalInputs(input); err != nil {
+		return err
+	}
+	if proof != nil && proof.CPPSourceProtocol != input.CPPSourceProtocol {
+		return fmt.Errorf("CPP original source protocol was deleted or downgraded")
+	}
+	seen, tools := make(map[string]bool), make(map[string]bool)
+	last := ""
+	for _, miss := range input.CPPIncludeSearchMisses {
+		key := miss.Assembly + "\x00" + miss.Source + "\x00" + miss.Include
+		origin, source, _ := strings.Cut(miss.Source, "/")
+		digest := input.Sources[source]
+		if origin == "tool" {
+			digest = input.ToolSources[source]
+		}
+		if miss.Protocol == CPPExpandedPackageSearchMissProtocol {
+			digest = input.Sources[miss.Assembly]
+			if input.CPPOriginals == nil || input.CPPSourceProtocol != CPPOriginalReplayProtocol || !containsString(input.AsmFiles, miss.Assembly) {
+				return fmt.Errorf("expanded CPP receipt lacks its independent full original inputs")
+			}
+		}
+		if err := ValidateCPPPackageSearchMiss(miss); err != nil || seen[key] || key <= last ||
+			input.Sources[miss.Assembly] == "" || digest == "" || input.ToolSources[miss.ToolSource] == "" {
+			return fmt.Errorf("CPP search absence is unbound, duplicated or noncanonical")
+		}
+		seen[key], tools[miss.ToolSource], last = true, true, key
+	}
+	for source := range input.ToolSources {
+		if !CPPLocalSource(source) || !strings.HasPrefix(source, "pkg/include/") && !tools[source] && !cppOriginalToolRegistered(input, source) {
+			return fmt.Errorf("tool CPP source lacks the exact fixed-search absence contract")
+		}
+	}
+	return nil
+}
+
+func SortCPPIncludeSearch(misses []CPPPackageSearchMiss) {
+	sort.Slice(misses, func(i, j int) bool {
+		x, y := misses[i], misses[j]
+		return x.Assembly+"\x00"+x.Source+"\x00"+x.Include < y.Assembly+"\x00"+y.Source+"\x00"+y.Include
+	})
+}
+
+// CPPRegularSource binds a canonical regular source within its actual origin.
+// In particular GOROOT-relative includes cannot redirect through symlinks.
+func CPPRegularSource(root, file string) (string, error) {
+	return sourcepath.CPPRegularSource(root, file)
+}
+
+func cppLiteralInclude(data []byte, wanted string) bool {
+	var scan scanner.Scanner
+	scan.Init(strings.NewReader(string(data)))
+	scan.Mode = scanner.ScanIdents | scanner.ScanStrings | scanner.ScanChars | scanner.ScanInts |
+		scanner.ScanFloats | scanner.ScanComments | scanner.SkipComments
+	scan.Whitespace = 1<<' ' | 1<<'\t' | 1<<'\r'
+	invalid := false
+	scan.Error = func(*scanner.Scanner, string) { invalid = true }
+	for token := scan.Scan(); token != scanner.EOF; token = scan.Scan() {
+		if token != '#' {
+			continue
+		}
+		if scan.Scan() != scanner.Ident || scan.TokenText() != "include" || scan.Scan() != scanner.String {
+			continue
+		}
+		literal, err := strconv.Unquote(scan.TokenText())
+		terminator := scan.Scan()
+		// This binds an original literal, not a complete input-stack directive.
+		// Included EOF may resume a parent's newline; Go and active CPP still
+		// require that newline and reject translation-unit EOF independently.
+		if (terminator == '\n' || terminator == scanner.EOF) && err == nil && literal == wanted && !invalid {
+			return true
+		}
+	}
+	return false
+}
diff --git a/gotoolprofile/cpp_include_eof_test.go b/gotoolprofile/cpp_include_eof_test.go
new file mode 100644
index 000000000..c0c06fe1a
--- /dev/null
+++ b/gotoolprofile/cpp_include_eof_test.go
@@ -0,0 +1,27 @@
+package gotoolprofile
+
+import "testing"
+
+func TestCPPIncludeLiteralPresenceDoesNotDecideInputStackEOF(t *testing.T) {
+	// Literal authentication is not directive syntax acceptance. An included
+	// tokenizer may resume its parent's newline; the active Go/CPP input stack
+	// must still reject the same directive at translation-unit EOF.
+	for _, source := range []string{
+		"#include \"../../src/value.h\"",
+		"#include \"../../src/value.h\" // final included comment",
+	} {
+		if !cppLiteralInclude([]byte(source), "../../src/value.h") {
+			t.Fatalf("original literal at included EOF was discarded: %q", source)
+		}
+	}
+	for _, source := range []string{
+		"#include \"../../src/value.h\" junk",
+		"#include \"../../src/other.h\"",
+		"// #include \"../../src/value.h\"",
+		"#include \"../../src/value.h",
+	} {
+		if cppLiteralInclude([]byte(source), "../../src/value.h") {
+			t.Fatalf("missing or invalid literal was authenticated: %q", source)
+		}
+	}
+}
diff --git a/gotoolprofile/cpp_include_root_test.go b/gotoolprofile/cpp_include_root_test.go
new file mode 100644
index 000000000..6805b1eb8
--- /dev/null
+++ b/gotoolprofile/cpp_include_root_test.go
@@ -0,0 +1,75 @@
+package gotoolprofile
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCPPIncludeAbsenceFollowsPhysicalPackageCWD(t *testing.T) {
+	base := t.TempDir()
+	physical, tool := filepath.Join(base, "real/module"), filepath.Join(base, "tool")
+	for name, content := range map[string]string{
+		"real/module/pkg/native.s": "#include \"../../src/value.h\"\nTEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$SOURCE_VALUE\nGLOBL ·value(SB),8,$4\n",
+		"real/src/value.h":         "#define SOURCE_VALUE 99\n",
+		"tool/src/value.h":         "#define SOURCE_VALUE 42\n",
+	} {
+		file := filepath.Join(base, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	alias := filepath.Join(base, "alias")
+	if err := os.Symlink(physical, alias); err != nil {
+		t.Fatal(err)
+	}
+	// The capture factory resolves its command directory before invoking Go.
+	// Windows' lexical '..' resolution through an unresolved alias is not the
+	// same search: keep it as an independent control, not the factory witness.
+	canonical, err := filepath.EvalSymlinks(alias)
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	observe := func(root, want string) {
+		t.Helper()
+		for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+			out, stderr, err := instrumentationActualCommand(t, filepath.Join(root, "pkg"),
+				instrumentationActualEnv(target, "0"), goBinary, "tool", "asm", "-S",
+				"-I", filepath.Join(tool, "pkg/include"), "-o", filepath.Join(t.TempDir(), "go.o"), "native.s")
+			if err != nil || len(stderr) != 0 || !strings.Contains(string(out), want) {
+				t.Fatalf("actual Go include selection (%s, root %s), want %s: %v\n%s\n%s", target, root, want, err, out, stderr)
+			}
+		}
+	}
+	observe(canonical, "63 00 00 00")
+	aliasValue := "63 00 00 00"
+	if runtime.GOOS == "windows" {
+		aliasValue = "2a 00 00 00"
+	}
+	observe(alias, aliasValue)
+	miss := CPPPackageSearchMiss{
+		Protocol: CPPPackageSearchMissProtocol, Assembly: "pkg/native.s", Source: "module/pkg/native.s",
+		Include: "../../src/value.h", PackageCandidate: "../src/value.h", ToolSource: "src/value.h",
+	}
+	if err := VerifyCPPPackageSearchMiss(miss, alias, tool); err == nil {
+		t.Fatal("lexical symlink parent hid the actual package-CWD preferred source")
+	}
+	if err := os.Remove(filepath.Join(base, "real/src/value.h")); err != nil {
+		t.Fatal(err)
+	}
+	if err := VerifyCPPPackageSearchMiss(miss, alias, tool); err != nil {
+		t.Fatalf("physical CWD correctly missing its original candidate: %v", err)
+	}
+	observe(canonical, "2a 00 00 00")
+	observe(alias, "2a 00 00 00")
+}
diff --git a/gotoolprofile/cpp_include_test.go b/gotoolprofile/cpp_include_test.go
new file mode 100644
index 000000000..93570a850
--- /dev/null
+++ b/gotoolprofile/cpp_include_test.go
@@ -0,0 +1,80 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCPPPackageIncludeAbsenceUsesPhysicalSourceAndEnvironment(t *testing.T) {
+	base := t.TempDir()
+	moduleRoot, toolRoot := filepath.Join(base, "module"), filepath.Join(base, "tool")
+	for name, contents := range map[string]string{
+		"module/pkg/native.s": "#include \"../../src/value.h\"\n",
+		"module/pkg/plain.go": "package fixture\n",
+		"tool/src/value.h":    "#define VALUE 42\n",
+	} {
+		file := filepath.Join(base, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	miss := CPPPackageSearchMiss{
+		Protocol: CPPPackageSearchMissProtocol, Assembly: "pkg/native.s", Source: "module/pkg/native.s",
+		Include: "../../src/value.h", PackageCandidate: "../src/value.h", ToolSource: "src/value.h",
+	}
+	if err := VerifyCPPPackageSearchMiss(miss, moduleRoot, toolRoot); err != nil {
+		t.Fatal(err)
+	}
+	input := &ConsumerInput{
+		Sources:                map[string]string{"pkg/native.s": strings.Repeat("a", 64), "pkg/plain.go": strings.Repeat("b", 64)},
+		ToolSources:            map[string]string{"src/value.h": strings.Repeat("c", 64)},
+		CPPIncludeSearchMisses: []CPPPackageSearchMiss{miss},
+	}
+	if err := ValidateCPPIncludeSearch(input, &SelectionProof{CPPIncludeSearchMisses: []CPPPackageSearchMiss{miss}}); err != nil {
+		t.Fatal(err)
+	}
+	input.CPPIncludeSearchMisses[0].Source = "module/pkg/plain.go"
+	if err := VerifyCPPPackageSearchMiss(input.CPPIncludeSearchMisses[0], moduleRoot, toolRoot); err == nil {
+		t.Fatal("self-consistent metadata authenticated a source with no include operand")
+	}
+	input.CPPIncludeSearchMisses = nil
+	if err := ValidateCPPIncludeSearch(input, nil); err == nil {
+		t.Fatal("deleting all absence evidence fell back to arbitrary tool source acceptance")
+	}
+	preferred := filepath.Join(base, "src/value.h")
+	if err := os.MkdirAll(filepath.Dir(preferred), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(filepath.Join(toolRoot, "src/value.h"), preferred); err != nil {
+		t.Fatal(err)
+	}
+	if err := VerifyCPPPackageSearchMiss(miss, moduleRoot, toolRoot); err == nil {
+		t.Fatal("outside-source shadow symlink was treated as absence")
+	}
+}
+
+func TestCPPIncludeTokensMatchOriginalQuotedOperand(t *testing.T) {
+	for _, source := range []string{
+		"#include \"../../src/value.h\"\n",
+		"#include \"../..\\x2fsrc/value.h\" // original quoted escape\n",
+	} {
+		if !cppLiteralInclude([]byte(source), "../../src/value.h") {
+			t.Fatalf("actual quoted include operand was not retained: %q", source)
+		}
+	}
+	for _, source := range []string{
+		"// #include \"../../src/value.h\"\n",
+		"/* #include \"../../src/value.h\" */\n",
+		"#include \"../../src/value.h\" junk\n",
+		"#include \"../../src/other.h\"\n",
+	} {
+		if cppLiteralInclude([]byte(source), "../../src/value.h") {
+			t.Fatalf("not an exact original include operand: %q", source)
+		}
+	}
+}
diff --git a/gotoolprofile/cpp_include_windows_test.go b/gotoolprofile/cpp_include_windows_test.go
new file mode 100644
index 000000000..e8e3bb8ed
--- /dev/null
+++ b/gotoolprofile/cpp_include_windows_test.go
@@ -0,0 +1,50 @@
+//go:build windows
+
+package gotoolprofile
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestCPPRegularSourceWindowsJunctionBoundaries(t *testing.T) {
+	t.Setenv("GODEBUG", "winsymlink=1,winreadlinkvolume=1")
+	base := t.TempDir()
+	root, outside := filepath.Join(base, "root"), filepath.Join(base, "outside")
+	for _, dir := range []string{root, outside} {
+		if err := os.Mkdir(dir, 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, "source.h"), []byte("#define VALUE 7\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	junction := func(alias, target string) {
+		t.Helper()
+		ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+		defer cancel()
+		command := exec.CommandContext(ctx, "cmd", "/c", "mklink", "/J", alias, target)
+		if output, err := command.CombinedOutput(); err != nil {
+			t.Fatalf("create required actual junction: %v\n%s", err, output)
+		}
+	}
+	alias := filepath.Join(base, "alias")
+	junction(alias, root)
+	want, err := sourcepath.Resolve(filepath.Join(root, "source.h"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, err := CPPRegularSource(alias, "source.h"); err != nil || got != want {
+		t.Fatalf("root alias lost its actual regular source: got=%q want=%q error=%v", got, want, err)
+	}
+	junction(filepath.Join(root, "redirected"), outside)
+	if got, err := CPPRegularSource(alias, "redirected/source.h"); err == nil || got != "" {
+		t.Fatalf("nested junction bypassed original source containment: %q (%v)", got, err)
+	}
+}
diff --git a/gotoolprofile/cpp_original_replay.go b/gotoolprofile/cpp_original_replay.go
new file mode 100644
index 000000000..1f36e2063
--- /dev/null
+++ b/gotoolprofile/cpp_original_replay.go
@@ -0,0 +1,280 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"path"
+	"reflect"
+	"strconv"
+	"strings"
+	"text/scanner"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+const CPPOriginalReplayProtocol = "exact_go_cpp_original_replay_v3"
+
+// CPPOriginalReplayInput transports query inputs, not source authority. Its
+// bytes must independently match the actual module/archive and selected SDK.
+// RequiredExpandedOperands is populated only after replay with the real header
+// and ordered driver defines. A missing or null entry cannot enter CPP/object.
+type CPPOriginalReplayInput struct {
+	Sources                  map[string]string                 `json:"sources"`
+	Units                    map[string]CPPOriginalUnit        `json:"units"`
+	RequiredExpandedOperands map[string][]CPPPackageSearchMiss `json:"required_expanded_operands"`
+}
+
+type CPPOriginalUnit struct {
+	Includes         map[string]string `json:"includes"`
+	GeneratedHeaders []string          `json:"generated_headers"`
+}
+
+func ValidateCPPOriginalInputs(input *ConsumerInput) error {
+	if input == nil {
+		return fmt.Errorf("missing CPP original input")
+	}
+	graph := input.CPPOriginals
+	if input.CPPSourceProtocol == "" && graph == nil {
+		return nil // Historical inputs retain their physical-literal contract.
+	}
+	if input.CPPSourceProtocol != CPPOriginalReplayProtocol || graph == nil ||
+		len(graph.Sources) == 0 || len(graph.Sources) > 512 || len(graph.Units) == 0 || len(graph.Units) > 512 {
+		return fmt.Errorf("CPP original graph/protocol is missing or unbounded")
+	}
+	total := 0
+	for id, text := range graph.Sources {
+		origin, file, ok := strings.Cut(id, "/")
+		wanted := input.Sources[file]
+		if origin == "tool" {
+			wanted = input.ToolSources[file]
+		}
+		if !ok || (origin != "module" && origin != "tool") || !CPPLocalSource(file) ||
+			len(text) > 64<<20-total || wanted == "" || bytesSHA256([]byte(text)) != wanted {
+			return fmt.Errorf("CPP original bytes lack their independent source hash: %s", id)
+		}
+		total += len(text)
+	}
+	for assembly, unit := range graph.Units {
+		// The complete source loop already authenticated every module/tool
+		// original against its exact hash. Retain the unit's source/edge checks
+		// without copying and hashing the same assembly bytes a second time.
+		_, original := graph.Sources["module/"+assembly]
+		if !CPPLocalSource(assembly) || input.Sources[assembly] == "" ||
+			!original || len(unit.Includes) > 100000 {
+			return fmt.Errorf("CPP original unit has no complete assembly source")
+		}
+		for include, id := range unit.Includes {
+			module, tool, err := CPPIncludeCandidates(assembly, include)
+			_, present := graph.Sources[id]
+			if err != nil || !present || id != "module/"+module && id != "tool/"+tool ||
+				id == "tool/"+tool && CPPLocalSource(module) && input.Sources[module] != "" {
+				return fmt.Errorf("CPP original resource differs from fixed search origins")
+			}
+		}
+		for index, name := range unit.GeneratedHeaders {
+			if index != 0 || name != "go_asm.h" || unit.Includes[name] != "" {
+				return fmt.Errorf("CPP deferred header has no exact compiler role")
+			}
+		}
+	}
+	// Object scope can be narrower than actual Go selection. Both executed
+	// originals and registered source-only companions need their complete unit;
+	// deleting a companion must not bypass source closure via a smaller graph.
+	for _, files := range [][]string{input.AsmFiles, input.RegisteredAsmFiles} {
+		for _, assembly := range files {
+			if _, exists := graph.Units[assembly]; !exists {
+				return fmt.Errorf("CPP original graph omitted selected package assembly: %s", assembly)
+			}
+		}
+	}
+	for assembly, required := range graph.RequiredExpandedOperands {
+		if _, exists := graph.Units[assembly]; !exists || !containsString(input.AsmFiles, assembly) {
+			return fmt.Errorf("CPP expanded operands claim an unknown assembly")
+		}
+		last := ""
+		for _, miss := range required {
+			key := cppSearchMissKey(miss)
+			if miss.Assembly != assembly || miss.Protocol != CPPExpandedPackageSearchMissProtocol ||
+				ValidateCPPPackageSearchMiss(miss) != nil || key <= last || input.ToolSources[miss.ToolSource] == "" {
+				return fmt.Errorf("CPP expanded operand set is unbound or noncanonical")
+			}
+			last = key
+		}
+	}
+	return nil
+}
+
+// ReplayCPPOriginal executes the one shared token-stack engine. It does not
+// read physical files or authenticate its inputs; producer, consumer and reader
+// independently bind those before comparing output, used bytes and operands.
+func ReplayCPPOriginal(input *ConsumerInput, assembly, packagePath string, defines []string, header []byte) (plan9asm.AssemblyCPPObservation, map[string]string, []CPPPackageSearchMiss, error) {
+	if err := ValidateCPPOriginalInputs(input); err != nil {
+		return plan9asm.AssemblyCPPObservation{}, nil, nil, err
+	}
+	if input.CPPOriginals == nil {
+		return plan9asm.AssemblyCPPObservation{}, nil, nil, fmt.Errorf("CPP replay lacks its full original graph")
+	}
+	graph, unit := input.CPPOriginals, input.CPPOriginals.Units[assembly]
+	original := "module/" + assembly
+	text, exists := graph.Sources[original]
+	if !exists {
+		return plan9asm.AssemblyCPPObservation{}, nil, nil, fmt.Errorf("CPP replay has no assembly original")
+	}
+	used := map[string]string{original: bytesSHA256([]byte(text))}
+	observation, err := plan9asm.ObserveAssemblyCPP(text, plan9asm.AssemblyPreprocessOptions{
+		FileName: original, Defines: defines,
+		ReadInclude: func(_ string, name string) (string, []byte, error) {
+			id := unit.Includes[name]
+			if id == "" {
+				for _, deferred := range unit.GeneratedHeaders {
+					if name == deferred && header == nil {
+						return "", nil, &cppGeneratedHeaderRequirement{assembly: assembly, operand: name}
+					}
+					if name == deferred && header != nil && packagePath != "" {
+						id = "generated/" + packagePath + "/go_asm.h"
+						used[id] = bytesSHA256(header)
+						return id, append([]byte(nil), header...), nil
+					}
+				}
+				return "", nil, fmt.Errorf("active CPP operand has no independently registered original: %s", name)
+			}
+			data, exists := graph.Sources[id]
+			if !exists {
+				return "", nil, fmt.Errorf("active CPP operand omitted its original bytes")
+			}
+			used[id] = bytesSHA256([]byte(data))
+			return id, []byte(data), nil
+		},
+	})
+	if err != nil {
+		return plan9asm.AssemblyCPPObservation{}, nil, nil, err
+	}
+	required, err := CPPExpandedOperands(input, assembly, observation)
+	if err != nil {
+		return plan9asm.AssemblyCPPObservation{}, nil, nil, err
+	}
+	return observation, used, required, nil
+}
+
+// CPPExpandedOperands consumes actual execution events, never raw candidate
+// records. Physical includes still require their unchanged v1 literal witness.
+func CPPExpandedOperands(input *ConsumerInput, assembly string, observation plan9asm.AssemblyCPPObservation) ([]CPPPackageSearchMiss, error) {
+	if input == nil || input.CPPOriginals == nil {
+		return nil, fmt.Errorf("expanded CPP event has no full original input")
+	}
+	unit := input.CPPOriginals.Units[assembly]
+	required := []CPPPackageSearchMiss{}
+	seen := make(map[string]bool)
+	for _, event := range observation.Events {
+		if event.Kind != "control" || event.Directive != "include" || !event.Executed || !event.EnabledBefore {
+			continue
+		}
+		var include string
+		var err error
+		for _, token := range event.Tokens {
+			if token.Kind == scanner.String {
+				include, err = strconv.Unquote(token.RecordedValue)
+				break
+			}
+		}
+		module, tool, candidateErr := CPPIncludeCandidates(assembly, include)
+		if err != nil || candidateErr != nil || event.Included != unit.Includes[include] && !strings.HasPrefix(event.Included, "generated/") {
+			return nil, fmt.Errorf("active expanded include lost its exact operand/origin")
+		}
+		if CPPLocalSource(module) {
+			continue
+		}
+		if event.Expansion == 0 {
+			if err := RequireCPPPackageSearchMiss(input, assembly, event.Position.File, include); err != nil {
+				return nil, err
+			}
+			continue
+		}
+		miss := CPPPackageSearchMiss{Protocol: CPPExpandedPackageSearchMissProtocol, Assembly: assembly,
+			Include: include, PackageCandidate: module, ToolSource: tool}
+		if event.Included != "tool/"+tool || ValidateCPPPackageSearchMiss(miss) != nil {
+			return nil, fmt.Errorf("expanded outside-package include has no canonical SDK fallback")
+		}
+		key := cppSearchMissKey(miss)
+		if !seen[key] {
+			seen[key] = true
+			required = append(required, miss)
+		}
+	}
+	SortCPPIncludeSearch(required)
+	return required, nil
+}
+
+func ValidateCPPExpandedOperands(input *ConsumerInput, assembly string, actual []CPPPackageSearchMiss) error {
+	if input == nil || input.CPPOriginals == nil || actual == nil {
+		return fmt.Errorf("CPP object lacks its actual expanded operand set")
+	}
+	wanted, present := input.CPPOriginals.RequiredExpandedOperands[assembly]
+	if !present || wanted == nil || !reflect.DeepEqual(wanted, actual) {
+		return fmt.Errorf("CPP expanded operands differ from the independently replayed producer inputs")
+	}
+	var receipts []CPPPackageSearchMiss
+	for _, miss := range input.CPPIncludeSearchMisses {
+		if miss.Assembly == assembly && miss.Protocol == CPPExpandedPackageSearchMissProtocol {
+			receipts = append(receipts, miss)
+		}
+	}
+	if len(receipts) != len(actual) || len(actual) != 0 && !reflect.DeepEqual(receipts, actual) {
+		return fmt.Errorf("CPP expanded absence receipts are missing, extra or unconsumed")
+	}
+	return nil
+}
+
+// CPPOriginalExecutionInput is used only after the caller has validated an
+// actual mode header/selection. It leaves the original query input and its
+// digest untouched; no ordinary/baseline operand collection is inherited.
+func CPPOriginalExecutionInput(input *ConsumerInput, assembly, packagePath string, defines []string, header []byte) (*ConsumerInput, []CPPPackageSearchMiss, error) {
+	data, err := MarshalConsumerInput(input)
+	if err != nil {
+		return nil, nil, err
+	}
+	clone, err := DecodeConsumerInput(strings.NewReader(string(data)))
+	if err != nil {
+		return nil, nil, err
+	}
+	_, _, required, err := ReplayCPPOriginal(clone, assembly, packagePath, defines, header)
+	if err != nil {
+		return nil, nil, err
+	}
+	clone.CPPOriginals.RequiredExpandedOperands = map[string][]CPPPackageSearchMiss{assembly: required}
+	physical := []CPPPackageSearchMiss{}
+	for _, miss := range clone.CPPIncludeSearchMisses {
+		if miss.Protocol == CPPPackageSearchMissProtocol {
+			physical = append(physical, miss)
+		}
+	}
+	clone.CPPIncludeSearchMisses = append(physical, required...)
+	SortCPPIncludeSearch(clone.CPPIncludeSearchMisses)
+	return clone, required, nil
+}
+
+func cppSearchMissKey(miss CPPPackageSearchMiss) string {
+	return miss.Assembly + "\x00" + miss.Source + "\x00" + miss.Include
+}
+
+// A source-only query may retain inactive SDK resources without claiming an
+// active absence receipt. Actual CPP/object additionally checks its full set.
+func cppOriginalToolRegistered(input *ConsumerInput, source string) bool {
+	if input.CPPOriginals == nil || input.CPPSourceProtocol != CPPOriginalReplayProtocol {
+		return false
+	}
+	for _, unit := range input.CPPOriginals.Units {
+		for _, id := range unit.Includes {
+			if id == "tool/"+source {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func CPPOriginalPackagePath(module, assembly string) string {
+	if directory := path.Dir(assembly); directory != "." {
+		return module + "/" + directory
+	}
+	return module
+}
diff --git a/gotoolprofile/cpp_original_replay_complexity_test.go b/gotoolprofile/cpp_original_replay_complexity_test.go
new file mode 100644
index 000000000..ea8f6366c
--- /dev/null
+++ b/gotoolprofile/cpp_original_replay_complexity_test.go
@@ -0,0 +1,113 @@
+package gotoolprofile
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Query validation only: this fixture supplies no original-source authority,
+// actual compiler object, platform applicability or assembly-ledger success.
+func cppOriginalValidationFixture(t testing.TB, units int) *ConsumerInput {
+	t.Helper()
+	input := &ConsumerInput{
+		CPPSourceProtocol: CPPOriginalReplayProtocol,
+		Sources:           make(map[string]string), ToolSources: make(map[string]string),
+		CPPOriginals: &CPPOriginalReplayInput{
+			Sources: make(map[string]string), Units: make(map[string]CPPOriginalUnit),
+			RequiredExpandedOperands: make(map[string][]CPPPackageSearchMiss),
+		},
+	}
+	for index := 0; index < units; index++ {
+		file := fmt.Sprintf("pkg/native_%03d.s", index)
+		text := "TEXT ·Probe(SB),4,$0-0\nRET\n" + strings.Repeat("// complete original bytes\n", 2048)
+		digest := sha256.Sum256([]byte(text))
+		input.Sources[file] = hex.EncodeToString(digest[:])
+		input.CPPOriginals.Sources["module/"+file] = text
+		input.CPPOriginals.Units[file] = CPPOriginalUnit{Includes: make(map[string]string)}
+		input.AsmFiles = append(input.AsmFiles, file)
+	}
+	return input
+}
+
+func TestCPPOriginalValidationHashesEverySourceOnce(t *testing.T) {
+	const units = 16
+	input := cppOriginalValidationFixture(t, units)
+	sparse := cppOriginalValidationFixture(t, units)
+	first := sparse.AsmFiles[0]
+	sparse.AsmFiles = []string{first}
+	sparse.CPPOriginals.Units = map[string]CPPOriginalUnit{first: sparse.CPPOriginals.Units[first]}
+	measure := func(in *ConsumerInput) int64 {
+		result := testing.Benchmark(func(b *testing.B) {
+			for index := 0; index < b.N; index++ {
+				if err := ValidateCPPOriginalInputs(in); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+		return result.AllocedBytesPerOp()
+	}
+	sparseBytes, fullBytes := measure(sparse), measure(input)
+	t.Logf("identical complete source graph: one unit=%d B/op; sixteen units=%d B/op", sparseBytes, fullBytes)
+	// Both controls validate every original, including the fifteen originals
+	// without a unit in the sparse graph. Extra units may allocate keys, but
+	// must not allocate another copy of the same complete source per digest.
+	if fullBytes-sparseBytes > units*1024 {
+		t.Fatalf("CPP units rehash independently validated originals: extra bytes=%d > %d", fullBytes-sparseBytes, units*1024)
+	}
+}
+
+func TestCPPOriginalSinglePassValidationRetainsAllResources(t *testing.T) {
+	input := cppOriginalValidationFixture(t, 2)
+	toolFile, toolText := "pkg/include/inactive.h", "#define INACTIVE 1\n"
+	digest := sha256.Sum256([]byte(toolText))
+	input.ToolSources[toolFile] = hex.EncodeToString(digest[:])
+	input.CPPOriginals.Sources["tool/"+toolFile] = toolText
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateCPPOriginalInputs(input); err != nil {
+		t.Fatal(err)
+	}
+	for _, fixture := range []struct {
+		name   string
+		mutate func(*ConsumerInput)
+	}{
+		{"first_original", func(in *ConsumerInput) { in.CPPOriginals.Sources["module/"+in.AsmFiles[0]] += "changed" }},
+		{"last_original", func(in *ConsumerInput) { in.CPPOriginals.Sources["module/"+in.AsmFiles[1]] += "changed" }},
+		{"hash", func(in *ConsumerInput) { in.Sources[in.AsmFiles[0]] = strings.Repeat("0", 64) }},
+		{"missing_original", func(in *ConsumerInput) { delete(in.CPPOriginals.Sources, "module/"+in.AsmFiles[0]) }},
+		{"missing_hash", func(in *ConsumerInput) { delete(in.Sources, in.AsmFiles[0]) }},
+		{"inactive_tool_original", func(in *ConsumerInput) { in.CPPOriginals.Sources["tool/"+toolFile] += "changed" }},
+		{"inactive_tool_hash", func(in *ConsumerInput) { in.ToolSources[toolFile] = strings.Repeat("0", 64) }},
+		{"unbound_include", func(in *ConsumerInput) {
+			in.CPPOriginals.Units[in.AsmFiles[0]].Includes["missing.h"] = "module/pkg/missing.h"
+		}},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			var changed ConsumerInput
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			fixture.mutate(&changed)
+			if err := ValidateCPPOriginalInputs(&changed); err == nil {
+				t.Fatal("single-pass validation omitted complete original/resource binding")
+			}
+		})
+	}
+}
+
+func BenchmarkCPPOriginalValidation(b *testing.B) {
+	input := cppOriginalValidationFixture(b, 16)
+	b.ReportAllocs()
+	b.ResetTimer()
+	for index := 0; index < b.N; index++ {
+		if err := ValidateCPPOriginalInputs(input); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/gotoolprofile/data_only_assembly.go b/gotoolprofile/data_only_assembly.go
new file mode 100644
index 000000000..37cee86dd
--- /dev/null
+++ b/gotoolprofile/data_only_assembly.go
@@ -0,0 +1,190 @@
+package gotoolprofile
+
+import (
+	"bufio"
+	"fmt"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+const DataOnlyAssemblyProtocol = "actual_go_data_only_symbol_listing_v1"
+
+// The producer derives the complete compact symbol inventory from a successful
+// original Go -S listing, rejecting every TEXT and unknown listing record.
+// Full data dumps stay out of the ledger. Like native empty-object evidence,
+// offline validation relies on the frozen producer, not a digest claiming to
+// cryptographically authenticate unavailable object bytes.
+type DataOnlyAssemblyProof struct {
+	Native  EmptyAssemblyProof `json:"native"`
+	Symbols []DataOnlySymbol   `json:"symbols"`
+}
+
+type DataOnlySymbol struct {
+	Name   string `json:"name"`
+	Kind   string `json:"kind"`
+	Static bool   `json:"static,omitempty"`
+	Size   int64  `json:"size"`
+}
+
+func (symbol DataOnlySymbol) Key() string {
+	if symbol.Static {
+		return symbol.Name + "<>"
+	}
+	return symbol.Name
+}
+
+var dataSymbolHeader = regexp.MustCompile(`^(\S+) (S[A-Z0-9]+) (static )?(dupok )?(cfunc )?size=([0-9]+) align=0x[0-9a-f]+$`)
+var legacyDataSymbolHeader = regexp.MustCompile(`^(\S+) (S[A-Z0-9]+) (static )?(dupok )?(cfunc )?size=([0-9]+)$`)
+var dataListingBytes = regexp.MustCompile(`^\t0x[0-9a-f]+( [0-9a-f]{2}){1,16} {2,}`)
+var dataListingRelocation = regexp.MustCompile(`^\trel -?[0-9]+\+[0-9]+ t=R_[A-Za-z0-9_:]+ .+\+-?[0-9a-f]+$`)
+
+func isDataOnlySymbolKind(kind string) bool {
+	switch kind {
+	case "SRODATA", "SRODATAFIPS", "SDATA", "SDATAFIPS", "SNOPTRDATA", "SNOPTRDATAFIPS", "SBSS", "SNOPTRBSS", "STLSBSS":
+		return true
+	default:
+		return false
+	}
+}
+
+func DataOnlySymbolsFromListing(listing []byte) ([]DataOnlySymbol, error) {
+	return dataOnlySymbolsFromListing(listing, dataSymbolHeader)
+}
+
+// DataOnlySymbolsFromListingForGoVersion selects the actual producer's header
+// grammar. Go 1.20-1.26 print alignment only for TEXT; Go 1.27 also prints it
+// for DATA. A missing current field or an extra historical field is not valid.
+// This parses an inventory, not a source, memory or object capability.
+func DataOnlySymbolsFromListingForGoVersion(listing []byte, version string) ([]DataOnlySymbol, error) {
+	minor, err := goMinor(version)
+	if err != nil || minor < 20 || minor > 27 {
+		return nil, fmt.Errorf("data-only listing requires a supported actual Go producer version")
+	}
+	header := dataSymbolHeader
+	if minor < 27 {
+		header = legacyDataSymbolHeader
+	}
+	return dataOnlySymbolsFromListing(listing, header)
+}
+
+func dataOnlySymbolsFromListing(listing []byte, header *regexp.Regexp) ([]DataOnlySymbol, error) {
+	if len(listing) == 0 || len(listing) > 4<<20 || listing[len(listing)-1] != '\n' {
+		return nil, fmt.Errorf("data-only native listing is empty, incomplete or too large")
+	}
+	scanner := bufio.NewScanner(strings.NewReader(string(listing)))
+	scanner.Buffer(nil, 64<<10)
+	var symbols []DataOnlySymbol
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "\t") {
+			if len(symbols) == 0 || !dataListingBytes.MatchString(line) && !dataListingRelocation.MatchString(line) {
+				return nil, fmt.Errorf("unknown non-data native listing record")
+			}
+			continue
+		}
+		match := header.FindStringSubmatch(line)
+		if match == nil || !isDataOnlySymbolKind(match[2]) {
+			return nil, fmt.Errorf("native data-only listing contains TEXT or an unknown symbol kind")
+		}
+		size, err := strconv.ParseInt(match[6], 10, 64)
+		if err != nil {
+			return nil, fmt.Errorf("invalid native data symbol size: %w", err)
+		}
+		symbols = append(symbols, DataOnlySymbol{Name: match[1], Kind: match[2], Static: match[3] != "", Size: size})
+		if len(symbols) > 16384 {
+			return nil, fmt.Errorf("native data-only symbol inventory exceeds its bound")
+		}
+	}
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+	sort.Slice(symbols, func(i, j int) bool { return symbols[i].Key() < symbols[j].Key() })
+	if err := validateDataOnlySymbols(symbols); err != nil {
+		return nil, err
+	}
+	return symbols, nil
+}
+
+func validateDataOnlySymbols(symbols []DataOnlySymbol) error {
+	if len(symbols) == 0 || len(symbols) > 16384 {
+		return fmt.Errorf("data-only assembly lacks a bounded nonempty symbol inventory")
+	}
+	for index, symbol := range symbols {
+		if symbol.Name == "" || strings.ContainsAny(symbol.Name, "\x00\r\n\t <>") ||
+			!isDataOnlySymbolKind(symbol.Kind) || symbol.Size < 0 ||
+			index > 0 && symbol.Key() <= symbols[index-1].Key() {
+			return fmt.Errorf("noncanonical, duplicate or non-data native symbol inventory")
+		}
+	}
+	return nil
+}
+
+// ValidateDataOnlySourceSymbols compares the complete parsed source's global
+// identities and sizes with the actual original assembler listing inventory.
+// It neither supplies bytes nor grants a source, object or native-memory role.
+func ValidateDataOnlySourceSymbols(file *plan9asm.File, packagePath string, symbols []DataOnlySymbol) error {
+	if file == nil || len(file.Funcs) != 0 || len(file.Globl) == 0 {
+		return fmt.Errorf("data-only source requires global declarations and no TEXT")
+	}
+	if err := validateDataOnlySymbols(symbols); err != nil {
+		return err
+	}
+	wanted := make(map[string]int64)
+	for _, global := range file.Globl {
+		name := strings.TrimSuffix(global.Sym, "<>")
+		if strings.HasPrefix(name, "·") {
+			name = NativeGoPackagePrefix(packagePath) + name
+		}
+		name = strings.ReplaceAll(strings.ReplaceAll(name, "·", "."), "∕", "/")
+		if strings.HasSuffix(global.Sym, "<>") {
+			name += "<>"
+		}
+		if _, duplicate := wanted[name]; duplicate || global.SizeRaw != "" {
+			return fmt.Errorf("data-only source has duplicate or unresolved GLOBL")
+		}
+		wanted[name] = global.Size
+	}
+	if len(wanted) != len(symbols) {
+		return fmt.Errorf("Go native data symbols differ from translated global declarations")
+	}
+	for _, symbol := range symbols {
+		if size, present := wanted[symbol.Key()]; !present || size != symbol.Size {
+			return fmt.Errorf("Go native data symbol name/size differs from translated GLOBL")
+		}
+	}
+	return nil
+}
+
+// NativeGoPackagePrefix is cmd/asm's byte-level objabi.PathToPrefix spelling,
+// not the LLVM logical symbol namespace and not URL escaping.
+func NativeGoPackagePrefix(packagePath string) string {
+	return gosym.PackagePrefix(packagePath)
+}
+
+func ValidateDataOnlyAssembly(input *ConsumerInput, cpp CPPProof, pkg PackageProof) error {
+	proof := cpp.DataOnlyAssembly
+	if (cpp.Emission == "data_only") != (proof != nil) {
+		return fmt.Errorf("data-only assembly requires an explicit same-scope native witness")
+	}
+	if proof == nil {
+		return nil
+	}
+	native := proof.Native
+	if input == nil || input.Observed == nil || input.SignatureSourceProtocol != SignatureSourceProtocol ||
+		native.Protocol != DataOnlyAssemblyProtocol || cpp.EmptyAssembly != nil || len(cpp.Signatures) != 0 ||
+		native.File != cpp.File || native.SourceSHA256 != input.Sources[cpp.File] ||
+		native.PackagePath != pkg.PackagePath || native.ProfileID != input.ID ||
+		native.Target != input.Observed.Target || native.GoVersion != input.Observed.GoVersion ||
+		native.AsmToolSHA256 != input.Observed.ToolBinarySHA256["asm"] ||
+		!discoverySHA256Pattern.MatchString(native.ObjectSHA256) ||
+		native.ObjectSHA256 == bytesSHA256(nil) ||
+		!discoverySHA256Pattern.MatchString(native.ListingSHA256) || native.ListingSHA256 == bytesSHA256(nil) {
+		return fmt.Errorf("data-only evidence differs from its actual Go/source/package/profile scope")
+	}
+	return validateDataOnlySymbols(proof.Symbols)
+}
diff --git a/gotoolprofile/data_only_assembly_test.go b/gotoolprofile/data_only_assembly_test.go
new file mode 100644
index 000000000..c8866da09
--- /dev/null
+++ b/gotoolprofile/data_only_assembly_test.go
@@ -0,0 +1,85 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDataOnlyNativeListingRequiresSelectedProducerGrammar(t *testing.T) {
+	const legacy = "pkg.data SDATA size=8\n" +
+		"\t0x0000 00 00 00 00 00 00 00 00                          ........\n" +
+		"pkg.zero SBSS size=16\n"
+	current := strings.ReplaceAll(strings.ReplaceAll(legacy, "size=8\n", "size=8 align=0x0\n"),
+		"size=16\n", "size=16 align=0x0\n")
+	for minor := 20; minor <= 27; minor++ {
+		version := fmt.Sprintf("go1.%d.1", minor)
+		t.Run(version, func(t *testing.T) {
+			accepted, refused := legacy, current
+			if minor == 27 {
+				accepted, refused = current, legacy
+			}
+			got, err := DataOnlySymbolsFromListingForGoVersion([]byte(accepted), version)
+			want := []DataOnlySymbol{{Name: "pkg.data", Kind: "SDATA", Size: 8}, {Name: "pkg.zero", Kind: "SBSS", Size: 16}}
+			if err != nil || !reflect.DeepEqual(got, want) {
+				t.Fatalf("producer inventory mismatch: %+v %v", got, err)
+			}
+			for _, malformed := range []string{refused, accepted + refused,
+				strings.Replace(accepted, "SDATA", "STEXT", 1), accepted + "tool warning\n"} {
+				if _, err := DataOnlySymbolsFromListingForGoVersion([]byte(malformed), version); err == nil {
+					t.Fatal("wrong producer or non-data listing accepted", malformed)
+				}
+			}
+		})
+	}
+	for _, version := range []string{"", "go1.19.13", "go1.28.1", "unknown"} {
+		if _, err := DataOnlySymbolsFromListingForGoVersion([]byte(current), version); err == nil {
+			t.Fatal("unknown producer acquired a listing grammar", version)
+		}
+	}
+	if _, err := DataOnlySymbolsFromListing([]byte(legacy)); err == nil {
+		t.Fatal("current-only entry silently accepted a missing alignment field")
+	}
+}
+
+func TestDataOnlyNativeListingCompleteGrammar(t *testing.T) {
+	const listing = "pkg.data SDATA size=8 align=0x0\n\t0x0000 f0 de bc 9a 78 56 34 12                          ....xV4.\n" +
+		"pkg.zero SBSS size=16 align=0x0\n" +
+		"local SRODATA static dupok size=8 align=0x0\n\t0x0000 00 00 00 00 00 00 00 00                          ........\n\trel 0+8 t=R_ADDR pkg.data+0\n"
+	want := []DataOnlySymbol{
+		{Name: "local", Kind: "SRODATA", Static: true, Size: 8},
+		{Name: "pkg.data", Kind: "SDATA", Size: 8},
+		{Name: "pkg.zero", Kind: "SBSS", Size: 16},
+	}
+	got, err := DataOnlySymbolsFromListing([]byte(listing))
+	if err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("complete data/relocation listing: got=%+v err=%v", got, err)
+	}
+	for name, source := range map[string]string{
+		"empty":            "",
+		"TEXT":             "pkg.fn STEXT nosplit size=1 args=0x0 locals=0x0 funcid=0x0\n",
+		"mixed TEXT":       listing + "pkg.fn STEXT size=1 align=0x0\n",
+		"unknown kind":     "pkg.other SUNDEFINED size=8 align=0x0\n",
+		"unknown record":   listing + "tool warning\n",
+		"headerless data":  "\t0x0000 00 00                          ..\n",
+		"instruction body": "pkg.data SDATA size=8 align=0x0\n\t0x0000 00000 (source.s:2) RET\n",
+		"duplicate":        listing + "pkg.zero SBSS size=16 align=0x0\n",
+		"missing newline":  "pkg.zero SBSS size=16 align=0x0",
+		"overflow size":    "pkg.zero SBSS size=9223372036854775808 align=0x0\n",
+		"negative size":    "pkg.zero SBSS size=-1 align=0x0\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := DataOnlySymbolsFromListing([]byte(source)); err == nil {
+				t.Fatal("non-data or incomplete original listing was accepted")
+			}
+		})
+	}
+	for _, kind := range []string{"SRODATA", "SRODATAFIPS", "SDATA", "SDATAFIPS", "SNOPTRDATA", "SNOPTRDATAFIPS", "SBSS", "SNOPTRBSS", "STLSBSS"} {
+		t.Run(kind, func(t *testing.T) {
+			if _, err := DataOnlySymbolsFromListing([]byte("pkg.symbol " + kind + " size=8 align=0x0\n")); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/doc.go b/gotoolprofile/doc.go
new file mode 100644
index 000000000..4ff36ae5e
--- /dev/null
+++ b/gotoolprofile/doc.go
@@ -0,0 +1,8 @@
+// Package gotoolprofile observes and verifies the Go toolchain inputs consumed
+// by the assembly translator. It is shared by the translator CLI and external
+// compatibility runners; neither observations nor serialized proofs grant new
+// lowering permissions without the corresponding source and consumer checks.
+//
+// This package follows the translator's version. Compatibility runners should
+// pin it and the translator executable to the same source revision.
+package gotoolprofile
diff --git a/gotoolprofile/empty_assembly.go b/gotoolprofile/empty_assembly.go
new file mode 100644
index 000000000..afb0a3b15
--- /dev/null
+++ b/gotoolprofile/empty_assembly.go
@@ -0,0 +1,30 @@
+package gotoolprofile
+
+import "fmt"
+
+const EmptyAssemblyProtocol = "actual_go_symbol_free_listing_v1"
+
+func ValidateEmptyAssembly(input *ConsumerInput, cpp CPPProof, pkg PackageProof) error {
+	proof := cpp.EmptyAssembly
+	if cpp.Emission != "assembly" && cpp.Emission != "symbol_free" && cpp.Emission != "data_only" ||
+		(cpp.Emission == "symbol_free") != (proof != nil) {
+		return fmt.Errorf("empty assembly requires an explicit same-scope native witness")
+	}
+	if err := ValidateDataOnlyAssembly(input, cpp, pkg); err != nil {
+		return err
+	}
+	if proof == nil {
+		return nil // Normal TEXT and data modules use the ordinary output proof.
+	}
+	if input == nil || input.Observed == nil || proof.Protocol != EmptyAssemblyProtocol ||
+		proof.File != cpp.File || proof.SourceSHA256 != input.Sources[cpp.File] ||
+		proof.PackagePath != pkg.PackagePath || proof.ProfileID != input.ID ||
+		proof.Target != input.Observed.Target || proof.GoVersion != input.Observed.GoVersion ||
+		proof.AsmToolSHA256 != input.Observed.ToolBinarySHA256["asm"] ||
+		!discoverySHA256Pattern.MatchString(proof.ObjectSHA256) ||
+		proof.ObjectSHA256 == bytesSHA256(nil) ||
+		proof.ListingSHA256 != bytesSHA256(nil) {
+		return fmt.Errorf("empty assembly evidence differs from its actual Go/source/package/profile scope")
+	}
+	return nil
+}
diff --git a/gotoolprofile/feature_environment.go b/gotoolprofile/feature_environment.go
new file mode 100644
index 000000000..e5233e8bc
--- /dev/null
+++ b/gotoolprofile/feature_environment.go
@@ -0,0 +1,43 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"strings"
+)
+
+// FeatureCommandEnvironment constructs a fresh target's actual command
+// environment. It does not normalize a returned observation or an already
+// authenticated consumer environment. Capture and cache inspection must use
+// this same construction before querying the real Go driver.
+func FeatureCommandEnvironment(base []string, target string, overrides map[string]string) ([]string, error) {
+	parts := strings.Split(target, "/")
+	if len(parts) != 2 || parts[0] == "" {
+		return nil, fmt.Errorf("invalid feature target %q", target)
+	}
+	cpuKeys := map[string]string{
+		"386": "GO386", "amd64": "GOAMD64", "arm": "GOARM", "arm64": "GOARM64", "wasm": "GOWASM",
+	}
+	cpuKey, supported := cpuKeys[parts[1]]
+	if !supported {
+		return nil, fmt.Errorf("unsupported feature target %q", target)
+	}
+	replacements := map[string]string{
+		"GOOS": parts[0], "GOARCH": parts[1], "CGO_ENABLED": "0",
+		"GOTOOLCHAIN": "local", "GOWORK": "off", "GOFLAGS": "",
+	}
+	for _, key := range []string{"GO386", "GOAMD64", "GOARM", "GOARM64", "GOWASM"} {
+		if key != cpuKey {
+			replacements[key] = ""
+		}
+	}
+	for key, value := range overrides {
+		if key != cpuKey && key != "GOEXPERIMENT" {
+			return nil, fmt.Errorf("feature profile cannot override %s for %s", key, target)
+		}
+		replacements[key] = value
+	}
+	// Empty inactive process values can still be supplied by Go's configuration
+	// files. Preserve GOENV and the real query output: unchanged strict replay
+	// rejects any resulting foreign CPU field rather than erasing evidence.
+	return replaceEnv(base, replacements), nil
+}
diff --git a/gotoolprofile/features.go b/gotoolprofile/features.go
new file mode 100644
index 000000000..92e983f1d
--- /dev/null
+++ b/gotoolprofile/features.go
@@ -0,0 +1,514 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// The target-driver foundation is integrated with profile scopes separately;
+// it must not silently turn feature-only inputs into baseline exclusions.
+type discoveryTargetFeatures = Observation
+
+const discoveryFeatureMarkerModule = "example.invalid/plan9asm-feature-markers"
+
+var discoveryFeatureEnvKeys = []string{
+	"CGO_ENABLED", "GOCACHE", "GO386", "GOAMD64", "GOARCH", "GOARM", "GOARM64", "GOEXPERIMENT", "GOOS", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOWASM",
+}
+
+func captureDiscoveryTargetFeatures(ctx context.Context, goBinary, markerDir string, baseEnv []string, target string, overrides map[string]string, run Runner) (*discoveryTargetFeatures, error) {
+	env, err := FeatureCommandEnvironment(baseEnv, target, overrides)
+	if err != nil {
+		return nil, err
+	}
+	parts := strings.Split(target, "/")
+	cpuKeys := map[string]string{"386": "GO386", "amd64": "GOAMD64", "arm": "GOARM", "arm64": "GOARM64", "wasm": "GOWASM"}
+	cpuKey := cpuKeys[parts[1]]
+	if !filepath.IsAbs(goBinary) || !filepath.IsAbs(markerDir) {
+		return nil, fmt.Errorf("feature driver and owned marker directory must be absolute")
+	}
+	resolvedDir, err := sourcepath.Resolve(markerDir)
+	if err != nil {
+		return nil, err
+	}
+	entries, err := os.ReadDir(resolvedDir)
+	if err != nil {
+		return nil, fmt.Errorf("read owned feature marker directory: %w", err)
+	}
+	if len(entries) != 0 {
+		return nil, fmt.Errorf("feature marker directory must exist and be empty")
+	}
+	driverHash, err := discoveryFeatureFileSHA256(goBinary)
+	if err != nil {
+		return nil, fmt.Errorf("feature driver: %w", err)
+	}
+	args := append([]string{"env", "-json"}, discoveryFeatureEnvKeys...)
+	output, envStderr, err := run(ctx, resolvedDir, env, goBinary, args...)
+	if err != nil {
+		return nil, fmt.Errorf("feature target environment: %w", err)
+	}
+	var actualEnv map[string]string
+	if err := json.Unmarshal(output, &actualEnv); err != nil {
+		return nil, fmt.Errorf("decode actual feature environment: %w", err)
+	}
+	if len(actualEnv) != len(discoveryFeatureEnvKeys) {
+		return nil, fmt.Errorf("incomplete actual feature environment")
+	}
+	for _, key := range discoveryFeatureEnvKeys {
+		if _, ok := actualEnv[key]; !ok {
+			return nil, fmt.Errorf("missing actual feature environment %s", key)
+		}
+	}
+	if actualEnv["GOOS"] != parts[0] || actualEnv["GOARCH"] != parts[1] || actualEnv["CGO_ENABLED"] != "0" {
+		return nil, fmt.Errorf("Go driver returned a different feature target")
+	}
+	for key, wanted := range overrides {
+		if actualEnv[key] != wanted {
+			return nil, fmt.Errorf("actual Go driver did not preserve required %s=%q (reported %q)", key, wanted, actualEnv[key])
+		}
+	}
+	minor, err := goMinor(actualEnv["GOVERSION"])
+	if err != nil || minor < 20 || minor > 27 {
+		return nil, fmt.Errorf("feature registration is not audited for Go version %q", actualEnv["GOVERSION"])
+	}
+	if err := validateDiscoveryCPUEnvironment(parts[1], actualEnv[cpuKey], minor); err != nil {
+		return nil, err
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, goBinary, env, actualEnv, run)
+	if err != nil {
+		return nil, err
+	}
+	tags, sourceHashes, err := discoveryBuiltinFeatureCandidates(actualEnv["GOROOT"], actualEnv["GOVERSION"])
+	if err != nil {
+		return nil, err
+	}
+	markerFiles := discoveryFeatureMarkerFiles(tags)
+	for name, data := range markerFiles {
+		file, err := os.OpenFile(filepath.Join(resolvedDir, name), os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+		if err != nil {
+			return nil, fmt.Errorf("create owned feature marker: %w", err)
+		}
+		_, writeErr := file.Write(data)
+		closeErr := file.Close()
+		if writeErr != nil || closeErr != nil {
+			return nil, fmt.Errorf("write owned feature marker: %v (close: %v)", writeErr, closeErr)
+		}
+	}
+	output, listStderr, err := run(ctx, resolvedDir, env, goBinary, "list", "-find", "-json", "-mod=readonly", ".")
+	if err != nil {
+		return nil, fmt.Errorf("feature marker selection: %w", err)
+	}
+	selection, err := decodeDiscoveryFeatureMarkers(output, resolvedDir, tags)
+	if err != nil {
+		return nil, err
+	}
+	output, recheckStderr, err := run(ctx, resolvedDir, env, goBinary, args...)
+	if err != nil {
+		return nil, fmt.Errorf("recheck actual feature environment: %w", err)
+	}
+	var afterEnv map[string]string
+	if err := json.Unmarshal(output, &afterEnv); err != nil || len(afterEnv) != len(actualEnv) {
+		return nil, fmt.Errorf("actual feature environment changed during marker selection")
+	}
+	for key, value := range actualEnv {
+		if after, exists := afterEnv[key]; !exists || after != value {
+			return nil, fmt.Errorf("actual feature environment changed during marker selection: %s", key)
+		}
+	}
+	// The observer binds the bytes consumed by both driver commands. Caller
+	// owns markerDir's lifetime; never remove cache-owned or user files here.
+	afterDriver, err := discoveryFeatureFileSHA256(goBinary)
+	if err != nil || afterDriver != driverHash {
+		return nil, fmt.Errorf("feature driver changed during capture")
+	}
+	afterTools, err := captureDiscoveryFeatureSubtools(ctx, goBinary, env, afterEnv, run)
+	if err != nil {
+		return nil, fmt.Errorf("recheck actual Go subtools: %w", err)
+	}
+	if !equalDiscoveryFeatureToolStates(tools, afterTools) {
+		return nil, fmt.Errorf("actual Go subtool bytes/routing/cache changed during capture")
+	}
+	for name, before := range sourceHashes {
+		after, err := discoveryFeatureFileSHA256(filepath.Join(actualEnv["GOROOT"], filepath.FromSlash(name)))
+		if err != nil || after != before {
+			return nil, fmt.Errorf("feature tool source changed during capture: %s", name)
+		}
+	}
+	afterEntries, err := os.ReadDir(resolvedDir)
+	if err != nil || len(afterEntries) != len(markerFiles) {
+		return nil, fmt.Errorf("feature marker files changed during capture")
+	}
+	for name, before := range markerFiles {
+		after, err := os.ReadFile(filepath.Join(resolvedDir, name))
+		if err != nil || !bytes.Equal(before, after) {
+			return nil, fmt.Errorf("feature marker bytes changed during capture: %s", name)
+		}
+	}
+	var selected []string
+	for _, tag := range tags {
+		if selection[tag] {
+			selected = append(selected, tag)
+		}
+	}
+	selectionJSON, err := json.Marshal(selection)
+	if err != nil {
+		return nil, err
+	}
+	// Do not leak machine-private source roots into portable profile evidence.
+	delete(actualEnv, "GOROOT")
+	delete(actualEnv, "GOTOOLDIR")
+	delete(actualEnv, "GOCACHE")
+	return &discoveryTargetFeatures{
+		Protocol: "go_driver_builtin_features_v2", Target: target, Environment: actualEnv,
+		GoVersion: actualEnv["GOVERSION"], DriverSHA256: driverHash, ToolSourceSHA256: sourceHashes,
+		ToolDirectory: tools.directory, ToolBinarySHA256: tools.digests,
+		ToolBinaryOrigins: tools.origins, ToolRoutingSHA256: tools.routing,
+		ToolDispatcherSHA256: tools.dispatcher,
+		ToolTags:             selected, MarkerSelection: selection, MarkerSourceSHA256: discoveryFeatureMarkerSHA256(markerFiles),
+		DriverSelectionSHA256: discoveryFeatureBytesSHA256(selectionJSON), EnvStderrSHA256: discoveryFeatureBytesSHA256(envStderr),
+		EnvRecheckStderrSHA256: discoveryFeatureBytesSHA256(recheckStderr),
+		ListStderrSHA256:       discoveryFeatureBytesSHA256(listStderr),
+	}, nil
+}
+
+func validateDiscoveryCPUEnvironment(arch, value string, minor int) error {
+	valid := false
+	switch arch {
+	case "386":
+		valid = value == "sse2" || value == "softfloat"
+	case "amd64":
+		valid = value == "v1" || value == "v2" || value == "v3" || value == "v4"
+	case "arm":
+		for _, version := range []string{"5", "6", "7"} {
+			valid = valid || value == version || value == version+",softfloat" || value == version+",hardfloat"
+		}
+	case "arm64":
+		if minor < 23 {
+			valid = value == ""
+			break
+		}
+		level := strings.Split(value, ",")[0]
+		for _, candidate := range discoveryCPUFeatureCandidates() {
+			valid = valid || candidate == "arm64."+level
+		}
+		for _, extension := range strings.Split(value, ",")[1:] {
+			if extension != "lse" && extension != "crypto" {
+				valid = false
+			}
+		}
+	case "wasm":
+		valid = true
+		for _, feature := range strings.Split(value, ",") {
+			if feature != "" && feature != "satconv" && feature != "signext" {
+				valid = false
+			}
+		}
+	}
+	if !valid {
+		return fmt.Errorf("unrecognized actual CPU feature environment for %s: %q", arch, value)
+	}
+	return nil
+}
+
+func discoveryCPUFeatureCandidates() []string {
+	tags := []string{"386.sse2", "386.softfloat", "wasm.satconv", "wasm.signext"}
+	for level := 1; level <= 4; level++ {
+		tags = append(tags, fmt.Sprintf("amd64.v%d", level))
+	}
+	for level := 5; level <= 7; level++ {
+		tags = append(tags, fmt.Sprintf("arm.%d", level))
+	}
+	for minor := 0; minor <= 9; minor++ {
+		tags = append(tags, fmt.Sprintf("arm64.v8.%d", minor))
+	}
+	for minor := 0; minor <= 5; minor++ {
+		tags = append(tags, fmt.Sprintf("arm64.v9.%d", minor))
+	}
+	return tags
+}
+
+func discoveryBuiltinFeatureCandidates(root string, versions ...string) ([]string, map[string]string, error) {
+	if !filepath.IsAbs(root) {
+		return nil, nil, fmt.Errorf("actual Go driver returned non-absolute GOROOT")
+	}
+	const cfg = "src/internal/buildcfg/cfg.go"
+	const flags = "src/internal/goexperiment/flags.go"
+	versionData, err := os.ReadFile(filepath.Join(root, "VERSION"))
+	if err != nil || len(versions) != 1 || strings.TrimSpace(strings.Split(string(versionData), "\n")[0]) != versions[0] {
+		return nil, nil, fmt.Errorf("actual Go source VERSION does not match driver GOVERSION")
+	}
+	minor, err := goMinor(versions[0])
+	if err != nil || minor < 20 || minor > 27 {
+		return nil, nil, fmt.Errorf("unsupported actual feature source version")
+	}
+	cfgData, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(cfg)))
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := validateDiscoveryFeatureRegistration(cfgData, minor); err != nil {
+		return nil, nil, err
+	}
+	flagsData, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(flags)))
+	if err != nil {
+		return nil, nil, err
+	}
+	experiments, err := discoveryExperimentFeatureCandidates(flagsData)
+	if err != nil {
+		return nil, nil, err
+	}
+	encoded, err := json.Marshal(experiments)
+	if err != nil || discoveryFeatureBytesSHA256(encoded) != discoveryVersionedExperimentFingerprints[minor] {
+		return nil, nil, fmt.Errorf("actual experiment Flags namespace differs from audited Go 1.%d source", minor)
+	}
+	tags := append(discoveryCPUFeatureCandidates(), experiments...)
+	sort.Strings(tags)
+	return tags, map[string]string{"VERSION": discoveryFeatureBytesSHA256(versionData), cfg: discoveryFeatureBytesSHA256(cfgData), flags: discoveryFeatureBytesSHA256(flagsData)}, nil
+}
+
+// Sorted actual Flags names from the same eight source versions audited below.
+// Binding their inventory to GOVERSION prevents a valid old Flags AST from
+// hiding experiments registered in the current driver.
+var discoveryVersionedExperimentFingerprints = map[int]string{
+	20: "48b85ced0e6d664288c06553e34762cd631e2b0399bdad5688d7798c6785e08f",
+	21: "40a8da1e5be03c7cd358c2692b1acb73c597a5efe7c02cf193be22c32c2d70c7",
+	22: "878f99519db76a94823059333c94e0610cfeef96ea911547b68d3cf3f769d6b7",
+	23: "9726432e4577241c2cd37c474d29245742f932fd88f62a706e89f099fe05c880",
+	24: "7f6653c3871242ec1e4f7dc3be2e00c66a64d224176b45acfe8dc8fdad5ada9c",
+	25: "438bf2033e42b67f81f59d72126b0c341d110b9c3ffdea46c47f35442f2121b1",
+	26: "91203a6562b47777218dbb24bba84f16083d8abbf9d169a8770207d6fdb8c325",
+	27: "aee888ef48c2fb3276d64ef9c9229667bd4a7187e2e0fd886444d2d9a7daab7d",
+}
+
+// These are normalized AST-token fingerprints of the complete registration
+// functions actually audited in Go 1.20.14, 1.21.13, 1.22.12, 1.23.12,
+// 1.24.13, 1.25.14, 1.26.8 and 1.27.1 sources. This is a finite source grammar
+// guard, not a coverage baseline. Unknown registration code must be reviewed;
+// it cannot silently invent an unobserved builtin or an arbitrary custom tag.
+var discoveryFeatureRegistrationFingerprints = map[string][]string{
+	"toolTags":       {"b4b6381704ea6e60d0d2522595df66db182ff1b58c29d2f753bea782496323a3"},
+	"experimentTags": {"f391da8e69ecb7f0383a9e342a8639489dcb7fd94c6596e7a9e483ced36476d2"},
+	"gogoarchTags": {
+		"b2dd21d5ca443f36db4fa966ed8fc3467216f88db85edb44b243a8c9ce332755", // Go 1.20–1.21
+		"ed7c2a3ec46db74c8888369284c192d2effd85b32f3c99082ceeb983a806a14c", // Go 1.22
+		"43924858e77d06c222e4dab4f21f24c8bd32207287edb370f258254a8cbf9b2f", // Go 1.23–1.24
+		"f9f731718824fba2d59ac1cb1de5743562acc6d3875f7d0677dc0dbd9806429c", // Go 1.25
+		"e51726aa195348f1455632487fd66752581ff49e055cfb8cdefe34b1908cc036", // Go 1.26–1.27
+	},
+}
+
+func validateDiscoveryFeatureRegistration(data []byte, minors ...int) error {
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "cfg.go", data, 0)
+	if err != nil || f.Name.Name != "buildcfg" {
+		return fmt.Errorf("invalid actual feature registration source: %v", err)
+	}
+	seen := make(map[string]bool)
+	for _, decl := range f.Decls {
+		fn, ok := decl.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		allowed, registered := discoveryFeatureRegistrationFingerprints[fn.Name.Name]
+		if !registered {
+			continue
+		}
+		if len(minors) != 0 && fn.Name.Name == "gogoarchTags" {
+			index, known := map[int]int{20: 0, 21: 0, 22: 1, 23: 2, 24: 2, 25: 3, 26: 4, 27: 4}[minors[0]]
+			if len(minors) != 1 || !known {
+				return fmt.Errorf("unrecognized actual feature registration Go version")
+			}
+			allowed = allowed[index : index+1]
+		}
+		if seen[fn.Name.Name] || fn.Recv != nil || fn.Body == nil {
+			return fmt.Errorf("invalid feature registration function %s", fn.Name.Name)
+		}
+		seen[fn.Name.Name] = true
+		var formatted bytes.Buffer
+		if err := format.Node(&formatted, fset, fn); err != nil {
+			return err
+		}
+		var scan scanner.Scanner
+		scan.Init(token.NewFileSet().AddFile("registration", -1, formatted.Len()), formatted.Bytes(), nil, 0)
+		var canonical bytes.Buffer
+		for {
+			_, tok, literal := scan.Scan()
+			if tok == token.EOF {
+				break
+			}
+			fmt.Fprintf(&canonical, "%s\x00%s\x00", tok, literal)
+		}
+		digest := discoveryFeatureBytesSHA256(canonical.Bytes())
+		accepted := false
+		for _, known := range allowed {
+			accepted = accepted || digest == known
+		}
+		if !accepted {
+			return fmt.Errorf("unrecognized actual feature registration function %s (%s)", fn.Name.Name, digest)
+		}
+	}
+	if len(seen) != len(discoveryFeatureRegistrationFingerprints) {
+		return fmt.Errorf("incomplete actual feature registration functions")
+	}
+	return nil
+}
+
+func discoveryExperimentFeatureCandidates(data []byte) ([]string, error) {
+	f, err := parser.ParseFile(token.NewFileSet(), "flags.go", data, 0)
+	if err != nil || f.Name.Name != "goexperiment" {
+		return nil, fmt.Errorf("invalid actual experiment flags source: %v", err)
+	}
+	var tags []string
+	seen := make(map[string]bool)
+	flagTypes := 0
+	for _, decl := range f.Decls {
+		gen, ok := decl.(*ast.GenDecl)
+		if !ok || gen.Tok != token.TYPE {
+			continue
+		}
+		for _, spec := range gen.Specs {
+			typ := spec.(*ast.TypeSpec)
+			if typ.Name.Name != "Flags" {
+				continue
+			}
+			flagTypes++
+			fields, ok := typ.Type.(*ast.StructType)
+			if !ok || typ.Assign.IsValid() {
+				return nil, fmt.Errorf("unrecognized actual experiment Flags type")
+			}
+			for _, field := range fields.Fields.List {
+				kind, ok := field.Type.(*ast.Ident)
+				if !ok || kind.Name != "bool" || len(field.Names) != 1 || field.Tag != nil {
+					return nil, fmt.Errorf("unrecognized actual experiment Flags field")
+				}
+				tag := "goexperiment." + strings.ToLower(field.Names[0].Name)
+				if seen[tag] {
+					return nil, fmt.Errorf("duplicate actual experiment flag %s", tag)
+				}
+				seen[tag] = true
+				tags = append(tags, tag)
+			}
+		}
+	}
+	if flagTypes != 1 || len(tags) == 0 {
+		return nil, fmt.Errorf("incomplete actual experiment Flags type")
+	}
+	sort.Strings(tags)
+	return tags, nil
+}
+
+func discoveryFeatureMarkerFiles(tags []string) map[string][]byte {
+	files := map[string][]byte{
+		"go.mod":  []byte("module " + discoveryFeatureMarkerModule + "\n\ngo 1.20\n"),
+		"base.go": []byte("package markers\n"),
+	}
+	for index, tag := range tags {
+		files[fmt.Sprintf("marker%03d.go", index)] = []byte("//go:build " + tag + "\n\npackage markers\n")
+	}
+	return files
+}
+
+func decodeDiscoveryFeatureMarkers(data []byte, dir string, tags []string) (map[string]bool, error) {
+	var pkg struct {
+		Dir            string
+		ImportPath     string
+		GoFiles        []string
+		IgnoredGoFiles []string
+		SFiles         []string
+		Error          *struct{ Err string }
+	}
+	if err := json.Unmarshal(data, &pkg); err != nil {
+		return nil, fmt.Errorf("decode actual feature marker selection: %w", err)
+	}
+	actualDir, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil || actualDir != dir || pkg.ImportPath != discoveryFeatureMarkerModule || pkg.Error != nil || len(pkg.SFiles) != 0 {
+		return nil, fmt.Errorf("Go driver returned a different or invalid marker package")
+	}
+	byFile := map[string]string{"base.go": ""}
+	for index, tag := range tags {
+		byFile[fmt.Sprintf("marker%03d.go", index)] = tag
+	}
+	seen := make(map[string]bool)
+	selection := make(map[string]bool, len(tags))
+	for _, group := range []struct {
+		files []string
+		match bool
+	}{{pkg.GoFiles, true}, {pkg.IgnoredGoFiles, false}} {
+		for _, file := range group.files {
+			tag, exists := byFile[file]
+			if !exists || seen[file] || (file == "base.go" && !group.match) {
+				return nil, fmt.Errorf("invalid actual feature marker file %s", file)
+			}
+			seen[file] = true
+			if tag != "" {
+				selection[tag] = group.match
+			}
+		}
+	}
+	if len(seen) != len(byFile) {
+		return nil, fmt.Errorf("actual feature selection omitted marker files")
+	}
+	return selection, nil
+}
+
+func discoveryFeatureTagNamespace(tag string) bool {
+	if tag == "boringcrypto" || tag == "race" || tag == "msan" || tag == "asan" || strings.HasPrefix(tag, "goexperiment.") || strings.HasPrefix(tag, "go1.") {
+		return true
+	}
+	for _, arch := range []string{
+		"386", "amd64", "amd64p32", "arm", "armbe", "arm64", "arm64be", "loong64", "mips", "mipsle", "mips64", "mips64le",
+		"mips64p32", "mips64p32le", "ppc", "ppc64", "ppc64le", "riscv", "riscv64", "s390", "s390x", "sparc", "sparc64", "wasm",
+	} {
+		if strings.HasPrefix(tag, arch+".") {
+			return true
+		}
+	}
+	return false
+}
+
+func discoveryFeatureBytesSHA256(data []byte) string {
+	return fmt.Sprintf("%x", sha256.Sum256(data))
+}
+
+func discoveryFeatureProfileID(observed *discoveryTargetFeatures) string {
+	// encoding/json orders map keys; observers also require sorted ToolTags.
+	// Bind every portable observation byte, including command/namespace proof,
+	// rather than permitting the same ID to carry a different evidence body.
+	data, _ := json.Marshal(observed)
+	return discoveryFeatureBytesSHA256(data)
+}
+
+func containsTargetFeature(tags []string, wanted string) bool {
+	for _, tag := range tags {
+		if tag == wanted {
+			return true
+		}
+	}
+	return false
+}
+
+func discoveryFeatureMarkerSHA256(files map[string][]byte) string {
+	names := make([]string, 0, len(files))
+	for name := range files {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	h := sha256.New()
+	for _, name := range names {
+		fmt.Fprintf(h, "%s\x00%d\x00", name, len(files[name]))
+		h.Write(files[name])
+	}
+	return fmt.Sprintf("%x", h.Sum(nil))
+}
diff --git a/gotoolprofile/file_sha.go b/gotoolprofile/file_sha.go
new file mode 100644
index 000000000..8f68d7642
--- /dev/null
+++ b/gotoolprofile/file_sha.go
@@ -0,0 +1,47 @@
+package gotoolprofile
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+	"sync"
+)
+
+const discoveryFeatureHashBufferSize = 256 << 10
+
+type discoveryFeatureHashBuffer = [discoveryFeatureHashBufferSize]byte
+
+type discoveryFeatureHashBuffers interface {
+	Get() any
+	Put(any)
+}
+
+var discoveryFeatureFileHashBuffers = sync.Pool{
+	New: func() any { return new(discoveryFeatureHashBuffer) },
+}
+
+func discoveryFeatureFileSHA256(name string) (string, error) {
+	f, err := os.Open(name)
+	if err != nil {
+		return "", err
+	}
+	return discoveryFeatureReadCloserSHA256(f, &discoveryFeatureFileHashBuffers)
+}
+
+func discoveryFeatureReadCloserSHA256(input io.ReadCloser, buffers discoveryFeatureHashBuffers) (string, error) {
+	buffer := buffers.Get().(*discoveryFeatureHashBuffer)
+	defer buffers.Put(buffer)
+	h := sha256.New()
+	// Hide WriterTo: os.File's fallback otherwise bypasses CopyBuffer and
+	// allocates its own small buffer. Every call still reads the complete file.
+	_, readErr := io.CopyBuffer(h, struct{ io.Reader }{input}, buffer[:])
+	closeErr := input.Close()
+	if readErr != nil {
+		return "", readErr
+	}
+	if closeErr != nil {
+		return "", closeErr
+	}
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
+}
diff --git a/gotoolprofile/file_sha_test.go b/gotoolprofile/file_sha_test.go
new file mode 100644
index 000000000..059715bb1
--- /dev/null
+++ b/gotoolprofile/file_sha_test.go
@@ -0,0 +1,333 @@
+package gotoolprofile
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"testing"
+)
+
+type fileSHAReader struct {
+	data                    []byte
+	position, calls, widest int
+	step                    int
+	failAfter               int
+	dataError, finalEOF     bool
+	readError, closeError   error
+	closed                  int
+}
+
+func (reader *fileSHAReader) Read(output []byte) (int, error) {
+	reader.calls++
+	if len(output) > reader.widest {
+		reader.widest = len(output)
+	}
+	if reader.failAfter > 0 && reader.position == reader.failAfter {
+		return 0, reader.readError
+	}
+	if reader.position == len(reader.data) {
+		if reader.readError != nil {
+			return 0, reader.readError
+		}
+		return 0, io.EOF
+	}
+	if reader.step > 0 && len(output) > reader.step {
+		output = output[:reader.step]
+	}
+	if reader.failAfter > 0 && len(output) > reader.failAfter-reader.position {
+		output = output[:reader.failAfter-reader.position]
+	}
+	n := copy(output, reader.data[reader.position:])
+	reader.position += n
+	if reader.dataError && reader.position == reader.failAfter {
+		return n, reader.readError
+	}
+	if reader.finalEOF && reader.position == len(reader.data) {
+		return n, io.EOF
+	}
+	return n, nil
+}
+
+func (reader *fileSHAReader) Close() error {
+	reader.closed++
+	return reader.closeError
+}
+
+type fileSHASpyBuffers struct {
+	mu         sync.Mutex
+	gets, puts int
+	active     map[*discoveryFeatureHashBuffer]bool
+	onPut      func()
+}
+
+func (buffers *fileSHASpyBuffers) Get() any {
+	buffer := new(discoveryFeatureHashBuffer)
+	buffers.mu.Lock()
+	defer buffers.mu.Unlock()
+	if buffers.active == nil {
+		buffers.active = make(map[*discoveryFeatureHashBuffer]bool)
+	}
+	buffers.gets++
+	buffers.active[buffer] = true
+	return buffer
+}
+
+func (buffers *fileSHASpyBuffers) Put(value any) {
+	buffer, valid := value.(*discoveryFeatureHashBuffer)
+	if !valid {
+		panic("unexpected hash buffer type")
+	}
+	buffers.mu.Lock()
+	defer buffers.mu.Unlock()
+	if !buffers.active[buffer] {
+		panic("unborrowed or double-returned hash buffer")
+	}
+	delete(buffers.active, buffer)
+	buffers.puts++
+	if buffers.onPut != nil {
+		buffers.onPut()
+	}
+}
+
+func fileSHAExpected(data []byte) string {
+	digest := sha256.Sum256(data)
+	return hex.EncodeToString(digest[:])
+}
+
+func fileSHAData(size int) []byte {
+	data := make([]byte, size)
+	for i := range data {
+		data[i] = byte(i*71 + i/251)
+	}
+	return data
+}
+
+// A counting wrapper around a real regular file measures each actual Read
+// request. Its WriterTo reproduces the stock Go genericWriteTo fallback, so
+// the baseline also exercises the path used by io.Copy on an *os.File.
+type fileSHACountingFile struct {
+	*os.File
+	calls, widest int
+}
+
+func (file *fileSHACountingFile) Read(output []byte) (int, error) {
+	file.calls++
+	if len(output) > file.widest {
+		file.widest = len(output)
+	}
+	return file.File.Read(output)
+}
+
+func (file *fileSHACountingFile) WriteTo(output io.Writer) (int64, error) {
+	return io.Copy(output, struct{ io.Reader }{file})
+}
+
+func TestFileSHA256BoundedReadRequestsOnActualFile(t *testing.T) {
+	data := fileSHAData(8 << 20)
+	name := filepath.Join(t.TempDir(), "input")
+	if err := os.WriteFile(name, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	opened, err := os.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file := &fileSHACountingFile{File: opened}
+	digest, err := discoveryFeatureReadCloserSHA256(file, &fileSHASpyBuffers{})
+	if err != nil || digest != fileSHAExpected(data) {
+		t.Fatalf("complete actual file digest: %s/%v", digest, err)
+	}
+	maximumReads := (len(data)+discoveryFeatureHashBufferSize-1)/discoveryFeatureHashBufferSize + 1
+	t.Logf("actual regular file bytes=%d Read calls=%d widest request=%d maximum calls=%d", len(data), file.calls, file.widest, maximumReads)
+	if file.calls > maximumReads || file.widest != discoveryFeatureHashBufferSize {
+		t.Fatalf("full regular file used small or unbounded read requests: calls=%d widest=%d", file.calls, file.widest)
+	}
+}
+
+func TestFileSHA256ShortReadsAndErrorsReturnBuffer(t *testing.T) {
+	readError := errors.New("original read failure")
+	closeError := errors.New("original close failure")
+	for _, row := range []struct {
+		name                  string
+		size, step            int
+		failAfter             int
+		dataError, finalEOF   bool
+		readError, closeError error
+		wantError             error
+	}{
+		{name: "empty"},
+		{name: "partial final block", size: 263},
+		{name: "data with EOF", size: 263, finalEOF: true},
+		{name: "short reads", size: 1027, step: 7},
+		{name: "empty read error", readError: readError, wantError: readError},
+		{name: "read error", size: 263, step: 7, readError: readError, wantError: readError},
+		{name: "early read error", size: 263, failAfter: 7, readError: readError, wantError: readError},
+		{name: "partial data with read error", size: 263, failAfter: 7, dataError: true, readError: readError, wantError: readError},
+		{name: "close error", size: 263, closeError: closeError, wantError: closeError},
+		{name: "read error precedes close error", size: 263, readError: readError, closeError: closeError, wantError: readError},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			reader := &fileSHAReader{
+				data: fileSHAData(row.size), step: row.step, failAfter: row.failAfter,
+				dataError: row.dataError, finalEOF: row.finalEOF,
+				readError: row.readError, closeError: row.closeError,
+			}
+			buffers := &fileSHASpyBuffers{onPut: func() {
+				if reader.closed != 1 {
+					t.Error("buffer returned before the owned reader closed")
+				}
+			}}
+			digest, err := discoveryFeatureReadCloserSHA256(reader, buffers)
+			wantConsumed := row.size
+			if row.failAfter > 0 {
+				wantConsumed = row.failAfter
+			}
+			if !errors.Is(err, row.wantError) || reader.closed != 1 || reader.position != wantConsumed {
+				t.Fatalf("full read/close/error precedence changed: position=%d closes=%d digest=%s err=%v", reader.position, reader.closed, digest, err)
+			}
+			if row.wantError != nil && digest != "" || row.wantError == nil && digest != fileSHAExpected(reader.data) {
+				t.Fatalf("success/failure digest changed: %s/%v", digest, err)
+			}
+			if buffers.gets != 1 || buffers.puts != 1 || len(buffers.active) != 0 {
+				t.Fatalf("bounded buffer not returned exactly once: gets=%d puts=%d active=%d", buffers.gets, buffers.puts, len(buffers.active))
+			}
+		})
+	}
+}
+
+func TestFileSHA256ActualFilesAlwaysRecaptureBytes(t *testing.T) {
+	for _, size := range []int{0, 1, 32767, 32768, 32769, discoveryFeatureHashBufferSize - 1, discoveryFeatureHashBufferSize, discoveryFeatureHashBufferSize + 1, 3*discoveryFeatureHashBufferSize + 17} {
+		t.Run(fmt.Sprint(size), func(t *testing.T) {
+			name := filepath.Join(t.TempDir(), "original")
+			data := fileSHAData(size)
+			if err := os.WriteFile(name, data, 0600); err != nil {
+				t.Fatal(err)
+			}
+			info, err := os.Stat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			before, err := FileSHA256(name)
+			if err != nil || before != fileSHAExpected(data) {
+				t.Fatalf("reference digest differs: %s/%v", before, err)
+			}
+			if size != 0 {
+				data[size-1] ^= 0x5a
+			}
+			if err := os.WriteFile(name, data, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chtimes(name, info.ModTime(), info.ModTime()); err != nil {
+				t.Fatal(err)
+			}
+			after, err := FileSHA256(name)
+			if err != nil || after != fileSHAExpected(data) || size != 0 && after == before {
+				t.Fatalf("same-path/size/mtime changed bytes were not read: %s/%v", after, err)
+			}
+		})
+	}
+	if digest, err := FileSHA256(filepath.Join(t.TempDir(), "missing")); err == nil || digest != "" {
+		t.Fatalf("missing file supplied a digest: %s/%v", digest, err)
+	}
+	if digest, err := FileSHA256(t.TempDir()); err == nil || digest != "" {
+		t.Fatalf("directory supplied a digest: %s/%v", digest, err)
+	}
+}
+
+func TestFileSHA256ConcurrentBufferReturn(t *testing.T) {
+	const count = 32
+	var workers sync.WaitGroup
+	buffers := new(fileSHASpyBuffers)
+	failures := make(chan error, 3*count)
+	for index := 0; index < count; index++ {
+		workers.Add(1)
+		go func(index int) {
+			defer workers.Done()
+			data := fileSHAData(discoveryFeatureHashBufferSize + index)
+			reader := &fileSHAReader{data: data, step: 1009}
+			digest, err := discoveryFeatureReadCloserSHA256(reader, buffers)
+			if err != nil || digest != fileSHAExpected(data) || reader.closed != 1 {
+				failures <- fmt.Errorf("worker %d: digest=%s closes=%d error=%v", index, digest, reader.closed, err)
+			}
+			// Also exercise the production sync.Pool concurrently, including
+			// immediate reuse after successful and error returns.
+			for _, readError := range []error{errors.New("read failure"), nil} {
+				reader := &fileSHAReader{data: data, readError: readError}
+				digest, err := discoveryFeatureReadCloserSHA256(reader, &discoveryFeatureFileHashBuffers)
+				if !errors.Is(err, readError) || reader.closed != 1 || readError == nil && digest != fileSHAExpected(data) {
+					failures <- fmt.Errorf("production pool worker %d: digest=%s closes=%d error=%v", index, digest, reader.closed, err)
+					return
+				}
+			}
+		}(index)
+	}
+	workers.Wait()
+	close(failures)
+	for failure := range failures {
+		t.Error(failure)
+	}
+	if buffers.gets != count || buffers.puts != count || len(buffers.active) != 0 {
+		t.Fatalf("concurrent buffer ownership leaked: gets=%d puts=%d active=%d", buffers.gets, buffers.puts, len(buffers.active))
+	}
+}
+
+func fileSHABaseline(name string) (string, error) {
+	file, err := os.Open(name)
+	if err != nil {
+		return "", err
+	}
+	hash := sha256.New()
+	_, readError := io.Copy(hash, file)
+	closeError := file.Close()
+	if readError != nil {
+		return "", readError
+	}
+	if closeError != nil {
+		return "", closeError
+	}
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+func BenchmarkFileSHA256CompletePhysicalRead(b *testing.B) {
+	fixture := filepath.Join(b.TempDir(), "fixture")
+	if err := os.WriteFile(fixture, fileSHAData(8<<20), 0600); err != nil {
+		b.Fatal(err)
+	}
+	for _, row := range []struct{ name, file string }{
+		{"fixture_8MiB", fixture},
+		{"selected_SDK_driver", filepath.Join(runtime.GOROOT(), "bin", "go")},
+	} {
+		info, err := os.Stat(row.file)
+		if err != nil {
+			b.Fatal(err)
+		}
+		reference, err := fileSHABaseline(row.file)
+		if err != nil {
+			b.Fatal(err)
+		}
+		for _, implementation := range []struct {
+			name string
+			hash func(string) (string, error)
+		}{
+			{"baseline_io_Copy", fileSHABaseline},
+			{"production", FileSHA256},
+		} {
+			b.Run(row.name+"/"+implementation.name, func(b *testing.B) {
+				b.SetBytes(info.Size())
+				b.ReportAllocs()
+				for i := 0; i < b.N; i++ {
+					digest, err := implementation.hash(row.file)
+					if err != nil || digest != reference {
+						b.Fatalf("full reference digest changed: %s/%v", digest, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/gotoolprofile/generated_header.go b/gotoolprofile/generated_header.go
new file mode 100644
index 000000000..6ba3d79ff
--- /dev/null
+++ b/gotoolprofile/generated_header.go
@@ -0,0 +1,244 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"path"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmheader"
+)
+
+const GeneratedHeaderProtocol = "actual_go_asmhdr_full_definitions_v1"
+const MetadataProtocol = "actual_go_cpu_profile_metadata_v2"
+
+// A compiler package can legitimately emit more than 4096 definitions. Bound
+// its full textual input and canonical output by bytes, not declaration count.
+const generatedHeaderByteLimit = goasmheader.ByteLimit
+
+// MetadataProof is deliberately not a SelectionProof. It proves generated
+// layout inputs, not successful assembly translation or LLVM object emission.
+type MetadataProof struct {
+	Protocol     string                   `json:"protocol"`
+	ProfileID    string                   `json:"profile_id"`
+	CustomTags   []string                 `json:"custom_tags,omitempty"`
+	Packages     []PackageProof           `json:"packages"`
+	Headers      []GeneratedHeaderProof   `json:"headers"`
+	Dependencies *OrdinaryDependencyProof `json:"ordinary_dependencies"`
+}
+
+type GeneratedHeaderProof struct {
+	Protocol          string            `json:"protocol"`
+	PackagePath       string            `json:"package_path"`
+	ProfileID         string            `json:"profile_id"`
+	Target            string            `json:"target"`
+	GoVersion         string            `json:"go_version"`
+	LanguageVersion   string            `json:"language_version"`
+	CompileToolSHA256 string            `json:"compile_tool_sha256"`
+	HeaderSHA256      string            `json:"header_sha256"`
+	ObjectSHA256      string            `json:"object_sha256"`
+	DefinitionsSHA256 string            `json:"definitions_sha256"`
+	Definitions       map[string]string `json:"definitions"`
+	CompiledGoSHA256  map[string]string `json:"compiled_go_sha256"`
+	ImportMap         map[string]string `json:"import_map"`
+	Imports           []ImportExport    `json:"imports,omitempty"`
+}
+
+// ImportExport records the actual same-profile dependency export used by the
+// compiler. ImportPath is the source spelling; PackagePath is its ImportMap
+// destination. Physical archive paths are private, never portable identities.
+type ImportExport struct {
+	ImportPath    string            `json:"import_path"`
+	PackagePath   string            `json:"package_path"`
+	ModulePath    string            `json:"module_path,omitempty"`
+	Version       string            `json:"version,omitempty"`
+	SourceModule  string            `json:"source_module,omitempty"`
+	SourceVersion string            `json:"source_version,omitempty"`
+	SourceRole    string            `json:"source_role"`
+	ExportSHA256  string            `json:"export_sha256"`
+	GoSHA256      map[string]string `json:"compiled_go_sha256"`
+}
+
+// HeaderDefinitions accepts only the complete object-like definitions emitted
+// by cmd/compile and the selected-types emitter. Unknown controls, duplicate
+// names and continuations fail instead of inventing values or presence.
+func HeaderDefinitions(header []byte) (map[string]string, error) {
+	return goasmheader.Definitions(header)
+}
+
+func generatedHeaderDefinitionSize(name, value string) (int, error) {
+	return goasmheader.DefinitionSize(name, value)
+}
+
+func generatedHeaderDefinitionsSize(definitions map[string]string) (int, error) {
+	return goasmheader.DefinitionsSize(definitions)
+}
+
+func HeaderDefinitionSHA256(definitions map[string]string) string {
+	return goasmheader.SHA256(definitions)
+}
+
+// ValidateMetadata is an offline replay of frozen source/tool provenance. The
+// producer and consumer must separately compare actual -asmhdr definitions
+// with all selected Go types; a recorded SHA is not a ZIP membership witness.
+func ValidateMetadata(input *ConsumerInput, proof *MetadataProof, tags []string) error {
+	if input == nil || input.Protocol != ConsumerProtocol || input.ID != ProfileID(input.Observed) {
+		return fmt.Errorf("missing canonical generated-header feature input")
+	}
+	if err := Validate(input.Observed); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != MetadataProtocol || proof.ProfileID != input.ID || !equalDiscoveryStrings(proof.CustomTags, tags) || len(proof.Packages) == 0 {
+		return fmt.Errorf("metadata query differs from its source/profile/tag scope")
+	}
+	selected, _, err := validatePackageSelection(input, proof.Packages, tags)
+	if err != nil {
+		return err
+	}
+	for _, file := range input.AsmFiles {
+		if !selected[file] {
+			return fmt.Errorf("metadata query did not load its source-required assembly package")
+		}
+	}
+	if len(proof.Headers) != len(proof.Packages) {
+		return fmt.Errorf("metadata query lacks complete per-package generated headers")
+	}
+	seen := make(map[string]bool)
+	for _, header := range proof.Headers {
+		var pkg *PackageProof
+		for index := range proof.Packages {
+			if proof.Packages[index].PackagePath == header.PackagePath {
+				pkg = &proof.Packages[index]
+			}
+		}
+		if pkg == nil || seen[header.PackagePath] {
+			return fmt.Errorf("duplicate or unselected generated-header package")
+		}
+		seen[header.PackagePath] = true
+		if err := ValidateGeneratedHeader(input, header, *pkg); err != nil {
+			return err
+		}
+	}
+	return ValidateOrdinaryDependencies(input, proof, tags)
+}
+
+func ValidateGeneratedHeader(input *ConsumerInput, proof GeneratedHeaderProof, pkg PackageProof) error {
+	if input == nil || input.Observed == nil {
+		return fmt.Errorf("missing generated-header source context")
+	}
+	return validateGeneratedHeaderContext(input, proof, pkg, generatedHeaderValidationContext{
+		protocol: GeneratedHeaderProtocol, id: input.ID, observed: input.Observed,
+		validateMacros: func() error { return ValidateOrdinaryAssemblerMacros(pkg.Macros, input.Observed, pkg.PackagePath) },
+	})
+}
+
+// Different source/profile protocols share layout and import validation, not
+// their identity. The public ordinary entry point always supplies its own
+// original protocol, observation and ordinary assembler registration.
+type generatedHeaderValidationContext struct {
+	protocol       string
+	id             string
+	observed       *Observation
+	validateMacros func() error
+}
+
+func validateGeneratedHeaderContext(input *ConsumerInput, proof GeneratedHeaderProof, pkg PackageProof, context generatedHeaderValidationContext) error {
+	if input == nil || context.observed == nil || context.validateMacros == nil || proof.Protocol != context.protocol ||
+		proof.PackagePath != pkg.PackagePath || proof.ProfileID != context.id ||
+		proof.Target != context.observed.Target || proof.GoVersion != context.observed.GoVersion ||
+		proof.CompileToolSHA256 != context.observed.ToolBinarySHA256["compile"] ||
+		!discoverySHA256Pattern.MatchString(proof.HeaderSHA256) || !discoverySHA256Pattern.MatchString(proof.ObjectSHA256) ||
+		proof.Definitions == nil {
+		return fmt.Errorf("generated header differs from its actual compiler/package/profile scope")
+	}
+	if _, err := generatedHeaderDefinitionsSize(proof.Definitions); err != nil {
+		return err
+	}
+	if proof.DefinitionsSHA256 != HeaderDefinitionSHA256(proof.Definitions) {
+		return fmt.Errorf("generated header differs from its complete definition digest")
+	}
+	if err := ValidatePackageModule(input, pkg); err != nil {
+		return err
+	}
+	if err := context.validateMacros(); err != nil {
+		return err
+	}
+	languageMinor, languageErr := goMinor(proof.LanguageVersion)
+	if proof.LanguageVersion == "go1" {
+		languageMinor, languageErr = 0, nil
+	}
+	toolMinor, toolErr := goMinor(context.observed.GoVersion)
+	if languageErr != nil || toolErr != nil || languageMinor > toolMinor || strings.Count(proof.LanguageVersion, ".") > 1 {
+		return fmt.Errorf("generated header lacks its actual supported module language version")
+	}
+	if len(pkg.CompiledGoFiles) == 0 || len(proof.CompiledGoSHA256) != len(pkg.CompiledGoFiles) {
+		return fmt.Errorf("generated header omits selected compiler Go inputs")
+	}
+	for _, file := range pkg.CompiledGoFiles {
+		if proof.CompiledGoSHA256[file] != pkg.SourceSHA256[file] || proof.CompiledGoSHA256[file] != input.Sources[file] {
+			return fmt.Errorf("generated header has different selected Go bytes")
+		}
+	}
+	if len(proof.Imports) > 4096 || !sort.SliceIsSorted(proof.Imports, func(i, j int) bool { return proof.Imports[i].ImportPath < proof.Imports[j].ImportPath }) {
+		return fmt.Errorf("generated header exceeds canonical import bounds")
+	}
+	if proof.ImportMap == nil || len(proof.ImportMap) > 4096 {
+		return fmt.Errorf("generated header lacks its complete same-load ImportMap")
+	}
+	usedImports := map[string]string{}
+	if proof.ImportMap["unsafe"] != "" {
+		if proof.ImportMap["unsafe"] != "unsafe" {
+			return fmt.Errorf("builtin unsafe import cannot use an invented export")
+		}
+		usedImports["unsafe"] = "unsafe"
+	}
+	for index, imported := range proof.Imports {
+		if imported.ImportPath == "" || imported.PackagePath == "" || imported.ImportPath == "unsafe" ||
+			strings.ContainsAny(imported.ImportPath+imported.PackagePath, "\r\n=\\") ||
+			index > 0 && imported.ImportPath == proof.Imports[index-1].ImportPath ||
+			!discoverySHA256Pattern.MatchString(imported.ExportSHA256) || len(imported.GoSHA256) == 0 {
+			return fmt.Errorf("generated header lacks a canonical actual dependency export")
+		}
+		if proof.ImportMap[imported.ImportPath] != imported.PackagePath {
+			return fmt.Errorf("generated-header export differs from the actual ImportMap")
+		}
+		usedImports[imported.ImportPath] = imported.PackagePath
+		if err := validateImportedSource(input, pkg, imported); err != nil {
+			return err
+		}
+	}
+	if len(usedImports) != len(proof.ImportMap) {
+		return fmt.Errorf("generated header omits actual dependency exports")
+	}
+	return nil
+}
+
+// Generated headers and supplemental test declarations authenticate the same
+// concrete compiler dependency exports and source/module roles.
+func validateImportedSource(input *ConsumerInput, pkg PackageProof, imported ImportExport) error {
+	packageDir := strings.TrimPrefix(imported.PackagePath, imported.ModulePath)
+	packageDir = strings.TrimPrefix(packageDir, "/")
+	if packageDir == "" {
+		packageDir = "."
+	}
+	if imported.SourceRole == "stdlib" {
+		if imported.ModulePath != "" || imported.Version != "" || imported.SourceModule != "" || imported.SourceVersion != "" || strings.Contains(strings.Split(imported.PackagePath, "/")[0], ".") {
+			return fmt.Errorf("stdlib dependency was relabeled as an external module")
+		}
+	} else {
+		if imported.ModulePath == "" || imported.SourceModule == "" ||
+			imported.PackagePath != imported.ModulePath && !strings.HasPrefix(imported.PackagePath, imported.ModulePath+"/") ||
+			(imported.SourceRole != "module" && imported.SourceRole != "main" && imported.SourceRole != "owned_local_replace" && imported.SourceRole != "version_replace") {
+			return fmt.Errorf("dependency export lacks its actual module/source role")
+		}
+	}
+	for file, digest := range imported.GoSHA256 {
+		if path.Clean(file) != file || file == "." || path.IsAbs(file) || strings.HasPrefix(file, "../") || strings.Contains(file, "\\") || path.Dir(file) != packageDir || !discoverySHA256Pattern.MatchString(digest) {
+			return fmt.Errorf("dependency export has an unsafe or missing source digest")
+		}
+		if imported.ModulePath == input.Module && (imported.Version != input.Version || imported.SourceModule != pkg.SourceModule || imported.SourceVersion != pkg.SourceVersion || imported.SourceRole != pkg.SourceRole || digest != input.Sources[file]) {
+			return fmt.Errorf("same-module dependency export differs from exact pre-load source inputs")
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/generated_header_agreement.go b/gotoolprofile/generated_header_agreement.go
new file mode 100644
index 000000000..d2932e9af
--- /dev/null
+++ b/gotoolprofile/generated_header_agreement.go
@@ -0,0 +1,65 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmheader"
+)
+
+// CanonicalGeneratedHeader is the effective assembly input. The original
+// compiler formatting/hash remains in GeneratedHeaderProof; every definition,
+// including unused names and presence, is retained in this deterministic text.
+func CanonicalGeneratedHeader(definitions map[string]string) ([]byte, error) {
+	return goasmheader.Canonical(definitions)
+}
+
+// ValidateGeneratedHeaderAgreement compares two independently produced actual
+// compiler queries. Self-consistent altered JSON is not agreement. Only the
+// physical compiler header/object bytes may differ after both queries passed
+// complete source/profile/role/import validation; their full definitions may not.
+func ValidateGeneratedHeaderAgreement(input *ConsumerInput, expected, actual *MetadataProof, tags []string) error {
+	if expected == nil || actual == nil {
+		return fmt.Errorf("generated assembly requires producer and independent consumer compiler metadata")
+	}
+	for _, proof := range []*MetadataProof{expected, actual} {
+		if err := ValidateMetadata(input, proof, tags); err != nil {
+			return err
+		}
+	}
+	if !reflect.DeepEqual(expected.Packages, actual.Packages) || !equalDiscoveryStrings(expected.CustomTags, actual.CustomTags) ||
+		!reflect.DeepEqual(expected.Dependencies, actual.Dependencies) {
+		return fmt.Errorf("generated-header compiler queries selected different package/source/tag roles")
+	}
+	byPackage := make(map[string]GeneratedHeaderProof, len(expected.Headers))
+	for _, header := range expected.Headers {
+		byPackage[header.PackagePath] = header
+	}
+	for _, header := range actual.Headers {
+		wanted, found := byPackage[header.PackagePath]
+		if !found {
+			return fmt.Errorf("generated-header consumer selected an unregistered package")
+		}
+		wanted.HeaderSHA256, wanted.ObjectSHA256 = "", ""
+		header.HeaderSHA256, header.ObjectSHA256 = "", ""
+		if !reflect.DeepEqual(wanted, header) {
+			return fmt.Errorf("independent generated-header definitions/imports differ from producer metadata")
+		}
+	}
+	return nil
+}
+
+func generatedCPPSourceSHA(proof *MetadataProof, packagePath, file string) string {
+	if proof == nil || file != packagePath+"/go_asm.h" {
+		return ""
+	}
+	for _, header := range proof.Headers {
+		if header.PackagePath == packagePath {
+			data, err := CanonicalGeneratedHeader(header.Definitions)
+			if err == nil {
+				return bytesSHA256(data)
+			}
+		}
+	}
+	return ""
+}
diff --git a/gotoolprofile/generated_header_bounds_test.go b/gotoolprofile/generated_header_bounds_test.go
new file mode 100644
index 000000000..5a45ac5a3
--- /dev/null
+++ b/gotoolprofile/generated_header_bounds_test.go
@@ -0,0 +1,183 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestGeneratedHeaderDefinitionsUseBytesNotDeclarationCount(t *testing.T) {
+	definitions := largeGeneratedDefinitions(5000)
+	var source strings.Builder
+	for index := 0; index < 5000; index++ {
+		fmt.Fprintf(&source, "#define const_Value%d %d\n", index, index)
+	}
+	actual, err := HeaderDefinitions([]byte(source.String()))
+	if err != nil || !reflect.DeepEqual(actual, definitions) {
+		t.Fatalf("complete bounded header was rejected or truncated: %v", err)
+	}
+	canonical, err := CanonicalGeneratedHeader(actual)
+	if err != nil {
+		t.Fatal(err)
+	}
+	parsed, err := HeaderDefinitions(canonical)
+	if err != nil || !reflect.DeepEqual(parsed, definitions) {
+		t.Fatalf("canonical header lost a late definition: %v", err)
+	}
+	encoded, err := json.Marshal(definitions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var replay map[string]string
+	if err := json.Unmarshal(encoded, &replay); err != nil {
+		t.Fatal(err)
+	}
+	if HeaderDefinitionSHA256(replay) != HeaderDefinitionSHA256(definitions) {
+		t.Fatal("complete definition digest did not survive JSON replay")
+	}
+	for _, changed := range []map[string]string{largeGeneratedDefinitions(4999), largeGeneratedDefinitions(5001)} {
+		if HeaderDefinitionSHA256(changed) == HeaderDefinitionSHA256(definitions) {
+			t.Fatal("late definition presence was ignored")
+		}
+	}
+	replay["const_Value4999"] = "changed"
+	if HeaderDefinitionSHA256(replay) == HeaderDefinitionSHA256(definitions) {
+		t.Fatal("late definition value was ignored")
+	}
+	for _, value := range []string{"4999", "different"} {
+		duplicate := source.String() + "#define const_Value4999 " + value + "\n"
+		if _, err := HeaderDefinitions([]byte(duplicate)); err == nil {
+			t.Fatal("a duplicate beyond the former count bound was accepted")
+		}
+	}
+}
+
+func largeGeneratedDefinitions(count int) map[string]string {
+	definitions := make(map[string]string, count)
+	for index := 0; index < count; index++ {
+		definitions[fmt.Sprintf("const_Value%d", index)] = fmt.Sprint(index)
+	}
+	return definitions
+}
+
+func TestGeneratedHeaderByteBoundsRejectBeforeCanonicalAllocation(t *testing.T) {
+	if _, err := HeaderDefinitions(make([]byte, 64<<20+1)); err == nil {
+		t.Fatal("oversized textual input was accepted")
+	}
+	// Individually bounded values can still exceed the shared full output
+	// budget. Share the test value instead of allocating a giant output.
+	value := strings.Repeat("1", 32<<20)
+	definitions := map[string]string{"First": value, "Second": value}
+	if _, err := generatedHeaderDefinitionsSize(definitions); err == nil {
+		t.Fatal("aggregate canonical byte budget was ignored")
+	}
+	if _, err := CanonicalGeneratedHeader(definitions); err == nil {
+		t.Fatal("oversized portable definitions became canonical source")
+	}
+	// The reader must apply the same budget before serializing an attacker-
+	// supplied portable map for its digest. This negative reaches that check
+	// before any successful module/tool provenance could be established.
+	observation := &Observation{Target: "linux/amd64", GoVersion: "go1.27.1"}
+	proof := GeneratedHeaderProof{
+		Protocol: GeneratedHeaderProtocol, PackagePath: "example.invalid/header",
+		Target: observation.Target, GoVersion: observation.GoVersion,
+		HeaderSHA256: strings.Repeat("a", 64), ObjectSHA256: strings.Repeat("b", 64),
+		Definitions: definitions,
+	}
+	err := validateGeneratedHeaderContext(&ConsumerInput{}, proof, PackageProof{PackagePath: proof.PackagePath},
+		generatedHeaderValidationContext{
+			protocol: GeneratedHeaderProtocol, observed: observation,
+			validateMacros: func() error { return nil },
+		})
+	if err == nil || !strings.Contains(err.Error(), "canonical byte bound") {
+		t.Fatalf("reader did not bound portable definitions before hashing: %v", err)
+	}
+	for name, value := range map[string]string{
+		"newlines": "1\n#define Injected 2", "carriage return": "1\r2", "NUL": "1\x002",
+		"empty": "", "leading space": " 1", "trailing space": "1 ", "continuation": "1\\",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := generatedHeaderDefinitionsSize(map[string]string{"Name": value}); err == nil {
+				t.Fatal("invalid definition survived canonical budget validation")
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderActualCompilerFullGrammarBeyond4096(t *testing.T) {
+	// cmd/compile/internal/gc.dumpasmhdr emits object-like constants and
+	// complete struct sizes/field offsets, not float/complex or blank names.
+	var source strings.Builder
+	source.WriteString(`package header
+const Text = "x y\n\t世界"
+const Truth = true
+const Rune = '世'
+const Signed = -7
+const Huge = 123456789012345678901234567890
+const Fraction = 1.25
+const Complex = 1 + 2i
+const _ = 1
+type Layout struct { First byte; _ [3]byte; Word uintptr; Last uint64 }
+type Alias = Layout
+type NonStruct int
+`)
+	for index := 0; index < 5000; index++ {
+		fmt.Fprintf(&source, "const Value%d = %d\n", index, index)
+	}
+	directory := t.TempDir()
+	goFile := filepath.Join(directory, "layout.go")
+	if err := os.WriteFile(goFile, []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			parts := strings.Split(target, "/")
+			header := filepath.Join(t.TempDir(), "go_asm.h")
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			env := replaceEnv(os.Environ(), map[string]string{"GOOS": parts[0], "GOARCH": parts[1], "CGO_ENABLED": "0"})
+			_, _, err := RunBounded(ctx, directory, env, "go", "tool", "compile",
+				"-p", "example.invalid/header", "-asmhdr", header, "-o", filepath.Join(t.TempDir(), "go.o"), goFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := os.ReadFile(header)
+			if err != nil {
+				t.Fatal(err)
+			}
+			actual, err := HeaderDefinitions(data)
+			if err != nil {
+				t.Fatalf("actual %s compiler header (%d bytes): %v", target, len(data), err)
+			}
+			wanted := largeGeneratedDefinitions(5000)
+			wanted["const_Text"] = `"x y\n\t世界"`
+			wanted["const_Truth"], wanted["const_Rune"] = "true", "19990"
+			wanted["const_Signed"], wanted["const_Huge"] = "-7", "123456789012345678901234567890"
+			size, word, last := "24", "8", "16"
+			if parts[1] == "386" || parts[1] == "arm" {
+				size, word, last = "16", "4", "8"
+			}
+			for _, name := range []string{"Layout", "Alias"} {
+				wanted[name+"__size"], wanted[name+"_First"] = size, "0"
+				wanted[name+"_Word"], wanted[name+"_Last"] = word, last
+			}
+			if !reflect.DeepEqual(actual, wanted) {
+				t.Fatalf("actual compiler definitions changed full values/presence: got %d, want %d", len(actual), len(wanted))
+			}
+			canonical, err := CanonicalGeneratedHeader(actual)
+			if err != nil {
+				t.Fatal(err)
+			}
+			replay, err := HeaderDefinitions(canonical)
+			if err != nil || !reflect.DeepEqual(replay, wanted) {
+				t.Fatalf("actual compiler grammar failed canonical replay: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/generated_header_builtin_import_test.go b/gotoolprofile/generated_header_builtin_import_test.go
new file mode 100644
index 000000000..100650902
--- /dev/null
+++ b/gotoolprofile/generated_header_builtin_import_test.go
@@ -0,0 +1,94 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGeneratedHeaderBuiltinUnsafeImportFamilyMatchesNativeObjects(t *testing.T) {
+	const original = `package header
+import "unsafe"
+type Inner struct { Byte byte; Word uintptr }
+type Values struct {
+	Prefix byte
+	Pointer unsafe.Pointer
+	Bytes []byte
+	Text string
+	Map map[byte]byte
+	Channel chan byte
+	Function func()
+	Any interface{}
+	Tail [0]byte
+}
+const Width = unsafe.Sizeof(Values{})
+const Alignment = unsafe.Alignof(Values{})
+const BytesOffset = unsafe.Offsetof(Values{}.Bytes)
+const EmbeddedOffset = unsafe.Offsetof(struct { Prefix byte; Inner }{}.Word)
+const Word = unsafe.Sizeof(uintptr(0))
+`
+	for _, test := range []struct {
+		name, source string
+	}{
+		{name: "qualified", source: original},
+		{name: "alias", source: strings.ReplaceAll(strings.Replace(original,
+			`import "unsafe"`, `import u "unsafe"`, 1), "unsafe.", "u.")},
+		{name: "dot", source: strings.ReplaceAll(strings.Replace(original,
+			`import "unsafe"`, `import . "unsafe"`, 1), "unsafe.", "")},
+		{name: "escaped path", source: strings.Replace(original, `import "unsafe"`, `import "\u0075nsafe"`, 1)},
+		{name: "raw path", source: strings.Replace(original, `import "unsafe"`, "import `unsafe`", 1)},
+		{name: "blank", source: "package header\nimport _ \"unsafe\"\ntype Values struct { Bytes []byte }\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+				t.Run(target, func(t *testing.T) {
+					actual := compileNativeHeaderRules(t, target, test.source)
+					replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20",
+						map[string]string{"header.go": test.source})
+					if err != nil || !reflect.DeepEqual(actual, replayed) {
+						t.Fatalf("Go-accepted builtin import properties differ from original replay: actual=%v replay=%v error=%v",
+							actual, replayed, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderBuiltinImportMapRetainsCompleteOriginalScope(t *testing.T) {
+	const source = "package header\nimport \"unsafe\"\nconst Word = unsafe.Sizeof(uintptr(0))\n"
+	sources := map[string]string{"header.go": source}
+	definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/amd64", "go1.20",
+		sources, map[string]string{"unsafe": "unsafe"})
+	if err != nil || definitions["const_Word"] != "8" {
+		t.Fatalf("complete original builtin property query failed: %v %v", definitions, err)
+	}
+	for _, test := range []struct {
+		name    string
+		imports map[string]string
+	}{
+		{name: "absent"},
+		{name: "deleted", imports: map[string]string{}},
+		{name: "rewritten", imports: map[string]string{"unsafe": "example.invalid/unsafe"}},
+		{name: "empty edge", imports: map[string]string{"unsafe": ""}},
+		{name: "extra", imports: map[string]string{"unsafe": "unsafe", "fmt": "fmt"}},
+		{name: "foreign", imports: map[string]string{"example.invalid/unsafe": "unsafe"}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/amd64", "go1.20",
+				sources, test.imports)
+			if definitions != nil || err == nil || NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("changed actual import map was accepted or hidden by unsupported fallback: %v %v", definitions, err)
+			}
+		})
+	}
+	plain := map[string]string{"header.go": "package header\nconst Word = 8\n"}
+	if definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/amd64", "go1.20",
+		plain, map[string]string{"unsafe": "unsafe"}); definitions != nil || err == nil || NativeHeaderSourceDomainUnsupported(err) {
+		t.Fatalf("unused builtin edge was borrowed from unrelated source: %v %v", definitions, err)
+	}
+	if definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/amd64", "go1.20",
+		plain, map[string]string{}); err != nil || definitions["const_Word"] != "8" {
+		t.Fatalf("complete empty original import map changed: %v %v", definitions, err)
+	}
+}
diff --git a/gotoolprofile/generated_header_descriptor_layout_test.go b/gotoolprofile/generated_header_descriptor_layout_test.go
new file mode 100644
index 000000000..7c2153af0
--- /dev/null
+++ b/gotoolprofile/generated_header_descriptor_layout_test.go
@@ -0,0 +1,80 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const nativeHeaderDescriptorSource = `package header
+type Record struct {
+    Word uintptr
+    Pointer *byte
+    Slice []uint16
+    Text string
+    Map map[uint8]uint16
+    Channel chan uint64
+    Send chan<- uint64
+    Receive <-chan uint64
+    Function func(uintptr) uintptr
+    Empty interface{}
+    NonEmpty interface { Read([]byte) (int, error) }
+    Tail [0]byte
+}
+type Alias = Record
+type Recursive struct {
+    Next *Recursive
+    Children map[string]*Recursive
+    Siblings []*Recursive
+}
+type Array struct { Elements [2]Record; Marker byte }
+type Zero struct { Function func(); Tail [0]*byte }
+`
+
+func TestGeneratedHeaderDescriptorLayoutsMatchActualNativeObjects(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, nativeHeaderDescriptorSource)
+			replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20",
+				map[string]string{"header.go": nativeHeaderDescriptorSource})
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("complete native descriptor header differs from original source replay:\nactual=%v\nreplayed=%v\nerror=%v", actual, replayed, err)
+			}
+			word := 8
+			if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+				word = 4
+			}
+			for name, words := range map[string]int{
+				"Record__size": 17, "Record_Pointer": 1, "Record_Slice": 2, "Record_Text": 5,
+				"Record_Map": 7, "Record_Channel": 8, "Record_Send": 9, "Record_Receive": 10,
+				"Record_Function": 11, "Record_Empty": 12, "Record_NonEmpty": 14, "Record_Tail": 16,
+				"Recursive__size": 5, "Recursive_Next": 0, "Recursive_Children": 1, "Recursive_Siblings": 2,
+				"Array__size": 35, "Array_Marker": 34, "Zero__size": 2, "Zero_Tail": 1,
+			} {
+				if actual[name] != fmt.Sprint(words*word) {
+					t.Fatalf("native word layout/tail padding changed: %s=%s, want %d", name, actual[name], words*word)
+				}
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderUnsafePointerPropertyMatchesActualNativeObjects(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target,
+				"package header\nimport \"unsafe\"\ntype Record struct { Value unsafe.Pointer }\n")
+			word := int64(8)
+			if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+				word = 4
+			}
+			sizes := &nativeHeaderGCSizes{word: word, cache: make(map[types.Type]nativeHeaderLayout), active: make(map[types.Type]bool)}
+			layout, err := sizes.layout(types.Typ[types.UnsafePointer], 0)
+			if err != nil || layout.size != word || layout.align != word || actual["Record__size"] != fmt.Sprint(layout.size) {
+				t.Fatalf("unsafe pointer property differs from native object: %+v %v actual=%v", layout, err, actual)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/generated_header_generic_properties_test.go b/gotoolprofile/generated_header_generic_properties_test.go
new file mode 100644
index 000000000..2600ce2d3
--- /dev/null
+++ b/gotoolprofile/generated_header_generic_properties_test.go
@@ -0,0 +1,65 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"testing"
+)
+
+const nativeHeaderGenericPropertiesSource = `package header
+type Generic[T any] struct {
+	Value T
+	Tail [0]byte
+}
+type Constrained[T interface { ~uint64 | ~string }] struct { Value T }
+type Pointers[T any] struct { Next *Pointers[T] }
+type Concrete = Generic[uint64]
+type Text = Generic[string]
+type Pointer = Pointers[byte]
+type Nested struct {
+	Prefix byte
+	Item Generic[uint32]
+	Other Constrained[string]
+}
+func Identity[T any](value T) T { return value }
+var InstantiatedFunction = Identity[int]
+`
+
+func TestGeneratedHeaderGenericPropertiesMatchActualNativeObjects(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, nativeHeaderGenericPropertiesSource)
+			for _, name := range []string{"Generic__size", "Constrained__size", "Pointers__size", "Identity"} {
+				if _, emitted := actual[name]; emitted {
+					t.Fatalf("actual Go compiler unexpectedly emitted an uninstantiated generic property: %s", name)
+				}
+			}
+			if actual["Concrete__size"] == "" || actual["Text__size"] == "" || actual["Nested__size"] == "" {
+				t.Fatalf("actual Go compiler did not emit concrete generic value properties: %v", actual)
+			}
+			replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20",
+				map[string]string{"header.go": nativeHeaderGenericPropertiesSource})
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("Go-accepted concrete generic properties differ from original source replay: actual=%v replay=%v error=%v",
+					actual, replayed, err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderGenericPropertyQueryRejectsInvalidDeclarations(t *testing.T) {
+	for _, test := range []struct {
+		name, source string
+	}{
+		{"constraint", "package header\ntype G[T ~uint64] struct { Value T }\ntype Wrong = G[string]\n"},
+		{"uninstantiated use", "package header\ntype G[T any] struct { Value T }\ntype Wrong = G\n"},
+		{"recursive value", "package header\ntype G[T any] struct { Self G[T] }\ntype Wrong = G[uint64]\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20",
+				map[string]string{"header.go": test.source})
+			if definitions != nil || err == nil || NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("invalid generic declaration gained properties or was swallowed as unsupported: %v %v", definitions, err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/generated_header_patch_test.go b/gotoolprofile/generated_header_patch_test.go
new file mode 100644
index 000000000..481e172fc
--- /dev/null
+++ b/gotoolprofile/generated_header_patch_test.go
@@ -0,0 +1,45 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestNativeHeaderAuditedPatchRegistration(t *testing.T) {
+	previous := nativeHeaderSourceHashes("go1.27.2")
+	current := nativeHeaderSourceHashes("go1.27.3")
+	if len(previous) != 22 || !reflect.DeepEqual(current, previous) {
+		t.Fatal("byte-identical audited header sources lost their complete registration", len(previous), len(current))
+	}
+	for _, version := range []string{"go1.27.2", "go1.27.3"} {
+		proof := &NativeHeaderSourceRules{Protocol: nativeHeaderSourceRulesProtocol, GoVersion: version, SourceSHA256: current}
+		if err := ValidateNativeHeaderSourceRules(proof, version); err != nil {
+			t.Fatal("audited exact header patch rejected", err)
+		}
+	}
+	for _, version := range []string{"go1.27.2", "go1.27.3"} {
+		for name := range current {
+			t.Run(version+"/changed/"+name, func(t *testing.T) {
+				changed := make(map[string]string, len(current))
+				for role, hash := range current {
+					changed[role] = hash
+				}
+				changed[name] = strings.Repeat("0", 64)
+				proof := &NativeHeaderSourceRules{Protocol: nativeHeaderSourceRulesProtocol, GoVersion: version, SourceSHA256: changed}
+				if ValidateNativeHeaderSourceRules(proof, version) == nil {
+					t.Fatal("changed exact header source acquired a registration")
+				}
+				delete(changed, name)
+				if ValidateNativeHeaderSourceRules(proof, version) == nil {
+					t.Fatal("missing exact header source acquired a registration")
+				}
+			})
+		}
+	}
+	for _, version := range []string{"go1.27.4", "go1.27", "go1.27.3-custom", "devel go1.27.3"} {
+		if nativeHeaderSourceHashes(version) != nil {
+			t.Fatal("unaudited header patch acquired source hashes", version)
+		}
+	}
+}
diff --git a/gotoolprofile/generated_header_source_registration.go b/gotoolprofile/generated_header_source_registration.go
new file mode 100644
index 000000000..6f2bc6708
--- /dev/null
+++ b/gotoolprofile/generated_header_source_registration.go
@@ -0,0 +1,133 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+// NativeHeaderSourceRules registers only the audited closed header property
+// model. It does not authenticate package bytes or create a compiler/ABI role.
+type NativeHeaderSourceRules struct {
+	Protocol     string            `json:"protocol"`
+	GoVersion    string            `json:"go_version"`
+	SourceSHA256 map[string]string `json:"source_sha256"`
+}
+
+const nativeHeaderSourceRulesProtocol = "closed_native_gc_header_rules_v1"
+
+var nativeHeaderSourceRegistration = map[string]map[string]string{
+	"go1.20.14": {
+		"src/cmd/compile/internal/amd64/galign.go":    "c0e78fbcf303739d661616a6d2fb58ffdd91477a1830dd37de12b42a32b77a92",
+		"src/cmd/compile/internal/arm/galign.go":      "36bf9475606bf6da4971dc044212cf9a0332971e53a50ec1889d4e84a3dfbc91",
+		"src/cmd/compile/internal/arm64/galign.go":    "8240611dc6d7933d40898ddf0abdede0e30433118fc1cc9343b70b5835a4a541",
+		"src/cmd/compile/internal/gc/export.go":       "b0181c71f9857cec9a3d589e81f885cc54a58be100919df79b7efee6df40eb12",
+		"src/cmd/compile/internal/gc/main.go":         "297d56f5e9b5cd3248d0cf685e39aeebd5513473532049d6748039de45f98ac8",
+		"src/cmd/compile/internal/ir/package.go":      "83c8cfe6681a3f26ffbec558aeb33e5eea424bd073ff23036b28ad2a0c4ff4d7",
+		"src/cmd/compile/internal/noder/helpers.go":   "d4264706539b096bc106b941d1ef37b653167efc47b7b477dd90f7754f38762b",
+		"src/cmd/compile/internal/noder/object.go":    "ae6c179b51a7e53c89350aa893f79c28ccee438334167549f6c80ede5de8e483",
+		"src/cmd/compile/internal/noder/reader.go":    "7ee01a4dfb3b2bc42027eab9fd5979d3a86be2fe0b0ce76cb9e9e7dcb7a58442",
+		"src/cmd/compile/internal/noder/writer.go":    "32ea040e4cfae703c9f9337f66ed293fd15a6d6ed7d7b9a625efe061c924e760",
+		"src/cmd/compile/internal/typecheck/const.go": "8c14d900fbeb4d3c5c46e89893f30bdf2e3c59b99ffe8729388dc8ad826e5bdd",
+		"src/cmd/compile/internal/typecheck/dcl.go":   "b35fee55dce8983c7f45157138db0771239f86c533465af26fda76a00bd09323",
+		"src/cmd/compile/internal/types/size.go":      "85a99896588d88b72026e1adbe82781612e61a42be5ad68150d5791f5d866558",
+		"src/cmd/compile/internal/types/type.go":      "e32891b13866cf3f96ed5b8570ac73f4f123cb1e0cfe9ecd3f38693c165676e9",
+		"src/cmd/compile/internal/types/universe.go":  "d4fb6989ac1e1d8d0d4afa40a747e295f7b428e368b44a3763b7e3c5a44cec56",
+		"src/cmd/compile/internal/wasm/ssa.go":        "3b6909e83756647d1a8ae67f4d934461362cbb7dd9e1cc12b16fa89922e2c215",
+		"src/cmd/compile/internal/x86/galign.go":      "6f5939341fb89f0357346667d282c5ce622ef58ce467c08fe6f0641edf60a1b7",
+		"src/cmd/internal/sys/arch.go":                "2ffa390a665fcd3ddf11b02310b47f6fd991a7a6ac875a732a4fc85632912498",
+		"src/go/constant/value.go":                    "e8aeb7562c1620179d2cf9846ec6c087ed3fb01c58b991934e8beb2c83da9ea9",
+		"src/go/types/builtins.go":                    "7b58bbeb58d133bb75f86a4af901d7f39de56cfcb5dd620a9529ee737e9ce689",
+		"src/go/types/resolver.go":                    "12f7e9a0a113467c8e4627a6e3d61962da3adbaa1fa957bc39e1ba01ceb1c975",
+		"src/go/types/sizes.go":                       "dae5a89f838c84cb8e2952862f7b7e23075465fb025853a7cd30d7722d3b1058",
+		"src/go/types/universe.go":                    "c3bb75082a60d673a8fe1ed1fbccb0065dac51a4c0f38c265b1c07fb35ed47a0",
+	},
+	"go1.27.1": {
+		"src/cmd/compile/internal/amd64/galign.go":    "c0e78fbcf303739d661616a6d2fb58ffdd91477a1830dd37de12b42a32b77a92",
+		"src/cmd/compile/internal/arm/galign.go":      "ebb81e7128fd8e4f2dd9a4d0820d86423334c13c04b433aee4f436bd1e60bae3",
+		"src/cmd/compile/internal/arm64/galign.go":    "8240611dc6d7933d40898ddf0abdede0e30433118fc1cc9343b70b5835a4a541",
+		"src/cmd/compile/internal/gc/export.go":       "74ac999b6213246274723e2b87d1b24aa76a7da7ac559c8a6fd574f1c34ba5cd",
+		"src/cmd/compile/internal/gc/main.go":         "630003459bf6c39ee0c795be1de24d184ae27ddc432a923a4ae7ec86256ad05c",
+		"src/cmd/compile/internal/ir/package.go":      "c4fd54d2ced005e666ff4e1f3db996af140cb34eadd2f0aaebefd010400c720a",
+		"src/cmd/compile/internal/noder/helpers.go":   "05afcf568b75e953a0e4ed8687c81f7f775ca891a220d10f119f2431721cedbc",
+		"src/cmd/compile/internal/noder/reader.go":    "d141b8f59f973af2a3c3cd22f9d3d8857c802d684074e0d15131cf8f778bb7d9",
+		"src/cmd/compile/internal/noder/writer.go":    "7ed9f0326c5794128110aaa796bb870ce5155a3e34fd47d5546cbeaa6269e52c",
+		"src/cmd/compile/internal/typecheck/const.go": "4cc3238f8b9afff771bf72a2753682f84f0b0be2d750179b0bb6d9daedfb8d4c",
+		"src/cmd/compile/internal/types/size.go":      "d32090d796ae53dc8d1430e206b9e98aee8e1e1b2407f952aa7fdd64b8fb9ad5",
+		"src/cmd/compile/internal/types/type.go":      "50e7b9332dd700aebbd6999f9a5d1bc17e8d24e3f21b06b3c30a628ea751e696",
+		"src/cmd/compile/internal/types/universe.go":  "410606b5ecb3e404bf3e6bc76d13b26c789dc0fb509d41b4b4ff95f158a8c40b",
+		"src/cmd/compile/internal/wasm/ssa.go":        "56d8eefdfecf0d2aaeeefcf73664b209deb487606db8184c8d9975e98df75def",
+		"src/cmd/compile/internal/x86/galign.go":      "6f5939341fb89f0357346667d282c5ce622ef58ce467c08fe6f0641edf60a1b7",
+		"src/cmd/internal/sys/arch.go":                "07ac549fe63e0df269822d5b10b704ca710489b2aa25e176df5d98f2a2c6b8f2",
+		"src/go/constant/value.go":                    "9a4afa576639c98ec2be2602e4b6aecb24760a3dbd386cc8ce8bb5c1d5c4895e",
+		"src/go/types/builtins.go":                    "5a85992f8539b3f64fd99efd827d5a6a518ffd379a8f75f3e5cc5f1efc0fe240",
+		"src/go/types/gcsizes.go":                     "129d9bc7a0fd76b818a8631fcbe8063a87236aa9ca6775280de29d96cf5ef6f7",
+		"src/go/types/resolver.go":                    "7c419b0161a73e57065e334a1a6fa186f782a7b7c616d635818ee93faa8d0bbf",
+		"src/go/types/sizes.go":                       "d097bbaba4237da84f93fd67c9133bcf2df7b429351283774895b7b909da5e93",
+		"src/go/types/universe.go":                    "5b59136965ddfb9aadec2f2a37165beece517445ce3871c3616a71088c63ba13",
+	},
+}
+
+func CaptureNativeHeaderSourceRules(root, version string) (*NativeHeaderSourceRules, error) {
+	if !filepath.IsAbs(root) {
+		return nil, fmt.Errorf("native header source rules require an audited actual SDK")
+	}
+	actualVersion, err := readInstrumentationRegistration(filepath.Join(root, "VERSION"))
+	if err != nil || strings.SplitN(string(actualVersion), "\n", 2)[0] != version {
+		return nil, fmt.Errorf("native header source rules differ from actual SDK VERSION: %v", err)
+	}
+	registration := nativeHeaderSourceHashes(version)
+	if registration == nil {
+		return nil, &nativeHeaderUnsupportedDomain{"actual SDK has no registered native header property query model"}
+	}
+	proof := &NativeHeaderSourceRules{Protocol: nativeHeaderSourceRulesProtocol, GoVersion: version, SourceSHA256: make(map[string]string)}
+	for name := range registration {
+		data, err := readInstrumentationRegistration(filepath.Join(root, filepath.FromSlash(name)))
+		if err != nil {
+			return nil, err
+		}
+		proof.SourceSHA256[name] = bytesSHA256(data)
+	}
+	if err := ValidateNativeHeaderSourceRules(proof, version); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateNativeHeaderSourceRules(proof *NativeHeaderSourceRules, version string) error {
+	wanted := nativeHeaderSourceHashes(version)
+	if proof == nil || proof.Protocol != nativeHeaderSourceRulesProtocol || proof.GoVersion != version || wanted == nil || !reflect.DeepEqual(wanted, proof.SourceSHA256) {
+		return fmt.Errorf("native generated-header rule registration is missing, changed or unaudited")
+	}
+	return nil
+}
+
+func nativeHeaderSourceHashes(version string) map[string]string {
+	if version != "go1.27.2" && version != "go1.27.3" {
+		return nativeHeaderSourceRegistration[version]
+	}
+	// Go 1.27.2 adds method-order fields to unified export data without changing
+	// these header layout rules or their complete source inventory.
+	// Go 1.27.3 has byte-identical sources for all 22 registered rules. Keep
+	// the two changes from 1.27.1 pinned separately, without admitting future
+	// unaudited patches or duplicating the unchanged source registration.
+	result := make(map[string]string, len(nativeHeaderSourceRegistration["go1.27.1"]))
+	for name, hash := range nativeHeaderSourceRegistration["go1.27.1"] {
+		result[name] = hash
+	}
+	result["src/cmd/compile/internal/noder/reader.go"] = "10051996ac541466c4f0f3ccfb3ca7181c38726050d49d2c113ab784119d8be6"
+	result["src/cmd/compile/internal/noder/writer.go"] = "53550393cf60bd31892e18a4a79715670a7243289445b57919faa69163a256e0"
+	return result
+}
+
+func RecheckNativeHeaderSourceRules(root string, proof *NativeHeaderSourceRules) error {
+	if proof == nil {
+		return fmt.Errorf("native generated-header rule recheck lacks its capture")
+	}
+	actual, err := CaptureNativeHeaderSourceRules(root, proof.GoVersion)
+	if err != nil || !reflect.DeepEqual(actual, proof) {
+		return fmt.Errorf("actual native generated-header SDK rules changed: %v", err)
+	}
+	return nil
+}
diff --git a/gotoolprofile/generated_header_source_replay.go b/gotoolprofile/generated_header_source_replay.go
new file mode 100644
index 000000000..d109448bb
--- /dev/null
+++ b/gotoolprofile/generated_header_source_replay.go
@@ -0,0 +1,425 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"path"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+type nativeHeaderUnsupportedDomain struct{ reason string }
+
+func (err *nativeHeaderUnsupportedDomain) Error() string { return err.reason }
+
+// NativeHeaderSourceDomainUnsupported only identifies an unimplemented query
+// domain. It cannot turn a source/compiler/registration failure into authority.
+func NativeHeaderSourceDomainUnsupported(err error) bool {
+	for depth := 0; err != nil && depth < 32; depth++ {
+		if _, ok := err.(*nativeHeaderUnsupportedDomain); ok {
+			return true
+		}
+		wrapped, ok := err.(interface{ Unwrap() error })
+		if !ok {
+			return false
+		}
+		err = wrapped.Unwrap()
+	}
+	return false
+}
+
+// ReplayNativeGeneratedHeader queries a closed source model. Its inputs must
+// independently match actual selected compiler sources and the stock SDK; it
+// grants neither source authentication nor ABI/native-memory permission.
+func ReplayNativeGeneratedHeader(packagePath, target, language string, sources map[string]string) (map[string]string, error) {
+	return replayNativeGeneratedHeader(packagePath, target, language, sources, nil, false)
+}
+
+// ReplayNativeGeneratedHeaderWithImportMap also requires the actual compiler's
+// complete import map to match the original source imports. Foreign imports
+// may only occur outside the complete constant/type property closure; their
+// actual export/source provenance is still required by the metadata consumer.
+// This remains a property query, not compiler acceptance.
+func ReplayNativeGeneratedHeaderWithImportMap(packagePath, target, language string, sources map[string]string,
+	importMap map[string]string) (map[string]string, error) {
+	return replayNativeGeneratedHeader(packagePath, target, language, sources, importMap, true)
+}
+
+func replayNativeGeneratedHeader(packagePath, target, language string, sources map[string]string,
+	importMap map[string]string, requireImportMap bool) (map[string]string, error) {
+	set, files, word, err := parseNativeHeaderSources(packagePath, target, language, sources)
+	if err != nil {
+		return nil, err
+	}
+	if requireImportMap {
+		imports := make(map[string]string)
+		for _, file := range files {
+			for _, spec := range file.Imports {
+				spelling, err := strconv.Unquote(spec.Path.Value)
+				if err != nil {
+					return nil, fmt.Errorf("native header original import path is invalid: %w", err)
+				}
+				imports[spelling] = spelling
+			}
+		}
+		if importMap == nil || len(importMap) != len(imports) {
+			return nil, fmt.Errorf("native header actual import map differs from complete original source imports")
+		}
+		for spelling := range imports {
+			actual := importMap[spelling]
+			if actual == "" || strings.ContainsAny(actual, "\\\r\n\t =") ||
+				spelling == "unsafe" && actual != "unsafe" {
+				return nil, fmt.Errorf("native header actual import map changes or omits an original source import")
+			}
+		}
+	}
+	files, err = nativeHeaderIndependentFiles(files)
+	if err != nil {
+		return nil, err
+	}
+
+	sizes := &nativeHeaderGCSizes{word: word, cache: make(map[types.Type]nativeHeaderLayout), active: make(map[types.Type]bool)}
+	pkg, err := (&types.Config{GoVersion: language, Sizes: sizes, IgnoreFuncBodies: true,
+		Importer: nativeHeaderBuiltinImporter{}}).Check(packagePath, set, files, nil)
+	if err != nil || sizes.err != nil {
+		return nil, fmt.Errorf("native header original declaration typecheck failed: %v %v", err, sizes.err)
+	}
+	return nativeGeneratedHeaderDefinitions(pkg, sizes)
+}
+
+type nativeHeaderBuiltinImporter struct{}
+
+func (nativeHeaderBuiltinImporter) Import(packagePath string) (*types.Package, error) {
+	if packagePath == "unsafe" {
+		return types.Unsafe, nil
+	}
+	return nil, fmt.Errorf("native header importer has no registered original dependency: %s", packagePath)
+}
+
+// Both ordinary and same-mode imported queries use this one native property
+// projection. It is not an ABI layout or an allocation permission.
+func nativeGeneratedHeaderDefinitions(pkg *types.Package, sizes *nativeHeaderGCSizes) (map[string]string, error) {
+	definitions := make(map[string]string)
+	add := func(name, value string) error {
+		if _, duplicate := definitions[name]; duplicate {
+			return fmt.Errorf("native header generated-name collision: %s", name)
+		}
+		definitions[name] = value
+		return nil
+	}
+	for _, name := range pkg.Scope().Names() {
+		if name == "_" {
+			continue
+		}
+		switch object := pkg.Scope().Lookup(name).(type) {
+		case *types.Const:
+			value := object.Val()
+			if value == nil || value.Kind() == constant.Unknown {
+				return nil, fmt.Errorf("native header source has an unresolved constant")
+			}
+			if value.Kind() != constant.Float && value.Kind() != constant.Complex {
+				if err := add("const_"+name, value.ExactString()); err != nil {
+					return nil, err
+				}
+			}
+		case *types.TypeName:
+			if generic, ok := object.Type().(interface {
+				TypeParams() *types.TypeParamList
+				TypeArgs() *types.TypeList
+			}); ok && generic.TypeParams().Len() != 0 && generic.TypeArgs().Len() == 0 {
+				// Native -asmhdr omits uninstantiated generic declarations.
+				// Concrete instances retain their full ordinary value layout.
+				continue
+			}
+			structure, ok := object.Type().Underlying().(*types.Struct)
+			if !ok {
+				continue
+			}
+			layout, err := sizes.layout(object.Type(), 0)
+			if err != nil {
+				return nil, err
+			}
+			if err := add(name+"__size", strconv.FormatInt(layout.size, 10)); err != nil {
+				return nil, err
+			}
+			for index := 0; index < structure.NumFields(); index++ {
+				field := structure.Field(index)
+				if field.Name() != "_" {
+					if err := add(name+"_"+field.Name(), strconv.FormatInt(layout.offsets[index], 10)); err != nil {
+						return nil, err
+					}
+				}
+			}
+		}
+	}
+	if _, err := CanonicalGeneratedHeader(definitions); err != nil {
+		return nil, err
+	}
+	return definitions, nil
+}
+
+// PreflightNativeGeneratedHeaderSource rejects already-unclosed query domains
+// before an expensive planning compiler query. A nil result is not a source,
+// compiler, header or object proof; all final consumers remain mandatory.
+func PreflightNativeGeneratedHeaderSource(packagePath, target, language string, sources map[string]string) error {
+	_, files, _, err := parseNativeHeaderSources(packagePath, target, language, sources)
+	if err == nil {
+		_, err = nativeHeaderIndependentFiles(files)
+	}
+	return err
+}
+
+func parseNativeHeaderSources(packagePath, target, language string, sources map[string]string) (*token.FileSet, []*ast.File, int64, error) {
+	if packagePath == "sync/atomic" || packagePath == "internal/runtime/atomic" || packagePath == "simd/archsimd" {
+		return nil, nil, 0, &nativeHeaderUnsupportedDomain{"native header requires compiler-special package layout rules"}
+	}
+	languageMinor, languageError := goMinor(language)
+	if language == "go1" || languageError == nil && languageMinor < 20 {
+		return nil, nil, 0, &nativeHeaderUnsupportedDomain{"native property query does not register this historical module language"}
+	}
+	goos, arch, ok := strings.Cut(target, "/")
+	word := int64(8)
+	switch arch {
+	case "386", "arm":
+		word = 4
+	case "amd64", "arm64", "wasm":
+	default:
+		return nil, nil, 0, fmt.Errorf("native header source has an unregistered target")
+	}
+	if !ok || !CPPLocalSource(goos) || strings.Contains(goos, "/") ||
+		packagePath == "" || strings.ContainsAny(packagePath, "\\\r\n\t =") ||
+		len(sources) == 0 || len(sources) > 4096 ||
+		language != "go1.20" && language != "go1.21" && language != "go1.22" && language != "go1.23" &&
+			language != "go1.24" && language != "go1.25" && language != "go1.26" && language != "go1.27" {
+		return nil, nil, 0, fmt.Errorf("native header source has an unclosed package/language scope")
+	}
+	set := token.NewFileSet()
+	var names []string
+	for name := range sources {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	var files []*ast.File
+	total, nodes := 0, 0
+	for _, name := range names {
+		text := sources[name]
+		if !CPPLocalSource(name) || !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") ||
+			strings.HasPrefix(path.Base(name), ".") || strings.HasPrefix(path.Base(name), "_") ||
+			len(text) > 2<<20 || len(text) > 16<<20-total || strings.ContainsRune(text, '\x00') {
+			return nil, nil, 0, fmt.Errorf("native header source is absent, nonordinary or unbounded")
+		}
+		total += len(text)
+		file, err := parser.ParseFile(set, name, text, parser.ParseComments)
+		if err != nil {
+			return nil, nil, 0, fmt.Errorf("native header original source is not valid Go: %v", err)
+		}
+		for _, spec := range file.Imports {
+			spelling, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				return nil, nil, 0, fmt.Errorf("native header original import path is invalid: %w", err)
+			}
+			if spelling == "" || strings.ContainsAny(spelling, "\\\r\n\t =") {
+				return nil, nil, 0, fmt.Errorf("native header original import path is not canonical")
+			}
+		}
+		closed := true
+		ast.Inspect(file, func(node ast.Node) bool {
+			if node == nil {
+				return false
+			}
+			nodes++
+			return nodes <= 100000
+		})
+		functionDocs := make(map[*ast.CommentGroup]bool)
+		for _, declaration := range file.Decls {
+			if function, ok := declaration.(*ast.FuncDecl); ok && function.Doc != nil {
+				functionDocs[function.Doc] = true
+			}
+		}
+		for _, group := range file.Comments {
+			for _, comment := range group.List {
+				if strings.HasPrefix(comment.Text, "//go:") && !strings.HasPrefix(comment.Text, "//go:build ") {
+					closed = closed && functionDocs[group] && nativeHeaderOrdinaryFunctionDirective(comment.Text)
+				}
+			}
+		}
+		if nodes > 100000 {
+			return nil, nil, 0, fmt.Errorf("native header original source exceeds its bounded query work")
+		}
+		if !closed {
+			return nil, nil, 0, &nativeHeaderUnsupportedDomain{"native header source requires unregistered compiler-directive rules"}
+		}
+		files = append(files, file)
+	}
+	if err := boundNativeHeaderStrings(files); err != nil {
+		return nil, nil, 0, err
+	}
+	return set, files, word, nil
+}
+
+// This finite ordinary function-code domain cannot add constants, named types
+// or native layout fields. Require the original function attachment, not just
+// a matching comment anywhere in a file. Compiler-special, linkage, generated
+// data and unknown directives retain their independent unclosed source roles.
+// A property query does not confer these directives' code or ABI semantics;
+// actual compiler/header and final object consumers still run on original bytes.
+func nativeHeaderOrdinaryFunctionDirective(text string) bool {
+	switch strings.TrimSpace(text) {
+	case "//go:noinline", "//go:nosplit", "//go:noescape", "//go:norace", "//go:nocheckptr", "//go:uintptrescapes":
+		return true
+	default:
+		return false
+	}
+}
+
+// This native model deliberately does not use the framework's SizesFor: old
+// StdSizes omits gc struct tail padding and padded array strides. This is a
+// native value-layout property model, not an allocation, pointee or ABI contract.
+type nativeHeaderLayout struct {
+	size, align int64
+	offsets     []int64
+}
+
+type nativeHeaderGCSizes struct {
+	word   int64
+	work   int
+	err    error
+	cache  map[types.Type]nativeHeaderLayout
+	active map[types.Type]bool
+}
+
+func (sizes *nativeHeaderGCSizes) Alignof(typ types.Type) int64 {
+	layout, err := sizes.layout(typ, 0)
+	if err != nil {
+		sizes.err = err
+		return 1
+	}
+	return layout.align
+}
+
+func (sizes *nativeHeaderGCSizes) Sizeof(typ types.Type) int64 {
+	layout, err := sizes.layout(typ, 0)
+	if err != nil {
+		sizes.err = err
+		return -1
+	}
+	return layout.size
+}
+
+func (sizes *nativeHeaderGCSizes) Offsetsof(fields []*types.Var) []int64 {
+	offsets := make([]int64, len(fields))
+	var end int64
+	for index, field := range fields {
+		layout, err := sizes.layout(field.Type(), 0)
+		if err == nil {
+			offsets[index], err = sizes.round(end, layout.align)
+		}
+		if err != nil || layout.size >= sizes.limit()-offsets[index] {
+			sizes.err = fmt.Errorf("native header field extent is unclosed or overflows")
+			offsets[index] = -1
+			return offsets
+		}
+		end = offsets[index] + layout.size
+	}
+	return offsets
+}
+
+func (sizes *nativeHeaderGCSizes) limit() int64 {
+	if sizes.word == 4 {
+		// Native calcStructOffset rejects field ends at the signed 32-bit
+		// boundary. Use the stricter common bound, including array queries.
+		return 1<<31 - 1
+	}
+	return 1 << 50
+}
+
+func (sizes *nativeHeaderGCSizes) round(value, align int64) (int64, error) {
+	if value < 0 || align < 1 || align > 8 || value > sizes.limit()-align {
+		return 0, fmt.Errorf("native header alignment/extent overflows")
+	}
+	return (value + align - 1) &^ (align - 1), nil
+}
+
+func (sizes *nativeHeaderGCSizes) layout(typ types.Type, depth int) (nativeHeaderLayout, error) {
+	if cached, present := sizes.cache[typ]; present {
+		return cached, nil
+	}
+	sizes.work++
+	if depth > 128 || sizes.work > 100000 || sizes.active[typ] {
+		return nativeHeaderLayout{}, fmt.Errorf("native header layout is recursive or exceeds its query bound")
+	}
+	sizes.active[typ] = true
+	defer delete(sizes.active, typ)
+	layout := nativeHeaderLayout{align: 1}
+	switch value := typ.Underlying().(type) {
+	case *types.Basic:
+		switch value.Kind() {
+		case types.Bool, types.Int8, types.Uint8:
+			layout.size, layout.align = 1, 1
+		case types.Int16, types.Uint16:
+			layout.size, layout.align = 2, 2
+		case types.Int32, types.Uint32, types.Float32:
+			layout.size, layout.align = 4, 4
+		case types.Int, types.Uint, types.Uintptr, types.UnsafePointer:
+			layout.size, layout.align = sizes.word, sizes.word
+		case types.String:
+			layout.size, layout.align = 2*sizes.word, sizes.word
+		case types.Int64, types.Uint64, types.Float64:
+			layout.size, layout.align = 8, sizes.word
+		case types.Complex64:
+			layout.size, layout.align = 8, 4
+		case types.Complex128:
+			layout.size, layout.align = 16, sizes.word
+		default:
+			return nativeHeaderLayout{}, &nativeHeaderUnsupportedDomain{"native header layout has an unclosed basic type"}
+		}
+	case *types.Pointer, *types.Map, *types.Chan, *types.Signature:
+		// Descriptors have a fixed representation. Do not follow their
+		// pointees, elements, backing stores or callable machine state.
+		layout.size, layout.align = sizes.word, sizes.word
+	case *types.Slice:
+		layout.size, layout.align = 3*sizes.word, sizes.word
+	case *types.Interface:
+		layout.size, layout.align = 2*sizes.word, sizes.word
+	case *types.Array:
+		element, err := sizes.layout(value.Elem(), depth+1)
+		if err != nil || value.Len() < 0 || element.size != 0 && value.Len() > (sizes.limit()-1)/element.size {
+			return nativeHeaderLayout{}, fmt.Errorf("native header array layout is unclosed or overflows")
+		}
+		layout.size, layout.align = element.size*value.Len(), element.align
+	case *types.Struct:
+		layout.offsets = make([]int64, value.NumFields())
+		var lastSize int64
+		for index := 0; index < value.NumFields(); index++ {
+			field, err := sizes.layout(value.Field(index).Type(), depth+1)
+			if err != nil {
+				return nativeHeaderLayout{}, err
+			}
+			offset, err := sizes.round(layout.size, field.align)
+			if err != nil || field.size >= sizes.limit()-offset {
+				return nativeHeaderLayout{}, fmt.Errorf("native header struct extent overflows")
+			}
+			layout.offsets[index], layout.size, lastSize = offset, offset+field.size, field.size
+			if field.align > layout.align {
+				layout.align = field.align
+			}
+		}
+		if layout.size > 0 && lastSize == 0 {
+			layout.size++
+		}
+		var err error
+		layout.size, err = sizes.round(layout.size, layout.align)
+		if err != nil {
+			return nativeHeaderLayout{}, err
+		}
+	default:
+		return nativeHeaderLayout{}, &nativeHeaderUnsupportedDomain{"native header layout requires an unclosed type-parameter model"}
+	}
+	sizes.cache[typ] = layout
+	return layout, nil
+}
diff --git a/gotoolprofile/generated_header_source_replay_test.go b/gotoolprofile/generated_header_source_replay_test.go
new file mode 100644
index 000000000..899519b06
--- /dev/null
+++ b/gotoolprofile/generated_header_source_replay_test.go
@@ -0,0 +1,139 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestGeneratedHeaderSourceRuleRegistrationBindsActualSDKAndCompleteSourceSet(t *testing.T) {
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Dir(filepath.Dir(goBinary))
+	root, err = filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	output, stderr, err := RunBounded(ctx, t.TempDir(), os.Environ(), goBinary, "env", "GOVERSION")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual native-header rule SDK version: %v\n%s\n%s", err, output, stderr)
+	}
+	version := strings.TrimSpace(string(output))
+	proof, err := CaptureNativeHeaderSourceRules(root, version)
+	if nativeHeaderSourceHashes(version) == nil {
+		if !NativeHeaderSourceDomainUnsupported(err) || proof != nil {
+			t.Fatalf("unknown actual SDK acquired registered omission authority: %v", err)
+		}
+		return
+	}
+	if err != nil || RecheckNativeHeaderSourceRules(root, proof) != nil {
+		t.Fatalf("actual audited native SDK rule capture/recheck: %v", err)
+	}
+	for _, mutate := range []func(*NativeHeaderSourceRules){
+		func(copy *NativeHeaderSourceRules) { copy.Protocol = "legacy" },
+		func(copy *NativeHeaderSourceRules) { copy.GoVersion = "go1.99" },
+		func(copy *NativeHeaderSourceRules) {
+			delete(copy.SourceSHA256, "src/cmd/compile/internal/types/size.go")
+		},
+		func(copy *NativeHeaderSourceRules) {
+			copy.SourceSHA256["src/cmd/compile/internal/types/size.go"] = strings.Repeat("1", 64)
+		},
+		func(copy *NativeHeaderSourceRules) { copy.SourceSHA256["extra"] = strings.Repeat("1", 64) },
+	} {
+		copy := *proof
+		copy.SourceSHA256 = make(map[string]string)
+		for name, digest := range proof.SourceSHA256 {
+			copy.SourceSHA256[name] = digest
+		}
+		mutate(&copy)
+		if ValidateNativeHeaderSourceRules(&copy, version) == nil {
+			t.Fatal("changed/deleted/extra rule registration acquired header replay authority")
+		}
+	}
+}
+
+func TestGeneratedHeaderSourceUnsupportedDomainCannotSwallowFailures(t *testing.T) {
+	_, unsupported := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", map[string]string{"header.go": "package header\nimport \"time\"\nconst Value = time.Second\n"})
+	if !NativeHeaderSourceDomainUnsupported(unsupported) || !NativeHeaderSourceDomainUnsupported(fmt.Errorf("property query: %w", unsupported)) {
+		t.Fatal("unclosed imported property model lacks its precise typed domain")
+	}
+	for _, failure := range []error{
+		fmt.Errorf("source parse failure"), errors.Join(unsupported, fmt.Errorf("source changed")),
+		fmt.Errorf("native header source query has unclosed imports"),
+	} {
+		if NativeHeaderSourceDomainUnsupported(failure) {
+			t.Fatal("an unrelated or joined failure became a conservative successful query")
+		}
+	}
+	for _, packagePath := range []string{"sync/atomic", "internal/runtime/atomic", "simd/archsimd"} {
+		definitions, err := ReplayNativeGeneratedHeader(packagePath, "linux/386", "go1.20", map[string]string{"header.go": "package header\ntype Record struct { Value uint64 }\n"})
+		if definitions != nil || !NativeHeaderSourceDomainUnsupported(err) {
+			t.Fatal("compiler-special layout acquired ordinary native alignment")
+		}
+	}
+	if _, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/386", "go1.20", map[string]string{"header.go": "package header\ntype Record struct { Value [1<<31]byte }\n"}); err == nil || NativeHeaderSourceDomainUnsupported(err) {
+		t.Fatal("overflow must fail, not suspend a supposedly successful source query")
+	}
+}
+
+func TestGeneratedHeaderSourceReplayMatchesOriginalNativeObjects(t *testing.T) {
+	source := nativeHeaderRulesSource
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, source)
+			replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20", map[string]string{"header.go": source})
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("complete native compiler header differs from independent original source replay:\nactual=%v\nreplayed=%v\nerror=%v", actual, replayed, err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderSourceReplayRejectsUnclosedInputs(t *testing.T) {
+	for _, source := range []string{
+		"package header\ntype Record struct { Value [1<<62]uint64 }\n",
+		"package header\ntype Record struct { Self Record }\n",
+		"package header\ntype A struct { B__size byte }\ntype A_B struct {}\n",
+	} {
+		if definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", map[string]string{"header.go": source}); err == nil || definitions != nil {
+			t.Fatalf("unclosed source acquired header definitions: %q %v %v", source, definitions, err)
+		}
+	}
+}
+
+func TestGeneratedHeaderSourceReplayRetainsBlankZeroTailAndMultifileIdentity(t *testing.T) {
+	sources := map[string]string{
+		"first.go":  "package header\nconst First = 7\ntype Record struct { First uint64; _ byte; Tail [0]byte }\n",
+		"second.go": "package header\nconst Second = First + 1\ntype Alias = Record\n",
+	}
+	wanted := map[string]string{"const_First": "7", "const_Second": "8", "Record__size": "16", "Record_First": "0", "Record_Tail": "9", "Alias__size": "16", "Alias_First": "0", "Alias_Tail": "9"}
+	actual, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", sources)
+	if err != nil || !reflect.DeepEqual(actual, wanted) {
+		t.Fatalf("multifile/blank/zero-tail native source replay: %v %v", actual, err)
+	}
+	for _, mutate := range []func(map[string]string){
+		func(copy map[string]string) { delete(copy, "first.go") },
+		func(copy map[string]string) { copy["second.go"] = "package different\nconst Second = 8\n" },
+		func(copy map[string]string) { copy["second_test.go"] = copy["second.go"]; delete(copy, "second.go") },
+	} {
+		copy := make(map[string]string)
+		for name, text := range sources {
+			copy[name] = text
+		}
+		mutate(copy)
+		if definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", copy); err == nil || definitions != nil {
+			t.Fatalf("changed original source acquired a complete header: %v %v", definitions, err)
+		}
+	}
+}
diff --git a/gotoolprofile/generated_header_source_resources.go b/gotoolprofile/generated_header_source_resources.go
new file mode 100644
index 000000000..40f948acd
--- /dev/null
+++ b/gotoolprofile/generated_header_source_resources.go
@@ -0,0 +1,207 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"sort"
+	"strconv"
+)
+
+// go/constant keeps string concatenations as lazy DAGs. Neither the original
+// source byte bound nor the AST node bound limits materializing that DAG in
+// go/types (for example len) or ExactString. This is a conservative resource
+// precheck, not another Go constant evaluator. It may refuse a query domain,
+// but cannot supply definitions, source acceptance or omission authority.
+type nativeHeaderStringBudget struct {
+	limit       uint64
+	work        int
+	bindings    map[string]ast.Expr
+	memo        map[string]uint64
+	active      map[string]bool
+	unpublished []ast.Expr
+	selector    func(*ast.SelectorExpr) (uint64, error)
+}
+
+func boundNativeHeaderStrings(files []*ast.File) error {
+	budget, err := newNativeHeaderStringBudget(files)
+	if err != nil {
+		return err
+	}
+	return budget.check(files)
+}
+
+func newNativeHeaderStringBudget(files []*ast.File) (*nativeHeaderStringBudget, error) {
+	budget := &nativeHeaderStringBudget{
+		limit: generatedHeaderByteLimit, bindings: make(map[string]ast.Expr),
+		memo: make(map[string]uint64), active: make(map[string]bool),
+	}
+	for _, file := range files {
+		for _, declaration := range file.Decls {
+			group, ok := declaration.(*ast.GenDecl)
+			if !ok || group.Tok != token.CONST {
+				continue
+			}
+			var previous []ast.Expr
+			for _, item := range group.Specs {
+				spec := item.(*ast.ValueSpec)
+				if len(spec.Values) != 0 {
+					previous = spec.Values
+				}
+				for index, name := range spec.Names {
+					if index >= len(previous) {
+						continue // The unchanged typechecker diagnoses invalid arity.
+					}
+					if name.Name == "_" {
+						budget.unpublished = append(budget.unpublished, previous[index])
+						continue
+					}
+					if _, duplicate := budget.bindings[name.Name]; duplicate {
+						return nil, fmt.Errorf("native header original constant declaration is duplicated")
+					}
+					budget.bindings[name.Name] = previous[index]
+				}
+				if len(previous) > len(spec.Names) {
+					budget.unpublished = append(budget.unpublished, previous[len(spec.Names):]...)
+				}
+			}
+		}
+	}
+	return budget, nil
+}
+
+func (budget *nativeHeaderStringBudget) check(files []*ast.File) error {
+	var names []string
+	for name := range budget.bindings {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	var total uint64
+	addExpression := func(expression ast.Expr) error {
+		width, err := budget.expression(expression, 0)
+		if err != nil {
+			return err
+		}
+		total, err = budget.add(total, width)
+		return err
+	}
+	for _, name := range names {
+		if err := addExpression(&ast.Ident{Name: name}); err != nil {
+			return err
+		}
+	}
+	for _, expression := range budget.unpublished {
+		if err := addExpression(expression); err != nil {
+			return err
+		}
+	}
+	for _, file := range files {
+		for _, declaration := range file.Decls {
+			if group, ok := declaration.(*ast.GenDecl); ok && group.Tok == token.CONST {
+				continue // Complete constant bindings were already charged above.
+			}
+			var failure error
+			ast.Inspect(declaration, func(node ast.Node) bool {
+				if node == nil || failure != nil {
+					return false
+				}
+				if _, body := node.(*ast.BlockStmt); body {
+					return false // Matches IgnoreFuncBodies; signatures remain checked.
+				}
+				if expression, ok := node.(ast.Expr); ok {
+					failure = addExpression(expression)
+					return false
+				}
+				return true
+			})
+			if failure != nil {
+				return failure
+			}
+		}
+	}
+	return nil
+}
+
+func (budget *nativeHeaderStringBudget) add(left, right uint64) (uint64, error) {
+	if left > budget.limit || right > budget.limit-left {
+		return 0, &nativeHeaderUnsupportedDomain{"native header string expansion exceeds its bounded query domain"}
+	}
+	return left + right, nil
+}
+
+func (budget *nativeHeaderStringBudget) expression(expression ast.Expr, depth int) (uint64, error) {
+	budget.work++
+	if depth > 128 || budget.work > 100000 {
+		return 0, &nativeHeaderUnsupportedDomain{"native header string expansion exceeds its bounded query work"}
+	}
+	switch expression := expression.(type) {
+	case *ast.SelectorExpr:
+		if budget.selector != nil {
+			return budget.selector(expression)
+		}
+		// Ordinary field receivers may contain original literals and calls.
+		// Observe those costs without evaluating the receiver or granting an
+		// imported string definition. A builtin package qualifier costs zero.
+		return budget.expression(expression.X, depth+1)
+	case *ast.BasicLit:
+		if expression.Kind != token.STRING {
+			return 0, nil
+		}
+		value, err := strconv.Unquote(expression.Value)
+		if err != nil {
+			return 0, fmt.Errorf("native header original string literal is invalid: %w", err)
+		}
+		// Six output bytes per original byte bounds Quote's Unicode/control
+		// escaping, including invalid UTF-8 and concatenation across literals.
+		width := uint64(len(value)) * 6
+		return budget.add(0, width)
+	case *ast.Ident:
+		definition, found := budget.bindings[expression.Name]
+		if !found {
+			return 0, nil // Names/types are resolved by the unchanged typechecker.
+		}
+		if width, found := budget.memo[expression.Name]; found {
+			return width, nil
+		}
+		if budget.active[expression.Name] {
+			return 0, fmt.Errorf("native header original constant declaration is recursive")
+		}
+		budget.active[expression.Name] = true
+		width, err := budget.expression(definition, depth+1)
+		delete(budget.active, expression.Name)
+		if err == nil {
+			budget.memo[expression.Name] = width
+		}
+		return width, err
+	default:
+		var width uint64
+		// A constant rune-to-string conversion produces at most four UTF-8
+		// bytes. Other calls/operations conservatively retain all operand
+		// expansion costs; this cannot evaluate or authorize an unknown call.
+		if _, call := expression.(*ast.CallExpr); call {
+			width = 4 * 6
+		}
+		var failure error
+		ast.Inspect(expression, func(node ast.Node) bool {
+			if node == nil || node == expression {
+				return node != nil
+			}
+			if failure != nil {
+				return false
+			}
+			if _, body := node.(*ast.BlockStmt); body {
+				return false
+			}
+			if child, ok := node.(ast.Expr); ok {
+				var operand uint64
+				operand, failure = budget.expression(child, depth+1)
+				if failure == nil {
+					width, failure = budget.add(width, operand)
+				}
+				return false
+			}
+			return true
+		})
+		return width, failure
+	}
+}
diff --git a/gotoolprofile/generated_header_source_resources_test.go b/gotoolprofile/generated_header_source_resources_test.go
new file mode 100644
index 000000000..d60e20098
--- /dev/null
+++ b/gotoolprofile/generated_header_source_resources_test.go
@@ -0,0 +1,266 @@
+package gotoolprofile
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"runtime/debug"
+	"strings"
+	"testing"
+	"time"
+)
+
+func nativeHeaderGrowingStringSources(steps int) map[string]string {
+	var first, second strings.Builder
+	first.WriteString("package header\nconst A0 = \"x\"\n")
+	second.WriteString("package header\n")
+	for step := 1; step <= steps; step++ {
+		file := &first
+		if step%2 != 0 {
+			file = &second
+		}
+		fmt.Fprintf(file, "const A%d = (A%d) + A%d\n", step, step-1, step-1)
+	}
+	fmt.Fprintf(&second, "const Alias = (A%d)\nvar Observed = len(Alias)\n", steps)
+	return map[string]string{"first.go": first.String(), "second.go": second.String()}
+}
+
+func TestGeneratedHeaderSourceStringExpansionBoundBeforeTypecheck(t *testing.T) {
+	const childKey = "PLAN9ASM_NATIVE_HEADER_RESOURCE_CHILD"
+	if os.Getenv(childKey) == "1" {
+		// This is a soft Go memory limit, not an OS allocation-security claim.
+		// The fixed 24-step witness has a 16 MiB largest original string, so the
+		// pre-fix child remains a deliberately bounded diagnostic, not an OOM test.
+		debug.SetMemoryLimit(128 << 20)
+		var before, after runtime.MemStats
+		runtime.ReadMemStats(&before)
+		definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", nativeHeaderGrowingStringSources(24))
+		runtime.ReadMemStats(&after)
+		t.Logf("NATIVE_HEADER_RESOURCE steps=24 allocated=%d retained=%d definitions=%d error=%v", after.TotalAlloc-before.TotalAlloc,
+			after.HeapAlloc, len(definitions), err)
+		if definitions != nil || !NativeHeaderSourceDomainUnsupported(err) {
+			t.Fatalf("bounded source model expanded a compact string DAG before its resource-domain refusal: definitions=%d error=%v", len(definitions), err)
+		}
+		if after.TotalAlloc-before.TotalAlloc > 8<<20 {
+			t.Fatalf("string resource guard ran after expensive type/constant materialization: allocated=%d", after.TotalAlloc-before.TotalAlloc)
+		}
+		return
+	}
+
+	binary, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	env := append(os.Environ(), childKey+"=1", "GOMEMLIMIT=128MiB")
+	stdout, stderr, err := RunBounded(ctx, t.TempDir(), env, binary,
+		"-test.run=^TestGeneratedHeaderSourceStringExpansionBoundBeforeTypecheck$", "-test.v", "-test.timeout=25s")
+	if err != nil || len(stderr) != 0 || !strings.Contains(string(stdout), "NATIVE_HEADER_RESOURCE steps=24") {
+		t.Fatalf("actual bounded model child failed its pre-typecheck resource contract: %v\n%s\n%s", err, stdout, stderr)
+	}
+	t.Logf("original resource child receipt:\n%s", stdout)
+}
+
+func TestGeneratedHeaderSourceOrdinaryStringConstantsRemainExact(t *testing.T) {
+	sources := nativeHeaderGrowingStringSources(6)
+	definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", sources)
+	if err != nil || definitions["const_Alias"] != fmt.Sprintf("%q", strings.Repeat("x", 64)) || definitions["const_A0"] != "\"x\"" {
+		t.Fatalf("ordinary alias/parenthesis/cross-file string semantics changed: %v %v", definitions, err)
+	}
+	sources["conversion.go"] = "package header\ntype Text string\nconst Converted = Text(\"a\" + \"b\")\nconst RuneText = string(65)\nconst Repeated = Converted\n"
+	definitions, err = ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", sources)
+	if err != nil || definitions["const_Converted"] != "\"ab\"" || definitions["const_RuneText"] != "\"A\"" || definitions["const_Repeated"] != "\"ab\"" {
+		t.Fatalf("bounded named/rune conversion string semantics changed: %v %v", definitions, err)
+	}
+}
+
+func TestGeneratedHeaderSourceStringResourcesMatchFiveNativeObjects(t *testing.T) {
+	source := "package header\n" +
+		"const (\n  First = \"a\"\n  Repeated\n  Pair = First + Repeated\n)\n" +
+		"type Text string\nconst Named = Text(Pair)\nconst Rune = string(65)\n" +
+		"const Escaped = \"\\x00\\xff\" + \"\\u2028\"\nconst Length = len(Named)\n"
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, source)
+			replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20", map[string]string{"header.go": source})
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("resource precheck changed actual native string/header semantics: actual=%v replay=%v error=%v", actual, replayed, err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderSourceStringResourceCheckedBoundaries(t *testing.T) {
+	budget := &nativeHeaderStringBudget{limit: 32, bindings: make(map[string]ast.Expr),
+		memo: make(map[string]uint64), active: make(map[string]bool)}
+	literal := &ast.BasicLit{Kind: token.STRING, Value: "\"abcd\""}
+	width, err := budget.expression(literal, 0)
+	if err != nil || width != 24 {
+		t.Fatalf("independent literal escaping bound: %d %v", width, err)
+	}
+	if sum, err := budget.add(width, 8); err != nil || sum != 32 {
+		t.Fatalf("exact resource boundary was rejected: %d %v", sum, err)
+	}
+	for _, pair := range [][2]uint64{{width, 9}, {33, 0}, {0, ^uint64(0)}} {
+		if _, err := budget.add(pair[0], pair[1]); !NativeHeaderSourceDomainUnsupported(err) {
+			t.Fatalf("overflow/excess became a bounded query: %v %v", pair, err)
+		}
+	}
+	budget.bindings["Recursive"] = &ast.Ident{Name: "Recursive"}
+	if _, err := budget.expression(&ast.Ident{Name: "Recursive"}, 0); err == nil || NativeHeaderSourceDomainUnsupported(err) {
+		t.Fatal("invalid constant recursion was swallowed as an unsupported successful query")
+	}
+	budget.work = 100000
+	if _, err := budget.expression(literal, 0); !NativeHeaderSourceDomainUnsupported(err) {
+		t.Fatal("exhausted precheck work acquired query authority")
+	}
+}
+
+func TestGeneratedHeaderSourceSelectorResourcesCoverOriginalReceivers(t *testing.T) {
+	for _, test := range []struct {
+		name, expression string
+		exceeds          bool
+	}{
+		{"field", `struct { Text string }{Text: "abcdef"}.Text`, true},
+		{"parenthesized", `(struct { Text string }{Text: "abcdef"}).Text`, true},
+		{"nested", `struct { Inner struct { Text string } }{Inner: struct { Text string }{Text: "abcdef"}}.Inner.Text`, true},
+		{"sizeof", `unsafe.Sizeof(struct { Text string }{Text: "abcdef"}.Text)`, true},
+		{"alignof", `unsafe.Alignof(struct { Text string }{Text: "abcdef"}.Text)`, true},
+		{"offsetof", `unsafe.Offsetof(struct { Text string }{Text: "abcdef"}.Text)`, true},
+		{"ordinary field", `struct { Value uint64 }{}.Value`, false},
+		{"builtin property", `unsafe.Sizeof(struct { Value uint64 }{}.Value)`, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			expression, err := parser.ParseExpr(test.expression)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Exercise only the existing resource observer, never materialize a
+			// Go constant or execute the receiver. The original witness is tiny.
+			budget := &nativeHeaderStringBudget{limit: 32, bindings: make(map[string]ast.Expr),
+				memo: make(map[string]uint64), active: make(map[string]bool)}
+			width, err := budget.expression(expression, 0)
+			if test.exceeds {
+				if !NativeHeaderSourceDomainUnsupported(err) {
+					t.Fatalf("selector receiver bypassed its original string resource bound: width=%d error=%v", width, err)
+				}
+			} else if err != nil || width > budget.limit {
+				t.Fatalf("small original receiver lost its bounded query domain: width=%d error=%v", width, err)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderSourcePreflightNeverCertifiesTypecheck(t *testing.T) {
+	for _, source := range []string{
+		"package header\nconst Huge = 1 << 1000000000\n",
+		"package header\ntype A = B\ntype B = A\n",
+		"package header\nconst Wrong = Missing\n",
+	} {
+		definitions, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/amd64", "go1.20", map[string]string{"header.go": source})
+		if definitions != nil || err == nil || NativeHeaderSourceDomainUnsupported(err) {
+			t.Fatalf("actual type/shift/alias failure became a conservative query success: %v %v", definitions, err)
+		}
+	}
+}
+
+func TestGeneratedHeaderSourceInvalidConstantsMatchActualCompiler(t *testing.T) {
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err = filepath.Abs(goBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := replaceEnv(os.Environ(), map[string]string{
+		"GOOS": "linux", "GOARCH": "amd64", "CGO_ENABLED": "0", "GOFLAGS": "",
+		"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOEXPERIMENT": "",
+	})
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	directory := t.TempDir()
+	if err := os.WriteFile(filepath.Join(directory, "go.mod"), []byte("module example.invalid/header\ngo 1.20\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err := RunBounded(ctx, directory, env, goBinary,
+		"env", "-json", "GOVERSION", "GOTOOLDIR", "GOHOSTOS")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual invalid-source SDK: %v\n%s\n%s", err, stdout, stderr)
+	}
+	var sdk struct{ GOVERSION, GOTOOLDIR, GOHOSTOS string }
+	if err := json.Unmarshal(stdout, &sdk); err != nil || sdk.GOTOOLDIR == "" || sdk.GOVERSION == "" {
+		t.Fatalf("invalid-source compiler has no actual SDK identity: %+v %v", sdk, err)
+	}
+	extension := ""
+	if sdk.GOHOSTOS == "windows" {
+		extension = ".exe"
+	}
+	compiler := filepath.Join(sdk.GOTOOLDIR, "compile"+extension)
+	inputs := []string{goBinary, compiler}
+	digests := make(map[string][32]byte)
+	for _, input := range inputs {
+		data, err := os.ReadFile(input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		digests[input] = sha256.Sum256(data)
+	}
+	for _, axis := range []string{"huge shift", "recursive alias", "missing constant"} {
+		t.Run(axis, func(t *testing.T) {
+			source := "package header\nconst Wrong = Missing\n"
+			diagnostic := "undefined: Missing"
+			switch axis {
+			case "huge shift":
+				source = "package header\nconst Huge = 1 << 1000000000\n"
+				diagnostic = "invalid shift count 1000000000"
+			case "recursive alias":
+				source = "package header\ntype A = B\ntype B = A\n"
+				diagnostic = "invalid recursive type A"
+			}
+			goFile := filepath.Join(directory, "header.go")
+			if err := os.WriteFile(goFile, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stdout, stderr, err := RunBounded(ctx, directory, env, goBinary,
+				"list", "-p=2", "-mod=readonly", "-export", "-compiled", "-json", ".")
+			var exit *exec.ExitError
+			output := string(stdout) + string(stderr)
+			if !errors.As(err, &exit) || exit.ExitCode() != 1 || !strings.Contains(string(stderr), "header.go:") ||
+				!strings.Contains(string(stderr), diagnostic) || strings.Contains(output, "panic:") {
+				t.Fatalf("actual original invalid declaration did not fail with a bound diagnostic: %v\n%s", err, output)
+			}
+			var selected struct {
+				ImportPath, Export string
+				CompiledGoFiles    []string
+			}
+			if err := json.Unmarshal(stdout, &selected); err != nil || selected.Export != "" ||
+				selected.ImportPath != "example.invalid/header" || !reflect.DeepEqual(selected.CompiledGoFiles, []string{"header.go"}) {
+				t.Fatalf("invalid original acquired compiler export evidence: export=%q error=%v", selected.Export, err)
+			}
+			for _, input := range append(inputs, goFile) {
+				data, err := os.ReadFile(input)
+				wanted := digests[input]
+				if input == goFile {
+					wanted = sha256.Sum256([]byte(source))
+				}
+				if err != nil || sha256.Sum256(data) != wanted {
+					t.Fatalf("invalid-source compiler input changed: %s %v", input, err)
+				}
+			}
+			t.Logf("NATIVE_HEADER_INVALID_SOURCE sdk=%s source_sha=%x compile_sha=%x selection_sha=%x exit=%d stderr=%q",
+				sdk.GOVERSION, sha256.Sum256([]byte(source)), digests[compiler], sha256.Sum256(stdout), exit.ExitCode(), stderr)
+		})
+	}
+}
diff --git a/gotoolprofile/generated_header_source_rules_test.go b/gotoolprofile/generated_header_source_rules_test.go
new file mode 100644
index 000000000..47dea56d9
--- /dev/null
+++ b/gotoolprofile/generated_header_source_rules_test.go
@@ -0,0 +1,334 @@
+package gotoolprofile
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+// These are native compiler observations, not a source-derived header proof or
+// permission to omit a CPU scope. The complete source replay is a later stage.
+const nativeHeaderRulesSource = `package header
+
+const (
+	First = iota + 1
+	Second
+)
+const Text = "x y\n世界"
+const Truth = true
+const Rune = '世'
+const Negative = -7
+const Huge = 1 << 80
+const Fraction = 1.25
+const Complex = 1 + 2i
+const IntegerFromFloat int16 = 2.0
+const TypedFloat float32 = 2
+const _ = 17
+
+type NonStruct int
+type Word = uintptr
+type Packet struct { First uint64; Last byte }
+type Alias = Packet
+type Defined Packet
+type Nested struct { Prefix byte; Body Packet; Tail uint16 }
+type ArrayRecord struct { Items [2]Packet; Last byte }
+type Blank struct { First byte; _ [3]byte; Word uintptr }
+type Empty struct {}
+type EmptyTail struct { Word uint64; Tail [0]byte }
+type ZeroArray struct { Values [0]uint64; Last byte }
+type Embedded struct { Packet }
+type LiteralAlias = struct { Value uint32 }
+type Lanes struct { First float64; Middle complex128; Last float32 }
+type Generic[T any] struct { Value T }
+
+var Variable = 11
+
+func Holder() {
+	type Local struct { Value uint64 }
+	const LocalConstant = 9
+	var value Local
+	_ = value
+	_ = LocalConstant
+}
+`
+
+func TestGeneratedHeaderNativeSourceDeclarationAndLayoutRules(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, nativeHeaderRulesSource)
+			wanted := map[string]string{
+				"const_First": "1", "const_Second": "2", "const_Text": `"x y\n世界"`,
+				"const_Truth": "true", "const_Rune": "19990", "const_Negative": "-7",
+				"const_Huge": "1208925819614629174706176", "Empty__size": "0",
+				"const_IntegerFromFloat": "2",
+				"LiteralAlias__size":     "4", "LiteralAlias_Value": "0",
+			}
+			packetSize, nestedSize, bodyOffset, tailOffset := "16", "32", "8", "24"
+			arraySize, arrayLast, blankSize, wordOffset := "40", "32", "16", "8"
+			zeroTailSize, zeroArraySize := "16", "8"
+			lanesSize := "32"
+			if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+				packetSize, nestedSize, bodyOffset, tailOffset = "12", "20", "4", "16"
+				arraySize, arrayLast, blankSize, wordOffset = "28", "24", "8", "4"
+				zeroTailSize, zeroArraySize = "12", "4"
+				lanesSize = "28"
+			}
+			for _, name := range []string{"Packet", "Alias", "Defined"} {
+				wanted[name+"__size"], wanted[name+"_First"], wanted[name+"_Last"] = packetSize, "0", "8"
+			}
+			wanted["Nested__size"], wanted["Nested_Prefix"] = nestedSize, "0"
+			wanted["Nested_Body"], wanted["Nested_Tail"] = bodyOffset, tailOffset
+			wanted["ArrayRecord__size"], wanted["ArrayRecord_Items"], wanted["ArrayRecord_Last"] = arraySize, "0", arrayLast
+			wanted["Blank__size"], wanted["Blank_First"], wanted["Blank_Word"] = blankSize, "0", wordOffset
+			wanted["EmptyTail__size"], wanted["EmptyTail_Word"], wanted["EmptyTail_Tail"] = zeroTailSize, "0", "8"
+			wanted["ZeroArray__size"], wanted["ZeroArray_Values"], wanted["ZeroArray_Last"] = zeroArraySize, "0", "0"
+			wanted["Embedded__size"], wanted["Embedded_Packet"] = packetSize, "0"
+			wanted["Lanes__size"], wanted["Lanes_First"], wanted["Lanes_Middle"], wanted["Lanes_Last"] = lanesSize, "0", "8", "24"
+			if !reflect.DeepEqual(actual, wanted) {
+				t.Fatalf("native compiler declaration/layout contract changed:\nactual=%v\nwanted=%v", actual, wanted)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderNativeLayoutIsNotPublicTypeModelAuthority(t *testing.T) {
+	const source = "package header\ntype Packet struct { First uint64; Last byte }\ntype EmptyTail struct { Word uint64; Tail [0]byte }\n"
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRules(t, target, source)
+			files := token.NewFileSet()
+			file, err := parser.ParseFile(files, "header.go", source, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, arch, _ := strings.Cut(target, "/")
+			sizes := types.SizesFor("gc", arch)
+			if sizes == nil {
+				t.Fatalf("missing actual framework size model for %s", arch)
+			}
+			pkg, err := (&types.Config{Sizes: sizes, GoVersion: "go1.20"}).Check("example.invalid/header", files, []*ast.File{file}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"Packet", "EmptyTail"} {
+				model := sizes.Sizeof(pkg.Scope().Lookup(name).Type())
+				t.Logf("NATIVE_HEADER_PUBLIC_MODEL target=%s type=%s compiler=%s public_model=%d equal=%t",
+					target, name, actual[name+"__size"], model, actual[name+"__size"] == fmt.Sprint(model))
+			}
+			// Native expectations are independent of the SDK running this test.
+			// Go 1.20 StdSizes returns 9/8 on both target widths, unlike gc.
+			wanted := "16"
+			if arch == "386" || arch == "arm" {
+				wanted = "12"
+			}
+			if actual["Packet__size"] != wanted || actual["EmptyTail__size"] != wanted {
+				t.Fatalf("native trailing/zero-tail padding changed: %v", actual)
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderNativeBuiltinImportPropertiesMatchSourceReplay(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		source string
+		want64 map[string]string
+		want32 map[string]string
+	}{
+		{
+			name:   "unsafe_import_constant",
+			source: "package header\nimport \"unsafe\"\nconst Word = unsafe.Sizeof(uintptr(0))\n",
+			want64: map[string]string{"const_Word": "8"},
+			want32: map[string]string{"const_Word": "4"},
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+				t.Run(target, func(t *testing.T) {
+					wanted := test.want64
+					if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+						wanted = test.want32
+					}
+					actual := compileNativeHeaderRules(t, target, test.source)
+					if !reflect.DeepEqual(actual, wanted) {
+						t.Fatalf("unclosed-source native observation changed: actual=%v wanted=%v", actual, wanted)
+					}
+					replayed, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20",
+						map[string]string{"header.go": test.source}, map[string]string{"unsafe": "unsafe"})
+					if err != nil || !reflect.DeepEqual(actual, replayed) {
+						t.Fatalf("actual builtin-import header differs from original property replay: actual=%v replay=%v error=%v",
+							actual, replayed, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGeneratedHeaderNativeDefinitionsFollowOriginalSourceChanges(t *testing.T) {
+	const original = "package header\nconst Value = 7\ntype Record struct { Value uint64 }\n"
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			before := compileNativeHeaderRules(t, target, original)
+			for _, test := range []struct {
+				name   string
+				source string
+			}{
+				{"constant_value", strings.Replace(original, "Value = 7", "Value = 8", 1)},
+				{"field_offset", strings.Replace(original, "{ Value uint64 }", "{ Prefix uint64; Value uint64 }", 1)},
+				{"definition_presence", "package header\nconst Value = 7\n"},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					after := compileNativeHeaderRules(t, target, test.source)
+					if reflect.DeepEqual(before, after) || HeaderDefinitionSHA256(before) == HeaderDefinitionSHA256(after) {
+						t.Fatal("actual native header did not retain changed complete original declarations")
+					}
+				})
+			}
+		})
+	}
+}
+
+func compileNativeHeaderRules(t *testing.T, target, source string) map[string]string {
+	t.Helper()
+	return compileNativeHeaderRulesWithImports(t, target, source, nil)
+}
+
+func compileNativeHeaderRulesWithImports(t *testing.T, target, source string, dependencies map[string]string) map[string]string {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err = filepath.Abs(goBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	goos, goarch, ok := strings.Cut(target, "/")
+	if !ok {
+		t.Fatal("invalid native compiler target")
+	}
+	env := replaceEnv(os.Environ(), map[string]string{
+		"GOOS": goos, "GOARCH": goarch, "CGO_ENABLED": "0", "GOTOOLCHAIN": "local",
+		"GOENV": "off", "GOWORK": "off", "GOFLAGS": "", "GOEXPERIMENT": "",
+	})
+	directory := t.TempDir()
+	stdout, stderr, err := RunBounded(ctx, directory, env, goBinary, "env", "-json", "GOROOT", "GOVERSION", "GOTOOLDIR", "GOHOSTOS", "GOENV")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual SDK env: %v\n%s\n%s", err, stdout, stderr)
+	}
+	var sdk struct{ GOROOT, GOVERSION, GOTOOLDIR, GOHOSTOS, GOENV string }
+	if err := json.Unmarshal(stdout, &sdk); err != nil || sdk.GOROOT == "" || sdk.GOTOOLDIR == "" || sdk.GOENV != "" {
+		t.Fatalf("incomplete selected SDK identity: %+v %v", sdk, err)
+	}
+	extension := ""
+	if sdk.GOHOSTOS == "windows" {
+		extension = ".exe"
+	}
+	actualDriver, err := filepath.EvalSymlinks(goBinary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expectedDriver, err := filepath.EvalSymlinks(filepath.Join(sdk.GOROOT, "bin", "go"+extension))
+	if err != nil || actualDriver != expectedDriver {
+		t.Fatalf("selected driver differs from its actual SDK: %s %s %v", actualDriver, expectedDriver, err)
+	}
+	compiler := filepath.Join(sdk.GOTOOLDIR, "compile"+extension)
+	inputs := []string{actualDriver, compiler}
+	digests := make(map[string][32]byte)
+	for _, input := range inputs {
+		data, err := os.ReadFile(input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		digests[input] = sha256.Sum256(data)
+	}
+	goFile, header, object := filepath.Join(directory, "header.go"), filepath.Join(directory, "go_asm.h"), filepath.Join(directory, "go.o")
+	if err := os.WriteFile(goFile, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	args := []string{"tool", "compile", "-p", "example.invalid/header", "-lang", "go1.20", "-asmhdr", header, "-o", object, goFile}
+	if len(dependencies) != 0 {
+		var names []string
+		for name := range dependencies {
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		var importConfig strings.Builder
+		for index, name := range names {
+			original := []byte(dependencies[name])
+			file := filepath.Join(directory, fmt.Sprintf("dependency-%d.go", index))
+			export := filepath.Join(directory, fmt.Sprintf("dependency-%d.a", index))
+			if err := os.WriteFile(file, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			stdout, stderr, err := RunBounded(ctx, directory, env, goBinary,
+				"tool", "compile", "-p", name, "-lang", "go1.20", "-o", export, file)
+			if err != nil || len(stdout) != 0 || len(stderr) != 0 {
+				t.Fatalf("actual original dependency compiler %s: %v\n%s\n%s", target, err, stdout, stderr)
+			}
+			bytes, err := os.ReadFile(export)
+			if err != nil || len(bytes) == 0 {
+				t.Fatalf("actual original dependency emitted no export: %v", err)
+			}
+			digests[file], digests[export] = sha256.Sum256(original), sha256.Sum256(bytes)
+			inputs = append(inputs, file, export)
+			fmt.Fprintf(&importConfig, "packagefile %s=%s\n", name, export)
+		}
+		config := filepath.Join(directory, "importcfg")
+		bytes := []byte(importConfig.String())
+		if err := os.WriteFile(config, bytes, 0600); err != nil {
+			t.Fatal(err)
+		}
+		digests[config] = sha256.Sum256(bytes)
+		inputs = append(inputs, config)
+		args = append(args[:len(args)-1], "-importcfg", config, goFile)
+	}
+	stdout, stderr, err = RunBounded(ctx, directory, env, goBinary, args...)
+	if err != nil || len(stdout) != 0 || len(stderr) != 0 {
+		t.Fatalf("actual native compiler %s: %v\n%s\n%s", target, err, stdout, stderr)
+	}
+	for _, input := range append(inputs, goFile) {
+		data, err := os.ReadFile(input)
+		if err != nil {
+			t.Fatal(err)
+		}
+		wanted := digests[input]
+		if input == goFile {
+			wanted = sha256.Sum256([]byte(source))
+		}
+		if sha256.Sum256(data) != wanted {
+			t.Fatalf("actual compiler input changed: %s", input)
+		}
+	}
+	headerBytes, err := os.ReadFile(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	objectBytes, err := os.ReadFile(object)
+	if err != nil || len(objectBytes) == 0 {
+		t.Fatalf("actual native compiler emitted no object: %v", err)
+	}
+	definitions, err := HeaderDefinitions(headerBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("NATIVE_HEADER_RULE_OBJECT sdk=%s target=%s source_sha=%x compile_sha=%x header_sha=%x object_sha=%x definitions=%d",
+		sdk.GOVERSION, target, sha256.Sum256([]byte(source)), digests[compiler], sha256.Sum256(headerBytes), sha256.Sum256(objectBytes), len(definitions))
+	return definitions
+}
diff --git a/gotoolprofile/generated_header_test.go b/gotoolprofile/generated_header_test.go
new file mode 100644
index 000000000..3318ab0f9
--- /dev/null
+++ b/gotoolprofile/generated_header_test.go
@@ -0,0 +1,69 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGeneratedHeaderDefinitionsPreserveValuesAndPresence(t *testing.T) {
+	header := []byte("// generated by compiler\n#define const_String \"x y\\n\"\n#define const_Huge 123456789012345678901234567890\n#define Layout__size 48\n")
+	defs, err := HeaderDefinitions(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string]string{"const_String": `"x y\n"`, "const_Huge": "123456789012345678901234567890", "Layout__size": "48"}
+	if !reflect.DeepEqual(defs, wanted) {
+		t.Fatalf("complete definitions = %v, want %v", defs, wanted)
+	}
+	reordered, err := HeaderDefinitions([]byte("// a different formatter\n#define Layout__size\t48\n#define const_Huge 123456789012345678901234567890\n#define const_String \"x y\\n\"\n"))
+	if err != nil || HeaderDefinitionSHA256(defs) != HeaderDefinitionSHA256(reordered) {
+		t.Fatalf("format-only difference changed canonical definitions: %v", err)
+	}
+	for _, changed := range []map[string]string{
+		{"const_String": `"x y\n"`, "const_Huge": "123456789012345678901234567890"},
+		{"const_String": `"x y\n"`, "const_Huge": "123456789012345678901234567890", "Layout__size": "49"},
+		{"const_String": `"x y\n"`, "const_Huge": "123456789012345678901234567890", "Layout__size": "48", "const_Fraction": "1.25"},
+	} {
+		if HeaderDefinitionSHA256(defs) == HeaderDefinitionSHA256(changed) {
+			t.Fatal("value, omission or additional presence was ignored")
+		}
+	}
+	if HeaderDefinitionSHA256(nil) != HeaderDefinitionSHA256(map[string]string{}) {
+		t.Fatal("an empty definition map did not survive JSON omitempty normalization")
+	}
+}
+
+func TestGeneratedHeaderDefinitionsRejectUnsupportedAndAmbiguousInput(t *testing.T) {
+	for _, source := range []string{
+		"#define DUP 1\n#define DUP 1\n", "#define FUNC(x) x\n", "#define EMPTY\n",
+		"#include \"fake.h\"\n", "#ifdef MISSING\n#endif\n", "TEXT Fake(SB),$0-0\n",
+		"#define BAD-NAME 1\n", "#define X 1\\\n+2\n", "/* hidden */\n", "#define X 1\x00\n",
+	} {
+		t.Run(strings.ReplaceAll(source, "\n", "_"), func(t *testing.T) {
+			if _, err := HeaderDefinitions([]byte(source)); err == nil {
+				t.Fatal("unrecognized compiler header syntax was silently accepted")
+			}
+		})
+	}
+}
+
+func TestCanonicalGeneratedHeaderRetainsExactFullDefinitions(t *testing.T) {
+	definitions := map[string]string{"Layout__size": "48", "const_String": `"x y\n"`, "const_Huge": "123456789012345678901234567890"}
+	data, err := CanonicalGeneratedHeader(definitions)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := HeaderDefinitions(data)
+	if err != nil || !reflect.DeepEqual(actual, definitions) {
+		t.Fatalf("canonical effective header changed values/presence: %s: %v", data, err)
+	}
+	if _, err := CanonicalGeneratedHeader(nil); err == nil {
+		t.Fatal("missing definitions became an empty generated input")
+	}
+	for _, bad := range []map[string]string{{"Bad-Name": "1"}, {"NAME": ""}, {"NAME": "1\n#define OTHER 2"}, {"NAME": "1\\"}} {
+		if _, err := CanonicalGeneratedHeader(bad); err == nil {
+			t.Fatal("noncanonical definitions became generated source bytes")
+		}
+	}
+}
diff --git a/gotoolprofile/helpers.go b/gotoolprofile/helpers.go
new file mode 100644
index 000000000..4bb0c9fee
--- /dev/null
+++ b/gotoolprofile/helpers.go
@@ -0,0 +1,106 @@
+package gotoolprofile
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+)
+
+// Runner keeps bounded stdout/stderr and child-process lifetime ownership at
+// the application boundary. Capture does not execute package initialization.
+type Runner func(context.Context, string, []string, string, ...string) ([]byte, []byte, error)
+
+var discoverySHA256Pattern = regexp.MustCompile("^[0-9a-f]{64}$")
+
+func replaceEnv(base []string, replacements map[string]string) []string {
+	var result []string
+	for _, item := range base {
+		key, _, _ := strings.Cut(item, "=")
+		if _, replace := replacements[key]; !replace {
+			result = append(result, item)
+		}
+	}
+	var keys []string
+	for key := range replacements {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	for _, key := range keys {
+		result = append(result, key+"="+replacements[key])
+	}
+	return result
+}
+
+func uniqueSortedDiscoveryStrings(values []string) []string {
+	set := make(map[string]bool)
+	for _, value := range values {
+		set[value] = true
+	}
+	result := make([]string, 0, len(set))
+	for value := range set {
+		result = append(result, value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func equalDiscoveryStrings(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for index := range a {
+		if a[index] != b[index] {
+			return false
+		}
+	}
+	return true
+}
+
+func validateTarget(target string) error {
+	parts := strings.Split(target, "/")
+	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
+		return fmt.Errorf("invalid target %q", target)
+	}
+	switch parts[1] {
+	case "386", "amd64", "arm", "arm64", "wasm":
+		return nil
+	default:
+		return fmt.Errorf("target %q uses unsupported Plan 9 architecture", target)
+	}
+}
+
+func discoveryModeledCPUFeatures(tags []string, arch, value string, minor int) []string {
+	var modeled []string
+	for _, tag := range tags {
+		if !strings.HasPrefix(tag, arch+".") {
+			modeled = append(modeled, tag)
+		}
+	}
+	level := strings.Split(value, ",")[0]
+	for _, candidate := range discoveryCPUFeatureCandidates() {
+		if !strings.HasPrefix(candidate, arch+".") {
+			continue
+		}
+		selected := candidate == arch+"."+level
+		switch arch {
+		case "amd64", "arm":
+			selected = candidate <= arch+"."+level
+		case "arm64":
+			selected = value != "" && (candidate <= "arm64."+level && strings.HasPrefix(candidate, "arm64."+level[:2]))
+			if strings.HasPrefix(level, "v9.") && strings.HasPrefix(candidate, "arm64.v8.") {
+				selected = int(candidate[len(candidate)-1]-'0') <= int(level[len(level)-1]-'0')+5
+			}
+		case "wasm":
+			// Go 1.26's gogoarchTags registers both unconditionally, even
+			// when go env GOWASM is empty. The source/actual-marker proof
+			// remains independent of this versioned expectation.
+			selected = minor >= 26 || containsTargetFeature(strings.Split(value, ","), strings.TrimPrefix(candidate, "wasm."))
+		}
+		if selected {
+			modeled = append(modeled, candidate)
+		}
+	}
+	return uniqueSortedDiscoveryStrings(modeled)
+}
diff --git a/gotoolprofile/helpers_test.go b/gotoolprofile/helpers_test.go
new file mode 100644
index 000000000..68b1cd69b
--- /dev/null
+++ b/gotoolprofile/helpers_test.go
@@ -0,0 +1,26 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestModeledWASMFeaturesMatchVersionedRegistration(t *testing.T) {
+	for minor := 20; minor <= 27; minor++ {
+		for _, setting := range []string{"", "satconv", "signext", "satconv,signext", "signext,satconv"} {
+			t.Run(fmt.Sprintf("go1.%d/%s", minor, setting), func(t *testing.T) {
+				var expected []string
+				for _, feature := range []string{"satconv", "signext"} {
+					if minor >= 26 || strings.Contains(setting, feature) {
+						expected = append(expected, "wasm."+feature)
+					}
+				}
+				actual := discoveryModeledCPUFeatures(nil, "wasm", setting, minor)
+				if !equalDiscoveryStrings(actual, expected) {
+					t.Fatalf("GOWASM=%q: got %q, want %q", setting, actual, expected)
+				}
+			})
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation.go b/gotoolprofile/instrumentation.go
new file mode 100644
index 000000000..1d57d4c91
--- /dev/null
+++ b/gotoolprofile/instrumentation.go
@@ -0,0 +1,414 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+type InstrumentationMode string
+
+const (
+	InstrumentationRace InstrumentationMode = "race"
+	InstrumentationMSan InstrumentationMode = "msan"
+	InstrumentationASan InstrumentationMode = "asan"
+)
+
+// InstrumentationBuildFlags returns one driver mode, never a synthetic build
+// tag. These flags alone do not prove that compilation, CGO, a cross SDK, or
+// the sanitizer runtime is available for a target.
+func InstrumentationBuildFlags(mode InstrumentationMode) ([]string, error) {
+	switch mode {
+	case "race", "msan", "asan":
+		return []string{"-" + string(mode)}, nil
+	default:
+		return nil, fmt.Errorf("invalid or nonexclusive Go instrumentation mode %q", mode)
+	}
+}
+
+// InstrumentationSourceRules is an in-process registration capture. It is not
+// a portable source exclusion or a compiler consumer proof. Target rules are
+// derived from the actual platform source, not a caller-provided support table.
+// The full instrumentInit registration gates CGO, mutual exclusion, and PIE
+// semantics; any change to that registration fails closed.
+type InstrumentationSourceRules struct {
+	root, version string
+	sources       map[string]string
+	registration  map[string]string
+	targets       map[InstrumentationMode]map[string]bool
+}
+
+var instrumentationRuleSources = []string{
+	"VERSION", "src/internal/platform/supported.go", "src/cmd/go/internal/work/init.go",
+}
+
+// This is the normalized token fingerprint of the complete instrumentInit
+// function, not a selected condition or a reported Supported field. The Go
+// 1.20 and 1.27 actual-source oracles verify the same audited registration.
+const instrumentationInitRegistration = "d1a0e667707a7a0016ce864f7ace726eed14227d666385fcb7aa6bc7beb3c708"
+
+const instrumentationRegistrationByteLimit = 2 << 20
+
+func CaptureInstrumentationSourceRules(root, version string) (*InstrumentationSourceRules, error) {
+	minor, err := goMinor(version)
+	if err != nil || minor < 20 || minor > 27 || !filepath.IsAbs(root) {
+		return nil, fmt.Errorf("instrumentation registration requires an absolute Go 1.20–1.27 source root")
+	}
+	contents := make(map[string][]byte)
+	for _, name := range instrumentationRuleSources {
+		data, err := readInstrumentationRegistration(filepath.Join(root, filepath.FromSlash(name)))
+		if err != nil {
+			return nil, fmt.Errorf("instrumentation source %s: %w", name, err)
+		}
+		contents[name] = data
+	}
+	return replayInstrumentationRuleSources(root, version, contents)
+}
+
+// A portable replay has no physical root and cannot satisfy Recheck. Both
+// paths parse exactly the same complete registrations from original bytes.
+func replayInstrumentationRuleSources(root, version string, contents map[string][]byte) (*InstrumentationSourceRules, error) {
+	return instrumentationRulesMemo.replay(root, version, contents)
+}
+
+func parseInstrumentationRuleSources(root, version string, contents map[string][]byte) (*InstrumentationSourceRules, error) {
+	rules := &InstrumentationSourceRules{
+		root: root, version: version, sources: make(map[string]string),
+		registration: make(map[string]string), targets: make(map[InstrumentationMode]map[string]bool),
+	}
+	for _, name := range instrumentationRuleSources {
+		rules.sources[name] = bytesSHA256(contents[name])
+	}
+	if strings.Split(strings.TrimSpace(string(contents["VERSION"])), "\n")[0] != version {
+		return nil, fmt.Errorf("instrumentation source VERSION differs from actual driver")
+	}
+	set := token.NewFileSet()
+	init, err := parser.ParseFile(set, "init.go", contents["src/cmd/go/internal/work/init.go"], 0)
+	if err != nil || init.Name.Name != "work" {
+		return nil, fmt.Errorf("invalid actual Go instrumentation driver registration")
+	}
+	function, err := discoveryAssemblerSourceFunction(init, "instrumentInit")
+	if err != nil {
+		return nil, err
+	}
+	fingerprint, err := ASTSHA(set, function)
+	if err != nil || fingerprint != instrumentationInitRegistration {
+		return nil, fmt.Errorf("unrecognized complete Go instrumentInit registration")
+	}
+	rules.registration["instrumentInit"] = fingerprint
+	for mode, name := range map[InstrumentationMode]string{"race": "RaceDetectorSupported", "msan": "MSanSupported", "asan": "ASanSupported"} {
+		data := contents["src/internal/platform/supported.go"]
+		targets, err := parseInstrumentationTargetRule(data, name)
+		if err != nil {
+			return nil, err
+		}
+		rules.targets[mode] = targets
+		set := token.NewFileSet()
+		platform, err := parser.ParseFile(set, "supported.go", data, 0)
+		if err != nil {
+			return nil, err
+		}
+		function, err := discoveryAssemblerSourceFunction(platform, name)
+		if err != nil {
+			return nil, err
+		}
+		rules.registration[name], err = ASTSHA(set, function)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return rules, nil
+}
+
+func readInstrumentationRegistration(name string) ([]byte, error) {
+	file, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	data, readErr := io.ReadAll(io.LimitReader(file, instrumentationRegistrationByteLimit+1))
+	closeErr := file.Close()
+	if readErr != nil || closeErr != nil {
+		return nil, errors.Join(readErr, closeErr)
+	}
+	if len(data) > instrumentationRegistrationByteLimit {
+		return nil, fmt.Errorf("instrumentation registration exceeds its byte bound")
+	}
+	return data, nil
+}
+
+func (rules *InstrumentationSourceRules) SourceHashes() map[string]string {
+	return copyInstrumentationHashes(rules.sources)
+}
+
+func (rules *InstrumentationSourceRules) RegistrationHashes() map[string]string {
+	return copyInstrumentationHashes(rules.registration)
+}
+
+func copyInstrumentationHashes(original map[string]string) map[string]string {
+	copy := make(map[string]string, len(original))
+	for key, value := range original {
+		copy[key] = value
+	}
+	return copy
+}
+
+func (rules *InstrumentationSourceRules) Recheck() error {
+	if rules == nil {
+		return fmt.Errorf("missing actual instrumentation source registration")
+	}
+	after, err := CaptureInstrumentationSourceRules(rules.root, rules.version)
+	if err != nil || !reflect.DeepEqual(rules, after) {
+		return fmt.Errorf("instrumentation source registration changed during consumption: %v", err)
+	}
+	return nil
+}
+
+func (rules *InstrumentationSourceRules) TargetSupported(target string, mode InstrumentationMode) (bool, error) {
+	if _, err := InstrumentationBuildFlags(mode); err != nil {
+		return false, err
+	}
+	if err := validateInstrumentationRuleTarget(target); err != nil {
+		return false, err
+	}
+	if rules == nil || rules.targets[mode] == nil || rules.registration["instrumentInit"] != instrumentationInitRegistration {
+		return false, fmt.Errorf("missing actual instrumentation target registration")
+	}
+	return rules.targets[mode][target], nil
+}
+
+func (rules *InstrumentationSourceRules) RequiresCGO(target string, mode InstrumentationMode) (bool, error) {
+	supported, err := rules.TargetSupported(target, mode)
+	if err != nil {
+		return false, err
+	}
+	if !supported {
+		return false, fmt.Errorf("no effective CGO requirement for a rejected instrumentation target")
+	}
+	return !strings.HasPrefix(target, "darwin/") || mode != "race", nil
+}
+
+func (rules *InstrumentationSourceRules) EffectiveBuildMode(target string, mode InstrumentationMode) (string, error) {
+	supported, err := rules.TargetSupported(target, mode)
+	if err != nil {
+		return "", err
+	}
+	if !supported {
+		return "", fmt.Errorf("no effective buildmode for a rejected instrumentation target")
+	}
+	if mode == "msan" && target != "linux/amd64" {
+		return "pie", nil
+	}
+	return "default", nil
+}
+
+type InstrumentationEarlyStatus string
+
+const (
+	// This is only an early target/flag gate. It is not export or object proof.
+	InstrumentationEarlyRuleAccepted         InstrumentationEarlyStatus = "early_target_rule_accepted"
+	InstrumentationOfficialTargetUnsupported InstrumentationEarlyStatus = "official_target_rule_unsupported"
+)
+
+// ClassifyInstrumentationEarlyResult accepts only an actual bounded driver
+// result paired with captured registration. It never classifies CGO, compiler,
+// SDK, timeout, malformed output, or additional errors as source inapplicability.
+// Production callers must separately bind the exact command, driver/version,
+// environment and original file/profile scope; this foundation is not such a
+// portable report, and accepted -find output is never a compilation claim.
+func ClassifyInstrumentationEarlyResult(rules *InstrumentationSourceRules, target string, mode InstrumentationMode, stdout, stderr []byte, commandErr error) (InstrumentationEarlyStatus, error) {
+	supported, err := rules.TargetSupported(target, mode)
+	if err != nil {
+		return "", err
+	}
+	if supported {
+		if commandErr != nil {
+			return "", fmt.Errorf("eligible instrumentation target driver failed: %w", commandErr)
+		}
+		// The zero-dependency early marker protocol has no registered
+		// informational stderr. Do not let successful JSON hide a warning,
+		// mixed error, or tool failure; a future allowance needs its own
+		// actual-driver observation and exact diagnostic registration.
+		if len(stderr) != 0 {
+			return "", fmt.Errorf("eligible instrumentation target emitted unregistered stderr")
+		}
+		var pkg struct {
+			Dir, ImportPath string
+			GoFiles         []string
+			Error           *struct{ Err string }
+		}
+		if err := json.Unmarshal(stdout, &pkg); err != nil || pkg.Dir == "" || pkg.ImportPath == "" || len(pkg.GoFiles) == 0 || pkg.Error != nil {
+			return "", fmt.Errorf("eligible instrumentation target omitted actual package selection")
+		}
+		return InstrumentationEarlyRuleAccepted, nil
+	}
+	wanted := "-" + string(mode) + " is not supported on " + target + "\n"
+	if len(stdout) != 0 || string(stderr) != wanted || !instrumentationActualExitTwo(commandErr) {
+		return "", fmt.Errorf("actual driver did not give the unique registered instrumentation target rejection")
+	}
+	return InstrumentationOfficialTargetUnsupported, nil
+}
+
+func instrumentationActualExitTwo(err error) bool {
+	for err != nil {
+		if exit, ok := err.(*exec.ExitError); ok {
+			return exit.ExitCode() == 2
+		}
+		// A joined error can carry a timeout, overflow, or resource failure.
+		// Do not extract a convenient ExitError from that mixed result.
+		wrapped, ok := err.(interface{ Unwrap() error })
+		if !ok {
+			return false
+		}
+		err = wrapped.Unwrap()
+	}
+	return false
+}
+
+func validateInstrumentationRuleTarget(target string) error {
+	parts := strings.Split(target, "/")
+	if len(parts) != 2 || !instrumentationTargetToken(parts[0]) || !instrumentationTargetToken(parts[1]) {
+		return fmt.Errorf("invalid instrumentation target %q", target)
+	}
+	return validateTarget(target)
+}
+
+func instrumentationTargetToken(value string) bool {
+	if value == "" {
+		return false
+	}
+	for _, char := range value {
+		if !(char >= 'a' && char <= 'z' || char >= '0' && char <= '9') {
+			return false
+		}
+	}
+	return true
+}
+
+func parseInstrumentationTargetRule(data []byte, name string) (map[string]bool, error) {
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "supported.go", data, 0)
+	if err != nil || file.Name.Name != "platform" {
+		return nil, fmt.Errorf("invalid instrumentation platform registration")
+	}
+	function, err := discoveryAssemblerSourceFunction(file, name)
+	if err != nil {
+		return nil, err
+	}
+	if function.Type.TypeParams != nil || function.Type.Params == nil || len(function.Type.Params.List) != 1 ||
+		len(function.Type.Params.List[0].Names) != 2 || function.Type.Params.List[0].Names[0].Name != "goos" || function.Type.Params.List[0].Names[1].Name != "goarch" ||
+		!instrumentationIdent(function.Type.Params.List[0].Type, "string") || function.Type.Results == nil || len(function.Type.Results.List) != 1 ||
+		len(function.Type.Results.List[0].Names) != 0 || !instrumentationIdent(function.Type.Results.List[0].Type, "bool") || len(function.Body.List) != 1 {
+		return nil, fmt.Errorf("unrecognized complete instrumentation platform function %s", name)
+	}
+	switchRule, ok := function.Body.List[0].(*ast.SwitchStmt)
+	if !ok || switchRule.Init != nil || !instrumentationIdent(switchRule.Tag, "goos") {
+		return nil, fmt.Errorf("unrecognized instrumentation platform switch %s", name)
+	}
+	targets, seenOS := make(map[string]bool), make(map[string]bool)
+	defaultSeen := false
+	for _, statement := range switchRule.Body.List {
+		clause, ok := statement.(*ast.CaseClause)
+		if !ok || len(clause.Body) != 1 {
+			return nil, fmt.Errorf("unrecognized instrumentation platform case %s", name)
+		}
+		result, ok := clause.Body[0].(*ast.ReturnStmt)
+		if !ok || len(result.Results) != 1 {
+			return nil, fmt.Errorf("incomplete instrumentation platform return %s", name)
+		}
+		if len(clause.List) == 0 {
+			if defaultSeen || !instrumentationIdent(result.Results[0], "false") {
+				return nil, fmt.Errorf("unknown instrumentation platform default %s", name)
+			}
+			defaultSeen = true
+			continue
+		}
+		arches, err := instrumentationArchAlternatives(result.Results[0])
+		if err != nil {
+			return nil, err
+		}
+		for _, item := range clause.List {
+			goos, err := instrumentationString(item)
+			if err != nil || seenOS[goos] {
+				return nil, fmt.Errorf("unknown or duplicate instrumentation platform OS")
+			}
+			seenOS[goos] = true
+			for _, arch := range arches {
+				targets[goos+"/"+arch] = true
+			}
+		}
+	}
+	if !defaultSeen || len(targets) == 0 {
+		return nil, fmt.Errorf("incomplete instrumentation platform target rule %s", name)
+	}
+	return targets, nil
+}
+
+func instrumentationArchAlternatives(expression ast.Expr) ([]string, error) {
+	if paren, ok := expression.(*ast.ParenExpr); ok {
+		return instrumentationArchAlternatives(paren.X)
+	}
+	binary, ok := expression.(*ast.BinaryExpr)
+	if !ok {
+		return nil, fmt.Errorf("unknown instrumentation architecture predicate")
+	}
+	if binary.Op == token.LOR {
+		left, err := instrumentationArchAlternatives(binary.X)
+		if err != nil {
+			return nil, err
+		}
+		right, err := instrumentationArchAlternatives(binary.Y)
+		if err != nil {
+			return nil, err
+		}
+		for _, a := range left {
+			for _, b := range right {
+				if a == b {
+					return nil, fmt.Errorf("duplicate instrumentation architecture predicate")
+				}
+			}
+		}
+		return append(left, right...), nil
+	}
+	if binary.Op != token.EQL {
+		return nil, fmt.Errorf("unknown instrumentation architecture comparison")
+	}
+	value := binary.Y
+	if !instrumentationIdent(binary.X, "goarch") {
+		if !instrumentationIdent(binary.Y, "goarch") {
+			return nil, fmt.Errorf("unknown instrumentation architecture input")
+		}
+		value = binary.X
+	}
+	arch, err := instrumentationString(value)
+	if err != nil {
+		return nil, err
+	}
+	return []string{arch}, nil
+}
+
+func instrumentationIdent(expression ast.Expr, name string) bool {
+	ident, ok := expression.(*ast.Ident)
+	return ok && ident.Name == name
+}
+
+func instrumentationString(expression ast.Expr) (string, error) {
+	literal, ok := expression.(*ast.BasicLit)
+	if !ok || literal.Kind != token.STRING {
+		return "", fmt.Errorf("unknown instrumentation target literal")
+	}
+	value, err := strconv.Unquote(literal.Value)
+	if err != nil || !instrumentationTargetToken(value) {
+		return "", fmt.Errorf("invalid instrumentation target literal")
+	}
+	return value, nil
+}
diff --git a/gotoolprofile/instrumentation_artifacts.go b/gotoolprofile/instrumentation_artifacts.go
new file mode 100644
index 000000000..e71af48b8
--- /dev/null
+++ b/gotoolprofile/instrumentation_artifacts.go
@@ -0,0 +1,177 @@
+package gotoolprofile
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const (
+	InstrumentationArtifactProtocol  = "actual_go_instrumentation_generated_artifacts_v1"
+	InstrumentationIRByteLimit       = int64(256 << 20)
+	InstrumentationObjectByteLimit   = int64(64 << 20)
+	InstrumentationArtifactByteLimit = int64(1 << 30)
+)
+
+// Generated LLVM outputs have their own defensive budgets. They are not CPP,
+// Go or authenticated module sources; these observations supply no source role
+// or object credit without the independent complete consumption proof.
+type InstrumentationLLVMArtifact struct {
+	Role   string `json:"role"`
+	Name   string `json:"name"`
+	Bytes  int64  `json:"bytes"`
+	SHA256 string `json:"sha256"`
+}
+
+type InstrumentationLLVMArtifacts struct {
+	Protocol string                      `json:"protocol"`
+	IR       InstrumentationLLVMArtifact `json:"ir"`
+	Object   InstrumentationLLVMArtifact `json:"object"`
+}
+
+// One budget belongs to one invocation, not one file. Its private counters
+// prevent repeated ordinals and overflow; it never grants source permissions.
+type InstrumentationLLVMArtifactBudget struct {
+	bytes   int64
+	ordinal int
+}
+
+func instrumentationArtifactNames(index int) (string, string) {
+	stem := fmt.Sprintf("instrumented-%04d", index)
+	return stem + ".ll", stem + ".o"
+}
+
+func (budget *InstrumentationLLVMArtifactBudget) check(index int, ir, object int64) error {
+	if budget == nil || budget.bytes < 0 || budget.bytes > InstrumentationArtifactByteLimit ||
+		budget.ordinal < 0 || index != budget.ordinal || ir <= 0 || ir > InstrumentationIRByteLimit ||
+		object <= 0 || object > InstrumentationObjectByteLimit {
+		return fmt.Errorf("generated LLVM artifact role, ordinal or individual byte bound is invalid")
+	}
+	remaining := InstrumentationArtifactByteLimit - budget.bytes
+	if ir > remaining || object > remaining-ir {
+		return fmt.Errorf("generated LLVM artifacts exceed the shared invocation byte bound")
+	}
+	return nil
+}
+
+// ValidateInstrumentationLLVMArtifacts replays only the generated-output
+// observation. The enclosing validator still proves actual Go/CPP/types,
+// LLVM22 compilation, selected-file coverage and the independently bound output.
+func ValidateInstrumentationLLVMArtifacts(index int, output OutputProof, proof *InstrumentationLLVMArtifacts, budget *InstrumentationLLVMArtifactBudget) error {
+	ir, object := instrumentationArtifactNames(index)
+	if proof == nil || proof.Protocol != InstrumentationArtifactProtocol || output.Part != ir ||
+		proof.IR.Role != "llvm_ir" || proof.IR.Name != ir || proof.Object.Role != "llvm_object" || proof.Object.Name != object ||
+		!discoverySHA256Pattern.MatchString(proof.IR.SHA256) || !discoverySHA256Pattern.MatchString(proof.Object.SHA256) ||
+		proof.IR.SHA256 != output.IR || proof.Object.SHA256 != output.Object {
+		return fmt.Errorf("generated LLVM artifacts lack their exact role/output identity")
+	}
+	if err := budget.check(index, proof.IR.Bytes, proof.Object.Bytes); err != nil {
+		return err
+	}
+	budget.bytes += proof.IR.Bytes + proof.Object.Bytes
+	budget.ordinal++
+	return nil
+}
+
+// CaptureInstrumentationLLVMArtifacts uses canonical regular files and a
+// bounded streaming digest. No LLVM text/object is read into a source buffer.
+// The directory, open inode, size and origin are rechecked after each read.
+func CaptureInstrumentationLLVMArtifacts(root string, index int, budget *InstrumentationLLVMArtifactBudget) (*InstrumentationLLVMArtifacts, error) {
+	if budget == nil || index < 0 || budget.ordinal != index || !filepath.IsAbs(root) {
+		return nil, fmt.Errorf("generated LLVM artifacts lack a canonical invocation origin/ordinal")
+	}
+	physicalRoot, err := sourcepath.Resolve(root)
+	if err != nil {
+		return nil, err
+	}
+	rootInfo, err := sourcepath.Lstat(physicalRoot)
+	if err != nil || !rootInfo.IsDir() {
+		return nil, fmt.Errorf("generated LLVM artifact origin is not an actual directory: %v", err)
+	}
+	ir, object := instrumentationArtifactNames(index)
+	irInfo, err := instrumentationLLVMArtifactInfo(physicalRoot, ir, "llvm_ir", InstrumentationIRByteLimit)
+	if err != nil {
+		return nil, err
+	}
+	objectInfo, err := instrumentationLLVMArtifactInfo(physicalRoot, object, "llvm_object", InstrumentationObjectByteLimit)
+	if err != nil {
+		return nil, err
+	}
+	// Reserve the whole invocation envelope before opening or hashing either
+	// file. The completed observations must fit that same envelope again.
+	if err := budget.check(index, irInfo.Size(), objectInfo.Size()); err != nil {
+		return nil, err
+	}
+	proof := &InstrumentationLLVMArtifacts{Protocol: InstrumentationArtifactProtocol}
+	proof.IR, err = captureInstrumentationLLVMArtifact(physicalRoot, ir, "llvm_ir", InstrumentationIRByteLimit, irInfo)
+	if err != nil {
+		return nil, err
+	}
+	proof.Object, err = captureInstrumentationLLVMArtifact(physicalRoot, object, "llvm_object", InstrumentationObjectByteLimit, objectInfo)
+	if err != nil {
+		return nil, err
+	}
+	afterRoot, err := sourcepath.Resolve(root)
+	if err != nil || afterRoot != physicalRoot {
+		return nil, fmt.Errorf("generated LLVM artifact origin changed during readback: %v", err)
+	}
+	afterInfo, err := os.Stat(physicalRoot)
+	if err != nil || !os.SameFile(rootInfo, afterInfo) {
+		return nil, fmt.Errorf("generated LLVM artifact directory was replaced: %v", err)
+	}
+	output := OutputProof{Part: ir, IR: proof.IR.SHA256, Object: proof.Object.SHA256}
+	if err := ValidateInstrumentationLLVMArtifacts(index, output, proof, budget); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func captureInstrumentationLLVMArtifact(root, name, role string, limit int64, reserved os.FileInfo) (result InstrumentationLLVMArtifact, resultErr error) {
+	path := filepath.Join(root, name)
+	before, err := instrumentationLLVMArtifactInfo(root, name, role, limit)
+	if err != nil {
+		return result, err
+	}
+	if reserved == nil || !os.SameFile(reserved, before) || before.Size() != reserved.Size() || !before.ModTime().Equal(reserved.ModTime()) {
+		return result, fmt.Errorf("generated LLVM artifact changed after its budget reservation: %s", name)
+	}
+	file, err := os.Open(path)
+	if err != nil {
+		return result, err
+	}
+	defer func() { resultErr = errors.Join(resultErr, file.Close()) }()
+	opened, err := file.Stat()
+	if err != nil || !os.SameFile(before, opened) || opened.Size() != before.Size() || !opened.Mode().IsRegular() {
+		return result, fmt.Errorf("generated LLVM artifact open identity changed: %s: %v", name, err)
+	}
+	digest := sha256.New()
+	count, err := io.Copy(digest, io.LimitReader(file, before.Size()+1))
+	if err != nil || count != before.Size() {
+		return result, fmt.Errorf("generated LLVM artifact changed or exceeded its streaming bound: %s: %v", name, err)
+	}
+	after, err := os.Lstat(path)
+	resolved, resolveErr := sourcepath.Resolve(path)
+	if err != nil || resolveErr != nil || resolved != path || !os.SameFile(before, after) ||
+		after.Size() != before.Size() || !after.ModTime().Equal(before.ModTime()) || !after.Mode().IsRegular() {
+		return result, fmt.Errorf("generated LLVM artifact was replaced or changed: %s: %v", name, errors.Join(err, resolveErr))
+	}
+	return InstrumentationLLVMArtifact{Role: role, Name: name, Bytes: count, SHA256: fmt.Sprintf("%x", digest.Sum(nil))}, nil
+}
+
+func instrumentationLLVMArtifactInfo(root, name, role string, limit int64) (os.FileInfo, error) {
+	path := filepath.Join(root, name)
+	resolved, err := sourcepath.Resolve(path)
+	if err != nil || resolved != path {
+		return nil, fmt.Errorf("generated LLVM artifact is missing or redirected: %s: %v", name, err)
+	}
+	info, err := sourcepath.Lstat(path)
+	if err != nil || !info.Mode().IsRegular() || info.Size() <= 0 || info.Size() > limit {
+		return nil, fmt.Errorf("generated %s must be a nonempty bounded regular artifact: %s: %v", role, name, err)
+	}
+	return info, nil
+}
diff --git a/gotoolprofile/instrumentation_artifacts_test.go b/gotoolprofile/instrumentation_artifacts_test.go
new file mode 100644
index 000000000..39c57733a
--- /dev/null
+++ b/gotoolprofile/instrumentation_artifacts_test.go
@@ -0,0 +1,148 @@
+package gotoolprofile
+
+import (
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func artifactTestObservation(index int, ir, object int64) (OutputProof, *InstrumentationLLVMArtifacts) {
+	irName, objectName := instrumentationArtifactNames(index)
+	digest := strings.Repeat("1", 64)
+	return OutputProof{Part: irName, IR: digest, Object: digest}, &InstrumentationLLVMArtifacts{
+		Protocol: InstrumentationArtifactProtocol,
+		IR:       InstrumentationLLVMArtifact{Role: "llvm_ir", Name: irName, Bytes: ir, SHA256: digest},
+		Object:   InstrumentationLLVMArtifact{Role: "llvm_object", Name: objectName, Bytes: object, SHA256: digest},
+	}
+}
+
+func TestInstrumentationArtifactSharedBudgetAndOverflow(t *testing.T) {
+	budget := &InstrumentationLLVMArtifactBudget{}
+	for index := 0; index < 3; index++ {
+		output, proof := artifactTestObservation(index, InstrumentationIRByteLimit, InstrumentationObjectByteLimit)
+		if err := ValidateInstrumentationLLVMArtifacts(index, output, proof, budget); err != nil {
+			t.Fatal(err)
+		}
+	}
+	output, proof := artifactTestObservation(3, 64<<20-1, 1)
+	if err := ValidateInstrumentationLLVMArtifacts(3, output, proof, budget); err != nil || budget.bytes != InstrumentationArtifactByteLimit {
+		t.Fatalf("exact shared bound: %v, %d", err, budget.bytes)
+	}
+	output, proof = artifactTestObservation(4, 1, 1)
+	if err := ValidateInstrumentationLLVMArtifacts(4, output, proof, budget); err == nil {
+		t.Fatal("a new file obtained a new invocation budget")
+	}
+	for _, used := range []int64{-1, math.MaxInt64} {
+		output, proof := artifactTestObservation(0, 1, 1)
+		if err := ValidateInstrumentationLLVMArtifacts(0, output, proof, &InstrumentationLLVMArtifactBudget{bytes: used}); err == nil {
+			t.Fatal("invalid/overflowed private counter accepted")
+		}
+	}
+}
+
+func TestInstrumentationArtifactRoleAndOrdinalTripwires(t *testing.T) {
+	for name, mutate := range map[string]func(*OutputProof, *InstrumentationLLVMArtifacts){
+		"old protocol":     func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.Protocol = "legacy" },
+		"deleted protocol": func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.Protocol = "" },
+		"source as IR":     func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.Role = "module_source" },
+		"source name":      func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.Name = "original.s" },
+		"swapped roles":    func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR, p.Object = p.Object, p.IR },
+		"empty hash":       func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.SHA256 = "" },
+		"changed hash":     func(o *OutputProof, _ *InstrumentationLLVMArtifacts) { o.IR = strings.Repeat("0", 64) },
+		"foreign object":   func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.Object.Name = "instrumented-0001.o" },
+		"escaped IR":       func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.Name = "../instrumented-0000.ll" },
+		"changed output":   func(o *OutputProof, _ *InstrumentationLLVMArtifacts) { o.Part = "instrumented-0001.ll" },
+		"IR over bound":    func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.Bytes = InstrumentationIRByteLimit + 1 },
+		"object over bound": func(_ *OutputProof, p *InstrumentationLLVMArtifacts) {
+			p.Object.Bytes = InstrumentationObjectByteLimit + 1
+		},
+		"negative bytes": func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.IR.Bytes = -1 },
+		"empty object":   func(_ *OutputProof, p *InstrumentationLLVMArtifacts) { p.Object.Bytes = 0 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			output, proof := artifactTestObservation(0, 1, 1)
+			mutate(&output, proof)
+			budget := &InstrumentationLLVMArtifactBudget{}
+			if err := ValidateInstrumentationLLVMArtifacts(0, output, proof, budget); err == nil || budget.bytes != 0 || budget.ordinal != 0 {
+				t.Fatal("invalid role mutated the budget or supplied evidence")
+			}
+		})
+	}
+	output, proof := artifactTestObservation(0, 1, 1)
+	budget := &InstrumentationLLVMArtifactBudget{}
+	if err := ValidateInstrumentationLLVMArtifacts(0, output, proof, budget); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateInstrumentationLLVMArtifacts(0, output, proof, budget); err == nil {
+		t.Fatal("duplicate ordinal accepted")
+	}
+	if err := ValidateInstrumentationLLVMArtifacts(0, output, nil, &InstrumentationLLVMArtifactBudget{}); err == nil {
+		t.Fatal("paired deletion accepted")
+	}
+	if err := ValidateInstrumentationLLVMArtifacts(0, output, proof, nil); err == nil {
+		t.Fatal("missing invocation budget accepted")
+	}
+}
+
+func TestInstrumentationArtifactPhysicalBoundsPrecedeStreaming(t *testing.T) {
+	for _, test := range []struct {
+		name       string
+		ir, object int64
+	}{
+		{"IR above its generated limit", InstrumentationIRByteLimit + 1, 1},
+		{"object above its generated limit", 1, InstrumentationObjectByteLimit + 1},
+		{"empty IR", 0, 1},
+		{"empty object", 1, 0},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			root := t.TempDir()
+			ir, object := instrumentationArtifactNames(0)
+			for name, size := range map[string]int64{ir: test.ir, object: test.object} {
+				file, err := os.OpenFile(filepath.Join(root, name), os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+				if err != nil {
+					t.Fatal(err)
+				}
+				truncateErr, closeErr := file.Truncate(size), file.Close()
+				if truncateErr != nil || closeErr != nil {
+					t.Fatalf("stat-only fixture: %v; %v", truncateErr, closeErr)
+				}
+			}
+			// Sparse invalid size fixtures establish pre-read refusal only;
+			// they are not valid LLVM or source/compiler certificates.
+			if _, err := CaptureInstrumentationLLVMArtifacts(root, 0, &InstrumentationLLVMArtifactBudget{}); err == nil ||
+				!strings.Contains(err.Error(), "must be a nonempty bounded regular artifact") {
+				t.Fatalf("unbounded/empty artifact did not reach its physical byte-bound rejection: %v", err)
+			}
+		})
+	}
+}
+
+func TestInstrumentationArtifactEqualByteReplacementLosesReservedIdentity(t *testing.T) {
+	// The private reservation helper requires a physical root; public capture
+	// resolves its caller's root before reserving any generated artifact.
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := "instrumented-0000.ll"
+	path := filepath.Join(root, name)
+	bytes := []byte("artifact inode fixture; no compiler/source claim\n")
+	if err := os.WriteFile(path, bytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	reserved, err := instrumentationLLVMArtifactInfo(root, name, "llvm_ir", InstrumentationIRByteLimit)
+	if err != nil {
+		t.Fatalf("regular artifact reservation at original root %q: %v", root, err)
+	}
+	if err := os.Rename(path, path+".retained"); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(path, bytes, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := captureInstrumentationLLVMArtifact(root, name, "llvm_ir", InstrumentationIRByteLimit, reserved); err == nil {
+		t.Fatal("equal bytes replaced the reserved physical file identity")
+	}
+}
diff --git a/gotoolprofile/instrumentation_asmdecl.go b/gotoolprofile/instrumentation_asmdecl.go
new file mode 100644
index 000000000..25afdcaec
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl.go
@@ -0,0 +1,285 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// go vet always resolves test packages, including with -tests=false: that
+// flag controls analyzers, not cmd/go's package loader. Use the registered
+// native vet tool's compilation-unit protocol instead. The unit is derived
+// independently from actual ordinary Go exports, never a filtered test unit.
+func instrumentationOrdinaryAsmdeclArgs() []string {
+	return []string{"tool", "vet", "-asmdecl", "ordinary.cfg"}
+}
+
+type instrumentationAsmdeclPackage struct {
+	Dir, ImportPath, Export          string
+	GoFiles, CompiledGoFiles, SFiles []string
+	Imports                          []string
+	ImportMap                        map[string]string
+	Standard, Incomplete             bool
+	Error                            json.RawMessage
+	DepsErrors                       []json.RawMessage
+	Module                           *instrumentationAsmdeclModule
+}
+
+type instrumentationAsmdeclModule struct {
+	Path, Version, Dir, GoMod, GoVersion string
+	Main                                 bool
+	Replace                              *instrumentationAsmdeclModule
+}
+
+// This is cmd/go's native vet configuration protocol. In particular, neither
+// VetxOnly nor SucceedOnTypecheckFailure may be set: type/declaration errors
+// must fail. A configuration is a query input, not an ABI or source capability.
+type instrumentationAsmdeclConfig struct {
+	ID, Compiler, Dir, ImportPath, GoVersion string
+	GoFiles, NonGoFiles                      []string
+	ImportMap, PackageFile                   map[string]string
+	Standard                                 map[string]bool
+	VetxOutput                               string
+}
+
+// RunInstrumentationOrdinaryAsmdecl checks only the independently selected
+// ordinary source role. Supplemental bodyless test declarations retain their
+// own actual test-export/typecheck consumer; they are not admitted here.
+// The caller must authenticate the original module, selection and exports
+// before supplying their expected identities and recheck its outer guards.
+func RunInstrumentationOrdinaryAsmdecl(ctx context.Context, binary, invocation string, env []string,
+	input *ConsumerInput, plan *InstrumentationOriginalPackagePlan, selected *PackageProof,
+	exports map[string]string, run Runner,
+) error {
+	return runInstrumentationOrdinaryAsmdecl(ctx, binary, invocation, env, input, plan, selected, exports, run, os.RemoveAll)
+}
+
+// The public producer always uses os.RemoveAll. This private per-call seam
+// makes cleanup-error propagation testable without a global hook or analyzer
+// failure, including when privileged root can remove mode-000 directories.
+func runInstrumentationOrdinaryAsmdecl(ctx context.Context, binary, invocation string, env []string,
+	input *ConsumerInput, plan *InstrumentationOriginalPackagePlan, selected *PackageProof,
+	exports map[string]string, run Runner, remove func(string) error,
+) (result error) {
+	env = replaceEnv(env, map[string]string{"GOENV": "off"})
+	if ctx == nil || ctx.Err() != nil || run == nil || remove == nil || input == nil || plan == nil || selected == nil ||
+		!filepath.IsAbs(binary) || !filepath.IsAbs(invocation) || len(exports) == 0 || len(exports) > 4096 ||
+		plan.PackagePath == "" || selected.PackagePath != plan.PackagePath {
+		return fmt.Errorf("ordinary asmdecl requires actual bounded source/export identities")
+	}
+	args := instrumentationOriginalCommand(plan, false)
+	args = append([]string{"list", "-deps"}, args[1:]...)
+	stdout, stderr, err := run(ctx, invocation, env, binary, args...)
+	if err != nil || len(stderr) != 0 || len(stdout) == 0 || len(stdout) > commandOutputLimit {
+		return fmt.Errorf("ordinary asmdecl export query failed (not source N/A): %v; %s", err, stderr)
+	}
+	config := instrumentationAsmdeclConfig{
+		ID: plan.PackagePath, Compiler: "gc", ImportPath: plan.PackagePath,
+		ImportMap: make(map[string]string), PackageFile: make(map[string]string), Standard: make(map[string]bool),
+	}
+	guards := &instrumentationTypeGraph{hashes: make(map[string]string), paths: make(map[string]string)}
+	seen := make(map[string]bool)
+	decoder := json.NewDecoder(bytes.NewReader(stdout))
+	var root *instrumentationAsmdeclPackage
+	for {
+		var pkg instrumentationAsmdeclPackage
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			return fmt.Errorf("actual ordinary asmdecl export JSON: %w", err)
+		}
+		if pkg.ImportPath == "" || seen[pkg.ImportPath] || len(seen) >= 4096 || pkg.Incomplete ||
+			len(pkg.Error) != 0 && string(pkg.Error) != "null" || len(pkg.DepsErrors) != 0 {
+			return fmt.Errorf("ordinary asmdecl export has duplicate, incomplete or failed package")
+		}
+		seen[pkg.ImportPath] = true
+		config.ImportMap[pkg.ImportPath] = pkg.ImportPath
+		config.Standard[pkg.ImportPath] = pkg.Standard
+		if pkg.ImportPath == "unsafe" {
+			continue
+		}
+		if !filepath.IsAbs(pkg.Export) || exports[pkg.ImportPath] == "" {
+			return fmt.Errorf("ordinary asmdecl export lacks independent identity: %s", pkg.ImportPath)
+		}
+		if err := guards.retain(pkg.Export); err != nil || guards.hashes[pkg.Export] != exports[pkg.ImportPath] {
+			return fmt.Errorf("ordinary asmdecl export differs from independent consumption: %s", pkg.ImportPath)
+		}
+		config.PackageFile[pkg.ImportPath] = pkg.Export
+		if pkg.ImportPath == plan.PackagePath {
+			root = &pkg
+		}
+	}
+	if root == nil || len(config.PackageFile) != len(exports) {
+		return fmt.Errorf("ordinary asmdecl actual export closure differs from its independently consumed denominator")
+	}
+	if err := bindInstrumentationAsmdeclSource(input, plan, selected, root, &config, guards); err != nil {
+		return err
+	}
+	for name, resolved := range root.ImportMap {
+		if !seen[resolved] {
+			return fmt.Errorf("ordinary asmdecl has an unconsumed import mapping: %s", name)
+		}
+		config.ImportMap[name] = resolved
+	}
+	for _, imported := range root.Imports {
+		if !seen[imported] {
+			return fmt.Errorf("ordinary asmdecl has an unconsumed actual import: %s", imported)
+		}
+	}
+	owned, err := os.MkdirTemp("", "plan9asm-ordinary-asmdecl-")
+	if err != nil {
+		return err
+	}
+	identity, err := sourcepath.Lstat(owned)
+	if err != nil {
+		return fmt.Errorf("ordinary asmdecl created directory identity unavailable: %w", err)
+	}
+	workspace := &instrumentationAsmdeclWorkspace{name: owned, identity: identity}
+	workspace.physical, err = sourcepath.Resolve(owned)
+	defer func() {
+		if cleanupErr := workspace.close(remove); cleanupErr != nil {
+			result = errors.Join(result, cleanupErr)
+		}
+	}()
+	if err != nil {
+		return fmt.Errorf("ordinary asmdecl created directory is not physical: %w", err)
+	}
+	if err := workspace.verify(); err != nil {
+		return err
+	}
+	config.VetxOutput = filepath.Join(owned, "ordinary.vetx")
+	encoded, err := json.Marshal(config)
+	if err != nil {
+		return err
+	}
+	filename := filepath.Join(owned, "ordinary.cfg")
+	if err := os.WriteFile(filename, encoded, 0600); err != nil {
+		return err
+	}
+	if err := guards.retain(filename); err != nil || guards.hashes[filename] != bytesSHA256(encoded) {
+		return fmt.Errorf("ordinary asmdecl written configuration differs: %v", err)
+	}
+	if err := workspace.verifyConfig(); err != nil {
+		return err
+	}
+	if err := recheckInstrumentationAsmdeclGuards(guards); err != nil {
+		return err
+	}
+	stdout, stderr, err = run(ctx, owned, env, binary, instrumentationOrdinaryAsmdeclArgs()...)
+	if err != nil || len(stdout) != 0 || len(stderr) != 0 {
+		return errors.Join(fmt.Errorf("original ordinary same-mode asmdecl failed or emitted unknown diagnostics (not source N/A): %v; %s; %s", err, stdout, stderr), workspace.verifyConfig())
+	}
+	if err := workspace.verifyConfig(); err != nil {
+		return err
+	}
+	return recheckInstrumentationAsmdeclGuards(guards)
+}
+
+func bindInstrumentationAsmdeclSource(input *ConsumerInput, plan *InstrumentationOriginalPackagePlan, selected *PackageProof,
+	pkg *instrumentationAsmdeclPackage, config *instrumentationAsmdeclConfig, guards *instrumentationTypeGraph,
+) error {
+	if err := ValidatePackageModule(input, *selected); err != nil {
+		return err
+	}
+	expectedDir := filepath.Join(input.SourceRoot, filepath.FromSlash(plan.PackageDirectory))
+	expectedDir, err := sourcepath.Resolve(expectedDir)
+	if err != nil {
+		return err
+	}
+	actualDir, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil || actualDir != expectedDir || pkg.Module == nil || pkg.Module.Path != selected.ModulePath ||
+		pkg.Module.Version != selected.ModuleVersion || pkg.Module.Main != (selected.SourceRole == "main") {
+		return fmt.Errorf("ordinary asmdecl package/module identity changed")
+	}
+	module := pkg.Module
+	if selected.SourceRole == "version_replace" {
+		replacement := module.Replace
+		if replacement == nil || replacement.Path != selected.SourceModule || replacement.Version != selected.SourceVersion ||
+			replacement.Version == "" || replacement.Main || replacement.Replace != nil {
+			return fmt.Errorf("ordinary asmdecl exact archive replacement identity changed")
+		}
+		module = replacement
+	} else if module.Replace != nil || selected.SourceRole != "main" && selected.SourceRole != "module" {
+		return fmt.Errorf("ordinary asmdecl has an unknown or local replacement role")
+	}
+	expectedRoot, err := sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return fmt.Errorf("ordinary asmdecl original module root is unavailable: %w", err)
+	}
+	for _, root := range []string{pkg.Module.Dir, module.Dir} {
+		physical, err := sourcepath.Resolve(root)
+		if err != nil || physical != expectedRoot {
+			return fmt.Errorf("ordinary asmdecl actual module root differs from original source")
+		}
+	}
+	config.Dir = actualDir
+	config.GoVersion = "go" + pkg.Module.GoVersion
+	if pkg.Module.GoVersion == "" {
+		config.GoVersion = "go1.16"
+	}
+	source := ImportExport{ModulePath: selected.ModulePath, Version: selected.ModuleVersion,
+		SourceModule: selected.SourceModule, SourceVersion: selected.SourceVersion, SourceRole: selected.SourceRole}
+	if err := guards.retainModuleMetadata(input, source, module.GoMod, expectedRoot); err != nil {
+		return fmt.Errorf("ordinary asmdecl original module metadata changed: %w", err)
+	}
+	if pkg.Module.GoMod != module.GoMod {
+		if err := guards.retainModuleMetadata(input, source, pkg.Module.GoMod, expectedRoot); err != nil {
+			return fmt.Errorf("ordinary asmdecl actual namespace metadata changed: %w", err)
+		}
+	}
+	for index, names := range [][]string{pkg.GoFiles, pkg.CompiledGoFiles, pkg.SFiles} {
+		var logical, actual []string
+		for _, name := range names {
+			if filepath.IsAbs(name) {
+				name, err = filepath.Rel(pkg.Dir, name)
+			}
+			if err != nil || path.Base(name) != name || !validInstrumentationSourcePath(name) || strings.HasSuffix(name, "_test.go") {
+				return fmt.Errorf("ordinary asmdecl source lacks an exact original role")
+			}
+			source := path.Join(plan.PackageDirectory, name)
+			if selected.SourceSHA256[source] == "" || selected.SourceSHA256[source] != input.Sources[source] {
+				return fmt.Errorf("ordinary asmdecl source differs from independently selected original bytes")
+			}
+			filename := filepath.Join(actualDir, name)
+			if err := guards.retain(filename); err != nil || guards.hashes[filename] != selected.SourceSHA256[source] {
+				return fmt.Errorf("ordinary asmdecl source bytes changed: %s", source)
+			}
+			logical, actual = append(logical, source), append(actual, filename)
+		}
+		sort.Strings(logical)
+		expected := [][]string{selected.GoFiles, selected.CompiledGoFiles, selected.SFiles}[index]
+		if !reflect.DeepEqual(logical, expected) {
+			return fmt.Errorf("ordinary asmdecl source selection changed")
+		}
+		if index == 1 {
+			config.GoFiles = actual
+		} else if index == 2 {
+			config.NonGoFiles = actual
+		}
+	}
+	return nil
+}
+
+func recheckInstrumentationAsmdeclGuards(guards *instrumentationTypeGraph) error {
+	for filename, expected := range guards.hashes {
+		physical, err := sourcepath.Resolve(filename)
+		if err != nil || physical != guards.paths[filename] {
+			return fmt.Errorf("ordinary asmdecl source/configuration/export path changed: %s", filename)
+		}
+		if actual, err := FileSHA256(filename); err != nil || actual != expected {
+			return fmt.Errorf("ordinary asmdecl source/configuration/export changed: %s", filename)
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_asmdecl_go127_test.go b/gotoolprofile/instrumentation_asmdecl_go127_test.go
new file mode 100644
index 000000000..d73e41c78
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl_go127_test.go
@@ -0,0 +1,114 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationOriginalAsmdeclRetainsExactOrdinarySourceUnit(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t),
+		os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := instrumentationOriginalFixture(t, marker.Early)
+	module, err := os.ReadFile(filepath.Join(input.SourceRoot, "go.mod"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod": string(module) + "\nrequire example.invalid/testonly v0.0.0\n" +
+			"replace example.invalid/testonly => ./test-dependency-missing\n",
+		"poison_test.go": "package markers\nimport _ \"example.invalid/testonly\"\n",
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(input.SourceRoot, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name], input.Headers[name] = bytesSHA256([]byte(source)), source
+	}
+	input.Directories["."] = append(input.Directories["."], "poison_test.go")
+	sort.Strings(input.Directories["."])
+	inventory, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, inventory, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := instrumentationFixtureEnvironment(os.Environ(), marker.Early)
+	_, stderr, err := RunBounded(ctx, input.SourceRoot, env, binary, "vet", "-race", "-asmdecl",
+		"-tests=false", "-p=1", "-mod=readonly", plan.PackagePath)
+	if err == nil || !strings.Contains(string(stderr), "test-dependency-missing") {
+		t.Fatalf("actual cmd/go still-loading-tests control did not fail: %v; %s", err, stderr)
+	}
+	proof, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(),
+		input, inventory, marker, plan, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(proof.Package.GoFiles, []string{"base.go", "mode_race.go"}) ||
+		!reflect.DeepEqual(proof.VetArgs, []string{"tool", "vet", "-asmdecl", "ordinary.cfg"}) {
+		t.Fatal("ordinary source role was lost or replaced by a filtered test package")
+	}
+
+	// Each mutation starts from the actual freshly written config. Even if
+	// native vet accepts a modified valid unit, its byte guard must reject it.
+	for _, field := range []string{"ID", "GoFiles", "NonGoFiles", "VetxOnly", "SucceedOnTypecheckFailure"} {
+		t.Run(field, func(t *testing.T) {
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if reflect.DeepEqual(args, []string{"tool", "vet", "-asmdecl", "ordinary.cfg"}) {
+					filename := filepath.Join(dir, "ordinary.cfg")
+					data, err := os.ReadFile(filename)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var config map[string]json.RawMessage
+					if err := json.Unmarshal(data, &config); err != nil {
+						t.Fatal(err)
+					}
+					switch field {
+					case "ID":
+						config[field] = json.RawMessage(`"other.invalid/source"`)
+					case "GoFiles", "NonGoFiles":
+						config[field] = json.RawMessage(`[]`)
+					default:
+						config[field] = json.RawMessage(`true`)
+					}
+					data, err = json.Marshal(config)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filename, data, 0600); err != nil {
+						t.Fatal(err)
+					}
+					changed = true
+				}
+				return RunBounded(ctx, dir, env, name, args...)
+			}
+			_, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(),
+				input, inventory, marker, plan, run)
+			if !changed || err == nil {
+				t.Fatalf("actual asmdecl config field %s mutation was not independently refused: %v", field, err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_asmdecl_owned_unix_go127_test.go b/gotoolprofile/instrumentation_asmdecl_owned_unix_go127_test.go
new file mode 100644
index 000000000..fc6495b5e
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl_owned_unix_go127_test.go
@@ -0,0 +1,185 @@
+//go:build go1.27 && unix
+
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationOrdinaryAsmdeclOwnedDirectoryCompletion(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t),
+		os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, scenario := range []string{"control", "replace before tool", "replace after tool", "cleanup error", "cleanup permissions"} {
+		t.Run(scenario, func(t *testing.T) {
+			input := instrumentationOriginalFixture(t, marker.Early)
+			inventory, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			plan, err := PlanInstrumentationOriginalPackage(input, inventory, marker.Early, ".", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(),
+				input, inventory, marker, plan, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var owned, backup, blocked string
+			var original, replacement os.FileInfo
+			actualToolCompleted := false
+			cleanupObserved := false
+			var actualCleanupError error
+			cleanupFailure := errors.New("independent owned cleanup fixture failure")
+			remove := os.RemoveAll
+			if scenario == "cleanup error" || scenario == "cleanup permissions" {
+				remove = func(name string) error {
+					if !actualToolCompleted || name != owned {
+						t.Fatal("cleanup was not bound to the successful actual analyzer workspace")
+					}
+					cleanupObserved = true
+					if scenario == "cleanup error" {
+						actualCleanupError = cleanupFailure
+					} else {
+						actualCleanupError = os.RemoveAll(name)
+					}
+					return actualCleanupError
+				}
+			}
+			t.Cleanup(func() {
+				if blocked != "" {
+					if err := os.Chmod(blocked, 0700); err != nil && !os.IsNotExist(err) {
+						t.Errorf("restore exact owned cleanup fixture: %v", err)
+					}
+				}
+				for name, identity := range map[string]os.FileInfo{backup: original, owned: replacement} {
+					if name == "" || identity == nil {
+						continue
+					}
+					info, err := os.Lstat(name)
+					if os.IsNotExist(err) {
+						continue
+					}
+					if err != nil || !os.SameFile(info, identity) {
+						t.Errorf("refuse changed exact fixture directory cleanup: %s", name)
+						continue
+					}
+					if err := os.RemoveAll(name); err != nil {
+						t.Errorf("exact fixture directory cleanup: %v", err)
+					}
+				}
+			})
+			replace := func() {
+				data, err := os.ReadFile(filepath.Join(owned, "ordinary.cfg"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				backup = owned + ".fixture-original"
+				if err := os.Rename(owned, backup); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(owned, 0700); err != nil {
+					t.Fatal(err)
+				}
+				replacement, err = os.Lstat(owned)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(owned, "ordinary.cfg"), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if !reflect.DeepEqual(args, instrumentationOrdinaryAsmdeclArgs()) {
+					return RunBounded(ctx, dir, env, name, args...)
+				}
+				owned = dir
+				original, err = os.Lstat(owned)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if scenario == "replace before tool" {
+					replace()
+				}
+				stdout, stderr, toolErr := RunBounded(ctx, dir, env, name, args...)
+				if toolErr != nil || len(stdout)+len(stderr) != 0 {
+					t.Fatalf("actual official analyzer fixture: %v; %s; %s", toolErr, stdout, stderr)
+				}
+				actualToolCompleted = true
+				if scenario == "replace after tool" {
+					replace()
+				}
+				if scenario == "cleanup error" {
+					replacement = original
+				}
+				if scenario == "cleanup permissions" {
+					blocked = filepath.Join(owned, "blocked")
+					if err := os.Mkdir(blocked, 0700); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(filepath.Join(blocked, "leaf"), []byte("owned fixture"), 0600); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Chmod(blocked, 0); err != nil {
+						t.Fatal(err)
+					}
+					replacement = original
+				}
+				return stdout, stderr, toolErr
+			}
+			modeEnv := instrumentationFixtureEnvironment(os.Environ(), marker.Early)
+			err = runInstrumentationOrdinaryAsmdecl(ctx, binary, input.SourceRoot, modeEnv, input, plan, &proof.Package,
+				map[string]string{proof.Package.PackagePath: proof.ArchiveSHA256}, run, remove)
+			if !actualToolCompleted {
+				t.Fatalf("fixture did not reach actual official analyzer: %v", err)
+			}
+			if scenario == "cleanup error" || scenario == "cleanup permissions" {
+				if !cleanupObserved {
+					t.Fatal("cleanup fixture did not observe the actual completion path")
+				}
+				if actualCleanupError == nil {
+					if err != nil {
+						t.Fatalf("successful actual removal was reported as a failure: %v", err)
+					}
+					t.Log("actual mode-000 removal succeeded; no permission-denial claim")
+				} else if !errors.Is(err, actualCleanupError) {
+					t.Fatalf("lost independently observed cleanup cause: cleanup=%v producer=%v", actualCleanupError, err)
+				}
+				if scenario == "cleanup error" && !errors.Is(err, cleanupFailure) {
+					t.Fatalf("successful analyzer did not preserve the distinct cleanup sentinel: %v", err)
+				}
+			} else if scenario == "control" {
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := os.Lstat(owned); !os.IsNotExist(err) {
+					t.Fatalf("successful original directory not cleaned: %v", err)
+				}
+			} else if err == nil {
+				t.Fatal("successful actual analyzer hid owned-directory replacement or cleanup failure")
+			}
+			if backup != "" {
+				info, err := os.Lstat(owned)
+				if err != nil || !os.SameFile(info, replacement) {
+					t.Fatal("producer deleted or changed replacement directory")
+				}
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_asmdecl_workspace.go b/gotoolprofile/instrumentation_asmdecl_workspace.go
new file mode 100644
index 000000000..2639cb280
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl_workspace.go
@@ -0,0 +1,59 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This identity belongs only to the temporary native analyzer invocation. It
+// is not a source/ABI capability and cannot be supplied through a public proof.
+type instrumentationAsmdeclWorkspace struct {
+	name     string
+	physical string
+	identity os.FileInfo
+}
+
+func (owned *instrumentationAsmdeclWorkspace) verify() error {
+	if owned == nil || owned.identity == nil || !owned.identity.IsDir() {
+		return fmt.Errorf("ordinary asmdecl lacks its created directory identity")
+	}
+	actual, err := os.Lstat(owned.name)
+	if err != nil || !actual.IsDir() || actual.Mode()&os.ModeSymlink != 0 || !os.SameFile(owned.identity, actual) {
+		return fmt.Errorf("ordinary asmdecl owned directory was removed or replaced: %v", err)
+	}
+	physical, err := sourcepath.Resolve(owned.name)
+	if err != nil || physical != owned.physical {
+		return fmt.Errorf("ordinary asmdecl owned directory alias changed: %v", err)
+	}
+	return nil
+}
+
+func (owned *instrumentationAsmdeclWorkspace) verifyConfig() error {
+	if err := owned.verify(); err != nil {
+		return err
+	}
+	info, err := os.Lstat(filepath.Join(owned.name, "ordinary.cfg"))
+	if err != nil || !info.Mode().IsRegular() {
+		return fmt.Errorf("ordinary asmdecl configuration is absent or redirected: %v", err)
+	}
+	return nil
+}
+
+func (owned *instrumentationAsmdeclWorkspace) close(remove func(string) error) error {
+	if err := owned.verify(); err != nil {
+		return err // never delete a replacement or an unproved alias target
+	}
+	if remove == nil {
+		return fmt.Errorf("ordinary asmdecl lacks its owned cleanup operation")
+	}
+	if err := remove(owned.name); err != nil {
+		return fmt.Errorf("ordinary asmdecl owned directory cleanup failed: %w", err)
+	}
+	if _, err := os.Lstat(owned.name); !os.IsNotExist(err) {
+		return fmt.Errorf("ordinary asmdecl owned directory cleanup did not complete: %v", err)
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_asmdecl_workspace_test.go b/gotoolprofile/instrumentation_asmdecl_workspace_test.go
new file mode 100644
index 000000000..c177096ab
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl_workspace_test.go
@@ -0,0 +1,89 @@
+package gotoolprofile
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestInstrumentationAsmdeclWorkspaceIdentityAndCleanup(t *testing.T) {
+	for _, scenario := range []string{"control", "missing", "replaced", "nonregular config", "cleanup error", "cleanup incomplete", "missing cleanup"} {
+		t.Run(scenario, func(t *testing.T) {
+			root := t.TempDir()
+			name := filepath.Join(root, "owned")
+			if err := os.Mkdir(name, 0700); err != nil {
+				t.Fatal(err)
+			}
+			identity, err := os.Lstat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			physical, err := filepath.EvalSymlinks(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			owned := &instrumentationAsmdeclWorkspace{name: name, physical: physical, identity: identity}
+			filename := filepath.Join(name, "ordinary.cfg")
+			if err := os.WriteFile(filename, []byte("actual config guard fixture"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := owned.verifyConfig(); err != nil {
+				t.Fatal(err)
+			}
+			remove := os.RemoveAll
+			cleanupFailure := errors.New("owned cleanup fixture failure")
+			switch scenario {
+			case "missing":
+				if err := os.RemoveAll(name); err != nil {
+					t.Fatal(err)
+				}
+			case "replaced":
+				if err := os.Rename(name, filepath.Join(root, "original")); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(name, 0700); err != nil {
+					t.Fatal(err)
+				}
+			case "nonregular config":
+				if err := os.Remove(filename); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(filename, 0700); err != nil {
+					t.Fatal(err)
+				}
+			case "cleanup error":
+				remove = func(string) error { return cleanupFailure }
+			case "cleanup incomplete":
+				remove = func(string) error { return nil }
+			case "missing cleanup":
+				remove = nil
+			}
+			if scenario == "nonregular config" {
+				if err := owned.verifyConfig(); err == nil {
+					t.Fatal("accepted a nonregular configuration leaf")
+				}
+				if err := owned.close(os.RemoveAll); err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			err = owned.close(remove)
+			if scenario == "control" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil {
+				t.Fatal("accepted incomplete ownership or cleanup")
+			}
+			if scenario == "cleanup error" && !errors.Is(err, cleanupFailure) {
+				t.Fatalf("lost original cleanup error: %v", err)
+			}
+			if scenario == "replaced" {
+				if _, err := os.Lstat(name); err != nil {
+					t.Fatal("removed replacement directory")
+				}
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_asmdecl_workspace_unix_test.go b/gotoolprofile/instrumentation_asmdecl_workspace_unix_test.go
new file mode 100644
index 000000000..01033c1e0
--- /dev/null
+++ b/gotoolprofile/instrumentation_asmdecl_workspace_unix_test.go
@@ -0,0 +1,139 @@
+//go:build unix
+
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// This reuses the signed metadata witness, not a signed external source ZIP.
+// The controlled source only tests separation of its physical source root
+// from the independent proxy metadata origin.
+func TestInstrumentationAsmdeclLegacyMetadataPhysicalRoot(t *testing.T) {
+	for _, inside := range []bool{false, true} {
+		name := "outside control"
+		if inside {
+			name = "inside aliased root"
+		}
+		t.Run(name, func(t *testing.T) {
+			input, actual, metadata := instrumentationTypeLegacyMetadataFixture(t)
+			physical := input.Original.SourceRoot
+			alias := filepath.Join(t.TempDir(), "original-source")
+			if err := os.Symlink(physical, alias); err != nil {
+				t.Fatal(err)
+			}
+			input.Original.SourceRoot = alias
+			if inside {
+				metadata = filepath.Join(physical, "proxy.mod")
+				if err := os.WriteFile(metadata, []byte(input.Original.ProxyGoMod.Contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Original.ProxyGoModPath = metadata
+			}
+			proof := input.Original.ProxyGoMod
+			selected := &PackageProof{
+				PackagePath: actual.ImportPath, ModulePath: proof.Module, ModuleVersion: proof.Version,
+				SourceModule: proof.Module, SourceVersion: proof.Version, SourceRole: "module",
+				GoModOrigin: proof.Protocol, GoModSHA256: proof.SHA256, GoModSum: proof.GoModSum,
+				GoFiles: actual.GoFiles, CompiledGoFiles: actual.CompiledGoFiles,
+				SourceSHA256: input.Original.Sources,
+			}
+			pkg := &instrumentationAsmdeclPackage{
+				Dir: physical, ImportPath: actual.ImportPath,
+				GoFiles: actual.GoFiles, CompiledGoFiles: actual.CompiledGoFiles,
+				Module: &instrumentationAsmdeclModule{
+					Path: proof.Module, Version: proof.Version, Dir: physical, GoMod: metadata,
+				},
+			}
+			plan := &InstrumentationOriginalPackagePlan{PackagePath: actual.ImportPath, PackageDirectory: "."}
+			guards := &instrumentationTypeGraph{hashes: make(map[string]string), paths: make(map[string]string)}
+			err := bindInstrumentationAsmdeclSource(input.Original, plan, selected, pkg, &instrumentationAsmdeclConfig{}, guards)
+			if inside {
+				if err == nil {
+					t.Fatal("logical root alias disguised metadata inside the original source root")
+				}
+			} else if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestInstrumentationAsmdeclWorkspaceAliasAndConfigRedirection(t *testing.T) {
+	for _, scenario := range []string{"control", "alias retarget", "config symlink"} {
+		t.Run(scenario, func(t *testing.T) {
+			root := t.TempDir()
+			first, second := filepath.Join(root, "first"), filepath.Join(root, "second")
+			for _, name := range []string{first, second} {
+				if err := os.Mkdir(name, 0700); err != nil {
+					t.Fatal(err)
+				}
+			}
+			physical := filepath.Join(first, "owned")
+			if err := os.Mkdir(physical, 0700); err != nil {
+				t.Fatal(err)
+			}
+			alias := filepath.Join(root, "alias")
+			if err := os.Symlink(first, alias); err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(alias, "owned")
+			identity, err := os.Lstat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			physical, err = filepath.EvalSymlinks(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			owned := &instrumentationAsmdeclWorkspace{name: name, physical: physical, identity: identity}
+			filename := filepath.Join(name, "ordinary.cfg")
+			if err := os.WriteFile(filename, []byte("unchanged config"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := owned.verifyConfig(); err != nil {
+				t.Fatal(err)
+			}
+			switch scenario {
+			case "alias retarget":
+				if err := os.Rename(physical, filepath.Join(second, "owned")); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Remove(alias); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(second, alias); err != nil {
+					t.Fatal(err)
+				}
+				actual, err := os.Lstat(name)
+				if err != nil || !os.SameFile(identity, actual) {
+					t.Fatal("retarget fixture failed to retain the original directory inode")
+				}
+			case "config symlink":
+				original := filepath.Join(root, "original.cfg")
+				if err := os.Rename(filename, original); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(original, filename); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if scenario == "control" {
+				if err := owned.verifyConfig(); err != nil {
+					t.Fatal(err)
+				}
+			} else if err := owned.verifyConfig(); err == nil {
+				t.Fatal("same inode/bytes authorized a retargeted alias or config leaf")
+			}
+			if scenario == "alias retarget" {
+				if err := owned.close(os.RemoveAll); err == nil {
+					t.Fatal("retargeted alias was deleted")
+				}
+			} else if err := owned.close(os.RemoveAll); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_build_plan.go b/gotoolprofile/instrumentation_build_plan.go
new file mode 100644
index 000000000..1eba3f1d7
--- /dev/null
+++ b/gotoolprofile/instrumentation_build_plan.go
@@ -0,0 +1,141 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strings"
+)
+
+// InstrumentationBuildPlan separates the requested driver mode from its
+// source-derived compiler/assembler flags. SourceLinkMode is the registered
+// driver's planned linker mode, not evidence of an executed linker or an
+// available sanitizer runtime. Only an actual same-mode compile observation
+// can establish that the compiler and assembler consumed CodegenFlags.
+type InstrumentationBuildPlan struct {
+	Protocol                    string              `json:"protocol"`
+	GoVersion                   string              `json:"go_version"`
+	Target                      string              `json:"target"`
+	Mode                        InstrumentationMode `json:"mode"`
+	RequestedBuildMode          string              `json:"requested_build_mode"`
+	InstrumentAdjustedBuildMode string              `json:"instrument_adjusted_build_mode"`
+	SourceLinkMode              string              `json:"source_link_mode"`
+	CodegenFlags                []string            `json:"codegen_flags,omitempty"`
+	RegistrationSHA256          map[string]string   `json:"registration_ast_sha256"`
+}
+
+func DeriveInstrumentationBuildPlan(source *InstrumentationSourceProof, target string, mode InstrumentationMode) (*InstrumentationBuildPlan, error) {
+	rules, err := ReplayInstrumentationSourceProof(source)
+	if err != nil {
+		return nil, err
+	}
+	adjusted, err := rules.EffectiveBuildMode(target, mode)
+	if err != nil {
+		return nil, err
+	}
+	minor, _ := goMinor(source.GoVersion)
+	registration, err := instrumentationBuildRegistration(source, minor)
+	if err != nil {
+		return nil, err
+	}
+	plan := &InstrumentationBuildPlan{
+		Protocol: "actual_go_instrumentation_build_plan_v1", GoVersion: source.GoVersion,
+		Target: target, Mode: mode, RequestedBuildMode: "default", InstrumentAdjustedBuildMode: adjusted,
+		SourceLinkMode: "exe", RegistrationSHA256: registration,
+	}
+	goos, goarch, _ := strings.Cut(target, "/")
+	if adjusted == "pie" {
+		plan.SourceLinkMode, plan.CodegenFlags = "pie", []string{"-shared"}
+		return plan, nil
+	}
+	// These branches apply only after the complete source registrations above
+	// match their audited Go version. Go 1.20 used an inline default branch;
+	// its Darwin ARM64 codegen was shared even though ldBuildmode stayed exe.
+	if minor == 20 {
+		switch goos {
+		case "android", "ios":
+			plan.SourceLinkMode, plan.CodegenFlags = "pie", []string{"-shared"}
+		case "windows":
+			if mode != InstrumentationRace {
+				plan.SourceLinkMode = "pie"
+			}
+		case "darwin":
+			if goarch == "arm64" {
+				plan.CodegenFlags = []string{"-shared"}
+			}
+		}
+		return plan, nil
+	}
+	defaultPIE := goos == "android" || goos == "ios" ||
+		goos == "windows" && mode != InstrumentationRace ||
+		goos == "darwin" && (minor >= 22 || goarch == "arm64")
+	if defaultPIE {
+		plan.SourceLinkMode = "pie"
+		if goos != "windows" {
+			plan.CodegenFlags = []string{"-shared"}
+		}
+	}
+	return plan, nil
+}
+
+func ValidateInstrumentationBuildPlan(plan *InstrumentationBuildPlan, source *InstrumentationSourceProof) error {
+	if plan == nil {
+		return fmt.Errorf("missing source-derived instrumentation build plan")
+	}
+	wanted, err := DeriveInstrumentationBuildPlan(source, plan.Target, plan.Mode)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(plan, wanted) {
+		return fmt.Errorf("instrumentation build plan differs from the complete actual driver sources")
+	}
+	return nil
+}
+
+func instrumentationBuildRegistration(source *InstrumentationSourceProof, minor int) (map[string]string, error) {
+	registration := make(map[string]string)
+	for _, item := range []struct{ file, name string }{
+		{"src/cmd/go/internal/work/init.go", "buildModeInit"},
+		{"src/internal/platform/supported.go", "DefaultPIE"},
+	} {
+		set := token.NewFileSet()
+		file, err := parser.ParseFile(set, item.file, source.SourceText[item.file], 0)
+		if err != nil {
+			return nil, err
+		}
+		function, err := discoveryAssemblerSourceFunction(file, item.name)
+		if minor == 20 && item.name == "DefaultPIE" {
+			for _, declaration := range file.Decls {
+				if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == item.name {
+					return nil, fmt.Errorf("unexpected Go 1.20 external DefaultPIE registration")
+				}
+			}
+			registration[item.name] = bytesSHA256(nil)
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+		registration[item.name], err = ASTSHA(set, function)
+		if err != nil {
+			return nil, err
+		}
+	}
+	wanted := map[string]string{
+		"buildModeInit": "93bbca69e0bd378d09842ab69c01c48e76dad5b6ebb5935674043ab16c50cba7",
+		"DefaultPIE":    "e8d3f7e66c3d0c23f4bdd4e5e9927d8adebb19229be425ebe6ad915fdb742374",
+	}
+	if minor == 20 {
+		wanted["buildModeInit"] = "e358c2b632bd5c665bb216cbb551a536dfd7ef556cb5238d0761ab482f8a3e81"
+		wanted["DefaultPIE"] = bytesSHA256(nil)
+	} else if minor == 21 {
+		wanted["buildModeInit"] = "9d5ad2c0f3e2f30c6c40fc75d7141bb35913eca1e0da1c6a11bb4061a2f20c51"
+		wanted["DefaultPIE"] = "2df09e5d91da08a13fa6874d579d69e5ef5438e2f0ae793f335329db28307d79"
+	}
+	if !reflect.DeepEqual(registration, wanted) {
+		return nil, fmt.Errorf("unrecognized complete Go codegen/buildmode registration")
+	}
+	return registration, nil
+}
diff --git a/gotoolprofile/instrumentation_build_plan_test.go b/gotoolprofile/instrumentation_build_plan_test.go
new file mode 100644
index 000000000..764e391aa
--- /dev/null
+++ b/gotoolprofile/instrumentation_build_plan_test.go
@@ -0,0 +1,98 @@
+package gotoolprofile
+
+import (
+	"go/parser"
+	"go/token"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationBuildPlanSeparatesRequestedModeAndCodegen(t *testing.T) {
+	source, err := CaptureInstrumentationSourceProof(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	minor, err := goMinor(runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, input := range []struct {
+		target, mode, adjusted, link string
+		codegen                      []string
+	}{
+		{"darwin/arm64", "race", "default", "pie", []string{"-shared"}},
+		{"darwin/amd64", "race", "default", "pie", []string{"-shared"}},
+		{"windows/amd64", "race", "default", "exe", nil},
+		{"linux/arm64", "race", "default", "exe", nil},
+		{"linux/arm64", "msan", "pie", "pie", []string{"-shared"}},
+		{"linux/amd64", "msan", "default", "exe", nil},
+	} {
+		t.Run(input.target+"/"+input.mode, func(t *testing.T) {
+			if strings.HasPrefix(input.target, "darwin/") && minor == 20 {
+				input.link = "exe"
+			}
+			if input.target == "darwin/amd64" && minor < 22 {
+				input.link, input.codegen = "exe", nil
+			}
+			plan, err := DeriveInstrumentationBuildPlan(source, input.target, InstrumentationMode(input.mode))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if plan.RequestedBuildMode != "default" || plan.InstrumentAdjustedBuildMode != input.adjusted ||
+				plan.SourceLinkMode != input.link || !reflect.DeepEqual(plan.CodegenFlags, input.codegen) {
+				t.Fatalf("wrong source-derived requested/adjusted/codegen/link plan: %+v", plan)
+			}
+			if err := ValidateInstrumentationBuildPlan(plan, source); err != nil {
+				t.Fatal(err)
+			}
+			plan.SourceLinkMode = "invented"
+			if err := ValidateInstrumentationBuildPlan(plan, source); err == nil {
+				t.Fatal("accepted a caller-reported final buildmode")
+			}
+		})
+	}
+}
+
+func TestInstrumentationBuildPlanRejectsRewrittenDefaultPIEWithFreshHashes(t *testing.T) {
+	proof, err := CaptureInstrumentationSourceProof(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	minor, _ := goMinor(runtime.Version())
+	name := "src/internal/platform/supported.go"
+	if minor == 20 {
+		name = "src/cmd/go/internal/work/init.go"
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, name, proof.SourceText[name], 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	functionName := "DefaultPIE"
+	if minor == 20 {
+		functionName = "buildModeInit"
+	}
+	function, err := discoveryAssemblerSourceFunction(file, functionName)
+	if err != nil {
+		t.Fatal(err)
+	}
+	start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+	original := proof.SourceText[name]
+	changed := strings.Replace(original[start:end], `"darwin"`, `"plan9"`, 1)
+	if changed == original[start:end] {
+		t.Fatal("the actual Darwin PIE registration was not found")
+	}
+	proof.SourceText[name] = original[:start] + changed + original[end:]
+	proof.SourceSHA256[name] = bytesSHA256([]byte(proof.SourceText[name]))
+	// Existing early-rule registrations remain valid: codegen must validate
+	// the complete additional registration, not trust the freshly rewritten
+	// source hash or confuse early acceptance with compiler flags.
+	if _, err := ReplayInstrumentationSourceProof(proof); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := DeriveInstrumentationBuildPlan(proof, "darwin/arm64", InstrumentationRace); err == nil {
+		t.Fatal("accepted a self-consistent rewritten effective PIE registration")
+	}
+}
diff --git a/gotoolprofile/instrumentation_consumer.go b/gotoolprofile/instrumentation_consumer.go
new file mode 100644
index 000000000..d39af9c29
--- /dev/null
+++ b/gotoolprofile/instrumentation_consumer.go
@@ -0,0 +1,182 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+const InstrumentationConsumerProtocol = "actual_go_instrumentation_source_context_v1"
+const InstrumentationPackageSelectionProtocol = "actual_go_instrumentation_package_selection_v1"
+const instrumentationAssemblerProtocol = "go_source_instrumentation_assembler_macros_v1"
+
+// InstrumentationConsumerInput keeps the complete original source input in its
+// original role. Its CPU foundation is not rewritten into a mode observation.
+// This single-package context is not export, header, CPP, LLVM or runtime proof.
+// External callers must independently authenticate original ZIP/metadata bytes.
+type InstrumentationConsumerInput struct {
+	Protocol    string                                  `json:"protocol"`
+	ID          string                                  `json:"mode_profile_id"`
+	Original    *ConsumerInput                          `json:"original"`
+	Sources     *InstrumentationOriginalSourceInventory `json:"original_source_inventory"`
+	Observation *InstrumentationExportObservation       `json:"actual_mode_observation"`
+	Plan        *InstrumentationOriginalPackagePlan     `json:"original_package_plan"`
+	TypeSources *InstrumentationTypeSourceProof         `json:"original_type_sources,omitempty"`
+}
+
+// InstrumentationPackageSelectionProof reuses concrete original package/source
+// identities but never the ordinary protocol or its profile ID. Actual loaders
+// must independently capture/recheck source, tools and selected dependency
+// exports; validating this source-only record does not discharge a candidate.
+type InstrumentationPackageSelectionProof struct {
+	Protocol      string         `json:"protocol"`
+	ModeProfileID string         `json:"mode_profile_id"`
+	InputSHA256   string         `json:"input_sha256"`
+	CustomTags    []string       `json:"custom_tags,omitempty"`
+	Packages      []PackageProof `json:"packages"`
+	Status        string         `json:"status"`
+}
+
+func NewInstrumentationConsumerInput(original *ConsumerInput, sources *InstrumentationOriginalSourceInventory, observed *InstrumentationExportObservation, plan *InstrumentationOriginalPackagePlan) (*InstrumentationConsumerInput, error) {
+	if observed == nil || plan == nil {
+		return nil, fmt.Errorf("missing actual mode observation or original planning scope")
+	}
+	input := &InstrumentationConsumerInput{
+		Protocol: InstrumentationConsumerProtocol, ID: InstrumentationEarlyProfileID(observed.Early),
+		Original: original, Sources: sources, Observation: observed, Plan: plan,
+	}
+	if err := ValidateInstrumentationConsumerInput(input, plan.PackageDirectory, plan.CustomTags); err != nil {
+		return nil, err
+	}
+	return input, nil
+}
+
+func ValidateInstrumentationConsumerInput(input *InstrumentationConsumerInput, directory string, tags []string) error {
+	if input == nil || input.Protocol != InstrumentationConsumerProtocol || input.Original == nil || input.Plan == nil || input.Observation == nil {
+		return fmt.Errorf("missing independent instrumentation source context")
+	}
+	if err := ValidateInstrumentationExportObservation(input.Observation); err != nil {
+		return err
+	}
+	if input.ID != InstrumentationEarlyProfileID(input.Observation.Early) || input.ID == input.Original.ID {
+		return fmt.Errorf("instrumentation context has a changed or ordinary profile identity")
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input.Original, input.Sources, input.Observation.Early, directory, tags, input.Plan); err != nil {
+		return err
+	}
+	if input.TypeSources != nil {
+		return ValidateInstrumentationTypeSources(input, input.TypeSources)
+	}
+	return nil
+}
+
+func DecodeInstrumentationConsumerInput(reader io.Reader, directory string, tags []string) (*InstrumentationConsumerInput, error) {
+	var input InstrumentationConsumerInput
+	if err := decodeInstrumentationOriginalJSON(reader, 40<<20, &input); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationConsumerInput(&input, directory, tags); err != nil {
+		return nil, err
+	}
+	return &input, nil
+}
+
+func DecodeInstrumentationPackageSelection(reader io.Reader, input *InstrumentationConsumerInput, directory string, tags []string) (*InstrumentationPackageSelectionProof, error) {
+	var proof InstrumentationPackageSelectionProof
+	if err := decodeInstrumentationOriginalJSON(reader, 8<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationPackageSelection(input, directory, tags, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+// The private physical source/proxy roots do not become portable identities.
+// Every original protocol/resource field and complete observed mode remain
+// bound. This digest alone authenticates neither source nor an invocation.
+func InstrumentationConsumerInputSHA256(input *InstrumentationConsumerInput) string {
+	if input == nil || input.Original == nil {
+		return ""
+	}
+	copy, original := *input, *input.Original
+	original.SourceRoot, original.ProxyGoModPath = "", ""
+	copy.Original = &original
+	return instrumentationObjectSHA(&copy)
+}
+
+func ValidateInstrumentationPackageSelection(input *InstrumentationConsumerInput, directory string, tags []string, proof *InstrumentationPackageSelectionProof) error {
+	if err := ValidateInstrumentationConsumerInput(input, directory, tags); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != InstrumentationPackageSelectionProtocol || proof.ModeProfileID != input.ID ||
+		proof.InputSHA256 != InstrumentationConsumerInputSHA256(input) || !equalDiscoveryStrings(proof.CustomTags, tags) ||
+		proof.Status != "consumer_pending" || len(proof.Packages) != 1 {
+		return fmt.Errorf("mode package selection differs from its complete independent context")
+	}
+	plan, pkg := input.Plan, proof.Packages[0]
+	if input.Original.SourceModule != "" && input.Original.SourceModule != input.Original.Module && pkg.SourceRole != "version_replace" {
+		return fmt.Errorf("mode namespace alias lacks its actual exact-version replacement role")
+	}
+	if len(plan.CgoFiles) != 0 || pkg.PackagePath != plan.PackagePath || !equalDiscoveryStrings(pkg.GoFiles, plan.GoFiles) ||
+		!equalDiscoveryStrings(pkg.CompiledGoFiles, plan.GoFiles) || !equalDiscoveryStrings(pkg.SFiles, plan.SFiles) {
+		return fmt.Errorf("mode package has changed original selection or an unproved generated/cgo source role")
+	}
+	ctx, err := instrumentationOriginalBuildContext(input.Sources, input.Observation.Early, tags, true)
+	if err != nil {
+		return err
+	}
+	macros := func(pkg PackageProof) error {
+		return ValidateInstrumentationAssemblerMacros(pkg.Macros, input, pkg.PackagePath)
+	}
+	_, _, err = validatePackageSelectionContext(input.Original, proof.Packages, plan.SFiles, nil, ctx, macros)
+	return err
+}
+
+// Go's registered asmArgs and experiment-macro rules are shared between modes.
+// Capture those actual source registrations unchanged, and separately bind
+// them to the independently observed mode environment and profile identity.
+func CaptureInstrumentationAssemblerMacros(root string, input *InstrumentationConsumerInput, packagePath string) (*AssemblerMacros, error) {
+	if input == nil || input.Plan == nil {
+		return nil, fmt.Errorf("missing actual instrumentation context")
+	}
+	if err := ValidateInstrumentationConsumerInput(input, input.Plan.PackageDirectory, input.Plan.CustomTags); err != nil {
+		return nil, err
+	}
+	proof, err := CaptureAssemblerMacros(root, input.Observation.Early.BaselineFeatures, packagePath)
+	if err != nil {
+		return nil, err
+	}
+	proof.Protocol, proof.FeatureID = instrumentationAssemblerProtocol, input.ID
+	if err := ValidateInstrumentationAssemblerMacros(proof, input, packagePath); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateInstrumentationAssemblerMacros(proof *AssemblerMacros, input *InstrumentationConsumerInput, packagePath string) error {
+	if input == nil || input.Plan == nil || input.Observation == nil {
+		return fmt.Errorf("missing independent instrumentation assembler context")
+	}
+	if err := ValidateInstrumentationConsumerInput(input, input.Plan.PackageDirectory, input.Plan.CustomTags); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != instrumentationAssemblerProtocol || proof.FeatureID != input.ID || packagePath != input.Plan.PackagePath {
+		return fmt.Errorf("assembler macros lost their actual mode/package binding")
+	}
+	// This copy validates the unchanged shared source-registration grammar;
+	// it is never emitted as an ordinary package/selection observation.
+	registration := *proof
+	registration.Protocol, registration.FeatureID = "go_source_assembler_macros_v1", input.Original.ID
+	if err := ValidateOrdinaryAssemblerMacros(&registration, input.Observation.Early.BaselineFeatures, packagePath); err != nil {
+		return err
+	}
+	early := input.Observation.Early
+	defines, err := plan9asm.GoAssemblerDefinesForEnvironment(early.Environment["GOOS"], early.Environment["GOARCH"], early.Environment)
+	if err != nil || !reflect.DeepEqual(defines, proof.Defines) || !reflect.DeepEqual(defines, input.Observation.Routing.AssemblerDefines) {
+		return fmt.Errorf("assembler definitions differ from the actual mode environment/routing")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_consumer_go127_test.go b/gotoolprofile/instrumentation_consumer_go127_test.go
new file mode 100644
index 000000000..a1720bb89
--- /dev/null
+++ b/gotoolprofile/instrumentation_consumer_go127_test.go
@@ -0,0 +1,206 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationConsumerPackageContextCannotBecomeOrdinary(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := instrumentationOriginalFixture(t, marker.Early)
+	sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, sources, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wrapped, err := NewInstrumentationConsumerInput(input, sources, marker, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	exported, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(), input, sources, marker, plan, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := exported.Package
+	root, stderr, err := RunBounded(ctx, input.SourceRoot, os.Environ(), binary, "env", "GOROOT")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual compiler root: %v; %s", err, stderr)
+	}
+	pkg.Macros, err = CaptureInstrumentationAssemblerMacros(strings.TrimSpace(string(root)), wrapped, pkg.PackagePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof := &InstrumentationPackageSelectionProof{
+		Protocol: InstrumentationPackageSelectionProtocol, ModeProfileID: wrapped.ID,
+		InputSHA256: InstrumentationConsumerInputSHA256(wrapped), Packages: []PackageProof{pkg},
+		Status: "consumer_pending",
+	}
+	if err := ValidateInstrumentationPackageSelection(wrapped, ".", nil, proof); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidatePackageSelection(input, proof.Packages, nil); err == nil {
+		t.Fatal("mode-selected assembly passed the ordinary package reader")
+	}
+	if wrapped.ID == input.ID || !reflect.DeepEqual(wrapped.Plan.BuildFlags, []string{"-race"}) {
+		t.Fatal("mode source context was reduced to its ordinary CPU foundation")
+	}
+	data, err := json.Marshal(wrapped)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := DecodeInstrumentationConsumerInput(strings.NewReader(string(data)), ".", nil); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{string(data) + "{}", strings.Replace(string(data), "\"protocol\":", "\"unknown\":true,\"protocol\":", 1)} {
+		if _, err := DecodeInstrumentationConsumerInput(strings.NewReader(invalid), ".", nil); err == nil {
+			t.Fatal("mode wrapper accepted unknown fields or trailing JSON")
+		}
+	}
+	for name, mutate := range map[string]func(*InstrumentationConsumerInput){
+		"missing protocol":       func(p *InstrumentationConsumerInput) { p.Protocol = "" },
+		"ordinary protocol":      func(p *InstrumentationConsumerInput) { p.Protocol = ConsumerProtocol },
+		"ordinary ID":            func(p *InstrumentationConsumerInput) { p.ID = p.Original.ID },
+		"missing mode":           func(p *InstrumentationConsumerInput) { p.Observation = nil },
+		"early only":             func(p *InstrumentationConsumerInput) { p.Observation.Routing = nil },
+		"missing ignored source": func(p *InstrumentationConsumerInput) { delete(p.Sources.Contents, "mode_msan.s") },
+		"changed original protocol": func(p *InstrumentationConsumerInput) {
+			p.Original.TestDependencySourceProtocol = TestDependencyProtocol
+		},
+		"CGO substitution":       func(p *InstrumentationConsumerInput) { p.Observation.Early.CGOEnabled = "1" },
+		"mode as tag":            func(p *InstrumentationConsumerInput) { p.Plan.CustomTags = []string{"race"} },
+		"missing selected scope": func(p *InstrumentationConsumerInput) { p.Plan.SFiles = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var p InstrumentationConsumerInput
+			if err := json.Unmarshal(data, &p); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&p)
+			if err := ValidateInstrumentationConsumerInput(&p, ".", nil); err == nil {
+				t.Fatal("accepted changed or downgraded mode context")
+			}
+		})
+	}
+	selection, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := DecodeInstrumentationPackageSelection(strings.NewReader(string(selection)), wrapped, ".", nil); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{string(selection) + "{}", strings.Replace(string(selection), "\"protocol\":", "\"unknown\":true,\"protocol\":", 1)} {
+		if _, err := DecodeInstrumentationPackageSelection(strings.NewReader(invalid), wrapped, ".", nil); err == nil {
+			t.Fatal("mode package reader accepted unknown fields or trailing JSON")
+		}
+	}
+	if _, err := DecodeInstrumentationPackageSelection(strings.NewReader(string(selection)), wrapped, ".", []string{"foreign"}); err == nil {
+		t.Fatal("mode package reader accepted a foreign independently requested tag scope")
+	}
+	for name, mutate := range map[string]func(*InstrumentationPackageSelectionProof){
+		"ordinary protocol":     func(p *InstrumentationPackageSelectionProof) { p.Protocol = ConsumerProtocol },
+		"ordinary ID":           func(p *InstrumentationPackageSelectionProof) { p.ModeProfileID = input.ID },
+		"missing input binding": func(p *InstrumentationPackageSelectionProof) { p.InputSHA256 = "" },
+		"ordinary macros": func(p *InstrumentationPackageSelectionProof) {
+			p.Packages[0].Macros.FeatureID = input.ID
+			p.Packages[0].Macros.Protocol = "go_source_assembler_macros_v1"
+		},
+		"wrong Go":          func(p *InstrumentationPackageSelectionProof) { p.Packages[0].GoFiles = []string{"base.go"} },
+		"wrong compiled Go": func(p *InstrumentationPackageSelectionProof) { p.Packages[0].CompiledGoFiles = []string{"base.go"} },
+		"missing ASM":       func(p *InstrumentationPackageSelectionProof) { p.Packages[0].SFiles = nil },
+		"missing package":   func(p *InstrumentationPackageSelectionProof) { p.Packages = nil },
+		"claim pass":        func(p *InstrumentationPackageSelectionProof) { p.Status = "passed" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var p InstrumentationPackageSelectionProof
+			if err := json.Unmarshal(selection, &p); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&p)
+			if err := ValidateInstrumentationPackageSelection(wrapped, ".", nil, &p); err == nil {
+				t.Fatal("accepted changed or downgraded actual package context")
+			}
+		})
+	}
+}
+
+func TestInstrumentationConsumerActualExclusiveModeSourceContexts(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, config := range []struct {
+		target string
+		mode   InstrumentationMode
+		cgo    string
+	}{
+		{"darwin/arm64", InstrumentationRace, "1"},
+		{"linux/arm64", InstrumentationMSan, "1"},
+		{"linux/arm64", InstrumentationASan, "1"},
+	} {
+		t.Run(config.target+"/"+string(config.mode), func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), config.target, config.mode, config.cgo, nil, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input := instrumentationOriginalFixture(t, marker.Early)
+			sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			plan, err := PlanInstrumentationOriginalPackage(input, sources, marker.Early, ".", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			wrapped, err := NewInstrumentationConsumerInput(input, sources, marker, plan)
+			if err != nil {
+				t.Fatal(err)
+			}
+			exported, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(), input, sources, marker, plan, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := exported.Package
+			root, stderr, err := RunBounded(ctx, input.SourceRoot, os.Environ(), binary, "env", "GOROOT")
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual compiler root: %v; %s", err, stderr)
+			}
+			pkg.Macros, err = CaptureInstrumentationAssemblerMacros(strings.TrimSpace(string(root)), wrapped, pkg.PackagePath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof := &InstrumentationPackageSelectionProof{
+				Protocol: InstrumentationPackageSelectionProtocol, ModeProfileID: wrapped.ID,
+				InputSHA256: InstrumentationConsumerInputSHA256(wrapped), Packages: []PackageProof{pkg}, Status: "consumer_pending",
+			}
+			if err := ValidateInstrumentationPackageSelection(wrapped, ".", nil, proof); err != nil {
+				t.Fatal(err)
+			}
+			if proof.Status != "consumer_pending" || wrapped.Observation.Early.Environment["CGO_ENABLED"] != config.cgo ||
+				wrapped.ID == input.ID || pkg.Macros.Protocol == "go_source_assembler_macros_v1" {
+				t.Fatal("mode package context lost its independently observed CGO/mode role")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_consumer_test.go b/gotoolprofile/instrumentation_consumer_test.go
new file mode 100644
index 000000000..0ff32c527
--- /dev/null
+++ b/gotoolprofile/instrumentation_consumer_test.go
@@ -0,0 +1,31 @@
+package gotoolprofile
+
+import (
+	"strings"
+	"testing"
+)
+
+// These malformed-context cases run in the root's historical Go matrix too.
+// Current-Go actual exports belong in the separately versioned oracle file.
+func TestInstrumentationConsumerRequiresCompleteSeparateProtocol(t *testing.T) {
+	if _, err := NewInstrumentationConsumerInput(nil, nil, nil, nil); err == nil {
+		t.Fatal("missing original/mode inputs became a consumer context")
+	}
+	if err := ValidateInstrumentationConsumerInput(nil, ".", nil); err == nil {
+		t.Fatal("missing context validated")
+	}
+	for _, reader := range []string{"", "{}", `{"protocol":"actual_go_cpu_profile_v2"}`} {
+		if _, err := DecodeInstrumentationConsumerInput(strings.NewReader(reader), ".", nil); err == nil {
+			t.Fatal("absent/ordinary context became instrumentation evidence")
+		}
+	}
+	if _, err := DecodeInstrumentationConsumerInput(nil, ".", nil); err == nil {
+		t.Fatal("nil context reader accepted")
+	}
+	if _, err := DecodeInstrumentationPackageSelection(strings.NewReader("{}"), nil, ".", nil); err == nil {
+		t.Fatal("unbound package selection accepted")
+	}
+	if _, err := CaptureInstrumentationAssemblerMacros("", nil, ""); err == nil {
+		t.Fatal("missing mode macros acquired a source role")
+	}
+}
diff --git a/gotoolprofile/instrumentation_consumption.go b/gotoolprofile/instrumentation_consumption.go
new file mode 100644
index 000000000..80a5be832
--- /dev/null
+++ b/gotoolprofile/instrumentation_consumption.go
@@ -0,0 +1,407 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"path"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+const InstrumentationConsumptionProtocol = "actual_go_instrumentation_llvm_objects_v3"
+
+// This standalone proof establishes only the original assembly's LLVM objects.
+// There is no corpus/report hook, candidate PASS, sanitizer runtime or link
+// claim. Ordinary and instrumented protocols cannot substitute for each other.
+type InstrumentationConsumptionProof struct {
+	Protocol       string                        `json:"protocol"`
+	ModeProfileID  string                        `json:"mode_profile_id"`
+	InputSHA256    string                        `json:"input_sha256"`
+	MetadataSHA256 string                        `json:"producer_metadata_sha256"`
+	Metadata       *InstrumentationMetadataProof `json:"actual_consumer_metadata"`
+	LLVM           *InstrumentationLLVMTool      `json:"llvm_tool"`
+	Files          []InstrumentationAssemblyFile `json:"files"`
+	Status         string                        `json:"status"`
+}
+
+type InstrumentationLLVMTool struct {
+	Version string `json:"version"`
+	SHA256  string `json:"sha256"`
+	Triple  string `json:"target_triple"`
+}
+
+type InstrumentationAssemblyFile struct {
+	CPP            CPPProof                          `json:"cpp"`
+	ExpandedSource string                            `json:"expanded_source"`
+	TypedSource    string                            `json:"typed_expanded_source"`
+	Declarations   []InstrumentationDeclarationProof `json:"actual_go_declarations"`
+	InputContents  map[string]string                 `json:"active_cpp_input_contents"`
+	Output         OutputProof                       `json:"output"`
+	Artifacts      *InstrumentationLLVMArtifacts     `json:"generated_artifacts"`
+}
+
+type InstrumentationDeclarationProof struct {
+	Symbol            string          `json:"symbol"`
+	File              string          `json:"file"`
+	DeclarationSHA256 string          `json:"declaration_ast_sha256"`
+	GoType            string          `json:"go_type"`
+	Layout            json.RawMessage `json:"layout"`
+}
+
+func InstrumentationMetadataSHA256(proof *InstrumentationMetadataProof) string {
+	return instrumentationObjectSHA(proof)
+}
+
+func ValidateInstrumentationMetadataAgreement(input *InstrumentationConsumerInput, expected, actual *InstrumentationMetadataProof, directory string, tags []string) error {
+	for _, proof := range []*InstrumentationMetadataProof{expected, actual} {
+		if err := ValidateInstrumentationMetadata(input, directory, tags, proof); err != nil {
+			return err
+		}
+	}
+	normalize := func(proof *InstrumentationMetadataProof) (*InstrumentationMetadataProof, error) {
+		copy, err := compactInstrumentationMetadataLayouts(proof)
+		if err != nil {
+			return nil, err
+		}
+		copy.Headers = append([]InstrumentationGeneratedHeader(nil), proof.Headers...)
+		for index := range copy.Headers {
+			copy.Headers[index].Header.HeaderSHA256 = ""
+			copy.Headers[index].Header.ObjectSHA256 = ""
+		}
+		return copy, nil
+	}
+	wanted, err := normalize(expected)
+	if err != nil {
+		return err
+	}
+	observed, err := normalize(actual)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(wanted, observed) {
+		return fmt.Errorf("independent same-mode metadata selected different source/exports/full definitions or routing")
+	}
+	return nil
+}
+
+func DecodeInstrumentationConsumption(reader io.Reader, input *InstrumentationConsumerInput, producer *InstrumentationMetadataProof, llvm *InstrumentationLLVMTool, directory string, tags []string) (*InstrumentationConsumptionProof, error) {
+	var proof InstrumentationConsumptionProof
+	if err := decodeInstrumentationOriginalJSON(reader, 40<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationConsumption(input, producer, llvm, directory, tags, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+var instrumentationLLVMVersion = regexp.MustCompile(`(?m)\bLLVM version 22(?:\.|$)`)
+
+func ValidateInstrumentationConsumption(input *InstrumentationConsumerInput, producer *InstrumentationMetadataProof, llvm *InstrumentationLLVMTool, directory string, tags []string, proof *InstrumentationConsumptionProof) error {
+	if err := ValidateInstrumentationMetadata(input, directory, tags, producer); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != InstrumentationConsumptionProtocol || proof.ModeProfileID != input.ID ||
+		proof.InputSHA256 != InstrumentationConsumerInputSHA256(input) || proof.MetadataSHA256 != InstrumentationMetadataSHA256(producer) ||
+		proof.Status != "llvm_objects_only" || llvm == nil || !instrumentationLLVMVersion.MatchString(llvm.Version) ||
+		!discoverySHA256Pattern.MatchString(llvm.SHA256) || llvm.Triple == "" || llvm.Triple != instrumentationConsumptionTriple(input.Plan.Target) || !reflect.DeepEqual(proof.LLVM, llvm) {
+		return fmt.Errorf("mode consumption lacks its independent context/producer/LLVM22 tool identity")
+	}
+	if err := ValidateInstrumentationMetadataAgreement(input, producer, proof.Metadata, directory, tags); err != nil {
+		return err
+	}
+	if len(proof.Files) != len(input.Plan.SFiles) || len(proof.Files) == 0 {
+		return fmt.Errorf("mode consumption lost its complete selected assembly denominator")
+	}
+	pkg := proof.Metadata.Selection.Packages[0]
+	arch, err := instrumentationConsumptionArch(input.Plan.Target)
+	if err != nil {
+		return err
+	}
+	bytes := 0
+	artifactBudget := &InstrumentationLLVMArtifactBudget{}
+	for index, file := range proof.Files {
+		cpp := file.CPP
+		bytes += len(file.ExpandedSource) + len(file.TypedSource)
+		if cpp.File != input.Plan.SFiles[index] || len(cpp.Signatures) != 0 ||
+			len(file.ExpandedSource) > AssemblySourceByteLimit || len(file.TypedSource) > AssemblySourceByteLimit || bytes > instrumentationOriginalInventoryLimit ||
+			cpp.ExpandedSHA256 != bytesSHA256([]byte(file.ExpandedSource)) || cpp.TypedExpandedSHA256 != bytesSHA256([]byte(file.TypedSource)) ||
+			cpp.Inputs["module/"+cpp.File] != input.Original.Sources[cpp.File] {
+			return fmt.Errorf("mode CPP differs from its original scope/actual source or has an unproved role")
+		}
+		if err := replayInstrumentationCPP(input, pkg, proof.Metadata, file); err != nil {
+			return err
+		}
+		for origin, digest := range cpp.Inputs {
+			kind, name, present := strings.Cut(origin, "/")
+			wanted := input.Original.Sources[name]
+			if kind == "tool" {
+				wanted = input.Original.ToolSources[name]
+			}
+			if kind == "generated" && name == pkg.PackagePath+"/go_asm.h" {
+				data, err := CanonicalGeneratedHeader(proof.Metadata.Headers[0].Header.Definitions)
+				if err != nil {
+					return err
+				}
+				wanted = bytesSHA256(data)
+			}
+			if !present || kind != "module" && kind != "tool" && kind != "generated" || wanted == "" || digest != wanted {
+				return fmt.Errorf("mode CPP read an unbound original/header resource")
+			}
+		}
+		parsed, err := validateInstrumentationAssemblyEmission(input, pkg, file, arch)
+		if err != nil {
+			return err
+		}
+		if err := replayInstrumentationDeclarationLayouts(input, pkg, file.Declarations); err != nil {
+			return err
+		}
+		for ordinal, fn := range parsed.Funcs {
+			symbol := instrumentationResolvedSymbol(pkg.PackagePath, fn.Sym)
+			if err := validateInstrumentationDeclaration(input, pkg, symbol, file.Declarations[ordinal]); err != nil {
+				return err
+			}
+			found := false
+			for _, expected := range proof.Metadata.Declarations {
+				if expected.Symbol == symbol {
+					wanted, err := compactInstrumentationDeclarationLayout(expected)
+					if err != nil {
+						return err
+					}
+					actual, err := compactInstrumentationDeclarationLayout(file.Declarations[ordinal])
+					if err != nil {
+						return err
+					}
+					found = reflect.DeepEqual(wanted, actual)
+				}
+			}
+			if !found {
+				return fmt.Errorf("mode LLVM layout differs from the independent actual typed Go metadata")
+			}
+		}
+		output := file.Output
+		if output.File != cpp.File || path.Base(output.Part) != output.Part || !strings.HasSuffix(output.Part, ".ll") ||
+			!discoverySHA256Pattern.MatchString(output.IR) || !discoverySHA256Pattern.MatchString(output.Object) {
+			return fmt.Errorf("mode consumption lacks its actual same-file LLVM IR/object")
+		}
+		if err := ValidateInstrumentationLLVMArtifacts(index, output, file.Artifacts, artifactBudget); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Callers first strictly decode the complete layout and replay the independent
+// original Go declaration. Only JSON whitespace is normalized: every ABI token
+// and all other declaration fields still participate in the exact comparison.
+func compactInstrumentationDeclarationLayout(proof InstrumentationDeclarationProof) (InstrumentationDeclarationProof, error) {
+	var layout bytes.Buffer
+	if err := json.Compact(&layout, proof.Layout); err != nil {
+		return InstrumentationDeclarationProof{}, err
+	}
+	proof.Layout = layout.Bytes()
+	return proof, nil
+}
+
+func compactInstrumentationMetadataLayouts(proof *InstrumentationMetadataProof) (*InstrumentationMetadataProof, error) {
+	copy := *proof
+	copy.Declarations = append([]InstrumentationDeclarationProof(nil), proof.Declarations...)
+	for index := range copy.Declarations {
+		declaration, err := compactInstrumentationDeclarationLayout(copy.Declarations[index])
+		if err != nil {
+			return nil, err
+		}
+		copy.Declarations[index] = declaration
+	}
+	return &copy, nil
+}
+
+func validateInstrumentationPackageDeclarations(input *InstrumentationConsumerInput, pkg PackageProof, declarations []InstrumentationDeclarationProof) error {
+	if declarations == nil || len(declarations) > 4096 || !sort.SliceIsSorted(declarations, func(i, j int) bool { return declarations[i].Symbol < declarations[j].Symbol }) {
+		return fmt.Errorf("mode metadata lacks complete canonical actual Go declaration layouts")
+	}
+	wanted := make(map[string]bool)
+	for _, name := range pkg.CompiledGoFiles {
+		parsed, err := parser.ParseFile(token.NewFileSet(), name, input.Sources.Contents[name], 0)
+		if err != nil {
+			return err
+		}
+		for _, declaration := range parsed.Decls {
+			fn, ok := declaration.(*ast.FuncDecl)
+			if ok && fn.Body == nil && fn.Recv == nil {
+				wanted[pkg.PackagePath+"."+fn.Name.Name] = true
+			}
+		}
+	}
+	if len(declarations) != len(wanted) {
+		return fmt.Errorf("mode metadata omitted an actual compiled bodyless declaration")
+	}
+	for _, declaration := range declarations {
+		if !wanted[declaration.Symbol] {
+			return fmt.Errorf("mode metadata changed or duplicated an actual declaration")
+		}
+		delete(wanted, declaration.Symbol)
+		if err := validateInstrumentationDeclaration(input, pkg, declaration.Symbol, declaration); err != nil {
+			return err
+		}
+	}
+	return replayInstrumentationDeclarationLayouts(input, pkg, declarations)
+}
+
+func replayInstrumentationCPP(input *InstrumentationConsumerInput, pkg PackageProof, metadata *InstrumentationMetadataProof, file InstrumentationAssemblyFile) error {
+	if len(file.InputContents) != len(file.CPP.Inputs) || len(file.InputContents) > 512 || file.TypedSource != file.ExpandedSource {
+		return fmt.Errorf("mode CPP lacks complete actual inputs or needs an unproved typed expansion")
+	}
+	total := 0
+	for id, text := range file.InputContents {
+		total += len(text)
+		if len(text) > InstrumentationCPPInputByteLimit(id) || total > instrumentationOriginalInventoryLimit || bytesSHA256([]byte(text)) != file.CPP.Inputs[id] {
+			return fmt.Errorf("mode CPP contents are changed or exceed the total byte bound")
+		}
+	}
+	read := func(id string) ([]byte, error) {
+		text, found := file.InputContents[id]
+		if !found || len(text) > InstrumentationCPPInputByteLimit(id) || bytesSHA256([]byte(text)) != file.CPP.Inputs[id] {
+			return nil, fmt.Errorf("mode CPP input contents differ from their original byte binding")
+		}
+		return []byte(text), nil
+	}
+	original := "module/" + file.CPP.File
+	source, err := read(original)
+	if err != nil || string(source) != input.Sources.Contents[file.CPP.File] {
+		return fmt.Errorf("mode CPP original assembly bytes differ from the complete source inventory")
+	}
+	if input.Original.CPPOriginals != nil {
+		header, err := CanonicalGeneratedHeader(metadata.Headers[0].Header.Definitions)
+		if err != nil {
+			return err
+		}
+		observation, used, required, err := ReplayCPPOriginal(input.Original, file.CPP.File, pkg.PackagePath, pkg.Macros.Defines, header)
+		if err != nil || file.CPP.ExpandedSearchMisses == nil || !reflect.DeepEqual(required, file.CPP.ExpandedSearchMisses) ||
+			observation.Output != file.ExpandedSource || !reflect.DeepEqual(used, file.CPP.Inputs) {
+			return fmt.Errorf("mode CPP original replay/expanded operands differ from its actual mode header and defines: %v", err)
+		}
+		return nil
+	}
+	used := map[string]bool{original: true}
+	expanded, err := plan9asm.PreprocessAssemblySource(string(source), plan9asm.AssemblyPreprocessOptions{
+		FileName: original, Defines: pkg.Macros.Defines,
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if err := RequireCPPPackageSearchMiss(input.Original, file.CPP.File, parent, name); err != nil {
+				return "", nil, err
+			}
+			module, tool, err := CPPIncludeCandidates(file.CPP.File, name)
+			if err != nil {
+				return "", nil, err
+			}
+			id := "tool/" + tool
+			if CPPLocalSource(module) && input.Original.Sources[module] != "" {
+				id = "module/" + module
+			} else if path.Clean(name) == "go_asm.h" {
+				id = "generated/" + pkg.PackagePath + "/go_asm.h"
+				data, err := CanonicalGeneratedHeader(metadata.Headers[0].Header.Definitions)
+				if err != nil || file.InputContents[id] != string(data) {
+					return "", nil, fmt.Errorf("mode generated include differs from the actual full native header")
+				}
+			}
+			data, err := read(id)
+			if err == nil {
+				used[id] = true
+			}
+			return id, data, err
+		},
+	})
+	if err != nil || expanded != file.ExpandedSource || len(used) != len(file.InputContents) {
+		return fmt.Errorf("mode CPP source-order replay differs from the complete actual graph: %v", err)
+	}
+	return nil
+}
+
+func validateInstrumentationDeclaration(input *InstrumentationConsumerInput, pkg PackageProof, symbol string, proof InstrumentationDeclarationProof) error {
+	if proof.Symbol != symbol || !strings.HasPrefix(symbol, pkg.PackagePath+".") ||
+		proof.GoType == "" || len(proof.GoType) > 4096 || strings.ContainsAny(proof.GoType, "\r\n\x00") || len(proof.Layout) > 1<<20 {
+		return fmt.Errorf("mode function lacks an exact actual Go declaration/type/layout")
+	}
+	selected := false
+	for _, name := range pkg.CompiledGoFiles {
+		selected = selected || name == proof.File
+	}
+	if !selected {
+		return fmt.Errorf("mode declaration source was not compiled by the actual Go package")
+	}
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, proof.File, input.Sources.Contents[proof.File], 0)
+	if err != nil {
+		return err
+	}
+	wanted := strings.TrimPrefix(symbol, pkg.PackagePath+".")
+	found := false
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != wanted {
+			continue
+		}
+		if found || fn.Body != nil || fn.Recv != nil {
+			return fmt.Errorf("mode function has no unique original bodyless non-method declaration")
+		}
+		found = true
+		digest, err := ASTSHA(fset, fn)
+		if err != nil || digest != proof.DeclarationSHA256 {
+			return fmt.Errorf("mode declaration differs from the original selected AST")
+		}
+	}
+	var sig plan9asm.FuncSig
+	if err := decodeInstrumentationOriginalJSON(strings.NewReader(string(proof.Layout)), 1<<20, &sig); err != nil {
+		return err
+	}
+	if !found || sig.Name != symbol || sig.Ret == "" || sig.ARMEntry != nil || sig.WASMContext != "" || sig.WASMNative ||
+		sig.ARM64ClosureABI != nil || sig.ARM64GoRegisterABI != nil || len(sig.ArgRegs) != 0 || sig.Attrs != "" {
+		return fmt.Errorf("mode layout acquired an unproved native/hidden/register ABI")
+	}
+	return nil
+}
+
+func instrumentationResolvedSymbol(pkg, sym string) string {
+	sym = strings.TrimSuffix(sym, "(SB)")
+	if strings.HasPrefix(sym, "·") {
+		return pkg + "." + strings.TrimPrefix(sym, "·")
+	}
+	return strings.ReplaceAll(strings.ReplaceAll(sym, "∕", "/"), "·", ".")
+}
+
+func instrumentationConsumptionArch(target string) (plan9asm.Arch, error) {
+	_, arch, _ := strings.Cut(target, "/")
+	switch arch {
+	case "386", "amd64":
+		return plan9asm.ArchAMD64, nil
+	case "arm":
+		return plan9asm.ArchARM, nil
+	case "arm64":
+		return plan9asm.ArchARM64, nil
+	case "wasm":
+		return plan9asm.ArchWASM, nil
+	}
+	return "", fmt.Errorf("unknown mode object architecture")
+}
+
+// These are concrete LLVM emission routes, not an instrumentation-support
+// table. Stock Go's source rules/actual mode observation independently decide
+// target eligibility; an unbound LLVM backend route remains a real failure.
+func instrumentationConsumptionTriple(target string) string {
+	return map[string]string{
+		"linux/386": "i386-unknown-linux-gnu", "linux/amd64": "x86_64-unknown-linux-gnu",
+		"linux/arm": "armv7-unknown-linux-gnueabihf", "linux/arm64": "aarch64-unknown-linux-gnu",
+		"darwin/386": "i386-apple-macosx", "darwin/amd64": "x86_64-apple-macosx", "darwin/arm64": "arm64-apple-macosx",
+		"windows/386": "i686-pc-windows-msvc", "windows/amd64": "x86_64-pc-windows-msvc", "windows/arm64": "aarch64-pc-windows-msvc",
+		"js/wasm": "wasm32-unknown-unknown", "wasip1/wasm": "wasm32-wasi",
+	}[target]
+}
diff --git a/gotoolprofile/instrumentation_darwin_test.go b/gotoolprofile/instrumentation_darwin_test.go
new file mode 100644
index 000000000..2c7846b4d
--- /dev/null
+++ b/gotoolprofile/instrumentation_darwin_test.go
@@ -0,0 +1,61 @@
+//go:build darwin
+
+package gotoolprofile
+
+import (
+	"os"
+	"os/exec"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Darwin race does not require CGO. Unlike the early -find oracle, these
+// commands really compile/export the selected assembly and run asmdecl. There
+// is no new executable program or claim that a sanitizer runtime was executed.
+func TestInstrumentationActualGoDarwinRaceAssemblyExportAndAsmdecl(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := instrumentationMarkerDirectory(t)
+	writeInstrumentationFixture(t, directory, "go.mod", []byte("module example.invalid/instrumentation-assembly\n\ngo 1.20\n"))
+	writeInstrumentationFixture(t, directory, "base.go", []byte("package markers\n\nfunc marker()\n"))
+	for _, mode := range []string{"race", "msan", "asan"} {
+		writeInstrumentationFixture(t, directory, "mode_"+mode+".go", []byte("//go:build "+mode+"\n\npackage markers\n\nconst Mode = \""+mode+"\"\n"))
+		writeInstrumentationFixture(t, directory, "mode_"+mode+".s", []byte("//go:build "+mode+"\n\n#include \"textflag.h\"\n\nTEXT ·marker(SB), NOSPLIT, $0-0\n\tRET\n"))
+	}
+	target := "darwin/" + runtime.GOARCH
+	for _, cgo := range []string{"0", "1"} {
+		t.Run("CGO="+cgo, func(t *testing.T) {
+			env := instrumentationActualEnv(target, cgo)
+			stdout, stderr, commandErr := instrumentationActualCommand(t, directory, env, goBinary, "list", "-export", "-json", "-race", "-p=1", "-mod=readonly", ".")
+			if commandErr != nil {
+				t.Fatalf("actual Go export failed (not source N/A): %s: %v", stderr, commandErr)
+			}
+			export, goFiles, asmFiles := decodeInstrumentationAssemblySelection(t, stdout)
+			if export == "" || !reflect.DeepEqual(goFiles, []string{"base.go", "mode_race.go"}) || !reflect.DeepEqual(asmFiles, []string{"mode_race.s"}) {
+				t.Fatalf("wrong actual compile/export selection: export=%q go=%v asm=%v", export, goFiles, asmFiles)
+			}
+			if _, err := os.Stat(export); err != nil {
+				t.Fatalf("actual export is absent: %v", err)
+			}
+			nm, stderr, commandErr := instrumentationActualCommand(t, directory, env, goBinary, "tool", "nm", export)
+			if commandErr != nil || !strings.Contains(string(nm), " T example.invalid/instrumentation-assembly.marker") {
+				t.Fatalf("actual selected assembly symbol is absent: %s: %s: %v", nm, stderr, commandErr)
+			}
+			_, stderr, commandErr = instrumentationActualCommand(t, directory, env, goBinary, "vet", "-race", "-asmdecl", "-p=1", "-mod=readonly", ".")
+			if commandErr != nil {
+				t.Fatalf("actual same-mode asmdecl failed: %s: %v", stderr, commandErr)
+			}
+		})
+	}
+	if err := rules.Recheck(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/gotoolprofile/instrumentation_emission.go b/gotoolprofile/instrumentation_emission.go
new file mode 100644
index 000000000..4154c4bc6
--- /dev/null
+++ b/gotoolprofile/instrumentation_emission.go
@@ -0,0 +1,55 @@
+package gotoolprofile
+
+import (
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// These are mode-bound native source roles, not ordinary selection evidence.
+// The unchanged listing payload is reused only with the actual mode ID, tools,
+// selected source and package. Every role still needs its real LLVM object.
+func validateInstrumentationAssemblyEmission(input *InstrumentationConsumerInput, pkg PackageProof, file InstrumentationAssemblyFile, arch plan9asm.Arch) (*plan9asm.File, error) {
+	if input == nil || input.Original == nil || input.Observation == nil || input.Observation.Early == nil ||
+		input.Observation.Early.BaselineFeatures == nil || input.Observation.Early.ModeTools == nil || pkg.Macros == nil {
+		return nil, fmt.Errorf("mode emission lacks its complete independent source/tool scope")
+	}
+	cpp := file.CPP
+	parsed, parseErr := plan9asm.ParseWithDefines(arch, file.TypedSource, pkg.Macros.Defines)
+	switch cpp.Emission {
+	case "assembly":
+		if parseErr != nil || len(parsed.Funcs) == 0 || cpp.EmptyAssembly != nil || cpp.DataOnlyAssembly != nil {
+			return nil, fmt.Errorf("mode TEXT source has a contradictory or missing native role: %v", parseErr)
+		}
+	case "symbol_free":
+		if parseErr == nil || parseErr.Error() != "no TEXT directive found" || cpp.EmptyAssembly == nil || cpp.DataOnlyAssembly != nil {
+			return nil, fmt.Errorf("mode symbol-free source contradicts its actual native role")
+		}
+		parsed = &plan9asm.File{Arch: arch}
+	case "data_only":
+		if parseErr != nil || len(parsed.Funcs) != 0 || len(parsed.Globl) == 0 || cpp.EmptyAssembly != nil || cpp.DataOnlyAssembly == nil {
+			return nil, fmt.Errorf("mode data-only source contradicts its actual native role: %v", parseErr)
+		}
+		if err := ValidateDataOnlySourceSymbols(parsed, pkg.PackagePath, cpp.DataOnlyAssembly.Symbols); err != nil {
+			return nil, err
+		}
+	default:
+		return nil, fmt.Errorf("unknown mode assembly emission role")
+	}
+	if len(file.Declarations) != len(parsed.Funcs) {
+		return nil, fmt.Errorf("mode source role lost its exact consumed Go declaration count")
+	}
+	// Only these scope fields are read by the shared native-listing validators.
+	// This private projection never enters ordinary selection validation and is
+	// not returned as a new ordinary input or source capability.
+	early := input.Observation.Early
+	observed := *early.BaselineFeatures
+	observed.ToolBinarySHA256 = early.ModeTools.BinarySHA256
+	scope := ConsumerInput{ID: input.ID, Observed: &observed,
+		SignatureSourceProtocol: input.Original.SignatureSourceProtocol,
+		Sources:                 input.Original.Sources}
+	if err := ValidateEmptyAssembly(&scope, cpp, pkg); err != nil {
+		return nil, err
+	}
+	return parsed, nil
+}
diff --git a/gotoolprofile/instrumentation_emission_test.go b/gotoolprofile/instrumentation_emission_test.go
new file mode 100644
index 000000000..306deeeaa
--- /dev/null
+++ b/gotoolprofile/instrumentation_emission_test.go
@@ -0,0 +1,119 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestInstrumentationEmissionPortableRoleGrammar(t *testing.T) {
+	// Explicit unit records exercise the finite role validator only. They are
+	// not actual Go captures and cannot satisfy ValidateInstrumentationMetadata
+	// or the complete consumption/report/ledger entry points.
+	for _, name := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(name, func(t *testing.T) {
+			arch, err := instrumentationConsumptionArch("linux/" + name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			const pkgPath = "example.invalid/unit.v2"
+			pkg := PackageProof{PackagePath: pkgPath, Macros: &AssemblerMacros{}}
+			for _, source := range []string{"", "// nonzero comment\n", "DATA local<>+0(SB)/8,$41\nGLOBL local<>(SB),0,$8\n"} {
+				file := InstrumentationAssemblyFile{TypedSource: source, CPP: CPPProof{File: "source.s", Emission: "symbol_free"}}
+				input := &InstrumentationConsumerInput{ID: strings.Repeat("b", 64),
+					Original: &ConsumerInput{SignatureSourceProtocol: SignatureSourceProtocol, Sources: map[string]string{"source.s": bytesSHA256([]byte(source))}},
+					Observation: &InstrumentationExportObservation{Early: &InstrumentationEarlyObservation{
+						BaselineFeatures: &Observation{Target: "linux/" + string(arch), GoVersion: "go1.27.1"},
+						ModeTools:        &InstrumentationToolState{BinarySHA256: map[string]string{"asm": strings.Repeat("a", 64)}},
+					}},
+				}
+				native := EmptyAssemblyProof{Protocol: EmptyAssemblyProtocol, ProfileID: input.ID, File: "source.s",
+					PackagePath: pkgPath, SourceSHA256: input.Original.Sources["source.s"], Target: "linux/" + string(arch),
+					GoVersion: "go1.27.1", AsmToolSHA256: strings.Repeat("a", 64), ObjectSHA256: strings.Repeat("c", 64), ListingSHA256: bytesSHA256(nil)}
+				if strings.HasPrefix(source, "DATA") {
+					file.CPP.Emission = "data_only"
+					native.Protocol, native.ListingSHA256 = DataOnlyAssemblyProtocol, strings.Repeat("d", 64)
+					file.CPP.DataOnlyAssembly = &DataOnlyAssemblyProof{Native: native, Symbols: []DataOnlySymbol{{Name: "local", Static: true, Kind: "SDATA", Size: 8}}}
+				} else {
+					file.CPP.EmptyAssembly = &native
+				}
+				if _, err := validateInstrumentationAssemblyEmission(input, pkg, file, arch); err != nil {
+					t.Fatal(err)
+				}
+				body, err := json.Marshal(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for name, change := range map[string]func(*InstrumentationAssemblyFile){
+					"known empty object": func(f *InstrumentationAssemblyFile) {
+						if f.CPP.EmptyAssembly != nil {
+							f.CPP.EmptyAssembly.ObjectSHA256 = bytesSHA256(nil)
+						} else {
+							f.CPP.DataOnlyAssembly.Native.ObjectSHA256 = bytesSHA256(nil)
+						}
+					},
+					"missing role": func(f *InstrumentationAssemblyFile) { f.CPP.Emission = "" },
+					"paired missing native": func(f *InstrumentationAssemblyFile) {
+						f.CPP.Emission = "assembly"
+						f.CPP.EmptyAssembly = nil
+						f.CPP.DataOnlyAssembly = nil
+					},
+					"both native roles": func(f *InstrumentationAssemblyFile) {
+						f.CPP.EmptyAssembly = &native
+						f.CPP.DataOnlyAssembly = &DataOnlyAssemblyProof{Native: native}
+					},
+					"unconsumed decl": func(f *InstrumentationAssemblyFile) {
+						f.Declarations = []InstrumentationDeclarationProof{{Symbol: "unconsumed"}}
+					},
+					"malformed TEXT":      func(f *InstrumentationAssemblyFile) { f.TypedSource = "TEXT\n" },
+					"different TEXT role": func(f *InstrumentationAssemblyFile) { f.TypedSource = "TEXT ·Unexpected(SB),$0-0\nRET\n" },
+					"missing DATA":        func(f *InstrumentationAssemblyFile) { f.TypedSource = "// symbol-free\n"; f.CPP.Emission = "data_only" },
+				} {
+					t.Run(file.CPP.Emission+"/"+name, func(t *testing.T) {
+						var changed InstrumentationAssemblyFile
+						if err := json.Unmarshal(body, &changed); err != nil {
+							t.Fatal(err)
+						}
+						change(&changed)
+						if _, err := validateInstrumentationAssemblyEmission(input, pkg, changed, arch); err == nil {
+							t.Fatal("contradictory role acquired a native source permission")
+						}
+					})
+				}
+			}
+			if _, err := validateInstrumentationAssemblyEmission(nil, pkg, InstrumentationAssemblyFile{}, arch); err == nil {
+				t.Fatal("nil scope accepted")
+			}
+		})
+	}
+}
+
+func TestDataOnlySourceCompleteSymbolIdentity(t *testing.T) {
+	const pkg = "example.invalid/data.v2"
+	const source = "DATA ·A+0(SB)/8,$1\nGLOBL ·A(SB),0,$8\nGLOBL local<>(SB),0,$16\nGLOBL foreign·B(SB),0,$4\n"
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	symbols := []DataOnlySymbol{{Name: "example.invalid/data%2ev2.A", Kind: "SDATA", Size: 8}, {Name: "foreign.B", Kind: "SBSS", Size: 4}, {Name: "local", Static: true, Kind: "SBSS", Size: 16}}
+	if err := ValidateDataOnlySourceSymbols(file, pkg, symbols); err != nil {
+		t.Fatal(err)
+	}
+	for _, changed := range []string{
+		strings.Replace(source, "·A", "·Other", -1),
+		strings.Replace(source, "$16", "$17", 1),
+		strings.Replace(source, "local<>", "local", -1),
+		source + "GLOBL extra(SB),0,$1\n",
+		source + "TEXT ·Fn(SB),$0-0\nRET\n",
+	} {
+		parsed, err := plan9asm.Parse(plan9asm.ArchAMD64, changed)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := ValidateDataOnlySourceSymbols(parsed, pkg, symbols); err == nil {
+			t.Fatal("changed native symbols were accepted")
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_export.go b/gotoolprofile/instrumentation_export.go
new file mode 100644
index 000000000..a068bd6c7
--- /dev/null
+++ b/gotoolprofile/instrumentation_export.go
@@ -0,0 +1,390 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const instrumentationExportModule = "example.invalid/instrumentation-export"
+
+// InstrumentationExportObservation is a current-Go, no-import marker export
+// and asmdecl observation. It proves real compilation and a defined assembly
+// symbol under the same mode, not linking, sanitizer execution, CC/SDK
+// availability, or compilation of any external candidate. Original exporters
+// still need their independently bound package/dependency/source observations.
+type InstrumentationExportObservation struct {
+	Protocol      string                           `json:"protocol"`
+	Early         *InstrumentationEarlyObservation `json:"early"`
+	BuildPlan     *InstrumentationBuildPlan        `json:"build_plan"`
+	Routing       *InstrumentationExportRouting    `json:"routing"`
+	Selection     *InstrumentationExportSelection  `json:"selection"`
+	FixtureSHA256 map[string]string                `json:"fixture_sha256"`
+	ExportArgs    []string                         `json:"export_args"`
+	VetArgs       []string                         `json:"vet_args"`
+	ArchiveSHA256 string                           `json:"archive_sha256"`
+	NMOutput      string                           `json:"nm_output"`
+	NMSHA256      string                           `json:"nm_sha256"`
+}
+
+type InstrumentationExportSelection struct {
+	ImportPath        string   `json:"import_path"`
+	GoFiles           []string `json:"go_files"`
+	SFiles            []string `json:"s_files"`
+	IgnoredGoFiles    []string `json:"ignored_go_files"`
+	IgnoredOtherFiles []string `json:"ignored_other_files"`
+}
+
+func CaptureInstrumentationExportObservation(ctx context.Context, binary, ownedDir string, env []string, target string, mode InstrumentationMode, cgo string, overrides map[string]string, run Runner) (*InstrumentationExportObservation, error) {
+	if ctx == nil || ctx.Err() != nil || run == nil {
+		return nil, fmt.Errorf("export observation requires a live context and bounded runner")
+	}
+	if !filepath.IsAbs(ownedDir) {
+		return nil, fmt.Errorf("export observation requires an absolute owned directory")
+	}
+	ownedDir, err := sourcepath.Resolve(ownedDir)
+	if err != nil {
+		return nil, err
+	}
+	env = replaceEnv(env, map[string]string{"GOENV": "off"})
+	entries, err := os.ReadDir(ownedDir)
+	if err != nil || len(entries) != 0 {
+		return nil, fmt.Errorf("export observation requires an existing empty owned directory")
+	}
+	earlyDir, markerDir := filepath.Join(ownedDir, "early"), filepath.Join(ownedDir, "export")
+	for _, dir := range []string{earlyDir, markerDir} {
+		if err := os.Mkdir(dir, 0700); err != nil {
+			return nil, err
+		}
+	}
+	early, err := CaptureInstrumentationEarlyObservation(ctx, binary, earlyDir, env, target, mode, cgo, overrides, run)
+	if err != nil {
+		return nil, err
+	}
+	minor, _ := goMinor(early.SourceRules.GoVersion)
+	if early.Status != InstrumentationEarlyRuleAccepted || minor != 27 {
+		return nil, fmt.Errorf("marker export routing requires an eligible current Go 1.27 mode; early rejection is not export proof")
+	}
+	plan, err := DeriveInstrumentationBuildPlan(early.SourceRules, target, mode)
+	if err != nil {
+		return nil, err
+	}
+	replacements := copyInstrumentationHashes(early.Environment)
+	delete(replacements, "GOVERSION")
+	replacements["GOTOOLCHAIN"], replacements["GOWORK"], replacements["GOFLAGS"], replacements["GOPACKAGESDRIVER"] = "local", "off", "", "off"
+	modeEnv := replaceEnv(env, replacements)
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, markerDir, modeEnv, run)
+	if err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationExportEnvironment(actual, commandContext, early); err != nil {
+		return nil, err
+	}
+	before, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil || !instrumentationExportToolsMatch(before, early.ModeTools) {
+		return nil, fmt.Errorf("mode tool state changed before actual export: %v", err)
+	}
+	environment, err := captureInstrumentationExportEnvironment(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil {
+		return nil, err
+	}
+	if environment.SourceSHA256["src/cmd/go/internal/work/init.go"] != early.SourceRules.SourceSHA256["src/cmd/go/internal/work/init.go"] {
+		return nil, fmt.Errorf("marker changed-environment source differs from its actual early build plan")
+	}
+	files := instrumentationExportFixture()
+	for name, data := range files {
+		file, err := os.OpenFile(filepath.Join(markerDir, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+		if err != nil {
+			return nil, err
+		}
+		_, writeErr := file.Write(data)
+		closeErr := file.Close()
+		if writeErr != nil || closeErr != nil {
+			return nil, fmt.Errorf("write owned export marker: %v (close: %v)", writeErr, closeErr)
+		}
+	}
+	proof := &InstrumentationExportObservation{
+		Protocol: "actual_go_instrumentation_marker_export_v2", Early: early, BuildPlan: plan,
+		FixtureSHA256: instrumentationExportFixtureHashes(files),
+		ExportArgs:    instrumentationExportArgs(mode), VetArgs: instrumentationVetArgs(mode),
+	}
+	stdout, stderr, commandErr := run(ctx, markerDir, modeEnv, binary, proof.ExportArgs...)
+	if commandErr != nil {
+		return nil, fmt.Errorf("eligible same-mode actual Go export failed (not source N/A): %w", commandErr)
+	}
+	archive, selection, err := decodeInstrumentationExport(stdout, markerDir, actual["GOCACHE"], mode)
+	if err != nil {
+		return nil, err
+	}
+	proof.Selection = selection
+	proof.ArchiveSHA256, err = FileSHA256(archive)
+	if err != nil {
+		return nil, fmt.Errorf("actual export archive is absent: %w", err)
+	}
+	defines, err := plan9asm.GoAssemblerDefinesForEnvironment(actual["GOOS"], actual["GOARCH"], actual)
+	if err != nil {
+		return nil, err
+	}
+	proof.Routing, err = captureInstrumentationExportRouting(stderr, actual["GOROOT"], markerDir, archive, early.ModeTools, plan, defines, environment, actual)
+	if err != nil {
+		return nil, err
+	}
+	stdout, stderr, commandErr = run(ctx, markerDir, modeEnv, binary, "tool", "nm", archive)
+	if commandErr != nil || len(stderr) != 0 {
+		return nil, fmt.Errorf("actual exported assembly nm failed or emitted unregistered diagnostics: %v", commandErr)
+	}
+	proof.NMOutput = instrumentationExportNMOutput(string(stdout), archive, markerDir)
+	proof.NMSHA256 = bytesSHA256([]byte(proof.NMOutput))
+	stdout, stderr, commandErr = run(ctx, markerDir, modeEnv, binary, proof.VetArgs...)
+	if commandErr != nil || len(stdout) != 0 || len(stderr) != 0 {
+		return nil, fmt.Errorf("actual same-mode asmdecl failed or emitted unregistered diagnostics: %v", commandErr)
+	}
+	if err := recheckInstrumentationExportInputs(ctx, binary, markerDir, modeEnv, actual, commandContext, early, files, archive, proof.ArchiveSHA256, before, run); err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationExportEnvironmentSources(actual["GOROOT"], actual["GOVERSION"], environment); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationExportObservation(proof); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateInstrumentationExportObservation(proof *InstrumentationExportObservation) error {
+	if proof == nil || proof.Protocol != "actual_go_instrumentation_marker_export_v2" {
+		return fmt.Errorf("missing actual same-mode marker export protocol")
+	}
+	if err := ValidateInstrumentationEarlyObservation(proof.Early); err != nil {
+		return err
+	}
+	minor, _ := goMinor(proof.Early.SourceRules.GoVersion)
+	if proof.Early.Status != InstrumentationEarlyRuleAccepted || minor != 27 {
+		return fmt.Errorf("early support/rejection does not prove a current actual export")
+	}
+	if err := ValidateInstrumentationBuildPlan(proof.BuildPlan, proof.Early.SourceRules); err != nil {
+		return err
+	}
+	if proof.BuildPlan.Target != proof.Early.Target || proof.BuildPlan.Mode != proof.Early.Mode {
+		return fmt.Errorf("export build plan differs from actual mode observation")
+	}
+	defines, err := plan9asm.GoAssemblerDefinesForEnvironment(proof.Early.Environment["GOOS"], proof.Early.Environment["GOARCH"], proof.Early.Environment)
+	if err != nil {
+		return err
+	}
+	if err := validateInstrumentationExportRouting(proof.Routing, proof.BuildPlan, defines, proof.Early.Environment); err != nil {
+		return err
+	}
+	if proof.Routing.EnvironmentSource.SourceSHA256["src/cmd/go/internal/work/init.go"] != proof.Early.SourceRules.SourceSHA256["src/cmd/go/internal/work/init.go"] {
+		return fmt.Errorf("marker environment and early build-plan sources differ")
+	}
+	if !reflect.DeepEqual(proof.Selection, instrumentationExpectedExportSelection(proof.Early.Mode)) ||
+		!reflect.DeepEqual(proof.FixtureSHA256, instrumentationExportFixtureHashes(instrumentationExportFixture())) ||
+		!reflect.DeepEqual(proof.ExportArgs, instrumentationExportArgs(proof.Early.Mode)) ||
+		!reflect.DeepEqual(proof.VetArgs, instrumentationVetArgs(proof.Early.Mode)) ||
+		!discoverySHA256Pattern.MatchString(proof.ArchiveSHA256) {
+		return fmt.Errorf("export lacks its complete same-mode selected/excluded sources, archive or actual commands")
+	}
+	if len(proof.NMOutput) > commandOutputLimit || proof.NMSHA256 != bytesSHA256([]byte(proof.NMOutput)) {
+		return fmt.Errorf("exported assembly symbol observation changed or exceeded its bound")
+	}
+	return validateInstrumentationExportNM(proof.NMOutput, proof.Early.Mode)
+}
+
+func instrumentationExportFixture() map[string][]byte {
+	files := map[string][]byte{
+		"go.mod":  []byte("module " + instrumentationExportModule + "\n\ngo 1.20\n"),
+		"base.go": []byte("package markers\n\nfunc marker()\n"),
+	}
+	for _, mode := range []string{"race", "msan", "asan"} {
+		files["mode_"+mode+".go"] = []byte("//go:build " + mode + "\n\npackage markers\n\nconst Mode = \"" + mode + "\"\n")
+		files["mode_"+mode+".s"] = []byte("//go:build " + mode + "\n\n#include \"textflag.h\"\n\nTEXT ·marker(SB), NOSPLIT, $0-0\n\tRET\n")
+	}
+	return files
+}
+
+func instrumentationExportFixtureHashes(files map[string][]byte) map[string]string {
+	hashes := make(map[string]string)
+	for name, contents := range files {
+		hashes[name] = bytesSHA256(contents)
+	}
+	return hashes
+}
+
+func instrumentationExportArgs(mode InstrumentationMode) []string {
+	return []string{"list", "-a", "-x", "-export", "-json", "-p=1", "-mod=readonly", "-" + string(mode), "."}
+}
+
+func instrumentationVetArgs(mode InstrumentationMode) []string {
+	return []string{"vet", "-" + string(mode), "-asmdecl", "-p=1", "-mod=readonly", "."}
+}
+
+func instrumentationExpectedExportSelection(mode InstrumentationMode) *InstrumentationExportSelection {
+	selected := &InstrumentationExportSelection{
+		ImportPath: instrumentationExportModule, GoFiles: []string{"base.go", "mode_" + string(mode) + ".go"},
+		SFiles: []string{"mode_" + string(mode) + ".s"},
+	}
+	for _, candidate := range []string{"asan", "msan", "race"} {
+		if candidate != string(mode) {
+			selected.IgnoredGoFiles = append(selected.IgnoredGoFiles, "mode_"+candidate+".go")
+			selected.IgnoredOtherFiles = append(selected.IgnoredOtherFiles, "mode_"+candidate+".s")
+		}
+	}
+	return selected
+}
+
+func decodeInstrumentationExport(data []byte, directory, cache string, mode InstrumentationMode) (string, *InstrumentationExportSelection, error) {
+	if len(data) == 0 || len(data) > commandOutputLimit {
+		return "", nil, fmt.Errorf("missing or over-bound actual marker export JSON")
+	}
+	var pkg struct {
+		Dir, ImportPath, Name, Export, BuildID                               string
+		GoFiles, SFiles, IgnoredGoFiles, IgnoredOtherFiles                   []string
+		CgoFiles, CFiles, CXXFiles, FFiles, SwigFiles, SwigCXXFiles, Imports []string
+		Incomplete                                                           bool
+		Error                                                                json.RawMessage
+		DepsErrors                                                           []json.RawMessage
+		Module                                                               *struct {
+			Path, Version, Dir, GoMod, GoVersion string
+			Main                                 bool
+			Replace                              json.RawMessage
+		}
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	if err := decoder.Decode(&pkg); err != nil {
+		return "", nil, err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return "", nil, fmt.Errorf("actual marker export contains multiple packages or trailing output")
+	}
+	selection := &InstrumentationExportSelection{pkg.ImportPath, pkg.GoFiles, pkg.SFiles, pkg.IgnoredGoFiles, pkg.IgnoredOtherFiles}
+	if pkg.Dir != directory || pkg.Name != "markers" || pkg.BuildID == "" || pkg.Incomplete || len(pkg.Error) != 0 || len(pkg.DepsErrors) != 0 ||
+		len(pkg.CgoFiles)+len(pkg.CFiles)+len(pkg.CXXFiles)+len(pkg.FFiles)+len(pkg.SwigFiles)+len(pkg.SwigCXXFiles)+len(pkg.Imports) != 0 ||
+		pkg.Module == nil || !pkg.Module.Main || pkg.Module.Path != instrumentationExportModule || pkg.Module.Version != "" ||
+		pkg.Module.Dir != directory || pkg.Module.GoMod != filepath.Join(directory, "go.mod") || pkg.Module.GoVersion != "1.20" || len(pkg.Module.Replace) != 0 ||
+		!reflect.DeepEqual(selection, instrumentationExpectedExportSelection(mode)) {
+		return "", nil, fmt.Errorf("actual export selected incomplete, foreign or mismatched original marker sources")
+	}
+	resolvedCache, err := sourcepath.Resolve(cache)
+	if err != nil {
+		return "", nil, err
+	}
+	resolved, err := sourcepath.Resolve(pkg.Export)
+	relative, relErr := filepath.Rel(resolvedCache, resolved)
+	if err != nil || relErr != nil || !filepath.IsAbs(pkg.Export) || !filepath.IsLocal(relative) {
+		return "", nil, fmt.Errorf("actual export archive is absent or outside the observed cache")
+	}
+	return pkg.Export, selection, nil
+}
+
+func instrumentationExportNMOutput(output, archive, directory string) string {
+	// nm prints the invoked archive path verbatim, but original Go object
+	// source symbols follow objabi.AbsFile's slash convention on Windows.
+	// Replace only these exact observed roots, not arbitrary whitespace or
+	// unknown symbol names. The complete output grammar remains strict.
+	return strings.NewReplacer(
+		archive, "@export", filepath.ToSlash(archive), "@export",
+		directory, "@marker", filepath.ToSlash(directory), "@marker",
+	).Replace(output)
+}
+
+func validateInstrumentationExportNM(output string, mode InstrumentationMode) error {
+	if !strings.HasSuffix(output, "\n") || strings.ContainsAny(output, "\x00\r") {
+		return fmt.Errorf("actual export nm output is incomplete or malformed")
+	}
+	defined := 0
+	for _, line := range strings.Split(strings.TrimSuffix(output, "\n"), "\n") {
+		object, body, ok := strings.Cut(line, ":\t")
+		if !ok || object != "@export(_go_.o)" && object != "@export(mode_"+string(mode)+".o)" {
+			return fmt.Errorf("actual nm output contains an unrelated object or diagnostic")
+		}
+		fields := strings.Fields(body)
+		if len(fields) == 1 && fields[0] == "U" || len(fields) == 2 && fields[0] == "U" {
+			continue
+		}
+		if len(fields) != 3 || len(fields[1]) != 1 || !strings.Contains("TtRrDdBb?", fields[1]) {
+			return fmt.Errorf("actual nm output has an unknown symbol grammar")
+		}
+		if _, err := strconv.ParseUint(fields[0], 16, 64); err != nil {
+			return fmt.Errorf("actual nm output has an invalid symbol address")
+		}
+		if object == "@export(mode_"+string(mode)+".o)" && fields[1] == "T" && fields[2] == instrumentationExportModule+".marker" {
+			defined++
+		}
+	}
+	if defined != 1 {
+		return fmt.Errorf("actual selected assembly does not define exactly one required marker symbol")
+	}
+	return nil
+}
+
+func instrumentationExportToolsMatch(actual *discoveryFeatureToolState, bound *InstrumentationToolState) bool {
+	return bound != nil && equalDiscoveryFeatureToolStates(actual, &discoveryFeatureToolState{
+		directory: bound.Directory, digests: bound.BinarySHA256, origins: bound.BinaryOrigins,
+		routing: bound.RoutingSHA256, dispatcher: bound.DispatcherSHA256,
+	})
+}
+
+func recheckInstrumentationExportEnvironment(actual, commandContext map[string]string, early *InstrumentationEarlyObservation) error {
+	portable := copyInstrumentationHashes(actual)
+	for _, key := range []string{"GOROOT", "GOTOOLDIR", "GOCACHE"} {
+		delete(portable, key)
+	}
+	if !reflect.DeepEqual(portable, early.Environment) || !reflect.DeepEqual(commandContext, early.CommandContext) {
+		return fmt.Errorf("actual export environment differs from its independently captured mode")
+	}
+	return nil
+}
+
+func recheckInstrumentationExportInputs(ctx context.Context, binary, directory string, env []string, actual, commandContext map[string]string, early *InstrumentationEarlyObservation, files map[string][]byte, archive, archiveSHA string, before *discoveryFeatureToolState, run Runner) error {
+	after, afterContext, err := instrumentationObserverEnvironment(ctx, binary, directory, env, run)
+	if err != nil || !reflect.DeepEqual(actual, after) || !reflect.DeepEqual(commandContext, afterContext) {
+		return fmt.Errorf("actual instrumentation environment changed during export")
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(sources, early.SourceRules) {
+		return fmt.Errorf("actual instrumentation source changed during export")
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, env, actual, run)
+	if err != nil {
+		return fmt.Errorf("actual mode compiler/assembler/nm/vet routing reobservation failed during export: %w", err)
+	}
+	if !equalDiscoveryFeatureToolStates(before, tools) {
+		difference, err := instrumentationExportToolDifference(before, tools)
+		if err != nil {
+			return fmt.Errorf("actual mode compiler/assembler/nm/vet routing changed during export; summarize bound states: %w", err)
+		}
+		return fmt.Errorf("actual mode compiler/assembler/nm/vet routing changed during export: %s", difference)
+	}
+	if hash, err := FileSHA256(binary); err != nil || hash != early.BaselineFeatures.DriverSHA256 {
+		return fmt.Errorf("actual driver changed during export")
+	}
+	for name, before := range early.BaselineFeatures.ToolSourceSHA256 {
+		if hash, err := FileSHA256(filepath.Join(actual["GOROOT"], filepath.FromSlash(name))); err != nil || hash != before {
+			return fmt.Errorf("actual CPU/experiment source changed during export: %s", name)
+		}
+	}
+	if hash, err := FileSHA256(archive); err != nil || hash != archiveSHA {
+		return fmt.Errorf("actual export archive changed during nm/asmdecl")
+	}
+	entries, err := os.ReadDir(directory)
+	if err != nil || len(entries) != len(files) {
+		return fmt.Errorf("actual export marker inventory changed during compilation")
+	}
+	for name, data := range files {
+		if hash, err := FileSHA256(filepath.Join(directory, name)); err != nil || hash != bytesSHA256(data) {
+			return fmt.Errorf("actual export marker source changed during compilation: %s", name)
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_export_declaration_memo.go b/gotoolprofile/instrumentation_export_declaration_memo.go
new file mode 100644
index 000000000..368b2aab4
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_declaration_memo.go
@@ -0,0 +1,81 @@
+package gotoolprofile
+
+import "sync"
+
+// Retain only immutable output from pure parsing of exact original bytes.
+// Every caller still checks the complete SDK version, source digests, projected
+// declaration count and AST registrations. Physical captures/rechecks still
+// read all source files. This is neither a proof cache nor object evidence.
+var instrumentationExportDeclarations = newInstrumentationExportDeclarationMemo(64, 8<<20)
+
+type instrumentationExportDeclarationKey struct {
+	name, target, sourceSHA string
+}
+
+type instrumentationExportDeclarationEntry struct {
+	original string
+	result   instrumentationExportDeclarationResult
+	bytes    int
+}
+
+type instrumentationExportDeclarationMemo struct {
+	mu                   sync.Mutex
+	maxEntries, maxBytes int
+	bytes                int
+	entries              map[instrumentationExportDeclarationKey]instrumentationExportDeclarationEntry
+	order                []instrumentationExportDeclarationKey
+}
+
+func newInstrumentationExportDeclarationMemo(maxEntries, maxBytes int) *instrumentationExportDeclarationMemo {
+	return &instrumentationExportDeclarationMemo{
+		maxEntries: maxEntries, maxBytes: maxBytes,
+		entries: make(map[instrumentationExportDeclarationKey]instrumentationExportDeclarationEntry),
+	}
+}
+
+func (memo *instrumentationExportDeclarationMemo) replay(name string, data []byte, target string) (instrumentationExportDeclarationResult, error) {
+	key := instrumentationExportDeclarationKey{name, target, bytesSHA256(data)}
+	memo.mu.Lock()
+	defer memo.mu.Unlock()
+	if entry, present := memo.entries[key]; present && entry.original == string(data) {
+		return entry.result, nil
+	}
+
+	result, err := parseInstrumentationExportDeclaration(name, data, target)
+	if err != nil {
+		return result, err
+	}
+	registered, known := instrumentationExportEnvironmentRegistrations[name+"#"+target]
+	byteCount := len(data) + len(name) + len(target) + len(key.sourceSHA) + len(result.text) + len(result.digest)
+	// Unknown or changed successful parses preserve their original result but
+	// cannot occupy retained entries. Derived strings are counted as well as
+	// inputs; there are no retained mutable AST nodes or caller-owned slices.
+	if !known || result.digest != registered || memo.maxEntries <= 0 || byteCount > memo.maxBytes {
+		return result, nil
+	}
+	if entry, present := memo.entries[key]; present {
+		memo.remove(key, entry)
+	}
+	for len(memo.entries) >= memo.maxEntries || memo.bytes+byteCount > memo.maxBytes {
+		oldest := memo.order[0]
+		memo.remove(oldest, memo.entries[oldest])
+	}
+	entry := instrumentationExportDeclarationEntry{string(data), result, byteCount}
+	memo.entries[key] = entry
+	memo.order = append(memo.order, key)
+	memo.bytes += byteCount
+	return result, nil
+}
+
+func (memo *instrumentationExportDeclarationMemo) remove(key instrumentationExportDeclarationKey, entry instrumentationExportDeclarationEntry) {
+	delete(memo.entries, key)
+	memo.bytes -= entry.bytes
+	for i, existing := range memo.order {
+		if existing == key {
+			copy(memo.order[i:], memo.order[i+1:])
+			memo.order[len(memo.order)-1] = instrumentationExportDeclarationKey{}
+			memo.order = memo.order[:len(memo.order)-1]
+			break
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_declaration_memo_test.go b/gotoolprofile/instrumentation_export_declaration_memo_test.go
new file mode 100644
index 000000000..c0a69ca9c
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_declaration_memo_test.go
@@ -0,0 +1,180 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func instrumentationDeclarationMemoOriginal(t *testing.T, target string) (string, []byte) {
+	t.Helper()
+	proof := instrumentationExportEnvironmentFixture(t)
+	name := "src/cmd/go/internal/cfg/cfg.go"
+	original, present := proof.SourceDeclarations[name+"#"+target]
+	if !present {
+		t.Fatalf("missing complete fixture declaration %s", target)
+	}
+	return name, []byte("package replay\n" + original + "\n")
+}
+
+func TestInstrumentationExportDeclarationMemoMatchesParserAndOwnsBytes(t *testing.T) {
+	proof := instrumentationExportEnvironmentFixture(t)
+	memo := newInstrumentationExportDeclarationMemo(64, 8<<20)
+	for key, original := range proof.SourceDeclarations {
+		name, target, _ := strings.Cut(key, "#")
+		data := []byte("package replay\n" + original + "\n")
+		want, err := parseInstrumentationExportDeclaration(name, data, target)
+		if err != nil || want.declarations != 1 {
+			t.Fatalf("original parser: %v", err)
+		}
+		for i := 0; i < 3; i++ {
+			got, err := memo.replay(name, data, target)
+			if err != nil || got != want {
+				t.Fatalf("memo differs from original parser for %s: %v", key, err)
+			}
+		}
+		data[0] = '!'
+		if _, err := memo.replay(name, data, target); err == nil {
+			t.Fatal("changed caller bytes borrowed a prior parse")
+		}
+		got, err := memo.replay(name, []byte("package replay\n"+original+"\n"), target)
+		if err != nil || got != want {
+			t.Fatalf("caller mutated the memo's original bytes: %v", err)
+		}
+	}
+	if len(memo.entries) != len(proof.SourceDeclarations) || len(memo.order) != len(memo.entries) {
+		t.Fatal("repeated or failed inputs occupied additional entries")
+	}
+}
+
+func TestInstrumentationExportDeclarationMemoExactInputsAndDeclarationCount(t *testing.T) {
+	name, data := instrumentationDeclarationMemoOriginal(t, "EnvOrAndChanged")
+	memo := newInstrumentationExportDeclarationMemo(8, 8<<20)
+	want, err := memo.replay(name, data, "EnvOrAndChanged")
+	if err != nil {
+		t.Fatal(err)
+	}
+	key := instrumentationExportDeclarationKey{name, "EnvOrAndChanged", bytesSHA256(data)}
+	entry := memo.entries[key]
+	// Simulate an equal index with different original bytes. The index cannot
+	// replace the exact-byte comparison or supply the retained projection.
+	entry.original = strings.Repeat("x", len(data))
+	entry.result.text, entry.result.digest = "invented", "invented"
+	memo.entries[key] = entry
+	got, err := memo.replay(name, data, "EnvOrAndChanged")
+	if err != nil || got != want || len(memo.entries) != 1 {
+		t.Fatalf("index collision borrowed an unrelated result: %v", err)
+	}
+	commented := append(append([]byte(nil), data...), []byte("\n// a distinct exact original\n")...)
+	got, err = memo.replay(name, commented, "EnvOrAndChanged")
+	if err != nil || got != want || len(memo.entries) != 2 {
+		t.Fatalf("different originals were conflated: %v", err)
+	}
+	extra := append(append([]byte(nil), data...), []byte("\nfunc additional() {}\n")...)
+	got, err = memo.replay(name, extra, "EnvOrAndChanged")
+	if err != nil || got.text != want.text || got.digest != want.digest || got.declarations != 2 {
+		t.Fatalf("complete source declaration count was lost: %v", err)
+	}
+	proof := instrumentationExportEnvironmentFixture(t)
+	proof.SourceDeclarations[name+"#EnvOrAndChanged"] += "\nfunc additional() {}\n"
+	if err := validateInstrumentationExportEnvironment(proof); err == nil {
+		t.Fatal("a warmed parse authorized an additional projected declaration")
+	}
+}
+
+func TestInstrumentationExportDeclarationMemoBoundsAndNonAdmission(t *testing.T) {
+	name, data := instrumentationDeclarationMemoOriginal(t, "EnvOrAndChanged")
+	probe := newInstrumentationExportDeclarationMemo(4, 8<<20)
+	if _, err := probe.replay(name, data, "EnvOrAndChanged"); err != nil {
+		t.Fatal(err)
+	}
+	entryBytes := probe.bytes
+	for _, input := range []struct {
+		entries, bytes int
+		wantEntries    int
+	}{
+		{1, entryBytes, 1}, {1, entryBytes - 1, 0},
+		{0, entryBytes, 0}, {-1, entryBytes, 0}, {1, 0, 0},
+	} {
+		memo := newInstrumentationExportDeclarationMemo(input.entries, input.bytes)
+		for i := 0; i < 2; i++ {
+			if _, err := memo.replay(name, data, "EnvOrAndChanged"); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if len(memo.entries) != input.wantEntries || memo.bytes > input.bytes {
+			t.Fatalf("entry/original/derived-byte bound changed: %+v", input)
+		}
+	}
+	memo := newInstrumentationExportDeclarationMemo(2, 8<<20)
+	for _, target := range []string{"EnvOrAndChanged", "GOAMD64", "GOARM64"} {
+		name, data := instrumentationDeclarationMemoOriginal(t, target)
+		if _, err := memo.replay(name, data, target); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if len(memo.entries) != 2 || len(memo.order) != 2 || memo.order[0].target != "GOAMD64" || memo.order[1].target != "GOARM64" {
+		t.Fatal("entry eviction is not bounded FIFO")
+	}
+	count := memo.bytes
+	for _, input := range []struct {
+		name, target string
+		data         []byte
+		wantError    bool
+	}{
+		{"unknown.go", "EnvOrAndChanged", data, false},
+		{name, "missing", data, true},
+		{name, "EnvOrAndChanged", []byte("package replay\nfunc EnvOrAndChanged() {}\n"), false},
+		{name, "EnvOrAndChanged", []byte("package replay\nfunc EnvOrAndChanged("), true},
+		{name, "EnvOrAndChanged", append(append([]byte(nil), data...), data[len("package replay\n"):]...), true},
+	} {
+		_, err := memo.replay(input.name, input.data, input.target)
+		if (err != nil) != input.wantError || len(memo.entries) != 2 || memo.bytes != count {
+			t.Fatalf("failed or unregistered parse was retained: %+v, %v", input, err)
+		}
+	}
+	bounded := newInstrumentationExportDeclarationMemo(8, entryBytes*2-1)
+	if _, err := bounded.replay(name, data, "EnvOrAndChanged"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := bounded.replay(name, append(append([]byte(nil), data...), '\n'), "EnvOrAndChanged"); err != nil {
+		t.Fatal(err)
+	}
+	if len(bounded.entries) != 1 || len(bounded.order) != 1 || bounded.bytes > bounded.maxBytes {
+		t.Fatal("original plus derived bytes did not trigger eviction")
+	}
+}
+
+func TestInstrumentationExportDeclarationMemoConcurrentImmutableResults(t *testing.T) {
+	name, data := instrumentationDeclarationMemoOriginal(t, "EnvOrAndChanged")
+	want, err := parseInstrumentationExportDeclaration(name, data, "EnvOrAndChanged")
+	if err != nil {
+		t.Fatal(err)
+	}
+	memo := newInstrumentationExportDeclarationMemo(8, 8<<20)
+	errors := make(chan error, 16)
+	var workers sync.WaitGroup
+	for i := 0; i < 16; i++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			for j := 0; j < 16; j++ {
+				got, err := memo.replay(name, data, "EnvOrAndChanged")
+				if err != nil || got != want {
+					errors <- fmt.Errorf("concurrent original replay changed: %v", err)
+					return
+				}
+				got.text, got.digest, got.declarations = "changed", "changed", 99
+			}
+		}()
+	}
+	workers.Wait()
+	close(errors)
+	for err := range errors {
+		t.Error(err)
+	}
+	if len(memo.entries) != 1 || len(memo.order) != 1 {
+		t.Fatal("concurrent exact inputs acquired independent retained entries")
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_display.go b/gotoolprofile/instrumentation_export_display.go
new file mode 100644
index 000000000..626b27f6d
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_display.go
@@ -0,0 +1,149 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// This finite renderer is bound to the complete Go 1.27.1/1.27.2 shell.go,
+// gc.go and buildid.go registrations in InstrumentationExportEnvironment.
+// It models updateBuildID's cache-copy display as well as runOut's
+// joinUnambiguously, fmtCmd and ShowCmd, not a shell parser or normalizer for
+// arbitrary observed commands. Only a whole exact rendered marker trace may
+// be projected into the existing portable routing protocol.
+type instrumentationExportTracePaths struct {
+	work, marker, compile, asm, include, archive string
+	separator                                    string
+}
+
+func instrumentationExportPhysicalTracePaths(work, root, marker, archive string, tools *InstrumentationToolState) (instrumentationExportTracePaths, error) {
+	if tools == nil || !validDiscoveryFeatureToolDirectory(tools.Directory) {
+		return instrumentationExportTracePaths{}, fmt.Errorf("export display lacks the actual SDK host tool directory")
+	}
+	separator, suffix := "/", ""
+	if strings.HasPrefix(strings.TrimPrefix(tools.Directory, "pkg/tool/"), "windows_") {
+		separator, suffix = `\`, ".exe"
+	}
+	for _, value := range []string{work, root, marker, archive} {
+		if !instrumentationExportHostAbsolutePath(value, separator) {
+			return instrumentationExportTracePaths{}, fmt.Errorf("export display lacks an absolute actual host path")
+		}
+	}
+	paths := instrumentationExportTracePaths{work: work, marker: marker, archive: archive, separator: separator}
+	for _, item := range []struct {
+		name string
+		out  *string
+	}{{"compile", &paths.compile}, {"asm", &paths.asm}} {
+		origin := "goroot/" + tools.Directory + "/" + item.name + suffix
+		if tools.BinaryOrigins[item.name] != origin {
+			return instrumentationExportTracePaths{}, fmt.Errorf("export display has an unbound actual %s host route", item.name)
+		}
+		*item.out = strings.TrimSuffix(root, separator) + separator + strings.ReplaceAll(strings.TrimPrefix(origin, "goroot/"), "/", separator)
+	}
+	paths.include = strings.TrimSuffix(root, separator) + separator + "pkg" + separator + "include"
+	return paths, nil
+}
+
+// The producer's file/tool observers already resolve physical paths. This
+// check recognizes the bound host spelling without using the target GOOS or
+// this reader's host filepath parser. Relative and drive-relative paths fail.
+func instrumentationExportHostAbsolutePath(value, separator string) bool {
+	if value == "" || strings.ContainsAny(value, "\x00\r\n") {
+		return false
+	}
+	if separator == "/" {
+		return strings.HasPrefix(value, "/")
+	}
+	if len(value) >= 3 && value[1] == ':' && value[2] == '\\' &&
+		(value[0] >= 'A' && value[0] <= 'Z' || value[0] >= 'a' && value[0] <= 'z') {
+		return true
+	}
+	if strings.HasPrefix(value, `\\`) {
+		parts := strings.Split(strings.TrimPrefix(value, `\\`), `\`)
+		return len(parts) >= 2 && parts[0] != "" && parts[0] != "." && parts[0] != "?" && parts[1] != ""
+	}
+	return false
+}
+
+func instrumentationRenderedExportTrace(plan *InstrumentationBuildPlan, defines []string, concurrency int, environment []string, paths instrumentationExportTracePaths) string {
+	mode := string(plan.Mode)
+	objdir := strings.TrimSuffix(paths.work, paths.separator) + paths.separator + "b001" + paths.separator
+	trimpath := strings.TrimSuffix(objdir, paths.separator) + "=>"
+	asm := []string{paths.asm, "-p", instrumentationExportModule, "-trimpath", trimpath, "-I", objdir, "-I", paths.include}
+	for _, define := range defines[:2] {
+		asm = append(asm, "-D", define)
+	}
+	asm = append(asm, plan.CodegenFlags...)
+	for _, define := range defines[2:] {
+		asm = append(asm, "-D", define)
+	}
+	installSuffix := mode
+	if plan.InstrumentAdjustedBuildMode == "pie" && len(plan.CodegenFlags) == 1 {
+		installSuffix += "_" + strings.TrimPrefix(plan.CodegenFlags[0], "-")
+	}
+	compile := []string{paths.compile, "-o", objdir + "_pkg_.a", "-trimpath", trimpath, "-p", instrumentationExportModule,
+		"-lang=go1.20", "-installsuffix", installSuffix, "-buildid", "@action/@action", "-goversion", plan.GoVersion,
+		"-symabis", objdir + "symabis"}
+	if concurrency > 1 {
+		compile = append(compile, "-c="+strconv.Itoa(concurrency))
+	}
+	compile = append(compile, plan.CodegenFlags...)
+	compile = append(compile, "-"+mode, "-nolocalimports", "-importcfg", objdir+"importcfg", "-pack", "-asmhdr", objdir+"go_asm.h",
+		paths.marker+paths.separator+"base.go", paths.marker+paths.separator+"mode_"+mode+".go")
+	assembly := paths.marker + paths.separator + "mode_" + mode + ".s"
+	symabis := append(append([]string(nil), asm...), "-gensymabis", "-o", objdir+"symabis", assembly)
+	object := append(append([]string(nil), asm...), "-o", objdir+"mode_"+mode+".o", assembly)
+
+	var lines []string
+	lines = append(lines, "WORK="+paths.work)
+	scriptDir := ""
+	show := func(dir, command string) {
+		command = instrumentationExportDisplayWORK(command, paths.work)
+		if dir != "" {
+			if dir != scriptDir {
+				lines = append(lines, "cd "+instrumentationExportDisplayWORK(dir, paths.work))
+				scriptDir = dir
+			}
+			dot := " ."
+			if strings.HasSuffix(dir, paths.separator) {
+				dot += paths.separator
+			}
+			command = strings.ReplaceAll(" "+command, " "+dir, dot)[1:]
+		}
+		lines = append(lines, command)
+	}
+	show("", "mkdir -p "+objdir)
+	show("", "echo -n > "+objdir+"go_asm.h # internal")
+	show(paths.marker, instrumentationExportCommandPrefix(environment)+instrumentationExportDisplayArgs(symabis))
+	show("", "echo '# import config' > "+objdir+"importcfg # internal")
+	show(paths.marker, instrumentationExportCommandPrefix(environment)+instrumentationExportDisplayArgs(compile))
+	show(paths.marker, instrumentationExportCommandPrefix(environment)+instrumentationExportDisplayArgs(object))
+	show(paths.marker, instrumentationExportDisplayArgs([]string{"go", "tool", "pack", "r", objdir + "_pkg_.a", objdir + "mode_" + mode + ".o"})+" # internal")
+	show("", instrumentationExportDisplayArgs([]string{"go", "tool", "buildid", "-w", objdir + "_pkg_.a"})+" # internal")
+	show("", instrumentationExportDisplayArgs([]string{"cp", objdir + "_pkg_.a", paths.archive})+" # internal")
+	return strings.Join(lines, "\n") + "\n"
+}
+
+func instrumentationExportDisplayWORK(command, work string) string {
+	command = strings.ReplaceAll(command, work, "$WORK")
+	escaped := strconv.Quote(work)
+	escaped = escaped[1 : len(escaped)-1]
+	if escaped != work {
+		command = strings.ReplaceAll(command, escaped, "$WORK")
+	}
+	return command
+}
+
+func instrumentationExportDisplayArgs(args []string) string {
+	var values []string
+	for _, value := range args {
+		quoted := strconv.Quote(value)
+		if value == "" || strings.ContainsAny(value, " ()>;") || len(quoted) > len(value)+2 {
+			values = append(values, quoted)
+		} else {
+			values = append(values, value)
+		}
+	}
+	return strings.Join(values, " ")
+}
diff --git a/gotoolprofile/instrumentation_export_display_go127_test.go b/gotoolprofile/instrumentation_export_display_go127_test.go
new file mode 100644
index 000000000..f744ccbe0
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_display_go127_test.go
@@ -0,0 +1,110 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationExportActualGoQuotedOwnedPath(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	owned := filepath.Join(instrumentationMarkerDirectory(t), "owned marker with spaces")
+	if err := os.Mkdir(owned, 0700); err != nil {
+		t.Fatal(err)
+	}
+	// The final archive-cache copy is a separate command-display producer
+	// from the compiler and assembler. Exercise its actual quoting on every
+	// host, not only Windows (where each backslash also requires quoting).
+	cache := filepath.Join(t.TempDir(), "cache with spaces")
+	if err := os.Mkdir(cache, 0700); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("GOCACHE", cache)
+	var trace, nm []byte
+	run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+		stdout, stderr, err := RunBounded(ctx, dir, env, name, args...)
+		if len(args) > 2 && args[0] == "list" && args[1] == "-a" && args[2] == "-x" {
+			trace = append([]byte(nil), stderr...)
+		}
+		if len(args) == 3 && args[0] == "tool" && args[1] == "nm" {
+			nm = append([]byte(nil), stdout...)
+		}
+		return stdout, stderr, err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	proof, err := CaptureInstrumentationExportObservation(ctx, binary, owned, os.Environ(), "darwin/arm64",
+		InstrumentationRace, "0", nil, run)
+	if err != nil {
+		t.Logf("actual original export -x trace:\n%s", trace)
+		t.Logf("actual original export nm output:\n%s", nm)
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(trace), "owned marker with spaces") || !strings.Contains(string(trace), `"`) {
+		t.Fatal("actual original export did not exercise Go's quoted path command display")
+	}
+	if err := ValidateInstrumentationExportObservation(proof); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual selected SDK/target=%s/%s raw trace SHA256=%s portable routing SHA256=%s archive SHA256=%s",
+		proof.Early.SourceRules.GoVersion, proof.Early.Target, bytesSHA256(trace), proof.Routing.TraceSHA256, proof.ArchiveSHA256)
+}
+
+func TestInstrumentationExportCommandDisplayActualRegisteredSDKSource(t *testing.T) {
+	name := "src/cmd/go/internal/work/shell.go"
+	data, err := readInstrumentationRegistration(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bytesSHA256(data) != instrumentationExportEnvironmentSourceRegistration[name] {
+		t.Fatal("command display's complete actual SDK source differs from its registered primary")
+	}
+	for _, declaration := range []string{"joinUnambiguously", "fmtCmd", "ShowCmd"} {
+		text, digest, err := instrumentationExportDeclaration(name, data, declaration)
+		if err != nil || len(text) == 0 || digest != instrumentationExportEnvironmentRegistrations[name+"#"+declaration] {
+			t.Fatalf("missing complete actual display declaration %s: %v", declaration, err)
+		}
+		t.Logf("source=%s wholeSHA256=%s declaration=%s ASTSHA256=%s", name, bytesSHA256(data), declaration, digest)
+		receipt, err := json.Marshal(map[string]string{"source_ref": name + "#" + declaration, "source_declaration": text, "ast_sha256": digest})
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("GO_EXPORT_DISPLAY_SOURCE %s", receipt)
+	}
+}
+
+func TestInstrumentationExportCacheCopyActualRegisteredSDKSource(t *testing.T) {
+	const name = "src/cmd/go/internal/work/buildid.go"
+	const declaration = "updateBuildID"
+	data, err := readInstrumentationRegistration(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text, digest, err := instrumentationExportDeclaration(name, data, declaration)
+	if err != nil {
+		t.Fatal(err)
+	}
+	receipt, err := json.Marshal(map[string]string{
+		"source_ref": name + "#" + declaration, "source_sha256": bytesSHA256(data),
+		"source_declaration": text, "ast_sha256": digest,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("GO_EXPORT_CACHE_SOURCE %s", receipt)
+	if bytesSHA256(data) != instrumentationExportEnvironmentSourceRegistration[name] ||
+		digest != instrumentationExportEnvironmentRegistrations[name+"#"+declaration] {
+		t.Fatal("complete actual cache-copy producer is not registered")
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_environment.go b/gotoolprofile/instrumentation_export_environment.go
new file mode 100644
index 000000000..227f98b64
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_environment.go
@@ -0,0 +1,327 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// This is a projection of complete registered Go driver declarations, not
+// an evaluator of arbitrary source. The producer checks membership in each
+// original SDK file before and after export; replay checks every complete AST.
+// Whole-file digests authenticate the frozen producer's inputs, not a claim
+// that a JSON digest alone can prove membership in an arbitrary SDK.
+type InstrumentationExportEnvironment struct {
+	Protocol           string            `json:"protocol"`
+	GoVersion          string            `json:"go_version"`
+	SourceSHA256       map[string]string `json:"source_sha256"`
+	SourceDeclarations map[string]string `json:"source_declarations"`
+	RegistrationSHA256 map[string]string `json:"registration_ast_sha256"`
+	BootstrapText      string            `json:"bootstrap_text"`
+	GoEnvPresent       bool              `json:"go_env_present"`
+	GoEnvText          string            `json:"go_env_text"`
+}
+
+const instrumentationExportEnvironmentProtocol = "actual_go_marker_changed_environment_v1"
+const instrumentationBootstrapSource = "src/internal/buildcfg/zbootstrap.go"
+
+// Complete audited Go 1.27.1/1.27.2 driver files (byte-identical). Pinning these alongside the
+// projected ASTs prevents accepting a rewritten, self-consistent projection
+// with fabricated whole-source digests. Future SDK changes need a fresh audit.
+var instrumentationExportEnvironmentSourceRegistration = map[string]string{
+	"src/cmd/go/internal/work/buildid.go": "6de8324513d2a5f9f629e8ae7ede623d1e87ef7b826fd1441265fc845a256555",
+	"src/cmd/go/internal/work/init.go":    "cd86d5c8fecb90d9db58ed3c98d0869ff6b5220c445025051d366818859a0963",
+	"src/cmd/go/internal/cfg/cfg.go":      "8eb038ac6df168fe5af971cd768d99dd3c64224273072a4160dcc5f51eacae9d",
+	"src/cmd/go/internal/work/shell.go":   "ffc69d476c2cde44a64c26693b2c9aeb42830ac2777f9f538ef268c86d57be2f",
+	"src/cmd/go/internal/work/gc.go":      "13359b8707e78300e8e0ec880b9a8d1af4bafdf32140b56df5f041a52fbc1325",
+}
+
+var instrumentationExportEnvironmentRegistrations = map[string]string{
+	"src/cmd/go/internal/work/buildid.go#updateBuildID":   "749e831a261f6638b3dfd4e3d6f77321276dfd530a8b906b7353343db9790858",
+	"src/cmd/go/internal/cfg/cfg.go#EnvOrAndChanged":      "496696c1fba2c248d479f6a60125bdd1e349a2fc0f6936aa50c17da5ef4f416a",
+	"src/cmd/go/internal/cfg/cfg.go#GOAMD64":              "802d8ea0ab395ea9620f0b9ce1d5e07cc08c5d947238d95d54286d7a04af53ab",
+	"src/cmd/go/internal/cfg/cfg.go#GOARM64":              "5699ca3bb24f5c90ba510c5d95233e2e74858490766f7252d22574f48c667a03",
+	"src/cmd/go/internal/cfg/cfg.go#GetArchEnv":           "554cc40b196a2240051eb791af577ac2bc392178053cf24467a9a99bcaf60812",
+	"src/cmd/go/internal/cfg/cfg.go#initEnvCache":         "14d9ec4cde6592bef7e3b5f7974d11fa47d1fb5a994dce6edf4972b33ba192de",
+	"src/cmd/go/internal/cfg/cfg.go#readEnvFile":          "3f62cec3d5f6853a4035a71195610afa3ddfb223f2d35d45e2d6c3ccb485bbb0",
+	"src/cmd/go/internal/work/gc.go#asm":                  "1c61898cd98e26c4187d29b46b763e6822b0df8b44f2807a7dbe4013cdf67a20",
+	"src/cmd/go/internal/work/gc.go#gc":                   "471dec7ded9c8b4d6adb0a4e2de4230c15b18fd85cdc3d210b46aae500c68dbb",
+	"src/cmd/go/internal/work/init.go#makeCfgChangedEnv":  "fe8772618100851a770d2dcf4c66f7bdd0edf4e8800702356a6072b3322fd82e",
+	"src/cmd/go/internal/work/shell.go#runOut":            "0fd749215e983f2f31d3d0499ee765d43c36392ecffad81d16cea517dfdceb00",
+	"src/cmd/go/internal/work/shell.go#joinUnambiguously": "c91dbacb9686e257fda39fd6c12cdef6cc9482376dda3afa2b7f9faec5d1408f",
+	"src/cmd/go/internal/work/shell.go#fmtCmd":            "acfa7656780c7e4133d04f15ab17ffda57b130f7fad7890938c29268989cb117",
+	"src/cmd/go/internal/work/shell.go#ShowCmd":           "a716a83e6144f79faebfb38918bb63c156c0ad99e45f908e27acf7afa47138bd",
+}
+
+func captureInstrumentationExportEnvironment(root, version string) (*InstrumentationExportEnvironment, error) {
+	minor, err := goMinor(version)
+	if err != nil || minor != 27 {
+		return nil, fmt.Errorf("unregistered actual marker changed-environment version")
+	}
+	proof := &InstrumentationExportEnvironment{
+		Protocol: instrumentationExportEnvironmentProtocol, GoVersion: version,
+		SourceSHA256: make(map[string]string), SourceDeclarations: make(map[string]string),
+		RegistrationSHA256: make(map[string]string),
+	}
+	files := make(map[string][]byte)
+	for key := range instrumentationExportEnvironmentRegistrations {
+		name, declaration, _ := strings.Cut(key, "#")
+		data, present := files[name]
+		if !present {
+			data, err = readInstrumentationRegistration(filepath.Join(root, filepath.FromSlash(name)))
+			if err != nil {
+				return nil, fmt.Errorf("capture actual marker environment source %s: %w", name, err)
+			}
+			files[name] = data
+			proof.SourceSHA256[name] = bytesSHA256(data)
+		}
+		text, digest, err := instrumentationExportDeclaration(name, data, declaration)
+		if err != nil {
+			return nil, err
+		}
+		proof.SourceDeclarations[key], proof.RegistrationSHA256[key] = text, digest
+	}
+	data, err := readInstrumentationRegistration(filepath.Join(root, filepath.FromSlash(instrumentationBootstrapSource)))
+	if err != nil {
+		return nil, fmt.Errorf("capture actual marker architecture defaults: %w", err)
+	}
+	proof.BootstrapText = string(data)
+	proof.SourceSHA256[instrumentationBootstrapSource] = bytesSHA256(data)
+	data, err = readInstrumentationRegistration(filepath.Join(root, "go.env"))
+	if err != nil && !os.IsNotExist(err) {
+		return nil, fmt.Errorf("capture actual SDK go.env: %w", err)
+	}
+	if err == nil {
+		proof.GoEnvPresent, proof.GoEnvText = true, string(data)
+		proof.SourceSHA256["go.env"] = bytesSHA256(data)
+	}
+	if err := validateInstrumentationExportEnvironment(proof); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func instrumentationExportDeclaration(name string, data []byte, target string) (string, string, error) {
+	result, err := instrumentationExportDeclarations.replay(name, data, target)
+	return result.text, result.digest, err
+}
+
+type instrumentationExportDeclarationResult struct {
+	text, digest string
+	declarations int
+}
+
+func parseInstrumentationExportDeclaration(name string, data []byte, target string) (instrumentationExportDeclarationResult, error) {
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, name, data, 0)
+	if err != nil {
+		return instrumentationExportDeclarationResult{}, fmt.Errorf("parse marker environment source %s: %w", name, err)
+	}
+	var found ast.Node
+	for _, declaration := range file.Decls {
+		var candidate ast.Node
+		if fn, ok := declaration.(*ast.FuncDecl); ok && fn.Name.Name == target {
+			candidate = fn
+		}
+		if group, ok := declaration.(*ast.GenDecl); ok {
+			for _, spec := range group.Specs {
+				if value, ok := spec.(*ast.ValueSpec); ok && len(value.Names) > 0 && value.Names[0].Name == target {
+					candidate = value
+				}
+			}
+		}
+		if candidate != nil {
+			if found != nil {
+				return instrumentationExportDeclarationResult{}, fmt.Errorf("duplicate registered marker environment declaration: %s#%s", name, target)
+			}
+			found = candidate
+		}
+	}
+	if found == nil {
+		return instrumentationExportDeclarationResult{}, fmt.Errorf("missing registered marker environment declaration: %s#%s", name, target)
+	}
+	digest, err := ASTSHA(set, found)
+	if err != nil {
+		return instrumentationExportDeclarationResult{}, err
+	}
+	var out bytes.Buffer
+	if _, ok := found.(*ast.ValueSpec); ok {
+		out.WriteString("var ")
+	}
+	if err := format.Node(&out, set, found); err != nil {
+		return instrumentationExportDeclarationResult{}, err
+	}
+	return instrumentationExportDeclarationResult{out.String(), digest, len(file.Decls)}, nil
+}
+
+func recheckInstrumentationExportEnvironmentSources(root, version string, before *InstrumentationExportEnvironment) error {
+	if err := validateInstrumentationExportEnvironment(before); err != nil {
+		return err
+	}
+	after, err := captureInstrumentationExportEnvironment(root, version)
+	if err != nil || !reflect.DeepEqual(before, after) {
+		return fmt.Errorf("actual marker changed-environment SDK sources/defaults changed during export: %v", err)
+	}
+	return nil
+}
+
+func validateInstrumentationExportEnvironment(proof *InstrumentationExportEnvironment) error {
+	if proof == nil || proof.Protocol != instrumentationExportEnvironmentProtocol {
+		return fmt.Errorf("missing actual marker changed-environment source protocol")
+	}
+	minor, err := goMinor(proof.GoVersion)
+	if err != nil || minor != 27 || !gotoolchain.AuditedGo127(proof.GoVersion) ||
+		len(proof.SourceDeclarations) != len(instrumentationExportEnvironmentRegistrations) ||
+		!reflect.DeepEqual(proof.RegistrationSHA256, instrumentationExportEnvironmentRegistrations) {
+		return fmt.Errorf("incomplete or unregistered marker changed-environment source projections")
+	}
+	for name, registered := range instrumentationExportEnvironmentSourceRegistration {
+		if proof.SourceSHA256[name] != registered {
+			return fmt.Errorf("changed complete registered marker environment source: %s", name)
+		}
+	}
+	files := map[string]bool{instrumentationBootstrapSource: true}
+	for key, registered := range instrumentationExportEnvironmentRegistrations {
+		name, target, _ := strings.Cut(key, "#")
+		files[name] = true
+		text, present := proof.SourceDeclarations[key]
+		if !present || len(text) == 0 || len(text) > instrumentationRegistrationByteLimit {
+			return fmt.Errorf("missing or over-bound marker environment declaration: %s", key)
+		}
+		result, err := instrumentationExportDeclarations.replay(name, []byte("package replay\n"+text+"\n"), target)
+		if err != nil || result.declarations != 1 {
+			return fmt.Errorf("marker environment projection must contain exactly one complete declaration: %s", key)
+		}
+		if result.digest != registered {
+			return fmt.Errorf("changed complete marker environment declaration: %s", key)
+		}
+	}
+	if proof.GoEnvPresent {
+		files["go.env"] = true
+		if len(proof.GoEnvText) > instrumentationRegistrationByteLimit ||
+			proof.SourceSHA256["go.env"] != bytesSHA256([]byte(proof.GoEnvText)) {
+			return fmt.Errorf("changed or over-bound actual SDK go.env")
+		}
+	} else if proof.GoEnvText != "" {
+		return fmt.Errorf("absent SDK go.env carries invented content")
+	}
+	if len(proof.SourceSHA256) != len(files) {
+		return fmt.Errorf("incomplete or additional marker environment source digests")
+	}
+	for name := range files {
+		if !discoverySHA256Pattern.MatchString(proof.SourceSHA256[name]) {
+			return fmt.Errorf("missing marker environment source digest: %s", name)
+		}
+	}
+	if len(proof.BootstrapText) == 0 || len(proof.BootstrapText) > instrumentationRegistrationByteLimit ||
+		proof.SourceSHA256[instrumentationBootstrapSource] != bytesSHA256([]byte(proof.BootstrapText)) {
+		return fmt.Errorf("changed or over-bound actual architecture defaults")
+	}
+	set := token.NewFileSet()
+	bootstrap, err := parser.ParseFile(set, instrumentationBootstrapSource, proof.BootstrapText, 0)
+	if err != nil || bootstrap.Name.Name != "buildcfg" {
+		return fmt.Errorf("malformed actual architecture default source")
+	}
+	wanted := map[string]string{"DefaultGOAMD64": "v1", "DefaultGOARM64": "v8.0", "version": proof.GoVersion}
+	seen := make(map[string]bool)
+	for _, declaration := range bootstrap.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST {
+			continue
+		}
+		for _, spec := range group.Specs {
+			value, ok := spec.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 {
+				continue
+			}
+			name := value.Names[0].Name
+			expected, required := wanted[name]
+			if !required {
+				continue
+			}
+			if seen[name] || len(value.Values) != 1 {
+				return fmt.Errorf("duplicate or incomplete actual architecture default: %s", name)
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return fmt.Errorf("nonliteral actual architecture default: %s", name)
+			}
+			decoded, err := strconv.Unquote(literal.Value)
+			if err != nil || decoded != expected {
+				return fmt.Errorf("unregistered actual architecture default: %s", name)
+			}
+			seen[name] = true
+		}
+	}
+	if len(seen) != len(wanted) {
+		return fmt.Errorf("missing actual architecture defaults/version")
+	}
+	return nil
+}
+
+// The marker observer explicitly passes its captured GOOS/GOARCH, so the
+// registered makeCfgChangedEnv cannot emit either mismatch. Eligible Go 1.27
+// instrumentation targets use AMD64 or ARM64; rejected targets never export.
+func instrumentationExportCommandEnvironment(proof *InstrumentationExportEnvironment, actual map[string]string, plan *InstrumentationBuildPlan) ([]string, error) {
+	if plan == nil {
+		return nil, fmt.Errorf("missing actual marker build plan")
+	}
+	if err := validateInstrumentationExportEnvironment(proof); err != nil {
+		return nil, err
+	}
+	osName, arch, valid := strings.Cut(plan.Target, "/")
+	if !valid || actual["GOOS"] != osName || actual["GOARCH"] != arch || proof.GoVersion != plan.GoVersion {
+		return nil, fmt.Errorf("marker command environment differs from the actual target/version")
+	}
+	key, defaultValue := "", ""
+	switch arch {
+	case "amd64":
+		key, defaultValue = "GOAMD64", "v1"
+	case "arm64":
+		key, defaultValue = "GOARM64", "v8.0"
+	default:
+		return nil, fmt.Errorf("marker export architecture lacks an eligible registered environment route")
+	}
+	value, present := actual[key]
+	if !present || value == "" || strings.ContainsAny(value, "\x00\r\n") {
+		return nil, fmt.Errorf("marker export lacks its actual architecture environment")
+	}
+	// Replay readEnvFile exactly: no trimming, first '=' split, uppercase first
+	// byte, last duplicate wins. An empty SDK value is present, not absent.
+	for _, line := range strings.Split(proof.GoEnvText, "\n") {
+		at := strings.IndexByte(line, '=')
+		if at < 0 || line[0] < 'A' || line[0] > 'Z' {
+			continue
+		}
+		if line[:at] == key {
+			defaultValue = line[at+1:]
+		}
+	}
+	if value == defaultValue {
+		return nil, nil
+	}
+	return []string{key + "=" + value}, nil
+}
+
+func instrumentationExportCommandPrefix(environment []string) string {
+	var out strings.Builder
+	for _, entry := range environment {
+		key, value, _ := strings.Cut(entry, "=")
+		if strings.ContainsRune(value, '\'') {
+			out.WriteString(key + "=" + strconv.Quote(value) + " ")
+		} else {
+			out.WriteString(key + "='" + value + "' ")
+		}
+	}
+	return out.String()
+}
diff --git a/gotoolprofile/instrumentation_export_environment_go127_test.go b/gotoolprofile/instrumentation_export_environment_go127_test.go
new file mode 100644
index 000000000..0c2fffe8d
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_environment_go127_test.go
@@ -0,0 +1,125 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This exercises the production post-export file guard with unchanged actual
+// SDK bytes copied into an owned directory. It is not another Go export or
+// runtime certificate, and never changes the installed SDK.
+func TestInstrumentationExportEnvironmentActualSDKPostCaptureGuards(t *testing.T) {
+	for _, scenario := range []string{
+		"unchanged", "driver bytes", "cache-copy producer bytes", "bootstrap bytes", "bootstrap default",
+		"SDK environment bytes", "SDK environment removed",
+		"absent environment created empty", "empty environment removed",
+	} {
+		t.Run(scenario, func(t *testing.T) {
+			root := instrumentationExportOwnedSDKSourceFixture(t)
+			environmentFile := filepath.Join(root, "go.env")
+			if scenario == "absent environment created empty" {
+				if err := os.Remove(environmentFile); err != nil && !os.IsNotExist(err) {
+					t.Fatal(err)
+				}
+			}
+			if scenario == "empty environment removed" {
+				if err := os.WriteFile(environmentFile, nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			before, err := captureInstrumentationExportEnvironment(root, runtime.Version())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := recheckInstrumentationExportEnvironmentSources(root, runtime.Version(), before); err != nil {
+				t.Fatalf("unchanged actual source guard: %v", err)
+			}
+
+			switch scenario {
+			case "cache-copy producer bytes":
+				instrumentationExportRewriteOwnedFile(t, root, "src/cmd/go/internal/work/buildid.go", func(data string) string {
+					return data + "\n// changed after capture\n"
+				})
+			case "driver bytes":
+				instrumentationExportRewriteOwnedFile(t, root, "src/cmd/go/internal/work/shell.go", func(data string) string {
+					return data + "\n// changed after capture\n"
+				})
+			case "bootstrap bytes":
+				instrumentationExportRewriteOwnedFile(t, root, instrumentationBootstrapSource, func(data string) string {
+					return data + "\n// changed after capture\n"
+				})
+			case "bootstrap default":
+				instrumentationExportRewriteOwnedFile(t, root, instrumentationBootstrapSource, func(data string) string {
+					return strings.Replace(data, "`v1`", "`v2`", 1)
+				})
+			case "SDK environment bytes":
+				if err := os.WriteFile(environmentFile, []byte("GOAMD64=v2\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "SDK environment removed", "empty environment removed":
+				if err := os.Remove(environmentFile); err != nil {
+					t.Fatal(err)
+				}
+			case "absent environment created empty":
+				if err := os.WriteFile(environmentFile, nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			err = recheckInstrumentationExportEnvironmentSources(root, runtime.Version(), before)
+			if scenario == "unchanged" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil {
+				t.Fatal("post-capture SDK source/default/environment mutation was accepted")
+			}
+		})
+	}
+}
+
+func instrumentationExportOwnedSDKSourceFixture(t *testing.T) string {
+	t.Helper()
+	root := t.TempDir()
+	names := []string{instrumentationBootstrapSource, "go.env"}
+	for name := range instrumentationExportEnvironmentSourceRegistration {
+		names = append(names, name)
+	}
+	for _, name := range names {
+		data, err := readInstrumentationRegistration(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+		if name == "go.env" && os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			t.Fatal(err)
+		}
+		target := filepath.Join(root, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(target), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(target, data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	return root
+}
+
+func instrumentationExportRewriteOwnedFile(t *testing.T, root, name string, rewrite func(string) string) {
+	t.Helper()
+	filename := filepath.Join(root, filepath.FromSlash(name))
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	changed := rewrite(string(data))
+	if changed == string(data) {
+		t.Fatal("mutation did not change the actual captured source")
+	}
+	if err := os.WriteFile(filename, []byte(changed), 0600); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_environment_test.go b/gotoolprofile/instrumentation_export_environment_test.go
new file mode 100644
index 000000000..96da6608c
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_environment_test.go
@@ -0,0 +1,204 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationExportEnvironmentCompleteSourcesAndDefaults(t *testing.T) {
+	original := instrumentationExportEnvironmentFixture(t)
+	encoded, err := json.Marshal(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*InstrumentationExportEnvironment){
+		"legacy protocol": func(p *InstrumentationExportEnvironment) {
+			p.Protocol = "actual_go_instrumentation_marker_export_routing_v1"
+		},
+		"future SDK":     func(p *InstrumentationExportEnvironment) { p.GoVersion = "go1.27.4" },
+		"missing source": func(p *InstrumentationExportEnvironment) { delete(p.SourceSHA256, "src/cmd/go/internal/cfg/cfg.go") },
+		"changed complete source": func(p *InstrumentationExportEnvironment) {
+			p.SourceSHA256["src/cmd/go/internal/work/shell.go"] = strings.Repeat("0", 64)
+		},
+		"extra source": func(p *InstrumentationExportEnvironment) { p.SourceSHA256["unregistered.go"] = strings.Repeat("0", 64) },
+		"missing declaration": func(p *InstrumentationExportEnvironment) {
+			delete(p.SourceDeclarations, "src/cmd/go/internal/work/init.go#makeCfgChangedEnv")
+		},
+		"rewritten declaration and AST": func(p *InstrumentationExportEnvironment) {
+			key := "src/cmd/go/internal/cfg/cfg.go#EnvOrAndChanged"
+			p.SourceDeclarations[key] = strings.Replace(p.SourceDeclarations[key], "val != def", "val == def", 1)
+			_, p.RegistrationSHA256[key], _ = instrumentationExportDeclaration("cfg.go", []byte("package replay\n"+p.SourceDeclarations[key]), "EnvOrAndChanged")
+		},
+		"additional projected declaration": func(p *InstrumentationExportEnvironment) {
+			key := "src/cmd/go/internal/cfg/cfg.go#EnvOrAndChanged"
+			p.SourceDeclarations[key] += "\nfunc unregistered() {}\n"
+		},
+		"missing registration": func(p *InstrumentationExportEnvironment) {
+			delete(p.RegistrationSHA256, "src/cmd/go/internal/work/gc.go#gc")
+		},
+		"missing bootstrap": func(p *InstrumentationExportEnvironment) { p.BootstrapText = "" },
+		"changed bootstrap digest": func(p *InstrumentationExportEnvironment) {
+			p.SourceSHA256[instrumentationBootstrapSource] = strings.Repeat("0", 64)
+		},
+		"rewritten CPU default and digest": func(p *InstrumentationExportEnvironment) {
+			p.BootstrapText = strings.Replace(p.BootstrapText, "`v1`", "`v2`", 1)
+			p.SourceSHA256[instrumentationBootstrapSource] = bytesSHA256([]byte(p.BootstrapText))
+		},
+		"rewritten ARM default and digest": func(p *InstrumentationExportEnvironment) {
+			p.BootstrapText = strings.Replace(p.BootstrapText, "`v8.0`", "`v8.1`", 1)
+			p.SourceSHA256[instrumentationBootstrapSource] = bytesSHA256([]byte(p.BootstrapText))
+		},
+		"changed SDK env digest":  func(p *InstrumentationExportEnvironment) { p.GoEnvText += "GOAMD64=v2\n" },
+		"invented absent SDK env": func(p *InstrumentationExportEnvironment) { p.GoEnvPresent = false },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var proof InstrumentationExportEnvironment
+			if err := json.Unmarshal(encoded, &proof); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&proof)
+			if err := validateInstrumentationExportEnvironment(&proof); err == nil {
+				t.Fatal("accepted missing, fabricated or changed driver source/default evidence")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportCommandEnvironmentSDKFileSemantics(t *testing.T) {
+	for _, input := range []struct {
+		name, arch, value, sdk string
+		absent                 bool
+		want                   []string
+	}{
+		{"AMD64 default", "amd64", "v1", "", false, nil},
+		{"AMD64 v2", "amd64", "v2", "", false, []string{"GOAMD64=v2"}},
+		{"AMD64 v3", "amd64", "v3", "", false, []string{"GOAMD64=v3"}},
+		{"AMD64 v4", "amd64", "v4", "", false, []string{"GOAMD64=v4"}},
+		{"ARM64 default", "arm64", "v8.0", "", false, nil},
+		{"ARM64 v8.1", "arm64", "v8.1", "", false, []string{"GOARM64=v8.1"}},
+		{"ARM64 v9.0", "arm64", "v9.0", "", false, []string{"GOARM64=v9.0"}},
+		{"absent file", "amd64", "v2", "", true, []string{"GOAMD64=v2"}},
+		{"SDK CPU override", "amd64", "v2", "GOAMD64=v2\n", false, nil},
+		{"SDK not runtime default", "amd64", "v1", "GOAMD64=v2\n", false, []string{"GOAMD64=v1"}},
+		{"present empty SDK key", "amd64", "v1", "GOAMD64=\n", false, []string{"GOAMD64=v1"}},
+		{"last duplicate wins", "amd64", "v3", "GOAMD64=v2\nGOAMD64=v3\n", false, nil},
+		{"last empty duplicate wins", "amd64", "v1", "GOAMD64=v1\nGOAMD64=\n", false, []string{"GOAMD64=v1"}},
+		{"no trimming", "amd64", "v1", "GOAMD64=v1 \n", false, []string{"GOAMD64=v1"}},
+		{"retain CR", "amd64", "v1", "GOAMD64=v1\r\n", false, []string{"GOAMD64=v1"}},
+		{"ignore lowercase", "amd64", "v1", "goamd64=v4\n", false, nil},
+		{"ignore leading space", "amd64", "v1", " GOAMD64=v4\n", false, nil},
+		{"ignore comment", "amd64", "v1", "#GOAMD64=v4\n", false, nil},
+		{"other arch key", "amd64", "v1", "GOARM64=v8.1\n", false, nil},
+		{"ARM64 SDK override", "arm64", "v8.1", "GOARM64=v8.1", false, nil},
+	} {
+		t.Run(input.name, func(t *testing.T) {
+			proof := instrumentationExportEnvironmentFixture(t)
+			proof.GoEnvPresent, proof.GoEnvText = !input.absent, input.sdk
+			if input.absent {
+				delete(proof.SourceSHA256, "go.env")
+			} else {
+				proof.SourceSHA256["go.env"] = bytesSHA256([]byte(input.sdk))
+			}
+			key := "GOAMD64"
+			if input.arch == "arm64" {
+				key = "GOARM64"
+			}
+			plan := &InstrumentationBuildPlan{Target: "darwin/" + input.arch, GoVersion: "go1.27.1"}
+			actual := map[string]string{"GOOS": "darwin", "GOARCH": input.arch, key: input.value}
+			got, err := instrumentationExportCommandEnvironment(proof, actual, plan)
+			if err != nil || !reflect.DeepEqual(got, input.want) {
+				t.Fatalf("actual SDK changed-env model: %v %v, want %v", got, err, input.want)
+			}
+			for name, mutate := range map[string]func(map[string]string){
+				"missing target": func(m map[string]string) { delete(m, "GOARCH") },
+				"wrong target":   func(m map[string]string) { m["GOOS"] = "linux" },
+				"missing CPU":    func(m map[string]string) { delete(m, key) },
+				"empty CPU":      func(m map[string]string) { m[key] = "" },
+				"malformed CPU":  func(m map[string]string) { m[key] += "\n" },
+			} {
+				t.Run(name, func(t *testing.T) {
+					changed := copyInstrumentationHashes(actual)
+					mutate(changed)
+					if _, err := instrumentationExportCommandEnvironment(proof, changed, plan); err == nil {
+						t.Fatal("accepted changed or incomplete actual target environment")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportRoutingCPUEnvironmentCannotBeNormalizedAway(t *testing.T) {
+	for _, arch := range []string{"amd64", "arm64"} {
+		t.Run(arch, func(t *testing.T) {
+			key, value := "GOAMD64", "v2"
+			if arch == "arm64" {
+				key, value = "GOARM64", "v8.1"
+			}
+			environment := []string{key + "=" + value}
+			prefix := instrumentationExportCommandPrefix(environment)
+			actual := map[string]string{"GOOS": "darwin", "GOARCH": arch, key: value}
+			plan := &InstrumentationBuildPlan{GoVersion: "go1.27.1", Target: "darwin/" + arch, Mode: InstrumentationRace, CodegenFlags: []string{"-shared"}}
+			defines := []string{"GOOS_darwin", "GOARCH_" + arch}
+			original := &InstrumentationExportRouting{
+				Protocol: "actual_go_instrumentation_marker_export_routing_v2", CompilerConcurrency: 2,
+				AssemblerDefines: defines, CommandEnvironment: environment,
+				EnvironmentSource: instrumentationExportEnvironmentFixture(t),
+				CanonicalTrace:    instrumentationExpectedExportTrace(plan, defines, 2, environment),
+			}
+			original.TraceSHA256 = bytesSHA256([]byte(original.CanonicalTrace))
+			if err := validateInstrumentationExportRouting(original, plan, defines, actual); err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*InstrumentationExportRouting){
+				"dropped prefix": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.ReplaceAll(p.CanonicalTrace, prefix, "")
+				},
+				"only one command": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.Replace(p.CanonicalTrace, prefix, "", 1)
+				},
+				"changed CPU": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.ReplaceAll(p.CanonicalTrace, value, "bogus")
+				},
+				"wrong quotes": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.ReplaceAll(p.CanonicalTrace, prefix, key+"="+value+" ")
+				},
+				"duplicate prefix": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.Replace(p.CanonicalTrace, prefix, prefix+prefix, 1)
+				},
+				"unrelated env": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.Replace(p.CanonicalTrace, prefix, "GODEBUG='unknown' "+prefix, 1)
+				},
+				"wrong arch key": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.ReplaceAll(p.CanonicalTrace, key, "GO386")
+				},
+				"invented GOOS mismatch": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.Replace(p.CanonicalTrace, prefix, "GOOS='darwin' "+prefix, 1)
+				},
+				"env on internal pack": func(p *InstrumentationExportRouting) {
+					p.CanonicalTrace = strings.Replace(p.CanonicalTrace, "go tool pack", prefix+"go tool pack", 1)
+				},
+				"changed recorded env": func(p *InstrumentationExportRouting) { p.CommandEnvironment = []string{key + "=bogus"} },
+				"missing source":       func(p *InstrumentationExportRouting) { p.EnvironmentSource = nil },
+				"legacy protocol": func(p *InstrumentationExportRouting) {
+					p.Protocol = "actual_go_instrumentation_marker_export_routing_v1"
+				},
+			} {
+				t.Run(name, func(t *testing.T) {
+					copy := *original
+					copy.CommandEnvironment = append([]string(nil), original.CommandEnvironment...)
+					mutate(&copy)
+					copy.TraceSHA256 = bytesSHA256([]byte(copy.CanonicalTrace))
+					if err := validateInstrumentationExportRouting(&copy, plan, defines, actual); err == nil {
+						t.Fatal("normalized away a changed actual CPU command route")
+					}
+				})
+			}
+		})
+	}
+	if got := instrumentationExportCommandPrefix([]string{"KEY=value'quoted"}); got != "KEY=\"value'quoted\" " {
+		t.Fatalf("registered shell quote rule changed: %q", got)
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_go127_test.go b/gotoolprofile/instrumentation_export_go127_test.go
new file mode 100644
index 000000000..bd2d6401d
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_go127_test.go
@@ -0,0 +1,214 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+// External instrumentation capture uses the current toolchain, not the
+// historical root compatibility matrix. These are real Go library exports,
+// assembly definitions and asmdecl checks; no new program is executed.
+func TestInstrumentationExportActualGoSameModeAndReplay(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, cgo := range []string{"0", "1"} {
+		t.Run("DarwinRaceCGO="+cgo, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			proof, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, cgo, nil, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if proof.Early.Environment["CGO_ENABLED"] != cgo || proof.BuildPlan.RequestedBuildMode != "default" ||
+				proof.BuildPlan.SourceLinkMode != "pie" || len(proof.BuildPlan.CodegenFlags) != 1 ||
+				proof.BuildPlan.CodegenFlags[0] != "-shared" || !strings.Contains(proof.NMOutput, "@export(mode_race.o):") {
+				t.Fatalf("incomplete actual same-mode export: %+v", proof)
+			}
+			data, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var restored InstrumentationExportObservation
+			if err := json.Unmarshal(data, &restored); err != nil {
+				t.Fatal(err)
+			}
+			if err := ValidateInstrumentationExportObservation(&restored); err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*InstrumentationExportObservation){
+				"missing protocol":        func(p *InstrumentationExportObservation) { p.Protocol = "" },
+				"early only":              func(p *InstrumentationExportObservation) { p.Routing = nil },
+				"missing archive":         func(p *InstrumentationExportObservation) { p.ArchiveSHA256 = "" },
+				"wrong asm source":        func(p *InstrumentationExportObservation) { p.Selection.SFiles = []string{"mode_msan.s"} },
+				"missing excluded source": func(p *InstrumentationExportObservation) { p.Selection.IgnoredOtherFiles = nil },
+				"missing real asm symbol": func(p *InstrumentationExportObservation) {
+					p.NMOutput = strings.ReplaceAll(p.NMOutput, "mode_race.o", "unrelated.o")
+					p.NMSHA256 = bytesSHA256([]byte(p.NMOutput))
+				},
+				"compile as early only": func(p *InstrumentationExportObservation) { p.ExportArgs = p.Early.CommandArgs },
+				"ordinary asmdecl":      func(p *InstrumentationExportObservation) { p.VetArgs = []string{"vet", "-asmdecl", "."} },
+				"CGO foundation substitution": func(p *InstrumentationExportObservation) {
+					p.Early.CGOEnabled = "1"
+					p.Early.Environment["CGO_ENABLED"] = "0"
+				},
+				"unbound generated input": func(p *InstrumentationExportObservation) { delete(p.FixtureSHA256, "mode_race.s") },
+			} {
+				t.Run(name, func(t *testing.T) {
+					var forged InstrumentationExportObservation
+					if err := json.Unmarshal(data, &forged); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&forged)
+					if err := ValidateInstrumentationExportObservation(&forged); err == nil {
+						t.Fatal("accepted incomplete or changed actual export proof")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportFailureCannotBecomeEarlySupportOrSourceNA(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, failure := range []string{"export", "vet", "nm", "unknown trace", "source mutation"} {
+		t.Run(failure, func(t *testing.T) {
+			runner := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if len(args) > 2 && args[0] == "list" && args[1] == "-a" {
+					if failure == "export" {
+						return nil, []byte("missing SDK\n"), exec.ErrNotFound
+					}
+					stdout, stderr, err := RunBounded(ctx, dir, env, name, args...)
+					if failure == "unknown trace" {
+						stderr = append(stderr, []byte("go: warning\n")...)
+					}
+					if failure == "source mutation" {
+						if writeErr := os.WriteFile(dir+"/mode_race.s", []byte("// changed original marker\n"), 0600); writeErr != nil {
+							t.Fatal(writeErr)
+						}
+					}
+					return stdout, stderr, err
+				}
+				if len(args) > 0 && (failure == "vet" && args[0] == "vet" || failure == "nm" && args[0] == "tool" && args[len(args)-2] == "nm") {
+					return nil, []byte("missing required tool\n"), exec.ErrNotFound
+				}
+				return RunBounded(ctx, dir, env, name, args...)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			if _, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, runner); err == nil {
+				t.Fatal("failed compiler/asmdecl/tool or changed input became a completed export observation")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportActualGoModeAndTargetFamily(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, input := range []struct {
+		target string
+		mode   InstrumentationMode
+		cgo    string
+	}{
+		{"darwin/amd64", InstrumentationRace, "0"},
+		{"linux/amd64", InstrumentationRace, "1"},
+		{"linux/arm64", InstrumentationRace, "1"},
+		{"freebsd/amd64", InstrumentationRace, "1"},
+		{"windows/amd64", InstrumentationRace, "1"},
+		{"linux/amd64", InstrumentationMSan, "1"},
+		{"linux/arm64", InstrumentationMSan, "1"},
+		{"linux/amd64", InstrumentationASan, "1"},
+		{"linux/arm64", InstrumentationASan, "1"},
+	} {
+		t.Run(input.target+"/"+string(input.mode), func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			proof, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), input.target, input.mode, input.cgo, nil, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if proof.Early.Environment["CGO_ENABLED"] != input.cgo || proof.Early.Mode != input.mode || proof.Early.Target != input.target {
+				t.Fatal("another CGO/mode/target impersonated this actual library export")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportActualGoAMD64CPUFamily(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"v1", "v2", "v3", "v4"} {
+		t.Run(level, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			var actualTrace []byte
+			runner := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := RunBounded(ctx, dir, env, name, args...)
+				if len(args) > 2 && args[0] == "list" && args[1] == "-a" && args[2] == "-x" {
+					actualTrace = append([]byte(nil), stderr...)
+				}
+				return stdout, stderr, err
+			}
+			proof, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t),
+				os.Environ(), "darwin/amd64", InstrumentationRace, "0", map[string]string{"GOAMD64": level}, runner)
+			if err != nil {
+				t.Fatalf("actual same-mode CPU %s export routing: %v\n%s", level, err, actualTrace)
+			}
+			if proof.Early.Environment["GOAMD64"] != level || proof.Routing == nil ||
+				!strings.Contains(proof.Routing.CanonicalTrace, " -D GOAMD64_"+level+" ") {
+				t.Fatal("actual CPU level was lost or replaced by cumulative build tags")
+			}
+			encoded, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var replay InstrumentationExportObservation
+			if err := json.Unmarshal(encoded, &replay); err != nil {
+				t.Fatal(err)
+			}
+			if err := ValidateInstrumentationExportObservation(&replay); err != nil {
+				t.Fatalf("independent CPU mode export replay: %v", err)
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportActualGoARM64CPUFamily(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"v8.0", "v8.0,lse", "v8.1", "v8.2", "v8.4", "v9.0", "v9.1", "v9.5"} {
+		t.Run(level, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			proof, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t),
+				os.Environ(), "darwin/arm64", InstrumentationRace, "0", map[string]string{"GOARM64": level}, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if proof.Early.Environment["GOARM64"] != level {
+				t.Fatal("actual ARM64 CPU was replaced by a different assembler feature profile")
+			}
+			if err := ValidateInstrumentationExportObservation(proof); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_nm_test.go b/gotoolprofile/instrumentation_export_nm_test.go
new file mode 100644
index 000000000..591ad3e43
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_nm_test.go
@@ -0,0 +1,49 @@
+package gotoolprofile
+
+import (
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationExportNMObservedSourceSpellings(t *testing.T) {
+	root := t.TempDir()
+	archive := filepath.Join(root, "cache with spaces", "export.a")
+	directory := filepath.Join(root, "source with spaces")
+	for _, source := range []string{directory, filepath.ToSlash(directory)} {
+		output := archive + "(_go_.o):\t 42 ? gofile.." + source + "/base.go\n" +
+			archive + "(mode_race.o):\t 80 T " + instrumentationExportModule + ".marker\n"
+		normalized := instrumentationExportNMOutput(output, archive, directory)
+		if !strings.Contains(normalized, "gofile..@marker/base.go\n") {
+			t.Fatalf("captured source spelling was not normalized: %q", normalized)
+		}
+		if err := validateInstrumentationExportNM(normalized, InstrumentationRace); err != nil {
+			t.Fatalf("actual source spelling broke complete nm grammar: %v", err)
+		}
+		foreign := strings.ReplaceAll(output, source, filepath.Join(root, "unobserved source"))
+		if err := validateInstrumentationExportNM(instrumentationExportNMOutput(foreign, archive, directory), InstrumentationRace); err == nil {
+			t.Fatal("unknown source symbol text was erased into the observed marker")
+		}
+	}
+}
+
+func TestInstrumentationExportNMUndefinedSymbolGrammarIsComplete(t *testing.T) {
+	defined := "@export(mode_race.o):\t 42 T " + instrumentationExportModule + ".marker\n"
+	for _, undefined := range []string{"U", "U unresolved.symbol"} {
+		output := "@export(mode_race.o):\t " + undefined + "\n" + defined
+		if err := validateInstrumentationExportNM(output, InstrumentationRace); err != nil {
+			t.Fatalf("rejected actual Go nm undefined grammar %q: %v", undefined, err)
+		}
+	}
+	for _, body := range []string{
+		"U missing unexpected warning", "U missing error", "U two symbols", "U missing\twarning",
+		"U missing -toolchain-error", "missing U", "warning", "", "42 U missing",
+	} {
+		t.Run(strings.ReplaceAll(body, "\t", "_"), func(t *testing.T) {
+			output := "@export(mode_race.o):\t " + body + "\n" + defined
+			if err := validateInstrumentationExportNM(output, InstrumentationRace); err == nil {
+				t.Fatalf("accepted unknown nm undefined-symbol text %q", body)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_replay_cost_test.go b/gotoolprofile/instrumentation_export_replay_cost_test.go
new file mode 100644
index 000000000..4d8f6ae88
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_replay_cost_test.go
@@ -0,0 +1,68 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationExportDeclarationsRepeatedOriginalDoesNotReparse(t *testing.T) {
+	proof := instrumentationExportEnvironmentFixture(t)
+	var replayError error
+	allocations := testing.AllocsPerRun(3, func() {
+		for key, original := range proof.SourceDeclarations {
+			name, target, _ := strings.Cut(key, "#")
+			_, _, replayError = instrumentationExportDeclaration(name, []byte("package replay\n"+original+"\n"), target)
+			if replayError != nil {
+				return
+			}
+		}
+	})
+	if replayError != nil {
+		t.Fatal(replayError)
+	}
+	// All complete original declarations and their registered digests still
+	// participate. Repeating pure parsing/formatting for each mode scope does
+	// not add source authority and should not dominate the object checks.
+	t.Logf("unchanged original declaration replay allocations=%.0f", allocations)
+	if allocations > 256 {
+		t.Fatalf("repeated original declarations rebuild SDK ASTs: %.0f allocations, want <=256", allocations)
+	}
+}
+
+func TestInstrumentationExportEnvironmentRepeatedOriginalKeepsValidationBounded(t *testing.T) {
+	proof := instrumentationExportEnvironmentFixture(t)
+	var replayError error
+	allocations := testing.AllocsPerRun(3, func() {
+		replayError = validateInstrumentationExportEnvironment(proof)
+	})
+	if replayError != nil {
+		t.Fatal(replayError)
+	}
+	t.Logf("unchanged original environment validation allocations=%.0f", allocations)
+	if allocations > 1024 {
+		t.Fatalf("repeated environment validation rebuilds driver ASTs: %.0f allocations, want <=1024", allocations)
+	}
+}
+
+func BenchmarkInstrumentationExportEnvironmentRepeatedValidation(b *testing.B) {
+	data, err := os.ReadFile("testdata/instrumentation-export-environment-go1.27.1.json")
+	if err != nil {
+		b.Fatal(err)
+	}
+	var proof InstrumentationExportEnvironment
+	if err := json.Unmarshal(data, &proof); err != nil {
+		b.Fatal(err)
+	}
+	if err := validateInstrumentationExportEnvironment(&proof); err != nil {
+		b.Fatal(err)
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if err := validateInstrumentationExportEnvironment(&proof); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_tools.go b/gotoolprofile/instrumentation_export_tools.go
new file mode 100644
index 000000000..c0c75ffe0
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_tools.go
@@ -0,0 +1,77 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// This is diagnostic projection only. Exact tool-state equality remains the
+// permission guard; neither these digests nor the changed-field list authorize
+// a route. Physical directories, origins and unknown map keys are not printed.
+func instrumentationExportToolDifference(before, after *discoveryFeatureToolState) (string, error) {
+	beforeSHA, err := instrumentationExportToolStateSHA(before)
+	if err != nil {
+		return "", err
+	}
+	afterSHA, err := instrumentationExportToolStateSHA(after)
+	if err != nil {
+		return "", err
+	}
+
+	var fields []string
+	if before == nil || after == nil {
+		fields = append(fields, "state_presence")
+	} else {
+		if before.directory != after.directory {
+			fields = append(fields, "directory")
+		}
+		if before.routing != after.routing {
+			fields = append(fields, "routing_sha256")
+		}
+		if before.dispatcher != after.dispatcher {
+			fields = append(fields, "dispatcher_sha256")
+		}
+		fields = append(fields, instrumentationExportToolMapDifference("binary_sha256", before.digests, after.digests)...)
+		fields = append(fields, instrumentationExportToolMapDifference("binary_origins", before.origins, after.origins)...)
+	}
+
+	return fmt.Sprintf("fields=%s before_sha256=%s after_sha256=%s", strings.Join(fields, ","), beforeSHA, afterSHA), nil
+}
+
+func instrumentationExportToolMapDifference(field string, before, after map[string]string) []string {
+	if reflect.DeepEqual(before, after) {
+		return nil
+	}
+	fields := []string{field}
+	for _, tool := range []string{"asm", "compile", "link", "nm", "vet"} {
+		beforeValue, beforeExists := before[tool]
+		afterValue, afterExists := after[tool]
+		if beforeExists != afterExists || beforeValue != afterValue {
+			fields = append(fields, field+"["+tool+"]")
+		}
+	}
+	return fields
+}
+
+func instrumentationExportToolStateSHA(state *discoveryFeatureToolState) (string, error) {
+	// Use explicitly exported fields: directly marshaling the private state would
+	// otherwise discard its entire identity. Nil maps and states remain distinct.
+	type projection struct {
+		Directory  string
+		Digests    map[string]string
+		Origins    map[string]string
+		Routing    string
+		Dispatcher string
+	}
+	var identity *projection
+	if state != nil {
+		identity = &projection{state.directory, state.digests, state.origins, state.routing, state.dispatcher}
+	}
+	data, err := json.Marshal(identity)
+	if err != nil {
+		return "", err
+	}
+	return discoveryFeatureBytesSHA256(data), nil
+}
diff --git a/gotoolprofile/instrumentation_export_tools_test.go b/gotoolprofile/instrumentation_export_tools_test.go
new file mode 100644
index 000000000..5d7f39ae4
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_tools_test.go
@@ -0,0 +1,142 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+// These guards observe the actual selected SDK environment, registered source
+// and executable routes. The injected failures below are deliberately unknown
+// command failures, never original-Go ABI rejection or object evidence.
+func instrumentationExportRecheckFixture(t *testing.T) (context.Context, string, string, map[string]string, map[string]string, *InstrumentationEarlyObservation, *discoveryFeatureToolState) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	t.Cleanup(cancel)
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, directory, os.Environ(), RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil {
+		t.Fatal(err)
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, os.Environ(), actual, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual %s registered SDK sources and complete tool routes observed", actual["GOVERSION"])
+	return ctx, binary, directory, actual, commandContext, &InstrumentationEarlyObservation{SourceRules: sources}, tools
+}
+
+func TestInstrumentationExportRecheckRetainsUnknownSubtoolCause(t *testing.T) {
+	ctx, binary, directory, actual, commandContext, early, before := instrumentationExportRecheckFixture(t)
+	for _, tool := range []string{"nm", "vet"} {
+		for _, cause := range []error{errors.New("fixture-bound unknown tool refusal"), context.DeadlineExceeded} {
+			t.Run(tool+"/"+cause.Error(), func(t *testing.T) {
+				seen := 0
+				run := func(ctx context.Context, dir string, env []string, driver string, args ...string) ([]byte, []byte, error) {
+					if reflect.DeepEqual(args, []string{"tool", "-n", tool}) {
+						seen++
+						return nil, nil, cause
+					}
+					return RunBounded(ctx, dir, env, driver, args...)
+				}
+				err := recheckInstrumentationExportInputs(ctx, binary, directory, os.Environ(), actual, commandContext, early, nil, "", "", before, run)
+				if err == nil || seen != 1 || !errors.Is(err, cause) || !strings.Contains(err.Error(), tool) {
+					t.Fatalf("actual SDK routing guard lost its bound unknown %s cause: seen=%d error=%v", tool, seen, err)
+				}
+			})
+		}
+	}
+}
+
+func TestInstrumentationExportRecheckDescribesRoutingFieldsWithoutPaths(t *testing.T) {
+	ctx, binary, directory, actual, commandContext, early, observed := instrumentationExportRecheckFixture(t)
+	const secret = "/private/fixture-routing-identity"
+	for _, scenario := range []struct {
+		name   string
+		field  string
+		mutate func(*discoveryFeatureToolState)
+	}{
+		{"directory", "directory", func(p *discoveryFeatureToolState) { p.directory = secret }},
+		{"routing", "routing_sha256", func(p *discoveryFeatureToolState) { p.routing = strings.Repeat("0", 64) }},
+		{"dispatcher", "dispatcher_sha256", func(p *discoveryFeatureToolState) { p.dispatcher = strings.Repeat("0", 64) }},
+		{"binary", "binary_sha256[nm]", func(p *discoveryFeatureToolState) { p.digests["nm"] = strings.Repeat("0", 64) }},
+		{"origin", "binary_origins[compile]", func(p *discoveryFeatureToolState) { p.origins["compile"] = secret }},
+		{"extra_key", "binary_sha256", func(p *discoveryFeatureToolState) { p.digests[secret] = strings.Repeat("0", 64) }},
+		{"nil_map", "binary_sha256", func(p *discoveryFeatureToolState) { p.digests = nil }},
+	} {
+		t.Run(scenario.name, func(t *testing.T) {
+			before := *observed
+			before.digests = copyInstrumentationHashes(observed.digests)
+			before.origins = copyInstrumentationHashes(observed.origins)
+			scenario.mutate(&before)
+			err := recheckInstrumentationExportInputs(ctx, binary, directory, os.Environ(), actual, commandContext, early, nil, "", "", &before, RunBounded)
+			if err == nil || !strings.Contains(err.Error(), scenario.field) || !strings.Contains(err.Error(), "before_sha256=") || !strings.Contains(err.Error(), "after_sha256=") {
+				t.Fatalf("exact tool mismatch lacks a bounded field/digest diagnosis: %v", err)
+			}
+			if strings.Contains(err.Error(), secret) || strings.Contains(err.Error(), actual["GOROOT"]) || strings.Contains(err.Error(), actual["GOCACHE"]) {
+				t.Fatal("tool difference diagnostic leaked a physical route")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportToolDifferenceRetainsExactIdentityWithoutPaths(t *testing.T) {
+	const secret = "/private/fixture-routing-identity"
+	states := []*discoveryFeatureToolState{
+		nil,
+		{},
+		{digests: map[string]string{}},
+		{digests: map[string]string{"nm": ""}},
+		{digests: map[string]string{secret: ""}},
+		{origins: map[string]string{}},
+		{origins: map[string]string{"nm": ""}},
+		{directory: secret},
+		{routing: secret},
+		{dispatcher: secret},
+	}
+
+	for i, before := range states {
+		for j, after := range states {
+			beforeSHA, err := instrumentationExportToolStateSHA(before)
+			if err != nil {
+				t.Fatal(err)
+			}
+			afterSHA, err := instrumentationExportToolStateSHA(after)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if (beforeSHA == afterSHA) != (i == j) {
+				t.Fatalf("diagnostic identity discarded distinct state %d/%d", i, j)
+			}
+
+			difference, err := instrumentationExportToolDifference(before, after)
+			if err != nil || strings.Contains(difference, secret) || len(difference) > 600 {
+				t.Fatalf("unbounded or path-bearing state difference %d/%d: %q, %v", i, j, difference, err)
+			}
+		}
+	}
+
+	before := &discoveryFeatureToolState{digests: map[string]string{"asm": "a", "vet": "b"}}
+	after := &discoveryFeatureToolState{digests: map[string]string{"vet": "b", "asm": "a"}}
+	beforeSHA, err := instrumentationExportToolStateSHA(before)
+	if err != nil {
+		t.Fatal(err)
+	}
+	afterSHA, err := instrumentationExportToolStateSHA(after)
+	if err != nil || beforeSHA != afterSHA {
+		t.Fatal("map insertion order changed the diagnostic digest")
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_trace.go b/gotoolprofile/instrumentation_export_trace.go
new file mode 100644
index 000000000..1da8abc10
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_trace.go
@@ -0,0 +1,135 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// This is a deliberately finite, no-import Go 1.27 marker build trace, not a
+// parser that treats arbitrary -x stderr as commands. A changed driver trace,
+// an additional package/command or any warning fails closed. Original package
+// exporters must retain their own dependency/source observations separately.
+var instrumentationActionID = regexp.MustCompile(` -buildid ([A-Za-z0-9_-]+)/([A-Za-z0-9_-]+) `)
+var instrumentationThreads = regexp.MustCompile(` -c=([0-9]+) `)
+
+type InstrumentationExportRouting struct {
+	Protocol            string                            `json:"protocol"`
+	CanonicalTrace      string                            `json:"canonical_trace"`
+	TraceSHA256         string                            `json:"trace_sha256"`
+	CompilerConcurrency int                               `json:"compiler_concurrency"`
+	AssemblerDefines    []string                          `json:"assembler_defines"`
+	CommandEnvironment  []string                          `json:"command_environment"`
+	EnvironmentSource   *InstrumentationExportEnvironment `json:"environment_source"`
+}
+
+func captureInstrumentationExportRouting(trace []byte, root, markerDir, archive string, tools *InstrumentationToolState, plan *InstrumentationBuildPlan, defines []string, environment *InstrumentationExportEnvironment, actual map[string]string) (*InstrumentationExportRouting, error) {
+	commandEnvironment, err := instrumentationExportCommandEnvironment(environment, actual, plan)
+	if err != nil {
+		return nil, err
+	}
+	if len(defines) < 2 {
+		return nil, fmt.Errorf("export trace lacks complete actual OS/architecture definitions")
+	}
+	if len(trace) == 0 || len(trace) > commandOutputLimit || !strings.HasSuffix(string(trace), "\n") || strings.ContainsAny(string(trace), "\x00\r") {
+		return nil, fmt.Errorf("missing, malformed or over-bound actual export command trace")
+	}
+	lines := strings.Split(strings.TrimSuffix(string(trace), "\n"), "\n")
+	if !strings.HasPrefix(lines[0], "WORK=") {
+		return nil, fmt.Errorf("export trace lacks its actual stock Go work directory")
+	}
+	paths, err := instrumentationExportPhysicalTracePaths(strings.TrimPrefix(lines[0], "WORK="), root, markerDir, archive, tools)
+	if err != nil {
+		return nil, err
+	}
+	observed := string(trace)
+	ids := instrumentationActionID.FindAllStringSubmatch(observed, -1)
+	if len(ids) != 1 || ids[0][1] != ids[0][2] {
+		return nil, fmt.Errorf("actual export compiler trace has missing or inconsistent action identity")
+	}
+	observed = instrumentationActionID.ReplaceAllString(observed, " -buildid @action/@action ")
+	concurrency := 1
+	threads := instrumentationThreads.FindAllStringSubmatch(observed, -1)
+	if len(threads) > 1 {
+		return nil, fmt.Errorf("duplicated export compiler concurrency")
+	}
+	if len(threads) == 1 {
+		var err error
+		concurrency, err = strconv.Atoi(threads[0][1])
+		if err != nil || concurrency < 2 || concurrency > 256 {
+			return nil, fmt.Errorf("invalid actual export compiler concurrency")
+		}
+	}
+	if observed != instrumentationRenderedExportTrace(plan, defines, concurrency, commandEnvironment, paths) {
+		return nil, fmt.Errorf("actual export did not execute the exact source-bound host command display/routing")
+	}
+	canonical := instrumentationExpectedExportTrace(plan, defines, concurrency, commandEnvironment)
+	proof := &InstrumentationExportRouting{
+		Protocol: "actual_go_instrumentation_marker_export_routing_v2", CanonicalTrace: canonical,
+		TraceSHA256: bytesSHA256([]byte(canonical)), CompilerConcurrency: concurrency,
+		AssemblerDefines:   append([]string(nil), defines...),
+		CommandEnvironment: commandEnvironment, EnvironmentSource: environment,
+	}
+	if err := validateInstrumentationExportRouting(proof, plan, defines, actual); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func validateInstrumentationExportRouting(proof *InstrumentationExportRouting, plan *InstrumentationBuildPlan, defines []string, actual map[string]string) error {
+	if proof == nil || proof.Protocol != "actual_go_instrumentation_marker_export_routing_v2" || plan == nil ||
+		len(defines) < 2 ||
+		len(proof.CanonicalTrace) > commandOutputLimit || proof.CompilerConcurrency < 1 || proof.CompilerConcurrency > 256 ||
+		!equalDiscoveryStrings(proof.AssemblerDefines, defines) || proof.TraceSHA256 != bytesSHA256([]byte(proof.CanonicalTrace)) {
+		return fmt.Errorf("incomplete actual instrumentation export routing evidence")
+	}
+	environment, err := instrumentationExportCommandEnvironment(proof.EnvironmentSource, actual, plan)
+	if err != nil || !equalDiscoveryStrings(proof.CommandEnvironment, environment) {
+		return fmt.Errorf("marker export command environment is not bound to its actual SDK/target: %v", err)
+	}
+	if proof.CanonicalTrace != instrumentationExpectedExportTrace(plan, defines, proof.CompilerConcurrency, environment) {
+		return fmt.Errorf("actual export did not execute the complete expected same-mode compiler/assembler routing")
+	}
+	return nil
+}
+
+func instrumentationExpectedExportTrace(plan *InstrumentationBuildPlan, defines []string, concurrency int, environment []string) string {
+	mode := string(plan.Mode)
+	prefix := instrumentationExportCommandPrefix(environment)
+	base := prefix + "@asm -p " + instrumentationExportModule + ` -trimpath "$WORK/b001=>" -I $WORK/b001/ -I @include`
+	// asmArgs emits OS/architecture first, then build-mode flags, then
+	// architecture-level CPU definitions. Shared AMD64 must not silently
+	// normalize a different order into the same observed command.
+	for _, define := range defines[:2] {
+		base += " -D " + define
+	}
+	for _, flag := range plan.CodegenFlags {
+		base += " " + flag
+	}
+	for _, define := range defines[2:] {
+		base += " -D " + define
+	}
+	installSuffix := mode
+	if plan.InstrumentAdjustedBuildMode == "pie" && len(plan.CodegenFlags) == 1 {
+		installSuffix += "_" + strings.TrimPrefix(plan.CodegenFlags[0], "-")
+	}
+	compile := prefix + `@compile -o $WORK/b001/_pkg_.a -trimpath "$WORK/b001=>" -p ` + instrumentationExportModule +
+		" -lang=go1.20 -installsuffix " + installSuffix + " -buildid @action/@action -goversion " + plan.GoVersion +
+		" -symabis $WORK/b001/symabis"
+	if concurrency > 1 {
+		compile += " -c=" + strconv.Itoa(concurrency)
+	}
+	for _, flag := range plan.CodegenFlags {
+		compile += " " + flag
+	}
+	compile += " -" + mode + " -nolocalimports -importcfg $WORK/b001/importcfg -pack -asmhdr $WORK/b001/go_asm.h ./base.go ./mode_" + mode + ".go"
+	return strings.Join([]string{
+		"WORK=@work", "mkdir -p $WORK/b001/", "echo -n > $WORK/b001/go_asm.h # internal", "cd @marker",
+		base + " -gensymabis -o $WORK/b001/symabis ./mode_" + mode + ".s",
+		"echo '# import config' > $WORK/b001/importcfg # internal", compile,
+		base + " -o $WORK/b001/mode_" + mode + ".o ./mode_" + mode + ".s",
+		"go tool pack r $WORK/b001/_pkg_.a $WORK/b001/mode_" + mode + ".o # internal",
+		"go tool buildid -w $WORK/b001/_pkg_.a # internal", "cp $WORK/b001/_pkg_.a @export # internal",
+	}, "\n") + "\n"
+}
diff --git a/gotoolprofile/instrumentation_export_trace_test.go b/gotoolprofile/instrumentation_export_trace_test.go
new file mode 100644
index 000000000..445d139f4
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_trace_test.go
@@ -0,0 +1,80 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+)
+
+func instrumentationExportEnvironmentFixture(t *testing.T) *InstrumentationExportEnvironment {
+	t.Helper()
+	data, err := os.ReadFile("testdata/instrumentation-export-environment-go1.27.1.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof InstrumentationExportEnvironment
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	if err := validateInstrumentationExportEnvironment(&proof); err != nil {
+		t.Fatal(err)
+	}
+	return &proof
+}
+
+func TestInstrumentationExportRoutingRejectsMissingMixedOrChangedCommands(t *testing.T) {
+	plan := &InstrumentationBuildPlan{GoVersion: "go1.27.1", Target: "darwin/arm64", Mode: InstrumentationRace, CodegenFlags: []string{"-shared"}}
+	defines := []string{"GOOS_darwin", "GOARCH_arm64"}
+	actual := map[string]string{"GOOS": "darwin", "GOARCH": "arm64", "GOARM64": "v8.0"}
+	original := &InstrumentationExportRouting{
+		Protocol: "actual_go_instrumentation_marker_export_routing_v2", CompilerConcurrency: 2, AssemblerDefines: defines,
+		CanonicalTrace:    instrumentationExpectedExportTrace(plan, defines, 2, nil),
+		EnvironmentSource: instrumentationExportEnvironmentFixture(t),
+	}
+	original.TraceSHA256 = bytesSHA256([]byte(original.CanonicalTrace))
+	if err := validateInstrumentationExportRouting(original, plan, defines, actual); err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*InstrumentationExportRouting){
+		"warning":     func(p *InstrumentationExportRouting) { p.CanonicalTrace += "go: unknown warning\n" },
+		"mixed error": func(p *InstrumentationExportRouting) { p.CanonicalTrace += "# failed-package\nmissing SDK\n" },
+		"no compiler": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, "@compile", "@fake", 1)
+		},
+		"wrong compiler": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, "@compile", "/unrelated/compile", 1)
+		},
+		"ordinary compiler": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, " -race ", " ", 1)
+		},
+		"mode as tag": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, " -race ", " -tags=race ", 1)
+		},
+		"two modes": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, " -race ", " -race -asan ", 1)
+		},
+		"ordinary asm": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.Replace(p.CanonicalTrace, " -shared ", " ", 1)
+		},
+		"fake mode source": func(p *InstrumentationExportRouting) {
+			p.CanonicalTrace = strings.ReplaceAll(p.CanonicalTrace, "mode_race", "mode_asan")
+		},
+		"duplicate compiler": func(p *InstrumentationExportRouting) { p.CanonicalTrace += p.CanonicalTrace },
+		"stale hash":         func(p *InstrumentationExportRouting) { p.TraceSHA256 = strings.Repeat("0", 64) },
+		"changed defines":    func(p *InstrumentationExportRouting) { p.AssemblerDefines = append(p.AssemblerDefines, "RACE") },
+		"missing protocol":   func(p *InstrumentationExportRouting) { p.Protocol = "" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			copy := *original
+			copy.AssemblerDefines = append([]string(nil), original.AssemblerDefines...)
+			mutate(&copy)
+			if name != "stale hash" {
+				copy.TraceSHA256 = bytesSHA256([]byte(copy.CanonicalTrace))
+			}
+			if err := validateInstrumentationExportRouting(&copy, plan, defines, actual); err == nil {
+				t.Fatal("accepted incomplete or mismatched same-mode export routing")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_export_windows_trace_test.go b/gotoolprofile/instrumentation_export_windows_trace_test.go
new file mode 100644
index 000000000..a631ca8ec
--- /dev/null
+++ b/gotoolprofile/instrumentation_export_windows_trace_test.go
@@ -0,0 +1,204 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// This fixture is Go 1.27.1's registered command display on a Windows SDK,
+// not an observation that Windows tools or Windows runtime ran on this host.
+// runOut quotes backslashes before fmtCmd substitutes both WORK spellings;
+// ShowCmd does not replace a quoted absolute source argument with dot.
+const instrumentationWindowsExportTrace = `WORK=C:\tmp\go-build1234
+mkdir -p $WORK\b001\
+echo -n > $WORK\b001\go_asm.h # internal
+cd C:\owned task\export
+GOAMD64='v2' "C:\\Go SDK\\pkg\\tool\\windows_amd64\\asm.exe" -p example.invalid/instrumentation-export -trimpath "$WORK\\b001=>" -I "$WORK\\b001\\" -I "C:\\Go SDK\\pkg\\include" -D GOOS_linux -D GOARCH_amd64 -D GOAMD64_v2 -gensymabis -o "$WORK\\b001\\symabis" "C:\\owned task\\export\\mode_race.s"
+echo '# import config' > $WORK\b001\importcfg # internal
+GOAMD64='v2' "C:\\Go SDK\\pkg\\tool\\windows_amd64\\compile.exe" -o "$WORK\\b001\\_pkg_.a" -trimpath "$WORK\\b001=>" -p example.invalid/instrumentation-export -lang=go1.20 -installsuffix race -buildid action/action -goversion go1.27.1 -symabis "$WORK\\b001\\symabis" -c=2 -race -nolocalimports -importcfg "$WORK\\b001\\importcfg" -pack -asmhdr "$WORK\\b001\\go_asm.h" "C:\\owned task\\export\\base.go" "C:\\owned task\\export\\mode_race.go"
+GOAMD64='v2' "C:\\Go SDK\\pkg\\tool\\windows_amd64\\asm.exe" -p example.invalid/instrumentation-export -trimpath "$WORK\\b001=>" -I "$WORK\\b001\\" -I "C:\\Go SDK\\pkg\\include" -D GOOS_linux -D GOARCH_amd64 -D GOAMD64_v2 -o "$WORK\\b001\\mode_race.o" "C:\\owned task\\export\\mode_race.s"
+go tool pack r "$WORK\\b001\\_pkg_.a" "$WORK\\b001\\mode_race.o" # internal
+go tool buildid -w "$WORK\\b001\\_pkg_.a" # internal
+cp "$WORK\\b001\\_pkg_.a" "C:\\cache root\\aa\\artifact-d" # internal
+`
+
+func instrumentationWindowsTraceInputs() (*InstrumentationToolState, *InstrumentationBuildPlan, []string, map[string]string) {
+	tools := &InstrumentationToolState{
+		Directory: "pkg/tool/windows_amd64",
+		BinaryOrigins: map[string]string{
+			"asm": "goroot/pkg/tool/windows_amd64/asm.exe", "compile": "goroot/pkg/tool/windows_amd64/compile.exe",
+		},
+	}
+	plan := &InstrumentationBuildPlan{GoVersion: "go1.27.1", Target: "linux/amd64", Mode: InstrumentationRace}
+	defines := []string{"GOOS_linux", "GOARCH_amd64", "GOAMD64_v2"}
+	actual := map[string]string{"GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v2"}
+	return tools, plan, defines, actual
+}
+
+func TestInstrumentationExportRoutingWindowsSourceBoundCommandDisplay(t *testing.T) {
+	tools, plan, defines, actual := instrumentationWindowsTraceInputs()
+	proof, err := captureInstrumentationExportRouting([]byte(instrumentationWindowsExportTrace), `C:\Go SDK`,
+		`C:\owned task\export`, `C:\cache root\aa\artifact-d`, tools, plan, defines,
+		instrumentationExportEnvironmentFixture(t), actual)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := instrumentationExpectedExportTrace(plan, defines, 2, []string{"GOAMD64=v2"})
+	if proof.CanonicalTrace != expected {
+		t.Fatal("Windows display did not retain the exact portable command/target/mode denominator")
+	}
+	data, err := json.MarshalIndent(proof, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var replay InstrumentationExportRouting
+	if err := json.Unmarshal(data, &replay); err != nil {
+		t.Fatal(err)
+	}
+	if err := validateInstrumentationExportRouting(&replay, plan, defines, actual); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstrumentationExportRoutingWindowsDisplayKeepsUnknownOutputFailed(t *testing.T) {
+	for name, mutate := range map[string]func(string) string{
+		"unknown tool":              func(trace string) string { return strings.ReplaceAll(trace, "asm.exe", "unknown.exe") },
+		"missing host suffix":       func(trace string) string { return strings.ReplaceAll(trace, "compile.exe", "compile") },
+		"wrong host root":           func(trace string) string { return strings.ReplaceAll(trace, `C:\\Go SDK`, `D:\\Go SDK`) },
+		"wrong host tool directory": func(trace string) string { return strings.ReplaceAll(trace, "windows_amd64", "linux_amd64") },
+		"unregistered quoting": func(trace string) string {
+			return strings.ReplaceAll(trace, `"C:\\Go SDK\\pkg\\tool\\windows_amd64\\compile.exe"`, `'C:\Go SDK\pkg\tool\windows_amd64\compile.exe'`)
+		},
+		"quoted unknown operand": func(trace string) string {
+			return strings.ReplaceAll(trace, `"C:\\owned task\\export\\base.go"`, `"C:\\owned task\\export\\base.go unexpected"`)
+		},
+		"prefix mutation":          func(trace string) string { return strings.ReplaceAll(trace, "GOAMD64='v2'", "GOAMD64='v3'") },
+		"prefix deletion":          func(trace string) string { return strings.ReplaceAll(trace, "GOAMD64='v2' ", "") },
+		"extra warning":            func(trace string) string { return trace + "unknown warning\n" },
+		"incorrect WORK escape":    func(trace string) string { return strings.ReplaceAll(trace, `$WORK\\b001`, `$WORK\b001`) },
+		"incorrect WORK separator": func(trace string) string { return strings.ReplaceAll(trace, `$WORK\\b001`, `$WORK/b001`) },
+		"unquoted cache copy": func(trace string) string {
+			return strings.Replace(trace, `cp "$WORK\\b001\\_pkg_.a" "C:\\cache root\\aa\\artifact-d"`,
+				`cp $WORK\b001\_pkg_.a C:\cache root\aa\artifact-d`, 1)
+		},
+		"relative WORK": func(trace string) string {
+			return strings.Replace(trace, `WORK=C:\tmp\go-build1234`, `WORK=tmp\go-build1234`, 1)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			tools, plan, defines, actual := instrumentationWindowsTraceInputs()
+			if _, err := captureInstrumentationExportRouting([]byte(mutate(instrumentationWindowsExportTrace)), `C:\Go SDK`,
+				`C:\owned task\export`, `C:\cache root\aa\artifact-d`, tools, plan, defines,
+				instrumentationExportEnvironmentFixture(t), actual); err == nil {
+				t.Fatal("accepted changed tool/path/operand/CPU display as the observed routing")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportRoutingHostIdentityNotTargetExecutableSuffix(t *testing.T) {
+	for _, host := range []string{"darwin_arm64", "linux_amd64", "windows_amd64"} {
+		for _, target := range []string{"darwin/amd64", "linux/amd64", "windows/amd64"} {
+			t.Run(host+"/"+target, func(t *testing.T) {
+				separator, suffix := "/", ""
+				root, work, marker, archive := "/sdk", "/tmp/go-build1234", "/owned/export", "/cache/export-d"
+				if strings.HasPrefix(host, "windows_") {
+					separator, suffix = `\`, ".exe"
+					root, work, marker, archive = `C:\sdk`, `C:\tmp\go-build1234`, `C:\owned\export`, `C:\cache\export-d`
+				}
+				tools := &InstrumentationToolState{Directory: "pkg/tool/" + host, BinaryOrigins: make(map[string]string)}
+				for _, name := range []string{"asm", "compile"} {
+					tools.BinaryOrigins[name] = "goroot/" + tools.Directory + "/" + name + suffix
+				}
+				paths, err := instrumentationExportPhysicalTracePaths(work, root, marker, archive, tools)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if paths.separator != separator || !strings.HasSuffix(paths.compile, "compile"+suffix) {
+					t.Fatal("target OS changed the actual SDK host executable")
+				}
+				goos, _, _ := strings.Cut(target, "/")
+				plan := &InstrumentationBuildPlan{GoVersion: "go1.27.1", Target: target, Mode: InstrumentationRace}
+				defines := []string{"GOOS_" + goos, "GOARCH_amd64", "GOAMD64_v1"}
+				actual := map[string]string{"GOOS": goos, "GOARCH": "amd64", "GOAMD64": "v1"}
+				trace := instrumentationRenderedExportTrace(plan, defines, 1, nil, paths)
+				trace = strings.Replace(trace, "@action/@action", "action/action", 1)
+				if _, err := captureInstrumentationExportRouting([]byte(trace), root, marker, archive, tools, plan, defines,
+					instrumentationExportEnvironmentFixture(t), actual); err != nil {
+					t.Fatal(err)
+				}
+				tools.BinaryOrigins["compile"] += ".exe"
+				if _, err := captureInstrumentationExportRouting([]byte(trace), root, marker, archive, tools, plan, defines,
+					instrumentationExportEnvironmentFixture(t), actual); err == nil {
+					t.Fatal("accepted a different observed host executable origin")
+				}
+			})
+		}
+	}
+}
+
+func TestInstrumentationExportRoutingWindowsDisplayNeedsBoundWholeSDKSource(t *testing.T) {
+	for _, key := range []string{"src/cmd/go/internal/work/shell.go", "src/cmd/go/internal/work/gc.go", "src/cmd/go/internal/work/buildid.go"} {
+		t.Run(key, func(t *testing.T) {
+			tools, plan, defines, actual := instrumentationWindowsTraceInputs()
+			source := instrumentationExportEnvironmentFixture(t)
+			source.SourceSHA256[key] = strings.Repeat("0", 64)
+			if _, err := captureInstrumentationExportRouting([]byte(instrumentationWindowsExportTrace), `C:\Go SDK`,
+				`C:\owned task\export`, `C:\cache root\aa\artifact-d`, tools, plan, defines, source, actual); err == nil {
+				t.Fatal("accepted command display without the complete registered SDK source bytes")
+			}
+		})
+	}
+}
+
+func TestInstrumentationExportCommandDisplayRequiresCompleteRegisteredDeclarations(t *testing.T) {
+	for _, name := range []string{"joinUnambiguously", "fmtCmd", "ShowCmd"} {
+		for _, mutation := range []string{"delete", "paired rewrite"} {
+			t.Run(name+"/"+mutation, func(t *testing.T) {
+				source := instrumentationExportEnvironmentFixture(t)
+				key := "src/cmd/go/internal/work/shell.go#" + name
+				if mutation == "delete" {
+					delete(source.SourceDeclarations, key)
+					delete(source.RegistrationSHA256, key)
+				} else {
+					source.SourceDeclarations[key] = "func " + name + "() {}"
+					_, source.RegistrationSHA256[key], _ = instrumentationExportDeclaration("shell.go",
+						[]byte("package replay\n"+source.SourceDeclarations[key]), name)
+				}
+				if err := validateInstrumentationExportEnvironment(source); err == nil {
+					t.Fatal("accepted missing or simultaneously rewritten display source and AST identity")
+				}
+			})
+		}
+	}
+}
+
+func TestInstrumentationExportPhysicalDisplayFailsClosedBeforeRendering(t *testing.T) {
+	for _, name := range []string{"missing tools", "missing origins", "unbound directory", "relative root", "relative archive", "relative marker", "empty definitions"} {
+		t.Run(name, func(t *testing.T) {
+			tools, plan, defines, actual := instrumentationWindowsTraceInputs()
+			root, marker, archive := `C:\Go SDK`, `C:\owned task\export`, `C:\cache root\aa\artifact-d`
+			switch name {
+			case "missing tools":
+				tools = nil
+			case "missing origins":
+				tools.BinaryOrigins = nil
+			case "unbound directory":
+				tools.Directory = "pkg/tool/windows_amd64/foreign"
+			case "relative root":
+				root = `Go SDK`
+			case "relative archive":
+				archive = `C:artifact-d`
+			case "relative marker":
+				marker = `\owned task\export`
+			case "empty definitions":
+				defines = nil
+			}
+			if _, err := captureInstrumentationExportRouting([]byte(instrumentationWindowsExportTrace), root, marker, archive,
+				tools, plan, defines, instrumentationExportEnvironmentFixture(t), actual); err == nil {
+				t.Fatal("accepted missing or relative actual source/tool/target routing")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_header_capture.go b/gotoolprofile/instrumentation_header_capture.go
new file mode 100644
index 000000000..9b51f89e9
--- /dev/null
+++ b/gotoolprofile/instrumentation_header_capture.go
@@ -0,0 +1,68 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+// CaptureInstrumentationNativeHeaderQuerySources also returns the unchanged
+// signature-only input required by an actual metadata query. Both projections
+// come from one independently selected/exported physical graph, not from two
+// agreeing JSON records. Only the separate property result can reduce planning.
+// Original ZIP/signed module and SDK authentication are prerequisites, exactly
+// as for the existing type-source capture; caller JSON is not source authority.
+func CaptureInstrumentationNativeHeaderQuerySources(ctx context.Context, binary, directory string, env []string,
+	input *InstrumentationConsumerInput, modules []TestModuleSource, run Runner,
+) (*InstrumentationNativeHeaderSourceProof, *InstrumentationTypeSourceProof, error) {
+	proof := &InstrumentationNativeHeaderSourceProof{Protocol: InstrumentationNativeHeaderSourcesProtocol, GoMods: make(map[string]string)}
+	var signatures InstrumentationTypeSourceProof
+	types, err := captureInstrumentationTypeSources(ctx, binary, directory, env, input, modules, run,
+		func(input *InstrumentationConsumerInput, types *InstrumentationTypeSourceProof, captured *instrumentationTypeGraph) error {
+			if err := retainInstrumentationRequiredTypeSources(input, types, captured); err != nil {
+				return err
+			}
+			data, err := json.Marshal(types)
+			if err != nil {
+				return err
+			}
+			if err := json.Unmarshal(data, &signatures); err != nil {
+				return err
+			}
+			proof.Types = types
+			for id, file := range captured.moduleFiles {
+				data, err := os.ReadFile(file)
+				if err != nil || len(data) > instrumentationOriginalFileLimit || bytesSHA256(data) != captured.hashes[file] {
+					return fmt.Errorf("native property original module metadata changed during capture: %v", err)
+				}
+				proof.GoMods[id] = string(data)
+			}
+			load := func(pkg *InstrumentationTypeSourcePackage) error {
+				files := captured.files[pkg.Dependency.Source.PackagePath]
+				if len(files) != len(pkg.Dependency.Source.GoSHA256) {
+					return fmt.Errorf("native property dependency lost its complete compiler source paths")
+				}
+				pkg.Contents = make(map[string]string)
+				for name, file := range files {
+					data, err := os.ReadFile(file)
+					captured.bytes += len(data)
+					if err != nil || len(data) > instrumentationOriginalFileLimit || captured.bytes > instrumentationOriginalInventoryLimit || bytesSHA256(data) != pkg.Dependency.Source.GoSHA256[name] {
+						return fmt.Errorf("native property dependency bytes changed or exceed their bound: %v", err)
+					}
+					pkg.Contents[name] = string(data)
+				}
+				return nil
+			}
+			_, _, _, _, err = instrumentationNativeHeaderReplay(input, proof, load)
+			return err
+		})
+	if err != nil {
+		return nil, nil, err
+	}
+	proof.Types = types
+	if _, _, err := ReplayInstrumentationNativeGeneratedHeader(input, proof); err != nil {
+		return nil, nil, err
+	}
+	return proof, &signatures, nil
+}
diff --git a/gotoolprofile/instrumentation_header_graph_test.go b/gotoolprofile/instrumentation_header_graph_test.go
new file mode 100644
index 000000000..1d01be007
--- /dev/null
+++ b/gotoolprofile/instrumentation_header_graph_test.go
@@ -0,0 +1,100 @@
+package gotoolprofile
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestInstrumentationTypeGraphRetainsModuleMetadataWithZeroMap(t *testing.T) {
+	for _, origin := range []string{"authenticated_proxy", "original_zip_member"} {
+		t.Run(origin, func(t *testing.T) {
+			input, pkg, metadata := instrumentationTypeLegacyMetadataFixture(t)
+			if origin == "original_zip_member" {
+				metadata = filepath.Join(input.Original.SourceRoot, "go.mod")
+				contents := input.Original.ProxyGoMod.Contents
+				if err := os.WriteFile(metadata, []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Original.ProxyGoMod, input.Original.ProxyGoModPath = nil, ""
+				input.Original.Sources["go.mod"] = bytesSHA256([]byte(contents))
+				input.Original.Directories["."] = []string{"go.mod", "legacy.go"}
+				pkg.Module.GoMod = metadata
+			}
+			// This existing private constructor deliberately omits the new
+			// query-only index. Keeping its zero value valid must not bypass
+			// the actual original/proxy metadata byte and path checks.
+			graph, err := instrumentationTypeMetadataCapture(input, pkg)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if graph.moduleFiles["original"] != metadata || graph.paths[metadata] != metadata {
+				t.Fatal("zero-valued index lost the independently validated module metadata path")
+			}
+		})
+	}
+}
+
+func TestInstrumentationTypeGraphModuleMetadataIndexUsesOwnedStorage(t *testing.T) {
+	var zero instrumentationTypeGraph
+	zero.recordModuleMetadataPath("original", "original.mod")
+	zero.recordModuleMetadataPath("foreign", "foreign.mod")
+	zero.recordModuleMetadataPath("original", "replacement.mod")
+	if want := map[string]string{
+		"original": "replacement.mod",
+		"foreign":  "foreign.mod",
+	}; !reflect.DeepEqual(zero.moduleFiles, want) {
+		t.Fatalf("zero graph changed exact metadata indexing: got %v, want %v", zero.moduleFiles, want)
+	}
+
+	other := instrumentationTypeGraph{moduleFiles: map[string]string{"existing": "kept.mod"}}
+	other.recordModuleMetadataPath("original", "other.mod")
+	if other.moduleFiles["existing"] != "kept.mod" || other.moduleFiles["original"] != "other.mod" {
+		t.Fatal("recording discarded an existing metadata binding")
+	}
+	if zero.moduleFiles["original"] != "replacement.mod" {
+		t.Fatal("separate graphs share mutable metadata index storage")
+	}
+}
+
+func TestInstrumentationTypeGraphModuleMetadataWritesUseRetainer(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "instrumentation_type_capture.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	writes := 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok {
+				return true
+			}
+			for _, left := range assignment.Lhs {
+				index, ok := left.(*ast.IndexExpr)
+				if !ok {
+					continue
+				}
+				field, ok := index.X.(*ast.SelectorExpr)
+				if !ok || field.Sel.Name != "moduleFiles" {
+					continue
+				}
+				writes++
+				if function.Name.Name != "recordModuleMetadataPath" {
+					t.Errorf("%s bypasses the zero-value-safe private metadata recorder", function.Name.Name)
+				}
+			}
+			return true
+		})
+	}
+	if writes != 1 {
+		t.Fatalf("expected one complete module-index mutation site, got %d", writes)
+	}
+}
diff --git a/gotoolprofile/instrumentation_header_sources.go b/gotoolprofile/instrumentation_header_sources.go
new file mode 100644
index 000000000..178df22b7
--- /dev/null
+++ b/gotoolprofile/instrumentation_header_sources.go
@@ -0,0 +1,253 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strconv"
+	"strings"
+
+	"golang.org/x/mod/modfile"
+)
+
+const InstrumentationNativeHeaderSourcesProtocol = "same_mode_native_header_property_sources_v1"
+
+// This is a separate planning-query input. It cannot supply TypeSources to an
+// object consumer, create an outcome, or grant ABI/native-memory permission.
+// Physical producers must recapture the complete sources and exports; JSON
+// agreement alone does not authenticate any original module or SDK.
+type InstrumentationNativeHeaderSourceProof struct {
+	Protocol string                          `json:"protocol"`
+	Types    *InstrumentationTypeSourceProof `json:"types"`
+	GoMods   map[string]string               `json:"original_module_metadata"`
+}
+
+func instrumentationHeaderModuleLanguage(text string) (string, error) {
+	parsed, err := modfile.Parse("go.mod", []byte(text), nil)
+	if err != nil || parsed.Module == nil {
+		return "", fmt.Errorf("native property original module language is not closed: %v", err)
+	}
+	if parsed.Go == nil {
+		return "", &nativeHeaderUnsupportedDomain{"native property query does not register the default historical module language"}
+	}
+	parts := strings.Split(parsed.Go.Version, ".")
+	if len(parts) < 2 || parts[0] != "1" {
+		return "", fmt.Errorf("native property original module language is not registered")
+	}
+	language := "go" + strings.Join(parts[:2], ".")
+	minor, err := goMinor(language)
+	if err != nil || minor < 20 || minor > 27 {
+		return "", &nativeHeaderUnsupportedDomain{"native property query does not register this module language"}
+	}
+	return language, nil
+}
+
+func validateInstrumentationHeaderGoMods(input *InstrumentationConsumerInput, proof *InstrumentationNativeHeaderSourceProof) error {
+	if proof == nil || proof.Protocol != InstrumentationNativeHeaderSourcesProtocol || proof.Types == nil || proof.GoMods == nil || len(proof.GoMods) > 4097 {
+		return fmt.Errorf("same-mode native header query lost its independent original source role")
+	}
+	if err := ValidateInstrumentationTypeSources(input, proof.Types); err != nil {
+		return err
+	}
+	wanted := map[string]string{"original": input.Original.Sources["go.mod"]}
+	if input.Original.ProxyGoMod != nil {
+		wanted["original"] = input.Original.ProxyGoMod.SHA256
+	}
+	for _, source := range proof.Types.SourceModules {
+		if source.SourceModule != "" {
+			wanted[source.ID()] = source.GoModSHA256
+		}
+	}
+	if len(wanted) != len(proof.GoMods) {
+		return fmt.Errorf("native header original module metadata is missing or unconsumed")
+	}
+	var total int
+	for id, digest := range wanted {
+		text, present := proof.GoMods[id]
+		total += len(text)
+		if !present || len(text) > instrumentationOriginalFileLimit || total > instrumentationOriginalInventoryLimit || digest == "" || bytesSHA256([]byte(text)) != digest {
+			return fmt.Errorf("native header original module metadata bytes changed: %s", id)
+		}
+		parsed, err := modfile.Parse("go.mod", []byte(text), nil)
+		if err != nil || parsed.Module == nil {
+			return fmt.Errorf("native header original module metadata is invalid: %v", err)
+		}
+		if id == "original" {
+			if parsed.Module.Mod.Path != input.Original.Module {
+				return fmt.Errorf("native header original declared module namespace changed")
+			}
+		}
+		// Foreign logical Module.Path and replacement archive namespaces need
+		// not coincide. Their actual roles and exact metadata origin are bound
+		// by the existing type-source resource validator, not guessed here.
+	}
+	return nil
+}
+
+func instrumentationNativeHeaderReplay(input *InstrumentationConsumerInput, proof *InstrumentationNativeHeaderSourceProof,
+	load func(*InstrumentationTypeSourcePackage) error,
+) (*instrumentationTypeReplay, *instrumentationDeclarationReplay, *nativeHeaderGCSizes, string, error) {
+	if err := validateInstrumentationHeaderGoMods(input, proof); err != nil {
+		return nil, nil, nil, "", err
+	}
+	language, err := instrumentationHeaderModuleLanguage(proof.GoMods["original"])
+	if err != nil {
+		return nil, nil, nil, "", err
+	}
+	_, arch, valid := strings.Cut(input.Plan.Target, "/")
+	word := int64(8)
+	switch arch {
+	case "386", "arm":
+		word = 4
+	case "amd64", "arm64", "wasm":
+	default:
+		valid = false
+	}
+	if !valid {
+		return nil, nil, nil, "", fmt.Errorf("same-mode native header query has an unknown target")
+	}
+	set := token.NewFileSet()
+	root := &instrumentationDeclarationReplay{functions: make(map[string]*ast.FuncDecl), types: make(map[string]*ast.TypeSpec),
+		constants: make(map[string]*ast.GenDecl), other: make(map[string]bool), needed: make(map[ast.Node]bool)}
+	for _, name := range input.Plan.GoFiles {
+		text, found := input.Sources.Contents[name]
+		if !found || bytesSHA256([]byte(text)) != input.Original.Sources[name] {
+			return nil, nil, nil, "", fmt.Errorf("native header selected original Go bytes changed")
+		}
+		file, err := parser.ParseFile(set, name, text, 0)
+		if err != nil || file.Name.Name != input.Plan.PackageName {
+			return nil, nil, nil, "", fmt.Errorf("native header selected original package changed: %v", err)
+		}
+		root.files = append(root.files, file)
+		if err := root.index(file); err != nil {
+			return nil, nil, nil, "", err
+		}
+	}
+	copy := *input
+	copy.TypeSources = proof.Types
+	graph, err := newInstrumentationTypeReplay(&copy, set, root)
+	if err != nil {
+		return nil, nil, nil, "", err
+	}
+	sizes := &nativeHeaderGCSizes{word: word, cache: make(map[types.Type]nativeHeaderLayout), active: make(map[types.Type]bool)}
+	graph.load, graph.nativeSizes = load, sizes
+	graph.language = func(source ImportExport) (string, error) {
+		if source.SourceRole == "stdlib" {
+			minor, err := goMinor(input.Observation.Early.BaselineFeatures.GoVersion)
+			return fmt.Sprintf("go1.%d", minor), err
+		}
+		if source.ModulePath == input.Original.Module && source.Version == input.Original.Version {
+			return language, nil
+		}
+		for _, module := range proof.Types.SourceModules {
+			if module.SourceModule == source.SourceModule && module.SourceVersion == source.SourceVersion {
+				return instrumentationHeaderModuleLanguage(proof.GoMods[module.ID()])
+			}
+		}
+		return "", fmt.Errorf("native header dependency has no authenticated module language")
+	}
+	// Header properties include every original constant and named struct, not
+	// merely names reachable from a bodyless assembly signature. Their imported
+	// closure is selected by the same existing declaration graph.
+	if err := requireNativeHeaderRoots(root); err != nil {
+		return nil, nil, nil, "", err
+	}
+	if err := boundInstrumentationHeaderStrings(graph); err != nil {
+		return nil, nil, nil, "", err
+	}
+	return graph, root, sizes, language, nil
+}
+
+// A qualified constant can itself be a lazy string DAG. Charge it through the
+// original per-file ImportMap before any go/types or ExactString evaluation;
+// independently checking each package would miss root-level duplication of an
+// imported string. The same existing resource budget handles the expressions.
+func boundInstrumentationHeaderStrings(graph *instrumentationTypeReplay) error {
+	budgets := make(map[string]*nativeHeaderStringBudget)
+	for target, replay := range graph.replays {
+		budget, err := newNativeHeaderStringBudget(replay.selectedFiles())
+		if err != nil {
+			return err
+		}
+		budgets[target] = budget
+	}
+	for target := range graph.replays {
+		replay := graph.replays[target] // Private closures must also be correct on Go 1.20.
+		budget := budgets[target]
+		importMap := graph.proof.RootImportMap
+		if target != graph.input.Plan.PackagePath {
+			for _, dependency := range graph.proof.Dependencies {
+				if dependency.Dependency.Source.PackagePath == target {
+					importMap = dependency.Dependency.ImportMap
+					break
+				}
+			}
+		}
+		budget.selector = func(expression *ast.SelectorExpr) (uint64, error) {
+			qualifier, ok := expression.X.(*ast.Ident)
+			if !ok {
+				return 0, fmt.Errorf("native property string selector is not a direct original import")
+			}
+			for _, file := range replay.files {
+				if expression.Pos() < file.Pos() || expression.End() > file.End() {
+					continue
+				}
+				for _, spec := range file.Imports {
+					spelling, err := strconv.Unquote(spec.Path.Value)
+					if err != nil {
+						return 0, err
+					}
+					child := importMap[spelling]
+					name := "unsafe"
+					for _, dependency := range graph.proof.Dependencies {
+						if dependency.Dependency.Source.PackagePath == child {
+							name = dependency.Name
+							break
+						}
+					}
+					if spec.Name != nil {
+						name = spec.Name.Name
+					}
+					if name != qualifier.Name {
+						continue
+					}
+					if child == "unsafe" {
+						return 0, nil // The unchanged typechecker verifies its numeric operation.
+					}
+					if budgets[child] == nil {
+						return 0, fmt.Errorf("native property string selector lost its original closure")
+					}
+					return budgets[child].expression(&ast.Ident{Name: expression.Sel.Name}, 0)
+				}
+			}
+			return 0, fmt.Errorf("native property string selector lost its file-local import")
+		}
+	}
+	for target, replay := range graph.replays {
+		if err := budgets[target].check(replay.selectedFiles()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// ReplayInstrumentationNativeGeneratedHeader independently derives properties
+// from original module language, selected Go bytes, and imported declarations.
+// It queries values only; the actual compiler header and final object consumer
+// must still independently agree under this exact mode/CPU/source selection.
+func ReplayInstrumentationNativeGeneratedHeader(input *InstrumentationConsumerInput, proof *InstrumentationNativeHeaderSourceProof) (map[string]string, string, error) {
+	graph, root, sizes, language, err := instrumentationNativeHeaderReplay(input, proof, nil)
+	if err != nil {
+		return nil, "", err
+	}
+	config := &types.Config{Sizes: sizes, GoVersion: language, IgnoreFuncBodies: true,
+		Importer: instrumentationTypeImporter{graph: graph, importMap: proof.Types.RootImportMap}}
+	pkg, err := config.Check(input.Plan.PackagePath, graph.set, root.selectedFiles(), nil)
+	if err != nil || sizes.err != nil {
+		return nil, "", fmt.Errorf("same-mode native header declaration replay failed: %v %v", err, sizes.err)
+	}
+	definitions, err := nativeGeneratedHeaderDefinitions(pkg, sizes)
+	return definitions, language, err
+}
diff --git a/gotoolprofile/instrumentation_header_sources_test.go b/gotoolprofile/instrumentation_header_sources_test.go
new file mode 100644
index 000000000..4008bfbae
--- /dev/null
+++ b/gotoolprofile/instrumentation_header_sources_test.go
@@ -0,0 +1,142 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func instrumentationHeaderReplayFixture(t *testing.T, arch string) (*InstrumentationConsumerInput, *InstrumentationNativeHeaderSourceProof) {
+	t.Helper()
+	input, _, _ := instrumentationImportedReplayFixture(t, arch)
+	const metadata = "module example.invalid/replay\n\ngo 1.20\n"
+	text := input.Sources.Contents["replay.go"] + "\ntype Tail struct { Value byte; End [0]byte }\n"
+	input.Sources.Contents["replay.go"] = text
+	input.Original.Sources["replay.go"] = bytesSHA256([]byte(text))
+	input.Original.Sources["go.mod"] = bytesSHA256([]byte(metadata))
+	input.TypeSources.InputSHA256 = instrumentationTypeSourceInputSHA(input)
+	return input, &InstrumentationNativeHeaderSourceProof{
+		Protocol: InstrumentationNativeHeaderSourcesProtocol,
+		Types:    input.TypeSources, GoMods: map[string]string{"original": metadata},
+	}
+}
+
+func TestInstrumentationNativeHeaderPropertiesRetainImportedConstantsAndGCTail(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			input, proof := instrumentationHeaderReplayFixture(t, arch)
+			definitions, language, err := ReplayInstrumentationNativeGeneratedHeader(input, proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			rowSize := "16"
+			if arch == "386" || arch == "arm" {
+				rowSize = "12"
+			}
+			for name, expected := range map[string]string{
+				"const_Size": "1", "Alias__size": rowSize,
+				"Alias_First": "0", "Alias_Payload": "2", "Alias_Last": "8",
+				"Tail__size": "2", "Tail_Value": "0", "Tail_End": "1",
+			} {
+				if definitions[name] != expected {
+					t.Fatalf("native property %s=%q, want %q", name, definitions[name], expected)
+				}
+			}
+			if language != "go1.20" {
+				t.Fatalf("original module language changed: %s", language)
+			}
+		})
+	}
+}
+
+func TestInstrumentationNativeHeaderPropertiesRejectLostLanguageAndSourceClosure(t *testing.T) {
+	input, proof := instrumentationHeaderReplayFixture(t, "arm64")
+	encoded, err := json.Marshal(struct {
+		Input *InstrumentationConsumerInput
+		Proof *InstrumentationNativeHeaderSourceProof
+	}{input, proof})
+	if err != nil {
+		t.Fatal(err)
+	}
+	mutations := map[string]func(*InstrumentationConsumerInput, *InstrumentationNativeHeaderSourceProof){
+		"role deletion":   func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) { p.Types = nil },
+		"downgrade":       func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) { p.Protocol = "v0" },
+		"module deletion": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) { p.GoMods = nil },
+		"language": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) {
+			p.GoMods["original"] = strings.Replace(p.GoMods["original"], "1.20", "1.21", 1)
+		},
+		"extra module": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) {
+			p.GoMods["extra"] = p.GoMods["original"]
+		},
+		"missing imported bytes": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) {
+			p.Types.Dependencies[0].Contents = nil
+		},
+		"changed imported bytes": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) {
+			p.Types.Dependencies[0].Contents["dep/types.go"] += "\n"
+		},
+		"paired imported bytes": func(_ *InstrumentationConsumerInput, p *InstrumentationNativeHeaderSourceProof) {
+			dependency := &p.Types.Dependencies[0]
+			dependency.Contents["dep/types.go"] += "\n"
+			dependency.Dependency.Source.GoSHA256["dep/types.go"] = bytesSHA256([]byte(dependency.Contents["dep/types.go"]))
+		},
+		"input mode/target": func(p *InstrumentationConsumerInput, _ *InstrumentationNativeHeaderSourceProof) {
+			p.Plan.Target = "linux/386"
+		},
+		"root bytes": func(p *InstrumentationConsumerInput, _ *InstrumentationNativeHeaderSourceProof) {
+			p.Sources.Contents["replay.go"] += "\n"
+		},
+	}
+	for name, mutate := range mutations {
+		t.Run(name, func(t *testing.T) {
+			var changed struct {
+				Input *InstrumentationConsumerInput
+				Proof *InstrumentationNativeHeaderSourceProof
+			}
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(changed.Input, changed.Proof)
+			if _, _, err := ReplayInstrumentationNativeGeneratedHeader(changed.Input, changed.Proof); err == nil {
+				t.Fatal("changed query inputs acquired native header planning authority")
+			}
+		})
+	}
+}
+
+func TestInstrumentationNativeHeaderPropertiesBoundImportedStringExpansionBeforeTypes(t *testing.T) {
+	input, proof := instrumentationHeaderReplayFixture(t, "arm64")
+	dependency := &proof.Types.Dependencies[0]
+	dependency.Contents["dep/types.go"] += "\nconst Seed = \"abcdefghijklmnop\"\n"
+	dependency.Dependency.Source.GoSHA256["dep/types.go"] = bytesSHA256([]byte(dependency.Contents["dep/types.go"]))
+	input.Original.Sources["dep/types.go"] = dependency.Dependency.Source.GoSHA256["dep/types.go"]
+	text := input.Sources.Contents["replay.go"] + "\nconst S0 = renamed.Seed\n"
+	for _, pair := range [][2]string{{"S1", "S0"}, {"S2", "S1"}, {"S3", "S2"}, {"S4", "S3"}, {"S5", "S4"}, {"S6", "S5"}, {"S7", "S6"}, {"S8", "S7"}, {"S9", "S8"}, {"S10", "S9"}, {"S11", "S10"}, {"S12", "S11"}, {"S13", "S12"}, {"S14", "S13"}, {"S15", "S14"}, {"S16", "S15"}, {"S17", "S16"}, {"S18", "S17"}, {"S19", "S18"}, {"S20", "S19"}} {
+		text += "const " + pair[0] + " = " + pair[1] + " + " + pair[1] + "\n"
+	}
+	input.Sources.Contents["replay.go"] = text
+	input.Original.Sources["replay.go"] = bytesSHA256([]byte(text))
+	proof.Types.InputSHA256 = instrumentationTypeSourceInputSHA(input)
+	_, _, err := ReplayInstrumentationNativeGeneratedHeader(input, proof)
+	if !NativeHeaderSourceDomainUnsupported(err) {
+		t.Fatalf("imported lazy string expansion was not bounded before typecheck: %v", err)
+	}
+}
+
+func TestInstrumentationNativeHeaderPropertiesKeepUnknownLanguageConservative(t *testing.T) {
+	for _, language := range []string{"", "go 1.19\n", "go 1.28\n"} {
+		t.Run(strings.TrimSpace(language), func(t *testing.T) {
+			input, proof := instrumentationHeaderReplayFixture(t, "arm64")
+			text := "module example.invalid/replay\n" + language
+			proof.GoMods["original"] = text
+			input.Original.Sources["go.mod"] = bytesSHA256([]byte(text))
+			proof.Types.InputSHA256 = instrumentationTypeSourceInputSHA(input)
+			if _, _, err := ReplayInstrumentationNativeGeneratedHeader(input, proof); !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unregistered module language did not retain its precise unsupported query role: %v", err)
+			}
+			proof.GoMods["original"] += "changed"
+			if _, _, err := ReplayInstrumentationNativeGeneratedHeader(input, proof); err == nil || NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("source corruption was swallowed by an unsupported query domain: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_invocation.go b/gotoolprofile/instrumentation_invocation.go
new file mode 100644
index 000000000..64bed5789
--- /dev/null
+++ b/gotoolprofile/instrumentation_invocation.go
@@ -0,0 +1,126 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+)
+
+const InstrumentationInvocationProtocol = "actual_go_instrumentation_cli_invocation_v1"
+
+type InstrumentationInvocationPhase string
+
+const (
+	InstrumentationMetadataQuery InstrumentationInvocationPhase = "metadata_query"
+	InstrumentationObjectCompile InstrumentationInvocationPhase = "llvm_objects"
+)
+
+// InstrumentationInvocationProof is the separate CLI result consumed by mode
+// callers. An independently expected phase/context and actual LLVM tool are
+// mandatory. Metadata queries have no object count; objects prove neither
+// final linking nor runtime semantics. No field supplies a candidate PASS.
+type InstrumentationInvocationProof struct {
+	Protocol         string                           `json:"protocol"`
+	Phase            InstrumentationInvocationPhase   `json:"phase"`
+	ModeProfileID    string                           `json:"mode_profile_id"`
+	InputSHA256      string                           `json:"input_sha256"`
+	Target           string                           `json:"target"`
+	PackageDirectory string                           `json:"package_directory"`
+	PackagePath      string                           `json:"package_path"`
+	CustomTags       []string                         `json:"custom_tags,omitempty"`
+	AsmFiles         []string                         `json:"asm_files"`
+	ObjectCount      int                              `json:"object_count"`
+	Metadata         *InstrumentationMetadataProof    `json:"metadata"`
+	Consumption      *InstrumentationConsumptionProof `json:"consumption,omitempty"`
+	LLVM             *InstrumentationLLVMTool         `json:"llvm,omitempty"`
+}
+
+func NewInstrumentationInvocation(input *InstrumentationConsumerInput, phase InstrumentationInvocationPhase,
+	metadata *InstrumentationMetadataProof, consumption *InstrumentationConsumptionProof, llvm *InstrumentationLLVMTool,
+) (*InstrumentationInvocationProof, error) {
+	if input == nil || input.Plan == nil {
+		return nil, fmt.Errorf("missing independently bound mode invocation input")
+	}
+	plan := input.Plan
+	proof := &InstrumentationInvocationProof{
+		Protocol: InstrumentationInvocationProtocol, Phase: phase, ModeProfileID: input.ID,
+		InputSHA256: InstrumentationConsumerInputSHA256(input), Target: plan.Target,
+		PackageDirectory: plan.PackageDirectory, PackagePath: plan.PackagePath,
+		CustomTags: append([]string(nil), plan.CustomTags...), AsmFiles: append([]string(nil), plan.SFiles...),
+		Metadata: metadata, Consumption: consumption, LLVM: llvm,
+	}
+	if consumption != nil {
+		proof.ObjectCount = len(consumption.Files)
+	}
+	if err := ValidateInstrumentationInvocation(input, phase, metadata, llvm, proof); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateInstrumentationInvocation(input *InstrumentationConsumerInput, phase InstrumentationInvocationPhase,
+	producer *InstrumentationMetadataProof, llvm *InstrumentationLLVMTool, proof *InstrumentationInvocationProof,
+) error {
+	if input == nil || input.Plan == nil {
+		return fmt.Errorf("missing independently expected original mode invocation scope")
+	}
+	plan := input.Plan
+	if err := ValidateInstrumentationConsumerInput(input, plan.PackageDirectory, plan.CustomTags); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != InstrumentationInvocationProtocol || proof.Phase != phase ||
+		proof.ModeProfileID != input.ID || proof.InputSHA256 != InstrumentationConsumerInputSHA256(input) ||
+		proof.Target != plan.Target || proof.PackageDirectory != plan.PackageDirectory || proof.PackagePath != plan.PackagePath ||
+		!equalDiscoveryStrings(proof.CustomTags, plan.CustomTags) || !equalDiscoveryStrings(proof.AsmFiles, plan.SFiles) {
+		return fmt.Errorf("mode invocation lost or changed its independent phase/source/target/profile/tag scope")
+	}
+	if err := ValidateInstrumentationMetadata(input, plan.PackageDirectory, plan.CustomTags, proof.Metadata); err != nil {
+		return err
+	}
+	sameProducer := false
+	if producer != nil {
+		if err := ValidateInstrumentationMetadata(input, plan.PackageDirectory, plan.CustomTags, producer); err != nil {
+			return err
+		}
+		wanted, err := compactInstrumentationMetadataLayouts(producer)
+		if err != nil {
+			return err
+		}
+		actual, err := compactInstrumentationMetadataLayouts(proof.Metadata)
+		if err != nil {
+			return err
+		}
+		// Unlike independent header recapture agreement, invocation producer
+		// identity retains every header hash and every other metadata field.
+		sameProducer = reflect.DeepEqual(wanted, actual)
+	}
+	switch phase {
+	case InstrumentationMetadataQuery:
+		if producer != nil && !sameProducer || llvm != nil || proof.LLVM != nil ||
+			proof.Consumption != nil || proof.ObjectCount != 0 {
+			return fmt.Errorf("metadata query borrowed object/compiler/other producer evidence")
+		}
+	case InstrumentationObjectCompile:
+		if producer == nil || !sameProducer || !reflect.DeepEqual(proof.LLVM, llvm) ||
+			proof.Consumption == nil || proof.ObjectCount != len(plan.SFiles) {
+			return fmt.Errorf("mode object invocation lacks its independent original producer/tool/full file denominator")
+		}
+		return ValidateInstrumentationConsumption(input, producer, llvm, plan.PackageDirectory, plan.CustomTags, proof.Consumption)
+	default:
+		return fmt.Errorf("unknown instrumentation invocation phase")
+	}
+	return nil
+}
+
+func DecodeInstrumentationInvocation(reader io.Reader, input *InstrumentationConsumerInput, phase InstrumentationInvocationPhase,
+	producer *InstrumentationMetadataProof, llvm *InstrumentationLLVMTool,
+) (*InstrumentationInvocationProof, error) {
+	var proof InstrumentationInvocationProof
+	if err := decodeInstrumentationOriginalJSON(reader, 48<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationInvocation(input, phase, producer, llvm, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
diff --git a/gotoolprofile/instrumentation_invocation_test.go b/gotoolprofile/instrumentation_invocation_test.go
new file mode 100644
index 000000000..c7c286a60
--- /dev/null
+++ b/gotoolprofile/instrumentation_invocation_test.go
@@ -0,0 +1,29 @@
+package gotoolprofile
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationInvocationReadersNeedIndependentModeSourcePhaseAndTools(t *testing.T) {
+	for _, input := range []*InstrumentationConsumerInput{nil, {}, {Plan: &InstrumentationOriginalPackagePlan{}}} {
+		for _, phase := range []InstrumentationInvocationPhase{InstrumentationMetadataQuery, InstrumentationObjectCompile, "passed", ""} {
+			if _, err := NewInstrumentationInvocation(input, phase, nil, nil, nil); err == nil {
+				t.Fatal("missing original mode context acquired a CLI result")
+			}
+			if err := ValidateInstrumentationInvocation(input, phase, nil, nil, &InstrumentationInvocationProof{}); err == nil {
+				t.Fatal("missing mode/phase/tool prerequisites validated")
+			}
+			for _, contents := range []string{"", "{}", `{"protocol":"actual_go_cpu_profile_consumer_v1"}`,
+				`{"protocol":"actual_go_instrumentation_cli_invocation_v1","phase":"passed"}`,
+				`{"protocol":"actual_go_instrumentation_cli_invocation_v1","unknown":true}`, "{}\n{}"} {
+				if _, err := DecodeInstrumentationInvocation(strings.NewReader(contents), input, phase, nil, nil); err == nil {
+					t.Fatal("ordinary, missing, unknown or trailing mode invocation accepted")
+				}
+			}
+		}
+	}
+	if _, err := DecodeInstrumentationInvocation(nil, nil, InstrumentationObjectCompile, nil, nil); err == nil {
+		t.Fatal("nil mode reader accepted")
+	}
+}
diff --git a/gotoolprofile/instrumentation_layout.go b/gotoolprofile/instrumentation_layout.go
new file mode 100644
index 000000000..6df58ecd2
--- /dev/null
+++ b/gotoolprofile/instrumentation_layout.go
@@ -0,0 +1,399 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// This is a closed declaration/type/constant replay over the independently
+// supplied original compiled source, not a type parsed from metadata strings.
+// Original AST nodes, including complete const groups and iota positions, are
+// retained. No Go arguments or return slots are invented from assembly.
+// Imported selectors additionally require the independently captured original
+// type-source input; paired metadata alone cannot supply that authority.
+type instrumentationDeclarationReplay struct {
+	files     []*ast.File
+	functions map[string]*ast.FuncDecl
+	types     map[string]*ast.TypeSpec
+	constants map[string]*ast.GenDecl
+	other     map[string]bool
+	needed    map[ast.Node]bool
+	selector  func(*ast.SelectorExpr) error
+}
+
+func replayInstrumentationDeclarationLayouts(input *InstrumentationConsumerInput, pkg PackageProof, declarations []InstrumentationDeclarationProof) error {
+	set := token.NewFileSet()
+	replay := &instrumentationDeclarationReplay{
+		functions: make(map[string]*ast.FuncDecl), types: make(map[string]*ast.TypeSpec),
+		constants: make(map[string]*ast.GenDecl), other: make(map[string]bool),
+		needed: make(map[ast.Node]bool),
+	}
+	for _, name := range pkg.CompiledGoFiles {
+		file, err := parser.ParseFile(set, name, input.Sources.Contents[name], 0)
+		if err != nil || file.Name.Name != input.Plan.PackageName {
+			return fmt.Errorf("actual compiled Go declaration source changed: %v", err)
+		}
+		replay.files = append(replay.files, file)
+		if err := replay.index(file); err != nil {
+			return err
+		}
+	}
+	imports, err := newInstrumentationTypeReplay(input, set, replay)
+	if err != nil {
+		return err
+	}
+	for _, declaration := range declarations {
+		name := strings.TrimPrefix(declaration.Symbol, pkg.PackagePath+".")
+		function := replay.functions[name]
+		if function == nil || function.Body != nil || function.Recv != nil {
+			return fmt.Errorf("actual compiled bodyless declaration disappeared")
+		}
+		replay.needed[function] = true
+		if err := replay.requireType(function.Type); err != nil {
+			return err
+		}
+	}
+	if len(declarations) == 0 {
+		return nil
+	}
+	selected := replay.selectedFiles()
+	_, arch, _ := strings.Cut(input.Plan.Target, "/")
+	sizes := types.SizesFor("gc", arch)
+	if sizes == nil {
+		return fmt.Errorf("actual target has no Go gc declaration layout")
+	}
+	minor, err := goMinor(input.Observation.Early.BaselineFeatures.GoVersion)
+	if err != nil {
+		return err
+	}
+	// Config.GoVersion is a language version. Go 1.20 panics for a patch
+	// release string; the exact driver patch remains independently observed.
+	config := &types.Config{Sizes: sizes, IgnoreFuncBodies: true, GoVersion: fmt.Sprintf("go1.%d", minor)}
+	if imports != nil {
+		config.Importer = instrumentationTypeImporter{graph: imports, importMap: imports.proof.RootImportMap}
+	}
+	typed, err := config.Check(pkg.PackagePath, set, selected, nil)
+	if err != nil {
+		return fmt.Errorf("original Go declaration type/constant closure is not independently closed: %w", err)
+	}
+	for _, declaration := range declarations {
+		name := strings.TrimPrefix(declaration.Symbol, pkg.PackagePath+".")
+		function, ok := typed.Scope().Lookup(name).(*types.Func)
+		if !ok {
+			return fmt.Errorf("actual original Go function type disappeared")
+		}
+		signature := function.Type().(*types.Signature)
+		for i := 0; i < signature.Params().Len(); i++ {
+			if sizes.Sizeof(signature.Params().At(i).Type()) == 0 {
+				return fmt.Errorf("mode ABI0 replay has an unclosed root/CLI two-builder zero-sized parameter difference: %s", declaration.Symbol)
+			}
+		}
+		if err := boundInstrumentationABI0Layout(signature); err != nil {
+			return err
+		}
+		actualType := types.TypeString(function.Type(), func(pkg *types.Package) string { return pkg.Path() })
+		layout, err := plan9asm.DeriveGoFuncABI0Signature(declaration.Symbol, function, arch, sizes)
+		if err != nil {
+			return err
+		}
+		var claimed plan9asm.FuncSig
+		if err := decodeInstrumentationOriginalJSON(strings.NewReader(string(declaration.Layout)), 1<<20, &claimed); err != nil {
+			return err
+		}
+		// The producer serializes a public layout observation. Independently
+		// derived signatures may also hold private live declaration inputs,
+		// which JSON cannot recreate and metadata must never authorize. Compare
+		// exactly the same public fields; retain the actual source/type replay.
+		encoded, err := json.Marshal(layout)
+		if err != nil {
+			return err
+		}
+		var observed plan9asm.FuncSig
+		if err := decodeInstrumentationOriginalJSON(strings.NewReader(string(encoded)), 1<<20, &observed); err != nil {
+			return err
+		}
+		if declaration.GoType != actualType || !reflect.DeepEqual(claimed, observed) {
+			return fmt.Errorf("mode Go type/complete ABI0 layout differs from independent original AST replay: %s", declaration.Symbol)
+		}
+	}
+	return nil
+}
+
+func (replay *instrumentationDeclarationReplay) selectedFiles() []*ast.File {
+	var selected []*ast.File
+	for _, original := range replay.files {
+		copy := *original
+		copy.Decls, copy.Imports = nil, nil
+		for _, declaration := range original.Decls {
+			if replay.needed[declaration] {
+				copy.Decls = append(copy.Decls, declaration)
+				continue
+			}
+			group, ok := declaration.(*ast.GenDecl)
+			if !ok || group.Tok != token.TYPE && group.Tok != token.IMPORT {
+				continue
+			}
+			filtered := *group
+			filtered.Specs = nil
+			for _, spec := range group.Specs {
+				if replay.needed[spec] {
+					filtered.Specs = append(filtered.Specs, spec)
+					if imported, ok := spec.(*ast.ImportSpec); ok {
+						copy.Imports = append(copy.Imports, imported)
+					}
+				}
+			}
+			if len(filtered.Specs) != 0 {
+				copy.Decls = append(copy.Decls, &filtered)
+			}
+		}
+		selected = append(selected, &copy)
+	}
+	return selected
+}
+
+// Bound aggregate expansion before the shared ABI0 builder allocates slots.
+// Source bytes alone do not bound a constant array's declared length.
+func boundInstrumentationABI0Layout(signature *types.Signature) error {
+	var count func(types.Type, int) (int64, error)
+	count = func(typ types.Type, depth int) (int64, error) {
+		if depth > 128 {
+			return 0, fmt.Errorf("original ABI0 type exceeds its nesting bound")
+		}
+		switch typ := typ.Underlying().(type) {
+		case *types.Array:
+			if typ.Len() > 4096 {
+				return 0, fmt.Errorf("original ABI0 array exceeds its slot bound")
+			}
+			child, err := count(typ.Elem(), depth+1)
+			if err != nil || child*typ.Len() > 4096 {
+				return 0, fmt.Errorf("original ABI0 array expansion exceeds its slot bound: %v", err)
+			}
+			if typ.Len() == 0 {
+				return 1, nil
+			}
+			return child * typ.Len(), nil
+		case *types.Struct:
+			if typ.NumFields() > 4096 {
+				return 0, fmt.Errorf("original ABI0 struct exceeds its field bound")
+			}
+			var total int64
+			for i := 0; i < typ.NumFields(); i++ {
+				child, err := count(typ.Field(i).Type(), depth+1)
+				if err != nil {
+					return 0, err
+				}
+				total += child
+				if total > 4096 {
+					return 0, fmt.Errorf("original ABI0 struct expansion exceeds its slot bound")
+				}
+			}
+			if total == 0 {
+				return 1, nil
+			}
+			return total, nil
+		case *types.Slice:
+			return 3, nil
+		case *types.Interface:
+			return 2, nil
+		case *types.Basic:
+			if typ.Kind() == types.String || typ.Kind() == types.Complex64 || typ.Kind() == types.Complex128 {
+				return 2, nil
+			}
+		}
+		return 1, nil
+	}
+	var total int64
+	for _, tuple := range []*types.Tuple{signature.Params(), signature.Results()} {
+		for i := 0; i < tuple.Len(); i++ {
+			parts, err := count(tuple.At(i).Type(), 0)
+			if err != nil {
+				return err
+			}
+			total += parts
+			if total > 4096 {
+				return fmt.Errorf("original ABI0 signature exceeds its total slot bound")
+			}
+		}
+	}
+	return nil
+}
+
+func (replay *instrumentationDeclarationReplay) index(file *ast.File) error {
+	register := func(name string) error {
+		if name == "_" {
+			return nil
+		}
+		if replay.functions[name] != nil || replay.types[name] != nil || replay.constants[name] != nil || replay.other[name] {
+			return fmt.Errorf("original Go declaration has a duplicate package name")
+		}
+		if len(replay.functions)+len(replay.types)+len(replay.constants)+len(replay.other) >= 32768 {
+			return fmt.Errorf("original Go declaration replay exceeds its name bound")
+		}
+		return nil
+	}
+	for _, declaration := range file.Decls {
+		switch declaration := declaration.(type) {
+		case *ast.FuncDecl:
+			if declaration.Recv != nil || declaration.Name.Name == "init" {
+				continue
+			}
+			if err := register(declaration.Name.Name); err != nil {
+				return err
+			}
+			replay.functions[declaration.Name.Name] = declaration
+		case *ast.GenDecl:
+			for _, spec := range declaration.Specs {
+				switch spec := spec.(type) {
+				case *ast.TypeSpec:
+					if spec.Name.Name == "_" {
+						continue
+					}
+					if err := register(spec.Name.Name); err != nil {
+						return err
+					}
+					replay.types[spec.Name.Name] = spec
+				case *ast.ValueSpec:
+					for _, name := range spec.Names {
+						if err := register(name.Name); err != nil {
+							return err
+						}
+						if name.Name == "_" {
+							continue
+						}
+						if declaration.Tok == token.CONST {
+							replay.constants[name.Name] = declaration
+						} else {
+							replay.other[name.Name] = true
+						}
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func (replay *instrumentationDeclarationReplay) requireName(name string) error {
+	if declaration := replay.types[name]; declaration != nil {
+		if replay.needed[declaration] {
+			return nil
+		}
+		if len(replay.needed) >= 4096 || declaration.TypeParams != nil && len(declaration.TypeParams.List) != 0 {
+			return fmt.Errorf("original declaration needs an unclosed generic type or exceeds its bound")
+		}
+		replay.needed[declaration] = true // recursive pointer types are checked by go/types.
+		return replay.requireType(declaration.Type)
+	}
+	if declaration := replay.constants[name]; declaration != nil {
+		if replay.needed[declaration] {
+			return nil
+		}
+		if len(replay.needed) >= 4096 {
+			return fmt.Errorf("original constant replay exceeds its declaration bound")
+		}
+		replay.needed[declaration] = true
+		for _, spec := range declaration.Specs {
+			value := spec.(*ast.ValueSpec)
+			if value.Type != nil {
+				if err := replay.requireType(value.Type); err != nil {
+					return err
+				}
+			}
+			for _, expression := range value.Values {
+				if err := replay.requireExpression(expression); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	if replay.other[name] || replay.functions[name] != nil || types.Universe.Lookup(name) == nil {
+		return fmt.Errorf("original declaration type/constant has an unclosed name: %s", name)
+	}
+	return nil
+}
+
+func (replay *instrumentationDeclarationReplay) requireExpression(expression ast.Expr) error {
+	var failed error
+	ast.Inspect(expression, func(node ast.Node) bool {
+		if failed != nil {
+			return false
+		}
+		switch node := node.(type) {
+		case *ast.SelectorExpr:
+			if replay.selector == nil {
+				failed = fmt.Errorf("original declaration needs an authenticated imported type/constant closure")
+			} else {
+				failed = replay.selector(node)
+			}
+			return false
+		case *ast.Ident:
+			failed = replay.requireName(node.Name)
+		}
+		return true
+	})
+	return failed
+}
+
+func (replay *instrumentationDeclarationReplay) requireType(expression ast.Expr) error {
+	fieldTypes := func(fields *ast.FieldList) error {
+		if fields != nil {
+			for _, field := range fields.List {
+				if err := replay.requireType(field.Type); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	switch expression := expression.(type) {
+	case *ast.Ident:
+		return replay.requireName(expression.Name)
+	case *ast.ParenExpr:
+		return replay.requireType(expression.X)
+	case *ast.StarExpr:
+		return replay.requireType(expression.X)
+	case *ast.ArrayType:
+		if expression.Len != nil {
+			if err := replay.requireExpression(expression.Len); err != nil {
+				return err
+			}
+		}
+		return replay.requireType(expression.Elt)
+	case *ast.StructType:
+		return fieldTypes(expression.Fields)
+	case *ast.InterfaceType:
+		return fieldTypes(expression.Methods)
+	case *ast.FuncType:
+		if expression.TypeParams != nil && len(expression.TypeParams.List) != 0 {
+			return fmt.Errorf("generic function needs its separate source/type contract")
+		}
+		if err := fieldTypes(expression.Params); err != nil {
+			return err
+		}
+		return fieldTypes(expression.Results)
+	case *ast.MapType:
+		if err := replay.requireType(expression.Key); err != nil {
+			return err
+		}
+		return replay.requireType(expression.Value)
+	case *ast.ChanType:
+		return replay.requireType(expression.Value)
+	case *ast.SelectorExpr:
+		if replay.selector == nil {
+			return fmt.Errorf("original declaration needs an authenticated imported type/constant closure")
+		}
+		return replay.selector(expression)
+	default:
+		return fmt.Errorf("original declaration has an unclosed type expression %T", expression)
+	}
+}
diff --git a/gotoolprofile/instrumentation_layout_observation_test.go b/gotoolprofile/instrumentation_layout_observation_test.go
new file mode 100644
index 000000000..cb5db132e
--- /dev/null
+++ b/gotoolprofile/instrumentation_layout_observation_test.go
@@ -0,0 +1,53 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestInstrumentationABI0ObservationRetainsPublicLayoutWithoutPrivatePermission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		for _, parameters := range []string{"value uint64", "values [3]uint64", "data []byte"} {
+			t.Run(arch+"/"+parameters, func(t *testing.T) {
+				source := "package replay\nfunc Probe(" + parameters + ") uintptr\n"
+				input, pkg, declaration := instrumentationReplayFixture(t, source, arch)
+				if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+					t.Fatal(err)
+				}
+				// Serialized layout observes all public fields. It cannot
+				// reconstruct a live source-bound opaque declaration input.
+				if strings.Contains(string(declaration.Layout), "arm64ABI0Declaration") {
+					t.Fatal("private declaration input escaped into public metadata")
+				}
+				for _, axis := range []string{"result offset", "result width", "native contract"} {
+					t.Run(axis, func(t *testing.T) {
+						var layout plan9asm.FuncSig
+						if err := json.Unmarshal(declaration.Layout, &layout); err != nil {
+							t.Fatal(err)
+						}
+						switch axis {
+						case "result offset":
+							layout.Frame.Results[0].Offset++
+						case "result width":
+							layout.Frame.Results[0].Type = plan9asm.I8
+						case "native contract":
+							layout.ArgRegs = []plan9asm.Reg{"R0"}
+						}
+						changed := declaration
+						var err error
+						changed.Layout, err = json.Marshal(layout)
+						if err != nil {
+							t.Fatal(err)
+						}
+						if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{changed}); err == nil {
+							t.Fatal("layout observation accepted an invented field or native contract")
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_layout_test.go b/gotoolprofile/instrumentation_layout_test.go
new file mode 100644
index 000000000..9343c9b6e
--- /dev/null
+++ b/gotoolprofile/instrumentation_layout_test.go
@@ -0,0 +1,244 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestInstrumentationDeclarationReplayClosedOriginalTypesAndConstants(t *testing.T) {
+	const source = `package replay
+type Element uint16
+type Alias = Element
+const (
+	_ = iota
+	Length
+	Count = Length + 2
+)
+type Row struct { Prefix byte; Payload [Count]Alias; Tail uintptr }
+type Node struct { Next *Node }
+func Probe(row Row, node *Node, text string, data []Alias, z complex64) (word uintptr, ok bool)
+`
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			input, pkg, declaration := instrumentationReplayFixture(t, source, arch)
+			if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+				t.Fatal(err)
+			}
+			for name, mutate := range map[string]func(*plan9asm.FuncSig){
+				"argument type":      func(sig *plan9asm.FuncSig) { sig.Args[0] = plan9asm.I8 },
+				"argument count":     func(sig *plan9asm.FuncSig) { sig.Args = sig.Args[:len(sig.Args)-1] },
+				"parameter offset":   func(sig *plan9asm.FuncSig) { sig.Frame.Params[0].Offset++ },
+				"parameter index":    func(sig *plan9asm.FuncSig) { sig.Frame.Params[0].Index++ },
+				"parameter field":    func(sig *plan9asm.FuncSig) { sig.Frame.Params[0].Field++ },
+				"nested field":       func(sig *plan9asm.FuncSig) { sig.Frame.Params[1].Fields[1]++ },
+				"parameter name":     func(sig *plan9asm.FuncSig) { sig.Frame.Params[0].Name = "invented" },
+				"return type":        func(sig *plan9asm.FuncSig) { sig.Ret = plan9asm.I8 },
+				"result offset":      func(sig *plan9asm.FuncSig) { sig.Frame.Results[0].Offset++ },
+				"result type":        func(sig *plan9asm.FuncSig) { sig.Frame.Results[0].Type = plan9asm.I8 },
+				"result name":        func(sig *plan9asm.FuncSig) { sig.Frame.Results[0].Name = "invented" },
+				"missing parameters": func(sig *plan9asm.FuncSig) { sig.Frame.Params = nil },
+				"missing results":    func(sig *plan9asm.FuncSig) { sig.Frame.Results = nil },
+			} {
+				t.Run(name, func(t *testing.T) {
+					changed := declaration
+					var layout plan9asm.FuncSig
+					if err := json.Unmarshal(declaration.Layout, &layout); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&layout)
+					var err error
+					changed.Layout, err = json.Marshal(layout)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{changed}); err == nil {
+						t.Fatal("paired metadata could invent an ordinary ABI0 layout")
+					}
+				})
+			}
+			changed := declaration
+			changed.GoType = "func() uint8"
+			if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{changed}); err == nil {
+				t.Fatal("metadata GoType overrode original compiled source")
+			}
+		})
+	}
+}
+
+func TestInstrumentationDeclarationReplayRequiresOriginalTargetAndCompleteLocalClosure(t *testing.T) {
+	input, pkg, declaration := instrumentationReplayFixture(t, `package replay
+type Alias = uintptr
+const Count = 3
+func Probe(a [Count]Alias) uintptr
+`, "arm64")
+	input.Plan.Target = "linux/386"
+	if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+		t.Fatal("64-bit metadata supplied a different target gc layout")
+	}
+	input.Plan.Target = "linux/arm64"
+	input.Sources.Contents["replay.go"] = strings.Replace(input.Sources.Contents["replay.go"], "const Count = 3", "const Count = 4", 1)
+	if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+		t.Fatal("unchanged function AST digest concealed an altered constant array layout")
+	}
+	input.Sources.Contents["replay.go"] = strings.Replace(input.Sources.Contents["replay.go"], "type Alias = uintptr", "", 1)
+	if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+		t.Fatal("missing original local type was supplied by metadata")
+	}
+}
+
+func TestInstrumentationDeclarationReplayRejectsUnclosedImportedTypesAndConstants(t *testing.T) {
+	for name, source := range map[string]string{
+		"imported type":            "package replay\nimport external \"example.invalid/external\"\nfunc Probe(a external.Value) uintptr\n",
+		"imported constant":        "package replay\nimport external \"example.invalid/external\"\nconst Count = external.Size\nfunc Probe(a [Count]byte) uintptr\n",
+		"local unknown type":       "package replay\nfunc Probe(a Missing) uintptr\n",
+		"local variable length":    "package replay\nvar Count = 3\nfunc Probe(a [Count]byte) uintptr\n",
+		"generic type":             "package replay\ntype Box[T any] struct { Value T }\nfunc Probe(a Box[uint64]) uintptr\n",
+		"unbounded constant array": "package replay\nconst Count = 1 << 30\nfunc Probe(a [Count]byte) uintptr\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			input := &InstrumentationConsumerInput{
+				Plan:        &InstrumentationOriginalPackagePlan{Target: "linux/arm64", PackageName: "replay"},
+				Sources:     &InstrumentationOriginalSourceInventory{Contents: map[string]string{"replay.go": source}},
+				Observation: &InstrumentationExportObservation{Early: &InstrumentationEarlyObservation{BaselineFeatures: &Observation{GoVersion: runtime.Version()}}},
+			}
+			pkg := PackageProof{PackagePath: "example.invalid/replay", CompiledGoFiles: []string{"replay.go"}}
+			declaration := InstrumentationDeclarationProof{Symbol: pkg.PackagePath + ".Probe"}
+			if err := replayInstrumentationDeclarationLayouts(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+				t.Fatal("metadata invented an unavailable original source/type/constant closure")
+			}
+		})
+	}
+}
+
+func TestInstrumentationDeclarationReplayRetainsCrossFileNamesAndConstantGroups(t *testing.T) {
+	const source = `package replay
+type uint16 uint64
+type Alias = uint16
+const (
+	_ = iota
+	Count
+	_ = iota
+	Length
+)
+func Probe(a [Length]Alias) uintptr
+`
+	input, pkg, declaration := instrumentationReplayFixture(t, source, "arm64")
+	declarationSource := "package replay\nfunc Probe(a [Length]Alias) uintptr\n"
+	typeSource := strings.Replace(source, declarationSource[len("package replay\n"):], "", 1)
+	input.Sources.Contents = map[string]string{"declaration.go": declarationSource, "types.go": typeSource}
+	pkg.CompiledGoFiles = []string{"declaration.go", "types.go"}
+	declaration.File = "declaration.go"
+	if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+		t.Fatal(err)
+	}
+	pkg.CompiledGoFiles = pkg.CompiledGoFiles[:1]
+	if err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+		t.Fatal("missing compiled sibling source supplied type/constant authority")
+	}
+}
+
+func TestInstrumentationDeclarationReplayZeroSizedParameterNeedsClosedBuilderAgreement(t *testing.T) {
+	input, pkg, declaration := instrumentationReplayFixture(t, "package replay\nfunc Probe(values [0]byte) uint64\n", "arm64")
+	err := validateInstrumentationPackageDeclarations(input, pkg, []InstrumentationDeclarationProof{declaration})
+	if err == nil || !strings.Contains(err.Error(), "two-builder zero-sized parameter difference") {
+		t.Fatalf("known root/CLI ABI0 difference became an accepted layout or invalid source: %v", err)
+	}
+}
+
+func TestInstrumentationABI0ReplayBoundsZeroSizedAggregateWork(t *testing.T) {
+	const source = `package replay
+type Huge struct { Empty [4096][4096]struct{}; Last byte }
+func Probe(values Huge) uint64
+`
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "replay.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	typed, err := (&types.Config{Sizes: types.SizesFor("gc", "arm64")}).Check("example.invalid/replay", set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	function := typed.Scope().Lookup("Probe").(*types.Func)
+	if err := boundInstrumentationABI0Layout(function.Type().(*types.Signature)); err == nil {
+		t.Fatal("empty aggregate slots concealed unbounded recursive ABI0 expansion work")
+	}
+}
+
+func TestInstrumentationABI0ReplayWorkBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		name, parameters, result string
+		accepted                 bool
+	}{
+		{"exact total", "[4095]byte", "uint64", true},
+		{"over total", "[4096]byte", "uint64", false},
+		{"nested exact", "[64][64]byte", "", true},
+		{"nested over", "[65][64]byte", "", false},
+		{"zero array nested over", "[4096][4096][0]byte", "", false},
+		{"deep nesting", strings.Repeat("[1]", 130) + "byte", "", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "package replay\nfunc Probe(values " + test.parameters + ") " + test.result + "\n"
+			set := token.NewFileSet()
+			file, err := parser.ParseFile(set, "replay.go", source, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			typed, err := (&types.Config{Sizes: types.SizesFor("gc", "arm64")}).Check("example.invalid/replay", set, []*ast.File{file}, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = boundInstrumentationABI0Layout(typed.Scope().Lookup("Probe").Type().(*types.Signature))
+			if (err == nil) != test.accepted {
+				t.Fatalf("typed source expansion bound = %v, want accepted=%v", err, test.accepted)
+			}
+		})
+	}
+}
+
+func instrumentationReplayFixture(t *testing.T, source, arch string) (*InstrumentationConsumerInput, PackageProof, InstrumentationDeclarationProof) {
+	t.Helper()
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "replay.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	const packagePath = "example.invalid/replay"
+	sizes := types.SizesFor("gc", arch)
+	typed, err := (&types.Config{Sizes: sizes}).Check(packagePath, set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	function := typed.Scope().Lookup("Probe").(*types.Func)
+	layout, err := plan9asm.DeriveGoFuncABI0Signature(packagePath+".Probe", function, arch, sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(layout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration := InstrumentationDeclarationProof{Symbol: layout.Name, File: "replay.go", GoType: types.TypeString(function.Type(), func(pkg *types.Package) string { return pkg.Path() }), Layout: data}
+	for _, node := range file.Decls {
+		if function, ok := node.(*ast.FuncDecl); ok && function.Name.Name == "Probe" {
+			declaration.DeclarationSHA256, err = ASTSHA(set, function)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	input := &InstrumentationConsumerInput{
+		Plan:        &InstrumentationOriginalPackagePlan{Target: "linux/" + arch, PackageName: "replay"},
+		Sources:     &InstrumentationOriginalSourceInventory{Contents: map[string]string{"replay.go": source}},
+		Observation: &InstrumentationExportObservation{Early: &InstrumentationEarlyObservation{BaselineFeatures: &Observation{GoVersion: runtime.Version()}}},
+	}
+	return input, PackageProof{PackagePath: packagePath, CompiledGoFiles: []string{"replay.go"}}, declaration
+}
diff --git a/gotoolprofile/instrumentation_metadata.go b/gotoolprofile/instrumentation_metadata.go
new file mode 100644
index 000000000..bf50323cf
--- /dev/null
+++ b/gotoolprofile/instrumentation_metadata.go
@@ -0,0 +1,198 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+const InstrumentationMetadataProtocol = "actual_go_instrumentation_metadata_v1"
+const InstrumentationGeneratedHeaderProtocol = "actual_go_instrumentation_asmhdr_v1"
+
+// InstrumentationMetadataProof is a query-only result. It binds the actual
+// same-mode original selection, dependency exports and complete native header.
+// It never certifies CPP, LLVM, C/SDK, sanitizers, final linking or execution.
+type InstrumentationMetadataProof struct {
+	Protocol               string                                `json:"protocol"`
+	ModeProfileID          string                                `json:"mode_profile_id"`
+	InputSHA256            string                                `json:"input_sha256"`
+	Selection              *InstrumentationPackageSelectionProof `json:"selection"`
+	Headers                []InstrumentationGeneratedHeader      `json:"headers"`
+	Dependencies           []InstrumentationDependencyExport     `json:"dependencies"`
+	Declarations           []InstrumentationDeclarationProof     `json:"actual_go_declarations"`
+	OriginalExportSHA256   string                                `json:"original_export_sha256"`
+	InvocationConfigSHA256 map[string]string                     `json:"invocation_config_sha256"`
+	LoadBuildFlags         []string                              `json:"load_build_flags"`
+	VetArgs                []string                              `json:"vet_args"`
+	Status                 string                                `json:"status"`
+}
+
+type InstrumentationGeneratedHeader struct {
+	Header        GeneratedHeaderProof `json:"header"`
+	CompilerFlags []string             `json:"compiler_flags"`
+}
+
+// Dependency source and export digests are observations of the actual bounded
+// source/type/export load, not independent ZIP membership proofs. External
+// foreign modules remain unsupported here until their authentication is bound.
+type InstrumentationDependencyExport struct {
+	Source    ImportExport      `json:"source"`
+	ImportMap map[string]string `json:"import_map"`
+}
+
+func InstrumentationHeaderCompilerFlags(input *InstrumentationConsumerInput) ([]string, error) {
+	if input == nil || input.Plan == nil {
+		return nil, fmt.Errorf("missing original mode header scope")
+	}
+	if err := ValidateInstrumentationConsumerInput(input, input.Plan.PackageDirectory, input.Plan.CustomTags); err != nil {
+		return nil, err
+	}
+	flags := append([]string(nil), input.Plan.BuildFlags...)
+	return append(flags, input.Observation.BuildPlan.CodegenFlags...), nil
+}
+
+func ValidateInstrumentationGeneratedHeader(input *InstrumentationConsumerInput, proof InstrumentationGeneratedHeader, pkg PackageProof) error {
+	flags, err := InstrumentationHeaderCompilerFlags(input)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(proof.CompilerFlags, flags) {
+		return fmt.Errorf("header compiler flags differ from the actual complete mode routing")
+	}
+	return validateGeneratedHeaderContext(input.Original, proof.Header, pkg, generatedHeaderValidationContext{
+		protocol: InstrumentationGeneratedHeaderProtocol, id: input.ID, observed: input.Observation.Early.BaselineFeatures,
+		validateMacros: func() error { return ValidateInstrumentationAssemblerMacros(pkg.Macros, input, pkg.PackagePath) },
+	})
+}
+
+func DecodeInstrumentationMetadata(reader io.Reader, input *InstrumentationConsumerInput, directory string, tags []string) (*InstrumentationMetadataProof, error) {
+	var proof InstrumentationMetadataProof
+	if err := decodeInstrumentationOriginalJSON(reader, 16<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationMetadata(input, directory, tags, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+func ValidateInstrumentationMetadata(input *InstrumentationConsumerInput, directory string, tags []string, proof *InstrumentationMetadataProof) error {
+	if err := ValidateInstrumentationConsumerInput(input, directory, tags); err != nil {
+		return err
+	}
+	if proof == nil || proof.Protocol != InstrumentationMetadataProtocol || proof.ModeProfileID != input.ID ||
+		proof.InputSHA256 != InstrumentationConsumerInputSHA256(input) || proof.Status != "consumer_pending" || len(proof.Headers) != 1 {
+		return fmt.Errorf("mode metadata lost its independent source/profile/query identity")
+	}
+	if !discoverySHA256Pattern.MatchString(proof.OriginalExportSHA256) ||
+		len(proof.InvocationConfigSHA256) < 1 || len(proof.InvocationConfigSHA256) > 2 ||
+		!discoverySHA256Pattern.MatchString(proof.InvocationConfigSHA256["go.mod"]) {
+		return fmt.Errorf("mode metadata lacks its actual original export/invocation configuration")
+	}
+	for name, digest := range proof.InvocationConfigSHA256 {
+		if name != "go.mod" && name != "go.sum" || !discoverySHA256Pattern.MatchString(digest) {
+			return fmt.Errorf("mode invocation has unknown/missing configuration")
+		}
+	}
+	flags, err := InstrumentationPackageLoadFlags(input)
+	if err != nil || !reflect.DeepEqual(flags, proof.LoadBuildFlags) || !reflect.DeepEqual(proof.VetArgs, InstrumentationPackageVetArgs(input)) {
+		return fmt.Errorf("mode export/asmdecl flags lost their exact original scope")
+	}
+	if err := ValidateInstrumentationPackageSelection(input, directory, tags, proof.Selection); err != nil {
+		return err
+	}
+	pkg := proof.Selection.Packages[0]
+	if err := validateInstrumentationPackageDeclarations(input, pkg, proof.Declarations); err != nil {
+		return err
+	}
+	if err := ValidateInstrumentationGeneratedHeader(input, proof.Headers[0], pkg); err != nil {
+		return err
+	}
+	if err := validateInstrumentationTypeSourceAgreement(input, proof.Headers[0].Header, proof.Dependencies); err != nil {
+		return err
+	}
+	return validateInstrumentationMetadataDependencies(input, pkg, proof.Headers[0].Header, proof.Dependencies)
+}
+
+func InstrumentationPackageLoadFlags(input *InstrumentationConsumerInput) ([]string, error) {
+	if input == nil || input.Plan == nil {
+		return nil, fmt.Errorf("missing actual mode package scope")
+	}
+	if err := ValidateInstrumentationConsumerInput(input, input.Plan.PackageDirectory, input.Plan.CustomTags); err != nil {
+		return nil, err
+	}
+	flags := append([]string{"-mod=readonly", "-p=1"}, input.Plan.BuildFlags...)
+	if len(input.Plan.CustomTags) != 0 {
+		flags = append(flags, "-tags="+strings.Join(input.Plan.CustomTags, ","))
+	}
+	return flags, nil
+}
+
+// The exact actual package path is used from an independent invocation module;
+// a downloaded external package must not become an invented versionless main.
+func InstrumentationPackageVetArgs(input *InstrumentationConsumerInput) []string {
+	if input == nil || input.Plan == nil {
+		return nil
+	}
+	if _, err := InstrumentationPackageLoadFlags(input); err != nil {
+		return nil
+	}
+	return instrumentationOrdinaryAsmdeclArgs()
+}
+
+func validateInstrumentationMetadataDependencies(input *InstrumentationConsumerInput, pkg PackageProof, header GeneratedHeaderProof, dependencies []InstrumentationDependencyExport) error {
+	if dependencies == nil || len(dependencies) > 4096 || !sort.SliceIsSorted(dependencies, func(i, j int) bool { return dependencies[i].Source.PackagePath < dependencies[j].Source.PackagePath }) {
+		return fmt.Errorf("mode dependency export closure is not bounded/canonical")
+	}
+	byPath := make(map[string]InstrumentationDependencyExport)
+	for _, dep := range dependencies {
+		source := dep.Source
+		if source.PackagePath == "" || source.PackagePath == pkg.PackagePath || source.PackagePath == "unsafe" || source.ImportPath != source.PackagePath ||
+			byPath[source.PackagePath].Source.PackagePath != "" || !discoverySHA256Pattern.MatchString(source.ExportSHA256) ||
+			len(source.GoSHA256) == 0 || len(source.GoSHA256) > 32768 || dep.ImportMap == nil || len(dep.ImportMap) > 4096 {
+			return fmt.Errorf("mode dependency lacks a unique actual export/source/import closure")
+		}
+		if source.ModulePath != "" && source.ModulePath != input.Original.Module && !instrumentationForeignDependencyBound(input, source) {
+			return fmt.Errorf("mode foreign dependency needs its independent authenticated original source closure")
+		}
+		if err := validateImportedSource(input.Original, pkg, source); err != nil {
+			return err
+		}
+		byPath[source.PackagePath] = dep
+	}
+	for _, imported := range header.Imports {
+		actual := byPath[imported.PackagePath].Source
+		actual.ImportPath = imported.ImportPath
+		if !reflect.DeepEqual(actual, imported) {
+			return fmt.Errorf("mode header import differs from the same-load dependency export/source")
+		}
+	}
+	visited := make(map[string]bool)
+	queue := []map[string]string{header.ImportMap}
+	for len(queue) != 0 {
+		imports := queue[0]
+		queue = queue[1:]
+		for spelling, target := range imports {
+			if spelling == "" || target == "" || strings.ContainsAny(spelling+target, "\r\n=\\") || spelling == "unsafe" && target != "unsafe" {
+				return fmt.Errorf("mode dependency has an invalid actual ImportMap")
+			}
+			if target == "unsafe" {
+				continue
+			}
+			dep, exists := byPath[target]
+			if !exists {
+				return fmt.Errorf("mode dependency export closure omitted a reachable package: %s", target)
+			}
+			if !visited[target] {
+				visited[target] = true
+				queue = append(queue, dep.ImportMap)
+			}
+		}
+	}
+	if len(visited) != len(dependencies) {
+		return fmt.Errorf("mode dependency export closure contains an unselected package")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_metadata_test.go b/gotoolprofile/instrumentation_metadata_test.go
new file mode 100644
index 000000000..a57ca4baa
--- /dev/null
+++ b/gotoolprofile/instrumentation_metadata_test.go
@@ -0,0 +1,23 @@
+package gotoolprofile
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationMetadataAndObjectReadersRequireIndependentContexts(t *testing.T) {
+	for _, input := range []*InstrumentationConsumerInput{nil, {}, {Plan: &InstrumentationOriginalPackagePlan{}}} {
+		if _, err := InstrumentationHeaderCompilerFlags(input); err == nil {
+			t.Fatal("missing actual mode context supplied compiler flags")
+		}
+		if _, err := InstrumentationPackageLoadFlags(input); err == nil {
+			t.Fatal("missing actual mode context supplied package flags")
+		}
+		if _, err := DecodeInstrumentationMetadata(strings.NewReader(`{}`), input, ".", nil); err == nil {
+			t.Fatal("unbound metadata acquired a mode/source role")
+		}
+		if _, err := DecodeInstrumentationConsumption(strings.NewReader(`{}`), input, nil, nil, ".", nil); err == nil {
+			t.Fatal("unbound objects acquired mode/source/LLVM evidence")
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_module.go b/gotoolprofile/instrumentation_module.go
new file mode 100644
index 000000000..27bc1611e
--- /dev/null
+++ b/gotoolprofile/instrumentation_module.go
@@ -0,0 +1,57 @@
+package gotoolprofile
+
+import (
+	"fmt"
+
+	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
+)
+
+// InstrumentationOriginalModulePath derives a namespace from complete original
+// ZIP go.mod bytes, not a requested path or a caller-supplied namespace override.
+// Its caller must independently authenticate the archive/member and guard the
+// original bytes before and after every actual source/export/object phase.
+func InstrumentationOriginalModulePath(contents, expectedSHA256 string) (string, error) {
+	if len(contents) == 0 || len(contents) > instrumentationOriginalFileLimit ||
+		!discoverySHA256Pattern.MatchString(expectedSHA256) || bytesSHA256([]byte(contents)) != expectedSHA256 {
+		return "", fmt.Errorf("original module namespace lacks bounded unchanged ZIP metadata")
+	}
+	parsed, err := modfile.Parse("go.mod", []byte(contents), nil)
+	if err != nil || parsed.Module == nil || module.CheckPath(parsed.Module.Mod.Path) != nil {
+		return "", fmt.Errorf("original module namespace has invalid or missing module metadata: %v", err)
+	}
+	return parsed.Module.Mod.Path, nil
+}
+
+func validateInstrumentationModuleNamespace(input *ConsumerInput, contents string) error {
+	if input == nil || input.SourceModule == "" && input.Version != "" || input.SourceModule != "" &&
+		(module.Check(input.SourceModule, input.Version) != nil || module.Check(input.Module, input.Version) != nil) {
+		return fmt.Errorf("original source role lacks an exact external identity or genuine versionless main module")
+	}
+	alias := input.SourceModule != "" && input.SourceModule != input.Module
+	if !alias {
+		if contents != "" {
+			return fmt.Errorf("unaliasable module carries unexplained namespace metadata")
+		}
+		return nil
+	}
+	// A legacy proxy directive is a separate authenticated origin and cannot
+	// supply a fictitious ZIP member or authorize another namespace here.
+	if input.ProxyGoMod != nil {
+		return fmt.Errorf("proxy go.mod cannot supply an original ZIP namespace alias")
+	}
+	members := 0
+	for _, name := range input.Directories["."] {
+		if name == "go.mod" {
+			members++
+		}
+	}
+	if members != 1 {
+		return fmt.Errorf("original alias lacks its unique complete root-directory go.mod member")
+	}
+	declared, err := InstrumentationOriginalModulePath(contents, input.Sources["go.mod"])
+	if err != nil || declared != input.Module {
+		return fmt.Errorf("original namespace differs from the exact ZIP module declaration: %v", err)
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_module_test.go b/gotoolprofile/instrumentation_module_test.go
new file mode 100644
index 000000000..1ec913a54
--- /dev/null
+++ b/gotoolprofile/instrumentation_module_test.go
@@ -0,0 +1,127 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestInstrumentationOriginalModuleNamespaceBindsOriginalBytesAndArchive(t *testing.T) {
+	contents := "module example.invalid/canonical\n\ngo 1.20\n"
+	input := &ConsumerInput{
+		Module: "example.invalid/canonical", SourceModule: "example.invalid/archive", Version: "v1.0.0",
+		SourceRoot: "/original-offline", Sources: map[string]string{"go.mod": bytesSHA256([]byte(contents))},
+		Directories: map[string][]string{".": {"go.mod", "probe.go"}},
+	}
+	body := "package probe\n"
+	input.Sources["probe.go"] = bytesSHA256([]byte(body))
+	inventory := &InstrumentationOriginalSourceInventory{
+		Protocol: instrumentationOriginalSourcesProtocol, Module: input.Module, Version: input.Version, Directory: ".",
+		Contents: map[string]string{"probe.go": body}, ModuleMetadata: contents,
+	}
+	if err := ValidateInstrumentationOriginalSourceInventory(input, ".", inventory); err != nil {
+		t.Fatal(err)
+	}
+	encoded, err := json.Marshal(struct {
+		Input   *ConsumerInput
+		Sources *InstrumentationOriginalSourceInventory
+	}{input, inventory})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*ConsumerInput, *InstrumentationOriginalSourceInventory){
+		"missing original bytes": func(_ *ConsumerInput, p *InstrumentationOriginalSourceInventory) { p.ModuleMetadata = "" },
+		"changed original bytes": func(_ *ConsumerInput, p *InstrumentationOriginalSourceInventory) { p.ModuleMetadata += "// changed\n" },
+		"changed namespace": func(i *ConsumerInput, p *InstrumentationOriginalSourceInventory) {
+			i.Module, p.Module = "example.invalid/other", "example.invalid/other"
+		},
+		"missing original member": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) { delete(i.Sources, "go.mod") },
+		"missing directory member": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) {
+			i.Directories["."] = []string{"probe.go"}
+		},
+		"duplicate directory member": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) {
+			i.Directories["."] = []string{"go.mod", "go.mod", "probe.go"}
+		},
+		"unbound metadata digest": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) {
+			i.Sources["go.mod"] = strings.Repeat("0", 64)
+		},
+		"main instead of archive": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) { i.SourceModule = "" },
+		"malformed archive path":  func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) { i.SourceModule = "bad archive" },
+		"wrong version major": func(i *ConsumerInput, p *InstrumentationOriginalSourceInventory) {
+			i.Version, p.Version = "v2.0.0", "v2.0.0"
+		},
+		"proxy instead of ZIP origin": func(i *ConsumerInput, _ *InstrumentationOriginalSourceInventory) { i.ProxyGoMod = &ProxyGoModProof{} },
+		"paired alias deletion": func(i *ConsumerInput, p *InstrumentationOriginalSourceInventory) {
+			i.Module, p.Module = i.SourceModule, i.SourceModule
+			// Retaining the original metadata cannot authorize this requested
+			// namespace: the actual source declaration still says canonical.
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var copied struct {
+				Input   *ConsumerInput
+				Sources *InstrumentationOriginalSourceInventory
+			}
+			if err := json.Unmarshal(encoded, &copied); err != nil {
+				t.Fatal(err)
+			}
+			change(copied.Input, copied.Sources)
+			if err := ValidateInstrumentationOriginalSourceInventory(copied.Input, ".", copied.Sources); err == nil {
+				t.Fatal("accepted an unbound original module namespace")
+			}
+		})
+	}
+}
+
+func TestInstrumentationOriginalModuleNamespaceRejectsInvalidMetadata(t *testing.T) {
+	for _, contents := range []string{
+		"", "go 1.20\n", "module bad module\n", "module example.invalid/a\nmodule example.invalid/b\n",
+		"module example.invalid/a\nunknown_directive x\n", strings.Repeat("x", instrumentationOriginalFileLimit+1),
+	} {
+		if _, err := InstrumentationOriginalModulePath(contents, bytesSHA256([]byte(contents))); err == nil {
+			t.Fatalf("accepted invalid or over-bound original module metadata (%d bytes)", len(contents))
+		}
+	}
+}
+
+func TestInstrumentationOriginalModuleNamespaceCaptureRejectsChangedAndRedirectedSource(t *testing.T) {
+	root := t.TempDir()
+	metadata := "module example.invalid/canonical\n\ngo 1.20\n"
+	body := "package probe\n"
+	for name, value := range map[string]string{"go.mod": metadata, "probe.go": body} {
+		if err := os.WriteFile(filepath.Join(root, name), []byte(value), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	input := &ConsumerInput{
+		Module: "example.invalid/canonical", SourceModule: "example.invalid/archive", Version: "v1.0.0", SourceRoot: root,
+		Sources:     map[string]string{"go.mod": bytesSHA256([]byte(metadata)), "probe.go": bytesSHA256([]byte(body))},
+		Directories: map[string][]string{".": {"go.mod", "probe.go"}},
+	}
+	captured, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil || captured.ModuleMetadata != metadata {
+		t.Fatalf("capture changed the complete original namespace bytes: %v", err)
+	}
+	filename := filepath.Join(root, "go.mod")
+	if err := os.WriteFile(filename, []byte(metadata+"// changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CaptureInstrumentationOriginalSourceInventory(input, "."); err == nil {
+		t.Fatal("captured source changed after registration")
+	}
+	if err := os.Remove(filename); err != nil {
+		t.Fatal(err)
+	}
+	copy := filepath.Join(t.TempDir(), "go.mod")
+	if err := os.WriteFile(copy, []byte(metadata), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(copy, filename); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CaptureInstrumentationOriginalSourceInventory(input, "."); err == nil {
+		t.Fatal("captured symlink instead of the original module member")
+	}
+}
diff --git a/gotoolprofile/instrumentation_observation.go b/gotoolprofile/instrumentation_observation.go
new file mode 100644
index 000000000..d7536176a
--- /dev/null
+++ b/gotoolprofile/instrumentation_observation.go
@@ -0,0 +1,345 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const instrumentationEarlyObservationProtocol = "actual_go_instrumentation_early_observation_v2"
+
+// InstrumentationEarlyObservation proves only stock Go's early target rule
+// and finite marker selection under one real mode. It is deliberately not an
+// export, compiler, sanitizer-runtime or original-source exclusion proof.
+// BaselineFeatures supplies CPU/experiment provenance only: its CGO=0 marker
+// selection never impersonates this mode's separately observed environment.
+type InstrumentationEarlyObservation struct {
+	Protocol              string                      `json:"protocol"`
+	Target                string                      `json:"target"`
+	Mode                  InstrumentationMode         `json:"mode"`
+	CGOEnabled            string                      `json:"cgo_enabled"`
+	BuildFlags            []string                    `json:"build_flags"`
+	BaselineFeatures      *Observation                `json:"baseline_cpu_features"`
+	ModeTools             *InstrumentationToolState   `json:"mode_tools"`
+	SourceRules           *InstrumentationSourceProof `json:"source_rules"`
+	Environment           map[string]string           `json:"environment"`
+	CommandContext        map[string]string           `json:"command_context"`
+	EnvironmentSHA256     string                      `json:"environment_sha256"`
+	ContextSHA256         string                      `json:"context_sha256"`
+	CommandArgs           []string                    `json:"command_args"`
+	ExitCode              int                         `json:"exit_code"`
+	DriverSelectionSHA256 string                      `json:"driver_selection_sha256"`
+	Stderr                string                      `json:"stderr"`
+	Status                InstrumentationEarlyStatus  `json:"status"`
+	MarkerSelection       map[string]bool             `json:"marker_selection"`
+	MarkerSourceSHA256    string                      `json:"marker_source_sha256"`
+}
+
+type InstrumentationToolState struct {
+	Directory        string            `json:"directory"`
+	BinarySHA256     map[string]string `json:"binary_sha256"`
+	BinaryOrigins    map[string]string `json:"binary_origins"`
+	RoutingSHA256    string            `json:"routing_sha256"`
+	DispatcherSHA256 string            `json:"dispatcher_sha256"`
+}
+
+func InstrumentationEarlyProfileID(observed *InstrumentationEarlyObservation) string {
+	if observed == nil {
+		return ""
+	}
+	data, _ := json.Marshal(observed)
+	return bytesSHA256(data)
+}
+
+func CaptureInstrumentationEarlyObservation(ctx context.Context, binary, ownedDir string, env []string, target string, mode InstrumentationMode, cgo string, overrides map[string]string, run Runner) (*InstrumentationEarlyObservation, error) {
+	if ctx == nil || ctx.Err() != nil || run == nil {
+		return nil, fmt.Errorf("instrumentation observer requires a live context and bounded runner")
+	}
+	flags, err := InstrumentationBuildFlags(mode)
+	if err != nil {
+		return nil, err
+	}
+	if cgo != "0" && cgo != "1" {
+		return nil, fmt.Errorf("instrumentation observer requires explicit CGO=0 or CGO=1")
+	}
+	// An actual mode observation owns its configuration. Do not silently
+	// read a private user go/env file, even when every CPU override is empty.
+	env = replaceEnv(env, map[string]string{"GOENV": "off"})
+	if !filepath.IsAbs(binary) || !filepath.IsAbs(ownedDir) {
+		return nil, fmt.Errorf("instrumentation driver and owned directory must be absolute")
+	}
+	ownedDir, err = sourcepath.Resolve(ownedDir)
+	if err != nil {
+		return nil, err
+	}
+	entries, err := os.ReadDir(ownedDir)
+	if err != nil || len(entries) != 0 {
+		return nil, fmt.Errorf("instrumentation observer directory must exist and be empty")
+	}
+	baselineDir, markerDir := filepath.Join(ownedDir, "baseline"), filepath.Join(ownedDir, "mode")
+	for _, dir := range []string{baselineDir, markerDir} {
+		if err := os.Mkdir(dir, 0700); err != nil {
+			return nil, err
+		}
+	}
+	baseline, err := Capture(ctx, binary, baselineDir, env, target, overrides, run)
+	if err != nil {
+		return nil, err
+	}
+	if err := Validate(baseline); err != nil {
+		return nil, err
+	}
+	replacements := copyInstrumentationHashes(baseline.Environment)
+	delete(replacements, "GOVERSION")
+	replacements["CGO_ENABLED"], replacements["GOTOOLCHAIN"] = cgo, "local"
+	replacements["GOWORK"], replacements["GOFLAGS"], replacements["GOPACKAGESDRIVER"] = "off", "", "off"
+	modeEnv := replaceEnv(env, replacements)
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, markerDir, modeEnv, run)
+	if err != nil {
+		return nil, err
+	}
+	beforeTools, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil {
+		return nil, err
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil {
+		return nil, err
+	}
+	rules, err := ReplayInstrumentationSourceProof(sources)
+	if err != nil {
+		return nil, err
+	}
+	tags := instrumentationObserverTags(baseline)
+	files := MarkerFiles(tags)
+	for name, contents := range files {
+		file, err := os.OpenFile(filepath.Join(markerDir, name), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+		if err != nil {
+			return nil, err
+		}
+		_, writeErr := file.Write(contents)
+		closeErr := file.Close()
+		if writeErr != nil || closeErr != nil {
+			return nil, fmt.Errorf("write instrumentation marker: %v (close: %v)", writeErr, closeErr)
+		}
+	}
+	args := append([]string{"list", "-find", "-json", "-mod=readonly"}, flags...)
+	args = append(args, ".")
+	stdout, stderr, commandErr := run(ctx, markerDir, modeEnv, binary, args...)
+	status, err := ClassifyInstrumentationEarlyResult(rules, target, mode, stdout, stderr, commandErr)
+	if err != nil {
+		return nil, err
+	}
+	observed := &InstrumentationEarlyObservation{
+		Protocol: instrumentationEarlyObservationProtocol, Target: target, Mode: mode,
+		CGOEnabled: cgo, BuildFlags: flags, BaselineFeatures: baseline, SourceRules: sources,
+		ModeTools: &InstrumentationToolState{
+			Directory: beforeTools.directory, BinarySHA256: beforeTools.digests, BinaryOrigins: beforeTools.origins,
+			RoutingSHA256: beforeTools.routing, DispatcherSHA256: beforeTools.dispatcher,
+		},
+		CommandContext: commandContext, CommandArgs: args,
+		Stderr: string(stderr), Status: status, MarkerSourceSHA256: MarkerSHA256(files),
+	}
+	if status == InstrumentationEarlyRuleAccepted {
+		observed.MarkerSelection, err = DecodeMarkers(stdout, markerDir, tags)
+		if err != nil {
+			return nil, err
+		}
+		// Keep the complete decoded marker selection, not the private
+		// package Dir embedded in raw JSON. Reobservers own different
+		// marker directories but must produce this same portable identity.
+		observed.DriverSelectionSHA256 = instrumentationObjectSHA(observed.MarkerSelection)
+	} else {
+		observed.ExitCode = 2
+		observed.DriverSelectionSHA256 = bytesSHA256(nil)
+	}
+	after, afterContext, err := instrumentationObserverEnvironment(ctx, binary, markerDir, modeEnv, run)
+	if err != nil || !reflect.DeepEqual(actual, after) || !reflect.DeepEqual(commandContext, afterContext) {
+		return nil, fmt.Errorf("actual mode environment or command context changed during observation")
+	}
+	afterSources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(sources, afterSources) {
+		return nil, fmt.Errorf("instrumentation source rules changed during observation")
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil || !equalDiscoveryFeatureToolStates(beforeTools, tools) {
+		return nil, fmt.Errorf("actual driver subtool identity changed during instrumentation observation")
+	}
+	if hash, err := FileSHA256(binary); err != nil || hash != baseline.DriverSHA256 {
+		return nil, fmt.Errorf("actual driver changed during instrumentation observation")
+	}
+	for name, before := range baseline.ToolSourceSHA256 {
+		if hash, err := FileSHA256(filepath.Join(actual["GOROOT"], filepath.FromSlash(name))); err != nil || hash != before {
+			return nil, fmt.Errorf("actual CPU/experiment source changed during instrumentation observation: %s", name)
+		}
+	}
+	entries, err = os.ReadDir(markerDir)
+	if err != nil || len(entries) != len(files) {
+		return nil, fmt.Errorf("instrumentation marker inventory changed during observation")
+	}
+	for name, contents := range files {
+		if hash, err := FileSHA256(filepath.Join(markerDir, name)); err != nil || hash != bytesSHA256(contents) {
+			return nil, fmt.Errorf("instrumentation marker source changed during observation")
+		}
+	}
+	observed.Environment = copyInstrumentationHashes(actual)
+	for _, key := range []string{"GOROOT", "GOTOOLDIR", "GOCACHE"} {
+		delete(observed.Environment, key)
+	}
+	observed.EnvironmentSHA256 = instrumentationObjectSHA(observed.Environment)
+	observed.ContextSHA256 = instrumentationObjectSHA(commandContext)
+	if err := ValidateInstrumentationEarlyObservation(observed); err != nil {
+		return nil, err
+	}
+	return observed, nil
+}
+
+func instrumentationObserverEnvironment(ctx context.Context, binary, dir string, env []string, run Runner) (map[string]string, map[string]string, error) {
+	keys := append(append([]string(nil), discoveryFeatureEnvKeys...), "CC", "CXX", "GOFLAGS", "GODEBUG", "GOENV")
+	args := append([]string{"env", "-json"}, keys...)
+	stdout, stderr, err := run(ctx, dir, env, binary, args...)
+	if err != nil || len(stderr) != 0 {
+		return nil, nil, fmt.Errorf("actual instrumentation environment query failed or emitted unregistered diagnostics: %v", err)
+	}
+	var actual map[string]string
+	if err := json.Unmarshal(stdout, &actual); err != nil || len(actual) != len(keys) {
+		return nil, nil, fmt.Errorf("incomplete actual instrumentation environment query")
+	}
+	commandContext := make(map[string]string)
+	for _, key := range []string{"CC", "CXX", "GOFLAGS", "GODEBUG", "GOENV"} {
+		value, present := actual[key]
+		if !present {
+			return nil, nil, fmt.Errorf("missing actual instrumentation command context %s", key)
+		}
+		commandContext[key] = value
+		delete(actual, key)
+	}
+	return actual, commandContext, nil
+}
+
+func ValidateInstrumentationEarlyObservation(observed *InstrumentationEarlyObservation) error {
+	if observed == nil || observed.Protocol != instrumentationEarlyObservationProtocol {
+		return fmt.Errorf("missing actual instrumentation early-observation protocol")
+	}
+	if err := Validate(observed.BaselineFeatures); err != nil {
+		return err
+	}
+	base := observed.BaselineFeatures
+	if err := validateInstrumentationModeTools(observed.ModeTools, base); err != nil {
+		return err
+	}
+	rules, err := ReplayInstrumentationSourceProof(observed.SourceRules)
+	if err != nil {
+		return err
+	}
+	flags, err := InstrumentationBuildFlags(observed.Mode)
+	if err != nil || !reflect.DeepEqual(flags, observed.BuildFlags) || observed.Target != base.Target ||
+		observed.SourceRules.GoVersion != base.GoVersion || observed.SourceRules.SourceSHA256["VERSION"] != base.ToolSourceSHA256["VERSION"] {
+		return fmt.Errorf("mode/source/actual driver identity differs from the complete CPU foundation")
+	}
+	if observed.CGOEnabled != "0" && observed.CGOEnabled != "1" || len(observed.Environment) != len(base.Environment) {
+		return fmt.Errorf("incomplete or unobserved instrumentation environment")
+	}
+	for key, wanted := range base.Environment {
+		if key == "CGO_ENABLED" {
+			wanted = observed.CGOEnabled
+		}
+		if actual, present := observed.Environment[key]; !present || actual != wanted {
+			return fmt.Errorf("mode observer differs from its CPU foundation: %s", key)
+		}
+	}
+	// Stock Go reports an empty configuration filename for explicit GOENV=off.
+	if len(observed.CommandContext) != 5 || observed.CommandContext["GOFLAGS"] != "" || observed.CommandContext["GOENV"] != "" {
+		return fmt.Errorf("missing or arbitrary instrumentation command context")
+	}
+	for _, key := range []string{"CC", "CXX", "GOFLAGS", "GODEBUG", "GOENV"} {
+		if _, present := observed.CommandContext[key]; !present {
+			return fmt.Errorf("missing actual instrumentation command context %s", key)
+		}
+	}
+	if observed.EnvironmentSHA256 != instrumentationObjectSHA(observed.Environment) || observed.ContextSHA256 != instrumentationObjectSHA(observed.CommandContext) {
+		return fmt.Errorf("mode environment/context no longer matches its captured digest")
+	}
+	wantedArgs := append([]string{"list", "-find", "-json", "-mod=readonly"}, flags...)
+	wantedArgs = append(wantedArgs, ".")
+	tags := instrumentationObserverTags(base)
+	if !reflect.DeepEqual(observed.CommandArgs, wantedArgs) || observed.MarkerSourceSHA256 != MarkerSHA256(MarkerFiles(tags)) ||
+		!discoverySHA256Pattern.MatchString(observed.DriverSelectionSHA256) {
+		return fmt.Errorf("missing exact instrumentation early invocation or complete marker inputs")
+	}
+	supported, err := rules.TargetSupported(observed.Target, observed.Mode)
+	if err != nil {
+		return err
+	}
+	if !supported {
+		wantedStderr := fmt.Sprintf("-%s is not supported on %s\n", observed.Mode, observed.Target)
+		if observed.Status != InstrumentationOfficialTargetUnsupported || observed.ExitCode != 2 || observed.Stderr != wantedStderr ||
+			observed.DriverSelectionSHA256 != bytesSHA256(nil) || len(observed.MarkerSelection) != 0 {
+			return fmt.Errorf("unsupported rule requires one exact complete actual Exit2 observation")
+		}
+		return nil
+	}
+	if observed.Status != InstrumentationEarlyRuleAccepted || observed.ExitCode != 0 || observed.Stderr != "" || len(observed.MarkerSelection) != len(tags) {
+		return fmt.Errorf("eligible early mode observation is incomplete or has unregistered diagnostics")
+	}
+	if observed.DriverSelectionSHA256 != instrumentationObjectSHA(observed.MarkerSelection) {
+		return fmt.Errorf("actual complete marker selection changed after observation")
+	}
+	if required, err := rules.RequiresCGO(observed.Target, observed.Mode); err != nil || required && observed.CGOEnabled != "1" {
+		return fmt.Errorf("eligible early mode is missing the source-required CGO prerequisite")
+	}
+	for _, tag := range tags {
+		wanted, isBuiltin := base.MarkerSelection[tag]
+		if !isBuiltin {
+			wanted = tag == string(observed.Mode)
+		}
+		if actual, present := observed.MarkerSelection[tag]; !present || actual != wanted {
+			return fmt.Errorf("actual mode marker selection contradicts the requested mode or CPU/experiment: %s", tag)
+		}
+	}
+	return nil
+}
+
+func instrumentationObserverTags(baseline *Observation) []string {
+	tags := []string{"race", "msan", "asan"}
+	for tag := range baseline.MarkerSelection {
+		tags = append(tags, tag)
+	}
+	sort.Strings(tags)
+	return tags
+}
+
+func validateInstrumentationModeTools(tools *InstrumentationToolState, baseline *Observation) error {
+	if tools == nil || tools.Directory != baseline.ToolDirectory || tools.DispatcherSHA256 != baseline.ToolDispatcherSHA256 ||
+		!discoverySHA256Pattern.MatchString(tools.RoutingSHA256) {
+		return fmt.Errorf("missing independently observed mode tool routing/dispatcher identity")
+	}
+	copy := *baseline
+	// Reuse only the common tool-origin/digest grammar. This temporary value
+	// is never returned as a CGO=0 observation of the mode's builtin tools.
+	copy.ToolBinarySHA256, copy.ToolBinaryOrigins = tools.BinarySHA256, tools.BinaryOrigins
+	copy.ToolRoutingSHA256, copy.ToolDispatcherSHA256 = tools.RoutingSHA256, tools.DispatcherSHA256
+	if err := Validate(&copy); err != nil {
+		return err
+	}
+	for _, name := range discoveryFeatureSubtools {
+		origin := tools.BinaryOrigins[name]
+		if origin != baseline.ToolBinaryOrigins[name] ||
+			strings.HasPrefix(origin, "goroot/") && tools.BinarySHA256[name] != baseline.ToolBinarySHA256[name] {
+			return fmt.Errorf("mode observer used different installed Go %s tools", name)
+		}
+	}
+	return nil
+}
+
+func instrumentationObjectSHA(value any) string {
+	data, _ := json.Marshal(value)
+	return bytesSHA256(data)
+}
diff --git a/gotoolprofile/instrumentation_observation_test.go b/gotoolprofile/instrumentation_observation_test.go
new file mode 100644
index 000000000..0925dca39
--- /dev/null
+++ b/gotoolprofile/instrumentation_observation_test.go
@@ -0,0 +1,169 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+func instrumentationFixtureEnvironment(base []string, early *InstrumentationEarlyObservation) []string {
+	observed := copyInstrumentationHashes(early.Environment)
+	for key, value := range early.CommandContext {
+		observed[key] = value
+	}
+	// `go env GOENV` reports an empty value for the observer's explicit off
+	// policy. Do not restore a user's environment file for fixture commands.
+	observed["GOENV"] = "off"
+	return replaceEnv(base, observed)
+}
+
+func captureActualInstrumentationEarly(t *testing.T, target string, mode InstrumentationMode, cgo string) *InstrumentationEarlyObservation {
+	t.Helper()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	proof, err := CaptureInstrumentationEarlyObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), target, mode, cgo, nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return proof
+}
+
+func TestInstrumentationEarlyObservationActualDriverAndPortableReplay(t *testing.T) {
+	for _, input := range []struct {
+		target string
+		mode   InstrumentationMode
+		status InstrumentationEarlyStatus
+	}{
+		{"darwin/arm64", InstrumentationRace, InstrumentationEarlyRuleAccepted},
+		{"linux/386", InstrumentationRace, InstrumentationOfficialTargetUnsupported},
+		{"js/wasm", InstrumentationASan, InstrumentationOfficialTargetUnsupported},
+	} {
+		t.Run(input.target+"/"+string(input.mode), func(t *testing.T) {
+			proof := captureActualInstrumentationEarly(t, input.target, input.mode, "0")
+			if proof.Status != input.status {
+				t.Fatalf("unexpected early-rule status %s", proof.Status)
+			}
+			data, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var restored InstrumentationEarlyObservation
+			if err := json.Unmarshal(data, &restored); err != nil {
+				t.Fatal(err)
+			}
+			if err := ValidateInstrumentationEarlyObservation(&restored); err != nil {
+				t.Fatal(err)
+			}
+			if InstrumentationEarlyProfileID(&restored) != InstrumentationEarlyProfileID(proof) {
+				t.Fatal("source/driver/environment/mode evidence changed on roundtrip")
+			}
+		})
+	}
+	withoutCGO := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	newDirectory := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	if InstrumentationEarlyProfileID(withoutCGO) != InstrumentationEarlyProfileID(newDirectory) {
+		t.Fatal("private marker directory polluted portable source/driver/environment identity")
+	}
+	withCGO := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "1")
+	if withCGO.BaselineFeatures.Environment["CGO_ENABLED"] != "0" || withCGO.Environment["CGO_ENABLED"] != "1" ||
+		InstrumentationEarlyProfileID(withCGO) == InstrumentationEarlyProfileID(withoutCGO) {
+		t.Fatal("CGO=0 CPU foundation impersonated the independently observed CGO=1 mode")
+	}
+}
+
+func TestInstrumentationEarlyObservationRejectsDowngradeAndChangedModeEnvironment(t *testing.T) {
+	original := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	for name, mutate := range map[string]func(*InstrumentationEarlyObservation){
+		"missing protocol":       func(p *InstrumentationEarlyObservation) { p.Protocol = "" },
+		"downgrade":              func(p *InstrumentationEarlyObservation) { p.Protocol = "go_driver_builtin_features_v2" },
+		"missing baseline":       func(p *InstrumentationEarlyObservation) { p.BaselineFeatures = nil },
+		"missing mode tools":     func(p *InstrumentationEarlyObservation) { p.ModeTools = nil },
+		"changed installed tool": func(p *InstrumentationEarlyObservation) { p.ModeTools.BinarySHA256["asm"] = strings.Repeat("0", 64) },
+		"missing source":         func(p *InstrumentationEarlyObservation) { p.SourceRules = nil },
+		"different mode":         func(p *InstrumentationEarlyObservation) { p.Mode = InstrumentationASan },
+		"fake success":           func(p *InstrumentationEarlyObservation) { p.Status = "exported" },
+		"extra flags":            func(p *InstrumentationEarlyObservation) { p.BuildFlags = append(p.BuildFlags, "-asan") },
+		"CGO source mismatch":    func(p *InstrumentationEarlyObservation) { p.Environment["CGO_ENABLED"] = "1" },
+		"CPU source mismatch":    func(p *InstrumentationEarlyObservation) { p.Environment["GOARM64"] = "v8.4" },
+		"unknown stderr":         func(p *InstrumentationEarlyObservation) { p.Stderr = "unknown warning\n" },
+		"missing marker":         func(p *InstrumentationEarlyObservation) { delete(p.MarkerSelection, "msan") },
+		"fake mode marker":       func(p *InstrumentationEarlyObservation) { p.MarkerSelection["race"] = false },
+		"missing context":        func(p *InstrumentationEarlyObservation) { delete(p.CommandContext, "CC") },
+	} {
+		t.Run(name, func(t *testing.T) {
+			data, err := json.Marshal(original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var modified InstrumentationEarlyObservation
+			if err := json.Unmarshal(data, &modified); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&modified)
+			if err := ValidateInstrumentationEarlyObservation(&modified); err == nil {
+				t.Fatal("accepted changed, incomplete or downgraded early observation")
+			}
+		})
+	}
+}
+
+func TestInstrumentationEarlyObservationDoesNotTurnPrerequisitesIntoTargetExclusions(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	for _, mode := range []InstrumentationMode{InstrumentationRace, InstrumentationMSan} {
+		if _, err := CaptureInstrumentationEarlyObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "linux/amd64", mode, "0", nil, RunBounded); err == nil {
+			t.Fatal("missing CGO became an unsupported target or early accepted observation")
+		}
+	}
+	if InstrumentationEarlyProfileID(nil) != "" {
+		t.Fatal("nil early observation received an identity")
+	}
+	env := replaceEnv(os.Environ(), map[string]string{"GODEBUG": "cpu.plan9asm_unregistered=off"})
+	if _, err := CaptureInstrumentationEarlyObservation(ctx, binary, instrumentationMarkerDirectory(t), env, "darwin/arm64", InstrumentationRace, "0", nil, RunBounded); err == nil {
+		t.Fatal("actual unknown driver warning became a complete mode observation")
+	}
+}
+
+func TestInstrumentationEarlyObservationUnsupportedNeedsExactCompleteWitness(t *testing.T) {
+	original := captureActualInstrumentationEarly(t, "linux/386", InstrumentationRace, "0")
+	for name, mutate := range map[string]func(*InstrumentationEarlyObservation){
+		"wrong exit":          func(p *InstrumentationEarlyObservation) { p.ExitCode = 1 },
+		"unknown diagnostics": func(p *InstrumentationEarlyObservation) { p.Stderr += "unknown warning\n" },
+		"wrong target":        func(p *InstrumentationEarlyObservation) { p.Target = "linux/arm" },
+		"nonempty stdout": func(p *InstrumentationEarlyObservation) {
+			p.DriverSelectionSHA256 = bytesSHA256([]byte("unknown output"))
+		},
+		"invented markers": func(p *InstrumentationEarlyObservation) { p.MarkerSelection = map[string]bool{"race": true} },
+		"missing source":   func(p *InstrumentationEarlyObservation) { delete(p.SourceRules.SourceText, "VERSION") },
+	} {
+		t.Run(name, func(t *testing.T) {
+			data, err := json.Marshal(original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var proof InstrumentationEarlyObservation
+			if err := json.Unmarshal(data, &proof); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&proof)
+			if err := ValidateInstrumentationEarlyObservation(&proof); err == nil {
+				t.Fatal("accepted incomplete or changed exact unsupported-target observation")
+			}
+		})
+	}
+	if !strings.Contains(original.Stderr, "-race is not supported on linux/386") {
+		t.Fatal("original actual unsupported diagnostic was not retained")
+	}
+}
diff --git a/gotoolprofile/instrumentation_original_decode.go b/gotoolprofile/instrumentation_original_decode.go
new file mode 100644
index 000000000..c6c88be67
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_decode.go
@@ -0,0 +1,56 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+)
+
+// Original inventories are shared inputs, rather than repeated contents in
+// each plan/export proof. Readers require the independently expected original
+// input, source inventory, mode observation and scope; no decoded success flag
+// or omitted field can supply those prerequisites.
+func DecodeInstrumentationOriginalSourceInventory(reader io.Reader, input *ConsumerInput, directory string) (*InstrumentationOriginalSourceInventory, error) {
+	var proof InstrumentationOriginalSourceInventory
+	if err := decodeInstrumentationOriginalJSON(reader, 32<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationOriginalSourceInventory(input, directory, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+func DecodeInstrumentationOriginalExport(reader io.Reader, input *ConsumerInput, inventory *InstrumentationOriginalSourceInventory, marker *InstrumentationExportObservation, plan *InstrumentationOriginalPackagePlan) (*InstrumentationOriginalExportProof, error) {
+	var proof InstrumentationOriginalExportProof
+	if err := decodeInstrumentationOriginalJSON(reader, 8<<20, &proof); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationOriginalExport(input, inventory, marker, plan, &proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+func decodeInstrumentationOriginalJSON(reader io.Reader, limit int64, destination any) error {
+	if reader == nil {
+		return fmt.Errorf("missing bounded original instrumentation proof reader")
+	}
+	data, err := io.ReadAll(io.LimitReader(reader, limit+1))
+	if err != nil {
+		return err
+	}
+	if len(data) == 0 || int64(len(data)) > limit {
+		return fmt.Errorf("original instrumentation proof exceeds its JSON byte bound")
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	decoder.DisallowUnknownFields()
+	if err := decoder.Decode(destination); err != nil {
+		return err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return fmt.Errorf("original instrumentation proof contains trailing input")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_original_export.go b/gotoolprofile/instrumentation_original_export.go
new file mode 100644
index 000000000..0f4458d22
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_export.go
@@ -0,0 +1,380 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const instrumentationOriginalExportProtocol = "actual_go_instrumentation_original_export_v1"
+
+// InstrumentationOriginalExportProof establishes stock-Go compilation/export
+// and asmdecl for the original package, never CPP/LLVM consumption or runtime.
+// Phase 1 admits only original compiled Go files with no imports: generated
+// CGO and dependency source roles need their own same-mode closure first.
+// The existing original ZIP/metadata authentication is a prerequisite supplied
+// by the caller, not established by a directory hash or this portable reader.
+type InstrumentationOriginalExportProof struct {
+	Protocol               string                              `json:"protocol"`
+	Plan                   *InstrumentationOriginalPackagePlan `json:"plan"`
+	MarkerObservationID    string                              `json:"marker_observation_id"`
+	Package                PackageProof                        `json:"package"`
+	ExportArgs             []string                            `json:"export_args"`
+	VetArgs                []string                            `json:"vet_args"`
+	InvocationConfigSHA256 map[string]string                   `json:"invocation_config_sha256"`
+	ArchiveSHA256          string                              `json:"archive_sha256"`
+	Status                 string                              `json:"status"`
+}
+
+func CaptureInstrumentationOriginalExport(ctx context.Context, binary, invocationDir string, env []string, input *ConsumerInput, inventory *InstrumentationOriginalSourceInventory, marker *InstrumentationExportObservation, plan *InstrumentationOriginalPackagePlan, run Runner) (*InstrumentationOriginalExportProof, error) {
+	if ctx == nil || ctx.Err() != nil || run == nil || !filepath.IsAbs(binary) || !filepath.IsAbs(invocationDir) {
+		return nil, fmt.Errorf("original export requires a live context, bounded runner and absolute owned invocation")
+	}
+	if err := ValidateInstrumentationExportObservation(marker); err != nil {
+		return nil, err
+	}
+	if plan == nil {
+		return nil, fmt.Errorf("missing original same-mode planning scope")
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input, inventory, marker.Early, plan.PackageDirectory, plan.CustomTags, plan); err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationOriginalSources(input); err != nil {
+		return nil, err
+	}
+	configs, err := captureInstrumentationInvocationConfig(invocationDir)
+	if err != nil {
+		return nil, err
+	}
+	replacements := copyInstrumentationHashes(marker.Early.Environment)
+	delete(replacements, "GOVERSION")
+	replacements["GOTOOLCHAIN"], replacements["GOWORK"], replacements["GOFLAGS"], replacements["GOPACKAGESDRIVER"] = "local", "off", "", "off"
+	replacements["GOENV"] = "off"
+	modeEnv := replaceEnv(env, replacements)
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, invocationDir, modeEnv, run)
+	if err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationExportEnvironment(actual, commandContext, marker.Early); err != nil {
+		return nil, err
+	}
+	before, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil || !instrumentationExportToolsMatch(before, marker.Early.ModeTools) {
+		return nil, fmt.Errorf("actual original export tool routing differs from the same-mode observation: %v", err)
+	}
+	proof := &InstrumentationOriginalExportProof{
+		Protocol: instrumentationOriginalExportProtocol, Plan: plan, Status: "consumer_pending",
+		MarkerObservationID: instrumentationObjectSHA(marker), InvocationConfigSHA256: configs,
+		ExportArgs: instrumentationOriginalCommand(plan, false), VetArgs: instrumentationOriginalCommand(plan, true),
+	}
+	stdout, stderr, commandErr := run(ctx, invocationDir, modeEnv, binary, proof.ExportArgs...)
+	if commandErr != nil || len(stderr) != 0 {
+		return nil, fmt.Errorf("original same-mode export failed or emitted unregistered diagnostics (not source N/A): %v; %s", commandErr, stderr)
+	}
+	archive, pkg, err := decodeInstrumentationOriginalExport(stdout, input, plan, actual["GOCACHE"])
+	if err != nil {
+		return nil, err
+	}
+	var metadata struct {
+		Module struct{ GoMod string }
+	}
+	if err := json.Unmarshal(stdout, &metadata); err != nil {
+		return nil, err
+	}
+	metadataHash, err := FileSHA256(metadata.Module.GoMod)
+	if err != nil {
+		return nil, err
+	}
+	proof.Package = *pkg
+	proof.ArchiveSHA256, err = FileSHA256(archive)
+	if err != nil {
+		return nil, err
+	}
+	if err := RunInstrumentationOrdinaryAsmdecl(ctx, binary, invocationDir, modeEnv, input, plan, pkg,
+		map[string]string{pkg.PackagePath: proof.ArchiveSHA256}, run); err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationOriginalSources(input); err != nil {
+		return nil, err
+	}
+	afterConfigs, err := captureInstrumentationInvocationConfig(invocationDir)
+	if err != nil || !reflect.DeepEqual(configs, afterConfigs) {
+		return nil, fmt.Errorf("owned invocation configuration changed during original export")
+	}
+	after, afterContext, err := instrumentationObserverEnvironment(ctx, binary, invocationDir, modeEnv, run)
+	if err != nil || !reflect.DeepEqual(actual, after) || !reflect.DeepEqual(commandContext, afterContext) {
+		return nil, fmt.Errorf("actual original export mode/environment changed")
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil || !equalDiscoveryFeatureToolStates(before, tools) {
+		return nil, fmt.Errorf("actual original export compiler/assembler/vet identity changed")
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(sources, marker.Early.SourceRules) {
+		return nil, fmt.Errorf("actual original export source-rule registration changed")
+	}
+	if hash, err := FileSHA256(binary); err != nil || hash != marker.Early.BaselineFeatures.DriverSHA256 {
+		return nil, fmt.Errorf("actual original export driver changed")
+	}
+	for name, expected := range marker.Early.BaselineFeatures.ToolSourceSHA256 {
+		if hash, err := FileSHA256(filepath.Join(actual["GOROOT"], filepath.FromSlash(name))); err != nil || hash != expected {
+			return nil, fmt.Errorf("actual original export CPU/experiment source changed: %s", name)
+		}
+	}
+	if hash, err := FileSHA256(archive); err != nil || hash != proof.ArchiveSHA256 {
+		return nil, fmt.Errorf("actual original export archive changed during asmdecl")
+	}
+	if hash, err := FileSHA256(metadata.Module.GoMod); err != nil || hash != metadataHash {
+		return nil, fmt.Errorf("actual original module metadata changed during asmdecl")
+	}
+	if err := ValidateInstrumentationOriginalExport(input, inventory, marker, plan, proof); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateInstrumentationOriginalExport(input *ConsumerInput, inventory *InstrumentationOriginalSourceInventory, marker *InstrumentationExportObservation, expected *InstrumentationOriginalPackagePlan, proof *InstrumentationOriginalExportProof) error {
+	if proof == nil || proof.Protocol != instrumentationOriginalExportProtocol || expected == nil || proof.Status != "consumer_pending" {
+		return fmt.Errorf("missing original export protocol or inappropriate completed outcome")
+	}
+	if err := ValidateInstrumentationExportObservation(marker); err != nil {
+		return err
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input, inventory, marker.Early, expected.PackageDirectory, expected.CustomTags, proof.Plan); err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(expected, proof.Plan) || proof.MarkerObservationID != instrumentationObjectSHA(marker) ||
+		!reflect.DeepEqual(proof.ExportArgs, instrumentationOriginalCommand(expected, false)) ||
+		!reflect.DeepEqual(proof.VetArgs, instrumentationOriginalCommand(expected, true)) ||
+		!discoverySHA256Pattern.MatchString(proof.ArchiveSHA256) ||
+		len(proof.InvocationConfigSHA256) < 1 || len(proof.InvocationConfigSHA256) > 2 {
+		return fmt.Errorf("original export differs from its expected same-mode source/command scope")
+	}
+	for name, hash := range proof.InvocationConfigSHA256 {
+		if name != "go.mod" && name != "go.sum" || !discoverySHA256Pattern.MatchString(hash) {
+			return fmt.Errorf("original export has an unknown or missing invocation config identity")
+		}
+	}
+	if proof.InvocationConfigSHA256["go.mod"] == "" {
+		return fmt.Errorf("original export has no immutable invocation module")
+	}
+	if proof.Package.SourceRole == "main" && proof.InvocationConfigSHA256["go.mod"] != input.Sources["go.mod"] {
+		return fmt.Errorf("versionless main invocation metadata differs from its original source")
+	}
+	if err := ValidatePackageModule(input, proof.Package); err != nil {
+		return err
+	}
+	if proof.Package.PackagePath != expected.PackagePath || !reflect.DeepEqual(proof.Package.GoFiles, expected.GoFiles) ||
+		!reflect.DeepEqual(proof.Package.CompiledGoFiles, expected.GoFiles) || !reflect.DeepEqual(proof.Package.SFiles, expected.SFiles) || proof.Package.Macros != nil || len(expected.CgoFiles) != 0 {
+		return fmt.Errorf("original export lost source roles or invented generated/CPP consumption")
+	}
+	hashes := make(map[string]string)
+	for _, files := range [][]string{expected.GoFiles, expected.SFiles} {
+		for _, file := range files {
+			hashes[file] = input.Sources[file]
+		}
+	}
+	if !reflect.DeepEqual(hashes, proof.Package.SourceSHA256) {
+		return fmt.Errorf("actual selected original source hashes differ")
+	}
+	return nil
+}
+
+func instrumentationOriginalCommand(plan *InstrumentationOriginalPackagePlan, vet bool) []string {
+	args := []string{"list", "-export", "-compiled", "-json", "-mod=readonly", "-p=1"}
+	if vet {
+		return instrumentationOrdinaryAsmdeclArgs()
+	}
+	args = append(args, plan.BuildFlags...)
+	if len(plan.CustomTags) != 0 {
+		args = append(args, "-tags="+strings.Join(plan.CustomTags, ","))
+	}
+	return append(args, plan.PackagePath)
+}
+
+func decodeInstrumentationOriginalExport(data []byte, input *ConsumerInput, plan *InstrumentationOriginalPackagePlan, cache string) (string, *PackageProof, error) {
+	if len(data) == 0 || len(data) > commandOutputLimit {
+		return "", nil, fmt.Errorf("missing or over-bound actual original export JSON")
+	}
+	var pkg struct {
+		Dir, ImportPath, Name, Export, BuildID                               string
+		GoFiles, CompiledGoFiles, SFiles                                     []string
+		CgoFiles, CFiles, CXXFiles, FFiles, SwigFiles, SwigCXXFiles, Imports []string
+		Incomplete                                                           bool
+		Error                                                                json.RawMessage
+		DepsErrors                                                           []json.RawMessage
+		Module                                                               *struct {
+			Path, Version, Dir, GoMod string
+			Main                      bool
+			Replace                   json.RawMessage
+		}
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	if err := decoder.Decode(&pkg); err != nil {
+		return "", nil, err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return "", nil, fmt.Errorf("actual original export contains multiple packages or trailing text")
+	}
+	root, err := sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return "", nil, err
+	}
+	actualDir, dirErr := sourcepath.Resolve(pkg.Dir)
+	if dirErr != nil || actualDir != filepath.Join(root, filepath.FromSlash(plan.PackageDirectory)) || pkg.ImportPath != plan.PackagePath ||
+		pkg.Name != plan.PackageName || pkg.BuildID == "" || pkg.Incomplete || len(pkg.Error) != 0 || len(pkg.DepsErrors) != 0 ||
+		len(pkg.CgoFiles)+len(pkg.CFiles)+len(pkg.CXXFiles)+len(pkg.FFiles)+len(pkg.SwigFiles)+len(pkg.SwigCXXFiles) != 0 {
+		return "", nil, fmt.Errorf("actual original export has unbound generated/native source roles or failed package metadata")
+	}
+	if len(pkg.Imports) != 0 {
+		return "", nil, fmt.Errorf("original export requires an independent same-mode dependency source closure")
+	}
+	if pkg.Module == nil || pkg.Module.Path != input.Module || pkg.Module.Version != input.Version || len(pkg.Module.Replace) != 0 ||
+		pkg.Module.Main != (input.SourceModule == "") || input.SourceModule != "" && input.SourceModule != input.Module {
+		return "", nil, fmt.Errorf("actual original export module/version/main/replacement differs from immutable source identity")
+	}
+	moduleDir, err := sourcepath.Resolve(pkg.Module.Dir)
+	if err != nil || moduleDir != root {
+		return "", nil, fmt.Errorf("actual module directory differs from the original source root")
+	}
+	selected := &PackageProof{
+		PackagePath: pkg.ImportPath, ModulePath: pkg.Module.Path, ModuleVersion: pkg.Module.Version,
+		SourceModule: pkg.Module.Path, SourceVersion: pkg.Module.Version, SourceRole: "module", SourceSHA256: make(map[string]string),
+	}
+	if pkg.Module.Main {
+		selected.SourceRole = "main"
+	}
+	for index, list := range [][]string{pkg.GoFiles, pkg.CompiledGoFiles, pkg.SFiles} {
+		var files []string
+		for _, name := range list {
+			if filepath.IsAbs(name) {
+				name, err = filepath.Rel(pkg.Dir, name)
+				if err != nil {
+					return "", nil, err
+				}
+			}
+			if path.Base(name) != name || !validInstrumentationSourcePath(name) {
+				return "", nil, fmt.Errorf("compiled Go path has no exact original role: %s", name)
+			}
+			file := path.Join(plan.PackageDirectory, name)
+			if input.Sources[file] == "" {
+				return "", nil, fmt.Errorf("actual compiled source has no original byte identity: %s", file)
+			}
+			files = append(files, file)
+			selected.SourceSHA256[file] = input.Sources[file]
+		}
+		sort.Strings(files)
+		switch index {
+		case 0:
+			selected.GoFiles = files
+		case 1:
+			selected.CompiledGoFiles = files
+		case 2:
+			selected.SFiles = files
+		}
+	}
+	if input.ProxyGoMod != nil {
+		if err := ValidateProxyGoMod(input.ProxyGoMod); err != nil {
+			return "", nil, err
+		}
+		selected.GoModOrigin, selected.GoModSHA256, selected.GoModSum = input.ProxyGoMod.Protocol, input.ProxyGoMod.SHA256, input.ProxyGoMod.GoModSum
+	}
+	expectedMod := input.Sources["go.mod"]
+	if input.ProxyGoMod != nil {
+		expectedMod = input.ProxyGoMod.SHA256
+	}
+	if hash, err := FileSHA256(pkg.Module.GoMod); err != nil || hash != expectedMod || expectedMod == "" {
+		return "", nil, fmt.Errorf("actual module metadata differs from the immutable original origin")
+	}
+	resolvedCache, err := sourcepath.Resolve(cache)
+	if err != nil {
+		return "", nil, err
+	}
+	archive, err := sourcepath.Resolve(pkg.Export)
+	relative, relErr := filepath.Rel(resolvedCache, archive)
+	if err != nil || relErr != nil || !filepath.IsAbs(pkg.Export) || !filepath.IsLocal(relative) {
+		return "", nil, fmt.Errorf("actual original export is absent or outside its observed owned cache")
+	}
+	return archive, selected, nil
+}
+
+func recheckInstrumentationOriginalSources(input *ConsumerInput) error {
+	if input == nil || !filepath.IsAbs(input.SourceRoot) || len(input.Sources) == 0 || len(input.Sources) > 65536 || len(input.Directories) == 0 {
+		return fmt.Errorf("missing bounded original source inventory")
+	}
+	root, err := sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return err
+	}
+	for directory, names := range input.Directories {
+		if directory != "." && !validInstrumentationSourcePath(directory) {
+			return fmt.Errorf("original directory escapes its source root")
+		}
+		physical := filepath.Join(root, filepath.FromSlash(directory))
+		resolved, err := sourcepath.Resolve(physical)
+		if err != nil || resolved != physical {
+			return fmt.Errorf("original directory is absent or redirected: %s", directory)
+		}
+		entries, err := os.ReadDir(physical)
+		if err != nil || len(entries) != len(names) {
+			return fmt.Errorf("original directory inventory changed: %s", directory)
+		}
+		for index, entry := range entries {
+			if entry.Name() != names[index] || entry.Type()&os.ModeSymlink != 0 || !entry.IsDir() && !entry.Type().IsRegular() {
+				return fmt.Errorf("original directory member changed or is not regular: %s", entry.Name())
+			}
+			if !entry.IsDir() && input.Sources[path.Join(directory, entry.Name())] == "" {
+				return fmt.Errorf("original resource lacks a full byte identity: %s", entry.Name())
+			}
+		}
+	}
+	for file, expected := range input.Sources {
+		if !validInstrumentationSourcePath(file) || !discoverySHA256Pattern.MatchString(expected) {
+			return fmt.Errorf("invalid original source byte identity")
+		}
+		physical, err := CPPRegularSource(root, file)
+		if err != nil {
+			return err
+		}
+		if hash, err := FileSHA256(physical); err != nil || hash != expected {
+			return fmt.Errorf("original source bytes changed: %s", file)
+		}
+	}
+	return nil
+}
+
+func captureInstrumentationInvocationConfig(directory string) (map[string]string, error) {
+	return CaptureInstrumentationInvocationConfig(directory)
+}
+
+// CaptureInstrumentationInvocationConfig snapshots only an existing owned
+// caller's module configuration. It never edits metadata, chooses versions or
+// supplies source authentication. Recheck it after every consumer stage.
+func CaptureInstrumentationInvocationConfig(directory string) (map[string]string, error) {
+	config := make(map[string]string)
+	for _, name := range []string{"go.mod", "go.sum"} {
+		file := filepath.Join(directory, name)
+		info, err := os.Lstat(file)
+		if os.IsNotExist(err) && name == "go.sum" {
+			continue
+		}
+		if err != nil || !info.Mode().IsRegular() || info.Size() > 8<<20 {
+			return nil, fmt.Errorf("owned invocation configuration is missing, nonregular or over-bound: %s", name)
+		}
+		config[name], err = FileSHA256(file)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return config, nil
+}
diff --git a/gotoolprofile/instrumentation_original_export_go127_test.go b/gotoolprofile/instrumentation_original_export_go127_test.go
new file mode 100644
index 000000000..cdc94b48c
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_export_go127_test.go
@@ -0,0 +1,170 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationOriginalExportActualSameModeAndReadback(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input := instrumentationOriginalFixture(t, marker.Early)
+	inventory, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, inventory, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(), input, inventory, marker, plan, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if proof.Status != "consumer_pending" || proof.Package.SourceRole != "main" ||
+		len(proof.Package.CompiledGoFiles) != 2 || proof.ArchiveSHA256 == "" {
+		t.Fatalf("incomplete original same-mode export: %+v", proof)
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var restored InstrumentationOriginalExportProof
+	if err := json.Unmarshal(data, &restored); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateInstrumentationOriginalExport(input, inventory, marker, plan, &restored); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := DecodeInstrumentationOriginalExport(strings.NewReader(string(data)), input, inventory, marker, plan); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{string(data) + "{}", strings.Replace(string(data), "\"protocol\":", "\"unknown\":true,\"protocol\":", 1)} {
+		if _, err := DecodeInstrumentationOriginalExport(strings.NewReader(invalid), input, inventory, marker, plan); err == nil {
+			t.Fatal("portable original export reader accepted unknown or trailing input")
+		}
+	}
+	for name, change := range map[string]func(*InstrumentationOriginalExportProof){
+		"erase mode": func(p *InstrumentationOriginalExportProof) {
+			p.ExportArgs = []string{"list", "-export", p.Package.PackagePath}
+		},
+		"ordinary vet": func(p *InstrumentationOriginalExportProof) {
+			p.VetArgs = []string{"vet", "-asmdecl", p.Package.PackagePath}
+		},
+		"claim pass":           func(p *InstrumentationOriginalExportProof) { p.Status = "passed" },
+		"fake generated":       func(p *InstrumentationOriginalExportProof) { p.Package.CompiledGoFiles = []string{"generated.go"} },
+		"delete ignored scope": func(p *InstrumentationOriginalExportProof) { p.Plan.Decisions = p.Plan.Decisions[1:] },
+		"other module":         func(p *InstrumentationOriginalExportProof) { p.Package.ModulePath = "example.invalid/foreign" },
+		"foreign main config": func(p *InstrumentationOriginalExportProof) {
+			p.InvocationConfigSHA256["go.mod"] = bytesSHA256([]byte("foreign"))
+		},
+		"missing archive": func(p *InstrumentationOriginalExportProof) { p.ArchiveSHA256 = "" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationOriginalExportProof
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			change(&changed)
+			if err := ValidateInstrumentationOriginalExport(input, inventory, marker, plan, &changed); err == nil {
+				t.Fatal("accepted missing or changed original same-mode export")
+			}
+		})
+	}
+	for _, phase := range []string{"export", "vet", "unknown stderr", "source mutation", "new sibling"} {
+		t.Run(phase, func(t *testing.T) {
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if len(args) > 1 && args[0] == "list" && args[1] == "-export" {
+					if phase == "export" {
+						return nil, []byte("missing compiler or SDK\n"), exec.ErrNotFound
+					}
+					out, stderr, err := RunBounded(ctx, dir, env, name, args...)
+					if phase == "unknown stderr" {
+						stderr = append(stderr, []byte("unknown warning\n")...)
+					}
+					if phase == "source mutation" || phase == "new sibling" {
+						file := "mode_asan.s"
+						if phase == "new sibling" {
+							file = "late.s"
+						}
+						if err := os.WriteFile(filepath.Join(input.SourceRoot, file), []byte("// changed source\n"), 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+					return out, stderr, err
+				}
+				if len(args) > 1 && args[0] == "tool" && args[1] == "vet" && phase == "vet" {
+					return nil, []byte("missing vet tool\n"), exec.ErrNotFound
+				}
+				return RunBounded(ctx, dir, env, name, args...)
+			}
+			if _, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(), input, inventory, marker, plan, run); err == nil {
+				t.Fatal("actual source/tool/SDK failure or warning became export proof")
+			}
+			if phase == "source mutation" {
+				if err := os.WriteFile(filepath.Join(input.SourceRoot, "mode_asan.s"), instrumentationExportFixture()["mode_asan.s"], 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestInstrumentationOriginalExportActualExclusiveModeFamily(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, config := range []struct {
+		target string
+		mode   InstrumentationMode
+	}{
+		{"darwin/arm64", InstrumentationRace},
+		{"linux/arm64", InstrumentationMSan},
+		{"linux/arm64", InstrumentationASan},
+	} {
+		t.Run(config.target+"/"+string(config.mode)+"/CGO1", func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+			defer cancel()
+			marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), config.target, config.mode, "1", nil, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input := instrumentationOriginalFixture(t, marker.Early)
+			sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			plan, err := PlanInstrumentationOriginalPackage(input, sources, marker.Early, ".", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proof, err := CaptureInstrumentationOriginalExport(ctx, binary, input.SourceRoot, os.Environ(), input, sources, marker, plan, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := ValidateInstrumentationOriginalExport(input, sources, marker, plan, proof); err != nil {
+				t.Fatal(err)
+			}
+			if plan.CGOEnabled != "1" || proof.Status != "consumer_pending" || proof.Package.Macros != nil {
+				t.Fatal("CGO1 original export borrowed ordinary/CPP consumption")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_original_plan.go b/gotoolprofile/instrumentation_original_plan.go
new file mode 100644
index 000000000..cec0c1eee
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_plan.go
@@ -0,0 +1,259 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/build"
+	"go/build/constraint"
+	"go/parser"
+	"go/token"
+	"io"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/mod/module"
+)
+
+const instrumentationOriginalPlanProtocol = "actual_go_instrumentation_original_package_plan_v1"
+
+// InstrumentationOriginalPackagePlan is a single original package's complete
+// source-selection denominator under one independently observed mode. It is
+// never an ordinary selection/exclusion proof or a translation outcome.
+// OriginalInputSHA256 binds the entire existing input, including supplemental
+// protocols and resources; none of those ordinary proofs becomes a mode proof.
+type InstrumentationOriginalPackagePlan struct {
+	Protocol              string                          `json:"protocol"`
+	OriginalInputSHA256   string                          `json:"original_input_sha256"`
+	SourceInventorySHA256 string                          `json:"source_inventory_sha256"`
+	ModeProfileID         string                          `json:"mode_profile_id"`
+	Target                string                          `json:"target"`
+	Mode                  InstrumentationMode             `json:"mode"`
+	CGOEnabled            string                          `json:"cgo_enabled"`
+	PackageDirectory      string                          `json:"package_directory"`
+	PackagePath           string                          `json:"package_path"`
+	PackageName           string                          `json:"package_name"`
+	CustomTags            []string                        `json:"custom_tags,omitempty"`
+	BuildFlags            []string                        `json:"build_flags"`
+	GoFiles               []string                        `json:"go_files"`
+	CgoFiles              []string                        `json:"cgo_files,omitempty"`
+	SFiles                []string                        `json:"s_files"`
+	Decisions             []InstrumentationSourceDecision `json:"decisions"`
+	Status                string                          `json:"status"`
+}
+
+type InstrumentationSourceDecision struct {
+	File         string `json:"file"`
+	SourceSHA256 string `json:"source_sha256"`
+	HeaderSHA256 string `json:"header_sha256"`
+	Selected     bool   `json:"selected"`
+	ModeRequired bool   `json:"mode_required"`
+	Reason       string `json:"reason"`
+}
+
+// PlanInstrumentationOriginalPackage replays source predicates, not a tool
+// invocation. A mode-required decision compares the same target/CPU/custom
+// tags/CGO with instrumentation false; this counterfactual is not a baseline
+// export or a CGO=1 observation manufactured from the CGO=0 CPU foundation.
+// The caller must independently authenticate these original source inputs
+// against the exact ZIP/metadata and retain the existing unchanged guards.
+func PlanInstrumentationOriginalPackage(input *ConsumerInput, sources *InstrumentationOriginalSourceInventory, early *InstrumentationEarlyObservation, directory string, tags []string) (*InstrumentationOriginalPackagePlan, error) {
+	if input == nil || input.Protocol != ConsumerProtocol || input.Observed == nil || input.ID != ProfileID(input.Observed) ||
+		module.CheckPath(input.Module) != nil || input.SourceRoot == "" || !filepath.IsAbs(input.SourceRoot) {
+		return nil, fmt.Errorf("missing complete original source/module input")
+	}
+	if err := ValidateInstrumentationEarlyObservation(early); err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(input.Observed, early.BaselineFeatures) {
+		return nil, fmt.Errorf("original CPU input differs from the actual mode foundation")
+	}
+	if directory != "." && !validInstrumentationSourcePath(directory) {
+		return nil, fmt.Errorf("noncanonical original package directory")
+	}
+	if err := validateInstrumentationCustomTags(tags, early); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationOriginalSourceInventory(input, directory, sources); err != nil {
+		return nil, err
+	}
+	names, present := input.Directories[directory]
+	if !present || len(names) == 0 || len(names) > 65536 || !sort.StringsAreSorted(names) {
+		return nil, fmt.Errorf("original package lacks its complete canonical directory")
+	}
+	ctx, err := instrumentationOriginalBuildContext(sources, early, tags, true)
+	if err != nil {
+		return nil, err
+	}
+	baseline, err := instrumentationOriginalBuildContext(sources, early, tags, false)
+	if err != nil {
+		return nil, err
+	}
+	headerContext := ctx
+	headerContext.OpenFile = func(file string) (io.ReadCloser, error) {
+		header, found := input.Headers[filepath.ToSlash(file)]
+		if !found {
+			return nil, fmt.Errorf("missing original selection header: %s", file)
+		}
+		return io.NopCloser(strings.NewReader(header)), nil
+	}
+	packagePath := input.Module
+	if directory != "." {
+		packagePath += "/" + directory
+	}
+	if module.CheckImportPath(packagePath) != nil {
+		return nil, fmt.Errorf("invalid original package import path")
+	}
+	plan := &InstrumentationOriginalPackagePlan{
+		Protocol: instrumentationOriginalPlanProtocol, OriginalInputSHA256: instrumentationOriginalInputSHA(input),
+		SourceInventorySHA256: instrumentationObjectSHA(sources),
+		ModeProfileID:         InstrumentationEarlyProfileID(early), Target: early.Target, Mode: early.Mode,
+		CGOEnabled: early.CGOEnabled, PackageDirectory: directory, PackagePath: packagePath,
+		CustomTags: append([]string(nil), tags...), BuildFlags: append([]string(nil), early.BuildFlags...),
+		Status: "consumer_pending",
+	}
+	packageName := ""
+	for index, name := range names {
+		if path.Base(name) != name || name == "." || name == ".." || index > 0 && name == names[index-1] {
+			return nil, fmt.Errorf("invalid or duplicate original directory member")
+		}
+		file := path.Join(directory, name)
+		if path.Ext(name) != ".go" && path.Ext(name) != ".s" {
+			continue
+		}
+		header, found := input.Headers[file]
+		if !found || len(header) > 1<<20 || !discoverySHA256Pattern.MatchString(input.Sources[file]) {
+			return nil, fmt.Errorf("original source lacks a bounded header or full byte identity: %s", file)
+		}
+		selected, err := ctx.MatchFile(directory, name)
+		if err != nil {
+			return nil, fmt.Errorf("original mode selection %s: %w", file, err)
+		}
+		fromHeader, err := headerContext.MatchFile(directory, name)
+		if err != nil || fromHeader != selected {
+			return nil, fmt.Errorf("original compact header and full source disagree on selection: %s", file)
+		}
+		withoutMode, err := baseline.MatchFile(directory, name)
+		if err != nil {
+			return nil, err
+		}
+		decision := InstrumentationSourceDecision{
+			File: file, SourceSHA256: input.Sources[file], HeaderSHA256: bytesSHA256([]byte(header)),
+			Selected: selected, ModeRequired: selected && !withoutMode, Reason: "matchfile_excluded",
+		}
+		if strings.HasSuffix(name, "_test.go") {
+			decision.Selected, decision.ModeRequired, decision.Reason = false, false, "not_ordinary_test_source"
+		} else if selected {
+			decision.Reason = "selected_original_source"
+			if path.Ext(name) == ".s" {
+				plan.SFiles = append(plan.SFiles, file)
+			} else {
+				parsed, err := parser.ParseFile(token.NewFileSet(), file, sources.Contents[file], parser.ImportsOnly)
+				if err != nil {
+					return nil, fmt.Errorf("unproved original Go package/import role: %s", file)
+				}
+				usesCgo := false
+				for _, imported := range parsed.Imports {
+					value, err := strconv.Unquote(imported.Path.Value)
+					if err != nil {
+						return nil, fmt.Errorf("invalid original import literal: %s", file)
+					}
+					usesCgo = usesCgo || value == "C"
+				}
+				if usesCgo && early.CGOEnabled == "0" {
+					decision.Selected, decision.ModeRequired, decision.Reason = false, false, "cgo_import_disabled"
+					plan.Decisions = append(plan.Decisions, decision)
+					continue
+				}
+				if parsed.Name.Name == "documentation" || packageName != "" && packageName != parsed.Name.Name {
+					return nil, fmt.Errorf("unproved or conflicting original ordinary Go package role: %s", file)
+				}
+				packageName = parsed.Name.Name
+				if usesCgo {
+					plan.CgoFiles = append(plan.CgoFiles, file)
+				} else {
+					plan.GoFiles = append(plan.GoFiles, file)
+				}
+			}
+		}
+		plan.Decisions = append(plan.Decisions, decision)
+	}
+	plan.PackageName = packageName
+	if len(plan.GoFiles)+len(plan.CgoFiles) == 0 || len(plan.SFiles) == 0 {
+		return nil, fmt.Errorf("mode package lacks an original ordinary Go/ASM pair; not an exclusion proof")
+	}
+	return plan, nil
+}
+
+func ValidateInstrumentationOriginalPackagePlan(input *ConsumerInput, sources *InstrumentationOriginalSourceInventory, early *InstrumentationEarlyObservation, directory string, tags []string, plan *InstrumentationOriginalPackagePlan) error {
+	if plan == nil || plan.Protocol != instrumentationOriginalPlanProtocol {
+		return fmt.Errorf("missing original instrumentation planning protocol")
+	}
+	wanted, err := PlanInstrumentationOriginalPackage(input, sources, early, directory, tags)
+	if err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(plan, wanted) {
+		return fmt.Errorf("original mode plan lost or changed a source/profile/tag scope")
+	}
+	return nil
+}
+
+func instrumentationOriginalInputSHA(input *ConsumerInput) string {
+	copy := *input
+	// Physical roots are invocation-only. All original/source/resource/protocol
+	// fields remain in this binding, including fields not consumed by phase 1.
+	copy.SourceRoot, copy.ProxyGoModPath = "", ""
+	return instrumentationObjectSHA(&copy)
+}
+
+func instrumentationOriginalBuildContext(sources *InstrumentationOriginalSourceInventory, early *InstrumentationEarlyObservation, tags []string, mode bool) (build.Context, error) {
+	minor, err := goMinor(early.SourceRules.GoVersion)
+	if err != nil {
+		return build.Context{}, err
+	}
+	ctx := build.Default
+	ctx.JoinPath = path.Join
+	ctx.GOOS, ctx.GOARCH = early.Environment["GOOS"], early.Environment["GOARCH"]
+	ctx.Compiler, ctx.CgoEnabled = "gc", early.CGOEnabled == "1"
+	ctx.BuildTags = append([]string(nil), tags...)
+	if mode {
+		ctx.BuildTags = append(ctx.BuildTags, string(early.Mode))
+	}
+	ctx.ToolTags = append([]string(nil), early.BaselineFeatures.ToolTags...)
+	ctx.ReleaseTags = nil
+	for version := 1; version <= minor; version++ {
+		ctx.ReleaseTags = append(ctx.ReleaseTags, fmt.Sprintf("go1.%d", version))
+	}
+	ctx.OpenFile = func(file string) (io.ReadCloser, error) {
+		header, found := sources.Contents[file]
+		if !found {
+			return nil, fmt.Errorf("uncaptured original selection input: %s", file)
+		}
+		return io.NopCloser(strings.NewReader(header)), nil
+	}
+	return ctx, nil
+}
+
+func validInstrumentationSourcePath(file string) bool {
+	return CPPLocalSource(file)
+}
+
+func validateInstrumentationCustomTags(tags []string, early *InstrumentationEarlyObservation) error {
+	if len(tags) > 16 || !sort.StringsAreSorted(tags) {
+		return fmt.Errorf("custom tag scope exceeds its bound or is noncanonical")
+	}
+	for index, tag := range tags {
+		expr, err := constraint.Parse("//go:build " + tag)
+		one, ok := expr.(*constraint.TagExpr)
+		_, builtin := early.MarkerSelection[tag]
+		if err != nil || !ok || one.Tag != tag || index > 0 && tag == tags[index-1] || builtin ||
+			tag == "race" || tag == "msan" || tag == "asan" || tag == "cgo" || tag == "gc" || tag == "gccgo" || strings.HasPrefix(tag, "go1.") ||
+			strings.HasPrefix(tag, "goexperiment.") {
+			return fmt.Errorf("custom tags cannot impersonate mode/builtin flags: %q", tag)
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_original_plan_test.go b/gotoolprofile/instrumentation_original_plan_test.go
new file mode 100644
index 000000000..258fda588
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_plan_test.go
@@ -0,0 +1,102 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func instrumentationOriginalFixture(t *testing.T, early *InstrumentationEarlyObservation) *ConsumerInput {
+	t.Helper()
+	files := instrumentationExportFixture()
+	input := &ConsumerInput{
+		Protocol: ConsumerProtocol, ID: ProfileID(early.BaselineFeatures), Observed: early.BaselineFeatures,
+		Module: instrumentationExportModule, SourceRoot: t.TempDir(), Sources: make(map[string]string),
+		Headers: make(map[string]string), Directories: make(map[string][]string),
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(input.SourceRoot, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = bytesSHA256(data)
+		input.Headers[name] = string(data)
+		input.Directories["."] = append(input.Directories["."], name)
+	}
+	sort.Strings(input.Directories["."])
+	input.AsmFiles = []string{"mode_asan.s", "mode_msan.s", "mode_race.s"}
+	return input
+}
+
+func TestInstrumentationOriginalPlanKeepsFullModeDenominator(t *testing.T) {
+	early := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	input := instrumentationOriginalFixture(t, early)
+	sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(plan.GoFiles, []string{"base.go", "mode_race.go"}) ||
+		!reflect.DeepEqual(plan.SFiles, []string{"mode_race.s"}) || len(plan.Decisions) != 7 ||
+		plan.Decisions[6].File != "mode_race.s" || !plan.Decisions[6].ModeRequired ||
+		plan.Status != "consumer_pending" || !reflect.DeepEqual(plan.BuildFlags, []string{"-race"}) {
+		t.Fatalf("incomplete mode/ordinary pairing denominator: %+v", plan)
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input, sources, early, ".", nil, plan); err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, change := range map[string]func(*InstrumentationOriginalPackagePlan){
+		"delete excluded": func(p *InstrumentationOriginalPackagePlan) { p.Decisions = p.Decisions[1:] },
+		"ordinary flags":  func(p *InstrumentationOriginalPackagePlan) { p.BuildFlags = nil },
+		"other mode":      func(p *InstrumentationOriginalPackagePlan) { p.Mode = InstrumentationMSan },
+		"unpaired go":     func(p *InstrumentationOriginalPackagePlan) { p.GoFiles = nil },
+		"claim pass":      func(p *InstrumentationOriginalPackagePlan) { p.Status = "passed" },
+		"changed scope":   func(p *InstrumentationOriginalPackagePlan) { p.CustomTags = []string{"changed"} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationOriginalPackagePlan
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			change(&changed)
+			if err := ValidateInstrumentationOriginalPackagePlan(input, sources, early, ".", nil, &changed); err == nil {
+				t.Fatal("accepted missing, changed or promoted original scope")
+			}
+		})
+	}
+	for _, tags := range [][]string{{"race"}, {"cgo"}, {"go1.27"}, {"amd64.v1"}, {"x", "x"}, {"x || y"}} {
+		if _, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", tags); err == nil {
+			t.Fatalf("accepted custom flags impersonating mode/builtin or malformed tags: %v", tags)
+		}
+	}
+	delete(input.Headers, "mode_msan.s")
+	if _, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil); err == nil {
+		t.Fatal("accepted an uncaptured excluded source")
+	}
+}
+
+func TestInstrumentationOriginalPlanPreservesOldInputFields(t *testing.T) {
+	early := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	input := instrumentationOriginalFixture(t, early)
+	sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.TestDependencySourceProtocol = TestDependencyProtocol
+	if err := ValidateInstrumentationOriginalPackagePlan(input, sources, early, ".", nil, plan); err == nil {
+		t.Fatal("old protocol/source-field mutation escaped complete input binding")
+	}
+}
diff --git a/gotoolprofile/instrumentation_original_sources.go b/gotoolprofile/instrumentation_original_sources.go
new file mode 100644
index 000000000..a29ad7547
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_sources.go
@@ -0,0 +1,127 @@
+package gotoolprofile
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"reflect"
+	"strings"
+)
+
+const instrumentationOriginalSourcesProtocol = "original_instrumentation_package_sources_v1"
+const instrumentationOriginalFileLimit = 2 << 20
+const instrumentationOriginalInventoryLimit = 16 << 20
+
+// InstrumentationOriginalSourceInventory retains complete original Go/ASM
+// bytes once per package, not once per mode/tag scope. Full bytes are needed
+// for import "C" and package-role AST replay; a package-clause header is not
+// proof that a source has no cgo import. Hash agreement is source binding, not
+// independent ZIP authentication: the caller still supplies that prerequisite.
+type InstrumentationOriginalSourceInventory struct {
+	Protocol  string            `json:"protocol"`
+	Module    string            `json:"module"`
+	Version   string            `json:"version"`
+	Directory string            `json:"directory"`
+	Contents  map[string]string `json:"contents"`
+	// Present only for a version-replaced archive with a different declared
+	// namespace. This is complete original go.mod, never proxy metadata.
+	ModuleMetadata string `json:"original_module_metadata,omitempty"`
+}
+
+func CaptureInstrumentationOriginalSourceInventory(input *ConsumerInput, directory string) (*InstrumentationOriginalSourceInventory, error) {
+	if err := recheckInstrumentationOriginalSources(input); err != nil {
+		return nil, err
+	}
+	names, present := input.Directories[directory]
+	if !present {
+		return nil, fmt.Errorf("original package directory is absent")
+	}
+	inventory := &InstrumentationOriginalSourceInventory{
+		Protocol: instrumentationOriginalSourcesProtocol, Module: input.Module, Version: input.Version,
+		Directory: directory, Contents: make(map[string]string),
+	}
+	total := 0
+	if input.SourceModule != "" && input.SourceModule != input.Module {
+		physical, err := CPPRegularSource(input.SourceRoot, "go.mod")
+		if err != nil {
+			return nil, err
+		}
+		opened, err := os.Open(physical)
+		if err != nil {
+			return nil, err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(opened, instrumentationOriginalFileLimit+1))
+		if err := errors.Join(readErr, opened.Close()); err != nil {
+			return nil, err
+		}
+		inventory.ModuleMetadata = string(data)
+		total += len(data)
+	}
+	for _, name := range names {
+		if path.Ext(name) != ".go" && path.Ext(name) != ".s" {
+			continue
+		}
+		file := path.Join(directory, name)
+		limit := instrumentationOriginalSourceByteLimit(file)
+		physical, err := CPPRegularSource(input.SourceRoot, file)
+		if err != nil {
+			return nil, err
+		}
+		opened, err := os.Open(physical)
+		if err != nil {
+			return nil, err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(opened, int64(limit)+1))
+		if err := errors.Join(readErr, opened.Close()); err != nil {
+			return nil, err
+		}
+		total += len(data)
+		if len(data) > limit || total > instrumentationOriginalInventoryLimit || bytesSHA256(data) != input.Sources[file] {
+			return nil, fmt.Errorf("original source changed or exceeds the bounded full-source inventory: %s", file)
+		}
+		inventory.Contents[file] = string(data)
+	}
+	if err := ValidateInstrumentationOriginalSourceInventory(input, directory, inventory); err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationOriginalSources(input); err != nil {
+		return nil, err
+	}
+	return inventory, nil
+}
+
+func ValidateInstrumentationOriginalSourceInventory(input *ConsumerInput, directory string, inventory *InstrumentationOriginalSourceInventory) error {
+	if input == nil || inventory == nil || inventory.Protocol != instrumentationOriginalSourcesProtocol ||
+		inventory.Module != input.Module || inventory.Version != input.Version || inventory.Directory != directory ||
+		directory != "." && !CPPLocalSource(directory) {
+		return fmt.Errorf("missing exact original full-source inventory identity")
+	}
+	if err := validateInstrumentationModuleNamespace(input, inventory.ModuleMetadata); err != nil {
+		return err
+	}
+	names, present := input.Directories[directory]
+	if !present || len(names) == 0 || len(names) > 65536 {
+		return fmt.Errorf("full-source inventory lacks its original complete directory")
+	}
+	wanted := make(map[string]string)
+	total := len(inventory.ModuleMetadata)
+	for _, name := range names {
+		if path.Ext(name) != ".go" && path.Ext(name) != ".s" {
+			continue
+		}
+		file := path.Join(directory, name)
+		contents, found := inventory.Contents[file]
+		total += len(contents)
+		if !found || len(contents) > instrumentationOriginalSourceByteLimit(file) || total > instrumentationOriginalInventoryLimit ||
+			!CPPLocalSource(file) || bytesSHA256([]byte(contents)) != input.Sources[file] || strings.ContainsRune(contents, '\x00') {
+			return fmt.Errorf("original full-source inventory is missing, changed or over-bound: %s", file)
+		}
+		wanted[file] = contents
+	}
+	if len(wanted) == 0 || !reflect.DeepEqual(wanted, inventory.Contents) {
+		return fmt.Errorf("original full-source inventory has missing or extra members")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_original_sources_test.go b/gotoolprofile/instrumentation_original_sources_test.go
new file mode 100644
index 000000000..35b5ede34
--- /dev/null
+++ b/gotoolprofile/instrumentation_original_sources_test.go
@@ -0,0 +1,182 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationOriginalFullSourcesRejectMissingAndChangedInventory(t *testing.T) {
+	early := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	input := instrumentationOriginalFixture(t, early)
+	original, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := DecodeInstrumentationOriginalSourceInventory(strings.NewReader(string(data)), input, "."); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{string(data) + "{}", strings.Replace(string(data), "\"protocol\":", "\"unknown\":true,\"protocol\":", 1)} {
+		if _, err := DecodeInstrumentationOriginalSourceInventory(strings.NewReader(invalid), input, "."); err == nil {
+			t.Fatal("portable source reader accepted unknown or trailing input")
+		}
+	}
+	for name, change := range map[string]func(*InstrumentationOriginalSourceInventory){
+		"missing protocol": func(p *InstrumentationOriginalSourceInventory) { p.Protocol = "" },
+		"other module":     func(p *InstrumentationOriginalSourceInventory) { p.Module += "/foreign" },
+		"other version":    func(p *InstrumentationOriginalSourceInventory) { p.Version = "v1.0.0" },
+		"delete ignored":   func(p *InstrumentationOriginalSourceInventory) { delete(p.Contents, "mode_msan.go") },
+		"extra source":     func(p *InstrumentationOriginalSourceInventory) { p.Contents["foreign.go"] = "package foreign\n" },
+		"changed body":     func(p *InstrumentationOriginalSourceInventory) { p.Contents["base.go"] += "// changed\n" },
+		"over-bound source": func(p *InstrumentationOriginalSourceInventory) {
+			p.Contents["base.go"] = strings.Repeat("x", instrumentationOriginalFileLimit+1)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var p InstrumentationOriginalSourceInventory
+			if err := json.Unmarshal(data, &p); err != nil {
+				t.Fatal(err)
+			}
+			change(&p)
+			if err := ValidateInstrumentationOriginalSourceInventory(input, ".", &p); err == nil {
+				t.Fatal("accepted truncated or changed original inventory")
+			}
+		})
+	}
+	if err := os.Remove(filepath.Join(input.SourceRoot, "base.go")); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Symlink(filepath.Join(t.TempDir(), "foreign.go"), filepath.Join(input.SourceRoot, "base.go")); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CaptureInstrumentationOriginalSourceInventory(input, "."); err == nil {
+		t.Fatal("read a redirected original source")
+	}
+}
+
+func TestInstrumentationOriginalPlanFullImportCMatchesActualGo(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	early := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	input := instrumentationOriginalFixture(t, early)
+	for name, body := range map[string]string{
+		"plain.go":   "import \"C\"",
+		"alias.go":   "import alias \"C\"",
+		"escaped.go": "import \"\\x43\"",
+		"raw.go":     "import `C`",
+	} {
+		data := []byte("package markers\n\n" + body + "\n")
+		if err := os.WriteFile(filepath.Join(input.SourceRoot, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Sources[name] = bytesSHA256(data)
+		// This is the ordinary package-clause-only input: it cannot prove
+		// absence of import C. The separate complete source must decide.
+		input.Headers[name] = "package markers\n"
+		input.Directories["."] = append(input.Directories["."], name)
+	}
+	sort.Strings(input.Directories["."])
+	sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := instrumentationActualEnv(early.Target, "0")
+	stdout, stderr, err := RunBounded(ctx, input.SourceRoot, env, binary, "list", "-find", "-json", "-mod=readonly", "-race", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual Go source selection failed: %v: %s", err, stderr)
+	}
+	var actual struct{ GoFiles, IgnoredGoFiles []string }
+	if err := json.Unmarshal(stdout, &actual); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(actual.GoFiles, plan.GoFiles) || len(actual.IgnoredGoFiles) != 6 {
+		t.Fatalf("full import-C source selection differs from actual Go: %+v versus %+v", actual, plan)
+	}
+	excluded := 0
+	for _, decision := range plan.Decisions {
+		if decision.Reason == "cgo_import_disabled" {
+			excluded++
+			if decision.Selected || decision.ModeRequired {
+				t.Fatal("disabled import-C source counted as selected instrumentation")
+			}
+		}
+	}
+	if excluded != 4 {
+		t.Fatalf("unclosed import-C grammar: %d", excluded)
+	}
+	withCGO := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "1")
+	input.Observed, input.ID = withCGO.BaselineFeatures, ProfileID(withCGO.BaselineFeatures)
+	cgoPlan, err := PlanInstrumentationOriginalPackage(input, sources, withCGO, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, err = RunBounded(ctx, input.SourceRoot, instrumentationActualEnv(withCGO.Target, "1"), binary, "list", "-find", "-json", "-mod=readonly", "-race", ".")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual CGO1 source selection failed: %v: %s", err, stderr)
+	}
+	var selectedCGO struct{ GoFiles, CgoFiles []string }
+	if err := json.Unmarshal(stdout, &selectedCGO); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(selectedCGO.GoFiles, cgoPlan.GoFiles) || !reflect.DeepEqual(selectedCGO.CgoFiles, cgoPlan.CgoFiles) || len(cgoPlan.CgoFiles) != 4 {
+		t.Fatalf("CGO1 original roles lost or relabeled as generated ordinary Go: %+v versus %+v", selectedCGO, cgoPlan)
+	}
+}
+
+func TestInstrumentationOriginalPlanDoesNotTrustStaleHeadersOrIdentity(t *testing.T) {
+	early := captureActualInstrumentationEarly(t, "darwin/arm64", InstrumentationRace, "0")
+	input := instrumentationOriginalFixture(t, early)
+	sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	input.Headers["mode_msan.go"] = "package markers\n"
+	if _, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil); err == nil {
+		t.Fatal("accepted a compact header which hid the original mode constraint")
+	}
+	input.Headers["mode_msan.go"] = sources.Contents["mode_msan.go"]
+	input.Version = "v1.0.0"
+	if _, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil); err == nil {
+		t.Fatal("assigned a version to the Go main module")
+	}
+}
+
+func TestInstrumentationOriginalPlanExclusiveModeFamily(t *testing.T) {
+	for _, mode := range []InstrumentationMode{InstrumentationRace, InstrumentationMSan, InstrumentationASan} {
+		t.Run(string(mode), func(t *testing.T) {
+			early := captureActualInstrumentationEarly(t, "linux/arm64", mode, "1")
+			input := instrumentationOriginalFixture(t, early)
+			sources, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			plan, err := PlanInstrumentationOriginalPackage(input, sources, early, ".", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(plan.SFiles, []string{"mode_" + string(mode) + ".s"}) || len(plan.Decisions) != 7 ||
+				plan.ModeProfileID != InstrumentationEarlyProfileID(early) || plan.CGOEnabled != "1" {
+				t.Fatalf("incomplete exclusive-mode source pairing: %+v", plan)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_rejection_guard.go b/gotoolprofile/instrumentation_rejection_guard.go
new file mode 100644
index 000000000..5e6cde020
--- /dev/null
+++ b/gotoolprofile/instrumentation_rejection_guard.go
@@ -0,0 +1,117 @@
+package gotoolprofile
+
+import (
+	"context"
+	"fmt"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Private to one actual bounded rejection invocation. It never memoizes a
+// successful source/tool check or supplies permissions to another consumer.
+type instrumentationRejectionGuard struct {
+	binary, directory string
+	sourceRoot        string
+	env               []string
+	input             *ConsumerInput
+	marker            *InstrumentationExportObservation
+	run               Runner
+	configs           map[string]string
+	actual            map[string]string
+	commandContext    map[string]string
+	tools             *discoveryFeatureToolState
+}
+
+func newInstrumentationRejectionGuard(ctx context.Context, binary, directory string, env []string, input *ConsumerInput, marker *InstrumentationExportObservation, run Runner) (*instrumentationRejectionGuard, error) {
+	directory, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationOriginalSources(input); err != nil {
+		return nil, err
+	}
+	sourceRoot, err := sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return nil, err
+	}
+	configs, err := captureInstrumentationInvocationConfig(directory)
+	if err != nil {
+		return nil, err
+	}
+	replacements := copyInstrumentationHashes(marker.Early.Environment)
+	delete(replacements, "GOVERSION")
+	replacements["GOTOOLCHAIN"], replacements["GOWORK"] = "local", "off"
+	replacements["GOFLAGS"], replacements["GOPACKAGESDRIVER"], replacements["GOENV"] = "", "off", "off"
+	modeEnv := replaceEnv(env, replacements)
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, directory, modeEnv, run)
+	if err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationExportEnvironment(actual, commandContext, marker.Early); err != nil {
+		return nil, err
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, modeEnv, actual, run)
+	if err != nil || !instrumentationExportToolsMatch(tools, marker.Early.ModeTools) {
+		return nil, fmt.Errorf("rejected-source actual tool routing differs from its mode observation: %v", err)
+	}
+	guard := &instrumentationRejectionGuard{
+		binary: binary, directory: directory, sourceRoot: sourceRoot, env: modeEnv, input: input, marker: marker, run: run,
+		configs: configs, actual: actual, commandContext: commandContext, tools: tools,
+	}
+	if err := guard.verify(ctx); err != nil {
+		return nil, err
+	}
+	return guard, nil
+}
+
+func (guard *instrumentationRejectionGuard) verify(ctx context.Context) error {
+	if ctx.Err() != nil {
+		return ctx.Err()
+	}
+	sourceRoot, err := sourcepath.Resolve(guard.input.SourceRoot)
+	if err != nil || sourceRoot != guard.sourceRoot {
+		return fmt.Errorf("rejected-source original physical root changed")
+	}
+	if err := recheckInstrumentationOriginalSources(guard.input); err != nil {
+		return err
+	}
+	configs, err := captureInstrumentationInvocationConfig(guard.directory)
+	if err != nil || !reflect.DeepEqual(configs, guard.configs) {
+		return fmt.Errorf("rejected-source invocation configuration changed: %v", err)
+	}
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, guard.binary, guard.directory, guard.env, guard.run)
+	if err != nil || !reflect.DeepEqual(actual, guard.actual) || !reflect.DeepEqual(commandContext, guard.commandContext) {
+		return fmt.Errorf("rejected-source actual environment/configuration changed: %v", err)
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, guard.binary, guard.env, actual, guard.run)
+	if err != nil || !equalDiscoveryFeatureToolStates(guard.tools, tools) {
+		return fmt.Errorf("rejected-source actual compiler/assembler/tool routing changed: %v", err)
+	}
+	if digest, err := FileSHA256(guard.binary); err != nil || digest != guard.marker.Early.BaselineFeatures.DriverSHA256 {
+		return fmt.Errorf("rejected-source actual driver changed")
+	}
+	rules, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(rules, guard.marker.Early.SourceRules) {
+		return fmt.Errorf("rejected-source actual mode source registrations changed: %v", err)
+	}
+	for _, hashes := range []map[string]string{guard.marker.Early.BaselineFeatures.ToolSourceSHA256, guard.input.ToolSources} {
+		for file, wanted := range hashes {
+			physical, err := CPPRegularSource(actual["GOROOT"], file)
+			if err != nil {
+				return err
+			}
+			if digest, err := FileSHA256(physical); err != nil || digest != wanted {
+				return fmt.Errorf("rejected-source actual SDK source changed: %s", file)
+			}
+		}
+	}
+	// The original invocation is an existing owned directory; reject a late
+	// redirect rather than using a different configuration with equal contents.
+	resolved, err := sourcepath.Resolve(guard.directory)
+	if err != nil || resolved != filepath.Clean(guard.directory) {
+		return fmt.Errorf("rejected-source invocation directory was redirected")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_rejection_metadata_test.go b/gotoolprofile/instrumentation_rejection_metadata_test.go
new file mode 100644
index 000000000..c267b18ad
--- /dev/null
+++ b/gotoolprofile/instrumentation_rejection_metadata_test.go
@@ -0,0 +1,61 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestInstrumentationSourceRejectionMetadataLateIdentity(t *testing.T) {
+	for _, change := range []string{"bytes", "same-byte final symlink", "same-byte directory redirect", "removed"} {
+		t.Run(change, func(t *testing.T) {
+			root := t.TempDir()
+			original := filepath.Join(root, "module")
+			if err := os.Mkdir(original, 0700); err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(original, "go.mod")
+			contents := []byte("module example.invalid/source-refusal\n\ngo 1.20\n")
+			if err := os.WriteFile(name, contents, 0600); err != nil {
+				t.Fatal(err)
+			}
+			physical, err := filepath.EvalSymlinks(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			metadata := instrumentationRejectedMetadata{path: name, physical: physical, digest: bytesSHA256(contents)}
+			if err := metadata.verify(); err != nil {
+				t.Fatal("original owned metadata: ", err)
+			}
+			switch change {
+			case "bytes":
+				if err := os.WriteFile(name, append(contents, []byte("// changed\n")...), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "same-byte final symlink":
+				replacement := filepath.Join(root, "equal-bytes.mod")
+				if err := os.Rename(name, replacement); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(replacement, name); err != nil {
+					t.Fatal(err)
+				}
+			case "same-byte directory redirect":
+				replacement := filepath.Join(root, "redirected-module")
+				if err := os.Rename(original, replacement); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(replacement, original); err != nil {
+					t.Fatal(err)
+				}
+			case "removed":
+				if err := os.Remove(name); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := metadata.verify(); err == nil {
+				t.Fatal("late missing, changed or physically redirected metadata retained source credit")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_rule_memo.go b/gotoolprofile/instrumentation_rule_memo.go
new file mode 100644
index 000000000..f43ddf6df
--- /dev/null
+++ b/gotoolprofile/instrumentation_rule_memo.go
@@ -0,0 +1,125 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"sync"
+)
+
+// This memo saves only pure parsing of audited registrations. Physical captures
+// still read every file, and portable replay still checks every supplied byte,
+// digest, version and AST registration. It retains neither source authority nor
+// a compiler/object result. Entry and original-byte bounds limit process memory.
+var instrumentationRulesMemo = newInstrumentationRuleMemo(16, 8<<20)
+
+type instrumentationRuleMemoKey struct {
+	version string
+	hashes  [3]string
+}
+
+type instrumentationRuleMemoEntry struct {
+	originals [3]string
+	rules     *InstrumentationSourceRules
+	bytes     int
+}
+
+type instrumentationRuleMemo struct {
+	mu                   sync.Mutex
+	maxEntries, maxBytes int
+	bytes                int
+	entries              map[instrumentationRuleMemoKey]instrumentationRuleMemoEntry
+	order                []instrumentationRuleMemoKey
+}
+
+func newInstrumentationRuleMemo(maxEntries, maxBytes int) *instrumentationRuleMemo {
+	return &instrumentationRuleMemo{
+		maxEntries: maxEntries, maxBytes: maxBytes,
+		entries: make(map[instrumentationRuleMemoKey]instrumentationRuleMemoEntry),
+	}
+}
+
+func (memo *instrumentationRuleMemo) replay(root, version string, contents map[string][]byte) (*InstrumentationSourceRules, error) {
+	key := instrumentationRuleMemoKey{version: version}
+	byteCount := len(version)
+	for i, name := range instrumentationRuleSources {
+		key.hashes[i] = bytesSHA256(contents[name])
+		byteCount += len(contents[name])
+	}
+
+	memo.mu.Lock()
+	defer memo.mu.Unlock()
+	if entry, present := memo.entries[key]; present {
+		exact := true
+		for i, name := range instrumentationRuleSources {
+			if entry.originals[i] != string(contents[name]) {
+				exact = false
+				break
+			}
+		}
+		if exact {
+			return cloneInstrumentationRules(entry.rules, root), nil
+		}
+	}
+
+	rules, err := parseInstrumentationRuleSources("", version, contents)
+	if err != nil {
+		return nil, err
+	}
+	minor, versionErr := goMinor(version)
+	// Unknown successful grammar is returned unchanged, but never retained.
+	// Only the fixed audited target tables can occupy memo entries; this also
+	// bounds derived maps independently of arbitrarily large source grammars.
+	if versionErr != nil || minor < 20 || minor > 27 ||
+		!reflect.DeepEqual(rules.registration, instrumentationRuleRegistrations(minor)) ||
+		memo.maxEntries <= 0 || byteCount > memo.maxBytes {
+		rules.root = root
+		return rules, nil
+	}
+
+	// A digest is only an index. A different exact-byte entry with that index
+	// replaces it, rather than borrowing its parsed result or double-counting.
+	if entry, present := memo.entries[key]; present {
+		memo.remove(key, entry)
+	}
+	for len(memo.entries) >= memo.maxEntries || memo.bytes+byteCount > memo.maxBytes {
+		oldest := memo.order[0]
+		memo.remove(oldest, memo.entries[oldest])
+	}
+	entry := instrumentationRuleMemoEntry{rules: rules, bytes: byteCount}
+	for i, name := range instrumentationRuleSources {
+		entry.originals[i] = string(contents[name])
+	}
+	memo.entries[key] = entry
+	memo.order = append(memo.order, key)
+	memo.bytes += byteCount
+	return cloneInstrumentationRules(rules, root), nil
+}
+
+func (memo *instrumentationRuleMemo) remove(key instrumentationRuleMemoKey, entry instrumentationRuleMemoEntry) {
+	delete(memo.entries, key)
+	memo.bytes -= entry.bytes
+	for i, existing := range memo.order {
+		if existing == key {
+			copy(memo.order[i:], memo.order[i+1:])
+			memo.order[len(memo.order)-1] = instrumentationRuleMemoKey{}
+			memo.order = memo.order[:len(memo.order)-1]
+			break
+		}
+	}
+}
+
+func cloneInstrumentationRules(original *InstrumentationSourceRules, root string) *InstrumentationSourceRules {
+	result := &InstrumentationSourceRules{
+		root: root, version: original.version,
+		sources:      copyInstrumentationHashes(original.sources),
+		registration: copyInstrumentationHashes(original.registration),
+		targets:      make(map[InstrumentationMode]map[string]bool, len(original.targets)),
+	}
+	for mode, targets := range original.targets {
+		copy := make(map[string]bool, len(targets))
+		for target, supported := range targets {
+			copy[target] = supported
+		}
+		result.targets[mode] = copy
+	}
+	return result
+}
diff --git a/gotoolprofile/instrumentation_rule_memo_test.go b/gotoolprofile/instrumentation_rule_memo_test.go
new file mode 100644
index 000000000..3c629fa3d
--- /dev/null
+++ b/gotoolprofile/instrumentation_rule_memo_test.go
@@ -0,0 +1,222 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func instrumentationMemoContents(proof *InstrumentationSourceProof) map[string][]byte {
+	contents := make(map[string][]byte, len(proof.SourceText))
+	for name, text := range proof.SourceText {
+		contents[name] = []byte(text)
+	}
+	return contents
+}
+
+func instrumentationMemoBytes(version string, contents map[string][]byte) int {
+	count := len(version)
+	for _, name := range instrumentationRuleSources {
+		count += len(contents[name])
+	}
+	return count
+}
+
+func TestInstrumentationRuleMemoMatchesUncachedAndOwnsOriginalBytes(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	contents := instrumentationMemoContents(proof)
+	want, err := parseInstrumentationRuleSources("", proof.GoVersion, contents)
+	if err != nil {
+		t.Fatal(err)
+	}
+	memo := newInstrumentationRuleMemo(2, 8<<20)
+	for i := 0; i < 3; i++ {
+		got, err := memo.replay("", proof.GoVersion, contents)
+		if err != nil || !reflect.DeepEqual(got, want) {
+			t.Fatalf("memo differs from original parser: %v", err)
+		}
+		got.targets[InstrumentationRace]["unregistered/target"] = true
+	}
+	if len(memo.entries) != 1 || len(memo.order) != 1 || memo.bytes != instrumentationMemoBytes(proof.GoVersion, contents) {
+		t.Fatal("repeated input occupied additional entries or changed byte accounting")
+	}
+	contents["VERSION"][0] = 'x'
+	if _, err := memo.replay("", proof.GoVersion, contents); err == nil {
+		t.Fatal("changed caller bytes reused earlier source validity")
+	}
+	got, err := memo.replay("", proof.GoVersion, instrumentationMemoContents(proof))
+	if err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("caller bytes modified retained originals: %v", err)
+	}
+}
+
+func TestInstrumentationRuleMemoIndexIsNotExactByteAuthority(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	contents := instrumentationMemoContents(proof)
+	memo := newInstrumentationRuleMemo(2, 8<<20)
+	want, err := memo.replay("", proof.GoVersion, contents)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Put different exact bytes under the same index to exercise the collision
+	// branch without claiming a real SHA-256 collision. They must not be a hit.
+	key := memo.order[0]
+	entry := memo.entries[key]
+	entry.originals[0] = "different bytes with the same test index"
+	entry.rules = cloneInstrumentationRules(entry.rules, "")
+	entry.rules.targets[InstrumentationRace]["unregistered/target"] = true
+	memo.entries[key] = entry
+	got, err := memo.replay("", proof.GoVersion, contents)
+	if err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("digest-only lookup borrowed another original: %v", err)
+	}
+	if memo.entries[key].originals[0] != proof.SourceText["VERSION"] || len(memo.entries) != 1 ||
+		len(memo.order) != 1 || memo.bytes != instrumentationMemoBytes(proof.GoVersion, contents) {
+		t.Fatal("collision replacement changed bounds or retained mismatching bytes")
+	}
+}
+
+func TestInstrumentationRuleMemoVersionAndAllSourcesSelectIndependentEntries(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	memo := newInstrumentationRuleMemo(8, 8<<20)
+	contents := instrumentationMemoContents(proof)
+	if _, err := memo.replay("", proof.GoVersion, contents); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range instrumentationRuleSources {
+		changed := instrumentationMemoContents(proof)
+		changed[name] = append(changed[name], []byte("\n// independent original bytes\n")...)
+		got, err := memo.replay("", proof.GoVersion, changed)
+		want, parseErr := parseInstrumentationRuleSources("", proof.GoVersion, changed)
+		if err != nil || parseErr != nil || !reflect.DeepEqual(got, want) {
+			t.Fatalf("source %s did not select its exact parsed result: %v / %v", name, err, parseErr)
+		}
+	}
+	// This is only parser-key coverage, not an observed SDK version claim.
+	alternateVersion := proof.GoVersion[:strings.LastIndex(proof.GoVersion, ".")] + ".999"
+	changed := instrumentationMemoContents(proof)
+	changed["VERSION"] = []byte(strings.Replace(proof.SourceText["VERSION"], proof.GoVersion, alternateVersion, 1))
+	got, err := memo.replay("", alternateVersion, changed)
+	if err != nil || got.version != alternateVersion || len(memo.entries) != 5 {
+		t.Fatalf("exact source/version keys were folded: %v", err)
+	}
+	if _, err := memo.replay("", proof.GoVersion, changed); err == nil {
+		t.Fatal("warmed alternate version bypassed VERSION validation")
+	}
+}
+
+func TestInstrumentationRuleMemoBoundsEvictAndOversizedInputsRemainUncached(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	base := instrumentationMemoContents(proof)
+	baseBytes := instrumentationMemoBytes(proof.GoVersion, base)
+	for name, memo := range map[string]*instrumentationRuleMemo{
+		"entry bound": newInstrumentationRuleMemo(2, 8<<20),
+		"byte bound":  newInstrumentationRuleMemo(8, 2*baseBytes+100),
+	} {
+		t.Run(name, func(t *testing.T) {
+			var first instrumentationRuleMemoKey
+			for i := 0; i < 3; i++ {
+				contents := instrumentationMemoContents(proof)
+				contents["src/internal/platform/supported.go"] = append(contents["src/internal/platform/supported.go"], []byte(fmt.Sprintf("\n// entry %d\n", i))...)
+				if _, err := memo.replay("", proof.GoVersion, contents); err != nil {
+					t.Fatal(err)
+				}
+				if i == 0 {
+					first = memo.order[0]
+				}
+			}
+			if _, retained := memo.entries[first]; retained || len(memo.entries) != 2 || len(memo.order) != 2 || memo.bytes > memo.maxBytes {
+				t.Fatal("memo did not evict oldest entries within both bounds")
+			}
+			count := 0
+			for _, entry := range memo.entries {
+				count += entry.bytes
+			}
+			if count != memo.bytes {
+				t.Fatal("eviction byte accounting differs from retained originals")
+			}
+		})
+	}
+	for _, memo := range []*instrumentationRuleMemo{
+		newInstrumentationRuleMemo(0, 8<<20),
+		newInstrumentationRuleMemo(2, baseBytes-1),
+	} {
+		for i := 0; i < 2; i++ {
+			if _, err := memo.replay("", proof.GoVersion, base); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if len(memo.entries) != 0 || len(memo.order) != 0 || memo.bytes != 0 {
+			t.Fatal("disabled or oversized input occupied the memo")
+		}
+	}
+}
+
+func TestInstrumentationRuleMemoDoesNotRetainErrorsOrUnregisteredTables(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	memo := newInstrumentationRuleMemo(2, 8<<20)
+	for name, contents := range map[string]map[string][]byte{
+		"wrong VERSION": instrumentationMemoContents(proof),
+		"unknown table": instrumentationMemoContents(proof),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if name == "wrong VERSION" {
+				contents["VERSION"] = []byte("wrong\n")
+			} else {
+				file := "src/internal/platform/supported.go"
+				contents[file] = []byte(strings.Replace(string(contents[file]), `case "linux":`, `case "plan9":`, 1))
+			}
+			for i := 0; i < 2; i++ {
+				got, err := memo.replay("", proof.GoVersion, contents)
+				want, parseErr := parseInstrumentationRuleSources("", proof.GoVersion, contents)
+				if fmt.Sprint(err) != fmt.Sprint(parseErr) || !reflect.DeepEqual(got, want) {
+					t.Fatalf("uncached failure/grammar behavior changed: %v / %v", err, parseErr)
+				}
+			}
+			if len(memo.entries) != 0 || len(memo.order) != 0 || memo.bytes != 0 {
+				t.Fatal("failed or unaudited registration occupied the memo")
+			}
+		})
+	}
+}
+
+func TestInstrumentationRuleMemoConcurrentReplaysHaveIndependentMapsAndRoots(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	contents := instrumentationMemoContents(proof)
+	want, err := parseInstrumentationRuleSources("", proof.GoVersion, contents)
+	if err != nil {
+		t.Fatal(err)
+	}
+	memo := newInstrumentationRuleMemo(2, 8<<20)
+	errors := make(chan error, 16)
+	var workers sync.WaitGroup
+	for i := 0; i < 16; i++ {
+		workers.Add(1)
+		go func(i int) {
+			defer workers.Done()
+			root := fmt.Sprintf("private-root-%d", i)
+			got, err := memo.replay(root, proof.GoVersion, contents)
+			if err != nil {
+				errors <- err
+				return
+			}
+			if !reflect.DeepEqual(got, cloneInstrumentationRules(want, root)) {
+				errors <- fmt.Errorf("worker %d received another replay's state", i)
+			}
+			got.sources["VERSION"] = "changed"
+			got.registration["instrumentInit"] = "changed"
+			got.targets[InstrumentationRace]["unregistered/target"] = true
+		}(i)
+	}
+	workers.Wait()
+	close(errors)
+	for err := range errors {
+		t.Error(err)
+	}
+	got, err := memo.replay("", proof.GoVersion, contents)
+	if err != nil || !reflect.DeepEqual(got, want) || len(memo.entries) != 1 {
+		t.Fatalf("concurrent outputs modified retained state: %v", err)
+	}
+}
diff --git a/gotoolprofile/instrumentation_rule_replay_cost_test.go b/gotoolprofile/instrumentation_rule_replay_cost_test.go
new file mode 100644
index 000000000..c8028b550
--- /dev/null
+++ b/gotoolprofile/instrumentation_rule_replay_cost_test.go
@@ -0,0 +1,82 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"runtime"
+	"testing"
+)
+
+func TestInstrumentationRuleReplayRepeatedOriginalDoesNotReparseSDK(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	var last *InstrumentationSourceRules
+	var replayError error
+	allocations := testing.AllocsPerRun(5, func() {
+		last, replayError = ReplayInstrumentationSourceProof(proof)
+	})
+	if replayError != nil || last == nil {
+		t.Fatalf("complete original replay failed: %v", replayError)
+	}
+	// Rechecking all original bytes and returning independent rule maps is
+	// required. Rebuilding complete SDK ASTs for every repeated scope is not.
+	// This deliberately generous allocation bound distinguishes those paths
+	// without depending on clock speed, host load, or LLVM execution.
+	t.Logf("unchanged original rule replay allocations=%.0f", allocations)
+	if allocations > 128 {
+		t.Fatalf("repeated original source replay reparses SDK rules: %.0f allocations, want <=128", allocations)
+	}
+}
+
+func TestInstrumentationRuleReplayReturnedMapsAndRootsRemainIndependent(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	first, err := ReplayInstrumentationSourceProof(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantSources := first.SourceHashes()
+	wantRegistration := first.RegistrationHashes()
+	wantTargets := make(map[InstrumentationMode]map[string]bool)
+	for mode, targets := range first.targets {
+		wantTargets[mode] = make(map[string]bool)
+		for target, supported := range targets {
+			wantTargets[mode][target] = supported
+		}
+	}
+	first.root = t.TempDir()
+	first.version = "go1.99.0"
+	first.sources["VERSION"] = "changed"
+	first.registration["instrumentInit"] = "changed"
+	for _, targets := range first.targets {
+		for target := range targets {
+			delete(targets, target)
+		}
+		targets["unregistered/target"] = true
+	}
+
+	again, err := ReplayInstrumentationSourceProof(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if again.root != "" || again.version != proof.GoVersion ||
+		!reflect.DeepEqual(again.sources, wantSources) ||
+		!reflect.DeepEqual(again.registration, wantRegistration) ||
+		!reflect.DeepEqual(again.targets, wantTargets) {
+		t.Fatal("one replay mutated another replay or acquired a physical root")
+	}
+	if err := again.Recheck(); err == nil {
+		t.Fatal("portable repeated replay acquired physical source authority")
+	}
+}
+
+func BenchmarkInstrumentationSourceProofRepeatedReplay(b *testing.B) {
+	proof, err := CaptureInstrumentationSourceProof(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := ReplayInstrumentationSourceProof(proof); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_source_budget_test.go b/gotoolprofile/instrumentation_source_budget_test.go
new file mode 100644
index 000000000..0155233f1
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_budget_test.go
@@ -0,0 +1,129 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestInstrumentationOriginalGeneratedAssemblyByteBudget(t *testing.T) {
+	const goLimit = 2 << 20
+	const assemblyLimit = 8 << 20
+	for _, test := range []struct {
+		name  string
+		sizes map[string]int
+		valid bool
+	}{
+		{"assembly above Go bound", map[string]int{"probe.s": 3 << 20}, true},
+		{"assembly exact bound", map[string]int{"probe.s": assemblyLimit}, true},
+		{"assembly over bound", map[string]int{"probe.s": assemblyLimit + 1}, false},
+		{"Go exact bound", map[string]int{"probe.go": goLimit}, true},
+		{"Go over bound", map[string]int{"probe.go": goLimit + 1}, false},
+		{"inventory exact bound", map[string]int{"a.s": assemblyLimit, "b.s": assemblyLimit}, true},
+		{"inventory over bound", map[string]int{"a.s": assemblyLimit, "b.s": assemblyLimit, "probe.go": 16}, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			input := &ConsumerInput{
+				Module: "example.invalid/sourcebudget", SourceRoot: t.TempDir(),
+				Sources: make(map[string]string), Directories: map[string][]string{".": {}},
+			}
+			for name, size := range test.sizes {
+				data := strings.Repeat(" ", size)
+				if err := os.WriteFile(filepath.Join(input.SourceRoot, name), []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+				input.Sources[name] = bytesSHA256([]byte(data))
+				input.Directories["."] = append(input.Directories["."], name)
+			}
+			sort.Strings(input.Directories["."])
+			inventory, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+			if !test.valid {
+				if err == nil {
+					t.Fatal("accepted an original source beyond its file or inventory byte bound")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := json.Marshal(inventory)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := DecodeInstrumentationOriginalSourceInventory(bytes.NewReader(data), input, "."); err != nil {
+				t.Fatal(err)
+			}
+			for name := range inventory.Contents {
+				inventory.Contents[name] += "changed"
+				if err := ValidateInstrumentationOriginalSourceInventory(input, ".", inventory); err == nil {
+					t.Fatal("large-source allowance erased original byte binding")
+				}
+				break
+			}
+		})
+	}
+}
+
+func TestInstrumentationCPPGeneratedAssemblyByteBudget(t *testing.T) {
+	const file = "probe.s"
+	source := strings.Repeat("NOP\n", 3<<18)
+	expanded, err := plan9asm.PreprocessAssemblySource(source, plan9asm.AssemblyPreprocessOptions{FileName: "module/" + file})
+	if err != nil || len(expanded) <= 2<<20 {
+		t.Fatalf("fixture lost its large expanded source: %d bytes: %v", len(expanded), err)
+	}
+	digest := bytesSHA256([]byte(source))
+	input := &InstrumentationConsumerInput{
+		Original: &ConsumerInput{Sources: map[string]string{file: digest}},
+		Sources:  &InstrumentationOriginalSourceInventory{Contents: map[string]string{file: source}},
+	}
+	proof := InstrumentationAssemblyFile{
+		CPP:            CPPProof{File: file, Inputs: map[string]string{"module/" + file: digest}},
+		ExpandedSource: expanded, TypedSource: expanded,
+		InputContents: map[string]string{"module/" + file: source},
+	}
+	pkg := PackageProof{Macros: &AssemblerMacros{}}
+	// This is only bounded CPP replay, not a package/export/object certificate.
+	if err := replayInstrumentationCPP(input, pkg, nil, proof); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name string
+		id   string
+		size int
+	}{
+		{"assembly over bound", "module/probe.s", 8<<20 + 1},
+		{"module header keeps old bound", "module/include.h", 2<<20 + 1},
+		{"tool header keeps old bound", "tool/textflag.h", 2<<20 + 1},
+		{"generated header keeps old bound", "generated/example.invalid/pkg/go_asm.h", 2<<20 + 1},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			text := strings.Repeat(" ", test.size)
+			changed := proof
+			changed.InputContents = map[string]string{test.id: text}
+			changed.CPP.Inputs = map[string]string{test.id: bytesSHA256([]byte(text))}
+			if err := replayInstrumentationCPP(input, pkg, nil, changed); err == nil || !strings.Contains(err.Error(), "bound") {
+				t.Fatalf("CPP input escaped its byte bound: %v", err)
+			}
+		})
+	}
+	t.Run("complete CPP inventory keeps total bound", func(t *testing.T) {
+		large := strings.Repeat(" ", 8<<20)
+		largeSHA := bytesSHA256([]byte(large))
+		changed := proof
+		changed.InputContents = map[string]string{
+			"module/" + file: source, "module/second.s": large, "module/third.s": large,
+		}
+		changed.CPP.Inputs = map[string]string{
+			"module/" + file: digest, "module/second.s": largeSHA, "module/third.s": largeSHA,
+		}
+		if err := replayInstrumentationCPP(input, pkg, nil, changed); err == nil || !strings.Contains(err.Error(), "bound") {
+			t.Fatalf("large-source allowance erased the complete CPP byte bound: %v", err)
+		}
+	})
+}
diff --git a/gotoolprofile/instrumentation_source_proof.go b/gotoolprofile/instrumentation_source_proof.go
new file mode 100644
index 000000000..57cc9020f
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_proof.go
@@ -0,0 +1,143 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"path/filepath"
+	"reflect"
+)
+
+const instrumentationSourceProofProtocol = "actual_go_instrumentation_rule_sources_v1"
+const instrumentationSourceProofJSONLimit = 16 << 20
+
+// InstrumentationSourceProof retains three bounded original tool sources,
+// not a self-reported Supported flag. Offline readers replay the complete
+// registered syntax and digests; only production rechecks authenticate these
+// bytes to the observed tool tree and driver. Inventory users should retain
+// one hash-addressed observation rather than copying it into each scope.
+type InstrumentationSourceProof struct {
+	Protocol           string            `json:"protocol"`
+	GoVersion          string            `json:"go_version"`
+	SourceText         map[string]string `json:"source_text"`
+	SourceSHA256       map[string]string `json:"source_sha256"`
+	RegistrationSHA256 map[string]string `json:"registration_ast_sha256"`
+}
+
+func CaptureInstrumentationSourceProof(root, version string) (*InstrumentationSourceProof, error) {
+	rules, err := CaptureInstrumentationSourceRules(root, version)
+	if err != nil {
+		return nil, err
+	}
+	proof := &InstrumentationSourceProof{
+		Protocol: instrumentationSourceProofProtocol, GoVersion: version,
+		SourceText: make(map[string]string), SourceSHA256: rules.SourceHashes(),
+		RegistrationSHA256: rules.RegistrationHashes(),
+	}
+	for _, name := range instrumentationRuleSources {
+		data, err := readInstrumentationRegistration(filepath.Join(root, filepath.FromSlash(name)))
+		if err != nil {
+			return nil, fmt.Errorf("read actual instrumentation source before portable capture: %s: %w", name, err)
+		}
+		if bytesSHA256(data) != proof.SourceSHA256[name] {
+			return nil, fmt.Errorf("actual instrumentation source changed before portable capture: %s", name)
+		}
+		proof.SourceText[name] = string(data)
+	}
+	if _, err := ReplayInstrumentationSourceProof(proof); err != nil {
+		return nil, err
+	}
+	if err := rules.Recheck(); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func DecodeInstrumentationSourceProof(reader io.Reader) (*InstrumentationSourceProof, error) {
+	if reader == nil {
+		return nil, fmt.Errorf("missing instrumentation source-proof reader")
+	}
+	data, err := io.ReadAll(io.LimitReader(reader, instrumentationSourceProofJSONLimit+1))
+	if err != nil {
+		return nil, fmt.Errorf("read instrumentation source-proof JSON: %w", err)
+	}
+	if len(data) > instrumentationSourceProofJSONLimit {
+		return nil, fmt.Errorf("instrumentation source-proof JSON exceeds its byte bound")
+	}
+	decoder := json.NewDecoder(bytes.NewReader(data))
+	decoder.DisallowUnknownFields()
+	var proof InstrumentationSourceProof
+	if err := decoder.Decode(&proof); err != nil {
+		return nil, err
+	}
+	if err := decoder.Decode(new(any)); err != io.EOF {
+		return nil, fmt.Errorf("instrumentation source-proof JSON contains trailing input")
+	}
+	if _, err := ReplayInstrumentationSourceProof(&proof); err != nil {
+		return nil, err
+	}
+	return &proof, nil
+}
+
+func ReplayInstrumentationSourceProof(proof *InstrumentationSourceProof) (*InstrumentationSourceRules, error) {
+	if proof == nil || proof.Protocol != instrumentationSourceProofProtocol {
+		return nil, fmt.Errorf("missing complete instrumentation source-rule protocol")
+	}
+	minor, err := goMinor(proof.GoVersion)
+	if err != nil || minor < 20 || minor > 27 {
+		return nil, fmt.Errorf("unregistered instrumentation source-rule version")
+	}
+	if len(proof.SourceText) != len(instrumentationRuleSources) || len(proof.SourceSHA256) != len(instrumentationRuleSources) || len(proof.RegistrationSHA256) != 4 {
+		return nil, fmt.Errorf("incomplete or additional instrumentation source-rule inputs")
+	}
+	contents := make(map[string][]byte)
+	for _, name := range instrumentationRuleSources {
+		text, present := proof.SourceText[name]
+		if !present || len(text) == 0 || len(text) > instrumentationRegistrationByteLimit {
+			return nil, fmt.Errorf("missing or over-bound instrumentation source: %s", name)
+		}
+		data := []byte(text)
+		if !discoverySHA256Pattern.MatchString(proof.SourceSHA256[name]) || proof.SourceSHA256[name] != bytesSHA256(data) {
+			return nil, fmt.Errorf("instrumentation source bytes differ from their digest: %s", name)
+		}
+		contents[name] = data
+	}
+	rules, err := replayInstrumentationRuleSources("", proof.GoVersion, contents)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(proof.RegistrationSHA256, rules.registration) {
+		return nil, fmt.Errorf("instrumentation source-rule AST evidence does not match complete original sources")
+	}
+	if !reflect.DeepEqual(rules.registration, instrumentationRuleRegistrations(minor)) {
+		return nil, fmt.Errorf("instrumentation source-rule AST is outside its audited Go-version registration")
+	}
+	return rules, nil
+}
+
+// These are fingerprints of complete Go function ASTs, not support lists.
+// Original source audits cover Go 1.20.14, 1.21.13, 1.22.12, 1.23.12,
+// 1.24.13, 1.25.14, 1.26.8 and 1.27.1. Offline replay must not accept a
+// self-consistent rewritten table paired with fabricated hashes.
+func instrumentationRuleRegistrations(minor int) map[string]string {
+	registration := map[string]string{
+		"instrumentInit":        instrumentationInitRegistration,
+		"RaceDetectorSupported": "f1077a853d15f529b979311e75e49657047b411dd25755e761507790e52bc19d",
+		"MSanSupported":         "98c808b64cf52346cb385372298f0766ecc0d5531edcfaea22c86a3a4b891ecd",
+		"ASanSupported":         "65371a8e429e1c91409dc53ded81e1350fc40b15be906c2d251661a9420acb12",
+	}
+	switch {
+	case minor <= 22:
+		registration["RaceDetectorSupported"] = "07ebe2ac0fe0dd91355ef1c9695b13b503c3a70f352572a1089ab787cda47c05"
+	case minor <= 24:
+		registration["RaceDetectorSupported"] = "95447113f45d943fb1ce1c39192534bec6470449235b2a5e2101346abb471b86"
+	case minor == 25:
+		registration["RaceDetectorSupported"] = "1b319ef10d602e24610a779974ad2eb3627c17fae84a2e8e2dc3b44d92f9a59e"
+	}
+	if minor <= 21 {
+		registration["MSanSupported"] = "3ba0479097ba90f8cffea03acdc0676902de4007a83ab05f1ac832cc95c4abf7"
+		registration["ASanSupported"] = "14108d20a2612a3ed49f8e6067a22e2e57958e2a3e5a980fea44fff2c2671504"
+	}
+	return registration
+}
diff --git a/gotoolprofile/instrumentation_source_proof_test.go b/gotoolprofile/instrumentation_source_proof_test.go
new file mode 100644
index 000000000..37160236e
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_proof_test.go
@@ -0,0 +1,125 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func actualInstrumentationSourceProof(t *testing.T) *InstrumentationSourceProof {
+	t.Helper()
+	proof, err := CaptureInstrumentationSourceProof(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return proof
+}
+
+func cloneInstrumentationSourceProof(t *testing.T, proof *InstrumentationSourceProof) *InstrumentationSourceProof {
+	t.Helper()
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result InstrumentationSourceProof
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	return &result
+}
+
+func TestInstrumentationSourceProofActualCaptureAndOfflineRoundtrip(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	restored, err := DecodeInstrumentationSourceProof(strings.NewReader(string(data)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rules, err := ReplayInstrumentationSourceProof(restored)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mode := range []InstrumentationMode{InstrumentationRace, InstrumentationMSan, InstrumentationASan} {
+		if _, err := rules.TargetSupported("linux/arm64", mode); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if strings.Contains(string(data), runtime.GOROOT()) {
+		t.Fatal("portable source proof leaked its physical tool root")
+	}
+	if rules.root != "" {
+		t.Fatal("offline replay acquired an actual source-tree identity")
+	}
+	if err := rules.Recheck(); err == nil {
+		t.Fatal("offline source replay impersonated a production source recheck")
+	}
+}
+
+func TestInstrumentationSourceProofRejectsForgedRegistrationAndBounds(t *testing.T) {
+	proof := actualInstrumentationSourceProof(t)
+	for name, mutate := range map[string]func(*testing.T, *InstrumentationSourceProof){
+		"missing protocol": func(t *testing.T, p *InstrumentationSourceProof) { p.Protocol = "" },
+		"downgrade":        func(t *testing.T, p *InstrumentationSourceProof) { p.Protocol = "go_driver_builtin_features_v2" },
+		"wrong version":    func(t *testing.T, p *InstrumentationSourceProof) { p.GoVersion = "go1.19.13" },
+		"missing source": func(t *testing.T, p *InstrumentationSourceProof) {
+			delete(p.SourceText, "src/cmd/go/internal/work/init.go")
+		},
+		"missing hash": func(t *testing.T, p *InstrumentationSourceProof) { delete(p.SourceSHA256, "VERSION") },
+		"missing AST":  func(t *testing.T, p *InstrumentationSourceProof) { delete(p.RegistrationSHA256, "MSanSupported") },
+		"foreign source": func(t *testing.T, p *InstrumentationSourceProof) {
+			p.SourceText["unregistered.go"] = "package unknown\n"
+		},
+		"changed bytes": func(t *testing.T, p *InstrumentationSourceProof) { p.SourceText["VERSION"] += "changed" },
+		"changed AST": func(t *testing.T, p *InstrumentationSourceProof) {
+			p.RegistrationSHA256["instrumentInit"] = strings.Repeat("0", 64)
+		},
+		"source bound": func(t *testing.T, p *InstrumentationSourceProof) {
+			p.SourceText["VERSION"] = strings.Repeat("x", instrumentationRegistrationByteLimit+1)
+		},
+		"self-consistent platform forgery": func(t *testing.T, p *InstrumentationSourceProof) {
+			key := "src/internal/platform/supported.go"
+			original := p.SourceText[key]
+			p.SourceText[key] = strings.Replace(original, `case "linux":`, `case "plan9":`, 1)
+			if p.SourceText[key] == original {
+				t.Fatal("actual platform fixture did not contain the expected complete grammar")
+			}
+			p.SourceSHA256[key] = bytesSHA256([]byte(p.SourceText[key]))
+			contents := make(map[string][]byte)
+			for name, text := range p.SourceText {
+				contents[name] = []byte(text)
+			}
+			rules, err := replayInstrumentationRuleSources("", p.GoVersion, contents)
+			if err != nil {
+				t.Fatal(err)
+			}
+			p.RegistrationSHA256 = rules.RegistrationHashes()
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			mutated := cloneInstrumentationSourceProof(t, proof)
+			mutate(t, mutated)
+			if _, err := ReplayInstrumentationSourceProof(mutated); err == nil {
+				t.Fatal("accepted incomplete or forged source-rule evidence")
+			}
+		})
+	}
+}
+
+func TestInstrumentationSourceProofDecoderRejectsUnknownTrailingAndOversizedJSON(t *testing.T) {
+	data, err := json.Marshal(actualInstrumentationSourceProof(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, input := range []string{
+		string(data) + "{}", `{"protocol":"x","supported":true}`,
+		strings.Repeat(" ", instrumentationSourceProofJSONLimit+1),
+	} {
+		if _, err := DecodeInstrumentationSourceProof(strings.NewReader(input)); err == nil {
+			t.Fatal("accepted unknown, trailing or over-bound source-proof JSON")
+		}
+	}
+}
diff --git a/gotoolprofile/instrumentation_source_rejection.go b/gotoolprofile/instrumentation_source_rejection.go
new file mode 100644
index 000000000..7274960c5
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_rejection.go
@@ -0,0 +1,343 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const instrumentationSourceRejectionProtocol = "original_instrumented_package_redeclaration_v1"
+
+// This proof covers only actual package-scope redeclarations. It grants no
+// export, generated-source, CPP, LLVM-object or runtime credit. Complete original
+// source selection and the same-mode compiler are independently prerequisites.
+type InstrumentationSourceRejection struct {
+	Protocol                 string                              `json:"protocol"`
+	Plan                     *InstrumentationOriginalPackagePlan `json:"plan"`
+	MarkerObservationID      string                              `json:"marker_observation_id"`
+	InvocationConfigSHA256   map[string]string                   `json:"invocation_config_sha256"`
+	ExportArgs               []string                            `json:"export_args"`
+	ExitCode                 int                                 `json:"exit_code"`
+	StdoutSHA256             string                              `json:"stdout_sha256"`
+	OriginalDiagnosticSHA256 string                              `json:"original_diagnostic_sha256"`
+	Redeclarations           []InstrumentationRedeclaration      `json:"redeclarations"`
+}
+
+type InstrumentationDeclarationPosition struct {
+	File   string `json:"file"`
+	Line   int    `json:"line"`
+	Column int    `json:"column"`
+}
+
+type InstrumentationRedeclaration struct {
+	Name     string                             `json:"name"`
+	Previous InstrumentationDeclarationPosition `json:"previous"`
+	Current  InstrumentationDeclarationPosition `json:"current"`
+}
+
+// Replay the complete selected syntax, never a declaration-name hint from a
+// diagnostic. Blank names, multiple init functions, method names and locals do
+// not occupy the package declaration namespace. Go line directives need their
+// own physical attribution mechanism and cannot enter this proof.
+func replayInstrumentationRedeclarations(inventory *InstrumentationOriginalSourceInventory, plan *InstrumentationOriginalPackagePlan) ([]InstrumentationRedeclaration, error) {
+	if inventory == nil || plan == nil || len(plan.CgoFiles) != 0 || len(plan.GoFiles) == 0 {
+		return nil, fmt.Errorf("redeclaration replay lacks complete ordinary Go source roles")
+	}
+	set := token.NewFileSet()
+	seen := make(map[string]InstrumentationDeclarationPosition)
+	result := []InstrumentationRedeclaration{}
+	for _, name := range plan.GoFiles {
+		contents, found := inventory.Contents[name]
+		if !found {
+			return nil, fmt.Errorf("redeclaration source is missing")
+		}
+		file, err := parser.ParseFile(set, name, contents, parser.ParseComments)
+		if err != nil || file.Name.Name != plan.PackageName {
+			return nil, fmt.Errorf("redeclaration replay has another syntax/package failure: %v", err)
+		}
+		for _, group := range file.Comments {
+			for _, comment := range group.List {
+				if strings.HasPrefix(comment.Text, "//line ") || strings.HasPrefix(comment.Text, "/*line ") {
+					return nil, fmt.Errorf("redeclaration source has unbound physical line attribution")
+				}
+			}
+		}
+		register := func(identifier *ast.Ident) error {
+			if identifier.Name == "_" {
+				return nil
+			}
+			if len(seen) >= 32768 || len(result) >= 32768 {
+				return fmt.Errorf("redeclaration replay exceeds its finite declaration bound")
+			}
+			position := set.PositionFor(identifier.Pos(), false)
+			current := InstrumentationDeclarationPosition{File: name, Line: position.Line, Column: position.Column}
+			if previous, found := seen[identifier.Name]; found {
+				result = append(result, InstrumentationRedeclaration{Name: identifier.Name, Previous: previous, Current: current})
+			} else {
+				seen[identifier.Name] = current
+			}
+			return nil
+		}
+		for _, declaration := range file.Decls {
+			var names []*ast.Ident
+			switch declaration := declaration.(type) {
+			case *ast.FuncDecl:
+				if declaration.Recv == nil && declaration.Name.Name != "init" {
+					names = append(names, declaration.Name)
+				}
+			case *ast.GenDecl:
+				for _, spec := range declaration.Specs {
+					switch spec := spec.(type) {
+					case *ast.TypeSpec:
+						names = append(names, spec.Name)
+					case *ast.ValueSpec:
+						names = append(names, spec.Names...)
+					}
+				}
+			}
+			for _, name := range names {
+				if err := register(name); err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+	return result, nil
+}
+
+func ValidateInstrumentationSourceRejection(input *ConsumerInput, inventory *InstrumentationOriginalSourceInventory, marker *InstrumentationExportObservation, plan *InstrumentationOriginalPackagePlan, proof *InstrumentationSourceRejection) error {
+	if proof == nil || plan == nil || proof.Protocol != instrumentationSourceRejectionProtocol || proof.ExitCode != 1 {
+		return fmt.Errorf("missing original same-mode redeclaration rejection protocol/exit")
+	}
+	if err := ValidateInstrumentationExportObservation(marker); err != nil {
+		return err
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input, inventory, marker.Early, plan.PackageDirectory, plan.CustomTags, proof.Plan); err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(plan, proof.Plan) || proof.MarkerObservationID != instrumentationObjectSHA(marker) ||
+		!reflect.DeepEqual(proof.ExportArgs, instrumentationOriginalCommand(plan, false)) ||
+		!discoverySHA256Pattern.MatchString(proof.StdoutSHA256) || !discoverySHA256Pattern.MatchString(proof.OriginalDiagnosticSHA256) ||
+		len(proof.InvocationConfigSHA256) < 1 || len(proof.InvocationConfigSHA256) > 2 || proof.InvocationConfigSHA256["go.mod"] == "" {
+		return fmt.Errorf("redeclaration rejection changed its original source/tool/command scope")
+	}
+	for name, digest := range proof.InvocationConfigSHA256 {
+		if name != "go.mod" && name != "go.sum" || !discoverySHA256Pattern.MatchString(digest) {
+			return fmt.Errorf("redeclaration rejection has an unknown invocation configuration")
+		}
+	}
+	if input.SourceModule == "" && proof.InvocationConfigSHA256["go.mod"] != input.Sources["go.mod"] {
+		return fmt.Errorf("main-package source refusal changed its original invocation metadata")
+	}
+	wanted, err := replayInstrumentationRedeclarations(inventory, plan)
+	if err != nil || len(wanted) == 0 || !reflect.DeepEqual(wanted, proof.Redeclarations) {
+		return fmt.Errorf("rejection differs from independent complete original declaration replay: %v", err)
+	}
+	return nil
+}
+
+func CaptureInstrumentationSourceRejection(ctx context.Context, binary, invocationDir string, env []string, input *ConsumerInput, inventory *InstrumentationOriginalSourceInventory, marker *InstrumentationExportObservation, plan *InstrumentationOriginalPackagePlan, run Runner) (*InstrumentationSourceRejection, error) {
+	if ctx == nil || ctx.Err() != nil || run == nil || !filepath.IsAbs(binary) || !filepath.IsAbs(invocationDir) || plan == nil {
+		return nil, fmt.Errorf("source rejection requires a live bounded original invocation")
+	}
+	if err := ValidateInstrumentationExportObservation(marker); err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationOriginalPackagePlan(input, inventory, marker.Early, plan.PackageDirectory, plan.CustomTags, plan); err != nil {
+		return nil, err
+	}
+	redeclarations, err := replayInstrumentationRedeclarations(inventory, plan)
+	if err != nil || len(redeclarations) == 0 {
+		return nil, fmt.Errorf("original source lacks a replayable package redeclaration: %v", err)
+	}
+	guard, err := newInstrumentationRejectionGuard(ctx, binary, invocationDir, env, input, marker, run)
+	if err != nil {
+		return nil, err
+	}
+	args := instrumentationOriginalCommand(plan, false)
+	stdout, stderr, commandErr := run(ctx, guard.directory, guard.env, binary, args...)
+	// Check sources, tools and environment even after an observed command failure.
+	guardErr := guard.verify(ctx)
+	code, plain := instrumentationRejectionExitCode(commandErr)
+	if guardErr != nil || !plain || code != 1 || ctx.Err() != nil {
+		return nil, fmt.Errorf("original compiler failure is not a guarded plain source refusal: %w", errors.Join(commandErr, guardErr, ctx.Err()))
+	}
+	metadata, err := validateInstrumentationRejectedSelection(stdout, input, plan)
+	if err != nil {
+		return nil, fmt.Errorf("%w; actual original command: %w", err, commandErr)
+	}
+	if err := validateInstrumentationRedeclarationDiagnostic(stderr, guard.directory, input, plan, redeclarations); err != nil {
+		return nil, err
+	}
+	if err := guard.verify(ctx); err != nil {
+		return nil, err
+	}
+	if err := metadata.verify(); err != nil {
+		return nil, err
+	}
+	proof := &InstrumentationSourceRejection{
+		Protocol: instrumentationSourceRejectionProtocol, Plan: plan,
+		MarkerObservationID: instrumentationObjectSHA(marker), InvocationConfigSHA256: guard.configs,
+		ExportArgs: args, ExitCode: 1, StdoutSHA256: bytesSHA256(stdout),
+		OriginalDiagnosticSHA256: bytesSHA256(stderr), Redeclarations: redeclarations,
+	}
+	return proof, ValidateInstrumentationSourceRejection(input, inventory, marker, plan, proof)
+}
+
+// RunBounded wraps a normal exit in one error chain. A joined timeout,
+// overflow, transport or cleanup failure is not that plain compiler exit.
+func instrumentationRejectionExitCode(err error) (int, bool) {
+	for err != nil {
+		switch current := err.(type) {
+		case *exec.ExitError:
+			return current.ExitCode(), true
+		case interface{ Unwrap() []error }:
+			return 0, false
+		case interface{ Unwrap() error }:
+			err = current.Unwrap()
+		default:
+			return 0, false
+		}
+	}
+	return 0, false
+}
+
+func validateInstrumentationRedeclarationDiagnostic(data []byte, invocationDir string, input *ConsumerInput, plan *InstrumentationOriginalPackagePlan, declarations []InstrumentationRedeclaration) error {
+	if len(data) == 0 || len(data) > commandOutputLimit || !strings.HasSuffix(string(data), "\n") {
+		return fmt.Errorf("missing or over-bound complete original compiler diagnostic")
+	}
+	lines := strings.Split(strings.TrimSuffix(string(data), "\n"), "\n")
+	if len(lines) != 1+2*len(declarations) || lines[0] != "# "+plan.PackagePath {
+		return fmt.Errorf("source rejection has unknown, incomplete or mixed diagnostics")
+	}
+	positionMatches := func(line, message string, expected InstrumentationDeclarationPosition) bool {
+		suffix := fmt.Sprintf(":%d:%d: %s", expected.Line, expected.Column, message)
+		if !strings.HasSuffix(line, suffix) {
+			return false
+		}
+		filename := strings.TrimSuffix(line, suffix)
+		if !filepath.IsAbs(filename) {
+			filename = filepath.Join(invocationDir, filename)
+		}
+		physical, err := CPPRegularSource(input.SourceRoot, expected.File)
+		if err != nil {
+			return false
+		}
+		resolved, err := sourcepath.Resolve(filename)
+		return err == nil && resolved == physical
+	}
+	for index, declaration := range declarations {
+		if !positionMatches(lines[1+2*index], declaration.Name+" redeclared in this block", declaration.Current) ||
+			!strings.HasPrefix(lines[2+2*index], "\t") ||
+			!positionMatches(strings.TrimPrefix(lines[2+2*index], "\t"), "other declaration of "+declaration.Name, declaration.Previous) {
+			return fmt.Errorf("compiler refusal lacks complete physical attribution to the original redeclarations")
+		}
+	}
+	return nil
+}
+
+type instrumentationRejectedMetadata struct {
+	path, physical, digest string
+}
+
+func (metadata instrumentationRejectedMetadata) verify() error {
+	info, err := os.Lstat(metadata.path)
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 2<<20 {
+		return fmt.Errorf("actual rejected module metadata is missing, redirected or over-bound")
+	}
+	physical, err := sourcepath.Resolve(metadata.path)
+	if err != nil || physical != metadata.physical {
+		return fmt.Errorf("actual rejected module metadata changed its physical origin")
+	}
+	if digest, err := FileSHA256(physical); err != nil || digest != metadata.digest {
+		return fmt.Errorf("actual rejected module metadata changed original bytes")
+	}
+	return nil
+}
+
+func validateInstrumentationRejectedSelection(data []byte, input *ConsumerInput, plan *InstrumentationOriginalPackagePlan) (*instrumentationRejectedMetadata, error) {
+	if len(data) == 0 || len(data) > commandOutputLimit {
+		return nil, fmt.Errorf("source refusal lacks bounded actual package-selection JSON")
+	}
+	var selected struct {
+		Dir, ImportPath, Name, Export, BuildID, ForTest             string
+		GoFiles, CompiledGoFiles, SFiles                            []string
+		CgoFiles, CFiles, CXXFiles, FFiles, SwigFiles, SwigCXXFiles []string
+		Incomplete                                                  bool
+		Error                                                       json.RawMessage
+		DepsErrors                                                  []json.RawMessage
+		Module                                                      *struct {
+			Path, Version, Dir, GoMod string
+			Main                      bool
+			Replace                   *struct {
+				Path, Version, Dir string
+				Replace            json.RawMessage
+			}
+		}
+	}
+	if err := json.Unmarshal(data, &selected); err != nil {
+		return nil, err
+	}
+	root, err := sourcepath.Resolve(input.SourceRoot)
+	if err != nil {
+		return nil, err
+	}
+	directory, err := sourcepath.Resolve(selected.Dir)
+	if err != nil || directory != filepath.Join(root, filepath.FromSlash(plan.PackageDirectory)) ||
+		selected.ImportPath != plan.PackagePath || selected.Name != plan.PackageName || selected.ForTest != "" ||
+		selected.Export != "" || selected.BuildID != "" || selected.Incomplete || len(selected.Error) != 0 || len(selected.DepsErrors) != 0 ||
+		len(selected.CgoFiles)+len(selected.CFiles)+len(selected.CXXFiles)+len(selected.FFiles)+len(selected.SwigFiles)+len(selected.SwigCXXFiles) != 0 {
+		return nil, fmt.Errorf("source refusal has foreign, generated, native, incomplete or exported package roles")
+	}
+	for _, files := range []struct{ actual, wanted []string }{
+		{selected.GoFiles, plan.GoFiles}, {selected.CompiledGoFiles, plan.GoFiles}, {selected.SFiles, plan.SFiles},
+	} {
+		var actual []string
+		for _, name := range files.actual {
+			if path.Base(name) != name || !CPPLocalSource(name) {
+				return nil, fmt.Errorf("source refusal has unbound compiled source origins")
+			}
+			actual = append(actual, path.Join(plan.PackageDirectory, name))
+		}
+		if !reflect.DeepEqual(actual, files.wanted) {
+			return nil, fmt.Errorf("source refusal changed complete actual Go/ASM selection")
+		}
+	}
+	owner := selected.Module
+	if owner == nil || owner.Path != input.Module || owner.Version != input.Version || owner.Main != (input.SourceModule == "") {
+		return nil, fmt.Errorf("source refusal changed actual module/version/main ownership")
+	}
+	if input.SourceModule != "" && input.SourceModule != input.Module {
+		if owner.Replace == nil || owner.Replace.Path != input.SourceModule || owner.Replace.Version != input.Version || len(owner.Replace.Replace) != 0 {
+			return nil, fmt.Errorf("source refusal lacks its exact versioned namespace replacement")
+		}
+		replaced, err := sourcepath.Resolve(owner.Replace.Dir)
+		if err != nil || replaced != root {
+			return nil, fmt.Errorf("source refusal changed original replaced archive root")
+		}
+	} else if owner.Replace != nil {
+		return nil, fmt.Errorf("source refusal has an unregistered replacement")
+	}
+	owned, err := sourcepath.Resolve(owner.Dir)
+	if err != nil || owned != root {
+		return nil, fmt.Errorf("source refusal changed original module root")
+	}
+	physical, err := sourcepath.Resolve(owner.GoMod)
+	if err != nil || !discoverySHA256Pattern.MatchString(input.Sources["go.mod"]) {
+		return nil, fmt.Errorf("rejected package metadata lacks its original physical/byte identity")
+	}
+	metadata := &instrumentationRejectedMetadata{path: owner.GoMod, physical: physical, digest: input.Sources["go.mod"]}
+	return metadata, metadata.verify()
+}
diff --git a/gotoolprofile/instrumentation_source_rejection_go127_test.go b/gotoolprofile/instrumentation_source_rejection_go127_test.go
new file mode 100644
index 000000000..4049ee058
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_rejection_go127_test.go
@@ -0,0 +1,246 @@
+//go:build go1.27 && (darwin || linux) && (amd64 || arm64)
+
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func instrumentationSourceRejectionFixture(t *testing.T, marker *InstrumentationExportObservation, previous, current string) (*ConsumerInput, *InstrumentationOriginalSourceInventory, *InstrumentationOriginalPackagePlan) {
+	t.Helper()
+	input := instrumentationOriginalFixture(t, marker.Early)
+	for name, declaration := range map[string]string{"base.go": previous, "mode_race.go": current} {
+		contents := input.Headers[name] + "\n" + declaration + "\n"
+		if err := os.WriteFile(filepath.Join(input.SourceRoot, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+		input.Headers[name], input.Sources[name] = contents, bytesSHA256([]byte(contents))
+	}
+	inventory, err := CaptureInstrumentationOriginalSourceInventory(input, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(input, inventory, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return input, inventory, plan
+}
+
+func instrumentationSourceRejectionMarker(t *testing.T, ctx context.Context, binary string) *InstrumentationExportObservation {
+	t.Helper()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(),
+		runtime.GOOS+"/"+runtime.GOARCH, InstrumentationRace, "1", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return marker
+}
+
+func TestInstrumentationSourceRejectionActualGoDeclarationFamily(t *testing.T) {
+	binary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
+	defer cancel()
+	marker := instrumentationSourceRejectionMarker(t, ctx, binary)
+	for _, previous := range instrumentationRedeclarationKinds {
+		for _, current := range instrumentationRedeclarationKinds {
+			t.Run(previous.name+"/"+current.name, func(t *testing.T) {
+				input, inventory, plan := instrumentationSourceRejectionFixture(t, marker, previous.declaration, current.declaration)
+				proof, err := CaptureInstrumentationSourceRejection(ctx, binary, input.SourceRoot, os.Environ(), input, inventory, marker, plan, RunBounded)
+				if err != nil {
+					t.Fatal("actual original compiler family rejection: ", err)
+				}
+				if proof.ExitCode != 1 || len(proof.Redeclarations) != 1 || proof.Redeclarations[0].Name != "Item" {
+					t.Fatalf("actual compiler refusal did not match complete declaration replay: %+v", proof)
+				}
+				data, err := json.Marshal(proof)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var replayed InstrumentationSourceRejection
+				if err := json.Unmarshal(data, &replayed); err != nil {
+					t.Fatal(err)
+				}
+				if err := ValidateInstrumentationSourceRejection(input, inventory, marker, plan, &replayed); err != nil {
+					t.Fatal("portable original refusal replay: ", err)
+				}
+				t.Logf("actual %s %s %s/%s compiler exit1, complete physical redeclarations=%+v",
+					runtime.Version(), plan.Target, previous.name, current.name, proof.Redeclarations)
+			})
+		}
+	}
+}
+
+func TestInstrumentationSourceRejectionActualFailureAndSourceGuards(t *testing.T) {
+	binary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
+	defer cancel()
+	marker := instrumentationSourceRejectionMarker(t, ctx, binary)
+	for _, phase := range []string{
+		"missing tool", "joined transport error", "joined context error", "unknown diagnostic",
+		"missing diagnostic", "missing selection", "source mutation", "new sibling", "metadata alias",
+	} {
+		t.Run(phase, func(t *testing.T) {
+			input, inventory, plan := instrumentationSourceRejectionFixture(t, marker, "const Item = 1", "const Item = 2")
+			observedExit := false
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if len(args) < 2 || args[0] != "list" || args[1] != "-export" {
+					return RunBounded(ctx, dir, env, name, args...)
+				}
+				if phase == "missing tool" {
+					return nil, []byte("missing actual compiler\n"), exec.ErrNotFound
+				}
+				stdout, stderr, err := RunBounded(ctx, dir, env, name, args...)
+				code, plain := instrumentationRejectionExitCode(err)
+				if !plain || code != 1 {
+					t.Fatalf("tripwire prerequisite lacks the unchanged actual compiler exit1: %v", err)
+				}
+				observedExit = true
+				switch phase {
+				case "joined transport error":
+					err = errors.Join(err, fmt.Errorf("unknown transport failure"))
+				case "joined context error":
+					err = errors.Join(err, context.DeadlineExceeded)
+				case "unknown diagnostic":
+					stderr = append(stderr, []byte("unknown compiler warning\n")...)
+				case "missing diagnostic":
+					stderr = nil
+				case "missing selection":
+					stdout = nil
+				case "source mutation", "new sibling":
+					file := "mode_asan.s"
+					if phase == "new sibling" {
+						file = "late.go"
+					}
+					if err := os.WriteFile(filepath.Join(input.SourceRoot, file), []byte("package late\n"), 0600); err != nil {
+						t.Fatal(err)
+					}
+				case "metadata alias":
+					metadata := filepath.Join(input.SourceRoot, "go.mod")
+					original := filepath.Join(t.TempDir(), "original-go.mod")
+					if err := os.Rename(metadata, original); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Symlink(original, metadata); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return stdout, stderr, err
+			}
+			if proof, err := CaptureInstrumentationSourceRejection(ctx, binary, input.SourceRoot, os.Environ(), input, inventory, marker, plan, run); err == nil || proof != nil {
+				t.Fatal("actual tool/transport/diagnostic/source failure became a source refusal")
+			}
+			if phase != "missing tool" && !observedExit {
+				t.Fatal("negative fixture never reached its actual compiler rejection")
+			}
+		})
+	}
+}
+
+func TestInstrumentationSourceRejectionMainMetadataAndPortableTripwires(t *testing.T) {
+	binary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	marker := instrumentationSourceRejectionMarker(t, ctx, binary)
+	input, inventory, plan := instrumentationSourceRejectionFixture(t, marker, "const Item = 1", "const Item = 2")
+	proof, err := CaptureInstrumentationSourceRejection(ctx, binary, input.SourceRoot, os.Environ(), input, inventory, marker, plan, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	encoded, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*InstrumentationSourceRejection){
+		"protocol":      func(p *InstrumentationSourceRejection) { p.Protocol = "unregistered" },
+		"exit":          func(p *InstrumentationSourceRejection) { p.ExitCode = 2 },
+		"command":       func(p *InstrumentationSourceRejection) { p.ExportArgs = nil },
+		"marker":        func(p *InstrumentationSourceRejection) { p.MarkerObservationID = strings.Repeat("a", 64) },
+		"physical line": func(p *InstrumentationSourceRejection) { p.Redeclarations[0].Current.Line++ },
+		"deleted pair":  func(p *InstrumentationSourceRejection) { p.Redeclarations = nil },
+		"foreign main config": func(p *InstrumentationSourceRejection) {
+			p.InvocationConfigSHA256["go.mod"] = bytesSHA256([]byte("foreign configuration"))
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationSourceRejection
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := ValidateInstrumentationSourceRejection(input, inventory, marker, plan, &changed); err == nil {
+				t.Fatal("changed original main-package metadata or compiler/source scope was accepted")
+			}
+		})
+	}
+}
+
+func TestInstrumentationSourceRejectionCanonicalInvocationAndOriginalRoot(t *testing.T) {
+	binary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	marker := instrumentationSourceRejectionMarker(t, ctx, binary)
+	for _, redirectSource := range []bool{false, true} {
+		name := "canonical command directory survives unused logical alias"
+		if redirectSource {
+			name = "original source alias cannot change physical origin"
+		}
+		t.Run(name, func(t *testing.T) {
+			input, inventory, plan := instrumentationSourceRejectionFixture(t, marker, "const Item = 1", "const Item = 2")
+			original, err := filepath.EvalSymlinks(input.SourceRoot)
+			if err != nil {
+				t.Fatal(err)
+			}
+			copyRoot := t.TempDir()
+			for file, contents := range input.Headers {
+				if err := os.WriteFile(filepath.Join(copyRoot, file), []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			alias := filepath.Join(t.TempDir(), "invocation")
+			if err := os.Symlink(original, alias); err != nil {
+				t.Fatal(err)
+			}
+			if redirectSource {
+				input.SourceRoot = alias
+			}
+			didRun := false
+			run := func(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, []byte, error) {
+				if len(args) > 1 && args[0] == "list" && args[1] == "-export" {
+					if dir != original {
+						t.Fatalf("actual export used unbound logical CWD %q, expected original physical %q", dir, original)
+					}
+					if err := os.Remove(alias); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.Symlink(copyRoot, alias); err != nil {
+						t.Fatal(err)
+					}
+					didRun = true
+				}
+				return RunBounded(ctx, dir, env, name, args...)
+			}
+			proof, err := CaptureInstrumentationSourceRejection(ctx, binary, alias, os.Environ(), input, inventory, marker, plan, run)
+			if !didRun {
+				t.Fatal("physical-identity fixture never reached the actual compiler")
+			}
+			if redirectSource {
+				if err == nil || proof != nil {
+					t.Fatal("equal-byte original source root redirection became a source refusal")
+				}
+			} else if err != nil || proof == nil {
+				t.Fatalf("unused alias changed the canonical actual invocation: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_source_rejection_test.go b/gotoolprofile/instrumentation_source_rejection_test.go
new file mode 100644
index 000000000..6b0e15371
--- /dev/null
+++ b/gotoolprofile/instrumentation_source_rejection_test.go
@@ -0,0 +1,112 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var instrumentationRedeclarationKinds = []struct {
+	name, declaration string
+	column            int
+}{
+	{"const", "const Item = 1", 7},
+	{"var", "var Item int", 5},
+	{"type", "type Item int", 6},
+	{"func", "func Item() {}", 6},
+}
+
+func TestInstrumentationSourceRejectionDeclarationNamespaceFamily(t *testing.T) {
+	for _, previous := range instrumentationRedeclarationKinds {
+		for _, current := range instrumentationRedeclarationKinds {
+			t.Run(previous.name+"/"+current.name, func(t *testing.T) {
+				inventory := &InstrumentationOriginalSourceInventory{Contents: map[string]string{
+					"a.go": "package sample\n\n" + previous.declaration + "\n",
+					"b.go": "package sample\n\n" + current.declaration + "\n",
+				}}
+				plan := &InstrumentationOriginalPackagePlan{PackageName: "sample", GoFiles: []string{"a.go", "b.go"}}
+				actual, err := replayInstrumentationRedeclarations(inventory, plan)
+				wanted := []InstrumentationRedeclaration{{
+					Name: "Item",
+					Previous: InstrumentationDeclarationPosition{
+						File: "a.go", Line: 3, Column: previous.column,
+					},
+					Current: InstrumentationDeclarationPosition{
+						File: "b.go", Line: 3, Column: current.column,
+					},
+				}}
+				if err != nil || !reflect.DeepEqual(actual, wanted) {
+					t.Fatalf("complete package namespace replay: got=%+v wanted=%+v error=%v", actual, wanted, err)
+				}
+			})
+		}
+	}
+}
+
+func TestInstrumentationSourceRejectionKeepsPhysicalNamesAndCompleteNamespace(t *testing.T) {
+	inventory := &InstrumentationOriginalSourceInventory{Contents: map[string]string{
+		"a.go": "package sample\nconst Item = 1\nvar _ int\nfunc init() {}\ntype A struct{}\nfunc (A) Method() {}\n",
+		"b.go": "package sample\nvar _ int\nfunc init() {}\ntype B struct{}\nfunc (B) Method() {}\nfunc local() { Item := 2; _ = Item }\nconst directiveText = \"//line somewhere.go:1\"\n",
+	}}
+	plan := &InstrumentationOriginalPackagePlan{PackageName: "sample", GoFiles: []string{"a.go", "b.go"}}
+	actual, err := replayInstrumentationRedeclarations(inventory, plan)
+	if err != nil || len(actual) != 0 {
+		t.Fatalf("blank/init/method/local/string names are not package redeclarations: %+v %v", actual, err)
+	}
+	inventory.Contents["b.go"] += "var Item int\ntype Item int\n"
+	actual, err = replayInstrumentationRedeclarations(inventory, plan)
+	if err != nil || len(actual) != 2 || actual[0].Previous != actual[1].Previous ||
+		actual[0].Previous != (InstrumentationDeclarationPosition{File: "a.go", Line: 2, Column: 7}) ||
+		actual[0].Current != (InstrumentationDeclarationPosition{File: "b.go", Line: 8, Column: 5}) ||
+		actual[1].Current != (InstrumentationDeclarationPosition{File: "b.go", Line: 9, Column: 6}) {
+		t.Fatalf("every duplicate must retain the first physical declaration: %+v %v", actual, err)
+	}
+}
+
+func TestInstrumentationSourceRejectionRefusesIncompleteOrReattributedSyntax(t *testing.T) {
+	for name, source := range map[string]string{
+		"missing":         "",
+		"another package": "package elsewhere\nconst Item = 2\n",
+		"syntax failure":  "package sample\nfunc broken(\n",
+		"line directive":  "package sample\n//line elsewhere.go:1\nconst Item = 2\n",
+		"block directive": "package sample\n/*line elsewhere.go:1*/ const Item = 2\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			inventory := &InstrumentationOriginalSourceInventory{Contents: map[string]string{
+				"a.go": "package sample\nconst Item = 1\n",
+			}}
+			if source != "" {
+				inventory.Contents["b.go"] = source
+			}
+			plan := &InstrumentationOriginalPackagePlan{PackageName: "sample", GoFiles: []string{"a.go", "b.go"}}
+			if _, err := replayInstrumentationRedeclarations(inventory, plan); err == nil {
+				t.Fatal("incomplete or physically reattributed source became a declaration witness")
+			}
+		})
+	}
+	for name, plan := range map[string]*InstrumentationOriginalPackagePlan{
+		"missing plan": nil,
+		"empty Go":     {PackageName: "sample"},
+		"cgo role":     {PackageName: "sample", GoFiles: []string{"a.go"}, CgoFiles: []string{"cgo.go"}},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := replayInstrumentationRedeclarations(&InstrumentationOriginalSourceInventory{}, plan); err == nil {
+				t.Fatal("missing or different source role became a declaration witness")
+			}
+		})
+	}
+}
+
+func TestInstrumentationSourceRejectionBoundsDeclarationWork(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("package sample\n")
+	for index := 0; index <= 32768; index++ {
+		fmt.Fprintf(&source, "var Item%d int\n", index)
+	}
+	inventory := &InstrumentationOriginalSourceInventory{Contents: map[string]string{"a.go": source.String()}}
+	plan := &InstrumentationOriginalPackagePlan{PackageName: "sample", GoFiles: []string{"a.go"}}
+	if _, err := replayInstrumentationRedeclarations(inventory, plan); err == nil {
+		t.Fatal("unbounded declaration inventory was accepted")
+	}
+}
diff --git a/gotoolprofile/instrumentation_target_exclusion.go b/gotoolprofile/instrumentation_target_exclusion.go
new file mode 100644
index 000000000..c1afc28fa
--- /dev/null
+++ b/gotoolprofile/instrumentation_target_exclusion.go
@@ -0,0 +1,158 @@
+package gotoolprofile
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+const InstrumentationTargetExclusionProtocol = "actual_go_instrumentation_tagged_target_exclusion_v1"
+
+// InstrumentationTargetExclusion is a distinct, zero-object mode-scope witness.
+// Early retains its unchanged v1 command. CommandArgs records the additional
+// actual command with this source requirement's exact canonical custom tags.
+// Neither observation is an original-package export or LLVM object proof.
+type InstrumentationTargetExclusion struct {
+	Protocol     string                           `json:"protocol"`
+	Early        *InstrumentationEarlyObservation `json:"early"`
+	CustomTags   []string                         `json:"custom_tags,omitempty"`
+	CommandArgs  []string                         `json:"command_args"`
+	ExitCode     int                              `json:"exit_code"`
+	StdoutSHA256 string                           `json:"stdout_sha256"`
+	Stderr       string                           `json:"stderr"`
+}
+
+func CaptureInstrumentationScopeObservation(ctx context.Context, binary, ownedDir string, env []string, target string, mode InstrumentationMode, cgo string, overrides map[string]string, tags []string, run Runner) (*InstrumentationEarlyObservation, *InstrumentationTargetExclusion, error) {
+	early, err := CaptureInstrumentationEarlyObservation(ctx, binary, ownedDir, env, target, mode, cgo, overrides, run)
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := validateInstrumentationScopeTags(tags, early); err != nil {
+		return nil, nil, err
+	}
+	if early.Status == InstrumentationEarlyRuleAccepted {
+		return early, nil, nil
+	}
+	dir := filepath.Join(ownedDir, "mode")
+	replacements := copyInstrumentationHashes(early.BaselineFeatures.Environment)
+	replacements["GOENV"] = "off"
+	delete(replacements, "GOVERSION")
+	replacements["CGO_ENABLED"], replacements["GOTOOLCHAIN"] = cgo, "local"
+	replacements["GOWORK"], replacements["GOFLAGS"], replacements["GOPACKAGESDRIVER"] = "off", "", "off"
+	modeEnv := replaceEnv(env, replacements)
+	if err := recheckInstrumentationTargetExclusion(ctx, binary, dir, modeEnv, early, run); err != nil {
+		return nil, nil, err
+	}
+	args := instrumentationTargetExclusionArgs(early.BuildFlags, tags)
+	stdout, stderr, commandErr := run(ctx, dir, modeEnv, binary, args...)
+	rules, err := ReplayInstrumentationSourceProof(early.SourceRules)
+	if err != nil {
+		return nil, nil, err
+	}
+	status, err := ClassifyInstrumentationEarlyResult(rules, target, mode, stdout, stderr, commandErr)
+	if err != nil || status != InstrumentationOfficialTargetUnsupported {
+		return nil, nil, fmt.Errorf("tagged instrumentation target rule is not the exact registered refusal: %v", err)
+	}
+	if err := recheckInstrumentationTargetExclusion(ctx, binary, dir, modeEnv, early, run); err != nil {
+		return nil, nil, err
+	}
+	proof := &InstrumentationTargetExclusion{
+		Protocol: InstrumentationTargetExclusionProtocol, Early: early,
+		CustomTags: append([]string(nil), tags...), CommandArgs: args,
+		ExitCode: 2, StdoutSHA256: bytesSHA256(stdout), Stderr: string(stderr),
+	}
+	if err := ValidateInstrumentationTargetExclusion(proof, tags); err != nil {
+		return nil, nil, err
+	}
+	return early, proof, nil
+}
+
+func instrumentationTargetExclusionArgs(flags, tags []string) []string {
+	args := append([]string{"list", "-find", "-json", "-mod=readonly"}, flags...)
+	if len(tags) != 0 {
+		args = append(args, "-tags="+strings.Join(tags, ","))
+	}
+	return append(args, ".")
+}
+
+func validateInstrumentationScopeTags(tags []string, early *InstrumentationEarlyObservation) error {
+	if early == nil || early.BaselineFeatures == nil {
+		return fmt.Errorf("mode scope tags lack the actual builtin foundation")
+	}
+	copy := *early
+	copy.MarkerSelection = early.BaselineFeatures.MarkerSelection
+	return validateInstrumentationCustomTags(tags, &copy)
+}
+
+func ValidateInstrumentationTargetExclusion(proof *InstrumentationTargetExclusion, tags []string) error {
+	if proof == nil || proof.Protocol != InstrumentationTargetExclusionProtocol {
+		return fmt.Errorf("missing tagged official target-exclusion protocol")
+	}
+	if err := ValidateInstrumentationEarlyObservation(proof.Early); err != nil {
+		return err
+	}
+	if err := validateInstrumentationScopeTags(tags, proof.Early); err != nil {
+		return err
+	}
+	if proof.Early.Status != InstrumentationOfficialTargetUnsupported ||
+		!equalDiscoveryStrings(tags, proof.CustomTags) ||
+		!reflect.DeepEqual(proof.CommandArgs, instrumentationTargetExclusionArgs(proof.Early.BuildFlags, tags)) ||
+		proof.ExitCode != 2 || proof.StdoutSHA256 != bytesSHA256(nil) || proof.Stderr != proof.Early.Stderr {
+		return fmt.Errorf("official target exclusion lacks the exact tagged Exit2/empty-output/unique diagnostic")
+	}
+	return nil
+}
+
+func recheckInstrumentationTargetExclusion(ctx context.Context, binary, dir string, env []string, early *InstrumentationEarlyObservation, run Runner) error {
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, dir, env, run)
+	if err != nil || !reflect.DeepEqual(commandContext, early.CommandContext) {
+		return fmt.Errorf("tagged target-rule command context changed: %v", err)
+	}
+	portable := copyInstrumentationHashes(actual)
+	for _, key := range []string{"GOROOT", "GOTOOLDIR", "GOCACHE"} {
+		delete(portable, key)
+	}
+	if !reflect.DeepEqual(portable, early.Environment) {
+		return fmt.Errorf("tagged target-rule actual mode environment changed")
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(sources, early.SourceRules) {
+		return fmt.Errorf("tagged target-rule complete source registration changed: %v", err)
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, env, actual, run)
+	if err != nil {
+		return err
+	}
+	state := &InstrumentationToolState{Directory: tools.directory, BinarySHA256: tools.digests,
+		BinaryOrigins: tools.origins, RoutingSHA256: tools.routing, DispatcherSHA256: tools.dispatcher}
+	if !reflect.DeepEqual(state, early.ModeTools) {
+		return fmt.Errorf("tagged target-rule actual subtool routing/bytes changed")
+	}
+	if digest, err := FileSHA256(binary); err != nil || digest != early.BaselineFeatures.DriverSHA256 {
+		return fmt.Errorf("tagged target-rule actual Go driver changed: %v", err)
+	}
+	for name, before := range early.BaselineFeatures.ToolSourceSHA256 {
+		if digest, err := FileSHA256(filepath.Join(actual["GOROOT"], filepath.FromSlash(name))); err != nil || digest != before {
+			return fmt.Errorf("tagged target-rule builtin source changed: %s: %v", name, err)
+		}
+	}
+	files := MarkerFiles(instrumentationObserverTags(early.BaselineFeatures))
+	entries, err := os.ReadDir(dir)
+	if err != nil || len(entries) != len(files) {
+		return fmt.Errorf("tagged target-rule marker inventory changed: %v", err)
+	}
+	for name, content := range files {
+		file := filepath.Join(dir, name)
+		info, err := os.Lstat(file)
+		if err != nil || !info.Mode().IsRegular() {
+			return fmt.Errorf("tagged target-rule marker is not a regular original source: %s", name)
+		}
+		if digest, err := FileSHA256(file); err != nil || digest != bytesSHA256(content) {
+			return fmt.Errorf("tagged target-rule marker source changed: %s: %v", name, err)
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_target_exclusion_test.go b/gotoolprofile/instrumentation_target_exclusion_test.go
new file mode 100644
index 000000000..f0a3fccd5
--- /dev/null
+++ b/gotoolprofile/instrumentation_target_exclusion_test.go
@@ -0,0 +1,121 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func captureActualTargetExclusion(t *testing.T, run Runner) *InstrumentationTargetExclusion {
+	t.Helper()
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	_, proof, err := CaptureInstrumentationScopeObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "windows/arm64", InstrumentationRace, "1", nil, []string{"alpha", "beta"}, run)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return proof
+}
+
+func TestInstrumentationTargetExclusionActualTagsAndStrictReplay(t *testing.T) {
+	proof := captureActualTargetExclusion(t, RunBounded)
+	tags := []string{"alpha", "beta"}
+	if err := ValidateInstrumentationTargetExclusion(proof, tags); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(proof.CommandArgs, []string{"list", "-find", "-json", "-mod=readonly", "-race", "-tags=alpha,beta", "."}) ||
+		strings.Contains(strings.Join(proof.Early.CommandArgs, " "), "-tags") {
+		t.Fatal("tagged scope command impersonated or altered the original v1 early command")
+	}
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mutations := map[string]func(*InstrumentationTargetExclusion){
+		"delete protocol":  func(p *InstrumentationTargetExclusion) { p.Protocol = "" },
+		"delete tags":      func(p *InstrumentationTargetExclusion) { p.CustomTags = nil },
+		"replace tags":     func(p *InstrumentationTargetExclusion) { p.CustomTags[0] = "other" },
+		"delete argv tags": func(p *InstrumentationTargetExclusion) { p.CommandArgs = p.Early.CommandArgs },
+		"wrong exit":       func(p *InstrumentationTargetExclusion) { p.ExitCode = 1 },
+		"mixed diagnostic": func(p *InstrumentationTargetExclusion) { p.Stderr += "missing SDK\n" },
+		"nonempty stdout":  func(p *InstrumentationTargetExclusion) { p.StdoutSHA256 = bytesSHA256([]byte("unexpected")) },
+		"different target": func(p *InstrumentationTargetExclusion) { p.Early.Target = "windows/amd64" },
+		"different mode":   func(p *InstrumentationTargetExclusion) { p.Early.Mode = InstrumentationASan },
+		"missing CGO":      func(p *InstrumentationTargetExclusion) { p.Early.CGOEnabled = "" },
+		"missing source rule": func(p *InstrumentationTargetExclusion) {
+			delete(p.Early.SourceRules.SourceText, "src/cmd/go/internal/work/init.go")
+		},
+		"different actual tool": func(p *InstrumentationTargetExclusion) {
+			p.Early.ModeTools.BinarySHA256["asm"] = strings.Repeat("0", 64)
+		},
+	}
+	for name, mutate := range mutations {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationTargetExclusion
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := ValidateInstrumentationTargetExclusion(&changed, tags); err == nil {
+				t.Fatal("incomplete or substituted scope refusal accepted")
+			}
+		})
+	}
+}
+
+func TestInstrumentationTargetExclusionRejectsChangedActualCommand(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, failure := range []string{"timeout", "missing SDK", "missing CC", "missing CGO", "mixed", "stdout", "marker"} {
+		t.Run(failure, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			seen := 0
+			run := func(ctx context.Context, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+				if !strings.Contains(strings.Join(args, " "), "-tags=alpha") {
+					return RunBounded(ctx, dir, env, binary, args...)
+				}
+				seen++
+				if failure == "marker" {
+					stdout, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+					if writeErr := os.WriteFile(filepath.Join(dir, "go.mod"), []byte("module forged\n"), 0600); writeErr != nil {
+						t.Fatal(writeErr)
+					}
+					return stdout, stderr, err
+				}
+				if failure == "timeout" {
+					return nil, nil, context.DeadlineExceeded
+				}
+				stdout, stderr, err := RunBounded(ctx, dir, env, binary, args...)
+				if failure == "stdout" {
+					stdout = []byte("unexpected")
+				} else {
+					stderr = append(stderr, []byte(failure+"\n")...)
+				}
+				return stdout, stderr, err
+			}
+			_, proof, err := CaptureInstrumentationScopeObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "windows/arm64", InstrumentationRace, "1", nil, []string{"alpha"}, run)
+			if err == nil || proof != nil || seen != 1 {
+				t.Fatalf("changed actual command became an exclusion: seen=%d proof=%v error=%v", seen, proof != nil, err)
+			}
+		})
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, proof, err := CaptureInstrumentationScopeObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "windows/arm64", InstrumentationRace, "1", nil, nil, RunBounded); err == nil || proof != nil || !errors.Is(ctx.Err(), context.Canceled) {
+		t.Fatal("cancelled command accepted")
+	}
+}
diff --git a/gotoolprofile/instrumentation_test.go b/gotoolprofile/instrumentation_test.go
new file mode 100644
index 000000000..371517eb6
--- /dev/null
+++ b/gotoolprofile/instrumentation_test.go
@@ -0,0 +1,383 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationBuildFlagsAreExclusiveDriverModes(t *testing.T) {
+	for _, mode := range []string{"race", "msan", "asan"} {
+		flags, err := InstrumentationBuildFlags(InstrumentationMode(mode))
+		if err != nil || !reflect.DeepEqual(flags, []string{"-" + mode}) {
+			t.Fatalf("%s: flags=%v err=%v", mode, flags, err)
+		}
+		flags[0] = "-tags=" + mode
+		again, _ := InstrumentationBuildFlags(InstrumentationMode(mode))
+		if again[0] != "-"+mode {
+			t.Fatal("caller mutated another invocation's flags")
+		}
+	}
+	for _, mode := range []string{"", "baseline", "Race", "race,asan", "-race", "race -asan", "cgo", "race\n"} {
+		if _, err := InstrumentationBuildFlags(InstrumentationMode(mode)); err == nil {
+			t.Fatalf("accepted non-mode %q", mode)
+		}
+	}
+}
+
+func TestInstrumentationRulesReadActualGoRegistration(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		target, mode, buildmode string
+		cgo                     bool
+	}{
+		{"darwin/arm64", "race", "default", false},
+		{"linux/arm64", "race", "default", true},
+		{"linux/amd64", "msan", "default", true},
+		{"linux/arm64", "msan", "pie", true},
+		{"linux/arm64", "asan", "default", true},
+	} {
+		if required, err := rules.RequiresCGO(test.target, InstrumentationMode(test.mode)); err != nil || required != test.cgo {
+			t.Fatalf("%+v: CGO=%v err=%v", test, required, err)
+		}
+		if mode, err := rules.EffectiveBuildMode(test.target, InstrumentationMode(test.mode)); err != nil || mode != test.buildmode {
+			t.Fatalf("%+v: buildmode=%q err=%v", test, mode, err)
+		}
+	}
+	if err := rules.Recheck(); err != nil {
+		t.Fatal(err)
+	}
+	sources, registration := rules.SourceHashes(), rules.RegistrationHashes()
+	if len(sources) != 3 || len(registration) != 4 {
+		t.Fatalf("incomplete source and registration identities: %v / %v", sources, registration)
+	}
+	sources["VERSION"], registration["instrumentInit"] = "changed", "changed"
+	if err := rules.Recheck(); err != nil {
+		t.Fatalf("caller mutated private rule capture through an accessor: %v", err)
+	}
+	var missing *InstrumentationSourceRules
+	if _, err := missing.TargetSupported("darwin/arm64", InstrumentationRace); err == nil {
+		t.Fatal("missing registration became target exclusion")
+	}
+	for _, target := range []string{"", "darwin", "darwin/arm64/race", "darwin /arm64", "linux/arm64\n", "linux/mips"} {
+		if _, err := rules.TargetSupported(target, InstrumentationRace); err == nil {
+			t.Fatalf("invalid or out-of-scope target %q was classified", target)
+		}
+	}
+	if _, err := rules.RequiresCGO("darwin/arm64", InstrumentationASan); err == nil {
+		t.Fatal("rejected target received an effective CGO claim")
+	}
+	if _, err := rules.EffectiveBuildMode("darwin/arm64", InstrumentationMSan); err == nil {
+		t.Fatal("rejected target received an effective PIE claim")
+	}
+	minor, err := goMinor(runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	wrongMinor := 20
+	if minor == wrongMinor {
+		wrongMinor++
+	}
+	for _, version := range []string{"go1.19.13", "go1.28.0", fmt.Sprintf("go1.%d.0", wrongMinor)} {
+		if _, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), version); err == nil {
+			t.Fatalf("accepted wrong or unaudited version %s", version)
+		}
+	}
+}
+
+func TestInstrumentationSourceRegistrationRejectsChangedAndMissingRules(t *testing.T) {
+	root := t.TempDir()
+	for _, name := range instrumentationRuleSources {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		writeInstrumentationFixture(t, root, name, data)
+	}
+	rules, err := CaptureInstrumentationSourceRules(root, runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	initPath := filepath.Join(root, "src/cmd/go/internal/work/init.go")
+	initial, err := os.ReadFile(initPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	changed := strings.Replace(string(initial), `cfg.Goos != "darwin"`, `cfg.Goos != "linux"`, 1)
+	if changed == string(initial) {
+		t.Fatal("actual registered CGO condition was not found")
+	}
+	writeInstrumentationFixture(t, root, "src/cmd/go/internal/work/init.go", []byte(changed))
+	if _, err := CaptureInstrumentationSourceRules(root, runtime.Version()); err == nil {
+		t.Fatal("accepted changed CGO/source semantics")
+	}
+	if err := rules.Recheck(); err == nil {
+		t.Fatal("source mutation after capture was ignored")
+	}
+	writeInstrumentationFixture(t, root, "src/cmd/go/internal/work/init.go", initial)
+	if err := os.Remove(filepath.Join(root, "src/internal/platform/supported.go")); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CaptureInstrumentationSourceRules(root, runtime.Version()); err == nil {
+		t.Fatal("missing platform registration became unsupported target")
+	}
+}
+
+func TestInstrumentationTargetGrammarIsCompleteAndFailClosed(t *testing.T) {
+	valid := `package platform
+func RaceDetectorSupported(goos, goarch string) bool {
+ switch goos {
+ case "linux", "freebsd": return goarch == "amd64" || goarch == "arm64"
+ case "darwin": return "amd64" == goarch
+ default: return false
+ }
+}`
+	targets, err := parseInstrumentationTargetRule([]byte(valid), "RaceDetectorSupported")
+	if err != nil || !targets["linux/amd64"] || !targets["freebsd/arm64"] || !targets["darwin/amd64"] || targets["darwin/arm64"] {
+		t.Fatalf("source-derived target rule=%v err=%v", targets, err)
+	}
+	for _, changed := range []string{
+		strings.Replace(valid, `goarch == "arm64"`, `goarch != "arm64"`, 1),
+		strings.Replace(valid, `return false`, `return true`, 1),
+		strings.Replace(valid, `case "darwin"`, `case "linux"`, 1),
+		strings.Replace(valid, `return "amd64" == goarch`, `log(); return "amd64" == goarch`, 1),
+		strings.Replace(valid, `switch goos`, `switch unknown`, 1),
+		strings.Replace(valid, `goos, goarch string`, `goos, goarch int`, 1),
+		strings.Replace(valid, `goarch == "arm64"`, `goarch == "amd64"`, 1),
+		strings.Replace(valid, `default: return false`, ``, 1),
+		strings.Replace(valid, `"linux", "freebsd"`, `"linux", "linux"`, 1),
+		strings.Replace(valid, `"arm64"`, `"arm 64"`, 1),
+		valid + `
+func RaceDetectorSupported(goos, goarch string) bool { return true }`,
+	} {
+		if _, err := parseInstrumentationTargetRule([]byte(changed), "RaceDetectorSupported"); err == nil {
+			t.Fatalf("accepted incomplete/unknown target grammar: %s", changed)
+		}
+	}
+}
+
+// This checks actual cmd/go early target rules and source selection, not
+// compile/export, sanitizer libraries, cross SDKs, or runtime support.
+func TestInstrumentationActualGoEarlyRulesAllDefaultTargets(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := instrumentationMarkerDirectory(t)
+	tags := []string{"asan", "msan", "race"}
+	for name, data := range MarkerFiles(tags) {
+		writeInstrumentationFixture(t, directory, name, data)
+	}
+	targets := []string{"darwin/amd64", "darwin/arm64", "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "windows/386", "windows/amd64", "windows/arm64", "js/wasm", "wasip1/wasm"}
+	for _, target := range targets {
+		for _, mode := range tags {
+			t.Run(target+"/"+mode, func(t *testing.T) {
+				// Go 1.20 has no wasip1, but mode validation runs before
+				// target package loading and must still reject this pair.
+				env := instrumentationActualEnv(target, "1")
+				flags, _ := InstrumentationBuildFlags(InstrumentationMode(mode))
+				args := append([]string{"list", "-find", "-json", "-mod=readonly"}, flags...)
+				args = append(args, ".")
+				stdout, stderr, commandErr := instrumentationActualCommand(t, directory, env, goBinary, args...)
+				status, err := ClassifyInstrumentationEarlyResult(rules, target, InstrumentationMode(mode), stdout, stderr, commandErr)
+				if err != nil {
+					t.Fatalf("actual driver: %s: %v", stderr, err)
+				}
+				if status == InstrumentationOfficialTargetUnsupported {
+					return
+				}
+				selected, err := DecodeMarkers(stdout, directory, tags)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, tag := range tags {
+					if selected[tag] != (tag == mode) {
+						t.Fatalf("mode flags did not independently select complete marker namespace: %v", selected)
+					}
+				}
+			})
+		}
+	}
+	if err := rules.Recheck(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstrumentationActualGoPrerequisitesAndConflictStayFailures(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := instrumentationMarkerDirectory(t)
+	for name, data := range MarkerFiles([]string{"asan", "msan", "race"}) {
+		writeInstrumentationFixture(t, directory, name, data)
+	}
+	for _, mode := range []string{"race", "msan", "asan"} {
+		stdout, stderr, commandErr := instrumentationActualCommand(t, directory, instrumentationActualEnv("linux/arm64", "0"), goBinary, "list", "-find", "-json", "-"+mode, ".")
+		if commandErr == nil || !strings.HasPrefix(string(stderr), "go: -"+mode+" requires cgo") {
+			t.Fatalf("actual CGO prerequisite missing: %s: %v", stderr, commandErr)
+		}
+		if _, err := ClassifyInstrumentationEarlyResult(rules, "linux/arm64", InstrumentationMode(mode), stdout, stderr, commandErr); err == nil {
+			t.Fatal("CGO/tool failure became target rejection or acceptance")
+		}
+	}
+	for _, modes := range [][2]string{{"race", "msan"}, {"race", "asan"}, {"msan", "asan"}} {
+		_, stderr, commandErr := instrumentationActualCommand(t, directory, instrumentationActualEnv("linux/arm64", "1"), goBinary, "list", "-find", "-"+modes[0], "-"+modes[1], ".")
+		want := "go: may not use -" + modes[0] + " and -" + modes[1] + " simultaneously\n"
+		if commandErr == nil || string(stderr) != want {
+			t.Fatalf("actual mode conflict=%q err=%v", stderr, commandErr)
+		}
+	}
+	env := replaceEnv(instrumentationActualEnv("linux/arm64", "1"), map[string]string{"CC": filepath.Join(directory, "missing-clang")})
+	stdout, stderr, commandErr := instrumentationActualCommand(t, directory, env, goBinary, "list", "-find", "-asan", ".")
+	if commandErr == nil {
+		t.Fatal("actual missing CC did not fail")
+	}
+	if _, err := ClassifyInstrumentationEarlyResult(rules, "linux/arm64", "asan", stdout, stderr, commandErr); err == nil {
+		t.Fatal("missing CC became source/target N/A")
+	}
+}
+
+func TestInstrumentationEarlyRejectionRequiresExactCompleteActualExit(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := instrumentationMarkerDirectory(t)
+	for name, data := range MarkerFiles([]string{"asan"}) {
+		writeInstrumentationFixture(t, directory, name, data)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, actualErr := instrumentationActualCommand(t, directory, instrumentationActualEnv("darwin/arm64", "1"), goBinary, "list", "-find", "-asan", ".")
+	if status, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", "asan", stdout, stderr, actualErr); err != nil || status != InstrumentationOfficialTargetUnsupported {
+		t.Fatalf("exact actual rejection=%s err=%v", status, err)
+	}
+	for _, bad := range []struct {
+		stdout, stderr []byte
+		err            error
+	}{
+		{[]byte("{}"), stderr, actualErr},
+		{nil, append(append([]byte(nil), stderr...), []byte("network failure\n")...), actualErr},
+		{nil, []byte("-asan is not supported on linux/arm64\n"), actualErr},
+		{nil, stderr, errors.New("exit status 2")},
+		{nil, stderr, errors.Join(actualErr, context.DeadlineExceeded)},
+		{nil, stderr, nil},
+	} {
+		if _, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", "asan", bad.stdout, bad.stderr, bad.err); err == nil {
+			t.Fatal("partial, mixed, fabricated, timed-out, or successful diagnostic became target exclusion")
+		}
+	}
+	for _, stdout := range [][]byte{nil, []byte("null"), []byte("{}"), []byte(`{"Dir":"a","ImportPath":"b","GoFiles":["a.go"],"Error":{"Err":"failed"}}`)} {
+		if _, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", "race", stdout, nil, nil); err == nil {
+			t.Fatal("empty, malformed, or failed package output became actual selection")
+		}
+	}
+}
+
+func TestInstrumentationAcceptedEarlyResultRejectsUnknownStderr(t *testing.T) {
+	rules, err := CaptureInstrumentationSourceRules(runtime.GOROOT(), runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := instrumentationMarkerDirectory(t)
+	for name, data := range MarkerFiles([]string{"asan", "msan", "race"}) {
+		writeInstrumentationFixture(t, directory, name, data)
+	}
+	goBinary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdout, stderr, commandErr := instrumentationActualCommand(t, directory, instrumentationActualEnv("darwin/arm64", "0"), goBinary, "list", "-find", "-json", "-race", ".")
+	if commandErr != nil || len(stderr) != 0 {
+		t.Fatalf("zero-dependency actual marker emitted unexpected diagnostics: %s: %v", stderr, commandErr)
+	}
+	if status, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", InstrumentationRace, stdout, stderr, nil); err != nil || status != InstrumentationEarlyRuleAccepted {
+		t.Fatalf("complete actual marker was rejected: %s: %v", status, err)
+	}
+	for _, diagnostics := range []string{
+		"unknown tool warning\n", "go: downloading unregistered/module v1.0.0\n",
+		"go: network unavailable\n", "-race is not supported on darwin/arm64\n",
+		"actual informational message\ncompiler error\n", " ",
+	} {
+		if _, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", InstrumentationRace, stdout, []byte(diagnostics), nil); err == nil {
+			t.Fatalf("accepted unregistered stderr alongside successful actual selection: %q", diagnostics)
+		}
+	}
+	env := replaceEnv(instrumentationActualEnv("darwin/arm64", "0"), map[string]string{"GODEBUG": "cpu.plan9asm_unregistered=off"})
+	stdout, stderr, commandErr = instrumentationActualCommand(t, directory, env, goBinary, "list", "-find", "-json", "-race", ".")
+	if commandErr != nil || !strings.Contains(string(stderr), "unknown cpu feature \"plan9asm_unregistered\"") {
+		t.Fatalf("actual successful driver warning was not reproduced: %s: %v", stderr, commandErr)
+	}
+	t.Logf("actual exit-0 driver warning: %q", stderr)
+	if _, err := ClassifyInstrumentationEarlyResult(rules, "darwin/arm64", InstrumentationRace, stdout, stderr, commandErr); err == nil {
+		t.Fatal("actual exit-0 unknown CPU warning became accepted instrumentation selection")
+	}
+}
+
+func instrumentationMarkerDirectory(t *testing.T) string {
+	t.Helper()
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return directory
+}
+
+func writeInstrumentationFixture(t *testing.T, root, name string, data []byte) {
+	t.Helper()
+	file := filepath.Join(root, filepath.FromSlash(name))
+	if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(file, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func instrumentationActualEnv(target, cgo string) []string {
+	parts := strings.Split(target, "/")
+	return replaceEnv(os.Environ(), map[string]string{"GOOS": parts[0], "GOARCH": parts[1], "CGO_ENABLED": cgo, "GOTOOLCHAIN": "local", "GOWORK": "off", "GOFLAGS": "", "GOENV": "off", "GOEXPERIMENT": ""})
+}
+
+func instrumentationActualCommand(t *testing.T, dir string, env []string, binary string, args ...string) ([]byte, []byte, error) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	return RunBounded(ctx, dir, env, binary, args...)
+}
+
+func decodeInstrumentationAssemblySelection(t *testing.T, stdout []byte) (string, []string, []string) {
+	t.Helper()
+	var pkg struct {
+		Export, ImportPath string
+		GoFiles, SFiles    []string
+		Error              *struct{ Err string }
+	}
+	if err := json.Unmarshal(stdout, &pkg); err != nil || pkg.Error != nil || pkg.ImportPath != "example.invalid/instrumentation-assembly" {
+		t.Fatalf("actual assembly marker package: %s: %v", stdout, err)
+	}
+	return pkg.Export, pkg.GoFiles, pkg.SFiles
+}
diff --git a/gotoolprofile/instrumentation_type_capture.go b/gotoolprofile/instrumentation_type_capture.go
new file mode 100644
index 000000000..563494406
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_capture.go
@@ -0,0 +1,584 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This is an original-input capture, separate from the metadata query. The
+// caller must already authenticate the module ZIP/go.mod and stock SDK. Actual
+// Go selects the whole graph twice under the registered mode, before and after
+// export compilation; source roots, bytes, exports and tool routing are checked
+// again at the end. No import prefix, export digest or portable JSON authorizes
+// a physical root. Foreign modules require their independent v2 source resource;
+// generated/native/embed roles stay closed.
+func CaptureInstrumentationTypeSources(ctx context.Context, binary, directory string, env []string, input *InstrumentationConsumerInput, run Runner) (*InstrumentationTypeSourceProof, error) {
+	modules := []TestModuleSource{}
+	if input != nil && input.TypeSources != nil {
+		modules = input.TypeSources.SourceModules
+	}
+	return CaptureInstrumentationTypeSourcesWithModules(ctx, binary, directory, env, input, modules, run)
+}
+
+func CaptureInstrumentationTypeSourcesWithModules(ctx context.Context, binary, directory string, env []string,
+	input *InstrumentationConsumerInput, modules []TestModuleSource, run Runner,
+) (*InstrumentationTypeSourceProof, error) {
+	return captureInstrumentationTypeSources(ctx, binary, directory, env, input, modules, run, retainInstrumentationRequiredTypeSources)
+}
+
+func captureInstrumentationTypeSources(ctx context.Context, binary, directory string, env []string,
+	input *InstrumentationConsumerInput, modules []TestModuleSource, run Runner,
+	retain func(*InstrumentationConsumerInput, *InstrumentationTypeSourceProof, *instrumentationTypeGraph) error,
+) (*InstrumentationTypeSourceProof, error) {
+	env = replaceEnv(env, map[string]string{"GOENV": "off"})
+	if ctx == nil || ctx.Err() != nil || run == nil || !filepath.IsAbs(binary) || !filepath.IsAbs(directory) || input == nil || input.Plan == nil {
+		return nil, fmt.Errorf("original type source capture needs a live bounded actual Go invocation")
+	}
+	// The consumer also compiles from the physical invocation directory.
+	// Windows short/long spellings can change compiler-recorded source names
+	// and export bytes even when both routes select the same original files.
+	directory, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return nil, err
+	}
+	if err := ValidateInstrumentationConsumerInput(input, input.Plan.PackageDirectory, input.Plan.CustomTags); err != nil {
+		return nil, err
+	}
+	if err := recheckInstrumentationOriginalSources(input.Original); err != nil {
+		return nil, err
+	}
+	moduleGuard, err := BindInstrumentationTypeModuleSources(ctx, binary, directory, env, modules, run)
+	if err != nil {
+		return nil, err
+	}
+	configuration, err := captureInstrumentationInvocationConfig(directory)
+	if err != nil {
+		return nil, err
+	}
+	actual, commandContext, err := instrumentationObserverEnvironment(ctx, binary, directory, env, run)
+	if err != nil {
+		return nil, err
+	}
+	early := input.Observation.Early
+	if err := recheckInstrumentationExportEnvironment(actual, commandContext, early); err != nil {
+		return nil, err
+	}
+	tools, err := captureDiscoveryFeatureSubtools(ctx, binary, env, actual, run)
+	if err != nil || !instrumentationExportToolsMatch(tools, early.ModeTools) {
+		return nil, fmt.Errorf("original type capture tool routing differs from the registered mode: %v", err)
+	}
+	before, err := captureInstrumentationTypeGraph(ctx, binary, directory, env, input, actual, false, moduleGuard, run)
+	if err != nil {
+		return nil, err
+	}
+	after, err := captureInstrumentationTypeGraph(ctx, binary, directory, env, input, actual, true, moduleGuard, run)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(before.selection, after.selection) {
+		return nil, fmt.Errorf("original type source selection/origin/ImportMap/bytes changed during export")
+	}
+	for file, expected := range before.hashes {
+		if after.hashes[file] != expected || after.paths[file] != before.paths[file] {
+			return nil, fmt.Errorf("original imported source/metadata physical path changed during export")
+		}
+	}
+	for file, expected := range after.hashes {
+		resolved, err := sourcepath.Resolve(file)
+		if err != nil || resolved != after.paths[file] {
+			return nil, fmt.Errorf("actual imported source/export path changed during capture")
+		}
+		if digest, err := FileSHA256(file); err != nil || digest != expected {
+			return nil, fmt.Errorf("actual imported source/export bytes changed during capture")
+		}
+	}
+	if err := recheckInstrumentationOriginalSources(input.Original); err != nil {
+		return nil, err
+	}
+	configs, err := captureInstrumentationInvocationConfig(directory)
+	if err != nil || !reflect.DeepEqual(configuration, configs) {
+		return nil, fmt.Errorf("original type capture invocation metadata changed")
+	}
+	now, nowContext, err := instrumentationObserverEnvironment(ctx, binary, directory, env, run)
+	if err != nil || !reflect.DeepEqual(now, actual) || !reflect.DeepEqual(nowContext, commandContext) {
+		return nil, fmt.Errorf("original type capture environment changed")
+	}
+	nowTools, err := captureDiscoveryFeatureSubtools(ctx, binary, env, actual, run)
+	if err != nil || !equalDiscoveryFeatureToolStates(tools, nowTools) {
+		return nil, fmt.Errorf("original type capture tool bytes/routing changed")
+	}
+	sources, err := CaptureInstrumentationSourceProof(actual["GOROOT"], actual["GOVERSION"])
+	if err != nil || !reflect.DeepEqual(sources, early.SourceRules) {
+		return nil, fmt.Errorf("original type capture SDK source rules changed")
+	}
+	if digest, err := FileSHA256(binary); err != nil || digest != early.BaselineFeatures.DriverSHA256 {
+		return nil, fmt.Errorf("original type capture Go driver changed")
+	}
+	for name, expected := range early.BaselineFeatures.ToolSourceSHA256 {
+		if digest, err := FileSHA256(filepath.Join(actual["GOROOT"], filepath.FromSlash(name))); err != nil || digest != expected {
+			return nil, fmt.Errorf("original type capture registered SDK source changed: %s", name)
+		}
+	}
+	proof := after.proof
+	if err := retain(input, proof, after); err != nil {
+		return nil, err
+	}
+	for file, expected := range after.hashes {
+		resolved, err := sourcepath.Resolve(file)
+		if err != nil || resolved != after.paths[file] {
+			return nil, fmt.Errorf("actual original type source path changed during AST capture")
+		}
+		if digest, err := FileSHA256(file); err != nil || digest != expected {
+			return nil, fmt.Errorf("actual original type source/export changed during AST capture")
+		}
+	}
+	if err := moduleGuard.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return proof, ValidateInstrumentationTypeSources(input, proof)
+}
+
+type instrumentationTypeListModule struct {
+	Path, Version, Dir, GoMod string
+	Main                      bool
+	Replace                   *instrumentationTypeListModule
+}
+
+type instrumentationTypeListPackage struct {
+	Dir, ImportPath, Name, Export, ForTest                      string
+	GoFiles, CompiledGoFiles, SFiles, Imports                   []string
+	CgoFiles, CFiles, CXXFiles, FFiles, SwigFiles, SwigCXXFiles []string
+	EmbedFiles, EmbedPatterns                                   []string
+	ImportMap                                                   map[string]string
+	Module                                                      *instrumentationTypeListModule
+	Incomplete                                                  bool
+	Error                                                       json.RawMessage
+	DepsErrors                                                  []json.RawMessage
+}
+
+type instrumentationTypeGraph struct {
+	proof       *InstrumentationTypeSourceProof
+	selection   map[string]string
+	hashes      map[string]string
+	paths       map[string]string
+	files       map[string]map[string]string
+	moduleFiles map[string]string
+	bytes       int
+	modules     *InstrumentationTypeModuleGuard
+}
+
+// This is only an index of metadata already retained by the original/foreign
+// source guards. Private graph constructors used for those guards need not
+// initialize the separate native-header query index.
+func (graph *instrumentationTypeGraph) recordModuleMetadataPath(id, filename string) {
+	if graph.moduleFiles == nil {
+		graph.moduleFiles = make(map[string]string)
+	}
+	graph.moduleFiles[id] = filename
+}
+
+func captureInstrumentationTypeGraph(ctx context.Context, binary, directory string, env []string, input *InstrumentationConsumerInput, actual map[string]string, export bool, modules *InstrumentationTypeModuleGuard, run Runner) (*instrumentationTypeGraph, error) {
+	flags, err := InstrumentationPackageLoadFlags(input)
+	if err != nil {
+		return nil, err
+	}
+	args := append([]string{"list", "-deps", "-compiled", "-json"}, flags...)
+	if export {
+		args = append(args, "-export")
+	}
+	args = append(args, input.Plan.PackagePath)
+	stdout, stderr, err := run(ctx, directory, env, binary, args...)
+	if err != nil || len(stderr) != 0 || len(stdout) == 0 || len(stdout) > commandOutputLimit {
+		return nil, fmt.Errorf("actual same-mode original type graph failed (not source N/A): %v; %s", err, stderr)
+	}
+	graph := &instrumentationTypeGraph{
+		proof:     &InstrumentationTypeSourceProof{Protocol: instrumentationTypeSourcesProtocol, InputSHA256: instrumentationTypeSourceInputSHA(input), Dependencies: []InstrumentationTypeSourcePackage{}, SourceModules: []TestModuleSource{}},
+		selection: make(map[string]string), hashes: make(map[string]string), paths: make(map[string]string), files: make(map[string]map[string]string),
+		modules: modules, moduleFiles: make(map[string]string),
+	}
+	for _, binding := range modules.bindings {
+		graph.proof.SourceModules = append(graph.proof.SourceModules, binding.source)
+	}
+	SortTestModuleSources(graph.proof.SourceModules)
+	decoder := json.NewDecoder(bytes.NewReader(stdout))
+	seen, rootSeen := make(map[string]bool), false
+	for {
+		var pkg instrumentationTypeListPackage
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			return nil, err
+		}
+		if len(seen) >= 4096 || pkg.ImportPath == "" || seen[pkg.ImportPath] || !token.IsIdentifier(pkg.Name) || pkg.Name == "_" ||
+			pkg.Incomplete || len(pkg.Error) != 0 || len(pkg.DepsErrors) != 0 || pkg.ForTest != "" ||
+			len(pkg.CgoFiles)+len(pkg.CFiles)+len(pkg.CXXFiles)+len(pkg.FFiles)+len(pkg.SwigFiles)+len(pkg.SwigCXXFiles)+len(pkg.EmbedFiles)+len(pkg.EmbedPatterns) != 0 {
+			return nil, fmt.Errorf("original type graph has unknown/generated/native/test/embed package roles")
+		}
+		seen[pkg.ImportPath] = true
+		if pkg.ImportPath == "unsafe" {
+			actualRoot, rootErr := sourcepath.Resolve(filepath.Join(actual["GOROOT"], "src", "unsafe"))
+			actualDir, dirErr := sourcepath.Resolve(pkg.Dir)
+			if pkg.Module != nil || pkg.Name != "unsafe" || rootErr != nil || dirErr != nil || actualDir != actualRoot {
+				return nil, fmt.Errorf("builtin unsafe package acquired an external role")
+			}
+			file := filepath.Join(actualRoot, "unsafe.go")
+			if err := graph.retain(file); err != nil {
+				return nil, err
+			}
+			graph.proof.UnsafeSHA256 = graph.hashes[file]
+			continue
+		}
+		entry, err := captureInstrumentationTypePackage(input, actual, pkg, graph, export)
+		if err != nil {
+			return nil, err
+		}
+		// Export bytes are intentionally absent from the pre/post source key:
+		// compilation creates them between the two independently selected graphs.
+		key := entry
+		key.Dependency.Source.ExportSHA256 = ""
+		graph.selection[pkg.ImportPath] = instrumentationObjectSHA(struct {
+			Package InstrumentationTypeSourcePackage
+			Origin  *instrumentationTypeListModule
+			Dir     string
+			SFiles  []string
+		}{Package: key, Origin: pkg.Module, Dir: pkg.Dir, SFiles: pkg.SFiles})
+		if pkg.ImportPath == input.Plan.PackagePath {
+			goFiles := instrumentationTypeNames(pkg.GoFiles, pkg.Dir, input.Original.SourceRoot)
+			compiledGoFiles := instrumentationTypeNames(pkg.CompiledGoFiles, pkg.Dir, input.Original.SourceRoot)
+			asmFiles := instrumentationTypeNames(pkg.SFiles, pkg.Dir, input.Original.SourceRoot)
+			if rootSeen || pkg.Name != input.Plan.PackageName || goFiles == nil || compiledGoFiles == nil || asmFiles == nil ||
+				!equalDiscoveryStrings(goFiles, input.Plan.GoFiles) || !equalDiscoveryStrings(compiledGoFiles, input.Plan.GoFiles) ||
+				!equalDiscoveryStrings(asmFiles, input.Plan.SFiles) {
+				return nil, fmt.Errorf("actual original type graph changed the planned root selection")
+			}
+			rootSeen, graph.proof.RootImportMap = true, entry.Dependency.ImportMap
+		} else {
+			graph.proof.Dependencies = append(graph.proof.Dependencies, entry)
+		}
+	}
+	if !rootSeen {
+		return nil, fmt.Errorf("original type graph omitted the root package")
+	}
+	sort.Slice(graph.proof.Dependencies, func(i, j int) bool {
+		return graph.proof.Dependencies[i].Dependency.Source.PackagePath < graph.proof.Dependencies[j].Dependency.Source.PackagePath
+	})
+	return graph, nil
+}
+
+func instrumentationTypeNames(names []string, directory, root string) []string {
+	if !filepath.IsAbs(root) || !filepath.IsAbs(directory) {
+		return nil
+	}
+	root, err := sourcepath.Resolve(root)
+	if err != nil {
+		return nil
+	}
+	directory, err = sourcepath.Resolve(directory)
+	if err != nil {
+		return nil
+	}
+	info, err := os.Stat(directory)
+	relative, relErr := filepath.Rel(root, directory)
+	if err != nil || !info.IsDir() || relErr != nil || !filepath.IsLocal(relative) {
+		return nil
+	}
+	// A valid empty selection differs from failure. Compare actual physical
+	// origins, not /var versus /private/var (or another root directory alias).
+	result := make([]string, 0, len(names))
+	for _, name := range names {
+		if !filepath.IsAbs(name) {
+			name = filepath.Join(directory, name)
+		}
+		parent, err := sourcepath.Resolve(filepath.Dir(name))
+		if err != nil {
+			return nil
+		}
+		name = filepath.Join(parent, filepath.Base(name))
+		rel, err := filepath.Rel(root, name)
+		if err != nil || !filepath.IsLocal(rel) {
+			return nil
+		}
+		file := filepath.ToSlash(rel)
+		if _, err := CPPRegularSource(root, file); err != nil {
+			return nil
+		}
+		result = append(result, file)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func captureInstrumentationTypePackage(input *InstrumentationConsumerInput, actual map[string]string, pkg instrumentationTypeListPackage, graph *instrumentationTypeGraph, export bool) (InstrumentationTypeSourcePackage, error) {
+	entry := InstrumentationTypeSourcePackage{Name: pkg.Name, Dependency: InstrumentationDependencyExport{
+		Source: ImportExport{ImportPath: pkg.ImportPath, PackagePath: pkg.ImportPath, SourceRole: "stdlib", GoSHA256: make(map[string]string)}, ImportMap: make(map[string]string)}}
+	root := filepath.Join(actual["GOROOT"], "src")
+	var foreign *instrumentationTypeModuleBinding
+	if pkg.Module != nil {
+		module := pkg.Module
+		if module.Path != input.Original.Module || module.Version != input.Original.Version || module.Main != (input.Original.SourceModule == "") {
+			var err error
+			foreign, entry.Dependency.Source, err = graph.modules.bindPackage(pkg)
+			if err != nil {
+				return entry, err
+			}
+			root, entry.SourceRootID = foreign.root, foreign.source.ID()
+			metadata := module.GoMod
+			if module.Replace != nil {
+				metadata = module.Replace.GoMod
+			}
+			if err := graph.retain(metadata); err != nil {
+				return entry, err
+			}
+			graph.recordModuleMetadataPath(foreign.source.ID(), metadata)
+		} else {
+			root = module.Dir
+			source := &entry.Dependency.Source
+			source.ModulePath, source.Version, source.SourceModule, source.SourceVersion, source.SourceRole = module.Path, module.Version, module.Path, module.Version, "module"
+			if module.Main {
+				source.SourceRole = "main"
+			}
+			if module.Replace != nil {
+				replacement := module.Replace
+				if replacement.Path != input.Original.SourceModule || replacement.Version != input.Original.Version || replacement.Replace != nil || replacement.Main || replacement.Version == "" {
+					return entry, fmt.Errorf("original type graph has an unknown/local replacement")
+				}
+				root = replacement.Dir
+				source.SourceModule, source.SourceVersion, source.SourceRole = replacement.Path, replacement.Version, "version_replace"
+			} else if input.Original.SourceModule != "" && input.Original.SourceModule != module.Path {
+				return entry, fmt.Errorf("original type graph lost its exact archive namespace replacement")
+			}
+			resolved, err := sourcepath.Resolve(root)
+			original, originalErr := sourcepath.Resolve(input.Original.SourceRoot)
+			if err != nil || originalErr != nil || resolved != original {
+				return entry, fmt.Errorf("actual imported module root differs from the authenticated original source")
+			}
+			metadata := module.GoMod
+			if module.Replace != nil {
+				metadata = module.Replace.GoMod
+			}
+			if err := graph.retainModuleMetadata(input.Original, entry.Dependency.Source, metadata, resolved); err != nil {
+				return entry, err
+			}
+			graph.recordModuleMetadataPath("original", metadata)
+		}
+	}
+	root, err := sourcepath.Resolve(root)
+	if err != nil {
+		return entry, err
+	}
+	directory, err := sourcepath.Resolve(pkg.Dir)
+	packageDirectory := strings.TrimPrefix(strings.TrimPrefix(pkg.ImportPath, entry.Dependency.Source.ModulePath), "/")
+	if packageDirectory == "" {
+		packageDirectory = "."
+	}
+	if err != nil || directory != filepath.Join(root, filepath.FromSlash(packageDirectory)) || len(pkg.CompiledGoFiles) == 0 {
+		return entry, fmt.Errorf("actual imported package is not in its stock SDK or exact original module root")
+	}
+	if len(pkg.GoFiles) > 32768 || len(pkg.CompiledGoFiles) > 32768 {
+		return entry, fmt.Errorf("original type graph has an unregistered generated compiler source")
+	}
+	goFiles := instrumentationTypeNames(pkg.GoFiles, directory, root)
+	compiledGoFiles := instrumentationTypeNames(pkg.CompiledGoFiles, directory, root)
+	if goFiles == nil || compiledGoFiles == nil || !reflect.DeepEqual(goFiles, compiledGoFiles) {
+		return entry, fmt.Errorf("original type graph has an unregistered generated compiler source")
+	}
+	if foreign != nil {
+		entry.SFiles = instrumentationTypeNames(pkg.SFiles, directory, root)
+		if entry.SFiles == nil {
+			return entry, fmt.Errorf("foreign assembly lost its actual original source selection")
+		}
+		for _, file := range entry.SFiles {
+			if foreign.source.Sources[file] == "" {
+				return entry, fmt.Errorf("foreign assembly is absent from its original ZIP source inventory")
+			}
+			if err := graph.retain(filepath.Join(root, filepath.FromSlash(file))); err != nil {
+				return entry, err
+			}
+			if graph.hashes[filepath.Join(root, filepath.FromSlash(file))] != foreign.source.Sources[file] {
+				return entry, fmt.Errorf("foreign selected assembly bytes changed")
+			}
+		}
+	}
+	for _, name := range pkg.CompiledGoFiles {
+		if !filepath.IsAbs(name) {
+			name = filepath.Join(directory, name)
+		}
+		if err := graph.retain(name); err != nil {
+			return entry, err
+		}
+		rel, err := filepath.Rel(root, graph.paths[name])
+		if err != nil || !filepath.IsLocal(rel) || filepath.Dir(rel) != filepath.FromSlash(packageDirectory) {
+			return entry, fmt.Errorf("original imported Go bytes have an unbound source role")
+		}
+		key := filepath.ToSlash(rel)
+		if foreign != nil && foreign.source.Sources[key] != graph.hashes[name] {
+			return entry, fmt.Errorf("foreign Go bytes differ from their independent original ZIP inventory")
+		}
+		if pkg.Module != nil && foreign == nil && input.Original.Sources[key] != graph.hashes[name] {
+			return entry, fmt.Errorf("imported same-module Go bytes differ from the original ZIP inventory")
+		}
+		info, err := os.Stat(name)
+		if err != nil || info.Size() > instrumentationOriginalFileLimit {
+			return entry, fmt.Errorf("original imported compiler source exceeds its byte bound")
+		}
+		if graph.files[pkg.ImportPath] == nil {
+			graph.files[pkg.ImportPath] = make(map[string]string)
+		}
+		graph.files[pkg.ImportPath][key], entry.Dependency.Source.GoSHA256[key] = name, graph.hashes[name]
+	}
+	for _, path := range pkg.Imports {
+		entry.Dependency.ImportMap[path] = path
+	}
+	for spelling, target := range pkg.ImportMap {
+		if spelling != target {
+			delete(entry.Dependency.ImportMap, target)
+		}
+		entry.Dependency.ImportMap[spelling] = target
+	}
+	if export {
+		if err := graph.retain(pkg.Export); err != nil {
+			return entry, fmt.Errorf("original imported package lacks its actual export: %v", err)
+		}
+		cache, err := sourcepath.Resolve(actual["GOCACHE"])
+		rel, relErr := filepath.Rel(cache, graph.paths[pkg.Export])
+		if err != nil || relErr != nil || !filepath.IsLocal(rel) {
+			return entry, fmt.Errorf("original imported export is outside the actual Go build cache")
+		}
+		entry.Dependency.Source.ExportSHA256 = graph.hashes[pkg.Export]
+	}
+	return entry, nil
+}
+
+// Metadata outside a legacy archive has a separate signed origin. It never
+// becomes a ZIP member or authorizes a namespace alias. Retain both actual Go's
+// path and the exact download path so every graph/post-export guard checks them.
+func (graph *instrumentationTypeGraph) retainModuleMetadata(input *ConsumerInput, source ImportExport, metadata, root string) error {
+	expected := input.Sources["go.mod"]
+	if proof := input.ProxyGoMod; proof != nil {
+		observed := PackageProof{
+			ModulePath: source.ModulePath, ModuleVersion: source.Version,
+			SourceModule: source.SourceModule, SourceVersion: source.SourceVersion, SourceRole: source.SourceRole,
+			GoModOrigin: proof.Protocol, GoModSHA256: proof.SHA256, GoModSum: proof.GoModSum,
+		}
+		if err := ValidatePackageModule(input, observed); err != nil {
+			return fmt.Errorf("original type graph has an unauthenticated legacy metadata origin: %w", err)
+		}
+		if _, present := input.Sources["go.mod"]; present || containsString(input.Directories["."], "go.mod") {
+			return fmt.Errorf("legacy type metadata cannot impersonate an original ZIP member")
+		}
+		for _, filename := range []string{metadata, input.ProxyGoModPath} {
+			info, err := os.Lstat(filename)
+			if err != nil || !filepath.IsAbs(filename) || !info.Mode().IsRegular() {
+				return fmt.Errorf("original type proxy metadata lacks a regular absolute observed path")
+			}
+			if err := graph.retain(filename); err != nil {
+				return fmt.Errorf("original type proxy metadata path changed: %w", err)
+			}
+		}
+		if graph.paths[metadata] != graph.paths[input.ProxyGoModPath] {
+			return fmt.Errorf("original type proxy metadata differs from its exact download path")
+		}
+		relative, err := filepath.Rel(root, graph.paths[metadata])
+		if err != nil || relative == "." || filepath.IsLocal(relative) {
+			return fmt.Errorf("original type proxy metadata must remain outside the original ZIP root")
+		}
+		expected = proof.SHA256
+	}
+	if err := graph.retain(metadata); err != nil || expected == "" || graph.hashes[metadata] != expected {
+		return fmt.Errorf("original type graph module metadata differs from its authenticated origin: %v", err)
+	}
+	return nil
+}
+
+func (graph *instrumentationTypeGraph) retain(name string) error {
+	if !filepath.IsAbs(name) || strings.ContainsAny(name, "\x00\r\n") {
+		return fmt.Errorf("actual original source/export has no absolute path")
+	}
+	resolved, err := sourcepath.Resolve(name)
+	if err != nil {
+		return err
+	}
+	info, err := os.Stat(resolved)
+	if err != nil || !info.Mode().IsRegular() {
+		return fmt.Errorf("actual original source/export is not a regular file")
+	}
+	digest, err := FileSHA256(resolved)
+	if err != nil {
+		return err
+	}
+	if prior := graph.hashes[name]; prior != "" && (prior != digest || graph.paths[name] != resolved) {
+		return fmt.Errorf("actual original source/export changed during graph capture")
+	}
+	graph.hashes[name], graph.paths[name] = digest, resolved
+	return nil
+}
+
+func retainInstrumentationRequiredTypeSources(input *InstrumentationConsumerInput, proof *InstrumentationTypeSourceProof, captured *instrumentationTypeGraph) error {
+	for _, module := range proof.SourceModules {
+		for _, header := range module.Headers {
+			captured.bytes += len(header)
+		}
+	}
+	copy := *input
+	copy.TypeSources = proof
+	set := token.NewFileSet()
+	root := &instrumentationDeclarationReplay{functions: make(map[string]*ast.FuncDecl), types: make(map[string]*ast.TypeSpec),
+		constants: make(map[string]*ast.GenDecl), other: make(map[string]bool), needed: make(map[ast.Node]bool)}
+	for _, name := range input.Plan.GoFiles {
+		file, err := parser.ParseFile(set, name, input.Sources.Contents[name], 0)
+		if err != nil {
+			return err
+		}
+		root.files = append(root.files, file)
+		if err := root.index(file); err != nil {
+			return err
+		}
+	}
+	graph, err := newInstrumentationTypeReplay(&copy, set, root)
+	if err != nil {
+		return err
+	}
+	graph.load = func(pkg *InstrumentationTypeSourcePackage) error {
+		files := captured.files[pkg.Dependency.Source.PackagePath]
+		if len(files) != len(pkg.Dependency.Source.GoSHA256) {
+			return fmt.Errorf("actual original type package lost its complete compiler source paths")
+		}
+		pkg.Contents = make(map[string]string)
+		for name, file := range files {
+			data, err := os.ReadFile(file)
+			captured.bytes += len(data)
+			if err != nil || len(data) > instrumentationOriginalFileLimit || captured.bytes > instrumentationOriginalInventoryLimit ||
+				bytesSHA256(data) != pkg.Dependency.Source.GoSHA256[name] {
+				return fmt.Errorf("original required imported type bytes changed or exceed their resource bound")
+			}
+			pkg.Contents[name] = string(data)
+		}
+		return nil
+	}
+	for _, function := range root.functions {
+		if function.Body == nil && function.Recv == nil {
+			if err := root.requireType(function.Type); err != nil {
+				return err
+			}
+		}
+	}
+	for index := range proof.Dependencies {
+		if graph.replays[proof.Dependencies[index].Dependency.Source.PackagePath] == nil {
+			proof.Dependencies[index].Contents = nil
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_type_capture_go127_test.go b/gotoolprofile/instrumentation_type_capture_go127_test.go
new file mode 100644
index 000000000..64da8a911
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_capture_go127_test.go
@@ -0,0 +1,136 @@
+//go:build go1.27
+
+package gotoolprofile
+
+// Actual mode export is a current-Go source role. Historical framework lanes
+// run the complete portable source/layout tests, not an invented old-mode
+// compiler observation; CaptureInstrumentationExportObservation rejects it.
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestInstrumentationTypeSourceCaptureActualGoAndOriginMutation(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := instrumentationOriginalFixture(t, marker.Early)
+	for name, source := range map[string]string{
+		"base.go":     "package markers\nimport (renamed \"syscall\"; \"math/bits\")\nfunc marker(value [bits.UintSize / 8]byte) renamed.Errno\n",
+		"mode_race.s": "//go:build race\n\n#include \"textflag.h\"\nTEXT ·marker(SB), NOSPLIT, $0-16\nRET\n",
+	} {
+		if err := os.WriteFile(filepath.Join(original.SourceRoot, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		original.Sources[name], original.Headers[name] = bytesSHA256([]byte(source)), source
+	}
+	inventory, err := CaptureInstrumentationOriginalSourceInventory(original, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(original, inventory, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, err := NewInstrumentationConsumerInput(original, inventory, marker, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := instrumentationFixtureEnvironment(os.Environ(), marker.Early)
+	proof, err := CaptureInstrumentationTypeSources(ctx, binary, original.SourceRoot, env, input, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(proof.Dependencies) == 0 || proof.RootImportMap["syscall"] != "syscall" || proof.RootImportMap["math/bits"] != "math/bits" {
+		t.Fatal("original actual import graph was not preserved")
+	}
+	retained := make(map[string]bool)
+	for _, pkg := range proof.Dependencies {
+		if pkg.Contents != nil {
+			retained[pkg.Dependency.Source.PackagePath] = true
+		}
+	}
+	if !reflect.DeepEqual(retained, map[string]bool{"syscall": true, "math/bits": true}) {
+		t.Fatalf("source capture retained unrelated ASTs or omitted required original source: %v", retained)
+	}
+	input.TypeSources = proof
+	for name, change := range map[string]func(*instrumentationTypeListPackage){
+		"SDK root": func(p *instrumentationTypeListPackage) { p.Dir = original.SourceRoot },
+		"foreign module": func(p *instrumentationTypeListPackage) {
+			p.Module = &instrumentationTypeListModule{Path: "example.invalid/foreign", Version: "v1.0.0", Dir: original.SourceRoot}
+		},
+		"local replacement": func(p *instrumentationTypeListPackage) {
+			p.Module.Replace = &instrumentationTypeListModule{Path: original.SourceRoot, Dir: original.SourceRoot}
+		},
+		"module version":          func(p *instrumentationTypeListPackage) { p.Module.Version = "v1.0.0" },
+		"import map":              func(p *instrumentationTypeListPackage) { p.ImportMap = map[string]string{"syscall": "math/bits"} },
+		"missing selected source": func(p *instrumentationTypeListPackage) { p.CompiledGoFiles = p.CompiledGoFiles[1:] },
+		"missing export":          func(p *instrumentationTypeListPackage) { p.Export = "" },
+		"test role":               func(p *instrumentationTypeListPackage) { p.ForTest = plan.PackagePath },
+		"embed role":              func(p *instrumentationTypeListPackage) { p.EmbedFiles = []string{"unbound.bin"} },
+		"Cgo role":                func(p *instrumentationTypeListPackage) { p.CgoFiles = []string{"unbound.go"} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := false
+			run := func(ctx context.Context, dir string, env []string, command string, args ...string) ([]byte, []byte, error) {
+				stdout, stderr, err := RunBounded(ctx, dir, env, command, args...)
+				if err != nil || len(args) == 0 || args[0] != "list" || !containsString(args, "-export") {
+					return stdout, stderr, err
+				}
+				decoder := json.NewDecoder(bytes.NewReader(stdout))
+				var output bytes.Buffer
+				for {
+					var pkg instrumentationTypeListPackage
+					if err := decoder.Decode(&pkg); err == io.EOF {
+						break
+					} else if err != nil {
+						return nil, nil, err
+					}
+					target := plan.PackagePath
+					if name == "SDK root" || name == "foreign module" {
+						target = "syscall"
+					}
+					if pkg.ImportPath == target {
+						change(&pkg)
+						changed = true
+					}
+					if err := json.NewEncoder(&output).Encode(pkg); err != nil {
+						return nil, nil, err
+					}
+				}
+				return output.Bytes(), stderr, nil
+			}
+			if _, err := CaptureInstrumentationTypeSources(ctx, binary, original.SourceRoot, env, input, run); err == nil || !changed {
+				t.Fatalf("changed actual source/origin/export/selection was accepted or fixture was not consumed: %v", err)
+			}
+		})
+	}
+	t.Run("actual source bytes", func(t *testing.T) {
+		file := filepath.Join(original.SourceRoot, "base.go")
+		if err := os.WriteFile(file, []byte(inventory.Contents["base.go"]+"\nconst Changed=1\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := CaptureInstrumentationTypeSources(ctx, binary, original.SourceRoot, env, input, RunBounded); err == nil || !strings.Contains(err.Error(), "source") {
+			t.Fatalf("changed original source bytes acquired an imported type closure: %v", err)
+		}
+	})
+	t.Log(fmt.Sprintf("actual stock-Go SDK source/alias/constant capture and %d origin/role/map/export negatives; no LLVM or runtime claim", 11))
+}
diff --git a/gotoolprofile/instrumentation_type_foreign_capture_go127_test.go b/gotoolprofile/instrumentation_type_foreign_capture_go127_test.go
new file mode 100644
index 000000000..d5130d078
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_foreign_capture_go127_test.go
@@ -0,0 +1,386 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+)
+
+// This proxy is a first-party mechanics fixture, NOT official SumDB source
+// authentication. Production capture must still use authenticated downloads.
+func instrumentationForeignFixtureProxy(t *testing.T, root, module, version, declaration string) {
+	t.Helper()
+	files := map[string]string{
+		"go.mod":          "module example.invalid/layoutdep\n\ngo 1.20\n",
+		"model/layout.go": declaration,
+	}
+	var buffer bytes.Buffer
+	writer := zip.NewWriter(&buffer)
+	names := make([]string, 0, len(files))
+	for name := range files {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		entry, err := writer.Create(module + "@" + version + "/" + name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := io.WriteString(entry, files[name]); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(root, filepath.FromSlash(module), "@v")
+	for suffix, contents := range map[string][]byte{
+		".mod":  []byte(files["go.mod"]),
+		".info": []byte(fmt.Sprintf("{\"Version\":%q,\"Time\":\"2026-01-01T00:00:00Z\"}\n", version)),
+		".zip":  buffer.Bytes(),
+	} {
+		writeInstrumentationFixture(t, directory, version+suffix, contents)
+	}
+}
+
+func instrumentationForeignFixtureResource(t *testing.T, data []byte) TestModuleSource {
+	t.Helper()
+	var download struct{ Path, Version, Dir, Zip, Sum, GoModSum string }
+	if err := json.Unmarshal(data, &download); err != nil {
+		t.Fatal(err)
+	}
+	resource := TestModuleSource{Protocol: TestDependencyModuleProtocol, SourceModule: download.Path, SourceVersion: download.Version,
+		ModuleSum: download.Sum, GoModSum: download.GoModSum, GoModOrigin: TestModuleOriginalGoModOrigin,
+		Sources: make(map[string]string), Headers: make(map[string]string), Directories: make(map[string][]TestSourceEntry)}
+	for _, directory := range []string{".", "model"} {
+		entries, err := os.ReadDir(filepath.Join(download.Dir, directory))
+		if err != nil {
+			t.Fatal(err)
+		}
+		resource.Directories[directory] = []TestSourceEntry{}
+		for _, entry := range entries {
+			member := TestSourceEntry{Name: entry.Name(), Kind: "directory"}
+			if !entry.IsDir() {
+				member.Kind = "file"
+				name := filepath.ToSlash(filepath.Join(directory, entry.Name()))
+				contents, err := os.ReadFile(filepath.Join(download.Dir, filepath.FromSlash(name)))
+				if err != nil {
+					t.Fatal(err)
+				}
+				member.SHA256 = bytesSHA256(contents)
+				resource.Sources[name] = member.SHA256
+				if strings.HasSuffix(name, ".go") || strings.HasSuffix(name, ".s") {
+					resource.Headers[name], err = TestSelectionHeader(name, contents)
+					if err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			resource.Directories[directory] = append(resource.Directories[directory], member)
+		}
+	}
+	resource.GoModSHA256 = resource.Sources["go.mod"]
+	var err error
+	resource.ZipSHA256, err = FileSHA256(download.Zip)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return resource
+}
+
+func TestInstrumentationForeignTypeSourceActualDualModule(t *testing.T) {
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	for _, fixture := range []struct {
+		name               string
+		replaced, bodyOnly bool
+		blankUnsafeImport  bool
+	}{
+		{name: "version_replacement_false"},
+		{name: "version_replacement_true", replaced: true},
+		{name: "ordinary_body_only", bodyOnly: true},
+		{name: "ordinary_body_blank_import", bodyOnly: true, blankUnsafeImport: true},
+	} {
+		replaced := fixture.replaced
+		t.Run(fixture.name, func(t *testing.T) {
+			proxy := instrumentationMarkerDirectory(t)
+			cache := instrumentationMarkerDirectory(t)
+			t.Cleanup(func() {
+				// Go intentionally extracts this owned fixture read-only. Restore
+				// only its directory modes before testing removes the private tree.
+				if err := filepath.Walk(cache, func(name string, info os.FileInfo, err error) error {
+					if err == nil && info.IsDir() {
+						return os.Chmod(name, 0700)
+					}
+					return err
+				}); err != nil {
+					t.Error(err)
+				}
+			})
+			archive := "example.invalid/layoutdep"
+			mod := "module " + instrumentationExportModule + "\n\ngo 1.20\nrequire example.invalid/layoutdep v1.0.0\n"
+			if replaced {
+				archive = "example.invalid/layout-archive"
+				mod += "replace example.invalid/layoutdep v1.0.0 => " + archive + " v1.0.0\n"
+			}
+			foreignSource := "package model\n"
+			if fixture.blankUnsafeImport {
+				foreignSource += "import _ \"unsafe\"\n"
+			}
+			foreignSource += "const Words=2\ntype Header struct { Lo uint32; Pad [Words]byte; Hi uint16 }\n"
+			instrumentationForeignFixtureProxy(t, proxy, archive, "v1.0.0", foreignSource)
+			proxyURL, err := gooriginalsrc.FileProxyURL(proxy)
+			if err != nil {
+				t.Fatal(err)
+			}
+			env := replaceEnv(os.Environ(), map[string]string{
+				"GOPROXY": proxyURL, "GOSUMDB": "off", "GONOSUMDB": "", "GOPRIVATE": "",
+				"GOMODCACHE": cache, "GOPATH": instrumentationMarkerDirectory(t),
+			})
+			marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), env,
+				"darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			original := instrumentationOriginalFixture(t, marker.Early)
+			rootSource := "package markers\nimport shape \"example.invalid/layoutdep/model\"\nfunc marker(value shape.Header) uint64\n"
+			if fixture.bodyOnly {
+				rootSource = "package markers\nimport shape \"example.invalid/layoutdep/model\"\nfunc marker(value uint64) uint64\nfunc ordinary() shape.Header { return shape.Header{} }\n"
+			}
+			for name, source := range map[string]string{
+				"go.mod":      mod,
+				"base.go":     rootSource,
+				"mode_race.s": "//go:build race\n\n#include \"textflag.h\"\nTEXT ·marker(SB),NOSPLIT,$0-16\nMOVD $0,R0\nMOVD R0,ret+8(FP)\nRET\n",
+			} {
+				writeInstrumentationFixture(t, original.SourceRoot, name, []byte(source))
+				original.Sources[name], original.Headers[name] = bytesSHA256([]byte(source)), source
+			}
+			env = instrumentationFixtureEnvironment(env, marker.Early)
+			download, downloadStderr, downloadErr := RunBounded(ctx, original.SourceRoot, env, binary,
+				"mod", "download", "-json", archive+"@v1.0.0")
+			if downloadErr != nil {
+				t.Fatalf("first-party fixture download: %v; %s", downloadErr, downloadStderr)
+			}
+			t.Logf("actual first-party download (not official authentication): %s; stderr=%q", download, downloadStderr)
+			// Keep raw stock-Go records before capture fails. These are actual
+			// Module/Replace/ImportMap records, not reconstructed expected roots.
+			args := []string{"list", "-mod=mod", "-deps", "-compiled", "-export", "-json", "-race", original.Module}
+			stdout, stderr, commandErr := RunBounded(ctx, original.SourceRoot, env, binary, args...)
+			if commandErr != nil || len(stderr) != 0 {
+				t.Fatalf("actual dual-module graph setup: %v; %s", commandErr, stderr)
+			}
+			// Freeze actual invocation metadata only after stock Go has written
+			// its first-party checksums. Capture may not mutate the inventory.
+			sum, err := os.ReadFile(filepath.Join(original.SourceRoot, "go.sum"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			original.Sources["go.sum"], original.Headers["go.sum"] = bytesSHA256(sum), string(sum)
+			original.Directories["."] = append(original.Directories["."], "go.sum")
+			sort.Strings(original.Directories["."])
+			inventory, err := CaptureInstrumentationOriginalSourceInventory(original, ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			plan, err := PlanInstrumentationOriginalPackage(original, inventory, marker.Early, ".", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input, err := NewInstrumentationConsumerInput(original, inventory, marker, plan)
+			if err != nil {
+				t.Fatal(err)
+			}
+			decoder := json.NewDecoder(bytes.NewReader(stdout))
+			found := false
+			for {
+				var pkg instrumentationTypeListPackage
+				if err := decoder.Decode(&pkg); err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				if pkg.ImportPath == plan.PackagePath {
+					record, err := json.Marshal(pkg)
+					if err != nil {
+						t.Fatal(err)
+					}
+					t.Logf("actual root package: %s", record)
+				}
+				if pkg.ImportPath == "example.invalid/layoutdep/model" {
+					found = true
+					if pkg.Module == nil || pkg.Module.Path != "example.invalid/layoutdep" || pkg.Module.Version != "v1.0.0" ||
+						(pkg.Module.Replace != nil) != replaced || pkg.Export == "" {
+						t.Fatalf("actual dependency identity lost: %+v", pkg)
+					}
+					record, err := json.Marshal(pkg)
+					if err != nil {
+						t.Fatal(err)
+					}
+					t.Logf("actual foreign package: %s", record)
+				}
+			}
+			if !found {
+				t.Fatal("stock Go omitted the foreign package")
+			}
+			t.Logf("actual tool=%s sha256=%s graph_sha256=%s argv=%q; first-party file proxy is not a SumDB certificate",
+				binary, marker.Early.BaselineFeatures.DriverSHA256, bytesSHA256(stdout), args)
+			resource := instrumentationForeignFixtureResource(t, download)
+			proof, err := CaptureInstrumentationTypeSourcesWithModules(ctx, binary, original.SourceRoot, env, input, []TestModuleSource{resource}, RunBounded)
+			if err != nil {
+				if !strings.Contains(err.Error(), "authenticated foreign module source closure") {
+					t.Fatalf("unexpected actual graph failure: %v", err)
+				}
+				t.Fatalf("actual dual-module source role remains unavailable: %v", err)
+			}
+			if proof == nil {
+				t.Fatal("capture returned no independent source proof")
+			}
+			if len(proof.SourceModules) != 1 || len(proof.Dependencies) != 1 || proof.Dependencies[0].SourceRootID != archive+"@v1.0.0" {
+				t.Fatal("v2 capture omitted the exact source-only foreign resource")
+			}
+			input.TypeSources = proof
+			encoded, err := json.Marshal(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if fixture.bodyOnly {
+				if proof.Dependencies[0].Contents != nil {
+					t.Fatal("ordinary body import unexpectedly obtained a declaration-AST role")
+				}
+				if err := ValidateInstrumentationTypeSources(input, proof); err != nil {
+					t.Fatalf("actual body-only original graph failed portable replay: %v", err)
+				}
+				mutations := map[string]func(*InstrumentationConsumerInput){}
+				if fixture.blankUnsafeImport {
+					mutations["deleted actual blank import"] = func(p *InstrumentationConsumerInput) {
+						p.TypeSources.Dependencies[0].Dependency.ImportMap = map[string]string{}
+						p.TypeSources.UnsafeSHA256 = ""
+					}
+					mutations["redirected actual blank spelling"] = func(p *InstrumentationConsumerInput) {
+						p.TypeSources.Dependencies[0].Dependency.ImportMap = map[string]string{"example.invalid/not-in-original": "unsafe"}
+					}
+				} else {
+					root, stderr, err := RunBounded(ctx, original.SourceRoot, env, binary, "env", "GOROOT")
+					if err != nil || len(stderr) != 0 {
+						t.Fatalf("actual SDK unsafe-source origin: %v; %s", err, stderr)
+					}
+					unsafeSHA, err := FileSHA256(filepath.Join(strings.TrimSpace(string(root)), "src", "unsafe", "unsafe.go"))
+					if err != nil {
+						t.Fatal(err)
+					}
+					mutations["invented unsafe import"] = func(p *InstrumentationConsumerInput) {
+						p.TypeSources.Dependencies[0].Dependency.ImportMap["unsafe"] = "unsafe"
+						p.TypeSources.UnsafeSHA256 = unsafeSHA
+					}
+				}
+				for name, mutate := range mutations {
+					t.Run(name, func(t *testing.T) {
+						var changed InstrumentationConsumerInput
+						if err := json.Unmarshal(encoded, &changed); err != nil {
+							t.Fatal(err)
+						}
+						mutate(&changed)
+						// Only the claimed topology changes; actual Go selection,
+						// source/header/ZIP bytes and export/tool receipts stay fixed.
+						if err := ValidateInstrumentationTypeSources(&changed, changed.TypeSources); err == nil {
+							t.Fatal("portable reader accepted changed ImportMap without declaration Contents")
+						}
+					})
+				}
+				return
+			}
+			for name, mutate := range map[string]func(*InstrumentationConsumerInput){
+				"inventory deleted": func(p *InstrumentationConsumerInput) { p.TypeSources.SourceModules = nil },
+				"inventory emptied": func(p *InstrumentationConsumerInput) { p.TypeSources.SourceModules = []TestModuleSource{} },
+				"v1 downgrade": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.Protocol = "actual_go_instrumentation_type_sources_v1"
+				},
+				"resource identity":      func(p *InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].SourceRootID += "-changed" },
+				"foreign source version": func(p *InstrumentationConsumerInput) { p.TypeSources.SourceModules[0].SourceVersion = "v1.0.1" },
+				"Go source removed": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.Dependencies[0].Dependency.Source.GoSHA256 = map[string]string{}
+				},
+				"assembly added": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.Dependencies[0].SFiles = []string{"model/unbound.s"}
+				},
+				"directory truncated": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.SourceModules[0].Directories["model"] = []TestSourceEntry{}
+				},
+				"header deleted": func(p *InstrumentationConsumerInput) {
+					delete(p.TypeSources.SourceModules[0].Headers, "model/layout.go")
+				},
+				"ZIP hash": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.SourceModules[0].ZipSHA256 = strings.Repeat("0", 64)
+				},
+				"module h1": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.SourceModules[0].ModuleSum = "h1:" + strings.Repeat("A", 43) + "="
+				},
+				"metadata h1": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.SourceModules[0].GoModSum = "h1:" + strings.Repeat("A", 43) + "="
+				},
+				"ordinary role": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.Dependencies[0].Dependency.Source.SourceRole = "main"
+				},
+				"actual export": func(p *InstrumentationConsumerInput) {
+					p.TypeSources.Dependencies[0].Dependency.Source.ExportSHA256 = strings.Repeat("0", 64)
+				},
+			} {
+				t.Run(name, func(t *testing.T) {
+					var changed InstrumentationConsumerInput
+					if err := json.Unmarshal(encoded, &changed); err != nil {
+						t.Fatal(err)
+					}
+					mutate(&changed)
+					actual, err := CaptureInstrumentationTypeSources(ctx, binary, original.SourceRoot, env, &changed, RunBounded)
+					if err == nil && reflect.DeepEqual(actual, changed.TypeSources) {
+						t.Fatal("changed foreign resources acquired an independent actual consumer proof")
+					}
+				})
+			}
+			guard, err := BindInstrumentationTypeModuleSources(ctx, binary, original.SourceRoot, env, proof.SourceModules, RunBounded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var downloaded struct{ Dir string }
+			if err := json.Unmarshal(download, &downloaded); err != nil {
+				t.Fatal(err)
+			}
+			foreignFile := filepath.Join(downloaded.Dir, "model", "layout.go")
+			originalBytes, err := os.ReadFile(foreignFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chmod(foreignFile, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(foreignFile, append(originalBytes, []byte("\n// actual post-load mutation\n")...), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := guard.Verify(ctx); err == nil {
+				t.Fatal("live final foreign source guard ignored actual original byte mutation")
+			}
+			if err := os.WriteFile(foreignFile, originalBytes, 0600); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_type_import_map_test.go b/gotoolprofile/instrumentation_type_import_map_test.go
new file mode 100644
index 000000000..183a8a3e8
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_import_map_test.go
@@ -0,0 +1,86 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestInstrumentationOriginalTypeImportMapCannotInventUnusedSourceEdges(t *testing.T) {
+	input, _, _ := instrumentationImportedReplayFixture(t, "arm64")
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*InstrumentationConsumerInput){
+		"extra root spelling": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.RootImportMap["forged/unselected"] = "example.invalid/replay/dep"
+		},
+		"absolute root spelling": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.RootImportMap["/private/forged/import"] = "example.invalid/replay/dep"
+		},
+		"extra dependency self edge": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.ImportMap["example.invalid/replay/dep"] = "example.invalid/replay/dep"
+		},
+		"same graph root spelling replacement": func(p *InstrumentationConsumerInput) {
+			delete(p.TypeSources.RootImportMap, "example.invalid/replay/dep")
+			p.TypeSources.RootImportMap["forged/replacement"] = "example.invalid/replay/dep"
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationConsumerInput
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			// The complete dependency graph and exports remain internally
+			// consistent. Only the independent original Go import bytes
+			// establish that these observed spellings were really selected.
+			if err := ValidateInstrumentationTypeSources(&changed, changed.TypeSources); err == nil {
+				t.Fatal("original type source accepted an unused/replaced import spelling")
+			}
+		})
+	}
+}
+
+func TestInstrumentationOriginalTypeImportMapUsesAllSelectedFileImports(t *testing.T) {
+	input, pkg, declaration := instrumentationImportedReplayFixture(t, "arm64")
+	// These imports are not needed by Probe's type, but still belong to the
+	// actual selected source graph. Aliases, blank imports and duplicated
+	// spellings across different files must not shrink that graph.
+	const extra = `package replay
+import (
+	_ "example.invalid/replay/dep"
+	different "example.invalid/replay/dep"
+)
+var _ = different.Count
+`
+	input.Plan.GoFiles = append(input.Plan.GoFiles, "extra.go")
+	input.Sources.Contents["extra.go"] = extra
+	input.Original.Sources["extra.go"] = bytesSHA256([]byte(extra))
+	input.TypeSources.InputSHA256 = instrumentationTypeSourceInputSHA(input)
+	if err := ValidateInstrumentationTypeSources(input, input.TypeSources); err != nil {
+		t.Fatal(err)
+	}
+	if err := replayInstrumentationDeclarationLayouts(input, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+		t.Fatal(err)
+	}
+	for _, missing := range []string{"extra.go", "replay.go"} {
+		t.Run("missing original "+missing, func(t *testing.T) {
+			copy := *input
+			sources := *input.Sources
+			copy.Sources = &sources
+			sources.Contents = make(map[string]string)
+			for name, contents := range input.Sources.Contents {
+				if name != missing {
+					sources.Contents[name] = contents
+				}
+			}
+			proof := *input.TypeSources
+			copy.TypeSources = &proof
+			proof.InputSHA256 = instrumentationTypeSourceInputSHA(&copy)
+			if err := ValidateInstrumentationTypeSources(&copy, &proof); err == nil {
+				t.Fatal("missing selected original source could authorize the same import map")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_type_legacy_metadata_test.go b/gotoolprofile/instrumentation_type_legacy_metadata_test.go
new file mode 100644
index 000000000..9be40488e
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_legacy_metadata_test.go
@@ -0,0 +1,178 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The source below is a controlled first-party fixture. Only its metadata
+// identity uses an existing independently signed public checksum record; this
+// test does not authenticate, translate or execute that external module.
+func instrumentationTypeLegacyMetadataFixture(t *testing.T) (*InstrumentationConsumerInput, instrumentationTypeListPackage, string) {
+	t.Helper()
+	metadata := fixtureProxyGoMod(t)
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const source = "package legacy\nvar Value byte\n"
+	if err := os.WriteFile(filepath.Join(root, "legacy.go"), []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	metadataDirectory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	filename := filepath.Join(metadataDirectory, "download.mod")
+	if err := os.WriteFile(filename, []byte(metadata.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	original := &ConsumerInput{
+		Module: metadata.Module, Version: metadata.Version, SourceModule: metadata.Module,
+		SourceRoot: root, Sources: map[string]string{"legacy.go": bytesSHA256([]byte(source))},
+		Directories: map[string][]string{".": {"legacy.go"}},
+		ProxyGoMod:  metadata, ProxyGoModPath: filename,
+	}
+	pkg := instrumentationTypeListPackage{
+		Dir: root, ImportPath: metadata.Module, Name: "legacy",
+		GoFiles: []string{"legacy.go"}, CompiledGoFiles: []string{"legacy.go"},
+		Module: &instrumentationTypeListModule{
+			Path: metadata.Module, Version: metadata.Version, Dir: root, GoMod: filename,
+		},
+	}
+	return &InstrumentationConsumerInput{Original: original}, pkg, filename
+}
+
+func instrumentationTypeMetadataCapture(input *InstrumentationConsumerInput, pkg instrumentationTypeListPackage) (*instrumentationTypeGraph, error) {
+	graph := &instrumentationTypeGraph{
+		hashes: make(map[string]string), paths: make(map[string]string),
+		files: make(map[string]map[string]string),
+	}
+	_, err := captureInstrumentationTypePackage(input, nil, pkg, graph, false)
+	return graph, err
+}
+
+func TestInstrumentationTypeMetadataAcceptsAuthenticatedLegacyOrigin(t *testing.T) {
+	for _, replaced := range []bool{false, true} {
+		name := "module"
+		if replaced {
+			name = "exact_version_replacement"
+		}
+		t.Run(name, func(t *testing.T) {
+			input, pkg, metadata := instrumentationTypeLegacyMetadataFixture(t)
+			if replaced {
+				replacement := *pkg.Module
+				pkg.Module.Replace = &replacement
+			}
+			graph, err := instrumentationTypeMetadataCapture(input, pkg)
+			if err != nil {
+				t.Fatalf("signed legacy metadata is a distinct origin, not a missing ZIP member: %v", err)
+			}
+			if graph.hashes[metadata] != input.Original.ProxyGoMod.SHA256 || graph.paths[metadata] != metadata {
+				t.Fatal("capture omitted the actual metadata byte/path guard")
+			}
+			if _, invented := input.Original.Sources["go.mod"]; invented {
+				t.Fatal("proxy metadata was added to the original source inventory")
+			}
+		})
+	}
+}
+
+func TestInstrumentationTypeMetadataKeepsOriginalZIPOrigin(t *testing.T) {
+	input, pkg, _ := instrumentationTypeLegacyMetadataFixture(t)
+	metadata := filepath.Join(input.Original.SourceRoot, "go.mod")
+	contents := input.Original.ProxyGoMod.Contents
+	if err := os.WriteFile(metadata, []byte(contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	input.Original.ProxyGoMod, input.Original.ProxyGoModPath = nil, ""
+	input.Original.Sources["go.mod"] = bytesSHA256([]byte(contents))
+	input.Original.Directories["."] = []string{"go.mod", "legacy.go"}
+	pkg.Module.GoMod = metadata
+	graph, err := instrumentationTypeMetadataCapture(input, pkg)
+	if err != nil || graph.hashes[metadata] != input.Original.Sources["go.mod"] {
+		t.Fatalf("ordinary original metadata lost its unchanged byte guard: %v", err)
+	}
+}
+
+func TestInstrumentationTypeMetadataRejectsChangedOriginsAndPaths(t *testing.T) {
+	for name, mutate := range map[string]func(*testing.T, *InstrumentationConsumerInput, *instrumentationTypeListPackage){
+		"missing proof": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.ProxyGoMod = nil
+		},
+		"signed proof changed": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.ProxyGoMod.SignedTree += "changed"
+		},
+		"missing inclusion": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.ProxyGoMod.Inclusion = nil
+		},
+		"foreign version": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.ProxyGoMod.Version = "v1.0.0"
+		},
+		"missing original namespace": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.SourceModule = ""
+		},
+		"unproved ZIP member": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.Sources["go.mod"] = i.Original.ProxyGoMod.SHA256
+		},
+		"invented ZIP member": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.Directories["."] = []string{"go.mod", "legacy.go"}
+		},
+		"missing download path": func(_ *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			i.Original.ProxyGoModPath = ""
+		},
+		"relative actual path": func(_ *testing.T, _ *InstrumentationConsumerInput, p *instrumentationTypeListPackage) {
+			p.Module.GoMod = "download.mod"
+		},
+		"different equal-byte metadata": func(t *testing.T, i *InstrumentationConsumerInput, p *instrumentationTypeListPackage) {
+			filename := filepath.Join(t.TempDir(), "copy.mod")
+			if err := os.WriteFile(filename, []byte(i.Original.ProxyGoMod.Contents), 0600); err != nil {
+				t.Fatal(err)
+			}
+			p.Module.GoMod = filename
+		},
+		"metadata inside ZIP root": func(t *testing.T, i *InstrumentationConsumerInput, p *instrumentationTypeListPackage) {
+			filename := filepath.Join(i.Original.SourceRoot, "go.mod")
+			if err := os.WriteFile(filename, []byte(i.Original.ProxyGoMod.Contents), 0600); err != nil {
+				t.Fatal(err)
+			}
+			i.Original.ProxyGoModPath, p.Module.GoMod = filename, filename
+		},
+		"metadata symlink": func(t *testing.T, i *InstrumentationConsumerInput, p *instrumentationTypeListPackage) {
+			filename := filepath.Join(t.TempDir(), "link.mod")
+			if err := os.Symlink(i.Original.ProxyGoModPath, filename); err != nil {
+				t.Fatal(err)
+			}
+			i.Original.ProxyGoModPath, p.Module.GoMod = filename, filename
+		},
+		"metadata bytes changed": func(t *testing.T, i *InstrumentationConsumerInput, _ *instrumentationTypeListPackage) {
+			if err := os.WriteFile(i.Original.ProxyGoModPath, []byte(i.Original.ProxyGoMod.Contents+"// changed\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			input, pkg, _ := instrumentationTypeLegacyMetadataFixture(t)
+			mutate(t, input, &pkg)
+			if _, err := instrumentationTypeMetadataCapture(input, pkg); err == nil {
+				t.Fatal("unbound legacy metadata acquired original imported-type authority")
+			}
+		})
+	}
+}
+
+func TestInstrumentationTypeMetadataCannotTrustPairedUnsignedBytes(t *testing.T) {
+	input, pkg, _ := instrumentationTypeLegacyMetadataFixture(t)
+	proof := input.Original.ProxyGoMod
+	proof.Contents += "// fabricated metadata\n"
+	proof.SHA256 = bytesSHA256([]byte(proof.Contents))
+	proof.SignedTree = strings.Replace(proof.SignedTree, "sum.golang.org", "untrusted.invalid", 1)
+	if err := os.WriteFile(input.Original.ProxyGoModPath, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := instrumentationTypeMetadataCapture(input, pkg); err == nil {
+		t.Fatal("paired proof/path/hash agreement replaced the signed original origin")
+	}
+}
diff --git a/gotoolprofile/instrumentation_type_modules.go b/gotoolprofile/instrumentation_type_modules.go
new file mode 100644
index 000000000..9bd0c880f
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_modules.go
@@ -0,0 +1,319 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+// These are source resources within the independent instrumentation v2 role.
+// Reusing the ZIP/directory verifier does not create a TestDependencyProof,
+// supplemental declaration, embed permission, or candidate assembly scope.
+type instrumentationTypeModuleBinding struct {
+	source                       TestModuleSource
+	root, archive, downloadedMod string
+	metadata                     map[string]string
+}
+
+type InstrumentationTypeModuleGuard struct {
+	bindings map[string]*instrumentationTypeModuleBinding
+}
+
+func validateInstrumentationTypeModuleResources(sources []TestModuleSource) error {
+	if sources == nil || len(sources) > 4096 {
+		return fmt.Errorf("instrumentation v2 requires its bounded explicit source-only module inventory")
+	}
+	entries, directories, headers, textBytes := 0, 0, 0, 0
+	for i, source := range sources {
+		if source.SourceModule == "" || i > 0 && sources[i-1].ID() >= source.ID() {
+			return fmt.Errorf("instrumentation foreign modules lack unique canonical exact identities")
+		}
+		if err := ValidateTestModuleSource(source); err != nil {
+			return fmt.Errorf("instrumentation source-only resource: %w", err)
+		}
+		directories += len(source.Directories)
+		headers += len(source.Headers)
+		for _, members := range source.Directories {
+			entries += len(members)
+		}
+		for _, contents := range source.Headers {
+			textBytes += len(contents)
+		}
+		if directories > 4096 || entries > 65536 || headers > 32768 || textBytes > instrumentationOriginalInventoryLimit {
+			return fmt.Errorf("instrumentation foreign source inventory exceeds its shared resource budget")
+		}
+	}
+	return nil
+}
+
+// BindInstrumentationTypeModuleSources obtains live paths only from the actual
+// bounded Go download. Recorded paths or matching export hashes cannot bind a
+// foreign source. The production producer separately authenticates the exact
+// download with the unchanged stock-Go/SumDB/ZIP/go.mod machinery.
+func BindInstrumentationTypeModuleSources(ctx context.Context, binary, directory string, env []string,
+	sources []TestModuleSource, run Runner,
+) (*InstrumentationTypeModuleGuard, error) {
+	if ctx == nil || ctx.Err() != nil || run == nil || !filepath.IsAbs(binary) || !filepath.IsAbs(directory) {
+		return nil, fmt.Errorf("instrumentation source modules require a live actual Go invocation")
+	}
+	if err := validateInstrumentationTypeModuleResources(sources); err != nil {
+		return nil, err
+	}
+	// A caller may not mutate the portable input to rewrite an already live guard.
+	data, err := json.Marshal(sources)
+	if err != nil {
+		return nil, err
+	}
+	var snapshot []TestModuleSource
+	if err := json.Unmarshal(data, &snapshot); err != nil {
+		return nil, err
+	}
+	guard := &InstrumentationTypeModuleGuard{bindings: make(map[string]*instrumentationTypeModuleBinding)}
+	for _, source := range snapshot {
+		stdout, stderr, err := run(ctx, directory, env, binary, "mod", "download", "-json", source.ID())
+		if err != nil || len(stderr) != 0 || len(stdout) == 0 || len(stdout) > commandOutputLimit {
+			return nil, fmt.Errorf("instrumentation exact foreign source download failed: %v; %s", err, stderr)
+		}
+		var download struct{ Path, Version, Dir, Zip, GoMod, Sum, GoModSum, Error string }
+		if err := json.Unmarshal(stdout, &download); err != nil || download.Error != "" ||
+			download.Path != source.SourceModule || download.Version != source.SourceVersion ||
+			download.Sum != source.ModuleSum || download.GoModSum != source.GoModSum {
+			return nil, fmt.Errorf("instrumentation source download differs from its exact ZIP/mod identity: %v", err)
+		}
+		root, err := sourcepath.Resolve(download.Dir)
+		if err != nil || !filepath.IsAbs(root) {
+			return nil, fmt.Errorf("instrumentation foreign source lacks an actual canonical root")
+		}
+		binding := &instrumentationTypeModuleBinding{source: source, root: root, archive: download.Zip,
+			downloadedMod: download.GoMod, metadata: make(map[string]string)}
+		guard.bindings[source.ID()] = binding
+		if err := guard.bindMetadata(binding, download.GoMod); err != nil {
+			return nil, err
+		}
+	}
+	return guard, guard.Verify(ctx)
+}
+
+func (guard *InstrumentationTypeModuleGuard) bindMetadata(binding *instrumentationTypeModuleBinding, filename string) error {
+	if err := VerifyTestModuleGoModMetadata(binding.source, binding.root, filename, binding.downloadedMod); err != nil {
+		return err
+	}
+	resolved, err := sourcepath.Resolve(filename)
+	if err != nil {
+		return err
+	}
+	if old, found := binding.metadata[filename]; found && old != resolved {
+		return fmt.Errorf("instrumentation foreign metadata changed its physical path")
+	}
+	binding.metadata[filename] = resolved
+	return nil
+}
+
+func (guard *InstrumentationTypeModuleGuard) bindPackage(pkg instrumentationTypeListPackage) (*instrumentationTypeModuleBinding, ImportExport, error) {
+	source := ImportExport{ImportPath: pkg.ImportPath, PackagePath: pkg.ImportPath, GoSHA256: make(map[string]string)}
+	actual := pkg.Module
+	if guard == nil || actual == nil || actual.Main || module.Check(actual.Path, actual.Version) != nil ||
+		pkg.ImportPath != actual.Path && !strings.HasPrefix(pkg.ImportPath, actual.Path+"/") {
+		return nil, source, fmt.Errorf("instrumentation foreign package lacks actual exact Module ownership")
+	}
+	source.ModulePath, source.Version = actual.Path, actual.Version
+	source.SourceModule, source.SourceVersion, source.SourceRole = actual.Path, actual.Version, "module"
+	metadata := actual.GoMod
+	root, err := sourcepath.Resolve(actual.Dir)
+	if err != nil {
+		return nil, source, err
+	}
+	if replacement := actual.Replace; replacement != nil {
+		if replacement.Main || replacement.Replace != nil || module.Check(replacement.Path, replacement.Version) != nil {
+			return nil, source, fmt.Errorf("instrumentation foreign source has unknown/local/nested replacement")
+		}
+		replaced, err := sourcepath.Resolve(replacement.Dir)
+		if err != nil || root != replaced {
+			return nil, source, fmt.Errorf("instrumentation replacement changed its actual source root")
+		}
+		source.SourceModule, source.SourceVersion, source.SourceRole = replacement.Path, replacement.Version, "version_replace"
+		metadata = replacement.GoMod
+	}
+	binding := guard.bindings[source.SourceModule+"@"+source.SourceVersion]
+	if binding == nil || binding.root != root {
+		return nil, source, fmt.Errorf("original type graph needs an authenticated foreign module source closure")
+	}
+	if err := guard.bindMetadata(binding, metadata); err != nil {
+		return nil, source, err
+	}
+	return binding, source, nil
+}
+
+// Verify rechecks original membership, ZIP/h1/mod origin and every observed
+// physical metadata path at the final metadata/CPP/LLVM consumer boundary.
+func (guard *InstrumentationTypeModuleGuard) Verify(ctx context.Context) error {
+	if ctx == nil || ctx.Err() != nil || guard == nil || guard.bindings == nil {
+		return fmt.Errorf("missing live instrumentation foreign source guard")
+	}
+	for _, binding := range guard.bindings {
+		if err := VerifyTestModuleSource(ctx, binding.source, binding.root, binding.archive); err != nil {
+			return err
+		}
+		for name, wanted := range binding.metadata {
+			actual, err := sourcepath.Resolve(name)
+			if err != nil || actual != wanted {
+				return fmt.Errorf("instrumentation foreign metadata path changed after loading")
+			}
+			if err := VerifyTestModuleGoModMetadata(binding.source, binding.root, name, binding.downloadedMod); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func validateInstrumentationTypeModuleCoverage(input *InstrumentationConsumerInput, proof *InstrumentationTypeSourceProof) error {
+	if err := validateInstrumentationTypeModuleResources(proof.SourceModules); err != nil {
+		return err
+	}
+	resources := make(map[string]TestModuleSource)
+	needed := make(map[string]map[string]bool)
+	for _, source := range proof.SourceModules {
+		resources[source.ID()] = source
+	}
+	for _, pkg := range proof.Dependencies {
+		source := pkg.Dependency.Source
+		foreign := source.ModulePath != "" && source.ModulePath != input.Original.Module
+		if !foreign {
+			if pkg.SourceRootID != "" || pkg.SFiles != nil {
+				return fmt.Errorf("ordinary/SDK type package acquired a foreign source-only role")
+			}
+			continue
+		}
+		id := source.SourceModule + "@" + source.SourceVersion
+		resource, found := resources[id]
+		if !found || pkg.SourceRootID != id || module.Check(source.ModulePath, source.Version) != nil ||
+			source.SourceRole != "module" && source.SourceRole != "version_replace" ||
+			source.SourceRole == "module" && (source.SourceModule != source.ModulePath || source.SourceVersion != source.Version) || pkg.SFiles == nil {
+			return fmt.Errorf("foreign type package lacks its actual independent module/source selection")
+		}
+		directory := strings.TrimPrefix(strings.TrimPrefix(source.PackagePath, source.ModulePath), "/")
+		if directory == "" {
+			directory = "."
+		}
+		if source.PackagePath != source.ModulePath && !strings.HasPrefix(source.PackagePath, source.ModulePath+"/") {
+			return fmt.Errorf("foreign package has a different declared module owner")
+		}
+		if needed[id] == nil {
+			needed[id] = make(map[string]bool)
+		}
+		if err := validateInstrumentationForeignSelection(input, pkg, resource, directory); err != nil {
+			return err
+		}
+		for dir := directory; ; dir = path.Dir(dir) {
+			needed[id][dir] = true
+			if dir == "." {
+				break
+			}
+		}
+		for file, hash := range source.GoSHA256 {
+			if path.Dir(file) != directory || resource.Sources[file] != hash {
+				return fmt.Errorf("foreign selected Go source differs from its original ZIP resource")
+			}
+		}
+		if !sort.StringsAreSorted(pkg.SFiles) {
+			return fmt.Errorf("foreign selected assembly is not canonical")
+		}
+		for i, file := range pkg.SFiles {
+			if path.Ext(file) != ".s" || path.Dir(file) != directory || resource.Sources[file] == "" || i > 0 && pkg.SFiles[i-1] == file {
+				return fmt.Errorf("foreign selected assembly has an unbound original source role")
+			}
+		}
+	}
+	if len(needed) != len(resources) {
+		return fmt.Errorf("instrumentation source-only inventory contains an unconsumed module")
+	}
+	for id, source := range resources {
+		if len(source.Directories) != len(needed[id]) {
+			return fmt.Errorf("instrumentation foreign source directories lost exact consumed coverage")
+		}
+		for directory := range source.Directories {
+			if !needed[id][directory] {
+				return fmt.Errorf("unconsumed instrumentation foreign directory")
+			}
+		}
+	}
+	return nil
+}
+
+func validateInstrumentationForeignSelection(input *InstrumentationConsumerInput, pkg InstrumentationTypeSourcePackage,
+	resource TestModuleSource, directory string,
+) error {
+	if input.Observation.Early.SourceRules == nil ||
+		input.Observation.Early.SourceRules.GoVersion != input.Observation.Early.BaselineFeatures.GoVersion {
+		return fmt.Errorf("foreign original selection lacks its same-SDK source-rule identity")
+	}
+	context, err := instrumentationOriginalBuildContext(&InstrumentationOriginalSourceInventory{Contents: resource.Headers},
+		input.Observation.Early, input.Plan.CustomTags, true)
+	if err != nil {
+		return err
+	}
+	goFiles, assembly := []string{}, []string{}
+	for _, member := range resource.Directories[directory] {
+		if member.Kind != "file" || path.Ext(member.Name) != ".go" && path.Ext(member.Name) != ".s" {
+			continue
+		}
+		file := path.Join(directory, member.Name)
+		selected, err := context.MatchFile(directory, member.Name)
+		if err != nil {
+			return fmt.Errorf("foreign ordinary source selection: %w", err)
+		}
+		if !selected || strings.HasSuffix(member.Name, "_test.go") {
+			continue
+		}
+		if path.Ext(member.Name) == ".s" {
+			assembly = append(assembly, file)
+			continue
+		}
+		syntax, err := parser.ParseFile(token.NewFileSet(), file, resource.Headers[file], parser.ImportsOnly)
+		if err != nil || syntax.Name.Name != pkg.Name {
+			return fmt.Errorf("foreign selected source lost its actual ordinary package clause")
+		}
+		for _, imported := range syntax.Imports {
+			spelling, err := strconv.Unquote(imported.Path.Value)
+			if err != nil || spelling == "C" {
+				return fmt.Errorf("foreign source-only type selection cannot grant a generated cgo role")
+			}
+		}
+		goFiles = append(goFiles, file)
+	}
+	claimed := make([]string, 0, len(pkg.Dependency.Source.GoSHA256))
+	for file := range pkg.Dependency.Source.GoSHA256 {
+		claimed = append(claimed, file)
+	}
+	sort.Strings(claimed)
+	if !reflect.DeepEqual(goFiles, claimed) || !reflect.DeepEqual(assembly, pkg.SFiles) {
+		return fmt.Errorf("foreign source-only selection differs from complete original directory/profile/tags")
+	}
+	// Body-only dependencies deliberately have no declaration-AST Contents.
+	// Their complete original selection headers still bind every import spelling.
+	return validateInstrumentationOriginalImportSpellings(goFiles, resource.Headers, pkg.Dependency.ImportMap)
+}
+
+func instrumentationForeignDependencyBound(input *InstrumentationConsumerInput, source ImportExport) bool {
+	if input.TypeSources == nil || input.TypeSources.Protocol != instrumentationTypeSourcesProtocol {
+		return false
+	}
+	for _, pkg := range input.TypeSources.Dependencies {
+		if pkg.SourceRootID != "" && reflect.DeepEqual(pkg.Dependency.Source, source) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/gotoolprofile/instrumentation_type_modules_test.go b/gotoolprofile/instrumentation_type_modules_test.go
new file mode 100644
index 000000000..8d379e65d
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_modules_test.go
@@ -0,0 +1,144 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Portable shape tests use first-party original ZIP bytes and a synthetic
+// export digest. They never claim an actual external-module authentication.
+func instrumentationForeignPortableFixture(t *testing.T) *InstrumentationConsumerInput {
+	t.Helper()
+	resource, _, _ := testDependencyModuleFixture(t)
+	const dependencyPath = "example.invalid/boundary/loader/internal/layout"
+	root := "package replay\nimport alias \"" + dependencyPath + "\"\nfunc Probe(value alias.Float) alias.Float\n"
+	foreign := "package layout\ntype Float = float32\n"
+	input := &InstrumentationConsumerInput{
+		Original: &ConsumerInput{Module: "example.invalid/replay", Sources: map[string]string{"replay.go": bytesSHA256([]byte(root))}},
+		Plan:     &InstrumentationOriginalPackagePlan{Target: "linux/amd64", PackageName: "replay", PackagePath: "example.invalid/replay", GoFiles: []string{"replay.go"}},
+		Sources:  &InstrumentationOriginalSourceInventory{Contents: map[string]string{"replay.go": root}},
+		Observation: &InstrumentationExportObservation{Early: &InstrumentationEarlyObservation{
+			Mode: InstrumentationRace, CGOEnabled: "0", Environment: map[string]string{"GOOS": "linux", "GOARCH": "amd64"},
+			BaselineFeatures: &Observation{GoVersion: runtime.Version()},
+			SourceRules:      &InstrumentationSourceProof{GoVersion: runtime.Version()},
+		}},
+	}
+	input.TypeSources = &InstrumentationTypeSourceProof{
+		Protocol: InstrumentationTypeSourcesProtocol, InputSHA256: instrumentationTypeSourceInputSHA(input),
+		RootImportMap: map[string]string{dependencyPath: dependencyPath}, SourceModules: []TestModuleSource{resource},
+		Dependencies: []InstrumentationTypeSourcePackage{{Name: "layout", SourceRootID: resource.ID(), SFiles: []string{},
+			Contents: map[string]string{"internal/layout/type.go": foreign},
+			Dependency: InstrumentationDependencyExport{ImportMap: map[string]string{}, Source: ImportExport{
+				ImportPath: dependencyPath, PackagePath: dependencyPath, ModulePath: resource.SourceModule, Version: resource.SourceVersion,
+				SourceModule: resource.SourceModule, SourceVersion: resource.SourceVersion, SourceRole: "module",
+				ExportSHA256: strings.Repeat("1", 64), GoSHA256: map[string]string{"internal/layout/type.go": bytesSHA256([]byte(foreign))},
+			}},
+		}},
+	}
+	return input
+}
+
+func TestInstrumentationForeignTypeResourcesPortableClosure(t *testing.T) {
+	input := instrumentationForeignPortableFixture(t)
+	if err := ValidateInstrumentationTypeSources(input, input.TypeSources); err != nil {
+		t.Fatal(err)
+	}
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var roundtrip InstrumentationConsumerInput
+	if err := json.Unmarshal(encoded, &roundtrip); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateInstrumentationTypeSources(&roundtrip, roundtrip.TypeSources); err != nil {
+		t.Fatal(err)
+	}
+	if roundtrip.TypeSources.Dependencies[0].SFiles == nil {
+		t.Fatal("explicit empty selected assembly was lost in JSON")
+	}
+	for name, mutate := range map[string]func(*InstrumentationConsumerInput){
+		"missing modules":          func(p *InstrumentationConsumerInput) { p.TypeSources.SourceModules = nil },
+		"missing source reference": func(p *InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].SourceRootID = "" },
+		"old protocol": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Protocol = "actual_go_instrumentation_type_sources_v1"
+		},
+		"foreign main role": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.SourceRole = "main"
+		},
+		"different declared version": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.Version = "v1.0.1"
+		},
+		"ordinary source role": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.ModulePath = p.Original.Module
+		},
+		"source-only assembly deleted": func(p *InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].SFiles = nil },
+		"source rules deleted":         func(p *InstrumentationConsumerInput) { p.Observation.Early.SourceRules = nil },
+		"selected source deleted": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.GoSHA256 = map[string]string{}
+		},
+		"directory removed": func(p *InstrumentationConsumerInput) { delete(p.TypeSources.SourceModules[0].Directories, "internal") },
+		"header removed": func(p *InstrumentationConsumerInput) {
+			delete(p.TypeSources.SourceModules[0].Headers, "internal/layout/type.go")
+		},
+		"source byte hash": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.GoSHA256["internal/layout/type.go"] = strings.Repeat("0", 64)
+		},
+		"different profile selection": func(p *InstrumentationConsumerInput) {
+			p.Observation.Early.Environment["GOARCH"] = "arm64"
+			p.TypeSources.Dependencies[0].SFiles = []string{"internal/layout/probe_amd64.s"}
+		},
+		"test source pretending ordinary": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.GoSHA256["internal/layout/extra_test.go"] = strings.Repeat("0", 64)
+		},
+		"unconsumed module": func(p *InstrumentationConsumerInput) {
+			extra := cloneTestModuleSource(t, p.TypeSources.SourceModules[0])
+			extra.SourceModule = "example.invalid/unused"
+			p.TypeSources.SourceModules = append(p.TypeSources.SourceModules, extra)
+			SortTestModuleSources(p.TypeSources.SourceModules)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationConsumerInput
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			// Rebinding the input digest cannot turn a changed selection or role
+			// into a missing-resource fallback.
+			changed.TypeSources.InputSHA256 = instrumentationTypeSourceInputSHA(&changed)
+			if err := ValidateInstrumentationTypeSources(&changed, changed.TypeSources); err == nil {
+				t.Fatal("accepted incomplete/changed foreign source-only closure")
+			}
+		})
+	}
+	if input.Original.TestDependencies != nil || input.Original.TestDependencySourceProtocol != "" {
+		t.Fatal("type resources borrowed a test-source role")
+	}
+}
+
+func TestInstrumentationForeignTypeResourcesSharedBudget(t *testing.T) {
+	input := instrumentationForeignPortableFixture(t)
+	resource := cloneTestModuleSource(t, input.TypeSources.SourceModules[0])
+	for file := range resource.Headers {
+		resource.Headers[file] = strings.Repeat(" ", 3<<20)
+	}
+	if err := validateInstrumentationTypeModuleResources([]TestModuleSource{resource}); err != nil {
+		t.Fatal(err)
+	}
+	other := cloneTestModuleSource(t, resource)
+	other.SourceModule = "example.invalid/other"
+	third := cloneTestModuleSource(t, resource)
+	third.SourceModule = "example.invalid/third"
+	resources := []TestModuleSource{resource, other, third}
+	SortTestModuleSources(resources)
+	if err := validateInstrumentationTypeModuleResources(resources); err == nil {
+		t.Fatal("each module received a fresh text-byte budget")
+	}
+	if !reflect.DeepEqual(input.TypeSources.SourceModules[0].Headers, instrumentationForeignPortableFixture(t).TypeSources.SourceModules[0].Headers) {
+		t.Fatal("budget validation mutated original resources")
+	}
+}
diff --git a/gotoolprofile/instrumentation_type_paths_go127_test.go b/gotoolprofile/instrumentation_type_paths_go127_test.go
new file mode 100644
index 000000000..5323d8c2c
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_paths_go127_test.go
@@ -0,0 +1,108 @@
+//go:build go1.27
+
+package gotoolprofile
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestInstrumentationTypeSourceCaptureActualLogicalRoot(t *testing.T) {
+	t.Setenv("GOFLAGS", "-tags=plan9asm_fixture_ambient")
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	defer cancel()
+	marker, err := CaptureInstrumentationExportObservation(ctx, binary, instrumentationMarkerDirectory(t), os.Environ(), "darwin/arm64", InstrumentationRace, "0", nil, RunBounded)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := instrumentationOriginalFixture(t, marker.Early)
+	physical, err := sourcepath.Resolve(original.SourceRoot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "module")
+	if err := os.Symlink(physical, alias); err != nil {
+		t.Fatal(err)
+	}
+	original.SourceRoot = alias
+	inventory, err := CaptureInstrumentationOriginalSourceInventory(original, ".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := PlanInstrumentationOriginalPackage(original, inventory, marker.Early, ".", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	input, err := NewInstrumentationConsumerInput(original, inventory, marker, plan)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed := 0
+	run := func(ctx context.Context, directory string, env []string, command string, args ...string) ([]byte, []byte, error) {
+		// SDK tool-route queries deliberately have no source working directory.
+		if directory != "" && directory != physical {
+			return nil, nil, fmt.Errorf("type capture must use one physical invocation directory, got %q", directory)
+		}
+		stdout, stderr, err := RunBounded(ctx, directory, env, command, args...)
+		if err != nil || len(args) == 0 || args[0] != "list" {
+			return stdout, stderr, err
+		}
+		decoder := json.NewDecoder(bytes.NewReader(stdout))
+		for {
+			var pkg instrumentationTypeListPackage
+			if err := decoder.Decode(&pkg); err == io.EOF {
+				break
+			} else if err != nil {
+				return nil, nil, err
+			}
+			if pkg.ImportPath == plan.PackagePath {
+				if pkg.Dir != physical || pkg.Dir == original.SourceRoot {
+					return nil, nil, fmt.Errorf("actual stock Go did not expose the distinct physical root: %q", pkg.Dir)
+				}
+				observed++
+				data, err := json.Marshal(pkg)
+				if err != nil {
+					return nil, nil, err
+				}
+				t.Logf("unaltered stock Go root JSON export=%t: %s", containsString(args, "-export"), data)
+			}
+		}
+		return stdout, stderr, nil
+	}
+	env := instrumentationFixtureEnvironment(os.Environ(), marker.Early)
+	proof, err := CaptureInstrumentationTypeSources(ctx, binary, alias, env, input, run)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if observed != 2 {
+		t.Fatalf("did not retain both actual pre/post selection commands: %d", observed)
+	}
+	original.SourceRoot = physical
+	canonical, err := CaptureInstrumentationTypeSources(ctx, binary, physical, env, input, RunBounded)
+	if err != nil || !reflect.DeepEqual(proof, canonical) {
+		t.Fatalf("same physical source acquired a different portable type identity: %v", err)
+	}
+	foreign := instrumentationOriginalFixture(t, marker.Early)
+	original.SourceRoot = foreign.SourceRoot
+	if _, err := CaptureInstrumentationTypeSources(ctx, binary, physical, env, input, RunBounded); err == nil || !strings.Contains(err.Error(), "actual imported module root differs from the authenticated original source") {
+		t.Fatalf("equal-byte foreign source root did not retain the exact physical origin rejection: %v", err)
+	}
+	original.SourceRoot = physical
+	t.Log("actual pre/post stock-Go JSON and same-root alias binding; equal-byte other root rejected, no LLVM or runtime claim")
+}
diff --git a/gotoolprofile/instrumentation_type_paths_test.go b/gotoolprofile/instrumentation_type_paths_test.go
new file mode 100644
index 000000000..57adf4f14
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_paths_test.go
@@ -0,0 +1,60 @@
+package gotoolprofile
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestInstrumentationTypeNamesPhysicalSourceIdentity(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	foreign, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, directory := range []string{root, foreign} {
+		if err := os.WriteFile(filepath.Join(directory, "source.go"), []byte("package source\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	alias := filepath.Join(t.TempDir(), "module")
+	if err := os.Symlink(root, alias); err != nil {
+		t.Fatal(err)
+	}
+	redirect := filepath.Join(root, "redirect.go")
+	if err := os.Symlink(filepath.Join(foreign, "source.go"), redirect); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(filepath.Join(root, "directory.go"), 0700); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, directory, root string
+		files                 []string
+		want                  []string
+	}{
+		{"canonical relative", root, root, []string{"source.go"}, []string{"source.go"}},
+		{"logical root physical file", root, alias, []string{filepath.Join(root, "source.go")}, []string{"source.go"}},
+		{"logical directory physical root", alias, root, []string{"source.go"}, []string{"source.go"}},
+		{"logical absolute file", alias, root, []string{filepath.Join(alias, "source.go")}, []string{"source.go"}},
+		{"valid empty", root, root, nil, []string{}},
+		{"equal-byte foreign root", foreign, root, []string{"source.go"}, nil},
+		{"absolute foreign file", root, root, []string{filepath.Join(foreign, "source.go")}, nil},
+		{"source symlink escape", root, root, []string{"redirect.go"}, nil},
+		{"missing source", root, root, []string{"missing.go"}, nil},
+		{"nonregular source", root, root, []string{"directory.go"}, nil},
+		{"missing root", root, filepath.Join(root, "missing"), nil, nil},
+		{"nonregular root", root, filepath.Join(root, "source.go"), nil, nil},
+		{"relative root", root, ".", []string{"source.go"}, nil},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := instrumentationTypeNames(test.files, test.directory, test.root); !reflect.DeepEqual(got, test.want) {
+				t.Fatalf("physical source selection: got %v (nil=%t), want %v (nil=%t)", got, got == nil, test.want, test.want == nil)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/instrumentation_type_sources.go b/gotoolprofile/instrumentation_type_sources.go
new file mode 100644
index 000000000..e708bdf40
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_sources.go
@@ -0,0 +1,398 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/mod/module"
+)
+
+const InstrumentationTypeSourcesProtocol = "actual_go_instrumentation_type_sources_v2"
+const instrumentationTypeSourcesProtocol = InstrumentationTypeSourcesProtocol
+
+// This input is captured before metadata and independently recaptured by its
+// actual consumer. Digests alone, or two agreeing metadata records, cannot
+// authenticate a source root. ZIP authentication and a trusted stock SDK are
+// still prerequisites. Only required imported type/constant packages retain
+// complete compiler-source bytes; all reachable exports/ImportMaps are bound.
+type InstrumentationTypeSourceProof struct {
+	Protocol      string                             `json:"protocol"`
+	InputSHA256   string                             `json:"input_sha256"`
+	UnsafeSHA256  string                             `json:"builtin_unsafe_source_sha256,omitempty"`
+	RootImportMap map[string]string                  `json:"root_import_map"`
+	Dependencies  []InstrumentationTypeSourcePackage `json:"dependencies"`
+	SourceModules []TestModuleSource                 `json:"source_only_modules"`
+}
+
+type InstrumentationTypeSourcePackage struct {
+	Name         string                          `json:"package_name"`
+	Dependency   InstrumentationDependencyExport `json:"dependency"`
+	Contents     map[string]string               `json:"contents,omitempty"`
+	SourceRootID string                          `json:"source_root_id,omitempty"`
+	SFiles       []string                        `json:"selected_source_only_assembly"`
+}
+
+func instrumentationTypeSourceInputSHA(input *InstrumentationConsumerInput) string {
+	if input == nil {
+		return ""
+	}
+	copy := *input
+	copy.TypeSources = nil
+	return InstrumentationConsumerInputSHA256(&copy)
+}
+
+// This predicate only requests capture cost. It grants no selector, layout or
+// source role: all original declarations must still pass the actual source
+// capture and the independently replayed imported AST closure.
+func InstrumentationRequiresTypeSources(input *InstrumentationConsumerInput) (bool, error) {
+	if input == nil || input.Plan == nil || input.Sources == nil {
+		return false, fmt.Errorf("missing original type-source planning input")
+	}
+	replay := &instrumentationDeclarationReplay{functions: make(map[string]*ast.FuncDecl), types: make(map[string]*ast.TypeSpec),
+		constants: make(map[string]*ast.GenDecl), other: make(map[string]bool), needed: make(map[ast.Node]bool)}
+	found := false
+	replay.selector = func(*ast.SelectorExpr) error { found = true; return nil }
+	for _, name := range input.Plan.GoFiles {
+		file, err := parser.ParseFile(token.NewFileSet(), name, input.Sources.Contents[name], 0)
+		if err != nil {
+			return false, err
+		}
+		if err := replay.index(file); err != nil {
+			return false, err
+		}
+	}
+	for _, function := range replay.functions {
+		if function.Body == nil && function.Recv == nil {
+			if err := replay.requireType(function.Type); err != nil {
+				return false, err
+			}
+		}
+	}
+	return found, nil
+}
+
+func ValidateInstrumentationTypeSources(input *InstrumentationConsumerInput, proof *InstrumentationTypeSourceProof) error {
+	if input == nil || input.Plan == nil || input.Original == nil || input.Observation == nil || input.Observation.Early == nil || input.Observation.Early.BaselineFeatures == nil || proof == nil ||
+		proof.Protocol != instrumentationTypeSourcesProtocol || proof.InputSHA256 != instrumentationTypeSourceInputSHA(input) ||
+		proof.RootImportMap == nil || len(proof.RootImportMap) > 4096 || proof.Dependencies == nil || len(proof.Dependencies) > 4096 {
+		return fmt.Errorf("original imported type source lost its independent input/scope identity")
+	}
+	if input.Sources == nil {
+		return fmt.Errorf("original import graph lacks complete selected Go source")
+	}
+	if err := validateInstrumentationTypeModuleCoverage(input, proof); err != nil {
+		return err
+	}
+	if err := validateInstrumentationOriginalImportSpellings(input.Plan.GoFiles, input.Sources.Contents, proof.RootImportMap); err != nil {
+		return err
+	}
+	dependencies := make([]InstrumentationDependencyExport, 0, len(proof.Dependencies))
+	header := GeneratedHeaderProof{ImportMap: proof.RootImportMap}
+	byPath := make(map[string]InstrumentationDependencyExport)
+	total := 0
+	for _, module := range proof.SourceModules {
+		for _, header := range module.Headers {
+			total += len(header)
+		}
+	}
+	unsafeNeeded := proof.RootImportMap["unsafe"] == "unsafe"
+	if !sort.SliceIsSorted(proof.Dependencies, func(i, j int) bool {
+		return proof.Dependencies[i].Dependency.Source.PackagePath < proof.Dependencies[j].Dependency.Source.PackagePath
+	}) {
+		return fmt.Errorf("original imported type packages are not canonical")
+	}
+	for _, pkg := range proof.Dependencies {
+		dep := pkg.Dependency
+		if dep.ImportMap["unsafe"] == "unsafe" {
+			unsafeNeeded = true
+		}
+		if !token.IsIdentifier(pkg.Name) || pkg.Name == "_" {
+			return fmt.Errorf("original imported package lacks its actual source name")
+		}
+		for name, contents := range pkg.Contents {
+			total += len(contents)
+			if len(contents) > instrumentationOriginalFileLimit || total > instrumentationOriginalInventoryLimit ||
+				bytesSHA256([]byte(contents)) != dep.Source.GoSHA256[name] || strings.ContainsRune(contents, '\x00') {
+				return fmt.Errorf("original imported declaration source changed or exceeds its byte bound")
+			}
+		}
+		if pkg.Contents != nil && len(pkg.Contents) != len(dep.Source.GoSHA256) {
+			return fmt.Errorf("imported declaration package lacks complete actual compiled source bytes")
+		}
+		if pkg.Contents != nil {
+			names := make([]string, 0, len(dep.Source.GoSHA256))
+			for name := range dep.Source.GoSHA256 {
+				names = append(names, name)
+			}
+			if err := validateInstrumentationOriginalImportSpellings(names, pkg.Contents, dep.ImportMap); err != nil {
+				return err
+			}
+		}
+		dependencies = append(dependencies, dep)
+		byPath[dep.Source.PackagePath] = dep
+	}
+	if unsafeNeeded != (proof.UnsafeSHA256 != "") || proof.UnsafeSHA256 != "" && !discoverySHA256Pattern.MatchString(proof.UnsafeSHA256) {
+		return fmt.Errorf("original type graph lost or invented the actual SDK builtin unsafe source identity")
+	}
+	for spelling, target := range proof.RootImportMap {
+		if target == "unsafe" {
+			continue
+		}
+		dep := byPath[target].Source
+		dep.ImportPath = spelling
+		header.Imports = append(header.Imports, dep)
+	}
+	pkg := PackageProof{PackagePath: input.Plan.PackagePath, SourceModule: input.Original.Module,
+		SourceVersion: input.Original.Version, SourceRole: "main"}
+	if input.Original.SourceModule != "" {
+		pkg.SourceRole = "module"
+		pkg.SourceModule = input.Original.SourceModule
+		if input.Original.SourceModule != input.Original.Module {
+			pkg.SourceRole = "version_replace"
+		}
+	}
+	copy := *input
+	copy.TypeSources = proof
+	return validateInstrumentationMetadataDependencies(&copy, pkg, header, dependencies)
+}
+
+// The physical capture supplies each ImportMap's targets. Independently bound
+// source bytes supply its exact spelling set, including imports used only by
+// bodies, blank imports and repeated spellings across selected files. A paired
+// metadata mutation cannot invent an unused edge to an already present export.
+func validateInstrumentationOriginalImportSpellings(names []string, contents map[string]string, importMap map[string]string) error {
+	if len(names) == 0 {
+		return fmt.Errorf("original import graph has no selected compiler Go files")
+	}
+	imports := make(map[string]bool)
+	for _, name := range names {
+		source, present := contents[name]
+		if !present {
+			return fmt.Errorf("original import graph lost selected Go source: %s", name)
+		}
+		file, err := parser.ParseFile(token.NewFileSet(), name, source, parser.ImportsOnly)
+		if err != nil {
+			return fmt.Errorf("original import syntax changed: %w", err)
+		}
+		for _, spec := range file.Imports {
+			spelling, err := strconv.Unquote(spec.Path.Value)
+			if err != nil || module.CheckImportPath(spelling) != nil {
+				return fmt.Errorf("original source has a noncanonical import spelling")
+			}
+			imports[spelling] = true
+		}
+	}
+	if len(imports) != len(importMap) {
+		return fmt.Errorf("original source/import-map spelling sets differ")
+	}
+	for spelling := range importMap {
+		if !imports[spelling] {
+			return fmt.Errorf("original import-map spelling is absent from selected Go bytes: %s", spelling)
+		}
+	}
+	return nil
+}
+
+type instrumentationTypeReplay struct {
+	input   *InstrumentationConsumerInput
+	set     *token.FileSet
+	proof   *InstrumentationTypeSourceProof
+	replays map[string]*instrumentationDeclarationReplay
+	typed   map[string]*types.Package
+	active  map[string]bool
+	load    func(*InstrumentationTypeSourcePackage) error // Actual capture only; never restored from JSON.
+	// Only the separate query-only native-header role supplies these. Existing
+	// metadata/ABI replay retains its original SizesFor and SDK-language rules.
+	nativeSizes *nativeHeaderGCSizes
+	language    func(ImportExport) (string, error)
+}
+
+func newInstrumentationTypeReplay(input *InstrumentationConsumerInput, set *token.FileSet, root *instrumentationDeclarationReplay) (*instrumentationTypeReplay, error) {
+	if input.TypeSources == nil {
+		return nil, nil // The original strict selector error remains in place.
+	}
+	if err := ValidateInstrumentationTypeSources(input, input.TypeSources); err != nil {
+		return nil, err
+	}
+	graph := &instrumentationTypeReplay{input: input, set: set, proof: input.TypeSources,
+		replays: map[string]*instrumentationDeclarationReplay{input.Plan.PackagePath: root},
+		typed:   make(map[string]*types.Package), active: make(map[string]bool)}
+	root.selector = func(expression *ast.SelectorExpr) error {
+		return graph.requireSelector(root, graph.proof.RootImportMap, expression)
+	}
+	return graph, nil
+}
+
+func (graph *instrumentationTypeReplay) dependency(target string) (*instrumentationDeclarationReplay, map[string]string, error) {
+	for index := range graph.proof.Dependencies {
+		pkg := &graph.proof.Dependencies[index]
+		if pkg.Dependency.Source.PackagePath != target {
+			continue
+		}
+		if len(pkg.Contents) == 0 {
+			if graph.load == nil {
+				return nil, nil, fmt.Errorf("original declaration needs an authenticated imported type/constant closure: %s", target)
+			}
+			if err := graph.load(pkg); err != nil {
+				return nil, nil, err
+			}
+		}
+		if prior := graph.replays[target]; prior != nil {
+			return prior, pkg.Dependency.ImportMap, nil
+		}
+		replay := &instrumentationDeclarationReplay{functions: make(map[string]*ast.FuncDecl), types: make(map[string]*ast.TypeSpec),
+			constants: make(map[string]*ast.GenDecl), other: make(map[string]bool), needed: make(map[ast.Node]bool)}
+		var names []string
+		for name := range pkg.Contents {
+			names = append(names, name)
+		}
+		sort.Strings(names)
+		for _, name := range names {
+			file, err := parser.ParseFile(graph.set, target+"/"+name, pkg.Contents[name], 0)
+			if err != nil || file.Name.Name != pkg.Name {
+				return nil, nil, fmt.Errorf("original imported declaration package has changed syntax/role: %v", err)
+			}
+			replay.files = append(replay.files, file)
+			if err := replay.index(file); err != nil {
+				return nil, nil, err
+			}
+		}
+		graph.replays[target] = replay
+		replay.selector = func(expression *ast.SelectorExpr) error {
+			return graph.requireSelector(replay, pkg.Dependency.ImportMap, expression)
+		}
+		return replay, pkg.Dependency.ImportMap, nil
+	}
+	return nil, nil, fmt.Errorf("original import omitted its independently observed package: %s", target)
+}
+
+func (graph *instrumentationTypeReplay) requireSelector(replay *instrumentationDeclarationReplay, importMap map[string]string, expression *ast.SelectorExpr) error {
+	qualifier, ok := expression.X.(*ast.Ident)
+	if !ok || !token.IsExported(expression.Sel.Name) {
+		return fmt.Errorf("original selector lacks a direct exported import identity")
+	}
+	for _, file := range replay.files {
+		if expression.Pos() < file.Pos() || expression.End() > file.End() {
+			continue
+		}
+		for _, spec := range file.Imports {
+			spelling, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				return err
+			}
+			target := importMap[spelling]
+			name := "unsafe"
+			if target != "unsafe" {
+				name = ""
+				for _, pkg := range graph.proof.Dependencies {
+					if pkg.Dependency.Source.PackagePath == target {
+						name = pkg.Name
+						break
+					}
+				}
+			}
+			if spec.Name != nil {
+				name = spec.Name.Name
+			}
+			if name != qualifier.Name {
+				continue
+			}
+			if target == "" || spelling == "unsafe" && target != "unsafe" {
+				return fmt.Errorf("original selector has no actual ImportMap edge")
+			}
+			replay.needed[spec] = true
+			if target == "unsafe" {
+				if types.Unsafe.Scope().Lookup(expression.Sel.Name) == nil {
+					return fmt.Errorf("unknown builtin unsafe selector")
+				}
+				return nil
+			}
+			child, _, err := graph.dependency(target)
+			if err != nil {
+				return err
+			}
+			return child.requireName(expression.Sel.Name)
+		}
+	}
+	return fmt.Errorf("original selector has no closed file-local import: %s", qualifier.Name)
+}
+
+type instrumentationTypeImporter struct {
+	graph     *instrumentationTypeReplay
+	importMap map[string]string
+}
+
+func (importer instrumentationTypeImporter) Import(name string) (*types.Package, error) {
+	graph := importer.graph
+	// No filename or prefix inference: every package owns its observed map.
+	target := importer.importMap[name]
+	if target == "unsafe" && name == "unsafe" {
+		return types.Unsafe, nil
+	}
+	if target == "" || graph.active[target] {
+		return nil, fmt.Errorf("original imported type graph has a missing edge or cycle")
+	}
+	if typed := graph.typed[target]; typed != nil {
+		return typed, nil
+	}
+	replay, importMap, err := graph.dependency(target)
+	if err != nil {
+		return nil, err
+	}
+	_, arch, _ := strings.Cut(graph.input.Plan.Target, "/")
+	minor, err := goMinor(graph.input.Observation.Early.BaselineFeatures.GoVersion)
+	if err != nil {
+		return nil, err
+	}
+	graph.active[target] = true
+	defer delete(graph.active, target)
+	config := types.Config{Sizes: types.SizesFor("gc", arch), GoVersion: fmt.Sprintf("go1.%d", minor), IgnoreFuncBodies: true,
+		Importer: instrumentationTypeImporter{graph: graph, importMap: importMap}}
+	if graph.nativeSizes != nil {
+		config.Sizes = graph.nativeSizes
+		for _, dependency := range graph.proof.Dependencies {
+			if dependency.Dependency.Source.PackagePath == target {
+				config.GoVersion, err = graph.language(dependency.Dependency.Source)
+				if err != nil {
+					return nil, err
+				}
+				break
+			}
+		}
+		if err := boundNativeHeaderStrings(replay.selectedFiles()); err != nil {
+			return nil, err
+		}
+	}
+	typed, err := config.Check(target, graph.set, replay.selectedFiles(), nil)
+	if err != nil {
+		return nil, fmt.Errorf("original imported type/constant closure is not independently closed: %w", err)
+	}
+	graph.typed[target] = typed
+	return typed, nil
+}
+
+// Verify that metadata consumes the pre-query source capture, not a paired
+// export/hash replacement. Every actual dependency and root spelling remains.
+func validateInstrumentationTypeSourceAgreement(input *InstrumentationConsumerInput, header GeneratedHeaderProof, dependencies []InstrumentationDependencyExport) error {
+	if input.TypeSources == nil {
+		return nil
+	}
+	if err := ValidateInstrumentationTypeSources(input, input.TypeSources); err != nil {
+		return err
+	}
+	wanted := make([]InstrumentationDependencyExport, 0, len(input.TypeSources.Dependencies))
+	for _, pkg := range input.TypeSources.Dependencies {
+		wanted = append(wanted, pkg.Dependency)
+	}
+	if !reflect.DeepEqual(input.TypeSources.RootImportMap, header.ImportMap) || !reflect.DeepEqual(wanted, dependencies) {
+		return fmt.Errorf("actual metadata dependency origins/source/export/importmap differ from original type capture")
+	}
+	return nil
+}
diff --git a/gotoolprofile/instrumentation_type_sources_test.go b/gotoolprofile/instrumentation_type_sources_test.go
new file mode 100644
index 000000000..82213ae42
--- /dev/null
+++ b/gotoolprofile/instrumentation_type_sources_test.go
@@ -0,0 +1,215 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func instrumentationImportedReplayFixture(t *testing.T, arch string) (*InstrumentationConsumerInput, PackageProof, InstrumentationDeclarationProof) {
+	t.Helper()
+	const packagePath = "example.invalid/replay"
+	const source = `package replay
+import renamed "example.invalid/replay/dep"
+type Alias = renamed.Row
+const Size = renamed.Count
+func Probe(value Alias, bytes [Size]byte) uintptr
+`
+	const dependency = `package dependency
+type Element uint16
+type Alias = Element
+const (
+	_ = iota
+	Count
+	_ = iota
+	Length
+)
+type Row struct { First byte; Payload [Length]Alias; Last uintptr }
+`
+	input := &InstrumentationConsumerInput{
+		Original: &ConsumerInput{Module: packagePath, Sources: map[string]string{
+			"replay.go": bytesSHA256([]byte(source)), "dep/types.go": bytesSHA256([]byte(dependency)),
+		}},
+		Plan:    &InstrumentationOriginalPackagePlan{Target: "linux/" + arch, PackageName: "replay", PackagePath: packagePath, GoFiles: []string{"replay.go"}},
+		Sources: &InstrumentationOriginalSourceInventory{Contents: map[string]string{"replay.go": source}},
+		Observation: &InstrumentationExportObservation{Early: &InstrumentationEarlyObservation{
+			BaselineFeatures: &Observation{GoVersion: runtime.Version()},
+		}},
+	}
+	input.TypeSources = &InstrumentationTypeSourceProof{
+		Protocol: instrumentationTypeSourcesProtocol, InputSHA256: instrumentationTypeSourceInputSHA(input),
+		SourceModules: []TestModuleSource{},
+		RootImportMap: map[string]string{packagePath + "/dep": packagePath + "/dep"},
+		Dependencies: []InstrumentationTypeSourcePackage{{
+			Name: "dependency", Contents: map[string]string{"dep/types.go": dependency},
+			Dependency: InstrumentationDependencyExport{
+				Source: ImportExport{ImportPath: packagePath + "/dep", PackagePath: packagePath + "/dep", ModulePath: packagePath,
+					SourceModule: packagePath, SourceRole: "main", ExportSHA256: strings.Repeat("1", 64),
+					GoSHA256: map[string]string{"dep/types.go": bytesSHA256([]byte(dependency))}},
+				ImportMap: map[string]string{},
+			},
+		}},
+	}
+	// Independent full-source go/types establishes the fixture's expected layout;
+	// it does not use the filtered replay or metadata signature strings.
+	set := token.NewFileSet()
+	depAST, err := parser.ParseFile(set, "dep/types.go", dependency, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", arch)
+	dep, err := (&types.Config{Sizes: sizes}).Check(packagePath+"/dep", set, []*ast.File{depAST}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(set, "replay.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	root, err := (&types.Config{Sizes: sizes, Importer: instrumentationFixtureImporter{dep: dep}}).Check(packagePath, set, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	function := root.Scope().Lookup("Probe").(*types.Func)
+	layout, err := plan9asm.DeriveGoFuncABI0Signature(packagePath+".Probe", function, arch, sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, err := json.Marshal(layout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return input, PackageProof{PackagePath: packagePath, CompiledGoFiles: []string{"replay.go"}}, InstrumentationDeclarationProof{
+		Symbol: layout.Name, File: "replay.go", GoType: types.TypeString(function.Type(), func(pkg *types.Package) string { return pkg.Path() }), Layout: data,
+	}
+}
+
+type instrumentationFixtureImporter struct{ dep *types.Package }
+
+func (importer instrumentationFixtureImporter) Import(name string) (*types.Package, error) {
+	if name != importer.dep.Path() {
+		return nil, types.Error{Msg: "fixture requested an unregistered import"}
+	}
+	return importer.dep, nil
+}
+
+func TestInstrumentationImportedTypeReplayRetainsAliasesConstGroupsAndTargetLayout(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			input, pkg, declaration := instrumentationImportedReplayFixture(t, arch)
+			needed, err := InstrumentationRequiresTypeSources(input)
+			if err != nil || !needed {
+				t.Fatalf("original source did not request its imported closure: %v", err)
+			}
+			if err := replayInstrumentationDeclarationLayouts(input, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+				t.Fatal(err)
+			}
+			encoded, err := json.Marshal(input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var roundtrip InstrumentationConsumerInput
+			if err := json.Unmarshal(encoded, &roundtrip); err != nil {
+				t.Fatal(err)
+			}
+			if err := replayInstrumentationDeclarationLayouts(&roundtrip, pkg, []InstrumentationDeclarationProof{declaration}); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestInstrumentationImportedTypeReplayRejectsMissingChangedAndPairedMetadata(t *testing.T) {
+	input, pkg, declaration := instrumentationImportedReplayFixture(t, "arm64")
+	encoded, err := json.Marshal(input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*InstrumentationConsumerInput){
+		"paired deletion":    func(p *InstrumentationConsumerInput) { p.TypeSources = nil },
+		"protocol downgrade": func(p *InstrumentationConsumerInput) { p.TypeSources.Protocol = "unverified" },
+		"input scope":        func(p *InstrumentationConsumerInput) { p.TypeSources.InputSHA256 = strings.Repeat("2", 64) },
+		"target":             func(p *InstrumentationConsumerInput) { p.Plan.Target = "linux/386" },
+		"SDK":                func(p *InstrumentationConsumerInput) { p.Observation.Early.BaselineFeatures.GoVersion = "go1.26.1" },
+		"module": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.ModulePath = "example.invalid/foreign"
+		},
+		"version": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.Version = "v1.2.3"
+		},
+		"replace origin": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.SourceRole = "owned_local_replace"
+		},
+		"import map missing": func(p *InstrumentationConsumerInput) { p.TypeSources.RootImportMap = map[string]string{} },
+		"import map changed": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.RootImportMap["example.invalid/replay/dep"] = "unsafe"
+		},
+		"package name": func(p *InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].Name = "forged" },
+		"export missing": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Dependency.Source.ExportSHA256 = ""
+		},
+		"source missing": func(p *InstrumentationConsumerInput) { p.TypeSources.Dependencies[0].Contents = nil },
+		"source changed": func(p *InstrumentationConsumerInput) {
+			p.TypeSources.Dependencies[0].Contents["dep/types.go"] += "\nconst Changed=1\n"
+		},
+		"paired source hash": func(p *InstrumentationConsumerInput) {
+			dep := &p.TypeSources.Dependencies[0]
+			dep.Contents["dep/types.go"] = strings.Replace(dep.Contents["dep/types.go"], "Length\n", "Length = 4\n", 1)
+			dep.Dependency.Source.GoSHA256["dep/types.go"] = bytesSHA256([]byte(dep.Contents["dep/types.go"]))
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed InstrumentationConsumerInput
+			if err := json.Unmarshal(encoded, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := replayInstrumentationDeclarationLayouts(&changed, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+				t.Fatal("changed original closure acquired imported declaration authority")
+			}
+		})
+	}
+	var layout plan9asm.FuncSig
+	if err := json.Unmarshal(declaration.Layout, &layout); err != nil {
+		t.Fatal(err)
+	}
+	layout.Frame.Params[0].Offset++
+	declaration.Layout, err = json.Marshal(layout)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := replayInstrumentationDeclarationLayouts(input, pkg, []InstrumentationDeclarationProof{declaration}); err == nil {
+		t.Fatal("paired producer/consumer layout bypassed original imported type replay")
+	}
+}
+
+func TestInstrumentationImportedTypeMetadataMustConsumeIndependentOriginalExportsAndSources(t *testing.T) {
+	input, _, _ := instrumentationImportedReplayFixture(t, "arm64")
+	dep := input.TypeSources.Dependencies[0].Dependency
+	header := GeneratedHeaderProof{ImportMap: input.TypeSources.RootImportMap}
+	for _, mutate := range []func(*InstrumentationDependencyExport){
+		func(p *InstrumentationDependencyExport) { p.Source.ExportSHA256 = strings.Repeat("3", 64) },
+		func(p *InstrumentationDependencyExport) { p.ImportMap = map[string]string{"unsafe": "unsafe"} },
+		func(p *InstrumentationDependencyExport) { p.Source.SourceModule = "example.invalid/other" },
+	} {
+		data, err := json.Marshal(dep)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var changed InstrumentationDependencyExport
+		if err := json.Unmarshal(data, &changed); err != nil {
+			t.Fatal(err)
+		}
+		mutate(&changed)
+		if err := validateInstrumentationTypeSourceAgreement(input, header, []InstrumentationDependencyExport{changed}); err == nil {
+			t.Fatal("paired metadata could replace the independent original input source/export/map")
+		}
+	}
+}
diff --git a/gotoolprofile/native_header_function_directives_test.go b/gotoolprofile/native_header_function_directives_test.go
new file mode 100644
index 000000000..155e91a9c
--- /dev/null
+++ b/gotoolprofile/native_header_function_directives_test.go
@@ -0,0 +1,81 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These directives affect ordinary function code, not the compiler's native
+// constant/type header projection. Actual compiler acceptance and all later
+// object/source consumers remain separate from this property query.
+func TestNativeHeaderOrdinaryFunctionDirectivesMatchActualCompiler(t *testing.T) {
+	for _, directive := range []string{"noinline", "nosplit", "noescape", "norace", "nocheckptr", "uintptrescapes"} {
+		t.Run(directive, func(t *testing.T) {
+			function := "func Body(value uintptr) uintptr { return value }\n"
+			if directive == "noescape" {
+				function = "func Body(value uintptr) uintptr\n"
+			}
+			source := "package header\nconst Count = 7\ntype Record struct { Value uint64; Tail byte }\n" +
+				"//go:" + directive + "\n" + function
+			for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+				t.Run(target, func(t *testing.T) {
+					actual := compileNativeHeaderRules(t, target, source)
+					sources := map[string]string{"header.go": source}
+					if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", target, "go1.20", sources); err != nil {
+						t.Fatalf("actual ordinary function directive forced unrelated CPU proposals: %v", err)
+					}
+					replayed, err := ReplayNativeGeneratedHeader("example.invalid/header", target, "go1.20", sources)
+					if err != nil || !reflect.DeepEqual(actual, replayed) {
+						t.Fatalf("actual complete header differs: actual=%v replay=%v error=%v", actual, replayed, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestNativeHeaderFunctionDirectivesRetainSourceRoles(t *testing.T) {
+	for name, source := range map[string]string{
+		"type attachment":     "package header\n//go:nosplit\ntype Record struct { Value uint64 }\n",
+		"constant attachment": "package header\n//go:noinline\nconst Count = 7\n",
+		"unattached":          "package header\n//go:nosplit\n\nfunc Body() {}\n",
+		"function body":       "package header\nfunc Body() {\n//go:noinline\n}\n",
+		"unknown":             "package header\n//go:unknown\nfunc Body() {}\n",
+		"arguments":           "package header\n//go:nosplit extra\nfunc Body() {}\n",
+		"special runtime":     "package header\n//go:systemstack\nfunc Body() {}\n",
+		"special barrier":     "package header\n//go:nowritebarrierrec\nfunc Body() {}\n",
+		"external symbol":     "package header\n//go:linkname Body other.Body\nfunc Body() {}\n",
+		"embedded data":       "package header\n//go:embed data\nvar Data string\n",
+		"cgo export":          "package header\n//go:cgo_export_static Body\nfunc Body() {}\n",
+		"wasm import":         "package header\n//go:wasmimport env Body\nfunc Body()\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			sources := map[string]string{"header.go": source}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/arm64", "go1.20", sources); !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unregistered directive/source role acquired property preflight: %v", err)
+			}
+			if properties, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/arm64", "go1.20", sources); properties != nil || !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unregistered directive/source role acquired header: %v %v", properties, err)
+			}
+		})
+	}
+
+	source := strings.Replace(nativeHeaderIndependentImportSource,
+		"func Holder()", "//go:nosplit\n//go:noinline\nfunc Holder()", 1)
+	imports := map[string]string{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe"}
+	for _, variant := range []string{source, strings.Replace(source, "Count = 7", "Count = 9", 1)} {
+		properties, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/arm64", "go1.20",
+			map[string]string{"header.go": variant}, imports)
+		if err != nil || properties["const_Count"] == "" || properties["Record_Tail"] != "8" {
+			t.Fatalf("function-only directive lost original imported property roots: %v %v", properties, err)
+		}
+		want := "7"
+		if variant != source {
+			want = "9"
+		}
+		if properties["const_Count"] != want {
+			t.Fatal("directive property replay hid a changed original constant")
+		}
+	}
+}
diff --git a/gotoolprofile/native_header_generic_roots_test.go b/gotoolprofile/native_header_generic_roots_test.go
new file mode 100644
index 000000000..71a406166
--- /dev/null
+++ b/gotoolprofile/native_header_generic_roots_test.go
@@ -0,0 +1,140 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// The import is outside the header property closure, while the mutually
+// referring generic declarations have no uninstantiated native properties.
+// Retain an ordinary alias and constant so omitting every type cannot pass.
+const nativeHeaderUninstantiatedRootsSource = `package header
+import dep "example.invalid/dependency"
+var unused = dep.New("initializer")
+type Frame[R, S any] struct { ctx *State[R, S] }
+type State[R, S any] struct { recv R; send S; inner[R] }
+type inner[R any] struct { next chan R }
+type Constrained[T interface { ~uint64 | ~string }] struct { Value T }
+type Record struct { Value uint64; Tail byte }
+type Alias = Record
+const Count = 7
+//go:noinline
+//go:nosplit
+func Holder() { _ = dep.New("body") }
+`
+
+func TestNativeHeaderUninstantiatedGenericRootsMatchActualCompiler(t *testing.T) {
+	dependencies := map[string]string{
+		"example.invalid/dependency": "package dependency\nfunc New(value string) string { return value }\n",
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRulesWithImports(t, target, nativeHeaderUninstantiatedRootsSource, dependencies)
+			if len(actual) != 7 || actual["Record__size"] == "" || actual["Alias__size"] == "" || actual["const_Count"] != "7" {
+				t.Fatalf("actual compiler did not retain exactly the ordinary native properties: %v", actual)
+			}
+			for name := range actual {
+				for _, generic := range []string{"Frame", "State", "inner", "Constrained"} {
+					if strings.HasPrefix(name, generic+"_") {
+						t.Fatalf("actual compiler emitted an uninstantiated generic property: %s", name)
+					}
+				}
+			}
+			t.Logf("ACTUAL_GO_UNINSTANTIATED_HEADER target=%s definitions=%v", target, actual)
+			sources := map[string]string{"header.go": nativeHeaderUninstantiatedRootsSource}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", target, "go1.20", sources); err != nil {
+				t.Fatalf("uninstantiated declaration forced unrelated native property queries: %v", err)
+			}
+			imports := map[string]string{"example.invalid/dependency": "example.invalid/dependency"}
+			replayed, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20", sources, imports)
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("complete native property projection differs: actual=%v replay=%v error=%v", actual, replayed, err)
+			}
+		})
+	}
+}
+
+func TestNativeHeaderGenericRootsRetainConcreteAndForeignDependencies(t *testing.T) {
+	for name, suffix := range map[string]string{
+		"concrete alias":         "type Concrete = Frame[uint64, string]\n",
+		"concrete field":         "type Concrete struct { Value Frame[uint64, string] }\n",
+		"concrete named type":    "type Concrete Frame[uint64, string]\n",
+		"concrete sizeof":        "const Width = u.Sizeof(Frame[uint64, string]{})\n",
+		"foreign type":           "type Foreign dep.Record\n",
+		"foreign field":          "type Foreign struct { Value dep.Record }\n",
+		"foreign array constant": "type Foreign struct { Value [dep.Count]byte }\n",
+		"foreign constant":       "const Foreign = dep.Count\n",
+		"unknown ordinary name":  "type Unknown struct { Value Missing }\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := strings.Replace(nativeHeaderUninstantiatedRootsSource,
+				"import dep \"example.invalid/dependency\"", "import dep \"example.invalid/dependency\"\nimport u \"unsafe\"", 1)
+			sources := map[string]string{"header.go": source + suffix}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/amd64", "go1.20", sources); !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unclosed concrete property was omitted: %v", err)
+			}
+			definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", "linux/amd64", "go1.20", sources,
+				map[string]string{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe"})
+			if definitions != nil || !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unclosed concrete property acquired a partial header: %v %v", definitions, err)
+			}
+		})
+	}
+}
+
+func TestNativeHeaderConcreteGenericRootsRequireCompleteClosure(t *testing.T) {
+	source := strings.Replace(nativeHeaderUninstantiatedRootsSource,
+		"import dep \"example.invalid/dependency\"", "import dep \"example.invalid/dependency\"\nimport u \"unsafe\"", 1) + `
+type Concrete = Frame[uint64, string]
+type Named Frame[uint64, string]
+type Nested struct { Value State[uint32, byte] }
+const Width = u.Sizeof(Frame[uint64, string]{})
+`
+	dependencies := map[string]string{
+		"example.invalid/dependency": "package dependency\nfunc New(value string) string { return value }\n",
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRulesWithImports(t, target, source, dependencies)
+			for _, property := range []string{"Concrete__size", "Named__size", "Nested__size", "const_Width"} {
+				if actual[property] == "" {
+					t.Fatalf("actual compiler omitted required concrete generic property %s: %v", property, actual)
+				}
+			}
+			// This finite adapter does not close instantiated declarations
+			// when foreign imports require selective AST replay. It must fail
+			// the entire query, never emit just the independent Record subset.
+			definitions, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20",
+				map[string]string{"header.go": source},
+				map[string]string{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe"})
+			if definitions != nil || !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("required native properties became a partial header: actual=%v replay=%v error=%v", actual, definitions, err)
+			}
+		})
+	}
+}
+
+func TestNativeHeaderGenericRootsRetainMalformedAndUnknownRoles(t *testing.T) {
+	for name, suffix := range map[string]string{
+		"duplicate generic":  "type Frame[T any] struct { Value T }\n",
+		"duplicate ordinary": "type Record struct {}\n",
+		"malformed generic":  "type Broken[T any struct {}\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			sources := map[string]string{"header.go": nativeHeaderUninstantiatedRootsSource + suffix}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/amd64", "go1.20", sources); err == nil || NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("invalid source was omitted or hidden as a domain fallback: %v", err)
+			}
+		})
+	}
+	for _, directive := range []string{"unknown", "linkname Holder other.Holder", "systemstack"} {
+		t.Run(directive, func(t *testing.T) {
+			source := strings.Replace(nativeHeaderUninstantiatedRootsSource, "//go:noinline", "//go:"+directive, 1)
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/amd64", "go1.20",
+				map[string]string{"header.go": source}); !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("generic omission laundered an unknown source role: %v", err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/native_header_roots.go b/gotoolprofile/native_header_roots.go
new file mode 100644
index 000000000..7432f7605
--- /dev/null
+++ b/gotoolprofile/native_header_roots.go
@@ -0,0 +1,90 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/ast"
+	"strconv"
+)
+
+// Native header queries and same-mode declaration queries share the original
+// AST closure machinery, not their consumer capabilities. Every constant and
+// nongeneric type root is retained. An uninstantiated generic declaration has
+// no native header definitions, just like variable initializers and function
+// bodies. Actual compiler acceptance remains independently required.
+func requireNativeHeaderRoots(root *instrumentationDeclarationReplay) error {
+	for name := range root.constants {
+		if err := root.requireName(name); err != nil {
+			return err
+		}
+	}
+	for name, declaration := range root.types {
+		if declaration.TypeParams != nil && len(declaration.TypeParams.List) != 0 {
+			// Go omits these from AsmHdrDecls. This only removes a top-level
+			// property root: a concrete alias, field or constant referring to
+			// the declaration must still close through requireName/requireType.
+			// Do not broaden the shared instrumentation type/ABI contract.
+			continue
+		}
+		if err := root.requireName(name); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// This adapter only closes properties independent of foreign declarations.
+// Imported constants/types still need a separately authenticated source graph;
+// an actual export digest alone cannot supply their independent property replay.
+func nativeHeaderIndependentFiles(files []*ast.File) ([]*ast.File, error) {
+	foreign := false
+	for _, file := range files {
+		for _, spec := range file.Imports {
+			spelling, err := strconv.Unquote(spec.Path.Value)
+			if err != nil {
+				return nil, fmt.Errorf("native header original import path is invalid: %w", err)
+			}
+			foreign = foreign || spelling != "unsafe"
+		}
+	}
+	if !foreign {
+		return files, nil
+	}
+
+	root := &instrumentationDeclarationReplay{
+		files: files, functions: make(map[string]*ast.FuncDecl),
+		types: make(map[string]*ast.TypeSpec), constants: make(map[string]*ast.GenDecl),
+		other: make(map[string]bool), needed: make(map[ast.Node]bool),
+	}
+	for _, file := range files {
+		if err := root.index(file); err != nil {
+			return nil, err
+		}
+	}
+	root.selector = func(expression *ast.SelectorExpr) error {
+		qualifier, ok := expression.X.(*ast.Ident)
+		if !ok {
+			return fmt.Errorf("native property selector is not a direct original import")
+		}
+		for _, file := range files {
+			if expression.Pos() < file.Pos() || expression.End() > file.End() {
+				continue
+			}
+			for _, spec := range file.Imports {
+				spelling, _ := strconv.Unquote(spec.Path.Value) // Checked above.
+				name := spelling
+				if spec.Name != nil {
+					name = spec.Name.Name
+				}
+				if spelling == "unsafe" && name == qualifier.Name {
+					root.needed[spec] = true
+					return nil
+				}
+			}
+		}
+		return fmt.Errorf("native header property needs an authenticated imported declaration")
+	}
+	if err := requireNativeHeaderRoots(root); err != nil {
+		return nil, &nativeHeaderUnsupportedDomain{err.Error()}
+	}
+	return root.selectedFiles(), nil
+}
diff --git a/gotoolprofile/native_header_roots_test.go b/gotoolprofile/native_header_roots_test.go
new file mode 100644
index 000000000..44222972c
--- /dev/null
+++ b/gotoolprofile/native_header_roots_test.go
@@ -0,0 +1,110 @@
+package gotoolprofile
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const nativeHeaderIndependentImportSource = `package header
+
+import (
+	dep "example.invalid/dependency"
+	word "unsafe"
+)
+
+var unusedByHeader = dep.New("initializer")
+
+type Record struct { Value uint64; Tail byte }
+type Alias = Record
+const Count = 7
+const Word = word.Sizeof(uintptr(0))
+
+func Holder() { _ = dep.New("function body") }
+`
+
+func TestNativeHeaderPropertyRootsRetainCompleteDefinitionsAndImports(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			sources := map[string]string{"header.go": nativeHeaderIndependentImportSource}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", target, "go1.20", sources); err != nil {
+				t.Fatal(err)
+			}
+			imports := map[string]string{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe"}
+			got, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20", sources, imports)
+			word, size := "8", "16"
+			if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+				word, size = "4", "12"
+			}
+			want := map[string]string{
+				"const_Count": "7", "const_Word": word,
+				"Record__size": size, "Record_Value": "0", "Record_Tail": "8",
+				"Alias__size": size, "Alias_Value": "0", "Alias_Tail": "8",
+			}
+			if err != nil || !reflect.DeepEqual(got, want) {
+				t.Fatalf("complete independent properties: got=%v want=%v error=%v", got, want, err)
+			}
+			for _, changed := range []map[string]string{
+				nil,
+				{"unsafe": "unsafe"},
+				{"example.invalid/dependency": "example.invalid/dependency"},
+				{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "foreign/unsafe"},
+				{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe", "extra": "extra"},
+			} {
+				if _, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20", sources, changed); err == nil {
+					t.Fatal("omitted/extra/changed complete original import map acquired properties")
+				}
+			}
+		})
+	}
+}
+
+func TestNativeHeaderPropertyRootsMatchActualImportedCompilerHeaders(t *testing.T) {
+	dependencies := map[string]string{
+		"example.invalid/dependency": "package dependency\nfunc New(value string) string { return value }\n",
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			actual := compileNativeHeaderRulesWithImports(t, target, nativeHeaderIndependentImportSource, dependencies)
+			replayed, err := ReplayNativeGeneratedHeaderWithImportMap("example.invalid/header", target, "go1.20",
+				map[string]string{"header.go": nativeHeaderIndependentImportSource},
+				map[string]string{"example.invalid/dependency": "example.invalid/dependency", "unsafe": "unsafe"})
+			if err != nil || !reflect.DeepEqual(actual, replayed) {
+				t.Fatalf("actual complete imported-source header differs: actual=%v replay=%v error=%v", actual, replayed, err)
+			}
+		})
+	}
+}
+
+func TestNativeHeaderPropertyRootsKeepDependentImportsConservative(t *testing.T) {
+	for name, suffix := range map[string]string{
+		"constant":         "const Imported = dep.Value\n",
+		"array length":     "type Imported struct { Values [dep.Count]byte }\n",
+		"named type":       "type Imported dep.Record\n",
+		"struct field":     "type Imported struct { Value dep.Record }\n",
+		"local variable":   "const Imported = word.Sizeof(unusedByHeader)\n",
+		"concrete generic": "type Generic[T any] struct { Value T }\ntype Concrete = Generic[uint64]\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			sources := map[string]string{"header.go": nativeHeaderIndependentImportSource + suffix}
+			if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/arm64", "go1.20", sources); !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unclosed property preflight did not remain conservative: %v", err)
+			}
+			if got, err := ReplayNativeGeneratedHeader("example.invalid/header", "linux/arm64", "go1.20", sources); got != nil || !NativeHeaderSourceDomainUnsupported(err) {
+				t.Fatalf("unclosed property acquired definitions: %v %v", got, err)
+			}
+		})
+	}
+}
+
+func TestNativeHeaderPropertyRootsDoNotHideMalformedSource(t *testing.T) {
+	for _, source := range []string{
+		nativeHeaderIndependentImportSource + "type Record struct {}\n",
+		nativeHeaderIndependentImportSource + "const Invalid = (\n",
+	} {
+		sources := map[string]string{"header.go": source}
+		if err := PreflightNativeGeneratedHeaderSource("example.invalid/header", "linux/arm64", "go1.20", sources); err == nil || NativeHeaderSourceDomainUnsupported(err) {
+			t.Fatalf("malformed source became a conservative successful query: %v", err)
+		}
+	}
+}
diff --git a/gotoolprofile/observation.go b/gotoolprofile/observation.go
new file mode 100644
index 000000000..fc9dd924c
--- /dev/null
+++ b/gotoolprofile/observation.go
@@ -0,0 +1,45 @@
+package gotoolprofile
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmmacros"
+)
+
+// Observation is the canonical source/tool-provenance feature evidence shared
+// by producers and compiler consumers. It is not a runtime-coverage claim.
+type Observation struct {
+	Protocol               string            `json:"protocol"`
+	Target                 string            `json:"target"`
+	Environment            map[string]string `json:"environment"`
+	GoVersion              string            `json:"go_version"`
+	DriverSHA256           string            `json:"driver_sha256"`
+	ToolDirectory          string            `json:"tool_directory"`
+	ToolBinarySHA256       map[string]string `json:"tool_binary_sha256"`
+	ToolBinaryOrigins      map[string]string `json:"tool_binary_origins"`
+	ToolRoutingSHA256      string            `json:"tool_routing_sha256"`
+	ToolDispatcherSHA256   string            `json:"tool_dispatcher_sha256"`
+	ToolSourceSHA256       map[string]string `json:"tool_source_sha256"`
+	ToolTags               []string          `json:"tool_tags"`
+	MarkerSelection        map[string]bool   `json:"marker_selection"`
+	MarkerSourceSHA256     string            `json:"marker_source_sha256"`
+	DriverSelectionSHA256  string            `json:"driver_selection_sha256"`
+	EnvStderrSHA256        string            `json:"env_stderr_sha256"`
+	EnvRecheckStderrSHA256 string            `json:"env_recheck_stderr_sha256"`
+	ListStderrSHA256       string            `json:"list_stderr_sha256"`
+}
+
+func ProfileID(observed *Observation) string {
+	data, _ := json.Marshal(observed)
+	return bytesSHA256(data)
+}
+
+func bytesSHA256(data []byte) string {
+	return fmt.Sprintf("%x", sha256.Sum256(data))
+}
+
+func goMinor(version string) (int, error) {
+	return goasmmacros.GoMinor(version)
+}
diff --git a/gotoolprofile/ordinary_dependency_sources.go b/gotoolprofile/ordinary_dependency_sources.go
new file mode 100644
index 000000000..a713f43ee
--- /dev/null
+++ b/gotoolprofile/ordinary_dependency_sources.go
@@ -0,0 +1,97 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"reflect"
+)
+
+const OrdinaryDependencyProtocol = "actual_go_ordinary_dependency_sources_v1"
+
+// OrdinaryDependencyProof binds every ordinary import edge and every package's
+// positive or empty embed selection. It never provides a test-variant role or
+// an assembly/output receipt for dependency packages.
+type OrdinaryDependencyProof struct {
+	Protocol         string                 `json:"protocol"`
+	Candidate        SourceInventory        `json:"candidate_sources"`
+	Packages         []SourcePackageProof   `json:"source_packages"`
+	ExternalPackages []SourcePackageProof   `json:"external_source_packages"`
+	SourceModules    []ModuleSourceSnapshot `json:"dependency_source_roots"`
+}
+
+func inventoryInput(input *ConsumerInput, inventory SourceInventory) *ConsumerInput {
+	view := *input
+	view.Sources, view.Headers = inventory.Sources, inventory.Headers
+	view.Directories = make(map[string][]string)
+	for dir, entries := range inventory.Directories {
+		view.Directories[dir] = []string{}
+		for _, entry := range entries {
+			view.Directories[dir] = append(view.Directories[dir], entry.Name)
+		}
+	}
+	return &view
+}
+
+func ValidateOrdinaryDependencies(input *ConsumerInput, metadata *MetadataProof, tags []string) error {
+	if input == nil || input.Observed == nil || metadata == nil {
+		return fmt.Errorf("ordinary dependency validation lacks source/profile metadata")
+	}
+	proof := metadata.Dependencies
+	if proof == nil || proof.Protocol != OrdinaryDependencyProtocol || len(proof.Packages) == 0 {
+		return fmt.Errorf("ordinary metadata lacks its complete dependency source role")
+	}
+	if err := ValidateSourceInventory(proof.Candidate); err != nil {
+		return err
+	}
+	view := inventoryInput(input, proof.Candidate)
+	for file, digest := range proof.Candidate.Sources {
+		if previous, found := input.Sources[file]; found && previous != digest {
+			return fmt.Errorf("ordinary dependency candidate bytes conflict with original inputs")
+		}
+	}
+	for dir, entries := range view.Directories {
+		if previous, found := input.Directories[dir]; found && !reflect.DeepEqual(previous, entries) {
+			return fmt.Errorf("ordinary dependency candidate membership conflicts with original inputs")
+		}
+	}
+	modules, err := sourceModuleSnapshots(input, proof.SourceModules)
+	if err != nil {
+		return err
+	}
+	roots := make(map[string]bool)
+	byPath := make(map[string]SourcePackageProof)
+	for _, source := range append(append([]SourcePackageProof(nil), proof.Packages...), proof.ExternalPackages...) {
+		byPath[source.Package.PackagePath] = source
+	}
+	for _, pkg := range metadata.Packages {
+		source, found := byPath[pkg.PackagePath]
+		actual := pkg
+		actual.Macros = nil
+		if !found || source.SourceRootID != "" || !reflect.DeepEqual(source.Package, actual) {
+			return fmt.Errorf("ordinary header root differs from its complete source closure")
+		}
+		roots[pkg.PackagePath] = true
+	}
+	if err := validatePackageSourceClosure(view, proof.Packages, proof.ExternalPackages, modules, roots, tags, false); err != nil {
+		return fmt.Errorf("ordinary dependency closure: %w", err)
+	}
+	for _, header := range metadata.Headers {
+		source := byPath[header.PackagePath]
+		if !reflect.DeepEqual(source.ImportMap, header.ImportMap) {
+			return fmt.Errorf("ordinary compiler import map differs from its complete source closure")
+		}
+		for _, imported := range header.Imports {
+			dep := byPath[imported.PackagePath]
+			pkg := dep.Package
+			goSHA := make(map[string]string)
+			for _, file := range pkg.CompiledGoFiles {
+				goSHA[file] = pkg.SourceSHA256[file]
+			}
+			if imported.ModulePath != pkg.ModulePath || imported.Version != pkg.ModuleVersion ||
+				imported.SourceModule != pkg.SourceModule || imported.SourceVersion != pkg.SourceVersion || imported.SourceRole != pkg.SourceRole ||
+				!reflect.DeepEqual(imported.GoSHA256, goSHA) || dep.SourceRootID != "" && imported.ExportSHA256 != dep.ExportSHA256 {
+				return fmt.Errorf("ordinary header export differs from bound dependency source/role")
+			}
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/ordinary_dependency_sources_test.go b/gotoolprofile/ordinary_dependency_sources_test.go
new file mode 100644
index 000000000..a92810840
--- /dev/null
+++ b/gotoolprofile/ordinary_dependency_sources_test.go
@@ -0,0 +1,169 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func ordinarySourceClosureFixture(t *testing.T) (*ConsumerInput, *MetadataProof, string) {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod":        "module example.invalid/ordinary\n\ngo 1.20\n",
+		"root.go":       "package ordinary\nimport _ \"example.invalid/ordinary/dep\"\n",
+		"dep/dep.go":    "package dep\nimport _ \"embed\"\n//go:embed asset.bin\nvar Asset []byte\n",
+		"dep/asset.bin": "original asset\n",
+	}
+	for file, text := range files {
+		filename := filepath.Join(root, filepath.FromSlash(file))
+		if err := os.MkdirAll(filepath.Dir(filename), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(filename, []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	var inventory SourceInventory
+	if err := CaptureSourceDirectory(context.Background(), &inventory, root, root, true); err != nil {
+		t.Fatal(err)
+	}
+	input := inventoryInput(&ConsumerInput{Module: "example.invalid/ordinary", Observed: &Observation{
+		Target: "linux/amd64", GoVersion: "go1.27.1", Environment: map[string]string{"GOOS": "linux", "GOARCH": "amd64"},
+	}}, inventory)
+	makePackage := func(name, file string) SourcePackageProof {
+		pkg := PackageProof{PackagePath: name, ModulePath: input.Module, SourceModule: input.Module, SourceRole: "main",
+			GoFiles: []string{file}, CompiledGoFiles: []string{file}, SourceSHA256: map[string]string{file: inventory.Sources[file]},
+		}
+		return SourcePackageProof{Package: pkg, VariantID: name, ImportMap: make(map[string]string)}
+	}
+	rootPackage := makePackage(input.Module, "root.go")
+	rootPackage.ImportMap[input.Module+"/dep"] = input.Module + "/dep"
+	rootPackage.Embed, err = CaptureTestEmbedSelection(rootPackage.Package, root, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dep := makePackage(input.Module+"/dep", "dep/dep.go")
+	dep.ImportMap["embed"] = "embed"
+	dep.Embed, err = CaptureTestEmbedSelection(dep.Package, root, []string{"asset.bin"}, []string{"dep/asset.bin"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	stdlib := ModuleSourceSnapshot{Protocol: TestDependencyModuleProtocol, GoVersion: input.Observed.GoVersion,
+		Sources:     map[string]string{"embed/embed.go": bytesSHA256([]byte("package embed\n"))},
+		Headers:     map[string]string{"embed/embed.go": "package embed\n"},
+		Directories: map[string][]TestSourceEntry{".": {{Name: "embed", Kind: "directory"}}, "embed": {{Name: "embed.go", Kind: "file", SHA256: bytesSHA256([]byte("package embed\n"))}}},
+	}
+	embed := SourcePackageProof{Package: PackageProof{PackagePath: "embed", SourceRole: "stdlib", GoFiles: []string{"embed/embed.go"}, CompiledGoFiles: []string{"embed/embed.go"}, SourceSHA256: stdlib.Sources},
+		VariantID: "embed", ImportMap: map[string]string{}, SourceRootID: stdlib.ID(), ExportSHA256: strings.Repeat("a", 64),
+		Embed: &EmbedSelection{Protocol: TestEmbedProtocol, Directives: map[string]string{"embed/embed.go": ""}, Files: map[string]string{}},
+	}
+	metadata := &MetadataProof{Dependencies: &OrdinaryDependencyProof{Protocol: OrdinaryDependencyProtocol,
+		Candidate: inventory, Packages: []SourcePackageProof{rootPackage, dep}, ExternalPackages: []SourcePackageProof{embed}, SourceModules: []ModuleSourceSnapshot{stdlib}},
+		Packages: []PackageProof{rootPackage.Package}, Headers: []GeneratedHeaderProof{{PackagePath: input.Module, ImportMap: rootPackage.ImportMap,
+			Imports: []ImportExport{{ImportPath: dep.Package.PackagePath, PackagePath: dep.Package.PackagePath, ModulePath: input.Module, SourceModule: input.Module, SourceRole: "main", GoSHA256: dep.Package.SourceSHA256, ExportSHA256: strings.Repeat("b", 64)}}}},
+	}
+	if err := ValidateOrdinaryDependencies(input, metadata, nil); err != nil {
+		t.Fatal(err)
+	}
+	return input, metadata, root
+}
+
+func TestOrdinaryDependencyCompleteClosureRejectsMutation(t *testing.T) {
+	input, proof, _ := ordinarySourceClosureFixture(t)
+	data, err := json.Marshal(proof)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*MetadataProof){
+		"missing role":            func(p *MetadataProof) { p.Dependencies = nil },
+		"test role":               func(p *MetadataProof) { p.Dependencies.Protocol = TestDependencyProtocol },
+		"missing empty selection": func(p *MetadataProof) { p.Dependencies.Packages[0].Embed = nil },
+		"missing selected asset":  func(p *MetadataProof) { p.Dependencies.Packages[1].Embed.Files = map[string]string{} },
+		"extra selected asset": func(p *MetadataProof) {
+			p.Dependencies.Packages[1].Embed.Files["root.go"] = p.Dependencies.Candidate.Sources["root.go"]
+		},
+		"missing original pattern":   func(p *MetadataProof) { p.Dependencies.Packages[1].Embed.Patterns = nil },
+		"test variant":               func(p *MetadataProof) { p.Dependencies.Packages[1].VariantID += " [test]" },
+		"foreign dependency removed": func(p *MetadataProof) { p.Dependencies.ExternalPackages = nil },
+		"foreign inventory removed":  func(p *MetadataProof) { p.Dependencies.SourceModules = nil },
+		"transitive edge removed":    func(p *MetadataProof) { p.Dependencies.Packages[1].ImportMap = map[string]string{} },
+		"transitive edge changed":    func(p *MetadataProof) { p.Dependencies.Packages[1].ImportMap["embed"] = "missing" },
+		"new generated source": func(p *MetadataProof) {
+			p.Dependencies.Packages[1].Package.CompiledGoFiles = []string{"dep/generated.go"}
+		},
+		"candidate directory omitted": func(p *MetadataProof) { delete(p.Dependencies.Candidate.Directories, "dep") },
+		"candidate bytes changed":     func(p *MetadataProof) { p.Dependencies.Candidate.Sources["dep/asset.bin"] = strings.Repeat("f", 64) },
+		"unbound export":              func(p *MetadataProof) { p.Dependencies.ExternalPackages[0].ExportSHA256 = "" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			var changed MetadataProof
+			if err := json.Unmarshal(data, &changed); err != nil {
+				t.Fatal(err)
+			}
+			mutate(&changed)
+			if err := ValidateOrdinaryDependencies(input, &changed, nil); err == nil {
+				t.Fatal("changed ordinary source/selection/role accepted")
+			}
+		})
+	}
+}
+
+func TestOrdinarySourceInventoryLiveGuards(t *testing.T) {
+	for _, axis := range []string{"bytes", "new file", "missing file", "symlink", "header", "cancelled"} {
+		t.Run(axis, func(t *testing.T) {
+			_, proof, root := ordinarySourceClosureFixture(t)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			asset := filepath.Join(root, "dep", "asset.bin")
+			switch axis {
+			case "bytes":
+				if err := os.WriteFile(asset, []byte("changed"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "new file":
+				if err := os.WriteFile(filepath.Join(root, "dep", "new.bin"), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "missing file":
+				if err := os.Remove(asset); err != nil {
+					t.Fatal(err)
+				}
+			case "symlink":
+				if err := os.Remove(asset); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(filepath.Join(root, "root.go"), asset); err != nil {
+					t.Fatal(err)
+				}
+			case "header":
+				proof.Dependencies.Candidate.Headers["root.go"] = "package fake\n"
+			case "cancelled":
+				cancel()
+			}
+			if err := VerifySourceInventory(ctx, proof.Dependencies.Candidate, root); err == nil {
+				t.Fatal("changed original source inventory accepted")
+			}
+		})
+	}
+}
+
+func TestSourceInventoryCaptureRejectsIncompleteAndOversizedProjection(t *testing.T) {
+	_, _, root := ordinarySourceClosureFixture(t)
+	for _, inventory := range []SourceInventory{
+		{Sources: map[string]string{}},
+		{Headers: map[string]string{}},
+		{Directories: map[string][]TestSourceEntry{}},
+		{Sources: map[string]string{}, Headers: map[string]string{}, Directories: map[string][]TestSourceEntry{"unrelated": make([]TestSourceEntry, 65536)}},
+	} {
+		if err := CaptureSourceDirectory(context.Background(), &inventory, root, root, false); err == nil {
+			t.Fatal("incomplete/unbounded source projection was silently initialized or expanded")
+		}
+	}
+}
diff --git a/gotoolprofile/portable_selection_paths_test.go b/gotoolprofile/portable_selection_paths_test.go
new file mode 100644
index 000000000..ab2737f70
--- /dev/null
+++ b/gotoolprofile/portable_selection_paths_test.go
@@ -0,0 +1,74 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"go/build"
+	"path"
+	"strings"
+	"testing"
+)
+
+func TestPortableSelectionDoesNotInheritHostJoinPath(t *testing.T) {
+	input, proof, _ := ordinarySourceClosureFixture(t)
+	// These maps contain portable module-relative names, not host filenames.
+	// Exercise the Windows failure on every host without changing source keys.
+	original := build.Default
+	build.Default.JoinPath = func(elements ...string) string {
+		return strings.ReplaceAll(path.Join(elements...), "/", "\\")
+	}
+	t.Cleanup(func() { build.Default = original })
+
+	t.Run("ordinary dependency and embed closure", func(t *testing.T) {
+		if err := ValidateOrdinaryDependencies(input, proof, nil); err != nil {
+			t.Fatal(err)
+		}
+	})
+	t.Run("ordinary package selection", func(t *testing.T) {
+		ctx, err := ordinaryPackageSelectionContext(input, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		selected, err := ctx.MatchFile("dep", "dep.go")
+		if err != nil || !selected {
+			t.Fatalf("portable nested source selection = %v, %v", selected, err)
+		}
+	})
+	t.Run("instrumentation package selection", func(t *testing.T) {
+		early := &InstrumentationEarlyObservation{
+			SourceRules: &InstrumentationSourceProof{GoVersion: "go1.27.2"},
+			Environment: input.Observed.Environment, BaselineFeatures: input.Observed,
+		}
+		sources := &InstrumentationOriginalSourceInventory{Contents: input.Headers}
+		ctx, err := instrumentationOriginalBuildContext(sources, early, nil, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		selected, err := ctx.MatchFile("dep", "dep.go")
+		if err != nil || !selected {
+			t.Fatalf("portable instrumentation selection = %v, %v", selected, err)
+		}
+	})
+	t.Run("supplemental test declaration", func(t *testing.T) {
+		input := &ConsumerInput{
+			Module: "example.invalid/portable", Observed: input.Observed,
+			Headers: map[string]string{
+				"nested/base.go":       "package nested\n",
+				"nested/value_test.go": "package nested\nfunc Value()\n",
+			},
+			Directories: map[string][]string{"nested": {"base.go", "value_test.go", "value.s"}},
+			Sources:     map[string]string{"nested/base.go": "base", "nested/value_test.go": "test", "nested/value.s": "asm"},
+		}
+		pkg := PackageProof{PackagePath: input.Module + "/nested", GoFiles: []string{"nested/base.go"},
+			SFiles: []string{"nested/value.s"}, SourceSHA256: map[string]string{"nested/base.go": "base"}}
+		proof := TestDeclarationProof{
+			Protocol: TestDeclarationProtocol, PackagePath: pkg.PackagePath, VariantID: pkg.PackagePath + " [" + pkg.PackagePath + ".test]",
+			Target: input.Observed.Target, GoVersion: input.Observed.GoVersion, ExportSHA256: strings.Repeat("a", 64),
+			GoFiles: []string{"nested/base.go", "nested/value_test.go"}, CompiledGoFiles: []string{"nested/base.go", "nested/value_test.go"},
+			SFiles: pkg.SFiles, SourceSHA256: input.Sources, ImportMap: map[string]string{},
+			Declarations: []TestDeclaration{{Symbol: pkg.PackagePath + ".Value", File: "nested/value_test.go", GoType: "func()", Layout: json.RawMessage(`{}`)}},
+		}
+		if err := validateTestDeclaration(input, []PackageProof{pkg}, proof, nil); err != nil {
+			t.Fatal(err)
+		}
+	})
+}
diff --git a/gotoolprofile/proof.go b/gotoolprofile/proof.go
new file mode 100644
index 000000000..1baafb7d5
--- /dev/null
+++ b/gotoolprofile/proof.go
@@ -0,0 +1,119 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+// Offline replay verifies a source/tool-provenance-validated observation. It
+// does not authenticate the Go binary or source bytes without the producer's
+// actual-driver and actual-source checks.
+func validateDiscoveryTargetFeatures(features *discoveryTargetFeatures) error {
+	if features == nil || features.Protocol != "go_driver_builtin_features_v2" {
+		return fmt.Errorf("missing actual Go driver builtin-feature protocol")
+	}
+	parts := strings.Split(features.Target, "/")
+	minor, err := goMinor(features.GoVersion)
+	if len(parts) != 2 || err != nil || minor < 20 || minor > 27 || features.GoVersion != features.Environment["GOVERSION"] ||
+		features.Environment["GOOS"] != parts[0] || features.Environment["GOARCH"] != parts[1] || features.Environment["CGO_ENABLED"] != "0" {
+		return fmt.Errorf("actual feature environment/version does not match its target")
+	}
+	if err := validateTarget(features.Target); err != nil {
+		return err
+	}
+	if len(features.Environment) != len(discoveryFeatureEnvKeys)-3 {
+		return fmt.Errorf("incomplete or nonportable actual feature environment")
+	}
+	for _, key := range discoveryFeatureEnvKeys {
+		if key != "GOROOT" && key != "GOTOOLDIR" && key != "GOCACHE" {
+			if _, present := features.Environment[key]; !present {
+				return fmt.Errorf("missing actual feature environment key %s", key)
+			}
+		}
+	}
+	if !validDiscoveryFeatureToolDirectory(features.ToolDirectory) ||
+		len(features.ToolBinarySHA256) != len(discoveryFeatureSubtools) ||
+		len(features.ToolBinaryOrigins) != len(discoveryFeatureSubtools) ||
+		!discoverySHA256Pattern.MatchString(features.ToolRoutingSHA256) ||
+		!discoverySHA256Pattern.MatchString(features.ToolDispatcherSHA256) {
+		return fmt.Errorf("missing actual Go subtool identity")
+	}
+	for _, name := range discoveryFeatureSubtools {
+		if !discoverySHA256Pattern.MatchString(features.ToolBinarySHA256[name]) {
+			return fmt.Errorf("missing actual Go %s tool identity", name)
+		}
+		suffix := ""
+		if strings.HasPrefix(strings.TrimPrefix(features.ToolDirectory, "pkg/tool/"), "windows_") {
+			suffix = ".exe"
+		}
+		origin := features.ToolBinaryOrigins[name]
+		if origin != "goroot/"+features.ToolDirectory+"/"+name+suffix &&
+			!(minor >= 25 && (name == "nm" || name == "vet") && origin == "gocache/builtin/cmd/"+name) {
+			return fmt.Errorf("unrecognized actual Go %s tool origin", name)
+		}
+	}
+	for _, digest := range []string{features.DriverSHA256, features.MarkerSourceSHA256, features.DriverSelectionSHA256, features.EnvStderrSHA256, features.EnvRecheckStderrSHA256, features.ListStderrSHA256} {
+		if !discoverySHA256Pattern.MatchString(digest) {
+			return fmt.Errorf("missing actual driver/marker/command identity")
+		}
+	}
+	if len(features.ToolSourceSHA256) != 3 {
+		return fmt.Errorf("incomplete actual Go feature-registration source identity")
+	}
+	for _, file := range []string{"VERSION", "src/internal/buildcfg/cfg.go", "src/internal/goexperiment/flags.go"} {
+		if !discoverySHA256Pattern.MatchString(features.ToolSourceSHA256[file]) {
+			return fmt.Errorf("missing actual feature-registration source %s", file)
+		}
+	}
+	cpuKey := map[string]string{"386": "GO386", "amd64": "GOAMD64", "arm": "GOARM", "arm64": "GOARM64", "wasm": "GOWASM"}[parts[1]]
+	if cpuKey == "" || validateDiscoveryCPUEnvironment(parts[1], features.Environment[cpuKey], minor) != nil {
+		return fmt.Errorf("invalid actual target CPU profile")
+	}
+	for _, key := range []string{"GO386", "GOAMD64", "GOARM", "GOARM64", "GOWASM"} {
+		if key != cpuKey && features.Environment[key] != "" {
+			return fmt.Errorf("foreign target CPU environment leaked into observation")
+		}
+	}
+	cpuNames := make(map[string]bool)
+	for _, tag := range discoveryCPUFeatureCandidates() {
+		cpuNames[tag] = true
+		if _, present := features.MarkerSelection[tag]; !present {
+			return fmt.Errorf("missing builtin CPU namespace member %s", tag)
+		}
+	}
+	var experiments []string
+	var allNames, selected []string
+	for name, enabled := range features.MarkerSelection {
+		allNames = append(allNames, name)
+		if enabled {
+			selected = append(selected, name)
+		}
+	}
+	allNames, selected = uniqueSortedDiscoveryStrings(allNames), uniqueSortedDiscoveryStrings(selected)
+	for _, tag := range allNames {
+		if strings.HasPrefix(tag, "goexperiment.") {
+			experiments = append(experiments, tag)
+		} else if !cpuNames[tag] {
+			return fmt.Errorf("unknown builtin namespace member %s", tag)
+		}
+	}
+	encoded, err := json.Marshal(experiments)
+	if err != nil || discoveryFeatureBytesSHA256(encoded) != discoveryVersionedExperimentFingerprints[minor] {
+		return fmt.Errorf("incomplete or foreign actual Go experiment namespace")
+	}
+	selectedCPU := discoveryModeledCPUFeatures(nil, parts[1], features.Environment[cpuKey], minor)
+	for tag := range cpuNames {
+		if features.MarkerSelection[tag] != containsTargetFeature(selectedCPU, tag) {
+			return fmt.Errorf("actual CPU marker selection disagrees with observed environment: %s", tag)
+		}
+	}
+	if !equalDiscoveryStrings(features.ToolTags, selected) || features.MarkerSourceSHA256 != discoveryFeatureMarkerSHA256(discoveryFeatureMarkerFiles(allNames)) {
+		return fmt.Errorf("feature tags do not match the complete actual marker observation")
+	}
+	encoded, err = json.Marshal(features.MarkerSelection)
+	if err != nil || features.DriverSelectionSHA256 != discoveryFeatureBytesSHA256(encoded) {
+		return fmt.Errorf("actual driver selection digest does not match its complete marker observation")
+	}
+	return nil
+}
diff --git a/gotoolprofile/proxy_go_mod.go b/gotoolprofile/proxy_go_mod.go
new file mode 100644
index 000000000..5ef8178ee
--- /dev/null
+++ b/gotoolprofile/proxy_go_mod.go
@@ -0,0 +1,35 @@
+package gotoolprofile
+
+import (
+	"context"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"golang.org/x/mod/sumdb/tlog"
+)
+
+// Keep the existing report schema and API while sharing the independent
+// authentication layer with original-source observers, without a root cycle.
+const ProxyGoModProtocol = golegacymod.ProxyGoModProtocol
+
+type ProxyGoModProof = golegacymod.ProxyGoModProof
+type SumDBReader = golegacymod.SumDBReader
+
+func CaptureProxyGoMod(path, version, zipSum, modSum string, contents, lookup []byte, tiles tlog.TileReader) (*ProxyGoModProof, error) {
+	return golegacymod.CaptureProxyGoMod(path, version, zipSum, modSum, contents, lookup, tiles)
+}
+
+func ValidateProxyGoMod(proof *ProxyGoModProof) error {
+	return golegacymod.ValidateProxyGoMod(proof)
+}
+
+func validProxyGoModH1(value string) bool {
+	return golegacymod.ValidH1(value)
+}
+
+func NewSumDBReader(ctx context.Context, moduleCache, proxy string) (*SumDBReader, error) {
+	return golegacymod.NewSumDBReader(ctx, moduleCache, proxy)
+}
+
+func ReadChecksumFile(name string, limit int) ([]byte, error) {
+	return golegacymod.ReadChecksumFile(name, limit)
+}
diff --git a/gotoolprofile/proxy_go_mod_capture.go b/gotoolprofile/proxy_go_mod_capture.go
new file mode 100644
index 000000000..38ab55bc6
--- /dev/null
+++ b/gotoolprofile/proxy_go_mod_capture.go
@@ -0,0 +1,26 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+)
+
+// CaptureDownloadedProxyGoMod authenticates an actual Go-downloaded metadata
+// file which is not in the original ZIP. This grants no source/package role;
+// callers still prove ZIP absence, full original inventory and actual imports.
+func CaptureDownloadedProxyGoMod(ctx context.Context, binary, directory string, env []string, name, version, zipSum, modSum, metadata string, prior *ProxyGoModProof) (*ProxyGoModProof, string, error) {
+	output, _, err := RunBounded(ctx, directory, env, binary, "env", "-json", "GOMODCACHE", "GOPROXY")
+	if err != nil {
+		return nil, "", err
+	}
+	var actual map[string]string
+	if err := json.Unmarshal(output, &actual); err != nil || len(actual) != 2 || !filepath.IsAbs(actual["GOMODCACHE"]) {
+		return nil, "", fmt.Errorf("invalid actual metadata cache observation")
+	}
+	return golegacymod.CaptureCachedProxyGoMod(ctx, actual["GOMODCACHE"], actual["GOPROXY"],
+		name, version, zipSum, modSum, metadata, prior)
+}
diff --git a/gotoolprofile/proxy_go_mod_capture_test.go b/gotoolprofile/proxy_go_mod_capture_test.go
new file mode 100644
index 000000000..b2c7e66be
--- /dev/null
+++ b/gotoolprofile/proxy_go_mod_capture_test.go
@@ -0,0 +1,100 @@
+package gotoolprofile
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+
+	"golang.org/x/mod/module"
+)
+
+// This is real public metadata authentication and actual Go environment/path
+// binding. It deliberately does not download or execute the external module;
+// the separate whole-ZIP verifier must still prove its original source bytes.
+func TestDownloadedProxyGoModAuthenticatedConsumerBinding(t *testing.T) {
+	for _, axis := range []string{"valid", "bytes", "identity", "unsigned", "missing inclusion", "wrong path", "symlink", "cancelled"} {
+		t.Run(axis, func(t *testing.T) {
+			origin := fixtureProxyGoMod(t)
+			cache, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			name, err := module.EscapePath(origin.Module)
+			if err != nil {
+				t.Fatal(err)
+			}
+			version, err := module.EscapeVersion(origin.Version)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file := filepath.Join(cache, "cache/download", filepath.FromSlash(name), "@v", version+".mod")
+			if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(file, []byte(origin.Contents), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			identity := origin.Module
+			switch axis {
+			case "bytes":
+				if err := os.WriteFile(file, []byte(origin.Contents+"// altered\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "identity":
+				identity += "/different"
+			case "unsigned":
+				origin.SignedTree = strings.Split(origin.SignedTree, "\n\n")[0] + "\n"
+			case "missing inclusion":
+				origin.Inclusion = nil
+			case "wrong path":
+				file = filepath.Join(t.TempDir(), "copied.mod")
+				if err := os.WriteFile(file, []byte(origin.Contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "symlink":
+				other := filepath.Join(t.TempDir(), "other.mod")
+				if err := os.Rename(file, other); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Symlink(other, file); err != nil {
+					t.Fatal(err)
+				}
+			case "cancelled":
+				cancel()
+			}
+			binary, err := exec.LookPath("go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var env []string
+			for _, item := range os.Environ() {
+				key, _, _ := strings.Cut(item, "=")
+				if key != "GOMODCACHE" && key != "GOTOOLCHAIN" && key != "GOWORK" && key != "GOFLAGS" && key != "GOPROXY" {
+					env = append(env, item)
+				}
+			}
+			env = append(env, "GOMODCACHE="+cache, "GOTOOLCHAIN=local", "GOWORK=off", "GOFLAGS=", "GOPROXY=off")
+			actual, path, err := CaptureDownloadedProxyGoMod(ctx, binary, t.TempDir(), env, identity, origin.Version, origin.ModuleSum, origin.GoModSum, file, origin)
+			if axis != "valid" {
+				if err == nil {
+					t.Fatal("altered proxy metadata source accepted")
+				}
+				return
+			}
+			if err != nil || path != file || !reflect.DeepEqual(actual, origin) {
+				t.Fatalf("authenticated current consumer binding: %v", err)
+			}
+			actual.Inclusion[0] = "mutated public projection"
+			if actual.Inclusion[0] == origin.Inclusion[0] {
+				t.Fatal("caller projection shares authenticated origin storage")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/proxy_go_mod_test.go b/gotoolprofile/proxy_go_mod_test.go
new file mode 100644
index 000000000..dab577f8e
--- /dev/null
+++ b/gotoolprofile/proxy_go_mod_test.go
@@ -0,0 +1,95 @@
+package gotoolprofile
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+
+	"golang.org/x/mod/sumdb/tlog"
+)
+
+// Captured from the public lookup and authenticated tiles, without compiling
+// or running that module. The fixture proves metadata, not source execution.
+func fixtureProxyGoMod(t *testing.T) *ProxyGoModProof {
+	t.Helper()
+	data, err := os.ReadFile("testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	return &proof
+}
+
+type forbiddenProxyTiles struct{ calls int }
+
+func (*forbiddenProxyTiles) Height() int                     { return 8 }
+func (*forbiddenProxyTiles) SaveTiles([]tlog.Tile, [][]byte) {}
+func (tiles *forbiddenProxyTiles) ReadTiles([]tlog.Tile) ([][]byte, error) {
+	tiles.calls++
+	return nil, fmt.Errorf("untrusted record must not trigger tile reads")
+}
+
+func TestProxyGoModCaptureRejectsUnauthenticatedRecordBeforeTiles(t *testing.T) {
+	proof := fixtureProxyGoMod(t)
+	lookup, err := tlog.FormatRecord(proof.RecordID, []byte(proof.Record))
+	if err != nil {
+		t.Fatal(err)
+	}
+	lookup = append(lookup, []byte(proof.SignedTree)...)
+	for _, test := range []struct {
+		name   string
+		zipSum string
+		modSum string
+		body   string
+	}{
+		{name: "missing download GoModSum", zipSum: proof.ModuleSum, body: proof.Contents},
+		{name: "different download ZIP", zipSum: proof.GoModSum, modSum: proof.GoModSum, body: proof.Contents},
+		{name: "changed actual metadata", zipSum: proof.ModuleSum, modSum: proof.GoModSum, body: proof.Contents + "// changed\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			tiles := new(forbiddenProxyTiles)
+			if _, err := CaptureProxyGoMod(proof.Module, proof.Version, test.zipSum, test.modSum, []byte(test.body), lookup, tiles); err == nil {
+				t.Fatal("download metadata bypassed its independent signed identity")
+			}
+			if tiles.calls != 0 {
+				t.Fatal("invalid identity was fetched before validation")
+			}
+		})
+	}
+}
+
+func TestProxyGoModAuthenticatesExactPublicRecordAndMetadata(t *testing.T) {
+	if err := ValidateProxyGoMod(fixtureProxyGoMod(t)); err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func(*ProxyGoModProof)
+	}{
+		{"module", func(p *ProxyGoModProof) { p.Module += "/different" }},
+		{"version", func(p *ProxyGoModProof) { p.Version = "v1.0.0" }},
+		{"zip identity", func(p *ProxyGoModProof) { p.ModuleSum = p.GoModSum }},
+		{"metadata identity", func(p *ProxyGoModProof) { p.GoModSum = p.ModuleSum }},
+		{"metadata bytes", func(p *ProxyGoModProof) { p.Contents += "// changed\n" }},
+		{"file sha", func(p *ProxyGoModProof) { p.SHA256 = strings.Repeat("0", 64) }},
+		{"record id", func(p *ProxyGoModProof) { p.RecordID++ }},
+		{"unsigned tree", func(p *ProxyGoModProof) { p.SignedTree = strings.Split(p.SignedTree, "\n\n")[0] + "\n" }},
+		{"signed extent", func(p *ProxyGoModProof) { p.SignedTree = strings.Replace(p.SignedTree, "63096671", "63096672", 1) }},
+		{"missing inclusion", func(p *ProxyGoModProof) { p.Inclusion = nil }},
+		{"changed inclusion", func(p *ProxyGoModProof) { p.Inclusion[0] = p.Inclusion[1] }},
+		{"foreign record", func(p *ProxyGoModProof) { p.Record = strings.Replace(p.Record, p.Module, "example.invalid/fake", -1) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			proof := fixtureProxyGoMod(t)
+			test.mutate(proof)
+			if err := ValidateProxyGoMod(proof); err == nil {
+				t.Fatal("unauthenticated legacy metadata was accepted")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/source_inventory.go b/gotoolprofile/source_inventory.go
new file mode 100644
index 000000000..cb8b171cc
--- /dev/null
+++ b/gotoolprofile/source_inventory.go
@@ -0,0 +1,114 @@
+package gotoolprofile
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// SourceInventory is shared byte/membership evidence. Its capture and replay
+// do not authorize any package, module, embed, test or instrumentation role.
+type SourceInventory struct {
+	Sources     map[string]string            `json:"sources"`
+	Headers     map[string]string            `json:"selection_headers"`
+	Directories map[string][]TestSourceEntry `json:"directories"`
+}
+
+// CaptureSourceDirectory retains every immediate member and every ancestor.
+// Recursive capture is needed for an embed pattern's negative-selection proof;
+// ordinary source-only packages need only their own directory and ancestors.
+func CaptureSourceDirectory(ctx context.Context, inventory *SourceInventory, root, directory string, recursive bool) error {
+	if ctx == nil || ctx.Err() != nil || inventory == nil {
+		return fmt.Errorf("source inventory capture requires a live context")
+	}
+	resolved, err := sourcepath.Resolve(root)
+	if err != nil || resolved != root || !filepath.IsAbs(root) {
+		return fmt.Errorf("source inventory root is missing or redirected")
+	}
+	name, err := filepath.Rel(root, directory)
+	name = filepath.ToSlash(name)
+	if err != nil || name != "." && !testSourceLocalPath(name) {
+		return fmt.Errorf("source inventory directory escapes its bound root")
+	}
+	resolved, err = sourcepath.Resolve(directory)
+	if err != nil || resolved != directory {
+		return fmt.Errorf("source inventory directory is redirected")
+	}
+	if inventory.Sources == nil && inventory.Headers == nil && inventory.Directories == nil {
+		inventory.Sources = make(map[string]string)
+		inventory.Headers = make(map[string]string)
+		inventory.Directories = make(map[string][]TestSourceEntry)
+	} else if inventory.Sources == nil || inventory.Headers == nil || inventory.Directories == nil {
+		return fmt.Errorf("source inventory has a partially initialized projection")
+	}
+	if name != "." {
+		if err := CaptureSourceDirectory(ctx, inventory, root, filepath.Dir(directory), false); err != nil {
+			return err
+		}
+	}
+	if _, captured := inventory.Directories[name]; !captured {
+		if len(inventory.Directories) >= 4096 {
+			return fmt.Errorf("source inventory exceeds its directory bound")
+		}
+		entries, err := os.ReadDir(directory)
+		if err != nil {
+			return err
+		}
+		entryCount := len(entries)
+		for _, previous := range inventory.Directories {
+			entryCount += len(previous)
+		}
+		if entryCount > 65536 {
+			return fmt.Errorf("source inventory exceeds its total member bound")
+		}
+		members := make([]TestSourceEntry, 0, len(entries))
+		for _, entry := range entries {
+			if err := ctx.Err(); err != nil {
+				return err
+			}
+			member := TestSourceEntry{Name: entry.Name(), Kind: "directory"}
+			if !entry.IsDir() {
+				if !entry.Type().IsRegular() || len(inventory.Sources) >= 65536 {
+					return fmt.Errorf("source inventory contains unbounded/nonregular bytes")
+				}
+				file := path.Join(name, entry.Name())
+				filename, err := CPPRegularSource(root, file)
+				if err != nil {
+					return err
+				}
+				data, err := readTestDependencySource(filename)
+				if err != nil {
+					return err
+				}
+				member.Kind, member.SHA256 = "file", bytesSHA256(data)
+				inventory.Sources[file] = member.SHA256
+				if path.Ext(file) == ".go" || path.Ext(file) == ".s" {
+					if len(inventory.Headers) >= 32768 {
+						return fmt.Errorf("source inventory exceeds its header bound")
+					}
+					header, err := TestSelectionHeader(file, data)
+					if err != nil {
+						return err
+					}
+					inventory.Headers[file] = header
+				}
+			}
+			members = append(members, member)
+		}
+		inventory.Directories[name] = members
+	}
+	if recursive {
+		for _, entry := range inventory.Directories[name] {
+			if entry.Kind == "directory" {
+				if err := CaptureSourceDirectory(ctx, inventory, root, filepath.Join(directory, entry.Name), true); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return ctx.Err()
+}
diff --git a/gotoolprofile/subtools.go b/gotoolprofile/subtools.go
new file mode 100644
index 000000000..ec90e45f5
--- /dev/null
+++ b/gotoolprofile/subtools.go
@@ -0,0 +1,116 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+var discoveryFeatureSubtools = []string{"asm", "compile", "link", "nm", "vet"}
+
+type discoveryFeatureToolState struct {
+	directory  string
+	digests    map[string]string
+	origins    map[string]string
+	routing    string
+	dispatcher string
+}
+
+// Resolve this exact driver's executable, not a guessed GOTOOLDIR path.
+// Recent official distributions build builtin nm into the caller-owned
+// GOCACHE. -n may build that official tool but does not execute it.
+func captureDiscoveryFeatureSubtools(ctx context.Context, binary string, env []string, actual map[string]string, run Runner) (*discoveryFeatureToolState, error) {
+	if ctx == nil || ctx.Err() != nil {
+		return nil, fmt.Errorf("actual Go subtool resolution requires a live context")
+	}
+	root, directory, cache := actual["GOROOT"], actual["GOTOOLDIR"], actual["GOCACHE"]
+	if !filepath.IsAbs(root) || !filepath.IsAbs(directory) || !filepath.IsAbs(cache) {
+		return nil, fmt.Errorf("actual Go subtool root/directory/cache must be absolute")
+	}
+	resolvedRoot, err := sourcepath.Resolve(root)
+	if err != nil {
+		return nil, fmt.Errorf("resolve actual Go GOROOT: %w", err)
+	}
+	resolvedDirectory, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return nil, fmt.Errorf("resolve actual Go GOTOOLDIR: %w", err)
+	}
+	resolvedCache, err := sourcepath.Resolve(cache)
+	if err != nil {
+		return nil, fmt.Errorf("resolve actual Go GOCACHE: %w", err)
+	}
+	relative, err := filepath.Rel(resolvedRoot, resolvedDirectory)
+	if err != nil || !validDiscoveryFeatureToolDirectory(filepath.ToSlash(relative)) {
+		return nil, fmt.Errorf("actual Go subtools are outside the bound GOROOT tool directory")
+	}
+	state := &discoveryFeatureToolState{directory: filepath.ToSlash(relative), digests: make(map[string]string), origins: make(map[string]string)}
+	dispatcherFile := filepath.Join(resolvedRoot, "src", "cmd", "go", "internal", "tool", "tool.go")
+	state.dispatcher, err = discoveryFeatureFileSHA256(dispatcherFile)
+	if err != nil {
+		return nil, fmt.Errorf("actual Go tool dispatcher: %w", err)
+	}
+	routes := map[string]string{"GOCACHE": resolvedCache}
+	env = replaceEnv(env, actual)
+	env = replaceEnv(env, map[string]string{"GOTOOLCHAIN": "local", "GOWORK": "off", "GOFLAGS": ""})
+	for _, name := range discoveryFeatureSubtools {
+		output, _, err := run(ctx, "", env, binary, "tool", "-n", name)
+		if err != nil {
+			return nil, fmt.Errorf("resolve actual Go %s route: %w", name, err)
+		}
+		file := strings.TrimSpace(string(output))
+		if !filepath.IsAbs(file) || strings.ContainsAny(file, "\r\n") {
+			return nil, fmt.Errorf("actual Go %s route is not one absolute executable", name)
+		}
+		resolved, err := sourcepath.Resolve(file)
+		if err != nil {
+			return nil, fmt.Errorf("actual Go %s executable: %w", name, err)
+		}
+		suffix := ""
+		if strings.HasPrefix(filepath.Base(resolvedDirectory), "windows_") {
+			suffix = ".exe"
+		}
+		if resolved == filepath.Join(resolvedDirectory, name+suffix) {
+			state.origins[name] = "goroot/" + state.directory + "/" + name + suffix
+		} else {
+			minor, err := goMinor(actual["GOVERSION"])
+			cacheRelative, relErr := filepath.Rel(resolvedCache, resolved)
+			if err != nil || minor < 25 || (name != "nm" && name != "vet") || relErr != nil || !filepath.IsLocal(cacheRelative) || filepath.Base(resolved) != name+suffix {
+				return nil, fmt.Errorf("unrecognized actual Go %s executable route", name)
+			}
+			state.origins[name] = "gocache/builtin/cmd/" + name
+		}
+		digest, err := discoveryFeatureFileSHA256(resolved)
+		if err != nil {
+			return nil, fmt.Errorf("actual Go %s tool: %w", name, err)
+		}
+		state.digests[name], routes[name] = digest, resolved
+	}
+	encoded, err := json.Marshal(routes)
+	if err != nil {
+		return nil, err
+	}
+	// Bind machine-local routing/cache identity without exporting paths.
+	state.routing = discoveryFeatureBytesSHA256(encoded)
+	afterDispatcher, err := discoveryFeatureFileSHA256(dispatcherFile)
+	if err != nil || afterDispatcher != state.dispatcher {
+		return nil, fmt.Errorf("actual Go tool dispatcher changed during resolution")
+	}
+	return state, nil
+}
+
+func validDiscoveryFeatureToolDirectory(directory string) bool {
+	parts := strings.Split(directory, "/")
+	return len(parts) == 3 && parts[0] == "pkg" && parts[1] == "tool" &&
+		parts[2] != "" && parts[2] != "." && parts[2] != ".." && !strings.ContainsAny(parts[2], "\\:") &&
+		strings.Count(parts[2], "_") == 1
+}
+
+func equalDiscoveryFeatureToolStates(a, b *discoveryFeatureToolState) bool {
+	return a != nil && b != nil && a.directory == b.directory && a.routing == b.routing && a.dispatcher == b.dispatcher &&
+		reflect.DeepEqual(a.digests, b.digests) && reflect.DeepEqual(a.origins, b.origins)
+}
diff --git a/gotoolprofile/subtools_paths_test.go b/gotoolprofile/subtools_paths_test.go
new file mode 100644
index 000000000..c3771f486
--- /dev/null
+++ b/gotoolprofile/subtools_paths_test.go
@@ -0,0 +1,30 @@
+package gotoolprofile
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFeatureSubtoolDirectoryErrorsKeepOrigin(t *testing.T) {
+	// Infrastructure failures need their origin even when Windows returns a
+	// bare syscall error. They must not become assembly rejection evidence.
+	for _, key := range []string{"GOROOT", "GOTOOLDIR", "GOCACHE"} {
+		t.Run(key, func(t *testing.T) {
+			present := t.TempDir()
+			actual := map[string]string{"GOROOT": present, "GOTOOLDIR": present, "GOCACHE": present}
+			actual[key] = filepath.Join(present, "missing")
+			run := func(context.Context, string, []string, string, ...string) ([]byte, []byte, error) {
+				t.Fatal("a missing directory must fail before invoking a tool")
+				return nil, nil, nil
+			}
+			observed, err := captureDiscoveryFeatureSubtools(context.Background(), "", nil, actual, run)
+			if observed != nil || !errors.Is(err, os.ErrNotExist) || !strings.HasPrefix(err.Error(), "resolve actual Go "+key+": ") {
+				t.Fatalf("lost directory role or original error: observation=%v error=%v", observed, err)
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/test_declarations.go b/gotoolprofile/test_declarations.go
new file mode 100644
index 000000000..927919265
--- /dev/null
+++ b/gotoolprofile/test_declarations.go
@@ -0,0 +1,300 @@
+package gotoolprofile
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"path"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+const SignatureSourceProtocol = "actual_go_signature_sources_v1"
+const TestDeclarationProtocol = "actual_go_inpackage_test_bodyless_declarations_v1"
+
+// Ordinary assembly selection remains ordinary. This separate witness binds
+// only missing declarations to a real stock-Go in-package test export and to
+// the complete same-profile typechecked source set. It grants no test execution.
+type TestDeclarationProof struct {
+	Protocol          string            `json:"protocol"`
+	PackagePath       string            `json:"package_path"`
+	VariantID         string            `json:"variant_id"`
+	ProfileID         string            `json:"profile_id"`
+	CustomTags        []string          `json:"custom_tags,omitempty"`
+	Target            string            `json:"target"`
+	GoVersion         string            `json:"go_version"`
+	DriverSHA256      string            `json:"driver_sha256"`
+	CompileToolSHA256 string            `json:"compile_tool_sha256"`
+	ExportSHA256      string            `json:"export_sha256"`
+	GoFiles           []string          `json:"go_files"`
+	CompiledGoFiles   []string          `json:"compiled_go_files"`
+	SFiles            []string          `json:"s_files"`
+	SourceSHA256      map[string]string `json:"source_sha256"`
+	Imports           []ImportExport    `json:"imports,omitempty"`
+	ImportMap         map[string]string `json:"import_map"`
+	Declarations      []TestDeclaration `json:"declarations"`
+}
+
+type TestDeclaration struct {
+	Symbol string          `json:"symbol"`
+	File   string          `json:"file"`
+	GoType string          `json:"go_type"`
+	Layout json.RawMessage `json:"layout"`
+}
+
+// Each actual TEXT and supplemental direct callee records its used signature. A test role
+// refers to the shared witness rather than copying its sources for each file.
+type SignatureSource struct {
+	Symbol          string `json:"symbol"`
+	Role            string `json:"role"`
+	Callee          bool   `json:"callee,omitempty"`
+	ABIInternal     bool   `json:"abi_internal,omitempty"`
+	LayoutSHA256    string `json:"layout_sha256"`
+	TestProofSHA256 string `json:"test_proof_sha256,omitempty"`
+}
+
+func TestDeclarationSHA256(proof TestDeclarationProof) string {
+	data, _ := json.Marshal(proof)
+	return bytesSHA256(data)
+}
+
+// A pretty-printed report may indent RawMessage layout bytes. Hash the same
+// canonical token stream used by the typed producer, not JSON presentation.
+func SignatureLayoutSHA256(layout json.RawMessage) string {
+	var compact bytes.Buffer
+	if err := json.Compact(&compact, layout); err != nil {
+		return ""
+	}
+	return bytesSHA256(compact.Bytes())
+}
+
+func ValidateSignatureSources(input *ConsumerInput, proof *SelectionProof, tags []string) error {
+	if input.SignatureSourceProtocol == "" {
+		if proof.SignatureSourceProtocol != "" || len(proof.TestDeclarations) != 0 {
+			return fmt.Errorf("legacy selection cannot acquire supplemental declaration evidence")
+		}
+		for _, cpp := range proof.CPP {
+			if len(cpp.Signatures) != 0 || cpp.DataOnlyAssembly != nil {
+				return fmt.Errorf("legacy selection cannot acquire signature-source evidence")
+			}
+		}
+		return nil
+	}
+	if input.SignatureSourceProtocol != SignatureSourceProtocol || proof.SignatureSourceProtocol != SignatureSourceProtocol {
+		return fmt.Errorf("missing or changed current signature-source protocol")
+	}
+	if err := ValidateTestDependencies(input, proof, tags); err != nil {
+		return err
+	}
+	byDigest := make(map[string]TestDeclarationProof)
+	declared := make(map[string]TestDeclaration)
+	for index, test := range proof.TestDeclarations {
+		if index > 0 && test.PackagePath <= proof.TestDeclarations[index-1].PackagePath {
+			return fmt.Errorf("noncanonical supplemental declaration package inventory")
+		}
+		if err := validateTestDeclaration(input, proof.Packages, test, tags); err != nil {
+			return err
+		}
+		digest := TestDeclarationSHA256(test)
+		byDigest[digest] = test
+		for _, decl := range test.Declarations {
+			if _, exists := declared[decl.Symbol]; exists {
+				return fmt.Errorf("duplicate supplemental declaration symbol")
+			}
+			declared[decl.Symbol] = decl
+		}
+	}
+	used, entries := make(map[string]bool), make(map[string]bool)
+	bound := make(map[string]SignatureSource)
+	for _, cpp := range proof.CPP {
+		if cpp.Emission == "data_only" {
+			if cpp.DataOnlyAssembly == nil || len(cpp.Signatures) != 0 {
+				return fmt.Errorf("data-only assembly requires a native witness and no function signatures")
+			}
+		} else if cpp.Emission != "symbol_free" && len(cpp.Signatures) == 0 {
+			return fmt.Errorf("current assembly consumption lacks signature-source inventory")
+		}
+		for index, source := range cpp.Signatures {
+			if source.Symbol == "" || !discoverySHA256Pattern.MatchString(source.LayoutSHA256) ||
+				index > 0 && source.Symbol <= cpp.Signatures[index-1].Symbol {
+				return fmt.Errorf("noncanonical or duplicated consumed signature source")
+			}
+			if source.Callee && source.Role != "inpackage_test_decl" {
+				return fmt.Errorf("supplemental callee lacks an actual test declaration")
+			}
+			if !source.Callee {
+				if entries[source.Symbol] {
+					return fmt.Errorf("duplicated assembly entry signature source")
+				}
+				entries[source.Symbol] = true
+			}
+			comparison := source
+			comparison.Callee = false
+			if previous, exists := bound[source.Symbol]; exists && previous != comparison {
+				return fmt.Errorf("entry/callee signature evidence disagrees across source files")
+			}
+			bound[source.Symbol] = comparison
+			switch source.Role {
+			case "ordinary_decl", "asm_fallback":
+				if source.TestProofSHA256 != "" {
+					return fmt.Errorf("ordinary/fallback signature falsely claims a test role")
+				}
+			case "inpackage_test_decl":
+				test, found := byDigest[source.TestProofSHA256]
+				decl, present := declared[source.Symbol]
+				want := input.Module
+				if path.Dir(cpp.File) != "." {
+					want += "/" + path.Dir(cpp.File)
+				}
+				if !found || !present || test.PackagePath != want || SignatureLayoutSHA256(decl.Layout) != source.LayoutSHA256 {
+					return fmt.Errorf("consumed signature differs from its exact test declaration/type/layout")
+				}
+				used[source.Symbol] = true
+			default:
+				return fmt.Errorf("unknown signature-source role")
+			}
+		}
+	}
+	if len(used) != len(declared) {
+		return fmt.Errorf("supplemental test declaration was not consumed by assembly")
+	}
+	return nil
+}
+
+func validateTestDeclaration(input *ConsumerInput, packages []PackageProof, test TestDeclarationProof, tags []string) error {
+	observed := input.Observed
+	if test.Protocol != TestDeclarationProtocol || test.ProfileID != input.ID || !equalDiscoveryStrings(test.CustomTags, tags) ||
+		test.Target != observed.Target || test.GoVersion != observed.GoVersion || test.DriverSHA256 != observed.DriverSHA256 ||
+		test.CompileToolSHA256 != observed.ToolBinarySHA256["compile"] || !discoverySHA256Pattern.MatchString(test.ExportSHA256) ||
+		test.VariantID != test.PackagePath+" ["+test.PackagePath+".test]" || len(test.Declarations) == 0 {
+		return fmt.Errorf("supplemental declaration has a different actual Go test/profile/export/tool role")
+	}
+	var ordinary *PackageProof
+	for index := range packages {
+		if packages[index].PackagePath == test.PackagePath {
+			ordinary = &packages[index]
+		}
+	}
+	if ordinary == nil || !reflect.DeepEqual(ordinary.SFiles, test.SFiles) || !reflect.DeepEqual(test.GoFiles, test.CompiledGoFiles) {
+		return fmt.Errorf("test variant differs from its original ordinary package/assembly identity")
+	}
+	minor, err := goMinor(observed.GoVersion)
+	if err != nil {
+		return err
+	}
+	ctx := build.Default
+	ctx.JoinPath = path.Join
+	ctx.GOOS, ctx.GOARCH, ctx.Compiler, ctx.CgoEnabled = observed.Environment["GOOS"], observed.Environment["GOARCH"], "gc", false
+	ctx.BuildTags, ctx.ToolTags, ctx.ReleaseTags = tags, observed.ToolTags, nil
+	for version := 1; version <= minor; version++ {
+		ctx.ReleaseTags = append(ctx.ReleaseTags, fmt.Sprintf("go1.%d", version))
+	}
+	ctx.OpenFile = func(name string) (io.ReadCloser, error) {
+		header, found := input.Headers[name]
+		if !found {
+			return nil, fmt.Errorf("test source has no original selection header")
+		}
+		return io.NopCloser(strings.NewReader(header)), nil
+	}
+	ordinaryClause, err := parser.ParseFile(token.NewFileSet(), ordinary.GoFiles[0], input.Headers[ordinary.GoFiles[0]], parser.PackageClauseOnly)
+	if err != nil {
+		return fmt.Errorf("ordinary package lacks its bound package clause")
+	}
+	ordinaryName := ordinaryClause.Name.Name
+	wantedGo := append([]string(nil), ordinary.GoFiles...)
+	dir := path.Dir(ordinary.GoFiles[0])
+	for _, name := range input.Directories[dir] {
+		if !strings.HasSuffix(name, "_test.go") {
+			continue
+		}
+		file := path.Join(dir, name)
+		selected, err := ctx.MatchFile(dir, name)
+		if err != nil {
+			return err
+		}
+		if !selected {
+			continue
+		}
+		clause, err := parser.ParseFile(token.NewFileSet(), file, input.Headers[file], parser.PackageClauseOnly)
+		if err != nil {
+			return fmt.Errorf("selected test source has no bound original package clause")
+		}
+		if clause.Name.Name == ordinaryName {
+			wantedGo = append(wantedGo, file)
+		}
+	}
+	sort.Strings(wantedGo)
+	if !reflect.DeepEqual(wantedGo, test.GoFiles) {
+		return fmt.Errorf("test variant omits/adds actual original same-package Go sources")
+	}
+	sources, testFiles := make(map[string]string), make(map[string]bool)
+	for _, files := range [][]string{test.GoFiles, test.SFiles} {
+		if len(files) == 0 || !sort.StringsAreSorted(files) {
+			return fmt.Errorf("test declaration lacks canonical actual selected source")
+		}
+		for index, name := range files {
+			if index > 0 && name == files[index-1] || input.Sources[name] == "" || test.SourceSHA256[name] != input.Sources[name] {
+				return fmt.Errorf("test declaration source differs from original ZIP bytes")
+			}
+			sources[name] = test.SourceSHA256[name]
+			if path.Ext(name) != ".go" {
+				continue
+			}
+			selected, err := ctx.MatchFile(path.Dir(name), path.Base(name))
+			clause, parseErr := parser.ParseFile(token.NewFileSet(), name, input.Headers[name], parser.PackageClauseOnly)
+			want := input.Module
+			if path.Dir(name) != "." {
+				want += "/" + path.Dir(name)
+			}
+			if err != nil || !selected || parseErr != nil || clause.Name.Name != ordinaryName || want != test.PackagePath {
+				return fmt.Errorf("test declaration contradicts its actual same-package target selection")
+			}
+			if strings.HasSuffix(name, "_test.go") {
+				testFiles[name] = true
+			}
+		}
+	}
+	if len(testFiles) == 0 || !reflect.DeepEqual(sources, test.SourceSHA256) {
+		return fmt.Errorf("test declaration has missing/extra original source inputs")
+	}
+	for _, name := range ordinary.GoFiles {
+		if sources[name] != ordinary.SourceSHA256[name] {
+			return fmt.Errorf("test variant omits an ordinary selected source")
+		}
+	}
+	for index, decl := range test.Declarations {
+		if !testFiles[decl.File] || !strings.HasPrefix(decl.Symbol, test.PackagePath+".") || decl.GoType == "" ||
+			!json.Valid(decl.Layout) || index > 0 && decl.Symbol <= test.Declarations[index-1].Symbol {
+			return fmt.Errorf("invalid or duplicated typed bodyless test declaration")
+		}
+	}
+	usedImports := make(map[string]string)
+	if test.ImportMap["unsafe"] != "" {
+		if test.ImportMap["unsafe"] != "unsafe" {
+			return fmt.Errorf("test builtin unsafe import has an invented export")
+		}
+		usedImports["unsafe"] = "unsafe"
+	}
+	for index, imported := range test.Imports {
+		if imported.ImportPath == "" || imported.PackagePath == "" || !discoverySHA256Pattern.MatchString(imported.ExportSHA256) || len(imported.GoSHA256) == 0 ||
+			index > 0 && imported.ImportPath <= test.Imports[index-1].ImportPath {
+			return fmt.Errorf("test typecheck lacks canonical dependency export/source roles")
+		}
+		if test.ImportMap[imported.ImportPath] != imported.PackagePath {
+			return fmt.Errorf("test dependency export differs from the actual ImportMap")
+		}
+		if err := validateImportedSource(input, *ordinary, imported); err != nil {
+			return err
+		}
+		usedImports[imported.ImportPath] = imported.PackagePath
+	}
+	if test.ImportMap == nil || !reflect.DeepEqual(test.ImportMap, usedImports) {
+		return fmt.Errorf("test typecheck omits actual dependency exports")
+	}
+	return nil
+}
diff --git a/gotoolprofile/test_dependencies.go b/gotoolprofile/test_dependencies.go
new file mode 100644
index 000000000..67b27c49c
--- /dev/null
+++ b/gotoolprofile/test_dependencies.go
@@ -0,0 +1,451 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"io"
+	"path"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+const SignatureQueryProtocol = "actual_go_missing_signature_query_v1"
+const TestDependencyProtocol = "actual_go_test_declaration_source_closure_v3"
+
+// A query binds only ordinary types and parsed CPP references. No test export,
+// signature layout, LLVM output or translation outcome is asserted here.
+type SignatureQueryProof struct {
+	Protocol  string             `json:"protocol"`
+	Selection *SelectionProof    `json:"selection"`
+	Requests  []SignatureRequest `json:"requests"`
+}
+
+type SignatureRequest struct {
+	File        string `json:"file"`
+	Symbol      string `json:"symbol"`
+	Callee      bool   `json:"callee,omitempty"`
+	ABIInternal bool   `json:"abi_internal,omitempty"`
+}
+
+// Source-only packages never enter the ordinary Go/ASM package inventory.
+// ImportMap retains all edges, including those leaving this exact module.
+type SourcePackageProof struct {
+	Package   PackageProof      `json:"package"`
+	VariantID string            `json:"variant_id"`
+	ImportMap map[string]string `json:"import_map"`
+	// Empty only for this candidate's authenticated original module. Foreign
+	// roots are classified by actual Go Module/Replace, never import prefixes.
+	SourceRootID string              `json:"source_root_id,omitempty"`
+	ExportSHA256 string              `json:"export_sha256,omitempty"`
+	Builtin      string              `json:"builtin,omitempty"`
+	Embed        *TestEmbedSelection `json:"embed_selection"`
+}
+
+// Historical test callers retain their name; this record alone grants no
+// test-variant, embed or compiler permission. The enclosing role validates it.
+type TestSourcePackage = SourcePackageProof
+
+type TestDependencyProof struct {
+	Protocol         string               `json:"protocol"`
+	Query            *SignatureQueryProof `json:"query"`
+	Packages         []TestSourcePackage  `json:"source_packages"`
+	ExternalPackages []TestSourcePackage  `json:"external_source_packages,omitempty"`
+	SourceModules    []TestModuleSource   `json:"dependency_source_roots,omitempty"`
+}
+
+// This authenticates source-only preload metadata, never a type/layout,
+// translated instruction or LLVM object. Final consumption remains separate.
+func ValidateTestDependencyPreload(input *ConsumerInput, dependency *TestDependencyProof, tags []string) error {
+	if dependency == nil || dependency.Protocol != TestDependencyProtocol || dependency.Query == nil ||
+		len(dependency.Query.Requests) == 0 || len(dependency.Packages) == 0 || len(dependency.Packages) > 4096 {
+		return fmt.Errorf("missing bounded test-declaration source-only preload")
+	}
+	if err := ValidateSignatureQuery(input, dependency.Query, tags); err != nil {
+		return err
+	}
+	roots := make(map[string]bool)
+	for _, request := range dependency.Query.Requests {
+		for _, pkg := range dependency.Query.Selection.Packages {
+			if containsString(pkg.SFiles, request.File) {
+				roots[pkg.PackagePath] = true
+			}
+		}
+	}
+	return validateTestSourceClosure(input, dependency, roots, tags)
+}
+
+func ValidateSignatureQuery(input *ConsumerInput, query *SignatureQueryProof, tags []string) error {
+	if input == nil || input.Protocol != ConsumerProtocol || input.Observed == nil || input.ID != ProfileID(input.Observed) ||
+		input.SignatureSourceProtocol != SignatureSourceProtocol || query == nil || query.Protocol != SignatureQueryProtocol || query.Selection == nil {
+		return fmt.Errorf("missing actual missing-signature preflight")
+	}
+	proof := query.Selection
+	if proof.Protocol != ConsumerProtocol || proof.SignatureSourceProtocol != input.SignatureSourceProtocol || proof.TestDependencySourceProtocol != input.TestDependencySourceProtocol ||
+		proof.ProfileID != input.ID || !equalDiscoveryStrings(proof.CustomTags, tags) ||
+		len(proof.Outputs) != 0 || len(proof.TestDeclarations) != 0 || proof.TestDependencies != nil ||
+		!reflect.DeepEqual(input.RegisteredAsmFiles, proof.RegisteredAsmFiles) {
+		return fmt.Errorf("signature preflight has a different source/profile role or claims translation")
+	}
+	if err := Validate(input.Observed); err != nil {
+		return err
+	}
+	selected, packages, err := validatePackageSelection(input, proof.Packages, tags)
+	if err != nil {
+		return err
+	}
+	if input.GeneratedHeaders != nil || proof.GeneratedHeaders != nil {
+		if err := ValidateGeneratedHeaderAgreement(input, input.GeneratedHeaders, proof.GeneratedHeaders, tags); err != nil {
+			return err
+		}
+	}
+	if _, err := validateCPPConsumption(input, proof, selected, packages); err != nil {
+		return err
+	}
+	seen := make(map[string]bool)
+	previous := ""
+	for _, request := range query.Requests {
+		key := request.File + "\x00" + request.Symbol
+		pkg, found := packages[request.File]
+		if !found || !strings.HasPrefix(request.Symbol, pkg.PackagePath+".") || seen[key] || key <= previous {
+			return fmt.Errorf("signature query has an unbound/duplicate/noncanonical source reference")
+		}
+		seen[key], previous = true, key
+	}
+	for _, cpp := range proof.CPP {
+		if len(cpp.Signatures) != 0 {
+			return fmt.Errorf("preflight cannot claim final typed signature consumption")
+		}
+	}
+	return nil
+}
+
+func ValidateTestDependencies(input *ConsumerInput, proof *SelectionProof, tags []string) error {
+	if input.TestDependencySourceProtocol == "" {
+		if proof.TestDependencySourceProtocol != "" || input.TestDependencies != nil || proof.TestDependencies != nil {
+			return fmt.Errorf("historical signature sources cannot acquire test dependency closure evidence")
+		}
+		return nil
+	}
+	if input.TestDependencySourceProtocol != TestDependencyProtocol || proof.TestDependencySourceProtocol != TestDependencyProtocol {
+		return fmt.Errorf("missing/changed current test dependency source protocol")
+	}
+	if input.TestDependencies == nil && proof.TestDependencies == nil {
+		if len(proof.TestDeclarations) != 0 {
+			return fmt.Errorf("actual test declaration lacks its pre-load missing-reference/source closure")
+		}
+		return nil // No extra source closure is needed for an ordinary declaration.
+	}
+	dependency := input.TestDependencies
+	if dependency == nil || !reflect.DeepEqual(dependency, proof.TestDependencies) || dependency.Protocol != TestDependencyProtocol ||
+		dependency.Query == nil || len(dependency.Query.Requests) == 0 || len(dependency.Packages) == 0 || len(dependency.Packages) > 4096 {
+		return fmt.Errorf("test dependency source-only contract is missing/changed/unconsumed")
+	}
+	queryInput := *input
+	queryInput.TestDependencies = nil
+	if err := ValidateTestDependencyPreload(&queryInput, dependency, tags); err != nil {
+		return err
+	}
+	if !reflect.DeepEqual(dependency.Query.Selection.Packages, proof.Packages) {
+		return fmt.Errorf("signature preflight and final ordinary package identity disagree")
+	}
+	byFile := make(map[string]CPPProof)
+	for _, cpp := range dependency.Query.Selection.CPP {
+		byFile[cpp.File] = cpp
+	}
+	consumed := make(map[string]SignatureRequest)
+	for _, cpp := range proof.CPP {
+		previous, found := byFile[cpp.File]
+		if !found || previous.ExpandedSHA256 != cpp.ExpandedSHA256 || previous.TypedExpandedSHA256 != cpp.TypedExpandedSHA256 ||
+			!reflect.DeepEqual(previous.Inputs, cpp.Inputs) || previous.Emission != cpp.Emission {
+			return fmt.Errorf("test signature preflight differs from actual normalized CPP consumption")
+		}
+		if !reflect.DeepEqual(previous.EmptyAssembly, cpp.EmptyAssembly) ||
+			!reflect.DeepEqual(previous.DataOnlyAssembly, cpp.DataOnlyAssembly) {
+			return fmt.Errorf("test signature preflight differs from actual native assembly evidence")
+		}
+		for _, source := range cpp.Signatures {
+			if source.Role == "inpackage_test_decl" {
+				key := cpp.File + "\x00" + source.Symbol
+				consumed[key] = SignatureRequest{File: cpp.File, Symbol: source.Symbol, Callee: source.Callee, ABIInternal: source.ABIInternal}
+			}
+		}
+	}
+	if len(consumed) != len(dependency.Query.Requests) {
+		return fmt.Errorf("test query contains missing/extra final signature references")
+	}
+	for _, request := range dependency.Query.Requests {
+		actual, found := consumed[request.File+"\x00"+request.Symbol]
+		if !found || actual != request {
+			return fmt.Errorf("test query entry/callee reference was not consumed")
+		}
+	}
+	for _, test := range proof.TestDeclarations {
+		var root *TestSourcePackage
+		for index := range dependency.Packages {
+			if dependency.Packages[index].Package.PackagePath == test.PackagePath {
+				root = &dependency.Packages[index]
+			}
+		}
+		if root == nil || !reflect.DeepEqual(root.ImportMap, test.ImportMap) || !reflect.DeepEqual(root.Package.SourceSHA256, test.SourceSHA256) {
+			return fmt.Errorf("actual test export differs from its complete pre-load source/ImportMap role")
+		}
+		for _, imported := range test.Imports {
+			var selected *TestSourcePackage
+			all := append(append([]TestSourcePackage(nil), dependency.Packages...), dependency.ExternalPackages...)
+			for index := range all {
+				if all[index].Package.PackagePath == imported.PackagePath {
+					selected = &all[index]
+				}
+			}
+			wanted := make(map[string]string)
+			if selected != nil {
+				for _, file := range selected.Package.CompiledGoFiles {
+					wanted[file] = selected.Package.SourceSHA256[file]
+				}
+			}
+			if selected == nil || !reflect.DeepEqual(wanted, imported.GoSHA256) ||
+				selected.Package.ModulePath != imported.ModulePath || selected.Package.ModuleVersion != imported.Version ||
+				selected.Package.SourceModule != imported.SourceModule || selected.Package.SourceVersion != imported.SourceVersion ||
+				selected.Package.SourceRole != imported.SourceRole ||
+				selected.SourceRootID != "" && selected.ExportSHA256 != imported.ExportSHA256 {
+				return fmt.Errorf("actual test export dependency differs from its complete source/module/export closure")
+			}
+		}
+	}
+	return nil
+}
+
+func containsString(values []string, wanted string) bool {
+	for _, value := range values {
+		if value == wanted {
+			return true
+		}
+	}
+	return false
+}
+
+func testSourceOnlyZeroAssembly(view *ConsumerInput, pkg PackageProof, dir string) bool {
+	if len(pkg.SFiles) == 0 {
+		return false
+	}
+	empty := bytesSHA256(nil)
+	for _, file := range pkg.SFiles {
+		header, present := view.Headers[file]
+		if path.Dir(file) != dir || !containsString(view.Directories[dir], path.Base(file)) ||
+			view.Sources[file] != empty || pkg.SourceSHA256[file] != empty ||
+			!present || header != "" {
+			return false
+		}
+	}
+	// Zero bytes cannot replace an instruction/object scope. Keep the full
+	// actual SFiles list: MatchFile, source membership and the independent
+	// consumer still verify it below. Nonzero symbol-free units are not zero.
+	return true
+}
+
+func validateTestSourceClosure(input *ConsumerInput, dependency *TestDependencyProof, roots map[string]bool, tags []string) error {
+	modules, err := testDependencySourceModules(input, dependency)
+	if err != nil {
+		return err
+	}
+	return validatePackageSourceClosure(input, dependency.Packages, dependency.ExternalPackages, modules, roots, tags, true)
+}
+
+// The bool is private and fixed by two distinct role validators. Shared source
+// selection does not move permission from the test role to the ordinary role.
+func validatePackageSourceClosure(input *ConsumerInput, local, external []SourcePackageProof, modules map[string]TestModuleSource, roots map[string]bool, tags []string, testVariants bool) error {
+	minor, err := goMinor(input.Observed.GoVersion)
+	if err != nil {
+		return err
+	}
+	ctx := build.Default
+	ctx.JoinPath = path.Join // Original-source maps use portable module-relative keys.
+	ctx.GOOS, ctx.GOARCH, ctx.Compiler, ctx.CgoEnabled = input.Observed.Environment["GOOS"], input.Observed.Environment["GOARCH"], "gc", false
+	ctx.BuildTags, ctx.ToolTags, ctx.ReleaseTags = tags, input.Observed.ToolTags, nil
+	for version := 1; version <= minor; version++ {
+		ctx.ReleaseTags = append(ctx.ReleaseTags, fmt.Sprintf("go1.%d", version))
+	}
+	packages := append(append([]SourcePackageProof(nil), local...), external...)
+	if len(packages) > 4096 {
+		return fmt.Errorf("test dependency package closure exceeds its bounded scope")
+	}
+	byPath := make(map[string]TestSourcePackage)
+	usedModules := make(map[string]map[string]bool)
+	for index, source := range packages {
+		pkg := source.Package
+		if (index < len(local)) != (source.SourceRootID == "") {
+			return fmt.Errorf("test dependency changed original versus external package source roles")
+		}
+		view, err := testDependencyPackageInput(input, source, modules)
+		if err != nil {
+			return err
+		}
+		ctx.OpenFile = func(name string) (io.ReadCloser, error) {
+			header, found := view.Headers[name]
+			if !found {
+				return nil, fmt.Errorf("test dependency source lacks its original selection/import header")
+			}
+			return io.NopCloser(strings.NewReader(header)), nil
+		}
+		start := 0
+		if index >= len(local) {
+			start = len(local)
+		}
+		builtin := source.Builtin == "go_typechecker_unsafe_v1"
+		if index > start && pkg.PackagePath <= packages[index-1].Package.PackagePath || byPath[pkg.PackagePath].VariantID != "" ||
+			pkg.Macros != nil || source.ImportMap == nil ||
+			!builtin && !reflect.DeepEqual(pkg.GoFiles, pkg.CompiledGoFiles) || len(pkg.GoFiles) == 0 || !sort.StringsAreSorted(pkg.GoFiles) {
+			return fmt.Errorf("noncanonical actual test source-only package")
+		}
+		wantedID := pkg.PackagePath
+		if testVariants && roots[pkg.PackagePath] {
+			wantedID += " [" + pkg.PackagePath + ".test]"
+		}
+		if source.VariantID != wantedID {
+			return fmt.Errorf("test dependency has a different actual package/test-variant identity")
+		}
+		dir := strings.TrimPrefix(strings.TrimPrefix(pkg.PackagePath, pkg.ModulePath), "/")
+		if dir == "" {
+			dir = "."
+		}
+		if testVariants && source.SourceRootID == "" && !roots[pkg.PackagePath] && len(pkg.SFiles) != 0 &&
+			!containsString(input.OrdinaryAsmPackages, dir) && !testSourceOnlyZeroAssembly(view, pkg, dir) {
+			return fmt.Errorf("source-only test dependency cannot replace another assembly translation scope: "+
+				"package=%s module=%s@%s source_root=%q directory=%s selected_asm=%q ordinary_asm_packages=%q target=%s profile=%s tags=%q",
+				pkg.PackagePath, pkg.ModulePath, pkg.ModuleVersion, source.SourceRootID, dir,
+				pkg.SFiles, input.OrdinaryAsmPackages, input.Observed.Target, input.ID, tags)
+		}
+		if view.Directories[dir] == nil {
+			return fmt.Errorf("test dependency lacks a complete original source directory")
+		}
+		embedDirectories, err := ValidateTestEmbedSelection(pkg, source.Embed, view)
+		if err != nil {
+			return err
+		}
+		if source.SourceRootID != "" {
+			if usedModules[source.SourceRootID] == nil {
+				usedModules[source.SourceRootID] = make(map[string]bool)
+			}
+			for ancestor := dir; ; ancestor = path.Dir(ancestor) {
+				usedModules[source.SourceRootID][ancestor] = true
+				if ancestor == "." {
+					break
+				}
+			}
+			for directory := range embedDirectories {
+				usedModules[source.SourceRootID][directory] = true
+			}
+		}
+		clause, err := parser.ParseFile(token.NewFileSet(), pkg.GoFiles[0], view.Headers[pkg.GoFiles[0]], parser.PackageClauseOnly)
+		if err != nil {
+			return fmt.Errorf("test dependency lacks a bound package clause")
+		}
+		var wantedGo, wantedAsm []string
+		imports := make(map[string]bool)
+		for _, name := range view.Directories[dir] {
+			file := path.Join(dir, name)
+			if path.Ext(name) != ".go" && path.Ext(name) != ".s" || strings.HasSuffix(name, "_test.go") && (!testVariants || !roots[pkg.PackagePath]) {
+				continue
+			}
+			selected, err := ctx.MatchFile(dir, name)
+			if err != nil {
+				return err
+			}
+			if !selected {
+				continue
+			}
+			if path.Ext(name) == ".s" {
+				wantedAsm = append(wantedAsm, file)
+				continue
+			}
+			syntax, err := parser.ParseFile(token.NewFileSet(), file, view.Headers[file], parser.ImportsOnly)
+			if err != nil {
+				return fmt.Errorf("test dependency has an unbound source/import header")
+			}
+			if syntax.Name.Name != clause.Name.Name {
+				if strings.HasSuffix(name, "_test.go") && syntax.Name.Name == clause.Name.Name+"_test" {
+					continue // External tests never acquire the in-package role.
+				}
+				return fmt.Errorf("test dependency changed its exact package identity")
+			}
+			wantedGo = append(wantedGo, file)
+			for _, imported := range syntax.Imports {
+				spelling, err := strconv.Unquote(imported.Path.Value)
+				if err != nil {
+					return fmt.Errorf("test dependency has an invalid original import spelling")
+				}
+				if spelling == "C" {
+					return fmt.Errorf("source-only test dependency requires a proven non-cgo source role")
+				}
+				imports[spelling] = true
+			}
+		}
+		sort.Strings(wantedGo)
+		sort.Strings(wantedAsm)
+		if !reflect.DeepEqual(wantedGo, pkg.GoFiles) || !reflect.DeepEqual(wantedAsm, pkg.SFiles) || len(imports) != len(source.ImportMap) {
+			return fmt.Errorf("test dependency source/ImportMap inventory contradicts original target/tag selection")
+		}
+		for spelling := range imports {
+			if source.ImportMap[spelling] == "" {
+				return fmt.Errorf("test dependency omits an actual original source import")
+			}
+		}
+		used := make(map[string]string)
+		for _, files := range [][]string{pkg.GoFiles, pkg.SFiles} {
+			for n, file := range files {
+				if n > 0 && file <= files[n-1] || path.Dir(file) != dir || view.Sources[file] == "" || view.Sources[file] != pkg.SourceSHA256[file] {
+					return fmt.Errorf("test dependency source differs from exact pre-load bytes")
+				}
+				used[file] = view.Sources[file]
+			}
+		}
+		if !reflect.DeepEqual(used, pkg.SourceSHA256) {
+			return fmt.Errorf("test dependency omitted/added source consumption")
+		}
+		byPath[pkg.PackagePath] = source
+	}
+	if len(usedModules) != len(modules) {
+		return fmt.Errorf("test dependency contains an unrelated source-module root")
+	}
+	for id, module := range modules {
+		for dir := range module.Directories {
+			if !usedModules[id][dir] {
+				return fmt.Errorf("test dependency contains an unrelated source-module directory")
+			}
+		}
+	}
+	visited := make(map[string]bool)
+	var visit func(string) error
+	visit = func(name string) error {
+		if visited[name] {
+			return nil
+		}
+		source, found := byPath[name]
+		if !found {
+			return fmt.Errorf("actual test dependency module/import closure is truncated: %s", name)
+		}
+		visited[name] = true
+		for spelling, destination := range source.ImportMap {
+			if spelling == "" || destination == "" {
+				return fmt.Errorf("test dependency has an incomplete actual ImportMap")
+			}
+			if err := visit(destination); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	for root := range roots {
+		if err := visit(root); err != nil {
+			return err
+		}
+	}
+	if len(visited) != len(byPath) {
+		return fmt.Errorf("test source-only inventory contains an unrelated package")
+	}
+	return nil
+}
diff --git a/gotoolprofile/test_dependency_assembly_scope_test.go b/gotoolprofile/test_dependency_assembly_scope_test.go
new file mode 100644
index 000000000..3dd3262d4
--- /dev/null
+++ b/gotoolprofile/test_dependency_assembly_scope_test.go
@@ -0,0 +1,151 @@
+package gotoolprofile
+
+import (
+	"strings"
+	"testing"
+)
+
+func testDependencyAssemblyScopeFixture() (*ConsumerInput, *TestDependencyProof) {
+	const module = "example.invalid/scope"
+	const file = "helper/asm.s"
+	source := TestSourcePackage{
+		Package: PackageProof{
+			PackagePath: module + "/helper", ModulePath: module, ModuleVersion: "v1.0.0",
+			SourceModule: module, SourceVersion: "v1.0.0", SourceRole: "module",
+			GoFiles: []string{"helper/helper.go"}, CompiledGoFiles: []string{"helper/helper.go"}, SFiles: []string{file},
+			SourceSHA256: map[string]string{
+				"helper/helper.go": bytesSHA256([]byte("package helper\n")), file: bytesSHA256(nil),
+			},
+		},
+		VariantID: module + "/helper", ImportMap: map[string]string{},
+	}
+	input := &ConsumerInput{
+		ID:     strings.Repeat("a", 64),
+		Module: module, Version: "v1.0.0", SourceModule: module,
+		Observed: &Observation{
+			GoVersion: "go1.27.1", Target: "darwin/amd64",
+			Environment: map[string]string{"GOOS": "darwin", "GOARCH": "amd64"},
+		},
+		Sources: map[string]string{
+			"helper/helper.go": source.Package.SourceSHA256["helper/helper.go"], file: source.Package.SourceSHA256[file],
+		},
+		Headers:             map[string]string{"helper/helper.go": "package helper\n", file: ""},
+		Directories:         map[string][]string{"helper": {"asm.s", "helper.go"}},
+		OrdinaryAsmPackages: []string{"registered"},
+	}
+	rootFiles := map[string]string{
+		"root.go":       "package scope\n",
+		"root_test.go":  "package scope\nimport \"example.invalid/scope/helper\"\n",
+		"probe_amd64.s": "TEXT ·probe(SB),$0-0\nRET\n",
+	}
+	root := TestSourcePackage{
+		Package: PackageProof{
+			PackagePath: module, ModulePath: module, ModuleVersion: "v1.0.0",
+			SourceModule: module, SourceVersion: "v1.0.0", SourceRole: "module",
+			GoFiles: []string{"root.go", "root_test.go"}, CompiledGoFiles: []string{"root.go", "root_test.go"},
+			SFiles: []string{"probe_amd64.s"}, SourceSHA256: make(map[string]string),
+		},
+		VariantID: module + " [" + module + ".test]",
+		ImportMap: map[string]string{module + "/helper": module + "/helper"},
+	}
+	for file, data := range rootFiles {
+		input.Sources[file] = bytesSHA256([]byte(data))
+		input.Headers[file] = data
+		root.Package.SourceSHA256[file] = input.Sources[file]
+	}
+	input.Headers["probe_amd64.s"] = ""
+	input.Directories["."] = []string{"helper", "probe_amd64.s", "root.go", "root_test.go"}
+	for _, selected := range []*TestSourcePackage{&root, &source} {
+		selected.Embed = &TestEmbedSelection{Protocol: TestEmbedProtocol, Directives: make(map[string]string), Files: make(map[string]string)}
+		for _, file := range selected.Package.GoFiles {
+			selected.Embed.Directives[file] = ""
+		}
+	}
+	return input, &TestDependencyProof{Packages: []TestSourcePackage{root, source}}
+}
+
+func TestTestDependencyAssemblyScopeDiagnosticBindsActualPair(t *testing.T) {
+	input, dependency := testDependencyAssemblyScopeFixture()
+	input.Sources["helper/asm.s"] = bytesSHA256([]byte("// nonempty\n"))
+	dependency.Packages[1].Package.SourceSHA256["helper/asm.s"] = input.Sources["helper/asm.s"]
+	err := validateTestSourceClosure(input, dependency, map[string]bool{input.Module: true}, []string{"chosen"})
+	if err == nil {
+		t.Fatal("unregistered assembly acquired a source-only translation role")
+	}
+	for _, detail := range []string{
+		"package=example.invalid/scope/helper", "module=example.invalid/scope@v1.0.0",
+		"source_root=\"\"", "directory=helper", "selected_asm=[\"helper/asm.s\"]",
+		"ordinary_asm_packages=[\"registered\"]",
+		"target=darwin/amd64", "profile=" + input.ID, "tags=[\"chosen\"]",
+	} {
+		if !strings.Contains(err.Error(), detail) {
+			t.Errorf("actual assembly-scope diagnostic lacks %s: %v", detail, err)
+		}
+	}
+}
+
+func TestTestDependencySourceOnlyZeroAssemblyKeepsActualSelection(t *testing.T) {
+	input, dependency := testDependencyAssemblyScopeFixture()
+	// An imported ordinary package is not a supplemental test root. Its
+	// actual zero-byte SFile must remain selected without claiming an object.
+	if err := validateTestSourceClosure(input, dependency, map[string]bool{input.Module: true}, nil); err != nil {
+		t.Fatal(err)
+	}
+	if len(dependency.Packages[1].Package.SFiles) != 1 {
+		t.Fatal("source-only empty sibling disappeared from actual Go selection")
+	}
+}
+
+func TestTestDependencySourceOnlyZeroAssemblyRejectsMissingAndNonzeroEvidence(t *testing.T) {
+	const file = "helper/asm.s"
+	for name, mutate := range map[string]func(*ConsumerInput, *TestDependencyProof){
+		"missing header is not empty": func(i *ConsumerInput, _ *TestDependencyProof) { delete(i.Headers, file) },
+		"nonempty header":             func(i *ConsumerInput, _ *TestDependencyProof) { i.Headers[file] = "\n" },
+		"missing original member": func(i *ConsumerInput, _ *TestDependencyProof) {
+			i.Directories["helper"] = []string{"helper.go"}
+		},
+		"missing original bytes": func(i *ConsumerInput, _ *TestDependencyProof) { delete(i.Sources, file) },
+		"missing actual bytes":   func(_ *ConsumerInput, d *TestDependencyProof) { delete(d.Packages[1].Package.SourceSHA256, file) },
+		"paired byte deletion": func(i *ConsumerInput, d *TestDependencyProof) {
+			delete(i.Sources, file)
+			delete(d.Packages[1].Package.SourceSHA256, file)
+		},
+		"paired selected role and byte deletion": func(_ *ConsumerInput, d *TestDependencyProof) {
+			d.Packages[1].Package.SFiles = nil
+			delete(d.Packages[1].Package.SourceSHA256, file)
+		},
+		"same hash absent original member and header": func(i *ConsumerInput, _ *TestDependencyProof) {
+			delete(i.Headers, file)
+			i.Directories["helper"] = []string{"helper.go"}
+		},
+		"unknown same-module role": func(_ *ConsumerInput, d *TestDependencyProof) { d.Packages[1].Package.SourceRole = "stdlib" },
+		"different module version": func(_ *ConsumerInput, d *TestDependencyProof) { d.Packages[1].Package.ModuleVersion = "v1.0.1" },
+		"different source root":    func(_ *ConsumerInput, d *TestDependencyProof) { d.Packages[1].SourceRootID = "other@v1.0.0" },
+		"mixed nonempty sibling": func(i *ConsumerInput, d *TestDependencyProof) {
+			other := "helper/nonempty.s"
+			i.Sources[other] = bytesSHA256([]byte("// not zero\n"))
+			i.Headers[other] = "//\n"
+			i.Directories["helper"] = append(i.Directories["helper"], "nonempty.s")
+			d.Packages[1].Package.SFiles = append(d.Packages[1].Package.SFiles, other)
+			d.Packages[1].Package.SourceSHA256[other] = i.Sources[other]
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			input, dependency := testDependencyAssemblyScopeFixture()
+			mutate(input, dependency)
+			if err := validateTestSourceClosure(input, dependency, map[string]bool{input.Module: true}, nil); err == nil {
+				t.Fatal("source-only zero-byte role accepted missing or contradictory actual source/selection evidence")
+			}
+		})
+	}
+	for _, data := range []string{"\n", "  \n", "// comment\n", "#define VALUE 1\n", "TEXT ·x(SB),$0-0\nRET\n"} {
+		t.Run("nonzero "+data, func(t *testing.T) {
+			input, dependency := testDependencyAssemblyScopeFixture()
+			input.Sources[file] = bytesSHA256([]byte(data))
+			dependency.Packages[1].Package.SourceSHA256[file] = input.Sources[file]
+			if err := validateTestSourceClosure(input, dependency, map[string]bool{input.Module: true}, nil); err == nil {
+				t.Fatal("nonzero source acquired the exact zero-byte source-only role")
+			}
+		})
+	}
+}
diff --git a/gotoolprofile/test_dependency_embeds.go b/gotoolprofile/test_dependency_embeds.go
new file mode 100644
index 000000000..228fc3e0e
--- /dev/null
+++ b/gotoolprofile/test_dependency_embeds.go
@@ -0,0 +1,353 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"go/build"
+	"go/scanner"
+	"go/token"
+	"io"
+	"io/fs"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+const TestEmbedProtocol = "actual_go_test_dependency_embed_selection_v1"
+
+// Every selected package carries a witness, including packages with no
+// directives. These are source inputs, never assembly/object completion.
+// The producer and consumer compare Directives with actual original bytes;
+// offline replay relies on their authenticated frozen-source provenance.
+type EmbedSelection struct {
+	Protocol   string            `json:"protocol"`
+	Directives map[string]string `json:"directives"`
+	Patterns   []string          `json:"patterns"`
+	Files      map[string]string `json:"files"`
+}
+
+type TestEmbedSelection = EmbedSelection
+
+// Preserve only genuine line-comment directives, not lookalikes in strings
+// or block comments. Pattern syntax is subsequently parsed by stock go/build.
+func TestEmbedDirectives(file string, data []byte) (string, error) {
+	if len(data) > 64<<20 {
+		return "", fmt.Errorf("embed directive source exceeds its byte bound")
+	}
+	var lexer scanner.Scanner
+	fset := token.NewFileSet()
+	var scanErr error
+	lexer.Init(fset.AddFile(file, -1, len(data)), data, func(_ token.Position, msg string) {
+		if scanErr == nil {
+			scanErr = fmt.Errorf("invalid original embed directive source: %s", msg)
+		}
+	}, scanner.ScanComments)
+	var result strings.Builder
+	for {
+		_, kind, text := lexer.Scan()
+		if kind == token.EOF {
+			break
+		}
+		if kind != token.COMMENT || !strings.HasPrefix(text, "//go:embed") {
+			continue
+		}
+		remainder := strings.TrimPrefix(text, "//go:embed")
+		if remainder != "" {
+			separator, _ := utf8.DecodeRuneInString(remainder)
+			if !unicode.IsSpace(separator) {
+				continue
+			}
+		}
+		// Retain potential directives without guessing the toolchain's
+		// whitespace rules. Stock go/build below decides the actual patterns.
+		result.WriteString(text)
+		result.WriteByte('\n')
+	}
+	return result.String(), scanErr
+}
+
+type testEmbedFileInfo string
+
+func (name testEmbedFileInfo) Name() string       { return string(name) }
+func (name testEmbedFileInfo) Size() int64        { return 0 }
+func (name testEmbedFileInfo) Mode() os.FileMode  { return 0600 }
+func (name testEmbedFileInfo) ModTime() time.Time { return time.Time{} }
+func (name testEmbedFileInfo) IsDir() bool        { return false }
+func (name testEmbedFileInfo) Sys() any           { return nil }
+
+func testEmbedPatterns(pkg PackageProof, directives, headers map[string]string) ([]string, error) {
+	ctx := build.Default
+	ctx.JoinPath = path.Join
+	ctx.UseAllFiles, ctx.CgoEnabled = true, false
+	ctx.ReadDir = func(string) ([]fs.FileInfo, error) {
+		var files []fs.FileInfo
+		for _, file := range pkg.GoFiles {
+			files = append(files, testEmbedFileInfo(path.Base(file)))
+		}
+		return files, nil
+	}
+	ctx.OpenFile = func(filename string) (io.ReadCloser, error) {
+		file := path.Join(path.Dir(pkg.GoFiles[0]), path.Base(filename))
+		header, present := headers[file]
+		if !present {
+			return nil, fmt.Errorf("embed source lacks its original selection/import header")
+		}
+		return io.NopCloser(strings.NewReader(header + directives[file] + "var _ string\n")), nil
+	}
+	selected, err := ctx.ImportDir(".", build.IgnoreVendor)
+	if err != nil {
+		return nil, fmt.Errorf("parse original embed directive grammar: %w", err)
+	}
+	patterns := append(append([]string(nil), selected.EmbedPatterns...), selected.TestEmbedPatterns...)
+	sort.Strings(patterns)
+	result := patterns[:0]
+	for _, pattern := range patterns {
+		if len(result) == 0 || pattern != result[len(result)-1] {
+			result = append(result, pattern)
+		}
+	}
+	return result, nil
+}
+
+func testEmbedBadName(name string) bool {
+	return module.CheckFilePath(name) != nil || name == ".git" || name == ".hg" || name == ".svn" || name == ".bzr"
+}
+
+// Resolve stock-Go patterns over complete original directories. A missing
+// subtree is unknown, not an empty match. Nested modules are explicit stops.
+func resolveTestEmbedFiles(dir string, patterns []string, directories map[string][]string, sources map[string]string) (map[string]string, map[string]bool, error) {
+	files, related := make(map[string]string), make(map[string]bool)
+	entries := make(map[string]bool)
+	var collect func(string) error
+	collect = func(current string) error {
+		if len(related) >= 4096 || len(entries) > 65536 {
+			return fmt.Errorf("embed inventory exceeds its directory/member bound")
+		}
+		members, present := directories[current]
+		if !present || members == nil {
+			return fmt.Errorf("embed directory has incomplete original membership: %s", current)
+		}
+		related[current] = true
+		for index, member := range members {
+			if !testSourceLocalPath(member) || path.Base(member) != member || index > 0 && member <= members[index-1] {
+				return fmt.Errorf("embed inventory contains noncanonical original membership")
+			}
+			name := path.Join(current, member)
+			if testEmbedBadName(member) {
+				continue
+			}
+			if len(entries) >= 65536 {
+				return fmt.Errorf("embed inventory exceeds its member bound")
+			}
+			entries[name] = true
+			if digest := sources[name]; digest != "" {
+				if !discoverySHA256Pattern.MatchString(digest) || directories[name] != nil {
+					return fmt.Errorf("embed inventory has conflicting original file/directory roles")
+				}
+			} else {
+				if err := collect(name); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	if len(patterns) == 0 {
+		return files, related, nil
+	}
+	if err := collect(dir); err != nil {
+		return nil, nil, err
+	}
+	var descend func(string, bool) int
+	descend = func(current string, all bool) int {
+		count := 0
+		for _, member := range directories[current] {
+			if testEmbedBadName(member) || !all && (strings.HasPrefix(member, ".") || strings.HasPrefix(member, "_")) {
+				continue
+			}
+			name := path.Join(current, member)
+			if digest := sources[name]; digest != "" {
+				files[name], count = digest, count+1
+			} else if sources[path.Join(name, "go.mod")] == "" {
+				count += descend(name, all)
+			}
+		}
+		return count
+	}
+	checks := 0
+	for _, pattern := range patterns {
+		glob, all := pattern, false
+		if strings.HasPrefix(glob, "all:") {
+			glob, all = strings.TrimPrefix(glob, "all:"), true
+		}
+		if _, err := path.Match(glob, ""); err != nil || glob == "." || !fs.ValidPath(glob) {
+			return nil, nil, fmt.Errorf("invalid embed pattern syntax")
+		}
+		count := 0
+		for name := range entries {
+			checks++
+			if checks > 4<<20 {
+				return nil, nil, fmt.Errorf("embed pattern replay exceeds its explicit matching-work bound")
+			}
+			rel := strings.TrimPrefix(name, dir+"/")
+			if dir == "." {
+				rel = name
+			}
+			matched, err := path.Match(glob, rel)
+			if err != nil || !matched {
+				continue
+			}
+			for ancestor := name; ancestor != dir; ancestor = path.Dir(ancestor) {
+				if sources[path.Join(ancestor, "go.mod")] != "" {
+					return nil, nil, fmt.Errorf("embed match crosses an original nested module")
+				}
+			}
+			if digest := sources[name]; digest != "" {
+				files[name], count = digest, count+1
+				continue
+			}
+			matchedCount := descend(name, all)
+			if matchedCount == 0 {
+				return nil, nil, fmt.Errorf("embed directory contains no embeddable files")
+			}
+			count += matchedCount
+		}
+		if count == 0 {
+			return nil, nil, fmt.Errorf("embed pattern has no original matching files")
+		}
+	}
+	return files, related, nil
+}
+
+func ValidateTestEmbedSelection(pkg PackageProof, proof *TestEmbedSelection, view *ConsumerInput) (map[string]bool, error) {
+	if view == nil || proof == nil || proof.Protocol != TestEmbedProtocol || proof.Directives == nil || proof.Files == nil ||
+		len(proof.Directives) != len(pkg.GoFiles) || len(pkg.GoFiles) == 0 || len(proof.Files) > 65536 || len(proof.Patterns) > 65536 {
+		return nil, fmt.Errorf("missing bounded actual test dependency embed source role")
+	}
+	for _, file := range pkg.GoFiles {
+		directives, present := proof.Directives[file]
+		if !present || len(directives) > 4<<20 || pkg.SourceSHA256[file] == "" {
+			return nil, fmt.Errorf("embed directive is not bound to every selected original Go file")
+		}
+		parsed, err := TestEmbedDirectives(file, []byte(directives))
+		if err != nil || parsed != directives {
+			return nil, fmt.Errorf("noncanonical original embed directive witness")
+		}
+	}
+	patterns, err := testEmbedPatterns(pkg, proof.Directives, view.Headers)
+	if err != nil {
+		return nil, err
+	}
+	if !equalDiscoveryStrings(patterns, proof.Patterns) {
+		return nil, fmt.Errorf("actual embed patterns contradict original Go directives")
+	}
+	files, related, err := resolveTestEmbedFiles(path.Dir(pkg.GoFiles[0]), patterns, view.Directories, view.Sources)
+	if err != nil {
+		return nil, err
+	}
+	if !reflect.DeepEqual(files, proof.Files) {
+		return nil, fmt.Errorf("actual embedded file selection contradicts original membership/bytes")
+	}
+	return related, nil
+}
+
+// Caller authorization is still required: root and every view source/member
+// must already be authenticated from the actual module ZIP or observed GOROOT.
+// This additionally binds compact directives to their actual full-file bytes.
+func VerifyTestEmbedDirectives(pkg PackageProof, proof *TestEmbedSelection, root string) error {
+	for _, file := range pkg.GoFiles {
+		filename, err := CPPRegularSource(root, file)
+		if err != nil {
+			return err
+		}
+		info, err := os.Stat(filename)
+		if err != nil || info.Size() > 64<<20 {
+			return fmt.Errorf("original embed source exceeds its byte bound")
+		}
+		data, err := os.ReadFile(filename)
+		if err != nil || bytesSHA256(data) != pkg.SourceSHA256[file] {
+			return fmt.Errorf("original embed directive source changed")
+		}
+		actual, err := TestEmbedDirectives(file, data)
+		if err != nil || proof == nil || actual != proof.Directives[file] {
+			return fmt.Errorf("recorded embed directives are not original source bytes")
+		}
+	}
+	return nil
+}
+
+// Actual files/patterns come from the same driver load as PackageProof. This
+// capture does not authenticate a root: callers must independently bind its
+// complete original inventory/ZIP (or observed standard-library tool root).
+func CaptureTestEmbedSelection(pkg PackageProof, root string, patterns, files []string) (*TestEmbedSelection, error) {
+	if len(patterns) > 65536 || len(files) > 65536 || len(pkg.GoFiles) == 0 || len(pkg.GoFiles) > 32768 {
+		return nil, fmt.Errorf("actual embed selection exceeds its source/pattern/file bound")
+	}
+	proof := &TestEmbedSelection{
+		Protocol: TestEmbedProtocol, Directives: make(map[string]string), Files: make(map[string]string),
+		Patterns: append([]string(nil), patterns...),
+	}
+	sort.Strings(proof.Patterns)
+	for index, pattern := range proof.Patterns {
+		if index > 0 && pattern == proof.Patterns[index-1] {
+			return nil, fmt.Errorf("actual embed selection repeats a pattern")
+		}
+	}
+	for _, file := range pkg.GoFiles {
+		filename, err := CPPRegularSource(root, file)
+		if err != nil {
+			return nil, err
+		}
+		info, err := os.Stat(filename)
+		if err != nil || info.Size() > 64<<20 {
+			return nil, fmt.Errorf("actual embed Go source exceeds its byte bound")
+		}
+		data, err := os.ReadFile(filename)
+		if err != nil || bytesSHA256(data) != pkg.SourceSHA256[file] {
+			return nil, fmt.Errorf("actual embed source differs from selected Go bytes")
+		}
+		proof.Directives[file], err = TestEmbedDirectives(file, data)
+		if err != nil || len(proof.Directives[file]) > 4<<20 {
+			if err == nil {
+				err = fmt.Errorf("actual embed directives exceed their byte bound")
+			}
+			return nil, err
+		}
+	}
+	for _, file := range files {
+		filename := file
+		if !filepath.IsAbs(filename) {
+			filename = filepath.Join(root, filepath.FromSlash(file))
+		}
+		filename, err := sourcepath.Resolve(filename)
+		if err != nil {
+			return nil, fmt.Errorf("actual embed file has no canonical original source: %w", err)
+		}
+		name, err := filepath.Rel(root, filename)
+		name = filepath.ToSlash(name)
+		if err != nil || !testSourceLocalPath(name) || proof.Files[name] != "" {
+			return nil, fmt.Errorf("actual embed file has a different/duplicate original root role: package=%s", pkg.PackagePath)
+		}
+		filename, err = CPPRegularSource(root, name)
+		if err != nil {
+			return nil, err
+		}
+		info, err := os.Stat(filename)
+		if err != nil || info.Size() > 64<<20 {
+			return nil, fmt.Errorf("actual embed file exceeds its byte bound")
+		}
+		proof.Files[name], err = FileSHA256(filename)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return proof, nil
+}
diff --git a/gotoolprofile/test_dependency_embeds_test.go b/gotoolprofile/test_dependency_embeds_test.go
new file mode 100644
index 000000000..c887f9537
--- /dev/null
+++ b/gotoolprofile/test_dependency_embeds_test.go
@@ -0,0 +1,301 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"go/build"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func testEmbedFixture(t *testing.T, directive string) (PackageProof, *TestEmbedSelection, *ConsumerInput, string) {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := map[string]string{
+		"source.go":          "package actualembed\nimport _ \"embed\"\n" + directive + "\nvar Data []byte\n",
+		"plain.bin":          "original plain bytes",
+		"space name":         "quoted original bytes",
+		"assets/a.bin":       "a",
+		"assets/.hidden":     "dot",
+		"assets/_hidden":     "underscore",
+		"assets/sub/b.bin":   "b",
+		"assets/sub/.hidden": "nested dot",
+	}
+	pkg := PackageProof{
+		GoFiles: []string{"source.go"}, CompiledGoFiles: []string{"source.go"},
+		SourceSHA256: make(map[string]string),
+	}
+	proof := &TestEmbedSelection{Protocol: TestEmbedProtocol, Directives: make(map[string]string), Files: make(map[string]string)}
+	view := &ConsumerInput{Sources: make(map[string]string), Headers: make(map[string]string), Directories: make(map[string][]string)}
+	for file, text := range data {
+		name := filepath.Join(root, filepath.FromSlash(file))
+		if err := os.MkdirAll(filepath.Dir(name), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(name, []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+		view.Sources[file] = bytesSHA256([]byte(text))
+	}
+	if err := filepath.WalkDir(root, func(name string, entry os.DirEntry, err error) error {
+		if err != nil || !entry.IsDir() {
+			return err
+		}
+		dir, err := filepath.Rel(root, name)
+		if err != nil {
+			return err
+		}
+		members, err := os.ReadDir(name)
+		if err != nil {
+			return err
+		}
+		for _, member := range members {
+			view.Directories[filepath.ToSlash(dir)] = append(view.Directories[filepath.ToSlash(dir)], member.Name())
+		}
+		return nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+	header, err := TestSelectionHeader("source.go", []byte(data["source.go"]))
+	if err != nil {
+		t.Fatal(err)
+	}
+	view.Headers["source.go"] = header
+	pkg.SourceSHA256["source.go"] = view.Sources["source.go"]
+	proof.Directives["source.go"], err = TestEmbedDirectives("source.go", []byte(data["source.go"]))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := build.Default.ImportDir(root, build.IgnoreVendor)
+	if err != nil {
+		t.Fatal(err)
+	}
+	proof.Patterns = actual.EmbedPatterns
+	proof.Files, _, err = resolveTestEmbedFiles(".", proof.Patterns, view.Directories, view.Sources)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, proof, view, root
+}
+
+func TestTestDependencyEmbedGrammarAndSelection(t *testing.T) {
+	for _, axis := range []struct {
+		directive string
+		files     []string
+	}{
+		{"//go:embed plain.bin", []string{"plain.bin"}},
+		{"//go:embed \"space name\"", []string{"space name"}},
+		{"//go:embed `space name`", []string{"space name"}},
+		{"//go:embed assets", []string{"assets/a.bin", "assets/sub/b.bin"}},
+		{"//go:embed all:assets", []string{"assets/.hidden", "assets/_hidden", "assets/a.bin", "assets/sub/.hidden", "assets/sub/b.bin"}},
+		{"//go:embed assets/*", []string{"assets/.hidden", "assets/_hidden", "assets/a.bin", "assets/sub/b.bin"}},
+		{"//go:embed plain.bin\n//go:embed plain.bin assets/*.bin", []string{"assets/a.bin", "plain.bin"}},
+		{"", nil},
+	} {
+		t.Run(axis.directive, func(t *testing.T) {
+			pkg, proof, view, root := testEmbedFixture(t, axis.directive)
+			data, err := json.Marshal(proof)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var replay TestEmbedSelection
+			if err := json.Unmarshal(data, &replay); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := ValidateTestEmbedSelection(pkg, &replay, view); err != nil {
+				t.Fatal(err)
+			}
+			if err := VerifyTestEmbedDirectives(pkg, &replay, root); err != nil {
+				t.Fatal(err)
+			}
+			var actual []string
+			for file := range replay.Files {
+				actual = append(actual, file)
+			}
+			sort.Strings(actual)
+			if !reflect.DeepEqual(actual, axis.files) {
+				t.Fatalf("embedded bytes = %q, independent expected %q", actual, axis.files)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+			output, _, err := RunBounded(ctx, root, append(os.Environ(), "GO111MODULE=off", "GOTOOLCHAIN=local"), "go", "list", "-e", "-json", ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var selected struct {
+				EmbedFiles []string
+				Error      *struct{ Err string }
+			}
+			if err := json.Unmarshal(output, &selected); err != nil || selected.Error != nil || !reflect.DeepEqual(actual, selected.EmbedFiles) {
+				t.Fatalf("stock Go selected original embed files = %q, replay = %q, error = %v/%#v", selected.EmbedFiles, actual, err, selected.Error)
+			}
+		})
+	}
+}
+
+func TestTestDependencyEmbedDirectiveWhitespaceMatchesActualGo(t *testing.T) {
+	for _, separator := range []string{" ", "\t", "\v", "\f", "\u00a0", "\u2003"} {
+		t.Run(fmt.Sprintf("U+%04X", []rune(separator)[0]), func(t *testing.T) {
+			pkg, proof, view, root := testEmbedFixture(t, "//go:embed"+separator+"plain.bin")
+			if _, err := ValidateTestEmbedSelection(pkg, proof, view); err != nil {
+				t.Fatalf("actual stock Go patterns %q cannot be replayed: %v", proof.Patterns, err)
+			}
+			var selectedFiles []string
+			if len(proof.Patterns) != 0 {
+				selectedFiles = []string{"plain.bin"}
+			}
+			captured, err := CaptureTestEmbedSelection(pkg, root, proof.Patterns, selectedFiles)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(proof.Patterns) == 0 {
+				// Historical Go parsers may ignore this separator. Their actual
+				// empty selection must remain empty, not acquire a future rule.
+				if len(captured.Files) != 0 {
+					t.Fatal("empty actual selection acquired embedded bytes")
+				}
+			}
+			if _, err := ValidateTestEmbedSelection(pkg, captured, view); err != nil {
+				t.Fatal(err)
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+			output, _, err := RunBounded(ctx, root, append(os.Environ(), "GO111MODULE=off", "GOTOOLCHAIN=local"), "go", "list", "-e", "-json", ".")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var actual struct {
+				EmbedPatterns []string
+				EmbedFiles    []string
+				Error         *struct{ Err string }
+			}
+			if err := json.Unmarshal(output, &actual); err != nil || actual.Error != nil || !reflect.DeepEqual(actual.EmbedPatterns, captured.Patterns) {
+				t.Fatalf("actual Go directive selection disagrees: %s, %v", output, err)
+			}
+			files, err := CaptureTestEmbedSelection(pkg, root, actual.EmbedPatterns, actual.EmbedFiles)
+			if err != nil || !reflect.DeepEqual(files, captured) {
+				t.Fatalf("actual Go asset selection disagrees: %#v, %v", files, err)
+			}
+		})
+	}
+}
+
+func TestTestDependencyEmbedRejectsMissingOrMutatedWitness(t *testing.T) {
+	for name, mutate := range map[string]func(*PackageProof, *TestEmbedSelection, *ConsumerInput){
+		"old protocol":               func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) { p.Protocol = "" },
+		"missing all directives":     func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) { p.Directives = nil },
+		"missing selected directive": func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) { delete(p.Directives, "source.go") },
+		"directive changed only": func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) {
+			p.Directives["source.go"] = "//go:embed plain.bin\n"
+		},
+		"pattern changed only":  func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) { p.Patterns = []string{"plain.bin"} },
+		"missing selected file": func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) { delete(p.Files, "assets/a.bin") },
+		"changed selected file bytes": func(_ *PackageProof, p *TestEmbedSelection, _ *ConsumerInput) {
+			p.Files["assets/a.bin"] = strings.Repeat("0", 64)
+		},
+		"missing nested directory": func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) { delete(v.Directories, "assets/sub") },
+		"same hash missing member": func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) {
+			v.Directories["assets"] = []string{".hidden", "_hidden", "sub"}
+		},
+		"truncated directory":  func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) { delete(v.Directories, ".") },
+		"fake original source": func(p *PackageProof, _ *TestEmbedSelection, _ *ConsumerInput) { p.SourceSHA256 = nil },
+		"malformed directory member": func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) {
+			v.Directories["assets"] = []string{"../escape"}
+		},
+		"file masquerades as directory": func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) {
+			v.Directories["assets/a.bin"] = []string{}
+		},
+		"mixed nested module": func(_ *PackageProof, _ *TestEmbedSelection, v *ConsumerInput) {
+			v.Sources["assets/go.mod"] = bytesSHA256([]byte("module example.invalid/foreign\n"))
+			v.Directories["assets"] = append(v.Directories["assets"], "go.mod")
+			sort.Strings(v.Directories["assets"])
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, proof, view, _ := testEmbedFixture(t, "//go:embed assets")
+			mutate(&pkg, proof, view)
+			if _, err := ValidateTestEmbedSelection(pkg, proof, view); err == nil {
+				t.Fatal("accepted incomplete/changed embed selection")
+			}
+		})
+	}
+	t.Run("paired deletion", func(t *testing.T) {
+		pkg, _, view, _ := testEmbedFixture(t, "//go:embed assets")
+		if _, err := ValidateTestEmbedSelection(pkg, nil, view); err == nil {
+			t.Fatal("paired input/consumer deletion downgraded the required embed role")
+		}
+	})
+}
+
+func TestTestDependencyEmbedOriginalDirectiveBytesAndGrammar(t *testing.T) {
+	pkg, proof, _, root := testEmbedFixture(t, "//go:embed assets")
+	proof.Directives["source.go"] = "//go:embed plain.bin\n"
+	if err := VerifyTestEmbedDirectives(pkg, proof, root); err == nil {
+		t.Fatal("arbitrary directive kept full-file SHA but passed actual byte comparison")
+	}
+	for _, source := range []string{
+		"package p\nvar s = `//go:embed fake`\n",
+		"package p\n/* //go:embed fake */\n",
+		"package p\n//go:embedded fake\n",
+	} {
+		actual, err := TestEmbedDirectives("source.go", []byte(source))
+		if err != nil || actual != "" {
+			t.Fatalf("non-directive received source authority: %q, %v", actual, err)
+		}
+	}
+	for _, directive := range []string{"//go:embed \"unterminated", "//go:embed \"x\"trailing", "//go:embed ../bad", "//go:embed .", "//go:embed [", "//go:embed absent"} {
+		pkg, proof, view, _ := testEmbedFixture(t, "//go:embed plain.bin")
+		proof.Directives["source.go"] = directive + "\n"
+		proof.Patterns = []string{strings.TrimPrefix(directive, "//go:embed ")}
+		if _, err := ValidateTestEmbedSelection(pkg, proof, view); err == nil {
+			t.Errorf("accepted malformed/empty original pattern %q", directive)
+		}
+	}
+	if path.Dir(pkg.GoFiles[0]) != "." {
+		t.Fatal("fixture changed package directory identity")
+	}
+}
+
+func TestTestDependencyEmbedActualCaptureRejectsOtherRootAndDuplicates(t *testing.T) {
+	pkg, proof, _, root := testEmbedFixture(t, "//go:embed plain.bin")
+	outside := filepath.Join(t.TempDir(), "plain.bin")
+	if err := os.WriteFile(outside, []byte("original plain bytes"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := CaptureTestEmbedSelection(pkg, root, proof.Patterns, []string{outside}); err == nil {
+		t.Fatal("identical asset bytes from another module acquired original membership")
+	}
+	if _, err := CaptureTestEmbedSelection(pkg, root, []string{"plain.bin", "plain.bin"}, nil); err == nil {
+		t.Fatal("noncanonical actual duplicate patterns were accepted")
+	}
+	if _, err := CaptureTestEmbedSelection(pkg, root, proof.Patterns, []string{"plain.bin", "plain.bin"}); err == nil {
+		t.Fatal("noncanonical actual duplicate asset roles were accepted")
+	}
+}
+
+func TestTestDependencyEmbedMatchingWorkIsBounded(t *testing.T) {
+	const count = 2050
+	var patterns []string
+	directories, sources := map[string][]string{".": {}}, make(map[string]string)
+	for index := 0; index < count; index++ {
+		name := fmt.Sprintf("file-%04d.bin", index)
+		directories["."] = append(directories["."], name)
+		sources[name] = bytesSHA256(nil)
+		patterns = append(patterns, name)
+	}
+	_, _, err := resolveTestEmbedFiles(".", patterns, directories, sources)
+	if err == nil || !strings.Contains(err.Error(), "matching-work bound") {
+		t.Fatalf("large valid inventory did not retain the explicit resource failure: %v", err)
+	}
+}
diff --git a/gotoolprofile/test_dependency_go_mod_metadata.go b/gotoolprofile/test_dependency_go_mod_metadata.go
new file mode 100644
index 000000000..39a250b1c
--- /dev/null
+++ b/gotoolprofile/test_dependency_go_mod_metadata.go
@@ -0,0 +1,56 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// VerifyTestModuleGoModMetadata binds actual Go Module.GoMod to the independent
+// exact-version download. Paths are private observations, not portable proof
+// fields. The source-root/ZIP verifier remains separately mandatory.
+func VerifyTestModuleGoModMetadata(source TestModuleSource, root, actual, downloaded string) error {
+	if err := ValidateTestModuleSource(source); err != nil {
+		return err
+	}
+	if source.SourceModule == "" {
+		return fmt.Errorf("stdlib cannot acquire proxy/module metadata")
+	}
+	canonical := func(filename string) (string, error) {
+		info, err := os.Lstat(filename)
+		if err != nil || !filepath.IsAbs(filename) || !info.Mode().IsRegular() {
+			return "", fmt.Errorf("actual dependency metadata is not a regular absolute source")
+		}
+		resolved, err := sourcepath.Resolve(filename)
+		if err != nil {
+			return "", fmt.Errorf("actual dependency metadata is missing or redirected")
+		}
+		digest, err := FileSHA256(resolved)
+		if err != nil || digest != source.GoModSHA256 {
+			return "", fmt.Errorf("actual dependency metadata differs from its authenticated origin")
+		}
+		return resolved, nil
+	}
+	actualPath, err := canonical(actual)
+	if err != nil {
+		return err
+	}
+	downloadPath, err := canonical(downloaded)
+	if err != nil {
+		return err
+	}
+	if source.GoModOrigin == ProxyGoModProtocol {
+		if actualPath != downloadPath {
+			return fmt.Errorf("actual dependency proxy metadata uses a different exact download path")
+		}
+		relative, err := filepath.Rel(root, downloadPath)
+		withinRoot := relative != ".." && !strings.HasPrefix(relative, ".."+string(filepath.Separator)) && !filepath.IsAbs(relative)
+		if err != nil || withinRoot {
+			return fmt.Errorf("proxy metadata must remain outside original ZIP source root")
+		}
+	}
+	return nil
+}
diff --git a/gotoolprofile/test_dependency_go_mod_origin.go b/gotoolprofile/test_dependency_go_mod_origin.go
new file mode 100644
index 000000000..8988f0f2d
--- /dev/null
+++ b/gotoolprofile/test_dependency_go_mod_origin.go
@@ -0,0 +1,40 @@
+package gotoolprofile
+
+import "fmt"
+
+// The proxy role authenticates metadata outside the immutable archive. It
+// never supplies a missing ZIP member or authorizes unrelated local sources.
+func validateTestModuleGoModOrigin(source TestModuleSource) error {
+	if source.SourceModule == "" {
+		return nil // The stdlib role forbids all module fields in its caller.
+	}
+	switch source.GoModOrigin {
+	case TestModuleOriginalGoModOrigin:
+		if source.ProxyGoMod != nil || source.Sources["go.mod"] != source.GoModSHA256 {
+			return fmt.Errorf("test dependency original go.mod lacks its exact ZIP source role")
+		}
+	case ProxyGoModProtocol:
+		proof := source.ProxyGoMod
+		if proof == nil || proof.Module != source.SourceModule || proof.Version != source.SourceVersion ||
+			proof.ModuleSum != source.ModuleSum || proof.GoModSum != source.GoModSum || proof.SHA256 != source.GoModSHA256 {
+			return fmt.Errorf("test dependency proxy metadata lacks its exact signed module/mod identity")
+		}
+		if _, present := source.Sources["go.mod"]; present {
+			return fmt.Errorf("test dependency proxy metadata cannot impersonate original ZIP bytes")
+		}
+		if _, present := source.Headers["go.mod"]; present {
+			return fmt.Errorf("test dependency proxy metadata cannot impersonate a source header")
+		}
+		for _, entry := range source.Directories["."] {
+			if entry.Name == "go.mod" {
+				return fmt.Errorf("test dependency proxy metadata conflicts with original directory membership")
+			}
+		}
+		if err := ValidateProxyGoMod(proof); err != nil {
+			return fmt.Errorf("authenticate test dependency proxy metadata: %w", err)
+		}
+	default:
+		return fmt.Errorf("test dependency lacks a recognized mandatory go.mod origin")
+	}
+	return nil
+}
diff --git a/gotoolprofile/test_dependency_legacy_metadata_test.go b/gotoolprofile/test_dependency_legacy_metadata_test.go
new file mode 100644
index 000000000..1ab5e6df3
--- /dev/null
+++ b/gotoolprofile/test_dependency_legacy_metadata_test.go
@@ -0,0 +1,209 @@
+package gotoolprofile
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This fixture exercises the compact shape plus the real public SumDB proof.
+// Its local source inventory is not the authenticated AEZ archive. Production
+// still has to compare the whole actual ZIP and selected bytes independently.
+func legacyTestModuleShape(t *testing.T) TestModuleSource {
+	t.Helper()
+	source, _, _ := testDependencyModuleFixture(t)
+	proof := fixtureProxyGoMod(t)
+	delete(source.Sources, "go.mod")
+	for index, entry := range source.Directories["."] {
+		if entry.Name == "go.mod" {
+			source.Directories["."] = append(source.Directories["."][:index], source.Directories["."][index+1:]...)
+			break
+		}
+	}
+	source.SourceModule, source.SourceVersion = proof.Module, proof.Version
+	source.ModuleSum, source.GoModSum, source.GoModSHA256 = proof.ModuleSum, proof.GoModSum, proof.SHA256
+	data, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fields map[string]any
+	if err := json.Unmarshal(data, &fields); err != nil {
+		t.Fatal(err)
+	}
+	fields["go_mod_origin"], fields["proxy_go_mod"] = ProxyGoModProtocol, proof
+	data, err = json.Marshal(fields)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal(data, &source); err != nil {
+		t.Fatal(err)
+	}
+	return source
+}
+
+func TestTestDependencyLegacyAuthenticatedMetadataShape(t *testing.T) {
+	source := legacyTestModuleShape(t)
+	if err := ValidateTestModuleSource(cloneTestModuleSource(t, source)); err != nil {
+		t.Fatal("authenticated metadata outside an original ZIP must retain its own origin:", err)
+	}
+}
+
+func TestTestDependencyGoModOriginCannotBeDeleted(t *testing.T) {
+	source, _, _ := testDependencyModuleFixture(t)
+	data, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var fields map[string]any
+	if err := json.Unmarshal(data, &fields); err != nil {
+		t.Fatal(err)
+	}
+	delete(fields, "go_mod_origin")
+	delete(fields, "proxy_go_mod")
+	data, err = json.Marshal(fields)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var replay TestModuleSource
+	if err := json.Unmarshal(data, &replay); err != nil {
+		t.Fatal(err)
+	}
+	if err := ValidateTestModuleSource(replay); err == nil {
+		t.Fatal("paired deletion of metadata-origin fields downgraded a current source-root proof")
+	}
+}
+
+func TestTestDependencyLegacyMetadataMutations(t *testing.T) {
+	source := legacyTestModuleShape(t)
+	for name, mutate := range map[string]func(*TestModuleSource){
+		"old root protocol": func(p *TestModuleSource) { p.Protocol = "actual_go_test_dependency_module_sources_v1" },
+		"unknown origin":    func(p *TestModuleSource) { p.GoModOrigin = "local_metadata" },
+		"missing origin and signature": func(p *TestModuleSource) {
+			p.GoModOrigin, p.ProxyGoMod = "", nil
+		},
+		"missing signature":     func(p *TestModuleSource) { p.ProxyGoMod = nil },
+		"changed module":        func(p *TestModuleSource) { p.SourceModule += "/other" },
+		"changed version":       func(p *TestModuleSource) { p.SourceVersion = "v1.0.0" },
+		"changed ZIP h1":        func(p *TestModuleSource) { p.ModuleSum = p.GoModSum },
+		"changed metadata h1":   func(p *TestModuleSource) { p.GoModSum = p.ModuleSum },
+		"changed metadata hash": func(p *TestModuleSource) { p.GoModSHA256 = strings.Repeat("0", 64) },
+		"forged ZIP member":     func(p *TestModuleSource) { p.Sources["go.mod"] = p.GoModSHA256 },
+		"forged ZIP directory entry": func(p *TestModuleSource) {
+			p.Directories["."] = append(p.Directories["."], TestSourceEntry{Name: "go.mod", Kind: "file", SHA256: p.GoModSHA256})
+		},
+		"proxy marked original ZIP": func(p *TestModuleSource) { p.GoModOrigin = TestModuleOriginalGoModOrigin },
+		"changed signed metadata":   func(p *TestModuleSource) { p.ProxyGoMod.Contents += "//changed\n" },
+		"unsigned tree":             func(p *TestModuleSource) { p.ProxyGoMod.SignedTree = "" },
+		"missing inclusion":         func(p *TestModuleSource) { p.ProxyGoMod.Inclusion = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneTestModuleSource(t, source)
+			mutate(&changed)
+			if err := ValidateTestModuleSource(changed); err == nil {
+				t.Fatal("changed or deleted legacy identity acquired source-root authority")
+			}
+		})
+	}
+	_, root, archive := testDependencyModuleFixture(t)
+	// A valid public metadata record cannot authenticate a different local
+	// archive. Recompute only its physical hash to reach the actual h1 guard.
+	source.ZipSHA256, _ = FileSHA256(archive)
+	if err := verifyTestModuleZIP(context.Background(), source, archive); err == nil {
+		t.Fatal("a self-consistent source/ZIP snapshot replaced the signed original module h1")
+	}
+	if err := VerifyTestModuleSource(context.Background(), source, root, archive); err == nil {
+		t.Fatal("proxy metadata bypassed complete actual source directory and ZIP verification")
+	}
+}
+
+func TestTestDependencyLegacyActualMetadataPathAndBytes(t *testing.T) {
+	source := legacyTestModuleShape(t)
+	root, metadata := t.TempDir(), filepath.Join(t.TempDir(), "authenticated.mod")
+	root, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	write := func(filename string) {
+		t.Helper()
+		if err := os.WriteFile(filename, []byte(source.ProxyGoMod.Contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write(metadata)
+	if err := VerifyTestModuleGoModMetadata(source, root, metadata, metadata); err != nil {
+		t.Fatal(err)
+	}
+	copy := filepath.Join(t.TempDir(), "equal.mod")
+	write(copy)
+	if err := VerifyTestModuleGoModMetadata(source, root, copy, metadata); err == nil {
+		t.Fatal("equal bytes at a different actual Module.GoMod path retained proxy origin")
+	}
+	inside := filepath.Join(root, "proxy.mod")
+	write(inside)
+	if err := VerifyTestModuleGoModMetadata(source, root, inside, inside); err == nil {
+		t.Fatal("proxy metadata inside the original archive acquired an external role")
+	}
+	redirect := filepath.Join(t.TempDir(), "redirect.mod")
+	if err := os.Symlink(metadata, redirect); err != nil {
+		t.Fatal(err)
+	}
+	if err := VerifyTestModuleGoModMetadata(source, root, redirect, metadata); err == nil {
+		t.Fatal("redirected metadata retained its actual regular source role")
+	}
+	if err := os.WriteFile(metadata, []byte("module example.invalid/changed\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := VerifyTestModuleGoModMetadata(source, root, metadata, metadata); err == nil {
+		t.Fatal("metadata bytes changed after authentication without failing")
+	}
+}
+
+func TestTestDependencyLegacyPackageRoleRequiresMatchingOrigin(t *testing.T) {
+	root := legacyTestModuleShape(t)
+	input := &ConsumerInput{Module: "example.invalid/main", Version: "v1.0.0"}
+	source := TestSourcePackage{
+		Package: PackageProof{
+			PackagePath: root.SourceModule, ModulePath: root.SourceModule, ModuleVersion: root.SourceVersion,
+			SourceModule: root.SourceModule, SourceVersion: root.SourceVersion, SourceRole: "module",
+			GoModOrigin: root.GoModOrigin, GoModSHA256: root.GoModSHA256, GoModSum: root.GoModSum,
+		},
+		SourceRootID: root.ID(), ExportSHA256: strings.Repeat("a", 64),
+	}
+	roots := map[string]TestModuleSource{root.ID(): root}
+	if _, err := testDependencyPackageInput(input, source, roots); err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*TestSourcePackage){
+		"deleted package origin":   func(p *TestSourcePackage) { p.Package.GoModOrigin = "" },
+		"deleted package hash":     func(p *TestSourcePackage) { p.Package.GoModSHA256 = "" },
+		"deleted package h1":       func(p *TestSourcePackage) { p.Package.GoModSum = "" },
+		"fake original metadata":   func(p *TestSourcePackage) { p.Package.GoModOrigin = TestModuleOriginalGoModOrigin },
+		"different source version": func(p *TestSourcePackage) { p.Package.SourceVersion = "v1.0.0" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := source
+			mutate(&changed)
+			if _, err := testDependencyPackageInput(input, changed, roots); err == nil {
+				t.Fatal("package metadata did not match its exact authenticated source root")
+			}
+		})
+	}
+}
+
+func TestTestDependencyLegacyMetadataRequiresRealArchive(t *testing.T) {
+	source := legacyTestModuleShape(t)
+	if source.Sources["go.mod"] != "" {
+		t.Fatal("proxy metadata was inserted into the original file inventory")
+	}
+	for _, entry := range source.Directories["."] {
+		if entry.Name == "go.mod" {
+			t.Fatal("proxy metadata was inserted into the original directory inventory")
+		}
+	}
+	if strings.Contains(source.ID(), "example.invalid") {
+		t.Fatal("fixture lost the actual signed public module identity")
+	}
+}
diff --git a/gotoolprofile/test_dependency_module_closure.go b/gotoolprofile/test_dependency_module_closure.go
new file mode 100644
index 000000000..31d614024
--- /dev/null
+++ b/gotoolprofile/test_dependency_module_closure.go
@@ -0,0 +1,81 @@
+package gotoolprofile
+
+import (
+	"fmt"
+	"strings"
+
+	"golang.org/x/mod/module"
+)
+
+func testDependencySourceModules(input *ConsumerInput, dependency *TestDependencyProof) (map[string]TestModuleSource, error) {
+	return sourceModuleSnapshots(input, dependency.SourceModules)
+}
+
+func sourceModuleSnapshots(input *ConsumerInput, sources []ModuleSourceSnapshot) (map[string]ModuleSourceSnapshot, error) {
+	if len(sources) > 4096 {
+		return nil, fmt.Errorf("test dependency source modules exceed their bounded scope")
+	}
+	modules := make(map[string]TestModuleSource)
+	for index, source := range sources {
+		if err := ValidateTestModuleSource(source); err != nil {
+			return nil, err
+		}
+		id := source.ID()
+		if index > 0 && id <= sources[index-1].ID() || source.SourceModule == "" && source.GoVersion != input.Observed.GoVersion {
+			return nil, fmt.Errorf("test dependency source roots have noncanonical identities/tool versions")
+		}
+		modules[id] = source
+	}
+	return modules, nil
+}
+
+func testDependencyPackageInput(input *ConsumerInput, source TestSourcePackage, modules map[string]TestModuleSource) (*ConsumerInput, error) {
+	pkg := source.Package
+	builtin := source.Builtin == "go_typechecker_unsafe_v1"
+	if source.Builtin != "" && (!builtin || pkg.PackagePath != "unsafe" || source.VariantID != "unsafe" ||
+		pkg.SourceRole != "stdlib" || source.ExportSHA256 != "" || len(source.ImportMap) != 0 ||
+		len(pkg.GoFiles) != 1 || pkg.GoFiles[0] != "unsafe/unsafe.go" || len(pkg.CompiledGoFiles) != 0 || len(pkg.SFiles) != 0) {
+		return nil, fmt.Errorf("test dependency changed the actual unsafe typechecker/documentation role")
+	}
+	if source.SourceRootID == "" {
+		if source.ExportSHA256 != "" || pkg.PackagePath != input.Module && !strings.HasPrefix(pkg.PackagePath, input.Module+"/") {
+			return nil, fmt.Errorf("test dependency has a different actual original-module source role")
+		}
+		if err := ValidatePackageModule(input, pkg); err != nil {
+			return nil, err
+		}
+		return input, nil
+	}
+	root, found := modules[source.SourceRootID]
+	if !found || !builtin && !discoverySHA256Pattern.MatchString(source.ExportSHA256) || pkg.PackagePath == "unsafe" && !builtin {
+		return nil, fmt.Errorf("test dependency lacks its actual foreign module/source/export boundary")
+	}
+	if pkg.ModulePath == input.Module {
+		return nil, fmt.Errorf("foreign dependency impersonates original candidate")
+	}
+	if pkg.SourceRole == "stdlib" {
+		if root.SourceModule != "" || pkg.ModulePath != "" || pkg.ModuleVersion != "" || pkg.SourceModule != "" || pkg.SourceVersion != "" ||
+			pkg.GoModOrigin != "" || pkg.GoModSHA256 != "" || pkg.GoModSum != "" ||
+			strings.Contains(strings.Split(pkg.PackagePath, "/")[0], ".") {
+			return nil, fmt.Errorf("test dependency changed actual stdlib source/tool role")
+		}
+	} else if module.Check(pkg.ModulePath, pkg.ModuleVersion) != nil ||
+		pkg.PackagePath != pkg.ModulePath && !strings.HasPrefix(pkg.PackagePath, pkg.ModulePath+"/") ||
+		pkg.SourceModule != root.SourceModule || pkg.SourceVersion != root.SourceVersion ||
+		pkg.GoModOrigin != root.GoModOrigin || pkg.GoModSHA256 != root.GoModSHA256 || pkg.GoModSum != root.GoModSum ||
+		pkg.SourceRole != "module" && pkg.SourceRole != "version_replace" ||
+		pkg.SourceRole == "module" && (pkg.SourceModule != pkg.ModulePath || pkg.SourceVersion != pkg.ModuleVersion) {
+		return nil, fmt.Errorf("test dependency changed actual Module/Replace source identity")
+	}
+	view := *input
+	view.Module, view.Version, view.SourceModule = pkg.ModulePath, pkg.ModuleVersion, pkg.SourceModule
+	view.Sources, view.Headers = root.Sources, root.Headers
+	view.Directories = make(map[string][]string)
+	for dir, entries := range root.Directories {
+		view.Directories[dir] = []string{}
+		for _, entry := range entries {
+			view.Directories[dir] = append(view.Directories[dir], entry.Name)
+		}
+	}
+	return &view, nil
+}
diff --git a/gotoolprofile/test_dependency_module_sources.go b/gotoolprofile/test_dependency_module_sources.go
new file mode 100644
index 000000000..2c79287f0
--- /dev/null
+++ b/gotoolprofile/test_dependency_module_sources.go
@@ -0,0 +1,442 @@
+package gotoolprofile
+
+import (
+	"archive/zip"
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"go/build/constraint"
+	"go/parser"
+	"go/token"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+const TestDependencyModuleProtocol = "actual_go_test_dependency_module_sources_v2"
+
+const TestModuleOriginalGoModOrigin = "original_zip_go_mod"
+
+// TestModuleSource is portable source evidence, not an authorization to load
+// arbitrary paths. The producer authenticates the Go download separately;
+// the consumer derives its own actual Module/Replace directory and ZIP and
+// compares their bytes. Offline replay relies on that frozen-run provenance.
+// Neither an export nor an external assembly file is a candidate LLVM output.
+type ModuleSourceSnapshot struct {
+	Protocol      string                       `json:"protocol"`
+	SourceModule  string                       `json:"source_module"`
+	SourceVersion string                       `json:"source_version"`
+	GoVersion     string                       `json:"go_version,omitempty"`
+	ModuleSum     string                       `json:"module_sum,omitempty"`
+	ZipSHA256     string                       `json:"zip_sha256,omitempty"`
+	GoModSum      string                       `json:"go_mod_sum,omitempty"`
+	GoModSHA256   string                       `json:"go_mod_sha256,omitempty"`
+	GoModOrigin   string                       `json:"go_mod_origin,omitempty"`
+	ProxyGoMod    *ProxyGoModProof             `json:"proxy_go_mod,omitempty"`
+	Sources       map[string]string            `json:"sources"`
+	Headers       map[string]string            `json:"selection_headers"`
+	Directories   map[string][]TestSourceEntry `json:"directories"`
+}
+
+// This is a source artifact, not a test-package authorization. Existing test
+// and instrumentation protocols continue to bind it through their own owners.
+type TestModuleSource = ModuleSourceSnapshot
+
+type TestSourceEntry struct {
+	Name   string `json:"name"`
+	Kind   string `json:"kind"`
+	SHA256 string `json:"sha256,omitempty"`
+}
+
+func (source ModuleSourceSnapshot) ID() string {
+	if source.SourceModule == "" {
+		return "stdlib@" + source.GoVersion
+	}
+	return source.SourceModule + "@" + source.SourceVersion
+}
+
+func testSourceLocalPath(name string) bool {
+	return name != "." && name != "" && path.Clean(name) == name &&
+		!path.IsAbs(name) && !strings.HasPrefix(name, "../") && !strings.Contains(name, "\\")
+}
+
+// ValidateTestModuleSource checks the compact witness shape and complete
+// directory/header membership. It does not authenticate arbitrary recorded
+// headers against a ZIP: VerifyTestModuleSource performs that byte comparison.
+func ValidateTestModuleSource(source TestModuleSource) error {
+	if source.Protocol != TestDependencyModuleProtocol || len(source.Directories) == 0 || len(source.Directories) > 4096 ||
+		len(source.Sources) == 0 || len(source.Sources) > 65536 || len(source.Headers) > 32768 {
+		return fmt.Errorf("missing bounded test dependency source-root inventory")
+	}
+	if source.SourceModule == "" {
+		if _, err := goMinor(source.GoVersion); err != nil || source.SourceVersion != "" || source.ModuleSum != "" ||
+			source.ZipSHA256 != "" || source.GoModSum != "" || source.GoModSHA256 != "" ||
+			source.GoModOrigin != "" || source.ProxyGoMod != nil {
+			return fmt.Errorf("stdlib dependency has a different source/tool role")
+		}
+	} else if module.Check(source.SourceModule, source.SourceVersion) != nil || source.GoVersion != "" ||
+		!testDependencyH1(source.ModuleSum) || !testDependencyH1(source.GoModSum) ||
+		!discoverySHA256Pattern.MatchString(source.ZipSHA256) || !discoverySHA256Pattern.MatchString(source.GoModSHA256) {
+		return fmt.Errorf("external dependency lacks exact ZIP/module/mod source identity")
+	}
+	if err := validateTestModuleGoModOrigin(source); err != nil {
+		return err
+	}
+	return ValidateSourceInventory(source.Inventory())
+}
+
+// Inventory is pure file membership evidence, not a test, ordinary or compiler
+// permission. Each consuming role separately authenticates its root and graph.
+func (source ModuleSourceSnapshot) Inventory() SourceInventory {
+	return SourceInventory{Sources: source.Sources, Headers: source.Headers, Directories: source.Directories}
+}
+
+func ValidateSourceInventory(source SourceInventory) error {
+	if len(source.Directories) == 0 || len(source.Directories) > 4096 || len(source.Sources) == 0 ||
+		len(source.Sources) > 65536 || len(source.Headers) > 32768 {
+		return fmt.Errorf("missing bounded source-root inventory")
+	}
+	if source.Directories["."] == nil {
+		return fmt.Errorf("test dependency omits its actual source-root directory")
+	}
+	used := make(map[string]string)
+	entryCount := 0
+	for dir, entries := range source.Directories {
+		if dir != "." && !testSourceLocalPath(dir) || entries == nil || len(entries) > 65536 {
+			return fmt.Errorf("unsafe or unbounded test dependency directory")
+		}
+		if dir != "." {
+			found := false
+			for _, entry := range source.Directories[path.Dir(dir)] {
+				found = found || entry.Name == path.Base(dir) && entry.Kind == "directory"
+			}
+			if !found {
+				return fmt.Errorf("test dependency omits its complete ancestor membership")
+			}
+		}
+		for i, entry := range entries {
+			entryCount++
+			if entryCount > 65536 {
+				return fmt.Errorf("test dependency directory inventory exceeds its total entry bound")
+			}
+			if !testSourceLocalPath(entry.Name) || path.Base(entry.Name) != entry.Name ||
+				i > 0 && entry.Name <= entries[i-1].Name || entry.Kind != "file" && entry.Kind != "directory" {
+				return fmt.Errorf("noncanonical test dependency directory entry")
+			}
+			if entry.Kind == "directory" {
+				if entry.SHA256 != "" {
+					return fmt.Errorf("directory cannot impersonate dependency source bytes")
+				}
+				continue
+			}
+			file := path.Join(dir, entry.Name)
+			if !discoverySHA256Pattern.MatchString(entry.SHA256) || source.Sources[file] != entry.SHA256 {
+				return fmt.Errorf("test dependency entry/source digest disagrees")
+			}
+			used[file] = entry.SHA256
+			if path.Ext(file) == ".go" || path.Ext(file) == ".s" {
+				if _, found := source.Headers[file]; !found {
+					return fmt.Errorf("test dependency omits a complete directory selection header")
+				}
+			}
+		}
+	}
+	if !reflect.DeepEqual(used, source.Sources) {
+		return fmt.Errorf("test dependency contains unrelated/unregistered source bytes")
+	}
+	for file, header := range source.Headers {
+		if source.Sources[file] == "" || path.Ext(file) != ".go" && path.Ext(file) != ".s" || len(header) > 4<<20 {
+			return fmt.Errorf("test dependency has an unbound or oversized selection header")
+		}
+	}
+	return nil
+}
+
+func testDependencyH1(sum string) bool {
+	// A canonical h1 is 44 base64 bytes after its prefix. The decoder also
+	// rejects a same-length string that is not a SHA256 checksum.
+	return validProxyGoModH1(sum)
+}
+
+// TestSelectionHeader preserves Go's leading-comment/blank-line semantics
+// and the original package/import spelling without storing function bodies.
+func TestSelectionHeader(file string, data []byte) (string, error) {
+	var header string
+	switch path.Ext(file) {
+	case ".go":
+		syntax, err := parser.ParseFile(token.NewFileSet(), file, data, parser.ImportsOnly)
+		if err != nil {
+			return "", err
+		}
+		end := syntax.Name.End()
+		for _, decl := range syntax.Decls {
+			if decl.End() > end {
+				end = decl.End()
+			}
+		}
+		header = string(data[:int(end)-1]) + "\n"
+	case ".s":
+		scanner := bufio.NewScanner(bytes.NewReader(data))
+		scanner.Buffer(make([]byte, 64<<10), 4<<20)
+		inBlock := false
+		var out strings.Builder
+		for scanner.Scan() {
+			line := scanner.Text()
+			trimmed := strings.TrimSpace(line)
+			if !inBlock && trimmed != "" && !strings.HasPrefix(trimmed, "//") && !strings.HasPrefix(trimmed, "/*") {
+				break
+			}
+			out.WriteString(line + "\n")
+			if strings.HasPrefix(trimmed, "/*") {
+				inBlock = true
+			}
+			if inBlock && strings.Contains(trimmed, "*/") {
+				inBlock = false
+			}
+		}
+		if err := scanner.Err(); err != nil {
+			return "", err
+		}
+		header = out.String()
+	default:
+		return "", fmt.Errorf("not a Go/ASM dependency selection source")
+	}
+	lines := strings.Split(header, "\n")
+	inBlock := false
+	for i, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if inBlock {
+			if strings.Contains(trimmed, "*/") {
+				inBlock = false
+			}
+			continue
+		}
+		if strings.HasPrefix(trimmed, "/*") {
+			inBlock = !strings.Contains(trimmed, "*/")
+			continue
+		}
+		if strings.HasPrefix(trimmed, "//") && !constraint.IsGoBuild(trimmed) && !constraint.IsPlusBuild(trimmed) && !strings.HasPrefix(trimmed, "//line ") {
+			lines[i] = line[:strings.Index(line, "//")] + "//"
+		}
+	}
+	return strings.Join(lines, "\n"), nil
+}
+
+// VerifyTestModuleSource compares the independent snapshot with real bytes.
+// For a module, archive must be the actual Go-downloaded original ZIP, not an
+// archive assembled from the snapshot. The caller checks Module/Replace and
+// actual download h1/modh1 before invoking this routine.
+func VerifyTestModuleSource(ctx context.Context, source TestModuleSource, root, archive string) error {
+	if ctx == nil || ctx.Err() != nil {
+		return fmt.Errorf("test dependency source verification requires a live context")
+	}
+	if err := ValidateTestModuleSource(source); err != nil {
+		return err
+	}
+	if err := VerifySourceInventory(ctx, source.Inventory(), root); err != nil {
+		return err
+	}
+	if source.SourceModule == "" {
+		if archive != "" {
+			return fmt.Errorf("stdlib source cannot acquire a module ZIP role")
+		}
+		return nil
+	}
+	return verifyTestModuleZIP(ctx, source, archive)
+}
+
+func VerifySourceInventory(ctx context.Context, source SourceInventory, root string) error {
+	if ctx == nil || ctx.Err() != nil {
+		return fmt.Errorf("source verification requires a live context")
+	}
+	if err := ValidateSourceInventory(source); err != nil {
+		return err
+	}
+	resolved, err := sourcepath.Resolve(root)
+	if err != nil || !filepath.IsAbs(root) || resolved != root {
+		return fmt.Errorf("test dependency source root is missing or redirected")
+	}
+	for dir, wanted := range source.Directories {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		entries, err := os.ReadDir(filepath.Join(root, filepath.FromSlash(dir)))
+		if err != nil || len(entries) != len(wanted) {
+			return fmt.Errorf("test dependency directory membership changed")
+		}
+		for i, entry := range entries {
+			if entry.Name() != wanted[i].Name || entry.IsDir() != (wanted[i].Kind == "directory") ||
+				!entry.IsDir() && !entry.Type().IsRegular() {
+				return fmt.Errorf("test dependency has a changed or non-regular directory member")
+			}
+		}
+	}
+	for file, wanted := range source.Sources {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		name, err := CPPRegularSource(root, file)
+		if err != nil {
+			return err
+		}
+		data, err := readTestDependencySource(name)
+		if err != nil || bytesSHA256(data) != wanted {
+			return fmt.Errorf("test dependency original source bytes changed: %s", file)
+		}
+		if expected, found := source.Headers[file]; found {
+			header, err := TestSelectionHeader(file, data)
+			if err != nil || header != expected {
+				return fmt.Errorf("test dependency recorded header differs from actual source bytes: %s", file)
+			}
+		}
+	}
+	return nil
+}
+
+func readTestDependencySource(name string) ([]byte, error) {
+	file, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+	info, err := file.Stat()
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+		return nil, fmt.Errorf("test dependency source exceeds its regular-file byte bound")
+	}
+	data, err := io.ReadAll(io.LimitReader(file, 64<<20+1))
+	if err != nil || len(data) > 64<<20 {
+		return nil, fmt.Errorf("test dependency source changed beyond its byte bound")
+	}
+	return data, nil
+}
+
+func verifyTestModuleZIP(ctx context.Context, source TestModuleSource, archive string) error {
+	before, err := FileSHA256(archive)
+	if err != nil || before != source.ZipSHA256 {
+		return fmt.Errorf("test dependency ZIP bytes changed")
+	}
+	sum, err := dirhash.HashZip(archive, dirhash.Hash1)
+	if err != nil || sum != source.ModuleSum {
+		return fmt.Errorf("test dependency ZIP h1 differs from actual Go download")
+	}
+	reader, err := zip.OpenReader(archive)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+	prefix := source.ID() + "/"
+	files := make(map[string]*zip.File)
+	dirs := map[string]map[string]string{".": {}}
+	optionalDirs := make(map[string]bool)
+	for _, member := range reader.File {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		if !strings.HasPrefix(member.Name, prefix) {
+			return fmt.Errorf("test dependency ZIP has a different exact module identity")
+		}
+		name := strings.TrimSuffix(strings.TrimPrefix(member.Name, prefix), "/")
+		if name == "" {
+			continue
+		}
+		if !testSourceLocalPath(name) {
+			return fmt.Errorf("test dependency ZIP has an unsafe member")
+		}
+		if member.FileInfo().IsDir() {
+			if optionalDirs[name] {
+				return fmt.Errorf("test dependency ZIP repeats a directory marker")
+			}
+			optionalDirs[name] = true
+			continue
+		}
+		if files[name] != nil || !member.Mode().IsRegular() {
+			return fmt.Errorf("test dependency ZIP repeats or redirects a source member")
+		}
+		files[name] = member
+		kind := "file"
+		for current := name; current != "."; current = path.Dir(current) {
+			dir := path.Dir(current)
+			if dirs[dir] == nil {
+				dirs[dir] = make(map[string]string)
+			}
+			if prior := dirs[dir][path.Base(current)]; prior != "" && prior != kind {
+				return fmt.Errorf("test dependency ZIP has a directory/file conflict")
+			}
+			dirs[dir][path.Base(current)] = kind
+			kind = "directory"
+		}
+	}
+	for name := range optionalDirs {
+		if files[name] != nil {
+			return fmt.Errorf("test dependency ZIP member has conflicting source roles")
+		}
+	}
+	if source.GoModOrigin == ProxyGoModProtocol && (files["go.mod"] != nil || optionalDirs["go.mod"]) {
+		return fmt.Errorf("authenticated proxy metadata conflicts with an original ZIP go.mod member")
+	}
+	for dir, entries := range source.Directories {
+		seen := make(map[string]bool)
+		for _, entry := range entries {
+			name := path.Join(dir, entry.Name)
+			if dirs[dir][entry.Name] != entry.Kind && !(entry.Kind == "directory" && optionalDirs[name]) {
+				return fmt.Errorf("test dependency directory is not complete original ZIP membership")
+			}
+			seen[entry.Name] = true
+		}
+		for name := range dirs[dir] {
+			if !seen[name] {
+				return fmt.Errorf("test dependency omitted an original ZIP directory member")
+			}
+		}
+	}
+	for file, expected := range source.Sources {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		member := files[file]
+		if member == nil || member.UncompressedSize64 > 64<<20 {
+			return fmt.Errorf("test dependency source is absent or too large in original ZIP")
+		}
+		stream, err := member.Open()
+		if err != nil {
+			return err
+		}
+		data, readErr := io.ReadAll(io.LimitReader(stream, 64<<20+1))
+		closeErr := stream.Close()
+		if readErr != nil || closeErr != nil || bytesSHA256(data) != expected {
+			return fmt.Errorf("test dependency selected source differs from original ZIP bytes")
+		}
+		if file == "go.mod" {
+			modSum, err := dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+				return io.NopCloser(bytes.NewReader(data)), nil
+			})
+			if err != nil || modSum != source.GoModSum {
+				return fmt.Errorf("test dependency original go.mod differs from authenticated proxy metadata")
+			}
+		}
+		if header, found := source.Headers[file]; found {
+			actual, err := TestSelectionHeader(file, data)
+			if err != nil || actual != header {
+				return fmt.Errorf("test dependency recorded header is not original ZIP content")
+			}
+		}
+	}
+	after, err := FileSHA256(archive)
+	if err != nil || after != before {
+		return fmt.Errorf("test dependency original ZIP changed during verification")
+	}
+	return nil
+}
+
+func SortTestModuleSources(sources []TestModuleSource) {
+	sort.Slice(sources, func(i, j int) bool { return sources[i].ID() < sources[j].ID() })
+}
diff --git a/gotoolprofile/test_dependency_module_sources_test.go b/gotoolprofile/test_dependency_module_sources_test.go
new file mode 100644
index 000000000..91dc3bf75
--- /dev/null
+++ b/gotoolprofile/test_dependency_module_sources_test.go
@@ -0,0 +1,285 @@
+package gotoolprofile
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+func testDependencyModuleFixture(t *testing.T) (TestModuleSource, string, string) {
+	t.Helper()
+	root, archive := t.TempDir(), filepath.Join(t.TempDir(), "module.zip")
+	var err error
+	root, err = filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod":                  "module example.invalid/boundary/loader\n\ngo 1.20\n",
+		"loader.go":               "// original license\n//go:build !race\n\npackage loader\nimport \"example.invalid/boundary/loader/internal/layout\"\ntype Float = layout.Float\n",
+		"internal/layout/type.go": "package layout\ntype Float = float32\n",
+		"internal/layout/table.h": "#define VALUE 7\n",
+	}
+	source := TestModuleSource{
+		Protocol: TestDependencyModuleProtocol, SourceModule: "example.invalid/boundary/loader", SourceVersion: "v1.0.0",
+		GoModOrigin: TestModuleOriginalGoModOrigin,
+		Sources:     make(map[string]string), Headers: make(map[string]string), Directories: make(map[string][]TestSourceEntry),
+	}
+	var buffer bytes.Buffer
+	writer := zip.NewWriter(&buffer)
+	for file, data := range files {
+		name := filepath.Join(root, filepath.FromSlash(file))
+		if err := os.MkdirAll(filepath.Dir(name), 0755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+		member, err := writer.Create(source.ID() + "/" + file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := io.WriteString(member, data); err != nil {
+			t.Fatal(err)
+		}
+		source.Sources[file] = bytesSHA256([]byte(data))
+		if path.Ext(file) == ".go" {
+			header, err := TestSelectionHeader(file, []byte(data))
+			if err != nil {
+				t.Fatal(err)
+			}
+			source.Headers[file] = header
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(archive, buffer.Bytes(), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, dir := range []string{".", "internal", "internal/layout"} {
+		entries, err := os.ReadDir(filepath.Join(root, filepath.FromSlash(dir)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, entry := range entries {
+			proof := TestSourceEntry{Name: entry.Name(), Kind: "directory"}
+			if !entry.IsDir() {
+				proof.Kind, proof.SHA256 = "file", source.Sources[path.Join(dir, entry.Name())]
+			}
+			source.Directories[dir] = append(source.Directories[dir], proof)
+		}
+	}
+	source.ZipSHA256 = bytesSHA256(buffer.Bytes())
+	source.ModuleSum, err = dirhash.HashZip(archive, dirhash.Hash1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source.GoModSHA256 = source.Sources["go.mod"]
+	source.GoModSum, err = dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader(files["go.mod"])), nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source, root, archive
+}
+
+func cloneTestModuleSource(t *testing.T, source TestModuleSource) TestModuleSource {
+	t.Helper()
+	data, err := json.Marshal(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result TestModuleSource
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	return result
+}
+
+func TestTestDependencyModuleSourceActualZIPAndSnapshot(t *testing.T) {
+	source, root, archive := testDependencyModuleFixture(t)
+	if err := VerifyTestModuleSource(context.Background(), cloneTestModuleSource(t, source), root, archive); err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*TestModuleSource){
+		"old protocol":           func(p *TestModuleSource) { p.Protocol = "" },
+		"different module":       func(p *TestModuleSource) { p.SourceModule += "/other" },
+		"different version":      func(p *TestModuleSource) { p.SourceVersion = "v1.0.1" },
+		"changed h1":             func(p *TestModuleSource) { p.ModuleSum = "h1:" + strings.Repeat("A", 43) + "=" },
+		"changed proxy mod h1":   func(p *TestModuleSource) { p.GoModSum = "h1:" + strings.Repeat("B", 43) + "=" },
+		"changed ZIP":            func(p *TestModuleSource) { p.ZipSHA256 = strings.Repeat("0", 64) },
+		"missing root directory": func(p *TestModuleSource) { delete(p.Directories, ".") },
+		"ZIP without original go.mod cannot invent proxy role": func(p *TestModuleSource) {
+			delete(p.Sources, "go.mod")
+			for i, entry := range p.Directories["."] {
+				if entry.Name == "go.mod" {
+					p.Directories["."] = append(p.Directories["."][:i], p.Directories["."][i+1:]...)
+					break
+				}
+			}
+			p.GoModSHA256 = ""
+		},
+		"missing ancestor":         func(p *TestModuleSource) { delete(p.Directories, "internal") },
+		"missing selection header": func(p *TestModuleSource) { delete(p.Headers, "loader.go") },
+		"arbitrary header unchanged full SHA and h1": func(p *TestModuleSource) {
+			p.Headers["loader.go"] = "package loader\nimport \"unsafe\"\n"
+		},
+		"truncated directory": func(p *TestModuleSource) {
+			p.Directories["internal/layout"] = p.Directories["internal/layout"][1:]
+		},
+		"extra unrelated file":   func(p *TestModuleSource) { p.Sources["missing.go"] = strings.Repeat("0", 64) },
+		"redirected source name": func(p *TestModuleSource) { p.Headers["../loader.go"] = "package loader\n" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneTestModuleSource(t, source)
+			mutate(&changed)
+			if err := VerifyTestModuleSource(context.Background(), changed, root, archive); err == nil {
+				t.Fatal("accepted mutated source identity, selection input or ZIP membership")
+			}
+		})
+	}
+	for _, mutation := range []string{"header.h", "new.go", "source.go", "symlink.go"} {
+		t.Run("actual file "+mutation, func(t *testing.T) {
+			proof, directory, zipFile := testDependencyModuleFixture(t)
+			name := "internal/layout/table.h"
+			if mutation == "new.go" || mutation == "symlink.go" {
+				name = "internal/layout/" + mutation
+			} else if mutation == "source.go" {
+				name = "loader.go"
+			}
+			filename := filepath.Join(directory, filepath.FromSlash(name))
+			if mutation == "symlink.go" {
+				if err := os.Symlink(filepath.Join(directory, "loader.go"), filename); err != nil {
+					t.Fatal(err)
+				}
+			} else if err := os.WriteFile(filename, []byte("package changed\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if err := VerifyTestModuleSource(context.Background(), proof, directory, zipFile); err == nil {
+				t.Fatal("accepted changed real source directory/header/non-Go member")
+			}
+		})
+	}
+}
+
+func TestTestDependencyModuleSourceSelfConsistentNonZIPBytes(t *testing.T) {
+	source, root, archive := testDependencyModuleFixture(t)
+	data := []byte("package loader\ntype Float = float64\n")
+	if err := os.WriteFile(filepath.Join(root, "loader.go"), data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	source.Sources["loader.go"] = bytesSHA256(data)
+	source.Headers["loader.go"], _ = TestSelectionHeader("loader.go", data)
+	for i := range source.Directories["."] {
+		if source.Directories["."][i].Name == "loader.go" {
+			source.Directories["."][i].SHA256 = source.Sources["loader.go"]
+		}
+	}
+	if err := ValidateTestModuleSource(source); err != nil {
+		t.Fatal("compact shape validation is not independent ZIP authentication:", err)
+	}
+	if err := VerifyTestModuleSource(context.Background(), source, root, archive); err == nil {
+		t.Fatal("self-consistent mutated file/header cannot replace actual original ZIP bytes")
+	}
+}
+
+func TestTestDependencyModuleSourceDuplicateZIPMembers(t *testing.T) {
+	for _, duplicate := range []string{"loader.go", "internal/"} {
+		t.Run(duplicate, func(t *testing.T) {
+			source, root, archive := testDependencyModuleFixture(t)
+			original, err := zip.OpenReader(archive)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var buffer bytes.Buffer
+			writer := zip.NewWriter(&buffer)
+			for _, file := range original.File {
+				member, err := writer.Create(file.Name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				stream, err := file.Open()
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, readErr := io.Copy(member, stream)
+				closeErr := stream.Close()
+				if readErr != nil || closeErr != nil {
+					t.Fatal("read original member:", readErr, closeErr)
+				}
+			}
+			if err := original.Close(); err != nil {
+				t.Fatal(err)
+			}
+			count := 1
+			if strings.HasSuffix(duplicate, "/") {
+				count = 2
+			}
+			for i := 0; i < count; i++ {
+				member, err := writer.Create(source.ID() + "/" + duplicate)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.HasSuffix(duplicate, "/") {
+					io.WriteString(member, "package loader\n")
+				}
+			}
+			if err := writer.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(archive, buffer.Bytes(), 0600); err != nil {
+				t.Fatal(err)
+			}
+			source.ZipSHA256 = bytesSHA256(buffer.Bytes())
+			source.ModuleSum, err = dirhash.HashZip(archive, dirhash.Hash1)
+			if err != nil {
+				t.Fatalf("construct duplicate-entry h1 for independent membership check: %v", err)
+			}
+			if err := VerifyTestModuleSource(context.Background(), source, root, archive); err == nil {
+				t.Fatal("accepted duplicate original ZIP source/directory marker")
+			}
+		})
+	}
+}
+
+func TestTestDependencyModuleSourceStdlibAndCanonicalOrdering(t *testing.T) {
+	source, root, _ := testDependencyModuleFixture(t)
+	source.SourceModule, source.SourceVersion, source.ModuleSum, source.ZipSHA256 = "", "", "", ""
+	source.GoModSum, source.GoModSHA256, source.GoVersion = "", "", "go1.27.1"
+	source.GoModOrigin = ""
+	if err := VerifyTestModuleSource(context.Background(), source, root, ""); err != nil {
+		t.Fatal(err)
+	}
+	if err := VerifyTestModuleSource(context.Background(), source, root, filepath.Join(root, "zip")); err == nil {
+		t.Fatal("stdlib cannot impersonate a downloaded external module")
+	}
+	sources := []TestModuleSource{source, {SourceModule: "example.invalid/aaa", SourceVersion: "v1.0.0"}}
+	SortTestModuleSources(sources)
+	if !sort.SliceIsSorted(sources, func(i, j int) bool { return sources[i].ID() < sources[j].ID() }) {
+		t.Fatal("source-root inventory lacks stable public ordering")
+	}
+}
+
+func TestTestDependencyModuleSourceCancelledAndMissingContext(t *testing.T) {
+	source, root, archive := testDependencyModuleFixture(t)
+	if err := VerifyTestModuleSource(nil, source, root, archive); err == nil {
+		t.Fatal("unbounded caller cannot authorize a source-root proof")
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if err := VerifyTestModuleSource(ctx, source, root, archive); err == nil {
+		t.Fatal("cancelled source proof became successful evidence")
+	}
+}
diff --git a/gotoolprofile/testdata/aez_proxy_go_mod.json b/gotoolprofile/testdata/aez_proxy_go_mod.json
new file mode 100644
index 000000000..96246bc86
--- /dev/null
+++ b/gotoolprofile/testdata/aez_proxy_go_mod.json
@@ -0,0 +1,40 @@
+{
+  "protocol": "sumdb_authenticated_legacy_proxy_go_mod_v1",
+  "module": "git.schwanenlied.me/yawning/aez.git",
+  "version": "v0.0.0-20180408160647-ec7426b44926",
+  "module_sum": "h1:z1JlywFx2QW25Z4P9fzORXaxf35ph/ZrhZINmfnDt10=",
+  "go_mod_sum": "h1:sXNmB4ljkeRBT0xvmbMGP7ldvC2C2CIUXBlqIO8XGc4=",
+  "contents": "module git.schwanenlied.me/yawning/aez.git\n",
+  "sha256": "51217a813b6bb8184f011045b7db489e39a15b45a0d2482b809282ad53fabdad",
+  "record_id": 70950,
+  "record": "git.schwanenlied.me/yawning/aez.git v0.0.0-20180408160647-ec7426b44926 h1:z1JlywFx2QW25Z4P9fzORXaxf35ph/ZrhZINmfnDt10=\ngit.schwanenlied.me/yawning/aez.git v0.0.0-20180408160647-ec7426b44926/go.mod h1:sXNmB4ljkeRBT0xvmbMGP7ldvC2C2CIUXBlqIO8XGc4=\n",
+  "signed_tree": "go.sum database tree\n63096671\ngSCZee8YEbv+WIaFZnbiZaC3PdKBDwMxohoHrewaZew=\n\n— sum.golang.org Az3grq/Cq/PfaFvUywfko/B6pQRQtwdhvCx9NpnD61yrF4nkzmvctgbpv90SRyGUMLcwtQwM+Bex611ZWu/fYEoIAAw=\n",
+  "record_inclusion": [
+    "NqQvTbtU48iFmhH0chDss3oRmvIfioL4b7IjyqBJ4ts=",
+    "5LHpHtzxI/CNGhD1NE354hFjVSTJaf9qRXiJxG2lrKo=",
+    "d7PL7iCMq17b2ymccQP+I5T0rZhbEahm8IQDE0p1xt4=",
+    "GyWsj49R3Sud0h4gerTyWAzAsd154njFB8XhlXe3tJk=",
+    "00aD1cTVTjf1gEyjuGYnXCURL9sA81zKyatpQVC76RQ=",
+    "04rgstjlie+HkSlYSmHM1A3LlMEqCmTZLNuQ/IZBlfs=",
+    "tqaJFxY5BbBwUTIdWmoKsiKA1VdCiFb+xbQRsp5Y9IQ=",
+    "2tVr84nwuBf7lgjt8wM0d2TJwftcOiED7e0kQVhNLWk=",
+    "ISv2dpAq90UoP3h++AhlKKvj9IhgyT0U6gri74aKZ04=",
+    "VPZWWPZoRL++K0XvrNdFI/iJ+ikku0JZAR9CKzoXnmk=",
+    "Ee1/SJveBCSu0WYWQNlLfJmarrpuidcjNUxP9q11NKs=",
+    "I6kpDvKhS5JWIDLEqcRFB00N3yNKx/ULEdvumFlYJYQ=",
+    "iUXg1dXx7mdtu0EgLrm0TmrbP5vAMCOwYE2nyGRaDa0=",
+    "OyRB8SiTy+S7E+o8V3P3W/rJMHyuvUGTfV2V8X1p7Lw=",
+    "2HQYgRwbSfs3xI40BpHHo7IWKRNvEelA5yqZ59Cj070=",
+    "USqwapc1YkB9LXDIlI9xUp/0dXkiKEOPPrxilYQ38t8=",
+    "HotSvLRfJ8CQECSq838MOtDpwAuCWXZ0aProVSoNSCE=",
+    "IonpIBObv6T1EJXacXeYy+phaffn9e7YJhTra5QW1sI=",
+    "f51zjGdB83VgjwqVThjahixewYj/FtSlaKKOwHX4fbA=",
+    "C8UgSeNVMFzXAPsBw5/2jjMWvckga1juj39PWST329c=",
+    "ADqFVRikXees79r66LHyA9CCRHTZCBdrk3YhPfplVFU=",
+    "YcHWLz4Fd8trksfogI2hm3t0eB+Ekq8f11XVh2CLto0=",
+    "zrJXqsI3DARgs5JiqthQv1qEaNQe8tYaBX2cyO7pLnY=",
+    "cHganxie1TBd5PbsRNDf73eO+dSJm9OK1mFe9V8CdUE=",
+    "zesWuZw10TEJInNKrllG2PEgH8cKacLp6LY5WpXGOcY=",
+    "KP/zuCVdOVVXFXyrQ6X/USAHIZ+knr/eNOX1FoeD0zI="
+  ]
+}
diff --git a/gotoolprofile/testdata/aez_proxy_go_mod_later_tree.json b/gotoolprofile/testdata/aez_proxy_go_mod_later_tree.json
new file mode 100644
index 000000000..f4f21aca1
--- /dev/null
+++ b/gotoolprofile/testdata/aez_proxy_go_mod_later_tree.json
@@ -0,0 +1,40 @@
+{
+  "protocol": "sumdb_authenticated_legacy_proxy_go_mod_v1",
+  "module": "git.schwanenlied.me/yawning/aez.git",
+  "version": "v0.0.0-20180408160647-ec7426b44926",
+  "module_sum": "h1:z1JlywFx2QW25Z4P9fzORXaxf35ph/ZrhZINmfnDt10=",
+  "go_mod_sum": "h1:sXNmB4ljkeRBT0xvmbMGP7ldvC2C2CIUXBlqIO8XGc4=",
+  "contents": "module git.schwanenlied.me/yawning/aez.git\n",
+  "sha256": "51217a813b6bb8184f011045b7db489e39a15b45a0d2482b809282ad53fabdad",
+  "record_id": 70950,
+  "record": "git.schwanenlied.me/yawning/aez.git v0.0.0-20180408160647-ec7426b44926 h1:z1JlywFx2QW25Z4P9fzORXaxf35ph/ZrhZINmfnDt10=\ngit.schwanenlied.me/yawning/aez.git v0.0.0-20180408160647-ec7426b44926/go.mod h1:sXNmB4ljkeRBT0xvmbMGP7ldvC2C2CIUXBlqIO8XGc4=\n",
+  "signed_tree": "go.sum database tree\n66217069\nF7nZ9khptYi9+VnKBOvYXH36kOeaYgpkfdb9Ja5gS1g=\n\n— sum.golang.org Az3grl1ZWs6jFHEgM82zWY5FoSLaAlhkC+4QS4/nUY6f9uB3O5H37y+ZvZPA3hb0pWQOWNWYlnNt/4kh7KKuYG9u7QM=\n",
+  "record_inclusion": [
+    "NqQvTbtU48iFmhH0chDss3oRmvIfioL4b7IjyqBJ4ts=",
+    "5LHpHtzxI/CNGhD1NE354hFjVSTJaf9qRXiJxG2lrKo=",
+    "d7PL7iCMq17b2ymccQP+I5T0rZhbEahm8IQDE0p1xt4=",
+    "GyWsj49R3Sud0h4gerTyWAzAsd154njFB8XhlXe3tJk=",
+    "00aD1cTVTjf1gEyjuGYnXCURL9sA81zKyatpQVC76RQ=",
+    "04rgstjlie+HkSlYSmHM1A3LlMEqCmTZLNuQ/IZBlfs=",
+    "tqaJFxY5BbBwUTIdWmoKsiKA1VdCiFb+xbQRsp5Y9IQ=",
+    "2tVr84nwuBf7lgjt8wM0d2TJwftcOiED7e0kQVhNLWk=",
+    "ISv2dpAq90UoP3h++AhlKKvj9IhgyT0U6gri74aKZ04=",
+    "VPZWWPZoRL++K0XvrNdFI/iJ+ikku0JZAR9CKzoXnmk=",
+    "Ee1/SJveBCSu0WYWQNlLfJmarrpuidcjNUxP9q11NKs=",
+    "I6kpDvKhS5JWIDLEqcRFB00N3yNKx/ULEdvumFlYJYQ=",
+    "iUXg1dXx7mdtu0EgLrm0TmrbP5vAMCOwYE2nyGRaDa0=",
+    "OyRB8SiTy+S7E+o8V3P3W/rJMHyuvUGTfV2V8X1p7Lw=",
+    "2HQYgRwbSfs3xI40BpHHo7IWKRNvEelA5yqZ59Cj070=",
+    "USqwapc1YkB9LXDIlI9xUp/0dXkiKEOPPrxilYQ38t8=",
+    "HotSvLRfJ8CQECSq838MOtDpwAuCWXZ0aProVSoNSCE=",
+    "IonpIBObv6T1EJXacXeYy+phaffn9e7YJhTra5QW1sI=",
+    "f51zjGdB83VgjwqVThjahixewYj/FtSlaKKOwHX4fbA=",
+    "C8UgSeNVMFzXAPsBw5/2jjMWvckga1juj39PWST329c=",
+    "ADqFVRikXees79r66LHyA9CCRHTZCBdrk3YhPfplVFU=",
+    "YcHWLz4Fd8trksfogI2hm3t0eB+Ekq8f11XVh2CLto0=",
+    "zrJXqsI3DARgs5JiqthQv1qEaNQe8tYaBX2cyO7pLnY=",
+    "cHganxie1TBd5PbsRNDf73eO+dSJm9OK1mFe9V8CdUE=",
+    "zesWuZw10TEJInNKrllG2PEgH8cKacLp6LY5WpXGOcY=",
+    "fI+NJuwSa32zkcFFj3ZA0ThU74dtjI1PVw22m8fn/n4="
+  ]
+}
diff --git a/gotoolprofile/testdata/instrumentation-export-environment-LICENSE b/gotoolprofile/testdata/instrumentation-export-environment-LICENSE
new file mode 100644
index 000000000..9834d256e
--- /dev/null
+++ b/gotoolprofile/testdata/instrumentation-export-environment-LICENSE
@@ -0,0 +1,31 @@
+The Go 1.27.1 source projections in
+instrumentation-export-environment-go1.27.1.json are derived from the Go
+project. The original license follows.
+
+Copyright 2009 The Go Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google LLC nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/gotoolprofile/testdata/instrumentation-export-environment-go1.27.1.json b/gotoolprofile/testdata/instrumentation-export-environment-go1.27.1.json
new file mode 100644
index 000000000..96070e57e
--- /dev/null
+++ b/gotoolprofile/testdata/instrumentation-export-environment-go1.27.1.json
@@ -0,0 +1,48 @@
+{
+  "protocol": "actual_go_marker_changed_environment_v1",
+  "go_version": "go1.27.1",
+  "source_sha256": {
+    "src/cmd/go/internal/work/buildid.go": "6de8324513d2a5f9f629e8ae7ede623d1e87ef7b826fd1441265fc845a256555",
+    "src/cmd/go/internal/work/init.go": "cd86d5c8fecb90d9db58ed3c98d0869ff6b5220c445025051d366818859a0963",
+    "src/cmd/go/internal/cfg/cfg.go": "8eb038ac6df168fe5af971cd768d99dd3c64224273072a4160dcc5f51eacae9d",
+    "src/cmd/go/internal/work/shell.go": "ffc69d476c2cde44a64c26693b2c9aeb42830ac2777f9f538ef268c86d57be2f",
+    "src/cmd/go/internal/work/gc.go": "13359b8707e78300e8e0ec880b9a8d1af4bafdf32140b56df5f041a52fbc1325",
+    "src/internal/buildcfg/zbootstrap.go": "1773928ca43d16ff0d012a5e23cf5168e3f7e7396aba681634e8eb3422772d64",
+    "go.env": "98fcab78e155e9fa0c36b18874add30724d04c2452078117c78618107ebfbc9e"
+  },
+  "source_declarations": {
+    "src/cmd/go/internal/work/buildid.go#updateBuildID": "func (b *Builder) updateBuildID(a *Action, target string) error {\n\tsh := b.Shell(a)\n\n\tif cfg.BuildX || cfg.BuildN {\n\t\tsh.ShowCmd(\"\", \"%s # internal\", joinUnambiguously(str.StringList(\"go\", \"tool\", \"buildid\", \"-w\", target)))\n\t\tif cfg.BuildN {\n\t\t\treturn nil\n\t\t}\n\t}\n\n\tc := cache.Default()\n\n\tswitch a.Mode {\n\tcase \"build\":\n\t\tcache.PutBytes(c, cache.Subkey(a.actionID, \"stdout\"), a.output)\n\tcase \"link\":\n\n\t\tfor _, a1 := range a.Deps {\n\t\t\tif p1 := a1.Package; p1 != nil && p1.Name == \"main\" {\n\t\t\t\tcache.PutBytes(c, cache.Subkey(a1.actionID, \"link-stdout\"), a.output)\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\n\tr, err := os.Open(target)\n\tif err != nil {\n\t\treturn err\n\t}\n\tmatches, hash, err := buildid.FindAndHash(r, a.buildID, 0)\n\tr.Close()\n\tif err != nil {\n\t\treturn err\n\t}\n\tnewID := a.buildID[:strings.LastIndex(a.buildID, buildIDSeparator)] + buildIDSeparator + buildid.HashToString(hash)\n\tif len(newID) != len(a.buildID) {\n\t\treturn fmt.Errorf(\"internal error: build ID length mismatch %q vs %q\", a.buildID, newID)\n\t}\n\n\ta.buildID = newID\n\tif a.json != nil {\n\t\ta.json.BuildID = a.buildID\n\t}\n\tif len(matches) == 0 {\n\n\t\treturn nil\n\t}\n\n\tw, err := os.OpenFile(target, os.O_RDWR, 0)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = buildid.Rewrite(w, matches, newID)\n\tif err != nil {\n\t\tw.Close()\n\t\treturn err\n\t}\n\tif err := w.Close(); err != nil {\n\t\treturn err\n\t}\n\n\tif a.Mode == \"build\" {\n\t\tr, err := os.Open(target)\n\t\tif err == nil {\n\t\t\tif a.output == nil {\n\t\t\t\tpanic(\"internal error: a.output not set\")\n\t\t\t}\n\t\t\toutputID, _, err := c.Put(a.actionID, r)\n\t\t\tr.Close()\n\t\t\tif err == nil && cfg.BuildX {\n\t\t\t\tsh.ShowCmd(\"\", \"%s # internal\", joinUnambiguously(str.StringList(\"cp\", target, c.OutputFile(outputID))))\n\t\t\t}\n\t\t\tif b.NeedExport {\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\ta.Package.Export = c.OutputFile(outputID)\n\t\t\t\ta.Package.BuildID = a.buildID\n\t\t\t}\n\t\t}\n\t}\n\tif c, ok := c.(*cache.DiskCache); a.Mode == \"link\" && a.CacheExecutable && ok {\n\t\tr, err := os.Open(target)\n\t\tif err == nil {\n\t\t\tif a.output == nil {\n\t\t\t\tpanic(\"internal error: a.output not set\")\n\t\t\t}\n\t\t\tname := a.Package.Internal.ExeName\n\t\t\tif name == \"\" {\n\t\t\t\tname = a.Package.DefaultExecName()\n\t\t\t}\n\t\t\toutputID, _, err := c.PutExecutable(a.actionID, name+cfg.ExeSuffix, r)\n\t\t\tr.Close()\n\t\t\ta.cachedExecutable = c.OutputFile(outputID)\n\t\t\tif err == nil && cfg.BuildX {\n\t\t\t\tsh.ShowCmd(\"\", \"%s # internal\", joinUnambiguously(str.StringList(\"cp\", target, a.cachedExecutable)))\n\t\t\t}\n\t\t}\n\t}\n\n\treturn nil\n}",
+    "src/cmd/go/internal/cfg/cfg.go#EnvOrAndChanged": "func EnvOrAndChanged(name, def string) (v string, changed bool) {\n\tval := Getenv(name)\n\tif val != \"\" {\n\t\tv = val\n\t\tif g, ok := envCache.goroot[name]; ok {\n\t\t\tchanged = val != g\n\t\t} else {\n\t\t\tchanged = val != def\n\t\t}\n\t\treturn v, changed\n\t}\n\treturn def, false\n}",
+    "src/cmd/go/internal/cfg/cfg.go#GOAMD64": "var GOAMD64, goAMD64Changed     = EnvOrAndChanged(\"GOAMD64\", buildcfg.DefaultGOAMD64)",
+    "src/cmd/go/internal/cfg/cfg.go#GOARM64": "var GOARM64, goARM64Changed     = EnvOrAndChanged(\"GOARM64\", buildcfg.DefaultGOARM64)",
+    "src/cmd/go/internal/cfg/cfg.go#GetArchEnv": "func GetArchEnv() (key, val string, changed bool) {\n\tswitch Goarch {\n\tcase \"arm\":\n\t\treturn \"GOARM\", GOARM, goARMChanged\n\tcase \"arm64\":\n\t\treturn \"GOARM64\", GOARM64, goARM64Changed\n\tcase \"386\":\n\t\treturn \"GO386\", GO386, go386Changed\n\tcase \"amd64\":\n\t\treturn \"GOAMD64\", GOAMD64, goAMD64Changed\n\tcase \"mips\", \"mipsle\":\n\t\treturn \"GOMIPS\", GOMIPS, goMIPSChanged\n\tcase \"mips64\", \"mips64le\":\n\t\treturn \"GOMIPS64\", GOMIPS64, goMIPS64Changed\n\tcase \"ppc64\", \"ppc64le\":\n\t\treturn \"GOPPC64\", GOPPC64, goPPC64Changed\n\tcase \"riscv64\":\n\t\treturn \"GORISCV64\", GORISCV64, goRISCV64Changed\n\tcase \"wasm\":\n\t\treturn \"GOWASM\", GOWASM, goWASMChanged\n\t}\n\treturn \"\", \"\", false\n}",
+    "src/cmd/go/internal/cfg/cfg.go#initEnvCache": "func initEnvCache() {\n\tenvCache.m = make(map[string]string)\n\tenvCache.goroot = make(map[string]string)\n\tif file, _, _ := EnvFile(); file != \"\" {\n\t\treadEnvFile(file, \"user\")\n\t}\n\tgoroot := findGOROOT(envCache.m[\"GOROOT\"])\n\tif goroot != \"\" {\n\t\treadEnvFile(filepath.Join(goroot, \"go.env\"), \"GOROOT\")\n\t}\n\n\t// Save the goroot for func init calling SetGOROOT,\n\t// and also overwrite anything that might have been in go.env.\n\t// It makes no sense for GOROOT/go.env to specify\n\t// a different GOROOT.\n\tenvCache.m[\"GOROOT\"] = goroot\n}",
+    "src/cmd/go/internal/cfg/cfg.go#readEnvFile": "func readEnvFile(file string, source string) {\n\tif file == \"\" {\n\t\treturn\n\t}\n\tdata, err := os.ReadFile(file)\n\tif err != nil {\n\t\treturn\n\t}\n\n\tfor len(data) > 0 {\n\t\t// Get next line.\n\t\tline := data\n\t\ti := bytes.IndexByte(data, '\\n')\n\t\tif i >= 0 {\n\t\t\tline, data = line[:i], data[i+1:]\n\t\t} else {\n\t\t\tdata = nil\n\t\t}\n\n\t\ti = bytes.IndexByte(line, '=')\n\t\tif i < 0 || line[0] < 'A' || 'Z' < line[0] {\n\t\t\t// Line is missing = (or empty) or a comment or not a valid env name. Ignore.\n\t\t\t// This should not happen in the user file, since the file should be maintained almost\n\t\t\t// exclusively by \"go env -w\", but better to silently ignore than to make\n\t\t\t// the go command unusable just because somehow the env file has\n\t\t\t// gotten corrupted.\n\t\t\t// In the GOROOT/go.env file, we expect comments.\n\t\t\tcontinue\n\t\t}\n\t\tkey, val := line[:i], line[i+1:]\n\n\t\tif source == \"GOROOT\" {\n\t\t\tenvCache.goroot[string(key)] = string(val)\n\t\t\t// In the GOROOT/go.env file, do not overwrite fields loaded from the user's go/env file.\n\t\t\tif _, ok := envCache.m[string(key)]; ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t}\n\t\tenvCache.m[string(key)] = string(val)\n\t}\n}",
+    "src/cmd/go/internal/work/gc.go#asm": "func (gcToolchain) asm(b *Builder, a *Action, sfiles []string) ([]string, error) {\n\tp := a.Package\n\targs := asmArgs(a, p)\n\n\tvar ofiles []string\n\tfor _, sfile := range sfiles {\n\t\tofile := a.Objdir + sfile[:len(sfile)-len(\".s\")] + \".o\"\n\t\tofiles = append(ofiles, ofile)\n\t\targs1 := append(args, \"-o\", ofile, fsys.Actual(mkAbs(p.Dir, sfile)))\n\t\tif err := b.Shell(a).run(p.Dir, p.ImportPath, cfgChangedEnv, args1...); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\treturn ofiles, nil\n}",
+    "src/cmd/go/internal/work/gc.go#gc": "func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, pgoProfile string, gofiles []string) (ofile string, output []byte, err error) {\n\tp := a.Package\n\tsh := b.Shell(a)\n\tobjdir := a.Objdir\n\tif archive != \"\" {\n\t\tofile = archive\n\t} else {\n\t\tout := \"_go_.o\"\n\t\tofile = objdir + out\n\t}\n\n\tpkgpath := pkgPath(a)\n\tdefaultGcFlags := []string{\"-p\", pkgpath}\n\tvers := gover.Local()\n\tif p.Module != nil {\n\t\tv := p.Module.GoVersion\n\t\tif v == \"\" {\n\t\t\tv = gover.DefaultGoModVersion\n\t\t}\n\t\t// TODO(samthanawalla): Investigate when allowedVersion is not true.\n\t\tif allowedVersion(v) {\n\t\t\tvers = v\n\t\t}\n\t}\n\tdefaultGcFlags = append(defaultGcFlags, \"-lang=go\"+gover.Lang(vers))\n\tif p.Standard {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-std\")\n\t}\n\n\t// If we're giving the compiler the entire package (no C etc files), tell it that,\n\t// so that it can give good error messages about forward declarations.\n\t// Exceptions: a few standard packages have forward declarations for\n\t// pieces supplied behind-the-scenes by package runtime.\n\textFiles := len(p.CgoFiles) + len(p.CFiles) + len(p.CXXFiles) + len(p.MFiles) + len(p.FFiles) + len(p.SFiles) + len(p.SysoFiles) + len(p.SwigFiles) + len(p.SwigCXXFiles)\n\tif p.Standard {\n\t\tswitch p.ImportPath {\n\t\tcase \"bytes\", \"internal/poll\", \"net\", \"os\":\n\t\t\tfallthrough\n\t\tcase \"runtime/metrics\", \"runtime/pprof\", \"runtime/trace\":\n\t\t\tfallthrough\n\t\tcase \"sync\", \"syscall\", \"time\":\n\t\t\textFiles++\n\t\t}\n\t}\n\tif extFiles == 0 {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-complete\")\n\t}\n\tif cfg.BuildContext.InstallSuffix != \"\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-installsuffix\", cfg.BuildContext.InstallSuffix)\n\t}\n\tif a.buildID != \"\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-buildid\", a.buildID)\n\t}\n\tif p.Internal.OmitDebug || cfg.Goos == \"plan9\" || cfg.Goarch == \"wasm\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-dwarf=false\")\n\t}\n\tif strings.HasPrefix(ToolchainVersion, \"go1\") && !strings.Contains(os.Args[0], \"go_bootstrap\") {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-goversion\", ToolchainVersion)\n\t}\n\tif p.Internal.Cover.Cfg != \"\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-coveragecfg=\"+p.Internal.Cover.Cfg)\n\t}\n\tif pgoProfile != \"\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-pgoprofile=\"+pgoProfile)\n\t}\n\tif symabis != \"\" {\n\t\tdefaultGcFlags = append(defaultGcFlags, \"-symabis\", symabis)\n\t}\n\n\tgcflags := str.StringList(forcedGcflags, p.Internal.Gcflags)\n\tif p.Internal.FuzzInstrument {\n\t\tgcflags = append(gcflags, fuzzInstrumentFlags()...)\n\t}\n\t// Add -c=N to use concurrent backend compilation, if possible.\n\tc, release := compilerConcurrency()\n\tdefer release()\n\tif c > 1 {\n\t\tdefaultGcFlags = append(defaultGcFlags, fmt.Sprintf(\"-c=%d\", c))\n\t}\n\n\targs := []any{cfg.BuildToolexec, base.Tool(\"compile\"), \"-o\", ofile, \"-trimpath\", a.trimpath(), defaultGcFlags, gcflags}\n\tif p.Internal.LocalPrefix == \"\" {\n\t\targs = append(args, \"-nolocalimports\")\n\t} else {\n\t\targs = append(args, \"-D\", p.Internal.LocalPrefix)\n\t}\n\tif importcfg != nil {\n\t\tif err := sh.writeFile(objdir+\"importcfg\", importcfg); err != nil {\n\t\t\treturn \"\", nil, err\n\t\t}\n\t\targs = append(args, \"-importcfg\", objdir+\"importcfg\")\n\t}\n\tif embedcfg != nil {\n\t\tif err := sh.writeFile(objdir+\"embedcfg\", embedcfg); err != nil {\n\t\t\treturn \"\", nil, err\n\t\t}\n\t\targs = append(args, \"-embedcfg\", objdir+\"embedcfg\")\n\t}\n\tif ofile == archive {\n\t\targs = append(args, \"-pack\")\n\t}\n\tif asmhdr {\n\t\targs = append(args, \"-asmhdr\", objdir+\"go_asm.h\")\n\t}\n\n\tfor _, f := range gofiles {\n\t\tf := mkAbs(p.Dir, f)\n\n\t\t// Handle overlays. Convert path names using fsys.Actual\n\t\t// so these paths can be handed directly to tools.\n\t\t// Deleted files won't show up in when scanning directories earlier,\n\t\t// so Actual will never return \"\" (meaning a deleted file) here.\n\t\t// TODO(#39958): Handle cases where the package directory\n\t\t// doesn't exist on disk (this can happen when all the package's\n\t\t// files are in an overlay): the code expects the package directory\n\t\t// to exist and runs some tools in that directory.\n\t\t// TODO(#39958): Process the overlays when the\n\t\t// gofiles, cgofiles, cfiles, sfiles, and cxxfiles variables are\n\t\t// created in (*Builder).build. Doing that requires rewriting the\n\t\t// code that uses those values to expect absolute paths.\n\t\targs = append(args, fsys.Actual(f))\n\t}\n\toutput, err = sh.runOut(base.Cwd(), cfgChangedEnv, args...)\n\treturn ofile, output, err\n}",
+    "src/cmd/go/internal/work/init.go#makeCfgChangedEnv": "func makeCfgChangedEnv() []string {\n\tvar env []string\n\tif cfg.Getenv(\"GOOS\") != cfg.Goos {\n\t\tenv = append(env, \"GOOS=\"+cfg.Goos)\n\t}\n\tif cfg.Getenv(\"GOARCH\") != cfg.Goarch {\n\t\tenv = append(env, \"GOARCH=\"+cfg.Goarch)\n\t}\n\tif archenv, val, changed := cfg.GetArchEnv(); changed {\n\t\tenv = append(env, archenv+\"=\"+val)\n\t}\n\treturn slices.Clip(env)\n}",
+    "src/cmd/go/internal/work/shell.go#ShowCmd": "func (sh *Shell) ShowCmd(dir string, format string, args ...any) {\n\n\tsh.printLock.Lock()\n\tdefer sh.printLock.Unlock()\n\n\tcmd := sh.fmtCmd(dir, format, args...)\n\n\tif dir != \"\" && dir != \"/\" {\n\t\tif dir != sh.scriptDir {\n\n\t\t\tsh.printfLocked(\"%s\", sh.fmtCmd(\"\", \"cd %s\\n\", dir))\n\t\t\tsh.scriptDir = dir\n\t\t}\n\n\t\tdot := \" .\"\n\t\tif dir[len(dir)-1] == filepath.Separator {\n\t\t\tdot += string(filepath.Separator)\n\t\t}\n\t\tcmd = strings.ReplaceAll(\" \"+cmd, \" \"+dir, dot)[1:]\n\t}\n\n\tsh.printfLocked(\"%s\\n\", cmd)\n}",
+    "src/cmd/go/internal/work/shell.go#fmtCmd": "func (sh *Shell) fmtCmd(dir string, format string, args ...any) string {\n\tcmd := fmt.Sprintf(format, args...)\n\tif sh.workDir != \"\" && !strings.HasPrefix(cmd, \"cat \") {\n\t\tcmd = strings.ReplaceAll(cmd, sh.workDir, \"$WORK\")\n\t\tescaped := strconv.Quote(sh.workDir)\n\t\tescaped = escaped[1 : len(escaped)-1]\n\t\tif escaped != sh.workDir {\n\t\t\tcmd = strings.ReplaceAll(cmd, escaped, \"$WORK\")\n\t\t}\n\t}\n\treturn cmd\n}",
+    "src/cmd/go/internal/work/shell.go#joinUnambiguously": "func joinUnambiguously(a []string) string {\n\tvar buf strings.Builder\n\tfor i, s := range a {\n\t\tif i > 0 {\n\t\t\tbuf.WriteByte(' ')\n\t\t}\n\t\tq := strconv.Quote(s)\n\n\t\tif s == \"\" || strings.ContainsAny(s, \" ()>;\") || len(q) > len(s)+2 {\n\t\t\tbuf.WriteString(q)\n\t\t} else {\n\t\t\tbuf.WriteString(s)\n\t\t}\n\t}\n\treturn buf.String()\n}",
+    "src/cmd/go/internal/work/shell.go#runOut": "func (sh *Shell) runOut(dir string, env []string, cmdargs ...any) ([]byte, error) {\n\ta := sh.action\n\n\tcmdline := str.StringList(cmdargs...)\n\n\tfor _, arg := range cmdline {\n\t\t// GNU binutils commands, including gcc and gccgo, interpret an argument\n\t\t// @foo anywhere in the command line (even following --) as meaning\n\t\t// \"read and insert arguments from the file named foo.\"\n\t\t// Don't say anything that might be misinterpreted that way.\n\t\tif strings.HasPrefix(arg, \"@\") {\n\t\t\treturn nil, fmt.Errorf(\"invalid command-line argument %s in command: %s\", arg, joinUnambiguously(cmdline))\n\t\t}\n\t}\n\n\tif cfg.BuildN || cfg.BuildX {\n\t\tvar envcmdline string\n\t\tfor _, e := range env {\n\t\t\tif j := strings.IndexByte(e, '='); j != -1 {\n\t\t\t\tif strings.ContainsRune(e[j+1:], '\\'') {\n\t\t\t\t\tenvcmdline += fmt.Sprintf(\"%s=%q\", e[:j], e[j+1:])\n\t\t\t\t} else {\n\t\t\t\t\tenvcmdline += fmt.Sprintf(\"%s='%s'\", e[:j], e[j+1:])\n\t\t\t\t}\n\t\t\t\tenvcmdline += \" \"\n\t\t\t}\n\t\t}\n\t\tenvcmdline += joinUnambiguously(cmdline)\n\t\tsh.ShowCmd(dir, \"%s\", envcmdline)\n\t\tif cfg.BuildN {\n\t\t\treturn nil, nil\n\t\t}\n\t}\n\n\tvar buf bytes.Buffer\n\tpath, err := pathcache.LookPath(cmdline[0])\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tcmd := exec.Command(path, cmdline[1:]...)\n\tif cmd.Path != \"\" {\n\t\tcmd.Args[0] = cmd.Path\n\t}\n\tcmd.Stdout = &buf\n\tcmd.Stderr = &buf\n\tcleanup := passLongArgsInResponseFiles(cmd)\n\tdefer cleanup()\n\tif dir != \".\" {\n\t\tcmd.Dir = dir\n\t}\n\tcmd.Env = cmd.Environ() // Pre-allocate with correct PWD.\n\n\t// Add the TOOLEXEC_IMPORTPATH environment variable for -toolexec tools.\n\t// It doesn't really matter if -toolexec isn't being used.\n\t// Note that a.Package.Desc is not really an import path,\n\t// but this is consistent with 'go list -f {{.ImportPath}}'.\n\t// Plus, it is useful to uniquely identify packages in 'go list -json'.\n\tif a != nil && a.Package != nil {\n\t\tcmd.Env = append(cmd.Env, \"TOOLEXEC_IMPORTPATH=\"+a.Package.Desc())\n\t}\n\n\tcmd.Env = append(cmd.Env, env...)\n\tstart := time.Now()\n\terr = cmd.Run()\n\tif a != nil && a.json != nil {\n\t\taj := a.json\n\t\taj.Cmd = append(aj.Cmd, joinUnambiguously(cmdline))\n\t\taj.CmdReal += time.Since(start)\n\t\tif ps := cmd.ProcessState; ps != nil {\n\t\t\taj.CmdUser += ps.UserTime()\n\t\t\taj.CmdSys += ps.SystemTime()\n\t\t}\n\t}\n\n\t// err can be something like 'exit status 1'.\n\t// Add information about what program was running.\n\t// Note that if buf.Bytes() is non-empty, the caller usually\n\t// shows buf.Bytes() and does not print err at all, so the\n\t// prefix here does not make most output any more verbose.\n\tif err != nil {\n\t\terr = errors.New(cmdline[0] + \": \" + err.Error())\n\t}\n\treturn buf.Bytes(), err\n}"
+  },
+  "registration_ast_sha256": {
+    "src/cmd/go/internal/work/buildid.go#updateBuildID": "749e831a261f6638b3dfd4e3d6f77321276dfd530a8b906b7353343db9790858",
+    "src/cmd/go/internal/cfg/cfg.go#EnvOrAndChanged": "496696c1fba2c248d479f6a60125bdd1e349a2fc0f6936aa50c17da5ef4f416a",
+    "src/cmd/go/internal/cfg/cfg.go#GOAMD64": "802d8ea0ab395ea9620f0b9ce1d5e07cc08c5d947238d95d54286d7a04af53ab",
+    "src/cmd/go/internal/cfg/cfg.go#GOARM64": "5699ca3bb24f5c90ba510c5d95233e2e74858490766f7252d22574f48c667a03",
+    "src/cmd/go/internal/cfg/cfg.go#GetArchEnv": "554cc40b196a2240051eb791af577ac2bc392178053cf24467a9a99bcaf60812",
+    "src/cmd/go/internal/cfg/cfg.go#initEnvCache": "14d9ec4cde6592bef7e3b5f7974d11fa47d1fb5a994dce6edf4972b33ba192de",
+    "src/cmd/go/internal/cfg/cfg.go#readEnvFile": "3f62cec3d5f6853a4035a71195610afa3ddfb223f2d35d45e2d6c3ccb485bbb0",
+    "src/cmd/go/internal/work/gc.go#asm": "1c61898cd98e26c4187d29b46b763e6822b0df8b44f2807a7dbe4013cdf67a20",
+    "src/cmd/go/internal/work/gc.go#gc": "471dec7ded9c8b4d6adb0a4e2de4230c15b18fd85cdc3d210b46aae500c68dbb",
+    "src/cmd/go/internal/work/init.go#makeCfgChangedEnv": "fe8772618100851a770d2dcf4c66f7bdd0edf4e8800702356a6072b3322fd82e",
+    "src/cmd/go/internal/work/shell.go#ShowCmd": "a716a83e6144f79faebfb38918bb63c156c0ad99e45f908e27acf7afa47138bd",
+    "src/cmd/go/internal/work/shell.go#fmtCmd": "acfa7656780c7e4133d04f15ab17ffda57b130f7fad7890938c29268989cb117",
+    "src/cmd/go/internal/work/shell.go#joinUnambiguously": "c91dbacb9686e257fda39fd6c12cdef6cc9482376dda3afa2b7f9faec5d1408f",
+    "src/cmd/go/internal/work/shell.go#runOut": "0fd749215e983f2f31d3d0499ee765d43c36392ecffad81d16cea517dfdceb00"
+  },
+  "bootstrap_text": "// Code generated by go tool dist; DO NOT EDIT.\n\npackage buildcfg\n\nimport \"runtime\"\n\nconst DefaultGO386 = `sse2`\nconst DefaultGOAMD64 = `v1`\nconst DefaultGOARM = `7`\nconst DefaultGOARM64 = `v8.0`\nconst DefaultGOMIPS = `hardfloat`\nconst DefaultGOMIPS64 = `hardfloat`\nconst DefaultGOPPC64 = `power8`\nconst DefaultGORISCV64 = `rva20u64`\nconst defaultGOEXPERIMENT = ``\nconst defaultGO_EXTLINK_ENABLED = ``\nconst defaultGO_LDSO = ``\nconst version = `go1.27.1`\nconst defaultGOOS = runtime.GOOS\nconst defaultGOARCH = runtime.GOARCH\nconst DefaultGOFIPS140 = `off`\nconst DefaultCGO_ENABLED = \"\"\n",
+  "go_env_present": true,
+  "go_env_text": "# This file contains the initial defaults for go command configuration.\n# Values set by 'go env -w' and written to the user's go/env file override these.\n# The environment overrides everything else.\n\n# Use the Go module mirror and checksum database by default.\n# See https://proxy.golang.org for details.\nGOPROXY=https://proxy.golang.org,direct\nGOSUMDB=sum.golang.org\n\n# Automatically download newer toolchains as directed by go.mod files.\n# See https://go.dev/doc/toolchain for details.\nGOTOOLCHAIN=auto\n"
+}
diff --git a/immediate_resolution_test.go b/immediate_resolution_test.go
new file mode 100644
index 000000000..fc3cadde1
--- /dev/null
+++ b/immediate_resolution_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestUnresolvedImmediateProbeRequiresContextButTranslationFails(t *testing.T) {
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+		body   string
+	}{
+		{ArchAMD64, "amd64", "ADDQ $const_stackGuard, AX"},
+		{ArchAMD64, "386", "ADDL $const_stackGuard, AX"},
+		{ArchARM64, "arm64", "ADD $(16 + frame__size), R0"},
+		{ArchARM, "arm", "ADD $const_stackGuard, R0"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			file, err := Parse(target.arch, "TEXT context(SB),$0-0\n"+target.body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			instruction := file.Funcs[0].Instrs[1]
+			if err := ProbeInstruction(target.arch, target.goarch, instruction); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unresolved single-instruction probe = %v, want context", err)
+			}
+			if err := ProbeInstructionSequence(target.arch, target.goarch, []Instr{instruction}); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unresolved instruction-sequence probe = %v, want context", err)
+			}
+		})
+	}
+}
+
+func TestTranslationRejectsUnresolvedImmediateInsteadOfInventingZero(t *testing.T) {
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+		triple string
+		move   string
+	}{
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu", "MOVQ %s, AX"},
+		{ArchAMD64, "386", "i386-unknown-linux-gnu", "MOVL %s, AX"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "MOVD %s, R0"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf", "MOVW %s, R0"},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown", "I64Const %s\nDrop"},
+	} {
+		for _, operand := range []string{"$missing_constant", "$(16 + missing_constant)"} {
+			for _, module := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/module=%v", target.goarch, operand, module), func(t *testing.T) {
+					source := "TEXT unresolved(SB),$0-0\n" + fmt.Sprintf(target.move, operand) + "\nRET\n"
+					file, err := Parse(target.arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: target.goarch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"unresolved": {Name: "unresolved", Ret: Void}},
+					}
+					if module {
+						ctx := llvm.NewContext()
+						mod, moduleErr := TranslateModuleInContext(ctx, file, options)
+						if moduleErr == nil {
+							mod.Dispose()
+						}
+						ctx.Dispose()
+						err = moduleErr
+					} else {
+						_, err = Translate(file, options)
+					}
+					if err == nil || !strings.Contains(err.Error(), "unresolved symbolic immediate") {
+						t.Fatalf("unresolved %s became a successful/fabricated value: %v", operand, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslationChecksRawDirectiveImmediatesBeforeDecoding(t *testing.T) {
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+		body   string
+	}{
+		{ArchAMD64, "amd64", "BYTE $(0x90 + missing_byte)"},
+		{ArchAMD64, "386", "BYTE $(0x90 + missing_byte)"},
+		{ArchARM64, "arm64", "WORD $(0xd503201f + missing_word)"},
+		{ArchARM, "arm", "WORD $(0xe320f000 + missing_word)"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			file, err := Parse(target.arch, "TEXT raw_unknown(SB),$0-0\n"+target.body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.goarch,
+				Sigs: map[string]FuncSig{"raw_unknown": {Name: "raw_unknown", Ret: Void}},
+			}
+			_, err = Translate(file, options)
+			if err == nil || !strings.Contains(err.Error(), "unresolved symbolic immediate") {
+				t.Fatalf("raw unknown immediate reached decoding: %v", err)
+			}
+			ctx := llvm.NewContext()
+			mod, moduleErr := TranslateModuleInContext(ctx, file, options)
+			if moduleErr == nil {
+				mod.Dispose()
+			}
+			ctx.Dispose()
+			if moduleErr == nil || !strings.Contains(moduleErr.Error(), "unresolved symbolic immediate") {
+				t.Fatalf("raw unknown immediate reached module decoding: %v", moduleErr)
+			}
+		})
+	}
+}
+
+func TestResolvedImmediateGrammarPreservesConstantsAndAddresses(t *testing.T) {
+	for _, text := range []string{
+		"$0", "$33", "$(16 + 17)", "$1.5", "$global(SB)", "$global+8(SB)",
+		"$slot+0(FP)", "$8(AX)", "$(-64*1024+104)(R13)", "$global(SB)(AX*8)",
+	} {
+		t.Run(text, func(t *testing.T) {
+			operand, err := parseOperand(text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := unresolvedSymbolicImmediateError(operand); err != nil {
+				t.Fatalf("resolved constant/address rejected: %v", err)
+			}
+		})
+	}
+}
+
+func TestTranslationCompilesExpandedImmediateOnEveryArchitecture(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch   Arch
+		goarch string
+		triple string
+		body   string
+		ret    LLVMType
+		size   int
+	}{
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu", "MOVQ $PRESENT, AX\nMOVQ AX, ret+0(FP)\nRET", I64, 8},
+		{ArchAMD64, "386", "i386-unknown-linux-gnu", "MOVL $PRESENT, AX\nMOVL AX, ret+0(FP)\nRET", I32, 4},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "MOVD $PRESENT, R0\nMOVD R0, ret+0(FP)\nRET", I64, 8},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf", "MOVW $PRESENT, R0\nMOVW R0, ret+0(FP)\nRET", I32, 4},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown", "I64Const $PRESENT\nReturn", I64, 8},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			source := fmt.Sprintf("#define PRESENT (16+17)\nTEXT known(SB),$0-%d\n%s\n", target.size, target.body)
+			file, err := Parse(target.arch, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple,
+				Sigs: map[string]FuncSig{"known": {Name: "known", Ret: target.ret, Frame: FrameLayout{
+					Results: []FrameSlot{{Offset: 0, Type: target.ret, Index: 0, Field: -1}},
+				}}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, string(target.ret)+" 33") {
+				t.Fatalf("expanded constant 33 missing from translated semantics:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, target.triple, "known.ll", "known.o", ir)
+		})
+	}
+}
diff --git a/instruction.go b/instruction.go
index 4331b80d0..4ac7e172f 100644
--- a/instruction.go
+++ b/instruction.go
@@ -27,13 +27,15 @@ func DescribeInstruction(arch Arch, goarch string, ins Instr) InstructionDescrip
 	for i, arg := range ins.Args {
 		operands[i] = operandClass(arch, goarch, arg)
 	}
+	// Keep rejected and accepted control spellings separate. The base opcode
+	// remains the family key; it is not the complete source-form identity.
 	return InstructionDescriptor{
 		Arch:     arch,
 		Goarch:   goarch,
 		Family:   InstructionFamily(arch, op),
 		Opcode:   op,
 		Operands: operands,
-		Form:     op + " " + strings.Join(operands, ","),
+		Form:     strings.ToUpper(strings.TrimSpace(string(ins.Op))) + " " + strings.Join(operands, ","),
 	}
 }
 
@@ -144,10 +146,10 @@ func arm64InstructionFamily(op string) string {
 	switch {
 	case isARM64BranchOpcode(op):
 		return "control-flow"
+	case strings.HasPrefix(op, "CAS") || strings.HasPrefix(op, "SWP") || strings.Contains(op, "XR") || strings.Contains(op, "XP"):
+		return "atomic-memory"
 	case strings.HasPrefix(op, "LD") || strings.HasPrefix(op, "ST") || strings.HasPrefix(op, "MOV"):
 		return "load-store-move"
-	case strings.HasPrefix(op, "CAS") || strings.HasPrefix(op, "SWP") || strings.Contains(op, "XR"):
-		return "atomic-memory"
 	case strings.HasPrefix(op, "AES") || strings.HasPrefix(op, "SHA"):
 		return "crypto"
 	case strings.HasPrefix(op, "V"):
@@ -233,7 +235,7 @@ func isARMBranchOpcode(op string) bool {
 
 func isInstructionDirective(op string) bool {
 	switch op {
-	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "FUNCDATA", "PCDATA":
+	case "TEXT", "DATA", "GLOBL", "BYTE", "WORD", "LONG", "QUAD", "PCALIGN", "PCALIGNMAX", "FUNCDATA", "PCDATA":
 		return true
 	default:
 		return false
@@ -315,6 +317,9 @@ func registerClass(arch Arch, goarch string, reg Reg) string {
 		if r == "ZR" {
 			return "zero-register"
 		}
+		if r == "RSP" {
+			return "stack-pointer"
+		}
 		if prefix, index, _, ok := regRangeParts(Reg(r)); ok {
 			switch {
 			case prefix == "Z" && index <= 31:
@@ -402,18 +407,48 @@ func ProbeInstruction(arch Arch, goarch string, ins Instr) error {
 	if strings.HasPrefix(normalizeInstructionOpcode(ins.Op), "REP") {
 		return fmt.Errorf("%w: REP prefix must be probed with its following instruction", ErrProbeNeedsContext)
 	}
+	if arch == ArchAMD64 && goarch == "386" && normalizeInstructionOpcode(ins.Op) == "JMP" &&
+		len(ins.Args) == 1 && ins.Args[0].Kind == OpImm && ins.Args[0].ImmRaw == "" {
+		return fmt.Errorf("%w: %s uses the 386 assembler's legacy numeric branch relocation and requires final text layout", ErrProbeNeedsContext, ins.Raw)
+	}
+	if arch == ArchARM && normalizeInstructionOpcode(ins.Op) == "RFE" {
+		return fmt.Errorf("%w: %s returns through privileged exception state", ErrProbeNeedsContext, ins.Raw)
+	}
+	if arch == ArchARM64 {
+		op := normalizeInstructionOpcode(ins.Op)
+		if op == "ADR" || op == "ADRP" {
+			return fmt.Errorf("%w: %s requires the final function-local label layout", ErrProbeNeedsContext, ins.Raw)
+		}
+		switch op {
+		case "TLBI", "SYS", "SYSL", "DCPS1", "DCPS2", "DCPS3", "DRPS", "ERET", "HLT", "HVC", "SMC":
+			return fmt.Errorf("%w: %s depends on privileged ARM64 execution state", ErrProbeNeedsContext, ins.Raw)
+		}
+	}
 	for _, arg := range ins.Args {
+		if arch == ArchAMD64 {
+			if err := validateX86SymbolDisplacement(arg); err != nil {
+				return fmt.Errorf("%s: %w", ins.Raw, err)
+			}
+		}
+		if err := unresolvedSymbolicImmediateErrorForArch(arg, arch); err != nil {
+			return fmt.Errorf("%w: %s needs resolved assembler constants: %v", ErrProbeNeedsContext, ins.Raw, err)
+		}
 		switch arg.Kind {
 		case OpFP, OpFPAddr:
 			return fmt.Errorf("%w: %s uses an FP frame slot", ErrProbeNeedsContext, ins.Raw)
-		case OpImm:
-			if arg.ImmRaw != "" {
-				return fmt.Errorf("%w: %s uses a symbolic immediate", ErrProbeNeedsContext, ins.Raw)
-			}
 		case OpMem:
+			if arch == ArchAMD64 {
+				if err := unresolvedX86MemoryOffsetError(arg.Mem); err != nil {
+					return fmt.Errorf("%s: %w", ins.Raw, err)
+				}
+			}
 			if arg.Mem.Base == PC {
 				return fmt.Errorf("%w: %s uses a PC-relative target", ErrProbeNeedsContext, ins.Raw)
 			}
+			if arch == ArchARM && armMemoryOffsetNeedsContext(arg.Mem) ||
+				arch == ArchARM64 && arm64MemoryOffsetNeedsContext(arg.Mem) {
+				return fmt.Errorf("%w: %s uses an unresolved memory-offset macro", ErrProbeNeedsContext, ins.Raw)
+			}
 		case OpIdent:
 			if InstructionFamily(arch, string(ins.Op)) == "control-flow" {
 				return fmt.Errorf("%w: %s uses a function-local target", ErrProbeNeedsContext, ins.Raw)
@@ -421,24 +456,104 @@ func ProbeInstruction(arch Arch, goarch string, ins Instr) error {
 		}
 	}
 
-	fn := Func{Sym: "plan9asm.probe", Instrs: []Instr{ins}}
+	instrs := []Instr{ins}
+	op, _, _, _ := armDecodeOp(string(ins.Op))
+	if arch == ArchARM && (op == "ADC" || op == "SBC" || op == "RSC") {
+		// A single-form coverage fixture may supply the ordinary implicit
+		// carry-family input with real source. CMP preserves every GPR
+		// and defines all NZCV bits, unlike invented entry flag slots.
+		// Do not apply this to other native predicates, a CPSR read, or full
+		// source sequences, which retain their independently checked context.
+		instrs = append([]Instr{{
+			Op: "CMP", Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpReg, Reg: "R0"}},
+			Raw: "CMP R0,R0 // explicit single-instruction probe flags fixture",
+		}}, instrs...)
+	}
+	if arch == ArchARM64 {
+		_, handled, err := parseARM64CarryForm(Op(normalizeInstructionOpcode(ins.Op)), ins)
+		if handled {
+			if err != nil {
+				return err
+			}
+			// This is only the single-form coverage fixture. A real CMP
+			// preserves GP inputs and supplies C for the complete typed
+			// carry grammar; no entry flag slot or caller source is changed.
+			// Sequence and full-source consumers still require their own
+			// reaching flag definition on every original CFG path.
+			instrs = append([]Instr{{
+				Op: "CMP", Args: []Operand{{Kind: OpReg, Reg: "R0"}, {Kind: OpReg, Reg: "R0"}},
+				Raw: "CMP R0,R0 // explicit single-instruction probe flags fixture",
+			}}, instrs...)
+		}
+	}
+	err := probeInstructionSequence(arch, goarch, instrs)
+	if arch == ArchARM && ins.Op == OpWORD && err != nil {
+		return fmt.Errorf("%w: %s requires surrounding instruction, register, and control-flow state: %v", ErrProbeNeedsContext, ins.Raw, err)
+	}
+	return err
+}
+
+// ProbeInstructionSequence runs a self-contained instruction sequence through
+// the real lowering pipeline. Coverage scanners use this for forms whose
+// meaning spans source directives, such as consecutive x86 BYTE/WORD/LONG/QUAD
+// directives that encode one or more machine instructions.
+func ProbeInstructionSequence(arch Arch, goarch string, instrs []Instr) error {
+	if len(instrs) == 0 {
+		return fmt.Errorf("empty instruction probe sequence")
+	}
+	if arch == ArchWASM {
+		return fmt.Errorf("%w: wasm instructions require their full function", ErrProbeNeedsContext)
+	}
+	return probeInstructionSequence(arch, goarch, instrs)
+}
+
+func probeInstructionSequence(arch Arch, goarch string, instrs []Instr) error {
+	fn := Func{Sym: "plan9asm.probe", Instrs: append([]Instr(nil), instrs...)}
+	if arch == ArchARM64 {
+		var err error
+		fn, err = arm64InstructionProbeFunc(instrs)
+		if err != nil {
+			return err
+		}
+	}
 	labels := map[string]struct{}{}
+	definedLabels := map[string]struct{}{}
 	sigs := map[string]FuncSig{
 		fn.Sym: {Name: fn.Sym, Ret: Void},
 	}
-	for _, arg := range ins.Args {
-		if arg.Kind == OpLabel {
-			labels[arg.Sym] = struct{}{}
-		}
-		if arg.Kind == OpSym && (ins.Op == OpCALL || ins.Op == OpJMP || normalizeInstructionOpcode(ins.Op) == "CALLNORESUME") {
-			name := strings.TrimSuffix(arg.Sym, "(SB)")
-			sigs[name] = FuncSig{Name: name, Ret: Void}
+	for _, ins := range instrs {
+		for _, arg := range ins.Args {
+			if err := unresolvedSymbolicImmediateErrorForArch(arg, arch); err != nil {
+				return fmt.Errorf("%w: %s needs resolved assembler constants: %v", ErrProbeNeedsContext, ins.Raw, err)
+			}
+			if arg.Kind == OpLabel {
+				labels[arg.Sym] = struct{}{}
+				if ins.Op == OpLABEL {
+					definedLabels[arg.Sym] = struct{}{}
+				}
+			}
+			if arg.Kind == OpSym && (ins.Op == OpCALL || ins.Op == OpJMP || normalizeInstructionOpcode(ins.Op) == "CALLNORESUME") {
+				name := strings.TrimSuffix(arg.Sym, "(SB)")
+				sigs[name] = FuncSig{Name: name, Ret: Void}
+			}
 		}
 	}
 	for label := range labels {
+		if _, ok := definedLabels[label]; ok {
+			continue
+		}
 		fn.Instrs = append(fn.Instrs, Instr{Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label}}, Raw: label + ":"})
 	}
-	fn.Instrs = append(fn.Instrs, Instr{Op: OpRET, Raw: "RET"})
+	exit := Instr{Op: OpRET, Raw: "RET"}
+	if arch == ArchARM64 {
+		// Isolated data may overwrite LR or SP. A synthetic caller RET
+		// would incorrectly require that data to preserve return state.
+		// This compile-only harness ends with a real faulting zero branch;
+		// it is never executed or counted as runtime conformance. Original
+		// control instructions retain all their ABI and target checks.
+		exit = Instr{Op: "B", Args: []Operand{{Kind: OpMem, Mem: MemRef{Base: ZR}}}, Raw: "B (ZR)"}
+	}
+	fn.Instrs = append(fn.Instrs, exit)
 	file := &File{Arch: arch, Funcs: []Func{fn}}
 	triple := ""
 	switch goarch {
@@ -456,5 +571,13 @@ func ProbeInstruction(arch Arch, goarch string, ins Instr) error {
 		wasmABI = WASMABIGo
 	}
 	_, err := translateIRText(file, Options{Goarch: goarch, TargetTriple: triple, Sigs: sigs, WASMABI: wasmABI})
+	if err == nil && arch == ArchAMD64 && x86TypedFPResultNeedsProof(fn, sigs[fn.Sym], goarch) {
+		// A synthetic coverage stub is a source query, not a declared ABI0
+		// caller. Keep mandatory inputs unknown instead of borrowing the
+		// ordinary emitter's permitted vector-scratch realization.
+		query := amd64Ctx{fpScalarSource: fn, fpSourceSig: sigs[fn.Sym], sig: sigs[fn.Sym],
+			goarch: goarch, targetTriple: triple}
+		return query.checkLoweredScalarFPResultInitialization()
+	}
 	return err
 }
diff --git a/instruction_arm64_carry_probe_test.go b/instruction_arm64_carry_probe_test.go
new file mode 100644
index 000000000..ab9da8425
--- /dev/null
+++ b/instruction_arm64_carry_probe_test.go
@@ -0,0 +1,314 @@
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func arm64CarryProbeOpcodes() []string {
+	return []string{"ADC", "ADCW", "ADCS", "ADCSW", "SBC", "SBCW", "SBCS", "SBCSW", "NGC", "NGCW", "NGCS", "NGCSW"}
+}
+
+func arm64CarryProbeForms(op string) []string {
+	if strings.HasPrefix(op, "NGC") {
+		return []string{"R1,R2", "ZR,R2", "R1,ZR", "ZR,ZR", "R0,R0"}
+	}
+	return []string{
+		"R1,R2", "R1,R2,R3", "ZR,R2", "ZR,R2,R3", "$0,R2", "$0,R2,R3",
+		"R1,ZR", "R1,ZR,ZR", "ZR,ZR,ZR", "R0,R0,R0", "R1,R2,R30",
+	}
+}
+
+func arm64CarryProbeFile(t *testing.T, body string) *File {
+	t.Helper()
+	file, err := Parse(ArchARM64, "TEXT carryProbe(SB),516,$0-0\n"+body+"\nB (ZR)\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file
+}
+
+func arm64CarryProbeBody(file *File) []Instr {
+	instrs := file.Funcs[0].Instrs
+	return instrs[1 : len(instrs)-1]
+}
+
+func arm64CarryProbeTranslate(file *File) (string, error) {
+	return Translate(file, Options{Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"carryProbe": {Name: "carryProbe", Ret: Void}},
+	})
+}
+
+func arm64CarryProbeCheckCompleteGoTable(t *testing.T, goroot string) {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(goroot, "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	versionData, err := os.ReadFile(filepath.Join(goroot, "VERSION"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	version := strings.SplitN(strings.TrimSpace(string(versionData)), "\n", 2)[0]
+	columns, err := arm64CarryProbeGoOptabColumns(source, version)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var aliases []string
+	for _, family := range []struct {
+		name string
+		rows []string
+	}{
+		{"AADC", []string{
+			"{AADC,C_ZREG,C_ZREG,C_NONE,C_ZREG,C_NONE,1,4,0,0,0},",
+			"{AADC,C_ZREG,C_NONE,C_NONE,C_ZREG,C_NONE,1,4,0,0,0},",
+		}},
+		{"ANGC", []string{"{ANGC,C_ZREG,C_NONE,C_NONE,C_ZREG,C_NONE,17,4,0,0,0},"}},
+	} {
+		rows := regexp.MustCompile(`(?m)^\s*\{`+family.name+`,[^\n]+`).FindAllString(source, -1)
+		for index, row := range rows {
+			rows[index] = strings.Join(strings.Fields(row), "")
+		}
+		if columns == 10 {
+			// The verified old schema lacks only the a5 destination column.
+			// Every other operand, encoder and effect field stays exact.
+			for index, row := range family.rows {
+				fields := strings.Split(row, ",")
+				family.rows[index] = strings.Join(append(fields[:5:5], fields[6:]...), ",")
+			}
+		}
+		if !reflect.DeepEqual(rows, family.rows) {
+			t.Fatalf("complete Go %s rows changed: got %v want %v", family.name, rows, family.rows)
+		}
+		start := strings.Index(source, "case "+family.name+":")
+		if start < 0 {
+			t.Fatalf("missing Go opcode alias registration: %s", family.name)
+		}
+		block := source[start+len("case "+family.name+":"):]
+		if end := strings.Index(block, "\n\t\tcase "); end >= 0 {
+			block = block[:end]
+		}
+		aliases = append(aliases, strings.TrimPrefix(family.name, "A"))
+		for _, match := range regexp.MustCompile(`oprangeset\(A([A-Z0-9]+), t\)`).FindAllStringSubmatch(block, -1) {
+			aliases = append(aliases, match[1])
+		}
+	}
+	want := arm64CarryProbeOpcodes()
+	sort.Strings(aliases)
+	sort.Strings(want)
+	if !reflect.DeepEqual(aliases, want) {
+		t.Fatalf("complete Go carry alias family changed: got %v want %v", aliases, want)
+	}
+
+	data, err = os.ReadFile(filepath.Join(goroot, "src/cmd/internal/obj/arm64/obj7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = string(data)
+	start := strings.Index(source, "var zrReplace = map[obj.As]bool{")
+	if start < 0 {
+		t.Fatal("Go source zero-alias table missing")
+	}
+	block := source[start:]
+	end := strings.Index(block, "\n}")
+	if end < 0 {
+		t.Fatal("Go source zero-alias table is not complete")
+	}
+	block = block[:end]
+	for _, op := range arm64CarryProbeOpcodes() {
+		present := regexp.MustCompile(`\bA` + op + `:\s+true,`).MatchString(block)
+		if present == strings.HasPrefix(op, "NGC") {
+			t.Fatalf("Go %s immediate-zero alias changed: present=%v", op, present)
+		}
+	}
+	t.Logf("actual %s: complete %d-column Optab, all 12 carry aliases and exact zero-replace membership", version, columns)
+}
+
+func TestARM64CarryProbeSingleCompleteForms(t *testing.T) {
+	for _, op := range arm64CarryProbeOpcodes() {
+		for _, operands := range arm64CarryProbeForms(op) {
+			spelling := op + " " + operands
+			t.Run(spelling, func(t *testing.T) {
+				file := arm64CarryProbeFile(t, spelling)
+				requireARM64GoAssemblerResult(t, file.Funcs[0].Instrs[0].Raw+"\n"+spelling+"\nB (ZR)\n", true)
+				ins := arm64CarryProbeBody(file)[0]
+				before := ins
+				before.Args = append([]Operand(nil), ins.Args...)
+				if err := ProbeInstruction(ArchARM64, "arm64", ins); err != nil {
+					t.Errorf("valid single carry form needs its own real CMP fixture: %v", err)
+				}
+				if !reflect.DeepEqual(ins, before) {
+					t.Fatal("single-form fixture mutated the original instruction")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64CarryProbeRetainsSequenceAndSourceFlagInputs(t *testing.T) {
+	for _, op := range arm64CarryProbeOpcodes() {
+		operands := "R1,R2,R3"
+		if strings.HasPrefix(op, "NGC") {
+			operands = "R1,R2"
+		}
+		spelling := op + " " + operands
+		for _, body := range []string{spelling, spelling + "\nCMP R0,R0", "CMP R0,R0\n" + spelling} {
+			t.Run(body, func(t *testing.T) {
+				file := arm64CarryProbeFile(t, body)
+				sequenceErr := ProbeInstructionSequence(ArchARM64, "arm64", arm64CarryProbeBody(file))
+				_, sourceErr := arm64CarryProbeTranslate(file)
+				for _, err := range []error{sequenceErr, sourceErr} {
+					if strings.HasPrefix(body, "CMP ") {
+						if err != nil {
+							t.Fatalf("actual prior CMP source was rejected: %v", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "unknown NZCV bits 0x2") {
+						t.Fatalf("missing or late CMP supplied the original carry input: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestARM64CarryProbeRejectsFormsOutsideGoGrammar(t *testing.T) {
+	for _, op := range arm64CarryProbeOpcodes() {
+		forms := []string{"R1", "R1,R2,R3,R4", "RSP,R2", "R1,RSP", "R1<<1,R2", "$1,R2", "(R1),R2"}
+		if strings.HasPrefix(op, "NGC") {
+			forms = append(forms, "R1,R2,R3", "$0,R2")
+		} else {
+			forms = append(forms, "R1,RSP,R2", "R1,R2,RSP", "R1.UXTW,R2,R3")
+		}
+		for _, operands := range forms {
+			t.Run(op+" "+operands, func(t *testing.T) {
+				spelling := op + " " + operands
+				requireARM64GoAssemblerResult(t, "TEXT invalidCarry(SB),516,$0-0\nCMP R0,R0\n"+spelling+"\nB (ZR)\n", false)
+				file := arm64CarryProbeFile(t, spelling)
+				if err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(file)[0]); err == nil {
+					t.Fatal("single-form fixture accepted a Go-invalid carry operand")
+				}
+			})
+		}
+		for _, suffix := range []string{".P", ".W", ".S"} {
+			t.Run(op+suffix, func(t *testing.T) {
+				spelling := op + suffix + " R1,R2"
+				requireARM64GoAssemblerResult(t, "TEXT invalidCarry(SB),516,$0-0\n"+spelling+"\nB (ZR)\n", false)
+				file := arm64CarryProbeFile(t, spelling)
+				if err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(file)[0]); err == nil {
+					t.Fatal("single-form fixture accepted a Go-invalid carry suffix")
+				}
+			})
+		}
+	}
+}
+
+func TestARM64CarryProbeDoesNotSupplyOtherConditionFlags(t *testing.T) {
+	for _, body := range []string{"CSET EQ,R1", "CSEL CS,R1,R2,R3", "CCMNW EQ,R1,$1,$0", "CSINVW MI,R1,R2,R3", "FCCMPD VS,F0,F1,$0"} {
+		t.Run(body, func(t *testing.T) {
+			file := arm64CarryProbeFile(t, body)
+			if err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(file)[0]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("carry fixture supplied a foreign condition's flags: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64AlwaysConditionProbeNeedsNoFlags(t *testing.T) {
+	for _, spelling := range []string{
+		"CCMNW AL,R26,$20,$11", "CCMNW AL,R19,R24,$7", "CSELW AL,R24,R16,R10",
+		"FCCMPD AL,F0,F9,$0", "FCCMPED AL,F0,F14,$11", "FCCMPES AL,F7,F14,$1", "FCCMPS AL,F31,F5,$5",
+		"CSINC AL,R17,R26,R26", "CSINCW AL,R11,R25,R21", "CSINV AL,R30,R6,R21", "CSINV AL,R26,R12,R30",
+		"CSINV AL,ZR,ZR,ZR", "CSINVW AL,R23,R21,R5", "CSINVW AL,R27,R21,R5", "CSINVW AL,ZR,ZR,R5",
+		"CSNEG AL,R26,R19,R21", "CSNEGW AL,R4,R5,R0",
+	} {
+		t.Run(spelling, func(t *testing.T) {
+			file := arm64CarryProbeFile(t, spelling)
+			requireARM64GoAssemblerResult(t, "TEXT alwaysCondition(SB),516,$0-0\n"+spelling+"\nB (ZR)\n", true)
+			if mask, err := arm64ConditionFlags("AL"); err != nil || mask != 0 {
+				t.Fatalf("AL is not a constant predicate: mask=%#x err=%v", mask, err)
+			}
+			if err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(file)[0]); err != nil {
+				t.Fatal(err)
+			}
+			if err := ProbeInstructionSequence(ArchARM64, "arm64", arm64CarryProbeBody(file)); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := arm64CarryProbeTranslate(file); err != nil {
+				t.Fatal(err)
+			}
+			conditional := arm64CarryProbeFile(t, strings.Replace(spelling, " AL,", " EQ,", 1))
+			if err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(conditional)[0]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("non-AL condition lost its original flag input: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64AlwaysConditionProbeMatchesCompleteGoConditions(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/list7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	block := regexp.MustCompile(`(?s)var strcond = \[16\]string\{(.*?)\n\}`).FindSubmatch(data)
+	if len(block) != 2 {
+		t.Fatal("complete Go ARM64 condition-name table changed")
+	}
+	var names []string
+	for _, match := range regexp.MustCompile(`"([A-Z]+)"`).FindAllSubmatch(block[1], -1) {
+		names = append(names, string(match[1]))
+	}
+	want := []string{"EQ", "NE", "HS", "LO", "MI", "PL", "VS", "VC", "HI", "LS", "GE", "LT", "GT", "LE", "AL", "NV"}
+	if !reflect.DeepEqual(names, want) {
+		t.Fatalf("complete Go condition names changed: got %v want %v", names, want)
+	}
+	for _, condition := range names {
+		t.Run(condition, func(t *testing.T) {
+			spelling := "CSEL " + condition + ",R1,R2,R3"
+			requireARM64GoAssemblerResult(t, "TEXT condition(SB),516,$0-0\n"+spelling+"\nB (ZR)\n", true)
+			file := arm64CarryProbeFile(t, spelling)
+			err := ProbeInstruction(ArchARM64, "arm64", arm64CarryProbeBody(file)[0])
+			if condition == "AL" || condition == "NV" {
+				if mask, maskErr := arm64ConditionFlags(condition); maskErr != nil || mask != 0 || err != nil {
+					t.Fatalf("constant condition needs flags: mask=%#x maskErr=%v probe=%v", mask, maskErr, err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("nonconstant %s lost its source-defined flags: %v", condition, err)
+			}
+		})
+	}
+}
+
+func TestARM64CarryProbeDoesNotInventSyscallContext(t *testing.T) {
+	for _, spelling := range []string{"SVC", "SVC $0", "SVC $7165"} {
+		t.Run(spelling, func(t *testing.T) {
+			file := arm64CarryProbeFile(t, spelling)
+			ins := arm64CarryProbeBody(file)[0]
+			before := ins
+			before.Args = append([]Operand(nil), ins.Args...)
+			if err := ProbeInstruction(ArchARM64, "arm64", ins); err != nil {
+				t.Fatalf("original Linux syscall probe acquired virtual flags as GP scratch: %v", err)
+			}
+			if err := ProbeInstructionSequence(ArchARM64, "arm64", []Instr{ins}); err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(ins, before) {
+				t.Fatal("syscall probe acquired invented entry instructions")
+			}
+			if _, err := arm64CarryProbeTranslate(file); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+				"carryProbe": {Name: "carryProbe", Ret: Void},
+			}}); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "requires an explicit ARM64 target") {
+				t.Fatalf("missing original syscall target was invented: %v", err)
+			}
+		})
+	}
+}
diff --git a/instruction_arm64_carry_schema_test.go b/instruction_arm64_carry_schema_test.go
new file mode 100644
index 000000000..15307206f
--- /dev/null
+++ b/instruction_arm64_carry_schema_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func arm64CarryProbeGoOptabColumns(source, version string) (int, error) {
+	match := regexp.MustCompile(`^go1\.(20|21|22|23|24|25|26|27)(?:\.[0-9]+)?$`).FindStringSubmatch(version)
+	if len(match) != 2 {
+		return 0, fmt.Errorf("unrecognized complete Optab SDK version %q", version)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "asm7.go", source, parser.SkipObjectResolution)
+	if err != nil {
+		return 0, err
+	}
+	var actual []string
+	declarations := 0
+	for _, declaration := range file.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.TYPE {
+			continue
+		}
+		for _, spec := range group.Specs {
+			typeSpec := spec.(*ast.TypeSpec)
+			if typeSpec.Name.Name != "Optab" {
+				continue
+			}
+			declarations++
+			structure, ok := typeSpec.Type.(*ast.StructType)
+			if !ok || typeSpec.Assign.IsValid() {
+				return 0, fmt.Errorf("Go Optab is not an original struct definition")
+			}
+			for _, field := range structure.Fields.List {
+				if len(field.Names) != 1 || field.Tag != nil {
+					return 0, fmt.Errorf("unrecognized grouped, embedded or tagged Optab field")
+				}
+				var fieldType string
+				switch typ := field.Type.(type) {
+				case *ast.Ident:
+					fieldType = typ.Name
+				case *ast.SelectorExpr:
+					if object, ok := typ.X.(*ast.Ident); ok {
+						fieldType = object.Name + "." + typ.Sel.Name
+					}
+				}
+				actual = append(actual, field.Names[0].Name+" "+fieldType)
+			}
+		}
+	}
+	want := []string{"as obj.As", "a1 uint8", "a2 uint8", "a3 uint8", "a4 uint8"}
+	extraDestination := match[1] != "20" && match[1] != "21"
+	if extraDestination {
+		want = append(want, "a5 uint8")
+	}
+	want = append(want, "type_ int8", "size_ int8", "param int16", "flag int8")
+	if extraDestination {
+		want = append(want, "scond uint8")
+	} else {
+		want = append(want, "scond uint16")
+	}
+	if declarations != 1 || !reflect.DeepEqual(actual, want) {
+		return 0, fmt.Errorf("complete Go %s Optab schema changed: declarations=%d got %v want %v", version, declarations, actual, want)
+	}
+	return len(want), nil
+}
+
+func TestARM64CarryProbeMatchesCompleteGoTable(t *testing.T) {
+	roots := []string{testGOROOT(t)}
+	if additional := os.Getenv("PLAN9ASM_TEST_CARRY_SDK_ROOTS"); additional != "" {
+		roots = append(roots, filepath.SplitList(additional)...)
+	}
+	seen := make(map[string]bool)
+	for _, root := range roots {
+		physical, err := filepath.EvalSymlinks(root)
+		if err != nil || !filepath.IsAbs(physical) {
+			t.Fatalf("actual SDK root required: %q: %v", root, err)
+		}
+		if seen[physical] {
+			continue
+		}
+		seen[physical] = true
+		t.Run(filepath.Base(physical), func(t *testing.T) {
+			arm64CarryProbeCheckCompleteGoTable(t, physical)
+		})
+	}
+}
+
+func TestARM64CarryProbeGoOptabRejectsUnknownSchemas(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(testGOROOT(t), "src/cmd/internal/obj/arm64/asm7.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	versionData, err := os.ReadFile(filepath.Join(testGOROOT(t), "VERSION"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	version := strings.SplitN(strings.TrimSpace(string(versionData)), "\n", 2)[0]
+	for _, change := range []struct{ name, source, version string }{
+		{"foreign_sdk", source, "go1.99.1"},
+		{"unknown_field", strings.Replace(source, "type Optab struct {", "type Optab struct {\nforeign int", 1), version},
+		{"changed_opcode_type", regexp.MustCompile(`(?m)^(\s*as\s+)obj\.As`).ReplaceAllString(source, "${1}int"), version},
+		{"changed_condition_type", regexp.MustCompile(`(?m)^(\s*scond\s+)uint(?:8|16)`).ReplaceAllString(source, "${1}uint32"), version},
+		{"duplicate_definition", source + "\ntype Optab struct {}\n", version},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			if change.source == source && change.version == version {
+				t.Fatal("negative schema fixture did not change its input")
+			}
+			if _, err := arm64CarryProbeGoOptabColumns(change.source, change.version); err == nil {
+				t.Fatal("unknown actual schema was silently reduced to known encoder rows")
+			}
+		})
+	}
+}
diff --git a/instruction_arm64_probe_test.go b/instruction_arm64_probe_test.go
new file mode 100644
index 000000000..b81f565b1
--- /dev/null
+++ b/instruction_arm64_probe_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestARM64InstructionProbeDoesNotRequireDataToPreserveCallerState(t *testing.T) {
+	for _, instruction := range []string{
+		"LDAXP (R25), (R30, R11)",
+		"LDXRW (RSP), R30",
+		"NEGSW R23<<1, R30",
+		"VLD3.P (R30)(R2), [V14.D2, V15.D2, V16.D2]",
+		"MOVD $0x1708(RSP), RSP",
+		"MOVD $-0x10000(RSP), RSP",
+		"MOVD R2, RSP",
+		"ADD R2, RSP, RSP",
+		"ADD R2.SXTX<<1, RSP, RSP",
+		"ADDW R1<<2, R3, RSP",
+		"SUB R1<<3, RSP",
+		"MOVW $0x10001000, RSP",
+		"AND $8, R0, RSP",
+		"BIC $8, R0, RSP",
+		"EOR $8, R0, RSP",
+		"ORR $8, R0, RSP",
+		"EON $8, R0, RSP",
+		"ORN $8, R0, RSP",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			// This is a compile-only harness, never an executable success.
+			// A real zero-address branch is independent of the tested data
+			// instruction's writes to the caller link and stack pointer.
+			source := "TEXT isolatedData(SB),516,$0-0\n" + instruction + "\nB (ZR)\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var tested Instr
+			for _, ins := range file.Funcs[0].Instrs {
+				if ins.Op != OpTEXT {
+					tested = ins
+					break
+				}
+			}
+			if err := ProbeInstruction(ArchARM64, "arm64", tested); err != nil {
+				t.Fatalf("a data form must not inherit a synthetic RET's caller-state requirement: %v", err)
+			}
+			if err := ProbeInstructionSequence(ArchARM64, "arm64", []Instr{tested}); err != nil {
+				t.Fatalf("a sequence probe must use the same state-independent exit: %v", err)
+			}
+
+			llc := findLLVM22Tool("llc")
+			if llc == "" {
+				t.Fatal("LLVM 22 llc not found")
+			}
+			for _, triple := range []string{
+				"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+				"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+			} {
+				ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+					Sigs: map[string]FuncSig{"isolatedData": {Name: "isolatedData", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				if !strings.Contains(ir, `asm sideeffect "br $0", "r,~{memory}"(i64 0)`+"\n  unreachable") {
+					t.Fatal("compile-only exit must remain a real faulting terminator, not a fake return")
+				}
+				compileLLVMToObject(t, llc, triple, "isolated-data.ll", "isolated-data.o", ir)
+			}
+		})
+	}
+}
+
+func TestARM64InstructionProbeRetainsNativeControlContracts(t *testing.T) {
+	for _, instruction := range []string{
+		"BL (R2)", "CALL (R15)", "RET R0", "RET R6", "RET R9", "RET R27", "JMP (R29)",
+		"WORD $0xd61f0120", "WORD $0xd65f0120",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT isolatedControl(SB),516,$0-0\n" + instruction + "\nB (ZR)\n"
+			requireARM64GoAssemblerResult(t, source, true)
+			file, err := Parse(ArchARM64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sequence := file.Funcs[0].Instrs[1:2]
+			if err := ProbeInstructionSequence(ArchARM64, "arm64", sequence); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("a faulting probe exit cannot establish an unknown native target's ABI: %v", err)
+			}
+		})
+	}
+}
+
+func TestARM64InstructionProbeExitRetainsStackMemorySafety(t *testing.T) {
+	source := "TEXT unboundedStack(SB),516,$0-0\nADD R2,RSP,RSP\nMOVD (RSP),R3\nB (ZR)\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "arm64", Sigs: map[string]FuncSig{
+		"unboundedStack": {Name: "unboundedStack", Ret: Void},
+	}})
+	if err == nil || !strings.Contains(err.Error(), "cannot bound dynamic local stack access") {
+		t.Fatalf("a real dereference of unbounded local SP must remain rejected: %v", err)
+	}
+}
diff --git a/instruction_control_identity_test.go b/instruction_control_identity_test.go
new file mode 100644
index 000000000..7c0474252
--- /dev/null
+++ b/instruction_control_identity_test.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDescribeInstructionRetainsFullControlIdentity(t *testing.T) {
+	for _, control := range []string{
+		"", ".Z", ".BCST", ".BCST.Z", ".SAE", ".SAE.Z",
+		".RN_SAE", ".RD_SAE", ".RU_SAE", ".RZ_SAE", ".RN_SAE.Z",
+		".Z.BCST", ".UNKNOWN",
+	} {
+		t.Run("VADDPD"+control, func(t *testing.T) {
+			// Identity preserves even invalid controls; it grants no grammar
+			// acceptance, initialized inputs or executable evidence.
+			ins := Instr{Op: Op(" vaddpd" + strings.ToLower(control) + " "), Args: []Operand{
+				{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X2"},
+			}}
+			for _, arch := range []string{"386", "amd64"} {
+				descriptor := DescribeInstruction(ArchAMD64, arch, ins)
+				if descriptor.Opcode != "VADDPD" || descriptor.Family != "avx" ||
+					descriptor.Form != "VADDPD"+control+" xmm,xmm,xmm" {
+					t.Fatalf("%s: source controls collapsed or changed the opcode family: %+v", arch, descriptor)
+				}
+			}
+		})
+	}
+}
diff --git a/instruction_test.go b/instruction_test.go
index 5c72af5d9..cc1ddfabb 100644
--- a/instruction_test.go
+++ b/instruction_test.go
@@ -35,6 +35,8 @@ func TestInstructionFamiliesAreArchitectureAware(t *testing.T) {
 		{ArchAMD64, "POPCNTQ", "bit-shift"},
 		{ArchAMD64, "PREFETCHT0", "cache-memory"},
 		{ArchAMD64, "VGF2P8AFFINEQB", "crypto-carryless"},
+		{ArchAMD64, "PCALIGN", "directive"},
+		{ArchAMD64, "PCALIGNMAX", "directive"},
 		{ArchARM64, "VLD1", "neon"},
 		{ArchARM64, "ZADD", "sve"},
 		{ArchARM64, "CASAL", "atomic-memory"},
@@ -166,7 +168,6 @@ func TestDescribeInstructionClassifiesOperands(t *testing.T) {
 
 func TestProbeInstructionChecksFormsThroughLowerer(t *testing.T) {
 	cases := []Instr{
-		{Op: "XORB", Raw: "XORB SI, (AX)", Args: []Operand{{Kind: OpReg, Reg: SI}, {Kind: OpMem, Mem: MemRef{Base: AX}}}},
 		{Op: "PUNPCKLQDQ", Raw: "PUNPCKLQDQ X0, X0", Args: []Operand{{Kind: OpReg, Reg: "X0"}, {Kind: OpReg, Reg: "X0"}}},
 	}
 	for _, ins := range cases {
@@ -175,6 +176,24 @@ func TestProbeInstructionChecksFormsThroughLowerer(t *testing.T) {
 		}
 	}
 
+	// An isolated memory RMW has neither a reaching address nor source bytes.
+	// The same form must still lower when actual typed source supplies both.
+	rmw := Instr{Op: "XORB", Raw: "XORB SI, (AX)", Args: []Operand{
+		{Kind: OpReg, Reg: SI}, {Kind: OpMem, Mem: MemRef{Base: AX}},
+	}}
+	if err := ProbeInstruction(ArchAMD64, "amd64", rmw); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unbound memory RMW probe error = %v, want ErrProbeNeedsContext", err)
+	}
+	const source = "TEXT ·probe(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ value+8(FP),SI\nXORB SI,(AX)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func probe(p *byte,value uint64)",
+			"amd64", "x86_64-unknown-linux-gnu", api)
+		if err != nil || ir == "" {
+			t.Errorf("%s: initialized memory RMW failed: %v", api, err)
+		}
+	}
+
 	fp := Instr{Op: "MOVQ", Raw: "MOVQ x+0(FP), AX", Args: []Operand{{Kind: OpFP, FPName: "x"}, {Kind: OpReg, Reg: AX}}}
 	if err := ProbeInstruction(ArchAMD64, "amd64", fp); !errors.Is(err, ErrProbeNeedsContext) {
 		t.Fatalf("FP probe error = %v, want ErrProbeNeedsContext", err)
diff --git a/internal/asmsig/borrowed.go b/internal/asmsig/borrowed.go
new file mode 100644
index 000000000..75191aa9e
--- /dev/null
+++ b/internal/asmsig/borrowed.go
@@ -0,0 +1,106 @@
+package asmsig
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// ARM64BorrowedTailFrame recognizes a declared, argument-free assembly helper
+// that reads arguments from the stack frame of its tail-jumping callers. Go's
+// assembler permits this pattern even though the helper's Go declaration has
+// no arguments. The LLVM function needs explicit arguments because an LLVM
+// call does not preserve the caller's physical frame layout.
+//
+// Require each local entry transfer to place every consumed word in the
+// corresponding outgoing ABI0 slot immediately before the branch. Anything
+// more involved needs a control-flow-aware frame model and stays unsupported.
+func ARM64BorrowedTailFrame(
+	file *plan9asm.File,
+	target plan9asm.Func,
+	declared, inferred plan9asm.FuncSig,
+	resolve func(string) string,
+) (plan9asm.FuncSig, bool) {
+	if len(declared.Args) != 0 || declared.Ret != plan9asm.Void ||
+		len(declared.Frame.Params) != 0 || len(declared.Frame.Results) != 0 ||
+		len(inferred.Frame.Params) == 0 || len(inferred.Frame.Results) != 0 ||
+		len(inferred.Args) != len(inferred.Frame.Params) {
+		return declared, false
+	}
+	for i, slot := range inferred.Frame.Params {
+		if slot.Offset != int64(i*8) || slot.Type != plan9asm.I64 {
+			return declared, false
+		}
+	}
+
+	targetName := resolve(target.Sym)
+	entries := 0
+	for _, caller := range file.Funcs {
+		if resolve(caller.Sym) == targetName {
+			continue
+		}
+		for i, ins := range caller.Instrs {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+				continue
+			}
+			sym, ok := directEntrySymbol(ins.Args[0].Sym)
+			if !ok || resolve(sym) != targetName {
+				continue
+			}
+			if strings.ToUpper(string(ins.Op)) != "B" ||
+				!hasImmediateARM64ABI0Stores(caller.Instrs, i, inferred.Frame.Params) {
+				return declared, false
+			}
+			entries++
+		}
+	}
+	if entries == 0 {
+		return declared, false
+	}
+
+	declared.Args = inferred.Args
+	declared.Frame.Params = inferred.Frame.Params
+	return declared, true
+}
+
+func hasImmediateARM64ABI0Stores(instrs []plan9asm.Instr, branch int, params []plan9asm.FrameSlot) bool {
+	if branch < len(params) {
+		return false
+	}
+	written := make(map[int64]bool, len(params))
+	for _, ins := range instrs[branch-len(params) : branch] {
+		if strings.ToUpper(string(ins.Op)) != "MOVD" || len(ins.Args) != 2 ||
+			ins.Args[1].Kind != plan9asm.OpMem ||
+			(ins.Args[1].Mem.Base != plan9asm.SP && ins.Args[1].Mem.Base != "RSP") ||
+			ins.Args[1].Mem.Index != "" || ins.Args[1].Mem.Sym != "" ||
+			ins.Args[1].Mem.OffRaw != "" || ins.Args[1].Mem.Segment != "" {
+			return false
+		}
+		written[ins.Args[1].Mem.Off] = true
+	}
+	for _, slot := range params {
+		if !written[slot.Offset+8] {
+			return false
+		}
+	}
+	return len(written) == len(params)
+}
+
+func directEntrySymbol(raw string) (string, bool) {
+	sym := strings.TrimSpace(raw)
+	if !strings.HasSuffix(sym, "(SB)") {
+		return "", false
+	}
+	sym = strings.TrimSuffix(sym, "(SB)")
+	if i := strings.LastIndexAny(sym, "+-"); i > 0 {
+		offset, err := strconv.ParseInt(strings.TrimSpace(sym[i:]), 0, 64)
+		if err == nil {
+			if offset != 0 {
+				return "", false
+			}
+			sym = strings.TrimSpace(sym[:i])
+		}
+	}
+	return sym, sym != ""
+}
diff --git a/internal/asmsig/borrowed_test.go b/internal/asmsig/borrowed_test.go
new file mode 100644
index 000000000..ec1f073d6
--- /dev/null
+++ b/internal/asmsig/borrowed_test.go
@@ -0,0 +1,92 @@
+package asmsig
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestARM64BorrowedTailFrameRequiresCompleteImmediateStores(t *testing.T) {
+	for _, tc := range []struct {
+		name   string
+		caller string
+		want   bool
+	}{
+		{name: "one word", caller: "MOVD R3, 8(RSP)\nB helper(SB)", want: true},
+		{name: "zero offset target", caller: "MOVD R3, 8(RSP)\nB helper+0(SB)", want: true},
+		{name: "two words", caller: "MOVD R3, 16(RSP)\nMOVD R4, 8(RSP)\nB helper(SB)", want: true},
+		{name: "missing store", caller: "B helper(SB)"},
+		{name: "wrong slot", caller: "MOVD R3, 24(RSP)\nB helper(SB)"},
+		{name: "intervening instruction", caller: "MOVD R3, 8(RSP)\nADD $1, R3\nB helper(SB)"},
+		{name: "ordinary call", caller: "MOVD R3, 8(RSP)\nBL helper(SB)"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			params := []plan9asm.FrameSlot{{Offset: 0, Type: plan9asm.I64, Index: 0}}
+			args := []plan9asm.LLVMType{plan9asm.I64}
+			if tc.name == "two words" {
+				params = append(params, plan9asm.FrameSlot{Offset: 8, Type: plan9asm.I64, Index: 1})
+				args = append(args, plan9asm.I64)
+			}
+			file, err := plan9asm.Parse(plan9asm.ArchARM64,
+				"TEXT caller(SB),$0\n"+tc.caller+"\nTEXT helper(SB),$0\nMOVD vector+0(FP), R3\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			declared := plan9asm.FuncSig{Name: "helper", Ret: plan9asm.Void}
+			inferred := plan9asm.FuncSig{
+				Name: "helper", Args: args, Ret: plan9asm.Void,
+				Frame: plan9asm.FrameLayout{Params: params},
+			}
+			got, ok := ARM64BorrowedTailFrame(file, file.Funcs[1], declared, inferred, func(s string) string { return s })
+			if ok != tc.want {
+				t.Fatalf("borrowed tail frame accepted=%t, want %t", ok, tc.want)
+			}
+			if ok && (len(got.Args) != len(args) || len(got.Frame.Params) != len(params)) {
+				t.Fatalf("incomplete borrowed frame: %+v", got)
+			}
+		})
+	}
+}
+
+func TestARM64BorrowedTailFrameRejectsUnprovenSecondEntry(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM64, `TEXT first(SB),$0
+	MOVD R3, 8(RSP)
+	B helper(SB)
+TEXT second(SB),$0
+	B helper(SB)
+TEXT helper(SB),$0
+	MOVD vector+0(FP), R3
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declared := plan9asm.FuncSig{Name: "helper", Ret: plan9asm.Void}
+	inferred := plan9asm.FuncSig{
+		Name: "helper", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.Void,
+		Frame: plan9asm.FrameLayout{Params: []plan9asm.FrameSlot{{Type: plan9asm.I64}}},
+	}
+	if _, ok := ARM64BorrowedTailFrame(file, file.Funcs[2], declared, inferred, func(s string) string { return s }); ok {
+		t.Fatal("accepted a helper with an unproven second entry")
+	}
+}
+
+func TestARM64BorrowedTailFrameRejectsConflictingDeclarations(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM64,
+		"TEXT caller(SB),$0\nMOVD R3, 8(RSP)\nB helper(SB)\nTEXT helper(SB),$0\nMOVD vector+0(FP), R3\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	inferred := plan9asm.FuncSig{
+		Name: "helper", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.Void,
+		Frame: plan9asm.FrameLayout{Params: []plan9asm.FrameSlot{{Type: plan9asm.I64}}},
+	}
+	for _, declared := range []plan9asm.FuncSig{
+		{Name: "helper", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.Void},
+		{Name: "helper", Ret: plan9asm.I64},
+	} {
+		if _, ok := ARM64BorrowedTailFrame(file, file.Funcs[1], declared, inferred, func(s string) string { return s }); ok {
+			t.Fatalf("accepted conflicting Go declaration: %+v", declared)
+		}
+	}
+}
diff --git a/internal/asmsig/forward.go b/internal/asmsig/forward.go
new file mode 100644
index 000000000..acce5dba2
--- /dev/null
+++ b/internal/asmsig/forward.go
@@ -0,0 +1,89 @@
+// Package asmsig contains signature inference shared by the command drivers.
+package asmsig
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// RefineTailForwarders gives declaration-free, pure tail stubs the ABI of
+// their destination. known protects signatures established by declarations or
+// other reliable ABI evidence. Explicit FP slots also provide usable evidence
+// when build tags hide the Go declarations but keep the assembly selected.
+// Existing signatures with no such evidence are not invented or discarded.
+func RefineTailForwarders(file *plan9asm.File, sigs map[string]plan9asm.FuncSig, resolve func(string) string, known map[string]bool) {
+	evidence := make(map[string]bool, len(known))
+	for name, value := range known {
+		evidence[name] = value
+	}
+	// Iteration resolves chains independent of source order. Cycles without
+	// any frame/declaration evidence remain unresolved.
+	for pass := 0; pass < len(file.Funcs); pass++ {
+		changed := false
+		for _, fn := range file.Funcs {
+			caller := resolve(fn.Sym)
+			if known[caller] {
+				continue
+			}
+			symbol, pure := pureTailTarget(fn)
+			if !pure {
+				continue
+			}
+			targetName := resolve(symbol)
+			target, ok := sigs[targetName]
+			if !ok || (!evidence[targetName] && len(target.Frame.Params) == 0 && len(target.Frame.Results) == 0) {
+				continue
+			}
+			target.Name = caller
+			// A pure tail-forwarder's value signature is not a real Go
+			// declaration plus source-selector proof for its register entry.
+			target.ARM64GoRegisterABI = nil
+			if !reflect.DeepEqual(sigs[caller], target) || !evidence[caller] {
+				sigs[caller] = target
+				evidence[caller] = true
+				changed = true
+			}
+		}
+		if !changed {
+			break
+		}
+	}
+}
+
+func pureTailTarget(fn plan9asm.Func) (string, bool) {
+	target := ""
+	for _, ins := range fn.Instrs {
+		op := strings.ToUpper(string(ins.Op))
+		switch op {
+		case "TEXT", "PCDATA", "FUNCDATA":
+			continue
+		case "RET":
+			if target != "" && len(ins.Args) == 0 {
+				continue // Unreachable after the unconditional tail transfer.
+			}
+		case "JMP", "B":
+		default:
+			return "", false
+		}
+		if target != "" || len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+			return "", false
+		}
+		sym := strings.TrimSpace(ins.Args[0].Sym)
+		if !strings.HasSuffix(sym, "(SB)") {
+			return "", false
+		}
+		target = strings.TrimSuffix(sym, "(SB)")
+		if i := strings.LastIndexAny(target, "+-"); i > 0 {
+			if offset, err := strconv.ParseInt(strings.TrimSpace(target[i:]), 0, 64); err == nil {
+				if offset != 0 {
+					return "", false
+				}
+				target = strings.TrimSpace(target[:i])
+			}
+		}
+	}
+	return target, target != ""
+}
diff --git a/internal/asmsig/forward_test.go b/internal/asmsig/forward_test.go
new file mode 100644
index 000000000..47f273321
--- /dev/null
+++ b/internal/asmsig/forward_test.go
@@ -0,0 +1,84 @@
+package asmsig
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestRefineTailForwarderDoesNotInventGoRegisterDeclaration(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchARM64, "TEXT wrapper<ABIInternal>(SB),$0\nB target(SB)\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	contract := &plan9asm.ARM64GoRegisterABI{
+		Params: []plan9asm.ARM64GoRegisterValue{{Index: 0, Type: plan9asm.I64, Register: "R0"}},
+	}
+	sigs := map[string]plan9asm.FuncSig{
+		"wrapper": {Name: "wrapper", Ret: plan9asm.Void},
+		"target":  {Name: "target", Args: []plan9asm.LLVMType{plan9asm.I64}, Ret: plan9asm.Void, ARM64GoRegisterABI: contract},
+	}
+	resolve := func(s string) string { return strings.TrimSuffix(s, "<ABIInternal>") }
+	RefineTailForwarders(file, sigs, resolve, map[string]bool{"target": true})
+	if sigs["wrapper"].ARM64GoRegisterABI != nil {
+		t.Fatal("a copied tail signature invented a declaration-backed register entry")
+	}
+}
+
+func TestRefineTailForwardersEvidenceAndPurity(t *testing.T) {
+	for _, tc := range []struct {
+		name, body                            string
+		knownCaller, knownTarget, frame, want bool
+	}{
+		{name: "frame", body: "JMP target(SB)", frame: true, want: true},
+		{name: "declaration", body: "JMP target(SB)", knownTarget: true, want: true},
+		{name: "zero_offset", body: "JMP target+0(SB)", frame: true, want: true},
+		{name: "ret_symbol", body: "RET target(SB)", frame: true, want: true},
+		{name: "dead_ret", body: "JMP target(SB)\nRET", frame: true, want: true},
+		{name: "unknown", body: "JMP target(SB)"},
+		{name: "protected", body: "JMP target(SB)", knownCaller: true, frame: true},
+		{name: "writes_register", body: "MOVQ $1, AX\nJMP target(SB)", frame: true},
+		{name: "call", body: "CALL target(SB)\nRET", frame: true},
+		{name: "offset", body: "JMP target+8(SB)", frame: true},
+		{name: "indirect", body: "JMP AX", frame: true},
+		{name: "conditional", body: "JEQ target(SB)", frame: true},
+		{name: "multiple", body: "JMP target(SB)\nJMP other(SB)", frame: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT caller(SB),$0\n"+tc.body+"\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			caller := plan9asm.FuncSig{Name: "caller", Ret: plan9asm.I64}
+			target := plan9asm.FuncSig{Name: "target", Ret: plan9asm.Void}
+			if tc.frame {
+				target.Args = []plan9asm.LLVMType{plan9asm.Ptr}
+				target.Frame.Params = []plan9asm.FrameSlot{{Type: plan9asm.Ptr, Field: -1}}
+			}
+			sigs := map[string]plan9asm.FuncSig{"caller": caller, "target": target}
+			RefineTailForwarders(file, sigs, func(s string) string { return s }, map[string]bool{"caller": tc.knownCaller, "target": tc.knownTarget})
+			want := caller
+			if tc.want {
+				want = target
+				want.Name = "caller"
+			}
+			if !reflect.DeepEqual(sigs["caller"], want) {
+				t.Fatalf("got %#v, want %#v", sigs["caller"], want)
+			}
+		})
+	}
+}
+
+func TestRefineTailForwardersUnprovenCycle(t *testing.T) {
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, "TEXT a(SB),$0\nJMP b(SB)\nTEXT b(SB),$0\nJMP a(SB)\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]plan9asm.FuncSig{"a": {Name: "a", Ret: plan9asm.I64}, "b": {Name: "b", Ret: plan9asm.I32}}
+	RefineTailForwarders(file, sigs, func(s string) string { return s }, nil)
+	if sigs["a"].Ret != plan9asm.I64 || sigs["b"].Ret != plan9asm.I32 {
+		t.Fatal("unproven cycle changed signatures")
+	}
+}
diff --git a/internal/goabi/stack.go b/internal/goabi/stack.go
new file mode 100644
index 000000000..b8cebe54c
--- /dev/null
+++ b/internal/goabi/stack.go
@@ -0,0 +1,35 @@
+// Package goabi describes the source Go stack layout, independently of the
+// LLVM target's pointer width or the host running the translator.
+package goabi
+
+import "math"
+
+// ABI0StackSize includes the trailing register-size alignment added by
+// cmd/compile/internal/abi.ABIAnalyzeFuncType. dataSize is the end of the last
+// declared parameter/result, which asmdecl reports without that alignment.
+// Padding is allocation metadata, not a new parameter or result field.
+func ABI0StackSize(goarch string, dataSize int64) (int64, bool) {
+	var alignment int64
+	switch goarch {
+	case "386", "arm":
+		alignment = 4
+	case "amd64", "arm64", "wasm":
+		// Go's wasm register/stack word is eight bytes even though the LLVM
+		// wasm32 address space uses four-byte pointers.
+		alignment = 8
+	default:
+		return 0, false
+	}
+	if dataSize < 0 || dataSize > math.MaxInt64-(alignment-1) {
+		return 0, false
+	}
+	return (dataSize + alignment - 1) &^ (alignment - 1), true
+}
+
+// MatchesABI0TextSize accepts the logical data end or the actual aligned ABI0
+// allocation, never arbitrary extra bytes. Legacy omitted/zero TEXT metadata
+// is a separate convention handled by callers.
+func MatchesABI0TextSize(goarch string, declared, dataSize int64) bool {
+	padded, ok := ABI0StackSize(goarch, dataSize)
+	return ok && (declared == dataSize || declared == padded)
+}
diff --git a/internal/goabi/stack_test.go b/internal/goabi/stack_test.go
new file mode 100644
index 000000000..02ce4156d
--- /dev/null
+++ b/internal/goabi/stack_test.go
@@ -0,0 +1,36 @@
+package goabi
+
+import (
+	"math"
+	"testing"
+)
+
+func TestABI0StackSize(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		word := int64(8)
+		if arch == "386" || arch == "arm" {
+			word = 4
+		}
+		for _, size := range []int64{0, 1, 4, 8, 12, 17, 28, math.MaxInt64 - 7} {
+			want := (size + word - 1) &^ (word - 1)
+			got, ok := ABI0StackSize(arch, size)
+			if !ok || got != want {
+				t.Fatalf("%s logical=%d: aligned=%d, valid=%t, want %d", arch, size, got, ok, want)
+			}
+			if !MatchesABI0TextSize(arch, size, size) || !MatchesABI0TextSize(arch, want, size) {
+				t.Fatalf("%s rejected logical/aligned metadata for %d", arch, size)
+			}
+			if MatchesABI0TextSize(arch, want+1, size) || MatchesABI0TextSize(arch, want+word, size) {
+				t.Fatalf("%s accepted arbitrary excess metadata for %d", arch, size)
+			}
+		}
+		for _, bad := range []int64{-1, math.MinInt64, math.MaxInt64} {
+			if _, ok := ABI0StackSize(arch, bad); ok || MatchesABI0TextSize(arch, bad, bad) {
+				t.Fatalf("%s accepted invalid/overflowing data size %d", arch, bad)
+			}
+		}
+	}
+	if _, ok := ABI0StackSize("unknown", 12); ok || MatchesABI0TextSize("unknown", 16, 12) {
+		t.Fatal("invented a stack alignment for an unknown architecture")
+	}
+}
diff --git a/internal/goasmcmd/command.go b/internal/goasmcmd/command.go
new file mode 100644
index 000000000..78b72cec8
--- /dev/null
+++ b/internal/goasmcmd/command.go
@@ -0,0 +1,90 @@
+// Package goasmcmd owns bounded, machine-readable stock-Go commands. It has no
+// dependency on the translator or its proof protocols.
+package goasmcmd
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os/exec"
+	"time"
+)
+
+type output struct {
+	buffer   bytes.Buffer
+	overflow bool
+}
+
+func (out *output) Len() int      { return out.buffer.Len() }
+func (out *output) Bytes() []byte { return out.buffer.Bytes() }
+
+func (out *output) Write(data []byte) (int, error) {
+	n := len(data)
+	if remaining := 4<<20 - out.Len(); n > remaining {
+		out.overflow = true
+		data = data[:remaining]
+	}
+	_, _ = out.buffer.Write(data)
+	return n, nil
+}
+
+// Observation retains the actual child outcome even when an independent
+// cancellation, pipe or descendant-cleanup failure is joined to its exit.
+// PGID identifies the owned group; it is not a claim that the group is gone.
+type Observation struct {
+	Stdout, Stderr []byte
+	PID, PGID      int
+	Waited         bool
+	ExitCode       int
+}
+
+// Observe keeps the streams distinct and returns the unwrapped command cause.
+// Unix implementations additionally terminate the fresh child's process group.
+func Observe(ctx context.Context, dir string, env []string, name string, args ...string) (Observation, error) {
+	observed := Observation{ExitCode: -1}
+	if ctx == nil {
+		return observed, fmt.Errorf("Go object command requires a live context")
+	}
+	if cause := ctx.Err(); cause != nil {
+		return observed, errors.Join(fmt.Errorf("Go object command requires a live context"), cause)
+	}
+	command := exec.CommandContext(ctx, name, args...)
+	command.Dir, command.Env, command.WaitDelay = dir, env, 2*time.Second
+	var stdout, stderr output
+	command.Stdout, command.Stderr = &stdout, &stderr
+	err := run(command)
+	if command.Process != nil {
+		observed.PID = command.Process.Pid
+		observed.PGID = configuredGroup(command)
+	}
+	if command.ProcessState != nil {
+		observed.Waited = true
+		observed.ExitCode = command.ProcessState.ExitCode()
+	}
+	if ctx.Err() != nil {
+		err = errors.Join(err, ctx.Err())
+	}
+	if stdout.overflow || stderr.overflow {
+		err = errors.Join(err, fmt.Errorf("Go object command output bound exceeded"))
+	}
+	observed.Stdout = append([]byte(nil), stdout.Bytes()...)
+	observed.Stderr = append([]byte(nil), stderr.Bytes()...)
+	return observed, err
+}
+
+// Run preserves the existing query contract: diagnostics are errors, and
+// callers receive stdout only after the complete owned command succeeds.
+func Run(ctx context.Context, dir string, env []string, name string, args ...string) ([]byte, error) {
+	if ctx == nil || ctx.Err() != nil {
+		return nil, fmt.Errorf("Go object command requires a live context")
+	}
+	observed, err := Observe(ctx, dir, env, name, args...)
+	if len(observed.Stderr) != 0 {
+		err = errors.Join(err, fmt.Errorf("Go object command diagnostics: %s", observed.Stderr))
+	}
+	if err != nil {
+		return nil, fmt.Errorf("actual Go %v: %w", args, err)
+	}
+	return observed.Stdout, nil
+}
diff --git a/internal/goasmcmd/command_other.go b/internal/goasmcmd/command_other.go
new file mode 100644
index 000000000..5621e4765
--- /dev/null
+++ b/internal/goasmcmd/command_other.go
@@ -0,0 +1,9 @@
+//go:build !unix
+
+package goasmcmd
+
+import "os/exec"
+
+func run(command *exec.Cmd) error { return command.Run() }
+
+func configuredGroup(command *exec.Cmd) int { return 0 }
diff --git a/internal/goasmcmd/command_test.go b/internal/goasmcmd/command_test.go
new file mode 100644
index 000000000..ace9e844b
--- /dev/null
+++ b/internal/goasmcmd/command_test.go
@@ -0,0 +1,155 @@
+package goasmcmd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestActualGoCommandBoundsAndMachineStdout(t *testing.T) {
+	for _, mode := range []string{"json", "stderr", "exit", "stdout overflow", "stderr overflow", "cancel"} {
+		t.Run(mode, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			if mode == "cancel" {
+				ctx, cancel = context.WithTimeout(context.Background(), 100*time.Millisecond)
+				defer cancel()
+			}
+			env := append(os.Environ(), "GOASM_COMMAND_FIXTURE="+mode)
+			data, err := Run(ctx, t.TempDir(), env, os.Args[0], "-test.run=^TestActualGoCommandFixture$")
+			if mode == "json" {
+				if err != nil || string(data) != `{"actual":true}` {
+					t.Fatalf("machine stdout changed: %q %v", data, err)
+				}
+				return
+			}
+			if err == nil || data != nil {
+				t.Fatalf("command %s falsely succeeded: %q %v", mode, data, err)
+			}
+			if mode == "cancel" && !errors.Is(err, context.DeadlineExceeded) {
+				t.Fatalf("cancellation lost deadline evidence: %v", err)
+			}
+			if mode == "stderr" && !strings.Contains(err.Error(), "download diagnostic") {
+				t.Fatalf("stderr was swallowed: %v", err)
+			}
+			if strings.HasSuffix(mode, "overflow") && !strings.Contains(err.Error(), "output bound exceeded") {
+				t.Fatalf("overflow was swallowed: %v", err)
+			}
+		})
+	}
+}
+
+func TestActualObservationRetainsExitAndSeparateStreams(t *testing.T) {
+	for _, mode := range []string{"json", "stderr", "exit", "cancel"} {
+		t.Run(mode, func(t *testing.T) {
+			budget := 5 * time.Second
+			if mode == "cancel" {
+				budget = 100 * time.Millisecond
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), budget)
+			defer cancel()
+			value, err := Observe(ctx, t.TempDir(), append(os.Environ(), "GOASM_COMMAND_FIXTURE="+mode),
+				os.Args[0], "-test.run=^TestActualGoCommandFixture$")
+			encoded, _ := json.Marshal(value)
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !value.Waited || value.PID <= 1 {
+				t.Fatalf("actual child not waited: %+v", value)
+			}
+			if mode == "cancel" {
+				killedExit := -1
+				if runtime.GOOS == "windows" {
+					// os.Process.Kill uses TerminateProcess(handle, 1), not a
+					// Unix signal. Preserve the exact observed exit and cause.
+					killedExit = 1
+				}
+				if !errors.Is(err, context.DeadlineExceeded) || value.ExitCode != killedExit {
+					t.Fatalf("deadline/killed exit lost: %+v %v", value, err)
+				}
+				return
+			}
+			if mode == "exit" {
+				if err == nil || value.ExitCode != 7 {
+					t.Fatalf("actual exit lost: %+v %v", value, err)
+				}
+				return
+			}
+			if err != nil || value.ExitCode != 0 || string(value.Stdout) != `{"actual":true}` {
+				t.Fatalf("stdout changed: %+v %v", value, err)
+			}
+			if mode == "stderr" && string(value.Stderr) != "download diagnostic" {
+				t.Fatalf("stderr not separate: %+v", value)
+			}
+		})
+	}
+}
+
+func TestActualGoCommandFixture(t *testing.T) {
+	switch os.Getenv("GOASM_COMMAND_FIXTURE") {
+	case "json":
+		_, _ = os.Stdout.WriteString(`{"actual":true}`)
+	case "stderr":
+		_, _ = os.Stdout.WriteString(`{"actual":true}`)
+		_, _ = os.Stderr.WriteString("download diagnostic")
+	case "stdout overflow":
+		_, _ = os.Stdout.Write(bytes.Repeat([]byte("x"), 4<<20+1))
+	case "stderr overflow":
+		_, _ = os.Stderr.Write(bytes.Repeat([]byte("x"), 4<<20+1))
+	case "exit":
+		os.Exit(7)
+	case "signal":
+		self, err := os.FindProcess(os.Getpid())
+		if err != nil {
+			os.Exit(2)
+		}
+		if err := self.Kill(); err != nil {
+			os.Exit(2)
+		}
+	case "cancel":
+		time.Sleep(time.Minute)
+	default:
+		return
+	}
+	os.Exit(0)
+}
+
+func TestActualObservationSignalAndMissingToolFail(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	observed, err := Observe(ctx, t.TempDir(), append(os.Environ(), "GOASM_COMMAND_FIXTURE=signal"),
+		os.Args[0], "-test.run=^TestActualGoCommandFixture$")
+	encoded, _ := json.Marshal(observed)
+	t.Logf("ORACLE_CHILD %s", encoded)
+	if err == nil || !observed.Waited || observed.PID <= 1 || observed.ExitCode == 0 {
+		t.Fatalf("real killed child falsely succeeded: %+v %v", observed, err)
+	}
+	missing, err := Observe(ctx, t.TempDir(), nil, filepath.Join(t.TempDir(), "missing-go"))
+	if err == nil || missing.Waited || missing.PID != 0 || missing.ExitCode != -1 {
+		t.Fatalf("missing tool falsely succeeded: %+v %v", missing, err)
+	}
+}
+
+func TestActualGoCommandRequiresLiveContext(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	for _, input := range []context.Context{nil, ctx} {
+		if _, err := Run(input, t.TempDir(), nil, "not-started"); err == nil {
+			t.Fatal("inactive context started a command")
+		}
+	}
+}
+
+func TestObservationEarlyCancellationRetainsCause(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	value, err := Observe(ctx, t.TempDir(), nil, "must-not-start")
+	if !errors.Is(err, context.Canceled) || value.ExitCode != -1 || value.PID != 0 || value.Waited {
+		t.Fatalf("early cancellation lost actual cause/no-child outcome: %+v %v", value, err)
+	}
+}
diff --git a/internal/goasmcmd/command_unix.go b/internal/goasmcmd/command_unix.go
new file mode 100644
index 000000000..e25317ca7
--- /dev/null
+++ b/internal/goasmcmd/command_unix.go
@@ -0,0 +1,17 @@
+//go:build unix
+
+package goasmcmd
+
+import (
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+	"os/exec"
+)
+
+func run(command *exec.Cmd) error { return ownedprocess.Run(command) }
+
+func configuredGroup(command *exec.Cmd) int {
+	if command.Process != nil && command.SysProcAttr != nil && command.SysProcAttr.Setpgid {
+		return command.Process.Pid
+	}
+	return 0
+}
diff --git a/internal/goasmheader/header.go b/internal/goasmheader/header.go
new file mode 100644
index 000000000..63cc98f23
--- /dev/null
+++ b/internal/goasmheader/header.go
@@ -0,0 +1,126 @@
+// Package goasmheader provides pure bounded header syntax. Definitions, JSON
+// and digests authenticate no SDK, compiler, package or memory capability.
+package goasmheader
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/token"
+	"reflect"
+	"sort"
+	"strings"
+	"unicode"
+)
+
+// ByteLimit preserves the existing full-definition textual contract.
+const ByteLimit = 64 << 20
+
+func Definitions(header []byte) (map[string]string, error) {
+	if len(header) > ByteLimit {
+		return nil, fmt.Errorf("generated header exceeds its bounded textual contract")
+	}
+	text := string(header)
+	if strings.ContainsRune(text, '\x00') {
+		return nil, fmt.Errorf("generated header exceeds its bounded textual contract")
+	}
+	definitions := make(map[string]string)
+	canonicalBytes := 0
+	for text != "" {
+		var line string
+		line, text, _ = strings.Cut(text, "\n")
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "//") {
+			continue
+		}
+		directive, remainder := generatedHeaderToken(line)
+		name, value := generatedHeaderToken(remainder)
+		if directive != "#define" || !token.IsIdentifier(name) {
+			return nil, fmt.Errorf("unrecognized generated header definition: %s", line)
+		}
+		if _, exists := definitions[name]; exists {
+			return nil, fmt.Errorf("duplicate generated header definition: %s", name)
+		}
+		size, err := DefinitionSize(name, value)
+		if err != nil || size > ByteLimit-canonicalBytes {
+			return nil, fmt.Errorf("invalid or unbounded generated header definition: %s", name)
+		}
+		canonicalBytes += size
+		definitions[name] = value
+	}
+	return definitions, nil
+}
+
+func generatedHeaderToken(text string) (string, string) {
+	index := strings.IndexFunc(text, unicode.IsSpace)
+	if index < 0 {
+		return text, ""
+	}
+	return text[:index], strings.TrimSpace(text[index:])
+}
+
+func DefinitionSize(name, value string) (int, error) {
+	// Check lengths before scanning values or allocating canonical output. Both
+	// component bounds also keep this addition safe on the supported 32-bit Go.
+	if len(name) > ByteLimit || len(value) > ByteLimit {
+		return 0, fmt.Errorf("unbounded generated header definition")
+	}
+	size := len("#define ") + len(name) + 1 + len(value) + 1
+	if size > ByteLimit {
+		return 0, fmt.Errorf("unbounded generated header definition")
+	}
+	if !token.IsIdentifier(name) || value == "" || strings.TrimSpace(value) != value ||
+		strings.ContainsAny(value, "\r\n\x00") || strings.HasSuffix(value, "\\") {
+		return 0, fmt.Errorf("noncanonical generated header definition")
+	}
+	return size, nil
+}
+
+func DefinitionsSize(definitions map[string]string) (int, error) {
+	if definitions == nil {
+		return 0, fmt.Errorf("missing generated header definitions")
+	}
+	total := 0
+	for name, value := range definitions {
+		size, err := DefinitionSize(name, value)
+		if err != nil {
+			return 0, err
+		}
+		if size > ByteLimit-total {
+			return 0, fmt.Errorf("generated header exceeds its canonical byte bound")
+		}
+		total += size
+	}
+	return total, nil
+}
+
+func SHA256(definitions map[string]string) string {
+	if len(definitions) == 0 {
+		definitions = map[string]string{}
+	}
+	data, _ := json.Marshal(definitions)
+	return fmt.Sprintf("%x", sha256.Sum256(data))
+}
+
+func Canonical(definitions map[string]string) ([]byte, error) {
+	size, err := DefinitionsSize(definitions)
+	if err != nil {
+		return nil, err
+	}
+	names := make([]string, 0, len(definitions))
+	for name := range definitions {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	var text strings.Builder
+	text.Grow(size)
+	for _, name := range names {
+		fmt.Fprintf(&text, "#define %s %s\n", name, definitions[name])
+	}
+	data := []byte(text.String())
+	parsed, err := Definitions(data)
+	if err != nil || !reflect.DeepEqual(parsed, definitions) {
+		return nil, fmt.Errorf("generated definitions cannot form an exact canonical header: %v", err)
+	}
+	return data, nil
+}
diff --git a/internal/goasmmacros/source.go b/internal/goasmmacros/source.go
new file mode 100644
index 000000000..c8a8b4ff4
--- /dev/null
+++ b/internal/goasmmacros/source.go
@@ -0,0 +1,266 @@
+// Package goasmmacros verifies the actual stock-Go assembler macro registrations.
+// Source rules describe ordinary/profile macro origins, never memory authority.
+package goasmmacros
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/scanner"
+	"go/token"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+type SourceRules struct {
+	GoVersion, PackageRole string
+	ToolSourceSHA256       map[string]string
+	RegistrationSHA256     map[string]string
+}
+
+// Capture uses the caller's input observer, retaining complete original source
+// hashes as well as independently registered normalized ASTs. A later source
+// mutation must be handled by that observer; this result is not a live token.
+func Capture(root, goVersion, packagePath string, read func(string) ([]byte, error)) (*SourceRules, error) {
+	if !filepath.IsAbs(root) || read == nil || packagePath == "" || path.Clean(packagePath) != packagePath ||
+		packagePath == "." || packagePath == ".." || strings.HasPrefix(packagePath, "../") ||
+		strings.HasPrefix(packagePath, "/") || strings.ContainsAny(packagePath, "@ \\\t\r\n\"'") {
+		return nil, fmt.Errorf("invalid actual assembler source root, reader or package path")
+	}
+	minor, err := GoMinor(goVersion)
+	if err != nil || minor < 20 || minor > 27 {
+		return nil, fmt.Errorf("assembler registration is not audited for %s", goVersion)
+	}
+	proof := &SourceRules{
+		GoVersion: goVersion, PackageRole: "ordinary_path",
+		ToolSourceSHA256:   make(map[string]string),
+		RegistrationSHA256: make(map[string]string),
+	}
+	version, err := read(filepath.Join(root, "VERSION"))
+	if err != nil || strings.TrimSpace(strings.Split(string(version), "\n")[0]) != goVersion {
+		return nil, fmt.Errorf("assembler source VERSION differs from actual driver")
+	}
+	proof.ToolSourceSHA256["VERSION"] = bytesSHA256(version)
+	readSource := func(name, pkg string) (*ast.File, *token.FileSet, error) {
+		data, err := read(filepath.Join(root, filepath.FromSlash(name)))
+		if err != nil {
+			return nil, nil, err
+		}
+		fset := token.NewFileSet()
+		file, err := parser.ParseFile(fset, name, data, 0)
+		if err != nil || file.Name.Name != pkg {
+			return nil, nil, fmt.Errorf("invalid assembler registration source %s", name)
+		}
+		proof.ToolSourceSHA256[name] = bytesSHA256(data)
+		return file, fset, nil
+	}
+	gc, gcSet, err := readSource("src/cmd/go/internal/work/gc.go", "work")
+	if err != nil {
+		return nil, err
+	}
+	args, err := SourceFunction(gc, "asmArgs")
+	if err != nil {
+		return nil, err
+	}
+	fingerprint, err := ASTSHA(gcSet, args)
+	if err != nil || fingerprint != argsFingerprints[minor] {
+		return nil, fmt.Errorf("unrecognized Go 1.%d cmd/go asmArgs registration", minor)
+	}
+	proof.RegistrationSHA256["asmArgs"] = fingerprint
+	asm, asmSet, err := readSource("src/cmd/asm/main.go", "main")
+	if err != nil {
+		return nil, err
+	}
+	main, err := SourceFunction(asm, "main")
+	if err != nil {
+		return nil, err
+	}
+	// Find every registration literal, not merely a guessed function name.
+	// A new registration elsewhere or a changed condition must fail closed.
+	literalCount := 0
+	ast.Inspect(asm, func(node ast.Node) bool {
+		literal, ok := node.(*ast.BasicLit)
+		if ok && literal.Kind == token.STRING {
+			value, _ := strconv.Unquote(literal.Value)
+			if strings.HasPrefix(value, "GOEXPERIMENT_") {
+				literalCount++
+			}
+		}
+		return true
+	})
+	var blocks []ast.Stmt
+	for _, statement := range main.Body.List {
+		var formatted bytes.Buffer
+		if err := format.Node(&formatted, asmSet, statement); err != nil {
+			return nil, err
+		}
+		if strings.Contains(formatted.String(), "GOEXPERIMENT_") {
+			blocks = append(blocks, statement)
+		}
+	}
+	if minor < 22 {
+		if literalCount != 0 || len(blocks) != 0 {
+			return nil, fmt.Errorf("unexpected pre-Go1.22 experiment macro registration")
+		}
+		proof.RegistrationSHA256["experiment_registration_absent"] = bytesSHA256(nil)
+		proof.PackageRole = "legacy_no_experiment_macros"
+		return proof, nil
+	}
+	if literalCount != 1 || len(blocks) != 1 {
+		return nil, fmt.Errorf("missing or additional experiment macro registrations")
+	}
+	fingerprint, err = ASTSHA(asmSet, blocks[0])
+	if err != nil || fingerprint != "32995e3cdb0c0ab1499abc494906e85ec47b639f2ebeac6b4c049d6d676a8b0f" {
+		return nil, fmt.Errorf("unrecognized package-role experiment macro registration")
+	}
+	proof.RegistrationSHA256["experiment_registration"] = fingerprint
+	special, specialSet, err := readSource("src/cmd/internal/objabi/pkgspecial.go", "objabi")
+	if err != nil {
+		return nil, err
+	}
+	fingerprint, err = ASTSHA(specialSet, special)
+	if err != nil || fingerprint != specialFingerprints[minor] {
+		return nil, fmt.Errorf("unrecognized Go 1.%d package-special registration", minor)
+	}
+	proof.RegistrationSHA256["package_special_registration"] = fingerprint
+	paths, err := allowedPackagePaths(special)
+	if err != nil {
+		return nil, err
+	}
+	if paths[packagePath] {
+		proof.PackageRole = "allow_asm_abi_path"
+	}
+	return proof, nil
+}
+
+func SourceFunction(file *ast.File, name string) (*ast.FuncDecl, error) {
+	var found *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == name {
+			if found != nil || function.Body == nil || function.Recv != nil {
+				return nil, fmt.Errorf("invalid assembler registration function %s", name)
+			}
+			found = function
+		}
+	}
+	if found == nil {
+		return nil, fmt.Errorf("missing assembler registration function %s", name)
+	}
+	return found, nil
+}
+
+func ASTSHA(fset *token.FileSet, node ast.Node) (string, error) {
+	var formatted bytes.Buffer
+	if err := format.Node(&formatted, fset, node); err != nil {
+		return "", err
+	}
+	var scan scanner.Scanner
+	scan.Init(token.NewFileSet().AddFile("registration", -1, formatted.Len()), formatted.Bytes(), nil, 0)
+	var canonical bytes.Buffer
+	for {
+		_, tok, literal := scan.Scan()
+		if tok == token.EOF {
+			break
+		}
+		fmt.Fprintf(&canonical, "%s\x00%s\x00", tok, literal)
+	}
+	return bytesSHA256(canonical.Bytes()), nil
+}
+
+func allowedPackagePaths(file *ast.File) (map[string]bool, error) {
+	paths := make(map[string]bool)
+	registrations := 0
+	for _, declaration := range file.Decls {
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok || general.Tok != token.VAR {
+			continue
+		}
+		for _, spec := range general.Specs {
+			value := spec.(*ast.ValueSpec)
+			if len(value.Names) == 0 || value.Names[0].Name != "allowAsmABIPkgs" {
+				continue
+			}
+			registrations++
+			if len(value.Names) != 1 || len(value.Values) != 1 {
+				return nil, fmt.Errorf("unrecognized package-special path registration")
+			}
+			list, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok {
+				return nil, fmt.Errorf("nonliteral package-special path registration")
+			}
+			for _, element := range list.Elts {
+				literal, ok := element.(*ast.BasicLit)
+				if !ok || literal.Kind != token.STRING {
+					return nil, fmt.Errorf("nonliteral package-special path")
+				}
+				pkg, err := strconv.Unquote(literal.Value)
+				if err != nil || pkg == "" || paths[pkg] {
+					return nil, fmt.Errorf("invalid or duplicate package-special path")
+				}
+				paths[pkg] = true
+			}
+		}
+	}
+	if registrations != 1 || len(paths) == 0 {
+		return nil, fmt.Errorf("incomplete package-special path inventory")
+	}
+	return paths, nil
+}
+
+// Complete normalized registration ASTs from the eight already audited actual
+// Go sources. These are source grammar guards, not lowerer coverage baselines.
+var argsFingerprints = map[int]string{
+	20: "bf67bdbe3e3c20c355bf387525aa895bee95ba89937c0d2c3ff97aa3c39676b9",
+	21: "bf67bdbe3e3c20c355bf387525aa895bee95ba89937c0d2c3ff97aa3c39676b9",
+	22: "bfb3ca150175f463b517ae6b7d0b6a5a3399844258429f9e4a70e5d3544313e5",
+	23: "2a986d99ca5b98d9e6d2b1bc904b03c8f5776192010cfe5a0422875c959851c2",
+	24: "2a986d99ca5b98d9e6d2b1bc904b03c8f5776192010cfe5a0422875c959851c2",
+	25: "2a986d99ca5b98d9e6d2b1bc904b03c8f5776192010cfe5a0422875c959851c2",
+	26: "2a986d99ca5b98d9e6d2b1bc904b03c8f5776192010cfe5a0422875c959851c2",
+	27: "4586887594337565ace2e18002673943804b443b3f70391842e933f3af557c8d",
+}
+
+var specialFingerprints = map[int]string{
+	22: "c49dc93a7426aa8657d56ea5e6aebd86d4798b3d27c7b27ee04422784f709198",
+	23: "fb45940df217866cbba98f749855c2ea93fd95e7f4b8c5c0e284841e762b3078",
+	24: "1aa641469c37d6ad633e20cf6750eac1f4809aad749a5e60e6ec0304a0f131b0",
+	25: "e2bb3c22dee594fc9278db7fe3c4eadd28c7f005bacba42bdb81cd52eb5babcc",
+	26: "4a67f46838d103efc652cea4670309c68eff5f07332fbb17df5f6fe3aa4161a9",
+	27: "488cab6435fd67db5c35939190ad5e3be6ea7a4cdd2b3e3a24c6993cea466c0f",
+}
+
+func GoMinor(version string) (int, error) {
+	if !strings.HasPrefix(version, "go1.") {
+		return 0, fmt.Errorf("invalid ordinary Go selection version")
+	}
+	parts := strings.Split(strings.TrimPrefix(version, "go1."), ".")
+	if len(parts) > 2 || len(parts) == 0 {
+		return 0, fmt.Errorf("invalid ordinary Go selection version")
+	}
+	for _, part := range parts {
+		if part == "" {
+			return 0, fmt.Errorf("invalid ordinary Go selection version")
+		}
+		for _, char := range part {
+			if char < '0' || char > '9' {
+				return 0, fmt.Errorf("invalid ordinary Go selection version")
+			}
+		}
+	}
+	minor, err := strconv.Atoi(parts[0])
+	if err != nil || minor < 1 || minor > 100 {
+		return 0, fmt.Errorf("invalid ordinary Go selection version")
+	}
+	return minor, nil
+}
+
+func bytesSHA256(data []byte) string { return fmt.Sprintf("%x", sha256.Sum256(data)) }
+
+func ArgsFingerprint(minor int) string    { return argsFingerprints[minor] }
+func SpecialFingerprint(minor int) string { return specialFingerprints[minor] }
diff --git a/internal/goasmmacros/source_test.go b/internal/goasmmacros/source_test.go
new file mode 100644
index 000000000..a2e88edeb
--- /dev/null
+++ b/internal/goasmmacros/source_test.go
@@ -0,0 +1,118 @@
+package goasmmacros
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCaptureActualSourceRules(t *testing.T) {
+	minor, err := GoMinor(runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, pkg := range []string{"example.invalid/ordinary", "runtime", "reflect"} {
+		reads := make(map[string]int)
+		read := func(name string) ([]byte, error) {
+			reads[name]++
+			return os.ReadFile(name)
+		}
+		proof, err := Capture(runtime.GOROOT(), runtime.Version(), pkg, read)
+		if err != nil {
+			t.Fatal(err)
+		}
+		role, files := "ordinary_path", 4
+		if minor < 22 {
+			role, files = "legacy_no_experiment_macros", 3
+		} else if pkg != "example.invalid/ordinary" {
+			role = "allow_asm_abi_path"
+		}
+		if proof.GoVersion != runtime.Version() || proof.PackageRole != role || len(proof.ToolSourceSHA256) != files || len(reads) != files {
+			t.Fatal("actual source registration differs from complete ordinary/special role", proof)
+		}
+		for name, digest := range proof.ToolSourceSHA256 {
+			full := filepath.Join(runtime.GOROOT(), filepath.FromSlash(name))
+			data, err := os.ReadFile(full)
+			if err != nil || reads[full] != 1 || fmt.Sprintf("%x", sha256.Sum256(data)) != digest {
+				t.Fatal("registration escaped original input observer", name, err)
+			}
+		}
+		if proof.RegistrationSHA256["asmArgs"] != ArgsFingerprint(minor) || ArgsFingerprint(minor) == "" {
+			t.Fatal("complete assembler argument AST is unbound")
+		}
+		if minor >= 22 && (proof.RegistrationSHA256["package_special_registration"] != SpecialFingerprint(minor) || SpecialFingerprint(minor) == "") {
+			t.Fatal("package-special AST is unbound")
+		}
+	}
+}
+
+func TestCaptureRejectsUnknownRegistrationsAndReadFailures(t *testing.T) {
+	minor, err := GoMinor(runtime.Version())
+	if err != nil {
+		t.Fatal(err)
+	}
+	mutations := []struct{ file, before, after string }{
+		{"VERSION", runtime.Version(), "go1.99.1"},
+		{"src/cmd/go/internal/work/gc.go", "\"GOARCH_\"", "\"UNKNOWN_ARCH_\""},
+		{"src/cmd/asm/main.go", "package main", "package wrong"},
+	}
+	if minor >= 22 {
+		mutations = append(mutations, struct{ file, before, after string }{
+			"src/cmd/asm/main.go", "GOEXPERIMENT_", "UNKNOWN_EXPERIMENT_",
+		}, struct{ file, before, after string }{
+			"src/cmd/internal/objabi/pkgspecial.go", "\"runtime\",", "\"example.invalid/ordinary\",",
+		})
+	}
+	for _, mutation := range mutations {
+		t.Run(mutation.file+"/"+mutation.before, func(t *testing.T) {
+			changed := false
+			read := func(name string) ([]byte, error) {
+				data, err := os.ReadFile(name)
+				if err == nil && name == filepath.Join(runtime.GOROOT(), filepath.FromSlash(mutation.file)) {
+					text := strings.Replace(string(data), mutation.before, mutation.after, 1)
+					changed = text != string(data)
+					data = []byte(text)
+				}
+				return data, err
+			}
+			if proof, err := Capture(runtime.GOROOT(), runtime.Version(), "example.invalid/ordinary", read); err == nil || proof != nil || !changed {
+				t.Fatal("changed actual source acquired registered macros", proof, err, changed)
+			}
+		})
+	}
+	for _, file := range []string{"VERSION", "src/cmd/go/internal/work/gc.go", "src/cmd/asm/main.go"} {
+		read := func(name string) ([]byte, error) {
+			if name == filepath.Join(runtime.GOROOT(), filepath.FromSlash(file)) {
+				return nil, errors.New("fixture unreadable input")
+			}
+			return os.ReadFile(name)
+		}
+		if proof, err := Capture(runtime.GOROOT(), runtime.Version(), "example.invalid/ordinary", read); err == nil || proof != nil {
+			t.Fatal("unreadable actual source supplied macro registration", file)
+		}
+	}
+}
+
+func TestCaptureRejectsUnboundInputs(t *testing.T) {
+	for _, version := range []string{"", "1.27", "go1.", "go1.27.x", "go1.27.1.extra", "go1.0.1", "go1.999.0", "go1.19.13", "go1.28.0"} {
+		if _, err := Capture(runtime.GOROOT(), version, "example.invalid/ordinary", os.ReadFile); err == nil {
+			t.Fatal("unregistered SDK accepted", version)
+		}
+	}
+	for _, pkg := range []string{"", "../ordinary", "/ordinary", "example.invalid/ordinary@v1.0.0", "example.invalid/ordinary\n"} {
+		if _, err := Capture(runtime.GOROOT(), runtime.Version(), pkg, os.ReadFile); err == nil {
+			t.Fatal("invalid package role accepted", pkg)
+		}
+	}
+	if _, err := Capture("relative", runtime.Version(), "example.invalid/ordinary", os.ReadFile); err == nil {
+		t.Fatal("relative SDK source root accepted")
+	}
+	if _, err := Capture(runtime.GOROOT(), runtime.Version(), "example.invalid/ordinary", nil); err == nil {
+		t.Fatal("missing actual source observer accepted")
+	}
+}
diff --git a/internal/goasmoracle/frontend.go b/internal/goasmoracle/frontend.go
new file mode 100644
index 000000000..37b90aac1
--- /dev/null
+++ b/internal/goasmoracle/frontend.go
@@ -0,0 +1,200 @@
+package goasmoracle
+
+import (
+	"strconv"
+	"strings"
+	"text/scanner"
+	"unicode"
+)
+
+type diagnosticToken struct {
+	kind         rune
+	text         string
+	line, column int
+}
+
+// These are the actual cmd/asm lexical roles, not supported instruction names.
+// Comments are skipped, but physical newlines retain statement boundaries.
+func diagnosticTokens(text string) ([]diagnosticToken, bool) {
+	var lexer scanner.Scanner
+	lexer.Init(strings.NewReader(text))
+	lexer.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
+	lexer.Mode = scanner.ScanChars | scanner.ScanFloats | scanner.ScanIdents |
+		scanner.ScanInts | scanner.ScanStrings | scanner.ScanComments | scanner.SkipComments
+	lexer.IsIdentRune = func(ch rune, index int) bool {
+		return unicode.IsLetter(ch) || ch == '_' || ch == '·' || ch == '∕' ||
+			index > 0 && unicode.IsDigit(ch)
+	}
+	lexer.Error = func(*scanner.Scanner, string) {}
+	var tokens []diagnosticToken
+	for kind := lexer.Scan(); kind != scanner.EOF; kind = lexer.Scan() {
+		tokens = append(tokens, diagnosticToken{kind, lexer.TokenText(), lexer.Position.Line, lexer.Position.Column})
+	}
+	return tokens, lexer.ErrorCount == 0
+}
+
+func tokenTexts(tokens []diagnosticToken) []string {
+	texts := make([]string, len(tokens))
+	for i, token := range tokens {
+		texts[i] = token.text
+	}
+	return texts
+}
+
+// A recognized frontend diagnostic never falls back to an arbitrary message.
+func frontendDiagnostic(data []byte, line, column int, message string, wasmWord bool) (known, bound bool) {
+	if strings.HasPrefix(message, "unrecognized instruction") {
+		return true, unrecognizedInstructionAt(data, line, column, message, wasmWord)
+	}
+	const expected = "expected identifier, found "
+	if strings.HasPrefix(message, "expected identifier") {
+		tokens, ok := diagnosticTokens(strings.Split(string(data), "\n")[line-1])
+		if !ok {
+			return true, false
+		}
+		for len(tokens) > 0 {
+			if tokens[0].kind == ';' || tokens[0].kind == '\n' {
+				tokens = tokens[1:]
+				continue
+			}
+			if tokens[0].kind != scanner.Ident {
+				// Go stops at the first invalid statement-start token. A
+				// later invalid token, or one in an operand, cannot bind it.
+				token := tokens[0]
+				return true, message == expected+strconv.Quote(token.text) &&
+					(column == 0 || column == token.column)
+			}
+			if len(tokens) >= 2 && tokens[1].kind == ':' {
+				tokens = tokens[2:]
+				continue
+			}
+			for len(tokens) > 0 && tokens[0].kind != ';' && tokens[0].kind != '\n' {
+				tokens = tokens[1:]
+			}
+		}
+		return true, false
+	}
+	if strings.HasPrefix(message, "label ") {
+		if column != 0 {
+			return true, false // cmd/asm errorf reports this role without a column.
+		}
+		quoted := strings.TrimSuffix(strings.TrimPrefix(message, "label "), " multiply defined")
+		name, err := strconv.Unquote(quoted)
+		if err != nil || message != "label "+strconv.Quote(name)+" multiply defined" {
+			return true, false
+		}
+		return true, duplicateLabelAt(data, line, name)
+	}
+	return false, false
+}
+
+// Replay only statement-start word/label roles. Go's actual exit and concrete
+// message establish rejection separately. Operand, comment and string tokens
+// cannot impersonate the frontend's original word. Whole-source lexing retains
+// multiline-comment identity and physical token positions.
+func unrecognizedInstructionAt(data []byte, line, column int, message string, wasmWord bool) bool {
+	all, ok := diagnosticTokens(string(data))
+	if !ok {
+		return false
+	}
+	var tokens []diagnosticToken
+	for _, token := range all {
+		if token.line == line {
+			tokens = append(tokens, token)
+		}
+	}
+	for len(tokens) > 0 {
+		if tokens[0].kind == ';' || tokens[0].kind == '\n' {
+			tokens = tokens[1:]
+			continue
+		}
+		word := tokens[0]
+		if word.kind != scanner.Ident {
+			return false // The Go frontend stops at an invalid initial token.
+		}
+		next := 1
+		if !wasmWord {
+			for next < len(tokens) && tokens[next].kind == '.' {
+				next++
+				if next == len(tokens) || tokens[next].kind != scanner.Ident {
+					return false
+				}
+				next++
+			}
+		}
+		if next < len(tokens) && tokens[next].kind == ':' {
+			tokens = tokens[next+1:]
+			continue
+		}
+		if message == "unrecognized instruction "+strconv.Quote(word.text) &&
+			(column == 0 || column == word.column) {
+			return true
+		}
+		for len(tokens) > 0 && tokens[0].kind != ';' && tokens[0].kind != '\n' {
+			tokens = tokens[1:]
+		}
+	}
+	return false
+}
+
+// Replay label attachment, not instruction validity. Actual exit 1 and Go's
+// concrete errorf message remain separately required by CheckOutcome. TEXT
+// resets the definition map; pending labels survive an attachment error.
+func duplicateLabelAt(data []byte, line int, name string) bool {
+	tokens, ok := diagnosticTokens(string(data))
+	if !ok {
+		return false
+	}
+	defined := make(map[string]bool)
+	var pending []string
+	for i := 0; i < len(tokens); {
+		if tokens[i].line > line {
+			return false
+		}
+		if tokens[i].kind == '\n' || tokens[i].kind == ';' {
+			i++
+			continue
+		}
+		if tokens[i].kind != scanner.Ident {
+			return false
+		}
+		word, position := tokens[i].text, tokens[i].line
+		i++
+		if i < len(tokens) && tokens[i].kind == ':' {
+			pending = append(pending, word)
+			i++
+			continue
+		}
+		// Consume the complete original statement, without borrowing labels
+		// hidden in operands, strings or comments. Unobserved CPP is unknown.
+		for i < len(tokens) && tokens[i].kind != '\n' && tokens[i].kind != ';' {
+			if tokens[i].kind == '#' {
+				return false
+			}
+			i++
+		}
+		if word == "TEXT" {
+			defined = make(map[string]bool)
+		}
+		if word == "DATA" || word == "GLOBL" {
+			continue // These pseudo-ops do not append a Prog.
+		}
+		duplicate := ""
+		for _, label := range pending {
+			if defined[label] {
+				duplicate = label
+				break
+			}
+			defined[label] = true
+		}
+		if position == line && duplicate != "" {
+			// Several attachment statements may share a physical line.
+			// errorf reports only its first error, not a later duplicate.
+			return duplicate == name
+		}
+		if duplicate == "" {
+			pending = nil
+		}
+	}
+	return false
+}
diff --git a/internal/goasmoracle/frontend_actual_test.go b/internal/goasmoracle/frontend_actual_test.go
new file mode 100644
index 000000000..ddd859511
--- /dev/null
+++ b/internal/goasmoracle/frontend_actual_test.go
@@ -0,0 +1,73 @@
+package goasmoracle
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestDiagnosticFrontendActualOriginalSources(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		accepted   bool
+	}{
+		{"integer", "1: NOP\n", false},
+		{"float", "1.0: NOP\n", false},
+		{"string", "\"name\": NOP\n", false},
+		{"char", "'x': NOP\n", false},
+		{"plus", "+name: NOP\n", false},
+		{"colon", ": NOP\n", false},
+		{"duplicate-inline", "first: first: NOP\n", false},
+		{"duplicate-pending", "first: first:\n", false},
+		{"duplicate-separated", "first: NOP\nfirst: NOP\n", false},
+		{"cross-TEXT", "first: NOP\nTEXT second(SB),$0-0\nfirst: NOP\n", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, object := oracleFixture(t)
+			data := "TEXT probe(SB),$0-0\n" + test.body + "RET\n"
+			if err := os.WriteFile(source, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			deadline := time.Now().Add(5 * time.Second)
+			if enclosing, ok := t.Deadline(); ok && enclosing.Before(deadline) {
+				deadline = enclosing
+			}
+			ctx, cancel := context.WithDeadline(context.Background(), deadline)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			exit := 1
+			if test.accepted {
+				exit = 0
+			}
+			if !observed.Waited || observed.ExitCode != exit {
+				t.Fatalf("actual frontend outcome differs: %+v %v", observed, err)
+			}
+			if !test.accepted {
+				role := "expected identifier, found "
+				if strings.HasPrefix(test.name, "duplicate-") {
+					role = "label \"first\" multiply defined"
+				}
+				if !strings.Contains(string(observed.Stderr), role) {
+					t.Fatalf("original frontend role absent: %+v", observed)
+				}
+			}
+			if failure := CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+				err, ctx.Err(), test.accepted, 0, nil); failure != nil {
+				t.Fatalf("actual frontend observation lost: %v", failure)
+			}
+		})
+	}
+}
diff --git a/internal/goasmoracle/frontend_boundary_test.go b/internal/goasmoracle/frontend_boundary_test.go
new file mode 100644
index 000000000..9e0bca6d6
--- /dev/null
+++ b/internal/goasmoracle/frontend_boundary_test.go
@@ -0,0 +1,73 @@
+package goasmoracle
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestDiagnosticFrontendPhysicalStatementBoundaries(t *testing.T) {
+	for _, test := range []struct {
+		name, body, message string
+		want                bool
+	}{
+		{"identifier-after-semicolon", "NOP;1:NOP", `expected identifier, found "1"`, true},
+		{"identifier-after-label", "ok:NOP;bad:1:NOP", `expected identifier, found "1"`, true},
+		{"first-invalid-not-later", "NOP;1:NOP;2:NOP", `expected identifier, found "2"`, false},
+		{"not-an-operand", "MOVQ $1,AX", `expected identifier, found "1"`, false},
+		{"duplicate-after-semicolon", "first:NOP;first:NOP", `label "first" multiply defined`, true},
+		{"first-duplicate-not-later", "a:NOP;a:NOP;b:NOP;b:NOP", `label "b" multiply defined`, false},
+		{"first-duplicate", "a:NOP;a:NOP;b:NOP;b:NOP", `label "a" multiply defined`, true},
+		{"same-line-TEXT-reset", "first:NOP;TEXT second(SB),$0-0;first:NOP", `label "first" multiply defined`, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, _ := oracleFixture(t)
+			if err := os.WriteFile(source, []byte("TEXT probe(SB),$0-0\n"+test.body+"\nRET\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if got := SourceDiagnosticLine(source, source+":2: "+test.message+"\n", 2); got != test.want {
+				t.Fatalf("complete physical statement boundary join=%t, want %t", got, test.want)
+			}
+		})
+	}
+}
+
+func TestDiagnosticFrontendActualSemicolonBoundaries(t *testing.T) {
+	for _, test := range []struct{ name, body string }{
+		{"identifier", "NOP;1:NOP"},
+		{"duplicate", "first:NOP;first:NOP"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, object := oracleFixture(t)
+			if err := os.WriteFile(source, []byte("TEXT probe(SB),$0-0\n"+test.body+"\nRET\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			deadline := time.Now().Add(5 * time.Second)
+			if enclosing, ok := t.Deadline(); ok && enclosing.Before(deadline) {
+				deadline = enclosing
+			}
+			ctx, cancel := context.WithDeadline(context.Background(), deadline)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 {
+				t.Fatalf("actual frontend outcome differs: %+v %v", observed, err)
+			}
+			if failure := CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+				err, ctx.Err(), false, 2, nil); failure != nil {
+				t.Fatalf("actual physical-line frontend observation lost: %v", failure)
+			}
+		})
+	}
+}
diff --git a/internal/goasmoracle/frontend_role_test.go b/internal/goasmoracle/frontend_role_test.go
new file mode 100644
index 000000000..0895c6b34
--- /dev/null
+++ b/internal/goasmoracle/frontend_role_test.go
@@ -0,0 +1,85 @@
+package goasmoracle
+
+import (
+	"os"
+	"strconv"
+	"testing"
+)
+
+// These are diagnostic-join controls, not claims that a fabricated diagnostic
+// came from Go. The original parser roots provide the separate actual oracle.
+func TestDiagnosticFrontendOriginalTokenBinding(t *testing.T) {
+	for _, test := range []struct {
+		name, body, message string
+		line, focus         int
+		want                bool
+	}{
+		{"integer", "1: NOP", `expected identifier, found "1"`, 2, 2, true},
+		{"string", `"name": NOP`, `expected identifier, found "\"name\""`, 2, 2, true},
+		{"colon", ": NOP", `expected identifier, found ":"`, 2, 2, true},
+		{"float", "1.0: NOP", `expected identifier, found "1.0"`, 2, 2, true},
+		{"char", "'x': NOP", `expected identifier, found "'x'"`, 2, 2, true},
+		{"plus", "+name: NOP", `expected identifier, found "+"`, 2, 2, true},
+		{"integer-not-prefix", "12: NOP", `expected identifier, found "1"`, 2, 2, false},
+		{"string-not-decoded-value", `"name": NOP`, `expected identifier, found "name"`, 2, 2, false},
+		{"wrong-token", "1: NOP", `expected identifier, found ":"`, 2, 2, false},
+		{"token-in-operand", "MOVQ $1,AX", `expected identifier, found "1"`, 2, 2, false},
+		{"valid-identifier", "name: NOP", `expected identifier, found "name"`, 2, 2, false},
+		{"header-is-not-token", "1: NOP", `expected identifier, found "1"`, 1, 2, false},
+		{"wrong-focus", "1: NOP", `expected identifier, found "1"`, 2, 3, false},
+		{"wrong-line", "1: NOP", `expected identifier, found "1"`, 3, 0, false},
+		{"unknown-nonidentifier-message", "1: NOP", "bad source", 2, 2, false},
+		{"noncanonical-quote", "1: NOP", `expected identifier, found "\x31"`, 2, 2, false},
+		{"message-tail", "1: NOP", `expected identifier, found "1" extra`, 2, 2, false},
+		{"unterminated-comment", "/* broken", `expected identifier, found "/"`, 2, 2, false},
+		{"comment-only", "// 1: NOP", `expected identifier, found "1"`, 2, 2, false},
+		{"unknown-identifier-control", "NOT_AN_INSTRUCTION", `unrecognized instruction "NOT_AN_INSTRUCTION"`, 2, 2, true},
+		{"duplicate-inline", "first: first: NOP", `label "first" multiply defined`, 2, 2, true},
+		{"duplicate-pending", "first: first:\nRET", `label "first" multiply defined`, 3, 3, true},
+		{"duplicate-separated", "first: NOP\nfirst: NOP", `label "first" multiply defined`, 3, 3, true},
+		{"duplicate-wrong-name", "first: first:\nRET", `label "other" multiply defined`, 3, 3, false},
+		{"duplicate-absent", "RET", `label "first" multiply defined`, 2, 2, false},
+		{"duplicate-label-in-comment", "// first: first:\nRET", `label "first" multiply defined`, 3, 3, false},
+		{"duplicate-late-definition", "RET\nfirst: first: NOP", `label "first" multiply defined`, 2, 2, false},
+		{"duplicate-new-text", "first: NOP\nTEXT second(SB),$0-0\nfirst: NOP", `label "first" multiply defined`, 4, 4, false},
+		{"duplicate-message-tail", "first: first:\nRET", `label "first" multiply defined extra`, 3, 3, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, _ := oracleFixture(t)
+			text := "TEXT probe(SB),$0-0\n" + test.body + "\nRET\n"
+			if err := os.WriteFile(source, []byte(text), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output := source + ":" + strconv.Itoa(test.line) + ": " + test.message + "\n"
+			if got := SourceDiagnosticLine(source, output, test.focus); got != test.want {
+				t.Fatalf("original frontend token/label join=%t, want %t", got, test.want)
+			}
+			if SourceDiagnosticLine(source, "foreign"+output, test.focus) {
+				t.Fatal("foreign source prefix acquired a frontend role")
+			}
+		})
+	}
+}
+
+// A target-free parser must never silently become a global opcode alias map.
+// The new x86 diagnostic adapter will be tested separately with exact targets.
+func TestDiagnosticDefaultDoesNotCanonicalizeBackendOpcodes(t *testing.T) {
+	for _, test := range []struct{ source, listing string }{
+		{"PADDD M0,X1", "PADDL M0, X1"},
+		{"PADDD.Z X0,X1", "PADDL.Z X0, X1"},
+		{"MOVD X0,M1", "MOVQ X0, M1"},
+		{"VMOVSS $0.0,K1,X0", "XORPS X0, K1, X0"},
+		{"VMOVSD.Z $0.0,X1,K7,X0", "XORPS.Z X0, X1, K7, X0"},
+	} {
+		t.Run(test.source, func(t *testing.T) {
+			source, _ := oracleFixture(t)
+			if err := os.WriteFile(source, []byte("TEXT probe(SB),$0-0\n"+test.source+"\nRET\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			output := "asm: bad: invalid instruction: 00000 (" + source + ":2)\t" + test.listing + "\n"
+			if ListingBindsSource(source, "2", "00000", test.listing) || SourceDiagnosticLine(source, output, 2) {
+				t.Fatal("target-free parser canonicalized a backend opcode")
+			}
+		})
+	}
+}
diff --git a/internal/goasmoracle/oracle.go b/internal/goasmoracle/oracle.go
new file mode 100644
index 000000000..ceb5c5ddb
--- /dev/null
+++ b/internal/goasmoracle/oracle.go
@@ -0,0 +1,262 @@
+// Package goasmoracle validates source-bound observations, not ISA/ABI authority.
+package goasmoracle
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+func CheckOutcome(source, object string, stdout, stderr []byte, commandErr, contextErr error, wantSuccess bool, focus int, additional func(string, string) bool) error {
+	if contextErr != nil {
+		return fmt.Errorf("Go assembler oracle infrastructure failure: deadline/cancellation: %w", contextErr)
+	}
+	if commandErr == nil {
+		if !wantSuccess {
+			return fmt.Errorf("Go assembler accepted a form expected outside the optab")
+		}
+		info, err := os.Lstat(object)
+		if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+			return fmt.Errorf("Go assembler oracle infrastructure failure: missing/nonregular/empty object: %v", err)
+		}
+		return nil
+	}
+	// Cleanup/pipe errors joined to a source exit are still infrastructure
+	// failures. A signal, launch error or unknown positive exit is not evidence.
+	exit, ok := commandErr.(*exec.ExitError)
+	if !ok || exit.ProcessState == nil || !exit.ProcessState.Exited() || exit.ExitCode() != 1 {
+		return fmt.Errorf("Go assembler oracle infrastructure failure: unknown process outcome: %w", commandErr)
+	}
+	streams := []string{string(stdout), string(stderr)}
+	for _, marker := range []string{"panic:", "fatal error:", "runtime: failed to", "runtime: out of memory", "signal:", "executable file not found"} {
+		for _, text := range streams {
+			if strings.Contains(text, marker) {
+				return fmt.Errorf("Go assembler oracle infrastructure failure: %s: %w", marker, commandErr)
+			}
+		}
+	}
+	// Go prints source positions either directly or in its illegal-combination
+	// listing. A footer alone, or a line for another source, cannot reject this
+	// exact fixture. Keep positive canonical line/column positions.
+	bound := false
+	for _, text := range streams {
+		bound = bound || SourceDiagnosticLine(source, text, focus) || (additional != nil && additional(source, text))
+	}
+	if !bound {
+		return fmt.Errorf("Go assembler oracle infrastructure failure: no concrete fixture diagnostic: %w", commandErr)
+	}
+	if wantSuccess {
+		return fmt.Errorf("Go assembler rejected accepted forms: %w", commandErr)
+	}
+	return nil
+}
+
+// ReadSource preserves the existing eight-MiB fixture bound. This is an
+// independent bounded physical read, not a caller-supplied snapshot/hash.
+func ReadSource(source string) ([]byte, bool) {
+	before, err := os.Lstat(source)
+	if err != nil || !before.Mode().IsRegular() || before.Size() < 0 || before.Size() > 8<<20 {
+		return nil, false
+	}
+	file, err := os.Open(source)
+	if err != nil {
+		return nil, false
+	}
+	opened, err := file.Stat()
+	if err != nil || !sameInput(before, opened) {
+		_ = file.Close()
+		return nil, false
+	}
+	data, readErr := io.ReadAll(io.LimitReader(file, before.Size()+1))
+	ended, endErr := file.Stat()
+	closeErr := file.Close()
+	after, pathErr := os.Lstat(source)
+	return data, readErr == nil && endErr == nil && closeErr == nil &&
+		pathErr == nil && int64(len(data)) == before.Size() &&
+		sameInput(before, ended) && sameInput(before, after)
+}
+
+func sameInput(before, after os.FileInfo) bool {
+	return os.SameFile(before, after) && before.Mode() == after.Mode() &&
+		before.Size() == after.Size() && before.ModTime() == after.ModTime()
+}
+
+// The token role is only a diagnostic join. It is not an instruction grammar,
+// lowering rule, or permission to execute a source statement.
+func statementOpcode(statement string) string {
+	opcode, _ := statementRole(statement)
+	return opcode
+}
+
+func statementRole(statement string) (string, bool) {
+	tokens, ok := diagnosticTokens(statement)
+	if !ok || len(tokens) == 0 || tokens[0].kind != scanner.Ident {
+		return "", false
+	}
+	opcode, next := tokens[0].text, 1
+	for next < len(tokens) && tokens[next].kind == '.' {
+		if next+1 >= len(tokens) || tokens[next+1].kind != scanner.Ident {
+			return "", false
+		}
+		opcode += "." + tokens[next+1].text
+		next += 2
+	}
+	if next < len(tokens) && tokens[next].kind == ':' {
+		// A label or label prefix is not this isolated statement's opcode.
+		return "", false
+	}
+	return opcode, next == len(tokens)
+}
+
+func positivePosition(text string) (int, bool) {
+	value, err := strconv.Atoi(text)
+	return value, err == nil && value > 0 && strconv.Itoa(value) == text
+}
+
+func canonicalPC(pc string) bool {
+	address, err := strconv.ParseUint(pc, 10, 64)
+	return err == nil && len(pc) >= 5 && fmt.Sprintf("%05d", address) == pc
+}
+
+func ListingBindsSource(source, position, pc, instruction string) bool {
+	data, ok := ReadSource(source)
+	line, valid := positivePosition(position)
+	lines := strings.Split(string(data), "\n")
+	if !ok || !valid || line > len(lines) || !canonicalPC(strings.TrimSpace(pc)) {
+		return false
+	}
+	fields := strings.Fields(instruction)
+	opcode, zeroOperands := statementRole(lines[line-1])
+	if len(fields) == 0 || opcode == "" || opcode != fields[0] {
+		return false
+	}
+	// A single listing token is complete only for an original statement with
+	// no operand tokens. Truncated operand-bearing listings remain unbound.
+	return len(fields) > 1 || zeroOperands
+}
+
+func SourceDiagnostic(source, output string) bool {
+	return SourceDiagnosticLine(source, output, 0)
+}
+
+// Only a real statement in this exact physical fixture can bind a diagnostic.
+// A nonzero focus is the script's actual isolated instruction, not its CPP
+// header, TEXT setup, RET footer, another source, or an unobserved #line route.
+func SourceDiagnosticLine(source, output string, focus int) bool {
+	return SourceDiagnosticLineWithListing(source, output, focus, nil)
+}
+
+// SourceDiagnosticLineWithListing permits an explicitly selected backend to
+// join a complete rewritten listing. The matcher runs only after the same
+// physical-source/path/line/focus/canonical-PC checks as the strict default.
+// Its lexical inputs are diagnostic observations, not instruction authority.
+func SourceDiagnosticLineWithListing(source, output string, focus int, match func(original, listing []string) bool) bool {
+	return sourceDiagnosticLine(source, output, focus, match, false)
+}
+
+// WasmSourceDiagnosticLine explicitly selects Go's wasm frontend word role.
+// Unlike the other supported targets, wasm does not consume opcode suffixes
+// before deciding whether the first identifier is a pending label. This is a
+// source diagnostic observation, never instruction or execution authority.
+func WasmSourceDiagnosticLine(source, output string, focus int) bool {
+	return sourceDiagnosticLine(source, output, focus, nil, true)
+}
+
+func sourceDiagnosticLine(source, output string, focus int, match func(original, listing []string) bool, wasmWord bool) bool {
+	data, ok := ReadSource(source)
+	if !ok || focus < 0 {
+		return false
+	}
+	lines := strings.Split(string(data), "\n")
+	backendDiagnostic := false
+	for _, line := range strings.Split(output, "\n") {
+		direct := strings.HasPrefix(line, source+":")
+		start, pc := 0, ""
+		// cmd/asm's obj.Link diagnostics add this exact backend prefix to
+		// source positions. It does not authorize embedded or foreign paths.
+		if !direct && strings.HasPrefix(line, "asm: "+source+":") {
+			direct, start = true, len("asm: ")
+		}
+		if !direct {
+			marker := strings.Index(line, "("+source+":")
+			if marker < 0 {
+				if strings.TrimSpace(line) != "" {
+					backendDiagnostic = strings.HasPrefix(line, "asm: ") &&
+						line != "asm: assembly failed" && line != "asm: "
+				}
+				continue
+			}
+			prefix := strings.TrimSpace(line[:marker])
+			fields := strings.Fields(prefix)
+			if len(fields) == 0 {
+				continue
+			}
+			pc = fields[len(fields)-1]
+			if !canonicalPC(pc) {
+				continue
+			}
+			if len(fields) == 1 {
+				if !backendDiagnostic {
+					continue
+				}
+			} else if !strings.HasPrefix(prefix, "asm: ") ||
+				strings.TrimSpace(strings.TrimSuffix(prefix, pc)) == "asm:" ||
+				strings.TrimSpace(strings.TrimSuffix(prefix, pc)) == "asm: assembly failed" {
+				continue
+			}
+			start = marker + 1
+		}
+		position := line[start+len(source)+1:]
+		end := strings.IndexAny(position, ":)")
+		if end < 0 {
+			continue
+		}
+		number, valid := positivePosition(position[:end])
+		if !valid || number > len(lines) || (focus > 0 && number != focus) {
+			continue
+		}
+		message := strings.TrimSpace(position[end+1:])
+		if position[end] == ')' {
+			if !direct && ListingBindsSource(source, position[:end], pc, message) {
+				return true
+			}
+			if !direct && match != nil && statementOpcode(lines[number-1]) != "" {
+				original, sourceOK := diagnosticTokens(lines[number-1])
+				listing, listingOK := diagnosticTokens(message)
+				if sourceOK && listingOK && len(listing) > 0 && listing[0].kind == scanner.Ident &&
+					match(tokenTexts(original), tokenTexts(listing)) {
+					return true
+				}
+			}
+			continue
+		}
+		if !direct {
+			continue
+		}
+		if column, detail, found := strings.Cut(message, ":"); found &&
+			(column == "" || strings.ContainsRune("+-0123456789", rune(column[0]))) {
+			if value, valid := positivePosition(column); valid && value <= len([]rune(lines[number-1])) && strings.TrimSpace(detail) != "" {
+				if known, bound := frontendDiagnostic(data, number, value, strings.TrimSpace(detail), wasmWord); known {
+					if bound {
+						return true
+					}
+				} else if statementOpcode(lines[number-1]) != "" {
+					return true
+				}
+			}
+			continue
+		}
+		if known, bound := frontendDiagnostic(data, number, 0, message, wasmWord); known {
+			if bound {
+				return true
+			}
+		} else if message != "" && statementOpcode(lines[number-1]) != "" {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/goasmoracle/oracle_test.go b/internal/goasmoracle/oracle_test.go
new file mode 100644
index 000000000..9efaba527
--- /dev/null
+++ b/internal/goasmoracle/oracle_test.go
@@ -0,0 +1,213 @@
+package goasmoracle
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func oracleFixture(t *testing.T) (string, string) {
+	t.Helper()
+	dir := t.TempDir()
+	source, object := filepath.Join(dir, "probe.s"), filepath.Join(dir, "probe.o")
+	if err := os.WriteFile(source, []byte("#include \"textflag.h\"\nTEXT probe(SB),$0-0\n\tMOVD R0,R1\n\tRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return source, object
+}
+
+func TestDiagnosticCompleteSourceAndFocus(t *testing.T) {
+	source, _ := oracleFixture(t)
+	for _, test := range []struct {
+		name, suffix string
+		focus        int
+		want         bool
+	}{
+		{"direct", ":3: bad operand\n", 3, true},
+		{"column", ":3:2: bad operand\n", 3, true},
+		{"zero-line", ":0: bad operand\n", 3, false},
+		{"overflow-line", ":99999999999999999999: bad operand\n", 3, false},
+		{"out-of-range-line", ":9999: bad operand\n", 3, false},
+		{"blank-line", ":5: bad operand\n", 0, false},
+		{"header", ":1: bad operand\n", 0, false},
+		{"TEXT-not-focus", ":2: bad operand\n", 3, false},
+		{"RET-not-focus", ":4: bad operand\n", 3, false},
+		{"zero-column", ":3:0: bad operand\n", 3, false},
+		{"negative-column", ":3:-1: bad operand\n", 3, false},
+		{"noncanonical-column", ":3:02: bad operand\n", 3, false},
+		{"out-of-range-column", ":3:9999: bad operand\n", 3, false},
+		{"no-detail", ":3:2: \n", 3, false},
+		{"empty-column", ":3:: bad operand\n", 3, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := SourceDiagnosticLine(source, source+test.suffix, test.focus); got != test.want {
+				t.Fatalf("bound=%t, want %t", got, test.want)
+			}
+		})
+	}
+}
+
+func TestDiagnosticScannerErrorsDoNotMatch(t *testing.T) {
+	for _, source := range []string{"MOVD R0,R1 /*", "MOVD /*", "#include \"x\"", "\x00MOVD R0,R1"} {
+		if statementOpcode(source) != "" {
+			t.Fatalf("malformed scanner input matched: %q", source)
+		}
+	}
+	if statementOpcode("\tMOVD R0,R1 // comment") != "MOVD" {
+		t.Fatal("real opcode lost")
+	}
+}
+
+func TestDiagnosticAssemblerIdentifierRoles(t *testing.T) {
+	// These are real assembler identifiers, not supported instruction names.
+	// Their current source-bound Go refusals must retain the diagnostic role.
+	for _, test := range []struct {
+		opcode string
+		bound  bool
+		exit   int
+	}{
+		{"NOT_AN_INSTRUCTION", true, 1},
+		{"_NOT_AN_INSTRUCTION", true, 1},
+		{"NOT_AN_INSTRUCTION_2", true, 1},
+		{"not_an_instruction", true, 1},
+		{"無效指令", true, 1},
+		{"NOT·AN", true, 1},
+		{"NOT∕AN", true, 1},
+		{"·NOT", true, 1},
+		{"∕NOT", true, 1},
+		{"NOT１２", true, 1},
+		{"LABEL:", false, 0},
+		{"LABEL: NOT_AN_INSTRUCTION", false, 1},
+		{"// NOT_AN_INSTRUCTION", false, 0},
+		{"/* NOT_AN_INSTRUCTION */", false, 0},
+		{"1NOT_AN_INSTRUCTION", false, 1},
+		{"/NOT_AN_INSTRUCTION", false, 1},
+		{".NOT_AN_INSTRUCTION", false, 1},
+		{"MOVD R0,R1 /*", false, 1},
+	} {
+		t.Run(test.opcode, func(t *testing.T) {
+			source, object := oracleFixture(t)
+			data := "TEXT probe(SB),$0-0\n\t" + test.opcode + "\n\tRET\n"
+			if err := os.WriteFile(source, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=arm64"),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, _ := json.Marshal(observed)
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if observed.ExitCode != test.exit || !observed.Waited {
+				t.Fatalf("actual original Go diagnostic differs: %+v %v", observed, err)
+			}
+			if test.bound {
+				if !strings.Contains(string(observed.Stderr), source+":2: unrecognized instruction \""+test.opcode+"\"") {
+					t.Fatalf("Go did not observe this exact identifier token: %+v", observed)
+				}
+				if got := statementOpcode("\t" + test.opcode); got != test.opcode {
+					t.Fatalf("original identifier token=%q, want %q", got, test.opcode)
+				}
+				if failure := CheckOutcome(source, object, observed.Stdout, observed.Stderr, err,
+					ctx.Err(), false, 2, nil); failure != nil {
+					t.Fatalf("real identifier diagnostic lost: %v", failure)
+				}
+			}
+			if got := SourceDiagnosticLine(source, source+":2: bad operand\n", 2); got != test.bound {
+				t.Fatalf("statement role=%t, want %t", got, test.bound)
+			}
+			for _, output := range []string{"foreign" + source + ":2: unrecognized instruction\n",
+				source + ":4: unrecognized instruction\n", "asm: assembly failed\n"} {
+				if SourceDiagnosticLine(source, output, 2) {
+					t.Fatalf("unbound identifier diagnostic matched: %q", output)
+				}
+			}
+			if SourceDiagnosticLine(source, "asm: illegal combination: 00000 ("+source+":2) FOREIGN R0,R1\n", 2) {
+				t.Fatal("different listing token matched the original statement")
+			}
+		})
+	}
+}
+
+func TestOutcomeSeparateStreamsAndActualExit(t *testing.T) {
+	source, object := oracleFixture(t)
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	observed, err := goasmcmd.Observe(ctx, t.TempDir(), append(os.Environ(), "GOASM_ORACLE_EXIT_ONE=1"),
+		os.Args[0], "-test.run=^TestOutcomeExitOneFixture$")
+	encoded, _ := json.Marshal(observed)
+	t.Logf("ORACLE_CHILD %s", encoded)
+	exit, ok := err.(*exec.ExitError)
+	if !ok || exit.ExitCode() != 1 || observed.ExitCode != 1 || !observed.Waited {
+		t.Fatalf("actual direct exit1 absent: %+v %v", observed, err)
+	}
+	for _, test := range []struct {
+		name           string
+		stdout, stderr []byte
+		cause, context error
+	}{
+		{"unknown-exit1", nil, nil, err, nil},
+		{"footer", nil, []byte("asm: assembly failed\n"), err, nil},
+		{"foreign", nil, []byte("foreign.s:3: bad operand\n"), err, nil},
+		{"split-detail", []byte(source + ":3:"), []byte(" bad operand\n"), err, nil},
+		{"split-backend", []byte("asm: bad constant\n"), []byte("00000 (" + source + ":3) MOVD R0,R1\n"), err, nil},
+		{"panic", []byte(source + ":3: bad operand\n"), []byte("panic: compiler defect\n"), err, nil},
+		{"joined-cleanup", nil, []byte(source + ":3: bad operand\n"), errors.Join(err, errors.New("cleanup failed")), nil},
+		{"deadline", nil, []byte(source + ":3: bad operand\n"), err, context.DeadlineExceeded},
+		{"cancel", nil, []byte(source + ":3: bad operand\n"), err, context.Canceled},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			failure := CheckOutcome(source, object, test.stdout, test.stderr, test.cause, test.context, false, 3, nil)
+			if failure == nil || !strings.Contains(failure.Error(), "infrastructure failure") {
+				t.Fatalf("unknown observation accepted: %v", failure)
+			}
+		})
+	}
+	if err := CheckOutcome(source, object, nil, []byte(source+":3: bad operand\n"), err, nil, false, 3, nil); err != nil {
+		t.Fatalf("real exit1 and exact statement lost: %v", err)
+	}
+}
+
+func TestOutcomeExitOneFixture(t *testing.T) {
+	if os.Getenv("GOASM_ORACLE_EXIT_ONE") == "1" {
+		os.Exit(1)
+	}
+}
+
+func TestSourcePhysicalReadGuards(t *testing.T) {
+	source, _ := oracleFixture(t)
+	for _, path := range []string{source + ".missing", filepath.Dir(source)} {
+		if _, ok := ReadSource(path); ok {
+			t.Fatal("nonregular source read succeeded")
+		}
+	}
+	alias := source + ".alias"
+	if err := os.Symlink(source, alias); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := ReadSource(alias); ok {
+		t.Fatal("symlink acquired regular-file role")
+	}
+	large := source + ".large"
+	file, err := os.Create(large)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := file.Truncate(8<<20 + 1); err != nil {
+		t.Fatal(err)
+	}
+	if err := file.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := ReadSource(large); ok {
+		t.Fatal("over-bound source read succeeded")
+	}
+}
diff --git a/internal/goasmoracle/package_listing.go b/internal/goasmoracle/package_listing.go
new file mode 100644
index 000000000..621a3ca8d
--- /dev/null
+++ b/internal/goasmoracle/package_listing.go
@@ -0,0 +1,32 @@
+package goasmoracle
+
+import (
+	"reflect"
+	"strings"
+)
+
+// PackageQualifiedListing joins Go's leading-middle-dot symbol spelling to
+// the exact package prefix selected by the observing assembler command. It
+// compares the complete token sequence; an arbitrary suffix match is not a
+// source observation. This grants no instruction or execution permission.
+func PackageQualifiedListing(original, listing []string, packagePrefix string) bool {
+	if packagePrefix == "" {
+		return false
+	}
+	var expected []string
+	qualified := false
+	for index, text := range original {
+		if index == 0 || !strings.HasPrefix(text, "·") {
+			expected = append(expected, text)
+			continue
+		}
+		name := strings.NewReplacer("·", ".", "∕", "/").Replace(text)
+		tokens, valid := diagnosticTokens(packagePrefix + name)
+		if !valid {
+			return false
+		}
+		expected = append(expected, tokenTexts(tokens)...)
+		qualified = true
+	}
+	return qualified && reflect.DeepEqual(expected, listing)
+}
diff --git a/internal/goasmoracle/prefixed_source_test.go b/internal/goasmoracle/prefixed_source_test.go
new file mode 100644
index 000000000..0a2dbc8d7
--- /dev/null
+++ b/internal/goasmoracle/prefixed_source_test.go
@@ -0,0 +1,81 @@
+package goasmoracle
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestDiagnosticBackendPrefixedSourcePositions(t *testing.T) {
+	source, _ := oracleFixture(t)
+	for _, test := range []struct {
+		name, output string
+		focus        int
+		want         bool
+	}{
+		{"plain", source + ":3: bad operand\n", 3, true},
+		{"backend", "asm: " + source + ":3: bad operand\n", 3, true},
+		{"backend-column", "asm: " + source + ":3:2: bad operand\n", 3, true},
+		{"foreign-path", "asm: foreign" + source + ":3: bad operand\n", 3, false},
+		{"embedded-path", "asm: wrapper " + source + ":3: bad operand\n", 3, false},
+		{"foreign-backend", "other: " + source + ":3: bad operand\n", 3, false},
+		{"missing-space", "asm:" + source + ":3: bad operand\n", 3, false},
+		{"repeated-prefix", "asm: asm: " + source + ":3: bad operand\n", 3, false},
+		{"wrong-focus", "asm: " + source + ":4: bad operand\n", 3, false},
+		{"zero-line", "asm: " + source + ":0: bad operand\n", 0, false},
+		{"noncanonical-line", "asm: " + source + ":03: bad operand\n", 0, false},
+		{"header", "asm: " + source + ":1: bad operand\n", 0, false},
+		{"blank", "asm: " + source + ":5: bad operand\n", 0, false},
+		{"zero-column", "asm: " + source + ":3:0: bad operand\n", 3, false},
+		{"no-detail", "asm: " + source + ":3:2: \n", 3, false},
+		{"footer", "asm: assembly failed\n", 0, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if got := SourceDiagnosticLine(source, test.output, test.focus); got != test.want {
+				t.Fatalf("source diagnostic=%t, want %t: %q", got, test.want, test.output)
+			}
+		})
+	}
+}
+
+func TestDiagnosticActualBackendSymbolRedeclaration(t *testing.T) {
+	for _, arch := range []string{"386", "amd64", "arm", "arm64", "wasm"} {
+		t.Run(arch, func(t *testing.T) {
+			source, object := oracleFixture(t)
+			data := "TEXT probe(SB),$0-0\nRET\nGLOBL probe(SB),8,$8\n"
+			if err := os.WriteFile(source, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			deadline := time.Now().Add(5 * time.Second)
+			if end, ok := t.Deadline(); ok && end.Before(deadline) {
+				deadline = end
+			}
+			ctx, cancel := context.WithDeadline(context.Background(), deadline)
+			defer cancel()
+			observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+				append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+				"go", "tool", "asm", "-o", object, source)
+			encoded, encodeErr := json.Marshal(observed)
+			if encodeErr != nil {
+				t.Fatal(encodeErr)
+			}
+			t.Logf("ORACLE_CHILD %s", encoded)
+			if !observed.Waited || observed.ExitCode != 1 || err == nil || ctx.Err() != nil {
+				t.Fatalf("actual Go symbol rejection absent: %+v %v", observed, err)
+			}
+			if !strings.Contains(string(observed.Stderr), "asm: "+source+":3: symbol probe redeclared") {
+				t.Fatalf("actual source-bound backend diagnostic absent: %s", observed.Stderr)
+			}
+			if failure := CheckOutcome(source, object, observed.Stdout, observed.Stderr,
+				err, ctx.Err(), false, 3, nil); failure != nil {
+				t.Fatal(failure)
+			}
+		})
+	}
+}
diff --git a/internal/goasmoracle/trailing_listing.go b/internal/goasmoracle/trailing_listing.go
new file mode 100644
index 000000000..6463c42b4
--- /dev/null
+++ b/internal/goasmoracle/trailing_listing.go
@@ -0,0 +1,54 @@
+package goasmoracle
+
+import (
+	"strings"
+	"text/scanner"
+)
+
+// SourceDiagnosticLineWithTrailingListing handles a separate backend layout:
+// asm: <PC> (<physical source>:<line>) <complete Prog>: <concrete error>.
+// Unlike the ordinary listing route, this has no preceding error to bind.
+// Only the selected matcher can authenticate both the Prog and trailing error;
+// the default diagnostic checker retains its original strict behavior.
+func SourceDiagnosticLineWithTrailingListing(source, output string, focus int,
+	match func(original, listing []string, detail string) bool) bool {
+	if focus < 0 || match == nil {
+		return false
+	}
+	data, valid := ReadSource(source)
+	if !valid {
+		return false
+	}
+	lines := strings.Split(string(data), "\n")
+	for _, line := range strings.Split(output, "\n") {
+		marker := strings.Index(line, "("+source+":")
+		if marker < 0 {
+			continue
+		}
+		prefix := strings.Fields(line[:marker])
+		if len(prefix) != 2 || prefix[0] != "asm:" || !canonicalPC(prefix[1]) {
+			continue
+		}
+		position := line[marker+1+len(source)+1:]
+		end := strings.IndexByte(position, ')')
+		if end < 0 {
+			continue
+		}
+		number, valid := positivePosition(position[:end])
+		if !valid || number > len(lines) || focus > 0 && number != focus ||
+			statementOpcode(lines[number-1]) == "" {
+			continue
+		}
+		instruction, message, found := strings.Cut(strings.TrimSpace(position[end+1:]), ": ")
+		if !found || instruction == "" || message == "" {
+			continue
+		}
+		original, sourceOK := diagnosticTokens(lines[number-1])
+		listing, listingOK := diagnosticTokens(instruction)
+		if sourceOK && listingOK && len(listing) > 0 &&
+			listing[0].kind == scanner.Ident && match(tokenTexts(original), tokenTexts(listing), message) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/goasmoracle/trailing_listing_test.go b/internal/goasmoracle/trailing_listing_test.go
new file mode 100644
index 000000000..9614ad715
--- /dev/null
+++ b/internal/goasmoracle/trailing_listing_test.go
@@ -0,0 +1,55 @@
+package goasmoracle
+
+import (
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestTrailingListingRequiresExactPhysicalStatement(t *testing.T) {
+	source, _ := oracleFixture(t)
+	if err := os.WriteFile(source, []byte("TEXT probe(SB),4,$3-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	output := "asm: 00001 (" + source + ":1) TEXT probe(SB), NOSPLIT, $3-0: concrete frame error\n"
+	wantOriginal := []string{"TEXT", "probe", "(", "SB", ")", ",", "4", ",", "$", "3", "-", "0"}
+	wantListing := []string{"TEXT", "probe", "(", "SB", ")", ",", "NOSPLIT", ",", "$", "3", "-", "0"}
+	match := func(original, listing []string, detail string) bool {
+		return reflect.DeepEqual(original, wantOriginal) && reflect.DeepEqual(listing, wantListing) &&
+			detail == "concrete frame error"
+	}
+	if !SourceDiagnosticLineWithTrailingListing(source, output, 1, match) {
+		t.Fatal("complete explicitly selected trailing diagnostic was lost")
+	}
+	if SourceDiagnosticLine(source, output, 1) || SourceDiagnosticLineWithListing(source, output, 1,
+		func(_, _ []string) bool { t.Fatal("ordinary matcher saw a bare backend prefix"); return true }) {
+		t.Fatal("default route acquired trailing-diagnostic authority")
+	}
+	for _, changed := range []string{
+		strings.Replace(output, source+":1", source+":2", 1),
+		strings.Replace(output, source+":1", "foreign"+source+":1", 1),
+		strings.Replace(output, source+":1", source+":01", 1),
+		strings.Replace(output, "00001", "1", 1),
+		strings.Replace(output, "asm: 00001", "00001", 1),
+		strings.Replace(output, "asm: 00001", "asm: unknown 00001", 1),
+		strings.Replace(output, "TEXT probe", "TEXT other", 1),
+		strings.Replace(output, "NOSPLIT, $3-0", "NOSPLIT", 1),
+		strings.Replace(output, ": concrete frame error", "", 1),
+		strings.Replace(output, "concrete frame error", "concrete /*hidden*/ frame error", 1),
+		strings.Replace(output, "concrete frame error", "unknown frame error", 1),
+	} {
+		if SourceDiagnosticLineWithTrailingListing(source, changed, 1, match) {
+			t.Errorf("changed complete trailing diagnostic acquired a role: %q", changed)
+		}
+	}
+	for _, focus := range []int{-1, 2} {
+		if SourceDiagnosticLineWithTrailingListing(source, output, focus, match) {
+			t.Errorf("wrong focus %d acquired a trailing role", focus)
+		}
+	}
+	if SourceDiagnosticLineWithTrailingListing(source, output, 1, nil) ||
+		SourceDiagnosticLineWithTrailingListing(source+".missing", output, 1, match) {
+		t.Fatal("missing matcher or physical source acquired a role")
+	}
+}
diff --git a/internal/goasmoracle/unknown_word_test.go b/internal/goasmoracle/unknown_word_test.go
new file mode 100644
index 000000000..5ac006f28
--- /dev/null
+++ b/internal/goasmoracle/unknown_word_test.go
@@ -0,0 +1,69 @@
+package goasmoracle
+
+import (
+	"fmt"
+	"os"
+	"testing"
+)
+
+// These fabricated joins exercise the observation schema, not Go acceptance,
+// instruction support or native execution. Actual Go is a separate fixture.
+func TestDiagnosticUnrecognizedInstructionWordAndDialect(t *testing.T) {
+	for _, test := range []struct {
+		name, body, message string
+		line, column, focus int
+		wasm, want          bool
+	}{
+		{"bare-word", "BAD_WORD", `unrecognized instruction "BAD_WORD"`, 2, 0, 2, false, true},
+		{"opcode-suffix-word", "BAD_WORD.EQ.S", `unrecognized instruction "BAD_WORD"`, 2, 0, 2, false, true},
+		{"opcode-suffix-not-whole-word", "BAD_WORD.EQ.S", `unrecognized instruction "BAD_WORD.EQ.S"`, 2, 0, 2, false, false},
+		{"bare-label-is-not-word", "first: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"default-suffix-label-is-not-word", "first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, false, false},
+		{"wasm-suffix-word", "first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, true},
+		{"wasm-after-label", "outer: first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, true},
+		{"default-after-label", "outer: first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, false, false},
+		{"unknown-after-label", "first: BAD_WORD", `unrecognized instruction "BAD_WORD"`, 2, 0, 2, false, true},
+		{"unknown-after-semicolon", "NOP; BAD_WORD", `unrecognized instruction "BAD_WORD"`, 2, 0, 2, false, true},
+		{"wasm-after-semicolon", "NOP; first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, true},
+		{"invalid-token-stops-parser", "1: NOP; first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"operand-token-is-not-word", "MOVQ $first,AX", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"string-token-is-not-word", `DATA blob<>+0(SB)/8,$"first.EQ.S"`, `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"comment-token-is-not-word", "// first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"multiline-comment-is-not-word", "/*\nfirst.EQ.S: NOP\n*/", `unrecognized instruction "first"`, 3, 0, 3, true, false},
+		{"malformed-comment", "/* first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"label-only-is-not-word", "first:", `unrecognized instruction "first"`, 2, 0, 2, true, false},
+		{"wrong-token", "first.EQ.S: NOP", `unrecognized instruction "other"`, 2, 0, 2, true, false},
+		{"full-suffix-is-not-word", "first.EQ.S: NOP", `unrecognized instruction "first.EQ.S"`, 2, 0, 2, true, false},
+		{"correct-column", "  first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 3, 2, true, true},
+		{"wrong-column", "  first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 4, 2, true, false},
+		{"out-of-range-column", "first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 999, 2, true, false},
+		{"wrong-physical-line", "first.EQ.S: NOP", `unrecognized instruction "first"`, 3, 0, 0, true, false},
+		{"wrong-focus", "first.EQ.S: NOP", `unrecognized instruction "first"`, 2, 0, 3, true, false},
+		{"unquoted-token", "first.EQ.S: NOP", "unrecognized instruction first", 2, 0, 2, true, false},
+		{"noncanonical-quote", "first.EQ.S: NOP", `unrecognized instruction "\x66irst"`, 2, 0, 2, true, false},
+		{"message-tail", "first.EQ.S: NOP", `unrecognized instruction "first" extra`, 2, 0, 2, true, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, _ := oracleFixture(t)
+			body := "TEXT Probe(SB),4,$0-0\n" + test.body + "\nRET\n"
+			if err := os.WriteFile(source, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			position := fmt.Sprintf("%d", test.line)
+			if test.column != 0 {
+				position += fmt.Sprintf(":%d", test.column)
+			}
+			output := source + ":" + position + ": " + test.message + "\n"
+			observe := SourceDiagnosticLine
+			if test.wasm {
+				observe = WasmSourceDiagnosticLine
+			}
+			if got := observe(source, output, test.focus); got != test.want {
+				t.Fatalf("original frontend word join=%t, want %t", got, test.want)
+			}
+			if observe(source, "foreign-"+output, test.focus) {
+				t.Fatal("foreign path prefix acquired the frontend word role")
+			}
+		})
+	}
+}
diff --git a/internal/goasmoracle/zero_operand_test.go b/internal/goasmoracle/zero_operand_test.go
new file mode 100644
index 000000000..129a99ed9
--- /dev/null
+++ b/internal/goasmoracle/zero_operand_test.go
@@ -0,0 +1,169 @@
+package goasmoracle
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestDiagnosticZeroOperandModeListings(t *testing.T) {
+	// This full ynone family covers mode-restricted P32/Py rows and their
+	// Pe word controls. Syntax/object observation grants no native execution.
+	want := map[string]string{
+		"LEAVEW": "Pe", "LEAVEL": "P32", "LEAVEQ": "Py",
+		"PUSHAW": "Pe", "PUSHAL": "P32",
+		"POPAW": "Pe", "POPAL": "P32",
+		"PUSHFW": "Pe", "PUSHFL": "P32", "PUSHFQ": "Py",
+		"POPFW": "Pe", "POPFL": "P32", "POPFQ": "Py",
+	}
+	table := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go")
+	data, ok := ReadSource(table)
+	if !ok {
+		t.Fatal("complete original Go x86 table unavailable")
+	}
+	rows := regexp.MustCompile(`(?m)^\s*\{A(LEAVE[WLQ]|PUSHA[WL]|POPA[WL]|PUSHF[WLQ]|POPF[WLQ]),\s*ynone,\s*(P32|Py|Pe),`).FindAllStringSubmatch(string(data), -1)
+	got := make(map[string]string)
+	for _, row := range rows {
+		if _, duplicate := got[row[1]]; duplicate {
+			t.Fatalf("duplicate original zero-operand table row: %q", row[0])
+		}
+		got[row[1]] = row[2]
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("complete original ynone family differs: got %v, want %v", got, want)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []string{"LEAVEW", "LEAVEL", "LEAVEQ", "PUSHAW", "PUSHAL", "POPAW", "POPAL", "PUSHFW", "PUSHFL", "PUSHFQ", "POPFW", "POPFL", "POPFQ"} {
+			t.Run(arch+"_"+opcode, func(t *testing.T) {
+				source, object := oracleFixture(t)
+				text := "TEXT probe(SB),$0-0\n\t" + opcode + "\n"
+				if strings.HasPrefix(opcode, "PUSHF") {
+					text += "\tPOPF" + strings.TrimPrefix(opcode, "PUSHF") + "\n"
+				} else if strings.HasPrefix(opcode, "POPF") {
+					text += "\tPUSHF" + strings.TrimPrefix(opcode, "POPF") + "\n"
+				}
+				text += "\tRET\n"
+				if err := os.WriteFile(source, []byte(text), 0600); err != nil {
+					t.Fatal(err)
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+				defer cancel()
+				observed, err := goasmcmd.Observe(ctx, filepath.Dir(source),
+					append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch),
+					"go", "tool", "asm", "-o", object, source)
+				encoded, _ := json.Marshal(observed)
+				t.Logf("ORACLE_CHILD %s", encoded)
+				accepted := !(arch == "amd64" && want[opcode] == "P32" || arch == "386" && want[opcode] == "Py")
+				exit := 1
+				if accepted {
+					exit = 0
+				}
+				if observed.ExitCode != exit || !observed.Waited {
+					t.Fatalf("actual original Go mode result differs: %+v %v", observed, err)
+				}
+				if !accepted {
+					bits := 64
+					if arch == "386" {
+						bits = 32
+					}
+					if !strings.Contains(string(observed.Stderr), fmt.Sprintf("asm: asmins: illegal in %d-bit mode:", bits)) ||
+						!strings.Contains(string(observed.Stderr), "("+source+":2)") {
+						t.Fatalf("no exact original mode listing: %+v", observed)
+					}
+				}
+				if failure := CheckOutcome(source, object, observed.Stdout, observed.Stderr, err,
+					ctx.Err(), accepted, 2, nil); failure != nil {
+					t.Fatalf("actual zero-operand source observation lost: %v", failure)
+				}
+				if !accepted {
+					for _, control := range []struct {
+						name           string
+						stdout, stderr []byte
+						cause          error
+						context        error
+					}{
+						{"foreign", nil, []byte(strings.ReplaceAll(string(observed.Stderr), "("+source+":2)", "(foreign"+source+":2)")), err, nil},
+						{"wrong-focus", nil, []byte(strings.ReplaceAll(string(observed.Stderr), "("+source+":2)", "("+source+":3)")), err, nil},
+						{"footer", nil, []byte("asm: assembly failed\n"), err, nil},
+						{"split-backend", []byte("asm: asmins: illegal in 64-bit mode:\n"), []byte("00000 (" + source + ":2) " + opcode + "\n"), err, nil},
+						{"joined-cleanup", observed.Stdout, observed.Stderr, errors.Join(err, errors.New("cleanup failed")), nil},
+						{"deadline", observed.Stdout, observed.Stderr, err, context.DeadlineExceeded},
+						{"panic", observed.Stdout, append(append([]byte(nil), observed.Stderr...), []byte("panic: assembler defect\n")...), err, nil},
+					} {
+						if CheckOutcome(source, object, control.stdout, control.stderr, control.cause,
+							control.context, false, 2, nil) == nil {
+							t.Fatalf("%s acquired a source rejection role", control.name)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestDiagnosticZeroOperandCompleteStatementBinding(t *testing.T) {
+	for _, test := range []struct {
+		name, statement, listing string
+		want                     bool
+	}{
+		{"zero", "LEAVEL", "LEAVEL", true},
+		{"zero-whitespace", "\tLEAVEL  ", "  LEAVEL  ", true},
+		{"line-comment", "LEAVEL // source comment", "LEAVEL", true},
+		{"block-comment", "LEAVEL /* source comment */", "LEAVEL", true},
+		{"suffix", "LEAVEQ.P", "LEAVEQ.P", true},
+		{"wrong-opcode", "LEAVEL", "LEAVEQ", false},
+		{"wrong-case", "LEAVEL", "leavel", false},
+		{"wrong-suffix", "LEAVEQ.P", "LEAVEQ", false},
+		{"truncated-registers", "MOVQ AX,BX", "MOVQ", false},
+		{"truncated-unary", "PUSHQ AX", "PUSHQ", false},
+		{"truncated-memory", "LEAVEW (AX)", "LEAVEW", false},
+		{"truncated-commented-operand", "MOVQ /* comment */ AX,BX", "MOVQ", false},
+		{"truncated-suffixed-operand", "MOVQ.P AX,BX", "MOVQ.P", false},
+		{"truncated-expression", "MOVQ $1+2,AX", "MOVQ", false},
+		{"truncated-empty-operand", "MOVQ ,", "MOVQ", false},
+		{"second-statement", "LEAVEL; RET", "LEAVEL", false},
+		{"operand-bearing-control", "MOVQ AX,BX", "MOVQ AX,BX", true},
+		{"label-only", "LEAVEL:", "LEAVEL", false},
+		{"label-prefix", "label: LEAVEL", "LEAVEL", false},
+		{"comment-only", "/* LEAVEL */", "LEAVEL", false},
+		{"malformed-comment", "LEAVEL /*", "LEAVEL", false},
+		{"no-opcode", "", "LEAVEL", false},
+		{"no-listing", "LEAVEL", "", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, _ := oracleFixture(t)
+			data := "TEXT probe(SB),$0-0\n" + test.statement + "\nRET\n"
+			if err := os.WriteFile(source, []byte(data), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if got := ListingBindsSource(source, "2", "00018", test.listing); got != test.want {
+				t.Fatalf("full source statement/listing bind=%t, want %t", got, test.want)
+			}
+			output := "asm: asmins: illegal in 32-bit mode: 00018 (" + source + ":2)\t" + test.listing + "\n"
+			if got := SourceDiagnosticLine(source, output, 2); got != test.want {
+				t.Fatalf("full diagnostic bind=%t, want %t", got, test.want)
+			}
+			for _, pc := range []string{"", "0", "0018", "000018", "-0018", "+0018", "0x012", "18446744073709551616"} {
+				if ListingBindsSource(source, "2", pc, test.listing) {
+					t.Fatalf("noncanonical listing PC acquired a role: %q", pc)
+				}
+			}
+			for _, position := range []string{"0", "-2", "02", "9999"} {
+				if ListingBindsSource(source, position, "00018", test.listing) {
+					t.Fatalf("noncanonical/foreign source line acquired a role: %q", position)
+				}
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86.go b/internal/goasmrules/x86.go
new file mode 100644
index 000000000..919daf101
--- /dev/null
+++ b/internal/goasmrules/x86.go
@@ -0,0 +1,127 @@
+// Package goasmrules reads the selected Go assembler's source rules for
+// independent coverage checks. These are inventories, not translation, runtime
+// or ABI certificates.
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// X86AVXRule retains a complete operand-class row and its opcode-specific
+// encoding table. Shared ytabs alone cannot establish broadcast, rounding,
+// SAE, zeroing, tuple widths or the actual encoding generation.
+type X86AVXRule struct {
+	Opcode         string   `json:"opcode"`
+	Ytab           string   `json:"ytab"`
+	Prefix         string   `json:"prefix"`
+	Classes        []string `json:"operand_classes"`
+	RowIndex       int      `json:"row_index"`
+	ZCase          string   `json:"zcase"`
+	ZOffset        int      `json:"zoffset"`
+	EncodingOffset int      `json:"encoding_offset"`
+	OpBytes        []string `json:"op_bytes"`
+}
+
+func LoadX86AVXRules(goroot string) ([]X86AVXRule, error) {
+	path := filepath.Join(goroot, "src", "cmd", "internal", "obj", "x86", "avx_optabs.go")
+	source, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read Go AVX rules: %w", err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "avx_optabs.go", source, 0)
+	if err != nil {
+		return nil, fmt.Errorf("parse Go AVX rules: %w", err)
+	}
+	return X86AVXRules(file)
+}
+
+// X86AVXRules preserves source row order, including rows with equal operand
+// classes or zero offsets. It intentionally does not infer frontend acceptance
+// or physical register identities from the table.
+func X86AVXRules(file *ast.File) ([]X86AVXRule, error) {
+	variables, err := x86TableVariables(file)
+	if err != nil {
+		return nil, err
+	}
+	entries := variables["avxOptab"]
+	if entries == nil {
+		return nil, fmt.Errorf("Go AVX source has no literal avxOptab")
+	}
+	var rules []X86AVXRule
+	for index, entry := range entries.Elts {
+		row, ok := entry.(*ast.CompositeLit)
+		if !ok {
+			return nil, fmt.Errorf("AVX entry %d is not a literal rule", index)
+		}
+		values, err := x86Fields(row, "as", "ytab", "prefix", "op")
+		if err != nil {
+			return nil, fmt.Errorf("AVX entry %d: %w", index, err)
+		}
+		opcode := expression(values[0])
+		ytab := expression(values[1])
+		prefix := expression(values[2])
+		encoding, ok := values[3].(*ast.CompositeLit)
+		if !strings.HasPrefix(opcode, "A") || len(opcode) < 2 || prefix == "" ||
+			!ok || expression(encoding.Type) != "opBytes" {
+			return nil, fmt.Errorf("AVX entry %d has an unrecognized opcode/prefix/encoding", index)
+		}
+		operands := variables[ytab]
+		if operands == nil || len(operands.Elts) == 0 {
+			return nil, fmt.Errorf("%s has no complete literal ytab %q", opcode, ytab)
+		}
+		data, err := x86EncodingBytes(encoding)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", opcode, err)
+		}
+		operandRows, err := x86OperandRules(operands)
+		if err != nil {
+			return nil, fmt.Errorf("%s/%s: %w", opcode, ytab, err)
+		}
+		offset := 0
+		for operandIndex, operand := range operandRows {
+			rules = append(rules, X86AVXRule{
+				Opcode: strings.TrimPrefix(opcode, "A"), Ytab: ytab, Prefix: prefix,
+				Classes: operand.classes, RowIndex: operandIndex, ZCase: operand.zcase,
+				ZOffset: operand.zoffset, EncodingOffset: offset,
+				OpBytes: append([]string(nil), data...),
+			})
+			offset += operand.zoffset
+		}
+	}
+	return rules, nil
+}
+
+func expression(value ast.Expr) string {
+	if value == nil {
+		return ""
+	}
+	var output bytes.Buffer
+	if err := format.Node(&output, token.NewFileSet(), value); err != nil {
+		return ""
+	}
+	return output.String()
+}
+
+func encodingExpression(value ast.Expr) bool {
+	switch node := value.(type) {
+	case *ast.Ident:
+		return true
+	case *ast.BasicLit:
+		_, err := strconv.ParseUint(node.Value, 0, 8)
+		return node.Kind == token.INT && err == nil
+	case *ast.ParenExpr:
+		return encodingExpression(node.X)
+	case *ast.BinaryExpr:
+		return node.Op == token.OR && encodingExpression(node.X) && encodingExpression(node.Y)
+	}
+	return false
+}
diff --git a/internal/goasmrules/x86_legacy.go b/internal/goasmrules/x86_legacy.go
new file mode 100644
index 000000000..9d192e5ad
--- /dev/null
+++ b/internal/goasmrules/x86_legacy.go
@@ -0,0 +1,285 @@
+package goasmrules
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// X86LegacyCatalog retains both ordered source tables, including their dummy,
+// nil-ytab and terminating entries. It is an encoder inventory, not a claim of
+// frontend acceptance, selected machine encoding, translation or execution.
+type X86LegacyCatalog struct {
+	OpBytesSize int               `json:"op_bytes_size"`
+	Optab       []X86LegacyOpcode `json:"optab"`
+	Movtab      []X86MoveRule     `json:"ymovtab"`
+}
+
+type X86LegacyOpcode struct {
+	Kind             string             `json:"kind"`
+	TableIndex       int                `json:"table_index"`
+	Opcode           string             `json:"opcode"`
+	OpcodeExpression string             `json:"opcode_expression"`
+	Ytab             string             `json:"ytab"`
+	Prefix           string             `json:"prefix"`
+	OpBytes          []string           `json:"op_bytes"`
+	EscapeAdjustment int                `json:"escape_adjustment"`
+	Rows             []X86LegacyOperand `json:"rows"`
+}
+
+type X86LegacyOperand struct {
+	RowIndex int      `json:"row_index"`
+	Classes  []string `json:"operand_classes"`
+	ZCase    string   `json:"zcase"`
+	ZOffset  int      `json:"zoffset"`
+	// UnmatchedOffset follows doasm's unmatched-row traversal, including xo
+	// for a leading 0x0f. It is not a final byte offset or row-selection proof:
+	// suffix/mode filters and zcase-specific consumption remain independent.
+	// Keep the complete opcode array; zoffset is not its row payload length.
+	UnmatchedOffset int `json:"unmatched_offset"`
+}
+
+type X86MoveRule struct {
+	Kind             string   `json:"kind"`
+	TableIndex       int      `json:"table_index"`
+	Opcode           string   `json:"opcode"`
+	OpcodeExpression string   `json:"opcode_expression"`
+	From             string   `json:"from"`
+	From3            string   `json:"from3"`
+	To               string   `json:"to"`
+	Code             string   `json:"code"`
+	OpBytes          []string `json:"op_bytes"`
+}
+
+func LoadX86LegacyRules(goroot string) (X86LegacyCatalog, error) {
+	path := filepath.Join(goroot, "src/cmd/internal/obj/x86/asm6.go")
+	file, err := parser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		return X86LegacyCatalog{}, fmt.Errorf("parse Go legacy rules: %w", err)
+	}
+	return X86LegacyRules(file)
+}
+
+func X86LegacyRules(file *ast.File) (X86LegacyCatalog, error) {
+	var result X86LegacyCatalog
+	variables, err := x86TableVariables(file)
+	if err != nil {
+		return result, err
+	}
+	constants := map[string]ast.Expr{}
+	for _, declaration := range file.Decls {
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		for _, spec := range general.Specs {
+			switch value := spec.(type) {
+			case *ast.TypeSpec:
+				if value.Name.Name == "opBytes" {
+					array, ok := value.Type.(*ast.ArrayType)
+					if !ok || expression(array.Elt) != "uint8" {
+						return result, fmt.Errorf("unrecognized opBytes type")
+					}
+					size, err := strconv.ParseUint(expression(array.Len), 0, 16)
+					if err != nil || size == 0 || result.OpBytesSize != 0 {
+						return result, fmt.Errorf("unrecognized or repeated opBytes capacity")
+					}
+					result.OpBytesSize = int(size)
+				}
+			case *ast.ValueSpec:
+				if general.Tok == token.CONST {
+					for i, name := range value.Names {
+						if i < len(value.Values) {
+							constants[name.Name] = value.Values[i]
+						}
+					}
+				}
+			}
+		}
+	}
+	optab, movtab := variables["optab"], variables["ymovtab"]
+	if result.OpBytesSize == 0 || optab == nil || expression(optab.Type) != "[...]Optab" || len(optab.Elts) < 2 ||
+		movtab == nil || expression(movtab.Type) != "[]movtab" || len(movtab.Elts) == 0 {
+		return result, fmt.Errorf("missing complete legacy table schema")
+	}
+	for index, node := range optab.Elts {
+		row, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return result, fmt.Errorf("optab entry %d is not literal", index)
+		}
+		values, err := x86Fields(row, "as", "ytab", "prefix", "op")
+		if err != nil {
+			return result, fmt.Errorf("optab entry %d: %w", index, err)
+		}
+		entry, err := readX86LegacyOpcode(values, index, result.OpBytesSize, variables, constants)
+		if err != nil {
+			return result, fmt.Errorf("optab entry %d: %w", index, err)
+		}
+		if (entry.Kind == "reserved") != (index == 0) || (entry.Kind == "sentinel") != (index == len(optab.Elts)-1) {
+			return result, fmt.Errorf("optab entry %d has misplaced/missing dummy or sentinel", index)
+		}
+		result.Optab = append(result.Optab, entry)
+	}
+	for index, node := range movtab.Elts {
+		row, ok := node.(*ast.CompositeLit)
+		if !ok {
+			return result, fmt.Errorf("ymovtab entry %d is not literal", index)
+		}
+		values, err := x86Fields(row, "as", "ft", "f3t", "tt", "code", "op")
+		if err != nil {
+			return result, fmt.Errorf("ymovtab entry %d: %w", index, err)
+		}
+		entry, err := readX86MoveRule(values, index)
+		if err != nil {
+			return result, fmt.Errorf("ymovtab entry %d: %w", index, err)
+		}
+		if err := x86MoveTableRowStructure(entry, index, len(movtab.Elts)); err != nil {
+			return result, err
+		}
+		result.Movtab = append(result.Movtab, entry)
+	}
+	return result, nil
+}
+
+// Captured catalogs and original AST reads share the same complete-table
+// structure. An excluded semantic group still cannot hide a forged sentinel.
+func x86MoveTableRowStructure(row X86MoveRule, index, count int) error {
+	if index < 0 || index >= count || row.TableIndex != index {
+		return fmt.Errorf("ymovtab entry %d lost its original table position", index)
+	}
+	if index == count-1 {
+		if row.Kind != "sentinel" || row.Opcode != "" || row.OpcodeExpression != "0" ||
+			row.From != "0" || row.From3 != "0" || row.To != "0" || row.Code != "0" || len(row.OpBytes) != 0 {
+			return fmt.Errorf("ymovtab entry %d lost its complete zero sentinel", index)
+		}
+	} else if row.Kind != "encoding" || row.Opcode == "" {
+		return fmt.Errorf("ymovtab entry %d is not an original encoding row", index)
+	}
+	return nil
+}
+
+func readX86LegacyOpcode(values []ast.Expr, index, capacity int, variables map[string]*ast.CompositeLit, constants map[string]ast.Expr) (X86LegacyOpcode, error) {
+	entry := X86LegacyOpcode{Kind: "encoding", TableIndex: index,
+		OpcodeExpression: expression(values[0]), Ytab: expression(values[1]), Prefix: expression(values[2])}
+	opcode, err := x86SourceOpcode(values[0])
+	if err != nil {
+		return entry, err
+	}
+	entry.Opcode = opcode
+	bytes, ok := values[3].(*ast.CompositeLit)
+	if !ok || expression(bytes.Type) != "opBytes" || len(bytes.Elts) > capacity {
+		return entry, fmt.Errorf("unrecognized opcode array")
+	}
+	entry.OpBytes, err = x86EncodingBytes(bytes)
+	if err != nil {
+		return entry, err
+	}
+	if _, ok := values[1].(*ast.Ident); !ok {
+		return entry, fmt.Errorf("unrecognized ytab reference")
+	}
+	if _, ok := values[2].(*ast.Ident); !ok && entry.Prefix != "0" {
+		return entry, fmt.Errorf("unrecognized prefix")
+	}
+	if opcode == "" || entry.OpcodeExpression == "obj.AXXX" {
+		if entry.Ytab != "nil" || entry.Prefix != "0" || len(entry.OpBytes) != 0 {
+			return entry, fmt.Errorf("nonzero dummy/sentinel")
+		}
+		entry.Kind = "sentinel"
+		if opcode != "" {
+			entry.Kind = "reserved"
+		}
+		return entry, nil
+	}
+	if entry.Ytab == "nil" {
+		entry.Kind = "special"
+		return entry, nil
+	}
+	rows, err := x86OperandRules(variables[entry.Ytab])
+	if err != nil {
+		return entry, fmt.Errorf("%s: %w", entry.Ytab, err)
+	}
+	if len(bytes.Elts) != 0 {
+		first := bytes.Elts[0]
+		if name, ok := first.(*ast.Ident); ok {
+			first = constants[name.Name]
+		}
+		value, err := strconv.ParseUint(expression(first), 0, 8)
+		if err != nil {
+			return entry, fmt.Errorf("cannot observe leading opcode byte for xo")
+		}
+		if value == 0x0f {
+			entry.EscapeAdjustment = 1
+		}
+	}
+	offset := 0
+	for index, row := range rows {
+		entry.Rows = append(entry.Rows, X86LegacyOperand{RowIndex: index, Classes: row.classes,
+			ZCase: row.zcase, ZOffset: row.zoffset, UnmatchedOffset: offset})
+		offset += row.zoffset + entry.EscapeAdjustment
+	}
+	return entry, nil
+}
+
+func readX86MoveRule(values []ast.Expr, index int) (X86MoveRule, error) {
+	entry := X86MoveRule{Kind: "encoding", TableIndex: index, OpcodeExpression: expression(values[0]),
+		From: expression(values[1]), From3: expression(values[2]), To: expression(values[3]), Code: expression(values[4])}
+	opcode, err := x86SourceOpcode(values[0])
+	if err != nil {
+		return entry, err
+	}
+	entry.Opcode = opcode
+	bytes, ok := values[5].(*ast.CompositeLit)
+	if !ok || expression(bytes.Type) != "[4]uint8" || len(bytes.Elts) > 4 {
+		return entry, fmt.Errorf("unrecognized move opcode array")
+	}
+	entry.OpBytes, err = x86EncodingBytes(bytes)
+	if err != nil {
+		return entry, err
+	}
+	for _, value := range values[1:5] {
+		if opcode == "" {
+			if expression(value) != "0" {
+				return entry, fmt.Errorf("nonzero movtab sentinel")
+			}
+		} else if _, ok := value.(*ast.Ident); !ok {
+			return entry, fmt.Errorf("unrecognized move role/code")
+		}
+	}
+	if opcode == "" {
+		if len(entry.OpBytes) != 0 {
+			return entry, fmt.Errorf("nonzero movtab sentinel bytes")
+		}
+		entry.Kind = "sentinel"
+	}
+	return entry, nil
+}
+
+func x86SourceOpcode(value ast.Expr) (string, error) {
+	name := expression(value)
+	if name == "0" {
+		return "", nil
+	}
+	if selector, ok := value.(*ast.SelectorExpr); ok {
+		if expression(selector.X) != "obj" {
+			return "", fmt.Errorf("foreign opcode %s", name)
+		}
+		name = selector.Sel.Name
+	} else if _, ok := value.(*ast.Ident); !ok {
+		return "", fmt.Errorf("unrecognized opcode %s", name)
+	}
+	return x86SourceOpcodeName(name)
+}
+
+// Keep captured enum spelling and its canonical opcode on one conversion
+// path. Source projections may validate this redundant identity without
+// reparsing expressions or introducing another opcode-name registry.
+func x86SourceOpcodeName(name string) (string, error) {
+	if !strings.HasPrefix(name, "A") || len(name) == 1 {
+		return "", fmt.Errorf("unrecognized opcode %s", name)
+	}
+	return name[1:], nil
+}
diff --git a/internal/goasmrules/x86_legacy_test.go b/internal/goasmrules/x86_legacy_test.go
new file mode 100644
index 000000000..b85eebf17
--- /dev/null
+++ b/internal/goasmrules/x86_legacy_test.go
@@ -0,0 +1,226 @@
+package goasmrules
+
+import (
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const legacyRulesFixture = `package x86
+type opBytes [31]uint8
+const Pm = 0x0f
+var shared = []ytab{
+	{Zm_r, 0, argList{Yml, Yrl}},
+	{Zm_r, 2, argList{Yml, Yrl}},
+	{Zr_m, 1, argList{Yrl, Yml}},
+}
+var pseudo = []ytab{{Zpseudo, 0, argList{}}}
+var optab = [...]Optab{
+	{obj.AXXX, nil, 0, opBytes{}},
+	{ATEST, shared, Px, opBytes{0x0f, 0x01, 0x02, 0x03, 0x04}},
+	{AOTHER, shared, Px1, opBytes{0x83, 0x01, 0x02, 0x03}},
+	{obj.ATEXT, pseudo, Px, opBytes{}},
+	{AENTER, nil, 0, opBytes{}},
+	{0, nil, 0, opBytes{}},
+}
+var ymovtab = []movtab{
+	{AMOVW, Yml, Ynone, Ytask, movMemReg2op, [4]uint8{0x0f, 0x00, 3, 0}},
+	{AMOVW, Yml, Ynone, Ytask, movMemReg2op, [4]uint8{0x0f, 0x00, 3, 0}},
+	{0, 0, 0, 0, 0, [4]uint8{}},
+}
+`
+
+func parseLegacyRulesFixture(t *testing.T, source string) *ast.File {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), "asm6.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file
+}
+
+func TestX86LegacyRulesPreserveCompleteEntriesAndOffsets(t *testing.T) {
+	got, err := X86LegacyRules(parseLegacyRulesFixture(t, legacyRulesFixture))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.OpBytesSize != 31 || len(got.Optab) != 6 || len(got.Movtab) != 3 {
+		t.Fatal("lost original table entries or array capacity", got)
+	}
+	for index, kind := range []string{"reserved", "encoding", "encoding", "encoding", "special", "sentinel"} {
+		entry := got.Optab[index]
+		if entry.Kind != kind || entry.TableIndex != index {
+			t.Fatal("lost source order or explicit classification", entry)
+		}
+	}
+	if got.Optab[3].Opcode != "TEXT" || got.Optab[3].OpcodeExpression != "obj.ATEXT" ||
+		len(got.Optab[3].Rows) != 1 || got.Optab[3].Rows[0].ZCase != "Zpseudo" ||
+		len(got.Optab[3].Rows[0].Classes) != 0 || len(got.Optab[3].OpBytes) != 0 {
+		t.Fatal("pseudo/no-operand/implicit-zero roles collapsed", got.Optab[3])
+	}
+	for index, wantOffsets := range [][]int{{0, 1, 4}, {0, 0, 2}} {
+		entry := got.Optab[index+1]
+		if entry.EscapeAdjustment != 1-index || entry.Ytab != "shared" || len(entry.Rows) != 3 {
+			t.Fatal("lost shared table or leading 0x0f adjustment", entry)
+		}
+		for rowIndex, offset := range wantOffsets {
+			row := entry.Rows[rowIndex]
+			if row.RowIndex != rowIndex || row.UnmatchedOffset != offset {
+				t.Fatal("legacy skip offset differs from original encoder", row)
+			}
+		}
+		if !reflect.DeepEqual(entry.Rows[0].Classes, entry.Rows[1].Classes) {
+			t.Fatal("duplicate operand rows were dropped")
+		}
+	}
+	if !reflect.DeepEqual(got.Optab[1].OpBytes, []string{"0x0f", "0x01", "0x02", "0x03", "0x04"}) {
+		t.Fatal("zoffset incorrectly cropped the opcode data", got.Optab[1])
+	}
+	for index, row := range got.Movtab {
+		if row.TableIndex != index {
+			t.Fatal("movtab source order lost", row)
+		}
+	}
+	move := got.Movtab[0]
+	if move.Kind != "encoding" || move.From != "Yml" || move.From3 != "Ynone" || move.To != "Ytask" ||
+		move.Code != "movMemReg2op" || !reflect.DeepEqual(move.OpBytes, []string{"0x0f", "0x00", "3", "0"}) ||
+		got.Movtab[2].Kind != "sentinel" {
+		t.Fatal("movtab roles/code/complete bytes were lost", got.Movtab)
+	}
+}
+
+func TestX86LegacyRulesObserveEveryEncodingAttribute(t *testing.T) {
+	before, err := X86LegacyRules(parseLegacyRulesFixture(t, legacyRulesFixture))
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := json.Marshal(before)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []struct{ before, after string }{
+		{"{Zm_r, 0", "{Zm_r, 1"},
+		{"{Zm_r, 0", "{Zr_m, 0"},
+		{"Yml, Yrl", "Yxm, Yxr"},
+		{"shared, Px,", "shared, P32,"},
+		{"0x04}", "0x05}"},
+		{"Yml, Ynone, Ytask", "Yml, Yrl, Ytask"},
+		{"movMemReg2op,", "movRegMem2op,"},
+		{"0x00, 3, 0", "0x00, 4, 0"},
+	} {
+		t.Run(mutation.after, func(t *testing.T) {
+			changed := strings.Replace(legacyRulesFixture, mutation.before, mutation.after, 1)
+			got, err := X86LegacyRules(parseLegacyRulesFixture(t, changed))
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := json.Marshal(got)
+			if err != nil || string(data) == string(original) {
+				t.Fatal("original encoding attribute disappeared", err)
+			}
+		})
+	}
+	aliased := strings.Replace(legacyRulesFixture, "opBytes{0x0f", "opBytes{Pm", 1)
+	got, err := X86LegacyRules(parseLegacyRulesFixture(t, aliased))
+	if err != nil || got.Optab[1].EscapeAdjustment != 1 {
+		t.Fatal("xo lost the actual named byte value", got, err)
+	}
+	keyed := strings.Replace(legacyRulesFixture,
+		"{Zm_r, 0, argList{Yml, Yrl}}", "{args: argList{Yml, Yrl}, zoffset: 0, zcase: Zm_r}", 1)
+	got, err = X86LegacyRules(parseLegacyRulesFixture(t, keyed))
+	if err != nil || !reflect.DeepEqual(got, before) {
+		t.Fatal("keyed and positional source rules differ", got, err)
+	}
+}
+
+func TestX86LegacyRulesFailClosedOnUnknownSource(t *testing.T) {
+	for _, mutation := range []struct{ before, after string }{
+		{"var optab", "var unknown"},
+		{"var optab", "var shared = []ytab{{Zm_r, 1, argList{Yml, Yrl}}}; var optab"},
+		{"var ymovtab", "var unknown"},
+		{"[31]uint8", "[30+1]uint8"},
+		{"ATEST, shared", "ATEST, missing"},
+		{"ATEST, shared", "external.ATEST, shared"},
+		{"{Zm_r, 0, argList", "{Zm_r, 0, extra, argList"},
+		{"{Zm_r, 0, argList{Yml, Yrl}}", "{zcase: Zm_r, zoffset: 0, extra: argList{Yml, Yrl}}"},
+		{"{Zm_r, 0, argList{Yml, Yrl}}", "{zcase: Zm_r, zcase: Zr_m, args: argList{Yml, Yrl}}"},
+		{"{Zm_r, 0, argList{Yml, Yrl}}", "{zcase: Zm_r, 0, argList{Yml, Yrl}}"},
+		{"{Zm_r, 0, argList", "{Zm_r, 1+1, argList"},
+		{"argList{Yml, Yrl}", "argList{operand(), Yrl}"},
+		{"Px, opBytes{0x0f", "Px, opBytes{makeByte()"},
+		{"Px, opBytes{0x0f", "Px, opBytes{256"},
+		{"{AENTER, nil, 0, opBytes{}}", "{AENTER, absent, 0, opBytes{}}"},
+		{"{0, nil, 0, opBytes{}}", "{0, nil, 1, opBytes{}}"},
+		{"{0, nil, 0, opBytes{}}", "{0, nil, 0, opBytes{1}}"},
+		{"{0, nil, 0, opBytes{}},", "{0, nil, 0, opBytes{}}, {AENTER, nil, 0, opBytes{}},"},
+		{"{obj.AXXX, nil, 0, opBytes{}}", "{AENTER, nil, 0, opBytes{}}"},
+		{"{0, 0, 0, 0, 0, [4]uint8{}}", "{0, Ynone, 0, 0, 0, [4]uint8{}}"},
+		{"[4]uint8{0x0f", "[5]uint8{0x0f"},
+		{"movMemReg2op,", "computeCode(),"},
+		{"Yml, Ynone, Ytask", "Yml, role(), Ytask"},
+	} {
+		t.Run(mutation.after, func(t *testing.T) {
+			changed := strings.Replace(legacyRulesFixture, mutation.before, mutation.after, 1)
+			if changed == legacyRulesFixture {
+				t.Fatal("ineffective mutation")
+			}
+			if _, err := X86LegacyRules(parseLegacyRulesFixture(t, changed)); err == nil {
+				t.Fatal("unrecognized or incomplete source was accepted")
+			}
+		})
+	}
+}
+
+func TestX86LegacyRulesRetainEveryActualSourceRow(t *testing.T) {
+	got, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file := parseLegacyRulesFixture(t, string(source))
+	// Independently count actual AST literals, without the reader's field,
+	// variable-index or row helpers and without a production opcode registry.
+	variables := map[string]*ast.CompositeLit{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if ok && len(value.Names) == 1 && len(value.Values) == 1 {
+			if literal, ok := value.Values[0].(*ast.CompositeLit); ok {
+				variables[value.Names[0].Name] = literal
+			}
+		}
+		return true
+	})
+	if len(got.Optab) != len(variables["optab"].Elts) || len(got.Movtab) != len(variables["ymovtab"].Elts) {
+		t.Fatal("original table entry lost")
+	}
+	rows := 0
+	for index, node := range variables["optab"].Elts {
+		entry := node.(*ast.CompositeLit)
+		table := entry.Elts[1].(*ast.Ident).Name
+		if table == "nil" {
+			if len(got.Optab[index].Rows) != 0 || got.Optab[index].Kind == "encoding" {
+				t.Fatal("special table invented rows", got.Optab[index])
+			}
+			continue
+		}
+		want := len(variables[table].Elts)
+		if len(got.Optab[index].Rows) != want || got.Optab[index].TableIndex != index {
+			t.Fatal("lost shared or repeated operand rows", table, want, got.Optab[index])
+		}
+		rows += want
+	}
+	if rows < 1000 || len(got.Movtab) < 100 {
+		t.Fatal("unexpectedly small original legacy inventory", rows, len(got.Movtab))
+	}
+	t.Logf("retained %d optab entries/%d operand rows and %d movtab entries, including explicit sentinels; inventory only", len(got.Optab), rows, len(got.Movtab))
+}
diff --git a/internal/goasmrules/x86_source.go b/internal/goasmrules/x86_source.go
new file mode 100644
index 000000000..e89dea95d
--- /dev/null
+++ b/internal/goasmrules/x86_source.go
@@ -0,0 +1,118 @@
+package goasmrules
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+	"strconv"
+)
+
+func x86TableVariables(file *ast.File) (map[string]*ast.CompositeLit, error) {
+	variables := map[string]*ast.CompositeLit{}
+	seen := map[string]bool{}
+	for _, declaration := range file.Decls {
+		general, ok := declaration.(*ast.GenDecl)
+		if !ok || general.Tok != token.VAR {
+			continue
+		}
+		for _, spec := range general.Specs {
+			value := spec.(*ast.ValueSpec)
+			for i, name := range value.Names {
+				if name.Name != "_" && seen[name.Name] {
+					return nil, fmt.Errorf("duplicate source variable %s", name.Name)
+				}
+				seen[name.Name] = true
+				if i < len(value.Values) {
+					if literal, ok := value.Values[i].(*ast.CompositeLit); ok {
+						variables[name.Name] = literal
+					}
+				}
+			}
+		}
+	}
+	return variables, nil
+}
+
+// Require the complete known schema. Missing, duplicate, mixed or additional
+// fields must not silently disappear from an independent rule inventory.
+func x86Fields(row *ast.CompositeLit, names ...string) ([]ast.Expr, error) {
+	if len(row.Elts) != len(names) {
+		return nil, fmt.Errorf("expected %d fields, found %d", len(names), len(row.Elts))
+	}
+	values := make([]ast.Expr, len(names))
+	_, keyed := row.Elts[0].(*ast.KeyValueExpr)
+	for index, entry := range row.Elts {
+		pair, isKeyed := entry.(*ast.KeyValueExpr)
+		if keyed != isKeyed {
+			return nil, fmt.Errorf("mixed named and positional fields")
+		}
+		if !keyed {
+			values[index] = entry
+			continue
+		}
+		found := false
+		for i, name := range names {
+			if expression(pair.Key) == name {
+				if values[i] != nil {
+					return nil, fmt.Errorf("duplicate field %s", name)
+				}
+				values[i], found = pair.Value, true
+				break
+			}
+		}
+		if !found {
+			return nil, fmt.Errorf("unknown field %s", expression(pair.Key))
+		}
+	}
+	return values, nil
+}
+
+type x86OperandRule struct {
+	classes []string
+	zcase   string
+	zoffset int
+}
+
+func x86OperandRules(literal *ast.CompositeLit) ([]x86OperandRule, error) {
+	if literal == nil || expression(literal.Type) != "[]ytab" || len(literal.Elts) == 0 {
+		return nil, fmt.Errorf("no nonempty literal []ytab")
+	}
+	var rows []x86OperandRule
+	for index, entry := range literal.Elts {
+		row, ok := entry.(*ast.CompositeLit)
+		if !ok {
+			return nil, fmt.Errorf("ytab row %d is not literal", index)
+		}
+		values, err := x86Fields(row, "zcase", "zoffset", "args")
+		if err != nil {
+			return nil, fmt.Errorf("ytab row %d: %w", index, err)
+		}
+		zcase, named := values[0].(*ast.Ident)
+		advance, err := strconv.ParseUint(expression(values[1]), 0, 8)
+		args, ok := values[2].(*ast.CompositeLit)
+		if !named || err != nil || !ok || expression(args.Type) != "argList" {
+			return nil, fmt.Errorf("ytab row %d has unrecognized rules", index)
+		}
+		classes := make([]string, 0, len(args.Elts))
+		for _, arg := range args.Elts {
+			name, ok := arg.(*ast.Ident)
+			if !ok {
+				return nil, fmt.Errorf("ytab row %d has non-identifier operand class", index)
+			}
+			classes = append(classes, name.Name)
+		}
+		rows = append(rows, x86OperandRule{classes, zcase.Name, int(advance)})
+	}
+	return rows, nil
+}
+
+func x86EncodingBytes(literal *ast.CompositeLit) ([]string, error) {
+	data := make([]string, 0, len(literal.Elts))
+	for _, value := range literal.Elts {
+		if !encodingExpression(value) {
+			return nil, fmt.Errorf("unsupported encoding expression %q", expression(value))
+		}
+		data = append(data, expression(value))
+	}
+	return data, nil
+}
diff --git a/internal/goasmrules/x86_test.go b/internal/goasmrules/x86_test.go
new file mode 100644
index 000000000..efad6e9f1
--- /dev/null
+++ b/internal/goasmrules/x86_test.go
@@ -0,0 +1,158 @@
+package goasmrules
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86AVXRulesRetainAllActualSourceRows(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "original.go", source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var entries *ast.CompositeLit
+	rowCounts := map[string]int{}
+	ast.Inspect(file, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+			return true
+		}
+		literal, ok := value.Values[0].(*ast.CompositeLit)
+		if !ok {
+			return true
+		}
+		rowCounts[value.Names[0].Name] = len(literal.Elts)
+		if value.Names[0].Name == "avxOptab" {
+			entries = literal
+		}
+		return true
+	})
+	if entries == nil {
+		t.Fatal("actual Go source lacks avxOptab")
+	}
+	want := 0
+	for _, entry := range entries.Elts {
+		row := entry.(*ast.CompositeLit)
+		var table string
+		for _, entry := range row.Elts {
+			if pair, ok := entry.(*ast.KeyValueExpr); ok && pair.Key.(*ast.Ident).Name == "ytab" {
+				table = pair.Value.(*ast.Ident).Name
+			}
+		}
+		if table == "" && len(row.Elts) > 1 {
+			if name, ok := row.Elts[1].(*ast.Ident); ok {
+				table = name.Name
+			}
+		}
+		if rowCounts[table] == 0 {
+			t.Fatalf("actual opcode has an unbound ytab %q", table)
+		}
+		want += rowCounts[table]
+	}
+	if len(rules) != want || want < 1000 {
+		t.Fatalf("lost original encoder rules: got %d, source defines %d", len(rules), want)
+	}
+	for _, rule := range rules {
+		if rule.Opcode == "" || rule.Prefix == "" || rule.ZCase == "" || rule.Classes == nil || len(rule.OpBytes) == 0 {
+			t.Fatalf("incomplete actual source rule: %+v", rule)
+		}
+	}
+	t.Logf("all %d original AVX operand/encoding rules retained", want)
+}
+
+func TestX86AVXRulesRejectUnrecognizedSourceInsteadOfDroppingIt(t *testing.T) {
+	const source = `package x86
+var operands = []ytab{{zcase: Zvex_rm_v_r, zoffset: 2, args: argList{Yxm, Yxr, Yxr}}}
+var avxOptab = []Optab{{as: AVXORPS, ytab: operands, prefix: Pavx, op: opBytes{vex128 | vex66, 0x57}}}
+`
+	for _, mutation := range []struct{ before, after string }{
+		{"var avxOptab", "var other"},
+		{"ytab: operands", "ytab: absent"},
+		{"prefix: Pavx,", ""},
+		{"zoffset: 2", "zoffset: 1+1"},
+		{"args: argList", "args: unknown"},
+		{"vex128 | vex66", "makePrefix()"},
+		{"0x57", "256"},
+		{"Yxm, Yxr, Yxr", "operand(), Yxr, Yxr"},
+	} {
+		t.Run(mutation.before, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), "fixture.go", strings.Replace(source, mutation.before, mutation.after, 1), 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := X86AVXRules(file); err == nil {
+				t.Fatal("unrecognized rule was silently inventoried")
+			}
+		})
+	}
+}
+
+func TestX86PackedBinaryWitnessesFollowCompleteCurrentTable(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	opcodes := map[string]bool{}
+	rows, witnesses := 0, 0
+	for _, rule := range rules {
+		if rule.Ytab != "_yvandnpd" {
+			continue
+		}
+		cases, err := X86PackedBinarySyntaxWitnesses(rule)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(cases) < 2 {
+			t.Fatal("every rule requires register and memory witnesses")
+		}
+		opcodes[rule.Opcode] = true
+		rows++
+		witnesses += len(cases)
+	}
+	if len(opcodes) < 60 || rows != len(opcodes)*8 {
+		t.Fatalf("unexpected complete packed-binary denominator: %d opcodes/%d rules", len(opcodes), rows)
+	}
+	t.Logf("generated %d source-syntax witnesses from all %d rules/%d opcodes; not object/runtime coverage", witnesses, rows, len(opcodes))
+}
+
+func TestX86PackedBinaryWitnessesKeepAttributesIndependent(t *testing.T) {
+	rule := X86AVXRule{
+		Opcode: "VPMULLW", Ytab: "_yvandnpd", Prefix: "Pavx",
+		Classes: []string{"Yzm", "Yzr", "Yknot0", "Yzr"}, ZCase: "Zevex_rm_v_k_r",
+		OpBytes: []string{"avxEscape | evex512 | evex66 | evex0F | evexW0", "evexN64 | evexZeroingEnabled", "0xD5"},
+	}
+	want := []string{"VPMULLW Z0,Z1,K1,Z2", "VPMULLW.Z Z0,Z1,K1,Z2", "VPMULLW (AX),Z1,K1,Z2", "VPMULLW.Z (AX),Z1,K1,Z2"}
+	got, err := X86PackedBinarySyntaxWitnesses(rule)
+	if err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("complete zeroing witness: %v/%v", got, err)
+	}
+	rule.OpBytes[1] += " | evexBcstN4"
+	got, err = X86PackedBinarySyntaxWitnesses(rule)
+	want = append(want, "VPMULLW.BCST (AX),Z1,K1,Z2", "VPMULLW.BCST.Z (AX),Z1,K1,Z2")
+	if err != nil || !reflect.DeepEqual(got, want) {
+		t.Fatalf("independent broadcast witness: %v/%v", got, err)
+	}
+	for _, attribute := range []string{"evexRoundingEnabled", "evexSaeEnabled"} {
+		local := rule
+		local.OpBytes = append([]string(nil), rule.OpBytes...)
+		local.OpBytes[1] += " | " + attribute
+		if _, err := X86PackedBinarySyntaxWitnesses(local); err == nil {
+			t.Fatal("future unaudited suffix silently disappeared")
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness.go b/internal/goasmrules/x86_witness.go
new file mode 100644
index 000000000..69388302d
--- /dev/null
+++ b/internal/goasmrules/x86_witness.go
@@ -0,0 +1,311 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strings"
+)
+
+// X86PackedBinarySyntaxWitnesses expands the complete _yvandnpd grammar used
+// by packed binary families. These are source-syntax candidates: low-bank X/Y
+// spellings can select VEX even when an EVEX table row also matches. Actual Go
+// objects and semantic oracles must independently establish encoding identity.
+// Frontend architecture restrictions are likewise checked by the actual Go
+// assembler, never silently pruned here.
+func X86PackedBinarySyntaxWitnesses(rule X86AVXRule) ([]string, error) {
+	if rule.Ytab != "_yvandnpd" {
+		return nil, fmt.Errorf("%s is outside the audited packed binary table grammar", rule.Opcode)
+	}
+	return x86PackedBinarySyntaxWitnesses(rule)
+}
+
+func x86PackedBinarySyntaxWitnesses(rule X86AVXRule) ([]string, error) {
+	return x86PackedSyntaxWitnesses(rule, false)
+}
+
+func x86PackedMoveTable(table string) bool {
+	return table == "_yvmovdqa" || table == "_yvmovapd" || table == "_yvmovdqa32"
+}
+
+func x86PackedMoveStoreRow(rule X86AVXRule) bool {
+	return x86PackedMoveTable(rule.Ytab) && (rule.ZCase == "Zvex_r_v_rm" ||
+		rule.ZCase == "Zevex_r_v_rm" || rule.ZCase == "Zevex_r_k_rm")
+}
+
+// These three original ytabs share count transport, independently of mnemonic,
+// lane width and numerical shift semantics. Encoding values remain in OpBytes.
+func x86PackedUniformShiftTable(table string) bool {
+	return table == "_yvpslld" || table == "_yvpsraq" || table == "_yvpslldq"
+}
+
+func x86PackedImmediateExtensionRow(rule X86AVXRule) bool {
+	return (x86PackedUniformShiftTable(rule.Ytab) || rule.Ytab == "_yvprold") && (rule.ZCase == "Zvex_i_rm_vo" ||
+		rule.ZCase == "Zevex_i_rm_vo" || rule.ZCase == "Zevex_i_rm_k_vo")
+}
+
+func x86PackedImmediateRegisterRow(rule X86AVXRule) bool {
+	return rule.Ytab == "_yvpshufd" && (rule.ZCase == "Zvex_i_rm_r" ||
+		rule.ZCase == "Zevex_i_rm_r" || rule.ZCase == "Zevex_i_rm_k_r")
+}
+
+// Integer widening spells both element sizes in its BW/BD/BQ/WD/WQ/DQ
+// suffix. Keep that ratio independent of the register carrier's capacity;
+// an X source alone cannot distinguish m2/m4/m8/m16 tuples.
+func x86PackedWideningRatio(rule X86AVXRule) int {
+	name := rule.Opcode
+	if len(name) != 9 || !strings.HasPrefix(name, "VPMOVSX") && !strings.HasPrefix(name, "VPMOVZX") {
+		return 0
+	}
+	input, output := strings.IndexByte("BWDQ", name[7]), strings.IndexByte("BWDQ", name[8])
+	if input < 0 || output <= input {
+		return 0
+	}
+	ratio := 1 << (output - input)
+	table := "_yvbroadcastss"
+	if ratio == 2 {
+		table = "_yvcvtdq2pd"
+	}
+	if rule.Ytab != table {
+		return 0
+	}
+	return ratio
+}
+
+func x86PackedWideningSource(destinationBytes, ratio int, evex bool) (string, int) {
+	tuple, class := destinationBytes/ratio, "Yxm"
+	if tuple > 16 {
+		class = "Yym"
+	}
+	if evex {
+		class += "Evex"
+	}
+	return class, tuple
+}
+
+func x86PackedSyntaxWitnesses(rule X86AVXRule, unary bool) ([]string, error) {
+	move, store := x86PackedMoveTable(rule.Ytab), x86PackedMoveStoreRow(rule)
+	shift, extension := x86PackedUniformShiftTable(rule.Ytab), x86PackedImmediateExtensionRow(rule)
+	registerImmediate := x86PackedImmediateRegisterRow(rule)
+	widening := x86PackedWideningRatio(rule)
+	immediate := extension || registerImmediate
+	scalar := rule.Ytab == "_yvaddsd" || rule.Ytab == "_yvgetexpsd"
+	floating := rule.Ytab == "_yvaddpd" || scalar
+	binaryTable := rule.Ytab == "_yvandnpd" || rule.Ytab == "_yvblendmpd" ||
+		rule.Ytab == "_yvaddsubpd" || rule.Ytab == "_yvpcmpeqb" || rule.Ytab == "_yvprold" || floating || shift
+	unaryTable := rule.Ytab == "_yvmovddup" || rule.Ytab == "_yvexpandpd" || move || registerImmediate || widening != 0
+	if (!unary && !binaryTable || unary && !unaryTable) || rule.Prefix != "Pavx" {
+		return nil, fmt.Errorf("%s is outside the audited packed vector table grammar", rule.Opcode)
+	}
+	maskCase := "Zevex_rm_v_k_r"
+	if immediate {
+		maskCase = "Zevex_i_rm_k_vo"
+	}
+	if registerImmediate {
+		maskCase = "Zevex_i_rm_k_r"
+	}
+	if unary && !immediate {
+		maskCase = "Zevex_rm_k_r"
+	}
+	if store {
+		maskCase = "Zevex_r_k_rm"
+	}
+	masked := rule.ZCase == maskCase
+	evex := masked || rule.ZCase == "Zevex_rm_v_r" || store && rule.ZCase == "Zevex_r_v_rm" ||
+		extension && rule.ZCase == "Zevex_i_rm_vo" || registerImmediate && rule.ZCase == "Zevex_i_rm_r"
+	if scalar {
+		row := 0
+		if rule.Ytab == "_yvaddsd" && evex {
+			row++
+		}
+		if masked {
+			row++
+		}
+		if rule.RowIndex != row {
+			return nil, fmt.Errorf("scalar source row ordinal differs from its encoding/mask transport")
+		}
+	}
+	if rule.Ytab == "_yvprold" && (!immediate || !evex) {
+		return nil, fmt.Errorf("packed immediate rotates require an EVEX immediate format")
+	}
+	if rule.Ytab == "_yvpslldq" && (!immediate || masked) {
+		return nil, fmt.Errorf("per-128-bit byte shifts require an unmasked immediate format")
+	}
+	maskResult := rule.Ytab == "_yvpcmpeqb" && evex
+	if (rule.Ytab == "_yvaddsubpd" || rule.Ytab == "_yvmovdqa") && evex ||
+		(rule.Ytab == "_yvexpandpd" || rule.Ytab == "_yvmovdqa32" || rule.Ytab == "_yvpsraq" || rule.Ytab == "_yvgetexpsd") && !evex {
+		return nil, fmt.Errorf("%s encoding generation differs from its packed table", rule.Opcode)
+	}
+	if !evex && rule.ZCase != "Zvex_rm_v_r" && !(store && rule.ZCase == "Zvex_r_v_rm") &&
+		!(extension && rule.ZCase == "Zvex_i_rm_vo") && !(registerImmediate && rule.ZCase == "Zvex_i_rm_r") {
+		return nil, fmt.Errorf("%s has an unmodeled packed vector zcase %s", rule.Opcode, rule.ZCase)
+	}
+	count := 3
+	if masked {
+		count = 4
+	}
+	if unary && !immediate {
+		count--
+	}
+	if len(rule.Classes) != count {
+		return nil, fmt.Errorf("%s packed vector arity differs from its zcase", rule.Opcode)
+	}
+	bank := ""
+	for _, candidate := range []struct {
+		memory, register, bank string
+	}{
+		{"Yxm", "Yxr", "X"},
+		{"Yym", "Yyr", "Y"},
+		{"YxmEvex", "YxrEvex", "X"},
+		{"YymEvex", "YyrEvex", "Y"},
+		{"Yzm", "Yzr", "Z"},
+	} {
+		resultClass := candidate.register
+		if maskResult {
+			resultClass = "Yk"
+		}
+		firstClass, secondClass := candidate.memory, candidate.register
+		if widening != 0 {
+			bytes := map[string]int{"X": 16, "Y": 32, "Z": 64}[candidate.bank]
+			firstClass, _ = x86PackedWideningSource(bytes, widening, evex)
+		}
+		if shift && !immediate {
+			// Register/m128 counts retain X even when data/result is Y/Z.
+			firstClass = "Yxm"
+			if evex {
+				firstClass += "Evex"
+			}
+		}
+		if immediate {
+			firstClass, secondClass = "Yu8", candidate.memory
+			if !evex {
+				if extension {
+					secondClass = candidate.register
+				}
+				if rule.Classes[0] == "Yi8" {
+					firstClass = "Yi8"
+				}
+			}
+		}
+		if store {
+			firstClass, resultClass = candidate.register, candidate.memory
+		}
+		if rule.Classes[0] == firstClass && (unary && !immediate || rule.Classes[1] == secondClass) &&
+			rule.Classes[count-1] == resultClass {
+			bank = candidate.bank
+			break
+		}
+	}
+	if bank == "" || !evex && bank == "Z" || scalar && bank != "X" || masked && rule.Classes[count-2] != "Yknot0" {
+		return nil, fmt.Errorf("%s has unmodeled packed vector operand classes %v", rule.Opcode, rule.Classes)
+	}
+	stride := 2
+	if evex {
+		stride = 3
+	}
+	if extension {
+		stride++ // The selected opcode is followed by a literal ModRM /digit.
+	}
+	if rule.EncodingOffset < 0 || rule.EncodingOffset+stride > len(rule.OpBytes) {
+		return nil, fmt.Errorf("%s encoding offset %d is outside its complete opBytes", rule.Opcode, rule.EncodingOffset)
+	}
+	encoding := rule.OpBytes[rule.EncodingOffset]
+	width := map[string]string{"X": "128", "Y": "256", "Z": "512"}[bank]
+	kind := "vex"
+	if evex {
+		kind = "evex"
+	}
+	if !hasEncodingTerm(encoding, kind+width) {
+		return nil, fmt.Errorf("%s operand width %s differs from encoding %s", rule.Opcode, bank, encoding)
+	}
+	features := ""
+	if evex {
+		features = rule.OpBytes[rule.EncodingOffset+1]
+	}
+	rounding := hasEncodingTerm(features, "evexRoundingEnabled")
+	sae := hasEncodingTerm(features, "evexSaeEnabled")
+	if rounding && sae || (rounding || sae) && (!floating || !scalar && bank != "Z") {
+		return nil, fmt.Errorf("%s adds unaudited rounding/SAE to the packed binary grammar", rule.Opcode)
+	}
+	if maskResult && hasEncodingTerm(features, "evexZeroingEnabled") {
+		return nil, fmt.Errorf("%s adds vector zeroing to a mask result", rule.Opcode)
+	}
+	destination := bank + "2"
+	if maskResult {
+		destination = "K2"
+	}
+	var witnesses []string
+	emit := func(source, suffix string) {
+		last := destination
+		if store {
+			source, last = bank+"0", source
+		}
+		operands := []string{source}
+		if immediate {
+			literal := "$7"
+			if rule.Classes[0] == "Yi8" {
+				literal = "$-1"
+			}
+			operands = []string{literal, source}
+		} else if !unary {
+			operands = append(operands, bank+"1")
+		}
+		if masked {
+			operands = append(operands, "K1")
+		}
+		operands = append(operands, last)
+		witnesses = append(witnesses, rule.Opcode+suffix+" "+strings.Join(operands, ","))
+	}
+	sources := []string{bank + "0", "(AX)"}
+	if widening != 0 {
+		sources[0] = strings.ToUpper(rule.Classes[0][1:2]) + "0"
+	}
+	if shift && !immediate {
+		sources[0] = "X0"
+	}
+	if extension && !evex {
+		sources = sources[:1] // VEX immediate rows are register-only.
+	}
+	if store {
+		sources[0] = destination
+	}
+	for _, source := range sources {
+		if move && !store && source != "(AX)" {
+			continue // Register alternatives select the earlier store row.
+		}
+		emit(source, "")
+		if masked && hasEncodingTerm(features, "evexZeroingEnabled") {
+			emit(source, ".Z")
+		}
+	}
+	if hasEncodingTerm(features, "evexBcstN4") || hasEncodingTerm(features, "evexBcstN8") {
+		emit("(AX)", ".BCST")
+		if masked && hasEncodingTerm(features, "evexZeroingEnabled") {
+			emit("(AX)", ".BCST.Z")
+		}
+	}
+	if rounding {
+		for _, control := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+			emit(bank+"0", "."+control)
+			if masked && hasEncodingTerm(features, "evexZeroingEnabled") {
+				emit(bank+"0", "."+control+".Z")
+			}
+		}
+	}
+	if sae {
+		emit(bank+"0", ".SAE")
+		if masked && hasEncodingTerm(features, "evexZeroingEnabled") {
+			emit(bank+"0", ".SAE.Z")
+		}
+	}
+	return witnesses, nil
+}
+
+func hasEncodingTerm(expression, term string) bool {
+	for _, candidate := range strings.FieldsFunc(expression, func(r rune) bool {
+		return r == '|' || r == '(' || r == ')' || r == ' ' || r == '\t' || r == '\n'
+	}) {
+		if candidate == term {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/goasmrules/x86_witness_abs_test.go b/internal/goasmrules/x86_witness_abs_test.go
new file mode 100644
index 000000000..89794c1b9
--- /dev/null
+++ b/internal/goasmrules/x86_witness_abs_test.go
@@ -0,0 +1,105 @@
+package goasmrules
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedAbsRowsShareUnaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedAbsRows,
+		`^V?PABS[BWDQ]$`, `[DQ]$`, x86PackedRowCounts{
+			names: 7, broadcast: 18,
+			rows: [3]int{3, 6, 24}, formats: [3]int{6, 12, 90}, widths: [3]int{42, 36, 30},
+		})
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if witness.Generation == "legacy" && witness.Second != witness.Destination ||
+				witness.Generation != "legacy" && witness.Second != "" {
+				t.Fatal("unary ABS syntax confused its destination and a second source", row.ID, witness)
+			}
+			if witness.Generation == "evex" && !witness.Memory && !strings.HasSuffix(witness.First, "16") {
+				t.Fatal("unary source can lose its original EVEX row", row.ID, witness)
+			}
+		}
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PABSB X0,X1", []byte{0x66, 0x0f, 0x38, 0x1c, 0xc8}},
+		{"PABSW (AX),X1", []byte{0x66, 0x0f, 0x38, 0x1d, 0x08}},
+		{"PABSD X0,X1", []byte{0x66, 0x0f, 0x38, 0x1e, 0xc8}},
+		{"VPABSB X0,X2", []byte{0xc4, 0xe2, 0x79, 0x1c, 0xd0}},
+		{"VPABSW (AX),Y2", []byte{0xc4, 0xe2, 0x7d, 0x1d, 0x10}},
+		{"VPABSD X16,X18", []byte{0x62, 0xa2, 0x7d, 0x08, 0x1e, 0xd0}},
+		{"VPABSD.BCST.Z (AX),K1,Z18", []byte{0x62, 0xe2, 0x7d, 0xd9, 0x1e, 0x10}},
+		{"VPABSQ.Z Y16,K1,Y18", []byte{0x62, 0xa2, 0xfd, 0xa9, 0x1f, 0xd0}},
+	})
+}
+
+func x86PackedAbsUnaryFixture() X86AVXRule {
+	return X86AVXRule{
+		Opcode: "VPABSD", Ytab: "_yvmovddup", Prefix: "Pavx", RowIndex: 3,
+		Classes: []string{"YxmEvex", "Yknot0", "YxrEvex"},
+		ZCase:   "Zevex_rm_k_r", ZOffset: 3,
+		OpBytes: []string{"avxEscape | evex128 | evex66 | evex0F38 | evexW0", "evexN16 | evexBcstN4 | evexZeroingEnabled", "0x1E"},
+	}
+}
+
+func TestX86PackedUnaryRowEncodingAndFailClosed(t *testing.T) {
+	if syntax, err := X86PackedBinarySyntaxWitnesses(x86PackedAbsUnaryFixture()); err == nil || len(syntax) != 0 {
+		t.Fatal("the strict public binary grammar acquired unary formats", syntax, err)
+	}
+	witnesses, err := x86PackedAVXRowWitnesses(x86PackedAbsUnaryFixture())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(witnesses) != 6 || witnesses[0].Instruction != "VPABSD X16,K1,X18" ||
+		witnesses[0].Second != "" || witnesses[0].Destination != "X18" ||
+		!bytes.Equal(witnesses[0].Encoding, []byte{0x62, 0xa2, 0x7d, 0x09, 0x1e, 0xd0}) ||
+		witnesses[5].Instruction != "VPABSD.BCST.Z (AX),K1,X18" ||
+		!bytes.Equal(witnesses[5].Encoding, []byte{0x62, 0xe2, 0x7d, 0x99, 0x1e, 0x10}) {
+		t.Fatal("unary source, destination or reserved vvvv/V' fields changed", witnesses)
+	}
+	for _, test := range []struct {
+		name   string
+		mutate func(*X86AVXRule)
+	}{
+		{"table", func(r *X86AVXRule) { r.Ytab = "unknown" }},
+		{"prefix", func(r *X86AVXRule) { r.Prefix = "Pq4" }},
+		{"binary zcase", func(r *X86AVXRule) { r.ZCase = "Zevex_rm_v_k_r" }},
+		{"binary arity", func(r *X86AVXRule) { r.Classes = append(r.Classes[:1], "YxrEvex", "Yknot0", "YxrEvex") }},
+		{"source class", func(r *X86AVXRule) { r.Classes[0] = "Yxm" }},
+		{"destination width", func(r *X86AVXRule) { r.Classes[2] = "YyrEvex" }},
+		{"mask class", func(r *X86AVXRule) { r.Classes[1] = "Yk" }},
+		{"offset", func(r *X86AVXRule) { r.EncodingOffset = 1 }},
+		{"stride", func(r *X86AVXRule) { r.ZOffset = 0 }},
+		{"width", func(r *X86AVXRule) { r.OpBytes[0] = strings.Replace(r.OpBytes[0], "evex128", "evex256", 1) }},
+		{"tuple", func(r *X86AVXRule) { r.OpBytes[1] = strings.Replace(r.OpBytes[1], "evexN16", "evexN64", 1) }},
+		{"broadcast conflict", func(r *X86AVXRule) { r.OpBytes[1] += " | evexBcstN8" }},
+		{"rounding", func(r *X86AVXRule) { r.OpBytes[1] += " | evexRoundingEnabled" }},
+		{"SAE", func(r *X86AVXRule) { r.OpBytes[1] += " | evexSaeEnabled" }},
+		{"future flag", func(r *X86AVXRule) { r.OpBytes[0] += " | futureFlag" }},
+		{"repeated flag", func(r *X86AVXRule) { r.OpBytes[0] += " | evex66" }},
+		{"W conflict", func(r *X86AVXRule) { r.OpBytes[0] += " | evexW1" }},
+		{"map conflict", func(r *X86AVXRule) { r.OpBytes[0] += " | evex0F" }},
+		{"opcode literal", func(r *X86AVXRule) { r.OpBytes[2] = "futureOpcode" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			local := x86PackedAbsUnaryFixture()
+			test.mutate(&local)
+			if witnesses, err := x86PackedAVXRowWitnesses(local); err == nil || len(witnesses) != 0 {
+				t.Fatal("unknown unary format silently accepted", witnesses, err)
+			}
+		})
+	}
+}
+
+func TestX86PackedUnaryEVEXOnlyTableRejectsVEX(t *testing.T) {
+	rule := X86AVXRule{
+		Opcode: "VPABSQ", Ytab: "_yvexpandpd", Prefix: "Pavx",
+		Classes: []string{"Yxm", "Yxr"}, ZCase: "Zvex_rm_v_r", ZOffset: 2,
+		OpBytes: []string{"avxEscape | vex128 | vex66 | vex0F38 | vexW1", "0x1F"},
+	}
+	if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+		t.Fatal("EVEX-only unary table acquired VEX", witnesses, err)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_all_avx_test.go b/internal/goasmrules/x86_witness_all_avx_test.go
new file mode 100644
index 000000000..7be864984
--- /dev/null
+++ b/internal/goasmrules/x86_witness_all_avx_test.go
@@ -0,0 +1,42 @@
+package goasmrules
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Every actual SDK row must reach the existing cold physical grammar. These
+// witnesses do not establish Go encoder selection, LLVM objects or execution.
+func TestX86AllOfficialAVXRowsHaveImmutableWitnesses(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil || len(rules) == 0 {
+		t.Fatal("complete actual SDK AVX table", len(rules), err)
+	}
+	for index, original := range rules {
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, original.Opcode, original.Ytab, original.RowIndex)
+		t.Run(id, func(t *testing.T) {
+			before, err := json.Marshal(original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			witnesses, witnessError := x86PackedAVXRowWitnesses(original)
+			after, err := json.Marshal(original)
+			if err != nil || !bytes.Equal(before, after) {
+				t.Fatal("cold grammar changed the original SDK row", err)
+			}
+			if witnessError != nil || len(witnesses) == 0 {
+				t.Fatalf("original row has no physical witnesses: %v; source=%s", witnessError, before)
+			}
+			for _, witness := range witnesses {
+				if strings.TrimSpace(witness.Instruction) == "" || len(witness.Encoding) == 0 {
+					t.Fatal("physical witness lost source or encoding", witness)
+				}
+			}
+		})
+	}
+	t.Logf("%d actual SDK AVX source rows checked; no object or runtime claim", len(rules))
+}
diff --git a/internal/goasmrules/x86_witness_bit_count_conflict_test.go b/internal/goasmrules/x86_witness_bit_count_conflict_test.go
new file mode 100644
index 000000000..815fac95d
--- /dev/null
+++ b/internal/goasmrules/x86_witness_bit_count_conflict_test.go
@@ -0,0 +1,89 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedBitCountConflictOfficialRowsAndControls(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedBitCountConflictRows,
+		`^(VPOPCNT[BWDQ]|VPLZCNT[DQ]|VPCONFLICT[DQ])$`, `[DQ]$`, x86PackedRowCounts{
+			names: 8, broadcast: 54,
+			rows: [3]int{0, 0, 48}, formats: [3]int{0, 0, 198}, widths: [3]int{66, 66, 66},
+		})
+	classes := []string{"YxmEvex,YxrEvex", "YxmEvex,Yknot0,YxrEvex",
+		"YymEvex,YyrEvex", "YymEvex,Yknot0,YyrEvex", "Yzm,Yzr", "Yzm,Yknot0,Yzr"}
+	// Independent complete semantic membership and official byte attributes.
+	for _, member := range []struct {
+		name         string
+		opcode       byte
+		w, broadcast int
+	}{
+		{"VPOPCNTB", 0x54, 0, 0}, {"VPOPCNTW", 0x54, 1, 0},
+		{"VPOPCNTD", 0x55, 0, 4}, {"VPOPCNTQ", 0x55, 1, 8},
+		{"VPLZCNTD", 0x44, 0, 4}, {"VPLZCNTQ", 0x44, 1, 8},
+		{"VPCONFLICTD", 0xc4, 0, 4}, {"VPCONFLICTQ", 0xc4, 1, 8},
+	} {
+		var payload []string
+		for _, width := range []int{128, 256, 512} {
+			features := fmt.Sprintf("evexN%d", width/8)
+			if member.broadcast != 0 {
+				features += fmt.Sprintf(" | evexBcstN%d", member.broadcast)
+			}
+			payload = append(payload, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d", width, member.w),
+				features+" | evexZeroingEnabled", fmt.Sprintf("0x%02X", member.opcode))
+		}
+		count := 0
+		for _, rule := range inventory.avx {
+			if rule.Opcode != member.name {
+				continue
+			}
+			zcase := "Zevex_rm_v_r"
+			if count%2 != 0 {
+				zcase = "Zevex_rm_k_r"
+			}
+			if count >= 6 || rule.RowIndex != count || rule.Ytab != "_yvexpandpd" || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*3 || rule.EncodingOffset != count/2*3 ||
+				strings.Join(rule.Classes, ",") != classes[count] || !reflect.DeepEqual(rule.OpBytes, payload) {
+				t.Fatal("complete unary row, opcode or tuple attributes changed", member.name, rule)
+			}
+			count++
+		}
+		if count != 6 {
+			t.Fatal("incomplete unary family member", member.name, count)
+		}
+	}
+	zeroing := 0
+	var semanticRows, semanticFormats [2]int // Bit count, then cross-lane conflict.
+	for _, row := range inventory.rows {
+		semantic := 0
+		if strings.HasPrefix(row.Opcode, "VPCONFLICT") {
+			semantic = 1
+		}
+		semanticRows[semantic]++
+		semanticFormats[semantic] += len(row.Witnesses)
+		for _, witness := range row.Witnesses {
+			if witness.Second != "" || witness.MaskResult || strings.Contains(witness.Instruction, "SAE") {
+				t.Fatal("unary integer witness acquired another data input or FP controls", row.ID, witness)
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+		}
+	}
+	if semanticRows != [2]int{36, 12} || semanticFormats != [2]int{144, 54} || zeroing != 66 {
+		t.Fatal("separate bit-count/conflict or unary control denominator changed", semanticRows, semanticFormats, zeroing)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VPOPCNTB.Z X16,K1,X18", []byte{0x62, 0xa2, 0x7d, 0x89, 0x54, 0xd0}},
+		{"VPOPCNTW Z16,Z18", []byte{0x62, 0xa2, 0xfd, 0x48, 0x54, 0xd0}},
+		{"VPOPCNTD.Z (AX),K1,X18", []byte{0x62, 0xe2, 0x7d, 0x89, 0x55, 0x10}},
+		{"VPOPCNTQ.BCST (AX),Y18", []byte{0x62, 0xe2, 0xfd, 0x38, 0x55, 0x10}},
+		{"VPLZCNTD (AX),Y18", []byte{0x62, 0xe2, 0x7d, 0x28, 0x44, 0x10}},
+		{"VPLZCNTQ.BCST.Z (AX),K1,Z18", []byte{0x62, 0xe2, 0xfd, 0xd9, 0x44, 0x10}},
+		{"VPCONFLICTD.BCST.Z (AX),K1,X18", []byte{0x62, 0xe2, 0x7d, 0x99, 0xc4, 0x10}},
+		{"VPCONFLICTQ X16,X18", []byte{0x62, 0xa2, 0xfd, 0x08, 0xc4, 0xd0}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_broadcast.go b/internal/goasmrules/x86_witness_broadcast.go
new file mode 100644
index 000000000..1cba25ee2
--- /dev/null
+++ b/internal/goasmrules/x86_witness_broadcast.go
@@ -0,0 +1,207 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type x86BroadcastSourceKind uint8
+
+const (
+	x86BroadcastVectorMemory x86BroadcastSourceKind = iota
+	x86BroadcastGP
+	x86BroadcastKData
+	x86BroadcastMemory
+)
+
+// Source carrier, source tuple and result width are independent format facts.
+// This is an encoding-row projection, not numerical or storage authority.
+type x86PackedBroadcastFormat struct {
+	source       x86BroadcastSourceKind
+	width, tuple int
+	masked       bool
+	encoding     x86PackedAVXOpcode
+}
+
+func x86PackedBroadcastFormatForRule(rule X86AVXRule) (x86PackedBroadcastFormat, error) {
+	f := x86PackedBroadcastFormat{masked: rule.ZCase == "Zevex_rm_k_r"}
+	f.encoding.kind = "vex"
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	if evex {
+		f.encoding.kind = "evex"
+	}
+	fail := func() (x86PackedBroadcastFormat, error) {
+		return f, fmt.Errorf("broadcast source/tuple/width differs from its official format")
+	}
+	if rule.Prefix != "Pavx" || rule.ZCase != "Zvex_rm_v_r" && rule.ZCase != "Zevex_rm_v_r" && !f.masked ||
+		len(rule.Classes) != 2 && !f.masked || f.masked && (len(rule.Classes) != 3 || rule.Classes[1] != "Yknot0") {
+		return fail()
+	}
+	destinations := map[string]int{"Yxr": 128, "Yyr": 256}
+	if evex {
+		destinations = map[string]int{"YxrEvex": 128, "YyrEvex": 256, "Yzr": 512}
+	}
+	f.width = destinations[rule.Classes[len(rule.Classes)-1]]
+	minimum, maximum, vexAllowed := 128, 512, false
+	switch rule.Ytab {
+	case "_yvpbroadcastb":
+		if len(rule.Opcode) != len("VPBROADCASTB") {
+			return fail()
+		}
+		f.tuple = map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[rule.Opcode[len(rule.Opcode)-1]]
+		if f.tuple == 0 {
+			return fail()
+		}
+		vexAllowed = true
+		if rule.Classes[0] == "Yrl" {
+			f.source, f.tuple = x86BroadcastGP, 0
+			if !evex {
+				return fail()
+			}
+		}
+	case "_yvbroadcastss":
+		f.tuple, vexAllowed = 4, true
+	case "_yvbroadcastsd":
+		f.tuple, minimum, vexAllowed = 8, 256, true
+	case "_yvbroadcasti32x2":
+		f.tuple = 8
+	case "_yvbroadcastf32x2":
+		f.tuple, minimum = 8, 256
+	case "_yvbroadcastf32x4":
+		f.source, f.tuple, minimum = x86BroadcastMemory, 16, 256
+	case "_yvbroadcastf32x8":
+		f.source, f.tuple, minimum = x86BroadcastMemory, 32, 512
+	case "_yvpbroadcastmb2q":
+		f.source = x86BroadcastKData
+		if f.masked {
+			return fail()
+		}
+	case "_yvbroadcastf128":
+		f.source, f.tuple, minimum, maximum, vexAllowed = x86BroadcastMemory, 16, 256, 256, true
+		if evex || f.masked {
+			return fail()
+		}
+	default:
+		return fail()
+	}
+	class := "Yxm"
+	if evex {
+		class += "Evex"
+	}
+	switch f.source {
+	case x86BroadcastGP:
+		class = "Yrl"
+	case x86BroadcastKData:
+		class = "Yk"
+	case x86BroadcastMemory:
+		class = "Ym"
+	}
+	if rule.Classes[0] != class || f.width < minimum || f.width > maximum || !evex && !vexAllowed ||
+		f.source == x86BroadcastVectorMemory && f.tuple == 0 {
+		return fail()
+	}
+	stride, offset := 2, 2
+	if evex {
+		stride, offset = 3, 0
+		if f.masked || f.source == x86BroadcastKData {
+			offset = 3
+		}
+	}
+	if rule.ZOffset != offset || rule.EncodingOffset < 0 || rule.EncodingOffset+stride > len(rule.OpBytes) {
+		return fail()
+	}
+	pp, w := "66", "W0"
+	if f.source == x86BroadcastKData {
+		pp = "F3"
+	}
+	if evex && (rule.Opcode == "VBROADCASTSD" || strings.Contains(rule.Opcode, "64X") || strings.HasSuffix(rule.Opcode, "Q")) {
+		w = "W1"
+	}
+	kind := f.encoding.kind
+	atoms, err := x86PackedEncodingAtoms(rule.OpBytes[rule.EncodingOffset], []string{
+		"avxEscape", kind + strconv.Itoa(f.width), kind + pp, kind + "0F38", kind + w,
+	}, nil)
+	if err != nil {
+		return fail()
+	}
+	if evex {
+		required := []string{"evexZeroingEnabled"}
+		if f.source == x86BroadcastKData {
+			required = []string{"0"}
+		} else if f.tuple != 0 {
+			required = append(required, "evexN"+strconv.Itoa(f.tuple))
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[rule.EncodingOffset+1], required, nil); err != nil {
+			return fail()
+		}
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[rule.EncodingOffset+stride-1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding.mapByte, f.encoding.pp, f.encoding.opcode = 2, 1, byte(opcode)
+	if pp == "F3" {
+		f.encoding.pp = 2
+	}
+	if atoms[kind+"W1"] {
+		f.encoding.wBit = 0x80
+	}
+	f.encoding.length = byte(map[int]int{128: 0, 256: 1, 512: 2}[f.width])
+	return f, nil
+}
+
+func x86PackedBroadcastRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86PackedBroadcastFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	evex := f.encoding.kind == "evex"
+	sources := []string{"X0", "(AX)"}
+	if evex {
+		sources[0] = "X16"
+	}
+	switch f.source {
+	case x86BroadcastGP:
+		sources = []string{"AX"}
+	case x86BroadcastKData:
+		sources = []string{"K0"}
+	case x86BroadcastMemory:
+		sources = []string{"(AX)"}
+	}
+	bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[f.width]
+	destination := bank + "2"
+	if evex {
+		destination = bank + "18"
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, source := range sources {
+		controls := []string{""}
+		if f.masked {
+			controls = append(controls, ".Z")
+		}
+		for _, suffix := range controls {
+			operands := source + "," + destination
+			p0, p2, modrm := byte(0xe0), f.encoding.length<<5|8, byte(0xd0)
+			if source == "X16" {
+				p0 = 0xa0
+			}
+			if source == "(AX)" {
+				modrm = 0x10
+			}
+			if f.masked {
+				operands, p2 = source+",K1,"+destination, p2|1
+			}
+			if suffix != "" {
+				p2 |= 0x80
+			}
+			witnesses = append(witnesses, X86PackedBinaryWitness{
+				Instruction: rule.Opcode + suffix + " " + operands, Generation: f.encoding.kind,
+				First: source, Destination: destination, Width: f.width,
+				Memory: source == "(AX)", Masked: f.masked, Zeroing: suffix != "",
+				Encoding: f.encoding.bytes(0x78, p0, p2, modrm),
+			})
+		}
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_broadcast_test.go b/internal/goasmrules/x86_witness_broadcast_test.go
new file mode 100644
index 000000000..c38295ad3
--- /dev/null
+++ b/internal/goasmrules/x86_witness_broadcast_test.go
@@ -0,0 +1,305 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86PackedBroadcastTestNames = `
+	VPBROADCASTB VPBROADCASTW VPBROADCASTD VPBROADCASTQ
+	VBROADCASTSS VBROADCASTSD VBROADCASTI32X2 VBROADCASTF32X2
+	VBROADCASTF32X4 VBROADCASTF64X2 VBROADCASTI32X4 VBROADCASTI64X2
+	VBROADCASTF32X8 VBROADCASTF64X4 VBROADCASTI32X8 VBROADCASTI64X4
+	VPBROADCASTMB2Q VPBROADCASTMW2D VBROADCASTF128 VBROADCASTI128`
+
+func TestX86PackedBroadcastCompleteOfficialTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Existing row reader gives a real format RED, without a future selector.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86PackedBroadcastTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := map[string]X86AVXRule{}
+	for index, row := range avx {
+		if strings.HasPrefix(row.Opcode, "VBROADCAST") || strings.HasPrefix(row.Opcode, "VPBROADCAST") {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = row
+		}
+	}
+	names, ids, instructions := map[string]bool{}, map[string]bool{}, map[string]bool{}
+	var rowKinds, formats [2]int
+	widthCounts := map[int]int{}
+	memory, masked, zeroing, kdata, single := 0, 0, 0, 0, 0
+	for _, row := range rows {
+		original, valid := originals[row.ID]
+		if !valid || ids[row.ID] || row.Opcode != original.Opcode || len(row.Witnesses) == 0 {
+			t.Fatal("broadcast lost its exact official row or source-only witness", row)
+		}
+		ids[row.ID], names[row.Opcode] = true, true
+		evex := strings.HasPrefix(original.ZCase, "Zevex_")
+		generation, index := "vex", 0
+		if evex {
+			generation, index = "evex", 1
+		}
+		rowKinds[index]++
+		width := map[string]int{"Yxr": 128, "Yyr": 256, "YxrEvex": 128, "YyrEvex": 256, "Yzr": 512}[original.Classes[len(original.Classes)-1]]
+		register := "X0"
+		if evex {
+			register = "X16"
+		}
+		sources := []string{register, "(AX)"}
+		switch original.Classes[0] {
+		case "Yrl":
+			sources = []string{"AX"}
+		case "Yk":
+			sources = []string{"K0"} // K0 is data here, never a writemask.
+		case "Ym":
+			sources = []string{"(AX)"}
+		case "Yxm", "YxmEvex":
+		default:
+			t.Fatal("broadcast source class escaped the complete official family", original)
+		}
+		wantMasked := original.ZCase == "Zevex_rm_k_r"
+		want := len(sources)
+		if wantMasked {
+			want *= 2
+		}
+		if len(row.Witnesses) != want {
+			t.Fatal("broadcast invented a register/memory alternative or omitted mask/zero controls", row.ID, len(row.Witnesses), want)
+		}
+		if want == 1 {
+			single++
+		}
+		for _, witness := range row.Witnesses {
+			if len(witness.Encoding) != 5 && !evex || len(witness.Encoding) != 6 && evex {
+				t.Fatal("broadcast has no complete VEX/EVEX bytes", row.ID, witness)
+			}
+			fields := strings.Fields(witness.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("broadcast has no complete source spelling", row.ID, witness)
+			}
+			operands := strings.Split(fields[1], ",")
+			allowed := false
+			for _, source := range sources {
+				allowed = allowed || witness.First == source
+			}
+			if !allowed || instructions[witness.Instruction] || witness.First != operands[0] ||
+				strings.TrimSuffix(fields[0], ".Z") != row.Opcode || witness.Zeroing != strings.HasSuffix(fields[0], ".Z") ||
+				witness.Destination != operands[len(operands)-1] ||
+				witness.Second != "" || witness.Width != width || witness.Generation != generation ||
+				witness.Memory != (witness.First == "(AX)") || witness.Masked != wantMasked ||
+				witness.MaskResult || witness.Broadcast || witness.Zeroing && !wantMasked ||
+				wantMasked && operands[1] != "K1" || !wantMasked && len(operands) != 2 {
+				t.Fatal("broadcast confused source data, destination or writemask roles", row.ID, witness)
+			}
+			instructions[witness.Instruction] = true
+			if witness.Encoding[2]&0x78 != 0x78 || !evex && witness.Encoding[0] != 0xc4 ||
+				evex && (!strings.HasSuffix(witness.Destination, "18") || witness.Encoding[0] != 0x62 || witness.Encoding[3]&8 == 0) {
+				t.Fatal("broadcast lost reserved vvvv/V' or physical EVEX identity", row.ID, witness)
+			}
+			formats[index]++
+			widthCounts[width]++
+			if witness.Memory {
+				memory++
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.First == "K0" {
+				kdata++
+			}
+		}
+	}
+	if len(names) != 20 || len(rows) != 111 || len(ids) != len(originals) || rowKinds != [2]int{13, 98} ||
+		formats != [2]int{24, 210} || widthCounts[128] != 60 || widthCounts[256] != 88 || widthCounts[512] != 86 ||
+		memory != 115 || masked != 136 || zeroing != 68 || kdata != 6 || single != 32 {
+		t.Fatal("complete scalar/block/GP/K-data broadcast denominator changed", len(names), len(rows), rowKinds, formats, widthCounts, memory, masked, zeroing, kdata, single)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VBROADCASTF128 (AX),Y2", []byte{0xc4, 0xe2, 0x7d, 0x1a, 0x10}},
+		{"VBROADCASTSS X0,X2", []byte{0xc4, 0xe2, 0x79, 0x18, 0xd0}},
+		{"VPBROADCASTB AX,X18", []byte{0x62, 0xe2, 0x7d, 0x08, 0x7a, 0xd0}},
+		{"VPBROADCASTQ AX,Z18", []byte{0x62, 0xe2, 0xfd, 0x48, 0x7c, 0xd0}},
+		{"VPBROADCASTMB2Q K0,Z18", []byte{0x62, 0xe2, 0xfe, 0x48, 0x2a, 0xd0}},
+		{"VPBROADCASTMW2D K0,X18", []byte{0x62, 0xe2, 0x7e, 0x08, 0x3a, 0xd0}},
+		{"VBROADCASTF32X4.Z (AX),K1,Z18", []byte{0x62, 0xe2, 0x7d, 0xc9, 0x1a, 0x10}},
+		{"VBROADCASTF64X4 (AX),Z18", []byte{0x62, 0xe2, 0xfd, 0x48, 0x1b, 0x10}},
+		{"VBROADCASTI32X2 X16,Z18", []byte{0x62, 0xa2, 0x7d, 0x48, 0x59, 0xd0}},
+	})
+}
+
+func TestX86PackedBroadcastOfficialSourceContracts(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := map[string]bool{}
+	for _, name := range strings.Fields(x86PackedBroadcastTestNames) {
+		selected[name] = true
+	}
+	seen := 0
+	for _, row := range rules {
+		if !selected[row.Opcode] {
+			continue
+		}
+		seen++
+		kind, width := "vex", map[string]int{"Yxr": 128, "Yyr": 256, "YxrEvex": 128, "YyrEvex": 256, "Yzr": 512}[row.Classes[len(row.Classes)-1]]
+		if strings.HasPrefix(row.ZCase, "Zevex_") {
+			kind = "evex"
+		}
+		pp, w := "66", 0
+		if row.Classes[0] == "Yk" {
+			pp = "F3"
+		}
+		if kind == "evex" && (row.Opcode == "VBROADCASTSD" || strings.Contains(row.Opcode, "64X") || strings.HasSuffix(row.Opcode, "Q")) {
+			w = 1
+		}
+		want := fmt.Sprintf("avxEscape|%s%d|%s%s|%s0F38|%sW%d", kind, width, kind, pp, kind, kind, w)
+		if strings.Join(strings.Fields(row.OpBytes[row.EncodingOffset]), "") != want {
+			t.Fatal("broadcast PP/W/map/width changed", row)
+		}
+		if kind != "evex" {
+			continue
+		}
+		feature := "0"
+		if row.Classes[0] == "Yrl" {
+			feature = "evexZeroingEnabled"
+		} else if row.Classes[0] != "Yk" {
+			bytes := 0
+			switch row.Ytab {
+			case "_yvpbroadcastb":
+				bytes = map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[row.Opcode[len(row.Opcode)-1]]
+			case "_yvbroadcastss":
+				bytes = 4
+			case "_yvbroadcastsd", "_yvbroadcasti32x2", "_yvbroadcastf32x2":
+				bytes = 8
+			case "_yvbroadcastf32x4":
+				bytes = 16
+			case "_yvbroadcastf32x8":
+				bytes = 32
+			}
+			feature = fmt.Sprintf("evexN%d|evexZeroingEnabled", bytes)
+		}
+		if strings.Join(strings.Fields(row.OpBytes[row.EncodingOffset+1]), "") != feature {
+			t.Fatal("broadcast borrowed a full vector tuple or foreign access control", row)
+		}
+	}
+	if seen != 111 {
+		t.Fatal("broadcast source contract lost an official row", seen)
+	}
+}
+
+func TestX86PackedBroadcastTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"GP memory", "vector GP", "memory-only register", "vector Y carrier", "scalar tuple", "block tuple", "GP tuple", "K-data tuple", "K-data zeroing", "K-data writemask", "K-data nonzero-only", "K-data memory", "K0 writemask class", "SD X width", "small block X width", "large block Y width", "VEX block EVEX", "K-data F2", "GP Q W0", "map", "BCST", "SAE", "rounding", "widening GP", "binary shrinking tuple"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VBROADCASTSS", 2
+			switch mutation {
+			case "GP memory", "GP tuple":
+				name, index = "VPBROADCASTB", 2
+			case "vector GP":
+				name, index = "VPBROADCASTB", 8
+			case "memory-only register", "block tuple":
+				name, index = "VBROADCASTF32X4", 0
+			case "K-data tuple", "K-data zeroing", "K-data writemask", "K-data nonzero-only", "K-data memory", "K-data F2":
+				name, index = "VPBROADCASTMB2Q", 0
+			case "K0 writemask class":
+				index = 3
+			case "SD X width":
+				name, index = "VBROADCASTSD", 1
+			case "small block X width":
+				name, index = "VBROADCASTF32X2", 0
+			case "large block Y width":
+				name, index = "VBROADCASTF32X8", 0
+			case "VEX block EVEX":
+				name, index = "VBROADCASTF128", 0
+			case "GP Q W0":
+				name, index = "VPBROADCASTQ", 2
+			case "widening GP":
+				name, index = "VPMOVSXBW", 2
+			case "binary shrinking tuple":
+				name, index = "VPMULLD", 2
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				row := original
+				row.Classes = append([]string(nil), row.Classes...)
+				row.OpBytes = append([]string(nil), row.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "GP memory", "K-data memory":
+					row.Classes[0] = "Ym"
+				case "vector GP", "widening GP":
+					row.Classes[0] = "Yrl"
+				case "memory-only register":
+					row.Classes[0] = "YxmEvex"
+				case "vector Y carrier":
+					row.Classes[0] = "YymEvex"
+				case "scalar tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN4", "evexN8", 1)
+				case "block tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN32", 1)
+				case "GP tuple":
+					row.OpBytes[feature] += "|evexN1"
+				case "K-data tuple":
+					row.OpBytes[feature] = "evexN8"
+				case "K-data zeroing":
+					row.OpBytes[feature] = "evexZeroingEnabled"
+				case "K-data writemask":
+					row.ZCase, row.Classes = "Zevex_rm_k_r", []string{"Yk", "Yknot0", row.Classes[1]}
+				case "K-data nonzero-only":
+					row.Classes[0] = "Yknot0"
+				case "K0 writemask class":
+					row.Classes[1] = "Yk"
+				case "SD X width", "small block X width":
+					row.Classes[len(row.Classes)-1] = "YxrEvex"
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex256", "evex128", 1)
+				case "large block Y width":
+					row.Classes[len(row.Classes)-1] = "YyrEvex"
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex512", "evex256", 1)
+				case "VEX block EVEX":
+					row.Classes[1], row.ZCase, row.ZOffset = "YyrEvex", "Zevex_rm_v_r", 3
+					row.OpBytes = []string{strings.ReplaceAll(row.OpBytes[0], "vex", "evex"), "evexN16|evexZeroingEnabled", row.OpBytes[1]}
+				case "K-data F2":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexF3", "evexF2", 1)
+				case "GP Q W0":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW1", "evexW0", 1)
+				case "map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F38", "evex0F", 1)
+				case "BCST":
+					row.OpBytes[feature] += "|evexBcstN4"
+				case "SAE":
+					row.OpBytes[feature] += "|evexSaeEnabled"
+				case "rounding":
+					row.OpBytes[feature] += "|evexRoundingEnabled"
+				case "binary shrinking tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN4", 1)
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("broadcast borrowed a foreign source role, tuple, prefix or masking capability", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("broadcast negative lost its exact original row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_byte_shuffle_test.go b/internal/goasmrules/x86_witness_byte_shuffle_test.go
new file mode 100644
index 000000000..615877f8f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_byte_shuffle_test.go
@@ -0,0 +1,78 @@
+package goasmrules
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+func TestX86PackedByteShuffleRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedByteShuffleRows,
+		`^V?PSHUFB$`, `^$`, x86PackedRowCounts{
+			names: 2,
+			rows:  [3]int{1, 2, 6}, formats: [3]int{2, 4, 18}, widths: [3]int{10, 8, 6},
+		})
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PSHUFB X0,X1", []byte{0x66, 0x0f, 0x38, 0x00, 0xc8}},
+		{"PSHUFB (AX),X1", []byte{0x66, 0x0f, 0x38, 0x00, 0x08}},
+		{"VPSHUFB X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x00, 0xd0}},
+		{"VPSHUFB (AX),Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x00, 0x10}},
+		{"VPSHUFB X16,X17,X18", []byte{0x62, 0xa2, 0x75, 0x00, 0x00, 0xd0}},
+		{"VPSHUFB Y16,Y17,K1,Y18", []byte{0x62, 0xa2, 0x75, 0x21, 0x00, 0xd0}},
+		{"VPSHUFB (AX),Z17,Z18", []byte{0x62, 0xe2, 0x75, 0x40, 0x00, 0x10}},
+		{"VPSHUFB.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0x75, 0xc1, 0x00, 0x10}},
+	})
+}
+
+func TestX86PackedLegacyTwoByteOpcodeConsumesCompleteTablePayload(t *testing.T) {
+	entry := X86LegacyOpcode{Kind: "encoding", Opcode: "PSHUFB", Ytab: "ymshufb", Prefix: "Pq", OpBytes: []string{"0x38", "0x00"}}
+	row := X86LegacyOperand{Classes: []string{"Yxm", "Yxr"}, ZCase: "Zm2_r", ZOffset: 2}
+	before := entry
+	before.OpBytes = append([]string(nil), entry.OpBytes...)
+	witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+	if err != nil || len(witnesses) != 2 || !bytes.Equal(witnesses[0].Encoding, []byte{0x66, 0x0f, 0x38, 0x00, 0xc8}) ||
+		!bytes.Equal(witnesses[1].Encoding, []byte{0x66, 0x0f, 0x38, 0x00, 0x08}) || !reflect.DeepEqual(entry, before) {
+		t.Fatalf("selected two-byte opcode was lost or mutated: %+v/%v", witnesses, err)
+	}
+	// Perturb only fixture metadata to prove both bytes come from the selected
+	// table payload. The independent original-Go join above owns ISA identity.
+	changed := entry
+	changed.OpBytes = []string{"0x39", "0x07"}
+	witnesses, err = x86PackedLegacyRowWitnesses(changed, row)
+	if err != nil || len(witnesses) != 2 || !bytes.Equal(witnesses[0].Encoding, []byte{0x66, 0x0f, 0x39, 0x07, 0xc8}) {
+		t.Fatal("two-byte encoder substituted a mnemonic-specific opcode", witnesses, err)
+	}
+}
+
+func TestX86PackedLegacyTwoByteOpcodeRejectsUnknownAxes(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mutate func(*X86LegacyOpcode, *X86LegacyOperand)
+	}{
+		{"kind", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Kind = "special" }},
+		{"table", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Ytab = "unknown" }},
+		{"prefix", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Prefix = "Pm" }},
+		{"escape", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.EscapeAdjustment = 1 }},
+		{"index", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.RowIndex = 1 }},
+		{"zcase", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZCase = "Zm_r" }},
+		{"stride", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZOffset = 1 }},
+		{"offset", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.UnmatchedOffset = 1 }},
+		{"classes", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.Classes = []string{"Ymm", "Ymr"} }},
+		{"empty", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = nil }},
+		{"short", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = []string{"0x38"} }},
+		{"extra", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = []string{"0x38", "0x00", "0x01"} }},
+		{"first symbol", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[0] = "opcode" }},
+		{"second symbol", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[1] = "opcode" }},
+		{"first overflow", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[0] = "0x138" }},
+		{"second overflow", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[1] = "0x100" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			entry := X86LegacyOpcode{Kind: "encoding", Opcode: "PSHUFB", Ytab: "ymshufb", Prefix: "Pq", OpBytes: []string{"0x38", "0x00"}}
+			row := X86LegacyOperand{Classes: []string{"Yxm", "Yxr"}, ZCase: "Zm2_r", ZOffset: 2}
+			test.mutate(&entry, &row)
+			if witnesses, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+				t.Fatal("unknown official encoding axis was silently accepted", witnesses, err)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_compact_expand.go b/internal/goasmrules/x86_witness_compact_expand.go
new file mode 100644
index 000000000..122238f2f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_compact_expand.go
@@ -0,0 +1,78 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func x86PackedCompactFormatForRule(rule X86AVXRule) (x86PackedUnaryMemoryFormat, error) {
+	f := x86PackedUnaryMemoryFormat{store: rule.Ytab == "_yvcompresspd"}
+	fail := func() (x86PackedUnaryMemoryFormat, error) {
+		return f, fmt.Errorf("compact/expand direction, carrier or element tuple differs from its official format")
+	}
+	stem, plain, masked := "EXPAND", "Zevex_rm_v_r", "Zevex_rm_k_r"
+	if f.store {
+		stem, plain, masked = "COMPRESS", "Zevex_r_v_rm", "Zevex_r_k_rm"
+	}
+	f.masked = rule.ZCase == masked
+	count, maskIndex := 2, 0
+	if f.masked {
+		count, maskIndex = 3, 1
+	}
+	if rule.Prefix != "Pavx" || rule.Ytab != "_yvcompresspd" && rule.Ytab != "_yvexpandpd" ||
+		rule.ZCase != plain && !f.masked || len(rule.Classes) != count || f.masked && rule.Classes[1] != "Yknot0" {
+		return fail()
+	}
+	first, last := rule.Classes[0], rule.Classes[count-1]
+	if f.store {
+		first, last = last, first
+	}
+	f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[first]
+	register := map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	widthIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width]
+	prefix, integer := "V", strings.HasPrefix(rule.Opcode, "VP")
+	if integer {
+		prefix = "VP"
+	}
+	member, valid := strings.CutPrefix(rule.Opcode, prefix+stem)
+	f.tuple = map[string]int{"B": 1, "W": 2, "D": 4, "Q": 8, "PS": 4, "PD": 8}[member]
+	if !valid || f.tuple == 0 || integer == strings.HasPrefix(member, "P") || f.width == 0 || last != register ||
+		rule.RowIndex != widthIndex*2+maskIndex || rule.ZOffset != maskIndex*3 ||
+		rule.EncodingOffset != widthIndex*3 || len(rule.OpBytes) != 9 {
+		return fail()
+	}
+	f.carrier = f.width / 8
+	w := "evexW0"
+	if f.tuple == 2 || f.tuple == 8 {
+		w = "evexW1"
+	}
+	offset := rule.EncodingOffset
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", "evex" + strconv.Itoa(f.width), "evex66", "evex0F38", w,
+	}, nil); err != nil {
+		return fail()
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], []string{
+		"evexN" + strconv.Itoa(f.tuple), "evexZeroingEnabled",
+	}, nil); err != nil {
+		return fail()
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+2], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: "evex", mapByte: 2, pp: 1, length: byte(widthIndex), opcode: byte(opcode)}
+	if w == "evexW1" {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func x86PackedCompactRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86PackedCompactFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	return f.witnesses(rule.Opcode), nil
+}
diff --git a/internal/goasmrules/x86_witness_compact_expand_test.go b/internal/goasmrules/x86_witness_compact_expand_test.go
new file mode 100644
index 000000000..505cea375
--- /dev/null
+++ b/internal/goasmrules/x86_witness_compact_expand_test.go
@@ -0,0 +1,223 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const x86CompactExpandTestMembers = `VCOMPRESSPS VCOMPRESSPD VPCOMPRESSB VPCOMPRESSW VPCOMPRESSD VPCOMPRESSQ
+	VEXPANDPS VEXPANDPD VPEXPANDB VPEXPANDW VPEXPANDD VPEXPANDQ`
+
+func TestX86CompactExpandCompleteOfficialRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, originals := map[string]bool{}, map[string]X86AVXRule{}
+	for _, name := range strings.Fields(x86CompactExpandTestMembers) {
+		names[name] = true
+	}
+	for index, rule := range avx {
+		if names[rule.Opcode] {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)] = rule
+		}
+	}
+	if len(originals) != 72 {
+		t.Fatal("complete twelve-member original row inventory changed", len(originals))
+	}
+	// Existing helper: expected initial RED is the unjoined store direction or
+	// element-sized tuple. No future helper or production capability is assumed.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86CompactExpandTestMembers)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions, members := map[string]bool{}, map[string]bool{}, map[string]int{}
+	widths := map[int]int{}
+	sourceMemory, destinationMemory, masked, zeroing, terminal := 0, 0, 0, 0, 0
+	for _, row := range rows {
+		original, found := originals[row.ID]
+		if !found || seen[row.ID] {
+			t.Fatal("compact/expand lost its original ordinal or duplicated a row", row)
+		}
+		seen[row.ID], members[row.Opcode] = true, members[row.Opcode]+1
+		expand := strings.Contains(row.Opcode, "EXPAND")
+		widthIndex, maskIndex := original.RowIndex/2, original.RowIndex%2
+		width, hasMask := 128<<widthIndex, maskIndex != 0
+		bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[width]
+		reg := map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[width]
+		mem := map[int]string{128: "YxmEvex", 256: "YymEvex", 512: "Yzm"}[width]
+		first, last, ytab, zcase := reg, mem, "_yvcompresspd", "Zevex_r_v_rm"
+		if expand {
+			first, last, ytab, zcase = mem, reg, "_yvexpandpd", "Zevex_rm_v_r"
+		}
+		classes := []string{first}
+		if hasMask {
+			classes = append(classes, "Yknot0")
+			zcase = strings.Replace(zcase, "_v_", "_k_", 1)
+			if expand {
+				zcase = "Zevex_rm_k_r"
+			}
+		}
+		classes = append(classes, last)
+		if original.Ytab != ytab || original.Prefix != "Pavx" || original.ZCase != zcase ||
+			original.ZOffset != maskIndex*3 || original.EncodingOffset != widthIndex*3 || len(original.OpBytes) != 9 ||
+			strings.Join(original.Classes, ",") != strings.Join(classes, ",") {
+			t.Fatal("direction, carrier or nonzero mask differs from original row", original)
+		}
+		bytes, w := 4, "evexW0"
+		if strings.HasSuffix(row.Opcode, "B") {
+			bytes = 1
+		} else if strings.HasSuffix(row.Opcode, "W") {
+			bytes, w = 2, "evexW1"
+		} else if strings.HasSuffix(row.Opcode, "Q") || strings.HasSuffix(row.Opcode, "PD") {
+			bytes, w = 8, "evexW1"
+		}
+		if _, err := x86PackedEncodingAtoms(original.OpBytes[original.EncodingOffset], []string{
+			"avxEscape", "evex" + strconv.Itoa(width), "evex66", "evex0F38", w,
+		}, nil); err != nil {
+			t.Fatal("compact/expand header changed", original, err)
+		}
+		if _, err := x86PackedEncodingAtoms(original.OpBytes[original.EncodingOffset+1], []string{
+			"evexN" + strconv.Itoa(bytes), "evexZeroingEnabled",
+		}, nil); err != nil {
+			t.Fatal("disp8 element scale was replaced by vector or dynamic compact extent", original, err)
+		}
+		for _, witness := range row.Witnesses {
+			fields := strings.Fields(witness.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("lost compact/expand instruction", witness)
+			}
+			args := strings.Split(fields[1], ",")
+			memorySource, memoryDestination := witness.First == "(AX)", witness.Destination == "(AX)"
+			if len(args) != len(classes) || instructions[witness.Instruction] || witness.First != args[0] ||
+				witness.Destination != args[len(args)-1] || witness.Second != "" || witness.MaskResult ||
+				witness.First != bank+"16" && !memorySource || witness.Destination != bank+"18" && !memoryDestination ||
+				memorySource && !expand || memoryDestination && expand ||
+				witness.Memory != memorySource || witness.Generation != "evex" || witness.Width != width ||
+				witness.Masked != hasMask || hasMask && args[1] != "K1" || witness.Broadcast ||
+				witness.Zeroing != strings.HasSuffix(fields[0], ".Z") || witness.Zeroing && !hasMask ||
+				len(witness.Encoding) != 6 || witness.Encoding[0] != 0x62 || witness.Encoding[2]&0x7f != 0x7d ||
+				witness.Encoding[3]&8 == 0 || witness.Encoding[3]&0x10 != 0 {
+				t.Fatal("compact store, source Memory, reserved vvvv or register result was conflated", row.ID, witness)
+			}
+			instructions[witness.Instruction], widths[width] = true, widths[width]+1
+			if memorySource {
+				sourceMemory++
+			}
+			if memoryDestination {
+				destinationMemory++
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if memoryDestination && witness.Zeroing {
+				terminal++
+			}
+		}
+	}
+	if len(rows) != 72 || len(seen) != len(originals) || len(instructions) != 216 || len(members) != 12 ||
+		widths[128] != 72 || widths[256] != 72 || widths[512] != 72 || sourceMemory != 54 || destinationMemory != 54 ||
+		masked != 144 || zeroing != 72 || terminal != 18 {
+		t.Fatal("complete compact/expand denominator changed", len(rows), len(instructions), widths, sourceMemory, destinationMemory, masked, zeroing, terminal)
+	}
+	for member, count := range members {
+		if count != 6 {
+			t.Fatal("member lost a complete width/mask row", member, count)
+		}
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VCOMPRESSPD X16,X18", []byte{0x62, 0xa2, 0xfd, 0x08, 0x8a, 0xc2}},
+		{"VPCOMPRESSB.Z Z16,K1,(AX)", []byte{0x62, 0xe2, 0x7d, 0xc9, 0x63, 0x00}},
+		{"VEXPANDPS (AX),Y18", []byte{0x62, 0xe2, 0x7d, 0x28, 0x88, 0x10}},
+		{"VPEXPANDW.Z X16,K1,X18", []byte{0x62, 0xa2, 0xfd, 0x89, 0x62, 0xd0}},
+	})
+}
+
+func TestX86CompactExpandRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, member := range strings.Fields(x86CompactExpandTestMembers) {
+		for _, mutation := range []string{"source width", "result width", "direction", "immediate", "K result", "K0 mask", "arity",
+			"full tuple", "BCST", "SAE", "rounding", "no zeroing", "W", "PP", "map", "VEX", "offset", "row index", "short payload", "opcode extent"} {
+			t.Run(member+"/"+mutation, func(t *testing.T) {
+				found := 0
+				for _, original := range rules {
+					if original.Opcode != member || original.RowIndex != 1 {
+						continue
+					}
+					found++
+					if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+						t.Fatal("negative requires its valid original", original, err)
+					}
+					row := original
+					row.Classes, row.OpBytes = append([]string(nil), original.Classes...), append([]string(nil), original.OpBytes...)
+					header, feature := row.EncodingOffset, row.EncodingOffset+1
+					switch mutation {
+					case "source width":
+						row.Classes[0] = strings.Replace(row.Classes[0], "x", "y", 1)
+					case "result width":
+						row.Classes[2] = strings.Replace(row.Classes[2], "x", "y", 1)
+					case "direction":
+						row.Classes[0], row.Classes[2] = row.Classes[2], row.Classes[0]
+					case "immediate":
+						row.Classes[0] = "Yu8"
+					case "K result":
+						row.Classes[2] = "Yk"
+					case "K0 mask":
+						row.Classes[1] = "Yk"
+					case "arity":
+						row.Classes = append(row.Classes, "Yk")
+					case "full tuple":
+						row.OpBytes[feature] = "evexN16|evexZeroingEnabled"
+					case "BCST":
+						row.OpBytes[feature] += "|evexBcstN4"
+					case "SAE":
+						row.OpBytes[feature] += "|evexSaeEnabled"
+					case "rounding":
+						row.OpBytes[feature] += "|evexRoundingEnabled"
+					case "no zeroing":
+						row.OpBytes[feature] = strings.ReplaceAll(row.OpBytes[feature], "evexZeroingEnabled", "")
+					case "W":
+						if strings.Contains(row.OpBytes[header], "evexW0") {
+							row.OpBytes[header] = strings.ReplaceAll(row.OpBytes[header], "evexW0", "evexW1")
+						} else {
+							row.OpBytes[header] = strings.ReplaceAll(row.OpBytes[header], "evexW1", "evexW0")
+						}
+					case "PP":
+						row.OpBytes[header] = strings.ReplaceAll(row.OpBytes[header], "evex66", "evexF3")
+					case "map":
+						row.OpBytes[header] = strings.ReplaceAll(row.OpBytes[header], "evex0F38", "evex0F3A")
+					case "VEX":
+						row.ZCase = "Zvex_rm_v_r"
+					case "offset":
+						row.EncodingOffset++
+					case "row index":
+						row.RowIndex++
+					case "short payload":
+						row.OpBytes = row.OpBytes[:8]
+					case "opcode extent":
+						row.OpBytes[header+2] = "256"
+					}
+					if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+						t.Fatal("foreign compact/expand axis accepted", mutation, row)
+					}
+				}
+				if found != 1 {
+					t.Fatal("negative lost its complete official member", member, found)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_condition.go b/internal/goasmrules/x86_witness_condition.go
new file mode 100644
index 000000000..47e4bb880
--- /dev/null
+++ b/internal/goasmrules/x86_witness_condition.go
@@ -0,0 +1,133 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86ConditionRow retains the Go source row. Branch layout and byte writes
+// share condition inputs, not CFG, numerical, native or address authority.
+type X86ConditionRow struct {
+	ID, Opcode string
+	Branch     bool
+	Witnesses  []X86ConditionWitness
+}
+
+type X86ConditionWitness struct {
+	Instruction, Layout string
+	Encoding            []byte
+}
+
+// X86ConditionalRows covers both complete legacy condition families. The
+// fixed closed layouts use known instruction lengths, never actual Go bytes
+// as their expected displacement. Go remains the branch relaxation engine.
+func X86ConditionalRows(catalog X86LegacyCatalog, arch string) ([]X86ConditionRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("conditional rows require a Go x86 mode")
+	}
+	var result []X86ConditionRow
+	names := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		branch := entry.Ytab == "yjcond"
+		if !branch && (entry.Ytab != "yscond" || !strings.HasPrefix(entry.Opcode, "SET")) {
+			continue
+		}
+		if names[entry.Opcode] {
+			return nil, fmt.Errorf("duplicate conditional member %s", entry.Opcode)
+		}
+		names[entry.Opcode] = true
+		payload, err := x86ConditionPayload(entry, branch)
+		if err != nil {
+			return nil, err
+		}
+		for _, operand := range entry.Rows {
+			row := X86ConditionRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex), Opcode: entry.Opcode, Branch: branch}
+			if branch {
+				hint := ""
+				if operand.RowIndex != 0 {
+					hint = fmt.Sprintf("$%d,", operand.RowIndex-1)
+				}
+				move := 3 // MOVQ GP,GP and CMPQ GP,GP; no handwritten jump padding.
+				if arch == "386" {
+					move = 2
+				}
+				for _, layout := range []struct {
+					name         string
+					displacement int
+				}{
+					{"short-forward", move},
+					{"near-forward", 128 + move},
+					{"short-backward", -(2*move + 4)},
+					{"near-backward", -(2*move + 139)},
+				} {
+					code := []byte{payload[0], byte(layout.displacement)}
+					if strings.HasPrefix(layout.name, "near") {
+						code = []byte{0x0f, payload[1]}
+						for index := 0; index < 4; index++ {
+							code = append(code, byte(uint32(layout.displacement)>>uint(index*8)))
+						}
+					}
+					row.Witnesses = append(row.Witnesses, X86ConditionWitness{Instruction: entry.Opcode + " " + hint + "taken", Layout: layout.name, Encoding: code})
+				}
+			} else {
+				for _, destination := range []struct {
+					name  string
+					modrm byte
+				}{{"AX", 0xc0}, {"AH", 0xc4}, {"0(SI)", 0x06}} {
+					code := append(append([]byte(nil), payload[:2]...), destination.modrm)
+					row.Witnesses = append(row.Witnesses, X86ConditionWitness{Instruction: entry.Opcode + " " + destination.name, Layout: destination.name, Encoding: code})
+				}
+			}
+			result = append(result, row)
+		}
+	}
+	if len(names) != 32 || len(result) != 64 {
+		return nil, fmt.Errorf("incomplete condition closure: names=%d rows=%d", len(names), len(result))
+	}
+	return result, nil
+}
+
+func x86ConditionPayload(entry X86LegacyOpcode, branch bool) ([]byte, error) {
+	fail := func() ([]byte, error) {
+		return nil, fmt.Errorf("unmodeled complete conditional schema/payload: %s", entry.Opcode)
+	}
+	var payload []byte
+	for _, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return fail()
+		}
+		payload = append(payload, byte(value))
+	}
+	if entry.Kind != "encoding" {
+		return fail()
+	}
+	if branch {
+		if entry.Ytab != "yjcond" || entry.Prefix != "Px" || entry.EscapeAdjustment != 0 || len(entry.Rows) != 3 ||
+			len(payload) != 2 && len(payload) != 3 || payload[0] < 0x70 || payload[0] > 0x7f ||
+			payload[1] != payload[0]+0x10 || len(payload) == 3 && payload[2] != 0 {
+			return fail()
+		}
+		for index, row := range entry.Rows {
+			classes := []string{"Ybr", "Yi0,Ybr", "Yi1,Ybr"}[index]
+			stride := 0
+			if index == 2 {
+				stride = 1
+			}
+			if row.RowIndex != index || row.ZCase != "Zbr" || row.ZOffset != stride || row.UnmatchedOffset != 0 || strings.Join(row.Classes, ",") != classes {
+				return fail()
+			}
+		}
+	} else {
+		if entry.Ytab != "yscond" || entry.Prefix != "Pb" || entry.EscapeAdjustment != 1 || len(entry.Rows) != 1 ||
+			len(payload) != 3 || payload[0] != 0x0f || payload[1] < 0x90 || payload[1] > 0x9f || payload[2] != 0 {
+			return fail()
+		}
+		row := entry.Rows[0]
+		if row.RowIndex != 0 || row.ZCase != "Zo_m" || row.ZOffset != 2 || row.UnmatchedOffset != 0 || strings.Join(row.Classes, ",") != "Ymb" {
+			return fail()
+		}
+	}
+	return payload, nil
+}
diff --git a/internal/goasmrules/x86_witness_condition_test.go b/internal/goasmrules/x86_witness_condition_test.go
new file mode 100644
index 000000000..87e8266ec
--- /dev/null
+++ b/internal/goasmrules/x86_witness_condition_test.go
@@ -0,0 +1,146 @@
+package goasmrules
+
+import (
+	"bytes"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ConditionalCompleteRowsAndLayouts(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ConditionalRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		names, ids := map[string]bool{}, map[string]bool{}
+		branches, sets, forms := 0, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || ids[row.ID] {
+				t.Fatal("lost ordered source ID", row)
+			}
+			ids[row.ID], names[row.Opcode] = true, true
+			want := 3
+			if row.Branch {
+				want = 4
+				branches++
+			} else {
+				sets++
+			}
+			if len(row.Witnesses) != want {
+				t.Fatal("lost complete control/byte layouts", row)
+			}
+			seen := map[string]bool{}
+			for _, w := range row.Witnesses {
+				if seen[w.Layout] || !strings.HasPrefix(w.Instruction, row.Opcode+" ") || len(w.Encoding) == 0 {
+					t.Fatal("duplicate/empty physical layout", row, w)
+				}
+				seen[w.Layout] = true
+				forms++
+			}
+		}
+		if len(rows) != 64 || len(names) != 32 || branches != 48 || sets != 16 || forms != 240 {
+			t.Fatal("complete condition family changed", arch, len(rows), len(names), branches, sets, forms)
+		}
+	}
+	if _, err := X86ConditionalRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign source mode admitted")
+	}
+	if _, err := X86ConditionalRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("empty source treated as successful coverage")
+	}
+}
+
+func TestX86ConditionalIndependentEncodingAnchors(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, a := range []struct {
+		arch, instruction, layout string
+		code                      []byte
+	}{
+		{"amd64", "JNE taken", "short-forward", []byte{0x75, 3}},
+		{"amd64", "JNE $0,taken", "near-forward", []byte{0x0f, 0x85, 0x83, 0, 0, 0}},
+		{"amd64", "JNE $1,taken", "short-backward", []byte{0x75, 0xf6}},
+		{"amd64", "JNE taken", "near-backward", []byte{0x0f, 0x85, 0x6f, 0xff, 0xff, 0xff}},
+		{"386", "JNE taken", "short-forward", []byte{0x75, 2}},
+		{"386", "JNE $0,taken", "near-forward", []byte{0x0f, 0x85, 0x82, 0, 0, 0}},
+		{"386", "JNE $1,taken", "short-backward", []byte{0x75, 0xf8}},
+		{"386", "JNE taken", "near-backward", []byte{0x0f, 0x85, 0x71, 0xff, 0xff, 0xff}},
+		{"amd64", "SETCC AX", "AX", []byte{0x0f, 0x93, 0xc0}},
+		{"386", "SETEQ AH", "AH", []byte{0x0f, 0x94, 0xc4}},
+		{"amd64", "SETPS 0(SI)", "0(SI)", []byte{0x0f, 0x9a, 6}},
+	} {
+		t.Run(a.arch+"/"+a.instruction+"/"+a.layout, func(t *testing.T) {
+			rows, err := X86ConditionalRows(catalog, a.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			matches := 0
+			for _, r := range rows {
+				for _, w := range r.Witnesses {
+					if w.Instruction == a.instruction && w.Layout == a.layout {
+						matches++
+						if !bytes.Equal(w.Encoding, a.code) {
+							t.Fatalf("code=%x want=%x", w.Encoding, a.code)
+						}
+					}
+				}
+			}
+			if matches != 1 {
+				t.Fatal("anchor lost unique original row/layout", matches)
+			}
+		})
+	}
+}
+
+func TestX86ConditionalRejectsChangedSchemaBeforeProjection(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range []string{"JCC", "SETCC"} {
+		for _, entry := range catalog.Optab {
+			if entry.Opcode != opcode {
+				continue
+			}
+			for _, m := range []struct {
+				name   string
+				change func(*X86LegacyOpcode)
+			}{
+				{"kind", func(e *X86LegacyOpcode) { e.Kind = "special" }},
+				{"prefix", func(e *X86LegacyOpcode) { e.Prefix = "Pq" }},
+				{"table", func(e *X86LegacyOpcode) { e.Ytab = "unknown" }},
+				{"escape", func(e *X86LegacyOpcode) { e.EscapeAdjustment ^= 1 }},
+				{"row-count", func(e *X86LegacyOpcode) { e.Rows = e.Rows[:len(e.Rows)-1] }},
+				{"row-order", func(e *X86LegacyOpcode) { e.Rows[0].RowIndex = 9 }},
+				{"classes", func(e *X86LegacyOpcode) { e.Rows[0].Classes = []string{"Yi8", "Ybr"} }},
+				{"zcase", func(e *X86LegacyOpcode) { e.Rows[0].ZCase = "Zjmp" }},
+				{"stride", func(e *X86LegacyOpcode) { e.Rows[0].ZOffset++ }},
+				{"offset", func(e *X86LegacyOpcode) { e.Rows[0].UnmatchedOffset++ }},
+				{"extra-payload", func(e *X86LegacyOpcode) { e.OpBytes = append(e.OpBytes, "0") }},
+				{"symbol-payload", func(e *X86LegacyOpcode) { e.OpBytes[0] = "opcode" }},
+				{"nonzero-tail", func(e *X86LegacyOpcode) { e.OpBytes[len(e.OpBytes)-1] = "1" }},
+			} {
+				t.Run(opcode+"/"+m.name, func(t *testing.T) {
+					branch := opcode == "JCC"
+					if _, err := x86ConditionPayload(entry, branch); err != nil {
+						t.Fatal("valid original failed before mutation", err)
+					}
+					changed := entry
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					m.change(&changed)
+					if _, err := x86ConditionPayload(changed, branch); err == nil {
+						t.Fatal("changed physical source axis admitted")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_conditional_move_test.go b/internal/goasmrules/x86_witness_conditional_move_test.go
new file mode 100644
index 000000000..65b07327a
--- /dev/null
+++ b/internal/goasmrules/x86_witness_conditional_move_test.go
@@ -0,0 +1,149 @@
+package goasmrules
+
+import (
+	"bytes"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ConditionalMoveCompleteOfficialRowsAndModes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, names := 0, map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if !strings.HasPrefix(entry.Opcode, "CMOV") {
+			continue
+		}
+		names[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			rows++
+			t.Run(entry.Opcode, func(t *testing.T) {
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, "amd64")
+				if err != nil || len(witnesses) != 2 {
+					t.Fatal("complete original CMOV Yml-to-Yrl row lacks register/memory witnesses", err, len(witnesses))
+				}
+			})
+		}
+	}
+	if rows != 48 || len(names) != 48 {
+		t.Fatal("complete independent conditional-move source closure changed", rows, len(names))
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ConditionalMoveRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		filtered, witnesses := 0, 0
+		ids := map[string]bool{}
+		for _, row := range rows {
+			if row.ID == "" || ids[row.ID] || !names[row.Opcode] {
+				t.Fatal("conditional move lost its unique original source identity", row)
+			}
+			ids[row.ID] = true
+			if row.ModeFiltered != "" {
+				if arch != "386" || row.Opcode[4] != 'Q' || len(row.Witnesses) != 0 {
+					t.Fatal("mode filtering invented or removed a physical witness", row)
+				}
+				filtered++
+			} else {
+				if len(row.Witnesses) != 2 {
+					t.Fatal("conditional register/memory source alternative disappeared", row)
+				}
+				witnesses += len(row.Witnesses)
+			}
+		}
+		wantFiltered, wantWitnesses := 0, 96
+		if arch == "386" {
+			wantFiltered, wantWitnesses = 16, 64
+		}
+		if len(rows) != 48 || filtered != wantFiltered || witnesses != wantWitnesses {
+			t.Fatal("source/mode denominator changed", arch, len(rows), filtered, witnesses)
+		}
+	}
+}
+
+func TestX86ConditionalMoveOrderedPayloadAnchorsAndControls(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := X86ConditionalMoveRows(catalog, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, anchor := range []struct {
+		instruction string
+		code        []byte
+	}{
+		{"CMOVWCC CX,BX", []byte{0x66, 0x0f, 0x43, 0xd9}},
+		{"CMOVLCC 0(SI),BX", []byte{0x0f, 0x43, 0x1e}},
+		{"CMOVQCC CX,BX", []byte{0x48, 0x0f, 0x43, 0xd9}},
+	} {
+		found := 0
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				if witness.Instruction == anchor.instruction {
+					found++
+					if !bytes.Equal(witness.Encoding, anchor.code) {
+						t.Fatal("original complete prefix/opcode/ModRM changed", anchor.instruction, witness.Encoding, anchor.code)
+					}
+				}
+			}
+		}
+		if found != 1 {
+			t.Fatal("missing or repeated independent payload anchor", anchor.instruction, found)
+		}
+	}
+	if _, err := X86ConditionalMoveRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign mode acquired x86 source rows")
+	}
+	if _, err := X86ConditionalMoveRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("empty source closure accepted")
+	}
+	for index, entry := range catalog.Optab {
+		if entry.Opcode != "CMOVLCC" {
+			continue
+		}
+		for _, change := range []string{"missing", "duplicate", "prefix", "classes", "zcase", "zoffset", "rowindex", "offset", "extent", "foreign-table"} {
+			t.Run(change, func(t *testing.T) {
+				copy := catalog
+				copy.Optab = append([]X86LegacyOpcode(nil), catalog.Optab...)
+				modified := entry
+				modified.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				modified.OpBytes = append([]string(nil), entry.OpBytes...)
+				switch change {
+				case "missing":
+					copy.Optab = append(copy.Optab[:index], copy.Optab[index+1:]...)
+				case "duplicate":
+					copy.Optab = append(copy.Optab, entry)
+				case "prefix":
+					modified.Prefix = "Px"
+				case "classes":
+					modified.Rows[0].Classes = []string{"Yxm", "Yxr"}
+				case "zcase":
+					modified.Rows[0].ZCase = "Zr_m"
+				case "zoffset":
+					modified.Rows[0].ZOffset++
+				case "rowindex":
+					modified.Rows[0].RowIndex++
+				case "offset":
+					modified.Rows[0].UnmatchedOffset++
+				case "extent":
+					modified.OpBytes = append(modified.OpBytes, "0")
+				case "foreign-table":
+					modified.Ytab = "yaddl"
+				}
+				if change != "missing" && change != "duplicate" {
+					copy.Optab[index] = modified
+				}
+				if _, err := X86ConditionalMoveRows(copy, "amd64"); err == nil {
+					t.Fatal("changed complete source attributes were accepted", change)
+				}
+			})
+		}
+		break
+	}
+}
diff --git a/internal/goasmrules/x86_witness_conversion76_test.go b/internal/goasmrules/x86_witness_conversion76_test.go
new file mode 100644
index 000000000..495450813
--- /dev/null
+++ b/internal/goasmrules/x86_witness_conversion76_test.go
@@ -0,0 +1,123 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// An independent source namespace, separate from ordinary packed numeric
+// conversion. Every literal record is passed to the existing witness helper.
+func TestX86PrecisionHalfScalarConversionOfficialSourceWitnesses(t *testing.T) {
+	names := strings.Fields(`
+		VCVTPD2PS VCVTPD2PSX VCVTPD2PSY VCVTPS2PD
+		VCVTPH2PS VCVTPS2PH VCVTSD2SS VCVTSS2SD
+		VCVTSD2SI VCVTSD2SIQ VCVTSS2SI VCVTSS2SIQ
+		VCVTTSD2SI VCVTTSD2SIQ VCVTTSS2SI VCVTTSS2SIQ
+		VCVTSD2USIL VCVTSD2USIQ VCVTSS2USIL VCVTSS2USIQ
+		VCVTTSD2USIL VCVTTSD2USIQ VCVTTSS2USIL VCVTTSS2USIQ
+		VCVTSI2SDL VCVTSI2SDQ VCVTSI2SSL VCVTSI2SSQ
+		VCVTUSI2SDL VCVTUSI2SDQ VCVTUSI2SSL VCVTUSI2SSQ
+	`)
+	selected := make(map[string]bool)
+	for _, name := range names {
+		if selected[name] {
+			t.Fatal("duplicate independent source member", name)
+		}
+		selected[name] = true
+	}
+	if len(selected) != 32 {
+		t.Fatal("complete precision/half/scalar source namespace changed", len(selected))
+	}
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, rows := make(map[string]bool), 0
+	for index, rule := range rules {
+		if !selected[rule.Opcode] {
+			continue
+		}
+		seen[rule.Opcode] = true
+		rows++
+		t.Run(fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex), func(t *testing.T) {
+			witnesses, err := x86PackedAVXRowWitnesses(rule)
+			if err != nil || len(witnesses) == 0 {
+				t.Fatal("complete original conversion row has no current physical witness", err)
+			}
+			for _, witness := range witnesses {
+				if len(witness.Encoding) == 0 || witness.Instruction == "" {
+					t.Fatal("physical witness lost its source or expected encoding", rule, witness)
+				}
+			}
+		})
+	}
+	if rows != 76 || len(seen) != 32 {
+		t.Fatal("source closure must retain every original row and member", rows, len(seen))
+	}
+}
+
+func TestX86PrecisionHalfScalarConversionRejectsMutatedSourceMetadata(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := X86PrecisionHalfScalarConversionRows(X86LegacyCatalog{}, avx)
+	if err != nil || len(rows) != 76 {
+		t.Fatal("complete source positive", len(rows), err)
+	}
+	selected := make(map[string]bool)
+	for _, row := range rows {
+		selected[row.ID] = true
+	}
+	checked := 0
+	for index, original := range avx {
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, original.Opcode, original.Ytab, original.RowIndex)
+		if !selected[id] {
+			continue
+		}
+		checked++
+		t.Run(id, func(t *testing.T) {
+			valid, err := x86PackedAVXRowWitnesses(original)
+			if err != nil || len(valid) == 0 {
+				t.Fatal("valid original must precede rejection controls", err)
+			}
+			for _, axis := range []string{"prefix", "row", "zoffset", "encoding-offset", "roles", "header", "zcase", "opcode-byte"} {
+				t.Run(axis, func(t *testing.T) {
+					changed := original
+					changed.Classes = append([]string(nil), original.Classes...)
+					changed.OpBytes = append([]string(nil), original.OpBytes...)
+					switch axis {
+					case "prefix":
+						changed.Prefix = "Pm"
+					case "row":
+						changed.RowIndex += 100
+					case "zoffset":
+						changed.ZOffset += 100
+					case "encoding-offset":
+						changed.EncodingOffset += len(changed.OpBytes)
+					case "roles":
+						changed.Classes[0] = "Yxxx"
+					case "header":
+						changed.OpBytes[changed.EncodingOffset] += " | evexInventedPermission"
+					case "zcase":
+						changed.ZCase = "Zinvalid"
+					case "opcode-byte":
+						stride := 2
+						if strings.HasPrefix(changed.ZCase, "Zevex_") {
+							stride = 3
+						}
+						changed.OpBytes[changed.EncodingOffset+stride-1] = "0x100"
+					}
+					if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+						t.Fatal("corrupted source metadata granted a legal physical format", axis, original, changed)
+					}
+				})
+			}
+		})
+	}
+	if checked != 76 {
+		t.Fatal("complete source controls changed", checked)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_conversion_remainder.go b/internal/goasmrules/x86_witness_conversion_remainder.go
new file mode 100644
index 000000000..6c00e418c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_conversion_remainder.go
@@ -0,0 +1,383 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// The six remaining ytabs reuse existing carriers and encoders.
+// The fourteen already-supported rows retain their existing dispatcher path.
+func x86ConversionRemainderTable(table string) bool {
+	switch table {
+	case "_yvcvtph2ps", "_yvcvtps2ph", "_yvcvtsd2si", "_yvcvtsd2usil", "_yvcvtsi2sdl", "_yvcvtusi2sdl":
+		return true
+	}
+	return false
+}
+
+// A fixed physical header is validated against its original source payload.
+// This reads no opcode-value registry, normalized operand or source permission.
+func x86ConversionRemainderEncoding(rule X86AVXRule, op x86PackedAVXOpcode, features []string) (x86PackedAVXOpcode, error) {
+	stride := 2
+	if op.kind == "evex" {
+		stride = 3
+	}
+	offset := rule.EncodingOffset
+	if rule.Prefix != "Pavx" || offset < 0 || offset+stride > len(rule.OpBytes) {
+		return op, fmt.Errorf("conversion prefix/payload boundary differs")
+	}
+	header := []string{
+		"avxEscape",
+		op.kind + strconv.Itoa([]int{128, 256, 512}[op.length]),
+		op.kind + map[byte]string{1: "0F", 2: "0F38", 3: "0F3A"}[op.mapByte],
+		op.kind + map[byte]string{0: "W0", 0x80: "W1"}[op.wBit],
+	}
+	if op.pp != 0 {
+		header = append(header, op.kind+map[byte]string{1: "66", 2: "F3", 3: "F2"}[op.pp])
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], header, nil); err != nil {
+		return op, err
+	}
+	if op.kind == "evex" {
+		if len(features) == 0 {
+			features = []string{"0"}
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], features, nil); err != nil {
+			return op, err
+		}
+	}
+	value, err := strconv.ParseUint(rule.OpBytes[offset+stride-1], 0, 8)
+	if err != nil {
+		return op, err
+	}
+	op.opcode = byte(value)
+	return op, nil
+}
+
+func x86ConversionRemainderPackedFormatForRule(rule X86AVXRule) (x86PackedNumericConversionFormat, error) {
+	f := x86PackedNumericConversionFormat{masked: rule.ZCase == "Zevex_rm_k_r"}
+	fail := func() (x86PackedNumericConversionFormat, error) {
+		return f, fmt.Errorf("precision/half widening carrier, tuple or controls differ")
+	}
+	if rule.Ytab != "_yvcvtph2ps" || rule.Opcode != "VCVTPH2PS" && rule.Opcode != "VCVTPS2PD" || rule.EncodingOffset < 0 || rule.EncodingOffset >= len(rule.OpBytes) {
+		return fail()
+	}
+	kind := "vex"
+	if strings.HasPrefix(rule.ZCase, "Zevex_") {
+		kind = "evex"
+	}
+	width := 128
+	if hasEncodingTerm(rule.OpBytes[rule.EncodingOffset], kind+"256") {
+		width = 256
+	} else if hasEncodingTerm(rule.OpBytes[rule.EncodingOffset], kind+"512") {
+		width = 512
+	}
+	index, offset, zoffset := width/256, 2*(width/256), 2
+	source, result := "Yxm", map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[width]
+	if kind == "evex" {
+		order := map[int]int{512: 0, 128: 1, 256: 2}[width]
+		index, offset, zoffset = 2+2*order, 4+3*order, 0
+		source = map[int]string{128: "YxmEvex", 256: "YxmEvex", 512: "YymEvex"}[width]
+		if width < 512 {
+			result += "Evex"
+		}
+		if f.masked {
+			index++
+			zoffset = 3
+		}
+	} else if width == 512 {
+		return fail()
+	}
+	classes := []string{source, result}
+	if f.masked {
+		classes = []string{source, "Yknot0", result}
+	}
+	if rule.ZCase != "Z"+kind+"_rm_v_r" && !f.masked ||
+		strings.Join(rule.Classes, ",") != strings.Join(classes, ",") || rule.RowIndex != index ||
+		rule.EncodingOffset != offset || rule.ZOffset != zoffset || len(rule.OpBytes) != 13 {
+		return fail()
+	}
+	f.source, f.result, f.tuple = maxConversionCarrier(width/2), width, width/16
+	op := x86PackedAVXOpcode{kind: kind, mapByte: 1, length: byte(width / 256)}
+	if rule.Opcode == "VCVTPH2PS" {
+		op.mapByte, op.pp = 2, 1
+	} else if kind == "evex" {
+		f.broadcast = 4
+	}
+	var features []string
+	if kind == "evex" {
+		features = []string{"evexN" + strconv.Itoa(f.tuple), "evexZeroingEnabled"}
+		if f.broadcast != 0 {
+			features = append(features, "evexBcstN4")
+		}
+		if width == 512 {
+			f.sae = true
+			features = append(features, "evexSaeEnabled")
+		}
+	}
+	var err error
+	f.encoding, err = x86ConversionRemainderEncoding(rule, op, features)
+	return f, err
+}
+
+func x86ConversionRemainderHalfFormatForRule(rule X86AVXRule) (x86PackedUnaryMemoryFormat, int, bool, error) {
+	f := x86PackedUnaryMemoryFormat{store: true, masked: rule.ZCase == "Zevex_i_r_k_rm"}
+	fail := func() (x86PackedUnaryMemoryFormat, int, bool, error) {
+		return f, 0, false, fmt.Errorf("half narrowing immediate/carriers/tuple differ")
+	}
+	if rule.Ytab != "_yvcvtps2ph" || rule.Opcode != "VCVTPS2PH" || rule.EncodingOffset < 0 || rule.EncodingOffset >= len(rule.OpBytes) {
+		return fail()
+	}
+	kind, selector := "vex", 7
+	if strings.HasPrefix(rule.ZCase, "Zevex_") {
+		kind = "evex"
+	}
+	width := 128
+	if hasEncodingTerm(rule.OpBytes[rule.EncodingOffset], kind+"256") {
+		width = 256
+	} else if hasEncodingTerm(rule.OpBytes[rule.EncodingOffset], kind+"512") {
+		width = 512
+	}
+	index, offset, zoffset := 2*(width/256), 2*(width/256), 0
+	source, result, immediate := map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[width], "Yxm", "Yu8"
+	if kind == "evex" {
+		order := map[int]int{512: 0, 128: 1, 256: 2}[width]
+		index, offset = 4+2*order, 4+3*order
+		if width < 512 {
+			source += "Evex"
+		}
+		result = map[int]string{128: "YxmEvex", 256: "YxmEvex", 512: "YymEvex"}[width]
+		if f.masked {
+			index++
+			zoffset = 3
+		}
+	} else {
+		if width == 512 || len(rule.Classes) < 1 {
+			return fail()
+		}
+		if rule.Classes[0] == "Yi8" {
+			selector, immediate, zoffset = -1, "Yi8", 2
+			index++
+		}
+	}
+	classes := []string{immediate, source, result}
+	if f.masked {
+		classes = []string{immediate, source, "Yknot0", result}
+	}
+	if rule.ZCase != "Z"+kind+"_i_r_rm" && !f.masked ||
+		strings.Join(rule.Classes, ",") != strings.Join(classes, ",") || rule.RowIndex != index ||
+		rule.EncodingOffset != offset || rule.ZOffset != zoffset || len(rule.OpBytes) != 13 {
+		return fail()
+	}
+	f.width, f.tuple, f.carrier = width, width/16, maxConversionCarrier(width/2)/8
+	features := []string{}
+	sae := kind == "evex" && width == 512
+	if kind == "evex" {
+		features = []string{"evexN" + strconv.Itoa(f.tuple), "evexZeroingEnabled"}
+		if sae {
+			features = append(features, "evexSaeEnabled")
+		}
+	}
+	var err error
+	f.encoding, err = x86ConversionRemainderEncoding(rule, x86PackedAVXOpcode{kind: kind, mapByte: 3, pp: 1, length: byte(width / 256)}, features)
+	return f, selector, sae, err
+}
+
+// The two scalar transports keep GP result and vector-upper copy distinct.
+// Scalar tuple and encoded W remain independent of mode32's effective GP word.
+type x86ConversionRemainderScalarFormat struct {
+	gpResult, rounding, sae bool
+	encoding                x86PackedAVXOpcode
+}
+
+func x86ConversionRemainderScalarFormatForRule(rule X86AVXRule) (x86ConversionRemainderScalarFormat, error) {
+	f := x86ConversionRemainderScalarFormat{gpResult: rule.Ytab == "_yvcvtsd2si" || rule.Ytab == "_yvcvtsd2usil"}
+	fail := func() (x86ConversionRemainderScalarFormat, error) {
+		return f, fmt.Errorf("scalar conversion GP/upper/result roles differ")
+	}
+	if !strings.HasPrefix(rule.Opcode, "VCVT") {
+		return fail()
+	}
+	left, right, ok := strings.Cut(strings.TrimPrefix(rule.Opcode, "VCVT"), "2")
+	if !ok {
+		return fail()
+	}
+	kind := "vex"
+	if strings.HasPrefix(rule.ZCase, "Zevex_") {
+		kind = "evex"
+	}
+	unsigned := rule.Ytab == "_yvcvtsd2usil" || rule.Ytab == "_yvcvtusi2sdl"
+	if unsigned && kind != "evex" {
+		return fail()
+	}
+	precision, gp64, tuple := "", false, 4
+	if f.gpResult {
+		truncated := strings.HasPrefix(left, "T")
+		precision = strings.TrimPrefix(left, "T")
+		if precision != "SS" && precision != "SD" || !unsigned && right != "SI" && right != "SIQ" || unsigned && right != "USIL" && right != "USIQ" {
+			return fail()
+		}
+		gp64 = strings.HasSuffix(right, "Q")
+		if precision == "SD" {
+			tuple = 8
+		}
+		f.sae, f.rounding = kind == "evex" && truncated, kind == "evex" && !truncated
+	} else {
+		if rule.Ytab != "_yvcvtsi2sdl" && rule.Ytab != "_yvcvtusi2sdl" || !unsigned && left != "SI" || unsigned && left != "USI" || len(right) != 3 {
+			return fail()
+		}
+		precision, gp64 = right[:2], right[2] == 'Q'
+		if precision != "SS" && precision != "SD" || right[2] != 'Q' && right[2] != 'L' {
+			return fail()
+		}
+		if gp64 {
+			tuple = 8
+		}
+		f.rounding = kind == "evex" && (gp64 || precision == "SS")
+	}
+	index, offset, zoffset, extent := 0, 0, 2, 5
+	if kind == "evex" {
+		index, offset, zoffset = 1, 2, 3
+	}
+	if unsigned {
+		index, offset, extent = 0, 0, 3
+	}
+	classes := []string{"Yml", "Yxr", "Yxr"}
+	if f.gpResult {
+		classes = []string{"Yxm", "Yrl"}
+	}
+	if kind == "evex" {
+		if f.gpResult {
+			classes[0] += "Evex"
+		} else {
+			classes[1] += "Evex"
+			classes[2] += "Evex"
+		}
+	}
+	if rule.ZCase != "Z"+kind+"_rm_v_r" ||
+		strings.Join(rule.Classes, ",") != strings.Join(classes, ",") || rule.RowIndex != index ||
+		rule.EncodingOffset != offset || rule.ZOffset != zoffset || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	op := x86PackedAVXOpcode{kind: kind, mapByte: 1, pp: 2}
+	if precision == "SD" {
+		op.pp = 3
+	}
+	if gp64 {
+		op.wBit = 0x80
+	}
+	var features []string
+	if kind == "evex" {
+		features = []string{"evexN" + strconv.Itoa(tuple)}
+		if f.rounding {
+			features = append(features, "evexRoundingEnabled")
+		}
+		if f.sae {
+			features = append(features, "evexSaeEnabled")
+		}
+	}
+	var err error
+	f.encoding, err = x86ConversionRemainderEncoding(rule, op, features)
+	return f, err
+}
+
+func (f x86ConversionRemainderScalarFormat) witnesses(opcode string) []X86PackedBinaryWitness {
+	bank := 0
+	if f.encoding.kind == "evex" {
+		bank = 16
+	}
+	first, second, last := fmt.Sprint("X", bank), "", "CX"
+	reg, rm := 1, bank
+	vvvv, p2 := byte(0x78), byte(8)
+	if !f.gpResult {
+		first, second, last = "CX", fmt.Sprint("X", bank+1), fmt.Sprint("X", bank+2)
+		reg, rm = bank+2, 1
+		vvvv, p2 = byte(^(bank+1)&15)<<3, byte(1-(bank+1)/16)<<3
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, memory := range []bool{false, true} {
+		controls := []string{""}
+		if !memory {
+			if f.rounding {
+				controls = append(controls, "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE")
+			}
+			if f.sae {
+				controls = append(controls, "SAE")
+			}
+		}
+		for _, control := range controls {
+			source, r := first, rm
+			mod := byte(0xc0)
+			if memory {
+				source, r, mod = "(AX)", 0, 0
+			}
+			p0 := byte((1-reg/8&1)<<7 | (1-r/8&1)<<5 | (1-reg/16)<<4)
+			if memory || !f.gpResult {
+				p0 |= 0x40
+			} else {
+				p0 |= byte(1-r/16) << 6
+			}
+			flags := p2
+			suffix := ""
+			if control != "" {
+				suffix = "." + control
+				flags |= 0x10
+				if control != "SAE" {
+					flags |= map[string]byte{"RN_SAE": 0, "RD_SAE": 1, "RU_SAE": 2, "RZ_SAE": 3}[control] << 5
+				}
+			}
+			operands := source + "," + last
+			if second != "" {
+				operands = source + "," + second + "," + last
+			}
+			witnesses = append(witnesses, X86PackedBinaryWitness{
+				Instruction: opcode + suffix + " " + operands, Generation: f.encoding.kind,
+				First: source, Second: second, Destination: last, Width: 128, Memory: memory,
+				Encoding: f.encoding.bytes(vvvv, p0, flags, mod|byte(reg&7)<<3|byte(r&7)),
+			})
+		}
+	}
+	return witnesses
+}
+
+func x86ConversionRemainderRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	switch rule.Ytab {
+	case "_yvcvtph2ps":
+		f, err := x86ConversionRemainderPackedFormatForRule(rule)
+		if err != nil {
+			return nil, err
+		}
+		return f.witnesses(rule.Opcode), nil
+	case "_yvcvtps2ph":
+		f, selector, sae, err := x86ConversionRemainderHalfFormatForRule(rule)
+		if err != nil {
+			return nil, err
+		}
+		var result []X86PackedBinaryWitness
+		for _, w := range f.witnesses(rule.Opcode) {
+			name, operands, _ := strings.Cut(w.Instruction, " ")
+			w.Instruction = fmt.Sprintf("%s $%d,%s", name, selector, operands)
+			w.Encoding = append(w.Encoding, byte(selector))
+			result = append(result, w)
+			if sae && w.Destination != "(AX)" {
+				copy := w
+				suffix := ".SAE"
+				if w.Zeroing {
+					suffix += ".Z"
+				}
+				copy.Instruction = fmt.Sprintf("%s%s $%d,%s", rule.Opcode, suffix, selector, operands)
+				copy.Encoding = append([]byte(nil), w.Encoding...)
+				copy.Encoding[3] |= 0x10
+				result = append(result, copy)
+			}
+		}
+		return result, nil
+	default:
+		f, err := x86ConversionRemainderScalarFormatForRule(rule)
+		if err != nil {
+			return nil, err
+		}
+		return f.witnesses(rule.Opcode), nil
+	}
+}
diff --git a/internal/goasmrules/x86_witness_duplicate_test.go b/internal/goasmrules/x86_witness_duplicate_test.go
new file mode 100644
index 000000000..c963ab0c7
--- /dev/null
+++ b/internal/goasmrules/x86_witness_duplicate_test.go
@@ -0,0 +1,131 @@
+package goasmrules
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedDuplicateCompleteOfficialTransport(t *testing.T) {
+	// Existing helpers keep the initial failure in format admission, rather
+	// than compilation against a future family selector.
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx,
+				`MOVDDUP MOVSHDUP MOVSLDUP VMOVDDUP VMOVSHDUP VMOVSLDUP`)
+		}, `^V?MOV(D|SH|SL)DUP$`, `a^`, x86PackedRowCounts{
+			names: 6, rows: [3]int{3, 6, 18}, formats: [3]int{6, 12, 54}, widths: [3]int{30, 24, 18},
+		})
+	masked, zeroing, memory := 0, 0, 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if witness.Generation == "legacy" && witness.Second != witness.Destination ||
+				witness.Generation != "legacy" && witness.Second != "" ||
+				witness.First == "" || witness.Memory != (witness.First == "(AX)") || witness.MaskResult {
+				t.Fatal("duplicate unary syntax acquired a numerical second source or mask result", row.ID, witness)
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.Memory {
+				memory++
+			}
+		}
+	}
+	if masked != 36 || zeroing != 18 || memory != 36 {
+		t.Fatal("duplicate mask/zero/source controls changed", masked, zeroing, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"MOVDDUP (AX),X1", []byte{0xf2, 0x0f, 0x12, 0x08}},
+		{"MOVSHDUP X0,X1", []byte{0xf3, 0x0f, 0x16, 0xc8}},
+		{"MOVSLDUP (AX),X1", []byte{0xf3, 0x0f, 0x12, 0x08}},
+		{"VMOVDDUP X0,X2", []byte{0xc5, 0xfb, 0x12, 0xd0}},
+		{"VMOVSLDUP (AX),Y2", []byte{0xc5, 0xfe, 0x12, 0x10}},
+		{"VMOVDDUP X16,X18", []byte{0x62, 0xa1, 0xff, 0x08, 0x12, 0xd0}},
+		{"VMOVSHDUP.Z (AX),K1,Z18", []byte{0x62, 0xe1, 0x7e, 0xc9, 0x16, 0x10}},
+	})
+}
+
+func TestX86PackedDuplicateAVXPrefixesAndTupleTransport(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx, `VMOVDDUP VMOVSHDUP VMOVSLDUP`)
+		}, `^VMOV(D|SH|SL)DUP$`, `a^`, x86PackedRowCounts{
+			names: 3, rows: [3]int{0, 6, 18}, formats: [3]int{0, 12, 54}, widths: [3]int{24, 24, 18},
+		})
+	for _, row := range inventory.avx {
+		if row.Opcode != "VMOVDDUP" && row.Opcode != "VMOVSHDUP" && row.Opcode != "VMOVSLDUP" {
+			continue
+		}
+		stride, feature, prefix := 2, "", "vexF3"
+		if strings.HasPrefix(row.ZCase, "Zevex_") {
+			stride, prefix = 3, "evexF3"
+			feature = []string{"evexN16", "evexN32", "evexN64"}[(row.RowIndex-2)/2]
+		}
+		if row.Opcode == "VMOVDDUP" {
+			prefix = strings.Replace(prefix, "F3", "F2", 1)
+			if row.RowIndex == 2 || row.RowIndex == 3 {
+				feature = "evexN8"
+			}
+		}
+		if !hasEncodingTerm(row.OpBytes[row.EncodingOffset], prefix) ||
+			feature != "" && row.OpBytes[row.EncodingOffset+1] != feature+" | evexZeroingEnabled" ||
+			row.ZOffset != stride && row.ZOffset != 0 {
+			t.Fatal("duplicate prefixes or complete native source tuple changed", row)
+		}
+	}
+}
+
+func TestX86PackedDuplicateTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"DDUP full tuple", "SHDUP narrow tuple", "broadcast", "SAE", "rounding", "binary F2", "ABS F3"} {
+		t.Run(mutation, func(t *testing.T) {
+			name := "VMOVDDUP"
+			if mutation == "SHDUP narrow tuple" {
+				name = "VMOVSHDUP"
+			} else if mutation == "binary F2" {
+				name = "VPMULLD"
+			} else if mutation == "ABS F3" {
+				name = "VPABSD"
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != 2 {
+					continue
+				}
+				found++
+				changed := original
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				feature := changed.EncodingOffset + 1
+				switch mutation {
+				case "DDUP full tuple":
+					changed.OpBytes[feature] = strings.Replace(changed.OpBytes[feature], "evexN8", "evexN16", 1)
+				case "SHDUP narrow tuple":
+					changed.OpBytes[feature] = strings.Replace(changed.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "broadcast":
+					changed.OpBytes[feature] += " | evexBcstN8"
+				case "SAE":
+					changed.OpBytes[feature] += " | evexSaeEnabled"
+				case "rounding":
+					changed.OpBytes[feature] += " | evexRoundingEnabled"
+				case "binary F2":
+					changed.OpBytes[changed.EncodingOffset] = strings.Replace(changed.OpBytes[changed.EncodingOffset], "evex66", "evexF2", 1)
+				case "ABS F3":
+					changed.OpBytes[changed.EncodingOffset] = strings.Replace(changed.OpBytes[changed.EncodingOffset], "evex66", "evexF3", 1)
+				}
+				if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("duplicate format borrowed another tuple or broadened an old family", mutation, changed)
+				}
+			}
+			if found != 1 {
+				t.Fatal("foreign-axis control lost its exact original row", name, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_encoding.go b/internal/goasmrules/x86_witness_encoding.go
new file mode 100644
index 000000000..d4d4dadfd
--- /dev/null
+++ b/internal/goasmrules/x86_witness_encoding.go
@@ -0,0 +1,18 @@
+package goasmrules
+
+// Fixed VEX/EVEX prefix fields, shared by the audited operand transports.
+// Operand roles and legal controls are validated before these bytes are made.
+type x86PackedAVXOpcode struct {
+	kind                              string
+	mapByte, wBit, pp, length, opcode byte
+}
+
+func (op x86PackedAVXOpcode) bytes(vvvv, p0, p2, modrm byte) []byte {
+	if op.kind == "evex" {
+		return []byte{0x62, p0 | op.mapByte, op.wBit | vvvv | 0x04 | op.pp, p2, op.opcode, modrm}
+	}
+	if op.mapByte == 1 && op.wBit == 0 {
+		return []byte{0xc5, 0x80 | vvvv | op.pp | op.length<<2, op.opcode, modrm}
+	}
+	return []byte{0xc4, 0xe0 | op.mapByte, op.wBit | vvvv | op.pp | op.length<<2, op.opcode, modrm}
+}
diff --git a/internal/goasmrules/x86_witness_evex_remainder_test.go b/internal/goasmrules/x86_witness_evex_remainder_test.go
new file mode 100644
index 000000000..8df4576ff
--- /dev/null
+++ b/internal/goasmrules/x86_witness_evex_remainder_test.go
@@ -0,0 +1,127 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedEVEXBinaryRemainderOfficialRowsAndControls(t *testing.T) {
+	// Independent official attributes, not a translator registry. Syntax alone
+	// does not identify an operation's numerical old-destination dependency.
+	members := []struct {
+		name         string
+		opcode       byte
+		w, broadcast int
+	}{
+		{"VPDPBUSD", 0x50, 0, 4}, {"VPDPBUSDS", 0x51, 0, 4},
+		{"VPDPWSSD", 0x52, 0, 4}, {"VPDPWSSDS", 0x53, 0, 4},
+		{"VPERMB", 0x8d, 0, 0}, {"VPERMW", 0x8d, 1, 0},
+		{"VPERMI2B", 0x75, 0, 0}, {"VPERMI2W", 0x75, 1, 0},
+		{"VPERMI2D", 0x76, 0, 4}, {"VPERMI2Q", 0x76, 1, 8},
+		{"VPERMI2PS", 0x77, 0, 4}, {"VPERMI2PD", 0x77, 1, 8},
+		{"VPERMT2B", 0x7d, 0, 0}, {"VPERMT2W", 0x7d, 1, 0},
+		{"VPERMT2D", 0x7e, 0, 4}, {"VPERMT2Q", 0x7e, 1, 8},
+		{"VPERMT2PS", 0x7f, 0, 4}, {"VPERMT2PD", 0x7f, 1, 8},
+		{"VPMADD52HUQ", 0xb5, 1, 8}, {"VPMADD52LUQ", 0xb4, 1, 8},
+		{"VPMULTISHIFTQB", 0x83, 1, 8},
+		{"VPROLVD", 0x15, 0, 4}, {"VPROLVQ", 0x15, 1, 8},
+		{"VPRORVD", 0x14, 0, 4}, {"VPRORVQ", 0x14, 1, 8},
+		{"VPSHLDVW", 0x70, 1, 0}, {"VPSHLDVD", 0x71, 0, 4}, {"VPSHLDVQ", 0x71, 1, 8},
+		{"VPSHRDVW", 0x72, 1, 0}, {"VPSHRDVD", 0x73, 0, 4}, {"VPSHRDVQ", 0x73, 1, 8},
+	}
+	wanted, names, broadcasts := map[string]int{}, []string{}, []string{}
+	for index, member := range members {
+		wanted[member.name] = index
+		names = append(names, member.name)
+		if member.broadcast != 0 {
+			broadcasts = append(broadcasts, member.name)
+		}
+	}
+	inventory := x86CheckPackedRowInventory(t, X86PackedEVEXBinaryRemainderRows,
+		"^("+strings.Join(names, "|")+")$", "^("+strings.Join(broadcasts, "|")+")$", x86PackedRowCounts{
+			names: 31, broadcast: 207,
+			rows: [3]int{0, 0, 186}, formats: [3]int{0, 0, 765}, widths: [3]int{255, 255, 255},
+		})
+	existing := regexp.MustCompile(`^(VBLENDM(PS|PD)|VPBLENDM[BWDQ]|VP(ANDN?|OR|XOR)[DQ]|VP(MIN|MAX)[SU]Q|VPMULLQ|VPS(LLVW|RLVW|RAVW|RAVQ))$`)
+	classes := []string{"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+		"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex", "Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr"}
+	var expectedIDs []string
+	counts, prior := map[string]int{}, map[string]int{}
+	for index, rule := range inventory.avx {
+		memberIndex, selected := wanted[rule.Opcode]
+		if !selected {
+			if rule.Ytab == "_yvblendmpd" {
+				if !existing.MatchString(rule.Opcode) {
+					t.Fatal("official EVEX grammar acquired an unaccounted member", rule)
+				}
+				prior[rule.Opcode]++
+			}
+			continue
+		}
+		member, row := members[memberIndex], counts[rule.Opcode]
+		counts[rule.Opcode]++
+		zcase := "Zevex_rm_v_r"
+		if row%2 != 0 {
+			zcase = "Zevex_rm_v_k_r"
+		}
+		var payload []string
+		for _, width := range []int{128, 256, 512} {
+			features := fmt.Sprintf("evexN%d", width/8)
+			if member.broadcast != 0 {
+				features += fmt.Sprintf(" | evexBcstN%d", member.broadcast)
+			}
+			payload = append(payload, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d", width, member.w),
+				features+" | evexZeroingEnabled", fmt.Sprintf("0x%02X", member.opcode))
+		}
+		if row >= 6 || rule.RowIndex != row || rule.Ytab != "_yvblendmpd" || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase || rule.ZOffset != row%2*3 || rule.EncodingOffset != row/2*3 ||
+			strings.Join(rule.Classes, ",") != classes[row] || !reflect.DeepEqual(rule.OpBytes, payload) {
+			t.Fatal("independent complete EVEX row, tuple or opcode attributes changed", rule)
+		}
+		expectedIDs = append(expectedIDs, fmt.Sprintf("avx/%d/%s/_yvblendmpd/%d", index, rule.Opcode, row))
+	}
+	var actualIDs []string
+	zeroing := 0
+	for _, row := range inventory.rows {
+		actualIDs = append(actualIDs, row.ID)
+		for _, witness := range row.Witnesses {
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.MaskResult || strings.Contains(witness.Instruction, "SAE") {
+				t.Fatal("integer EVEX remainder acquired mask results or FP controls", row.ID, witness)
+			}
+		}
+	}
+	if len(counts) != 31 || len(prior) != 23 || len(expectedIDs) != 186 || zeroing != 255 ||
+		!reflect.DeepEqual(actualIDs, expectedIDs) {
+		t.Fatal("complete remainder lost official row identity, old join exclusions or controls", len(counts), len(prior), zeroing)
+	}
+	for name, count := range counts {
+		if count != 6 {
+			t.Fatal("incomplete retained member", name, count)
+		}
+	}
+	for name, count := range prior {
+		if count != 6 {
+			t.Fatal("previous joined member changed", name, count)
+		}
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VPERMB X16,X17,X18", []byte{0x62, 0xa2, 0x75, 0x00, 0x8d, 0xd0}},
+		{"VPERMW.Z (AX),Y17,K1,Y18", []byte{0x62, 0xe2, 0xf5, 0xa1, 0x8d, 0x10}},
+		{"VPMULTISHIFTQB.BCST.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0xf5, 0xd1, 0x83, 0x10}},
+		{"VPROLVD (AX),Y17,Y18", []byte{0x62, 0xe2, 0x75, 0x20, 0x15, 0x10}},
+		{"VPRORVQ.Z Z16,Z17,K1,Z18", []byte{0x62, 0xa2, 0xf5, 0xc1, 0x14, 0xd0}},
+		{"VPDPBUSD.BCST (AX),X17,X18", []byte{0x62, 0xe2, 0x75, 0x10, 0x50, 0x10}},
+		{"VPDPWSSDS.Z X16,X17,K1,X18", []byte{0x62, 0xa2, 0x75, 0x81, 0x53, 0xd0}},
+		{"VPMADD52HUQ.BCST.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0xf5, 0xd1, 0xb5, 0x10}},
+		{"VPERMI2B X16,X17,X18", []byte{0x62, 0xa2, 0x75, 0x00, 0x75, 0xd0}},
+		{"VPERMT2PD.BCST (AX),Y17,Y18", []byte{0x62, 0xe2, 0xf5, 0x30, 0x7f, 0x10}},
+		{"VPSHLDVW.Z Z16,Z17,K1,Z18", []byte{0x62, 0xa2, 0xf5, 0xc1, 0x70, 0xd0}},
+		{"VPSHRDVD.BCST.Z (AX),X17,K1,X18", []byte{0x62, 0xe2, 0x75, 0x91, 0x73, 0x10}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_exchange_test.go b/internal/goasmrules/x86_witness_exchange_test.go
new file mode 100644
index 000000000..75cd8502d
--- /dev/null
+++ b/internal/goasmrules/x86_witness_exchange_test.go
@@ -0,0 +1,182 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86ExchangeSchemaForTest(name string) []string {
+	if len(name) < 5 {
+		return nil
+	}
+	stem, width := name[:len(name)-1], name[len(name)-1]
+	if !strings.ContainsRune("BWLQ", rune(width)) {
+		return nil
+	}
+	if stem == "XADD" {
+		if width == 'B' {
+			return []string{"Zr_m/1/Yrb,Ymb"}
+		}
+		return []string{"Zr_m/1/Yrl,Yml"}
+	}
+	if stem != "XCHG" {
+		return nil
+	}
+	if width == 'B' {
+		return []string{"Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb"}
+	}
+	return []string{"Z_rp/1/Yax,Yrl", "Zrp_/1/Yrl,Yax", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"}
+}
+
+func TestX86ExchangeCompleteOriginalSourceTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, rows := 0, 0
+	for _, entry := range catalog.Optab {
+		schema := x86ExchangeSchemaForTest(entry.Opcode)
+		if schema == nil {
+			continue
+		}
+		names++
+		if len(entry.Rows) != len(schema) {
+			t.Fatal("complete exchange source table changed", entry.Opcode)
+		}
+		for _, row := range entry.Rows {
+			rows++
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				if got := fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")); got != schema[row.RowIndex] {
+					t.Fatal("independent exchange source schema changed", got)
+				}
+				before := fmt.Sprintf("%#v/%#v", entry, row)
+				for _, arch := range []string{"amd64", "386"} {
+					witnesses, err := x86ScalarRMWRowWitnesses(entry, row, arch)
+					if err != nil || len(witnesses) == 0 {
+						t.Error("EXCHANGE_SOURCE_TRANSPORT_GAP", arch, err)
+					}
+				}
+				if before != fmt.Sprintf("%#v/%#v", entry, row) {
+					t.Fatal("exchange formatter mutated its original source")
+				}
+			})
+		}
+	}
+	if names != 8 || rows != 18 {
+		t.Fatal("complete exchange inventory changed", names, rows)
+	}
+}
+
+func TestX86ExchangeCompleteSourceMetadataBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	maxInt := int(^uint(0) >> 1)
+	for _, entry := range catalog.Optab {
+		if x86ExchangeSchemaForTest(entry.Opcode) == nil {
+			continue
+		}
+		for _, selected := range entry.Rows {
+			for _, field := range []string{"original-arity", "selected-arity", "original-index", "selected-index", "original-offset", "selected-offset", "original-stride", "selected-stride", "earlier-row", "row-count", "source-role", "prefix", "nonbyte", "short", "extra", "zero", "symbolic", "escape-negative", "escape-overflow", "escape-opposite"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", entry.Opcode, selected.RowIndex, field), func(t *testing.T) {
+					changed, row := entry, selected
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					switch field {
+					case "original-arity":
+						changed.Rows[row.RowIndex].Classes = []string{strings.Join(row.Classes, ",")}
+					case "selected-arity":
+						row.Classes = []string{strings.Join(row.Classes, ",")}
+					case "original-index":
+						changed.Rows[row.RowIndex].RowIndex = -1
+					case "selected-index":
+						row.RowIndex = maxInt
+					case "original-offset":
+						changed.Rows[row.RowIndex].UnmatchedOffset = -maxInt - 1
+					case "selected-offset":
+						row.UnmatchedOffset = maxInt
+					case "original-stride":
+						changed.Rows[row.RowIndex].ZOffset = -maxInt - 1
+					case "selected-stride":
+						row.ZOffset = maxInt
+					case "earlier-row":
+						changed.Rows[0].Classes = []string{"Ynone"}
+					case "row-count":
+						changed.Rows = append(changed.Rows, row)
+					case "source-role":
+						changed.Opcode = "CMPXCHG" + entry.Opcode[len(entry.Opcode)-1:]
+					case "prefix":
+						changed.Prefix = "P32"
+					case "nonbyte":
+						changed.OpBytes[0] = "0x100"
+					case "short":
+						changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+					case "extra":
+						changed.OpBytes = append(changed.OpBytes, "0")
+					case "zero":
+						changed.OpBytes[0] = "0"
+					case "symbolic":
+						changed.OpBytes[0] = "Pm"
+					case "escape-negative":
+						changed.EscapeAdjustment = -maxInt - 1
+					case "escape-overflow":
+						changed.EscapeAdjustment = maxInt
+					case "escape-opposite":
+						changed.EscapeAdjustment = 1 - entry.EscapeAdjustment
+					}
+					defer func() {
+						if failure := recover(); failure != nil {
+							t.Error("EXCHANGE_SOURCE_SCHEMA_PANIC", failure)
+						}
+					}()
+					if reflect.DeepEqual(changed, entry) && reflect.DeepEqual(row, selected) {
+						t.Fatal("negative did not change source metadata")
+					}
+					if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+						t.Fatal("EXCHANGE_SOURCE_MALFORMED_ACCEPTED", field)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ExchangeSourceClosureBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mode := range []string{"", "arm64", "wasm"} {
+		if _, err := X86ExchangeRows(catalog, mode); err == nil {
+			t.Fatal("foreign mode acquired exchange source rows", mode)
+		}
+	}
+	if _, err := X86ExchangeRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("missing catalog acquired complete source closure")
+	}
+	for _, field := range []string{"missing", "duplicate", "foreign-table"} {
+		changed := catalog
+		changed.Optab = append([]X86LegacyOpcode(nil), catalog.Optab...)
+		for index, entry := range changed.Optab {
+			if entry.Opcode != "XADDL" {
+				continue
+			}
+			switch field {
+			case "missing":
+				changed.Optab = append(changed.Optab[:index], changed.Optab[index+1:]...)
+			case "duplicate":
+				changed.Optab = append(changed.Optab, entry)
+			case "foreign-table":
+				changed.Optab[index].Ytab = "yaddl"
+			}
+			break
+		}
+		if _, err := X86ExchangeRows(changed, "amd64"); err == nil {
+			t.Fatal("incomplete or contradictory exchange source closure", field)
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_explicit_simd.go b/internal/goasmrules/x86_witness_explicit_simd.go
new file mode 100644
index 000000000..c545826c5
--- /dev/null
+++ b/internal/goasmrules/x86_witness_explicit_simd.go
@@ -0,0 +1,260 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// This source-only projection shares literal/media transport across lane,
+// compare, implicit-X0 and sign-mask families. It grants no operand values,
+// memory tuple, MMX region, FLAGS or native-entry facts.
+func X86LegacyExplicitSIMDRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("explicit SIMD source view requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	for _, entry := range catalog.Optab {
+		if !x86LegacyExplicitSIMDMember(entry) {
+			continue
+		}
+		for _, original := range entry.Rows {
+			witnesses, err := x86LegacyExplicitSIMDRowWitnesses(entry, original)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, original.RowIndex, err)
+			}
+			row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, original.RowIndex), Opcode: entry.Opcode, Witnesses: witnesses}
+			if arch == "386" && entry.Prefix == "Pq3" {
+				row.ModeFiltered, row.Witnesses = "original Go rejects legacy REX.W in mode386", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(result) != 28 {
+		return nil, fmt.Errorf("incomplete original explicit SIMD source view: rows=%d", len(result))
+	}
+	return result, nil
+}
+
+func x86LegacyExplicitSIMDMember(entry X86LegacyOpcode) bool {
+	switch entry.Ytab {
+	case "yextractps", "yextrw", "yextr", "yinsrw", "yinsr", "yxcmpi", "yblendvpd", "ysha1rnds4", "ysha256rnds2", "yxrrl", "ymskb":
+		return true
+	case "yxr":
+		return entry.Prefix == "Pm" // MASKMOVOU retains its implicit-address owner.
+	case "yxm_q4":
+		return entry.Opcode == "PHMINPOSUW" || entry.Opcode == "PTEST"
+	case "yxshuf":
+		return entry.Opcode == "INSERTPS" // Explicit overlap with the complete literal view.
+	}
+	return false
+}
+
+func x86LegacyExplicitSIMDEncoding(entry X86LegacyOpcode, row X86LegacyOperand) ([]byte, error) {
+	fail := func() ([]byte, error) { return nil, fmt.Errorf("unmodeled complete explicit SIMD source schema") }
+	schemas := map[string][]string{
+		"yextractps": {"Zibr_m/2/Yu2,Yxr,Yml"},
+		"yextrw":     {"Zibm_r/2/Yu8,Yxr,Yrl", "Zibr_m/2/Yu8,Yxr,Yml"},
+		"yextr":      {"Zibr_m/3/Yu8,Yxr,Ymm"}, "yinsrw": {"Zibm_r/2/Yu8,Yml,Yxr"}, "yinsr": {"Zibm_r/3/Yu8,Ymm,Yxr"},
+		"yxcmpi": {"Zm_r_i_xm/2/Yxm,Yxr,Yi8"}, "yblendvpd": {"Z_m_r/1/Yxr0,Yxm,Yxr"},
+		"ysha1rnds4": {"Zibm_r/2/Yu2,Yxm,Yxr"}, "ysha256rnds2": {"Zlit_m_r/0/Yxr0,Yxm,Yxr"},
+		"yxrrl": {"Zm_r/1/Yxr,Yrl"}, "ymskb": {"Zm_r_xm/2/Yxr,Yrl", "Zm_r_xm/1/Ymr,Yrl"},
+		"yxr": {"Zm_r_xm/1/Yxr,Yxr"}, "yxm_q4": {"Zm_r/1/Yxm,Yxr"},
+	}
+	if entry.Ytab == "yxshuf" {
+		return x86LegacyLiteralSIMDEncoding(entry, row)
+	}
+	if entry.Kind != "encoding" {
+		return fail()
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, schemas[entry.Ytab]); err != nil {
+		return nil, err
+	}
+	escape := 0
+	if entry.Ytab == "ysha256rnds2" {
+		escape = 1
+	}
+	if entry.EscapeAdjustment != escape {
+		return fail()
+	}
+	// Symbolic mandatory-prefix atoms belong only to their media positions;
+	// every other atom must be an actual byte before any span is selected.
+	atoms := make([]byte, len(entry.OpBytes))
+	for i, atom := range entry.OpBytes {
+		if i == 0 && entry.Prefix == "Px" && (entry.Ytab == "yxcmpi" || entry.Ytab == "ymskb") {
+			atoms[i] = map[string]byte{"Pe": 0x66, "Pf2": 0xf2, "Pf3": 0xf3}[atom]
+			if atoms[i] == 0 {
+				return fail()
+			}
+			continue
+		}
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return fail()
+		}
+		atoms[i] = byte(value)
+	}
+	prefix := []byte{0x66, 0x0f}
+	opcode := func(value byte) bool { return value != 0 && value != 0x0f }
+	literal := func(start, end int) bool {
+		if start < 0 || end <= start || end > len(atoms) || atoms[end-1] != 0 {
+			return false
+		}
+		for _, value := range atoms[start : end-1] {
+			if value == 0 {
+				return false
+			}
+		}
+		return true
+	}
+	var selected []byte
+	switch entry.Ytab {
+	case "yextractps", "yextr", "yinsr", "ysha1rnds4":
+		if len(atoms) != 3 || !literal(0, 3) || atoms[0] != 0x3a || !opcode(atoms[1]) {
+			return fail()
+		}
+		if entry.Ytab == "ysha1rnds4" {
+			if entry.Prefix != "Pm" {
+				return fail()
+			}
+			prefix = []byte{0x0f}
+		} else {
+			wide := strings.HasSuffix(entry.Opcode, "Q")
+			if wide && (entry.Ytab != "yextr" && entry.Ytab != "yinsr" || entry.Prefix != "Pq3") || !wide && entry.Prefix != "Pq" {
+				return fail()
+			}
+			if wide {
+				prefix = []byte{0x66, 0x48, 0x0f}
+			}
+		}
+		selected = atoms[:2]
+	case "yextrw":
+		if entry.Prefix != "Pq" || len(atoms) != 5 || !literal(0, 2) || !literal(2, 5) || !opcode(atoms[0]) || atoms[2] != 0x3a || !opcode(atoms[3]) {
+			return fail()
+		}
+		selected = atoms[:1]
+		if row.RowIndex == 1 {
+			selected = atoms[2:4]
+		}
+	case "yinsrw":
+		if entry.Prefix != "Pq" || len(atoms) != 2 || !literal(0, 2) || !opcode(atoms[0]) {
+			return fail()
+		}
+		selected = atoms[:1]
+	case "yxcmpi":
+		if len(atoms) != 2 {
+			return fail()
+		}
+		mandatory := map[string]byte{"PD": 0x66, "SD": 0xf2, "SS": 0xf3}[strings.TrimPrefix(entry.Opcode, "CMP")]
+		if entry.Prefix == "Px" && mandatory != 0 && atoms[0] == mandatory {
+			prefix = []byte{atoms[0], 0x0f}
+			selected = atoms[1:]
+		} else if entry.Prefix == "Pm" && entry.Opcode == "CMPPS" && atoms[1] == 0 {
+			prefix = []byte{0x0f}
+			selected = atoms[:1]
+		} else {
+			return fail()
+		}
+		if !opcode(selected[0]) {
+			return fail()
+		}
+	case "ysha256rnds2":
+		if entry.Prefix != "Px" || len(atoms) != 4 || !literal(0, 4) || atoms[0] != 0x0f || atoms[1] != 0x38 || !opcode(atoms[2]) {
+			return fail()
+		}
+		prefix = nil
+		selected = atoms[:3]
+	case "yblendvpd", "yxm_q4":
+		if entry.Prefix != "Pq4" || len(atoms) != 1 || !opcode(atoms[0]) {
+			return fail()
+		}
+		prefix = append(prefix, 0x38)
+		selected = atoms
+	case "yxr", "yxrrl":
+		if len(atoms) != 1 || !opcode(atoms[0]) {
+			return fail()
+		}
+		if entry.Prefix == "Pm" {
+			prefix = []byte{0x0f}
+		} else if entry.Ytab != "yxrrl" || entry.Prefix != "Pq" {
+			return fail()
+		}
+		selected = atoms
+	case "ymskb":
+		if entry.Prefix != "Px" || len(atoms) != 3 || atoms[0] != 0x66 || !opcode(atoms[1]) || atoms[1] != atoms[2] {
+			return fail()
+		}
+		selected = atoms[1:2]
+		if row.RowIndex == 1 {
+			prefix = []byte{0x0f}
+			selected = atoms[2:]
+		}
+	default:
+		return fail()
+	}
+	return append(prefix, selected...), nil
+}
+
+func x86LegacyExplicitSIMDRowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86ScalarRMWWitness, error) {
+	encoding, err := x86LegacyExplicitSIMDEncoding(entry, row)
+	if err != nil {
+		return nil, err
+	}
+	sources, destinations := []string{"X0", "(AX)"}, []string{"X1", "X1"}
+	if row.Classes[0] == "Yxr" || row.Classes[0] == "Ymr" {
+		sources, destinations = []string{"X0"}, []string{"AX"}
+		if row.Classes[0] == "Ymr" {
+			sources[0] = "M0"
+		}
+		if row.Classes[1] == "Yxr" {
+			destinations[0] = "X1"
+		}
+	}
+	leadingImmediate := row.Classes[0] == "Yu8" || row.Classes[0] == "Yu2"
+	extract := row.ZCase == "Zibr_m"
+	if leadingImmediate {
+		if extract {
+			sources, destinations = []string{"X0", "X0"}, []string{"AX", "(AX)"}
+		} else if row.Classes[1] == "Yxr" {
+			sources, destinations = []string{"X0"}, []string{"AX"}
+		} else if row.Classes[1] == "Yml" || row.Classes[1] == "Ymm" {
+			sources[0] = "AX"
+		}
+		if entry.Ytab == "yextrw" && row.RowIndex == 1 {
+			sources, destinations = []string{"X0"}, []string{"(AX)"}
+		}
+	}
+	var result []X86ScalarRMWWitness
+	for index, source := range sources {
+		destination := destinations[index]
+		modrm := byte(0xc8)
+		if source == "(AX)" {
+			modrm = 0x08
+		}
+		if destination == "AX" {
+			modrm = 0xc0
+		}
+		if destination == "(AX)" {
+			modrm = 0x00
+		}
+		instruction := entry.Opcode + " " + source + "," + destination
+		code := append(append([]byte(nil), encoding...), modrm)
+		if leadingImmediate {
+			immediate := byte(7)
+			if row.Classes[0] == "Yu2" {
+				immediate = 3
+			}
+			instruction = fmt.Sprintf("%s $%d,%s,%s", entry.Opcode, immediate, source, destination)
+			code = append(code, immediate)
+		}
+		if row.ZCase == "Zm_r_i_xm" {
+			instruction += ",$7"
+			code = append(code, 7)
+		}
+		if row.Classes[0] == "Yxr0" {
+			instruction = entry.Opcode + " X0," + source + "," + destination
+		}
+		result = append(result, X86ScalarRMWWitness{Instruction: instruction, Destination: destination, Encoding: code})
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_explicit_simd_test.go b/internal/goasmrules/x86_witness_explicit_simd_test.go
new file mode 100644
index 000000000..3fe9e0f95
--- /dev/null
+++ b/internal/goasmrules/x86_witness_explicit_simd_test.go
@@ -0,0 +1,192 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func explicitSIMD27Entries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	schemas := map[string][]string{
+		"yextractps":   {"Zibr_m/2/Yu2,Yxr,Yml"},
+		"yextrw":       {"Zibm_r/2/Yu8,Yxr,Yrl", "Zibr_m/2/Yu8,Yxr,Yml"},
+		"yextr":        {"Zibr_m/3/Yu8,Yxr,Ymm"},
+		"yinsrw":       {"Zibm_r/2/Yu8,Yml,Yxr"},
+		"yinsr":        {"Zibm_r/3/Yu8,Ymm,Yxr"},
+		"yxcmpi":       {"Zm_r_i_xm/2/Yxm,Yxr,Yi8"},
+		"yblendvpd":    {"Z_m_r/1/Yxr0,Yxm,Yxr"},
+		"ysha1rnds4":   {"Zibm_r/2/Yu2,Yxm,Yxr"},
+		"ysha256rnds2": {"Zlit_m_r/0/Yxr0,Yxm,Yxr"},
+		"yxrrl":        {"Zm_r/1/Yxr,Yrl"},
+		"ymskb":        {"Zm_r_xm/2/Yxr,Yrl", "Zm_r_xm/1/Ymr,Yrl"},
+		"yxr":          {"Zm_r_xm/1/Yxr,Yxr"},
+		"yxm_q4":       {"Zm_r/1/Yxm,Yxr"},
+	}
+	var entries []X86LegacyOpcode
+	rows := 0
+	for _, entry := range catalog.Optab {
+		schema, selected := schemas[entry.Ytab]
+		// These shared tables already have independently owned arithmetic,
+		// extension and state rows. This closure retains their complete
+		// remaining lane-move and explicit-test families, not table authority.
+		if entry.Ytab == "yxr" && entry.Opcode != "MOVHLPS" && entry.Opcode != "MOVLHPS" ||
+			entry.Ytab == "yxm_q4" && entry.Opcode != "PHMINPOSUW" && entry.Opcode != "PTEST" {
+			continue
+		}
+		if entry.Opcode == "INSERTPS" {
+			schema, selected = []string{"Zibm_r/2/Yu8,Yxm,Yxr"}, true
+		}
+		if !selected {
+			continue
+		}
+		if entry.Kind != "encoding" || len(entry.Rows) != len(schema) {
+			t.Fatal("original complete schema changed", entry)
+		}
+		offset := 0
+		for i, row := range entry.Rows {
+			if row.RowIndex != i || row.UnmatchedOffset != offset || fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schema[i] {
+				t.Fatal("original ordered schema changed", entry, row)
+			}
+			offset += row.ZOffset + entry.EscapeAdjustment
+		}
+		entries, rows = append(entries, entry), rows+len(entry.Rows)
+	}
+	if len(entries) != 26 || rows != 28 {
+		t.Fatal("complete explicit SIMD inventory changed", len(entries), rows)
+	}
+	return entries
+}
+
+func TestX86LegacyExplicitSIMDCompleteSourceTransport(t *testing.T) {
+	for _, entry := range explicitSIMD27Entries(t) {
+		for _, row := range entry.Rows {
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				before := fmt.Sprintf("%#v", entry)
+				// The original RED used the older packed-only projection. The
+				// final explicit view retains GP and MMX syntax without adding
+				// either bank to the packed numerical consumer.
+				witnesses, err := x86LegacyExplicitSIMDRowWitnesses(entry, row)
+				want := 2
+				if entry.Ytab == "yextrw" || entry.Ytab == "yxrrl" || entry.Ytab == "ymskb" || entry.Ytab == "yxr" {
+					want = 1
+				}
+				if err != nil || len(witnesses) != want {
+					t.Errorf("EXPLICIT_SIMD_SOURCE_TRANSPORT_GAP: got=%d want=%d error=%v", len(witnesses), want, err)
+				}
+				for _, w := range witnesses {
+					if w.Instruction == "" || len(w.Encoding) == 0 || w.Destination == "" {
+						t.Error("incomplete or foreign witness", w)
+					}
+				}
+				if before != fmt.Sprintf("%#v", entry) {
+					t.Fatal("formatter mutated original source")
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyExplicitSIMDWholeSourceMetadataBoundaries(t *testing.T) {
+	for _, entry := range explicitSIMD27Entries(t) {
+		for _, original := range entry.Rows {
+			for _, field := range []string{"kind", "row-count", "original-arity", "selected-arity", "original-offset", "selected-offset", "original-stride", "selected-stride", "selected-index", "selected-zcase", "escape-negative", "escape-overflow", "prefix", "short", "extra", "nonbyte", "last-original-arity", "last-original-zcase", "last-original-offset", "last-original-stride"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", entry.Opcode, original.RowIndex, field), func(t *testing.T) {
+					changed, row := entry, original
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					maxInt := int(^uint(0) >> 1)
+					switch field {
+					case "kind":
+						changed.Kind = "reserved"
+					case "row-count":
+						changed.Rows = append(changed.Rows, original)
+					case "original-arity":
+						changed.Rows[0].Classes = []string{strings.Join(changed.Rows[0].Classes, ",")}
+					case "selected-arity":
+						row.Classes = []string{strings.Join(row.Classes, ",")}
+					case "original-offset":
+						changed.Rows[0].UnmatchedOffset = -maxInt - 1
+					case "selected-offset":
+						row.UnmatchedOffset = maxInt
+					case "original-stride":
+						changed.Rows[0].ZOffset = -maxInt - 1
+					case "selected-stride":
+						row.ZOffset = maxInt
+					case "selected-index":
+						row.RowIndex = maxInt
+					case "selected-zcase":
+						row.ZCase = "Zlit"
+					case "escape-negative":
+						changed.EscapeAdjustment = -1
+					case "escape-overflow":
+						changed.EscapeAdjustment = maxInt
+					case "prefix":
+						changed.Prefix = "P32"
+					case "short":
+						changed.OpBytes = nil
+					case "extra":
+						changed.OpBytes = append(changed.OpBytes, "0")
+					case "nonbyte":
+						changed.OpBytes[len(changed.OpBytes)-1] = "0x100"
+					case "last-original-arity":
+						changed.Rows[len(changed.Rows)-1].Classes = nil
+					case "last-original-zcase":
+						changed.Rows[len(changed.Rows)-1].ZCase = "Zlit"
+					case "last-original-offset":
+						changed.Rows[len(changed.Rows)-1].UnmatchedOffset = maxInt
+					case "last-original-stride":
+						changed.Rows[len(changed.Rows)-1].ZOffset = maxInt
+					}
+					defer func() {
+						if failure := recover(); failure != nil {
+							t.Errorf("EXPLICIT_SIMD_METADATA_PANIC: %v", failure)
+						}
+					}()
+					if reflect.DeepEqual(changed, entry) && reflect.DeepEqual(row, original) {
+						t.Fatal("ineffective mutation")
+					}
+					if _, err := x86LegacyExplicitSIMDRowWitnesses(changed, row); err == nil {
+						t.Error("EXPLICIT_SIMD_MALFORMED_ACCEPTED", field)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyExplicitSIMDAllAtomsAndPrefixRoles(t *testing.T) {
+	for _, entry := range explicitSIMD27Entries(t) {
+		for _, row := range entry.Rows {
+			for index := range entry.OpBytes {
+				t.Run(fmt.Sprintf("%s/%d/atom%d", entry.Opcode, row.RowIndex, index), func(t *testing.T) {
+					changed := entry
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					changed.OpBytes[index] = "0x100"
+					if _, err := x86LegacyExplicitSIMDRowWitnesses(changed, row); err == nil {
+						t.Fatal("unselected/prefix atom was not validated", index)
+					}
+				})
+			}
+			if entry.Ytab == "yxcmpi" && entry.Prefix == "Px" {
+				t.Run(entry.Opcode+"/coherent-foreign-mandatory", func(t *testing.T) {
+					changed := entry
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					changed.OpBytes[0] = "Pf3"
+					if entry.OpBytes[0] == "Pf3" {
+						changed.OpBytes[0] = "Pf2"
+					}
+					if _, err := x86LegacyExplicitSIMDRowWitnesses(changed, row); err == nil {
+						t.Fatal("EXPLICIT_SIMD_MANDATORY_ROLE_CHANGED")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_float_binary_test.go b/internal/goasmrules/x86_witness_float_binary_test.go
new file mode 100644
index 000000000..4e4a5ff97
--- /dev/null
+++ b/internal/goasmrules/x86_witness_float_binary_test.go
@@ -0,0 +1,110 @@
+package goasmrules
+
+import (
+	"bytes"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86AVXFloatBinaryMembers = `VADDPS VADDPD VADDSS VADDSD VSUBPS VSUBPD VSUBSS VSUBSD
+	VMULPS VMULPD VMULSS VMULSD VDIVPS VDIVPD VDIVSS VDIVSD
+	VMINPS VMINPD VMINSS VMINSD VMAXPS VMAXPD VMAXSS VMAXSD`
+
+func TestX86AVXFloatBinaryRowsCompleteControls(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	members := regexp.MustCompile(`^V(ADD|SUB|MUL|DIV|MIN|MAX)(PS|PD|SS|SD)$`)
+	official := 0
+	for _, rule := range avx {
+		if members.MatchString(rule.Opcode) {
+			official++
+		}
+	}
+	if official != 132 {
+		t.Fatal("complete original AVX floating row denominator changed", official)
+	}
+	build := func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+		return x86PackedBinaryRows(legacy, avx, x86AVXFloatBinaryMembers)
+	}
+	inventory := x86CheckPackedRowInventory(t, build, members.String(), `P[SD]$`, x86PackedRowCounts{
+		names: 24, broadcast: 108,
+		rows: [3]int{0, 36, 96}, formats: [3]int{0, 72, 612}, widths: [3]int{336, 132, 216},
+	})
+	rounding, sae, zeroing, formats := 0, 0, 0, 0
+	for _, row := range inventory.rows {
+		minmax := strings.HasPrefix(row.Opcode, "VMIN") || strings.HasPrefix(row.Opcode, "VMAX")
+		for _, witness := range row.Witnesses {
+			formats++
+			operation := strings.Fields(witness.Instruction)[0]
+			if strings.Contains(operation, "_SAE") {
+				rounding++
+				if minmax || witness.Memory || witness.Width != 512 && !strings.HasSuffix(row.Opcode, "SS") && !strings.HasSuffix(row.Opcode, "SD") {
+					t.Fatal("embedded rounding escaped its original arithmetic register shape", row.ID, witness)
+				}
+			}
+			if strings.Contains(operation, ".SAE") {
+				sae++
+				if !minmax || witness.Memory || witness.Width != 512 && !strings.HasSuffix(row.Opcode, "SS") && !strings.HasSuffix(row.Opcode, "SD") {
+					t.Fatal("SAE escaped its original MIN/MAX register shape", row.ID, witness)
+				}
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+		}
+	}
+	if formats != 684 || rounding != 192 || sae != 24 || zeroing != 204 {
+		t.Fatal("full floating control witness inventory changed", formats, rounding, sae, zeroing)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VADDSD X0,X1,X2", []byte{0xc5, 0xf3, 0x58, 0xd0}},
+		{"VADDSS X0,X1,X2", []byte{0xc5, 0xf2, 0x58, 0xd0}},
+		{"VDIVSD.RD_SAE X16,X17,X18", []byte{0x62, 0xa1, 0xf7, 0x30, 0x5e, 0xd0}},
+		{"VMINPD.SAE Z16,Z17,Z18", []byte{0x62, 0xa1, 0xf5, 0x50, 0x5d, 0xd0}},
+		{"VMINSD.SAE X16,X17,X18", []byte{0x62, 0xa1, 0xf7, 0x10, 0x5d, 0xd0}},
+		{"VMAXSS.SAE.Z X16,X17,K1,X18", []byte{0x62, 0xa1, 0x76, 0x91, 0x5f, 0xd0}},
+	})
+}
+
+func TestX86AVXFloatBinarySAEKeepsVectorLength(t *testing.T) {
+	rule := X86AVXRule{Opcode: "VMINPD", Ytab: "_yvaddpd", Prefix: "Pavx",
+		Classes: []string{"Yzm", "Yzr", "Yzr"}, ZCase: "Zevex_rm_v_r",
+		OpBytes: []string{"avxEscape | evex512 | evex66 | evex0F | evexW1", "evexN64 | evexBcstN8 | evexSaeEnabled | evexZeroingEnabled", "0x5D"}}
+	witnesses, err := x86PackedAVXRowWitnesses(rule)
+	if err != nil || len(witnesses) != 4 || witnesses[3].Instruction != "VMINPD.SAE Z16,Z17,Z18" ||
+		!bytes.Equal(witnesses[3].Encoding, []byte{0x62, 0xa1, 0xf5, 0x50, 0x5d, 0xd0}) {
+		t.Fatal("SAE reused RC's LL replacement or lost its complete original row", witnesses, err)
+	}
+	for _, edit := range []func(*X86AVXRule){
+		func(r *X86AVXRule) { r.OpBytes[1] += " | evexRoundingEnabled" },
+		func(r *X86AVXRule) { r.OpBytes[0] += " | evexF2" },
+		func(r *X86AVXRule) { r.Ytab = "_yvandnpd" },
+		func(r *X86AVXRule) {
+			r.Classes = []string{"YxmEvex", "YxrEvex", "YxrEvex"}
+			r.OpBytes[0] = strings.Replace(r.OpBytes[0], "evex512", "evex128", 1)
+			r.OpBytes[1] = strings.Replace(r.OpBytes[1], "evexN64", "evexN16", 1)
+		},
+	} {
+		local := rule
+		local.OpBytes = append([]string(nil), rule.OpBytes...)
+		edit(&local)
+		if witnesses, err := x86PackedAVXRowWitnesses(local); err == nil || len(witnesses) != 0 {
+			t.Fatal("unknown SAE, width, PP or conflicting ER metadata acquired witnesses", witnesses, err)
+		}
+	}
+}
+
+func TestX86AVXFloatBinaryScalarPPDoesNotWidenIntegerBinary(t *testing.T) {
+	for _, prefix := range []string{"vexF2", "vexF3"} {
+		rule := X86AVXRule{Opcode: "VPMULLD", Ytab: "_yvandnpd", Prefix: "Pavx",
+			Classes: []string{"Yxm", "Yxr", "Yxr"}, ZCase: "Zvex_rm_v_r", ZOffset: 2,
+			OpBytes: []string{"avxEscape | vex128 | " + prefix + " | vex0F38 | vexW0", "0x40"}}
+		if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+			t.Fatal("floating scalar pp widened integer binary grammar", witnesses, err)
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_fma3_test.go b/internal/goasmrules/x86_witness_fma3_test.go
new file mode 100644
index 000000000..0209dc564
--- /dev/null
+++ b/internal/goasmrules/x86_witness_fma3_test.go
@@ -0,0 +1,184 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86FMA3OfficialRowsAndFullControlWitnesses(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	family := regexp.MustCompile(`^V(FM(ADD|SUB)|FNM(ADD|SUB)|FMADDSUB|FMSUBADD)(132|213|231)(PS|PD|SS|SD)$`)
+	names := map[string]bool{}
+	var rows []X86PackedBinaryRow
+	var official, expected, rejected, broadcast, rounding, zeroing int
+	var generations, formats, widths [3]int
+	var firstError error
+	for index, rule := range avx {
+		if !family.MatchString(rule.Opcode) {
+			continue
+		}
+		names[rule.Opcode] = true
+		official++
+		counts := []int{2, 2, 7, 14, 3, 6, 3, 6}
+		if strings.HasSuffix(rule.Opcode, "SS") || strings.HasSuffix(rule.Opcode, "SD") {
+			if rule.Ytab != "_yvaddsd" {
+				t.Fatal("scalar FMA3 changed official operand grammar", rule)
+			}
+			counts = []int{2, 6, 12}
+		} else if rule.Ytab != "_yvaddpd" {
+			t.Fatal("packed FMA3 changed official operand grammar", rule)
+		}
+		if rule.RowIndex < 0 || rule.RowIndex >= len(counts) {
+			t.Fatal("FMA3 acquired an unreviewed official row", rule)
+		}
+		expected += counts[rule.RowIndex]
+		witnesses, err := x86PackedAVXRowWitnesses(rule)
+		if err != nil {
+			rejected++
+			if firstError == nil {
+				firstError = fmt.Errorf("%s/%d: %w", rule.Opcode, rule.RowIndex, err)
+			}
+			continue
+		}
+		if len(witnesses) != counts[rule.RowIndex] {
+			t.Fatalf("%s/%d: got %d control witnesses, want %d", rule.Opcode, rule.RowIndex, len(witnesses), counts[rule.RowIndex])
+		}
+		rows = append(rows, X86PackedBinaryRow{
+			ID:     fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex),
+			Opcode: rule.Opcode, Witnesses: witnesses,
+		})
+		generation := 1
+		if witnesses[0].Generation == "evex" {
+			generation = 2
+		}
+		generations[generation]++
+		for _, witness := range witnesses {
+			formats[generation]++
+			width, ok := map[int]int{128: 0, 256: 1, 512: 2}[witness.Width]
+			if !ok || witness.Generation != witnesses[0].Generation || witness.MaskResult {
+				t.Fatal("FMA3 lost carrier, generation or vector destination", rule, witness)
+			}
+			widths[width]++
+			if generation == 2 && (!strings.HasSuffix(witness.Second, "17") ||
+				!strings.HasSuffix(witness.Destination, "18") || witness.Encoding[0] != 0x62) {
+				t.Fatal("original EVEX FMA3 witness can fall back to VEX", rule, witness)
+			}
+			if witness.Broadcast {
+				broadcast++
+				if !witness.Memory || rule.Ytab != "_yvaddpd" {
+					t.Fatal("scalar or register FMA3 acquired broadcast", rule, witness)
+				}
+			}
+			if strings.Contains(witness.Instruction, "_SAE") {
+				rounding++
+				if witness.Memory || witness.Broadcast || generation != 2 || rule.Ytab == "_yvaddpd" && witness.Width != 512 {
+					t.Fatal("FMA3 rounding escaped its original register-only control grammar", rule, witness)
+				}
+			}
+			if witness.Zeroing {
+				zeroing++
+				if !witness.Masked {
+					t.Fatal("zeroing FMA3 lost its nonzero mask", rule, witness)
+				}
+			}
+		}
+	}
+	if len(names) != 60 || official != 360 || expected != 2028 {
+		t.Fatalf("official FMA3 scope drift: names=%d rows=%d control expectations=%d", len(names), official, expected)
+	}
+	if rejected != 0 {
+		t.Fatalf("%d/%d original FMA3 rows lack witness grammar (policy expects %d witnesses): %v", rejected, official, expected, firstError)
+	}
+	if len(rows) != 360 || generations != [3]int{0, 96, 264} || formats != [3]int{0, 192, 1836} ||
+		widths != [3]int{876, 396, 756} || broadcast != 324 || rounding != 720 || zeroing != 612 {
+		t.Fatalf("FMA3 row/control inventory drift: rows=%d generations=%v formats=%v widths=%v broadcast=%d rounding=%d zeroing=%d",
+			len(rows), generations, formats, widths, broadcast, rounding, zeroing)
+	}
+	t.Log("360 original rows / 2028 candidate control witnesses; original Go bytes, initialized APIs, objects and runtime require their separate owners")
+}
+
+func TestX86FMA3OfficialScalarTupleAndRoundingEncoding(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, anchor := range []struct {
+		opcode, instruction string
+		row                 int
+		encoding            []byte
+	}{
+		{"VFMADD132PS", "VFMADD132PS X0,X1,X2", 0, []byte{0xc4, 0xe2, 0x71, 0x98, 0xd0}},
+		{"VFMSUB213PD", "VFMSUB213PD (AX),Y1,Y2", 1, []byte{0xc4, 0xe2, 0xf5, 0xaa, 0x10}},
+		{"VFNMADD231PS", "VFNMADD231PS.RN_SAE Z16,Z17,Z18", 2, []byte{0x62, 0xa2, 0x75, 0x10, 0xbc, 0xd0}},
+		{"VFNMSUB132PD", "VFNMSUB132PD.RZ_SAE.Z Z16,Z17,K1,Z18", 3, []byte{0x62, 0xa2, 0xf5, 0xf1, 0x9e, 0xd0}},
+		{"VFMADD132SD", "VFMADD132SD.RD_SAE X16,X17,X18", 1, []byte{0x62, 0xa2, 0xf5, 0x30, 0x99, 0xd0}},
+		{"VFMADD132SS", "VFMADD132SS.RU_SAE.Z X16,X17,K1,X18", 2, []byte{0x62, 0xa2, 0x75, 0xd1, 0x99, 0xd0}},
+		{"VFMADD132SD", "VFMADD132SD (AX),X17,X18", 1, []byte{0x62, 0xe2, 0xf5, 0x00, 0x99, 0x10}},
+		{"VFMADD132PS", "VFMADD132PS.BCST.Z (AX),X17,K1,X18", 5, []byte{0x62, 0xe2, 0x75, 0x91, 0x98, 0x10}},
+	} {
+		t.Run(anchor.instruction, func(t *testing.T) {
+			found := false
+			for _, rule := range avx {
+				if rule.Opcode != anchor.opcode || rule.RowIndex != anchor.row {
+					continue
+				}
+				witnesses, err := x86PackedAVXRowWitnesses(rule)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, witness := range witnesses {
+					if witness.Instruction == anchor.instruction {
+						found = true
+						if !bytes.Equal(witness.Encoding, anchor.encoding) {
+							t.Fatalf("original FMA3 tuple/RC bytes are %x, want %x", witness.Encoding, anchor.encoding)
+						}
+					}
+				}
+			}
+			if !found {
+				t.Fatal("original FMA3 row/control witness is absent")
+			}
+		})
+	}
+}
+
+func TestX86FMA3OfficialScalarMetadataFailsClosed(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, rule := range avx {
+		if rule.Opcode != "VFMADD132SD" || rule.RowIndex != 1 {
+			continue
+		}
+		for _, test := range []struct {
+			name   string
+			mutate func(*X86AVXRule)
+		}{
+			{"carrier tuple", func(r *X86AVXRule) { r.OpBytes[3] = strings.Replace(r.OpBytes[3], "evexN8", "evexN16", 1) }},
+			{"wrong precision tuple", func(r *X86AVXRule) { r.OpBytes[3] = strings.Replace(r.OpBytes[3], "evexN8", "evexN4", 1) }},
+			{"scalar broadcast", func(r *X86AVXRule) { r.OpBytes[3] += " | evexBcstN8" }},
+			{"standalone SAE", func(r *X86AVXRule) { r.OpBytes[3] += " | evexSaeEnabled" }},
+			{"W conflict", func(r *X86AVXRule) { r.OpBytes[2] += " | evexW0" }},
+			{"future flag", func(r *X86AVXRule) { r.OpBytes[3] += " | futureFlag" }},
+		} {
+			t.Run(test.name, func(t *testing.T) {
+				local := rule
+				local.OpBytes = append([]string(nil), rule.OpBytes...)
+				test.mutate(&local)
+				if witnesses, err := x86PackedAVXRowWitnesses(local); err == nil || len(witnesses) != 0 {
+					t.Fatal("unknown scalar tuple/control metadata acquired witnesses", witnesses, err)
+				}
+			})
+		}
+		return
+	}
+	t.Fatal("original scalar FMA3 row is absent")
+}
diff --git a/internal/goasmrules/x86_witness_fp_immediate_control.go b/internal/goasmrules/x86_witness_fp_immediate_control.go
new file mode 100644
index 000000000..f958a0051
--- /dev/null
+++ b/internal/goasmrules/x86_witness_fp_immediate_control.go
@@ -0,0 +1,78 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// The three original FP-control tables share emission with leading-immediate
+// vector rows. Scalar N4/N8 tuples do not change the X register carrier or
+// certify MXCSR, old-destination, numerical input or native memory authority.
+func x86FloatingImmediateControlRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f := x86VectorResultFormat{unary: rule.Ytab == "_yvgetmantpd"}
+	fail := func() ([]X86PackedBinaryWitness, error) {
+		return nil, fmt.Errorf("FP immediate source/carrier/tuple/SAE differs from its official format")
+	}
+	scalar := rule.Ytab == "_yvfixupimmsd"
+	if !f.unary && !scalar && rule.Ytab != "_yvfixupimmpd" {
+		return fail()
+	}
+	plain, masked, count := "Zevex_i_rm_v_r", "Zevex_i_rm_v_k_r", 4
+	if f.unary {
+		plain, masked, count = "Zevex_i_rm_r", "Zevex_i_rm_k_r", 3
+	}
+	f.masked = rule.ZCase == masked
+	maskIndex := 0
+	if f.masked {
+		count, maskIndex = count+1, 1
+	}
+	if len(rule.Opcode) < 2 || rule.Prefix != "Pavx" || rule.ZCase != plain && !f.masked || len(rule.Classes) != count ||
+		rule.Classes[0] != "Yu8" || f.masked && rule.Classes[count-2] != "Yknot0" {
+		return fail()
+	}
+	f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[rule.Classes[1]]
+	register := map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	index := map[int]int{512: 0, 128: 1, 256: 2}[f.width] // Original Z, X, Y order.
+	extent, tuple := 9, f.width/8
+	precision, w := 4, "evexW0"
+	suffix := rule.Opcode[len(rule.Opcode)-2:]
+	if suffix == "PD" || suffix == "SD" {
+		precision, w = 8, "evexW1"
+	}
+	if scalar {
+		index, extent, tuple = 0, 3, precision
+	}
+	if f.width == 0 || scalar && (f.width != 128 || suffix != "SS" && suffix != "SD") ||
+		!scalar && suffix != "PS" && suffix != "PD" || rule.Classes[count-1] != register ||
+		!f.unary && rule.Classes[2] != register || rule.RowIndex != index*2+maskIndex ||
+		rule.EncodingOffset != index*3 || rule.ZOffset != maskIndex*3 || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	offset := rule.EncodingOffset
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", "evex" + strconv.Itoa(f.width), "evex66", "evex0F3A", w,
+	}, nil); err != nil {
+		return fail()
+	}
+	f.broadcast, f.sae = !scalar, scalar || f.width == 512
+	features := []string{"evexN" + strconv.Itoa(tuple), "evexZeroingEnabled"}
+	if f.broadcast {
+		features = append(features, "evexBcstN"+strconv.Itoa(precision))
+	}
+	if f.sae {
+		features = append(features, "evexSaeEnabled")
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], features, nil); err != nil {
+		return fail()
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+2], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: "evex", mapByte: 3, pp: 1,
+		length: map[int]byte{128: 0, 256: 1, 512: 2}[f.width], opcode: byte(opcode)}
+	if precision == 8 {
+		f.encoding.wBit = 0x80
+	}
+	return f.witnesses(rule.Opcode), nil
+}
diff --git a/internal/goasmrules/x86_witness_fp_immediate_control_test.go b/internal/goasmrules/x86_witness_fp_immediate_control_test.go
new file mode 100644
index 000000000..67eb9b26c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_fp_immediate_control_test.go
@@ -0,0 +1,184 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86FloatingImmediateControlTestNames = `
+	VGETMANTPS VGETMANTPD VGETMANTSS VGETMANTSD
+	VRNDSCALEPS VRNDSCALEPD VRNDSCALESS VRNDSCALESD
+	VREDUCEPS VREDUCEPD VREDUCESS VREDUCESD
+	VFIXUPIMMPS VFIXUPIMMPD VFIXUPIMMSS VFIXUPIMMSD
+	VRANGEPS VRANGEPD VRANGESS VRANGESD`
+
+func TestX86FloatingImmediateControlCompleteOriginalRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	for _, name := range strings.Fields(x86FloatingImmediateControlTestNames) {
+		names[name] = true
+	}
+	originals := map[string]X86AVXRule{}
+	for index, row := range avx {
+		if names[row.Opcode] {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = row
+		}
+	}
+	if len(names) != 20 || len(originals) != 80 {
+		t.Fatal("complete control family changed", len(names), len(originals))
+	}
+	// Existing helper only: this must reach an unsupported-format RED, not a
+	// future selector/API symbol compilation error. Not run during preparation.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86FloatingImmediateControlTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions := map[string]bool{}, map[string]bool{}
+	byTable, widths := map[string]int{}, map[int]int{}
+	masked, zeroing, broadcast, sae, memory := 0, 0, 0, 0, 0
+	for _, row := range rows {
+		from, found := originals[row.ID]
+		if !found || seen[row.ID] {
+			t.Fatal("lost exact original row", row)
+		}
+		seen[row.ID] = true
+		byTable[from.Ytab]++
+		width := map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[from.Classes[1]]
+		bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[width]
+		unary, scalar := from.Ytab == "_yvgetmantpd", from.Ytab == "_yvfixupimmsd"
+		wantMasked := strings.Contains(strings.Join(from.Classes, ","), "Yknot0")
+		for _, w := range row.Witnesses {
+			fields := strings.Fields(w.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("lost source syntax", w)
+			}
+			args := strings.Split(fields[1], ",")
+			second, arity := bank+"17", 4
+			if unary {
+				second, arity = "", 3
+			}
+			if wantMasked {
+				arity++
+			}
+			isSAE := strings.Contains(fields[0], ".SAE")
+			if len(args) != arity || args[0] != "$7" || instructions[w.Instruction] ||
+				w.First != args[1] || w.First != bank+"16" && w.First != "(AX)" ||
+				w.Second != second || w.Destination != bank+"18" || args[len(args)-1] != w.Destination ||
+				w.Generation != "evex" || w.Width != width || w.MaskResult || w.Masked != wantMasked ||
+				w.Masked && args[len(args)-2] != "K1" || w.Zeroing && !w.Masked ||
+				w.Zeroing != strings.HasSuffix(fields[0], ".Z") || w.Memory != (w.First == "(AX)") ||
+				w.Broadcast != strings.Contains(fields[0], ".BCST") || w.Broadcast && (!w.Memory || scalar) ||
+				isSAE && (w.Memory || !scalar && width != 512) ||
+				len(w.Encoding) != 7 || w.Encoding[0] != 0x62 || w.Encoding[6] != 7 {
+				t.Fatal("immediate/arity/scalar/tuple/mask/control roles conflated", row.ID, w)
+			}
+			// Unary packed reserves vvvv/V'; scalar upper and binary data use it.
+			if unary && (w.Encoding[2]&0x78 != 0x78 || w.Encoding[3]&8 == 0) ||
+				!unary && (w.Encoding[2]&0x78 != 0x70 || w.Encoding[3]&8 != 0) {
+				t.Fatal("reserved vvvv and live scalar/binary source conflated", row.ID, w)
+			}
+			instructions[w.Instruction] = true
+			widths[width]++
+			if w.Masked {
+				masked++
+			}
+			if w.Zeroing {
+				zeroing++
+			}
+			if w.Broadcast {
+				broadcast++
+			}
+			if isSAE {
+				sae++
+			}
+			if w.Memory {
+				memory++
+			}
+		}
+	}
+	if len(rows) != 80 || len(seen) != len(originals) || len(instructions) != 390 ||
+		byTable["_yvgetmantpd"] != 36 || byTable["_yvfixupimmpd"] != 24 || byTable["_yvfixupimmsd"] != 20 ||
+		widths[128] != 180 || widths[256] != 90 || widths[512] != 120 ||
+		masked != 260 || zeroing != 130 || broadcast != 90 || sae != 60 || memory != 210 {
+		t.Fatal("complete control projection changed", len(rows), len(instructions), byTable, widths, masked, zeroing, broadcast, sae, memory)
+	}
+}
+
+func TestX86FloatingImmediateControlRejectsForeignFormatAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"VGETMANTPD", "VFIXUPIMMPD", "VRNDSCALESD"} {
+		for _, mutation := range []string{"signed immediate", "K0 mask", "K result", "tuple", "prefix", "map", "rounding", "offset", "forbidden control", "W", "source carrier", "short opcode", "extent", "row index"} {
+			t.Run(name+"/"+mutation, func(t *testing.T) {
+				found := 0
+				index := 1
+				if mutation == "forbidden control" && name != "VRNDSCALESD" {
+					index = 3 // Packed X must not inherit the Z row's SAE.
+				}
+				for _, original := range rules {
+					if original.Opcode != name || original.RowIndex != index {
+						continue
+					}
+					found++
+					if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+						t.Fatal("negative needs valid original", err)
+					}
+					row := original
+					row.Classes = append([]string(nil), row.Classes...)
+					row.OpBytes = append([]string(nil), row.OpBytes...)
+					switch mutation {
+					case "signed immediate":
+						row.Classes[0] = "Yi8"
+					case "K0 mask":
+						row.Classes[len(row.Classes)-2] = "Yk"
+					case "K result":
+						row.Classes[len(row.Classes)-1] = "Yk"
+					case "tuple":
+						row.OpBytes[row.EncodingOffset+1] = strings.ReplaceAll(strings.ReplaceAll(row.OpBytes[row.EncodingOffset+1], "evexN64", "evexN32"), "evexN8", "evexN16")
+					case "prefix":
+						row.OpBytes[row.EncodingOffset] = strings.Replace(row.OpBytes[row.EncodingOffset], "evex66", "evexF2", 1)
+					case "map":
+						row.OpBytes[row.EncodingOffset] = strings.Replace(row.OpBytes[row.EncodingOffset], "evex0F3A", "evex0F38", 1)
+					case "rounding":
+						row.OpBytes[row.EncodingOffset+1] += "|evexRoundingEnabled"
+					case "offset":
+						row.EncodingOffset++
+					case "forbidden control":
+						control := "evexSaeEnabled"
+						if name == "VRNDSCALESD" {
+							control = "evexBcstN8"
+						}
+						row.OpBytes[row.EncodingOffset+1] += "|" + control
+					case "W":
+						row.OpBytes[row.EncodingOffset] = strings.Replace(row.OpBytes[row.EncodingOffset], "evexW1", "evexW0", 1)
+					case "source carrier":
+						row.Classes[1] = "YymEvex"
+					case "short opcode":
+						row.Opcode = ""
+					case "extent":
+						row.OpBytes = append(row.OpBytes, "0")
+					case "row index":
+						row.RowIndex++
+					}
+					if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+						t.Fatal("foreign control format accepted", row)
+					}
+				}
+				if found != 1 {
+					t.Fatal("missing original negative owner", found)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_gfni.go b/internal/goasmrules/x86_witness_gfni.go
new file mode 100644
index 000000000..15e7d1729
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gfni.go
@@ -0,0 +1,102 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Both families have byte-vector results; only affine has a leading imm8
+// and m64 matrix broadcast. W1 never changes the byte mask's granularity.
+type x86GFNIFormat struct {
+	width                        int
+	immediate, masked, broadcast bool
+	encoding                     x86PackedAVXOpcode
+}
+
+func x86GFNIFormatForRule(rule X86AVXRule) (x86GFNIFormat, error) {
+	f := x86GFNIFormat{immediate: rule.Ytab == "_yvgf2p8affineinvqb"}
+	fail := func() (x86GFNIFormat, error) {
+		return f, fmt.Errorf("GFNI data/matrix/tuple/control differs from its official format")
+	}
+	first, plain, masked, opcodeMap, mapByte, w := 0, "Zvex_rm_v_r", "Zevex_rm_v_k_r", "0F38", byte(2), "W0"
+	if f.immediate {
+		first, plain, masked, opcodeMap, mapByte, w = 1, "Zvex_i_rm_v_r", "Zevex_i_rm_v_k_r", "0F3A", 3, "W1"
+		member, valid := strings.CutPrefix(rule.Opcode, "VGF2P8AFFINE")
+		if !valid || member != "QB" && member != "INVQB" {
+			return fail()
+		}
+	} else if rule.Opcode != "VGF2P8MULB" || rule.Ytab != "_yvandnpd" {
+		return fail()
+	}
+	f.masked = rule.ZCase == masked
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	count := first + 3
+	if f.masked {
+		count++
+	}
+	if evex {
+		plain = strings.Replace(plain, "Zvex_", "Zevex_", 1)
+	}
+	if rule.Prefix != "Pavx" || rule.ZCase != plain && !f.masked || len(rule.Classes) != count ||
+		f.immediate && rule.Classes[0] != "Yu8" || f.masked && rule.Classes[first+2] != "Yknot0" {
+		return fail()
+	}
+	f.width = map[string]int{"Yxm": 128, "Yym": 256}[rule.Classes[first]]
+	register := map[int]string{128: "Yxr", 256: "Yyr"}[f.width]
+	if evex {
+		f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[rule.Classes[first]]
+		register = map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	}
+	if f.width == 0 || rule.Classes[first+1] != register || rule.Classes[count-1] != register || len(rule.OpBytes) != 13 {
+		return fail()
+	}
+	widthIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width]
+	index, offset, zoffset, kind, stride := widthIndex, widthIndex*2, 2, "vex", 2
+	if evex {
+		index, offset, zoffset, kind, stride = 2+widthIndex*2, 4+widthIndex*3, 0, "evex", 3
+		if f.masked {
+			index, zoffset = index+1, 3
+		}
+	}
+	if rule.RowIndex != index || rule.EncodingOffset != offset || rule.ZOffset != zoffset {
+		return fail()
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", kind + strconv.Itoa(f.width), kind + "66", kind + opcodeMap, kind + w,
+	}, nil); err != nil {
+		return fail()
+	}
+	if evex {
+		required := []string{"evexN" + strconv.Itoa(f.width/8), "evexZeroingEnabled"}
+		if f.immediate {
+			required = append(required, "evexBcstN8")
+			f.broadcast = true
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], required, nil); err != nil {
+			return fail()
+		}
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+stride-1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: kind, mapByte: mapByte, pp: 1, length: byte(widthIndex), opcode: byte(opcode)}
+	if f.immediate {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func x86GFNIAffineRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86GFNIFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	if !f.immediate {
+		return nil, fmt.Errorf("GFNI multiply retains the generic binary transport")
+	}
+	return (x86VectorResultFormat{
+		width: f.width, masked: f.masked, broadcast: f.broadcast, encoding: f.encoding,
+	}).witnesses(rule.Opcode), nil
+}
diff --git a/internal/goasmrules/x86_witness_gfni_test.go b/internal/goasmrules/x86_witness_gfni_test.go
new file mode 100644
index 000000000..a09621b78
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gfni_test.go
@@ -0,0 +1,234 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86GFNITestNames = "VGF2P8MULB VGF2P8AFFINEQB VGF2P8AFFINEINVQB"
+
+func TestX86GFNICompleteOriginalRowTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	for _, name := range strings.Fields(x86GFNITestNames) {
+		names[name] = true
+	}
+	for _, entry := range legacy.Optab {
+		if names[entry.Opcode] {
+			t.Fatal("GFNI acquired a legacy Go row", entry)
+		}
+	}
+	originals := map[string]X86AVXRule{}
+	for index, row := range avx {
+		if names[row.Opcode] {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = row
+		}
+	}
+	if len(originals) != 24 {
+		t.Fatal("complete GFNI original source denominator changed", len(originals))
+	}
+	// Existing helper only: a future selector's missing symbol is not RED.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86GFNITestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions := map[string]bool{}, map[string]bool{}
+	rowCounts, formats, generations, widths := map[string]int{}, map[string]int{}, map[string]int{}, map[int]int{}
+	masked, zeroing, broadcast, memory := 0, 0, 0, 0
+	for _, row := range rows {
+		original, found := originals[row.ID]
+		if !found || seen[row.ID] {
+			t.Fatal("GFNI lost original row identity", row)
+		}
+		seen[row.ID], rowCounts[row.Opcode] = true, rowCounts[row.Opcode]+1
+		affine := row.Opcode != "VGF2P8MULB"
+		offset, table := 0, "_yvandnpd"
+		if affine {
+			offset, table = 1, "_yvgf2p8affineinvqb"
+		}
+		if original.Ytab != table {
+			t.Fatal("GFNI lost its distinct binary/immediate source grammar", original)
+		}
+		width := map[string]int{"Yxm": 128, "Yym": 256, "YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[original.Classes[offset]]
+		bank, kind, first, second, destination := map[int]string{128: "X", 256: "Y", 512: "Z"}[width], "vex", "0", "1", "2"
+		if strings.HasPrefix(original.ZCase, "Zevex_") {
+			kind, first, second, destination = "evex", "16", "17", "18"
+		}
+		for _, w := range row.Witnesses {
+			fields := strings.Fields(w.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("GFNI lost source syntax", w)
+			}
+			args := strings.Split(fields[1], ",")
+			wantMasked := original.ZCase == "Zevex_rm_v_k_r" || original.ZCase == "Zevex_i_rm_v_k_r"
+			if instructions[w.Instruction] || strings.Split(fields[0], ".")[0] != row.Opcode || affine && args[0] != "$7" ||
+				w.First != args[offset] || w.First != bank+first && w.First != "(AX)" || w.Second != args[offset+1] || w.Second != bank+second ||
+				w.Destination != bank+destination || args[len(args)-1] != w.Destination || w.Width != width || w.Generation != kind || w.MaskResult ||
+				w.Masked != wantMasked || w.Masked && args[len(args)-2] != "K1" || w.Zeroing != strings.HasSuffix(fields[0], ".Z") || w.Zeroing && !w.Masked ||
+				w.Memory != (w.First == "(AX)") || w.Broadcast != strings.Contains(fields[0], ".BCST") || w.Broadcast && (!affine || !w.Memory || kind != "evex") {
+				t.Fatal("GFNI conflated matrix/data/immediate/byte-mask roles", row.ID, w)
+			}
+			wantLength := 5
+			if kind == "evex" {
+				wantLength++
+			}
+			if affine {
+				wantLength++
+			}
+			if len(w.Encoding) != wantLength || affine && w.Encoding[len(w.Encoding)-1] != 7 {
+				t.Fatal("GFNI lost its exact immediate transport", row.ID, w)
+			}
+			instructions[w.Instruction] = true
+			formats[row.Opcode]++
+			generations[kind]++
+			widths[width]++
+			if w.Masked {
+				masked++
+			}
+			if w.Zeroing {
+				zeroing++
+			}
+			if w.Broadcast {
+				broadcast++
+			}
+			if w.Memory {
+				memory++
+			}
+		}
+	}
+	if len(rows) != 24 || len(seen) != 24 || len(instructions) != 84 || rowCounts["VGF2P8MULB"] != 8 || rowCounts["VGF2P8AFFINEQB"] != 8 || rowCounts["VGF2P8AFFINEINVQB"] != 8 ||
+		formats["VGF2P8MULB"] != 22 || formats["VGF2P8AFFINEQB"] != 31 || formats["VGF2P8AFFINEINVQB"] != 31 || generations["vex"] != 12 || generations["evex"] != 72 ||
+		widths[128] != 30 || widths[256] != 30 || widths[512] != 24 || masked != 48 || zeroing != 24 || broadcast != 18 || memory != 51 {
+		t.Fatal("complete GFNI row/control denominator changed", len(rows), len(instructions), rowCounts, formats, generations, widths, masked, zeroing, broadcast, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VGF2P8MULB X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0xcf, 0xd0}},
+		{"VGF2P8MULB.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0x75, 0xc1, 0xcf, 0x10}},
+		{"VGF2P8AFFINEQB $7,Y0,Y1,Y2", []byte{0xc4, 0xe3, 0xf5, 0xce, 0xd0, 0x07}},
+		{"VGF2P8AFFINEINVQB $7,X16,X17,X18", []byte{0x62, 0xa3, 0xf5, 0x00, 0xcf, 0xd0, 0x07}},
+		{"VGF2P8AFFINEQB.BCST $7,(AX),Z17,Z18", []byte{0x62, 0xe3, 0xf5, 0x50, 0xce, 0x10, 0x07}},
+		{"VGF2P8AFFINEINVQB.BCST.Z $7,(AX),Y17,K1,Y18", []byte{0x62, 0xe3, 0xf5, 0xb1, 0xcf, 0x10, 0x07}},
+	})
+}
+
+func TestX86GFNIMultiplyRetainsExistingBinaryTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := x86PackedBinaryRows(legacy, avx, "VGF2P8MULB")
+	if err != nil {
+		t.Fatal(err)
+	}
+	formats := 0
+	for _, row := range rows {
+		for _, w := range row.Witnesses {
+			formats++
+			if w.Broadcast || strings.Contains(w.Instruction, "$") || w.MaskResult {
+				t.Fatal("MUL borrowed affine or K-result transport", row.ID, w)
+			}
+		}
+	}
+	if len(rows) != 8 || formats != 22 {
+		t.Fatal("complete existing MUL source rows changed", len(rows), formats)
+	}
+}
+
+func TestX86GFNIRejectsForeignFormatAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"MUL BCST", "MUL W1", "MUL no66", "MUL map", "signed immediate", "matrix carrier", "data carrier", "K result", "K0 writemask", "matrix tuple", "BCST element", "rounding", "SAE", "affine map", "affine W0", "affine prefix", "VEX Z", "offset", "row index", "opcode extent"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VGF2P8AFFINEQB", 2
+			if strings.HasPrefix(mutation, "MUL ") {
+				name = "VGF2P8MULB"
+			}
+			if mutation == "K0 writemask" {
+				index = 3
+			}
+			if mutation == "VEX Z" {
+				index = 0
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+					t.Fatal("negative requires a valid complete original row", original, err)
+				}
+				row := original
+				row.Classes = append([]string(nil), row.Classes...)
+				row.OpBytes = append([]string(nil), row.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "MUL BCST":
+					row.OpBytes[feature] += "|evexBcstN8"
+				case "MUL W1":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW0", "evexW1", 1)
+				case "MUL no66":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex66", "", 1)
+				case "MUL map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F38", "evex0F", 1)
+				case "signed immediate":
+					row.Classes[0] = "Yi8"
+				case "matrix carrier":
+					row.Classes[1] = "YymEvex"
+				case "data carrier":
+					row.Classes[2] = "YyrEvex"
+				case "K result":
+					row.Classes[len(row.Classes)-1] = "Yk"
+				case "K0 writemask":
+					row.Classes[3] = "Yk"
+				case "matrix tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "BCST element":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexBcstN8", "evexBcstN4", 1)
+				case "rounding":
+					row.OpBytes[feature] += "|evexRoundingEnabled"
+				case "SAE":
+					row.OpBytes[feature] += "|evexSaeEnabled"
+				case "affine map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F3A", "evex0F38", 1)
+				case "affine W0":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW1", "evexW0", 1)
+				case "affine prefix":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex66", "evexF3", 1)
+				case "VEX Z":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "vex128", "vex512", 1)
+				case "offset":
+					row.EncodingOffset++
+				case "row index":
+					row.RowIndex++
+				case "opcode extent":
+					row.OpBytes[header+2] = "256"
+				}
+				if fmt.Sprint(row) == fmt.Sprint(original) {
+					t.Fatal("negative did not change its source row", mutation)
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("GFNI borrowed a foreign source/control capability", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("negative lost its exact Go row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_gp_bmi.go b/internal/goasmrules/x86_witness_gp_bmi.go
new file mode 100644
index 000000000..cdb431fed
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gp_bmi.go
@@ -0,0 +1,133 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// These four scalar transports share the original VEX payload, not numerical
+// semantics. In particular, MULX's vvvv operand is an output, not an input.
+type x86GPBMIFormat struct {
+	width, immediate    int
+	reversed, extension bool
+	digit               byte
+	encoding            x86PackedAVXOpcode
+}
+
+func x86GPBMITab(table string) bool {
+	return table == "_yandnl" || table == "_ybextrl" || table == "_yblsil" || table == "_yrorxl"
+}
+
+func x86GPBMIFormatForRule(rule X86AVXRule) (x86GPBMIFormat, error) {
+	f := x86GPBMIFormat{width: 32, immediate: -1}
+	f.encoding.kind = "vex"
+	fail := func() (x86GPBMIFormat, error) {
+		return f, fmt.Errorf("%s scalar GP roles/row/VEX payload differ from the original format", rule.Opcode)
+	}
+	if !x86GPBMITab(rule.Ytab) || rule.Prefix != "Pavx" || rule.EncodingOffset != 0 {
+		return fail()
+	}
+	classes, zcase, zoffset, row, stride := "Yml,Yrl,Yrl", "Zvex_rm_v_r", 2, 0, 2
+	mapTerm := "vex0F38"
+	optional := []string{"vexW0", "vexW1", "vexF2", "vexF3"}
+	switch rule.Ytab {
+	case "_ybextrl":
+		f.reversed = true
+		classes, zcase = "Yrl,Yml,Yrl", "Zvex_v_rm_r"
+		optional = append(optional, "vex66")
+	case "_yblsil":
+		f.extension = true
+		classes, zcase, zoffset, stride = "Yml,Yrl", "Zvex_rm_r_vo", 3, 3
+		optional = []string{"vexW0", "vexW1"}
+	case "_yrorxl":
+		f.immediate = 1
+		classes, zcase, zoffset, mapTerm = "Yu8,Yml,Yrl", "Zvex_i_rm_r", 0, "vex0F3A"
+		if rule.RowIndex == 1 {
+			f.immediate, classes, zoffset, row = 255, "Yi8,Yml,Yrl", 2, 1
+		}
+		optional = []string{"vexW0", "vexW1", "vexF2"}
+	}
+	if rule.RowIndex != row || rule.ZOffset != zoffset || rule.ZCase != zcase ||
+		strings.Join(rule.Classes, ",") != classes || len(rule.OpBytes) != stride {
+		return fail()
+	}
+	atoms, err := x86PackedEncodingAtoms(rule.OpBytes[0], []string{"avxEscape", "vex128", mapTerm}, optional)
+	if err != nil || atoms["vexW0"] == atoms["vexW1"] {
+		return fail()
+	}
+	if atoms["vexW1"] {
+		f.width, f.encoding.wBit = 64, 0x80
+	}
+	if !strings.HasSuffix(rule.Opcode, "L") && !strings.HasSuffix(rule.Opcode, "Q") ||
+		strings.HasSuffix(rule.Opcode, "Q") != (f.width == 64) {
+		return fail()
+	}
+	prefixes := 0
+	for index, prefix := range []string{"66", "F3", "F2"} {
+		if atoms["vex"+prefix] {
+			prefixes++
+			f.encoding.pp = byte(index + 1)
+		}
+	}
+	if prefixes > 1 || f.immediate >= 0 && !atoms["vexF2"] {
+		return fail()
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding.mapByte, f.encoding.opcode = 2, byte(opcode)
+	if f.immediate >= 0 {
+		f.encoding.mapByte = 3
+	}
+	if f.extension {
+		digit, err := strconv.ParseUint(rule.OpBytes[2], 0, 3)
+		if err != nil {
+			return fail()
+		}
+		f.digit = byte(digit)
+	}
+	return f, nil
+}
+
+func x86GPBMIRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86GPBMIFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, memory := range []bool{false, true} {
+		rm, modrm := "AX", byte(0xd8) // BX is ModRM.reg; AX is r/m.
+		if memory {
+			rm, modrm = "(AX)", 0x18
+		}
+		first, second, destination, vvvv := rm, "CX", "BX", byte(0x70)
+		operands := first + "," + second + "," + destination
+		if f.reversed {
+			first, second = second, first
+			operands = first + "," + second + "," + destination
+		} else if f.extension {
+			second, destination = "", "CX" // Result is VEX.vvvv; reg is literal /digit.
+			modrm = modrm&0xc7 | f.digit<<3
+			operands = first + "," + destination
+		} else if f.immediate >= 0 {
+			second, vvvv = "", 0x78 // The original immediate transport reserves vvvv.
+			immediate := "$1"
+			if f.immediate == 255 {
+				immediate = "$-1"
+			}
+			operands = immediate + "," + first + "," + destination
+		}
+		encoded := f.encoding.bytes(vvvv, 0, 0, modrm)
+		if f.immediate >= 0 {
+			encoded = append(encoded, byte(f.immediate))
+		}
+		witnesses = append(witnesses, X86PackedBinaryWitness{
+			Instruction: rule.Opcode + " " + operands, Generation: "vex",
+			First: first, Second: second, Destination: destination,
+			Width: f.width, Memory: memory, Encoding: encoded,
+		})
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_gp_bmi_test.go b/internal/goasmrules/x86_witness_gp_bmi_test.go
new file mode 100644
index 000000000..9357ac0e3
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gp_bmi_test.go
@@ -0,0 +1,145 @@
+package goasmrules
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Membership is independent of both the formatter and translator registries.
+func x86GPBMIOfficialTestRules(t *testing.T) []X86AVXRule {
+	t.Helper()
+	names := strings.Fields(`ANDNL ANDNQ BEXTRL BEXTRQ BLSIL BLSIQ BLSMSKL BLSMSKQ BLSRL BLSRQ
+		BZHIL BZHIQ MULXL MULXQ PDEPL PDEPQ PEXTL PEXTQ RORXL RORXQ SARXL SARXQ SHLXL SHLXQ SHRXL SHRXQ`)
+	selected := make(map[string]bool)
+	for _, name := range names {
+		if selected[name] {
+			t.Fatal("duplicate independent GP member", name)
+		}
+		selected[name] = true
+	}
+	if len(selected) != 26 {
+		t.Fatal("complete GP namespace changed", len(selected))
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rules []X86AVXRule
+	seen, tables := make(map[string]int), make(map[string]int)
+	for _, rule := range avx {
+		if selected[rule.Opcode] {
+			rules = append(rules, rule)
+			seen[rule.Opcode]++
+			tables[rule.Ytab]++
+		}
+	}
+	for name := range selected {
+		want := 1
+		if strings.HasPrefix(name, "RORX") {
+			want = 2
+		}
+		if seen[name] != want {
+			t.Fatal("complete original member rows changed", name, seen[name], want)
+		}
+	}
+	if len(rules) != 28 || len(tables) != 4 || tables["_yandnl"] != 8 || tables["_ybextrl"] != 10 || tables["_yblsil"] != 6 || tables["_yrorxl"] != 4 {
+		t.Fatal("complete original source tables changed", len(rules), tables)
+	}
+	return rules
+}
+
+func TestX86GPBMICompleteOfficialSourceWitnesses(t *testing.T) {
+	for _, rule := range x86GPBMIOfficialTestRules(t) {
+		t.Run(fmt.Sprintf("%s/%d", rule.Opcode, rule.RowIndex), func(t *testing.T) {
+			witnesses, err := x86PackedAVXRowWitnesses(rule)
+			if err != nil || len(witnesses) != 2 {
+				t.Fatal("original row lacks its register and memory witness", len(witnesses), err)
+			}
+			for index, w := range witnesses {
+				if w.Generation != "vex" || w.Width != 32 && w.Width != 64 || w.Memory != (index == 1) ||
+					w.Masked || w.Zeroing || w.Broadcast || w.MaskResult || len(w.Encoding) == 0 {
+					t.Fatal("GP transport gained vector controls or lost an operand alternative", w)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GPBMISourceTransportByteAnchors(t *testing.T) {
+	anchors := map[string]string{
+		"ANDNL AX,CX,BX":    "c4e270f2d8",
+		"ANDNQ (AX),CX,BX":  "c4e2f0f218",
+		"BEXTRQ CX,AX,BX":   "c4e2f0f7d8",
+		"BLSIQ AX,CX":       "c4e2f0f3d8",
+		"BLSMSKL (AX),CX":   "c4e270f310",
+		"MULXQ AX,CX,BX":    "c4e2f3f6d8",
+		"RORXL $1,AX,BX":    "c4e37bf0d801",
+		"RORXQ $-1,(AX),BX": "c4e3fbf018ff",
+	}
+	for _, rule := range x86GPBMIOfficialTestRules(t) {
+		witnesses, err := x86PackedAVXRowWitnesses(rule)
+		if err != nil {
+			t.Fatal("valid original before byte controls", err)
+		}
+		for _, w := range witnesses {
+			if encoded, ok := anchors[w.Instruction]; ok {
+				want, err := hex.DecodeString(encoded)
+				if err != nil || !bytes.Equal(w.Encoding, want) {
+					t.Fatal("independent operand/extension/vvvv/imm8 anchor", w, encoded, err)
+				}
+				delete(anchors, w.Instruction)
+			}
+		}
+	}
+	if len(anchors) != 0 {
+		t.Fatal("missing independent GP transport anchors", anchors)
+	}
+}
+
+func TestX86GPBMIRejectsMutatedSourceMetadata(t *testing.T) {
+	for _, rule := range x86GPBMIOfficialTestRules(t) {
+		t.Run(fmt.Sprintf("%s/%d", rule.Opcode, rule.RowIndex), func(t *testing.T) {
+			if witnesses, err := x86PackedAVXRowWitnesses(rule); err != nil || len(witnesses) != 2 {
+				t.Fatal("valid original before rejection controls", err)
+			}
+			for _, axis := range []string{"prefix", "row", "zoffset", "offset", "roles", "zcase", "header", "length", "W", "opcode-byte", "extra-payload"} {
+				t.Run(axis, func(t *testing.T) {
+					changed := rule
+					changed.Classes = append([]string(nil), rule.Classes...)
+					changed.OpBytes = append([]string(nil), rule.OpBytes...)
+					switch axis {
+					case "prefix":
+						changed.Prefix = "Pm"
+					case "row":
+						changed.RowIndex += 10
+					case "zoffset":
+						changed.ZOffset += 10
+					case "offset":
+						changed.EncodingOffset++
+					case "roles":
+						changed.Classes[len(changed.Classes)-1] = "Yxr"
+					case "zcase":
+						changed.ZCase = "Zevex_rm_v_r"
+					case "header":
+						changed.OpBytes[0] += "|vexInventedPermission"
+					case "length":
+						changed.OpBytes[0] = strings.Replace(changed.OpBytes[0], "vex128", "vex256", 1)
+					case "W":
+						changed.OpBytes[0] = strings.NewReplacer("vexW0", "vexW1", "vexW1", "vexW0").Replace(changed.OpBytes[0])
+					case "opcode-byte":
+						changed.OpBytes[1] = "0x100"
+					case "extra-payload":
+						changed.OpBytes = append(changed.OpBytes, "0")
+					}
+					if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+						t.Fatal("corrupt original metadata granted a physical GP format", axis, changed)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_gp_data_flags_cpu.go b/internal/goasmrules/x86_witness_gp_data_flags_cpu.go
new file mode 100644
index 000000000..f3f5bb6f1
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gp_data_flags_cpu.go
@@ -0,0 +1,74 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Source families sharing a transport do not inherit each other's numerical,
+// address, FLAGS, machine-state or native-entry contracts.
+func x86GPDataFlagsCPUSourceMember(entry X86LegacyOpcode) bool {
+	name := entry.Opcode
+	if len(name) == 0 {
+		return false
+	}
+	width, stem := name[len(name)-1], name[:len(name)-1]
+	switch entry.Ytab {
+	case "yxorb", "ytestl", "ybtl":
+		return true // These complete tables own only the selected data families.
+	case "ybswap":
+		return stem == "BSWAP" && strings.ContainsRune("LQ", rune(width))
+	case "ym_rl":
+		return stem == "LEA" && strings.ContainsRune("WLQ", rune(width))
+	case "yrb_mb":
+		return width == 'B' && (stem == "XADD" || stem == "CMPXCHG")
+	case "yrl_ml":
+		return strings.ContainsRune("WLQ", rune(width)) && (stem == "XADD" || stem == "CMPXCHG") ||
+			strings.ContainsRune("LQ", rune(width)) && stem == "MOVNTI" || name == "MOVQL"
+	case "yscond":
+		return name == "CMPXCHG8B" || name == "CMPXCHG16B"
+	case "ycrc32b":
+		return name == "CRC32B"
+	case "ycrc32l":
+		return (stem == "CRC32" || stem == "TZCNT") && strings.ContainsRune("WLQ", rune(width))
+	case "yrdrand":
+		return name == "RDPID" || (stem == "RDRAND" || stem == "RDSEED") && strings.ContainsRune("WLQ", rune(width))
+	}
+	return false
+}
+
+// X86GPDataFlagsCPURows retains original rows and mode refusals. Go also
+// encodes CPU-invalid register destinations for MOVNTI and pair CMPXCHG;
+// those source observations must never be treated as numerical positives.
+func X86GPDataFlagsCPURows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("GP source view requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if !x86GPDataFlagsCPUSourceMember(entry) {
+			continue
+		}
+		for _, original := range entry.Rows {
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, original.RowIndex)
+			if seen[id] {
+				return nil, fmt.Errorf("duplicate GP source row %s", id)
+			}
+			seen[id] = true
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, original, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", id, err)
+			}
+			row := X86ScalarRMWRow{ID: id, Opcode: entry.Opcode, Witnesses: witnesses}
+			if arch == "386" && entry.Prefix == "Pw" {
+				row.ModeFiltered, row.Witnesses = "original Go Pw requires amd64", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(result) != 99 && len(result) != 100 {
+		return nil, fmt.Errorf("incomplete GP source view: rows=%d", len(result))
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_gp_data_flags_cpu_test.go b/internal/goasmrules/x86_witness_gp_data_flags_cpu_test.go
new file mode 100644
index 000000000..b63c9b22f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_gp_data_flags_cpu_test.go
@@ -0,0 +1,287 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is an independent source inventory, not a numerical consumer registry.
+// Shared tables also contain ARPL, descriptor/state and FS/GS-base roles.
+func gpDataFlagsCPUOriginalMember(entry X86LegacyOpcode) bool {
+	switch entry.Ytab {
+	case "yxorb", "ytestl", "ybtl", "ybswap":
+		return true
+	case "ym_rl":
+		return strings.HasPrefix(entry.Opcode, "LEA")
+	case "yrb_mb", "yrl_ml":
+		return strings.HasPrefix(entry.Opcode, "XADD") || strings.HasPrefix(entry.Opcode, "CMPXCHG") ||
+			strings.HasPrefix(entry.Opcode, "MOVNTI") || entry.Opcode == "MOVQL"
+	case "yscond":
+		return entry.Opcode == "CMPXCHG8B" || entry.Opcode == "CMPXCHG16B"
+	case "ycrc32b", "ycrc32l":
+		return strings.HasPrefix(entry.Opcode, "CRC32") || strings.HasPrefix(entry.Opcode, "TZCNT")
+	case "yrdrand":
+		return strings.HasPrefix(entry.Opcode, "RDRAND") || strings.HasPrefix(entry.Opcode, "RDSEED") || entry.Opcode == "RDPID"
+	}
+	return false
+}
+
+func gpDataFlagsCPUOriginalEntries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	schemas := map[string][]string{
+		"yxorb":   {"Zib_/1/Yi32,Yal", "Zibo_m/2/Yi32,Ymb", "Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb"},
+		"ytestl":  {"Zil_/1/Yi32,Yax", "Zilo_m/2/Yi32,Yml", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"},
+		"ybtl":    {"Zibo_m/2/Yi8,Yml", "Zr_m/1/Yrl,Yml"},
+		"ybswap":  {"Z_rp/2/Yrl"},
+		"ym_rl":   {"Zm_r/1/Ym,Yrl"},
+		"yrb_mb":  {"Zr_m/1/Yrb,Ymb"},
+		"yrl_ml":  {"Zr_m/1/Yrl,Yml"},
+		"yscond":  {"Zo_m/2/Ymb"},
+		"ycrc32b": {"Zlitm_r/0/Ymb,Yrl"},
+		"ycrc32l": {"Zlitm_r/0/Yml,Yrl"},
+		"yrdrand": {"Zo_m/2/Yrl"},
+	}
+	var entries []X86LegacyOpcode
+	counts, rows := map[string]int{}, 0
+	for _, entry := range catalog.Optab {
+		if !gpDataFlagsCPUOriginalMember(entry) {
+			continue
+		}
+		want := schemas[entry.Ytab]
+		if entry.Kind != "encoding" || len(entry.Rows) != len(want) {
+			t.Fatal("complete GP original source table changed", entry)
+		}
+		offset := 0
+		for i, row := range entry.Rows {
+			schema := fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ","))
+			if row.RowIndex != i || row.UnmatchedOffset != offset || schema != want[i] ||
+				len(row.Classes) != strings.Count(strings.Split(want[i], "/")[2], ",")+1 {
+				t.Fatal("original complete GP row/arity/order changed", entry, row)
+			}
+			offset += row.ZOffset + entry.EscapeAdjustment
+			counts[entry.Ytab]++
+			rows++
+		}
+		entries = append(entries, entry)
+	}
+	for table, count := range map[string]int{
+		"yxorb": 32, "ytestl": 12, "ybtl": 24, "ybswap": 2, "ym_rl": 3,
+		"yrb_mb": 2, "yrl_ml": 9, "yscond": 2, "ycrc32b": 1, "ycrc32l": 6,
+	} {
+		if counts[table] != count {
+			t.Fatal("complete GP source family count changed", table, counts)
+		}
+	}
+	if counts["yrdrand"] != 6 && counts["yrdrand"] != 7 || rows != 93+counts["yrdrand"] {
+		t.Fatal("complete GP source union changed", rows, counts)
+	}
+	return entries
+}
+
+func TestX86GPDataFlagsCPUCompleteOriginalSourceInventory(t *testing.T) {
+	gpDataFlagsCPUOriginalEntries(t)
+}
+
+func TestX86GPDataFlagsCPURegisterOpcodeCannotBePadding(t *testing.T) {
+	for _, entry := range gpDataFlagsCPUOriginalEntries(t) {
+		if entry.Ytab != "ybswap" {
+			continue
+		}
+		t.Run(entry.Opcode, func(t *testing.T) {
+			// Keep the full original schema, escape and source identity.
+			// Only the register-in-opcode base is replaced by padding.
+			changed := entry
+			changed.OpBytes = []string{"0x0f", "0"}
+			if got, err := x86ScalarRMWRowWitnesses(changed, entry.Rows[0], "amd64"); err == nil {
+				t.Fatal("GP_DATA_FLAGS_CPU_REGISTER_OPCODE_PADDING_ACCEPTED", got)
+			}
+		})
+	}
+}
+
+func TestX86GPDataFlagsCPUExistingTransportCompleteFamily(t *testing.T) {
+	for _, entry := range gpDataFlagsCPUOriginalEntries(t) {
+		for _, row := range entry.Rows {
+			for _, arch := range []string{"amd64", "386"} {
+				if arch == "386" && entry.Prefix == "Pw" {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%d/%s", entry.Opcode, row.RowIndex, arch), func(t *testing.T) {
+					before := fmt.Sprintf("%#v", entry)
+					witnesses, err := x86ScalarRMWRowWitnesses(entry, row, arch)
+					want := 2
+					if entry.Ytab == "yrdrand" || entry.Ytab == "ym_rl" || entry.Ytab == "ybswap" ||
+						row.ZCase == "Zib_" || row.ZCase == "Zil_" || row.ZCase == "Zm_r" {
+						want = 1
+					}
+					if err != nil || len(witnesses) != want {
+						t.Fatal("GP_DATA_FLAGS_CPU_SOURCE_TRANSPORT_FEATURE_GAP", err, len(witnesses), want)
+					}
+					for _, witness := range witnesses {
+						if witness.Instruction == "" || witness.Destination == "" || len(witness.Encoding) == 0 ||
+							entry.Ytab == "yrdrand" && strings.Contains(witness.Instruction, "(") {
+							t.Fatal("source-only witness lost its complete operand roles", entry, witness)
+						}
+					}
+					if before != fmt.Sprintf("%#v", entry) {
+						t.Fatal("cold formatter modified original source")
+					}
+					for _, expression := range []string{"obj.A" + entry.Opcode, ""} {
+						variant := entry
+						variant.OpcodeExpression = expression
+						got, err := x86ScalarRMWRowWitnesses(variant, row, arch)
+						if err != nil || !reflect.DeepEqual(got, witnesses) {
+							t.Fatal("captured obj enum or existing unobserved fixture contract changed", expression, err)
+						}
+					}
+					if entry.Ytab == "ycrc32b" || entry.Ytab == "ycrc32l" {
+						implicit := entry
+						// Removing this explicit zero does not change the full
+						// [31]byte Go array: its remaining cells are already zero.
+						implicit.OpBytes = append([]string(nil), entry.OpBytes[:len(entry.OpBytes)-1]...)
+						got, err := x86ScalarRMWRowWitnesses(implicit, row, arch)
+						if err != nil || !reflect.DeepEqual(got, witnesses) {
+							t.Fatal("GP_DATA_FLAGS_CPU_IMPLICIT_ZERO_EQUIVALENCE_GAP", entry.Opcode, row.RowIndex, arch, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GPDataFlagsCPUCompleteOriginalMetadataBoundaries(t *testing.T) {
+	for _, entry := range gpDataFlagsCPUOriginalEntries(t) {
+		for _, original := range entry.Rows {
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, original.RowIndex), func(t *testing.T) {
+				for _, field := range []string{
+					"kind", "row-count", "original-arity", "selected-arity", "original-joined-arity", "selected-joined-arity", "original-class", "selected-class",
+					"original-index", "selected-index", "original-zcase", "selected-zcase",
+					"original-stride-negative", "original-stride-overflow", "selected-stride",
+					"original-offset-negative", "selected-offset-overflow", "prefix",
+					"escape-negative", "escape-overflow", "empty-payload", "truncated-payload",
+				} {
+					changed, row := entry, original
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					maxInt := int(^uint(0) >> 1)
+					switch field {
+					case "kind":
+						changed.Kind = "reserved"
+					case "row-count":
+						changed.Rows = append(changed.Rows, original)
+					case "original-arity":
+						changed.Rows[0].Classes = append(append([]string(nil), changed.Rows[0].Classes...), "Ynone")
+					case "selected-arity":
+						row.Classes = append(append([]string(nil), row.Classes...), "Ynone")
+					case "original-joined-arity":
+						changed.Rows[0].Classes = []string{strings.Join(changed.Rows[0].Classes, ",")}
+						if len(entry.Rows[0].Classes) == 1 {
+							changed.Rows[0].Classes = nil
+						}
+					case "selected-joined-arity":
+						row.Classes = []string{strings.Join(row.Classes, ",")}
+						if len(original.Classes) == 1 {
+							row.Classes = nil
+						}
+					case "original-class":
+						changed.Rows[0].Classes = append([]string(nil), changed.Rows[0].Classes...)
+						changed.Rows[0].Classes[0] = "Yinvalid"
+					case "selected-class":
+						row.Classes = append([]string(nil), row.Classes...)
+						row.Classes[0] = "Yinvalid"
+					case "original-index":
+						changed.Rows[0].RowIndex = -1
+					case "selected-index":
+						row.RowIndex = maxInt
+					case "original-zcase":
+						changed.Rows[0].ZCase = "Zinvalid"
+					case "selected-zcase":
+						row.ZCase = "Zinvalid"
+					case "original-stride-negative":
+						changed.Rows[0].ZOffset = -maxInt - 1
+					case "original-stride-overflow":
+						changed.Rows[0].ZOffset = maxInt
+					case "selected-stride":
+						row.ZOffset = maxInt
+					case "original-offset-negative":
+						changed.Rows[0].UnmatchedOffset = -maxInt - 1
+					case "selected-offset-overflow":
+						row.UnmatchedOffset = maxInt
+					case "prefix":
+						changed.Prefix = "Pinvalid"
+					case "escape-negative":
+						changed.EscapeAdjustment = -1
+					case "escape-overflow":
+						changed.EscapeAdjustment = maxInt
+					case "empty-payload":
+						changed.OpBytes = nil
+					case "truncated-payload":
+						end := len(changed.OpBytes) - 1
+						if entry.Ytab == "ycrc32b" || entry.Ytab == "ycrc32l" {
+							// The final zero alone is implicit-padding equivalent;
+							// remove an actual mandatory opcode byte as well.
+							end--
+						}
+						changed.OpBytes = changed.OpBytes[:end]
+					}
+					func() {
+						defer func() {
+							if p := recover(); p != nil {
+								t.Errorf("GP_DATA_FLAGS_CPU_METADATA_PANIC op=%s row=%d mutation=%s panic=%v", entry.Opcode, original.RowIndex, field, p)
+							}
+						}()
+						if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+							t.Errorf("GP_DATA_FLAGS_CPU_MALFORMED_ACCEPTED op=%s row=%d mutation=%s", entry.Opcode, original.RowIndex, field)
+						}
+					}()
+				}
+				// Every payload atom, including later literal bytes and its
+				// terminator, must be validated before any slice or emission.
+				for index := range entry.OpBytes {
+					for _, atom := range []string{"-1", "0x100", "not-a-byte"} {
+						changed := entry
+						changed.OpBytes = append([]string(nil), entry.OpBytes...)
+						changed.OpBytes[index] = atom
+						if _, err := x86ScalarRMWRowWitnesses(changed, original, "amd64"); err == nil {
+							t.Errorf("GP_DATA_FLAGS_CPU_MALFORMED_ACCEPTED op=%s row=%d atomIndex=%d atom=%q", entry.Opcode, original.RowIndex, index, atom)
+						}
+					}
+				}
+				if entry.Ytab == "yxorb" {
+					for _, axis := range [][2]string{{"W", "Pe"}, {"L", "Px"}, {"Q", "Pw"}} {
+						changed := entry
+						changed.Opcode = entry.Opcode[:len(entry.Opcode)-1] + axis[0]
+						changed.Prefix = axis[1]
+						// Keep enum/name consistent so the independent byte-width
+						// grammar guard, not source identity, rejects this clone.
+						changed.OpcodeExpression = "A" + changed.Opcode
+						if _, err := x86ScalarRMWRowWitnesses(changed, original, "amd64"); err == nil {
+							t.Errorf("GP_DATA_FLAGS_CPU_BYTE_SCHEMA_WIDENED op=%s row=%d changed=%s prefix=%s", entry.Opcode, original.RowIndex, changed.Opcode, axis[1])
+						}
+					}
+				}
+				if entry.Ytab == "ycrc32b" || entry.Ytab == "ycrc32l" {
+					for index := range entry.OpBytes {
+						changed := entry
+						changed.OpBytes = append([]string(nil), entry.OpBytes...)
+						changed.OpBytes[index] = "0"
+						if index == len(entry.OpBytes)-1 {
+							changed.OpBytes[index] = "1"
+						}
+						if _, err := x86ScalarRMWRowWitnesses(changed, original, "amd64"); err == nil {
+							t.Errorf("GP_DATA_FLAGS_CPU_MALFORMED_ACCEPTED op=%s row=%d literalZeroIndex=%d", entry.Opcode, original.RowIndex, index)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_horizontal_test.go b/internal/goasmrules/x86_witness_horizontal_test.go
new file mode 100644
index 000000000..8bfe70a7c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_horizontal_test.go
@@ -0,0 +1,94 @@
+package goasmrules
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+func TestX86PackedHorizontalIntegerRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedHorizontalIntegerRows,
+		`^V?PH(ADD|SUB)(W|D|SW)$`, `^$`, x86PackedRowCounts{
+			names: 12, mmx: 1,
+			rows: [3]int{6, 12, 0}, formats: [3]int{12, 24, 0}, widths: [3]int{24, 12, 0},
+		})
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PHADDW X0,X1", []byte{0x66, 0x0f, 0x38, 0x01, 0xc8}},
+		{"PHADDD (AX),X1", []byte{0x66, 0x0f, 0x38, 0x02, 0x08}},
+		{"PHADDSW X0,X1", []byte{0x66, 0x0f, 0x38, 0x03, 0xc8}},
+		{"PHSUBW (AX),X1", []byte{0x66, 0x0f, 0x38, 0x05, 0x08}},
+		{"PHSUBD X0,X1", []byte{0x66, 0x0f, 0x38, 0x06, 0xc8}},
+		{"PHSUBSW (AX),X1", []byte{0x66, 0x0f, 0x38, 0x07, 0x08}},
+		{"VPHADDW X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x01, 0xd0}},
+		{"VPHADDD (AX),Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x02, 0x10}},
+		{"VPHADDSW Y0,Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x03, 0xd0}},
+		{"VPHSUBW (AX),X1,X2", []byte{0xc4, 0xe2, 0x71, 0x05, 0x10}},
+		{"VPHSUBD X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x06, 0xd0}},
+		{"VPHSUBSW (AX),Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x07, 0x10}},
+	})
+}
+
+func x86HorizontalLiteralFixture() (X86LegacyOpcode, X86LegacyOperand) {
+	entry := X86LegacyOpcode{
+		Kind: "encoding", Opcode: "PHADDD", Ytab: "ymmxmm0f38", Prefix: "Px", EscapeAdjustment: 1,
+		OpBytes: []string{"0x0F", "0x38", "0x02", "0", "0x66", "0x0F", "0x38", "0x02", "0"},
+	}
+	row := X86LegacyOperand{
+		RowIndex: 1, Classes: []string{"Yxm", "Yxr"}, ZCase: "Zlitm_r", ZOffset: 5, UnmatchedOffset: 4,
+	}
+	return entry, row
+}
+
+func TestX86PackedLegacyLiteralOpcodeConsumesSelectedTablePayload(t *testing.T) {
+	entry, row := x86HorizontalLiteralFixture()
+	before := entry
+	before.OpBytes = append([]string(nil), entry.OpBytes...)
+	witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+	if err != nil || len(witnesses) != 2 ||
+		!bytes.Equal(witnesses[0].Encoding, []byte{0x66, 0x0f, 0x38, 0x02, 0xc8}) ||
+		!bytes.Equal(witnesses[1].Encoding, []byte{0x66, 0x0f, 0x38, 0x02, 0x08}) || !reflect.DeepEqual(entry, before) {
+		t.Fatal("selected XMM literal payload was lost, confused with MMX or mutated", witnesses, err)
+	}
+	// Only the independent original-Go join establishes the ISA identity. The
+	// encoder must consume the selected table bytes, not replace them by name.
+	entry.OpBytes[7] = "0x06"
+	witnesses, err = x86PackedLegacyRowWitnesses(entry, row)
+	if err != nil || len(witnesses) != 2 || !bytes.Equal(witnesses[0].Encoding, []byte{0x66, 0x0f, 0x38, 0x06, 0xc8}) {
+		t.Fatal("literal encoder substituted a mnemonic-specific opcode", witnesses, err)
+	}
+}
+
+func TestX86PackedLegacyLiteralOpcodeRejectsUnknownAxes(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mutate func(*X86LegacyOpcode, *X86LegacyOperand)
+	}{
+		{"kind", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Kind = "special" }},
+		{"table", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Ytab = "unknown" }},
+		{"prefix", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Prefix = "Pq4" }},
+		{"escape", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.EscapeAdjustment = 0 }},
+		{"index", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.RowIndex = 0 }},
+		{"zcase", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZCase = "Zm_r" }},
+		{"stride", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZOffset = 4 }},
+		{"offset", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.UnmatchedOffset = 3 }},
+		{"MMX row", func(_ *X86LegacyOpcode, r *X86LegacyOperand) {
+			r.RowIndex, r.Classes, r.ZOffset, r.UnmatchedOffset = 0, []string{"Ymm", "Ymr"}, 3, 0
+		}},
+		{"empty", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = nil }},
+		{"short", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = e.OpBytes[:8] }},
+		{"extra", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = append(e.OpBytes, "0x90") }},
+		{"early terminator", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[6] = "0" }},
+		{"missing terminator", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[8] = "0x90" }},
+		{"previous terminator", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[3] = "0x90" }},
+		{"symbol", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[7] = "opcode" }},
+		{"overflow", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes[7] = "0x102" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			entry, row := x86HorizontalLiteralFixture()
+			test.mutate(&entry, &row)
+			if witnesses, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+				t.Fatal("unknown literal row or incomplete payload was silently accepted", witnesses, err)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_immediate_integer_compare_test.go b/internal/goasmrules/x86_witness_immediate_integer_compare_test.go
new file mode 100644
index 000000000..1d14c7c29
--- /dev/null
+++ b/internal/goasmrules/x86_witness_immediate_integer_compare_test.go
@@ -0,0 +1,181 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86ImmediateIntegerCompareTestNames = "VPCMPB VPCMPUB VPCMPW VPCMPUW VPCMPD VPCMPUD VPCMPQ VPCMPUQ"
+
+func TestX86ImmediateIntegerCompareCompleteOfficialRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	for _, name := range strings.Fields(x86ImmediateIntegerCompareTestNames) {
+		names[name] = true
+	}
+	originals := map[string]X86AVXRule{}
+	for _, entry := range legacy.Optab {
+		if names[entry.Opcode] {
+			t.Fatal("immediate integer compare acquired a legacy row", entry)
+		}
+	}
+	for index, row := range avx {
+		if names[row.Opcode] {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = row
+		}
+	}
+	if len(originals) != 48 {
+		t.Fatal("complete eight-member six-row original source denominator changed", len(originals))
+	}
+	// Existing helper: RED must report a real unsupported table format.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86ImmediateIntegerCompareTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions, members := map[string]bool{}, map[string]bool{}, map[string]bool{}
+	widths, destinations := map[int]int{}, map[string]int{}
+	masked, broadcast, memory := 0, 0, 0
+	for _, row := range rows {
+		original, found := originals[row.ID]
+		if !found || seen[row.ID] || original.Ytab != "_yvpcmpb" {
+			t.Fatal("immediate compare lost original table identity", row)
+		}
+		seen[row.ID], members[row.Opcode] = true, true
+		width := map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[original.Classes[1]]
+		bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[width]
+		for _, w := range row.Witnesses {
+			fields := strings.Fields(w.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("lost immediate compare instruction", w)
+			}
+			args := strings.Split(fields[1], ",")
+			if instructions[w.Instruction] || args[0] != "$7" || w.First != args[1] || w.Second != args[2] ||
+				w.First != bank+"16" && w.First != "(AX)" || w.Second != bank+"17" ||
+				w.Destination != args[len(args)-1] || w.Destination != "K0" && w.Destination != "K2" ||
+				w.Generation != "evex" || w.Width != width || !w.MaskResult || w.Zeroing ||
+				w.Masked != (original.ZCase == "Zevex_i_rm_v_k_r") || w.Masked && args[3] != "K1" ||
+				w.Memory != (w.First == "(AX)") || w.Broadcast != strings.Contains(fields[0], ".BCST") ||
+				w.Broadcast && (!w.Memory || !strings.HasSuffix(row.Opcode, "D") && !strings.HasSuffix(row.Opcode, "Q")) ||
+				len(w.Encoding) != 7 || w.Encoding[0] != 0x62 || w.Encoding[1]&0x1f != 0x13 || w.Encoding[2]&0x7f != 0x75 ||
+				w.Encoding[3]&0x88 != 0 || 128<<(w.Encoding[3]>>5&3) != width || w.Encoding[6] != 7 {
+				t.Fatal("immediate/vector/K-result/nonzero-mask roles were conflated", row.ID, w)
+			}
+			instructions[w.Instruction] = true
+			widths[width]++
+			destinations[w.Destination]++
+			if w.Masked {
+				masked++
+			}
+			if w.Broadcast {
+				broadcast++
+			}
+			if w.Memory {
+				memory++
+			}
+		}
+	}
+	if len(rows) != 48 || len(seen) != len(originals) || len(members) != 8 || len(instructions) != 240 ||
+		widths[128] != 80 || widths[256] != 80 || widths[512] != 80 ||
+		destinations["K0"] != 120 || destinations["K2"] != 120 || masked != 120 || broadcast != 48 || memory != 144 {
+		t.Fatal("complete immediate compare row/control denominator changed", len(rows), len(members), len(instructions), widths, destinations, masked, broadcast, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VPCMPB $7,X16,X17,K0", []byte{0x62, 0xb3, 0x75, 0x00, 0x3f, 0xc0, 0x07}},
+		{"VPCMPUB $7,(AX),Z17,K1,K2", []byte{0x62, 0xf3, 0x75, 0x41, 0x3e, 0x10, 0x07}},
+		{"VPCMPW $7,Y16,Y17,K2", []byte{0x62, 0xb3, 0xf5, 0x20, 0x3f, 0xd0, 0x07}},
+		{"VPCMPUW $7,Z16,Z17,K1,K0", []byte{0x62, 0xb3, 0xf5, 0x41, 0x3e, 0xc0, 0x07}},
+		{"VPCMPD.BCST $7,(AX),X17,K0", []byte{0x62, 0xf3, 0x75, 0x10, 0x1f, 0x00, 0x07}},
+		{"VPCMPUD $7,Z16,Z17,K1,K2", []byte{0x62, 0xb3, 0x75, 0x41, 0x1e, 0xd0, 0x07}},
+		{"VPCMPQ $7,X16,X17,K1,K2", []byte{0x62, 0xb3, 0xf5, 0x01, 0x1f, 0xd0, 0x07}},
+		{"VPCMPUQ.BCST $7,(AX),Y17,K1,K0", []byte{0x62, 0xf3, 0xf5, 0x31, 0x1e, 0x00, 0x07}},
+	})
+}
+
+func TestX86ImmediateIntegerCompareRejectsForeignFormatAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"signed immediate", "source carrier", "second carrier", "vector result", "nonzero-only result", "K0 writemask", "tuple", "byte BCST", "wrong BCST element", "zeroing", "rounding", "SAE", "map", "PP", "W", "VEX", "offset", "row index", "opcode extent"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VPCMPD", 0
+			if mutation == "byte BCST" {
+				name = "VPCMPB"
+			}
+			if mutation == "K0 writemask" {
+				index = 1
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+					t.Fatal("negative requires its valid original row", original, err)
+				}
+				row := original
+				row.Classes, row.OpBytes = append([]string(nil), original.Classes...), append([]string(nil), original.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "signed immediate":
+					row.Classes[0] = "Yi8"
+				case "source carrier":
+					row.Classes[1] = "YymEvex"
+				case "second carrier":
+					row.Classes[2] = "YyrEvex"
+				case "vector result":
+					row.Classes[len(row.Classes)-1] = "YxrEvex"
+				case "nonzero-only result":
+					row.Classes[len(row.Classes)-1] = "Yknot0"
+				case "K0 writemask":
+					row.Classes[3] = "Yk"
+				case "tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "byte BCST":
+					row.OpBytes[feature] += "|evexBcstN4"
+				case "wrong BCST element":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexBcstN4", "evexBcstN8", 1)
+				case "zeroing":
+					row.OpBytes[feature] += "|evexZeroingEnabled"
+				case "rounding":
+					row.OpBytes[feature] += "|evexRoundingEnabled"
+				case "SAE":
+					row.OpBytes[feature] += "|evexSaeEnabled"
+				case "map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F3A", "evex0F38", 1)
+				case "PP":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex66", "evexF3", 1)
+				case "W":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW0", "evexW1", 1)
+				case "VEX":
+					row.ZCase = "Zvex_i_rm_v_r"
+				case "offset":
+					row.EncodingOffset++
+				case "row index":
+					row.RowIndex++
+				case "opcode extent":
+					row.OpBytes[header+2] = "256"
+				}
+				if fmt.Sprint(row) == fmt.Sprint(original) {
+					t.Fatal("negative did not change its original row", mutation)
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("immediate integer compare borrowed a foreign format axis", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("negative lost its original row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_immediate_shuffle_test.go b/internal/goasmrules/x86_witness_immediate_shuffle_test.go
new file mode 100644
index 000000000..83ebd77bd
--- /dev/null
+++ b/internal/goasmrules/x86_witness_immediate_shuffle_test.go
@@ -0,0 +1,109 @@
+package goasmrules
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedImmediateShuffleCompleteOfficialTransport(t *testing.T) {
+	// PSHUFL and PSHUFD have distinct source optab entries. Preserve both;
+	// neither is a frontend-only alias like PADDD.
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx,
+				`PSHUFL PSHUFD PSHUFHW PSHUFLW VPSHUFD VPSHUFHW VPSHUFLW`)
+		}, `^(PSHUF(L|D|HW|LW)|VPSHUF(D|HW|LW))$`, `^VPSHUFD$`, x86PackedRowCounts{
+			names: 7, broadcast: 9,
+			rows: [3]int{4, 12, 18}, formats: [3]int{8, 24, 63}, widths: [3]int{41, 33, 21},
+		})
+	masked, zeroing, memory := 0, 0, 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			operands := strings.Split(strings.Fields(witness.Instruction)[1], ",")
+			if witness.First != operands[1] || witness.First == "" || witness.Second != "" ||
+				witness.Memory != (witness.First == "(AX)") || witness.MaskResult {
+				t.Fatal("unary immediate shuffle confused its literal, source and destination", row.ID, witness)
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.Memory {
+				memory++
+			}
+		}
+	}
+	if masked != 42 || zeroing != 21 || memory != 52 {
+		t.Fatal("shuffle mask/zero/complete memory controls changed", masked, zeroing, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PSHUFL $7,X0,X1", []byte{0x66, 0x0f, 0x70, 0xc8, 7}},
+		{"PSHUFD $7,(AX),X1", []byte{0x66, 0x0f, 0x70, 0x08, 7}},
+		{"PSHUFHW $7,X0,X1", []byte{0xf3, 0x0f, 0x70, 0xc8, 7}},
+		{"PSHUFLW $7,(AX),X1", []byte{0xf2, 0x0f, 0x70, 0x08, 7}},
+		{"VPSHUFD $7,X0,X2", []byte{0xc5, 0xf9, 0x70, 0xd0, 7}},
+		{"VPSHUFHW $-1,(AX),Y2", []byte{0xc5, 0xfe, 0x70, 0x10, 255}},
+		{"VPSHUFD.BCST.Z $7,(AX),K1,Z18", []byte{0x62, 0xe1, 0x7d, 0xd9, 0x70, 0x10, 7}},
+		{"VPSHUFLW $7,Y16,Y18", []byte{0x62, 0xa1, 0x7f, 0x28, 0x70, 0xd0, 7}},
+	})
+}
+
+func TestX86PackedImmediateShuffleAVXRegisterDestinationTransport(t *testing.T) {
+	x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx, `VPSHUFD VPSHUFHW VPSHUFLW`)
+		}, `^VPSHUF(D|HW|LW)$`, `^VPSHUFD$`, x86PackedRowCounts{
+			names: 3, broadcast: 9,
+			rows: [3]int{0, 12, 18}, formats: [3]int{0, 24, 63}, widths: [3]int{33, 33, 21},
+		})
+}
+
+func TestX86PackedImmediateShuffleTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"rotate extension role", "signed EVEX", "word broadcast", "tuple", "SAE", "binary F3"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VPSHUFD", 4
+			if mutation == "word broadcast" {
+				name = "VPSHUFHW"
+			} else if mutation == "binary F3" {
+				name, index = "VPMULLD", 2
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				changed := original
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				changed.Classes = append([]string(nil), original.Classes...)
+				switch mutation {
+				case "rotate extension role":
+					changed.ZCase = "Zevex_i_rm_vo"
+				case "signed EVEX":
+					changed.Classes[0] = "Yi8"
+				case "word broadcast":
+					changed.OpBytes[changed.EncodingOffset+1] += " | evexBcstN4"
+				case "tuple":
+					changed.OpBytes[changed.EncodingOffset+1] = strings.Replace(changed.OpBytes[changed.EncodingOffset+1], "evexN16", "evexN8", 1)
+				case "SAE":
+					changed.OpBytes[changed.EncodingOffset+1] += " | evexSaeEnabled"
+				case "binary F3":
+					changed.OpBytes[changed.EncodingOffset] = strings.Replace(changed.OpBytes[changed.EncodingOffset], "evex66", "evexF3", 1)
+				}
+				if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("shuffle borrowed another role, memory shape or old prefix capability", mutation, changed)
+				}
+			}
+			if found != 1 {
+				t.Fatal("shuffle negative lost its exact source row", name, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_insert_extract.go b/internal/goasmrules/x86_witness_insert_extract.go
new file mode 100644
index 000000000..541806792
--- /dev/null
+++ b/internal/goasmrules/x86_witness_insert_extract.go
@@ -0,0 +1,278 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Transfer direction and tuple are independent of the vector carrier. This
+// record owns physical syntax only, never numerical inputs or native storage.
+type x86InsertExtractFormat struct {
+	width, tuple, selector int
+	insert, gp, alternate  bool
+	masked, memory         bool
+	encoding               x86PackedAVXOpcode
+}
+
+func x86InsertExtractFormatForRule(rule X86AVXRule) (x86InsertExtractFormat, error) {
+	f := x86InsertExtractFormat{selector: 7, memory: true}
+	fail := func() (x86InsertExtractFormat, error) {
+		return f, fmt.Errorf("insert/extract source, transfer and result differ from their official format")
+	}
+	if len(rule.Classes) < 3 || rule.Prefix != "Pavx" || rule.Opcode == "" {
+		return fail()
+	}
+	f.insert = strings.HasPrefix(rule.Ytab, "_yvinsert") || rule.Ytab == "_yvpinsrb"
+	f.gp = rule.Ytab == "_yvextractps" || rule.Ytab == "_yvpextrw" || rule.Ytab == "_yvpinsrb"
+	maskedCase := "Zevex_i_r_k_rm"
+	if f.insert {
+		maskedCase = "Zevex_i_rm_v_k_r"
+	}
+	f.masked = rule.ZCase == maskedCase
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	kind, plain, count := "vex", "Zvex_i_r_rm", 3
+	if f.insert {
+		plain, count = "Zvex_i_rm_v_r", 4
+	}
+	if evex {
+		kind, plain = "evex", strings.Replace(plain, "Zvex_", "Zevex_", 1)
+	}
+	if f.masked {
+		count++
+	}
+	if rule.Classes[0] == "Yi8" && !evex && !f.insert {
+		f.selector = -1
+	} else if rule.Classes[0] != "Yu8" {
+		return fail()
+	}
+	f.alternate = rule.Ytab == "_yvpextrw" && rule.Classes[len(rule.Classes)-1] == "Yrl"
+	if f.alternate {
+		plain = strings.Replace(plain, "_i_r_rm", "_i_rm_r", 1)
+		f.memory = false
+	}
+	if len(rule.Classes) != count || rule.ZCase != plain && !f.masked ||
+		f.masked && rule.Classes[count-2] != "Yknot0" {
+		return fail()
+	}
+	vector := 1
+	if f.insert {
+		vector = 2
+	}
+	f.width = map[string]int{"Yxr": 128, "YxrEvex": 128, "Yyr": 256, "YyrEvex": 256, "Yzr": 512}[rule.Classes[vector]]
+	register := map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[f.width]
+	if evex && f.width != 512 {
+		register += "Evex"
+	}
+	if f.width == 0 || rule.Classes[vector] != register || f.insert && rule.Classes[count-1] != register {
+		return fail()
+	}
+	index, offset, stride, extent := 0, 0, 2, 2
+	block, wide := false, false
+	switch rule.Ytab {
+	case "_yvextractf128", "_yvinsertf128":
+		f.tuple, block = 16, true
+		if evex || f.width != 256 {
+			return fail()
+		}
+		if !f.insert {
+			stride = 0
+			if f.selector < 0 {
+				index, stride = 1, 2
+			}
+		}
+	case "_yvextractf32x4", "_yvinsertf32x4", "_yvextractf32x8", "_yvinsertf32x8":
+		f.tuple, block, extent = 16, true, 6
+		wide = strings.HasSuffix(rule.Ytab, "x8")
+		if wide {
+			f.tuple, extent = 32, 3
+		}
+		if !evex || f.width != 256 && f.width != 512 || wide && f.width != 512 {
+			return fail()
+		}
+		if !wide {
+			index, offset = (f.width/256-1)*2, (f.width/256-1)*3
+		}
+		stride = 0
+		if f.masked {
+			index, stride = index+1, 3
+		}
+	case "_yvextractps", "_yvpextrw", "_yvinsertps", "_yvpinsrb":
+		f.tuple, extent = 4, 5
+		if f.gp && rule.Opcode != "VEXTRACTPS" {
+			f.tuple = map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[rule.Opcode[len(rule.Opcode)-1]]
+		}
+		if f.width != 128 || f.masked || f.tuple == 0 {
+			return fail()
+		}
+		if !f.insert {
+			stride = 0
+			if f.selector < 0 {
+				index, stride = 1, 2
+			}
+		}
+		if evex {
+			index, offset, stride = 2, 2, 3
+			if f.insert {
+				index = 1
+			}
+		}
+		if rule.Ytab == "_yvpextrw" {
+			extent = 10
+			if f.alternate {
+				index, offset = index+2, 2
+			}
+			if evex {
+				index, offset = 4, 4
+				if f.alternate {
+					index, offset = 5, 7
+				}
+			}
+		}
+	default:
+		return fail()
+	}
+	transfer := "Yml"
+	if !f.gp {
+		transfer = "Yxm"
+		if f.tuple == 32 {
+			transfer = "Yym"
+		}
+		if evex {
+			transfer += "Evex"
+		}
+	} else if f.alternate {
+		transfer = "Yrl"
+	}
+	transferIndex := count - 1
+	if f.insert {
+		transferIndex = 1
+	}
+	if rule.Classes[transferIndex] != transfer || rule.RowIndex != index || rule.EncodingOffset != offset ||
+		rule.ZOffset != stride || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	w, opcodeMap, mapByte := "W0", "0F3A", byte(3)
+	if strings.HasSuffix(rule.Opcode, "Q") || strings.Contains(rule.Opcode, "64X") {
+		w = "W1"
+	}
+	// Word insertion uses the older 0F transport, independently of its
+	// r/m-to-vvvv/result roles. Alternate word extraction shares that map.
+	if f.alternate || f.insert && f.gp && f.tuple == 2 {
+		opcodeMap, mapByte = "0F", 1
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", kind + strconv.Itoa(f.width), kind + "66", kind + opcodeMap, kind + w,
+	}, nil); err != nil {
+		return fail()
+	}
+	opcodeOffset := offset + 1
+	if evex {
+		features := []string{"evexN" + strconv.Itoa(f.tuple)}
+		if block {
+			features = append(features, "evexZeroingEnabled")
+		}
+		if f.alternate {
+			features = []string{"0"} // Register-only 0F/C5 has no memory tuple.
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], features, nil); err != nil {
+			return fail()
+		}
+		opcodeOffset++
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[opcodeOffset], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: kind, mapByte: mapByte, pp: 1, length: byte(f.width / 256), opcode: byte(opcode)}
+	if w == "W1" {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func x86InsertExtractRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86InsertExtractFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	bank, base := 0, 1
+	if f.encoding.kind == "evex" {
+		bank, base = 16, 17
+	}
+	vector := func(bytes, index int) string {
+		return fmt.Sprint(map[int]string{16: "X", 32: "Y", 64: "Z"}[bytes], index)
+	}
+	transferBytes := f.tuple
+	if transferBytes < 16 {
+		transferBytes = 16
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, memory := range []bool{false, true} {
+		if memory && !f.memory {
+			continue
+		}
+		for _, zeroing := range []bool{false, true} {
+			// Memory .Z extraction is retained as a separate source/ISA
+			// observation, never silently presented as an ordinary store.
+			if zeroing && (!f.masked || memory && !f.insert) {
+				continue
+			}
+			first, second, last := vector(f.width/8, bank), "", vector(transferBytes, bank+2)
+			reg, rm, vvvv, p2 := bank, bank+2, byte(0x78), f.encoding.length<<5|8
+			if f.gp {
+				last, rm = "CX", 1
+			}
+			if f.insert {
+				first, second, last = vector(transferBytes, bank), vector(f.width/8, base), vector(f.width/8, bank+2)
+				reg, rm, vvvv = bank+2, bank, byte((^base&15)<<3)
+				if f.gp {
+					first, rm = "CX", 1
+				}
+				if base&16 != 0 {
+					p2 &^= 8
+				}
+			} else if f.alternate {
+				reg, rm = rm, reg
+			}
+			modrm := byte(0xc0 | (reg&7)<<3 | rm&7)
+			if memory {
+				rm, modrm = 0, byte((reg&7)<<3)
+				if f.insert {
+					first = "(AX)"
+				} else {
+					last = "(AX)"
+				}
+			}
+			p0 := byte(0)
+			for _, extension := range []struct{ bit, mask int }{{8, 0x80}, {16, 0x10}} {
+				if reg&extension.bit == 0 {
+					p0 |= byte(extension.mask)
+				}
+			}
+			if rm&8 == 0 {
+				p0 |= 0x20
+			}
+			if rm&16 == 0 {
+				p0 |= 0x40
+			}
+			operands, suffix := fmt.Sprintf("$%d,%s", f.selector, first), ""
+			if f.insert {
+				operands += "," + second
+			}
+			if f.masked {
+				operands, p2 = operands+",K1", p2|1
+			}
+			if zeroing {
+				suffix, p2 = ".Z", p2|0x80
+			}
+			encoding := append(f.encoding.bytes(vvvv, p0, p2, modrm), byte(f.selector))
+			witnesses = append(witnesses, X86PackedBinaryWitness{
+				Instruction: rule.Opcode + suffix + " " + operands + "," + last, Generation: f.encoding.kind,
+				First: first, Second: second, Destination: last, Width: f.width,
+				Memory: f.insert && memory, Masked: f.masked, Zeroing: zeroing, Encoding: encoding,
+			})
+		}
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_insert_extract_test.go b/internal/goasmrules/x86_witness_insert_extract_test.go
new file mode 100644
index 000000000..6cb219626
--- /dev/null
+++ b/internal/goasmrules/x86_witness_insert_extract_test.go
@@ -0,0 +1,152 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Source rows include alternate encodings shadowed by an earlier matching Go
+// row. Their physical witnesses do not imply that named source selects them.
+func TestX86InsertExtractCompleteOfficialSourceAndExistingWitnesses(t *testing.T) {
+	expected := map[string]int{
+		"VEXTRACTF128": 2, "VEXTRACTI128": 2,
+		"VEXTRACTF32X4": 4, "VEXTRACTF64X2": 4,
+		"VEXTRACTI32X4": 4, "VEXTRACTI64X2": 4,
+		"VEXTRACTF32X8": 2, "VEXTRACTF64X4": 2,
+		"VEXTRACTI32X8": 2, "VEXTRACTI64X4": 2,
+		"VEXTRACTPS": 3, "VPEXTRB": 3, "VPEXTRD": 3,
+		"VPEXTRQ": 3, "VPEXTRW": 6,
+		"VINSERTF128": 1, "VINSERTI128": 1,
+		"VINSERTF32X4": 4, "VINSERTF64X2": 4,
+		"VINSERTI32X4": 4, "VINSERTI64X2": 4,
+		"VINSERTF32X8": 2, "VINSERTF64X4": 2,
+		"VINSERTI32X8": 2, "VINSERTI64X4": 2,
+		"VINSERTPS": 2, "VPINSRB": 2, "VPINSRD": 2,
+		"VPINSRQ": 2, "VPINSRW": 2,
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	members, tables, originals := map[string]int{}, map[string]bool{}, map[string]X86AVXRule{}
+	var order []string
+	for index, rule := range avx {
+		if _, found := expected[rule.Opcode]; !found {
+			continue
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)
+		if _, duplicate := originals[id]; duplicate {
+			t.Fatal("duplicate original source row", id)
+		}
+		originals[id], tables[rule.Ytab] = rule, true
+		order = append(order, id)
+		members[rule.Opcode]++
+	}
+	if len(originals) != 82 || len(members) != 30 || len(tables) != 10 {
+		t.Fatal("complete insert/extract source closure changed", len(originals), len(members), len(tables))
+	}
+	for name, want := range expected {
+		if members[name] != want {
+			t.Fatal("original member rows changed", name, members[name], want)
+		}
+	}
+	// First RED must reach the existing shared witness grammar. It must not
+	// depend on a missing future family API or an invented encoder stub.
+	physical := 0
+	for _, id := range order {
+		original := originals[id]
+		t.Run(id, func(t *testing.T) {
+			witnesses, err := x86PackedAVXRowWitnesses(original)
+			if err != nil {
+				t.Fatal("complete official physical row lacks an existing witness path", err)
+			}
+			if len(witnesses) == 0 {
+				t.Fatal("empty physical row cannot establish a witness", id)
+			}
+			for _, witness := range witnesses {
+				if len(witness.Encoding) == 0 || witness.MaskResult || witness.Broadcast {
+					t.Fatal("insert/extract acquired an unowned encoding or source/result kind", id, witness)
+				}
+			}
+			physical += len(witnesses)
+		})
+	}
+	if physical != 197 {
+		t.Fatal("complete physical projection changed, not a named-source pass count", physical)
+	}
+}
+
+func TestX86InsertExtractRejectsForeignPhysicalAxes(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, original := range avx {
+		if !strings.HasPrefix(original.Ytab, "_yvextract") && !strings.HasPrefix(original.Ytab, "_yvinsert") &&
+			original.Ytab != "_yvpextrw" && original.Ytab != "_yvpinsrb" {
+			continue
+		}
+		if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+			t.Fatal("negative control has no valid original", original, err)
+		}
+		for _, axis := range []string{"prefix", "table", "ordinal", "offset", "stride", "immediate", "source", "destination", "mask", "zcase", "header", "W", "tuple", "extent"} {
+			t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, original.RowIndex, axis), func(t *testing.T) {
+				changed := original
+				changed.Classes = append([]string(nil), original.Classes...)
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				switch axis {
+				case "prefix":
+					changed.Prefix = "Pm"
+				case "table":
+					changed.Ytab = "_foreign_insert_extract"
+				case "ordinal":
+					changed.RowIndex += 1000
+				case "offset":
+					changed.EncodingOffset++
+				case "stride":
+					changed.ZOffset++
+				case "immediate":
+					changed.Classes[0] = "Yi32"
+				case "source":
+					changed.Classes[1] = "Yk"
+				case "destination":
+					changed.Classes[len(changed.Classes)-1] = "Yk"
+				case "mask":
+					found := false
+					for index, class := range changed.Classes {
+						if class == "Yknot0" {
+							changed.Classes[index], found = "Yk0", true
+						}
+					}
+					if !found {
+						changed.Classes = append(changed.Classes, "Yk0")
+					}
+				case "zcase":
+					changed.ZCase = "Zevex_rm_v_r"
+				case "header":
+					changed.OpBytes[changed.EncodingOffset] += "|foreignTransferAxis"
+				case "W":
+					from, to := "W0", "W1"
+					if strings.Contains(changed.OpBytes[changed.EncodingOffset], "W1") {
+						from, to = to, from
+					}
+					changed.OpBytes[changed.EncodingOffset] = strings.Replace(changed.OpBytes[changed.EncodingOffset], from, to, 1)
+				case "tuple":
+					changed.OpBytes[changed.EncodingOffset+1] = "evexN64"
+				case "extent":
+					changed.OpBytes = append(changed.OpBytes, "0")
+				}
+				if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("foreign physical metadata was accepted", original, axis)
+				}
+			})
+		}
+		count++
+	}
+	if count != 82 {
+		t.Fatal("negative controls lost an original row", count)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_integer_compare_test.go b/internal/goasmrules/x86_witness_integer_compare_test.go
new file mode 100644
index 000000000..0ecebdeb7
--- /dev/null
+++ b/internal/goasmrules/x86_witness_integer_compare_test.go
@@ -0,0 +1,78 @@
+package goasmrules
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86PackedIntegerCompareRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedIntegerCompareRows,
+		`^V?PCMP(EQ|GT)[BWLQD]$`, `^VPCMP(EQ|GT)[DQ]$`, x86PackedRowCounts{
+			names: 16, mmx: 6, broadcast: 24,
+			rows: [3]int{8, 16, 48}, formats: [3]int{16, 32, 120}, widths: [3]int{72, 56, 40},
+		})
+	maskResults := 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if witness.Generation == "evex" {
+				if witness.Destination != "K2" || witness.Zeroing {
+					t.Fatal("EVEX compare acquired a vector result or merging/zeroing suffix", witness)
+				}
+				maskResults++
+			} else if strings.HasPrefix(witness.Destination, "K") {
+				t.Fatal("legacy/VEX compare lost its vector result", witness)
+			}
+		}
+	}
+	if maskResults != 120 {
+		t.Fatal("incomplete independent K-result format inventory", maskResults)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PCMPEQB X0,X1", []byte{0x66, 0x0f, 0x74, 0xc8}},
+		{"PCMPEQW (AX),X1", []byte{0x66, 0x0f, 0x75, 0x08}},
+		{"PCMPEQL X0,X1", []byte{0x66, 0x0f, 0x76, 0xc8}},
+		{"PCMPEQQ (AX),X1", []byte{0x66, 0x0f, 0x38, 0x29, 0x08}},
+		{"PCMPGTB X0,X1", []byte{0x66, 0x0f, 0x64, 0xc8}},
+		{"PCMPGTW (AX),X1", []byte{0x66, 0x0f, 0x65, 0x08}},
+		{"PCMPGTL X0,X1", []byte{0x66, 0x0f, 0x66, 0xc8}},
+		{"PCMPGTQ (AX),X1", []byte{0x66, 0x0f, 0x38, 0x37, 0x08}},
+		{"VPCMPEQD X0,X1,X2", []byte{0xc5, 0xf1, 0x76, 0xd0}},
+		{"VPCMPGTQ Y0,Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x37, 0xd0}},
+		{"VPCMPEQB X16,X17,K2", []byte{0x62, 0xb1, 0x75, 0x00, 0x74, 0xd0}},
+		{"VPCMPEQW (AX),Y17,K1,K2", []byte{0x62, 0xf1, 0x75, 0x21, 0x75, 0x10}},
+		{"VPCMPEQD.BCST (AX),Z17,K2", []byte{0x62, 0xf1, 0x75, 0x50, 0x76, 0x10}},
+		{"VPCMPEQQ.BCST (AX),Z17,K1,K2", []byte{0x62, 0xf2, 0xf5, 0x51, 0x29, 0x10}},
+		{"VPCMPGTB Y16,Y17,K2", []byte{0x62, 0xb1, 0x75, 0x20, 0x64, 0xd0}},
+		{"VPCMPGTW Z16,Z17,K1,K2", []byte{0x62, 0xb1, 0x75, 0x41, 0x65, 0xd0}},
+		{"VPCMPGTD X16,X17,K1,K2", []byte{0x62, 0xb1, 0x75, 0x01, 0x66, 0xd0}},
+		{"VPCMPGTQ Z16,Z17,K2", []byte{0x62, 0xb2, 0xf5, 0x40, 0x37, 0xd0}},
+	})
+}
+
+func TestX86PackedIntegerCompareRejectsUnknownResultAxes(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mutate func(*X86AVXRule)
+	}{
+		{"unrelated table", func(r *X86AVXRule) { r.Ytab = "_yvandnpd" }},
+		{"vector result", func(r *X86AVXRule) { r.Classes[2] = "YxrEvex" }},
+		{"general purpose result", func(r *X86AVXRule) { r.Classes[2] = "Yrl" }},
+		{"zeroing", func(r *X86AVXRule) { r.OpBytes[1] += " | evexZeroingEnabled" }},
+		{"rounding", func(r *X86AVXRule) { r.OpBytes[1] += " | evexRoundingEnabled" }},
+		{"SAE", func(r *X86AVXRule) { r.OpBytes[1] += " | evexSaeEnabled" }},
+		{"offset", func(r *X86AVXRule) { r.ZOffset = 3 }},
+		{"width", func(r *X86AVXRule) { r.OpBytes[0] = "avxEscape | evex256 | evex66 | evex0F | evexW0" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			rule := X86AVXRule{
+				Opcode: "VPCMPEQD", Ytab: "_yvpcmpeqb", Prefix: "Pavx",
+				Classes: []string{"YxmEvex", "YxrEvex", "Yk"}, ZCase: "Zevex_rm_v_r",
+				OpBytes: []string{"avxEscape | evex128 | evex66 | evex0F | evexW0", "evexN16 | evexBcstN4", "0x76"},
+			}
+			test.mutate(&rule)
+			if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+				t.Fatal("unknown compare result axis was silently accepted", witnesses, err)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_integer_mask_result.go b/internal/goasmrules/x86_witness_integer_mask_result.go
new file mode 100644
index 000000000..674fac525
--- /dev/null
+++ b/internal/goasmrules/x86_witness_integer_mask_result.go
@@ -0,0 +1,113 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Vector input width/tuple and K result/writemask are independent roles.
+// Matching this physical format grants no input, memory or numeric authority.
+type x86IntegerMaskResultFormat struct {
+	width, broadcast  int
+	masked, immediate bool
+	encoding          x86PackedAVXOpcode
+}
+
+func x86IntegerMaskResultFormatForRule(rule X86AVXRule) (x86IntegerMaskResultFormat, error) {
+	f := x86IntegerMaskResultFormat{immediate: rule.Ytab == "_yvpcmpb"}
+	fail := func() (x86IntegerMaskResultFormat, error) {
+		return f, fmt.Errorf("integer mask-result input/tuple/K roles differ from their official format")
+	}
+	first, plain, masked := 0, "Zevex_rm_v_r", "Zevex_rm_v_k_r"
+	if f.immediate {
+		first, plain, masked = 1, "Zevex_i_rm_v_r", "Zevex_i_rm_v_k_r"
+	}
+	f.masked = rule.ZCase == masked
+	count := first + 3
+	if f.masked {
+		count++
+	}
+	if rule.Ytab != "_yvpcmpb" && rule.Ytab != "_yvpshufbitqmb" || rule.Prefix != "Pavx" || rule.ZCase != plain && !f.masked ||
+		len(rule.Classes) != count || f.immediate && rule.Classes[0] != "Yu8" || rule.Classes[count-1] != "Yk" ||
+		f.masked && rule.Classes[first+2] != "Yknot0" {
+		return fail()
+	}
+	f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[rule.Classes[first]]
+	second := map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	member, valid := strings.CutPrefix(rule.Opcode, "VPCMP")
+	member = strings.TrimPrefix(member, "U")
+	pp, opcodeMap, mapByte := "66", "0F3A", byte(3)
+	if !f.immediate {
+		member, valid = strings.CutPrefix(rule.Opcode, "VPTESTM")
+		if !valid {
+			member, valid = strings.CutPrefix(rule.Opcode, "VPTESTNM")
+			pp = "F3"
+		}
+		opcodeMap, mapByte = "0F38", 2
+	}
+	if !valid || len(member) != 1 || f.width == 0 || rule.Classes[first+1] != second {
+		return fail()
+	}
+	bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[member[0]]
+	if bits == 0 {
+		return fail()
+	}
+	widthIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width]
+	maskIndex := 0
+	if f.masked {
+		maskIndex = 1
+	}
+	if rule.RowIndex != widthIndex*2+maskIndex || rule.ZOffset != maskIndex*3 ||
+		rule.EncodingOffset != widthIndex*3 || len(rule.OpBytes) != 9 {
+		return fail()
+	}
+	w := "W0"
+	if bits == 16 || bits == 64 {
+		w = "W1"
+	}
+	offset := rule.EncodingOffset
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", "evex" + strconv.Itoa(f.width), "evex" + pp, "evex" + opcodeMap, "evex" + w,
+	}, nil); err != nil {
+		return fail()
+	}
+	required := []string{"evexN" + strconv.Itoa(f.width/8)}
+	if bits >= 32 {
+		f.broadcast = bits / 8
+		required = append(required, "evexBcstN"+strconv.Itoa(f.broadcast))
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], required, nil); err != nil {
+		return fail()
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+2], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	if !f.immediate {
+		want := uint64(0x26)
+		if bits >= 32 {
+			want++
+		}
+		if opcode != want {
+			return fail() // The shared ytab also has a distinct VPSHUFBITQMB opcode.
+		}
+	}
+	f.encoding = x86PackedAVXOpcode{kind: "evex", mapByte: mapByte, pp: 1, length: byte(widthIndex), opcode: byte(opcode)}
+	if pp == "F3" {
+		f.encoding.pp = 2
+	}
+	if w == "W1" {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func x86IntegerMaskResultRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86IntegerMaskResultFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	physical := x86VectorResultFormat{width: f.width, masked: f.masked, broadcast: f.broadcast != 0, maskResult: true, encoding: f.encoding}
+	return physical.witnessesWithControl(rule.Opcode, f.immediate, 7), nil
+}
diff --git a/internal/goasmrules/x86_witness_integer_test_mask_test.go b/internal/goasmrules/x86_witness_integer_test_mask_test.go
new file mode 100644
index 000000000..cafd3e209
--- /dev/null
+++ b/internal/goasmrules/x86_witness_integer_test_mask_test.go
@@ -0,0 +1,182 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86IntegerTestMaskTestMembers = `VPTESTMB VPTESTMW VPTESTMD VPTESTMQ
+	VPTESTNMB VPTESTNMW VPTESTNMD VPTESTNMQ`
+
+func TestX86IntegerTestMaskCompleteOfficialTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Existing entry point: the initial RED must be an actual unsupported
+	// format, not a test compiled against a future public family selector.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86IntegerTestMaskTestMembers)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 48 {
+		t.Fatal("lost a VPTESTM/NM row or included VPSHUFBITQMB/legacy PTEST", len(rows))
+	}
+	for _, name := range strings.Fields(x86IntegerTestMaskTestMembers) {
+		letter := name[len(name)-1]
+		lane := map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[letter]
+		pp, w, opcode := "66", "W0", 0x26
+		if strings.HasPrefix(name, "VPTESTNM") {
+			pp = "F3"
+		}
+		if letter == 'W' || letter == 'Q' {
+			w = "W1"
+		}
+		if lane >= 4 {
+			opcode = 0x27
+		}
+		var payload []string
+		for _, width := range []int{128, 256, 512} {
+			feature := fmt.Sprintf("evexN%d", width/8)
+			if lane >= 4 {
+				feature += fmt.Sprintf(" | evexBcstN%d", lane)
+			}
+			payload = append(payload, fmt.Sprintf("avxEscape | evex%d | evex%s | evex0F38 | evex%s", width, pp, w),
+				feature, fmt.Sprintf("0x%02X", opcode))
+		}
+		count := 0
+		for _, rule := range avx {
+			if rule.Opcode != name {
+				continue
+			}
+			if count >= 6 {
+				t.Fatal("extra original member row", name, rule)
+			}
+			classes := [][]string{{"YxmEvex", "YxrEvex"}, {"YymEvex", "YyrEvex"}, {"Yzm", "Yzr"}}[count/2]
+			zcase := "Zevex_rm_v_r"
+			if count%2 != 0 {
+				classes, zcase = append(classes, "Yknot0"), "Zevex_rm_v_k_r"
+			}
+			classes = append(classes, "Yk") // K0 is a legal result; it is not a write mask.
+			if rule.Ytab != "_yvpshufbitqmb" || rule.Prefix != "Pavx" || rule.RowIndex != count ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*3 || rule.EncodingOffset != count/2*3 ||
+				!reflect.DeepEqual(rule.Classes, classes) || !reflect.DeepEqual(rule.OpBytes, payload) {
+				t.Fatal("source width, memory tuple, polarity or K roles changed", name, rule)
+			}
+			count++
+		}
+		if count != 6 {
+			t.Fatal("member lost its complete official table", name, count)
+		}
+	}
+	widths, destinations := map[int]int{}, map[string]int{}
+	memory, masked, broadcast, witnesses := 0, 0, 0, 0
+	for _, row := range rows {
+		for _, witness := range row.Witnesses {
+			if witness.Generation != "evex" || !witness.MaskResult || witness.Zeroing ||
+				witness.Destination != "K0" && witness.Destination != "K2" ||
+				!strings.HasSuffix(witness.Second, "17") || witness.Memory != (witness.First == "(AX)") {
+				t.Fatal("vector source, optional write mask and result K were conflated", row.ID, witness)
+			}
+			if witness.Memory {
+				memory++
+			}
+			if witness.Masked {
+				masked++
+				if witness.Broadcast {
+					// Input K1 and result K2 remain independent at every tuple.
+					if !strings.Contains(witness.Instruction, ",K1,"+witness.Destination) {
+						t.Fatal("a write mask acquired the destination role", witness)
+					}
+				}
+			}
+			if witness.Broadcast {
+				broadcast++
+			}
+			widths[witness.Width]++
+			destinations[witness.Destination]++
+			witnesses++
+		}
+	}
+	if witnesses != 240 || memory != 144 || masked != 120 || broadcast != 48 ||
+		!reflect.DeepEqual(widths, map[int]int{128: 80, 256: 80, 512: 80}) ||
+		!reflect.DeepEqual(destinations, map[string]int{"K0": 120, "K2": 120}) {
+		t.Fatal("complete eight-member projection changed", witnesses, memory, masked, broadcast, widths, destinations)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VPTESTMB X16,X17,K2", []byte{0x62, 0xb2, 0x75, 0x00, 0x26, 0xd0}},
+		{"VPTESTNMW (AX),Y17,K1,K2", []byte{0x62, 0xf2, 0xf6, 0x21, 0x26, 0x10}},
+		{"VPTESTMD.BCST (AX),Z17,K2", []byte{0x62, 0xf2, 0x75, 0x50, 0x27, 0x10}},
+		{"VPTESTNMQ.BCST (AX),Z17,K1,K2", []byte{0x62, 0xf2, 0xf6, 0x51, 0x27, 0x10}},
+		{"VPTESTMQ Y16,Y17,K0", []byte{0x62, 0xb2, 0xf5, 0x20, 0x27, 0xc0}},
+		{"VPTESTNMD.BCST (AX),X17,K1,K0", []byte{0x62, 0xf2, 0x76, 0x11, 0x27, 0x00}},
+	})
+}
+
+func TestX86IntegerTestMaskTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"source width", "vector result", "K0 input mask", "exclude K0 result", "tuple", "BCST tuple", "W", "polarity", "zeroing", "SAE", "rounding", "opcode", "row stride", "byte broadcast"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, rowIndex := "VPTESTNMQ", 5
+			if mutation == "byte broadcast" {
+				name, rowIndex = "VPTESTMB", 1
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != rowIndex {
+					continue
+				}
+				found++
+				rule := original
+				rule.Classes, rule.OpBytes = append([]string(nil), original.Classes...), append([]string(nil), original.OpBytes...)
+				header, feature := rule.EncodingOffset, rule.EncodingOffset+1
+				switch mutation {
+				case "source width":
+					rule.Classes[0] = "YxmEvex"
+				case "vector result":
+					rule.Classes[3] = "Yzr"
+				case "K0 input mask":
+					rule.Classes[2] = "Yk"
+				case "exclude K0 result":
+					rule.Classes[3] = "Yknot0"
+				case "tuple":
+					rule.OpBytes[feature] = strings.Replace(rule.OpBytes[feature], "evexN64", "evexN8", 1)
+				case "BCST tuple":
+					rule.OpBytes[feature] = strings.Replace(rule.OpBytes[feature], "evexBcstN8", "evexBcstN4", 1)
+				case "W":
+					rule.OpBytes[header] = strings.Replace(rule.OpBytes[header], "evexW1", "evexW0", 1)
+				case "polarity":
+					rule.OpBytes[header] = strings.Replace(rule.OpBytes[header], "evexF3", "evex66", 1)
+				case "zeroing":
+					rule.OpBytes[feature] += " | evexZeroingEnabled"
+				case "SAE":
+					rule.OpBytes[feature] += " | evexSaeEnabled"
+				case "rounding":
+					rule.OpBytes[feature] += " | evexRoundingEnabled"
+				case "opcode":
+					rule.OpBytes[header+2] = "0x8F"
+				case "row stride":
+					rule.ZOffset = 1
+				case "byte broadcast":
+					rule.OpBytes[feature] += " | evexBcstN4"
+				}
+				if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+					t.Fatal("foreign test-to-mask axis was admitted", mutation, witnesses, err)
+				}
+			}
+			if found != 1 {
+				t.Fatal("independent original mutation row missing", found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_inventory_test.go b/internal/goasmrules/x86_witness_inventory_test.go
new file mode 100644
index 000000000..da02fdb5f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_inventory_test.go
@@ -0,0 +1,133 @@
+package goasmrules
+
+import (
+	"bytes"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86PackedRowCounts struct {
+	names, mmx, broadcast int
+	rows, formats         [3]int // Legacy, VEX, EVEX.
+	widths                [3]int // 128, 256, 512 bits.
+}
+
+type x86PackedEncodingAnchor struct {
+	instruction string
+	encoding    []byte
+}
+
+func x86CheckPackedEncodingAnchors(t *testing.T, rows []X86PackedBinaryRow, anchors []x86PackedEncodingAnchor) {
+	t.Helper()
+	observed := map[string][]byte{}
+	for _, row := range rows {
+		for _, witness := range row.Witnesses {
+			if _, exists := observed[witness.Instruction]; exists {
+				t.Fatal("distinct official rows lost their physical witness identity", witness.Instruction)
+			}
+			observed[witness.Instruction] = witness.Encoding
+		}
+	}
+	for _, row := range anchors {
+		t.Run(row.instruction, func(t *testing.T) {
+			if got := observed[row.instruction]; !bytes.Equal(got, row.encoding) {
+				t.Fatalf("official encoding is %x, want %x", got, row.encoding)
+			}
+		})
+	}
+}
+
+type x86PackedRowInventory struct {
+	rows   []X86PackedBinaryRow
+	legacy X86LegacyCatalog
+	avx    []X86AVXRule
+	names  map[string]bool
+}
+
+// Both the family membership and expected counts are independent test data.
+// The complete official catalogs, not the translator registry, own the rows.
+func x86CheckPackedRowInventory(t *testing.T,
+	build func(X86LegacyCatalog, []X86AVXRule) ([]X86PackedBinaryRow, error),
+	member, broadcast string, want x86PackedRowCounts) x86PackedRowInventory {
+	t.Helper()
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := build(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	family, allowedBroadcast := regexp.MustCompile(member), regexp.MustCompile(broadcast)
+	ids, names := map[string]bool{}, map[string]bool{}
+	generation := map[string]int{"legacy": 0, "vex": 1, "evex": 2}
+	width := map[int]int{128: 0, 256: 1, 512: 2}
+	var got x86PackedRowCounts
+	for _, row := range rows {
+		if row.ID == "" || ids[row.ID] || len(row.Witnesses) < 2 || !family.MatchString(row.Opcode) {
+			t.Fatal("lost original row, family or register/memory witness", row.ID, row.Opcode)
+		}
+		ids[row.ID], names[row.Opcode] = true, true
+		kind := row.Witnesses[0].Generation
+		g, valid := generation[kind]
+		if !valid || strings.HasPrefix(row.ID, "optab/") != (kind == "legacy") {
+			t.Fatal("original row and encoding generation disagree", row.ID, kind)
+		}
+		got.rows[g]++
+		for _, witness := range row.Witnesses {
+			w, valid := width[witness.Width]
+			// Legacy PS rows without a mandatory prefix are three bytes.
+			if !valid || witness.Generation != kind || witness.Instruction == "" || len(witness.Encoding) < 3 {
+				t.Fatal("incomplete or inconsistent original encoding witness", row.ID, witness)
+			}
+			got.formats[g]++
+			got.widths[w]++
+			if witness.MaskResult != strings.HasPrefix(witness.Destination, "K") {
+				t.Fatal("official result class differs from its witness", row.ID)
+			}
+			destination := strings.HasSuffix(witness.Destination, "18")
+			if witness.MaskResult {
+				destination = witness.Destination == "K2"
+			}
+			if kind == "evex" && (witness.Encoding[0] != 0x62 ||
+				(witness.Second != "" && !strings.HasSuffix(witness.Second, "17")) || !destination) {
+				t.Fatal("official EVEX identity can fall back to VEX", row.ID)
+			}
+			if witness.Broadcast {
+				got.broadcast++
+				if kind != "evex" || !witness.Memory || !allowedBroadcast.MatchString(row.Opcode) {
+					t.Fatal("broadcast escaped the independent family contract", row.ID)
+				}
+			}
+		}
+	}
+	check := func(name string) {
+		if family.MatchString(name) && !names[name] {
+			t.Fatal("official family member omitted", name)
+		}
+	}
+	for _, entry := range legacy.Optab {
+		check(entry.Opcode)
+		for _, row := range entry.Rows {
+			if names[entry.Opcode] && strings.Join(row.Classes, ",") == "Ymm,Ymr" {
+				got.mmx++
+			}
+		}
+	}
+	for _, row := range avx {
+		check(row.Opcode)
+	}
+	got.names = len(names)
+	if got != want {
+		t.Fatalf("official family inventory drift:\n got %+v\nwant %+v", got, want)
+	}
+	t.Logf("%s: original rows %v, format expectations %v; %d MMX rows separate, no translation/runtime claim",
+		runtime.Version(), got.rows, got.formats, got.mmx)
+	return x86PackedRowInventory{rows: rows, legacy: legacy, avx: avx, names: names}
+}
diff --git a/internal/goasmrules/x86_witness_k_data.go b/internal/goasmrules/x86_witness_k_data.go
new file mode 100644
index 000000000..23b9b0fa9
--- /dev/null
+++ b/internal/goasmrules/x86_witness_k_data.go
@@ -0,0 +1,197 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// These are source semantic families, not opcode values or ISA permissions.
+// K-data widths and encoded vector length are deliberately independent.
+func x86KDataTable(name string) string {
+	if len(name) == 8 && strings.HasPrefix(name, "VPMOVM2") && strings.ContainsRune("BWDQ", rune(name[7])) {
+		return "_yvpbroadcastmb2q"
+	}
+	if len(name) == 8 && strings.HasPrefix(name, "VPMOV") && strings.HasSuffix(name, "2M") && strings.ContainsRune("BWDQ", rune(name[5])) {
+		return "_yvpmovb2m"
+	}
+	if len(name) == 8 && strings.HasPrefix(name, "KUNPCK") {
+		first, last := strings.IndexByte("BWDQ", name[6]), strings.IndexByte("BWDQ", name[7])
+		if first >= 0 && last == first+1 {
+			return "_ykaddb"
+		}
+	}
+	if len(name) < 2 || !strings.ContainsRune("BWDQ", rune(name[len(name)-1])) {
+		return ""
+	}
+	switch name[:len(name)-1] {
+	case "KADD", "KAND", "KANDN", "KOR", "KXNOR", "KXOR":
+		return "_ykaddb"
+	case "KNOT", "KTEST", "KORTEST":
+		return "_yknotb"
+	case "KMOV":
+		return "_ykmovb"
+	case "KSHIFTL", "KSHIFTR":
+		return "_ykshiftlb"
+	}
+	return ""
+}
+
+func X86KDataRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	seen := map[string]bool{}
+	var names []string
+	for _, rule := range avx {
+		if x86KDataTable(rule.Opcode) != "" && !seen[rule.Opcode] {
+			seen[rule.Opcode] = true
+			names = append(names, rule.Opcode)
+		}
+	}
+	rows, err := x86PackedBinaryRows(legacy, avx, strings.Join(names, " "))
+	if err == nil && (len(names) != 59 || len(rows) != 87) {
+		err = fmt.Errorf("incomplete K-data source closure: names=%d rows=%d", len(names), len(rows))
+	}
+	return rows, err
+}
+
+func x86KDataRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	fail := func() ([]X86PackedBinaryWitness, error) {
+		return nil, fmt.Errorf("K-data roles, width, prefix or ordered source payload changed")
+	}
+	table, name := rule.Ytab, rule.Opcode
+	if table == "" || table != x86KDataTable(name) || rule.Prefix != "Pavx" {
+		return fail()
+	}
+	classes, zcase, index, offset, stride, payload := "Yk,Yk", "Zvex_rm_v_r", 0, 0, 2, 2
+	kind, carrier, length, mapName, opcodeMap := "vex", 0, byte(0), "0F", byte(1)
+	lane := name[len(name)-1]
+	pp, w := byte(0), byte(0)
+	if lane == 'B' || lane == 'D' {
+		pp = 1
+	}
+	if lane == 'D' || lane == 'Q' {
+		w = 0x80
+	}
+	switch table {
+	case "_ykaddb":
+		classes, length = "Yk,Yk,Yk", 1
+		if strings.HasPrefix(name, "KUNPCK") {
+			pp, w = 0, 0
+			if name[6] == 'B' {
+				pp = 1
+			} else if name[6] == 'D' {
+				w = 0x80
+			}
+		}
+	case "_yknotb":
+	case "_ykshiftlb":
+		classes, zcase, mapName, opcodeMap, pp = "Yu8,Yk,Yk", "Zvex_i_rm_r", "0F3A", 3, 1
+		w = 0
+		if lane == 'W' || lane == 'Q' {
+			w = 0x80
+		}
+	case "_ykmovb":
+		index, payload = rule.RowIndex, 8
+		if index < 0 || index >= 4 {
+			return fail()
+		}
+		classes = []string{"Yk,Ym", "Yk,Yrl", "Ykm,Yk", "Yrl,Yk"}[index]
+		offset = index * 2
+		if index == 0 {
+			zcase = "Zvex_r_v_rm"
+		}
+		if index == 1 || index == 3 {
+			if lane == 'D' || lane == 'Q' {
+				pp, w = 3, 0
+				if lane == 'Q' {
+					w = 0x80
+				}
+			}
+		}
+	case "_yvpbroadcastmb2q", "_yvpmovb2m":
+		index = rule.RowIndex
+		if index < 0 || index >= 3 {
+			return fail()
+		}
+		kind, carrier, length = "evex", 128<<uint(index), byte(index)
+		zcase, offset, stride, payload, mapName, opcodeMap, pp = "Zevex_rm_v_r", index*3, 3, 9, "0F38", 2, 2
+		vector := []string{"YxrEvex", "YyrEvex", "Yzr"}[index]
+		classes = "Yk," + vector
+		if table == "_yvpmovb2m" {
+			classes, lane = vector+",Yk", name[5]
+		}
+		w = 0
+		if lane == 'W' || lane == 'Q' {
+			w = 0x80
+		}
+	default:
+		return fail()
+	}
+	if rule.RowIndex != index || rule.EncodingOffset != offset || rule.ZOffset != stride ||
+		rule.ZCase != zcase || strings.Join(rule.Classes, ",") != classes || len(rule.OpBytes) != payload {
+		return fail()
+	}
+	encodedLength := 128 << uint(length)
+	wName := "W0"
+	if w != 0 {
+		wName = "W1"
+	}
+	atoms := []string{"avxEscape", kind + strconv.Itoa(encodedLength), kind + mapName, kind + wName}
+	if pp != 0 {
+		atoms = append(atoms, kind+[]string{"", "66", "F3", "F2"}[pp])
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], atoms, nil); err != nil {
+		return fail()
+	}
+	if kind == "evex" && rule.OpBytes[offset+1] != "0" {
+		return fail() // Register-only data: no tuple, BCST, mask, Z or SAE.
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+stride-1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	encoding := x86PackedAVXOpcode{kind: kind, mapByte: opcodeMap, wBit: w, pp: pp, length: length, opcode: byte(opcode)}
+	type candidate struct {
+		first, second, destination, text string
+		vvvv, modrm                      byte
+		memory                           bool
+	}
+	candidates := []candidate{{first: "K0", destination: "K3", text: "K0,K3", vvvv: 0x78, modrm: 0xd8}}
+	switch table {
+	case "_ykaddb":
+		candidates[0].second, candidates[0].text, candidates[0].vvvv = "K7", "K0,K7,K3", 0x40
+	case "_yknotb":
+		if strings.Contains(name, "TEST") {
+			candidates[0].second, candidates[0].destination, candidates[0].text, candidates[0].modrm = "K7", "", "K0,K7", 0xf8
+		}
+	case "_ykshiftlb":
+		candidates[0].text = "$5,K0,K3"
+	case "_ykmovb":
+		switch index {
+		case 0:
+			candidates[0].destination, candidates[0].text, candidates[0].modrm = "0(AX)", "K0,0(AX)", 0
+		case 1:
+			candidates[0].destination, candidates[0].text = "BX", "K0,BX"
+		case 2:
+			candidates = append(candidates, candidate{first: "0(AX)", destination: "K3", text: "0(AX),K3", vvvv: 0x78, modrm: 0x18, memory: true})
+		case 3:
+			candidates[0].first, candidates[0].text = "AX", "AX,K3"
+		}
+	case "_yvpbroadcastmb2q":
+		vector := fmt.Sprintf("%c1", "XYZ"[index])
+		candidates[0].destination, candidates[0].text, candidates[0].modrm = vector, "K0,"+vector, 0xc8
+	case "_yvpmovb2m":
+		vector := fmt.Sprintf("%c1", "XYZ"[index])
+		candidates[0].first, candidates[0].text, candidates[0].modrm = vector, vector+",K3", 0xd9
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, c := range candidates {
+		code := encoding.bytes(c.vvvv, 0xf0, 0x08|length<<5, c.modrm)
+		if table == "_ykshiftlb" {
+			code = append(code, 5)
+		}
+		witnesses = append(witnesses, X86PackedBinaryWitness{Instruction: name + " " + c.text, Generation: kind,
+			First: c.first, Second: c.second, Destination: c.destination, Width: carrier,
+			Memory: c.memory, MaskResult: strings.HasPrefix(c.destination, "K"), Encoding: code})
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_k_data_test.go b/internal/goasmrules/x86_witness_k_data_test.go
new file mode 100644
index 000000000..011712e16
--- /dev/null
+++ b/internal/goasmrules/x86_witness_k_data_test.go
@@ -0,0 +1,123 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86KDataCompleteExistingRowTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const members = `KADDB KADDD KADDQ KADDW KANDB KANDD KANDNB KANDND KANDNQ KANDNW KANDQ KANDW KMOVB KMOVD KMOVQ KMOVW KNOTB KNOTD KNOTQ KNOTW KORB KORD KORQ KORTESTB KORTESTD KORTESTQ KORTESTW KORW KSHIFTLB KSHIFTLD KSHIFTLQ KSHIFTLW KSHIFTRB KSHIFTRD KSHIFTRQ KSHIFTRW KTESTB KTESTD KTESTQ KTESTW KUNPCKBW KUNPCKDQ KUNPCKWD KXNORB KXNORD KXNORQ KXNORW KXORB KXORD KXORQ KXORW VPMOVB2M VPMOVD2M VPMOVM2B VPMOVM2D VPMOVM2Q VPMOVM2W VPMOVQ2M VPMOVW2M`
+	wanted := map[string]bool{}
+	for _, name := range strings.Fields(members) {
+		wanted[name] = true
+	}
+	originals, tables := map[string]bool{}, map[string]int{}
+	oldBroadcast := 0
+	for index, row := range avx {
+		if row.Opcode == "VPBROADCASTMB2Q" || row.Opcode == "VPBROADCASTMW2D" {
+			oldBroadcast++
+		}
+		if !wanted[row.Opcode] {
+			continue
+		}
+		originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = true
+		tables[row.Ytab]++
+	}
+	expected := map[string]int{
+		"_ykaddb": 27, "_yknotb": 12, "_ykmovb": 16,
+		"_ykshiftlb": 8, "_yvpbroadcastmb2q": 12, "_yvpmovb2m": 12,
+	}
+	if len(wanted) != 59 || len(originals) != 87 || oldBroadcast != 6 || len(tables) != 6 {
+		t.Fatal("complete K-data source closure lost", len(wanted), len(originals), oldBroadcast, tables)
+	}
+	for table, count := range expected {
+		if tables[table] != count {
+			t.Fatal("complete original format group lost", table, tables[table], count)
+		}
+	}
+	// Real format RED through an existing helper, no future API symbol.
+	rows, err := x86PackedBinaryRows(legacy, avx, members)
+	if err != nil {
+		t.Fatal("complete K-data row/source-role transport", err)
+	}
+	seen := map[string]bool{}
+	formats := 0
+	for _, row := range rows {
+		if !originals[row.ID] || seen[row.ID] || len(row.Witnesses) == 0 {
+			t.Fatal("source record lost/duplicated", row)
+		}
+		seen[row.ID] = true
+		for _, w := range row.Witnesses {
+			if strings.Fields(w.Instruction)[0] != row.Opcode || w.Masked || w.Zeroing || w.Broadcast {
+				t.Fatal("K data borrowed writemasking/suffix capabilities", row, w)
+			}
+			formats++
+		}
+	}
+	if len(seen) != 87 || formats != 91 {
+		t.Fatal("source-kind canonical projection lost", len(seen), formats)
+	}
+}
+
+func TestX86KDataFormatKeepsEveryPhysicalAxis(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, original := range rules {
+		if x86KDataTable(original.Opcode) == "" {
+			continue
+		}
+		count++
+		for _, change := range []string{"prefix", "row", "offset", "stride", "class", "length", "W", "suffix", "control"} {
+			t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, original.RowIndex, change), func(t *testing.T) {
+				rule := original
+				rule.Classes = append([]string(nil), original.Classes...)
+				rule.OpBytes = append([]string(nil), original.OpBytes...)
+				switch change {
+				case "prefix":
+					rule.Prefix = "Px"
+				case "row":
+					rule.RowIndex += 4
+				case "offset":
+					rule.EncodingOffset++
+				case "stride":
+					rule.ZOffset++
+				case "class":
+					rule.Classes[0] = "Yknot0"
+				case "length":
+					rule.OpBytes[rule.EncodingOffset] = strings.ReplaceAll(strings.ReplaceAll(strings.ReplaceAll(rule.OpBytes[rule.EncodingOffset], "128", "BAD"), "256", "BAD"), "512", "BAD")
+				case "W":
+					atom := rule.OpBytes[rule.EncodingOffset]
+					if strings.Contains(atom, "W0") {
+						atom = strings.ReplaceAll(atom, "W0", "W1")
+					} else {
+						atom = strings.ReplaceAll(atom, "W1", "W0")
+					}
+					rule.OpBytes[rule.EncodingOffset] = atom
+				case "suffix":
+					rule.Opcode += ".Z"
+				case "control":
+					rule.OpBytes[rule.EncodingOffset] += "|evexZeroingEnabled"
+				}
+				if _, err := x86KDataRowWitnesses(rule); err == nil {
+					t.Fatal("K data borrowed another width/role/control", change, rule)
+				}
+			})
+		}
+	}
+	if count != 87 {
+		t.Fatal("complete K-data negative denominator changed", count)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_leading_immediate_vector.go b/internal/goasmrules/x86_witness_leading_immediate_vector.go
new file mode 100644
index 000000000..520324cc9
--- /dev/null
+++ b/internal/goasmrules/x86_witness_leading_immediate_vector.go
@@ -0,0 +1,204 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Physical immediate/source/result roles do not combine the families'
+// numerical, old-destination or native-access contracts.
+type x86VectorResultFormat struct {
+	width                         int
+	unary, masked, broadcast, sae bool
+	rounding, maskResult          bool
+	encoding                      x86PackedAVXOpcode
+}
+
+func x86LeadingImmediateVectorFormatForRule(rule X86AVXRule) (x86VectorResultFormat, error) {
+	f := x86VectorResultFormat{masked: rule.ZCase == "Zevex_i_rm_v_k_r"}
+	fail := func() (x86VectorResultFormat, error) {
+		return f, fmt.Errorf("leading-immediate two-vector result roles differ from their official format")
+	}
+	count, maskIndex := 4, 0
+	if f.masked {
+		count, maskIndex = 5, 1
+	}
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	plain, kind := "Zvex_i_rm_v_r", "vex"
+	if evex {
+		plain, kind = "Zevex_i_rm_v_r", "evex"
+	}
+	if rule.Prefix != "Pavx" || rule.ZCase != plain && !f.masked || len(rule.Classes) != count ||
+		rule.Classes[0] != "Yu8" || f.masked && rule.Classes[3] != "Yknot0" {
+		return fail()
+	}
+	f.width = map[string]int{"Yxm": 128, "Yym": 256}[rule.Classes[1]]
+	register := map[int]string{128: "Yxr", 256: "Yyr"}[f.width]
+	if evex {
+		f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[rule.Classes[1]]
+		register = map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	}
+	widthIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width]
+	index, offset, zoffset, extent := widthIndex*2+maskIndex, widthIndex*3, maskIndex*3, 9
+	if rule.Ytab == "_yvgf2p8affineinvqb" {
+		extent = 13
+		index, offset = index+2, offset+4
+		if !evex {
+			index, offset, zoffset = widthIndex, widthIndex*2, 2
+		}
+	} else if rule.Ytab != "_yvalignd" || !evex {
+		return fail()
+	}
+	if f.width == 0 || rule.Classes[2] != register || rule.Classes[count-1] != register ||
+		rule.RowIndex != index || rule.ZOffset != zoffset ||
+		rule.EncodingOffset != offset || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	w, opcodeMap, pp, mapByte, bcstBytes := "W0", "0F3A", byte(1), byte(3), 0
+	if strings.HasSuffix(rule.Opcode, "Q") || strings.HasSuffix(rule.Opcode, "DW") {
+		w = "W1"
+	}
+	if strings.HasSuffix(rule.Opcode, "D") || strings.HasSuffix(rule.Opcode, "Q") {
+		bcstBytes = 4
+		if w == "W1" {
+			bcstBytes = 8
+		}
+	}
+	if extent == 13 {
+		switch rule.Opcode {
+		case "VPALIGNR":
+		case "VSHUFPS", "VSHUFPD":
+			opcodeMap, mapByte = "0F", 1
+			if rule.Opcode == "VSHUFPS" {
+				pp, bcstBytes = 0, 4
+			} else {
+				bcstBytes = 8
+				if evex {
+					w = "W1"
+				}
+			}
+		default:
+			return fail()
+		}
+	}
+	header := []string{"avxEscape", kind + strconv.Itoa(f.width), kind + opcodeMap, kind + w}
+	if pp != 0 {
+		header = append(header, kind+"66")
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], header, nil); err != nil {
+		return fail()
+	}
+	opcodeOffset := offset + 1
+	if evex {
+		f.broadcast = bcstBytes != 0
+		features := []string{"evexN" + strconv.Itoa(f.width/8), "evexZeroingEnabled"}
+		if f.broadcast {
+			features = append(features, "evexBcstN"+strconv.Itoa(bcstBytes))
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], features, nil); err != nil {
+			return fail()
+		}
+		opcodeOffset++
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[opcodeOffset], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: kind, mapByte: mapByte, pp: pp, length: byte(widthIndex), opcode: byte(opcode)}
+	if w == "W1" {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func x86LeadingImmediateVectorRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86LeadingImmediateVectorFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	return f.witnesses(rule.Opcode), nil
+}
+
+// Only validated vector-source/vector-result transport is shared.
+// Family factories retain mandatory prefixes, W, tuples and broadcast guards.
+func (f x86VectorResultFormat) witnesses(opcode string) []X86PackedBinaryWitness {
+	return f.witnessesWithControl(opcode, true, 7)
+}
+
+func (f x86VectorResultFormat) witnessesWithControl(opcode string, immediate bool, selector int) []X86PackedBinaryWitness {
+	bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[f.width]
+	first, second, destination := bank+"0", bank+"1", bank+"2"
+	if f.encoding.kind == "evex" {
+		first, second, destination = bank+"16", bank+"17", bank+"18"
+	}
+	if f.unary {
+		second = ""
+	}
+	destinations := []struct {
+		name string
+		reg  byte
+	}{{destination, 2}}
+	if f.maskResult {
+		destinations = []struct {
+			name string
+			reg  byte
+		}{{"K2", 2}, {"K0", 0}}
+	}
+	var witnesses []X86PackedBinaryWitness
+	// K2 then K0 stays outside the source/control loops, preserving prior owners.
+	for _, target := range destinations {
+		for _, source := range []string{first, "(AX)"} {
+			for _, control := range []string{"", "BCST", "SAE", "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				broadcast, sae := control == "BCST", control == "SAE"
+				rounding := strings.HasSuffix(control, "_SAE")
+				if broadcast && (source != "(AX)" || !f.broadcast) || sae && (source == "(AX)" || !f.sae) || rounding && (source == "(AX)" || !f.rounding) {
+					continue
+				}
+				for _, zeroing := range []bool{false, true} {
+					if zeroing && (!f.masked || f.maskResult) {
+						continue
+					}
+					operands, suffix, vvvv := source, "", byte(0x70)
+					if immediate {
+						operands = fmt.Sprintf("$%d,%s", selector, source)
+					}
+					p0, p2, modrm := byte(0xa0), f.encoding.length<<5, byte(0xc0)|target.reg<<3
+					if f.maskResult {
+						p0 |= 0x10
+					}
+					if f.unary {
+						vvvv, p2 = 0x78, p2|8
+					} else {
+						operands += "," + second
+					}
+					if source == "(AX)" {
+						p0, modrm = p0|0x40, target.reg<<3
+					}
+					if f.masked {
+						operands, p2 = operands+",K1", p2|1
+					}
+					if control != "" {
+						suffix, p2 = "."+control, p2|0x10
+					}
+					if rounding {
+						p2 = p2&^0x60 | map[string]byte{"RN_SAE": 0, "RD_SAE": 1, "RU_SAE": 2, "RZ_SAE": 3}[control]<<5
+					}
+					if zeroing {
+						suffix, p2 = suffix+".Z", p2|0x80
+					}
+					encoding := f.encoding.bytes(vvvv, p0, p2, modrm)
+					if immediate {
+						encoding = append(encoding, byte(selector))
+					}
+					witnesses = append(witnesses, X86PackedBinaryWitness{
+						Instruction: opcode + suffix + " " + operands + "," + target.name, Generation: f.encoding.kind,
+						First: source, Second: second, Destination: target.name, Width: f.width, Memory: source == "(AX)",
+						Masked: f.masked, Zeroing: zeroing, Broadcast: broadcast, MaskResult: f.maskResult, Encoding: encoding,
+					})
+				}
+			}
+		}
+	}
+	return witnesses
+}
diff --git a/internal/goasmrules/x86_witness_leading_immediate_vector_test.go b/internal/goasmrules/x86_witness_leading_immediate_vector_test.go
new file mode 100644
index 000000000..61ade243e
--- /dev/null
+++ b/internal/goasmrules/x86_witness_leading_immediate_vector_test.go
@@ -0,0 +1,231 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const x86LeadingImmediateVectorTestNames = `VALIGND VALIGNQ
+	VPSHLDW VPSHLDD VPSHLDQ VPSHRDW VPSHRDD VPSHRDQ VPTERNLOGD VPTERNLOGQ VDBPSADBW`
+
+func TestX86LeadingImmediateVectorCompleteOfficialRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, originals := map[string]bool{}, map[string]X86AVXRule{}
+	for _, name := range strings.Fields(x86LeadingImmediateVectorTestNames) {
+		names[name] = true
+	}
+	for _, entry := range legacy.Optab {
+		if names[entry.Opcode] {
+			t.Fatal("leading-immediate vector family acquired a legacy row", entry)
+		}
+	}
+	for index, row := range avx {
+		if names[row.Opcode] {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)] = row
+		}
+	}
+	if len(names) != 11 || len(originals) != 66 {
+		t.Fatal("four complete families lost an original official row", len(names), len(originals))
+	}
+	// Existing helper: the initial RED must be an actual unsupported format,
+	// not a missing future API. This join grants no numerical or memory rights.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86LeadingImmediateVectorTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions, members := map[string]bool{}, map[string]bool{}, map[string]int{}
+	widths := map[int]int{}
+	masked, zeroing, broadcast, memory := 0, 0, 0, 0
+	for _, row := range rows {
+		original, found := originals[row.ID]
+		if !found || seen[row.ID] || original.Ytab != "_yvalignd" {
+			t.Fatal("leading-immediate vector join lost its original identity", row)
+		}
+		seen[row.ID], members[row.Opcode] = true, members[row.Opcode]+1
+		widthIndex, maskIndex := original.RowIndex/2, original.RowIndex%2
+		width, hasMask := 128<<widthIndex, maskIndex != 0
+		bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[width]
+		registerClass := map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[width]
+		classes := []string{"Yu8", map[int]string{128: "YxmEvex", 256: "YymEvex", 512: "Yzm"}[width], registerClass}
+		if hasMask {
+			classes = append(classes, "Yknot0")
+		}
+		classes = append(classes, registerClass)
+		zcase := "Zevex_i_rm_v_r"
+		if hasMask {
+			zcase = "Zevex_i_rm_v_k_r"
+		}
+		if original.Prefix != "Pavx" || original.ZCase != zcase || original.ZOffset != maskIndex*3 ||
+			original.EncodingOffset != widthIndex*3 || len(original.OpBytes) != 9 ||
+			strings.Join(original.Classes, ",") != strings.Join(classes, ",") {
+			t.Fatal("leading immediate, two sources, mask and result were conflated", original)
+		}
+		w, bcst := "W0", 0
+		if strings.HasSuffix(row.Opcode, "Q") || strings.HasSuffix(row.Opcode, "W") && row.Opcode != "VDBPSADBW" {
+			w = "W1"
+		}
+		if strings.HasSuffix(row.Opcode, "D") {
+			bcst = 4
+		} else if strings.HasSuffix(row.Opcode, "Q") {
+			bcst = 8
+		}
+		if _, err := x86PackedEncodingAtoms(original.OpBytes[original.EncodingOffset], []string{
+			"avxEscape", "evex" + strconv.Itoa(width), "evex66", "evex0F3A", "evex" + w,
+		}, nil); err != nil {
+			t.Fatal("leading-immediate header changed", original, err)
+		}
+		features := []string{"evexN" + strconv.Itoa(width/8), "evexZeroingEnabled"}
+		if bcst != 0 {
+			features = append(features, "evexBcstN"+strconv.Itoa(bcst))
+		}
+		if _, err := x86PackedEncodingAtoms(original.OpBytes[original.EncodingOffset+1], features, nil); err != nil {
+			t.Fatal("full tuple/broadcast/zeroing axis changed", original, err)
+		}
+		payload, err := strconv.ParseUint(original.OpBytes[original.EncodingOffset+2], 0, 8)
+		if err != nil {
+			t.Fatal("official immediate payload has no byte opcode", original, err)
+		}
+		for _, witness := range row.Witnesses {
+			fields := strings.Fields(witness.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("lost leading-immediate instruction", witness)
+			}
+			args := strings.Split(fields[1], ",")
+			if len(args) != len(classes) || instructions[witness.Instruction] || args[0] != "$7" ||
+				witness.First != args[1] || witness.First != bank+"16" && witness.First != "(AX)" ||
+				witness.Second != args[2] || witness.Second != bank+"17" ||
+				witness.Destination != args[len(args)-1] || witness.Destination != bank+"18" ||
+				witness.Width != width || witness.Generation != "evex" || witness.MaskResult ||
+				witness.Masked != hasMask || hasMask && args[3] != "K1" ||
+				witness.Zeroing != strings.Contains(fields[0], ".Z") || witness.Zeroing && !hasMask ||
+				witness.Memory != (witness.First == "(AX)") || witness.Broadcast != strings.Contains(fields[0], ".BCST") ||
+				witness.Broadcast && (!witness.Memory || bcst == 0) || len(witness.Encoding) != 7 ||
+				witness.Encoding[0] != 0x62 || witness.Encoding[1]&0xf != 3 || witness.Encoding[2]&0x7f != 0x75 ||
+				(witness.Encoding[2]&0x80 != 0) != (w == "W1") ||
+				(witness.Encoding[3]&0x80 != 0) != witness.Zeroing ||
+				(witness.Encoding[3]&0x10 != 0) != witness.Broadcast ||
+				witness.Encoding[3]&7 != byte(maskIndex) || 128<<(witness.Encoding[3]>>5&3) != width ||
+				witness.Encoding[4] != byte(payload) || witness.Encoding[6] != 7 {
+				t.Fatal("leading immediate/two-vector/vector-result witness borrowed a foreign role", row.ID, witness)
+			}
+			instructions[witness.Instruction], widths[width] = true, widths[width]+1
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.Broadcast {
+				broadcast++
+			}
+			if witness.Memory {
+				memory++
+			}
+		}
+	}
+	if len(rows) != 66 || len(seen) != len(originals) || len(members) != 11 || len(instructions) != 270 ||
+		widths[128] != 90 || widths[256] != 90 || widths[512] != 90 ||
+		masked != 180 || zeroing != 90 || broadcast != 72 || memory != 171 {
+		t.Fatal("complete leading-immediate source/control denominator changed", len(rows), members, len(instructions), widths, masked, zeroing, broadcast, memory)
+	}
+	for member, count := range members {
+		if count != 6 {
+			t.Fatal("member lost an original width/mask row", member, count)
+		}
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VALIGND $7,X16,X17,X18", []byte{0x62, 0xa3, 0x75, 0x00, 0x03, 0xd0, 0x07}},
+		{"VALIGNQ.BCST.Z $7,(AX),Z17,K1,Z18", []byte{0x62, 0xe3, 0xf5, 0xd1, 0x03, 0x10, 0x07}},
+		{"VPSHLDW $7,X16,X17,X18", []byte{0x62, 0xa3, 0xf5, 0x00, 0x70, 0xd0, 0x07}},
+		{"VPTERNLOGQ.BCST $7,(AX),Y17,Y18", []byte{0x62, 0xe3, 0xf5, 0x30, 0x25, 0x10, 0x07}},
+		{"VDBPSADBW.Z $7,Y16,Y17,K1,Y18", []byte{0x62, 0xa3, 0x75, 0xa1, 0x42, 0xd0, 0x07}},
+	})
+}
+
+func TestX86LeadingImmediateVectorRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"signed immediate", "source carrier", "second carrier", "K result", "K0 mask",
+		"tuple", "word BCST", "SAD BCST", "both BCST sizes", "no zeroing", "SAE", "rounding", "W", "map", "PP",
+		"VEX", "offset", "row index", "opcode extent"} {
+		t.Run(mutation, func(t *testing.T) {
+			name := "VALIGND"
+			if mutation == "word BCST" {
+				name = "VPSHLDW"
+			} else if mutation == "SAD BCST" {
+				name = "VDBPSADBW"
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != 1 {
+					continue
+				}
+				found++
+				if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+					t.Fatal("negative requires its valid original source row", original, err)
+				}
+				row := original
+				row.Classes, row.OpBytes = append([]string(nil), original.Classes...), append([]string(nil), original.OpBytes...)
+				header, features := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "signed immediate":
+					row.Classes[0] = "Yi8"
+				case "source carrier":
+					row.Classes[1] = "YymEvex"
+				case "second carrier":
+					row.Classes[2] = "YyrEvex"
+				case "K result":
+					row.Classes[4] = "Yk"
+				case "K0 mask":
+					row.Classes[3] = "Yk"
+				case "tuple":
+					row.OpBytes[features] = strings.Replace(row.OpBytes[features], "evexN16", "evexN8", 1)
+				case "word BCST":
+					row.OpBytes[features] += "|evexBcstN8"
+				case "SAD BCST":
+					row.OpBytes[features] += "|evexBcstN4"
+				case "both BCST sizes":
+					row.OpBytes[features] += "|evexBcstN8"
+				case "no zeroing":
+					row.OpBytes[features] = strings.ReplaceAll(row.OpBytes[features], "evexZeroingEnabled", "")
+				case "SAE":
+					row.OpBytes[features] += "|evexSaeEnabled"
+				case "rounding":
+					row.OpBytes[features] += "|evexRoundingEnabled"
+				case "W":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW0", "evexW1", 1)
+				case "map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F3A", "evex0F38", 1)
+				case "PP":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex66", "evexF3", 1)
+				case "VEX":
+					row.ZCase = "Zvex_i_rm_v_r"
+				case "offset":
+					row.EncodingOffset++
+				case "row index":
+					row.RowIndex++
+				case "opcode extent":
+					row.OpBytes[header+2] = "256"
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("leading-immediate vector row borrowed a foreign format axis", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("negative lost its original row", name, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_legacy_float_binary_test.go b/internal/goasmrules/x86_witness_legacy_float_binary_test.go
new file mode 100644
index 000000000..5dcbe3cc8
--- /dev/null
+++ b/internal/goasmrules/x86_witness_legacy_float_binary_test.go
@@ -0,0 +1,138 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86LegacyFloatingBinaryCompleteExistingTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := `ADDPD ADDPS ADDSD ADDSS DIVPD DIVPS DIVSD DIVSS
+        MAXPD MAXPS MAXSD MAXSS MINPD MINPS MINSD MINSS
+        MULPD MULPS MULSD MULSS SUBPD SUBPS SUBSD SUBSS`
+	selected := map[string]bool{}
+	for _, name := range strings.Fields(names) {
+		selected[name] = true
+	}
+	originals := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if !selected[entry.Opcode] {
+			continue
+		}
+		if entry.Ytab != "yxm" || len(entry.Rows) != 1 || len(entry.OpBytes) != 1 {
+			t.Fatal("original complete media schema changed", entry)
+		}
+		row := entry.Rows[0]
+		if row.RowIndex != 0 || row.ZCase != "Zm_r_xm" || row.ZOffset != 1 ||
+			row.UnmatchedOffset != 0 || strings.Join(row.Classes, ",") != "Yxm,Yxr" {
+			t.Fatal("original operand classes/offsets changed", entry)
+		}
+		originals[fmt.Sprintf("optab/%d/%s/yxm/0", entry.TableIndex, entry.Opcode)] = true
+	}
+	if len(originals) != 24 {
+		t.Fatal("lost complete source family", len(originals))
+	}
+	// Existing helper only: no future selector symbol is needed to compile RED.
+	rows, err := x86PackedBinaryRows(catalog, nil, names)
+	if err != nil {
+		t.Fatal("complete legacy FP source-prefix transport", err)
+	}
+	seen, shapes := map[string]bool{}, 0
+	for _, row := range rows {
+		if !originals[row.ID] || seen[row.ID] || len(row.Witnesses) != 2 {
+			t.Fatal("source row lost/duplicated", row)
+		}
+		seen[row.ID] = true
+		for _, w := range row.Witnesses {
+			if w.Generation != "legacy" || w.Width != 128 || w.Second != "X1" ||
+				w.Destination != "X1" || w.Masked || w.Zeroing || w.Broadcast || w.MaskResult {
+				t.Fatal("legacy RMW roles/controls changed", w)
+			}
+			shapes++
+		}
+	}
+	if len(seen) != 24 || shapes != 48 {
+		t.Fatal("source projection changed", len(seen), shapes)
+	}
+}
+
+func TestX86LegacyFloatingBinaryMediaPrefixControls(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var scalar X86LegacyOpcode
+	checked := 0
+	for _, entry := range catalog.Optab {
+		if !x86LegacyFloatingBinaryMember(entry.Opcode) {
+			continue
+		}
+		if _, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0]); err != nil {
+			t.Fatal("valid original media source required", err)
+		}
+		if entry.Opcode == "ADDSD" {
+			scalar = entry
+		}
+		t.Run(entry.Opcode+"/foreign-prefix", func(t *testing.T) {
+			changed := entry
+			changed.Prefix = "Pf3"
+			if strings.HasSuffix(entry.Opcode, "SS") {
+				changed.Prefix = "Pf2"
+			}
+			if _, err := x86PackedLegacyRowWitnesses(changed, entry.Rows[0]); err == nil {
+				t.Fatal("media mandatory prefix borrowed from another source class", changed)
+			}
+		})
+		checked++
+	}
+	if checked != 24 || scalar.Opcode != "ADDSD" {
+		t.Fatal("missing complete media controls", checked)
+	}
+	for _, control := range []string{"ytab", "row-index", "classes", "zcase", "zoffset", "offset", "escape", "extent", "symbolic-byte"} {
+		t.Run(control, func(t *testing.T) {
+			entry, row := scalar, scalar.Rows[0]
+			switch control {
+			case "ytab":
+				entry.Ytab = "ymm"
+			case "row-index":
+				row.RowIndex++
+			case "classes":
+				row.Classes = []string{"Ymm", "Yxr"}
+			case "zcase":
+				row.ZCase = "Zm_r"
+			case "zoffset":
+				row.ZOffset++
+			case "offset":
+				row.UnmatchedOffset++
+			case "escape":
+				entry.EscapeAdjustment++
+			case "extent":
+				entry.OpBytes = append(append([]string(nil), entry.OpBytes...), "0")
+			case "symbolic-byte":
+				entry.OpBytes = []string{"Pm"}
+			}
+			if _, err := x86PackedLegacyRowWitnesses(entry, row); err == nil {
+				t.Fatal("foreign complete media axes accepted", control)
+			}
+		})
+	}
+	for _, opcode := range []string{"ANDPD", "PABSD"} {
+		for _, prefix := range []string{"Pf2", "Pf3", "Ym"} {
+			t.Run(opcode+"/"+prefix, func(t *testing.T) {
+				entry := scalar
+				entry.Opcode, entry.Prefix = opcode, prefix
+				if x86LegacyFloatingBinaryMember(opcode) {
+					t.Fatal("suffix admitted an unrelated semantic family", opcode)
+				}
+				if _, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0]); err == nil {
+					t.Fatal("floating media prefix widened the old binary/ABS grammar", opcode, prefix)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_legacy_media.go b/internal/goasmrules/x86_witness_legacy_media.go
new file mode 100644
index 000000000..1fc4f7e68
--- /dev/null
+++ b/internal/goasmrules/x86_witness_legacy_media.go
@@ -0,0 +1,246 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86LegacyMediaRow is an explicit carrier projection. The pre-existing
+// packed projection intentionally continues to exclude physical MMX regions.
+// Source bytes and syntax supply no numerical, memory or entry permission.
+type X86LegacyMediaRow struct {
+	ID, Opcode, ModeFiltered string
+	Witnesses                []X86PackedBinaryWitness
+}
+
+func x86LegacyMediaRemainderMember(name string) bool {
+	if name == "PSADBW" {
+		return true
+	}
+	for _, stem := range []string{"ADDSUB", "HADD", "HSUB", "RCP", "RSQRT", "SQRT"} {
+		if strings.HasPrefix(name, stem) {
+			suffix := strings.TrimPrefix(name, stem)
+			return suffix == "PS" || suffix == "PD" || suffix == "SS" || suffix == "SD"
+		}
+	}
+	for _, stem := range []string{"COMI", "UCOMI"} {
+		if strings.HasPrefix(name, stem) {
+			return name == stem+"SS" || name == stem+"SD"
+		}
+	}
+	return name == "CVTPD2PS" || name == "CVTPS2PD" || name == "CVTSD2SS" || name == "CVTSS2SD"
+}
+
+// X86LegacyMediaRemainderRows retains each of the original 96 source rows.
+// A mode refusal remains an inventory row and cannot acquire a witness.
+func X86LegacyMediaRemainderRows(catalog X86LegacyCatalog, arch string) ([]X86LegacyMediaRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("legacy media requires a Go x86 source mode")
+	}
+	var result []X86LegacyMediaRow
+	for _, entry := range catalog.Optab {
+		for _, operand := range entry.Rows {
+			selected := entry.Ytab == "ymm" && operand.RowIndex == 0 ||
+				entry.Ytab == "yps" && operand.RowIndex < 2 || entry.Ytab == "yxmov" ||
+				entry.Ytab == "yxm" && x86LegacyMediaRemainderMember(entry.Opcode)
+			if !selected {
+				continue
+			}
+			witnesses, mmx, err := x86LegacyMediaRowWitnesses(entry, operand)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86LegacyMediaRow{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses,
+			}
+			if mmx && arch == "386" {
+				row.ModeFiltered, row.Witnesses = "original Go Py1/Py3 rejects named MMX in 386 mode", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(result) != 96 {
+		return nil, fmt.Errorf("incomplete original legacy media closure: rows=%d", len(result))
+	}
+	return result, nil
+}
+
+// One transport models bank, direction and immediate roles independently of
+// semantic families. Table offsets/payloads remain the only opcode source.
+type x86LegacyMediaFormat struct {
+	prefix           []byte
+	opcode, digit    byte
+	mmx, store, imm8 bool
+}
+
+// Pure carrier/ModRM emission is shared by the old XMM consumer and the
+// complete mixed-bank source view. Callers own shape validation and source
+// selection. The carrier width establishes neither a memory tuple nor NUM.
+func x86LegacyMediaCarrierWitnesses(name string, classes []string, prefix []byte, memorySource bool) []X86PackedBinaryWitness {
+	first, last, width := "X0", "X1", 128
+	if classes[0] == "Ymm" || classes[0] == "Ymr" {
+		first = "M0"
+	}
+	if classes[1] == "Ymr" {
+		last, width = "M1", 64
+	} else if classes[1] == "Yml" {
+		last = "CX"
+	}
+	sources, destinations := []string{first}, []string{last}
+	if classes[0] == "Ym" {
+		sources = []string{"(AX)"}
+	} else if memorySource && (classes[0] == "Yxm" || classes[0] == "Ymm") {
+		sources = append(sources, "(AX)")
+	}
+	if classes[1] == "Yml" {
+		destinations = append(destinations, "(AX)")
+	}
+	var result []X86PackedBinaryWitness
+	for _, source := range sources {
+		for _, destination := range destinations {
+			modrm := byte(0xc8)
+			if source == "(AX)" {
+				modrm = 0x08
+			} else if destination == "CX" {
+				modrm = 0xc1
+			} else if destination == "(AX)" {
+				modrm = 0
+			}
+			result = append(result, X86PackedBinaryWitness{
+				Instruction: name + " " + source + "," + destination, Generation: "legacy", Width: width,
+				First: source, Second: destination, Destination: destination, Memory: source == "(AX)" || destination == "(AX)",
+				Encoding: append(append([]byte(nil), prefix...), modrm),
+			})
+		}
+	}
+	return result
+}
+
+func x86LegacyMediaRowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86PackedBinaryWitness, bool, error) {
+	format, err := x86LegacyMediaFormatForRow(entry, row)
+	if err != nil {
+		return nil, false, err
+	}
+	register, width := "X", 128
+	if format.mmx {
+		register, width = "M", 64
+	}
+	firsts := []string{register + "0", "(AX)"}
+	if entry.Ytab == "yxmov" {
+		// A memory operand selects each direction unambiguously. Register
+		// aliases and half-move encodings have their independent owners.
+		firsts = []string{"(AX)"}
+	}
+	if format.imm8 {
+		firsts = []string{""}
+	}
+	var result []X86PackedBinaryWitness
+	for _, first := range firsts {
+		destination, second, modrm := register+"1", register+"1", byte(0xc8)
+		if first == "(AX)" {
+			modrm = 0x08
+		}
+		if format.store {
+			first, destination, second, modrm = "X1", "(AX)", "", 0x08
+		}
+		code := append(append([]byte(nil), format.prefix...), format.opcode, modrm)
+		instruction := entry.Opcode + " " + first + "," + destination
+		if format.imm8 {
+			instruction = entry.Opcode + " $-1," + destination
+			code[len(code)-1] = 0xc1 | format.digit<<3
+			code = append(code, 255)
+		}
+		result = append(result, X86PackedBinaryWitness{
+			Instruction: instruction, Generation: "legacy", Width: width,
+			First: first, Second: second, Destination: destination,
+			Memory: first == "(AX)" || destination == "(AX)", Encoding: code,
+		})
+	}
+	return result, format.mmx, nil
+}
+
+func x86LegacyMediaFormatForRow(entry X86LegacyOpcode, row X86LegacyOperand) (x86LegacyMediaFormat, error) {
+	format := x86LegacyMediaFormat{prefix: []byte{0x0f}}
+	var schema []string
+	offset := row.UnmatchedOffset
+	switch entry.Ytab {
+	case "ymm":
+		if entry.Prefix != "Py1" || len(entry.OpBytes) != 3 || entry.OpBytes[1] != "Pe" || entry.OpBytes[0] != entry.OpBytes[2] || row.RowIndex != 0 {
+			return format, fmt.Errorf("unmodeled complete Py1 MMX payload")
+		}
+		schema = []string{"Zm_r_xm/1/Ymm,Ymr", "Zm_r_xm/2/Yxm,Yxr"}
+		format.mmx = true
+	case "yps":
+		if entry.Prefix != "Py3" || len(entry.OpBytes) != 8 || entry.OpBytes[3] != "Pe" || entry.OpBytes[5] != "Pe" ||
+			entry.OpBytes[0] != entry.OpBytes[4] || entry.OpBytes[1] != entry.OpBytes[6] || entry.OpBytes[2] != entry.OpBytes[7] || row.RowIndex > 1 {
+			return format, fmt.Errorf("unmodeled complete Py3 MMX payload")
+		}
+		schema = []string{"Zm_r_xm/1/Ymm,Ymr", "Zibo_m_xm/2/Yi8,Ymr", "Zm_r_xm/2/Yxm,Yxr", "Zibo_m_xm/3/Yi8,Yxr"}
+		format.mmx, format.imm8 = true, row.RowIndex == 1
+	case "yxmov":
+		if len(entry.OpBytes) != 2 {
+			return format, fmt.Errorf("unmodeled complete directional media payload")
+		}
+		schema = []string{"Zm_r_xm/1/Yxm,Yxr", "Zr_m_xm/1/Yxr,Yxm"}
+		format.store = row.RowIndex == 1
+	case "yxm":
+		if !x86LegacyMediaRemainderMember(entry.Opcode) || len(entry.OpBytes) != 1 {
+			return format, fmt.Errorf("foreign legacy media family")
+		}
+		schema = []string{"Zm_r_xm/1/Yxm,Yxr"}
+	default:
+		return format, fmt.Errorf("unmodeled legacy media table")
+	}
+	if entry.Kind != "encoding" || entry.EscapeAdjustment != 0 || len(entry.Rows) != len(schema) || row.RowIndex < 0 || row.RowIndex >= len(schema) {
+		return format, fmt.Errorf("unmodeled complete media source schema")
+	}
+	position := 0
+	for index, original := range entry.Rows {
+		if original.RowIndex != index || original.UnmatchedOffset != position ||
+			fmt.Sprintf("%s/%d/%s", original.ZCase, original.ZOffset, strings.Join(original.Classes, ",")) != schema[index] {
+			return format, fmt.Errorf("media ordered source row changed")
+		}
+		position += original.ZOffset
+	}
+	if fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schema[row.RowIndex] ||
+		row.UnmatchedOffset != entry.Rows[row.RowIndex].UnmatchedOffset || position != len(entry.OpBytes) {
+		return format, fmt.Errorf("media selected row/complete extent changed")
+	}
+	if !format.mmx {
+		switch entry.Prefix {
+		case "Pe", "Pq":
+			format.prefix = []byte{0x66, 0x0f}
+		case "Pm":
+		case "Pf2":
+			format.prefix = []byte{0xf2, 0x0f}
+		case "Pf3":
+			format.prefix = []byte{0xf3, 0x0f}
+		default:
+			return format, fmt.Errorf("unmodeled legacy media prefix")
+		}
+	}
+	var payload [8]byte // The complete admitted schemas have at most eight atoms.
+	for index, token := range entry.OpBytes {
+		if token == "Pe" && (entry.Ytab == "ymm" && index == 1 || entry.Ytab == "yps" && (index == 3 || index == 5)) {
+			continue // The complete Py1/Py3 schema already bound its positions.
+		}
+		value, err := strconv.ParseUint(token, 0, 8)
+		if err != nil {
+			return format, fmt.Errorf("media complete payload contains a non-byte atom")
+		}
+		payload[index] = byte(value)
+	}
+	if entry.Ytab == "yps" && payload[2] > 7 {
+		return format, fmt.Errorf("media complete /digit is not three bits")
+	}
+	format.opcode = payload[offset]
+	if format.imm8 {
+		if payload[offset+1] > 7 {
+			return format, fmt.Errorf("media immediate /digit is not three bits")
+		}
+		format.digit = payload[offset+1]
+	}
+	return format, nil
+}
diff --git a/internal/goasmrules/x86_witness_legacy_media_test.go b/internal/goasmrules/x86_witness_legacy_media_test.go
new file mode 100644
index 000000000..a1530c863
--- /dev/null
+++ b/internal/goasmrules/x86_witness_legacy_media_test.go
@@ -0,0 +1,193 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This independent scope names semantic families, not opcode bytes. The
+// original table still supplies every row, class, prefix and payload.
+func x86LegacyMediaTestMember(entry X86LegacyOpcode, row X86LegacyOperand) bool {
+	switch entry.Ytab {
+	case "ymm":
+		return row.RowIndex == 0
+	case "yps":
+		return row.RowIndex < 2
+	case "yxmov":
+		return true
+	case "yxm":
+		return strings.Contains(" ADDSUBPD ADDSUBPS COMISD COMISS CVTPD2PS CVTPS2PD CVTSD2SS CVTSS2SD HADDPD HADDPS HSUBPD HSUBPS PSADBW RCPPS RCPSS RSQRTPS RSQRTSS SQRTPD SQRTPS SQRTSD SQRTSS UCOMISD UCOMISS ", " "+entry.Opcode+" ")
+	}
+	return false
+}
+
+// The recorded RED used the old default helper. The final explicit carrier
+// projection keeps that helper's MMX refusal and all previous views intact.
+func TestX86LegacyMediaRemainderExplicitCarrierTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, entry := range catalog.Optab {
+		for _, row := range entry.Rows {
+			if !x86LegacyMediaTestMember(entry, row) {
+				continue
+			}
+			counts[entry.Ytab]++
+			t.Run(fmt.Sprintf("%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex), func(t *testing.T) {
+				witnesses, mmx, err := x86LegacyMediaRowWitnesses(entry, row)
+				if err != nil || len(witnesses) == 0 {
+					t.Fatal("complete explicit carrier projection has no transport", err)
+				}
+				if mmx {
+					if old, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(old) != 0 {
+						t.Fatal("default packed consumer acquired physical MMX rows", old, err)
+					}
+				}
+				for _, w := range witnesses {
+					if w.Width != 128 && !mmx || w.Width != 64 && mmx || w.Generation != "legacy" ||
+						w.Masked || w.Zeroing || w.Broadcast || w.MaskResult {
+						t.Fatal("carrier or unrelated control changed", w)
+					}
+				}
+			})
+		}
+	}
+	if fmt.Sprint(counts) != "map[ymm:33 yps:16 yxm:23 yxmov:24]" {
+		t.Fatal("complete original media denominator changed", counts)
+	}
+}
+
+func TestX86LegacyMediaRemainderModesAndPayload(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86LegacyMediaRemainderRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ids, formats, filtered := map[string]bool{}, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || ids[row.ID] {
+				t.Fatal("original row identity missing/repeated", row)
+			}
+			ids[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("refused mode acquired witnesses", row)
+				}
+			}
+			formats += len(row.Witnesses)
+		}
+		wantFormats, wantFiltered := 160, 0
+		if arch == "386" {
+			wantFormats, wantFiltered = 70, 49
+		}
+		if len(ids) != 96 || formats != wantFormats || filtered != wantFiltered {
+			t.Fatal("original source/carrier/mode union changed", arch, len(ids), formats, filtered)
+		}
+	}
+	for _, original := range catalog.Optab {
+		if original.Opcode != "PADDB" {
+			continue
+		}
+		entry := original
+		entry.OpBytes = append([]string(nil), original.OpBytes...)
+		entry.OpBytes[0], entry.OpBytes[2] = "0xfd", "0xfd"
+		w, _, err := x86LegacyMediaRowWitnesses(entry, entry.Rows[0])
+		if err != nil || len(w) != 2 || !bytes.Equal(w[0].Encoding, []byte{0x0f, 0xfd, 0xc8}) {
+			t.Fatal("transport replaced original selected bytes by a mnemonic table", w, err)
+		}
+	}
+}
+
+func TestX86LegacyMediaCompleteMMXAtomsRemainTyped(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if original.Ytab != "ymm" && original.Ytab != "yps" {
+			continue
+		}
+		for _, control := range []string{"opcode-is-prefix", "unused-extension"} {
+			if control == "unused-extension" && original.Ytab != "yps" {
+				continue
+			}
+			t.Run(original.Opcode+"/"+control, func(t *testing.T) {
+				entry := original
+				entry.OpBytes = append([]string(nil), original.OpBytes...)
+				if control == "unused-extension" {
+					entry.OpBytes[2], entry.OpBytes[7] = "8", "8"
+				} else if entry.Ytab == "ymm" {
+					entry.OpBytes[0], entry.OpBytes[2] = "Pe", "Pe"
+				} else {
+					entry.OpBytes[0], entry.OpBytes[4] = "Pe", "Pe"
+				}
+				if w, _, err := x86LegacyMediaRowWitnesses(entry, entry.Rows[0]); err == nil || len(w) != 0 {
+					t.Fatal("complete MMX schema confused a prefix/opcode or ignored an invalid /digit", w, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyMediaRemainderRejectsForeignAxes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		for _, operand := range original.Rows {
+			if !x86LegacyMediaTestMember(original, operand) {
+				continue
+			}
+			for _, control := range []string{"kind", "table", "prefix", "escape", "index", "classes", "zcase", "stride", "offset", "extent", "selected-byte", "unselected-byte"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, operand.RowIndex, control), func(t *testing.T) {
+					entry, row := original, operand
+					entry.OpBytes = append([]string(nil), original.OpBytes...)
+					switch control {
+					case "kind":
+						entry.Kind = "special"
+					case "table":
+						entry.Ytab = "unknown"
+					case "prefix":
+						entry.Prefix = "unknown"
+					case "escape":
+						entry.EscapeAdjustment++
+					case "index":
+						row.RowIndex = len(entry.Rows)
+					case "classes":
+						row.Classes = []string{"Yunknown", "Yxr"}
+					case "zcase":
+						row.ZCase = "Zunknown"
+					case "stride":
+						row.ZOffset++
+					case "offset":
+						row.UnmatchedOffset++
+					case "extent":
+						entry.OpBytes = append(entry.OpBytes, "0")
+					case "selected-byte":
+						entry.OpBytes[row.UnmatchedOffset] = "not-a-byte"
+					case "unselected-byte":
+						index := len(entry.OpBytes) - 1
+						if index == row.UnmatchedOffset {
+							index = 0
+						}
+						entry.OpBytes[index] = "not-a-byte"
+					}
+					if w, _, err := x86LegacyMediaRowWitnesses(entry, row); err == nil || len(w) != 0 {
+						t.Fatal("foreign source axes silently acquired media transport", control, w, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_legacy_scalar_conversion_test.go b/internal/goasmrules/x86_witness_legacy_scalar_conversion_test.go
new file mode 100644
index 000000000..42bf7b516
--- /dev/null
+++ b/internal/goasmrules/x86_witness_legacy_scalar_conversion_test.go
@@ -0,0 +1,113 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func scalarConversion12OriginalEntries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	tables := map[string]bool{"yxcvfl": true, "yxcvfq": true, "yxcvlf": true, "yxcvqf": true}
+	var entries []X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		if !tables[entry.Ytab] {
+			continue
+		}
+		wantClasses := []string{"Yxm", "Yrl"}
+		if entry.Ytab == "yxcvlf" || entry.Ytab == "yxcvqf" {
+			wantClasses = []string{"Yml", "Yxr"}
+		}
+		stride := 1
+		if entry.Ytab == "yxcvfq" || entry.Ytab == "yxcvqf" {
+			stride = 2
+		}
+		if entry.Kind != "encoding" || entry.EscapeAdjustment != 0 || len(entry.Rows) != 1 || entry.Rows[0].RowIndex != 0 || entry.Rows[0].UnmatchedOffset != 0 || entry.Rows[0].ZCase != "Zm_r_xm" || entry.Rows[0].ZOffset != stride || !reflect.DeepEqual(entry.Rows[0].Classes, wantClasses) || len(entry.OpBytes) != stride {
+			t.Fatal("complete original scalar conversion schema changed", entry)
+		}
+		entries = append(entries, entry)
+	}
+	if len(entries) != 12 {
+		t.Fatal("complete four-table conversion inventory changed", len(entries))
+	}
+	return entries
+}
+
+func TestX86LegacyScalarConversionCompleteSourceTransport(t *testing.T) {
+	for _, entry := range scalarConversion12OriginalEntries(t) {
+		t.Run(entry.Opcode, func(t *testing.T) {
+			before := fmt.Sprintf("%#v", entry)
+			witnesses, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0])
+			if err != nil || len(witnesses) != 2 {
+				t.Error("SCALAR_CONVERSION_SOURCE_TRANSPORT_GAP", entry.Opcode, err)
+			}
+			for _, w := range witnesses {
+				if w.Instruction == "" || len(w.Encoding) == 0 || w.Destination == "" {
+					t.Error("incomplete source witness", w)
+				}
+			}
+			if before != fmt.Sprintf("%#v", entry) {
+				t.Fatal("formatter mutated original source")
+			}
+		})
+	}
+}
+
+func TestX86LegacyScalarConversionWholeSourceMetadataBoundaries(t *testing.T) {
+	for _, entry := range scalarConversion12OriginalEntries(t) {
+		for _, field := range []string{"kind", "row-count", "original-arity", "selected-arity", "original-offset", "selected-offset", "original-stride", "selected-stride", "selected-index", "escape-negative", "escape-overflow", "prefix", "short", "extra", "nonbyte"} {
+			t.Run(entry.Opcode+"/"+field, func(t *testing.T) {
+				changed, row := entry, entry.Rows[0]
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				changed.OpBytes = append([]string(nil), entry.OpBytes...)
+				maxInt := int(^uint(0) >> 1)
+				switch field {
+				case "kind":
+					changed.Kind = "reserved"
+				case "row-count":
+					changed.Rows = append(changed.Rows, row)
+				case "original-arity":
+					changed.Rows[0].Classes = []string{strings.Join(row.Classes, ",")}
+				case "selected-arity":
+					row.Classes = []string{strings.Join(row.Classes, ",")}
+				case "original-offset":
+					changed.Rows[0].UnmatchedOffset = -maxInt - 1
+				case "selected-offset":
+					row.UnmatchedOffset = maxInt
+				case "original-stride":
+					changed.Rows[0].ZOffset = -maxInt - 1
+				case "selected-stride":
+					row.ZOffset = maxInt
+				case "selected-index":
+					row.RowIndex = maxInt
+				case "escape-negative":
+					changed.EscapeAdjustment = -1
+				case "escape-overflow":
+					changed.EscapeAdjustment = maxInt
+				case "prefix":
+					changed.Prefix = "P32"
+				case "short":
+					changed.OpBytes = nil
+				case "extra":
+					changed.OpBytes = append(changed.OpBytes, "0")
+				case "nonbyte":
+					changed.OpBytes[len(changed.OpBytes)-1] = "0x100"
+				}
+				defer func() {
+					if failure := recover(); failure != nil {
+						t.Errorf("SCALAR_CONVERSION_METADATA_PANIC: %v", failure)
+					}
+				}()
+				if _, err := x86PackedLegacyRowWitnesses(changed, row); err == nil {
+					t.Error("SCALAR_CONVERSION_MALFORMED_ACCEPTED", field)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_logical_test.go b/internal/goasmrules/x86_witness_logical_test.go
new file mode 100644
index 000000000..7e47c266c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_logical_test.go
@@ -0,0 +1,109 @@
+package goasmrules
+
+import (
+	"bytes"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func TestX86PackedLogicalRowsShareBinaryWitnesses(t *testing.T) {
+	x86CheckPackedRowInventory(t, X86PackedLogicalRows,
+		`^(V?P(ANDN?|OR|XOR)(D|Q)?|V?(ANDN?|OR|XOR)(PS|PD))$`,
+		`(D|Q|PS|PD)$`, x86PackedRowCounts{
+			names: 32, mmx: 4, broadcast: 144,
+			rows: [3]int{12, 24, 96}, formats: [3]int{24, 48, 432}, widths: [3]int{192, 168, 144},
+		})
+}
+
+func TestX86PackedLogicalLegacyPrefixAxes(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []struct {
+		name string
+		want []byte
+	}{
+		{"ANDPS", []byte{0x0f, 0x54, 0xc8}},
+		{"ANDPD", []byte{0x66, 0x0f, 0x54, 0xc8}},
+		{"XORPD", []byte{0x66, 0x0f, 0x57, 0xc8}},
+		{"PAND", []byte{0x66, 0x0f, 0xdb, 0xc8}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			for _, entry := range legacy.Optab {
+				if entry.Opcode != row.name {
+					continue
+				}
+				operand := entry.Rows[len(entry.Rows)-1]
+				witnesses, err := x86PackedLegacyRowWitnesses(entry, operand)
+				if err != nil || len(witnesses) != 2 || !bytes.Equal(witnesses[0].Encoding, row.want) {
+					t.Fatalf("official legacy prefix bytes: %+v / %v, want %x", witnesses, err, row.want)
+				}
+				entry.Prefix = "Pf3"
+				if _, err := x86PackedLegacyRowWitnesses(entry, operand); err == nil {
+					t.Fatal("unmodeled mandatory prefix accepted")
+				}
+				return
+			}
+			t.Fatal("missing official opcode", row.name)
+		})
+	}
+}
+
+func TestX86PackedLogicalAVXPrefixAndTableAxes(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []struct {
+		name string
+		row  int
+		want []byte
+	}{
+		{"VANDPS", 0, []byte{0xc5, 0xf0, 0x54, 0xd0}},
+		{"VANDPD", 0, []byte{0xc5, 0xf1, 0x54, 0xd0}},
+		{"VPAND", 0, []byte{0xc5, 0xf1, 0xdb, 0xd0}},
+		{"VANDPS", 2, []byte{0x62, 0xa1, 0x74, 0x00, 0x54, 0xd0}},
+		{"VANDPD", 2, []byte{0x62, 0xa1, 0xf5, 0x00, 0x54, 0xd0}},
+	} {
+		t.Run(row.name+"/"+strconv.Itoa(row.row), func(t *testing.T) {
+			for _, rule := range avx {
+				if rule.Opcode != row.name || rule.RowIndex != row.row {
+					continue
+				}
+				witnesses, err := x86PackedAVXRowWitnesses(rule)
+				if err != nil || len(witnesses) < 2 || !bytes.Equal(witnesses[0].Encoding, row.want) {
+					t.Fatalf("official AVX prefix/table bytes: %+v / %v, want %x", witnesses, err, row.want)
+				}
+				for _, suffix := range []string{" | futurePrefix", " | vexF3", " | evexF2"} {
+					changed := rule
+					changed.OpBytes = append([]string(nil), rule.OpBytes...)
+					changed.OpBytes[rule.EncodingOffset] += suffix
+					if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+						t.Fatal("unmodeled or contradictory mandatory prefix accepted", suffix)
+					}
+				}
+				if row.row == 2 {
+					rule.Ytab = "_yvaddsubpd"
+					if _, err := x86PackedAVXRowWitnesses(rule); err == nil {
+						t.Fatal("VEX-only grammar acquired EVEX")
+					}
+				}
+				return
+			}
+			t.Fatal("missing official row", row.name, row.row)
+		})
+	}
+}
+
+func TestX86PackedBinaryRejectsVEX512(t *testing.T) {
+	rule := X86AVXRule{
+		Opcode: "VPAND", Ytab: "_yvaddsubpd", Prefix: "Pavx", ZCase: "Zvex_rm_v_r", ZOffset: 2,
+		Classes: []string{"Yzm", "Yzr", "Yzr"},
+		OpBytes: []string{"avxEscape | vex512 | vex66 | vex0F | vexW0", "0xdb"},
+	}
+	if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+		t.Fatal("VEX acquired an impossible Z/512-bit encoding", witnesses, err)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_mask_blend_test.go b/internal/goasmrules/x86_witness_mask_blend_test.go
new file mode 100644
index 000000000..8c006be47
--- /dev/null
+++ b/internal/goasmrules/x86_witness_mask_blend_test.go
@@ -0,0 +1,25 @@
+package goasmrules
+
+import "testing"
+
+func TestX86PackedMaskBlendRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedMaskBlendRows,
+		`^(VBLENDM(PS|PD)|VPBLENDM[BWDQ])$`, `^(VBLENDM(PS|PD)|VPBLENDM[DQ])$`, x86PackedRowCounts{
+			names: 6, broadcast: 36,
+			rows: [3]int{0, 0, 36}, formats: [3]int{0, 0, 144}, widths: [3]int{48, 48, 48},
+		})
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VBLENDMPS X16,X17,X18", []byte{0x62, 0xa2, 0x75, 0x00, 0x65, 0xd0}},
+		{"VBLENDMPS.BCST.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0x75, 0xd1, 0x65, 0x10}},
+		{"VBLENDMPD (AX),Y17,Y18", []byte{0x62, 0xe2, 0xf5, 0x20, 0x65, 0x10}},
+		{"VBLENDMPD.BCST (AX),X17,K1,X18", []byte{0x62, 0xe2, 0xf5, 0x11, 0x65, 0x10}},
+		{"VPBLENDMB X16,X17,K1,X18", []byte{0x62, 0xa2, 0x75, 0x01, 0x66, 0xd0}},
+		{"VPBLENDMB.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0x75, 0xc1, 0x66, 0x10}},
+		{"VPBLENDMW Y16,Y17,Y18", []byte{0x62, 0xa2, 0xf5, 0x20, 0x66, 0xd0}},
+		{"VPBLENDMW.Z Z16,Z17,K1,Z18", []byte{0x62, 0xa2, 0xf5, 0xc1, 0x66, 0xd0}},
+		{"VPBLENDMD.BCST (AX),Y17,Y18", []byte{0x62, 0xe2, 0x75, 0x30, 0x64, 0x10}},
+		{"VPBLENDMD.Z X16,X17,K1,X18", []byte{0x62, 0xa2, 0x75, 0x81, 0x64, 0xd0}},
+		{"VPBLENDMQ Z16,Z17,Z18", []byte{0x62, 0xa2, 0xf5, 0x40, 0x64, 0xd0}},
+		{"VPBLENDMQ.BCST.Z (AX),X17,K1,X18", []byte{0x62, 0xe2, 0xf5, 0x91, 0x64, 0x10}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_media_x87_remainder.go b/internal/goasmrules/x86_witness_media_x87_remainder.go
new file mode 100644
index 000000000..d0d00a7c0
--- /dev/null
+++ b/internal/goasmrules/x86_witness_media_x87_remainder.go
@@ -0,0 +1,200 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+)
+
+func x86LegacyMediaX87Schema(table string) []string {
+	switch table {
+	case "yxcvm1":
+		return []string{"Zm_r_xm/2/Yxm,Yxr", "Zm_r_xm/2/Yxm,Ymr"}
+	case "yxcvm2":
+		return []string{"Zm_r_xm/2/Yxm,Yxr", "Zm_r_xm/2/Ymm,Yxr"}
+	case "ylddqu":
+		return []string{"Zm_r/1/Ym,Yxr"}
+	case "yxr":
+		return []string{"Zm_r_xm/1/Yxr,Yxr"}
+	case "ymr":
+		return []string{"Zm_r/1/Ymr,Ymr"}
+	case "yxr_ml":
+		return []string{"Zr_m_xm/1/Yxr,Yml"}
+	case "ymr_ml":
+		return []string{"Zr_m_xm/1/Ymr,Yml"}
+	case "ymrxr":
+		return []string{"Zm_r/1/Ymr,Yxr", "Zm_r_xm/1/Yxm,Yxr"}
+	case "ymmxmm0f38":
+		return []string{"Zlitm_r/3/Ymm,Ymr", "Zlitm_r/5/Yxm,Yxr"}
+	case "ymshuf":
+		return []string{"Zibm_r/2/Yi8,Ymm,Ymr"}
+	case "yfxch":
+		return []string{"Zo_m/2/Yf0,Yrf", "Zm_o/2/Yrf,Yf0"}
+	case "ystsw":
+		return []string{"Zo_m/2/Ym", "Zlit/1/Yax"}
+	}
+	return nil
+}
+
+// X86LegacyMediaX87Rows retains complete original source tables, including
+// physical MMX, implicit-address, status and Go-accepted invalid-machine-code
+// forms. Source bytes grant none of their numerical or native permissions.
+func X86LegacyMediaX87Rows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("media/x87 source view requires an explicit Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if x86LegacyMediaX87Schema(entry.Ytab) == nil {
+			continue
+		}
+		for _, row := range entry.Rows {
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			if seen[id] {
+				return nil, fmt.Errorf("duplicate original media/x87 source row %s", id)
+			}
+			seen[id] = true
+			witnesses, err := x86LegacyMediaX87RowWitnesses(entry, row)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", id, err)
+			}
+			result = append(result, X86ScalarRMWRow{ID: id, Opcode: entry.Opcode, Witnesses: witnesses})
+		}
+	}
+	if len(result) != 31 {
+		return nil, fmt.Errorf("incomplete original media/x87 source tables: rows=%d", len(result))
+	}
+	return result, nil
+}
+
+// Complete-source validation precedes all offsets. Prefix roles, unmatched
+// strides, consumed spans and carriers are independent of numerical semantics.
+func x86LegacyMediaX87Encoding(entry X86LegacyOpcode, row X86LegacyOperand) ([]byte, error) {
+	fail := func() ([]byte, error) { return nil, fmt.Errorf("unmodeled complete media/x87 source grammar") }
+	if entry.Kind != "encoding" || entry.Opcode == "" {
+		return fail()
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, x86LegacyMediaX87Schema(entry.Ytab)); err != nil {
+		return nil, err
+	}
+	prefix, ok := map[string][]byte{"Px": {}, "Pm": {0x0f}, "Pe": {0x66},
+		"Pf2": {0xf2, 0x0f}, "Pf3": {0xf3, 0x0f}, "Pq4": {0x66, 0x0f, 0x38}}[entry.Prefix]
+	if !ok {
+		return fail()
+	}
+	atoms := make([]byte, len(entry.OpBytes))
+	for index, token := range entry.OpBytes {
+		value, err := strconv.ParseUint(token, 0, 8)
+		if err != nil && (entry.Ytab == "yxcvm1" || entry.Ytab == "yxcvm2") && entry.Prefix == "Px" && (index == 0 || index == 2) {
+			var found bool
+			atoms[index], found = map[string]byte{"Pe": 0x66, "Pm": 0x0f, "Pf2": 0xf2, "Pf3": 0xf3}[token]
+			if !found {
+				return fail()
+			}
+		} else if err != nil {
+			return fail()
+		} else {
+			atoms[index] = byte(value)
+		}
+	}
+	escape := 0
+	if entry.Ytab == "ymmxmm0f38" {
+		escape = 1
+	}
+	if len(atoms) == 0 || entry.EscapeAdjustment != escape || (atoms[0] == 0x0f) != (escape == 1) {
+		return fail()
+	}
+	opcode := func(value byte) bool { return value != 0 && value != 0x0f }
+	mediaPrefix := func(value byte) bool { return value == 0x66 || value == 0x0f || value == 0xf2 || value == 0xf3 }
+	switch entry.Ytab {
+	case "yxcvm1", "yxcvm2":
+		if len(atoms) != 4 {
+			return fail()
+		}
+		if entry.Prefix == "Px" && mediaPrefix(atoms[0]) && mediaPrefix(atoms[2]) && opcode(atoms[1]) && opcode(atoms[3]) {
+			offset := row.UnmatchedOffset
+			prefix = []byte{atoms[offset], 0x0f}
+			if atoms[offset] == 0x0f {
+				prefix = []byte{0x0f}
+			}
+			prefix = append(prefix, atoms[offset+1])
+		} else if entry.Ytab == "yxcvm2" && entry.Prefix == "Pm" && atoms[1] == 0 && atoms[3] == 0 && opcode(atoms[0]) && opcode(atoms[2]) {
+			prefix = append(prefix, atoms[row.UnmatchedOffset])
+		} else {
+			return fail()
+		}
+	case "ymmxmm0f38":
+		if entry.Prefix != "Px" || len(atoms) != 9 || atoms[0] != 0x0f || atoms[1] != 0x38 || !opcode(atoms[2]) || atoms[3] != 0 ||
+			atoms[4] != 0x66 || atoms[5] != 0x0f || atoms[6] != 0x38 || !opcode(atoms[7]) || atoms[8] != 0 {
+			return fail()
+		}
+		end := row.UnmatchedOffset + row.ZOffset
+		if row.RowIndex == 0 {
+			end++ // The selected leading 0F is also part of the literal span.
+		}
+		prefix = atoms[row.UnmatchedOffset : end-1]
+	case "ymshuf":
+		if entry.Prefix != "Pm" || len(atoms) != 2 || !opcode(atoms[0]) || atoms[1] != 0 {
+			return fail()
+		}
+		prefix = append(prefix, atoms[0])
+	case "yfxch", "ystsw":
+		if entry.Prefix != "Px" || len(atoms) != 4 || atoms[0] < 0xd8 || atoms[0] > 0xdf || atoms[1] > 7 || atoms[2] < 0xd8 || atoms[2] > 0xdf ||
+			entry.Ytab == "yfxch" && atoms[3] > 7 || entry.Ytab == "ystsw" && atoms[3] == 0 {
+			return fail()
+		}
+		return atoms[row.UnmatchedOffset : row.UnmatchedOffset+2], nil
+	default:
+		count := 1
+		allowed := entry.Prefix == "Pm"
+		switch entry.Ytab {
+		case "ylddqu":
+			allowed = entry.Prefix == "Pf2" || entry.Prefix == "Pq4"
+		case "yxr", "yxr_ml":
+			allowed = entry.Prefix == "Pe" || entry.Prefix == "Pm"
+		case "ymrxr":
+			count, allowed = 2, entry.Prefix == "Pf3"
+		}
+		if !allowed || len(atoms) != count {
+			return fail()
+		}
+		for _, atom := range atoms {
+			if !opcode(atom) {
+				return fail()
+			}
+		}
+		if entry.Prefix == "Pe" {
+			prefix = append(prefix, 0x0f)
+		}
+		prefix = append(prefix, atoms[row.UnmatchedOffset])
+	}
+	return prefix, nil
+}
+
+func x86LegacyMediaX87RowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86ScalarRMWWitness, error) {
+	encoding, err := x86LegacyMediaX87Encoding(entry, row)
+	if err != nil {
+		return nil, err
+	}
+	if entry.Ytab == "yfxch" || entry.Ytab == "ystsw" {
+		return x86X87CarrierWitnesses(entry.Opcode, row, encoding[0], encoding[1]), nil
+	}
+	classes := row.Classes
+	immediate := classes[0] == "Yi8"
+	if immediate {
+		classes = classes[1:]
+	}
+	// The MMX-input conversion's memory alternative selects the earlier XMM
+	// row. Other r/m source classes retain both physical carrier alternatives.
+	memorySource := entry.Ytab != "yxcvm2" || row.RowIndex == 0
+	packed := x86LegacyMediaCarrierWitnesses(entry.Opcode, classes, encoding, memorySource)
+	var result []X86ScalarRMWWitness
+	for _, witness := range packed {
+		if immediate {
+			witness.Instruction = entry.Opcode + " $7," + witness.First + "," + witness.Destination
+			witness.Encoding = append(witness.Encoding, 7)
+		}
+		result = append(result, X86ScalarRMWWitness{Instruction: witness.Instruction, Destination: witness.Destination, Encoding: witness.Encoding})
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_media_x87_remainder_test.go b/internal/goasmrules/x86_witness_media_x87_remainder_test.go
new file mode 100644
index 000000000..007a349dc
--- /dev/null
+++ b/internal/goasmrules/x86_witness_media_x87_remainder_test.go
@@ -0,0 +1,312 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These are the complete original source tables. Their shared operand shapes
+// do not grant physical MMX, implicit DI, x87 status or numerical permission.
+func mediaX87OriginalSchema(table string) []string {
+	return map[string][]string{
+		"yxcvm1":     {"Zm_r_xm/2/Yxm,Yxr", "Zm_r_xm/2/Yxm,Ymr"},
+		"yxcvm2":     {"Zm_r_xm/2/Yxm,Yxr", "Zm_r_xm/2/Ymm,Yxr"},
+		"ylddqu":     {"Zm_r/1/Ym,Yxr"},
+		"yxr":        {"Zm_r_xm/1/Yxr,Yxr"},
+		"ymr":        {"Zm_r/1/Ymr,Ymr"},
+		"yxr_ml":     {"Zr_m_xm/1/Yxr,Yml"},
+		"ymr_ml":     {"Zr_m_xm/1/Ymr,Yml"},
+		"ymrxr":      {"Zm_r/1/Ymr,Yxr", "Zm_r_xm/1/Yxm,Yxr"},
+		"ymmxmm0f38": {"Zlitm_r/3/Ymm,Ymr", "Zlitm_r/5/Yxm,Yxr"},
+		"ymshuf":     {"Zibm_r/2/Yi8,Ymm,Ymr"},
+		"yfxch":      {"Zo_m/2/Yf0,Yrf", "Zm_o/2/Yrf,Yf0"},
+		"ystsw":      {"Zo_m/2/Ym", "Zlit/1/Yax"},
+	}[table]
+}
+
+func mediaX87OriginalEntries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts, rows := map[string]int{}, 0
+	var entries []X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		schema := mediaX87OriginalSchema(entry.Ytab)
+		if schema == nil {
+			continue
+		}
+		if entry.Kind != "encoding" || len(entry.Rows) != len(schema) {
+			t.Fatal("complete media/x87 original source table changed", entry)
+		}
+		offset := 0
+		for index, row := range entry.Rows {
+			shape := fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ","))
+			if row.RowIndex != index || row.UnmatchedOffset != offset || shape != schema[index] ||
+				len(row.Classes) != strings.Count(strings.Split(schema[index], "/")[2], ",")+1 {
+				t.Fatal("complete media/x87 original row order or arity changed", entry, row)
+			}
+			offset += row.ZOffset + entry.EscapeAdjustment
+			counts[entry.Ytab]++
+			rows++
+		}
+		entries = append(entries, entry)
+	}
+	want := map[string]int{"yxcvm1": 8, "yxcvm2": 4, "ylddqu": 2, "yxr": 3,
+		"ymr": 1, "yxr_ml": 3, "ymr_ml": 1, "ymrxr": 2, "ymmxmm0f38": 2,
+		"ymshuf": 1, "yfxch": 2, "ystsw": 2}
+	if rows != 31 || len(entries) != 21 || !reflect.DeepEqual(counts, want) {
+		t.Fatal("complete media/x87 original source denominator changed", rows, len(entries), counts)
+	}
+	return entries
+}
+
+// The initial feature RED called existing transport, rather than a missing
+// new API. Keep that old source-consumer boundary observable after adding the
+// explicit projection; no physical-state permission follows from either view.
+func mediaX87ExistingWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86ScalarRMWWitness, error) {
+	if entry.Ytab == "yfxch" || entry.Ytab == "ystsw" {
+		return x86X87RowWitnesses(entry, row)
+	}
+	if entry.Ytab == "yxr" {
+		return x86LegacyExplicitSIMDRowWitnesses(entry, row)
+	}
+	packed, err := x86PackedLegacyRowWitnesses(entry, row)
+	var result []X86ScalarRMWWitness
+	for _, witness := range packed {
+		result = append(result, X86ScalarRMWWitness{
+			Instruction: witness.Instruction, Destination: witness.Destination, Encoding: witness.Encoding,
+		})
+	}
+	return result, err
+}
+
+func TestX86LegacyMediaX87CompleteOriginalSourceInventory(t *testing.T) {
+	mediaX87OriginalEntries(t)
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"", "arm64", "wasm"} {
+		if rows, err := X86LegacyMediaX87Rows(catalog, arch); err == nil || len(rows) != 0 {
+			t.Fatal("source view accepted an absent or foreign physical Go mode", arch, err)
+		}
+	}
+	mediaX87CapturedPublicViews(t, catalog)
+}
+
+func mediaX87CapturedPublicViews(t *testing.T, catalog X86LegacyCatalog) {
+	t.Helper()
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index, entry := range catalog.Optab {
+		view := X86PackedNumericConversionRows
+		atom := 3 // The unselected MMX conversion opcode.
+		if entry.Ytab == "ymmxmm0f38" {
+			view, atom = X86PackedHorizontalIntegerRows, 2
+		} else if entry.Ytab != "yxcvm1" && entry.Ytab != "yxcvm2" {
+			continue
+		} else if entry.Prefix == "Pm" {
+			atom = 2 // This source uses a zero stride placeholder at atom3.
+		}
+		before, err := view(catalog, avx)
+		if err != nil {
+			t.Fatal("original public view must pass before metadata mutations", entry.Opcode, err)
+		}
+		for _, field := range []string{"empty-expression", "unselected-byte", "captured-expression-without-rows", "missing-expression-invalid-original-index", "neither-capture-field"} {
+			t.Run("public-source/"+entry.Opcode+"/"+field, func(t *testing.T) {
+				changed := catalog
+				changed.Optab = append([]X86LegacyOpcode(nil), catalog.Optab...)
+				item := &changed.Optab[index]
+				item.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				item.OpBytes = append([]string(nil), entry.OpBytes...)
+				switch field {
+				case "empty-expression":
+					item.OpcodeExpression = ""
+				case "unselected-byte":
+					item.OpBytes[atom] = "not-a-byte"
+				case "captured-expression-without-rows":
+					item.Rows = nil
+				case "missing-expression-invalid-original-index":
+					item.OpcodeExpression, item.Rows[0].RowIndex = "", -1
+				case "neither-capture-field":
+					item.OpcodeExpression, item.Rows = "", nil
+				}
+				got, err := view(changed, avx)
+				if field == "empty-expression" {
+					if err != nil || !reflect.DeepEqual(got, before) {
+						t.Fatal("existing empty-expression whole-row contract changed", err)
+					}
+				} else if err == nil || len(got) != 0 {
+					t.Fatal("incomplete or corrupt capture acquired public source-view authority", field, got, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyMediaX87ExistingTransportCompleteOriginalRows(t *testing.T) {
+	for _, entry := range mediaX87OriginalEntries(t) {
+		for _, row := range entry.Rows {
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				before := fmt.Sprintf("%#v", entry)
+				witnesses, err := x86LegacyMediaX87RowWitnesses(entry, row)
+				if err != nil || len(witnesses) == 0 {
+					t.Fatal("MEDIA_X87_COMPLETE_SOURCE_TRANSPORT_FEATURE_GAP", err)
+				}
+				for _, witness := range witnesses {
+					if witness.Instruction == "" || witness.Destination == "" || len(witness.Encoding) == 0 {
+						t.Fatal("source-only witness lost its original operand roles", entry, row, witness)
+					}
+				}
+				if before != fmt.Sprintf("%#v", entry) {
+					t.Fatal("source formatter mutated the original table")
+				}
+				previous, previousErr := mediaX87ExistingWitnesses(entry, row)
+				old := (entry.Ytab == "yxcvm1" || entry.Ytab == "yxcvm2") && row.RowIndex == 0 ||
+					entry.Ytab == "ymmxmm0f38" && row.RowIndex == 1 || entry.Ytab == "yxr" && entry.Prefix == "Pm"
+				if old && (previousErr != nil || !reflect.DeepEqual(witnesses, previous)) || !old && (previousErr == nil || len(previous) != 0) {
+					t.Fatal("explicit source projection changed the original packed/x87 consumer boundary", previousErr, previous)
+				}
+				withoutExpression := entry
+				withoutExpression.OpcodeExpression = ""
+				if got, err := x86LegacyMediaX87RowWitnesses(withoutExpression, row); err != nil || !reflect.DeepEqual(got, witnesses) {
+					t.Fatal("whole-row validation incorrectly required a source expression", err)
+				}
+				if old && entry.Ytab != "yxr" {
+					// Historical pure-format fixtures have neither captured
+					// rows nor an expression. Retain their old partial result;
+					// they cannot produce a complete-source view or NUM facts.
+					withoutExpression.Rows = nil
+					got, err := mediaX87ExistingWitnesses(withoutExpression, row)
+					if err != nil || !reflect.DeepEqual(got, previous) {
+						t.Fatal("uncaptured synthetic format contract changed", err)
+					}
+					if got, err := x86LegacyMediaX87RowWitnesses(withoutExpression, row); err == nil || len(got) != 0 {
+						t.Fatal("partial synthetic fixture acquired complete-source authority", got, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func mediaX87RequireMetadataRefusal(t *testing.T, entry X86LegacyOpcode, row X86LegacyOperand, field string) {
+	t.Helper()
+	for _, consumer := range []struct {
+		name string
+		read func(X86LegacyOpcode, X86LegacyOperand) ([]X86ScalarRMWWitness, error)
+	}{{"original", mediaX87ExistingWitnesses}, {"complete", x86LegacyMediaX87RowWitnesses}} {
+		func() {
+			defer func() {
+				if caught := recover(); caught != nil {
+					t.Errorf("MEDIA_X87_METADATA_PANIC %s/%d/%s: consumer=%s %v", entry.Opcode, row.RowIndex, field, consumer.name, caught)
+				}
+			}()
+			if got, err := consumer.read(entry, row); err == nil || len(got) != 0 {
+				t.Errorf("MEDIA_X87_METADATA_ACCEPTED %s/%d/%s: consumer=%s %v", entry.Opcode, row.RowIndex, field, consumer.name, got)
+			}
+		}()
+	}
+}
+
+func TestX86LegacyMediaX87CompleteOriginalMetadataBoundaries(t *testing.T) {
+	for _, entry := range mediaX87OriginalEntries(t) {
+		for _, original := range entry.Rows {
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, original.RowIndex), func(t *testing.T) {
+				for _, field := range []string{
+					"kind", "row-count", "original-arity", "selected-arity", "original-comma-arity", "selected-comma-arity",
+					"original-class", "selected-class", "original-index", "selected-index", "original-zcase", "selected-zcase",
+					"negative-stride", "overflow-stride", "selected-stride", "negative-offset", "selected-offset",
+					"negative-escape", "overflow-escape", "prefix", "opcode-expression", "empty-payload", "truncated-payload", "extra-payload",
+					"captured-expression-without-rows", "missing-expression-invalid-original-index",
+				} {
+					changed, row := entry, original
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					maxInt := int(^uint(0) >> 1)
+					switch field {
+					case "kind":
+						changed.Kind = "reserved"
+					case "row-count":
+						changed.Rows = append(changed.Rows, original)
+					case "original-arity":
+						changed.Rows[0].Classes = append(append([]string(nil), entry.Rows[0].Classes...), "Ynone")
+					case "selected-arity":
+						row.Classes = append(append([]string(nil), row.Classes...), "Ynone")
+					case "original-comma-arity":
+						changed.Rows[0].Classes = []string{strings.Join(entry.Rows[0].Classes, ",")}
+						if len(entry.Rows[0].Classes) == 1 {
+							changed.Rows[0].Classes = nil
+						}
+					case "selected-comma-arity":
+						row.Classes = []string{strings.Join(row.Classes, ",")}
+						if len(original.Classes) == 1 {
+							row.Classes = nil
+						}
+					case "original-class":
+						changed.Rows[0].Classes = append([]string(nil), entry.Rows[0].Classes...)
+						changed.Rows[0].Classes[0] = "Yinvalid"
+					case "selected-class":
+						row.Classes = append([]string(nil), row.Classes...)
+						row.Classes[0] = "Yinvalid"
+					case "original-index":
+						changed.Rows[0].RowIndex = -1
+					case "selected-index":
+						row.RowIndex = maxInt
+					case "original-zcase":
+						changed.Rows[0].ZCase = "Zinvalid"
+					case "selected-zcase":
+						row.ZCase = "Zinvalid"
+					case "negative-stride":
+						changed.Rows[0].ZOffset = -maxInt - 1
+					case "overflow-stride":
+						changed.Rows[0].ZOffset = maxInt
+					case "selected-stride":
+						row.ZOffset = maxInt
+					case "negative-offset":
+						changed.Rows[0].UnmatchedOffset = -maxInt - 1
+					case "selected-offset":
+						row.UnmatchedOffset = maxInt
+					case "negative-escape":
+						changed.EscapeAdjustment = -1
+					case "overflow-escape":
+						changed.EscapeAdjustment = maxInt
+					case "prefix":
+						changed.Prefix = "Pinvalid"
+					case "opcode-expression":
+						changed.OpcodeExpression = "obj.ANOP"
+					case "captured-expression-without-rows":
+						changed.Rows = nil
+					case "missing-expression-invalid-original-index":
+						changed.OpcodeExpression = ""
+						changed.Rows[0].RowIndex = -1
+					case "empty-payload":
+						changed.OpBytes = nil
+					case "truncated-payload":
+						changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+					case "extra-payload":
+						changed.OpBytes = append(changed.OpBytes, "0x90")
+					}
+					mediaX87RequireMetadataRefusal(t, changed, row, field)
+				}
+				// Every original atom is validated, including an unselected
+				// row's prefix, opcode, field fragment and literal terminator.
+				for index := range entry.OpBytes {
+					for _, atom := range []string{"not-a-byte", "0x100"} {
+						changed := entry
+						changed.OpBytes = append([]string(nil), entry.OpBytes...)
+						changed.OpBytes[index] = atom
+						mediaX87RequireMetadataRefusal(t, changed, original, fmt.Sprintf("payload-atom-%d-%s", index, atom))
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_move_remainder.go b/internal/goasmrules/x86_witness_move_remainder.go
new file mode 100644
index 000000000..46441167f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_move_remainder.go
@@ -0,0 +1,336 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Original operand transport, not initialized values or native storage. The official row and its payload remain the encoding authority.
+type x86MoveRemainderFormat struct {
+	width, tuple     int
+	rm, reg, vvvv    int
+	classes          []string
+	masked, zeroable bool
+	encoding         x86PackedAVXOpcode
+}
+
+func x86MoveRemainderTable(table string) bool {
+	switch table {
+	case "_yvlddqu", "_yvmaskmovdqu", "_yvmaskmovpd", "_yvmovd",
+		"_yvmovhlps", "_yvmovhpd", "_yvmovmskpd", "_yvmovntdq",
+		"_yvmovntdqa", "_yvmovq", "_yvmovsd":
+		return true
+	}
+	return false
+}
+
+func x86MoveRemainderFormatForRule(rule X86AVXRule) (x86MoveRemainderFormat, error) {
+	f := x86MoveRemainderFormat{width: 128, rm: 0, vvvv: -1}
+	fail := func() (x86MoveRemainderFormat, error) {
+		return f, fmt.Errorf("move row differs from its original finite transport")
+	}
+	if !x86MoveRemainderTable(rule.Ytab) || rule.Prefix != "Pavx" || rule.Opcode == "" ||
+		rule.EncodingOffset < 0 || rule.EncodingOffset >= len(rule.OpBytes) {
+		return fail()
+	}
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	kind, stride := "vex", 2
+	if evex {
+		kind, stride = "evex", 3
+	}
+	header := rule.OpBytes[rule.EncodingOffset]
+	if hasEncodingTerm(header, kind+"256") {
+		f.width = 256
+	} else if hasEncodingTerm(header, kind+"512") {
+		f.width = 512
+	}
+	v := map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[f.width]
+	if evex && f.width != 512 {
+		v += "Evex"
+	}
+	index, offset, extent := rule.RowIndex, rule.EncodingOffset, 0
+	wantIndex, wantOffset, wantStride := 0, 0, stride
+	store, tupleAttribute, zeroAttribute := false, evex, false
+	zcase := kind + "_rm_v_r"
+	classes := ""
+	pp, w, opcodeMap := "", "W0", "0F"
+	switch rule.Ytab {
+	case "_yvlddqu", "_yvmovmskpd":
+		if evex || f.width == 512 {
+			return fail()
+		}
+		wantIndex, wantOffset, extent = f.width/256, 2*(f.width/256), 4
+		classes, f.tuple = "Ym,"+v, f.width/8
+		pp = "F2"
+		if rule.Ytab == "_yvmovmskpd" {
+			classes, f.tuple, pp = v+",Yrl", 0, "66"
+			if strings.HasSuffix(rule.Opcode, "PS") {
+				pp = ""
+			}
+		}
+	case "_yvmaskmovdqu":
+		if evex || f.width != 128 {
+			return fail()
+		}
+		classes, pp, extent = v+","+v, "66", 2
+	case "_yvmaskmovpd":
+		if evex || f.width == 512 || index < 0 || index > 3 {
+			return fail()
+		}
+		store, f.tuple, f.vvvv, pp, opcodeMap = index < 2, f.width/8, 1, "66", "0F38"
+		wantIndex = f.width / 256
+		if !store {
+			wantIndex += 2
+		}
+		wantOffset, extent = 2*wantIndex, 8
+		classes = "Ym," + v + "," + v
+		if store {
+			classes = v + "," + v + ",Ym"
+		}
+		if strings.HasSuffix(rule.Opcode, "Q") {
+			w = "W1"
+		}
+	case "_yvmovntdq", "_yvmovntdqa":
+		if !evex && f.width == 512 {
+			return fail()
+		}
+		wantIndex, wantOffset, extent = f.width/256, 2*(f.width/256), 13
+		if evex {
+			wantIndex += 2
+			wantOffset = 4 + 3*(wantIndex-2)
+		}
+		store, f.tuple, pp = rule.Ytab == "_yvmovntdq", f.width/8, "66"
+		classes = "Ym," + v
+		if store {
+			classes = v + ",Ym"
+			if strings.HasSuffix(rule.Opcode, "PS") {
+				pp = ""
+			} else if evex && strings.HasSuffix(rule.Opcode, "PD") {
+				w = "W1"
+			}
+		} else {
+			opcodeMap = "0F38"
+		}
+	case "_yvmovhlps":
+		if f.width != 128 {
+			return fail()
+		}
+		classes, f.vvvv, tupleAttribute, extent = v+","+v+","+v, 1, false, 5
+		if evex {
+			wantIndex, wantOffset = 1, 2
+		}
+	case "_yvmovhpd", "_yvmovd":
+		if f.width != 128 || index < 0 || index > 3 || evex != (index >= 2) {
+			return fail()
+		}
+		store, wantIndex, extent = index%2 == 0, index, 10
+		wantOffset = []int{0, 2, 4, 7}[index]
+		f.tuple = 8
+		transfer := "Ym"
+		if rule.Ytab == "_yvmovd" {
+			transfer, f.tuple, pp = "Yml", 4, "66"
+		} else if strings.HasSuffix(rule.Opcode, "PD") {
+			pp = "66"
+			if evex {
+				w = "W1"
+			}
+		}
+		classes = transfer + "," + v
+		if store {
+			classes = v + "," + transfer
+		} else if rule.Ytab == "_yvmovhpd" {
+			classes, f.vvvv = transfer+","+v+","+v, 1
+		}
+	case "_yvmovq":
+		if f.width != 128 || index < 0 || index > 7 || evex != (index >= 4) {
+			return fail()
+		}
+		local := index % 4
+		store, wantIndex, f.tuple, pp, w, extent = local < 2, index, 8, "66", "W1", 20
+		wantOffset = 2 * index
+		if evex {
+			wantOffset = 8 + 3*(index-4)
+		} else if local == 1 {
+			w = "W0"
+		}
+		transfer := "Yml"
+		if local%2 != 0 {
+			transfer = "Yxm"
+			if evex {
+				transfer += "Evex"
+			}
+		}
+		if local == 3 {
+			pp = "F3"
+			if !evex {
+				w = "W0"
+			}
+		}
+		classes = transfer + "," + v
+		if store {
+			classes = v + "," + transfer
+		}
+	case "_yvmovsd":
+		if f.width != 128 || index < 0 || index > 11 || evex != (index >= 4) {
+			return fail()
+		}
+		wantIndex, extent = index, 20
+		wantOffset = []int{0, 2, 4, 6, 8, 8, 11, 11, 14, 14, 17, 17}[index]
+		if evex && index%2 == 0 {
+			wantStride = 0
+		}
+		pp, f.tuple = "F3", 4
+		if strings.HasSuffix(rule.Opcode, "SD") {
+			pp, f.tuple = "F2", 8
+			if evex {
+				w = "W1"
+			}
+		}
+		formats := []string{
+			v + "," + v + "," + v, v + ",Ym", "Ym," + v, v + "," + v + "," + v,
+			v + "," + v + "," + v, v + "," + v + ",Yknot0," + v,
+			v + ",Ym", v + ",Yknot0,Ym", "Ym," + v, "Ym,Yknot0," + v,
+			v + "," + v + "," + v, v + "," + v + ",Yknot0," + v,
+		}
+		classes = formats[index]
+		store = index == 0 || index == 1 || index >= 4 && index <= 7
+		f.masked = index == 5 || index == 7 || index == 9 || index == 11
+		if index == 0 || index == 3 || index == 4 || index == 5 || index >= 10 {
+			f.vvvv, tupleAttribute = 1, false
+		}
+		zeroAttribute = evex && index != 6 && index != 7
+	default:
+		return fail()
+	}
+	if store {
+		zcase = kind + "_r_v_rm"
+	}
+	f.classes = strings.Split(classes, ",")
+	f.reg = len(f.classes) - 1
+	if store {
+		f.rm, f.reg = len(f.classes)-1, 0
+	}
+	if f.masked {
+		if f.vvvv >= 0 {
+			zcase = strings.Replace(zcase, "_v_", "_v_k_", 1)
+		} else {
+			zcase = strings.Replace(zcase, "_v_", "_k_", 1)
+		}
+	}
+	if index != wantIndex || offset != wantOffset || rule.ZOffset != wantStride || len(rule.OpBytes) != extent ||
+		rule.ZCase != "Z"+zcase || strings.Join(rule.Classes, ",") != classes {
+		return fail()
+	}
+	atoms := []string{"avxEscape", kind + strconv.Itoa(f.width), kind + opcodeMap, kind + w}
+	if pp != "" {
+		atoms = append(atoms, kind+pp)
+	}
+	if _, err := x86PackedEncodingAtoms(header, atoms, nil); err != nil {
+		return fail()
+	}
+	if evex {
+		var attributes []string
+		if tupleAttribute {
+			attributes = append(attributes, "evexN"+strconv.Itoa(f.tuple))
+		}
+		if zeroAttribute {
+			attributes = append(attributes, "evexZeroingEnabled")
+		}
+		if len(attributes) == 0 {
+			attributes = []string{"0"}
+		}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], attributes, nil); err != nil {
+			return fail()
+		}
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+stride-1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.zeroable = f.masked && zeroAttribute
+	f.encoding = x86PackedAVXOpcode{kind: kind, mapByte: 1, length: byte(f.width / 256), opcode: byte(opcode)}
+	if opcodeMap == "0F38" {
+		f.encoding.mapByte = 2
+	}
+	if w == "W1" {
+		f.encoding.wBit = 0x80
+	}
+	f.encoding.pp = map[string]byte{"": 0, "66": 1, "F3": 2, "F2": 3}[pp]
+	return f, nil
+}
+
+func x86MoveRemainderRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86MoveRemainderFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	bank := 0
+	if f.encoding.kind == "evex" {
+		bank = 16 // Force the late EVEX row instead of an earlier VEX match.
+	}
+	rmClass := f.classes[f.rm]
+	var witnesses []X86PackedBinaryWitness
+	for _, memory := range []bool{false, true} {
+		if memory && rmClass != "Ym" && rmClass != "Yml" && !strings.Contains(rmClass, "mEvex") && rmClass != "Yxm" ||
+			!memory && rmClass == "Ym" {
+			continue
+		}
+		for _, zeroing := range []bool{false, true} {
+			if zeroing && !f.zeroable {
+				continue
+			}
+			args, indices := make([]string, len(f.classes)), make([]int, len(f.classes))
+			for i, class := range f.classes {
+				indices[i] = bank + i
+				switch class {
+				case "Yknot0":
+					args[i], indices[i] = "K1", 1
+				case "Yml", "Yrl":
+					args[i], indices[i] = "CX", 1
+				default:
+					args[i] = fmt.Sprint(map[int]string{128: "X", 256: "Y", 512: "Z"}[f.width], indices[i])
+				}
+			}
+			if memory {
+				args[f.rm], indices[f.rm] = "(AX)", 0
+			}
+			reg, rm := indices[f.reg], indices[f.rm]
+			modrm := byte(0xc0 | (reg&7)<<3 | rm&7)
+			if memory {
+				modrm &^= 0xc0
+			}
+			vvvv, p0, p2 := byte(0x78), byte(0), f.encoding.length<<5|8
+			if f.vvvv >= 0 {
+				index := indices[f.vvvv]
+				vvvv, p2 = byte(^index&15)<<3, f.encoding.length<<5|byte(1-index/16)<<3
+			}
+			if f.encoding.kind == "evex" {
+				p0 = byte((1-reg/8&1)<<7 | (1-rm/8&1)<<5 | (1-reg/16)<<4)
+				if memory || rmClass == "Yml" || rmClass == "Yrl" {
+					p0 |= 0x40
+				} else {
+					p0 |= byte(1-rm/16) << 6
+				}
+			}
+			if f.masked {
+				p2 |= 1
+			}
+			suffix := ""
+			if zeroing {
+				suffix, p2 = ".Z", p2|0x80
+			}
+			second := ""
+			if f.vvvv >= 0 {
+				second = args[f.vvvv]
+			}
+			witnesses = append(witnesses, X86PackedBinaryWitness{
+				Instruction: rule.Opcode + suffix + " " + strings.Join(args, ","), Generation: f.encoding.kind,
+				First: args[0], Second: second, Destination: args[len(args)-1], Width: f.width,
+				Memory: memory && f.rm == 0, Masked: f.masked, Zeroing: zeroing,
+				Encoding: f.encoding.bytes(vvvv, p0, p2, modrm),
+			})
+		}
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_move_remainder_test.go b/internal/goasmrules/x86_witness_move_remainder_test.go
new file mode 100644
index 000000000..3be424a48
--- /dev/null
+++ b/internal/goasmrules/x86_witness_move_remainder_test.go
@@ -0,0 +1,164 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveRemainderCompleteOriginalSourceRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	const members = `VLDDQU VMASKMOVDQU VMASKMOVPD VMASKMOVPS VMOVD VMOVHLPS
+VMOVHPD VMOVHPS VMOVLHPS VMOVLPD VMOVLPS VMOVMSKPD VMOVMSKPS
+VMOVNTDQ VMOVNTDQA VMOVNTPD VMOVNTPS VMOVQ VMOVSD VMOVSS
+VPMASKMOVD VPMASKMOVQ VPMOVMSKB`
+	wanted := map[string]bool{}
+	for _, name := range strings.Fields(members) {
+		wanted[name] = true
+	}
+	originals := map[string]X86AVXRule{}
+	tables := map[string]int{}
+	for index, rule := range avx {
+		if !wanted[rule.Opcode] {
+			continue
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)
+		if _, duplicate := originals[id]; duplicate {
+			t.Fatal("duplicate source row", id)
+		}
+		originals[id] = rule
+		tables[rule.Ytab]++
+	}
+	counts := map[string]int{"_yvlddqu": 2, "_yvmaskmovdqu": 1, "_yvmaskmovpd": 16,
+		"_yvmovd": 4, "_yvmovhlps": 4, "_yvmovhpd": 16, "_yvmovmskpd": 6,
+		"_yvmovntdq": 15, "_yvmovntdqa": 5, "_yvmovq": 8, "_yvmovsd": 24}
+	if len(wanted) != 23 || len(originals) != 101 || len(tables) != len(counts) {
+		t.Fatal("complete AVX move source closure changed", len(wanted), len(originals), tables)
+	}
+	for table, count := range counts {
+		if tables[table] != count {
+			t.Fatal("original ytab group changed", table, tables[table], count)
+		}
+	}
+	// Use the existing row helper. No future factory, selector or encoding
+	// symbol is needed to establish the real format boundary on all101 rows.
+	for index, rule := range avx {
+		if !wanted[rule.Opcode] {
+			continue
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)
+		t.Run(id, func(t *testing.T) {
+			if _, err := x86PackedAVXRowWitnesses(rule); err != nil {
+				t.Fatal("original move row format", err)
+			}
+		})
+	}
+	if t.Failed() {
+		return
+	}
+	rows, err := x86PackedBinaryRows(legacy, avx, members)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{}
+	for _, row := range rows {
+		original, exists := originals[row.ID]
+		if !exists || seen[row.ID] || row.Opcode != original.Opcode {
+			t.Fatal("source row dropped, aliased or duplicated", row.ID)
+		}
+		seen[row.ID] = true
+	}
+	if len(seen) != 101 {
+		t.Fatal("source closure lost a row", len(seen))
+	}
+	// This is source-row retention only. In particular, no assertion here
+	// calls a shadowed register alternative a hit of its later source row.
+}
+
+func TestX86MoveRemainderOriginalFormatAxesRemainBound(t *testing.T) {
+	type mutation struct {
+		name string
+		edit func(*X86AVXRule)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count, evex := 0, 0
+	for _, original := range avx {
+		if !x86MoveRemainderTable(original.Ytab) {
+			continue
+		}
+		witnesses, err := x86PackedAVXRowWitnesses(original)
+		if err != nil {
+			t.Fatal(original.Opcode, original.RowIndex, err)
+		}
+		for _, w := range witnesses {
+			if w.Zeroing && !w.Masked || w.Broadcast || w.MaskResult ||
+				w.Memory != (w.First == "(AX)") ||
+				original.Ytab == "_yvmovsd" && w.Destination == "(AX)" && w.Zeroing ||
+				original.Ytab == "_yvmaskmovpd" && w.Masked {
+				t.Fatal("source-only memory, scalar-store or vector-mask role was broadened", original, w)
+			}
+		}
+		mutations := []mutation{
+			{"prefix", func(r *X86AVXRule) { r.Prefix = "Pe" }},
+			{"classes", func(r *X86AVXRule) { r.Classes = append(r.Classes, "Yknot0") }},
+			{"row", func(r *X86AVXRule) { r.RowIndex += 100 }},
+			{"offset", func(r *X86AVXRule) { r.EncodingOffset++ }},
+			{"stride", func(r *X86AVXRule) { r.ZOffset++ }},
+			{"extent", func(r *X86AVXRule) { r.OpBytes = append(r.OpBytes, "0") }},
+			{"mandatory-prefix", func(r *X86AVXRule) {
+				p := &r.OpBytes[r.EncodingOffset]
+				switch {
+				case strings.Contains(*p, "F2"):
+					*p = strings.Replace(*p, "F2", "F3", 1)
+				case strings.Contains(*p, "F3"):
+					*p = strings.Replace(*p, "F3", "F2", 1)
+				case strings.Contains(*p, "66"):
+					*p = strings.Replace(*p, "66", "F2", 1)
+				default:
+					*p += "|vex66"
+				}
+			}},
+			{"word", func(r *X86AVXRule) {
+				p := &r.OpBytes[r.EncodingOffset]
+				if strings.Contains(*p, "W0") {
+					*p = strings.Replace(*p, "W0", "W1", 1)
+				} else {
+					*p = strings.Replace(*p, "W1", "W0", 1)
+				}
+			}},
+		}
+		if strings.HasPrefix(original.ZCase, "Zevex_") {
+			evex++
+			mutations = append(mutations,
+				mutation{"broadcast", func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += "|evexBcstN8" }},
+				mutation{"tuple", func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += "|evexN64" }})
+			if original.Ytab == "_yvmovsd" && (original.RowIndex == 6 || original.RowIndex == 7) {
+				mutations = append(mutations, mutation{"scalar-store-zeroing", func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += "|evexZeroingEnabled" }})
+			}
+		}
+		for _, mutation := range mutations {
+			changed := original
+			changed.OpBytes = append([]string(nil), original.OpBytes...)
+			changed.Classes = append([]string(nil), original.Classes...)
+			mutation.edit(&changed)
+			if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+				t.Fatal("changed source metadata borrowed a legal move format", original.Opcode, original.RowIndex, mutation.name)
+			}
+		}
+		count++
+	}
+	if count != 101 || evex != 44 {
+		t.Fatal("original move format-negative denominator changed", count, evex)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_moves_test.go b/internal/goasmrules/x86_witness_moves_test.go
new file mode 100644
index 000000000..032782760
--- /dev/null
+++ b/internal/goasmrules/x86_witness_moves_test.go
@@ -0,0 +1,203 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86PackedMoveTestRows(t *testing.T) ([]X86PackedBinaryRow, map[string]X86AVXRule) {
+	t.Helper()
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := x86PackedBinaryRows(legacy, avx, `
+		VMOVDQA VMOVDQU VMOVAPD VMOVAPS VMOVUPD VMOVUPS
+		VMOVDQA32 VMOVDQA64 VMOVDQU8 VMOVDQU16 VMOVDQU32 VMOVDQU64`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := make(map[string]X86AVXRule)
+	for index, rule := range avx {
+		if rule.Ytab == "_yvmovdqa" || rule.Ytab == "_yvmovapd" || rule.Ytab == "_yvmovdqa32" {
+			original[fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)] = rule
+		}
+	}
+	return rows, original
+}
+
+func TestX86PackedMoveRowsRetainDirectionAndTerminalControls(t *testing.T) {
+	rows, original := x86PackedMoveTestRows(t)
+	type counts struct {
+		rows, formats                 [2]int // VEX, EVEX.
+		widths                        [3]int
+		copies, loads, stores, faults int
+	}
+	var got counts
+	seen, names := make(map[string]bool), make(map[string]bool)
+	for _, row := range rows {
+		rule, exists := original[row.ID]
+		if !exists || seen[row.ID] || len(row.Witnesses) == 0 || row.Opcode != rule.Opcode {
+			t.Fatal("lost original move row identity", row)
+		}
+		seen[row.ID], names[row.Opcode] = true, true
+		store := strings.HasPrefix(rule.ZCase, "Zvex_r_") || strings.HasPrefix(rule.ZCase, "Zevex_r_")
+		generation := 0
+		if strings.HasPrefix(rule.ZCase, "Zevex_") {
+			generation = 1
+		}
+		got.rows[generation]++
+		for _, witness := range row.Witnesses {
+			if witness.Memory != (witness.First == "(AX)") || witness.Second != "" || witness.Broadcast || witness.MaskResult {
+				t.Fatal("move direction changed source-only Memory or invented a second source", row.ID, witness)
+			}
+			if witness.Masked != (len(rule.Classes) == 3) || witness.Zeroing && !witness.Masked || len(witness.Encoding) < 4 {
+				t.Fatal("move lost its mask, zeroing or physical bytes", row.ID, witness)
+			}
+			width, valid := map[int]int{128: 0, 256: 1, 512: 2}[witness.Width]
+			if !valid || (witness.Generation == "evex") != (generation == 1) {
+				t.Fatal("move width/generation changed", row.ID, witness)
+			}
+			got.formats[generation]++
+			got.widths[width]++
+			switch {
+			case witness.Memory:
+				if store {
+					t.Fatal("store row acquired a load witness", row.ID, witness)
+				}
+				got.loads++
+			case witness.Destination == "(AX)":
+				if !store {
+					t.Fatal("load row acquired a store witness", row.ID, witness)
+				}
+				if witness.Zeroing {
+					got.faults++ // Go accepts these bytes; normal value execution is #UD.
+				} else {
+					got.stores++
+				}
+			default:
+				if !store {
+					t.Fatal("load-row register alternative falsely claims first-match ownership", row.ID, witness)
+				}
+				got.copies++
+			}
+		}
+	}
+	want := counts{rows: [2]int{24, 120}, formats: [2]int{36, 270}, widths: [3]int{108, 108, 90}, copies: 102, loads: 102, stores: 72, faults: 30}
+	if len(rows) != 144 || len(seen) != len(original) || len(names) != 12 || got != want {
+		t.Fatal("AVX-only move row/candidate denominator drift", len(rows), len(original), len(names), got, want)
+	}
+}
+
+func TestX86PackedMoveLoadRegisterAlternativesRetainSelectedStoreRows(t *testing.T) {
+	rows, original := x86PackedMoveTestRows(t)
+	owners := make(map[string]string)
+	for _, row := range rows {
+		for _, witness := range row.Witnesses {
+			if !witness.Memory && witness.Destination != "(AX)" {
+				if owners[witness.Instruction] != "" {
+					t.Fatal("physical register witness has duplicate row owners", witness.Instruction)
+				}
+				owners[witness.Instruction] = row.ID
+			}
+		}
+	}
+	selections := 0
+	for wantedID, rule := range original {
+		if !strings.HasPrefix(rule.ZCase, "Zvex_rm_") && !strings.HasPrefix(rule.ZCase, "Zevex_rm_") {
+			continue
+		}
+		bank := strings.ToUpper(rule.Classes[0][1:2])
+		first, destination := bank+"0", bank+"2"
+		if strings.HasPrefix(rule.ZCase, "Zevex_") {
+			first, destination = bank+"16", bank+"18"
+		}
+		mask, suffixes := "", []string{""}
+		if len(rule.Classes) == 3 {
+			mask, suffixes = ",K1", []string{"", ".Z"}
+		}
+		for _, suffix := range suffixes {
+			instruction := rule.Opcode + suffix + " " + first + mask + "," + destination
+			selectedID := owners[instruction]
+			selected, exists := original[selectedID]
+			if !exists || selectedID == wantedID || selected.RowIndex >= rule.RowIndex || selected.Opcode != rule.Opcode || len(selected.Classes) != len(rule.Classes) ||
+				selected.Classes[0] != rule.Classes[len(rule.Classes)-1] || selected.Classes[len(selected.Classes)-1] != rule.Classes[0] ||
+				!strings.HasPrefix(selected.ZCase, strings.Split(rule.ZCase, "_")[0]+"_r_") {
+				t.Fatal("load row lost its separately selected register alternative", wantedID, instruction, selectedID)
+			}
+			selections++
+		}
+	}
+	if len(owners) != 102 || selections != 102 {
+		t.Fatal("shadow selections were dropped or counted as additional physical witnesses", len(owners), selections)
+	}
+}
+
+func x86PackedMoveStoreFixture() X86AVXRule {
+	return X86AVXRule{Opcode: "VMOVDQU16", Ytab: "_yvmovdqa32", Prefix: "Pavx", RowIndex: 3,
+		Classes: []string{"YyrEvex", "Yknot0", "YymEvex"}, ZCase: "Zevex_r_k_rm", ZOffset: 3,
+		OpBytes: []string{"avxEscape | evex256 | evexF2 | evex0F | evexW1", "evexN32 | evexZeroingEnabled", "0x7F"}}
+}
+
+func TestX86PackedMoveRowBytesUseDirectionAndMoveOnlyPrefixes(t *testing.T) {
+	rule := X86AVXRule{Opcode: "VMOVUPS", Ytab: "_yvmovapd", Prefix: "Pavx", Classes: []string{"Yxr", "Yxm"},
+		ZCase: "Zvex_r_v_rm", ZOffset: 2, OpBytes: []string{"avxEscape | vex128 | vex0F | vexW0", "0x11"}}
+	witnesses, err := x86PackedAVXRowWitnesses(rule)
+	if err != nil || len(witnesses) != 2 || witnesses[0].Instruction != "VMOVUPS X0,X2" ||
+		!bytes.Equal(witnesses[0].Encoding, []byte{0xc5, 0xf8, 0x11, 0xc2}) ||
+		witnesses[1].Instruction != "VMOVUPS X0,(AX)" || !bytes.Equal(witnesses[1].Encoding, []byte{0xc5, 0xf8, 0x11, 0x00}) {
+		t.Fatal("store direction reused load ModRM roles", witnesses, err)
+	}
+	witnesses, err = x86PackedAVXRowWitnesses(x86PackedMoveStoreFixture())
+	if err != nil || len(witnesses) != 4 || witnesses[0].Instruction != "VMOVDQU16 Y16,K1,Y18" ||
+		!bytes.Equal(witnesses[0].Encoding, []byte{0x62, 0xa1, 0xff, 0x29, 0x7f, 0xc2}) ||
+		witnesses[3].Instruction != "VMOVDQU16.Z Y16,K1,(AX)" || witnesses[3].Memory ||
+		!bytes.Equal(witnesses[3].Encoding, []byte{0x62, 0xe1, 0xff, 0xa9, 0x7f, 0x00}) {
+		t.Fatal("F2/W1 store or terminal EVEX.z identity changed", witnesses, err)
+	}
+	for _, prefix := range []string{"vexF2", "vexF3"} {
+		binary := X86AVXRule{Opcode: "VPMULLD", Ytab: "_yvandnpd", Prefix: "Pavx", Classes: []string{"Yxm", "Yxr", "Yxr"},
+			ZCase: "Zvex_rm_v_r", ZOffset: 2, OpBytes: []string{"avxEscape | vex128 | " + prefix + " | vex0F38 | vexW0", "0x40"}}
+		if _, err := x86PackedAVXRowWitnesses(binary); err == nil {
+			t.Fatal("move-only pp widened the old binary grammar", prefix)
+		}
+	}
+}
+
+func TestX86PackedMoveRowRejectsUnauditedAxes(t *testing.T) {
+	for _, edit := range []func(*X86AVXRule){
+		func(r *X86AVXRule) { r.Ytab = "unknown" },
+		func(r *X86AVXRule) { r.ZCase = "Zevex_rm_k_r" },
+		func(r *X86AVXRule) { r.Classes[0] = "YymEvex" },
+		func(r *X86AVXRule) { r.Classes[1] = "Yk" },
+		func(r *X86AVXRule) { r.Classes[2] = "YxmEvex" },
+		func(r *X86AVXRule) { r.ZOffset = 0 },
+		func(r *X86AVXRule) { r.EncodingOffset = 1 },
+		func(r *X86AVXRule) { r.OpBytes[0] += " | evexF3" },
+		func(r *X86AVXRule) { r.OpBytes[0] += " | evex66" },
+		func(r *X86AVXRule) { r.OpBytes[0] += " | futureFlag" },
+		func(r *X86AVXRule) { r.OpBytes[1] += " | evexBcstN4" },
+		func(r *X86AVXRule) { r.OpBytes[1] += " | evexRoundingEnabled" },
+		func(r *X86AVXRule) { r.OpBytes[1] += " | evexSaeEnabled" },
+		func(r *X86AVXRule) { r.OpBytes[1] = "evexN64 | evexZeroingEnabled" },
+	} {
+		rule := x86PackedMoveStoreFixture()
+		before := rule
+		before.OpBytes, before.Classes = append([]string(nil), rule.OpBytes...), append([]string(nil), rule.Classes...)
+		edit(&rule)
+		if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+			t.Fatal("unknown move direction or attribute silently accepted", witnesses, err)
+		}
+		if reflect.DeepEqual(rule, before) {
+			t.Fatal("negative control did not mutate its row")
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_movtab_remainder.go b/internal/goasmrules/x86_witness_movtab_remainder.go
new file mode 100644
index 000000000..66c0904af
--- /dev/null
+++ b/internal/goasmrules/x86_witness_movtab_remainder.go
@@ -0,0 +1,201 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86MovtabRemainderRows joins the five non-TLS fallback code groups.
+// The eighteen double shifts keep their existing owner. TLS base loads need
+// actual OS/shared/relocation observations and remain absent from this byte
+// projection; their all-zero table payload is never a successful encoding.
+func X86MovtabRemainderRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" || len(catalog.Movtab) != 113 {
+		return nil, fmt.Errorf("movtab source view needs a complete table and explicit x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for index, original := range catalog.Movtab {
+		if err := x86MoveTableRowStructure(original, index, len(catalog.Movtab)); err != nil {
+			return nil, err
+		}
+		if original.Kind == "sentinel" || original.Code == "movDoubleShift" || original.Code == "movTLSReg" {
+			continue
+		}
+		shape := original.Opcode + "/" + original.From + "/" + original.From3 + "/" + original.To + "/" + original.Code
+		if seen[shape] {
+			return nil, fmt.Errorf("duplicate original movtab source role: %s", shape)
+		}
+		seen[shape] = true
+		witnesses, err := x86MovtabRemainderRowWitnesses(original)
+		if err != nil {
+			return nil, fmt.Errorf("movtab/%d: %w", index, err)
+		}
+		row := X86ScalarRMWRow{
+			ID:     fmt.Sprintf("ymovtab/%d/%s/%s", index, original.Opcode, original.Code),
+			Opcode: original.Opcode, Witnesses: witnesses,
+		}
+		if arch == "386" && (original.From == "Ycr8" || original.To == "Ycr8") {
+			row.ModeFiltered, row.Witnesses = "original Go rejects CR8 REX.R in 386 mode", nil
+		}
+		result = append(result, row)
+	}
+	if len(result) != 92 {
+		return nil, fmt.Errorf("incomplete non-TLS movtab source rows: %d", len(result))
+	}
+	return result, nil
+}
+
+func x86MovtabRemainderRowWitnesses(row X86MoveRule) ([]X86ScalarRMWWitness, error) {
+	fail := func() ([]X86ScalarRMWWitness, error) {
+		return nil, fmt.Errorf("unmodeled complete movtab source grammar")
+	}
+	if row.Kind != "encoding" || row.TableIndex < 0 || row.Opcode == "" || row.From3 != "Ynone" ||
+		len(row.OpBytes) == 0 || len(row.OpBytes) > 4 {
+		return fail()
+	}
+	if row.OpcodeExpression != "" {
+		name, err := x86SourceOpcodeName(strings.TrimPrefix(row.OpcodeExpression, "obj."))
+		if err != nil || name != row.Opcode {
+			return fail()
+		}
+	}
+	if row.Code == "movLit" {
+		return x86MovtabStackLiteral(row)
+	}
+	span, toSpecial := 1, false
+	switch row.Code {
+	case "movRegMem":
+	case "movMemReg":
+		toSpecial = true
+	case "movRegMem2op":
+		span = 2
+	case "movMemReg2op":
+		span, toSpecial = 2, true
+	default:
+		return fail() // TLS has no target-independent literal; shifts keep their owner.
+	}
+	special, ordinary := row.From, row.To
+	if toSpecial {
+		special, ordinary = row.To, row.From
+	}
+	extension, valid := x86MovtabSpecialRegister(row.Opcode, special, ordinary, span, toSpecial)
+	if !valid {
+		return fail()
+	}
+	var payload [4]byte
+	for index, atom := range row.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return fail()
+		}
+		payload[index] = byte(value)
+	}
+	if payload[0] == 0 || span == 2 && payload[0] != 0x0f || payload[span] != extension {
+		return fail()
+	}
+	operands := []string{"BX"}
+	if ordinary == "Yml" {
+		operands = append(operands, "0(SI)")
+	} else if ordinary == "Ym" {
+		operands = []string{"0(SI)"}
+	}
+	prefix := append([]byte(nil), payload[:span-1]...)
+	if extension == 8 {
+		prefix = append([]byte{0x44}, prefix...) // Special-register REX.R; never REX.W.
+	}
+	var result []X86ScalarRMWWitness
+	for _, operand := range operands {
+		modrm := byte(0xc3) // BX
+		if operand == "0(SI)" {
+			modrm = 6
+		}
+		first, last := strings.ToUpper(strings.TrimPrefix(special, "Y")), operand
+		if toSpecial {
+			first, last = last, first
+		}
+		result = append(result, X86ScalarRMWWitness{
+			Instruction: row.Opcode + " " + first + "," + last, Destination: last,
+			Encoding: x86SourceModRMBytes(prefix, payload[span-1], modrm|(extension&7)<<3),
+		})
+	}
+	return result, nil
+}
+
+// The special register determines the ModRM field and legal ordinary class.
+// It does not determine opcode bytes, numeric values or native privileges.
+func x86MovtabSpecialRegister(op, special, ordinary string, span int, toSpecial bool) (byte, bool) {
+	if span == 1 && op == "MOVW" && ordinary == "Yml" {
+		for index, class := range []string{"Yes", "Ycs", "Yss", "Yds", "Yfs", "Ygs"} {
+			if special == class {
+				return byte(index), true
+			}
+		}
+	}
+	if span != 2 {
+		return 0, false
+	}
+	if ordinary == "Yrl" && (op == "MOVL" || op == "MOVQ") && len(special) == 4 {
+		index := special[3] - '0'
+		if special[:3] == "Ycr" && (index == 0 || index == 2 || index == 3 || index == 4 || index == 8) ||
+			special[:3] == "Ydr" && (index == 0 || index == 6 || index == 7 || op == "MOVQ" && (index == 2 || index == 3)) {
+			return index, true
+		}
+	}
+	if op == "MOVL" && ordinary == "Yml" && (special == "Ytr6" || special == "Ytr7") {
+		return special[3] - '0', true
+	}
+	if (op == "MOVL" || op == "MOVQ") && ordinary == "Ym" && (special == "Ygdtr" || special == "Yidtr") {
+		field := byte(0)
+		if special == "Yidtr" {
+			field = 1
+		}
+		if toSpecial {
+			field += 2
+		}
+		return field, true
+	}
+	if op == "MOVW" && ordinary == "Yml" {
+		field, found := map[string]byte{"Yldtr": 0, "Ymsw": 4, "Ytask": 1}[special]
+		if toSpecial {
+			field += 2
+		}
+		return field, found
+	}
+	return 0, false
+}
+
+func x86MovtabStackLiteral(row X86MoveRule) ([]X86ScalarRMWWitness, error) {
+	fail := func() ([]X86ScalarRMWWitness, error) { return nil, fmt.Errorf("unmodeled segment-stack literal") }
+	width := row.Opcode[len(row.Opcode)-1]
+	stem := row.Opcode[:len(row.Opcode)-1]
+	if (stem != "PUSH" && stem != "POP") || !strings.ContainsRune("WLQ", rune(width)) {
+		return fail()
+	}
+	class, empty := row.From, row.To
+	if stem == "POP" {
+		class, empty = row.To, row.From
+	}
+	if empty != "Ynone" || !strings.Contains(" Ycs Yss Yds Yes Yfs Ygs ", " "+class+" ") ||
+		stem == "POP" && class == "Ycs" || width == 'Q' && class != "Yfs" && class != "Ygs" {
+		return fail()
+	}
+	atoms := append([]string(nil), row.OpBytes...)
+	if atoms[0] == "Pe" && width == 'W' {
+		atoms[0] = "0x66"
+	}
+	code, err := x86SourceLiteralBytes(atoms, 4)
+	if err != nil || (code[0] == 0x66) != (width == 'W') {
+		return fail()
+	}
+	span := code
+	if width == 'W' {
+		span = span[1:]
+	}
+	if len(span) == 0 || span[0] == 0x0f && len(span) != 2 || span[0] != 0x0f && len(span) != 1 {
+		return fail()
+	}
+	operand := strings.ToUpper(strings.TrimPrefix(class, "Y"))
+	return []X86ScalarRMWWitness{{Instruction: row.Opcode + " " + operand, Destination: operand, Encoding: code}}, nil
+}
diff --git a/internal/goasmrules/x86_witness_movtab_remainder_test.go b/internal/goasmrules/x86_witness_movtab_remainder_test.go
new file mode 100644
index 000000000..fcec663ae
--- /dev/null
+++ b/internal/goasmrules/x86_witness_movtab_remainder_test.go
@@ -0,0 +1,250 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"testing"
+)
+
+func movtabRemainderOriginalRows(t *testing.T) []X86MoveRule {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rows []X86MoveRule
+	for _, row := range catalog.Movtab {
+		if row.Kind == "encoding" && row.Code != "movDoubleShift" && row.Code != "movTLSReg" {
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 92 {
+		t.Fatal("complete non-TLS source formatter denominator changed", len(rows))
+	}
+	return rows
+}
+
+func TestX86MovtabRemainderCompleteSourceTransport(t *testing.T) {
+	for _, row := range movtabRemainderOriginalRows(t) {
+		t.Run(fmt.Sprintf("%d/%s/%s", row.TableIndex, row.Opcode, row.Code), func(t *testing.T) {
+			before := fmt.Sprintf("%#v", row)
+			witnesses, err := x86MovtabRemainderRowWitnesses(row)
+			if err != nil || len(witnesses) == 0 {
+				t.Fatal("MOVTAB_REMAINDER_FORMATTER_FEATURE_GAP", row.TableIndex, row.Code, err)
+			}
+			for _, witness := range witnesses {
+				if witness.Instruction == "" || len(witness.Encoding) == 0 {
+					t.Fatal("source formatter returned an empty encoding", row, witness)
+				}
+			}
+			if before != fmt.Sprintf("%#v", row) {
+				t.Fatal("source formatter mutated its original capture")
+			}
+		})
+	}
+}
+
+func TestX86MovtabRemainderPaddingAndSourceIdentity(t *testing.T) {
+	for _, original := range movtabRemainderOriginalRows(t) {
+		t.Run(fmt.Sprintf("%d/%s", original.TableIndex, original.Opcode), func(t *testing.T) {
+			want, err := x86MovtabRemainderRowWitnesses(original)
+			if err != nil {
+				t.Fatal("original complete source required", err)
+			}
+			for _, expression := range []string{"", "obj.A" + original.Opcode} {
+				row := original
+				row.OpcodeExpression = expression
+				if got, err := x86MovtabRemainderRowWitnesses(row); err != nil || !reflect.DeepEqual(got, want) {
+					t.Fatal("equivalent source enum spelling changed output", expression, err)
+				}
+			}
+			row := original
+			for len(row.OpBytes) > 0 && (row.OpBytes[len(row.OpBytes)-1] == "0" || row.OpBytes[len(row.OpBytes)-1] == "00") {
+				row.OpBytes = row.OpBytes[:len(row.OpBytes)-1]
+			}
+			if got, err := x86MovtabRemainderRowWitnesses(row); err != nil || !reflect.DeepEqual(got, want) {
+				t.Fatal("implicit fixed-array padding changed source bytes", original, err)
+			}
+			if original.Code != "movLit" {
+				row = original
+				row.OpBytes = append([]string(nil), original.OpBytes...)
+				field := 1
+				if original.Code == "movRegMem2op" || original.Code == "movMemReg2op" {
+					field = 2
+				}
+				row.OpBytes[field] = "9"
+				movtabRequireMetadataRefusal(t, row, "foreign-special-register-field")
+			}
+		})
+	}
+}
+
+func TestX86MovtabRemainderPublicSourceBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"", "arm64", "wasm"} {
+		if rows, err := X86MovtabRemainderRows(catalog, arch); err == nil || len(rows) != 0 {
+			t.Fatal("source projection accepted absent or foreign mode", arch)
+		}
+	}
+	for _, mutation := range []string{"duplicate-role", "missing-row", "index", "unknown-code"} {
+		changed := catalog
+		changed.Movtab = append([]X86MoveRule(nil), catalog.Movtab...)
+		switch mutation {
+		case "duplicate-role":
+			changed.Movtab[1] = changed.Movtab[0]
+			changed.Movtab[1].TableIndex = 1
+		case "missing-row":
+			changed.Movtab = changed.Movtab[1:]
+		case "index":
+			changed.Movtab[0].TableIndex = 1
+		case "unknown-code":
+			changed.Movtab[0].Code = "movUnknown"
+		}
+		if rows, err := X86MovtabRemainderRows(changed, "amd64"); err == nil || len(rows) != 0 {
+			t.Fatal("incomplete original table acquired source ownership", mutation)
+		}
+	}
+	for _, original := range catalog.Movtab {
+		if original.Code == "movTLSReg" {
+			if got, err := x86MovtabRemainderRowWitnesses(original); err == nil || len(got) != 0 {
+				t.Fatal("TLS zero payload became successful target-independent bytes", original, got)
+			}
+		}
+	}
+}
+
+func TestX86MovtabRemainderCompleteTableSentinel(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{
+		"final-payload", "final-from", "final-code", "final-opcode",
+		"shift-sentinel", "TLS-sentinel", "shift-reserved", "TLS-reserved",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := catalog
+			changed.Movtab = append([]X86MoveRule(nil), catalog.Movtab...)
+			switch mutation {
+			case "final-payload":
+				changed.Movtab[112].OpBytes = []string{"0x90"}
+			case "final-from":
+				changed.Movtab[112].From = "Yrl"
+			case "final-code":
+				changed.Movtab[112].Code = "movUnknown"
+			case "final-opcode":
+				changed.Movtab[112].Opcode, changed.Movtab[112].OpcodeExpression = "MOVL", "AMOVL"
+			case "shift-sentinel":
+				changed.Movtab[92].Kind = "sentinel"
+			case "TLS-sentinel":
+				changed.Movtab[110].Kind = "sentinel"
+			case "shift-reserved":
+				changed.Movtab[92].Kind = "reserved"
+			case "TLS-reserved":
+				changed.Movtab[110].Kind = "reserved"
+			}
+			if got, err := X86MovtabRemainderRows(changed, "amd64"); err == nil || len(got) != 0 {
+				t.Fatal("MOVTAB_COMPLETE_TABLE_SENTINEL_ACCEPTED", mutation, len(got), err)
+			}
+		})
+	}
+}
+
+// Initially the old hook rejects these different source families wholesale.
+// These controls become new-formatter metadata tests when that independent
+// formatter is wired in; their initial PASS is not a metadata defect repair.
+func TestX86MovtabRemainderCompleteSourceMetadataBoundaries(t *testing.T) {
+	for _, original := range movtabRemainderOriginalRows(t) {
+		t.Run(fmt.Sprintf("%d/%s/%s", original.TableIndex, original.Opcode, original.Code), func(t *testing.T) {
+			for _, field := range []string{
+				"kind", "negative-index", "empty-opcode", "opcode-expression",
+				"from", "from3", "to", "joined-from", "code", "empty-payload", "overflow-capacity",
+			} {
+				row := original
+				row.OpBytes = append([]string(nil), original.OpBytes...)
+				switch field {
+				case "kind":
+					row.Kind = "sentinel"
+				case "negative-index":
+					row.TableIndex = -1
+				case "empty-opcode":
+					row.Opcode = ""
+				case "opcode-expression":
+					row.OpcodeExpression = "obj.ANOP"
+				case "from":
+					row.From = "Yinvalid"
+				case "from3":
+					row.From3 = "Yrl"
+				case "to":
+					row.To = "Yinvalid"
+				case "joined-from":
+					row.From += ",Ynone"
+				case "code":
+					row.Code = "movUnknown"
+				case "empty-payload":
+					row.OpBytes = nil
+				case "overflow-capacity":
+					row.OpBytes = []string{"0x90", "0", "0", "0", "0"}
+				}
+				movtabRequireMetadataRefusal(t, row, field)
+			}
+			for index := range original.OpBytes {
+				for _, atom := range []string{"-1", "0x100", "not-a-byte"} {
+					row := original
+					row.OpBytes = append([]string(nil), original.OpBytes...)
+					row.OpBytes[index] = atom
+					movtabRequireMetadataRefusal(t, row, fmt.Sprintf("atom-%d-%s", index, atom))
+				}
+			}
+			if original.Code == "movLit" {
+				row := original
+				row.OpBytes = []string{"0x90", "0x90", "0x90", "0x90"}
+				movtabRequireMetadataRefusal(t, row, "unterminated-literal")
+			}
+		})
+	}
+}
+
+func movtabRequireMetadataRefusal(t *testing.T, row X86MoveRule, field string) {
+	t.Helper()
+	defer func() {
+		if caught := recover(); caught != nil {
+			t.Errorf("MOVTAB_REMAINDER_METADATA_PANIC row=%d field=%s panic=%v", row.TableIndex, field, caught)
+		}
+	}()
+	if got, err := x86MovtabRemainderRowWitnesses(row); err == nil || len(got) != 0 {
+		t.Errorf("MOVTAB_REMAINDER_METADATA_ACCEPTED row=%d field=%s witnesses=%v", row.TableIndex, field, got)
+	}
+}
+
+func TestX86MovtabRemainderDoesNotWidenExistingDoubleShift(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	refused, accepted := 0, 0
+	for _, row := range catalog.Movtab {
+		if row.Kind != "encoding" {
+			continue
+		}
+		got, err := x86ScalarDoubleShiftWitnesses(row)
+		if row.Code == "movDoubleShift" {
+			if err != nil || len(got) == 0 {
+				t.Fatal("existing double-shift row regressed", row, err)
+			}
+			accepted++
+		} else {
+			if err == nil || len(got) != 0 {
+				t.Fatal("new source family acquired old double-shift membership", row, got)
+			}
+			refused++
+		}
+	}
+	if accepted != 18 || refused != 94 {
+		t.Fatal("old formatter source-family boundary changed", accepted, refused)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_narrowing.go b/internal/goasmrules/x86_witness_narrowing.go
new file mode 100644
index 000000000..3aeb9849c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_narrowing.go
@@ -0,0 +1,73 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+func x86PackedSingleSourceNarrowFormatForRule(rule X86AVXRule) (x86PackedUnaryMemoryFormat, error) {
+	f := x86PackedUnaryMemoryFormat{masked: rule.ZCase == "Zevex_r_k_rm", store: true}
+	fail := func() (x86PackedUnaryMemoryFormat, error) {
+		return f, fmt.Errorf("single-source narrowing source/tuple/carrier differs from its official format")
+	}
+	if rule.Prefix != "Pavx" || rule.Ytab != "_yvpmovdb" && rule.Ytab != "_yvpmovdw" ||
+		rule.ZCase != "Zevex_r_v_rm" && !f.masked || len(rule.Classes) != 2 && !f.masked ||
+		f.masked && (len(rule.Classes) != 3 || rule.Classes[1] != "Yknot0") {
+		return fail()
+	}
+	f.width = map[string]int{"YxrEvex": 128, "YyrEvex": 256, "Yzr": 512}[rule.Classes[0]]
+	pair, found := strings.CutPrefix(rule.Opcode, "VPMOV")
+	if !found {
+		return fail()
+	}
+	pair = strings.TrimPrefix(strings.TrimPrefix(pair, "US"), "S")
+	if len(pair) != 2 {
+		return fail()
+	}
+	bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}
+	input, output := bits[pair[0]], bits[pair[1]]
+	if input <= output || output == 0 || f.width == 0 ||
+		(rule.Ytab == "_yvpmovdw") != (input/output == 2) {
+		return fail()
+	}
+	f.tuple, f.carrier = f.width/8*output/input, 16
+	destination := "YxmEvex"
+	if f.tuple > 16 {
+		f.carrier, destination = 32, "YymEvex"
+	}
+	widthIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width]
+	maskIndex := 0
+	if f.masked {
+		maskIndex = 1
+	}
+	if rule.Classes[len(rule.Classes)-1] != destination || rule.RowIndex != widthIndex*2+maskIndex ||
+		rule.ZOffset != maskIndex*3 || rule.EncodingOffset != widthIndex*3 || len(rule.OpBytes) != 9 {
+		return fail()
+	}
+	offset := rule.EncodingOffset
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", "evex" + strconv.Itoa(f.width), "evexF3", "evex0F38", "evexW0",
+	}, nil); err != nil {
+		return fail()
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], []string{
+		"evexN" + strconv.Itoa(f.tuple), "evexZeroingEnabled",
+	}, nil); err != nil {
+		return fail()
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[offset+2], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: "evex", mapByte: 2, pp: 2, length: byte(widthIndex), opcode: byte(opcode)}
+	return f, nil
+}
+
+func x86PackedSingleSourceNarrowRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86PackedSingleSourceNarrowFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	return f.witnesses(rule.Opcode), nil
+}
diff --git a/internal/goasmrules/x86_witness_numeric_conversion.go b/internal/goasmrules/x86_witness_numeric_conversion.go
new file mode 100644
index 000000000..27a53b0d9
--- /dev/null
+++ b/internal/goasmrules/x86_witness_numeric_conversion.go
@@ -0,0 +1,220 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Physical carriers, active input tuple and encoded width are independent.
+// These source-table facts confer no numerical, pointee or native authority.
+type x86PackedNumericConversionFormat struct {
+	source, result, tuple, broadcast int
+	masked, rounding, sae            bool
+	encoding                         x86PackedAVXOpcode
+}
+
+func x86PackedNumericConversionFormatForRule(rule X86AVXRule) (x86PackedNumericConversionFormat, error) {
+	f := x86PackedNumericConversionFormat{masked: rule.ZCase == "Zevex_rm_k_r"}
+	f.encoding.kind = "vex"
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	if evex {
+		f.encoding.kind = "evex"
+	}
+	fail := func() (x86PackedNumericConversionFormat, error) {
+		return f, fmt.Errorf("packed numeric source/result/tuple/control differs from its official format")
+	}
+	stride := 2
+	if evex {
+		stride = 3
+	}
+	if rule.Prefix != "Pavx" || rule.ZCase != "Zvex_rm_v_r" && rule.ZCase != "Zevex_rm_v_r" && !f.masked ||
+		len(rule.Classes) != 2 && !f.masked || f.masked && (len(rule.Classes) != 3 || rule.Classes[1] != "Yknot0") ||
+		rule.EncodingOffset < 0 || rule.EncodingOffset+stride > len(rule.OpBytes) {
+		return fail()
+	}
+	kind := f.encoding.kind
+	atoms, err := x86PackedEncodingAtoms(rule.OpBytes[rule.EncodingOffset], []string{"avxEscape", kind + "0F"}, []string{
+		kind + "128", kind + "256", kind + "512", kind + "66", kind + "F2", kind + "F3", kind + "W0", kind + "W1",
+	})
+	if err != nil || atoms[kind+"W0"] == atoms[kind+"W1"] {
+		return fail()
+	}
+	width, lengths, prefixes, pp := 0, 0, 0, ""
+	for index, bits := range []int{128, 256, 512} {
+		if atoms[kind+strconv.Itoa(bits)] {
+			width, f.encoding.length = bits, byte(index)
+			lengths++
+		}
+	}
+	for index, prefix := range []string{"66", "F3", "F2"} {
+		if atoms[kind+prefix] {
+			pp, f.encoding.pp = prefix, byte(index+1)
+			prefixes++
+		}
+	}
+	if lengths != 1 || prefixes > 1 || !evex && (width == 512 || atoms["vexW1"]) {
+		return fail()
+	}
+	input, output, vexRows := 32, 32, 0
+	order, control, allowedPP, w := []int{512, 128, 256}, true, "", "W0"
+	switch rule.Ytab {
+	case "_yvcvtdq2ps":
+		vexRows, allowedPP = 2, ",66,F3"
+	case "_yvcvtdq2pd", "_yvcvtudq2pd":
+		output, control, allowedPP, order = 64, false, "F3", []int{128, 256, 512}
+		if rule.Ytab == "_yvcvtdq2pd" {
+			vexRows = 2
+		}
+	case "_yvcvtps2qq":
+		output, allowedPP = 64, "66"
+	case "_yvcvtpd2qq":
+		allowedPP = ",F2"
+		if atoms["evexW1"] {
+			input, output, w, allowedPP = 64, 64, "W1", "66,F3"
+		}
+	case "_yvcvtpd2dq", "_yvcvtpd2dqx", "_yvcvtpd2dqy", "_yvcvtpd2udqx", "_yvcvtpd2udqy":
+		input, w, allowedPP, order = 64, "W1", ",66,F2", []int{512}
+		if rule.Ytab != "_yvcvtpd2dq" {
+			control, order = false, []int{128}
+			if strings.HasSuffix(rule.Ytab, "y") {
+				order[0] = 256
+			}
+			allowedPP = ",F2"
+			if rule.Ytab == "_yvcvtpd2dqx" || rule.Ytab == "_yvcvtpd2dqy" {
+				vexRows, allowedPP = 1, "66,F2"
+				if !evex {
+					w = "W0"
+				}
+			}
+		}
+	default:
+		return fail()
+	}
+	if !atoms[kind+w] || !strings.Contains(","+allowedPP+",", ","+pp+",") {
+		return fail()
+	}
+	f.source, f.result, f.tuple = width, width, width/8
+	if input < output {
+		f.source, f.tuple = maxConversionCarrier(width/2), width/16
+	} else if input > output {
+		f.result = maxConversionCarrier(width / 2)
+	}
+	sourceClass := map[int]string{128: "Yxm", 256: "Yym", 512: "Yzm"}[f.source]
+	resultClass := map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[f.result]
+	if evex {
+		if f.source < 512 {
+			sourceClass += "Evex"
+		}
+		if f.result < 512 {
+			resultClass += "Evex"
+		}
+	}
+	index, offset, zoffset := -1, -1, 2
+	if evex {
+		for i, candidate := range order {
+			if width == candidate {
+				index, offset, zoffset = vexRows+2*i, 2*vexRows+3*i, 0
+			}
+		}
+		if f.masked {
+			index, zoffset = index+1, 3
+		}
+	} else if vexRows == 2 && width == 128 || vexRows == 1 && width == order[0] {
+		index, offset = 0, 0
+	} else if vexRows == 2 && width == 256 {
+		index, offset = 1, 2
+	}
+	if rule.Classes[0] != sourceClass || rule.Classes[len(rule.Classes)-1] != resultClass ||
+		index < 0 || rule.RowIndex != index || rule.EncodingOffset != offset || rule.ZOffset != zoffset || len(rule.OpBytes) != 2*vexRows+3*len(order) {
+		return fail()
+	}
+	if evex {
+		optional := []string{}
+		if control && width == 512 {
+			optional = []string{"evexRoundingEnabled", "evexSaeEnabled"}
+		}
+		flags, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], []string{
+			"evexN" + strconv.Itoa(f.tuple), "evexBcstN" + strconv.Itoa(input/8), "evexZeroingEnabled",
+		}, optional)
+		if err != nil || control && width == 512 && flags["evexRoundingEnabled"] == flags["evexSaeEnabled"] {
+			return fail()
+		}
+		f.broadcast, f.rounding, f.sae = input/8, flags["evexRoundingEnabled"], flags["evexSaeEnabled"]
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[rule.EncodingOffset+stride-1], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding.mapByte, f.encoding.opcode = 1, byte(opcode)
+	if atoms[kind+"W1"] {
+		f.encoding.wBit = 0x80
+	}
+	return f, nil
+}
+
+func maxConversionCarrier(bits int) int {
+	if bits < 128 {
+		return 128
+	}
+	return bits
+}
+
+func x86PackedNumericConversionRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86PackedNumericConversionFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	return f.witnesses(rule.Opcode), nil
+}
+
+func (f x86PackedNumericConversionFormat) witnesses(opcode string) []X86PackedBinaryWitness {
+	bank := map[int]string{128: "X", 256: "Y", 512: "Z"}
+	source, destination := bank[f.source]+"0", bank[f.result]+"2"
+	if f.encoding.kind == "evex" {
+		source, destination = bank[f.source]+"16", bank[f.result]+"18"
+	}
+	controls := []string{""}
+	if f.masked {
+		controls = append(controls, ".Z")
+	}
+	var witnesses []X86PackedBinaryWitness
+	add := func(first, suffix string, p2 byte) {
+		operands, p0, modrm := first+","+destination, byte(0xa0), byte(0xd0)
+		if first == "(AX)" {
+			p0, modrm = 0xe0, 0x10
+		}
+		if f.masked {
+			operands, p2 = first+",K1,"+destination, p2|1
+		}
+		if strings.HasSuffix(suffix, ".Z") {
+			p2 |= 0x80
+		}
+		witnesses = append(witnesses, X86PackedBinaryWitness{
+			Instruction: opcode + suffix + " " + operands, Generation: f.encoding.kind,
+			First: first, Destination: destination, Width: f.result, Memory: first == "(AX)",
+			Masked: f.masked, Zeroing: strings.HasSuffix(suffix, ".Z"), Broadcast: strings.Contains(suffix, ".BCST"),
+			Encoding: f.encoding.bytes(0x78, p0, p2, modrm),
+		})
+	}
+	p2 := f.encoding.length<<5 | 8
+	for _, first := range []string{source, "(AX)"} {
+		for _, suffix := range controls {
+			add(first, suffix, p2)
+		}
+	}
+	for _, suffix := range controls {
+		if f.broadcast != 0 {
+			add("(AX)", ".BCST"+suffix, p2|0x10)
+		}
+		if f.rounding {
+			for index, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				add(source, "."+rounding+suffix, p2&^0x60|byte(index)<<5|0x10)
+			}
+		}
+		if f.sae {
+			add(source, ".SAE"+suffix, p2|0x10)
+		}
+	}
+	return witnesses
+}
diff --git a/internal/goasmrules/x86_witness_numeric_conversion_test.go b/internal/goasmrules/x86_witness_numeric_conversion_test.go
new file mode 100644
index 000000000..5eb0ca54f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_numeric_conversion_test.go
@@ -0,0 +1,298 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent complete ordinary packed numeric namespace. Scalar, pure
+// precision, F16C and decoder-only FP16/BF16 families have separate owners.
+const x86PackedNumericConversionTestNames = `
+	CVTPS2PL CVTTPS2PL CVTPD2PL CVTTPD2PL CVTPL2PS CVTPL2PD
+	VCVTPS2DQ VCVTTPS2DQ VCVTPD2DQX VCVTPD2DQY VCVTTPD2DQX VCVTTPD2DQY VCVTPD2DQ VCVTTPD2DQ
+	VCVTPD2QQ VCVTPD2UQQ VCVTTPD2QQ VCVTTPD2UQQ VCVTPS2UDQ VCVTTPS2UDQ VCVTUDQ2PS
+	VCVTQQ2PD VCVTUQQ2PD VCVTPS2QQ VCVTPS2UQQ VCVTTPS2QQ VCVTTPS2UQQ VCVTUDQ2PD
+	VCVTPD2UDQX VCVTTPD2UDQX VCVTQQ2PSX VCVTUQQ2PSX
+	VCVTPD2UDQY VCVTTPD2UDQY VCVTQQ2PSY VCVTUQQ2PSY
+	VCVTPD2UDQ VCVTTPD2UDQ VCVTQQ2PS VCVTUQQ2PS VCVTDQ2PS VCVTDQ2PD`
+
+func TestX86PackedNumericConversionCompleteOfficialTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This existing entry point must reach a real format RED, not fail to
+	// compile against a future conversion selector or carrier helper.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86PackedNumericConversionTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := map[string]bool{}
+	for _, name := range strings.Fields(x86PackedNumericConversionTestNames) {
+		selected[name] = true
+	}
+	type original struct {
+		classes              []string
+		generation, features string
+		masked               bool
+	}
+	originals := map[string]original{}
+	mmx := 0
+	for _, entry := range legacy.Optab {
+		if !selected[entry.Opcode] {
+			continue
+		}
+		for _, row := range entry.Rows {
+			if row.Classes[0] == "Ymm" || row.Classes[len(row.Classes)-1] == "Ymr" {
+				mmx++
+				continue
+			}
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			originals[id] = original{row.Classes, "legacy", "", false}
+		}
+	}
+	for index, row := range avx {
+		if !selected[row.Opcode] {
+			continue
+		}
+		kind, features := "vex", ""
+		if strings.HasPrefix(row.ZCase, "Zevex_") {
+			kind, features = "evex", row.OpBytes[row.EncodingOffset+1]
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)
+		originals[id] = original{row.Classes, kind, features, row.ZCase == "Zevex_rm_k_r"}
+	}
+	sizes := map[string]int{"Yxm": 16, "YxmEvex": 16, "Yym": 32, "YymEvex": 32, "Yzm": 64, "Yxr": 16, "YxrEvex": 16, "Yyr": 32, "YyrEvex": 32, "Yzr": 64}
+	seen, names, instructions := map[string]bool{}, map[string]bool{}, map[string]bool{}
+	rowKinds, formats := map[string]int{}, map[string]int{}
+	widths, encodingWidths := map[int]int{}, map[int]int{}
+	broadcast, masked, zeroing, rounding, sae, different := 0, 0, 0, 0, 0, 0
+	for _, row := range rows {
+		from, valid := originals[row.ID]
+		if !valid || seen[row.ID] || len(row.Witnesses) == 0 {
+			t.Fatal("packed numeric conversion lost an original ordinary row", row)
+		}
+		seen[row.ID], names[row.Opcode] = true, true
+		rowKinds[from.generation]++
+		sourceBytes, destinationBytes := sizes[from.classes[0]], sizes[from.classes[len(from.classes)-1]]
+		encodingWidth := sourceBytes * 8
+		if destinationBytes > sourceBytes {
+			encodingWidth = destinationBytes * 8
+		}
+		for _, witness := range row.Witnesses {
+			fields := strings.Fields(witness.Instruction)
+			if len(fields) != 2 || len(witness.Encoding) < 3 {
+				t.Fatal("packed conversion lost source or bytes", row.ID, witness)
+			}
+			operands := strings.Split(fields[1], ",")
+			first := strings.ToUpper(from.classes[0][1:2]) + "0"
+			destination := strings.ToUpper(from.classes[len(from.classes)-1][1:2]) + "2"
+			if from.generation == "legacy" {
+				destination = "X1"
+			}
+			if from.generation == "evex" {
+				first = first[:1] + "16"
+				destination = destination[:1] + "18"
+			}
+			if instructions[witness.Instruction] || strings.Split(fields[0], ".")[0] != row.Opcode ||
+				witness.First != operands[0] || witness.Destination != destination || operands[len(operands)-1] != destination ||
+				witness.First != first && witness.First != "(AX)" || witness.Memory != (witness.First == "(AX)") ||
+				witness.Generation != from.generation || witness.Masked != from.masked || witness.Width != destinationBytes*8 || witness.MaskResult ||
+				witness.Zeroing != strings.HasSuffix(fields[0], ".Z") || witness.Zeroing && !witness.Masked ||
+				witness.Broadcast != strings.Contains(fields[0], ".BCST") || witness.Broadcast && !witness.Memory ||
+				witness.Masked && operands[1] != "K1" ||
+				from.generation == "legacy" && witness.Second != destination || from.generation != "legacy" && witness.Second != "" {
+				t.Fatal("conversion conflated physical carriers, tuple, mask, or syntax read metadata", row.ID, witness)
+			}
+			instructions[witness.Instruction] = true
+			isRound, isSAE := strings.Contains(fields[0], "_SAE"), strings.Contains(fields[0], ".SAE")
+			if witness.Broadcast && !hasEncodingTerm(from.features, "evexBcstN4") && !hasEncodingTerm(from.features, "evexBcstN8") ||
+				isRound && (!hasEncodingTerm(from.features, "evexRoundingEnabled") || witness.Memory) ||
+				isSAE && (!hasEncodingTerm(from.features, "evexSaeEnabled") || witness.Memory) {
+				t.Fatal("conversion borrowed a foreign broadcast/ER/SAE source capability", row.ID, witness)
+			}
+			if from.generation == "evex" {
+				if len(witness.Encoding) != 6 || witness.Encoding[0] != 0x62 || witness.Encoding[2]&0x78 != 0x78 || witness.Encoding[3]&8 == 0 {
+					t.Fatal("conversion lost unary reserved vvvv/V' or EVEX identity", row.ID, witness)
+				}
+				if !isRound && !isSAE && 128<<(witness.Encoding[3]>>5&3) != encodingWidth {
+					t.Fatal("conversion encoded destination width in place of source/result carrier geometry", row.ID, witness)
+				}
+			}
+			formats[from.generation]++
+			widths[witness.Width]++
+			encodingWidths[encodingWidth]++
+			if witness.Broadcast {
+				broadcast++
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if isRound {
+				rounding++
+			}
+			if isSAE {
+				sae++
+			}
+			if sourceBytes != destinationBytes {
+				different++
+			}
+		}
+	}
+	if len(rows) != 162 || len(seen) != len(originals) || len(names) != 42 || mmx != 6 ||
+		rowKinds["legacy"] != 6 || rowKinds["vex"] != 12 || rowKinds["evex"] != 144 ||
+		formats["legacy"] != 12 || formats["vex"] != 24 || formats["evex"] != 840 ||
+		widths[128] != 298 || widths[256] != 278 || widths[512] != 300 ||
+		encodingWidths[128] != 240 || encodingWidths[256] != 228 || encodingWidths[512] != 408 ||
+		broadcast != 216 || masked != 560 || zeroing != 280 || rounding != 168 || sae != 24 || different != 306 {
+		t.Fatal("complete42 conversion row/control denominator changed", len(rows), len(names), mmx, rowKinds, formats, widths, encodingWidths, broadcast, masked, zeroing, rounding, sae, different)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"CVTPL2PD (AX),X1", []byte{0xf3, 0x0f, 0xe6, 0x08}},
+		{"CVTPD2PL X0,X1", []byte{0xf2, 0x0f, 0xe6, 0xc8}},
+		{"CVTTPS2PL X0,X1", []byte{0xf3, 0x0f, 0x5b, 0xc8}},
+		{"VCVTDQ2PS Y0,Y2", []byte{0xc5, 0xfc, 0x5b, 0xd0}},
+		{"VCVTDQ2PD X0,Y2", []byte{0xc5, 0xfe, 0xe6, 0xd0}},
+		{"VCVTPD2DQY Y0,X2", []byte{0xc5, 0xff, 0xe6, 0xd0}},
+		{"VCVTPD2UDQY Y16,X18", []byte{0x62, 0xa1, 0xfc, 0x28, 0x79, 0xd0}},
+		{"VCVTPS2QQ Y16,Z18", []byte{0x62, 0xa1, 0x7d, 0x48, 0x7b, 0xd0}},
+		{"VCVTQQ2PS Z16,Y18", []byte{0x62, 0xa1, 0xfc, 0x48, 0x5b, 0xd0}},
+		{"VCVTUDQ2PD (AX),X18", []byte{0x62, 0xe1, 0x7e, 0x08, 0x7a, 0x10}},
+		{"VCVTTPD2UQQ.BCST.Z (AX),K1,Z18", []byte{0x62, 0xe1, 0xfd, 0xd9, 0x78, 0x10}},
+	})
+}
+
+func TestX86PackedNumericConversionMMXOriginalRowsRemainSeparate(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ordinary, mmx, inputs, outputs := 0, 0, 0, 0
+	for _, entry := range legacy.Optab {
+		if entry.Ytab != "yxcvm1" && entry.Ytab != "yxcvm2" {
+			continue
+		}
+		if len(entry.Rows) != 2 {
+			t.Fatal("packed conversion lost its complete ordinary/MMX source rows", entry)
+		}
+		for _, row := range entry.Rows {
+			if row.RowIndex == 0 && strings.Join(row.Classes, ",") == "Yxm,Yxr" {
+				ordinary++
+				continue
+			}
+			if row.RowIndex != 1 || row.ZCase != "Zm_r_xm" || row.ZOffset != 2 || row.UnmatchedOffset != 2 {
+				t.Fatal("MMX source row metadata changed", entry, row)
+			}
+			switch strings.Join(row.Classes, ",") {
+			case "Ymm,Yxr":
+				inputs++
+			case "Yxm,Ymr":
+				outputs++
+			default:
+				t.Fatal("MMX acquired a GP/vector source-role reinterpretation", entry, row)
+			}
+			mmx++
+		}
+	}
+	if ordinary != 6 || mmx != 6 || inputs != 2 || outputs != 4 {
+		t.Fatal("complete legacy ordinary/MMX source denominator changed", ordinary, mmx, inputs, outputs)
+	}
+	// This owner inventories source rows only. It proves no new MMX native
+	// caller, region/EMMS closure or successful/failed translator execution.
+}
+
+func TestX86PackedNumericConversionRejectsForeignCarrierAndControlAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"wide source carrier", "wide larger X tuple", "narrow destination", "narrow encoding width", "narrow input tuple", "same source carrier", "same input tuple", "exact integer widening ER", "narrow alias ER", "ER plus SAE", "BCST element width", "K0 writemask class", "GP result", "GP vector input"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VCVTPS2QQ", 0
+			switch mutation {
+			case "wide larger X tuple":
+				index = 2
+			case "narrow destination":
+				name = "VCVTQQ2PS"
+			case "narrow encoding width":
+				name = "VCVTPD2UDQY"
+			case "narrow input tuple":
+				name = "VCVTPD2UDQX"
+			case "same source carrier":
+				name = "VCVTPD2QQ"
+			case "same input tuple":
+				name, index = "VCVTPD2QQ", 2
+			case "exact integer widening ER":
+				name, index = "VCVTUDQ2PD", 4
+			case "narrow alias ER":
+				name = "VCVTQQ2PSX"
+			case "K0 writemask class":
+				name, index = "VCVTPD2QQ", 1
+			case "GP result":
+				name, index = "VCVTPS2UDQ", 2
+			case "GP vector input":
+				name, index = "VCVTUDQ2PS", 2
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+					t.Fatal("negative requires its complete original row to remain valid", original, err)
+				}
+				row := original
+				row.Classes = append([]string(nil), row.Classes...)
+				row.OpBytes = append([]string(nil), row.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "wide source carrier":
+					row.Classes[0] = "YxmEvex"
+				case "wide larger X tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN8", "evexN16", 1)
+				case "narrow destination":
+					row.Classes[len(row.Classes)-1] = "Yzr"
+				case "narrow encoding width":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex256", "evex128", 1)
+				case "narrow input tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "same source carrier":
+					row.Classes[0] = "YymEvex"
+				case "same input tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "exact integer widening ER", "narrow alias ER":
+					row.OpBytes[feature] += "|evexRoundingEnabled"
+				case "ER plus SAE":
+					row.OpBytes[feature] += "|evexSaeEnabled"
+				case "BCST element width":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexBcstN4", "evexBcstN8", 1)
+				case "K0 writemask class":
+					row.Classes[1] = "Yk"
+				case "GP result":
+					row.Classes[len(row.Classes)-1] = "Yrl"
+				case "GP vector input":
+					row.Classes[0] = "Yrl"
+				}
+				if strings.Join(row.Classes, ",") == strings.Join(original.Classes, ",") && strings.Join(row.OpBytes, ",") == strings.Join(original.OpBytes, ",") {
+					t.Fatal("conversion negative did not mutate its original row", mutation, row)
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("packed conversion borrowed a foreign domain/carrier/tuple/control", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("conversion negative lost its exact original Go row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_ordinary_move_test.go b/internal/goasmrules/x86_witness_ordinary_move_test.go
new file mode 100644
index 000000000..a625f42f4
--- /dev/null
+++ b/internal/goasmrules/x86_witness_ordinary_move_test.go
@@ -0,0 +1,221 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func ordinaryMoveSchemaForTest(name string, historical bool) []string {
+	gp := []string{"Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl", "Zil_rp/1/Yi32,Yrl", "Zilo_m/2/Yi32,Yml"}
+	switch name {
+	case "MOVB":
+		return []string{"Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb", "Zib_rp/1/Yi32,Yrb", "Zibo_m/2/Yi32,Ymb"}
+	case "MOVW":
+		return append(gp, "Zaut_r/2/Yiauto,Yrl")
+	case "MOVL":
+		return append(gp, "Zm_r_xm/1/Yml,Ymr", "Zr_m_xm/1/Ymr,Yml", "Zm_r_xm/2/Yml,Yxr", "Zr_m_xm/2/Yxr,Yml", "Zaut_r/2/Yiauto,Yrl")
+	case "MOVQ":
+		rows := []string{"Zm_r_xm_nr/1/Ym,Ymr", "Zr_m_xm_nr/1/Ymr,Ym", "Zm_r_xm_nr/2/Yxr,Ymr", "Zm_r_xm_nr/2/Yxm,Yxr", "Zr_m_xm_nr/2/Yxr,Yxm", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"}
+		if historical {
+			rows = append(rows, "Zilo_m/2/Ys32,Yrl")
+		}
+		return append(rows, "Ziq_rp/1/Yi64,Yrl", "Zilo_m/2/Yi32,Yml", "Zm_r_xm/1/Ymm,Ymr", "Zr_m_xm/1/Ymr,Ymm", "Zm_r_xm/2/Yml,Yxr", "Zr_m_xm/2/Yxr,Yml", "Zaut_r/1/Yiauto,Yrl")
+	}
+	return nil
+}
+
+func TestX86OrdinaryMoveOriginalCompleteTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, rows := 0, 0
+	for _, entry := range catalog.Optab {
+		schema := ordinaryMoveSchemaForTest(entry.Opcode, len(entry.Rows) == 15)
+		if schema == nil {
+			continue
+		}
+		names++
+		if len(entry.Rows) != len(schema) {
+			t.Fatal("complete ordinary MOV table changed", entry.Opcode)
+		}
+		for _, row := range entry.Rows {
+			rows++
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				if got := fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")); got != schema[row.RowIndex] {
+					t.Fatal("independent complete source schema changed", got)
+				}
+				before := fmt.Sprintf("%#v/%#v", entry, row)
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, row, "amd64")
+				if err != nil || row.ZCase != "Zaut_r" && len(witnesses) == 0 {
+					t.Fatal("ORDINARY_MOV_SOURCE_TRANSPORT_GAP", err)
+				}
+				if before != fmt.Sprintf("%#v/%#v", entry, row) {
+					t.Fatal("ordinary source formatter mutated original metadata")
+				}
+			})
+		}
+	}
+	if names != 4 || rows != 32 && rows != 33 {
+		t.Fatal("complete four-table source inventory changed", names, rows)
+	}
+}
+
+func TestX86OrdinaryMoveCompleteMetadataBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	maxInt := int(^uint(0) >> 1)
+	for _, entry := range catalog.Optab {
+		if ordinaryMoveSchemaForTest(entry.Opcode, len(entry.Rows) == 15) == nil {
+			continue
+		}
+		for _, selected := range entry.Rows {
+			for _, field := range []string{"original-arity", "selected-arity", "original-index", "selected-index", "original-offset", "selected-offset", "original-stride", "selected-stride", "earlier-row", "last-row", "row-count", "prefix", "source-role", "nonbyte", "payload-short", "payload-extra", "symbolic-marker", "opcode-zero", "opcode-escape", "escape-one", "escape-negative", "escape-overflow"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", entry.Opcode, selected.RowIndex, field), func(t *testing.T) {
+					changed, row := entry, selected
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					switch field {
+					case "original-arity":
+						changed.Rows[row.RowIndex].Classes = []string{strings.Join(row.Classes, ",")}
+					case "selected-arity":
+						row.Classes = []string{strings.Join(row.Classes, ",")}
+					case "original-index":
+						changed.Rows[row.RowIndex].RowIndex = maxInt
+					case "selected-index":
+						row.RowIndex = -1
+					case "original-offset":
+						changed.Rows[row.RowIndex].UnmatchedOffset = -maxInt - 1
+					case "selected-offset":
+						row.UnmatchedOffset = maxInt
+					case "original-stride":
+						changed.Rows[row.RowIndex].ZOffset = maxInt
+					case "selected-stride":
+						row.ZOffset = -1
+					case "earlier-row":
+						changed.Rows[0].ZOffset = -maxInt - 1
+					case "last-row":
+						changed.Rows[len(changed.Rows)-1].Classes = []string{"Yiauto,Yrl"}
+					case "row-count":
+						changed.Rows = append(changed.Rows, row)
+					case "prefix":
+						changed.Prefix = "Pw"
+					case "source-role":
+						changed.Opcode = "MOVTLS"
+					case "nonbyte":
+						changed.OpBytes[0] = "0x100"
+					case "payload-short":
+						changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+					case "payload-extra":
+						changed.OpBytes = append(changed.OpBytes, "0")
+					case "symbolic-marker":
+						changed.OpBytes[0] = "Pe"
+					case "opcode-zero":
+						changed.OpBytes[0] = "0"
+					case "opcode-escape":
+						changed.OpBytes[0] = "0x0f"
+					case "escape-one":
+						changed.EscapeAdjustment = 1
+					case "escape-negative":
+						changed.EscapeAdjustment = -maxInt - 1
+					case "escape-overflow":
+						changed.EscapeAdjustment = maxInt
+					}
+					defer func() {
+						if failure := recover(); failure != nil {
+							t.Error("ORDINARY_MOV_SCHEMA_PANIC", failure)
+						}
+					}()
+					if reflect.DeepEqual(changed, entry) && reflect.DeepEqual(row, selected) {
+						t.Fatal("negative did not change original or selected metadata")
+					}
+					if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+						t.Fatal("ORDINARY_MOV_MALFORMED_ACCEPTED", field)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryMoveSourceRolesAndModeBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	historical := false
+	for _, entry := range catalog.Optab {
+		if entry.Opcode == "MOVQ" {
+			historical = len(entry.Rows) == 15
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86OrdinaryMoveRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		roles := map[string]int{}
+		filtered, rewrites := 0, 0
+		for _, row := range rows {
+			roles[row.Role]++
+			if row.Rewrite != "" {
+				if row.Role != "address" || row.Rewrite != "LEA"+row.Opcode[3:] {
+					t.Fatal("address rewrite supplied a different role", row)
+				}
+				rewrites++
+			}
+			if row.ModeFiltered != "" {
+				if arch != "386" || row.Opcode != "MOVQ" || len(row.Witnesses) != 0 {
+					t.Fatal("mode filter supplied a witness or removed a legal mode", row)
+				}
+				filtered++
+			} else if len(row.Witnesses) == 0 {
+				t.Fatal("unfiltered original source row lacks its observation", row)
+			}
+		}
+		gp, wantFiltered := 16, 0
+		if historical {
+			gp++
+		}
+		if arch == "386" {
+			wantFiltered = 9
+			if historical {
+				wantFiltered++
+			}
+		}
+		if !reflect.DeepEqual(roles, map[string]int{"GP": gp, "bank": 13, "address": 3}) || filtered != wantFiltered || rewrites != 2 {
+			t.Fatal("complete source-role/mode partition changed", roles, filtered, rewrites)
+		}
+	}
+	for _, arch := range []string{"", "arm64", "wasm"} {
+		if _, err := X86OrdinaryMoveRows(catalog, arch); err == nil {
+			t.Fatal("foreign mode borrowed ordinary x86 source transport", arch)
+		}
+	}
+	if _, err := X86OrdinaryMoveRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("missing catalog supplied an ordinary MOV closure")
+	}
+	for _, field := range []string{"missing", "duplicate"} {
+		changed := catalog
+		changed.Optab = append([]X86LegacyOpcode(nil), catalog.Optab...)
+		for index, entry := range changed.Optab {
+			if entry.Opcode != "MOVL" {
+				continue
+			}
+			if field == "missing" {
+				changed.Optab = append(changed.Optab[:index], changed.Optab[index+1:]...)
+			} else {
+				changed.Optab = append(changed.Optab, entry)
+			}
+			break
+		}
+		if _, err := X86OrdinaryMoveRows(changed, "amd64"); err == nil {
+			t.Fatal("incomplete/duplicate catalog supplied an ordinary MOV closure", field)
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_permutation_shuffle.go b/internal/goasmrules/x86_witness_permutation_shuffle.go
new file mode 100644
index 000000000..772d0eb59
--- /dev/null
+++ b/internal/goasmrules/x86_witness_permutation_shuffle.go
@@ -0,0 +1,152 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// These source schemas share transport, not selector topology, old values or
+// native-access authority. The literal opcode remains in the original payload.
+func x86PermutationShuffleRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f := x86VectorResultFormat{}
+	fail := func() ([]X86PackedBinaryWitness, error) {
+		return nil, fmt.Errorf("permutation source/control/result differs from its official format")
+	}
+	immediate := strings.Contains(rule.ZCase, "_i_")
+	f.unary = immediate && (rule.ZCase == "Zvex_i_rm_r" || rule.ZCase == "Zevex_i_rm_r" || rule.ZCase == "Zevex_i_rm_k_r")
+	f.masked = rule.ZCase == "Zevex_rm_v_k_r" || rule.ZCase == "Zevex_i_rm_k_r" || rule.ZCase == "Zevex_i_rm_v_k_r"
+	evex := strings.HasPrefix(rule.ZCase, "Zevex_")
+	first, count, kind := 0, 3, "vex"
+	if immediate {
+		first, count = 1, 4
+		if f.unary {
+			count--
+		}
+	}
+	if f.masked {
+		count++
+	}
+	if evex {
+		kind = "evex"
+	}
+	plain := "Zvex_rm_v_r"
+	if immediate {
+		plain = "Zvex_i_rm_v_r"
+		if f.unary {
+			plain = "Zvex_i_rm_r"
+		}
+	}
+	if evex {
+		plain = strings.Replace(plain, "Zvex_", "Zevex_", 1)
+	}
+	selector := 7
+	if immediate && len(rule.Classes) > 0 && rule.Classes[0] == "Yi8" && !evex {
+		selector = -1
+	}
+	if rule.Prefix != "Pavx" || rule.ZCase != plain && !f.masked || len(rule.Classes) != count ||
+		immediate && rule.Classes[0] != "Yu8" && selector != -1 ||
+		f.masked && rule.Classes[count-2] != "Yknot0" {
+		return fail()
+	}
+	f.width = map[string]int{"Yxm": 128, "Yym": 256}[rule.Classes[first]]
+	register := map[int]string{128: "Yxr", 256: "Yyr"}[f.width]
+	if evex {
+		f.width = map[string]int{"YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[rule.Classes[first]]
+		register = map[int]string{128: "YxrEvex", 256: "YyrEvex", 512: "Yzr"}[f.width]
+	}
+	if f.width == 0 || rule.Classes[count-1] != register || !f.unary && rule.Classes[first+1] != register {
+		return fail()
+	}
+	widthIndex, maskIndex := map[int]int{128: 0, 256: 1, 512: 2}[f.width], 0
+	if f.masked {
+		maskIndex = 1
+	}
+	index, offset, zoffset, extent := 0, 0, 2, 2
+	switch rule.Ytab {
+	case "_yvperm2f128":
+		if evex || f.width != 256 || !immediate || f.unary || selector < 0 {
+			return fail()
+		}
+	case "_yvpermd":
+		if immediate || f.width == 128 || !evex && f.width != 256 {
+			return fail()
+		}
+		extent = 8
+		if evex {
+			index, offset, zoffset = 1+(widthIndex-1)*2+maskIndex, 2+(widthIndex-1)*3, maskIndex*3
+		}
+	case "_yvpermilpd":
+		extent = 26
+		index, offset = 4+widthIndex, 4+widthIndex*2
+		if immediate {
+			index, offset, zoffset = widthIndex*2, widthIndex*2, 0
+			if selector < 0 {
+				index, zoffset = index+1, 2
+			}
+		}
+		if evex {
+			index, offset, zoffset = 12+widthIndex*2+maskIndex, 17+widthIndex*3, maskIndex*3
+			if immediate {
+				index, offset = 6+widthIndex*2+maskIndex, 8+widthIndex*3
+			}
+		}
+	case "_yvpermq":
+		if f.width == 128 || !evex && (!immediate || f.width != 256) {
+			return fail()
+		}
+		extent = 14
+		index, zoffset = 0, 0
+		if selector < 0 {
+			index, zoffset = 1, 2
+		}
+		if evex {
+			index, offset, zoffset = 6+(widthIndex-1)*2+maskIndex, 8+(widthIndex-1)*3, maskIndex*3
+			if immediate {
+				index, offset = 2+(widthIndex-1)*2+maskIndex, 2+(widthIndex-1)*3
+			}
+		}
+	case "_yvshuff32x4":
+		if !evex || f.width == 128 || !immediate || f.unary {
+			return fail()
+		}
+		index, offset, zoffset, extent = (widthIndex-1)*2+maskIndex, (widthIndex-1)*3, maskIndex*3, 6
+	default:
+		return fail()
+	}
+	if !evex && f.width == 512 || rule.RowIndex != index || rule.EncodingOffset != offset ||
+		rule.ZOffset != zoffset || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	w, bits := "W0", 32
+	if rule.Ytab == "_yvpermq" || strings.HasSuffix(rule.Opcode, "64X2") ||
+		evex && rule.Ytab == "_yvpermilpd" && strings.HasSuffix(rule.Opcode, "PD") {
+		w, bits = "W1", 64
+	}
+	opcodeMap, mapByte := "0F38", byte(2)
+	if immediate {
+		opcodeMap, mapByte = "0F3A", 3
+	}
+	if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{
+		"avxEscape", kind + strconv.Itoa(f.width), kind + "66", kind + opcodeMap, kind + w,
+	}, nil); err != nil {
+		return fail()
+	}
+	opcodeOffset := offset + 1
+	if evex {
+		features := []string{"evexN" + strconv.Itoa(f.width/8), "evexBcstN" + strconv.Itoa(bits/8), "evexZeroingEnabled"}
+		if _, err := x86PackedEncodingAtoms(rule.OpBytes[offset+1], features, nil); err != nil {
+			return fail()
+		}
+		f.broadcast, opcodeOffset = true, opcodeOffset+1
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[opcodeOffset], 0, 8)
+	if err != nil {
+		return fail()
+	}
+	f.encoding = x86PackedAVXOpcode{kind: kind, mapByte: mapByte, pp: 1, length: byte(widthIndex), opcode: byte(opcode)}
+	if w == "W1" {
+		f.encoding.wBit = 0x80
+	}
+	return f.witnessesWithControl(rule.Opcode, immediate, selector), nil
+}
diff --git a/internal/goasmrules/x86_witness_permutation_shuffle_test.go b/internal/goasmrules/x86_witness_permutation_shuffle_test.go
new file mode 100644
index 000000000..a70d7c732
--- /dev/null
+++ b/internal/goasmrules/x86_witness_permutation_shuffle_test.go
@@ -0,0 +1,185 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86PermutationShuffleTestNames = `VPERMILPD VPERMILPS VPERMPD VPERMQ
+	VPERMD VPERMPS VPERM2F128 VPERM2I128
+	VSHUFF32X4 VSHUFF64X2 VSHUFI32X4 VSHUFI64X2`
+
+func TestX86PermutationShuffleCompleteOriginalRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := map[string][2]int{
+		"VPERMILPD": {18, 66}, "VPERMILPS": {18, 66},
+		"VPERMPD": {10, 40}, "VPERMQ": {10, 40},
+		"VPERMD": {5, 20}, "VPERMPS": {5, 20},
+		"VPERM2F128": {1, 2}, "VPERM2I128": {1, 2},
+		"VSHUFF32X4": {4, 18}, "VSHUFF64X2": {4, 18},
+		"VSHUFI32X4": {4, 18}, "VSHUFI64X2": {4, 18},
+	}
+	originals := map[string]X86AVXRule{}
+	for index, rule := range avx {
+		if _, found := expected[rule.Opcode]; found {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)] = rule
+		}
+	}
+	if len(originals) != 84 || len(strings.Fields(x86PermutationShuffleTestNames)) != 12 {
+		t.Fatal("complete source closure changed", len(originals))
+	}
+	for _, entry := range legacy.Optab {
+		if _, found := expected[entry.Opcode]; found {
+			t.Fatal("AVX permutation closure acquired a legacy source row", entry)
+		}
+	}
+	// Current helper: the first real RED must be a genuine format limitation,
+	// not a missing future join API or an uninitialized synthetic program.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86PermutationShuffleTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, spellings, members := map[string]bool{}, map[string]bool{}, map[string][2]int{}
+	for _, row := range rows {
+		rule, found := originals[row.ID]
+		if !found || seen[row.ID] || rule.Opcode != row.Opcode {
+			t.Fatal("lost original source row identity", row)
+		}
+		seen[row.ID] = true
+		count := members[row.Opcode]
+		count[0]++
+		for _, witness := range row.Witnesses {
+			fields := strings.Fields(witness.Instruction)
+			if len(fields) != 2 || spellings[witness.Instruction] || witness.MaskResult {
+				t.Fatal("duplicate or foreign permutation result", row.ID, witness)
+			}
+			args := strings.Split(fields[1], ",")
+			if len(args) != len(rule.Classes) || len(witness.Encoding) == 0 {
+				t.Fatal("incomplete original operand/encoding witness", row.ID, witness)
+			}
+			immediate := rule.Classes[0] == "Yu8" || rule.Classes[0] == "Yi8"
+			first := 0
+			if immediate {
+				first = 1
+				literal := "$7"
+				if rule.Classes[0] == "Yi8" {
+					literal = "$-1"
+				}
+				encoded := byte(7)
+				if rule.Classes[0] == "Yi8" {
+					encoded = 255
+				}
+				if args[0] != literal || witness.Encoding[len(witness.Encoding)-1] != encoded {
+					t.Fatal("signed/unsigned source rows or imm8 transport merged", row.ID, witness)
+				}
+			}
+			masked := strings.Contains(strings.Join(rule.Classes, ","), "Yknot0")
+			unary := immediate && len(rule.Classes) == 3 || immediate && masked && len(rule.Classes) == 4
+			width := map[string]int{"Yxm": 128, "YxmEvex": 128, "Yym": 256, "YymEvex": 256, "Yzm": 512}[rule.Classes[first]]
+			if len(args) != len(rule.Classes) || witness.Width != width || witness.Masked != masked || masked && args[len(args)-2] != "K1" ||
+				witness.First != args[first] || witness.Destination != args[len(args)-1] ||
+				witness.Memory != (witness.First == "(AX)") ||
+				witness.Zeroing != strings.Contains(fields[0], ".Z") || witness.Zeroing && !masked ||
+				witness.Broadcast != strings.Contains(fields[0], ".BCST") || witness.Broadcast && !witness.Memory ||
+				unary && witness.Second != "" || !unary && witness.Second != args[first+1] {
+				t.Fatal("source/control/result roles or width/tuple/mask were confused", row.ID, witness)
+			}
+			spellings[witness.Instruction] = true
+			count[1]++
+		}
+		members[row.Opcode] = count
+	}
+	if len(seen) != 84 || len(spellings) != 328 || len(members) != 12 {
+		t.Fatal("complete row/witness closure changed", len(seen), len(spellings), len(members))
+	}
+	for name, want := range expected {
+		if members[name] != want {
+			t.Fatal("member lost original rows or controls", name, members[name], want)
+		}
+	}
+}
+
+func TestX86PermutationShuffleRejectsForeignPhysicalAxes(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := " " + strings.Join(strings.Fields(x86PermutationShuffleTestNames), " ") + " "
+	count := 0
+	for _, original := range avx {
+		if !strings.Contains(names, " "+original.Opcode+" ") {
+			continue
+		}
+		if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+			t.Fatal("negative control has no valid original", original, err)
+		}
+		for _, axis := range []string{"prefix", "table", "ordinal", "offset", "stride", "source", "destination", "header", "payload", "mask", "W", "tuple", "broadcast"} {
+			t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, original.RowIndex, axis), func(t *testing.T) {
+				changed := original
+				changed.Classes = append([]string(nil), original.Classes...)
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				switch axis {
+				case "prefix":
+					changed.Prefix = "Pm"
+				case "table":
+					changed.Ytab = "_foreign_permutation"
+				case "ordinal":
+					changed.RowIndex += 1000
+				case "offset":
+					changed.EncodingOffset++
+				case "stride":
+					changed.ZOffset++
+				case "source":
+					changed.Classes[0] = "Yrl"
+				case "destination":
+					changed.Classes[len(changed.Classes)-1] = "Yk"
+				case "header":
+					changed.OpBytes[changed.EncodingOffset] += "|foreignPermutationAxis"
+				case "payload":
+					index := changed.EncodingOffset + 1
+					if strings.HasPrefix(changed.ZCase, "Zevex_") {
+						index++
+					}
+					changed.OpBytes[index] = "0x100"
+				case "mask":
+					changed.Classes = append(changed.Classes, "Yknot0")
+				case "W":
+					header := changed.OpBytes[changed.EncodingOffset]
+					if strings.Contains(header, "W0") {
+						header = strings.Replace(header, "W0", "W1", 1)
+					} else {
+						header = strings.Replace(header, "W1", "W0", 1)
+					}
+					changed.OpBytes[changed.EncodingOffset] = header
+				case "tuple", "broadcast":
+					if strings.HasPrefix(changed.ZCase, "Zevex_") {
+						index := changed.EncodingOffset + 1
+						if axis == "tuple" {
+							changed.OpBytes[index] = strings.ReplaceAll(changed.OpBytes[index], "evexN", "foreignN")
+						} else {
+							changed.OpBytes[index] = strings.ReplaceAll(changed.OpBytes[index], "evexBcstN", "foreignBcstN")
+						}
+					} else {
+						changed.OpBytes[changed.EncodingOffset] += "|evexN16"
+					}
+				}
+				if witnesses, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("foreign physical axis silently accepted", axis, changed, witnesses)
+				}
+			})
+		}
+		count++
+	}
+	if count != 84 {
+		t.Fatal("foreign-axis controls lost original source rows", count)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_reciprocal14_test.go b/internal/goasmrules/x86_witness_reciprocal14_test.go
new file mode 100644
index 000000000..c95a834f2
--- /dev/null
+++ b/internal/goasmrules/x86_witness_reciprocal14_test.go
@@ -0,0 +1,83 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86Reciprocal14OfficialRowsAndControls(t *testing.T) {
+	build := func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+		return x86PackedBinaryRows(legacy, avx,
+			"VRCP14PS VRCP14PD VRCP14SS VRCP14SD VRSQRT14PS VRSQRT14PD VRSQRT14SS VRSQRT14SD")
+	}
+	inventory := x86CheckPackedRowInventory(t, build, `^V(RCP|RSQRT)14(P[SD]|S[SD])$`, `P[SD]$`, x86PackedRowCounts{
+		names: 8, broadcast: 36,
+		rows: [3]int{0, 0, 32}, formats: [3]int{0, 0, 132}, widths: [3]int{60, 36, 36},
+	})
+	// Complete independent byte attributes. Scalar SS/SD here use 66, not
+	// the F3/F2 prefix used by the separate VADDSS/VADDSD scalar format.
+	for _, member := range []struct {
+		name   string
+		opcode byte
+		w      int
+		scalar bool
+	}{
+		{"VRCP14PS", 0x4c, 0, false}, {"VRCP14PD", 0x4c, 1, false},
+		{"VRCP14SS", 0x4d, 0, true}, {"VRCP14SD", 0x4d, 1, true},
+		{"VRSQRT14PS", 0x4e, 0, false}, {"VRSQRT14PD", 0x4e, 1, false},
+		{"VRSQRT14SS", 0x4f, 0, true}, {"VRSQRT14SD", 0x4f, 1, true},
+	} {
+		var payload []string
+		widths := []int{128, 256, 512}
+		if member.scalar {
+			widths = widths[:1]
+		}
+		for _, width := range widths {
+			tuple, features := width/8, ""
+			if member.scalar {
+				tuple = 4 << member.w
+			} else {
+				features = fmt.Sprintf(" | evexBcstN%d", 4<<member.w)
+			}
+			payload = append(payload,
+				fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d", width, member.w),
+				fmt.Sprintf("evexN%d%s | evexZeroingEnabled", tuple, features), fmt.Sprintf("0x%02X", member.opcode))
+		}
+		count := 0
+		for _, rule := range inventory.avx {
+			if rule.Opcode != member.name {
+				continue
+			}
+			table, zcase, rows := "_yvexpandpd", "Zevex_rm_v_r", 6
+			if member.scalar {
+				table, rows = "_yvgetexpsd", 2
+			}
+			if count%2 != 0 {
+				zcase = "Zevex_rm_k_r"
+				if member.scalar {
+					zcase = "Zevex_rm_v_k_r"
+				}
+			}
+			if count >= rows || rule.RowIndex != count || rule.Ytab != table || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*3 || rule.EncodingOffset != count/2*3 ||
+				!reflect.DeepEqual(rule.OpBytes, payload) {
+				t.Fatal("complete reciprocal14 official row or byte attributes changed", member.name, rule)
+			}
+			count++
+		}
+		if count != len(widths)*2 {
+			t.Fatal("reciprocal14 member lost an official row", member.name, count)
+		}
+	}
+	for _, row := range inventory.rows {
+		scalar := strings.HasSuffix(row.Opcode, "SS") || strings.HasSuffix(row.Opcode, "SD")
+		for _, witness := range row.Witnesses {
+			if (witness.Second != "") != scalar || witness.MaskResult || strings.Contains(witness.Instruction, "SAE") ||
+				scalar && (witness.Width != 128 || witness.Broadcast) {
+				t.Fatal("reciprocal14 operand transport acquired another format", row.ID, witness)
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_remaining_avx_test.go b/internal/goasmrules/x86_witness_remaining_avx_test.go
new file mode 100644
index 000000000..6f2716a46
--- /dev/null
+++ b/internal/goasmrules/x86_witness_remaining_avx_test.go
@@ -0,0 +1,149 @@
+package goasmrules
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This tests source-row grammar only. A witness is not stock-Go selection,
+// a public translated function, an LLVM object or executed semantics.
+func TestX86RemainingAVXSemanticClosuresExistingWitnesses(t *testing.T) {
+	groups := []struct {
+		name    string
+		rows    int
+		members string
+	}{
+		{"FP-unary-scaled-rounding", 90, `
+			VEXP2PD VEXP2PS VGETEXPPD VGETEXPPS VGETEXPSD VGETEXPSS
+			VRCP28PD VRCP28PS VRCP28SD VRCP28SS VRCPPS VRCPSS
+			VROUNDPD VROUNDPS VROUNDSD VROUNDSS VRSQRT28PD VRSQRT28PS
+			VRSQRT28SD VRSQRT28SS VRSQRTPS VRSQRTSS VSCALEFPD VSCALEFPS
+			VSCALEFSD VSCALEFSS VSQRTPD VSQRTPS VSQRTSD VSQRTSS
+		`},
+		{"indexed-memory", 80, `
+			VGATHERDPD VGATHERDPS VGATHERPF0DPD VGATHERPF0DPS VGATHERPF0QPD VGATHERPF0QPS
+			VGATHERPF1DPD VGATHERPF1DPS VGATHERPF1QPD VGATHERPF1QPS VGATHERQPD VGATHERQPS
+			VPGATHERDD VPGATHERDQ VPGATHERQD VPGATHERQQ VPSCATTERDD VPSCATTERDQ
+			VPSCATTERQD VPSCATTERQQ VSCATTERDPD VSCATTERDPS VSCATTERPF0DPD VSCATTERPF0DPS
+			VSCATTERPF0QPD VSCATTERPF0QPS VSCATTERPF1DPD VSCATTERPF1DPS VSCATTERPF1QPD VSCATTERPF1QPS
+			VSCATTERQPD VSCATTERQPS
+		`},
+		{"FP-compare-class", 46, `
+			VCMPPD VCMPPS VCMPSD VCMPSS VCOMISD VCOMISS
+			VFPCLASSPDX VFPCLASSPDY VFPCLASSPDZ VFPCLASSPSX VFPCLASSPSY VFPCLASSPSZ
+			VFPCLASSSD VFPCLASSSS VUCOMISD VUCOMISS
+		`},
+		{"horizontal-blend-dot-SAD", 37, `
+			VADDSUBPD VADDSUBPS VBLENDPD VBLENDPS VBLENDVPD VBLENDVPS
+			VDPPD VDPPS VHADDPD VHADDPS VHSUBPD VHSUBPS
+			VMPSADBW VPBLENDD VPBLENDVB VPBLENDW VPHMINPOSUW VPSADBW
+		`},
+		{"GP-BMI", 28, `
+			ANDNL ANDNQ BEXTRL BEXTRQ BLSIL BLSIQ
+			BLSMSKL BLSMSKQ BLSRL BLSRQ BZHIL BZHIQ
+			MULXL MULXQ PDEPL PDEPQ PEXTL PEXTQ
+			RORXL RORXQ SARXL SARXQ SHLXL SHLXQ
+			SHRXL SHRXQ
+		`},
+		{"crypto", 28, `
+			VAESDEC VAESDECLAST VAESENC VAESENCLAST VAESIMC VAESKEYGENASSIST
+			VPCLMULQDQ
+		`},
+		{"four-register-special", 12, `
+			V4FMADDPS V4FMADDSS V4FNMADDPS V4FNMADDSS VP4DPWSSD VP4DPWSSDS
+		`},
+		{"packed-string-compare", 8, `
+			VPCMPESTRI VPCMPESTRM VPCMPISTRI VPCMPISTRM
+		`},
+		{"bit-shuffle-to-K", 6, `
+			VPSHUFBITQMB
+		`},
+		{"vector-test-FLAGS", 6, `
+			VPTEST VTESTPD VTESTPS
+		`},
+		{"state-control", 4, `
+			VLDMXCSR VSTMXCSR VZEROALL VZEROUPPER
+		`},
+	}
+	if len(groups) != 11 {
+		t.Fatal("complete remaining semantic closure changed", len(groups))
+	}
+	selected := make(map[string]int)
+	for index, group := range groups {
+		for _, name := range strings.Fields(group.members) {
+			if _, duplicate := selected[name]; duplicate {
+				t.Fatal("source member belongs to more than one remaining closure", name)
+			}
+			selected[name] = index
+		}
+	}
+	if len(selected) != 147 {
+		t.Fatal("complete remaining source namespace changed", len(selected))
+	}
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	type originalRow struct {
+		id   string
+		rule X86AVXRule
+	}
+	rows := make([][]originalRow, len(groups))
+	seen := make(map[string]bool)
+	total := 0
+	for index, rule := range rules {
+		group, retained := selected[rule.Opcode]
+		if !retained {
+			continue
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)
+		rows[group] = append(rows[group], originalRow{id, rule})
+		seen[rule.Opcode] = true
+		total++
+	}
+	if total != 345 || len(seen) != 147 {
+		t.Fatal("retain all original rows and members, without shadow/direction filtering", total, len(seen))
+	}
+	for index, group := range groups {
+		if len(rows[index]) != group.rows {
+			t.Fatal("complete original semantic family row count changed", group.name, len(rows[index]), group.rows)
+		}
+		t.Run(group.name, func(t *testing.T) {
+			for _, original := range rows[index] {
+				t.Run(original.id, func(t *testing.T) {
+					// Preserve the full literal row, including ordinal, payload,
+					// offset and source classes. Never rebuild it from a witness.
+					before, err := json.Marshal(original.rule)
+					if err != nil {
+						t.Fatal(err)
+					}
+					t.Logf("original_source_id=%s original_rule=%s", original.id, before)
+					// A panic is a failing row too; retain later rows in this
+					// discovery run rather than losing the remaining directory.
+					defer func() {
+						if failure := recover(); failure != nil {
+							t.Errorf("existing witness helper panicked for original row %s: %v", original.id, failure)
+						}
+					}()
+					witnesses, err := x86PackedAVXRowWitnesses(original.rule)
+					after, encodeErr := json.Marshal(original.rule)
+					if encodeErr != nil || !bytes.Equal(before, after) {
+						t.Fatal("witness helper changed the original source metadata", original.id, encodeErr)
+					}
+					if err != nil || len(witnesses) == 0 {
+						t.Fatal("original row has no complete current witness grammar; not evidence of translator/ISA rejection", original.id, err)
+					}
+					for _, witness := range witnesses {
+						if witness.Instruction == "" || len(witness.Encoding) == 0 {
+							t.Fatal("existing witness lost a complete source or expected encoding", original.id, witness)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_rotate_test.go b/internal/goasmrules/x86_witness_rotate_test.go
new file mode 100644
index 000000000..7f3c01c2f
--- /dev/null
+++ b/internal/goasmrules/x86_witness_rotate_test.go
@@ -0,0 +1,202 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedRotateCompleteOfficialTransport(t *testing.T) {
+	// Use the existing transport, so a missing immediate format is a test
+	// failure rather than an undefined future family-selector compilation error.
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx,
+				`VPROLD VPROLQ VPRORD VPRORQ VPROLVD VPROLVQ VPRORVD VPRORVQ`)
+		}, `^VPRO[LR]V?[DQ]$`, `^VPRO[LR]V?[DQ]$`, x86PackedRowCounts{
+			names: 8, broadcast: 72,
+			rows: [3]int{0, 0, 48}, formats: [3]int{0, 0, 216}, widths: [3]int{72, 72, 72},
+		})
+	members := []struct {
+		name     string
+		bits     int
+		left     bool
+		variable bool
+	}{
+		{"VPROLD", 32, true, false}, {"VPROLQ", 64, true, false},
+		{"VPRORD", 32, false, false}, {"VPRORQ", 64, false, false},
+		{"VPROLVD", 32, true, true}, {"VPROLVQ", 64, true, true},
+		{"VPRORVD", 32, false, true}, {"VPRORVQ", 64, false, true},
+	}
+	var expectedIDs []string
+	for _, member := range members {
+		table, plain, masked, stride := "_yvprold", "Zevex_i_rm_vo", "Zevex_i_rm_k_vo", 4
+		if member.variable {
+			table, plain, masked, stride = "_yvblendmpd", "Zevex_rm_v_r", "Zevex_rm_v_k_r", 3
+		}
+		var payload []string
+		for _, width := range []int{128, 256, 512} {
+			mapName, opcode := "evex0F", "0x72"
+			if member.variable {
+				mapName, opcode = "evex0F38", "0x14"
+				if member.left {
+					opcode = "0x15"
+				}
+			}
+			payload = append(payload,
+				fmt.Sprintf("avxEscape | evex%d | evex66 | %s | evexW%d", width, mapName, member.bits/32-1),
+				fmt.Sprintf("evexN%d | evexBcstN%d | evexZeroingEnabled", width/8, member.bits/8), opcode)
+			if !member.variable {
+				extension := "00"
+				if member.left {
+					extension = "01"
+				}
+				payload = append(payload, extension)
+			}
+		}
+		count := 0
+		for index, rule := range inventory.avx {
+			if rule.Opcode != member.name {
+				continue
+			}
+			if count >= 6 {
+				t.Fatal("rotate member acquired an unaccounted official row", member.name, rule)
+			}
+			bank := []string{"YxmEvex,YxrEvex", "YymEvex,YyrEvex", "Yzm,Yzr"}[count/2]
+			classes := strings.Split(bank, ",")
+			if member.variable {
+				classes = []string{classes[0], classes[1], classes[1]}
+			} else {
+				classes = append([]string{"Yu8"}, classes...)
+			}
+			zcase := plain
+			if count%2 != 0 {
+				zcase = masked
+				classes = append(classes[:len(classes)-1], "Yknot0", classes[len(classes)-1])
+			}
+			if rule.RowIndex != count || rule.Ytab != table || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*stride || rule.EncodingOffset != count/2*stride ||
+				!reflect.DeepEqual(rule.Classes, classes) || !reflect.DeepEqual(rule.OpBytes, payload) {
+				t.Fatal("complete rotate count/data format or encoding attributes changed", member.name, rule)
+			}
+			expectedIDs = append(expectedIDs, fmt.Sprintf("avx/%d/%s/%s/%d", index, member.name, table, count))
+			count++
+		}
+		if count != 6 {
+			t.Fatal("complete rotate member lost official rows", member.name, count)
+		}
+	}
+	var actualIDs []string
+	var fullVariable []X86PackedBinaryRow
+	zeroing := 0
+	for _, row := range inventory.rows {
+		actualIDs = append(actualIDs, row.ID)
+		variable := strings.Contains(row.ID, "/_yvblendmpd/")
+		if variable {
+			fullVariable = append(fullVariable, row)
+		}
+		for _, witness := range row.Witnesses {
+			operands := strings.Split(strings.Fields(witness.Instruction)[1], ",")
+			first := 0
+			if !variable {
+				first = 1
+			}
+			wrongSecond := variable && witness.Second == "" || !variable && witness.Second != ""
+			if witness.First == "" || witness.First != operands[first] ||
+				witness.Memory != (witness.First == "(AX)") || wrongSecond ||
+				witness.MaskResult || strings.Contains(witness.Instruction, "SAE") {
+				t.Fatal("rotate count source acquired another format's operand role", row.ID, witness)
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+		}
+	}
+	// Both slices follow official source order, not the semantic member order.
+	var sourceOrderIDs []string
+	wanted := map[string]bool{}
+	for _, id := range expectedIDs {
+		wanted[id] = true
+	}
+	for index, rule := range inventory.avx {
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)
+		if wanted[id] {
+			sourceOrderIDs = append(sourceOrderIDs, id)
+		}
+	}
+	if zeroing != 72 || !reflect.DeepEqual(actualIDs, sourceOrderIDs) {
+		t.Fatal("complete rotate source IDs or mask-control denominator changed", zeroing)
+	}
+	previous, err := X86PackedEVEXBinaryRemainderRows(inventory.legacy, inventory.avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var previousVariable []X86PackedBinaryRow
+	for _, row := range previous {
+		if strings.HasPrefix(row.Opcode, "VPROLV") || strings.HasPrefix(row.Opcode, "VPRORV") {
+			previousVariable = append(previousVariable, row)
+		}
+	}
+	if len(previousVariable) != 24 || !reflect.DeepEqual(fullVariable, previousVariable) {
+		t.Fatal("whole-family owner changed previously joined variable rows or witness fields")
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VPROLD $7,X16,X18", []byte{0x62, 0xb1, 0x6d, 0x00, 0x72, 0xc8, 7}},
+		{"VPROLQ.BCST.Z $7,(AX),K1,Z18", []byte{0x62, 0xf1, 0xed, 0xd1, 0x72, 0x08, 7}},
+		{"VPRORD $7,X16,X18", []byte{0x62, 0xb1, 0x6d, 0x00, 0x72, 0xc0, 7}},
+		{"VPRORQ.BCST $7,(AX),Y18", []byte{0x62, 0xf1, 0xed, 0x30, 0x72, 0x00, 7}},
+		{"VPROLVD (AX),Y17,Y18", []byte{0x62, 0xe2, 0x75, 0x20, 0x15, 0x10}},
+		{"VPROLVQ.BCST.Z (AX),X17,K1,X18", []byte{0x62, 0xe2, 0xf5, 0x91, 0x15, 0x10}},
+		{"VPRORVD X16,X17,X18", []byte{0x62, 0xa2, 0x75, 0x00, 0x14, 0xd0}},
+		{"VPRORVQ.Z Z16,Z17,K1,Z18", []byte{0x62, 0xa2, 0xf5, 0xc1, 0x14, 0xd0}},
+	})
+}
+
+func TestX86PackedRotateTransportRejectsForeignCountFormats(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"signed-immediate", "uniform-count", "narrow-count", "SAE", "immediate-table", "VEX"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, row := "VPROLD", 0
+			if mutation == "narrow-count" || mutation == "immediate-table" {
+				name, row = "VPROLVD", 2
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != row {
+					continue
+				}
+				found++
+				changed := original
+				changed.Classes = append([]string(nil), original.Classes...)
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				switch mutation {
+				case "signed-immediate":
+					changed.Classes[0] = "Yi8"
+				case "uniform-count":
+					changed.Classes[0] = "YxmEvex"
+				case "narrow-count":
+					changed.Classes[0] = "YxmEvex"
+				case "SAE":
+					changed.OpBytes[1] += " | evexSaeEnabled"
+				case "immediate-table":
+					changed.Ytab = "_yvprold"
+				case "VEX":
+					changed.ZCase = "Zvex_i_rm_vo"
+					changed.Classes = []string{"Yu8", "Yxr", "Yxr"}
+					changed.OpBytes = []string{"avxEscape | vex128 | vex66 | vex0F | vexW0", "0x72", "01"}
+				}
+				if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("rotate transport borrowed another count grammar or FP control", mutation, changed)
+				}
+			}
+			if found != 1 {
+				t.Fatal("mutation lost its exact official source row", name, row, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_rows.go b/internal/goasmrules/x86_witness_rows.go
new file mode 100644
index 000000000..ac314fbe4
--- /dev/null
+++ b/internal/goasmrules/x86_witness_rows.go
@@ -0,0 +1,1145 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86PackedBinaryRow retains the owning official table row. Witnesses are
+// expectations, not evidence that Go assembled or plan9asm translated them.
+type X86PackedBinaryRow struct {
+	ID, Opcode string
+	Witnesses  []X86PackedBinaryWitness
+}
+
+// Unary and immediate AVX rows leave Second empty, as do legacy unary immediates;
+// legacy RMW immediates leave First empty and retain data/destination in Second.
+// Syntax fields do not certify reads: typed effects own mask and old bytes.
+type X86PackedBinaryWitness struct {
+	Instruction, Generation    string
+	First, Second, Destination string
+	Width                      int
+	Memory, Masked, Zeroing    bool
+	Broadcast                  bool
+	MaskResult                 bool
+	Encoding                   []byte
+}
+
+// X86GPBMIRows retains the complete scalar BMI/bit-field VEX row grammar.
+// Shared transport does not merge FLAGS, implicit DX or dual-output semantics.
+func X86GPBMIRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `ANDNL ANDNQ BEXTRL BEXTRQ
+		BLSIL BLSIQ BLSMSKL BLSMSKQ BLSRL BLSRQ BZHIL BZHIQ MULXL MULXQ
+		PDEPL PDEPQ PEXTL PEXTQ RORXL RORXQ SARXL SARXQ SHLXL SHLXQ SHRXL SHRXQ`)
+}
+
+// X86PrecisionHalfScalarConversionRows retains all ordinary precision, F16C
+// and scalar FP/GP conversions; numerical and native contracts stay separate.
+func X86PrecisionHalfScalarConversionRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VCVTPD2PS VCVTPD2PSX VCVTPD2PSY VCVTPS2PD
+  VCVTPH2PS VCVTPS2PH VCVTSD2SS VCVTSS2SD
+  VCVTSD2SI VCVTSD2SIQ VCVTSS2SI VCVTSS2SIQ
+  VCVTTSD2SI VCVTTSD2SIQ VCVTTSS2SI VCVTTSS2SIQ
+  VCVTSD2USIL VCVTSD2USIQ VCVTSS2USIL VCVTSS2USIQ
+  VCVTTSD2USIL VCVTTSD2USIQ VCVTTSS2USIL VCVTTSS2USIQ
+  VCVTSI2SDL VCVTSI2SDQ VCVTSI2SSL VCVTSI2SSQ
+  VCVTUSI2SDL VCVTUSI2SDQ VCVTUSI2SSL VCVTUSI2SSQ`)
+}
+
+// X86MoveRemainderRows retains complete scalar, half, GP/vector, sign-mask
+// and non-temporal move tables, including named-source shadow alternatives.
+func X86MoveRemainderRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VLDDQU VMASKMOVDQU VMASKMOVPD VMASKMOVPS
+		VMOVD VMOVHLPS VMOVHPD VMOVHPS VMOVLHPS VMOVLPD VMOVLPS
+		VMOVMSKPD VMOVMSKPS VMOVNTDQ VMOVNTDQA VMOVNTPD VMOVNTPS
+		VMOVQ VMOVSD VMOVSS VPMASKMOVD VPMASKMOVQ VPMOVMSKB`)
+}
+
+// X86InsertExtractRows retains all original rows, including alternate physical
+// encodings shadowed by earlier named-source rows. Selection needs its observer.
+func X86InsertExtractRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VEXTRACTF128 VEXTRACTI128
+		VEXTRACTF32X4 VEXTRACTF64X2 VEXTRACTI32X4 VEXTRACTI64X2
+		VEXTRACTF32X8 VEXTRACTF64X4 VEXTRACTI32X8 VEXTRACTI64X4
+		VEXTRACTPS VPEXTRB VPEXTRW VPEXTRD VPEXTRQ
+		VINSERTF128 VINSERTI128 VINSERTF32X4 VINSERTF64X2 VINSERTI32X4 VINSERTI64X2
+		VINSERTF32X8 VINSERTF64X4 VINSERTI32X8 VINSERTI64X4 VINSERTPS VPINSRB VPINSRW VPINSRD VPINSRQ`)
+}
+
+// X86PermutationShuffleRows retains complete in-lane, whole-vector and block
+// permutations. Existing I2/T2 and B/W indexed rows keep their original owner.
+func X86PermutationShuffleRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPERMILPD VPERMILPS VPERMPD VPERMQ
+		VPERMD VPERMPS VPERM2F128 VPERM2I128
+		VSHUFF32X4 VSHUFF64X2 VSHUFI32X4 VSHUFI64X2`)
+}
+
+// X86LegacyFloatingBinaryRows retains all six legacy PS/PD/SS/SD binary
+// families. Shared media encoding does not merge their numerical contracts.
+func X86LegacyFloatingBinaryRows(legacy X86LegacyCatalog, _ []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	var names []string
+	for _, entry := range legacy.Optab {
+		if x86LegacyFloatingBinaryMember(entry.Opcode) {
+			names = append(names, entry.Opcode)
+		}
+	}
+	if len(names) != 24 {
+		return nil, fmt.Errorf("incomplete legacy floating binary source family: %d", len(names))
+	}
+	return x86PackedBinaryRows(legacy, nil, strings.Join(names, " "))
+}
+
+func x86LegacyFloatingBinaryMember(opcode string) bool {
+	if len(opcode) < 5 {
+		return false
+	}
+	switch opcode[:len(opcode)-2] {
+	case "ADD", "SUB", "MUL", "DIV", "MIN", "MAX":
+		switch opcode[len(opcode)-2:] {
+		case "PS", "PD", "SS", "SD":
+			return true
+		}
+	}
+	return false
+}
+
+// X86FloatingImmediateControlRows retains the five complete PS/PD/SS/SD
+// immediate-control families. Numerical/environment contracts stay typed.
+func X86FloatingImmediateControlRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		VGETMANTPS VGETMANTPD VGETMANTSS VGETMANTSD
+		VRNDSCALEPS VRNDSCALEPD VRNDSCALESS VRNDSCALESD
+		VREDUCEPS VREDUCEPD VREDUCESS VREDUCESD
+		VFIXUPIMMPS VFIXUPIMMPD VFIXUPIMMSS VFIXUPIMMSD
+		VRANGEPS VRANGEPD VRANGESS VRANGESD`)
+}
+
+// X86CompactExpandRows retains both unary directions and all twelve members.
+// Go-encoded memory .Z compression remains a terminal #UD witness.
+func X86CompactExpandRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VCOMPRESSPS VCOMPRESSPD VPCOMPRESSB VPCOMPRESSW VPCOMPRESSD VPCOMPRESSQ
+		VEXPANDPS VEXPANDPD VPEXPANDB VPEXPANDW VPEXPANDD VPEXPANDQ`)
+}
+
+// X86LeadingImmediateVectorRows retains four distinct numerical families on
+// the original shared immediate/two-vector/vector-result encoding grammar.
+func X86LeadingImmediateVectorRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VALIGND VALIGNQ
+		VPSHLDW VPSHLDD VPSHLDQ VPSHRDW VPSHRDD VPSHRDQ VPTERNLOGD VPTERNLOGQ VDBPSADBW`)
+}
+
+// X86TwoSourceImmediateShuffleRows retains the legacy RMW and AVX three-data
+// forms. Their shared transport does not combine align and shuffle semantics.
+func X86TwoSourceImmediateShuffleRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `PALIGNR VPALIGNR SHUFPD VSHUFPD SHUFPS VSHUFPS`)
+}
+
+// X86GFNIRows retains all named Go multiply and affine/inverse GFNI rows.
+// Matrix qword broadcast is independent from byte-granular result masking.
+func X86GFNIRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VGF2P8MULB VGF2P8AFFINEQB VGF2P8AFFINEINVQB`)
+}
+
+// X86ImmediateIntegerCompareRows retains all signed/unsigned B/W/D/Q
+// immediate comparisons, with K results independent from the input width.
+func X86ImmediateIntegerCompareRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPCMPB VPCMPUB VPCMPW VPCMPUW VPCMPD VPCMPUD VPCMPQ VPCMPUQ`)
+}
+
+// X86IntegerTestMaskRows retains only the eight integer AND/nonzero/zero
+// tests. The bit-shuffle opcode on their shared ytab has its own semantics.
+func X86IntegerTestMaskRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPTESTMB VPTESTMW VPTESTMD VPTESTMQ
+		VPTESTNMB VPTESTNMW VPTESTNMD VPTESTNMQ`)
+}
+
+// X86PackedNumericConversionRows retains ordinary packed FP/integer numeric
+// conversions. The six original MMX rows keep their separate region owner.
+func X86PackedNumericConversionRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		CVTPS2PL CVTTPS2PL CVTPD2PL CVTTPD2PL CVTPL2PS CVTPL2PD
+		VCVTPS2DQ VCVTTPS2DQ VCVTPD2DQX VCVTPD2DQY VCVTTPD2DQX VCVTTPD2DQY VCVTPD2DQ VCVTTPD2DQ
+		VCVTPD2QQ VCVTPD2UQQ VCVTTPD2QQ VCVTTPD2UQQ VCVTPS2UDQ VCVTTPS2UDQ VCVTUDQ2PS
+		VCVTQQ2PD VCVTUQQ2PD VCVTPS2QQ VCVTPS2UQQ VCVTTPS2QQ VCVTTPS2UQQ VCVTUDQ2PD
+		VCVTPD2UDQX VCVTTPD2UDQX VCVTQQ2PSX VCVTUQQ2PSX
+		VCVTPD2UDQY VCVTTPD2UDQY VCVTQQ2PSY VCVTUQQ2PSY
+		VCVTPD2UDQ VCVTTPD2UDQ VCVTQQ2PS VCVTUQQ2PS VCVTDQ2PS VCVTDQ2PD`)
+}
+
+// X86PackedIntegerMinMaxRows retains all amd64 legacy and AVX min/max rows.
+func X86PackedIntegerMinMaxRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PMAXSB PMAXSW PMAXSD PMAXUB PMAXUW PMAXUD
+		PMINSB PMINSW PMINSD PMINUB PMINUW PMINUD
+		VPMAXSB VPMAXSW VPMAXSD VPMAXSQ VPMAXUB VPMAXUW VPMAXUD VPMAXUQ
+		VPMINSB VPMINSW VPMINSD VPMINSQ VPMINUB VPMINUW VPMINUD VPMINUQ`)
+}
+
+// X86PackedAverageMultiplyRows retains the XMM/VEX/EVEX rounded-average,
+// word-product, adjacent multiply-add and widened dword-product families.
+// MMX rows keep their separate region/EMMS contract and are not included.
+func X86PackedAverageMultiplyRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PAVGB PAVGW VPAVGB VPAVGW
+		PMULLW PMULHW PMULHUW PMULHRSW VPMULLW VPMULHW VPMULHUW VPMULHRSW
+		PMADDUBSW PMADDWL VPMADDUBSW VPMADDWD
+		PMULDQ PMULULQ VPMULDQ VPMULUDQ`)
+}
+
+// X86PackedLogicalRows retains packed integer and PS/PD bitwise families,
+// including the separate EVEX D/Q names. MMX regions remain a separate owner.
+func X86PackedLogicalRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PAND PANDN POR PXOR ANDPS ANDPD ANDNPS ANDNPD ORPS ORPD XORPS XORPD
+		VPAND VPANDN VPOR VPXOR VANDPS VANDPD VANDNPS VANDNPD VORPS VORPD VXORPS VXORPD
+		VPANDD VPANDQ VPANDND VPANDNQ VPORD VPORQ VPXORD VPXORQ`)
+}
+
+// X86PackedUnpackRows retains integer and PS/PD low/high interleave families.
+// The six MMX rows retain their separate region and memory-access contracts.
+func X86PackedUnpackRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PUNPCKLBW PUNPCKHBW PUNPCKLWL PUNPCKHWL PUNPCKLLQ PUNPCKHLQ PUNPCKLQDQ PUNPCKHQDQ
+		UNPCKLPS UNPCKHPS UNPCKLPD UNPCKHPD
+		VPUNPCKLBW VPUNPCKHBW VPUNPCKLWD VPUNPCKHWD VPUNPCKLDQ VPUNPCKHDQ VPUNPCKLQDQ VPUNPCKHQDQ
+		VUNPCKLPS VUNPCKHPS VUNPCKLPD VUNPCKHPD`)
+}
+
+// X86PackedNarrowRows retains signed/unsigned saturating dword-to-word and
+// word-to-byte packs. The three MMX rows keep their separate region owner.
+func X86PackedNarrowRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PACKSSLW PACKSSWB PACKUSDW PACKUSWB VPACKSSDW VPACKSSWB VPACKUSDW VPACKUSWB`)
+}
+
+// X86SingleSourceNarrowingRows retains every truncating and saturating store
+// row, including Go-encoded memory.Z forms whose architectural result is #UD.
+func X86SingleSourceNarrowingRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		VPMOVDB VPMOVDW VPMOVQB VPMOVQD VPMOVQW VPMOVWB
+		VPMOVSDB VPMOVSDW VPMOVSQB VPMOVSQD VPMOVSQW VPMOVSWB
+		VPMOVUSDB VPMOVUSDW VPMOVUSQB VPMOVUSQD VPMOVUSQW VPMOVUSWB`)
+}
+
+// X86PackedPerLaneShiftRows retains the complete W/D/Q logical-left,
+// logical-right and arithmetic-right per-lane shift families.
+func X86PackedPerLaneShiftRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		VPSLLVW VPSLLVD VPSLLVQ VPSRLVW VPSRLVD VPSRLVQ VPSRAVW VPSRAVD VPSRAVQ`)
+}
+
+// X86PackedUniformByteShiftRows retains complete XMM and AVX uniform lane
+// shifts and per-128-bit byte shifts. MMX regions keep their separate owner.
+func X86PackedUniformByteShiftRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PSLLW PSLLL PSLLQ PSRLW PSRLL PSRLQ PSRAW PSRAL PSLLO PSRLO
+		VPSLLW VPSLLD VPSLLQ VPSRLW VPSRLD VPSRLQ VPSRAW VPSRAD VPSRAQ VPSLLDQ VPSRLDQ`)
+}
+
+// X86PackedSignRows retains all B/W/D conditional-sign rows. Go's legacy
+// table is XMM-only; VEX adds X/Y forms, without MMX, EVEX or broadcast.
+func X86PackedSignRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `PSIGNB PSIGNW PSIGND VPSIGNB VPSIGNW VPSIGND`)
+}
+
+// X86PackedAbsRows retains all unary B/W/D/Q ABS rows, including each
+// overlapping VEX/EVEX row and the original mask/broadcast attributes.
+func X86PackedAbsRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `PABSB PABSW PABSD VPABSB VPABSW VPABSD VPABSQ`)
+}
+
+// X86PackedBitCountConflictRows retains all EVEX unary bit-count/conflict rows.
+// Their shared encoding grammar does not combine the independent semantic owners.
+func X86PackedBitCountConflictRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPOPCNTB VPOPCNTW VPOPCNTD VPOPCNTQ VPLZCNTD VPLZCNTQ
+		VPCONFLICTD VPCONFLICTQ`)
+}
+
+// X86Reciprocal14Rows retains all packed/scalar EVEX reciprocal14 estimates.
+// The byte grammar owns roles and tuples, not numerical or native authority.
+func X86Reciprocal14Rows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx,
+		"VRCP14PS VRCP14PD VRCP14SS VRCP14SD VRSQRT14PS VRSQRT14PD VRSQRT14SS VRSQRT14SD")
+}
+
+// X86PackedRotateRows retains the complete immediate and per-lane D/Q rotate family.
+// Variable members remain independently owned by the EVEX binary remainder scope.
+func X86PackedRotateRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPROLD VPROLQ VPRORD VPRORQ
+		VPROLVD VPROLVQ VPRORVD VPRORVQ`)
+}
+
+// X86PackedDuplicateRows retains all legacy/VEX/EVEX duplicate-element moves.
+func X86PackedDuplicateRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx,
+		`MOVDDUP MOVSHDUP MOVSLDUP VMOVDDUP VMOVSHDUP VMOVSLDUP`)
+}
+
+// X86PackedImmediateShuffleRows retains every non-MMX legacy/VEX/EVEX source row.
+// PSHUFL and PSHUFD are distinct optab entries, not frontend-only aliases.
+func X86PackedImmediateShuffleRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx,
+		`PSHUFL PSHUFD PSHUFHW PSHUFLW VPSHUFD VPSHUFHW VPSHUFLW`)
+}
+
+// X86PackedWideningRows retains the complete sign/zero-extension source family.
+// Shrinking native tuples and source carriers remain separate from result width.
+func X86PackedWideningRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PMOVSXBW PMOVSXBD PMOVSXBQ PMOVSXWD PMOVSXWQ PMOVSXDQ
+		PMOVZXBW PMOVZXBD PMOVZXBQ PMOVZXWD PMOVZXWQ PMOVZXDQ
+		VPMOVSXBW VPMOVSXBD VPMOVSXBQ VPMOVSXWD VPMOVSXWQ VPMOVSXDQ
+		VPMOVZXBW VPMOVZXBD VPMOVZXBQ VPMOVZXWD VPMOVZXWQ VPMOVZXDQ`)
+}
+
+// X86PackedBroadcastRows retains scalar, block, GP and K-data broadcast rows.
+func X86PackedBroadcastRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		VPBROADCASTB VPBROADCASTW VPBROADCASTD VPBROADCASTQ VBROADCASTSS VBROADCASTSD
+		VBROADCASTI32X2 VBROADCASTF32X2 VBROADCASTF32X4 VBROADCASTF64X2 VBROADCASTI32X4 VBROADCASTI64X2
+		VBROADCASTF32X8 VBROADCASTF64X4 VBROADCASTI32X8 VBROADCASTI64X4
+		VPBROADCASTMB2Q VPBROADCASTMW2D VBROADCASTF128 VBROADCASTI128`)
+}
+
+// X86PackedMoveRows retains the twelve AVX whole-vector move names. Legacy
+// moves are separate; register alternatives belong to the first store rows.
+func X86PackedMoveRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VMOVDQA VMOVDQU VMOVAPD VMOVAPS VMOVUPD VMOVUPS
+		VMOVDQA32 VMOVDQA64 VMOVDQU8 VMOVDQU16 VMOVDQU32 VMOVDQU64`)
+}
+
+// X86PackedHorizontalIntegerRows retains the XMM and VEX horizontal add/sub
+// rows. PHADDD's distinct MMX row keeps its independent region/EMMS owner.
+func X86PackedHorizontalIntegerRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PHADDW PHADDD PHADDSW PHSUBW PHSUBD PHSUBSW
+		VPHADDW VPHADDD VPHADDSW VPHSUBW VPHSUBD VPHSUBSW`)
+}
+
+// X86PackedByteShuffleRows retains byte-indexed vector permutations. The
+// separate VPSHUFBITQMB bit-to-mask family does not share this operand grammar.
+func X86PackedByteShuffleRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `PSHUFB VPSHUFB`)
+}
+
+// X86PackedIntegerCompareRows retains both vector and mask results. MMX's
+// six legacy rows retain their separate region and EMMS contract.
+func X86PackedIntegerCompareRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PCMPEQB PCMPEQW PCMPEQL PCMPEQQ PCMPGTB PCMPGTW PCMPGTL PCMPGTQ
+		VPCMPEQB VPCMPEQW VPCMPEQD VPCMPEQQ VPCMPGTB VPCMPGTW VPCMPGTD VPCMPGTQ`)
+}
+
+// X86PackedMaskBlendRows retains the floating-point and integer mask-blend
+// families. Only the PS/PD/D/Q members permit scalar-memory broadcast.
+func X86PackedMaskBlendRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VBLENDMPS VBLENDMPD VPBLENDMB VPBLENDMW VPBLENDMD VPBLENDMQ`)
+}
+
+// X86FMA3Rows retains the original named fused floating-point rows. The
+// official table owns each member, order, precision and physical encoding.
+func X86FMA3Rows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	var names []string
+	for _, rule := range avx {
+		if strings.HasPrefix(rule.Opcode, "VFM") || strings.HasPrefix(rule.Opcode, "VFNM") {
+			names = append(names, rule.Opcode)
+		}
+	}
+	return x86PackedBinaryRows(legacy, avx, strings.Join(names, " "))
+}
+
+// X86AVXFloatBinaryRows retains the ordinary PS/PD/SS/SD arithmetic rows;
+// legacy, horizontal, alternating and raw FP16 families have separate owners.
+func X86AVXFloatBinaryRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VADDPS VADDPD VADDSS VADDSD VSUBPS VSUBPD VSUBSS VSUBSD
+		VMULPS VMULPD VMULSS VMULSD VDIVPS VDIVPD VDIVSS VDIVSD
+		VMINPS VMINPD VMINSS VMINSD VMAXPS VMAXPD VMAXSS VMAXSD`)
+}
+
+// X86PackedEVEXBinaryRemainderRows retains the remaining _yvblendmpd members.
+// Their common encoding grammar does not imply common old-destination reads.
+func X86PackedEVEXBinaryRemainderRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `VPDPBUSD VPDPBUSDS VPDPWSSD VPDPWSSDS VPMADD52HUQ VPMADD52LUQ
+		VPERMB VPERMW VPERMI2B VPERMI2W VPERMI2D VPERMI2Q VPERMI2PS VPERMI2PD
+		VPERMT2B VPERMT2W VPERMT2D VPERMT2Q VPERMT2PS VPERMT2PD VPMULTISHIFTQB
+		VPROLVD VPROLVQ VPRORVD VPRORVQ VPSHLDVW VPSHLDVD VPSHLDVQ VPSHRDVW VPSHRDVD VPSHRDVQ`)
+}
+
+// X86PackedBinaryPilotRows covers the shared packed add/subtract and D/Q
+// low-multiply pilot. MMX and the separate W multiply family are not included.
+// PADDD is a frontend alias, not an additional official encoder row.
+func X86PackedBinaryPilotRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, `
+		PADDB PADDW PADDL PADDQ PADDSB PADDSW PADDUSB PADDUSW
+		VPADDB VPADDW VPADDD VPADDQ VPADDSB VPADDSW VPADDUSB VPADDUSW
+		PSUBB PSUBW PSUBL PSUBQ PSUBSB PSUBSW PSUBUSB PSUBUSW
+		VPSUBB VPSUBW VPSUBD VPSUBQ VPSUBSB VPSUBSW VPSUBUSB VPSUBUSW
+		PMULLD VPMULLD VPMULLQ`)
+}
+
+func x86PackedBinaryRows(legacy X86LegacyCatalog, avx []X86AVXRule, names string) ([]X86PackedBinaryRow, error) {
+	// Scope names are independent of the translator's registry. All operand,
+	// width, suffix and encoding axes still come from the original Go rows.
+	selected := map[string]bool{}
+	for _, name := range strings.Fields(names) {
+		selected[name] = false
+	}
+	var rows []X86PackedBinaryRow
+	for _, entry := range legacy.Optab {
+		if _, ok := selected[entry.Opcode]; !ok {
+			continue
+		}
+		for _, operand := range entry.Rows {
+			classes := strings.Join(operand.Classes, ",")
+			if (entry.Ytab == "yxcvm1" && classes == "Yxm,Ymr" || entry.Ytab == "yxcvm2" && classes == "Ymm,Yxr") &&
+				operand.RowIndex == 1 && operand.ZCase == "Zm_r_xm" && operand.ZOffset == 2 && operand.UnmatchedOffset == 2 {
+				continue // Original MMX conversions require a separate physical region.
+			}
+			if entry.Ytab == "yps" && entry.Prefix == "Py3" && entry.EscapeAdjustment == 0 &&
+				(operand.RowIndex == 0 && classes == "Ymm,Ymr" && operand.ZCase == "Zm_r_xm" && operand.ZOffset == 1 && operand.UnmatchedOffset == 0 ||
+					operand.RowIndex == 1 && classes == "Yi8,Ymr" && operand.ZCase == "Zibo_m_xm" && operand.ZOffset == 2 && operand.UnmatchedOffset == 1) {
+				continue // The sixteen original MMX rows need their region/EMMS owner.
+			}
+			if operand.RowIndex == 0 && strings.Join(operand.Classes, ",") == "Ymm,Ymr" && operand.UnmatchedOffset == 0 &&
+				(entry.Ytab == "ymm" && operand.ZCase == "Zm_r_xm" && operand.ZOffset == 1 ||
+					entry.Ytab == "ymmxmm0f38" && entry.Prefix == "Px" && entry.EscapeAdjustment == 1 &&
+						operand.ZCase == "Zlitm_r" && operand.ZOffset == 3) {
+				continue // MMX regions have a separate owner and EMMS contract.
+			}
+			witnesses, err := x86PackedLegacyRowWitnesses(entry, operand)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			rows = append(rows, X86PackedBinaryRow{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses,
+			})
+			selected[entry.Opcode] = true
+		}
+	}
+	for index, rule := range avx {
+		if _, ok := selected[rule.Opcode]; !ok {
+			continue
+		}
+		witnesses, err := x86PackedAVXRowWitnesses(rule)
+		if err != nil {
+			return nil, fmt.Errorf("%s/%d: %w", rule.Opcode, rule.RowIndex, err)
+		}
+		rows = append(rows, X86PackedBinaryRow{
+			ID:     fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex),
+			Opcode: rule.Opcode, Witnesses: witnesses,
+		})
+		selected[rule.Opcode] = true
+	}
+	for name, found := range selected {
+		if !found {
+			return nil, fmt.Errorf("official packed opcode %s has no retained row", name)
+		}
+	}
+	return rows, nil
+}
+
+func x86PackedAVXRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	if x86GPBMITab(rule.Ytab) {
+		return x86GPBMIRowWitnesses(rule)
+	}
+	if x86VSIBTable(rule.Ytab) {
+		return x86VSIBRowWitnesses(rule)
+	}
+	if x86SpecialVectorStateRoute(rule) {
+		return x86SpecialVectorStateRowWitnesses(rule)
+	}
+	if x86ConversionRemainderTable(rule.Ytab) {
+		return x86ConversionRemainderRowWitnesses(rule)
+	}
+	if x86MoveRemainderTable(rule.Ytab) {
+		return x86MoveRemainderRowWitnesses(rule)
+	}
+	if x86KDataTable(rule.Opcode) != "" {
+		return x86KDataRowWitnesses(rule)
+	}
+	if strings.HasPrefix(rule.Ytab, "_yvextract") || strings.HasPrefix(rule.Ytab, "_yvinsert") ||
+		rule.Ytab == "_yvpextrw" || rule.Ytab == "_yvpinsrb" {
+		return x86InsertExtractRowWitnesses(rule)
+	}
+	if rule.Ytab == "_yvpermilpd" || rule.Ytab == "_yvpermq" || rule.Ytab == "_yvpermd" ||
+		rule.Ytab == "_yvperm2f128" || rule.Ytab == "_yvshuff32x4" {
+		return x86PermutationShuffleRowWitnesses(rule)
+	}
+	if rule.Ytab == "_yvgetmantpd" || rule.Ytab == "_yvfixupimmpd" || rule.Ytab == "_yvfixupimmsd" {
+		return x86FloatingImmediateControlRowWitnesses(rule)
+	}
+	if strings.HasPrefix(rule.Opcode, "VCOMPRESS") || strings.HasPrefix(rule.Opcode, "VPCOMPRESS") ||
+		strings.HasPrefix(rule.Opcode, "VEXPAND") || strings.HasPrefix(rule.Opcode, "VPEXPAND") {
+		return x86PackedCompactRowWitnesses(rule)
+	}
+	if rule.Ytab == "_yvalignd" {
+		return x86LeadingImmediateVectorRowWitnesses(rule)
+	}
+	if rule.Ytab == "_yvgf2p8affineinvqb" {
+		if rule.Opcode == "VPALIGNR" || rule.Opcode == "VSHUFPS" || rule.Opcode == "VSHUFPD" {
+			return x86LeadingImmediateVectorRowWitnesses(rule)
+		}
+		return x86GFNIAffineRowWitnesses(rule)
+	}
+	if rule.Opcode == "VGF2P8MULB" {
+		if _, err := x86GFNIFormatForRule(rule); err != nil {
+			return nil, err
+		}
+		// Retain the original no-immediate binary witness transport below.
+	}
+	if rule.Ytab == "_yvpcmpb" || rule.Ytab == "_yvpshufbitqmb" {
+		return x86IntegerMaskResultRowWitnesses(rule)
+	}
+	if strings.HasPrefix(rule.Ytab, "_yvcvt") && x86PackedWideningRatio(rule) == 0 {
+		return x86PackedNumericConversionRowWitnesses(rule)
+	}
+	if rule.Ytab == "_yvpmovdb" || rule.Ytab == "_yvpmovdw" {
+		return x86PackedSingleSourceNarrowRowWitnesses(rule)
+	}
+	if strings.HasPrefix(rule.Opcode, "VBROADCAST") || strings.HasPrefix(rule.Opcode, "VPBROADCAST") {
+		return x86PackedBroadcastRowWitnesses(rule)
+	}
+	move, store := x86PackedMoveTable(rule.Ytab), x86PackedMoveStoreRow(rule)
+	shift, extensionRow := x86PackedUniformShiftTable(rule.Ytab), x86PackedImmediateExtensionRow(rule)
+	registerImmediate := x86PackedImmediateRegisterRow(rule)
+	widening := x86PackedWideningRatio(rule)
+	immediate := extensionRow || registerImmediate
+	unary := rule.Ytab == "_yvmovddup" || rule.Ytab == "_yvexpandpd" || move || registerImmediate || widening != 0
+	syntax, err := x86PackedSyntaxWitnesses(rule, unary)
+	if err != nil {
+		return nil, err
+	}
+	masked := rule.ZCase == "Zevex_rm_v_k_r" || rule.ZCase == "Zevex_rm_k_r" ||
+		rule.ZCase == "Zevex_i_rm_k_vo" || rule.ZCase == "Zevex_i_rm_k_r" || store && rule.ZCase == "Zevex_r_k_rm"
+	kind, stride, width := "vex", 2, 128
+	if strings.HasPrefix(rule.ZCase, "Zevex_") {
+		kind, stride = "evex", 3
+	}
+	if extensionRow {
+		stride++
+	}
+	// The validated data/result class owns vector width. Widening has a
+	// smaller independent source carrier; mask results keep their data class.
+	dataClass := rule.Classes[0]
+	if shift || immediate {
+		dataClass = rule.Classes[1]
+	}
+	if widening != 0 {
+		dataClass = rule.Classes[len(rule.Classes)-1]
+	}
+	bank := strings.ToUpper(dataClass[1:2])
+	if bank == "Y" {
+		width = 256
+	} else if bank == "Z" {
+		width = 512
+	}
+	wantClass := map[string]string{"X": "Yxm", "Y": "Yym", "Z": "Yzm"}[bank]
+	if kind == "evex" && bank != "Z" {
+		wantClass += "Evex"
+	}
+	wideningTuple := 0
+	if widening != 0 {
+		wantClass, wideningTuple = x86PackedWideningSource(width/8, widening, kind == "evex")
+	}
+	if shift && !immediate {
+		wantClass = "Yxm"
+		if kind == "evex" {
+			wantClass += "Evex"
+		}
+	}
+	if extensionRow && kind == "vex" {
+		wantClass = "Y" + strings.ToLower(bank) + "r"
+	}
+	wantOffset := stride
+	if kind == "evex" && !masked && rule.Ytab != "_yvpslldq" ||
+		kind == "vex" && immediate && rule.Classes[0] == "Yu8" {
+		wantOffset = 0
+	}
+	memoryClass := rule.Classes[0]
+	if immediate {
+		memoryClass = rule.Classes[1]
+	}
+	if store {
+		memoryClass = rule.Classes[len(rule.Classes)-1]
+	}
+	if memoryClass != wantClass || rule.ZOffset != wantOffset {
+		return nil, fmt.Errorf("generation/class/row stride mismatch")
+	}
+	header := rule.OpBytes[rule.EncodingOffset]
+	optional := []string{kind + "66", kind + "0F", kind + "0F38", kind + "W0", kind + "W1"}
+	if move || rule.Ytab == "_yvaddsd" || rule.Ytab == "_yvmovddup" || registerImmediate {
+		optional = append(optional, kind+"F2", kind+"F3")
+	}
+	atoms, err := x86PackedEncodingAtoms(header, []string{
+		"avxEscape", kind + strconv.Itoa(width),
+	}, optional)
+	if err != nil || atoms[kind+"0F"] == atoms[kind+"0F38"] || atoms[kind+"W0"] == atoms[kind+"W1"] {
+		return nil, fmt.Errorf("unmodeled packed encoding header %q", header)
+	}
+	if widening != 0 && (!atoms[kind+"66"] || !atoms[kind+"0F38"] || !atoms[kind+"W0"]) {
+		return nil, fmt.Errorf("widening prefix, map or W mode differs from its official transport")
+	}
+	duplicate := rule.Ytab == "_yvmovddup" && (atoms[kind+"F2"] || atoms[kind+"F3"])
+	if duplicate && (!atoms[kind+"0F"] || kind == "vex" && !atoms[kind+"W0"] ||
+		kind == "evex" && atoms[kind+"F2"] != atoms[kind+"W1"]) {
+		return nil, fmt.Errorf("duplicate prefix, map or W mode differs from its official transport")
+	}
+	if registerImmediate && (!atoms[kind+"0F"] || !atoms[kind+"W0"]) {
+		return nil, fmt.Errorf("shuffle map or W mode differs from its official transport")
+	}
+	if (shift || extensionRow) && (!atoms[kind+"66"] || !atoms[kind+"0F"] ||
+		(kind == "vex" || rule.Ytab == "_yvpslldq") && !atoms[kind+"W0"]) {
+		return nil, fmt.Errorf("shift prefix or W mode differs from its official transport")
+	}
+	mapByte, wBit, length, pp := byte(1), byte(0), byte(0), byte(0)
+	for index, prefix := range []string{"66", "F3", "F2"} {
+		if atoms[kind+prefix] {
+			if pp != 0 {
+				return nil, fmt.Errorf("conflicting packed mandatory prefixes")
+			}
+			pp = byte(index + 1)
+		}
+	}
+	if registerImmediate && pp == 0 {
+		return nil, fmt.Errorf("shuffle requires its retained mandatory prefix")
+	}
+	if atoms[kind+"0F38"] {
+		mapByte = 2
+	}
+	if atoms[kind+"W1"] {
+		wBit = 0x80
+	}
+	if width == 256 {
+		length = 1
+	} else if width == 512 {
+		length = 2
+	}
+	if kind == "evex" {
+		features := rule.OpBytes[rule.EncodingOffset+1]
+		tuple := width / 8
+		optional := []string{"evexZeroingEnabled", "evexBcstN4", "evexBcstN8"}
+		if widening != 0 {
+			tuple, optional = wideningTuple, []string{"evexZeroingEnabled"}
+		}
+		if registerImmediate {
+			optional = []string{"evexZeroingEnabled"}
+			if atoms["evex66"] {
+				optional = append(optional, "evexBcstN4")
+			}
+		}
+		if duplicate {
+			optional = []string{"evexZeroingEnabled"}
+			if width == 128 && atoms["evexF2"] {
+				tuple = 8 // DDUP.X reads m64; other duplicate tuples stay full width.
+			}
+		}
+		if shift && !immediate {
+			tuple = 16 // Uniform count access stays m128 for X/Y/Z data.
+		}
+		if move || shift && (!immediate || rule.Ytab == "_yvpslldq") {
+			optional = []string{"evexZeroingEnabled"}
+		}
+		if rule.Ytab == "_yvaddsd" || rule.Ytab == "_yvgetexpsd" {
+			tuple = 4
+			if wBit != 0 {
+				tuple = 8
+			}
+			optional = []string{"evexZeroingEnabled"}
+		}
+		if rule.Ytab == "_yvaddpd" && width == 512 || rule.Ytab == "_yvaddsd" {
+			optional = append(optional, "evexRoundingEnabled", "evexSaeEnabled")
+		}
+		if rule.Ytab == "_yvpslldq" {
+			optional = nil // Per-128-bit byte shifts have neither mask nor BCST.
+		}
+		flags, err := x86PackedEncodingAtoms(features, []string{"evexN" + strconv.Itoa(tuple)}, optional)
+		if err != nil || flags["evexBcstN4"] && flags["evexBcstN8"] {
+			return nil, fmt.Errorf("unmodeled packed encoding features %q", features)
+		}
+	}
+	opcodeIndex := rule.EncodingOffset + stride - 1
+	if extensionRow {
+		opcodeIndex--
+	}
+	opcode, err := strconv.ParseUint(rule.OpBytes[opcodeIndex], 0, 8)
+	if err != nil {
+		return nil, fmt.Errorf("packed opcode is not a byte literal")
+	}
+	var extension uint64
+	if extensionRow {
+		extension, err = strconv.ParseUint(rule.OpBytes[opcodeIndex+1], 0, 8)
+		if err != nil || extension > 7 {
+			return nil, fmt.Errorf("immediate opcode extension is not a three-bit literal")
+		}
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, instruction := range syntax {
+		if kind == "evex" {
+			// High banks force EVEX even for unmasked X/Y forms. Low-bank
+			// syntax alone cannot identify overlapping VEX/EVEX rows.
+			if widening != 0 {
+				sourceBank := strings.ToUpper(rule.Classes[0][1:2])
+				if sourceBank != bank {
+					instruction = strings.Replace(instruction, sourceBank+"0", sourceBank+"16", 1)
+				}
+			}
+			instruction = strings.NewReplacer(bank+"0", bank+"16", bank+"1", bank+"17", bank+"2", bank+"18").Replace(instruction)
+		}
+		if kind == "evex" && shift && !immediate {
+			instruction = strings.ReplaceAll(instruction, "X0", "X16")
+		}
+		fields := strings.Fields(instruction)
+		operands := strings.Split(fields[1], ",")
+		second, vvvv, vprime := operands[1], byte(0x70), byte(0)
+		first := operands[0]
+		if immediate {
+			first, second = operands[1], ""
+		}
+		if extensionRow {
+			vvvv = 0x68 // Destination 2/18 is vvvv/V' only in /digit formats.
+		}
+		if unary {
+			// Unary encodings reserve VEX.vvvv and EVEX.V' as ones;
+			// the mask and merging destination remain separate inputs.
+			second, vvvv, vprime = "", 0x78, 0x08
+		}
+		witness := X86PackedBinaryWitness{
+			Instruction: instruction, Generation: kind, Width: width,
+			First: first, Second: second, Destination: operands[len(operands)-1],
+			Memory: first == "(AX)", Masked: masked,
+			Zeroing: strings.HasSuffix(fields[0], ".Z"), Broadcast: strings.Contains(fields[0], ".BCST"),
+			MaskResult: rule.Classes[len(rule.Classes)-1] == "Yk",
+		}
+		modrm := byte(0xd0) // destination 2/18, r/m register 0/16.
+		memory := witness.Memory || store && witness.Destination == "(AX)"
+		if store {
+			modrm = 0xc2 // source 0/16 owns ModRM.reg; destination 2/18 is r/m.
+		}
+		if memory {
+			modrm = 0x10 // the only memory witness is the undisturbed (AX).
+			if store {
+				modrm = 0x00
+			}
+		}
+		if extensionRow {
+			modrm = 0xc0 | byte(extension)<<3
+			if memory {
+				modrm = byte(extension) << 3
+			}
+		}
+		p0, p2 := byte(0), byte(0)
+		if kind == "evex" {
+			p0, p2 = byte(0xa0), length<<5|vprime
+			if memory {
+				p0 = 0xe0
+			}
+			if extensionRow {
+				p0 |= 0x10 // ModRM.reg is /digit, not destination register 18.
+			}
+			if witness.MaskResult {
+				p0 |= 0x10 // K2 has no destination bit 4, unlike vector 18.
+			}
+			if masked {
+				p2 |= 1 // K1; binary V' is zero for the second source 17.
+			}
+			if witness.Zeroing {
+				p2 |= 0x80
+			}
+			if witness.Broadcast {
+				p2 |= 0x10
+			}
+			if strings.Contains(fields[0], ".SAE") {
+				p2 |= 0x10 // SAE keeps LL; embedded rounding replaces it below.
+			}
+			for control, suffix := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				if strings.Contains(fields[0], "."+suffix) {
+					p2 = p2&^0x60 | byte(control)<<5 | 0x10
+				}
+			}
+		}
+		transport := x86PackedAVXOpcode{kind, mapByte, wBit, pp, length, byte(opcode)}
+		witness.Encoding = transport.bytes(vvvv, p0, p2, modrm)
+		if immediate {
+			value, err := strconv.ParseInt(strings.TrimPrefix(operands[0], "$"), 0, 16)
+			if err != nil || value < -128 || value > 255 {
+				return nil, fmt.Errorf("shift witness has no byte immediate")
+			}
+			witness.Encoding = append(witness.Encoding, byte(value))
+		}
+		witnesses = append(witnesses, witness)
+	}
+	return witnesses, nil
+}
+
+// X86SpecialVectorStateRows retains the nine complete non-GP/non-VSIB closures.
+func X86SpecialVectorStateRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	return x86PackedBinaryRows(legacy, avx, x86SpecialVectorStateNames)
+}
+
+func x86PackedEncodingAtoms(expression string, required, optional []string) (map[string]bool, error) {
+	allowed, found := map[string]bool{}, map[string]bool{}
+	for _, term := range append(append([]string(nil), required...), optional...) {
+		allowed[term] = true
+	}
+	for _, term := range strings.FieldsFunc(expression, func(r rune) bool {
+		return r == '|' || r == '(' || r == ')' || r == ' ' || r == '\t' || r == '\n'
+	}) {
+		if !allowed[term] || found[term] {
+			return nil, fmt.Errorf("unrecognized or repeated encoding term %s", term)
+		}
+		found[term] = true
+	}
+	for _, term := range required {
+		if !found[term] {
+			return nil, fmt.Errorf("missing encoding term %s", term)
+		}
+	}
+	return found, nil
+}
+
+func x86PackedLegacyRowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86PackedBinaryWitness, error) {
+	// Captured source must retain the whole original schema/payload even
+	// when this old consumer selects only its ordinary XMM row. Only old
+	// fixtures with neither rows nor a source expression use the partial path.
+	var capturedEncoding []byte
+	if (entry.Ytab == "yxcvm1" || entry.Ytab == "yxcvm2" || entry.Ytab == "ymmxmm0f38") &&
+		(len(entry.Rows) != 0 || entry.OpcodeExpression != "") {
+		var err error
+		capturedEncoding, err = x86LegacyMediaX87Encoding(entry, row)
+		if err != nil {
+			return nil, err
+		}
+	}
+	scalarConversion := x86LegacyScalarConversionTable(entry.Ytab)
+	var scalar x86LegacyScalarConversionForm
+	if scalarConversion {
+		var err error
+		scalar, err = x86LegacyScalarConversionProperties(entry, row)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if entry.Ytab == "yxshuf" || entry.Ytab == "yaes" {
+		encoding, err := x86LegacyLiteralSIMDEncoding(entry, row)
+		if err != nil {
+			return nil, err
+		}
+		if len(entry.OpBytes) > 2 {
+			return x86LegacyLiteralSIMDWitnesses(entry, encoding), nil
+		}
+		// Keep the original six placeholder-row syntax fields unchanged.
+	}
+	literal := entry.Ytab == "ymmxmm0f38" && entry.Prefix == "Px" && entry.EscapeAdjustment == 1 &&
+		row.RowIndex == 1 && row.ZCase == "Zlitm_r" && row.ZOffset == 5 && row.UnmatchedOffset == 4
+	shift := entry.Ytab == "yps" || entry.Ytab == "ypsdq"
+	immediate := shift && strings.Join(row.Classes, ",") == "Yi8,Yxr"
+	shuffle := (entry.Ytab == "yxshuf" || entry.Ytab == "ypalignr") && strings.Join(row.Classes, ",") == "Yu8,Yxm,Yxr"
+	conversion := entry.Ytab == "yxcvm1" || entry.Ytab == "yxcvm2"
+	if entry.Kind != "encoding" || entry.EscapeAdjustment != 0 && !literal ||
+		strings.Join(row.Classes, ",") != "Yxm,Yxr" && !immediate && !shuffle && !scalarConversion {
+		return nil, fmt.Errorf("unmodeled legacy packed operand row")
+	}
+	// Reuse the complete encoding for the original ordinary conversion and
+	// XMM literal rows. New MMX and other source roles retain the old refusal.
+	if capturedEncoding != nil && (conversion && row.RowIndex == 0 || literal) {
+		return x86LegacyMediaCarrierWitnesses(entry.Opcode, []string{"Yxm", "Yxr"}, capturedEncoding, true), nil
+	}
+	prefix, offset, opcodeBytes := []byte{0x66, 0x0f}, 0, 1
+	terminator := 0
+	switch {
+	case scalarConversion:
+		prefix, offset = []byte{scalar.mandatory, 0x0f}, scalar.opcodeOffset
+		if scalar.wide {
+			prefix = []byte{scalar.mandatory, 0x48, 0x0f}
+		}
+	case conversion && row.RowIndex == 0 && row.ZCase == "Zm_r_xm" && row.ZOffset == 2 && row.UnmatchedOffset == 0 && len(entry.OpBytes) == 4:
+		if entry.Prefix == "Px" && (entry.OpBytes[2] == "Pe" || entry.OpBytes[2] == "Pm") {
+			mandatory := map[string]byte{"Pe": 0x66, "Pf2": 0xf2, "Pf3": 0xf3}[entry.OpBytes[0]]
+			if mandatory == 0 {
+				return nil, fmt.Errorf("unmodeled packed conversion mandatory prefix")
+			}
+			prefix, offset = []byte{mandatory, 0x0f}, 1
+		} else if entry.Ytab == "yxcvm2" && entry.Prefix == "Pm" && entry.OpBytes[1] == "0" && entry.OpBytes[3] == "0" {
+			prefix = []byte{0x0f}
+		} else {
+			return nil, fmt.Errorf("unmodeled packed conversion complete prefix payload")
+		}
+	case entry.Ytab == "yps" && entry.Prefix == "Py3" && entry.EscapeAdjustment == 0:
+		if len(entry.OpBytes) != 8 || entry.OpBytes[3] != "Pe" || entry.OpBytes[5] != "Pe" ||
+			entry.OpBytes[0] != entry.OpBytes[4] || entry.OpBytes[1] != entry.OpBytes[6] || entry.OpBytes[2] != entry.OpBytes[7] {
+			return nil, fmt.Errorf("unmodeled complete Py3 shift payload")
+		}
+		if !immediate && row.RowIndex == 2 && row.ZCase == "Zm_r_xm" && row.ZOffset == 2 && row.UnmatchedOffset == 3 {
+			offset = 4
+		} else if immediate && row.RowIndex == 3 && row.ZCase == "Zibo_m_xm" && row.ZOffset == 3 && row.UnmatchedOffset == 5 {
+			offset = 6
+		} else {
+			return nil, fmt.Errorf("unmodeled Py3 XMM shift row")
+		}
+	case entry.Ytab == "ypsdq" && entry.Prefix == "Pq" && immediate && row.RowIndex == 0 &&
+		row.ZCase == "Zibo_m" && row.ZOffset == 2 && row.UnmatchedOffset == 0 && len(entry.OpBytes) == 2:
+	case shuffle && row.RowIndex == 0 && row.ZCase == "Zibm_r" && row.ZOffset == 2 && row.UnmatchedOffset == 0 &&
+		len(entry.OpBytes) == 2:
+		switch {
+		case entry.Ytab == "ypalignr" && entry.Prefix == "Pq" && entry.OpBytes[0] == "0x3a" && entry.OpBytes[1] == "0x0f":
+			opcodeBytes = 2
+		case entry.Ytab == "yxshuf" && (entry.OpBytes[1] == "0" || entry.OpBytes[1] == "00"):
+			// The second atom is the original stride placeholder, not /digit.
+			if entry.OpBytes[0] == "0xc6" {
+				if entry.Opcode == "SHUFPS" && entry.Prefix == "Pm" {
+					prefix = []byte{0x0f}
+				} else if entry.Opcode != "SHUFPD" || entry.Prefix != "Pq" {
+					return nil, fmt.Errorf("unmodeled legacy PS/PD shuffle prefix")
+				}
+			} else if entry.OpBytes[0] == "0x70" && (entry.Prefix == "Pf2" || entry.Prefix == "Pf3") {
+				prefix[0] = map[string]byte{"Pf2": 0xf2, "Pf3": 0xf3}[entry.Prefix]
+			} else if entry.Prefix != "Pq" || entry.OpBytes[0] != "0x70" {
+				return nil, fmt.Errorf("unmodeled legacy immediate shuffle prefix")
+			}
+		default:
+			return nil, fmt.Errorf("unmodeled legacy immediate shuffle payload")
+		}
+	case literal:
+		// Zlitm_r emits the selected zero-terminated sequence verbatim,
+		// including its mandatory prefix and opcode-map bytes.
+		prefix, offset, opcodeBytes, terminator = nil, row.UnmatchedOffset, row.ZOffset-1, 1
+		if len(entry.OpBytes) != offset+opcodeBytes+terminator ||
+			entry.OpBytes[offset-1] != "0" || entry.OpBytes[len(entry.OpBytes)-1] != "0" {
+			return nil, fmt.Errorf("unmodeled legacy packed literal boundaries")
+		}
+	case entry.Ytab == "ymm" && entry.Prefix == "Py1" && row.RowIndex == 1 && row.ZCase == "Zm_r_xm" && row.ZOffset == 2 && row.UnmatchedOffset == 1:
+		if len(entry.OpBytes) != 3 || entry.OpBytes[1] != "Pe" || entry.OpBytes[0] != entry.OpBytes[2] {
+			return nil, fmt.Errorf("unmodeled Py1 XMM opcode payload")
+		}
+		offset = 2 // Py1 consumes the Pe at offset 1 before the opcode.
+	case x86LegacyFloatingBinaryMember(entry.Opcode):
+		if entry.Ytab != "yxm" || len(entry.Rows) != 1 || row.RowIndex != 0 || row.ZCase != "Zm_r_xm" ||
+			row.ZOffset != 1 || row.UnmatchedOffset != 0 || len(entry.OpBytes) != 1 {
+			return nil, fmt.Errorf("unmodeled complete legacy floating media row")
+		}
+		// Zm_r_xm calls mediaop after the source prefix switch. In particular
+		// Ym emits no prefix there, so mediaop supplies the missing 0F escape.
+		// Keep the source literal; neither this path nor the scalar suffix
+		// alone grants another family's mandatory-prefix capability.
+		switch suffix := entry.Opcode[len(entry.Opcode)-2:]; {
+		case suffix == "PS" && (entry.Prefix == "Pm" || entry.Prefix == "Ym"):
+			prefix = []byte{0x0f}
+		case suffix == "PD" && (entry.Prefix == "Pe" || entry.Prefix == "Pq"):
+		case suffix == "SS" && entry.Prefix == "Pf3":
+			prefix = []byte{0xf3, 0x0f}
+		case suffix == "SD" && entry.Prefix == "Pf2":
+			prefix = []byte{0xf2, 0x0f}
+		default:
+			return nil, fmt.Errorf("legacy floating media prefix conflicts with its source class")
+		}
+	case entry.Ytab == "yxm" && (entry.Prefix == "Pe" || entry.Prefix == "Pq" || entry.Prefix == "Pm") &&
+		row.RowIndex == 0 && row.ZCase == "Zm_r_xm" && row.ZOffset == 1 && row.UnmatchedOffset == 0:
+		if entry.Prefix == "Pm" {
+			prefix = []byte{0x0f}
+		}
+	case entry.Ytab == "yxm" && row.RowIndex == 0 && row.ZCase == "Zm_r_xm" &&
+		row.ZOffset == 1 && row.UnmatchedOffset == 0 && len(entry.OpBytes) == 1 &&
+		(entry.Prefix == "Pf2" && entry.OpBytes[0] == "0x12" ||
+			entry.Prefix == "Pf3" && (entry.OpBytes[0] == "0x12" || entry.OpBytes[0] == "0x16")):
+		// Only the duplicate move payloads join this prefix class; scalar
+		// arithmetic and conversion yxm rows keep their separate contracts.
+		prefix = []byte{0xf2, 0x0f}
+		if entry.Prefix == "Pf3" {
+			prefix[0] = 0xf3
+		}
+	case entry.Ytab == "yxm_q4" && entry.Prefix == "Pq4" && row.RowIndex == 0 && row.ZCase == "Zm_r" && row.ZOffset == 1 && row.UnmatchedOffset == 0:
+		prefix = append(prefix, 0x38)
+	case entry.Ytab == "ymshufb" && entry.Prefix == "Pq" && row.RowIndex == 0 && row.ZCase == "Zm2_r" && row.ZOffset == 2 && row.UnmatchedOffset == 0:
+		// Go's Zm2_r emits two selected opcode bytes before ModRM. They
+		// are payload, not another mandatory prefix or a mnemonic lookup.
+		opcodeBytes = 2
+	default:
+		return nil, fmt.Errorf("unmodeled legacy packed prefix/offset rule")
+	}
+	if !shift && !shuffle && !conversion && len(entry.OpBytes) != offset+opcodeBytes+terminator {
+		return nil, fmt.Errorf("unmodeled legacy packed opcode payload")
+	}
+	encoding := prefix
+	for _, value := range entry.OpBytes[offset : offset+opcodeBytes] {
+		opcode, err := strconv.ParseUint(value, 0, 8)
+		if err != nil || literal && opcode == 0 || scalarConversion && (opcode == 0 || opcode == 0x0f) {
+			return nil, fmt.Errorf("legacy packed opcode is not a byte literal")
+		}
+		encoding = append(encoding, byte(opcode))
+	}
+	if !scalarConversion && !immediate && !shuffle {
+		return x86LegacyMediaCarrierWitnesses(entry.Opcode, []string{"Yxm", "Yxr"}, encoding, true), nil
+	}
+	sources, extension := []string{"X0", "(AX)"}, uint64(0)
+	if scalarConversion {
+		sources = []string{"X0", "0(SI)"}
+	}
+	if immediate {
+		var err error
+		extension, err = strconv.ParseUint(entry.OpBytes[offset+1], 0, 8)
+		if err != nil || extension > 7 {
+			return nil, fmt.Errorf("legacy shift opcode extension is not a three-bit literal")
+		}
+		sources = []string{""}
+	}
+	var witnesses []X86PackedBinaryWitness
+	for _, first := range sources {
+		modrm := byte(0xc8)
+		memory := first == "(AX)" || scalarConversion && first == "0(SI)"
+		if memory {
+			modrm = 0x08
+			if scalarConversion {
+				modrm |= 6
+			}
+		}
+		destination, second := "X1", "X1"
+		if scalarConversion {
+			if scalar.fromFloat {
+				destination, second = "BX", ""
+				modrm = modrm&0xc7 | 3<<3
+			} else if first == "X0" {
+				first, modrm = "CX", modrm&0xf8|1
+			}
+		}
+		instruction := entry.Opcode + " " + first + "," + destination
+		encoded := append(append([]byte(nil), encoding...), modrm)
+		if shuffle {
+			instruction = entry.Opcode + " $7," + first + ",X1"
+			if entry.OpBytes[0] == "0x70" {
+				second = "" // Unary integer shuffle; align/PS/PD retain old destination.
+			}
+			encoded = append(encoded, 7)
+		}
+		if immediate {
+			instruction = entry.Opcode + " $-1,X1"
+			encoded = append(append([]byte(nil), encoding...), 0xc1|byte(extension)<<3, 255)
+		}
+		witnesses = append(witnesses, X86PackedBinaryWitness{
+			Instruction: instruction, Generation: "legacy", Width: 128,
+			First: first, Second: second, Destination: destination, Memory: memory,
+			Encoding: encoded,
+		})
+	}
+	return witnesses, nil
+}
+
+// X86LegacyLiteralSIMDRows retains two complete source tables. The overlap
+// with older shuffle views remains the same original row identity. A carrier
+// width is not a memory tuple, numerical input or native-entry permission.
+func X86LegacyLiteralSIMDRows(catalog X86LegacyCatalog, arch string) ([]X86PackedBinaryRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("literal SIMD source view requires an explicit Go x86 mode")
+	}
+	var rows []X86PackedBinaryRow
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yxshuf" && entry.Ytab != "yaes" {
+			continue
+		}
+		for _, operand := range entry.Rows {
+			witnesses, err := x86PackedLegacyRowWitnesses(entry, operand)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			rows = append(rows, X86PackedBinaryRow{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses,
+			})
+		}
+	}
+	if len(rows) != 33 {
+		return nil, fmt.Errorf("incomplete original literal SIMD source view: rows=%d", len(rows))
+	}
+	return rows, nil
+}
+
+// These single-row Z cases use the selected complete zero-terminated span;
+// zoffset is an unmatched-row stride, not the number of literal bytes emitted.
+func x86LegacyLiteralSIMDEncoding(entry X86LegacyOpcode, selected X86LegacyOperand) ([]byte, error) {
+	fail := func() ([]byte, error) { return nil, fmt.Errorf("unmodeled complete literal SIMD source schema") }
+	classes, zcase := []string{"Yxm", "Yxr"}, "Zlitm_r"
+	if entry.Ytab == "yxshuf" {
+		classes, zcase = []string{"Yu8", "Yxm", "Yxr"}, "Zibm_r"
+	} else if entry.Ytab != "yaes" {
+		return fail()
+	}
+	valid := func(row X86LegacyOperand) bool {
+		if row.RowIndex != 0 || row.ZCase != zcase || row.ZOffset != 2 || row.UnmatchedOffset != 0 || len(row.Classes) != len(classes) {
+			return false
+		}
+		for index, class := range classes {
+			if row.Classes[index] != class {
+				return false
+			}
+		}
+		return true
+	}
+	if entry.Kind != "encoding" || len(entry.Rows) != 1 || !valid(entry.Rows[0]) || !valid(selected) || len(entry.OpBytes) < 2 || len(entry.OpBytes) > 4 {
+		return fail()
+	}
+	literal := make([]byte, len(entry.OpBytes))
+	for index, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil || (value == 0) != (index == len(literal)-1) {
+			return fail()
+		}
+		literal[index] = byte(value)
+	}
+	literal = literal[:len(literal)-1]
+	var prefix []byte
+	escape := 0
+	switch {
+	case entry.Ytab == "yxshuf" && len(literal) == 1 && literal[0] != 0x0f:
+		switch entry.Prefix {
+		case "Pq":
+			prefix = []byte{0x66, 0x0f}
+		case "Pf2":
+			prefix = []byte{0xf2, 0x0f}
+		case "Pf3":
+			prefix = []byte{0xf3, 0x0f}
+		case "Pm":
+			prefix = []byte{0x0f}
+		default:
+			return fail()
+		}
+	case entry.Prefix == "Pq" && len(literal) == 2:
+		mapByte := byte(0x38)
+		if entry.Ytab == "yxshuf" {
+			mapByte = 0x3a
+		}
+		if literal[0] != mapByte {
+			return fail()
+		}
+		prefix = []byte{0x66, 0x0f}
+	case entry.Ytab == "yaes" && entry.Prefix == "Px" && len(literal) == 3 && literal[0] == 0x0f && literal[1] == 0x38:
+		// Go emits the selected leading 0F before PutOpBytesLit advances;
+		// the combined source span retains it exactly once.
+		escape = 1
+	default:
+		return fail()
+	}
+	if entry.EscapeAdjustment != escape {
+		return fail()
+	}
+	return append(prefix, literal...), nil
+}
+
+func x86LegacyLiteralSIMDWitnesses(entry X86LegacyOpcode, encoding []byte) []X86PackedBinaryWitness {
+	var witnesses []X86PackedBinaryWitness
+	for _, source := range []string{"X0", "(AX)"} {
+		modrm := byte(0xc8)
+		if source == "(AX)" {
+			modrm = 0x08
+		}
+		instruction := entry.Opcode + " " + source + ",X1"
+		code := append(append([]byte(nil), encoding...), modrm)
+		if entry.Ytab == "yxshuf" {
+			instruction = entry.Opcode + " $7," + source + ",X1"
+			code = append(code, 7)
+		}
+		witnesses = append(witnesses, X86PackedBinaryWitness{Instruction: instruction, Generation: "legacy", Width: 128,
+			First: source, Second: "X1", Destination: "X1", Memory: source == "(AX)", Encoding: code})
+	}
+	return witnesses
+}
diff --git a/internal/goasmrules/x86_witness_rows_test.go b/internal/goasmrules/x86_witness_rows_test.go
new file mode 100644
index 000000000..07998a0ec
--- /dev/null
+++ b/internal/goasmrules/x86_witness_rows_test.go
@@ -0,0 +1,430 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86LegacyLiteralSIMDSource(entry X86LegacyOpcode) bool {
+	return entry.Ytab == "yxshuf" || entry.Ytab == "yaes"
+}
+
+// Independent source bytes follow Go's prefix switch plus PutOpBytesLit.
+// The matched row's stride is not the zero-terminated literal's length.
+func x86LegacyLiteralSIMDExpected(t *testing.T, entry X86LegacyOpcode) []X86PackedBinaryWitness {
+	t.Helper()
+	prefixes := map[string][]byte{"Pq": {0x66, 0x0f}, "Pf2": {0xf2, 0x0f}, "Pf3": {0xf3, 0x0f}, "Pm": {0x0f}, "Px": {}}
+	prefix, found := prefixes[entry.Prefix]
+	if !found {
+		t.Fatal("unmodeled independent source prefix", entry)
+	}
+	encoding := append([]byte(nil), prefix...)
+	for index, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil || value == 0 && index != len(entry.OpBytes)-1 {
+			t.Fatal("independent source literal changed", entry, index, err)
+		}
+		if value != 0 {
+			encoding = append(encoding, byte(value))
+		}
+	}
+	var cases []X86PackedBinaryWitness
+	for _, source := range []string{"X0", "(AX)"} {
+		modrm := byte(0xc8)
+		if source == "(AX)" {
+			modrm = 0x08
+		}
+		instruction := entry.Opcode + " " + source + ",X1"
+		code := append(append([]byte(nil), encoding...), modrm)
+		if entry.Ytab == "yxshuf" {
+			instruction = entry.Opcode + " $7," + source + ",X1"
+			code = append(code, 7)
+		}
+		cases = append(cases, X86PackedBinaryWitness{Instruction: instruction, Destination: "X1", Encoding: code})
+	}
+	return cases
+}
+
+func TestX86LegacyLiteralSIMDCompleteOriginalInventory(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts, spans, ids := map[string]int{}, map[int]int{}, map[string]bool{}
+	escaped := 0
+	for _, entry := range catalog.Optab {
+		if !x86LegacyLiteralSIMDSource(entry) {
+			continue
+		}
+		if entry.Kind != "encoding" || len(entry.Rows) != 1 {
+			t.Fatal("complete original literal SIMD entry changed", entry)
+		}
+		row := entry.Rows[0]
+		classes, zcase := "Yxm,Yxr", "Zlitm_r"
+		if entry.Ytab == "yxshuf" {
+			classes, zcase = "Yu8,Yxm,Yxr", "Zibm_r"
+		}
+		if strings.Join(row.Classes, ",") != classes || len(row.Classes) != strings.Count(classes, ",")+1 ||
+			row.RowIndex != 0 || row.ZCase != zcase || row.ZOffset != 2 || row.UnmatchedOffset != 0 {
+			t.Fatal("original literal SIMD classes/stride/selection changed", entry)
+		}
+		id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+		if ids[id] || len(entry.OpBytes) < 2 || len(entry.OpBytes) > 4 {
+			t.Fatal("original literal SIMD identity or span changed", id, entry)
+		}
+		ids[id] = true
+		counts[entry.Ytab]++
+		spans[len(entry.OpBytes)]++
+		zero, err := strconv.ParseUint(entry.OpBytes[len(entry.OpBytes)-1], 0, 8)
+		if err != nil || zero != 0 {
+			t.Fatal("original literal SIMD terminator changed", id, err)
+		}
+		if entry.EscapeAdjustment != 0 {
+			if entry.EscapeAdjustment != 1 || entry.Ytab != "yaes" || entry.Prefix != "Px" || entry.OpBytes[0] != "0x0f" {
+				t.Fatal("original literal SIMD escape traversal changed", id, entry)
+			}
+			escaped++
+		}
+	}
+	if len(ids) != 33 || counts["yxshuf"] != 23 || counts["yaes"] != 10 || spans[2] != 6 || spans[3] != 22 || spans[4] != 5 || escaped != 5 {
+		t.Fatal("complete original literal SIMD union changed", len(ids), counts, spans, escaped)
+	}
+}
+
+func TestX86LegacyLiteralSIMDExistingTransportCompleteBytes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range catalog.Optab {
+		if !x86LegacyLiteralSIMDSource(entry) {
+			continue
+		}
+		row := entry.Rows[0]
+		id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+		t.Run(id, func(t *testing.T) {
+			expected := map[string]X86PackedBinaryWitness{}
+			for _, witness := range x86LegacyLiteralSIMDExpected(t, entry) {
+				expected[id+"/"+witness.Instruction] = witness
+			}
+			witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+			if err != nil || len(witnesses) != 2 {
+				t.Fatal("LEGACY_LITERAL_SIMD_SOURCE_TRANSPORT_FEATURE_GAP", err)
+			}
+			for _, witness := range witnesses {
+				key := id + "/" + witness.Instruction
+				want, found := expected[key]
+				if !found || !bytes.Equal(want.Encoding, witness.Encoding) || want.Destination != witness.Destination {
+					t.Fatal("literal SIMD transport differs from actual-Go source fixture", key, witness, want)
+				}
+				delete(expected, key)
+			}
+			if len(expected) != 0 {
+				t.Fatal("literal SIMD transport omitted original source cases", id, expected)
+			}
+		})
+	}
+}
+
+func TestX86LegacyLiteralSIMDRejectsMalformedSource(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if !x86LegacyLiteralSIMDSource(original) {
+			continue
+		}
+		selected := original.Rows[0]
+		for _, control := range []string{"kind", "row-count", "prefix", "escape", "index", "zcase", "stride", "offset",
+			"original-arity", "selected-arity", "original-index", "original-zcase", "original-stride", "original-offset",
+			"original-immediate-role", "selected-immediate-role", "missing-zero", "early-zero", "tail", "nonbyte"} {
+			if strings.HasSuffix(control, "immediate-role") && original.Ytab != "yxshuf" {
+				continue
+			}
+			t.Run(original.Opcode+"/"+control, func(t *testing.T) {
+				entry, row := original, selected
+				entry.Rows = append([]X86LegacyOperand(nil), original.Rows...)
+				entry.OpBytes = append([]string(nil), original.OpBytes...)
+				switch control {
+				case "kind":
+					entry.Kind = "special"
+				case "row-count":
+					entry.Rows = append(entry.Rows, selected)
+				case "prefix":
+					entry.Prefix = "Pw"
+				case "escape":
+					entry.EscapeAdjustment++
+				case "index":
+					row.RowIndex++
+				case "zcase":
+					row.ZCase = "Zibr_m"
+				case "stride":
+					row.ZOffset++
+				case "offset":
+					row.UnmatchedOffset++
+				case "original-arity":
+					entry.Rows[0].Classes = []string{strings.Join(selected.Classes, ",")}
+				case "selected-arity":
+					row.Classes = []string{strings.Join(selected.Classes, ",")}
+				case "original-index":
+					entry.Rows[0].RowIndex++
+				case "original-zcase":
+					entry.Rows[0].ZCase = "Zibr_m"
+				case "original-stride":
+					entry.Rows[0].ZOffset++
+				case "original-offset":
+					entry.Rows[0].UnmatchedOffset++
+				case "original-immediate-role":
+					entry.Rows[0].Classes = append([]string(nil), selected.Classes...)
+					entry.Rows[0].Classes[0] = "Yi32"
+				case "selected-immediate-role":
+					row.Classes = append([]string(nil), selected.Classes...)
+					row.Classes[0] = "Yi32"
+				case "missing-zero":
+					entry.OpBytes = entry.OpBytes[:len(entry.OpBytes)-1]
+				case "early-zero":
+					entry.OpBytes[0] = "0"
+				case "tail":
+					entry.OpBytes = append(entry.OpBytes, "0")
+				case "nonbyte":
+					entry.OpBytes[0] = "256"
+				}
+				defer func() {
+					if value := recover(); value != nil {
+						t.Fatal("LEGACY_LITERAL_SIMD_MALFORMED_PANIC", control, value)
+					}
+				}()
+				if witnesses, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+					t.Fatal("LEGACY_LITERAL_SIMD_MALFORMED_ACCEPTED", control, witnesses, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyLiteralSIMDRejectsEveryLiteralAtom(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if !x86LegacyLiteralSIMDSource(original) {
+			continue
+		}
+		for index := 1; index < len(original.OpBytes); index++ {
+			values := []string{"0", "256"}
+			if index == len(original.OpBytes)-1 {
+				values = []string{"1"} // Preserve the span while removing its final zero.
+			}
+			for _, value := range values {
+				t.Run(fmt.Sprintf("%s/atom%d/%s", original.Opcode, index, value), func(t *testing.T) {
+					entry := original
+					entry.OpBytes = append([]string(nil), original.OpBytes...)
+					entry.OpBytes[index] = value
+					defer func() {
+						if panicValue := recover(); panicValue != nil {
+							t.Fatal("LEGACY_LITERAL_SIMD_MALFORMED_PANIC", index, value, panicValue)
+						}
+					}()
+					if witnesses, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0]); err == nil || len(witnesses) != 0 {
+						t.Fatal("LEGACY_LITERAL_SIMD_MALFORMED_ACCEPTED", index, value, witnesses, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyLiteralSIMDViewKeepsCompleteIDsAndMode(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86LegacyLiteralSIMDRows(catalog, arch)
+		if err != nil || len(rows) != 33 {
+			t.Fatal("complete literal SIMD view changed", arch, len(rows), err)
+		}
+		seen, witnesses := map[string]bool{}, 0
+		for _, row := range rows {
+			if seen[row.ID] || len(row.Witnesses) != 2 {
+				t.Fatal("literal SIMD original source identity repeated or lost a carrier", row)
+			}
+			seen[row.ID] = true
+			witnesses += len(row.Witnesses)
+		}
+		if witnesses != 66 {
+			t.Fatal("literal SIMD carrier witness union changed", witnesses)
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		if rows, err := X86LegacyLiteralSIMDRows(catalog, arch); err == nil || len(rows) != 0 {
+			t.Fatal("literal SIMD view inferred a missing or foreign x86 mode", arch, rows, err)
+		}
+	}
+}
+
+func TestX86LegacyLiteralSIMDLeadingEscapeRemainsClosed(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := 0
+	for _, original := range catalog.Optab {
+		if original.Ytab != "yxshuf" || len(original.OpBytes) != 2 {
+			continue
+		}
+		rows++
+		for _, escape := range []int{0, 1} {
+			t.Run(fmt.Sprintf("%s/escape%d", original.Opcode, escape), func(t *testing.T) {
+				entry := original
+				entry.OpBytes = []string{"0x0f", "0"}
+				entry.EscapeAdjustment = escape
+				if witnesses, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0]); err == nil || len(witnesses) != 0 {
+					t.Fatal("closed old view admitted a one-atom leading escape", witnesses, err)
+				}
+				if encoding, err := x86LegacyLiteralSIMDEncoding(entry, entry.Rows[0]); err == nil || len(encoding) != 0 {
+					t.Fatal("LEGACY_LITERAL_SIMD_PRIVATE_ESCAPE_ACCEPTED", escape, encoding, err)
+				}
+			})
+		}
+	}
+	if rows != 6 {
+		t.Fatal("closed placeholder source-row control inventory changed", rows)
+	}
+}
+
+func TestX86PackedNarrowRowsShareBinaryWitnesses(t *testing.T) {
+	x86CheckPackedRowInventory(t, X86PackedNarrowRows, `^V?PACK`, `DW$`, x86PackedRowCounts{
+		names: 8, mmx: 3, broadcast: 18,
+		rows: [3]int{4, 8, 24}, formats: [3]int{8, 16, 90}, widths: [3]int{46, 38, 30},
+	})
+}
+
+func TestX86PackedAverageMultiplyRowsShareBinaryWitnesses(t *testing.T) {
+	x86CheckPackedRowInventory(t, X86PackedAverageMultiplyRows,
+		`^V?(PAVG[BW]|PMUL(LW|HW|HUW|HRSW|DQ|ULQ|UDQ)|PMADD(UBSW|WL|WD))$`,
+		`^VPMUL(DQ|UDQ)$`, x86PackedRowCounts{
+			names: 20, mmx: 7, broadcast: 18,
+			rows: [3]int{10, 20, 60}, formats: [3]int{20, 40, 198}, widths: [3]int{106, 86, 66},
+		})
+}
+
+func TestX86PackedBinaryPilotRows(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedBinaryPilotRows,
+		`^V?(P(ADD|SUB)(B|W|L|D|Q|SB|SW|USB|USW)|PMULL[DQ])$`,
+		`[DQ]$`, x86PackedRowCounts{
+			names: 35, mmx: 7, broadcast: 54,
+			rows: [3]int{17, 34, 108}, formats: [3]int{34, 68, 378}, widths: [3]int{194, 160, 126},
+		})
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if len(witness.Encoding) < 4 {
+				t.Fatal("integer pilot lost its mandatory prefix or vector encoding", row.ID, witness)
+			}
+		}
+	}
+	for _, name := range []string{"PADDD", "PMULLW", "VPMULLW"} {
+		if inventory.names[name] {
+			t.Fatalf("alias or unmodified word multiply entered pilot: %s", name)
+		}
+	}
+	wordMultiply := 0
+	for _, entry := range inventory.legacy.Optab {
+		if entry.Opcode == "PMULLW" {
+			wordMultiply += len(entry.Rows)
+		}
+	}
+	for _, row := range inventory.avx {
+		if row.Opcode == "VPMULLW" {
+			wordMultiply++
+		}
+	}
+	if wordMultiply != 10 {
+		t.Fatal("outside-pilot word multiply inventory changed", wordMultiply)
+	}
+}
+
+func TestX86PackedBinaryRowEncodingAndFailClosed(t *testing.T) {
+	rule := X86AVXRule{
+		Opcode: "VPMULLD", Ytab: "_yvandnpd", Prefix: "Pavx", RowIndex: 3,
+		Classes: []string{"YxmEvex", "YxrEvex", "Yknot0", "YxrEvex"},
+		ZCase:   "Zevex_rm_v_k_r", ZOffset: 3,
+		OpBytes: []string{"avxEscape | evex128 | evex66 | evex0F38 | evexW0", "evexN16 | evexBcstN4 | evexZeroingEnabled", "0x40"},
+	}
+	witnesses, err := x86PackedAVXRowWitnesses(rule)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(witnesses) != 6 || witnesses[0].Instruction != "VPMULLD X16,X17,K1,X18" ||
+		!bytes.Equal(witnesses[0].Encoding, []byte{0x62, 0xa2, 0x75, 0x01, 0x40, 0xd0}) ||
+		witnesses[5].Instruction != "VPMULLD.BCST.Z (AX),X17,K1,X18" ||
+		!bytes.Equal(witnesses[5].Encoding, []byte{0x62, 0xe2, 0x75, 0x91, 0x40, 0x10}) {
+		t.Fatalf("independent fixed-register EVEX expectation: %+v", witnesses)
+	}
+	for _, mutate := range []func(*X86AVXRule){
+		func(r *X86AVXRule) { r.OpBytes[0] += " | futureFlag" },
+		func(r *X86AVXRule) { r.OpBytes[0] += " | evexW1" },
+		func(r *X86AVXRule) { r.OpBytes[1] += " | evexSaeEnabled" },
+		func(r *X86AVXRule) { r.OpBytes[1] = strings.Replace(r.OpBytes[1], "evexN16", "evexN64", 1) },
+		func(r *X86AVXRule) { r.OpBytes[2] = "opcodeConstant" },
+		func(r *X86AVXRule) { r.EncodingOffset = 1 },
+		func(r *X86AVXRule) { r.ZOffset = 2 },
+		func(r *X86AVXRule) { r.Classes[0] = "Yxm" },
+		func(r *X86AVXRule) { r.Ytab = "unknown" },
+	} {
+		local := rule
+		local.OpBytes = append([]string(nil), rule.OpBytes...)
+		local.Classes = append([]string(nil), rule.Classes...)
+		mutate(&local)
+		if _, err := x86PackedAVXRowWitnesses(local); err == nil {
+			t.Fatalf("unmodeled official row silently accepted: %+v", local)
+		}
+	}
+}
+
+func TestX86PackedBinaryLegacyRowUsesSelectedPrefixOffset(t *testing.T) {
+	entry := X86LegacyOpcode{Kind: "encoding", Opcode: "PADDL", Ytab: "ymm", Prefix: "Py1", OpBytes: []string{"0xfe", "Pe", "0xfe"}}
+	row := X86LegacyOperand{RowIndex: 1, Classes: []string{"Yxm", "Yxr"}, ZCase: "Zm_r_xm", ZOffset: 2, UnmatchedOffset: 1}
+	witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+	if err != nil || len(witnesses) != 2 || !bytes.Equal(witnesses[0].Encoding, []byte{0x66, 0x0f, 0xfe, 0xc8}) ||
+		!bytes.Equal(witnesses[1].Encoding, []byte{0x66, 0x0f, 0xfe, 0x08}) {
+		t.Fatalf("Py1 selected XMM prefix/opcode: %+v/%v", witnesses, err)
+	}
+	for _, offset := range []int{0, 2, 3} {
+		local := row
+		local.UnmatchedOffset = offset
+		if _, err := x86PackedLegacyRowWitnesses(entry, local); err == nil {
+			t.Fatal("unmatched traversal offset was mistaken for a selected opcode offset", offset)
+		}
+	}
+	entry.OpBytes[1] = "Pf2"
+	if _, err := x86PackedLegacyRowWitnesses(entry, row); err == nil {
+		t.Fatal("changed legacy mandatory prefix was ignored")
+	}
+}
+
+func TestX86PackedIntegerMinMaxRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedIntegerMinMaxRows,
+		`^V?P(MIN|MAX)`, `[DQ]$`, x86PackedRowCounts{
+			names: 28, broadcast: 72,
+			rows: [3]int{12, 24, 96}, formats: [3]int{24, 48, 360}, widths: [3]int{168, 144, 120},
+		})
+	narrowEVEX := 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if witness.Generation == "evex" && witness.Width < 512 && !witness.Masked &&
+				!witness.Broadcast && !strings.HasSuffix(row.Opcode, "Q") {
+				narrowEVEX++
+			}
+		}
+	}
+	if narrowEVEX != 48 {
+		t.Fatal("unmasked narrow non-Q EVEX inventory drift", narrowEVEX)
+	}
+}
diff --git a/internal/goasmrules/x86_witness_scalar_compare.go b/internal/goasmrules/x86_witness_scalar_compare.go
new file mode 100644
index 000000000..6fb7c4b29
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_compare.go
@@ -0,0 +1,35 @@
+package goasmrules
+
+import "fmt"
+
+// X86ScalarCompareRows reuses the ordered scalar transport. It supplies no
+// data writes or FLAGS values; those belong to the typed read-only effects.
+func X86ScalarCompareRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "386" && arch != "amd64" {
+		return nil, fmt.Errorf("scalar compare requires a Go x86 source mode")
+	}
+	var result []X86ScalarRMWRow
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "ycmpl" && entry.Ytab != "ycmpb" && entry.Ytab != "ytestl" {
+			continue
+		}
+		for _, operand := range entry.Rows {
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86ScalarRMWRow{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses,
+			}
+			if arch == "386" && entry.Prefix == "Pw" {
+				row.ModeFiltered, row.Witnesses = "original Go rejects REX.W in 386 mode", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(result) != 31 {
+		return nil, fmt.Errorf("incomplete original scalar compare closure: rows=%d", len(result))
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_scalar_compare_test.go b/internal/goasmrules/x86_witness_scalar_compare_test.go
new file mode 100644
index 000000000..de0120bf7
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_compare_test.go
@@ -0,0 +1,82 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+func TestX86ScalarCompareRemainingExistingTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "ycmpl" && entry.Ytab != "ycmpb" && entry.Ytab != "ytestl" {
+			continue
+		}
+		for _, row := range entry.Rows {
+			counts[entry.Ytab]++
+			t.Run(fmt.Sprintf("%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex), func(t *testing.T) {
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, row, "amd64")
+				if err != nil || len(witnesses) == 0 {
+					t.Fatal("complete original read-only scalar row has no witness transport", err)
+				}
+			})
+		}
+	}
+	if fmt.Sprint(counts) != "map[ycmpb:4 ycmpl:15 ytestl:12]" {
+		t.Fatal("complete original compare/test denominator changed", counts)
+	}
+}
+
+func TestX86ScalarCompareOrderedOperandsModesAndPayload(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	anchors := map[string][]byte{
+		"CMPB AL,$128":     {0x3c, 0x80},
+		"CMPB BL,$128":     {0x80, 0xfb, 0x80},
+		"CMPL BX,$1":       {0x83, 0xfb, 1},
+		"CMPL AX,$128":     {0x3d, 0x80, 0, 0, 0},
+		"CMPL 0(SI),BX":    {0x39, 0x1e},
+		"CMPL CX,0(SI)":    {0x3b, 0x0e},
+		"TESTL $128,AX":    {0xa9, 0x80, 0, 0, 0},
+		"TESTW $128,0(SI)": {0x66, 0xf7, 0x06, 0x80, 0},
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ScalarCompareRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, formats, filtered := map[string]bool{}, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || seen[row.ID] {
+				t.Fatal("original compare row identity missing/repeated", row)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("refused source mode acquired witnesses", row)
+				}
+			}
+			formats += len(row.Witnesses)
+			for _, witness := range row.Witnesses {
+				if expected, ok := anchors[witness.Instruction]; ok && !bytes.Equal(expected, witness.Encoding) {
+					t.Fatal("accumulator, immediate direction or ModRM source order changed", witness, expected)
+				}
+			}
+		}
+		wantFormats, wantFiltered := 48, 0
+		if arch == "386" {
+			wantFormats, wantFiltered = 34, 9
+		}
+		if len(seen) != 31 || formats != wantFormats || filtered != wantFiltered {
+			t.Fatal("original compare source/mode union changed", arch, len(seen), formats, filtered)
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_scalar_conversion.go b/internal/goasmrules/x86_witness_scalar_conversion.go
new file mode 100644
index 000000000..8836f41b3
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_conversion.go
@@ -0,0 +1,100 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86LegacyScalarConversionForm struct {
+	fromFloat, wide bool
+	mandatory       byte
+	opcodeOffset    int
+}
+
+func x86LegacyScalarConversionTable(table string) bool {
+	switch table {
+	case "yxcvfl", "yxcvfq", "yxcvlf", "yxcvqf":
+		return true
+	}
+	return false
+}
+
+// Validate the complete original media row before the common encoder selects
+// any payload. These are bank/width roles, never numerical or memory facts.
+func x86LegacyScalarConversionProperties(entry X86LegacyOpcode, row X86LegacyOperand) (x86LegacyScalarConversionForm, error) {
+	f := x86LegacyScalarConversionForm{
+		fromFloat: entry.Ytab == "yxcvfl" || entry.Ytab == "yxcvfq",
+		wide:      entry.Ytab == "yxcvfq" || entry.Ytab == "yxcvqf",
+	}
+	fail := func() (x86LegacyScalarConversionForm, error) {
+		return f, fmt.Errorf("legacy scalar conversion differs from its complete source role")
+	}
+	if !x86LegacyScalarConversionTable(entry.Ytab) || entry.Kind != "encoding" || entry.EscapeAdjustment != 0 {
+		return fail()
+	}
+	source, destination, found := strings.Cut(entry.Opcode, "2")
+	floating, integer := destination, strings.TrimPrefix(source, "CVT")
+	if f.fromFloat {
+		floating, integer = strings.TrimPrefix(strings.TrimPrefix(source, "CVT"), "T"), destination
+	}
+	if !found || !strings.HasPrefix(source, "CVT") || floating != "SS" && floating != "SD" ||
+		integer != "SL" && integer != "SQ" || (integer == "SQ") != f.wide {
+		return fail()
+	}
+	mandatory, classes, stride := "Pf2", "Yml,Yxr", 1
+	f.mandatory = 0xf2
+	if floating == "SS" {
+		mandatory, f.mandatory = "Pf3", 0xf3
+	}
+	if f.fromFloat {
+		classes = "Yxm,Yrl"
+	}
+	if f.wide {
+		stride, f.opcodeOffset = 2, 1
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, []string{fmt.Sprintf("Zm_r_xm/%d/%s", stride, classes)}); err != nil {
+		return f, err
+	}
+	if len(entry.OpBytes) != stride || !f.wide && entry.Prefix != mandatory ||
+		f.wide && (entry.Prefix != "Pw" || entry.OpBytes[0] != mandatory) {
+		return fail()
+	}
+	return f, nil
+}
+
+// X86LegacyScalarConversionRows retains all four original signed scalar
+// conversion tables. Legacy Q rows stay visible when Go rejects mode386.
+func X86LegacyScalarConversionRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("legacy scalar conversion requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if !x86LegacyScalarConversionTable(entry.Ytab) {
+			continue
+		}
+		if seen[entry.Opcode] {
+			return nil, fmt.Errorf("duplicate original scalar conversion table")
+		}
+		seen[entry.Opcode] = true
+		for _, original := range entry.Rows {
+			witnesses, err := x86PackedLegacyRowWitnesses(entry, original)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, original.RowIndex, err)
+			}
+			row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, original.RowIndex), Opcode: entry.Opcode}
+			for _, witness := range witnesses {
+				row.Witnesses = append(row.Witnesses, X86ScalarRMWWitness{Instruction: witness.Instruction, Destination: witness.Destination, Encoding: witness.Encoding})
+			}
+			if arch == "386" && entry.Prefix == "Pw" {
+				row.ModeFiltered, row.Witnesses = "original Go rejects legacy REX.W in mode386", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(seen) != 12 || len(result) != 12 {
+		return nil, fmt.Errorf("incomplete original scalar conversion tables")
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_scalar_rm_register_test.go b/internal/goasmrules/x86_witness_scalar_rm_register_test.go
new file mode 100644
index 000000000..28cfe588b
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_rm_register_test.go
@@ -0,0 +1,148 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Existing-helper TDD draft: source tables select the complete remaining
+// format group. This is not a new handwritten instruction/value registry.
+func TestX86ScalarRMRegisterRemainingOriginalRows(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, names := 0, map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yml_rl" || strings.HasPrefix(entry.Opcode, "CMOV") {
+			continue
+		}
+		if names[entry.Opcode] {
+			t.Fatal("duplicate original source member", entry.Opcode)
+		}
+		names[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			rows++
+			t.Run(fmt.Sprint(entry.TableIndex)+"/"+entry.Opcode, func(t *testing.T) {
+				if entry.Kind != "encoding" || len(entry.Rows) != 1 || operand.RowIndex != 0 ||
+					operand.ZCase != "Zm_r" || operand.ZOffset != 1 || strings.Join(operand.Classes, ",") != "Yml,Yrl" {
+					t.Fatal("original complete GP source table changed", entry, operand)
+				}
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, "amd64")
+				if err != nil || len(witnesses) != 2 {
+					t.Fatal("complete original rm-to-register row lacks register/memory witnesses", err, len(witnesses))
+				}
+				for index, witness := range witnesses {
+					want := entry.Opcode + " CX,BX"
+					if index == 1 {
+						want = entry.Opcode + " 0(SI),BX"
+					}
+					if witness.Instruction != want || witness.Destination != "BX" || len(witness.Encoding) < 2 {
+						t.Fatal("physical alternative, destination or order changed", witness, want)
+					}
+				}
+			})
+		}
+	}
+	if rows != 28 || len(names) != 28 {
+		t.Fatal("complete remaining source-format denominator changed", rows, len(names))
+	}
+}
+
+func TestX86ScalarRMRegisterPrefixTransportAndControls(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	witnesses := map[string][]byte{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yml_rl" || strings.HasPrefix(entry.Opcode, "CMOV") {
+			continue
+		}
+		w, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], "amd64")
+		if err != nil || len(w) != 2 {
+			t.Fatal("valid original must precede prefix controls", entry.Opcode, err)
+		}
+		for _, witness := range w {
+			witnesses[witness.Instruction] = witness.Encoding
+		}
+		t.Run(entry.Opcode+"/wrong-prefix", func(t *testing.T) {
+			changed := entry
+			changed.Prefix = "Px"
+			if entry.Prefix == "Px" {
+				changed.Prefix = "Pw"
+			}
+			if _, err := x86ScalarRMWRowWitnesses(changed, entry.Rows[0], "amd64"); err == nil {
+				t.Fatal("another legal prefix class changed the original family/width envelope")
+			}
+		})
+	}
+	for _, anchor := range []struct {
+		instruction string
+		code        []byte
+	}{
+		{"ADCXL CX,BX", []byte{0x66, 0x0f, 0x38, 0xf6, 0xd9}},
+		{"ADCXQ 0(SI),BX", []byte{0x66, 0x48, 0x0f, 0x38, 0xf6, 0x1e}},
+		{"ADOXL CX,BX", []byte{0xf3, 0x0f, 0x38, 0xf6, 0xd9}},
+		{"ADOXQ 0(SI),BX", []byte{0xf3, 0x48, 0x0f, 0x38, 0xf6, 0x1e}},
+		{"LZCNTW CX,BX", []byte{0x66, 0xf3, 0x0f, 0xbd, 0xd9}},
+		{"LZCNTL 0(SI),BX", []byte{0xf3, 0x0f, 0xbd, 0x1e}},
+		{"POPCNTQ CX,BX", []byte{0xf3, 0x48, 0x0f, 0xb8, 0xd9}},
+		{"MOVWLSX 0(SI),BX", []byte{0x0f, 0xbf, 0x1e}},
+		{"MOVLQSX CX,BX", []byte{0x48, 0x63, 0xd9}},
+		{"MOVLQZX 0(SI),BX", []byte{0x8b, 0x1e}},
+		{"LARQ CX,BX", []byte{0x48, 0x0f, 0x02, 0xd9}},
+	} {
+		if !bytes.Equal(witnesses[anchor.instruction], anchor.code) {
+			t.Fatal("original prefix/payload/ModRM anchor changed", anchor.instruction, witnesses[anchor.instruction], anchor.code)
+		}
+	}
+}
+
+func TestX86ScalarRMRegisterSourceModesAndClosure(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ScalarRMRegisterRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		filtered, witnesses := 0, 0
+		ids := map[string]bool{}
+		for _, row := range rows {
+			if ids[row.ID] || row.ID == "" {
+				t.Fatal("original row identity is missing or repeated", row)
+			}
+			ids[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("refused source acquired a selected encoding", row)
+				}
+			} else {
+				if len(row.Witnesses) != 2 {
+					t.Fatal("register/memory alternative disappeared", row)
+				}
+				witnesses += len(row.Witnesses)
+			}
+		}
+		wantFiltered, wantWitnesses := 0, 56
+		if arch == "386" {
+			wantFiltered, wantWitnesses = 11, 34
+		}
+		if len(rows) != 28 || filtered != wantFiltered || witnesses != wantWitnesses {
+			t.Fatal("actual source/mode denominator changed", arch, len(rows), filtered, witnesses)
+		}
+	}
+	if _, err := X86ScalarRMRegisterRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign source mode acquired x86 rows")
+	}
+	if _, err := X86ScalarRMRegisterRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("empty source inventory acquired a complete closure")
+	}
+}
diff --git a/internal/goasmrules/x86_witness_scalar_rmw.go b/internal/goasmrules/x86_witness_scalar_rmw.go
new file mode 100644
index 000000000..a4855c22a
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_rmw.go
@@ -0,0 +1,992 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86ScalarRMWRow retains every source row, including mode-filtered rows.
+// Candidates describe selected syntax/bytes, not numerical or storage facts.
+type X86ScalarRMWRow struct {
+	ID, Opcode, ModeFiltered string
+	Witnesses                []X86ScalarRMWWitness
+}
+
+type X86ScalarRMWWitness struct {
+	Instruction, Destination string
+	Encoding                 []byte
+}
+
+// X86OrdinaryMoveRow keeps bank transfers and address rewrites separate from
+// GP syntax. None of these source observations grants numerical/storage facts.
+type X86OrdinaryMoveRow struct {
+	X86ScalarRMWRow
+	Role, Rewrite string
+}
+
+func X86OrdinaryMoveRows(catalog X86LegacyCatalog, arch string) ([]X86OrdinaryMoveRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("ordinary MOV requires a Go x86 mode")
+	}
+	var result []X86OrdinaryMoveRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Opcode != "MOVB" && entry.Opcode != "MOVW" && entry.Opcode != "MOVL" && entry.Opcode != "MOVQ" {
+			continue
+		}
+		if seen[entry.Opcode] {
+			return nil, fmt.Errorf("duplicate ordinary MOV source table")
+		}
+		seen[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86OrdinaryMoveRow{X86ScalarRMWRow: X86ScalarRMWRow{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses}, Role: "GP"}
+			if strings.Contains(operand.ZCase, "_xm") {
+				row.Role = "bank"
+			} else if operand.ZCase == "Zaut_r" {
+				row.Role = "address"
+				if entry.Opcode != "MOVW" {
+					row.Rewrite = "LEA" + entry.Opcode[3:]
+				}
+			}
+			if arch == "386" && entry.Prefix == "Pw8" && operand.UnmatchedOffset >= 8 {
+				row.ModeFiltered, row.Witnesses = "original Go Pw8 requires amd64 at source offset >= 8", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(seen) != 4 || len(result) != 32 && len(result) != 33 {
+		return nil, fmt.Errorf("incomplete ordinary MOV source tables: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+func x86OrdinaryMoveSchema(entry X86LegacyOpcode) []string {
+	gp := []string{"Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl", "Zil_rp/1/Yi32,Yrl", "Zilo_m/2/Yi32,Yml"}
+	switch entry.Ytab {
+	case "ymovb":
+		return []string{"Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb", "Zib_rp/1/Yi32,Yrb", "Zibo_m/2/Yi32,Ymb"}
+	case "ymovw":
+		return append(gp, "Zaut_r/2/Yiauto,Yrl")
+	case "ymovl":
+		return append(gp, "Zm_r_xm/1/Yml,Ymr", "Zr_m_xm/1/Ymr,Yml", "Zm_r_xm/2/Yml,Yxr", "Zr_m_xm/2/Yxr,Yml", "Zaut_r/2/Yiauto,Yrl")
+	case "ymovq":
+		rows := []string{"Zm_r_xm_nr/1/Ym,Ymr", "Zr_m_xm_nr/1/Ymr,Ym", "Zm_r_xm_nr/2/Yxr,Ymr", "Zm_r_xm_nr/2/Yxm,Yxr", "Zr_m_xm_nr/2/Yxr,Yxm", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"}
+		if len(entry.Rows) == 15 {
+			rows = append(rows, "Zilo_m/2/Ys32,Yrl")
+		}
+		return append(rows, "Ziq_rp/1/Yi64,Yrl", "Zilo_m/2/Yi32,Yml", "Zm_r_xm/1/Ymm,Ymr", "Zr_m_xm/1/Ymr,Ymm", "Zm_r_xm/2/Yml,Yxr", "Zr_m_xm/2/Yxr,Yml", "Zaut_r/1/Yiauto,Yrl")
+	}
+	return nil
+}
+
+// X86ExchangeRows retains the complete ordered XCHG/XADD source tables.
+// Prefix ownership, implicit locking, FLAGS and initialized inputs stay with
+// the existing typed consumers; a source witness grants none of those facts.
+func X86ExchangeRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("exchange source rows require a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if x86ScalarExchangeTable(entry.Opcode) == "" {
+			continue
+		}
+		if seen[entry.Opcode] {
+			return nil, fmt.Errorf("duplicate exchange source table")
+		}
+		seen[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses}
+			if arch == "386" && entry.Prefix == "Pw" {
+				row.ModeFiltered, row.Witnesses = "original Go rejects REX.W in 386 mode", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(seen) != 8 || len(result) != 18 {
+		return nil, fmt.Errorf("incomplete exchange source closure: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+func x86ScalarExchangeTable(name string) string {
+	if len(name) != 5 || !strings.ContainsRune("BWLQ", rune(name[4])) {
+		return ""
+	}
+	switch name[:4] {
+	case "XADD":
+		if name[4] == 'B' {
+			return "yrb_mb"
+		}
+		return "yrl_ml"
+	case "XCHG":
+		if name[4] == 'B' {
+			return "yml_mb"
+		}
+		return "yxchg"
+	}
+	return ""
+}
+
+// X86ScalarRMWRows projects the six complete legacy scalar RMW tables. The
+// original reader supplies all ordered attributes and opcode payloads; this
+// adapter does not carry a second per-mnemonic opcode table.
+func X86ScalarRMWRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "386" && arch != "amd64" {
+		return nil, fmt.Errorf("scalar RMW requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		name := entry.Opcode
+		if len(name) < 3 {
+			continue
+		}
+		stem, width := name[:len(name)-1], name[len(name)-1]
+		if !strings.Contains(" ADC ADD AND OR SBB SUB XOR INC DEC NEG NOT BTC BTR BTS ", " "+stem+" ") ||
+			!strings.ContainsRune("BWLQ", rune(width)) || strings.HasPrefix(stem, "BT") && width == 'B' {
+			continue
+		}
+		if seen[name] {
+			return nil, fmt.Errorf("duplicate scalar RMW source member %s", name)
+		}
+		seen[name] = true
+		for _, operand := range entry.Rows {
+			row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, name, entry.Ytab, operand.RowIndex), Opcode: name}
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s: %w", row.ID, err)
+			}
+			switch {
+			case arch == "386" && entry.Prefix == "Pw":
+				row.ModeFiltered = "Pw requires amd64"
+			case arch == "amd64" && entry.Prefix == "Px1" && operand.RowIndex == 0:
+				row.ModeFiltered = "amd64 skips Px1 short-register row"
+			default:
+				row.Witnesses = witnesses
+			}
+			result = append(result, row)
+		}
+	}
+	if len(seen) != 53 || len(result) != 169 {
+		return nil, fmt.Errorf("incomplete scalar RMW source closure: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+// X86ConditionalMoveRows reuses the scalar syntax/byte containers and
+// transport. Conditional reads, old destinations and FLAGS remain owned by
+// the typed family; this projection supplies no numerical or storage facts.
+func X86ConditionalMoveRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "386" && arch != "amd64" {
+		return nil, fmt.Errorf("conditional move requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if !strings.HasPrefix(entry.Opcode, "CMOV") {
+			continue
+		}
+		if seen[entry.Opcode] || len(entry.Opcode) != 7 || len(entry.Rows) != 1 {
+			return nil, fmt.Errorf("duplicate or malformed conditional-move source member")
+		}
+		seen[entry.Opcode] = true
+		operand := entry.Rows[0]
+		witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", entry.Opcode, err)
+		}
+		row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex), Opcode: entry.Opcode}
+		if arch == "386" && entry.Prefix == "Pw" {
+			row.ModeFiltered = "Pw requires amd64"
+		} else {
+			row.Witnesses = witnesses
+		}
+		result = append(result, row)
+	}
+	if len(seen) != 48 || len(result) != 48 {
+		return nil, fmt.Errorf("incomplete conditional-move source closure: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+// X86ScalarRMRegisterRows retains the non-CMOV yml_rl source closure. Mode
+// filtering follows the independently observed original Go REX.W refusals;
+// operand spellings and bytes still come from the shared scalar transport.
+func X86ScalarRMRegisterRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "386" && arch != "amd64" {
+		return nil, fmt.Errorf("scalar rm-to-register requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yml_rl" || strings.HasPrefix(entry.Opcode, "CMOV") {
+			continue
+		}
+		if seen[entry.Opcode] || len(entry.Rows) != 1 {
+			return nil, fmt.Errorf("duplicate or malformed scalar rm-to-register source")
+		}
+		seen[entry.Opcode] = true
+		witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], arch)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", entry.Opcode, err)
+		}
+		row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab), Opcode: entry.Opcode}
+		if arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Pfw" || entry.Prefix == "Pq4w" || entry.Prefix == "Pq5w") {
+			row.ModeFiltered = "original Go source rejects REX.W in 386 mode"
+		} else {
+			row.Witnesses = witnesses
+		}
+		result = append(result, row)
+	}
+	if len(result) != 28 || len(seen) != 28 {
+		return nil, fmt.Errorf("incomplete scalar rm-to-register closure: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+// X86ScalarMultiplyMOVBERows joins the complete ordered integer multiply and
+// byte-order-move tables. Implicit accumulator, old destination, FLAGS and
+// memory inputs remain the existing typed families' responsibility.
+func X86ScalarMultiplyMOVBERows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "386" && arch != "amd64" {
+		return nil, fmt.Errorf("scalar multiply/MOVBE requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		if seen[entry.Opcode] {
+			return nil, fmt.Errorf("duplicate scalar multiply/MOVBE source member")
+		}
+		seen[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, operand, arch)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses}
+			if arch == "386" && entry.Prefix == "Pw" {
+				row.ModeFiltered, row.Witnesses = "original Go rejects REX.W in 386 mode", nil
+			}
+			result = append(result, row)
+		}
+	}
+	if len(seen) != 9 || len(result) != 24 {
+		return nil, fmt.Errorf("incomplete scalar multiply/MOVBE closure: names=%d rows=%d", len(seen), len(result))
+	}
+	return result, nil
+}
+
+// X86ScalarImplicitMulDivRows retains the four complete integer families.
+// Other users of ydivb/ydivl (descriptor/state operations and NOPs) have their
+// own contracts; sharing an operand table grants no numerical authority.
+func X86ScalarImplicitMulDivRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("implicit integer rows require a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		stem, width, known := x86ScalarImplicitFamily(entry.Opcode)
+		if !known {
+			continue
+		}
+		table := "ydivl"
+		if width == 'B' {
+			table = "ydivb"
+		} else if stem == "IMUL" {
+			table = "yimul"
+		}
+		if seen[entry.Opcode] || entry.Ytab != table || len(entry.Rows) == 0 {
+			return nil, fmt.Errorf("duplicate or changed implicit integer source table")
+		}
+		seen[entry.Opcode] = true
+		witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], arch)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", entry.Opcode, err)
+		}
+		row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab),
+			Opcode: entry.Opcode, Witnesses: witnesses}
+		if arch == "386" && width == 'Q' {
+			row.ModeFiltered, row.Witnesses = "original Go rejects REX.W in 386 mode", nil
+		}
+		result = append(result, row)
+	}
+	if len(seen) != 16 {
+		return nil, fmt.Errorf("incomplete implicit integer source families: names=%d", len(seen))
+	}
+	return result, nil
+}
+
+func x86ScalarImplicitFamily(name string) (string, byte, bool) {
+	if len(name) < 4 || !strings.ContainsRune("BWLQ", rune(name[len(name)-1])) {
+		return "", 0, false
+	}
+	stem, width := name[:len(name)-1], name[len(name)-1]
+	return stem, width, stem == "MUL" || stem == "IMUL" || stem == "DIV" || stem == "IDIV"
+}
+
+// X86ScalarMoveExtensionRows retains both complete extension source schemas.
+// Ymb is an encoding class: the two legacy word-to-word spellings still read
+// words. The existing typed semantic forms own those widths and physical views.
+func X86ScalarMoveExtensionRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("extension MOV source rows require a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		_, prefix, table := x86ScalarMoveExtensionPrefix(entry.Opcode)
+		if table == "" {
+			continue
+		}
+		if seen[entry.Opcode] || entry.Ytab != table || len(entry.Rows) != 1 {
+			return nil, fmt.Errorf("duplicate or changed complete extension MOV source")
+		}
+		seen[entry.Opcode] = true
+		witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], arch)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", entry.Opcode, err)
+		}
+		row := X86ScalarRMWRow{ID: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab),
+			Opcode: entry.Opcode, Witnesses: witnesses}
+		if arch == "386" && prefix == "Pw" {
+			row.ModeFiltered, row.Witnesses = "original Go rejects REX.W in 386 mode", nil
+		}
+		result = append(result, row)
+	}
+	if len(seen) != 14 {
+		return nil, fmt.Errorf("incomplete extension MOV source families: names=%d", len(seen))
+	}
+	return result, nil
+}
+
+// The returned width selects the encoding prefix, not a memory-read extent.
+// Source bytes still come from the original table, never a mnemonic-byte map.
+func x86ScalarMoveExtensionPrefix(name string) (byte, string, string) {
+	if len(name) == 6 && name[:3] == "MOV" && (name[3] == 'S' || name[3] == 'Z') && name[4:] == "WW" {
+		return 'W', "Pe", "ymb_rl"
+	}
+	if len(name) != 7 || name[:3] != "MOV" || name[5:] != "SX" && name[5:] != "ZX" {
+		return 0, "", ""
+	}
+	source, destination := name[3], name[4]
+	if source == 'B' && strings.ContainsRune("WLQ", rune(destination)) {
+		return destination, map[byte]string{'W': "Pq", 'L': "Pm", 'Q': "Pw"}[destination], "ymb_rl"
+	}
+	if source == 'W' && (destination == 'L' || destination == 'Q') {
+		return destination, map[byte]string{'L': "Pm", 'Q': "Pw"}[destination], "yml_rl"
+	}
+	if source == 'L' && destination == 'Q' {
+		if name[5:] == "ZX" {
+			return 'L', "Px", "yml_rl" // Ordinary MOVL, including mode32.
+		}
+		return 'Q', "Pw", "yml_rl"
+	}
+	return 0, "", ""
+}
+
+// Validate every original row before selecting a byte offset. The selected
+// row alone cannot establish the stride, arity or identity of earlier rows.
+// Exact schemas and a 0/1 source escape bound all subsequent offset arithmetic.
+func x86ScalarCompleteOperandSchema(entry X86LegacyOpcode, row X86LegacyOperand, schema []string) error {
+	if len(schema) == 0 || len(entry.Rows) != len(schema) || row.RowIndex < 0 || row.RowIndex >= len(schema) ||
+		entry.EscapeAdjustment < 0 || entry.EscapeAdjustment > 1 {
+		return fmt.Errorf("unmodeled complete scalar operand schema/escape")
+	}
+	if entry.OpcodeExpression != "" {
+		name, err := x86SourceOpcodeName(strings.TrimPrefix(entry.OpcodeExpression, "obj."))
+		if err != nil || name != entry.Opcode {
+			return fmt.Errorf("scalar opcode disagrees with its captured source enum")
+		}
+	}
+	offset := 0
+	for index, original := range entry.Rows {
+		fields := strings.Split(schema[index], "/")
+		if len(fields) != 3 {
+			return fmt.Errorf("invalid internal scalar schema")
+		}
+		var classes []string
+		if fields[2] != "" {
+			classes = strings.Split(fields[2], ",")
+		}
+		stride, err := strconv.Atoi(fields[1])
+		if err != nil || stride < 0 || original.RowIndex != index || original.ZCase != fields[0] ||
+			original.ZOffset != stride || original.UnmatchedOffset != offset || len(original.Classes) != len(classes) {
+			return fmt.Errorf("scalar complete original row identity changed")
+		}
+		for position, class := range classes {
+			if original.Classes[position] != class {
+				return fmt.Errorf("scalar complete original operand class changed")
+			}
+		}
+		offset += stride + entry.EscapeAdjustment
+	}
+	original := entry.Rows[row.RowIndex]
+	if row.ZCase != original.ZCase || row.ZOffset != original.ZOffset || row.UnmatchedOffset != original.UnmatchedOffset ||
+		len(row.Classes) != len(original.Classes) {
+		return fmt.Errorf("scalar selected row differs from complete original source")
+	}
+	for index, class := range original.Classes {
+		if row.Classes[index] != class {
+			return fmt.Errorf("scalar selected operand classes differ from original row")
+		}
+	}
+	return nil
+}
+
+func x86ScalarRMWRowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand, arch string) ([]X86ScalarRMWWitness, error) {
+	// These are ordered physical schemas, not opcode values. In particular,
+	// /digit immediate extension and ModRM direction have different transports.
+	schemas := map[string][]string{
+		"yxorb":   {"Zib_/1/Yi32,Yal", "Zibo_m/2/Yi32,Ymb", "Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb"},
+		"yaddl":   {"Zibo_m/2/Yi8,Yml", "Zil_/1/Yi32,Yax", "Zilo_m/2/Yi32,Yml", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"},
+		"yincl":   {"Z_rp/1/Yrl", "Zo_m/2/Yml"},
+		"yincq":   {"Zo_m/2/Yml"},
+		"yscond":  {"Zo_m/2/Ymb"},
+		"ybtl":    {"Zibo_m/2/Yi8,Yml", "Zr_m/1/Yrl,Yml"},
+		"yml_rl":  {"Zm_r/1/Yml,Yrl"},
+		"ymb_rl":  {"Zmb_r/1/Ymb,Yrl"},
+		"ycmpb":   {"Z_ib/1/Yal,Yi32", "Zm_ibo/2/Ymb,Yi32", "Zm_r/1/Ymb,Yrb", "Zr_m/1/Yrb,Ymb"},
+		"ycmpl":   {"Zm_ibo/2/Yml,Yi8", "Z_il/1/Yax,Yi32", "Zm_ilo/2/Yml,Yi32", "Zm_r/1/Yml,Yrl", "Zr_m/1/Yrl,Yml"},
+		"ytestl":  {"Zil_/1/Yi32,Yax", "Zilo_m/2/Yi32,Yml", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"},
+		"yimul":   {"Zm_o/2/Yml", "Zib_rr/1/Yi8,Yrl", "Zil_rr/1/Yi32,Yrl", "Zm_r/2/Yml,Yrl"},
+		"yimul3":  {"Zibm_r/2/Yi8,Yml,Yrl", "Zibm_r/2/Yi32,Yml,Yrl"},
+		"ymovbe":  {"Zlitm_r/3/Ym,Yrl", "Zlitr_m/3/Yrl,Ym"},
+		"ydivb":   {"Zm_o/2/Ymb"},
+		"ydivl":   {"Zm_o/2/Yml"},
+		"yrb_mb":  {"Zr_m/1/Yrb,Ymb"},
+		"yrl_ml":  {"Zr_m/1/Yrl,Yml"},
+		"yml_mb":  {"Zr_m/1/Yrb,Ymb", "Zm_r/1/Ymb,Yrb"},
+		"yxchg":   {"Z_rp/1/Yax,Yrl", "Zrp_/1/Yrl,Yax", "Zr_m/1/Yrl,Yml", "Zm_r/1/Yml,Yrl"},
+		"ybswap":  {"Z_rp/2/Yrl"},
+		"ym_rl":   {"Zm_r/1/Ym,Yrl"},
+		"ycrc32b": {"Zlitm_r/0/Ymb,Yrl"},
+		"ycrc32l": {"Zlitm_r/0/Yml,Yrl"},
+		"yrdrand": {"Zo_m/2/Yrl"},
+	}
+	schema := schemas[entry.Ytab]
+	ordinary := x86OrdinaryMoveSchema(entry)
+	if ordinary != nil {
+		schema = ordinary
+	}
+	if entry.Opcode == "" {
+		return nil, fmt.Errorf("missing scalar source opcode")
+	}
+	width := entry.Opcode[len(entry.Opcode)-1]
+	exchangeTable := x86ScalarExchangeTable(entry.Opcode)
+	exchange := exchangeTable != ""
+	if exchange && exchangeTable != entry.Ytab {
+		return nil, fmt.Errorf("exchange source family does not own this table")
+	}
+	if !exchange && (entry.Ytab == "yml_mb" || entry.Ytab == "yxchg" ||
+		(entry.Ytab == "yrb_mb" || entry.Ytab == "yrl_ml" || entry.Ytab == "ybswap" ||
+			entry.Ytab == "ym_rl" || entry.Ytab == "ycrc32b" || entry.Ytab == "ycrc32l" || entry.Ytab == "yrdrand") &&
+			!x86GPDataFlagsCPUSourceMember(entry)) {
+		return nil, fmt.Errorf("source family does not own the shared data table")
+	}
+	if entry.Ytab == "yxorb" && width != 'B' || entry.Ytab == "ytestl" && !strings.ContainsRune("WLQ", rune(width)) {
+		return nil, fmt.Errorf("scalar table and operand width disagree")
+	}
+	if entry.Opcode == "RDPID" {
+		width = 'L' // Its source has no suffix, but the Yrl result uses 32 bits.
+	}
+	if entry.Ytab == "ydivb" || entry.Ytab == "ydivl" {
+		stem, actualWidth, known := x86ScalarImplicitFamily(entry.Opcode)
+		if !known || actualWidth == 'B' && entry.Ytab != "ydivb" || actualWidth != 'B' &&
+			(entry.Ytab != "ydivl" || stem == "IMUL") {
+			return nil, fmt.Errorf("shared divide table member is outside the implicit integer family")
+		}
+	}
+	conditional := strings.HasPrefix(entry.Opcode, "CMOV")
+	remainingPrefix := ""
+	if conditional {
+		if len(entry.Opcode) != 7 || entry.Ytab != "yml_rl" || !strings.ContainsRune("WLQ", rune(entry.Opcode[4])) {
+			return nil, fmt.Errorf("unmodeled conditional-move source shape")
+		}
+		width = entry.Opcode[4]
+	} else if entry.Ytab == "yml_rl" {
+		width, remainingPrefix = x86ScalarYmlRegisterPrefix(entry.Opcode)
+		if remainingPrefix == "" {
+			return nil, fmt.Errorf("scalar source family does not own this table")
+		}
+	} else if entry.Ytab == "ymb_rl" {
+		var table string
+		width, remainingPrefix, table = x86ScalarMoveExtensionPrefix(entry.Opcode)
+		if table != "ymb_rl" {
+			return nil, fmt.Errorf("extension MOV source class does not own this table")
+		}
+	}
+	expectedPrefix := map[byte]string{'B': "Pb", 'W': "Pe", 'L': "Px", 'Q': "Pw"}[width]
+	if ordinary != nil {
+		if entry.Ytab != "ymov"+strings.ToLower(string(width)) || entry.Opcode != "MOV"+string(width) || entry.EscapeAdjustment != 0 {
+			return nil, fmt.Errorf("ordinary MOV source role/escape changed")
+		}
+		if width == 'Q' {
+			expectedPrefix = "Pw8"
+		}
+	} else if remainingPrefix != "" {
+		expectedPrefix = remainingPrefix
+	} else if (entry.Ytab == "ybtl" || conditional) && width != 'Q' {
+		expectedPrefix = map[byte]string{'W': "Pq", 'L': "Pm"}[width]
+	} else if entry.Ytab == "yincl" {
+		expectedPrefix = "Px1"
+	} else if entry.Ytab == "ymovbe" {
+		expectedPrefix = map[byte]string{'W': "Pq", 'L': "Pm", 'Q': "Pw"}[width]
+	} else if entry.Opcode == "MOVNTIL" || entry.Opcode == "CMPXCHG8B" {
+		expectedPrefix = "Pm"
+	} else if entry.Opcode == "CMPXCHG16B" {
+		expectedPrefix = "Pw"
+	} else if entry.Opcode == "RDPID" {
+		expectedPrefix = "Pf3"
+	} else if entry.Ytab == "ycrc32b" {
+		expectedPrefix = "Px"
+	}
+	if entry.Kind != "encoding" || expectedPrefix == "" || entry.Prefix != expectedPrefix {
+		return nil, fmt.Errorf("unmodeled complete scalar operand schema/prefix")
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, schema); err != nil {
+		return nil, err
+	}
+	multiplyMove := entry.Ytab == "yimul" || entry.Ytab == "yimul3" || entry.Ytab == "ymovbe"
+	if multiplyMove && !strings.ContainsRune("WLQ", rune(width)) {
+		return nil, fmt.Errorf("scalar carrier is outside the complete table grammar")
+	}
+	var payload []byte
+	mediaPrefixes := map[int]string{}
+	if ordinary != nil {
+		for _, original := range entry.Rows {
+			if strings.Contains(original.ZCase, "_xm") && original.ZOffset == 2 {
+				marker := "Pe"
+				if original.ZCase == "Zm_r_xm_nr" {
+					marker = "Pf3"
+					if original.Classes[1] == "Ymr" {
+						marker = "Pf2"
+					}
+				}
+				mediaPrefixes[original.UnmatchedOffset] = marker
+			}
+		}
+	}
+	for index, token := range entry.OpBytes {
+		if marker := mediaPrefixes[index]; marker != "" {
+			if token != marker {
+				return nil, fmt.Errorf("ordinary MOV source media-prefix atom changed")
+			}
+			payload = append(payload, map[string]byte{"Pe": 0x66, "Pf2": 0xf2, "Pf3": 0xf3}[marker])
+			continue
+		}
+		if entry.Ytab == "yimul" && index == 4 {
+			if token != "Pm" {
+				return nil, fmt.Errorf("scalar multiply source lost its symbolic escape")
+			}
+			payload = append(payload, 0x0f) // Go's Pm opcode-escape atom.
+			continue
+		}
+		value, err := strconv.ParseUint(token, 0, 8)
+		if err != nil {
+			return nil, fmt.Errorf("scalar opcode atom is not a byte")
+		}
+		payload = append(payload, byte(value))
+	}
+	adjustment := 0
+	if len(payload) != 0 && payload[0] == 0x0f {
+		adjustment = 1
+	}
+	if entry.EscapeAdjustment != adjustment {
+		return nil, fmt.Errorf("scalar original leading byte and source escape differ")
+	}
+	if multiplyMove {
+		for _, original := range entry.Rows {
+			start, size := original.UnmatchedOffset, original.ZOffset+entry.EscapeAdjustment
+			if start < 0 || start+size > len(payload) {
+				return nil, fmt.Errorf("scalar complete source payload is truncated")
+			}
+			for index, atom := range payload[start : start+size] {
+				terminator := entry.Ytab != "yimul" && index == size-1
+				if terminator != (atom == 0) || entry.Ytab == "yimul" && start == 0 && index == 1 && atom > 7 {
+					return nil, fmt.Errorf("scalar literal terminator or extension changed")
+				}
+			}
+			if entry.Ytab == "ymovbe" && (entry.EscapeAdjustment == 1) != (payload[start] == 0x0f) {
+				return nil, fmt.Errorf("scalar literal source escape changed")
+			}
+		}
+	}
+	offset := 0
+	for _, previous := range entry.Rows[:row.RowIndex] {
+		offset += previous.ZOffset + adjustment
+	}
+	last := entry.Rows[len(entry.Rows)-1]
+	payloadEnd := last.UnmatchedOffset + last.ZOffset + adjustment
+	literalData := entry.Ytab == "ycrc32b" || entry.Ytab == "ycrc32l"
+	if entry.Ytab == "ybswap" {
+		// Z_rp consumes escape+opcode, not the unmatched-row stride.
+		payloadEnd = 2
+		if len(payload) != 2 || payload[0] != 0x0f || payload[1] == 0 || payload[1]&7 != 0 {
+			return nil, fmt.Errorf("unmodeled register-in-opcode source span")
+		}
+	}
+	if literalData {
+		span, mandatory := 3, byte(0xf3)
+		if strings.HasPrefix(entry.Opcode, "CRC32") {
+			span, mandatory = 4, 0xf2
+		}
+		if len(payload) != span && len(payload) != span+1 || len(payload) < 2 ||
+			payload[0] != mandatory || payload[1] != 0x0f || span == 4 && payload[2] != 0x38 {
+			return nil, fmt.Errorf("unmodeled complete data literal map/span")
+		}
+		for i, atom := range payload {
+			if (i == span) != (atom == 0) {
+				return nil, fmt.Errorf("data literal opcode or zero terminator changed")
+			}
+		}
+		payloadEnd = len(payload) // Fixed-array padding supplies an omitted zero.
+	}
+	if ordinary != nil && last.ZCase == "Zaut_r" {
+		// Go advances by zoffset on a nonmatch, but Zaut_r consumes only its
+		// single placeholder. The final MOVW/L row retains its original stride.
+		payloadEnd = last.UnmatchedOffset + 1
+	}
+	if entry.EscapeAdjustment != adjustment || row.UnmatchedOffset != offset ||
+		payloadEnd != len(payload) || offset < 0 || offset >= len(payload) {
+		return nil, fmt.Errorf("scalar complete payload/ordered offset changed")
+	}
+	if ordinary != nil {
+		for _, original := range entry.Rows {
+			start := original.UnmatchedOffset
+			if strings.Contains(original.ZCase, "_xm") && original.ZOffset == 2 {
+				start++
+			}
+			if original.ZCase != "Zaut_r" && (payload[start] == 0 || payload[start] == 0x0f) {
+				return nil, fmt.Errorf("ordinary MOV opcode atom crosses its source span")
+			}
+			switch original.ZCase {
+			case "Zibo_m", "Zilo_m":
+				if payload[start+1] != 0 {
+					return nil, fmt.Errorf("ordinary immediate MOV lost its /0 extension")
+				}
+			case "Zaut_r":
+				if payload[start] != 0 {
+					return nil, fmt.Errorf("ordinary address MOV lost its unused placeholder")
+				}
+			}
+		}
+	}
+	if exchange {
+		for _, original := range entry.Rows {
+			start := original.UnmatchedOffset + adjustment
+			if payload[start] == 0 || payload[start] == 0x0f ||
+				(original.ZCase == "Z_rp" || original.ZCase == "Zrp_") && payload[start]&7 != 0 {
+				return nil, fmt.Errorf("exchange opcode span or short-register base changed")
+			}
+		}
+	}
+	var prefix []byte
+	switch entry.Prefix {
+	case "Pe":
+		prefix = []byte{0x66}
+	case "Pm":
+		prefix = []byte{0x0f}
+	case "Pq":
+		prefix = []byte{0x66, 0x0f}
+	case "Pw":
+		prefix = []byte{0x48}
+	case "Pw8":
+		if offset >= 8 {
+			prefix = []byte{0x48}
+		}
+	case "Pf3":
+		prefix = []byte{0xf3, 0x0f}
+	case "Pef3":
+		prefix = []byte{0x66, 0xf3, 0x0f}
+	case "Pfw":
+		prefix = []byte{0xf3, 0x48, 0x0f}
+	case "Pq4":
+		prefix = []byte{0x66, 0x0f, 0x38}
+	case "Pq4w":
+		prefix = []byte{0x66, 0x48, 0x0f, 0x38}
+	case "Pq5":
+		prefix = []byte{0xf3, 0x0f, 0x38}
+	case "Pq5w":
+		prefix = []byte{0xf3, 0x48, 0x0f, 0x38}
+	}
+	if literalData && entry.Prefix == "Pw" {
+		prefix = nil // REX follows the literal's mandatory F2/F3 below.
+	}
+	bank := ordinary != nil && strings.Contains(row.ZCase, "_xm")
+	if bank {
+		if row.ZOffset == 2 {
+			prefix = append([]byte{payload[offset]}, prefix...)
+			offset++
+		}
+		prefix = append(prefix, 0x0f)
+	}
+	if payload[offset] == 0x0f {
+		prefix = append(prefix, 0x0f)
+		offset++
+	}
+	if offset >= len(payload) {
+		return nil, fmt.Errorf("missing scalar opcode")
+	}
+	byteOperand := width == 'B'
+	src, dst, accumulator := "CX", "BX", "AX"
+	if byteOperand {
+		src, dst, accumulator = "CL", "BL", "AL"
+	}
+	if literalData {
+		dst = "BX" // CRC32B reads one byte, but its result carrier is not byte-sized.
+	}
+	// Earlier matching classes own register/register and small-immediate
+	// shadows. The late direction is witnessed by memory source instead.
+	var operands [][2]string
+	immediate := int64(128)
+	compare := entry.Ytab == "ycmpl" || entry.Ytab == "ycmpb"
+	switch row.ZCase {
+	case "Zib_", "Zil_":
+		operands = append(operands, [2]string{"$128", accumulator})
+	case "Z_ib", "Z_il":
+		operands = append(operands, [2]string{accumulator, "$128"})
+	case "Zm_ibo", "Zm_ilo":
+		if row.Classes[1] == "Yi8" {
+			immediate = 1
+		}
+		operands = append(operands, [2]string{dst, fmt.Sprint("$", immediate)}, [2]string{"0(SI)", fmt.Sprint("$", immediate)})
+	case "Zibo_m", "Zilo_m":
+		if row.Classes[0] == "Yi8" {
+			immediate = 1
+		}
+		if ordinary != nil {
+			if row.Classes[0] == "Ys32" {
+				immediate = -1
+				operands = append(operands, [2]string{"$-1", dst})
+			} else {
+				operands = append(operands, [2]string{fmt.Sprint("$", immediate), "0(SI)"})
+			}
+		} else {
+			operands = append(operands, [2]string{fmt.Sprint("$", immediate), dst}, [2]string{fmt.Sprint("$", immediate), "0(SI)"})
+		}
+	case "Zib_rp", "Zil_rp", "Ziq_rp":
+		if row.ZCase == "Ziq_rp" {
+			immediate = 0x1122334455667788
+			operands = append(operands, [2]string{"$0x1122334455667788", dst})
+		} else {
+			operands = append(operands, [2]string{fmt.Sprint("$", immediate), dst})
+		}
+	case "Zaut_r":
+		operands = append(operands, [2]string{"$slot+0(SP)", dst})
+	case "Zm_r_xm", "Zm_r_xm_nr":
+		destination := "M1"
+		if row.Classes[1] == "Yxr" {
+			destination = "X1"
+		}
+		switch row.Classes[0] {
+		case "Ym":
+			operands = append(operands, [2]string{"0(SI)", destination})
+		case "Yxr", "Yxm":
+			operands = append(operands, [2]string{"X0", destination})
+			if row.Classes[0] == "Yxm" {
+				operands = append(operands, [2]string{"0(SI)", destination})
+			}
+		default:
+			operands = append(operands, [2]string{src, destination})
+			if width == 'L' {
+				operands = append(operands, [2]string{"0(SI)", destination})
+			}
+		}
+	case "Zr_m_xm", "Zr_m_xm_nr":
+		source := "M1"
+		if row.Classes[0] == "Yxr" {
+			source = "X1"
+		}
+		if row.Classes[1] == "Ym" || row.Classes[1] == "Yxm" {
+			operands = append(operands, [2]string{source, "0(SI)"})
+		} else {
+			operands = append(operands, [2]string{source, src})
+			if width == 'L' {
+				operands = append(operands, [2]string{source, "0(SI)"})
+			}
+		}
+	case "Zib_rr", "Zil_rr", "Zibm_r":
+		if row.Classes[0] == "Yi8" {
+			immediate = 1
+		}
+		input := fmt.Sprint("$", immediate)
+		if row.ZCase == "Zibm_r" {
+			operands = append(operands, [2]string{input + "," + src, dst}, [2]string{input + ",0(SI)", dst})
+		} else {
+			operands = append(operands, [2]string{input, dst})
+		}
+	case "Zr_m":
+		if !compare {
+			operands = append(operands, [2]string{src, dst})
+		}
+		operands = append(operands, [2]string{src, "0(SI)"})
+	case "Zm_r", "Zmb_r":
+		if entry.Ytab == "yml_rl" || entry.Ytab == "ymb_rl" || entry.Ytab == "yimul" || compare {
+			operands = append(operands, [2]string{src, dst})
+		}
+		operands = append(operands, [2]string{"0(SI)", dst})
+	case "Zlitm_r":
+		if literalData {
+			operands = append(operands, [2]string{src, dst})
+		}
+		operands = append(operands, [2]string{"0(SI)", dst})
+	case "Zlitr_m":
+		operands = append(operands, [2]string{src, "0(SI)"})
+	case "Zm_o":
+		operands = append(operands, [2]string{"", src}, [2]string{"", "0(SI)"})
+	case "Z_rp":
+		if exchange {
+			operands = append(operands, [2]string{"AX", dst}, [2]string{"AX", "AX"})
+		} else {
+			operands = append(operands, [2]string{"", dst})
+		}
+	case "Zrp_":
+		operands = append(operands, [2]string{dst, "AX"})
+	case "Zo_m":
+		if entry.Ytab != "yincl" || arch == "amd64" {
+			operands = append(operands, [2]string{"", dst})
+		}
+		if len(row.Classes) != 1 || row.Classes[0] != "Yrl" {
+			operands = append(operands, [2]string{"", "0(SI)"})
+		}
+	}
+	var witnesses []X86ScalarRMWWitness
+	for _, args := range operands {
+		code := append(append([]byte(nil), prefix...), payload[offset])
+		memory := args[0] == "0(SI)" || args[1] == "0(SI)" || row.ZCase == "Zibm_r" && strings.HasSuffix(args[0], ",0(SI)")
+		rm := byte(3)
+		if memory {
+			rm = 6
+		} else {
+			rm |= 0xc0
+			if row.ZCase == "Zm_r" || row.ZCase == "Zmb_r" || row.ZCase == "Zibm_r" || row.ZCase == "Zm_o" || literalData {
+				rm = 0xc1
+			} // CX source, BX destination.
+		}
+		if bank {
+			rm = 0xc1
+			if args[0] == "X0" {
+				rm = 0xc0
+			}
+			if memory {
+				rm = 6
+			}
+		}
+		switch row.ZCase {
+		case "Zm_r_xm", "Zm_r_xm_nr", "Zr_m_xm", "Zr_m_xm_nr":
+			code = append(code, rm|1<<3)
+		case "Zaut_r":
+			code[len(code)-1] = 0x8d // Go's Zaut_r transport; L/Q are progedit rewrites.
+			code = append(code, 0x1c, 0x24)
+		case "Zr_m":
+			code = append(code, rm|1<<3)
+		case "Zm_r", "Zmb_r":
+			code = append(code, rm|3<<3)
+		case "Zib_rr", "Zil_rr", "Zibm_r":
+			code = append(code, rm|3<<3)
+		case "Zlitm_r", "Zlitr_m":
+			if literalData && entry.Prefix == "Pw" {
+				code = append(code, 0x48)
+			}
+			end := offset + 1
+			for end < len(payload) && payload[end] != 0 {
+				code = append(code, payload[end])
+				end++
+			}
+			register := byte(3)
+			if row.ZCase == "Zlitr_m" {
+				register = 1
+			}
+			code = append(code, rm|register<<3)
+		case "Zibo_m", "Zilo_m", "Zm_ibo", "Zm_ilo", "Zo_m", "Zm_o":
+			if offset+1 >= len(payload) || payload[offset+1] > 7 {
+				return nil, fmt.Errorf("scalar /digit is not a three-bit extension")
+			}
+			code = append(code, rm|payload[offset+1]<<3)
+		case "Z_rp", "Zrp_", "Zib_rp", "Zil_rp", "Ziq_rp":
+			if !exchange || args[0] != "AX" || args[1] != "AX" {
+				code[len(code)-1] += 3
+			}
+		}
+		if row.ZCase != "Zaut_r" && (strings.HasPrefix(args[0], "$") || compare && strings.HasPrefix(args[1], "$")) {
+			n := 1
+			if row.ZCase == "Zil_" || row.ZCase == "Zilo_m" || row.ZCase == "Z_il" || row.ZCase == "Zm_ilo" ||
+				row.ZCase == "Zil_rr" || row.ZCase == "Zil_rp" || row.ZCase == "Zibm_r" && row.Classes[0] == "Yi32" {
+				n = 4
+				if width == 'W' {
+					n = 2
+				}
+			}
+			if row.ZCase == "Ziq_rp" {
+				n = 8
+			}
+			for shift := 0; shift < n; shift++ {
+				code = append(code, byte(immediate>>uint(shift*8)))
+			}
+		}
+		instruction := entry.Opcode + " "
+		if args[0] != "" {
+			instruction += args[0] + ","
+		}
+		destination := args[1]
+		if row.ZCase == "Zm_o" {
+			destination = "AX" // B uses AL/AH; the separate DX output remains a semantic effect.
+		}
+		witnesses = append(witnesses, X86ScalarRMWWitness{Instruction: instruction + args[1], Destination: destination, Encoding: code})
+	}
+	return witnesses, nil
+}
+
+// This is family/prefix grammar, not an opcode-byte table. The original Go
+// payload remains the only instruction-byte source. GP spellings use the Yrl
+// carrier; source-memory tuples and result definedness belong to typed effects.
+func x86ScalarYmlRegisterPrefix(name string) (byte, string) {
+	if len(name) < 2 {
+		return 0, ""
+	}
+	if strings.HasPrefix(name, "MOV") {
+		width, prefix, table := x86ScalarMoveExtensionPrefix(name)
+		if table != "yml_rl" {
+			return 0, ""
+		}
+		return width, prefix
+	}
+	width, stem := name[len(name)-1], name[:len(name)-1]
+	switch stem {
+	case "BSF", "BSR", "LAR", "LSL":
+		return width, map[byte]string{'W': "Pq", 'L': "Pm", 'Q': "Pw"}[width]
+	case "LZCNT", "POPCNT":
+		return width, map[byte]string{'W': "Pef3", 'L': "Pf3", 'Q': "Pfw"}[width]
+	case "ADCX", "ADOX":
+		prefix := "Pq4"
+		if stem == "ADOX" {
+			prefix = "Pq5"
+		}
+		if width == 'Q' {
+			return width, prefix + "w"
+		}
+		if width == 'L' {
+			return width, prefix
+		}
+	}
+	return 0, ""
+}
diff --git a/internal/goasmrules/x86_witness_scalar_rmw_test.go b/internal/goasmrules/x86_witness_scalar_rmw_test.go
new file mode 100644
index 000000000..7eceedce9
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_rmw_test.go
@@ -0,0 +1,835 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarMoveExtensionOriginalTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, entry := range catalog.Optab {
+		if !strings.HasPrefix(entry.Opcode, "MOV") || entry.Ytab != "ymb_rl" && entry.Ytab != "yml_rl" {
+			continue
+		}
+		count++
+		t.Run(entry.Opcode, func(t *testing.T) {
+			witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], "amd64")
+			if err != nil || len(witnesses) != 2 {
+				t.Fatal("SCALAR_EXTENSION_SOURCE_FEATURE_GAP", err)
+			}
+		})
+	}
+	if count != 14 {
+		t.Fatal("complete extension source family changed", count)
+	}
+}
+
+func TestX86ScalarMoveExtensionCompleteRowsAndModes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ScalarMoveExtensionRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, filtered, witnesses := map[string]bool{}, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || seen[row.ID] || row.Opcode == "MOVLQZX" && row.ModeFiltered != "" {
+				t.Fatal("source identity or legal mode32 MOVLQZX lost", row)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("mode32 Pw form acquired selected syntax")
+				}
+			}
+			witnesses += len(row.Witnesses)
+		}
+		if len(rows) != 14 || filtered != map[string]int{"amd64": 0, "386": 5}[arch] || witnesses != map[string]int{"amd64": 28, "386": 18}[arch] {
+			t.Fatal("complete extension source/mode closure changed", arch, len(rows), filtered, witnesses)
+		}
+	}
+	for _, arch := range []string{"", "arm64", "wasm"} {
+		if _, err := X86ScalarMoveExtensionRows(catalog, arch); err == nil {
+			t.Fatal("foreign mode acquired x86 extension source rows", arch)
+		}
+	}
+	if _, err := X86ScalarMoveExtensionRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("empty extension source silently passed")
+	}
+	for index, entry := range catalog.Optab {
+		if entry.Opcode != "MOVSWW" {
+			continue
+		}
+		changed := catalog
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab[:index]...), catalog.Optab[index+1:]...)
+		if _, err := X86ScalarMoveExtensionRows(changed, "amd64"); err == nil {
+			t.Fatal("missing word-word source silently passed")
+		}
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab...), entry)
+		if _, err := X86ScalarMoveExtensionRows(changed, "amd64"); err == nil {
+			t.Fatal("duplicate extension source silently passed")
+		}
+		break
+	}
+}
+
+func TestX86ScalarMoveExtensionCompleteMetadataBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	maxInt := int(^uint(0) >> 1)
+	for _, entry := range catalog.Optab {
+		if !strings.HasPrefix(entry.Opcode, "MOV") || entry.Ytab != "ymb_rl" && entry.Ytab != "yml_rl" {
+			continue
+		}
+		for _, field := range []string{"original-arity", "selected-arity", "original-index", "selected-index", "original-offset",
+			"selected-offset", "original-stride", "selected-stride", "zcase", "row-count", "prefix", "source-role", "opcode", "nonbyte", "payload-short", "payload-extra"} {
+			t.Run(entry.Opcode+"/"+field, func(t *testing.T) {
+				changed, row := entry, entry.Rows[0]
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				changed.OpBytes = append([]string(nil), entry.OpBytes...)
+				switch field {
+				case "original-arity":
+					changed.Rows[0].Classes = []string{strings.Join(row.Classes, ",")}
+				case "selected-arity":
+					row.Classes = []string{strings.Join(row.Classes, ",")}
+				case "original-index":
+					changed.Rows[0].RowIndex++
+				case "selected-index":
+					row.RowIndex = -1
+				case "original-offset":
+					changed.Rows[0].UnmatchedOffset = -1
+				case "selected-offset":
+					row.UnmatchedOffset = maxInt
+				case "original-stride":
+					changed.Rows[0].ZOffset = maxInt
+				case "selected-stride":
+					row.ZOffset = -1
+				case "zcase":
+					changed.Rows[0].ZCase, row.ZCase = "Zr_m", "Zr_m"
+				case "row-count":
+					changed.Rows = append(changed.Rows, row)
+				case "prefix":
+					changed.Prefix = "P32"
+				case "source-role":
+					changed.Ytab, row.ZCase, row.Classes = "yml_rl", "Zm_r", []string{"Yml", "Yrl"}
+					if entry.Ytab == "yml_rl" {
+						changed.Ytab, row.ZCase, row.Classes = "ymb_rl", "Zmb_r", []string{"Ymb", "Yrl"}
+					}
+					changed.Rows[0] = row
+				case "opcode":
+					changed.Opcode += ".BAD"
+				case "nonbyte":
+					changed.OpBytes[0] = "0x100"
+				case "payload-short":
+					changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+				case "payload-extra":
+					changed.OpBytes = append(changed.OpBytes, "0")
+				}
+				if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+					t.Fatal("SCALAR_EXTENSION_MALFORMED_ACCEPTED", field)
+				}
+			})
+		}
+		for _, escape := range []int{-4, -1, 2, maxInt - 1, maxInt} {
+			t.Run(fmt.Sprintf("%s/escape%d", entry.Opcode, escape), func(t *testing.T) {
+				changed := entry
+				changed.EscapeAdjustment = escape
+				defer func() {
+					if failure := recover(); failure != nil {
+						t.Error("SCALAR_EXTENSION_METADATA_PANIC", failure)
+					}
+				}()
+				if _, err := x86ScalarRMWRowWitnesses(changed, changed.Rows[0], "amd64"); err == nil {
+					t.Fatal("SCALAR_EXTENSION_MALFORMED_ACCEPTED", escape)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarImplicitMulDivOriginalSourceTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, excluded := 0, 0
+	numeric := regexp.MustCompile(`^(?:I?MUL|I?DIV)[BWLQ]$`)
+	for _, entry := range catalog.Optab {
+		if numeric.MatchString(entry.Opcode) && (entry.Ytab == "ydivb" || entry.Ytab == "ydivl" || entry.Ytab == "yimul") {
+			selected++
+			t.Run(entry.Opcode, func(t *testing.T) {
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], "amd64")
+				if err != nil || len(witnesses) != 2 {
+					t.Fatal("SCALAR_IMPLICIT_MULDIV_SOURCE_FEATURE_GAP", err)
+				}
+			})
+		} else if entry.Ytab == "ydivb" || entry.Ytab == "ydivl" {
+			excluded++
+			t.Run("separate-state-or-nop/"+entry.Opcode, func(t *testing.T) {
+				if _, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], "amd64"); err == nil {
+					t.Fatal("descriptor/state/NOP acquired the numerical source transport")
+				}
+			})
+		}
+	}
+	if selected != 16 || excluded != 12 {
+		t.Fatal("complete numerical/state source partition changed", selected, excluded)
+	}
+}
+
+func TestX86ScalarImplicitMulDivCompleteRowsAndModes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ScalarImplicitMulDivRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, filtered, witnesses := map[string]bool{}, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || seen[row.ID] {
+				t.Fatal("implicit source identity is absent or repeated", row.ID)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("386 Q source acquired a named witness")
+				}
+			}
+			for _, witness := range row.Witnesses {
+				if witness.Destination != "AX" {
+					t.Fatal("implicit primary result lost AX/AL:AH carrier", witness)
+				}
+				witnesses++
+			}
+		}
+		if len(rows) != 16 || filtered != map[string]int{"amd64": 0, "386": 4}[arch] ||
+			witnesses != map[string]int{"amd64": 32, "386": 24}[arch] {
+			t.Fatal("complete implicit source/mode union differs", arch, len(rows), filtered, witnesses)
+		}
+	}
+	for _, arch := range []string{"", "arm", "wasm"} {
+		if _, err := X86ScalarImplicitMulDivRows(catalog, arch); err == nil {
+			t.Fatal("foreign mode acquired an implicit x86 source view", arch)
+		}
+	}
+	if _, err := X86ScalarImplicitMulDivRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("missing source closure silently passed")
+	}
+	for index, entry := range catalog.Optab {
+		if entry.Opcode != "DIVB" {
+			continue
+		}
+		changed := catalog
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab[:index]...), catalog.Optab[index+1:]...)
+		if _, err := X86ScalarImplicitMulDivRows(changed, "amd64"); err == nil {
+			t.Fatal("missing original family member silently passed")
+		}
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab...), entry)
+		if _, err := X86ScalarImplicitMulDivRows(changed, "amd64"); err == nil {
+			t.Fatal("duplicate original family member silently passed")
+		}
+		break
+	}
+}
+
+func TestX86ScalarImplicitMulDivMalformedSourceIsBounded(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	numeric := regexp.MustCompile(`^(?:I?MUL|I?DIV)[BWLQ]$`)
+	maxInt := int(^uint(0) >> 1)
+	for _, entry := range catalog.Optab {
+		if !numeric.MatchString(entry.Opcode) || entry.Ytab != "ydivb" && entry.Ytab != "ydivl" && entry.Ytab != "yimul" {
+			continue
+		}
+		for _, mutation := range []string{"original-arity", "selected-arity", "original-index", "selected-index",
+			"original-offset", "selected-offset", "original-stride", "selected-stride", "zcase", "row-count",
+			"prefix", "width-and-prefix", "non-numerical-family", "payload-short", "payload-extra", "nonbyte", "extension"} {
+			if mutation == "non-numerical-family" && entry.Ytab == "yimul" {
+				continue // The old general ytab formatter has no family-name contract.
+			}
+			t.Run(entry.Opcode+"/"+mutation, func(t *testing.T) {
+				changed, row := entry, entry.Rows[0]
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				changed.OpBytes = append([]string(nil), entry.OpBytes...)
+				switch mutation {
+				case "original-arity":
+					changed.Rows[0].Classes = append(append([]string(nil), row.Classes...), "")
+				case "selected-arity":
+					row.Classes = append(append([]string(nil), row.Classes...), "")
+				case "original-index":
+					changed.Rows[0].RowIndex++
+				case "selected-index":
+					row.RowIndex = -1
+				case "original-offset":
+					changed.Rows[0].UnmatchedOffset = -1
+				case "selected-offset":
+					row.UnmatchedOffset = maxInt
+				case "original-stride":
+					changed.Rows[0].ZOffset = maxInt
+				case "selected-stride":
+					row.ZOffset = -1
+				case "zcase":
+					changed.Rows[0].ZCase, row.ZCase = "Zo_m", "Zo_m"
+				case "row-count":
+					changed.Rows = append(changed.Rows, row)
+				case "prefix":
+					changed.Prefix = "P32"
+				case "width-and-prefix":
+					width, prefix := "B", "Pb"
+					if strings.HasSuffix(entry.Opcode, "B") {
+						width, prefix = "W", "Pe"
+					}
+					changed.Opcode, changed.Prefix = entry.Opcode[:len(entry.Opcode)-1]+width, prefix
+				case "non-numerical-family":
+					changed.Opcode = "NOP" + entry.Opcode[len(entry.Opcode)-1:]
+				case "payload-short":
+					changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+				case "payload-extra":
+					changed.OpBytes = append(changed.OpBytes, "0")
+				case "nonbyte":
+					changed.OpBytes[0] = "0x100"
+				case "extension":
+					changed.OpBytes[1] = "8"
+				}
+				if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+					t.Fatal("SCALAR_IMPLICIT_MULDIV_MALFORMED_ACCEPTED", mutation)
+				}
+			})
+		}
+		for _, escape := range []int{-4, -3, -1, 1, 2, maxInt - 1, maxInt} {
+			t.Run(fmt.Sprintf("%s/escape%d", entry.Opcode, escape), func(t *testing.T) {
+				changed := entry
+				changed.EscapeAdjustment = escape
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				offset := 0
+				for index := range changed.Rows {
+					changed.Rows[index].UnmatchedOffset = offset
+					offset += changed.Rows[index].ZOffset + escape
+				}
+				defer func() {
+					if failure := recover(); failure != nil {
+						t.Error("SCALAR_IMPLICIT_MULDIV_METADATA_PANIC", escape, failure)
+					}
+				}()
+				if _, err := x86ScalarRMWRowWitnesses(changed, changed.Rows[0], "amd64"); err == nil {
+					t.Fatal("SCALAR_IMPLICIT_MULDIV_MALFORMED_ACCEPTED", escape)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarCompleteOriginalSchemaBeforeSelectedPayload(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var entry X86LegacyOpcode
+	for _, candidate := range catalog.Optab {
+		if candidate.Opcode == "ADDL" {
+			entry = candidate
+		}
+	}
+	if len(entry.Rows) != 5 || entry.Ytab != "yaddl" {
+		t.Fatal("independent original multi-row scalar fixture changed")
+	}
+	if witnesses, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[1], "amd64"); err != nil || len(witnesses) != 1 {
+		t.Fatal("original complete source positive was not accepted", err)
+	}
+	maxInt := int(^uint(0) >> 1)
+	minInt := -maxInt - 1
+	check := func(t *testing.T, changed X86LegacyOpcode, selected X86LegacyOperand) {
+		t.Helper()
+		defer func() {
+			if failure := recover(); failure != nil {
+				t.Error("SCALAR_SHARED_SCHEMA_PANIC", failure)
+			}
+		}()
+		if _, err := x86ScalarRMWRowWitnesses(changed, selected, "amd64"); err == nil {
+			t.Fatal("SCALAR_SHARED_SCHEMA_INVALID_ACCEPTED")
+		}
+	}
+	for index := range entry.Rows {
+		for _, field := range []string{"index", "zcase", "stride", "offset", "arity"} {
+			t.Run(fmt.Sprintf("original%d/%s", index, field), func(t *testing.T) {
+				changed := entry
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				original := &changed.Rows[index]
+				switch field {
+				case "index":
+					original.RowIndex++
+				case "zcase":
+					original.ZCase = "Zunknown"
+				case "stride":
+					original.ZOffset = 0
+				case "offset":
+					original.UnmatchedOffset = -1
+				case "arity":
+					original.Classes = []string{strings.Join(original.Classes, ",")}
+				}
+				check(t, changed, entry.Rows[1])
+			})
+		}
+	}
+	for _, field := range []string{"arity", "index", "zcase", "stride", "offset"} {
+		t.Run("selected/"+field, func(t *testing.T) {
+			selected := entry.Rows[1]
+			switch field {
+			case "arity":
+				selected.Classes = []string{strings.Join(selected.Classes, ",")}
+			case "index":
+				selected.RowIndex = -1
+			case "zcase":
+				selected.ZCase = "Zunknown"
+			case "stride":
+				selected.ZOffset = -1
+			case "offset":
+				selected.UnmatchedOffset = minInt
+			}
+			check(t, entry, selected)
+		})
+	}
+	for _, value := range []int{0, minInt, maxInt} {
+		t.Run(fmt.Sprintf("consistent-previous-stride%d", value), func(t *testing.T) {
+			changed := entry
+			changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+			changed.Rows[0].ZOffset = value
+			selected := entry.Rows[1]
+			selected.UnmatchedOffset = value
+			if value == maxInt {
+				selected = entry.Rows[2]
+				selected.UnmatchedOffset = value + entry.Rows[1].ZOffset
+			}
+			// Keep the final original payload boundary untouched. The old
+			// selected-offset check alone accepts zero or wrapped offsets.
+			check(t, changed, selected)
+		})
+	}
+}
+
+// This exercises the existing scalar transport before adding a new view. A
+// source-format refusal is a missing projection, not a numerical defect.
+func TestX86ScalarMultiplyMOVBECompleteSourceTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		for _, row := range entry.Rows {
+			count++
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				witnesses, err := x86ScalarRMWRowWitnesses(entry, row, "amd64")
+				if err != nil || len(witnesses) == 0 {
+					t.Fatal("SCALAR_MULTIPLY_MOVBE_SOURCE_FEATURE_GAP", err)
+				}
+			})
+		}
+	}
+	if count != 24 {
+		t.Fatal("complete original three-table denominator changed", count)
+	}
+}
+
+func TestX86ScalarMultiplyMOVBECompleteRowsAndModes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := X86ScalarMultiplyMOVBERows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, filtered, witnesses := map[string]bool{}, 0, 0
+		for _, row := range rows {
+			if row.ID == "" || seen[row.ID] {
+				t.Fatal("duplicate or missing original row identity", row.ID)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("refused source mode acquired a witness")
+				}
+			}
+			witnesses += len(row.Witnesses)
+		}
+		if len(rows) != 24 || filtered != map[string]int{"amd64": 0, "386": 8}[arch] ||
+			witnesses != map[string]int{"amd64": 36, "386": 24}[arch] {
+			t.Fatal("complete scalar multiply/MOVBE source-mode closure changed", arch, len(rows), filtered, witnesses)
+		}
+	}
+	for _, arch := range []string{"", "arm64", "wasm"} {
+		if _, err := X86ScalarMultiplyMOVBERows(catalog, arch); err == nil {
+			t.Fatal("foreign source mode acquired scalar transport", arch)
+		}
+	}
+	if _, err := X86ScalarMultiplyMOVBERows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("empty source inventory silently passed")
+	}
+	for index, entry := range catalog.Optab {
+		if entry.Ytab != "yimul3" {
+			continue
+		}
+		changed := catalog
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab[:index]...), catalog.Optab[index+1:]...)
+		if _, err := X86ScalarMultiplyMOVBERows(changed, "amd64"); err == nil {
+			t.Fatal("missing complete source member admitted")
+		}
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab...), entry)
+		if _, err := X86ScalarMultiplyMOVBERows(changed, "amd64"); err == nil {
+			t.Fatal("duplicate complete source member admitted")
+		}
+		break
+	}
+}
+
+func TestX86ScalarMultiplyMOVBERejectsMalformedSource(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		for _, row := range entry.Rows {
+			mutations := []string{"original-arity", "selected-arity", "original-index", "selected-index",
+				"original-zcase", "selected-zcase", "original-offset", "selected-offset",
+				"original-stride", "selected-stride", "row-count", "prefix", "escape", "payload-short"}
+			if entry.Ytab == "yimul3" {
+				mutations = append(mutations, "original-immediate-role", "selected-immediate-role")
+			}
+			for _, mutation := range mutations {
+				t.Run(fmt.Sprintf("%s/%d/%s", entry.Opcode, row.RowIndex, mutation), func(t *testing.T) {
+					changed, selected := entry, row
+					changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					original := &changed.Rows[row.RowIndex]
+					switch mutation {
+					case "original-arity":
+						original.Classes = []string{strings.Join(original.Classes, ",")}
+						if len(row.Classes) == 1 {
+							original.Classes = append(original.Classes, "")
+						}
+					case "selected-arity":
+						selected.Classes = []string{strings.Join(selected.Classes, ",")}
+						if len(row.Classes) == 1 {
+							selected.Classes = append(selected.Classes, "")
+						}
+					case "original-index":
+						original.RowIndex++
+					case "selected-index":
+						selected.RowIndex = -1
+					case "original-zcase":
+						original.ZCase = "Zibr_m"
+					case "selected-zcase":
+						selected.ZCase = "Zibr_m"
+					case "original-offset":
+						original.UnmatchedOffset++
+					case "selected-offset":
+						selected.UnmatchedOffset++
+					case "original-stride":
+						original.ZOffset++
+					case "selected-stride":
+						selected.ZOffset++
+					case "row-count":
+						changed.Rows = append(changed.Rows, row)
+					case "prefix":
+						changed.Prefix = "P32"
+					case "escape":
+						changed.EscapeAdjustment++
+					case "payload-short":
+						changed.OpBytes = changed.OpBytes[:len(changed.OpBytes)-1]
+					case "original-immediate-role":
+						original.Classes = append([]string(nil), original.Classes...)
+						original.Classes[0] = "Yu8"
+					case "selected-immediate-role":
+						selected.Classes = append([]string(nil), selected.Classes...)
+						selected.Classes[0] = "Yu8"
+					}
+					// No malformed metadata may panic before returning a refusal.
+					if _, err := x86ScalarRMWRowWitnesses(changed, selected, "amd64"); err == nil {
+						t.Fatal("SCALAR_MULTIPLY_MOVBE_MALFORMED_ACCEPTED", mutation)
+					}
+				})
+			}
+			for atom := range entry.OpBytes {
+				values := []string{"0x100", "not-a-byte"}
+				if entry.Ytab == "yimul" {
+					if atom == 1 {
+						values = append(values, "8")
+					} else if atom == 4 {
+						values = append(values, "0x0f", "Pe")
+					} else {
+						values = append(values, "0")
+					}
+				} else if entry.OpBytes[atom] == "0" || entry.OpBytes[atom] == "00" {
+					values = append(values, "1")
+				} else {
+					values = append(values, "0")
+				}
+				for _, value := range values {
+					t.Run(fmt.Sprintf("%s/%d/atom%d/%s", entry.Opcode, row.RowIndex, atom, value), func(t *testing.T) {
+						changed := entry
+						changed.OpBytes = append([]string(nil), entry.OpBytes...)
+						changed.OpBytes[atom] = value
+						if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+							t.Fatal("SCALAR_MULTIPLY_MOVBE_MALFORMED_ACCEPTED", atom, value)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarMultiplyMOVBEEscapeBoundsBeforePayload(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	maxInt := int(^uint(0) >> 1)
+	entries := 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		entries++
+		for _, escape := range []int{-4, -3, -1, 2, maxInt - 1, maxInt} {
+			t.Run(fmt.Sprintf("%s/escape%d", entry.Opcode, escape), func(t *testing.T) {
+				changed := entry
+				changed.EscapeAdjustment = escape
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				offset := 0
+				for index := range changed.Rows {
+					changed.Rows[index].UnmatchedOffset = offset
+					offset += changed.Rows[index].ZOffset + escape
+				}
+				// Offsets intentionally remain consistent with the malformed
+				// adjustment. An earlier unrelated row mismatch must not hide
+				// a negative slice length or overflowing span calculation.
+				defer func() {
+					if failure := recover(); failure != nil {
+						t.Error("SCALAR_MULTIPLY_MOVBE_ESCAPE_PANIC", escape, failure)
+					}
+				}()
+				if _, err := x86ScalarRMWRowWitnesses(changed, changed.Rows[0], "amd64"); err == nil {
+					t.Fatal("SCALAR_MULTIPLY_MOVBE_MALFORMED_ACCEPTED", escape)
+				}
+			})
+		}
+	}
+	if entries != 9 {
+		t.Fatal("escape bounds control lost complete source entries", entries)
+	}
+}
+
+func TestX86ScalarMultiplyMOVBERejectsByteWidthTableMutation(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		for _, row := range entry.Rows {
+			count++
+			t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+				changed := entry
+				changed.Opcode = entry.Opcode[:len(entry.Opcode)-1] + "B"
+				changed.Prefix = "Pb"
+				// Keep all original rows and bytes coherent. IMULB belongs to
+				// the independent ydivb table, not the W/L/Q carrier grammar.
+				if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+					t.Fatal("SCALAR_MULTIPLY_MOVBE_BYTE_WIDTH_ACCEPTED", entry.Ytab)
+				}
+			})
+		}
+	}
+	if count != 24 {
+		t.Fatal("width mutation lost complete original source rows", count)
+	}
+}
+
+func TestX86ScalarRMWCompleteOrderedRowsAndModes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mode := range []struct {
+		arch                string
+		filtered, witnesses int
+	}{{"amd64", 2, 278}, {"386", 45, 202}} {
+		rows, err := X86ScalarRMWRows(catalog, mode.arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		names, ids := map[string]bool{}, map[string]bool{}
+		filtered, witnesses := 0, 0
+		for _, row := range rows {
+			if row.ID == "" || ids[row.ID] || row.ModeFiltered == "" && len(row.Witnesses) == 0 {
+				t.Fatal("lost source identity or selected syntax", row)
+			}
+			ids[row.ID], names[row.Opcode] = true, true
+			if row.ModeFiltered != "" {
+				filtered++
+				if len(row.Witnesses) != 0 {
+					t.Fatal("mode-filtered row acquired a selected witness", row)
+				}
+			}
+			for _, witness := range row.Witnesses {
+				if !strings.HasPrefix(witness.Instruction, row.Opcode+" ") || len(witness.Encoding) == 0 || witness.Destination == "" {
+					t.Fatal("incomplete selected scalar witness", row)
+				}
+				witnesses++
+			}
+		}
+		if len(rows) != 169 || len(names) != 53 || filtered != mode.filtered || witnesses != mode.witnesses {
+			t.Fatal("source/mode/selected grammar denominator changed", mode, len(rows), len(names), filtered, witnesses)
+		}
+	}
+	if _, err := X86ScalarRMWRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign mode entered x86 scalar projection")
+	}
+	if _, err := X86ScalarRMWRows(X86LegacyCatalog{}, "amd64"); err == nil {
+		t.Fatal("missing source closure was treated as successful empty coverage")
+	}
+	for index, entry := range catalog.Optab {
+		if entry.Opcode != "ADCB" {
+			continue
+		}
+		changed := catalog
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab[:index]...), catalog.Optab[index+1:]...)
+		if _, err := X86ScalarRMWRows(changed, "amd64"); err == nil {
+			t.Fatal("missing family member admitted")
+		}
+		changed.Optab = append(append([]X86LegacyOpcode(nil), catalog.Optab...), entry)
+		if _, err := X86ScalarRMWRows(changed, "amd64"); err == nil {
+			t.Fatal("duplicate source member admitted")
+		}
+		break
+	}
+}
+
+func TestX86ScalarRMWSelectedPayloadAnchors(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	anchors := []struct {
+		mode, instruction string
+		code              []byte
+	}{
+		{"amd64", "ADDB $128,AL", []byte{0x04, 0x80}},
+		{"amd64", "ADDW $128,AX", []byte{0x66, 0x05, 0x80, 0}},
+		{"amd64", "ADDL $1,BX", []byte{0x83, 0xc3, 1}},
+		{"amd64", "ADDQ $128,BX", []byte{0x48, 0x81, 0xc3, 0x80, 0, 0, 0}},
+		{"amd64", "SUBL CX,0(SI)", []byte{0x29, 0x0e}},
+		{"amd64", "SUBL 0(SI),BX", []byte{0x2b, 0x1e}},
+		{"amd64", "BTSQ $1,BX", []byte{0x48, 0x0f, 0xba, 0xeb, 1}},
+		{"amd64", "BTCW CX,0(SI)", []byte{0x66, 0x0f, 0xbb, 0x0e}},
+		{"amd64", "INCL BX", []byte{0xff, 0xc3}},
+		{"386", "INCL BX", []byte{0x43}},
+		{"386", "DECL 0(SI)", []byte{0xff, 0x0e}},
+		{"amd64", "NOTB BL", []byte{0xf6, 0xd3}},
+	}
+	for _, anchor := range anchors {
+		t.Run(anchor.mode+"/"+anchor.instruction, func(t *testing.T) {
+			rows, err := X86ScalarRMWRows(catalog, anchor.mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			matches := 0
+			for _, row := range rows {
+				for _, witness := range row.Witnesses {
+					if witness.Instruction == anchor.instruction {
+						matches++
+						if !bytes.Equal(witness.Encoding, anchor.code) {
+							t.Fatalf("payload %x want=%x", witness.Encoding, anchor.code)
+						}
+					}
+				}
+			}
+			if matches != 1 {
+				t.Fatal("selected source must have one row owner", matches)
+			}
+		})
+	}
+}
+
+func TestX86ScalarRMWRejectsChangedPhysicalAxes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range catalog.Optab {
+		if entry.Opcode != "ADDQ" {
+			continue
+		}
+		for _, mutation := range []struct {
+			name   string
+			change func(*X86LegacyOpcode, *X86LegacyOperand)
+		}{
+			{"class", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.Classes = []string{"Yu8", "Yml"} }},
+			{"zcase", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZCase = "Zm_r" }},
+			{"stride", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.ZOffset++ }},
+			{"offset", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.UnmatchedOffset++ }},
+			{"index", func(_ *X86LegacyOpcode, r *X86LegacyOperand) { r.RowIndex = 1 }},
+			{"prefix", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.Prefix = "Pe" }},
+			{"escape", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.EscapeAdjustment = 1 }},
+			{"truncated", func(e *X86LegacyOpcode, _ *X86LegacyOperand) { e.OpBytes = e.OpBytes[:1] }},
+			{"extra", func(e *X86LegacyOpcode, _ *X86LegacyOperand) {
+				e.OpBytes = append(append([]string(nil), e.OpBytes...), "0")
+			}},
+			{"symbol", func(e *X86LegacyOpcode, _ *X86LegacyOperand) {
+				e.OpBytes = append([]string(nil), e.OpBytes...)
+				e.OpBytes[0] = "opcode"
+			}},
+			{"extension", func(e *X86LegacyOpcode, _ *X86LegacyOperand) {
+				e.OpBytes = append([]string(nil), e.OpBytes...)
+				e.OpBytes[1] = "8"
+			}},
+		} {
+			t.Run(mutation.name, func(t *testing.T) {
+				row := entry.Rows[0]
+				if witnesses, err := x86ScalarRMWRowWitnesses(entry, row, "amd64"); err != nil || len(witnesses) != 2 {
+					t.Fatal("valid original failed before negative", err)
+				}
+				changed := entry
+				mutation.change(&changed, &row)
+				if _, err := x86ScalarRMWRowWitnesses(changed, row, "amd64"); err == nil {
+					t.Fatal("changed physical axis admitted", fmt.Sprint(changed, row))
+				}
+			})
+		}
+		return
+	}
+	t.Fatal("actual Go omitted ADDQ")
+}
diff --git a/internal/goasmrules/x86_witness_scalar_shift.go b/internal/goasmrules/x86_witness_scalar_shift.go
new file mode 100644
index 000000000..85941fcd6
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_shift.go
@@ -0,0 +1,186 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86ScalarShiftRotateRows retains Group2 and the separate double-shift
+// fallback. Equal SAL/SHL bytes do not merge their original source records.
+func X86ScalarShiftRotateRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("scalar shifts require a Go x86 mode")
+	}
+	var rows []X86ScalarRMWRow
+	names := map[string]bool{}
+	add := func(id, opcode string, witnesses []X86ScalarRMWWitness) {
+		row := X86ScalarRMWRow{ID: id, Opcode: opcode, Witnesses: witnesses}
+		if arch == "386" && strings.HasSuffix(opcode, "Q") {
+			row.Witnesses, row.ModeFiltered = nil, "legacy Q requires amd64"
+		}
+		rows = append(rows, row)
+	}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yshb" && entry.Ytab != "yshl" {
+			continue
+		}
+		names[entry.Opcode] = true
+		for _, row := range entry.Rows {
+			witnesses, err := x86ScalarGroup2Witnesses(entry, row)
+			if err != nil {
+				return nil, err
+			}
+			add(fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex), entry.Opcode, witnesses)
+		}
+	}
+	for _, row := range catalog.Movtab {
+		if row.Code != "movDoubleShift" {
+			continue
+		}
+		witnesses, err := x86ScalarDoubleShiftWitnesses(row)
+		if err != nil || !names[row.Opcode] {
+			return nil, fmt.Errorf("double-shift source roles: %v", err)
+		}
+		add(fmt.Sprintf("ymovtab/%d/%s/movDoubleShift", row.TableIndex, row.Opcode), row.Opcode, witnesses)
+	}
+	if len(names) != 32 || len(rows) != 138 {
+		return nil, fmt.Errorf("incomplete scalar shift closure: names=%d records=%d", len(names), len(rows))
+	}
+	return rows, nil
+}
+
+func x86ScalarGroup2Witnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86ScalarRMWWitness, error) {
+	fail := func() ([]X86ScalarRMWWitness, error) {
+		return nil, fmt.Errorf("unmodeled complete Group2 schema/payload")
+	}
+	if entry.Kind != "encoding" || len(entry.Opcode) < 2 || entry.EscapeAdjustment != 0 {
+		return fail()
+	}
+	width := entry.Opcode[len(entry.Opcode)-1]
+	byteOperand := width == 'B'
+	expectedPrefix := map[byte]string{'B': "Pb", 'W': "Pe", 'L': "Px", 'Q': "Pw"}[width]
+	schema := []string{"Zo_m/2/Yi1,Yml", "Zibo_m/2/Yu8,Yml", "Zo_m/2/Ycl,Yml", "Zo_m/2/Ycx,Yml"}
+	if byteOperand {
+		schema = []string{"Zo_m/2/Yi1,Ymb", "Zibo_m/2/Yu8,Ymb", "Zo_m/2/Ycx,Ymb"}
+	}
+	if entry.Ytab != map[bool]string{true: "yshb", false: "yshl"}[byteOperand] ||
+		expectedPrefix == "" || entry.Prefix != expectedPrefix ||
+		len(entry.Rows) != len(schema) || len(entry.OpBytes) != len(schema)*2 || row.RowIndex < 0 || row.RowIndex >= len(schema) {
+		return fail()
+	}
+	var payload []byte
+	for _, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return fail()
+		}
+		payload = append(payload, byte(value))
+	}
+	for index, original := range entry.Rows {
+		if original.RowIndex != index || original.UnmatchedOffset != index*2 ||
+			fmt.Sprintf("%s/%d/%s", original.ZCase, original.ZOffset, strings.Join(original.Classes, ",")) != schema[index] ||
+			payload[index*2+1] > 7 || payload[index*2+1] != payload[1] {
+			return fail()
+		}
+	}
+	if row.UnmatchedOffset != row.RowIndex*2 || fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schema[row.RowIndex] {
+		return fail()
+	}
+	counts := map[string][]string{"Yi1": {"$1"}, "Yu8": {"$0", "$7"}, "Ycl": {"CL"}, "Ycx": {"CX"}}[row.Classes[0]]
+	if byteOperand && row.Classes[0] == "Ycx" {
+		counts = append(counts, "CL") // Both spellings select this byte row.
+	}
+	var prefix []byte
+	if width == 'W' {
+		prefix = []byte{0x66}
+	} else if width == 'Q' {
+		prefix = []byte{0x48}
+	}
+	return x86ScalarShiftWitnesses(entry.Opcode, prefix, payload[row.UnmatchedOffset], payload[row.UnmatchedOffset+1], counts, byteOperand, false), nil
+}
+
+func x86ScalarDoubleShiftWitnesses(row X86MoveRule) ([]X86ScalarRMWWitness, error) {
+	fail := func() ([]X86ScalarRMWWitness, error) {
+		return nil, fmt.Errorf("unmodeled complete movDoubleShift schema/payload")
+	}
+	if row.Kind != "encoding" || row.Code != "movDoubleShift" || len(row.Opcode) < 2 || row.From3 != "Yrl" || row.To != "Yml" || len(row.OpBytes) != 4 {
+		return fail()
+	}
+	width := row.Opcode[len(row.Opcode)-1]
+	stem := row.Opcode[:len(row.Opcode)-1]
+	if stem != "SHL" && stem != "SHR" {
+		return fail()
+	}
+	offset, prefix := 0, []byte{0x0f}
+	if width == 'W' || width == 'Q' {
+		atom, value := "Pe", byte(0x66)
+		if width == 'Q' {
+			atom, value = "Pw", 0x48
+		}
+		if row.OpBytes[0] != atom {
+			return fail()
+		}
+		offset, prefix = 1, []byte{value, 0x0f}
+	} else if width != 'L' {
+		return fail()
+	}
+	var opcodes []byte
+	for _, atom := range row.OpBytes[offset:] {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return fail()
+		}
+		opcodes = append(opcodes, byte(value))
+	}
+	for _, padding := range opcodes[2:] {
+		if padding != 0 {
+			return fail()
+		}
+	}
+	counts := map[string][]string{"Yi8": {"$1"}, "Ycl": {"CL"}, "Ycx": {"CX"}}[row.From]
+	if len(counts) == 0 {
+		return fail()
+	}
+	opcode := opcodes[0]
+	if row.From != "Yi8" {
+		opcode = opcodes[1]
+	}
+	return x86ScalarShiftWitnesses(row.Opcode, prefix, opcode, 0, counts, false, true), nil
+}
+
+// Source opcodes and /digit values remain literal Go payload, not another
+// per-mnemonic table. Count kind, data width and ModRM roles stay independent.
+func x86ScalarShiftWitnesses(opcode string, prefix []byte, op, extension byte, counts []string, byteOperand, double bool) []X86ScalarRMWWitness {
+	destination := "BX"
+	if byteOperand {
+		destination = "BL"
+	}
+	var witnesses []X86ScalarRMWWitness
+	for _, last := range []string{destination, "0(SI)"} {
+		for _, count := range counts {
+			operands, modrm := count+","+last, byte(0xc3)
+			if last == "0(SI)" {
+				modrm = 6
+			}
+			if double {
+				operands = count + ",AX," + last
+			} else {
+				modrm |= extension << 3
+			}
+			encoded := x86SourceModRMBytes(prefix, op, modrm)
+			if strings.HasPrefix(count, "$") && (double || count != "$1") {
+				value, _ := strconv.Atoi(count[1:])
+				encoded = append(encoded, byte(value))
+			}
+			witnesses = append(witnesses, X86ScalarRMWWitness{Instruction: opcode + " " + operands, Destination: last, Encoding: encoded})
+		}
+	}
+	return witnesses
+}
+
+// Source-only ModRM emission. Grammar, register-bank and memory roles must
+// be validated before callers supply the complete prefix/opcode and field.
+func x86SourceModRMBytes(prefix []byte, opcode, modrm byte) []byte {
+	return append(append([]byte(nil), prefix...), opcode, modrm)
+}
diff --git a/internal/goasmrules/x86_witness_scalar_shift_test.go b/internal/goasmrules/x86_witness_scalar_shift_test.go
new file mode 100644
index 000000000..7d8b37a62
--- /dev/null
+++ b/internal/goasmrules/x86_witness_scalar_shift_test.go
@@ -0,0 +1,167 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftCompleteOriginalRecords(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := map[string]string{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yshb" && entry.Ytab != "yshl" {
+			continue
+		}
+		for _, row := range entry.Rows {
+			originals[fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)] = entry.Opcode
+		}
+	}
+	for _, row := range catalog.Movtab {
+		if row.Code == "movDoubleShift" {
+			originals[fmt.Sprintf("ymovtab/%d/%s/movDoubleShift", row.TableIndex, row.Opcode)] = row.Opcode
+		}
+	}
+	for _, mode := range []struct {
+		arch             string
+		filtered, shapes int
+	}{{"amd64", 0, 356}, {"386", 38, 264}} {
+		rows, err := X86ScalarShiftRotateRows(catalog, mode.arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, names, syntax := map[string]bool{}, map[string]bool{}, map[string]bool{}
+		filtered, shapes := 0, 0
+		for _, row := range rows {
+			if originals[row.ID] != row.Opcode || seen[row.ID] {
+				t.Fatal("lost original shift source record", row)
+			}
+			seen[row.ID], names[row.Opcode] = true, true
+			if row.ModeFiltered != "" {
+				if mode.arch != "386" || !strings.HasSuffix(row.Opcode, "Q") || len(row.Witnesses) != 0 {
+					t.Fatal("wrong mode filter", row)
+				}
+				filtered++
+				continue
+			}
+			for _, w := range row.Witnesses {
+				if syntax[w.Instruction] || !strings.HasPrefix(w.Instruction, row.Opcode+" ") || len(w.Encoding) < 2 {
+					t.Fatal("duplicate or lost selected syntax", row, w)
+				}
+				syntax[w.Instruction] = true
+				shapes++
+				args := strings.Split(strings.Fields(w.Instruction)[1], ",")
+				destination := "BX"
+				if strings.HasSuffix(row.Opcode, "B") {
+					destination = "BL"
+				}
+				if args[len(args)-1] != w.Destination || w.Destination != destination && w.Destination != "0(SI)" {
+					t.Fatal("data/count/destination roles changed", w)
+				}
+				if strings.HasPrefix(row.ID, "ymovtab/") && (len(args) != 3 || args[1] != "AX") || strings.HasPrefix(row.ID, "optab/") && len(args) != 2 {
+					t.Fatal("Group2 and double-shift roles conflated", row, w)
+				}
+			}
+		}
+		if len(rows) != 138 || len(originals) != 138 || len(seen) != 138 || len(names) != 32 || filtered != mode.filtered || shapes != mode.shapes {
+			t.Fatal("source/mode/projection changed", mode.arch, len(rows), len(seen), len(names), filtered, shapes)
+		}
+	}
+}
+
+func TestX86ScalarShiftRejectsForeignPhysicalAxes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var original X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		if entry.Ytab == "yshl" {
+			original = entry
+			break
+		}
+	}
+	if _, err := x86ScalarGroup2Witnesses(original, original.Rows[1]); err != nil {
+		t.Fatal("valid Group2 required", err)
+	}
+	if _, err := x86ScalarRMWRowWitnesses(original, original.Rows[1], "amd64"); err == nil {
+		t.Fatal("Group2 must not weaken the separate six-table GP grammar")
+	}
+	for _, mutation := range []string{"prefix", "signed count", "zoffset", "offset", "digit8", "digit mismatch", "payload", "row index", "destination", "empty opcode"} {
+		t.Run("Group2/"+mutation, func(t *testing.T) {
+			entry := original
+			entry.OpBytes = append([]string(nil), original.OpBytes...)
+			entry.Rows = append([]X86LegacyOperand(nil), original.Rows...)
+			for i := range entry.Rows {
+				entry.Rows[i].Classes = append([]string(nil), entry.Rows[i].Classes...)
+			}
+			row := entry.Rows[1]
+			switch mutation {
+			case "prefix":
+				entry.Prefix = "Pf3"
+			case "signed count":
+				entry.Rows[1].Classes[0] = "Yi8"
+				row = entry.Rows[1]
+			case "zoffset":
+				row.ZOffset++
+			case "offset":
+				row.UnmatchedOffset++
+			case "digit8":
+				entry.OpBytes[3] = "8"
+			case "digit mismatch":
+				entry.OpBytes[3] = "0"
+			case "payload":
+				entry.OpBytes = entry.OpBytes[:len(entry.OpBytes)-1]
+			case "row index":
+				row.RowIndex = 20
+			case "destination":
+				entry.Rows[1].Classes[1] = "Yxr"
+				row = entry.Rows[1]
+			case "empty opcode":
+				entry.Opcode = ""
+			}
+			if _, err := x86ScalarGroup2Witnesses(entry, row); err == nil {
+				t.Fatal("foreign Group2 format accepted", mutation)
+			}
+		})
+	}
+	var move X86MoveRule
+	for _, row := range catalog.Movtab {
+		if row.Code == "movDoubleShift" {
+			move = row
+			break
+		}
+	}
+	if _, err := x86ScalarDoubleShiftWitnesses(move); err != nil {
+		t.Fatal("valid double-shift required", err)
+	}
+	for _, mutation := range []string{"count", "data", "destination", "padding", "payload", "opcode", "code"} {
+		t.Run("double/"+mutation, func(t *testing.T) {
+			row := move
+			row.OpBytes = append([]string(nil), move.OpBytes...)
+			switch mutation {
+			case "count":
+				row.From = "Yu8"
+			case "data":
+				row.From3 = "Yxr"
+			case "destination":
+				row.To = "Ymb"
+			case "padding":
+				row.OpBytes[3] = "1"
+			case "payload":
+				row.OpBytes = row.OpBytes[:3]
+			case "opcode":
+				row.Opcode = "RCLL"
+			case "code":
+				row.Code = "movLit"
+			}
+			if _, err := x86ScalarDoubleShiftWitnesses(row); err == nil {
+				t.Fatal("foreign double-shift accepted", mutation)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_shift_test.go b/internal/goasmrules/x86_witness_shift_test.go
new file mode 100644
index 000000000..899714243
--- /dev/null
+++ b/internal/goasmrules/x86_witness_shift_test.go
@@ -0,0 +1,31 @@
+package goasmrules
+
+import "testing"
+
+var x86PerLaneShiftRowCounts = x86PackedRowCounts{
+	names: 9, broadcast: 54,
+	rows: [3]int{0, 10, 54}, formats: [3]int{0, 20, 216}, widths: [3]int{82, 82, 72},
+}
+
+func TestX86PackedPerLaneShiftRowsShareBinaryWitnesses(t *testing.T) {
+	x86CheckPackedRowInventory(t, X86PackedPerLaneShiftRows,
+		`^VPS(LL|RL|RA)V`, `[DQ]$`, x86PerLaneShiftRowCounts)
+}
+
+func TestX86PackedPerLaneShiftEncodingAxes(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedPerLaneShiftRows,
+		`^VPS(LL|RL|RA)V`, `[DQ]$`, x86PerLaneShiftRowCounts)
+	// Independent literal bytes span all nine names, X/Y/Z widths,
+	// W0/W1, masks, zeroing, complete memory and D/Q-only broadcast.
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"VPSLLVD X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x47, 0xd0}},
+		{"VPSLLVQ Y0,Y1,Y2", []byte{0xc4, 0xe2, 0xf5, 0x47, 0xd0}},
+		{"VPSLLVW X16,X17,X18", []byte{0x62, 0xa2, 0xf5, 0x00, 0x12, 0xd0}},
+		{"VPSRAVD X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x46, 0xd0}},
+		{"VPSRAVQ.BCST.Z (AX),Z17,K1,Z18", []byte{0x62, 0xe2, 0xf5, 0xd1, 0x46, 0x10}},
+		{"VPSRAVW.Z (AX),Y17,K1,Y18", []byte{0x62, 0xe2, 0xf5, 0xa1, 0x11, 0x10}},
+		{"VPSRLVD.BCST (AX),X17,X18", []byte{0x62, 0xe2, 0x75, 0x10, 0x45, 0x10}},
+		{"VPSRLVQ Y16,Y17,K1,Y18", []byte{0x62, 0xa2, 0xf5, 0x21, 0x45, 0xd0}},
+		{"VPSRLVW Z16,Z17,Z18", []byte{0x62, 0xa2, 0xf5, 0x40, 0x10, 0xd0}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_sign_test.go b/internal/goasmrules/x86_witness_sign_test.go
new file mode 100644
index 000000000..1923da769
--- /dev/null
+++ b/internal/goasmrules/x86_witness_sign_test.go
@@ -0,0 +1,21 @@
+package goasmrules
+
+import "testing"
+
+func TestX86PackedSignRowsShareBinaryWitnesses(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t, X86PackedSignRows,
+		`^V?PSIGN`, `^$`, x86PackedRowCounts{
+			names: 6,
+			rows:  [3]int{3, 6, 0}, formats: [3]int{6, 12, 0}, widths: [3]int{12, 6, 0},
+		})
+	// Every opcode has its own literal anchor; the row inventory above also
+	// requires both register and memory sources at every official width.
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PSIGNB X0,X1", []byte{0x66, 0x0f, 0x38, 0x08, 0xc8}},
+		{"PSIGNW (AX),X1", []byte{0x66, 0x0f, 0x38, 0x09, 0x08}},
+		{"PSIGND X0,X1", []byte{0x66, 0x0f, 0x38, 0x0a, 0xc8}},
+		{"VPSIGNB X0,X1,X2", []byte{0xc4, 0xe2, 0x71, 0x08, 0xd0}},
+		{"VPSIGNW Y0,Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x09, 0xd0}},
+		{"VPSIGND (AX),Y1,Y2", []byte{0xc4, 0xe2, 0x75, 0x0a, 0x10}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_single_source_narrowing_test.go b/internal/goasmrules/x86_witness_single_source_narrowing_test.go
new file mode 100644
index 000000000..915b885af
--- /dev/null
+++ b/internal/goasmrules/x86_witness_single_source_narrowing_test.go
@@ -0,0 +1,171 @@
+package goasmrules
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86SingleSourceNarrowingTestMembers = `VPMOVDB VPMOVDW VPMOVQB VPMOVQD VPMOVQW VPMOVWB
+	VPMOVSDB VPMOVSDW VPMOVSQB VPMOVSQD VPMOVSQW VPMOVSWB
+	VPMOVUSDB VPMOVUSDW VPMOVUSQB VPMOVUSQD VPMOVUSQW VPMOVUSWB`
+
+func TestX86SingleSourceNarrowingCompleteOfficialTransport(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Use an existing helper: RED must be a real format-admission failure,
+	// never compilation against a not-yet-implemented public selector.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86SingleSourceNarrowingTestMembers)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 108 {
+		t.Fatal("lost an official narrowing row", len(rows))
+	}
+	for _, group := range []struct {
+		prefix string
+		opcode int
+	}{{"VPMOV", 0x30}, {"VPMOVS", 0x20}, {"VPMOVUS", 0x10}} {
+		for _, pair := range []struct {
+			suffix                string
+			input, output, opcode int
+		}{{"WB", 2, 1, 0}, {"DB", 4, 1, 1}, {"QB", 8, 1, 2},
+			{"DW", 4, 2, 3}, {"QW", 8, 2, 4}, {"QD", 8, 4, 5}} {
+			name := group.prefix + pair.suffix
+			table := "_yvpmovdb"
+			if pair.input/pair.output == 2 {
+				table = "_yvpmovdw"
+			}
+			var payload []string
+			for _, width := range []int{128, 256, 512} {
+				payload = append(payload,
+					fmt.Sprintf("avxEscape | evex%d | evexF3 | evex0F38 | evexW0", width),
+					fmt.Sprintf("evexN%d | evexZeroingEnabled", width/8*pair.output/pair.input),
+					fmt.Sprintf("0x%02X", group.opcode+pair.opcode))
+			}
+			count := 0
+			for _, row := range avx {
+				if row.Opcode != name {
+					continue
+				}
+				if count >= 6 {
+					t.Fatal("extra official member row", name, row)
+				}
+				width := 16 << (count / 2)
+				source := []string{"YxrEvex", "YyrEvex", "Yzr"}[count/2]
+				destination := "YxmEvex"
+				if width*pair.output/pair.input > 16 {
+					destination = "YymEvex"
+				}
+				classes, zcase := []string{source, destination}, "Zevex_r_v_rm"
+				if count%2 != 0 {
+					classes, zcase = []string{source, "Yknot0", destination}, "Zevex_r_k_rm"
+				}
+				if row.RowIndex != count || row.Ytab != table || row.Prefix != "Pavx" ||
+					row.ZCase != zcase || row.ZOffset != count%2*3 || row.EncodingOffset != count/2*3 ||
+					!reflect.DeepEqual(row.Classes, classes) || !reflect.DeepEqual(row.OpBytes, payload) {
+					t.Fatal("source width, shrinking tuple or destination carrier changed", name, row)
+				}
+				count++
+			}
+			if count != 6 {
+				t.Fatal("member lost an original Go row", name, count)
+			}
+		}
+	}
+	widths, memory, masked, zeroing := map[int]int{}, 0, 0, 0
+	for _, row := range rows {
+		for _, w := range row.Witnesses {
+			args := strings.Split(strings.Fields(w.Instruction)[1], ",")
+			if w.Generation != "evex" || w.First != args[0] || !strings.HasSuffix(w.First, "16") ||
+				w.Second != "" || w.Memory || w.Broadcast || w.MaskResult ||
+				w.Destination != args[len(args)-1] {
+				t.Fatal("store direction was confused with source-memory or register zeroing", row.ID, w)
+			}
+			if w.Destination == "(AX)" {
+				memory++
+			} else if !strings.HasSuffix(w.Destination, "18") {
+				t.Fatal("physical destination bank does not force EVEX", row.ID, w)
+			}
+			if w.Masked {
+				masked++
+			}
+			if w.Zeroing {
+				zeroing++
+			}
+			widths[w.Width]++
+		}
+	}
+	if !reflect.DeepEqual(widths, map[int]int{128: 108, 256: 108, 512: 108}) || memory != 162 || masked != 216 || zeroing != 108 {
+		t.Fatal("complete Go projection changed; 54 memory.Z forms require terminal traps, leaving 270 ordinary forms",
+			widths, memory, masked, zeroing)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"VPMOVDB X16,X18", []byte{0x62, 0xa2, 0x7e, 0x08, 0x31, 0xc2}},
+		{"VPMOVUSQB Y16,X18", []byte{0x62, 0xa2, 0x7e, 0x28, 0x12, 0xc2}},
+		{"VPMOVSQD.Z Z16,K1,Y18", []byte{0x62, 0xa2, 0x7e, 0xc9, 0x25, 0xc2}},
+		{"VPMOVWB X16,(AX)", []byte{0x62, 0xe2, 0x7e, 0x08, 0x30, 0x00}},
+		{"VPMOVUSQW Z16,K1,(AX)", []byte{0x62, 0xe2, 0x7e, 0x49, 0x14, 0x00}},
+	})
+}
+
+func TestX86SingleSourceNarrowingTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"source carrier", "result carrier", "full tuple", "BCST", "SAE", "rounding", "W1", "66", "0F", "load direction", "zero mask", "row stride"} {
+		t.Run(mutation, func(t *testing.T) {
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != "VPMOVUSQB" || original.RowIndex != 5 {
+					continue
+				}
+				found++
+				row := original
+				row.Classes, row.OpBytes = append([]string(nil), row.Classes...), append([]string(nil), row.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "source carrier":
+					row.Classes[0] = "YxrEvex"
+				case "result carrier":
+					row.Classes[2] = "YymEvex"
+				case "full tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN8", "evexN64", 1)
+				case "BCST":
+					row.OpBytes[feature] += " | evexBcstN8"
+				case "SAE":
+					row.OpBytes[feature] += " | evexSaeEnabled"
+				case "rounding":
+					row.OpBytes[feature] += " | evexRoundingEnabled"
+				case "W1":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW0", "evexW1", 1)
+				case "66":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexF3", "evex66", 1)
+				case "0F":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F38", "evex0F", 1)
+				case "load direction":
+					row.ZCase = "Zevex_rm_k_r"
+				case "zero mask":
+					row.Classes[1] = "Yk"
+				case "row stride":
+					row.ZOffset = 1
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("foreign narrowing transport was admitted", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("independent mutation row is absent", found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_source_members.go b/internal/goasmrules/x86_witness_source_members.go
new file mode 100644
index 000000000..1692e39e8
--- /dev/null
+++ b/internal/goasmrules/x86_witness_source_members.go
@@ -0,0 +1,18 @@
+package goasmrules
+
+import "encoding/json"
+
+// Own a complete ordered source cohort, including every original field and
+// fixed-array capacity. This is captured Go metadata, not an opcode registry.
+func x86LegacySourceMembers(catalog X86LegacyCatalog, schema func(string) []string) ([]byte, error) {
+	var members []X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		if schema(entry.Ytab) != nil {
+			members = append(members, entry)
+		}
+	}
+	return json.Marshal(struct {
+		Capacity int
+		Members  []X86LegacyOpcode
+	}{catalog.OpBytesSize, members})
+}
diff --git a/internal/goasmrules/x86_witness_special_vector_state.go b/internal/goasmrules/x86_witness_special_vector_state.go
new file mode 100644
index 000000000..83a97b7be
--- /dev/null
+++ b/internal/goasmrules/x86_witness_special_vector_state.go
@@ -0,0 +1,367 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// The closed source namespace is an inventory, not an opcode-value table.
+const x86SpecialVectorStateNames = " V4FMADDPS V4FMADDSS V4FNMADDPS V4FNMADDSS VADDSUBPD VADDSUBPS VAESDEC " +
+	"VAESDECLAST VAESENC VAESENCLAST VAESIMC VAESKEYGENASSIST VBLENDPD VBLENDPS " +
+	"VBLENDVPD VBLENDVPS VCMPPD VCMPPS VCMPSD VCMPSS VCOMISD " +
+	"VCOMISS VDPPD VDPPS VEXP2PD VEXP2PS VFPCLASSPDX VFPCLASSPDY " +
+	"VFPCLASSPDZ VFPCLASSPSX VFPCLASSPSY VFPCLASSPSZ VFPCLASSSD VFPCLASSSS VGETEXPPD " +
+	"VGETEXPPS VGETEXPSD VGETEXPSS VHADDPD VHADDPS VHSUBPD VHSUBPS " +
+	"VLDMXCSR VMPSADBW VP4DPWSSD VP4DPWSSDS VPBLENDD VPBLENDVB VPBLENDW " +
+	"VPCLMULQDQ VPCMPESTRI VPCMPESTRM VPCMPISTRI VPCMPISTRM VPHMINPOSUW VPSADBW " +
+	"VPSHUFBITQMB VPTEST VRCP28PD VRCP28PS VRCP28SD VRCP28SS VRCPPS " +
+	"VRCPSS VROUNDPD VROUNDPS VROUNDSD VROUNDSS VRSQRT28PD VRSQRT28PS " +
+	"VRSQRT28SD VRSQRT28SS VRSQRTPS VRSQRTSS VSCALEFPD VSCALEFPS VSCALEFSD " +
+	"VSCALEFSS VSQRTPD VSQRTPS VSQRTSD VSQRTSS VSTMXCSR VTESTPD " +
+	"VTESTPS VUCOMISD VUCOMISS VZEROALL VZEROUPPER "
+
+func x86SpecialVectorStateName(opcode string) bool {
+	return strings.Contains(x86SpecialVectorStateNames, " "+opcode+" ")
+}
+
+// Preserve the existing twenty-two successful row paths. No failure fallback
+// is used: the remaining rows enter the new grammar before old dispatch.
+func x86SpecialVectorStateRoute(rule X86AVXRule) bool {
+	if !x86SpecialVectorStateName(rule.Opcode) {
+		return false
+	}
+	if rule.EncodingOffset < 0 || rule.EncodingOffset >= len(rule.OpBytes) {
+		return true
+	}
+	header := rule.OpBytes[rule.EncodingOffset]
+	if rule.Ytab == "_yvaddsd" || rule.Ytab == "_yvaddsubpd" && hasEncodingTerm(header, "vex66") ||
+		rule.Ytab == "_yvcvtdq2ps" && !hasEncodingTerm(header, "evexW1") {
+		return false
+	}
+	return true
+}
+
+type x86SpecialVectorRow struct {
+	physical                         x86VectorResultFormat
+	immediate, registerMask, quartet bool
+	selector                         int
+}
+
+// Decode only the immutable fixed prefix atoms, using the existing atom reader
+// and byte encoder. The source payload remains the sole opcode-value owner.
+func x86SpecialVectorHeader(rule X86AVXRule, offset int) (x86PackedAVXOpcode, map[string]bool, int, error) {
+	var op x86PackedAVXOpcode
+	if rule.Prefix != "Pavx" || offset < 0 || offset >= len(rule.OpBytes) {
+		return op, nil, 0, fmt.Errorf("fixed source prefix/payload boundary differs")
+	}
+	kind := "vex"
+	if hasEncodingTerm(rule.OpBytes[offset], "evex128") || hasEncodingTerm(rule.OpBytes[offset], "evex256") || hasEncodingTerm(rule.OpBytes[offset], "evex512") {
+		kind = "evex"
+	}
+	optional := []string{
+		kind + "128", kind + "256", kind + "512", kind + "66", kind + "F3", kind + "F2", kind + "0F", kind + "0F38", kind + "0F3A", kind + "W0", kind + "W1",
+	}
+	if kind == "vex" {
+		optional = append(optional, "vexWIG")
+	}
+	atoms, err := x86PackedEncodingAtoms(rule.OpBytes[offset], []string{"avxEscape"}, optional)
+	if err != nil {
+		return op, nil, 0, err
+	}
+	op.kind = kind
+	widths, maps, prefixes := 0, 0, 0
+	for index, word := range []string{"128", "256", "512"} {
+		if atoms[kind+word] {
+			op.length = byte(index)
+			widths++
+		}
+	}
+	for index, word := range []string{"0F", "0F38", "0F3A"} {
+		if atoms[kind+word] {
+			op.mapByte = byte(index + 1)
+			maps++
+		}
+	}
+	for index, word := range []string{"66", "F3", "F2"} {
+		if atoms[kind+word] {
+			op.pp = byte(index + 1)
+			prefixes++
+		}
+	}
+	wordModes := 0
+	for _, mode := range []string{"W0", "W1", "WIG"} {
+		if atoms[kind+mode] {
+			wordModes++
+		}
+	}
+	if widths != 1 || maps != 1 || prefixes > 1 || wordModes != 1 || kind == "vex" && op.length == 2 {
+		return op, nil, 0, fmt.Errorf("fixed prefix width/map/W are not unique")
+	}
+	if atoms[kind+"W1"] {
+		op.wBit = 0x80
+	}
+	stride := 2
+	flags := map[string]bool{}
+	if kind == "evex" {
+		stride = 3
+		if offset+stride > len(rule.OpBytes) {
+			return op, nil, 0, fmt.Errorf("truncated EVEX payload")
+		}
+		flags, err = x86PackedEncodingAtoms(rule.OpBytes[offset+1], nil, []string{
+			"evexN4", "evexN8", "evexN16", "evexN32", "evexN64", "evexBcstN4", "evexBcstN8",
+			"evexZeroingEnabled", "evexRoundingEnabled", "evexSaeEnabled",
+		})
+		if err != nil {
+			return op, nil, 0, err
+		}
+	}
+	if offset+stride > len(rule.OpBytes) {
+		return op, nil, 0, fmt.Errorf("truncated fixed payload")
+	}
+	value, err := strconv.ParseUint(rule.OpBytes[offset+stride-1], 0, 8)
+	if err != nil {
+		return op, nil, 0, err
+	}
+	op.opcode = byte(value)
+	return op, flags, stride, nil
+}
+
+func x86SpecialVectorFormatForRule(rule X86AVXRule) (x86SpecialVectorRow, error) {
+	var f x86SpecialVectorRow
+	fail := func() (x86SpecialVectorRow, error) {
+		return f, fmt.Errorf("special vector source roles/header/tuple/ordinal differ")
+	}
+	op, flags, _, err := x86SpecialVectorHeader(rule, rule.EncodingOffset)
+	if err != nil {
+		return f, err
+	}
+	classes := append([]string(nil), rule.Classes...)
+	f.selector = 7
+	f.registerMask = rule.ZCase == "Zvex_hr_rm_v_r"
+	if f.registerMask {
+		if len(classes) != 4 {
+			return fail()
+		}
+		classes = classes[1:]
+	} else if len(classes) > 0 && (classes[0] == "Yu8" || classes[0] == "Yi8") {
+		f.immediate = true
+		if classes[0] == "Yi8" {
+			f.selector = -1
+		}
+		classes = classes[1:]
+	}
+	f.physical.masked = strings.Contains(rule.ZCase, "_k_")
+	if f.physical.masked {
+		if len(classes) < 3 || classes[len(classes)-2] != "Yknot0" {
+			return fail()
+		}
+		classes = append(classes[:len(classes)-2], classes[len(classes)-1])
+	}
+	if len(classes) != 2 && len(classes) != 3 {
+		return fail()
+	}
+	f.physical.unary = len(classes) == 2
+	f.physical.maskResult = classes[len(classes)-1] == "Yk"
+	f.physical.width = 128 << op.length
+	f.physical.encoding = op
+	f.quartet = !f.physical.unary && strings.HasSuffix(classes[1], "Multi4")
+	bank := map[int]string{128: "x", 256: "y", 512: "z"}[f.physical.width]
+	memory, register := "Y"+bank+"m", "Y"+bank+"r"
+	if op.kind == "evex" && bank != "z" {
+		memory += "Evex"
+		register += "Evex"
+	}
+	if f.quartet {
+		if classes[0] != "Ym" || classes[1] != register+"Multi4" || f.physical.maskResult {
+			return fail()
+		}
+	} else if classes[0] != memory {
+		return fail()
+	}
+	if !f.physical.unary && !f.quartet && classes[1] != register {
+		return fail()
+	}
+	if !f.physical.maskResult && classes[len(classes)-1] != register {
+		return fail()
+	}
+	if f.registerMask && (op.kind != "vex" || rule.Classes[0] != register) {
+		return fail()
+	}
+	want := "Z" + op.kind + "_rm_v_r"
+	if f.registerMask {
+		want = "Zvex_hr_rm_v_r"
+	} else if f.immediate {
+		want = "Z" + op.kind + "_i_rm_r"
+		if !f.physical.unary {
+			want = "Z" + op.kind + "_i_rm_v_r"
+		}
+	}
+	if f.physical.masked {
+		want = "Zevex_rm_v_k_r"
+		if f.physical.unary {
+			want = "Zevex_rm_k_r"
+		}
+		if f.immediate {
+			want = "Zevex_i_rm_k_r"
+			if !f.physical.unary {
+				want = "Zevex_i_rm_v_k_r"
+			}
+		}
+	}
+	if rule.ZCase != want {
+		return fail()
+	}
+	if op.kind == "evex" {
+		tuple, tupleTerms := 0, 0
+		for _, n := range []int{4, 8, 16, 32, 64} {
+			if flags["evexN"+strconv.Itoa(n)] {
+				tuple = n
+				tupleTerms++
+			}
+		}
+		expected := f.physical.width / 8
+		if strings.HasSuffix(rule.Opcode, "SS") && !strings.HasPrefix(rule.Opcode, "VP") {
+			expected = 4
+		}
+		if strings.HasSuffix(rule.Opcode, "SD") && !strings.HasPrefix(rule.Opcode, "VP") {
+			expected = 8
+		}
+		if f.quartet {
+			expected = 16
+		}
+		if tupleTerms != 1 || tuple != expected || flags["evexBcstN4"] && flags["evexBcstN8"] || flags["evexRoundingEnabled"] && flags["evexSaeEnabled"] {
+			return fail()
+		}
+		f.physical.broadcast = flags["evexBcstN4"] || flags["evexBcstN8"]
+		f.physical.sae = flags["evexSaeEnabled"]
+		f.physical.rounding = flags["evexRoundingEnabled"]
+		if f.physical.masked && !f.physical.maskResult && !flags["evexZeroingEnabled"] {
+			return fail()
+		}
+		if f.physical.maskResult && flags["evexZeroingEnabled"] {
+			return fail()
+		}
+	}
+	// Count the original fixed-payload blocks, including shared masked pairs.
+	row, offset := 0, 0
+	for offset < len(rule.OpBytes) {
+		block, features, stride, err := x86SpecialVectorHeader(rule, offset)
+		if err != nil {
+			return f, err
+		}
+		paired := block.kind == "evex" && (features["evexZeroingEnabled"] || f.physical.maskResult)
+		signedImmediate := block.kind == "vex" && f.immediate && (f.selector < 0 || op.kind == "vex" && rule.ZOffset == 0)
+		if offset == rule.EncodingOffset {
+			expectedRow, expectedZ := row, stride
+			if paired {
+				expectedZ = 0
+				if f.physical.masked {
+					expectedRow++
+					expectedZ = stride
+				}
+			}
+			if signedImmediate {
+				expectedZ = 0
+				if f.selector < 0 {
+					expectedRow++
+					expectedZ = stride
+				}
+			}
+			if rule.RowIndex != expectedRow || rule.ZOffset != expectedZ {
+				return fail()
+			}
+		}
+		row++
+		if paired || signedImmediate {
+			row++
+		}
+		offset += stride
+	}
+	return f, nil
+}
+
+func x86SpecialVectorStateRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	if rule.ZCase == "Zvex" || rule.ZCase == "Zvex_rm_v_ro" {
+		op, _, _, err := x86SpecialVectorHeader(rule, 0)
+		if err != nil {
+			return nil, err
+		}
+		if rule.EncodingOffset != 0 || rule.RowIndex != 0 {
+			return nil, fmt.Errorf("state source offset/ordinal differs")
+		}
+		if rule.ZCase == "Zvex" {
+			if len(rule.Classes) != 0 || rule.ZOffset != 2 || len(rule.OpBytes) != 2 {
+				return nil, fmt.Errorf("zero-state source operands differ")
+			}
+			code := op.bytes(0x78, 0xe0, 0, 0)
+			code = code[:len(code)-1]
+			return []X86PackedBinaryWitness{{Instruction: rule.Opcode, Generation: "vex", Encoding: code}}, nil
+		}
+		if len(rule.Classes) != 1 || rule.Classes[0] != "Ym" || rule.ZOffset != 3 || len(rule.OpBytes) != 3 {
+			return nil, fmt.Errorf("MXCSR source memory/digit differs")
+		}
+		digit, err := strconv.ParseUint(rule.OpBytes[2], 0, 3)
+		if err != nil {
+			return nil, err
+		}
+		read := rule.Opcode == "VLDMXCSR"
+		w := X86PackedBinaryWitness{Instruction: rule.Opcode + " (AX)", Generation: "vex", Memory: read, Encoding: op.bytes(0x78, 0xe0, 0, byte(digit)<<3)}
+		if read {
+			w.First = "(AX)"
+		} else {
+			w.Destination = "(AX)"
+		}
+		return []X86PackedBinaryWitness{w}, nil
+	}
+	f, err := x86SpecialVectorFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	rows := f.physical.witnessesWithControl(rule.Opcode, f.immediate, f.selector)
+	if f.registerMask {
+		for index := range rows {
+			w := &rows[index]
+			mask := string(w.Destination[0]) + "3"
+			name, args, _ := strings.Cut(w.Instruction, " ")
+			w.Instruction = name + " " + mask + "," + args
+			w.Encoding = append(w.Encoding, 0x30)
+		}
+	}
+	if f.quartet {
+		selected := rows[:0]
+		for _, w := range rows {
+			if !w.Memory {
+				continue
+			}
+			bank := string(w.Second[0])
+			first := bank + "16"
+			group := "[" + bank + "16-" + bank + "19]"
+			destination := string(w.Destination[0]) + "20"
+			w.Instruction = strings.Replace(w.Instruction, ","+w.Second, ","+group, 1)
+			w.Instruction = strings.TrimSuffix(w.Instruction, w.Destination) + destination
+			w.Instruction = strings.Replace(w.Instruction, "(AX)", "(BX)", 1)
+			w.First = "(BX)"
+			w.Second, w.Destination = first, destination
+			w.Encoding[2] |= 8   // vvvv low bits select the aligned base16, not17.
+			w.Encoding[5] = 0x23 // ModRM.reg is destination20; existing group producer uses BX.
+			selected = append(selected, w)
+		}
+		rows = selected
+	}
+	if strings.HasPrefix(rule.Opcode, "VPCMPESTR") || strings.HasPrefix(rule.Opcode, "VPCMPISTR") {
+		for index := range rows {
+			w := &rows[index]
+			if !w.Memory {
+				continue
+			}
+			// EAX/EDX are implicit numeric lengths, so use the independent BX
+			// address role rather than invent pointer-to-number authority.
+			w.First = "(BX)"
+			w.Instruction = strings.Replace(w.Instruction, "(AX)", "(BX)", 1)
+			at := len(w.Encoding) - 2 // ModRM precedes the original imm8.
+			w.Encoding[at] = w.Encoding[at]&^7 | 3
+		}
+	}
+	return rows, nil
+}
diff --git a/internal/goasmrules/x86_witness_special_vector_state_test.go b/internal/goasmrules/x86_witness_special_vector_state_test.go
new file mode 100644
index 000000000..de2e8acac
--- /dev/null
+++ b/internal/goasmrules/x86_witness_special_vector_state_test.go
@@ -0,0 +1,108 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86SpecialVectorStateCompleteOriginalRows(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := X86SpecialVectorStateRows(X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	originals := map[string]X86AVXRule{}
+	for index, rule := range avx {
+		if x86SpecialVectorStateName(rule.Opcode) {
+			originals[fmt.Sprintf("avx/%d/%s/%s/%d", index, rule.Opcode, rule.Ytab, rule.RowIndex)] = rule
+		}
+	}
+	if len(rows) != 237 || len(originals) != 237 {
+		t.Fatal("complete237 original source closure", len(rows), len(originals))
+	}
+	for _, row := range rows {
+		names[row.Opcode] = true
+		t.Run(row.ID, func(t *testing.T) {
+			original, found := originals[row.ID]
+			if !found || len(row.Witnesses) == 0 {
+				t.Fatal("original row lost source/witnesses", row.ID)
+			}
+			valid, err := x86PackedAVXRowWitnesses(original)
+			if err != nil || len(valid) == 0 {
+				t.Fatal("valid source must precede negative metadata", err)
+			}
+			// The complete opcode payload contains other generations and widths.
+			// Only this row's current encoding block supplies suffix controls.
+			inputForms := 2
+			if len(original.Classes) <= 1 {
+				inputForms = 1
+			}
+			masked, maskResult := false, false
+			for _, class := range original.Classes {
+				masked = masked || class == "Yknot0"
+				if strings.HasSuffix(class, "Multi4") {
+					inputForms = 1
+				}
+			}
+			if len(original.Classes) > 0 {
+				maskResult = original.Classes[len(original.Classes)-1] == "Yk"
+			}
+			controls := ""
+			if strings.HasPrefix(original.ZCase, "Zevex_") {
+				controls = original.OpBytes[original.EncodingOffset+1]
+			}
+			want := inputForms
+			if strings.Contains(controls, "evexBcstN") {
+				want++
+			}
+			if strings.Contains(controls, "evexSaeEnabled") {
+				want++
+			}
+			if strings.Contains(controls, "evexRoundingEnabled") {
+				want += 4
+			}
+			if masked && !maskResult {
+				want *= 2
+			}
+			if maskResult {
+				want *= 2
+			}
+			if len(valid) != want {
+				t.Fatal("current source block shape count", row.ID, len(valid), want)
+			}
+			for _, axis := range []string{"prefix", "classes", "header", "payload-bound"} {
+				t.Run(axis, func(t *testing.T) {
+					bad := original
+					bad.Classes = append([]string(nil), original.Classes...)
+					bad.OpBytes = append([]string(nil), original.OpBytes...)
+					switch axis {
+					case "prefix":
+						bad.Prefix = "Pm"
+					case "classes":
+						if len(bad.Classes) == 0 {
+							bad.Classes = []string{"Yxxx"}
+						} else {
+							bad.Classes[0] = "Yxxx"
+						}
+					case "header":
+						bad.OpBytes[bad.EncodingOffset] += " | inventedEncodingPermission"
+					case "payload-bound":
+						bad.EncodingOffset += len(bad.OpBytes)
+					}
+					if _, err := x86PackedAVXRowWitnesses(bad); err == nil {
+						t.Fatal("mutated source metadata granted a physical grammar", axis, row.ID)
+					}
+				})
+			}
+		})
+	}
+	if len(names) != 89 {
+		t.Fatal("complete89 source names", len(names))
+	}
+}
diff --git a/internal/goasmrules/x86_witness_stack_control.go b/internal/goasmrules/x86_witness_stack_control.go
new file mode 100644
index 000000000..49b938921
--- /dev/null
+++ b/internal/goasmrules/x86_witness_stack_control.go
@@ -0,0 +1,313 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// X86SourceRelocation is an instruction-relative source encoding requirement.
+// It supplies no symbol address, caller, stack or native execution permission.
+type X86SourceRelocation struct {
+	Offset, Size int
+	Kind, Symbol string
+	Add          int64
+}
+
+// Canonical witnesses retain the last explicit syntax carrier in Destination.
+// Stack, implicit outputs and control-flow effects remain separate contracts.
+type X86StackControlWitness struct {
+	X86ScalarRMWWitness
+	// Origin distinguishes source syntax from direct backend candidates.
+	// Neither spelling nor candidate bytes establish an actual observation.
+	Origin      string
+	Relocations []X86SourceRelocation
+	// Local branch witnesses use an independent fixture envelope: this many
+	// one-byte padding instructions precede their next RET target.
+	BranchPadding int `json:",omitempty"`
+}
+
+type X86StackControlRow struct {
+	ID, Opcode, ModeFiltered string
+	Witnesses                []X86StackControlWitness
+}
+
+// X86StackControlSource owns exact original member metadata and optional
+// original DUFF frame transport. Its private fields cannot alias callers.
+type X86StackControlSource struct {
+	members               []byte
+	duffBefore, duffAfter []byte
+}
+
+func LoadX86StackControlSource(goroot string) (X86StackControlSource, error) {
+	var source X86StackControlSource
+	catalog, err := LoadX86LegacyRules(goroot)
+	if err != nil {
+		return source, err
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(goroot, "src/cmd/internal/obj/x86/asm6.go"), nil, 0)
+	if err != nil {
+		return source, err
+	}
+	variables, err := x86TableVariables(file)
+	if err != nil {
+		return source, err
+	}
+	transport := map[string][]byte{}
+	for _, name := range []string{"bpduff1", "bpduff2"} {
+		literal := variables[name]
+		if literal == nil {
+			continue
+		}
+		if expression(literal.Type) != "[]byte" || len(literal.Elts) == 0 {
+			return source, fmt.Errorf("invalid original DUFF frame literal")
+		}
+		for _, atom := range literal.Elts {
+			value, err := strconv.ParseUint(expression(atom), 0, 8)
+			if err != nil {
+				return source, fmt.Errorf("non-byte original DUFF frame literal")
+			}
+			// Unlike fixed opBytes literals, these slices include zero bytes.
+			transport[name] = append(transport[name], byte(value))
+		}
+	}
+	uses := map[string]int{}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "doasm" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok || len(call.Args) != 1 {
+				return true
+			}
+			selector, ok := call.Fun.(*ast.SelectorExpr)
+			if !ok || selector.Sel.Name != "Put" {
+				return true
+			}
+			receiver, valid := selector.X.(*ast.Ident)
+			argument, named := call.Args[0].(*ast.Ident)
+			if valid && named && receiver.Name == "ab" && (argument.Name == "bpduff1" || argument.Name == "bpduff2") {
+				uses[argument.Name]++
+			}
+			return true
+		})
+	}
+	if len(transport) != 0 || len(uses) != 0 {
+		if len(transport) != 2 || len(uses) != 2 || uses["bpduff1"] != 1 || uses["bpduff2"] != 1 {
+			return source, fmt.Errorf("incomplete original DUFF frame transport")
+		}
+	}
+	source.duffBefore, source.duffAfter = transport["bpduff1"], transport["bpduff2"]
+	source.members, err = x86LegacySourceMembers(catalog, x86StackControlSchema)
+	return source, err
+}
+
+func x86StackControlSchema(table string) []string {
+	switch table {
+	case "ycall":
+		return []string{"Zcallindreg/0/Yml", "Zcallindreg/2/Yrx,Yrx", "Zcallind/2/Yindir", "Zcall/0/Ybr", "Zcallcon/1/Yi32"}
+	case "yloop":
+		return []string{"Zloop/1/Ybr"}
+	case "yjmp":
+		return []string{"Zo_m64/2/Yml", "Zjmp/0/Ybr", "Zjmpcon/1/Yi32"}
+	case "ypopl":
+		return []string{"Z_rp/1/Yrl", "Zo_m/2/Ym"}
+	case "ypushl":
+		return []string{"Zrp_/1/Yrl", "Zm_o/2/Ym", "Zib_/1/Yi8", "Zil_/1/Yi32"}
+	case "yret":
+		return []string{"Zo_iw/1/", "Zo_iw/1/Yi32"}
+	case "yduff":
+		return []string{"Zcallduff/1/Yi32"}
+	}
+	return nil
+}
+
+func X86StackControlRows(catalog X86LegacyCatalog, source X86StackControlSource, arch string) ([]X86StackControlRow, error) {
+	if arch != "amd64" && arch != "386" || len(source.members) == 0 {
+		return nil, fmt.Errorf("stack/control source requires an original source and x86 mode")
+	}
+	members, err := x86LegacySourceMembers(catalog, x86StackControlSchema)
+	if err != nil || !bytes.Equal(members, source.members) {
+		return nil, fmt.Errorf("stack/control members differ from the captured Go source")
+	}
+	var result []X86StackControlRow
+	names, counts := map[string]bool{}, map[string]int{}
+	for index, entry := range catalog.Optab {
+		if x86StackControlSchema(entry.Ytab) == nil {
+			continue
+		}
+		if entry.TableIndex != index || names[entry.Opcode] {
+			return nil, fmt.Errorf("original stack/control index or member duplicated")
+		}
+		names[entry.Opcode] = true
+		for _, operand := range entry.Rows {
+			witnesses, err := x86StackControlWitnesses(entry, operand, source, arch, catalog.OpBytesSize)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			row := X86StackControlRow{ID: fmt.Sprintf("optab/%d/%s/%s/%d", index, entry.Opcode, entry.Ytab, operand.RowIndex), Opcode: entry.Opcode, Witnesses: witnesses}
+			if entry.Prefix == "P32" && arch == "amd64" || (entry.Prefix == "Py" || entry.Prefix == "Pw") && arch == "386" {
+				row.ModeFiltered, row.Witnesses = "original Go "+entry.Prefix+" rejects this source mode", nil
+			}
+			result = append(result, row)
+			counts[entry.Ytab]++
+		}
+	}
+	want := map[string]int{"ycall": 5, "yloop": 6, "yjmp": 3, "ypopl": 6, "ypushl": 12, "yret": 6, "yduff": 2}
+	if len(result) != 40 || len(names) != 19 || len(counts) != len(want) {
+		return nil, fmt.Errorf("incomplete original stack/control source cohort")
+	}
+	for table, count := range want {
+		if counts[table] != count {
+			return nil, fmt.Errorf("incomplete stack/control source table %s", table)
+		}
+	}
+	return result, nil
+}
+
+func x86StackControlWitnesses(entry X86LegacyOpcode, row X86LegacyOperand, source X86StackControlSource, arch string, capacity int) ([]X86StackControlWitness, error) {
+	if entry.Kind != "encoding" || entry.Opcode == "" || entry.OpcodeExpression == "" || entry.TableIndex < 0 ||
+		capacity <= 0 || len(entry.OpBytes) == 0 || len(entry.OpBytes) > capacity || arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("invalid captured stack/control entry")
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, x86StackControlSchema(entry.Ytab)); err != nil {
+		return nil, err
+	}
+	var prefix []byte
+	switch entry.Prefix {
+	case "Px", "P32", "Py":
+	case "Pe":
+		prefix = []byte{0x66}
+	case "Pw":
+		prefix = []byte{0x48}
+	default:
+		return nil, fmt.Errorf("unmodeled stack/control source prefix")
+	}
+	payload := make([]byte, len(entry.OpBytes))
+	for index, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return nil, fmt.Errorf("stack/control source contains a non-byte atom")
+		}
+		payload[index] = byte(value)
+	}
+	if entry.EscapeAdjustment != 0 || row.UnmatchedOffset >= len(payload) {
+		return nil, fmt.Errorf("stack/control source offset or escape changed")
+	}
+	offset, opcode := row.UnmatchedOffset, payload[row.UnmatchedOffset]
+	span := func(length int) bool { return offset+length <= len(payload) }
+	var result []X86StackControlWitness
+	add := func(arguments string, code []byte, padding int, relocations ...X86SourceRelocation) {
+		for index := range relocations {
+			// R_CALLIND is a zero-size marker at the instruction's start;
+			// encoded displacement fields follow the emitted prefixes.
+			if relocations[index].Size != 0 {
+				relocations[index].Offset += len(prefix)
+			}
+		}
+		origin := "stock-asm"
+		if row.ZCase == "Zcallduff" {
+			origin = "stock-backend"
+		}
+		result = append(result, X86StackControlWitness{
+			X86ScalarRMWWitness: X86ScalarRMWWitness{Instruction: strings.TrimSpace(entry.Opcode + " " + arguments),
+				Destination: arguments[strings.LastIndex(arguments, ",")+1:], Encoding: append(append([]byte(nil), prefix...), code...)},
+			Origin: origin, Relocations: relocations, BranchPadding: padding})
+	}
+	switch row.ZCase {
+	case "Z_rp", "Zrp_":
+		add("BX", []byte{opcode + 3}, 0)
+	case "Zo_m", "Zm_o", "Zo_m64", "Zcallindreg":
+		if !span(2) || payload[offset+1] > 7 {
+			return nil, fmt.Errorf("stack/control source lacks a valid group extension")
+		}
+		operands := []string{"0(SI)"}
+		if row.ZCase == "Zo_m64" || row.ZCase == "Zcallindreg" {
+			operands = []string{"BX", "0(SI)"}
+		}
+		if len(row.Classes) == 2 {
+			operands = []string{"CX,BX"}
+		}
+		for _, arguments := range operands {
+			modrm := byte(6)
+			if strings.HasSuffix(arguments, "BX") {
+				modrm = 0xc3
+			}
+			var relocations []X86SourceRelocation
+			if row.ZCase == "Zcallindreg" {
+				relocations = []X86SourceRelocation{{Kind: "R_CALLIND"}}
+			}
+			add(arguments, x86SourceModRMBytes(nil, opcode, modrm|payload[offset+1]<<3), 0, relocations...)
+		}
+	case "Zib_", "Zil_", "Zo_iw":
+		value, width, arguments := 7, 1, "$7"
+		if row.ZCase == "Zil_" {
+			value, width, arguments = 300, 4, "$300"
+			if entry.Prefix == "Pe" {
+				width = 2
+			}
+		} else if row.ZCase == "Zo_iw" {
+			value, width, arguments = 37, 2, "$37"
+			if len(row.Classes) == 0 {
+				width, arguments = 0, ""
+			}
+		}
+		code := []byte{opcode}
+		for index := 0; index < width; index++ {
+			code = append(code, byte(value>>uint(index*8)))
+		}
+		add(arguments, code, 0)
+	case "Zcall", "Zcallduff":
+		arguments, symbol, addend := "·Target+7(SB)", "literal.Target", int64(7)
+		code, displacement := []byte{opcode, 0, 0, 0, 0}, 1
+		if row.ZCase == "Zcallduff" {
+			symbol, addend = "runtime."+strings.ToLower(entry.Opcode), 37
+			arguments = "$" + strings.Replace(symbol, ".", "·", 1) + "+37(SB)"
+			if arch == "amd64" {
+				code = append(append(append([]byte(nil), source.duffBefore...), code...), source.duffAfter...)
+				displacement += len(source.duffBefore)
+			}
+		}
+		add(arguments, code, 0, X86SourceRelocation{displacement, 4, "R_CALL", symbol, addend})
+	case "Zcallcon", "Zjmpcon":
+		if row.ZCase == "Zjmpcon" {
+			if !span(2) {
+				return nil, fmt.Errorf("constant jump lost its near opcode")
+			}
+			opcode = payload[offset+1]
+		}
+		add("$37", []byte{opcode, 0, 0, 0, 0}, 0, X86SourceRelocation{1, 4, "R_PCREL", "", 37})
+	case "Zloop", "Zjmp":
+		code := []byte{opcode, 1}
+		if entry.Opcode == "JCXZL" {
+			code = append([]byte{0x67}, code...)
+		}
+		add("after", code, 1)
+		if row.ZCase == "Zjmp" {
+			if !span(2) {
+				return nil, fmt.Errorf("local jump lost its near opcode")
+			}
+			add("after", []byte{payload[offset+1], 160, 0, 0, 0}, 160)
+			add("·Target(SB)", []byte{payload[offset+1], 0, 0, 0, 0}, 0, X86SourceRelocation{1, 4, "R_CALL", "literal.Target", 0})
+		}
+	case "Zcallind":
+		if !span(2) {
+			return nil, fmt.Errorf("symbol-indirect call lost its group encoding")
+		}
+		kind := "R_PCREL"
+		if arch == "386" {
+			kind = "R_ADDR"
+		}
+		add("*·Target(SB)", []byte{opcode, payload[offset+1], 0, 0, 0, 0}, 0, X86SourceRelocation{2, 4, kind, "literal.Target", 0})
+	default:
+		return nil, fmt.Errorf("unmodeled stack/control encoding group")
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_stack_control_test.go b/internal/goasmrules/x86_witness_stack_control_test.go
new file mode 100644
index 000000000..08b7bab3b
--- /dev/null
+++ b/internal/goasmrules/x86_witness_stack_control_test.go
@@ -0,0 +1,226 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func stackControlOriginalSchemas() map[string][]string {
+	return map[string][]string{
+		"ycall":  {"Zcallindreg/0/Yml", "Zcallindreg/2/Yrx,Yrx", "Zcallind/2/Yindir", "Zcall/0/Ybr", "Zcallcon/1/Yi32"},
+		"yloop":  {"Zloop/1/Ybr"},
+		"yjmp":   {"Zo_m64/2/Yml", "Zjmp/0/Ybr", "Zjmpcon/1/Yi32"},
+		"ypopl":  {"Z_rp/1/Yrl", "Zo_m/2/Ym"},
+		"ypushl": {"Zrp_/1/Yrl", "Zm_o/2/Ym", "Zib_/1/Yi8", "Zil_/1/Yi32"},
+		"yret":   {"Zo_iw/1/", "Zo_iw/1/Yi32"},
+		"yduff":  {"Zcallduff/1/Yi32"},
+	}
+}
+
+func stackControlOriginalCatalog(t *testing.T) X86LegacyCatalog {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return catalog
+}
+
+func TestX86StackControlCompleteOriginalSchemas(t *testing.T) {
+	catalog := stackControlOriginalCatalog(t)
+	schemas := stackControlOriginalSchemas()
+	want := map[string]int{"ycall": 5, "yloop": 6, "yjmp": 3, "ypopl": 6, "ypushl": 12, "yret": 6, "yduff": 2}
+	counts := map[string]int{}
+	names := map[string]bool{}
+	rows := 0
+	for _, entry := range catalog.Optab {
+		schema, selected := schemas[entry.Ytab]
+		if !selected {
+			continue
+		}
+		if entry.Kind != "encoding" || names[entry.Opcode] || entry.EscapeAdjustment != 0 ||
+			strings.TrimPrefix(entry.OpcodeExpression, "obj.") != "A"+entry.Opcode {
+			t.Fatal("complete original stack/control entry identity changed", entry)
+		}
+		names[entry.Opcode] = true
+		for _, row := range entry.Rows {
+			if err := x86ScalarCompleteOperandSchema(entry, row, schema); err != nil {
+				t.Fatal("original complete operand schema changed", entry.Opcode, err)
+			}
+			counts[entry.Ytab]++
+			rows++
+		}
+	}
+	if rows != 40 || len(names) != 19 || len(counts) != 7 {
+		t.Fatal("complete source rows/tables changed", rows, len(names), counts)
+	}
+	for table, count := range want {
+		if counts[table] != count {
+			t.Fatal("missing original table row", table, counts[table], count)
+		}
+	}
+}
+
+// The separate source owner supplies byte/relocation projections while the
+// original scalar owner's refusal remains independently checked below.
+func stackControlSourceProbe(entry X86LegacyOpcode, row X86LegacyOperand, source X86StackControlSource, arch string, capacity int) ([]X86StackControlWitness, error) {
+	return x86StackControlWitnesses(entry, row, source, arch, capacity)
+}
+
+func TestX86StackControlFormatterFeature(t *testing.T) {
+	catalog := stackControlOriginalCatalog(t)
+	schemas := stackControlOriginalSchemas()
+	source, err := LoadX86StackControlSource(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			for _, entry := range catalog.Optab {
+				if schemas[entry.Ytab] == nil || entry.Prefix == "P32" && arch == "amd64" ||
+					(entry.Prefix == "Py" || entry.Prefix == "Pw") && arch == "386" {
+					continue
+				}
+				for _, row := range entry.Rows {
+					t.Run(fmt.Sprintf("%s/%d", entry.Opcode, row.RowIndex), func(t *testing.T) {
+						witnesses, err := stackControlSourceProbe(entry, row, source, arch, catalog.OpBytesSize)
+						if err != nil || len(witnesses) == 0 {
+							t.Fatal("STACK_CONTROL_FORMATTER_FEATURE_GAP", entry.Opcode, row, err)
+						}
+						for _, witness := range witnesses {
+							if witness.Instruction == "" || len(witness.Encoding) == 0 {
+								t.Fatal("source metadata is not byte evidence", entry.Opcode, witness)
+							}
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86StackControlCompleteMetadataBoundaries(t *testing.T) {
+	catalog := stackControlOriginalCatalog(t)
+	source, err := LoadX86StackControlSource(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var original X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		if entry.Opcode == "PUSHQ" {
+			original = entry
+		}
+	}
+	if len(original.Rows) != 4 {
+		t.Fatal("missing complete PUSHQ source schema")
+	}
+	for name, mutate := range map[string]func(*X86LegacyOpcode){
+		"captured-enum":          func(e *X86LegacyOpcode) { e.OpcodeExpression = "APUSHL" },
+		"missing-earlier-row":    func(e *X86LegacyOpcode) { e.Rows = e.Rows[1:] },
+		"earlier-stride":         func(e *X86LegacyOpcode) { e.Rows[0].ZOffset++ },
+		"earlier-classes":        func(e *X86LegacyOpcode) { e.Rows[0].Classes = []string{"Ym"} },
+		"selected-offset":        func(e *X86LegacyOpcode) { e.Rows[3].UnmatchedOffset++ },
+		"selected-row-order":     func(e *X86LegacyOpcode) { e.Rows[3].RowIndex-- },
+		"source-escape":          func(e *X86LegacyOpcode) { e.EscapeAdjustment = 1 },
+		"missing-opcode-payload": func(e *X86LegacyOpcode) { e.OpBytes = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := original
+			changed.Rows = append([]X86LegacyOperand(nil), original.Rows...)
+			changed.OpBytes = append([]string(nil), original.OpBytes...)
+			mutate(&changed)
+			selected := changed.Rows[len(changed.Rows)-1]
+			if witnesses, err := stackControlSourceProbe(changed, selected, source, "amd64", catalog.OpBytesSize); err == nil {
+				t.Fatal("STACK_CONTROL_METADATA_ACCEPTED", name, witnesses)
+			}
+		})
+	}
+	t.Log("Initial rejection by the old source helper is not a newly repaired metadata defect.")
+}
+
+func TestX86StackControlDoesNotWidenExistingScalarOwner(t *testing.T) {
+	catalog := stackControlOriginalCatalog(t)
+	schemas := stackControlOriginalSchemas()
+	for _, entry := range catalog.Optab {
+		if schemas[entry.Ytab] == nil {
+			continue
+		}
+		for _, row := range entry.Rows {
+			for _, arch := range []string{"amd64", "386"} {
+				if witnesses, err := x86ScalarRMWRowWitnesses(entry, row, arch); err == nil || len(witnesses) != 0 {
+					t.Fatal("separate source-control grammar widened an old scalar owner", entry.Opcode, row, arch, witnesses, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86StackControlPublicSourceBoundaries(t *testing.T) {
+	original := stackControlOriginalCatalog(t)
+	source, err := LoadX86StackControlSource(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := X86StackControlRows(original, source, "amd64"); err != nil {
+		t.Fatal("actual complete source is a prerequisite", err)
+	}
+	for _, mutation := range []string{"missing-member", "duplicate-member", "retag-member", "swapped-names", "changed-class", "changed-payload", "missing-enum", "capacity", "zero-source", "foreign-arch"} {
+		t.Run(mutation, func(t *testing.T) {
+			catalog := original
+			catalog.Optab = append([]X86LegacyOpcode(nil), original.Optab...)
+			captured, arch := source, "amd64"
+			index := -1
+			for position, entry := range catalog.Optab {
+				if entry.Opcode == "CALL" {
+					index = position
+				}
+			}
+			if index < 0 {
+				t.Fatal("original CALL source disappeared")
+			}
+			entry := catalog.Optab[index]
+			switch mutation {
+			case "missing-member":
+				entry.Ytab = "ynone"
+			case "duplicate-member":
+				for _, alternative := range original.Optab {
+					if alternative.Opcode == "JMP" {
+						entry = alternative
+						entry.TableIndex = index
+					}
+				}
+			case "retag-member":
+				entry.Opcode, entry.OpcodeExpression = "MOVL", "AMOVL"
+			case "swapped-names":
+				for position, alternative := range catalog.Optab {
+					if alternative.Opcode == "JMP" {
+						entry.Opcode, alternative.Opcode = alternative.Opcode, entry.Opcode
+						entry.OpcodeExpression, alternative.OpcodeExpression = alternative.OpcodeExpression, entry.OpcodeExpression
+						catalog.Optab[position] = alternative
+					}
+				}
+			case "changed-class":
+				entry.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				entry.Rows[0].Classes = append([]string(nil), entry.Rows[0].Classes...)
+				entry.Rows[0].Classes[0] = "Ynone"
+			case "changed-payload":
+				entry.OpBytes = append([]string(nil), entry.OpBytes...)
+				entry.OpBytes[0] = "0xfe"
+			case "missing-enum":
+				entry.OpcodeExpression = ""
+			case "capacity":
+				catalog.OpBytesSize++
+			case "zero-source":
+				captured = X86StackControlSource{}
+			case "foreign-arch":
+				arch = "arm64"
+			}
+			catalog.Optab[index] = entry
+			if rows, err := X86StackControlRows(catalog, captured, arch); err == nil {
+				t.Fatal("uncaptured source became a complete source view", mutation, rows)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_state_system_memory.go b/internal/goasmrules/x86_witness_state_system_memory.go
new file mode 100644
index 000000000..1d348813c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_state_system_memory.go
@@ -0,0 +1,320 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// X86StateSystemMemoryRow separates a stock frontend refusal from both mode
+// restrictions and the backend's physical encoding. Neither grants numerical,
+// storage, privileged-state, CFG or native-entry permission.
+type X86StateSystemMemoryRow struct {
+	X86ScalarRMWRow
+	FrontendRejected string                `json:",omitempty"`
+	BackendWitnesses []X86ScalarRMWWitness `json:",omitempty"`
+}
+
+// X86UnaryDestinations is immutable to callers; only the source loader can
+// populate its complete role map. A zero value cannot classify source rows.
+type X86UnaryDestinations struct {
+	roles   map[string]bool
+	members []byte
+}
+
+// LoadX86UnaryDestinations captures the complete original frontend role map.
+// It does not change the legacy catalog or its existing serialized views.
+func LoadX86UnaryDestinations(goroot string) (X86UnaryDestinations, error) {
+	var zero X86UnaryDestinations
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(goroot, "src/cmd/internal/obj/x86/obj6.go"), nil, 0)
+	if err != nil {
+		return zero, err
+	}
+	variables, err := x86TableVariables(file)
+	if err != nil {
+		return zero, err
+	}
+	literal := variables["unaryDst"]
+	if literal == nil || expression(literal.Type) != "map[obj.As]bool" {
+		return zero, fmt.Errorf("missing complete original unaryDst role map")
+	}
+	result := map[string]bool{}
+	for _, element := range literal.Elts {
+		pair, ok := element.(*ast.KeyValueExpr)
+		if !ok {
+			return zero, fmt.Errorf("nonliteral unaryDst source role")
+		}
+		name, err := x86SourceOpcodeName(strings.TrimPrefix(expression(pair.Key), "obj."))
+		setting := expression(pair.Value)
+		if _, exists := result[name]; exists || err != nil || setting != "true" && setting != "false" {
+			return zero, fmt.Errorf("invalid or duplicate unaryDst source role")
+		}
+		result[name] = setting == "true"
+	}
+	if len(result) == 0 {
+		return zero, fmt.Errorf("empty original unaryDst source roles")
+	}
+	catalog, err := LoadX86LegacyRules(goroot)
+	if err != nil {
+		return zero, err
+	}
+	members, err := x86StateSystemMemoryMembers(catalog)
+	if err != nil {
+		return zero, err
+	}
+	return X86UnaryDestinations{roles: result, members: members}, nil
+}
+
+// Capture actual member metadata, never an independently maintained opcode
+// registry. Serialization owns its bytes and cannot alias caller catalog slices.
+func x86StateSystemMemoryMembers(catalog X86LegacyCatalog) ([]byte, error) {
+	return x86LegacySourceMembers(catalog, x86StateSystemMemorySchema)
+}
+
+func x86StateSystemMemorySchema(table string) []string {
+	switch table {
+	case "yclflush", "ysvrs_om":
+		return []string{"Zo_m/2/Ym"}
+	case "ysvrs_mo", "yprefetch":
+		return []string{"Zm_o/2/Ym"}
+	case "ydivb":
+		return []string{"Zm_o/2/Ymb"}
+	case "ydivl":
+		return []string{"Zm_o/2/Yml"}
+	case "yincq":
+		return []string{"Zo_m/2/Yml"}
+	case "ywrfsbase":
+		return []string{"Zm_o/2/Yrl"}
+	case "yrdrand":
+		return []string{"Zo_m/2/Yrl"}
+	case "yrl_m":
+		return []string{"Zr_m/1/Yrl,Ym"}
+	case "yrl_ml":
+		return []string{"Zr_m/1/Yrl,Yml"}
+	case "ym_rl":
+		return []string{"Zm_r/1/Ym,Yrl"}
+	case "ycrc32l":
+		return []string{"Zlitm_r/0/Yml,Yrl"}
+	case "yin":
+		return []string{"Zib_/1/Yi32", "Zlit/1/"}
+	case "yint":
+		return []string{"Zib_/1/Yi32"}
+	case "yxabort":
+		return []string{"Zib_/1/Yu8"}
+	case "yxbegin":
+		return []string{"Zjmp/1/Ybr"}
+	}
+	return nil
+}
+
+// X86StateSystemMemoryRows retains all original rows, including source
+// frontend failures. Destination means the explicit To carrier; implicit
+// architectural outputs remain with their independent semantic consumers.
+func X86StateSystemMemoryRows(catalog X86LegacyCatalog, frontend X86UnaryDestinations, arch string) ([]X86StateSystemMemoryRow, error) {
+	if arch != "amd64" && arch != "386" || len(frontend.roles) == 0 {
+		return nil, fmt.Errorf("state source view requires an explicit x86 mode and frontend roles")
+	}
+	members, err := x86StateSystemMemoryMembers(catalog)
+	if err != nil || !bytes.Equal(members, frontend.members) {
+		return nil, fmt.Errorf("state members differ from the captured Go encoder source")
+	}
+	var result []X86StateSystemMemoryRow
+	counts, names := map[string]int{}, map[string]bool{}
+	for index, entry := range catalog.Optab {
+		if x86StateSystemMemorySchema(entry.Ytab) == nil {
+			continue
+		}
+		if entry.TableIndex != index || names[entry.Opcode] {
+			return nil, fmt.Errorf("original state source index or unique opcode changed")
+		}
+		names[entry.Opcode] = true
+		for _, original := range entry.Rows {
+			counts[entry.Ytab]++
+			witnesses, err := x86StateSystemMemoryWitnesses(entry, original, catalog.OpBytesSize)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, original.RowIndex, err)
+			}
+			row := X86StateSystemMemoryRow{X86ScalarRMWRow: X86ScalarRMWRow{
+				ID: fmt.Sprintf("optab/%d/%s/%s/%d", index, entry.Opcode, entry.Ytab, original.RowIndex), Opcode: entry.Opcode}}
+			if original.ZCase == "Zo_m" {
+				if _, exists := frontend.roles[entry.Opcode]; !exists {
+					return nil, fmt.Errorf("missing original unary destination role for %s", entry.Opcode)
+				}
+			}
+			if (original.ZCase == "Zm_o" || original.ZCase == "Zo_m") && frontend.roles[entry.Opcode] != (original.ZCase == "Zo_m") {
+				row.FrontendRejected = "original unaryDst operand slot disagrees with " + original.ZCase + "; stock asm reports asmand: bad address"
+				row.BackendWitnesses = witnesses
+			} else if arch == "amd64" && entry.Prefix == "P32" || arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Pfw") {
+				row.ModeFiltered = "original Go " + entry.Prefix + " rejects this source mode"
+			} else {
+				row.Witnesses = witnesses
+			}
+			result = append(result, row)
+		}
+	}
+	want := map[string]int{
+		"yclflush": 15, "ysvrs_mo": 9, "ysvrs_om": 6, "yin": 12,
+		"yint": 1, "ydivl": 20, "ydivb": 5, "ywrfsbase": 7,
+		"ycrc32l": 7, "yprefetch": 4, "yincq": 13, "yrdrand": 10,
+		"ym_rl": 12, "yrl_m": 2, "yrl_ml": 10, "yxbegin": 1, "yxabort": 1,
+	}
+	_, hasRDPID := frontend.roles["RDPID"]
+	if hasRDPID {
+		want["yrdrand"]++
+	}
+	if names["RDPID"] != hasRDPID || len(counts) != len(want) {
+		return nil, fmt.Errorf("state source/frontend inventory does not contain the complete tables")
+	}
+	for table, count := range want {
+		if counts[table] != count {
+			return nil, fmt.Errorf("incomplete state source table %s: %d/%d", table, counts[table], count)
+		}
+	}
+	return result, nil
+}
+
+func x86StateSystemMemoryWitnesses(entry X86LegacyOpcode, row X86LegacyOperand, capacity int) ([]X86ScalarRMWWitness, error) {
+	if entry.Kind != "encoding" || entry.Opcode == "" || entry.OpcodeExpression == "" || entry.TableIndex < 0 || capacity <= 0 || len(entry.OpBytes) == 0 || len(entry.OpBytes) > capacity {
+		return nil, fmt.Errorf("invalid complete state source entry")
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, row, x86StateSystemMemorySchema(entry.Ytab)); err != nil {
+		return nil, err
+	}
+	var prefix []byte
+	switch entry.Prefix {
+	case "Px", "Pb", "P32":
+	case "Pe":
+		prefix = []byte{0x66}
+	case "Pm":
+		prefix = []byte{0x0f}
+	case "Pq":
+		prefix = []byte{0x66, 0x0f}
+	case "Pf2", "Pf3", "Pfw":
+		prefix = []byte{0xf3, 0x0f}
+		if entry.Prefix == "Pf2" {
+			prefix[0] = 0xf2
+		} else if entry.Prefix == "Pfw" {
+			prefix = []byte{0xf3, 0x48, 0x0f}
+		}
+	case "Pw":
+		prefix = []byte{0x48}
+	default:
+		return nil, fmt.Errorf("unmodeled original state source prefix")
+	}
+	payload := make([]byte, len(entry.OpBytes))
+	for index, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return nil, fmt.Errorf("state source contains a non-byte atom")
+		}
+		payload[index] = byte(value)
+	}
+	if entry.EscapeAdjustment != 0 && payload[0] != 0x0f || entry.EscapeAdjustment == 0 && payload[0] == 0x0f {
+		return nil, fmt.Errorf("state source escape and original leading atom differ")
+	}
+	offset := row.UnmatchedOffset
+	if offset >= len(payload) {
+		return nil, fmt.Errorf("state source selected span is missing")
+	}
+	code := append(append([]byte(nil), prefix...), payload[offset])
+	if row.ZCase == "Zlit" || row.ZCase == "Zlitm_r" {
+		literal, err := x86SourceLiteralBytes(entry.OpBytes[offset:], capacity-offset)
+		if err != nil {
+			return nil, err
+		}
+		code = append(append([]byte(nil), prefix...), literal...)
+		if entry.Prefix == "Pw" {
+			// Go inserts REX after mandatory literal prefixes, before 0F.
+			code = code[1:]
+			position := 0
+			for position < len(code) && (code[position] == 0x66 || code[position] == 0xf2 || code[position] == 0xf3) {
+				position++
+			}
+			code = append(code[:position], append([]byte{0x48}, code[position:]...)...)
+		}
+	} else if payload[offset] == 0x0f {
+		offset++
+		if offset >= len(payload) {
+			return nil, fmt.Errorf("state source opcode is truncated")
+		}
+		code = append(code, payload[offset])
+	}
+	operands := [][2]string{{"", "BX"}}
+	switch row.ZCase {
+	case "Zm_o", "Zo_m":
+		if row.Classes[0] == "Ymb" {
+			operands[0][1] = "BL"
+		}
+		if row.Classes[0] == "Ym" {
+			operands = nil
+		}
+		if row.Classes[0] != "Yrl" {
+			operands = append(operands, [2]string{"", "0(SI)"})
+		}
+	case "Zr_m":
+		operands = [][2]string{{"CX", "0(SI)"}}
+		if row.Classes[1] == "Yml" {
+			operands = append([][2]string{{"CX", "BX"}}, operands...)
+		}
+	case "Zm_r":
+		operands = [][2]string{{"0(SI)", "BX"}}
+	case "Zlitm_r":
+		operands = [][2]string{{"CX", "BX"}, {"0(SI)", "BX"}}
+	case "Zib_":
+		operands = [][2]string{{"", "$7"}}
+	case "Zlit":
+		operands = [][2]string{{}}
+	case "Zjmp":
+		operands = [][2]string{{"", "1(PC)"}}
+	}
+	var result []X86ScalarRMWWitness
+	for _, args := range operands {
+		encoding := append([]byte(nil), code...)
+		modrm := byte(0xc3)
+		if args[0] == "0(SI)" || args[1] == "0(SI)" {
+			modrm = 6
+		}
+		switch row.ZCase {
+		case "Zm_o", "Zo_m":
+			if offset+1 >= len(payload) || payload[offset+1] > 7 {
+				return nil, fmt.Errorf("state source /digit is truncated or invalid")
+			}
+			encoding = x86SourceModRMBytes(code[:len(code)-1], code[len(code)-1], modrm|payload[offset+1]<<3)
+		case "Zr_m":
+			encoding = x86SourceModRMBytes(code[:len(code)-1], code[len(code)-1], modrm|1<<3)
+		case "Zm_r", "Zlitm_r":
+			if args[0] == "CX" {
+				modrm = 0xc1
+			}
+			encoding = x86SourceModRMBytes(code[:len(code)-1], code[len(code)-1], modrm|3<<3)
+		case "Zjmp", "Zib_":
+			if entry.Ytab == "yxbegin" || entry.Ytab == "yxabort" {
+				if len(payload) < offset+2 || entry.Opcode != map[string]string{"yxbegin": "XBEGIN", "yxabort": "XABORT"}[entry.Ytab] {
+					return nil, fmt.Errorf("transaction source lost its original second opcode")
+				}
+				encoding = append(encoding, payload[offset+1])
+			}
+			if row.ZCase == "Zjmp" {
+				encoding = append(encoding, 0, 0, 0, 0)
+			} else {
+				encoding = append(encoding, 7)
+			}
+		}
+		instruction, destination := entry.Opcode, args[1]
+		if args[0] != "" {
+			instruction += " " + args[0] + "," + args[1]
+		} else if args[1] != "" {
+			instruction += " " + args[1]
+		}
+		if row.ZCase == "Zm_o" || row.ZCase == "Zib_" {
+			destination = ""
+		}
+		result = append(result, X86ScalarRMWWitness{Instruction: instruction, Destination: destination, Encoding: encoding})
+	}
+	return result, nil
+}
diff --git a/internal/goasmrules/x86_witness_state_system_memory_test.go b/internal/goasmrules/x86_witness_state_system_memory_test.go
new file mode 100644
index 000000000..99efba48a
--- /dev/null
+++ b/internal/goasmrules/x86_witness_state_system_memory_test.go
@@ -0,0 +1,375 @@
+package goasmrules
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func stateSystemOriginalUnaryDestinations(t *testing.T) map[string]bool {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/obj6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	result := map[string]bool{}
+	for _, declaration := range file.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		for _, spec := range group.Specs {
+			value, ok := spec.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || value.Names[0].Name != "unaryDst" || len(value.Values) != 1 {
+				continue
+			}
+			literal, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok {
+				t.Fatal("original unaryDst is not a complete source literal")
+			}
+			for _, element := range literal.Elts {
+				pair := element.(*ast.KeyValueExpr)
+				key, setting := pair.Key.(*ast.Ident), pair.Value.(*ast.Ident)
+				if !strings.HasPrefix(key.Name, "A") || setting.Name != "true" && setting.Name != "false" {
+					t.Fatal("original unaryDst key/value changed", element)
+				}
+				result[strings.TrimPrefix(key.Name, "A")] = setting.Name == "true"
+			}
+		}
+	}
+	if len(result) == 0 {
+		t.Fatal("actual SDK has no captured unaryDst source roles")
+	}
+	return result
+}
+
+// Inventory complete source tables, including their already joined numeric
+// users. Shared encodings supply no machine-state, memory or native permission.
+func stateSystemOriginalSchema(table string) []string {
+	switch table {
+	case "yclflush", "ysvrs_om":
+		return []string{"Zo_m/2/Ym"}
+	case "ysvrs_mo", "yprefetch":
+		return []string{"Zm_o/2/Ym"}
+	case "ydivb":
+		return []string{"Zm_o/2/Ymb"}
+	case "ydivl":
+		return []string{"Zm_o/2/Yml"}
+	case "yincq":
+		return []string{"Zo_m/2/Yml"}
+	case "ywrfsbase":
+		return []string{"Zm_o/2/Yrl"}
+	case "yrdrand":
+		return []string{"Zo_m/2/Yrl"}
+	case "yrl_m":
+		return []string{"Zr_m/1/Yrl,Ym"}
+	case "yrl_ml":
+		return []string{"Zr_m/1/Yrl,Yml"}
+	case "ym_rl":
+		return []string{"Zm_r/1/Ym,Yrl"}
+	case "ycrc32l":
+		return []string{"Zlitm_r/0/Yml,Yrl"}
+	case "yin":
+		return []string{"Zib_/1/Yi32", "Zlit/1/"}
+	case "yint":
+		return []string{"Zib_/1/Yi32"}
+	case "yxabort":
+		return []string{"Zib_/1/Yu8"}
+	case "yxbegin":
+		return []string{"Zjmp/1/Ybr"}
+	}
+	return nil
+}
+
+func stateSystemOriginalEntries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]int{
+		"yclflush": 15, "ysvrs_mo": 9, "ysvrs_om": 6, "yin": 12,
+		"yint": 1, "ydivl": 20, "ydivb": 5, "ywrfsbase": 7,
+		"ycrc32l": 7, "yprefetch": 4, "yincq": 13, "yrdrand": 10,
+		"ym_rl": 12, "yrl_m": 2, "yrl_ml": 10, "yxbegin": 1, "yxabort": 1,
+	}
+	var entries []X86LegacyOpcode
+	counts, seen, total := map[string]int{}, map[string]bool{}, 0
+	for _, entry := range catalog.Optab {
+		schema := stateSystemOriginalSchema(entry.Ytab)
+		if schema == nil {
+			continue
+		}
+		if entry.Kind != "encoding" || seen[entry.Opcode] || len(entry.Rows) != len(schema) {
+			t.Fatal("complete state/system original entry changed", entry)
+		}
+		seen[entry.Opcode] = true
+		if entry.Opcode == "RDPID" {
+			want["yrdrand"]++
+		}
+		offset := 0
+		for index, row := range entry.Rows {
+			parts := strings.Split(schema[index], "/")
+			classes := []string{}
+			if parts[2] != "" {
+				classes = strings.Split(parts[2], ",")
+			}
+			shape := fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ","))
+			if row.RowIndex != index || row.UnmatchedOffset != offset || shape != schema[index] ||
+				!reflect.DeepEqual(row.Classes, classes) {
+				t.Fatal("complete state/system original row changed", entry, row)
+			}
+			offset += row.ZOffset + entry.EscapeAdjustment
+			counts[entry.Ytab]++
+			total++
+		}
+		entries = append(entries, entry)
+	}
+	rows, entryCount := 135, 129
+	if seen["RDPID"] {
+		rows++
+		entryCount++
+	}
+	if total != rows || len(entries) != entryCount || !reflect.DeepEqual(counts, want) {
+		t.Fatal("complete state/system source denominator changed", total, len(entries), counts, want)
+	}
+	return entries
+}
+
+func TestX86StateSystemMemoryCompleteOriginalInventory(t *testing.T) {
+	stateSystemOriginalEntries(t)
+}
+
+func TestX86StateSystemMemoryRequiresCompleteSourceOrigin(t *testing.T) {
+	original, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	frontend, err := LoadX86UnaryDestinations(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for index := 0; index < reflect.TypeOf(frontend).NumField(); index++ {
+		if reflect.TypeOf(frontend).Field(index).PkgPath == "" {
+			t.Fatal("caller can modify captured frontend roles directly")
+		}
+	}
+	if _, err := X86StateSystemMemoryRows(original, frontend, "amd64"); err != nil {
+		t.Fatal("original complete source is a prerequisite", err)
+	}
+	for _, mutation := range []string{"duplicate-member", "missing-complete-table", "incomplete-frontend", "zero-frontend", "missing-enum", "renamed-missing-enum", "retag-member", "swap-member-names", "changed-member-payload"} {
+		t.Run(mutation, func(t *testing.T) {
+			catalog := original
+			catalog.Optab = append([]X86LegacyOpcode(nil), original.Optab...)
+			roles := frontend
+			first, replacement := -1, X86LegacyOpcode{}
+			for index, entry := range original.Optab {
+				if entry.Ytab == "yclflush" {
+					if first < 0 {
+						first = index
+					} else {
+						replacement = entry
+						break
+					}
+				}
+			}
+			if first < 0 || replacement.Opcode == "" {
+				t.Fatal("complete source counterexample lost its original members")
+			}
+			switch mutation {
+			case "duplicate-member":
+				replacement.TableIndex = first
+				catalog.Optab[first] = replacement
+			case "missing-complete-table":
+				for _, entry := range original.Optab {
+					if entry.Ytab == "ydivb" {
+						replacement = entry
+						break
+					}
+				}
+				for index, entry := range original.Optab {
+					if entry.Ytab == "yprefetch" {
+						copy := replacement
+						copy.TableIndex = index
+						copy.Opcode = fmt.Sprintf("SOURCE%d", index)
+						copy.OpcodeExpression = "A" + copy.Opcode
+						catalog.Optab[index] = copy
+					}
+				}
+			case "incomplete-frontend":
+				roles = X86UnaryDestinations{roles: map[string]bool{"NOP": true}}
+			case "zero-frontend":
+				roles = X86UnaryDestinations{}
+			case "missing-enum", "renamed-missing-enum":
+				found := false
+				for index, entry := range catalog.Optab {
+					if entry.Opcode == "CLFLUSH" {
+						entry.OpcodeExpression = ""
+						if mutation == "renamed-missing-enum" {
+							entry.Opcode = "CAPTURED_FAKE_FLUSH"
+						}
+						catalog.Optab[index], found = entry, true
+						break
+					}
+				}
+				if !found {
+					t.Fatal("original CLFLUSH counterexample disappeared")
+				}
+			case "retag-member", "swap-member-names", "changed-member-payload":
+				prefetch, move := -1, -1
+				for index, entry := range catalog.Optab {
+					if entry.Opcode == "PREFETCHT0" {
+						prefetch = index
+					}
+					if entry.Opcode == "MOVL" {
+						move = index
+					}
+				}
+				if prefetch < 0 || move < 0 {
+					t.Fatal("original source member relabeling controls disappeared")
+				}
+				first, second := catalog.Optab[prefetch], catalog.Optab[move]
+				if mutation == "changed-member-payload" {
+					first = stateSystemClone(first)
+					first.OpBytes[0] = "0x19"
+					catalog.Optab[prefetch] = first
+					break
+				}
+				if mutation == "swap-member-names" {
+					second.Opcode, second.OpcodeExpression = first.Opcode, first.OpcodeExpression
+					catalog.Optab[move] = second
+				}
+				first.Opcode, first.OpcodeExpression = "MOVL", "AMOVL"
+				catalog.Optab[prefetch] = first
+			}
+			if rows, err := X86StateSystemMemoryRows(catalog, roles, "amd64"); err == nil {
+				t.Fatal("incomplete original source was admitted", mutation, len(rows))
+			}
+		})
+	}
+}
+
+// The first RED uses the existing helper. A refusal here identifies a missing
+// complete source projection, not a numerical or privileged execution bug.
+func TestX86StateSystemMemoryExistingTransportCompleteOriginalRows(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	unary := stateSystemOriginalUnaryDestinations(t)
+	frontend := 0
+	for _, entry := range stateSystemOriginalEntries(t) {
+		for _, row := range entry.Rows {
+			for _, arch := range []string{"amd64", "386"} {
+				if arch == "amd64" && entry.Prefix == "P32" ||
+					arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Pfw") {
+					continue // Original row retained; separate actual-Go mode refusals below.
+				}
+				if (row.ZCase == "Zm_o" || row.ZCase == "Zo_m") && unary[entry.Opcode] != (row.ZCase == "Zo_m") {
+					frontend++
+					t.Logf("ORIGINAL_FRONTEND_SLOT_REJECTION %s %s/%d: unaryDst disagrees with %s, retained in the complete inventory", arch, entry.Opcode, row.RowIndex, row.ZCase)
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, entry.Opcode, row.RowIndex), func(t *testing.T) {
+					witnesses, err := x86StateSystemMemoryWitnesses(entry, row, catalog.OpBytesSize)
+					if err != nil || len(witnesses) == 0 {
+						t.Fatal("complete source transport feature missing", entry.Ytab, row, err)
+					}
+					old, oldErr := x86ScalarRMWRowWitnesses(entry, row, arch)
+					t.Logf("STATE_SYSTEM_OLD_CONSUMER %s/%s/%d accepted=%t", arch, entry.Opcode, row.RowIndex, oldErr == nil && len(old) != 0)
+				})
+			}
+		}
+	}
+	if frontend != 2 {
+		t.Fatal("original per-mode frontend slot boundary changed", frontend)
+	}
+}
+
+func stateSystemClone(entry X86LegacyOpcode) X86LegacyOpcode {
+	entry.OpBytes = append([]string(nil), entry.OpBytes...)
+	entry.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+	for index := range entry.Rows {
+		entry.Rows[index].Classes = append([]string(nil), entry.Rows[index].Classes...)
+	}
+	return entry
+}
+
+// Keep old-consumer observations even when the new projection is added. A
+// malformed rejection alone is not evidence that the corresponding original
+// source row was accepted: the independent positive owner above supplies that.
+func TestX86StateSystemMemoryCompleteOriginalMetadataBoundaries(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range stateSystemOriginalEntries(t) {
+		for _, selected := range original.Rows {
+			t.Run(fmt.Sprintf("%s/%d", original.Opcode, selected.RowIndex), func(t *testing.T) {
+				for _, mutation := range []string{
+					"negative-escape", "overflow-escape", "negative-selected-index",
+					"past-selected-index", "original-index", "original-class",
+					"selected-class", "selected-arity", "selected-offset",
+					"original-stride", "nonbyte-tail", "enum-identity", "enum-missing",
+				} {
+					entry := stateSystemClone(original)
+					row := entry.Rows[selected.RowIndex]
+					switch mutation {
+					case "negative-escape", "overflow-escape":
+						entry.EscapeAdjustment = -3
+						if mutation == "overflow-escape" {
+							entry.EscapeAdjustment = int(^uint(0) >> 1)
+						}
+						offset := 0
+						for index := range entry.Rows {
+							entry.Rows[index].UnmatchedOffset = offset
+							offset += entry.Rows[index].ZOffset + entry.EscapeAdjustment
+						}
+						row = entry.Rows[selected.RowIndex]
+					case "negative-selected-index":
+						row.RowIndex = -1
+					case "past-selected-index":
+						row.RowIndex = len(entry.Rows)
+					case "original-index":
+						entry.Rows[0].RowIndex = -1
+					case "original-class":
+						entry.Rows[0].Classes = []string{"Yinvalid"}
+					case "selected-class":
+						row.Classes = []string{"Yinvalid"}
+					case "selected-arity":
+						row.Classes = append(append([]string(nil), row.Classes...), "Ynone")
+					case "selected-offset":
+						row.UnmatchedOffset = -1
+					case "original-stride":
+						entry.Rows[0].ZOffset = -1
+					case "nonbyte-tail":
+						entry.OpBytes[len(entry.OpBytes)-1] = "256"
+					case "enum-identity":
+						entry.OpcodeExpression = "ANOP"
+					case "enum-missing":
+						entry.OpcodeExpression = ""
+					}
+					func() {
+						defer func() {
+							if value := recover(); value != nil {
+								t.Errorf("%s panicked: %v", mutation, value)
+							}
+						}()
+						if witnesses, err := x86ScalarRMWRowWitnesses(entry, row, "amd64"); mutation != "enum-missing" && err == nil {
+							t.Errorf("%s admitted damaged captured source: %+v", mutation, witnesses)
+						}
+						if witnesses, err := x86StateSystemMemoryWitnesses(entry, row, catalog.OpBytesSize); err == nil {
+							t.Errorf("%s admitted damaged source in the new projection: %+v", mutation, witnesses)
+						}
+					}()
+				}
+			})
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_two_source_immediate_test.go b/internal/goasmrules/x86_witness_two_source_immediate_test.go
new file mode 100644
index 000000000..7930e4659
--- /dev/null
+++ b/internal/goasmrules/x86_witness_two_source_immediate_test.go
@@ -0,0 +1,255 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86TwoSourceImmediateShuffleTestNames = "PALIGNR VPALIGNR SHUFPD VSHUFPD SHUFPS VSHUFPS"
+
+func TestX86TwoSourceImmediateShuffleLegacyPrefixBoundaries(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	checked := 0
+	for _, entry := range legacy.Optab {
+		if entry.Opcode != "PALIGNR" && entry.Opcode != "SHUFPS" && entry.Opcode != "SHUFPD" {
+			continue
+		}
+		for _, prefix := range []string{"Pq", "Pm", "Pf2", "Pf3"} {
+			if prefix == entry.Prefix {
+				continue
+			}
+			t.Run(entry.Opcode+"/"+prefix, func(t *testing.T) {
+				if _, err := x86PackedLegacyRowWitnesses(entry, entry.Rows[0]); err != nil {
+					t.Fatal("negative requires its valid original row", err)
+				}
+				bad := entry
+				bad.Prefix = prefix
+				if _, err := x86PackedLegacyRowWitnesses(bad, entry.Rows[0]); err == nil {
+					t.Fatal("foreign legacy immediate prefix accepted", bad)
+				}
+			})
+			checked++
+		}
+	}
+	if checked != 9 {
+		t.Fatal("legacy prefix negative denominator changed", checked)
+	}
+}
+
+func TestX86TwoSourceImmediateShuffleCompleteOriginalRows(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	for _, name := range strings.Fields(x86TwoSourceImmediateShuffleTestNames) {
+		names[name] = true
+	}
+	type original struct {
+		kind    string
+		classes []string
+		masked  bool
+	}
+	originals := map[string]original{}
+	for _, entry := range legacy.Optab {
+		if !names[entry.Opcode] {
+			continue
+		}
+		for _, row := range entry.Rows {
+			if strings.Join(row.Classes, ",") != "Yu8,Yxm,Yxr" || row.ZCase != "Zibm_r" || row.RowIndex != 0 {
+				t.Fatal("legacy two-source immediate acquired a foreign/MMX row", entry, row)
+			}
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			originals[id] = original{"legacy", row.Classes, false}
+		}
+	}
+	for index, row := range avx {
+		if !names[row.Opcode] {
+			continue
+		}
+		kind := "vex"
+		if strings.HasPrefix(row.ZCase, "Zevex_") {
+			kind = "evex"
+		}
+		id := fmt.Sprintf("avx/%d/%s/%s/%d", index, row.Opcode, row.Ytab, row.RowIndex)
+		originals[id] = original{kind, row.Classes, row.ZCase == "Zevex_i_rm_v_k_r"}
+	}
+	if len(originals) != 27 {
+		t.Fatal("complete six-name original source denominator changed", len(originals))
+	}
+	// Existing helper only: do not manufacture missing-API compile RED.
+	rows, err := x86PackedBinaryRows(legacy, avx, x86TwoSourceImmediateShuffleTestNames)
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen, instructions := map[string]bool{}, map[string]bool{}
+	rowKinds, formats, widths := map[string]int{}, map[string]int{}, map[int]int{}
+	masked, zeroing, broadcast, memory := 0, 0, 0, 0
+	for _, row := range rows {
+		from, found := originals[row.ID]
+		if !found || seen[row.ID] {
+			t.Fatal("two-source immediate lost original row identity", row)
+		}
+		seen[row.ID] = true
+		rowKinds[from.kind]++
+		width := map[string]int{"Yxm": 128, "Yym": 256, "YxmEvex": 128, "YymEvex": 256, "Yzm": 512}[from.classes[1]]
+		bank := map[int]string{128: "X", 256: "Y", 512: "Z"}[width]
+		first, second, destination := bank+"0", bank+"1", bank+"2"
+		if from.kind == "legacy" {
+			destination = "X1"
+		}
+		if from.kind == "evex" {
+			first, second, destination = bank+"16", bank+"17", bank+"18"
+		}
+		for _, w := range row.Witnesses {
+			fields := strings.Fields(w.Instruction)
+			if len(fields) != 2 {
+				t.Fatal("lost source syntax", w)
+			}
+			args := strings.Split(fields[1], ",")
+			count := 4
+			if from.kind == "legacy" {
+				count = 3
+			}
+			if w.Masked {
+				count++
+			}
+			if len(args) != count {
+				t.Fatal("lost source arity", row.ID, w)
+			}
+			if instructions[w.Instruction] || args[0] != "$7" || w.First != args[1] || w.First != first && w.First != "(AX)" || w.Second != second || w.Destination != destination || args[len(args)-1] != destination ||
+				w.Width != width || w.Generation != from.kind || w.MaskResult || w.Masked != from.masked || w.Masked && args[len(args)-2] != "K1" ||
+				w.Memory != (w.First == "(AX)") || w.Zeroing != strings.HasSuffix(fields[0], ".Z") || w.Zeroing && !w.Masked ||
+				w.Broadcast != strings.Contains(fields[0], ".BCST") || w.Broadcast && (!w.Memory || from.kind != "evex" || row.Opcode == "VPALIGNR") ||
+				len(w.Encoding) < 4 || w.Encoding[len(w.Encoding)-1] != 7 {
+				t.Fatal("immediate/source/legacy-RMW/width/mask roles were conflated", row.ID, w)
+			}
+			// Legacy SHUF/PALIGNR reads the literal second operand as data;
+			// unary PSHUFD/HW/LW still has its existing empty Second metadata.
+			if from.kind == "legacy" && w.Second != w.Destination {
+				t.Fatal("legacy old destination was erased", row.ID, w)
+			}
+			instructions[w.Instruction] = true
+			formats[from.kind]++
+			widths[width]++
+			if w.Masked {
+				masked++
+			}
+			if w.Zeroing {
+				zeroing++
+			}
+			if w.Broadcast {
+				broadcast++
+			}
+			if w.Memory {
+				memory++
+			}
+		}
+	}
+	if len(rows) != 27 || len(seen) != len(originals) || len(instructions) != 90 || rowKinds["legacy"] != 3 || rowKinds["vex"] != 6 || rowKinds["evex"] != 18 ||
+		formats["legacy"] != 6 || formats["vex"] != 12 || formats["evex"] != 72 || widths[128] != 36 || widths[256] != 30 || widths[512] != 24 || masked != 48 || zeroing != 24 || broadcast != 18 || memory != 54 {
+		t.Fatal("complete two-source immediate denominator changed", len(rows), len(instructions), rowKinds, formats, widths, masked, zeroing, broadcast, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"PALIGNR $7,X0,X1", []byte{0x66, 0x0f, 0x3a, 0x0f, 0xc8, 0x07}},
+		{"SHUFPS $7,(AX),X1", []byte{0x0f, 0xc6, 0x08, 0x07}},
+		{"SHUFPD $7,X0,X1", []byte{0x66, 0x0f, 0xc6, 0xc8, 0x07}},
+		{"VPALIGNR $7,Y0,Y1,Y2", []byte{0xc4, 0xe3, 0x75, 0x0f, 0xd0, 0x07}},
+		{"VPALIGNR.Z $7,X16,X17,K1,X18", []byte{0x62, 0xa3, 0x75, 0x81, 0x0f, 0xd0, 0x07}},
+		{"VSHUFPS.BCST.Z $7,(AX),Z17,K1,Z18", []byte{0x62, 0xe1, 0x74, 0xd1, 0xc6, 0x10, 0x07}},
+		{"VSHUFPD.BCST $7,(AX),Y17,Y18", []byte{0x62, 0xe1, 0xf5, 0x30, 0xc6, 0x10, 0x07}},
+	})
+}
+
+func TestX86TwoSourceImmediateShuffleRejectsForeignFormatAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"PAL BCST", "PAL W1", "PAL map", "PAL no66", "PS BCST8", "PS prefix", "PS W1", "PD BCST4", "PD W0", "signed immediate", "source carrier", "data carrier", "K result", "K0 writemask", "tuple", "rounding", "SAE", "offset", "row index", "opcode extent"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VSHUFPS", 2
+			if strings.HasPrefix(mutation, "PAL ") {
+				name = "VPALIGNR"
+			}
+			if strings.HasPrefix(mutation, "PD ") {
+				name = "VSHUFPD"
+			}
+			if mutation == "K0 writemask" {
+				index = 3
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				if _, err := x86PackedAVXRowWitnesses(original); err != nil {
+					t.Fatal("negative requires its valid original row", original, err)
+				}
+				row := original
+				row.Classes = append([]string(nil), row.Classes...)
+				row.OpBytes = append([]string(nil), row.OpBytes...)
+				header, feature := row.EncodingOffset, row.EncodingOffset+1
+				switch mutation {
+				case "PAL BCST":
+					row.OpBytes[feature] += "|evexBcstN8"
+				case "PAL W1", "PS W1":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW0", "evexW1", 1)
+				case "PAL map":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex0F3A", "evex0F38", 1)
+				case "PAL no66":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evex66", "", 1)
+				case "PS BCST8":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexBcstN4", "evexBcstN8", 1)
+				case "PS prefix":
+					row.OpBytes[header] += "|evex66"
+				case "PD BCST4":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexBcstN8", "evexBcstN4", 1)
+				case "PD W0":
+					row.OpBytes[header] = strings.Replace(row.OpBytes[header], "evexW1", "evexW0", 1)
+				case "signed immediate":
+					row.Classes[0] = "Yi8"
+				case "source carrier":
+					row.Classes[1] = "YymEvex"
+				case "data carrier":
+					row.Classes[2] = "YyrEvex"
+				case "K result":
+					row.Classes[len(row.Classes)-1] = "Yk"
+				case "K0 writemask":
+					row.Classes[3] = "Yk"
+				case "tuple":
+					row.OpBytes[feature] = strings.Replace(row.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "rounding":
+					row.OpBytes[feature] += "|evexRoundingEnabled"
+				case "SAE":
+					row.OpBytes[feature] += "|evexSaeEnabled"
+				case "offset":
+					row.EncodingOffset++
+				case "row index":
+					row.RowIndex++
+				case "opcode extent":
+					row.OpBytes[header+2] = "256"
+				}
+				if fmt.Sprint(row) == fmt.Sprint(original) {
+					t.Fatal("negative did not change its original row", mutation)
+				}
+				if _, err := x86PackedAVXRowWitnesses(row); err == nil {
+					t.Fatal("two-source immediate borrowed a foreign format", mutation, row)
+				}
+			}
+			if found != 1 {
+				t.Fatal("negative lost its exact original row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_unary_memory.go b/internal/goasmrules/x86_witness_unary_memory.go
new file mode 100644
index 000000000..291e35026
--- /dev/null
+++ b/internal/goasmrules/x86_witness_unary_memory.go
@@ -0,0 +1,55 @@
+package goasmrules
+
+import "fmt"
+
+// A unary vector memory alternative has independent encoded width, register
+// carrier and tuple. Direction owns operand transport, never memory authority.
+type x86PackedUnaryMemoryFormat struct {
+	width, tuple, carrier int
+	masked, store         bool
+	encoding              x86PackedAVXOpcode
+}
+
+func (f x86PackedUnaryMemoryFormat) witnesses(opcode string) []X86PackedBinaryWitness {
+	bank := 16
+	if f.encoding.kind == "vex" {
+		bank = 0
+	}
+	source := fmt.Sprint(map[int]string{128: "X", 256: "Y", 512: "Z"}[f.width], bank)
+	destination := fmt.Sprint(map[int]string{16: "X", 32: "Y", 64: "Z"}[f.carrier], bank+2)
+	var witnesses []X86PackedBinaryWitness
+	for _, memory := range []bool{false, true} {
+		first, last, modrm := source, destination, byte(0xd0)
+		if f.store {
+			modrm = 0xc2
+		}
+		p0 := byte(0xa0)
+		if memory {
+			p0 = 0xe0
+			if f.store {
+				last, modrm = "(AX)", 0
+			} else {
+				first, modrm = "(AX)", 0x10
+			}
+		}
+		for _, zeroing := range []bool{false, true} {
+			if zeroing && !f.masked {
+				continue
+			}
+			operands, suffix, p2 := first+","+last, "", f.encoding.length<<5|8
+			if f.masked {
+				operands, p2 = first+",K1,"+last, p2|1
+			}
+			if zeroing {
+				suffix, p2 = ".Z", p2|0x80
+			}
+			witnesses = append(witnesses, X86PackedBinaryWitness{
+				Instruction: opcode + suffix + " " + operands, Generation: f.encoding.kind,
+				First: first, Destination: last, Width: f.width, Memory: !f.store && memory,
+				Masked: f.masked, Zeroing: zeroing,
+				Encoding: f.encoding.bytes(0x78, p0, p2, modrm),
+			})
+		}
+	}
+	return witnesses
+}
diff --git a/internal/goasmrules/x86_witness_uniform_controls_test.go b/internal/goasmrules/x86_witness_uniform_controls_test.go
new file mode 100644
index 000000000..9c73a0eb8
--- /dev/null
+++ b/internal/goasmrules/x86_witness_uniform_controls_test.go
@@ -0,0 +1,116 @@
+package goasmrules
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86UniformByteShiftRejectsUnknownAVXFormatAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	seed := func(op string, row int) X86AVXRule {
+		for _, rule := range rules {
+			if rule.Opcode == op && rule.RowIndex == row {
+				rule.Classes = append([]string(nil), rule.Classes...)
+				rule.OpBytes = append([]string(nil), rule.OpBytes...)
+				return rule
+			}
+		}
+		t.Fatalf("original official row absent: %s/%d", op, row)
+		return X86AVXRule{}
+	}
+	for _, row := range []struct {
+		name, op string
+		index    int
+		change   func(*X86AVXRule)
+	}{
+		{"extension-is-not-register", "VPSLLD", 9, func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+3] = "8" }},
+		{"unmasked-row-stride", "VPSLLD", 8, func(r *X86AVXRule) { r.ZOffset = 4 }},
+		{"uniform-m128-not-data-width", "VPSLLD", 14, func(r *X86AVXRule) {
+			r.OpBytes[r.EncodingOffset+1] = strings.ReplaceAll(r.OpBytes[r.EncodingOffset+1], "evexN16", "evexN32")
+		}},
+		{"uniform-count-not-Y", "VPSLLD", 14, func(r *X86AVXRule) { r.Classes[0] = "YymEvex" }},
+		{"uniform-count-no-BCST", "VPSLLD", 14, func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += " | evexBcstN4" }},
+		{"VPSRAQ-count-independent-data-width", "VPSRAQ", 8, func(r *X86AVXRule) { r.Classes[1] = "YxrEvex" }},
+		{"VEX-immediate-register-only", "VPSLLD", 0, func(r *X86AVXRule) { r.Classes[1] = "Yxm" }},
+		{"EVEX-immediate-unsigned-only", "VPSLLD", 6, func(r *X86AVXRule) { r.Classes[0] = "Yi8" }},
+		{"nonzero-mask-class", "VPSLLD", 7, func(r *X86AVXRule) { r.Classes[2] = "Yk" }},
+		{"byte-no-mask", "VPSLLDQ", 4, func(r *X86AVXRule) {
+			r.ZCase = "Zevex_i_rm_k_vo"
+			r.Classes = []string{"Yu8", "YxmEvex", "Yknot0", "YxrEvex"}
+		}},
+		{"byte-immediate-only", "VPSLLDQ", 4, func(r *X86AVXRule) {
+			r.ZCase, r.ZOffset = "Zevex_rm_v_r", 3
+			r.Classes = []string{"YxmEvex", "YxrEvex", "YxrEvex"}
+		}},
+		{"byte-no-BCST", "VPSLLDQ", 4, func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += " | evexBcstN4" }},
+		{"byte-no-zeroing", "VPSLLDQ", 4, func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset+1] += " | evexZeroingEnabled" }},
+		{"byte-W0", "VPSLLDQ", 4, func(r *X86AVXRule) {
+			r.OpBytes[r.EncodingOffset] = strings.ReplaceAll(r.OpBytes[r.EncodingOffset], "evexW0", "evexW1")
+		}},
+		{"VEX-W0", "VPSLLD", 0, func(r *X86AVXRule) {
+			r.OpBytes[r.EncodingOffset] = strings.ReplaceAll(r.OpBytes[r.EncodingOffset], "vexW0", "vexW1")
+		}},
+		{"unknown-header-atom", "VPSLLD", 6, func(r *X86AVXRule) { r.OpBytes[r.EncodingOffset] += " | evexUnaudited" }},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			rule := seed(row.op, row.index)
+			row.change(&rule)
+			if witnesses, err := x86PackedAVXRowWitnesses(rule); err == nil || len(witnesses) != 0 {
+				t.Fatal("unmodeled official format returned partial or accepted witnesses", witnesses, err)
+			}
+		})
+	}
+}
+
+func TestX86UniformByteShiftRejectsUnknownLegacyFormatAxes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, control := range []string{"extension", "prefix", "payload", "offset", "class", "byte-extension"} {
+		t.Run(control, func(t *testing.T) {
+			op, index := "PSLLL", 3
+			if control == "byte-extension" {
+				op, index = "PSLLO", 0
+			}
+			found := 0
+			for _, entry := range catalog.Optab {
+				if entry.Opcode != op {
+					continue
+				}
+				for _, row := range entry.Rows {
+					if row.RowIndex != index {
+						continue
+					}
+					found++
+					entry.OpBytes = append([]string(nil), entry.OpBytes...)
+					row.Classes = append([]string(nil), row.Classes...)
+					switch control {
+					case "extension":
+						entry.OpBytes[2], entry.OpBytes[7] = "8", "8"
+					case "prefix":
+						entry.OpBytes[5] = "Pm"
+					case "payload":
+						entry.OpBytes = append(entry.OpBytes, "0")
+					case "offset":
+						row.UnmatchedOffset++
+					case "class":
+						row.Classes[1] = "Yxm"
+					case "byte-extension":
+						entry.OpBytes[1] = "8"
+					}
+					if witnesses, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+						t.Fatal("unmodeled complete legacy row returned witnesses", witnesses, err)
+					}
+				}
+			}
+			if found != 1 {
+				t.Fatal("missing or repeated original official row", found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_uniform_transport_test.go b/internal/goasmrules/x86_witness_uniform_transport_test.go
new file mode 100644
index 000000000..80162dcc6
--- /dev/null
+++ b/internal/goasmrules/x86_witness_uniform_transport_test.go
@@ -0,0 +1,187 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These tests intentionally call the existing row transport entry points.
+// Before the shared format is implemented, they must fail on its missing
+// format, rather than require an undefined future helper to compile.
+func TestX86UniformByteShiftImmediateOpcodeExtensionAnchors(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, anchor := range []struct {
+		opcode, instruction string
+		row                 int
+		encoding            []byte
+	}{
+		{"VPSLLD", "VPSLLD $7,X0,X2", 0, []byte{0xc5, 0xe9, 0x72, 0xf0, 7}},
+		{"VPSLLD", "VPSLLD $-1,X0,X2", 1, []byte{0xc5, 0xe9, 0x72, 0xf0, 255}},
+		{"VPSLLD", "VPSLLD $7,X16,X18", 6, []byte{0x62, 0xb1, 0x6d, 0x00, 0x72, 0xf0, 7}},
+		{"VPSLLD", "VPSLLD.BCST.Z $7,(AX),K1,Y18", 9, []byte{0x62, 0xf1, 0x6d, 0xb1, 0x72, 0x30, 7}},
+		{"VPSRLQ", "VPSRLQ X16,Z17,K1,Z18", 17, []byte{0x62, 0xa1, 0xf5, 0x41, 0xd3, 0xd0}},
+		{"VPSLLDQ", "VPSLLDQ $7,(AX),Z18", 6, []byte{0x62, 0xf1, 0x6d, 0x40, 0x73, 0x38, 7}},
+	} {
+		t.Run(anchor.instruction, func(t *testing.T) {
+			found := 0
+			for _, rule := range rules {
+				if rule.Opcode != anchor.opcode || rule.RowIndex != anchor.row {
+					continue
+				}
+				witnesses, err := x86PackedAVXRowWitnesses(rule)
+				if err != nil {
+					t.Fatal("official shift format is not transported", err)
+				}
+				for _, witness := range witnesses {
+					if witness.Instruction != anchor.instruction {
+						continue
+					}
+					found++
+					if !bytes.Equal(witness.Encoding, anchor.encoding) {
+						t.Fatalf("opcode extension/vvvv transport: got %x, want %x", witness.Encoding, anchor.encoding)
+					}
+					if strings.HasPrefix(strings.Fields(witness.Instruction)[1], "$") &&
+						(strings.HasPrefix(witness.First, "$") || witness.Second != "") {
+						t.Fatal("immediate became a loaded register or fictitious second input", witness)
+					}
+				}
+			}
+			if found != 1 {
+				t.Fatal("missing or repeated independent official row witness", found)
+			}
+		})
+	}
+}
+
+func TestX86UniformByteShiftCompleteOfficialAVXTransport(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, widths := map[string]bool{}, map[int]int{}
+	rows, formats := map[string]int{}, map[string]int{}
+	single, broadcast := 0, 0
+	for _, rule := range rules {
+		if rule.Ytab != "_yvpslld" && rule.Ytab != "_yvpsraq" && rule.Ytab != "_yvpslldq" {
+			continue
+		}
+		names[rule.Opcode] = true
+		t.Run(fmt.Sprintf("%s/%s/%d", rule.Opcode, rule.Ytab, rule.RowIndex), func(t *testing.T) {
+			witnesses, err := x86PackedAVXRowWitnesses(rule)
+			if err != nil || len(witnesses) == 0 {
+				t.Fatal("complete official row has no concrete transport", err)
+			}
+			generation := witnesses[0].Generation
+			rows[generation]++
+			if len(witnesses) == 1 {
+				single++
+			}
+			for _, witness := range witnesses {
+				formats[generation]++
+				widths[witness.Width]++
+				if witness.Broadcast {
+					broadcast++
+				}
+				// Uniform register counts are always X/m128, even when
+				// their independent data and destination carriers are Y/Z.
+				immediate := rule.Classes[0] == "Yi8" || rule.Classes[0] == "Yu8"
+				if !immediate && witness.First != "(AX)" &&
+					(witness.First != "X0" && witness.First != "X16") {
+					t.Fatal("uniform count inherited its data carrier width", witness)
+				}
+			}
+		})
+	}
+	if len(names) != 11 || !reflect.DeepEqual(rows, map[string]int{"vex": 56, "evex": 114}) ||
+		!reflect.DeepEqual(formats, map[string]int{"vex": 72, "evex": 390}) ||
+		!reflect.DeepEqual(widths, map[int]int{128: 166, 256: 166, 512: 130}) || single != 40 || broadcast != 54 {
+		t.Fatal("complete official AVX denominator drift", len(names), rows, formats, widths, single, broadcast)
+	}
+}
+
+func TestX86UniformByteShiftCompleteOfficialLegacyTransport(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := map[string]bool{}
+	rows, formats, single, mmx := 0, 0, 0, 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yps" && entry.Ytab != "ypsdq" {
+			continue
+		}
+		names[entry.Opcode] = true
+		for _, row := range entry.Rows {
+			if strings.Join(row.Classes, ",") == "Ymm,Ymr" || strings.Join(row.Classes, ",") == "Yi8,Ymr" {
+				mmx++ // Separate physical region/EMMS/mode owner; not passed here.
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%s/%d", entry.Opcode, entry.Ytab, row.RowIndex), func(t *testing.T) {
+				witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+				if err != nil || len(witnesses) == 0 {
+					t.Fatal("complete original XMM row has no concrete transport", err)
+				}
+				rows++
+				formats += len(witnesses)
+				if len(witnesses) == 1 {
+					single++
+				}
+				for _, witness := range witnesses {
+					if witness.Generation != "legacy" || witness.Width != 128 || witness.Second != witness.Destination {
+						t.Fatal("legacy count/data/RMW identity changed", witness)
+					}
+				}
+			})
+		}
+	}
+	if len(names) != 10 || rows != 18 || formats != 26 || single != 10 || mmx != 16 {
+		t.Fatal("complete XMM rows or separate MMX denominator drift", len(names), rows, formats, single, mmx)
+	}
+}
+
+func TestX86UniformByteShiftLegacyImmediateExtensionAnchors(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, anchor := range []struct {
+		opcode string
+		row    int
+		bytes  []byte
+	}{
+		{"PSLLL", 3, []byte{0x66, 0x0f, 0x72, 0xf1, 255}},
+		{"PSLLO", 0, []byte{0x66, 0x0f, 0x73, 0xf9, 255}},
+	} {
+		t.Run(anchor.opcode, func(t *testing.T) {
+			found := 0
+			for _, entry := range catalog.Optab {
+				if entry.Opcode != anchor.opcode {
+					continue
+				}
+				for _, row := range entry.Rows {
+					if row.RowIndex != anchor.row {
+						continue
+					}
+					witnesses, err := x86PackedLegacyRowWitnesses(entry, row)
+					if err != nil || len(witnesses) != 1 {
+						t.Fatal("legacy immediate has no exact one-row transport", err)
+					}
+					found++
+					if !bytes.Equal(witnesses[0].Encoding, anchor.bytes) || witnesses[0].First != "" || witnesses[0].Second != "X1" {
+						t.Fatal("legacy immediate acquired a fictitious first read or wrong /digit", witnesses)
+					}
+				}
+			}
+			if found != 1 {
+				t.Fatal("missing or repeated original legacy immediate row", found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_unpack_test.go b/internal/goasmrules/x86_witness_unpack_test.go
new file mode 100644
index 000000000..f6f09feb8
--- /dev/null
+++ b/internal/goasmrules/x86_witness_unpack_test.go
@@ -0,0 +1,44 @@
+package goasmrules
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestX86PackedUnpackRowsShareBinaryWitnesses(t *testing.T) {
+	x86CheckPackedRowInventory(t, X86PackedUnpackRows,
+		`^V?P?UNPCK[HL](BW|WL|LQ|WD|DQ|QDQ|PS|PD)$`,
+		`(DQ|PS|PD)$`, x86PackedRowCounts{
+			names: 24, mmx: 6, broadcast: 72,
+			rows: [3]int{12, 24, 72}, formats: [3]int{24, 48, 288}, widths: [3]int{144, 120, 96},
+		})
+}
+
+func TestX86PackedUnpackEncodingAxes(t *testing.T) {
+	legacy, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := X86PackedUnpackRows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Literal bytes independently cover the legacy L/W versus AVX D/W
+	// spellings, pp=0/66, VEX W0 versus EVEX W1, mask, width and broadcast.
+	x86CheckPackedEncodingAnchors(t, rows, []x86PackedEncodingAnchor{
+		{"PUNPCKLWL X0,X1", []byte{0x66, 0x0f, 0x61, 0xc8}},
+		{"PUNPCKHLQ (AX),X1", []byte{0x66, 0x0f, 0x6a, 0x08}},
+		{"UNPCKLPS X0,X1", []byte{0x0f, 0x14, 0xc8}},
+		{"UNPCKHPD (AX),X1", []byte{0x66, 0x0f, 0x15, 0x08}},
+		{"VPUNPCKLWD X0,X1,X2", []byte{0xc5, 0xf1, 0x61, 0xd0}},
+		{"VPUNPCKLQDQ Y0,Y1,Y2", []byte{0xc5, 0xf5, 0x6c, 0xd0}},
+		{"VPUNPCKLQDQ X16,X17,X18", []byte{0x62, 0xa1, 0xf5, 0x00, 0x6c, 0xd0}},
+		{"VUNPCKLPS X16,X17,X18", []byte{0x62, 0xa1, 0x74, 0x00, 0x14, 0xd0}},
+		{"VPUNPCKHDQ.BCST.Z (AX),Y17,K1,Y18", []byte{0x62, 0xe1, 0x75, 0xb1, 0x6a, 0x10}},
+		{"VUNPCKHPD.BCST (AX),Z17,Z18", []byte{0x62, 0xe1, 0xf5, 0x50, 0x15, 0x10}},
+	})
+}
diff --git a/internal/goasmrules/x86_witness_vsib.go b/internal/goasmrules/x86_witness_vsib.go
new file mode 100644
index 000000000..e468ac3ee
--- /dev/null
+++ b/internal/goasmrules/x86_witness_vsib.go
@@ -0,0 +1,224 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// VSIB has independent data and index carriers. The encoding transport does
+// not establish initialized indices, a backing allocation or active-lane rights.
+type x86VSIBFormat struct {
+	encoding          x86PackedAVXOpcode
+	data, index       int
+	scatter, prefetch bool
+	extension         byte
+}
+
+func x86VSIBTable(table string) bool {
+	switch table {
+	case "_yvgatherdps", "_yvgatherdpd", "_yvgatherqps",
+		"_yvpscatterdd", "_yvpscatterdq", "_yvpscatterqd",
+		"_yvgatherpf0dps", "_yvgatherpf0dpd":
+		return true
+	}
+	return false
+}
+
+// X86IndexedMemoryRows keeps every gather, scatter and prefetch source row.
+// Prefetch is a hint; an object for it is not evidence of an actual memory read.
+func X86IndexedMemoryRows(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+	var names []string
+	seen := make(map[string]bool)
+	for _, rule := range avx {
+		if x86VSIBTable(rule.Ytab) && !seen[rule.Opcode] {
+			names = append(names, rule.Opcode)
+			seen[rule.Opcode] = true
+		}
+	}
+	return x86PackedBinaryRows(legacy, avx, strings.Join(names, " "))
+}
+
+func x86VSIBClassWidth(class string, memory bool) int {
+	class = strings.TrimSuffix(class, "Evex")
+	classes := []string{"Yxr", "Yyr", "Yzr"}
+	if memory {
+		classes = []string{"Yxvm", "Yyvm", "Yzvm"}
+	}
+	for index, candidate := range classes {
+		if class == candidate {
+			return 128 << index
+		}
+	}
+	return 0
+}
+
+func x86VSIBFormatForRule(rule X86AVXRule) (x86VSIBFormat, error) {
+	f := x86VSIBFormat{}
+	fail := func() (x86VSIBFormat, error) {
+		return f, fmt.Errorf("VSIB source roles, carriers or physical payload differ")
+	}
+	if !x86VSIBTable(rule.Ytab) || rule.EncodingOffset < 0 || rule.EncodingOffset >= len(rule.OpBytes) {
+		return fail()
+	}
+	kind, memory, data := "evex", 0, 2
+	switch rule.ZCase {
+	case "Zvex_v_rm_r":
+		kind, memory = "vex", 1
+	case "Zevex_rm_k_r":
+	case "Zevex_r_k_rm":
+		f.scatter, memory, data = true, 2, 0
+	case "Zevex_k_rmo":
+		f.prefetch, memory = true, 1
+	default:
+		return fail()
+	}
+	wantClasses := 3
+	if f.prefetch {
+		wantClasses = 2
+	}
+	if len(rule.Classes) != wantClasses {
+		return fail()
+	}
+	f.index = x86VSIBClassWidth(rule.Classes[memory], true)
+	if f.prefetch {
+		if rule.Classes[0] != "Yknot0" {
+			return fail()
+		}
+	} else {
+		f.data = x86VSIBClassWidth(rule.Classes[data], false)
+		if kind == "vex" && x86VSIBClassWidth(rule.Classes[0], false) != f.data ||
+			kind == "evex" && rule.Classes[1] != "Yknot0" {
+			return fail()
+		}
+	}
+	width := f.data
+	if f.index > width {
+		width = f.index
+	}
+	if f.index == 0 || !f.prefetch && f.data == 0 {
+		return fail()
+	}
+	class := func(width int, indexed bool) string {
+		name := map[int]string{128: "Yxr", 256: "Yyr", 512: "Yzr"}[width]
+		if indexed {
+			name = map[int]string{128: "Yxvm", 256: "Yyvm", 512: "Yzvm"}[width]
+		}
+		if kind == "evex" && width < 512 {
+			name += "Evex"
+		}
+		return name
+	}
+	if rule.Classes[memory] != class(f.index, true) ||
+		!f.prefetch && rule.Classes[data] != class(f.data, false) ||
+		kind == "vex" && rule.Classes[0] != class(f.data, false) {
+		return fail()
+	}
+	if f.prefetch {
+		wantIndex := 512
+		if rule.Ytab == "_yvgatherpf0dpd" {
+			wantIndex = 256
+		}
+		if f.index != wantIndex {
+			return fail()
+		}
+	} else {
+		wantData, wantIndex := width, width
+		switch rule.Ytab {
+		case "_yvgatherdpd", "_yvpscatterdq":
+			wantIndex = maxConversionCarrier(width / 2)
+		case "_yvgatherqps", "_yvpscatterqd":
+			wantData = maxConversionCarrier(width / 2)
+		}
+		if f.data != wantData || f.index != wantIndex {
+			return fail()
+		}
+	}
+	index, offset, zoffset, extent := width/256, 2*(width/256), 2, 13
+	if kind == "evex" {
+		index, offset, zoffset = 2+width/256, 4+3*(width/256), 3
+		if f.scatter {
+			index, offset, extent = width/256, 3*(width/256), 9
+		}
+		if f.prefetch {
+			width, index, offset, zoffset, extent = 512, 0, 0, 4, 4
+		}
+	} else if width == 512 {
+		return fail()
+	}
+	if rule.RowIndex != index || rule.EncodingOffset != offset || rule.ZOffset != zoffset || len(rule.OpBytes) != extent {
+		return fail()
+	}
+	op := x86PackedAVXOpcode{kind: kind, mapByte: 2, pp: 1, length: byte(width / 256)}
+	element := 4
+	if hasEncodingTerm(rule.OpBytes[offset], kind+"W1") {
+		op.wBit, element = 0x80, 8
+	}
+	var features []string
+	if kind == "evex" {
+		features = []string{"evexN" + strconv.Itoa(element)}
+	}
+	var err error
+	f.encoding, err = x86ConversionRemainderEncoding(rule, op, features)
+	if err != nil {
+		return f, err
+	}
+	if f.prefetch {
+		extension, err := strconv.ParseUint(rule.OpBytes[3], 0, 3)
+		if err != nil || extension != 1 && extension != 2 && extension != 5 && extension != 6 {
+			return fail()
+		}
+		f.extension = byte(extension)
+	}
+	return f, nil
+}
+
+func x86VSIBRowWitnesses(rule X86AVXRule) ([]X86PackedBinaryWitness, error) {
+	f, err := x86VSIBFormatForRule(rule)
+	if err != nil {
+		return nil, err
+	}
+	bank := 0
+	if f.encoding.kind == "evex" {
+		bank = 16
+	}
+	carrier := func(width, register int) string {
+		return fmt.Sprint(map[int]string{128: "X", 256: "Y", 512: "Z"}[width], register)
+	}
+	index := carrier(f.index, bank)
+	data, mask := carrier(f.data, bank+2), "K1"
+	if f.prefetch {
+		data = ""
+	}
+	if f.encoding.kind == "vex" {
+		mask = carrier(f.data, 1)
+	}
+	reg, vvvv, p0 := byte(2), byte(0x78), byte(0xe0)
+	p2 := f.encoding.length<<5 | 1
+	if f.encoding.kind == "vex" {
+		vvvv = 0x70 // VEX vector mask register one.
+	}
+	if f.prefetch {
+		reg, p0 = f.extension, 0xf0
+	}
+	var witnesses []X86PackedBinaryWitness
+	for scale := 0; scale < 4; scale++ {
+		memory := fmt.Sprintf("(AX)(%s*%d)", index, 1<<scale)
+		operands := memory + "," + mask + "," + data
+		if f.encoding.kind == "vex" {
+			operands = mask + "," + memory + "," + data
+		} else if f.scatter {
+			operands = data + "," + mask + "," + memory
+		} else if f.prefetch {
+			operands = mask + "," + memory
+		}
+		encoding := f.encoding.bytes(vvvv, p0, p2, reg<<3|4)
+		encoding = append(encoding, byte(scale)<<6) // index low bits and AX are zero.
+		witnesses = append(witnesses, X86PackedBinaryWitness{
+			Instruction: rule.Opcode + " " + operands, Generation: f.encoding.kind,
+			First: memory, Second: index, Destination: data, Width: f.data,
+			Memory: true, Masked: true, Encoding: encoding,
+		})
+	}
+	return witnesses, nil
+}
diff --git a/internal/goasmrules/x86_witness_vsib_test.go b/internal/goasmrules/x86_witness_vsib_test.go
new file mode 100644
index 000000000..e0d2156a4
--- /dev/null
+++ b/internal/goasmrules/x86_witness_vsib_test.go
@@ -0,0 +1,87 @@
+package goasmrules
+
+import (
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VSIBCompleteOfficialRows(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := X86IndexedMemoryRows(X86LegacyCatalog{}, avx)
+	if err != nil || len(rows) != 80 {
+		t.Fatal("complete gather/scatter/prefetch source family", len(rows), err)
+	}
+	names := make(map[string]bool)
+	for _, row := range rows {
+		names[row.Opcode] = true
+		t.Run(row.ID, func(t *testing.T) {
+			if len(row.Witnesses) != 4 {
+				t.Fatal("all four legal VSIB scales must retain each source row", row)
+			}
+			for _, w := range row.Witnesses {
+				if len(w.Encoding) == 0 || w.Second == "" || !w.Memory ||
+					!strings.Contains(w.Instruction, "(AX)("+w.Second+"*") {
+					t.Fatal("VSIB index disappeared into an ordinary contiguous memory form", w)
+				}
+			}
+		})
+	}
+	if len(names) != 32 {
+		t.Fatal("complete VSIB namespace changed", len(names))
+	}
+}
+
+func TestX86VSIBSourceControls(t *testing.T) {
+	avx, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range avx {
+		if !x86VSIBTable(original.Ytab) {
+			continue
+		}
+		if _, err := x86VSIBFormatForRule(original); err != nil {
+			t.Fatal("valid original must precede negative metadata", original, err)
+		}
+		for _, axis := range []string{"index", "prefix", "row", "payload", "mask", "mask-encoding"} {
+			changed := original
+			changed.Classes = append([]string(nil), original.Classes...)
+			changed.OpBytes = append([]string(nil), original.OpBytes...)
+			switch axis {
+			case "index":
+				for index, class := range changed.Classes {
+					if strings.Contains(class, "vm") {
+						changed.Classes[index] = "Yml"
+					}
+				}
+			case "prefix":
+				changed.Prefix = "Pm"
+			case "row":
+				changed.RowIndex += 100
+			case "payload":
+				changed.OpBytes[changed.EncodingOffset] += "|evexInventedPermission"
+			case "mask":
+				for index, class := range changed.Classes {
+					if class == "Yknot0" {
+						changed.Classes[index] = "Yk0"
+					}
+				}
+				if changed.ZCase == "Zvex_v_rm_r" {
+					changed.Classes[0] = "Yknot0"
+				}
+			case "mask-encoding":
+				if changed.ZCase != "Zvex_v_rm_r" {
+					continue
+				}
+				changed.Classes[0] += "Evex"
+			}
+			if _, err := x86VSIBFormatForRule(changed); err == nil {
+				t.Fatal("corrupted original metadata granted a VSIB format", axis, original, changed)
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_widening_test.go b/internal/goasmrules/x86_witness_widening_test.go
new file mode 100644
index 000000000..6253becfd
--- /dev/null
+++ b/internal/goasmrules/x86_witness_widening_test.go
@@ -0,0 +1,180 @@
+package goasmrules
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedWideningCompleteOfficialTransport(t *testing.T) {
+	// Existing helpers keep RED in format admission, rather than compilation
+	// against a future family selector. Sign and zero retain distinct rows.
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx, `
+				PMOVSXBW PMOVSXBD PMOVSXBQ PMOVSXWD PMOVSXWQ PMOVSXDQ
+				PMOVZXBW PMOVZXBD PMOVZXBQ PMOVZXWD PMOVZXWQ PMOVZXDQ
+				VPMOVSXBW VPMOVSXBD VPMOVSXBQ VPMOVSXWD VPMOVSXWQ VPMOVSXDQ
+				VPMOVZXBW VPMOVZXBD VPMOVZXBQ VPMOVZXWD VPMOVZXWQ VPMOVZXDQ`)
+		}, `^V?PMOV(SX|ZX)(BW|BD|BQ|WD|WQ|DQ)$`, `a^`, x86PackedRowCounts{
+			names: 24, rows: [3]int{12, 24, 72}, formats: [3]int{24, 48, 216}, widths: [3]int{120, 96, 72},
+		})
+	masked, zeroing, memory := 0, 0, 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			operands := strings.Split(strings.Fields(witness.Instruction)[1], ",")
+			if witness.First != operands[0] || witness.First == "" || witness.Broadcast || witness.MaskResult ||
+				witness.Memory != (witness.First == "(AX)") ||
+				witness.Generation == "legacy" && witness.Second != witness.Destination ||
+				witness.Generation != "legacy" && witness.Second != "" {
+				t.Fatal("widening syntax confused source, destination or numerical input roles", row.ID, witness)
+			}
+			if witness.Masked {
+				masked++
+			}
+			if witness.Zeroing {
+				zeroing++
+			}
+			if witness.Memory {
+				memory++
+			}
+		}
+	}
+	if masked != 144 || zeroing != 72 || memory != 144 {
+		t.Fatal("complete widening mask/zero/memory controls changed", masked, zeroing, memory)
+	}
+	x86CheckPackedEncodingAnchors(t, inventory.rows, []x86PackedEncodingAnchor{
+		{"PMOVSXBW X0,X1", []byte{0x66, 0x0f, 0x38, 0x20, 0xc8}},
+		{"PMOVZXBQ (AX),X1", []byte{0x66, 0x0f, 0x38, 0x32, 0x08}},
+		{"VPMOVSXBW X0,Y2", []byte{0xc4, 0xe2, 0x7d, 0x20, 0xd0}},
+		{"VPMOVZXDQ (AX),Y2", []byte{0xc4, 0xe2, 0x7d, 0x35, 0x10}},
+		{"VPMOVSXBW Y16,Z18", []byte{0x62, 0xa2, 0x7d, 0x48, 0x20, 0xd0}},
+		{"VPMOVSXBQ X16,Z18", []byte{0x62, 0xa2, 0x7d, 0x48, 0x22, 0xd0}},
+		{"VPMOVZXDQ.Z (AX),K1,Z18", []byte{0x62, 0xe2, 0x7d, 0xc9, 0x35, 0x10}},
+	})
+}
+
+func TestX86PackedWideningAVXIndependentCarriersAndTuples(t *testing.T) {
+	inventory := x86CheckPackedRowInventory(t,
+		func(legacy X86LegacyCatalog, avx []X86AVXRule) ([]X86PackedBinaryRow, error) {
+			return x86PackedBinaryRows(legacy, avx, `
+				VPMOVSXBW VPMOVSXBD VPMOVSXBQ VPMOVSXWD VPMOVSXWQ VPMOVSXDQ
+				VPMOVZXBW VPMOVZXBD VPMOVZXBQ VPMOVZXWD VPMOVZXWQ VPMOVZXDQ`)
+		}, `^VPMOV(SX|ZX)(BW|BD|BQ|WD|WQ|DQ)$`, `a^`, x86PackedRowCounts{
+			names: 12, rows: [3]int{0, 24, 72}, formats: [3]int{0, 48, 216}, widths: [3]int{96, 96, 72},
+		})
+	bytes := map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}
+	for _, row := range inventory.avx {
+		if !inventory.names[row.Opcode] {
+			continue
+		}
+		n := len(row.Opcode)
+		ratio := bytes[row.Opcode[n-1]] / bytes[row.Opcode[n-2]]
+		width := map[string]int{"Yxr": 128, "YxrEvex": 128, "Yyr": 256, "YyrEvex": 256, "Yzr": 512}[row.Classes[len(row.Classes)-1]]
+		kind, source := "vex", "Yxm"
+		if width/8/ratio > 16 {
+			source = "Yym"
+		}
+		if strings.HasPrefix(row.ZCase, "Zevex_") {
+			kind, source = "evex", source+"Evex"
+			want := fmt.Sprintf("evexN%d|evexZeroingEnabled", width/8/ratio)
+			if strings.Join(strings.Fields(row.OpBytes[row.EncodingOffset+1]), "") != want {
+				t.Fatal("widening lost its shrinking tuple or gained foreign access controls", row)
+			}
+		}
+		wantHeader := fmt.Sprintf("avxEscape|%s%d|%s66|%s0F38|%sW0", kind, width, kind, kind, kind)
+		if row.Classes[0] != source || strings.Join(strings.Fields(row.OpBytes[row.EncodingOffset]), "") != wantHeader {
+			t.Fatal("widening inferred destination width from its smaller source carrier", row)
+		}
+	}
+	ySources, differentBanks := 0, 0
+	for _, row := range inventory.rows {
+		for _, witness := range row.Witnesses {
+			if witness.Memory {
+				continue
+			}
+			n := len(row.Opcode)
+			ratio := bytes[row.Opcode[n-1]] / bytes[row.Opcode[n-2]]
+			source, index := "X", "0"
+			if witness.Width/8/ratio > 16 {
+				source = "Y"
+				ySources++
+			}
+			if witness.Generation == "evex" {
+				index = "16"
+			}
+			if witness.First != source+index {
+				t.Fatal("widening changed its physical source bank", row.ID, witness)
+			}
+			if source != witness.Destination[:1] {
+				differentBanks++
+			}
+		}
+	}
+	if ySources != 18 || differentBanks != 84 {
+		t.Fatal("widening carrier-width controls changed", ySources, differentBanks)
+	}
+}
+
+func TestX86PackedWideningTransportRejectsForeignAxes(t *testing.T) {
+	rules, err := LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mutation := range []string{"ratio two X source", "ratio eight Y source", "ratio eight larger X tuple", "full tuple", "broadcast", "SAE", "rounding", "W1", "F2", "0F map", "binary role", "binary shrinking tuple", "ABS shrinking tuple"} {
+		t.Run(mutation, func(t *testing.T) {
+			name, index := "VPMOVSXBW", 7
+			if mutation == "ratio eight Y source" || mutation == "ratio eight larger X tuple" {
+				name = "VPMOVSXBQ"
+			} else if mutation == "binary shrinking tuple" {
+				name, index = "VPMULLD", 2
+			} else if mutation == "ABS shrinking tuple" {
+				name, index = "VPABSD", 2
+			}
+			found := 0
+			for _, original := range rules {
+				if original.Opcode != name || original.RowIndex != index {
+					continue
+				}
+				found++
+				changed := original
+				changed.OpBytes = append([]string(nil), original.OpBytes...)
+				changed.Classes = append([]string(nil), original.Classes...)
+				header, feature := changed.EncodingOffset, changed.EncodingOffset+1
+				switch mutation {
+				case "ratio two X source":
+					changed.Classes[0] = "YxmEvex"
+				case "ratio eight Y source":
+					changed.Classes[0] = "YymEvex"
+				case "ratio eight larger X tuple":
+					changed.OpBytes[feature] = strings.Replace(changed.OpBytes[feature], "evexN8", "evexN16", 1)
+				case "full tuple":
+					changed.OpBytes[feature] = strings.Replace(changed.OpBytes[feature], "evexN32", "evexN64", 1)
+				case "binary shrinking tuple", "ABS shrinking tuple":
+					changed.OpBytes[feature] = strings.Replace(changed.OpBytes[feature], "evexN16", "evexN8", 1)
+				case "broadcast":
+					changed.OpBytes[feature] += " | evexBcstN8"
+				case "SAE":
+					changed.OpBytes[feature] += " | evexSaeEnabled"
+				case "rounding":
+					changed.OpBytes[feature] += " | evexRoundingEnabled"
+				case "W1":
+					changed.OpBytes[header] = strings.Replace(changed.OpBytes[header], "evexW0", "evexW1", 1)
+				case "F2":
+					changed.OpBytes[header] = strings.Replace(changed.OpBytes[header], "evex66", "evexF2", 1)
+				case "0F map":
+					changed.OpBytes[header] = strings.Replace(changed.OpBytes[header], "evex0F38", "evex0F", 1)
+				case "binary role":
+					changed.ZCase = "Zevex_rm_v_k_r"
+				}
+				if _, err := x86PackedAVXRowWitnesses(changed); err == nil {
+					t.Fatal("widening borrowed a foreign carrier, prefix, tuple or numerical source role", mutation, changed)
+				}
+			}
+			if found != 1 {
+				t.Fatal("widening negative lost its exact original source row", name, index, found)
+			}
+		})
+	}
+}
diff --git a/internal/goasmrules/x86_witness_x87.go b/internal/goasmrules/x86_witness_x87.go
new file mode 100644
index 000000000..cb5253b6c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_x87.go
@@ -0,0 +1,152 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// X86X87Row retains an original row, not an initialized x87 value or native
+// entry. Register carrier, memory type/width, rounding and state are separate.
+type X86X87Row struct {
+	ID, Opcode string
+	Witnesses  []X86ScalarRMWWitness
+}
+
+func x86X87RowSchema(table string) []string {
+	switch table {
+	case "yfmvx":
+		return []string{"Zm_o/2/Ym,Yf0"}
+	case "yfadd":
+		return []string{"Zm_o/2/Ym,Yf0", "Zm_o/2/Yrf,Yf0", "Zo_m/2/Yf0,Yrf"}
+	case "yfcmv":
+		return []string{"Zm_o/2/Yrf,Yf0"}
+	case "ycompp":
+		return []string{"Zo_m/2/Yf0,Yrf"}
+	default:
+		return nil
+	}
+}
+
+func x86X87MoveRowSchema(table string) []string {
+	switch table {
+	case "yfmvd":
+		return []string{"Zm_o/2/Ym,Yf0", "Zo_m/2/Yf0,Ym", "Zm_o/2/Yrf,Yf0", "Zo_m/2/Yf0,Yrf"}
+	case "yfmvdp":
+		return []string{"Zo_m/2/Yf0,Ym", "Zo_m/2/Yf0,Yrf"}
+	case "yfmvf":
+		return []string{"Zm_o/2/Ym,Yf0", "Zo_m/2/Yf0,Ym"}
+	case "yfmvp":
+		return []string{"Zo_m/2/Yf0,Ym"}
+	default:
+		return nil
+	}
+}
+
+// X86X87Rows projects four complete ordered tables through two directions and
+// three carrier shapes. All bytes come from the original selected payload.
+func X86X87Rows(catalog X86LegacyCatalog, arch string) ([]X86X87Row, error) {
+	return x86X87Rows(catalog, arch, x86X87RowSchema, 79)
+}
+
+// X86X87MoveRows retains the remaining MOVE tables without widening the
+// original source view. Source direction and pop encodings grant no value,
+// native memory, precision or x87 control permission.
+func X86X87MoveRows(catalog X86LegacyCatalog, arch string) ([]X86X87Row, error) {
+	return x86X87Rows(catalog, arch, x86X87MoveRowSchema, 18)
+}
+
+func x86X87Rows(catalog X86LegacyCatalog, arch string, schema func(string) []string, expected int) ([]X86X87Row, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("x87 source transport requires an explicit Go x86 mode")
+	}
+	var rows []X86X87Row
+	for _, entry := range catalog.Optab {
+		if schema(entry.Ytab) == nil {
+			continue
+		}
+		for _, operand := range entry.Rows {
+			witnesses, err := x86X87RowWitnesses(entry, operand)
+			if err != nil {
+				return nil, fmt.Errorf("%s/%d: %w", entry.Opcode, operand.RowIndex, err)
+			}
+			rows = append(rows, X86X87Row{
+				ID:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex),
+				Opcode: entry.Opcode, Witnesses: witnesses,
+			})
+		}
+	}
+	if len(rows) != expected {
+		return nil, fmt.Errorf("incomplete original x87 table closure: rows=%d", len(rows))
+	}
+	return rows, nil
+}
+
+func x86X87RowWitnesses(entry X86LegacyOpcode, row X86LegacyOperand) ([]X86ScalarRMWWitness, error) {
+	schema := x86X87RowSchema(entry.Ytab)
+	if schema == nil {
+		schema = x86X87MoveRowSchema(entry.Ytab)
+	}
+	if schema == nil || entry.Kind != "encoding" || entry.Prefix != "Px" || entry.EscapeAdjustment != 0 ||
+		len(entry.Rows) != len(schema) || len(entry.OpBytes) != 2*len(schema) || len(row.Classes) != 2 || row.RowIndex < 0 || row.RowIndex >= len(schema) {
+		return nil, fmt.Errorf("unmodeled complete x87 source schema")
+	}
+	var payload [2]byte
+	for index, original := range entry.Rows {
+		shape := fmt.Sprintf("%s/%d/%s", original.ZCase, original.ZOffset, strings.Join(original.Classes, ","))
+		if len(original.Classes) != 2 || original.RowIndex != index || original.UnmatchedOffset != 2*index || shape != schema[index] {
+			return nil, fmt.Errorf("ordered x87 source row changed")
+		}
+		for atom := 0; atom < 2; atom++ {
+			value, err := strconv.ParseUint(entry.OpBytes[2*index+atom], 0, 8)
+			if err != nil || atom == 0 && (value < 0xd8 || value > 0xdf) ||
+				atom == 1 && (original.Classes[0] == "Ym" || original.Classes[1] == "Ym") && value > 7 {
+				return nil, fmt.Errorf("x87 source opcode/ModRM atom changed")
+			}
+			if index == row.RowIndex {
+				payload[atom] = byte(value)
+			}
+		}
+	}
+	if row.UnmatchedOffset != 2*row.RowIndex ||
+		fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schema[row.RowIndex] {
+		return nil, fmt.Errorf("selected x87 source row differs")
+	}
+	return x86X87CarrierWitnesses(entry.Opcode, row, payload[0], payload[1]), nil
+}
+
+// Callers validate complete source roles before selecting these carrier bytes.
+// The one-operand status forms share memory addressing and AX literal emission,
+// not numerical status-bit availability or a native x87 entry contract.
+func x86X87CarrierWitnesses(name string, row X86LegacyOperand, opcode, fragment byte) []X86ScalarRMWWitness {
+	if len(row.Classes) == 1 && row.Classes[0] == "Yax" {
+		return []X86ScalarRMWWitness{{Instruction: name + " AX", Destination: "AX", Encoding: []byte{opcode, fragment}}}
+	}
+	var witnesses []X86ScalarRMWWitness
+	memory := row.Classes[0] == "Ym" || len(row.Classes) == 2 && row.Classes[1] == "Ym"
+	for _, lane := range []byte{1, 7} {
+		first, last := fmt.Sprint("F", lane), "F0"
+		// Go asmando ORs its full field fragment with the fixed register
+		// mode. In particular FUCOMPP's decimal 13 is not a REX bit.
+		code := []byte{opcode, 0xc0 | lane | fragment<<3}
+		if memory {
+			first, code = "(AX)", []byte{opcode, fragment << 3}
+			if lane == 7 {
+				first, code = "7(AX)", []byte{opcode, 0x40 | fragment<<3, 7}
+			}
+		}
+		if len(row.Classes) == 1 {
+			last = "" // FSTSW memory has no explicit F0 source.
+		}
+		if row.ZCase == "Zo_m" {
+			first, last = last, first
+		}
+		instruction := name + " " + last
+		if first != "" {
+			instruction = name + " " + first + "," + last
+		}
+		witnesses = append(witnesses, X86ScalarRMWWitness{Instruction: instruction,
+			Destination: last, Encoding: code})
+	}
+	return witnesses
+}
diff --git a/internal/goasmrules/x86_witness_x87_test.go b/internal/goasmrules/x86_witness_x87_test.go
new file mode 100644
index 000000000..0662b2f46
--- /dev/null
+++ b/internal/goasmrules/x86_witness_x87_test.go
@@ -0,0 +1,375 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This inventory is independent of a new formatter. It names the four whole
+// source tables, not an opcode-byte registry or a numerical x87 permission.
+var x86X87SourceTableNames = map[string]string{
+	"yfmvx": `FMOVB FMOVV FMOVX FCOMF FCOMFP FCOML FCOMLP FCOMW FCOMWP
+		FADDW FADDL FADDF FMULW FMULL FMULF FSUBW FSUBL FSUBF
+		FSUBRW FSUBRL FSUBRF FDIVW FDIVL FDIVF FDIVRW FDIVRL FDIVRF`,
+	"yfadd": "FCOMD FCOMDP FADDD FMULD FSUBD FSUBRD FDIVD FDIVRD",
+	"yfcmv": `FCMOVCC FCMOVCS FCMOVEQ FCMOVHI FCMOVLS FCMOVB FCMOVBE
+		FCMOVNB FCMOVNBE FCMOVE FCMOVNE FCMOVNU FCMOVU FCMOVUN FCOMI FCOMIP`,
+	"ycompp": `FCOMDPP FUCOM FUCOMI FUCOMIP FUCOMP FUCOMPP
+		FADDDP FMULDP FSUBDP FSUBRDP FDIVDP FDIVRDP`,
+}
+
+func x86X87SourceTableMember(entry X86LegacyOpcode) bool {
+	_, found := x86X87SourceTableNames[entry.Ytab]
+	return found
+}
+
+func TestX86LegacyX87CompleteOriginalSourceInventory(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	schemas := map[string][]string{
+		"yfmvx":  {"Zm_o/2/Ym,Yf0"},
+		"yfadd":  {"Zm_o/2/Ym,Yf0", "Zm_o/2/Yrf,Yf0", "Zo_m/2/Yf0,Yrf"},
+		"yfcmv":  {"Zm_o/2/Yrf,Yf0"},
+		"ycompp": {"Zo_m/2/Yf0,Yrf"},
+	}
+	counts, names, identities := map[string]int{}, map[string]bool{}, map[string]bool{}
+	fragments := 0
+	for _, entry := range catalog.Optab {
+		if !x86X87SourceTableMember(entry) {
+			continue
+		}
+		if names[entry.Opcode] || !strings.Contains(" "+strings.Join(strings.Fields(x86X87SourceTableNames[entry.Ytab]), " ")+" ", " "+entry.Opcode+" ") {
+			t.Fatal("missing, repeated or foreign x87 source member", entry)
+		}
+		names[entry.Opcode] = true
+		if entry.Kind != "encoding" || entry.Prefix != "Px" || entry.EscapeAdjustment != 0 ||
+			len(entry.Rows) != len(schemas[entry.Ytab]) || len(entry.OpBytes) != 2*len(entry.Rows) {
+			t.Fatal("complete x87 source schema changed", entry)
+		}
+		for index, row := range entry.Rows {
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			if identities[id] || row.RowIndex != index || row.UnmatchedOffset != 2*index ||
+				fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schemas[entry.Ytab][index] {
+				t.Fatal("original ordered x87 row identity changed", id, row)
+			}
+			identities[id] = true
+			counts[entry.Ytab]++
+			for atom := 0; atom < 2; atom++ {
+				value, err := strconv.ParseUint(entry.OpBytes[2*index+atom], 0, 8)
+				if err != nil || atom == 0 && (value < 0xd8 || value > 0xdf) {
+					t.Fatal("x87 row lost an actual opcode/ModRM source atom", id, err)
+				}
+				if atom == 1 && value > 7 {
+					fragments++
+					if entry.Opcode != "FUCOMPP" || value != 13 {
+						t.Fatal("source ModRM field-fragment inventory changed", id, value)
+					}
+				}
+			}
+		}
+	}
+	for table, expected := range map[string]int{"yfmvx": 27, "yfadd": 24, "yfcmv": 16, "ycompp": 12} {
+		if counts[table] != expected {
+			t.Fatal("incomplete x87 original row family", table, counts[table], expected)
+		}
+	}
+	if len(identities) != 79 || len(names) != 63 || fragments != 1 {
+		t.Fatal("x87 row/name/field-fragment union changed", len(identities), len(names), fragments)
+	}
+}
+
+// The recorded feature RED called the old helper. The new explicit x87
+// projection preserves that packed-only refusal and all its original views.
+func TestX86LegacyX87ExplicitCarrierTransportRequired(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range catalog.Optab {
+		if !x86X87SourceTableMember(entry) {
+			continue
+		}
+		for _, row := range entry.Rows {
+			t.Run(fmt.Sprintf("%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex), func(t *testing.T) {
+				witnesses, err := x86X87RowWitnesses(entry, row)
+				if err != nil || len(witnesses) != 2 {
+					t.Fatal("complete original x87 row has no explicit carrier transport", err)
+				}
+				if previous, err := x86PackedLegacyRowWitnesses(entry, row); err == nil || len(previous) != 0 {
+					t.Fatal("x87 projection widened the old packed-only contract", previous, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyX87TransportRejectsForeignSourceAxes(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if !x86X87SourceTableMember(original) {
+			continue
+		}
+		for _, selected := range original.Rows {
+			for _, control := range []string{"kind", "table", "prefix", "escape", "index", "classes", "zcase", "stride", "offset", "extent", "selected-byte", "unselected-byte"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, selected.RowIndex, control), func(t *testing.T) {
+					entry, row := original, selected
+					entry.OpBytes = append([]string(nil), original.OpBytes...)
+					switch control {
+					case "kind":
+						entry.Kind = "special"
+					case "table":
+						entry.Ytab = "unmodeled"
+					case "prefix":
+						entry.Prefix = "Pw"
+					case "escape":
+						entry.EscapeAdjustment++
+					case "index":
+						row.RowIndex = len(entry.Rows)
+					case "classes":
+						row.Classes = []string{"Yxm", "Yxr"}
+					case "zcase":
+						row.ZCase = "Zm_r_xm"
+					case "stride":
+						row.ZOffset++
+					case "offset":
+						row.UnmatchedOffset++
+					case "extent":
+						entry.OpBytes = append(entry.OpBytes, "0")
+					case "selected-byte":
+						entry.OpBytes[row.UnmatchedOffset] = "Pe"
+					case "unselected-byte":
+						entry.OpBytes[len(entry.OpBytes)-1] = "invalid"
+					}
+					if witnesses, err := x86X87RowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+						t.Fatal("foreign source attributes supplied an x87 carrier transport", control, witnesses, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// The remaining MOVE tables form a separate view. Their original row IDs
+// must not enlarge the already qualified 79-row projection.
+var x86X87MoveSourceSchemas = map[string][]string{
+	"yfmvd":  {"Zm_o/2/Ym,Yf0", "Zo_m/2/Yf0,Ym", "Zm_o/2/Yrf,Yf0", "Zo_m/2/Yf0,Yrf"},
+	"yfmvdp": {"Zo_m/2/Yf0,Ym", "Zo_m/2/Yf0,Yrf"},
+	"yfmvf":  {"Zm_o/2/Ym,Yf0", "Zo_m/2/Yf0,Ym"},
+	"yfmvp":  {"Zo_m/2/Yf0,Ym"},
+}
+
+func TestX86LegacyX87MoveCompleteOriginalInventory(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts, names, ids := map[string]int{}, map[string]bool{}, map[string]bool{}
+	for _, entry := range catalog.Optab {
+		schema := x86X87MoveSourceSchemas[entry.Ytab]
+		if schema == nil {
+			continue
+		}
+		if names[entry.Opcode] || entry.Kind != "encoding" || entry.Prefix != "Px" ||
+			entry.EscapeAdjustment != 0 || len(entry.Rows) != len(schema) || len(entry.OpBytes) != 2*len(schema) {
+			t.Fatal("complete original MOVE entry changed", entry)
+		}
+		names[entry.Opcode] = true
+		for index, row := range entry.Rows {
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			if ids[id] || row.RowIndex != index || row.UnmatchedOffset != 2*index ||
+				fmt.Sprintf("%s/%d/%s", row.ZCase, row.ZOffset, strings.Join(row.Classes, ",")) != schema[index] {
+				t.Fatal("original ordered MOVE identity changed", id, row)
+			}
+			ids[id] = true
+			counts[entry.Ytab]++
+		}
+	}
+	for table, expected := range map[string]int{"yfmvd": 4, "yfmvdp": 2, "yfmvf": 6, "yfmvp": 6} {
+		if counts[table] != expected {
+			t.Fatal("incomplete original MOVE family", table, counts[table], expected)
+		}
+	}
+	if len(ids) != 18 || len(names) != 11 {
+		t.Fatal("MOVE source-row/name denominator changed", len(ids), len(names))
+	}
+}
+
+// RED uses the existing renderer's actual refusal, not an absent new API or
+// a claim that the initialized translator cannot execute this instruction.
+func TestX86LegacyX87MoveTransportCompleteDirections(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, entry := range catalog.Optab {
+		if x86X87MoveSourceSchemas[entry.Ytab] == nil {
+			continue
+		}
+		for _, row := range entry.Rows {
+			t.Run(fmt.Sprintf("%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex), func(t *testing.T) {
+				id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+				expected := map[string]X86ScalarRMWWitness{}
+				opcode, firstErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset], 0, 8)
+				fragment, lastErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset+1], 0, 8)
+				if firstErr != nil || lastErr != nil {
+					t.Fatal("independent original MOVE payload", id, firstErr, lastErr)
+				}
+				for _, lane := range []byte{1, 7} {
+					first, last := fmt.Sprint("F", lane), "F0"
+					code := []byte{byte(opcode), 0xc0 | lane | byte(fragment<<3)}
+					if row.Classes[0] == "Ym" || row.Classes[1] == "Ym" {
+						first, code = "(AX)", []byte{byte(opcode), byte(fragment << 3)}
+						if lane == 7 {
+							first, code = "7(AX)", []byte{byte(opcode), 0x40 | byte(fragment<<3), 7}
+						}
+					}
+					if row.ZCase == "Zo_m" {
+						first, last = last, first
+					}
+					instruction := entry.Opcode + " " + first + "," + last
+					expected[id+"/"+instruction] = X86ScalarRMWWitness{Instruction: instruction, Destination: last, Encoding: code}
+				}
+				witnesses, err := x86X87RowWitnesses(entry, row)
+				if err != nil || len(witnesses) != 2 {
+					t.Fatal("X87_MOVE_SOURCE_TRANSPORT_FEATURE_GAP", err)
+				}
+				for _, witness := range witnesses {
+					key := id + "/" + witness.Instruction
+					want, found := expected[key]
+					if !found || !bytes.Equal(witness.Encoding, want.Encoding) || witness.Destination != want.Destination {
+						t.Fatal("MOVE transport differs from the independent actual-Go source cases", key, witness, want)
+					}
+					delete(expected, key)
+				}
+				if len(expected) != 0 {
+					t.Fatal("MOVE transport omitted an independent original source case", id, expected)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyX87MoveRejectsChangedPayloadAndDirection(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if x86X87MoveSourceSchemas[original.Ytab] == nil {
+			continue
+		}
+		for _, selected := range original.Rows {
+			for _, control := range []string{"prefix", "stride", "offset", "extent", "row-order", "direction", "unselected-byte", "memory-digit"} {
+				if control == "memory-digit" && selected.Classes[0] != "Ym" && selected.Classes[1] != "Ym" {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, selected.RowIndex, control), func(t *testing.T) {
+					entry, row := original, selected
+					entry.OpBytes = append([]string(nil), original.OpBytes...)
+					entry.Rows = append([]X86LegacyOperand(nil), original.Rows...)
+					switch control {
+					case "prefix":
+						entry.Prefix = "Pw"
+					case "stride":
+						row.ZOffset++
+					case "offset":
+						row.UnmatchedOffset++
+					case "extent":
+						entry.OpBytes = append(entry.OpBytes, "0")
+					case "row-order":
+						entry.Rows[0].RowIndex++
+					case "direction":
+						row.ZCase = "Zlit"
+					case "unselected-byte":
+						entry.OpBytes[len(entry.OpBytes)-1] = "invalid"
+					case "memory-digit":
+						entry.OpBytes[row.UnmatchedOffset+1] = "8"
+					}
+					if witnesses, err := x86X87RowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+						t.Fatal("changed original MOVE source acquired a format witness", control, witnesses, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyX87MoveViewPreservesOriginalProjection(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		original, err := X86X87Rows(catalog, arch)
+		if err != nil || len(original) != 79 {
+			t.Fatal("MOVE closure enlarged the original x87 projection", arch, err)
+		}
+		seen := map[string]bool{}
+		for _, row := range original {
+			seen[row.ID] = true
+		}
+		moves, err := X86X87MoveRows(catalog, arch)
+		if err != nil || len(moves) != 18 {
+			t.Fatal("remaining MOVE projection lost its complete rows", arch, err)
+		}
+		for _, row := range moves {
+			if seen[row.ID] || len(row.Witnesses) != 2 {
+				t.Fatal("new MOVE source identity repeated or overlapped the original view", arch, row)
+			}
+			seen[row.ID] = true
+		}
+		if len(seen) != 97 {
+			t.Fatal("old/new original x87 source union changed", arch, len(seen))
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		if rows, err := X86X87MoveRows(catalog, arch); err == nil || len(rows) != 0 {
+			t.Fatal("MOVE source projection inferred a missing or foreign x86 mode", arch, rows, err)
+		}
+	}
+}
+
+func TestX86LegacyX87MoveRejectsMalformedClassTuples(t *testing.T) {
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, original := range catalog.Optab {
+		if x86X87MoveSourceSchemas[original.Ytab] == nil {
+			continue
+		}
+		for _, selected := range original.Rows {
+			for _, owner := range []string{"original", "selected"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", original.Opcode, selected.RowIndex, owner), func(t *testing.T) {
+					entry, row := original, selected
+					entry.Rows = append([]X86LegacyOperand(nil), original.Rows...)
+					// Joining class names is not injective. This malformed
+					// single class has the same text as the two-class schema.
+					malformed := []string{strings.Join(selected.Classes, ",")}
+					if owner == "original" {
+						entry.Rows[selected.RowIndex].Classes = malformed
+					} else {
+						row.Classes = malformed
+					}
+					defer func() {
+						if value := recover(); value != nil {
+							t.Fatal("X87_MOVE_MALFORMED_CLASS_TUPLE_PANIC", owner, value)
+						}
+					}()
+					if witnesses, err := x86X87RowWitnesses(entry, row); err == nil || len(witnesses) != 0 {
+						t.Fatal("malformed class tuple acquired a source witness", owner, witnesses, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/internal/goasmrules/x86_witness_zero_operand.go b/internal/goasmrules/x86_witness_zero_operand.go
new file mode 100644
index 000000000..03de6aabd
--- /dev/null
+++ b/internal/goasmrules/x86_witness_zero_operand.go
@@ -0,0 +1,120 @@
+package goasmrules
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// X86ZeroOperandRows projects Go's complete ynone/Zlit source family.
+// Literal encodings grant no numerical, FLAGS, memory, stack, native-entry,
+// privileged-state or floating-point precision facts to the translator.
+func X86ZeroOperandRows(catalog X86LegacyCatalog, arch string) ([]X86ScalarRMWRow, error) {
+	if arch != "amd64" && arch != "386" {
+		return nil, fmt.Errorf("zero-operand source view requires a Go x86 mode")
+	}
+	var result []X86ScalarRMWRow
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "ynone" {
+			continue
+		}
+		if seen[entry.Opcode] || len(entry.Rows) != 1 {
+			return nil, fmt.Errorf("duplicate or incomplete zero-operand source entry")
+		}
+		seen[entry.Opcode] = true
+		row, err := x86ZeroOperandSourceRow(entry, entry.Rows[0], arch, catalog.OpBytesSize)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", entry.Opcode, err)
+		}
+		result = append(result, row)
+	}
+	if len(result) == 0 {
+		return nil, fmt.Errorf("missing zero-operand source entries")
+	}
+	return result, nil
+}
+
+func x86ZeroOperandSourceRow(entry X86LegacyOpcode, selected X86LegacyOperand, arch string, capacity int) (X86ScalarRMWRow, error) {
+	var result X86ScalarRMWRow
+	fail := func() (X86ScalarRMWRow, error) {
+		return result, fmt.Errorf("unmodeled complete zero-operand source grammar")
+	}
+	if arch != "amd64" && arch != "386" || entry.Kind != "encoding" || entry.Ytab != "ynone" ||
+		entry.Opcode == "" || entry.TableIndex < 0 || capacity <= 0 || len(entry.OpBytes) == 0 || len(entry.OpBytes) > capacity {
+		return fail()
+	}
+	if err := x86ScalarCompleteOperandSchema(entry, selected, []string{"Zlit/1/"}); err != nil {
+		return result, err
+	}
+	// PutOpBytesLit reads to the first zero, including implicit array padding.
+	// Validate the entire original payload, even bytes after that terminator:
+	// SAHF deliberately retains a later, currently unused sequence in Go.
+	literal, err := x86SourceLiteralBytes(entry.OpBytes, capacity)
+	if err != nil {
+		return fail()
+	}
+	escape := 0
+	if literal[0] == 0x0f {
+		escape = 1
+	}
+	if entry.EscapeAdjustment != escape {
+		return fail()
+	}
+	var prefix []byte
+	switch entry.Prefix {
+	case "Px", "Pb":
+	case "Pm":
+		prefix = []byte{0x0f}
+	case "Pe":
+		prefix = []byte{0x66}
+	case "Pw":
+		prefix = []byte{0x48}
+		if arch == "386" {
+			result.ModeFiltered = "original Go Pw requires amd64"
+		}
+	case "P32":
+		if arch == "amd64" {
+			result.ModeFiltered = "original Go P32 requires 386"
+		}
+	case "Py":
+		if arch == "386" {
+			result.ModeFiltered = "original Go Py requires amd64"
+		}
+	case "Pf3":
+		prefix = []byte{0xf3, 0x0f}
+	default:
+		return fail()
+	}
+	result.ID = fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, selected.RowIndex)
+	result.Opcode = entry.Opcode
+	if result.ModeFiltered == "" {
+		result.Witnesses = []X86ScalarRMWWitness{{Instruction: entry.Opcode, Encoding: append(prefix, literal...)}}
+	}
+	return result, nil
+}
+
+// Fixed-array literals stop at the first zero, including implicit padding.
+// Every source atom remains validated even after emission stops.
+func x86SourceLiteralBytes(atoms []string, capacity int) ([]byte, error) {
+	if capacity <= 0 || len(atoms) == 0 || len(atoms) > capacity {
+		return nil, fmt.Errorf("invalid source literal capacity")
+	}
+	literal := make([]byte, 0, len(atoms))
+	terminated := false
+	for _, atom := range atoms {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			return nil, fmt.Errorf("source literal contains a non-byte atom")
+		}
+		if value == 0 {
+			terminated = true
+		}
+		if !terminated {
+			literal = append(literal, byte(value))
+		}
+	}
+	if len(literal) == 0 || !terminated && len(atoms) == capacity {
+		return nil, fmt.Errorf("empty or unterminated source literal")
+	}
+	return literal, nil
+}
diff --git a/internal/goasmrules/x86_witness_zero_operand_test.go b/internal/goasmrules/x86_witness_zero_operand_test.go
new file mode 100644
index 000000000..ca21db98c
--- /dev/null
+++ b/internal/goasmrules/x86_witness_zero_operand_test.go
@@ -0,0 +1,247 @@
+package goasmrules
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func zeroOperandOriginalEntries(t *testing.T) []X86LegacyOpcode {
+	t.Helper()
+	catalog, err := LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var entries []X86LegacyOpcode
+	prefixes := map[string]int{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "ynone" {
+			continue
+		}
+		if entry.Kind != "encoding" || len(entry.Rows) != 1 {
+			t.Fatal("complete zero-operand source entry changed", entry)
+		}
+		row := entry.Rows[0]
+		if row.RowIndex != 0 || row.ZCase != "Zlit" || row.ZOffset != 1 ||
+			row.UnmatchedOffset != 0 || len(row.Classes) != 0 {
+			t.Fatal("complete zero-operand original schema changed", entry)
+		}
+		prefixes[entry.Prefix]++
+		entries = append(entries, entry)
+	}
+	for prefix, want := range map[string]int{
+		"Px": 68, "Pm": 24, "Pe": 15, "P32": 12, "Pw": 10, "Pb": 7, "Py": 3,
+	} {
+		if prefixes[prefix] != want {
+			t.Fatal("complete source prefix inventory changed", prefix, prefixes)
+		}
+	}
+	if prefixes["Pf3"] > 1 || len(entries) != 139+prefixes["Pf3"] || len(prefixes) != 7+prefixes["Pf3"] {
+		t.Fatal("complete zero-operand SDK inventory changed", len(entries), prefixes)
+	}
+	return entries
+}
+
+// This independent model follows Go's prefix switch and PutOpBytesLit.
+// It is checked against actual Go objects in the package-level owner. The
+// first zero terminates emission, but every original array atom is retained.
+func zeroOperandExpected(t *testing.T, entry X86LegacyOpcode, arch string) ([]byte, bool) {
+	t.Helper()
+	if arch != "amd64" && arch != "386" {
+		t.Fatal("foreign test mode", arch)
+	}
+	if arch == "amd64" && entry.Prefix == "P32" ||
+		arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Py") {
+		return nil, false
+	}
+	prefixes := map[string][]byte{
+		"Px": {}, "Pb": {}, "P32": {}, "Py": {},
+		"Pm": {0x0f}, "Pe": {0x66}, "Pw": {0x48}, "Pf3": {0xf3, 0x0f},
+	}
+	prefix, found := prefixes[entry.Prefix]
+	if !found {
+		t.Fatal("independent original prefix changed", entry)
+	}
+	code := append([]byte(nil), prefix...)
+	terminated := false
+	for i, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			t.Fatal("independent original literal atom changed", entry.Opcode, i, atom, err)
+		}
+		if value == 0 {
+			terminated = true
+		}
+		if !terminated {
+			code = append(code, byte(value))
+		}
+	}
+	return code, true
+}
+
+func TestX86ZeroOperandCompleteOriginalInventory(t *testing.T) {
+	entries := zeroOperandOriginalEntries(t)
+	accepted, refused := 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		for _, entry := range entries {
+			code, valid := zeroOperandExpected(t, entry, arch)
+			if !valid {
+				refused++
+				continue
+			}
+			if len(code) == 0 {
+				t.Fatal("empty original source literal", arch, entry)
+			}
+			accepted++
+		}
+	}
+	if refused != 25 || accepted != 2*len(entries)-25 {
+		t.Fatal("complete mode inventory changed", accepted, refused)
+	}
+}
+
+func TestX86ZeroOperandExistingSourceTransportCompleteBytes(t *testing.T) {
+	for _, entry := range zeroOperandOriginalEntries(t) {
+		for _, arch := range []string{"amd64", "386"} {
+			code, valid := zeroOperandExpected(t, entry, arch)
+			if !valid {
+				continue
+			}
+			id := fmt.Sprintf("optab/%d/%s/ynone/0/%s", entry.TableIndex, entry.Opcode, arch)
+			t.Run(id, func(t *testing.T) {
+				before := fmt.Sprintf("%#v", entry)
+				// Both original REDs called the existing scalar-only helper.
+				// The explicit source view closes that feature gap without
+				// changing the older numerical consumer's accepted domain.
+				row, err := x86ZeroOperandSourceRow(entry, entry.Rows[0], arch, 31)
+				if err != nil || row.ModeFiltered != "" || len(row.Witnesses) != 1 {
+					t.Fatal("ZERO_OPERAND_SOURCE_TRANSPORT_FEATURE_GAP", err, row)
+				}
+				witness := row.Witnesses[0]
+				if witness.Instruction != entry.Opcode || witness.Destination != "" || !bytes.Equal(witness.Encoding, code) {
+					t.Fatal("original source identity/literal bytes differ", witness, code)
+				}
+				if before != fmt.Sprintf("%#v", entry) {
+					t.Fatal("source formatter mutated the original entry")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ZeroOperandCompleteMetadataBoundaries(t *testing.T) {
+	entries := zeroOperandOriginalEntries(t)
+	checks := 0
+	for _, entry := range entries {
+		t.Run(entry.Opcode, func(t *testing.T) {
+			arch := "amd64"
+			if entry.Prefix == "P32" {
+				arch = "386"
+			}
+			for _, field := range []string{
+				"kind", "ytab", "row-count", "original-arity", "selected-arity",
+				"original-index", "selected-index", "original-zcase", "selected-zcase",
+				"original-stride-negative", "original-stride-overflow", "selected-stride",
+				"original-offset-negative", "selected-offset-overflow", "prefix",
+				"escape-negative", "escape-overflow", "escape-identity", "empty-payload",
+				"empty-literal", "payload-full-without-terminator", "payload-overflow",
+			} {
+				changed, row := entry, entry.Rows[0]
+				changed.Rows = append([]X86LegacyOperand(nil), entry.Rows...)
+				changed.OpBytes = append([]string(nil), entry.OpBytes...)
+				maxInt := int(^uint(0) >> 1)
+				switch field {
+				case "kind":
+					changed.Kind = "reserved"
+				case "ytab":
+					changed.Ytab = "yin"
+				case "row-count":
+					changed.Rows = append(changed.Rows, row)
+				case "original-arity":
+					changed.Rows[0].Classes = []string{"Ynone"}
+				case "selected-arity":
+					row.Classes = []string{"Ynone"}
+				case "original-index":
+					changed.Rows[0].RowIndex = 1
+				case "selected-index":
+					row.RowIndex = -1
+				case "original-zcase":
+					changed.Rows[0].ZCase = "Zpseudo"
+				case "selected-zcase":
+					row.ZCase = "Zlitm_r"
+				case "original-stride-negative":
+					changed.Rows[0].ZOffset = -maxInt - 1
+				case "original-stride-overflow":
+					changed.Rows[0].ZOffset = maxInt
+				case "selected-stride":
+					row.ZOffset = 0
+				case "original-offset-negative":
+					changed.Rows[0].UnmatchedOffset = -maxInt - 1
+				case "selected-offset-overflow":
+					row.UnmatchedOffset = maxInt
+				case "prefix":
+					changed.Prefix = "Pq"
+				case "escape-negative":
+					changed.EscapeAdjustment = -1
+				case "escape-overflow":
+					changed.EscapeAdjustment = maxInt
+				case "escape-identity":
+					changed.EscapeAdjustment = 1 - entry.EscapeAdjustment
+				case "empty-payload":
+					changed.OpBytes = nil
+				case "empty-literal":
+					changed.OpBytes[0] = "0"
+				case "payload-full-without-terminator", "payload-overflow":
+					// The observed Go source uses a 31-byte fixed array.
+					// Filling it removes the implicit zero terminator.
+					count := 31
+					if field == "payload-overflow" {
+						count++
+					}
+					changed.OpBytes = make([]string, count)
+					for i := range changed.OpBytes {
+						changed.OpBytes[i] = "1"
+					}
+					// Preserve source escape identity so the missing implicit
+					// terminator is the independent rejection reason.
+					changed.OpBytes[0] = entry.OpBytes[0]
+				}
+				checks++
+				if _, err := x86ZeroOperandSourceRow(changed, row, arch, 31); err == nil {
+					t.Errorf("malformed original source accepted: op=%s mode=%s mutation=%s", entry.Opcode, arch, field)
+				}
+			}
+			for i := range entry.OpBytes {
+				for _, atom := range []string{"-1", "0x100", "Pm"} {
+					changed := entry
+					changed.OpBytes = append([]string(nil), entry.OpBytes...)
+					changed.OpBytes[i] = atom
+					checks++
+					if _, err := x86ZeroOperandSourceRow(changed, entry.Rows[0], arch, 31); err == nil {
+						t.Errorf("malformed literal atom accepted: op=%s index=%d atom=%q", entry.Opcode, i, atom)
+					}
+				}
+			}
+		})
+	}
+	want := 3703
+	if len(entries) == 140 {
+		want = 3731
+	}
+	if checks != want {
+		t.Fatal("complete metadata control count changed", checks, want)
+	}
+	t.Logf("ZERO_OPERAND_METADATA_CHECKS=%d", checks)
+}
+
+func TestX86ZeroOperandSourceViewKeepsScalarConsumerBoundary(t *testing.T) {
+	for _, entry := range zeroOperandOriginalEntries(t) {
+		for _, arch := range []string{"amd64", "386"} {
+			if _, err := x86ScalarRMWRowWitnesses(entry, entry.Rows[0], arch); err == nil {
+				t.Fatal("source literal widened the older scalar numerical consumer", entry.Opcode, arch)
+			}
+		}
+	}
+}
diff --git a/internal/golegacymod/capture.go b/internal/golegacymod/capture.go
new file mode 100644
index 000000000..ed28cb198
--- /dev/null
+++ b/internal/golegacymod/capture.go
@@ -0,0 +1,78 @@
+package golegacymod
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+// CaptureCachedProxyGoMod authenticates metadata in a separately observed Go
+// cache. Its caller must bind cache/proxy to the actual Go environment and
+// independently observe the whole ZIP/tree, including the absent go.mod.
+// No package-selection or assembly authority follows from this proof.
+func CaptureCachedProxyGoMod(ctx context.Context, cache, proxy, name, version, zipSum, modSum, metadata string, prior *ProxyGoModProof) (*ProxyGoModProof, string, error) {
+	if ctx == nil {
+		return nil, "", fmt.Errorf("legacy metadata capture needs a live context")
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, "", err
+	}
+	if !filepath.IsAbs(cache) {
+		return nil, "", fmt.Errorf("invalid actual metadata cache observation")
+	}
+	escapedModule, err := module.EscapePath(name)
+	if err != nil {
+		return nil, "", err
+	}
+	escapedVersion, err := module.EscapeVersion(version)
+	if err != nil {
+		return nil, "", err
+	}
+	wanted := filepath.Join(cache, "cache", "download", filepath.FromSlash(escapedModule), "@v", escapedVersion+".mod")
+	if filepath.Clean(metadata) != wanted {
+		return nil, "", fmt.Errorf("proxy go.mod is not the actual exact-version download metadata")
+	}
+	info, err := os.Lstat(wanted)
+	if err != nil || !info.Mode().IsRegular() {
+		return nil, "", fmt.Errorf("proxy metadata is not a regular exact-version download file")
+	}
+	canonical, err := sourcepath.Resolve(wanted)
+	if err != nil {
+		return nil, "", err
+	}
+	contents, err := ReadChecksumFile(canonical, 1024)
+	if err != nil {
+		return nil, "", err
+	}
+	if prior != nil {
+		// Revalidate the signature/inclusion and current bytes. The immutable
+		// exact pair does not require another public checkpoint or network read.
+		if err := ValidateProxyGoMod(prior); err != nil {
+			return nil, "", err
+		}
+		if prior.Module != name || prior.Version != version || prior.ModuleSum != zipSum || prior.GoModSum != modSum ||
+			prior.Contents != string(contents) || prior.SHA256 != bytesSHA256(contents) {
+			return nil, "", fmt.Errorf("downloaded metadata differs from authenticated producer origin")
+		}
+		proof := *prior
+		proof.Inclusion = append([]string(nil), prior.Inclusion...)
+		return &proof, canonical, nil
+	}
+	reader, err := NewSumDBReader(ctx, cache, proxy)
+	if err != nil {
+		return nil, "", err
+	}
+	lookup, err := reader.Read("lookup/"+escapedModule+"@"+escapedVersion, 16<<10)
+	if err != nil {
+		return nil, "", err
+	}
+	proof, err := CaptureProxyGoMod(name, version, zipSum, modSum, contents, lookup, reader)
+	if err != nil {
+		return nil, "", err
+	}
+	return proof, canonical, nil
+}
diff --git a/internal/golegacymod/capture_test.go b/internal/golegacymod/capture_test.go
new file mode 100644
index 000000000..e211ba417
--- /dev/null
+++ b/internal/golegacymod/capture_test.go
@@ -0,0 +1,66 @@
+package golegacymod
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"golang.org/x/mod/module"
+)
+
+func TestCachedProxyGoModKeepsAuthenticationAndContext(t *testing.T) {
+	data, err := os.ReadFile("../../gotoolprofile/testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	cache := t.TempDir()
+	escaped, err := module.EscapePath(proof.Module)
+	if err != nil {
+		t.Fatal(err)
+	}
+	metadata := filepath.Join(cache, "cache", "download", escaped, "@v", proof.Version+".mod")
+	if err := os.MkdirAll(filepath.Dir(metadata), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(metadata, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	capture := func(ctx context.Context, prior *ProxyGoModProof) (*ProxyGoModProof, string, error) {
+		return CaptureCachedProxyGoMod(ctx, cache, "off", proof.Module, proof.Version,
+			proof.ModuleSum, proof.GoModSum, metadata, prior)
+	}
+	actual, name, err := capture(context.Background(), &proof)
+	physical, physicalErr := filepath.EvalSymlinks(metadata)
+	if err != nil || physicalErr != nil || name != physical || !reflect.DeepEqual(actual, &proof) {
+		t.Fatal("complete public authentication was not retained", err, physicalErr)
+	}
+	actual.Inclusion[0] = "changed"
+	if reflect.DeepEqual(actual, &proof) {
+		t.Fatal("returned proof shares its caller's mutable audit path")
+	}
+	if _, _, err := capture(context.Background(), actual); err == nil {
+		t.Fatal("changed inclusion bypassed independent authentication")
+	}
+	if _, _, err := capture(nil, &proof); err == nil {
+		t.Fatal("nil context accepted cached metadata")
+	}
+	canceled, cancel := context.WithCancel(context.Background())
+	cancel()
+	if _, _, err := capture(canceled, &proof); !errors.Is(err, context.Canceled) {
+		t.Fatal("canceled capture borrowed a prior signature", err)
+	}
+	if err := os.WriteFile(metadata, []byte(proof.Contents+"\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, _, err := capture(context.Background(), &proof); err == nil {
+		t.Fatal("cached signature hid changed actual metadata")
+	}
+}
diff --git a/internal/golegacymod/proof.go b/internal/golegacymod/proof.go
new file mode 100644
index 000000000..5c9baa9cd
--- /dev/null
+++ b/internal/golegacymod/proof.go
@@ -0,0 +1,143 @@
+// Package golegacymod authenticates Go's separately synthesized legacy module
+// metadata. It grants no ZIP membership, package, frame or assembly capability.
+package golegacymod
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"strings"
+
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/sumdb/dirhash"
+	"golang.org/x/mod/sumdb/note"
+	"golang.org/x/mod/sumdb/tlog"
+)
+
+const ProxyGoModProtocol = "sumdb_authenticated_legacy_proxy_go_mod_v1"
+
+// This is Go's public sum.golang.org verifier, not a caller-supplied trust key.
+// A signed tree alone is insufficient: the exact record needs its audit path.
+const publicSumDBKey = "sum.golang.org+033de0ae+Ac4zctda0e5eza+HJyk9SxEdh+s3Ux18htTTAD8OuAn8"
+
+// ProxyGoModProof authenticates metadata outside the module ZIP. Contents is
+// restricted to Go's canonical synthesized module directive, not library code.
+// SignedTree and Inclusion are independent of the actual module/source proof.
+type ProxyGoModProof struct {
+	Protocol   string   `json:"protocol"`
+	Module     string   `json:"module"`
+	Version    string   `json:"version"`
+	ModuleSum  string   `json:"module_sum"`
+	GoModSum   string   `json:"go_mod_sum"`
+	Contents   string   `json:"contents"`
+	SHA256     string   `json:"sha256"`
+	RecordID   int64    `json:"record_id"`
+	Record     string   `json:"record"`
+	SignedTree string   `json:"signed_tree"`
+	Inclusion  []string `json:"record_inclusion"`
+}
+
+// CaptureProxyGoMod proves membership using authenticated sumdb tiles. Reading
+// the cache or fetching a tile is the caller's bounded, owned-resource policy.
+func CaptureProxyGoMod(path, version, zipSum, modSum string, contents, lookup []byte, tiles tlog.TileReader) (*ProxyGoModProof, error) {
+	if len(lookup) > 16<<10 || tiles == nil {
+		return nil, fmt.Errorf("legacy module metadata lacks a bounded checksum lookup")
+	}
+	id, record, signed, err := tlog.ParseRecord(lookup)
+	if err != nil {
+		return nil, fmt.Errorf("parse legacy checksum record: %w", err)
+	}
+	proof := &ProxyGoModProof{
+		Protocol: ProxyGoModProtocol, Module: path, Version: version, ModuleSum: zipSum,
+		GoModSum: modSum, Contents: string(contents), SHA256: bytesSHA256(contents),
+		RecordID: id, Record: string(record), SignedTree: string(signed),
+	}
+	tree, err := validateProxyGoModRecord(proof)
+	if err != nil {
+		return nil, err
+	}
+	audit, err := tlog.ProveRecord(tree.N, id, tlog.TileHashReader(tree, tiles))
+	if err != nil {
+		return nil, fmt.Errorf("prove legacy checksum record inclusion: %w", err)
+	}
+	for _, hash := range audit {
+		proof.Inclusion = append(proof.Inclusion, hash.String())
+	}
+	if err := ValidateProxyGoMod(proof); err != nil {
+		return nil, err
+	}
+	return proof, nil
+}
+
+func ValidateProxyGoMod(proof *ProxyGoModProof) error {
+	tree, err := validateProxyGoModRecord(proof)
+	if err != nil {
+		return err
+	}
+	if len(proof.Inclusion) > 64 {
+		return fmt.Errorf("legacy checksum inclusion exceeds its bound")
+	}
+	var audit tlog.RecordProof
+	for _, encoded := range proof.Inclusion {
+		data, err := base64.StdEncoding.DecodeString(encoded)
+		if err != nil || len(data) != tlog.HashSize || base64.StdEncoding.EncodeToString(data) != encoded {
+			return fmt.Errorf("invalid legacy checksum inclusion hash")
+		}
+		var hash tlog.Hash
+		copy(hash[:], data)
+		audit = append(audit, hash)
+	}
+	if err := tlog.CheckRecord(audit, tree.N, tree.Hash, proof.RecordID, tlog.RecordHash([]byte(proof.Record))); err != nil {
+		return fmt.Errorf("legacy checksum record is not in its signed tree: %w", err)
+	}
+	return nil
+}
+
+func validateProxyGoModRecord(proof *ProxyGoModProof) (tlog.Tree, error) {
+	if proof == nil || proof.Protocol != ProxyGoModProtocol || module.Check(proof.Module, proof.Version) != nil ||
+		len(proof.Contents) > 1024 || proof.Contents != "module "+proof.Module+"\n" ||
+		proof.SHA256 != bytesSHA256([]byte(proof.Contents)) || !ValidH1(proof.ModuleSum) || !ValidH1(proof.GoModSum) ||
+		len(proof.Record) > 4096 || len(proof.SignedTree) > 4096 || proof.RecordID < 0 {
+		return tlog.Tree{}, fmt.Errorf("invalid independent legacy proxy-go.mod identity")
+	}
+	sum, err := dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+		return io.NopCloser(bytes.NewBufferString(proof.Contents)), nil
+	})
+	if err != nil || sum != proof.GoModSum {
+		return tlog.Tree{}, fmt.Errorf("proxy go.mod bytes differ from their independent Go h1")
+	}
+	lines := strings.Split(strings.TrimSuffix(proof.Record, "\n"), "\n")
+	if len(lines) != 2 || lines[0] != proof.Module+" "+proof.Version+" "+proof.ModuleSum ||
+		lines[1] != proof.Module+" "+proof.Version+"/go.mod "+proof.GoModSum {
+		return tlog.Tree{}, fmt.Errorf("checksum record differs from exact ZIP and proxy metadata identities")
+	}
+	verifier, err := note.NewVerifier(publicSumDBKey)
+	if err != nil {
+		return tlog.Tree{}, err
+	}
+	signed, err := note.Open([]byte(proof.SignedTree), note.VerifierList(verifier))
+	if err != nil {
+		return tlog.Tree{}, fmt.Errorf("legacy checksum tree lacks the public sumdb signature: %w", err)
+	}
+	tree, err := tlog.ParseTree([]byte(signed.Text))
+	if err != nil || tree.N <= proof.RecordID {
+		return tlog.Tree{}, fmt.Errorf("invalid legacy checksum signed tree extent")
+	}
+	return tree, nil
+}
+
+// ValidH1 checks only the checksum spelling. It is not authentication.
+func ValidH1(value string) bool {
+	if !strings.HasPrefix(value, "h1:") {
+		return false
+	}
+	encoded := strings.TrimPrefix(value, "h1:")
+	data, err := base64.StdEncoding.DecodeString(encoded)
+	return err == nil && len(data) == 32 && base64.StdEncoding.EncodeToString(data) == encoded
+}
+
+func bytesSHA256(data []byte) string {
+	return fmt.Sprintf("%x", sha256.Sum256(data))
+}
diff --git a/internal/golegacymod/reader.go b/internal/golegacymod/reader.go
new file mode 100644
index 000000000..a0611c2eb
--- /dev/null
+++ b/internal/golegacymod/reader.go
@@ -0,0 +1,176 @@
+package golegacymod
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/mod/sumdb/tlog"
+)
+
+// Sumdb responses are public source metadata, never executable dependencies.
+// Cache reads are read-only; fetched bytes stay in memory and are authenticated
+// before being recorded. No user/global cache is written or cleaned.
+type SumDBReader struct {
+	Context        context.Context
+	Cache          string
+	Client         *http.Client
+	ReadonlyCaches []string
+}
+
+func NewSumDBReader(ctx context.Context, moduleCache, proxy string) (*SumDBReader, error) {
+	if !filepath.IsAbs(moduleCache) || len(proxy) > 64<<10 {
+		return nil, fmt.Errorf("invalid actual checksum cache configuration")
+	}
+	reader := &SumDBReader{
+		Context: ctx,
+		Cache:   filepath.Join(moduleCache, "cache", "download", "sumdb", "sum.golang.org"),
+	}
+	seen := map[string]bool{reader.Cache: true}
+	for _, item := range strings.FieldsFunc(proxy, func(char rune) bool { return char == ',' || char == '|' }) {
+		location, err := url.Parse(item)
+		if err != nil {
+			return nil, fmt.Errorf("invalid actual module proxy: %w", err)
+		}
+		if location.Scheme != "file" {
+			continue
+		}
+		if location.Host != "" || location.User != nil || location.RawQuery != "" || location.Fragment != "" || location.Opaque != "" {
+			return nil, fmt.Errorf("checksum reuse requires an absolute local file proxy")
+		}
+		cachePath := filepath.FromSlash(location.Path)
+		// file:///C:/... is Go's local Windows file-proxy spelling. Keep
+		// native drive/UNC handling in filepath rather than accepting hosts.
+		if filepath.Separator == '\\' && len(cachePath) >= 3 && cachePath[0] == '\\' && cachePath[2] == ':' {
+			cachePath = cachePath[1:]
+		}
+		if !filepath.IsAbs(cachePath) {
+			return nil, fmt.Errorf("checksum reuse requires an absolute local file proxy")
+		}
+		cache := filepath.Join(cachePath, "sumdb", "sum.golang.org")
+		if seen[cache] {
+			continue
+		}
+		seen[cache] = true
+		reader.ReadonlyCaches = append(reader.ReadonlyCaches, cache)
+		if len(reader.ReadonlyCaches) > 8 {
+			return nil, fmt.Errorf("checksum cache roots exceed their explicit bound")
+		}
+	}
+	return reader, nil
+}
+
+func (reader *SumDBReader) Height() int                     { return 8 }
+func (reader *SumDBReader) SaveTiles([]tlog.Tile, [][]byte) {}
+
+func (reader *SumDBReader) ReadTiles(tiles []tlog.Tile) ([][]byte, error) {
+	if len(tiles) > 64 {
+		return nil, fmt.Errorf("checksum tile request exceeds its explicit bound")
+	}
+	var result [][]byte
+	for _, tile := range tiles {
+		if tile.H != 8 || tile.W < 1 || tile.W > 256 {
+			return nil, fmt.Errorf("invalid checksum tile extent")
+		}
+		if reader.Context == nil || reader.Context.Err() != nil {
+			return nil, fmt.Errorf("checksum tile request has no live context")
+		}
+		data, err := reader.readCache(tile.Path(), tile.W*tlog.HashSize)
+		if os.IsNotExist(err) && tile.W < 256 {
+			full := tile
+			full.W = 256
+			data, err = reader.readCache(full.Path(), 256*tlog.HashSize)
+			if err == nil && len(data) == 256*tlog.HashSize {
+				data = data[:tile.W*tlog.HashSize]
+			}
+		}
+		if os.IsNotExist(err) {
+			data, err = reader.Read(tile.Path(), tile.W*tlog.HashSize)
+		}
+		if err != nil {
+			return nil, fmt.Errorf("read exact checksum tile %s: %w", tile.Path(), err)
+		}
+		if len(data) != tile.W*tlog.HashSize {
+			return nil, fmt.Errorf("checksum tile %s has an incorrect byte extent", tile.Path())
+		}
+		result = append(result, data)
+	}
+	return result, nil
+}
+
+func (reader *SumDBReader) Read(name string, limit int) ([]byte, error) {
+	if reader.Context == nil || reader.Context.Err() != nil || strings.Contains(name, "..") || strings.HasPrefix(name, "/") {
+		return nil, fmt.Errorf("invalid bounded checksum source read")
+	}
+	data, err := reader.readCache(name, limit)
+	if err == nil {
+		return data, nil
+	}
+	if !os.IsNotExist(err) {
+		return nil, err
+	}
+	request, err := http.NewRequestWithContext(reader.Context, http.MethodGet, "https://sum.golang.org/"+name, nil)
+	if err != nil {
+		return nil, err
+	}
+	client := reader.Client
+	if client == nil {
+		client = http.DefaultClient
+	}
+	response, err := client.Do(request)
+	if err != nil {
+		return nil, fmt.Errorf("read signed checksum source: %w", err)
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("checksum source returned HTTP %d", response.StatusCode)
+	}
+	data, err = io.ReadAll(io.LimitReader(response.Body, int64(limit+1)))
+	if err != nil {
+		return nil, fmt.Errorf("read checksum source: %w", err)
+	}
+	if len(data) > limit {
+		return nil, fmt.Errorf("checksum source exceeds its explicit bound")
+	}
+	return data, nil
+}
+
+func (reader *SumDBReader) readCache(name string, limit int) ([]byte, error) {
+	var missing error
+	for _, cache := range append([]string{reader.Cache}, reader.ReadonlyCaches...) {
+		data, err := ReadChecksumFile(filepath.Join(cache, filepath.FromSlash(name)), limit)
+		if !os.IsNotExist(err) {
+			return data, err // Bad cache bytes or access errors must not be hidden.
+		}
+		missing = err
+	}
+	return nil, missing
+}
+
+func ReadChecksumFile(name string, limit int) ([]byte, error) {
+	info, err := os.Lstat(name)
+	if err != nil {
+		return nil, err
+	}
+	if !info.Mode().IsRegular() || info.Size() > int64(limit) {
+		return nil, fmt.Errorf("checksum cache source is not a bounded regular file")
+	}
+	file, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+	data, err := io.ReadAll(io.LimitReader(file, int64(limit+1)))
+	if err != nil {
+		return nil, err
+	}
+	if len(data) > limit {
+		return nil, fmt.Errorf("checksum cache source exceeds its explicit bound")
+	}
+	return data, nil
+}
diff --git a/internal/gooriginalsrc/dependency_environment.go b/internal/gooriginalsrc/dependency_environment.go
new file mode 100644
index 000000000..ce422bd1c
--- /dev/null
+++ b/internal/gooriginalsrc/dependency_environment.go
@@ -0,0 +1,36 @@
+package gooriginalsrc
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+)
+
+// DependencyQueryEnvironment allows module lookup only in the already observed
+// download cache's file-proxy index. GOPROXY=off cannot resolve legacy imports
+// even when their exact ZIPs are present. There is no network/direct fallback,
+// source rewrite, compiler-version change or checksum-verification exemption.
+func DependencyQueryEnvironment(environment []string) ([]string, error) {
+	cache := ""
+	var result []string
+	for _, item := range environment {
+		key, value, ok := strings.Cut(item, "=")
+		if !ok || key == "" {
+			return nil, fmt.Errorf("malformed dependency query environment")
+		}
+		if key == "GOMODCACHE" {
+			cache = value
+		}
+		if key != "GOPROXY" && key != "GONOPROXY" {
+			result = append(result, item)
+		}
+	}
+	if !filepath.IsAbs(cache) {
+		return nil, fmt.Errorf("dependency query requires an absolute observed module cache")
+	}
+	proxy, err := FileProxyURL(filepath.Join(cache, "cache", "download"))
+	if err != nil {
+		return nil, err
+	}
+	return append(result, "GOPROXY="+proxy, "GONOPROXY=none"), nil
+}
diff --git a/internal/gooriginalsrc/dependency_list.go b/internal/gooriginalsrc/dependency_list.go
new file mode 100644
index 000000000..140dc3b8e
--- /dev/null
+++ b/internal/gooriginalsrc/dependency_list.go
@@ -0,0 +1,124 @@
+package gooriginalsrc
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/mod/module"
+)
+
+// DependencyListRunner executes an actual bounded stock-Go command. It is an
+// IO seam only: output still needs independent exact source/export observation.
+type DependencyListRunner func(directory string, args []string) (stdout, stderr []byte, err error)
+
+// RunDependencyList prepares only private module metadata, then independently
+// repeats the requested query read-only. Preparatory output is never evidence
+// for a compiler export, assembly acceptance or a source exclusion.
+func RunDependencyList(ctx context.Context, temporary, path, version string, args []string, run DependencyListRunner) ([]byte, error) {
+	if len(args) < 2 || len(args) > 7 || args[0] != "list" || run == nil {
+		return nil, fmt.Errorf("exact dependency query needs a bounded list command")
+	}
+	selected := args[len(args)-1]
+	if module.CheckImportPath(selected) != nil || selected != path && !strings.HasPrefix(selected, path+"/") {
+		return nil, fmt.Errorf("dependency query escaped its exact primary package namespace")
+	}
+	seen := make(map[string]bool)
+	for _, argument := range args[1 : len(args)-1] {
+		switch argument {
+		case "-deps", "-compiled", "-export", "-json", "-mod=readonly":
+		default:
+			return nil, fmt.Errorf("unregistered dependency query argument %q", argument)
+		}
+		if seen[argument] {
+			return nil, fmt.Errorf("repeated dependency query argument %q", argument)
+		}
+		seen[argument] = true
+	}
+	if !seen["-json"] || !seen["-mod=readonly"] {
+		return nil, fmt.Errorf("dependency query omitted its complete read-only JSON role")
+	}
+	prepared, readonly := []string{"list", "-mod=mod"}, []string{"list", "-mod=readonly"}
+	for _, argument := range args[1:] {
+		if strings.HasPrefix(argument, "-mod=") {
+			continue
+		}
+		readonly = append(readonly, argument)
+		if argument != "-export" {
+			prepared = append(prepared, argument)
+		}
+	}
+	return RunDependencyQuery(ctx, temporary, path, version, func(directory string) ([]byte, error) {
+		_, diagnostic, err := run(directory, prepared)
+		if err != nil {
+			return nil, fmt.Errorf("prepare exact dependency query: %w; %s", err, diagnostic)
+		}
+		if err := dependencyPreparationDiagnostics(diagnostic); err != nil {
+			return nil, err
+		}
+		entries, _, err := ReadDirectory(directory, 2)
+		if err != nil {
+			return nil, err
+		}
+		snapshot := NewSnapshot()
+		if err := snapshot.Directory(directory, false); err != nil {
+			return nil, err
+		}
+		for _, entry := range entries {
+			if entry.Name() != "go.mod" && entry.Name() != "go.sum" {
+				return nil, fmt.Errorf("dependency preparation created a foreign file")
+			}
+			file := filepath.Join(directory, entry.Name())
+			info, err := os.Lstat(file)
+			if err != nil || !info.Mode().IsRegular() || info.Size() > 256<<10 {
+				return nil, errors.Join(fmt.Errorf("dependency preparation metadata is redirected or over-bound"), err)
+			}
+			if err := snapshot.Retain(file); err != nil {
+				return nil, err
+			}
+		}
+		data, err := snapshot.ReadRetained(filepath.Join(directory, "go.mod"))
+		if err != nil {
+			return nil, err
+		}
+		if err := validateDependencyQueryMetadata(data, path, version); err != nil {
+			return nil, err
+		}
+		output, diagnostic, err := run(directory, readonly)
+		if len(diagnostic) != 0 {
+			err = errors.Join(err, fmt.Errorf("read-only dependency query diagnostics: %s", diagnostic))
+		}
+		return output, errors.Join(err, snapshot.Verify())
+	})
+}
+
+// These are cmd/go's module-resolution progress messages (modload/import.go,
+// modload/load.go and modfetch/fetch.go), never assembler rejection evidence.
+// Unknown diagnostics, nonzero commands and cleanup failures remain errors.
+func dependencyPreparationDiagnostics(data []byte) error {
+	if len(data) > 64<<10 {
+		return fmt.Errorf("dependency preparation diagnostics exceed their bound")
+	}
+	for _, line := range strings.Split(strings.TrimSuffix(string(data), "\n"), "\n") {
+		if line == "" && len(data) == 0 {
+			return nil
+		}
+		fields := strings.Fields(line)
+		valid := false
+		switch {
+		case len(fields) == 4 && fields[0] == "go:" && fields[1] == "downloading":
+			valid = module.Check(fields[2], fields[3]) == nil
+		case len(fields) == 6 && strings.HasPrefix(line, "go: finding module for package "):
+			valid = module.CheckImportPath(fields[5]) == nil
+		case len(fields) == 6 && fields[0] == "go:" && fields[1] == "found" && fields[3] == "in":
+			valid = module.CheckImportPath(fields[2]) == nil && module.Check(fields[4], fields[5]) == nil
+		}
+		if !valid {
+			return fmt.Errorf("unregistered dependency preparation diagnostic: %s", line)
+		}
+	}
+	return nil
+}
diff --git a/internal/gooriginalsrc/dependency_list_test.go b/internal/gooriginalsrc/dependency_list_test.go
new file mode 100644
index 000000000..f5f1a0d2f
--- /dev/null
+++ b/internal/gooriginalsrc/dependency_list_test.go
@@ -0,0 +1,145 @@
+package gooriginalsrc
+
+import (
+	"context"
+	"errors"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestOriginalDependencyListSeparatesPreparationAndEvidence(t *testing.T) {
+	for _, variant := range []string{"complete", "prepare error", "unknown diagnostic", "final diagnostic", "final error", "changed sum", "changed pin"} {
+		t.Run(variant, func(t *testing.T) {
+			calls := 0
+			failure := errors.New("actual command failed")
+			args := []string{"list", "-deps", "-export", "-json", "-mod=readonly", "example.invalid/legacy"}
+			original := append([]string(nil), args...)
+			output, err := RunDependencyList(context.Background(), t.TempDir(), "example.invalid/legacy", "v1.2.3", args,
+				func(directory string, command []string) ([]byte, []byte, error) {
+					calls++
+					actual := strings.Join(command, " ")
+					if calls == 1 {
+						if !strings.Contains(actual, "-mod=mod") || strings.Contains(actual, "-export") {
+							t.Fatal("preparation compiled an export or lost its private metadata role")
+						}
+						if variant == "prepare error" {
+							return nil, nil, failure
+						}
+						if variant == "unknown diagnostic" {
+							return nil, []byte("go: unknown tool failure\n"), nil
+						}
+						if variant == "changed pin" {
+							file := filepath.Join(directory, "go.mod")
+							data, err := os.ReadFile(file)
+							if err != nil {
+								t.Fatal(err)
+							}
+							return nil, nil, os.WriteFile(file, []byte(strings.ReplaceAll(string(data), "v1.2.3", "v1.2.4")), 0600)
+						}
+						if err := os.WriteFile(filepath.Join(directory, "go.sum"), []byte("prepared checksums\n"), 0600); err != nil {
+							t.Fatal(err)
+						}
+						return []byte("not evidence"), []byte("go: finding module for package example.invalid/dep\ngo: found example.invalid/dep in example.invalid/dep v1.0.0\n"), nil
+					}
+					if calls != 2 || !strings.Contains(actual, "-mod=readonly") || !strings.Contains(actual, "-export") {
+						t.Fatal("actual query lost its complete read-only export command")
+					}
+					switch variant {
+					case "final diagnostic":
+						return nil, []byte("go: downloading example.invalid/dep v1.0.0\n"), nil
+					case "final error":
+						return nil, nil, failure
+					case "changed sum":
+						return nil, nil, os.WriteFile(filepath.Join(directory, "go.sum"), []byte("changed\n"), 0600)
+					}
+					return []byte("actual read-only output"), nil, nil
+				})
+			if !reflect.DeepEqual(args, original) {
+				t.Fatal("query mutated caller command arguments")
+			}
+			if variant == "complete" {
+				if err != nil || calls != 2 || string(output) != "actual read-only output" {
+					t.Fatal("read-only query did not close independently", err)
+				}
+			} else if err == nil {
+				t.Fatal("failed or changed query became evidence")
+			}
+			if (variant == "prepare error" || variant == "final error") && !errors.Is(err, failure) {
+				t.Fatal("actual command failure was hidden", err)
+			}
+			if (variant == "prepare error" || variant == "unknown diagnostic" || variant == "changed pin") && calls != 1 {
+				t.Fatal("unclosed preparation reached the export command")
+			}
+		})
+	}
+}
+
+func TestOriginalDependencyProgressIsNotArbitraryDiagnostics(t *testing.T) {
+	for _, diagnostic := range []string{
+		"warning: uncertain result\n", "go: downloading example.invalid/lib nope\n",
+		"go: found ./local in example.invalid/lib v1.0.0\n", "go: finding module for package ../local\n",
+		"go: downloading example.invalid/lib v1.0.0\nunknown failure\n", "\n",
+	} {
+		if dependencyPreparationDiagnostics([]byte(diagnostic)) == nil {
+			t.Fatal("unregistered diagnostic was hidden", diagnostic)
+		}
+	}
+}
+
+func TestOriginalDependencyEnvironmentHasNoNetworkFallback(t *testing.T) {
+	cache := filepath.Join(t.TempDir(), "cache, direct|fallback")
+	env := []string{"GOMODCACHE=" + cache, "GOPROXY=https://example.invalid,direct", "GONOPROXY=*", "GOTOOLCHAIN=local", "GOSUMDB=sum.golang.org"}
+	original := append([]string(nil), env...)
+	actual, err := DependencyQueryEnvironment(env)
+	if err != nil || !reflect.DeepEqual(env, original) {
+		t.Fatal("query altered its caller environment", err)
+	}
+	proxies := 0
+	for _, item := range actual {
+		if strings.HasPrefix(item, "GOPROXY=") {
+			proxies++
+			if !strings.HasPrefix(item, "GOPROXY=file:///") || strings.ContainsAny(item, ",|") {
+				t.Fatal("query acquired a network/direct fallback", item)
+			}
+			location, err := url.Parse(strings.TrimPrefix(item, "GOPROXY="))
+			wanted := filepath.ToSlash(filepath.Join(cache, "cache", "download"))
+			if !strings.HasPrefix(wanted, "/") {
+				wanted = "/" + wanted
+			}
+			if err != nil || location.Path != wanted {
+				t.Fatal("cache proxy no longer names the observed directory", item, err)
+			}
+		}
+		if strings.HasPrefix(item, "GONOPROXY=") && item != "GONOPROXY=none" {
+			t.Fatal("private pattern bypassed the cache-only proxy")
+		}
+	}
+	if proxies != 1 {
+		t.Fatal("ambiguous cache-only proxy environment")
+	}
+}
+
+func TestOriginalDependencyListRejectsUnboundQueryRoles(t *testing.T) {
+	for _, arguments := range [][]string{
+		{"list", "-e", "-json", "-mod=readonly", "example.invalid/legacy"},
+		{"list", "-test", "-json", "-mod=readonly", "example.invalid/legacy"},
+		{"list", "-json", "-mod=vendor", "example.invalid/legacy"},
+		{"list", "-json", "-json", "-mod=readonly", "example.invalid/legacy"},
+		{"list", "-json", "-mod=readonly", "example.invalid/other"},
+		{"list", "-json", "-mod=readonly", "example.invalid/legacy/..."},
+	} {
+		called := false
+		_, err := RunDependencyList(context.Background(), t.TempDir(), "example.invalid/legacy", "v1.2.3", arguments,
+			func(string, []string) ([]byte, []byte, error) {
+				called = true
+				return nil, nil, nil
+			})
+		if err == nil || called {
+			t.Fatal("unbound role reached an actual query", arguments, err)
+		}
+	}
+}
diff --git a/internal/gooriginalsrc/dependency_query.go b/internal/gooriginalsrc/dependency_query.go
new file mode 100644
index 000000000..7a33070bb
--- /dev/null
+++ b/internal/gooriginalsrc/dependency_query.go
@@ -0,0 +1,134 @@
+package gooriginalsrc
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
+)
+
+const dependencyQueryModule = "example.invalid/plan9asm-original-query"
+
+// RunDependencyQuery owns command configuration, not original source or frame
+// authority. The caller still observes every selected exact original module.
+// Only the actual bounded Go query may populate go.mod/go.sum in this private
+// directory. It never writes to the selected archive or adopts ancestor files.
+func RunDependencyQuery(ctx context.Context, temporary, path, version string, run func(string) ([]byte, error)) (_ []byte, result error) {
+	if ctx == nil || run == nil || !filepath.IsAbs(temporary) ||
+		module.Check(path, version) != nil || module.CanonicalVersion(version) != version || path == dependencyQueryModule {
+		return nil, fmt.Errorf("invalid exact dependency query")
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	directory, err := os.MkdirTemp(temporary, "original-dependency-query-")
+	if err != nil {
+		return nil, err
+	}
+	identity, err := os.Lstat(directory)
+	if err != nil {
+		return nil, err
+	}
+	defer func() {
+		result = errors.Join(result, closeDependencyQuery(directory, identity, path, version))
+	}()
+	physical, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return nil, err
+	}
+	directory = physical
+	name := filepath.Join(directory, "go.mod")
+	data := "module " + dependencyQueryModule + "\ngo 1.20\nrequire " + path + " " + version + "\n"
+	file, err := os.OpenFile(name, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0600)
+	if err != nil {
+		return nil, err
+	}
+	_, writeErr := file.WriteString(data)
+	if err := errors.Join(writeErr, file.Close()); err != nil {
+		return nil, err
+	}
+	output, err := run(directory)
+	return output, errors.Join(err, ctx.Err())
+}
+
+func closeDependencyQuery(directory string, identity os.FileInfo, path, version string) error {
+	info, statErr := os.Lstat(directory)
+	if statErr != nil || identity == nil || !info.IsDir() || !os.SameFile(identity, info) {
+		return errors.Join(fmt.Errorf("dependency query directory was redirected or replaced"), statErr)
+	}
+	entries, current, err := ReadDirectory(directory, 2)
+	if err != nil || identity == nil || !os.SameFile(identity, current) {
+		return errors.Join(fmt.Errorf("dependency query directory identity changed"), err)
+	}
+	if len(entries) == 0 {
+		return errors.Join(fmt.Errorf("dependency query lost its metadata"), os.Remove(directory))
+	}
+	snapshot := NewSnapshot()
+	if err := snapshot.Directory(directory, false); err != nil {
+		return err
+	}
+	for _, entry := range entries {
+		if entry.Name() != "go.mod" && entry.Name() != "go.sum" {
+			return fmt.Errorf("dependency query acquired foreign member %q", entry.Name())
+		}
+		name := filepath.Join(directory, entry.Name())
+		info, err := os.Lstat(name)
+		if err != nil || !info.Mode().IsRegular() || info.Size() > 256<<10 {
+			return errors.Join(fmt.Errorf("dependency query metadata is redirected or exceeds its bound"), err)
+		}
+		if err := snapshot.Retain(name); err != nil {
+			return err
+		}
+	}
+	data, err := snapshot.ReadRetained(filepath.Join(directory, "go.mod"))
+	if err != nil {
+		return err
+	}
+	if err := validateDependencyQueryMetadata(data, path, version); err != nil {
+		return err
+	}
+	if err := snapshot.Verify(); err != nil {
+		return err
+	}
+	// Never recursively remove an unexpected member or a replaced directory.
+	// The bounded actual command has completed before any owned file is freed.
+	for _, entry := range entries {
+		if _, err := snapshot.ReadRetained(filepath.Join(directory, entry.Name())); err != nil {
+			return err
+		}
+		if err := os.Remove(filepath.Join(directory, entry.Name())); err != nil {
+			return err
+		}
+	}
+	_, current, err = ReadDirectory(directory, 0)
+	if err != nil || !os.SameFile(identity, current) {
+		return errors.Join(fmt.Errorf("dependency query changed during cleanup"), err)
+	}
+	return os.Remove(directory)
+}
+
+func validateDependencyQueryMetadata(data []byte, path, version string) error {
+	parsed, err := modfile.Parse("go.mod", data, nil)
+	if err != nil || parsed.Module == nil || parsed.Module.Mod.Path != dependencyQueryModule ||
+		len(parsed.Replace)+len(parsed.Exclude)+len(parsed.Retract) != 0 || len(parsed.Require) > 64 {
+		return errors.Join(fmt.Errorf("dependency query lost its separate exact-module configuration"), err)
+	}
+	found := 0
+	for _, requirement := range parsed.Require {
+		if requirement.Mod.Path == path {
+			if requirement.Mod.Version != version {
+				return fmt.Errorf("dependency query changed its exact primary version")
+			}
+			found++
+		}
+	}
+	if found != 1 {
+		return fmt.Errorf("dependency query omitted or repeated its exact primary module")
+	}
+	return nil
+}
diff --git a/internal/gooriginalsrc/dependency_query_test.go b/internal/gooriginalsrc/dependency_query_test.go
new file mode 100644
index 000000000..6c3a25c17
--- /dev/null
+++ b/internal/gooriginalsrc/dependency_query_test.go
@@ -0,0 +1,80 @@
+package gooriginalsrc
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestOriginalDependencyQueryOwnsSeparateMetadata(t *testing.T) {
+	temporary := t.TempDir()
+	ancestor := filepath.Join(temporary, "go.mod")
+	const ancestorBytes = "module example.invalid/ancestor\ngo 1.20\n"
+	if err := os.WriteFile(ancestor, []byte(ancestorBytes), 0600); err != nil {
+		t.Fatal(err)
+	}
+	var directory string
+	output, err := RunDependencyQuery(context.Background(), temporary, "example.invalid/legacy", "v1.2.3", func(dir string) ([]byte, error) {
+		directory = dir
+		data, err := os.ReadFile(filepath.Join(dir, "go.mod"))
+		if err != nil || dir == temporary || !strings.Contains(string(data), "require example.invalid/legacy v1.2.3\n") {
+			return nil, fmt.Errorf("exact legacy dependency lacks an independently owned query: %v", err)
+		}
+		if err := os.WriteFile(filepath.Join(dir, "go.sum"), []byte("command-produced checksums\n"), 0600); err != nil {
+			return nil, err
+		}
+		return []byte("actual query output"), nil
+	})
+	if err != nil || string(output) != "actual query output" {
+		t.Fatal("dependency query did not retain its actual command", err)
+	}
+	if _, err := os.Lstat(directory); !os.IsNotExist(err) {
+		t.Fatal("completed command left its owned metadata", err)
+	}
+	data, err := os.ReadFile(ancestor)
+	if err != nil || string(data) != ancestorBytes {
+		t.Fatal("query changed ancestor metadata", err)
+	}
+}
+
+func TestOriginalDependencyQueryFailureAndForeignCleanup(t *testing.T) {
+	for _, variant := range []string{"command failure", "foreign member", "redirected metadata", "changed pin", "replacement", "removed metadata"} {
+		t.Run(variant, func(t *testing.T) {
+			temporary := t.TempDir()
+			var directory string
+			commandFailure := errors.New("actual query failed")
+			_, err := RunDependencyQuery(context.Background(), temporary, "example.invalid/legacy", "v1.2.3", func(dir string) ([]byte, error) {
+				directory = dir
+				switch variant {
+				case "command failure":
+					return nil, commandFailure
+				case "foreign member":
+					return nil, os.WriteFile(filepath.Join(dir, "foreign.txt"), []byte("preserve"), 0600)
+				case "redirected metadata":
+					return nil, os.Symlink(filepath.Join(temporary, "outside"), filepath.Join(dir, "go.sum"))
+				case "removed metadata":
+					return nil, os.Remove(filepath.Join(dir, "go.mod"))
+				case "changed pin", "replacement":
+					data := "module example.invalid/plan9asm-original-query\ngo 1.20\nrequire example.invalid/legacy v1.2.4\n"
+					if variant == "replacement" {
+						data = strings.ReplaceAll(data, "v1.2.4", "v1.2.3") + "replace example.invalid/legacy => ../foreign\n"
+					}
+					return nil, os.WriteFile(filepath.Join(dir, "go.mod"), []byte(data), 0600)
+				}
+				return nil, nil
+			})
+			if err == nil || variant == "command failure" && !errors.Is(err, commandFailure) {
+				t.Fatal("failed or foreign command became a successful query", err)
+			}
+			if variant == "foreign member" {
+				if data, err := os.ReadFile(filepath.Join(directory, "foreign.txt")); err != nil || string(data) != "preserve" {
+					t.Fatal("query cleanup removed a foreign member", err)
+				}
+			}
+		})
+	}
+}
diff --git a/internal/gooriginalsrc/digest.go b/internal/gooriginalsrc/digest.go
new file mode 100644
index 000000000..2600b5c01
--- /dev/null
+++ b/internal/gooriginalsrc/digest.go
@@ -0,0 +1,33 @@
+package gooriginalsrc
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+// HashRegularFile streams every current byte of a canonical bounded file. The
+// existing physical reader checks opening/EOF identity, extent and close errors.
+// This digest is not a retained Snapshot, source role or ASM capability. Each
+// call opens and reads the file again; neither metadata nor a cache supplies it.
+func HashRegularFile(name string, maximum int64) ([sha256.Size]byte, error) {
+	var result [sha256.Size]byte
+	info, err := os.Lstat(name)
+	if err != nil || !filepath.IsAbs(name) || !info.Mode().IsRegular() ||
+		maximum < 0 || maximum > toolByteLimit || info.Size() < 0 || info.Size() > maximum {
+		return result, fmt.Errorf("canonical regular file is missing or exceeds its byte bound")
+	}
+	reader, err := openOriginalRoleFile(name, info, name, "", originalToolFile)
+	if err != nil {
+		return result, err
+	}
+	// Hide io.Discard.ReaderFrom: CopyBuffer must use the existing pooled
+	// 64-KiB buffer, not Discard's separate small-read fast path.
+	if err := copyOriginalFile(struct{ io.Writer }{io.Discard}, reader); err != nil {
+		return result, err
+	}
+	reader.hash.Sum(result[:0])
+	return result, nil
+}
diff --git a/internal/gooriginalsrc/digest_test.go b/internal/gooriginalsrc/digest_test.go
new file mode 100644
index 000000000..763f60502
--- /dev/null
+++ b/internal/gooriginalsrc/digest_test.go
@@ -0,0 +1,69 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+)
+
+func TestHashRegularFileExactBytesAndBounds(t *testing.T) {
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := filepath.Join(directory, "input")
+	for _, size := range []int{0, 1, 65535, 65536, 65537, 1 << 20} {
+		data := bytes.Repeat([]byte{0xa5}, size)
+		if err := os.WriteFile(name, data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		digest, err := HashRegularFile(name, int64(size))
+		if err != nil || digest != sha256.Sum256(data) {
+			t.Fatal("complete bounded bytes changed", size, err)
+		}
+		if size > 0 {
+			if _, err := HashRegularFile(name, int64(size-1)); err == nil {
+				t.Fatal("file exceeded the caller's exact byte bound", size)
+			}
+		}
+	}
+	for _, limit := range []int64{-1, toolByteLimit + 1} {
+		if _, err := HashRegularFile(name, limit); err == nil {
+			t.Fatal("invalid bound acquired a physical file observation", limit)
+		}
+	}
+	if _, err := HashRegularFile(directory, toolByteLimit); err == nil {
+		t.Fatal("directory became a regular-file digest")
+	}
+}
+
+func TestHashRegularFileConcurrentPoolIsolation(t *testing.T) {
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var workers sync.WaitGroup
+	for index := 0; index < 8; index++ {
+		name := filepath.Join(directory, string(rune('a'+index)))
+		data := bytes.Repeat([]byte{byte(index)}, 65537+index)
+		if err := os.WriteFile(name, data, 0600); err != nil {
+			t.Fatal(err)
+		}
+		want := sha256.Sum256(data)
+		workers.Add(1)
+		go func(name string, want [32]byte) {
+			defer workers.Done()
+			for round := 0; round < 8; round++ {
+				actual, err := HashRegularFile(name, toolByteLimit)
+				if err != nil || actual != want {
+					t.Error("pooled buffer mixed independent physical files", err)
+					return
+				}
+			}
+		}(name, want)
+	}
+	workers.Wait()
+}
diff --git a/internal/gooriginalsrc/directory.go b/internal/gooriginalsrc/directory.go
new file mode 100644
index 000000000..a4e500d52
--- /dev/null
+++ b/internal/gooriginalsrc/directory.go
@@ -0,0 +1,54 @@
+package gooriginalsrc
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// ReadDirectory returns a complete bounded physical inventory, not a source
+// capability. Consumers select their own fixed limit and retain its identity.
+func ReadDirectory(name string, maximum int) (_ []os.DirEntry, _ os.FileInfo, result error) {
+	if !filepath.IsAbs(name) || maximum < 0 || maximum > fileLimit+directoryLimit {
+		return nil, nil, fmt.Errorf("original directory has no absolute bounded inventory role")
+	}
+	physical, err := sourcepath.Resolve(name)
+	before, statErr := os.Lstat(physical)
+	if err != nil || statErr != nil || !before.IsDir() {
+		return nil, nil, errors.Join(err, statErr, fmt.Errorf("original directory is unavailable"))
+	}
+	file, err := os.Open(physical)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer func() { result = errors.Join(result, file.Close()) }()
+	opened, err := file.Stat()
+	if err != nil || !opened.IsDir() || !os.SameFile(before, opened) {
+		return nil, nil, errors.Join(err, fmt.Errorf("original directory changed while opening"))
+	}
+	entries, err := file.ReadDir(maximum + 1)
+	if err != nil && err != io.EOF {
+		return nil, nil, err
+	}
+	if len(entries) > maximum {
+		return nil, nil, fmt.Errorf("original directory inventory exceeds its count bound")
+	}
+	// ReadDir may return its last nonempty batch without EOF. Require a further
+	// empty read with real EOF; a bounded prefix must never become a success.
+	if extra, err := file.ReadDir(1); len(extra) != 0 || err != io.EOF {
+		return nil, nil, errors.Join(err, fmt.Errorf("original directory inventory lacks complete EOF"))
+	}
+	after, statErr := os.Lstat(physical)
+	resolved, resolveErr := sourcepath.Resolve(name)
+	if statErr != nil || resolveErr != nil || resolved != physical || !after.IsDir() ||
+		!os.SameFile(opened, after) || before.Size() != after.Size() || !before.ModTime().Equal(after.ModTime()) {
+		return nil, nil, errors.Join(statErr, resolveErr, fmt.Errorf("original directory identity or generation changed while reading"))
+	}
+	sort.Slice(entries, func(i, j int) bool { return entries[i].Name() < entries[j].Name() })
+	return entries, before, nil
+}
diff --git a/internal/gooriginalsrc/directory_test.go b/internal/gooriginalsrc/directory_test.go
new file mode 100644
index 000000000..e18c2608f
--- /dev/null
+++ b/internal/gooriginalsrc/directory_test.go
@@ -0,0 +1,92 @@
+package gooriginalsrc
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+	"testing"
+)
+
+func TestSnapshotNonrecursiveGraphMemberBounds(t *testing.T) {
+	for _, role := range []string{"files across directories", "directory members"} {
+		t.Run(role, func(t *testing.T) {
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			snapshot := NewSnapshot()
+			if role == "directory members" {
+				for i := 0; i < directoryLimit; i++ {
+					if err := os.Mkdir(filepath.Join(root, fmt.Sprintf("directory-%04d", i)), 0700); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := snapshot.Directory(root, false); err == nil {
+					t.Fatal("nonrecursive original directory members acquired a fresh graph-wide count budget")
+				}
+				return
+			}
+			for _, part := range []string{"first", "second"} {
+				directory := filepath.Join(root, part)
+				if err := os.Mkdir(directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				for i := 0; i < fileLimit/2+1; i++ {
+					file, err := os.OpenFile(filepath.Join(directory, fmt.Sprintf("member-%05d", i)), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := file.Close(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				if err := snapshot.Directory(directory, false); part == "first" {
+					if err != nil {
+						t.Fatal("actual first bounded inventory was rejected", err)
+					}
+				} else if err == nil {
+					t.Fatal("nonrecursive original file members acquired a fresh graph-wide count budget")
+				}
+			}
+		})
+	}
+}
+
+func TestOriginalDirectoryBoundedEOF(t *testing.T) {
+	for _, maximum := range []int{0, 1, 256} {
+		t.Run(fmt.Sprintf("bound-%d", maximum), func(t *testing.T) {
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for i := maximum - 1; i >= 0; i-- {
+				if err := os.WriteFile(filepath.Join(root, fmt.Sprintf("member-%03d", i)), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			entries, info, err := ReadDirectory(root, maximum)
+			if err != nil || info == nil || len(entries) != maximum {
+				t.Fatal("complete directory did not close its actual boundary EOF", err)
+			}
+			names := make([]string, len(entries))
+			for i, entry := range entries {
+				names[i] = entry.Name()
+			}
+			if !sort.StringsAreSorted(names) {
+				t.Fatal("bounded original inventory changed the stable sorted member rule")
+			}
+			if err := os.WriteFile(filepath.Join(root, "overflow"), nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+			if entries, _, err := ReadDirectory(root, maximum); err == nil || entries != nil {
+				t.Fatal("a truncated bounded directory prefix was accepted as complete")
+			}
+		})
+	}
+	for _, name := range []string{"", ".", "relative/directory"} {
+		if _, _, err := ReadDirectory(name, 1); err == nil {
+			t.Fatal("directory reader accepted a relative physical role")
+		}
+	}
+}
diff --git a/internal/gooriginalsrc/download.go b/internal/gooriginalsrc/download.go
new file mode 100644
index 000000000..46d4721e1
--- /dev/null
+++ b/internal/gooriginalsrc/download.go
@@ -0,0 +1,277 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/modfile"
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+var ErrUnclosedModuleDeclaration = errors.New("original downloaded module declaration/language is unclosed")
+
+// DownloadReceipt is ordinary data decoded from an actual driver's stdout.
+// Supplying it cannot create an object/frame token; each factory owns its command.
+type DownloadReceipt struct {
+	Path, Version, Dir, Zip, GoMod, Sum, GoModSum, Error string
+}
+
+// Module separates the exact archive identity from the original go.mod namespace.
+// It is a value-copy observation, not a source permission or mutation interface.
+type Module struct {
+	SourceModule, SourceVersion string
+	Root, GoMod, ModulePath     string
+	// GoModOrigin distinguishes an original ZIP member from independently
+	// authenticated proxy metadata; the latter must never become a ZIP file.
+	GoModOrigin string
+	// GoVersion preserves the original directive, including its absence.
+	GoVersion string
+}
+
+// SelectedGoVersion models cmd/go's module metadata, not a caller-supplied
+// language override. A main module without a go line has the fixed 1.16
+// default; dependency metadata retains the absent directive as an empty field.
+// Consumers must still match the actual Go query and guard the original bytes.
+func SelectedGoVersion(declared string, main bool) string {
+	if declared == "" && main {
+		return "1.16"
+	}
+	return declared
+}
+
+// OriginSet shares the original graph-wide inventory bounds across exact modules.
+// Unrelated cache additions are allowed; observed parent identities are not.
+type OriginSet struct {
+	mu          sync.Mutex
+	cache       string
+	files       *Snapshot
+	directories map[string]os.FileInfo
+	modules     map[string]Module
+	revoked     bool
+}
+
+func NewOriginSet(cache, goBinary string) (*OriginSet, error) {
+	if !filepath.IsAbs(cache) || !filepath.IsAbs(goBinary) {
+		return nil, fmt.Errorf("exact source guard requires bounded absolute cache/tool roles")
+	}
+	set := &OriginSet{cache: cache, files: newModuleSnapshot(),
+		directories: make(map[string]os.FileInfo), modules: make(map[string]Module)}
+	if err := set.retainCacheDirectory(cache); err != nil {
+		return nil, err
+	}
+	if err := set.files.RetainTool(goBinary); err != nil {
+		return nil, err
+	}
+	return set, nil
+}
+
+// Observe validates the complete original ZIP, metadata and extracted tree.
+// The caller must independently execute its actual exact-download command.
+func (set *OriginSet) Observe(ctx context.Context, path, version string, receipt DownloadReceipt) (_ Module, result error) {
+	return set.observe(ctx, path, version, receipt, nil)
+}
+
+// ObserveLegacy retains exactly the same whole-ZIP/tree/tool checks as Observe.
+// The separate public SumDB proof may supply only canonical metadata absent
+// from that complete ZIP. A proof, receipt or Module alone grants no package
+// selection, compiler, native-frame or assembly capability.
+func (set *OriginSet) ObserveLegacy(ctx context.Context, path, version string, receipt DownloadReceipt, proof *golegacymod.ProxyGoModProof) (Module, error) {
+	return set.observe(ctx, path, version, receipt, proof)
+}
+
+func (set *OriginSet) observe(ctx context.Context, path, version string, receipt DownloadReceipt, proof *golegacymod.ProxyGoModProof) (_ Module, result error) {
+	if set == nil || ctx == nil {
+		return Module{}, fmt.Errorf("exact source observation requires a live origin set and context")
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	defer func() {
+		if result != nil {
+			set.revoked = true
+		}
+	}()
+	if err := ctx.Err(); err != nil {
+		return Module{}, err
+	}
+	if err := set.verifyLocked(); err != nil {
+		return Module{}, err
+	}
+	if module.Check(path, version) != nil || module.CanonicalVersion(version) != version {
+		return Module{}, fmt.Errorf("downloaded source requires a canonical exact module version")
+	}
+	if receipt.Error != "" || receipt.Path != path || receipt.Version != version {
+		return Module{}, fmt.Errorf("actual module download returned a different or incomplete exact identity")
+	}
+	key := path + "@" + version
+	if _, exists := set.modules[key]; !exists && len(set.modules) >= 64 {
+		return Module{}, fmt.Errorf("downloaded source module graph exceeds its explicit bound")
+	}
+	escapedPath, err := module.EscapePath(path)
+	if err != nil {
+		return Module{}, err
+	}
+	escapedVersion, err := module.EscapeVersion(version)
+	if err != nil {
+		return Module{}, err
+	}
+	root := filepath.Join(set.cache, escapedPath+"@"+escapedVersion)
+	prefix := filepath.Join(set.cache, "cache", "download", escapedPath, "@v", escapedVersion)
+	roles := []struct{ actual, expected string }{
+		{receipt.Dir, root}, {receipt.Zip, prefix + ".zip"}, {receipt.GoMod, prefix + ".mod"},
+	}
+	for _, role := range roles {
+		physical, err := sourcepath.Resolve(role.actual)
+		if err != nil || physical != role.expected {
+			return Module{}, fmt.Errorf("actual exact download escaped its canonical cache source role")
+		}
+		for directory := filepath.Dir(role.expected); ; directory = filepath.Dir(directory) {
+			if err := set.retainCacheDirectory(directory); err != nil {
+				return Module{}, err
+			}
+			if directory == set.cache {
+				break
+			}
+			relative, err := filepath.Rel(set.cache, directory)
+			if err != nil || !filepath.IsLocal(relative) {
+				return Module{}, fmt.Errorf("downloaded cache directory role escaped its observed root")
+			}
+		}
+	}
+	// The actual receipt may spell a validated ancestor alias. All retained
+	// source roles below use the independently checked canonical cache paths.
+	receipt.Dir, receipt.Zip, receipt.GoMod = root, prefix+".zip", prefix+".mod"
+	if err := set.files.Directory(root, true); err != nil {
+		return Module{}, err
+	}
+	for _, name := range []string{prefix + ".zip", prefix + ".mod"} {
+		if err := set.files.Retain(name); err != nil {
+			return Module{}, err
+		}
+	}
+	zipSum, dirSum, err := set.moduleHashes(ctx, root, path, version, prefix+".zip")
+	if err != nil {
+		return Module{}, fmt.Errorf("original module ZIP/tree did not close: %w", err)
+	}
+	if zipSum != receipt.Sum {
+		return Module{}, fmt.Errorf("original ZIP bytes differ from actual Go download h1")
+	}
+	if dirSum != zipSum {
+		return Module{}, fmt.Errorf("complete original cache directory differs from original ZIP h1")
+	}
+	modData, origin, err := set.moduleMetadata(path, version, receipt, proof)
+	if err != nil {
+		return Module{}, err
+	}
+	modSum, err := dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+		return io.NopCloser(bytes.NewReader(modData)), nil
+	})
+	if err != nil || modSum != receipt.GoModSum {
+		return Module{}, fmt.Errorf("original module metadata differs from actual Go download h1")
+	}
+	parsed, err := modfile.Parse(receipt.GoMod, modData, nil)
+	if err != nil || parsed.Module == nil {
+		return Module{}, ErrUnclosedModuleDeclaration
+	}
+	observed := Module{SourceModule: path, SourceVersion: version, Root: root,
+		GoMod: prefix + ".mod", ModulePath: parsed.Module.Mod.Path, GoModOrigin: origin}
+	if parsed.Go != nil {
+		observed.GoVersion = parsed.Go.Version
+	}
+	set.modules[key] = observed
+	if err := ctx.Err(); err != nil {
+		return Module{}, err
+	}
+	return observed, set.verifyLocked()
+}
+
+// OriginalZIPGoMod identifies metadata retained as an actual archive member.
+const OriginalZIPGoMod = "original_zip_go_mod"
+
+// Called only after the complete extracted tree and original ZIP hashes agree.
+// The metadata proof does not replace either source observation. The complete
+// retained directory inventory detects a subsequently added go.mod too.
+func (set *OriginSet) moduleMetadata(path, version string, receipt DownloadReceipt, proof *golegacymod.ProxyGoModProof) ([]byte, string, error) {
+	goMod := filepath.Join(receipt.Dir, "go.mod")
+	memberHash := set.files.hashes[goMod]
+	if memberHash != "" {
+		if proof != nil || memberHash != set.files.hashes[receipt.GoMod] {
+			return nil, "", fmt.Errorf("original ZIP go.mod differs from exact downloaded module metadata")
+		}
+		data, err := set.files.ReadRetained(goMod)
+		return data, OriginalZIPGoMod, err
+	}
+	if proof == nil {
+		return nil, "", fmt.Errorf("original ZIP lacks go.mod and authenticated legacy proxy metadata")
+	}
+	if _, err := os.Lstat(goMod); !os.IsNotExist(err) {
+		return nil, "", fmt.Errorf("legacy metadata requires an absent original go.mod path: %v", err)
+	}
+	if err := golegacymod.ValidateProxyGoMod(proof); err != nil {
+		return nil, "", err
+	}
+	data, err := set.files.ReadRetained(receipt.GoMod)
+	if err != nil {
+		return nil, "", err
+	}
+	if proof.Module != path || proof.Version != version || proof.ModuleSum != receipt.Sum ||
+		proof.GoModSum != receipt.GoModSum || proof.SHA256 != set.files.hashes[receipt.GoMod] ||
+		proof.Contents != string(data) {
+		return nil, "", fmt.Errorf("legacy proxy metadata differs from exact original ZIP/download identity")
+	}
+	return data, golegacymod.ProxyGoModProtocol, nil
+}
+
+func (set *OriginSet) retainCacheDirectory(name string) error {
+	if !filepath.IsAbs(name) {
+		return fmt.Errorf("downloaded cache directory requires an absolute physical role")
+	}
+	if _, retained := set.directories[name]; !retained && len(set.directories) >= directoryLimit {
+		return fmt.Errorf("downloaded cache directory inventory exceeds its count bound")
+	}
+	physical, err := sourcepath.Resolve(name)
+	info, statErr := os.Lstat(name)
+	if err != nil || statErr != nil || physical != name || !info.IsDir() {
+		return fmt.Errorf("downloaded source cache directory is missing, redirected or over-bound")
+	}
+	if previous := set.directories[name]; previous != nil && !os.SameFile(previous, info) {
+		return fmt.Errorf("downloaded source cache directory identity changed during capture")
+	}
+	set.directories[name] = info
+	return nil
+}
+
+func (set *OriginSet) Verify() error {
+	if set == nil {
+		return fmt.Errorf("missing exact original source guard")
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	err := set.verifyLocked()
+	if err != nil {
+		set.revoked = true
+	}
+	return err
+}
+
+func (set *OriginSet) verifyLocked() error {
+	if set.revoked {
+		return fmt.Errorf("exact original source guard is permanently revoked")
+	}
+	for name, expected := range set.directories {
+		physical, err := sourcepath.Resolve(name)
+		actual, statErr := os.Lstat(name)
+		if err != nil || statErr != nil || physical != name || !actual.IsDir() || !os.SameFile(expected, actual) {
+			return fmt.Errorf("downloaded source cache directory identity changed")
+		}
+	}
+	return set.files.Verify()
+}
diff --git a/internal/gooriginalsrc/download_boundary.go b/internal/gooriginalsrc/download_boundary.go
new file mode 100644
index 000000000..4dc718d23
--- /dev/null
+++ b/internal/gooriginalsrc/download_boundary.go
@@ -0,0 +1,205 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+)
+
+// ErrDownloadBoundaryChanged rejects cleanup of foreign bytes or identities.
+var ErrDownloadBoundaryChanged = errors.New("download command boundary changed")
+
+// DownloadBoundary owns temporary command IO, not source or frame authority.
+// It removes only its original metadata file and then its empty directory.
+type DownloadBoundary struct {
+	mu                      sync.Mutex
+	identity                *DownloadBoundary
+	directory, name         string
+	directoryInfo, fileInfo os.FileInfo
+	file                    *os.File
+	metadata                string
+	written                 []byte
+	prepared                bool
+	fileClosed, fileRemoved bool
+	directoryRemoved        bool
+	closeErr                error
+}
+
+// NewDownloadBoundary gives a download command an independent module boundary
+// so that it cannot mutate an ancestor module. All IO uses actual OS primitives.
+func NewDownloadBoundary(temporary, prefix, modulePath string) (_ *DownloadBoundary, result error) {
+	if temporary != "" && !filepath.IsAbs(temporary) ||
+		prefix == "" || len(prefix) > 255 || strings.ContainsAny(prefix, "/\\\x00") ||
+		module.CheckPath(modulePath) != nil || len(modulePath) > fileByteLimit-32 {
+		return nil, fmt.Errorf("invalid bounded download command boundary")
+	}
+	created, err := os.MkdirTemp(temporary, prefix)
+	if err != nil {
+		return nil, err
+	}
+	boundary := &DownloadBoundary{directory: created, metadata: "module " + modulePath + "\ngo 1.20\n"}
+	boundary.identity = boundary
+	boundary.directoryInfo, err = os.Lstat(created)
+	if err != nil || !boundary.directoryInfo.IsDir() {
+		// Without a stable directory identity there is no safe cleanup target.
+		return nil, errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, boundary.Close())
+		}
+	}()
+	physical, err := sourcepath.Resolve(created)
+	if err != nil {
+		return nil, err
+	}
+	boundary.directory = physical
+	entries, info, err := ReadDirectory(physical, 0)
+	if err != nil || len(entries) != 0 || !os.SameFile(boundary.directoryInfo, info) {
+		return nil, errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	boundary.name = filepath.Join(physical, "go.mod")
+	boundary.file, err = os.OpenFile(boundary.name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		return nil, err
+	}
+	boundary.fileInfo, err = boundary.file.Stat()
+	if err != nil {
+		return nil, err
+	}
+	return boundary, nil
+}
+
+func (boundary *DownloadBoundary) ownsIdentity() bool {
+	return boundary != nil && boundary.identity == boundary
+}
+
+// Directory exposes only a command working directory, never a source role.
+func (boundary *DownloadBoundary) Directory() string {
+	if !boundary.ownsIdentity() {
+		return ""
+	}
+	return boundary.directory
+}
+
+// Prepare writes and closes the actual descriptor. A failed or partial write
+// retains its cause and cleans up only the bytes that were actually written.
+func (boundary *DownloadBoundary) Prepare() (result error) {
+	if !boundary.ownsIdentity() {
+		return ErrDownloadBoundaryChanged
+	}
+	boundary.mu.Lock()
+	defer boundary.mu.Unlock()
+	if boundary.prepared || boundary.fileClosed || boundary.directoryRemoved {
+		return errors.Join(ErrDownloadBoundaryChanged, boundary.closeErr)
+	}
+	boundary.prepared = true
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, boundary.close())
+		}
+	}()
+	n, err := boundary.file.WriteString(boundary.metadata)
+	boundary.written = []byte(boundary.metadata[:n])
+	if err := errors.Join(err, boundary.closeFile()); err != nil {
+		return err
+	}
+	return boundary.verify()
+}
+
+func (boundary *DownloadBoundary) closeFile() error {
+	if boundary.file != nil && !boundary.fileClosed {
+		boundary.fileClosed = true
+		boundary.closeErr = boundary.file.Close()
+	}
+	return boundary.closeErr
+}
+
+// Verify checks the complete current directory, original inode and full bytes.
+func (boundary *DownloadBoundary) Verify() error {
+	if !boundary.ownsIdentity() {
+		return ErrDownloadBoundaryChanged
+	}
+	boundary.mu.Lock()
+	defer boundary.mu.Unlock()
+	return boundary.verify()
+}
+
+func (boundary *DownloadBoundary) verify() error {
+	entries, info, err := ReadDirectory(boundary.directory, 1)
+	if err != nil || boundary.directoryInfo == nil || !os.SameFile(boundary.directoryInfo, info) {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	if len(entries) != 1 || entries[0].Name() != "go.mod" || boundary.fileInfo == nil {
+		return ErrDownloadBoundaryChanged
+	}
+	actual, err := os.Lstat(boundary.name)
+	if err != nil || !actual.Mode().IsRegular() || !os.SameFile(boundary.fileInfo, actual) || actual.Size() != int64(len(boundary.written)) {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	snapshot := NewSnapshot()
+	if err := snapshot.Retain(boundary.name); err != nil {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	data, err := snapshot.ReadRetained(boundary.name)
+	if err != nil || !bytes.Equal(data, boundary.written) {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	after, err := os.Lstat(boundary.name)
+	if err != nil || !os.SameFile(boundary.fileInfo, after) {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	if err := snapshot.Verify(); err != nil {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	entries, info, err = ReadDirectory(boundary.directory, 1)
+	if err != nil || !os.SameFile(boundary.directoryInfo, info) || len(entries) != 1 || entries[0].Name() != "go.mod" {
+		return errors.Join(ErrDownloadBoundaryChanged, err)
+	}
+	return nil
+}
+
+// Close is nonrecursive and refuses foreign members, bytes or inode changes.
+func (boundary *DownloadBoundary) Close() error {
+	if boundary == nil {
+		return nil
+	}
+	if !boundary.ownsIdentity() {
+		return ErrDownloadBoundaryChanged
+	}
+	boundary.mu.Lock()
+	defer boundary.mu.Unlock()
+	return boundary.close()
+}
+
+func (boundary *DownloadBoundary) close() error {
+	result := boundary.closeFile()
+	if boundary.directoryRemoved {
+		return result
+	}
+	if boundary.fileInfo != nil && !boundary.fileRemoved {
+		if err := boundary.verify(); err != nil {
+			return errors.Join(result, err)
+		}
+		if err := os.Remove(boundary.name); err != nil {
+			return errors.Join(result, err)
+		}
+		boundary.fileRemoved = true
+	}
+	entries, info, err := ReadDirectory(boundary.directory, 0)
+	if err != nil || boundary.directoryInfo == nil || !os.SameFile(boundary.directoryInfo, info) || len(entries) != 0 {
+		return errors.Join(result, ErrDownloadBoundaryChanged, err)
+	}
+	err = os.Remove(boundary.directory)
+	if err == nil {
+		boundary.directoryRemoved = true
+	}
+	return errors.Join(result, err)
+}
diff --git a/internal/gooriginalsrc/download_boundary_test.go b/internal/gooriginalsrc/download_boundary_test.go
new file mode 100644
index 000000000..c016c0ddd
--- /dev/null
+++ b/internal/gooriginalsrc/download_boundary_test.go
@@ -0,0 +1,167 @@
+package gooriginalsrc
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestOriginalDownloadBoundaryFailureAndForeignGuards(t *testing.T) {
+	for _, role := range []string{"closed FD", "same-inode bytes", "file replacement", "directory replacement", "foreign member"} {
+		t.Run(role, func(t *testing.T) {
+			boundary, err := NewDownloadBoundary(t.TempDir(), "original-download-", "example.invalid/command")
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := boundary.Close(); err != nil && !errors.Is(err, os.ErrClosed) {
+					t.Error(err)
+				}
+			})
+			if role == "closed FD" {
+				if err := boundary.file.Close(); err != nil {
+					t.Fatal(err)
+				}
+				err := boundary.Prepare()
+				if !errors.Is(err, os.ErrClosed) {
+					t.Fatal("actual closed-descriptor write failure was not retained", err)
+				}
+				t.Log("ACTUAL_CLOSED_FD_WRITE", err)
+				if _, err := os.Lstat(boundary.directory); !os.IsNotExist(err) {
+					t.Fatal("actual early write failure left its owned command boundary", err)
+				}
+				return
+			}
+			if err := boundary.Prepare(); err != nil {
+				t.Fatal(err)
+			}
+			switch role {
+			case "same-inode bytes":
+				changed := append([]byte(nil), boundary.written...)
+				changed[0] ^= 1
+				if err := os.WriteFile(boundary.name, changed, 0600); err != nil {
+					t.Fatal(err)
+				}
+				info, err := os.Lstat(boundary.name)
+				if err != nil || !os.SameFile(info, boundary.fileInfo) {
+					t.Fatal("byte mutation did not keep original inode", err)
+				}
+				if !errors.Is(boundary.Close(), ErrDownloadBoundaryChanged) {
+					t.Fatal("changed same-inode metadata was removed")
+				}
+				if data, err := os.ReadFile(boundary.name); err != nil || string(data) != string(changed) {
+					t.Fatal("foreign byte mutation was not preserved", err)
+				}
+				if err := os.WriteFile(boundary.name, boundary.written, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "file replacement":
+				moved := filepath.Join(t.TempDir(), "original-metadata")
+				if err := os.Rename(boundary.name, moved); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(boundary.name, boundary.written, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(boundary.Close(), ErrDownloadBoundaryChanged) {
+					t.Fatal("same-byte replacement metadata was removed")
+				}
+				if _, err := os.Stat(boundary.name); err != nil {
+					t.Fatal("replacement metadata was not preserved", err)
+				}
+				if err := os.Remove(boundary.name); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(moved, boundary.name); err != nil {
+					t.Fatal(err)
+				}
+			case "directory replacement":
+				moved := filepath.Join(t.TempDir(), "original-boundary")
+				if err := os.Rename(boundary.directory, moved); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(boundary.directory, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(boundary.Close(), ErrDownloadBoundaryChanged) {
+					t.Fatal("foreign replacement directory was removed")
+				}
+				if err := os.Remove(boundary.directory); err != nil {
+					t.Fatal("replacement directory was not preserved", err)
+				}
+				if err := os.Rename(moved, boundary.directory); err != nil {
+					t.Fatal(err)
+				}
+			case "foreign member":
+				foreign := filepath.Join(boundary.directory, "foreign.txt")
+				if err := os.WriteFile(foreign, []byte("foreign owner"), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !errors.Is(boundary.Close(), ErrDownloadBoundaryChanged) {
+					t.Fatal("unexpected member did not invalidate cleanup")
+				}
+				if data, err := os.ReadFile(foreign); err != nil || string(data) != "foreign owner" {
+					t.Fatal("foreign member was not preserved", err)
+				}
+				if err := os.Remove(foreign); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func TestOriginalDownloadBoundaryOwnerAndUnpreparedCleanup(t *testing.T) {
+	for _, prepared := range []bool{false, true} {
+		t.Run(map[bool]string{false: "empty original", true: "prepared original"}[prepared], func(t *testing.T) {
+			boundary, err := NewDownloadBoundary(t.TempDir(), "original-download-", "example.invalid/command")
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Cleanup(func() {
+				if err := boundary.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if prepared {
+				if err := boundary.Prepare(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			copied := new(DownloadBoundary)
+			reflect.ValueOf(copied).Elem().Set(reflect.ValueOf(boundary).Elem())
+			if copied.Directory() != "" || !errors.Is(copied.Verify(), ErrDownloadBoundaryChanged) ||
+				!errors.Is(copied.Prepare(), ErrDownloadBoundaryChanged) || !errors.Is(copied.Close(), ErrDownloadBoundaryChanged) {
+				t.Fatal("whole-value IO owner copy borrowed cleanup identity")
+			}
+			if _, err := os.Lstat(boundary.name); err != nil {
+				t.Fatal("copied IO owner removed original metadata", err)
+			}
+			if err := boundary.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := os.Lstat(boundary.directory); !os.IsNotExist(err) {
+				t.Fatal("original empty/prepared boundary cleanup failed", err)
+			}
+		})
+	}
+}
+
+func TestOriginalDownloadBoundaryRejectsRelativeTemporary(t *testing.T) {
+	// An existing relative directory must fail before creating anything. Do
+	// not require the checkout and testing's temporary root to share a volume.
+	boundary, err := NewDownloadBoundary(".", "original-download-", "example.invalid/command")
+	if boundary != nil {
+		// Even a regressed implementation owns only its newly created child.
+		defer func() {
+			if err := boundary.Close(); err != nil {
+				t.Error(err)
+			}
+		}()
+	}
+	if err == nil || boundary != nil {
+		t.Fatal("relative temporary directory acquired a command boundary", err)
+	}
+}
diff --git a/internal/gooriginalsrc/download_language_test.go b/internal/gooriginalsrc/download_language_test.go
new file mode 100644
index 000000000..c4526101c
--- /dev/null
+++ b/internal/gooriginalsrc/download_language_test.go
@@ -0,0 +1,82 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+func TestOriginSetModuleLanguageDeclaration(t *testing.T) {
+	for _, fixture := range []struct {
+		name, metadata, declared string
+		invalid                  bool
+	}{
+		{"implicit", "module example.invalid/zip-guard\n", "", false},
+		{"explicit", "module example.invalid/zip-guard\ngo 1.20\n", "1.20", false},
+		{"missing module", "go 1.20\n", "", true},
+		{"malformed language", "module example.invalid/zip-guard\ngo wrong\n", "", true},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			set, receipt, files := originalZIPConsistencyFixture(t)
+			files["go.mod"] = []byte(fixture.metadata)
+			for _, name := range []string{filepath.Join(receipt.Dir, "go.mod"), receipt.GoMod} {
+				if err := os.WriteFile(name, files["go.mod"], 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			writeOriginalZIPFixture(t, receipt.Zip, receipt.Path+"@"+receipt.Version, files, "unchanged")
+			var err error
+			receipt.Sum, err = dirhash.HashZip(receipt.Zip, dirhash.Hash1)
+			if err != nil {
+				t.Fatal(err)
+			}
+			receipt.GoModSum, err = dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+				return io.NopCloser(bytes.NewReader(files["go.mod"])), nil
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed, err := set.Observe(context.Background(), receipt.Path, receipt.Version, receipt)
+			if fixture.invalid {
+				if !errors.Is(err, ErrUnclosedModuleDeclaration) {
+					t.Fatalf("invalid original metadata accepted: %v", err)
+				}
+				if err := set.Verify(); err == nil {
+					t.Fatal("invalid language metadata did not revoke its observation")
+				}
+				return
+			}
+			if err != nil || observed.GoVersion != fixture.declared {
+				t.Fatalf("literal language directive was lost: %q, %v", observed.GoVersion, err)
+			}
+			if err := set.Verify(); err != nil {
+				t.Fatal(err)
+			}
+			actual, err := os.ReadFile(filepath.Join(receipt.Dir, "go.mod"))
+			if err != nil || !bytes.Equal(actual, files["go.mod"]) {
+				t.Fatal("observation rewrote the original language metadata", err)
+			}
+		})
+	}
+}
+
+func TestSelectedGoVersionKeepsModuleRoles(t *testing.T) {
+	for _, declared := range []string{"", "1.16", "1.20", "1.27.1"} {
+		if got := SelectedGoVersion(declared, false); got != declared {
+			t.Fatalf("dependency metadata changed from %q to %q", declared, got)
+		}
+		wanted := declared
+		if wanted == "" {
+			wanted = "1.16"
+		}
+		if got := SelectedGoVersion(declared, true); got != wanted {
+			t.Fatalf("main metadata = %q, want %q", got, wanted)
+		}
+	}
+}
diff --git a/internal/gooriginalsrc/download_legacy_test.go b/internal/gooriginalsrc/download_legacy_test.go
new file mode 100644
index 000000000..fd7720947
--- /dev/null
+++ b/internal/gooriginalsrc/download_legacy_test.go
@@ -0,0 +1,176 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/golegacymod"
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+func originalLegacyMetadataProof(t *testing.T) *golegacymod.ProxyGoModProof {
+	t.Helper()
+	data, err := os.ReadFile("../../gotoolprofile/testdata/aez_proxy_go_mod.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var proof golegacymod.ProxyGoModProof
+	if err := json.Unmarshal(data, &proof); err != nil {
+		t.Fatal(err)
+	}
+	return &proof
+}
+
+// This fixture exercises only the metadata-role consumer with an independently
+// signed public record. It does not claim a complete original ZIP observation,
+// compile external source, or create a frame/assembly permission.
+func originalLegacyMetadataFixture(t *testing.T) (*OriginSet, DownloadReceipt, *golegacymod.ProxyGoModProof) {
+	t.Helper()
+	proof := originalLegacyMetadataProof(t)
+	root, metadata := t.TempDir(), filepath.Join(t.TempDir(), "module.mod")
+	if err := os.WriteFile(metadata, []byte(proof.Contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	set := &OriginSet{files: newModuleSnapshot()}
+	if err := set.files.Directory(root, true); err != nil {
+		t.Fatal(err)
+	}
+	if err := set.files.Retain(metadata); err != nil {
+		t.Fatal(err)
+	}
+	receipt := DownloadReceipt{Path: proof.Module, Version: proof.Version,
+		Dir: root, GoMod: metadata, Sum: proof.ModuleSum, GoModSum: proof.GoModSum}
+	return set, receipt, proof
+}
+
+func TestOriginalLegacyMetadataSeparateAuthenticatedRole(t *testing.T) {
+	set, receipt, proof := originalLegacyMetadataFixture(t)
+	before, err := os.ReadFile(receipt.GoMod)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data, role, err := set.moduleMetadata(receipt.Path, receipt.Version, receipt, proof)
+	if err != nil || role != golegacymod.ProxyGoModProtocol || !bytes.Equal(data, before) {
+		t.Fatal("signed legacy metadata lost its separate original role", role, err)
+	}
+	if _, err := os.Lstat(filepath.Join(receipt.Dir, "go.mod")); !os.IsNotExist(err) {
+		t.Fatal("metadata observation invented an original ZIP member", err)
+	}
+	if err := set.files.Verify(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestOriginalLegacyMetadataRejectsUnboundOrChangedOrigins(t *testing.T) {
+	for _, role := range []string{
+		"missing proof", "signature", "inclusion", "path", "version", "zip sum", "metadata sum",
+		"metadata bytes", "unretained copy", "original member", "original directory", "added member",
+	} {
+		t.Run(role, func(t *testing.T) {
+			set, receipt, proof := originalLegacyMetadataFixture(t)
+			path, version := receipt.Path, receipt.Version
+			original := filepath.Join(receipt.Dir, "go.mod")
+			switch role {
+			case "missing proof":
+				proof = nil
+			case "signature":
+				proof.SignedTree += "changed"
+			case "inclusion":
+				proof.Inclusion = nil
+			case "path":
+				path = "example.invalid/changed"
+			case "version":
+				version = "v1.0.0"
+			case "zip sum":
+				receipt.Sum = proof.GoModSum
+			case "metadata sum":
+				receipt.GoModSum = proof.ModuleSum
+			case "metadata bytes":
+				if err := os.WriteFile(receipt.GoMod, []byte(proof.Contents+"\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "unretained copy":
+				receipt.GoMod = filepath.Join(t.TempDir(), "copy.mod")
+				if err := os.WriteFile(receipt.GoMod, []byte(proof.Contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "original member", "added member":
+				if err := os.WriteFile(original, []byte(proof.Contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if role == "original member" {
+					if err := set.files.Retain(original); err != nil {
+						t.Fatal(err)
+					}
+				}
+			case "original directory":
+				if err := os.Mkdir(original, 0700); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if _, _, err := set.moduleMetadata(path, version, receipt, proof); err == nil {
+				t.Fatal("unclosed legacy metadata acquired an original source role")
+			}
+		})
+	}
+}
+
+func TestOriginSetLegacyProofCannotReplaceWholeZIPIdentity(t *testing.T) {
+	for _, withProof := range []bool{false, true} {
+		t.Run(map[bool]string{false: "missing authentication", true: "different authenticated ZIP"}[withProof], func(t *testing.T) {
+			set, receipt, files := originalZIPConsistencyFixture(t)
+			delete(files, "go.mod")
+			if err := os.Remove(filepath.Join(receipt.Dir, "go.mod")); err != nil {
+				t.Fatal(err)
+			}
+			writeOriginalZIPFixture(t, receipt.Zip, receipt.Path+"@"+receipt.Version, files, "unchanged")
+			var err error
+			receipt.Sum, err = dirhash.HashZip(receipt.Zip, dirhash.Hash1)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var proof *golegacymod.ProxyGoModProof
+			if withProof {
+				proof = originalLegacyMetadataProof(t)
+			}
+			_, err = set.ObserveLegacy(context.Background(), receipt.Path, receipt.Version, receipt, proof)
+			if err == nil || !strings.Contains(err.Error(), "legacy proxy metadata") {
+				t.Fatal("missing/different authentication did not reach the independent metadata guard", err)
+			}
+			if err := set.Verify(); err == nil {
+				t.Fatal("failed legacy origin did not permanently revoke its observation")
+			}
+		})
+	}
+}
+
+func TestOriginSetMetadataRetainsActualCanonicalDownloadRole(t *testing.T) {
+	set, receipt, _ := originalZIPConsistencyFixture(t)
+	alias := filepath.Join(t.TempDir(), "cache-alias")
+	if err := os.Symlink(set.cache, alias); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []*string{&receipt.Dir, &receipt.Zip, &receipt.GoMod} {
+		relative, err := filepath.Rel(set.cache, *name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		*name = filepath.Join(alias, relative)
+	}
+	observed, err := set.Observe(context.Background(), receipt.Path, receipt.Version, receipt)
+	if err != nil || observed.GoModOrigin != OriginalZIPGoMod {
+		t.Fatal("validated ancestor alias lost its canonical original metadata", err)
+	}
+	if !strings.HasPrefix(observed.Root, set.cache+string(filepath.Separator)) ||
+		!strings.HasPrefix(observed.GoMod, set.cache+string(filepath.Separator)) {
+		t.Fatal("original metadata retained an unbound alias instead of its canonical role")
+	}
+	if err := set.Verify(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/gooriginalsrc/download_size_test.go b/internal/gooriginalsrc/download_size_test.go
new file mode 100644
index 000000000..48fd49c9f
--- /dev/null
+++ b/internal/gooriginalsrc/download_size_test.go
@@ -0,0 +1,146 @@
+package gooriginalsrc
+
+import (
+	"archive/zip"
+	"context"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/sumdb/dirhash"
+	modzip "golang.org/x/mod/zip"
+)
+
+// Ordinary module archives and non-Go payload members are not individual Go
+// source buffers. Stock Go's ZIP validator has a separate bounded contract.
+// The fake receipt here proves only origin consistency, never ASM authority.
+func TestOriginSetGoAcceptedArchiveAndPayloadExtents(t *testing.T) {
+	for _, role := range []string{"archive", "payload member"} {
+		t.Run(role, func(t *testing.T) {
+			set, receipt, _ := originalZIPConsistencyFixture(t)
+			method, members, extent := uint16(zip.Store), 3, int64(8<<20)
+			if role == "payload member" {
+				method, members, extent = zip.Deflate, 1, fileByteLimit+1
+			}
+			for index := 0; index < members; index++ {
+				name := filepath.Join(receipt.Dir, string(rune('a'+index))+".bin")
+				file, err := os.Create(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, copyErr := io.CopyN(file, zeroOriginalZIPReader{}, extent)
+				if err := errors.Join(copyErr, file.Close()); err != nil {
+					t.Fatal(err)
+				}
+			}
+			originalLargeZIPFixture(t, receipt, method)
+			if _, err := modzip.CheckZip(module.Version{Path: receipt.Path, Version: receipt.Version}, receipt.Zip); err != nil {
+				t.Fatal("official Go ZIP validator rejected the independent positive", err)
+			}
+			info, err := os.Stat(receipt.Zip)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if role == "archive" && info.Size() <= fileByteLimit || role == "payload member" && info.Size() >= fileByteLimit {
+				t.Fatal("fixture did not isolate its archive/member boundary", info.Size())
+			}
+			receipt.Sum, err = dirhash.HashZip(receipt.Zip, dirhash.Hash1)
+			if err != nil {
+				t.Fatal(err)
+			}
+			tree, err := dirhash.HashDir(receipt.Dir, receipt.Path+"@"+receipt.Version, dirhash.Hash1)
+			if err != nil || tree != receipt.Sum {
+				t.Fatal("independent complete original ZIP/tree hashes differ", err)
+			}
+			observed, err := set.Observe(context.Background(), receipt.Path, receipt.Version, receipt)
+			if err != nil || observed.Root != receipt.Dir {
+				t.Fatal("Go-accepted complete archive/tree was treated as a small source buffer", err)
+			}
+			if err := set.Verify(); err != nil {
+				t.Fatal(err)
+			}
+			large := receipt.Zip
+			if role == "payload member" {
+				large = filepath.Join(receipt.Dir, "a.bin")
+			}
+			if _, err := set.files.ReadRetained(large); err == nil {
+				t.Fatal("module artifact was allocated as an enlarged source buffer")
+			}
+			if err := NewSnapshot().Retain(large); err == nil {
+				t.Fatal("ordinary source inventory borrowed the module artifact bound")
+			}
+			if err := set.files.RetainTool(large); err == nil {
+				t.Fatal("module artifact was relabeled as a compiler tool")
+			}
+			file, err := os.OpenFile(large, os.O_RDWR, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer file.Close()
+			info, err = file.Stat()
+			if err != nil {
+				t.Fatal(err)
+			}
+			var tail [1]byte
+			if _, err := file.ReadAt(tail[:], info.Size()-1); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := file.WriteAt([]byte{tail[0] ^ 1}, info.Size()-1); err != nil {
+				t.Fatal(err)
+			}
+			if err := set.Verify(); err == nil {
+				t.Fatal("changed complete large module bytes retained their origin")
+			}
+			if _, err := file.WriteAt(tail[:], info.Size()-1); err != nil {
+				t.Fatal(err)
+			}
+			if err := set.Verify(); err == nil {
+				t.Fatal("restoring large module bytes revived a revoked origin")
+			}
+		})
+	}
+}
+
+func TestModuleArtifactBoundDoesNotExceedGoZIPLimit(t *testing.T) {
+	root := originalToolFixtureRoot(t)
+	name := makeOriginalToolExtent(t, root, "too-large", modzip.MaxZipFile+1)
+	if err := newModuleSnapshot().Retain(name); err == nil {
+		t.Fatal("module artifact exceeded Go's complete archive/member bound")
+	}
+}
+
+func originalLargeZIPFixture(t *testing.T, receipt DownloadReceipt, method uint16) {
+	t.Helper()
+	file, err := os.Create(receipt.Zip)
+	if err != nil {
+		t.Fatal(err)
+	}
+	writer := zip.NewWriter(file)
+	err = filepath.WalkDir(receipt.Dir, func(name string, entry os.DirEntry, walkErr error) error {
+		if walkErr != nil || entry.IsDir() {
+			return walkErr
+		}
+		relative, err := filepath.Rel(receipt.Dir, name)
+		if err != nil {
+			return err
+		}
+		member, err := writer.CreateHeader(&zip.FileHeader{
+			Name: receipt.Path + "@" + receipt.Version + "/" + filepath.ToSlash(relative), Method: method,
+		})
+		if err != nil {
+			return err
+		}
+		input, err := os.Open(name)
+		if err != nil {
+			return err
+		}
+		_, copyErr := io.Copy(member, input)
+		return errors.Join(copyErr, input.Close())
+	})
+	if err := errors.Join(err, writer.Close(), file.Close()); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/gooriginalsrc/download_zip_test.go b/internal/gooriginalsrc/download_zip_test.go
new file mode 100644
index 000000000..6601d4e36
--- /dev/null
+++ b/internal/gooriginalsrc/download_zip_test.go
@@ -0,0 +1,175 @@
+package gooriginalsrc
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"golang.org/x/mod/sumdb/dirhash"
+)
+
+// This is only an exact-origin consistency fixture. The test binary is not a
+// Go driver, and a DownloadReceipt here cannot mint a package/frame capability.
+func originalZIPConsistencyFixture(t *testing.T) (*OriginSet, DownloadReceipt, map[string][]byte) {
+	t.Helper()
+	cache, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	key := "example.invalid/zip-guard@v1.0.0"
+	root := filepath.Join(cache, key)
+	prefix := filepath.Join(cache, "cache", "download", "example.invalid", "zip-guard", "@v", "v1.0.0")
+	for _, directory := range []string{root, filepath.Dir(prefix)} {
+		if err := os.MkdirAll(directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	files := map[string][]byte{
+		"go.mod":  []byte("module example.invalid/zip-guard\ngo 1.20\n"),
+		"value.s": []byte("TEXT ·Value(SB),4,$0-0\n\tRET\n"),
+	}
+	for name, data := range files {
+		if err := os.WriteFile(filepath.Join(root, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := os.WriteFile(prefix+".mod", files["go.mod"], 0600); err != nil {
+		t.Fatal(err)
+	}
+	writeOriginalZIPFixture(t, prefix+".zip", key, files, "unchanged")
+	zipSum, err := dirhash.HashZip(prefix+".zip", dirhash.Hash1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	modSum, err := dirhash.Hash1([]string{"go.mod"}, func(string) (io.ReadCloser, error) {
+		return io.NopCloser(bytes.NewReader(files["go.mod"])), nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	tool, err := filepath.EvalSymlinks(os.Args[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	set, err := NewOriginSet(cache, tool)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return set, DownloadReceipt{Path: "example.invalid/zip-guard", Version: "v1.0.0", Dir: root,
+		Zip: prefix + ".zip", GoMod: prefix + ".mod", Sum: zipSum, GoModSum: modSum}, files
+}
+
+func writeOriginalZIPFixture(t *testing.T, name, key string, files map[string][]byte, role string) {
+	t.Helper()
+	var output bytes.Buffer
+	writer := zip.NewWriter(&output)
+	for _, member := range []string{"go.mod", "value.s"} {
+		if _, present := files[member]; !present {
+			continue
+		}
+		entry, err := writer.CreateHeader(&zip.FileHeader{Name: key + "/" + member, Method: zip.Deflate})
+		if err != nil {
+			t.Fatal(err)
+		}
+		data := files[member]
+		if role == "oversized member" && member == "value.s" {
+			if _, err := io.CopyN(entry, zeroOriginalZIPReader{}, fileByteLimit+1); err != nil {
+				t.Fatal(err)
+			}
+		} else if _, err := entry.Write(data); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if role == "duplicate" {
+		entry, err := writer.Create(key + "/value.s")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := entry.Write(files["value.s"]); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := writer.Close(); err != nil {
+		t.Fatal(err)
+	}
+	data := output.Bytes()
+	if role == "dishonest header" || role == "CRC" {
+		// Locate the actual central record by its complete original member name.
+		member := []byte(key + "/value.s")
+		position := bytes.LastIndex(data, member)
+		if position < 46 || binary.LittleEndian.Uint32(data[position-46:]) != 0x02014b50 {
+			t.Fatal("first-party ZIP did not contain its actual central member record")
+		}
+		header := data[position-46:]
+		if role == "dishonest header" {
+			binary.LittleEndian.PutUint32(header[24:], fileByteLimit+1)
+		} else {
+			header[16] ^= 1
+		}
+	}
+	if err := os.WriteFile(name, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+}
+
+type zeroOriginalZIPReader struct{}
+
+func (zeroOriginalZIPReader) Read(data []byte) (int, error) {
+	for i := range data {
+		data[i] = 0
+	}
+	return len(data), nil
+}
+
+func TestOriginSetZIPCompleteBoundedMembers(t *testing.T) {
+	for _, role := range []string{"unchanged", "oversized member", "dishonest header", "CRC", "duplicate"} {
+		t.Run(role, func(t *testing.T) {
+			set, receipt, files := originalZIPConsistencyFixture(t)
+			writeOriginalZIPFixture(t, receipt.Zip, receipt.Path+"@"+receipt.Version, files, role)
+			observed, err := set.Observe(context.Background(), receipt.Path, receipt.Version, receipt)
+			if role == "unchanged" {
+				if err != nil || observed.Root != receipt.Dir {
+					t.Fatal("complete original ZIP/tree positive failed", err)
+				}
+				if err := set.Verify(); err != nil {
+					t.Fatal(err)
+				}
+				return
+			}
+			if err == nil {
+				t.Fatal("invalid complete ZIP yielded an exact origin observation")
+			}
+			if (role == "oversized member" || role == "dishonest header") && !strings.Contains(err.Error(), "ZIP member extent") {
+				t.Fatalf("ZIP content was consumed before its retained extent guard: %v", err)
+			}
+			if err := set.Verify(); err == nil {
+				t.Fatal(fmt.Sprintf("failed %s ZIP observation did not permanently revoke", role))
+			}
+		})
+	}
+}
+
+type originalCloseFailureFixture struct {
+	*bytes.Reader
+	failure error
+}
+
+func (reader originalCloseFailureFixture) Close() error { return reader.failure }
+
+func TestOriginalMemberHashRequiresClose(t *testing.T) {
+	failure := errors.New("first-party member close failure")
+	_, err := hashOriginalMembers([]string{"module@v1.0.0/member"}, func(string) (io.ReadCloser, error) {
+		return originalCloseFailureFixture{Reader: bytes.NewReader([]byte("complete original bytes")), failure: failure}, nil
+	})
+	if !errors.Is(err, failure) {
+		t.Fatal("Go Hash1 discarded a member close failure", err)
+	}
+}
diff --git a/internal/gooriginalsrc/file_proxy.go b/internal/gooriginalsrc/file_proxy.go
new file mode 100644
index 000000000..8ce0b159c
--- /dev/null
+++ b/internal/gooriginalsrc/file_proxy.go
@@ -0,0 +1,25 @@
+package gooriginalsrc
+
+import (
+	"fmt"
+	"net/url"
+	"path/filepath"
+	"strings"
+)
+
+// FileProxyURL names one absolute local proxy, without allowing punctuation in
+// its directory name to introduce another GOPROXY entry or network fallback.
+func FileProxyURL(directory string) (string, error) {
+	if !filepath.IsAbs(directory) {
+		return "", fmt.Errorf("file proxy requires an absolute directory")
+	}
+	return fileProxyURL(filepath.ToSlash(directory)), nil
+}
+
+func fileProxyURL(path string) string {
+	if !strings.HasPrefix(path, "/") {
+		path = "/" + path // Windows drive paths use file:///C:/..., not a host.
+	}
+	proxy := (&url.URL{Scheme: "file", Path: path}).String()
+	return strings.NewReplacer(",", "%2C", "|", "%7C").Replace(proxy)
+}
diff --git a/internal/gooriginalsrc/file_proxy_test.go b/internal/gooriginalsrc/file_proxy_test.go
new file mode 100644
index 000000000..71aca8110
--- /dev/null
+++ b/internal/gooriginalsrc/file_proxy_test.go
@@ -0,0 +1,38 @@
+package gooriginalsrc
+
+import (
+	"net/url"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFileProxyURLPreservesLocalPathAndSeparators(t *testing.T) {
+	for _, path := range []string{
+		"/tmp/module proxy", "C:/module proxy", "D:/a,b|c#d%20/中文",
+		"//server/share/proxy", "/tmp/a,b|c#d%20/中文",
+	} {
+		encoded := fileProxyURL(path)
+		parsed, err := url.Parse(encoded)
+		if err != nil {
+			t.Fatal(err)
+		}
+		want := path
+		if !strings.HasPrefix(want, "/") {
+			want = "/" + want
+		}
+		if parsed.Scheme != "file" || parsed.Host != "" || parsed.Path != want ||
+			parsed.RawQuery != "" || parsed.Fragment != "" || strings.ContainsAny(encoded, ",|") {
+			t.Fatalf("%q changed local proxy identity: %q", path, encoded)
+		}
+	}
+	directory := filepath.Join(t.TempDir(), "local,proxy|only")
+	if got, err := FileProxyURL(directory); err != nil || got != fileProxyURL(filepath.ToSlash(directory)) {
+		t.Fatal("host path conversion differs", got, err)
+	}
+	for _, relative := range []string{"", ".", "proxy"} {
+		if _, err := FileProxyURL(relative); err == nil {
+			t.Fatal("relative proxy directory accepted", relative)
+		}
+	}
+}
diff --git a/internal/gooriginalsrc/snapshot.go b/internal/gooriginalsrc/snapshot.go
new file mode 100644
index 000000000..022a7ff12
--- /dev/null
+++ b/internal/gooriginalsrc/snapshot.go
@@ -0,0 +1,464 @@
+// Package gooriginalsrc observes bounded original files and exact Go-download
+// origins. Its state is byte/role consistency data, never an ASM capability.
+package gooriginalsrc
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"hash"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	modzip "golang.org/x/mod/zip"
+)
+
+var originalHashBuffers = sync.Pool{New: func() any { return new([64 << 10]byte) }}
+
+const (
+	fileLimit      = 65536
+	directoryLimit = 4096
+	fileByteLimit  = 16 << 20
+	toolByteLimit  = 64 << 20
+	// A current ordinary cross-target SDK source/export graph plus its
+	// independently selected Go driver exceeds 64 MiB (71,297,622 bytes in
+	// the measured crypto witness). Keep one finite shared 128 MiB budget.
+	// Hashing remains streaming; per-file and role/count bounds are unchanged.
+	totalByteLimit = 128 << 20
+)
+
+type originalFileRole uint8
+
+const (
+	originalSourceFile originalFileRole = iota + 1
+	originalToolFile
+	originalModuleArtifact
+)
+
+func (role originalFileRole) byteLimit() int64 {
+	switch role {
+	case originalSourceFile:
+		return fileByteLimit
+	case originalToolFile:
+		// This is the existing Go frame driver/subtool physical-read limit.
+		// Sources, exports and ZIP members do not acquire the tool role.
+		return toolByteLimit
+	case originalModuleArtifact:
+		return modzip.MaxZipFile
+	default:
+		return -1
+	}
+}
+
+// Snapshot retains complete physical files and directory membership. It has no
+// serialized constructor, command callback, frame, signature or permission.
+type Snapshot struct {
+	hashes, paths   map[string]string
+	entries         map[string][]string
+	directories     map[string]os.FileInfo
+	files           map[string]os.FileInfo
+	retainedRoles   map[string]originalFileRole
+	tools           map[string]os.FileInfo
+	fileRoles       map[string]bool
+	directoryRoles  map[string]bool
+	bytes           int64
+	moduleArtifacts bool
+}
+
+// SnapshotView is the existing producer's observation data. These maps expose
+// no capability: consumers must retain their own actual Snapshot and Verify it.
+// The compatibility producer uses this view rather than duplicating inventories.
+type SnapshotView struct {
+	Hashes, Paths map[string]string
+	Entries       map[string][]string
+	Directories   map[string]os.FileInfo
+}
+
+func NewSnapshot() *Snapshot {
+	return &Snapshot{
+		hashes: make(map[string]string), paths: make(map[string]string),
+		entries: make(map[string][]string), directories: make(map[string]os.FileInfo),
+		files:         make(map[string]os.FileInfo),
+		retainedRoles: make(map[string]originalFileRole), tools: make(map[string]os.FileInfo),
+		fileRoles: make(map[string]bool), directoryRoles: make(map[string]bool),
+	}
+}
+
+func (snapshot *Snapshot) View() SnapshotView {
+	return SnapshotView{snapshot.hashes, snapshot.paths, snapshot.entries, snapshot.directories}
+}
+
+func (snapshot *Snapshot) Retain(name string) error {
+	if snapshot != nil && snapshot.moduleArtifacts {
+		return snapshot.retain(name, originalModuleArtifact)
+	}
+	return snapshot.retain(name, originalSourceFile)
+}
+
+// Only the exact module-origin factory uses this inventory. It retains a
+// complete Go-bounded archive and extracted tree, not a larger source/parser
+// buffer. The ordinary SDK/source/export inventory keeps its existing limits.
+func newModuleSnapshot() *Snapshot {
+	snapshot := NewSnapshot()
+	snapshot.moduleArtifacts = true
+	return snapshot
+}
+
+func (snapshot *Snapshot) byteLimit() int64 {
+	if snapshot.moduleArtifacts {
+		// One finite graph budget can hold a maximum-size Go module's ZIP
+		// and extracted tree plus the existing tool/metadata budget. Each
+		// module is also checked against Go's independent 500 MiB limits.
+		return 2*modzip.MaxZipFile + totalByteLimit
+	}
+	return totalByteLimit
+}
+
+// RetainTool observes an explicitly selected original driver/subtool, using
+// the existing 64 MiB tool contract. It shares the original graph budget and
+// cannot be read as source bytes or mint source/frame/ASM permissions.
+func (snapshot *Snapshot) RetainTool(name string) error {
+	return snapshot.retain(name, originalToolFile)
+}
+
+func (snapshot *Snapshot) retain(name string, role originalFileRole) error {
+	if snapshot == nil || snapshot.hashes == nil || snapshot.retainedRoles == nil ||
+		!filepath.IsAbs(name) || role.byteLimit() < 0 {
+		return fmt.Errorf("original file path is missing or over-bound")
+	}
+	if _, retained := snapshot.hashes[name]; !retained && len(snapshot.hashes) >= fileLimit {
+		return fmt.Errorf("original file inventory exceeds its count bound")
+	}
+	info, err := os.Lstat(name)
+	if err != nil || !info.Mode().IsRegular() || info.Size() < 0 || info.Size() > role.byteLimit() {
+		return fmt.Errorf("original source/export is missing, nonregular or over-bound: %s", filepath.Base(name))
+	}
+	if prior, exists := snapshot.retainedRoles[name]; exists && prior != role {
+		return fmt.Errorf("original physical file cannot be relabeled between source and tool")
+	}
+	// Tools are a small explicitly selected inventory. Check their original
+	// inode as well as the path so hard links and case/parent aliases cannot
+	// turn the same physical file into the other observation role.
+	if role != originalToolFile {
+		for _, tool := range snapshot.tools {
+			if os.SameFile(tool, info) {
+				return fmt.Errorf("original tool inode cannot be relabeled as source")
+			}
+		}
+	} else {
+		for prior, file := range snapshot.files {
+			if snapshot.retainedRoles[prior] != originalToolFile && os.SameFile(file, info) {
+				return fmt.Errorf("original source inode cannot be relabeled as tool")
+			}
+		}
+	}
+	physical, err := sourcepath.Resolve(name)
+	if err != nil {
+		return err
+	}
+	if !snapshot.fileRoles[physical] && len(snapshot.fileRoles) >= fileLimit {
+		return fmt.Errorf("original file member inventory exceeds its shared count bound")
+	}
+	digest, err := originalRoleFileSHA256(name, info, role)
+	if err != nil {
+		return err
+	}
+	if prior, present := snapshot.hashes[name]; present {
+		if prior != digest || snapshot.paths[name] != physical || !os.SameFile(snapshot.files[name], info) {
+			return fmt.Errorf("original source/export changed during capture")
+		}
+	} else {
+		if info.Size() > snapshot.byteLimit()-snapshot.bytes {
+			return fmt.Errorf("original source/export inventory exceeds its byte bound: retained=%d incoming=%d limit=%d",
+				snapshot.bytes, info.Size(), snapshot.byteLimit())
+		}
+		snapshot.bytes += info.Size()
+	}
+	snapshot.hashes[name], snapshot.paths[name], snapshot.files[name] = digest, physical, info
+	snapshot.retainedRoles[name] = role
+	if role == originalToolFile {
+		snapshot.tools[name] = info
+	}
+	snapshot.fileRoles[physical] = true
+	return nil
+}
+
+func (snapshot *Snapshot) Directory(name string, recursive bool) error {
+	if snapshot == nil || snapshot.directories == nil || !filepath.IsAbs(name) {
+		return fmt.Errorf("original source directory requires an absolute initialized role")
+	}
+	if _, retained := snapshot.directories[name]; !retained && len(snapshot.directories) >= directoryLimit {
+		return fmt.Errorf("original source directory inventory exceeds its count bound")
+	}
+	physical, err := sourcepath.Resolve(name)
+	if err != nil {
+		return err
+	}
+	entries, info, err := ReadDirectory(name, fileLimit+directoryLimit)
+	if err != nil {
+		return err
+	}
+	if prior, present := snapshot.directories[name]; present &&
+		(!os.SameFile(prior, info) || snapshot.paths[name] != physical) {
+		return fmt.Errorf("original source directory identity changed")
+	}
+	newFiles, newDirectories := make(map[string]bool), make(map[string]bool)
+	if !snapshot.directoryRoles[physical] {
+		newDirectories[physical] = true
+	}
+	for _, entry := range entries {
+		child := filepath.Join(physical, entry.Name())
+		if entry.Type()&os.ModeSymlink != 0 || !entry.IsDir() && !entry.Type().IsRegular() {
+			return fmt.Errorf("original source directory contains an unbound nonregular entry")
+		}
+		if entry.IsDir() {
+			if !snapshot.directoryRoles[child] {
+				newDirectories[child] = true
+			}
+		} else if !snapshot.fileRoles[child] {
+			newFiles[child] = true
+		}
+	}
+	if len(snapshot.fileRoles)+len(newFiles) > fileLimit || len(snapshot.directoryRoles)+len(newDirectories) > directoryLimit {
+		return fmt.Errorf("complete original directory members exceed the shared graph count bound")
+	}
+	for child := range newFiles {
+		snapshot.fileRoles[child] = true
+	}
+	for child := range newDirectories {
+		snapshot.directoryRoles[child] = true
+	}
+	names := make([]string, 0, len(entries))
+	for _, entry := range entries {
+		child := filepath.Join(physical, entry.Name())
+		names = append(names, entry.Name()+":"+entry.Type().String())
+		if entry.Type()&os.ModeSymlink != 0 || !entry.IsDir() && !entry.Type().IsRegular() {
+			return fmt.Errorf("original source directory contains an unbound nonregular entry")
+		}
+		if recursive {
+			if entry.IsDir() {
+				if err := snapshot.Directory(child, true); err != nil {
+					return err
+				}
+			} else if err := snapshot.Retain(child); err != nil {
+				return err
+			}
+		}
+	}
+	if prior, present := snapshot.entries[name]; present && !reflect.DeepEqual(prior, names) {
+		return fmt.Errorf("original source directory membership changed during capture")
+	}
+	snapshot.entries[name], snapshot.paths[name], snapshot.directories[name] = names, physical, info
+	return nil
+}
+
+func (snapshot *Snapshot) Verify() error {
+	if snapshot == nil || snapshot.hashes == nil || snapshot.files == nil ||
+		snapshot.retainedRoles == nil || snapshot.directories == nil {
+		return fmt.Errorf("missing original source/export inventory")
+	}
+	for name, digest := range snapshot.hashes {
+		info, err := os.Lstat(name)
+		physical, resolveErr := sourcepath.Resolve(name)
+		if err != nil || resolveErr != nil || !info.Mode().IsRegular() ||
+			physical != snapshot.paths[name] || !os.SameFile(snapshot.files[name], info) {
+			return fmt.Errorf("original source/export physical identity changed")
+		}
+		actual, err := originalRoleFileSHA256(name, snapshot.files[name], snapshot.retainedRoles[name])
+		if err != nil {
+			return fmt.Errorf("original source/export bytes changed: %w", err)
+		}
+		if actual != digest {
+			return fmt.Errorf("original source/export bytes changed")
+		}
+	}
+	for name := range snapshot.directories {
+		physical, err := sourcepath.Resolve(name)
+		entries, info, readErr := ReadDirectory(name, fileLimit+directoryLimit)
+		if err != nil || readErr != nil || physical != snapshot.paths[name] ||
+			!os.SameFile(snapshot.directories[name], info) {
+			return fmt.Errorf("original source directory identity changed")
+		}
+		names := make([]string, 0, len(entries))
+		for _, entry := range entries {
+			names = append(names, entry.Name()+":"+entry.Type().String())
+		}
+		if !reflect.DeepEqual(names, snapshot.entries[name]) {
+			return fmt.Errorf("original source directory membership changed")
+		}
+	}
+	return nil
+}
+
+// ReadRetained reads only an independently retained physical file, using a
+// 16 MiB source-buffer bound and the streaming hash's complete EOF guard.
+// Larger module artifacts remain stream-only; these bytes grant no permission.
+func (snapshot *Snapshot) ReadRetained(name string) ([]byte, error) {
+	if snapshot == nil || snapshot.files[name] == nil || snapshot.files[name].Size() > fileByteLimit {
+		return nil, fmt.Errorf("retained source buffer exceeds its byte bound")
+	}
+	reader, err := snapshot.OpenRetained(name)
+	if err != nil {
+		return nil, err
+	}
+	buffer := &originalFileBuffer{bytes: make([]byte, int(snapshot.files[name].Size()))}
+	err = copyOriginalFile(buffer, reader)
+	if err != nil {
+		return nil, err
+	}
+	return buffer.bytes, nil
+}
+
+// OpenRetained exposes only an observed source/member's strict physical stream
+// under its own role's limit, never a compiler tool. Complete EOF and close
+// errors must be consumed; this does not enlarge ReadRetained's buffer limit
+// or mint source/frame permissions.
+func (snapshot *Snapshot) OpenRetained(name string) (io.ReadCloser, error) {
+	if snapshot == nil || !filepath.IsAbs(name) {
+		return nil, fmt.Errorf("missing retained original file role")
+	}
+	expected := snapshot.files[name]
+	digest, retained := snapshot.hashes[name]
+	physical, err := sourcepath.Resolve(name)
+	if !retained || expected == nil || err != nil || physical != snapshot.paths[name] ||
+		snapshot.retainedRoles[name] != originalSourceFile && snapshot.retainedRoles[name] != originalModuleArtifact {
+		return nil, fmt.Errorf("original file was not retained at its physical role")
+	}
+	role := snapshot.retainedRoles[name]
+	if expected.Size() < 0 || expected.Size() > role.byteLimit() {
+		return nil, fmt.Errorf("retained original file exceeds its byte bound")
+	}
+	return openOriginalRoleFile(name, expected, physical, digest, role)
+}
+
+// A fixed extent prevents io.Copy from allocating extra storage if an original
+// metadata file grows after the observation. Overflow rejects, never truncates.
+type originalFileBuffer struct {
+	bytes  []byte
+	offset int
+}
+
+func (buffer *originalFileBuffer) Write(data []byte) (int, error) {
+	if len(data) > len(buffer.bytes)-buffer.offset {
+		return 0, fmt.Errorf("original source file grew beyond its retained extent")
+	}
+	count := copy(buffer.bytes[buffer.offset:], data)
+	buffer.offset += count
+	return count, nil
+}
+
+func originalFileSHA256(name string, expected os.FileInfo) (string, error) {
+	return originalRoleFileSHA256(name, expected, originalSourceFile)
+}
+
+func originalRoleFileSHA256(name string, expected os.FileInfo, role originalFileRole) (string, error) {
+	physical, err := sourcepath.Resolve(name)
+	if err != nil {
+		return "", err
+	}
+	reader, err := openOriginalRoleFile(name, expected, physical, "", role)
+	if err != nil {
+		return "", err
+	}
+	if err := copyOriginalFile(io.Discard, reader); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", reader.hash.Sum(nil)), nil
+}
+
+func copyOriginalFile(output io.Writer, reader io.ReadCloser) error {
+	buffer := originalHashBuffers.Get().(*[64 << 10]byte)
+	defer originalHashBuffers.Put(buffer)
+	_, err := io.CopyBuffer(output, reader, buffer[:])
+	return errors.Join(err, reader.Close())
+}
+
+type originalFileReader struct {
+	file     *os.File
+	name     string
+	physical string
+	expected os.FileInfo
+	digest   string
+	hash     hash.Hash
+	count    int64
+	complete bool
+	closed   bool
+	failure  error
+}
+
+func openOriginalFile(name string, expected os.FileInfo, physical, digest string) (*originalFileReader, error) {
+	return openOriginalRoleFile(name, expected, physical, digest, originalSourceFile)
+}
+
+func openOriginalRoleFile(name string, expected os.FileInfo, physical, digest string, role originalFileRole) (*originalFileReader, error) {
+	if expected == nil || role.byteLimit() < 0 || expected.Size() < 0 || expected.Size() > role.byteLimit() {
+		return nil, fmt.Errorf("original source file has no bounded physical extent")
+	}
+	before, err := os.Lstat(name)
+	resolved, resolveErr := sourcepath.Resolve(name)
+	if err != nil || resolveErr != nil || resolved != physical || !before.Mode().IsRegular() ||
+		!os.SameFile(expected, before) || before.Size() != expected.Size() {
+		return nil, fmt.Errorf("original source file identity or extent changed before opening")
+	}
+	file, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	opened, err := file.Stat()
+	if err != nil || !opened.Mode().IsRegular() || !os.SameFile(expected, opened) || opened.Size() != expected.Size() {
+		return nil, errors.Join(fmt.Errorf("original source file identity changed while opening"), file.Close())
+	}
+	return &originalFileReader{file: file, name: name, physical: physical,
+		expected: expected, digest: digest, hash: sha256.New()}, nil
+}
+
+func (reader *originalFileReader) Read(data []byte) (int, error) {
+	if reader.failure != nil {
+		return 0, reader.failure
+	}
+	if reader.closed {
+		return 0, os.ErrClosed
+	}
+	if reader.complete {
+		return 0, io.EOF
+	}
+	if remaining := reader.expected.Size() - reader.count + 1; int64(len(data)) > remaining {
+		data = data[:int(remaining)]
+	}
+	count, err := reader.file.Read(data)
+	reader.count += int64(count)
+	_, _ = reader.hash.Write(data[:count])
+	if reader.count > reader.expected.Size() {
+		err = fmt.Errorf("original source file grew beyond its retained extent")
+	} else if err == io.EOF {
+		after, statErr := os.Lstat(reader.name)
+		physical, resolveErr := sourcepath.Resolve(reader.name)
+		if statErr != nil || resolveErr != nil || physical != reader.physical || !after.Mode().IsRegular() ||
+			!os.SameFile(reader.expected, after) || reader.count != reader.expected.Size() || reader.count != after.Size() ||
+			reader.digest != "" && fmt.Sprintf("%x", reader.hash.Sum(nil)) != reader.digest {
+			err = fmt.Errorf("original source file identity, bytes or extent changed while reading")
+		} else {
+			reader.complete = true
+		}
+	}
+	if err != nil && err != io.EOF {
+		reader.failure = err
+	}
+	return count, err
+}
+
+func (reader *originalFileReader) Close() error {
+	if reader.closed {
+		return reader.failure
+	}
+	reader.closed = true
+	if !reader.complete {
+		reader.failure = errors.Join(reader.failure, fmt.Errorf("original source member did not reach complete EOF"))
+	}
+	reader.failure = errors.Join(reader.failure, reader.file.Close())
+	return reader.failure
+}
diff --git a/internal/gooriginalsrc/snapshot_sdk_budget_test.go b/internal/gooriginalsrc/snapshot_sdk_budget_test.go
new file mode 100644
index 000000000..9f8060c57
--- /dev/null
+++ b/internal/gooriginalsrc/snapshot_sdk_budget_test.go
@@ -0,0 +1,38 @@
+package gooriginalsrc
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestSnapshotActualSDKGraphAndDriverExtent(t *testing.T) {
+	// Measured ordinary Go 1.27.1 darwin/amd64 crypto graph, observed by
+	// the Linux driver: complete sources/exports plus the original driver.
+	// This is a byte-budget fixture, not a claim of external-library success.
+	const sourceBytes = int64(54155434)
+	const driverBytes = int64(17142188)
+	root := originalToolFixtureRoot(t)
+	snapshot := NewSnapshot()
+	left := sourceBytes
+	for index := 0; left > 0; index++ {
+		extent := int64(16 << 20)
+		if left < extent {
+			extent = left
+		}
+		path := makeOriginalToolExtent(t, root, fmt.Sprintf("source-%d", index), extent)
+		if err := snapshot.Retain(path); err != nil {
+			t.Fatal(err)
+		}
+		left -= extent
+	}
+	driver := makeOriginalToolExtent(t, root, "go", driverBytes)
+	if err := snapshot.RetainTool(driver); err != nil {
+		t.Fatalf("ordinary measured SDK/driver graph was refused: %v", err)
+	}
+	if snapshot.bytes != sourceBytes+driverBytes {
+		t.Fatal("graph silently omitted original physical bytes", snapshot.bytes)
+	}
+	if err := snapshot.Verify(); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/gooriginalsrc/snapshot_stream_test.go b/internal/gooriginalsrc/snapshot_stream_test.go
new file mode 100644
index 000000000..5864ceb42
--- /dev/null
+++ b/internal/gooriginalsrc/snapshot_stream_test.go
@@ -0,0 +1,128 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime"
+	"syscall"
+	"testing"
+)
+
+type retainedSourceOpener interface {
+	OpenRetained(string) (io.ReadCloser, error)
+}
+
+// Returns whether replacement happened while the original stream was open.
+// Windows' ordinary read handle denies deletion/rename. Require that exact
+// protection, consume and close the unchanged stream, then still exercise the
+// same-byte replacement against the retained snapshot after closing it.
+func renameOriginalStreamMember(t *testing.T, snapshot *Snapshot, reader io.ReadCloser, name, backup string, remaining int64) bool {
+	t.Helper()
+	err := os.Rename(name, backup)
+	if err == nil {
+		return true
+	}
+	const sharingViolation = syscall.Errno(32) // Windows ERROR_SHARING_VIOLATION.
+	if runtime.GOOS != "windows" || !errors.Is(err, sharingViolation) {
+		t.Fatal("unexpected original stream rename failure", err)
+	}
+	count, readErr := io.Copy(io.Discard, reader)
+	closeErr := reader.Close()
+	if readErr != nil || closeErr != nil || count != remaining {
+		t.Fatal("OS-protected unchanged stream did not reach complete EOF", readErr, closeErr)
+	}
+	if err := snapshot.Verify(); err != nil {
+		t.Fatal("denied rename changed the original snapshot", err)
+	}
+	if err := os.Rename(name, backup); err != nil {
+		t.Fatal("closed stream still prevented the actual replacement", err)
+	}
+	t.Log("OS denied live rename; checking actual replacement after complete stream close")
+	return false
+}
+
+func TestSnapshotRetainedStreamPhysicalClosure(t *testing.T) {
+	for _, role := range []string{"unchanged", "same inode growth", "replacement", "tail byte", "incomplete close"} {
+		t.Run(role, func(t *testing.T) {
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(root, "member")
+			original := bytes.Repeat([]byte("original complete source\n"), 6000)
+			if err := os.WriteFile(name, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			snapshot := NewSnapshot()
+			if err := snapshot.Retain(name); err != nil {
+				t.Fatal(err)
+			}
+			opener, exists := any(snapshot).(retainedSourceOpener)
+			if !exists {
+				t.Fatal("complete retained tree has no strict streaming physical read route")
+			}
+			reader, err := opener.OpenRetained(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer reader.Close()
+			var prefix [1]byte
+			if _, err := io.ReadFull(reader, prefix[:]); err != nil || prefix[0] != original[0] {
+				t.Fatal("actual original member could not be read before mutation", err)
+			}
+			switch role {
+			case "same inode growth":
+				before, err := os.Lstat(name)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Truncate(name, fileByteLimit+1); err != nil {
+					t.Fatal(err)
+				}
+				after, err := os.Lstat(name)
+				if err != nil || !os.SameFile(before, after) || after.Size() <= fileByteLimit {
+					t.Fatal("the actual open member did not grow at the same inode", err)
+				}
+			case "replacement":
+				live := renameOriginalStreamMember(t, snapshot, reader, name,
+					filepath.Join(t.TempDir(), "original"), int64(len(original)-1))
+				if err := os.WriteFile(name, original, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if !live {
+					if err := snapshot.Verify(); err == nil {
+						t.Fatal("closed stream's same-byte replacement retained the snapshot")
+					}
+					if replacement, err := opener.OpenRetained(name); err == nil {
+						replacement.Close()
+						t.Fatal("replacement reopened as the original retained stream")
+					}
+					return
+				}
+			case "tail byte":
+				changed := append([]byte(nil), original...)
+				changed[len(changed)-1] ^= 1
+				if err := os.WriteFile(name, changed, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "incomplete close":
+				if err := reader.Close(); err == nil {
+					t.Fatal("an incomplete member close impersonated complete EOF")
+				}
+				return
+			}
+			count, readErr := io.Copy(io.Discard, reader)
+			closeErr := reader.Close()
+			if role == "unchanged" {
+				if readErr != nil || closeErr != nil || count != int64(len(original)-1) {
+					t.Fatal("original member stream did not close complete EOF", readErr, closeErr)
+				}
+			} else if readErr == nil && closeErr == nil {
+				t.Fatal("a changed open physical member yielded a complete retained stream")
+			}
+		})
+	}
+}
diff --git a/internal/gooriginalsrc/snapshot_test.go b/internal/gooriginalsrc/snapshot_test.go
new file mode 100644
index 000000000..975e951e5
--- /dev/null
+++ b/internal/gooriginalsrc/snapshot_test.go
@@ -0,0 +1,248 @@
+package gooriginalsrc
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+type retainedSourceReader interface {
+	ReadRetained(string) ([]byte, error)
+}
+
+func TestSnapshotReadRetainedFullEOF(t *testing.T) {
+	for _, role := range []string{"unchanged", "tail byte", "grown metadata", "replacement", "symlink"} {
+		t.Run(role, func(t *testing.T) {
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(root, "go.mod")
+			original := bytes.Repeat([]byte("module example.invalid/source\n"), 3000)
+			if err := os.WriteFile(name, original, 0600); err != nil {
+				t.Fatal(err)
+			}
+			snapshot := NewSnapshot()
+			if err := snapshot.Retain(name); err != nil {
+				t.Fatal(err)
+			}
+			before, err := os.Lstat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch role {
+			case "tail byte":
+				changed := append([]byte(nil), original...)
+				changed[len(changed)-1] ^= 1
+				if err := os.WriteFile(name, changed, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "grown metadata":
+				if err := os.Truncate(name, fileByteLimit+1); err != nil {
+					t.Fatal(err)
+				}
+				after, err := os.Lstat(name)
+				if err != nil || !os.SameFile(before, after) || after.Size() <= fileByteLimit {
+					t.Fatal("first-party retained metadata did not actually grow past the original bound", err)
+				}
+			case "replacement", "symlink":
+				backup := filepath.Join(t.TempDir(), "original")
+				if err := os.Rename(name, backup); err != nil {
+					t.Fatal(err)
+				}
+				if role == "symlink" {
+					if err := os.Symlink(backup, name); err != nil {
+						t.Fatal(err)
+					}
+				} else if err := os.WriteFile(name, original, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			reader, ok := any(snapshot).(retainedSourceReader)
+			if !ok {
+				t.Fatal("retained metadata has no strict bounded physical read route")
+			}
+			actual, err := reader.ReadRetained(name)
+			if role == "unchanged" {
+				if err != nil || !bytes.Equal(actual, original) {
+					t.Fatal("original complete metadata tail was not read through EOF", err)
+				}
+			} else if err == nil || actual != nil {
+				t.Fatal("changed or over-bound retained metadata yielded bytes")
+			}
+		})
+	}
+}
+
+func TestSnapshotRepeatedAtCountBounds(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	name := filepath.Join(root, "member")
+	if err := os.WriteFile(name, []byte{1}, 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, role := range []string{"file", "directory", "cache directory"} {
+		t.Run(role, func(t *testing.T) {
+			snapshot := NewSnapshot()
+			var repeat, add func(string) error
+			switch role {
+			case "file":
+				if err := snapshot.Retain(name); err != nil {
+					t.Fatal(err)
+				}
+				for i := 1; i < fileLimit; i++ {
+					snapshot.hashes[fmt.Sprintf("count-only-%d", i)] = ""
+				}
+				repeat, add = snapshot.Retain, snapshot.Retain
+			case "directory":
+				if err := snapshot.Directory(root, false); err != nil {
+					t.Fatal(err)
+				}
+				for i := 1; i < directoryLimit; i++ {
+					snapshot.directories[fmt.Sprintf("count-only-%d", i)] = nil
+				}
+				repeat = func(name string) error { return snapshot.Directory(name, false) }
+				add = repeat
+			case "cache directory":
+				set := &OriginSet{directories: make(map[string]os.FileInfo)}
+				if err := set.retainCacheDirectory(root); err != nil {
+					t.Fatal(err)
+				}
+				for i := 1; i < directoryLimit; i++ {
+					set.directories[fmt.Sprintf("count-only-%d", i)] = nil
+				}
+				repeat, add = set.retainCacheDirectory, set.retainCacheDirectory
+			}
+			existing := root
+			if role == "file" {
+				existing = name
+			}
+			if err := repeat(existing); err != nil {
+				t.Fatal("re-observing an existing physical role consumed a new count slot", err)
+			}
+			extra := filepath.Join(root, "new-"+role)
+			if role == "file" {
+				if err := os.WriteFile(extra, []byte{2}, 0600); err != nil {
+					t.Fatal(err)
+				}
+			} else if err := os.Mkdir(extra, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if err := add(extra); err == nil {
+				t.Fatal("a new physical role escaped the original count bound")
+			}
+		})
+	}
+}
+
+func TestSnapshotRejectsRelativeDirectory(t *testing.T) {
+	if err := NewSnapshot().Directory(".", false); err == nil {
+		t.Fatal("relative directory acquired an original physical source role")
+	}
+}
+
+func TestSnapshotFullEOFAndPhysicalRoles(t *testing.T) {
+	for _, role := range []string{"unchanged", "tail byte", "same bytes replacement", "symlink", "added member"} {
+		t.Run(role, func(t *testing.T) {
+			root, err := filepath.EvalSymlinks(t.TempDir())
+			if err != nil {
+				t.Fatal(err)
+			}
+			name := filepath.Join(root, "source")
+			bytes := make([]byte, 64<<10+227)
+			for i := range bytes {
+				bytes[i] = byte(i)
+			}
+			if err := os.WriteFile(name, bytes, 0600); err != nil {
+				t.Fatal(err)
+			}
+			snapshot := NewSnapshot()
+			if err := snapshot.Directory(root, true); err != nil {
+				t.Fatal(err)
+			}
+			if snapshot.View().Hashes[name] != fmt.Sprintf("%x", sha256.Sum256(bytes)) {
+				t.Fatal("snapshot did not hash the complete original tail through EOF")
+			}
+			switch role {
+			case "tail byte":
+				bytes[len(bytes)-1] ^= 1
+				if err := os.WriteFile(name, bytes, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "same bytes replacement", "symlink":
+				backup := filepath.Join(t.TempDir(), "original")
+				if err := os.Rename(name, backup); err != nil {
+					t.Fatal(err)
+				}
+				if role == "symlink" {
+					if err := os.Symlink(backup, name); err != nil {
+						t.Fatal(err)
+					}
+				} else if err := os.WriteFile(name, bytes, 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "added member":
+				if err := os.WriteFile(filepath.Join(root, "ignored"), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			err = snapshot.Verify()
+			if role == "unchanged" && err != nil {
+				t.Fatal(err)
+			}
+			if role != "unchanged" && err == nil {
+				t.Fatal("changed physical source role was accepted")
+			}
+		})
+	}
+}
+
+func TestSnapshotOriginalSharedBounds(t *testing.T) {
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	snapshot := NewSnapshot()
+	bytes := make([]byte, fileByteLimit)
+	for i := 0; i < totalByteLimit/fileByteLimit; i++ {
+		name := filepath.Join(root, fmt.Sprintf("member-%d", i))
+		if err := os.WriteFile(name, bytes, 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := snapshot.Retain(name); err != nil {
+			t.Fatal("existing graph-wide byte budget rejected its boundary", err)
+		}
+	}
+	if snapshot.bytes != totalByteLimit {
+		t.Fatal("graph-wide byte accounting is incomplete")
+	}
+	if err := snapshot.Verify(); err != nil {
+		t.Fatal(err)
+	}
+	overflow := filepath.Join(root, "extra")
+	if err := os.WriteFile(overflow, []byte{1}, 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := snapshot.Retain(overflow); err == nil {
+		t.Fatal("another module/member acquired a fresh byte budget")
+	}
+}
+
+func TestOriginSetInvalidRoles(t *testing.T) {
+	for _, cache := range []string{"", ".", "relative/cache"} {
+		if _, err := NewOriginSet(cache, "/nonexistent/tool"); err == nil {
+			t.Fatal("nonabsolute or missing source/tool role was accepted")
+		}
+	}
+	if err := (*Snapshot)(nil).Verify(); err == nil {
+		t.Fatal("nil source snapshot was accepted")
+	}
+	if err := (*OriginSet)(nil).Verify(); err == nil {
+		t.Fatal("nil exact-source guard was accepted")
+	}
+}
diff --git a/internal/gooriginalsrc/snapshot_tool_test.go b/internal/gooriginalsrc/snapshot_tool_test.go
new file mode 100644
index 000000000..bf41a7826
--- /dev/null
+++ b/internal/gooriginalsrc/snapshot_tool_test.go
@@ -0,0 +1,463 @@
+package gooriginalsrc
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+type retainedToolObserver interface {
+	RetainTool(string) error
+}
+
+func requireRetainedToolObserver(t *testing.T, snapshot *Snapshot) retainedToolObserver {
+	t.Helper()
+	observer, ok := any(snapshot).(retainedToolObserver)
+	if !ok {
+		t.Fatal("original selected tool has no distinct bounded physical observation route")
+	}
+	return observer
+}
+
+func makeOriginalToolExtent(t *testing.T, root, base string, extent int64) string {
+	t.Helper()
+	name := filepath.Join(root, base)
+	file, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer file.Close()
+	if err := file.Truncate(extent); err != nil {
+		t.Fatal(err)
+	}
+	if extent > 0 {
+		if _, err := file.WriteAt([]byte{0x52}, 0); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := file.WriteAt([]byte{0xa7}, extent-1); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := file.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return name
+}
+
+func originalToolFixtureRoot(t *testing.T) string {
+	t.Helper()
+	root, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return root
+}
+
+func originalToolFullDigest(t *testing.T, name string) string {
+	t.Helper()
+	file, err := os.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	digest := sha256.New()
+	_, readErr := io.Copy(digest, file)
+	closeErr := file.Close()
+	if readErr != nil || closeErr != nil {
+		t.Fatal("independent complete tool bytes were not read", readErr, closeErr)
+	}
+	return fmt.Sprintf("%x", digest.Sum(nil))
+}
+
+func TestSnapshotTypedToolLimits(t *testing.T) {
+	for _, extent := range []int64{17 << 20, 64 << 20, 64<<20 + 1} {
+		t.Run(fmt.Sprintf("extent-%d", extent), func(t *testing.T) {
+			name := makeOriginalToolExtent(t, originalToolFixtureRoot(t), "go", extent)
+			snapshot := NewSnapshot()
+			observer := requireRetainedToolObserver(t, snapshot)
+			err := observer.RetainTool(name)
+			if extent > 64<<20 {
+				if err == nil || snapshot.bytes != 0 || len(snapshot.hashes) != 0 {
+					t.Fatal("oversized tool acquired a retained observation")
+				}
+				return
+			}
+			if err != nil || snapshot.bytes != extent {
+				t.Fatal("existing 64 MiB tool contract was narrowed to source bounds", err)
+			}
+			if snapshot.View().Hashes[name] != originalToolFullDigest(t, name) {
+				t.Fatal("tool observation did not consume the complete independent bytes")
+			}
+			if err := snapshot.Verify(); err != nil {
+				t.Fatal(err)
+			}
+			if err := observer.RetainTool(name); err != nil || snapshot.bytes != extent {
+				t.Fatal("repeat tool retention consumed another byte budget", err)
+			}
+			if err := NewSnapshot().Retain(name); err == nil {
+				t.Fatal("tool limit leaked into ordinary source/export retention")
+			}
+		})
+	}
+	for _, role := range []string{"source first", "tool first"} {
+		t.Run("shared-budget-"+role, func(t *testing.T) {
+			root := originalToolFixtureRoot(t)
+			source := makeOriginalToolExtent(t, root, "source", 16<<20)
+			tool := makeOriginalToolExtent(t, root, "compile", 48<<20)
+			snapshot := NewSnapshot()
+			observer := requireRetainedToolObserver(t, snapshot)
+			if role == "source first" {
+				if err := snapshot.Retain(source); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := observer.RetainTool(tool); err != nil {
+				t.Fatal(err)
+			}
+			if err := snapshot.Retain(source); err != nil || snapshot.bytes != 64<<20 {
+				t.Fatal("source/tool observations do not share the original total", err)
+			}
+			for index := 0; index < 4; index++ {
+				member := makeOriginalToolExtent(t, root, fmt.Sprintf("member-%d", index), 16<<20)
+				if err := snapshot.Retain(member); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if snapshot.bytes != totalByteLimit {
+				t.Fatal("source/tool graph no longer reaches its shared boundary")
+			}
+			extra := makeOriginalToolExtent(t, root, "extra", 1)
+			if err := snapshot.Retain(extra); err == nil {
+				t.Fatal("new source acquired another graph-wide byte budget")
+			}
+			if err := observer.RetainTool(extra); err == nil {
+				t.Fatal("new tool acquired another graph-wide byte budget")
+			}
+			if err := snapshot.Verify(); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestSnapshotTypedToolRoleIsolation(t *testing.T) {
+	for _, first := range []string{"source", "tool"} {
+		for _, alias := range []string{"same path", "hard link", "parent alias"} {
+			t.Run(first+"-"+alias, func(t *testing.T) {
+				root := originalToolFixtureRoot(t)
+				name := makeOriginalToolExtent(t, root, "member", 64<<10+1)
+				snapshot := NewSnapshot()
+				observer := requireRetainedToolObserver(t, snapshot)
+				retainFirst, retainSecond := snapshot.Retain, observer.RetainTool
+				if first == "tool" {
+					retainFirst, retainSecond = retainSecond, retainFirst
+				}
+				if err := retainFirst(name); err != nil {
+					t.Fatal(err)
+				}
+				other := name
+				switch alias {
+				case "hard link":
+					other = filepath.Join(root, "alias")
+					if err := os.Link(name, other); err != nil {
+						t.Fatal(err)
+					}
+				case "parent alias":
+					parent := filepath.Join(originalToolFixtureRoot(t), "alias")
+					if err := os.Symlink(root, parent); err != nil {
+						t.Fatal(err)
+					}
+					other = filepath.Join(parent, filepath.Base(name))
+				}
+				before, beforeErr := os.Stat(name)
+				after, afterErr := os.Stat(other)
+				if beforeErr != nil || afterErr != nil || !os.SameFile(before, after) {
+					t.Fatal("cross-role alias does not identify the same physical fixture")
+				}
+				if err := retainSecond(other); err == nil || snapshot.bytes != before.Size() {
+					t.Fatal("same source/tool inode acquired a different retained role", err)
+				}
+				if first == "tool" {
+					if data, err := snapshot.ReadRetained(name); err == nil || data != nil {
+						t.Fatal("retained tool yielded bytes through the source read route")
+					}
+					if reader, err := snapshot.OpenRetained(name); err == nil || reader != nil {
+						if reader != nil {
+							_ = reader.Close()
+						}
+						t.Fatal("retained tool yielded a source stream")
+					}
+					if err := snapshot.Directory(root, true); err == nil {
+						t.Fatal("recursive source inventory silently relabeled the tool")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestSnapshotTypedToolPhysicalClosure(t *testing.T) {
+	for _, role := range []string{"unchanged", "tail byte", "same inode growth", "same inode shrink", "same bytes replacement", "symlink", "directory", "added member", "directory replacement"} {
+		t.Run(role, func(t *testing.T) {
+			root := originalToolFixtureRoot(t)
+			name := makeOriginalToolExtent(t, root, "go", 17<<20)
+			snapshot := NewSnapshot()
+			observer := requireRetainedToolObserver(t, snapshot)
+			if err := observer.RetainTool(name); err != nil {
+				t.Fatal(err)
+			}
+			if err := snapshot.Directory(root, false); err != nil {
+				t.Fatal(err)
+			}
+			before, err := os.Lstat(name)
+			if err != nil {
+				t.Fatal(err)
+			}
+			switch role {
+			case "tail byte":
+				file, err := os.OpenFile(name, os.O_WRONLY, 0600)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, writeErr := file.WriteAt([]byte{0xa6}, before.Size()-1)
+				closeErr := file.Close()
+				if writeErr != nil || closeErr != nil {
+					t.Fatal(writeErr, closeErr)
+				}
+			case "same inode growth", "same inode shrink":
+				extent := before.Size() + 1
+				if role == "same inode shrink" {
+					extent = before.Size() - 1
+				}
+				if err := os.Truncate(name, extent); err != nil {
+					t.Fatal(err)
+				}
+				after, err := os.Lstat(name)
+				if err != nil || !os.SameFile(before, after) || after.Size() != extent {
+					t.Fatal("tool fixture did not actually change extent at the same inode", err)
+				}
+			case "same bytes replacement", "symlink", "directory":
+				backup := filepath.Join(originalToolFixtureRoot(t), "original")
+				if err := os.Rename(name, backup); err != nil {
+					t.Fatal(err)
+				}
+				switch role {
+				case "same bytes replacement":
+					makeOriginalToolExtent(t, root, "go", before.Size())
+					if originalToolFullDigest(t, name) != originalToolFullDigest(t, backup) {
+						t.Fatal("replacement control changed bytes instead of only inode")
+					}
+				case "symlink":
+					if err := os.Symlink(backup, name); err != nil {
+						t.Fatal(err)
+					}
+				case "directory":
+					if err := os.Mkdir(name, 0700); err != nil {
+						t.Fatal(err)
+					}
+				}
+			case "added member":
+				makeOriginalToolExtent(t, root, "foreign", 1)
+			case "directory replacement":
+				backup := filepath.Join(originalToolFixtureRoot(t), "original")
+				if err := os.Rename(root, backup); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(root, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Rename(filepath.Join(backup, "go"), name); err != nil {
+					t.Fatal(err)
+				}
+				after, err := os.Lstat(name)
+				if err != nil || !os.SameFile(before, after) {
+					t.Fatal("directory replacement did not preserve the original tool inode", err)
+				}
+			}
+			err = snapshot.Verify()
+			if role == "unchanged" {
+				if err != nil {
+					t.Fatal(err)
+				}
+			} else if err == nil {
+				t.Fatal("changed tool file or complete directory observation was accepted")
+			}
+		})
+	}
+}
+
+func TestOriginSetTypedTool(t *testing.T) {
+	root := originalToolFixtureRoot(t)
+	cache := filepath.Join(root, "cache")
+	if err := os.Mkdir(cache, 0700); err != nil {
+		t.Fatal(err)
+	}
+	tool := makeOriginalToolExtent(t, root, "go", 17<<20)
+	set, err := NewOriginSet(cache, tool)
+	if err != nil {
+		t.Fatal("exact original download classified its selected tool as source/export", err)
+	}
+	if err := set.Verify(); err != nil {
+		t.Fatal(err)
+	}
+	if data, err := set.files.ReadRetained(tool); err == nil || data != nil {
+		t.Fatal("original download tool escaped through a source byte route")
+	}
+}
+
+func TestSnapshotTypedToolStreamPhysicalClosure(t *testing.T) {
+	for _, role := range []string{"unchanged", "same inode growth", "same inode shrink", "tail byte", "replacement", "symlink", "incomplete close", "close error"} {
+		t.Run(role, func(t *testing.T) {
+			root := originalToolFixtureRoot(t)
+			name := makeOriginalToolExtent(t, root, "go", 17<<20)
+			snapshot := NewSnapshot()
+			if err := snapshot.RetainTool(name); err != nil {
+				t.Fatal(err)
+			}
+			before := snapshot.files[name]
+			reader, err := openOriginalRoleFile(name, before, snapshot.paths[name], snapshot.hashes[name], originalToolFile)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer reader.Close()
+			var prefix [1]byte
+			if _, err := io.ReadFull(reader, prefix[:]); err != nil || prefix[0] != 0x52 {
+				t.Fatal("actual tool member was not open before mutation", err)
+			}
+			switch role {
+			case "same inode growth", "same inode shrink":
+				extent := int64(toolByteLimit + 1)
+				if role == "same inode shrink" {
+					extent = before.Size() - 1
+				}
+				if err := os.Truncate(name, extent); err != nil {
+					t.Fatal(err)
+				}
+				after, err := os.Lstat(name)
+				if err != nil || !os.SameFile(before, after) || after.Size() != extent {
+					t.Fatal("open tool extent control did not use the original inode", err)
+				}
+			case "tail byte":
+				file, err := os.OpenFile(name, os.O_WRONLY, 0600)
+				if err != nil {
+					t.Fatal(err)
+				}
+				_, writeErr := file.WriteAt([]byte{0xa6}, before.Size()-1)
+				closeErr := file.Close()
+				if writeErr != nil || closeErr != nil {
+					t.Fatal(writeErr, closeErr)
+				}
+			case "replacement", "symlink":
+				backup := filepath.Join(originalToolFixtureRoot(t), "original")
+				live := renameOriginalStreamMember(t, snapshot, reader, name, backup, before.Size()-1)
+				if role == "replacement" {
+					makeOriginalToolExtent(t, root, "go", before.Size())
+				} else if err := os.Symlink(backup, name); err != nil {
+					t.Fatal(err)
+				}
+				if !live {
+					if err := snapshot.Verify(); err == nil {
+						t.Fatal("closed stream replacement retained the tool snapshot")
+					}
+					if replacement, err := openOriginalRoleFile(name, before, snapshot.paths[name], snapshot.hashes[name], originalToolFile); err == nil {
+						replacement.Close()
+						t.Fatal("replacement reopened as the original tool stream")
+					}
+					return
+				}
+			case "incomplete close":
+				if err := reader.Close(); err == nil {
+					t.Fatal("an incomplete original tool stream impersonated EOF")
+				}
+				return
+			}
+			count, readErr := io.Copy(io.Discard, reader)
+			if role == "close error" {
+				if readErr != nil || count != before.Size()-1 {
+					t.Fatal("close-error control did not first consume full tool EOF", readErr)
+				}
+				if err := reader.file.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}
+			closeErr := reader.Close()
+			if role == "unchanged" {
+				if readErr != nil || closeErr != nil || count != before.Size()-1 {
+					t.Fatal("complete tool stream was not closed through original EOF", readErr, closeErr)
+				}
+			} else if role == "close error" {
+				if !errors.Is(closeErr, os.ErrClosed) {
+					t.Fatal("actual closed tool FD error was lost", closeErr)
+				}
+			} else if readErr == nil && closeErr == nil {
+				t.Fatal("a changed tool stream was accepted through EOF")
+			}
+		})
+	}
+}
+
+func TestSnapshotTypedToolInvalidRolesAndCounts(t *testing.T) {
+	root := originalToolFixtureRoot(t)
+	tool := makeOriginalToolExtent(t, root, "go", 1)
+	for _, role := range []string{"nil", "relative", "missing", "directory", "symlink", "unknown role"} {
+		t.Run(role, func(t *testing.T) {
+			snapshot := NewSnapshot()
+			name := tool
+			switch role {
+			case "nil":
+				snapshot = nil
+			case "relative":
+				name = "go"
+			case "missing":
+				name = filepath.Join(root, "missing")
+			case "directory":
+				name = root
+			case "symlink":
+				name = filepath.Join(root, "symlink")
+				if err := os.Symlink(tool, name); err != nil {
+					t.Fatal(err)
+				}
+			case "unknown role":
+				if err := snapshot.RetainTool(tool); err != nil {
+					t.Fatal(err)
+				}
+				snapshot.retainedRoles[tool] = originalFileRole(255)
+				if err := snapshot.Verify(); err == nil {
+					t.Fatal("unknown private file role acquired a byte bound")
+				}
+				return
+			}
+			if err := snapshot.RetainTool(name); err == nil {
+				t.Fatal("invalid original tool role was retained")
+			}
+		})
+	}
+	for _, role := range []string{"retained files", "complete members"} {
+		t.Run(role, func(t *testing.T) {
+			snapshot := NewSnapshot()
+			if err := snapshot.RetainTool(tool); err != nil {
+				t.Fatal(err)
+			}
+			// Counter-only slots exercise the shared limit. They are not
+			// actual source observations and do not claim a valid inventory.
+			for index := 1; index < fileLimit; index++ {
+				name := fmt.Sprintf("count-only-%d", index)
+				if role == "retained files" {
+					snapshot.hashes[name] = ""
+				} else {
+					snapshot.fileRoles[name] = true
+				}
+			}
+			if err := snapshot.RetainTool(tool); err != nil || snapshot.bytes != 1 {
+				t.Fatal("repeat tool used another count/byte slot", err)
+			}
+			extra := makeOriginalToolExtent(t, originalToolFixtureRoot(t), "extra", 1)
+			if err := snapshot.RetainTool(extra); err == nil {
+				t.Fatal("new tool escaped the original shared file/member bound")
+			}
+		})
+	}
+}
diff --git a/internal/gooriginalsrc/zip.go b/internal/gooriginalsrc/zip.go
new file mode 100644
index 000000000..a9aa161ba
--- /dev/null
+++ b/internal/gooriginalsrc/zip.go
@@ -0,0 +1,274 @@
+package gooriginalsrc
+
+import (
+	"archive/zip"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+	"golang.org/x/mod/module"
+	"golang.org/x/mod/sumdb/dirhash"
+	modzip "golang.org/x/mod/zip"
+)
+
+func (set *OriginSet) moduleHashes(ctx context.Context, root, path, version, archive string) (zipSum, dirSum string, result error) {
+	result = set.withOriginalZIP(ctx, module.Version{Path: path, Version: version}, archive, func(reader *zip.Reader) error {
+		var err error
+		zipSum, dirSum, err = set.moduleReaderHashes(ctx, root, path, version, reader)
+		return err
+	})
+	return
+}
+
+func (set *OriginSet) moduleReaderHashes(ctx context.Context, root, path, version string, reader *zip.Reader) (string, string, error) {
+	if len(reader.File) > fileLimit {
+		return "", "", fmt.Errorf("original ZIP member inventory exceeds its count bound")
+	}
+	key := path + "@" + version
+	physical := make(map[string]string)
+	var treeBytes int64
+	for name, info := range set.files.files {
+		relative, err := filepath.Rel(root, name)
+		if err != nil || !filepath.IsLocal(relative) {
+			continue
+		}
+		member := key + "/" + filepath.ToSlash(relative)
+		physical[member] = name
+		treeBytes += info.Size()
+	}
+	if treeBytes > modzip.MaxZipFile || treeBytes > set.files.bytes || set.files.bytes > set.files.byteLimit() {
+		return "", "", fmt.Errorf("original ZIP/tree escaped its shared inventory byte bound")
+	}
+	members := make(map[string]*zip.File)
+	var names []string
+	var zipBytes int64
+	for _, member := range reader.File {
+		if _, duplicate := members[member.Name]; duplicate {
+			return "", "", fmt.Errorf("original ZIP contains a duplicate member")
+		}
+		original, exists := physical[member.Name]
+		if !exists {
+			return "", "", fmt.Errorf("original ZIP member has no complete retained tree role")
+		}
+		extent := set.files.files[original].Size()
+		if extent < 0 || member.UncompressedSize64 > modzip.MaxZipFile || member.UncompressedSize64 != uint64(extent) {
+			return "", "", fmt.Errorf("original ZIP member extent differs from its bounded retained tree role")
+		}
+		zipBytes += extent
+		if zipBytes > treeBytes {
+			return "", "", fmt.Errorf("original ZIP members exceed their retained tree extent")
+		}
+		members[member.Name] = member
+		names = append(names, member.Name)
+	}
+	if len(members) != len(physical) || zipBytes != treeBytes {
+		return "", "", fmt.Errorf("original ZIP/tree complete member inventories differ")
+	}
+	zipSum, err := hashOriginalMembers(names, func(name string) (io.ReadCloser, error) {
+		member := members[name]
+		reader, err := member.Open()
+		if err != nil {
+			return nil, err
+		}
+		return &originalZIPReader{reader: reader, expected: int64(member.UncompressedSize64), ctx: ctx}, nil
+	})
+	if err != nil {
+		return "", "", err
+	}
+	dirSum, err := hashOriginalMembers(names, func(name string) (io.ReadCloser, error) {
+		if err := ctx.Err(); err != nil {
+			return nil, err
+		}
+		reader, err := set.files.OpenRetained(physical[name])
+		if err != nil {
+			return nil, err
+		}
+		return &originalContextReader{ReadCloser: reader, ctx: ctx}, nil
+	})
+	return zipSum, dirSum, err
+}
+
+// Stream the retained archive into a private validation scratch. Both Go's
+// path-only validator and ZIP member consumers use those same guarded bytes,
+// without buffering a whole module ZIP in memory or replacing its source root.
+func (set *OriginSet) withOriginalZIP(ctx context.Context, identity module.Version, archive string, consume func(*zip.Reader) error) (result error) {
+	owned, err := os.MkdirTemp(set.cache, "plan9asm-original-zip-check-")
+	if err != nil {
+		return err
+	}
+	directoryInfo, err := os.Lstat(owned)
+	if err != nil {
+		return err
+	}
+	name := filepath.Join(owned, "original.zip")
+	var fileInfo os.FileInfo
+	defer func() {
+		actual, statErr := os.Lstat(owned)
+		physical, resolveErr := sourcepath.Resolve(owned)
+		entries, _, readErr := ReadDirectory(owned, 1)
+		if statErr != nil || resolveErr != nil || readErr != nil || physical != owned ||
+			!actual.IsDir() || !os.SameFile(directoryInfo, actual) {
+			result = errors.Join(result, fmt.Errorf("owned ZIP validation directory identity changed"))
+			return
+		}
+		if fileInfo == nil {
+			if len(entries) != 0 {
+				result = errors.Join(result, fmt.Errorf("owned ZIP validation inventory is unclosed"))
+				return
+			}
+		} else {
+			actual, err := os.Lstat(name)
+			if err != nil || len(entries) != 1 || entries[0].Name() != "original.zip" ||
+				!actual.Mode().IsRegular() || !os.SameFile(fileInfo, actual) {
+				result = errors.Join(result, fmt.Errorf("owned ZIP validation file identity changed"))
+				return
+			}
+		}
+		result = errors.Join(result, os.RemoveAll(owned))
+	}()
+	file, err := os.OpenFile(name, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0600)
+	if err != nil {
+		return err
+	}
+	fileInfo, err = file.Stat()
+	if err != nil {
+		return errors.Join(err, file.Close())
+	}
+	reader, err := set.files.OpenRetained(archive)
+	if err != nil {
+		return errors.Join(err, file.Close())
+	}
+	writeErr := copyOriginalFile(file, &originalContextReader{ReadCloser: reader, ctx: ctx})
+	if err := errors.Join(writeErr, file.Close()); err != nil {
+		return err
+	}
+	afterWrite, err := os.Lstat(name)
+	if err != nil || !afterWrite.Mode().IsRegular() || !os.SameFile(fileInfo, afterWrite) || afterWrite.Size() != set.files.files[archive].Size() {
+		return errors.Join(err, fmt.Errorf("owned ZIP validation file changed while writing"))
+	}
+	fileInfo = afterWrite
+	expected := set.files.hashes[archive]
+	verify := func() error {
+		actualDirectory, statErr := os.Lstat(owned)
+		entries, _, readErr := ReadDirectory(owned, 1)
+		if statErr != nil || readErr != nil || !actualDirectory.IsDir() || !os.SameFile(directoryInfo, actualDirectory) ||
+			len(entries) != 1 || entries[0].Name() != "original.zip" {
+			return errors.Join(statErr, readErr, fmt.Errorf("owned ZIP validation directory/inventory changed"))
+		}
+		actual, err := originalRoleFileSHA256(name, fileInfo, originalModuleArtifact)
+		if err != nil || actual != expected {
+			return errors.Join(err, fmt.Errorf("owned ZIP validation bytes changed"))
+		}
+		return nil
+	}
+	if err := verify(); err != nil {
+		return err
+	}
+	_, checkErr := modzip.CheckZip(identity, name)
+	if err := errors.Join(checkErr, verify()); err != nil {
+		return err
+	}
+	zipReader, err := zip.OpenReader(name)
+	if err != nil {
+		return err
+	}
+	consumeErr := consume(&zipReader.Reader)
+	return errors.Join(consumeErr, zipReader.Close(), verify(), ctx.Err())
+}
+
+// Go Hash1 intentionally ignores Close errors. Accumulate them independently
+// so failed physical EOF/CRC/resource closure cannot become an h1 success.
+func hashOriginalMembers(names []string, open func(string) (io.ReadCloser, error)) (string, error) {
+	var closeErr error
+	sum, err := dirhash.Hash1(names, func(name string) (io.ReadCloser, error) {
+		reader, err := open(name)
+		if err != nil {
+			return nil, err
+		}
+		return &originalCloseReader{ReadCloser: reader, result: &closeErr}, nil
+	})
+	return sum, errors.Join(err, closeErr)
+}
+
+type originalCloseReader struct {
+	io.ReadCloser
+	result *error
+}
+
+func (reader *originalCloseReader) Close() error {
+	err := reader.ReadCloser.Close()
+	*reader.result = errors.Join(*reader.result, err)
+	return err
+}
+
+type originalContextReader struct {
+	io.ReadCloser
+	ctx context.Context
+}
+
+func (reader *originalContextReader) Read(data []byte) (int, error) {
+	if err := reader.ctx.Err(); err != nil {
+		return 0, err
+	}
+	return reader.ReadCloser.Read(data)
+}
+
+func (reader *originalContextReader) Close() error {
+	return errors.Join(reader.ctx.Err(), reader.ReadCloser.Close())
+}
+
+type originalZIPReader struct {
+	reader   io.ReadCloser
+	ctx      context.Context
+	expected int64
+	count    int64
+	complete bool
+	closed   bool
+	failure  error
+}
+
+func (reader *originalZIPReader) Read(data []byte) (int, error) {
+	if reader.failure != nil {
+		return 0, reader.failure
+	}
+	if reader.closed {
+		return 0, os.ErrClosed
+	}
+	if reader.complete {
+		return 0, io.EOF
+	}
+	if err := reader.ctx.Err(); err != nil {
+		reader.failure = err
+		return 0, err
+	}
+	if remaining := reader.expected - reader.count + 1; int64(len(data)) > remaining {
+		data = data[:int(remaining)]
+	}
+	count, err := reader.reader.Read(data)
+	reader.count += int64(count)
+	if reader.count > reader.expected || err == io.EOF && reader.count != reader.expected {
+		err = fmt.Errorf("original ZIP member did not close its complete retained extent")
+	} else if err == io.EOF {
+		reader.complete = true
+	}
+	if err != nil && err != io.EOF {
+		reader.failure = err
+	}
+	return count, err
+}
+
+func (reader *originalZIPReader) Close() error {
+	if reader.closed {
+		return reader.failure
+	}
+	reader.closed = true
+	if !reader.complete {
+		reader.failure = errors.Join(reader.failure, fmt.Errorf("original ZIP member lacks complete EOF/CRC"))
+	}
+	reader.failure = errors.Join(reader.failure, reader.ctx.Err(), reader.reader.Close())
+	return reader.failure
+}
diff --git a/internal/gostaticstorage/archive.go b/internal/gostaticstorage/archive.go
new file mode 100644
index 000000000..0b89c60e9
--- /dev/null
+++ b/internal/gostaticstorage/archive.go
@@ -0,0 +1,322 @@
+// Package gostaticstorage observes bounded actual Go static storage. An object
+// record is not a pointer, caller, frame, initialized result or read permission.
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+var ErrContext = errors.New("static storage needs actual source context")
+
+type relocation struct {
+	Offset int64
+	Size   int64
+	Type   uint16
+}
+
+type dataRecord struct {
+	Name          string
+	Kind          uint8
+	ABI           uint16
+	Flags, Flags2 uint8
+	Size, Align   int64
+	Data          []byte
+	Relocations   []relocation
+	Member        string
+	Index         uint32
+}
+
+const archiveLimit = 16 << 20
+
+// ArchiveMemberInventoryLimit is the existing complete compiler archive bound.
+// SDK ASM inventories reserve two members for __.PKGDEF and _go_.o.
+// Reusing this bound supplies no source/object or instruction authority.
+const ArchiveMemberInventoryLimit = 64
+
+// ObjectSymbolInventoryLimit is the existing complete object-symbol bound.
+// Frontend cost preflights may reuse it; it creates no observation or authority.
+const ObjectSymbolInventoryLimit = 1 << 16
+const symbolLimit = ObjectSymbolInventoryLimit
+
+func contextError(message string) error { return fmt.Errorf("%w: %s", ErrContext, message) }
+
+// readArchive consumes an ordinary compiler archive, not nm/listing text. The
+// capture boundary separately binds the Go version and complete format sources.
+// This prototype excludes native/assembly archive members rather than guessing
+// a missing object's ownership. Every offset/count is checked before indexing.
+func readArchive(data []byte, target string) (map[string]dataRecord, error) {
+	members, err := archiveMembers(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(members) != 2 || members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+		return nil, contextError("missing or nonordinary compiler package/object members")
+	}
+	object, err := objectBody(members[1].data, target)
+	if err != nil {
+		return nil, err
+	}
+	return readObject(object)
+}
+
+type archiveMember struct {
+	name   string
+	data   []byte
+	offset int64
+}
+
+func archiveMembers(data []byte) ([]archiveMember, error) {
+	if len(data) < 8 || len(data) > archiveLimit || string(data[:8]) != "!<arch>\n" {
+		return nil, contextError("invalid compiler archive header or byte bound")
+	}
+	seen := make(map[string]bool)
+	var members []archiveMember
+	for pos := 8; pos < len(data); {
+		if len(seen) >= ArchiveMemberInventoryLimit || len(data)-pos < 60 {
+			return nil, contextError("truncated or oversized archive member inventory")
+		}
+		header := data[pos : pos+60]
+		name := strings.TrimSpace(string(header[:16]))
+		if string(header[58:]) != "`\n" || seen[name] || name == "" || strings.ContainsAny(name, "/\\\x00\r\n") {
+			return nil, contextError("duplicate, unknown or non-compiler archive member")
+		}
+		seen[name] = true
+		size, err := strconv.ParseUint(strings.TrimSpace(string(header[48:58])), 10, 32)
+		pos += 60
+		if err != nil || size == 0 || size > uint64(len(data)-pos) {
+			return nil, contextError("invalid archive member extent")
+		}
+		members = append(members, archiveMember{name, data[pos : pos+int(size)], int64(pos)})
+		pos += int(size)
+		if size&1 != 0 {
+			if pos >= len(data) || data[pos] != '\n' && data[pos] != 0 {
+				return nil, contextError("invalid archive alignment byte")
+			}
+			pos++
+		}
+	}
+	return members, nil
+}
+
+func objectBody(object []byte, target string) ([]byte, error) {
+	end := bytes.Index(object, []byte("\n!\n"))
+	if end < 0 || end > 4096 {
+		return nil, contextError("invalid compiler object text header")
+	}
+	if _, err := objectVersion(object, target); err != nil {
+		return nil, err
+	}
+	return object[end+3:], nil
+}
+
+func objectVersion(object []byte, target string) (string, error) {
+	version, err := objectHeaderVersion(object, target)
+	if err != nil {
+		return "", err
+	}
+	if !gotoolchain.AuditedGo127(version) {
+		return "", contextError("object target/version differs from selected compiler")
+	}
+	return version, nil
+}
+
+// The caller must separately admit and bind the exact producer. Parsing this
+// header alone does not register a compiler object format.
+func objectHeaderVersion(object []byte, target string) (string, error) {
+	end := bytes.IndexByte(object, '\n')
+	if end < 0 || end > 4096 {
+		return "", contextError("invalid compiler object version header")
+	}
+	goos, goarch, valid := strings.Cut(target, "/")
+	words := strings.Fields(string(object[:end]))
+	if !valid || len(words) < 5 || words[0] != "go" || words[1] != "object" ||
+		words[2] != goos || words[3] != goarch {
+		return "", contextError("object target/version differs from selected compiler")
+	}
+	return words[4], nil
+}
+
+// ValidateObjectVersion binds an object (or compiler export member) to its
+// producer's exact patch release. Shared format support alone is not a match.
+func ValidateObjectVersion(object []byte, target, version string) error {
+	actual, err := objectVersion(object, target)
+	if err != nil {
+		return err
+	}
+	if actual != version {
+		return contextError("object version differs from its actual producer")
+	}
+	return nil
+}
+
+// These byte roles are pinned to Go 1.27.1 cmd/internal/goobj/objfile.go, rather
+// than inferred from symbol spellings or the data-only assembler listing.
+func readObject(data []byte) (map[string]dataRecord, error) {
+	return readObjectRole(data, 0, false)
+}
+
+// checkedObject is shared structural validation, not an archive/source role.
+// DATA and TEXT readers still independently choose their allowed member roles.
+type checkedGoObject struct {
+	block    func(int) []byte
+	stringAt func([]byte) (string, error)
+	indices  [3][]uint32
+	count    int
+}
+
+func checkedObject(data []byte, flags uint32, emptyAssembly bool) (*checkedGoObject, error) {
+	return checkedObjectRecords(data, flags, emptyAssembly, false)
+}
+
+// SDK compiler bodies have four independently bounded definition namespaces.
+// This offline decoding role supplies no SDK provenance or source authority.
+// Ordinary bodies and individual assembly members retain their original bound.
+func checkedSDKObject(data []byte, flags uint32, emptyAssembly bool) (*checkedGoObject, error) {
+	return checkedObjectRecords(data, flags, emptyAssembly, flags&16 != 0 && flags&4 == 0)
+}
+
+func checkedObjectRecords(data []byte, flags uint32, emptyAssembly, sdkCompiler bool) (*checkedGoObject, error) {
+	const headerSize = 8 + 8 + 4 + 19*4
+	if len(data) < headerSize || len(data) > archiveLimit || string(data[:8]) != "\x00go120ld" {
+		return nil, contextError("unknown or truncated binary goobj header")
+	}
+	// ObjFlagShared, FromAssembly and Unlinkable are outside this prototype.
+	if binary.LittleEndian.Uint32(data[16:20]) != flags {
+		return nil, contextError("nonordinary compiler object flags")
+	}
+	var offsets [19]int
+	previous := headerSize
+	for i := range offsets {
+		value := uint64(binary.LittleEndian.Uint32(data[20+4*i:]))
+		if value < uint64(previous) || value > uint64(len(data)) {
+			return nil, contextError("overlapping, unordered or out-of-range object block")
+		}
+		offsets[i], previous = int(value), int(value)
+	}
+	if offsets[18] != len(data) {
+		return nil, contextError("object blocks do not cover exact EOF")
+	}
+	block := func(index int) []byte { return data[offsets[index]:offsets[index+1]] }
+	// Check every fixed-record block, including unused reference/aux records.
+	widths := [...]int{16, 8, 8, 21, 21, 21, 21, 21, 10, 8, 16, 4, 4, 4, 23, 9, 0, 16}
+	for index, width := range widths {
+		if width == 0 {
+			continue // Raw DATA bytes are bounded by the complete object interval.
+		}
+		// Index tables contain N+1 entries and are checked exactly below.
+		// SDK relocation/Aux work is bounded by its own aligned byte block,
+		// not the unrelated number of definitions in a single namespace.
+		boundedByBytes := index >= 11 && index <= 13 || sdkCompiler && (index == 14 || index == 15)
+		if len(block(index))%width != 0 || !boundedByBytes && len(block(index))/width > symbolLimit {
+			return nil, contextError(fmt.Sprintf("invalid or excessive binary block record count: block=%d bytes=%d width=%d records=%d limit=%d",
+				index, len(block(index)), width, len(block(index))/width, symbolLimit))
+		}
+	}
+	definitionBlocks := [...]int{3, 4, 5, 6}
+	count := 0
+	for _, i := range definitionBlocks {
+		count += len(block(i)) / 21
+	}
+	definitionLimit := symbolLimit
+	if sdkCompiler {
+		definitionLimit *= len(definitionBlocks)
+	}
+	if count == 0 && !emptyAssembly || count > definitionLimit || len(block(9))/8 != len(block(4))/21 || len(block(10))/16 != len(block(5))/21 {
+		return nil, contextError("invalid symbol/hash inventory")
+	}
+	var indices [3][]uint32
+	for slot, spec := range []struct{ index, records, width int }{{11, 14, 23}, {12, 15, 9}, {13, 16, 1}} {
+		if len(block(spec.index)) != 4*(count+1) {
+			return nil, contextError("missing complete symbol index inventory")
+		}
+		values := make([]uint32, count+1)
+		for i := range values {
+			values[i] = binary.LittleEndian.Uint32(block(spec.index)[4*i:])
+			if i == 0 && values[i] != 0 || i > 0 && values[i] < values[i-1] || uint64(values[i]) > uint64(len(block(spec.records))/spec.width) {
+				return nil, contextError("unordered or overflowing object index")
+			}
+		}
+		if uint64(values[count]) != uint64(len(block(spec.records))/spec.width) {
+			return nil, contextError("unconsumed object index tail")
+		}
+		indices[slot] = values
+	}
+	stringAt := func(ref []byte) (string, error) {
+		length, off := uint64(binary.LittleEndian.Uint32(ref)), uint64(binary.LittleEndian.Uint32(ref[4:]))
+		if length > 4096 || off < headerSize || off > uint64(offsets[0]) || length > uint64(offsets[0])-off {
+			return "", contextError("object string outside complete string block")
+		}
+		name := string(data[int(off):int(off+length)])
+		if strings.ContainsAny(name, "\x00\r\n") {
+			return "", contextError("invalid binary symbol name")
+		}
+		return name, nil
+	}
+	// Validate all string-bearing fixed records, not just requested definitions.
+	// Reference/auxiliary inventory cannot hide an overflowing string reference.
+	for _, spec := range []struct{ index, width, start int }{{0, 16, 0}, {1, 8, 0}, {2, 8, 0}, {3, 21, 0}, {4, 21, 0}, {5, 21, 0}, {6, 21, 0}, {7, 21, 0}, {17, 16, 8}} {
+		for pos := 0; pos < len(block(spec.index)); pos += spec.width {
+			if _, err := stringAt(block(spec.index)[pos+spec.start : pos+spec.start+8]); err != nil {
+				return nil, err
+			}
+		}
+	}
+	// The pinned objabi SymKind enum ends at SSEHUNWINDINFO (25).
+	// Sxxx (0) is only meaningful for an undefined nonpackage reference.
+	for index := 3; index <= 7; index++ {
+		for pos := 0; pos < len(block(index)); pos += 21 {
+			kind := block(index)[pos+10]
+			if kind > 25 || index != 7 && kind == 0 {
+				return nil, contextError("unknown or undefined Go symbol kind")
+			}
+		}
+	}
+	return &checkedGoObject{block, stringAt, indices, count}, nil
+}
+
+func readObjectRole(data []byte, flags uint32, emptyAssembly bool) (map[string]dataRecord, error) {
+	object, err := checkedObject(data, flags, emptyAssembly)
+	if err != nil {
+		return nil, err
+	}
+	block, stringAt, indices, count := object.block, object.stringAt, object.indices, object.count
+	result := make(map[string]dataRecord, count)
+	symbols := data[binary.LittleEndian.Uint32(data[32:]):binary.LittleEndian.Uint32(data[48:])]
+	for i := 0; i < count; i++ {
+		// All five symbol blocks are adjacent, as checked above. Keep DATA's
+		// legacy named-definition view separate from indexed TEXT metadata.
+		sym := symbols[21*i : 21*(i+1)]
+		name, err := stringAt(sym[:8])
+		if err != nil {
+			return nil, err
+		}
+		// Content-addressed symbols can share an empty name; they never become
+		// requested typed globals. Named duplicate definitions fail closed.
+		if name != "" {
+			if _, duplicate := result[name]; duplicate {
+				return nil, contextError("duplicate native symbol definition")
+			}
+		}
+		r := dataRecord{Name: name, ABI: binary.LittleEndian.Uint16(sym[8:]), Kind: sym[10], Flags: sym[11], Flags2: sym[12],
+			Size: int64(binary.LittleEndian.Uint32(sym[13:])), Align: int64(binary.LittleEndian.Uint32(sym[17:]))}
+		start, end := int(indices[2][i]), int(indices[2][i+1])
+		if end > start {
+			r.Data = append([]byte(nil), block(16)[start:end]...)
+		}
+		for j := indices[0][i]; j < indices[0][i+1]; j++ {
+			q := block(14)[int(j)*23 : int(j+1)*23]
+			r.Relocations = append(r.Relocations, relocation{int64(int32(binary.LittleEndian.Uint32(q))), int64(q[4]), binary.LittleEndian.Uint16(q[5:])})
+		}
+		if name != "" {
+			result[name] = r
+		}
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/archive_go127_test.go b/internal/gostaticstorage/archive_go127_test.go
new file mode 100644
index 000000000..e7610b710
--- /dev/null
+++ b/internal/gostaticstorage/archive_go127_test.go
@@ -0,0 +1,349 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+const fixtureModule = "example.invalid/staticstorage"
+
+func fixture(t *testing.T) (string, string, []string) {
+	t.Helper()
+	dir := t.TempDir()
+	var err error
+	dir, err = filepath.EvalSymlinks(dir) // This fixture owns the fresh directory.
+	if err != nil {
+		t.Fatal(err)
+	}
+	files := map[string]string{
+		"go.mod": "module " + fixtureModule + "\n\ngo 1.27.1\n",
+		"storage.go": `package staticstorage
+import "example.invalid/staticstorage/dep"
+var Keys [48]byte
+var Data = [4]byte{1, 2, 3, 4}
+var Mixed struct { Flag bool; Word uint32; Pointer *byte; Tail [3]byte }
+var Relocated = struct { Number uint32; Pointer *byte }{7, &Keys[0]}
+var TwiceRelocated = struct { Number uint32; First, Second *byte }{7, &Keys[0], &Keys[1]}
+var Address uintptr
+var PointerOnly *byte
+var StringOnly string
+var SliceOnly []byte
+var MapOnly map[byte]byte
+var ComplexOnly complex128
+var BlankOnly struct { _ [8]byte }
+var ZeroSize [0]byte
+func Read() byte { return Keys[0] + Data[0] + dep.Keys[0] }
+`,
+		"dep/dep.go": `package dep
+var Flags struct { _ [64]byte; Enabled bool; Tail [3]byte }
+var Keys [16]byte
+func Set(v byte) { Keys[0] = v; Flags.Enabled = v != 0 }
+`,
+	}
+	for name, data := range files {
+		file := filepath.Join(dir, filepath.FromSlash(name))
+		if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(file, []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = filepath.EvalSymlinks(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	env := fixtureEnv(t, "linux/amd64")
+	return dir, binary, env
+}
+
+func fixtureEnv(t *testing.T, target string) []string {
+	t.Helper()
+	values := make(map[string]string)
+	for _, pair := range os.Environ() {
+		key, value, _ := strings.Cut(pair, "=")
+		values[key] = value
+	}
+	for _, key := range []string{"GOCACHE", "GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		canonical, err := filepath.EvalSymlinks(values[key])
+		if !filepath.IsAbs(values[key]) || err != nil || canonical != values[key] {
+			// Only a fresh factory-owned artifact may be canonicalized. Do
+			// not rewrite a redirected caller input into an accepted role.
+			values[key] = t.TempDir()
+			canonical, err = filepath.EvalSymlinks(values[key])
+			if err != nil {
+				t.Fatal(err)
+			}
+			values[key] = canonical
+		}
+	}
+	goos, goarch, _ := strings.Cut(target, "/")
+	for key, value := range map[string]string{
+		"GOOS": goos, "GOARCH": goarch, "GOTOOLCHAIN": "local", "GOENV": "off",
+		"GOWORK": "off", "CGO_ENABLED": "0", "GOFLAGS": "", "GOEXPERIMENT": "",
+		"GOAMD64": "v1", "GOPROXY": "off", "GOSUMDB": "off",
+	} {
+		values[key] = value
+	}
+	var env []string
+	for key, value := range values {
+		env = append(env, key+"="+value)
+	}
+	return env
+}
+
+func run(t *testing.T, binary, dir string, env []string, args ...string) []byte {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	output, err := goasmcmd.Run(ctx, dir, env, binary, args...)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return output
+}
+
+// The independent reader uses actual SDK exports and an explicit importcfg at
+// the compiler boundary. No fake SDK source membership or SDK file mutation is
+// involved. It reads binary objects through Go's archive/goobj implementation,
+// not nm text or this package's parser.
+const officialReaderSource = `package main
+import (
+ "cmd/internal/archive"
+ "cmd/internal/goobj"
+ "encoding/json"
+ "fmt"
+ "os"
+)
+type Reloc struct { Offset, Size int64; Type uint16 }
+type Record struct {
+ Name string; Kind uint8; ABI uint16; Flags, Flags2 uint8
+ Size, Align int64; Data []byte; Relocations []Reloc
+}
+func main() {
+ f, err := os.Open(os.Args[1]); if err != nil { panic(err) }; defer f.Close()
+ a, err := archive.Parse(f, false); if err != nil { panic(err) }
+ result := map[string]Record{}
+ for _, entry := range a.Entries {
+  if entry.Type != archive.EntryGoObj { continue }
+  data := make([]byte, entry.Obj.Size)
+  n, err := f.ReadAt(data, entry.Obj.Offset)
+  if err != nil || n != len(data) { panic(fmt.Sprint(n, err)) }
+  r := goobj.NewReaderFromBytes(data, false); if r == nil { panic("goobj") }
+  count := r.NSym()+r.NHashed64def()+r.NHasheddef()+r.NNonpkgdef()
+  for i:=0; i<count; i++ {
+   s := r.Sym(uint32(i))
+   name := s.Name(r)
+   v := Record{Name:name, Kind:s.Type(), ABI:s.ABI(), Flags:s.Flag(), Flags2:s.Flag2(), Size:int64(s.Siz()), Align:int64(s.Align()), Data:r.Data(uint32(i))}
+   for j:=0; j<r.NReloc(uint32(i)); j++ {
+    q:=r.Reloc(uint32(i),j)
+    v.Relocations=append(v.Relocations,Reloc{int64(q.Off()),int64(q.Siz()),q.Type()})
+   }
+   result[name]=v
+  }
+ }
+ if err:=json.NewEncoder(os.Stdout).Encode(result); err!=nil { panic(err) }
+}
+`
+
+func officialReader(t *testing.T, binary string) string {
+	return officialReaderForSource(t, binary, officialReaderSource)
+}
+
+func officialReaderForSource(t *testing.T, binary, source string) string {
+	t.Helper()
+	dir := t.TempDir()
+	var err error
+	dir, err = filepath.EvalSymlinks(dir) // Fresh fixture-owned output, not an input redirect.
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, data := range map[string]string{"main.go": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	env := fixtureEnv(t, runtime.GOOS+"/"+runtime.GOARCH)
+	arguments := []string{"list", "-deps", "-export", "-f",
+		"{{if .Export}}packagefile {{.ImportPath}}={{.Export}}{{end}}",
+		"cmd/internal/archive", "cmd/internal/goobj", "encoding/json", "fmt", "os"}
+	if source == sdkTextReaderSource {
+		arguments = append(arguments, "cmd/internal/objfile")
+	}
+	config := run(t, binary, dir, env, arguments...)
+	if err := os.WriteFile(filepath.Join(dir, "importcfg"), config, 0600); err != nil {
+		t.Fatal(err)
+	}
+	tool := filepath.Join(dir, gotoolchain.HostExecutable("official-reader"))
+	run(t, binary, dir, env, "tool", "compile", "-p", "main", "-importcfg", "importcfg", "-o", "main.o", "main.go")
+	run(t, binary, dir, env, "tool", "link", "-importcfg", "importcfg", "-o", tool, "main.o")
+	if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+		if source == sdkTextReaderSource {
+			artifact = filepath.Join(artifact, "text-sdk-oracle")
+		} else if source == sdkNamespaceReaderSource {
+			artifact = filepath.Join(artifact, "namespace-sdk-oracle")
+		} else if source == sdkIndexedAuxReaderSource {
+			artifact = filepath.Join(artifact, "aux-sdk-oracle")
+		} else if source == sdkIndexedCountsReaderSource {
+			artifact = filepath.Join(artifact, "indexed-counts-sdk-oracle")
+		} else if source == sdkASMDataReaderSource {
+			artifact = filepath.Join(artifact, "asm-data-sdk-oracle")
+		} else if source != officialReaderSource {
+			artifact = filepath.Join(artifact, "cpu-sdk-oracle")
+		}
+		if err := os.MkdirAll(artifact, 0700); err != nil {
+			t.Fatal(err)
+		}
+		goenv := run(t, binary, dir, env, "env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOOS", "GOARCH")
+		var actual map[string]string
+		if err := json.Unmarshal(goenv, &actual); err != nil {
+			t.Fatal(err)
+		}
+		inputs := map[string]string{}
+		for role, file := range map[string]string{
+			"go":      binary,
+			"compile": filepath.Join(actual["GOTOOLDIR"], gotoolchain.HostExecutable("compile")),
+			"link":    filepath.Join(actual["GOTOOLDIR"], gotoolchain.HostExecutable("link")),
+		} {
+			data, err := os.ReadFile(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			inputs[role] = digest(data)
+		}
+		for name := range formatSources {
+			data, err := os.ReadFile(filepath.Join(actual["GOROOT"], filepath.FromSlash(name)))
+			if err != nil || digest(data) != formatSources[name] {
+				t.Fatal("independent reader SDK format source changed", name, err)
+			}
+			inputs[name] = digest(data)
+		}
+		readerBytes, err := os.ReadFile(tool)
+		if err != nil {
+			t.Fatal(err)
+		}
+		inputs["reader"] = digest(readerBytes)
+		metadata, _ := json.MarshalIndent(struct {
+			Directory, Binary string
+			Environment       []string
+			Tools             map[string]string
+			SourceSHA256      string
+			Commands          [][]string
+		}{dir, binary, env, inputs, digest([]byte(source)), [][]string{
+			arguments,
+			{"tool", "compile", "-p", "main", "-importcfg", "importcfg", "-o", "main.o", "main.go"},
+			{"tool", "link", "-importcfg", "importcfg", "-o", tool, "main.o"},
+		}}, "", "  ")
+		for name, data := range map[string][]byte{"sdk-reader-source.go": []byte(source), "sdk-reader-importcfg": config, "sdk-reader-input.json": metadata, "sdk-reader-env.json": goenv, "sdk-reader": readerBytes} {
+			if err := os.WriteFile(filepath.Join(artifact, name), data, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	return tool
+}
+
+func TestGoStaticStorageActualBinaryDataRecords(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	oracle := officialReader(t, binary)
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			output := run(t, binary, dir, fixtureEnv(t, target), selectionArguments()...)
+			packages := make(map[string]Package)
+			decoder := json.NewDecoder(bytes.NewReader(output))
+			for {
+				var pkg Package
+				if err := decoder.Decode(&pkg); err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				packages[pkg.ImportPath] = pkg
+			}
+			selected := packages[fixtureModule]
+			if selected.Export == "" || packages[fixtureModule+"/dep"].Export == "" {
+				t.Fatalf("actual owned/imported exports missing: %s", output)
+			}
+			data, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var expected map[string]dataRecord
+			oracleRaw := run(t, oracle, dir, fixtureEnv(t, target), selected.Export)
+			if err := json.Unmarshal(oracleRaw, &expected); err != nil {
+				t.Fatal(err)
+			}
+			depData, err := os.ReadFile(packages[fixtureModule+"/dep"].Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			depRaw := run(t, oracle, dir, fixtureEnv(t, target), packages[fixtureModule+"/dep"].Export)
+			var depExpected map[string]dataRecord
+			if err := json.Unmarshal(depRaw, &depExpected); err != nil {
+				t.Fatal(err)
+			}
+			depActual, err := readArchive(depData, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"Flags", "Keys"} {
+				name = fixtureModule + "/dep." + name
+				if depExpected[name].Size == 0 || !reflect.DeepEqual(depActual[name], depExpected[name]) {
+					t.Fatal("independent imported data record differs", name)
+				}
+			}
+			if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+				if !filepath.IsAbs(artifact) {
+					t.Fatal("artifact root must be explicit and absolute")
+				}
+				folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"))
+				if err := os.MkdirAll(folder, 0700); err != nil {
+					t.Fatal(err)
+				}
+				for name, contents := range map[string][]byte{"actual.a": data, "sdk-reader.json": oracleRaw, "selected.json": output, "dep.a": depData, "dep-sdk-reader.json": depRaw} {
+					if err := os.WriteFile(filepath.Join(folder, name), contents, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			t.Logf("ACTUAL_ARCHIVE_SHA256 %s %x SDK_READER_SHA256 %x", target, sha256.Sum256(data), sha256.Sum256(oracleRaw))
+			for _, name := range []string{"Keys", "Data", "Mixed", "Relocated"} {
+				if expected[fixtureModule+"."+name].Size == 0 {
+					t.Fatal("independent actual compiler object omitted", name)
+				}
+			}
+			t.Logf("ACTUAL_GO_BINARY_STORAGE %s Keys=%+v Data=%+v Mixed=%+v", target,
+				expected[fixtureModule+".Keys"], expected[fixtureModule+".Data"], expected[fixtureModule+".Mixed"])
+			actual, err := readArchive(data, target)
+			if err != nil {
+				t.Fatalf("compiled initialized storage lacks binary producer: %v", err)
+			}
+			for _, name := range []string{"Keys", "Data", "Mixed", "Relocated"} {
+				name = fixtureModule + "." + name
+				if !reflect.DeepEqual(actual[name], expected[name]) {
+					t.Fatalf("independent SDK binary record differs for %s: got %+v want %+v", name, actual[name], expected[name])
+				}
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_arm64_go127_test.go b/internal/gostaticstorage/assembly_arm64_go127_test.go
new file mode 100644
index 000000000..dc4274e0f
--- /dev/null
+++ b/internal/gostaticstorage/assembly_arm64_go127_test.go
@@ -0,0 +1,116 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestGoStaticStorageARM64AssemblyDefaultTargetRoles(t *testing.T) {
+	directory, goBinary, _ := fixture(t)
+	oracle := officialReaderForSource(t, goBinary, sdkTextReaderSource)
+	consumer := filepath.Join(directory, "armcarrier")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goSource := "package armcarrier\nfunc callee(input uint64) uint32\n" +
+		"func entry(input uint64) uint32 { return callee(input) }\n"
+	assembly := "TEXT ·callee(SB),4,$0-12\nMOVD input+0(FP),R0\nMOVD R0,ret+8(FP)\nRET\n"
+	for name, data := range map[string]string{"value.go": goSource, "value_arm64.s": assembly} {
+		if err := os.WriteFile(filepath.Join(consumer, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goRoot := filepath.Dir(filepath.Dir(goBinary))
+	builtins, err := os.ReadFile(filepath.Join(goRoot, "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, goos := range []string{"darwin", "linux", "windows", "freebsd", "openbsd"} {
+		t.Run(goos, func(t *testing.T) {
+			target := goos + "/arm64"
+			environment := fixtureEnv(t, target)
+			selection := run(t, goBinary, consumer, environment, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			var selected struct {
+				Export string
+				SFiles []string
+			}
+			if err := json.Unmarshal(selection, &selected); err != nil ||
+				len(selected.SFiles) != 1 || selected.SFiles[0] != "value_arm64.s" || selected.Export == "" {
+				t.Fatal("actual ARM64 member selection differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, consumer, environment, selected.Export)
+			var official []TextMember
+			if err := json.Unmarshal(raw, &official); err != nil || len(official) != 3 {
+				t.Fatal("independent SDK complete ARM64 archive differs", err)
+			}
+			compilerFlags := uint32(0)
+			if goos == "darwin" {
+				compilerFlags = 1 // default PIE: SDK work/init.go and platform.DefaultPIE
+			}
+			if official[1].Flags != compilerFlags || official[2].Flags != compilerFlags|4 {
+				t.Fatal("actual default driver member roles differ from pinned SDK")
+			}
+			observed, err := ObserveARM64AssemblyArchive(archive, builtins, target, selected.SFiles)
+			if err != nil || !reflect.DeepEqual(observed, official) {
+				t.Fatal("all original ARM64 bytes/positions/flags differ from SDK reader", err)
+			}
+			// Exact role flags are required, not a union of plausible flags.
+			// In particular Darwin's default Shared bit cannot authorize Std,
+			// Unlinkable or a mismatched compiler/assembler member role.
+			for memberIndex := 1; memberIndex < len(official); memberIndex++ {
+				member := official[memberIndex]
+				for _, flags := range []uint32{0, 1, 4, 5, 8, 16, 31} {
+					if flags == member.Flags {
+						continue
+					}
+					t.Run(fmt.Sprintf("member%d-flags%d", memberIndex, flags), func(t *testing.T) {
+						changed := append([]byte(nil), archive...)
+						body := changed[member.Offset : member.Offset+member.Size]
+						headerEnd := bytes.Index(body, []byte("\n!\n"))
+						if headerEnd < 0 || len(body)-headerEnd-3 < 20 {
+							t.Fatal("actual member flag position is missing")
+						}
+						binary.LittleEndian.PutUint32(body[headerEnd+3+16:headerEnd+3+20], flags)
+						if _, err := ObserveARM64AssemblyArchive(changed, builtins, target, selected.SFiles); err == nil {
+							t.Fatal("offline observation accepted wrong original member role")
+						}
+					})
+				}
+			}
+			objectPath := filepath.Join(t.TempDir(), "original.o")
+			listing := run(t, goBinary, consumer, environment, "tool", "asm", "-S", "-p",
+				fixtureModule+"/armcarrier", "-o", objectPath, "value_arm64.s")
+			object, err := os.ReadFile(objectPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			standaloneRaw := run(t, oracle, consumer, environment, objectPath)
+			var standalone []TextMember
+			if err := json.Unmarshal(standaloneRaw, &standalone); err != nil || len(standalone) != 1 || standalone[0].Flags != 4 {
+				t.Fatal("actual direct tool asm role differs", err)
+			}
+			texts, err := ObserveARM64AssemblyText(object, builtins, target)
+			if err != nil || !reflect.DeepEqual(texts, standalone[0].Texts) {
+				t.Fatal("standalone original ARM64 object differs from SDK reader", err)
+			}
+			retainTextArtifact(t, target, "arm64-byte-carrier", map[string][]byte{
+				"archive-original.a": archive, "archive-sdk.json": raw,
+				"object-original.o": object, "object-sdk.json": standaloneRaw,
+				"object-listing.txt": listing, "selection.json": selection,
+				"source-value.go": []byte(goSource), "source-value.s": []byte(assembly),
+			})
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data.go b/internal/gostaticstorage/assembly_data.go
new file mode 100644
index 000000000..43aaaef04
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data.go
@@ -0,0 +1,370 @@
+package gostaticstorage
+
+import (
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+)
+
+// ASMDataProtocol describes offline source/object observations only. Neither
+// a fragment nor a successful join is a storage, initializer, read or native
+// body certificate. Live SDK source provenance is a separate producer role.
+const ASMDataProtocol = "actual_go_asm_data_observation_v1"
+
+// ASMDataCPPProtocol does not certify the raw-to-expanded transformation. The
+// live SDK producer must independently bind that execution and all its inputs.
+const ASMDataCPPProtocol = "actual_go_sdk_cpp_asm_data_observation_v1"
+
+type ASMDataValueKind string
+
+const (
+	ASMDataInteger ASMDataValueKind = "integer"
+	ASMDataFloat   ASMDataValueKind = "float"
+	ASMDataString  ASMDataValueKind = "string"
+	ASMDataAddress ASMDataValueKind = "address"
+)
+
+type ASMDataAddressValue struct {
+	Name   string
+	Static bool
+	ABI    uint16
+	Addend int64
+}
+
+// ASMDataFragment retains the source value and its actual encoded bytes. Bits
+// are the width-truncated integer or IEEE float bit pattern, not a Go type.
+type ASMDataFragment struct {
+	Ordinal, Line int
+	Offset, Width int64
+	Kind          ASMDataValueKind
+	Bits          uint64
+	String        []byte
+	Address       *ASMDataAddressValue
+}
+
+type ASMGlobalLayout struct {
+	Ordinal, Line int
+	Name          string
+	Static        bool
+	ABI           uint16
+	Flags         uint64
+	DeclaredSize  int64
+	Fragments     []ASMDataFragment
+	Definition    ASMDataDefinition
+}
+
+// ASMDataDefinition is one exact object-local record. Repeated names, hashes
+// or bytes do not merge identities or select a linker winner.
+type ASMDataDefinition struct {
+	Namespace           TextSymbolNamespace
+	Relative, Index     uint32
+	Name                string
+	ABI                 uint16
+	Kind, Flags, Flags2 uint8
+	Size, Align         uint32
+	Hash                []byte
+	DataOffset          uint32
+	Data                []byte
+	Relocations         []TextRelocation
+}
+
+type ASMDataMember struct {
+	Name         string
+	NameBytes    []byte
+	Ordinal      int
+	Offset, Size int64
+	ObjectOffset int64
+	Flags        uint32
+	Definitions  []ASMDataDefinition
+	Texts        []TextRecord
+}
+
+// SDKASMDataSource contains whole, separately retained inputs. The offline
+// API does not authenticate a CPP invocation, generated header or SDK origin.
+// Original and Expanded must each describe the observed directive grammar;
+// unknown macros and generated-header roles remain Context.
+type SDKASMDataSource struct {
+	Name                           string
+	Original, Expanded             []byte
+	OriginalObject, ExpandedObject []byte
+}
+
+type SDKASMDataObservationRequest struct {
+	PackagePath   string
+	Target        string
+	Archive       []byte
+	BuiltinSource []byte
+	Sources       []SDKASMDataSource
+	Referenced    map[string]SDKReferencedArchive
+}
+
+type ASMDataSourceObservation struct {
+	Name                           string
+	OriginalSHA256, ExpandedSHA256 string
+	OriginalObjectSHA256           string
+	ExpandedObjectSHA256           string
+	OriginalProgramSHA256          string
+	ExpandedProgramSHA256          string
+	Layouts                        []ASMGlobalLayout
+	ExpandedLayouts                []ASMGlobalLayout
+	Original, Expanded             ASMDataMember
+	TextOrder                      []ASMSourceText
+	GeneratedFuncdata              []ASMGeneratedFuncdata
+	GeneratedFloatPools            []ASMGeneratedFloatPool
+}
+
+type SDKASMDataObservation struct {
+	Protocol, PackagePath, Target string
+	ArchiveSHA256                 string
+	Members                       []ASMDataMember
+	Sources                       []ASMDataSourceObservation
+}
+
+// ObserveX86SDKASMData is intentionally separate from the existing owned and
+// SDK CPU readers. Successful offline parsing cannot mint their permissions.
+func ObserveX86SDKASMData(request SDKASMDataObservationRequest) (*SDKASMDataObservation, error) {
+	return observeX86SDKASMData(request, false)
+}
+
+// ObserveX86SDKCPPASMData observes the complete expanded grammar and checks
+// both independently assembled objects against the original compiler archive.
+// Raw bytes are retained by digest, not interpreted as an expanded program.
+// This offline adapter authenticates no CPP, SDK, header or storage role.
+func ObserveX86SDKCPPASMData(request SDKASMDataObservationRequest) (*SDKASMDataObservation, error) {
+	return observeX86SDKASMData(request, true)
+}
+
+// ObserveX86SDKASMDataListingObjects checks separately assembled listing
+// objects against an existing complete source/header-mapped object request.
+// Both use the authenticated position-mapped input. Every code byte,
+// relocation, DATA definition, object-local identity and complete debug
+// position must agree with that source's independently assembled object. This is
+// a pure observation, not source, initializer, instruction or read authority.
+func ObserveX86SDKASMDataListingObjects(request SDKASMDataObservationRequest, ordinal int, originalBytes, expandedBytes []byte) ([]TextRecord, []TextRecord, error) {
+	if ordinal < 0 || ordinal >= len(request.Sources) || len(originalBytes) == 0 || len(expandedBytes) == 0 ||
+		len(originalBytes) > archiveLimit || len(expandedBytes) > archiveLimit {
+		return nil, nil, contextError("listing objects lack a bounded selected source identity")
+	}
+	observation, err := ObserveX86SDKCPPASMData(request)
+	if err != nil {
+		return nil, nil, err
+	}
+	referenced, err := sdkReferencedArchiveSymbols(request.Referenced, request.Target)
+	if err != nil {
+		return nil, nil, err
+	}
+	original, err := observeASMDataObject(originalBytes, request.BuiltinSource, request.Target, sdkAssemblyObjectFlags(request.Target), referenced)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !reflect.DeepEqual(original, observation.Sources[ordinal].Original) {
+		return nil, nil, contextError("original listing object differs from complete authenticated source metadata")
+	}
+	expanded, err := observeASMDataObject(expandedBytes, request.BuiltinSource, request.Target, sdkAssemblyObjectFlags(request.Target), referenced)
+	if err != nil {
+		return nil, nil, err
+	}
+	if !reflect.DeepEqual(expanded, observation.Sources[ordinal].Expanded) {
+		if len(original.Definitions) == len(expanded.Definitions) {
+			for index, first := range original.Definitions {
+				second := expanded.Definitions[index]
+				first.DataOffset, second.DataOffset = 0, 0
+				if !reflect.DeepEqual(first, second) {
+					return nil, nil, contextError(fmt.Sprintf("expanded listing definition %d differs: namespace=%d name=%q kind=%d sizes=%d/%d", index, first.Namespace, first.Name, first.Kind, first.Size, second.Size))
+				}
+			}
+		}
+		return nil, nil, contextError("expanded listing object changed code/DATA/relocation/namespace")
+	}
+	return original.Texts, expanded.Texts, nil
+}
+
+func observeX86SDKASMData(request SDKASMDataObservationRequest, cpp bool) (*SDKASMDataObservation, error) {
+	if !X86SDKTarget(request.Target) || request.PackagePath == "" ||
+		strings.ContainsAny(request.PackagePath, "\x00\r\n") || len(request.PackagePath) > 4096 {
+		return nil, contextError("unobserved SDK DATA target or package identity")
+	}
+	if len(request.Sources) == 0 || len(request.Sources) > 62 {
+		return nil, contextError("SDK DATA source inventory violates the archive member bound")
+	}
+	total := int64(len(request.Archive)) + int64(len(request.BuiltinSource))
+	names := make([]string, len(request.Sources))
+	for index, source := range request.Sources {
+		if filepath.Base(source.Name) != source.Name || !strings.HasSuffix(source.Name, ".s") {
+			return nil, contextError("SDK DATA source name differs from its exact selected route")
+		}
+		for ordinal, input := range [][]byte{source.Original, source.Expanded, source.OriginalObject, source.ExpandedObject} {
+			// A real CPP execution may expand a comments-only selected ASM
+			// to empty bytes. Only the CPP adapter admits that grammar; both
+			// complete objects and the matching archive member remain required.
+			if len(input) == 0 && !(cpp && ordinal == 1) || len(input) > archiveLimit {
+				return nil, contextError("SDK DATA source/object input violates its complete byte bound")
+			}
+			total += int64(len(input))
+		}
+		names[index] = source.Name
+	}
+	for _, dependency := range request.Referenced {
+		total += int64(len(dependency.Archive))
+	}
+	if total > 64<<20 {
+		return nil, contextError("SDK DATA whole input graph exceeds its existing byte bound")
+	}
+	memberNames, err := sdkAssemblyMemberNames(names)
+	if err != nil {
+		return nil, err
+	}
+	referenced, err := sdkReferencedArchiveSymbols(request.Referenced, request.Target)
+	if err != nil {
+		return nil, err
+	}
+	members, err := archiveMembers(request.Archive)
+	if err != nil {
+		return nil, err
+	}
+	if len(members) != len(names)+2 || members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+		return nil, contextError("SDK DATA archive differs from the complete selected inventory")
+	}
+	observation := &SDKASMDataObservation{Protocol: ASMDataProtocol, PackagePath: request.PackagePath,
+		Target: request.Target, ArchiveSHA256: digest(request.Archive)}
+	if cpp {
+		observation.Protocol = ASMDataCPPProtocol
+	}
+	for ordinal, member := range members {
+		value := ASMDataMember{Name: member.name, NameBytes: []byte(member.name), Ordinal: ordinal,
+			Offset: member.offset, Size: int64(len(member.data))}
+		if ordinal != 0 {
+			flags := sdkCompilerObjectFlags(request.Target)
+			if ordinal > 1 {
+				if member.name != memberNames[ordinal-2] {
+					return nil, contextError("SDK DATA archive/source ordinal or exact byte-truncated member name differs")
+				}
+				flags |= 4
+			}
+			value, err = observeASMDataObject(member.data, request.BuiltinSource, request.Target, flags, referenced)
+			if err != nil {
+				return nil, contextError(fmt.Sprintf("SDK DATA member=%s: %v", member.name, err))
+			}
+			value.Name, value.NameBytes, value.Ordinal, value.Offset, value.Size = member.name, []byte(member.name), ordinal, member.offset, int64(len(member.data))
+			value.ObjectOffset += member.offset
+		}
+		observation.Members = append(observation.Members, value)
+	}
+	if err := validateASMDataArchiveNames(observation.Members); err != nil {
+		return nil, err
+	}
+	for index, source := range request.Sources {
+		expandedGrammar := source.Expanded
+		if cpp && len(expandedGrammar) == 0 {
+			// The lexer uses a nonempty physical stream. A newline represents
+			// zero statements; it is not substituted into retained source bytes.
+			expandedGrammar = []byte("\n")
+		}
+		originalGrammar := source.Original
+		if cpp {
+			originalGrammar = expandedGrammar
+		}
+		originalProgram, err := asmDataProgramFingerprint(originalGrammar)
+		if err != nil {
+			return nil, err
+		}
+		expandedProgram, err := asmDataProgramFingerprint(expandedGrammar)
+		if err != nil || originalProgram != expandedProgram {
+			return nil, contextError("whole original and expanded ASM token programs differ")
+		}
+		originalStates, err := parseASMDataSource(originalGrammar, request.PackagePath, request.Target)
+		if err != nil {
+			return nil, err
+		}
+		expandedStates, err := parseASMDataSource(expandedGrammar, request.PackagePath, request.Target)
+		if err != nil {
+			return nil, err
+		}
+		original, err := observeASMDataObject(source.OriginalObject, request.BuiltinSource, request.Target, sdkAssemblyObjectFlags(request.Target), referenced)
+		if err != nil {
+			return nil, contextError(fmt.Sprintf("SDK DATA original source=%s: %v", source.Name, err))
+		}
+		expanded, err := observeASMDataObject(source.ExpandedObject, request.BuiltinSource, request.Target, sdkAssemblyObjectFlags(request.Target), referenced)
+		if err != nil {
+			return nil, contextError(fmt.Sprintf("SDK DATA expanded source=%s: %v", source.Name, err))
+		}
+		textOrder, err := ASMSourceTextOrder(originalGrammar, request.PackagePath, original)
+		if err != nil {
+			return nil, err
+		}
+		expandedOrder, err := ASMSourceTextOrder(expandedGrammar, request.PackagePath, expanded)
+		if err != nil || !reflect.DeepEqual(textOrder, expandedOrder) {
+			if err == nil {
+				err = contextError("original/expanded source TEXT physical associations differ")
+			}
+			return nil, err
+		}
+		generated, err := generatedASMFuncdataWithTextOrder(originalGrammar, request.PackagePath, original, textOrder)
+		if err != nil {
+			return nil, err
+		}
+		expandedGenerated, err := generatedASMFuncdataWithTextOrder(expandedGrammar, request.PackagePath, expanded, expandedOrder)
+		if err != nil || !sameGeneratedFuncdata(generated, expandedGenerated) {
+			return nil, contextError("original/expanded generated FUNCDATA roles differ")
+		}
+		pools, err := generatedASMFloatPools(originalGrammar, request.Target, original, textOrder)
+		if err != nil {
+			return nil, err
+		}
+		expandedPools, err := generatedASMFloatPools(expandedGrammar, request.Target, expanded, expandedOrder)
+		if err != nil || !sameGeneratedFloatPools(pools, expandedPools) {
+			return nil, contextError("original/expanded generated float-pool roles differ")
+		}
+		ordinary := asmDataWithoutGeneratedFloatPools(asmDataWithoutGeneratedFuncdata(original, generated), pools)
+		layouts, err := joinASMDataLayouts(originalStates, ordinary)
+		if err != nil {
+			return nil, err
+		}
+		expandedOrdinary := asmDataWithoutGeneratedFloatPools(asmDataWithoutGeneratedFuncdata(expanded, expandedGenerated), expandedPools)
+		expandedLayouts, err := joinASMDataLayouts(expandedStates, expandedOrdinary)
+		if err != nil {
+			return nil, err
+		}
+		if !sameASMDataObjects(original, observation.Members[index+2]) || !sameASMDataObjects(original, expanded) {
+			return nil, contextError("whole original/expanded/compiler ASM DATA or TEXT object identities differ")
+		}
+		if cpp && (!reflect.DeepEqual(original.Texts, expanded.Texts) ||
+			!reflect.DeepEqual(original.Texts, observation.Members[index+2].Texts)) {
+			// A live CPP producer maps the actual source positions before
+			// assembling. Unlike the older offline token-equal observation,
+			// this role requires complete PC/filename/line metadata parity.
+			return nil, contextError("complete CPP original/expanded/compiler TEXT positions differ")
+		}
+		// Ordinals and physical source lines stay in both retained source records;
+		// compare the directive grammar separately from those original positions.
+		normalize := func(values []ASMGlobalLayout) []ASMGlobalLayout {
+			result := append([]ASMGlobalLayout(nil), values...)
+			for index := range result {
+				result[index].Ordinal, result[index].Line = 0, 0
+				result[index].Definition.DataOffset = 0
+				result[index].Fragments = append([]ASMDataFragment(nil), result[index].Fragments...)
+				for ordinal := range result[index].Fragments {
+					result[index].Fragments[ordinal].Ordinal, result[index].Fragments[ordinal].Line = 0, 0
+				}
+			}
+			return result
+		}
+		if !reflect.DeepEqual(normalize(layouts), normalize(expandedLayouts)) {
+			return nil, contextError("original and expanded DATA/GLOBL grammar differs")
+		}
+		if cpp {
+			// No raw-source grammar certificate is inferred from an expanded
+			// program or a matching machine object. CPP provenance is external
+			// to this observation-only adapter.
+			originalProgram, layouts = "", nil
+		}
+		observation.Sources = append(observation.Sources, ASMDataSourceObservation{Name: source.Name,
+			OriginalSHA256: digest(source.Original), ExpandedSHA256: digest(source.Expanded),
+			OriginalObjectSHA256: digest(source.OriginalObject), ExpandedObjectSHA256: digest(source.ExpandedObject),
+			OriginalProgramSHA256: originalProgram, ExpandedProgramSHA256: expandedProgram,
+			Layouts: layouts, ExpandedLayouts: expandedLayouts, Original: original, Expanded: expanded, TextOrder: textOrder,
+			GeneratedFuncdata: generated, GeneratedFloatPools: pools})
+	}
+	return observation, nil
+}
diff --git a/internal/gostaticstorage/assembly_data_declaration.go b/internal/gostaticstorage/assembly_data_declaration.go
new file mode 100644
index 000000000..d23d10a11
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_declaration.go
@@ -0,0 +1,58 @@
+package gostaticstorage
+
+type asmDataStorageIdentity struct {
+	name string
+	abi  uint16
+}
+
+type asmDataStorageExtent struct {
+	asmDataStorageIdentity
+	size uint32
+}
+
+func asmDataCompilerBSSDeclaration(member ASMDataMember, definition ASMDataDefinition) bool {
+	return member.Name == "_go_.o" && definition.Namespace == TextSymbolSelf &&
+		definition.ABI != 65535 && (definition.Kind == 9 || definition.Kind == 10) &&
+		definition.Flags&1 == 0 && definition.Size > 0 &&
+		len(definition.Data) == 0 && len(definition.Relocations) == 0
+}
+
+func asmDataAssemblyInitializer(member ASMDataMember, definition ASMDataDefinition) bool {
+	kind := asmDataBaseKind(definition.Kind)
+	// The enclosing SDK archive reader authenticates the exact selected member
+	// names, including their byte truncation. A suffix is not an origin proof.
+	return member.Name != "" && member.Name != "_go_.o" && member.Name != "__.PKGDEF" &&
+		definition.Namespace == TextSymbolNonpkgDefinition && definition.ABI != 65535 &&
+		definition.Flags&1 == 0 && (kind == 3 || kind == 5 || kind == 7) &&
+		definition.Size > 0 && len(definition.Data) > 0 && uint64(len(definition.Data)) <= uint64(definition.Size)
+}
+
+// Go can declare storage without an initializer and define it in ASM. The
+// linker admits this empty-BSS/content pair before diagnosing duplicate bodies.
+// Classify only the exact observed pair; neither record is rewritten/removed,
+// and no winning body, numerical bytes or storage permission is returned.
+func asmDataCompilerDeclarationPairs(members []ASMDataMember) map[asmDataStorageExtent]bool {
+	initializers := make(map[asmDataStorageExtent]bool)
+	declarations := make(map[asmDataStorageIdentity]int)
+	var candidates []asmDataStorageExtent
+	for _, member := range members {
+		for _, definition := range member.Definitions {
+			identity := asmDataStorageIdentity{definition.Name, definition.ABI}
+			extent := asmDataStorageExtent{identity, definition.Size}
+			if asmDataAssemblyInitializer(member, definition) {
+				initializers[extent] = true
+			}
+			if asmDataCompilerBSSDeclaration(member, definition) {
+				declarations[identity]++
+				candidates = append(candidates, extent)
+			}
+		}
+	}
+	result := make(map[asmDataStorageExtent]bool)
+	for _, candidate := range candidates {
+		if declarations[candidate.asmDataStorageIdentity] == 1 && initializers[candidate] {
+			result[candidate] = true
+		}
+	}
+	return result
+}
diff --git a/internal/gostaticstorage/assembly_data_declaration_test.go b/internal/gostaticstorage/assembly_data_declaration_test.go
new file mode 100644
index 000000000..7abc54dde
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_declaration_test.go
@@ -0,0 +1,108 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// This collision model supplies no storage/source certificate. The real SDK
+// factory independently observes its compiler declaration and ASM initializer.
+func asmDataDeclarationFixture() []ASMDataMember {
+	return []ASMDataMember{
+		{Name: "_go_.o", Definitions: []ASMDataDefinition{{Name: "fixture.table",
+			Namespace: TextSymbolSelf, Index: 5, Relative: 5, Kind: 10, Size: 8}}},
+		{Name: "values.o", Definitions: []ASMDataDefinition{{Name: "fixture.table",
+			Namespace: TextSymbolNonpkgDefinition, Kind: 3, Size: 8,
+			Data: []byte{0, 1, 2, 3, 4, 5, 6, 7}}}},
+	}
+}
+
+func TestASMDataCompilerBSSDeclarationAndASMInitializer(t *testing.T) {
+	t.Run("byte-truncated-ASM-member-name", func(t *testing.T) {
+		members := asmDataDeclarationFixture()
+		// The existing SDK archive protocol truncates the complete original
+		// object filename to 16 bytes, which may remove its .o suffix.
+		members[1].Name = "long-assembly-na"
+		if err := validateASMDataArchiveNames(members); err != nil {
+			t.Fatal("an exact observed SDK member needed a filename-suffix heuristic", err)
+		}
+	})
+	for _, bss := range []uint8{9, 10} {
+		for _, data := range []uint8{3, 5, 7} {
+			for _, reverse := range []bool{false, true} {
+				t.Run(fmt.Sprintf("BSS%d-DATA%d-reverse%t", bss, data, reverse), func(t *testing.T) {
+					members, before := asmDataDeclarationFixture(), asmDataDeclarationFixture()
+					for _, rows := range [][]ASMDataMember{members, before} {
+						rows[0].Definitions[0].Kind, rows[1].Definitions[0].Kind = bss, data
+						if reverse {
+							rows[0], rows[1] = rows[1], rows[0]
+						}
+					}
+					if err := validateASMDataArchiveNames(members); err != nil {
+						t.Fatal("compiler empty BSS declaration rejected a complete ASM initializer", err)
+					}
+					if !reflect.DeepEqual(members, before) {
+						t.Fatal("collision checking selected a body or normalized an original kind")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestASMDataBSSDeclarationPairDoesNotAuthorizeConflicts(t *testing.T) {
+	for _, mutation := range []string{"size", "ABI", "empty-initializer", "compiler-data", "compiler-reloc",
+		"compiler-DUPok", "initializer-DUPok", "compiler-namespace", "initializer-namespace",
+		"compiler-origin", "initializer-origin", "duplicate-declaration", "two-initializers",
+		"TEXT-initializer", "TLS-declaration", "reserved-initializer-member", "empty-initializer-member"} {
+		t.Run(mutation, func(t *testing.T) {
+			members := asmDataDeclarationFixture()
+			declaration, initializer := &members[0].Definitions[0], &members[1].Definitions[0]
+			switch mutation {
+			case "size":
+				initializer.Size++
+			case "ABI":
+				initializer.ABI = 1
+			case "empty-initializer":
+				initializer.Data = nil
+			case "compiler-data":
+				declaration.Data = []byte{1}
+			case "compiler-reloc":
+				declaration.Relocations = []TextRelocation{{Size: 8}}
+			case "compiler-DUPok":
+				declaration.Flags = 1
+			case "initializer-DUPok":
+				initializer.Flags = 1
+			case "compiler-namespace":
+				declaration.Namespace = TextSymbolNonpkgDefinition
+			case "initializer-namespace":
+				initializer.Namespace = TextSymbolSelf
+			case "compiler-origin":
+				members[0].Name = "another.o"
+			case "initializer-origin":
+				members[1].Name = "_go_.o"
+			case "reserved-initializer-member":
+				members[1].Name = "__.PKGDEF"
+			case "empty-initializer-member":
+				members[1].Name = ""
+			case "duplicate-declaration":
+				copy := *declaration
+				copy.Index, copy.Relative = 6, 6
+				members[0].Definitions = append(members[0].Definitions, copy)
+			case "two-initializers":
+				copy := members[1]
+				copy.Name = "another.o"
+				members = append(members, copy)
+			case "TEXT-initializer":
+				initializer.Kind = 1
+			case "TLS-declaration":
+				declaration.Kind = 11
+			}
+			if err := validateASMDataArchiveNames(members); !errors.Is(err, ErrContext) {
+				t.Fatal("unproved declaration/initializer pair acquired a body choice", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data_expression.go b/internal/gostaticstorage/assembly_data_expression.go
new file mode 100644
index 000000000..75b846f22
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_expression.go
@@ -0,0 +1,207 @@
+package gostaticstorage
+
+import (
+	"strconv"
+	"text/scanner"
+	"unicode/utf8"
+)
+
+const (
+	asmDataLeftShift  rune = -1000
+	asmDataRightShift rune = -1001
+)
+
+type asmDataToken struct {
+	kind rune
+	text string
+	line int
+}
+
+type asmDataExpression struct {
+	tokens []asmDataToken
+	pos    int
+	err    error
+	depth  int
+}
+
+func (p *asmDataExpression) peek() rune {
+	if p.pos >= len(p.tokens) {
+		return scanner.EOF
+	}
+	return p.tokens[p.pos].kind
+}
+
+func (p *asmDataExpression) next() asmDataToken {
+	if p.pos >= len(p.tokens) {
+		return asmDataToken{kind: scanner.EOF}
+	}
+	token := p.tokens[p.pos]
+	p.pos++
+	return token
+}
+
+func (p *asmDataExpression) fail(message string) {
+	if p.err == nil {
+		p.err = contextError(message)
+	}
+}
+
+func (p *asmDataExpression) enter() bool {
+	p.depth++
+	if p.depth > 256 {
+		p.fail("DATA expression nesting exceeds its observation bound")
+		return false
+	}
+	return true
+}
+
+// These are Go assembler uint64 expression rules, not Go constant folding.
+// In particular left shift consumes one factor and returns its term, whereas
+// right shift consumes a term on the right. Preserve those actual parser rules.
+func (p *asmDataExpression) integer() uint64 {
+	value := p.term()
+	for p.err == nil {
+		switch p.peek() {
+		case '+':
+			p.next()
+			value += p.term()
+		case '-':
+			p.next()
+			value -= p.term()
+		case '|':
+			p.next()
+			value |= p.term()
+		case '^':
+			p.next()
+			value ^= p.term()
+		default:
+			return value
+		}
+	}
+	return 0
+}
+
+func (p *asmDataExpression) term() uint64 {
+	if !p.enter() {
+		return 0
+	}
+	defer func() { p.depth-- }()
+	value := p.factor()
+	for p.err == nil {
+		switch p.peek() {
+		case '*':
+			p.next()
+			value *= p.factor()
+		case '/', '%':
+			operator := p.next().kind
+			divisor := p.factor()
+			if int64(value) < 0 || divisor == 0 {
+				p.fail("DATA division/modulo has a high-bit dividend or zero divisor")
+				return 0
+			}
+			if operator == '/' {
+				value /= divisor
+			} else {
+				value %= divisor
+			}
+		case asmDataLeftShift:
+			p.next()
+			shift := p.factor()
+			if int64(shift) < 0 {
+				p.fail("DATA left shift has a negative count")
+				return 0
+			}
+			return value << shift
+		case asmDataRightShift:
+			p.next()
+			shift := p.term()
+			if int64(shift) < 0 || int64(value) < 0 {
+				p.fail("DATA right shift has a negative count or high-bit value")
+				return 0
+			}
+			value >>= shift
+		case '&':
+			p.next()
+			value &= p.factor()
+		default:
+			return value
+		}
+	}
+	return 0
+}
+
+func (p *asmDataExpression) factor() uint64 {
+	if !p.enter() {
+		return 0
+	}
+	defer func() { p.depth-- }()
+	token := p.next()
+	switch token.kind {
+	case scanner.Int:
+		value, err := strconv.ParseUint(token.text, 0, 64)
+		if err != nil {
+			p.fail("invalid DATA integer token")
+		}
+		return value
+	case scanner.Char:
+		text, err := strconv.Unquote(token.text)
+		value, size := utf8.DecodeRuneInString(text)
+		if err != nil || size == 1 && value == utf8.RuneError {
+			p.fail("invalid DATA character token")
+		}
+		return uint64(value)
+	case '+':
+		return p.factor()
+	case '-':
+		return -p.factor()
+	case '~':
+		return ^p.factor()
+	case '(':
+		value := p.integer()
+		if p.next().kind != ')' {
+			p.fail("unclosed DATA integer expression")
+		}
+		return value
+	default:
+		p.fail("DATA value is not an integer expression")
+		return 0
+	}
+}
+
+func (p *asmDataExpression) floating() float64 {
+	if !p.enter() {
+		return 0
+	}
+	defer func() { p.depth-- }()
+	token := p.next()
+	switch token.kind {
+	case scanner.Float:
+		value, err := strconv.ParseFloat(token.text, 64)
+		if err != nil {
+			p.fail("invalid or out-of-range DATA float token")
+		}
+		return value
+	case '+':
+		return p.floating()
+	case '-':
+		return -p.floating()
+	case '(':
+		value := p.floating()
+		if p.next().kind != ')' {
+			p.fail("unclosed DATA float expression")
+		}
+		return value
+	default:
+		p.fail("DATA float grammar admits only a float token, signs and parentheses")
+		return 0
+	}
+}
+
+func asmDataInteger(tokens []asmDataToken) (uint64, error) {
+	p := &asmDataExpression{tokens: tokens}
+	value := p.integer()
+	if p.pos != len(tokens) {
+		p.fail("unconsumed DATA integer expression")
+	}
+	return value, p.err
+}
diff --git a/internal/gostaticstorage/assembly_data_go127_test.go b/internal/gostaticstorage/assembly_data_go127_test.go
new file mode 100644
index 000000000..0b559b419
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_go127_test.go
@@ -0,0 +1,300 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This independently compiled SDK reader preserves every object-local DATA
+// identity, exact data interval and ordered relocation. It does not call our
+// parser, combine definitions by name, or infer initialized storage authority.
+const sdkASMDataReaderSource = `package main
+
+import (
+	"cmd/internal/archive"
+	"cmd/internal/goobj"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type Reference struct {
+	PackageIndex, SymbolIndex uint32
+	Package, Name string
+	ABI uint16
+	ABIKnown bool
+	Kind uint8
+	KindKnown bool
+}
+type Relocation struct {
+	Offset, Size int64
+	Type uint16
+	Add int64
+	Target Reference
+}
+type Definition struct {
+	Namespace int
+	Relative, Index uint32
+	Name string
+	ABI uint16
+	Kind, Flags, Flags2 uint8
+	Size, Align uint32
+	Hash []byte
+	DataOffset uint32
+	Data []byte
+	Relocations []Relocation
+}
+type Member struct {
+	Name string
+	NameBytes []byte
+	Ordinal int
+	Offset, Size int64
+	ObjectOffset int64
+	Flags uint32
+	Definitions []Definition
+}
+
+func main() {
+	f, err := os.Open(os.Args[1])
+	if err != nil { panic(err) }
+	defer f.Close()
+	a, err := archive.Parse(f, false)
+	if err != nil { panic(err) }
+	var members []Member
+	for ordinal, entry := range a.Entries {
+		member := Member{Name: entry.Name, NameBytes: []byte(entry.Name), Ordinal: ordinal,
+			Offset: entry.Offset, Size: entry.Size}
+		if entry.Type != archive.EntryPkgDef && entry.Type != archive.EntryGoObj {
+			panic("unexpected original archive member")
+		}
+		if entry.Type == archive.EntryGoObj {
+			member.ObjectOffset = entry.Obj.Offset
+			data := make([]byte, entry.Obj.Size)
+			n, err := f.ReadAt(data, entry.Obj.Offset)
+			if err != nil || n != len(data) { panic(fmt.Sprint(n, err)) }
+			r := goobj.NewReaderFromBytes(data, false)
+			if r == nil { panic("invalid original goobj") }
+			member.Flags = r.Flags()
+			counts := [5]int{r.NSym(), r.NHashed64def(), r.NHasheddef(), r.NNonpkgdef(), r.NNonpkgref()}
+			resolve := func(ref goobj.SymRef) Reference {
+				v := Reference{PackageIndex: ref.PkgIdx, SymbolIndex: ref.SymIdx}
+				var index uint32
+				switch ref.PkgIdx {
+				case goobj.PkgIdxSelf:
+					index = ref.SymIdx
+				case goobj.PkgIdxHashed64:
+					index = uint32(counts[0]) + ref.SymIdx
+				case goobj.PkgIdxHashed:
+					index = uint32(counts[0] + counts[1]) + ref.SymIdx
+				case goobj.PkgIdxNone:
+					index = uint32(counts[0] + counts[1] + counts[2]) + ref.SymIdx
+				default:
+					panic("fixture unexpectedly acquired a foreign DATA relocation")
+				}
+				s := r.Sym(index)
+				v.Name, v.ABI, v.ABIKnown = s.Name(r), s.ABI(), true
+				return v
+			}
+			var index uint32
+			for namespace, count := range counts {
+				for relative := 0; relative < count; relative++ {
+					s := r.Sym(index)
+					if namespace != 4 && s.Type() != 1 && s.Type() != 2 {
+						definition := Definition{Namespace: namespace, Relative: uint32(relative), Index: index,
+							Name: s.Name(r), ABI: s.ABI(), Kind: s.Type(), Flags: s.Flag(), Flags2: s.Flag2(),
+							Size: s.Siz(), Align: s.Align(), DataOffset: r.DataOff(index), Data: r.Data(index)}
+						if namespace == 1 {
+							hash := r.Hash64(uint32(relative))
+							definition.Hash = make([]byte, 8)
+							for byteIndex := range definition.Hash { definition.Hash[byteIndex] = byte(hash >> (8 * byteIndex)) }
+						}
+						if namespace == 2 { definition.Hash = append([]byte(nil), r.Hash(uint32(relative))[:]...) }
+						for j := 0; j < r.NReloc(index); j++ {
+							q := r.Reloc(index, j)
+							definition.Relocations = append(definition.Relocations, Relocation{
+								Offset: int64(q.Off()), Size: int64(q.Siz()), Type: q.Type(), Add: q.Add(), Target: resolve(q.Sym())})
+						}
+						member.Definitions = append(member.Definitions, definition)
+					}
+					index++
+				}
+			}
+		}
+		members = append(members, member)
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(members); err != nil { panic(err) }
+}
+`
+
+const asmDataIndependentGlobals = 512
+
+func asmDataFixtureSource(arch string) string {
+	width := 8
+	if arch == "386" {
+		width = 4
+	}
+	source := fmt.Sprintf(`TEXT ·Entry(SB),4,$0-0
+RET
+DATA integers<>+0(SB)/1,$-1
+DATA integers<>+1(SB)/2,$0x12345
+DATA integers<>+3(SB)/4,$(1<<32)+7
+DATA integers<>+7(SB)/8,$~0
+GLOBL integers<>(SB),8,$24
+DATA floats<>+0(SB)/4,$1.25
+DATA floats<>+4(SB)/8,$-(3.5)
+GLOBL floats<>(SB),8,$20
+DATA strings<>+0(SB)/8,$"A\x00B"
+DATA strings<>+8(SB)/0,$""
+GLOBL strings<>(SB),8,$16
+DATA sparse<>+2(SB)/1,$'世'
+DATA sparse<>+6(SB)/2,$17/3
+GLOBL sparse<>(SB),8,$20
+DATA pointers<>+0(SB)/%d,$anchor<>+1(SB)
+GLOBL pointers<>(SB),$%d
+GLOBL anchor<>(SB),16,$8
+GLOBL mutable<>(SB),$32
+GLOBL tls<>(SB),256,$%d
+DATA shortened<>+10(SB)/8,$0x0102030405060708
+GLOBL shortened<>(SB),8,$1
+DATA shared+0(SB)/1,$7
+GLOBL shared(SB),2|8,$1
+`, width, width, width)
+	for index, test := range asmDataGrammarCases {
+		source += fmt.Sprintf("DATA complete_%d<>+0(SB)/%d,$%s\nGLOBL complete_%d<>(SB),8,$16\n", index, test.width, test.value, index)
+	}
+	source += "GLOBL before<>(SB),16,$1\nDATA before<>+2(SB)/4,$7\n"
+	source += "DATA noptr<>(SB)/1,$7\nGLOBL noptr<>(SB),16,$1\n"
+	source += "DATA priority<>(SB)/1,$7\nGLOBL priority<>(SB),8|16|256,$1\n"
+	source += "DATA ignored<>(SB)/1,$7\nGLOBL ignored<>(SB),1|4|32|64|512|1024|2048|4096,$1\n"
+	source += "DATA ·Visible(SB)/1,$7\nGLOBL ·Visible(SB),8,$1\n"
+	source += fmt.Sprintf("DATA addresses<>+0(SB)/%d,$anchor<>-1(SB)\n", width)
+	source += fmt.Sprintf("DATA addresses<>+%d(SB)/%d,$·Visible+(1+2)(SB)\n", width, width)
+	source += fmt.Sprintf("DATA addresses<>+%d(SB)/%d,$foreign∕pkg·Symbol+5(SB)\n", width*2, width)
+	source += fmt.Sprintf("GLOBL addresses<>(SB),$%d\n", width*3)
+	for index := 0; index < asmDataIndependentGlobals; index++ {
+		source += fmt.Sprintf("DATA independent_%d<>(SB)/1,$%d\nGLOBL independent_%d<>(SB),8,$1\n",
+			index, index&255, index)
+	}
+	return source
+}
+
+func TestGoSDKASMDataFirstParty(t *testing.T) {
+	directory, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkASMDataReaderSource)
+	textOracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			consumer := filepath.Join(directory, "datafixture."+arch)
+			if err := os.Mkdir(consumer, 0700); err != nil {
+				t.Fatal(err)
+			}
+			goSource := "package datafixture\nfunc Entry()\n"
+			assembly := asmDataFixtureSource(arch)
+			second := "DATA shared+0(SB)/1,$7\nGLOBL shared(SB),2|8,$1\nDATA integers<>+0(SB)/1,$9\nGLOBL integers<>(SB),8,$1\n"
+			for name, data := range map[string]string{"data.go": goSource, "data.s": assembly, "second.s": second} {
+				if err := os.WriteFile(filepath.Join(consumer, name), []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			selection := run(t, binary, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				ImportPath, Export string
+				SFiles             []string
+				Standard           bool
+			}
+			if err := json.Unmarshal(selection, &selected); err != nil || selected.Standard ||
+				!reflect.DeepEqual(selected.SFiles, []string{"data.s", "second.s"}) {
+				t.Fatal("actual first-party source inventory differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, consumer, env, selected.Export)
+			textRaw := run(t, textOracle, consumer, env, selected.Export)
+			var original []ASMDataMember
+			var originalTexts []TextMember
+			if err := json.Unmarshal(raw, &original); err != nil || len(original) != 4 {
+				t.Fatal("independent original DATA inventory differs", err)
+			}
+			if err := json.Unmarshal(textRaw, &originalTexts); err != nil || len(originalTexts) != 4 {
+				t.Fatal("independent original whole TEXT inventory differs", err)
+			}
+			request := SDKASMDataObservationRequest{PackagePath: selected.ImportPath, Target: target, Archive: archive, BuiltinSource: builtin}
+			artifacts := map[string][]byte{"original.a": archive, "selection.json": selection,
+				"data-sdk.json": raw, "text-sdk.json": textRaw, "source-data.go": []byte(goSource)}
+			for index, name := range selected.SFiles {
+				source, err := os.ReadFile(filepath.Join(consumer, name))
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Keep actual physical source lines stable for the initial whole
+				// object join. Distinct raw spacing is still retained and hashed.
+				expanded := []byte(strings.ReplaceAll(string(source), ",", ", "))
+				expandedName := fmt.Sprintf("expanded-%d.asm", index)
+				if err := os.WriteFile(filepath.Join(consumer, expandedName), expanded, 0600); err != nil {
+					t.Fatal(err)
+				}
+				input := SDKASMDataSource{Name: name, Original: source, Expanded: expanded}
+				for role, sourceName := range map[string]string{"original": name, "expanded": expandedName} {
+					objectName := fmt.Sprintf("%s-%d.o", role, index)
+					run(t, binary, consumer, env, "tool", "asm", "-std", "-p", selected.ImportPath, "-o", objectName, sourceName)
+					object, err := os.ReadFile(filepath.Join(consumer, objectName))
+					if err != nil {
+						t.Fatal(err)
+					}
+					if role == "original" {
+						input.OriginalObject = object
+					} else {
+						input.ExpandedObject = object
+					}
+					artifacts[objectName] = object
+					artifacts[objectName+".sdk.json"] = run(t, oracle, consumer, env, objectName)
+				}
+				artifacts["source-"+name] = source
+				artifacts[expandedName] = expanded
+				request.Sources = append(request.Sources, input)
+			}
+			retainTextArtifact(t, target, "asm-data-first-party", artifacts)
+			observation, err := ObserveX86SDKASMData(request)
+			if err != nil || observation == nil {
+				t.Fatal("typed DATA source/object observation rejected actual Go input", err)
+			}
+			if observation.Protocol != ASMDataProtocol || observation.Target != target || observation.PackagePath != selected.ImportPath || len(observation.Sources) != 2 {
+				t.Fatal("whole source/member observation lost its metadata boundary")
+			}
+			for index := range original {
+				original[index].Texts = originalTexts[index].Texts
+			}
+			observedJSON, err := json.MarshalIndent(observation, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			retainTextArtifact(t, target, "asm-data-first-party", map[string][]byte{"observation.json": observedJSON})
+			if !reflect.DeepEqual(observation.Members, original) {
+				t.Fatal("complete namespace/index/data/relocation/TEXT observation differs from actual SDK")
+			}
+			if len(observation.Sources[0].Layouts) != 16+len(asmDataGrammarCases)+asmDataIndependentGlobals || len(observation.Sources[1].Layouts) != 2 {
+				t.Fatal("typed DATA/GLOBL grammar lost source declarations")
+			}
+			if _, err := ObserveX86SDKAssemblyArchive(archive, builtin, target, selected.SFiles); err == nil || !strings.Contains(err.Error(), "assembly DATA definition") {
+				t.Fatal("offline DATA observation widened the unchanged SDK TEXT permission", err)
+			}
+			t.Run("input-guards", func(t *testing.T) { checkASMDataInputGuards(t, request) })
+			t.Run("binary-guards", func(t *testing.T) { checkASMDataBinaryGuards(t, request) })
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data_guards_go127_test.go b/internal/gostaticstorage/assembly_data_guards_go127_test.go
new file mode 100644
index 000000000..bac34c936
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_guards_go127_test.go
@@ -0,0 +1,234 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"math"
+	"strings"
+	"testing"
+)
+
+func cloneASMDataRequest(t *testing.T, request SDKASMDataObservationRequest) SDKASMDataObservationRequest {
+	t.Helper()
+	encoded, err := json.Marshal(request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result SDKASMDataObservationRequest
+	if err := json.Unmarshal(encoded, &result); err != nil {
+		t.Fatal(err)
+	}
+	return result
+}
+
+// These controls consume the exact objects made by the positive fixture, not
+// synthetic object JSON. The returned observations have no live owner to copy,
+// close or revoke; neither mutations nor a pass can create such authority.
+func checkASMDataInputGuards(t *testing.T, original SDKASMDataObservationRequest) {
+	t.Helper()
+	for name, mutate := range map[string]func(*SDKASMDataObservationRequest){
+		"non-DUPok-named-storage": func(r *SDKASMDataObservationRequest) {
+			clearFlag := func(data []byte) {
+				body, err := objectBody(data, r.Target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				view, err := checkedObject(body, 20, true)
+				if err != nil {
+					t.Fatal(err)
+				}
+				symbols, err := view.indexedSymbols()
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, symbol := range symbols {
+					if symbol.Name == "shared" {
+						offset := int(binary.LittleEndian.Uint32(body[20+4*3:])) + int(symbol.Index)*21 + 11
+						body[offset] &^= 1
+					}
+				}
+			}
+			members, err := archiveMembers(r.Archive)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, member := range members[2:] {
+				clearFlag(member.data)
+			}
+			for index := range r.Sources {
+				clearFlag(r.Sources[index].OriginalObject)
+				clearFlag(r.Sources[index].ExpandedObject)
+				for _, slot := range []*[]byte{&r.Sources[index].Original, &r.Sources[index].Expanded} {
+					*slot = bytes.ReplaceAll(*slot, []byte("2|8"), []byte("8"))
+				}
+			}
+		},
+		"missing-source":          func(r *SDKASMDataObservationRequest) { r.Sources = r.Sources[:1] },
+		"empty-sources":           func(r *SDKASMDataObservationRequest) { r.Sources = nil },
+		"extra-source":            func(r *SDKASMDataObservationRequest) { r.Sources = append(r.Sources, r.Sources[0]) },
+		"reordered-sources":       func(r *SDKASMDataObservationRequest) { r.Sources[0], r.Sources[1] = r.Sources[1], r.Sources[0] },
+		"source-name":             func(r *SDKASMDataObservationRequest) { r.Sources[0].Name = "foreign.s" },
+		"source-directory":        func(r *SDKASMDataObservationRequest) { r.Sources[0].Name = "nested/data.s" },
+		"source-extension":        func(r *SDKASMDataObservationRequest) { r.Sources[0].Name = "data.asm" },
+		"missing-original":        func(r *SDKASMDataObservationRequest) { r.Sources[0].Original = nil },
+		"missing-expanded":        func(r *SDKASMDataObservationRequest) { r.Sources[0].Expanded = nil },
+		"missing-original-object": func(r *SDKASMDataObservationRequest) { r.Sources[0].OriginalObject = nil },
+		"missing-expanded-object": func(r *SDKASMDataObservationRequest) { r.Sources[0].ExpandedObject = nil },
+		"foreign-original-object": func(r *SDKASMDataObservationRequest) { r.Sources[0].OriginalObject = r.Sources[1].OriginalObject },
+		"foreign-expanded-object": func(r *SDKASMDataObservationRequest) { r.Sources[0].ExpandedObject = r.Sources[1].ExpandedObject },
+		"original-program": func(r *SDKASMDataObservationRequest) {
+			r.Sources[0].Original = bytes.Replace(r.Sources[0].Original, []byte("RET"), []byte("NOP"), 1)
+		},
+		"expanded-program": func(r *SDKASMDataObservationRequest) {
+			r.Sources[0].Expanded = bytes.Replace(r.Sources[0].Expanded, []byte("RET"), []byte("NOP"), 1)
+		},
+		"wrong-package":      func(r *SDKASMDataObservationRequest) { r.PackagePath += "/foreign" },
+		"empty-package":      func(r *SDKASMDataObservationRequest) { r.PackagePath = "" },
+		"wrong-target":       func(r *SDKASMDataObservationRequest) { r.Target = "linux/arm64" },
+		"missing-builtin":    func(r *SDKASMDataObservationRequest) { r.BuiltinSource = nil },
+		"edited-builtin":     func(r *SDKASMDataObservationRequest) { r.BuiltinSource[0] ^= 1 },
+		"archive-tail":       func(r *SDKASMDataObservationRequest) { r.Archive = append(r.Archive, 0) },
+		"archive-truncation": func(r *SDKASMDataObservationRequest) { r.Archive = r.Archive[:len(r.Archive)-1] },
+		"source-NUL":         func(r *SDKASMDataObservationRequest) { r.Sources[0].Original = append(r.Sources[0].Original, 0) },
+		"unknown-header-role": func(r *SDKASMDataObservationRequest) {
+			r.Sources[0].Original = append([]byte("#include \"go_asm.h\"\n"), r.Sources[0].Original...)
+		},
+		"raw-data-value": func(r *SDKASMDataObservationRequest) {
+			for _, slot := range []*[]byte{&r.Sources[0].Original, &r.Sources[0].Expanded} {
+				*slot = bytes.Replace(*slot, []byte("0x12345"), []byte("0x12346"), 1)
+			}
+		},
+		"raw-global-size": func(r *SDKASMDataObservationRequest) {
+			for _, slot := range []*[]byte{&r.Sources[0].Original, &r.Sources[0].Expanded} {
+				*slot = bytes.Replace(*slot, []byte("$24"), []byte("$25"), 1)
+			}
+		},
+		"raw-missing-layout": func(r *SDKASMDataObservationRequest) {
+			for _, slot := range []*[]byte{&r.Sources[0].Original, &r.Sources[0].Expanded} {
+				lines := strings.Split(string(*slot), "\n")
+				var kept []string
+				for _, line := range lines {
+					if !strings.Contains(line, "mutable<>") {
+						kept = append(kept, line)
+					}
+				}
+				*slot = []byte(strings.Join(kept, "\n"))
+			}
+		},
+		"raw-extra-layout": func(r *SDKASMDataObservationRequest) {
+			for _, slot := range []*[]byte{&r.Sources[0].Original, &r.Sources[0].Expanded} {
+				*slot = append(*slot, []byte("GLOBL foreign<>(SB),8,$1\n")...)
+			}
+		},
+		"raw-reordered-globals": func(r *SDKASMDataObservationRequest) {
+			for _, slot := range []*[]byte{&r.Sources[0].Original, &r.Sources[0].Expanded} {
+				lines := strings.Split(string(*slot), "\n")
+				first, second := -1, -1
+				for index, line := range lines {
+					if strings.HasPrefix(line, "GLOBL integers<>") {
+						first = index
+					} else if strings.HasPrefix(line, "GLOBL floats<>") {
+						second = index
+					}
+				}
+				if first < 0 || second < 0 {
+					t.Fatal("actual GLOBL order witness is missing")
+				}
+				lines[first], lines[second] = lines[second], lines[first]
+				*slot = []byte(strings.Join(lines, "\n"))
+			}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneASMDataRequest(t, original)
+			mutate(&changed)
+			if observation, err := ObserveX86SDKASMData(changed); !errors.Is(err, ErrContext) || observation != nil {
+				t.Fatal("changed complete source/object input acquired an observation", err)
+			}
+		})
+	}
+}
+
+func checkASMDataBinaryGuards(t *testing.T, original SDKASMDataObservationRequest) {
+	t.Helper()
+	body, err := objectBody(original.Sources[0].OriginalObject, original.Target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	view, err := checkedObject(body, 20, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	symbols, err := view.indexedSymbols()
+	if err != nil {
+		t.Fatal(err)
+	}
+	var integers, pointers, anonymous, text uint32
+	found := make(map[string]bool)
+	for _, symbol := range symbols {
+		switch {
+		case symbol.Name == "integers":
+			integers, found["integer"] = symbol.Index, true
+		case symbol.Name == "pointers":
+			pointers, found["pointer"] = symbol.Index, true
+		case symbol.Name == "" && symbol.Kind == 7 && !found["anonymous"]:
+			anonymous, found["anonymous"] = symbol.Index, true
+		case symbol.Kind == 1:
+			text, found["text"] = symbol.Index, true
+		}
+	}
+	if len(found) != 4 || len(view.block(10)) == 0 {
+		t.Fatal("actual DATA binary guard witnesses are incomplete", found)
+	}
+	blockOffset := func(block int) int { return int(binary.LittleEndian.Uint32(body[20+block*4:])) }
+	symbolOffset := func(index uint32) int { return blockOffset(3) + int(index)*21 }
+	dataOffset := func(index uint32) int { return blockOffset(16) + int(view.indices[2][index]) }
+	relocation := blockOffset(14) + int(view.indices[0][pointers])*23
+	for name, mutate := range map[string]func([]byte){
+		"owned-flags":          func(b []byte) { binary.LittleEndian.PutUint32(b[16:], 4) },
+		"compiler-flags":       func(b []byte) { binary.LittleEndian.PutUint32(b[16:], 16) },
+		"unknown-flags":        func(b []byte) { binary.LittleEndian.PutUint32(b[16:], 20|2) },
+		"unknown-kind":         func(b []byte) { b[symbolOffset(integers)+10] = 255 },
+		"DATA-size":            func(b []byte) { b[symbolOffset(integers)+13]++ },
+		"DATA-alignment":       func(b []byte) { b[symbolOffset(integers)+17]++ },
+		"DATA-ABI":             func(b []byte) { b[symbolOffset(integers)+8]++ },
+		"DATA-flags":           func(b []byte) { b[symbolOffset(integers)+11] ^= 1 },
+		"DATA-byte":            func(b []byte) { b[dataOffset(integers)] ^= 1 },
+		"anonymous-DATA-byte":  func(b []byte) { b[dataOffset(anonymous)] ^= 1 },
+		"whole-TEXT-byte":      func(b []byte) { b[dataOffset(text)] ^= 1 },
+		"content-hash":         func(b []byte) { b[blockOffset(10)] ^= 1 },
+		"DATA-string-overflow": func(b []byte) { binary.LittleEndian.PutUint32(b[symbolOffset(integers)+4:], math.MaxUint32) },
+		"DATA-index-overflow":  func(b []byte) { binary.LittleEndian.PutUint32(b[blockOffset(13)+int(integers)*4:], math.MaxUint32) },
+		"DATA-index-tail": func(b []byte) {
+			binary.LittleEndian.PutUint32(b[blockOffset(13)+view.count*4:], uint32(len(view.block(16))-1))
+		},
+		"relocation-offset":     func(b []byte) { b[relocation]++ },
+		"relocation-negative":   func(b []byte) { binary.LittleEndian.PutUint32(b[relocation:], math.MaxUint32) },
+		"relocation-width":      func(b []byte) { b[relocation+4]++ },
+		"relocation-type":       func(b []byte) { binary.LittleEndian.PutUint16(b[relocation+5:], 2) },
+		"relocation-addend":     func(b []byte) { b[relocation+7]++ },
+		"relocation-target":     func(b []byte) { b[relocation+19]++ },
+		"relocation-overflow":   func(b []byte) { binary.LittleEndian.PutUint32(b[relocation+19:], math.MaxUint32) },
+		"relocation-namespace":  func(b []byte) { binary.LittleEndian.PutUint32(b[relocation+15:], 2147483645) },
+		"relocation-invalidnil": func(b []byte) { binary.LittleEndian.PutUint32(b[relocation+15:], 0) },
+		"hash-count":            func(b []byte) { binary.LittleEndian.PutUint32(b[20+11*4:], uint32(blockOffset(11)-16)) },
+		"namespace-crossover":   func(b []byte) { binary.LittleEndian.PutUint32(b[20+4*4:], uint32(blockOffset(4)-21)) },
+		"object-EOF":            func(b []byte) { binary.LittleEndian.PutUint32(b[20+18*4:], uint32(len(b)-1)) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneASMDataRequest(t, original)
+			changedBody, err := objectBody(changed.Sources[0].OriginalObject, changed.Target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutate(changedBody)
+			if observation, err := ObserveX86SDKASMData(changed); !errors.Is(err, ErrContext) || observation != nil {
+				t.Fatal("changed actual object acquired DATA identity/whole-body agreement", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data_index_test.go b/internal/gostaticstorage/assembly_data_index_test.go
new file mode 100644
index 000000000..6b56ffa20
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_index_test.go
@@ -0,0 +1,210 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This model exercises candidate selection and collision rules only. The
+// actual Go archives in TestGoSDKASMDataFirstParty establish binary provenance.
+func asmDataIndexedFixture(count int) ([]asmDataLayoutState, ASMDataMember) {
+	states := make([]asmDataLayoutState, count)
+	member := ASMDataMember{Definitions: make([]ASMDataDefinition, count)}
+	for index := range states {
+		name := fmt.Sprintf("global%d", index)
+		data := []byte{byte(index)}
+		states[index] = asmDataLayoutState{layout: ASMGlobalLayout{Name: name},
+			global: true, kind: 3, actualSize: 1, data: data}
+		member.Definitions[index] = ASMDataDefinition{Namespace: TextSymbolNonpkgDefinition,
+			Relative: uint32(index), Index: uint32(index), Name: name, Kind: 3, Size: 1, Data: data}
+	}
+	return states, member
+}
+
+func TestASMDataIndexedCandidateIdentity(t *testing.T) {
+	states, member := asmDataIndexedFixture(16384)
+	layouts, err := joinASMDataLayouts(states, member)
+	if err != nil || len(layouts) != len(states) {
+		t.Fatal("complete independent global inventory did not join", err)
+	}
+	for index, layout := range layouts {
+		if layout.Definition.Index != uint32(index) || layout.Definition.Relative != uint32(index) {
+			t.Fatal("candidate index selected a different object-local identity", index)
+		}
+	}
+	for name, mutate := range map[string]func(*ASMDataMember){
+		"same-body-different-namespace": func(m *ASMDataMember) {
+			copy := m.Definitions[0]
+			copy.Namespace, copy.Index = TextSymbolSelf, uint32(len(m.Definitions))
+			m.Definitions = append(m.Definitions, copy)
+		},
+		"same-body-same-namespace": func(m *ASMDataMember) {
+			copy := m.Definitions[0]
+			copy.Relative, copy.Index = uint32(len(m.Definitions)), uint32(len(m.Definitions))
+			m.Definitions = append(m.Definitions, copy)
+		},
+		"different-kind-candidate": func(m *ASMDataMember) {
+			copy := m.Definitions[0]
+			copy.Kind, copy.Index = 9, uint32(len(m.Definitions))
+			m.Definitions = append(m.Definitions, copy)
+		},
+		"wrong-ABI":                func(m *ASMDataMember) { m.Definitions[0].ABI = 1 },
+		"missing-definition":       func(m *ASMDataMember) { m.Definitions = m.Definitions[1:] },
+		"reused-combined-index":    func(m *ASMDataMember) { m.Definitions[1].Index = 0 },
+		"reordered-relative-index": func(m *ASMDataMember) { m.Definitions[1].Relative = 0 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			states, member := asmDataIndexedFixture(8)
+			mutate(&member)
+			if _, err := joinASMDataLayouts(states, member); !errors.Is(err, ErrContext) {
+				t.Fatal("candidate membership became body-selection authority", err)
+			}
+		})
+	}
+}
+
+func TestASMDataNamedCollisionGroups(t *testing.T) {
+	definition := func(name string, abi uint16, kind, flags uint8) ASMDataDefinition {
+		return ASMDataDefinition{Name: name, ABI: abi, Namespace: TextSymbolSelf, Kind: kind, Flags: flags}
+	}
+	text := func(abi uint16, flags uint8) TextRecord {
+		return TextRecord{Name: "entry", ABI: abi, Namespace: TextSymbolSelf, Kind: 1, Flags: flags}
+	}
+	for _, test := range []struct {
+		name    string
+		members []ASMDataMember
+		valid   bool
+	}{
+		{"all-DUPok", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}}}, true},
+		{"one-non-DUPok", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 3, 0)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}}}, true},
+		{"two-non-DUPok", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("value", 0, 3, 0)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 3, 0)}}}, false},
+		{"same-member-DUPok", []ASMDataMember{{Definitions: []ASMDataDefinition{
+			definition("value", 0, 3, 1), definition("value", 0, 3, 1)}}}, false},
+		{"storage-ABI", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}},
+			{Definitions: []ASMDataDefinition{definition("value", 1, 3, 1)}}}, false},
+		{"storage-kind", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("value", 0, 3, 1)}},
+			{Definitions: []ASMDataDefinition{definition("value", 0, 9, 1)}}}, false},
+		{"TEXT-storage-kind", []ASMDataMember{{Definitions: []ASMDataDefinition{definition("entry", 0, 3, 1)}},
+			{Texts: []TextRecord{text(0, 1)}}}, false},
+		{"TEXT-distinct-ABI", []ASMDataMember{{Texts: []TextRecord{text(0, 0), text(1, 0)}}}, true},
+		{"TEXT-same-ABI-non-DUPok", []ASMDataMember{{Texts: []TextRecord{text(0, 0)}},
+			{Texts: []TextRecord{text(0, 0)}}}, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			err := validateASMDataArchiveNames(test.members)
+			if test.valid && err != nil || !test.valid && !errors.Is(err, ErrContext) {
+				t.Fatal("complete named collision class differs", err)
+			}
+		})
+	}
+}
+
+// Nonpackage DUPok definitions may occur several times in one Go compiler
+// member. This validates collision classes, not a linked winning body or source
+// role; the actual SDK runtime factory independently exercises the real archive.
+func TestASMDataSameMemberNonpkgDUPokKeepsIndexedIdentities(t *testing.T) {
+	fixture := func() []ASMDataMember {
+		return []ASMDataMember{{Definitions: []ASMDataDefinition{
+			{Name: "fixture.funcval", Namespace: TextSymbolNonpkgDefinition, Index: 10,
+				Relative: 0, Kind: 3, Flags: 1, Size: 8, Data: []byte{1}},
+			{Name: "fixture.funcval", Namespace: TextSymbolNonpkgDefinition, Index: 11,
+				Relative: 1, Kind: 3, Flags: 1, Size: 8, Data: []byte{2}},
+		}}}
+	}
+	for _, mutation := range []string{"none", "third-index", "duplicate-index", "duplicate-relative", "self", "mixed-namespace",
+		"one-non-DUPok", "non-DUPok-first", "two-non-DUPok", "kind", "ABI"} {
+		t.Run(mutation, func(t *testing.T) {
+			members := fixture()
+			definitions := members[0].Definitions
+			switch mutation {
+			case "third-index":
+				third := definitions[1]
+				third.Index, third.Relative = 12, 2
+				members[0].Definitions = append(definitions, third)
+			case "duplicate-index":
+				definitions[1].Index = definitions[0].Index
+			case "duplicate-relative":
+				definitions[1].Relative = definitions[0].Relative
+			case "self":
+				definitions[0].Namespace, definitions[1].Namespace = TextSymbolSelf, TextSymbolSelf
+			case "mixed-namespace":
+				definitions[1].Namespace = TextSymbolSelf
+			case "one-non-DUPok":
+				definitions[1].Flags = 0
+			case "non-DUPok-first":
+				definitions[0].Flags = 0
+			case "two-non-DUPok":
+				definitions[0].Flags, definitions[1].Flags = 0, 0
+			case "kind":
+				definitions[1].Kind = 7
+			case "ABI":
+				definitions[1].ABI = 1
+			}
+			before := fmt.Sprintf("%#v", members)
+			err := validateASMDataArchiveNames(members)
+			valid := mutation == "none" || mutation == "third-index" || mutation == "one-non-DUPok" || mutation == "non-DUPok-first"
+			if valid && err != nil || !valid && !errors.Is(err, ErrContext) {
+				t.Fatal("original nonpackage DUPok/index collision class differs", err)
+			}
+			if before != fmt.Sprintf("%#v", members) {
+				t.Fatal("collision validation changed an original definition")
+			}
+			if mutation == "none" && !reflect.DeepEqual(members, fixture()) {
+				t.Fatal("collision checking selected or merged a DUPok body")
+			}
+		})
+	}
+}
+
+func TestASMDataCompleteInputGraphBound(t *testing.T) {
+	request := SDKASMDataObservationRequest{Target: "linux/amd64", PackagePath: "example.invalid/fixture",
+		Archive: []byte("archive"), BuiltinSource: make([]byte, 64<<20),
+		Sources: []SDKASMDataSource{{Name: "data.s", Original: []byte("source"), Expanded: []byte("source"),
+			OriginalObject: []byte("object"), ExpandedObject: []byte("object")}}}
+	if _, err := ObserveX86SDKASMData(request); !errors.Is(err, ErrContext) ||
+		!strings.Contains(err.Error(), "whole input graph") {
+		t.Fatal("BuiltinSource was omitted from the complete input graph budget", err)
+	}
+}
+
+func BenchmarkASMDataIndexedJoin(b *testing.B) {
+	for _, count := range []int{1024, 4096, 16384} {
+		b.Run(fmt.Sprintf("globals-%d", count), func(b *testing.B) {
+			states, member := asmDataIndexedFixture(count)
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if _, err := joinASMDataLayouts(states, member); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func BenchmarkASMDataNamedDUPokGroups(b *testing.B) {
+	for _, count := range []int{1024, 4096, 16384} {
+		b.Run(fmt.Sprintf("members-%d", count), func(b *testing.B) {
+			members := make([]ASMDataMember, count)
+			for index := range members {
+				members[index].Definitions = []ASMDataDefinition{{Name: "shared", Kind: 3, Flags: 1,
+					Namespace: TextSymbolSelf}}
+			}
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if err := validateASMDataArchiveNames(members); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data_object.go b/internal/gostaticstorage/assembly_data_object.go
new file mode 100644
index 000000000..5ee7f3b0f
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_object.go
@@ -0,0 +1,244 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"reflect"
+)
+
+func observeASMDataObject(data, builtin []byte, target string, flags uint32, referenced sdkReferencedSymbols) (ASMDataMember, error) {
+	var member ASMDataMember
+	builtins, err := textBuiltins(builtin)
+	if err != nil {
+		return member, err
+	}
+	reader := objectBody
+	if flags&16 != 0 && flags&4 == 0 {
+		reader = sdkObjectBody
+	}
+	body, err := reader(data, target)
+	if err != nil {
+		return member, err
+	}
+	member.ObjectOffset = int64(len(data) - len(body))
+	object, err := checkedSDKObject(body, flags, flags&4 != 0)
+	if err != nil {
+		return member, err
+	}
+	// TEXT validates every reference, relocation and auxiliary record, including
+	// unused ones. It retains all original bodies rather than choosing by name.
+	member.Texts, err = readCheckedTextObjectKinds(object, target, builtins, referenced, true)
+	if err != nil {
+		return member, err
+	}
+	symbols, err := object.indexedSymbols()
+	if err != nil {
+		return member, err
+	}
+	resolve, _, err := objectReferenceResolver(object, builtins, referenced)
+	if err != nil {
+		return member, err
+	}
+	member.Flags = flags
+	for _, symbol := range symbols {
+		if symbol.Namespace == TextSymbolNonpkgReference || currentSDKObjectIsText(symbol.Kind) {
+			continue
+		}
+		index := int(symbol.Index)
+		start, end := object.indices[2][index], object.indices[2][index+1]
+		dataBytes := append([]byte(nil), object.block(16)[start:end]...)
+		value := ASMDataDefinition{Namespace: symbol.Namespace, Relative: symbol.Relative, Index: symbol.Index,
+			Name: symbol.Name, ABI: symbol.ABI, Kind: symbol.Kind, Flags: symbol.Flags, Flags2: symbol.Flags2,
+			Size: symbol.Size, Align: symbol.Align, Hash: append([]byte(nil), symbol.Hash...),
+			DataOffset: binary.LittleEndian.Uint32(body[20+16*4:]) + start, Data: dataBytes}
+		for ordinal := object.indices[0][index]; ordinal < object.indices[0][index+1]; ordinal++ {
+			raw := object.block(14)[int(ordinal)*23 : (int(ordinal)+1)*23]
+			target, err := resolve(raw[15:])
+			if err != nil {
+				return member, err
+			}
+			relocation := TextRelocation{Offset: int64(int32(binary.LittleEndian.Uint32(raw))), Size: int64(raw[4]),
+				Type: binary.LittleEndian.Uint16(raw[5:]), Add: int64(binary.LittleEndian.Uint64(raw[7:])), Target: target}
+			if relocation.Offset < 0 || relocation.Size > int64(len(value.Data)) || relocation.Offset > int64(len(value.Data))-relocation.Size {
+				return member, contextError("DATA physical relocation exceeds its actual written data")
+			}
+			value.Relocations = append(value.Relocations, relocation)
+		}
+		member.Definitions = append(member.Definitions, value)
+	}
+	return member, nil
+}
+
+func asmDataBaseKind(kind uint8) uint8 {
+	switch kind {
+	case 4: // SRODATAFIPS.
+		return 3
+	case 6: // SNOPTRDATAFIPS.
+		return 5
+	case 8: // SDATAFIPS.
+		return 7
+	}
+	return kind
+}
+
+func validateASMDataArchiveNames(members []ASMDataMember) error {
+	declarationPairs := asmDataCompilerDeclarationPairs(members)
+	type abiGroup struct {
+		// The value records whether this member's definitions use the
+		// linker-visible nonpackage namespace, rather than package-local Self.
+		members      map[int]bool
+		nonDuplicate bool
+	}
+	type definitionIndex struct {
+		group    *abiGroup
+		member   int
+		index    uint32
+		relative bool
+	}
+	type namedGroup struct {
+		kind       uint8
+		storageABI uint16
+		abis       map[uint16]*abiGroup
+	}
+	seen := make(map[string]*namedGroup)
+	var nonpackageIndices map[definitionIndex]bool
+	observe := func(name string, abi uint16, namespace TextSymbolNamespace, kind, flags uint8, member int, index, relative uint32) error {
+		if name == "" || abi == 65535 || namespace == TextSymbolHashed64 || namespace == TextSymbolHashed {
+			return nil
+		}
+		kind = asmDataBaseKind(kind)
+		group := seen[name]
+		if group == nil {
+			group = &namedGroup{kind: kind, storageABI: abi, abis: make(map[uint16]*abiGroup)}
+			seen[name] = group
+		}
+		if group.kind != kind {
+			return contextError(fmt.Sprintf("SDK ASM DATA named definition collides with a different TEXT/storage kind: name=%q previous-kind=%d kind=%d ABI=%d namespace=%d member=%d index=%d",
+				name, group.kind, kind, abi, namespace, member, index))
+		}
+		if !currentSDKObjectIsText(kind) && group.storageABI != abi {
+			return contextError("SDK ASM DATA named storage has multiple ABI identities")
+		}
+		identities := group.abis[abi]
+		if identities == nil {
+			identities = &abiGroup{members: make(map[int]bool)}
+			group.abis[abi] = identities
+		}
+		duplicate := flags&1 != 0
+		previousNonpackage, sameMember := identities.members[member]
+		nonpackage := namespace == TextSymbolNonpkgDefinition
+		if sameMember && !(previousNonpackage && nonpackage) || !duplicate && identities.nonDuplicate {
+			return contextError(fmt.Sprintf("SDK ASM DATA named definition has an ambiguous non-DUPok body: name=%q ABI=%d namespace=%d member=%d same-member=%t previous-non-DUPok=%t flags=%#x",
+				name, abi, namespace, member, sameMember, identities.nonDuplicate, flags))
+		}
+		if nonpackage {
+			// Keep every object-local identity. DUPok permits several original
+			// definitions; it never permits replaying the same index twice or
+			// selecting one body by its name or equal data bytes.
+			if nonpackageIndices == nil {
+				nonpackageIndices = make(map[definitionIndex]bool)
+			}
+			combined := definitionIndex{group: identities, member: member, index: index}
+			local := definitionIndex{group: identities, member: member, index: relative, relative: true}
+			if nonpackageIndices[combined] || nonpackageIndices[local] {
+				return contextError("SDK ASM DATA named definition repeats an original nonpackage index: " + name)
+			}
+			nonpackageIndices[combined], nonpackageIndices[local] = true, true
+		}
+		identities.members[member] = nonpackage
+		identities.nonDuplicate = identities.nonDuplicate || !duplicate
+		// Only aggregate collision facts, never a winning body. All original
+		// member/namespace/index identities remain in the returned observation.
+		return nil
+	}
+	for ordinal, member := range members {
+		for _, definition := range member.Definitions {
+			if asmDataCompilerBSSDeclaration(member, definition) &&
+				declarationPairs[asmDataStorageExtent{asmDataStorageIdentity{definition.Name, definition.ABI}, definition.Size}] {
+				continue // Preserve the original record; it is not a second initialized body.
+			}
+			if err := observe(definition.Name, definition.ABI, definition.Namespace, definition.Kind, definition.Flags, ordinal, definition.Index, definition.Relative); err != nil {
+				return err
+			}
+		}
+		for _, text := range member.Texts {
+			if err := observe(text.Name, text.ABI, text.Namespace, text.Kind, text.Flags, ordinal, text.Index, text.Relative); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func joinASMDataLayouts(states []asmDataLayoutState, member ASMDataMember) ([]ASMGlobalLayout, error) {
+	type candidateKey struct {
+		name string
+		abi  uint16
+	}
+	candidates := make(map[candidateKey][]int, len(member.Definitions))
+	for index, definition := range member.Definitions {
+		key := candidateKey{definition.Name, definition.ABI}
+		candidates[key] = append(candidates[key], index)
+	}
+	used := make(map[uint32]bool)
+	lastRelative := make(map[TextSymbolNamespace]uint32)
+	layouts := make([]ASMGlobalLayout, 0, len(states))
+	for _, state := range states {
+		indices := candidates[candidateKey{state.layout.Name, state.layout.ABI}]
+		// The name/ABI identifies candidate membership only. An ambiguous object
+		// never selects a body by hash, bytes or a convenient storage namespace.
+		if len(indices) != 1 || used[member.Definitions[indices[0]].Index] {
+			return nil, contextError("source GLOBL lacks one unique object-local DATA definition")
+		}
+		definition := member.Definitions[indices[0]]
+		if previous, present := lastRelative[definition.Namespace]; present && definition.Relative <= previous {
+			return nil, contextError("source GLOBL order differs from its actual object-local namespace order")
+		}
+		lastRelative[definition.Namespace] = definition.Relative
+		used[definition.Index] = true
+		if asmDataBaseKind(definition.Kind) != state.kind || int64(definition.Size) != state.actualSize ||
+			!bytes.Equal(definition.Data, state.data) || (definition.Flags&1 != 0) != (state.layout.Flags&2 != 0) ||
+			len(definition.Relocations) != len(state.addresses) {
+			return nil, contextError("source DATA/GLOBL bytes, size, flags or relocation inventory differs from the actual object")
+		}
+		for ordinal, fragment := range state.addresses {
+			relocation := definition.Relocations[ordinal]
+			address := fragment.Address
+			if relocation.Offset != fragment.Offset || relocation.Size != fragment.Width || relocation.Type != 1 ||
+				relocation.Add != address.Addend || relocation.Target.Name != address.Name || !relocation.Target.ABIKnown || relocation.Target.ABI != address.ABI {
+				return nil, contextError("source address fragment differs from its exact ordered actual R_ADDR")
+			}
+		}
+		layout := state.layout
+		layout.Definition = definition
+		layouts = append(layouts, layout)
+	}
+	for _, definition := range member.Definitions {
+		if definition.Name != "" && asmDataBaseKind(definition.Kind) >= 3 && asmDataBaseKind(definition.Kind) <= 11 && !used[definition.Index] {
+			return nil, contextError("actual assembly DATA definition is missing from the whole source inventory")
+		}
+	}
+	return layouts, nil
+}
+
+// Whole anonymous definitions are compared too: they cannot hide unconsumed
+// DATA bytes or relocations. Physical source-file positions are retained in
+// both observations; line-preserving inputs must otherwise agree exactly.
+func sameASMDataObjects(first, second ASMDataMember) bool {
+	filter := func(member ASMDataMember) ASMDataMember {
+		member.Name, member.NameBytes, member.Ordinal, member.Offset, member.Size, member.ObjectOffset = "", nil, 0, 0, 0, 0
+		definitions := make([]ASMDataDefinition, 0, len(member.Definitions))
+		for _, definition := range member.Definitions {
+			definition.DataOffset = 0
+			definitions = append(definitions, definition)
+		}
+		member.Definitions = definitions
+		member.Texts = append([]TextRecord(nil), member.Texts...)
+		for index := range member.Texts {
+			member.Texts[index].Positions, member.Texts[index].PCFile, member.Texts[index].PCLine = nil, nil, nil
+		}
+		return member
+	}
+	return reflect.DeepEqual(filter(first), filter(second))
+}
diff --git a/internal/gostaticstorage/assembly_data_source.go b/internal/gostaticstorage/assembly_data_source.go
new file mode 100644
index 000000000..42d6ab62b
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_source.go
@@ -0,0 +1,381 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"text/scanner"
+	"unicode"
+)
+
+type asmDataLayoutState struct {
+	layout     ASMGlobalLayout
+	global     bool
+	kind       uint8
+	actualSize int64
+	data       []byte
+	addresses  []ASMDataFragment
+}
+
+func asmDataProgramFingerprint(source []byte) (string, error) {
+	statements, err := asmDataStatements(source)
+	if err != nil {
+		return "", err
+	}
+	// Preserve complete statement/token order, not merely DATA values. Raw
+	// source hashes remain separate; whitespace/comments do not change grammar.
+	type token struct {
+		Kind rune
+		Text string
+	}
+	program := make([][]token, len(statements))
+	for ordinal, statement := range statements {
+		for _, value := range statement {
+			program[ordinal] = append(program[ordinal], token{value.kind, value.text})
+		}
+	}
+	encoded, err := json.Marshal(program)
+	if err != nil {
+		return "", err
+	}
+	return digest(encoded), nil
+}
+
+func joinASMSourceTexts(source []byte, packagePath string, member ASMDataMember) error {
+	_, err := ASMSourceTextOrder(source, packagePath, member)
+	return err
+}
+
+func asmDataStatements(source []byte) ([][]asmDataToken, error) {
+	if len(source) == 0 || len(source) > archiveLimit || bytes.IndexByte(source, 0) >= 0 {
+		return nil, contextError("DATA source violates its complete byte bound")
+	}
+	var lexicalError error
+	var lexer scanner.Scanner
+	lexer.Init(bytes.NewReader(source))
+	lexer.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
+	lexer.Mode = scanner.ScanChars | scanner.ScanFloats | scanner.ScanIdents |
+		scanner.ScanInts | scanner.ScanStrings | scanner.ScanComments
+	lexer.IsIdentRune = func(ch rune, index int) bool {
+		return unicode.IsLetter(ch) || ch == '_' || ch == '·' || ch == '∕' || index > 0 && unicode.IsDigit(ch)
+	}
+	lexer.Error = func(_ *scanner.Scanner, message string) {
+		lexicalError = contextError("invalid DATA source token: " + message)
+	}
+	var statements [][]asmDataToken
+	var statement []asmDataToken
+	for {
+		kind := lexer.Scan()
+		text := lexer.TokenText()
+		if lexicalError != nil {
+			return nil, lexicalError
+		}
+		if kind == scanner.Comment {
+			continue
+		}
+		if kind == '#' {
+			return nil, contextError("DATA source needs an independent CPP/generated-header observation")
+		}
+		if kind == '\n' || kind == ';' || kind == scanner.EOF {
+			if len(statement) != 0 {
+				if len(statements) >= symbolLimit {
+					return nil, contextError("DATA source statement inventory exceeds its bound")
+				}
+				statements = append(statements, statement)
+				statement = nil
+			}
+			if kind == scanner.EOF {
+				return statements, nil
+			}
+			continue
+		}
+		if (kind == '<' || kind == '>') && lexer.Peek() == kind {
+			lexer.Next()
+			text += text
+			if kind == '<' {
+				kind = asmDataLeftShift
+			} else {
+				kind = asmDataRightShift
+			}
+		}
+		// Go lex.Make normalizes these characters in every token, including
+		// string and character literals, not just identifiers.
+		text = strings.ReplaceAll(strings.ReplaceAll(text, "·", "."), "∕", "/")
+		statement = append(statement, asmDataToken{kind: kind, text: text, line: lexer.Position.Line})
+		if len(statement) > symbolLimit {
+			return nil, contextError("DATA statement token inventory exceeds its bound")
+		}
+	}
+}
+
+func asmDataOperands(tokens []asmDataToken) [][]asmDataToken {
+	var operands [][]asmDataToken
+	start, depth := 0, 0
+	for index, token := range tokens {
+		if token.kind == '(' {
+			depth++
+		} else if token.kind == ')' {
+			depth--
+		} else if token.kind == ',' && depth == 0 {
+			operands = append(operands, tokens[start:index])
+			start = index + 1
+		}
+	}
+	return append(operands, tokens[start:])
+}
+
+// Go PathToPrefix escapes bytes, and only escapes periods in the last path
+// segment. This is source spelling normalization, not a package authority test.
+func asmDataPackagePrefix(path string) string {
+	const hex = "0123456789abcdef"
+	slash := strings.LastIndexByte(path, '/')
+	var prefix strings.Builder
+	for index := 0; index < len(path); index++ {
+		ch := path[index]
+		if ch <= ' ' || ch == '.' && index > slash || ch == '%' || ch == '"' || ch >= 0x7f {
+			prefix.WriteByte('%')
+			prefix.WriteByte(hex[ch>>4])
+			prefix.WriteByte(hex[ch&15])
+		} else {
+			prefix.WriteByte(ch)
+		}
+	}
+	return prefix.String()
+}
+
+func asmDataSymbol(tokens []asmDataToken, packagePath string) (ASMDataAddressValue, error) {
+	var symbol ASMDataAddressValue
+	if len(tokens) < 4 || tokens[0].kind != scanner.Ident || tokens[len(tokens)-3].kind != '(' ||
+		tokens[len(tokens)-2].text != "SB" || tokens[len(tokens)-1].kind != ')' {
+		return symbol, contextError("DATA/GLOBL requires an exact symbol(SB) operand")
+	}
+	symbol.Name = tokens[0].text
+	if strings.HasPrefix(symbol.Name, ".") {
+		symbol.Name = asmDataPackagePrefix(packagePath) + symbol.Name
+	}
+	p := &asmDataExpression{tokens: tokens[1 : len(tokens)-3]}
+	if p.peek() == '<' {
+		p.next()
+		if p.peek() == '>' {
+			symbol.Static, symbol.ABI = true, 65535
+		} else {
+			selector := p.next()
+			if selector.kind != scanner.Ident || selector.text != "ABI0" && selector.text != "ABIInternal" {
+				return symbol, contextError("unknown DATA/GLOBL symbol ABI selector")
+			}
+			if selector.text == "ABIInternal" {
+				symbol.ABI = 1
+			}
+		}
+		if p.next().kind != '>' {
+			return symbol, contextError("unclosed DATA/GLOBL symbol attributes")
+		}
+	}
+	if p.peek() == '+' || p.peek() == '-' {
+		symbol.Addend = int64(p.integer())
+	}
+	if p.err != nil || p.pos != len(p.tokens) {
+		return symbol, contextError("unconsumed or invalid DATA/GLOBL symbol operand")
+	}
+	return symbol, nil
+}
+
+func asmDataValue(tokens []asmDataToken, width int64, packagePath string, pointerWidth int64) (ASMDataFragment, error) {
+	fragment := ASMDataFragment{Width: width}
+	if len(tokens) < 2 || tokens[0].kind != '$' || width < 0 || width > archiveLimit {
+		return fragment, contextError("DATA requires a bounded immediate value")
+	}
+	value := tokens[1:]
+	if value[0].kind == scanner.String {
+		text, err := strconv.Unquote(value[0].text)
+		if err != nil || len(value) != 1 || int64(len(text)) > width {
+			return fragment, contextError("invalid or oversized DATA string value")
+		}
+		fragment.Kind, fragment.String = ASMDataString, []byte(text)
+		return fragment, nil
+	}
+	if value[0].kind == scanner.Ident {
+		symbol, err := asmDataSymbol(value, packagePath)
+		if err != nil || width != pointerWidth {
+			return fragment, contextError("DATA address requires an exact pointer-sized symbol value")
+		}
+		fragment.Kind, fragment.Address = ASMDataAddress, &symbol
+		return fragment, nil
+	}
+	for _, token := range value {
+		if token.kind != scanner.Float {
+			continue
+		}
+		if width != 4 && width != 8 {
+			return fragment, contextError("DATA float requires width 4 or 8")
+		}
+		p := &asmDataExpression{tokens: value}
+		floatValue := p.floating()
+		if p.err != nil || p.pos != len(value) {
+			return fragment, contextError("invalid DATA float expression")
+		}
+		fragment.Kind = ASMDataFloat
+		if width == 4 {
+			fragment.Bits = uint64(math.Float32bits(float32(floatValue)))
+		} else {
+			fragment.Bits = math.Float64bits(floatValue)
+		}
+		return fragment, nil
+	}
+	if width != 1 && width != 2 && width != 4 && width != 8 {
+		return fragment, contextError("DATA integer requires width 1, 2, 4 or 8")
+	}
+	valueBits, err := asmDataInteger(value)
+	if err != nil {
+		return fragment, err
+	}
+	fragment.Kind, fragment.Bits = ASMDataInteger, valueBits
+	if width != 8 {
+		fragment.Bits &= uint64(1)<<(uint(width)*8) - 1
+	}
+	return fragment, nil
+}
+
+func parseASMDataSource(source []byte, packagePath, target string) ([]asmDataLayoutState, error) {
+	statements, err := asmDataStatements(source)
+	if err != nil {
+		return nil, err
+	}
+	pointerWidth := int64(8)
+	if !X86SDKTarget(target) {
+		return nil, contextError("DATA source target has no observed pointer width")
+	}
+	if strings.HasSuffix(target, "/386") {
+		pointerWidth = 4
+	}
+	states := make(map[string]*asmDataLayoutState)
+	lastEnd := make(map[string]int64)
+	totalWritten := int64(0)
+	var ordered []*asmDataLayoutState
+	for ordinal, statement := range statements {
+		if statement[0].text != "DATA" && statement[0].text != "GLOBL" {
+			continue
+		}
+		operands := asmDataOperands(statement[1:])
+		global := statement[0].text == "GLOBL"
+		if !global && len(operands) != 2 || global && len(operands) != 2 && len(operands) != 3 {
+			return nil, contextError("invalid DATA/GLOBL operand count")
+		}
+		nameTokens := operands[0]
+		width := int64(0)
+		if !global {
+			length := len(nameTokens)
+			if length < 3 || nameTokens[length-2].kind != '/' || nameTokens[length-1].kind != scanner.Int {
+				return nil, contextError("DATA width must be one decimal integer token")
+			}
+			parsedWidth, err := strconv.ParseInt(nameTokens[length-1].text, 10, 64)
+			if err != nil {
+				return nil, contextError("invalid DATA width token")
+			}
+			width, nameTokens = parsedWidth, nameTokens[:length-2]
+		}
+		symbol, err := asmDataSymbol(nameTokens, packagePath)
+		if err != nil || global && symbol.Addend != 0 || !global && (symbol.Addend < 0 || symbol.Addend > archiveLimit-width) {
+			return nil, contextError("invalid or unbounded DATA/GLOBL symbol extent")
+		}
+		key := fmt.Sprintf("%s\x00%d", symbol.Name, symbol.ABI)
+		state := states[key]
+		if state == nil {
+			state = &asmDataLayoutState{layout: ASMGlobalLayout{Name: symbol.Name, Static: symbol.Static, ABI: symbol.ABI}}
+			states[key] = state
+		}
+		if global {
+			if state.global {
+				return nil, contextError("duplicate source GLOBL declaration")
+			}
+			flags := uint64(0)
+			if len(operands) == 3 {
+				flags, err = asmDataInteger(operands[1])
+				if err != nil {
+					return nil, err
+				}
+			}
+			sizeOperand := operands[len(operands)-1]
+			if len(sizeOperand) < 2 || sizeOperand[0].kind != '$' {
+				return nil, contextError("GLOBL extent must be an immediate integer")
+			}
+			size, err := asmDataInteger(sizeOperand[1:])
+			if err != nil || int64(size) < 0 || size > archiveLimit {
+				return nil, contextError("GLOBL declared extent exceeds its byte bound")
+			}
+			state.global, state.actualSize = true, int64(size)
+			state.layout.Ordinal, state.layout.Line = ordinal, statement[0].line
+			state.layout.Flags, state.layout.DeclaredSize = flags, int64(size)
+			if state.kind == 0 {
+				state.kind = 9 // SBSS.
+			}
+			switch {
+			case flags&8 != 0:
+				state.kind = 3 // SRODATA.
+			case flags&16 != 0:
+				if state.kind == 7 || state.kind == 8 {
+					state.kind = 5 // SNOPTRDATA.
+				} else {
+					state.kind = 10 // SNOPTRBSS.
+				}
+			case flags&256 != 0:
+				state.kind = 11 // STLSBSS.
+			}
+			ordered = append(ordered, state)
+			continue
+		}
+		if end, present := lastEnd[symbol.Name]; present && symbol.Addend < end {
+			return nil, contextError("source DATA entries overlap or are nonmonotonic")
+		}
+		fragment, err := asmDataValue(operands[1], width, packagePath, pointerWidth)
+		if err != nil {
+			return nil, err
+		}
+		fragment.Ordinal, fragment.Line, fragment.Offset = ordinal, statement[0].line, symbol.Addend
+		lastEnd[symbol.Name] = symbol.Addend + width
+		if state.kind == 11 {
+			return nil, contextError("source DATA initializes TLSBSS")
+		}
+		if state.kind == 0 || state.kind == 9 {
+			state.kind = 7 // SDATA.
+		} else if state.kind == 10 {
+			state.kind = 5 // SNOPTRDATA.
+		}
+		end := fragment.Offset + fragment.Width
+		if end > int64(len(state.data)) {
+			totalWritten += end - int64(len(state.data))
+			if totalWritten > archiveLimit {
+				return nil, contextError("DATA complete written layout inventory exceeds its object byte bound")
+			}
+			state.data = append(state.data, make([]byte, end-int64(len(state.data)))...)
+		}
+		if end > state.actualSize {
+			state.actualSize = end
+		}
+		for byteIndex := int64(0); byteIndex < fragment.Width; byteIndex++ {
+			switch fragment.Kind {
+			case ASMDataInteger, ASMDataFloat:
+				state.data[fragment.Offset+byteIndex] = byte(fragment.Bits >> (8 * uint(byteIndex)))
+			case ASMDataString:
+				if byteIndex < int64(len(fragment.String)) {
+					state.data[fragment.Offset+byteIndex] = fragment.String[byteIndex]
+				}
+			}
+		}
+		if fragment.Kind == ASMDataAddress {
+			state.addresses = append(state.addresses, fragment)
+		}
+		state.layout.Fragments = append(state.layout.Fragments, fragment)
+	}
+	if len(ordered) != len(states) {
+		return nil, contextError("source DATA lacks its complete GLOBL/object layout")
+	}
+	result := make([]asmDataLayoutState, len(ordered))
+	for index, state := range ordered {
+		result[index] = *state
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/assembly_data_source_test.go b/internal/gostaticstorage/assembly_data_source_test.go
new file mode 100644
index 000000000..46f2e6567
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_source_test.go
@@ -0,0 +1,128 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+var asmDataGrammarCases = []struct {
+	name, value string
+	width       int64
+	kind        ASMDataValueKind
+	bits        uint64
+	text        string
+}{
+	{"byte-truncation", "-1", 1, ASMDataInteger, 255, ""},
+	{"word-truncation", "0x12345", 2, ASMDataInteger, 0x2345, ""},
+	{"uint64-wrap", "(~0)+2", 8, ASMDataInteger, 1, ""},
+	{"binary-radix", "0b1010_0110", 1, ASMDataInteger, 0xa6, ""},
+	{"octal-radix", "0o1234", 2, ASMDataInteger, 668, ""},
+	{"go-precedence", "1|2^3+4*5&7", 8, ASMDataInteger, 4, ""},
+	{"division-modulo", "29/4%3", 8, ASMDataInteger, 1, ""},
+	{"left-shift", "1<<65", 8, ASMDataInteger, 0, ""},
+	{"right-associative-shift", "64>>4>>1", 8, ASMDataInteger, 16, ""},
+	{"char-truncation", "'世'", 1, ASMDataInteger, 0x16, ""},
+	{"char-lex-normalization", "'·'", 1, ASMDataInteger, '.', ""},
+	{"float32", "1.25", 4, ASMDataFloat, uint64(math.Float32bits(1.25)), ""},
+	{"float64", "-(3.5)", 8, ASMDataFloat, math.Float64bits(-3.5), ""},
+	{"negative-zero", "-0.0", 8, ASMDataFloat, uint64(1) << 63, ""},
+	{"hex-float", "0x1.8p+1", 4, ASMDataFloat, uint64(math.Float32bits(3)), ""},
+	{"float32-overflow", "1e40", 4, ASMDataFloat, uint64(0x7f800000), ""},
+	{"float64-subnormal", "5e-324", 8, ASMDataFloat, 1, ""},
+	// Official asm parses float64 first. Direct Go constant conversion to
+	// float32 would instead round this decimal to the next float32 value.
+	{"float32-rounding", "1.0000000596046448", 4, ASMDataFloat, uint64(math.Float32bits(1)), ""},
+	{"string-padding", `"A\x00B"`, 8, ASMDataString, 0, "A\x00B"},
+	{"arbitrary-string-width", `"abcde"`, 5, ASMDataString, 0, "abcde"},
+	{"string-utf8", `"世"`, 4, ASMDataString, 0, "世"},
+	{"string-lex-normalization", `"·∕"`, 4, ASMDataString, 0, "./"},
+	{"zero-string", `""`, 0, ASMDataString, 0, ""},
+}
+
+func TestASMDataTypedGrammar(t *testing.T) {
+	for _, test := range asmDataGrammarCases {
+		t.Run(test.name, func(t *testing.T) {
+			source := fmt.Sprintf("DATA value<>+0(SB)/%d,$%s\nGLOBL value<>(SB),8,$16\n", test.width, test.value)
+			states, err := parseASMDataSource([]byte(source), "example.invalid/fixture", "linux/amd64")
+			if err != nil || len(states) != 1 || len(states[0].layout.Fragments) != 1 {
+				t.Fatal("complete typed fragment differs", err)
+			}
+			fragment := states[0].layout.Fragments[0]
+			if fragment.Kind != test.kind || fragment.Bits != test.bits || string(fragment.String) != test.text {
+				t.Fatal("typed source value differs", fragment)
+			}
+		})
+	}
+}
+
+func TestASMDataSourceGuards(t *testing.T) {
+	for name, source := range map[string]string{
+		"width-expression":       "DATA a(SB)/(1+1),$3\nGLOBL a(SB),$8",
+		"width-hex":              "DATA a(SB)/0x4,$3\nGLOBL a(SB),$8",
+		"width-int3":             "DATA a(SB)/3,$3\nGLOBL a(SB),$8",
+		"width-float1":           "DATA a(SB)/1,$3.0\nGLOBL a(SB),$8",
+		"width-address4-amd64":   "DATA a(SB)/4,$b(SB)\nGLOBL a(SB),$8",
+		"non-immediate":          "DATA a(SB)/1,3\nGLOBL a(SB),$8",
+		"oversized-string":       "DATA a(SB)/1,$\"ab\"\nGLOBL a(SB),$8",
+		"float-arithmetic":       "DATA a(SB)/8,$1.0+2.0\nGLOBL a(SB),$8",
+		"integer-float":          "DATA a(SB)/8,$1+2.0\nGLOBL a(SB),$8",
+		"integer-overflow":       "DATA a(SB)/8,$18446744073709551616\nGLOBL a(SB),$8",
+		"float-overflow":         "DATA a(SB)/8,$1e999\nGLOBL a(SB),$8",
+		"zero-divisor":           "DATA a(SB)/8,$1/0\nGLOBL a(SB),$8",
+		"high-bit-divisor":       "DATA a(SB)/8,$(~0)/2\nGLOBL a(SB),$8",
+		"high-bit-modulo":        "DATA a(SB)/8,$(~0)%2\nGLOBL a(SB),$8",
+		"high-bit-right-shift":   "DATA a(SB)/8,$(~0)>>1\nGLOBL a(SB),$8",
+		"negative-left-shift":    "DATA a(SB)/8,$1<<-1\nGLOBL a(SB),$8",
+		"negative-right-shift":   "DATA a(SB)/8,$1>>-1\nGLOBL a(SB),$8",
+		"left-shift-tail":        "DATA a(SB)/8,$1<<2*3\nGLOBL a(SB),$8",
+		"overlap":                "DATA a(SB)/4,$1\nDATA a+3(SB)/1,$2\nGLOBL a(SB),$8",
+		"backwards":              "DATA a+4(SB)/1,$1\nDATA a+2(SB)/1,$2\nGLOBL a(SB),$8",
+		"negative-offset":        "DATA a-1(SB)/1,$1\nGLOBL a(SB),$8",
+		"global-offset":          "GLOBL a+1(SB),$8",
+		"global-non-immediate":   "GLOBL a(SB),8",
+		"global-duplicate":       "GLOBL a(SB),$8\nGLOBL a(SB),$8",
+		"missing-global":         "DATA a(SB)/1,$1",
+		"unknown-ABI":            "GLOBL a<ABI99>(SB),$8",
+		"wrong-register":         "GLOBL a(FP),$8",
+		"pointer-tail":           "DATA a(SB)/8,$b(SB)+1\nGLOBL a(SB),$8",
+		"macro":                  "#define SIZE 8\nGLOBL a(SB),$SIZE",
+		"generated-header":       "#include \"go_asm.h\"\nGLOBL a(SB),$8",
+		"tls-initialization":     "GLOBL a(SB),256,$8\nDATA a(SB)/1,$1",
+		"unclosed-expression":    "DATA a(SB)/8,$(1+2\nGLOBL a(SB),$8",
+		"excessive-expr-depth":   "DATA a(SB)/8,$" + strings.Repeat("(", 300) + "1" + strings.Repeat(")", 300) + "\nGLOBL a(SB),$8",
+		"aggregate-sparse-bound": "DATA a+16777215(SB)/1,$1\nGLOBL a(SB),$1\nDATA b+16777215(SB)/1,$1\nGLOBL b(SB),$1",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := parseASMDataSource([]byte(source), "example.invalid/fixture", "linux/amd64"); !errors.Is(err, ErrContext) {
+				t.Fatal("invalid/unbounded/unclosed DATA grammar did not fail closed", err)
+			}
+		})
+	}
+}
+
+func TestASMDataLayoutOrderAndFlags(t *testing.T) {
+	for _, test := range []struct {
+		name, source string
+		size, length int64
+		kind         uint8
+		flags        uint64
+	}{
+		{"before-data", "GLOBL a<>(SB),16,$1\nDATA a<>+2(SB)/4,$7", 6, 6, 5, 16},
+		{"after-data", "DATA a<>+2(SB)/4,$7\nGLOBL a<>(SB),8,$1", 1, 6, 3, 8},
+		{"declared-tail", "DATA a<>(SB)/1,$7\nGLOBL a<>(SB),8,$24", 24, 1, 3, 8},
+		{"noptr-data", "DATA a<>(SB)/1,$7\nGLOBL a<>(SB),16,$1", 1, 1, 5, 16},
+		{"flag-priority", "DATA a<>(SB)/1,$7\nGLOBL a<>(SB),8|16|256,$1", 1, 1, 3, 280},
+		{"ignored-other-flags", "DATA a<>(SB)/1,$7\nGLOBL a<>(SB),1|4|32|64|512|1024|2048|4096,$1", 1, 1, 7, 7781},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			states, err := parseASMDataSource([]byte(test.source), "example.invalid/fixture", "linux/amd64")
+			if err != nil || len(states) != 1 || states[0].actualSize != test.size || int64(len(states[0].data)) != test.length ||
+				states[0].kind != test.kind || states[0].layout.Flags != test.flags {
+				t.Fatal("GLOBL size/P length/source flag order differs", states, err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_data_standalone.go b/internal/gostaticstorage/assembly_data_standalone.go
new file mode 100644
index 000000000..5c7d480c1
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_standalone.go
@@ -0,0 +1,42 @@
+package gostaticstorage
+
+import "strings"
+
+// AMD64AssemblyData is a complete standalone object/source observation. It is
+// not an SDK role or a certificate for storage, reads, addresses or native ABI.
+type AMD64AssemblyData struct {
+	Member    ASMDataMember
+	Layouts   []ASMGlobalLayout
+	TextOrder []ASMSourceText
+}
+
+// ObserveAMD64AssemblyData reuses the same typed DATA grammar and complete
+// object decoder as the SDK observer without borrowing SDK provenance. The
+// live caller must retain the actual producer, expanded source and object.
+func ObserveAMD64AssemblyData(source, object, builtin []byte, packagePath, target string) (AMD64AssemblyData, error) {
+	var result AMD64AssemblyData
+	if target != "linux/amd64" && target != "darwin/amd64" && target != "windows/amd64" ||
+		packagePath == "" || len(packagePath) > 4096 || strings.ContainsAny(packagePath, "\x00\r\n") ||
+		len(object) == 0 || len(object) > archiveLimit || len(source)+len(object)+len(builtin) > 64<<20 {
+		return result, contextError("standalone AMD64 DATA has an unobserved target or unbounded input")
+	}
+	// All three targets have the same AMD64 pointer-width DATA grammar. The
+	// object itself is still checked against its exact physical OS/architecture.
+	states, err := parseASMDataSource(source, packagePath, "linux/amd64")
+	if err != nil {
+		return result, err
+	}
+	result.Member, err = observeASMDataObject(object, builtin, target, 4, nil)
+	if err != nil {
+		return AMD64AssemblyData{}, err
+	}
+	result.TextOrder, err = ASMSourceTextOrder(source, packagePath, result.Member)
+	if err != nil {
+		return AMD64AssemblyData{}, err
+	}
+	result.Layouts, err = joinASMDataLayouts(states, result.Member)
+	if err != nil {
+		return AMD64AssemblyData{}, err
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/assembly_data_standalone_go127_test.go b/internal/gostaticstorage/assembly_data_standalone_go127_test.go
new file mode 100644
index 000000000..b07e5448a
--- /dev/null
+++ b/internal/gostaticstorage/assembly_data_standalone_go127_test.go
@@ -0,0 +1,90 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestGoStandaloneAMD64DataIndependentOriginalObjects(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	dataOracle := officialReaderForSource(t, driver, sdkASMDataReaderSource)
+	textOracle := officialReaderForSource(t, driver, sdkTextReaderSource)
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(driver)), builtinSourceRole))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The shared independent fixture exercises all integer/float/string
+	// fragments, sparse/tail/BSS extents, flags and address relocations. Here
+	// it is an ordinary standalone object, never an SDK archive or -std input.
+	source := []byte(asmDataFixtureSource("amd64"))
+	name := filepath.Join(directory, "standalone.asm")
+	if err := os.WriteFile(name, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			env := fixtureEnv(t, target)
+			objectName := filepath.Join(t.TempDir(), "standalone.o")
+			run(t, driver, directory, env, "tool", "asm", "-p", fixtureModule, "-o", objectName, name)
+			object, err := os.ReadFile(objectName)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var actual []ASMDataMember
+			var texts []TextMember
+			if err := json.Unmarshal(run(t, dataOracle, directory, env, objectName), &actual); err != nil || len(actual) != 1 {
+				t.Fatal("actual SDK standalone DATA reader", err)
+			}
+			if err := json.Unmarshal(run(t, textOracle, directory, env, objectName), &texts); err != nil || len(texts) != 1 {
+				t.Fatal("actual SDK standalone TEXT reader", err)
+			}
+			observed, err := ObserveAMD64AssemblyData(source, object, builtin, fixtureModule, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if observed.Member.Flags != 4 || !reflect.DeepEqual(observed.Member.Definitions, actual[0].Definitions) ||
+				!reflect.DeepEqual(observed.Member.Texts, texts[0].Texts) || len(observed.Layouts) < len(asmDataGrammarCases) {
+				t.Fatal("standalone observation differs from complete independent SDK records")
+			}
+			for name, mutate := range map[string]func([]byte, []byte) ([]byte, []byte){
+				"wrong-value": func(s, o []byte) ([]byte, []byte) {
+					return bytes.Replace(s, []byte("0x12345"), []byte("0x12346"), 1), o
+				},
+				"missing-layout": func(s, o []byte) ([]byte, []byte) {
+					return bytes.ReplaceAll(s, []byte("GLOBL mutable<>(SB),$32"), nil), o
+				},
+				"missing-TEXT": func(s, o []byte) ([]byte, []byte) {
+					return bytes.Replace(s, []byte("TEXT ·Entry"), []byte("MISSING ·Entry"), 1), o
+				},
+				"unknown-CPP":       func(s, o []byte) ([]byte, []byte) { return append([]byte("#define VALUE 1\n"), s...), o },
+				"object-tail":       func(s, o []byte) ([]byte, []byte) { return s, append(o, 0) },
+				"object-truncation": func(s, o []byte) ([]byte, []byte) { return s, o[:len(o)-1] },
+			} {
+				t.Run(name, func(t *testing.T) {
+					changedSource, changedObject := mutate(bytes.Clone(source), bytes.Clone(object))
+					if bytes.Equal(changedSource, source) && bytes.Equal(changedObject, object) {
+						t.Fatal("negative did not change an input")
+					}
+					if _, err := ObserveAMD64AssemblyData(changedSource, changedObject, builtin, fixtureModule, target); !errors.Is(err, ErrContext) {
+						t.Fatal("unbound source/object acquired a standalone observation", err)
+					}
+				})
+			}
+			for _, wrongTarget := range []string{"linux/386", "linux/arm64", "js/wasm", "freebsd/amd64"} {
+				if _, err := ObserveAMD64AssemblyData(source, object, builtin, fixtureModule, wrongTarget); !errors.Is(err, ErrContext) {
+					t.Fatal("standalone AMD64 observer accepted another physical target", wrongTarget, err)
+				}
+			}
+			if _, err := ObserveAMD64AssemblyData(source, object, nil, fixtureModule, target); !errors.Is(err, ErrContext) {
+				t.Fatal("missing actual builtin source was accepted", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool.go b/internal/gostaticstorage/assembly_generated_float_pool.go
new file mode 100644
index 000000000..2cbc06ad4
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool.go
@@ -0,0 +1,225 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"text/scanner"
+)
+
+// ASMGeneratedFloatPool observes a source FCONST rewrite and its unchanged
+// object-local DATA/TEXT associations. It is not an ASMGlobalLayout, readable
+// literal, initialization, numerical, native-entry or storage permission.
+type ASMGeneratedFloatPool struct {
+	Definition ASMDataDefinition
+	Owners     []ASMGeneratedFloatPoolOwner
+}
+
+type ASMGeneratedFloatPoolOwner struct {
+	StatementOrdinal, TextSourceOrdinal, TextObjectOrdinal int
+	TextNamespace                                          TextSymbolNamespace
+	TextRelative, TextIndex                                uint32
+	Opcode                                                 string
+	SourceFloat64Bits                                      uint64
+	RelocationOrdinal                                      int
+	Relocation                                             TextRelocation
+}
+
+type asmGeneratedFloatPoolForm struct {
+	width uint32
+	move  bool
+}
+
+// Complete obj/x86.progedit FCONST producer directory. This small source
+// metadata grammar neither assembles an instruction nor permits its execution.
+// In particular VEX arithmetic is not one of Go's FCONST rewrites.
+var asmGeneratedFloatPoolForms = map[string]asmGeneratedFloatPoolForm{
+	"MOVSS": {4, true}, "VMOVSS": {4, true},
+	"FMOVF": {4, false}, "FADDF": {4, false}, "FSUBF": {4, false}, "FSUBRF": {4, false},
+	"FMULF": {4, false}, "FDIVF": {4, false}, "FDIVRF": {4, false},
+	"FCOMF": {4, false}, "FCOMFP": {4, false},
+	"ADDSS": {4, false}, "SUBSS": {4, false}, "MULSS": {4, false}, "DIVSS": {4, false},
+	"COMISS": {4, false}, "UCOMISS": {4, false},
+	"MOVSD": {8, true}, "VMOVSD": {8, true},
+	"FMOVD": {8, false}, "FADDD": {8, false}, "FSUBD": {8, false}, "FSUBRD": {8, false},
+	"FMULD": {8, false}, "FDIVD": {8, false}, "FDIVRD": {8, false},
+	"FCOMD": {8, false}, "FCOMDP": {8, false},
+	"ADDSD": {8, false}, "SUBSD": {8, false}, "MULSD": {8, false}, "DIVSD": {8, false},
+	"COMISD": {8, false}, "UCOMISD": {8, false},
+}
+
+type asmGeneratedFloatPoolUse struct {
+	owner ASMGeneratedFloatPoolOwner
+	pool  int
+}
+
+func generatedASMFloatPools(source []byte, target string, member ASMDataMember, texts []ASMSourceText) ([]ASMGeneratedFloatPool, error) {
+	if !bytes.Contains(source, []byte("$")) {
+		return nil, nil // No source FCONST can occur without its immediate marker.
+	}
+	statements, err := asmDataStatements(source)
+	if err != nil {
+		return nil, err
+	}
+	if !X86SDKTarget(target) || len(texts) != len(member.Texts) || member.Flags&4 == 0 {
+		return nil, contextError("generated float pool lacks its complete source/TEXT/target role")
+	}
+	seenTexts := make(map[int]bool, len(texts))
+	for ordinal, owner := range texts {
+		if owner.SourceOrdinal != ordinal || owner.ObjectOrdinal < 0 || owner.ObjectOrdinal >= len(member.Texts) || seenTexts[owner.ObjectOrdinal] {
+			return nil, contextError("generated float pool source/TEXT ordinal changed")
+		}
+		text := member.Texts[owner.ObjectOrdinal]
+		if owner.Name != text.Name || owner.ABI != text.ABI || owner.Namespace != text.Namespace ||
+			owner.Relative != text.Relative || owner.Index != text.Index {
+			return nil, contextError("generated float pool source/TEXT identity changed")
+		}
+		seenTexts[owner.ObjectOrdinal] = true
+	}
+	definitions := make(map[string][]ASMDataDefinition, len(member.Definitions))
+	for _, definition := range member.Definitions {
+		definitions[definition.Name] = append(definitions[definition.Name], definition)
+	}
+	var pools []ASMGeneratedFloatPool
+	byName := make(map[string]int)
+	uses := make([][]asmGeneratedFloatPoolUse, len(texts))
+	textOrdinal := -1
+	for ordinal, statement := range statements {
+		// Labels do not produce an instruction or a DATA owner.
+		for len(statement) >= 2 && statement[0].kind == scanner.Ident && statement[1].kind == ':' {
+			statement = statement[2:]
+		}
+		if len(statement) == 0 {
+			continue
+		}
+		if statement[0].text == "TEXT" {
+			textOrdinal++
+			continue // ASMSourceTextOrder already validated every exact declaration.
+		}
+		form, known := asmGeneratedFloatPoolForms[statement[0].text]
+		if !known {
+			continue
+		}
+		operands := asmDataOperands(statement[1:])
+		if len(operands) < 1 || len(operands[0]) < 2 || operands[0][0].kind != '$' {
+			continue
+		}
+		value, floating, err := asmGeneratedFloatPoolConstant(operands[0][1:])
+		if err != nil {
+			return nil, err
+		}
+		if !floating {
+			continue // An integer immediate or symbolic address is not TYPE_FCONST.
+		}
+		if len(operands) != 2 || textOrdinal < 0 || textOrdinal >= len(texts) {
+			return nil, contextError("generated float pool FCONST lacks its exact source TEXT/operand role")
+		}
+		if form.move && math.Float64bits(value) == 0 && asmGeneratedFloatPoolZeroXOR(operands[1]) {
+			continue // The original float64 +0, not rounded f32 zero, selects XORPS.
+		}
+		bits := math.Float64bits(value)
+		if form.width == 4 {
+			bits = uint64(math.Float32bits(float32(value)))
+		}
+		name := fmt.Sprintf("$f%d.%0*x", form.width*8, form.width*2, bits)
+		pool, present := byName[name]
+		if !present {
+			matches := definitions[name]
+			if len(matches) != 1 || !validGeneratedFloatPoolDefinition(matches[0], form.width, bits, target) {
+				return nil, contextError("generated float pool source/IEEE/name/hash/definition differs")
+			}
+			pool = len(pools)
+			byName[name] = pool
+			pools = append(pools, ASMGeneratedFloatPool{Definition: matches[0]})
+		}
+		text := texts[textOrdinal]
+		uses[text.ObjectOrdinal] = append(uses[text.ObjectOrdinal], asmGeneratedFloatPoolUse{pool: pool,
+			owner: ASMGeneratedFloatPoolOwner{StatementOrdinal: ordinal, TextSourceOrdinal: textOrdinal,
+				TextObjectOrdinal: text.ObjectOrdinal, TextNamespace: text.Namespace,
+				TextRelative: text.Relative, TextIndex: text.Index, Opcode: statement[0].text,
+				SourceFloat64Bits: math.Float64bits(value)}})
+	}
+	if textOrdinal+1 != len(texts) {
+		return nil, contextError("generated float pool source omitted its complete TEXT inventory")
+	}
+	if len(pools) == 0 {
+		return nil, nil // Neither a symbol prefix nor its payload classifies DATA.
+	}
+	if err := joinGeneratedFloatPoolOwners(member, pools, byName, uses, target); err != nil {
+		return nil, err
+	}
+	return pools, nil
+}
+
+func asmGeneratedFloatPoolConstant(tokens []asmDataToken) (float64, bool, error) {
+	floating := false
+	for _, token := range tokens {
+		floating = floating || token.kind == scanner.Float
+	}
+	if !floating {
+		return 0, false, nil
+	}
+	// Reuse the bounded Go assembler float grammar: float token, recursive
+	// signs and parentheses only. ParseFloat handles hexadecimal/underscores;
+	// integer-only and binary expressions never acquire this metadata role.
+	parser := asmDataExpression{tokens: tokens}
+	value := parser.floating()
+	if parser.err != nil || parser.pos != len(tokens) {
+		return 0, false, contextError("generated float pool has an unknown FCONST expression")
+	}
+	return value, true, nil
+}
+
+func asmGeneratedFloatPoolZeroXOR(operand []asmDataToken) bool {
+	if len(operand) != 1 || operand[0].kind != scanner.Ident || !strings.HasPrefix(operand[0].text, "X") {
+		return false
+	}
+	register, err := strconv.Atoi(strings.TrimPrefix(operand[0].text, "X"))
+	return err == nil && register >= 0 && register <= 15 && operand[0].text == fmt.Sprintf("X%d", register)
+}
+
+func validGeneratedFloatPoolDefinition(definition ASMDataDefinition, width uint32, bits uint64, target string) bool {
+	align := width
+	if width == 8 && strings.HasSuffix(target, "/386") {
+		align = 4
+	}
+	var data [8]byte
+	binary.LittleEndian.PutUint64(data[:], bits)
+	return definition.Namespace == TextSymbolHashed64 && definition.ABI == 0 && definition.Kind == 3 &&
+		definition.Flags == 2 && definition.Flags2 == 0 && definition.Size == width && definition.Align == align &&
+		len(definition.Relocations) == 0 && bytes.Equal(definition.Data, data[:width]) && bytes.Equal(definition.Hash, data[:])
+}
+
+func sameGeneratedFloatPools(first, second []ASMGeneratedFloatPool) bool {
+	normalize := func(values []ASMGeneratedFloatPool) []ASMGeneratedFloatPool {
+		result := append([]ASMGeneratedFloatPool(nil), values...)
+		for index := range result {
+			result[index].Definition.DataOffset = 0 // Full member observations retain physical offsets.
+		}
+		return result
+	}
+	return reflect.DeepEqual(normalize(first), normalize(second))
+}
+
+func asmDataWithoutGeneratedFloatPools(member ASMDataMember, pools []ASMGeneratedFloatPool) ASMDataMember {
+	if len(pools) == 0 {
+		return member
+	}
+	byIndex := make(map[uint32]ASMDataDefinition, len(pools))
+	for _, pool := range pools {
+		byIndex[pool.Definition.Index] = pool.Definition
+	}
+	definitions := make([]ASMDataDefinition, 0, len(member.Definitions))
+	for _, definition := range member.Definitions {
+		pool, present := byIndex[definition.Index]
+		if !present || !reflect.DeepEqual(pool, definition) {
+			definitions = append(definitions, definition)
+		}
+	}
+	member.Definitions = definitions
+	return member // Only the explicit DATA join sees this partition, never a literal reader.
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool_go127_test.go b/internal/gostaticstorage/assembly_generated_float_pool_go127_test.go
new file mode 100644
index 000000000..4e907c32b
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool_go127_test.go
@@ -0,0 +1,370 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent obj6.progedit directory, not an implementation permission map.
+var asmGeneratedFloatPoolNames = [][]string{
+	{
+		"MOVSS", "VMOVSS", "FMOVF", "FADDF", "FSUBF", "FSUBRF", "FMULF", "FDIVF", "FDIVRF",
+		"FCOMF", "FCOMFP", "ADDSS", "SUBSS", "MULSS", "DIVSS", "COMISS", "UCOMISS",
+	},
+	{
+		"MOVSD", "VMOVSD", "FMOVD", "FADDD", "FSUBD", "FSUBRD", "FMULD", "FDIVD", "FDIVRD",
+		"FCOMD", "FCOMDP", "ADDSD", "SUBSD", "MULSD", "DIVSD", "COMISD", "UCOMISD",
+	},
+}
+
+var asmGeneratedFloatPoolValues = []struct {
+	text     string
+	bits32   uint32
+	bits64   uint64
+	positive bool
+}{
+	{"0.0", 0, 0, true},
+	{"-0.0", 0x80000000, 0x8000000000000000, false},
+	{"1.25", 0x3fa00000, 0x3ff4000000000000, false},
+	{"-2.5", 0xc0200000, 0xc004000000000000, false},
+	{"1.000000059604644775390625", 0x3f800000, 0x3ff0000010000000, false},
+	{"1e-50", 0, 0x358dee7a4ad4b81f, false},
+	{"1e40", 0x7f800000, 0x483d6329f1c35ca5, false},
+	{"(+(-2.5))", 0xc0200000, 0xc004000000000000, false},
+	{"0x1.4p+0", 0x3fa00000, 0x3ff4000000000000, false},
+	{"1.2_5", 0x3fa00000, 0x3ff4000000000000, false},
+	{"-(-0.0)", 0, 0, true},
+}
+
+type asmGeneratedFloatPoolCase struct {
+	name, instruction, pool string
+	width                   uint32
+	bits, sourceBits        uint64
+}
+
+func asmGeneratedFloatPoolSource(arch, pkg string) ([]byte, []byte, []asmGeneratedFloatPoolCase) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package poolfixture\n")
+	var cases []asmGeneratedFloatPoolCase
+	appendCase := func(op string, size int, value int, register int) {
+		literal := asmGeneratedFloatPoolValues[value]
+		index := len(cases)
+		name, objectName := fmt.Sprintf("·Case%d", index), fmt.Sprintf("%s.Case%d", pkg, index)
+		if index%11 == 0 {
+			name, objectName = fmt.Sprintf("private%d<>", index), fmt.Sprintf("private%d", index)
+		} else {
+			fmt.Fprintf(&declarations, "func Case%d()\n", index)
+		}
+		destination := fmt.Sprintf("X%d", register)
+		if strings.HasPrefix(op, "F") {
+			destination = "F0"
+		}
+		instruction := fmt.Sprintf("%s $%s,%s", op, literal.text, destination)
+		bits := literal.bits64
+		if size == 4 {
+			bits = uint64(literal.bits32)
+		}
+		pool := fmt.Sprintf("$f%d.%0*x", size*8, size*2, bits)
+		if strings.Contains(op, "MOVS") && literal.positive && register < 16 {
+			pool = "" // The original float64 +0 bits select legacy XORPS.
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+		cases = append(cases, asmGeneratedFloatPoolCase{objectName, instruction, pool, uint32(size), bits, literal.bits64})
+	}
+	for precision, names := range asmGeneratedFloatPoolNames {
+		for _, op := range names {
+			for value := range asmGeneratedFloatPoolValues {
+				appendCase(op, 4+4*precision, value, 0)
+			}
+		}
+		for _, op := range names[:2] {
+			for _, register := range []int{7, 15, 16, 31} {
+				if arch == "386" && register == 15 || !strings.HasPrefix(op, "V") && register >= 16 {
+					continue // Independent actual Go mode/register restrictions.
+				}
+				for _, value := range []int{0, 1} {
+					appendCase(op, 4+4*precision, value, register)
+				}
+			}
+		}
+	}
+	// This ordinary explicit DATA remains the only actual source layout.
+	source.WriteString("DATA ordinary<>(SB)/8,$0x1122334455667788\nGLOBL ordinary<>(SB),8,$8\n")
+	return []byte(source.String()), []byte(declarations.String()), cases
+}
+
+func asmGeneratedFloatPoolOfficialDirectory(t *testing.T, root string) {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(root, "src/cmd/internal/obj/x86/obj6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var actual []string
+	ast.Inspect(file, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok || len(clause.List) == 0 {
+			return true
+		}
+		first, ok := clause.List[0].(*ast.Ident)
+		if !ok || first.Name != "AMOVSS" && first.Name != "AFMOVF" && first.Name != "AMOVSD" && first.Name != "AFMOVD" {
+			return true
+		}
+		for _, expression := range clause.List {
+			identifier, ok := expression.(*ast.Ident)
+			if !ok {
+				t.Fatal("actual scalar pool rewrite has an unknown opcode selector")
+			}
+			actual = append(actual, strings.TrimPrefix(identifier.Name, "A"))
+		}
+		return true
+	})
+	expected := append(append([]string(nil), asmGeneratedFloatPoolNames[0]...), asmGeneratedFloatPoolNames[1]...)
+	if !reflect.DeepEqual(actual, expected) || len(actual) != 34 {
+		t.Fatal("the independent complete Go FCONST rewrite directory changed", actual)
+	}
+}
+
+func asmGeneratedFloatPoolOriginal(t *testing.T, data, text []byte) []ASMDataMember {
+	t.Helper()
+	var members []ASMDataMember
+	var texts []TextMember
+	if err := json.Unmarshal(data, &members); err != nil {
+		t.Fatal("stock Go complete DATA reader", err)
+	}
+	if err := json.Unmarshal(text, &texts); err != nil || len(texts) != len(members) {
+		t.Fatal("stock Go complete TEXT reader", err)
+	}
+	for index := range members {
+		members[index].Texts = texts[index].Texts
+	}
+	return members
+}
+
+func asmGeneratedFloatPoolStockControls(t *testing.T, member ASMDataMember, cases []asmGeneratedFloatPoolCase, arch string) {
+	t.Helper()
+	wanted := map[string]bool{"ordinary": true}
+	for _, row := range cases {
+		if row.pool != "" {
+			wanted[row.pool] = true
+		}
+	}
+	definitions := make(map[string]ASMDataDefinition)
+	for _, definition := range member.Definitions {
+		if !wanted[definition.Name] {
+			continue // Whole anonymous/AUX records remain in the independent object comparisons.
+		}
+		if definition.Name != "ordinary" {
+			t.Logf("actual generated definition name=%q ns=%d relative=%d index=%d ABI=%d kind=%d flags=%d/%d size=%d align=%d data=%x hash=%x relocs=%v",
+				definition.Name, definition.Namespace, definition.Relative, definition.Index, definition.ABI, definition.Kind,
+				definition.Flags, definition.Flags2, definition.Size, definition.Align, definition.Data, definition.Hash, definition.Relocations)
+		}
+		if _, exists := definitions[definition.Name]; exists {
+			t.Fatal("the stock assembler repeated an object-local definition name")
+		}
+		definitions[definition.Name] = definition
+	}
+	texts := make(map[string]TextRecord)
+	for _, text := range member.Texts {
+		texts[text.Name] = text
+	}
+	if len(texts) != len(cases) || len(definitions) != 14 || len(wanted) != 14 {
+		t.Fatal("actual complete TEXT or deduplicated DATA inventory differs", len(texts), len(cases), len(definitions))
+	}
+	for _, row := range cases {
+		text, present := texts[row.name]
+		if !present {
+			t.Fatal("stock reader lost an actual source owner", row.name)
+		}
+		if row.pool == "" {
+			if len(text.Relocations) != 0 || !bytes.Contains(text.Code, []byte{0x0f, 0x57}) {
+				t.Fatal("original positive-zero MOV did not become relocation-free legacy XORPS", row.instruction)
+			}
+			continue
+		}
+		definition, present := definitions[row.pool]
+		align := row.width
+		if arch == "386" && align == 8 {
+			align = 4
+		}
+		var expected [8]byte
+		binary.LittleEndian.PutUint64(expected[:], row.bits)
+		if !present || definition.Namespace != TextSymbolHashed64 || definition.ABI != 0 || definition.Kind != 3 ||
+			definition.Flags != 2 || definition.Flags2 != 0 || definition.Size != row.width || definition.Align != align ||
+			!bytes.Equal(definition.Data, expected[:row.width]) || !bytes.Equal(definition.Hash, expected[:]) || len(definition.Relocations) != 0 {
+			t.Fatal("actual float pool differs from the independent Go writer/IEEE directory", row.instruction, definition)
+		}
+		if len(text.Relocations) != 1 {
+			t.Fatal("original scalar FCONST lost its unique actual pool relocation", row.instruction, text.Relocations)
+		}
+		relocation := text.Relocations[0]
+		kind := uint16(14) // Actual amd64 R_PCREL; mode32 retains R_ADDR.
+		if arch == "386" {
+			kind = 1
+		}
+		if relocation.Type != kind || relocation.Size != 4 || relocation.Add != 0 ||
+			relocation.Target.PackageIndex != 2147483646 || relocation.Target.SymbolIndex != definition.Relative ||
+			relocation.Target.Name != definition.Name || !relocation.Target.ABIKnown || relocation.Target.ABI != 0 {
+			t.Fatal("actual source owner and object-local pool reference differ", row.instruction, relocation)
+		}
+	}
+}
+
+func asmGeneratedFloatPoolMetadataControls(t *testing.T, source ASMDataSourceObservation, cases []asmGeneratedFloatPoolCase) {
+	t.Helper()
+	if len(source.GeneratedFloatPools) != 13 || len(source.TextOrder) != len(cases) {
+		t.Fatal("the complete deduplicated metadata or source TEXT directory differs")
+	}
+	byOwner := make(map[int]ASMGeneratedFloatPoolOwner)
+	for _, pool := range source.GeneratedFloatPools {
+		for _, owner := range pool.Owners {
+			if owner.TextSourceOrdinal < 0 || owner.TextSourceOrdinal >= len(cases) {
+				t.Fatal("generated pool owner escaped the complete source", owner)
+			}
+			row := cases[owner.TextSourceOrdinal]
+			text := source.TextOrder[owner.TextSourceOrdinal]
+			actual := source.Original.Texts[text.ObjectOrdinal]
+			if _, duplicate := byOwner[owner.TextSourceOrdinal]; duplicate || pool.Definition.Name != row.pool ||
+				owner.StatementOrdinal != 3*owner.TextSourceOrdinal+1 || owner.TextObjectOrdinal != text.ObjectOrdinal ||
+				owner.TextNamespace != text.Namespace || owner.TextRelative != text.Relative || owner.TextIndex != text.Index ||
+				actual.Name != row.name || owner.Opcode != strings.Fields(row.instruction)[0] || owner.SourceFloat64Bits != row.sourceBits ||
+				owner.RelocationOrdinal != 0 || len(actual.Relocations) != 1 || !reflect.DeepEqual(owner.Relocation, actual.Relocations[0]) {
+				t.Fatal("the FCONST/TEXT/physical-relocation metadata association differs", row, owner)
+			}
+			byOwner[owner.TextSourceOrdinal] = owner
+		}
+	}
+	for ordinal, row := range cases {
+		_, associated := byOwner[ordinal]
+		if associated != (row.pool != "") {
+			t.Fatal("source pool and original positive-zero XOR roles were confused", row)
+		}
+	}
+}
+
+func TestGoSDKASMGeneratedFloatPoolWholeFamilyObservation(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	root := filepath.Dir(filepath.Dir(driver))
+	asmGeneratedFloatPoolOfficialDirectory(t, root)
+	if err := GeneratedFloatPoolSources(runtime.Version(), func(role string) ([]byte, error) {
+		return os.ReadFile(filepath.Join(root, filepath.FromSlash(role)))
+	}); err != nil {
+		t.Fatal("the independent actual SDK producer sources differ", err)
+	}
+	dataOracle := officialReaderForSource(t, driver, sdkASMDataReaderSource)
+	textOracle := officialReaderForSource(t, driver, sdkTextReaderSource)
+	builtin, err := os.ReadFile(filepath.Join(root, builtinSourceRole))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "darwin/amd64", "windows/386", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			_, arch, _ := strings.Cut(target, "/")
+			env := fixtureEnv(t, target)
+			consumer := filepath.Join(directory, strings.ReplaceAll(target, "/", "-"))
+			if err := os.Mkdir(consumer, 0700); err != nil {
+				t.Fatal(err)
+			}
+			pkg := fixtureModule + "/" + filepath.Base(consumer)
+			source, declarations, cases := asmGeneratedFloatPoolSource(arch, pkg)
+			for name, data := range map[string][]byte{"pool.go": declarations, "pool.s": source} {
+				if err := os.WriteFile(filepath.Join(consumer, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			selection := run(t, driver, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				ImportPath, Export string
+				SFiles             []string
+			}
+			if json.Unmarshal(selection, &selected) != nil || selected.ImportPath != pkg || !reflect.DeepEqual(selected.SFiles, []string{"pool.s"}) {
+				t.Fatal("actual complete first-party assembly selection differs")
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			data := run(t, dataOracle, consumer, env, selected.Export)
+			text := run(t, textOracle, consumer, env, selected.Export)
+			actual := asmGeneratedFloatPoolOriginal(t, data, text)
+			if len(actual) != 3 {
+				t.Fatal("actual original archive lost its complete member inventory", len(actual))
+			}
+			request := SDKASMDataObservationRequest{PackagePath: pkg, Target: target, Archive: archive, BuiltinSource: builtin}
+			expanded := bytes.ReplaceAll(source, []byte(","), []byte(", "))
+			if err := os.WriteFile(filepath.Join(consumer, "expanded.asm"), expanded, 0600); err != nil {
+				t.Fatal(err)
+			}
+			input := SDKASMDataSource{Name: "pool.s", Original: source, Expanded: expanded}
+			artifacts := map[string][]byte{"source-pool.s": source, "source-pool.go": declarations,
+				"expanded.asm": expanded, "original.a": archive, "selection.json": selection, "data-sdk.json": data, "text-sdk.json": text}
+			for _, role := range []string{"original", "expanded"} {
+				name := "pool.s"
+				if role == "expanded" {
+					name = "expanded.asm"
+				}
+				arguments := []string{"tool", "asm", "-std"}
+				if target == "darwin/amd64" {
+					arguments = append(arguments, "-shared")
+				}
+				arguments = append(arguments, "-p", pkg, "-o", role+".o", name)
+				run(t, driver, consumer, env, arguments...)
+				object, err := os.ReadFile(filepath.Join(consumer, role+".o"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if role == "original" {
+					input.OriginalObject = object
+				} else {
+					input.ExpandedObject = object
+				}
+				artifacts[role+".o"] = object
+				artifacts[role+"-data-sdk.json"] = run(t, dataOracle, consumer, env, role+".o")
+				artifacts[role+"-text-sdk.json"] = run(t, textOracle, consumer, env, role+".o")
+			}
+			request.Sources = []SDKASMDataSource{input}
+			retainTextArtifact(t, target, "generated-float-pool", artifacts)
+			t.Run("stock-reader-complete-family", func(t *testing.T) {
+				asmGeneratedFloatPoolStockControls(t, actual[2], cases, arch)
+				for _, role := range []string{"original", "expanded"} {
+					member := asmGeneratedFloatPoolOriginal(t, artifacts[role+"-data-sdk.json"], artifacts[role+"-text-sdk.json"])
+					if len(member) != 1 || !sameASMDataObjects(member[0], actual[2]) {
+						t.Fatal("independent original/expanded/archive DATA/TEXT inventory differs", role)
+					}
+				}
+			})
+			t.Run("complete-source-join-without-literal-authority", func(t *testing.T) {
+				observation, err := ObserveX86SDKASMData(request)
+				if err != nil || observation == nil {
+					t.Fatal("actual assembler-created float pool is absent from the complete source/object observation", err)
+				}
+				if !reflect.DeepEqual(observation.Members, actual) || len(observation.Sources) != 1 ||
+					len(observation.Sources[0].Layouts) != 1 || len(observation.Sources[0].ExpandedLayouts) != 1 ||
+					observation.Sources[0].Layouts[0].Name != "ordinary" || len(observation.Sources[0].GeneratedFuncdata) != 0 {
+					t.Fatal("generated float pools replaced whole objects, explicit DATA or FUNCDATA roles")
+				}
+				asmGeneratedFloatPoolMetadataControls(t, observation.Sources[0], cases)
+				images, err := ReadonlyLiteralDataInitializers(observation)
+				if err != nil || len(images) != 1 || images[0].Definition.Name != "ordinary" ||
+					!bytes.Equal(images[0].Initial, []byte{0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11}) {
+					t.Fatal("generated pools entered the image plan or blocked ordinary private RODATA", images, err)
+				}
+			})
+			t.Run("complete-source-and-binary-guards", func(t *testing.T) {
+				asmGeneratedFloatPoolGuards(t, request)
+			})
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool_guards_go127_test.go b/internal/gostaticstorage/assembly_generated_float_pool_guards_go127_test.go
new file mode 100644
index 000000000..17d20b864
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool_guards_go127_test.go
@@ -0,0 +1,173 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"strings"
+	"testing"
+)
+
+// Alter all three actual objects together. Otherwise their ordinary inequality
+// could hide a missing generated-source, payload, hash or relocation check.
+func asmGeneratedFloatPoolMutateAll(t *testing.T, request *SDKASMDataObservationRequest, mutation string) {
+	t.Helper()
+	members, err := archiveMembers(request.Archive)
+	if err != nil || len(members) != 3 || len(request.Sources) != 1 {
+		t.Fatal("incomplete actual synchronized mutation fixture", err)
+	}
+	for _, object := range [][]byte{members[2].data, request.Sources[0].OriginalObject, request.Sources[0].ExpandedObject} {
+		body, err := objectBody(object, request.Target)
+		if err != nil {
+			t.Fatal(err)
+		}
+		view, err := checkedObject(body, sdkAssemblyObjectFlags(request.Target), true)
+		if err != nil {
+			t.Fatal("original synchronized object precondition", err)
+		}
+		symbols, err := view.indexedSymbols()
+		if err != nil {
+			t.Fatal(err)
+		}
+		var pool uint32
+		var relative uint32
+		found := false
+		for _, symbol := range symbols {
+			if symbol.Name == "$f32.80000000" {
+				pool, relative, found = symbol.Index, symbol.Relative, true
+			}
+		}
+		if !found {
+			t.Fatal("actual negative-zero pool witness is absent")
+		}
+		block := func(index int) int { return int(binary.LittleEndian.Uint32(body[20+index*4:])) }
+		symbol := block(3) + int(pool)*21
+		data := block(16) + int(view.indices[2][pool])
+		hash := block(9) + int(relative)*8
+		relocation := -1
+		for _, candidate := range symbols {
+			if candidate.Kind != 1 {
+				continue
+			}
+			for index := view.indices[0][candidate.Index]; index < view.indices[0][candidate.Index+1]; index++ {
+				offset := block(14) + int(index)*23
+				if binary.LittleEndian.Uint32(body[offset+15:]) == 2147483646 &&
+					binary.LittleEndian.Uint32(body[offset+19:]) == relative {
+					relocation = offset
+					break
+				}
+			}
+			if relocation >= 0 {
+				break
+			}
+		}
+		if relocation < 0 {
+			t.Fatal("actual source owner relocation is absent")
+		}
+		switch mutation {
+		case "pool-name":
+			name := int(binary.LittleEndian.Uint32(body[symbol+4:]))
+			body[name+len("$f32.80000000")-1] = '1'
+		case "pool-ABI":
+			body[symbol+8] = 1
+		case "pool-kind":
+			body[symbol+10] = 5
+		case "pool-local-flag":
+			body[symbol+11] &^= 2
+		case "pool-duplicate-flag":
+			body[symbol+11] |= 1
+		case "pool-flags2":
+			body[symbol+12] = 1
+		case "pool-size":
+			binary.LittleEndian.PutUint32(body[symbol+13:], 8)
+		case "pool-alignment":
+			binary.LittleEndian.PutUint32(body[symbol+17:], 8)
+		case "pool-bytes":
+			body[data] ^= 1
+		case "pool-hash":
+			body[hash] ^= 1
+		case "pool-bytes-and-matching-hash":
+			body[data] ^= 1
+			body[hash] ^= 1
+		case "pool-namespace":
+			binary.LittleEndian.PutUint32(body[20+5*4:], uint32(block(5)-21))
+		case "owner-offset":
+			body[relocation]++
+		case "owner-width":
+			body[relocation+4] = 1
+		case "owner-addend":
+			body[relocation+7] = 1
+		case "owner-type":
+			kind := uint16(1)
+			if strings.HasSuffix(request.Target, "/386") {
+				kind = 14
+			}
+			binary.LittleEndian.PutUint16(body[relocation+5:], kind)
+		case "owner-namespace":
+			binary.LittleEndian.PutUint32(body[relocation+15:], 2147483645)
+		case "owner-index":
+			binary.LittleEndian.PutUint32(body[relocation+19:], relative+1)
+		default:
+			t.Fatal("unknown synchronized object negative", mutation)
+		}
+	}
+}
+
+func asmGeneratedFloatPoolGuards(t *testing.T, original SDKASMDataObservationRequest) {
+	t.Helper()
+	for _, mutation := range []string{
+		"pool-name", "pool-ABI", "pool-kind", "pool-local-flag", "pool-duplicate-flag", "pool-flags2",
+		"pool-size", "pool-alignment", "pool-bytes", "pool-hash", "pool-bytes-and-matching-hash", "pool-namespace",
+		"owner-offset", "owner-width", "owner-addend", "owner-type", "owner-namespace", "owner-index",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			changed := cloneASMDataRequest(t, original)
+			asmGeneratedFloatPoolMutateAll(t, &changed, mutation)
+			if bytes.Equal(changed.Archive, original.Archive) {
+				t.Fatal("negative failed to change the actual complete archive")
+			}
+			if observation, err := ObserveX86SDKASMData(changed); !errors.Is(err, ErrContext) || observation != nil {
+				t.Fatal("forged generated identity/payload/relocation acquired a source/object observation", err)
+			}
+		})
+	}
+	for name, replacement := range map[string]string{
+		"source-literal":        "MOVSS $-1.0",
+		"source-width":          "MOVSD $-0.0",
+		"source-without-FCONST": "XORPS X0",
+		"prefix-without-FCONST": "MOVSS \"$f32.80000000\"(SB)",
+		"integer-only":          "MOVSS $0",
+		"parenthesized-integer": "MOVSS $(0)",
+		"binary-floating":       "MOVSS $(1.0*0.0)",
+		"mixed-floating":        "MOVSS $(1+0.0)",
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneASMDataRequest(t, original)
+			source := bytes.Replace(changed.Sources[0].Original, []byte("MOVSS $-0.0"), []byte(replacement), 1)
+			if bytes.Equal(source, changed.Sources[0].Original) {
+				t.Fatal("actual source mutation witness is absent")
+			}
+			changed.Sources[0].Original = source
+			changed.Sources[0].Expanded = bytes.ReplaceAll(source, []byte(","), []byte(", "))
+			if observation, err := ObserveX86SDKASMData(changed); !errors.Is(err, ErrContext) || observation != nil {
+				t.Fatal("an unmatched FCONST source acquired a generated-pool owner", err)
+			}
+		})
+	}
+	for _, statement := range []string{"GLOBL ordinary<>(SB),8,$8", "TEXT ·Case1(SB),4,$0-0"} {
+		t.Run("missing-"+strings.Fields(statement)[0], func(t *testing.T) {
+			changed := cloneASMDataRequest(t, original)
+			source := bytes.Replace(changed.Sources[0].Original, []byte(statement), []byte("NOP"), 1)
+			if bytes.Equal(source, changed.Sources[0].Original) {
+				t.Fatal("actual whole source inventory witness is absent")
+			}
+			changed.Sources[0].Original = source
+			changed.Sources[0].Expanded = bytes.ReplaceAll(source, []byte(","), []byte(", "))
+			if observation, err := ObserveX86SDKASMData(changed); !errors.Is(err, ErrContext) || observation != nil {
+				t.Fatal("an unknown DATA definition or missing source TEXT borrowed the pool partition", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool_owners.go b/internal/gostaticstorage/assembly_generated_float_pool_owners.go
new file mode 100644
index 000000000..405813dea
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool_owners.go
@@ -0,0 +1,74 @@
+package gostaticstorage
+
+import "strings"
+
+func generatedFloatPoolReference(definition ASMDataDefinition, ref TextReference) bool {
+	return ref.PackageIndex == 2147483646 && ref.SymbolIndex == definition.Relative &&
+		ref.Name == definition.Name && ref.ABIKnown && ref.ABI == definition.ABI && (!ref.KindKnown || ref.Kind == definition.Kind)
+}
+
+// Source order selects actual pool relocations inside each independently
+// associated TEXT. Do not infer a producer from a name or search another TEXT
+// for convenient matching bytes. Every pool relocation must have one owner.
+func joinGeneratedFloatPoolOwners(member ASMDataMember, pools []ASMGeneratedFloatPool, byName map[string]int, uses [][]asmGeneratedFloatPoolUse, target string) error {
+	relocationType := uint16(14) // Actual x86-64 R_PCREL; 386 uses R_ADDR.
+	if strings.HasSuffix(target, "/386") {
+		relocationType = 1
+	}
+	byRelative := make(map[uint32]int, len(pools))
+	for ordinal, pool := range pools {
+		byRelative[pool.Definition.Relative] = ordinal
+	}
+	associated := func(ref TextReference) bool {
+		_, named := byName[ref.Name]
+		_, indexed := byRelative[ref.SymbolIndex]
+		return named || ref.PackageIndex == 2147483646 && indexed
+	}
+	for ordinal, text := range member.Texts {
+		use, position := 0, 0
+		lastEnd := int64(0)
+		for relocationOrdinal, relocation := range text.Relocations {
+			if !associated(relocation.Target) {
+				continue
+			}
+			if use >= len(uses[ordinal]) {
+				return contextError("generated float pool has an extra ordinary TEXT reference without a source FCONST")
+			}
+			expected := uses[ordinal][use]
+			definition := pools[expected.pool].Definition
+			if !generatedFloatPoolReference(definition, relocation.Target) || relocation.Type != relocationType ||
+				relocation.Size != 4 || relocation.Add != 0 || relocation.Offset < lastEnd ||
+				relocation.Offset > text.Size-relocation.Size {
+				return contextError("generated float pool source and actual object-local relocation differ")
+			}
+			end := relocation.Offset + relocation.Size
+			for position < len(text.Positions) && text.Positions[position].End <= relocation.Offset {
+				position++
+			}
+			if position == len(text.Positions) || text.Positions[position].Start > relocation.Offset ||
+				text.Positions[position].End < end || text.Positions[position].File == "" || text.Positions[position].Line <= 0 {
+				return contextError("generated float pool relocation crosses its actual source-PC interval")
+			}
+			expected.owner.RelocationOrdinal, expected.owner.Relocation = relocationOrdinal, relocation
+			pools[expected.pool].Owners = append(pools[expected.pool].Owners, expected.owner)
+			use++
+			lastEnd = end
+		}
+		if use != len(uses[ordinal]) {
+			return contextError("generated float pool source has no corresponding actual TEXT relocation")
+		}
+		for _, auxiliary := range text.Auxiliary {
+			if associated(auxiliary.Target) {
+				return contextError("generated float pool is an unassociated TEXT auxiliary target")
+			}
+		}
+	}
+	for _, definition := range member.Definitions {
+		for _, relocation := range definition.Relocations {
+			if associated(relocation.Target) {
+				return contextError("generated float pool is an ordinary DATA relocation target")
+			}
+		}
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool_schema.go b/internal/gostaticstorage/assembly_generated_float_pool_schema.go
new file mode 100644
index 000000000..f252e9491
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool_schema.go
@@ -0,0 +1,31 @@
+package gostaticstorage
+
+// Bind the actual FCONST producer, IEEE definition attributes, Hash64 writer,
+// namespaces and relocation kinds through the existing live guarded reader.
+// Offline metadata alone authenticates no source or executable tool identity.
+var generatedFloatPoolSourceRoles = map[string]string{
+	"src/cmd/internal/obj/x86/obj6.go":     "01fda250221982020a6cd368d95c47f8eda1a987a4113425fe28de3dade992d3",
+	"src/cmd/internal/obj/sym.go":          "2bb2646a6ccff23aa42d8c4960be7cf82af5570ae5a83a1a355b7b822ee2149d",
+	"src/cmd/internal/obj/objfile.go":      "803546227c02cf46bfa4158be3dfd8067e7457f4e4f78349cb6d42c700b2fcb7",
+	"src/cmd/internal/goobj/objfile.go":    "caf835a17e23aa02cae9bda6e8723d8be359846fc4453bd53f3a3947744b938a",
+	"src/cmd/internal/objabi/symkind.go":   "de287864b7ff9a3614becc538cbabdccdecc030a848aad5d5bbef6ec7ec5c225",
+	"src/cmd/internal/objabi/reloctype.go": "49bebd30a27d05a24de77398ab524dfbeb0630c8b88c06646c1e4734e4f1fc9d",
+}
+
+// GeneratedFloatPoolSources checks observation-only producer source identity.
+// It does not make generated pools eligible for literal or numerical readers.
+func GeneratedFloatPoolSources(version string, read func(string) ([]byte, error)) error {
+	if version != "go1.27.1" && version != "go1.27.2" && version != "go1.27.3" || read == nil {
+		return contextError("unregistered generated float-pool source/schema")
+	}
+	for role, expected := range generatedFloatPoolSourceRoles {
+		data, err := read(role)
+		if err != nil {
+			return err
+		}
+		if digest(data) != expected {
+			return contextError("generated float-pool producer source differs from the registered actual SDK")
+		}
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/assembly_generated_float_pool_test.go b/internal/gostaticstorage/assembly_generated_float_pool_test.go
new file mode 100644
index 000000000..916dbb9f5
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_float_pool_test.go
@@ -0,0 +1,139 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"math"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Synthetic metadata unit fixture only: the Go1.27 whole-family test supplies
+// independently assembled and stock-reader-observed source/object evidence.
+func generatedFloatPoolUnitFixture(t *testing.T) ([]byte, ASMDataMember, []ASMSourceText) {
+	t.Helper()
+	source := []byte("TEXT ·value(SB),4,$0-0\nMOVSS $-0.0,X0\nRET\n")
+	definition := ASMDataDefinition{Namespace: TextSymbolHashed64, Name: "$f32.80000000", Kind: 3, Flags: 2,
+		Size: 4, Align: 4, Data: []byte{0, 0, 0, 0x80}, Hash: []byte{0, 0, 0, 0x80, 0, 0, 0, 0}}
+	text := TextRecord{Namespace: TextSymbolNonpkgDefinition, Index: 1, Name: "fixture.value", Kind: 1, Size: 9,
+		Code:      []byte{0xf3, 0x0f, 0x10, 0x05, 0, 0, 0, 0, 0xc3},
+		Positions: []TextPosition{{Start: 0, End: 8, File: "pool.s", Line: 2}, {Start: 8, End: 9, File: "pool.s", Line: 3}},
+		Relocations: []TextRelocation{{Offset: 4, Size: 4, Type: 14,
+			Target: TextReference{PackageIndex: 2147483646, Name: definition.Name, ABIKnown: true}}}}
+	member := ASMDataMember{Flags: sdkAssemblyObjectFlags("linux/amd64"),
+		Definitions: []ASMDataDefinition{definition}, Texts: []TextRecord{text}}
+	order, err := ASMSourceTextOrder(source, "fixture", member)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source, member, order
+}
+
+func TestASMGeneratedFloatPoolMetadataOnlyAndCompleteOwners(t *testing.T) {
+	source, member, texts := generatedFloatPoolUnitFixture(t)
+	pools, err := generatedASMFloatPools(source, "linux/amd64", member, texts)
+	if err != nil || len(pools) != 1 || len(pools[0].Owners) != 1 || !reflect.DeepEqual(pools[0].Definition, member.Definitions[0]) {
+		t.Fatal("a complete synthetic source/object metadata association was lost", pools, err)
+	}
+	owner := pools[0].Owners[0]
+	if owner.StatementOrdinal != 1 || owner.TextSourceOrdinal != 0 || owner.TextObjectOrdinal != 0 ||
+		owner.TextNamespace != TextSymbolNonpkgDefinition || owner.TextIndex != 1 || owner.Opcode != "MOVSS" ||
+		owner.SourceFloat64Bits != 0x8000000000000000 || owner.RelocationOrdinal != 0 || !reflect.DeepEqual(owner.Relocation, member.Texts[0].Relocations[0]) {
+		t.Fatal("the source, original IEEE value and complete physical owner were not retained", owner)
+	}
+	if _, err := joinASMDataLayouts(nil, member); !errors.Is(err, ErrContext) {
+		t.Fatal("ordinary DATA became permissive for an unconsumed generated definition", err)
+	}
+	partition := asmDataWithoutGeneratedFloatPools(member, pools)
+	if layouts, err := joinASMDataLayouts(nil, partition); err != nil || len(layouts) != 0 || len(member.Definitions) != 1 {
+		t.Fatal("metadata partition created a source DATA layout or removed the complete observation", err)
+	}
+	partition.Definitions = append(partition.Definitions, ASMDataDefinition{Name: "$f32.unknown", Kind: 3, Namespace: TextSymbolHashed64})
+	if _, err := joinASMDataLayouts(nil, partition); !errors.Is(err, ErrContext) {
+		t.Fatal("unknown prefixed DATA inherited a metadata partition", err)
+	}
+	changed := []byte(strings.Replace(string(source), "MOVSS $-0.0,X0", "MOVSS \"$f32.80000000\"(SB),X0", 1))
+	withoutProducer, err := generatedASMFloatPools(changed, "linux/amd64", member, texts)
+	if err != nil || len(withoutProducer) != 0 {
+		t.Fatal("a generated-looking name supplied its own absent FCONST producer", withoutProducer, err)
+	}
+	if _, err := joinASMDataLayouts(nil, asmDataWithoutGeneratedFloatPools(member, withoutProducer)); !errors.Is(err, ErrContext) {
+		t.Fatal("a non-FCONST prefix obtained a complete DATA observation", err)
+	}
+}
+
+func TestASMGeneratedFloatPoolRejectsUnassociatedReferences(t *testing.T) {
+	for name, change := range map[string]func(*ASMDataMember, []ASMSourceText){
+		"extra-TEXT": func(member *ASMDataMember, _ []ASMSourceText) {
+			member.Texts[0].Relocations = append(member.Texts[0].Relocations, member.Texts[0].Relocations[0])
+		},
+		"DATA": func(member *ASMDataMember, _ []ASMSourceText) {
+			member.Definitions = append(member.Definitions, ASMDataDefinition{Name: "ordinary", Kind: 5,
+				Relocations: append([]TextRelocation(nil), member.Texts[0].Relocations...)})
+		},
+		"auxiliary": func(member *ASMDataMember, _ []ASMSourceText) {
+			member.Texts[0].Auxiliary = []TextAuxiliary{{Type: 2, Target: member.Texts[0].Relocations[0].Target}}
+		},
+		"missing-relocation": func(member *ASMDataMember, _ []ASMSourceText) { member.Texts[0].Relocations = nil },
+		"missing-PC":         func(member *ASMDataMember, _ []ASMSourceText) { member.Texts[0].Positions = nil },
+		"changed-PC":         func(member *ASMDataMember, _ []ASMSourceText) { member.Texts[0].Relocations[0].Offset++ },
+		"source-order":       func(_ *ASMDataMember, order []ASMSourceText) { order[0].SourceOrdinal++ },
+		"object-order":       func(_ *ASMDataMember, order []ASMSourceText) { order[0].ObjectOrdinal++ },
+		"text-namespace":     func(_ *ASMDataMember, order []ASMSourceText) { order[0].Namespace = TextSymbolSelf },
+		"text-name":          func(_ *ASMDataMember, order []ASMSourceText) { order[0].Name += "changed" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			source, member, order := generatedFloatPoolUnitFixture(t)
+			change(&member, order)
+			if pools, err := generatedASMFloatPools(source, "linux/amd64", member, order); !errors.Is(err, ErrContext) || pools != nil {
+				t.Fatal("an unassociated object/source reference acquired a pool observation", pools, err)
+			}
+		})
+	}
+}
+
+func TestASMGeneratedFloatPoolFloatExpressionGrammar(t *testing.T) {
+	for _, literal := range []string{"1.25", "(+1.25)", "-(-1.25)", "0x1.4p+0", "1.2_5"} {
+		t.Run(literal, func(t *testing.T) {
+			statements, err := asmDataStatements([]byte(literal))
+			if err != nil || len(statements) != 1 {
+				t.Fatal("float grammar fixture", err)
+			}
+			value, floating, err := asmGeneratedFloatPoolConstant(statements[0])
+			if err != nil || !floating || math.Float64bits(value) != 0x3ff4000000000000 {
+				t.Fatal("official recursive float grammar lost its exact original value", value, floating, err)
+			}
+		})
+	}
+	for _, literal := range []string{"1", "(1)", "1.0+0.0", "1.0*0.0", "(1+0.0)", strings.Repeat("(", 257) + "1.0" + strings.Repeat(")", 257)} {
+		t.Run(literal, func(t *testing.T) {
+			statements, err := asmDataStatements([]byte(literal))
+			if err != nil || len(statements) != 1 {
+				t.Fatal("negative float grammar fixture", err)
+			}
+			if _, floating, err := asmGeneratedFloatPoolConstant(statements[0]); err == nil && floating {
+				t.Fatal("integer, binary or unbounded float grammar acquired FCONST metadata")
+			}
+		})
+	}
+}
+
+func TestASMGeneratedFloatPoolProducerSourcesFailClosed(t *testing.T) {
+	for _, version := range []string{"", "go1.20.14", "go1.26.2", "go1.27.4"} {
+		called := false
+		err := GeneratedFloatPoolSources(version, func(string) ([]byte, error) { called = true; return nil, nil })
+		if !errors.Is(err, ErrContext) || called {
+			t.Fatal("unregistered pool schema used a source reader", version, called, err)
+		}
+	}
+	if err := GeneratedFloatPoolSources("go1.27.2", nil); !errors.Is(err, ErrContext) {
+		t.Fatal("a missing guarded reader acquired pool source identity", err)
+	}
+	if err := GeneratedFloatPoolSources("go1.27.2", func(string) ([]byte, error) { return []byte("changed actual source"), nil }); !errors.Is(err, ErrContext) {
+		t.Fatal("a changed producer source acquired pool source identity", err)
+	}
+	want := errors.New("unavailable guarded source")
+	if err := GeneratedFloatPoolSources("go1.27.2", func(string) ([]byte, error) { return nil, want }); !errors.Is(err, want) {
+		t.Fatal("a guarded source failure was hidden", err)
+	}
+}
diff --git a/internal/gostaticstorage/assembly_generated_funcdata.go b/internal/gostaticstorage/assembly_generated_funcdata.go
new file mode 100644
index 000000000..1d0e0ad10
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_funcdata.go
@@ -0,0 +1,261 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/binary"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// ASMGeneratedFuncdata is an actual assembler-created metadata association.
+// It is never an ASMGlobalLayout, literal, readable storage, GC-correctness,
+// native-entry or numerical permission.
+type ASMGeneratedFuncdata struct {
+	Definition ASMDataDefinition
+	Owners     []ASMGeneratedFuncdataOwner
+}
+
+type ASMGeneratedFuncdataOwner struct {
+	StatementOrdinal, TextSourceOrdinal, TextObjectOrdinal int
+	Slot                                                   int
+	TextNamespace                                          TextSymbolNamespace
+	TextRelative, TextIndex                                uint32
+}
+
+func generatedASMFuncdata(source []byte, packagePath string, member ASMDataMember) ([]ASMGeneratedFuncdata, error) {
+	if !bytes.Contains(source, []byte("no_pointers_stackmap")) {
+		return nil, nil
+	}
+	texts, err := ASMSourceTextOrder(source, packagePath, member)
+	if err != nil {
+		return nil, err
+	}
+	return generatedASMFuncdataWithTextOrder(source, packagePath, member, texts)
+}
+
+func generatedASMFuncdataWithTextOrder(source []byte, packagePath string, member ASMDataMember, texts []ASMSourceText) ([]ASMGeneratedFuncdata, error) {
+	if !bytes.Contains(source, []byte("no_pointers_stackmap")) {
+		return nil, nil // No additional parser/query cost for unrelated sources.
+	}
+	statements, err := asmDataStatements(source)
+	if err != nil {
+		return nil, err
+	}
+	if len(texts) != len(member.Texts) || member.Flags&4 == 0 {
+		return nil, contextError("generated FUNCDATA lacks the complete actual source/TEXT order")
+	}
+	definitionsByRelative := make(map[uint32][]ASMDataDefinition)
+	for _, definition := range member.Definitions {
+		if definition.Namespace == TextSymbolHashed {
+			definitionsByRelative[definition.Relative] = append(definitionsByRelative[definition.Relative], definition)
+		}
+	}
+	var metadata *ASMGeneratedFuncdata
+	owners := make(map[int]bool)
+	seenTexts := make(map[int]bool, len(texts))
+	textOrdinal := -1
+	for ordinal, statement := range statements {
+		if statement[0].text == "TEXT" {
+			textOrdinal++
+			if textOrdinal >= len(texts) {
+				return nil, contextError("generated FUNCDATA source has an unassociated TEXT")
+			}
+			owner := texts[textOrdinal]
+			if owner.SourceOrdinal != textOrdinal || owner.ObjectOrdinal < 0 || owner.ObjectOrdinal >= len(member.Texts) || seenTexts[owner.ObjectOrdinal] {
+				return nil, contextError("generated FUNCDATA source/TEXT ordinal changed")
+			}
+			text := member.Texts[owner.ObjectOrdinal]
+			operands := asmDataOperands(statement[1:])
+			if len(operands) != 2 && len(operands) != 3 {
+				return nil, contextError("generated FUNCDATA source TEXT declaration changed")
+			}
+			symbol, err := asmDataSymbol(operands[0], packagePath)
+			namespace := TextSymbolNonpkgDefinition
+			if symbol.Static {
+				namespace = TextSymbolSelf
+			}
+			if err != nil || symbol.Addend != 0 || owner.Name != symbol.Name || owner.ABI != symbol.ABI || owner.Namespace != namespace ||
+				owner.Name != text.Name || owner.ABI != text.ABI || owner.Namespace != text.Namespace || owner.Relative != text.Relative || owner.Index != text.Index {
+				return nil, contextError("generated FUNCDATA source/TEXT identity changed")
+			}
+			seenTexts[owner.ObjectOrdinal] = true
+		}
+		reserved := false
+		for _, token := range statement {
+			reserved = reserved || token.text == "no_pointers_stackmap"
+		}
+		if !reserved {
+			continue
+		}
+		operands := asmDataOperands(statement[1:])
+		if statement[0].text != "FUNCDATA" || len(operands) != 2 || len(operands[0]) < 2 || operands[0][0].kind != '$' || textOrdinal < 0 {
+			return nil, contextError("reserved generated FUNCDATA has a storage/address or unbound source use")
+		}
+		slot, err := asmDataInteger(operands[0][1:])
+		symbol, symbolErr := asmDataSymbol(operands[1], packagePath)
+		if err != nil || symbolErr != nil || slot != 1 || symbol.Name != "no_pointers_stackmap" || symbol.ABI != 0 || symbol.Static || symbol.Addend != 0 {
+			return nil, contextError("reserved generated FUNCDATA lost its complete locals-map source role")
+		}
+		owner := texts[textOrdinal]
+		if owners[owner.ObjectOrdinal] {
+			return nil, contextError("generated FUNCDATA has a duplicate source owner/slot")
+		}
+		ref, found := generatedFuncdataSlot(member.Texts[owner.ObjectOrdinal], int(slot))
+		if !found || ref.PackageIndex != 2147483645 || !ref.ABIKnown || ref.ABI != 0 {
+			return nil, contextError("generated FUNCDATA lacks its exact hashed object-local auxiliary slot")
+		}
+		var definitions []ASMDataDefinition
+		for _, definition := range definitionsByRelative[ref.SymbolIndex] {
+			if generatedFuncdataReference(definition, ref) {
+				definitions = append(definitions, definition)
+			}
+		}
+		if len(definitions) != 1 || !validGeneratedLocalsDefinition(definitions[0]) {
+			return nil, contextError("generated FUNCDATA has an unknown payload/hash/namespace/definition")
+		}
+		if metadata == nil {
+			metadata = &ASMGeneratedFuncdata{Definition: definitions[0]}
+		} else if !reflect.DeepEqual(metadata.Definition, definitions[0]) {
+			return nil, contextError("one reserved locals-map rewrite produced different definitions")
+		}
+		owners[owner.ObjectOrdinal] = true
+		metadata.Owners = append(metadata.Owners, ASMGeneratedFuncdataOwner{StatementOrdinal: ordinal, TextSourceOrdinal: textOrdinal,
+			TextObjectOrdinal: owner.ObjectOrdinal, Slot: 1, TextNamespace: owner.Namespace, TextRelative: owner.Relative, TextIndex: owner.Index})
+	}
+	if textOrdinal+1 != len(texts) {
+		return nil, contextError("generated FUNCDATA source omitted part of its complete TEXT order")
+	}
+	if metadata == nil {
+		return nil, nil // No generated definition is inferred from a name or payload.
+	}
+	definition := metadata.Definition
+	normalized := strings.ReplaceAll(definition.Name, "·", ".")
+	for _, statement := range statements {
+		var prefix strings.Builder
+		for index, token := range statement {
+			text := token.text
+			if unquoted, err := strconv.Unquote(text); err == nil {
+				text = unquoted
+			}
+			prefix.WriteString(text)
+			if token.kind == '(' && index+2 < len(statement) && statement[index+1].text == "SB" && statement[index+2].kind == ')' && strings.Contains(prefix.String(), normalized) {
+				return nil, contextError("generated metadata has an explicit source storage/address alias")
+			}
+		}
+	}
+	if err := validateGeneratedFuncdataReferences(member, definition, owners); err != nil {
+		return nil, err
+	}
+	return []ASMGeneratedFuncdata{*metadata}, nil
+}
+
+// Recheck every use, not only the auxiliary entry selected by one owner. The
+// source observer and pure readonly planner share this closed metadata role.
+func validateGeneratedFuncdataReferences(member ASMDataMember, definition ASMDataDefinition, owners map[int]bool) error {
+	uses := 0
+	for ordinal, text := range member.Texts {
+		for _, relocation := range text.Relocations {
+			if generatedFuncdataReference(definition, relocation.Target) || relocation.Target.Name == definition.Name {
+				return contextError("generated metadata is an ordinary TEXT relocation target")
+			}
+		}
+		slot := -1
+		for _, auxiliary := range text.Auxiliary {
+			if auxiliary.Type == 2 {
+				slot++ // Nil entries occupy real FUNCDATA slots too.
+			}
+			if generatedFuncdataReference(definition, auxiliary.Target) || auxiliary.Target.Name == definition.Name {
+				if auxiliary.Type != 2 || slot != 1 || !owners[ordinal] || !generatedFuncdataReference(definition, auxiliary.Target) {
+					return contextError("generated metadata has an unassociated auxiliary owner or slot")
+				}
+				uses++
+			}
+		}
+	}
+	for _, data := range member.Definitions {
+		for _, relocation := range data.Relocations {
+			if generatedFuncdataReference(definition, relocation.Target) || relocation.Target.Name == definition.Name {
+				return contextError("generated metadata is an ordinary DATA relocation target")
+			}
+		}
+	}
+	if uses != len(owners) {
+		return contextError("generated metadata auxiliary inventory differs from its complete source owners")
+	}
+	return nil
+}
+
+func generatedFuncdataSlot(text TextRecord, wanted int) (TextReference, bool) {
+	slot := 0
+	for _, auxiliary := range text.Auxiliary {
+		if auxiliary.Type == 2 {
+			if slot == wanted {
+				return auxiliary.Target, true
+			}
+			slot++
+		}
+	}
+	return TextReference{}, false
+}
+
+func generatedFuncdataReference(definition ASMDataDefinition, ref TextReference) bool {
+	return definition.Namespace == TextSymbolHashed && ref.PackageIndex == 2147483645 && ref.SymbolIndex == definition.Relative &&
+		ref.Name == definition.Name && ref.ABIKnown && ref.ABI == definition.ABI && (!ref.KindKnown || ref.Kind == definition.Kind)
+}
+
+func validGeneratedLocalsDefinition(definition ASMDataDefinition) bool {
+	if definition.Namespace != TextSymbolHashed || definition.ABI != 0 || definition.Kind != 3 || definition.Flags != 1 || definition.Flags2 != 0 ||
+		definition.Size != 8 || definition.Align != 4 || len(definition.Relocations) != 0 || !bytes.Equal(definition.Data, []byte{2, 0, 0, 0, 0, 0, 0, 0}) {
+		return false
+	}
+	// Selected Go GCLocalsSym and writer.contentHash are independent hashes.
+	// Validate the full generated identity, never merely a gclocals name prefix.
+	nameHash := sha256.Sum256(definition.Data)
+	nameHash[0] ^= 0xff
+	if definition.Name != "gclocals·"+base64.StdEncoding.EncodeToString(nameHash[:16]) {
+		return false
+	}
+	hash := sha256.New()
+	hash.Write([]byte{1})
+	var shape [9]byte
+	binary.LittleEndian.PutUint64(shape[:8], uint64(definition.Size))
+	shape[8] = 'F'
+	hash.Write(shape[:])
+	hash.Write(bytes.TrimRight(definition.Data, "\x00"))
+	return bytes.Equal(definition.Hash, hash.Sum(nil)[:16])
+}
+
+func sameGeneratedFuncdata(first, second []ASMGeneratedFuncdata) bool {
+	normalize := func(values []ASMGeneratedFuncdata) []ASMGeneratedFuncdata {
+		result := append([]ASMGeneratedFuncdata(nil), values...)
+		for index := range result {
+			result[index].Definition.DataOffset = 0 // Physical offsets stay in both complete members.
+		}
+		return result
+	}
+	return reflect.DeepEqual(normalize(first), normalize(second))
+}
+
+// Only independently source/auxiliary-closed generated metadata is partitioned.
+// The original DATA join remains unchanged and strict for every other byte.
+// Full definitions are retained in both complete object observations above.
+func asmDataWithoutGeneratedFuncdata(member ASMDataMember, metadata []ASMGeneratedFuncdata) ASMDataMember {
+	if len(metadata) == 0 {
+		return member
+	}
+	definitions := make([]ASMDataDefinition, 0, len(member.Definitions))
+	for _, definition := range member.Definitions {
+		generated := false
+		for _, record := range metadata {
+			generated = generated || reflect.DeepEqual(record.Definition, definition)
+		}
+		if !generated {
+			definitions = append(definitions, definition)
+		}
+	}
+	member.Definitions = definitions
+	return member
+}
diff --git a/internal/gostaticstorage/assembly_generated_funcdata_schema.go b/internal/gostaticstorage/assembly_generated_funcdata_schema.go
new file mode 100644
index 000000000..0cd0f1100
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_funcdata_schema.go
@@ -0,0 +1,33 @@
+package gostaticstorage
+
+// These actual source hashes bind the reserved FUNCDATA rewrite, generated
+// content-addressable identity, writer hash/namespace and ordered auxiliaries.
+// Source identity is distinct from the offline object observation, which cannot
+// authenticate its caller or construct a live source/storage capability.
+var generatedFuncdataSourceRoles = map[string]string{
+	"src/cmd/internal/obj/plist.go":      "50c121d6c72c356c605176e02bce549dd6e0e8107af6c0eed467f7b3adb418e3",
+	"src/cmd/internal/obj/sym.go":        "2bb2646a6ccff23aa42d8c4960be7cf82af5570ae5a83a1a355b7b822ee2149d",
+	"src/cmd/internal/obj/objfile.go":    "803546227c02cf46bfa4158be3dfd8067e7457f4e4f78349cb6d42c700b2fcb7",
+	"src/cmd/internal/hash/hash.go":      "8574000887ab8f24695355bc9247f189a332698db89c63b2ac13a6149ca36350",
+	"pkg/include/funcdata.h":             "bd73b7c27a4d3f8560a5a9dd1a5da54e0e48572311a744cf7843e709b7f2a015",
+	"src/cmd/internal/goobj/objfile.go":  "caf835a17e23aa02cae9bda6e8723d8be359846fc4453bd53f3a3947744b938a",
+	"src/cmd/internal/objabi/symkind.go": "de287864b7ff9a3614becc538cbabdccdecc030a848aad5d5bbef6ec7ec5c225",
+}
+
+// GeneratedFuncdataSources reads the required producer facts through the live
+// factory's guarded reader. It supplies no DATA, GC, native or numerical role.
+func GeneratedFuncdataSources(version string, read func(string) ([]byte, error)) error {
+	if version != "go1.27.1" && version != "go1.27.2" && version != "go1.27.3" || read == nil {
+		return contextError("unregistered generated FUNCDATA source/schema")
+	}
+	for role, expected := range generatedFuncdataSourceRoles {
+		data, err := read(role)
+		if err != nil {
+			return err
+		}
+		if digest(data) != expected {
+			return contextError("generated FUNCDATA producer source differs from the registered actual SDK")
+		}
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/assembly_generated_funcdata_test.go b/internal/gostaticstorage/assembly_generated_funcdata_test.go
new file mode 100644
index 000000000..eff5745b1
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_funcdata_test.go
@@ -0,0 +1,195 @@
+package gostaticstorage
+
+import (
+	"encoding/hex"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func generatedFuncdataFixture(t *testing.T) ([]byte, ASMDataMember) {
+	t.Helper()
+	hash, err := hex.DecodeString("b7518df6dd275dfd7c0f147d0194c737")
+	if err != nil {
+		t.Fatal(err)
+	}
+	definition := ASMDataDefinition{Namespace: TextSymbolHashed, Index: 0, Relative: 0,
+		Name: "gclocals·J26BEvPExEQhJvjp9E8Whg==", ABI: 0, Kind: 3, Flags: 1,
+		Size: 8, Align: 4, Hash: hash, Data: []byte{2, 0, 0, 0, 0, 0, 0, 0}}
+	member := ASMDataMember{Flags: sdkAssemblyObjectFlags("linux/386"), Definitions: []ASMDataDefinition{definition}}
+	var source strings.Builder
+	for index, name := range []string{"first", "independent"} {
+		source.WriteString("TEXT ·" + name + "(SB),4,$0-0\nFUNCDATA $1,no_pointers_stackmap(SB)\nRET\n")
+		member.Texts = append(member.Texts, TextRecord{Namespace: TextSymbolNonpkgDefinition, Relative: uint32(index), Index: uint32(index + 1),
+			Name: "fixture." + name, ABI: 0, Kind: 1, Auxiliary: []TextAuxiliary{
+				{Type: 1}, {Type: 2}, {Type: 2, Target: TextReference{PackageIndex: 2147483645, SymbolIndex: 0, Name: definition.Name, ABI: 0, ABIKnown: true}},
+			}})
+	}
+	return []byte(source.String()), member
+}
+
+func TestASMGeneratedFuncdataNeverCreatesDataOrLiteralLayout(t *testing.T) {
+	source, member := generatedFuncdataFixture(t)
+	metadata, err := generatedASMFuncdata(source, "fixture", member)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if layouts, err := joinASMDataLayouts(nil, member); !errors.Is(err, ErrContext) || layouts != nil {
+		t.Fatal("the existing DATA join stopped rejecting unconsumed definitions", err)
+	}
+	partition := asmDataWithoutGeneratedFuncdata(member, metadata)
+	if layouts, err := joinASMDataLayouts(nil, partition); err != nil || len(layouts) != 0 || len(member.Definitions) != 1 {
+		t.Fatal("metadata partition invented a DATA layout or removed its complete object record", err)
+	}
+	partition.Definitions = append(partition.Definitions, ASMDataDefinition{Name: "unproved", Kind: 3, Namespace: TextSymbolSelf})
+	if _, err := joinASMDataLayouts(nil, partition); !errors.Is(err, ErrContext) {
+		t.Fatal("another unconsumed DATA definition inherited the metadata exception", err)
+	}
+	member.Name, member.NameBytes, member.Ordinal = "metadata.o", []byte("metadata.o"), 2
+	observation := &SDKASMDataObservation{Protocol: ASMDataCPPProtocol, PackagePath: "fixture", Target: "linux/386",
+		Members: []ASMDataMember{{Name: "__.PKGDEF"}, {Name: "_go_.o"}, member},
+		Sources: []ASMDataSourceObservation{{Name: "metadata.s", Original: member, Expanded: member, GeneratedFuncdata: metadata}}}
+	if images, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) || images != nil {
+		t.Fatal("generated metadata entered the private literal/initializer directory", images, err)
+	}
+	withoutRole := []byte(strings.ReplaceAll(string(source), "FUNCDATA $1,no_pointers_stackmap(SB)", "NOP"))
+	if records, err := generatedASMFuncdata(withoutRole, "fixture", member); err != nil || len(records) != 0 {
+		t.Fatal("a generated-looking name/hash/payload supplied its own missing source role", records, err)
+	}
+}
+
+func TestASMGeneratedFuncdataWholeSourceOwnerAndNilSlot(t *testing.T) {
+	source, member := generatedFuncdataFixture(t)
+	before := append([]byte(nil), source...)
+	metadata, err := generatedASMFuncdata(source, "fixture", member)
+	if err != nil || len(metadata) != 1 || len(metadata[0].Owners) != 2 || !reflect.DeepEqual(metadata[0].Definition, member.Definitions[0]) {
+		t.Fatal("complete source-owned metadata was not independently classified", metadata, err)
+	}
+	for index, owner := range metadata[0].Owners {
+		if owner.Slot != 1 || owner.TextSourceOrdinal != index || owner.TextObjectOrdinal != index || owner.TextNamespace != TextSymbolNonpkgDefinition || owner.TextIndex != uint32(index+1) {
+			t.Fatal("nil funcdata slot or exact source/object owner was lost", owner)
+		}
+	}
+	if !reflect.DeepEqual(source, before) {
+		t.Fatal("classification modified source bytes")
+	}
+}
+
+func TestASMGeneratedFuncdataRejectsPermissionAndIdentityChanges(t *testing.T) {
+	for name, mutate := range map[string]func(*ASMDataMember){
+		"namespace":      func(m *ASMDataMember) { m.Definitions[0].Namespace = TextSymbolSelf },
+		"relative-index": func(m *ASMDataMember) { m.Definitions[0].Relative++ },
+		"ABI":            func(m *ASMDataMember) { m.Definitions[0].ABI = 1 },
+		"kind":           func(m *ASMDataMember) { m.Definitions[0].Kind = 5 },
+		"flags":          func(m *ASMDataMember) { m.Definitions[0].Flags = 0 },
+		"flags2":         func(m *ASMDataMember) { m.Definitions[0].Flags2 = 1 },
+		"size":           func(m *ASMDataMember) { m.Definitions[0].Size++ },
+		"alignment":      func(m *ASMDataMember) { m.Definitions[0].Align = 8 },
+		"payload":        func(m *ASMDataMember) { m.Definitions[0].Data[0] = 1 },
+		"hash":           func(m *ASMDataMember) { m.Definitions[0].Hash[0] ^= 1 },
+		"generated-name": func(m *ASMDataMember) { m.Definitions[0].Name += "forged" },
+		"data-relocation": func(m *ASMDataMember) {
+			m.Definitions[0].Relocations = []TextRelocation{{Target: m.Texts[0].Auxiliary[2].Target}}
+		},
+		"ordinary-TEXT-relocation": func(m *ASMDataMember) {
+			m.Texts[0].Relocations = []TextRelocation{{Target: m.Texts[0].Auxiliary[2].Target}}
+		},
+		"ordinary-DATA-relocation": func(m *ASMDataMember) {
+			m.Definitions = append(m.Definitions, ASMDataDefinition{Name: "ordinary", Kind: 5,
+				Relocations: []TextRelocation{{Target: m.Texts[0].Auxiliary[2].Target}}})
+		},
+		"extra-aux-owner": func(m *ASMDataMember) { m.Texts[0].Auxiliary = append(m.Texts[0].Auxiliary, m.Texts[0].Auxiliary[2]) },
+		"wrong-aux-kind":  func(m *ASMDataMember) { m.Texts[0].Auxiliary[2].Type = 3 },
+		"nil-slot-removed": func(m *ASMDataMember) {
+			m.Texts[0].Auxiliary = append(m.Texts[0].Auxiliary[:1], m.Texts[0].Auxiliary[2:]...)
+		},
+		"owner-reference-namespace": func(m *ASMDataMember) { m.Texts[0].Auxiliary[2].Target.PackageIndex-- },
+		"owner-reference-index":     func(m *ASMDataMember) { m.Texts[0].Auxiliary[2].Target.SymbolIndex++ },
+		"owner-reference-ABI":       func(m *ASMDataMember) { m.Texts[0].Auxiliary[2].Target.ABI = 1 },
+		"unassociated-second-TEXT":  func(m *ASMDataMember) { m.Texts[1].Name = "fixture.unrelated" },
+	} {
+		t.Run(name, func(t *testing.T) {
+			source, member := generatedFuncdataFixture(t)
+			mutate(&member)
+			if metadata, err := generatedASMFuncdata(source, "fixture", member); err == nil || len(metadata) != 0 {
+				t.Fatal("changed metadata/source/object authority was accepted", metadata, err)
+			}
+		})
+	}
+	for _, suffix := range []string{
+		"\nGLOBL no_pointers_stackmap(SB),8,$8\n", "\nDATA no_pointers_stackmap+0(SB)/8,$2\n",
+		"\nLEAL no_pointers_stackmap(SB),AX\n", "\nMOVL $no_pointers_stackmap(SB),AX\n",
+		"\nLEAL gclocals·J26BEvPExEQhJvjp9E8Whg==(SB),AX\n",
+		"\nMOVL $\"gclocals·J26BEvPExEQhJvjp9E8Whg==\"(SB),AX\n",
+		"\nLEAL \"gclocals·J26BEvPExEQhJvjp9E8Whg==\"+4(SB),AX\n",
+		"\nGLOBL \"gclocals·J26BEvPExEQhJvjp9E8Whg==\"(SB),8,$8\n",
+	} {
+		t.Run(suffix, func(t *testing.T) {
+			source, member := generatedFuncdataFixture(t)
+			if metadata, err := generatedASMFuncdata(append(source, []byte(suffix)...), "fixture", member); err == nil || len(metadata) != 0 {
+				t.Fatal("explicit storage/address use acquired a generated-only metadata role", metadata, err)
+			}
+		})
+	}
+	for _, body := range []string{
+		"FUNCDATA $1,no_pointers_stackmap(SB)\nFUNCDATA $1,no_pointers_stackmap(SB)",
+		"FUNCDATA $0,no_pointers_stackmap(SB)",
+	} {
+		t.Run(body, func(t *testing.T) {
+			source, member := generatedFuncdataFixture(t)
+			source = []byte(strings.Replace(string(source), "FUNCDATA $1,no_pointers_stackmap(SB)", body, 1))
+			if metadata, err := generatedASMFuncdata(source, "fixture", member); err == nil || len(metadata) != 0 {
+				t.Fatal("duplicate source owner/slot or wrong reserved slot acquired metadata", metadata, err)
+			}
+		})
+	}
+}
+
+func TestASMGeneratedFuncdataRejectsChangedTextOrder(t *testing.T) {
+	for name, mutate := range map[string]func([]ASMSourceText) []ASMSourceText{
+		"missing":        func(_ []ASMSourceText) []ASMSourceText { return nil },
+		"index":          func(values []ASMSourceText) []ASMSourceText { values[0].ObjectOrdinal = -1; return values },
+		"source-ordinal": func(values []ASMSourceText) []ASMSourceText { values[0].SourceOrdinal++; return values },
+		"namespace":      func(values []ASMSourceText) []ASMSourceText { values[0].Namespace = TextSymbolSelf; return values },
+		"symbol":         func(values []ASMSourceText) []ASMSourceText { values[0].Name = "unrelated"; return values },
+		"ABI":            func(values []ASMSourceText) []ASMSourceText { values[0].ABI++; return values },
+		"relative":       func(values []ASMSourceText) []ASMSourceText { values[0].Relative++; return values },
+		"physical-index": func(values []ASMSourceText) []ASMSourceText { values[0].Index++; return values },
+		"duplicate": func(values []ASMSourceText) []ASMSourceText {
+			values[1].ObjectOrdinal = values[0].ObjectOrdinal
+			return values
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			source, member := generatedFuncdataFixture(t)
+			order, err := ASMSourceTextOrder(source, "fixture", member)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if metadata, err := generatedASMFuncdataWithTextOrder(source, "fixture", member, mutate(order)); err == nil || len(metadata) != 0 {
+				t.Fatal("a different source/TEXT mapping was accepted", metadata, err)
+			}
+		})
+	}
+}
+
+func TestASMGeneratedFuncdataProducerSourcesFailClosed(t *testing.T) {
+	for _, version := range []string{"", "go1.20.14", "go1.26.2", "go1.27.4"} {
+		called := false
+		err := GeneratedFuncdataSources(version, func(string) ([]byte, error) { called = true; return nil, nil })
+		if !errors.Is(err, ErrContext) || called {
+			t.Fatal("unregistered metadata schema read or gained a source role", version, called, err)
+		}
+	}
+	if err := GeneratedFuncdataSources("go1.27.2", nil); !errors.Is(err, ErrContext) {
+		t.Fatal("a missing guarded reader acquired a metadata source role", err)
+	}
+	if err := GeneratedFuncdataSources("go1.27.2", func(string) ([]byte, error) { return []byte("different actual source"), nil }); !errors.Is(err, ErrContext) {
+		t.Fatal("changed actual producer source acquired a metadata source role", err)
+	}
+	want := errors.New("guarded source unavailable")
+	if err := GeneratedFuncdataSources("go1.27.2", func(string) ([]byte, error) { return nil, want }); !errors.Is(err, want) {
+		t.Fatal("a guarded reader failure was hidden", err)
+	}
+}
diff --git a/internal/gostaticstorage/assembly_generated_patch_go127_test.go b/internal/gostaticstorage/assembly_generated_patch_go127_test.go
new file mode 100644
index 000000000..a6ecc2569
--- /dev/null
+++ b/internal/gostaticstorage/assembly_generated_patch_go127_test.go
@@ -0,0 +1,78 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestASMGeneratedAuditedPatchSources(t *testing.T) {
+	for _, profile := range []struct {
+		name  string
+		count int
+		roles map[string]string
+		check func(string, func(string) ([]byte, error)) error
+	}{
+		{"funcdata", 7, generatedFuncdataSourceRoles, GeneratedFuncdataSources},
+		{"float pool", 6, generatedFloatPoolSourceRoles, GeneratedFloatPoolSources},
+	} {
+		t.Run(profile.name, func(t *testing.T) {
+			if len(profile.roles) != profile.count {
+				t.Fatal("audited generated-metadata producer inventory changed", len(profile.roles))
+			}
+			sources := make(map[string][]byte, len(profile.roles))
+			for name := range profile.roles {
+				data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+				if err != nil {
+					t.Fatal(err)
+				}
+				sources[name] = data
+			}
+			for _, version := range []string{"go1.27.2", "go1.27.3"} {
+				t.Run(version, func(t *testing.T) {
+					seen := make(map[string]bool)
+					err := profile.check(version, func(name string) ([]byte, error) {
+						seen[name] = true
+						return sources[name], nil
+					})
+					if err != nil || len(seen) != len(profile.roles) {
+						t.Fatal("audited exact patch did not check every original producer file", err, len(seen))
+					}
+				})
+			}
+			for _, version := range []string{"go1.27.2", "go1.27.3"} {
+				for name := range profile.roles {
+					t.Run(version+"/changed/"+name, func(t *testing.T) {
+						seen := false
+						if err := profile.check(version, func(role string) ([]byte, error) {
+							if role == name {
+								seen = true
+								return append(append([]byte(nil), sources[role]...), '\n'), nil
+							}
+							return sources[role], nil
+						}); !seen || !errors.Is(err, ErrContext) {
+							t.Fatal("changed exact producer source was not independently rejected", seen, err)
+						}
+					})
+				}
+				if err := profile.check(version, func(string) ([]byte, error) { return nil, os.ErrNotExist }); !errors.Is(err, os.ErrNotExist) {
+					t.Fatal("guarded reader failure was hidden", version, err)
+				}
+			}
+			for _, version := range []string{"go1.27.4", "go1.27", "go1.27.3-custom", "devel go1.27.3"} {
+				t.Run("unregistered/"+version, func(t *testing.T) {
+					if err := profile.check(version, func(string) ([]byte, error) {
+						t.Fatal("unregistered patch consulted producer bytes")
+						return nil, nil
+					}); !errors.Is(err, ErrContext) {
+						t.Fatal("unaudited patch acquired generated metadata roles", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_member_names_go127_test.go b/internal/gostaticstorage/assembly_member_names_go127_test.go
new file mode 100644
index 000000000..480763364
--- /dev/null
+++ b/internal/gostaticstorage/assembly_member_names_go127_test.go
@@ -0,0 +1,109 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoSDKAssemblyActualTruncatedMemberNames(t *testing.T) {
+	directory, compiler, _ := fixture(t)
+	oracle := officialReaderForSource(t, compiler, sdkNamespaceReaderSource)
+	consumer := filepath.Join(directory, "longmember")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	name := "long_original_assembly_member.s"
+	unicodeName := "zzzzzzzzzzzzzzz界.s"
+	goSource := "package longmember\nfunc Entry()\nfunc Unicode()\n"
+	assembly := "#include \"textflag.h\"\nTEXT ·Entry(SB),NOSPLIT,$0-0\nRET\n"
+	unicodeAssembly := "#include \"textflag.h\"\nTEXT ·Unicode(SB),NOSPLIT,$0-0\nRET\n"
+	for file, data := range map[string]string{"value.go": goSource, name: assembly, unicodeName: unicodeAssembly} {
+		if err := os.WriteFile(filepath.Join(consumer, file), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(compiler)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			raw := run(t, compiler, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly",
+				"-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				Export   string
+				SFiles   []string
+				Standard bool
+			}
+			if err := json.Unmarshal(raw, &selected); err != nil || selected.Standard ||
+				!reflect.DeepEqual(selected.SFiles, []string{name, unicodeName}) {
+				t.Fatal("actual first-party source role differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			originalRaw := run(t, oracle, consumer, env, selected.Export)
+			var original []namespaceOracleMember
+			if err := json.Unmarshal(originalRaw, &original); err != nil || len(original) != 4 {
+				t.Fatal("official original archive inventory differs", err)
+			}
+			for ordinal, source := range selected.SFiles {
+				wanted := (strings.TrimSuffix(source, ".s") + ".o")[:16]
+				if !bytes.Equal(original[ordinal+2].NameBytes, []byte(wanted)) || original[ordinal+2].Flags != 20 {
+					t.Fatal("official original byte-truncated member/flags differ", original[ordinal+2])
+				}
+			}
+			retainTextArtifact(t, target, "indexed-long-member", map[string][]byte{
+				"original.a": archive, "namespace-sdk.json": originalRaw, "selection.json": raw,
+				"source-value.go": []byte(goSource), "source-assembly.s": []byte(assembly), "source-unicode.s": []byte(unicodeAssembly),
+			})
+			observed, err := ObserveX86SDKAssemblyArchive(archive, builtin, target, selected.SFiles)
+			if err != nil || len(observed) != 4 {
+				t.Fatal("exact actual SDK-format long source/member route was rejected", err)
+			}
+			for ordinal, source := range selected.SFiles {
+				wanted := (strings.TrimSuffix(source, ".s") + ".o")[:16]
+				member := observed[ordinal+2]
+				if member.Name != wanted || member.Offset != original[ordinal+2].Offset || member.Size != original[ordinal+2].Size ||
+					len(member.Texts) != 1 || member.Texts[0].ABI != 0 || len(member.Texts[0].Code) == 0 {
+					t.Fatal("original ordinal/whole-body member identity differs", member)
+				}
+			}
+			for _, files := range [][]string{
+				{name}, {name, name}, {unicodeName, name}, {name, "long_original_assembly_foreign.s"},
+				{name, "unknown.s"},
+			} {
+				if _, err := ObserveX86SDKAssemblyArchive(archive, builtin, target, files); !errors.Is(err, ErrContext) {
+					t.Fatal("missing/duplicate/reordered/colliding/unknown source chose a long member", files, err)
+				}
+			}
+		})
+	}
+}
+
+func TestGoSDKAssemblyCompleteMemberNameInventory(t *testing.T) {
+	for _, sources := range [][]string{
+		{"long_original_assembly_member.s", "long_original_assembly_other.s"},
+		{"same.s", "same.s"}, {"../foreign.s"}, {"foreign\\path.s"}, {"not-assembly.go"}, {"_go_.s"},
+	} {
+		if _, err := sdkAssemblyMemberNames(sources); !errors.Is(err, ErrContext) {
+			t.Fatal("ambiguous/noncanonical SDK selected-source inventory acquired a member route", sources, err)
+		}
+	}
+	wanted := []string{"short.o", "zzzzzzzzzzzzzzz\xe7"}
+	actual, err := sdkAssemblyMemberNames([]string{"short.s", "zzzzzzzzzzzzzzz界.s"})
+	if err != nil || !reflect.DeepEqual(actual, wanted) {
+		t.Fatal("SDK packInternal byte width became a rune/prefix match", actual, err)
+	}
+}
diff --git a/internal/gostaticstorage/assembly_namespace_go127_test.go b/internal/gostaticstorage/assembly_namespace_go127_test.go
new file mode 100644
index 000000000..825351d6b
--- /dev/null
+++ b/internal/gostaticstorage/assembly_namespace_go127_test.go
@@ -0,0 +1,231 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This independent reader enumerates the official four definition namespaces
+// and the separate NonPkgRefs block. It does not use plan9asm's object reader.
+const sdkNamespaceReaderSource = `package main
+
+import (
+	"cmd/internal/archive"
+	"cmd/internal/goobj"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type Definition struct {
+	Namespace int
+	Relative, Index uint32
+	Name string
+	ABI uint16
+	Kind, Flags, Flags2 uint8
+	Size, Align uint32
+	Hash []byte
+}
+type Member struct {
+	Name string
+	NameBytes []byte
+	Offset, Size int64
+	Flags uint32
+	Counts [5]int
+	Definitions []Definition
+}
+
+func main() {
+	f, err := os.Open(os.Args[1])
+	if err != nil { panic(err) }
+	defer f.Close()
+	a, err := archive.Parse(f, false)
+	if err != nil { panic(err) }
+	var members []Member
+	for _, entry := range a.Entries {
+		member := Member{Name: entry.Name, NameBytes: []byte(entry.Name), Offset: entry.Offset, Size: entry.Size}
+		if entry.Type != archive.EntryPkgDef && entry.Type != archive.EntryGoObj {
+			panic("unexpected original archive member")
+		}
+		if entry.Type == archive.EntryGoObj {
+			data := make([]byte, entry.Obj.Size)
+			n, err := f.ReadAt(data, entry.Obj.Offset)
+			if err != nil || n != len(data) { panic(fmt.Sprint(n, err)) }
+			r := goobj.NewReaderFromBytes(data, false)
+			if r == nil { panic("invalid original goobj") }
+			member.Flags = r.Flags()
+			member.Counts = [5]int{r.NSym(), r.NHashed64def(), r.NHasheddef(), r.NNonpkgdef(), r.NNonpkgref()}
+			var index uint32
+			for namespace, count := range member.Counts {
+				for relative := 0; relative < count; relative++ {
+					s := r.Sym(index)
+					definition := Definition{Namespace: namespace, Relative: uint32(relative), Index: index,
+						Name: s.Name(r), ABI: s.ABI(), Kind: s.Type(), Flags: s.Flag(), Flags2: s.Flag2(), Size: s.Siz(), Align: s.Align()}
+					if namespace == 1 {
+						hash := r.Hash64(uint32(relative))
+						definition.Hash = make([]byte, 8)
+						for byteIndex := range definition.Hash { definition.Hash[byteIndex] = byte(hash >> (8 * byteIndex)) }
+					}
+					if namespace == 2 { definition.Hash = append([]byte(nil), r.Hash(uint32(relative))[:]...) }
+					member.Definitions = append(member.Definitions, definition)
+					index++
+				}
+			}
+		}
+		members = append(members, member)
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(members); err != nil { panic(err) }
+}
+`
+
+type namespaceOracleDefinition struct {
+	Namespace           int
+	Relative, Index     uint32
+	Name                string
+	ABI                 uint16
+	Kind, Flags, Flags2 uint8
+	Size, Align         uint32
+	Hash                []byte
+}
+
+type namespaceOracleMember struct {
+	Name         string
+	NameBytes    []byte
+	Offset, Size int64
+	Flags        uint32
+	Counts       [5]int
+	Definitions  []namespaceOracleDefinition
+}
+
+func TestGoSDKAssemblyIndexedOnceFuncFirstParty(t *testing.T) {
+	directory, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkNamespaceReaderSource)
+	textOracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	consumer := filepath.Join(directory, "namespacefixture")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goSource := `package namespacefixture
+
+import "sync"
+
+var Counter byte
+var First = sync.OnceFunc(func() { Counter++ })
+var Second = sync.OnceFunc(func() { Counter += 2 })
+
+func Read() byte
+`
+	assembly := "#include \"textflag.h\"\nTEXT ·Read(SB),NOSPLIT,$0-1\nMOVB ·Counter(SB),AL\nMOVB AL,ret+0(FP)\nRET\n"
+	for name, data := range map[string]string{"value.go": goSource, "read.s": assembly} {
+		if err := os.WriteFile(filepath.Join(consumer, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			// The flags reproduce the SDK binary format, not SDK source identity.
+			// The actual first-party package remains Standard=false.
+			selection := run(t, binary, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly",
+				"-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				Export   string
+				SFiles   []string
+				Standard bool
+			}
+			if err := json.Unmarshal(selection, &selected); err != nil || selected.Standard ||
+				selected.Export == "" || !reflect.DeepEqual(selected.SFiles, []string{"read.s"}) {
+				t.Fatal("actual first-party selection/role differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, consumer, env, selected.Export)
+			textRaw := run(t, textOracle, consumer, env, selected.Export)
+			var original []namespaceOracleMember
+			var originalTexts []TextMember
+			if err := json.Unmarshal(raw, &original); err != nil || len(original) != 3 {
+				t.Fatal("actual namespace/hash oracle inventory differs", err)
+			}
+			if err := json.Unmarshal(textRaw, &originalTexts); err != nil || len(originalTexts) != len(original) {
+				t.Fatal("actual whole TEXT oracle inventory differs", err)
+			}
+			members, err := archiveMembers(archive)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for memberIndex, member := range members[1:] {
+				body, err := objectBody(member.data, target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				object, err := checkedObject(body, original[memberIndex+1].Flags, memberIndex != 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				symbols, err := object.indexedSymbols()
+				if err != nil {
+					t.Fatal(err)
+				}
+				encoded, err := json.Marshal(symbols)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var observed []namespaceOracleDefinition
+				if err := json.Unmarshal(encoded, &observed); err != nil || !reflect.DeepEqual(observed, original[memberIndex+1].Definitions) {
+					t.Fatal("all original namespace/index/hash/flag records differ from the independent SDK", err)
+				}
+			}
+			for namespace, count := range original[1].Counts {
+				if count == 0 {
+					t.Fatal("first-party original lacks a required namespace boundary", namespace)
+				}
+			}
+			groups := make(map[string][]namespaceOracleDefinition)
+			for _, definition := range original[1].Definitions {
+				if definition.Namespace == 2 && definition.Kind == 1 && strings.HasPrefix(definition.Name, "sync.OnceFunc.func1") {
+					groups[definition.Name] = append(groups[definition.Name], definition)
+				}
+			}
+			duplicateGroups := 0
+			for name, definitions := range groups {
+				if len(definitions) < 2 {
+					continue
+				}
+				duplicateGroups++
+				for _, definition := range definitions {
+					if definition.Flags != 0 || definition.Flags2 != 0 || definition.ABI != 1 || len(definition.Hash) != 16 {
+						t.Fatal("actual repeated inline closure namespace/hash facts differ", definition)
+					}
+				}
+				t.Logf("ACTUAL_HASHED_INLINE target=%s name=%s records=%d", target, name, len(definitions))
+			}
+			if duplicateGroups == 0 {
+				t.Fatal("first-party source did not reproduce actual duplicate indexed TEXT")
+			}
+			retainTextArtifact(t, target, "indexed-oncefunc", map[string][]byte{
+				"original.a": archive, "source-value.go": []byte(goSource), "source-read.s": []byte(assembly),
+				"selection.json": selection, "namespace-sdk.json": raw, "text-sdk.json": textRaw,
+			})
+			observed, err := ObserveX86SDKAssemblyArchive(archive, builtin, target, selected.SFiles)
+			if err != nil || !reflect.DeepEqual(observed, originalTexts) {
+				t.Fatal("SDK-only indexed observation rejected legal first-party namespace or lost whole TEXT", err)
+			}
+			if _, err := ObserveX86AssemblyArchive(archive, builtin, target, selected.SFiles); err == nil {
+				t.Fatal("ordinary owned observer acquired SDK binary flags/namespace permission")
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_namespace_guards_go127_test.go b/internal/gostaticstorage/assembly_namespace_guards_go127_test.go
new file mode 100644
index 000000000..d0a8679c9
--- /dev/null
+++ b/internal/gostaticstorage/assembly_namespace_guards_go127_test.go
@@ -0,0 +1,284 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"math"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"testing"
+)
+
+func indexedNamespaceObjectFixture(t *testing.T, arch string) ([]byte, []TextReference) {
+	t.Helper()
+	directory, compiler, _ := fixture(t)
+	goSource := `package staticstorage
+import "sync"
+var Value byte
+var First = sync.OnceFunc(func() { Value++ })
+var Second = sync.OnceFunc(func() { Value += 2 })
+func Read() byte { return Value }
+`
+	if err := os.WriteFile(filepath.Join(directory, "storage.go"), []byte(goSource), 0600); err != nil {
+		t.Fatal(err)
+	}
+	raw := run(t, compiler, directory, fixtureEnv(t, "linux/"+arch),
+		"list", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", ".")
+	var selected struct{ Export string }
+	if err := json.Unmarshal(raw, &selected); err != nil || selected.Export == "" {
+		t.Fatal("actual namespace fixture export differs", err)
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil {
+		t.Fatal(err)
+	}
+	members, err := archiveMembers(archive)
+	if err != nil || len(members) != 2 {
+		t.Fatal("actual namespace fixture members differ", err)
+	}
+	body, err := objectBody(members[1].data, "linux/"+arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(compiler)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtins, err := textBuiltins(builtin)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return body, builtins
+}
+
+func TestGoSDKAssemblyNamespaceBinaryBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			original, builtins := indexedNamespaceObjectFixture(t, arch)
+			view, err := checkedObject(original, 16, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := readTextObject(original, "linux/"+arch, 16, false, builtins); err != nil {
+				t.Fatal("actual original namespace object failed precondition", err)
+			}
+			blockOffset := func(block int) int { return int(binary.LittleEndian.Uint32(original[20+4*block:])) }
+			counts := [5]int{}
+			for namespace := range counts {
+				counts[namespace] = len(view.block(namespace+3)) / 21
+				if counts[namespace] == 0 {
+					t.Fatal("actual fixture did not populate namespace", namespace)
+				}
+			}
+			for block := 3; block <= 7; block++ {
+				t.Run("truncated-symbol-block-"+strconv.Itoa(block), func(t *testing.T) {
+					changed := append([]byte(nil), original...)
+					binary.LittleEndian.PutUint32(changed[20+4*(block+1):], uint32(blockOffset(block+1)-1))
+					if _, err := readTextObject(changed, "linux/"+arch, 16, false, builtins); !errors.Is(err, ErrContext) {
+						t.Fatal("truncated original namespace acquired observation", err)
+					}
+				})
+			}
+			for block := 4; block <= 7; block++ {
+				t.Run("namespace-crossover-"+strconv.Itoa(block), func(t *testing.T) {
+					changed := append([]byte(nil), original...)
+					binary.LittleEndian.PutUint32(changed[20+4*block:], uint32(blockOffset(block)+21))
+					if _, err := readTextObject(changed, "linux/"+arch, 16, false, builtins); !errors.Is(err, ErrContext) {
+						t.Fatal("changed namespace boundary acquired another index identity", err)
+					}
+				})
+			}
+			for _, block := range []int{9, 10} {
+				t.Run("hash-inventory-"+strconv.Itoa(block), func(t *testing.T) {
+					changed := append([]byte(nil), original...)
+					width := 8
+					if block == 10 {
+						width = 16
+					}
+					binary.LittleEndian.PutUint32(changed[20+4*(block+1):], uint32(blockOffset(block+1)-width))
+					if _, err := readTextObject(changed, "linux/"+arch, 16, false, builtins); !errors.Is(err, ErrContext) {
+						t.Fatal("missing hash entry acquired an indexed definition", err)
+					}
+				})
+			}
+			if len(view.block(14)) < 23 {
+				t.Fatal("actual original lacks a relocation boundary witness")
+			}
+			for _, reference := range []struct {
+				name  string
+				pkg   uint32
+				bound uint32
+			}{
+				{"self", 2147483643, uint32(counts[0])},
+				{"hashed64", 2147483646, uint32(counts[1])},
+				{"hashed", 2147483645, uint32(counts[2])},
+				{"nonpkg-def-ref", 2147483647, uint32(counts[3] + counts[4])},
+				{"builtin", 2147483644, uint32(len(builtins))},
+				{"foreign-package", uint32(len(view.block(1)) / 8), 0},
+				{"nil-nonzero", 0, 1},
+				{"overflow", 2147483645, math.MaxUint32},
+			} {
+				t.Run("reference-"+reference.name, func(t *testing.T) {
+					changed := append([]byte(nil), original...)
+					offset := blockOffset(14) + 15
+					binary.LittleEndian.PutUint32(changed[offset:], reference.pkg)
+					binary.LittleEndian.PutUint32(changed[offset+4:], reference.bound)
+					if _, err := readTextObject(changed, "linux/"+arch, 16, false, builtins); !errors.Is(err, ErrContext) {
+						t.Fatal("out-of-bound namespace reference acquired a different symbol", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoSDKAssemblyActualDUPokAndStaticRemainIndexed(t *testing.T) {
+	directory, compiler, _ := fixture(t)
+	oracle := officialReaderForSource(t, compiler, sdkTextReaderSource)
+	consumer := filepath.Join(directory, "namedfixture")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goSource := "package namedfixture\nfunc Entry()\n"
+	assembly := "#include \"textflag.h\"\nTEXT sharedWitness(SB),DUPOK|NOSPLIT,$0-0\nRET\n" +
+		"TEXT private<>(SB),NOSPLIT,$0-0\nRET\n"
+	for name, source := range map[string]string{
+		"value.go": goSource, "first.s": assembly + "TEXT ·Entry(SB),NOSPLIT,$0-0\nRET\n", "second.s": assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(consumer, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(compiler)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			raw := run(t, compiler, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly",
+				"-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				Export string
+				SFiles []string
+			}
+			if err := json.Unmarshal(raw, &selected); err != nil || len(selected.SFiles) != 2 {
+				t.Fatal("actual named/static archive source inventory differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			originalRaw := run(t, oracle, consumer, env, selected.Export)
+			var original []TextMember
+			if err := json.Unmarshal(originalRaw, &original); err != nil {
+				t.Fatal(err)
+			}
+			observed, err := ObserveX86SDKAssemblyArchive(archive, builtin, target, selected.SFiles)
+			if err != nil || !reflect.DeepEqual(observed, original) {
+				t.Fatal("original DUPok/static bodies were rejected, lost or selected by name", err)
+			}
+			var duplicate, static []TextRecord
+			for _, member := range observed[2:] {
+				for _, text := range member.Texts {
+					if text.Name == "sharedWitness" {
+						duplicate = append(duplicate, text)
+					}
+					if text.Name == "private" {
+						static = append(static, text)
+					}
+				}
+			}
+			if len(duplicate) != 2 || len(static) != 2 {
+				t.Fatal("legal repeated named/static source bodies were not preserved", len(duplicate), len(static))
+			}
+			for _, text := range duplicate {
+				if text.Namespace != TextSymbolNonpkgDefinition || text.Flags&1 == 0 || text.ABI != 0 {
+					t.Fatal("actual DUPok namespace/ABI differs", text)
+				}
+			}
+			for _, text := range static {
+				if text.ABI != 65535 {
+					t.Fatal("actual static object-local ABI differs", text)
+				}
+			}
+			changed := append([]byte(nil), archive...)
+			members, err := archiveMembers(changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, member := range members[2:] {
+				body, err := objectBody(member.data, target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				view, err := checkedObject(body, 20, false)
+				if err != nil {
+					t.Fatal(err)
+				}
+				symbols, err := view.indexedSymbols()
+				if err != nil {
+					t.Fatal(err)
+				}
+				start := int(binary.LittleEndian.Uint32(body[20+4*3:]))
+				for _, symbol := range symbols {
+					if symbol.Name == "sharedWitness" {
+						body[start+int(symbol.Index)*21+11] &^= 1
+					}
+				}
+			}
+			if _, err := ObserveX86SDKAssemblyArchive(changed, builtin, target, selected.SFiles); !errors.Is(err, ErrContext) {
+				t.Fatal("unproved ordinary named duplicates acquired DUPok observation", err)
+			}
+			retainTextArtifact(t, target, "indexed-named-static", map[string][]byte{
+				"original.a": archive, "original-sdk.json": originalRaw, "selection.json": raw,
+				"source-value.go": []byte(goSource), "source-shared.s": []byte(assembly),
+			})
+		})
+	}
+}
+
+func TestGoSDKAssemblyNamedCollisionPermissions(t *testing.T) {
+	text := indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition, Name: "fixture.Entry", ABI: 0, Kind: 1}
+	for _, control := range []struct {
+		name    string
+		first   indexedObjectSymbol
+		second  indexedObjectSymbol
+		allowed bool
+	}{
+		{"ordinary named duplicate", text, text, false},
+		{"different ABI TEXT", text, func() indexedObjectSymbol { v := text; v.ABI = 1; return v }(), true},
+		{"DUPok observations", func() indexedObjectSymbol { v := text; v.Flags = 1; return v }(), text, true},
+		{"storage collision", text, func() indexedObjectSymbol { v := text; v.Kind = 4; return v }(), false},
+		{"hashed same name", text, func() indexedObjectSymbol { v := text; v.Namespace = TextSymbolHashed; return v }(), true},
+		{"static same name", text, func() indexedObjectSymbol { v := text; v.ABI = 65535; return v }(), true},
+	} {
+		t.Run(control.name, func(t *testing.T) {
+			definitions := make(sdkAssemblyNamedDefinitions)
+			if err := definitions.observe(control.first, false); err != nil {
+				t.Fatal(err)
+			}
+			err := definitions.observe(control.second, false)
+			if (err == nil) != control.allowed {
+				t.Fatal("named collision rule acquired or lost observation permission", err)
+			}
+			if control.allowed && control.second.Namespace == TextSymbolNonpkgDefinition && control.second.ABI != 65535 {
+				if !reflect.DeepEqual(definitions[text.Name], []indexedObjectSymbol{control.first, control.second}) {
+					t.Fatal("named observations selected or discarded a body winner")
+				}
+			}
+		})
+	}
+	definitions := make(sdkAssemblyNamedDefinitions)
+	data := text
+	data.Namespace, data.Kind = TextSymbolHashed, 4
+	if !errors.Is(definitions.observe(data, true), ErrContext) {
+		t.Fatal("a hashed assembly DATA definition bypassed its independent role")
+	}
+}
diff --git a/internal/gostaticstorage/assembly_namespace_reference_go127_test.go b/internal/gostaticstorage/assembly_namespace_reference_go127_test.go
new file mode 100644
index 000000000..77ae7abdb
--- /dev/null
+++ b/internal/gostaticstorage/assembly_namespace_reference_go127_test.go
@@ -0,0 +1,245 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// This separate SDK oracle resolves only actual Aux references to sync/atomic
+// through the target compiler's NSym block, exactly as the official loader.
+// It never falls through into the target's hashed/nonpackage definitions.
+const sdkIndexedAuxReaderSource = `package main
+
+import (
+	"cmd/internal/archive"
+	"cmd/internal/goobj"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type Reference struct {
+	OwnerIndex, AuxiliaryIndex uint32
+	Type uint8
+	PackageIndex, SymbolIndex uint32
+	Package, Name string
+	ABI uint16
+	Kind uint8
+	DiagnosticPresent bool
+}
+
+func compiler(path string) *goobj.Reader {
+	f, err := os.Open(path)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	a, err := archive.Parse(f, false)
+	if err != nil {
+		panic(err)
+	}
+	for _, entry := range a.Entries {
+		if entry.Name != "_go_.o" {
+			continue
+		}
+		data := make([]byte, entry.Obj.Size)
+		n, err := f.ReadAt(data, entry.Obj.Offset)
+		if err != nil || n != len(data) {
+			panic(fmt.Sprint(n, err))
+		}
+		r := goobj.NewReaderFromBytes(data, false)
+		if r == nil {
+			panic("invalid original compiler object")
+		}
+		return r
+	}
+	panic("missing actual compiler member")
+}
+
+func main() {
+	r, target := compiler(os.Args[1]), compiler(os.Args[2])
+	diagnostics := make(map[goobj.SymRef]string)
+	for index := 0; index < r.NRefName(); index++ {
+		diagnostic := r.RefName(index)
+		diagnostics[diagnostic.Sym()] = diagnostic.Name(r)
+	}
+	var result []Reference
+	count := r.NSym() + r.NHashed64def() + r.NHasheddef() + r.NNonpkgdef()
+	for index := uint32(0); index < uint32(count); index++ {
+		for ordinal, auxiliary := range r.Auxs(index) {
+			ref := auxiliary.Sym()
+			if ref.PkgIdx == 0 || ref.PkgIdx >= uint32(r.NPkg()) || r.Pkg(int(ref.PkgIdx)) != "sync/atomic" {
+				continue
+			}
+			if ref.SymIdx >= uint32(target.NSym()) {
+				panic("foreign reference is not in actual SymbolDefs")
+			}
+			symbol := target.Sym(ref.SymIdx)
+			diagnostic, present := diagnostics[ref]
+			if present && diagnostic != symbol.Name(target) {
+				panic("diagnostic differs from actual indexed target")
+			}
+			result = append(result, Reference{OwnerIndex: index, AuxiliaryIndex: uint32(ordinal), Type: auxiliary.Type(),
+				PackageIndex: ref.PkgIdx, SymbolIndex: ref.SymIdx, Package: r.Pkg(int(ref.PkgIdx)),
+				Name: symbol.Name(target), ABI: symbol.ABI(), Kind: symbol.Type(), DiagnosticPresent: present})
+		}
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(result); err != nil {
+		panic(err)
+	}
+}
+`
+
+type indexedAuxOracleReference struct {
+	OwnerIndex, AuxiliaryIndex uint32
+	Type                       uint8
+	PackageIndex, SymbolIndex  uint32
+	Package, Name              string
+	ABI                        uint16
+	Kind                       uint8
+	DiagnosticPresent          bool
+}
+
+func indexedForeignArchiveFixture(t *testing.T, arch string) ([]byte, []byte, map[string]SDKReferencedArchive) {
+	t.Helper()
+	directory, compiler, _ := fixture(t)
+	consumer := filepath.Join(directory, "auxfixture")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goSource := "package auxfixture\nimport \"sync/atomic\"\nvar Flag atomic.Bool\n" +
+		"func Store(value bool) { Flag.Store(value) }\nfunc Entry()\n"
+	assembly := "#include \"textflag.h\"\nTEXT ·Entry(SB),NOSPLIT,$0-0\nRET\n"
+	for name, source := range map[string]string{"value.go": goSource, "entry.s": assembly} {
+		if err := os.WriteFile(filepath.Join(consumer, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	raw := run(t, compiler, consumer, fixtureEnv(t, "linux/"+arch),
+		"list", "-deps", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", "-asmflags=-std", ".")
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	referenced := make(map[string]SDKReferencedArchive)
+	var archive []byte
+	for {
+		var selected struct {
+			ImportPath, Export string
+			SFiles             []string
+			Standard           bool
+		}
+		if err := decoder.Decode(&selected); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		if selected.Export == "" {
+			continue
+		}
+		data, err := os.ReadFile(selected.Export)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if selected.ImportPath == fixtureModule+"/auxfixture" {
+			if selected.Standard || !reflect.DeepEqual(selected.SFiles, []string{"entry.s"}) {
+				t.Fatal("first-party binary format fixture acquired SDK source identity")
+			}
+			archive = data
+		} else {
+			if !selected.Standard {
+				t.Fatal("actual metadata dependency is not this SDK", selected.ImportPath)
+			}
+			referenced[selected.ImportPath] = SDKReferencedArchive{selected.ImportPath, selected.SFiles, data}
+		}
+	}
+	if archive == nil || referenced["sync/atomic"].Archive == nil {
+		t.Fatal("actual SDK dependency/export route is incomplete")
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(compiler)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	retainTextArtifact(t, "linux/"+arch, "indexed-aux", map[string][]byte{
+		"original.a": archive, "atomic-original.a": referenced["sync/atomic"].Archive,
+		"graph.json": raw, "source-value.go": []byte(goSource), "source-entry.s": []byte(assembly),
+	})
+	return archive, builtin, referenced
+}
+
+func TestGoSDKAssemblyActualAuxOnlyIndexedReference(t *testing.T) {
+	_, compiler, _ := fixture(t)
+	oracle := officialReaderForSource(t, compiler, sdkIndexedAuxReaderSource)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			archive, builtin, referenced := indexedForeignArchiveFixture(t, arch)
+			directory := t.TempDir()
+			for name, data := range map[string][]byte{"original.a": archive, "atomic-original.a": referenced["sync/atomic"].Archive} {
+				if err := os.WriteFile(filepath.Join(directory, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			raw := run(t, oracle, directory, fixtureEnv(t, "linux/"+arch),
+				filepath.Join(directory, "original.a"), filepath.Join(directory, "atomic-original.a"))
+			var original []indexedAuxOracleReference
+			if err := json.Unmarshal(raw, &original); err != nil || len(original) == 0 {
+				t.Fatal("independent actual indexed auxiliary references are missing", err)
+			}
+			retainTextArtifact(t, "linux/"+arch, "indexed-aux", map[string][]byte{"aux-sdk.json": raw})
+
+			observed, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, "linux/"+arch, []string{"entry.s"}, referenced)
+			if err != nil || len(observed) != 3 {
+				t.Fatal("actual Aux-only indexed type reference was rejected despite its complete SDK export object", err)
+			}
+			targets, err := sdkReferencedArchiveSymbols(referenced, "linux/"+arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			members, err := archiveMembers(archive)
+			if err != nil {
+				t.Fatal(err)
+			}
+			body, err := objectBody(members[1].data, "linux/"+arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			object, err := checkedObject(body, 16, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			auxOnly := 0
+			for _, expected := range original {
+				ordinal := object.indices[1][expected.OwnerIndex] + expected.AuxiliaryIndex
+				raw := object.block(15)[int(ordinal)*9 : int(ordinal+1)*9]
+				ref := TextReference{PackageIndex: binary.LittleEndian.Uint32(raw[1:]), SymbolIndex: binary.LittleEndian.Uint32(raw[5:])}
+				ref.Package, err = object.stringAt(object.block(1)[int(ref.PackageIndex)*8 : int(ref.PackageIndex+1)*8])
+				if err != nil || raw[0] != expected.Type || ref.PackageIndex != expected.PackageIndex ||
+					ref.SymbolIndex != expected.SymbolIndex || ref.Package != expected.Package {
+					t.Fatal("actual complete original Aux/index route differs from the independent SDK", err)
+				}
+				ref, err = resolveSDKIndexedReference(ref, expected.Name, expected.DiagnosticPresent, targets)
+				if err != nil || ref.Name != expected.Name || ref.ABI != expected.ABI || ref.Kind != expected.Kind ||
+					!ref.ABIKnown || !ref.KindKnown {
+					t.Fatal("actual referenced compiler SymbolDefs differs from the independent SDK", ref, expected, err)
+				}
+				if !expected.DiagnosticPresent && expected.Type == 0 && expected.Name == "type:sync/atomic.Bool" {
+					auxOnly++
+				}
+			}
+			if auxOnly == 0 {
+				t.Fatal("first-party fixture did not independently reproduce the AuxGotype-only reference")
+			}
+			if _, err := ObserveX86SDKAssemblyArchive(archive, builtin, "linux/"+arch, []string{"entry.s"}); err == nil {
+				t.Fatal("SDK observer guessed an unresolved indexed type without actual referenced bytes")
+			}
+			if _, err := ObserveX86AssemblyArchive(archive, builtin, "linux/"+arch, []string{"entry.s"}); err == nil {
+				t.Fatal("default owned observer inherited SDK referenced-object permissions")
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_namespace_reference_guards_go127_test.go b/internal/gostaticstorage/assembly_namespace_reference_guards_go127_test.go
new file mode 100644
index 000000000..3dcd3539f
--- /dev/null
+++ b/internal/gostaticstorage/assembly_namespace_reference_guards_go127_test.go
@@ -0,0 +1,172 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"errors"
+	"math"
+	"testing"
+)
+
+func copySDKReferencedArchives(original map[string]SDKReferencedArchive) map[string]SDKReferencedArchive {
+	result := make(map[string]SDKReferencedArchive, len(original))
+	for path, archive := range original {
+		archive.Sources = append([]string(nil), archive.Sources...)
+		archive.Archive = append([]byte(nil), archive.Archive...)
+		result[path] = archive
+	}
+	return result
+}
+
+func sdkReferencedCompiler(t *testing.T, archive []byte, target string) ([]byte, *checkedGoObject) {
+	t.Helper()
+	members, err := archiveMembers(archive)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err := objectBody(members[1].data, target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	object, err := checkedObject(body, 16, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return body, object
+}
+
+func TestGoSDKAssemblyReferencedArchiveBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			archive, builtin, dependencies := indexedForeignArchiveFixture(t, arch)
+			if _, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, target, []string{"entry.s"}, dependencies); err != nil {
+				t.Fatal("complete actual indexed-reference precondition", err)
+			}
+			_, atomic := sdkReferencedCompiler(t, dependencies["sync/atomic"].Archive, target)
+			selfCount := uint32(len(atomic.block(3)) / 21)
+			originalBody, original := sdkReferencedCompiler(t, archive, target)
+			var auxiliaryOffset int
+			for position := 0; position < len(original.block(15)); position += 9 {
+				auxiliary := original.block(15)[position : position+9]
+				pkg := binary.LittleEndian.Uint32(auxiliary[1:])
+				if pkg == 0 || pkg >= uint32(len(original.block(1))/8) {
+					continue
+				}
+				path, err := original.stringAt(original.block(1)[int(pkg)*8 : int(pkg+1)*8])
+				if err != nil {
+					t.Fatal(err)
+				}
+				if path == "sync/atomic" && auxiliary[0] == 0 {
+					auxiliaryOffset = int(binary.LittleEndian.Uint32(originalBody[20+4*15:])) + position
+					break
+				}
+			}
+			if auxiliaryOffset == 0 {
+				t.Fatal("actual Aux-only foreign boundary is absent")
+			}
+
+			for _, test := range []struct {
+				name   string
+				mutate func(map[string]SDKReferencedArchive)
+			}{
+				{"missing target", func(values map[string]SDKReferencedArchive) { delete(values, "sync/atomic") }},
+				{"missing archive", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					value.Archive = nil
+					values["sync/atomic"] = value
+				}},
+				{"wrong package", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					value.PackagePath = "internal/cpu"
+					values["sync/atomic"] = value
+				}},
+				{"wrong key", func(values map[string]SDKReferencedArchive) {
+					values["../sync/atomic"] = values["sync/atomic"]
+				}},
+				{"missing assembly member", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					value.Sources = nil
+					values["sync/atomic"] = value
+				}},
+				{"foreign assembly member", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					value.Sources[0] = "foreign.s"
+					values["sync/atomic"] = value
+				}},
+				{"foreign compiler member", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					members, err := archiveMembers(value.Archive)
+					if err != nil {
+						t.Fatal(err)
+					}
+					value.Archive[int(members[1].offset)-60] = 'x'
+					values["sync/atomic"] = value
+				}},
+				{"truncated archive", func(values map[string]SDKReferencedArchive) {
+					value := values["sync/atomic"]
+					value.Archive = value.Archive[:len(value.Archive)-1]
+					values["sync/atomic"] = value
+				}},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					changed := copySDKReferencedArchives(dependencies)
+					test.mutate(changed)
+					if _, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, target, []string{"entry.s"}, changed); !errors.Is(err, ErrContext) {
+						t.Fatal("invalid referenced archive acquired metadata", err)
+					}
+				})
+			}
+			for _, bound := range []uint32{selfCount, selfCount + 1, selfCount + uint32(len(atomic.block(4))/21), math.MaxUint32} {
+				t.Run("NSym boundary", func(t *testing.T) {
+					changed := append([]byte(nil), archive...)
+					body, _ := sdkReferencedCompiler(t, changed, target)
+					binary.LittleEndian.PutUint32(body[auxiliaryOffset+5:], bound)
+					if _, err := ObserveX86SDKAssemblyArchiveReferences(changed, builtin, target, []string{"entry.s"}, dependencies); !errors.Is(err, ErrContext) {
+						t.Fatal("foreign SymIdx crossed into a hashed/nonpackage namespace", bound, err)
+					}
+				})
+			}
+			for _, flags := range []uint32{0, 4, 17, 24} {
+				t.Run("compiler flags", func(t *testing.T) {
+					changed := copySDKReferencedArchives(dependencies)
+					body, _ := sdkReferencedCompiler(t, changed["sync/atomic"].Archive, target)
+					binary.LittleEndian.PutUint32(body[16:], flags)
+					if _, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, target, []string{"entry.s"}, changed); !errors.Is(err, ErrContext) {
+						t.Fatal("foreign flags acquired SDK indexed metadata", flags, err)
+					}
+				})
+			}
+			other := "linux/amd64"
+			if arch == "amd64" {
+				other = "linux/386"
+			}
+			if _, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, other, []string{"entry.s"}, dependencies); !errors.Is(err, ErrContext) {
+				t.Fatal("referenced archive changed target identity", err)
+			}
+			for _, abi := range []uint16{2, 65535} {
+				t.Run("unknown or object-local ABI", func(t *testing.T) {
+					changed := copySDKReferencedArchives(dependencies)
+					body, _ := sdkReferencedCompiler(t, changed["sync/atomic"].Archive, target)
+					index := binary.LittleEndian.Uint32(originalBody[auxiliaryOffset+5:])
+					start := int(binary.LittleEndian.Uint32(body[20+4*3:])) + int(index)*21
+					binary.LittleEndian.PutUint16(body[start+8:], abi)
+					if _, err := ObserveX86SDKAssemblyArchiveReferences(archive, builtin, target, []string{"entry.s"}, changed); !errors.Is(err, ErrContext) {
+						t.Fatal("foreign target guessed an unknown/object-local ABI", abi, err)
+					}
+				})
+			}
+			if len(original.block(17)) == 0 {
+				t.Fatal("actual source object lacks diagnostic-name negative control")
+			}
+			changed := append([]byte(nil), archive...)
+			body, _ := sdkReferencedCompiler(t, changed, target)
+			start := int(binary.LittleEndian.Uint32(body[20+4*17:]))
+			copy(body[start:start+8], originalBody[auxiliaryOffset+1:auxiliaryOffset+9])
+			if _, err := ObserveX86SDKAssemblyArchiveReferences(changed, builtin, target, []string{"entry.s"}, dependencies); !errors.Is(err, ErrContext) {
+				t.Fatal("diagnostic RefName overrode actual compiler index identity", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_text.go b/internal/gostaticstorage/assembly_text.go
new file mode 100644
index 000000000..11a04f264
--- /dev/null
+++ b/internal/gostaticstorage/assembly_text.go
@@ -0,0 +1,235 @@
+package gostaticstorage
+
+import (
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// ObserveARM64AssemblyText is an offline original-object observation. It does
+// not construct a live source, caller carrier, entry adapter or frame slot.
+func ObserveARM64AssemblyText(data, builtinSource []byte, target string) ([]TextRecord, error) {
+	if !arm64AssemblyObservationTarget(target) {
+		return nil, contextError("unobserved ARM64 assembly target")
+	}
+	return observeAssemblyText(data, builtinSource, target)
+}
+
+// ObserveARM64AssemblyArchive retains original caller/callee records only.
+// Neither selected source names nor a successful decode grant LLVM authority.
+func ObserveARM64AssemblyArchive(data, builtinSource []byte, target string, sources []string) ([]TextMember, error) {
+	if !arm64AssemblyObservationTarget(target) {
+		return nil, contextError("unobserved ARM64 assembly archive target")
+	}
+	return observeAssemblyArchive(data, builtinSource, target, sources, false)
+}
+
+func arm64AssemblyObservationTarget(target string) bool {
+	switch target {
+	case "darwin/arm64", "linux/arm64", "windows/arm64", "freebsd/arm64", "openbsd/arm64":
+		return true
+	}
+	return false
+}
+
+// ObserveX86AssemblyText decodes complete original Go assembler object bytes.
+// It is an offline observation: neither these bytes nor its return value create
+// an Observation, a live source lease or a memory/entry permission.
+func ObserveX86AssemblyText(data, builtinSource []byte, target string) ([]TextRecord, error) {
+	if !X86SDKTarget(target) {
+		return nil, contextError("unobserved x86 assembly target")
+	}
+	return observeAssemblyText(data, builtinSource, target)
+}
+
+func observeAssemblyText(data, builtinSource []byte, target string) ([]TextRecord, error) {
+	builtins, err := textBuiltins(builtinSource)
+	if err != nil {
+		return nil, err
+	}
+	body, err := objectBody(data, target)
+	if err != nil {
+		return nil, err
+	}
+	return readTextObject(body, target, 4, false, builtins)
+}
+
+// ObserveX86AssemblyArchive retains every member of a bounded owned-main Go
+// archive. sources is selection metadata, not authority. A live factory must
+// independently bind that actual selection, the SDK work/gc.go member route,
+// original source and standalone assembler output before using any record.
+func ObserveX86AssemblyArchive(data, builtinSource []byte, target string, sources []string) ([]TextMember, error) {
+	return observeX86AssemblyArchive(data, builtinSource, target, sources, false)
+}
+
+func observeX86AssemblyArchive(data, builtinSource []byte, target string, sources []string, sdk bool) ([]TextMember, error) {
+	if !X86SDKTarget(target) || !sdk && target != "linux/386" && target != "linux/amd64" {
+		return nil, contextError("unobserved x86 assembly archive target")
+	}
+	return observeAssemblyArchive(data, builtinSource, target, sources, sdk)
+}
+
+func observeAssemblyArchive(data, builtinSource []byte, target string, sources []string, sdk bool) ([]TextMember, error) {
+	return observeAssemblyArchiveReferences(data, builtinSource, target, sources, sdk, nil, nil)
+}
+
+func observeAssemblyArchiveReferences(data, builtinSource []byte, target string, sources []string, sdk bool, referenced sdkReferencedSymbols, calls map[string]bool) ([]TextMember, error) {
+	builtins, err := textBuiltins(builtinSource)
+	if err != nil {
+		return nil, err
+	}
+	members, err := archiveMembers(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(sources) == 0 || len(members) != len(sources)+2 || members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+		return nil, contextError("assembly archive differs from selected member inventory")
+	}
+	var sdkNames []string
+	if sdk {
+		sdkNames, err = sdkAssemblyMemberNames(sources)
+		if err != nil {
+			return nil, err
+		}
+	}
+	seenSources := make(map[string]bool)
+	definitions := make(map[string]bool)
+	storage := make(map[string]bool)
+	sdkDefinitions := make(sdkAssemblyNamedDefinitions)
+	// Preserve the independent archive role; direct tool asm observations
+	// below still require their own exact flags instead of this profile.
+	compilerFlags := sdkCompilerObjectFlags(target) &^ 16
+	result := []TextMember{{Name: members[0].name, Offset: members[0].offset, Size: int64(len(members[0].data))}}
+	for index, member := range members[1:] {
+		flags := compilerFlags
+		if sdk {
+			flags |= 16 // ObjFlagStd in the independently pinned Go 1.27.1 format.
+		}
+		if index != 0 {
+			name := sources[index-1]
+			memberName := strings.TrimSuffix(name, ".s") + ".o"
+			if sdk {
+				memberName = sdkNames[index-1]
+			}
+			if filepath.Base(name) != name || !strings.HasSuffix(name, ".s") || seenSources[name] || member.name != memberName {
+				return nil, contextError("assembly source/member route differs")
+			}
+			seenSources[name] = true
+			flags |= 4
+		}
+		reader := objectBody
+		if sdk && index == 0 {
+			reader = sdkObjectBody
+		}
+		body, err := reader(member.data, target)
+		if err != nil {
+			return nil, err
+		}
+		var sdkObject *checkedGoObject
+		if !sdk {
+			records, err := assemblyArchiveDefinitions(body, flags)
+			if err != nil {
+				return nil, err
+			}
+			for _, record := range records {
+				name := record.Name
+				key := name + "\x00" + strconv.Itoa(int(record.ABI))
+				if definitions[key] || storage[name] || index != 0 && record.Kind != 1 {
+					return nil, contextError("duplicate same-ABI/storage or assembly DATA definition")
+				}
+				definitions[key] = true
+				storage[name] = record.Kind != 1
+			}
+		} else {
+			object, err := checkedSDKObject(body, flags, index != 0)
+			if err != nil {
+				return nil, err
+			}
+			sdkObject = object
+			symbols, err := object.indexedSymbols()
+			if err != nil {
+				return nil, err
+			}
+			for _, symbol := range symbols {
+				if err := sdkDefinitions.observeCallText(symbol, index != 0, calls); err != nil {
+					return nil, err
+				}
+			}
+		}
+		var texts []TextRecord
+		if sdk {
+			texts, err = readCheckedTextObjectKinds(sdkObject, target, builtins, referenced, true)
+		} else {
+			texts, err = readTextObjectReferences(body, target, flags, false, builtins, referenced)
+		}
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, TextMember{Name: member.name, Offset: member.offset, Size: int64(len(member.data)), Flags: flags, Texts: texts})
+	}
+	return result, nil
+}
+
+// The legacy owned/DATA reader intentionally retains its strict named view.
+// SDK indexed observation uses a separate path, never widening this one.
+func assemblyArchiveDefinitions(data []byte, flags uint32) ([]dataRecord, error) {
+	records, err := readObjectRole(data, flags, false)
+	if err != nil {
+		return nil, err
+	}
+	values := make([]dataRecord, 0, len(records))
+	for _, record := range records {
+		values = append(values, record)
+	}
+	return values, nil
+}
+
+// ObserveX86SDKAssemblyArchive observes an original SDK archive. This offline
+// decoder does not establish SDK source provenance, storage or native entry
+// authority; its caller must independently authenticate those roles.
+func ObserveX86SDKAssemblyArchive(data, builtinSource []byte, target string, sources []string) ([]TextMember, error) {
+	return observeX86AssemblyArchive(data, builtinSource, target, sources, true)
+}
+
+// SDKReferencedArchive is offline metadata input, not SDK provenance or a
+// storage/entry certificate. A live producer separately seals its actual
+// selected dependency path, member inventory and complete original bytes.
+type SDKReferencedArchive struct {
+	PackagePath string
+	Sources     []string
+	Archive     []byte
+}
+
+// ObserveX86SDKAssemblyArchiveReferences additionally observes indexed
+// references through separately retained actual dependency archives.
+func ObserveX86SDKAssemblyArchiveReferences(data, builtinSource []byte, target string, sources []string, referenced map[string]SDKReferencedArchive) ([]TextMember, error) {
+	if !X86SDKTarget(target) {
+		return nil, contextError("unobserved SDK indexed-reference target")
+	}
+	symbols, err := sdkReferencedArchiveSymbols(referenced, target)
+	if err != nil {
+		return nil, err
+	}
+	return observeAssemblyArchiveReferences(data, builtinSource, target, sources, true, symbols, nil)
+}
+
+// ObserveX86SDKCallArchiveReferences projects callable TEXT only. Unrelated
+// compiler/assembly storage keeps its complete object/reference validation,
+// but supplies no DATA identity, selected winner or memory permission. Every
+// TEXT collision and every requested name's storage collision remains strict.
+func ObserveX86SDKCallArchiveReferences(data, builtinSource []byte, target string, sources []string,
+	referenced map[string]SDKReferencedArchive, calls map[string]bool) ([]TextMember, error) {
+	if !X86SDKTarget(target) || len(calls) == 0 || len(calls) > 4096 {
+		return nil, contextError("SDK call TEXT needs its bounded target inventory")
+	}
+	for name, requested := range calls {
+		if name == "" || !requested {
+			return nil, contextError("SDK call TEXT has an invalid requested name")
+		}
+	}
+	symbols, err := sdkReferencedArchiveSymbols(referenced, target)
+	if err != nil {
+		return nil, err
+	}
+	return observeAssemblyArchiveReferences(data, builtinSource, target, sources, true, symbols, calls)
+}
diff --git a/internal/gostaticstorage/assembly_text_go127_test.go b/internal/gostaticstorage/assembly_text_go127_test.go
new file mode 100644
index 000000000..a6b635917
--- /dev/null
+++ b/internal/gostaticstorage/assembly_text_go127_test.go
@@ -0,0 +1,124 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoStaticStorageX86AssemblyCompleteOriginalSDKReader(t *testing.T) {
+	directory, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	consumer := filepath.Join(directory, "asmconsumer")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	goSource := `package asmconsumer
+import owner "example.invalid/staticstorage"
+var _ = owner.Keys
+func Feature() byte
+func Other() byte
+`
+	if err := os.WriteFile(filepath.Join(consumer, "value.go"), []byte(goSource), 0600); err != nil {
+		t.Fatal(err)
+	}
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			originalSource := "#include \"textflag.h\"\nTEXT ·Feature(SB),NOSPLIT,$0-1\n" +
+				"CMPB internal∕cpu·X86+64(SB),$1\nMOVB internal∕cpu·X86+65(SB),AL\nMOVB AL,ret+0(FP)\nRET\n"
+			otherSource := "#include \"textflag.h\"\nTEXT ·Other(SB),NOSPLIT,$0-1\n" +
+				"MOVB example·invalid∕staticstorage·Keys+1(SB),AL\nMOVB AL,ret+0(FP)\nRET\n"
+			first, second := "first_"+arch+".s", "second_"+arch+".s"
+			for name, source := range map[string]string{first: originalSource, second: otherSource} {
+				if err := os.WriteFile(filepath.Join(consumer, name), []byte(source), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			selection := run(t, binary, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly", ".")
+			var selected struct {
+				Export string
+				SFiles []string
+			}
+			if err := json.Unmarshal(selection, &selected); err != nil || len(selected.SFiles) != 2 {
+				t.Fatal("actual selected assembler member inventory differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, consumer, env, selected.Export)
+			var official []TextMember
+			if err := json.Unmarshal(raw, &official); err != nil || len(official) != 4 {
+				t.Fatal("independent SDK all-member reader differs", err)
+			}
+			observed, err := ObserveX86AssemblyArchive(archive, builtin, target, selected.SFiles)
+			if err != nil || !reflect.DeepEqual(observed, official) {
+				t.Fatal("whole compiler/assembler archive differs from SDK reader", err)
+			}
+			for _, mutation := range []struct {
+				name    string
+				target  string
+				sources []string
+			}{
+				{"unobserved target", "darwin/amd64", selected.SFiles},
+				{"source order", target, []string{selected.SFiles[1], selected.SFiles[0]}},
+				{"duplicate source", target, []string{selected.SFiles[0], selected.SFiles[0]}},
+				{"missing member", target, selected.SFiles[:1]},
+				{"source path alias", target, []string{"./" + selected.SFiles[0], selected.SFiles[1]}},
+			} {
+				t.Run(mutation.name, func(t *testing.T) {
+					if _, err := ObserveX86AssemblyArchive(archive, builtin, mutation.target, mutation.sources); err == nil {
+						t.Fatal("offline decoder accepted changed archive target/member/source role")
+					}
+				})
+			}
+			objectPath := filepath.Join(filepath.Dir(oracle), "assembly-"+arch+".o")
+			listing := run(t, binary, consumer, env, "tool", "asm", "-S", "-p", fixtureModule+"/asmconsumer", "-I",
+				filepath.Join(filepath.Dir(filepath.Dir(binary)), "pkg", "include"), "-o", objectPath, filepath.Join(consumer, first))
+			object, err := os.ReadFile(objectPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			standaloneRaw := run(t, oracle, consumer, env, objectPath)
+			var standalone []TextMember
+			if err := json.Unmarshal(standaloneRaw, &standalone); err != nil || len(standalone) != 1 {
+				t.Fatal("independent standalone SDK reader differs", err)
+			}
+			texts, err := ObserveX86AssemblyText(object, builtin, target)
+			if err != nil || !reflect.DeepEqual(texts, standalone[0].Texts) {
+				t.Fatal("complete original assembler object differs from SDK reader", err)
+			}
+			if len(texts) != 1 || len(texts[0].Relocations) != 2 || !strings.Contains(string(listing), "internal/cpu.X86") {
+				t.Fatal("independent full CMP immediate/MOV relocation witness was not consumed")
+			}
+			for _, member := range observed {
+				if member.Name == strings.TrimSuffix(first, ".s")+".o" && !reflect.DeepEqual(member.Texts, texts) {
+					t.Fatal("actual original assembler object/archive member TEXT identity differs")
+				}
+			}
+			encoded, err := json.Marshal(observed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			retainTextArtifact(t, target, "numerical-read-assembly", map[string][]byte{
+				"archive-original.a": archive, "archive-sdk.json": raw, "archive-observed.json": encoded,
+				"object-original.o": object, "object-sdk.json": standaloneRaw, "object-listing.txt": listing,
+				"selection.json": selection, "source-first.s": []byte(originalSource), "source-second.s": []byte(otherSource),
+				"source-value.go": []byte(goSource), "builtin-source.go": builtin,
+			})
+			t.Logf("ACTUAL_NUMERICAL_READ_ARCHIVE target=%s archiveSHA256=%s objectSHA256=%s members=%d",
+				target, digest(archive), digest(object), len(observed))
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_text_source.go b/internal/gostaticstorage/assembly_text_source.go
new file mode 100644
index 000000000..eada51d87
--- /dev/null
+++ b/internal/gostaticstorage/assembly_text_source.go
@@ -0,0 +1,94 @@
+package gostaticstorage
+
+// ASMSourceText associates one source TEXT ordinal with its unchanged physical
+// goobj record. It is diagnostic metadata, never native entry/call/result or
+// storage authority. ObjectOrdinal indexes Member.Texts, not source order.
+type ASMSourceText struct {
+	SourceOrdinal, ObjectOrdinal int
+	Name                         string
+	ABI                          uint16
+	Namespace                    TextSymbolNamespace
+	Relative, Index              uint32
+}
+
+// ASMSourceTextOrder retains the actual assembler's namespace/index ordering
+// while checking a complete one-to-one source association. Go NumberSyms puts
+// static ASM definitions in Self and all nonstatic ASM definitions in Nonpkg;
+// it preserves declaration order inside each bank, not across the banks.
+// Linkshared/content-addressable TEXT needs a separate observed source role.
+func ASMSourceTextOrder(source []byte, packagePath string, member ASMDataMember) ([]ASMSourceText, error) {
+	statements, err := asmDataStatements(source)
+	if err != nil {
+		return nil, err
+	}
+	type key struct {
+		name string
+		abi  uint16
+		ns   TextSymbolNamespace
+	}
+	var names []key
+	for _, statement := range statements {
+		if statement[0].text != "TEXT" {
+			continue
+		}
+		operands := asmDataOperands(statement[1:])
+		if len(operands) != 2 && len(operands) != 3 {
+			return nil, contextError("source TEXT declaration has an invalid operand inventory")
+		}
+		symbol, err := asmDataSymbol(operands[0], packagePath)
+		if err != nil || symbol.Addend != 0 {
+			return nil, contextError("source TEXT declaration lacks its exact symbol/ABI")
+		}
+		namespace := TextSymbolNonpkgDefinition
+		if symbol.Static {
+			namespace = TextSymbolSelf
+		}
+		names = append(names, key{symbol.Name, symbol.ABI, namespace})
+	}
+	if len(names) != len(member.Texts) {
+		return nil, contextError("source TEXT declaration inventory differs from the complete actual object")
+	}
+	if len(names) == 0 {
+		return nil, nil
+	}
+	if member.Flags&4 == 0 {
+		return nil, contextError("source TEXT association requires an actual assembler object role")
+	}
+	physical := make(map[key]int, len(names))
+	indices := make(map[uint32]bool, len(names))
+	var previous TextRecord
+	for ordinal, record := range member.Texts {
+		if record.Name == "" || !currentSDKObjectIsText(record.Kind) ||
+			record.Namespace != TextSymbolSelf && record.Namespace != TextSymbolNonpkgDefinition ||
+			record.Namespace == TextSymbolSelf && (record.ABI != 65535 || record.Index != record.Relative) ||
+			record.Namespace == TextSymbolNonpkgDefinition && record.ABI != 0 && record.ABI != 1 ||
+			record.Index < record.Relative || indices[record.Index] {
+			return nil, contextError("source TEXT has an unknown/duplicate physical symbol role")
+		}
+		if ordinal != 0 && (record.Index <= previous.Index || record.Namespace < previous.Namespace ||
+			record.Namespace == previous.Namespace && (record.Relative <= previous.Relative ||
+				record.Index-record.Relative != previous.Index-previous.Relative)) {
+			return nil, contextError("source TEXT physical namespace/index order differs")
+		}
+		identity := key{record.Name, record.ABI, record.Namespace}
+		if _, duplicate := physical[identity]; duplicate {
+			return nil, contextError("source TEXT has duplicate symbol/ABI/namespace identities")
+		}
+		physical[identity], indices[record.Index], previous = ordinal, true, record
+	}
+	result := make([]ASMSourceText, len(names))
+	used := make(map[int]bool, len(names))
+	last := make(map[TextSymbolNamespace]int)
+	for ordinal, identity := range names {
+		objectOrdinal, found := physical[identity]
+		prior, hasPrior := last[identity.ns]
+		if !found || used[objectOrdinal] || hasPrior && objectOrdinal <= prior {
+			return nil, contextError("source TEXT symbol/ABI/namespace/ordinal differs from the exact original body")
+		}
+		record := member.Texts[objectOrdinal]
+		result[ordinal] = ASMSourceText{SourceOrdinal: ordinal, ObjectOrdinal: objectOrdinal,
+			Name: record.Name, ABI: record.ABI, Namespace: record.Namespace, Relative: record.Relative, Index: record.Index}
+		used[objectOrdinal], last[identity.ns] = true, objectOrdinal
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/assembly_text_source_order_go127_test.go b/internal/gostaticstorage/assembly_text_source_order_go127_test.go
new file mode 100644
index 000000000..8e42c6ec3
--- /dev/null
+++ b/internal/gostaticstorage/assembly_text_source_order_go127_test.go
@@ -0,0 +1,77 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestGoASMTextMixedNamespaceSourceOrder(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	oracle := officialReaderForSource(t, driver, sdkTextReaderSource)
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(driver)), builtinSourceRole))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// An ordinary standalone encoder fixture, not an SDK/native-entry role.
+	// Source interleaves foreign, package and static definitions deliberately.
+	source := []byte(`TEXT foreign∕pkg·First(SB),4,$0-0
+	MOVQ $101, AX
+	RET
+TEXT ·OwnOne(SB),4,$0-0
+	MOVQ $202, AX
+	RET
+TEXT private<>(SB),4,$0-0
+	XORQ AX, AX
+	RET
+TEXT foreign∕pkg·Second(SB),4,$0-0
+	MOVQ $303, AX
+	RET
+TEXT ·OwnTwo(SB),4,$0-0
+	MOVQ $404, AX
+	RET
+`)
+	name := filepath.Join(directory, "mixed.asm")
+	if err := os.WriteFile(name, source, 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			environment := fixtureEnv(t, target)
+			objectPath := filepath.Join(t.TempDir(), "mixed.o")
+			run(t, driver, directory, environment, "tool", "asm", "-p", fixtureModule, "-o", objectPath, name)
+			object, err := os.ReadFile(objectPath)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var actual []TextMember
+			if err := json.Unmarshal(run(t, oracle, directory, environment, objectPath), &actual); err != nil || len(actual) != 1 {
+				t.Fatal("actual original Go TEXT reader", err)
+			}
+			for _, record := range actual[0].Texts {
+				t.Logf("physical TEXT namespace=%d index=%d relative=%d name=%q ABI=%d", record.Namespace, record.Index, record.Relative, record.Name, record.ABI)
+			}
+			observed, err := ObserveAMD64AssemblyData(source, object, builtin, fixtureModule, target)
+			if err != nil {
+				t.Fatal("complete source TEXT association failed", err)
+			}
+			if !reflect.DeepEqual(observed.Member.Texts, actual[0].Texts) {
+				t.Fatal("source association reordered/rewrote original physical records")
+			}
+			var order []int
+			for ordinal, association := range observed.TextOrder {
+				if association.SourceOrdinal != ordinal {
+					t.Fatal("source TEXT ordinal changed", association)
+				}
+				order = append(order, association.ObjectOrdinal)
+			}
+			if !reflect.DeepEqual(order, []int{1, 2, 0, 3, 4}) {
+				t.Fatal("actual original namespace/index association differs", order)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/assembly_text_source_test.go b/internal/gostaticstorage/assembly_text_source_test.go
new file mode 100644
index 000000000..f686b3342
--- /dev/null
+++ b/internal/gostaticstorage/assembly_text_source_test.go
@@ -0,0 +1,93 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func asmTextSourceOrderFixture() ([]byte, ASMDataMember) {
+	source := []byte(`TEXT foreign·Entry<ABIInternal>(SB),4,$0-0
+RET
+TEXT private<>(SB),4,$0-0
+RET
+TEXT ·Own<ABI0>(SB),4,$0-0
+RET
+TEXT other<>(SB),4,$0-0
+RET
+TEXT foreign·Second<ABI0>(SB),4,$0-0
+RET
+`)
+	member := ASMDataMember{Flags: 4, Texts: []TextRecord{
+		{Name: "private", ABI: 65535, Namespace: TextSymbolSelf, Index: 0, Relative: 0, Kind: 1, Size: 1, Code: []byte{0xc3}},
+		{Name: "other", ABI: 65535, Namespace: TextSymbolSelf, Index: 1, Relative: 1, Kind: 1, Size: 1, Code: []byte{0xc3}},
+		{Name: "foreign.Entry", ABI: 1, Namespace: TextSymbolNonpkgDefinition, Index: 20, Relative: 0, Kind: 1, Size: 1, Code: []byte{0xc3}},
+		{Name: "fixture.Own", ABI: 0, Namespace: TextSymbolNonpkgDefinition, Index: 21, Relative: 1, Kind: 1, Size: 1, Code: []byte{0xc3}},
+		{Name: "foreign.Second", ABI: 0, Namespace: TextSymbolNonpkgDefinition, Index: 22, Relative: 2, Kind: 1, Size: 1, Code: []byte{0xc3}},
+	}}
+	return source, member
+}
+
+func TestASMSourceTextOrderPreservesPhysicalRecords(t *testing.T) {
+	source, member := asmTextSourceOrderFixture()
+	before, _ := json.Marshal(member)
+	order, err := ASMSourceTextOrder(source, "fixture", member)
+	if err != nil || len(order) != len(member.Texts) {
+		t.Fatal("complete mixed-bank association", err)
+	}
+	var indices []int
+	for ordinal, association := range order {
+		indices = append(indices, association.ObjectOrdinal)
+		record := member.Texts[association.ObjectOrdinal]
+		if association.SourceOrdinal != ordinal || association.Name != record.Name || association.ABI != record.ABI ||
+			association.Namespace != record.Namespace || association.Relative != record.Relative || association.Index != record.Index {
+			t.Fatal("association lost an exact source/physical identity", association, record)
+		}
+	}
+	after, _ := json.Marshal(member)
+	if !reflect.DeepEqual(indices, []int{2, 0, 3, 1, 4}) || !bytes.Equal(before, after) {
+		t.Fatal("source association sorted/rewrote physical evidence", indices)
+	}
+}
+
+func TestASMSourceTextOrderCompleteIdentityGuards(t *testing.T) {
+	for _, row := range []struct {
+		name   string
+		mutate func(*[]byte, *ASMDataMember)
+	}{
+		{"missing", func(_ *[]byte, m *ASMDataMember) { m.Texts = m.Texts[:4] }},
+		{"duplicate-record", func(_ *[]byte, m *ASMDataMember) { m.Texts[4] = m.Texts[3] }},
+		{"duplicate-source", func(s *[]byte, _ *ASMDataMember) {
+			*s = bytes.Replace(*s, []byte("foreign·Second<ABI0>"), []byte("foreign·Entry<ABIInternal>"), 1)
+		}},
+		{"wrong-ABI", func(s *[]byte, _ *ASMDataMember) {
+			*s = bytes.Replace(*s, []byte("Own<ABI0>"), []byte("Own<ABIInternal>"), 1)
+		}},
+		{"wrong-static-role", func(s *[]byte, _ *ASMDataMember) { *s = bytes.Replace(*s, []byte("private<>"), []byte("private"), 1) }},
+		{"unknown-name", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].Name = "foreign.Unknown" }},
+		{"unknown-ABI", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].ABI = 9 }},
+		{"unknown-kind", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].Kind = 3 }},
+		{"hashed-role", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].Namespace = TextSymbolHashed }},
+		{"reference-role", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].Namespace = TextSymbolNonpkgReference }},
+		{"wrong-static-namespace", func(_ *[]byte, m *ASMDataMember) { m.Texts[0].Namespace = TextSymbolNonpkgDefinition }},
+		{"wrong-named-namespace", func(_ *[]byte, m *ASMDataMember) { m.Texts[2].Namespace = TextSymbolSelf }},
+		{"duplicate-index", func(_ *[]byte, m *ASMDataMember) { m.Texts[3].Index = m.Texts[2].Index }},
+		{"wrong-relative", func(_ *[]byte, m *ASMDataMember) { m.Texts[3].Relative++ }},
+		{"physical-order", func(_ *[]byte, m *ASMDataMember) { m.Texts[0], m.Texts[1] = m.Texts[1], m.Texts[0] }},
+		{"source-order-in-bank", func(s *[]byte, _ *ASMDataMember) {
+			*s = []byte(strings.NewReplacer("private<>", "other<>", "other<>", "private<>").Replace(string(*s)))
+		}},
+		{"compiler-not-ASM", func(_ *[]byte, m *ASMDataMember) { m.Flags = 16 }},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source, member := asmTextSourceOrderFixture()
+			row.mutate(&source, &member)
+			if _, err := ASMSourceTextOrder(source, "fixture", member); !errors.Is(err, ErrContext) {
+				t.Fatal("unknown/duplicate/missing/exchanged identity acquired an association", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/capture.go b/internal/gostaticstorage/capture.go
new file mode 100644
index 000000000..91fab8882
--- /dev/null
+++ b/internal/gostaticstorage/capture.go
@@ -0,0 +1,571 @@
+package gostaticstorage
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"go/token"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gooriginalsrc"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+const Protocol = "actual_go_static_numeric_storage_prototype_v1"
+
+// Request supplies actual input locations and references, not permissions.
+// The prototype accepts an ordinary pure-Go flat main module and its actual
+// same-module imports only. It does not download modules or load test variants.
+type Request struct {
+	GoBinary, Directory, PackagePath, Target string
+	Environment                              []string
+	Variables                                []Reference
+}
+
+type Reference struct{ PackagePath, Name string }
+type Span struct{ Offset, Length int64 }
+
+// Variable records initialized numerical storage, never a constant value after
+// initialization. uintptr bits here grant no pointer/address permission.
+type Variable struct {
+	Reference
+	NativeName, GoType string
+	Size, Alignment    int64 // zero object Alignment means unspecified, not inferred
+	Kind               uint8
+	Numerical          []Span
+	DefinitionMember   string
+	DefinitionIndex    uint32
+}
+
+type Package struct {
+	Dir, ImportPath, Name, Export, ForTest                      string
+	Root                                                        string
+	GoFiles, CompiledGoFiles, SFiles, HFiles, CgoFiles, Imports []string
+	EmbedFiles, EmbedPatterns, CFiles, CXXFiles, MFiles, FFiles []string
+	SwigFiles, SwigCXXFiles, SysoFiles                          []string
+	Standard                                                    bool
+	Goroot                                                      bool
+	ImportMap                                                   map[string]string
+	Module                                                      *struct {
+		Path, Version, Dir, GoMod string
+		Main                      bool
+		Replace                   json.RawMessage
+	}
+	Error      json.RawMessage
+	DepsErrors []json.RawMessage
+}
+
+// Report retains complete bounded original bytes so a reader can recompute
+// hashes and binary records. Its JSON is an observation, not a sealed authority.
+// Physical paths are private invocation artifacts; this is not ledger format.
+type Report struct {
+	Protocol, Target, PackagePath string
+	Environment                   map[string]string
+	RawEnvironment, RawSelection  []byte
+	Source                        map[string][]byte
+	SourceSHA256                  map[string]string
+	Archives                      map[string][]byte
+	ArchiveSHA256                 map[string]string
+	Tools                         map[string]string
+	Variables                     []Variable
+	CommandDirectory              string
+	CommandArguments              []string
+	CommandBinary                 string
+	CommandEnvironment            map[string]string
+	TextProtocol                  string
+	TextBuiltinSource             []byte
+	TextArchives                  map[string][]TextMember
+}
+
+// Observation can be created only by Capture's actual command/source boundary.
+// It is not wired to translation or declaration-only result initialization.
+type Observation struct {
+	mu      sync.Mutex
+	ready   bool
+	request Request
+	report  Report
+	inputs  map[string]string
+	dirs    map[string]os.FileInfo
+	seal    [32]byte
+}
+
+var formatSources = map[string]string{
+	"src/cmd/internal/goobj/objfile.go":    "caf835a17e23aa02cae9bda6e8723d8be359846fc4453bd53f3a3947744b938a",
+	"src/cmd/internal/archive/archive.go":  "7e7a3af16eef5c6140145f245ae21147b42a462def4d6e043a74b54710a083a1",
+	"src/cmd/internal/objabi/symkind.go":   "de287864b7ff9a3614becc538cbabdccdecc030a848aad5d5bbef6ec7ec5c225",
+	"src/cmd/internal/objfile/goobj.go":    "5411305140a7f5cd3f61f826d1b6fbbab155db6c94fd263a7ecf1a570e80dc04",
+	"src/cmd/internal/sys/arch.go":         "07ac549fe63e0df269822d5b10b704ca710489b2aa25e176df5d98f2a2c6b8f2",
+	"src/cmd/internal/objabi/reloctype.go": "49bebd30a27d05a24de77398ab524dfbeb0630c8b88c06646c1e4734e4f1fc9d",
+	"src/cmd/internal/obj/pcln.go":         "c165134b74c7e6f908d852551280b45ca58b580226ec27aa345bb869b554448f",
+	builtinSourceRole:                      "8f38ef757cdebb27963ee9befe24dd8041b86d217937db30f13e4d3d91207311",
+}
+
+func digest(data []byte) string {
+	value := sha256.Sum256(data)
+	return hex.EncodeToString(value[:])
+}
+
+func readRegular(name string, limit int64) ([]byte, error) {
+	resolved, resolveErr := sourcepath.Resolve(name)
+	info, err := sourcepath.Lstat(name)
+	if resolveErr != nil || resolved != name || err != nil || !info.Mode().IsRegular() || info.Size() < 0 || info.Size() > limit {
+		return nil, contextError("missing, redirected or oversized regular input: " + name)
+	}
+	f, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+	opened, err := f.Stat()
+	if err != nil || !os.SameFile(info, opened) {
+		return nil, contextError("input changed while opening")
+	}
+	data, err := io.ReadAll(io.LimitReader(f, limit+1))
+	if err != nil || int64(len(data)) != info.Size() {
+		return nil, contextError("input changed or exceeded read bound")
+	}
+	return data, nil
+}
+
+func within(root, name string) bool {
+	rel, err := filepath.Rel(root, name)
+	return err == nil && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) && !filepath.IsAbs(rel)
+}
+
+func snapshot(root, protocol string) (map[string][]byte, error) {
+	files := make(map[string][]byte)
+	budget := sourceBudget(protocol)
+	total := int64(0)
+	err := filepath.WalkDir(root, func(name string, entry os.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			if name != root && strings.HasPrefix(entry.Name(), ".") {
+				return contextError("hidden/nested source directory outside prototype")
+			}
+			return nil
+		}
+		if err := budget.checkCount(len(files) + 1); err != nil {
+			return err
+		}
+		data, err := readRegular(name, 16<<20)
+		if err != nil {
+			return err
+		}
+		if err := budget.checkBytes(total, len(data)); err != nil {
+			return err
+		}
+		total += int64(len(data))
+		rel, _ := filepath.Rel(root, name)
+		files[filepath.ToSlash(rel)] = data
+		return nil
+	})
+	return files, err
+}
+
+func Capture(ctx context.Context, request Request) (*Observation, error) {
+	return capture(ctx, request, false)
+}
+
+func capture(ctx context.Context, request Request, sdkCPU bool) (*Observation, error) {
+	protocol := Protocol
+	if sdkCPU {
+		protocol = SDKCPUProtocol
+	}
+	return captureRole(ctx, request, protocol)
+}
+
+func captureRole(ctx context.Context, request Request, protocol string) (*Observation, error) {
+	sdkCPU, sdkGlobals := protocol == SDKCPUProtocol, protocol == SDKGlobalsProtocol
+	sdk := sdkCPU || sdkGlobals
+	if ctx == nil || ctx.Err() != nil || !filepath.IsAbs(request.GoBinary) || !filepath.IsAbs(request.Directory) ||
+		request.PackagePath == "" || len(request.Variables) == 0 || len(request.Variables) > 32 {
+		return nil, contextError("missing actual source context or bounded variable request")
+	}
+	goos, arch, valid := strings.Cut(request.Target, "/")
+	if !valid || (arch != "386" && arch != "amd64" && arch != "arm" && arch != "arm64" && arch != "wasm") ||
+		goos != "linux" && goos != "darwin" && goos != "windows" && !(goos == "js" && arch == "wasm") {
+		return nil, contextError("unknown target")
+	}
+	root, err := sourcepath.Resolve(request.Directory)
+	if err != nil {
+		return nil, fmt.Errorf("%w: resolve original source root: %w", ErrContext, err)
+	}
+	if root != request.Directory {
+		return nil, contextError("source root must be canonical")
+	}
+	if sdkCPU && (request.PackagePath != "internal/cpu" || !sdkCPUTarget(request.Target) ||
+		root != filepath.Join(filepath.Dir(filepath.Dir(request.GoBinary)), "src", "internal", "cpu")) {
+		return nil, contextError("SDK producer requires exact original CPU owner")
+	}
+	if sdkGlobals && (!sdkCPUTarget(request.Target) || !sdkGlobalDirectory(request.GoBinary, root, request.PackagePath)) {
+		return nil, contextError("SDK global producer requires this invoked installation's exact original package")
+	}
+	provided := make(map[string]string)
+	for _, pair := range request.Environment {
+		key, value, ok := strings.Cut(pair, "=")
+		if !ok || key == "" {
+			return nil, contextError("invalid environment")
+		}
+		if _, duplicate := provided[key]; duplicate {
+			return nil, contextError("duplicate environment key")
+		}
+		provided[key] = value
+	}
+	if provided["GOFLAGS"] != "" || provided["GOEXPERIMENT"] != "" || provided["GOPACKAGESDRIVER"] != "" && provided["GOPACKAGESDRIVER"] != "off" {
+		return nil, contextError("unbound flags, experiments or package driver")
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(provided[key]) {
+			return nil, contextError("explicit command cache/temp directory required")
+		}
+	}
+	for key, value := range map[string]string{"GOOS": goos, "GOARCH": arch, "GOAMD64": "v1", "GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "CGO_ENABLED": "0", "GOPROXY": "off"} {
+		if key == "CGO_ENABLED" && sdk && (provided[key] == "0" || provided[key] == "1") {
+			continue // Preserve the explicitly observed SDK profile; sources stay pure Go.
+		}
+		provided[key] = value
+	}
+	if sdk {
+		for key, value := range sdkCPUProfile(request.Target) {
+			provided[key] = value
+		}
+	}
+	request.Environment = nil
+	for key, value := range provided {
+		request.Environment = append(request.Environment, key+"="+value)
+	}
+	sort.Strings(request.Environment)
+	request.Variables = append([]Reference(nil), request.Variables...)
+	sort.Slice(request.Variables, func(i, j int) bool { return referenceKey(request.Variables[i]) < referenceKey(request.Variables[j]) })
+	for i, ref := range request.Variables {
+		if !token.IsIdentifier(ref.Name) || ref.Name == "_" || ref.PackagePath == "" || i > 0 && ref == request.Variables[i-1] {
+			return nil, contextError("invalid or duplicate variable reference")
+		}
+	}
+	source, err := snapshot(root, protocol)
+	if err != nil {
+		return nil, fmt.Errorf("%w: snapshot complete original sources: %w", ErrContext, err)
+	}
+	if !sdk && source["go.mod"] == nil {
+		return nil, contextError("complete original module sources lack go.mod")
+	}
+	if sdkCPU {
+		if err := sdkCPUSource(source); err != nil {
+			return nil, fmt.Errorf("%w: complete original SDK CPU sources: %w", ErrContext, err)
+		}
+	}
+	o := &Observation{request: request, inputs: make(map[string]string), report: Report{
+		Protocol: Protocol, Target: request.Target, PackagePath: request.PackagePath,
+		Source: source, SourceSHA256: make(map[string]string), Archives: make(map[string][]byte),
+		ArchiveSHA256: make(map[string]string), Tools: make(map[string]string),
+	}}
+	o.report.Protocol = protocol
+	o.dirs = make(map[string]os.FileInfo)
+	directories := []string{request.Directory, provided["GOCACHE"], provided["GOMODCACHE"], provided["GOPATH"], provided["TMPDIR"], provided["GOTMPDIR"]}
+	if sdk {
+		directories = append(directories, filepath.Dir(filepath.Dir(request.GoBinary)))
+	}
+	for _, name := range directories {
+		resolved, err := sourcepath.Resolve(name)
+		info, statErr := sourcepath.Lstat(name)
+		if err != nil || resolved != name || statErr != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
+			return nil, contextError("actual command input/cache/temp root is redirected or missing")
+		}
+		o.dirs[name] = info
+	}
+	for name, data := range source {
+		o.report.SourceSHA256[name] = digest(data)
+	}
+	driver, err := readRegular(request.GoBinary, 64<<20)
+	if err != nil {
+		return nil, err
+	}
+	o.inputs[request.GoBinary] = digest(driver)
+	o.report.CommandDirectory = request.Directory
+	o.report.CommandArguments = o.selectionArguments()
+	o.report.CommandBinary = request.GoBinary
+	o.report.CommandEnvironment = make(map[string]string)
+	for _, key := range []string{"GOROOT", "GOCACHE", "GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR", "GOOS", "GOARCH", "GOAMD64", "GOTOOLCHAIN", "GOENV", "GOWORK", "CGO_ENABLED", "GOPROXY", "GOFLAGS", "GOEXPERIMENT"} {
+		o.report.CommandEnvironment[key] = provided[key]
+	}
+	if sdk {
+		for key, value := range sdkCPUProfile(request.Target) {
+			o.report.CommandEnvironment[key] = value
+		}
+	}
+	if err := o.observe(ctx); err != nil {
+		return nil, err
+	}
+	if sdkGlobals {
+		if err := o.captureSDKGlobalDependencies(ctx); err != nil {
+			return nil, err
+		}
+	}
+	raw, err := o.run(ctx, o.selectionArguments()...)
+	if err != nil {
+		return nil, err
+	}
+	o.report.RawSelection = raw
+	packages, err := reportPackages(o.report, root)
+	if err != nil {
+		return nil, err
+	}
+	total := 0
+	for path, pkg := range packages {
+		data, err := readRegular(pkg.Export, archiveLimit)
+		if err != nil || !within(o.report.Environment["GOCACHE"], pkg.Export) {
+			return nil, contextError("archive differs from actual cache/source role")
+		}
+		total += len(data)
+		if total > 64<<20 {
+			return nil, contextError("actual export byte bound exceeded")
+		}
+		o.report.Archives[path], o.report.ArchiveSHA256[path] = data, digest(data)
+		o.inputs[pkg.Export] = digest(data)
+	}
+	o.report.Variables, err = bindVariables(o.report, packages, request.Variables)
+	if err != nil {
+		return nil, err
+	}
+	o.report.TextProtocol = TextProtocol
+	o.report.TextArchives, err = textArchives(o.report, packages)
+	if err != nil {
+		return nil, err
+	}
+	encoded, _ := json.Marshal(o.report)
+	o.seal, o.ready = sha256.Sum256(encoded), true
+	if err := o.Verify(ctx); err != nil {
+		return nil, err
+	}
+	return o, nil
+}
+
+func (o *Observation) run(ctx context.Context, args ...string) ([]byte, error) {
+	stage, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	return goasmcmd.Run(stage, o.request.Directory, o.request.Environment, o.request.GoBinary, args...)
+}
+
+func (o *Observation) observe(ctx context.Context) error {
+	arguments := []string{"env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOCACHE", "GOMODCACHE", "GOOS", "GOARCH", "GOAMD64", "GOFLAGS", "GOEXPERIMENT", "CGO_ENABLED", "GOWORK"}
+	if sdkStorageProtocol(o.report.Protocol) {
+		arguments = append(arguments, "GO386", "GOARM", "GOARM64", "GOWASM")
+	}
+	raw, err := o.run(ctx, arguments...)
+	if err != nil {
+		return err
+	}
+	var env map[string]string
+	if err := json.Unmarshal(raw, &env); err != nil || !gotoolchain.AuditedGo127(env["GOVERSION"]) ||
+		env["GOOS"]+"/"+env["GOARCH"] != o.request.Target || env["GOFLAGS"] != "" || env["GOEXPERIMENT"] != "" ||
+		env["CGO_ENABLED"] != o.report.CommandEnvironment["CGO_ENABLED"] ||
+		!sdkStorageProtocol(o.report.Protocol) && env["CGO_ENABLED"] != "0" ||
+		env["GOWORK"] != "off" || filepath.Join(env["GOROOT"], "bin", gotoolchain.HostExecutable("go")) != o.request.GoBinary {
+		return contextError("actual Go driver/profile/target differs")
+	}
+	if env["GOMODCACHE"] != o.report.CommandEnvironment["GOMODCACHE"] {
+		return contextError("actual Go module cache differs from the explicit command role")
+	}
+	if !sdkStorageProtocol(o.report.Protocol) {
+		if err := ValidateOwnedSourceDirectory(o.request.Directory, env["GOROOT"], env["GOMODCACHE"]); err != nil {
+			return err
+		}
+	}
+	if sdkStorageProtocol(o.report.Protocol) {
+		for key, expected := range sdkCPUProfile(o.request.Target) {
+			if env[key] != expected {
+				return contextError("actual SDK target tuning differs")
+			}
+		}
+	}
+	o.report.Environment, o.report.RawEnvironment = env, raw
+	paths := map[string]string{"go": o.request.GoBinary, "VERSION": filepath.Join(env["GOROOT"], "VERSION")}
+	route, err := o.run(ctx, "tool", "-n", "compile")
+	if err != nil || strings.TrimSpace(string(route)) != filepath.Join(env["GOTOOLDIR"], gotoolchain.HostExecutable("compile")) {
+		return contextError("unknown actual compile route")
+	}
+	paths["compile"] = strings.TrimSpace(string(route))
+	if sdkStorageProtocol(o.report.Protocol) {
+		route, err := o.run(ctx, "tool", "-n", "asm")
+		if err != nil || strings.TrimSpace(string(route)) != filepath.Join(env["GOTOOLDIR"], gotoolchain.HostExecutable("asm")) {
+			return contextError("unknown actual SDK assembly route")
+		}
+		paths["asm"] = strings.TrimSpace(string(route))
+		for role := range sdkCPUFormatSources {
+			paths[role] = filepath.Join(env["GOROOT"], filepath.FromSlash(role))
+		}
+	}
+	for name := range formatSources {
+		paths[name] = filepath.Join(env["GOROOT"], filepath.FromSlash(name))
+	}
+	for role, name := range paths {
+		data, err := readRegular(name, 64<<20)
+		if err != nil || formatSources[role] != "" && digest(data) != formatSources[role] ||
+			sdkCPUFormatSources[role] != "" && digest(data) != sdkCPUFormatSources[role] ||
+			role == "VERSION" && strings.Split(string(data), "\n")[0] != env["GOVERSION"] {
+			return contextError("actual SDK/tool/object-format source differs")
+		}
+		if previous := o.inputs[name]; previous != "" && previous != digest(data) {
+			return contextError("actual driver changed during observation")
+		}
+		o.report.Tools[role], o.inputs[name] = digest(data), digest(data)
+		if role == builtinSourceRole {
+			o.report.TextBuiltinSource = append([]byte(nil), data...)
+		}
+	}
+	return nil
+}
+
+func (o *Observation) Verify(ctx context.Context) error {
+	if o == nil {
+		return contextError("nil observation")
+	}
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	if !o.ready || ctx == nil || ctx.Err() != nil {
+		return contextError("observation is revoked or lacks live context")
+	}
+	fail := func(err error) error { o.ready = false; return err }
+	if err := o.verifyDirectories(); err != nil {
+		return fail(err)
+	}
+	encoded, _ := json.Marshal(o.report)
+	if sha256.Sum256(encoded) != o.seal {
+		return fail(contextError("sealed producer report changed"))
+	}
+	source, err := o.snapshotSource()
+	if err != nil {
+		return fail(fmt.Errorf("%w: snapshot complete original source inventory: %w", ErrContext, err))
+	}
+	if !reflect.DeepEqual(source, o.report.Source) {
+		return fail(contextError("complete original source inventory changed"))
+	}
+	for name, expected := range o.inputs {
+		actual, err := gooriginalsrc.HashRegularFile(name, 64<<20)
+		if err != nil || hex.EncodeToString(actual[:]) != expected {
+			return fail(contextError("actual source/tool/export bytes changed"))
+		}
+	}
+	raw, err := o.run(ctx, o.verificationArguments()...)
+	if err != nil || !sameSelection(raw, o.report.RawSelection) {
+		return fail(contextError("actual selected package/import/export changed"))
+	}
+	// The final command is not an exemption from the source/export guards.
+	final, err := o.snapshotSource()
+	if err != nil {
+		return fail(fmt.Errorf("%w: snapshot original sources after actual final selection: %w", ErrContext, err))
+	}
+	if !reflect.DeepEqual(final, o.report.Source) {
+		return fail(contextError("source changed during actual final selection"))
+	}
+	for name, expected := range o.inputs {
+		actual, err := gooriginalsrc.HashRegularFile(name, 64<<20)
+		if err != nil || hex.EncodeToString(actual[:]) != expected {
+			return fail(contextError("tool/export changed during actual final selection"))
+		}
+	}
+	if err := o.verifyDirectories(); err != nil {
+		return fail(err)
+	}
+	return nil
+}
+
+func (o *Observation) verifyDirectories() error {
+	for name, original := range o.dirs {
+		resolved, resolveErr := sourcepath.Resolve(name)
+		info, err := sourcepath.Lstat(name)
+		if err != nil || resolveErr != nil || resolved != name || !info.IsDir() || !os.SameFile(info, original) {
+			return contextError("actual command/source/cache/temp root identity changed")
+		}
+	}
+	return nil
+}
+
+func selectionArguments() []string {
+	// -a recompiles this bounded same-module graph: an already cached export
+	// alone is not an observation of the actual selected compiler's data record.
+	return []string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "-mod=readonly", "."}
+}
+
+func (o *Observation) selectionArguments() []string {
+	if o.report.Protocol == SDKCPUProtocol {
+		return sdkCPUArguments()
+	}
+	if o.report.Protocol == SDKGlobalsProtocol {
+		return sdkGlobalsArguments(o.report.PackagePath)
+	}
+	return selectionArguments()
+}
+
+// Capture retains its forced compiler prior. Live verification still queries
+// the same complete selection/export graph and guards every current byte on
+// both sides of that command; it need not force recompilation of that graph.
+func (o *Observation) verificationArguments() []string {
+	arguments := o.selectionArguments()
+	result := make([]string, 0, len(arguments))
+	for _, argument := range arguments {
+		if argument != "-a" {
+			result = append(result, argument)
+		}
+	}
+	return result
+}
+
+func referenceKey(ref Reference) string { return ref.PackagePath + "\x00" + ref.Name }
+
+// CheckReport checks an independently decoded snapshot against the live sealed
+// producer and reconstructs the retained bytes. JSON alone cannot satisfy it.
+func (o *Observation) CheckReport(ctx context.Context, report Report) error {
+	if o == nil {
+		return contextError("nil observation")
+	}
+	o.mu.Lock()
+	data, _ := json.Marshal(report)
+	matched := o.ready && sha256.Sum256(data) == o.seal
+	o.mu.Unlock()
+	if !matched {
+		return contextError("readback report differs from sealed original command outputs")
+	}
+	if err := o.Verify(ctx); err != nil {
+		return err
+	}
+	return ValidateReport(report)
+}
+
+func (o *Observation) Readback(ctx context.Context) (Report, error) {
+	if err := o.Verify(ctx); err != nil {
+		return Report{}, err
+	}
+	o.mu.Lock()
+	defer o.mu.Unlock()
+	data, _ := json.Marshal(o.report)
+	var result Report
+	if err := json.Unmarshal(data, &result); err != nil {
+		return Report{}, err
+	}
+	if err := ValidateReport(result); err != nil {
+		return Report{}, err
+	}
+	return result, nil
+}
+
+func (o *Observation) Close() {
+	if o != nil {
+		o.mu.Lock()
+		o.ready = false
+		o.mu.Unlock()
+	}
+}
diff --git a/internal/gostaticstorage/capture_go127_test.go b/internal/gostaticstorage/capture_go127_test.go
new file mode 100644
index 000000000..c68222551
--- /dev/null
+++ b/internal/gostaticstorage/capture_go127_test.go
@@ -0,0 +1,222 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+func request(t *testing.T, dir, binary, target string) Request {
+	t.Helper()
+	return Request{GoBinary: binary, Directory: dir, PackagePath: fixtureModule, Target: target,
+		Environment: fixtureEnv(t, target), Variables: []Reference{
+			{fixtureModule, "Keys"}, {fixtureModule, "Data"}, {fixtureModule, "Mixed"}, {fixtureModule, "Relocated"},
+			{fixtureModule + "/dep", "Flags"}, {fixtureModule + "/dep", "Keys"},
+		}}
+}
+
+func captured(t *testing.T, req Request) (*Observation, Report) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	o, err := Capture(ctx, req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(o.Close)
+	report, err := o.Readback(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return o, report
+}
+
+func TestGoStaticStorageTypedProducerAndReader(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			o, report := captured(t, request(t, dir, binary, target))
+			word := int64(8)
+			if strings.HasSuffix(target, "/386") || strings.HasSuffix(target, "/arm") {
+				word = 4
+			}
+			expected := map[string][]Span{
+				fixtureModule + ".Keys":      {{0, 48}},
+				fixtureModule + ".Data":      {{0, 4}},
+				fixtureModule + ".Mixed":     {{0, 1}, {4, 4}, {8 + word, 3}},
+				fixtureModule + ".Relocated": {{0, 4}},
+				fixtureModule + "/dep.Flags": {{64, 4}},
+				fixtureModule + "/dep.Keys":  {{0, 16}},
+			}
+			for _, variable := range report.Variables {
+				if !reflect.DeepEqual(variable.Numerical, expected[variable.NativeName]) || variable.Alignment != 0 {
+					t.Fatalf("numerical/blank/pointer/padding or real alignment observation differs: %+v", variable)
+				}
+			}
+			data, err := json.MarshalIndent(report, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var decoded Report
+			if err := json.Unmarshal(data, &decoded); err != nil || o.CheckReport(context.Background(), decoded) != nil {
+				t.Fatalf("independent readback failed: %v", err)
+			}
+			if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+				folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"))
+				if err := os.MkdirAll(folder, 0700); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(filepath.Join(folder, "producer-report.json"), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+		})
+	}
+}
+
+func cloneReport(t *testing.T, report Report) Report {
+	t.Helper()
+	data, err := json.Marshal(report)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result Report
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	return result
+}
+
+func TestGoStaticStorageReaderMutationGuards(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	o, report := captured(t, request(t, dir, binary, "linux/amd64"))
+	for name, mutate := range map[string]func(*Report){
+		"target":      func(r *Report) { r.Target = "linux/386" },
+		"owner":       func(r *Report) { r.Variables[0].PackagePath += "/other" },
+		"native name": func(r *Report) { r.Variables[0].NativeName += "other" },
+		"size":        func(r *Report) { r.Variables[0].Size++ },
+		"alignment":   func(r *Report) { r.Variables[0].Alignment = 16 },
+		"blank bytes": func(r *Report) {
+			for i := range r.Variables {
+				if r.Variables[i].Name == "Mixed" {
+					r.Variables[i].Numerical = []Span{{0, r.Variables[i].Size}}
+				}
+			}
+		},
+		"source bytes":       func(r *Report) { r.Source["storage.go"][0] ^= 1 },
+		"source hash":        func(r *Report) { r.SourceSHA256["storage.go"] = strings.Repeat("0", 64) },
+		"archive bytes":      func(r *Report) { r.Archives[fixtureModule][0] ^= 1 },
+		"archive hash":       func(r *Report) { r.ArchiveSHA256[fixtureModule] = strings.Repeat("0", 64) },
+		"format rules":       func(r *Report) { r.Tools["src/cmd/internal/goobj/objfile.go"] = strings.Repeat("0", 64) },
+		"tool":               func(r *Report) { r.Tools["compile"] = strings.Repeat("0", 64) },
+		"command dir":        func(r *Report) { r.CommandDirectory += "/other" },
+		"command argv":       func(r *Report) { r.CommandArguments = append(r.CommandArguments, "./...") },
+		"effective tmpdir":   func(r *Report) { r.CommandEnvironment["TMPDIR"] += "other" },
+		"trailing JSON":      func(r *Report) { r.RawSelection = append(r.RawSelection, []byte("garbage")...) },
+		"omitted archive":    func(r *Report) { delete(r.Archives, fixtureModule+"/dep") },
+		"duplicate variable": func(r *Report) { r.Variables = append(r.Variables, r.Variables[0]) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneReport(t, report)
+			mutate(&changed)
+			if err := o.CheckReport(context.Background(), changed); !errors.Is(err, ErrContext) {
+				t.Fatalf("changed recorded input acquired authority: %v", err)
+			}
+		})
+	}
+	var decoded Observation
+	data, _ := json.Marshal(o)
+	if err := json.Unmarshal(data, &decoded); err != nil || !errors.Is(decoded.Verify(context.Background()), ErrContext) {
+		t.Fatal("JSON recreated sealed producer")
+	}
+	if !errors.Is((*Observation)(nil).Verify(context.Background()), ErrContext) || !errors.Is((*Observation)(nil).CheckReport(context.Background(), report), ErrContext) {
+		t.Fatal("nil observer must return Context")
+	}
+	o.Close()
+	if !errors.Is(o.Verify(context.Background()), ErrContext) {
+		t.Fatal("Close did not revoke")
+	}
+}
+
+func TestGoStaticStoragePhysicalSourceAndInputGuards(t *testing.T) {
+	for _, kind := range []string{"source", "inventory", "temp identity", "requested name", "duplicate", "wrong owner", "wrong package", "flags", "unknown SDK"} {
+		t.Run(kind, func(t *testing.T) {
+			dir, binary, _ := fixture(t)
+			req := request(t, dir, binary, "linux/amd64")
+			ownedTemp := ""
+			if kind == "temp identity" {
+				ownedTemp = t.TempDir()
+				ownedTemp, _ = filepath.EvalSymlinks(ownedTemp)
+				for i, pair := range req.Environment {
+					if strings.HasPrefix(pair, "TMPDIR=") || strings.HasPrefix(pair, "GOTMPDIR=") {
+						key, _, _ := strings.Cut(pair, "=")
+						req.Environment[i] = key + "=" + ownedTemp
+					}
+				}
+			}
+			if kind == "requested name" {
+				req.Variables[0].Name = "Read" // function, not variable
+			} else if kind == "duplicate" {
+				req.Variables = append(req.Variables, req.Variables[0])
+			} else if kind == "wrong owner" {
+				req.Variables[0].PackagePath += "/other"
+			} else if kind == "wrong package" {
+				req.PackagePath += "/other"
+			} else if kind == "flags" {
+				for i, pair := range req.Environment {
+					if strings.HasPrefix(pair, "GOFLAGS=") {
+						req.Environment[i] = "GOFLAGS=-race"
+					}
+				}
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			o, err := Capture(ctx, req)
+			if kind == "requested name" || kind == "duplicate" || kind == "wrong owner" || kind == "wrong package" || kind == "flags" {
+				if err == nil {
+					o.Close()
+					t.Fatal("invalid identity/role acquired producer")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer o.Close()
+			switch kind {
+			case "source":
+				file := filepath.Join(dir, "storage.go")
+				data, _ := os.ReadFile(file)
+				if err := os.WriteFile(file, append(data, '\n'), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "inventory":
+				if err := os.WriteFile(filepath.Join(dir, "new.go"), []byte("package staticstorage\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			case "temp identity":
+				// Retarget only an independently fixture-owned directory, never
+				// the runner/shared cache. The request's actual role must stay put.
+				if err := os.Rename(ownedTemp, ownedTemp+"-old"); err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Mkdir(ownedTemp, 0700); err != nil {
+					t.Fatal(err)
+				}
+			case "unknown SDK":
+				o.report.Tools["src/cmd/internal/goobj/objfile.go"] = strings.Repeat("0", 64)
+			}
+			if err := o.Verify(ctx); !errors.Is(err, ErrContext) {
+				t.Fatalf("physical original input changed but certificate survived: %v", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/decoder_object.go b/internal/gostaticstorage/decoder_object.go
new file mode 100644
index 000000000..b971580f6
--- /dev/null
+++ b/internal/gostaticstorage/decoder_object.go
@@ -0,0 +1,54 @@
+package gostaticstorage
+
+import "strings"
+
+// DecoderObjectFormatSourceHashes returns observation-format pins, not source
+// authority. The producer must independently read and retain these SDK files.
+func DecoderObjectFormatSourceHashes() map[string]string {
+	result := make(map[string]string, len(formatSources))
+	for name, hash := range formatSources {
+		result[name] = hash
+	}
+	return result
+}
+
+// ObserveDecoderARM64Object checks the complete ordinary tool-asm object used
+// by the decoder oracle. It is a byte-kind observation, not a source, native
+// TEXT entry, relocation/linkability or execution permission. The command has
+// no -p flag, so the original Go writer requires FromAssembly|Unlinkable (12).
+func ObserveDecoderARM64Object(data []byte, symbol string) error {
+	if len(data) == 0 || len(data) > archiveLimit ||
+		!strings.HasPrefix(symbol, "<unlinkable>.probe") || strings.ContainsAny(symbol, "\x00\r\n") {
+		return contextError("invalid decoder object extent or expected symbol")
+	}
+	body, err := objectBody(data, "linux/arm64")
+	if err != nil {
+		return err
+	}
+	object, err := checkedObject(body, 12, false)
+	if err != nil {
+		return err
+	}
+	symbols, err := object.indexedSymbols()
+	if err != nil {
+		return err
+	}
+	texts := 0
+	for _, observed := range symbols {
+		if observed.Namespace == TextSymbolNonpkgReference || observed.Kind != 1 {
+			continue
+		}
+		texts++
+		if observed.Name != symbol || observed.Size == 0 || int(observed.Index) >= object.count {
+			return contextError("decoder object does not define this exact nonempty probe TEXT")
+		}
+		start, end := object.indices[2][observed.Index], object.indices[2][observed.Index+1]
+		if end-start != observed.Size {
+			return contextError("decoder TEXT extent differs from its complete object data")
+		}
+	}
+	if texts != 1 {
+		return contextError("decoder object must contain exactly one current probe TEXT")
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/guards_go127_test.go b/internal/gostaticstorage/guards_go127_test.go
new file mode 100644
index 000000000..89a25fc3f
--- /dev/null
+++ b/internal/gostaticstorage/guards_go127_test.go
@@ -0,0 +1,219 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func objectBytes(t *testing.T, archive []byte) []byte {
+	t.Helper()
+	for pos := 8; pos+60 <= len(archive); {
+		header := archive[pos : pos+60]
+		size, err := strconv.Atoi(strings.TrimSpace(string(header[48:58])))
+		if err != nil || size <= 0 || size > len(archive)-pos-60 {
+			t.Fatal("test input lacks actual archive member")
+		}
+		pos += 60
+		if strings.TrimSpace(string(header[:16])) == "_go_.o" {
+			object := archive[pos : pos+size]
+			end := bytes.Index(object, []byte("\n!\n"))
+			if end < 0 {
+				t.Fatal("test input lacks actual object text header")
+			}
+			return object[end+3:]
+		}
+		pos += size + size%2
+	}
+	t.Fatal("test input lacks actual compiler object")
+	return nil
+}
+
+func blockOffset(object []byte, block int) int {
+	return int(binary.LittleEndian.Uint32(object[20+4*block:]))
+}
+
+func symbolIndex(t *testing.T, object []byte, name string) int {
+	t.Helper()
+	first, end := blockOffset(object, 3), blockOffset(object, 7)
+	for pos := first; pos < end; pos += 21 {
+		length := int(binary.LittleEndian.Uint32(object[pos:]))
+		off := int(binary.LittleEndian.Uint32(object[pos+4:]))
+		if string(object[off:off+length]) == name {
+			return (pos - first) / 21
+		}
+	}
+	t.Fatal("actual native symbol missing", name)
+	return 0
+}
+
+func TestGoStaticStorageBinaryBoundaryGuards(t *testing.T) {
+	dir, binaryPath, _ := fixture(t)
+	selected := run(t, binaryPath, dir, fixtureEnv(t, "linux/amd64"), selectionArguments()...)
+	var root Package
+	decoder := json.NewDecoder(bytes.NewReader(selected))
+	for root.ImportPath != fixtureModule {
+		if err := decoder.Decode(&root); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original, err := os.ReadFile(root.Export)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := readArchive(original, "linux/amd64"); err != nil {
+		t.Fatal("actual positive control", err)
+	}
+	for name, mutate := range map[string]func([]byte){
+		"archive magic":   func(a []byte) { a[0] ^= 1 },
+		"member overflow": func(a []byte) { copy(a[8+48:8+58], "9999999999") },
+		"unknown member":  func(a []byte) { copy(a[8:8+16], "unknown_member  ") },
+		"goobj magic":     func(a []byte) { objectBytes(t, a)[0] ^= 1 },
+		"object flags":    func(a []byte) { binary.LittleEndian.PutUint32(objectBytes(t, a)[16:], 1) },
+		"backwards block": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[20+4*4:], uint32(blockOffset(o, 3)-1))
+		},
+		"overflow block": func(a []byte) { binary.LittleEndian.PutUint32(objectBytes(t, a)[20+4*14:], ^uint32(0)) },
+		"unconsumed EOF": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[20+4*18:], uint32(len(o)-1))
+		},
+		"partial fixed record": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[20+4*4:], uint32(blockOffset(o, 4)+1))
+		},
+		"nonzero index start": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[blockOffset(o, 13):], 1)
+		},
+		"overflow index": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[blockOffset(o, 13)+4:], ^uint32(0))
+		},
+		"string outside block": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[blockOffset(o, 3)+4:], uint32(len(o)))
+		},
+		"overflow string length": func(a []byte) {
+			o := objectBytes(t, a)
+			binary.LittleEndian.PutUint32(o[blockOffset(o, 3):], ^uint32(0))
+		},
+		"duplicate definition": func(a []byte) {
+			o := objectBytes(t, a)
+			keys := blockOffset(o, 3) + 21*symbolIndex(t, o, fixtureModule+".Keys")
+			data := blockOffset(o, 3) + 21*symbolIndex(t, o, fixtureModule+".Data")
+			copy(o[data:data+8], o[keys:keys+8])
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := append([]byte(nil), original...)
+			mutate(changed)
+			if _, err := readArchive(changed, "linux/amd64"); !errors.Is(err, ErrContext) {
+				t.Fatalf("malformed binary accepted: %v", err)
+			}
+		})
+	}
+	for _, target := range []string{"linux/386", "linux/arm64", "unknown/amd64"} {
+		t.Run("wrong-target-"+target, func(t *testing.T) {
+			if _, err := readArchive(original, target); !errors.Is(err, ErrContext) {
+				t.Fatal("object target changed but accepted")
+			}
+		})
+	}
+}
+
+func TestGoStaticStorageRetainedRelocationAndLayoutGuards(t *testing.T) {
+	dir, binaryPath, _ := fixture(t)
+	req := request(t, dir, binaryPath, "linux/amd64")
+	req.Variables = append(req.Variables, Reference{fixtureModule, "TwiceRelocated"})
+	o, report := captured(t, req)
+	for name, mutate := range map[string]func([]byte, int){
+		"unsupported relocation":   func(object []byte, pos int) { binary.LittleEndian.PutUint16(object[pos+5:], 0xffff) },
+		"invalid relocation width": func(object []byte, pos int) { object[pos+4] = 3 },
+		"negative relocation":      func(object []byte, pos int) { binary.LittleEndian.PutUint32(object[pos:], ^uint32(0)) },
+		"outside relocation":       func(object []byte, pos int) { binary.LittleEndian.PutUint32(object[pos:], 1<<20) },
+		"overlap relocation":       func(object []byte, pos int) { copy(object[pos+23:pos+27], object[pos:pos+4]) },
+		"extent mismatch": func(object []byte, _ int) {
+			pos := blockOffset(object, 3) + 21*symbolIndex(t, object, fixtureModule+".Keys")
+			binary.LittleEndian.PutUint32(object[pos+13:], 47)
+		},
+		"BSS changed into empty DATA": func(object []byte, _ int) {
+			pos := blockOffset(object, 3) + 21*symbolIndex(t, object, fixtureModule+".Keys")
+			object[pos+10] = 5
+		},
+		"nonordinary native flags": func(object []byte, _ int) {
+			pos := blockOffset(object, 3) + 21*symbolIndex(t, object, fixtureModule+".Keys")
+			object[pos+11] = 1
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneReport(t, report)
+			object := objectBytes(t, changed.Archives[fixtureModule])
+			idx := symbolIndex(t, object, fixtureModule+".TwiceRelocated")
+			rel := binary.LittleEndian.Uint32(object[blockOffset(object, 11)+idx*4:])
+			pos := blockOffset(object, 14) + int(rel)*23
+			mutate(object, pos)
+			// Recompute the outer hash so reconstruction, not a stale digest,
+			// rejects invalid compiler records. The sealed producer also rejects.
+			changed.ArchiveSHA256[fixtureModule] = digest(changed.Archives[fixtureModule])
+			if !errors.Is(ValidateReport(changed), ErrContext) || !errors.Is(o.CheckReport(context.Background(), changed), ErrContext) {
+				t.Fatal("invalid data/layout record acquired numerical storage")
+			}
+		})
+	}
+}
+
+func TestGoStaticStorageNumericalDoesNotGrantPointerStorage(t *testing.T) {
+	dir, binaryPath, _ := fixture(t)
+	for _, name := range []string{"PointerOnly", "StringOnly", "SliceOnly", "MapOnly", "ComplexOnly", "BlankOnly", "ZeroSize"} {
+		t.Run(name, func(t *testing.T) {
+			req := request(t, dir, binaryPath, "linux/amd64")
+			req.Variables = []Reference{{fixtureModule, name}}
+			o, err := Capture(context.Background(), req)
+			if !errors.Is(err, ErrContext) {
+				if o != nil {
+					o.Close()
+				}
+				t.Fatalf("non-numerical/header/blank/empty storage granted: %v", err)
+			}
+		})
+	}
+	// uintptr is initialized numeric bits only; there is deliberately no API
+	// in this package that grants an address/pointer or translation permission.
+	req := request(t, dir, binaryPath, "linux/amd64")
+	req.Variables = []Reference{{fixtureModule, "Address"}}
+	_, report := captured(t, req)
+	if len(report.Variables) != 1 || len(report.Variables[0].Numerical) != 1 || report.Variables[0].Numerical[0] != (Span{0, 8}) {
+		t.Fatal("uintptr lost numerical byte definition")
+	}
+}
+
+func TestGoStaticStorageSelectionDisplayBoundary(t *testing.T) {
+	original := []byte(`{"ImportPath":"owner","Stale":true,"StaleReason":"build ID mismatch","Future":{"A":1}}`)
+	stable := []byte(`{"ImportPath":"owner","Future":{"A":1}}`)
+	if !sameSelection(original, stable) {
+		t.Fatal("typed cache display is not source/import/export identity")
+	}
+	for _, bad := range []string{
+		`{"ImportPath":"other","Future":{"A":1}}`,
+		`{"ImportPath":"owner","Future":{"A":2}}`,
+		`{"ImportPath":"owner","Stale":null,"Future":{"A":1}}`,
+		`{"ImportPath":"owner","Stale":"true","Future":{"A":1}}`,
+		`{"ImportPath":"owner","StaleReason":false,"Future":{"A":1}}`,
+		string(stable) + "garbage",
+		string(stable) + string(stable),
+	} {
+		if sameSelection(original, []byte(bad)) {
+			t.Fatal("unknown field/input/trailing record was washed away", bad)
+		}
+	}
+}
diff --git a/internal/gostaticstorage/indexed_metadata.go b/internal/gostaticstorage/indexed_metadata.go
new file mode 100644
index 000000000..66b52f106
--- /dev/null
+++ b/internal/gostaticstorage/indexed_metadata.go
@@ -0,0 +1,154 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+// This type intentionally cannot be used by the TEXT/DATA readers. It validates
+// complete bounded object structure but only exposes compiler SymbolDefs
+// metadata. Hashed bodies, Aux, initializers and native code grant no role.
+type sdkIndexedMetadataObject struct {
+	block    func(int) []byte
+	stringAt func([]byte) (string, error)
+}
+
+func checkedSDKIndexedMetadata(data []byte, flags uint32, emptyAssembly bool) (*sdkIndexedMetadataObject, error) {
+	const headerSize = 8 + 8 + 4 + 19*4
+	if len(data) < headerSize || len(data) > archiveLimit || string(data[:8]) != "\x00go120ld" ||
+		binary.LittleEndian.Uint32(data[16:20]) != flags {
+		return nil, contextError("invalid SDK indexed-metadata object header/flags/bound")
+	}
+	var offsets [19]int
+	previous := headerSize
+	for index := range offsets {
+		value := uint64(binary.LittleEndian.Uint32(data[20+4*index:]))
+		if value < uint64(previous) || value > uint64(len(data)) {
+			return nil, contextError("invalid SDK indexed-metadata block interval")
+		}
+		offsets[index], previous = int(value), int(value)
+	}
+	if offsets[18] != len(data) {
+		return nil, contextError("SDK indexed-metadata blocks do not cover exact EOF")
+	}
+	block := func(index int) []byte { return data[offsets[index]:offsets[index+1]] }
+	for _, specification := range []struct{ index, width int }{
+		{0, 16}, {1, 8}, {2, 8}, {3, 21}, {4, 21}, {5, 21}, {6, 21}, {7, 21},
+		{8, 10}, {9, 8}, {10, 16}, {11, 4}, {12, 4}, {13, 4}, {14, 23}, {15, 9}, {17, 16},
+	} {
+		if len(block(specification.index))%specification.width != 0 {
+			return nil, contextError("unaligned SDK indexed-metadata record block")
+		}
+	}
+	if len(block(3))/21 > symbolLimit {
+		return nil, contextError("SDK indexed-metadata SymbolDefs exceed target metadata bound")
+	}
+	definitions := 0
+	for index := 3; index <= 6; index++ {
+		definitions += len(block(index)) / 21
+	}
+	if definitions == 0 && !emptyAssembly ||
+		len(block(9))/8 != len(block(4))/21 || len(block(10))/16 != len(block(5))/21 {
+		return nil, contextError("SDK indexed-metadata definition/hash counts differ")
+	}
+	// Validate all three index inventories without allocating N+1 entries.
+	// The original whole archive bounds every loop and referenced byte interval.
+	for _, specification := range []struct{ index, records, width int }{{11, 14, 23}, {12, 15, 9}, {13, 16, 1}} {
+		indices := block(specification.index)
+		bound := uint32(len(block(specification.records)) / specification.width)
+		if len(indices) != 4*(definitions+1) {
+			return nil, contextError("SDK indexed-metadata lacks complete symbol index inventory")
+		}
+		var prior uint32
+		for offset := 0; offset < len(indices); offset += 4 {
+			value := binary.LittleEndian.Uint32(indices[offset:])
+			if offset == 0 && value != 0 || value < prior || value > bound {
+				return nil, contextError("SDK indexed-metadata symbol index is unordered/out of bounds")
+			}
+			prior = value
+		}
+		if prior != bound {
+			return nil, contextError("SDK indexed-metadata has unconsumed symbol index tail")
+		}
+	}
+	stringBytes := func(reference []byte) ([]byte, error) {
+		length := uint64(binary.LittleEndian.Uint32(reference))
+		offset := uint64(binary.LittleEndian.Uint32(reference[4:]))
+		if length > 4096 || offset < headerSize || offset > uint64(offsets[0]) || length > uint64(offsets[0])-offset {
+			return nil, contextError("SDK indexed-metadata string exceeds original string block")
+		}
+		value := data[int(offset):int(offset+length)]
+		if bytes.IndexAny(value, "\x00\r\n") >= 0 {
+			return nil, contextError("invalid SDK indexed-metadata string")
+		}
+		return value, nil
+	}
+	for _, specification := range []struct{ index, width, start int }{
+		{0, 16, 0}, {1, 8, 0}, {2, 8, 0}, {3, 21, 0}, {4, 21, 0}, {5, 21, 0},
+		{6, 21, 0}, {7, 21, 0}, {17, 16, 8},
+	} {
+		for offset := 0; offset < len(block(specification.index)); offset += specification.width {
+			if _, err := stringBytes(block(specification.index)[offset+specification.start:]); err != nil {
+				return nil, err
+			}
+		}
+	}
+	for index := 3; index <= 7; index++ {
+		for offset := 0; offset < len(block(index)); offset += 21 {
+			kind := block(index)[offset+10]
+			if kind > 25 || index != 7 && kind == 0 {
+				return nil, contextError("unknown/undefined SDK indexed-metadata symbol kind")
+			}
+		}
+	}
+	stringAt := func(reference []byte) (string, error) {
+		value, err := stringBytes(reference)
+		return string(value), err
+	}
+	return &sdkIndexedMetadataObject{block: block, stringAt: stringAt}, nil
+}
+
+func (object *sdkIndexedMetadataObject) selfSymbols() ([]indexedObjectSymbol, error) {
+	block := object.block(3)
+	result := make([]indexedObjectSymbol, 0, len(block)/21)
+	for offset := 0; offset < len(block); offset += 21 {
+		symbol := block[offset : offset+21]
+		name, err := object.stringAt(symbol)
+		if err != nil {
+			return nil, err
+		}
+		index := uint32(offset / 21)
+		result = append(result, indexedObjectSymbol{Namespace: TextSymbolSelf, Relative: index, Index: index,
+			Name: name, ABI: binary.LittleEndian.Uint16(symbol[8:]), Kind: symbol[10], Flags: symbol[11], Flags2: symbol[12],
+			Size: binary.LittleEndian.Uint32(symbol[13:]), Align: binary.LittleEndian.Uint32(symbol[17:])})
+	}
+	return result, nil
+}
+
+// The pinned CPU source's one-argument linkname variables live in NonpkgDefs.
+// Only that independent CPU role may request this additional namespace; generic
+// SDK globals and indexed foreign references retain SymbolDefs alone.
+func (object *sdkIndexedMetadataObject) storageSymbols(cpu bool) ([]indexedObjectSymbol, error) {
+	result, err := object.selfSymbols()
+	if err != nil || !cpu {
+		return result, err
+	}
+	base := uint32(0)
+	for _, block := range []int{3, 4, 5} {
+		base += uint32(len(object.block(block)) / 21)
+	}
+	block := object.block(6)
+	for offset := 0; offset < len(block); offset += 21 {
+		symbol := block[offset : offset+21]
+		name, err := object.stringAt(symbol)
+		if err != nil {
+			return nil, err
+		}
+		relative := uint32(offset / 21)
+		result = append(result, indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition,
+			Relative: relative, Index: base + relative, Name: name,
+			ABI: binary.LittleEndian.Uint16(symbol[8:]), Kind: symbol[10], Flags: symbol[11], Flags2: symbol[12],
+			Size: binary.LittleEndian.Uint32(symbol[13:]), Align: binary.LittleEndian.Uint32(symbol[17:])})
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/indexed_metadata_guards_go127_test.go b/internal/gostaticstorage/indexed_metadata_guards_go127_test.go
new file mode 100644
index 000000000..b2fc342b2
--- /dev/null
+++ b/internal/gostaticstorage/indexed_metadata_guards_go127_test.go
@@ -0,0 +1,151 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"errors"
+	"math"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestGoSDKIndexedMetadataCompleteStructuralGuards(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			original, _ := indexedNamespaceObjectFixture(t, arch)
+			complete, err := checkedObject(original, 16, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+			metadata, err := checkedSDKIndexedMetadata(original, 16, false)
+			if err != nil {
+				t.Fatal("actual complete metadata precondition", err)
+			}
+			symbols, err := metadata.selfSymbols()
+			if err != nil {
+				t.Fatal(err)
+			}
+			all, err := complete.indexedSymbols()
+			if err != nil || !reflect.DeepEqual(symbols, all[:len(complete.block(3))/21]) {
+				t.Fatal("metadata-only reader exposed a different or non-SymbolDefs target", err)
+			}
+			for _, symbol := range symbols {
+				if symbol.Namespace != TextSymbolSelf || len(symbol.Hash) != 0 {
+					t.Fatal("referenced-only metadata granted a hashed/native body identity", symbol)
+				}
+			}
+			blockOffset := func(block int) int { return int(binary.LittleEndian.Uint32(original[20+4*block:])) }
+			check := func(t *testing.T, mutate func([]byte)) {
+				t.Helper()
+				changed := append([]byte(nil), original...)
+				mutate(changed)
+				if _, err := checkedSDKIndexedMetadata(changed, 16, false); !errors.Is(err, ErrContext) {
+					t.Fatal("invalid original metadata structure acquired a target table", err)
+				}
+			}
+			for _, block := range []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17} {
+				t.Run("record alignment "+strconv.Itoa(block), func(t *testing.T) {
+					check(t, func(data []byte) {
+						binary.LittleEndian.PutUint32(data[20+4*(block+1):], uint32(blockOffset(block+1)-1))
+					})
+				})
+			}
+			for _, block := range []int{9, 10} {
+				t.Run("hash count "+strconv.Itoa(block), func(t *testing.T) {
+					check(t, func(data []byte) {
+						width := 8
+						if block == 10 {
+							width = 16
+						}
+						binary.LittleEndian.PutUint32(data[20+4*(block+1):], uint32(blockOffset(block+1)-width))
+					})
+				})
+			}
+			for _, block := range []int{11, 12, 13} {
+				for _, kind := range []string{"first", "last", "overflow", "count", "decreasing"} {
+					t.Run("index "+strconv.Itoa(block)+" "+kind, func(t *testing.T) {
+						check(t, func(data []byte) {
+							start, end := blockOffset(block), blockOffset(block+1)
+							switch kind {
+							case "first":
+								binary.LittleEndian.PutUint32(data[start:], 1)
+							case "last":
+								last := binary.LittleEndian.Uint32(data[end-4:])
+								if last == 0 {
+									t.Fatal("actual index lacks a complete terminal witness")
+								}
+								binary.LittleEndian.PutUint32(data[end-4:], last-1)
+							case "overflow":
+								binary.LittleEndian.PutUint32(data[end-4:], math.MaxUint32)
+							case "count":
+								binary.LittleEndian.PutUint32(data[20+4*(block+1):], uint32(end-4))
+							case "decreasing":
+								binary.LittleEndian.PutUint32(data[start+4:], 1)
+								binary.LittleEndian.PutUint32(data[start+8:], 0)
+							}
+						})
+					})
+				}
+			}
+			for _, block := range []int{3, 4, 5, 6, 7, 17} {
+				t.Run("unused string "+strconv.Itoa(block), func(t *testing.T) {
+					if len(complete.block(block)) == 0 {
+						t.Fatal("actual first-party namespace/string witness is absent", block)
+					}
+					check(t, func(data []byte) {
+						start := blockOffset(block)
+						if block == 17 {
+							start += 8
+						}
+						binary.LittleEndian.PutUint32(data[start+4:], uint32(len(data)+1))
+					})
+				})
+			}
+			for block := 3; block <= 7; block++ {
+				t.Run("unknown kind "+strconv.Itoa(block), func(t *testing.T) {
+					check(t, func(data []byte) { data[blockOffset(block)+10] = 26 })
+				})
+			}
+			for block := 3; block <= 6; block++ {
+				t.Run("undefined definition "+strconv.Itoa(block), func(t *testing.T) {
+					check(t, func(data []byte) { data[blockOffset(block)+10] = 0 })
+				})
+			}
+			t.Run("exact EOF", func(t *testing.T) {
+				check(t, func(data []byte) { binary.LittleEndian.PutUint32(data[20+4*18:], uint32(len(data)-1)) })
+			})
+			t.Run("flags", func(t *testing.T) {
+				check(t, func(data []byte) { binary.LittleEndian.PutUint32(data[16:], 20) })
+			})
+		})
+	}
+}
+
+func TestGoSDKIndexedMetadataSymbolDefsBoundRemainsStrict(t *testing.T) {
+	const headerSize = 8 + 8 + 4 + 19*4
+	count := symbolLimit + 1
+	var blocks [18][]byte
+	blocks[3] = make([]byte, 21*count)
+	for offset := 0; offset < len(blocks[3]); offset += 21 {
+		binary.LittleEndian.PutUint32(blocks[3][offset+4:], headerSize)
+		blocks[3][offset+10] = 3
+	}
+	for _, block := range []int{11, 12, 13} {
+		blocks[block] = make([]byte, 4*(count+1))
+	}
+	data := make([]byte, headerSize)
+	copy(data, "\x00go120ld")
+	binary.LittleEndian.PutUint32(data[16:], 16)
+	for index, block := range blocks {
+		binary.LittleEndian.PutUint32(data[20+4*index:], uint32(len(data)))
+		data = append(data, block...)
+	}
+	binary.LittleEndian.PutUint32(data[20+4*18:], uint32(len(data)))
+	if _, err := checkedSDKIndexedMetadata(data, 16, false); !errors.Is(err, ErrContext) ||
+		!strings.Contains(err.Error(), "SymbolDefs exceed target metadata bound") {
+		t.Fatal("referenced-only streaming widened the actual target metadata bound", err)
+	}
+}
diff --git a/internal/gostaticstorage/object_count_test.go b/internal/gostaticstorage/object_count_test.go
new file mode 100644
index 000000000..38081bf3b
--- /dev/null
+++ b/internal/gostaticstorage/object_count_test.go
@@ -0,0 +1,138 @@
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"errors"
+	"testing"
+)
+
+// Every definition owns three N+1 index entries, including a mandatory final
+// sentinel. The ordinary definition limit stays strict. This structural test
+// also runs with the minimum compiler, independently of SDK capture support.
+func TestGoObjectDefinitionLimitIncludesIndexSentinel(t *testing.T) {
+	for _, count := range []int{symbolLimit - 1, symbolLimit, symbolLimit + 1} {
+		data := goObjectDefinitionCountsFixture([4]int{count}, 0)
+		_, err := checkedObject(data, 0, false)
+		if count <= symbolLimit && err != nil {
+			t.Error("complete legal ordinary N+1 index inventory rejected", count, err)
+		} else if count > symbolLimit && !errors.Is(err, ErrContext) {
+			t.Error("ordinary definition bound widened", count, err)
+		}
+	}
+}
+
+// This builds only the structural definition/index inventories. It is not a
+// source observation or a complete executable TEXT/body fixture.
+func goObjectDefinitionCountsFixture(definitions [4]int, flags uint32) []byte {
+	const headerSize = 8 + 8 + 4 + 19*4
+	var blocks [18][]byte
+	total := 0
+	for namespace, count := range definitions {
+		total += count
+		block := make([]byte, 21*count)
+		for offset := 0; offset < len(block); offset += 21 {
+			binary.LittleEndian.PutUint32(block[offset+4:], headerSize)
+			block[offset+10] = 3
+		}
+		blocks[3+namespace] = block
+	}
+	blocks[9] = make([]byte, 8*definitions[1])
+	blocks[10] = make([]byte, 16*definitions[2])
+	for _, block := range []int{11, 12, 13} {
+		blocks[block] = make([]byte, 4*(total+1))
+	}
+	data := make([]byte, headerSize)
+	copy(data, "\x00go120ld")
+	binary.LittleEndian.PutUint32(data[16:], flags)
+	for index, block := range blocks {
+		binary.LittleEndian.PutUint32(data[20+4*index:], uint32(len(data)))
+		data = append(data, block...)
+	}
+	binary.LittleEndian.PutUint32(data[20+4*18:], uint32(len(data)))
+	return data
+}
+
+func TestGoSDKCompilerDefinitionNamespaceBounds(t *testing.T) {
+	for _, row := range []struct {
+		name        string
+		definitions [4]int
+		flags       uint32
+		ordinary    bool
+		accept      bool
+	}{
+		{"separate-namespaces", [4]int{22152, 515, 45159, 6976}, 16, false, true},
+		{"four-namespace-bound", [4]int{symbolLimit, symbolLimit, symbolLimit, symbolLimit}, 16, false, true},
+		{"ordinary-total-stays-bounded", [4]int{symbolLimit, 1}, 16, true, false},
+		{"nonstandard-has-no-SDK-role", [4]int{symbolLimit, 1}, 0, false, false},
+		{"assembly-has-no-compiler-role", [4]int{symbolLimit, 1}, 20, false, false},
+		{"self-overflow", [4]int{symbolLimit + 1}, 16, false, false},
+		{"hashed64-overflow", [4]int{1, symbolLimit + 1}, 16, false, false},
+		{"hashed-overflow", [4]int{1, 0, symbolLimit + 1}, 16, false, false},
+		{"nonpackage-overflow", [4]int{1, 0, 0, symbolLimit + 1}, 16, false, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			data := goObjectDefinitionCountsFixture(row.definitions, row.flags)
+			var err error
+			if row.ordinary {
+				_, err = checkedObject(data, row.flags, false)
+			} else {
+				_, err = checkedSDKObject(data, row.flags, false)
+			}
+			if row.accept && err != nil || !row.accept && !errors.Is(err, ErrContext) {
+				t.Fatal("definition namespace role or resource bound differs", err)
+			}
+		})
+	}
+}
+
+func TestGoSDKCompilerBodyRejectsMalformedIntervalsAndIndices(t *testing.T) {
+	for _, mutation := range []string{"flags", "header-offset", "truncated", "missing-sentinel",
+		"nonzero-first", "overflowing-tail", "relocation-width", "auxiliary-width", "object-bytes"} {
+		t.Run(mutation, func(t *testing.T) {
+			data := goObjectDefinitionCountsFixture([4]int{1}, 16)
+			offset := func(index int) int {
+				return int(binary.LittleEndian.Uint32(data[20+4*index:]))
+			}
+			switch mutation {
+			case "flags":
+				binary.LittleEndian.PutUint32(data[16:], 0)
+			case "header-offset":
+				binary.LittleEndian.PutUint32(data[20:], ^uint32(0))
+			case "truncated":
+				data = data[:len(data)-1]
+			case "missing-sentinel":
+				at := offset(12) - 4
+				data = append(data[:at:at], data[at+4:]...)
+				for index := 12; index <= 18; index++ {
+					binary.LittleEndian.PutUint32(data[20+4*index:], uint32(offset(index)-4))
+				}
+			case "nonzero-first":
+				binary.LittleEndian.PutUint32(data[offset(11):], 1)
+			case "overflowing-tail":
+				binary.LittleEndian.PutUint32(data[offset(11)+4:], ^uint32(0))
+			case "relocation-width", "auxiliary-width":
+				first := 15
+				if mutation == "auxiliary-width" {
+					first = 16
+				}
+				data = append(data, 0)
+				for index := first; index <= 18; index++ {
+					binary.LittleEndian.PutUint32(data[20+4*index:], uint32(offset(index)+1))
+				}
+			case "object-bytes":
+				// Make a structurally bounded raw-DATA interval whose complete
+				// object exceeds the existing byte budget by exactly one byte.
+				indexTail := offset(13) + 4
+				padding := archiveLimit + 1 - len(data)
+				data = append(data, make([]byte, padding)...)
+				binary.LittleEndian.PutUint32(data[indexTail:], uint32(padding))
+				for index := 17; index <= 18; index++ {
+					binary.LittleEndian.PutUint32(data[20+4*index:], uint32(len(data)))
+				}
+			}
+			if _, err := checkedSDKObject(data, 16, false); !errors.Is(err, ErrContext) {
+				t.Fatal("SDK role accepted malformed or oversized object", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/object_namespace.go b/internal/gostaticstorage/object_namespace.go
new file mode 100644
index 000000000..9d4f47cea
--- /dev/null
+++ b/internal/gostaticstorage/object_namespace.go
@@ -0,0 +1,103 @@
+package gostaticstorage
+
+import "encoding/binary"
+
+// TextSymbolNamespace is an observed goobj block, not a native entry, storage
+// identity or permission. Namespace-relative indices belong to one exact
+// original object; they are never archive-global name lookup keys.
+type TextSymbolNamespace uint8
+
+const (
+	TextSymbolSelf TextSymbolNamespace = iota
+	TextSymbolHashed64
+	TextSymbolHashed
+	TextSymbolNonpkgDefinition
+	TextSymbolNonpkgReference
+)
+
+type indexedObjectSymbol struct {
+	Namespace           TextSymbolNamespace
+	Relative, Index     uint32
+	Name                string
+	ABI                 uint16
+	Kind, Flags, Flags2 uint8
+	Size, Align         uint32
+	Hash                []byte
+}
+
+// indexedSymbols preserves all four definition blocks and NonPkgRefs. DATA's
+// separate named-global reader does not use this observation to admit hashes.
+func (object *checkedGoObject) indexedSymbols() ([]indexedObjectSymbol, error) {
+	var symbols []indexedObjectSymbol
+	for namespace := TextSymbolSelf; namespace <= TextSymbolNonpkgReference; namespace++ {
+		block := object.block(3 + int(namespace))
+		for offset := 0; offset < len(block); offset += 21 {
+			symbol := block[offset : offset+21]
+			name, err := object.stringAt(symbol[:8])
+			if err != nil {
+				return nil, err
+			}
+			value := indexedObjectSymbol{
+				Namespace: namespace, Relative: uint32(offset / 21), Index: uint32(len(symbols)),
+				Name: name, ABI: binary.LittleEndian.Uint16(symbol[8:]), Kind: symbol[10],
+				Flags: symbol[11], Flags2: symbol[12],
+				Size: binary.LittleEndian.Uint32(symbol[13:]), Align: binary.LittleEndian.Uint32(symbol[17:]),
+			}
+			switch namespace {
+			case TextSymbolHashed64:
+				start := offset / 21 * 8
+				value.Hash = append([]byte(nil), object.block(9)[start:start+8]...)
+			case TextSymbolHashed:
+				start := offset / 21 * 16
+				value.Hash = append([]byte(nil), object.block(10)[start:start+16]...)
+			}
+			symbols = append(symbols, value)
+		}
+	}
+	return symbols, nil
+}
+
+// Only named link-visible definitions enter this collision check. Hashed and
+// static definitions retain their independent object-local indices. DUPok
+// groups are observed in full, never reduced to a chosen linker/body winner.
+type sdkAssemblyNamedDefinitions map[string][]indexedObjectSymbol
+
+// This is the IsText role of the independently pinned current SDK schema,
+// not a producer, namespace, ABI or storage permission. Historical readers
+// keep their own enum: Kind 2 was SRODATA in older Go versions.
+func currentSDKObjectIsText(kind uint8) bool {
+	return kind == 1 || kind == 2 // STEXT, STEXTFIPS.
+}
+
+func (definitions sdkAssemblyNamedDefinitions) observeCallText(symbol indexedObjectSymbol, assembly bool, calls map[string]bool) error {
+	if calls != nil && !calls[symbol.Name] && !currentSDKObjectIsText(symbol.Kind) {
+		return nil // Unrelated storage is never selected or returned as a callee.
+	}
+	return definitions.observe(symbol, assembly)
+}
+
+func (definitions sdkAssemblyNamedDefinitions) observe(symbol indexedObjectSymbol, assembly bool) error {
+	if symbol.Namespace == TextSymbolNonpkgReference || symbol.Name == "" {
+		return nil
+	}
+	if assembly && !currentSDKObjectIsText(symbol.Kind) {
+		return contextError("assembly DATA definition needs an independent role: " + symbol.Name)
+	}
+	if symbol.Namespace == TextSymbolHashed64 || symbol.Namespace == TextSymbolHashed || symbol.ABI == 65535 {
+		return nil
+	}
+	for _, previous := range definitions[symbol.Name] {
+		if !currentSDKObjectIsText(symbol.Kind) || symbol.Kind != previous.Kind {
+			return contextError("SDK name collides with a different TEXT/storage kind: " + symbol.Name)
+		}
+		if symbol.ABI != previous.ABI {
+			continue
+		}
+		namedNonpackage := symbol.Namespace == TextSymbolNonpkgDefinition || previous.Namespace == TextSymbolNonpkgDefinition
+		if !namedNonpackage || symbol.Flags&1 == 0 && previous.Flags&1 == 0 {
+			return contextError("duplicate SDK same-ABI named definition: " + symbol.Name)
+		}
+	}
+	definitions[symbol.Name] = append(definitions[symbol.Name], symbol)
+	return nil
+}
diff --git a/internal/gostaticstorage/object_reference_resolver.go b/internal/gostaticstorage/object_reference_resolver.go
new file mode 100644
index 000000000..c290b21bd
--- /dev/null
+++ b/internal/gostaticstorage/object_reference_resolver.go
@@ -0,0 +1,90 @@
+package gostaticstorage
+
+import "encoding/binary"
+
+// This shared resolver preserves the existing TEXT reference rules. Calling
+// it creates no DATA or native permission; each consumer validates its exact
+// record inventory and byte extent independently.
+func objectReferenceResolver(object *checkedGoObject, builtins []TextReference, referenced sdkReferencedSymbols) (func([]byte) (TextReference, error), [5]int, error) {
+	block := object.block
+	counts := [5]int{}
+	var symbols []byte
+	for index := range counts {
+		counts[index] = len(block(index+3)) / 21
+		symbols = append(symbols, block(index+3)...)
+	}
+	symbol := func(index uint32) ([]byte, error) {
+		if uint64(index) >= uint64(len(symbols)/21) {
+			return nil, contextError("TEXT reference symbol index out of bounds")
+		}
+		return symbols[int(index)*21 : (int(index)+1)*21], nil
+	}
+	refNames := make(map[[2]uint32]string)
+	for pos := 0; pos < len(block(17)); pos += 16 {
+		record := block(17)[pos : pos+16]
+		key := [2]uint32{binary.LittleEndian.Uint32(record), binary.LittleEndian.Uint32(record[4:])}
+		name, err := object.stringAt(record[8:])
+		if _, duplicate := refNames[key]; err != nil || duplicate {
+			return nil, counts, contextError("invalid or duplicate TEXT reference name")
+		}
+		refNames[key] = name
+	}
+	resolve := func(raw []byte) (TextReference, error) {
+		var err error
+		ref := TextReference{PackageIndex: binary.LittleEndian.Uint32(raw), SymbolIndex: binary.LittleEndian.Uint32(raw[4:])}
+		index, bound := ref.SymbolIndex, 0
+		switch ref.PackageIndex {
+		case 0:
+			if index != 0 {
+				return ref, contextError("nonzero invalid TEXT symbol reference")
+			}
+			return ref, nil
+		case 2147483643: // PkgIdxSelf, pinned goobj format.
+			bound = counts[0]
+		case 2147483646: // PkgIdxHashed64.
+			bound = counts[1]
+			index += uint32(counts[0])
+		case 2147483645: // PkgIdxHashed.
+			bound = counts[2]
+			index += uint32(counts[0] + counts[1])
+		case 2147483647: // PkgIdxNone, including nonpackage references.
+			bound = counts[3] + counts[4]
+			index += uint32(counts[0] + counts[1] + counts[2])
+		case 2147483644: // PkgIdxBuiltin.
+			if uint64(index) >= uint64(len(builtins)) {
+				return ref, contextError("TEXT builtin index out of bounds")
+			}
+			ref.Name, ref.ABI, ref.ABIKnown = builtins[index].Name, builtins[index].ABI, true
+			return ref, nil
+		default:
+			if ref.PackageIndex >= 2147483643 || uint64(ref.PackageIndex) >= uint64(len(block(1))/8) || index >= symbolLimit {
+				return ref, contextError("TEXT package/index reference out of bounds")
+			}
+			ref.Package, err = object.stringAt(block(1)[int(ref.PackageIndex)*8 : (int(ref.PackageIndex)+1)*8])
+			if err != nil || ref.Package == "" {
+				return ref, contextError("TEXT foreign reference lacks actual package record")
+			}
+			diagnostic, present := refNames[[2]uint32{ref.PackageIndex, ref.SymbolIndex}]
+			if referenced != nil {
+				return resolveSDKIndexedReference(ref, diagnostic, present, referenced)
+			}
+			ref.Name = diagnostic
+			if !present || ref.Name == "" {
+				return ref, contextError("TEXT foreign reference lacks actual package/name record")
+			}
+			return ref, nil
+		}
+		if uint64(ref.SymbolIndex) >= uint64(bound) {
+			return ref, contextError("TEXT local symbol reference out of bounds")
+		}
+		s, err := symbol(index)
+		if err != nil {
+			return ref, err
+		}
+		ref.Name, err = object.stringAt(s[:8])
+		ref.ABI = binary.LittleEndian.Uint16(s[8:])
+		ref.ABIKnown = true
+		return ref, err
+	}
+	return resolve, counts, nil
+}
diff --git a/internal/gostaticstorage/object_references.go b/internal/gostaticstorage/object_references.go
new file mode 100644
index 000000000..d1d2e2e3c
--- /dev/null
+++ b/internal/gostaticstorage/object_references.go
@@ -0,0 +1,120 @@
+package gostaticstorage
+
+import (
+	"fmt"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// Each slice is exactly the compiler object's SymbolDefs block. Hashed and
+// nonpackage definitions cannot be reached by a foreign package SymbolIndex.
+// The live SDK source producer separately authenticates the map's package,
+// export path and whole archive bytes; these records alone grant no role.
+type sdkReferencedSymbols map[string][]indexedObjectSymbol
+
+func resolveSDKIndexedReference(ref TextReference, diagnostic string, present bool, referenced sdkReferencedSymbols) (TextReference, error) {
+	symbols, exists := referenced[ref.Package]
+	if !exists || uint64(ref.SymbolIndex) >= uint64(len(symbols)) {
+		return ref, contextError("TEXT foreign reference lacks actual indexed compiler definition")
+	}
+	symbol := symbols[ref.SymbolIndex]
+	if symbol.Namespace != TextSymbolSelf || symbol.Relative != ref.SymbolIndex || symbol.Index != ref.SymbolIndex ||
+		symbol.Name == "" || symbol.ABI != 0 && symbol.ABI != 1 || symbol.Kind == 0 ||
+		present && diagnostic != symbol.Name {
+		return ref, contextError("TEXT foreign indexed definition or diagnostic identity differs")
+	}
+	ref.Name, ref.ABI, ref.ABIKnown = symbol.Name, symbol.ABI, true
+	ref.Kind, ref.KindKnown = symbol.Kind, true
+	return ref, nil
+}
+
+func sdkReferencedArchiveSymbols(archives map[string]SDKReferencedArchive, target string) (sdkReferencedSymbols, error) {
+	if len(archives) > 4096 {
+		return nil, contextError("excessive SDK referenced archive inventory")
+	}
+	paths := make([]string, 0, len(archives))
+	for path := range archives {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+
+	result := make(sdkReferencedSymbols, len(archives))
+	var totalBytes int
+	for _, path := range paths {
+		archive := archives[path]
+		if path == "" || path != archive.PackagePath || !filepath.IsLocal(filepath.FromSlash(path)) ||
+			filepath.ToSlash(filepath.Clean(filepath.FromSlash(path))) != path {
+			return nil, contextError("SDK referenced package key/path differs")
+		}
+		totalBytes += len(archive.Archive)
+		if totalBytes > 64<<20 {
+			return nil, contextError("complete SDK referenced archives exceed their byte bound")
+		}
+		members, err := archiveMembers(archive.Archive)
+		if err != nil {
+			return nil, err
+		}
+		if len(members) != len(archive.Sources)+2 || members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+			return nil, contextError("SDK referenced archive differs from selected member inventory")
+		}
+		names, err := sdkAssemblyMemberNames(archive.Sources)
+		if err != nil {
+			return nil, err
+		}
+		for index, member := range members[1:] {
+			flags := sdkCompilerObjectFlags(target)
+			if index != 0 {
+				if member.name != names[index-1] {
+					return nil, contextError("SDK referenced source/member route differs")
+				}
+				flags |= 4
+			}
+			reader := objectBody
+			if index == 0 {
+				reader = sdkObjectBody
+			}
+			body, err := reader(member.data, target)
+			if err != nil {
+				return nil, contextError(fmt.Sprintf("SDK referenced package=%s member=%s object header: %v", path, member.name, err))
+			}
+			object, err := checkedSDKIndexedMetadata(body, flags, index != 0)
+			if err != nil {
+				return nil, contextError("SDK referenced package=" + path + " member=" + member.name + ": " + err.Error())
+			}
+			if index == 0 {
+				result[path], err = object.selfSymbols()
+				if err != nil {
+					return nil, err
+				}
+			}
+		}
+	}
+	return result, nil
+}
+
+// Go 1.27.1 work/gc.go packInternal truncates the compiler's object filename
+// to 16 bytes, including a possible partial UTF-8 rune. Match the complete
+// selected sources in original order before observing any body. Prefix matches
+// and truncated-name collisions never select a source or archive member.
+func sdkAssemblyMemberNames(sources []string) ([]string, error) {
+	seenSources := make(map[string]bool, len(sources))
+	seenMembers := map[string]bool{"__.PKGDEF": true, "_go_.o": true}
+	result := make([]string, 0, len(sources))
+	for _, source := range sources {
+		if filepath.Base(source) != source || !strings.HasSuffix(source, ".s") || seenSources[source] ||
+			strings.ContainsAny(source, "\\\x00\r\n") {
+			return nil, contextError("duplicate or noncanonical complete SDK assembly source")
+		}
+		name := strings.TrimSuffix(source, ".s") + ".o"
+		if len(name) > 16 {
+			name = name[:16]
+		}
+		if seenMembers[name] {
+			return nil, contextError("SDK assembly source names collide after archive byte truncation")
+		}
+		seenSources[source], seenMembers[name] = true, true
+		result = append(result, name)
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/object_references_large_go127_test.go b/internal/gostaticstorage/object_references_large_go127_test.go
new file mode 100644
index 000000000..f9c5942b0
--- /dev/null
+++ b/internal/gostaticstorage/object_references_large_go127_test.go
@@ -0,0 +1,158 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const sdkIndexedCountsReaderSource = `package main
+
+import (
+	"cmd/internal/archive"
+	"cmd/internal/goobj"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type Member struct {
+	Name string
+	Offset, Size int64
+	Flags uint32
+	Counts [5]int
+}
+
+func main() {
+	f, err := os.Open(os.Args[1])
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	a, err := archive.Parse(f, false)
+	if err != nil {
+		panic(err)
+	}
+	var result []Member
+	for _, entry := range a.Entries {
+		member := Member{Name: entry.Name, Offset: entry.Offset, Size: entry.Size}
+		if entry.Type == archive.EntryGoObj {
+			data := make([]byte, entry.Obj.Size)
+			n, err := f.ReadAt(data, entry.Obj.Offset)
+			if err != nil || n != len(data) {
+				panic(fmt.Sprint(n, err))
+			}
+			r := goobj.NewReaderFromBytes(data, false)
+			if r == nil {
+				panic("invalid original compiler object")
+			}
+			member.Flags = r.Flags()
+			member.Counts = [5]int{r.NSym(), r.NHashed64def(), r.NHasheddef(), r.NNonpkgdef(), r.NNonpkgref()}
+		}
+		result = append(result, member)
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(result); err != nil {
+		panic(err)
+	}
+}
+`
+
+func TestGoSDKReferencedLargeHashedMetadataFirstParty(t *testing.T) {
+	directory, compiler, _ := fixture(t)
+	oracle := officialReaderForSource(t, compiler, sdkIndexedCountsReaderSource)
+	consumer := filepath.Join(directory, "largehashed")
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	var source strings.Builder
+	source.WriteString("package largehashed\nvar Values = []string{\n")
+	for index := 0; index < symbolLimit+16; index++ {
+		fmt.Fprintf(&source, "%q,\n", fmt.Sprintf("unique-%06d", index))
+	}
+	source.WriteString("}\n")
+	if err := os.WriteFile(filepath.Join(consumer, "value.go"), []byte(source.String()), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			raw := run(t, compiler, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", ".")
+			var selected struct {
+				Export   string
+				Standard bool
+			}
+			if err := json.Unmarshal(raw, &selected); err != nil || selected.Standard || selected.Export == "" {
+				t.Fatal("actual first-party large hashed source role differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			countsRaw := run(t, oracle, consumer, env, selected.Export)
+			var counts []namespaceOracleMember
+			if err := json.Unmarshal(countsRaw, &counts); err != nil || len(counts) != 2 ||
+				counts[1].Flags != 16 || counts[1].Counts[0] > symbolLimit || counts[1].Counts[2] <= symbolLimit {
+				t.Fatal("official large hashed/SymbolDefs counts differ", counts, err)
+			}
+			retainTextArtifact(t, target, "indexed-large-hashed", map[string][]byte{
+				"original.a": archive, "counts-sdk.json": countsRaw, "selection.json": raw, "source-value.go": []byte(source.String()),
+			})
+			observed, err := sdkReferencedArchiveSymbols(map[string]SDKReferencedArchive{
+				fixtureModule + "/largehashed": {PackagePath: fixtureModule + "/largehashed", Archive: archive},
+			}, target)
+			if err != nil || len(observed[fixtureModule+"/largehashed"]) != counts[1].Counts[0] {
+				t.Fatal("SDK referenced-only metadata allocated/rejected unrelated hashed bodies", err)
+			}
+			members, err := archiveMembers(archive)
+			if err != nil {
+				t.Fatal(err)
+			}
+			body, err := objectBody(members[1].data, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := checkedObject(body, 16, false); !errors.Is(err, ErrContext) {
+				t.Fatal("metadata-only role enlarged complete TEXT/body budget", err)
+			}
+		})
+	}
+}
+
+func TestGoSDKReferencedActualRuntimeNamespaceCounts(t *testing.T) {
+	directory, compiler, _ := fixture(t)
+	oracle := officialReaderForSource(t, compiler, sdkIndexedCountsReaderSource)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			env := fixtureEnv(t, "linux/"+arch)
+			raw := run(t, compiler, directory, env, "list", "-json", "-compiled", "-export", "-mod=readonly", "runtime")
+			var selected struct {
+				ImportPath, Export string
+				SFiles             []string
+				Standard           bool
+			}
+			if err := json.Unmarshal(raw, &selected); err != nil || !selected.Standard || selected.ImportPath != "runtime" || selected.Export == "" {
+				t.Fatal("actual SDK runtime export/source role differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			countsRaw := run(t, oracle, directory, env, selected.Export)
+			var counts []namespaceOracleMember
+			if err := json.Unmarshal(countsRaw, &counts); err != nil || len(counts) != len(selected.SFiles)+2 || counts[1].Flags != 16 {
+				t.Fatal("official actual runtime member/namespace counts differ", err)
+			}
+			retainTextArtifact(t, "linux/"+arch, "indexed-runtime", map[string][]byte{
+				"original.a": archive, "counts-sdk.json": countsRaw, "selection.json": raw,
+			})
+			t.Logf("ACTUAL_SDK_RUNTIME_COUNTS %s compiler=%v archive_bytes=%d", arch, counts[1].Counts, len(archive))
+		})
+	}
+}
diff --git a/internal/gostaticstorage/object_version_test.go b/internal/gostaticstorage/object_version_test.go
new file mode 100644
index 000000000..3c181c396
--- /dev/null
+++ b/internal/gostaticstorage/object_version_test.go
@@ -0,0 +1,29 @@
+package gostaticstorage
+
+import "testing"
+
+func TestObjectVersionRetainsExactAuditedProducer(t *testing.T) {
+	for _, version := range []string{"go1.27.1", "go1.27.2", "go1.27.3"} {
+		object := []byte("go object linux arm64 " + version + " GOARM64=v8.0\n!\nbody")
+		if body, err := objectBody(object, "linux/arm64"); err != nil || string(body) != "body" {
+			t.Fatalf("audited object %s: %q %v", version, body, err)
+		}
+		if err := ValidateObjectVersion(object, "linux/arm64", version); err != nil {
+			t.Fatal(err)
+		}
+		for _, other := range []string{"", "go1.27.1", "go1.27.2", "go1.27.3"} {
+			if other != version && ValidateObjectVersion(object, "linux/arm64", other) == nil {
+				t.Fatalf("object %s borrowed producer %s", version, other)
+			}
+		}
+		if ValidateObjectVersion(object, "linux/amd64", version) == nil {
+			t.Fatal("object borrowed a different target")
+		}
+	}
+	for _, version := range []string{"go1.27.4", "go1.28.1", "go1.27.3rc1", "go1.27.3-custom", "devel go1.27.3"} {
+		object := []byte("go object linux arm64 " + version + "\n!\nbody")
+		if _, err := objectBody(object, "linux/arm64"); err == nil {
+			t.Fatalf("unaudited object %s accepted", version)
+		}
+	}
+}
diff --git a/internal/gostaticstorage/observation_sources_go127_test.go b/internal/gostaticstorage/observation_sources_go127_test.go
new file mode 100644
index 000000000..966855d07
--- /dev/null
+++ b/internal/gostaticstorage/observation_sources_go127_test.go
@@ -0,0 +1,38 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func TestGoAuditedObjectObservationSources(t *testing.T) {
+	// The installed same-distribution Go 1.27.2 and 1.27.3 cmd source trees
+	// were compared: all 4517 files (323 cmd/internal) are byte-identical.
+	// Read the installed sources independently of any retained observation;
+	// the patch version alone must never replace these exact format pins.
+	if !gotoolchain.AuditedGo127(runtime.Version()) {
+		t.Fatal("selected SDK patch has no object-format audit", runtime.Version())
+	}
+	if len(formatSources) != 8 || len(sdkCPUFormatSources) != 5 {
+		t.Fatal("object/SDK source-role inventory changed")
+	}
+	for _, roles := range []map[string]string{formatSources, sdkCPUFormatSources} {
+		for name, want := range roles {
+			t.Run(name, func(t *testing.T) {
+				data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got := digest(data); got != want {
+					t.Fatalf("actual observation source SHA256 = %s, want %s", got, want)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/gostaticstorage/owned_source.go b/internal/gostaticstorage/owned_source.go
new file mode 100644
index 000000000..3c00a2b9a
--- /dev/null
+++ b/internal/gostaticstorage/owned_source.go
@@ -0,0 +1,69 @@
+package gostaticstorage
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// SourceDirectoryWithinRoot is a physical relationship query, not a source
+// permission. Existing ancestors must be compared by identity: case aliases
+// can name the same directory even when EvalSymlinks preserves their spelling.
+func SourceDirectoryWithinRoot(directory, root string) (bool, error) {
+	if !filepath.IsAbs(directory) || !filepath.IsAbs(root) {
+		return false, contextError("physical source relationship requires absolute roots")
+	}
+	physical, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return false, err
+	}
+	rootInfo, err := os.Stat(root)
+	if err != nil {
+		return false, err
+	}
+	if !rootInfo.IsDir() {
+		return false, contextError("physical source root is not a directory")
+	}
+	for ancestor := physical; ; ancestor = filepath.Dir(ancestor) {
+		info, err := os.Stat(ancestor)
+		if err != nil {
+			return false, err
+		}
+		if !info.IsDir() {
+			return false, contextError("physical source ancestor is not a directory")
+		}
+		if os.SameFile(info, rootInfo) {
+			return true, nil
+		}
+		if filepath.Dir(ancestor) == ancestor {
+			return false, nil
+		}
+	}
+}
+
+// ValidateOwnedSourceDirectory excludes physical SDK and downloaded cache
+// roots from the ordinary owned-main observation role. Go's Main/Version
+// metadata alone cannot identify that role. This check grants no permission.
+func ValidateOwnedSourceDirectory(directory, goRoot, moduleCache string) error {
+	if !filepath.IsAbs(directory) || !filepath.IsAbs(goRoot) || !filepath.IsAbs(moduleCache) {
+		return contextError("owned source lacks actual absolute SDK/cache/source roots")
+	}
+	physicalDirectory, err := sourcepath.Resolve(directory)
+	if err != nil {
+		return err
+	}
+	if physicalDirectory != directory {
+		return contextError("owned source directory is redirected")
+	}
+	for _, forbidden := range []string{goRoot, moduleCache} {
+		inside, err := SourceDirectoryWithinRoot(physicalDirectory, forbidden)
+		if err != nil {
+			return err
+		}
+		if inside {
+			return contextError("cached external or SDK source cannot acquire an ordinary owned-main role")
+		}
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/owned_source_test.go b/internal/gostaticstorage/owned_source_test.go
new file mode 100644
index 000000000..92f630cb8
--- /dev/null
+++ b/internal/gostaticstorage/owned_source_test.go
@@ -0,0 +1,62 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestOwnedSourceDirectoryUsesPhysicalAncestors(t *testing.T) {
+	base, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	root := filepath.Join(base, "Cache")
+	child := filepath.Join(root, "module", "nested")
+	sibling := filepath.Join(base, "Cache-other")
+	for _, directory := range []string{child, sibling} {
+		if err := os.MkdirAll(directory, 0700); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, test := range []struct {
+		name, directory, root string
+		inside                bool
+	}{
+		{"root itself", root, root, true},
+		{"nested child", child, root, true},
+		{"prefix sibling", sibling, root, false},
+		{"case spelling", child, filepath.Join(base, strings.ToUpper(filepath.Base(root))), false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if test.name == "case spelling" {
+				original, err := os.Stat(root)
+				if err != nil {
+					t.Fatal(err)
+				}
+				alternate, err := os.Stat(test.root)
+				if os.IsNotExist(err) {
+					if err := os.Mkdir(test.root, 0700); err != nil {
+						t.Fatal(err)
+					}
+					alternate, err = os.Stat(test.root)
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				test.inside = os.SameFile(original, alternate)
+			}
+			inside, err := SourceDirectoryWithinRoot(test.directory, test.root)
+			if err != nil || inside != test.inside {
+				t.Fatalf("physical ancestor relationship: inside=%v, want=%v, error=%v", inside, test.inside, err)
+			}
+			if test.inside {
+				if err := ValidateOwnedSourceDirectory(test.directory, sibling, test.root); !errors.Is(err, ErrContext) {
+					t.Fatal("physical cached source acquired owned role", err)
+				}
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/reader.go b/internal/gostaticstorage/reader.go
new file mode 100644
index 000000000..9aede999a
--- /dev/null
+++ b/internal/gostaticstorage/reader.go
@@ -0,0 +1,563 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"golang.org/x/mod/modfile"
+)
+
+// list -export builds the archive before emitting its PackagePublic snapshot.
+// Stale/StaleReason describe the pre-build cache state (SDK cmd/go/internal/load
+// pkg.go), so the immediately repeated command legitimately omits them. Compare
+// every other JSON field, including unknown fields, in its original role. These
+// two display fields may only have their official bool/string types; complete
+// original stdout is retained separately, never rewritten into evidence.
+func sameSelection(first, second []byte) bool {
+	decode := func(raw []byte) ([]map[string]json.RawMessage, bool) {
+		if len(raw) > 4<<20 {
+			return nil, false
+		}
+		decoder := json.NewDecoder(bytes.NewReader(raw))
+		var result []map[string]json.RawMessage
+		for {
+			var item map[string]json.RawMessage
+			if err := decoder.Decode(&item); err == io.EOF {
+				return result, len(result) != 0
+			} else if err != nil || item == nil || len(result) >= 64 {
+				return nil, false
+			}
+			for name, value := range item {
+				if name == "Stale" {
+					var display bool
+					if string(value) == "null" || json.Unmarshal(value, &display) != nil {
+						return nil, false
+					}
+					delete(item, name)
+				} else if name == "StaleReason" {
+					var display string
+					if string(value) == "null" || json.Unmarshal(value, &display) != nil {
+						return nil, false
+					}
+					delete(item, name)
+				} else {
+					var compact bytes.Buffer
+					if json.Compact(&compact, value) != nil {
+						return nil, false
+					}
+					item[name] = compact.Bytes()
+				}
+			}
+			result = append(result, item)
+		}
+	}
+	a, okA := decode(first)
+	b, okB := decode(second)
+	return okA && okB && reflect.DeepEqual(a, b)
+}
+
+func reportPackages(report Report, root string) (map[string]Package, error) {
+	if report.Protocol == SDKCPUProtocol {
+		return sdkCPUPackages(report)
+	}
+	if report.Protocol == SDKGlobalsProtocol {
+		return sdkGlobalsPackages(report)
+	}
+	if err := ValidateOwnedSourceDirectory(root, report.Environment["GOROOT"], report.Environment["GOMODCACHE"]); err != nil {
+		return nil, err
+	}
+	decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+	packages := make(map[string]Package)
+	for {
+		var pkg Package
+		err := decoder.Decode(&pkg)
+		if err == io.EOF {
+			break
+		}
+		if err != nil || len(packages) >= 64 {
+			return nil, contextError("incomplete or oversized actual selection JSON")
+		}
+		if pkg.ImportPath == "unsafe" && pkg.Standard && pkg.Export == "" {
+			continue // Builtin types only; never requested storage.
+		}
+		if _, duplicate := packages[pkg.ImportPath]; duplicate || pkg.ImportPath == "" || pkg.Module == nil || !pkg.Module.Main ||
+			pkg.Module.Dir != root || pkg.Module.Version != "" || len(pkg.Module.Replace) != 0 && string(pkg.Module.Replace) != "null" ||
+			pkg.Module.GoMod != filepath.Join(root, "go.mod") || pkg.Standard || pkg.ForTest != "" ||
+			len(pkg.Error) != 0 && string(pkg.Error) != "null" || len(pkg.DepsErrors) != 0 || pkg.Export == "" ||
+			!filepath.IsAbs(pkg.Export) || !within(root, pkg.Dir) || len(pkg.GoFiles) == 0 || len(pkg.GoFiles) > 256 {
+			return nil, contextError("unbound main-module/package/import/archive role")
+		}
+		for _, files := range [][]string{pkg.SFiles, pkg.CgoFiles, pkg.EmbedFiles, pkg.EmbedPatterns, pkg.CFiles,
+			pkg.CXXFiles, pkg.MFiles, pkg.FFiles, pkg.SwigFiles, pkg.SwigCXXFiles, pkg.SysoFiles} {
+			if len(files) != 0 {
+				return nil, contextError("generated, assembly, cgo, embed or foreign role outside prototype")
+			}
+		}
+		wanted := make([]string, 0, len(pkg.GoFiles))
+		seen := make(map[string]bool)
+		for _, name := range pkg.GoFiles {
+			if filepath.Base(name) != name || seen[name] {
+				return nil, contextError("duplicate or noncanonical selected source")
+			}
+			seen[name] = true
+			absolute := filepath.Join(pkg.Dir, name)
+			rel, _ := filepath.Rel(root, absolute)
+			if report.Source[filepath.ToSlash(rel)] == nil {
+				return nil, contextError("selected source lacks original bytes")
+			}
+			wanted = append(wanted, absolute)
+		}
+		actual := append([]string(nil), pkg.CompiledGoFiles...)
+		for i, file := range actual {
+			if !filepath.IsAbs(file) {
+				if filepath.Base(file) != file {
+					return nil, contextError("unbound relative compiled source")
+				}
+				actual[i] = filepath.Join(pkg.Dir, file)
+			}
+		}
+		sort.Strings(wanted)
+		sort.Strings(actual)
+		if !reflect.DeepEqual(wanted, actual) {
+			return nil, contextError("effective compiled source differs from original source")
+		}
+		pkg.CompiledGoFiles = actual
+		packages[pkg.ImportPath] = pkg
+	}
+	entry, exists := packages[report.PackagePath]
+	if !exists || entry.Dir != root || entry.Module.Path != report.PackagePath {
+		return nil, contextError("requested package differs from actual main-module root")
+	}
+	mod, err := modfile.Parse("go.mod", report.Source["go.mod"], nil)
+	if err != nil || mod.Module == nil || mod.Module.Mod.Path != entry.Module.Path || len(mod.Replace) != 0 {
+		return nil, contextError("original module declaration differs from actual selection")
+	}
+	for _, pkg := range packages {
+		if pkg.Module.Path != entry.Module.Path || pkg.ImportPath != entry.Module.Path && !strings.HasPrefix(pkg.ImportPath, entry.Module.Path+"/") {
+			return nil, contextError("package identity differs from actual module")
+		}
+		for _, path := range pkg.Imports {
+			if path == "unsafe" {
+				continue
+			}
+			destination := path
+			if mapped := pkg.ImportMap[path]; mapped != "" {
+				destination = mapped
+			}
+			if destination != path || packages[destination].ImportPath == "" {
+				return nil, contextError("unbound actual import map or dependency")
+			}
+		}
+		if len(pkg.ImportMap) != 0 {
+			for path, destination := range pkg.ImportMap {
+				found := false
+				for _, actual := range pkg.Imports {
+					found = found || actual == path
+				}
+				if !found || path != destination {
+					return nil, contextError("unknown actual import-map edge")
+				}
+			}
+		}
+	}
+	return packages, nil
+}
+
+func bindVariables(report Report, packages map[string]Package, references []Reference) ([]Variable, error) {
+	_, arch, _ := strings.Cut(report.Target, "/")
+	sizes := types.SizesFor("gc", arch)
+	if sizes == nil {
+		return nil, contextError("unknown actual target layout")
+	}
+	var result []Variable
+	for _, ref := range references {
+		pkg, exists := packages[ref.PackagePath]
+		if !exists {
+			return nil, contextError("variable owner is not an actual imported/entry package")
+		}
+		fset := token.NewFileSet()
+		var syntax []*ast.File
+		selfLinknames := make(map[string]bool)
+		standardFunctions := make(map[string]bool)
+		sourceRoot := pkg.Dir
+		if !sdkStorageProtocol(report.Protocol) {
+			sourceRoot = pkg.Module.Dir
+		}
+		for _, file := range pkg.CompiledGoFiles {
+			rel, _ := filepath.Rel(sourceRoot, file)
+			key := filepath.ToSlash(rel)
+			if report.Protocol == SDKGlobalsProtocol {
+				key = sdkGlobalSourceKey(report.PackagePath, pkg, filepath.Base(file))
+			}
+			parsed, err := parser.ParseFile(fset, file, report.Source[key], parser.ParseComments)
+			if err != nil {
+				return nil, contextError("complete selected Go source cannot be parsed")
+			}
+			// Linknames need an independently bound aliased backing producer.
+			for _, group := range parsed.Comments {
+				for _, comment := range group.List {
+					if strings.HasPrefix(comment.Text, "//go:linknamestd") && report.Protocol == SDKCPUProtocol {
+						words := strings.Fields(comment.Text)
+						if len(words) != 2 || words[0] != "//go:linknamestd" || !token.IsIdentifier(words[1]) ||
+							words[1] == ref.Name || standardFunctions[words[1]] || selfLinknames[words[1]] ||
+							!sdkExternalFunctionDirective(parsed, comment, words[1]) {
+							return nil, contextError("invalid, duplicate or variable SDK standard-linkname directive")
+						}
+						standardFunctions[words[1]] = true
+						continue // An unrelated external function supplies no variable backing.
+					}
+					if report.Protocol == SDKGlobalsProtocol && (strings.HasPrefix(comment.Text, "//go:linkname") || strings.HasPrefix(comment.Text, "//go:linknamestd")) {
+						words := strings.Fields(comment.Text)
+						if len(words) < 2 || len(words) > 3 || !token.IsIdentifier(words[1]) || words[1] == ref.Name {
+							return nil, contextError("requested SDK global has an aliased/linkname storage role")
+						}
+						continue // Unrelated function directives confer no variable backing.
+					}
+					if strings.HasPrefix(comment.Text, "//go:linkname") && report.Protocol == SDKCPUProtocol {
+						words := strings.Fields(comment.Text)
+						if len(words) != 2 || words[0] != "//go:linkname" || !token.IsIdentifier(words[1]) ||
+							selfLinknames[words[1]] || standardFunctions[words[1]] {
+							return nil, contextError("aliased, duplicate or invalid SDK self-linkname")
+						}
+						selfLinknames[words[1]] = true
+						continue
+					}
+					if strings.HasPrefix(comment.Text, "//go:linkname") || strings.HasPrefix(comment.Text, "//line ") {
+						return nil, contextError("linkname/source remapping outside prototype")
+					}
+				}
+			}
+			syntax = append(syntax, parsed)
+		}
+		actual := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+			data := report.Archives[path]
+			if data == nil || packages[path].ImportPath != path {
+				return nil, contextError("type importer lacks authenticated actual archive")
+			}
+			return io.NopCloser(bytes.NewReader(data)), nil
+		})
+		typed, err := (&types.Config{Importer: actual, Sizes: sizes, GoVersion: "go1.27"}).Check(pkg.ImportPath, fset, syntax, nil)
+		if err != nil || typed.Name() != pkg.Name {
+			return nil, contextError("same-source target typecheck differs from actual package")
+		}
+		object, exists := typed.Scope().Lookup(ref.Name).(*types.Var)
+		if !exists || object.Pkg() == nil || object.Pkg().Path() != ref.PackagePath {
+			return nil, contextError("requested object is not an actual package variable")
+		}
+		if report.Protocol == SDKGlobalsProtocol && (ref.PackagePath != report.PackagePath || !sdkGlobalPointerFree(object.Type(), 0)) {
+			return nil, contextError("SDK global requires its original entry-package pointer-free variable")
+		}
+		if ref.PackagePath != report.PackagePath || report.Protocol == SDKCPUProtocol {
+			// For an imported owner, require the actual selected export's Var,
+			// not merely a same-spelled source declaration in another directory.
+			imported, err := actual.Import(ref.PackagePath)
+			if err != nil {
+				return nil, contextError("actual imported variable export cannot be decoded")
+			}
+			declared, ok := imported.Scope().Lookup(ref.Name).(*types.Var)
+			qualifier := func(pkg *types.Package) string { return pkg.Path() }
+			if !ok || declared.Pkg() == nil || declared.Pkg().Path() != ref.PackagePath ||
+				types.TypeString(declared.Type(), qualifier) != types.TypeString(object.Type(), qualifier) {
+				return nil, contextError("actual imported Var differs from complete original declaration")
+			}
+			object = declared
+		}
+		size := sizes.Sizeof(object.Type())
+		if size <= 0 || size > 1<<20 {
+			return nil, contextError("variable extent outside bounded numerical storage")
+		}
+		numerical := make([]bool, int(size))
+		if err := numericBytes(object.Type(), sizes, numerical, 0, 0); err != nil {
+			return nil, err
+		}
+		var records map[string]dataRecord
+		if report.Protocol == SDKGlobalsProtocol {
+			records, err = readSDKGlobalArchive(report.Archives[ref.PackagePath], report.Target, pkg.SFiles)
+		} else if report.Protocol == SDKCPUProtocol {
+			records, err = readSDKCPUArchive(report.Archives[ref.PackagePath], report.Target, pkg.SFiles)
+		} else {
+			records, err = readArchive(report.Archives[ref.PackagePath], report.Target)
+		}
+		if err != nil {
+			return nil, err
+		}
+		name := gosym.PackagePrefix(ref.PackagePath) + "." + ref.Name
+		record, present := records[name]
+		flags2 := uint8(0)
+		if selfLinknames[ref.Name] {
+			flags2 = 16 // SymFlag2Linkname: exact original one-argument Var directive.
+		}
+		if !present || record.Name != name || record.Size != size || record.ABI != 0 || record.Flags != 0 || record.Flags2 != flags2 {
+			return nil, contextError("actual variable and native symbol identity/extent/flags disagree")
+		}
+		switch record.Kind {
+		case 9, 10: // SBSS, SNOPTRBSS; initialized bytes, not constant values.
+			if len(record.Data) != 0 || len(record.Relocations) != 0 {
+				return nil, contextError("BSS record has nonzero data/relocation role")
+			}
+		case 5, 7: // SNOPTRDATA, SDATA. Do not infer missing DATA tail bytes.
+			if int64(len(record.Data)) != size {
+				return nil, contextError("DATA does not explicitly initialize the complete native extent")
+			}
+		default:
+			return nil, contextError("requested object is not ordinary initialized BSS/DATA")
+		}
+		used := make([]bool, len(numerical))
+		for _, relocation := range record.Relocations {
+			if relocation.Type != 1 || relocation.Offset < 0 || relocation.Size != 4 && relocation.Size != 8 ||
+				relocation.Size > size || relocation.Offset > size-relocation.Size {
+				return nil, contextError("unsupported or invalid physical DATA relocation")
+			}
+			for offset := relocation.Offset; offset < relocation.Offset+relocation.Size; offset++ {
+				if used[offset] {
+					return nil, contextError("overlapping DATA relocations")
+				}
+				used[offset], numerical[offset] = true, false
+			}
+		}
+		var spans []Span
+		for offset := 0; offset < len(numerical); {
+			if !numerical[offset] {
+				offset++
+				continue
+			}
+			first := offset
+			for offset < len(numerical) && numerical[offset] {
+				offset++
+			}
+			spans = append(spans, Span{int64(first), int64(offset - first)})
+		}
+		if len(spans) == 0 {
+			return nil, contextError("variable contains no initialized numerical byte span")
+		}
+		result = append(result, Variable{Reference: ref, NativeName: name,
+			GoType: types.TypeString(object.Type(), func(pkg *types.Package) string { return pkg.Path() }),
+			Size:   size, Alignment: record.Align, Kind: record.Kind, Numerical: spans,
+			DefinitionMember: record.Member, DefinitionIndex: record.Index})
+	}
+	return result, nil
+}
+
+func sdkExternalFunctionDirective(file *ast.File, comment *ast.Comment, name string) bool {
+	for _, declaration := range file.Decls {
+		function, valid := declaration.(*ast.FuncDecl)
+		if !valid || function.Name.Name != name || function.Recv != nil || function.Body != nil || function.Doc == nil {
+			continue
+		}
+		for _, actual := range function.Doc.List {
+			if actual == comment {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func numericBytes(typ types.Type, sizes types.Sizes, bytes []bool, base int64, depth int) error {
+	if depth > 64 || base < 0 || base > int64(len(bytes)) {
+		return contextError("numerical type graph bound exceeded")
+	}
+	size := sizes.Sizeof(typ)
+	if size < 0 || size > int64(len(bytes))-base {
+		return contextError("type span exceeds actual object extent")
+	}
+	switch typ := typ.Underlying().(type) {
+	case *types.Basic:
+		if typ.Info()&(types.IsInteger|types.IsFloat|types.IsBoolean) != 0 && typ.Info()&types.IsUntyped == 0 {
+			for offset := base; offset < base+size; offset++ {
+				bytes[offset] = true
+			}
+		}
+	case *types.Array:
+		stride := sizes.Sizeof(typ.Elem())
+		if typ.Len() > 1<<20 || stride < 0 {
+			return contextError("array layout bound exceeded")
+		}
+		for i := int64(0); i < typ.Len(); i++ {
+			if err := numericBytes(typ.Elem(), sizes, bytes, base+i*stride, depth+1); err != nil {
+				return err
+			}
+		}
+	case *types.Struct:
+		fields := make([]*types.Var, typ.NumFields())
+		for i := range fields {
+			fields[i] = typ.Field(i)
+		}
+		for i, off := range sizes.Offsetsof(fields) {
+			if fields[i].Name() == "_" {
+				continue // Blank padding is not numerical permission.
+			}
+			if err := numericBytes(fields[i].Type(), sizes, bytes, base+off, depth+1); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+// ValidateReport independently reconstructs record/layout agreement from all
+// retained bytes. It does not authenticate arbitrary JSON or recreate a token;
+// actual source/tool/command guards remain Observation.Verify's obligation.
+func ValidateReport(report Report) error {
+	sdkCPU := report.Protocol == SDKCPUProtocol
+	sdkGlobals := report.Protocol == SDKGlobalsProtocol
+	if report.Protocol != Protocol && !sdkCPU && !sdkGlobals || !gotoolchain.AuditedGo127(report.Environment["GOVERSION"]) ||
+		report.Environment["GOOS"]+"/"+report.Environment["GOARCH"] != report.Target ||
+		report.Environment["GOFLAGS"] != "" || report.Environment["GOEXPERIMENT"] != "" ||
+		(!sdkCPU && !sdkGlobals && report.Environment["CGO_ENABLED"] != "0" ||
+			(sdkCPU || sdkGlobals) && report.Environment["CGO_ENABLED"] != "0" && report.Environment["CGO_ENABLED"] != "1") ||
+		report.Environment["CGO_ENABLED"] != report.CommandEnvironment["CGO_ENABLED"] || report.Environment["GOWORK"] != "off" ||
+		len(report.Source) == 0 || len(report.Source) != len(report.SourceSHA256) ||
+		len(report.Archives) == 0 || len(report.Archives) > 64 || len(report.Archives) != len(report.ArchiveSHA256) ||
+		len(report.Variables) == 0 || len(report.Variables) > 32 {
+		return contextError("report lacks bounded complete original inputs")
+	}
+	if err := validateSourceInventory(report.Source, report.Protocol); err != nil {
+		return err
+	}
+	arguments, toolCount, environmentCount := selectionArguments(), 3+len(formatSources), 16
+	if sdkCPU || sdkGlobals {
+		arguments, toolCount = sdkCPUArguments(), toolCount+1+len(sdkCPUFormatSources)
+		if sdkGlobals {
+			arguments = sdkGlobalsArguments(report.PackagePath)
+		}
+		environmentCount += 4
+		for key, expected := range sdkCPUProfile(report.Target) {
+			if report.CommandEnvironment[key] != expected || report.Environment[key] != expected {
+				return contextError("SDK retained target tuning differs")
+			}
+		}
+		if report.Tools["asm"] == "" {
+			return contextError("SDK report omits selected actual assembly tool")
+		}
+		for role, hash := range sdkCPUFormatSources {
+			if report.Tools[role] != hash {
+				return contextError("unknown SDK assembly source-to-member rules")
+			}
+		}
+	}
+	if len(report.RawEnvironment) > 64<<10 || len(report.RawSelection) > 4<<20 ||
+		!reflect.DeepEqual(report.CommandArguments, arguments) || !filepath.IsAbs(report.CommandDirectory) ||
+		report.CommandBinary != filepath.Join(report.Environment["GOROOT"], "bin", gotoolchain.HostExecutable("go")) ||
+		len(report.Tools) != toolCount || len(report.CommandEnvironment) != environmentCount {
+		return contextError("report command/tool inventory differs")
+	}
+	for _, key := range []string{"GOCACHE", "GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		if !filepath.IsAbs(report.CommandEnvironment[key]) {
+			return contextError("report lacks effective command cache/temp role")
+		}
+	}
+	for key, value := range map[string]string{"GOTOOLCHAIN": "local", "GOENV": "off", "GOWORK": "off", "CGO_ENABLED": "0", "GOPROXY": "off", "GOFLAGS": "", "GOEXPERIMENT": "", "GOAMD64": "v1"} {
+		if key == "CGO_ENABLED" && (sdkCPU || sdkGlobals) {
+			continue // The exact observed value was checked against its command above.
+		}
+		if report.CommandEnvironment[key] != value {
+			return contextError("report effective command profile differs")
+		}
+	}
+	if report.CommandEnvironment["GOOS"]+"/"+report.CommandEnvironment["GOARCH"] != report.Target ||
+		report.CommandEnvironment["GOCACHE"] != report.Environment["GOCACHE"] ||
+		report.CommandEnvironment["GOMODCACHE"] != report.Environment["GOMODCACHE"] ||
+		report.CommandEnvironment["GOROOT"] != "" && report.CommandEnvironment["GOROOT"] != report.Environment["GOROOT"] {
+		return contextError("actual effective command directory/target/cache role differs")
+	}
+	for _, hash := range report.Tools {
+		if len(hash) != 64 || strings.IndexFunc(hash, func(r rune) bool { return r < '0' || r > '9' && r < 'a' || r > 'f' }) >= 0 {
+			return contextError("invalid original tool digest")
+		}
+	}
+	for _, role := range []string{"go", "VERSION", "compile"} {
+		if report.Tools[role] == "" {
+			return contextError("report omits actual selected tool role")
+		}
+	}
+	var env map[string]string
+	if err := json.Unmarshal(report.RawEnvironment, &env); err != nil || !reflect.DeepEqual(env, report.Environment) {
+		return contextError("retained actual environment differs")
+	}
+	for name, expected := range formatSources {
+		if report.Tools[name] != expected {
+			return contextError("report uses unknown object-format source rules")
+		}
+	}
+	for name, data := range report.Source {
+		if name == "" || strings.Contains(name, "\\") || filepath.IsAbs(name) || filepath.ToSlash(filepath.Clean(name)) != name || name == ".." || strings.HasPrefix(name, "../") || digest(data) != report.SourceSHA256[name] {
+			return contextError("retained source bytes/name/hash changed")
+		}
+	}
+	total := 0
+	for name, data := range report.Archives {
+		if len(data) > archiveLimit || digest(data) != report.ArchiveSHA256[name] {
+			return contextError("retained actual archive bytes/hash changed")
+		}
+		members, err := archiveMembers(data)
+		if err != nil {
+			return err
+		}
+		for _, member := range members {
+			if err := ValidateObjectVersion(member.data, report.Target, report.Environment["GOVERSION"]); err != nil {
+				return err
+			}
+		}
+		total += len(data)
+	}
+	if total > 64<<20 {
+		return contextError("retained actual export byte bound exceeded")
+	}
+	var packagesRaw []Package
+	decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+	for len(packagesRaw) < 65 {
+		var pkg Package
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			return contextError("incomplete retained selection")
+		}
+		packagesRaw = append(packagesRaw, pkg)
+	}
+	root := ""
+	if sdkCPU {
+		root = filepath.Join(report.Environment["GOROOT"], "src", "internal", "cpu")
+	}
+	if sdkGlobals {
+		root = filepath.Join(report.Environment["GOROOT"], "src", filepath.FromSlash(report.PackagePath))
+	}
+	for _, pkg := range packagesRaw {
+		if pkg.ImportPath == report.PackagePath && pkg.Module != nil {
+			root = pkg.Module.Dir
+		}
+	}
+	packages, err := reportPackages(report, root)
+	if err != nil || root != report.CommandDirectory || len(packages) != len(report.Archives) {
+		return contextError("retained actual package/archive inventory differs")
+	}
+	var references []Reference
+	for i, variable := range report.Variables {
+		if !token.IsIdentifier(variable.Name) || variable.Name == "_" || variable.PackagePath == "" ||
+			i > 0 && referenceKey(variable.Reference) <= referenceKey(report.Variables[i-1].Reference) {
+			return contextError("noncanonical or duplicate requested variable")
+		}
+		references = append(references, variable.Reference)
+	}
+	actual, err := bindVariables(report, packages, references)
+	if err != nil || !reflect.DeepEqual(actual, report.Variables) {
+		return contextError("reader reconstruction differs from recorded numerical/native storage")
+	}
+	texts, err := textArchives(report, packages)
+	if err != nil || report.TextProtocol != TextProtocol || !reflect.DeepEqual(texts, report.TextArchives) {
+		return contextError("reader reconstruction differs from actual TEXT records")
+	}
+	return nil
+}
diff --git a/internal/gostaticstorage/readonly_literal_data.go b/internal/gostaticstorage/readonly_literal_data.go
new file mode 100644
index 000000000..8bd018445
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_data.go
@@ -0,0 +1,164 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"reflect"
+)
+
+// ReadonlyLiteralDataImage is a pure initializer plan, never a live owner,
+// pointer, numerical-read or native-body capability. Its object-local identity
+// is retained instead of choosing a global by name or hash.
+type ReadonlyLiteralDataImage struct {
+	SourceOrdinal, MemberOrdinal int
+	SourceName, MemberName       string
+	DeclaredSize                 int64
+	Definition                   ASMDataDefinition
+	Fragments                    []ASMDataFragment
+	Initial                      []byte
+}
+
+// ReadonlyLiteralDataInitializers examines already observed complete DATA
+// records. Only the separate live SDK factory can create an initializer owner.
+func ReadonlyLiteralDataInitializers(observation *SDKASMDataObservation) ([]ReadonlyLiteralDataImage, error) {
+	if observation == nil || observation.Protocol != ASMDataProtocol && observation.Protocol != ASMDataCPPProtocol ||
+		!X86SDKTarget(observation.Target) || observation.PackagePath == "" ||
+		len(observation.Sources) == 0 || len(observation.Sources) > 62 || len(observation.Members) != len(observation.Sources)+2 {
+		return nil, contextError("readonly literal DATA lacks its complete observation role")
+	}
+	names := make([]string, len(observation.Sources))
+	for index, source := range observation.Sources {
+		names[index] = source.Name
+	}
+	members, err := sdkAssemblyMemberNames(names)
+	if err != nil {
+		return nil, err
+	}
+	var total int64
+	// Preflight the whole allocation, including unwritten zero tails, before
+	// creating any image. Sparse P bytes alone are not the initialized extent.
+	for _, source := range observation.Sources {
+		for _, layout := range source.ExpandedLayouts {
+			total += int64(layout.Definition.Size)
+			if layout.Definition.Size > archiveLimit || total > archiveLimit {
+				return nil, contextError("readonly literal DATA complete initializer bytes exceed the existing object bound")
+			}
+		}
+	}
+	var images []ReadonlyLiteralDataImage
+	for ordinal, source := range observation.Sources {
+		member := observation.Members[ordinal+2]
+		if member.Ordinal != ordinal+2 || member.Name != members[ordinal] || !bytes.Equal(member.NameBytes, []byte(member.Name)) ||
+			member.Flags != sdkAssemblyObjectFlags(observation.Target) ||
+			source.Original.Flags != sdkAssemblyObjectFlags(observation.Target) ||
+			source.Expanded.Flags != sdkAssemblyObjectFlags(observation.Target) ||
+			!sameASMDataObjects(source.Original, member) || !sameASMDataObjects(source.Original, source.Expanded) {
+			return nil, contextError("readonly literal DATA whole source/object/archive identity differs")
+		}
+		if observation.Protocol == ASMDataCPPProtocol && (!reflect.DeepEqual(source.Original.Texts, member.Texts) ||
+			!reflect.DeepEqual(source.Original.Texts, source.Expanded.Texts) || source.Layouts != nil || source.OriginalProgramSHA256 != "") {
+			return nil, contextError("readonly literal DATA borrowed a raw program or changed complete CPP positions")
+		}
+		type identity struct {
+			namespace TextSymbolNamespace
+			index     uint32
+		}
+		definitions := make(map[identity]ASMDataDefinition, len(member.Definitions))
+		for _, definition := range member.Definitions {
+			key := identity{definition.Namespace, definition.Index}
+			if _, exists := definitions[key]; exists {
+				return nil, contextError("readonly literal DATA repeats an object-local definition")
+			}
+			definitions[key] = definition
+		}
+		used := make(map[identity]bool)
+		lastGlobal := -1
+		for _, layout := range source.ExpandedLayouts {
+			key := identity{layout.Definition.Namespace, layout.Definition.Index}
+			definition, present := definitions[key]
+			first, second := definition, layout.Definition
+			first.DataOffset, second.DataOffset = 0, 0
+			if !present || used[key] || !reflect.DeepEqual(first, second) || layout.Ordinal <= lastGlobal || layout.Line < 1 {
+				return nil, contextError("readonly literal DATA layout lost its unique source/namespace/index join")
+			}
+			lastGlobal, used[key] = layout.Ordinal, true
+			if !layout.Static || layout.ABI != 65535 || layout.Name == "" || definition.Name != layout.Name || definition.ABI != layout.ABI ||
+				layout.Flags != 8 && layout.Flags != 24 || definition.Namespace != TextSymbolSelf || asmDataBaseKind(definition.Kind) != 3 ||
+				definition.Flags != 0 || definition.Flags2 != 0 || len(definition.Hash) != 0 || len(definition.Relocations) != 0 {
+				return nil, contextError("DATA is not one private relocation-free readonly literal definition")
+			}
+			if layout.DeclaredSize < 0 || layout.DeclaredSize > archiveLimit || definition.Size > archiveLimit || len(definition.Data) > int(definition.Size) {
+				return nil, contextError("readonly literal DATA written bytes exceed its actual object extent")
+			}
+			initial := make([]byte, definition.Size)
+			end, previous, expectedSize := int64(0), -1, layout.DeclaredSize
+			for _, fragment := range layout.Fragments {
+				if fragment.Offset < end || fragment.Width < 0 || fragment.Offset > int64(len(definition.Data))-fragment.Width ||
+					fragment.Ordinal <= previous || fragment.Line < 1 || fragment.Address != nil {
+					return nil, contextError("readonly literal DATA fragments overlap or lose their source extent/order")
+				}
+				end, previous = fragment.Offset+fragment.Width, fragment.Ordinal
+				// GloblPos sets Size to the declared value. Only DATA after
+				// that declaration can grow it; prior P bytes do not enlarge
+				// a subsequently shortened GLOBL or make it linkable.
+				if fragment.Ordinal > layout.Ordinal && end > expectedSize {
+					expectedSize = end
+				}
+				switch fragment.Kind {
+				case ASMDataInteger, ASMDataFloat:
+					if len(fragment.String) != 0 || fragment.Width != 1 && fragment.Width != 2 && fragment.Width != 4 && fragment.Width != 8 ||
+						fragment.Kind == ASMDataFloat && fragment.Width != 4 && fragment.Width != 8 ||
+						fragment.Width < 8 && fragment.Bits>>(8*uint(fragment.Width)) != 0 {
+						return nil, contextError("readonly literal DATA bit pattern differs from its exact scalar width")
+					}
+					for index := int64(0); index < fragment.Width; index++ {
+						initial[fragment.Offset+index] = byte(fragment.Bits >> (8 * uint(index)))
+					}
+				case ASMDataString:
+					if fragment.Bits != 0 || int64(len(fragment.String)) > fragment.Width {
+						return nil, contextError("readonly literal DATA string exceeds its exact padded byte extent")
+					}
+					copy(initial[fragment.Offset:end], fragment.String)
+				default:
+					return nil, contextError("readonly literal DATA contains an address or unknown initializer role")
+				}
+			}
+			if expectedSize != int64(definition.Size) || end != int64(len(definition.Data)) || !bytes.Equal(initial[:end], definition.Data) {
+				return nil, contextError("readonly literal DATA reconstructed sparse bytes differ from the original object")
+			}
+			image := ReadonlyLiteralDataImage{SourceOrdinal: ordinal, MemberOrdinal: member.Ordinal,
+				SourceName: source.Name, MemberName: member.Name, DeclaredSize: layout.DeclaredSize,
+				Definition: definition, Fragments: layout.Fragments, Initial: initial}
+			// The plan owns its arrays; caller mutation cannot change the observed
+			// object or another plan. This remains a pure value, not an owner token.
+			image.Definition.Data = append([]byte(nil), definition.Data...)
+			image.Fragments = append([]ASMDataFragment(nil), layout.Fragments...)
+			for index := range image.Fragments {
+				image.Fragments[index].String = append([]byte(nil), layout.Fragments[index].String...)
+			}
+			images = append(images, image)
+		}
+		metadata, err := readonlyGeneratedMetadata(source, observation.Target)
+		if err != nil {
+			return nil, err
+		}
+		for _, definition := range metadata {
+			key := identity{definition.Namespace, definition.Index}
+			actual, present := definitions[key]
+			first, second := actual, definition
+			first.DataOffset, second.DataOffset = 0, 0
+			if !present || used[key] || !reflect.DeepEqual(first, second) {
+				return nil, contextError("readonly metadata lost its exact definition or overlaps an ordinary DATA layout")
+			}
+			used[key] = true // Inventory only: metadata never produces an image.
+		}
+		for _, definition := range member.Definitions {
+			if definition.Name != "" && !used[identity{definition.Namespace, definition.Index}] {
+				return nil, contextError("readonly literal DATA omits a named definition from the complete source")
+			}
+		}
+	}
+	if len(images) == 0 {
+		return nil, contextError("complete source has no private readonly literal DATA initializers")
+	}
+	return images, nil
+}
diff --git a/internal/gostaticstorage/readonly_literal_data_go127_test.go b/internal/gostaticstorage/readonly_literal_data_go127_test.go
new file mode 100644
index 000000000..5f8d5d638
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_data_go127_test.go
@@ -0,0 +1,168 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"debug/elf"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This uses the real Go assembler/compiler and linker, not an SDK-origin
+// token. Explicit -std flags exercise the offline object role only. Complete
+// ELF bytes independently establish sparse and zero-tail materialization.
+func TestReadonlyLiteralDataActualGoObjects(t *testing.T) {
+	directory, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkASMDataReaderSource)
+	root := filepath.Dir(filepath.Dir(binary))
+	builtin, err := os.ReadFile(filepath.Join(root, "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			pkg := fixtureModule + "/readonly" + arch
+			consumer := filepath.Join(directory, "readonly"+arch)
+			if err := os.Mkdir(consumer, 0700); err != nil {
+				t.Fatal(err)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT ·Entry(SB),4,$0-0\n")
+			var directives strings.Builder
+			for index, test := range asmDataGrammarCases {
+				name := fmt.Sprintf("literal_%d", index)
+				fmt.Fprintf(&source, "MOVL %s<>(SB),AX\n", name)
+				fmt.Fprintf(&directives, "DATA %s<>+0(SB)/%d,$%s\nGLOBL %s<>(SB),8,$16\n",
+					name, test.width, test.value, name)
+			}
+			for _, name := range []string{"sparse", "tail", "before", "zero_only"} {
+				fmt.Fprintf(&source, "MOVL %s<>(SB),AX\n", name)
+			}
+			source.WriteString("RET\n")
+			directives.WriteString("DATA sparse<>+2(SB)/1,$255\nDATA sparse<>+7(SB)/4,$0x12345678\nGLOBL sparse<>(SB),8|16,$24\n")
+			directives.WriteString("DATA tail<>(SB)/1,$31\nGLOBL tail<>(SB),8,$32\n")
+			directives.WriteString("GLOBL before<>(SB),8,$8\nDATA before<>+8(SB)/4,$0x88776655\n")
+			directives.WriteString("GLOBL zero_only<>(SB),8,$24\n")
+			source.WriteString(directives.String())
+			assembly := []byte(source.String())
+			goSource := []byte("package readonlyfixture\nfunc Entry()\n")
+			for name, data := range map[string][]byte{"source.go": goSource, "table.s": assembly} {
+				if err := os.WriteFile(filepath.Join(consumer, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			selection := run(t, binary, consumer, env, "list", "-compiled", "-export", "-json", "-gcflags=-std", "-asmflags=-std", ".")
+			var selected struct {
+				ImportPath, Export string
+				SFiles             []string
+				Standard           bool
+			}
+			if json.Unmarshal(selection, &selected) != nil || selected.ImportPath != pkg || selected.Standard ||
+				!reflect.DeepEqual(selected.SFiles, []string{"table.s"}) {
+				t.Fatal("actual first-party selected source inventory differs")
+			}
+			read := func(file string) []byte {
+				data, err := os.ReadFile(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				return data
+			}
+			archive := read(selected.Export)
+			original := run(t, oracle, consumer, env, selected.Export)
+			request := SDKASMDataObservationRequest{PackagePath: pkg, Target: target, Archive: archive, BuiltinSource: builtin}
+			input := SDKASMDataSource{Name: "table.s", Original: assembly, Expanded: assembly}
+			artifacts := map[string][]byte{"original.a": archive, "data-sdk.json": original,
+				"source-table.s": assembly, "source.go": goSource, "selection.json": selection}
+			for _, role := range []string{"original", "expanded"} {
+				object := filepath.Join(consumer, role+".o")
+				run(t, binary, consumer, env, "tool", "asm", "-std", "-p", pkg, "-o", object, "table.s")
+				data := read(object)
+				artifacts[role+".o"] = data
+				artifacts[role+".sdk.json"] = run(t, oracle, consumer, env, object)
+				if role == "original" {
+					input.OriginalObject = data
+				} else {
+					input.ExpandedObject = data
+				}
+			}
+			request.Sources = []SDKASMDataSource{input}
+			observation, err := ObserveX86SDKASMData(request)
+			if err != nil {
+				t.Fatal("complete actual source/whole original objects", err)
+			}
+			var official []ASMDataMember
+			if json.Unmarshal(original, &official) != nil || len(official) != len(observation.Members) ||
+				!reflect.DeepEqual(official[2].Definitions, observation.Members[2].Definitions) {
+				t.Fatal("private DATA namespace/index/bytes differ from independent Go reader")
+			}
+			caller := filepath.Join(directory, "caller"+arch)
+			if err := os.Mkdir(caller, 0700); err != nil {
+				t.Fatal(err)
+			}
+			callerSource := []byte(fmt.Sprintf("package main\nimport %q\nfunc main(){ readonlyfixture.Entry() }\n", pkg))
+			if err := os.WriteFile(filepath.Join(caller, "main.go"), callerSource, 0600); err != nil {
+				t.Fatal(err)
+			}
+			executable := filepath.Join(caller, "original-linked")
+			run(t, binary, caller, env, "build", "-gcflags="+pkg+"=-std", "-asmflags="+pkg+"=-std", "-o", executable, ".")
+			artifacts["linked-original.elf"] = read(executable)
+			artifacts["caller.go"] = callerSource
+			encoded, err := json.Marshal(observation)
+			if err != nil {
+				t.Fatal(err)
+			}
+			artifacts["observation.json"] = encoded
+			retainTextArtifact(t, target, "readonly-literal", artifacts)
+			images, err := ReadonlyLiteralDataInitializers(observation)
+			if err != nil || len(images) != len(asmDataGrammarCases)+4 {
+				t.Fatal("complete actual literal initializer family remains unclosed", err)
+			}
+			object, err := elf.Open(executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer object.Close()
+			if arch == "386" && object.Machine != elf.EM_386 || arch == "amd64" && object.Machine != elf.EM_X86_64 {
+				t.Fatal("actual ELF target differs")
+			}
+			symbols, err := object.Symbols()
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, image := range images {
+				matches := 0
+				for _, symbol := range symbols {
+					if symbol.Name != image.Definition.Name {
+						continue
+					}
+					matches++
+					section := object.Sections[symbol.Section]
+					data, err := section.Data()
+					start := symbol.Value - section.Addr
+					if err != nil || section.Name != ".rodata" || symbol.Size != uint64(len(image.Initial)) ||
+						start > uint64(len(data)) || symbol.Size > uint64(len(data))-start ||
+						!bytes.Equal(image.Initial, data[start:start+symbol.Size]) {
+						t.Fatal("exact sparse/tail initializer differs from actual Go linked bytes", image.Definition.Name, err)
+					}
+				}
+				if matches != 1 {
+					t.Fatal("private first-party linked symbol is not unique", image.Definition.Name, matches)
+				}
+			}
+			encoded, err = json.Marshal(images)
+			if err != nil {
+				t.Fatal(err)
+			}
+			retainTextArtifact(t, target, "readonly-literal", map[string][]byte{"initializers.json": encoded})
+		})
+	}
+}
diff --git a/internal/gostaticstorage/readonly_literal_data_test.go b/internal/gostaticstorage/readonly_literal_data_test.go
new file mode 100644
index 000000000..db98e1b4c
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_data_test.go
@@ -0,0 +1,222 @@
+package gostaticstorage
+
+import (
+	"encoding/json"
+	"errors"
+	"testing"
+)
+
+// This is a pure rule model, not an SDK source, owner or object-byte oracle.
+// ActualGoObjects independently checks every literal class and linked padding.
+func readonlyLiteralModel() *SDKASMDataObservation {
+	definition := ASMDataDefinition{Namespace: TextSymbolSelf, Name: "literal", ABI: 65535,
+		Kind: 3, Size: 8, Data: []byte{0, 255}, DataOffset: 100}
+	fragment := ASMDataFragment{Ordinal: 0, Line: 1, Offset: 1, Width: 1, Kind: ASMDataInteger, Bits: 255}
+	layout := ASMGlobalLayout{Ordinal: 1, Line: 2, Name: definition.Name, Static: true, ABI: 65535,
+		Flags: 24, DeclaredSize: 8, Fragments: []ASMDataFragment{fragment}, Definition: definition}
+	member := ASMDataMember{Name: "table.o", NameBytes: []byte("table.o"), Ordinal: 2, Flags: 20,
+		Definitions: []ASMDataDefinition{definition}}
+	return &SDKASMDataObservation{Protocol: ASMDataCPPProtocol, PackagePath: "model", Target: "linux/amd64",
+		Members: []ASMDataMember{{Name: "__.PKGDEF"}, {Name: "_go_.o"}, member},
+		Sources: []ASMDataSourceObservation{{Name: "table.s", Original: member, Expanded: member, ExpandedLayouts: []ASMGlobalLayout{layout}}}}
+}
+
+func readonlyLiteralClone(t *testing.T, observation *SDKASMDataObservation) *SDKASMDataObservation {
+	t.Helper()
+	data, err := json.Marshal(observation)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var copied SDKASMDataObservation
+	if err := json.Unmarshal(data, &copied); err != nil {
+		t.Fatal(err)
+	}
+	return &copied
+}
+
+func TestReadonlyLiteralDataModelAndOwnership(t *testing.T) {
+	observation := readonlyLiteralModel()
+	images, err := ReadonlyLiteralDataInitializers(observation)
+	if err != nil || len(images) != 1 || len(images[0].Initial) != 8 || images[0].Initial[1] != 255 {
+		t.Fatal("exact sparse/tail model was rejected", err)
+	}
+	images[0].Initial[1] = 0
+	images[0].Definition.Data[1] = 0
+	images[0].Fragments[0].Bits = 0
+	if observation.Sources[0].ExpandedLayouts[0].Fragments[0].Bits != 255 || observation.Members[2].Definitions[0].Data[1] != 255 {
+		t.Fatal("pure returned plan aliases the complete original observation")
+	}
+}
+
+func TestReadonlyLiteralDataOrdinaryAndFIPSKinds(t *testing.T) {
+	for _, kind := range []uint8{1, 2, 3, 4, 5, 6, 7, 8, 9, 25} {
+		observation := readonlyLiteralClone(t, readonlyLiteralModel())
+		observation.Members[2].Definitions[0].Kind = kind
+		observation.Sources[0].Original.Definitions[0].Kind = kind
+		observation.Sources[0].Expanded.Definitions[0].Kind = kind
+		observation.Sources[0].ExpandedLayouts[0].Definition.Kind = kind
+		images, err := ReadonlyLiteralDataInitializers(observation)
+		if kind == 3 || kind == 4 {
+			if err != nil || len(images) != 1 || images[0].Definition.Kind != kind || images[0].Initial[1] != 255 {
+				t.Fatalf("readonly kind %d lost original kind or bytes: %v", kind, err)
+			}
+		} else if !errors.Is(err, ErrContext) || images != nil {
+			t.Fatalf("non-readonly kind %d acquired a literal initializer: %v", kind, err)
+		}
+	}
+}
+
+func TestReadonlyLiteralDataRoleAndIdentityNegatives(t *testing.T) {
+	cases := map[string]func(*SDKASMDataObservation){
+		"protocol":             func(o *SDKASMDataObservation) { o.Protocol = "public-json" },
+		"target":               func(o *SDKASMDataObservation) { o.Target = "linux/arm64" },
+		"package":              func(o *SDKASMDataObservation) { o.PackagePath = "" },
+		"empty-source":         func(o *SDKASMDataObservation) { o.Sources = nil },
+		"missing-member":       func(o *SDKASMDataObservation) { o.Members = o.Members[:2] },
+		"source-route":         func(o *SDKASMDataObservation) { o.Sources[0].Name = "foreign.s" },
+		"member-route":         func(o *SDKASMDataObservation) { o.Members[2].Name = "foreign.o" },
+		"member-bytes":         func(o *SDKASMDataObservation) { o.Members[2].NameBytes[0] ^= 1 },
+		"member-ordinal":       func(o *SDKASMDataObservation) { o.Members[2].Ordinal++ },
+		"member-flags":         func(o *SDKASMDataObservation) { o.Members[2].Flags = 4 },
+		"expanded-object":      func(o *SDKASMDataObservation) { o.Sources[0].Expanded.Definitions[0].Data[0] = 1 },
+		"original-object":      func(o *SDKASMDataObservation) { o.Sources[0].Original.Definitions[0].Index++ },
+		"compiler-object":      func(o *SDKASMDataObservation) { o.Members[2].Definitions[0].Relative++ },
+		"borrowed-raw-program": func(o *SDKASMDataObservation) { o.Sources[0].OriginalProgramSHA256 = "same-code" },
+		"borrowed-raw-layout":  func(o *SDKASMDataObservation) { o.Sources[0].Layouts = o.Sources[0].ExpandedLayouts },
+		"missing-layout":       func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts = nil },
+		"repeated-layout": func(o *SDKASMDataObservation) {
+			o.Sources[0].ExpandedLayouts = append(o.Sources[0].ExpandedLayouts, o.Sources[0].ExpandedLayouts[0])
+		},
+		"layout-index": func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Definition.Index++ },
+		"layout-namespace": func(o *SDKASMDataObservation) {
+			o.Sources[0].ExpandedLayouts[0].Definition.Namespace = TextSymbolHashed
+		},
+		"layout-relative": func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Definition.Relative++ },
+		"not-static":      func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Static = false },
+		"wrong-ABI":       func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].ABI = 0 },
+		"wrong-name":      func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Name = "same-code-foreign" },
+		"unknown-flags":   func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Flags |= 32 },
+		"DUPok":           func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Flags |= 2 },
+		"mutable":         func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].Flags = 16 },
+		"negative-size":   func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].DeclaredSize = -1 },
+		"wrong-size":      func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].DeclaredSize = 9 },
+		"short-size":      func(o *SDKASMDataObservation) { o.Sources[0].ExpandedLayouts[0].DeclaredSize = 1 },
+	}
+	for name, mutate := range cases {
+		t.Run(name, func(t *testing.T) {
+			observation := readonlyLiteralClone(t, readonlyLiteralModel())
+			mutate(observation)
+			if _, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) {
+				t.Fatal("unbound or foreign DATA became an initializer", err)
+			}
+		})
+	}
+}
+
+func TestReadonlyLiteralDataFragmentNegatives(t *testing.T) {
+	for name, mutate := range map[string]func(*ASMDataFragment){
+		"negative-offset":    func(f *ASMDataFragment) { f.Offset = -1 },
+		"negative-width":     func(f *ASMDataFragment) { f.Width = -1 },
+		"past-written-P":     func(f *ASMDataFragment) { f.Offset = 2 },
+		"unsupported-width":  func(f *ASMDataFragment) { f.Width = 3 },
+		"wrong-float-width":  func(f *ASMDataFragment) { f.Kind = ASMDataFloat },
+		"bits-not-truncated": func(f *ASMDataFragment) { f.Bits = 511 },
+		"different-bits":     func(f *ASMDataFragment) { f.Bits = 254 },
+		"unknown-kind":       func(f *ASMDataFragment) { f.Kind = "bytes-from-hash" },
+		"address":            func(f *ASMDataFragment) { f.Kind = ASMDataAddress; f.Address = &ASMDataAddressValue{Name: "foreign"} },
+		"hidden-address":     func(f *ASMDataFragment) { f.Address = &ASMDataAddressValue{Name: "foreign"} },
+		"hidden-string":      func(f *ASMDataFragment) { f.String = []byte("x") },
+		"string-overflow":    func(f *ASMDataFragment) { f.Kind = ASMDataString; f.Bits = 0; f.String = []byte("xy") },
+		"string-hidden-bits": func(f *ASMDataFragment) { f.Kind = ASMDataString; f.String = []byte{255} },
+		"negative-ordinal":   func(f *ASMDataFragment) { f.Ordinal = -1 },
+		"missing-line":       func(f *ASMDataFragment) { f.Line = 0 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			observation := readonlyLiteralModel()
+			mutate(&observation.Sources[0].ExpandedLayouts[0].Fragments[0])
+			if _, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) {
+				t.Fatal("invalid literal fragment became initialized bytes", err)
+			}
+		})
+	}
+	for _, kind := range []string{"overlap", "reordered", "missing-fragment", "missing-hole"} {
+		t.Run(kind, func(t *testing.T) {
+			observation := readonlyLiteralModel()
+			layout := &observation.Sources[0].ExpandedLayouts[0]
+			switch kind {
+			case "overlap", "reordered":
+				second := layout.Fragments[0]
+				if kind == "overlap" {
+					second.Ordinal++
+				} else {
+					second.Offset++
+				}
+				layout.Fragments = append(layout.Fragments, second)
+			case "missing-fragment":
+				layout.Fragments = nil
+			case "missing-hole":
+				layout.Fragments[0].Offset = 0
+			}
+			if _, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) {
+				t.Fatal("incomplete sparse source became an initializer", err)
+			}
+		})
+	}
+}
+
+func TestReadonlyLiteralDataAggregateZeroTailBudget(t *testing.T) {
+	observation := readonlyLiteralModel()
+	layout := &observation.Sources[0].ExpandedLayouts[0]
+	layout.DeclaredSize = archiveLimit
+	layout.Definition.Size = archiveLimit
+	observation.Members[2].Definitions[0].Size = archiveLimit
+	observation.Sources[0].Original.Definitions[0].Size = archiveLimit
+	observation.Sources[0].Expanded.Definitions[0].Size = archiveLimit
+	second := *layout
+	second.Name, second.Ordinal = "second", 2
+	second.Definition.Name, second.Definition.Relative, second.Definition.Index = "second", 1, 1
+	second.DeclaredSize, second.Definition.Size = 1, 1
+	second.Fragments, second.Definition.Data = nil, nil
+	observation.Sources[0].ExpandedLayouts = append(observation.Sources[0].ExpandedLayouts, second)
+	for _, member := range []*ASMDataMember{&observation.Members[2], &observation.Sources[0].Original, &observation.Sources[0].Expanded} {
+		member.Definitions = append(member.Definitions, second.Definition)
+	}
+	if _, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) {
+		t.Fatal("per-global zero tails bypassed the aggregate initializer byte bound", err)
+	}
+}
+
+func TestReadonlyLiteralDataDefinitionRoleNegatives(t *testing.T) {
+	for name, mutate := range map[string]func(*ASMDataDefinition){
+		"named-link-visible": func(d *ASMDataDefinition) { d.ABI = 0 },
+		"hashed64":           func(d *ASMDataDefinition) { d.Namespace = TextSymbolHashed64 },
+		"hashed":             func(d *ASMDataDefinition) { d.Namespace = TextSymbolHashed },
+		"nonpkg-definition":  func(d *ASMDataDefinition) { d.Namespace = TextSymbolNonpkgDefinition },
+		"nonpkg-reference":   func(d *ASMDataDefinition) { d.Namespace = TextSymbolNonpkgReference },
+		// Kind 4 retains its positive whole-object case above. FIPS tagging
+		// does not turn mutable NOPTR storage into a readonly initializer.
+		"mutable-NOPTR-FIPS":      func(d *ASMDataDefinition) { d.Kind = 6 },
+		"mutable-NOPTR":           func(d *ASMDataDefinition) { d.Kind = 5 },
+		"mutable-DATA":            func(d *ASMDataDefinition) { d.Kind = 7 },
+		"BSS":                     func(d *ASMDataDefinition) { d.Kind = 9 },
+		"TLSBSS":                  func(d *ASMDataDefinition) { d.Kind = 11 },
+		"DUPok":                   func(d *ASMDataDefinition) { d.Flags = 1 },
+		"unknown-flags":           func(d *ASMDataDefinition) { d.Flags = 128 },
+		"other-role-flags":        func(d *ASMDataDefinition) { d.Flags2 = 1 },
+		"hash-cannot-select-body": func(d *ASMDataDefinition) { d.Hash = []byte("samehash") },
+		"written-beyond-size":     func(d *ASMDataDefinition) { d.Size = 1 },
+		"size-beyond-budget":      func(d *ASMDataDefinition) { d.Size = archiveLimit + 1 },
+		"address-relocation":      func(d *ASMDataDefinition) { d.Relocations = []TextRelocation{{Offset: 0, Size: 1, Type: 1}} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			observation := readonlyLiteralClone(t, readonlyLiteralModel())
+			for _, member := range []*ASMDataMember{&observation.Members[2], &observation.Sources[0].Original, &observation.Sources[0].Expanded} {
+				mutate(&member.Definitions[0])
+			}
+			mutate(&observation.Sources[0].ExpandedLayouts[0].Definition)
+			if _, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) {
+				t.Fatal("whole-object agreement borrowed a different DATA role", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/readonly_literal_generated_metadata.go b/internal/gostaticstorage/readonly_literal_generated_metadata.go
new file mode 100644
index 000000000..d2f41965e
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_generated_metadata.go
@@ -0,0 +1,140 @@
+package gostaticstorage
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+	"sort"
+)
+
+// Generated metadata explains whole-object inventory, not initialized storage.
+// Validate mutable records again before the planner accounts for them. The live
+// factory's independent source/tool association remains a separate authority.
+func readonlyGeneratedMetadata(source ASMDataSourceObservation, target string) ([]ASMDataDefinition, error) {
+	if len(source.GeneratedFloatPools) == 0 && len(source.GeneratedFuncdata) == 0 {
+		return nil, nil
+	}
+	member := source.Expanded
+	if len(source.TextOrder) != len(member.Texts) || len(source.TextOrder) == 0 || len(source.TextOrder) > symbolLimit ||
+		len(source.GeneratedFuncdata) > 1 || len(source.GeneratedFloatPools)+len(source.GeneratedFuncdata) > len(member.Definitions) {
+		return nil, contextError("readonly metadata lacks its complete source/TEXT inventory")
+	}
+	seenTexts := make(map[int]bool, len(source.TextOrder))
+	for ordinal, owner := range source.TextOrder {
+		if owner.SourceOrdinal != ordinal || owner.ObjectOrdinal < 0 || owner.ObjectOrdinal >= len(member.Texts) || seenTexts[owner.ObjectOrdinal] {
+			return nil, contextError("readonly metadata source/TEXT order changed")
+		}
+		text := member.Texts[owner.ObjectOrdinal]
+		if owner.Name != text.Name || owner.ABI != text.ABI || owner.Namespace != text.Namespace ||
+			owner.Relative != text.Relative || owner.Index != text.Index {
+			return nil, contextError("readonly metadata source/TEXT identity changed")
+		}
+		seenTexts[owner.ObjectOrdinal] = true
+	}
+	statements := make(map[int]bool)
+	definitions, err := readonlyGeneratedFloatPools(source, target, statements)
+	if err != nil {
+		return nil, err
+	}
+	for _, metadata := range source.GeneratedFuncdata {
+		if !validGeneratedLocalsDefinition(metadata.Definition) || len(metadata.Owners) == 0 || len(metadata.Owners) > len(member.Texts) {
+			return nil, contextError("readonly FUNCDATA metadata definition/payload/hash/owners changed")
+		}
+		owners := make(map[int]bool, len(metadata.Owners))
+		for _, owner := range metadata.Owners {
+			if !readonlyMetadataStatement(statements, owner.StatementOrdinal, owner.TextSourceOrdinal) ||
+				!readonlyMetadataTextOwner(source.TextOrder, owner.TextSourceOrdinal, owner.TextObjectOrdinal,
+					owner.TextNamespace, owner.TextRelative, owner.TextIndex) || owner.Slot != 1 || owners[owner.TextObjectOrdinal] {
+				return nil, contextError("readonly FUNCDATA metadata source/TEXT/slot owner changed")
+			}
+			ref, found := generatedFuncdataSlot(member.Texts[owner.TextObjectOrdinal], owner.Slot)
+			if !found || !generatedFuncdataReference(metadata.Definition, ref) {
+				return nil, contextError("readonly FUNCDATA metadata lost its actual auxiliary identity")
+			}
+			owners[owner.TextObjectOrdinal] = true
+		}
+		if err := validateGeneratedFuncdataReferences(member, metadata.Definition, owners); err != nil {
+			return nil, err
+		}
+		definitions = append(definitions, metadata.Definition)
+	}
+	return definitions, nil
+}
+
+func readonlyMetadataTextOwner(order []ASMSourceText, source, object int, namespace TextSymbolNamespace, relative, index uint32) bool {
+	if source < 0 || source >= len(order) {
+		return false
+	}
+	text := order[source]
+	return text.ObjectOrdinal == object && text.Namespace == namespace && text.Relative == relative && text.Index == index
+}
+
+func readonlyMetadataStatement(used map[int]bool, statement, textSource int) bool {
+	if statement <= textSource || statement >= symbolLimit || used[statement] {
+		return false
+	}
+	used[statement] = true
+	return true
+}
+
+func readonlyGeneratedFloatPools(source ASMDataSourceObservation, target string, statements map[int]bool) ([]ASMDataDefinition, error) {
+	if len(source.GeneratedFloatPools) == 0 {
+		return nil, nil
+	}
+	member := source.Expanded
+	// Reconstruct only the existing relocation-owner inventory. Neither an
+	// assembler nor a new source parser is needed by this pure image planner.
+	replay := make([]ASMGeneratedFloatPool, len(source.GeneratedFloatPools))
+	uses := make([][]asmGeneratedFloatPoolUse, len(member.Texts))
+	byName := make(map[string]int, len(replay))
+	var definitions []ASMDataDefinition
+	totalOwners := 0
+	for ordinal, pool := range source.GeneratedFloatPools {
+		if len(pool.Owners) == 0 || len(pool.Owners) > symbolLimit-totalOwners {
+			return nil, contextError("readonly float-pool metadata has no bounded actual source owners")
+		}
+		totalOwners += len(pool.Owners)
+		if _, duplicate := byName[pool.Definition.Name]; duplicate {
+			return nil, contextError("readonly float-pool metadata repeats a definition")
+		}
+		byName[pool.Definition.Name] = ordinal
+		replay[ordinal].Definition = pool.Definition
+		for _, owner := range pool.Owners {
+			form, known := asmGeneratedFloatPoolForms[owner.Opcode]
+			if !known || !readonlyMetadataStatement(statements, owner.StatementOrdinal, owner.TextSourceOrdinal) ||
+				!readonlyMetadataTextOwner(source.TextOrder, owner.TextSourceOrdinal, owner.TextObjectOrdinal,
+					owner.TextNamespace, owner.TextRelative, owner.TextIndex) {
+				return nil, contextError("readonly float-pool metadata source/TEXT/opcode owner changed")
+			}
+			value := math.Float64frombits(owner.SourceFloat64Bits)
+			if math.IsNaN(value) || math.IsInf(value, 0) {
+				return nil, contextError("readonly float-pool original FCONST is not a finite float64 token")
+			}
+			bits := owner.SourceFloat64Bits
+			if form.width == 4 {
+				bits = uint64(math.Float32bits(float32(value)))
+			}
+			name := fmt.Sprintf("$f%d.%0*x", form.width*8, form.width*2, bits)
+			if pool.Definition.Name != name || !validGeneratedFloatPoolDefinition(pool.Definition, form.width, bits, target) {
+				return nil, contextError("readonly float-pool metadata IEEE/name/namespace/attributes/hash changed")
+			}
+			text := member.Texts[owner.TextObjectOrdinal]
+			if owner.RelocationOrdinal < 0 || owner.RelocationOrdinal >= len(text.Relocations) ||
+				!reflect.DeepEqual(owner.Relocation, text.Relocations[owner.RelocationOrdinal]) {
+				return nil, contextError("readonly float-pool metadata lost its actual relocation identity")
+			}
+			uses[owner.TextObjectOrdinal] = append(uses[owner.TextObjectOrdinal], asmGeneratedFloatPoolUse{owner: owner, pool: ordinal})
+		}
+		definitions = append(definitions, pool.Definition)
+	}
+	for _, textUses := range uses {
+		sort.Slice(textUses, func(i, j int) bool { return textUses[i].owner.StatementOrdinal < textUses[j].owner.StatementOrdinal })
+	}
+	if err := joinGeneratedFloatPoolOwners(member, replay, byName, uses, target); err != nil {
+		return nil, err
+	}
+	if !sameGeneratedFloatPools(source.GeneratedFloatPools, replay) {
+		return nil, contextError("readonly float-pool complete relocation owners differ")
+	}
+	return definitions, nil
+}
diff --git a/internal/gostaticstorage/readonly_literal_generated_metadata_go127_test.go b/internal/gostaticstorage/readonly_literal_generated_metadata_go127_test.go
new file mode 100644
index 000000000..00f8f070f
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_generated_metadata_go127_test.go
@@ -0,0 +1,193 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type readonlyMixedMetadataCase struct {
+	name                          string
+	floatPool, funcdata, ordinary bool
+}
+
+func readonlyMixedMetadataSource(test readonlyMixedMetadataCase) []byte {
+	var source strings.Builder
+	source.WriteString("TEXT ·Entry(SB),4,$0-0\n")
+	if test.funcdata {
+		source.WriteString("FUNCDATA $1,no_pointers_stackmap(SB)\n")
+	}
+	if test.floatPool {
+		source.WriteString("MOVSS $-0.0,X0\nADDSD $1.25,X0\n")
+	}
+	if test.ordinary {
+		source.WriteString("MOVL ordinary<>(SB),AX\n")
+	}
+	source.WriteString("RET\n")
+	if test.ordinary {
+		source.WriteString("DATA ordinary<>+2(SB)/2,$0xbeef\nGLOBL ordinary<>(SB),8,$16\n")
+	}
+	return []byte(source.String())
+}
+
+// These are actual complete compiler archives plus two independently assembled
+// objects. Stock Go readers preserve all DATA/TEXT/auxiliary records; neither
+// metadata nor the returned initializer plan is SDK or native-entry authority.
+func readonlyMixedMetadataActual(t *testing.T, directory, driver, dataOracle, textOracle, target string, builtin []byte, test readonlyMixedMetadataCase) *SDKASMDataObservation {
+	t.Helper()
+	env := fixtureEnv(t, target)
+	consumer := filepath.Join(directory, strings.ReplaceAll(target, "/", "-")+"-"+test.name)
+	if err := os.Mkdir(consumer, 0700); err != nil {
+		t.Fatal(err)
+	}
+	pkg := fixtureModule + "/" + filepath.Base(consumer)
+	source := readonlyMixedMetadataSource(test)
+	expanded := bytes.ReplaceAll(source, []byte(","), []byte(", "))
+	declarations := []byte("package mixedfixture\nfunc Entry()\n")
+	for name, data := range map[string][]byte{"mixed.go": declarations, "mixed.s": source, "expanded.asm": expanded} {
+		if err := os.WriteFile(filepath.Join(consumer, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	selection := run(t, driver, consumer, env, "list", "-json", "-compiled", "-export", "-mod=readonly", "-gcflags=-std", "-asmflags=-std", ".")
+	var selected struct {
+		ImportPath, Export string
+		SFiles             []string
+		Standard           bool
+	}
+	if json.Unmarshal(selection, &selected) != nil || selected.ImportPath != pkg || selected.Standard ||
+		!reflect.DeepEqual(selected.SFiles, []string{"mixed.s"}) {
+		t.Fatal("actual complete mixed-metadata source inventory differs")
+	}
+	archive, err := os.ReadFile(selected.Export)
+	if err != nil {
+		t.Fatal(err)
+	}
+	data := run(t, dataOracle, consumer, env, selected.Export)
+	text := run(t, textOracle, consumer, env, selected.Export)
+	actual := asmGeneratedFloatPoolOriginal(t, data, text)
+	if len(actual) != 3 || len(actual[2].Texts) != 1 || actual[2].Texts[0].Name != pkg+".Entry" {
+		t.Fatal("the original mixed-metadata archive has an incomplete source/TEXT inventory")
+	}
+	request := SDKASMDataObservationRequest{PackagePath: pkg, Target: target, Archive: archive, BuiltinSource: builtin}
+	input := SDKASMDataSource{Name: "mixed.s", Original: source, Expanded: expanded}
+	artifacts := map[string][]byte{"source-mixed.s": source, "expanded.asm": expanded, "source-mixed.go": declarations,
+		"original.a": archive, "selection.json": selection, "data-sdk.json": data, "text-sdk.json": text}
+	for _, role := range []string{"original", "expanded"} {
+		file := "mixed.s"
+		if role == "expanded" {
+			file = "expanded.asm"
+		}
+		arguments := []string{"tool", "asm", "-std"}
+		if target == "darwin/amd64" {
+			arguments = append(arguments, "-shared")
+		}
+		arguments = append(arguments, "-p", pkg, "-o", role+".o", file)
+		run(t, driver, consumer, env, arguments...)
+		object, err := os.ReadFile(filepath.Join(consumer, role+".o"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if role == "original" {
+			input.OriginalObject = object
+		} else {
+			input.ExpandedObject = object
+		}
+		artifacts[role+".o"] = object
+		artifacts[role+"-data-sdk.json"] = run(t, dataOracle, consumer, env, role+".o")
+		artifacts[role+"-text-sdk.json"] = run(t, textOracle, consumer, env, role+".o")
+		members := asmGeneratedFloatPoolOriginal(t, artifacts[role+"-data-sdk.json"], artifacts[role+"-text-sdk.json"])
+		if len(members) != 1 || !sameASMDataObjects(members[0], actual[2]) {
+			t.Fatal("complete independently assembled DATA/TEXT/auxiliary records differ", role)
+		}
+	}
+	request.Sources = []SDKASMDataSource{input}
+	observation, err := ObserveX86SDKASMData(request)
+	if err != nil || observation == nil || !reflect.DeepEqual(observation.Members, actual) || len(observation.Sources) != 1 {
+		t.Fatal("the complete actual mixed source/object observation differs", err)
+	}
+	observed := observation.Sources[0]
+	expectedCounts := [3]int{}
+	if test.floatPool {
+		expectedCounts[0] = 2
+	}
+	if test.funcdata {
+		expectedCounts[1] = 1
+	}
+	if test.ordinary {
+		expectedCounts[2] = 1
+	}
+	if [3]int{len(observed.GeneratedFloatPools), len(observed.GeneratedFuncdata), len(observed.ExpandedLayouts)} != expectedCounts {
+		t.Fatal("ordinary layouts and actual independent metadata classes were confused")
+	}
+	if test.floatPool {
+		for _, pool := range observed.GeneratedFloatPools {
+			if len(pool.Owners) != 1 || pool.Definition.Name != "$f32.80000000" && pool.Definition.Name != "$f64.3ff4000000000000" {
+				t.Fatal("the actual two-width FCONST metadata lost its complete owner", pool)
+			}
+		}
+	}
+	if test.funcdata && (len(observed.GeneratedFuncdata[0].Owners) != 1 || observed.GeneratedFuncdata[0].Owners[0].Slot != 1) {
+		t.Fatal("actual reserved FUNCDATA lost its source/auxiliary owner")
+	}
+	retainTextArtifact(t, target, "readonly-mixed-"+test.name, artifacts)
+	return observation
+}
+
+func TestReadonlyLiteralDataActualGoMixedGeneratedMetadata(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	dataOracle := officialReaderForSource(t, driver, sdkASMDataReaderSource)
+	textOracle := officialReaderForSource(t, driver, sdkTextReaderSource)
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(driver)), builtinSourceRole))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"linux/386", "linux/amd64", "darwin/amd64", "windows/386", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			for _, test := range []readonlyMixedMetadataCase{
+				{"float-pool", true, false, true},
+				{"funcdata", false, true, true},
+				{"both", true, true, true},
+				{"metadata-only", true, true, false},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					observation := readonlyMixedMetadataActual(t, directory, driver, dataOracle, textOracle, target, builtin, test)
+					t.Run("ordinary-only-initializer", func(t *testing.T) {
+						images, err := ReadonlyLiteralDataInitializers(observation)
+						if !test.ordinary {
+							if !errors.Is(err, ErrContext) || images != nil {
+								t.Fatal("metadata-only source acquired an initialized image", images, err)
+							}
+							return
+						}
+						expected := make([]byte, 16)
+						expected[2], expected[3] = 0xef, 0xbe
+						if err != nil || len(images) != 1 || images[0].Definition.Name != "ordinary" ||
+							images[0].Definition.Namespace != TextSymbolSelf || images[0].Definition.ABI != 65535 ||
+							!bytes.Equal(images[0].Initial, expected) || len(images[0].Fragments) != 1 {
+							t.Fatal("verified metadata blocked ordinary RODATA or entered the initializer directory", images, err)
+						}
+						before := readonlyLiteralClone(t, observation)
+						images[0].Initial[2] = 0
+						images[0].Definition.Data[2] = 0
+						if !reflect.DeepEqual(before, observation) {
+							t.Fatal("ordinary image mutated a complete metadata/source/object observation")
+						}
+					})
+					if test.name == "both" {
+						t.Run("complete-metadata-guards", func(t *testing.T) {
+							readonlyMixedMetadataGuards(t, observation)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/readonly_literal_generated_metadata_guards_go127_test.go b/internal/gostaticstorage/readonly_literal_generated_metadata_guards_go127_test.go
new file mode 100644
index 000000000..ead9e72a7
--- /dev/null
+++ b/internal/gostaticstorage/readonly_literal_generated_metadata_guards_go127_test.go
@@ -0,0 +1,218 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"errors"
+	"testing"
+)
+
+func readonlyMixedMetadataMembers(observation *SDKASMDataObservation, change func(*ASMDataMember)) {
+	for _, member := range []*ASMDataMember{&observation.Members[2], &observation.Sources[0].Original, &observation.Sources[0].Expanded} {
+		change(member)
+	}
+}
+
+func readonlyMixedMetadataPoolDefinition(observation *SDKASMDataObservation, change func(*ASMDataDefinition)) {
+	readonlyMixedMetadataDefinition(observation, &observation.Sources[0].GeneratedFloatPools[0].Definition, change)
+}
+
+func readonlyMixedMetadataDefinition(observation *SDKASMDataObservation, definition *ASMDataDefinition, change func(*ASMDataDefinition)) {
+	index := definition.Index
+	readonlyMixedMetadataMembers(observation, func(member *ASMDataMember) {
+		for ordinal := range member.Definitions {
+			if member.Definitions[ordinal].Index == index {
+				change(&member.Definitions[ordinal])
+			}
+		}
+	})
+	change(definition)
+}
+
+func readonlyMixedMetadataUnknown(observation *SDKASMDataObservation, name string, forged bool) {
+	definition := observation.Sources[0].GeneratedFloatPools[0].Definition
+	definition.Name = name
+	definition.Index, definition.Relative = 100000, 100000
+	readonlyMixedMetadataMembers(observation, func(member *ASMDataMember) {
+		member.Definitions = append(member.Definitions, definition)
+	})
+	if forged {
+		pool := observation.Sources[0].GeneratedFloatPools[0]
+		pool.Definition = definition
+		observation.Sources[0].GeneratedFloatPools = append(observation.Sources[0].GeneratedFloatPools, pool)
+	}
+}
+
+func readonlyMixedMetadataGuards(t *testing.T, original *SDKASMDataObservation) {
+	t.Helper()
+	for name, change := range map[string]func(*SDKASMDataObservation){
+		"missing-pool-metadata": func(o *SDKASMDataObservation) { o.Sources[0].GeneratedFloatPools = nil },
+		"missing-FUNCDATA-metadata": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata = nil
+		},
+		"missing-all-metadata": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFloatPools, o.Sources[0].GeneratedFuncdata = nil, nil
+		},
+		"duplicate-pool": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFloatPools = append(o.Sources[0].GeneratedFloatPools, o.Sources[0].GeneratedFloatPools[0])
+		},
+		"duplicate-FUNCDATA": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata = append(o.Sources[0].GeneratedFuncdata, o.Sources[0].GeneratedFuncdata[0])
+		},
+		"missing-pool-owner": func(o *SDKASMDataObservation) { o.Sources[0].GeneratedFloatPools[0].Owners = nil },
+		"missing-FUNCDATA-owner": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata[0].Owners = nil
+		},
+		"duplicate-pool-owner": func(o *SDKASMDataObservation) {
+			pool := &o.Sources[0].GeneratedFloatPools[0]
+			pool.Owners = append(pool.Owners, pool.Owners[0])
+		},
+		"duplicate-FUNCDATA-owner": func(o *SDKASMDataObservation) {
+			metadata := &o.Sources[0].GeneratedFuncdata[0]
+			metadata.Owners = append(metadata.Owners, metadata.Owners[0])
+		},
+		"pool-is-ordinary-layout": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFloatPools[0].Definition = o.Sources[0].ExpandedLayouts[0].Definition
+		},
+		"FUNCDATA-is-ordinary-layout": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata[0].Definition = o.Sources[0].ExpandedLayouts[0].Definition
+		},
+		"missing-source-TEXT": func(o *SDKASMDataObservation) { o.Sources[0].TextOrder = nil },
+		"pool-definition-name": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFloatPools[0].Definition.Name += "forged"
+		},
+		"pool-definition-index": func(o *SDKASMDataObservation) { o.Sources[0].GeneratedFloatPools[0].Definition.Index++ },
+		"pool-definition-namespace": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFloatPools[0].Definition.Namespace = TextSymbolSelf
+		},
+		"pool-IEEE": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Data[0] ^= 1 })
+		},
+		"pool-IEEE-and-matching-hash": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) {
+				definition.Data[0] ^= 1
+				definition.Hash[0] ^= 1
+			})
+		},
+		"pool-local-role": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Flags = 0 })
+		},
+		"pool-whole-hash": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Hash[0] ^= 1 })
+		},
+		"pool-whole-width": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Size = 8 })
+		},
+		"pool-whole-alignment": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Align = 8 })
+		},
+		"pool-whole-ABI": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.ABI = 1 })
+		},
+		"pool-whole-kind": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Kind = 5 })
+		},
+		"pool-whole-flags2": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataPoolDefinition(o, func(definition *ASMDataDefinition) { definition.Flags2 = 1 })
+		},
+		"unknown-named-definition": func(o *SDKASMDataObservation) { readonlyMixedMetadataUnknown(o, "uncovered", false) },
+		"unknown-float-prefix": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataUnknown(o, "$f32.00000001", false)
+		},
+		"unknown-FUNCDATA-prefix": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataUnknown(o, "gclocals·unproved", false)
+		},
+		"unknown-definition-with-forged-owner": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataUnknown(o, "$f32.80000000", true)
+		},
+		"extra-pool-TEXT-reference": func(o *SDKASMDataObservation) {
+			relocation := o.Sources[0].GeneratedFloatPools[0].Owners[0].Relocation
+			readonlyMixedMetadataMembers(o, func(member *ASMDataMember) {
+				member.Texts[0].Relocations = append(member.Texts[0].Relocations, relocation)
+			})
+		},
+		"extra-pool-auxiliary": func(o *SDKASMDataObservation) {
+			ref := o.Sources[0].GeneratedFloatPools[0].Owners[0].Relocation.Target
+			readonlyMixedMetadataMembers(o, func(member *ASMDataMember) {
+				member.Texts[0].Auxiliary = append(member.Texts[0].Auxiliary, TextAuxiliary{Type: 2, Target: ref})
+			})
+		},
+		"FUNCDATA-invalid-payload": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata[0].Definition.Data[0] ^= 1
+		},
+		"FUNCDATA-invalid-hash": func(o *SDKASMDataObservation) {
+			o.Sources[0].GeneratedFuncdata[0].Definition.Hash[0] ^= 1
+		},
+		"FUNCDATA-whole-payload": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataDefinition(o, &o.Sources[0].GeneratedFuncdata[0].Definition,
+				func(definition *ASMDataDefinition) { definition.Data[0] ^= 1 })
+		},
+		"FUNCDATA-whole-hash": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataDefinition(o, &o.Sources[0].GeneratedFuncdata[0].Definition,
+				func(definition *ASMDataDefinition) { definition.Hash[0] ^= 1 })
+		},
+		"FUNCDATA-whole-role": func(o *SDKASMDataObservation) {
+			readonlyMixedMetadataDefinition(o, &o.Sources[0].GeneratedFuncdata[0].Definition,
+				func(definition *ASMDataDefinition) { definition.Flags = 0 })
+		},
+		"FUNCDATA-extra-TEXT-reference": func(o *SDKASMDataObservation) {
+			definition := o.Sources[0].GeneratedFuncdata[0].Definition
+			readonlyMixedMetadataMembers(o, func(member *ASMDataMember) {
+				member.Texts[0].Relocations = append(member.Texts[0].Relocations, TextRelocation{Offset: 0, Size: 4, Type: 1,
+					Target: TextReference{PackageIndex: 2147483645, SymbolIndex: definition.Relative, Name: definition.Name, ABIKnown: true}})
+			})
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			observation := readonlyLiteralClone(t, original)
+			change(observation)
+			if images, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) || images != nil {
+				t.Fatal("unproved or forged metadata hid an uncovered named DATA definition", images, err)
+			}
+		})
+	}
+	readonlyMixedMetadataOwnerGuards(t, original)
+}
+
+func readonlyMixedMetadataOwnerGuards(t *testing.T, original *SDKASMDataObservation) {
+	t.Helper()
+	for name, change := range map[string]func(*ASMGeneratedFloatPoolOwner){
+		"statement":          func(owner *ASMGeneratedFloatPoolOwner) { owner.StatementOrdinal = -1 },
+		"source-TEXT":        func(owner *ASMGeneratedFloatPoolOwner) { owner.TextSourceOrdinal++ },
+		"object-TEXT":        func(owner *ASMGeneratedFloatPoolOwner) { owner.TextObjectOrdinal++ },
+		"TEXT-namespace":     func(owner *ASMGeneratedFloatPoolOwner) { owner.TextNamespace = TextSymbolSelf },
+		"TEXT-relative":      func(owner *ASMGeneratedFloatPoolOwner) { owner.TextRelative++ },
+		"TEXT-index":         func(owner *ASMGeneratedFloatPoolOwner) { owner.TextIndex++ },
+		"non-FCONST-opcode":  func(owner *ASMGeneratedFloatPoolOwner) { owner.Opcode = "MOVL" },
+		"original-IEEE":      func(owner *ASMGeneratedFloatPoolOwner) { owner.SourceFloat64Bits = 0 },
+		"relocation-ordinal": func(owner *ASMGeneratedFloatPoolOwner) { owner.RelocationOrdinal++ },
+		"relocation-offset":  func(owner *ASMGeneratedFloatPoolOwner) { owner.Relocation.Offset++ },
+		"relocation-width":   func(owner *ASMGeneratedFloatPoolOwner) { owner.Relocation.Size = 1 },
+		"relocation-target":  func(owner *ASMGeneratedFloatPoolOwner) { owner.Relocation.Target.SymbolIndex++ },
+	} {
+		t.Run("pool-owner-"+name, func(t *testing.T) {
+			observation := readonlyLiteralClone(t, original)
+			change(&observation.Sources[0].GeneratedFloatPools[0].Owners[0])
+			if images, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) || images != nil {
+				t.Fatal("forged pool source/TEXT/relocation owner bypassed complete inventory", images, err)
+			}
+		})
+	}
+	for name, change := range map[string]func(*ASMGeneratedFuncdataOwner){
+		"statement":      func(owner *ASMGeneratedFuncdataOwner) { owner.StatementOrdinal = -1 },
+		"source-TEXT":    func(owner *ASMGeneratedFuncdataOwner) { owner.TextSourceOrdinal++ },
+		"object-TEXT":    func(owner *ASMGeneratedFuncdataOwner) { owner.TextObjectOrdinal++ },
+		"TEXT-namespace": func(owner *ASMGeneratedFuncdataOwner) { owner.TextNamespace = TextSymbolSelf },
+		"TEXT-relative":  func(owner *ASMGeneratedFuncdataOwner) { owner.TextRelative++ },
+		"TEXT-index":     func(owner *ASMGeneratedFuncdataOwner) { owner.TextIndex++ },
+		"auxiliary-slot": func(owner *ASMGeneratedFuncdataOwner) { owner.Slot = 0 },
+	} {
+		t.Run("FUNCDATA-owner-"+name, func(t *testing.T) {
+			observation := readonlyLiteralClone(t, original)
+			change(&observation.Sources[0].GeneratedFuncdata[0].Owners[0])
+			if images, err := ReadonlyLiteralDataInitializers(observation); !errors.Is(err, ErrContext) || images != nil {
+				t.Fatal("forged FUNCDATA source/TEXT/auxiliary owner bypassed complete inventory", images, err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/runtime_body_bound_go127_test.go b/internal/gostaticstorage/runtime_body_bound_go127_test.go
new file mode 100644
index 000000000..fcdd2f494
--- /dev/null
+++ b/internal/gostaticstorage/runtime_body_bound_go127_test.go
@@ -0,0 +1,167 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This is an offline full-body parse of actual SDK compiler output, not an
+// SDK/frame/source certificate. All referenced archives keep their separate
+// metadata-only role; the selected compiler member retains full TEXT/DATA.
+func TestGoSDKRuntimeFullCompilerBody(t *testing.T) {
+	directory, compiler, _ := fixture(t)
+	// Keep the original SDK oracle output bounded: it visits every original
+	// definition and payload, returning counts rather than megabytes of JSON
+	// names. Existing small-fixture tests compare individual complete records.
+	oracleSource := strings.Replace(sdkIndexedCountsReaderSource, "Counts [5]int", "Counts [5]int\nDataBytes, Relocations, AuxRecords int\nKinds, AuxKinds map[uint8]int", 1)
+	oracleSource = strings.Replace(oracleSource, "result = append(result, member)", `
+		if entry.Type == archive.EntryGoObj {
+			data := make([]byte, entry.Obj.Size)
+			if _, err := f.ReadAt(data, entry.Obj.Offset); err != nil { panic(err) }
+			r := goobj.NewReaderFromBytes(data, false)
+			member.Kinds = make(map[uint8]int)
+			member.AuxKinds = make(map[uint8]int)
+			for i := 0; i < r.NSym()+r.NHashed64def()+r.NHasheddef()+r.NNonpkgdef(); i++ {
+				member.DataBytes += len(r.Data(uint32(i)))
+				member.Relocations += r.NReloc(uint32(i))
+				member.Kinds[r.Sym(uint32(i)).Type()]++
+				for j := 0; j < r.NAux(uint32(i)); j++ {
+					member.AuxRecords++
+					member.AuxKinds[r.Aux(uint32(i), j).Type()]++
+				}
+			}
+		}
+		result = append(result, member)`, 1)
+	oracle := officialReaderForSource(t, compiler, oracleSource)
+	builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(compiler)), "src/cmd/internal/goobj/builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			raw := run(t, compiler, directory, env, "list", "-deps", "-json", "-compiled", "-export", "-mod=readonly", "runtime")
+			decoder := json.NewDecoder(bytes.NewReader(raw))
+			referenced := make(map[string]SDKReferencedArchive)
+			var archive []byte
+			for {
+				var selected struct {
+					ImportPath, Export string
+					SFiles             []string
+				}
+				if err := decoder.Decode(&selected); err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				if selected.ImportPath == "unsafe" {
+					continue
+				}
+				data, err := os.ReadFile(selected.Export)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if selected.ImportPath == "runtime" {
+					archive = data
+				} else {
+					referenced[selected.ImportPath] = SDKReferencedArchive{PackagePath: selected.ImportPath, Sources: selected.SFiles, Archive: data}
+				}
+			}
+			if len(archive) == 0 {
+				t.Fatal("actual SDK runtime compiler archive was not selected")
+			}
+			members, err := archiveMembers(archive)
+			if err != nil || len(members) < 2 || members[1].name != "_go_.o" {
+				t.Fatal("actual compiler member inventory", err)
+			}
+			filename := filepath.Join(t.TempDir(), "runtime.a")
+			if err := os.WriteFile(filename, archive, 0600); err != nil {
+				t.Fatal(err)
+			}
+			var expected []struct {
+				Name                               string
+				Counts                             [5]int
+				DataBytes, Relocations, AuxRecords int
+				Kinds, AuxKinds                    map[uint8]int
+			}
+			if err := json.Unmarshal(run(t, oracle, directory, env, filename), &expected); err != nil || len(expected) != len(members) {
+				t.Fatal("original SDK full definition oracle", err)
+			}
+			symbols, err := sdkReferencedArchiveSymbols(referenced, target)
+			if err != nil {
+				t.Fatal("actual complete referenced namespaces", err)
+			}
+			member, err := observeASMDataObject(members[1].data, builtin, target, sdkCompilerObjectFlags(target), symbols)
+			if err != nil {
+				t.Fatal("actual SDK compiler full TEXT/DATA/reloc body rejected", err)
+			}
+			want := expected[1]
+			// Read Aux through the checked full-body structure and its N+1
+			// indexes, without inventing a public DATA/Aux observation role.
+			body, err := sdkObjectBody(members[1].data, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			object, err := checkedSDKObject(body, sdkCompilerObjectFlags(target), false)
+			if err != nil {
+				t.Fatal("actual SDK Aux structure was not completely checked", err)
+			}
+			auxBlock := object.block(15)
+			auxRecords := 0
+			auxKinds := make(map[uint8]int)
+			for index := 0; index < object.count; index++ {
+				start, end := object.indices[1][index], object.indices[1][index+1]
+				for ordinal := start; ordinal < end; ordinal++ {
+					auxRecords++
+					auxKinds[auxBlock[int(ordinal)*9]]++
+				}
+			}
+			if auxRecords != want.AuxRecords || len(auxKinds) != len(want.AuxKinds) {
+				t.Fatal("complete compiler Aux inventory differs from original SDK reader", auxRecords, auxKinds, want)
+			}
+			for kind, count := range want.AuxKinds {
+				if auxKinds[kind] != count {
+					t.Fatal("compiler Aux kind inventory differs", kind, count, auxKinds[kind])
+				}
+			}
+			count := want.Counts[0] + want.Counts[1] + want.Counts[2] + want.Counts[3]
+			if len(member.Texts)+len(member.Definitions) != count {
+				t.Fatal("full compiler body discarded definitions", len(member.Texts), len(member.Definitions), count)
+			}
+			seen := make([]bool, count)
+			kinds := make(map[uint8]int)
+			bytes, relocations := 0, 0
+			check := func(index uint32, kind uint8, size, relocs int) {
+				if int(index) >= count || seen[index] {
+					t.Fatal("compiler definition index escaped/duplicated actual original inventory", index)
+				}
+				seen[index] = true
+				kinds[kind]++
+				bytes += size
+				relocations += relocs
+			}
+			for _, text := range member.Texts {
+				check(text.Index, text.Kind, len(text.Code), len(text.Relocations))
+			}
+			for _, data := range member.Definitions {
+				check(data.Index, data.Kind, len(data.Data), len(data.Relocations))
+			}
+			if bytes != want.DataBytes || relocations != want.Relocations || len(kinds) != len(want.Kinds) {
+				t.Fatal("full compiler payload differs from independent SDK reader", bytes, relocations, want)
+			}
+			for kind, count := range want.Kinds {
+				if kinds[kind] != count {
+					t.Fatal("compiler full-body symbol kind inventory differs", kind, count, kinds[kind])
+				}
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/sdk.go b/internal/gostaticstorage/sdk.go
new file mode 100644
index 000000000..550db901e
--- /dev/null
+++ b/internal/gostaticstorage/sdk.go
@@ -0,0 +1,217 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+const SDKCPUProtocol = "actual_go_sdk_cpu_numeric_storage_prototype_v1"
+
+// gcToolchain.asm (gc.go:416) maps each selected SFile, in order, to its
+// actual .o member. Bind that SDK rule as well as the observed asm route; the
+// filename suffix by itself is not a source-to-object certificate.
+var sdkCPUFormatSources = map[string]string{
+	"src/cmd/go/internal/work/gc.go":     "13359b8707e78300e8e0ec880b9a8d1af4bafdf32140b56df5f041a52fbc1325",
+	"src/cmd/go/internal/work/init.go":   "cd86d5c8fecb90d9db58ed3c98d0869ff6b5220c445025051d366818859a0963",
+	"src/internal/platform/supported.go": "b2ee50eb1857a0dfd98cbfbd0c8a6c78f3a3e334cfc56557a24c8517681bc442",
+	"src/cmd/compile/internal/gc/obj.go": "dfed5fe0bee6e0dab23e3fd3c1327c12273895cf8141ad4b896cef8bc73269f2",
+	"src/cmd/link/internal/ld/go.go":     "1035a2c6ca034d8a47ae6ee3a4be530e0b32170120d527d75fc46df29be68c84",
+}
+
+// CaptureSDKCPU observes only the original selected Go 1.27.1 internal/cpu
+// owner. Standard or Module=nil alone are never evidence of SDK ownership.
+// This separate producer does not grant SB/native-entry/translation permission.
+func CaptureSDKCPU(ctx context.Context, request Request) (*Observation, error) {
+	return capture(ctx, request, true)
+}
+
+func sdkCPUArguments() []string {
+	return []string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "internal/cpu"}
+}
+
+func sdkCPUTarget(target string) bool {
+	if X86SDKTarget(target) {
+		return true
+	}
+	switch target {
+	case "linux/arm", "linux/arm64", "js/wasm":
+		return true
+	}
+	return false
+}
+
+func sdkCPUProfile(target string) map[string]string {
+	profile := map[string]string{"GO386": "", "GOARM": "", "GOARM64": "", "GOWASM": ""}
+	switch target {
+	case "linux/386", "windows/386":
+		profile["GO386"] = "sse2"
+	case "linux/arm":
+		profile["GOARM"] = "7,hardfloat"
+	case "linux/arm64":
+		profile["GOARM64"] = "v8.0"
+	}
+	return profile
+}
+
+// Original files, including ignored/test/assembly files, are pinned to the
+// selected stock SDK, not inferred from the directory or package spelling.
+// Only this bounded owner is supported; this is not a general stdlib loader.
+var sdkCPUSources = map[string]string{
+	"cpu.go":                   "9af4310772f84d92f2a98e9f16e6553fdbefc4ce6286e0f508121e6c8819faf7",
+	"cpu.s":                    "39594514f3cb069cecfc6782f81385cbb3570a2ca1b0f3028db1dfa75fd5837e",
+	"cpu_arm.go":               "909650fdeab24972e89f702b663732297e00f12078339defb3da4b9e2d6e6159",
+	"cpu_arm64.go":             "5b156522fb27d47992d4ab013779c6d24c87e002a1a83550042cbd1d1d641538",
+	"cpu_arm64.s":              "90803105802e7e92084aeabb2985b3b770ebfe9ab045e997790ade7eabe3a6b4",
+	"cpu_arm64_android.go":     "8b7f051aa72bd245b71fe2e2462069ae05e30df5b104b61875d9f207be0e9913",
+	"cpu_arm64_darwin.go":      "83d95025242aca57e8258aa1fbb1c84a976717db1977c5200c5e8c41daecb099",
+	"cpu_arm64_freebsd.go":     "a128fa45e38c0f2975d1eeb4287463361fe2ceabb1060a04b1aae8e01719757e",
+	"cpu_arm64_hwcap.go":       "4e38722a3a8970e66ba2aa9aaf4eded7a46d8e57443b9fed16e05c56f23994b2",
+	"cpu_arm64_linux.go":       "92a9f87d05a0c080cddd9f4ea8af606e57f43d1fa5bd48ce7db2048b693402bf",
+	"cpu_arm64_openbsd.go":     "06ade8fe6706a137cbcecc895b7af08b80a6a9e9e4b1e626060e36ec40d627dc",
+	"cpu_arm64_other.go":       "810f3fed4a62636bc78b5896eccdcc46ba78129b13f4fe200ffa7285042cf0ba",
+	"cpu_arm64_windows.go":     "cd0dd8a3102d59d039a6ff9f236c2e18d91c19424a873241f23d6270baddfa9b",
+	"cpu_darwin.go":            "5c9dafb5c15b5cb405520aa711230231111de33601eb732922991fe008ae2384",
+	"cpu_loong64.go":           "ee25ebaec6b9365bff35b6c7b19b93bc5848ec2ec5897e1d7a25362eeca30d62",
+	"cpu_loong64.s":            "b5ad39be941a89a31481d0321c36baf80ecc80ca91e8b0c0f668c7f18820aa03",
+	"cpu_loong64_hwcap.go":     "5a91f8bf23674f1e97869a50686ef2d25ce97d17f75399437f5eda65a4902374",
+	"cpu_loong64_linux.go":     "8c24d8a08fe921cca8ffa555bf2d186ad6d3c645345fe997fddb0da95f13f4ff",
+	"cpu_mips.go":              "e29c18ecf33b490fb974604d690007e9aaf1c4a6a4c253100405613d1f636e87",
+	"cpu_mips64x.go":           "6ed64689241f6dbd3f79975a6c073f541045c62f5e7b9cafea7a8f4f0663e5bc",
+	"cpu_mipsle.go":            "e29c18ecf33b490fb974604d690007e9aaf1c4a6a4c253100405613d1f636e87",
+	"cpu_no_name.go":           "8215f72c7d9df7b7b3b53f1d6a5df311816e57cf6e5a06f21f7be50097ca79cc",
+	"cpu_ppc64x.go":            "5a7a1ceaf9b5f43addcdddb9ea5e8b430cac94d7e27fbf63962cceb4836f190d",
+	"cpu_ppc64x_aix.go":        "9f25df3971d54401d69de9e289946837f34a0be07a4263f94a252938478e23ca",
+	"cpu_ppc64x_linux.go":      "3e4ecc7e14ca82f767642fd2e48753d470ccb94c90c60dc5789664244530c129",
+	"cpu_ppc64x_other.go":      "cfd68633c11ced7cedcb93b1a71a4b02fe15835970ffbcc6dc78aeeadf0cc461",
+	"cpu_riscv64.go":           "d127180a261f61f485eb6448ab95575bd4a2b8a8f27ff60e6ad7ecc4d28ae3a3",
+	"cpu_riscv64_linux.go":     "26a08d2184a041108c255d1df2afe84c34a0c8798aa379356ad94f9af034ec1c",
+	"cpu_riscv64_other.go":     "9a8423e00805e1e95a1b3d6d218eaefe1442c1060d2ca9b51b9e18250ab62e96",
+	"cpu_s390x.go":             "da56587ea0fcdadfaeae80c57a96b6044260ef3965c9e893af18f655cb98cfac",
+	"cpu_s390x.s":              "c0a535dc06b98e14ee72277e800a61f412b58d0ca10db50780c498f40c4e41cc",
+	"cpu_s390x_test.go":        "1eb3d6fe149aae62104c6ebd9742e977916abad1d15e0c020c27090d24d5c2fb",
+	"cpu_test.go":              "2bbd71d724a24a17009b8b4b3b38b4057db57e5751697a8a7cbd58a88a0da7f0",
+	"cpu_wasm.go":              "22f9de4a9088c0dff432817ec066451b6e35aafecf2328063ed3d87c9883db56",
+	"cpu_windows.go":           "41eaf49d064a01655c3c7b7af2c5152151fd9d5462b7c708aad8d9c298abff3f",
+	"cpu_windows_test.go":      "6064d216bc3134406d4cd3d39eabfceac8c88292cfdfd6ae55a6783ddd7152b6",
+	"cpu_x86.go":               "395ce0d3004df63df376585519bc1b46303b206415c1915ab80b7bead155e26a",
+	"cpu_x86.s":                "ee4dca9916b29475e600d85f71f0dfd134496d153c77d20a643b139cc6e18fed",
+	"cpu_x86_darwin.go":        "036050c7259aa9282697b31603c3e5c8eb1ce234a1bbf26f9a326635a9645040",
+	"cpu_x86_netbsd.go":        "680675d11b22c292cd57425c573e206377238e2671ab5dc15f74307300a96eaf",
+	"cpu_x86_other.go":         "f24c84fc53bb2b8b067fdb462d6ac56594c371163527fba998f45c0f65c0c2f9",
+	"cpu_x86_test.go":          "2c6198efdfa141f25bbe984d59c38c40acb17bca3e1b90c5e23497cf1245df2a",
+	"datacache_unsupported.go": "1ee1b485113109cb851e7141c072ad31493414c963fd469f398fc0ea2b385a9c",
+	"datacache_x86.go":         "bbd50f64070d9497f062de27710a17d1aead867054d7dd9143bf063cdcd4fbea",
+	"datacache_x86_test.go":    "5b6c2963fed1a9fc4d260b6bd0ce83f921ab6571a7cc3b0dc6c6a2c2944f5256",
+	"export_test.go":           "6ae4785c9b482cfaadb490f2cb06a42cf5e9c796dcc8e3460f7f25fd41bd8dcd",
+	"export_x86_test.go":       "c9179504d2f6041efc0afe3a8a4bd56e66866fefce9dfb8377c47d074fde4455",
+}
+
+func sdkCPUSource(source map[string][]byte) error {
+	if len(source) != len(sdkCPUSources) {
+		return contextError("original SDK CPU source inventory differs")
+	}
+	for name, expected := range sdkCPUSources {
+		if digest(source[name]) != expected {
+			return contextError("original SDK CPU source bytes differ")
+		}
+	}
+	return nil
+}
+
+func sdkCPUPackages(report Report) (map[string]Package, error) {
+	root := report.Environment["GOROOT"]
+	dir := filepath.Join(root, "src", "internal", "cpu")
+	if !sdkCPUTarget(report.Target) || report.PackagePath != "internal/cpu" || report.CommandDirectory != dir ||
+		report.CommandBinary != filepath.Join(root, "bin", gotoolchain.HostExecutable("go")) || sdkCPUSource(report.Source) != nil {
+		return nil, contextError("unbound original SDK CPU owner/target/source role")
+	}
+	decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+	packages := make(map[string]Package)
+	unsafeSeen := false
+	for count := 0; ; count++ {
+		var pkg Package
+		err := decoder.Decode(&pkg)
+		if err == io.EOF {
+			break
+		}
+		if err != nil || count >= 2 || !pkg.Standard || !pkg.Goroot || pkg.Root != root || pkg.Module != nil ||
+			pkg.ForTest != "" || len(pkg.Error) != 0 && string(pkg.Error) != "null" || len(pkg.DepsErrors) != 0 {
+			return nil, contextError("incomplete, foreign or nonoriginal SDK selection")
+		}
+		if pkg.ImportPath == "unsafe" {
+			if unsafeSeen || pkg.Name != "unsafe" || pkg.Dir != filepath.Join(root, "src", "unsafe") ||
+				pkg.Export != "" || !reflect.DeepEqual(pkg.GoFiles, []string{"unsafe.go"}) || len(pkg.Imports) != 0 ||
+				len(pkg.ImportMap) != 0 || len(pkg.SFiles) != 0 {
+				return nil, contextError("unbound builtin SDK unsafe owner")
+			}
+			unsafeSeen = true
+			continue
+		}
+		if pkg.ImportPath != "internal/cpu" || pkg.Name != "cpu" || pkg.Dir != dir || packages[pkg.ImportPath].ImportPath != "" ||
+			!filepath.IsAbs(pkg.Export) || !within(report.Environment["GOCACHE"], pkg.Export) || len(pkg.GoFiles) == 0 ||
+			!reflect.DeepEqual(pkg.Imports, []string{"unsafe"}) || len(pkg.ImportMap) != 0 {
+			return nil, contextError("requested SDK CPU identity/import/archive differs")
+		}
+		for _, files := range [][]string{pkg.CgoFiles, pkg.EmbedFiles, pkg.EmbedPatterns, pkg.CFiles, pkg.CXXFiles, pkg.MFiles,
+			pkg.FFiles, pkg.SwigFiles, pkg.SwigCXXFiles, pkg.SysoFiles} {
+			if len(files) != 0 {
+				return nil, contextError("foreign/generated SDK role outside prototype")
+			}
+		}
+		seen := map[string]bool{}
+		expected := []string{}
+		for _, name := range pkg.GoFiles {
+			if filepath.Base(name) != name || !strings.HasSuffix(name, ".go") || seen[name] || report.Source[name] == nil {
+				return nil, contextError("unbound selected original SDK Go source")
+			}
+			seen[name] = true
+			expected = append(expected, filepath.Join(dir, name))
+		}
+		actual := append([]string(nil), pkg.CompiledGoFiles...)
+		for i, name := range actual {
+			if !filepath.IsAbs(name) {
+				if filepath.Base(name) != name {
+					return nil, contextError("unbound SDK compiled source")
+				}
+				actual[i] = filepath.Join(dir, name)
+			}
+		}
+		sort.Strings(expected)
+		sort.Strings(actual)
+		if !reflect.DeepEqual(expected, actual) {
+			return nil, contextError("SDK compiled source differs from originals")
+		}
+		for _, name := range pkg.SFiles {
+			if filepath.Base(name) != name || !strings.HasSuffix(name, ".s") || seen[name] || report.Source[name] == nil {
+				return nil, contextError("unbound selected original SDK assembly source")
+			}
+			seen[name] = true
+		}
+		pkg.CompiledGoFiles = actual
+		packages[pkg.ImportPath] = pkg
+	}
+	if !unsafeSeen || len(packages) != 1 {
+		return nil, contextError("missing exact SDK CPU dependency inventory")
+	}
+	return packages, nil
+}
+
+// Every member is decoded and structurally checked. Assembly is inventoried,
+// never used as a requested storage definition or a native entry certificate.
+func readSDKCPUArchive(data []byte, target string, sources []string) (map[string]dataRecord, error) {
+	if !sdkCPUTarget(target) {
+		return nil, contextError("unobserved SDK CPU archive target")
+	}
+	// Keep ABI/index identity until after structural validation. Go's Darwin
+	// compiler emits same-named ABI0/ABIInternal TEXT wrappers; neither can
+	// supply a Go variable. CPU assembly storage remains expressly forbidden.
+	return readSDKCompilerStorageArchive(data, target, sources, true)
+}
diff --git a/internal/gostaticstorage/sdk_archive_definition_inventory.go b/internal/gostaticstorage/sdk_archive_definition_inventory.go
new file mode 100644
index 000000000..add3702fa
--- /dev/null
+++ b/internal/gostaticstorage/sdk_archive_definition_inventory.go
@@ -0,0 +1,97 @@
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"sort"
+)
+
+// SDKArchiveDefinitionIdentity is an offline object-local record. In particular,
+// equal names, bytes or hashes do not select a linked winner or mint a role.
+type SDKArchiveDefinitionIdentity struct {
+	PackagePath, MemberName string
+	MemberOrdinal           int
+	Namespace               TextSymbolNamespace
+	Index                   uint32
+	Name                    string
+	ABI                     uint16
+	Kind, Flags, Flags2     uint8
+	Size, Align             uint32
+}
+
+// SDKArchiveDefinitionInventory retains every named definition in every actual
+// selected archive member. A live linker producer separately authenticates the
+// complete source graph, archives, tool route, command profile and linked image.
+func SDKArchiveDefinitionInventory(archives map[string]SDKReferencedArchive, target string) ([]SDKArchiveDefinitionIdentity, error) {
+	if !X86SDKTarget(target) {
+		return nil, contextError("definition inventory has an unobserved SDK target")
+	}
+	// Reuse the complete exact header/member/index grammar and shared aggregate
+	// archive bounds, rather than interpreting another permissive object format.
+	if _, err := sdkReferencedArchiveSymbols(archives, target); err != nil {
+		return nil, err
+	}
+	paths := make([]string, 0, len(archives))
+	for path := range archives {
+		paths = append(paths, path)
+	}
+	sort.Strings(paths)
+	var result []SDKArchiveDefinitionIdentity
+	for _, path := range paths {
+		members, err := archiveMembers(archives[path].Archive)
+		if err != nil {
+			return nil, err
+		}
+		for ordinal, member := range members[1:] {
+			flags, reader := sdkCompilerObjectFlags(target), sdkObjectBody
+			if ordinal != 0 {
+				flags, reader = flags|4, objectBody
+			}
+			body, err := reader(member.data, target)
+			if err != nil {
+				return nil, err
+			}
+			object, err := checkedSDKIndexedMetadata(body, flags, ordinal != 0)
+			if err != nil {
+				return nil, err
+			}
+			symbols, err := sdkMetadataDefinitionInventory(object)
+			if err != nil {
+				return nil, err
+			}
+			for _, symbol := range symbols {
+				if symbol.Name == "" || symbol.Namespace == TextSymbolNonpkgReference {
+					continue
+				}
+				result = append(result, SDKArchiveDefinitionIdentity{PackagePath: path,
+					MemberName: member.name, MemberOrdinal: ordinal + 1,
+					Namespace: symbol.Namespace, Index: symbol.Index, Name: symbol.Name,
+					ABI: symbol.ABI, Kind: symbol.Kind, Flags: symbol.Flags, Flags2: symbol.Flags2,
+					Size: symbol.Size, Align: symbol.Align})
+			}
+		}
+	}
+	return result, nil
+}
+
+// This is an ambiguity inventory, not storageSymbols(cpu): observing that a
+// namespace exists does not give its objects the pinned CPU/global role.
+func sdkMetadataDefinitionInventory(object *sdkIndexedMetadataObject) ([]indexedObjectSymbol, error) {
+	var result []indexedObjectSymbol
+	base := uint32(0)
+	for group, namespace := range []TextSymbolNamespace{TextSymbolSelf, TextSymbolHashed64, TextSymbolHashed, TextSymbolNonpkgDefinition} {
+		block := object.block(group + 3)
+		for offset := 0; offset < len(block); offset += 21 {
+			raw := block[offset : offset+21]
+			name, err := object.stringAt(raw)
+			if err != nil {
+				return nil, err
+			}
+			relative := uint32(offset / 21)
+			result = append(result, indexedObjectSymbol{Namespace: namespace, Relative: relative, Index: base + relative, Name: name,
+				ABI: binary.LittleEndian.Uint16(raw[8:]), Kind: raw[10], Flags: raw[11], Flags2: raw[12],
+				Size: binary.LittleEndian.Uint32(raw[13:]), Align: binary.LittleEndian.Uint32(raw[17:])})
+		}
+		base += uint32(len(block) / 21)
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/sdk_call_projection_test.go b/internal/gostaticstorage/sdk_call_projection_test.go
new file mode 100644
index 000000000..222ba066c
--- /dev/null
+++ b/internal/gostaticstorage/sdk_call_projection_test.go
@@ -0,0 +1,61 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestSDKCallTextProjectionKeepsStorageAndRequestedNamesSeparate(t *testing.T) {
+	calls := map[string]bool{"fixture.Callee": true}
+	for _, name := range []string{"unrelated-compiler-DUPok", "unrelated-assembly-DUPok"} {
+		t.Run(name, func(t *testing.T) {
+			first := indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition, Name: "fixture.funcdata", ABI: 0, Kind: 3, Flags: 1, Index: 1}
+			second := first
+			second.Index = 2
+			projection := make(sdkAssemblyNamedDefinitions)
+			for _, symbol := range []indexedObjectSymbol{first, second} {
+				if err := projection.observeCallText(symbol, name == "unrelated-assembly-DUPok", calls); err != nil {
+					t.Fatal("unrelated storage blocked a TEXT-only projection", err)
+				}
+			}
+			if len(projection) != 0 {
+				t.Fatal("unrelated storage acquired a selected named identity", projection)
+			}
+			strict := make(sdkAssemblyNamedDefinitions)
+			if err := strict.observe(first, false); err != nil {
+				t.Fatal(err)
+			}
+			if err := strict.observe(second, false); !errors.Is(err, ErrContext) {
+				t.Fatal("the existing full storage collision observer was weakened", err)
+			}
+		})
+	}
+	for _, reverse := range []bool{false, true} {
+		t.Run(map[bool]string{false: "requested-TEXT-then-storage", true: "requested-storage-then-TEXT"}[reverse], func(t *testing.T) {
+			text := indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition, Name: "fixture.Callee", Kind: 1}
+			storage := text
+			storage.Kind, storage.Flags = 3, 1
+			first, second := text, storage
+			if reverse {
+				first, second = second, first
+			}
+			projection := make(sdkAssemblyNamedDefinitions)
+			if err := projection.observeCallText(first, false, calls); err != nil {
+				t.Fatal(err)
+			}
+			if err := projection.observeCallText(second, false, calls); !errors.Is(err, ErrContext) {
+				t.Fatal("a requested name crossed TEXT/storage roles", err)
+			}
+		})
+	}
+	t.Run("unrelated-TEXT-stays-strict", func(t *testing.T) {
+		text := indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition, Name: "fixture.Other", Kind: 1}
+		projection := make(sdkAssemblyNamedDefinitions)
+		if err := projection.observeCallText(text, false, calls); err != nil {
+			t.Fatal(err)
+		}
+		if err := projection.observeCallText(text, false, calls); !errors.Is(err, ErrContext) {
+			t.Fatal("unrelated duplicate TEXT was hidden by the requested-name projection", err)
+		}
+	})
+}
diff --git a/internal/gostaticstorage/sdk_capture_go127_test.go b/internal/gostaticstorage/sdk_capture_go127_test.go
new file mode 100644
index 000000000..e2910e706
--- /dev/null
+++ b/internal/gostaticstorage/sdk_capture_go127_test.go
@@ -0,0 +1,304 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	encodingbinary "encoding/binary"
+	"encoding/json"
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func sdkRequest(t *testing.T, binary, target string) Request {
+	t.Helper()
+	return Request{GoBinary: binary, Directory: filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "internal", "cpu"),
+		PackagePath: "internal/cpu", Target: target, Environment: fixtureEnv(t, target),
+		Variables: []Reference{{"internal/cpu", "X86"}, {"internal/cpu", "CacheLineSize"}}}
+}
+
+func sdkCaptured(t *testing.T, req Request) (*Observation, Report) {
+	t.Helper()
+	o, err := CaptureSDKCPU(context.Background(), req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(o.Close)
+	report, err := o.Readback(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return o, report
+}
+
+func TestGoSDKStaticStorageTypedProducerAndReader(t *testing.T) {
+	_, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkMemberReaderSource)
+	for _, target := range []string{
+		"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm",
+		"darwin/amd64", "windows/386", "windows/amd64",
+	} {
+		t.Run(target, func(t *testing.T) {
+			o, report := sdkCaptured(t, sdkRequest(t, binary, target))
+			pad, word := int64(64), int64(8)
+			if target == "linux/arm" {
+				pad = 32
+			}
+			if target == "linux/arm64" {
+				pad = 128
+			}
+			if target == "linux/386" || target == "windows/386" || target == "linux/arm" {
+				word = 4
+			}
+			for _, v := range report.Variables {
+				expectedSize, expectedSpans, kind := word, []Span{{0, word}}, uint8(5)
+				if v.Name == "X86" {
+					expectedSize, expectedSpans, kind = 2*pad+36, []Span{{pad, 36}}, 10
+				}
+				if v.Size != expectedSize || v.Kind != kind || v.Alignment != 0 || !reflect.DeepEqual(v.Numerical, expectedSpans) {
+					t.Fatalf("actual target numerical/BSS/DATA/blank layout differs: %+v", v)
+				}
+			}
+			packages, err := sdkCPUPackages(report)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := packages["internal/cpu"]
+			raw := run(t, oracle, report.CommandDirectory, fixtureEnv(t, target), pkg.Export)
+			var members []sdkMember
+			if err := json.Unmarshal(raw, &members); err != nil {
+				t.Fatal(err)
+			}
+			records, err := readSDKCPUArchive(report.Archives["internal/cpu"], target, pkg.SFiles)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, m := range members {
+				for name, record := range m.Variables {
+					if !reflect.DeepEqual(records[name], record) {
+						t.Fatal("SDK original all-member oracle differs", name)
+					}
+				}
+			}
+			encoded, err := json.MarshalIndent(report, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			var decoded Report
+			if json.Unmarshal(encoded, &decoded) != nil || o.CheckReport(context.Background(), decoded) != nil {
+				t.Fatal("actual SDK readback failed")
+			}
+			if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+				folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"))
+				if err := os.MkdirAll(folder, 0700); err != nil {
+					t.Fatal(err)
+				}
+				for name, data := range map[string][]byte{"sdk-producer-report.json": encoded, "sdk-producer-members.json": raw} {
+					if err := os.WriteFile(filepath.Join(folder, name), data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func changeSDKSelection(t *testing.T, report *Report, key string, value any) {
+	t.Helper()
+	decoder := json.NewDecoder(bytes.NewReader(report.RawSelection))
+	var buf bytes.Buffer
+	for {
+		var pkg map[string]json.RawMessage
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		var path string
+		_ = json.Unmarshal(pkg["ImportPath"], &path)
+		if path == "internal/cpu" {
+			raw, err := json.Marshal(value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg[key] = raw
+		}
+		if err := json.NewEncoder(&buf).Encode(pkg); err != nil {
+			t.Fatal(err)
+		}
+	}
+	report.RawSelection = buf.Bytes()
+}
+
+func TestGoSDKStaticStorageOwnerAndReaderGuards(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	o, report := sdkCaptured(t, sdkRequest(t, binary, "linux/amd64"))
+	for name, mutate := range map[string]func(*Report){
+		"standard alone":                 func(r *Report) { changeSDKSelection(t, r, "Goroot", false) },
+		"module nil arbitrary directory": func(r *Report) { changeSDKSelection(t, r, "Dir", dir) },
+		"wrong root":                     func(r *Report) { changeSDKSelection(t, r, "Root", dir) },
+		"module owner": func(r *Report) {
+			changeSDKSelection(t, r, "Module", map[string]any{"Path": "internal/cpu", "Dir": dir, "Main": true})
+		},
+		"import map":                     func(r *Report) { changeSDKSelection(t, r, "ImportMap", map[string]string{"unsafe": "elsewhere"}) },
+		"native member":                  func(r *Report) { changeSDKSelection(t, r, "SysoFiles", []string{"cpu.syso"}) },
+		"wrong assembly role":            func(r *Report) { changeSDKSelection(t, r, "SFiles", []string{"cpu_x86.s", "cpu.s"}) },
+		"assembly command rule":          func(r *Report) { r.Tools["src/cmd/go/internal/work/gc.go"] = strings.Repeat("0", 64) },
+		"unbound target tuning":          func(r *Report) { r.CommandEnvironment["GOARM"] = "6,softfloat" },
+		"report target/profile mismatch": func(r *Report) { r.Target = "darwin/amd64" },
+		"original source changed with hash": func(r *Report) {
+			r.Source["cpu.go"] = append(r.Source["cpu.go"], '\n')
+			r.SourceSHA256["cpu.go"] = digest(r.Source["cpu.go"])
+		},
+		"original inventory omitted": func(r *Report) { delete(r.Source, "cpu_windows.go"); delete(r.SourceSHA256, "cpu_windows.go") },
+		"aliased linkname": func(r *Report) {
+			r.Source["cpu.go"] = bytes.Replace(r.Source["cpu.go"], []byte("//go:linkname X86"), []byte("//go:linkname X86 other.X86"), 1)
+			r.SourceSHA256["cpu.go"] = digest(r.Source["cpu.go"])
+		},
+		"pointer or padding bytes": func(r *Report) {
+			for i := range r.Variables {
+				if r.Variables[i].Name == "X86" {
+					r.Variables[i].Numerical = []Span{{0, r.Variables[i].Size}}
+				}
+			}
+		},
+		"self linkname flag removed": func(r *Report) {
+			a := r.Archives["internal/cpu"]
+			obj := objectBytes(t, a)
+			pos := blockOffset(obj, 3) + 21*symbolIndex(t, obj, "internal/cpu.X86")
+			obj[pos+12] = 0
+			r.ArchiveSHA256["internal/cpu"] = digest(a)
+		},
+		"self linkname flag extended": func(r *Report) {
+			a := r.Archives["internal/cpu"]
+			obj := objectBytes(t, a)
+			pos := blockOffset(obj, 3) + 21*symbolIndex(t, obj, "internal/cpu.X86")
+			obj[pos+12] |= 32
+			r.ArchiveSHA256["internal/cpu"] = digest(a)
+		},
+		"extent disagreement": func(r *Report) {
+			a := r.Archives["internal/cpu"]
+			obj := objectBytes(t, a)
+			pos := blockOffset(obj, 3) + 21*symbolIndex(t, obj, "internal/cpu.X86")
+			encodingbinary.LittleEndian.PutUint32(obj[pos+13:], 165)
+			r.ArchiveSHA256["internal/cpu"] = digest(a)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneReport(t, report)
+			mutate(&changed)
+			if !errors.Is(ValidateReport(changed), ErrContext) || !errors.Is(o.CheckReport(context.Background(), changed), ErrContext) {
+				t.Fatal("unbound SDK role acquired producer")
+			}
+		})
+	}
+	for _, kind := range []string{"lookalike owner", "arbitrary module nil", "unknown target", "function not Var", "missing Var"} {
+		t.Run(kind, func(t *testing.T) {
+			req := sdkRequest(t, binary, "linux/amd64")
+			switch kind {
+			case "lookalike owner":
+				req.Directory = dir
+			case "arbitrary module nil":
+				req.PackagePath = "unsafe"
+			case "unknown target":
+				req.Target = "freebsd/amd64"
+			case "function not Var":
+				req.Variables = []Reference{{"internal/cpu", "Initialize"}}
+			case "missing Var":
+				req.Variables = []Reference{{"internal/cpu", "NoSuchVar"}}
+			}
+			if got, err := CaptureSDKCPU(context.Background(), req); !errors.Is(err, ErrContext) {
+				if got != nil {
+					got.Close()
+				}
+				t.Fatal("unbound original SDK request accepted", err)
+			}
+		})
+	}
+	if got, err := Capture(context.Background(), sdkRequest(t, binary, "linux/amd64")); !errors.Is(err, ErrContext) {
+		if got != nil {
+			got.Close()
+		}
+		t.Fatal("ordinary module producer widened")
+	}
+	if _, err := CaptureSDKCPU(nil, sdkRequest(t, binary, "linux/amd64")); !errors.Is(err, ErrContext) {
+		t.Fatal("nil SDK context accepted")
+	}
+}
+
+func sdkMemberBody(t *testing.T, archive []byte, name string) []byte {
+	t.Helper()
+	members, err := archiveMembers(archive)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, member := range members {
+		if member.name == name {
+			body, err := objectBody(member.data, "linux/amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			return body
+		}
+	}
+	t.Fatal("missing actual SDK member", name)
+	return nil
+}
+
+func TestGoSDKStaticStorageAllMemberBinaryGuards(t *testing.T) {
+	_, binary, _ := fixture(t)
+	_, report := sdkCaptured(t, sdkRequest(t, binary, "linux/amd64"))
+	original := report.Archives["internal/cpu"]
+	for name, mutate := range map[string]func([]byte){
+		"compiler nonstd":               func(a []byte) { encodingbinary.LittleEndian.PutUint32(objectBytes(t, a)[16:], 0) },
+		"empty member nonstd":           func(a []byte) { encodingbinary.LittleEndian.PutUint32(sdkMemberBody(t, a, "cpu.o")[16:], 4) },
+		"assembly missing assembly bit": func(a []byte) { encodingbinary.LittleEndian.PutUint32(sdkMemberBody(t, a, "cpu_x86.o")[16:], 16) },
+		"assembly extra flags":          func(a []byte) { encodingbinary.LittleEndian.PutUint32(sdkMemberBody(t, a, "cpu_x86.o")[16:], 21) },
+		"assembly block overflow": func(a []byte) {
+			encodingbinary.LittleEndian.PutUint32(sdkMemberBody(t, a, "cpu_x86.o")[20+4*14:], ^uint32(0))
+		},
+		"assembly same ABI wrapper": func(a []byte) {
+			obj := sdkMemberBody(t, a, "cpu_x86.o")
+			pos := blockOffset(obj, 3) + 21*symbolIndex(t, obj, "internal/cpu.cpuid")
+			encodingbinary.LittleEndian.PutUint16(obj[pos+8:], 1)
+		},
+		"assembly storage collision": func(a []byte) {
+			obj := sdkMemberBody(t, a, "cpu_x86.o")
+			pos := blockOffset(obj, 3) + 21*symbolIndex(t, obj, "internal/cpu.cpuid")
+			off := encodingbinary.LittleEndian.Uint32(obj[pos+4:])
+			name := "internal/cpu.X86"
+			copy(obj[int(off):], name)
+			encodingbinary.LittleEndian.PutUint32(obj[pos:], uint32(len(name)))
+			obj[pos+10] = 10
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := append([]byte(nil), original...)
+			mutate(changed)
+			if _, err := readSDKCPUArchive(changed, "linux/amd64", []string{"cpu.s", "cpu_x86.s"}); !errors.Is(err, ErrContext) {
+				t.Fatal("malformed or unbound SDK member accepted", err)
+			}
+		})
+	}
+	for _, sources := range [][]string{nil, {"cpu.s"}, {"cpu_x86.s", "cpu.s"}, {"cpu.s", "../cpu_x86.s"}} {
+		if _, err := readSDKCPUArchive(original, "linux/amd64", sources); !errors.Is(err, ErrContext) {
+			t.Fatal("unbound selected SFile roles accepted")
+		}
+	}
+	if _, err := readArchive(original, "linux/amd64"); !errors.Is(err, ErrContext) {
+		t.Fatal("ordinary archive member grammar broadened")
+	}
+	empty := append([]byte(nil), sdkMemberBody(t, original, "cpu.o")...)
+	for _, flags := range []uint32{0, 16} {
+		encodingbinary.LittleEndian.PutUint32(empty[16:], flags)
+		if _, err := readObjectRole(empty, flags, false); !errors.Is(err, ErrContext) {
+			t.Fatal("empty compiler object broadened")
+		}
+	}
+}
diff --git a/internal/gostaticstorage/sdk_compiler_text.go b/internal/gostaticstorage/sdk_compiler_text.go
new file mode 100644
index 000000000..6da98896a
--- /dev/null
+++ b/internal/gostaticstorage/sdk_compiler_text.go
@@ -0,0 +1,26 @@
+package gostaticstorage
+
+// ObserveX86SDKCompilerText observes the complete two-member archive emitted
+// by the existing SDK header compiler. It is offline object metadata only;
+// neither this function nor a returned record supplies a declaration or ABI.
+func ObserveX86SDKCompilerText(data, builtin []byte, target string, referenced map[string]SDKReferencedArchive) ([]TextRecord, error) {
+	if !X86SDKTarget(target) {
+		return nil, contextError("unobserved SDK compiler TEXT target")
+	}
+	members, err := archiveMembers(data)
+	if err != nil {
+		return nil, err
+	}
+	if len(members) != 2 || members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+		return nil, contextError("SDK compiler TEXT lacks its complete two-member archive")
+	}
+	symbols, err := sdkReferencedArchiveSymbols(referenced, target)
+	if err != nil {
+		return nil, err
+	}
+	member, err := observeASMDataObject(members[1].data, builtin, target, sdkCompilerObjectFlags(target), symbols)
+	if err != nil {
+		return nil, err
+	}
+	return member.Texts, nil
+}
diff --git a/internal/gostaticstorage/sdk_fips_text_kind_go127_test.go b/internal/gostaticstorage/sdk_fips_text_kind_go127_test.go
new file mode 100644
index 000000000..b4ebbe850
--- /dev/null
+++ b/internal/gostaticstorage/sdk_fips_text_kind_go127_test.go
@@ -0,0 +1,206 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func sdkFIPSOracleSymbol(value namespaceOracleDefinition) indexedObjectSymbol {
+	return indexedObjectSymbol{Namespace: TextSymbolNamespace(value.Namespace), Relative: value.Relative,
+		Index: value.Index, Name: value.Name, ABI: value.ABI, Kind: value.Kind,
+		Flags: value.Flags, Flags2: value.Flags2, Size: value.Size, Align: value.Align,
+		Hash: append([]byte(nil), value.Hash...)}
+}
+
+func TestGoSDKFIPSTextKindOriginalArchive(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	oracle := officialReaderForSource(t, driver, sdkNamespaceReaderSource)
+	root := filepath.Dir(filepath.Dir(driver))
+	role := "src/cmd/internal/objabi/symkind.go"
+	kinds, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(role)))
+	if err != nil || digest(kinds) != formatSources[role] ||
+		!bytes.Contains(kinds, []byte("return t == STEXT || t == STEXTFIPS")) {
+		t.Fatal("actual current SDK SymKind schema differs from its independently pinned source", err)
+	}
+	builtin, err := os.ReadFile(filepath.Join(root, filepath.FromSlash(builtinSourceRole)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const path = "crypto/internal/fips140/bigmod"
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			target := "linux/" + arch
+			env := fixtureEnv(t, target)
+			selection := run(t, driver, directory, env, "list", "-json", "-compiled", "-export", path)
+			var selected struct {
+				ImportPath, Dir, Root, Export string
+				Standard, Goroot              bool
+				SFiles                        []string
+			}
+			if err := json.Unmarshal(selection, &selected); err != nil || selected.ImportPath != path ||
+				!selected.Standard || !selected.Goroot || selected.Root != root ||
+				selected.Dir != filepath.Join(root, "src", filepath.FromSlash(path)) ||
+				!reflect.DeepEqual(selected.SFiles, []string{"nat_" + arch + ".s"}) || selected.Export == "" {
+				t.Fatal("actual stock FIPS package/source/archive prior differs", err)
+			}
+			archive, err := os.ReadFile(selected.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			assembly, err := os.ReadFile(filepath.Join(selected.Dir, selected.SFiles[0]))
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, directory, env, selected.Export)
+			var actual []namespaceOracleMember
+			if err := json.Unmarshal(raw, &actual); err != nil || len(actual) != len(selected.SFiles)+2 {
+				t.Fatal("independent actual Go archive prior is incomplete", err)
+			}
+			members, err := archiveMembers(archive)
+			if err != nil || len(members) != len(actual) {
+				t.Fatal("whole original FIPS archive member prior differs", err)
+			}
+			observed := make([]ASMDataMember, len(members)-1)
+			indexed := make([][]indexedObjectSymbol, len(observed))
+			groups := make(map[string][]indexedObjectSymbol)
+			for ordinal, member := range members {
+				prior := actual[ordinal]
+				if prior.Name != member.name || !bytes.Equal(prior.NameBytes, []byte(member.name)) ||
+					prior.Offset != member.offset || prior.Size != int64(len(member.data)) {
+					t.Fatal("original archive member/name-byte/extent identity differs", ordinal)
+				}
+				if ordinal == 0 {
+					continue
+				}
+				flags := sdkCompilerObjectFlags(target)
+				if ordinal != 1 {
+					flags |= 4
+				}
+				if prior.Flags != flags {
+					t.Fatal("actual compiler/assembler member flags differ from the current producer role", ordinal, prior.Flags)
+				}
+				reader := sdkObjectBody
+				if ordinal != 1 {
+					reader = objectBody
+				}
+				body, err := reader(member.data, target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				object, err := checkedObject(body, prior.Flags, ordinal != 1)
+				if err != nil {
+					t.Fatal("original complete object precondition", err)
+				}
+				symbols, err := object.indexedSymbols()
+				if err != nil || len(symbols) != len(prior.Definitions) {
+					t.Fatal("original complete namespace inventory differs", err)
+				}
+				value := &observed[ordinal-1]
+				value.Name, value.Ordinal, value.Flags = member.name, ordinal, prior.Flags
+				for index, symbol := range symbols {
+					if !reflect.DeepEqual(symbol, sdkFIPSOracleSymbol(prior.Definitions[index])) {
+						t.Fatal("actual raw kind/ABI/namespace/index/hash/flags identity differs", ordinal, index)
+					}
+					if symbol.Namespace == TextSymbolNonpkgReference {
+						continue
+					}
+					groups[symbol.Name] = append(groups[symbol.Name], symbol)
+					// Use the independently observed current enum here, not a
+					// production classifier or a FIPS package/name heuristic.
+					if symbol.Kind == 1 || symbol.Kind == 2 {
+						value.Texts = append(value.Texts, TextRecord{Name: symbol.Name, ABI: symbol.ABI,
+							Kind: symbol.Kind, Namespace: symbol.Namespace, Index: symbol.Index,
+							Relative: symbol.Relative, Flags: symbol.Flags, Flags2: symbol.Flags2,
+							Size: int64(symbol.Size), Hash: append([]byte(nil), symbol.Hash...)})
+					} else {
+						value.Definitions = append(value.Definitions, ASMDataDefinition{Name: symbol.Name,
+							ABI: symbol.ABI, Kind: symbol.Kind, Namespace: symbol.Namespace,
+							Index: symbol.Index, Relative: symbol.Relative, Flags: symbol.Flags,
+							Flags2: symbol.Flags2, Size: symbol.Size, Align: symbol.Align,
+							Hash: append([]byte(nil), symbol.Hash...)})
+					}
+				}
+				indexed[ordinal-1] = symbols
+			}
+			for _, name := range []string{"addMulVVW1024", "addMulVVW1536", "addMulVVW2048"} {
+				entries := groups[path+"."+name]
+				want := 1 // 386 has no register-ABI wrapper; do not invent ABI1 there.
+				if arch == "amd64" {
+					want = 2
+				}
+				seen := make(map[uint16]bool)
+				for _, entry := range entries {
+					if entry.Kind != 2 || entry.Size == 0 || entry.ABI > 1 || seen[entry.ABI] {
+						t.Fatal("actual FIPS code prior is not distinct nonempty STEXTFIPS entries", name, entries)
+					}
+					seen[entry.ABI] = true
+				}
+				if len(entries) != want || !seen[0] || arch == "amd64" && !seen[1] {
+					t.Fatal("actual original assembly/compiler ABI inventory differs", name, entries)
+				}
+			}
+			storage := groups[path+".supportADX"]
+			if len(storage) != 1 || storage[0].ABI != 0 || storage[0].Kind == 1 || storage[0].Kind == 2 {
+				t.Fatal("the actual bool global, unlike the code, does not have multiple ABI identities", storage)
+			}
+			retainTextArtifact(t, target, "fips-text-kind", map[string][]byte{
+				"original.a": archive, "selection.json": selection, "namespace-sdk.json": raw,
+				"symkind.go": kinds, "source-" + selected.SFiles[0]: assembly,
+			})
+			t.Logf("ACTUAL_FIPS_ARCHIVE target=%s members=%d archiveSHA256=%s entries=3 wrapperABI=%t",
+				target, len(members), digest(archive), arch == "amd64")
+			t.Run("archive-classification", func(t *testing.T) {
+				if err := validateASMDataArchiveNames(observed); err != nil {
+					t.Fatal("actual FIPS code was classified as ambiguous storage", err)
+				}
+			})
+			t.Run("named-classification", func(t *testing.T) {
+				definitions := make(sdkAssemblyNamedDefinitions)
+				for member, symbols := range indexed {
+					for _, symbol := range symbols {
+						if err := definitions.observe(symbol, member != 0); err != nil {
+							t.Fatal("complete actual SDK text identities lost their original role", symbol.Name, err)
+						}
+					}
+				}
+			})
+			t.Run("no-raw-owned-or-forged-role", func(t *testing.T) {
+				if _, err := ObserveX86AssemblyArchive(archive, builtin, target, selected.SFiles); !errors.Is(err, ErrContext) {
+					t.Fatal("FIPS classification granted an ordinary owned archive role", err)
+				}
+				if _, err := ObserveX86AssemblyText(members[2].data, builtin, target); !errors.Is(err, ErrContext) {
+					t.Fatal("FIPS classification granted an ordinary standalone raw object role", err)
+				}
+				body, err := objectBody(members[2].data, target)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, mutate := range []func([]byte){
+					func(data []byte) { data[0] ^= 1 },
+					func(data []byte) {
+						start := binary.LittleEndian.Uint32(data[20+4*6:])
+						data[start+10] = 26
+					},
+					func(data []byte) {
+						end := binary.LittleEndian.Uint32(data[20+4*7:])
+						binary.LittleEndian.PutUint32(data[20+4*7:], end-1)
+					},
+				} {
+					changed := append([]byte(nil), body...)
+					mutate(changed)
+					if _, err := checkedObject(changed, actual[2].Flags, false); !errors.Is(err, ErrContext) {
+						t.Fatal("raw magic/kind/namespace mutation acquired the current text observation role", err)
+					}
+				}
+			})
+		})
+	}
+}
diff --git a/internal/gostaticstorage/sdk_globals.go b/internal/gostaticstorage/sdk_globals.go
new file mode 100644
index 000000000..f847a986e
--- /dev/null
+++ b/internal/gostaticstorage/sdk_globals.go
@@ -0,0 +1,366 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"go/types"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// This producer independently authenticates ordinary Go-defined variables in
+// the selected stock SDK. Its actual complete source/export graph, original
+// compiler records and target types are separate from the exact CPU producer.
+// Neither an SDK path nor a Standard flag alone supplies this authority.
+const SDKGlobalsProtocol = "actual_go_sdk_go_numeric_storage_v1"
+
+func CaptureSDKGlobals(ctx context.Context, request Request) (*Observation, error) {
+	return captureRole(ctx, request, SDKGlobalsProtocol)
+}
+
+func sdkStorageProtocol(protocol string) bool {
+	return protocol == SDKCPUProtocol || protocol == SDKGlobalsProtocol
+}
+
+func sdkGlobalDirectory(binary, directory, path string) bool {
+	return path != "" && filepath.IsLocal(filepath.FromSlash(path)) &&
+		filepath.ToSlash(filepath.Clean(filepath.FromSlash(path))) == path &&
+		directory == filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", filepath.FromSlash(path))
+}
+
+func sdkGlobalsArguments(path string) []string {
+	return []string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", path}
+}
+
+func sdkGlobalsSelections(raw []byte, root, entry string, exports bool) (map[string]Package, error) {
+	decoder := json.NewDecoder(bytes.NewReader(raw))
+	packages := make(map[string]Package)
+	for {
+		var pkg Package
+		if err := decoder.Decode(&pkg); err == io.EOF {
+			break
+		} else if err != nil || len(packages) >= 64 {
+			return nil, contextError("incomplete or excessive SDK global source graph")
+		}
+		if !sdkGlobalDirectory(filepath.Join(root, "bin", gotoolchain.HostExecutable("go")), pkg.Dir, pkg.ImportPath) ||
+			!pkg.Standard || !pkg.Goroot || pkg.Root != root || pkg.Module != nil || pkg.ForTest != "" || pkg.Name == "" ||
+			packages[pkg.ImportPath].ImportPath != "" || len(pkg.GoFiles) == 0 ||
+			len(pkg.Error) != 0 && string(pkg.Error) != "null" || len(pkg.DepsErrors) != 0 {
+			return nil, contextError("SDK global graph has a foreign/nonoriginal package identity")
+		}
+		if exports && pkg.ImportPath != "unsafe" && !filepath.IsAbs(pkg.Export) {
+			return nil, contextError("SDK global graph lacks its actual compiler export")
+		}
+		for _, files := range [][]string{pkg.CgoFiles, pkg.EmbedFiles, pkg.EmbedPatterns, pkg.CFiles, pkg.CXXFiles,
+			pkg.MFiles, pkg.FFiles, pkg.SwigFiles, pkg.SwigCXXFiles, pkg.SysoFiles} {
+			if len(files) != 0 {
+				return nil, contextError("SDK global graph needs a separate generated/foreign source mapping")
+			}
+		}
+		seen := make(map[string]bool)
+		for _, files := range [][]string{pkg.GoFiles, pkg.SFiles, pkg.HFiles} {
+			for _, name := range files {
+				if filepath.Base(name) != name || strings.ContainsAny(name, "\\\x00\r\n") || seen[name] {
+					return nil, contextError("SDK global selected source identity differs")
+				}
+				seen[name] = true
+			}
+		}
+		wanted := make([]string, len(pkg.GoFiles))
+		for index, name := range pkg.GoFiles {
+			wanted[index] = filepath.Join(pkg.Dir, name)
+		}
+		actual := append([]string(nil), pkg.CompiledGoFiles...)
+		for index, name := range actual {
+			if !filepath.IsAbs(name) {
+				if filepath.Base(name) != name {
+					return nil, contextError("SDK global compiled source needs original mapping")
+				}
+				actual[index] = filepath.Join(pkg.Dir, name)
+			}
+		}
+		sort.Strings(wanted)
+		sort.Strings(actual)
+		if pkg.ImportPath != "unsafe" && !reflect.DeepEqual(actual, wanted) {
+			return nil, contextError("SDK global compiler selection differs from complete original Go sources")
+		}
+		pkg.CompiledGoFiles = actual
+		packages[pkg.ImportPath] = pkg
+	}
+	if packages[entry].ImportPath != entry || packages["unsafe"].ImportPath != "" && packages["unsafe"].Name != "unsafe" {
+		return nil, contextError("SDK global source graph lacks its original entry/builtin identity")
+	}
+	for _, pkg := range packages {
+		for _, path := range pkg.Imports {
+			if packages[path].ImportPath != path || pkg.ImportMap[path] != "" && pkg.ImportMap[path] != path {
+				return nil, contextError("SDK global import graph has an unobserved/aliased edge")
+			}
+		}
+		for path, destination := range pkg.ImportMap {
+			if path != destination || packages[path].ImportPath != path {
+				return nil, contextError("SDK global import-map identity differs")
+			}
+		}
+	}
+	return packages, nil
+}
+
+func sdkGlobalSourceKey(entry string, pkg Package, name string) string {
+	if pkg.ImportPath == entry {
+		return name
+	}
+	return "_sdk/" + pkg.ImportPath + "/" + name
+}
+
+func (o *Observation) captureSDKGlobalDependencies(ctx context.Context) error {
+	// Observe and guard the original sources before the independently forced
+	// compiler/export command. Verification repeats its complete selection.
+	raw, err := o.run(ctx, "list", "-deps", "-json", "-compiled", o.request.PackagePath)
+	if err != nil {
+		return err
+	}
+	packages, err := sdkGlobalsSelections(raw, o.report.Environment["GOROOT"], o.request.PackagePath, false)
+	if err != nil {
+		return err
+	}
+	usage, err := sourceUsage(o.report.Source, o.report.Protocol)
+	if err != nil {
+		return err
+	}
+	for _, pkg := range packages {
+		resolved, resolveErr := sourcepath.Resolve(pkg.Dir)
+		info, err := sourcepath.Lstat(pkg.Dir)
+		if resolveErr != nil || resolved != pkg.Dir || err != nil || !info.IsDir() || info.Mode()&os.ModeSymlink != 0 {
+			return contextError("SDK global selected directory is redirected/missing")
+		}
+		o.dirs[pkg.Dir] = info
+		for _, files := range [][]string{pkg.GoFiles, pkg.SFiles, pkg.HFiles} {
+			for _, name := range files {
+				absolute, key := filepath.Join(pkg.Dir, name), sdkGlobalSourceKey(o.request.PackagePath, pkg, name)
+				data, err := readRegular(absolute, 16<<20)
+				if err != nil {
+					return err
+				}
+				if previous, present := o.report.Source[key]; present {
+					if !bytes.Equal(previous, data) {
+						return contextError("SDK global original source changed before compiler selection")
+					}
+				} else if err := usage.add(len(data)); err != nil {
+					return err
+				}
+				o.report.Source[key], o.report.SourceSHA256[key] = data, digest(data)
+				o.inputs[absolute] = digest(data)
+			}
+		}
+	}
+	return nil
+}
+
+func (o *Observation) snapshotSource() (map[string][]byte, error) {
+	source, err := snapshot(o.request.Directory, o.report.Protocol)
+	if err != nil || o.report.Protocol != SDKGlobalsProtocol {
+		return source, err
+	}
+	packages, err := sdkGlobalsSelections(o.report.RawSelection, o.report.Environment["GOROOT"], o.report.PackagePath, true)
+	if err != nil {
+		return nil, err
+	}
+	usage, err := sourceUsage(source, o.report.Protocol)
+	if err != nil {
+		return nil, err
+	}
+	for _, pkg := range packages {
+		if pkg.ImportPath == o.report.PackagePath {
+			continue
+		}
+		for _, files := range [][]string{pkg.GoFiles, pkg.SFiles, pkg.HFiles} {
+			for _, name := range files {
+				key := sdkGlobalSourceKey(o.report.PackagePath, pkg, name)
+				if _, present := source[key]; present {
+					return nil, contextError("SDK dependency source collides with original package inventory")
+				}
+				data, err := readRegular(filepath.Join(pkg.Dir, name), 16<<20)
+				if err != nil {
+					return nil, err
+				}
+				if err := usage.add(len(data)); err != nil {
+					return nil, err
+				}
+				source[key] = data
+			}
+		}
+	}
+	return source, nil
+}
+
+func sdkGlobalsPackages(report Report) (map[string]Package, error) {
+	root := report.Environment["GOROOT"]
+	if !sdkCPUTarget(report.Target) || !sdkGlobalDirectory(report.CommandBinary, report.CommandDirectory, report.PackagePath) {
+		return nil, contextError("SDK global owner/target/source role differs")
+	}
+	packages, err := sdkGlobalsSelections(report.RawSelection, root, report.PackagePath, true)
+	if err != nil {
+		return nil, err
+	}
+	for path, pkg := range packages {
+		if path != "unsafe" && !within(report.Environment["GOCACHE"], pkg.Export) {
+			return nil, contextError("SDK global compiler export is outside its observed cache")
+		}
+		for _, files := range [][]string{pkg.GoFiles, pkg.SFiles, pkg.HFiles} {
+			for _, name := range files {
+				if report.Source[sdkGlobalSourceKey(report.PackagePath, pkg, name)] == nil {
+					return nil, contextError("SDK global complete selected source bytes are absent")
+				}
+			}
+		}
+	}
+	delete(packages, "unsafe") // The builtin has source, never an archive/global.
+	return packages, nil
+}
+
+func sdkGlobalPointerFree(typ types.Type, depth int) bool {
+	if depth > 64 {
+		return false
+	}
+	switch typ := typ.Underlying().(type) {
+	case *types.Basic:
+		return typ.Info()&(types.IsInteger|types.IsFloat|types.IsBoolean) != 0 && typ.Info()&types.IsUntyped == 0
+	case *types.Array:
+		return sdkGlobalPointerFree(typ.Elem(), depth+1)
+	case *types.Struct:
+		for index := 0; index < typ.NumFields(); index++ {
+			if !sdkGlobalPointerFree(typ.Field(index).Type(), depth+1) {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+// Every actual member is structurally checked in its exact selected SDK role.
+// Only compiler SymbolDefs supply Go-defined storage. Assembly data, hashed
+// namespaces and exported-type records never supply a requested variable.
+func readSDKGlobalArchive(data []byte, target string, sources []string) (map[string]dataRecord, error) {
+	return readSDKCompilerStorageArchive(data, target, sources, false)
+}
+
+func readSDKCompilerStorageArchive(data []byte, target string, sources []string, cpu bool) (map[string]dataRecord, error) {
+	members, err := archiveMembers(data)
+	names, namesErr := sdkAssemblyMemberNames(sources)
+	if err != nil || namesErr != nil || len(members) != len(sources)+2 ||
+		members[0].name != "__.PKGDEF" || members[1].name != "_go_.o" {
+		return nil, contextError("SDK global archive differs from complete selected source/member roles")
+	}
+	var compiler *sdkIndexedMetadataObject
+	definitions := make(map[string]bool)
+	for index, member := range members[1:] {
+		flags := sdkCompilerObjectFlags(target)
+		if index != 0 {
+			if member.name != names[index-1] {
+				return nil, contextError("SDK global assembly source/member identity differs")
+			}
+			flags |= 4
+		}
+		reader := objectBody
+		if index == 0 {
+			reader = sdkObjectBody
+		}
+		body, err := reader(member.data, target)
+		if err != nil {
+			return nil, err
+		}
+		object, err := checkedSDKIndexedMetadata(body, flags, index != 0)
+		if err != nil {
+			return nil, err
+		}
+		symbols, err := object.storageSymbols(cpu)
+		if err != nil {
+			return nil, err
+		}
+		for _, symbol := range symbols {
+			if symbol.Name == "" {
+				continue // Anonymous records retain indexed identity and cannot name a variable.
+			}
+			if cpu && index != 0 && symbol.Kind != 1 {
+				return nil, contextError(fmt.Sprintf("assembly data backing outside SDK CPU storage role: member=%s symbol=%q kind=%d ABI=%d", member.name, symbol.Name, symbol.Kind, symbol.ABI))
+			}
+			identity := symbol.Name + "\x00" + string(rune(symbol.ABI))
+			if definitions[identity] {
+				return nil, contextError(fmt.Sprintf("SDK global has duplicate same-ABI native definitions: member=%s symbol=%q ABI=%d", member.name, symbol.Name, symbol.ABI))
+			}
+			definitions[identity] = true
+		}
+		if index == 0 {
+			compiler = object
+		}
+	}
+	result := make(map[string]dataRecord)
+	symbols, err := compiler.storageSymbols(cpu)
+	if err != nil {
+		return nil, err
+	}
+	for _, symbol := range symbols {
+		name, index := symbol.Name, symbol.Index
+		if name == "" || symbol.Kind == 1 {
+			continue // Anonymous/type metadata and TEXT never provide Go variable storage.
+		}
+		if result[name].Name != "" {
+			return nil, contextError("SDK compiler storage has an empty/duplicate original definition")
+		}
+		record := dataRecord{Name: name, Member: "_go_.o", Index: index, ABI: symbol.ABI,
+			Kind: symbol.Kind, Flags: symbol.Flags, Flags2: symbol.Flags2,
+			Size: int64(symbol.Size), Align: int64(symbol.Align)}
+		start := binary.LittleEndian.Uint32(compiler.block(13)[index*4:])
+		end := binary.LittleEndian.Uint32(compiler.block(13)[(index+1)*4:])
+		record.Data = append([]byte(nil), compiler.block(16)[start:end]...)
+		first := binary.LittleEndian.Uint32(compiler.block(11)[index*4:])
+		last := binary.LittleEndian.Uint32(compiler.block(11)[(index+1)*4:])
+		for offset := first; offset < last; offset++ {
+			relocation := compiler.block(14)[offset*23 : (offset+1)*23]
+			record.Relocations = append(record.Relocations, relocationRecord(relocation))
+		}
+		result[name] = record
+	}
+	return result, nil
+}
+
+func relocationRecord(value []byte) relocation {
+	return relocation{int64(int32(binary.LittleEndian.Uint32(value))), int64(value[4]), binary.LittleEndian.Uint16(value[5:])}
+}
+
+// This separate report role retains member identities only. It has no native
+// TEXT observations; consumers must bind their independent whole SDK objects.
+func sdkGlobalMembers(report Report, packages map[string]Package) (map[string][]TextMember, error) {
+	result := make(map[string][]TextMember)
+	for path, pkg := range packages {
+		if _, err := readSDKGlobalArchive(report.Archives[path], report.Target, pkg.SFiles); err != nil {
+			return nil, err
+		}
+		members, err := archiveMembers(report.Archives[path])
+		if err != nil {
+			return nil, err
+		}
+		for index, member := range members {
+			flags := uint32(0)
+			if index > 0 {
+				flags = sdkCompilerObjectFlags(report.Target)
+			}
+			if index > 1 {
+				flags |= 4
+			}
+			result[path] = append(result[path], TextMember{Name: member.name, Offset: member.offset, Size: int64(len(member.data)), Flags: flags})
+		}
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/sdk_go127_test.go b/internal/gostaticstorage/sdk_go127_test.go
new file mode 100644
index 000000000..43932afc4
--- /dev/null
+++ b/internal/gostaticstorage/sdk_go127_test.go
@@ -0,0 +1,165 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type sdkDefinition struct {
+	Name                   string
+	Kind                   uint8
+	ABI                    uint16
+	Flags, Flags2          uint8
+	Size, Align            int64
+	DataBytes, Relocations int
+}
+
+type sdkMember struct {
+	Name         string
+	Type         int
+	Offset, Size int64
+	TextHeader   []byte
+	ObjectFlags  uint32
+	Definitions  []sdkDefinition
+	Variables    map[string]dataRecord
+}
+
+// All member/definition metadata comes from the original SDK implementation.
+// Variables retain full bytes/relocations; unrelated TEXT data is not treated
+// as storage and receives no translation or native-entry permission.
+const sdkMemberReaderSource = `package main
+import (
+ "cmd/internal/archive"
+ "cmd/internal/goobj"
+ "encoding/json"
+ "fmt"
+ "os"
+)
+type Reloc struct { Offset, Size int64; Type uint16 }
+type Record struct {
+ Name string; Kind uint8; ABI uint16; Flags, Flags2 uint8
+ Size, Align int64; Data []byte; Relocations []Reloc
+ Member string; Index uint32
+}
+type Definition struct {
+ Name string; Kind uint8; ABI uint16; Flags, Flags2 uint8
+ Size, Align int64; DataBytes, Relocations int
+}
+type Member struct {
+ Name string; Type int; Offset, Size int64
+ TextHeader []byte; ObjectFlags uint32; Definitions []Definition
+ Variables map[string]Record
+}
+func main() {
+ f,err:=os.Open(os.Args[1]); if err!=nil { panic(err) }; defer f.Close()
+ a,err:=archive.Parse(f,false); if err!=nil { panic(err) }
+ members:=[]Member{}
+ for _,entry:=range a.Entries {
+  m:=Member{Name:entry.Name,Type:int(entry.Type),Offset:entry.Offset,Size:entry.Size}
+  if entry.Type==archive.EntryGoObj {
+   m.TextHeader=entry.Obj.TextHeader
+   data:=make([]byte,entry.Obj.Size)
+   n,err:=f.ReadAt(data,entry.Obj.Offset); if err!=nil||n!=len(data) { panic(fmt.Sprint(n,err)) }
+   r:=goobj.NewReaderFromBytes(data,false); if r==nil { panic("goobj") }
+   m.ObjectFlags=r.Flags(); m.Variables=map[string]Record{}
+   count:=r.NSym()+r.NHashed64def()+r.NHasheddef()+r.NNonpkgdef()
+   for i:=0;i<count;i++ {
+    s:=r.Sym(uint32(i)); name:=s.Name(r)
+    m.Definitions=append(m.Definitions,Definition{Name:name,Kind:s.Type(),ABI:s.ABI(),Flags:s.Flag(),Flags2:s.Flag2(),Size:int64(s.Siz()),Align:int64(s.Align()),DataBytes:len(r.Data(uint32(i))),Relocations:r.NReloc(uint32(i))})
+    if name!="internal/cpu.X86"&&name!="internal/cpu.CacheLineSize" { continue }
+    v:=Record{
+     Name:name, Kind:s.Type(), ABI:s.ABI(), Flags:s.Flag(), Flags2:s.Flag2(),
+     Size:int64(s.Siz()), Align:int64(s.Align()), Data:r.Data(uint32(i)),
+     Member:entry.Name, Index:uint32(i),
+    }
+    for j:=0;j<r.NReloc(uint32(i));j++ { q:=r.Reloc(uint32(i),j); v.Relocations=append(v.Relocations,Reloc{int64(q.Off()),int64(q.Siz()),q.Type()}) }
+    m.Variables[name]=v
+   }
+  }
+  members=append(members,m)
+ }
+ if err:=json.NewEncoder(os.Stdout).Encode(members);err!=nil { panic(err) }
+}
+`
+
+func TestGoSDKStaticStorageOriginalCPUArchiveMembers(t *testing.T) {
+	_, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkMemberReaderSource)
+	root := filepath.Dir(filepath.Dir(binary))
+	dir := filepath.Join(root, "src", "internal", "cpu")
+	for _, target := range []string{
+		"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm",
+		"darwin/amd64", "windows/386", "windows/amd64",
+	} {
+		t.Run(target, func(t *testing.T) {
+			selected := run(t, binary, dir, fixtureEnv(t, target), "list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "internal/cpu")
+			decoder := json.NewDecoder(bytes.NewReader(selected))
+			var actual Package
+			for {
+				var pkg Package
+				if err := decoder.Decode(&pkg); err == io.EOF {
+					break
+				} else if err != nil {
+					t.Fatal(err)
+				}
+				if pkg.ImportPath == "internal/cpu" {
+					actual = pkg
+				}
+			}
+			if !actual.Standard || actual.Dir != dir || actual.Module != nil || actual.Export == "" {
+				t.Fatalf("original SDK owner selection differs: %+v", actual)
+			}
+			archive, err := os.ReadFile(actual.Export)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, dir, fixtureEnv(t, target), actual.Export)
+			var members []sdkMember
+			if err := json.Unmarshal(raw, &members); err != nil {
+				t.Fatal(err)
+			}
+			var variable dataRecord
+			matches := 0
+			for _, member := range members {
+				if value, exists := member.Variables["internal/cpu.X86"]; exists {
+					variable = value
+					matches++
+				}
+			}
+			if matches != 1 || variable.Kind != 10 || variable.Size <= 0 || len(variable.Data) != 0 || len(variable.Relocations) != 0 {
+				t.Fatalf("actual SDK native BSS identity is not unique/initialized: %+v", members)
+			}
+			artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR")
+			if artifact != "" {
+				folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"))
+				if err := os.MkdirAll(folder, 0700); err != nil {
+					t.Fatal(err)
+				}
+				for name, data := range map[string][]byte{"actual.a": archive, "selected.json": selected, "sdk-members.json": raw} {
+					if err := os.WriteFile(filepath.Join(folder, name), data, 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+			}
+			t.Logf("SDK_ORIGINAL_CPU %s archiveSHA256=%s members=%d X86=%+v", target, digest(archive), len(members), variable)
+			for _, member := range members {
+				t.Logf("SDK_ORIGINAL_MEMBER %s %s type=%d flags=%#x definitions=%d", target, member.Name, member.Type, member.ObjectFlags, len(member.Definitions))
+			}
+			data, err := readSDKCPUArchive(archive, target, actual.SFiles)
+			if err != nil {
+				t.Fatalf("original SDK initialized numerical storage lacks binary producer: %v", err)
+			}
+			if !reflect.DeepEqual(data[variable.Name], variable) {
+				t.Fatal("original SDK BSS record differs from actual Go archive reader")
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/sdk_object_header.go b/internal/gostaticstorage/sdk_object_header.go
new file mode 100644
index 000000000..904f50c1f
--- /dev/null
+++ b/internal/gostaticstorage/sdk_object_header.go
@@ -0,0 +1,65 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"strings"
+)
+
+const sdkCgoMetadataPrefix = "\n$$\n\n$$\n\n\n$$  // cgo\n"
+
+// sdkObjectBody observes a compiler metadata prologue only. It cannot supply
+// a dynamic import, linker flag, external call or memory capability.
+func sdkObjectBody(object []byte, target string) ([]byte, error) {
+	end := bytes.Index(object, []byte("\n!\n"))
+	if end < 0 || end > 64<<10 {
+		return nil, contextError("SDK compiler metadata prologue exceeds its byte bound")
+	}
+	metadata := bytes.Index(object[:end], []byte(sdkCgoMetadataPrefix))
+	if metadata < 0 {
+		if bytes.Contains(object[:end], []byte("$$")) || bytes.Contains(object[:end], []byte("// cgo")) {
+			return nil, contextError("SDK compiler metadata has an unregistered prologue spelling")
+		}
+		return objectBody(object, target)
+	}
+	if metadata > 4096 || !bytes.HasSuffix(object[:metadata], []byte("\n\n")) ||
+		!bytes.HasSuffix(object[:end], []byte("\n\n$$\n\n")) {
+		return nil, contextError("SDK compiler metadata lacks its exact export/prologue delimiters")
+	}
+	payload := object[metadata+len(sdkCgoMetadataPrefix) : end-len("\n\n$$\n\n")]
+	var directives [][]string
+	if json.Unmarshal(payload, &directives) != nil || len(directives) == 0 || len(directives) > 1024 {
+		return nil, contextError("SDK compiler metadata is not one bounded complete directive array")
+	}
+	for _, directive := range directives {
+		if !sdkCgoMetadataDirective(directive) {
+			return nil, contextError("SDK compiler metadata has an unknown or incomplete directive row")
+		}
+	}
+	if _, err := objectVersion(object, target); err != nil {
+		return nil, err
+	}
+	return object[end+3:], nil
+}
+
+// This is the complete row grammar in the pinned linker's setCgoAttr. It
+// observes the original rows without applying any of their linker effects.
+func sdkCgoMetadataDirective(row []string) bool {
+	if len(row) < 2 || len(row) > 4 {
+		return false
+	}
+	for _, field := range row {
+		if len(field) > 4096 || strings.ContainsAny(field, "\x00\r\n") {
+			return false
+		}
+	}
+	switch row[0] {
+	case "cgo_import_dynamic":
+		return true
+	case "cgo_import_static", "cgo_dynamic_linker", "cgo_ldflag":
+		return len(row) == 2
+	case "cgo_export_static", "cgo_export_dynamic":
+		return len(row) < 4 || row[3] == "ABI0" || row[3] == "ABIInternal"
+	}
+	return false
+}
diff --git a/internal/gostaticstorage/sdk_object_header_test.go b/internal/gostaticstorage/sdk_object_header_test.go
new file mode 100644
index 000000000..5085902d2
--- /dev/null
+++ b/internal/gostaticstorage/sdk_object_header_test.go
@@ -0,0 +1,94 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestSDKCompilerMetadataPrologueKeepsOwnedHeaderBoundary(t *testing.T) {
+	var directives [][]string
+	for index := 0; index < 160; index++ {
+		directives = append(directives, []string{"cgo_import_dynamic", "local_symbol", "remote_symbol", "native-library"})
+	}
+	payload, err := json.Marshal(directives)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, target := range []string{"darwin/amd64", "windows/amd64", "windows/386"} {
+		header := "go object " + strings.ReplaceAll(target, "/", " ") + " go1.27.2\n\n"
+		object := []byte(header + "\n$$\n\n$$\n\n\n$$  // cgo\n" + string(payload) + "\n\n$$\n\n\n!\nbody")
+		if _, err := objectBody(object, target); !errors.Is(err, ErrContext) {
+			t.Fatalf("%s large SDK prologue widened the legacy owned object reader", target)
+		}
+		body, err := sdkObjectBody(object, target)
+		if err != nil || !bytes.Equal(body, []byte("body")) {
+			t.Fatalf("%s lost the complete stock compiler metadata prologue: %v", target, err)
+		}
+	}
+}
+
+func TestSDKCompilerMetadataPrologueCompleteRowGrammar(t *testing.T) {
+	for _, name := range []string{"cgo_import_dynamic", "cgo_import_static", "cgo_export_static", "cgo_export_dynamic", "cgo_dynamic_linker", "cgo_ldflag"} {
+		for _, count := range []int{0, 1, 2, 3, 4, 5} {
+			row := make([]string, count)
+			for index := range row {
+				row[index] = "symbol"
+			}
+			if count > 0 {
+				row[0] = name
+			}
+			if count == 4 {
+				row[3] = "ABIInternal"
+			}
+			accepted := count == 2
+			if name == "cgo_import_dynamic" || name == "cgo_export_static" || name == "cgo_export_dynamic" {
+				accepted = count >= 2 && count <= 4
+			}
+			if sdkCgoMetadataDirective(row) != accepted {
+				t.Fatalf("complete original linker row changed: %q", row)
+			}
+		}
+	}
+	for _, row := range [][]string{
+		{"cgo_unknown", "name"},
+		{"cgo_export_static", "name", "external", "ABIUnknown"},
+		{"cgo_import_dynamic", "name\x00"},
+		{"cgo_ldflag", "-flag\ninjected"},
+		{"cgo_import_static", strings.Repeat("x", 4097)},
+	} {
+		if sdkCgoMetadataDirective(row) {
+			t.Fatalf("malformed directive supplied a metadata row: %q", row)
+		}
+	}
+}
+
+func TestSDKCompilerMetadataPrologueRejectsUnboundFormat(t *testing.T) {
+	const header = "go object windows amd64 go1.27.2\n\n"
+	wrap := func(payload string) []byte {
+		return []byte(header + sdkCgoMetadataPrefix + payload + "\n\n$$\n\n\n!\nbody")
+	}
+	valid := wrap(`[["cgo_import_dynamic","local","remote","library"]]`)
+	for name, object := range map[string][]byte{
+		"missing-array":    wrap(`{}`),
+		"empty-array":      wrap(`[]`),
+		"empty-directive":  wrap(`[[]]`),
+		"unknown-row":      wrap(`[["unknown","symbol"]]`),
+		"nonstring-field":  wrap(`[["cgo_ldflag",42]]`),
+		"trailing-json":    wrap(`[["cgo_ldflag","-flag"]] []`),
+		"missing-trailer":  bytes.Replace(valid, []byte("\n\n$$\n\n\n!\n"), []byte("\n!\n"), 1),
+		"missing-export":   bytes.Replace(valid, []byte(sdkCgoMetadataPrefix), []byte("\n$$  // cgo\n"), 1),
+		"oversized-body":   wrap(strings.Repeat(" ", 64<<10)),
+		"foreign-target":   bytes.Replace(valid, []byte("windows amd64"), []byte("linux amd64"), 1),
+		"foreign-version":  bytes.Replace(valid, []byte("go1.27.2"), []byte("go1.26.9"), 1),
+		"ordinary-padding": []byte(header + strings.Repeat("x", 4097) + "\n!\nbody"),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := sdkObjectBody(object, "windows/amd64"); !errors.Is(err, ErrContext) {
+				t.Fatalf("unbound metadata supplied a compiler object: %v", err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/sdk_text_kind_test.go b/internal/gostaticstorage/sdk_text_kind_test.go
new file mode 100644
index 000000000..aa6a75082
--- /dev/null
+++ b/internal/gostaticstorage/sdk_text_kind_test.go
@@ -0,0 +1,187 @@
+package gostaticstorage
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// These models exercise the already-pinned current SDK collision role only.
+// The actual archive/enum prior is TestGoSDKFIPSTextKindOriginalArchive; a raw
+// number, name, namespace or successful collision check supplies no provenance.
+func sdkTextKindFixture(kind uint8, abi uint16) indexedObjectSymbol {
+	return indexedObjectSymbol{Namespace: TextSymbolNonpkgDefinition, Name: "fixture.Entry",
+		ABI: abi, Kind: kind, Relative: uint32(abi), Index: uint32(abi), Size: 1}
+}
+
+func sdkTextKindMember(symbol indexedObjectSymbol) ASMDataMember {
+	return ASMDataMember{Texts: []TextRecord{{Namespace: symbol.Namespace,
+		Name: symbol.Name, ABI: symbol.ABI, Kind: symbol.Kind, Flags: symbol.Flags,
+		Relative: symbol.Relative, Index: symbol.Index, Size: int64(symbol.Size), Code: []byte{0xc3}}}}
+}
+
+func TestSDKCurrentTextKindsKeepDistinctABIIdentities(t *testing.T) {
+	for _, kind := range []uint8{1, 2} { // Go 1.27 STEXT and STEXTFIPS, not historical Kind2.
+		t.Run(fmt.Sprintf("kind%d", kind), func(t *testing.T) {
+			compiler, assembly := sdkTextKindFixture(kind, 1), sdkTextKindFixture(kind, 0)
+			compiler.Namespace = TextSymbolSelf
+			for _, order := range []bool{false, true} {
+				t.Run(fmt.Sprintf("assemblyFirst=%t", order), func(t *testing.T) {
+					inputs := []indexedObjectSymbol{compiler, assembly}
+					if order {
+						inputs[0], inputs[1] = inputs[1], inputs[0]
+					}
+					t.Run("archive", func(t *testing.T) {
+						members := []ASMDataMember{sdkTextKindMember(inputs[0]), sdkTextKindMember(inputs[1])}
+						before := []ASMDataMember{sdkTextKindMember(inputs[0]), sdkTextKindMember(inputs[1])}
+						if err := validateASMDataArchiveNames(members); err != nil {
+							t.Fatal("actual text kind was mistaken for multi-ABI storage", err)
+						}
+						if !reflect.DeepEqual(members, before) {
+							t.Fatal("collision checking rewrote or selected an original text body")
+						}
+					})
+					t.Run("named", func(t *testing.T) {
+						observed := make(sdkAssemblyNamedDefinitions)
+						for _, symbol := range inputs {
+							if err := observed.observe(symbol, symbol.ABI == 0); err != nil {
+								t.Fatal("actual text kind lost its separate compiler/assembly identity", err)
+							}
+						}
+						if !reflect.DeepEqual(observed[compiler.Name], inputs) {
+							t.Fatal("named text checking merged ABIs or normalized raw kind/namespace/index")
+						}
+					})
+				})
+			}
+		})
+	}
+}
+
+func TestSDKCurrentTextKindsKeepStorageAndNamespaceBoundaries(t *testing.T) {
+	for _, kind := range []uint8{1, 2} {
+		first := sdkTextKindFixture(kind, 0)
+		for _, abi := range []uint16{0, 1} {
+			for _, reverse := range []bool{false, true} {
+				t.Run(fmt.Sprintf("kind%d/mixed-kind-ABI%d/reverse%t", kind, abi, reverse), func(t *testing.T) {
+					second := sdkTextKindFixture(3-kind, abi)
+					second.Flags = 1
+					inputs := []indexedObjectSymbol{first, second}
+					if reverse {
+						inputs[0], inputs[1] = inputs[1], inputs[0]
+					}
+					// Classifying both kinds as current text does not choose
+					// between differently typed definitions of the same name.
+					members := []ASMDataMember{sdkTextKindMember(inputs[0]), sdkTextKindMember(inputs[1])}
+					if err := validateASMDataArchiveNames(members); !errors.Is(err, ErrContext) {
+						t.Fatal("mixed STEXT/STEXTFIPS bodies acquired an archive winner", err)
+					}
+					observed := make(sdkAssemblyNamedDefinitions)
+					if err := observed.observe(inputs[0], false); err != nil {
+						t.Fatal("original single text definition precondition", err)
+					}
+					if err := observed.observe(inputs[1], false); !errors.Is(err, ErrContext) {
+						t.Fatal("mixed STEXT/STEXTFIPS bodies acquired a named winner", err)
+					}
+				})
+			}
+		}
+		t.Run(fmt.Sprintf("kind%d/same-member-DUPok", kind), func(t *testing.T) {
+			copy := first
+			copy.Flags = 1
+			member := sdkTextKindMember(copy)
+			member.Texts = append(member.Texts, member.Texts[0])
+			if err := validateASMDataArchiveNames([]ASMDataMember{member}); !errors.Is(err, ErrContext) {
+				t.Fatal("DUPok collapsed two same-member text identities", err)
+			}
+		})
+		duplicate, hashed64, hashed, static, reference := first, first, first, first, first
+		duplicate.Flags = 1
+		hashed64.Namespace = TextSymbolHashed64
+		hashed.Namespace = TextSymbolHashed
+		static.ABI = 65535
+		reference.Namespace = TextSymbolNonpkgReference
+		for _, test := range []struct {
+			name   string
+			second indexedObjectSymbol
+			valid  bool
+		}{
+			{"same-ABI-non-DUPok", first, false},
+			{"same-ABI-DUPok", duplicate, true},
+			{"hashed64-local", hashed64, true},
+			{"hashed-local", hashed, true},
+			{"static-local", static, true},
+			{"reference-not-definition", reference, true},
+		} {
+			t.Run(fmt.Sprintf("kind%d/%s", kind, test.name), func(t *testing.T) {
+				observed := make(sdkAssemblyNamedDefinitions)
+				if err := observed.observe(first, false); err != nil {
+					t.Fatal("original current text precondition", err)
+				}
+				err := observed.observe(test.second, false)
+				if test.valid && err != nil || !test.valid && !errors.Is(err, ErrContext) {
+					t.Fatal("text classification changed a same-ABI or namespace boundary", err)
+				}
+				if test.valid {
+					want := []indexedObjectSymbol{first}
+					if test.second.Namespace == TextSymbolNonpkgDefinition && test.second.ABI != 65535 {
+						want = append(want, test.second)
+					}
+					if !reflect.DeepEqual(observed[first.Name], want) {
+						t.Fatal("object-local namespace became a named body winner")
+					}
+				}
+			})
+		}
+		for storage := uint8(3); storage <= 11; storage++ { // Complete current RODATA/DATA/BSS/TLS kinds.
+			t.Run(fmt.Sprintf("kind%d/storage%d", kind, storage), func(t *testing.T) {
+				value := ASMDataDefinition{Namespace: TextSymbolSelf, Name: first.Name, Kind: storage, Flags: 1}
+				other := value
+				other.ABI = 1
+				for _, members := range [][]ASMDataMember{
+					{{Definitions: []ASMDataDefinition{value}}, {Definitions: []ASMDataDefinition{other}}},
+					{{Definitions: []ASMDataDefinition{value}}, sdkTextKindMember(first)},
+				} {
+					if err := validateASMDataArchiveNames(members); !errors.Is(err, ErrContext) {
+						t.Fatal("real storage acquired multiple ABIs or a text identity", err)
+					}
+				}
+				changed := first
+				changed.Kind = storage
+				observed := make(sdkAssemblyNamedDefinitions)
+				if err := observed.observe(first, false); err != nil {
+					t.Fatal(err)
+				}
+				if err := observed.observe(changed, false); !errors.Is(err, ErrContext) {
+					t.Fatal("storage collided with an actual text definition", err)
+				}
+				if err := make(sdkAssemblyNamedDefinitions).observe(changed, true); !errors.Is(err, ErrContext) {
+					t.Fatal("assembly DATA bypassed its independent source/object role", err)
+				}
+			})
+		}
+	}
+	t.Run("FIPS-kind-cannot-mint-GLOBL-storage", func(t *testing.T) {
+		states, member := asmDataIndexedFixture(1)
+		member.Definitions[0].Kind = 2
+		if _, err := joinASMDataLayouts(states, member); !errors.Is(err, ErrContext) {
+			t.Fatal("a forged text kind replaced actual typed DATA storage", err)
+		}
+	})
+}
+
+func TestSDKCurrentTextKindDoesNotRegisterHistoricalObjects(t *testing.T) {
+	// Go 1.20 used 2 for SRODATA. The binary magic alone did not change. A
+	// current-kind collision fix must not expand the authenticated producer set.
+	for _, version := range []string{"go1.20.14", "go1.23.12", "go1.26.9", "go1.27.4"} {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(version+"/"+arch, func(t *testing.T) {
+				object := []byte("go object linux " + arch + " " + version + "\n!\n\x00go120ld")
+				if _, err := objectBody(object, "linux/"+arch); !errors.Is(err, ErrContext) {
+					t.Fatal("a current SymKind number registered a different object producer", err)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/gostaticstorage/source_inventory.go b/internal/gostaticstorage/source_inventory.go
new file mode 100644
index 000000000..709ba8493
--- /dev/null
+++ b/internal/gostaticstorage/source_inventory.go
@@ -0,0 +1,75 @@
+package gostaticstorage
+
+// SDK globals retain the complete recursive original owner tree (including
+// ignored files, separate nested packages and testdata), plus every selected
+// dependency's original Go/ASM/header bytes. This is a larger source role than
+// the flat owned-module prototype, not permission to omit unselected inputs.
+// The same finite accounting applies to capture, live verification and offline
+// report validation. CPU's separately pinned whole inventory stays unchanged.
+type sourceInventoryBudget struct {
+	files int
+	bytes int64
+}
+
+func sourceBudget(protocol string) sourceInventoryBudget {
+	if protocol == SDKGlobalsProtocol {
+		return sourceInventoryBudget{files: 4096, bytes: 64 << 20}
+	}
+	return sourceInventoryBudget{files: 256, bytes: 16 << 20}
+}
+
+func (budget sourceInventoryBudget) checkCount(count int) error {
+	if count > budget.files {
+		return contextError("source inventory bound exceeded")
+	}
+	return nil
+}
+
+func (budget sourceInventoryBudget) checkBytes(total int64, length int) error {
+	if length > 16<<20 {
+		return contextError("source file byte bound exceeded")
+	}
+	if total > budget.bytes || int64(length) > budget.bytes-total {
+		return contextError("source byte bound exceeded")
+	}
+	return nil
+}
+
+type sourceInventoryUsage struct {
+	budget sourceInventoryBudget
+	files  int
+	bytes  int64
+}
+
+func sourceUsage(source map[string][]byte, protocol string) (sourceInventoryUsage, error) {
+	usage := sourceInventoryUsage{budget: sourceBudget(protocol)}
+	if err := usage.budget.checkCount(len(source)); err != nil {
+		return sourceInventoryUsage{}, err
+	}
+	for _, data := range source {
+		if err := usage.add(len(data)); err != nil {
+			return sourceInventoryUsage{}, err
+		}
+	}
+	return usage, nil
+}
+
+// A caller adds only a previously absent source key, after independently
+// checking any duplicate's original bytes. Failed additions leave the complete
+// inventory unchanged and are rejected before bytes enter the retained map.
+func (usage *sourceInventoryUsage) add(length int) error {
+	if err := usage.budget.checkCount(usage.files + 1); err != nil {
+		return err
+	}
+	if err := usage.budget.checkBytes(usage.bytes, length); err != nil {
+		return err
+	}
+	usage.files++
+	usage.bytes += int64(length)
+	return nil
+}
+
+func validateSourceInventory(source map[string][]byte, protocol string) error {
+	_, err := sourceUsage(source, protocol)
+	return err
+}
diff --git a/internal/gostaticstorage/source_snapshot_go127_test.go b/internal/gostaticstorage/source_snapshot_go127_test.go
new file mode 100644
index 000000000..49d7aa2bd
--- /dev/null
+++ b/internal/gostaticstorage/source_snapshot_go127_test.go
@@ -0,0 +1,150 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestGoSDKGlobalCompleteRuntimeSourceInventory(t *testing.T) {
+	_, binary, _ := fixture(t)
+	directory := filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "runtime")
+	var count, total int
+	err := filepath.WalkDir(directory, func(name string, entry os.DirEntry, err error) error {
+		if err != nil || entry.IsDir() {
+			return err
+		}
+		data, err := os.ReadFile(name)
+		if err != nil {
+			return err
+		}
+		count++
+		total += len(data)
+		return nil
+	})
+	if err != nil || count <= 256 {
+		t.Fatal("actual complete runtime counterexample absent", count, err)
+	}
+	observation, err := CaptureSDKGlobals(context.Background(), Request{
+		GoBinary: binary, Directory: directory, PackagePath: "runtime", Target: "linux/amd64",
+		Environment: fixtureEnv(t, "linux/amd64"), Variables: []Reference{{"runtime", "worldsema"}},
+	})
+	if err != nil {
+		t.Fatal("complete actual SDK runtime source/storage capture", err)
+	}
+	defer observation.Close()
+	report, err := observation.Readback(context.Background())
+	if err != nil || ValidateReport(report) != nil {
+		t.Fatal("complete original runtime report", err)
+	}
+	primaryCount, primaryBytes := 0, 0
+	err = filepath.WalkDir(directory, func(name string, entry os.DirEntry, err error) error {
+		if err != nil || entry.IsDir() {
+			return err
+		}
+		data, err := os.ReadFile(name)
+		if err != nil {
+			return err
+		}
+		rel, err := filepath.Rel(directory, name)
+		if err != nil || !bytes.Equal(report.Source[filepath.ToSlash(rel)], data) {
+			t.Fatalf("original runtime member omitted/changed: %s (%v)", rel, err)
+		}
+		primaryCount++
+		primaryBytes += len(data)
+		return nil
+	})
+	if err != nil || primaryCount != count || primaryBytes != total {
+		t.Fatal("complete recursive original inventory changed", err)
+	}
+	variable := report.Variables[0]
+	if variable.NativeName != "runtime.worldsema" || variable.Size != 4 || variable.Kind != 5 ||
+		len(variable.Numerical) != 1 || variable.Numerical[0] != (Span{0, 4}) {
+		t.Fatal("actual original compiler/type numerical storage differs", variable)
+	}
+	// Unselected/test/nested originals remain live input guards. Matching
+	// self-reported hashes cannot authenticate omission or edited bytes.
+	for _, key := range []string{"asm_amd64.s", "sys_linux_amd64.s", "testdata/testprog/abort.go", "asm_arm64.s", "_sdk/internal/abi/abi.go"} {
+		t.Run(key, func(t *testing.T) {
+			if report.Source[key] == nil {
+				t.Fatal("original input is absent", key)
+			}
+			changed := cloneReport(t, report)
+			delete(changed.Source, key)
+			delete(changed.SourceSHA256, key)
+			if !errors.Is(observation.CheckReport(context.Background(), changed), ErrContext) {
+				t.Fatal("omitted complete original member acquired authority", key)
+			}
+		})
+	}
+	for _, name := range []string{"iscgo", "g0", "cgoTraceback"} {
+		t.Run("unsupported-storage-"+name, func(t *testing.T) {
+			bad, err := CaptureSDKGlobals(context.Background(), Request{
+				GoBinary: binary, Directory: directory, PackagePath: "runtime", Target: "linux/amd64",
+				Environment: fixtureEnv(t, "linux/amd64"), Variables: []Reference{{"runtime", name}},
+			})
+			if bad != nil {
+				bad.Close()
+			}
+			if !errors.Is(err, ErrContext) || strings.Contains(err.Error(), "source inventory bound") ||
+				!strings.Contains(err.Error(), "aliased/linkname storage role") && !strings.Contains(err.Error(), "pointer-free variable") {
+				t.Fatal("runtime source budget created an unsupported native storage role", name, err)
+			}
+		})
+	}
+	t.Run("offline-shared-count-bound", func(t *testing.T) {
+		changed := cloneReport(t, report)
+		for index := 0; len(changed.Source) <= 4096; index++ {
+			name := fmt.Sprintf("_sdk/dep/extra-%04d.go", index)
+			changed.Source[name], changed.SourceSHA256[name] = []byte{}, digest(nil)
+		}
+		if err := ValidateReport(changed); !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "source inventory bound exceeded") {
+			t.Fatal("offline report lost the shared complete source count bound", err)
+		}
+	})
+	t.Logf("complete runtime original inventory: files=%d bytes=%d; complete selected graph files=%d", count, total, len(report.Source))
+}
+
+func TestGoSDKGlobalRuntimeSourceAllTargets(t *testing.T) {
+	_, binary, _ := fixture(t)
+	directory := filepath.Join(filepath.Dir(filepath.Dir(binary)), "src", "runtime")
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			environment := fixtureEnv(t, target)
+			// The discovering host-default numerical retry retains CGO=1.
+			// Its runtime graph is still independently required to be pure Go.
+			if target == "linux/amd64" {
+				for index, pair := range environment {
+					if strings.HasPrefix(pair, "CGO_ENABLED=") {
+						environment[index] = "CGO_ENABLED=1"
+					}
+				}
+			}
+			observation, err := CaptureSDKGlobals(context.Background(), Request{
+				GoBinary: binary, Directory: directory, PackagePath: "runtime", Target: target,
+				Environment: environment, Variables: []Reference{{"runtime", "worldsema"}},
+			})
+			if err != nil {
+				t.Fatal("complete actual target SDK runtime source/storage capture", err)
+			}
+			defer observation.Close()
+			report, err := observation.Readback(context.Background())
+			if err != nil || ValidateReport(report) != nil || len(report.Source) <= 256 ||
+				report.Source["asm_amd64.s"] == nil || report.Source["testdata/testprog/abort.go"] == nil ||
+				len(report.Variables) != 1 || report.Variables[0].NativeName != "runtime.worldsema" || report.Variables[0].Size != 4 {
+				t.Fatal("complete target runtime inventory/source/native storage differs", err)
+			}
+			if target == "linux/amd64" && (report.Environment["CGO_ENABLED"] != "1" || report.CommandEnvironment["CGO_ENABLED"] != "1") {
+				t.Fatal("runtime original profile was replaced with CGO=0")
+			}
+			t.Logf("complete actual %s runtime source graph: files=%d", target, len(report.Source))
+		})
+	}
+}
diff --git a/internal/gostaticstorage/source_snapshot_test.go b/internal/gostaticstorage/source_snapshot_test.go
new file mode 100644
index 000000000..7359a45c0
--- /dev/null
+++ b/internal/gostaticstorage/source_snapshot_test.go
@@ -0,0 +1,192 @@
+package gostaticstorage
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func snapshotFixtureDirectory(t *testing.T) string {
+	t.Helper()
+	directory, err := sourcepath.Resolve(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	return directory
+}
+
+func TestStaticStorageCapturePreservesSourceInventoryDiagnostic(t *testing.T) {
+	directory := snapshotFixtureDirectory(t)
+	for index := 0; index < 257; index++ {
+		if err := os.WriteFile(filepath.Join(directory, fmt.Sprintf("source-%03d.go", index)), []byte("package fixture\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	request := Request{GoBinary: filepath.Join(directory, "go"), Directory: directory,
+		PackagePath: "example.invalid/fixture", Target: "linux/amd64", Variables: []Reference{{"example.invalid/fixture", "V"}}}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		request.Environment = append(request.Environment, key+"="+directory)
+	}
+	observation, err := Capture(context.Background(), request)
+	if observation != nil {
+		observation.Close()
+	}
+	if !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "source inventory bound exceeded") {
+		t.Fatal("underlying source inventory failure was discarded", err)
+	}
+}
+
+func TestStaticStorageSourceInventoryRoleBounds(t *testing.T) {
+	for _, test := range []struct {
+		protocol string
+		files    int
+		bytes    int64
+	}{
+		{Protocol, 256, 16 << 20},
+		{SDKCPUProtocol, 256, 16 << 20},
+		{SDKGlobalsProtocol, 4096, 64 << 20},
+		{"unknown", 256, 16 << 20},
+	} {
+		t.Run(test.protocol, func(t *testing.T) {
+			budget := sourceBudget(test.protocol)
+			if budget.files != test.files || budget.bytes != test.bytes {
+				t.Fatal("source role borrowed another inventory budget", budget)
+			}
+			if err := budget.checkBytes(test.bytes-1, 1); err != nil {
+				t.Fatal("exact complete byte boundary", err)
+			}
+			for _, test := range []struct {
+				total  int64
+				length int
+			}{{test.bytes, 1}, {test.bytes + 1, 0}, {0, 16<<20 + 1}} {
+				if !errors.Is(budget.checkBytes(test.total, test.length), ErrContext) {
+					t.Fatal("over-bound bytes acquired source authority", test)
+				}
+			}
+			source := make(map[string][]byte)
+			for index := 0; index < test.files; index++ {
+				source[fmt.Sprintf("source-%04d.go", index)] = nil
+			}
+			if err := validateSourceInventory(source, test.protocol); err != nil {
+				t.Fatal("exact complete count boundary", err)
+			}
+			// Selected dependencies consume the same budget as the whole
+			// original primary tree, never a second unlimited inventory.
+			source["_sdk/dep/extra.go"] = nil
+			if !errors.Is(validateSourceInventory(source, test.protocol), ErrContext) {
+				t.Fatal("selected dependency bypassed shared complete count bound")
+			}
+			block := make([]byte, 16<<20)
+			complete := make(map[string][]byte)
+			for index := int64(0); index < test.bytes/(16<<20); index++ {
+				complete[fmt.Sprintf("input-%d.go", index)] = block
+			}
+			if err := validateSourceInventory(complete, test.protocol); err != nil {
+				t.Fatal("exact complete aggregate byte boundary", err)
+			}
+			complete["_sdk/dep/extra.go"] = []byte{1}
+			if !errors.Is(validateSourceInventory(complete, test.protocol), ErrContext) {
+				t.Fatal("selected dependency bypassed shared complete byte bound")
+			}
+		})
+	}
+}
+
+func TestStaticStorageSnapshotRetainsCompleteRecursiveTree(t *testing.T) {
+	directory := snapshotFixtureDirectory(t)
+	for index := 0; index < 4096; index++ {
+		name := fmt.Sprintf("nested/package/testdata/input-%04d", index)
+		file := filepath.Join(directory, filepath.FromSlash(name))
+		if index == 0 {
+			if err := os.MkdirAll(filepath.Dir(file), 0700); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if err := os.WriteFile(file, []byte(name), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	for _, protocol := range []string{Protocol, SDKCPUProtocol} {
+		if _, err := snapshot(directory, protocol); !errors.Is(err, ErrContext) {
+			t.Fatal("small module/CPU source role widened", protocol, err)
+		}
+	}
+	source, err := snapshot(directory, SDKGlobalsProtocol)
+	if err != nil || len(source) != 4096 || string(source["nested/package/testdata/input-4095"]) != "nested/package/testdata/input-4095" {
+		t.Fatal("complete recursive SDK original tree omitted a member", len(source), err)
+	}
+	if err := os.WriteFile(filepath.Join(directory, "extra.go"), []byte("package extra\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := snapshot(directory, SDKGlobalsProtocol); !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "source inventory bound exceeded") {
+		t.Fatal("over-bound SDK recursive tree accepted", err)
+	}
+	// Verify uses that identical source budget and preserves its cause. It
+	// fails before any actual command and permanently revokes this test state.
+	observation := &Observation{ready: true, request: Request{Directory: directory}, report: Report{Protocol: SDKGlobalsProtocol}}
+	encoded, err := json.Marshal(observation.report)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observation.seal = sha256.Sum256(encoded)
+	if err := observation.Verify(context.Background()); !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "source inventory bound exceeded") {
+		t.Fatal("live snapshot discarded its identical original source bound", err)
+	}
+	if err := observation.Verify(context.Background()); !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "revoked") {
+		t.Fatal("failed source inventory revived the observation", err)
+	}
+}
+
+func TestStaticStorageSourceRootAndCPUFailuresRetainCause(t *testing.T) {
+	directory := snapshotFixtureDirectory(t)
+	request := Request{GoBinary: filepath.Join(directory, "bin", "go"), Directory: filepath.Join(directory, "missing"),
+		PackagePath: "example.invalid/fixture", Target: "linux/amd64", Variables: []Reference{{"example.invalid/fixture", "V"}}}
+	if _, err := Capture(context.Background(), request); !errors.Is(err, ErrContext) || !errors.Is(err, os.ErrNotExist) {
+		t.Fatal("missing original source root lost its actual filesystem cause", err)
+	}
+	request.Directory, request.PackagePath = filepath.Join(directory, "src", "internal", "cpu"), "internal/cpu"
+	if err := os.MkdirAll(request.Directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		request.Environment = append(request.Environment, key+"="+directory)
+	}
+	if _, err := CaptureSDKCPU(context.Background(), request); !errors.Is(err, ErrContext) || !strings.Contains(err.Error(), "original SDK CPU source inventory differs") {
+		t.Fatal("pinned SDK CPU source role failure was discarded", err)
+	}
+}
+
+func TestStaticStorageSourceUsageRejectsBeforeAddition(t *testing.T) {
+	for _, protocol := range []string{Protocol, SDKCPUProtocol, SDKGlobalsProtocol} {
+		t.Run(protocol, func(t *testing.T) {
+			budget := sourceBudget(protocol)
+			usage := sourceInventoryUsage{budget: budget, files: budget.files, bytes: 1}
+			before := usage
+			if !errors.Is(usage.add(1), ErrContext) || usage != before {
+				t.Fatal("failed count addition altered retained inventory", usage)
+			}
+			usage.files, usage.bytes = 1, budget.bytes
+			before = usage
+			if !errors.Is(usage.add(1), ErrContext) || usage != before {
+				t.Fatal("failed byte addition altered retained inventory", usage)
+			}
+			usage.bytes = budget.bytes - 1
+			if err := usage.add(1); err != nil || usage.files != 2 || usage.bytes != budget.bytes {
+				t.Fatal("exact complete boundary addition differs", usage, err)
+			}
+			original := map[string][]byte{"primary.go": {1, 2}, "_sdk/dep/dep.go": {3}}
+			usage, err := sourceUsage(original, protocol)
+			if err != nil || usage.files != 2 || usage.bytes != 3 {
+				t.Fatal("complete initial primary/dependency accounting differs", usage, err)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/text.go b/internal/gostaticstorage/text.go
new file mode 100644
index 000000000..40d270780
--- /dev/null
+++ b/internal/gostaticstorage/text.go
@@ -0,0 +1,411 @@
+package gostaticstorage
+
+import (
+	"encoding/binary"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"math"
+	"strconv"
+	"strings"
+)
+
+const TextProtocol = "actual_go_text_records_observation_v2"
+const builtinSourceRole = "src/cmd/internal/goobj/builtinlist.go"
+
+// These are binary observations, not decoded instruction/read, TEXT entry,
+// caller, pointer or result certificates. Wasm Size/Positions use Go virtual
+// PCs; Code/Relocation offsets still address physical object bytes.
+type TextReference struct {
+	PackageIndex, SymbolIndex uint32
+	Package, Name             string
+	ABI                       uint16
+	ABIKnown                  bool
+	Kind                      uint8
+	KindKnown                 bool
+}
+
+type TextRelocation struct {
+	Offset, Size int64
+	Type         uint16
+	Add          int64
+	Target       TextReference
+}
+
+type TextAuxiliary struct {
+	Type   uint8
+	Target TextReference
+}
+
+type TextPosition struct {
+	Start, End int64
+	File       string
+	Line       int32
+}
+
+type TextRecord struct {
+	Index          uint32
+	Namespace      TextSymbolNamespace
+	Relative       uint32
+	Hash           []byte
+	Name           string
+	ABI            uint16
+	Kind           uint8
+	Flags, Flags2  uint8
+	Size           int64
+	Code           []byte
+	Relocations    []TextRelocation
+	Auxiliary      []TextAuxiliary
+	PCFile, PCLine []byte
+	Positions      []TextPosition
+}
+
+type TextMember struct {
+	Name         string
+	Offset, Size int64
+	Flags        uint32
+	Texts        []TextRecord
+}
+
+func textBuiltins(source []byte) ([]TextReference, error) {
+	return textBuiltinsForDigest(source, formatSources[builtinSourceRole])
+}
+
+func textBuiltinsForDigest(source []byte, expected string) ([]TextReference, error) {
+	if digest(source) != expected {
+		return nil, contextError("TEXT builtin source differs from the selected SDK")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), builtinSourceRole, source, 0)
+	if err != nil {
+		return nil, contextError("invalid original builtin table")
+	}
+	var result []TextReference
+	for _, declaration := range file.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.VAR {
+			continue
+		}
+		for _, specification := range group.Specs {
+			value, ok := specification.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || value.Names[0].Name != "builtins" || len(value.Values) != 1 {
+				return nil, contextError("unknown builtin source declaration")
+			}
+			table, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok || len(table.Elts) == 0 || len(table.Elts) > symbolLimit {
+				return nil, contextError("invalid bounded builtin inventory")
+			}
+			for _, element := range table.Elts {
+				pair, ok := element.(*ast.CompositeLit)
+				if !ok || len(pair.Elts) != 2 {
+					return nil, contextError("unknown builtin pair")
+				}
+				name, nameOK := pair.Elts[0].(*ast.BasicLit)
+				abi, abiOK := pair.Elts[1].(*ast.BasicLit)
+				if !nameOK || !abiOK {
+					return nil, contextError("nonliteral builtin identity")
+				}
+				text, textErr := strconv.Unquote(name.Value)
+				number, abiErr := strconv.ParseUint(abi.Value, 10, 16)
+				if textErr != nil || abiErr != nil || text == "" {
+					return nil, contextError("invalid builtin name/ABI")
+				}
+				result = append(result, TextReference{Name: text, ABI: uint16(number), ABIKnown: true})
+			}
+		}
+	}
+	if len(result) == 0 {
+		return nil, contextError("missing actual builtin inventory")
+	}
+	return result, nil
+}
+
+func textArchives(report Report, packages map[string]Package) (map[string][]TextMember, error) {
+	if report.Protocol == SDKGlobalsProtocol {
+		return sdkGlobalMembers(report, packages)
+	}
+	builtins, err := textBuiltins(report.TextBuiltinSource)
+	if err != nil {
+		return nil, err
+	}
+	result := make(map[string][]TextMember, len(packages))
+	for path, pkg := range packages {
+		archive := report.Archives[path]
+		// Reuse the existing source/member role admission unchanged. The
+		// following parser supplies metadata, not another admission path.
+		if report.Protocol == SDKCPUProtocol {
+			_, err = readSDKCPUArchive(archive, report.Target, pkg.SFiles)
+		} else {
+			_, err = readArchive(archive, report.Target)
+		}
+		if err != nil {
+			return nil, err
+		}
+		result[path], err = readTextArchive(archive, report.Target, report.Protocol == SDKCPUProtocol, builtins)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return result, nil
+}
+
+func readTextArchive(data []byte, target string, sdkCPU bool, builtins []TextReference) ([]TextMember, error) {
+	members, err := archiveMembers(data)
+	if err != nil {
+		return nil, err
+	}
+	var result []TextMember
+	for index, member := range members {
+		value := TextMember{Name: member.name, Offset: member.offset, Size: int64(len(member.data))}
+		if index != 0 {
+			if sdkCPU {
+				value.Flags = sdkCompilerObjectFlags(target)
+				if index != 1 {
+					value.Flags |= 4
+				}
+			}
+			reader := objectBody
+			if sdkCPU && index == 1 {
+				reader = sdkObjectBody
+			}
+			body, err := reader(member.data, target)
+			if err != nil {
+				return nil, err
+			}
+			value.Texts, err = readTextObject(body, target, value.Flags, sdkCPU && index != 1, builtins)
+			if err != nil {
+				return nil, err
+			}
+		}
+		result = append(result, value)
+	}
+	return result, nil
+}
+
+func readTextObject(data []byte, target string, flags uint32, empty bool, builtins []TextReference) ([]TextRecord, error) {
+	return readTextObjectReferences(data, target, flags, empty, builtins, nil)
+}
+
+func readTextObjectReferences(data []byte, target string, flags uint32, empty bool, builtins []TextReference, referenced sdkReferencedSymbols) ([]TextRecord, error) {
+	return readTextObjectKinds(data, target, flags, empty, builtins, referenced, true)
+}
+
+func readTextObjectKinds(data []byte, target string, flags uint32, empty bool, builtins []TextReference, referenced sdkReferencedSymbols, fipsText bool) ([]TextRecord, error) {
+	object, err := checkedObject(data, flags, empty)
+	if err != nil {
+		return nil, err
+	}
+	return readCheckedTextObjectKinds(object, target, builtins, referenced, fipsText)
+}
+
+func readCheckedTextObjectKinds(object *checkedGoObject, target string, builtins []TextReference, referenced sdkReferencedSymbols, fipsText bool) ([]TextRecord, error) {
+	block := object.block
+	definitions, err := object.indexedSymbols()
+	if err != nil {
+		return nil, err
+	}
+	resolve, counts, err := objectReferenceResolver(object, builtins, referenced)
+	if err != nil {
+		return nil, err
+	}
+	// Validate unused reference/auxiliary records too: an overflowing reference
+	// cannot hide behind another requested TEXT or a DATA-only definition.
+	for _, spec := range []struct{ block, width, start int }{{8, 10, 0}, {14, 23, 15}, {15, 9, 1}, {17, 16, 0}} {
+		for pos := 0; pos < len(block(spec.block)); pos += spec.width {
+			if _, err := resolve(block(spec.block)[pos+spec.start : pos+spec.start+8]); err != nil {
+				return nil, err
+			}
+		}
+	}
+	// All values come from the hash-bound Go1.27.1 objabi/goobj sources.
+	// Enumerating a relocation kind records its identity, not read/address
+	// permission or a decoded addend. Validate unused records as well.
+	for pos := 0; pos < len(block(14)); pos += 23 {
+		kind := binary.LittleEndian.Uint16(block(14)[pos+5:])
+		if !(kind >= 1 && kind <= 106 || kind == 0x8001 || kind == 0x8005) {
+			return nil, contextError("unknown original Go relocation kind")
+		}
+	}
+	for pos := 0; pos < len(block(15)); pos += 9 {
+		if block(15)[pos] > 14 {
+			return nil, contextError("unknown original Go auxiliary kind")
+		}
+	}
+	_, arch, _ := strings.Cut(target, "/")
+	minLC := int64(1)
+	if arch == "arm" || arch == "arm64" {
+		minLC = 4
+	}
+	if arch != "386" && arch != "amd64" && arch != "arm" && arch != "arm64" && arch != "wasm" {
+		return nil, contextError("unknown TEXT PC target")
+	}
+	var result []TextRecord
+	for index := 0; index < object.count; index++ {
+		definition := definitions[index]
+		if definition.Kind != 1 && !(fipsText && currentSDKObjectIsText(definition.Kind)) {
+			continue
+		}
+		value := TextRecord{Index: uint32(index), Namespace: definition.Namespace, Relative: definition.Relative,
+			Hash: append([]byte(nil), definition.Hash...), Name: definition.Name, ABI: definition.ABI,
+			Kind: definition.Kind, Flags: definition.Flags, Flags2: definition.Flags2, Size: int64(definition.Size)}
+		start, end := object.indices[2][index], object.indices[2][index+1]
+		value.Code = append([]byte(nil), block(16)[start:end]...)
+		if value.Size > archiveLimit || arch != "wasm" && value.Size != int64(len(value.Code)) {
+			return nil, contextError("TEXT native/virtual code extent differs")
+		}
+		for j := object.indices[0][index]; j < object.indices[0][index+1]; j++ {
+			q := block(14)[int(j)*23 : int(j+1)*23]
+			ref, _ := resolve(q[15:])
+			r := TextRelocation{Offset: int64(int32(binary.LittleEndian.Uint32(q))), Size: int64(q[4]), Type: binary.LittleEndian.Uint16(q[5:]), Add: int64(binary.LittleEndian.Uint64(q[7:])), Target: ref}
+			if r.Offset < 0 || r.Size > int64(len(value.Code)) || r.Offset > int64(len(value.Code))-r.Size || r.Type == 0 {
+				return nil, contextError("TEXT physical relocation exceeds its code")
+			}
+			value.Relocations = append(value.Relocations, r)
+		}
+		var pcfile, pcline []byte
+		seen := make(map[uint8]bool)
+		for j := object.indices[1][index]; j < object.indices[1][index+1]; j++ {
+			q := block(15)[int(j)*9 : int(j+1)*9]
+			ref, _ := resolve(q[1:])
+			if q[0] > 14 || q[0] == 8 && seen[8] || q[0] == 9 && seen[9] {
+				return nil, contextError("unknown or duplicate TEXT PC auxiliary record")
+			}
+			seen[q[0]] = true
+			value.Auxiliary = append(value.Auxiliary, TextAuxiliary{q[0], ref})
+			if q[0] != 8 && q[0] != 9 {
+				continue
+			}
+			if ref.PackageIndex != 2147483645 {
+				return nil, contextError("TEXT PC table lacks its actual hashed data role")
+			}
+			id := int(ref.SymbolIndex) + counts[0] + counts[1]
+			from, to := object.indices[2][id], object.indices[2][id+1]
+			if q[0] == 8 {
+				pcfile = block(16)[from:to]
+			} else {
+				pcline = block(16)[from:to]
+			}
+		}
+		positions, err := textPositions(pcfile, pcline, value.Size, minLC, object)
+		if err != nil {
+			return nil, err
+		}
+		value.Positions = positions
+		value.PCFile, value.PCLine = append([]byte(nil), pcfile...), append([]byte(nil), pcline...)
+		result = append(result, value)
+	}
+	return result, nil
+}
+
+type pcValueSpan struct{ start, end, value int64 }
+
+func textPCTable(data []byte, extent, minLC int64) ([]pcValueSpan, error) {
+	if extent < 0 || extent > archiveLimit || minLC != 1 && minLC != 4 {
+		return nil, contextError("invalid bounded TEXT PC extent/quantum")
+	}
+	var result []pcValueSpan
+	pc, value := int64(0), int64(-1)
+	read := func() (uint32, error) {
+		var number uint32
+		for shift := uint(0); shift <= 28; shift += 7 {
+			if len(data) == 0 || shift == 28 && data[0] > 15 {
+				return 0, contextError("truncated or overflowing TEXT PC varint")
+			}
+			b := data[0]
+			data = data[1:]
+			number |= uint32(b&127) << shift
+			if b&128 == 0 {
+				if shift != 0 && b == 0 {
+					return 0, contextError("noncanonical TEXT PC varint")
+				}
+				return number, nil
+			}
+		}
+		return 0, contextError("oversized TEXT PC varint")
+	}
+	for len(result) < symbolLimit {
+		delta, err := read()
+		if err != nil {
+			return nil, err
+		}
+		if delta == 0 && len(result) != 0 {
+			if len(data) != 0 || pc != extent {
+				return nil, contextError("TEXT PC table has a tail or incomplete extent")
+			}
+			return result, nil
+		}
+		change := int64(delta >> 1)
+		if delta&1 != 0 {
+			change = -change - 1
+		}
+		value += change
+		distance, err := read()
+		// The pinned funcpctab writer can emit one (value, zero-distance)
+		// pair for a TEXT-only function. Its logical PC domain is empty;
+		// physical wasm bytes are deliberately not constrained by this role.
+		zeroPC := extent == 0 && len(result) == 0 && distance == 0
+		if err != nil || distance == 0 && !zeroPC || value < math.MinInt32 || value > math.MaxInt32 {
+			return nil, contextError("invalid TEXT PC/value delta")
+		}
+		end := pc + int64(distance)*minLC
+		if end <= pc && !zeroPC || end > extent {
+			return nil, contextError("overflowing or oversized TEXT PC interval")
+		}
+		result = append(result, pcValueSpan{pc, end, value})
+		pc = end
+	}
+	return nil, contextError("TEXT PC interval inventory exceeds its bound")
+}
+
+func textPositions(files, lines []byte, extent, minLC int64, object *checkedGoObject) ([]TextPosition, error) {
+	if len(files) == 0 && len(lines) == 0 {
+		if extent == 0 {
+			return nil, nil
+		}
+		return []TextPosition{{0, extent, "", 0}}, nil
+	}
+	fileSpans, err := textPCTable(files, extent, minLC)
+	if err != nil {
+		return nil, err
+	}
+	lineSpans, err := textPCTable(lines, extent, minLC)
+	if err != nil {
+		return nil, err
+	}
+	var result []TextPosition
+	for f, l := 0, 0; f < len(fileSpans) && l < len(lineSpans); {
+		file, line := fileSpans[f], lineSpans[l]
+		if file.value < 0 || file.value >= int64(len(object.block(2))/8) {
+			return nil, contextError("TEXT PC file index out of bounds")
+		}
+		name, err := object.stringAt(object.block(2)[file.value*8 : (file.value+1)*8])
+		if err != nil {
+			return nil, err
+		}
+		start, end := file.start, file.end
+		if line.start > start {
+			start = line.start
+		}
+		if line.end < end {
+			end = line.end
+		}
+		if end > extent {
+			end = extent
+		}
+		if start < end {
+			value := TextPosition{start, end, name, int32(line.value)}
+			last := len(result) - 1
+			if last >= 0 && result[last].End == start && result[last].File == name && result[last].Line == value.Line {
+				result[last].End = end
+			} else {
+				result = append(result, value)
+			}
+		}
+		if file.end <= line.end {
+			f++
+		}
+		if line.end <= file.end {
+			l++
+		}
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/text_go127_test.go b/internal/gostaticstorage/text_go127_test.go
new file mode 100644
index 000000000..a7da24a81
--- /dev/null
+++ b/internal/gostaticstorage/text_go127_test.go
@@ -0,0 +1,475 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func retainTextArtifact(t *testing.T, target, role string, files map[string][]byte) {
+	t.Helper()
+	if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+		folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"), role)
+		if err := os.MkdirAll(folder, 0700); err != nil {
+			t.Fatal(err)
+		}
+		for name, data := range files {
+			if err := os.WriteFile(filepath.Join(folder, name), data, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
+
+// This reader uses the selected SDK's binary readers and PCToLine. It does not
+// call the production parser or derive a source read/native-entry permission.
+const sdkTextReaderSource = `package main
+
+import (
+	"cmd/internal/archive"
+	"cmd/internal/goobj"
+	"cmd/internal/objfile"
+	"encoding/json"
+	"fmt"
+	"os"
+)
+
+type Ref struct {
+	PackageIndex, SymbolIndex uint32
+	Package, Name             string
+	ABI                       uint16
+	ABIKnown                  bool
+	// This reader observes the existing default TEXT role, which does not
+	// admit referenced-archive kind metadata. Keep that provenance explicit.
+	Kind                      uint8
+	KindKnown                 bool
+}
+type Reloc struct {
+	Offset, Size int64
+	Type         uint16
+	Add          int64
+	Target       Ref
+}
+type Aux struct {
+	Type   uint8
+	Target Ref
+}
+type Position struct {
+	Start, End int64
+	File       string
+	Line       int32
+}
+type Text struct {
+	Index         uint32
+	Namespace     uint8
+	Relative      uint32
+	Hash          []byte
+	Name          string
+	ABI           uint16
+	Kind          uint8
+	Flags, Flags2 uint8
+	Size          int64
+	Code          []byte
+	Relocations   []Reloc
+	Auxiliary     []Aux
+	PCFile, PCLine []byte
+	Positions     []Position
+}
+type Member struct {
+	Name         string
+	Offset, Size int64
+	Flags        uint32
+	Texts        []Text
+}
+
+func main() {
+	f, err := os.Open(os.Args[1])
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	a, err := archive.Parse(f, false)
+	if err != nil {
+		panic(err)
+	}
+	o, err := objfile.Open(os.Args[1])
+	if err != nil {
+		panic(err)
+	}
+	defer o.Close()
+	entries := map[string]*objfile.Entry{}
+	for _, e := range o.Entries() {
+		if entries[e.Name()] != nil {
+			panic("duplicate entry")
+		}
+		entries[e.Name()] = e
+	}
+	result := []Member{}
+	for _, e := range a.Entries {
+		m := Member{Name: e.Name, Offset: e.Offset, Size: e.Size}
+		if e.Type != archive.EntryPkgDef && e.Type != archive.EntryGoObj {
+			panic("unknown member")
+		}
+		if e.Type == archive.EntryGoObj {
+			data := make([]byte, e.Obj.Size)
+			n, err := f.ReadAt(data, e.Obj.Offset)
+			if err != nil || n != len(data) {
+				panic(fmt.Sprint(n, err))
+			}
+			r := goobj.NewReaderFromBytes(data, false)
+			if r == nil {
+				panic("goobj")
+			}
+			m.Flags = r.Flags()
+			refs := map[goobj.SymRef]string{}
+			for i := 0; i < r.NRefName(); i++ {
+				q := r.RefName(i)
+				refs[q.Sym()] = q.Name(r)
+			}
+			resolve := func(q goobj.SymRef) Ref {
+				v := Ref{PackageIndex: q.PkgIdx, SymbolIndex: q.SymIdx}
+				var index uint32
+				switch q.PkgIdx {
+				case goobj.PkgIdxInvalid:
+					return v
+				case goobj.PkgIdxSelf:
+					index = q.SymIdx
+				case goobj.PkgIdxHashed64:
+					index = q.SymIdx + uint32(r.NSym())
+				case goobj.PkgIdxHashed:
+					index = q.SymIdx + uint32(r.NSym()+r.NHashed64def())
+				case goobj.PkgIdxNone:
+					index = q.SymIdx + uint32(r.NSym()+r.NHashed64def()+r.NHasheddef())
+				case goobj.PkgIdxBuiltin:
+					name, abi := goobj.BuiltinName(int(q.SymIdx))
+					v.Name = name
+					v.ABI = uint16(abi)
+					v.ABIKnown = true
+					return v
+				default:
+					v.Package = r.Pkg(int(q.PkgIdx))
+					v.Name = refs[q]
+					return v
+				}
+				s := r.Sym(index)
+				v.Name = s.Name(r)
+				v.ABI = s.ABI()
+				v.ABIKnown = true
+				return v
+			}
+			entry := entries[e.Name]
+			if entry == nil {
+				panic("missing objfile entry")
+			}
+			liner, err := entry.PCLineTable()
+			if err != nil {
+				panic(err)
+			}
+			count := r.NSym() + r.NHashed64def() + r.NHasheddef() + r.NNonpkgdef()
+			for i := 0; i < count; i++ {
+				s := r.Sym(uint32(i))
+				if s.Type() != 1 && s.Type() != 2 {
+					continue
+				}
+				v := Text{Index: uint32(i), Name: s.Name(r), ABI: s.ABI(), Kind: s.Type(), Flags: s.Flag(), Flags2: s.Flag2(), Size: int64(s.Siz()), Code: r.Data(uint32(i))}
+				start := 0
+				for namespace, count := range []int{r.NSym(), r.NHashed64def(), r.NHasheddef(), r.NNonpkgdef()} {
+					if i < start + count {
+						v.Namespace = uint8(namespace)
+						v.Relative = uint32(i - start)
+						break
+					}
+					start += count
+				}
+				if v.Namespace == 1 {
+					hash := r.Hash64(v.Relative)
+					v.Hash = make([]byte, 8)
+					for index := range v.Hash {
+						v.Hash[index] = byte(hash >> (8 * index))
+					}
+				}
+				if v.Namespace == 2 {
+					v.Hash = append([]byte(nil), r.Hash(v.Relative)[:]...)
+				}
+				for j := 0; j < r.NReloc(uint32(i)); j++ {
+					q := r.Reloc(uint32(i), j)
+					v.Relocations = append(v.Relocations, Reloc{int64(q.Off()), int64(q.Siz()), q.Type(), q.Add(), resolve(q.Sym())})
+				}
+				for j := 0; j < r.NAux(uint32(i)); j++ {
+					q := r.Aux(uint32(i), j)
+					v.Auxiliary = append(v.Auxiliary, Aux{q.Type(), resolve(q.Sym())})
+					if q.Type() == goobj.AuxPcfile || q.Type() == goobj.AuxPcline {
+						ref := q.Sym()
+						if ref.PkgIdx != goobj.PkgIdxHashed {
+							panic("unexpected original PC data role")
+						}
+						data := r.Data(ref.SymIdx + uint32(r.NSym()+r.NHashed64def()))
+						if q.Type() == goobj.AuxPcfile {
+							v.PCFile = data
+						} else {
+							v.PCLine = data
+						}
+					}
+				}
+				for pc := int64(0); pc < int64(s.Siz()); pc++ {
+					file, line, _ := liner.PCToLine(uint64(r.DataOff(uint32(i))) + uint64(pc))
+					k := len(v.Positions) - 1
+					if k >= 0 && v.Positions[k].File == file && v.Positions[k].Line == int32(line) {
+						v.Positions[k].End = pc + 1
+					} else {
+						v.Positions = append(v.Positions, Position{pc, pc + 1, file, int32(line)})
+					}
+				}
+				m.Texts = append(m.Texts, v)
+			}
+		}
+		result = append(result, m)
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(result); err != nil {
+		panic(err)
+	}
+}
+`
+
+func TestGoStaticStorageTEXTActualSourceReport(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			_, report := captured(t, request(t, dir, binary, target))
+			encoded, err := json.Marshal(report)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var envelope map[string]json.RawMessage
+			if err := json.Unmarshal(encoded, &envelope); err != nil {
+				t.Fatal(err)
+			}
+			var recorded map[string]json.RawMessage
+			if err := json.Unmarshal(envelope["TextArchives"], &recorded); err != nil {
+				// Keep observing the real original object before reporting RED.
+				recorded = nil
+			}
+			packages, err := reportPackages(report, dir)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, path := range []string{fixtureModule, fixtureModule + "/dep"} {
+				raw := run(t, oracle, dir, fixtureEnv(t, target), packages[path].Export)
+				var original []map[string]json.RawMessage
+				if err := json.Unmarshal(raw, &original); err != nil || len(original) != 2 {
+					t.Fatalf("actual original archive oracle failed: %v", err)
+				}
+				if artifact := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); artifact != "" {
+					folder := filepath.Join(artifact, strings.ReplaceAll(target, "/", "-"), strings.TrimPrefix(path, fixtureModule))
+					if err := os.MkdirAll(folder, 0700); err != nil {
+						t.Fatal(err)
+					}
+					for name, data := range map[string][]byte{"text-sdk.json": raw, "text-report.json": encoded, "text-original.a": report.Archives[path]} {
+						if err := os.WriteFile(filepath.Join(folder, name), data, 0600); err != nil {
+							t.Fatal(err)
+						}
+					}
+				}
+				t.Logf("ORIGINAL_TEXT %s %s archiveSHA256=%s members=%d", target, path, report.ArchiveSHA256[path], len(original))
+				var actual any
+				if err := json.Unmarshal(raw, &actual); err != nil {
+					t.Fatal(err)
+				}
+				var claimed any
+				if err := json.Unmarshal(recorded[path], &claimed); err != nil || !reflect.DeepEqual(actual, claimed) {
+					t.Errorf("actual selected source/archive lacks complete TEXT relocation Add/Sym/Aux/source-PC readback: %s", path)
+				}
+			}
+		})
+	}
+}
+
+func TestGoSDKStaticStorageTEXTAllOriginalMembers(t *testing.T) {
+	_, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			_, report := sdkCaptured(t, sdkRequest(t, binary, target))
+			packages, err := sdkCPUPackages(report)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, report.CommandDirectory, fixtureEnv(t, target), packages["internal/cpu"].Export)
+			var original []TextMember
+			if err := json.Unmarshal(raw, &original); err != nil {
+				t.Fatal(err)
+			}
+			if !reflect.DeepEqual(original, report.TextArchives["internal/cpu"]) {
+				t.Fatal("complete original SDK member/TEXT/relocation/PC identity differs")
+			}
+			if target == "linux/386" || target == "linux/amd64" {
+				observed, err := ObserveX86SDKAssemblyArchive(report.Archives["internal/cpu"], report.TextBuiltinSource,
+					target, packages["internal/cpu"].SFiles)
+				if err != nil || !reflect.DeepEqual(observed, original) {
+					t.Fatal("SDK-only x86 archive observation differs from the independent complete SDK reader", err)
+				}
+			}
+			encoded, err := json.MarshalIndent(report, "", "  ")
+			if err != nil {
+				t.Fatal(err)
+			}
+			retainTextArtifact(t, target, "sdk-text", map[string][]byte{
+				"text-sdk.json": raw, "text-report.json": encoded, "text-original.a": report.Archives["internal/cpu"],
+			})
+			t.Logf("SDK_ORIGINAL_TEXT %s archiveSHA256=%s members=%d", target, report.ArchiveSHA256["internal/cpu"], len(original))
+		})
+	}
+}
+
+func TestGoStaticStorageTEXTX86ActualRelocationAddend(t *testing.T) {
+	dir, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	for _, target := range []string{"linux/386", "linux/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			_, owner := sdkCaptured(t, sdkRequest(t, binary, target))
+			var offset int64 = -1
+			for _, variable := range owner.Variables {
+				if variable.Name == "X86" && len(variable.Numerical) == 1 {
+					offset = variable.Numerical[0].Offset
+				}
+			}
+			if offset < 0 {
+				t.Fatal("missing actual target numerical CPU field span")
+			}
+			// This is an object-format counterexample, not a read permission.
+			// CPU's first numerical field is HasAES; raw Add alone is not its
+			// source offset when the instruction has trailing immediate bytes.
+			source := "#include \"textflag.h\"\nTEXT ·Witness(SB),NOSPLIT,$0-0\n" +
+				"CMPB internal∕cpu·X86+" + strconv.FormatInt(offset, 10) + "(SB), $1\n" +
+				"MOVB internal∕cpu·X86+" + strconv.FormatInt(offset+1, 10) + "(SB), AL\nRET\n"
+			file := filepath.Join(dir, "witness.s")
+			object := filepath.Join(dir, "witness.o")
+			if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			env := fixtureEnv(t, target)
+			listing := run(t, binary, dir, env, "tool", "asm", "-S", "-p", fixtureModule,
+				"-I", filepath.Join(filepath.Dir(filepath.Dir(binary)), "pkg", "include"), "-o", object, file)
+			data, err := os.ReadFile(object)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, dir, env, object)
+			var original []TextMember
+			if err := json.Unmarshal(raw, &original); err != nil || len(original) != 1 || len(original[0].Texts) != 1 {
+				t.Fatalf("actual standalone Go TEXT oracle differs: %v", err)
+			}
+			body, err := objectBody(data, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			builtins, err := textBuiltins(owner.TextBuiltinSource)
+			if err != nil {
+				t.Fatal(err)
+			}
+			texts, err := readTextObject(body, target, 4, false, builtins)
+			if err != nil || !reflect.DeepEqual(texts, original[0].Texts) {
+				t.Fatalf("actual Go source/code/relocation/PC readback differs: %v", err)
+			}
+			value := texts[0]
+			if len(value.Relocations) != 2 || len(value.Positions) != 3 || value.Positions[0].Line != 3 || value.Positions[1].Line != 4 || value.Positions[2].Line != 5 {
+				t.Fatalf("instruction source-PC witness is not exact: %+v", value)
+			}
+			for index, relocation := range value.Relocations {
+				if relocation.Target.Name != "internal/cpu.X86" || relocation.Target.ABI != 0 || relocation.Size != 4 {
+					t.Fatal("real Go relocation target/width differs", relocation)
+				}
+				want := offset + int64(index)
+				if target == "linux/amd64" {
+					if relocation.Type != 14 {
+						t.Fatal("actual AMD64 relocation is not R_PCREL", relocation)
+					}
+					tail := value.Positions[index].End - relocation.Offset - relocation.Size
+					if relocation.Add+tail != want || index == 0 && (tail != 1 || relocation.Add == want) {
+						t.Fatal("CMP immediate tail/addend counterexample was lost", relocation, tail)
+					}
+				} else if relocation.Type != 1 || relocation.Add != want {
+					t.Fatal("actual 386 absolute source relocation differs", relocation)
+				}
+			}
+			retainTextArtifact(t, target, "asm-text", map[string][]byte{
+				"text-sdk.json": raw, "text-original.o": data, "text-source.s": []byte(source), "text-listing.txt": listing,
+			})
+			// Querying a standalone object never relaxes ordinary Capture's
+			// no-assembly source role or creates a token from these bytes.
+			if observed, err := Capture(context.Background(), request(t, dir, binary, target)); err == nil {
+				observed.Close()
+				t.Fatal("TEXT metadata silently expanded ordinary source admission")
+			}
+			if !bytes.Contains(listing, []byte("internal/cpu.X86")) {
+				t.Fatal("actual Go did not consume the specified native source symbol")
+			}
+		})
+	}
+}
+
+func TestGoStaticStorageTEXTActualZeroPC(t *testing.T) {
+	_, binary, _ := fixture(t)
+	oracle := officialReaderForSource(t, binary, sdkTextReaderSource)
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			dir, err := filepath.EvalSymlinks(t.TempDir()) // Only this fresh owned output.
+			if err != nil {
+				t.Fatal(err)
+			}
+			source := []byte("#include \"textflag.h\"\nTEXT ·Empty(SB),NOSPLIT,$0-0\n")
+			file, object := filepath.Join(dir, "empty.s"), filepath.Join(dir, "empty.o")
+			if err := os.WriteFile(file, source, 0600); err != nil {
+				t.Fatal(err)
+			}
+			env := fixtureEnv(t, target)
+			listing := run(t, binary, dir, env, "tool", "asm", "-S", "-p", fixtureModule,
+				"-I", filepath.Join(filepath.Dir(filepath.Dir(binary)), "pkg", "include"), "-o", object, file)
+			original, err := os.ReadFile(object)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw := run(t, oracle, dir, env, object)
+			var members []TextMember
+			if err := json.Unmarshal(raw, &members); err != nil || len(members) != 1 || len(members[0].Texts) != 1 {
+				t.Fatal("original zero-PC SDK reader differs", err)
+			}
+			body, err := objectBody(original, target)
+			if err != nil {
+				t.Fatal(err)
+			}
+			builtin, err := os.ReadFile(filepath.Join(filepath.Dir(filepath.Dir(binary)), builtinSourceRole))
+			if err != nil {
+				t.Fatal(err)
+			}
+			builtins, err := textBuiltins(builtin)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed, err := readTextObject(body, target, 4, false, builtins)
+			if err != nil || !reflect.DeepEqual(observed, members[0].Texts) {
+				t.Fatal("actual zero-PC object/code/AUX role was rejected", err)
+			}
+			retainTextArtifact(t, target, "zero-text", map[string][]byte{
+				"text-source.s": source, "text-original.o": original, "text-sdk.json": raw, "text-listing.txt": listing,
+			})
+			if target == "js/wasm" {
+				if observed[0].Size != 1 || len(observed[0].Code) <= 1 {
+					t.Fatal("actual wasm TEXT-only virtual/physical axes differ", observed[0])
+				}
+			} else if observed[0].Size != 0 || observed[0].Positions != nil || !bytes.Equal(observed[0].PCFile, []byte{2, 0, 0}) || !bytes.Equal(observed[0].PCLine, []byte{6, 0, 0}) {
+				t.Fatal("actual TEXT-only zero-PC value/distance/terminator role differs", observed[0])
+			}
+			t.Logf("actual zero-PC %s logical=%d physical=%d", target, observed[0].Size, len(observed[0].Code))
+		})
+	}
+}
diff --git a/internal/gostaticstorage/text_guards_go127_test.go b/internal/gostaticstorage/text_guards_go127_test.go
new file mode 100644
index 000000000..2eb6c4be9
--- /dev/null
+++ b/internal/gostaticstorage/text_guards_go127_test.go
@@ -0,0 +1,307 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"math"
+	"reflect"
+	"testing"
+)
+
+func textFixtureRecord(t *testing.T) (*Observation, Report, []byte, *checkedGoObject, TextRecord) {
+	t.Helper()
+	dir, driver, _ := fixture(t)
+	observation, report := captured(t, request(t, dir, driver, "linux/amd64"))
+	members, err := archiveMembers(report.Archives[fixtureModule])
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err := objectBody(members[1].data, report.Target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	object, err := checkedObject(body, 0, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, value := range report.TextArchives[fixtureModule][1].Texts {
+		if value.Name == fixtureModule+".Read" {
+			return observation, report, body, object, value
+		}
+	}
+	t.Fatal("actual first-party Go TEXT is missing")
+	return nil, Report{}, nil, nil, TextRecord{}
+}
+
+func TestGoStaticStorageTEXTReportMutationGuards(t *testing.T) {
+	o, report, _, _, _ := textFixtureRecord(t)
+	for name, mutate := range map[string]func(*Report){
+		"protocol":       func(r *Report) { r.TextProtocol += "changed" },
+		"no protocol":    func(r *Report) { r.TextProtocol = "" },
+		"builtin bytes":  func(r *Report) { r.TextBuiltinSource[0] ^= 1 },
+		"missing source": func(r *Report) { r.TextBuiltinSource = nil },
+		"missing owner":  func(r *Report) { delete(r.TextArchives, fixtureModule) },
+		"extra owner":    func(r *Report) { r.TextArchives[fixtureModule+"/other"] = r.TextArchives[fixtureModule] },
+		"missing member": func(r *Report) { r.TextArchives[fixtureModule] = r.TextArchives[fixtureModule][:1] },
+		"member order": func(r *Report) {
+			m := r.TextArchives[fixtureModule]
+			m[0], m[1] = m[1], m[0]
+		},
+		"member offset":  func(r *Report) { r.TextArchives[fixtureModule][1].Offset++ },
+		"member flags":   func(r *Report) { r.TextArchives[fixtureModule][1].Flags |= 4 },
+		"code":           func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Code[0] ^= 1 },
+		"size":           func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Size++ },
+		"text index":     func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Index++ },
+		"text namespace": func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Namespace = TextSymbolHashed },
+		"relative index": func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relative++ },
+		"content hash":   func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Hash = []byte{1, 2, 3} },
+		"text ABI":       func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].ABI++ },
+		"text kind":      func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Kind++ },
+		"addend":         func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Add++ },
+		"relocation offset": func(r *Report) {
+			r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Offset++
+		},
+		"relocation width": func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Size++ },
+		"relocation kind":  func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Type++ },
+		"known ABI": func(r *Report) {
+			r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Target.ABIKnown = false
+		},
+		"symbol index":  func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Target.SymbolIndex++ },
+		"symbol kind":   func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Target.Kind++ },
+		"kind known":    func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Target.KindKnown = true },
+		"native symbol": func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[0].Target.Name += "other" },
+		"package":       func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Relocations[2].Target.Package += "/other" },
+		"auxiliary":     func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Auxiliary[0].Type++ },
+		"PC interval":   func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Positions[0].End++ },
+		"source file":   func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Positions[0].File += ".other" },
+		"source line":   func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].Positions[0].Line++ },
+		"pcfile bytes":  func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].PCFile[0] ^= 1 },
+		"pcline bytes":  func(r *Report) { r.TextArchives[fixtureModule][1].Texts[1].PCLine[0] ^= 1 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := cloneReport(t, report)
+			mutate(&changed)
+			if !errors.Is(ValidateReport(changed), ErrContext) || !errors.Is(o.CheckReport(context.Background(), changed), ErrContext) {
+				t.Fatal("edited TEXT metadata acquired a live/source or binary agreement role")
+			}
+		})
+	}
+	o.Close()
+	if !errors.Is(o.CheckReport(context.Background(), report), ErrContext) {
+		t.Fatal("closed TEXT observation retained authority")
+	}
+}
+
+func TestGoStaticStorageTEXTBinaryMutationGuards(t *testing.T) {
+	_, report, original, view, text := textFixtureRecord(t)
+	builtins, err := textBuiltins(report.TextBuiltinSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	blockOffset := func(index int) int { return int(binary.LittleEndian.Uint32(original[20+4*index:])) }
+	symbol := blockOffset(3) + int(text.Index)*21
+	relocation := blockOffset(14) + int(view.indices[0][text.Index])*23
+	auxiliary := blockOffset(15) + int(view.indices[1][text.Index])*9
+	pcfile, unusedAux := -1, -1
+	for index := 0; index < view.count; index++ {
+		for j := view.indices[1][index]; j < view.indices[1][index+1]; j++ {
+			position := blockOffset(15) + int(j)*9
+			if index == int(text.Index) && original[position] == 8 {
+				id := int(binary.LittleEndian.Uint32(original[position+5:])) + len(view.block(3))/21 + len(view.block(4))/21
+				pcfile = blockOffset(16) + int(view.indices[2][id])
+			}
+			if original[blockOffset(3)+index*21+10] != 1 {
+				unusedAux = position
+			}
+		}
+	}
+	if pcfile < 0 || unusedAux < 0 || len(view.block(17)) < 16 {
+		t.Fatal("actual object did not supply the required mutation roles")
+	}
+	for name, mutate := range map[string]func([]byte){
+		"magic":               func(b []byte) { b[0] ^= 1 },
+		"flags":               func(b []byte) { b[16] ^= 4 },
+		"unordered blocks":    func(b []byte) { binary.LittleEndian.PutUint32(b[20+4*4:], uint32(blockOffset(3)-1)) },
+		"block overflow":      func(b []byte) { binary.LittleEndian.PutUint32(b[20+4*6:], math.MaxUint32) },
+		"data index overflow": func(b []byte) { binary.LittleEndian.PutUint32(b[blockOffset(13)+4*int(text.Index):], math.MaxUint32) },
+		"unknown relocation":  func(b []byte) { binary.LittleEndian.PutUint16(b[relocation+5:], math.MaxUint16) },
+		"relocation extent":   func(b []byte) { binary.LittleEndian.PutUint32(b[relocation:], uint32(len(text.Code)+1)) },
+		"negative relocation": func(b []byte) { binary.LittleEndian.PutUint32(b[relocation:], math.MaxUint32) },
+		"invalid nil reference": func(b []byte) {
+			binary.LittleEndian.PutUint32(b[relocation+15:], 0)
+			binary.LittleEndian.PutUint32(b[relocation+19:], 1)
+		},
+		"unknown package": func(b []byte) { binary.LittleEndian.PutUint32(b[relocation+15:], math.MaxUint32) },
+		"self index":      func(b []byte) { binary.LittleEndian.PutUint32(b[relocation+19:], math.MaxUint32) },
+		"builtin index": func(b []byte) {
+			binary.LittleEndian.PutUint32(b[relocation+15:], 2147483644)
+			binary.LittleEndian.PutUint32(b[relocation+19:], uint32(len(builtins)))
+		},
+		"unknown symbol kind": func(b []byte) { b[symbol+10] = 255 },
+		"defined symbol string": func(b []byte) {
+			binary.LittleEndian.PutUint32(b[symbol+4:], math.MaxUint32)
+		},
+		"unknown TEXT aux":   func(b []byte) { b[auxiliary] = 255 },
+		"unknown unused aux": func(b []byte) { b[unusedAux] = 255 },
+		"PC file index":      func(b []byte) { b[pcfile] = 126 },
+		"PC zero delta":      func(b []byte) { b[pcfile+1] = 0 },
+		"PC extent overflow": func(b []byte) { b[pcfile+1]++ },
+		"PC varint overflow": func(b []byte) { b[pcfile] = 128; b[pcfile+1] = 128; b[pcfile+2] = 128 },
+		"code extent":        func(b []byte) { binary.LittleEndian.PutUint32(b[symbol+13:], uint32(text.Size+1)) },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := append([]byte(nil), original...)
+			mutate(changed)
+			if _, err := readTextObject(changed, "linux/amd64", 0, false, builtins); !errors.Is(err, ErrContext) {
+				t.Fatal("malformed original Go object metadata was admitted", err)
+			}
+		})
+	}
+	t.Run("duplicate reference", func(t *testing.T) {
+		changed := append(append([]byte(nil), original...), view.block(17)[:16]...)
+		binary.LittleEndian.PutUint32(changed[20+4*18:], uint32(len(changed)))
+		if _, err := readTextObject(changed, "linux/amd64", 0, false, builtins); !errors.Is(err, ErrContext) {
+			t.Fatal("duplicate complete reference-name record was admitted", err)
+		}
+	})
+}
+
+func TestGoStaticStorageTEXTPCTableBounds(t *testing.T) {
+	for name, data := range map[string][]byte{
+		"empty":          nil,
+		"truncated":      {128},
+		"overflow":       {128, 128, 128, 128, 16},
+		"noncanonical":   {130, 0, 2, 0},
+		"zero distance":  {2, 0, 0},
+		"incomplete":     {2, 1, 0},
+		"tail":           {2, 2, 0, 0},
+		"outside extent": {2, 3, 0},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := textPCTable(data, 2, 1); !errors.Is(err, ErrContext) {
+				t.Fatal("malformed bounded source-PC table acquired an observation", err)
+			}
+		})
+	}
+	if spans, err := textPCTable([]byte{2, 2, 0}, 2, 1); err != nil || !reflect.DeepEqual(spans, []pcValueSpan{{0, 2, 0}}) {
+		t.Fatal("valid complete source-PC table was rejected", spans, err)
+	}
+	for _, input := range [][2]int64{{-1, 1}, {0, 1}, {archiveLimit + 1, 1}, {2, 0}, {2, math.MaxInt64}} {
+		if _, err := textPCTable([]byte{2, 2, 0}, input[0], input[1]); !errors.Is(err, ErrContext) {
+			t.Fatal("invalid logical extent/quantum was accepted", input, err)
+		}
+	}
+}
+
+func TestGoStaticStorageTEXTWasmDistinctExtents(t *testing.T) {
+	dir, driver, _ := fixture(t)
+	_, report := captured(t, request(t, dir, driver, "js/wasm"))
+	members, err := archiveMembers(report.Archives[fixtureModule])
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err := objectBody(members[1].data, report.Target)
+	if err != nil {
+		t.Fatal(err)
+	}
+	view, err := checkedObject(body, 0, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtins, err := textBuiltins(report.TextBuiltinSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, text := range report.TextArchives[fixtureModule][1].Texts {
+		if text.Name != fixtureModule+".Read" {
+			continue
+		}
+		if text.Size <= 0 || text.Size >= int64(len(text.Code)) || len(text.Positions) == 0 || text.Positions[len(text.Positions)-1].End != text.Size {
+			t.Fatal("actual wasm object lacks distinct complete virtual-PC/physical-code axes", text)
+		}
+		physicalBeyondPC := false
+		for _, r := range text.Relocations {
+			physicalBeyondPC = physicalBeyondPC || r.Offset >= text.Size && r.Offset+r.Size <= int64(len(text.Code))
+		}
+		if !physicalBeyondPC {
+			t.Fatal("actual wasm relocations did not witness physical offsets beyond virtual PCs")
+		}
+		encoded, err := json.Marshal(report)
+		if err != nil {
+			t.Fatal(err)
+		}
+		retainTextArtifact(t, report.Target, "wasm-boundaries", map[string][]byte{
+			"text-report.json": encoded, "text-original.a": report.Archives[fixtureModule], "text-original.goobj": body,
+		})
+		// These direct parser mutations are structural controls only. Neither
+		// acquires a live source seal or a native/read permission.
+		symbol := int(binary.LittleEndian.Uint32(body[32:])) + int(text.Index)*21
+		for _, extent := range []int64{text.Size + 1, 0} {
+			changed := append([]byte(nil), body...)
+			binary.LittleEndian.PutUint32(changed[symbol+13:], uint32(extent))
+			if _, err := readTextObject(changed, report.Target, 0, false, builtins); !errors.Is(err, ErrContext) {
+				t.Error("wasm physical bytes masked invalid virtual PC coverage", extent, err)
+			}
+		}
+		changed := append([]byte(nil), body...)
+		relocation := int(binary.LittleEndian.Uint32(body[20+4*14:])) + int(view.indices[0][text.Index])*23
+		binary.LittleEndian.PutUint32(changed[relocation:], uint32(len(text.Code)+1))
+		if _, err := readTextObject(changed, report.Target, 0, false, builtins); !errors.Is(err, ErrContext) {
+			t.Fatal("wasm logical PC size masked an out-of-code physical relocation", err)
+		}
+		t.Logf("actual wasm virtualPC=%d physicalCode=%d relocations=%d", text.Size, len(text.Code), len(text.Relocations))
+		return
+	}
+	t.Fatal("actual wasm Read TEXT was absent")
+}
+
+func TestGoStaticStorageTEXTZeroPCMetadataRole(t *testing.T) {
+	// No logical PCs means there is no positive pc-value interval. A lone zero
+	// is truncated because the first zero is a value delta, not termination.
+	for _, tables := range [][2][]byte{
+		{{0}, nil}, {nil, {0}}, {{0}, {0}}, {{2, 1, 0}, {2, 1, 0}},
+	} {
+		if _, err := textPositions(tables[0], tables[1], 0, 1, nil); !errors.Is(err, ErrContext) {
+			t.Error("nonempty PC AUX data was ignored at zero logical extent", tables, err)
+		}
+	}
+	if positions, err := textPositions(nil, nil, 0, 1, nil); err != nil || positions != nil {
+		t.Fatal("canonical no-PC metadata role was rejected", positions, err)
+	}
+	if spans, err := textPCTable([]byte{2, 0, 0}, 0, 1); err != nil || !reflect.DeepEqual(spans, []pcValueSpan{{0, 0, 0}}) {
+		t.Fatal("actual Go's zero-PC value/distance/terminator role was rejected", spans, err)
+	}
+}
+
+func TestGoStaticStorageTEXTReferenceAndKindIdentity(t *testing.T) {
+	_, report, _, _, text := textFixtureRecord(t)
+	encoded, err := json.Marshal(text)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var record map[string]json.RawMessage
+	if err := json.Unmarshal(encoded, &record); err != nil || string(record["Kind"]) != "1" {
+		t.Error("TEXT/FIPS TEXT kind identity was omitted", err)
+	}
+	var relocations []struct {
+		Target struct {
+			PackageIndex uint32
+			ABIKnown     bool
+		}
+	}
+	if err := json.Unmarshal(record["Relocations"], &relocations); err != nil {
+		t.Fatal(err)
+	}
+	for _, r := range relocations {
+		if r.Target.ABIKnown != (r.Target.PackageIndex >= 2147483643) {
+			t.Error("an unobserved foreign ABI zero was indistinguishable from an actual local ABI0")
+		}
+	}
+	if report.TextProtocol != TextProtocol {
+		t.Fatal("TEXT observations lost their separate protocol")
+	}
+}
diff --git a/internal/gostaticstorage/tls_assembly.go b/internal/gostaticstorage/tls_assembly.go
new file mode 100644
index 000000000..9b7954080
--- /dev/null
+++ b/internal/gostaticstorage/tls_assembly.go
@@ -0,0 +1,29 @@
+package gostaticstorage
+
+import "strings"
+
+// ObserveX86TLSAssemblyText retains complete standalone tool-asm TEXT bytes,
+// source positions and relocations, including the exact Shared object flag.
+// This offline observation grants no native entry, thread or TLS address role.
+// The ordinary Linux numerical-read observer keeps its separate admission.
+func ObserveX86TLSAssemblyText(data, builtin []byte, target string, shared bool) ([]TextRecord, error) {
+	goos, arch, valid := strings.Cut(target, "/")
+	if !valid || arch != "386" && arch != "amd64" ||
+		goos != "linux" && goos != "android" && goos != "darwin" && goos != "windows" && goos != "freebsd" &&
+			goos != "openbsd" && goos != "netbsd" && goos != "dragonfly" && goos != "solaris" && goos != "plan9" {
+		return nil, contextError("unobserved x86 TLS assembler target")
+	}
+	builtins, err := textBuiltins(builtin)
+	if err != nil {
+		return nil, err
+	}
+	body, err := objectBody(data, target)
+	if err != nil {
+		return nil, err
+	}
+	flags := uint32(4) // FromAssembly, with the explicit -p linkable role.
+	if shared {
+		flags |= 1
+	}
+	return readTextObject(body, target, flags, false, builtins)
+}
diff --git a/internal/gostaticstorage/verification_arguments_test.go b/internal/gostaticstorage/verification_arguments_test.go
new file mode 100644
index 000000000..74db0ead2
--- /dev/null
+++ b/internal/gostaticstorage/verification_arguments_test.go
@@ -0,0 +1,113 @@
+package gostaticstorage
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"testing"
+)
+
+func TestGoStaticStorageCaptureAndLiveSelectionArguments(t *testing.T) {
+	// These unready objects test only pure command construction. They carry no
+	// observed source, original compiler archive or storage authority.
+	for _, row := range []struct {
+		protocol, path string
+		capture, live  []string
+	}{
+		{Protocol, "example.invalid/owner",
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "-mod=readonly", "."},
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-p=1", "-mod=readonly", "."}},
+		{SDKCPUProtocol, "internal/cpu",
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "internal/cpu"},
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-p=1", "internal/cpu"}},
+		{SDKGlobalsProtocol, "internal/runtime/atomic",
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-a", "-p=1", "internal/runtime/atomic"},
+			[]string{"list", "-deps", "-json", "-compiled", "-export", "-p=1", "internal/runtime/atomic"}},
+	} {
+		t.Run(row.protocol, func(t *testing.T) {
+			observation := &Observation{report: Report{Protocol: row.protocol, PackagePath: row.path,
+				CommandArguments: append([]string(nil), row.capture...)}}
+			if got := observation.selectionArguments(); !reflect.DeepEqual(got, row.capture) {
+				t.Fatal("original compiler capture must retain its complete forced-build command", got)
+			}
+			provider, ok := any(observation).(interface{ verificationArguments() []string })
+			if !ok {
+				t.Fatal("live verification still shares the forced compiler-capture command")
+			}
+			actual := provider.verificationArguments()
+			if !reflect.DeepEqual(actual, row.live) {
+				t.Fatal("live selection changed its scope or retained repeated forced compilation", actual, row.live)
+			}
+			actual[0] = "mutated"
+			if !reflect.DeepEqual(provider.verificationArguments(), row.live) ||
+				!reflect.DeepEqual(observation.selectionArguments(), row.capture) ||
+				!reflect.DeepEqual(observation.report.CommandArguments, row.capture) {
+				t.Fatal("live argv was cached, shared or substituted for original compiler evidence")
+			}
+			if row.protocol == SDKGlobalsProtocol {
+				observation.report.PackagePath = "internal/cpu"
+				want := append([]string(nil), row.live...)
+				want[len(want)-1] = observation.report.PackagePath
+				if !reflect.DeepEqual(provider.verificationArguments(), want) {
+					t.Fatal("pure command construction reused mutable package scope")
+				}
+			}
+		})
+	}
+}
+
+func TestGoStaticStorageLiveSelectionRemainsAnActualOwnedCommand(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "capture.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for function, arguments := range map[string]string{
+		"captureRole": "selectionArguments", "Verify": "verificationArguments",
+	} {
+		t.Run(function, func(t *testing.T) {
+			matches := 0
+			for _, declaration := range file.Decls {
+				method, ok := declaration.(*ast.FuncDecl)
+				if !ok || method.Name.Name != function {
+					continue
+				}
+				ast.Inspect(method.Body, func(node ast.Node) bool {
+					call, ok := node.(*ast.CallExpr)
+					if !ok {
+						return true
+					}
+					selector, ok := call.Fun.(*ast.SelectorExpr)
+					if !ok || selector.Sel.Name != "run" {
+						return true
+					}
+					receiver, ok := selector.X.(*ast.Ident)
+					if !ok || receiver.Name != "o" {
+						return true
+					}
+					matches++
+					if len(call.Args) != 2 || call.Ellipsis == token.NoPos {
+						t.Fatal("selection command stopped using the complete original live scope")
+					}
+					context, ok := call.Args[0].(*ast.Ident)
+					query, queryOK := call.Args[1].(*ast.CallExpr)
+					if !ok || context.Name != "ctx" || !queryOK || len(query.Args) != 0 {
+						t.Fatal("selection command lost its actual context or substituted query arguments")
+					}
+					generator, ok := query.Fun.(*ast.SelectorExpr)
+					if !ok || generator.Sel.Name != arguments {
+						t.Fatal("original compiler capture and live selection must use separate command roles", arguments)
+					}
+					owner, ok := generator.X.(*ast.Ident)
+					if !ok || owner.Name != "o" {
+						t.Fatal("selection command borrowed a different observation scope")
+					}
+					return true
+				})
+			}
+			if matches != 1 {
+				t.Fatal("each original capture/live verification must execute its own actual owned selection command", matches)
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/verification_commands_go127_test.go b/internal/gostaticstorage/verification_commands_go127_test.go
new file mode 100644
index 000000000..655779ec3
--- /dev/null
+++ b/internal/gostaticstorage/verification_commands_go127_test.go
@@ -0,0 +1,52 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestGoStaticStorageRepeatedLiveSelectionPreservesOriginalCompilerPrior(t *testing.T) {
+	directory, binary, _ := fixture(t)
+	// Existing physical-input, report, lifetime and unknown-field guard roots
+	// cover those boundaries separately. This narrow witness uses only actual
+	// stock-Go commands and archives, never a wrapper or simulated compiler.
+	observation, report := captured(t, request(t, directory, binary, "linux/amd64"))
+	if !reflect.DeepEqual(report.CommandArguments, selectionArguments()) || ValidateReport(report) != nil {
+		t.Fatal("actual original forced-build compiler prior is missing")
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	for index := 0; index < 3; index++ {
+		if err := observation.Verify(ctx); err != nil {
+			t.Fatal("unchanged actual source/export selection must remain valid", err)
+		}
+		if !reflect.DeepEqual(observation.report, report) {
+			t.Fatal("live verification rewrote original compiler arguments, outputs or source evidence")
+		}
+	}
+	// All captured file bytes still match. A live command must nevertheless
+	// observe a different compiler profile instead of reusing an earlier
+	// selection/result. No SDK or shared tool file is changed by this test.
+	originalEnvironment := append([]string(nil), observation.request.Environment...)
+	changed := false
+	for index, pair := range observation.request.Environment {
+		if pair == "GOAMD64=v1" {
+			observation.request.Environment[index], changed = "GOAMD64=v2", true
+		}
+	}
+	if !changed {
+		t.Fatal("actual command-environment mutation did not apply")
+	}
+	if err := observation.Verify(ctx); !errors.Is(err, ErrContext) {
+		t.Fatal("live selection accepted another actual compiler profile", err)
+	}
+	observation.request.Environment = originalEnvironment
+	if err := observation.Verify(ctx); !errors.Is(err, ErrContext) {
+		t.Fatal("restoring the actual environment revived a revoked observation", err)
+	}
+}
diff --git a/internal/gostaticstorage/windows_unwind.go b/internal/gostaticstorage/windows_unwind.go
new file mode 100644
index 000000000..adb942879
--- /dev/null
+++ b/internal/gostaticstorage/windows_unwind.go
@@ -0,0 +1,231 @@
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"reflect"
+	"strings"
+)
+
+// ObserveWindowsAMD64AssemblyText observes the complete checked assembler TEXT
+// inventory. It grants no permission to omit unwind metadata or use a frame.
+func ObserveWindowsAMD64AssemblyText(data, builtinSource []byte) ([]TextRecord, error) {
+	_, observed, err := windowsAMD64AssemblyText(data, builtinSource)
+	return observed.Texts, err
+}
+
+func windowsAMD64AssemblyText(data, builtinSource []byte) (*checkedGoObject, WindowsAMD64AssemblyUnwind, error) {
+	var result WindowsAMD64AssemblyUnwind
+	if len(data) == 0 || len(data) > archiveLimit {
+		return nil, result, contextError("Windows assembly object exceeds its byte bound")
+	}
+	version, err := objectHeaderVersion(data, "windows/amd64")
+	if err != nil {
+		return nil, result, err
+	}
+	schema, ok := windowsUnwindFormat(version)
+	if !ok {
+		return nil, result, contextError("unregistered Windows unwind object producer")
+	}
+	builtins, err := textBuiltinsForDigest(builtinSource, schema.builtin)
+	if err != nil {
+		return nil, result, err
+	}
+	end := bytes.Index(data, []byte("\n!\n"))
+	if end < 0 || end > 4096 {
+		return nil, result, contextError("invalid Windows assembly object text header")
+	}
+	body := data[end+3:]
+	object, err := checkedObject(body, 4, false)
+	if err != nil {
+		return nil, result, err
+	}
+	// Record widths/indexing are identical, but old symbol/Aux enums are not.
+	// Reject unknown historical values before invoking the shared byte reader.
+	for _, index := range []int{3, 4, 5, 6, 7} {
+		for pos := 0; pos < len(object.block(index)); pos += 21 {
+			kind := object.block(index)[pos+10]
+			if kind > schema.kind || schema.kind >= 24 && kind == 2 {
+				return nil, result, contextError("unknown or FIPS Windows assembly symbol kind")
+			}
+		}
+	}
+	for pos := 0; pos < len(object.block(15)); pos += 9 {
+		if object.block(15)[pos] > schema.aux {
+			return nil, result, contextError("unknown Windows assembly auxiliary kind")
+		}
+	}
+	for pos := 0; pos < len(object.block(14)); pos += 23 {
+		kind := binary.LittleEndian.Uint16(object.block(14)[pos+5:])
+		if !(kind >= 1 && kind <= schema.relocationMax || kind == 0x8001 || kind == 0x8005) {
+			return nil, result, contextError("unknown Windows assembly relocation kind")
+		}
+	}
+	texts, err := readCheckedTextObjectKinds(object, "windows/amd64", builtins, nil, false)
+	if err != nil {
+		return nil, result, err
+	}
+	if len(texts) == 0 {
+		return nil, result, contextError("Windows metadata lacks its complete TEXT inventory")
+	}
+	result.Texts = texts
+	result.Version, result.AuxType = version, schema.aux
+	result.TextFlags2, result.ListingAlignment = schema.flag2, schema.listingAlignment
+	return object, result, nil
+}
+
+// WindowsAMD64UnwindRecord observes one complete original Go metadata record.
+// It grants no source, frame, handler or native Windows unwind permission.
+type WindowsAMD64UnwindRecord struct {
+	Index                uint32
+	Name                 string
+	Data                 []byte
+	PrologueEnd, PushEnd uint8
+}
+
+type WindowsAMD64AssemblyUnwind struct {
+	Texts            []TextRecord
+	Unwind           []WindowsAMD64UnwindRecord
+	Version          string
+	AuxType          uint8
+	TextFlags2       uint8
+	ListingAlignment bool
+}
+
+// ObserveWindowsAMD64AssemblyUnwind is a read-only, bounded object observation.
+// A live source factory must independently bind original source, actual tools,
+// the pinned producer/schema, full listing and physical prologue/source PCs.
+func ObserveWindowsAMD64AssemblyUnwind(data, builtinSource []byte, privateLeaves ...[]TextRecord) (WindowsAMD64AssemblyUnwind, error) {
+	var result WindowsAMD64AssemblyUnwind
+	if len(privateLeaves) > 1 {
+		return result, contextError("Windows metadata has multiple private source-role inventories")
+	}
+	object, observed, err := windowsAMD64AssemblyText(data, builtinSource)
+	if err != nil {
+		return result, err
+	}
+	result = observed
+	texts := result.Texts
+	schema, _ := windowsUnwindFormat(result.Version) // checked by the shared reader
+	var leaves map[uint32]TextRecord
+	if len(privateLeaves) == 1 && len(privateLeaves[0]) != 0 {
+		if len(privateLeaves[0]) > len(texts) {
+			return result, contextError("Windows private source-role inventory exceeds its complete object")
+		}
+		leaves = make(map[uint32]TextRecord, len(privateLeaves[0]))
+		for _, text := range privateLeaves[0] {
+			_, duplicate := leaves[text.Index]
+			if duplicate || text.Name == "" || text.Kind != 1 || text.Flags != 16 ||
+				!(text.Namespace == TextSymbolSelf && text.ABI == 65535 ||
+					text.Namespace == TextSymbolNonpkgDefinition && text.ABI == 0) {
+				return result, contextError("Windows private source-role inventory has an invalid TEXT identity")
+			}
+			leaves[text.Index] = text
+		}
+	}
+	block := object.block
+	counts := [4]int{}
+	var symbols []byte
+	for index := range counts {
+		counts[index] = len(block(index+3)) / 21
+		symbols = append(symbols, block(index+3)...)
+	}
+	hashedStart, hashedEnd := counts[0]+counts[1], counts[0]+counts[1]+counts[2]
+	byIndex := make(map[uint32]WindowsAMD64UnwindRecord)
+	names := make(map[string]bool)
+	for index := 0; index < object.count; index++ {
+		symbol := symbols[index*21 : (index+1)*21]
+		name, err := object.stringAt(symbol[:8])
+		if err != nil || name != "" && names[name] {
+			return result, contextError("duplicate or invalid Windows definition name")
+		}
+		if name != "" {
+			names[name] = true
+		}
+		for n := object.indices[1][index]; n < object.indices[1][index+1]; n++ {
+			if block(15)[int(n)*9] == schema.aux && symbol[10] != 1 {
+				return result, contextError("Windows SEH auxiliary belongs to a non-TEXT definition")
+			}
+		}
+		if symbol[10] != schema.kind {
+			if strings.HasPrefix(name, "go:sehuw.") {
+				return result, contextError("Windows unwind name lacks its actual metadata kind")
+			}
+			continue
+		}
+		start, end := object.indices[2][index], object.indices[2][index+1]
+		if index < hashedStart || index >= hashedEnd || binary.LittleEndian.Uint16(symbol[8:]) != 0 ||
+			symbol[11] != 3 || symbol[12] != schema.flag2 || binary.LittleEndian.Uint32(symbol[13:]) != 12 ||
+			binary.LittleEndian.Uint32(symbol[17:]) != 4 || end-start != 12 {
+			return result, contextError("Windows unwind symbol/block/extent role differs")
+		}
+		bytes := block(16)[start:end]
+		if name != "go:sehuw.12."+base64.StdEncoding.EncodeToString(bytes) {
+			return result, contextError("Windows unwind name does not bind its complete original bytes")
+		}
+		if bytes[0] != 1 {
+			return result, contextError("Windows native exception-handler/version flags require a separate role")
+		}
+		if object.indices[0][index] != object.indices[0][index+1] ||
+			object.indices[1][index] != object.indices[1][index+1] {
+			return result, contextError("Windows unwind auxiliary/relocation requires a separate role")
+		}
+		if bytes[1] == 0 || bytes[2] != 2 || bytes[3] != 5 || bytes[4] != bytes[1] ||
+			bytes[5] != 3 || bytes[6] == 0 || bytes[6] >= bytes[4] || bytes[7] != 0x50 ||
+			binary.LittleEndian.Uint32(bytes[8:]) != 0 {
+			return result, contextError("unknown Windows unwind header/node/offset/tail grammar")
+		}
+		value := WindowsAMD64UnwindRecord{uint32(index), name, append([]byte(nil), bytes...), bytes[1], bytes[6]}
+		byIndex[value.Index] = value
+		result.Unwind = append(result.Unwind, value)
+	}
+	used := make(map[uint32]bool)
+	textNames := make(map[string]bool)
+	for _, text := range texts {
+		leaf, private := leaves[text.Index]
+		if private && !reflect.DeepEqual(leaf, text) {
+			return WindowsAMD64AssemblyUnwind{}, contextError("Windows private TEXT differs from its complete source/object association")
+		}
+		if text.Name == "" || textNames[text.Name] || text.Kind != 1 || !private && text.ABI != 0 ||
+			text.Flags&^16 != 0 || text.Flags2 != schema.flag2 {
+			return WindowsAMD64AssemblyUnwind{}, contextError("Windows closed-local metadata needs complete distinct ABI0 TEXTs")
+		}
+		textNames[text.Name] = true
+		links := 0
+		for _, aux := range text.Auxiliary {
+			if aux.Type != schema.aux {
+				continue
+			}
+			links++
+			if aux.Target.PackageIndex != 2147483645 || !aux.Target.ABIKnown || aux.Target.ABI != 0 ||
+				uint64(aux.Target.SymbolIndex) >= uint64(counts[2]) {
+				return WindowsAMD64AssemblyUnwind{}, contextError("Windows TEXT SEH reference lacks its local hashed role")
+			}
+			index := aux.Target.SymbolIndex + uint32(hashedStart)
+			unwind, exists := byIndex[index]
+			if !exists || aux.Target.Name != unwind.Name || int(unwind.PrologueEnd) >= len(text.Code) {
+				return WindowsAMD64AssemblyUnwind{}, contextError("Windows TEXT refers to missing/wrong/oversized unwind metadata")
+			}
+			used[index] = true
+		}
+		minimumLinks := 1
+		if private {
+			// The original-source join checks whether this leaf has an
+			// automatic frame. Observe either valid object shape here; only
+			// the independently bound zero-frame source can omit SEH.
+			minimumLinks = 0
+			delete(leaves, text.Index)
+		}
+		if links < minimumLinks || links > 1 {
+			return WindowsAMD64AssemblyUnwind{}, contextError("Windows TEXT has missing or duplicate SEH auxiliary ownership")
+		}
+	}
+	if len(leaves) != 0 {
+		return WindowsAMD64AssemblyUnwind{}, contextError("Windows private source-role inventory has a foreign TEXT")
+	}
+	if len(used) != len(byIndex) {
+		return WindowsAMD64AssemblyUnwind{}, contextError("Windows unwind inventory has an orphan definition")
+	}
+	return result, nil
+}
diff --git a/internal/gostaticstorage/windows_unwind_go127_test.go b/internal/gostaticstorage/windows_unwind_go127_test.go
new file mode 100644
index 000000000..ce82001e6
--- /dev/null
+++ b/internal/gostaticstorage/windows_unwind_go127_test.go
@@ -0,0 +1,231 @@
+//go:build go1.27
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func windowsUnwindObjectFixture(t *testing.T) ([]byte, []byte) {
+	t.Helper()
+	directory, driver, _ := fixture(t)
+	assembly := "TEXT ·Value(SB),4,$160-16\nMOVQ a+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n" +
+		"TEXT ·Void(SB),4,$160-8\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nRET\n"
+	name, object := filepath.Join(directory, "unwind.s"), filepath.Join(directory, "unwind.o")
+	if err := os.WriteFile(name, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	run(t, driver, directory, fixtureEnv(t, "windows/amd64"), "tool", "asm", "-p", fixtureModule,
+		"-o", object, name)
+	data, err := readRegular(object, archiveLimit)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtin, err := readRegular(filepath.Join(filepath.Dir(filepath.Dir(driver)), builtinSourceRole), archiveLimit)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The independent selected-SDK reader supplies all TEXT aux and source PCs;
+	// it neither calls the production decoder nor grants a live source role.
+	oracle := officialReaderForSource(t, driver, sdkTextReaderSource)
+	raw := run(t, oracle, directory, fixtureEnv(t, "windows/amd64"), object)
+	var actual []TextMember
+	if err := json.Unmarshal(raw, &actual); err != nil || len(actual) != 1 {
+		t.Fatal("independent original Windows Go object reader failed", err)
+	}
+	observed, err := ObserveWindowsAMD64AssemblyUnwind(data, builtin)
+	if err != nil || !reflect.DeepEqual(observed.Texts, actual[0].Texts) {
+		t.Fatal("complete Windows TEXT metadata differs from independent SDK reader", err)
+	}
+	return data, builtin
+}
+
+func TestGoStaticStorageWindowsUnwindActualExceptionHandlerRefusal(t *testing.T) {
+	directory, driver, _ := fixture(t)
+	name, object := filepath.Join(directory, "handler.s"), filepath.Join(directory, "handler.o")
+	assembly := "TEXT ·asmcgocall_landingpad(SB),4,$160-0\nRET\n"
+	if err := os.WriteFile(name, []byte(assembly), 0600); err != nil {
+		t.Fatal(err)
+	}
+	listing := run(t, driver, directory, fixtureEnv(t, "windows/amd64"), "tool", "asm", "-S",
+		"-p", "runtime", "-o", object, name)
+	if !bytes.Contains(listing, []byte("R_PEIMAGEOFF runtime.sehtramp")) {
+		t.Fatal("actual original handler control lacks its real PE-image relocation")
+	}
+	data, err := readRegular(object, archiveLimit)
+	if err != nil {
+		t.Fatal(err)
+	}
+	builtin, err := readRegular(filepath.Join(filepath.Dir(filepath.Dir(driver)), builtinSourceRole), archiveLimit)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := ObserveWindowsAMD64AssemblyUnwind(data, builtin); !errors.Is(err, ErrContext) ||
+		!strings.Contains(err.Error(), "exception-handler") {
+		t.Fatal("actual native handler metadata entered ordinary closed-local observation", err)
+	}
+	t.Logf("ACTUAL_WINDOWS_HANDLER_OBJECT bytes=%d sha256=%s hex=%x\n%s", len(data), digest(data), data, listing)
+}
+
+func TestGoStaticStorageWindowsUnwindCompleteSchemaAndGuards(t *testing.T) {
+	data, builtin := windowsUnwindObjectFixture(t)
+	observed, err := ObserveWindowsAMD64AssemblyUnwind(data, builtin)
+	if err != nil || len(observed.Texts) != 2 || len(observed.Unwind) != 1 ||
+		observed.Unwind[0].PushEnd != 1 || observed.Unwind[0].PrologueEnd != 4 ||
+		!bytes.Equal(observed.Unwind[0].Data, []byte{1, 4, 2, 5, 4, 3, 1, 0x50, 0, 0, 0, 0}) {
+		t.Fatal("complete original two-TEXT shared SEH observation differs", err)
+	}
+	start := bytes.Index(data, []byte("\n!\n")) + 3
+	body := data[start:]
+	offset := func(block int) int { return start + int(binary.LittleEndian.Uint32(body[20+block*4:])) }
+	index := int(observed.Unwind[0].Index)
+	metadataSymbol := offset(3) + index*21
+	metadataData := offset(16) + int(binary.LittleEndian.Uint32(data[offset(13)+index*4:]))
+	metadataName := start + int(binary.LittleEndian.Uint32(data[metadataSymbol+4:]))
+	metadataAux := func(text TextRecord) int {
+		from := int(binary.LittleEndian.Uint32(data[offset(12)+int(text.Index)*4:]))
+		to := int(binary.LittleEndian.Uint32(data[offset(12)+(int(text.Index)+1)*4:]))
+		for index := from; index < to; index++ {
+			if data[offset(15)+index*9] == 14 {
+				return offset(15) + index*9
+			}
+		}
+		t.Fatal("actual original TEXT omitted its SEH auxiliary")
+		return 0
+	}
+	aux := metadataAux(observed.Texts[0])
+	textSymbol := offset(3) + int(observed.Texts[0].Index)*21
+	mutations := map[string]func([]byte) []byte{
+		"wrong target":          func(v []byte) []byte { return bytes.Replace(v, []byte("windows amd64"), []byte("linuxxx amd64"), 1) },
+		"extra EOF":             func(v []byte) []byte { return append(v, 0) },
+		"truncated EOF":         func(v []byte) []byte { return v[:len(v)-1] },
+		"wrong object flag":     func(v []byte) []byte { v[start+16] = 0; return v },
+		"wrong kind":            func(v []byte) []byte { v[metadataSymbol+10] = 24; return v },
+		"wrong ABI":             func(v []byte) []byte { v[metadataSymbol+8] = 1; return v },
+		"missing local flag":    func(v []byte) []byte { v[metadataSymbol+11] = 1; return v },
+		"extra symbol flag":     func(v []byte) []byte { v[metadataSymbol+11] |= 4; return v },
+		"extra TEXT flag":       func(v []byte) []byte { v[textSymbol+11] |= 1; return v },
+		"extra flag2":           func(v []byte) []byte { v[metadataSymbol+12] = 1; return v },
+		"wrong size":            func(v []byte) []byte { v[metadataSymbol+13] = 13; return v },
+		"wrong alignment":       func(v []byte) []byte { v[metadataSymbol+17] = 8; return v },
+		"missing namespace":     func(v []byte) []byte { v[metadataName] = 'x'; return v },
+		"noncanonical base64":   func(v []byte) []byte { v[metadataName+11] = '_'; return v },
+		"unbound byte change":   func(v []byte) []byte { v[metadataData+1]++; return v },
+		"missing TEXT link":     func(v []byte) []byte { v[aux] = 12; return v },
+		"duplicate TEXT link":   func(v []byte) []byte { copy(v[aux-9:aux], v[aux:aux+9]); return v },
+		"zero TEXT link":        func(v []byte) []byte { clear(v[aux+1 : aux+9]); return v },
+		"wrong reference block": func(v []byte) []byte { binary.LittleEndian.PutUint32(v[aux+1:], 2147483647); return v },
+		"wrong hashed kind":     func(v []byte) []byte { binary.LittleEndian.PutUint32(v[aux+5:], 0); return v },
+		"out-of-bounds link":    func(v []byte) []byte { binary.LittleEndian.PutUint32(v[aux+5:], 65536); return v },
+		"foreign link":          func(v []byte) []byte { binary.LittleEndian.PutUint32(v[aux+1:], 65536); return v },
+		"unused malformed reference": func(v []byte) []byte {
+			binary.LittleEndian.PutUint32(v[offset(7)+4:], 0xffffffff)
+			return v
+		},
+		"non-TEXT SEH owner": func(v []byte) []byte {
+			v[offset(3)+int(observed.Texts[0].Index)*21+10] = 24
+			return v
+		},
+		"SEH relocation role": func(v []byte) []byte {
+			binary.LittleEndian.PutUint32(v[offset(11)+(index+1)*4:], 1)
+			return v
+		},
+		"SEH auxiliary role": func(v []byte) []byte {
+			from := binary.LittleEndian.Uint32(v[offset(12)+index*4:])
+			binary.LittleEndian.PutUint32(v[offset(12)+(index+1)*4:], from+1)
+			return v
+		},
+		"orphan hashed metadata": func(v []byte) []byte { return windowsUnwindWithOrphan(t, v, observed.Unwind[0]) },
+	}
+	for _, byteIndex := range []int{0, 2, 3, 5, 7, 8, 9, 10, 11} {
+		mutations["canonical-name grammar byte "+string(rune('A'+byteIndex))] = func(v []byte) []byte {
+			v[metadataData+byteIndex] ^= 1
+			copy(v[metadataName:], "go:sehuw.12."+base64.StdEncoding.EncodeToString(v[metadataData:metadataData+12]))
+			return v
+		}
+	}
+	for _, offsetCase := range []struct {
+		name                     string
+		prologue, setFrame, push byte
+	}{{"zero prologue", 0, 0, 1}, {"zero push", 4, 4, 0}, {"offset order", 4, 4, 4}, {"header and node differ", 4, 5, 1}} {
+		mutations[offsetCase.name] = func(v []byte) []byte {
+			v[metadataData+1], v[metadataData+4], v[metadataData+6] = offsetCase.prologue, offsetCase.setFrame, offsetCase.push
+			copy(v[metadataName:], "go:sehuw.12."+base64.StdEncoding.EncodeToString(v[metadataData:metadataData+12]))
+			return v
+		}
+	}
+	for name, change := range mutations {
+		t.Run(name, func(t *testing.T) {
+			changed := change(append([]byte(nil), data...))
+			if _, err := ObserveWindowsAMD64AssemblyUnwind(changed, builtin); !errors.Is(err, ErrContext) {
+				t.Fatal("changed complete Windows metadata was accepted", err)
+			}
+		})
+	}
+	t.Run("changed builtin schema", func(t *testing.T) {
+		if _, err := ObserveWindowsAMD64AssemblyUnwind(data, append(append([]byte(nil), builtin...), '\n')); !errors.Is(err, ErrContext) {
+			t.Fatal("caller builtin schema replaced the original selected SDK", err)
+		}
+	})
+}
+
+// Rebuild the complete indexed object with one valid but unreferenced hashed
+// SEH definition. Existing class-relative references remain unchanged; every
+// object block, index tail and data extent still covers the exact EOF.
+func windowsUnwindWithOrphan(t *testing.T, data []byte, metadata WindowsAMD64UnwindRecord) []byte {
+	t.Helper()
+	start := bytes.Index(data, []byte("\n!\n")) + 3
+	body := data[start:]
+	var offsets [19]int
+	for index := range offsets {
+		offsets[index] = int(binary.LittleEndian.Uint32(body[20+index*4:]))
+	}
+	blocks := make([][]byte, 18)
+	for index := range blocks {
+		blocks[index] = append([]byte(nil), body[offsets[index]:offsets[index+1]]...)
+	}
+	insert := (len(blocks[3]) + len(blocks[4]) + len(blocks[5])) / 21
+	payload := append([]byte(nil), metadata.Data...)
+	payload[1], payload[4] = 5, 5
+	name := "go:sehuw.12." + base64.StdEncoding.EncodeToString(payload)
+	symbol := append([]byte(nil), body[offsets[3]+int(metadata.Index)*21:offsets[3]+(int(metadata.Index)+1)*21]...)
+	binary.LittleEndian.PutUint32(symbol, uint32(len(name)))
+	binary.LittleEndian.PutUint32(symbol[4:], uint32(offsets[0]))
+	blocks[5] = append(blocks[5], symbol...)
+	blocks[10] = append(blocks[10], make([]byte, 16)...)
+	dataPosition := int(binary.LittleEndian.Uint32(blocks[13][insert*4:]))
+	blocks[16] = append(append(append([]byte(nil), blocks[16][:dataPosition]...), payload...), blocks[16][dataPosition:]...)
+	for _, index := range []int{11, 12, 13} {
+		old := blocks[index]
+		updated := append([]byte(nil), old[:(insert+1)*4]...)
+		value := binary.LittleEndian.Uint32(old[insert*4:])
+		if index == 13 {
+			value += 12
+		}
+		updated = binary.LittleEndian.AppendUint32(updated, value)
+		for pos := (insert + 1) * 4; pos < len(old); pos += 4 {
+			value := binary.LittleEndian.Uint32(old[pos:])
+			if index == 13 {
+				value += 12
+			}
+			updated = binary.LittleEndian.AppendUint32(updated, value)
+		}
+		blocks[index] = updated
+	}
+	rebuilt := append(append([]byte(nil), body[:offsets[0]]...), []byte(name)...)
+	for index, block := range blocks {
+		binary.LittleEndian.PutUint32(rebuilt[20+index*4:], uint32(len(rebuilt)))
+		rebuilt = append(rebuilt, block...)
+	}
+	binary.LittleEndian.PutUint32(rebuilt[20+18*4:], uint32(len(rebuilt)))
+	return append(append([]byte(nil), data[:start]...), rebuilt...)
+}
diff --git a/internal/gostaticstorage/windows_unwind_patch_test.go b/internal/gostaticstorage/windows_unwind_patch_test.go
new file mode 100644
index 000000000..a0a57bfdb
--- /dev/null
+++ b/internal/gostaticstorage/windows_unwind_patch_test.go
@@ -0,0 +1,153 @@
+package gostaticstorage
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestWindowsUnwindAuditedPatchProducerSchema(t *testing.T) {
+	// Independently compared complete sources at golang/go tags go1.26.9
+	// (2ae494ef9fb90e0da0073c31800ba38870249994) and go1.26.10
+	// (4e8c85f5319d999bfd7617fdc191631e5634e3c5). Every role is byte-identical;
+	// another patch number alone does not register its producer or object schema.
+	inputs := []struct{ role, sha256 string }{
+		{"src/cmd/internal/obj/x86/seh.go", "552514c6d05a8943a77527e2a9b9d993c31200b659cc871d194239d970879f22"},
+		{"src/cmd/internal/goobj/objfile.go", "d33fd9dd676fed9d8c10c31af6b728112413dabfe8ba34b928126af27ced40b0"},
+		{"src/cmd/internal/obj/objfile.go", "e839648ca9e4fccfae70e089e3f836f5d6fd82228ffe1712cd4423169cb0f6ee"},
+		{"src/cmd/internal/obj/sym.go", "4695f8b4d4084314634a0173fb5a94c76f81b5a28137025143a54b7139dfb529"},
+		{"src/cmd/internal/obj/plist.go", "59ef5068404a639eeb87c1c706b7b79c46884d22c459d2c7458c793220ec4afc"},
+		{"src/cmd/internal/objabi/symkind.go", "de287864b7ff9a3614becc538cbabdccdecc030a848aad5d5bbef6ec7ec5c225"},
+		{"src/cmd/internal/objabi/reloctype.go", "eca81bff6d4f34b3b6f0b0fcf06f0e40b293cef68a0b81be3829094b56d8a822"},
+		{"src/cmd/internal/goobj/builtinlist.go", "7dc5b3b8dff057b9f7e8c75afacecadc238f7538995f161bd55576ad448a4101"},
+	}
+	var roles, hashes []string
+	for _, input := range inputs {
+		roles = append(roles, input.role)
+		hashes = append(hashes, input.sha256)
+	}
+	if !reflect.DeepEqual(windowsUnwindSourceRoles[:], roles) {
+		t.Fatal("Windows unwind source-role census changed", windowsUnwindSourceRoles)
+	}
+	want := windowsUnwindSchema{
+		sources:          fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(hashes, "\n")))),
+		builtin:          inputs[len(inputs)-1].sha256,
+		kind:             25,
+		aux:              14,
+		flag2:            16,
+		relocationMax:    103,
+		listingAlignment: false,
+	}
+	for _, version := range []string{"go1.26.8", "go1.26.9", "go1.26.10"} {
+		t.Run(version, func(t *testing.T) {
+			got, ok := windowsUnwindFormat(version)
+			if !ok || got != want {
+				t.Fatalf("audited role-specific producer/schema missing or changed: %#v, registered=%t", got, ok)
+			}
+			// This role must not admit historical compiler archives to the
+			// unrelated current-only object reader, even for a Windows target.
+			for _, target := range []string{"windows/amd64", "linux/amd64", "darwin/amd64"} {
+				object := []byte("go object " + strings.ReplaceAll(target, "/", " ") + " " + version + "\n!\n\x00go120ld")
+				if _, err := objectBody(object, target); !errors.Is(err, ErrContext) {
+					t.Fatal("a Windows unwind producer registered a generic compiler archive", target, err)
+				}
+			}
+		})
+	}
+}
+
+func TestWindowsUnwindCurrentPatchProducerSchema(t *testing.T) {
+	// The complete eight source roles are byte-identical in Go 1.27.2 and
+	// 1.27.3. Keep their independent file census rather than admitting a minor
+	// version range or deriving expected identity from the production schema.
+	inputs := []struct{ role, sha256 string }{
+		{"src/cmd/internal/obj/x86/seh.go", "3e7b9a27ed35bb507c39685d3aff193c758566baa4a392816cdf4d19e8419e67"},
+		{"src/cmd/internal/goobj/objfile.go", "caf835a17e23aa02cae9bda6e8723d8be359846fc4453bd53f3a3947744b938a"},
+		{"src/cmd/internal/obj/objfile.go", "803546227c02cf46bfa4158be3dfd8067e7457f4e4f78349cb6d42c700b2fcb7"},
+		{"src/cmd/internal/obj/sym.go", "2bb2646a6ccff23aa42d8c4960be7cf82af5570ae5a83a1a355b7b822ee2149d"},
+		{"src/cmd/internal/obj/plist.go", "50c121d6c72c356c605176e02bce549dd6e0e8107af6c0eed467f7b3adb418e3"},
+		{"src/cmd/internal/objabi/symkind.go", "de287864b7ff9a3614becc538cbabdccdecc030a848aad5d5bbef6ec7ec5c225"},
+		{"src/cmd/internal/objabi/reloctype.go", "49bebd30a27d05a24de77398ab524dfbeb0630c8b88c06646c1e4734e4f1fc9d"},
+		{"src/cmd/internal/goobj/builtinlist.go", "8f38ef757cdebb27963ee9befe24dd8041b86d217937db30f13e4d3d91207311"},
+	}
+	var roles, hashes []string
+	for _, input := range inputs {
+		roles = append(roles, input.role)
+		hashes = append(hashes, input.sha256)
+	}
+	if !reflect.DeepEqual(windowsUnwindSourceRoles[:], roles) {
+		t.Fatal("Windows unwind source-role census changed", windowsUnwindSourceRoles)
+	}
+	want := windowsUnwindSchema{
+		sources:          fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(hashes, "\n")))),
+		builtin:          inputs[len(inputs)-1].sha256,
+		kind:             25,
+		aux:              14,
+		flag2:            0,
+		relocationMax:    106,
+		listingAlignment: true,
+	}
+	for _, version := range []string{"go1.27.1", "go1.27.2", "go1.27.3"} {
+		t.Run(version, func(t *testing.T) {
+			if got, ok := windowsUnwindFormat(version); !ok || got != want {
+				t.Fatalf("audited Windows producer/schema missing or changed: %#v, registered=%t", got, ok)
+			}
+		})
+	}
+	object := []byte("go object windows amd64 go1.27.4\n!\n\x00go120ld")
+	if _, err := objectBody(object, "windows/amd64"); !errors.Is(err, ErrContext) {
+		t.Fatal("Windows observation registered an unaudited generic object format", err)
+	}
+}
+
+func TestWindowsUnwindPatchProducerSourcesFailClosed(t *testing.T) {
+	for _, version := range []string{
+		"", "go1.26", "go1.26.7", "go1.26.11", "go1.26.100", "go1.26.10rc1", "devel go1.26.10",
+		"go1.27.4", "go1.27.3rc1", "go1.27.3-custom", "devel go1.27.3",
+	} {
+		t.Run(version, func(t *testing.T) {
+			called := false
+			data, err := WindowsAMD64UnwindSources(version, func(string) ([]byte, error) {
+				called = true
+				return nil, nil
+			})
+			if !errors.Is(err, ErrContext) || called || data != nil {
+				t.Fatal("an unaudited patch gained or read a producer source role", called, data, err)
+			}
+		})
+	}
+	for _, version := range []string{"go1.26.8", "go1.26.9", "go1.26.10", "go1.27.3"} {
+		t.Run(version, func(t *testing.T) {
+			if data, err := WindowsAMD64UnwindSources(version, nil); !errors.Is(err, ErrContext) || data != nil {
+				t.Fatal("missing guarded source reader gained a role", data, err)
+			}
+			var read []string
+			data, err := WindowsAMD64UnwindSources(version, func(role string) ([]byte, error) {
+				read = append(read, role)
+				return []byte("different actual source: " + role), nil
+			})
+			if !errors.Is(err, ErrContext) || data != nil || !reflect.DeepEqual(read, windowsUnwindSourceRoles[:]) {
+				t.Fatal("changed source was admitted or the complete census was not read", read, data, err)
+			}
+			for index, role := range windowsUnwindSourceRoles {
+				t.Run(role, func(t *testing.T) {
+					want := errors.New("guarded source unavailable")
+					var read []string
+					data, err := WindowsAMD64UnwindSources(version, func(name string) ([]byte, error) {
+						read = append(read, name)
+						if name == role {
+							return nil, want
+						}
+						return []byte("different actual source: " + name), nil
+					})
+					if !errors.Is(err, want) || data != nil || !reflect.DeepEqual(read, windowsUnwindSourceRoles[:index+1]) {
+						t.Fatal("guarded source error or exact role traversal changed", read, data, err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/internal/gostaticstorage/windows_unwind_schema.go b/internal/gostaticstorage/windows_unwind_schema.go
new file mode 100644
index 000000000..7bc55838a
--- /dev/null
+++ b/internal/gostaticstorage/windows_unwind_schema.go
@@ -0,0 +1,92 @@
+package gostaticstorage
+
+import "strings"
+
+// These inputs bind the complete SEH producer, object writer/schema, symbol
+// traversal, listing writer and builtin namespace. A schema pin is SHA256 of
+// the eight lowercase file SHA256s, joined with LF in this exact order.
+var windowsUnwindSourceRoles = [...]string{
+	"src/cmd/internal/obj/x86/seh.go",
+	"src/cmd/internal/goobj/objfile.go",
+	"src/cmd/internal/obj/objfile.go",
+	"src/cmd/internal/obj/sym.go",
+	"src/cmd/internal/obj/plist.go",
+	"src/cmd/internal/objabi/symkind.go",
+	"src/cmd/internal/objabi/reloctype.go",
+	builtinSourceRole,
+}
+
+type windowsUnwindSchema struct {
+	sources, builtin string
+	kind, aux, flag2 uint8
+	relocationMax    uint16
+	listingAlignment bool
+}
+
+// Go 1.23 introduced the listed, hashed SEH definitions observed here. Earlier
+// package-local SEH objects are a different role. None of these registrations
+// expands the generic Go 1.27 compiler archive or DATA observation contracts.
+func windowsUnwindFormat(version string) (windowsUnwindSchema, bool) {
+	var schema windowsUnwindSchema
+	switch version {
+	case "go1.23.12":
+		schema = windowsUnwindSchema{
+			"616a38a54d0f9782a2266c8dc04d75ab77a3c5c3db4b9d07339617ec73320b1e",
+			"a49b363c40c3d3bd8b477e72bf53a6ffab49220559a64260b806ba9f44ff8ae2",
+			20, 13, 16, 91, false,
+		}
+	case "go1.24.13":
+		schema = windowsUnwindSchema{
+			"1282c8c5aa1e786f73c3e754d2cc238d8dd662ff00d0ecb70b65784e142c40d9",
+			"aa40a9079a0ce71b9f44eea97b54271eaee0ab869f5cb6c5d00e3c157aee951f",
+			24, 14, 16, 95, false,
+		}
+	case "go1.25.14":
+		schema = windowsUnwindSchema{
+			"812ce8a0cdfa179c7375b510044ceef1a511cddcc419d250d8f80fe328dbe7e9",
+			"acb5795f8a9a22d3f44dc1993ac269e11733c971a6f4dee83d96343f2de527a8",
+			25, 14, 16, 99, false,
+		}
+	case "go1.26.8", "go1.26.9", "go1.26.10":
+		schema = windowsUnwindSchema{
+			"5428221d6c92317f9d80594122a4eef9f82abb9865499fd39d92522d72cd79a9",
+			"7dc5b3b8dff057b9f7e8c75afacecadc238f7538995f161bd55576ad448a4101",
+			25, 14, 16, 103, false,
+		}
+	case "go1.27.1", "go1.27.2", "go1.27.3":
+		schema = windowsUnwindSchema{
+			"836468efd5f9e8b71f828b4c0e5b7fc5fc2eb99842b5f16ca5b47c1eb611b86e",
+			"8f38ef757cdebb27963ee9befe24dd8041b86d217937db30f13e4d3d91207311",
+			25, 14, 0, 106, true,
+		}
+	default:
+		return schema, false
+	}
+	return schema, true
+}
+
+// WindowsAMD64UnwindSources reads every required actual SDK input through the
+// live factory's guarded reader. It returns the matching builtin source, not
+// authority to use a caller-provided schema or grant native unwind behavior.
+func WindowsAMD64UnwindSources(version string, read func(string) ([]byte, error)) ([]byte, error) {
+	schema, ok := windowsUnwindFormat(version)
+	if !ok || read == nil {
+		return nil, contextError("unregistered Windows unwind producer")
+	}
+	var hashes []string
+	var builtin []byte
+	for _, role := range windowsUnwindSourceRoles {
+		data, err := read(role)
+		if err != nil {
+			return nil, err
+		}
+		hashes = append(hashes, digest(data))
+		if role == builtinSourceRole {
+			builtin = data
+		}
+	}
+	if digest([]byte(strings.Join(hashes, "\n"))) != schema.sources {
+		return nil, contextError("Windows unwind producer/schema differs from actual pinned SDK")
+	}
+	return builtin, nil
+}
diff --git a/internal/gostaticstorage/windows_unwind_schema_test.go b/internal/gostaticstorage/windows_unwind_schema_test.go
new file mode 100644
index 000000000..d35e0cfdb
--- /dev/null
+++ b/internal/gostaticstorage/windows_unwind_schema_test.go
@@ -0,0 +1,212 @@
+//go:build go1.23
+
+package gostaticstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// This reader is compiled against the selected SDK's actual goobj/objabi
+// exports. It does not copy our enum numbers, offsets or SEH decoder.
+const windowsUnwindSDKReader = `package main
+import (
+ "bytes"
+ "cmd/internal/goobj"
+ "cmd/internal/objabi"
+ "encoding/json"
+ "os"
+)
+func main() {
+ data, err := os.ReadFile(os.Args[1])
+ if err != nil { panic(err) }
+ reader := goobj.NewReaderFromBytes(data[bytes.Index(data, []byte("\n!\n"))+3:], true)
+ type record struct {
+  Name string
+  Kind, Flags, Flags2 uint8
+  Align uint32
+  Data []byte
+ }
+ result := struct {
+  Kind, Aux uint8
+  TextFlags2 uint8
+  Records []record
+  Links map[string]string
+ }{Kind: uint8(objabi.SSEHUNWINDINFO), Aux: goobj.AuxSehUnwindInfo, Links: map[string]string{}}
+ count := reader.NSym()+reader.NHashed64def()+reader.NHasheddef()+reader.NNonpkgdef()
+ for index := uint32(0); index < uint32(count); index++ {
+  symbol := reader.Sym(index)
+  switch objabi.SymKind(symbol.Type()) {
+  case objabi.SSEHUNWINDINFO:
+   result.Records = append(result.Records, record{symbol.Name(reader), symbol.Type(), symbol.Flag(), symbol.Flag2(), symbol.Align(), reader.Data(index)})
+  case objabi.STEXT:
+   result.TextFlags2 = symbol.Flag2()
+   for _, aux := range reader.Auxs(index) {
+    if aux.Type() != goobj.AuxSehUnwindInfo { continue }
+    ref := aux.Sym()
+    if ref.PkgIdx != goobj.PkgIdxHashed { panic("SEH reference is not hashed") }
+    target := reader.Sym(uint32(reader.NSym()+reader.NHashed64def())+ref.SymIdx)
+    if _, duplicate := result.Links[symbol.Name(reader)]; duplicate { panic("duplicate SEH link") }
+    result.Links[symbol.Name(reader)] = target.Name(reader)
+   }
+  }
+ }
+ if err := json.NewEncoder(os.Stdout).Encode(result); err != nil { panic(err) }
+}
+`
+
+func TestWindowsUnwindHistoricalSchemaActualSDK(t *testing.T) {
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	environment := append(os.Environ(), "GOTOOLCHAIN=local", "GOWORK=off", "GOENV=off", "GOFLAGS=",
+		"GOEXPERIMENT=", "CGO_ENABLED=0", "GOPROXY=off", "GOSUMDB=off", "GOAMD64=v1",
+		"GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH)
+	run := func(env []string, binary string, args ...string) []byte {
+		t.Helper()
+		ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
+		defer cancel()
+		output, err := goasmcmd.Run(ctx, directory, env, binary, args...)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return output
+	}
+	write := func(name, content string) {
+		t.Helper()
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	write("go.mod", "module example.invalid/sehschema\n\ngo 1.20\n")
+	write("original.s", "TEXT ·Value(SB),4,$160-16\nMOVQ a+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n"+
+		"TEXT ·Void(SB),4,$160-8\nMOVQ a+0(FP),AX\nMOVQ AX,16(SP)\nRET\n")
+	version := strings.TrimSpace(string(run(environment, driver, "env", "GOVERSION")))
+	root := strings.TrimSpace(string(run(environment, driver, "env", "GOROOT")))
+	read := func(role string) ([]byte, error) { return os.ReadFile(filepath.Join(root, filepath.FromSlash(role))) }
+	builtin, err := WindowsAMD64UnwindSources(version, read)
+	if err != nil {
+		t.Fatal("actual SDK needs its independently audited schema", err)
+	}
+	target := append(append([]string(nil), environment...), "GOOS=windows", "GOARCH=amd64")
+	run(target, driver, "tool", "asm", "-p", "example.invalid/sehschema", "-o", "original.o", "original.s")
+	data, err := os.ReadFile(filepath.Join(directory, "original.o"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := ObserveWindowsAMD64AssemblyUnwind(data, builtin)
+	if err != nil || len(observed.Texts) != 2 || len(observed.Unwind) != 1 || observed.Version != version {
+		t.Fatal("complete original Windows object observation failed", err)
+	}
+
+	write("reader.go", windowsUnwindSDKReader)
+	config := run(environment, driver, "list", "-deps", "-export", "-f",
+		"{{if .Export}}packagefile {{.ImportPath}}={{.Export}}{{end}}",
+		"cmd/internal/goobj", "cmd/internal/objabi", "bytes", "encoding/json", "os")
+	write("importcfg", string(config))
+	reader := filepath.Join(directory, gotoolchain.HostExecutable("reader"))
+	run(environment, driver, "tool", "compile", "-p", "main", "-importcfg", "importcfg", "-o", "reader.o", "reader.go")
+	run(environment, driver, "tool", "link", "-importcfg", "importcfg", "-o", reader, "reader.o")
+	var actual struct {
+		Kind, Aux, TextFlags2 uint8
+		Records               []struct {
+			Name                string
+			Kind, Flags, Flags2 uint8
+			Align               uint32
+			Data                []byte
+		}
+		Links map[string]string
+	}
+	if err := json.Unmarshal(run(environment, reader, "original.o"), &actual); err != nil {
+		t.Fatal(err)
+	}
+	if len(actual.Records) != len(observed.Unwind) || len(actual.Links) != len(observed.Texts) ||
+		actual.Aux != observed.AuxType || actual.TextFlags2 != observed.TextFlags2 {
+		t.Fatal("actual SDK complete enum/inventory differs", actual, observed)
+	}
+	for index, record := range actual.Records {
+		value := observed.Unwind[index]
+		if record.Name != value.Name || record.Kind != actual.Kind || record.Flags != 3 ||
+			record.Flags2 != observed.TextFlags2 || record.Align != 4 || !bytes.Equal(record.Data, value.Data) {
+			t.Fatal("actual SDK complete SEH record differs", record, value)
+		}
+	}
+	for _, text := range observed.Texts {
+		if actual.Links[text.Name] != observed.Unwind[0].Name {
+			t.Fatal("actual SDK TEXT/SEH ownership differs", text.Name)
+		}
+	}
+
+	start := bytes.Index(data, []byte("\n!\n")) + 3
+	block := func(index int) int { return start + int(binary.LittleEndian.Uint32(data[start+20+index*4:])) }
+	symbol := block(3) + int(observed.Unwind[0].Index)*21
+	textSymbol := block(3) + int(observed.Texts[0].Index)*21
+	changes := map[string]func([]byte){
+		"other symbol enum":      func(v []byte) { v[symbol+10] = actual.Kind - 1 },
+		"unknown symbol enum":    func(v []byte) { v[symbol+10] = actual.Kind + 1 },
+		"other metadata flag2":   func(v []byte) { v[symbol+12] ^= 16 },
+		"other TEXT flag2":       func(v []byte) { v[textSymbol+12] ^= 16 },
+		"wrong binary alignment": func(v []byte) { v[symbol+17] = 0 },
+		"unknown auxiliary enum": func(v []byte) { v[block(15)] = actual.Aux + 1 },
+		"other auxiliary enum": func(v []byte) {
+			for pos := block(15); pos < block(16); pos += 9 {
+				if v[pos] == actual.Aux {
+					v[pos]--
+					return
+				}
+			}
+			t.Fatal("actual object omitted SEH link")
+		},
+	}
+	for name, change := range changes {
+		t.Run(name, func(t *testing.T) {
+			changed := append([]byte(nil), data...)
+			change(changed)
+			if _, err := ObserveWindowsAMD64AssemblyUnwind(changed, builtin); !errors.Is(err, ErrContext) {
+				t.Fatal("changed producer-specific object accepted", err)
+			}
+		})
+	}
+	for _, role := range windowsUnwindSourceRoles {
+		t.Run("source/"+role, func(t *testing.T) {
+			_, err := WindowsAMD64UnwindSources(version, func(name string) ([]byte, error) {
+				value, err := read(name)
+				if name == role {
+					value = append(value, '\n')
+				}
+				return value, err
+			})
+			if !errors.Is(err, ErrContext) {
+				t.Fatal("changed SDK source accepted", err)
+			}
+		})
+	}
+	if _, err := WindowsAMD64UnwindSources("go1.99.1", read); !errors.Is(err, ErrContext) {
+		t.Fatal("unregistered producer accepted", err)
+	}
+	if _, err := ObserveWindowsAMD64AssemblyUnwind(data, append(append([]byte(nil), builtin...), '\n')); !errors.Is(err, ErrContext) {
+		t.Fatal("changed builtin source accepted", err)
+	}
+	if version != "go1.27.1" && version != "go1.27.2" && version != "go1.27.3" {
+		if _, err := objectBody(data, "windows/amd64"); !errors.Is(err, ErrContext) {
+			t.Fatal("Windows role widened generic compiler object admission", err)
+		}
+	}
+	t.Logf("actual SDK %s: kind=%d aux=%d flags2=%d; %d TEXTs, %d shared unwind record",
+		version, actual.Kind, actual.Aux, actual.TextFlags2, len(observed.Texts), len(observed.Unwind))
+}
diff --git a/internal/gostaticstorage/x86_sdk_target.go b/internal/gostaticstorage/x86_sdk_target.go
new file mode 100644
index 000000000..1e0095423
--- /dev/null
+++ b/internal/gostaticstorage/x86_sdk_target.go
@@ -0,0 +1,27 @@
+package gostaticstorage
+
+// X86SDKTarget selects an observation grammar, not a source or storage lease.
+// Every object still has to carry the exact requested GOOS/GOARCH header, flags
+// and original selected member identity. Darwin/386 is not a current Go target.
+func X86SDKTarget(target string) bool {
+	switch target {
+	case "linux/386", "linux/amd64", "darwin/amd64", "windows/386", "windows/amd64":
+		return true
+	}
+	return false
+}
+
+// Go's default Darwin PIE profile passes -shared to its compiler and assembler;
+// Windows PIE does not. These are exact pinned SDK object flags, not a mask of
+// acceptable flags. Direct standalone tool objects retain their separate role.
+func sdkCompilerObjectFlags(target string) uint32 {
+	flags := uint32(16) // ObjFlagStd.
+	if target == "darwin/amd64" || target == "darwin/arm64" {
+		flags |= 1 // ObjFlagShared.
+	}
+	return flags
+}
+
+func sdkAssemblyObjectFlags(target string) uint32 {
+	return sdkCompilerObjectFlags(target) | 4 // ObjFlagFromAssembly.
+}
diff --git a/internal/gostaticstorage/x86_sdk_target_test.go b/internal/gostaticstorage/x86_sdk_target_test.go
new file mode 100644
index 000000000..463330670
--- /dev/null
+++ b/internal/gostaticstorage/x86_sdk_target_test.go
@@ -0,0 +1,60 @@
+package gostaticstorage
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+func TestX86SDKTargetExactProfiles(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "darwin/amd64", "windows/386", "windows/amd64"} {
+		if !X86SDKTarget(target) {
+			t.Fatalf("missing observed target grammar: %s", target)
+		}
+		compiler, assembly := uint32(16), uint32(20)
+		if target == "darwin/amd64" {
+			compiler, assembly = 17, 21
+		}
+		if sdkCompilerObjectFlags(target) != compiler || sdkAssemblyObjectFlags(target) != assembly {
+			t.Fatalf("%s lost its exact compiler/assembler object flags", target)
+		}
+	}
+	for _, target := range []string{"darwin/386", "freebsd/amd64", "linux/arm64", "windows/arm64", "js/wasm", "linux/amd64/", " linux/amd64"} {
+		if X86SDKTarget(target) {
+			t.Fatalf("unobserved x86 SDK target accepted: %q", target)
+		}
+	}
+}
+
+func TestSDKExternalFunctionDirectiveDoesNotSupplyVariableBacking(t *testing.T) {
+	for _, test := range []struct {
+		name, declaration string
+		accepted          bool
+	}{
+		{"external", "//go:linknamestd callback\nfunc callback(value uint32) bool", true},
+		{"variable", "//go:linknamestd callback\nvar callback uint32", false},
+		{"implemented", "//go:linknamestd callback\nfunc callback(value uint32) bool { return false }", false},
+		{"different-function", "//go:linknamestd callback\nfunc other(value uint32) bool", false},
+		{"unattached", "//go:linknamestd callback\n\nfunc callback(value uint32) bool", false},
+		{"method", "type Owner struct{}\n//go:linknamestd callback\nfunc (Owner) callback(value uint32) bool", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), "fixture.go", "package fixture\n"+test.declaration, parser.ParseComments)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var directive *ast.Comment
+			for _, group := range file.Comments {
+				for _, comment := range group.List {
+					if comment.Text == "//go:linknamestd callback" {
+						directive = comment
+					}
+				}
+			}
+			if directive == nil || sdkExternalFunctionDirective(file, directive, "callback") != test.accepted {
+				t.Fatal("directive does not retain its exact attached external-function role")
+			}
+		})
+	}
+}
diff --git a/internal/gosym/package_prefix.go b/internal/gosym/package_prefix.go
new file mode 100644
index 000000000..0bd12c176
--- /dev/null
+++ b/internal/gosym/package_prefix.go
@@ -0,0 +1,39 @@
+// Package gosym describes Go's native symbol spelling, not source permissions
+// or the LLVM logical namespace.
+package gosym
+
+import "strings"
+
+// PackagePrefix implements objabi.PathToPrefix's byte grammar. Only periods
+// after the final slash are escaped; UTF-8 is escaped one byte at a time.
+func PackagePrefix(packagePath string) string {
+	lastSlash := strings.LastIndexByte(packagePath, '/')
+	escaped := func(index int) bool {
+		value := packagePath[index]
+		return value <= ' ' || value == '.' && index > lastSlash ||
+			value == '%' || value == '"' || value >= 0x7f
+	}
+	count := 0
+	for index := 0; index < len(packagePath); index++ {
+		if escaped(index) {
+			count++
+		}
+	}
+	if count == 0 {
+		return packagePath
+	}
+	const hex = "0123456789abcdef"
+	var prefix strings.Builder
+	prefix.Grow(len(packagePath) + 2*count)
+	for index := 0; index < len(packagePath); index++ {
+		value := packagePath[index]
+		if escaped(index) {
+			prefix.WriteByte('%')
+			prefix.WriteByte(hex[value>>4])
+			prefix.WriteByte(hex[value&0xf])
+		} else {
+			prefix.WriteByte(value)
+		}
+	}
+	return prefix.String()
+}
diff --git a/internal/gosym/package_prefix_test.go b/internal/gosym/package_prefix_test.go
new file mode 100644
index 000000000..37ca24936
--- /dev/null
+++ b/internal/gosym/package_prefix_test.go
@@ -0,0 +1,44 @@
+package gosym
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestPackagePrefixByteGrammar(t *testing.T) {
+	for _, test := range []struct{ raw, native string }{
+		{"", ""},
+		{"example.invalid/plain", "example.invalid/plain"},
+		{"gopkg.in/example.v3", "gopkg.in/example%2ev3"},
+		{"example.invalid/dotted.path/plain", "example.invalid/dotted.path/plain"},
+		{"a/b.c.d", "a/b%2ec%2ed"},
+		{"a/%2e", "a/%252e"},
+		{"a/\"quoted\"", "a/%22quoted%22"},
+		{"a/空间", "a/%e7%a9%ba%e9%97%b4"},
+		{"a/\x00\x1f \x7f", "a/%00%1f%20%7f"},
+	} {
+		t.Run(fmt.Sprintf("%q", test.raw), func(t *testing.T) {
+			if actual := PackagePrefix(test.raw); actual != test.native {
+				t.Fatalf("native byte spelling = %q, want %q", actual, test.native)
+			}
+		})
+	}
+	for value := 0; value <= 255; value++ {
+		for _, final := range []bool{false, true} {
+			t.Run(fmt.Sprintf("byte-%02x/final=%t", value, final), func(t *testing.T) {
+				encoded := string([]byte{byte(value)})
+				// Explicit ASCII classes from objabi's grammar, not URL rules.
+				if value <= 32 || value >= 127 || value == 34 || value == 37 || final && value == 46 {
+					encoded = fmt.Sprintf("%%%02x", value)
+				}
+				raw, expected := "domain/"+string([]byte{byte(value)}), "domain/"+encoded
+				if !final {
+					raw, expected = string([]byte{byte(value)})+"/pkg", encoded+"/pkg"
+				}
+				if actual := PackagePrefix(raw); actual != expected {
+					t.Fatalf("native byte spelling = %q, want %q", actual, expected)
+				}
+			})
+		}
+	}
+}
diff --git a/internal/gotoolchain/executable.go b/internal/gotoolchain/executable.go
new file mode 100644
index 000000000..a713de867
--- /dev/null
+++ b/internal/gotoolchain/executable.go
@@ -0,0 +1,16 @@
+package gotoolchain
+
+import "runtime"
+
+// HostExecutable adds the host's executable suffix. It is independent of the
+// observed assembly target: a Windows Go driver can emit Linux objects.
+func HostExecutable(name string) string {
+	return hostExecutable(name, runtime.GOOS)
+}
+
+func hostExecutable(name, goos string) string {
+	if goos == "windows" {
+		return name + ".exe"
+	}
+	return name
+}
diff --git a/internal/gotoolchain/executable_test.go b/internal/gotoolchain/executable_test.go
new file mode 100644
index 000000000..0dbe0d4a8
--- /dev/null
+++ b/internal/gotoolchain/executable_test.go
@@ -0,0 +1,32 @@
+package gotoolchain
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestHostExecutableNames(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin", "windows"} {
+		for _, name := range []string{"go", "asm", "official-reader"} {
+			want := name
+			if goos == "windows" {
+				want += ".exe"
+			}
+			if got := hostExecutable(name, goos); got != want {
+				t.Fatalf("%s/%s: got %q, want %q", goos, name, got, want)
+			}
+		}
+	}
+	root, err := Root()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if HostExecutable("go") != hostExecutable("go", runtime.GOOS) {
+		t.Fatal("host suffix differs")
+	}
+	if info, err := os.Stat(filepath.Join(root, "bin", HostExecutable("go"))); err != nil || !info.Mode().IsRegular() {
+		t.Fatal("actual selected SDK driver is missing", err)
+	}
+}
diff --git a/internal/gotoolchain/observation_version.go b/internal/gotoolchain/observation_version.go
new file mode 100644
index 000000000..8c2f419ec
--- /dev/null
+++ b/internal/gotoolchain/observation_version.go
@@ -0,0 +1,8 @@
+package gotoolchain
+
+// AuditedGo127 identifies releases whose observation formats have been
+// reviewed. It is only a version gate: consumers must still bind the actual
+// SDK sources, tools and object bytes. Unknown patches need a fresh audit.
+func AuditedGo127(version string) bool {
+	return version == "go1.27.1" || version == "go1.27.2" || version == "go1.27.3"
+}
diff --git a/internal/gotoolchain/observation_version_test.go b/internal/gotoolchain/observation_version_test.go
new file mode 100644
index 000000000..17f9c1ac8
--- /dev/null
+++ b/internal/gotoolchain/observation_version_test.go
@@ -0,0 +1,19 @@
+package gotoolchain
+
+import "testing"
+
+func TestAuditedGo127(t *testing.T) {
+	for _, version := range []string{"go1.27.1", "go1.27.2", "go1.27.3"} {
+		if !AuditedGo127(version) {
+			t.Errorf("audited release %q rejected", version)
+		}
+	}
+	for _, version := range []string{
+		"", "go1.27", "go1.27.0", "go1.27.4", "go1.28.1", "go1.26.2",
+		"go1.27.3rc1", "go1.27.3-custom", "devel go1.27.3", "go1.27.3\n",
+	} {
+		if AuditedGo127(version) {
+			t.Errorf("unaudited release %q accepted", version)
+		}
+	}
+}
diff --git a/internal/gotoolchain/root.go b/internal/gotoolchain/root.go
new file mode 100644
index 000000000..e4ba3a7c5
--- /dev/null
+++ b/internal/gotoolchain/root.go
@@ -0,0 +1,50 @@
+package gotoolchain
+
+import (
+	"encoding/json"
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sync"
+)
+
+var fallback struct {
+	once sync.Once
+	root string
+	err  error
+}
+
+// Root returns the toolchain root that owns this binary's standard headers.
+// Trimpath builds omit the embedded GOROOT, so ask the matching go command.
+func Root() (string, error) {
+	if root := runtime.GOROOT(); root != "" {
+		return root, nil
+	}
+	fallback.once.Do(func() {
+		out, err := exec.Command("go", "env", "-json", "GOROOT", "GOVERSION").Output()
+		if err != nil {
+			fallback.err = fmt.Errorf("resolve GOROOT for trimpath binary: %w", err)
+			return
+		}
+		fallback.root, fallback.err = parseRoot(out, runtime.Version())
+	})
+	return fallback.root, fallback.err
+}
+
+func parseRoot(output []byte, binaryVersion string) (string, error) {
+	var env struct {
+		GOROOT    string `json:"GOROOT"`
+		GOVERSION string `json:"GOVERSION"`
+	}
+	if err := json.Unmarshal(output, &env); err != nil {
+		return "", fmt.Errorf("decode Go toolchain environment: %w", err)
+	}
+	if env.GOVERSION != binaryVersion {
+		return "", fmt.Errorf("Go toolchain version %q does not match binary version %q", env.GOVERSION, binaryVersion)
+	}
+	if !filepath.IsAbs(env.GOROOT) {
+		return "", fmt.Errorf("Go toolchain GOROOT %q is not absolute", env.GOROOT)
+	}
+	return env.GOROOT, nil
+}
diff --git a/internal/gotoolchain/root_test.go b/internal/gotoolchain/root_test.go
new file mode 100644
index 000000000..dc77c22e0
--- /dev/null
+++ b/internal/gotoolchain/root_test.go
@@ -0,0 +1,47 @@
+package gotoolchain
+
+import (
+	"path/filepath"
+	"strconv"
+	"testing"
+)
+
+func TestParseRootRejectsMismatchedOrInvalidGo(t *testing.T) {
+	root := t.TempDir()
+	for _, test := range []struct {
+		name    string
+		output  string
+		version string
+		wantErr bool
+	}{
+		{
+			name: "matching", output: `{"GOROOT":` + strconv.Quote(root) + `,"GOVERSION":"go1.27.1"}`,
+			version: "go1.27.1",
+		},
+		{
+			name: "different version", output: `{"GOROOT":` + strconv.Quote(root) + `,"GOVERSION":"go1.27.0"}`,
+			version: "go1.27.1", wantErr: true,
+		},
+		{
+			name: "relative root", output: `{"GOROOT":"relative","GOVERSION":"go1.27.1"}`,
+			version: "go1.27.1", wantErr: true,
+		},
+		{
+			name: "missing root", output: `{"GOVERSION":"go1.27.1"}`,
+			version: "go1.27.1", wantErr: true,
+		},
+		{
+			name: "invalid JSON", output: `{`, version: "go1.27.1", wantErr: true,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := parseRoot([]byte(test.output), test.version)
+			if (err != nil) != test.wantErr {
+				t.Fatalf("root = %q, error = %v, want error %v", got, err, test.wantErr)
+			}
+			if !test.wantErr && filepath.Clean(got) != root {
+				t.Fatalf("root = %q, want %q", got, root)
+			}
+		})
+	}
+}
diff --git a/internal/nativeoracle/darwin.go b/internal/nativeoracle/darwin.go
new file mode 100644
index 000000000..b1c261850
--- /dev/null
+++ b/internal/nativeoracle/darwin.go
@@ -0,0 +1,57 @@
+// Package nativeoracle configures test-only native C drivers. Its SDK selection
+// supplies no translator source, frame, ABI or numerical-state permission.
+package nativeoracle
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// DarwinClangFlags uses the actual developer selection, not SDKROOT or a guessed
+// SDK version. LLVM's default configuration may override both environment and
+// ordinary compiler flags, so disable it explicitly before selecting the SDK.
+// The caller retains its independent LLVM 22 version and command ownership checks.
+func DarwinClangFlags(ctx context.Context, environment []string) ([]string, error) {
+	if ctx == nil {
+		return nil, fmt.Errorf("native macOS SDK query requires a bounded context")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, fmt.Errorf("native macOS SDK query requires a bounded context")
+	}
+	observed, err := goasmcmd.Observe(ctx, "", environment, "/usr/bin/xcrun",
+		"--sdk", "macosx", "--show-sdk-path")
+	if err != nil {
+		return nil, fmt.Errorf("required actual macOS SDK query: %w; stdout=%q stderr=%q",
+			err, observed.Stdout, observed.Stderr)
+	}
+	if len(observed.Stderr) != 0 {
+		return nil, fmt.Errorf("required actual macOS SDK query emitted diagnostics: stdout=%q stderr=%q",
+			observed.Stdout, observed.Stderr)
+	}
+	return darwinClangFlagsFromSDKOutput(observed.Stdout)
+}
+
+func darwinClangFlagsFromSDKOutput(output []byte) ([]string, error) {
+	text := string(output)
+	if !strings.HasSuffix(text, "\n") {
+		return nil, fmt.Errorf("actual macOS SDK query did not return one complete absolute path")
+	}
+	requested := strings.TrimSuffix(text, "\n")
+	if !filepath.IsAbs(requested) || strings.ContainsAny(requested, "\r\n\x00") {
+		return nil, fmt.Errorf("actual macOS SDK query did not return one complete absolute path")
+	}
+	root, err := filepath.EvalSymlinks(requested)
+	if err != nil {
+		return nil, fmt.Errorf("resolve actual macOS SDK directory: %w", err)
+	}
+	info, err := os.Stat(root)
+	if err != nil || !info.IsDir() {
+		return nil, fmt.Errorf("actual macOS SDK path is not a directory: %q: %v", root, err)
+	}
+	return []string{"--no-default-config", "-isysroot", root}, nil
+}
diff --git a/internal/nativeoracle/darwin_query_darwin_test.go b/internal/nativeoracle/darwin_query_darwin_test.go
new file mode 100644
index 000000000..1b4cd77f4
--- /dev/null
+++ b/internal/nativeoracle/darwin_query_darwin_test.go
@@ -0,0 +1,43 @@
+package nativeoracle
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestDarwinClangFlagsMissingDeveloperSelectionNeverUsesSDKROOT(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	environment := append(os.Environ(),
+		"DEVELOPER_DIR="+filepath.Join(t.TempDir(), "missing-developer-tools"),
+		"SDKROOT="+t.TempDir())
+	if flags, err := DarwinClangFlags(ctx, environment); err == nil || flags != nil {
+		t.Fatalf("missing actual developer SDK fell back to SDKROOT: flags=%q err=%v", flags, err)
+	}
+}
+
+func TestDarwinClangFlagsResolveActualDirectoryAlias(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "owned SDK")
+	if err := os.Mkdir(root, 0700); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(t.TempDir(), "SDK alias")
+	if err := os.Symlink(root, alias); err != nil {
+		t.Fatal(err)
+	}
+	flags, err := darwinClangFlagsFromSDKOutput([]byte(alias + "\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected, err := os.Stat(flags[2])
+	if err != nil {
+		t.Fatal(err)
+	}
+	original, err := os.Stat(root)
+	if err != nil || !os.SameFile(selected, original) {
+		t.Fatalf("SDK flags invented a directory identity: %v", err)
+	}
+}
diff --git a/internal/nativeoracle/darwin_test.go b/internal/nativeoracle/darwin_test.go
new file mode 100644
index 000000000..cd6933956
--- /dev/null
+++ b/internal/nativeoracle/darwin_test.go
@@ -0,0 +1,49 @@
+package nativeoracle
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestDarwinClangFlagsRequireCompleteExistingDirectory(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "actual SDK with spaces")
+	if err := os.Mkdir(root, 0700); err != nil {
+		t.Fatal(err)
+	}
+	physical, err := filepath.EvalSymlinks(root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	flags, err := darwinClangFlagsFromSDKOutput([]byte(root + "\n"))
+	want := []string{"--no-default-config", "-isysroot", physical}
+	if err != nil || !reflect.DeepEqual(flags, want) {
+		t.Fatalf("actual SDK arguments=%q want=%q error=%v", flags, want, err)
+	}
+	file := filepath.Join(t.TempDir(), "not-a-directory")
+	if err := os.WriteFile(file, []byte("not an SDK"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, output := range []string{
+		"", root, root + "\n\n", root + "\r\n", root + "\n/other\n",
+		"relative/SDK\n", root + "\x00\n", file + "\n",
+		filepath.Join(root, "missing") + "\n",
+	} {
+		if flags, err := darwinClangFlagsFromSDKOutput([]byte(output)); err == nil || flags != nil {
+			t.Fatalf("malformed/missing SDK selection accepted: output=%q flags=%q err=%v", output, flags, err)
+		}
+	}
+}
+
+func TestDarwinClangFlagsRejectUnboundedAndExpiredQueries(t *testing.T) {
+	expired, cancel := context.WithDeadline(context.Background(), time.Now().Add(-time.Second))
+	defer cancel()
+	for _, ctx := range []context.Context{nil, context.Background(), expired} {
+		if flags, err := DarwinClangFlags(ctx, nil); err == nil || flags != nil {
+			t.Fatalf("unbounded/expired SDK query accepted: flags=%q err=%v", flags, err)
+		}
+	}
+}
diff --git a/internal/ownedprocess/group_darwin_test.go b/internal/ownedprocess/group_darwin_test.go
new file mode 100644
index 000000000..1a54bd2aa
--- /dev/null
+++ b/internal/ownedprocess/group_darwin_test.go
@@ -0,0 +1,152 @@
+//go:build darwin
+
+package ownedprocess
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestDarwinOwnedZombieGroup(t *testing.T) {
+	if os.Getenv("PLAN9ASM_ZOMBIE_FIXTURE") == "1" {
+		os.Exit(0)
+	}
+	command := exec.Command(os.Args[0], "-test.run=^TestDarwinOwnedZombieGroup$")
+	command.Env = append(os.Environ(), "PLAN9ASM_ZOMBIE_FIXTURE=1")
+	command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	if err := command.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = command.Process.Kill()
+		_ = command.Wait()
+	}()
+	pid := command.Process.Pid
+	deadline := time.Now().Add(3 * time.Second)
+	for {
+		members, err := observeProcessGroup(pid)
+		if err != nil {
+			t.Fatalf("observe exact owned zombie: %v", err)
+		}
+		if len(members) == 1 && members[0].PID == pid && members[0].State == "Z" {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatalf("owned child did not become a zombie: %v", members)
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	if err := syscall.Kill(-pid, syscall.SIGKILL); !errors.Is(err, syscall.EPERM) {
+		t.Fatalf("actual Darwin zombie-only group did not reproduce EPERM: %v", err)
+	}
+	err := stopGroup(pid, false, syscall.Kill, func(pgid int) ([]groupMember, error) {
+		return []groupMember{{PID: pid, PGID: pgid, State: "Z"}}, nil
+	})
+	if !errors.Is(err, syscall.EPERM) || errors.Is(err, os.ErrProcessDone) {
+		t.Fatalf("unwaited owned group permission error was suppressed: %v", err)
+	}
+}
+
+// Hold a zombie in the fresh group after its leader has actually been waited.
+// Its outside-group supervisor is this test, so the kernel cannot reap it
+// before the post-Wait cleanup check. Every process and file is test-owned.
+func TestDarwinReapedParentZombieDescendant(t *testing.T) {
+	switch os.Getenv("PLAN9ASM_REAPED_GROUP_FIXTURE") {
+	case "leader":
+		if err := os.WriteFile("ready", []byte(strconv.Itoa(os.Getpid())), 0600); err != nil {
+			os.Exit(5)
+		}
+		for end := time.Now().Add(10 * time.Second); time.Now().Before(end); {
+			if _, err := os.Stat("release"); err == nil {
+				os.Exit(0)
+			}
+			time.Sleep(5 * time.Millisecond)
+		}
+		os.Exit(6)
+	case "zombie":
+		os.Exit(0)
+	}
+	dir := t.TempDir()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	leader := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestDarwinReapedParentZombieDescendant$")
+	leader.Env = append(os.Environ(), "PLAN9ASM_REAPED_GROUP_FIXTURE=leader")
+	leader.Dir = dir
+	done := make(chan error, 1)
+	go func() { done <- Run(leader) }()
+	finished := false
+	defer func() {
+		cancel()
+		if !finished {
+			select {
+			case <-done:
+			case <-time.After(3 * time.Second):
+				t.Error("owned leader cleanup did not complete")
+			}
+		}
+	}()
+	var pgid int
+	for end := time.Now().Add(3 * time.Second); pgid == 0; {
+		if data, err := os.ReadFile(filepath.Join(dir, "ready")); err == nil {
+			pgid, _ = strconv.Atoi(string(data))
+		}
+		if time.Now().After(end) {
+			t.Fatal("owned leader did not start")
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	child := exec.Command(os.Args[0], "-test.run=^TestDarwinReapedParentZombieDescendant$")
+	child.Env = append(os.Environ(), "PLAN9ASM_REAPED_GROUP_FIXTURE=zombie")
+	child.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pgid: pgid}
+	if err := child.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = child.Process.Kill()
+		_ = child.Wait()
+	}()
+	for end := time.Now().Add(3 * time.Second); ; {
+		members, err := observeProcessGroup(pgid)
+		if err != nil {
+			t.Fatalf("owned descendant snapshot: %v", err)
+		}
+		exited := false
+		for _, member := range members {
+			if member.PID == child.Process.Pid && member.State == "Z" {
+				exited = true
+			}
+		}
+		if exited {
+			break
+		}
+		if time.Now().After(end) {
+			t.Fatalf("descendant did not exit: %v", members)
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "release"), nil, 0600); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case err := <-done:
+		finished = true
+		if leader.ProcessState == nil {
+			t.Fatal("leader was not actually waited")
+		}
+		if signalErr := syscall.Kill(-pgid, syscall.SIGKILL); !errors.Is(signalErr, syscall.EPERM) {
+			t.Fatalf("actual zombie-only Darwin group: %v", signalErr)
+		}
+		if err != nil {
+			t.Fatalf("reaped parent with zombie-only descendants rejected: %v", err)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("post-Wait cleanup did not finish")
+	}
+}
diff --git a/internal/ownedprocess/group_linux_test.go b/internal/ownedprocess/group_linux_test.go
new file mode 100644
index 000000000..d655bb2a3
--- /dev/null
+++ b/internal/ownedprocess/group_linux_test.go
@@ -0,0 +1,109 @@
+//go:build linux
+
+package ownedprocess
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestLinuxOwnedGroupWaitsForTerminationWithUnreapedZombie(t *testing.T) {
+	const variable = "PLAN9ASM_LINUX_GROUP_FIXTURE"
+	switch os.Getenv(variable) {
+	case "zombie":
+		os.Exit(0)
+	case "leader":
+		if err := os.WriteFile("ready", []byte(strconv.Itoa(os.Getpid())), 0600); err != nil {
+			os.Exit(2)
+		}
+		for end := time.Now().Add(10 * time.Second); time.Now().Before(end); {
+			if _, err := os.Stat("release"); err == nil {
+				os.Exit(0)
+			}
+			time.Sleep(time.Millisecond)
+		}
+		os.Exit(3)
+	}
+	directory := t.TempDir()
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	command := func(role string) *exec.Cmd {
+		cmd := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestLinuxOwnedGroupWaitsForTerminationWithUnreapedZombie$")
+		cmd.Env = append(os.Environ(), variable+"="+role)
+		cmd.Dir = directory
+		return cmd
+	}
+	leader := command("leader")
+	done := make(chan error, 1)
+	go func() { done <- Run(leader) }()
+	joined := false
+	defer func() {
+		cancel()
+		if !joined {
+			<-done
+		}
+	}()
+	var pgid int
+	for pgid == 0 && ctx.Err() == nil {
+		data, _ := os.ReadFile(filepath.Join(directory, "ready"))
+		pgid, _ = strconv.Atoi(string(data))
+		if pgid == 0 {
+			time.Sleep(time.Millisecond)
+		}
+	}
+	if pgid <= 1 {
+		t.Fatal("owned leader did not become ready", ctx.Err())
+	}
+	child := command("zombie")
+	child.SysProcAttr = &syscall.SysProcAttr{Setpgid: true, Pgid: pgid}
+	if err := child.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = child.Process.Kill(); _ = child.Wait() }()
+	for {
+		members, err := observeProcessGroup(pgid)
+		if err != nil {
+			t.Fatal(err)
+		}
+		exited := false
+		for _, member := range members {
+			exited = exited || member.PID == child.Process.Pid && member.State == "Z"
+		}
+		if exited {
+			break
+		}
+		if ctx.Err() != nil {
+			t.Fatal("owned child failed to reach its actual zombie state", ctx.Err())
+		}
+		time.Sleep(time.Millisecond)
+	}
+	if err := os.WriteFile(filepath.Join(directory, "release"), nil, 0600); err != nil {
+		t.Fatal(err)
+	}
+	err := <-done
+	joined = true
+	if err != nil || leader.ProcessState == nil {
+		t.Fatal("waited leader and truly exited child were not joined", err)
+	}
+	if err := syscall.Kill(child.Process.Pid, 0); err != nil {
+		t.Fatal("independent parent did not retain the zombie until Wait", err)
+	}
+	data, err := os.ReadFile(fmt.Sprintf("/proc/%d/stat", child.Process.Pid))
+	if err != nil {
+		t.Fatal(err)
+	}
+	end := strings.LastIndex(string(data), ") ")
+	if end < 0 || !strings.HasPrefix(string(data), strconv.Itoa(child.Process.Pid)+" (") ||
+		!strings.HasPrefix(string(data[end+2:]), "Z ") {
+		t.Fatalf("independent kernel record does not prove this child exited: %s", data)
+	}
+	t.Logf("kernel terminal child remains visible until its owning parent reaps: %s", data)
+}
diff --git a/internal/ownedprocess/group_unix.go b/internal/ownedprocess/group_unix.go
new file mode 100644
index 000000000..f7b2d7632
--- /dev/null
+++ b/internal/ownedprocess/group_unix.go
@@ -0,0 +1,110 @@
+//go:build unix
+
+package ownedprocess
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// ErrCleanup distinguishes descendant cleanup failures from the command exit.
+var ErrCleanup = errors.New("owned command descendants")
+
+type groupMember struct {
+	PID   int
+	PGID  int
+	State string
+	Born  uint64 // Linux starttime prevents reused PIDs matching a prior snapshot.
+}
+
+type groupObserver func(int) ([]groupMember, error)
+
+// Run owns only this command's newly created process group. Both cancellation
+// and ordinary parent exit stop descendants before the caller removes files.
+func Run(command *exec.Cmd) error {
+	command.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	command.Cancel = func() error {
+		if command.Process == nil {
+			return os.ErrProcessDone
+		}
+		return stopGroup(command.Process.Pid, false, syscall.Kill, observeProcessGroup)
+	}
+	err := command.Run()
+	if command.Process != nil {
+		cleanup := stopGroup(command.Process.Pid, command.ProcessState != nil, syscall.Kill, observeProcessGroup)
+		if cleanup != nil && !errors.Is(cleanup, os.ErrProcessDone) {
+			err = errors.Join(err, fmt.Errorf("%w: %w", ErrCleanup, cleanup))
+		}
+	}
+	return err
+}
+
+func stopGroup(pgid int, parentReaped bool, kill func(int, syscall.Signal) error, observe groupObserver) error {
+	if pgid <= 1 {
+		return fmt.Errorf("refuse an unowned process group: %d", pgid)
+	}
+	err := kill(-pgid, syscall.SIGKILL)
+	if errors.Is(err, syscall.ESRCH) {
+		return os.ErrProcessDone
+	}
+	if err != nil && !errors.Is(err, syscall.EPERM) || !parentReaped || observe == nil {
+		return err
+	}
+	deadline := time.Now().Add(3 * time.Second)
+	tick := time.NewTicker(5 * time.Millisecond)
+	defer tick.Stop()
+	var previous map[int]groupMember
+	for {
+		members, snapshotErr := observe(pgid)
+		if snapshotErr != nil {
+			return errors.Join(err, fmt.Errorf("inspect exited owned group: %w", snapshotErr))
+		}
+		seen := make(map[int]groupMember, len(members))
+		terminal, stable := true, previous != nil && len(previous) == len(members)
+		for _, member := range members {
+			if member.PID <= 1 || member.PGID != pgid || seen[member.PID].PID != 0 || !validGroupState(member.State) {
+				return errors.Join(err, fmt.Errorf("owned group membership is unknown"))
+			}
+			seen[member.PID] = member
+			terminal = terminal && member.State[0] == 'Z'
+			stable = stable && previous[member.PID] == member
+		}
+		if terminal && stable {
+			// Zombies cannot fork or write files. Their outside-group parent,
+			// not this owner, must reap them. Two complete terminal snapshots
+			// also close a child forked during a non-atomic /proc traversal.
+			return os.ErrProcessDone
+		}
+		if !terminal && err != nil || time.Now().After(deadline) {
+			return errors.Join(err, fmt.Errorf("owned group still has a live or unstable member"))
+		}
+		previous = nil
+		if terminal {
+			previous = seen
+		}
+		<-tick.C
+	}
+}
+
+func validGroupState(state string) bool {
+	// Linux has additional live states (uninterruptible, tracing, idle).
+	// None is terminal credit; only a validated Z record establishes exit.
+	return validDarwinState(state) || len(state) == 1 && strings.ContainsRune("DtXxKWP", rune(state[0]))
+}
+
+func validDarwinState(state string) bool {
+	if len(state) == 0 || !strings.ContainsRune("IRSTUZ", rune(state[0])) {
+		return false
+	}
+	for _, modifier := range state[1:] {
+		if !strings.ContainsRune("+<>AELNSsVWX", modifier) {
+			return false
+		}
+	}
+	return true
+}
diff --git a/internal/ownedprocess/group_unix_test.go b/internal/ownedprocess/group_unix_test.go
new file mode 100644
index 000000000..7152bc1b1
--- /dev/null
+++ b/internal/ownedprocess/group_unix_test.go
@@ -0,0 +1,184 @@
+//go:build unix
+
+package ownedprocess
+
+import (
+	"errors"
+	"os"
+	"syscall"
+	"testing"
+)
+
+func TestOwnedGroupPermissionRequiresExitedMembership(t *testing.T) {
+	const pgid = 4123
+	for _, test := range []struct {
+		name         string
+		parentReaped bool
+		members      []groupMember
+		observeErr   error
+		wantDone     bool
+	}{
+		{name: "reaped absent", parentReaped: true, wantDone: true},
+		{name: "reaped zombie descendants", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid, State: "Z"}}, wantDone: true},
+		{name: "zombie leader before wait", members: []groupMember{{PID: pgid, PGID: pgid, State: "Z"}, {PID: 4124, PGID: pgid, State: "Z+"}}},
+		{name: "leader termination unknown"},
+		{name: "leader missing with zombie descendant", members: []groupMember{{PID: 4124, PGID: pgid, State: "Z"}}},
+		{name: "live leader", members: []groupMember{{PID: pgid, PGID: pgid, State: "S"}}},
+		{name: "live descendant", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid, State: "R"}}},
+		{name: "stopped descendant", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid, State: "T"}}},
+		{name: "unknown state", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid, State: "?"}}},
+		{name: "wrong group", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid + 1, State: "Z"}}},
+		{name: "unknown pid", parentReaped: true, members: []groupMember{{PGID: pgid, State: "Z"}}},
+		{name: "duplicate member", parentReaped: true, members: []groupMember{{PID: 4124, PGID: pgid, State: "Z"}, {PID: 4124, PGID: pgid, State: "Z"}}},
+		{name: "inaccessible membership", parentReaped: true, observeErr: syscall.EPERM},
+		{name: "snapshot unavailable", parentReaped: true, observeErr: syscall.EIO},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			calls := 0
+			err := stopGroup(pgid, test.parentReaped, func(pid int, signal syscall.Signal) error {
+				if pid != -pgid || signal != syscall.SIGKILL {
+					t.Fatalf("unowned signal: %d %v", pid, signal)
+				}
+				return syscall.EPERM
+			}, func(observed int) ([]groupMember, error) {
+				calls++
+				if observed != pgid {
+					t.Fatalf("unowned observation: %d", observed)
+				}
+				return test.members, test.observeErr
+			})
+			wantCalls := 0
+			if test.parentReaped {
+				wantCalls = 1
+				if test.wantDone {
+					wantCalls = 2 // Independent terminal snapshots close membership races.
+				}
+			}
+			if calls != wantCalls {
+				t.Fatalf("permission result lacks a post-Wait membership check: got %d want %d", calls, wantCalls)
+			}
+			if test.wantDone {
+				if !errors.Is(err, os.ErrProcessDone) {
+					t.Fatalf("independently exited group rejected: %v", err)
+				}
+			} else if !errors.Is(err, syscall.EPERM) || errors.Is(err, os.ErrProcessDone) {
+				t.Fatalf("live/unknown/inaccessible group accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestOwnedGroupRejectsBroadSignalTargets(t *testing.T) {
+	for _, pgid := range []int{-1, 0, 1} {
+		called := false
+		err := stopGroup(pgid, true, func(int, syscall.Signal) error {
+			called = true
+			return nil
+		}, nil)
+		if err == nil || called {
+			t.Fatalf("unowned broad target was signalled: %d %v", pgid, err)
+		}
+	}
+}
+
+func TestOwnedGroupOtherSignalOutcomesRemainExact(t *testing.T) {
+	for _, signalErr := range []error{nil, syscall.ESRCH, syscall.EIO, syscall.EINVAL, syscall.EPERM} {
+		err := stopGroup(4123, true, func(int, syscall.Signal) error { return signalErr }, nil)
+		if signalErr == syscall.ESRCH {
+			if !errors.Is(err, os.ErrProcessDone) {
+				t.Fatalf("absent group: %v", err)
+			}
+		} else if err != signalErr {
+			t.Fatalf("signal error changed: got %v want %v", err, signalErr)
+		}
+	}
+}
+
+func TestOwnedGroupSuccessfulSignalRequiresTerminalMembership(t *testing.T) {
+	const pgid = 4123
+	for _, row := range []struct {
+		name       string
+		states     [][]groupMember
+		minimum    int
+		observeErr error
+	}{
+		{name: "terminal members", states: [][]groupMember{{{PID: 4124, PGID: pgid, State: "Z"}}}, minimum: 2},
+		{name: "signal delivery is asynchronous", states: [][]groupMember{
+			{{PID: 4124, PGID: pgid, State: "S"}},
+			{{PID: 4124, PGID: pgid, State: "Z"}},
+		}, minimum: 3},
+		{name: "new descendant requires another complete observation", states: [][]groupMember{
+			{{PID: 4124, PGID: pgid, State: "Z"}},
+			{{PID: 4124, PGID: pgid, State: "Z"}, {PID: 4125, PGID: pgid, State: "Z"}},
+		}, minimum: 3},
+		{name: "reused pid requires another complete observation", states: [][]groupMember{
+			{{PID: 4124, PGID: pgid, State: "Z", Born: 100}},
+			{{PID: 4124, PGID: pgid, State: "Z", Born: 200}},
+		}, minimum: 3},
+		{name: "live member exceeds the bounded join", states: [][]groupMember{{{PID: 4124, PGID: pgid, State: "R"}}}, minimum: 2},
+		{name: "live then inaccessible", states: [][]groupMember{{{PID: 4124, PGID: pgid, State: "R"}}}, minimum: 2, observeErr: syscall.EACCES},
+		{name: "unknown kernel state", states: [][]groupMember{{{PID: 4124, PGID: pgid, State: "?"}}}, minimum: 1},
+		{name: "foreign group", states: [][]groupMember{{{PID: 4124, PGID: pgid + 1, State: "Z"}}}, minimum: 1},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			calls := 0
+			err := stopGroup(pgid, true, func(pid int, signal syscall.Signal) error {
+				if pid != -pgid || signal != syscall.SIGKILL {
+					t.Fatalf("cleanup signalled a different group or invented success probe: %d %v", pid, signal)
+				}
+				return nil
+			}, func(group int) ([]groupMember, error) {
+				calls++
+				if group != pgid {
+					t.Fatal("observed another group", group)
+				}
+				index := calls - 1
+				if index >= len(row.states) {
+					if row.observeErr != nil {
+						return nil, row.observeErr
+					}
+					index = len(row.states) - 1
+				}
+				return row.states[index], nil
+			})
+			if calls < row.minimum {
+				t.Fatal("accepted signal returned without terminal kernel observations", calls, err)
+			}
+			wantDone := row.name == "terminal members" || row.name == "signal delivery is asynchronous" ||
+				row.name == "new descendant requires another complete observation" ||
+				row.name == "reused pid requires another complete observation"
+			if wantDone != errors.Is(err, os.ErrProcessDone) || !wantDone && err == nil {
+				t.Fatal("live, unknown, or unstable membership acquired terminal credit", err)
+			}
+			if row.observeErr != nil && !errors.Is(err, row.observeErr) {
+				t.Fatal("membership failure was lost", err)
+			}
+		})
+	}
+}
+
+func TestOwnedGroupAbsentFastPathDoesNotInspect(t *testing.T) {
+	for _, row := range []struct {
+		name         string
+		parentReaped bool
+		signalErr    error
+	}{
+		{name: "already absent", parentReaped: true, signalErr: syscall.ESRCH},
+		{name: "parent still needs Wait"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			err := stopGroup(4123, row.parentReaped, func(pid int, signal syscall.Signal) error {
+				if pid != -4123 || signal != syscall.SIGKILL {
+					t.Fatal("unexpected signal", pid, signal)
+				}
+				return row.signalErr
+			}, func(int) ([]groupMember, error) {
+				t.Fatal("empty fast path or pre-Wait cancellation scanned membership")
+				return nil, syscall.EIO
+			})
+			if row.parentReaped && !errors.Is(err, os.ErrProcessDone) || !row.parentReaped && err != nil {
+				t.Fatal("original command outcome changed", err)
+			}
+		})
+	}
+}
diff --git a/internal/ownedprocess/job_windows.go b/internal/ownedprocess/job_windows.go
new file mode 100644
index 000000000..64f83fc9f
--- /dev/null
+++ b/internal/ownedprocess/job_windows.go
@@ -0,0 +1,251 @@
+package ownedprocess
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+// ErrCleanup distinguishes descendant cleanup failures from the command exit.
+var ErrCleanup = errors.New("owned command descendants")
+
+// Run creates the leader suspended, assigns it to a private non-breakaway job,
+// then resumes its sole initial thread. Assigning an already running process
+// would leave a race in which its earliest descendants escape the job.
+// The job handle is not inherited; closing it also terminates its descendants.
+func Run(command *exec.Cmd) (result error) {
+	job, err := windows.CreateJobObject(nil, nil)
+	if err != nil {
+		return err
+	}
+	owner := &windowsJob{handle: job}
+	defer func() { result = errors.Join(result, owner.close()) }()
+	owner.port, err = windows.CreateIoCompletionPort(windows.InvalidHandle, 0, 0, 1)
+	if err != nil {
+		return err
+	}
+	completion := struct {
+		Key  uintptr
+		Port windows.Handle
+	}{uintptr(job), owner.port}
+	if _, err := windows.SetInformationJobObject(job, windows.JobObjectAssociateCompletionPortInformation,
+		uintptr(unsafe.Pointer(&completion)), uint32(unsafe.Sizeof(completion))); err != nil {
+		return err
+	}
+	limits := windows.JOBOBJECT_EXTENDED_LIMIT_INFORMATION{}
+	limits.BasicLimitInformation.LimitFlags = windows.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE
+	if _, err := windows.SetInformationJobObject(job, windows.JobObjectExtendedLimitInformation,
+		uintptr(unsafe.Pointer(&limits)), uint32(unsafe.Sizeof(limits))); err != nil {
+		return err
+	}
+
+	attributes := syscall.SysProcAttr{}
+	if command.SysProcAttr != nil {
+		attributes = *command.SysProcAttr
+	}
+	if attributes.CreationFlags&(windows.CREATE_SUSPENDED|windows.CREATE_BREAKAWAY_FROM_JOB) != 0 {
+		return fmt.Errorf("owned command cannot inherit suspended or breakaway creation flags")
+	}
+	attributes.CreationFlags |= windows.CREATE_SUSPENDED
+	command.SysProcAttr = &attributes
+	// os/exec rejects Cancel on a command not created with CommandContext.
+	if command.Cancel != nil {
+		command.Cancel = func() error { return owner.cancel(command) }
+	}
+	if command.WaitDelay == 0 {
+		command.WaitDelay = 2 * time.Second
+	}
+	if err := command.Start(); err != nil {
+		return err
+	}
+	process, err := windows.OpenProcess(windows.PROCESS_SET_QUOTA|windows.PROCESS_TERMINATE|windows.SYNCHRONIZE,
+		false, uint32(command.Process.Pid))
+	if err == nil {
+		defer func() { result = errors.Join(result, windows.CloseHandle(process)) }()
+		err = owner.attachAndResume(process, uint32(command.Process.Pid))
+	}
+	if err != nil {
+		// An unassigned leader has never executed user code or created children.
+		killErr := command.Process.Kill()
+		if errors.Is(killErr, os.ErrProcessDone) {
+			killErr = nil
+		}
+		return errors.Join(err, killErr, owner.close(), command.Wait())
+	}
+
+	// Wait for the leader, not os/exec's output readers: a descendant may still
+	// hold stdout/stderr open. Cancel terminates this same private job.
+	state, waitErr := windows.WaitForSingleObject(process, windows.INFINITE)
+	if waitErr == nil && state != windows.WAIT_OBJECT_0 {
+		waitErr = fmt.Errorf("unexpected owned leader wait state %d", state)
+	}
+	cleanupErr := owner.close()
+	return errors.Join(waitErr, cleanupErr, command.Wait())
+}
+
+type windowsJob struct {
+	mu       sync.Mutex
+	handle   windows.Handle
+	port     windows.Handle
+	assigned bool
+	stopped  bool
+}
+
+func (owner *windowsJob) cancel(command *exec.Cmd) error {
+	owner.mu.Lock()
+	defer owner.mu.Unlock()
+	if owner.handle == 0 {
+		return os.ErrProcessDone
+	}
+	owner.stopped = true
+	if !owner.assigned {
+		return command.Process.Kill()
+	}
+	return windows.TerminateJobObject(owner.handle, 1)
+}
+
+func (owner *windowsJob) attachAndResume(process windows.Handle, pid uint32) error {
+	owner.mu.Lock()
+	defer owner.mu.Unlock()
+	if owner.stopped {
+		return fmt.Errorf("owned command cancelled before job assignment")
+	}
+	if err := windows.AssignProcessToJobObject(owner.handle, process); err != nil {
+		return fmt.Errorf("assign suspended command to private job: %w", err)
+	}
+	owner.assigned = true
+	thread, err := suspendedWindowsThread(pid)
+	if err != nil {
+		return err
+	}
+	count, resumeErr := windows.ResumeThread(thread)
+	closeErr := windows.CloseHandle(thread)
+	if resumeErr == nil && count != 1 {
+		resumeErr = fmt.Errorf("initial owned thread suspend count %d, want 1", count)
+	}
+	return errors.Join(resumeErr, closeErr)
+}
+
+func suspendedWindowsThread(pid uint32) (thread windows.Handle, result error) {
+	snapshot, err := windows.CreateToolhelp32Snapshot(windows.TH32CS_SNAPTHREAD, 0)
+	if err != nil {
+		return 0, err
+	}
+	defer func() {
+		result = errors.Join(result, windows.CloseHandle(snapshot))
+		if result != nil && thread != 0 {
+			result = errors.Join(result, windows.CloseHandle(thread))
+			thread = 0
+		}
+	}()
+	entry := windows.ThreadEntry32{Size: uint32(unsafe.Sizeof(windows.ThreadEntry32{}))}
+	var id uint32
+	for err = windows.Thread32First(snapshot, &entry); err == nil; err = windows.Thread32Next(snapshot, &entry) {
+		if entry.Size < uint32(unsafe.Offsetof(entry.OwnerProcessID)+unsafe.Sizeof(entry.OwnerProcessID)) {
+			return 0, fmt.Errorf("incomplete thread ownership snapshot")
+		}
+		if entry.OwnerProcessID == pid {
+			if id != 0 || entry.ThreadID == 0 {
+				return 0, fmt.Errorf("suspended command does not have one initial thread")
+			}
+			id = entry.ThreadID
+		}
+		entry.Size = uint32(unsafe.Sizeof(entry))
+	}
+	if !errors.Is(err, windows.ERROR_NO_MORE_FILES) {
+		return 0, err
+	}
+	if id == 0 {
+		return 0, fmt.Errorf("suspended command initial thread is missing")
+	}
+	thread, err = windows.OpenThread(windows.THREAD_SUSPEND_RESUME|windows.THREAD_QUERY_LIMITED_INFORMATION, false, id)
+	if err != nil {
+		return 0, err
+	}
+	// A snapshot ID is not ownership: an external termination can recycle a
+	// thread ID before OpenThread. Recheck the opened handle while the leader's
+	// process handle still pins its identity, before touching the thread state.
+	return thread, verifyWindowsThreadOwner(thread, pid)
+}
+
+var getProcessIDOfThread = windows.NewLazySystemDLL("kernel32.dll").NewProc("GetProcessIdOfThread")
+
+func verifyWindowsThreadOwner(thread windows.Handle, pid uint32) error {
+	actual, _, err := getProcessIDOfThread.Call(uintptr(thread))
+	if actual == 0 {
+		return fmt.Errorf("query opened thread ownership: %w", err)
+	}
+	if pid <= 1 || actual != uintptr(pid) {
+		return fmt.Errorf("opened thread belongs to process %d, not owned process %d", actual, pid)
+	}
+	return nil
+}
+
+func (owner *windowsJob) close() error {
+	owner.mu.Lock()
+	defer owner.mu.Unlock()
+	if owner.handle == 0 {
+		return nil
+	}
+	var err error
+	if owner.assigned {
+		err = windows.TerminateJobObject(owner.handle, 1)
+		if err == nil {
+			err = waitWindowsJobEmpty(owner.handle, owner.port)
+		}
+	}
+	// KILL_ON_JOB_CLOSE is also the fallback when explicit cleanup fails.
+	err = errors.Join(err, windows.CloseHandle(owner.handle))
+	owner.handle = 0
+	if owner.port != 0 {
+		err = errors.Join(err, windows.CloseHandle(owner.port))
+		owner.port = 0
+	}
+	if err != nil {
+		return fmt.Errorf("%w: %w", ErrCleanup, err)
+	}
+	return nil
+}
+
+var getJobCompletion = windows.NewLazySystemDLL("kernel32.dll").NewProc("GetQueuedCompletionStatus")
+
+const jobObjectMsgActiveProcessZero = 4 // winnt.h: JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO
+
+func waitWindowsJobEmpty(job, port windows.Handle) error {
+	// TerminateJobObject is asynchronous. ActiveProcesses accounting can reach
+	// zero before the processes finish exiting. The private completion port is
+	// attached before the first assignment, so no exit notification is missed.
+	deadline := time.Now().Add(5 * time.Second)
+	for {
+		remaining := time.Until(deadline)
+		if remaining <= 0 {
+			return fmt.Errorf("owned job did not complete process termination")
+		}
+		var message uint32
+		// Job packets use the OVERLAPPED field as an integer process ID, not a
+		// Go pointer. Do not expose that ID to the GC as *windows.Overlapped.
+		var key, id uintptr
+		ok, _, err := getJobCompletion.Call(uintptr(port), uintptr(unsafe.Pointer(&message)),
+			uintptr(unsafe.Pointer(&key)), uintptr(unsafe.Pointer(&id)),
+			uintptr((remaining+time.Millisecond-1)/time.Millisecond))
+		if ok == 0 {
+			return fmt.Errorf("wait for owned job termination: %w", err)
+		}
+		if key != uintptr(job) {
+			return fmt.Errorf("foreign completion in private owned job port")
+		}
+		if message == jobObjectMsgActiveProcessZero {
+			if id != 0 {
+				return fmt.Errorf("invalid process identity in empty-job completion")
+			}
+			return nil
+		}
+	}
+}
diff --git a/internal/ownedprocess/job_windows_test.go b/internal/ownedprocess/job_windows_test.go
new file mode 100644
index 000000000..1d80b30bf
--- /dev/null
+++ b/internal/ownedprocess/job_windows_test.go
@@ -0,0 +1,24 @@
+package ownedprocess
+
+import (
+	"os"
+	"testing"
+
+	"golang.org/x/sys/windows"
+)
+
+func TestWindowsOpenedThreadRetainsProcessIdentity(t *testing.T) {
+	thread := windows.CurrentThread()
+	pid := uint32(os.Getpid())
+	if err := verifyWindowsThreadOwner(thread, pid); err != nil {
+		t.Fatal(err)
+	}
+	for _, foreign := range []uint32{0, 1, pid + 1} {
+		if err := verifyWindowsThreadOwner(thread, foreign); err == nil {
+			t.Fatalf("foreign process %d borrowed the current thread", foreign)
+		}
+	}
+	if err := verifyWindowsThreadOwner(0, pid); err == nil {
+		t.Fatal("missing thread handle acquired ownership")
+	}
+}
diff --git a/internal/ownedprocess/observe_darwin_kernel.go b/internal/ownedprocess/observe_darwin_kernel.go
new file mode 100644
index 000000000..513cf65d3
--- /dev/null
+++ b/internal/ownedprocess/observe_darwin_kernel.go
@@ -0,0 +1,97 @@
+//go:build darwin
+
+package ownedprocess
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"time"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+// Query only kernel BSD process records, without spawning ps or performing
+// Mach task/thread queries. Both selectors include no-TTY processes and
+// zombies. Unlike SysctlKinfoProcSlice, SysctlRaw does not retry ENOMEM in an
+// unbounded loop when a process group grows between its size/read calls.
+func observeProcessGroup(pgid int) ([]groupMember, error) {
+	return observeKernelProcessGroup(pgid, os.Getpid(), unix.SysctlRaw)
+}
+
+type kernelProcessQuery func(string, ...int) ([]byte, error)
+
+const membershipOutputLimit = 1 << 20
+
+func observeKernelProcessGroup(pgid, callerPID int, query kernelProcessQuery) ([]groupMember, error) {
+	if pgid <= 1 || callerPID <= 1 || query == nil {
+		return nil, fmt.Errorf("invalid Darwin kernel membership request")
+	}
+	started := time.Now()
+	read := func(name string, identity int) ([]groupMember, error) {
+		data, err := query(name, identity)
+		if err != nil {
+			return nil, fmt.Errorf("Darwin kernel membership query: %w", err)
+		}
+		if time.Since(started) > 1500*time.Millisecond {
+			return nil, fmt.Errorf("Darwin kernel membership observation exceeded its budget")
+		}
+		return decodeKernelProcessRecords(data)
+	}
+	caller, err := read("kern.proc.pid", callerPID)
+	if err != nil {
+		return nil, err
+	}
+	if len(caller) != 1 || caller[0].PID != callerPID || caller[0].State == "Z" {
+		return nil, fmt.Errorf("Darwin kernel membership lacks its live observer")
+	}
+	members, err := read("kern.proc.pgrp", pgid)
+	if err != nil {
+		return nil, err
+	}
+	for _, member := range members {
+		if member.PGID != pgid {
+			return nil, fmt.Errorf("Darwin kernel membership contains an unselected process")
+		}
+	}
+	after, err := read("kern.proc.pid", callerPID)
+	if err != nil {
+		return nil, err
+	}
+	// The observer is this live Go process, not a reused receipt PID. Its
+	// identity/group must remain stable; runnable and sleeping are both live.
+	if len(after) != 1 || after[0].PID != callerPID || after[0].PGID != caller[0].PGID || after[0].State == "Z" {
+		return nil, fmt.Errorf("Darwin kernel membership observer changed")
+	}
+	return members, nil
+}
+
+func decodeKernelProcessRecords(data []byte) ([]groupMember, error) {
+	// Use the target's generated x/sys ABI layout for field offsets; never
+	// copy kernel pointer fields into Go objects or dereference them. Both
+	// supported Darwin targets (amd64/arm64) have little-endian integer fields.
+	var layout unix.KinfoProc
+	const recordSize = unix.SizeofKinfoProc
+	if unsafe.Sizeof(layout) != recordSize || len(data) > membershipOutputLimit || len(data)%recordSize != 0 {
+		return nil, fmt.Errorf("Darwin kernel membership has an invalid size")
+	}
+	pidOffset := int(unsafe.Offsetof(layout.Proc) + unsafe.Offsetof(layout.Proc.P_pid))
+	groupOffset := int(unsafe.Offsetof(layout.Eproc) + unsafe.Offsetof(layout.Eproc.Pgid))
+	stateOffset := int(unsafe.Offsetof(layout.Proc) + unsafe.Offsetof(layout.Proc.P_stat))
+	seen := make(map[int]bool, len(data)/recordSize)
+	var members []groupMember
+	for offset := 0; offset < len(data); offset += recordSize {
+		record := data[offset : offset+recordSize]
+		pid := int(int32(binary.LittleEndian.Uint32(record[pidOffset : pidOffset+4])))
+		pgid := int(int32(binary.LittleEndian.Uint32(record[groupOffset : groupOffset+4])))
+		// sys/proc.h: SIDL=1, SRUN=2, SSLEEP=3, SSTOP=4, SZOMB=5.
+		state := record[stateOffset]
+		if pid <= 1 || pgid <= 0 || seen[pid] || state < 1 || state > 5 {
+			return nil, fmt.Errorf("Darwin kernel membership has an unknown record")
+		}
+		seen[pid] = true
+		members = append(members, groupMember{PID: pid, PGID: pgid, State: string("IRSTZ"[state-1])})
+	}
+	return members, nil
+}
diff --git a/internal/ownedprocess/observe_darwin_kernel_test.go b/internal/ownedprocess/observe_darwin_kernel_test.go
new file mode 100644
index 000000000..5b8093036
--- /dev/null
+++ b/internal/ownedprocess/observe_darwin_kernel_test.go
@@ -0,0 +1,149 @@
+//go:build darwin
+
+package ownedprocess
+
+import (
+	"encoding/binary"
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func kernelRecordFixture(pid, pgid int32, state byte) []byte {
+	var layout unix.KinfoProc
+	data := make([]byte, unix.SizeofKinfoProc)
+	pidOffset := int(unsafe.Offsetof(layout.Proc) + unsafe.Offsetof(layout.Proc.P_pid))
+	groupOffset := int(unsafe.Offsetof(layout.Eproc) + unsafe.Offsetof(layout.Eproc.Pgid))
+	stateOffset := int(unsafe.Offsetof(layout.Proc) + unsafe.Offsetof(layout.Proc.P_stat))
+	binary.LittleEndian.PutUint32(data[pidOffset:pidOffset+4], uint32(pid))
+	binary.LittleEndian.PutUint32(data[groupOffset:groupOffset+4], uint32(pgid))
+	data[stateOffset] = state
+	return data
+}
+
+func TestDarwinKernelMembershipRecordStates(t *testing.T) {
+	for state, want := range map[byte]string{1: "I", 2: "R", 3: "S", 4: "T", 5: "Z"} {
+		members, err := decodeKernelProcessRecords(kernelRecordFixture(4124, 4123, state))
+		if err != nil || !reflect.DeepEqual(members, []groupMember{{PID: 4124, PGID: 4123, State: want}}) {
+			t.Fatalf("kernel state %d: %v %v", state, members, err)
+		}
+	}
+	for name, data := range map[string][]byte{
+		"truncated":      make([]byte, unix.SizeofKinfoProc-1),
+		"extra byte":     make([]byte, unix.SizeofKinfoProc+1),
+		"oversized":      make([]byte, membershipOutputLimit+1),
+		"zero PID":       kernelRecordFixture(0, 4123, 5),
+		"init PID":       kernelRecordFixture(1, 4123, 5),
+		"negative PID":   kernelRecordFixture(-1, 4123, 5),
+		"zero group":     kernelRecordFixture(4124, 0, 5),
+		"negative group": kernelRecordFixture(4124, -1, 5),
+		"unknown state":  kernelRecordFixture(4124, 4123, 0),
+		"future state":   kernelRecordFixture(4124, 4123, 6),
+		"duplicate PID":  append(kernelRecordFixture(4124, 4123, 5), kernelRecordFixture(4124, 4123, 5)...),
+	} {
+		t.Run(name, func(t *testing.T) {
+			members, err := decodeKernelProcessRecords(data)
+			if err == nil || members != nil {
+				t.Fatalf("unknown/partial kernel records accepted: %v %v", members, err)
+			}
+		})
+	}
+}
+
+func TestDarwinKernelMembershipExactSelectorsAndLiveWitness(t *testing.T) {
+	for _, absent := range []bool{false, true} {
+		calls := 0
+		query := func(name string, args ...int) ([]byte, error) {
+			calls++
+			identity := 100
+			want := "kern.proc.pid"
+			if calls == 2 {
+				identity, want = 4123, "kern.proc.pgrp"
+			}
+			if name != want || !reflect.DeepEqual(args, []int{identity}) || calls > 3 {
+				t.Fatalf("broad/retried kernel query: %s %v (call %d)", name, args, calls)
+			}
+			if calls != 2 {
+				return kernelRecordFixture(100, 99, 3), nil
+			}
+			if absent {
+				return nil, nil
+			}
+			return kernelRecordFixture(4124, 4123, 5), nil
+		}
+		members, err := observeKernelProcessGroup(4123, 100, query)
+		if err != nil || calls != 3 || absent && len(members) != 0 || !absent && len(members) != 1 {
+			t.Fatalf("exact independent kernel observation: %v %v calls=%d absent=%v", members, err, calls, absent)
+		}
+	}
+}
+
+func TestDarwinKernelMembershipRejectsQueryAndWitnessFailures(t *testing.T) {
+	for name, replace := range map[string]struct {
+		stage int
+		data  []byte
+		err   error
+	}{
+		"query failure":        {1, nil, unix.EPERM},
+		"group grew":           {2, nil, unix.ENOMEM},
+		"after query failure":  {3, nil, unix.EIO},
+		"missing caller":       {1, nil, nil},
+		"zombie caller":        {1, kernelRecordFixture(100, 99, 5), nil},
+		"wrong caller":         {1, kernelRecordFixture(101, 99, 3), nil},
+		"multiple callers":     {1, append(kernelRecordFixture(100, 99, 3), kernelRecordFixture(101, 99, 3)...), nil},
+		"wrong group":          {2, kernelRecordFixture(4124, 4000, 5), nil},
+		"missing after caller": {3, nil, nil},
+		"wrong after caller":   {3, kernelRecordFixture(101, 99, 3), nil},
+		"changed caller group": {3, kernelRecordFixture(100, 98, 3), nil},
+		"zombie after caller":  {3, kernelRecordFixture(100, 99, 5), nil},
+	} {
+		t.Run(name, func(t *testing.T) {
+			calls := 0
+			query := func(string, ...int) ([]byte, error) {
+				calls++
+				if calls == replace.stage {
+					return replace.data, replace.err
+				}
+				if calls == 2 {
+					return kernelRecordFixture(4124, 4123, 5), nil
+				}
+				return kernelRecordFixture(100, 99, 3), nil
+			}
+			members, err := observeKernelProcessGroup(4123, 100, query)
+			if err == nil || members != nil || calls != replace.stage || replace.err != nil && !errors.Is(err, replace.err) {
+				t.Fatalf("invalid kernel observation accepted or retried: %v %v calls=%d", members, err, calls)
+			}
+		})
+	}
+}
+
+func TestDarwinKernelMembershipRequestAndElapsedBounds(t *testing.T) {
+	for _, identities := range [][2]int{{0, 100}, {1, 100}, {-10, 100}, {4123, 0}, {4123, 1}} {
+		called := false
+		query := func(string, ...int) ([]byte, error) {
+			called = true
+			return nil, nil
+		}
+		members, err := observeKernelProcessGroup(identities[0], identities[1], query)
+		if called || err == nil || members != nil {
+			t.Fatalf("invalid request reached the kernel: %v %v called=%v", identities, err, called)
+		}
+	}
+	if _, err := observeKernelProcessGroup(4123, 100, nil); err == nil {
+		t.Fatal("missing kernel query accepted")
+	}
+	calls := 0
+	query := func(string, ...int) ([]byte, error) {
+		calls++
+		time.Sleep(1600 * time.Millisecond)
+		return kernelRecordFixture(100, 99, 3), nil
+	}
+	members, err := observeKernelProcessGroup(4123, 100, query)
+	if err == nil || members != nil || calls != 1 {
+		t.Fatalf("late kernel result accepted or retried: %v %v calls=%d", members, err, calls)
+	}
+}
diff --git a/internal/ownedprocess/observe_darwin_test.go b/internal/ownedprocess/observe_darwin_test.go
new file mode 100644
index 000000000..01d21e024
--- /dev/null
+++ b/internal/ownedprocess/observe_darwin_test.go
@@ -0,0 +1,58 @@
+//go:build darwin
+
+package ownedprocess
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestDarwinMembershipIncludesNoTTYLiveMembers(t *testing.T) {
+	if os.Getenv("PLAN9ASM_NO_TTY_FIXTURE") == "1" {
+		if err := os.WriteFile("ready", nil, 0600); err != nil {
+			os.Exit(5)
+		}
+		time.Sleep(10 * time.Second)
+		os.Exit(0)
+	}
+	dir := t.TempDir()
+	child := exec.Command(os.Args[0], "-test.run=^TestDarwinMembershipIncludesNoTTYLiveMembers$")
+	child.Dir = dir
+	child.Env = append(os.Environ(), "PLAN9ASM_NO_TTY_FIXTURE=1")
+	// A new session has no controlling terminal. It must not disappear
+	// from the kernel group selector, even when its creator is in another one.
+	child.SysProcAttr = &syscall.SysProcAttr{Setsid: true}
+	if err := child.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer func() {
+		_ = child.Process.Kill()
+		_ = child.Wait()
+	}()
+	for end := time.Now().Add(3 * time.Second); ; {
+		if _, err := os.Stat(filepath.Join(dir, "ready")); err == nil {
+			break
+		}
+		if time.Now().After(end) {
+			t.Fatal("no-TTY child did not start")
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	pgid, err := syscall.Getpgid(child.Process.Pid)
+	if err != nil || pgid != child.Process.Pid {
+		t.Fatalf("test-owned independent group: %d %v", pgid, err)
+	}
+	members, err := observeProcessGroup(pgid)
+	if err != nil || len(members) != 1 || members[0].PID != child.Process.Pid || members[0].State[0] == 'Z' {
+		t.Fatalf("no-TTY live group member was hidden: %v %v", members, err)
+	}
+	permission := stopGroup(pgid, true, func(int, syscall.Signal) error { return syscall.EPERM }, observeProcessGroup)
+	if !errors.Is(permission, syscall.EPERM) || errors.Is(permission, os.ErrProcessDone) {
+		t.Fatalf("actual live no-TTY group suppressed a permission error: %v", permission)
+	}
+}
diff --git a/internal/ownedprocess/observe_linux.go b/internal/ownedprocess/observe_linux.go
new file mode 100644
index 000000000..17f33f531
--- /dev/null
+++ b/internal/ownedprocess/observe_linux.go
@@ -0,0 +1,122 @@
+//go:build linux
+
+package ownedprocess
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+var observeProcessGroup groupObserver = func(pgid int) ([]groupMember, error) {
+	return observeProcProcessGroup("/proc", pgid, os.Getpid(), syscall.Kill)
+}
+
+func observeProcProcessGroup(root string, pgid, callerPID int, probe func(int, syscall.Signal) error) ([]groupMember, error) {
+	if pgid <= 1 || callerPID <= 0 || probe == nil {
+		return nil, fmt.Errorf("invalid Linux process membership request")
+	}
+	if err := requireVisibleProcMount(root); err != nil {
+		return nil, err
+	}
+	started := time.Now()
+	read := func(name string) (groupMember, error) {
+		data, err := os.ReadFile(filepath.Join(root, name, "stat"))
+		if err != nil {
+			return groupMember{}, err
+		}
+		if time.Since(started) > 1500*time.Millisecond {
+			return groupMember{}, fmt.Errorf("Linux process membership exceeded its budget")
+		}
+		return decodeProcStat(data)
+	}
+	caller, err := read("self")
+	if err != nil || caller.PID != callerPID || caller.State == "Z" {
+		return nil, errors.Join(fmt.Errorf("Linux process membership lacks its live observer"), err)
+	}
+	entries, err := os.ReadDir(root)
+	if err != nil || len(entries) > 65536 {
+		return nil, errors.Join(fmt.Errorf("Linux process membership directory is unavailable or oversized"), err)
+	}
+	var members []groupMember
+	for _, entry := range entries {
+		pid, err := strconv.Atoi(entry.Name())
+		if err != nil || pid <= 0 {
+			continue
+		}
+		member, err := read(entry.Name())
+		if errors.Is(err, os.ErrNotExist) || errors.Is(err, syscall.ESRCH) {
+			continue // A process removed during enumeration is already gone.
+		}
+		if err != nil || member.PID != pid {
+			return nil, errors.Join(fmt.Errorf("Linux process membership is incomplete"), err)
+		}
+		if member.PGID == pgid {
+			members = append(members, member)
+		}
+	}
+	after, err := read("self")
+	if err != nil || after.PID != caller.PID || after.PGID != caller.PGID || after.Born != caller.Born || after.State == "Z" {
+		return nil, errors.Join(fmt.Errorf("Linux process membership observer changed"), err)
+	}
+	if len(members) == 0 {
+		if err := probe(-pgid, 0); !errors.Is(err, syscall.ESRCH) {
+			return nil, errors.Join(fmt.Errorf("empty Linux membership did not establish an absent group"), err)
+		}
+	}
+	return members, nil
+}
+
+func requireVisibleProcMount(root string) error {
+	data, err := os.ReadFile(filepath.Join(root, "self", "mountinfo"))
+	if err != nil || len(data) > 1<<20 {
+		return errors.Join(fmt.Errorf("Linux process mount visibility is unknown"), err)
+	}
+	found := 0
+	for _, line := range strings.Split(string(data), "\n") {
+		before, after, present := strings.Cut(line, " - ")
+		fields, filesystem := strings.Fields(before), strings.Fields(after)
+		if !present || len(fields) < 6 || fields[4] != root {
+			continue
+		}
+		if len(filesystem) != 3 || filesystem[0] != "proc" {
+			return fmt.Errorf("Linux process view is not procfs")
+		}
+		for _, option := range strings.Split(fields[5]+","+filesystem[2], ",") {
+			if strings.HasPrefix(option, "hidepid=") && option != "hidepid=0" && option != "hidepid=off" {
+				return fmt.Errorf("Linux process view hides group members")
+			}
+		}
+		found++
+	}
+	if found != 1 {
+		return fmt.Errorf("Linux process view lacks one complete procfs mount")
+	}
+	return nil
+}
+
+func decodeProcStat(data []byte) (groupMember, error) {
+	// proc_pid_stat(5): comm is parenthesized and may itself contain spaces
+	// or ')'. State, pgrp and starttime are fields 3, 5 and 22 respectively.
+	text := string(data)
+	open, close := strings.Index(text, " ("), strings.LastIndex(text, ") ")
+	if len(data) > 65536 || open < 1 || close <= open {
+		return groupMember{}, fmt.Errorf("invalid Linux stat record")
+	}
+	pid, pidErr := strconv.Atoi(text[:open])
+	fields := strings.Fields(text[close+2:])
+	if pidErr != nil || pid <= 0 || len(fields) < 20 || len(fields[0]) != 1 || !strings.Contains("RSDTtXZxKWPI", fields[0]) {
+		return groupMember{}, fmt.Errorf("invalid Linux stat identity or state")
+	}
+	pgid, groupErr := strconv.Atoi(fields[2])
+	born, bornErr := strconv.ParseUint(fields[19], 10, 64)
+	if groupErr != nil || pgid < 0 || bornErr != nil {
+		return groupMember{}, fmt.Errorf("invalid Linux stat group or lifetime")
+	}
+	return groupMember{PID: pid, PGID: pgid, State: fields[0], Born: born}, nil
+}
diff --git a/internal/ownedprocess/observe_linux_test.go b/internal/ownedprocess/observe_linux_test.go
new file mode 100644
index 000000000..0269510a6
--- /dev/null
+++ b/internal/ownedprocess/observe_linux_test.go
@@ -0,0 +1,106 @@
+//go:build linux
+
+package ownedprocess
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+func procStatFixture(pid, pgid int, state string, born uint64) []byte {
+	fields := strings.Fields(state + " 100 " + strconv.Itoa(pgid) + strings.Repeat(" 0", 16) + " " + strconv.FormatUint(born, 10))
+	return []byte(fmt.Sprintf("%d (name with ) and spaces) %s\n", pid, strings.Join(fields, " ")))
+}
+
+func TestLinuxProcStatIdentityAndStates(t *testing.T) {
+	for _, state := range []string{"R", "S", "D", "T", "t", "Z", "I", "X"} {
+		member, err := decodeProcStat(procStatFixture(4124, 4123, state, 1007))
+		want := groupMember{PID: 4124, PGID: 4123, State: state, Born: 1007}
+		if err != nil || member != want {
+			t.Fatal("actual proc field indices or parenthesized command changed", member, err)
+		}
+	}
+	for name, data := range map[string][]byte{
+		"truncated":          []byte("4124 (x) Z 100 4123"),
+		"unknown state":      procStatFixture(4124, 4123, "?", 1007),
+		"Darwin-only state":  procStatFixture(4124, 4123, "U", 1007),
+		"state modifier":     procStatFixture(4124, 4123, "Z+", 1007),
+		"negative pid":       procStatFixture(-1, 4123, "Z", 1007),
+		"negative group":     procStatFixture(4124, -1, "Z", 1007),
+		"missing command":    []byte("4124 Z 100 4123"),
+		"starttime overflow": []byte(strings.Replace(string(procStatFixture(4124, 4123, "Z", 1007)), "1007", "18446744073709551616", 1)),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if _, err := decodeProcStat(data); err == nil {
+				t.Fatal("unknown or incomplete kernel identity accepted")
+			}
+		})
+	}
+}
+
+func TestLinuxProcMembershipRequiresCompleteVisibleView(t *testing.T) {
+	for _, mutation := range []string{"none", "hidden", "wrong filesystem", "missing mount", "missing process", "wrong pid", "unknown state", "absent"} {
+		t.Run(mutation, func(t *testing.T) {
+			root := t.TempDir()
+			for _, pid := range []int{100, 4124} {
+				if err := os.Mkdir(filepath.Join(root, strconv.Itoa(pid)), 0700); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if err := os.Symlink("100", filepath.Join(root, "self")); err != nil {
+				t.Fatal(err)
+			}
+			write := func(name string, data []byte) {
+				if err := os.WriteFile(filepath.Join(root, name), data, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			write("100/stat", procStatFixture(100, 99, "S", 1000))
+			write("4124/stat", procStatFixture(4124, 4123, "Z", 1007))
+			mount := fmt.Sprintf("20 1 0:5 / %s rw - proc proc rw\n", root)
+			switch mutation {
+			case "hidden":
+				mount = strings.TrimSuffix(mount, "\n") + ",hidepid=2\n"
+			case "wrong filesystem":
+				mount = strings.Replace(mount, "- proc", "- tmpfs", 1)
+			case "missing mount":
+				mount = ""
+			case "missing process", "absent":
+				if err := os.Remove(filepath.Join(root, "4124/stat")); err != nil {
+					t.Fatal(err)
+				}
+			case "wrong pid":
+				write("4124/stat", procStatFixture(4125, 4123, "Z", 1007))
+			case "unknown state":
+				write("4124/stat", procStatFixture(4124, 4123, "?", 1007))
+			}
+			write("100/mountinfo", []byte(mount))
+			members, err := observeProcProcessGroup(root, 4123, 100, func(pid int, signal syscall.Signal) error {
+				if pid != -4123 || signal != 0 {
+					t.Fatal("observation signalled an unowned process", pid, signal)
+				}
+				if mutation == "absent" {
+					return syscall.ESRCH
+				}
+				return nil
+			})
+			if mutation == "none" {
+				if err != nil || !reflect.DeepEqual(members, []groupMember{{PID: 4124, PGID: 4123, State: "Z", Born: 1007}}) {
+					t.Fatal("complete membership changed", members, err)
+				}
+			} else if mutation == "absent" {
+				if err != nil || len(members) != 0 {
+					t.Fatal("independent kernel absence rejected", members, err)
+				}
+			} else if err == nil || members != nil {
+				t.Fatal("partial, hidden or foreign process view acquired terminal membership", members, err)
+			}
+		})
+	}
+}
diff --git a/internal/ownedprocess/observe_other_unix.go b/internal/ownedprocess/observe_other_unix.go
new file mode 100644
index 000000000..88e4148ef
--- /dev/null
+++ b/internal/ownedprocess/observe_other_unix.go
@@ -0,0 +1,7 @@
+//go:build unix && !darwin && !linux
+
+package ownedprocess
+
+// Other kernels retain the original strict signal outcome. In particular,
+// EPERM is not evidence that a group has exited.
+var observeProcessGroup groupObserver
diff --git a/internal/sdkfrontend/directory.go b/internal/sdkfrontend/directory.go
new file mode 100644
index 000000000..7348f5d36
--- /dev/null
+++ b/internal/sdkfrontend/directory.go
@@ -0,0 +1,39 @@
+package sdkfrontend
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// WorkingDirectory fixes the actual load directory's opened physical spelling.
+// Pair it with the physical GOROOT/cache environment before packages.Load:
+// cmd/go's internal-import checks compare directory prefixes, not file IDs.
+// This grants no package selection, source, frame or numerical permission.
+func WorkingDirectory(directory string) (string, error) {
+	if directory == "" {
+		var err error
+		directory, err = os.Getwd()
+		if err != nil {
+			return "", fmt.Errorf("locate package-load working directory: %w", err)
+		}
+	}
+	absolute, err := filepath.Abs(directory)
+	if err != nil {
+		return "", fmt.Errorf("locate package-load working directory: %w", err)
+	}
+	physical, err := sourcepath.Resolve(absolute)
+	if err != nil {
+		return "", fmt.Errorf("resolve package-load working directory: %w", err)
+	}
+	info, err := sourcepath.Lstat(physical)
+	if err != nil {
+		return "", fmt.Errorf("inspect package-load working directory: %w", err)
+	}
+	if !info.IsDir() {
+		return "", fmt.Errorf("package-load working directory is not its actual directory")
+	}
+	return physical, nil
+}
diff --git a/internal/sdkfrontend/directory_test.go b/internal/sdkfrontend/directory_test.go
new file mode 100644
index 000000000..2d0410eb1
--- /dev/null
+++ b/internal/sdkfrontend/directory_test.go
@@ -0,0 +1,57 @@
+package sdkfrontend
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestWorkingDirectoryActualIdentity(t *testing.T) {
+	actual := t.TempDir()
+	alias := filepath.Join(t.TempDir(), "original-directory")
+	sdkEnvironmentAlias(t, alias, actual)
+	want, err := sourcepath.Resolve(actual)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, input := range []string{actual, alias, filepath.Join(alias, ".")} {
+		got, err := WorkingDirectory(input)
+		if err != nil || got != want {
+			t.Errorf("load directory changed its physical identity: %q -> %q, want %q (%v)", input, got, want, err)
+		}
+	}
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	want, err = sourcepath.Resolve(cwd)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, err := WorkingDirectory(""); err != nil || got != want {
+		t.Errorf("implicit load directory changed its actual current node: %q != %q (%v)", got, want, err)
+	}
+}
+
+func TestWorkingDirectoryRejectsMissingOrNonDirectory(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "original-file")
+	const contents = "original file must not be replaced\n"
+	if err := os.WriteFile(file, []byte(contents), 0600); err != nil {
+		t.Fatal(err)
+	}
+	missing := filepath.Join(root, "missing")
+	for _, input := range []string{file, missing} {
+		if got, err := WorkingDirectory(input); err == nil || got != "" {
+			t.Errorf("unbound working-directory role was accepted: %q -> %q (%v)", input, got, err)
+		}
+	}
+	if got, err := os.ReadFile(file); err != nil || string(got) != contents {
+		t.Fatal("non-directory input changed", err)
+	}
+	if _, err := os.Lstat(missing); !os.IsNotExist(err) {
+		t.Fatal("missing directory was created or substituted", err)
+	}
+}
diff --git a/internal/sdkfrontend/environment.go b/internal/sdkfrontend/environment.go
new file mode 100644
index 000000000..4c72dd6d5
--- /dev/null
+++ b/internal/sdkfrontend/environment.go
@@ -0,0 +1,184 @@
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// FeatureEnvironment prepares a compiler consumer's command directories while
+// retaining the already observed Go tool invocation.
+func FeatureEnvironment(goos, goarch string, input []string) ([]string, error) {
+	return commandEnvironment(goos, goarch, input, true)
+}
+
+// Resolve the ordinary load environment before packages.Load. Its later source
+// observers receive this exact environment, never defaults reconstructed from
+// the process after selection. Explicit nonordinary settings remain visible
+// and cannot acquire an ordinary source proof.
+func OrdinaryEnvironment(goos, goarch string, input []string) ([]string, error) {
+	return commandEnvironment(goos, goarch, input, false)
+}
+
+func commandEnvironment(goos, goarch string, input []string, retainGOROOT bool) ([]string, error) {
+	values := make(map[string]string)
+	for _, item := range input {
+		key, value, ok := strings.Cut(item, "=")
+		if !ok || key == "" || strings.ContainsRune(item, '\x00') {
+			return nil, fmt.Errorf("malformed package-load environment")
+		}
+		values[key] = value
+	}
+	values["GOOS"], values["GOARCH"] = goos, goarch
+	if values["GOTOOLCHAIN"] == "" {
+		values["GOTOOLCHAIN"] = "local"
+	}
+	if values["GOPACKAGESDRIVER"] == "" {
+		// Match packages.Load's automatic discovery, including its use of
+		// the process PATH. A discovered driver is not an ordinary Go load.
+		driver, err := exec.LookPath("gopackagesdriver")
+		if err != nil {
+			driver = "off"
+		}
+		values["GOPACKAGESDRIVER"] = driver
+	}
+	encode := func() []string {
+		result := make([]string, 0, len(values))
+		for key, value := range values {
+			result = append(result, key+"="+value)
+		}
+		sort.Strings(result)
+		return result
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, "", encode(), "go",
+		"env", "-json", "GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH", "CGO_ENABLED", "GOENV", "GOWORK", "GOFLAGS")
+	if err != nil || len(stderr) != 0 {
+		return nil, fmt.Errorf("resolve package-load cache environment: %v (stderr: %s)", err, stderr)
+	}
+	var actual map[string]string
+	if err := json.Unmarshal(stdout, &actual); err != nil {
+		return nil, fmt.Errorf("decode package-load cache environment: %w", err)
+	}
+	// Stock Go selects its cgo default for the requested target. Forcing zero
+	// here would silently drop selected assembly (including runtime/cgo).
+	// Pure-Go source proofs still require an explicitly compatible profile.
+	if actual["CGO_ENABLED"] != "0" && actual["CGO_ENABLED"] != "1" {
+		return nil, fmt.Errorf("invalid effective package-load CGO_ENABLED")
+	}
+	values["CGO_ENABLED"] = actual["CGO_ENABLED"]
+	values["GOFLAGS"] = actual["GOFLAGS"]
+	goenv, err := GoEnvFile(values["GOENV"], actual["GOENV"])
+	if err != nil {
+		return nil, fmt.Errorf("resolve package-load GOENV: %w", err)
+	}
+	actual["GOENV"] = goenv
+	for _, key := range []string{"GOENV", "GOWORK"} {
+		values[key] = actual[key]
+		if values[key] == "" {
+			values[key] = "off"
+		}
+	}
+	for _, key := range []string{"GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH"} {
+		paths := []string{actual[key]}
+		if key == "GOPATH" {
+			paths = filepath.SplitList(actual[key])
+		}
+		if len(paths) == 0 {
+			return nil, fmt.Errorf("package-load %s has no actual path", key)
+		}
+		for index, path := range paths {
+			if !filepath.IsAbs(path) {
+				return nil, fmt.Errorf("package-load %s must resolve to absolute paths", key)
+			}
+			// A local module may never download a dependency, so cmd/go need
+			// not create GOPATH/GOMODCACHE. Prepare each actual selected path
+			// before the load captures it, never repair a later source proof.
+			if key != "GOROOT" {
+				if err := os.MkdirAll(path, 0755); err != nil {
+					return nil, fmt.Errorf("prepare package-load %s: %w", key, err)
+				}
+			}
+			// Fix the actual filesystem target before packages.Load. Alias,
+			// case and separator spellings are not canonical source identity,
+			// even when cmd/go preserves them in its original go env output.
+			paths[index], err = sourcepath.Resolve(path)
+			if err != nil {
+				return nil, fmt.Errorf("resolve package-load %s: %w", key, err)
+			}
+			info, err := sourcepath.Lstat(paths[index])
+			if err != nil {
+				return nil, fmt.Errorf("inspect package-load %s: %w", key, err)
+			}
+			if !info.IsDir() {
+				return nil, fmt.Errorf("package-load %s is not its actual directory", key)
+			}
+		}
+		if key == "GOROOT" && retainGOROOT {
+			// The physical directory was validated above. Changing this
+			// command spelling can rebuild builtin Go tools with different
+			// bytes/routes, invalidating an already captured feature profile.
+			values[key] = actual[key]
+		} else {
+			values[key] = strings.Join(paths, string(filepath.ListSeparator))
+		}
+	}
+	for _, key := range []string{"TMPDIR", "GOTMPDIR"} {
+		if values[key] == "" {
+			values[key] = values["TMPDIR"]
+			if values[key] == "" {
+				values[key] = os.TempDir()
+			}
+		}
+		path, err := filepath.Abs(values[key])
+		if err != nil {
+			return nil, err
+		}
+		values[key], err = sourcepath.Resolve(path)
+		if err != nil {
+			return nil, fmt.Errorf("resolve package-load %s: %w", key, err)
+		}
+		info, err := sourcepath.Lstat(values[key])
+		if err != nil {
+			return nil, fmt.Errorf("inspect package-load %s: %w", key, err)
+		}
+		if !info.IsDir() {
+			return nil, fmt.Errorf("package-load %s is not its actual directory", key)
+		}
+	}
+	return encode(), nil
+}
+
+func GoEnvFile(requested, actual string) (string, error) {
+	if actual == "" || actual == "off" {
+		return actual, nil
+	}
+	// Resolve the absence before packages.Load. An implicit missing config
+	// carries Go's defaults; explicitly fixing that choice prevents a later
+	// file from changing the compiler invocation observed by source guards.
+	// User-selected paths and existing settings keep their original role.
+	_, err := os.Lstat(actual)
+	if os.IsNotExist(err) {
+		if requested != "" {
+			return actual, nil // Keep an explicitly selected missing config visible.
+		}
+		return "off", nil
+	}
+	if err != nil {
+		return "", err
+	}
+	// Preserve the chosen file and its settings, but hand its opened physical
+	// spelling to the actual load. SDK observers still require that exact file
+	// and recheck its eager identity/bytes; this is never a config substitution.
+	return sourcepath.Resolve(actual)
+}
diff --git a/internal/sdkfrontend/environment_identity_other_test.go b/internal/sdkfrontend/environment_identity_other_test.go
new file mode 100644
index 000000000..7f4fe3ca2
--- /dev/null
+++ b/internal/sdkfrontend/environment_identity_other_test.go
@@ -0,0 +1,15 @@
+//go:build !windows
+
+package sdkfrontend
+
+import (
+	"os"
+	"testing"
+)
+
+func sdkEnvironmentAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	if err := os.Symlink(actual, alias); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/sdkfrontend/environment_identity_test.go b/internal/sdkfrontend/environment_identity_test.go
new file mode 100644
index 000000000..173964770
--- /dev/null
+++ b/internal/sdkfrontend/environment_identity_test.go
@@ -0,0 +1,192 @@
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestOrdinaryEnvironmentActualCommandPathIdentity(t *testing.T) {
+	root := t.TempDir()
+	actual := filepath.Join(root, "actual")
+	if err := os.Mkdir(actual, 0700); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(root, "alias")
+	sdkEnvironmentAlias(t, alias, actual)
+	sdkAlias := filepath.Join(root, "sdk")
+	sdkEnvironmentAlias(t, sdkAlias, runtime.GOROOT())
+	for _, profile := range []string{"off", "saved-config"} {
+		t.Run(profile, func(t *testing.T) {
+			config := "off"
+			if profile == "saved-config" {
+				config = filepath.Join(alias, "go-env")
+				if err := os.WriteFile(config, []byte("GOPROXY=https://actual-config.invalid,direct\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			input := append(os.Environ(), "GOENV="+config, "GOROOT="+sdkAlias,
+				"GOOS=linux", "GOARCH=amd64", "GOWORK=off", "GOTOOLCHAIN=local", "GOFLAGS=", "GOPACKAGESDRIVER=off")
+			for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+				path := filepath.Join(alias, key)
+				if key == "TMPDIR" || key == "GOTMPDIR" {
+					if err := os.Mkdir(path, 0700); err != nil && !os.IsExist(err) {
+						t.Fatal(err)
+					}
+				}
+				input = append(input, key+"="+path)
+			}
+			if runtime.GOOS == "windows" {
+				// Native handle resolution must bind the same actual target,
+				// not guess identity from drive case or slash replacement.
+				for _, key := range []string{"GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR", "GOENV"} {
+					path := config
+					if key == "GOROOT" {
+						path = sdkAlias
+					} else if key != "GOENV" {
+						path = filepath.Join(alias, key)
+					}
+					if path != "off" {
+						volume := filepath.VolumeName(path)
+						input = append(input, key+"="+filepath.ToSlash(strings.ToLower(volume)+strings.TrimPrefix(path, volume)))
+					}
+				}
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			defer cancel()
+			keys := []string{"GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH", "GOENV", "CGO_ENABLED", "GOPROXY", "GOFLAGS"}
+			before, stderr, err := gotoolprofile.RunBounded(ctx, "", input, "go", append([]string{"env", "-json"}, keys...)...)
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual original compiler profile: %v; %s", err, stderr)
+			}
+			var original map[string]string
+			if err := json.Unmarshal(before, &original); err != nil {
+				t.Fatal(err)
+			}
+			environment, err := OrdinaryEnvironment("linux", "amd64", input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			provided, err := EnvironmentValues(environment)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, key := range []string{"GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+				canonical, err := sourcepath.Resolve(provided[key])
+				if err != nil || canonical != provided[key] {
+					t.Errorf("actual selected %s was not handed off in its opened physical spelling: got=%q physical=%q error=%v", key, provided[key], canonical, err)
+				}
+				requested := filepath.Join(alias, key)
+				if key == "GOROOT" {
+					requested = sdkAlias
+				}
+				want, err := sourcepath.Resolve(requested)
+				if err != nil || provided[key] != want {
+					t.Errorf("actual selected %s changed its filesystem target: %q != %q (%v)", key, provided[key], want, err)
+				}
+			}
+			if config != "off" {
+				want, err := sourcepath.Resolve(config)
+				if err != nil || provided["GOENV"] != want {
+					t.Errorf("saved config was disabled or lacks its physical identity: got=%q want=%q error=%v", provided["GOENV"], want, err)
+				}
+			}
+			after, stderr, err := gotoolprofile.RunBounded(ctx, "", environment, "go", append([]string{"env", "-json"}, keys...)...)
+			if err != nil || len(stderr) != 0 {
+				t.Fatalf("actual canonical compiler profile: %v; %s", err, stderr)
+			}
+			var observed map[string]string
+			if err := json.Unmarshal(after, &observed); err != nil {
+				t.Fatal(err)
+			}
+			for _, key := range []string{"CGO_ENABLED", "GOPROXY", "GOFLAGS"} {
+				if observed[key] != original[key] {
+					t.Errorf("canonical path handoff changed actual compiler default/config %s: %q != %q", key, observed[key], original[key])
+				}
+			}
+		})
+	}
+}
+
+func TestOrdinaryEnvironmentCommandPathRejectionPreservesInputs(t *testing.T) {
+	checkCommandPathRejectionPreservesInputs(t, OrdinaryEnvironment)
+}
+
+func TestFeatureEnvironmentCommandPathRejectionPreservesInputs(t *testing.T) {
+	checkCommandPathRejectionPreservesInputs(t, FeatureEnvironment)
+}
+
+func checkCommandPathRejectionPreservesInputs(t *testing.T, prepare func(string, string, []string) ([]string, error)) {
+	t.Helper()
+	for _, key := range []string{"GOROOT", "GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		t.Run(key, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "original-not-directory")
+			const original = "selected original file, not command storage\n"
+			if err := os.WriteFile(path, []byte(original), 0600); err != nil {
+				t.Fatal(err)
+			}
+			input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", key+"="+path)
+			if output, err := prepare("linux", "amd64", input); err == nil || len(output) != 0 {
+				t.Fatalf("non-directory %s supplied a command/source profile: %v", key, err)
+			}
+			if data, err := os.ReadFile(path); err != nil || string(data) != original {
+				t.Fatalf("preparing %s replaced its original file: %v", key, err)
+			}
+		})
+	}
+	for _, key := range []string{"TMPDIR", "GOTMPDIR"} {
+		t.Run("missing-"+key, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "missing")
+			input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", key+"="+path)
+			if output, err := prepare("linux", "amd64", input); err == nil || len(output) != 0 {
+				t.Fatalf("missing selected %s was silently substituted: %v", key, err)
+			}
+			if _, err := os.Stat(path); !os.IsNotExist(err) {
+				t.Fatalf("selected missing %s was repaired after observation: %v", key, err)
+			}
+		})
+	}
+}
+
+func TestOrdinaryEnvironmentRetainsGOPATHComponentSelection(t *testing.T) {
+	root := t.TempDir()
+	actual := filepath.Join(root, "actual")
+	if err := os.Mkdir(actual, 0700); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(root, "alias")
+	sdkEnvironmentAlias(t, alias, actual)
+	paths := []string{filepath.Join(alias, "first"), filepath.Join(alias, "second")}
+	var want []string
+	for _, path := range paths {
+		if err := os.Mkdir(path, 0700); err != nil {
+			t.Fatal(err)
+		}
+		physical, err := sourcepath.Resolve(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		want = append(want, physical)
+	}
+	input := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOPATH="+strings.Join(paths, string(filepath.ListSeparator)))
+	environment, err := OrdinaryEnvironment("linux", "amd64", input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values, err := EnvironmentValues(environment)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if values["GOPATH"] != strings.Join(want, string(filepath.ListSeparator)) {
+		t.Fatalf("actual ordered GOPATH components were collapsed or lack their physical identities: %q != %q", values["GOPATH"], want)
+	}
+}
diff --git a/internal/sdkfrontend/environment_identity_windows_test.go b/internal/sdkfrontend/environment_identity_windows_test.go
new file mode 100644
index 000000000..7bae66876
--- /dev/null
+++ b/internal/sdkfrontend/environment_identity_windows_test.go
@@ -0,0 +1,21 @@
+//go:build windows
+
+package sdkfrontend
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+)
+
+func sdkEnvironmentAlias(t *testing.T, alias, actual string) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	stdout, stderr, err := gotoolprofile.RunBounded(ctx, "", nil, "cmd", "/c", "mklink", "/J", alias, actual)
+	if err != nil {
+		t.Fatalf("create required actual Windows junction: %v; %s; %s", err, stdout, stderr)
+	}
+}
diff --git a/internal/sdkfrontend/environment_test.go b/internal/sdkfrontend/environment_test.go
new file mode 100644
index 000000000..92d80e750
--- /dev/null
+++ b/internal/sdkfrontend/environment_test.go
@@ -0,0 +1,51 @@
+package sdkfrontend
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Keep the shared selection rule portable to Go 1.20, not only covered by a
+// frontend nested module whose current package loader needs a newer toolchain.
+func TestGoEnvFileSelection(t *testing.T) {
+	dir := t.TempDir()
+	missing := filepath.Join(dir, "missing-goenv")
+	existing := filepath.Join(dir, "saved-goenv")
+	const saved = "GOFLAGS=-tags=saved_profile\n"
+	if err := os.WriteFile(existing, []byte(saved), 0600); err != nil {
+		t.Fatal(err)
+	}
+	physical, err := sourcepath.Resolve(existing)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, test := range []struct {
+		name, requested, actual, want string
+	}{
+		{"absent implicit file", "", missing, "off"},
+		{"saved implicit file", "", existing, physical},
+		{"explicit missing file", missing, missing, missing},
+		{"explicit saved file", existing, existing, physical},
+		{"explicit off", "off", "off", "off"},
+		// Stock Go reports an empty GOENV for explicit off. The enclosing
+		// ordinary environment encoder retains the explicit command spelling.
+		{"stock explicit off observation", "off", "", ""},
+		{"empty actual configuration", "", "", ""},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := GoEnvFile(test.requested, test.actual)
+			if err != nil || got != test.want {
+				t.Fatalf("compiler configuration selection: got %q, %v; want %q", got, err, test.want)
+			}
+		})
+	}
+	if _, err := os.Stat(missing); !os.IsNotExist(err) {
+		t.Fatalf("resolving implicit defaults created a configuration file: %v", err)
+	}
+	if data, err := os.ReadFile(existing); err != nil || string(data) != saved {
+		t.Fatalf("resolving defaults changed saved compiler settings: %v", err)
+	}
+}
diff --git a/internal/sdkfrontend/feature_environment_test.go b/internal/sdkfrontend/feature_environment_test.go
new file mode 100644
index 000000000..487b59ae5
--- /dev/null
+++ b/internal/sdkfrontend/feature_environment_test.go
@@ -0,0 +1,71 @@
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestFeatureEnvironmentRetainsActualGOROOTCommand(t *testing.T) {
+	alias := filepath.Join(t.TempDir(), "selected-sdk")
+	sdkEnvironmentAlias(t, alias, runtime.GOROOT())
+	input := append(os.Environ(), "GOROOT="+alias, "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0", "GOFLAGS=")
+	before := append([]string(nil), input...)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	query := func(environment []string) map[string]string {
+		data, stderr, err := gotoolprofile.RunBounded(ctx, "", environment, "go",
+			"env", "-json", "GOROOT", "CGO_ENABLED", "GOFLAGS")
+		if err != nil || len(stderr) != 0 {
+			t.Fatalf("actual Go environment: %v; %s", err, stderr)
+		}
+		var actual map[string]string
+		if err := json.Unmarshal(data, &actual); err != nil {
+			t.Fatal(err)
+		}
+		return actual
+	}
+	original := query(input)
+	physical, err := sourcepath.Resolve(original["GOROOT"])
+	if err != nil || physical == original["GOROOT"] {
+		t.Fatalf("fixture did not retain a distinct actual SDK spelling: %q, %q, %v", original["GOROOT"], physical, err)
+	}
+	for _, row := range []struct {
+		name  string
+		apply func(string, string, []string) ([]string, error)
+		want  string
+	}{
+		{"feature", FeatureEnvironment, original["GOROOT"]},
+		{"ordinary", OrdinaryEnvironment, physical},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			environment, err := row.apply("linux", "amd64", input)
+			if err != nil {
+				t.Fatal(err)
+			}
+			values, err := EnvironmentValues(environment)
+			if err != nil || values["GOROOT"] != row.want {
+				t.Errorf("selected command GOROOT: got %q, want %q (%v)", values["GOROOT"], row.want, err)
+			}
+			resolved, err := sourcepath.Resolve(values["GOROOT"])
+			if err != nil || resolved != physical {
+				t.Errorf("changed physical SDK: %q, want %q (%v)", resolved, physical, err)
+			}
+			observed := query(environment)
+			if observed["GOROOT"] != row.want || observed["CGO_ENABLED"] != original["CGO_ENABLED"] || observed["GOFLAGS"] != original["GOFLAGS"] {
+				t.Errorf("actual Go command selection changed: %v", observed)
+			}
+			if !reflect.DeepEqual(input, before) {
+				t.Fatal("consumer changed its producer's environment")
+			}
+		})
+	}
+}
diff --git a/internal/sdkfrontend/load.go b/internal/sdkfrontend/load.go
new file mode 100644
index 000000000..22fc38a53
--- /dev/null
+++ b/internal/sdkfrontend/load.go
@@ -0,0 +1,189 @@
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+type Loader func(context.Context, string, []string) (*Package, error)
+
+// Reload invokes the frontend's real loader under owned command roots, then
+// compares its complete source/import graph, sizes and selected source bytes.
+// The resulting types must come from this new load, never an environment label
+// attached to the original load. Compiler defaults are observed, not replaced.
+func Reload(ctx context.Context, binary string, pkg *Package, selected *Selection, load Loader) (_ *Package, _ *Selection, _ func() error, result error) {
+	if ctx != nil && ctx.Err() != nil {
+		return nil, nil, nil, ctx.Err()
+	}
+	if ctx == nil || selected == nil || load == nil {
+		return nil, nil, nil, contextError("reload requires its live context and actual-load selection")
+	}
+	if _, bounded := ctx.Deadline(); !bounded {
+		return nil, nil, nil, contextError("reload requires a bounded context")
+	}
+	if err := Check(pkg, selected, selected.target); err != nil {
+		return nil, nil, nil, err
+	}
+	observed, stderr, err := gotoolprofile.RunBounded(ctx, pkg.Dir, selected.env, binary, "env", "-json",
+		"GOOS", "GOARCH", "GOAMD64", "GO386", "GOFLAGS", "GOEXPERIMENT", "CGO_ENABLED", "GOROOT", "GOCACHE")
+	if err != nil || len(stderr) != 0 {
+		return nil, nil, nil, errors.Join(err, Stderr(stderr))
+	}
+	var actual map[string]string
+	if err := json.Unmarshal(observed, &actual); err != nil {
+		return nil, nil, nil, err
+	}
+	goos, arch, _ := strings.Cut(selected.target, "/")
+	baseline := arch == "amd64" && actual["GOAMD64"] == "v1" || arch == "386" && actual["GO386"] == "sse2"
+	if !gostaticstorage.X86SDKTarget(selected.target) || actual["GOOS"] != goos || actual["GOARCH"] != arch || !baseline || actual["GOFLAGS"] != "" ||
+		actual["GOEXPERIMENT"] != "" || actual["CGO_ENABLED"] != "0" && actual["CGO_ENABLED"] != "1" {
+		return nil, nil, nil, contextError("source requires the actual baseline x86 compiler profile")
+	}
+	if selected.mode != nil && *selected.mode != actual["GOFLAGS"] {
+		return nil, nil, nil, contextError("effective source flags changed after selection")
+	}
+	// cmd/go leaves an unset, inactive architecture's CPU setting empty. Give
+	// that unused mode its baseline spelling for the observer's complete x86
+	// command profile; the active setting was independently checked above.
+	if arch != "amd64" && actual["GOAMD64"] == "" {
+		actual["GOAMD64"] = "v1"
+	}
+	if arch != "386" && actual["GO386"] == "" {
+		actual["GO386"] = "sse2"
+	}
+	cache, err := sourcepath.Resolve(actual["GOCACHE"])
+	if err != nil || !filepath.IsAbs(cache) {
+		return nil, nil, nil, contextError("build cache is not an existing absolute directory")
+	}
+	root, err := sourcepath.Resolve(actual["GOROOT"])
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	directory, err := sourcepath.Resolve(pkg.Dir)
+	if err != nil || !filepath.IsLocal(filepath.FromSlash(pkg.Path)) || directory != filepath.Join(root, "src", filepath.FromSlash(pkg.Path)) {
+		return nil, nil, nil, contextError(fmt.Sprintf("selected package is not inside the invoked SDK: %v", err))
+	}
+	before, err := Graph(pkg)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	inputs, err := GraphHashes(pkg)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	values, err := EnvironmentValues(selected.env)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	// Honor the actual invocation's temporary root rather than ambient state.
+	workspace, close, err := newReloadWorkspace(values["TMPDIR"])
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, close())
+		}
+	}()
+	workspace, err = sourcepath.Resolve(workspace)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	for key, value := range map[string]string{
+		"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOPROXY": "off",
+		"GOFLAGS": actual["GOFLAGS"], "GOEXPERIMENT": actual["GOEXPERIMENT"],
+		"CGO_ENABLED": actual["CGO_ENABLED"], "GOPACKAGESDRIVER": "off",
+		"GOOS": actual["GOOS"], "GOARCH": actual["GOARCH"],
+		"GOAMD64": actual["GOAMD64"], "GO386": actual["GO386"], "GOROOT": root, "GOCACHE": cache,
+	} {
+		values[key] = value
+	}
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		path := filepath.Join(workspace, strings.ToLower(key))
+		if err := os.Mkdir(path, 0700); err != nil {
+			return nil, nil, nil, err
+		}
+		values[key] = path
+	}
+	environment := EncodeEnvironment(values)
+	reloaded, err := load(ctx, directory, environment)
+	if err != nil {
+		return nil, nil, nil, err
+	}
+	if reloaded == nil || reloaded.Module || reloaded.IllTyped || len(reloaded.Errors) != 0 ||
+		reloaded.Path != pkg.Path || reloaded.Types == nil || reloaded.Test || reloaded.Types == pkg.Types {
+		return nil, nil, nil, contextError("actual reload is not the same ordinary SDK package with distinct types")
+	}
+	after, err := Graph(reloaded)
+	if err != nil || !reflect.DeepEqual(before, after) || !reflect.DeepEqual(Sizes(pkg.Sizes), Sizes(reloaded.Sizes)) {
+		return nil, nil, nil, contextError(fmt.Sprintf("source/import graph differs after actual reload: %v", err))
+	}
+	afterInputs, err := GraphHashes(reloaded)
+	if err != nil || !reflect.DeepEqual(inputs, afterInputs) {
+		return nil, nil, nil, contextError(fmt.Sprintf("source bytes changed during actual reload: %v", err))
+	}
+	return reloaded, CaptureSelection(reloaded, selected.target, environment, nil), close, nil
+}
+
+func newReloadWorkspace(parent string) (string, func() error, error) {
+	owned, err := os.MkdirTemp(parent, "plan9asm-sdk-numerical-load-")
+	if err != nil {
+		return "", nil, err
+	}
+	// Capture the actual directory ID before any consumer can replace it.
+	// os.Lstat's Windows FileInfo defers that observation until SameFile.
+	identity, err := sourcepath.Lstat(owned)
+	if err != nil {
+		return "", nil, err
+	}
+	close := func() error {
+		now, err := sourcepath.Lstat(owned)
+		if os.IsNotExist(err) {
+			return nil
+		}
+		if err != nil || !now.IsDir() || !os.SameFile(identity, now) {
+			return contextError("owned reload directory changed before cleanup")
+		}
+		return os.RemoveAll(owned)
+	}
+	return owned, close, nil
+}
+
+func EnvironmentValues(environment []string) (map[string]string, error) {
+	values := make(map[string]string)
+	for _, entry := range environment {
+		key, value, valid := strings.Cut(entry, "=")
+		if !valid || key == "" || strings.ContainsRune(entry, '\x00') {
+			return nil, fmt.Errorf("malformed actual SDK loading environment")
+		}
+		values[key] = value
+	}
+	return values, nil
+}
+
+func EncodeEnvironment(values map[string]string) []string {
+	result := make([]string, 0, len(values))
+	for key, value := range values {
+		result = append(result, key+"="+value)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func Stderr(stderr []byte) error {
+	if len(stderr) == 0 {
+		return nil
+	}
+	return fmt.Errorf("actual Go stderr: %s", strings.TrimSpace(string(stderr)))
+}
diff --git a/internal/sdkfrontend/metadata.go b/internal/sdkfrontend/metadata.go
new file mode 100644
index 000000000..601ee27d7
--- /dev/null
+++ b/internal/sdkfrontend/metadata.go
@@ -0,0 +1,53 @@
+package sdkfrontend
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// CaptureMetadata returns an actual selected whole member and its existing
+// live metadata-only owner. It creates no numerical/readonly/minimum owner,
+// Options, native entry or frame. Callers must close the returned source and
+// keep its original context live; diagnostic File/report values are not tokens.
+// This explicit role is never a broad fallback from another source error.
+// Only actual GoBinary/Directory/PackagePath/AssemblyFile/Target/Environment
+// select this producer. CaptureRequest.Root and Package supply no permission.
+// Canonical member selection does not certify a caller's original alias node;
+// a caller/member lifetime proof must independently preserve that request.
+func CaptureMetadata(ctx context.Context, request CaptureRequest) (_ *plan9asm.File, _ *plan9asm.GoX86SDKASMDataSource, result error) {
+	if ctx == nil {
+		return nil, nil, contextError("metadata capture needs its original bounded context")
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, nil, err
+	}
+	directory, err := sourcepath.Resolve(request.Directory)
+	if err != nil {
+		return nil, nil, err
+	}
+	assembly, err := sourcepath.Resolve(request.AssemblyFile)
+	if err != nil || filepath.Dir(assembly) != directory {
+		return nil, nil, contextError("metadata assembly origin differs from its actual package")
+	}
+	source, err := plan9asm.CaptureGoX86SDKASMDataSource(ctx, plan9asm.GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: directory, PackagePath: request.PackagePath,
+		Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	file, err := source.Assembly(ctx, filepath.Base(assembly))
+	if err != nil {
+		return nil, nil, err
+	}
+	return file, source, nil
+}
diff --git a/internal/sdkfrontend/metadata_go127_test.go b/internal/sdkfrontend/metadata_go127_test.go
new file mode 100644
index 000000000..0a2e7bfc5
--- /dev/null
+++ b/internal/sdkfrontend/metadata_go127_test.go
@@ -0,0 +1,174 @@
+//go:build go1.27
+
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSharedSDKMetadataOriginalEmptyDATACompleteThreeOS(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			ctx, request := sdkMetadataOriginalRequest(t, target)
+			original := &sdkMinimumCallbackContext{Context: ctx}
+			file, source, err := CaptureMetadata(original, request)
+			if err != nil {
+				t.Fatal("actual complete SDK metadata precondition", err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			})
+			if len(file.Funcs) != 3 || len(file.Data)+len(file.Globl) != 0 ||
+				file.Funcs[0].Sym != "runtime·memequal<ABIInternal>" || file.Funcs[2].Sym != "memeqbody<>" {
+				t.Fatal("actual selected original member was cropped or relabeled")
+			}
+			raw, err := source.Readback(original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var observed struct {
+				CPP          []plan9asm.AssemblyCPPObservation
+				Positions    []json.RawMessage
+				ObjectInputs gostaticstorage.SDKASMDataObservationRequest
+				Objects      *gostaticstorage.SDKASMDataObservation
+			}
+			if json.Unmarshal(raw, &observed) != nil || observed.Objects == nil ||
+				len(observed.Objects.Sources) < 2 || len(observed.Objects.Members) != len(observed.Objects.Sources)+2 ||
+				len(observed.CPP) != len(observed.Objects.Sources) || len(observed.Positions) != len(observed.CPP) {
+				t.Fatal("metadata lost the complete selected package/header/CPP inventory")
+			}
+			replayed, err := gostaticstorage.ObserveX86SDKCPPASMData(observed.ObjectInputs)
+			if err != nil || !reflect.DeepEqual(replayed, observed.Objects) {
+				t.Fatal("whole original/expanded/compiler object tuples differ", err)
+			}
+			found := false
+			for index, member := range observed.Objects.Sources {
+				if len(member.ExpandedLayouts) != 0 {
+					t.Fatal("empty DATA inventory became an initializer")
+				}
+				if member.Name == "equal_amd64.s" {
+					found = true
+					var order []int
+					for _, association := range member.TextOrder {
+						order = append(order, association.ObjectOrdinal)
+					}
+					if !reflect.DeepEqual(order, []int{1, 2, 0}) || member.Original.Texts[0].Name != "memeqbody" ||
+						!reflect.DeepEqual(member.Original.Texts, observed.Objects.Members[index+2].Texts) {
+						t.Fatal("source ordinals replaced unchanged physical records")
+					}
+				}
+			}
+			if !found {
+				t.Fatal("selected original member is absent")
+			}
+			owner, err := plan9asm.CaptureGoX86SDKReadonlyLiteralDataOwner(original, source)
+			if owner != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) ||
+				!strings.Contains(err.Error(), "no private readonly literal DATA initializers") {
+				t.Fatal("metadata manufactured an empty initializer owner", err)
+			}
+			for _, method := range []string{"BindNumericalReads", "BindNumericalReadsWithLiteralAlignment", "Options"} {
+				if _, present := reflect.TypeOf(source).MethodByName(method); present {
+					t.Fatal("metadata leaf exposes another permission", method)
+				}
+			}
+			if missing, err := source.Assembly(original, "unselected.s"); missing != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("unselected member acquired source identity", err)
+			}
+			if err := source.Verify(original); err != nil {
+				t.Fatal("unsupported member selection revoked its independent live observer", err)
+			}
+			var reached atomic.Bool
+			original.mu.Lock()
+			original.callback = func(method string) {
+				if method == "Err" && reached.CompareAndSwap(false, true) {
+					if err := source.Close(); err != nil {
+						t.Error(err)
+					}
+				}
+			}
+			original.mu.Unlock()
+			if closed, err := source.Assembly(original, "equal_amd64.s"); closed != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) || !reached.Load() {
+				t.Fatal("callback Close published parsed metadata after revocation", err)
+			}
+			original.mu.Lock()
+			original.callback = nil
+			original.mu.Unlock()
+			if err := source.Verify(original); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("restored callback revived the closed original observer", err)
+			}
+			if closed, err := source.Readback(original); closed != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Fatal("closed owner retained diagnostic publication", err)
+			}
+		})
+	}
+}
+
+// Only command/profile setup lives here; all ASM/header/object observation
+// remains in the existing production producer. CGO is the actual Go default.
+func sdkMetadataOriginalRequest(t *testing.T, target string) (context.Context, CaptureRequest) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	t.Cleanup(cancel)
+	goos, arch, valid := strings.Cut(target, "/")
+	if !valid {
+		t.Fatal("invalid test target")
+	}
+	for key, value := range map[string]string{"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOFLAGS": "", "GOEXPERIMENT": "",
+		"GOPACKAGESDRIVER": "off", "GOPROXY": "off", "GOOS": goos, "GOARCH": arch, "GOAMD64": "v1", "GO386": "sse2"} {
+		t.Setenv(key, value)
+	}
+	t.Setenv("CGO_ENABLED", "")
+	if err := os.Unsetenv("CGO_ENABLED"); err != nil {
+		t.Fatal(err)
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		directory, err := sourcepath.Resolve(t.TempDir())
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Setenv(key, directory)
+	}
+	root, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(root, "src", "internal", "bytealg")
+	environment := os.Environ()
+	cgo, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, binary, "env", "CGO_ENABLED")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual default CGO profile: %v\n%s", err, stderr)
+	}
+	values, err := EnvironmentValues(environment)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values["CGO_ENABLED"] = strings.TrimSpace(string(cgo))
+	return ctx, CaptureRequest{GoBinary: binary, Directory: directory, PackagePath: "internal/bytealg",
+		AssemblyFile: filepath.Join(directory, "equal_amd64.s"), Target: target, Environment: EncodeEnvironment(values)}
+}
diff --git a/internal/sdkfrontend/metadata_test.go b/internal/sdkfrontend/metadata_test.go
new file mode 100644
index 000000000..ef946d12f
--- /dev/null
+++ b/internal/sdkfrontend/metadata_test.go
@@ -0,0 +1,39 @@
+package sdkfrontend
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestSharedSDKMetadataCanceledCaptureHasNoOwner(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	file, source, err := CaptureMetadata(ctx, CaptureRequest{})
+	if file != nil || source != nil || !errors.Is(err, context.Canceled) {
+		t.Fatal("canceled input created a metadata owner", err)
+	}
+	file, source, err = CaptureMetadata(nil, CaptureRequest{})
+	if file != nil || source != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("missing context created a metadata owner", err)
+	}
+}
+
+func TestSharedSDKMetadataInvalidOriginHasNoOwner(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	directory, outside := t.TempDir(), t.TempDir()
+	assembly := filepath.Join(outside, "outside.s")
+	if err := os.WriteFile(assembly, []byte("TEXT example<>(SB),4,$0-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	file, source, err := CaptureMetadata(ctx, CaptureRequest{Directory: directory, AssemblyFile: assembly})
+	if file != nil || source != nil || !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("out-of-package origin created a metadata owner", err)
+	}
+}
diff --git a/internal/sdkfrontend/minimum.go b/internal/sdkfrontend/minimum.go
new file mode 100644
index 000000000..1380dfe33
--- /dev/null
+++ b/internal/sdkfrontend/minimum.go
@@ -0,0 +1,176 @@
+package sdkfrontend
+
+import (
+	"context"
+	"errors"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+// BindNumericalReads composes independent owners only when the complete typed
+// source requests their role. Ordinary reads retain their ordinary binder.
+func (source *Source) BindNumericalReads(ctx context.Context, pkg plan9asm.GoPackage, file *plan9asm.File, options plan9asm.Options) (bound plan9asm.Options, result error) {
+	if err := source.begin(ctx); err != nil {
+		return plan9asm.Options{}, err
+	}
+	defer func() {
+		result = errors.Join(result, source.end())
+		if result != nil {
+			bound = plan9asm.Options{}
+		}
+	}()
+	requested := plan9asm.GoX86SDKLiteralAlignmentRequested(file, options)
+	if err := source.stillLive(); err != nil {
+		return plan9asm.Options{}, err
+	}
+	if !requested {
+		return source.Numerical.BindNumericalReads(ctx, pkg, file, options)
+	}
+	if source.literalOwner == nil {
+		return plan9asm.Options{}, contextError("metadata-only source has no literal-minimum owner")
+	}
+	if !source.minimumAttempted {
+		source.minimumAttempted = true // One actual attempt under the original bounded context.
+		source.minimum, source.minimumError = plan9asm.CaptureGoX86SDKLiteralAlignment(ctx, source.literalOwner)
+		if source.minimumError == nil {
+			source.originalMinimum = source.minimum
+			source.cleanup = append(source.cleanup, source.minimum.Close)
+		}
+	}
+	if source.minimumError != nil {
+		return plan9asm.Options{}, source.minimumError
+	}
+	if err := source.stillLive(); err != nil {
+		return plan9asm.Options{}, err
+	}
+	// The core binder independently authenticates the exact same original
+	// owner/source/context/profile, minimum generation and complete function.
+	return source.Numerical.BindNumericalReadsWithLiteralAlignment(ctx, pkg, file, options, source.minimum)
+}
+
+func (source *Source) Verify(ctx context.Context) (result error) {
+	if err := source.begin(ctx); err != nil {
+		return err
+	}
+	defer func() { result = errors.Join(result, source.end()) }()
+	result = source.Numerical.Verify(ctx)
+	if source.minimum != nil {
+		result = errors.Join(result, source.minimum.Verify(ctx))
+	}
+	return result
+}
+
+// Active operations are exclusive, but Close never waits on user/context
+// callbacks. It permanently revokes the handle and defers owned cleanup until
+// that operation unwinds. Reentry cannot duplicate a capture or deadlock.
+func (source *Source) begin(ctx context.Context) error {
+	if source == nil || ctx == nil {
+		return contextError("source lacks its original bounded context")
+	}
+	source.mu.Lock()
+	if source.identity != source {
+		source.mu.Unlock()
+		return contextError("foreign source cannot enter borrowed ownership")
+	}
+	// Active cache publication is exclusively owned by the operation. Never
+	// read its in-progress fields or call a user context from another entrant.
+	if source.active {
+		source.mu.Unlock()
+		return contextError("source operation is already active")
+	}
+	if !source.originalComponents() {
+		source.closePending = true
+		cleanup := source.cleanup
+		source.cleanup, source.closed = nil, true
+		source.mu.Unlock()
+		return errors.Join(contextError("original source components changed permanently"), source.revoke(), closeSDKSource(cleanup))
+	}
+	if source.closed || source.closePending ||
+		!reflect.TypeOf(ctx).Comparable() || ctx != source.context {
+		source.mu.Unlock()
+		return contextError("source/owner/context/minimum is closed, reentrant or changed")
+	}
+	source.active = true
+	source.mu.Unlock()
+	// Reserve exclusivity before any caller context callback. Nested begin
+	// must reject before sampling Err/Deadline/Done, not recursively invoke it.
+	if err := ctx.Err(); err != nil {
+		source.mu.Lock()
+		source.closePending = true
+		source.mu.Unlock()
+		return errors.Join(err, source.end())
+	}
+	return nil
+}
+
+func (source *Source) stillLive() error {
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if !source.originalComponents() || source.closed || source.closePending {
+		return contextError("source closed or changed during its active operation")
+	}
+	return nil
+}
+
+func (source *Source) end() error {
+	source.mu.Lock()
+	source.active = false
+	if !source.originalComponents() {
+		source.closePending = true
+	}
+	if !source.closePending {
+		source.mu.Unlock()
+		return nil
+	}
+	cleanup := source.cleanup
+	source.cleanup, source.closed = nil, true
+	source.mu.Unlock()
+	return errors.Join(contextError("source closed or changed during its active operation"), source.revoke(), closeSDKSource(cleanup))
+}
+
+// Called under mu before/after every user callback boundary. Public Numerical
+// replacement cannot silently change the source whose resources we own.
+func (source *Source) originalComponents() bool {
+	return source.identity == source && source.Numerical != nil && source.Numerical == source.originalNumerical &&
+		source.literalOwner == source.originalLiteralOwner && source.minimum == source.originalMinimum
+}
+
+func (source *Source) Close() error {
+	if source == nil {
+		return nil
+	}
+	source.mu.Lock()
+	if source.identity != source {
+		source.mu.Unlock()
+		return contextError("foreign source cannot close borrowed owners")
+	}
+	if source.closed {
+		source.mu.Unlock()
+		return nil
+	}
+	source.closePending = true
+	if source.active {
+		source.mu.Unlock()
+		return source.revoke() // Immediate publication revocation; no locks/callbacks/artifact disposal.
+	}
+	cleanup := source.cleanup
+	source.cleanup, source.closed = nil, true
+	source.mu.Unlock()
+	return errors.Join(source.revoke(), closeSDKSource(cleanup))
+}
+
+func (source *Source) revoke() error {
+	if source.originalNumerical == nil {
+		return nil
+	}
+	return source.originalNumerical.Revoke()
+}
+
+func closeSDKSource(cleanup []func() error) error {
+	var result error
+	for index := len(cleanup) - 1; index >= 0; index-- {
+		result = errors.Join(result, cleanup[index]())
+	}
+	return result
+}
diff --git a/internal/sdkfrontend/minimum_go127_test.go b/internal/sdkfrontend/minimum_go127_test.go
new file mode 100644
index 000000000..aff0917a9
--- /dev/null
+++ b/internal/sdkfrontend/minimum_go127_test.go
@@ -0,0 +1,671 @@
+//go:build go1.27
+
+package sdkfrontend
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestSharedSDKLiteralMinimumOriginalCompleteMaps(t *testing.T) {
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, "internal/runtime/maps", "memhash_amd64.s")
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if !plan9asm.GoX86SDKLiteralAlignmentRequested(file, options) {
+		t.Fatal("complete actual source lost its typed linked-minimum cost")
+	}
+	if _, err := source.Numerical.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("default numerical binder manufactured a linked minimum", err)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("shared complete source lacks its genuine minimum handoff", err)
+	}
+	ir, err := plan9asm.Translate(file, bound)
+	if err != nil || strings.Count(ir, "define ") != len(file.Funcs) || len(file.Funcs) != 2 || len(file.Globl) != 2 ||
+		!strings.Contains(ir, "external global [128 x i8]") {
+		t.Fatal("complete source/function/DATA/mutable-storage publication differs", err)
+	}
+	minimum := source.minimum
+	first, err := minimum.Readback(ctx)
+	if err != nil || sdkMinimumLinkCommands(t, first) != 1 {
+		t.Fatal("genuine minimum needs exactly one original Go link receipt", err)
+	}
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); err != nil || source.minimum != minimum {
+		t.Fatal("same live source unnecessarily recaptured a minimum", err)
+	}
+	second, err := minimum.Readback(ctx)
+	if err != nil || !bytes.Equal(first, second) || sdkMinimumLinkCommands(t, second) != 1 {
+		t.Fatal("cached minimum added commands or changed its exact report", err)
+	}
+	// The successful genuine producer stores its cache fields in sequence.
+	// Model that publication boundary using the real cached minimum, not a
+	// fabricated producer/floor. An active entrant must not inspect the cache.
+	source.mu.Lock()
+	source.active, source.originalMinimum = true, nil
+	source.mu.Unlock()
+	if err := source.Verify(ctx); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("concurrent active operation was accepted", err)
+	}
+	source.mu.Lock()
+	changed := source.closePending
+	source.active, source.originalMinimum = false, minimum
+	source.mu.Unlock()
+	if changed {
+		t.Fatal("active entrant inspected a partially published genuine cache and revoked its owner")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("active entrant permanently changed the genuine source", err)
+	}
+	foreignContext, cancel := context.WithTimeout(ctx, time.Minute)
+	defer cancel()
+	if _, err := source.BindNumericalReads(foreignContext, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("a new context acquired the original factory", err)
+	}
+	foreign := &Source{Numerical: source.Numerical, identity: source, cleanup: source.cleanup}
+	if err := foreign.Close(); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("foreign handle closed borrowed resources", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("foreign close revoked the original factory", err)
+	}
+	if err := minimum.Close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) || source.minimum != minimum {
+		t.Fatal("closed cached minimum was rebuilt or retained authority", err)
+	}
+	if _, err := plan9asm.Translate(file, bound); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("closed minimum retained publication authority", err)
+	}
+}
+
+func TestSharedSDKLiteralMinimumCRC32NoAdditionalLink(t *testing.T) {
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, "hash/crc32", "crc32_amd64.s")
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	before, err := source.Numerical.Readback(ctx)
+	if err != nil || sdkMinimumLinkCommands(t, before) != 0 {
+		t.Fatal("ordinary producer added a Go link", err)
+	}
+	for attempt := 0; attempt < 2; attempt++ {
+		_, err := source.BindNumericalReads(ctx, pkg, file, options)
+		if err != nil || source.minimumAttempted || source.minimum != nil {
+			t.Fatal("ordinary CRC32 unnecessarily paid for a minimum", err)
+		}
+	}
+	after, err := source.Numerical.Readback(ctx)
+	if err != nil || !bytes.Equal(before, after) || sdkMinimumLinkCommands(t, after) != 0 {
+		t.Fatal("ordinary repeated binding added commands or changed its complete receipt", err)
+	}
+}
+
+// Repeated-binding cost and whole-publication lifetime are independent axes.
+// Each retains a genuine capture and the original five-minute context budget.
+func TestSharedSDKLiteralMinimumCRC32WholeSourceAndLifecycle(t *testing.T) {
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, "hash/crc32", "crc32_amd64.s")
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil || source.minimumAttempted || source.minimum != nil {
+		t.Fatal("ordinary CRC32 whole source borrowed a linked minimum", err)
+	}
+	if _, err := plan9asm.Translate(file, bound); err != nil {
+		t.Fatal(err)
+	}
+	resolve := options.ResolveSym
+	closed := false
+	var closes int32
+	source.cleanup = append(source.cleanup, func() error { atomic.AddInt32(&closes, 1); return nil })
+	options.ResolveSym = func(symbol string) string {
+		if !closed {
+			closed = true
+			if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Error("reentrant binder acquired the active source", err)
+			}
+			if err := source.Verify(ctx); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Error("reentrant verifier acquired the active source", err)
+			}
+			var workers sync.WaitGroup
+			for i := 0; i < 2; i++ {
+				workers.Add(1)
+				go func() {
+					defer workers.Done()
+					if err := source.Close(); err != nil {
+						t.Error(err)
+					}
+				}()
+			}
+			workers.Wait() // Close must return while this callback still owns the operation.
+			if atomic.LoadInt32(&closes) != 0 {
+				t.Error("concurrent Close cleaned resources during an active callback")
+			}
+		}
+		return resolve(symbol)
+	}
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("callback Close published bound options", err)
+	}
+	if err := source.Verify(ctx); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("callback Close was not permanent", err)
+	}
+	if err := source.Close(); err != nil {
+		t.Fatal("owned callbacks were closed twice", err)
+	}
+	if atomic.LoadInt32(&closes) != 1 {
+		t.Fatal("pending Close did not release its ownership exactly once", closes)
+	}
+}
+
+func TestSharedSDKLiteralMinimumLateNumericalReplacement(t *testing.T) {
+	for _, action := range []string{"before-begin", "callback-replacement", "callback-close"} {
+		t.Run(action, func(t *testing.T) { sharedSDKLiteralMinimumLateMutation(t, action) })
+	}
+}
+
+func sharedSDKLiteralMinimumLateMutation(t *testing.T, action string) {
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, "internal/runtime/maps", "memhash_amd64.s")
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); err != nil {
+		t.Fatal(err)
+	}
+	if action == "before-begin" {
+		original := source.Numerical
+		source.Numerical = nil
+		if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatal("pre-operation numerical replacement accepted", err)
+		}
+		source.Numerical = original
+		if err := source.Verify(ctx); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatal("restored pointer revived permanently changed source ownership", err)
+		}
+		return
+	}
+	resolve, calls := options.ResolveSym, 0
+	acted := false
+	options.ResolveSym = func(symbol string) string {
+		calls++
+		if calls > len(file.Funcs) && !acted {
+			acted = true
+			if action == "callback-close" {
+				if err := source.Close(); err != nil {
+					t.Error(err)
+				}
+			} else {
+				source.Numerical = nil
+			}
+		}
+		return resolve(symbol)
+	}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("late callback replacement escaped the shared original-source join", err)
+	}
+	if bound.NumericalReads != nil || len(bound.Sigs) != 0 {
+		t.Fatal("deferred guard failure retained nonempty bound options")
+	}
+}
+
+func sdkMinimumLinkCommands(t *testing.T, raw []byte) int {
+	t.Helper()
+	var report struct {
+		Commands []struct{ Arguments []string }
+	}
+	if err := json.Unmarshal(raw, &report); err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, command := range report.Commands {
+		if len(command.Arguments) > 2 && command.Arguments[0] == "tool" && command.Arguments[1] == "link" && command.Arguments[2] != "-V" {
+			count++
+		}
+	}
+	return count
+}
+
+// This independently observes cmd/go's exact selected source and exports;
+// gc-imported dependencies never replace the primary's complete original syntax.
+func sdkMinimumOriginalPackage(t *testing.T, path, assembly string) (context.Context, CaptureRequest, plan9asm.GoPackage, *plan9asm.File, plan9asm.Options) {
+	return sdkMinimumOriginalPackageContext(t, path, assembly, nil)
+}
+
+func sdkMinimumOriginalPackageContext(t *testing.T, path, assembly string, decorate func(context.Context) context.Context) (context.Context, CaptureRequest, plan9asm.GoPackage, *plan9asm.File, plan9asm.Options) {
+	t.Helper()
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
+	t.Cleanup(cancel)
+	var originalContext context.Context = ctx
+	if decorate != nil {
+		originalContext = decorate(ctx)
+	}
+	for key, value := range map[string]string{"GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOFLAGS": "", "GOEXPERIMENT": "", "GOPACKAGESDRIVER": "off", "GOPROXY": "off", "GOOS": "linux", "GOARCH": "amd64", "GOAMD64": "v1", "GO386": "sse2"} {
+		t.Setenv(key, value)
+	}
+	t.Setenv("CGO_ENABLED", "")
+	if err := os.Unsetenv("CGO_ENABLED"); err != nil {
+		t.Fatal(err)
+	}
+	for _, key := range []string{"GOCACHE", "GOMODCACHE", "GOPATH", "TMPDIR", "GOTMPDIR"} {
+		directory, err := sourcepath.Resolve(t.TempDir())
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Setenv(key, directory)
+	}
+	root, err := sourcepath.Resolve(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	binary, err = sourcepath.Resolve(binary)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := filepath.Join(root, "src", filepath.FromSlash(path))
+	environment := os.Environ()
+	cgo, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, binary, "env", "CGO_ENABLED")
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual default CGO profile: %v\n%s", err, stderr)
+	}
+	values, err := EnvironmentValues(environment)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values["CGO_ENABLED"] = strings.TrimSpace(string(cgo))
+	environment = EncodeEnvironment(values)
+	output, stderr, err := gotoolprofile.RunBounded(ctx, directory, environment, binary, "list", "-deps", "-export", "-compiled", "-mod=readonly", "-json", path)
+	if err != nil || len(stderr) != 0 {
+		t.Fatalf("actual original SDK selection: %v\n%s", err, stderr)
+	}
+	selected := make(map[string]gostaticstorage.Package)
+	decoder := json.NewDecoder(bytes.NewReader(output))
+	for {
+		var item gostaticstorage.Package
+		if err := decoder.Decode(&item); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Fatal(err)
+		}
+		if !item.Standard || !item.Goroot || item.Module != nil || len(item.Error) != 0 || len(item.DepsErrors) != 0 {
+			t.Fatal("actual selection is not an ordinary SDK graph", item.ImportPath)
+		}
+		selected[item.ImportPath] = item
+	}
+	primary, found := selected[path]
+	if !found || len(primary.GoFiles) != len(primary.CompiledGoFiles) {
+		t.Fatal("complete original primary source is absent")
+	}
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, filename := range primary.GoFiles {
+		file, err := parser.ParseFile(fset, filepath.Join(directory, filename), nil, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	imports := importer.ForCompiler(fset, "gc", func(importPath string) (io.ReadCloser, error) {
+		if mapped, ok := primary.ImportMap[importPath]; ok {
+			importPath = mapped
+		}
+		dependency, found := selected[importPath]
+		if !found || dependency.Export == "" {
+			return nil, fmt.Errorf("missing actual SDK export: %s", importPath)
+		}
+		return os.Open(dependency.Export)
+	})
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes, Importer: imports, GoVersion: "go1.27"}).Check(path, fset, syntax, nil)
+	if err != nil {
+		t.Fatal("complete independently typed primary", err)
+	}
+	pkg := plan9asm.GoPackage{Path: path, Types: typed, Syntax: syntax, Imports: make(map[string]*types.Package)}
+	view := &Package{Path: path, Types: typed, Sizes: sizes, Imports: make(map[string]*Package)}
+	for _, dependency := range typed.Imports() {
+		pkg.Imports[dependency.Path()] = dependency
+		view.Imports[dependency.Path()] = &Package{Path: dependency.Path(), Types: dependency}
+	}
+	filename := filepath.Join(directory, assembly)
+	raw, err := plan9asm.ReadGoAssemblySource(filename, directory)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := plan9asm.ParseWithDefines(plan9asm.ArchAMD64, string(raw), plan9asm.GoAssemblerDefines("linux", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := plan9asm.Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: func(symbol string) string { return Resolve(path, symbol) }, Sigs: make(map[string]plan9asm.FuncSig)}
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			continue // A private continuation has no Go entry declaration.
+		}
+		name := strings.TrimPrefix(Resolve("", fn.Sym), ".")
+		declaration, valid := typed.Scope().Lookup(name).(*types.Func)
+		if !valid {
+			t.Fatal("original TEXT has no actual declaration", name)
+		}
+		sig, err := plan9asm.DeriveGoFuncABI0Signature(Resolve(path, fn.Sym), declaration, "amd64", sizes)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options.Sigs[sig.Name] = sig
+	}
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op != plan9asm.OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != plan9asm.OpSym {
+				continue
+			}
+			symbol := strings.TrimSuffix(ins.Args[0].Sym, "(SB)")
+			if strings.HasSuffix(symbol, "<>") {
+				continue
+			}
+			name := strings.TrimPrefix(Resolve("", symbol), ".")
+			declaration, valid := typed.Scope().Lookup(name).(*types.Func)
+			if !valid {
+				t.Fatal("ordinary tail lacks its actual Go declaration", name)
+			}
+			sig, err := plan9asm.DeriveGoFuncABI0Signature(Resolve(path, symbol), declaration, "amd64", sizes)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options.Sigs[sig.Name] = sig
+		}
+	}
+	return originalContext, CaptureRequest{GoBinary: binary, Root: root, Directory: directory, PackagePath: path, AssemblyFile: filename, Target: "linux/amd64", Environment: environment, Package: view}, pkg, file, options
+}
+
+type sdkMinimumCallbackContext struct {
+	context.Context
+	mu         sync.Mutex
+	callback   func(string)
+	inside     int32
+	errSamples int32
+	failure    error
+}
+
+func (ctx *sdkMinimumCallbackContext) invoke(method string) {
+	ctx.mu.Lock()
+	callback := ctx.callback
+	ctx.mu.Unlock()
+	if callback != nil && atomic.CompareAndSwapInt32(&ctx.inside, 0, 1) {
+		defer atomic.StoreInt32(&ctx.inside, 0)
+		callback(method)
+	}
+}
+func (ctx *sdkMinimumCallbackContext) Err() error {
+	atomic.AddInt32(&ctx.errSamples, 1)
+	ctx.invoke("Err")
+	ctx.mu.Lock()
+	failure := ctx.failure
+	ctx.mu.Unlock()
+	if failure != nil {
+		return failure
+	}
+	return ctx.Context.Err()
+}
+func (ctx *sdkMinimumCallbackContext) Deadline() (time.Time, bool) {
+	ctx.invoke("Deadline")
+	return ctx.Context.Deadline()
+}
+func (ctx *sdkMinimumCallbackContext) Done() <-chan struct{} {
+	ctx.invoke("Done")
+	return ctx.Context.Done()
+}
+
+func TestSharedSDKLiteralMinimumContextReentryBeforeCallbacks(t *testing.T) {
+	var caller *sdkMinimumCallbackContext
+	ctx, request, _, file, _ := sdkMinimumOriginalPackageContext(t, "hash/crc32", "crc32_amd64.s", func(base context.Context) context.Context {
+		caller = &sdkMinimumCallbackContext{Context: base}
+		return caller
+	})
+	_, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	for _, method := range []string{"Err", "Deadline", "Done"} {
+		var reached int32
+		caller.mu.Lock()
+		caller.callback = func(observed string) {
+			if observed != method || !atomic.CompareAndSwapInt32(&reached, 0, 1) {
+				return
+			}
+			before := atomic.LoadInt32(&caller.errSamples)
+			err := source.begin(ctx)
+			if err == nil {
+				if endErr := source.end(); endErr != nil {
+					t.Error(endErr)
+				}
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Error("same-context nested operation entered before callback guard", method, err)
+			}
+			if atomic.LoadInt32(&caller.errSamples) != before {
+				t.Error("nested active operation resampled caller Err", method)
+			}
+		}
+		caller.mu.Unlock()
+		if err := source.Verify(ctx); err != nil {
+			t.Fatal("non-mutating context reentry revoked original owner", method, err)
+		}
+		caller.mu.Lock()
+		caller.callback = nil
+		caller.mu.Unlock()
+		if atomic.LoadInt32(&reached) != 1 {
+			t.Fatal("real context callback was not reached", method)
+		}
+	}
+}
+
+func TestSharedSDKLiteralMinimumOriginalContextFailurePermanent(t *testing.T) {
+	var caller *sdkMinimumCallbackContext
+	ctx, request, _, file, _ := sdkMinimumOriginalPackageContext(t, "hash/crc32", "crc32_amd64.s", func(base context.Context) context.Context {
+		caller = &sdkMinimumCallbackContext{Context: base}
+		return caller
+	})
+	_, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	caller.mu.Lock()
+	caller.failure = context.Canceled
+	caller.mu.Unlock()
+	if err := source.Verify(ctx); !errors.Is(err, context.Canceled) {
+		t.Fatal("original caller cancellation cause was lost", err)
+	}
+	caller.mu.Lock()
+	caller.failure = nil
+	caller.mu.Unlock()
+	if err := source.Verify(ctx); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("restored original Err callback revived a failed source lifetime", err)
+	}
+}
+
+func TestSharedSDKLiteralMinimumConcurrentActualCapture(t *testing.T) {
+	var caller *sdkMinimumCallbackContext
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackageContext(t, "internal/runtime/maps", "memhash_amd64.s", func(base context.Context) context.Context {
+		caller = &sdkMinimumCallbackContext{Context: base}
+		return caller
+	})
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	var reached int32
+	caller.mu.Lock()
+	caller.callback = func(method string) {
+		// Test-only phase observation, never an SDK ownership/caller proof.
+		var pcs [32]uintptr
+		frames := runtime.CallersFrames(pcs[:runtime.Callers(2, pcs[:])])
+		capture := false
+		for {
+			frame, more := frames.Next()
+			if strings.HasSuffix(frame.Function, ".CaptureGoX86SDKLiteralAlignment") {
+				capture = true
+			}
+			if !more {
+				break
+			}
+		}
+		if !capture || !atomic.CompareAndSwapInt32(&reached, 0, 1) {
+			return
+		}
+		errors := make(chan error, 2)
+		go func() { _, err := source.BindNumericalReads(ctx, pkg, file, options); errors <- err }()
+		go func() { errors <- source.Verify(ctx) }()
+		for i := 0; i < 2; i++ {
+			if err := <-errors; !errorsIsSDKContext(err) {
+				t.Error("concurrent caller entered actual minimum capture", method, err)
+			}
+		}
+	}
+	caller.mu.Unlock()
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); err != nil {
+		t.Fatal("genuine minimum capture did not retain its exclusive owner", err)
+	}
+	caller.mu.Lock()
+	caller.callback = nil
+	caller.mu.Unlock()
+	if atomic.LoadInt32(&reached) != 1 {
+		t.Fatal("actual original producer capture callback was not observed")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("rejected concurrent entry revoked captured owner", err)
+	}
+}
+
+func errorsIsSDKContext(err error) bool { return errors.Is(err, plan9asm.ErrProbeNeedsContext) }
+
+func TestSharedSDKLiteralMinimumCloseRevokesPreviouslyBoundOptions(t *testing.T) {
+	for _, path := range []string{"hash/crc32", "internal/runtime/maps"} {
+		t.Run(path, func(t *testing.T) { sharedSDKMinimumClosePreviousOptions(t, path) })
+	}
+}
+
+func sharedSDKMinimumClosePreviousOptions(t *testing.T, path string) {
+	assembly := "crc32_amd64.s"
+	if path == "internal/runtime/maps" {
+		assembly = "memhash_amd64.s"
+	}
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, path, assembly)
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	previous, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve, closed := options.ResolveSym, false
+	original, err := os.ReadFile(request.AssemblyFile)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options.ResolveSym = func(symbol string) string {
+		if !closed {
+			closed = true
+			if err := source.Close(); err != nil {
+				t.Error(err)
+			}
+			if _, err := plan9asm.Translate(file, previous); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Error("Close retained old text publication during active callback", err)
+			}
+			func() {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, err := plan9asm.TranslateModuleInContext(context, file, previous)
+				if !module.IsNil() {
+					module.Dispose()
+				}
+				if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+					t.Error("Close retained old module publication during active callback", err)
+				}
+			}()
+			result, err := plan9asm.TranslateGoModule(pkg, original, plan9asm.GoModuleOptions{GOARCH: "amd64", GOOS: "linux", TargetTriple: previous.TargetTriple, FileName: filepath.Base(request.AssemblyFile), NumericalReads: previous.NumericalReads, ResolveSym: previous.ResolveSym})
+			if result != nil && !result.Module.IsNil() {
+				result.Module.Dispose()
+			}
+			if !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+				t.Error("Close retained old Go-module publication during active callback", err)
+			}
+		}
+		return resolve(symbol)
+	}
+	if _, err := source.BindNumericalReads(ctx, pkg, file, options); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("active Close accepted outer binding", err)
+	}
+}
diff --git a/internal/sdkfrontend/nodata_go127_test.go b/internal/sdkfrontend/nodata_go127_test.go
new file mode 100644
index 000000000..4f0ce24b6
--- /dev/null
+++ b/internal/sdkfrontend/nodata_go127_test.go
@@ -0,0 +1,126 @@
+//go:build go1.27
+
+package sdkfrontend
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestSharedSDKNumericalOriginalNoDATAKeepsIndependentRoles(t *testing.T) {
+	ctx, request := sdkMetadataOriginalRequest(t, "linux/amd64")
+	request.Root = filepath.Dir(filepath.Dir(request.GoBinary))
+	request.AssemblyFile = filepath.Join(request.Directory, "count_amd64.s")
+	request.Package = &Package{Path: request.PackagePath}
+	file, metadata, err := CaptureMetadata(ctx, request)
+	if err != nil {
+		t.Fatal("complete original source/object precondition", err)
+	}
+	t.Cleanup(func() {
+		if err := metadata.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if len(file.Funcs) != 3 || len(file.Data)+len(file.Globl) != 0 {
+		t.Fatal("complete original count member changed")
+	}
+	actual, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal("an empty DATA inventory cannot require an initializer owner", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	if !reflect.DeepEqual(file, actual) || source.literalOwner != nil || source.minimum != nil || source.minimumAttempted {
+		t.Fatal("no-DATA numerical capture invented initializer/minimum or changed original nodes")
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("actual independent numerical source not live", err)
+	}
+}
+
+func TestSharedSDKNoDATACountText(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "count_amd64.s", "text")
+}
+
+func TestSharedSDKNoDATACountModule(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "count_amd64.s", "module")
+}
+
+func TestSharedSDKNoDATACountGoModule(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "count_amd64.s", "go-module")
+}
+
+func TestSharedSDKNoDATAIndexByteText(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "indexbyte_amd64.s", "text")
+}
+
+func TestSharedSDKNoDATAIndexByteModule(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "indexbyte_amd64.s", "module")
+}
+
+func TestSharedSDKNoDATAIndexByteGoModule(t *testing.T) {
+	sharedSDKNoDATAOriginalOwner(t, "indexbyte_amd64.s", "go-module")
+}
+
+// Each complete member/API owns a fresh original producer deadline. Sharing
+// this fixture must not share the live factory or its remaining budget.
+func sharedSDKNoDATAOriginalOwner(t *testing.T, member, api string) {
+	t.Helper()
+	ctx, request, pkg, file, options := sdkMinimumOriginalPackage(t, "internal/bytealg", member)
+	file, source, err := Capture(ctx, request, file)
+	if err != nil {
+		t.Fatal("complete original no-DATA numerical source", err)
+	}
+	t.Cleanup(func() {
+		if err := source.Close(); err != nil {
+			t.Error(err)
+		}
+	})
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("original numerical/TEXT nodes did not bind", err)
+	}
+	var ir string
+	switch api {
+	case "text":
+		ir, err = plan9asm.Translate(file, bound)
+	case "module":
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, translateErr := plan9asm.TranslateModuleInContext(context, file, bound)
+		err = translateErr
+		if !module.IsNil() {
+			defer module.Dispose()
+			ir = module.String()
+		}
+	case "go-module":
+		original, readErr := os.ReadFile(request.AssemblyFile)
+		if readErr != nil {
+			t.Fatal(readErr)
+		}
+		translation, translateErr := plan9asm.TranslateGoModule(pkg, original,
+			plan9asm.GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple,
+				ResolveSym: bound.ResolveSym, FileName: member, NumericalReads: bound.NumericalReads})
+		err = translateErr
+		if translation != nil {
+			defer translation.Module.Dispose()
+			ir = translation.Module.String()
+		}
+	default:
+		t.Fatal("unknown complete original API owner", api)
+	}
+	if err != nil || ir == "" {
+		t.Fatal("complete original numerical continuation lost state/identity", err)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("complete original source owner changed after translation", err)
+	}
+}
diff --git a/internal/sdkfrontend/nodata_ownership_test.go b/internal/sdkfrontend/nodata_ownership_test.go
new file mode 100644
index 000000000..d891df0ba
--- /dev/null
+++ b/internal/sdkfrontend/nodata_ownership_test.go
@@ -0,0 +1,125 @@
+package sdkfrontend
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func sharedSDKNoDATAOwners(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "owners.go", source, 0)
+	if err != nil {
+		return err
+	}
+	want := map[string][2]string{}
+	for suffix, member := range map[string]string{"Count": "count_amd64.s", "IndexByte": "indexbyte_amd64.s"} {
+		for ending, api := range map[string]string{"Text": "text", "Module": "module", "GoModule": "go-module"} {
+			want["TestSharedSDKNoDATA"+suffix+ending] = [2]string{member, api}
+		}
+	}
+	seen := map[string]bool{}
+	var helper *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		if fn.Name.Name == "sharedSDKNoDATAOriginalOwner" {
+			helper = fn
+		}
+		if !strings.HasPrefix(fn.Name.Name, "TestSharedSDKNoDATA") {
+			continue
+		}
+		axis, exists := want[fn.Name.Name]
+		if !exists || seen[fn.Name.Name] || fn.Body == nil || len(fn.Body.List) != 1 {
+			return fmt.Errorf("missing, duplicate or aggregated owner %s", fn.Name.Name)
+		}
+		expression, ok := fn.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			return fmt.Errorf("conditional owner %s", fn.Name.Name)
+		}
+		call, ok := expression.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 3 {
+			return fmt.Errorf("complete original owner call missing")
+		}
+		name, named := call.Fun.(*ast.Ident)
+		parameter, parameterOK := call.Args[0].(*ast.Ident)
+		member, memberOK := call.Args[1].(*ast.BasicLit)
+		api, apiOK := call.Args[2].(*ast.BasicLit)
+		if !named || name.Name != "sharedSDKNoDATAOriginalOwner" || !parameterOK || parameter.Name != "t" ||
+			!memberOK || member.Value != strconv.Quote(axis[0]) || !apiOK || api.Value != strconv.Quote(axis[1]) {
+			return fmt.Errorf("original member/API ownership changed")
+		}
+		seen[fn.Name.Name] = true
+	}
+	if len(seen) != 6 || helper == nil || helper.Body == nil {
+		return fmt.Errorf("six independent complete original owners required")
+	}
+	counts := map[string]int{}
+	var factory *ast.CallExpr
+	var forbidden string
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if name, ok := call.Fun.(*ast.Ident); ok {
+			counts[name.Name]++
+			if name.Name == "sdkMinimumOriginalPackage" {
+				factory = call
+			}
+		}
+		if selector, ok := call.Fun.(*ast.SelectorExpr); ok {
+			counts[selector.Sel.Name]++
+			if selector.Sel.Name == "Run" || strings.HasPrefix(selector.Sel.Name, "Skip") {
+				forbidden = selector.Sel.Name
+			}
+		}
+		return true
+	})
+	for _, name := range []string{"sdkMinimumOriginalPackage", "Capture", "BindNumericalReads", "Verify", "Translate", "TranslateModuleInContext", "TranslateGoModule"} {
+		if counts[name] != 1 {
+			return fmt.Errorf("complete fresh producer/consumer/guard %s changed", name)
+		}
+	}
+	if forbidden != "" {
+		return fmt.Errorf("shared or skipped complete owner: %s", forbidden)
+	}
+	for _, statement := range helper.Body.List {
+		if assignment, ok := statement.(*ast.AssignStmt); ok && len(assignment.Rhs) == 1 && assignment.Rhs[0] == factory {
+			return nil
+		}
+	}
+	return fmt.Errorf("fresh factory is conditional or shared")
+}
+
+func TestSharedSDKNoDATAOwnersAreCompleteAndIndependent(t *testing.T) {
+	source, err := os.ReadFile("nodata_go127_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := sharedSDKNoDATAOwners(source); err != nil {
+		t.Fatal(err)
+	}
+	for _, change := range []struct{ old, replacement string }{
+		{"TestSharedSDKNoDATACountText", "NotAnOwner"},
+		{`"indexbyte_amd64.s", "go-module"`, `"count_amd64.s", "go-module"`},
+		{"sdkMinimumOriginalPackage(t,", "cachedFactory(t,"},
+		{"source.Verify(ctx)", "source.Unchecked(ctx)"},
+		{"source.Verify(ctx)", `t.Skip("missing tools")`},
+	} {
+		index := strings.LastIndex(string(source), change.old)
+		if index < 0 {
+			t.Fatal("ownership mutation lost its source target", change.old)
+		}
+		changed := string(source[:index]) + change.replacement + string(source[index+len(change.old):])
+		if err := sharedSDKNoDATAOwners([]byte(changed)); err == nil {
+			t.Fatal("missing or shared original member/API owner was accepted", change.old)
+		}
+	}
+}
diff --git a/internal/sdkfrontend/owners.go b/internal/sdkfrontend/owners.go
new file mode 100644
index 000000000..8e9a1aa34
--- /dev/null
+++ b/internal/sdkfrontend/owners.go
@@ -0,0 +1,135 @@
+package sdkfrontend
+
+import (
+	"context"
+	"errors"
+	"go/types"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type OwnerRequest struct {
+	PackagePath string
+	CPU         bool
+	Variables   []plan9asm.GoNumericalStorageReference
+}
+
+// OwnerRequests is a cost query over actual typed package scopes. It has no
+// numerical type/storage/read grammar: the separate SDK producer authenticates
+// the complete original Go definition, pointer-free type and compiler record.
+// Private assembly data and functions never become Go-defined variables here.
+func OwnerRequests(pkg *Package, file *plan9asm.File, target string) []OwnerRequest {
+	if pkg == nil || pkg.Module || file == nil || file.Arch != plan9asm.ArchAMD64 ||
+		!gostaticstorage.X86SDKTarget(target) {
+		return nil
+	}
+	packages := make(map[string]*Package)
+	var visit func(*Package)
+	visit = func(current *Package) {
+		if current == nil || current.Module || len(packages) >= 256 || packages[current.Path] != nil {
+			return
+		}
+		packages[current.Path] = current
+		for _, dependency := range current.Imports {
+			visit(dependency)
+		}
+	}
+	visit(pkg)
+	requests := make(map[string]*OwnerRequest)
+	variables := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		for _, instruction := range fn.Instrs {
+			for _, operand := range instruction.Args {
+				if operand.Kind != plan9asm.OpSym || !strings.HasSuffix(operand.Sym, "(SB)") {
+					continue
+				}
+				name := strings.TrimSuffix(operand.Sym, "(SB)")
+				if offset := strings.IndexAny(name, "+-"); offset >= 0 {
+					name = name[:offset]
+				}
+				name = Resolve(pkg.Path, name)
+				if strings.ContainsAny(name, "<>") || variables[name] {
+					continue
+				}
+				dot := strings.LastIndexByte(name, '.')
+				if dot < 1 || dot == len(name)-1 {
+					continue
+				}
+				path, symbol := name[:dot], name[dot+1:]
+				cpu := name == "internal/cpu.X86"
+				if !cpu {
+					owner := packages[path]
+					if owner == nil || owner.Types == nil || owner.Types.Path() != path || owner.Types.Scope() == nil {
+						continue
+					}
+					variable, valid := owner.Types.Scope().Lookup(symbol).(*types.Var)
+					if !valid || variable.IsField() || variable.Pkg() != owner.Types {
+						continue
+					}
+				}
+				key := path
+				if cpu {
+					key += "/cpu"
+				}
+				if requests[key] == nil {
+					requests[key] = &OwnerRequest{PackagePath: path, CPU: cpu}
+				}
+				requests[key].Variables = append(requests[key].Variables,
+					plan9asm.GoNumericalStorageReference{PackagePath: path, Name: symbol})
+				variables[name] = true
+			}
+		}
+	}
+	keys := make([]string, 0, len(requests))
+	for key := range requests {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	result := make([]OwnerRequest, 0, len(keys))
+	for _, key := range keys {
+		request := requests[key]
+		sort.Slice(request.Variables, func(i, j int) bool { return request.Variables[i].Name < request.Variables[j].Name })
+		result = append(result, *request)
+	}
+	return result
+}
+
+func NumericalOwnerRequested(pkg *Package, file *plan9asm.File, target string) bool {
+	return len(OwnerRequests(pkg, file, target)) != 0
+}
+
+func captureOwners(ctx context.Context, request CaptureRequest, file *plan9asm.File) (_ []*plan9asm.GoNumericalStorageOwner, _ func() error, result error) {
+	queries := OwnerRequests(request.Package, file, request.Target)
+	if len(queries) == 0 || len(queries) > 8 {
+		return nil, nil, contextError("source lacks a bounded typed SDK variable query")
+	}
+	var owners []*plan9asm.GoNumericalStorageOwner
+	close := func() error {
+		for index := len(owners) - 1; index >= 0; index-- {
+			owners[index].Close()
+		}
+		owners = nil
+		return nil
+	}
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, close())
+		}
+	}()
+	for _, query := range queries {
+		owner, err := plan9asm.CaptureGoNumericalStorageOwner(ctx, plan9asm.GoNumericalStorageCaptureRequest{
+			GoBinary: request.GoBinary, Directory: filepath.Join(request.Root, "src", filepath.FromSlash(query.PackagePath)),
+			PackagePath: query.PackagePath, Target: request.Target, Environment: request.Environment,
+			Variables: query.Variables, SDKCPU: query.CPU, SDKGlobals: !query.CPU,
+		})
+		if err != nil {
+			return nil, nil, err
+		}
+		owners = append(owners, owner)
+	}
+	return owners, close, nil
+}
diff --git a/internal/sdkfrontend/owners_test.go b/internal/sdkfrontend/owners_test.go
new file mode 100644
index 000000000..c87929840
--- /dev/null
+++ b/internal/sdkfrontend/owners_test.go
@@ -0,0 +1,65 @@
+package sdkfrontend
+
+import (
+	"go/token"
+	"go/types"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestSDKVariableOwnerQueryUsesActualTypedScopes(t *testing.T) {
+	primary, imported := types.NewPackage("arbitrary/sdk", "sdk"), types.NewPackage("another/sdk", "sdk")
+	for _, pkg := range []*types.Package{primary, imported} {
+		pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, "mutable", types.NewArray(types.Typ[types.Uint8], 128)))
+		pkg.Scope().Insert(types.NewVar(token.NoPos, pkg, "opaque", types.NewPointer(types.Typ[types.Uint8])))
+		pkg.Scope().Insert(types.NewConst(token.NoPos, pkg, "constant", types.Typ[types.Uint8], nil))
+		pkg.Scope().Insert(types.NewFunc(token.NoPos, pkg, "function", types.NewSignature(nil, nil, nil, false)))
+	}
+	pkg := &Package{Path: primary.Path(), Types: primary, Imports: map[string]*Package{
+		imported.Path(): {Path: imported.Path(), Types: imported},
+	}}
+	file, err := plan9asm.Parse(plan9asm.ArchAMD64, `TEXT ·Probe(SB),4,$0-0
+AESENC ·mutable+16(SB), X0
+AESENC ·mutable(SB), X0
+MOVQ another∕sdk·mutable(SB), AX
+MOVQ ·opaque(SB), AX
+MOVQ ·constant(SB), AX
+CALL ·function(SB)
+MOVOU ·literal<>(SB), X0
+CMPB internal∕cpu·X86+82(SB), $1
+RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	queries := OwnerRequests(pkg, file, "linux/amd64")
+	want := []OwnerRequest{
+		{PackagePath: imported.Path(), Variables: []plan9asm.GoNumericalStorageReference{{PackagePath: imported.Path(), Name: "mutable"}}},
+		{PackagePath: primary.Path(), Variables: []plan9asm.GoNumericalStorageReference{
+			{PackagePath: primary.Path(), Name: "mutable"}, {PackagePath: primary.Path(), Name: "opaque"},
+		}},
+		{PackagePath: "internal/cpu", CPU: true, Variables: []plan9asm.GoNumericalStorageReference{{PackagePath: "internal/cpu", Name: "X86"}}},
+	}
+	if !reflect.DeepEqual(queries, want) {
+		t.Fatalf("typed owner query = %+v, want %+v", queries, want)
+	}
+	// An opaque variable may request the independent observer, but this cost
+	// query supplies no pointer-free, initialized storage or memory authority.
+	pkg.Module = true
+	if len(OwnerRequests(pkg, file, "linux/amd64")) != 0 {
+		t.Fatal("a foreign module borrowed the stock SDK cost route")
+	}
+	pkg.Module = false
+	for _, target := range []string{"linux/386", "darwin/amd64", "windows/386", "windows/amd64"} {
+		if !reflect.DeepEqual(OwnerRequests(pkg, file, target), want) {
+			t.Fatalf("%s cost query lost the original typed SDK variable roles", target)
+		}
+	}
+	for _, target := range []string{"darwin/386", "freebsd/amd64", "linux/arm64", "unknown/amd64"} {
+		if len(OwnerRequests(pkg, file, target)) != 0 {
+			t.Fatalf("%s borrowed an unobserved x86 SDK source role", target)
+		}
+	}
+}
diff --git a/internal/sdkfrontend/package.go b/internal/sdkfrontend/package.go
new file mode 100644
index 000000000..bb7c85ebf
--- /dev/null
+++ b/internal/sdkfrontend/package.go
@@ -0,0 +1,276 @@
+// Package sdkfrontend shares the SDK numerical source handoff between Go
+// package frontends. The package view deliberately has no x/tools dependency:
+// the translator and its source observers continue to support Go 1.20.
+package sdkfrontend
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/types"
+	"path/filepath"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/gotoolprofile"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Package is a comparison view of an actual load, never source authority.
+// Frontends retain the original load and supply a fresh view to each guard.
+type Package struct {
+	ID, Name, Path, Dir                  string
+	GoFiles, CompiledGoFiles, OtherFiles []string
+	Module, Test, IllTyped               bool
+	Errors                               []string
+	Types                                *types.Package
+	Sizes                                types.Sizes
+	Imports                              map[string]*Package
+}
+
+type Selection struct {
+	identity string
+	target   string
+	types    *types.Package
+	sizes    []int64
+	imports  map[string]*types.Package
+	env      []string
+	mode     *string
+	ready    bool
+	graph    map[string]string
+	inputs   map[string]string
+	problem  error
+}
+
+func contextError(message string) error {
+	return fmt.Errorf("%w: SDK numerical %s", plan9asm.ErrProbeNeedsContext, message)
+}
+
+func Identity(pkg *Package) string {
+	if pkg == nil {
+		return ""
+	}
+	canonical := func(files []string) []string {
+		result := append([]string(nil), files...)
+		sort.Strings(result)
+		return result
+	}
+	imports := make(map[string]string, len(pkg.Imports))
+	for path, dependency := range pkg.Imports {
+		if dependency == nil {
+			return ""
+		}
+		imports[path] = dependency.Path
+	}
+	encoded, err := json.Marshal(struct {
+		ID, Name, Path, Dir                  string
+		GoFiles, CompiledGoFiles, OtherFiles []string
+		Module, Test                         bool
+		Imports                              map[string]string
+	}{pkg.ID, pkg.Name, pkg.Path, pkg.Dir, canonical(pkg.GoFiles), canonical(pkg.CompiledGoFiles),
+		canonical(pkg.OtherFiles), pkg.Module, pkg.Test, imports})
+	if err != nil {
+		return ""
+	}
+	return fmt.Sprintf("%x", sha256.Sum256(encoded))
+}
+
+func Sizes(sizes types.Sizes) []int64 {
+	if sizes == nil {
+		return nil
+	}
+	var values []int64
+	for _, kind := range []types.BasicKind{
+		types.UnsafePointer, types.Int8, types.Uint8, types.Int16, types.Uint16,
+		types.Int32, types.Uint32, types.Int64, types.Uint64, types.Int, types.Uint,
+		types.Float32, types.Float64,
+	} {
+		values = append(values, sizes.Sizeof(types.Typ[kind]))
+	}
+	return values
+}
+
+// CaptureSelection belongs at the actual packages.Load boundary. A selection
+// retains the producer's types/environment; it cannot reconstruct a capability.
+func CaptureSelection(pkg *Package, target string, environment []string, mode *string) *Selection {
+	imports := make(map[string]*types.Package, len(pkg.Imports))
+	for path, dependency := range pkg.Imports {
+		if dependency != nil {
+			imports[path] = dependency.Types
+		}
+	}
+	ready := !pkg.Test && len(pkg.CompiledGoFiles) != 0 && reflect.DeepEqual(pkg.GoFiles, pkg.CompiledGoFiles)
+	for _, entry := range environment {
+		if strings.HasPrefix(entry, "GOFLAGS=") && strings.Contains(entry, "-overlay") ||
+			strings.HasPrefix(entry, "GOPACKAGESDRIVER=") && entry != "GOPACKAGESDRIVER=off" {
+			ready = false
+		}
+	}
+	selection := &Selection{identity: Identity(pkg), target: target, types: pkg.Types, sizes: Sizes(pkg.Sizes),
+		imports: imports, env: append([]string(nil), environment...), mode: mode, ready: ready}
+	if !pkg.Module && ready {
+		var err error
+		selection.graph, err = Graph(pkg)
+		if err == nil {
+			selection.inputs, err = GraphHashes(pkg)
+		}
+		selection.ready = err == nil
+		selection.problem = err
+	}
+	return selection
+}
+
+func (selected *Selection) Environment() []string { return append([]string(nil), selected.env...) }
+
+func Check(pkg *Package, selected *Selection, target string) error {
+	if selected != nil && selected.problem != nil {
+		return fmt.Errorf("SDK numerical original load inputs: %w", selected.problem)
+	}
+	if pkg == nil || selected == nil || !selected.ready || selected.types != pkg.Types ||
+		selected.target != target || pkg.Types == nil || pkg.Sizes == nil || pkg.IllTyped || len(pkg.Errors) != 0 ||
+		selected.identity == "" || selected.identity != Identity(pkg) ||
+		!reflect.DeepEqual(selected.sizes, Sizes(pkg.Sizes)) || len(selected.imports) != len(pkg.Imports) {
+		return contextError("actual-load identity changed")
+	}
+	for path, dependency := range pkg.Imports {
+		if dependency == nil || dependency.Types == nil || dependency.Types != selected.imports[path] {
+			return contextError("actual-load dependency types changed")
+		}
+	}
+	if selected.graph != nil {
+		graph, err := Graph(pkg)
+		if err != nil || !reflect.DeepEqual(graph, selected.graph) {
+			return contextError("original complete source/import graph changed")
+		}
+		inputs, err := GraphHashes(pkg)
+		if err != nil || !reflect.DeepEqual(inputs, selected.inputs) {
+			return contextError("original complete selected source bytes changed")
+		}
+	}
+	return nil
+}
+
+func GraphHashes(pkg *Package) (map[string]string, error) {
+	result := make(map[string]string)
+	seen := make(map[*Package]bool)
+	var visit func(*Package) error
+	visit = func(current *Package) error {
+		if current == nil || len(seen) >= 256 {
+			return contextError("source hash graph is incomplete or unbounded")
+		}
+		if seen[current] {
+			return nil
+		}
+		seen[current] = true
+		if current.Path == "unsafe" && current.Types == types.Unsafe && len(current.Imports) == 0 &&
+			len(current.GoFiles)+len(current.CompiledGoFiles)+len(current.OtherFiles) == 0 {
+			return nil // The compiler builtin has no selected source/export files.
+		}
+		inputs, err := SourceHashes(current)
+		if err != nil {
+			return fmt.Errorf("package %s (Go=%d compiled=%d other=%d): %w", current.Path,
+				len(current.GoFiles), len(current.CompiledGoFiles), len(current.OtherFiles), err)
+		}
+		for name, digest := range inputs {
+			if existing, duplicate := result[name]; duplicate && existing != digest {
+				return contextError("source hash graph has conflicting inputs")
+			}
+			result[name] = digest
+		}
+		if len(result) > 8192 {
+			return contextError("complete source hash inventory is unbounded")
+		}
+		for _, dependency := range current.Imports {
+			if err := visit(dependency); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return result, visit(pkg)
+}
+
+func Graph(pkg *Package) (map[string]string, error) {
+	graph := make(map[string]string)
+	var visit func(*Package) error
+	visit = func(current *Package) error {
+		if current == nil || current.IllTyped || len(current.Errors) != 0 || current.Types == nil || current.Module {
+			return contextError("import graph is incomplete or not standard")
+		}
+		identity, err := PhysicalIdentity(current)
+		if err != nil {
+			return err
+		}
+		if existing, seen := graph[current.Path]; seen {
+			if existing != identity {
+				return contextError("import graph has conflicting package identities")
+			}
+			return nil
+		}
+		if len(graph) >= 256 || identity == "" {
+			return contextError("import graph is unbounded")
+		}
+		graph[current.Path] = identity
+		for _, dependency := range current.Imports {
+			if err := visit(dependency); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	return graph, visit(pkg)
+}
+
+// Resolve a comparison projection only. Original source/type snapshots retain
+// their spelling; byte-identical foreign sources cannot borrow SDK identity.
+func PhysicalIdentity(pkg *Package) (string, error) {
+	physical := *pkg
+	var err error
+	physical.Dir, err = sourcepath.Resolve(pkg.Dir)
+	if err != nil {
+		return "", err
+	}
+	for _, files := range []*[]string{&physical.GoFiles, &physical.CompiledGoFiles, &physical.OtherFiles} {
+		resolved := make([]string, len(*files))
+		seen := make(map[string]bool, len(resolved))
+		for index, name := range *files {
+			filename, err := sourcepath.Resolve(name)
+			if err != nil || filepath.Dir(filename) != physical.Dir || seen[filename] {
+				return "", contextError(fmt.Sprintf("selection has a missing, redirected or duplicate source: %v", err))
+			}
+			seen[filename], resolved[index] = true, filename
+		}
+		*files = resolved
+	}
+	return Identity(&physical), nil
+}
+
+func SourceHashes(pkg *Package) (map[string]string, error) {
+	files := append(append([]string(nil), pkg.CompiledGoFiles...), pkg.OtherFiles...)
+	if pkg.Path == "unsafe" && pkg.Types == types.Unsafe && len(pkg.Imports) == 0 && len(files) == 0 {
+		// go/packages retains the builtin's API source but correctly reports
+		// no ordinary compiled Go file. Retain that selected source as input.
+		files = append([]string(nil), pkg.GoFiles...)
+	}
+	if len(files) == 0 || len(files) > 512 {
+		return nil, contextError("selected source inventory is unbounded")
+	}
+	result := make(map[string]string, len(files))
+	for _, name := range files {
+		physical, err := sourcepath.Resolve(name)
+		if err != nil {
+			return nil, err
+		}
+		if _, duplicate := result[physical]; duplicate {
+			return nil, contextError("source hash inventory has duplicate physical files")
+		}
+		digest, err := gotoolprofile.FileSHA256(physical)
+		if err != nil {
+			return nil, err
+		}
+		result[physical] = digest
+	}
+	return result, nil
+}
diff --git a/internal/sdkfrontend/package_test.go b/internal/sdkfrontend/package_test.go
new file mode 100644
index 000000000..784730093
--- /dev/null
+++ b/internal/sdkfrontend/package_test.go
@@ -0,0 +1,122 @@
+package sdkfrontend
+
+import (
+	"context"
+	"errors"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func selectedFixture(t *testing.T, name string) *Package {
+	t.Helper()
+	folder := t.TempDir()
+	file := filepath.Join(folder, "value.go")
+	if err := os.WriteFile(file, []byte("package sample\nvar Value uint64\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return &Package{ID: name, Name: "sample", Path: name, Dir: folder,
+		GoFiles: []string{file}, CompiledGoFiles: []string{file}, Types: types.NewPackage(name, "sample"),
+		Sizes: types.SizesFor("gc", "amd64"), Imports: make(map[string]*Package)}
+}
+
+func TestSelectionRetainsCompleteOriginalSourceAndTypes(t *testing.T) {
+	pkg, dependency := selectedFixture(t, "sample"), selectedFixture(t, "dependency")
+	pkg.Imports[dependency.Path] = dependency
+	selection := CaptureSelection(pkg, "linux/amd64", []string{"GOPACKAGESDRIVER=off"}, nil)
+	if err := Check(pkg, selection, "linux/amd64"); err != nil {
+		t.Fatal(err)
+	}
+	for _, mutate := range []func() func(){
+		func() func() {
+			old := pkg.Types
+			pkg.Types = types.NewPackage(pkg.Path, pkg.Name)
+			return func() { pkg.Types = old }
+		},
+		func() func() {
+			old := dependency.Types
+			dependency.Types = types.NewPackage(dependency.Path, dependency.Name)
+			return func() { dependency.Types = old }
+		},
+		func() func() {
+			old := dependency.CompiledGoFiles
+			dependency.CompiledGoFiles = nil
+			return func() { dependency.CompiledGoFiles = old }
+		},
+		func() func() {
+			file := dependency.GoFiles[0]
+			old, err := os.ReadFile(file)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(file, append(old, '\n'), 0600); err != nil {
+				t.Fatal(err)
+			}
+			return func() {
+				if err := os.WriteFile(file, old, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+		},
+	} {
+		restore := mutate()
+		if err := Check(pkg, selection, "linux/amd64"); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+			t.Fatal("changed original load/source was accepted", err)
+		}
+		restore()
+	}
+}
+
+func TestSDKReloadRequiresBoundedActualLoadContext(t *testing.T) {
+	pkg := selectedFixture(t, "sample")
+	selected := CaptureSelection(pkg, "linux/amd64", nil, nil)
+	loader := func(context.Context, string, []string) (*Package, error) {
+		t.Fatal("unbound or cancelled reload invoked a loader")
+		return nil, nil
+	}
+	cancelled, cancel := context.WithCancel(context.Background())
+	cancel()
+	for _, ctx := range []context.Context{nil, context.Background(), cancelled} {
+		actual, selection, release, err := Reload(ctx, "go", pkg, selected, loader)
+		if actual != nil || selection != nil || release != nil || err == nil {
+			t.Fatalf("invalid context produced a source load: %v", err)
+		}
+		if ctx == cancelled && !errors.Is(err, context.Canceled) {
+			t.Fatal("cancellation became a missing-proof classification", err)
+		}
+	}
+	ctx, stop := context.WithTimeout(context.Background(), time.Minute)
+	defer stop()
+	if _, _, _, err := Reload(ctx, "go", pkg, nil, loader); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatal("missing load selection did not fail before command execution", err)
+	}
+}
+
+func TestSharedSDKSourceClosesInReverseOrderAndRetainsErrors(t *testing.T) {
+	first, second := errors.New("numerical"), errors.New("data")
+	var order []string
+	source := &Source{}
+	source.identity = source
+	for _, row := range []struct {
+		name string
+		err  error
+	}{{"CPU", nil}, {"data", second}, {"literal", nil}, {"numerical", first}} {
+		row := row
+		source.cleanup = append(source.cleanup, func() error {
+			order = append(order, row.name)
+			return row.err
+		})
+	}
+	err := source.Close()
+	if !errors.Is(err, first) || !errors.Is(err, second) || !reflect.DeepEqual(order, []string{"numerical", "literal", "data", "CPU"}) {
+		t.Fatalf("lost owner/close order or authoritative error: %v, %v", order, err)
+	}
+	if err := source.Close(); err != nil || len(order) != 4 {
+		t.Fatal("closed handles were invoked twice", err)
+	}
+}
diff --git a/internal/sdkfrontend/resolve_test.go b/internal/sdkfrontend/resolve_test.go
new file mode 100644
index 000000000..4aac1cac7
--- /dev/null
+++ b/internal/sdkfrontend/resolve_test.go
@@ -0,0 +1,20 @@
+package sdkfrontend
+
+import "testing"
+
+func TestSDKResolverPreservesNativeNamespaceAndLogicalABISelectors(t *testing.T) {
+	for source, want := range map[string]string{
+		"·Value":                     "arbitrary/sdk.Value",
+		"·Value<ABI0>":               "arbitrary/sdk.Value",
+		"·Value<ABIInternal>":        "arbitrary/sdk.Value",
+		"runtime·Value<ABIInternal>": "runtime.Value",
+		"internal∕cpu·X86":           "internal/cpu.X86",
+		"·literal<>":                 "arbitrary/sdk.literal<>",
+		"·literal$local":             "arbitrary/sdk.literal$local",
+		"·Value<ABIUnknown>":         "arbitrary/sdk.Value<ABIUnknown>",
+	} {
+		if actual := Resolve("arbitrary/sdk", source); actual != want {
+			t.Fatalf("Resolve(%q) = %q, want %q", source, actual, want)
+		}
+	}
+}
diff --git a/internal/sdkfrontend/source.go b/internal/sdkfrontend/source.go
new file mode 100644
index 000000000..85e2f9f32
--- /dev/null
+++ b/internal/sdkfrontend/source.go
@@ -0,0 +1,162 @@
+package sdkfrontend
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"strings"
+	"sync"
+
+	"github.com/xgo-dev/plan9asm"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+// Source owns the independently captured whole-file numerical/readonly join.
+// Parsed CPP readback supplies no permission without its live numerical binder.
+type Source struct {
+	Numerical                          *plan9asm.GoX86NumericalReadSource
+	cleanup                            []func() error
+	mu                                 sync.Mutex
+	identity                           *Source
+	context                            context.Context
+	originalNumerical                  *plan9asm.GoX86NumericalReadSource
+	literalOwner, originalLiteralOwner *plan9asm.GoX86SDKReadonlyLiteralDataOwner
+	minimum, originalMinimum           *plan9asm.GoX86SDKLiteralAlignment
+	minimumAttempted                   bool
+	minimumError                       error
+	active, closePending, closed       bool
+}
+
+func Resolve(packagePath, symbol string) string {
+	// The selector chooses a source entry role; LLVM's logical symbol keeps
+	// the independently observed Go declaration name. Private <> is distinct.
+	symbol = strings.TrimSuffix(strings.TrimSuffix(symbol, "<ABIInternal>"), "<ABI0>")
+	symbol = strings.ReplaceAll(strings.ReplaceAll(symbol, "∕", "/"), "·", ".")
+	if strings.HasPrefix(symbol, ".") {
+		return packagePath + symbol
+	}
+	return symbol
+}
+
+// CPUOwnerRequested is only a cost query. The independent storage/source
+// producers authenticate package role, variable layout and every native read.
+func CPUOwnerRequested(pkg *Package, file *plan9asm.File, target string) bool {
+	if pkg == nil || pkg.Module || file == nil || file.Arch != plan9asm.ArchAMD64 ||
+		!gostaticstorage.X86SDKTarget(target) {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		for _, instruction := range fn.Instrs {
+			for _, operand := range instruction.Args {
+				if operand.Kind != plan9asm.OpSym || !strings.HasSuffix(operand.Sym, "(SB)") {
+					continue
+				}
+				name := strings.TrimSuffix(operand.Sym, "(SB)")
+				if offset := strings.IndexAny(name, "+-"); offset >= 0 {
+					name = name[:offset]
+				}
+				if Resolve(pkg.Path, name) == "internal/cpu.X86" {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+type CaptureRequest struct {
+	GoBinary, Root, Directory, PackagePath, AssemblyFile, Target string
+	Environment                                                  []string
+	Package                                                      *Package
+}
+
+func Capture(ctx context.Context, request CaptureRequest, file *plan9asm.File) (_ *plan9asm.File, _ *Source, result error) {
+	directory, err := sourcepath.Resolve(request.Directory)
+	if err != nil {
+		return nil, nil, err
+	}
+	asm, err := sourcepath.Resolve(request.AssemblyFile)
+	if err != nil || filepath.Dir(asm) != directory {
+		return nil, nil, contextError(fmt.Sprintf("assembly origin differs: %v", err))
+	}
+	owners, close, err := captureOwners(ctx, request, file)
+	if err != nil {
+		return nil, nil, err
+	}
+	source := &Source{cleanup: []func() error{close}, context: ctx}
+	source.identity = source
+	defer func() {
+		if result != nil {
+			result = errors.Join(result, source.Close())
+		}
+	}()
+	numerical := plan9asm.GoX86NumericalReadCaptureRequest{
+		GoBinary: request.GoBinary, Directory: directory, PackagePath: request.PackagePath, AssemblyFile: filepath.Base(asm),
+		Target: request.Target, Environment: request.Environment, Owners: owners,
+	}
+	// Observe the complete selected package archive even when this member has
+	// no DATA. Another selected member may define private literals; the core
+	// joins this exact empty member without lending it those literal reads.
+	data, err := plan9asm.CaptureGoX86SDKASMDataSource(ctx, plan9asm.GoX86SDKASMDataCaptureRequest{
+		GoBinary: request.GoBinary, Directory: directory, PackagePath: request.PackagePath, Target: request.Target, Environment: request.Environment,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+	source.cleanup = append(source.cleanup, data.Close)
+	rawData, err := data.Readback(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	var observedData struct {
+		Objects *gostaticstorage.SDKASMDataObservation
+	}
+	if json.Unmarshal(rawData, &observedData) != nil || observedData.Objects == nil {
+		return nil, nil, contextError("complete assembly observation readback differs")
+	}
+	hasData := false
+	for _, member := range observedData.Objects.Sources {
+		hasData = hasData || len(member.ExpandedLayouts) != 0
+	}
+	if hasData {
+		// Presence requests the existing strict initializer producer. Mutable,
+		// malformed or unregistered DATA still fails; it never falls back to
+		// metadata-only observation after an initializer error.
+		literal, err := plan9asm.CaptureGoX86SDKReadonlyLiteralDataOwner(ctx, data)
+		if err != nil {
+			return nil, nil, err
+		}
+		source.cleanup = append(source.cleanup, literal.Close)
+		source.literalOwner, source.originalLiteralOwner = literal, literal
+		numerical.ReadonlyLiterals = literal
+	} else {
+		numerical.AssemblySource = data
+	}
+	source.Numerical, err = plan9asm.CaptureGoX86SDKNumericalReadSource(ctx, numerical)
+	if err != nil {
+		return nil, nil, err
+	}
+	source.cleanup = append(source.cleanup, source.Numerical.Close)
+	source.originalNumerical = source.Numerical
+	raw, err := source.Numerical.Readback(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	var observed struct {
+		CPP plan9asm.AssemblyCPPObservation
+	}
+	if err := json.Unmarshal(raw, &observed); err != nil {
+		return nil, nil, err
+	}
+	actual, err := plan9asm.Parse(plan9asm.ArchAMD64, observed.CPP.Output)
+	if err != nil {
+		return nil, nil, err
+	}
+	if err := source.Verify(ctx); err != nil {
+		return nil, nil, err
+	}
+	return actual, source, nil
+}
diff --git a/internal/sdkfrontend/workspace_test.go b/internal/sdkfrontend/workspace_test.go
new file mode 100644
index 000000000..8152acf70
--- /dev/null
+++ b/internal/sdkfrontend/workspace_test.go
@@ -0,0 +1,68 @@
+package sdkfrontend
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm"
+)
+
+func TestOwnedSDKReloadWorkspaceRejectsEqualMetadataReplacement(t *testing.T) {
+	parent := t.TempDir()
+	owned, release, err := newReloadWorkspace(parent)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stamp := time.Unix(1700000000, 0)
+	populate := func(directory string) {
+		t.Helper()
+		if err := os.WriteFile(filepath.Join(directory, "retained.txt"), []byte("identical bytes\n"), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.Chtimes(directory, stamp, stamp); err != nil {
+			t.Fatal(err)
+		}
+	}
+	populate(owned)
+	retained := owned + ".retained"
+	// Deliberately do not call SameFile before replacement. Such a call fills
+	// os.Lstat's lazy Windows file ID and conceals the old cleanup defect.
+	if err := os.Rename(owned, retained); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Mkdir(owned, 0700); err != nil {
+		t.Fatal(err)
+	}
+	populate(owned)
+	if err := release(); !errors.Is(err, plan9asm.ErrProbeNeedsContext) {
+		t.Fatalf("equal-metadata replacement acquired the owned cleanup role: %v", err)
+	}
+	for _, directory := range []string{retained, owned} {
+		actual, err := os.ReadFile(filepath.Join(directory, "retained.txt"))
+		if err != nil || string(actual) != "identical bytes\n" {
+			t.Fatalf("rejected cleanup removed original/replacement contents: %q: %v", directory, err)
+		}
+	}
+}
+
+func TestOwnedSDKReloadWorkspaceReleasesOnlyItsOwnDirectory(t *testing.T) {
+	owned, release, err := newReloadWorkspace(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(owned, "owned.txt"), []byte("owned\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if err := release(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(owned); !os.IsNotExist(err) {
+		t.Fatal("owned workspace survived successful cleanup", err)
+	}
+	if err := release(); err != nil {
+		t.Fatal("successful cleanup was not idempotent", err)
+	}
+}
diff --git a/internal/sourcepath/cpp.go b/internal/sourcepath/cpp.go
new file mode 100644
index 000000000..63e4eee38
--- /dev/null
+++ b/internal/sourcepath/cpp.go
@@ -0,0 +1,41 @@
+package sourcepath
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+	"strings"
+)
+
+// CPPLocalSource describes a canonical slash-separated source name. It grants
+// no source, tool or include authority to the path or its physical contents.
+func CPPLocalSource(file string) bool {
+	return file != "" && file != "." && !path.IsAbs(file) && path.Clean(file) == file &&
+		file != ".." && !strings.HasPrefix(file, "../") && !strings.ContainsAny(file, ":\\\x00\r\n")
+}
+
+// CPPRegularSource binds a bounded canonical file within an actual origin.
+// Parent/file symlinks cannot redirect a selected SDK or module include.
+func CPPRegularSource(root, file string) (string, error) {
+	if !filepath.IsAbs(root) || !CPPLocalSource(file) {
+		return "", fmt.Errorf("unsafe exact CPP source identity")
+	}
+	resolvedRoot, err := Resolve(root)
+	if err != nil {
+		return "", err
+	}
+	name := filepath.Join(resolvedRoot, filepath.FromSlash(file))
+	resolved, err := Resolve(name)
+	if err != nil {
+		return "", fmt.Errorf("CPP source is missing: %s: %w", file, err)
+	}
+	if resolved != name {
+		return "", fmt.Errorf("CPP source is redirected: %s", file)
+	}
+	info, err := os.Lstat(name)
+	if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+		return "", fmt.Errorf("CPP source must be a bounded regular file: %s", file)
+	}
+	return name, nil
+}
diff --git a/internal/sourcepath/lstat_other.go b/internal/sourcepath/lstat_other.go
new file mode 100644
index 000000000..3e729faa7
--- /dev/null
+++ b/internal/sourcepath/lstat_other.go
@@ -0,0 +1,12 @@
+//go:build !windows
+
+package sourcepath
+
+import "os"
+
+// Lstat captures file identity immediately, without following a final symlink.
+// Unlike os.Lstat on Windows, its FileInfo never reopens the original path
+// later when os.SameFile is called.
+func Lstat(name string) (os.FileInfo, error) {
+	return os.Lstat(name)
+}
diff --git a/internal/sourcepath/lstat_test.go b/internal/sourcepath/lstat_test.go
new file mode 100644
index 000000000..7eeb958a8
--- /dev/null
+++ b/internal/sourcepath/lstat_test.go
@@ -0,0 +1,56 @@
+package sourcepath
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestLstatRetainsIdentityAfterReplacement(t *testing.T) {
+	for _, directory := range []bool{false, true} {
+		name := "file"
+		if directory {
+			name = "directory"
+		}
+		t.Run(name, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), name)
+			stamp := time.Unix(1700000000, 0)
+			create := func() {
+				t.Helper()
+				var err error
+				if directory {
+					err = os.Mkdir(path, 0700)
+				} else {
+					err = os.WriteFile(path, []byte("identical bytes\n"), 0600)
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.Chtimes(path, stamp, stamp); err != nil {
+					t.Fatal(err)
+				}
+			}
+			create()
+			before, err := Lstat(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Do not call SameFile before replacing: that would eagerly fill
+			// os.Lstat's lazy ID and conceal the Windows regression.
+			retained := path + ".retained"
+			if err := os.Rename(path, retained); err != nil {
+				t.Fatal(err)
+			}
+			create()
+			replacement, err := Lstat(path)
+			if err != nil || os.SameFile(before, replacement) {
+				t.Fatalf("replacement inherited the reserved identity: %v", err)
+			}
+			original, err := Lstat(retained)
+			if err != nil || !os.SameFile(before, original) {
+				t.Fatalf("renamed original lost its captured identity: %v", err)
+			}
+		})
+	}
+}
diff --git a/internal/sourcepath/lstat_windows.go b/internal/sourcepath/lstat_windows.go
new file mode 100644
index 000000000..86c940239
--- /dev/null
+++ b/internal/sourcepath/lstat_windows.go
@@ -0,0 +1,35 @@
+//go:build windows
+
+package sourcepath
+
+import (
+	"errors"
+	"os"
+
+	"golang.org/x/sys/windows"
+)
+
+// Lstat captures identity from an open handle. os.Lstat defers reading the
+// Windows file ID until os.SameFile, which can then observe a replacement at
+// the same path. OPEN_REPARSE_POINT preserves the final symlink's own identity.
+func Lstat(name string) (info os.FileInfo, resultErr error) {
+	path, err := windows.UTF16PtrFromString(name)
+	if err != nil {
+		return nil, &os.PathError{Op: "lstat identity", Path: name, Err: err}
+	}
+	handle, err := windows.CreateFile(path, 0,
+		windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+		nil, windows.OPEN_EXISTING,
+		windows.FILE_FLAG_BACKUP_SEMANTICS|windows.FILE_FLAG_OPEN_REPARSE_POINT, 0)
+	if err != nil {
+		return nil, &os.PathError{Op: "lstat identity", Path: name, Err: err}
+	}
+	file := os.NewFile(uintptr(handle), name)
+	defer func() {
+		resultErr = errors.Join(resultErr, file.Close())
+		if resultErr != nil {
+			info = nil
+		}
+	}()
+	return file.Stat()
+}
diff --git a/internal/sourcepath/path_other.go b/internal/sourcepath/path_other.go
new file mode 100644
index 000000000..2b03958b7
--- /dev/null
+++ b/internal/sourcepath/path_other.go
@@ -0,0 +1,11 @@
+//go:build !windows
+
+// Package sourcepath resolves filesystem paths used for source/tool identity.
+// Resolution alone does not establish containment, ownership or a stable lease.
+package sourcepath
+
+import "path/filepath"
+
+func Resolve(name string) (string, error) {
+	return filepath.EvalSymlinks(name)
+}
diff --git a/internal/sourcepath/path_test.go b/internal/sourcepath/path_test.go
new file mode 100644
index 000000000..139a6c2e9
--- /dev/null
+++ b/internal/sourcepath/path_test.go
@@ -0,0 +1,35 @@
+package sourcepath
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveActualSourceAndMissingPaths(t *testing.T) {
+	root := t.TempDir()
+	file := filepath.Join(root, "source.s")
+	if err := os.WriteFile(file, []byte("source"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(root, "alias.s")
+	if err := os.Symlink(file, alias); err != nil {
+		t.Fatal(err)
+	}
+	resolved, err := Resolve(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if actual, err := Resolve(alias); err != nil || actual != resolved {
+		t.Fatalf("actual symlink identity differs: got=%q want=%q error=%v", actual, resolved, err)
+	}
+	if err := os.Remove(file); err != nil {
+		t.Fatal(err)
+	}
+	for _, missing := range []string{file, alias, filepath.Join(root, "missing", "child")} {
+		if actual, err := Resolve(missing); actual != "" || !errors.Is(err, os.ErrNotExist) {
+			t.Fatalf("missing/broken path was accepted or lost its cause: path=%q resolved=%q error=%v", missing, actual, err)
+		}
+	}
+}
diff --git a/internal/sourcepath/path_windows.go b/internal/sourcepath/path_windows.go
new file mode 100644
index 000000000..3d5fb90f7
--- /dev/null
+++ b/internal/sourcepath/path_windows.go
@@ -0,0 +1,80 @@
+//go:build windows
+
+package sourcepath
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/sys/windows"
+)
+
+// Resolve uses the actual opened file identity, including directory junctions.
+// Go 1.23 changed os.FileMode for junctions: EvalSymlinks may leave the alias
+// unchanged or fail at a descendant. Neither result binds a physical source.
+// This does not change process-wide GODEBUG settings or trust a lexical path
+// merely because Stat succeeds. Callers still own containment and live guards.
+func Resolve(name string) (resolved string, resultErr error) {
+	file, err := os.Open(name)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		resultErr = errors.Join(resultErr, file.Close())
+		if resultErr != nil {
+			resolved = ""
+		}
+	}()
+	info, err := file.Stat()
+	if err != nil {
+		return "", err
+	}
+	buffer := make([]uint16, 512)
+	for len(buffer) <= 32768 {
+		// FILE_NAME_NORMALIZED | VOLUME_NAME_DOS, both zero. Unknown,
+		// unavailable or inaccessible native routes are errors, not fallbacks.
+		n, err := windows.GetFinalPathNameByHandle(windows.Handle(file.Fd()), &buffer[0], uint32(len(buffer)), 0)
+		if err != nil {
+			return "", &os.PathError{Op: "resolve final source path", Path: name, Err: err}
+		}
+		if n >= uint32(len(buffer)) {
+			if n >= 32768 {
+				break
+			}
+			buffer = make([]uint16, n+1)
+			continue
+		}
+		resolved, err = windowsDOSPath(windows.UTF16ToString(buffer[:n]))
+		if err != nil {
+			return "", err
+		}
+		reopened, err := os.Stat(resolved)
+		if err != nil {
+			return "", err
+		}
+		if !os.SameFile(info, reopened) {
+			return "", fmt.Errorf("resolved source path changed its opened file identity")
+		}
+		return resolved, nil
+	}
+	return "", fmt.Errorf("resolved source path exceeds the Windows UTF-16 path bound")
+}
+
+func windowsDOSPath(name string) (string, error) {
+	switch {
+	case strings.HasPrefix(name, `\\?\UNC\`):
+		name = `\\` + strings.TrimPrefix(name, `\\?\UNC\`)
+	case strings.HasPrefix(name, `\\?\`) && len(name) >= 7 && name[5:7] == `:\` &&
+		(name[4] >= 'A' && name[4] <= 'Z' || name[4] >= 'a' && name[4] <= 'z'):
+		name = name[4:]
+	default:
+		return "", fmt.Errorf("resolved source has no normalized Windows DOS or UNC path")
+	}
+	if !filepath.IsAbs(name) || strings.ContainsAny(name, "\x00\r\n") || filepath.Clean(name) != name {
+		return "", fmt.Errorf("resolved source path is not canonical")
+	}
+	return name, nil
+}
diff --git a/internal/sourcepath/path_windows_test.go b/internal/sourcepath/path_windows_test.go
new file mode 100644
index 000000000..0fa1babd2
--- /dev/null
+++ b/internal/sourcepath/path_windows_test.go
@@ -0,0 +1,122 @@
+//go:build windows
+
+package sourcepath
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestResolveWindowsJunctionIdentity(t *testing.T) {
+	root := t.TempDir()
+	actual := filepath.Join(root, "actual")
+	child := filepath.Join(actual, "nested")
+	if err := os.MkdirAll(child, 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(child, "source.s"), []byte("TEXT ·Probe(SB),$0-0\nRET\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	alias := filepath.Join(root, "alias")
+	ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, "cmd", "/c", "mklink", "/J", alias, actual)
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("create required native directory junction: %v\n%s", err, output)
+	}
+	linkInfo, err := Lstat(alias)
+	if err != nil {
+		t.Fatal(err)
+	}
+	targetInfo, err := Lstat(actual)
+	if err != nil || os.SameFile(linkInfo, targetInfo) {
+		t.Fatalf("identity capture followed the final junction: %v", err)
+	}
+	for _, mode := range []string{"0", "1"} {
+		t.Run("winsymlink="+mode, func(t *testing.T) {
+			t.Setenv("GODEBUG", "winsymlink="+mode+",winreadlinkvolume=1")
+			for _, suffix := range []string{".", "nested", "nested/source.s"} {
+				t.Run(suffix, func(t *testing.T) {
+					want, err := Resolve(filepath.Join(actual, filepath.FromSlash(suffix)))
+					if err != nil {
+						t.Fatal(err)
+					}
+					got, err := Resolve(filepath.Join(alias, filepath.FromSlash(suffix)))
+					if err != nil || got != want || !filepath.IsAbs(got) {
+						t.Fatalf("junction identity differs: got=%q want=%q error=%v", got, want, err)
+					}
+					before, err := os.Stat(filepath.Join(alias, filepath.FromSlash(suffix)))
+					if err != nil {
+						t.Fatal(err)
+					}
+					after, err := os.Stat(got)
+					if err != nil || !os.SameFile(before, after) {
+						t.Fatalf("resolved a different actual file: %v", err)
+					}
+				})
+			}
+			if _, err := Resolve(filepath.Join(alias, "missing")); !errors.Is(err, os.ErrNotExist) {
+				t.Fatalf("missing junction descendant lost its actual cause: %v", err)
+			}
+		})
+	}
+}
+
+func TestResolveWindowsLongPathAndHandleRelease(t *testing.T) {
+	root := t.TempDir()
+	name := filepath.Join(root, strings.Repeat("long-", 35), "child", "source.s")
+	if err := os.MkdirAll(filepath.Dir(name), 0700); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(name, []byte("source"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for i := 0; i < 16; i++ {
+		if _, err := Lstat(name); err != nil {
+			t.Fatal("long-path identity capture", err)
+		}
+		resolved, err := Resolve(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		data, err := os.ReadFile(resolved)
+		if err != nil || string(data) != "source" {
+			t.Fatalf("long resolved path cannot reopen its source: %v", err)
+		}
+	}
+	// Rename and remove immediately: resolution must not retain an open file.
+	renamed := name + ".renamed"
+	if err := os.Rename(name, renamed); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Remove(renamed); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestWindowsDOSPathRetainsOnlyNativeAbsoluteRoutes(t *testing.T) {
+	for native, want := range map[string]string{
+		`\\?\C:\source\file.s`:        `C:\source\file.s`,
+		`\\?\C:\`:                     `C:\`,
+		`\\?\UNC\server\share\file.s`: `\\server\share\file.s`,
+	} {
+		if got, err := windowsDOSPath(native); err != nil || got != want {
+			t.Fatalf("normalized native route %q: got=%q want=%q error=%v", native, got, want, err)
+		}
+	}
+	for _, native := range []string{
+		"", `C:\source`, `\\.\C:\source`, `\\?\C:source`,
+		`\\?\Volume{unbound}\source`, `\\?\C:\source\..\file.s`,
+		"\\\\?\\C:\\source\x00hidden", "\\\\?\\C:\\source\nline",
+	} {
+		if got, err := windowsDOSPath(native); err == nil || got != "" {
+			t.Fatalf("unknown/noncanonical native route accepted: %q => %q (%v)", native, got, err)
+		}
+	}
+}
diff --git a/llvm22_separate_lld_test.go b/llvm22_separate_lld_test.go
new file mode 100644
index 000000000..cb8f8d7c5
--- /dev/null
+++ b/llvm22_separate_lld_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestLLVM22RequiredSeparateWasmLinker(t *testing.T) {
+	if path := findLLVM22Tool("wasm-ld"); path == "" {
+		t.Fatal("required LLVM 22 wasm linker was not found; LLD may be packaged separately from LLVM_CONFIG")
+	}
+}
+
+func TestLLVM22ConfiguredCompilersCannotFallbackToAnotherInstallation(t *testing.T) {
+	bindir := filepath.Join(t.TempDir(), "configured-llvm22", "bin")
+	for _, name := range []string{"llc", "clang", "clang++", "llvm-mc", "llvm-objdump", "opt"} {
+		t.Run(name, func(t *testing.T) {
+			if actual := llvm22ToolCandidates(name, bindir); !reflect.DeepEqual(actual, []string{filepath.Join(bindir, name)}) {
+				t.Fatalf("configured compiler acquired a fallback: %v", actual)
+			}
+		})
+	}
+}
+
+func TestLLVM22SeparateLinkerCandidatesRetainExactVersion(t *testing.T) {
+	bindir := filepath.Join(t.TempDir(), "configured-llvm22", "bin")
+	for _, name := range []string{"wasm-ld", "ld.lld", "ld64.lld", "lld-link"} {
+		t.Run(name, func(t *testing.T) {
+			want := []string{
+				filepath.Join(bindir, name), name + "-22", name,
+				filepath.Join("/opt/homebrew/opt/lld@22/bin", name),
+				filepath.Join("/usr/local/opt/lld@22/bin", name),
+			}
+			if actual := llvm22ToolCandidates(name, bindir); !reflect.DeepEqual(actual, want) {
+				t.Fatalf("separate LLD candidate policy changed: %v", actual)
+			}
+		})
+	}
+}
+
+func TestLLVM22VersionMatchingRejectsOtherMajors(t *testing.T) {
+	for _, test := range []struct {
+		version string
+		valid   bool
+	}{
+		{"Homebrew LLD 22.1.8\n", true},
+		{"Debian LLVM version 22.1.8\n", true},
+		{"clang version 22.1.8\n", true},
+		{"LLD 21.1.8\n", false},
+		{"LLD 23.0.0\n", false},
+		{"LLD 220.1.0\n", false},
+		{"LLVM version 23.0.0\n", false},
+		{"clang version 21.1.0\n", false},
+	} {
+		t.Run(test.version, func(t *testing.T) {
+			if llvm22ToolVersionRE.MatchString(test.version) != test.valid {
+				t.Fatalf("major version matching changed: %q", test.version)
+			}
+		})
+	}
+}
diff --git a/llvm_ir_memory_test.go b/llvm_ir_memory_test.go
new file mode 100644
index 000000000..c5309b8bb
--- /dev/null
+++ b/llvm_ir_memory_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestLLVMIRMemoryBufferExactBytes(t *testing.T) {
+	for _, text := range []string{"", "prefix\x00suffix", "UTF-8: λ\n", strings.Repeat("abcdef\n", 16384)} {
+		buffer := llvmIRMemoryBuffer(text)
+		if buffer.IsNil() {
+			t.Fatal("LLVM returned an absent memory buffer")
+		}
+		actual := buffer.Bytes()
+		buffer.Dispose() // This buffer was inspected, not consumed by ParseIR.
+		if !bytes.Equal(actual, []byte(text)) {
+			t.Fatalf("IR buffer byte mismatch: got %d bytes, want %d", len(actual), len(text))
+		}
+	}
+}
+
+func unavailableIRTemporaryDirectory(t *testing.T) {
+	t.Helper()
+	missing := filepath.Join(t.TempDir(), "absent")
+	for _, variable := range []string{"TMPDIR", "TMP", "TEMP"} {
+		t.Setenv(variable, missing)
+	}
+	if filepath.Clean(os.TempDir()) != missing {
+		t.Fatalf("temporary directory selection differs: %q", os.TempDir())
+	}
+	if _, err := os.Stat(missing); !os.IsNotExist(err) {
+		t.Fatalf("temporary directory must remain absent: %v", err)
+	}
+}
+
+func TestLLVMIRParsingWithoutTemporaryDirectory(t *testing.T) {
+	unavailableIRTemporaryDirectory(t)
+	context := llvm.NewContext()
+	defer context.Dispose()
+	const valid = "define i32 @answer() { ret i32 7 }\n"
+	for iteration := 0; iteration < 8; iteration++ {
+		module, err := parseIRModuleInContext(context, valid)
+		if err != nil {
+			t.Fatal("valid in-memory IR must not require a temporary file", err)
+		}
+		if module.Context() != context || module.NamedFunction("answer").IsNil() {
+			module.Dispose()
+			t.Fatal("IR parsing lost its function or caller-owned context")
+		}
+		verifyErr := llvm.VerifyModule(module, llvm.ReturnStatusAction)
+		module.Dispose()
+		if verifyErr != nil {
+			t.Fatal(verifyErr)
+		}
+
+		module, err = parseIRModuleInContext(context, "define i32 @broken() {")
+		if !module.IsNil() {
+			module.Dispose()
+			t.Fatal("failed parsing returned a partial module")
+		}
+		if err == nil || !strings.Contains(err.Error(), "parse generated ir:") {
+			t.Fatalf("malformed IR must retain the LLVM parser diagnostic: %v", err)
+		}
+	}
+}
+
+func TestTranslateAPIsWithoutTemporaryDirectory(t *testing.T) {
+	const source = "TEXT ·nop(SB),4,$0-0\nPXOR X0,X0\nPXOR X1,X1\nPADDD X0,X1\nRET\n"
+	packageDeclarations := mustGoPackage(t, "memoryir", "package memoryir\nfunc nop()\n")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		Sigs:       map[string]FuncSig{"nop": {Name: "nop", Ret: Void}}}
+	unavailableIRTemporaryDirectory(t)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			if api == "text" {
+				text, err := Translate(file, options)
+				if err != nil || !strings.Contains(text, "@nop(") {
+					t.Fatalf("text translation failed without temporary storage: %v", err)
+				}
+				return
+			}
+			var module llvm.Module
+			if api == "module" {
+				module, err = TranslateModuleInContext(context, file, options)
+			} else {
+				result, translateErr := TranslateGoModuleInContext(context, packageDeclarations, []byte(source),
+					GoModuleOptions{GOARCH: "amd64", TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym})
+				err = translateErr
+				if result != nil {
+					module = result.Module
+				}
+			}
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil || module.IsNil() {
+				t.Fatalf("module translation failed without temporary storage: %v", err)
+			}
+			if module.Context() != context || module.NamedFunction("nop").IsNil() {
+				t.Fatal("translation lost its function or caller-owned context")
+			}
+			if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/llvm_ir_module_identity_test.go b/llvm_ir_module_identity_test.go
new file mode 100644
index 000000000..96b88f10e
--- /dev/null
+++ b/llvm_ir_module_identity_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestLLVMIRParsingRetainsDistinctModuleIdentity(t *testing.T) {
+	const body = `@cell = private global i32 7
+define i32 @read_cell() {
+  %value = load volatile i32, ptr @cell
+  ret i32 %value
+}
+`
+	for _, test := range []struct {
+		name   string
+		header string
+	}{
+		{"default", ""},
+		{"explicit", "source_filename = \"original-observer.s\"\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			context := llvm.NewContext()
+			defer context.Dispose()
+			first, err := parseIRModuleInContext(context, test.header+body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer first.Dispose()
+			second, err := parseIRModuleInContext(context, test.header+body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer second.Dispose()
+			for _, module := range []llvm.Module{first, second} {
+				if module.Context() != context || module.NamedFunction("read_cell").IsNil() {
+					t.Fatal("module lost its caller context or private-global reader")
+				}
+				cell := module.NamedGlobal("cell")
+				if cell.IsNil() || cell.Linkage() != llvm.PrivateLinkage {
+					t.Fatal("module lost its actual private global")
+				}
+				if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+					t.Fatal(err)
+				}
+			}
+			field := func(module llvm.Module, prefix string) string {
+				for _, line := range strings.Split(module.String(), "\n") {
+					if strings.HasPrefix(line, prefix) {
+						value := strings.TrimSpace(strings.TrimPrefix(line, prefix))
+						if value == "" || value == "''" || value == "\"\"" {
+							t.Fatalf("module has an empty %s", prefix)
+						}
+						return value
+					}
+				}
+				t.Fatalf("module lacks %s", prefix)
+				return ""
+			}
+			firstID, secondID := field(first, "; ModuleID = "), field(second, "; ModuleID = ")
+			if firstID == secondID {
+				t.Errorf("separately parsed modules reused ModuleID %s", firstID)
+			}
+			firstSource, secondSource := field(first, "source_filename = "), field(second, "source_filename = ")
+			if test.header == "" {
+				if firstSource == secondSource {
+					t.Errorf("separately parsed modules reused default source_filename %s", firstSource)
+				}
+			} else if firstSource != "\"original-observer.s\"" || secondSource != firstSource {
+				t.Errorf("explicit source_filename changed: %s, %s", firstSource, secondSource)
+			}
+		})
+	}
+}
diff --git a/llvm_module_assembly.go b/llvm_module_assembly.go
new file mode 100644
index 000000000..5fa5b99da
--- /dev/null
+++ b/llvm_module_assembly.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+/*
+#include <stddef.h>
+#include <stdlib.h>
+typedef struct LLVMOpaqueModule *LLVMModuleRef;
+typedef struct LLVMOpaqueValue *LLVMValueRef;
+typedef struct LLVMOpaqueType *LLVMTypeRef;
+typedef struct LLVMOpaqueContext *LLVMContextRef;
+typedef struct LLVMOpaqueMemoryBuffer *LLVMMemoryBufferRef;
+extern const char *LLVMGetModuleInlineAsm(LLVMModuleRef M, size_t *Len);
+extern LLVMValueRef LLVMIsAAtomicCmpXchgInst(LLVMValueRef Val);
+extern LLVMValueRef LLVMIsAAtomicRMWInst(LLVMValueRef Val);
+extern unsigned LLVMGetNumArgOperands(LLVMValueRef Instr);
+extern LLVMTypeRef LLVMInt8TypeInContext(LLVMContextRef C);
+extern LLVMTypeRef LLVMScalableVectorType(LLVMTypeRef ElementType, unsigned ElementCount);
+extern int LLVMGetTypeKind(LLVMTypeRef Ty);
+extern char *LLVMNormalizeTargetTriple(const char *Triple);
+extern void LLVMDisposeMessage(char *Message);
+extern LLVMMemoryBufferRef LLVMCreateMemoryBufferWithMemoryRangeCopy(const char *InputData, size_t InputDataLength, const char *BufferName);
+
+static void plan9asmIRMemoryBuffer(const char *Text, size_t Length, const char *Name, LLVMMemoryBufferRef *Out) {
+    *Out = LLVMCreateMemoryBufferWithMemoryRangeCopy(Text, Length, Name);
+}
+*/
+import "C"
+
+import (
+	"os"
+	"strconv"
+	"sync/atomic"
+	"time"
+	"unsafe"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Preserve independent default module/source identities without creating files.
+// The process prefix is observed once; parsing only increments the sequence.
+var llvmIRBufferPrefix = "plan9asm-" + strconv.Itoa(os.Getpid()) + "-" +
+	strconv.FormatInt(time.Now().UnixNano(), 36) + "-"
+
+var llvmIRBufferSequence atomic.Uint64
+
+// The pinned binding only constructs IR buffers from files or stdin. LLVM22's
+// copying constructor keeps the exact byte length, including embedded NULs.
+// The caller owns this buffer until ParseIR consumes it, even on parse failure.
+func llvmIRMemoryBuffer(text string) llvm.MemoryBuffer {
+	input := C.CString(text)
+	defer C.free(unsafe.Pointer(input))
+	name := C.CString(llvmIRBufferPrefix + strconv.FormatUint(llvmIRBufferSequence.Add(1), 36) + ".ll")
+	defer C.free(unsafe.Pointer(name))
+	var buffer llvm.MemoryBuffer
+	C.plan9asmIRMemoryBuffer(input, C.size_t(len(text)), name,
+		(*C.LLVMMemoryBufferRef)(unsafe.Pointer(&buffer.C)))
+	return buffer
+}
+
+// LLVM22 llvm-c/Core.h exposes LLVMGetModuleInlineAsm, but llvm v0.10.1
+// only binds its setter. Replace this length-only bridge with the official
+// getter when available; no assembly text needs copying or interpretation.
+func llvmModuleHasAssembly(module llvm.Module) bool {
+	var length C.size_t
+	C.LLVMGetModuleInlineAsm(C.LLVMModuleRef(unsafe.Pointer(module.C)), &length)
+	return length != 0
+}
+
+// The pinned Go binding omits these LLVM22 instruction-class queries.
+func llvmInstructionIsAtomicMemory(instruction llvm.Value) bool {
+	value := C.LLVMValueRef(unsafe.Pointer(instruction.C))
+	return C.LLVMIsAAtomicCmpXchgInst(value) != nil || C.LLVMIsAAtomicRMWInst(value) != nil
+}
+
+func llvmCallArgumentCount(instruction llvm.Value) int {
+	return int(C.LLVMGetNumArgOperands(C.LLVMValueRef(unsafe.Pointer(instruction.C))))
+}
+
+// Obtain the missing binding enum from an actual LLVM22 scalable type. The
+// existing module context owns this uniqued type; no context is allocated or
+// retained. This avoids a copied enum and platform-specific header search paths.
+func llvmScalableVectorKind(context llvm.Context) llvm.TypeKind {
+	owner := C.LLVMContextRef(unsafe.Pointer(context.C))
+	typ := C.LLVMScalableVectorType(C.LLVMInt8TypeInContext(owner), 1)
+	return llvm.TypeKind(C.LLVMGetTypeKind(typ))
+}
+
+// LLVM22 exposes this normalizer in llvm-c/TargetMachine.h. The official
+// llvm v0.10.1 binding does not expose it, so keep ownership in this small
+// C API bridge until that binding supplies the query.
+func llvmNormalizedTargetTriple(triple string) string {
+	if triple == "" {
+		return ""
+	}
+	input := C.CString(triple)
+	defer C.free(unsafe.Pointer(input))
+	normalized := C.LLVMNormalizeTargetTriple(input)
+	defer C.LLVMDisposeMessage(normalized)
+	return C.GoString(normalized)
+}
diff --git a/llvm_object_lifecycle_test.go b/llvm_object_lifecycle_test.go
new file mode 100644
index 000000000..d5d86d28e
--- /dev/null
+++ b/llvm_object_lifecycle_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func TestLLVMObjectHelperRetainsIndependentStageContexts(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "stdlib_arm64_test_helpers_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"testGoEnv", "compileLLVMToObject"} {
+		t.Run(name, func(t *testing.T) {
+			var function *ast.FuncDecl
+			for _, decl := range file.Decls {
+				if candidate, ok := decl.(*ast.FuncDecl); ok && candidate.Name.Name == name {
+					function = candidate
+				}
+			}
+			if function == nil {
+				t.Fatal("bounded object helper missing")
+			}
+			contexts, commands, consumers, cancellations := 0, 0, 0, 0
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				if ident, ok := call.Fun.(*ast.Ident); ok {
+					switch ident.Name {
+					case "runtimeOracleStageContext":
+						contexts++
+					case "runtimeOracleCombinedOutput":
+						consumers++
+					case "cancel":
+						cancellations++
+					}
+				}
+				if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+					if receiver, ok := method.X.(*ast.Ident); ok && receiver.Name == "exec" {
+						if method.Sel.Name != "CommandContext" {
+							t.Errorf("helper lost its stage context: exec.%s", method.Sel.Name)
+						}
+						commands++
+					}
+				}
+				return true
+			})
+			if contexts != 1 || commands != 1 || consumers != 1 || cancellations != 1 {
+				t.Fatalf("independent stage lifecycle required: context=%d command=%d consumer=%d cancel=%d",
+					contexts, commands, consumers, cancellations)
+			}
+		})
+	}
+}
+
+func TestLLVMObjectHelperActualLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	const ir = "define i32 @bounded_object(i32 %x) { %r = add i32 %x, 7 ret i32 %r }\n"
+	for _, triple := range []string{
+		"i386-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf",
+		"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			compileLLVMToObject(t, llc, triple, "bounded.ll", "bounded.o", ir)
+		})
+	}
+}
+
+func TestLLVMObjectHelperActualGoEnv(t *testing.T) {
+	value, err := testGoEnv(t, "GOROOT")
+	if err != nil || value == "" {
+		t.Fatalf("actual go env failed: %v\n%s", err, value)
+	}
+	if info, err := os.Stat(value); err != nil || !info.IsDir() {
+		t.Fatalf("actual GOROOT is not a directory: %q: %v", value, err)
+	}
+}
+
+func TestLLVMObjectHelperGoEnvRetainsActualExitAndOutput(t *testing.T) {
+	output, err := testGoEnv(t, "-definitely-not-a-valid-go-flag")
+	var exit *exec.ExitError
+	if !errors.As(err, &exit) || exit.ExitCode() != 2 || !strings.Contains(output, "flag provided but not defined: -definitely-not-a-valid-go-flag") {
+		t.Fatalf("actual go env exit/output was lost: %v\n%s", err, output)
+	}
+}
diff --git a/llvm_object_lifecycle_unix_test.go b/llvm_object_lifecycle_unix_test.go
new file mode 100644
index 000000000..8e9b7213d
--- /dev/null
+++ b/llvm_object_lifecycle_unix_test.go
@@ -0,0 +1,96 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLLVMObjectHelperDeadlineFixture(t *testing.T) {
+	mode := os.Getenv("PLAN9ASM_OBJECT_HELPER_FIXTURE")
+	if mode == "" {
+		return
+	}
+	// The helper's five-second test deadline leaves two seconds before its
+	// cleanup reserve. Do not spend that window starting two more copies of
+	// the large LLVM-linked test binary just to hold an output pipe.
+	// This failure-only shim creates one real pipe-holding child; it never
+	// emits an object or impersonates successful Go/LLVM output.
+	sleep, err := exec.LookPath("sleep")
+	if err != nil {
+		t.Fatal("deadline fixture requires sleep:", err)
+	}
+	t.Setenv("PLAN9ASM_OBJECT_HELPER_SLEEP", sleep)
+	shim := filepath.Join(t.TempDir(), "go")
+	const script = `#!/bin/sh
+"$PLAN9ASM_OBJECT_HELPER_SLEEP" 30 &
+child=$!
+printf '%s' "$child" > "$PLAN9ASM_RUNTIME_COMMAND_CHILD_PID" || exit 1
+printf '%s\n' "owned child holds its parent's output pipe"
+wait "$child"
+`
+	if err := os.WriteFile(shim, []byte(script), 0700); err != nil {
+		t.Fatal(err)
+	}
+	switch mode {
+	case "object":
+		compileLLVMToObject(t, shim, arm64LinuxGNUTriple, "deadline.ll", "deadline.o", "define void @deadline() { ret void }\n")
+	case "go-env":
+		t.Setenv("PATH", filepath.Dir(shim))
+		output, err := testGoEnv(t, "GOROOT")
+		if err != nil {
+			t.Fatalf("go env failed: %v\n%s", err, output)
+		}
+	default:
+		t.Fatalf("unknown object helper fixture %q", mode)
+	}
+	t.Fatal("failure-only helper unexpectedly succeeded")
+}
+
+func TestLLVMObjectHelperDeadlineCleansOwnedDescendant(t *testing.T) {
+	for _, mode := range []string{"object", "go-env"} {
+		t.Run(mode, func(t *testing.T) {
+			pidFile := filepath.Join(t.TempDir(), "owned-child.pid")
+			ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
+			defer cancel()
+			command := exec.CommandContext(ctx, os.Args[0],
+				"-test.run=^TestLLVMObjectHelperDeadlineFixture$", "-test.timeout=5s", "-test.v")
+			command.Env = append(os.Environ(),
+				"PLAN9ASM_OBJECT_HELPER_FIXTURE="+mode,
+				"PLAN9ASM_RUNTIME_COMMAND_CHILD_PID="+pidFile,
+			)
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			data, readErr := os.ReadFile(pidFile)
+			if readErr != nil {
+				t.Fatalf("owned descendant did not publish its identity: %v\n%s", readErr, output)
+			}
+			pid, parseErr := strconv.Atoi(string(data))
+			if parseErr != nil || pid <= 1 {
+				t.Fatalf("invalid owned descendant identity %q: %v", data, parseErr)
+			}
+			child, findErr := os.FindProcess(pid)
+			if findErr != nil {
+				t.Fatal(findErr)
+			}
+			defer child.Kill()
+			var exit *exec.ExitError
+			if ctx.Err() != nil || !errors.As(err, &exit) || exit.ExitCode() != 1 {
+				t.Fatalf("helper did not fail within its own stage deadline: %v\n%s", err, output)
+			}
+			for _, witness := range []string{"context deadline exceeded", "owned child holds its parent's output pipe"} {
+				if !strings.Contains(string(output), witness) {
+					t.Fatalf("helper discarded deadline/output witness %q: %v\n%s", witness, err, output)
+				}
+			}
+			runtimeOracleAssertChildStopped(t, pid)
+		})
+	}
+}
diff --git a/native_amd64_physical_runtime_test.go b/native_amd64_physical_runtime_test.go
new file mode 100644
index 000000000..ee023a5dc
--- /dev/null
+++ b/native_amd64_physical_runtime_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+// The descriptor is a first-party physical C ABI fixture, not a Go function
+// signature. Its independent C layout checks every assembly byte offset.
+func nativeAMD64PhysicalABIFixture() (string, string) {
+	var source strings.Builder
+	source.WriteString("#include \"textflag.h\"\nTEXT dispatch<>(SB),NOSPLIT,$224\nMOVQ R12,208(SP)\nMOVQ DI,216(SP)\nMOVQ DI,R11\n")
+	for i := 0; i < 8; i++ {
+		fmt.Fprintf(&source, "MOVQ %d(R11),X%d\n", 264+8*i, i)
+	}
+	for i, reg := range []string{"DI", "SI", "DX", "CX", "R8", "R9"} {
+		fmt.Fprintf(&source, "MOVQ %d(R11),%s\n", 8+8*i, reg)
+	}
+	for i := 0; i < 26; i++ {
+		fmt.Fprintf(&source, "MOVQ %d(R11),R12\nMOVQ R12,%d(SP)\n", 56+8*i, 8*i)
+	}
+	source.WriteString("MOVQ 0(R11),R10\nCALL R10\nMOVQ 216(SP),DI\nMOVQ AX,328(DI)\nMOVQ DX,336(DI)\nMOVQ X0,344(DI)\nMOVQ X1,352(DI)\nMOVQ 208(SP),R12\nRET\nGLOBL ·entry(SB),RODATA|NOPTR,$8\nDATA ·entry(SB)/8,$dispatch<>(SB)\n")
+	var code strings.Builder
+	code.WriteString(`#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+typedef struct { uintptr_t fn; uint64_t a[32]; double f[8]; uint64_t r[4]; } Args;
+typedef struct { double lo,hi; } Floats;
+typedef struct { uint64_t lo; double hi; } Mixed;
+_Static_assert(sizeof(uintptr_t)==8 && offsetof(Args,f)==264 && offsetof(Args,r)==328,"physical layout");
+#if defined(__APPLE__)
+extern void *entry __asm("_probe.entry");
+#else
+extern void *entry __asm("probe.entry");
+#endif
+#define ALIGNED() do { if ((uintptr_t)__builtin_frame_address(0)&15) abort(); } while(0)
+static uint64_t bits(double value) { uint64_t result; memcpy(&result,&value,8); return result; }
+`)
+	for _, count := range []int{6, 7, 32} {
+		var args, lo, hi []string
+		for i := 0; i < count; i++ {
+			args = append(args, fmt.Sprintf("uint64_t a%d", i))
+			lo = append(lo, fmt.Sprintf("a%d*%d", i, i+1))
+			hi = append(hi, fmt.Sprintf("a%d*%d", i, 33-i))
+		}
+		fmt.Fprintf(&code, "static __attribute__((noinline)) __uint128_t ints%d(%s){ ALIGNED(); return ((__uint128_t)(%s)<<64)|(%s); }\n", count, strings.Join(args, ","), strings.Join(hi, "+"), strings.Join(lo, "+"))
+	}
+	for _, count := range []int{8, 9} {
+		var args, lo, hi []string
+		for i := 0; i < count; i++ {
+			args = append(args, fmt.Sprintf("double f%d", i))
+			lo = append(lo, fmt.Sprintf("f%d*%d", i, i+1))
+			hi = append(hi, fmt.Sprintf("f%d*%d", i, 10-i))
+		}
+		fmt.Fprintf(&code, "static __attribute__((noinline)) Floats floats%d(%s){ ALIGNED(); return (Floats){%s,%s}; }\n", count, strings.Join(args, ","), strings.Join(lo, "+"), strings.Join(hi, "+"))
+	}
+	var mixedArgs, mixedInt, mixedFloat []string
+	for i := 0; i < 24; i++ {
+		mixedArgs = append(mixedArgs, fmt.Sprintf("uint64_t a%d", i))
+		mixedInt = append(mixedInt, fmt.Sprintf("a%d*%d", i, i+1))
+	}
+	for i := 0; i < 8; i++ {
+		mixedArgs = append(mixedArgs, fmt.Sprintf("double f%d", i))
+		mixedFloat = append(mixedFloat, fmt.Sprintf("f%d*%d", i, i+1))
+	}
+	fmt.Fprintf(&code, "static __attribute__((noinline)) Mixed mixed32(%s){ ALIGNED(); return (Mixed){%s,%s}; }\n", strings.Join(mixedArgs, ","), strings.Join(mixedInt, "+"), strings.Join(mixedFloat, "+"))
+	code.WriteString(`static void invoke(Args *args) {
+ register uint64_t kept __asm("r12")=UINT64_C(0x912837465abcdeff);
+ __asm__ volatile("" : "+r"(kept));
+ ((void (*)(Args *))entry)(args);
+ __asm__ volatile("" : "+r"(kept));
+ if(kept!=UINT64_C(0x912837465abcdeff)) abort();
+}
+int main(void) {
+ for(unsigned seed=0;seed<32;seed++) for(unsigned kind=0;kind<6;kind++) {
+  struct { uint64_t before; Args args; uint64_t after; } box;
+  memset(&box,0xa5,sizeof(box));
+  box.before=UINT64_C(0xfedcba9876543210); box.after=UINT64_C(0x123456789abcdef0);
+  for(unsigned i=0;i<32;i++) box.args.a[i]=seed*19+i*7+1;
+  for(unsigned i=0;i<8;i++) box.args.f[i]=seed+i*.25+.5;
+  uint64_t lo=0,hi=0; double flo=0,fhi=0;
+  if(kind<3) {
+   unsigned count=kind==0?6:kind==1?7:32;
+   for(unsigned i=0;i<count;i++){ lo+=box.args.a[i]*(i+1); hi+=box.args.a[i]*(33-i); }
+   box.args.fn=kind==0?(uintptr_t)ints6:kind==1?(uintptr_t)ints7:(uintptr_t)ints32;
+  } else if(kind<5) {
+   unsigned count=kind==3?8:9;
+   double ninth=seed+2.5;
+   if(count==9) box.args.a[6]=bits(ninth);
+   for(unsigned i=0;i<count;i++){ double value=i==8?ninth:box.args.f[i]; flo+=value*(i+1);fhi+=value*(10-i); }
+   box.args.fn=kind==3?(uintptr_t)floats8:(uintptr_t)floats9;
+  } else {
+   for(unsigned i=0;i<24;i++) lo+=box.args.a[i]*(i+1);
+   for(unsigned i=0;i<8;i++) fhi+=box.args.f[i]*(i+1);
+   box.args.fn=(uintptr_t)mixed32;
+  }
+  invoke(&box.args);
+  if(box.before!=UINT64_C(0xfedcba9876543210)||box.after!=UINT64_C(0x123456789abcdef0)) return 1;
+  if(kind<3 && (box.args.r[0]!=lo||box.args.r[1]!=hi)) return 2;
+  if(kind>=3&&kind<5 && (box.args.r[2]!=bits(flo)||box.args.r[3]!=bits(fhi))) return 3;
+  if(kind==5 && (box.args.r[0]!=lo||box.args.r[2]!=bits(fhi))) return 4;
+ }
+ return 0;
+}
+`)
+	return source.String(), code.String()
+}
+
+func TestCrossLinuxRuntimeMatrixX86NativePhysicalABIArguments(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	source, mainC := nativeAMD64PhysicalABIFixture()
+	nativeAMD64OriginalObject(t, runtime.GOOS, source)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod, err := TranslateNativeModule(ctx, []byte(source), NativeOptions{GOOS: runtime.GOOS, GOARCH: "amd64", PackagePath: "probe"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer mod.Dispose()
+	for _, optimize := range []bool{false, true} {
+		ir := mod.String()
+		if optimize {
+			ir = x86DwordProductIROptimize(t, ir)
+		}
+		for _, backend := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR-O2-%t/backend-O%d", optimize, backend), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang, "-target", triple}, "native-physical-args", triple, ir, mainC, prefix, backend)
+			})
+		}
+	}
+}
diff --git a/native_amd64_physical_test.go b/native_amd64_physical_test.go
new file mode 100644
index 000000000..2586d3cc6
--- /dev/null
+++ b/native_amd64_physical_test.go
@@ -0,0 +1,338 @@
+package plan9asm
+
+import (
+	"bytes"
+	"debug/elf"
+	"debug/macho"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func nativeAMD64OriginalObject(t *testing.T, goos, source string) string {
+	t.Helper()
+	return nativePhysicalOriginalObject(t, goos, "amd64", source)
+}
+
+func nativePhysicalOriginalObject(t *testing.T, goos, arch, source string) string {
+	t.Helper()
+	dir := t.TempDir()
+	file := filepath.Join(dir, "physical.s")
+	if err := os.WriteFile(file, []byte(source), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	listing, err := goasmcmd.Run(ctx, dir, append(os.Environ(),
+		"GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off",
+		"GOOS="+goos, "GOARCH="+arch), filepath.Join(runtime.GOROOT(), "bin/go"),
+		"tool", "asm", "-S", "-p", "probe", "-I", filepath.Join(runtime.GOROOT(), "pkg/include"),
+		"-o", filepath.Join(dir, "original.o"), file)
+	if err != nil {
+		t.Fatalf("original Go physical source rejected: %v\n%s\n%s", err, listing, source)
+	}
+	if info, err := os.Stat(filepath.Join(dir, "original.o")); err != nil || info.Size() == 0 {
+		t.Fatal("missing original Go object", err)
+	}
+	return string(listing)
+}
+
+func nativePhysicalAssemblyObject(t *testing.T, assembly, arch string) {
+	t.Helper()
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM22 clang is required")
+	}
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "native.s"), filepath.Join(dir, "native.o")
+	if err := os.WriteFile(input, []byte(assembly), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "arm64" {
+		triple = "aarch64-unknown-linux-gnu"
+	}
+	stage, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	bytes, err := goasmcmd.Run(stage, dir, os.Environ(), clang, "-target", triple, "-c", input, "-o", output)
+	if err != nil {
+		t.Fatalf("physical assembly object: %v\n%s\n%s", err, bytes, assembly)
+	}
+	if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+		t.Fatal("missing native assembly object", err)
+	}
+}
+
+func nativeAMD64PhysicalObjects(t *testing.T, source string, options NativeOptions) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod, err := TranslateNativeModule(ctx, []byte(source), options)
+	if err != nil {
+		t.Fatal("complete physical source rejected", err)
+	}
+	defer mod.Dispose()
+	if err := llvm.VerifyModule(mod, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		x86PackedStringCompileObject(t, llc, mod.Target(), mod.String(), level)
+	}
+	return mod.String()
+}
+
+// Each row is an independently assemblable function. These are physical
+// instructions, never synthetic Go arguments, initial values or call results.
+func TestNativeAMD64TypedPhysicalFormatFamilies(t *testing.T) {
+	rows := []struct{ name, body string }{
+		{"call_register", "CALL AX\nCALL R10"},
+		{"call_memory", "CALL (AX)\nCALL 8(R11)"},
+		{"global_word", "MOVQ ·word(SB),DI\nMOVQ DI,·word(SB)"},
+		{"global_address", "MOVQ $·word(SB),AX\nLEAQ ·word(SB),DX"},
+		{"code_address", "MOVQ $physical<>(SB),DX"},
+		{"xmm_qword", "MOVQ X0,X1\nMOVQ X1,AX\nMOVQ AX,X2\nMOVQ X2,8(SP)\nMOVQ 8(SP),X3"},
+		{"xmm_dword", "MOVL X1,AX\nMOVL AX,X2\nMOVL X2,8(SP)\nMOVL 8(SP),X3"},
+		{"scalar_double", "MOVSD X0,X1\nMOVSD X1,8(SP)\nMOVSD 8(SP),X2"},
+		{"scalar_single", "MOVSS X0,X1\nMOVSS X1,8(SP)\nMOVSS 8(SP),X2"},
+		{"byte_alias", "MOVB AH,BX\nMOVB AX,8(SP)\nMOVB 8(SP),R8\nMOVB AH,(R8)"},
+		{"word", "MOVW $65535,AX\nMOVW AX,(DI)\nMOVW (DI),R9\nADDW $1,R9"},
+		{"dword", "MOVL $0xffffffff,AX\nMOVL AX,(DI)\nMOVL (DI),R9\nADDL $1,R9"},
+		{"qword", "MOVQ $0x123456789abcdef,AX\nMOVQ AX,(DI)\nMOVQ (DI),R9\nADDQ $1,R9"},
+		{"arithmetic_bytes", "ADDB AX,BX\nSUBB $1,(DI)\nXORB R8,R9\nANDB $3,AX\nORB CX,DX"},
+		{"compare_test", "CMPB AX,$1\nCMPW AX,BX\nCMPQ (DI),AX\nTESTB $3,AX\nTESTW AX,(DI)"},
+		{"shift_count", "SHLB CX,AX\nSHLW CL,BX\nSARL CX,(DI)\nRORQ $255,AX\nSHLQ $1,DX,AX"},
+		{"push_pop_qword", "PUSHQ AX\nPOPQ BX\nPUSHQ (DI)\nPOPQ (DI)\nPUSHQ $-1\nPOPQ AX"},
+		{"push_pop_word", "PUSHW AX\nPOPW BX\nPUSHW (DI)\nPOPW (DI)"},
+		{"push_pop_flags", "PUSHFQ\nPOPFQ\nPUSHFW\nPOPFW"},
+		{"adjust_stack", "ADJSP $112\nADJSP $-112"},
+		{"adjust_explicit_stack", "ADJSP $112,SP\nADJSP $-112,SP"},
+		{"divide_byte", "DIVB BX\nIDIVB (DI)"},
+		{"divide_word", "DIVW BX\nIDIVW (DI)"},
+		{"divide_dword", "DIVL CX\nIDIVL 8(DI)"},
+		{"divide_qword", "DIVQ R10\nIDIVQ (DI)"},
+		{"indexed_memory", "MOVQ (AX)(CX*4),DX\nMOVSD 8(AX)(R8*2),X0\nMOVQ 8(CX*4),AX"},
+		{"arithmetic_offset", "MOVQ 0+(1*8)(AX),DX\nMOVQ (4+4)(SP),AX"},
+		{"absolute_memory", "MOVL 8,AX\nMOVW AX,16"},
+		{"stack_segments", "PUSHQ FS\nPOPQ FS\nPUSHW GS\nPOPW GS"},
+		{"stack_immediate", "PUSHQ $0xffffffff\nPOPQ AX\nPUSHW $65535\nPOPW AX"},
+	}
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, row := range rows {
+			t.Run(goos+"/"+row.name, func(t *testing.T) {
+				source := "#include \"textflag.h\"\nTEXT physical<>(SB),NOSPLIT|NOFRAME,$0-0\n" + row.body + "\nRET\n" +
+					"GLOBL ·word(SB),NOPTR,$8\nDATA ·word(SB)/8,$7\n"
+				nativeAMD64OriginalObject(t, goos, source)
+				nativeAMD64PhysicalObjects(t, source, NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe"})
+			})
+		}
+	}
+}
+
+func TestNativeAMD64ManagedFrameMatchesGoAssembler(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, row := range []struct {
+			name, flags string
+			frame       int
+			call        bool
+			entry, exit string
+		}{
+			{"leaf0", "NOSPLIT", 0, false, "", "c3"},
+			{"noframe0", "NOSPLIT|NOFRAME", 0, false, "", "c3"},
+			{"call0", "NOSPLIT", 0, true, "554889e5", "5dc3"},
+			{"frame8", "NOSPLIT", 8, false, "554889e54883ec08", "4883c4085dc3"},
+			{"frame16", "NOSPLIT", 16, true, "554889e54883ec10", "4883c4105dc3"},
+			{"frame224", "NOSPLIT", 224, true, "554889e54881ece0000000", "4881c4e00000005dc3"},
+			{"noframe224", "NOSPLIT|NOFRAME", 224, true, "4881ece0000000", "4881c4e0000000c3"},
+		} {
+			t.Run(goos+"/"+row.name, func(t *testing.T) {
+				body := "MOVQ AX,DX\n"
+				if row.call {
+					body += "CALL imported(SB)\n"
+				}
+				source := fmt.Sprintf("#include \"textflag.h\"\nTEXT physical<>(SB),%s,$%d-0\n%sRET\n", row.flags, row.frame, body)
+				listing := nativeAMD64OriginalObject(t, goos, source)
+				wantBP := !strings.Contains(row.flags, "NOFRAME") && (row.frame != 0 || row.call)
+				modernGo := strings.Contains(listing, "PUSHQ\tBP") == wantBP
+				if !modernGo {
+					if row.frame != 0 {
+						// The older producer reserves locals+BP together. Its
+						// saved slot and final SP/BP match, but not entry FLAGS.
+						for _, part := range []string{fmt.Sprintf("SUBQ\t$%d, SP", row.frame+8),
+							fmt.Sprintf("MOVQ\tBP, %d(SP)", row.frame), fmt.Sprintf("LEAQ\t%d(SP), BP", row.frame),
+							fmt.Sprintf("MOVQ\t%d(SP), BP", row.frame), fmt.Sprintf("ADDQ\t$%d, SP", row.frame+8)} {
+							if !strings.Contains(listing, part) {
+								t.Fatal("unknown historical Go frame shape", part, listing)
+							}
+						}
+					} else if !row.call || strings.Contains(listing, "\tSUBQ\t") || strings.Contains(listing, "\tMOVQ\tBP,") {
+						t.Fatal("unknown historical zero-local nonleaf frame", listing)
+					}
+					t.Log("historical Go object retained; current frame contract is independently checked, not byte/FLAGS equivalence", listing)
+				}
+				opts := NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe", Imports: map[string]string{"imported": "callee"}}
+				assembly, _, err := TranslateNativeSource([]byte(source), opts)
+				if err != nil {
+					t.Fatal("actual Go managed frame rejected", err)
+				}
+				if strings.Contains(assembly, "pushq %rbp") != wantBP || strings.Contains(assembly, "popq %rbp") != wantBP {
+					t.Fatal("native frame differs from original Go", assembly, listing)
+				}
+				if row.frame > 0 {
+					for _, part := range []string{fmt.Sprintf("subq $%d, %%rsp", row.frame), fmt.Sprintf("addq $%d, %%rsp", row.frame)} {
+						if !strings.Contains(assembly, part) {
+							t.Fatal("native frame lost its exact Go local extent", part, assembly)
+						}
+					}
+				}
+				ir := nativeAMD64PhysicalObjects(t, source, opts)
+				if modernGo {
+					nativeAMD64CompareFrameMachineCode(t, goos, listing, ir)
+				}
+				// Literal machine-byte oracles preserve the selected current
+				// frame contract even when the host Go uses an older epoch.
+				machine := row.entry + "4889c2"
+				if row.call {
+					machine += "e800000000"
+				}
+				want, err := hex.DecodeString(machine + row.exit)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					code := nativeAMD64ObjectCode(t, goos, ir, level)
+					if len(code) < len(want) {
+						t.Fatalf("short current frame: %x", code)
+					}
+					code = append([]byte(nil), code[:len(want)]...)
+					if row.call {
+						pc := len(row.entry)/2 + 3
+						for i := pc + 1; i < pc+5; i++ {
+							code[i] = 0
+						}
+					}
+					if !bytes.Equal(code, want) {
+						t.Fatalf("%s current frame contract differs: got %x want %x", level, code, want)
+					}
+				}
+			})
+		}
+	}
+}
+
+// The original assembler's instruction bytes are an independent oracle for
+// every SP/BP change, including the extra saved BP for a zero-local nonleaf.
+// Only the external CALL displacement is relocation-owned and normalized.
+func nativeAMD64CompareFrameMachineCode(t *testing.T, goos, listing, ir string) {
+	t.Helper()
+	var want []byte
+	for _, row := range regexp.MustCompile(`(?m)^\s*0x[[:xdigit:]]+\s+((?:[[:xdigit:]]{2} )+)`).FindAllStringSubmatch(listing, -1) {
+		part, err := hex.DecodeString(strings.ReplaceAll(row[1], " ", ""))
+		if err != nil {
+			t.Fatal(err)
+		}
+		want = append(want, part...)
+	}
+	lastRET := bytes.LastIndexByte(want, 0xc3)
+	if lastRET < 0 {
+		t.Fatal("original Go frame has no RET", listing)
+	}
+	want = want[:lastRET+1]
+	for _, level := range []string{"-O0", "-O2"} {
+		got := nativeAMD64ObjectCode(t, goos, ir, level)
+		if len(got) < len(want) {
+			t.Fatalf("short native frame: got %x original %x", got, want)
+		}
+		got = append([]byte(nil), got[:len(want)]...)
+		expected := append([]byte(nil), want...)
+		for _, row := range regexp.MustCompile(`(?m)^\s*0x([[:xdigit:]]+)\s+[0-9]+[^\n]*\tCALL\t`).FindAllStringSubmatch(listing, -1) {
+			position, err := strconv.ParseUint(row[1], 16, 32)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pc := int(position)
+			if pc+5 > len(expected) || expected[pc] != 0xe8 || got[pc] != 0xe8 {
+				t.Fatal("original/native CALL boundary differs", listing)
+			}
+			for i := pc + 1; i < pc+5; i++ {
+				got[i], expected[i] = 0, 0
+			}
+		}
+		if !bytes.Equal(got, expected) {
+			t.Fatalf("%s physical frame differs: native %x original Go %x\n%s", level, got, expected, listing)
+		}
+	}
+}
+
+func TestNativeAMD64TypedPhysicalRejectsUnprovedForms(t *testing.T) {
+	for _, body := range []string{
+		"CALL $1", "CALL unknown(SB)", "CALL X0", "MOVQ X16,X0", "MOVSD AX,X0", "MOVQ (AX),(BX)",
+		"MOVQ $1,X0", "DIVL $1", "PUSHQ X0", "POPQ $1", "ADJSP AX", "ADJSP $8,AX",
+		"MOVQ value+0(FP),AX", "MOVQ unknown(SB),AX", "MOVQ $unknown(SB),AX", "MOVQ AX,8(FS)",
+		"MOVQ 1(R8)(SP*2),AX", "ADDQ.Z AX,BX",
+	} {
+		t.Run(body, func(t *testing.T) {
+			source := "#include \"textflag.h\"\nTEXT physical<>(SB),NOSPLIT|NOFRAME,$0-0\n" + body + "\nRET\n"
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			mod, err := TranslateNativeModule(ctx, []byte(source), NativeOptions{GOOS: "linux", GOARCH: "amd64", PackagePath: "probe"})
+			if err == nil {
+				mod.Dispose()
+				t.Fatal("unproved physical form acquired a native carrier")
+			}
+			if !mod.IsNil() {
+				t.Fatal("rejected source returned an owned partial module")
+			}
+		})
+	}
+}
+
+func nativeAMD64ObjectCode(t *testing.T, goos, ir, level string) []byte {
+	t.Helper()
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "frame.ll"), filepath.Join(dir, "frame.o")
+	if err := os.WriteFile(input, []byte(ir), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	_, err := goasmcmd.Run(ctx, dir, os.Environ(), findLLVM22Tool("llc"), level, "-filetype=obj", input, "-o", output)
+	cancel()
+	if err != nil {
+		t.Fatal("LLVM frame object", err)
+	}
+	var got []byte
+	if goos == "linux" {
+		object, err := elf.Open(output)
+		if err != nil {
+			t.Fatal(err)
+		}
+		got, err = object.Section(".text").Data()
+		object.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else {
+		object, err := macho.Open(output)
+		if err != nil {
+			t.Fatal(err)
+		}
+		got, err = object.Section("__text").Data()
+		object.Close()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	return got
+}
diff --git a/native_amd64_source.go b/native_amd64_source.go
index ae624b5fd..d8efac17c 100644
--- a/native_amd64_source.go
+++ b/native_amd64_source.go
@@ -6,54 +6,95 @@ import (
 	"strings"
 )
 
-type nativeAMD64 struct{ *nativeEmitter }
+type nativeAMD64 struct {
+	*nativeEmitter
+	frame nativeFramePlan
+}
 
 func nativeAMD64Reg(o Operand, bits int) (string, error) {
 	if o.Kind != OpReg {
 		return "", fmt.Errorf("expected amd64 register")
 	}
-	names := map[Reg][2]string{AX: {"eax", "rax"}, BX: {"ebx", "rbx"}, CX: {"ecx", "rcx"}, DX: {"edx", "rdx"}, SI: {"esi", "rsi"}, DI: {"edi", "rdi"}, SP: {"esp", "rsp"}, BP: {"ebp", "rbp"}}
-	if n, ok := names[o.Reg]; ok {
-		if bits == 32 {
-			return "%" + n[0], nil
+	if bits == 8 {
+		switch o.Reg {
+		case AH, CH, DH, BH:
+			return "%" + strings.ToLower(string(o.Reg)), nil
 		}
-		return "%" + n[1], nil
+	}
+	if base, _, ok := amd64ByteAlias(o.Reg); ok {
+		o.Reg = base
+	}
+	names := map[Reg][4]string{
+		AX: {"al", "ax", "eax", "rax"}, BX: {"bl", "bx", "ebx", "rbx"},
+		CX: {"cl", "cx", "ecx", "rcx"}, DX: {"dl", "dx", "edx", "rdx"},
+		SI: {"sil", "si", "esi", "rsi"}, DI: {"dil", "di", "edi", "rdi"},
+		SP: {"spl", "sp", "esp", "rsp"}, BP: {"bpl", "bp", "ebp", "rbp"},
+	}
+	width := map[int]int{8: 0, 16: 1, 32: 2, 64: 3}[bits]
+	if n, ok := names[o.Reg]; ok {
+		return "%" + n[width], nil
 	}
 	name := string(o.Reg)
 	if strings.HasPrefix(name, "R") {
 		n, err := strconv.Atoi(name[1:])
 		if err == nil && n >= 8 && n <= 15 {
-			suffix := ""
-			if bits == 32 {
-				suffix = "d"
-			}
+			suffix := []string{"b", "w", "d", ""}[width]
 			return fmt.Sprintf("%%r%d%s", n, suffix), nil
 		}
 	}
 	return "", fmt.Errorf("unsupported amd64 register %s", name)
 }
 
-func nativeAMD64Operand(o Operand, bits int) (string, error) {
+func (e *nativeAMD64) operand(o Operand, bits int) (string, error) {
 	switch o.Kind {
 	case OpReg:
+		if xmm, ok := nativeAMD64XMM(o); ok {
+			return xmm, nil
+		}
 		return nativeAMD64Reg(o, bits)
 	case OpImm:
-		if o.ImmRaw != "" {
-			return "", fmt.Errorf("unresolved native immediate")
+		if o.ImmRaw == "" && !o.ImmIsFloat {
+			return fmt.Sprintf("$%d", o.Imm), nil
+		}
+	}
+	if !x86ScalarCompareMemoryValid(o, "amd64") {
+		return "", fmt.Errorf("unsupported native address %s", o.String())
+	}
+	if base, m, ok := x86ScalarCompareSBAddress(o, "amd64"); ok {
+		_, off, _ := parseSBRef(m.Sym)
+		target, err := e.symbol(base+"(SB)", true)
+		if err != nil {
+			return "", err
+		}
+		if off += m.Off; off != 0 {
+			target += fmt.Sprintf("%+d", off)
 		}
-		return fmt.Sprintf("$%d", o.Imm), nil
-	case OpMem:
-		m := o.Mem
-		if m.Sym != "" || m.OffRaw != "" || m.Index != "" || m.Segment != "" || m.Off < -1<<31 || m.Off > 1<<31-1 {
-			break
+		return target + "(%rip)", nil
+	}
+	if o.Kind == OpSym {
+		if address, err := parseInt(o.Sym); err == nil {
+			return fmt.Sprintf("%d", address), nil
 		}
-		base, err := nativeAMD64Reg(Operand{Kind: OpReg, Reg: m.Base}, 64)
+	}
+	if o.Kind != OpMem || o.Mem.Segment != "" {
+		return "", fmt.Errorf("native memory needs physical backing: %s", o.String())
+	}
+	base := ""
+	if o.Mem.Base != "" {
+		var err error
+		base, err = nativeAMD64Reg(Operand{Kind: OpReg, Reg: o.Mem.Base}, 64)
 		if err != nil {
 			return "", err
 		}
-		return fmt.Sprintf("%d(%s)", m.Off, base), nil
 	}
-	return "", fmt.Errorf("unsupported amd64 operand %s", o.String())
+	if o.Mem.Index == "" {
+		if base == "" {
+			return fmt.Sprintf("%d", o.Mem.Off), nil
+		}
+		return fmt.Sprintf("%d(%s)", o.Mem.Off, base), nil
+	}
+	index, err := nativeAMD64Reg(Operand{Kind: OpReg, Reg: o.Mem.Index}, 64)
+	return fmt.Sprintf("%d(%s,%s,%d)", o.Mem.Off, base, index, o.Mem.Scale), err
 }
 
 func nativeAMD64XMM(o Operand) (string, bool) {
@@ -88,6 +129,7 @@ func (e *nativeAMD64) instruction(out *strings.Builder, ins Instr) error {
 	}
 	switch op {
 	case "TEXT":
+		e.frame.prologue(out)
 		return nil
 	case "LABEL":
 		fmt.Fprintf(out, "%s:\n", e.labels[a[0].Sym])
@@ -96,12 +138,24 @@ func (e *nativeAMD64) instruction(out *strings.Builder, ins Instr) error {
 		if len(a) != 0 {
 			return bad()
 		}
+		e.frame.epilogue(out)
 		emit("ret")
 		return nil
 	case "CALL", "JMP":
 		if len(a) != 1 {
 			return bad()
 		}
+		if a[0].Kind == OpReg || a[0].Kind == OpMem {
+			if a[0].Kind == OpReg && !isX86YrlRegisterForArch(a[0].Reg, "amd64") {
+				return bad()
+			}
+			dst, err := e.operand(a[0], 64)
+			if err != nil {
+				return err
+			}
+			emit(strings.ToLower(op), "*"+dst)
+			return nil
+		}
 		dst, err := e.branch(a[0], true)
 		if err != nil {
 			return err
@@ -127,73 +181,5 @@ func (e *nativeAMD64) instruction(out *strings.Builder, ins Instr) error {
 		emit(inst, dst)
 		return nil
 	}
-	if len(a) != 2 {
-		return bad()
-	}
-	bits := 64
-	if strings.HasSuffix(op, "L") {
-		bits = 32
-	}
-	allowed := map[string]bool{"MOVQ": true, "MOVL": true, "LEAQ": true, "ADDQ": true, "ADDL": true, "SUBQ": true, "SUBL": true, "XORQ": true, "XORL": true, "ANDQ": true, "ANDL": true, "ORQ": true, "ORL": true, "CMPQ": true, "CMPL": true, "TESTQ": true, "TESTL": true, "SHLQ": true, "SHLL": true, "SHRQ": true, "SHRL": true, "SARQ": true, "SARL": true}
-	if !allowed[op] {
-		return bad()
-	}
-	// MOVQ between XMM and integer registers is a bit transfer, not conversion.
-	if op == "MOVQ" {
-		x0, ok0 := nativeAMD64XMM(a[0])
-		x1, ok1 := nativeAMD64XMM(a[1])
-		if ok0 || ok1 {
-			if ok0 && ok1 {
-				return bad()
-			}
-			if ok0 {
-				r, err := nativeAMD64Operand(a[1], 64)
-				if err != nil || a[1].Kind == OpImm {
-					return bad()
-				}
-				emit("movq", x0, r)
-			} else {
-				r, err := nativeAMD64Operand(a[0], 64)
-				if err != nil || a[0].Kind == OpImm {
-					return bad()
-				}
-				emit("movq", r, x1)
-			}
-			return nil
-		}
-	}
-	// Go CMP places the minuend first, unlike AT&T syntax.
-	if op == "CMPQ" || op == "CMPL" {
-		a = []Operand{a[1], a[0]}
-	}
-	if a[1].Kind == OpImm || (a[0].Kind == OpMem && a[1].Kind == OpMem) {
-		return bad()
-	}
-	if op == "LEAQ" && (a[0].Kind != OpMem || a[1].Kind != OpReg) {
-		return bad()
-	}
-	shift := strings.HasPrefix(op, "SHL") || strings.HasPrefix(op, "SHR") || strings.HasPrefix(op, "SAR")
-	if shift && (a[0].Kind != OpImm || a[0].Imm < 0 || a[0].Imm >= int64(bits)) {
-		return bad()
-	}
-	if a[0].Kind == OpImm && !shift {
-		v := a[0].Imm
-		if bits == 32 {
-			if v < -1<<31 || v > 1<<32-1 {
-				return bad()
-			}
-		} else if !(op == "MOVQ" && a[1].Kind == OpReg) && (v < -1<<31 || v > 1<<31-1) {
-			return bad()
-		}
-	}
-	src, err := nativeAMD64Operand(a[0], bits)
-	if err != nil {
-		return err
-	}
-	dst, err := nativeAMD64Operand(a[1], bits)
-	if err != nil {
-		return err
-	}
-	emit(strings.ToLower(op), src, dst)
-	return nil
+	return e.typedInstruction(out, ins)
 }
diff --git a/native_amd64_stack_frame_test.go b/native_amd64_stack_frame_test.go
new file mode 100644
index 000000000..eba6593ab
--- /dev/null
+++ b/native_amd64_stack_frame_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func TestNativeAMD64StackFrameTracksGoStackForms(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, row := range []struct {
+			name, body string
+			balanced   bool
+		}{
+			{"word", "PUSHW AX\nPOPW DX", true},
+			{"flags", "PUSHFQ\nPOPFQ", true},
+			{"adjust", "ADJSP $8\nADJSP $-8", true},
+			{"segment_native_width", "PUSHL FS\nPOPL FS", true},
+			{"unbalanced_push", "PUSHW AX", false},
+			{"unbalanced_pop", "POPQ AX", false},
+			{"unbalanced_flags", "PUSHFW", false},
+			{"unbalanced_adjust", "ADJSP $8", false},
+			{"mismatched_width", "PUSHW AX\nPOPQ AX", false},
+		} {
+			t.Run(goos+"/"+row.name, func(t *testing.T) {
+				source := "#include \"textflag.h\"\nTEXT physical<>(SB),NOSPLIT|NOFRAME,$0-0\n" + row.body + "\nRET\n"
+				opts := NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe"}
+				if row.balanced {
+					nativeAMD64OriginalObject(t, goos, source)
+					nativeAMD64PhysicalObjects(t, source, opts)
+					return
+				}
+				dir := t.TempDir()
+				file := filepath.Join(dir, "original.s")
+				if err := os.WriteFile(file, []byte(source), 0o600); err != nil {
+					t.Fatal(err)
+				}
+				stage, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				observed, err := goasmcmd.Observe(stage, dir, append(os.Environ(),
+					"GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off",
+					"GOOS="+goos, "GOARCH=amd64"), filepath.Join(runtime.GOROOT(), "bin/go"),
+					"tool", "asm", "-I", filepath.Join(runtime.GOROOT(), "pkg/include"), "-o", filepath.Join(dir, "original.o"), file)
+				if stage.Err() != nil || err == nil || !observed.Waited || observed.ExitCode != 1 ||
+					!strings.Contains(string(observed.Stderr), "unbalanced PUSH/POP") {
+					t.Fatalf("unknown original Go stack rejection: %v; exit=%d\n%s\n%s", err, observed.ExitCode, observed.Stdout, observed.Stderr)
+				}
+				t.Log("actual Go rejected this complete source", string(observed.Stderr))
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateNativeModule(ctx, []byte(source), opts)
+				if err == nil {
+					mod.Dispose()
+					t.Fatal("Go-invalid stack acquired a native module")
+				}
+				if !mod.IsNil() {
+					t.Fatal("rejected source returned a partial module")
+				}
+			})
+		}
+	}
+}
diff --git a/native_amd64_symbols_test.go b/native_amd64_symbols_test.go
new file mode 100644
index 000000000..207315c50
--- /dev/null
+++ b/native_amd64_symbols_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+func TestNativeAMD64BoundMachineSymbolsAndCallTable(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			t.Run(goos+"/address_"+width, func(t *testing.T) {
+				source := fmt.Sprintf("#include \"textflag.h\"\nTEXT address<>(SB),NOSPLIT|NOFRAME,$0-0\nMOV%s $·word(SB),AX\nRET\nGLOBL ·word(SB),NOPTR,$8\nDATA ·word(SB)/8,$7\n", width)
+				listing := nativeAMD64OriginalObject(t, goos, source)
+				ir := nativeAMD64PhysicalObjects(t, source, NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe"})
+				nativeAMD64CompareFrameMachineCode(t, goos, listing, ir)
+			})
+		}
+		t.Run(goos+"/external_data", func(t *testing.T) {
+			const source = "#include \"textflag.h\"\nTEXT load<>(SB),NOSPLIT|NOFRAME,$0-0\nMOVQ ·descriptor(SB),DI\nMOVQ (DI),DI\nRET\n"
+			nativeAMD64OriginalObject(t, goos, source)
+			opts := NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe",
+				Imports: map[string]string{"·descriptor": "example.com/owner.descriptor"}}
+			ir := nativeAMD64PhysicalObjects(t, source, opts)
+			if !strings.Contains(ir, `@"example.com/owner.descriptor" = external global i8`) {
+				t.Fatal("external data identity was not an address reference", ir)
+			}
+		})
+		t.Run(goos+"/call_table", func(t *testing.T) {
+			const source = "#include \"textflag.h\"\nTEXT table<>(SB),NOSPLIT|NOFRAME,$0-0\nCALL target(SB)\nCALL target(SB)\nCALL target(SB)\n"
+			listing := nativeAMD64OriginalObject(t, goos, source)
+			if strings.Count(listing, "\tCALL\t") != 3 {
+				t.Fatal("original Go call table changed", listing)
+			}
+			ir := nativeAMD64PhysicalObjects(t, source, NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe",
+				Imports: map[string]string{"target": "machine_target"}})
+			for _, level := range []string{"-O0", "-O2"} {
+				code := nativeAMD64ObjectCode(t, goos, ir, level)
+				if len(code) < 17 || code[0] != 0xe8 || code[5] != 0xe8 || code[10] != 0xe8 || code[15] != 0x0f || code[16] != 0x0b {
+					t.Fatalf("CALL slots or explicit fallthrough boundary changed: %x", code)
+				}
+			}
+		})
+	}
+	for _, row := range []struct {
+		body, symbol, object string
+	}{
+		{"CALL ·descriptor(SB)", "·descriptor", "owner.descriptor"},
+		{"JMP ·descriptor(SB)", "·descriptor", "owner.descriptor"},
+		{"MOVQ ·missing(SB),AX", "·descriptor", "owner.descriptor"},
+		{"MOVQ ·descriptor(SB),AX", "·descriptor+8", "owner.descriptor"},
+		{"MOVQ ·descriptor(SB),AX", "·descriptor", "unsafe\n.globl injected"},
+	} {
+		t.Run(row.body+"/"+row.symbol+"/"+row.object, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			mod, err := TranslateNativeModule(ctx, []byte("#include \"textflag.h\"\nTEXT load<>(SB),NOSPLIT|NOFRAME,$0-0\n"+row.body+"\nRET\n"),
+				NativeOptions{GOOS: "linux", GOARCH: "amd64", PackagePath: "probe", Imports: map[string]string{row.symbol: row.object}})
+			if err == nil {
+				mod.Dispose()
+				t.Fatal("external data acquired a callable or mismatched symbol role")
+			}
+		})
+	}
+}
diff --git a/native_amd64_typed.go b/native_amd64_typed.go
new file mode 100644
index 000000000..798df8cc1
--- /dev/null
+++ b/native_amd64_typed.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+func (e *nativeAMD64) emitTyped(out *strings.Builder, name string, bits int, args ...Operand) error {
+	values := make([]string, len(args))
+	for i, arg := range args {
+		var err error
+		values[i], err = e.operand(arg, bits)
+		if err != nil {
+			return err
+		}
+	}
+	fmt.Fprintf(out, "\t%s %s\n", name, strings.Join(values, ", "))
+	return nil
+}
+
+// Only the existing typed family grammar selects a physical operation. No
+// Go register facts, numerical values, FLAGS or call prototypes are invented.
+func (e *nativeAMD64) typedInstruction(out *strings.Builder, ins Instr) error {
+	op, args := string(ins.Op), ins.Args
+	bad := func() error { return fmt.Errorf("unsupported native amd64 typed form: %q", ins.Raw) }
+	if ins.Op == "ADJSP" {
+		if len(args) < 1 || len(args) > 2 ||
+			args[0].Kind != OpImm || args[0].ImmRaw != "" || args[0].ImmIsFloat ||
+			args[0].Imm < -2147483647 || args[0].Imm > 2147483647 ||
+			len(args) == 2 && (args[1].Kind != OpReg || args[1].Reg != SP) {
+			return bad()
+		}
+		// Match obj6 ADJSP's SUB/ADD selection, including physical FLAGS.
+		if args[0].Imm > 0 {
+			fmt.Fprintf(out, "\tsubq $%d, %%rsp\n", args[0].Imm)
+		}
+		if args[0].Imm < 0 {
+			fmt.Fprintf(out, "\taddq $%d, %%rsp\n", -args[0].Imm)
+		}
+		return nil
+	}
+	if f, known, err := x86LockScalarRMWProperties(ins.Op, ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		if f.spec.unary {
+			return e.emitTyped(out, strings.ToLower(op), f.spec.bits, f.destination)
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.spec.bits, f.source, f.destination)
+	}
+	if f, known, err := x86ScalarCompareProperties(ins.Op, ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		if !f.test {
+			f.args[0], f.args[1] = f.args[1], f.args[0]
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.bits, f.args[:]...)
+	}
+	if f, known, err := x86ScalarShiftProperties(ins.Op, ins, "amd64"); known && !f.bmi2 {
+		if err != nil {
+			return err
+		}
+		if f.count.Kind == OpReg {
+			f.count.Reg = CL
+		}
+		count, err := e.operand(f.count, 8)
+		if err != nil {
+			return err
+		}
+		dst, err := e.operand(f.destination, f.bits)
+		if err != nil {
+			return err
+		}
+		if f.double {
+			src, err := e.operand(f.source, f.bits)
+			if err != nil {
+				return err
+			}
+			fmt.Fprintf(out, "\t%sd%s %s, %s, %s\n", strings.ToLower(f.stem), strings.ToLower(op[len(op)-1:]), count, src, dst)
+		} else {
+			fmt.Fprintf(out, "\t%s %s, %s\n", strings.ToLower(op), count, dst)
+		}
+		return nil
+	}
+	if f, known, err := x86StackWidthProperties(ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		if len(args) == 1 && x86SegmentRegisterOperand(args[0]) {
+			name := strings.ToLower(op)
+			if f.segmentNativeWidth {
+				name = name[:len(name)-1] + "q"
+			}
+			fmt.Fprintf(out, "\t%s %%%s\n", name, strings.ToLower(string(args[0].Reg)))
+			return nil
+		}
+		if len(args) == 1 && args[0].Kind == OpImm {
+			arg := args[0]
+			arg.Imm = amd64ScalarAddSubImmediateInt64(arg.Imm, f.bits)
+			return e.emitTyped(out, strings.ToLower(op), f.bits, arg)
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.bits, args...)
+	}
+	if f, known, err := x86ImplicitDivideProperties(ins.Op, ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.spec.bits, f.source)
+	}
+	if f, known, err := x86GPSIMDTransferProperties(ins, "amd64"); known {
+		if err != nil || f.mmx {
+			return bad()
+		}
+		name := "movq"
+		if f.bits == 32 {
+			name = "movd"
+		}
+		return e.emitTyped(out, name, f.bits, args...)
+	}
+	if f, known, err := amd64ScalarVectorMoveProperties(ins, "amd64"); known {
+		if err != nil || !f.spec.legacy || f.literal {
+			return bad()
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.spec.bits, args...)
+	}
+	if width := x86LEAWidth(ins.Op, "amd64"); width != 0 {
+		if _, err := x86LEAOperandWidth(ins, "amd64"); err != nil {
+			return err
+		}
+		return e.emitTyped(out, strings.ToLower(op), int(width*8), args...)
+	}
+	if f, known, err := x86ScalarPhysicalMoveProperties(ins, "amd64"); known {
+		if err != nil {
+			return err
+		}
+		if f.address {
+			f.source.Sym = strings.TrimPrefix(f.source.Sym, "$")
+			return e.emitTyped(out, "lea"+strings.ToLower(op[len(op)-1:]), f.bits, f.source, f.destination)
+		}
+		return e.emitTyped(out, strings.ToLower(op), f.bits, f.source, f.destination)
+	}
+	return bad()
+}
diff --git a/native_arm64_source.go b/native_arm64_source.go
index 3b6595dc9..933cca371 100644
--- a/native_arm64_source.go
+++ b/native_arm64_source.go
@@ -22,7 +22,9 @@ func nativeReg(o Operand, bits int, sp bool) (string, error) {
 	if o.Kind != OpReg {
 		return "", fmt.Errorf("expected native register")
 	}
-	if o.Reg == SP && sp && bits == 64 {
+	// The parser preserves the physical stack pointer as RSP. Plain SP is
+	// Go's pseudo stack pointer and must not reach this native backend.
+	if o.Reg == Reg("RSP") && sp && bits == 64 {
 		return "sp", nil
 	}
 	if o.Reg == ZR {
diff --git a/native_arm64_source_test.go b/native_arm64_source_test.go
index 7be676ef6..54a30c469 100644
--- a/native_arm64_source_test.go
+++ b/native_arm64_source_test.go
@@ -54,13 +54,36 @@ int main(void) {
 }`)
 }
 
+func TestNativeARM64SourceRequiresLLVM22(t *testing.T) {
+	executable, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cmd := exec.Command(executable, "-test.run=^TestNativeARM64Source$", "-test.v")
+	for _, variable := range os.Environ() {
+		if !strings.HasPrefix(strings.ToUpper(variable), "LLVM_CONFIG=") {
+			cmd.Env = append(cmd.Env, variable)
+		}
+	}
+	cmd.Env = append(cmd.Env, "LLVM_CONFIG="+filepath.Join(t.TempDir(), "missing-llvm-config"))
+
+	output, err := cmd.CombinedOutput()
+	if err == nil {
+		t.Fatalf("native ARM64 source test passed without required LLVM 22 tools:\n%s", output)
+	}
+	if !strings.Contains(string(output), "LLVM 22 clang not found") {
+		t.Fatalf("native ARM64 source test did not fail for missing LLVM 22: %v\n%s", err, output)
+	}
+}
+
 // Compile the generated Mach-O assembly on every LLVM host; only execution
 // needs Darwin/ARM64. No test or implementation reads a Go object format.
 func nativeCompileAndRun(t *testing.T, assembly, harness string) {
 	t.Helper()
-	clang, err := exec.LookPath("clang")
-	if err != nil {
-		t.Skip("clang not installed")
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
 	}
 	dir := t.TempDir()
 	src := filepath.Join(dir, "native.s")
@@ -181,12 +204,13 @@ func TestNativeARM64RejectsUnsupportedSource(t *testing.T) {
 		{"empty", "", "no TEXT"},
 		{"data only", "GLOBL ·p(SB), RODATA, $8\n", "requires TEXT"},
 		{"invalid local name", "TEXT bad-name<>(SB), NOSPLIT, $0\nRET\n", "file-local"},
-		{"duplicate label", prefix + "here:\nRET\nhere:\nRET\n", "duplicate native label"},
+		{"duplicate label", prefix + "here:\nRET\nhere:\nRET\n", `label "here" multiply defined`},
 		{"invalid global name", prefix + "RET\nGLOBL p<>(SB), RODATA, $8\n", "package global"},
 		{"duplicate global", prefix + "RET\nGLOBL ·p(SB), RODATA, $8\nGLOBL ·p(SB), RODATA, $8\n", "duplicate native GLOBL"},
 		{"empty global", prefix + "RET\nGLOBL ·p(SB), RODATA, $0\n", "GLOBL size"},
 		{"huge global", prefix + "RET\nGLOBL ·p(SB), RODATA, $67108865\n", "GLOBL size"},
-		{"data width", prefix + "RET\nGLOBL ·p(SB), RODATA, $8\nDATA ·p(SB)/3, $1\n", "DATA width"},
+		// The shared DATA grammar rejects this before native lowering.
+		{"data width", prefix + "RET\nGLOBL ·p(SB), RODATA, $8\nDATA ·p(SB)/3, $1\n", "DATA integer requires width 1, 2, 4 or 8"},
 		{"data string", prefix + "RET\nGLOBL ·p(SB), RODATA, $8\nDATA ·p(SB)/3, $\"abc\"\n", "source syntax"},
 		{"block comment", prefix + "/* ignored */ RET\n", "source syntax"},
 		{"FP to FP integer move", prefix + "MOVD F0, R0\n", "unsupported native register"},
@@ -237,6 +261,17 @@ func TestNativeARM64RejectsUnsupportedSource(t *testing.T) {
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 			assembly, data, err := TranslateNativeARM64Source([]byte(tc.source), map[string]string{"imported": "strlen"}, "probe")
+			if tc.name == "data only" {
+				if err != nil || len(data) != 1 || data[0].Size != 8 || assembly == "" {
+					t.Fatal("legal BSS-only source rejected", err, data, assembly)
+				}
+				nativePhysicalOriginalObject(t, "darwin", "arm64", "#include \"textflag.h\"\n"+tc.source)
+				ir := nativeAMD64PhysicalObjects(t, tc.source, NativeOptions{GOOS: "darwin", GOARCH: "arm64", PackagePath: "probe"})
+				if !strings.Contains(ir, "zeroinitializer") || strings.Contains(ir, "define ") {
+					t.Fatal("BSS-only source acquired a fabricated function", ir)
+				}
+				return
+			}
 			if err == nil || !strings.Contains(err.Error(), tc.want) {
 				t.Fatalf("err=%v; want %q", err, tc.want)
 			}
diff --git a/native_authority.go b/native_authority.go
new file mode 100644
index 000000000..49af059b6
--- /dev/null
+++ b/native_authority.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "fmt"
+
+// Native source authorities describe different complete source/object joins.
+// Choosing one dispatch branch cannot silently discard the other authority.
+func mixedNativeAuthorityContext() error {
+	return fmt.Errorf("%w: numerical-read and ARM64 byte-carrier authorities cannot be combined", ErrProbeNeedsContext)
+}
+
+func (source *GoX86NumericalReadSource) revokeNumericalSource() {
+	if source == nil {
+		return
+	}
+	source.mu.Lock()
+	defer source.mu.Unlock()
+	if source.identity == source {
+		source.ready = false
+	}
+}
+
+func rejectMixedNativeAuthorities(binding *GoX86NumericalReadBinding, carrier *GoARM64ByteCarrierSource) error {
+	if binding == nil || carrier == nil {
+		return nil
+	}
+	// Do not hold either source lock while entering the other source. A copied
+	// token is not allowed to revoke the original token's unrelated live owner.
+	if binding.originalBinding == binding && binding.source == binding.originalSource {
+		binding.source.revokeNumericalSource()
+	}
+	carrier.revokeCarrier()
+	return mixedNativeAuthorityContext()
+}
diff --git a/native_authority_exclusion_go127_test.go b/native_authority_exclusion_go127_test.go
new file mode 100644
index 000000000..ddbf4b3ae
--- /dev/null
+++ b/native_authority_exclusion_go127_test.go
@@ -0,0 +1,152 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Each negative replay starts with an actual successful, independently sealed
+// authority. A foreign nonnil token must not be silently ignored by dispatch.
+func TestNativeAuthorityARM64RejectsNumericalReadBinding(t *testing.T) {
+	directory, packagePath, _ := arm64ByteCarrierFixture(t)
+	declarations, err := os.ReadFile(filepath.Join(directory, "decl.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "original_arm64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, packagePath, string(declarations))
+	request := arm64ByteCarrierRequest(t, directory, packagePath)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			lease, release := runtimeOracleStageContext(t)
+			defer release()
+			source, err := CaptureGoARM64ByteCarrierSource(lease, request)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer source.Close()
+			triple := "aarch64-unknown-linux-gnu"
+			ir, err := arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), triple, nil)
+			if err != nil || ir == "" {
+				t.Fatal("actual single-authority consumer precondition", err)
+			}
+			calls := 0
+			resolve := testResolveSym(pkg.Path)
+			ir, err = arm64ByteCarrierTranslateAPI(t, api, source, pkg, string(assembly), triple,
+				func(_ *File, options *Options, goOptions *GoModuleOptions) {
+					foreign := &GoX86NumericalReadBinding{}
+					options.NumericalReads, goOptions.NumericalReads = foreign, foreign
+					callback := func(symbol string) string {
+						calls++
+						return resolve(symbol)
+					}
+					options.ResolveSym, goOptions.ResolveSym = callback, callback
+				})
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || calls != 0 {
+				t.Errorf("mixed native authorities reached callbacks or returned output: calls=%d error=%v", calls, err)
+			}
+			if !errors.Is(source.Verify(lease), ErrProbeNeedsContext) {
+				t.Error("mixed-authority failure did not revoke the actual ARM64 source")
+			}
+		})
+	}
+}
+
+func TestNativeAuthorityNumericalRejectsARM64Source(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg, file, unbound, create := numericalConsumerFactory(t, arch)
+			for _, api := range []string{"text", "context", "go-module", "binding"} {
+				t.Run(api, func(t *testing.T) {
+					source, options := create(t)
+					positiveAPI := api
+					if api == "binding" {
+						positiveAPI = "text"
+					}
+					if numericalFamilyTranslate(t, positiveAPI, pkg, file, options) == "" {
+						t.Fatal("actual single-authority consumer returned no output")
+					}
+					calls := 0
+					callback := func(symbol string) string {
+						calls++
+						return options.NumericalReads.resolve(symbol)
+					}
+					foreign := &GoARM64ByteCarrierSource{}
+					mixed := options
+					mixed.ARM64ByteCarrierSource, mixed.ResolveSym = foreign, callback
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var err error
+					output := false
+					switch api {
+					case "text":
+						var ir string
+						ir, err = Translate(file, mixed)
+						output = ir != ""
+					case "context":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, mixed)
+						if !module.IsNil() {
+							output = true
+							module.Dispose()
+						}
+					case "go-module":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(context, pkg, numericalWrapperOriginal(t, source), GoModuleOptions{
+							FileName: source.request.AssemblyFile, GOOS: "linux", GOARCH: arch,
+							TargetTriple: options.TargetTriple, ResolveSym: callback,
+							NumericalReads: options.NumericalReads, ARM64ByteCarrierSource: foreign,
+						})
+						if result != nil {
+							output = true
+							if !result.Module.IsNil() {
+								result.Module.Dispose()
+							}
+						}
+					case "binding":
+						request := unbound
+						request.ARM64ByteCarrierSource, request.ResolveSym = foreign, callback
+						var result Options
+						result, err = source.BindNumericalReads(options.NumericalReads.context, pkg, file, request)
+						output = result.NumericalReads != nil
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) || output || calls != 0 {
+						t.Errorf("mixed native authorities reached callbacks or returned output: calls=%d error=%v", calls, err)
+					}
+					if !errors.Is(source.Verify(options.NumericalReads.context), ErrProbeNeedsContext) {
+						t.Error("mixed-authority failure did not revoke the actual numerical source")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestNativeAuthorityNumericalPrivateSealRejectsARM64Source(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, _, _, create := numericalConsumerFactory(t, arch)
+			source, options := create(t)
+			binding := options.NumericalReads
+			if err := binding.verify(); err != nil {
+				t.Fatal("actual original numerical seal precondition", err)
+			}
+			binding.options.ARM64ByteCarrierSource = &GoARM64ByteCarrierSource{}
+			if !errors.Is(binding.verify(), ErrProbeNeedsContext) {
+				t.Error("private numerical seal silently retained a foreign ARM64 authority")
+			}
+			if !errors.Is(source.Verify(binding.context), ErrProbeNeedsContext) {
+				t.Error("mixed private seal did not permanently revoke its numerical source")
+			}
+		})
+	}
+}
diff --git a/native_c_tools_darwin_arm64_test.go b/native_c_tools_darwin_arm64_test.go
new file mode 100644
index 000000000..bead0c99f
--- /dev/null
+++ b/native_c_tools_darwin_arm64_test.go
@@ -0,0 +1,36 @@
+//go:build darwin && arm64
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestDarwinNativeARM64CompilerUsesActualSelectedSDK(t *testing.T) {
+	_, _, compiler, runner := arm64FPPairRuntimeTools(t)
+	if len(runner) != 0 {
+		t.Fatal("native Darwin compiler acquired a cross-runtime runner")
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "/usr/bin/xcrun", "--sdk", "macosx", "--show-sdk-path")
+	command.Env = os.Environ()
+	output, stderr, err := runtimeOracleMachineOutput(ctx, command)
+	if err != nil || len(stderr) != 0 || !strings.HasSuffix(string(output), "\n") {
+		t.Fatalf("independent actual SDK query: %v\n%s%s", err, output, stderr)
+	}
+	root, err := filepath.EvalSymlinks(strings.TrimSuffix(string(output), "\n"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"--no-default-config", "-isysroot", root}
+	if !reflect.DeepEqual(compiler[1:], want) {
+		t.Fatalf("native compiler flags=%q want actual SDK flags=%q", compiler[1:], want)
+	}
+	t.Logf("actual native LLVM22 compiler=%q SDK=%q flags=%q", compiler[0], root, compiler[1:])
+}
diff --git a/native_call_table_terminator_test.go b/native_call_table_terminator_test.go
new file mode 100644
index 000000000..f901bad14
--- /dev/null
+++ b/native_call_table_terminator_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+func TestNativeCallTableTerminatorSourceAndModule(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			ops := []string{"CALL"}
+			if arch == "arm64" {
+				ops = append(ops, "BL")
+			}
+			for _, op := range ops {
+				for _, slots := range []int{4, 2000} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%d", goos, arch, op, slots), func(t *testing.T) {
+						source := "#include \"textflag.h\"\nTEXT callbackTable(SB),NOSPLIT|NOFRAME,$0-0\n" +
+							strings.Repeat(op+" target(SB)\n", slots)
+						listing := nativePhysicalOriginalObject(t, goos, arch, source)
+						if strings.Count(listing, "\tCALL\t")+strings.Count(listing, "\tBL\t") != slots {
+							t.Fatal("original Go table lost its complete call inventory", listing)
+						}
+						opts := NativeOptions{GOOS: goos, GOARCH: arch, PackagePath: "probe",
+							Imports:     map[string]string{"target": "machine_target"},
+							CodeEntries: map[string]string{"callbackTable": "probe.callback_table"}}
+						assembly, _, err := TranslateNativeSource([]byte(source), opts)
+						if err != nil {
+							t.Fatal("original Go table rejected by source formatter", err)
+						}
+						ir := nativeAMD64PhysicalObjects(t, source, opts)
+						trap, width, trapSize := "\tud2\n", 5, 2
+						if arch == "arm64" {
+							trap, width, trapSize = "\tbrk #0\n", 4, 4
+						}
+						if !strings.Contains(assembly, trap) || strings.Contains(assembly, "\tret") ||
+							!strings.Contains(ir, "naked noinline") {
+							t.Fatal("source/module continuation differs or invented a return/prototype", assembly, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							code := nativeAMD64ObjectCode(t, goos, ir, level)
+							end := slots * width
+							if len(code) < end+trapSize {
+								t.Fatalf("short table object: %d bytes", len(code))
+							}
+							for slot := 0; slot < slots; slot++ {
+								position := slot * width
+								if arch == "amd64" && code[position] != 0xe8 ||
+									arch == "arm64" && binary.LittleEndian.Uint32(code[position:position+4])&0xfc000000 != 0x94000000 {
+									t.Fatalf("%s call slot %d changed at byte %d", level, slot, position)
+								}
+							}
+							if arch == "amd64" && (code[end] != 0x0f || code[end+1] != 0x0b) ||
+								arch == "arm64" && binary.LittleEndian.Uint32(code[end:end+4]) != 0xd4200000 {
+								t.Fatalf("%s explicit trap moved the final slot boundary", level)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestNativeCallTableRetainsUnprovedContinuationGuards(t *testing.T) {
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			prefix := "TEXT callbackTable(SB),NOSPLIT|NOFRAME,$0-0\n"
+			move := "MOVQ AX,DX\n"
+			if arch == "arm64" {
+				move = "MOVD R0,R1\n"
+			}
+			for _, row := range []struct{ name, source string }{
+				{"unknown callee", prefix + "CALL unknown(SB)\n"},
+				{"invalid operand", prefix + "CALL $1\n"},
+				{"open continuation", prefix + "CALL target(SB)\n" + move},
+				{"Go arguments", strings.Replace(prefix, "$0-0", "$0-8", 1) + "CALL target(SB)\n"},
+				{"missing NOSPLIT", strings.Replace(prefix, "NOSPLIT|", "", 1) + "CALL target(SB)\n"},
+				{"data callee", prefix + "CALL ·data(SB)\n"},
+			} {
+				t.Run(goos+"/"+arch+"/"+row.name, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					mod, err := TranslateNativeModule(ctx, []byte(row.source), NativeOptions{
+						GOOS: goos, GOARCH: arch, PackagePath: "probe",
+						Imports:     map[string]string{"target": "machine_target", "·data": "data_object"},
+						CodeEntries: map[string]string{"callbackTable": "probe.callback_table"}})
+					if err == nil {
+						mod.Dispose()
+						t.Fatal("call-table role acquired an unproved continuation or callee")
+					}
+					if !mod.IsNil() {
+						t.Fatal("rejected source returned a partial module")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/native_code_entries.go b/native_code_entries.go
new file mode 100644
index 000000000..77fd9c7f0
--- /dev/null
+++ b/native_code_entries.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+var nativeCodeObjectName = regexp.MustCompile(`^[A-Za-z_][A-Za-z_0-9.]*$`)
+
+// A bound bare TEXT is an address-only native entry, never an
+// inferred Go declaration or C prototype. The physical backend validates
+// its complete body and assembler-managed frame independently.
+func validateNativeCodeEntry(fn Func, opts NativeOptions) error {
+	if !nativeName.MatchString(fn.Sym) || len(fn.Instrs) < 2 {
+		return fmt.Errorf("native code entry requires complete bare TEXT: %s", fn.Sym)
+	}
+	_, err := nativeTextFrame(fn, opts)
+	return err
+}
+
+func validateNativeCodeBindings(f *File, opts NativeOptions) error {
+	seen := make(map[string]bool, len(opts.CodeEntries))
+	for source, object := range opts.CodeEntries {
+		if !nativeName.MatchString(source) || !nativeCodeObjectName.MatchString(object) || strings.HasPrefix(object, "__plan9_native_") {
+			return fmt.Errorf("unsupported native code entry binding %q -> %q", source, object)
+		}
+		if seen[object] {
+			return fmt.Errorf("duplicate native code entry object %q", object)
+		}
+		seen[object] = true
+		if _, imported := opts.Imports[source]; imported {
+			return fmt.Errorf("native code entry collides with import identity %q", source)
+		}
+		for _, alias := range opts.Imports {
+			if object == alias {
+				return fmt.Errorf("native code entry collides with native import %q", object)
+			}
+		}
+		found := false
+		for _, fn := range f.Funcs {
+			found = found || fn.Sym == source
+		}
+		if !found {
+			return fmt.Errorf("native code entry has no source TEXT %q", source)
+		}
+		for _, g := range f.Globl {
+			if object == opts.PackagePath+"."+strings.TrimPrefix(g.Sym, "·") {
+				return fmt.Errorf("native code entry collides with DATA %q", object)
+			}
+		}
+	}
+	return nil
+}
diff --git a/native_code_entries_test.go b/native_code_entries_test.go
new file mode 100644
index 000000000..70c381bd3
--- /dev/null
+++ b/native_code_entries_test.go
@@ -0,0 +1,184 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+func nativeCodeEntryOptions(goos, arch string) NativeOptions {
+	return NativeOptions{
+		GOOS: goos, GOARCH: arch, PackagePath: "probe",
+		Imports:     map[string]string{"imported": "strlen"},
+		CodeEntries: map[string]string{"strlen": "probe.native_strlen"},
+	}
+}
+
+func TestNativeCodeEntryTailStubFamily(t *testing.T) {
+	rootOutput, err := exec.Command("go", "env", "GOROOT").CombinedOutput()
+	if err != nil {
+		t.Fatalf("actual Go GOROOT: %v\n%s", err, rootOutput)
+	}
+	goRoot := strings.TrimSpace(string(rootOutput))
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			ops := []string{"JMP"}
+			if arch == "arm64" {
+				ops = append(ops, "B")
+			}
+			for _, op := range ops {
+				for _, frame := range []string{"$0", "$0-0"} {
+					for _, deadRet := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%s/%s/%s/ret-%v", goos, arch, op, frame, deadRet), func(t *testing.T) {
+							source := fmt.Sprintf("#include \"textflag.h\"\nTEXT strlen(SB), NOSPLIT|NOFRAME, %s\n%s imported(SB)\n", frame, op)
+							if deadRet {
+								source += "RET\n"
+							}
+							dir := t.TempDir()
+							file := filepath.Join(dir, "entry.s")
+							if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+								t.Fatal(err)
+							}
+							goCmd := exec.Command("go", "tool", "asm", "-I", filepath.Join(goRoot, "pkg", "include"), "-o", filepath.Join(dir, "go.o"), file)
+							goCmd.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS="+goos, "GOARCH="+arch)
+							if out, err := goCmd.CombinedOutput(); err != nil {
+								t.Fatalf("actual Go assembler: %v\n%s", err, out)
+							}
+							opts := nativeCodeEntryOptions(goos, arch)
+							asm, _, err := TranslateNativeSource([]byte(source), opts)
+							if err != nil {
+								t.Fatal(err)
+							}
+							if !strings.Contains(asm, "probe.native_strlen") || !strings.Contains(asm, "strlen") {
+								t.Fatal(asm)
+							}
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							mod, err := TranslateNativeModule(ctx, []byte(source), opts)
+							if err != nil {
+								t.Fatal(err)
+							}
+							defer mod.Dispose()
+							entry := mod.NamedFunction("probe.native_strlen")
+							if entry.IsNil() || entry.Linkage() != llvm.ExternalLinkage || mod.NamedGlobal("strlen").IsNil() {
+								t.Fatalf("code token and foreign import identity collided:\n%s", mod.String())
+							}
+							assembly := nativeModuleAssembly(t, mod.String(), "default<O2>")
+							asmFile := filepath.Join(dir, "llvm.s")
+							if err := os.WriteFile(asmFile, []byte(assembly), 0600); err != nil {
+								t.Fatal(err)
+							}
+							clang := findLLVM22Tool("clang")
+							if clang == "" {
+								t.Fatal("LLVM 22 clang is required")
+							}
+							if out, err := exec.Command(clang, "--target="+mod.Target(), "-c", asmFile, "-o", filepath.Join(dir, "llvm.o")).CombinedOutput(); err != nil {
+								t.Fatalf("LLVM 22 object: %v\n%s\n%s", err, out, assembly)
+							}
+							nativeFile := filepath.Join(dir, "native.s")
+							if err := os.WriteFile(nativeFile, []byte(asm), 0600); err != nil {
+								t.Fatal(err)
+							}
+							if out, err := exec.Command(clang, "--target="+mod.Target(), "-c", nativeFile, "-o", filepath.Join(dir, "native.o")).CombinedOutput(); err != nil {
+								t.Fatalf("LLVM 22 standalone native source object: %v\n%s\n%s", err, out, asm)
+							}
+							if goos == runtime.GOOS && arch == runtime.GOARCH {
+								harness := filepath.Join(dir, "main.c")
+								prefix := ""
+								if goos == "darwin" {
+									prefix = "_"
+								}
+								code := fmt.Sprintf("extern unsigned long token(const char *) __asm(\"%sprobe.native_strlen\");\nint main(void){return token(\"\")!=0 || token(\"native token\")!=12;}\n", prefix)
+								if err := os.WriteFile(harness, []byte(code), 0600); err != nil {
+									t.Fatal(err)
+								}
+								exe := filepath.Join(dir, "probe")
+								ctx, cancel := runtimeOracleStageContext(t)
+								command := runtimeOracleNativeCCommand(t, ctx, clang, "-O2", harness, filepath.Join(dir, "llvm.o"), "-o", exe)
+								out, err := runtimeOracleCombinedOutput(ctx, command)
+								cancel()
+								if err != nil {
+									t.Fatalf("native C link: %v\n%s", err, out)
+								}
+								if out, err := exec.Command(exe).CombinedOutput(); err != nil {
+									t.Fatalf("native C call: %v\n%s", err, out)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestNativeCodeEntryRejectsUnprovedContracts(t *testing.T) {
+	const source = "TEXT strlen(SB), NOSPLIT|NOFRAME, $0\nJMP imported(SB)\nRET\n"
+	for _, arch := range []string{"amd64", "arm64"} {
+		for _, tc := range []struct {
+			name, src string
+			entries   map[string]string
+		}{
+			{"absent", source, nil},
+			{"wrong entry", source, map[string]string{"other": "probe.native_strlen"}},
+			{"import collision", source, map[string]string{"strlen": "strlen"}},
+			{"unsafe symbol", source, map[string]string{"strlen": "bad\n.globl injected"}},
+			{"Go function", strings.ReplaceAll(source, "strlen(SB)", "·strlen(SB)"), map[string]string{"·strlen": "probe.native_strlen"}},
+			{"no NOFRAME", strings.ReplaceAll(source, "|NOFRAME", ""), map[string]string{"strlen": "probe.native_strlen"}},
+			{"nonzero frame", strings.ReplaceAll(source, "$0", "$16"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"Go argument frame", strings.ReplaceAll(source, "$0", "$0-8"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"call is not tail", strings.ReplaceAll(source, "JMP", "CALL"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"indirect tail", strings.ReplaceAll(source, "imported(SB)", "(R0)"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"unknown target", strings.ReplaceAll(source, "imported", "unknown"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"target addend", strings.ReplaceAll(source, "imported(SB)", "imported+8(SB)"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"import identity shadow", strings.ReplaceAll(source, "strlen(SB)", "imported(SB)"), map[string]string{"imported": "probe.native_strlen"}},
+			{"data before tail", strings.ReplaceAll(source, "JMP", "MOVD R0, R1\nJMP"), map[string]string{"strlen": "probe.native_strlen"}},
+			{"dead data is not leaf proof", source + "MOVD R0, R1\n", map[string]string{"strlen": "probe.native_strlen"}},
+			{"unbound sibling", source + "TEXT other(SB), NOSPLIT|NOFRAME, $0\nJMP imported(SB)\n", map[string]string{"strlen": "probe.native_strlen"}},
+			{"duplicate export", source + "TEXT other(SB), NOSPLIT|NOFRAME, $0\nJMP imported(SB)\n", map[string]string{"strlen": "probe.native_strlen", "other": "probe.native_strlen"}},
+		} {
+			t.Run(arch+"/"+tc.name, func(t *testing.T) {
+				opts := nativeCodeEntryOptions("linux", arch)
+				opts.CodeEntries = tc.entries
+				physical := tc.name == "no NOFRAME" || tc.name == "call is not tail" ||
+					arch == "amd64" && tc.name == "nonzero frame" ||
+					arch == "arm64" && (tc.name == "data before tail" || tc.name == "dead data is not leaf proof")
+				if physical {
+					nativePhysicalOriginalObject(t, "linux", arch, "#include \"textflag.h\"\n"+tc.src)
+					assembly, _, err := TranslateNativeSource([]byte(tc.src), opts)
+					if err != nil {
+						t.Fatal("explicit physical entry rejected", err)
+					}
+					nativePhysicalAssemblyObject(t, assembly, arch)
+					if tc.name != "dead data is not leaf proof" {
+						ir := nativeAMD64PhysicalObjects(t, tc.src, opts)
+						if !strings.Contains(ir, "naked noinline") {
+							t.Fatal("physical entry acquired a typed call convention", ir)
+						}
+						return
+					}
+					// The original dead instruction remains legal assembly, but
+					// does not complete a returning LLVM carrier.
+				} else if asm, _, err := TranslateNativeSource([]byte(tc.src), opts); err == nil || asm != "" {
+					t.Fatalf("accepted unproved contract: %v\n%s", err, asm)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateNativeModule(ctx, []byte(tc.src), opts)
+				if err == nil {
+					mod.Dispose()
+					t.Fatal("accepted unproved code address")
+				}
+				if !mod.IsNil() {
+					t.Fatal("error returned a partial module")
+				}
+			})
+		}
+	}
+}
diff --git a/native_code_entry_return_test.go b/native_code_entry_return_test.go
new file mode 100644
index 000000000..6a56c2df3
--- /dev/null
+++ b/native_code_entry_return_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+func nativeReturnEntrySource(frame string) []byte {
+	return []byte(fmt.Sprintf("#include \"textflag.h\"\nTEXT rawEntry(SB), NOSPLIT|NOFRAME, %s\nRET\n"+
+		"GLOBL ·entry(SB), RODATA|NOPTR, $8\nDATA ·entry(SB)/8, $rawEntry(SB)\n", frame))
+}
+
+// The map binds an address token, never an inferred Go/C function prototype.
+// The original Go assembler and both LLVM object levels see the same source.
+func TestNativeCodeEntryReturnLeafObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			for _, frame := range []string{"$0", "$0-0"} {
+				t.Run(goos+"/"+arch+"/"+frame, func(t *testing.T) {
+					source := nativeReturnEntrySource(frame)
+					directory := t.TempDir()
+					file := filepath.Join(directory, "entry.s")
+					if err := os.WriteFile(file, source, 0o600); err != nil {
+						t.Fatal(err)
+					}
+					stage, cancel := runtimeOracleStageContext(t)
+					output, err := goasmcmd.Run(stage, directory, append(os.Environ(),
+						"GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off",
+						"GOOS="+goos, "GOARCH="+arch), filepath.Join(runtime.GOROOT(), "bin/go"),
+						"tool", "asm", "-p", "probe", "-I", filepath.Join(runtime.GOROOT(), "pkg/include"),
+						"-o", filepath.Join(directory, "original.o"), file)
+					cancel()
+					if err != nil {
+						t.Fatalf("actual Go assembler: %v\n%s", err, output)
+					}
+					t.Log("complete original Go assembly object accepted; no native execution claimed")
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					mod, err := TranslateNativeModule(ctx, source, NativeOptions{
+						GOOS: goos, GOARCH: arch, PackagePath: "probe",
+						CodeEntries: map[string]string{"rawEntry": "probe.native_return"},
+					})
+					if err != nil {
+						t.Fatal("closed return-only address entry rejected", err)
+					}
+					defer mod.Dispose()
+					entry := mod.NamedFunction("probe.native_return")
+					global := mod.NamedGlobal("probe.entry")
+					if entry.IsNil() || global.IsNil() {
+						t.Fatal("missing original code or DATA identity")
+					}
+					initializer := global.Initializer()
+					if initializer.IsNil() || initializer.OperandsCount() != 1 || initializer.Operand(0) != entry {
+						t.Fatal("DATA did not retain its exact code-symbol relocation")
+					}
+					if !strings.Contains(mod.String(), "naked noinline") || strings.Contains(mod.String(), "module asm") {
+						t.Fatal("entry lost its existing address-only carrier", mod.String())
+					}
+					if err := llvm.VerifyModule(mod, llvm.ReturnStatusAction); err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, mod.Target(), mod.String(), level)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestNativeCodeEntryReturnLeafRejectsUnprovedContracts(t *testing.T) {
+	for _, arch := range []string{"amd64", "arm64"} {
+		source := string(nativeReturnEntrySource("$0-0"))
+		registerAccess, frameAccess := "MOVQ AX,DX", "MOVQ value+0(FP),AX"
+		if arch == "arm64" {
+			registerAccess, frameAccess = "MOVD R0,R1", "MOVD value+0(FP),R0"
+		}
+		for _, row := range []struct{ name, source string }{
+			{"missing NOFRAME", strings.Replace(source, "|NOFRAME", "", 1)},
+			{"missing NOSPLIT", strings.Replace(source, "NOSPLIT|", "", 1)},
+			{"nonzero frame", strings.Replace(source, "$0-0", "$16-0", 1)},
+			{"Go argument frame", strings.Replace(source, "$0-0", "$0-8", 1)},
+			{"package Go symbol", strings.ReplaceAll(source, "rawEntry(SB)", "·rawEntry(SB)")},
+			{"return changes stack", strings.Replace(source, "\nRET\n", "\nRET $8\n", 1)},
+			{"register access", strings.Replace(source, "\nRET\n", "\n"+registerAccess+"\nRET\n", 1)},
+			{"FP access", strings.Replace(source, "\nRET\n", "\n"+frameAccess+"\nRET\n", 1)},
+			{"unowned sibling", source + "\nTEXT other(SB), NOSPLIT|NOFRAME, $0-0\nRET\n"},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				opts := NativeOptions{
+					GOOS: "linux", GOARCH: arch, PackagePath: "probe",
+					CodeEntries: map[string]string{"rawEntry": "probe.native_return"},
+				}
+				if row.name == "missing NOFRAME" || row.name == "register access" ||
+					arch == "amd64" && row.name == "nonzero frame" {
+					nativePhysicalOriginalObject(t, "linux", arch, row.source)
+					ir := nativeAMD64PhysicalObjects(t, row.source, opts)
+					if !strings.Contains(ir, "naked noinline") || !strings.Contains(ir, "probe.native_return") {
+						t.Fatal("physical entry lost its exact address-only identity", ir)
+					}
+					return
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateNativeModule(ctx, []byte(row.source), opts)
+				if err == nil {
+					mod.Dispose()
+					t.Fatal("unproved source inherited the closed address-entry role")
+				}
+				if !mod.IsNil() {
+					t.Fatal("rejected source returned a partial module")
+				}
+			})
+		}
+	}
+}
diff --git a/native_data_only_test.go b/native_data_only_test.go
new file mode 100644
index 000000000..0b2437634
--- /dev/null
+++ b/native_data_only_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+func TestNativeDataOnlyTranslationUnits(t *testing.T) {
+	const source = "#include \"textflag.h\"\nGLOBL ·entry(SB),RODATA|NOPTR,$8\nDATA ·entry(SB)/8,$target(SB)\n"
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			t.Run(goos+"/"+arch, func(t *testing.T) {
+				nativePhysicalOriginalObject(t, goos, arch, source)
+				opts := NativeOptions{GOOS: goos, GOARCH: arch, PackagePath: "probe",
+					Imports: map[string]string{"target": "component_target"}}
+				assembly, data, err := TranslateNativeSource([]byte(source), opts)
+				if err != nil || len(data) != 1 || data[0].Size != 8 || !strings.Contains(assembly, "component_target") {
+					t.Fatal("complete data-only source lost its exact bound address", err, data, assembly)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				mod, err := TranslateNativeModule(ctx, []byte(source), opts)
+				if err != nil {
+					t.Fatal("complete data-only module rejected", err)
+				}
+				defer mod.Dispose()
+				entry, target := mod.NamedGlobal("probe.entry"), mod.NamedGlobal("component_target")
+				if !mod.FirstFunction().IsNil() || entry.IsNil() || target.IsNil() || !entry.IsGlobalConstant() ||
+					entry.Initializer().OperandsCount() != 1 || entry.Initializer().Operand(0) != target {
+					t.Fatal("data address became a guessed function or lost relocation identity", mod.String())
+				}
+				if err := llvm.VerifyModule(mod, llvm.ReturnStatusAction); err != nil {
+					t.Fatal(err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc is required")
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, mod.Target(), mod.String(), level)
+				}
+			})
+		}
+	}
+	for _, row := range []struct{ name, source string }{
+		{"empty", ""},
+		{"no GLOBL", "DATA ·entry(SB)/8,$target(SB)\n"},
+		{"unknown symbol", strings.Replace(source, "$target(SB)", "$unknown(SB)", 1)},
+		{"symbol offset", strings.Replace(source, "$target(SB)", "$target+8(SB)", 1)},
+		{"narrow relocation", strings.Replace(source, "/8,", "/4,", 1)},
+		{"outside storage", strings.Replace(source, "DATA ·entry(SB)", "DATA ·entry+8(SB)", 1)},
+		{"overlap", source + "DATA ·entry(SB)/8,$1\n"},
+		{"foreign flag", strings.Replace(source, "RODATA|NOPTR", "RODATA|32", 1)},
+		{"unowned code entry", source},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			opts := NativeOptions{GOOS: "linux", GOARCH: "amd64", PackagePath: "probe",
+				Imports: map[string]string{"target": "component_target"}}
+			if row.name == "unowned code entry" {
+				opts.CodeEntries = map[string]string{"target": "component_target"}
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			mod, err := TranslateNativeModule(ctx, []byte(row.source), opts)
+			if err == nil {
+				mod.Dispose()
+				t.Fatal("unbound or malformed data acquired a native module")
+			}
+			if !mod.IsNil() {
+				t.Fatal("error returned a partial module")
+			}
+		})
+	}
+}
diff --git a/native_flags_test.go b/native_flags_test.go
new file mode 100644
index 000000000..6653141f5
--- /dev/null
+++ b/native_flags_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	llvm "github.com/xgo-dev/llvm"
+)
+
+func TestNativeFlagsAcceptGoIntegerGrammar(t *testing.T) {
+	for _, row := range []struct {
+		source  string
+		allowed []string
+		want    map[string]bool
+	}{
+		{"4", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true}},
+		{"512", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOFRAME": true}},
+		{"516", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"0x204", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"0X204", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"01004", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"0b1000000100", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"(1 << 9) + 4", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"NOSPLIT | 0x200", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true, "NOFRAME": true}},
+		{"NOSPLIT | NOSPLIT", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true}},
+		{"(4 * 3) & ~8", []string{"NOSPLIT", "NOFRAME"}, map[string]bool{"NOSPLIT": true}},
+		{"8", []string{"RODATA", "NOPTR"}, map[string]bool{"RODATA": true}},
+		{"0x10", []string{"RODATA", "NOPTR"}, map[string]bool{"NOPTR": true}},
+		{"24", []string{"RODATA", "NOPTR"}, map[string]bool{"RODATA": true, "NOPTR": true}},
+		{"(RODATA | NOPTR)", []string{"RODATA", "NOPTR"}, map[string]bool{"RODATA": true, "NOPTR": true}},
+		{"RODATA & ~RODATA", []string{"RODATA", "NOPTR"}, map[string]bool{}},
+		{"0x0", []string{"RODATA", "NOPTR"}, map[string]bool{}},
+	} {
+		t.Run(row.source, func(t *testing.T) {
+			got, err := nativeFlags(row.source, row.allowed...)
+			if err != nil || !reflect.DeepEqual(got, row.want) {
+				t.Fatalf("native flags %q: got %v, %v; want %v", row.source, got, err, row.want)
+			}
+		})
+	}
+}
+
+func TestNativeFlagsRejectEveryForeignBitAndMalformedExpression(t *testing.T) {
+	for _, role := range []struct {
+		name    string
+		allowed []string
+		bits    map[string]uint64
+		mask    uint64
+	}{
+		{"TEXT", []string{"NOSPLIT", "NOFRAME"}, map[string]uint64{"NOSPLIT": 4, "NOFRAME": 512}, 516},
+		{"GLOBL", []string{"RODATA", "NOPTR"}, map[string]uint64{"RODATA": 8, "NOPTR": 16}, 24},
+	} {
+		t.Run(role.name, func(t *testing.T) {
+			for value := uint64(0); value < 1024; value++ {
+				for _, source := range []string{strconv.FormatUint(value, 10), fmt.Sprintf("0x%x", value)} {
+					got, err := nativeFlags(source, role.allowed...)
+					if value & ^role.mask != 0 {
+						if err == nil || got != nil {
+							t.Fatalf("foreign %s bits accepted: %s => %v, %v", role.name, source, got, err)
+						}
+						continue
+					}
+					want := map[string]bool{}
+					for name, bit := range role.bits {
+						if value&bit != 0 {
+							want[name] = true
+						}
+					}
+					if err != nil || !reflect.DeepEqual(got, want) {
+						t.Fatalf("complete %s mask %s: got %v, %v; want %v", role.name, source, got, err, want)
+					}
+				}
+			}
+			for bit := uint(10); bit < 64; bit++ {
+				source := fmt.Sprintf("0x%x", role.mask|uint64(1)<<bit)
+				if got, err := nativeFlags(source, role.allowed...); err == nil || got != nil {
+					t.Fatalf("high foreign %s bit accepted: %s => %v, %v", role.name, source, got, err)
+				}
+			}
+			for _, source := range []string{"", "4|", "|4", "4||512", "4.0", "unknown", "NOSPLIT_extra", "0x204junk", "18446744073709551616", "-4", "~0"} {
+				if got, err := nativeFlags(source, role.allowed...); err == nil || got != nil {
+					t.Fatalf("malformed/foreign %s flags accepted: %q => %v, %v", role.name, source, got, err)
+				}
+			}
+		})
+	}
+}
+
+func TestNativeFlagsStrictCPPFeedsBothNativeConsumers(t *testing.T) {
+	const source = "#include \"textflag.h\"\nTEXT tail(SB),NOSPLIT|NOFRAME,$0\nJMP imported(SB)\n" +
+		"GLOBL ·entry(SB),RODATA|NOPTR,$8\nDATA ·entry(SB)/8,$tail(SB)\n"
+	// Independent Go textflag.h values: neither the preprocessor's producer
+	// nor the native decoder's implementation supplies this oracle.
+	const header = "#define NOSPLIT 4\n#define NOFRAME 512\n#define RODATA 8\n#define NOPTR 16\n"
+	expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+		FileName: "callback.s",
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if parent != "callback.s" || name != "textflag.h" {
+				return "", nil, fmt.Errorf("unexpected native include %q from %q", name, parent)
+			}
+			return "textflag.h", []byte(header), nil
+		},
+	})
+	if err != nil || strings.Contains(expanded, "NOSPLIT") || strings.Contains(expanded, "RODATA") {
+		t.Fatal("strict CPP did not produce its actual numeric flag source", expanded, err)
+	}
+	for _, goos := range []string{"linux", "darwin"} {
+		for _, arch := range []string{"amd64", "arm64"} {
+			t.Run(goos+"/"+arch, func(t *testing.T) {
+				options := NativeOptions{GOOS: goos, GOARCH: arch, PackagePath: "probe",
+					Imports: map[string]string{"imported": "body"}, CodeEntries: map[string]string{"tail": "probe.tail"}}
+				want, wantData, err := TranslateNativeSource([]byte(source), options)
+				if err != nil {
+					t.Fatal("unchanged named-flag native source", err)
+				}
+				got, gotData, err := TranslateNativeSource([]byte(expanded), options)
+				if err != nil || got != want || !reflect.DeepEqual(gotData, wantData) {
+					t.Fatal("strict CPP flags changed complete native source/data", got, gotData, err)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateNativeModule(ctx, []byte(expanded), options)
+				if err != nil {
+					t.Fatal("strict CPP flags were not consumed by the native module", err)
+				}
+				defer module.Dispose()
+				entry := module.NamedGlobal("probe.entry")
+				if entry.IsNil() || !entry.IsGlobalConstant() || module.NamedFunction("probe.tail").IsNil() {
+					t.Fatal("numeric flags lost readonly storage or the explicitly bound native entry", module.String())
+				}
+			})
+		}
+	}
+}
+
+func TestNativeNumericFlagsKeepRequiredEntryBits(t *testing.T) {
+	for _, arch := range []string{"amd64", "arm64"} {
+		for _, flags := range []string{"0", "512", "4", "8", "516|32", "0x100000204"} {
+			t.Run(arch+"/"+flags, func(t *testing.T) {
+				source := "TEXT tail(SB)," + flags + ",$0\nJMP imported(SB)\n"
+				options := NativeOptions{GOOS: "linux", GOARCH: arch, PackagePath: "probe",
+					Imports: map[string]string{"imported": "body"}, CodeEntries: map[string]string{"tail": "probe.tail"}}
+				if flags == "4" {
+					// NOSPLIT remains required. An explicit zero Go frame may
+					// use the assembler's ordinary leaf frame policy.
+					nativePhysicalOriginalObject(t, "linux", arch, "#include \"textflag.h\"\n"+source)
+					nativeAMD64PhysicalObjects(t, source, options)
+					return
+				}
+				if output, data, err := TranslateNativeSource([]byte(source), options); err == nil || output != "" || data != nil {
+					t.Fatal("native code entry ignored missing/foreign flag bits", output, data, err)
+				}
+			})
+		}
+	}
+}
diff --git a/native_frame.go b/native_frame.go
new file mode 100644
index 000000000..1fdc28705
--- /dev/null
+++ b/native_frame.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type nativeFramePlan struct {
+	local  int64
+	saveBP bool
+}
+
+// Match current Go obj6's fixed-frame entry/return contract. Older host
+// compilers can build this backend; their historical frame sequences and
+// incoming FLAGS are not selected by the host SDK. Physical SP is independent
+// of logical Go parameter, result and caller permissions.
+func nativeTextFrame(fn Func, target NativeOptions) (nativeFramePlan, error) {
+	var plan nativeFramePlan
+	parts := strings.Split(fn.Instrs[0].Raw, ",")
+	if len(parts) != 3 || !strings.HasPrefix(strings.TrimSpace(parts[2]), "$") {
+		return plan, fmt.Errorf("native TEXT requires a complete fixed frame: %s", fn.Sym)
+	}
+	spec, err := parseTEXTFrameSpec(parts)
+	if target.GOARCH == "arm64" && (err != nil || spec.argSize != 0 || spec.frameSize != 0) {
+		return plan, fmt.Errorf("native ARM64 TEXT requires zero Go frame: %s", fn.Sym)
+	}
+	if err != nil || spec.argSize != 0 || spec.frameSize < 0 || spec.frameSize > 2147483639 || spec.frameSize%8 != 0 {
+		return plan, fmt.Errorf("native TEXT requires aligned fixed locals and zero Go arguments: %s", fn.Sym)
+	}
+	flags, err := nativeFlags(parts[1], "NOSPLIT", "NOFRAME")
+	if err != nil || !flags["NOSPLIT"] {
+		return plan, fmt.Errorf("native TEXT requires exact NOSPLIT/frame flags: %s", fn.Sym)
+	}
+	if target.GOARCH != "amd64" {
+		for _, ins := range fn.Instrs {
+			if (ins.Op == "CALL" || ins.Op == "BL") && !flags["NOFRAME"] {
+				return plan, fmt.Errorf("native ARM64 non-leaf TEXT requires NOFRAME: %s", fn.Sym)
+			}
+		}
+		return plan, nil
+	}
+	plan.local = spec.frameSize
+	hasCall := false
+	var stackDelta int64
+	for _, ins := range fn.Instrs {
+		hasCall = hasCall || ins.Op == "CALL"
+		if stack, known, err := x86StackWidthProperties(ins, "amd64"); known {
+			if err != nil {
+				return plan, err
+			}
+			if stack.mode == amd64StackPushValue || stack.mode == amd64StackPushFlags {
+				stackDelta += int64(stack.bits / 8)
+			} else {
+				stackDelta -= int64(stack.bits / 8)
+			}
+		} else if ins.Op == "ADJSP" && len(ins.Args) != 0 && ins.Args[0].Kind == OpImm {
+			stackDelta += ins.Args[0].Imm
+		}
+		if ins.Op == OpRET && stackDelta != 0 {
+			return plan, fmt.Errorf("native TEXT has unbalanced PUSH/POP: %s", fn.Sym)
+		}
+	}
+	plan.saveBP = !flags["NOFRAME"] && (plan.local != 0 || hasCall)
+	return plan, nil
+}
+
+func (p nativeFramePlan) prologue(out *strings.Builder) {
+	if p.saveBP {
+		out.WriteString("\tpushq %rbp\n\tmovq %rsp, %rbp\n")
+	}
+	if p.local != 0 {
+		fmt.Fprintf(out, "\tsubq $%d, %%rsp\n", p.local)
+	}
+}
+
+func (p nativeFramePlan) epilogue(out *strings.Builder) {
+	if p.local != 0 {
+		fmt.Fprintf(out, "\taddq $%d, %%rsp\n", p.local)
+	}
+	if p.saveBP {
+		out.WriteString("\tpopq %rbp\n")
+	}
+}
diff --git a/native_module.go b/native_module.go
index 2fd31d418..afc689fce 100644
--- a/native_module.go
+++ b/native_module.go
@@ -43,8 +43,12 @@ func TranslateNativeModule(ctx llvm.Context, src []byte, opts NativeOptions) (mo
 	globals := map[string]llvm.Value{}
 	imports := map[string]llvm.Value{}
 	for i, fn := range f.Funcs {
-		v := llvm.AddFunction(mod, fmt.Sprintf("__plan9_native_%d", i), carrierTy)
-		v.SetLinkage(llvm.InternalLinkage)
+		name, linkage := fmt.Sprintf("__plan9_native_%d", i), llvm.InternalLinkage
+		if object, bound := opts.CodeEntries[fn.Sym]; bound {
+			name, linkage = object, llvm.ExternalLinkage
+		}
+		v := llvm.AddFunction(mod, name, carrierTy)
+		v.SetLinkage(linkage)
 		for _, attr := range []string{"naked", "noinline"} {
 			v.AddFunctionAttr(ctx.CreateEnumAttribute(llvm.AttributeKindID(attr), 0))
 		}
@@ -90,6 +94,9 @@ func TranslateNativeModule(ctx llvm.Context, src []byte, opts NativeOptions) (mo
 			}
 		}
 		if alias, ok := opts.Imports[name]; ok {
+			if strings.HasPrefix(name, "·") && !data {
+				return llvm.Value{}, fmt.Errorf("native data binding is not a callable entry: %s", s)
+			}
 			if v, ok := imports[alias]; ok {
 				return v, nil
 			}
@@ -153,8 +160,7 @@ func TranslateNativeModule(ctx llvm.Context, src []byte, opts NativeOptions) (mo
 		if err = e.functionBody(&body, fn); err != nil {
 			return mod, err
 		}
-		last := string(fn.Instrs[len(fn.Instrs)-1].Op)
-		if last != "RET" && last != "JMP" && last != "B" {
+		if _, complete := nativeFunctionEnd(fn.Instrs[len(fn.Instrs)-1].Op, opts.GOARCH); !complete {
 			return mod, fmt.Errorf("native naked TEXT must end with RET or an unconditional branch: %s", fn.Sym)
 		}
 		// Escape literal x86 '$' immediates before adding LLVM template operands.
diff --git a/native_module_test.go b/native_module_test.go
index eebb62367..47ef653cf 100644
--- a/native_module_test.go
+++ b/native_module_test.go
@@ -70,10 +70,13 @@ int main(void){return call_entry("native ABI")!=10 || call_mixedEntry(5,0x400000
 
 func nativeModuleAssembly(t *testing.T, ir, pipeline string) string {
 	t.Helper()
-	for _, name := range []string{"opt", "llc"} {
-		if _, err := exec.LookPath(name); err != nil {
-			t.Skip(name + " unavailable")
-		}
+	opt := findLLVM22Tool("opt")
+	if opt == "" {
+		t.Fatal("LLVM 22 opt not found")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
 	}
 	dir := t.TempDir()
 	src := filepath.Join(dir, "native.ll")
@@ -82,10 +85,10 @@ func nativeModuleAssembly(t *testing.T, ir, pipeline string) string {
 	if err := os.WriteFile(src, []byte(ir), 0600); err != nil {
 		t.Fatal(err)
 	}
-	if b, err := exec.Command("opt", "-passes="+pipeline, "-verify-each", "-S", src, "-o", optimized).CombinedOutput(); err != nil {
+	if b, err := exec.Command(opt, "-passes="+pipeline, "-verify-each", "-S", src, "-o", optimized).CombinedOutput(); err != nil {
 		t.Fatalf("opt: %v\n%s\n%s", err, b, ir)
 	}
-	if b, err := exec.Command("llc", "-relocation-model=pic", optimized, "-o", out).CombinedOutput(); err != nil {
+	if b, err := exec.Command(llc, "-relocation-model=pic", optimized, "-o", out).CombinedOutput(); err != nil {
 		t.Fatalf("llc: %v\n%s\n%s", err, b, ir)
 	}
 	asm, err := os.ReadFile(out)
@@ -95,6 +98,41 @@ func nativeModuleAssembly(t *testing.T, ir, pipeline string) string {
 	return string(asm)
 }
 
+func TestNativeModuleToolPreflight(t *testing.T) {
+	const ir = `target triple = "x86_64-unknown-linux-gnu"
+define void @noop() {
+  ret void
+}
+`
+	assembly := nativeModuleAssembly(t, ir, "default<O2>")
+	if !strings.Contains(assembly, "noop") {
+		t.Fatalf("missing compiled function:\n%s", assembly)
+	}
+}
+
+func TestNativeNakedModuleRequiresLLVM22(t *testing.T) {
+	executable, err := os.Executable()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cmd := exec.Command(executable, "-test.run=^TestNativeModuleToolPreflight$", "-test.v")
+	for _, variable := range os.Environ() {
+		if !strings.HasPrefix(strings.ToUpper(variable), "LLVM_CONFIG=") {
+			cmd.Env = append(cmd.Env, variable)
+		}
+	}
+	cmd.Env = append(cmd.Env, "LLVM_CONFIG="+filepath.Join(t.TempDir(), "missing-llvm-config"))
+
+	output, err := cmd.CombinedOutput()
+	if err == nil {
+		t.Fatalf("native module test passed without required LLVM 22 tools:\n%s", output)
+	}
+	if !strings.Contains(string(output), "LLVM 22 opt not found") {
+		t.Fatalf("native module test did not fail for missing LLVM 22: %v\n%s", err, output)
+	}
+}
+
 func TestNativeNakedLinkAndReachability(t *testing.T) {
 	for _, arch := range []string{"amd64", "arm64"} {
 		t.Run(arch, func(t *testing.T) {
@@ -134,11 +172,11 @@ func TestNativeNakedLinkAndReachability(t *testing.T) {
 func TestNativeNakedModuleReject(t *testing.T) {
 	ctx := llvm.NewContext()
 	defer ctx.Dispose()
-	for _, src := range []string{"TEXT f<>(SB), NOSPLIT, $0\nBAD\n", "TEXT f<>(SB), NOSPLIT, $0\nMOVQ $1, AX\n", "TEXT f<>(SB), NOSPLIT, $0\nRET\nend:\n", "TEXT f<>(SB), NOSPLIT, $0\nJMP missing(SB)\n", "TEXT f<>(SB), NOSPLIT, $0\nRET\nGLOBL ·entry(SB), RODATA, $4\nDATA ·entry(SB)/8, $f<>(SB)\n"} {
+	for _, src := range []string{"TEXT f<>(SB), NOSPLIT, $0\nBAD\n", "TEXT f<>(SB), NOSPLIT, $0\nMOVQ $1, AX\n", "TEXT f<>(SB), NOSPLIT, $0\nRET\nend:\nMOVQ $1,AX\n", "TEXT f<>(SB), NOSPLIT, $0\nJMP missing(SB)\n", "TEXT f<>(SB), NOSPLIT, $0\nRET\nGLOBL ·entry(SB), RODATA, $4\nDATA ·entry(SB)/8, $f<>(SB)\n"} {
 		mod, err := TranslateNativeModule(ctx, []byte(src), NativeOptions{GOOS: "linux", GOARCH: "amd64", PackagePath: "probe"})
 		if err == nil {
 			mod.Dispose()
-			t.Fatal("accepted invalid source")
+			t.Fatalf("accepted invalid source: %q", src)
 		}
 		if mod != (llvm.Module{}) {
 			t.Fatal("returned partial module")
@@ -146,6 +184,50 @@ func TestNativeNakedModuleReject(t *testing.T) {
 	}
 }
 
+// An unreferenced empty final label emits no instruction and cannot create a
+// machine fallthrough. Keep its real acceptance separate from the incomplete
+// final instruction rejected above, and retain the function via a DATA address.
+func TestCrossLinuxRuntimeMatrixX86NativeNakedEmptyFinalLabel(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	const source = `TEXT f<>(SB),NOSPLIT,$0
+RET
+end:
+GLOBL ·entry(SB),RODATA,$8
+DATA ·entry(SB)/8,$f<>(SB)
+`
+	goAssemblerOracleOutput(t, "amd64", strings.NewReplacer("NOSPLIT", "4", "RODATA", "8").Replace(source), "", true)
+	goos := "linux"
+	if strings.Contains(triple, "apple") {
+		goos = "darwin"
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateNativeModule(ctx, []byte(source), NativeOptions{GOOS: goos, GOARCH: "amd64", PackagePath: "probe"})
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if module.NamedGlobal("probe.entry").IsNil() {
+		t.Fatal("missing real function-address consumer")
+	}
+	const main = `#include <string.h>
+#if defined(__APPLE__)
+extern unsigned char entry[] __asm("_probe.entry");
+#else
+extern unsigned char entry[] __asm("probe.entry");
+#endif
+int main(void) {
+    void (*function)(void);
+    memcpy(&function, entry, sizeof(function));
+    function();
+    return 0;
+}
+`
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "native-empty-final-label", triple, module.String(), main, prefix)
+}
+
 func TestNativeNakedDataAndIRReferences(t *testing.T) {
 	for _, arch := range []string{"amd64", "arm64"} {
 		t.Run(arch, func(t *testing.T) {
diff --git a/native_source.go b/native_source.go
index 2762d7858..507e58f47 100644
--- a/native_source.go
+++ b/native_source.go
@@ -39,7 +39,14 @@ func ForeignNativeFunctions(src []byte, goarch string) map[string]bool {
 type NativeOptions struct {
 	GOOS, GOARCH string
 	PackagePath  string
-	Imports      map[string]string
+	// Bare imports name external machine entries. A ·name key binds an
+	// external package-global address for memory operands, never CALL/JMP.
+	Imports map[string]string
+	// CodeEntries binds source-native, bare TEXT address tokens to distinct
+	// object symbols. It is not a Go/C signature. Complete physical forms and
+	// explicit NOSPLIT fixed frames are validated by the native backend;
+	// unbound bare TEXT stays declaration-driven. No entry is bound by default.
+	CodeEntries map[string]string
 }
 
 // SupportsNativeTarget reports implemented instruction/object-format pairs.
@@ -48,7 +55,8 @@ func SupportsNativeTarget(goos, goarch string) bool {
 }
 
 // TranslateNativeSource translates checked Plan 9 source directly to native
-// assembly, without Go object files, implicit frames, or signature inference.
+// assembly, without Go object files or signature inference. Explicit fixed
+// TEXT frames retain their target entry/return transformation.
 func TranslateNativeSource(src []byte, opts NativeOptions) (string, []NativeData, error) {
 	f, ep, data, err := prepareNativeSource(src, opts)
 	if err != nil {
@@ -60,7 +68,11 @@ func TranslateNativeSource(src []byte, opts NativeOptions) (string, []NativeData
 		if err := e.functionLabels(fn, i); err != nil {
 			return "", nil, err
 		}
-		fmt.Fprintf(&out, ".text\n.p2align 2\n%s:\n", e.funcs[fn.Sym])
+		out.WriteString(".text\n.p2align 2\n")
+		if _, bound := opts.CodeEntries[fn.Sym]; bound {
+			fmt.Fprintf(&out, ".globl %s\n", e.funcs[fn.Sym])
+		}
+		fmt.Fprintf(&out, "%s:\n", e.funcs[fn.Sym])
 		if opts.GOOS == "linux" {
 			fmt.Fprintf(&out, ".type %s, @function\n", e.funcs[fn.Sym])
 		}
@@ -131,40 +143,41 @@ func prepareNativeSource(src []byte, opts NativeOptions) (*File, *nativeEmitter,
 	if err != nil {
 		return nil, nil, nil, err
 	}
-	if len(f.Funcs) == 0 {
-		return nil, nil, nil, fmt.Errorf("native assembly requires TEXT")
+	if len(f.Funcs) == 0 && len(f.Globl) == 0 {
+		return nil, nil, nil, fmt.Errorf("native assembly requires TEXT or GLOBL")
+	}
+	if err := validateNativeCodeBindings(f, opts); err != nil {
+		return nil, nil, nil, err
 	}
 	e := nativeEmitter{target: opts, funcs: map[string]string{}, globals: map[string]string{}, imports: imports}
 	for name, alias := range imports {
-		if !nativeName.MatchString(name) || !nativeName.MatchString(alias) {
+		function := nativeName.MatchString(name) && nativeName.MatchString(alias)
+		data := strings.HasPrefix(name, "·") && nativeName.MatchString(strings.TrimPrefix(name, "·")) && nativeDataObjectName.MatchString(alias)
+		if !function && !data {
 			return nil, nil, nil, fmt.Errorf("unsupported native import %q -> %q", name, alias)
 		}
 	}
 	for i, fn := range f.Funcs {
 		name := strings.TrimSuffix(fn.Sym, "<>")
-		if name == fn.Sym || !nativeName.MatchString(name) {
+		object, bound := opts.CodeEntries[fn.Sym]
+		if !bound && (name == fn.Sym || !nativeName.MatchString(name)) {
 			return nil, nil, nil, fmt.Errorf("native TEXT must be file-local: %s", fn.Sym)
 		}
+		if bound {
+			if err := validateNativeCodeEntry(fn, opts); err != nil {
+				return nil, nil, nil, err
+			}
+		}
 		if _, ok := e.funcs[fn.Sym]; ok {
 			return nil, nil, nil, fmt.Errorf("duplicate native TEXT %s", fn.Sym)
 		}
 		e.funcs[fn.Sym] = fmt.Sprintf("Lnative_func_%d", i)
-		parts := strings.Split(fn.Instrs[0].Raw, ",")
-		if len(parts) != 3 || (strings.TrimSpace(parts[2]) != "$0" && strings.TrimSpace(parts[2]) != "$0-0") {
-			return nil, nil, nil, fmt.Errorf("native TEXT requires zero Go frame and arguments: %s", fn.Sym)
+		if bound {
+			e.funcs[fn.Sym] = strconv.Quote(e.prefix() + object)
 		}
-		flags, err := nativeFlags(parts[1], "NOSPLIT", "NOFRAME")
-		if err != nil {
+		if _, err := nativeTextFrame(fn, opts); err != nil {
 			return nil, nil, nil, err
 		}
-		if !flags["NOSPLIT"] {
-			return nil, nil, nil, fmt.Errorf("native TEXT requires NOSPLIT: %s", fn.Sym)
-		}
-		for _, ins := range fn.Instrs {
-			if (ins.Op == "BL" || ins.Op == "CALL") && !flags["NOFRAME"] {
-				return nil, nil, nil, fmt.Errorf("native non-leaf TEXT requires NOFRAME: %s", fn.Sym)
-			}
-		}
 	}
 	var data []NativeData
 	for _, g := range f.Globl {
@@ -198,6 +211,7 @@ func prepareNativeSource(src []byte, opts NativeOptions) (*File, *nativeEmitter,
 }
 
 var nativeName = regexp.MustCompile(`^[A-Za-z_][A-Za-z_0-9]*$`)
+var nativeDataObjectName = regexp.MustCompile(`^[A-Za-z_][A-Za-z_0-9./-]*$`)
 var nativePseudoRegister = regexp.MustCompile(`\b(?:SP|FP|g|G|R18_PLATFORM|R18|R31|W[0-9]+)\b`)
 
 // The general parser deliberately tolerates ignored includes and symbolic
@@ -232,7 +246,18 @@ func nativeSource(src []byte, goarch string) (string, error) {
 				for _, raw := range splitTopLevelCSV(rest) {
 					raw = strings.TrimSpace(raw)
 					if !strings.HasPrefix(raw, "$") && strings.HasSuffix(raw, ")") && !strings.HasSuffix(raw, "(SB)") {
-						if i := strings.LastIndex(raw, "("); i >= 0 {
+						i := strings.LastIndex(raw, "(")
+						if goarch == "amd64" && i >= 0 && strings.HasSuffix(raw[:i], ")") {
+							// Strip a real base before an index suffix, keeping
+							// parenthesized constant displacements intact.
+							base := strings.LastIndex(raw[:i], "(")
+							if base >= 0 {
+								if _, register := parseReg(strings.TrimSpace(raw[base+1 : i-1])); register {
+									i = base
+								}
+							}
+						}
+						if i >= 0 {
 							offset := strings.TrimSpace(raw[:i])
 							if offset != "" {
 								if _, ok := parseImmExpr(offset); !ok {
@@ -277,20 +302,36 @@ func nativeInteger(s string) (uint64, bool) {
 	return parseImmExpr(strings.TrimPrefix(s, "$"))
 }
 func nativeFlags(s string, allowed ...string) (map[string]bool, error) {
-	flags := map[string]bool{}
-	for _, flag := range strings.Split(strings.TrimSpace(s), "|") {
-		flag = strings.TrimSpace(flag)
-		if flag == "0" {
-			continue
-		}
-		ok := false
-		for _, a := range allowed {
-			ok = ok || flag == a
-		}
-		if !ok || flags[flag] {
-			return nil, fmt.Errorf("unsupported native flag %q", flag)
+	// cmd/asm consumes a complete integer expression after CPP expands
+	// textflag.h. Decode that same value without truncating foreign flag bits;
+	// native TEXT and DATA retain their separate, deliberately closed roles.
+	if len(s) > goIntegerExpressionMaxBytes {
+		return nil, fmt.Errorf("native flags exceed the integer expression bound")
+	}
+	bits := make(map[string]uint64, len(allowed))
+	var mask uint64
+	for _, name := range allowed {
+		bit, ok := parseImmExpr(goTextFlagValues[name])
+		if !ok {
+			return nil, fmt.Errorf("unregistered native flag %q", name)
+		}
+		bits[name], mask = bit, mask|bit
+	}
+	expression := globlFlagName.ReplaceAllStringFunc(s, func(name string) string {
+		if value, ok := goTextFlagValues[name]; ok {
+			return value
+		}
+		return name
+	})
+	value, ok := parseImmExpr(expression)
+	if !ok || value&^mask != 0 {
+		return nil, fmt.Errorf("unsupported native flags %q", s)
+	}
+	flags := make(map[string]bool, len(allowed))
+	for name, bit := range bits {
+		if value&bit != 0 {
+			flags[name] = true
 		}
-		flags[flag] = true
 	}
 	return flags, nil
 }
@@ -327,6 +368,9 @@ func (e *nativeEmitter) symbol(s string, data bool) (string, error) {
 		}
 	}
 	if alias, ok := e.imports[name]; ok {
+		if strings.HasPrefix(name, "·") && !data {
+			return "", fmt.Errorf("native data binding is not a callable entry: %s", s)
+		}
 		return strconv.Quote(e.prefix() + alias), nil
 	}
 	return "", fmt.Errorf("undeclared foreign symbol or unsupported native reference %s", s)
@@ -362,18 +406,42 @@ func (e *nativeEmitter) functionLabels(fn Func, i int) error {
 	}
 	return nil
 }
+
+// A trailing call keeps its address-sensitive slots and explicitly bounds
+// the final continuation. It never invents a returning machine instruction.
+func nativeFunctionEnd(op Op, arch string) (trap string, valid bool) {
+	switch op {
+	case OpRET, "JMP", "B":
+		return "", true
+	case "CALL", "BL":
+		if arch == "amd64" {
+			return "\tud2\n", true
+		}
+		if arch == "arm64" {
+			return "\tbrk #0\n", true
+		}
+	}
+	return "", false
+}
+
 func (e *nativeEmitter) functionBody(out *strings.Builder, fn Func) error {
+	plan, frameErr := nativeTextFrame(fn, e.target)
+	if frameErr != nil {
+		return frameErr
+	}
 	for _, ins := range fn.Instrs {
 		var err error
 		if e.target.GOARCH == "arm64" {
 			err = (&nativeARM64{e}).instruction(out, ins)
 		} else {
-			err = (&nativeAMD64{e}).instruction(out, ins)
+			err = (&nativeAMD64{nativeEmitter: e, frame: plan}).instruction(out, ins)
 		}
 		if err != nil {
 			return fmt.Errorf("native %s: %s: %w", fn.Sym, ins.Raw, err)
 		}
 	}
+	trap, _ := nativeFunctionEnd(fn.Instrs[len(fn.Instrs)-1].Op, e.target.GOARCH)
+	out.WriteString(trap)
 	return nil
 }
 
diff --git a/native_source_test.go b/native_source_test.go
index 0e51123ee..524508c74 100644
--- a/native_source_test.go
+++ b/native_source_test.go
@@ -85,9 +85,9 @@ int main(void) {
 
 func nativeTargetCompileRun(t *testing.T, opts NativeOptions, asm, harness string) {
 	t.Helper()
-	clang, err := exec.LookPath("clang")
-	if err != nil {
-		t.Skip("clang unavailable")
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang not found")
 	}
 	dir := t.TempDir()
 	src := filepath.Join(dir, "native.s")
@@ -182,7 +182,20 @@ func TestNativeAMD64Reject(t *testing.T) {
 	opts := NativeOptions{GOOS: "linux", GOARCH: "amd64"}
 	for _, body := range []string{"MOVQ foo+8(SP), AX", "MOVQ x+0(FP), AX", "MOVQ $symbol, AX", "MOVQ $1.5, AX", "MOVQ (AX)(CX*4), DX", "MOVQ 2147483648(AX), DX", "MOVQ FS:0(AX), DX", "MOVQ AX, R16", "MOVQ AX, X16", "MOVQ X0, X1", "MOVQ $4, X0", "ADDQ $0xffffffff, AX", "MOVQ $0x100000000, (AX)", "MOVL $0x100000000, AX", "SHLQ $64, AX", "SHLQ CX, AX", "LEAQ AX, BX", "MOVQ (AX), (BX)", "MOVQ AX, $1", "CALL AX", "CALL missing(SB)", "JEQ missing", "RET AX", "MOVB AL, BL", "MOVQ $1, AX, BX", "PUSHQ AX"} {
 		t.Run(body, func(t *testing.T) {
-			_, _, err := TranslateNativeSource([]byte("TEXT f<>(SB), NOSPLIT|NOFRAME, $0\n"+body+"\n"), opts)
+			source := "TEXT f<>(SB), NOSPLIT|NOFRAME, $0\n" + body + "\n"
+			assembly, _, err := TranslateNativeSource([]byte(source), opts)
+			switch body {
+			case "MOVQ (AX)(CX*4), DX", "MOVQ X0, X1", "ADDQ $0xffffffff, AX",
+				"SHLQ $64, AX", "SHLQ CX, AX", "CALL AX", "MOVB AL, BL", "PUSHQ AX":
+				// Preserve the original fragment. Its physical format is now
+				// modeled; this does not assert a returning function or ABI.
+				if err != nil {
+					t.Fatal("legal physical fragment rejected", err)
+				}
+				nativeAMD64OriginalObject(t, "linux", "#include \"textflag.h\"\n"+source)
+				nativePhysicalAssemblyObject(t, assembly, "amd64")
+				return
+			}
 			if err == nil {
 				t.Fatal("accepted unsupported form")
 			}
diff --git a/parser.go b/parser.go
index ae63e0672..5e9f96a75 100644
--- a/parser.go
+++ b/parser.go
@@ -2,15 +2,25 @@ package plan9asm
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
+	"math"
 	"strconv"
 	"strings"
+	"text/scanner"
 )
 
 // File is a parsed Plan 9 asm source file (subset).
 type File struct {
-	Arch  Arch
-	Funcs []Func
+	Arch                 Arch
+	Funcs                []Func
+	x86Continuations     map[string]x86Continuation
+	x86ContinuationGraph *x86ContinuationGraph
+	x86DirectTails       *x86DirectTailGraph // request-local whole-source continuation graph
+	// UnlinkedPrelude records instructions before the first TEXT. Go assembles
+	// them into no named function, so they cannot affect any translated symbol.
+	// Corpus verification checks the same source with Go's assembler first.
+	UnlinkedPrelude []string
 
 	// Data and Globl capture a minimal subset of the Plan 9 DATA/GLOBL directives
 	// used by some stdlib asm (e.g. hash/crc32/crc32_amd64.s).
@@ -35,6 +45,35 @@ type Func struct {
 	ArgSize   int64
 
 	Instrs []Instr
+
+	// X86RawText retains a byte-exact, address-sensitive raw TEXT body. It is
+	// populated only when another source instruction takes the body's address
+	// (including symbol+offset patching), so ordinary BYTE-encoded instructions
+	// still go through semantic decoding and validation.
+	X86RawText []byte
+	// X86RawAlign retains a leading PCALIGN on an address-sensitive raw body.
+	// Go aligns the function itself when PCALIGN precedes its first byte.
+	X86RawAlign int64
+
+	x86ContinuationAddresses map[string]x86Continuation
+	x86IndirectLabels        []string
+	x86ContinuationFlow      *x86ContinuationFlow
+	x86SourceStack           *x86SourceStackProof // recomputed final source ABI0 stack proof
+	x86SourceStackFailure    string               // diagnostic only; never authorizes an effect or return
+	x86FixedLocal            *x86FixedLocalProof
+	// Set only by the closed same-file Go binding proof, never by a guessed
+	// helper FuncSig. The ABI0 root's GP/NZCV entry is otherwise unspecified.
+	arm64PrivateRegisterEntry  bool
+	arm64PrivateUnexposedFrame bool                    // original source proof retained across audited helper coalescing
+	arm64PrivateTailSource     *arm64PrivateTailSource // complete, immutable zero-frame continuation source
+	arm64PrivateCallSource     *arm64PrivateCallSource // sealed original CALL bodies and exact prepared CFG
+	arm64ABI0TailSource        *arm64ABI0TailSource
+	arm64PrivateSourceAdded    int                 // resource accounting only, never a machine-state permission
+	x86RawReplay               *x86RawReplaySource // immutable raw source/replay identity, never a capability
+	x86DirectTailRoot          *x86DirectTailRoot
+	x86ResultFlowBudget        *x86ResultFlowBudget // request-local combined proof accounting only
+	x86BoolCalls               *x86ABI0BoolCallPlan // private complete-source logical CALL plan only
+	x86BoolReadonlyInputs      bool                 // private callee replay; never entry/native authority
 }
 
 // Parse parses a subset of Go/Plan 9 assembly syntax.
@@ -49,16 +88,50 @@ type Func struct {
 //   - #define NAME <body> with optional single-line continuation via '\' and
 //     macro invocation when the entire statement is just NAME.
 func Parse(arch Arch, src string) (*File, error) {
-	f := &File{Arch: arch}
+	return ParseWithDefines(arch, src, nil)
+}
 
-	pp, err := preprocess(src)
+// ParseWithDefines parses assembly with the same predefined symbols cmd/go
+// supplies to cmd/asm (for example GOOS_windows or GOARM64_LSE).
+func ParseWithDefines(arch Arch, src string, defines []string) (*File, error) {
+	pp, err := preprocessWithDefines(src, defines)
 	if err != nil {
 		return nil, err
 	}
+	return parsePreprocessedAssembly(arch, pp)
+}
+
+// parsePreprocessedAssembly consumes the caller's complete expanded source.
+// In particular it cannot silently ignore an active include or apply another
+// macro environment to identifiers left by the actual preprocessor.
+func parsePreprocessedAssembly(arch Arch, pp string) (*File, error) {
+	f := &File{Arch: arch}
 
 	sc := bufio.NewScanner(strings.NewReader(pp))
+	// A short nested macro can expand beyond 64 KiB on one logical line.
+	// Bound the scanner by the actual expanded input, including its final EOF.
+	sc.Buffer(nil, len(pp)+1)
 	lineno := 0
 	var cur *Func
+	var pendingLabels []assemblyLabelPrefix
+	labels := make(map[string]bool)
+	flushLabels := func() error {
+		for _, label := range pendingLabels {
+			if labels[label.name] {
+				return fmt.Errorf("line %d: label %q multiply defined", lineno, label.name)
+			}
+			labels[label.name] = true
+			if cur == nil {
+				f.UnlinkedPrelude = append(f.UnlinkedPrelude, label.raw)
+				continue
+			}
+			cur.Instrs = append(cur.Instrs, Instr{
+				Op: OpLABEL, Args: []Operand{{Kind: OpLabel, Sym: label.name}}, Raw: label.raw,
+			})
+		}
+		pendingLabels = nil
+		return nil
+	}
 	for sc.Scan() {
 		lineno++
 		line := strings.TrimSpace(sc.Text())
@@ -69,39 +142,23 @@ func Parse(arch Arch, src string) (*File, error) {
 			if stmt == "" {
 				continue
 			}
-			if strings.HasSuffix(stmt, ":") {
-				if cur == nil {
-					return nil, fmt.Errorf("line %d: label outside TEXT: %q", lineno, stmt)
+			for {
+				label, found := statementLabelPrefix(arch, stmt)
+				if !found {
+					break
 				}
-				lbl := strings.TrimSpace(strings.TrimSuffix(stmt, ":"))
-				if lbl == "" {
-					return nil, fmt.Errorf("line %d: empty label: %q", lineno, stmt)
-				}
-				cur.Instrs = append(cur.Instrs, Instr{
-					Op:   OpLABEL,
-					Args: []Operand{{Kind: OpLabel, Sym: lbl}},
-					Raw:  stmt,
-				})
-				continue
+				pendingLabels = append(pendingLabels, label)
+				stmt = label.rest
 			}
-			// Support "label: INSTR ..." on one statement.
-			if c := strings.IndexByte(stmt, ':'); c >= 0 {
-				left := strings.TrimSpace(stmt[:c])
-				right := strings.TrimSpace(stmt[c+1:])
-				if left != "" && right != "" && !strings.ContainsAny(left, " \t") {
-					if cur == nil {
-						return nil, fmt.Errorf("line %d: label outside TEXT: %q", lineno, stmt)
-					}
-					cur.Instrs = append(cur.Instrs, Instr{
-						Op:   OpLABEL,
-						Args: []Operand{{Kind: OpLabel, Sym: left}},
-						Raw:  left + ":",
-					})
-					stmt = right
-				}
+			if stmt == "" {
+				continue
 			}
 
-			opStr, rest := splitOpcode(stmt)
+			head, err := parseAssemblyOpcode(arch, stmt)
+			if err != nil {
+				return nil, fmt.Errorf("line %d: %v", lineno, err)
+			}
+			opStr, rest := head.name, head.rest
 			op := Op(strings.ToUpper(opStr))
 			if arch == ArchWASM {
 				// Go's wasm assembler distinguishes low-level WebAssembly Call
@@ -114,6 +171,15 @@ func Parse(arch Arch, src string) (*File, error) {
 					op = "WASMRETURN"
 				}
 			}
+			if op != OpTEXT && op != "DATA" && op != "GLOBL" {
+				if err := flushLabels(); err != nil {
+					return nil, err
+				}
+			}
+			if cur == nil && op != OpTEXT && op != "DATA" && op != "GLOBL" {
+				f.UnlinkedPrelude = append(f.UnlinkedPrelude, stmt)
+				continue
+			}
 			switch op {
 			case OpTEXT:
 				// TEXT name(SB), flags, $frame-args
@@ -129,6 +195,12 @@ func Parse(arch Arch, src string) (*File, error) {
 				if sym == "" {
 					return nil, fmt.Errorf("line %d: empty TEXT symbol: %q", lineno, stmt)
 				}
+				// Early Plan 9 assembly commonly spelled function definitions as
+				// TEXT ·name+0(SB). The zero is a symbol offset, not part of the
+				// linker name; current Go still accepts this legacy form.
+				if base, off := splitSymPlusOff(sym); base != sym && off == 0 {
+					sym = base
+				}
 				frameSize, argSize, err := parseTEXTFrame(parts)
 				if err != nil {
 					return nil, fmt.Errorf("line %d: %v", lineno, err)
@@ -136,6 +208,10 @@ func Parse(arch Arch, src string) (*File, error) {
 				f.Funcs = append(f.Funcs, Func{Sym: sym, FrameSize: frameSize, ArgSize: argSize})
 				cur = &f.Funcs[len(f.Funcs)-1]
 				cur.Instrs = append(cur.Instrs, Instr{Op: OpTEXT, Raw: stmt})
+				labels = make(map[string]bool)
+				if err := flushLabels(); err != nil {
+					return nil, err
+				}
 				continue
 
 			case "DATA":
@@ -223,50 +299,103 @@ func Parse(arch Arch, src string) (*File, error) {
 	return f, nil
 }
 
+// cmd/asm's line grammar admits zero or more pending identifier labels before
+// an instruction. Suffix tokens precede the colon on non-wasm architectures,
+// but do not change the label's original identifier. Operand/string colons
+// never enter this role. DATA/GLOBL and EOF do not consume pending labels.
+type assemblyLabelPrefix struct {
+	name, raw, rest string
+}
+
+func statementLabelPrefix(arch Arch, statement string) (assemblyLabelPrefix, bool) {
+	colon := strings.IndexByte(statement, ':')
+	if colon < 0 {
+		return assemblyLabelPrefix{}, false
+	}
+	reader := newPPGoReader("<label-prefix>", statement[:colon])
+	word, err := reader.next()
+	if err != nil || word.kind != scanner.Ident {
+		return assemblyLabelPrefix{}, false
+	}
+	for {
+		token, err := reader.next()
+		if err != nil {
+			return assemblyLabelPrefix{}, false
+		}
+		if token.kind == scanner.EOF {
+			return assemblyLabelPrefix{word.text, strings.TrimSpace(statement[:colon+1]), strings.TrimSpace(statement[colon+1:])}, true
+		}
+		if token.kind != '.' || arch != ArchAMD64 && arch != ArchARM && arch != ArchARM64 {
+			return assemblyLabelPrefix{}, false
+		}
+		suffix, err := reader.next()
+		if err != nil || suffix.kind != scanner.Ident {
+			return assemblyLabelPrefix{}, false
+		}
+	}
+}
+
 func parseTEXTFrame(parts []string) (frameSize, argSize int64, err error) {
+	spec, err := parseTEXTFrameSpec(parts)
+	return spec.frameSize, spec.argSize, err
+}
+
+type textFrameSpec struct {
+	frameSize, argSize int64
+	argsSpecified      bool
+}
+
+// Keep Go's omitted argument-size state distinct from an explicit zero. The
+// public numeric fields retain their historical zero value; source-sensitive
+// consumers can recover this distinction from the retained original TEXT.
+func parseTEXTFrameSpec(parts []string) (textFrameSpec, error) {
+	var result textFrameSpec
 	if len(parts) < 2 {
-		return 0, 0, nil
+		return result, nil
 	}
 	spec := strings.TrimSpace(parts[len(parts)-1])
 	if !strings.HasPrefix(spec, "$") {
-		return 0, 0, nil
+		return result, nil
 	}
 	spec = strings.TrimSpace(strings.TrimPrefix(spec, "$"))
 	frameText, argText := spec, ""
 	if i := strings.LastIndex(spec, "-"); i > 0 {
+		result.argsSpecified = true
 		frameText, argText = strings.TrimSpace(spec[:i]), strings.TrimSpace(spec[i+1:])
 	}
 	frame, ok := parseImmExpr(frameText)
 	if !ok {
-		return 0, 0, fmt.Errorf("unresolved TEXT frame size %q", frameText)
+		return result, fmt.Errorf("unresolved TEXT frame size %q", frameText)
 	}
-	if argText == "" {
-		return int64(frame), 0, nil
+	result.frameSize = int64(frame)
+	if !result.argsSpecified {
+		return result, nil
 	}
 	args, ok := parseImmExpr(argText)
 	if !ok {
-		return 0, 0, fmt.Errorf("unresolved TEXT argument size %q", argText)
+		return result, fmt.Errorf("unresolved TEXT argument size %q", argText)
 	}
-	return int64(frame), int64(args), nil
+	result.argSize = int64(args)
+	return result, nil
 }
 
 func parseDATAStmt(arch Arch, rest string) (DataStmt, error) {
 	// DATA sym+off(SB)/width, $value
-	lhs, rhs, ok := strings.Cut(rest, ",")
-	if !ok {
+	parts := splitTopLevelCSV(rest)
+	if len(parts) != 2 {
 		return DataStmt{}, fmt.Errorf("invalid DATA: %q", "DATA "+rest)
 	}
-	lhs = strings.TrimSpace(lhs)
-	rhs = strings.TrimSpace(rhs)
+	lhs, rhs := parts[0], parts[1]
 	if lhs == "" || rhs == "" {
 		return DataStmt{}, fmt.Errorf("invalid DATA: %q", "DATA "+rest)
 	}
 
 	// lhs: sym+off(SB)/width
-	symPart, widthStr, ok := strings.Cut(lhs, "/")
-	if !ok {
+	widthSeparator := strings.LastIndexByte(lhs, '/')
+	if widthSeparator < 0 {
 		return DataStmt{}, fmt.Errorf("DATA missing /width: %q", "DATA "+rest)
 	}
+	symPart, widthStr := lhs[:widthSeparator], lhs[widthSeparator+1:]
 	width, err := parseWidth(arch, widthStr)
 	if err != nil || width <= 0 {
 		return DataStmt{}, fmt.Errorf("DATA invalid width %q: %q", widthStr, "DATA "+rest)
@@ -282,9 +411,37 @@ func parseDATAStmt(arch Arch, rest string) (DataStmt, error) {
 		return DataStmt{}, fmt.Errorf("DATA empty symbol: %q", "DATA "+rest)
 	}
 
-	sym, off := splitSymPlusOff(symPart)
+	sym, off, concrete := parseSymbolOffset(symPart)
+	if !concrete || strings.ContainsAny(sym, "\"'`") {
+		return DataStmt{}, fmt.Errorf("DATA unresolved or malformed displacement: %q", "DATA "+rest)
+	}
 
-	val, ok := parseImm(rhs)
+	// DATA's width applies to the value's type, not to a generic immediate
+	// bit pattern. cmd/asm converts a FLOAT leaf to float32 before writing
+	// four bytes; truncating the low bits of float64 would silently corrupt it.
+	expression := strings.TrimSpace(strings.TrimPrefix(rhs, "$"))
+	val, integerError := strconv.ParseUint(expression, 0, 64)
+	ok := integerError == nil
+	if !ok {
+		val, ok = parseImmExpr(expression)
+	}
+	ok = ok && strings.HasPrefix(rhs, "$")
+	if ok && width != 1 && width != 2 && width != 4 && width != 8 {
+		return DataStmt{}, fmt.Errorf("DATA integer requires width 1, 2, 4 or 8: %q", rest)
+	}
+	if !ok && strings.HasPrefix(rhs, "$") {
+		if value, floating := parseGoFloatLiteral(expression); floating {
+			switch width {
+			case 4:
+				val = uint64(math.Float32bits(float32(value)))
+			case 8:
+				val = math.Float64bits(value)
+			default:
+				return DataStmt{}, fmt.Errorf("DATA float requires width 4 or 8: %q", rest)
+			}
+			ok = true
+		}
+	}
 	var payload []byte
 	var addr string
 	if !ok {
@@ -298,9 +455,9 @@ func parseDATAStmt(arch Arch, rest string) (DataStmt, error) {
 		}
 	}
 	if !ok {
-		// Accept symbol-address initializers (e.g. $runtime·main(SB)) even when
-		// relocation details are not modeled; encode as zero placeholder.
-		if strings.HasPrefix(strings.TrimSpace(rhs), "$") {
+		// Preserve symbol-address initializers for relocation-aware lowering.
+		// Value is not a byte payload for an address initializer.
+		if strings.HasPrefix(rhs, "$") && strings.HasSuffix(rhs, "(SB)") {
 			if sym, symOK := parseSym(strings.TrimPrefix(strings.TrimSpace(rhs), "$")); symOK {
 				addr = sym
 				val = 0
@@ -311,7 +468,7 @@ func parseDATAStmt(arch Arch, rest string) (DataStmt, error) {
 	if !ok {
 		return DataStmt{}, fmt.Errorf("DATA invalid immediate %q: %q", rhs, "DATA "+rest)
 	}
-	return DataStmt{Sym: sym, Off: off, Width: width, Value: uint64(val), Payload: payload, Addr: addr}, nil
+	return DataStmt{Sym: sym, Off: off, Width: width, Value: val, Payload: payload, Addr: addr}, nil
 }
 
 func parseWidth(arch Arch, s string) (int64, error) {
@@ -329,14 +486,20 @@ func parseWidth(arch Arch, s string) (int64, error) {
 }
 
 func parseGLOBLStmt(rest string) (GloblStmt, error) {
+	// GLOBL sym(SB), $size
 	// GLOBL sym(SB), flags, $size
-	parts := strings.Split(rest, ",")
-	if len(parts) != 3 {
+	parts := splitTopLevelCSV(rest)
+	if len(parts) != 2 && len(parts) != 3 {
 		return GloblStmt{}, fmt.Errorf("invalid GLOBL: %q", "GLOBL "+rest)
 	}
 	symPart := strings.TrimSpace(parts[0])
-	flags := strings.TrimSpace(parts[1])
-	sizePart := strings.TrimSpace(parts[2])
+	flags := ""
+	sizePartIndex := 1
+	if len(parts) == 3 {
+		flags = strings.TrimSpace(parts[1])
+		sizePartIndex = 2
+	}
+	sizePart := strings.TrimSpace(parts[sizePartIndex])
 	if !strings.HasSuffix(symPart, "(SB)") {
 		return GloblStmt{}, fmt.Errorf("GLOBL symbol must end with (SB): %q", "GLOBL "+rest)
 	}
@@ -344,38 +507,79 @@ func parseGLOBLStmt(rest string) (GloblStmt, error) {
 	if sym == "" {
 		return GloblStmt{}, fmt.Errorf("GLOBL empty symbol: %q", "GLOBL "+rest)
 	}
-	sz, ok := parseImm(sizePart)
-	if (!ok || sz < 0) && strings.HasPrefix(sizePart, "$(") && strings.HasSuffix(sizePart, ")") {
-		// Some platform asm uses symbolic struct-size macros in GLOBL sizes
-		// (e.g. $(machTimebaseInfo__size)). We don't evaluate include-time
-		// macros here, so keep a conservative non-zero placeholder size.
-		sz, ok = 64, true
+	// cmd/asm evaluates the symbol displacement before requiring it to be
+	// zero. Keep a zero expression out of the declaration's identity so DATA
+	// and GLOBL name the same object. A declaration cannot retain an
+	// unresolved expression as a different, phantom storage identity.
+	var off int64
+	var concrete bool
+	sym, off, concrete = parseSymbolOffset(sym)
+	if !concrete || strings.ContainsAny(sym, "\"'`") {
+		return GloblStmt{}, fmt.Errorf("GLOBL unresolved or malformed symbol displacement: %q", "GLOBL "+rest)
+	}
+	if off != 0 {
+		return GloblStmt{}, fmt.Errorf("GLOBL symbol must not be offset from SB: %q", "GLOBL "+rest)
+	}
+	if !strings.HasPrefix(sizePart, "$") {
+		return GloblStmt{}, fmt.Errorf("GLOBL size must be an immediate: %q", sizePart)
 	}
-	if !ok || sz < 0 {
+	expression := strings.TrimSpace(strings.TrimPrefix(sizePart, "$"))
+	sz, ok := parseImmExpr(expression)
+	if !ok && memoryOffsetExpressionNeedsContext(expression) {
+		// Retain generated layout syntax for inventory, never a guessed
+		// zero or 64-byte allocation. Both lowering paths reject SizeRaw.
+		return GloblStmt{Sym: sym, Flags: flags, SizeRaw: sizePart}, nil
+	}
+	if !ok || int64(sz) < 0 {
 		return GloblStmt{}, fmt.Errorf("GLOBL invalid size %q: %q", sizePart, "GLOBL "+rest)
 	}
 	return GloblStmt{Sym: sym, Flags: flags, Size: int64(sz)}, nil
 }
 
 func splitSymPlusOff(s string) (sym string, off int64) {
-	// Best-effort parse for forms like:
-	//   name+0
-	//   name-8
-	// If offset parsing fails, treat the entire string as a symbol name.
 	s = strings.TrimSpace(s)
-	if s == "" {
-		return "", 0
-	}
-	// Prefer the last '+' or '-' as the separator.
-	sep := strings.LastIndexAny(s, "+-")
-	if sep <= 0 || sep == len(s)-1 {
-		return s, 0
+	if name, offset, concrete := parseSymbolOffset(s); concrete {
+		return name, offset
 	}
-	n, err := parseInt(s[sep:])
-	if err != nil {
-		return s, 0
+	return s, 0
+}
+
+// Separate the first explicit displacement outside quoted tokens. A later
+// parseable suffix cannot repair an invalid earlier expression. The public
+// query keeps unresolved input verbatim; DATA/GLOBL consumers require concrete.
+func parseSymbolOffset(s string) (name string, offset int64, concrete bool) {
+	s = strings.TrimSpace(s)
+	var quote byte
+	for index := 0; index < len(s); index++ {
+		character := s[index]
+		if quote != 0 {
+			if character == '\\' && quote != '`' && index+1 < len(s) {
+				index++
+			} else if character == quote {
+				quote = 0
+			}
+			continue
+		}
+		switch character {
+		case '\'', '"', '`':
+			quote = character
+		case '+', '-':
+			if index == 0 {
+				return "", 0, false
+			}
+			name = strings.TrimSpace(s[:index])
+			value, valid := parseImmExpr(s[index:])
+			return name, int64(value), name != "" && valid
+		}
 	}
-	return strings.TrimSpace(s[:sep]), n
+	return s, 0, s != "" && quote == 0
+}
+
+// SplitSymbolOffset parses a Go assembly symbol and its constant-expression
+// displacement. An unparseable displacement leaves the input unchanged so
+// callers can report the original symbol in their own context.
+func SplitSymbolOffset(s string) (sym string, off int64) {
+	return splitSymPlusOff(s)
 }
 
 func parseInt(s string) (int64, error) {
@@ -398,8 +602,14 @@ func parseOperandsCSV(arch Arch, op Op, s string) ([]Operand, error) {
 		if part == "" {
 			continue
 		}
+		if arch == ArchAMD64 {
+			if operand, matched := parseX86BranchIdentifier(op, part); matched {
+				out = append(out, operand)
+				continue
+			}
+		}
 		legacy := []string{part}
-		if arch == ArchAMD64 && op == "SHLL" {
+		if arch == ArchAMD64 && (op == "SHLL" || op == "SHLQ" || op == "SHRL" || op == "SHRQ") {
 			legacy = splitLegacyColonOperand(part)
 		}
 		for _, item := range legacy {
@@ -410,10 +620,9 @@ func parseOperandsCSV(arch Arch, op Op, s string) ([]Operand, error) {
 			out = append(out, op)
 		}
 	}
-	// Direct branches treat a bare token as a label even when it also looks like
-	// an architecture register (for example amd64 JL V1 and ARM BEQ X7 in Go
-	// 1.23's math/big assembly). Indirect branch and call opcodes stay outside
-	// this rule because their bare register operands are meaningful.
+	// ARM direct branches treat a bare token as a label even when the shared
+	// parser recognizes it as another architecture's register, such as BEQ X7.
+	// x86 uses its complete source namespace before generic operand parsing.
 	if branchRegisterTokenIsLabel(arch, op) && len(out) == 1 && out[0].Kind == OpReg {
 		out[0] = Operand{Kind: OpIdent, Ident: strings.TrimSpace(s)}
 	}
@@ -421,6 +630,98 @@ func parseOperandsCSV(arch Arch, op Op, s string) ([]Operand, error) {
 }
 
 func parseOperandForArch(arch Arch, s string) (Operand, error) {
+	if arch == ArchAMD64 || arch == ArchARM || arch == ArchARM64 {
+		operand := strings.TrimSpace(s)
+		// Go's shared parser accepts '*' on register and register-memory
+		// operands, not just x86. Reuse architecture-specific normalization
+		// (g, R(n), RSP) while preserving symbol/immediate indirection.
+		if strings.HasPrefix(operand, "*") {
+			indirect := strings.TrimSpace(operand[1:])
+			if !strings.HasPrefix(indirect, "*") {
+				parsed, err := parseOperandForArch(arch, indirect)
+				if err == nil && (parsed.Kind == OpReg || parsed.Kind == OpMem) {
+					return parsed, nil
+				}
+			}
+		}
+	}
+	if arch == ArchAMD64 {
+		x86Operand := strings.TrimSpace(s)
+		address := strings.HasPrefix(x86Operand, "$")
+		body := strings.TrimSpace(strings.TrimPrefix(x86Operand, "$"))
+		if memory, matched, err := parseX86SymbolIndexedMemory(body); matched {
+			if err != nil {
+				// Preserve the old shared parser's g index spelling, but do
+				// not normalize a new unscaled Reg or address-immediate g
+				// annotation into a Go-valid ignored 386 register.
+				normalized := normalizeGoGRegister(arch, body)
+				if !address && errors.Is(err, ErrProbeNeedsContext) && normalized != body && x86SymbolGIndex.MatchString(body) {
+					if legacy, ok := parseMem(normalized); ok &&
+						strings.HasSuffix(legacy.Sym, "(SB)") && legacy.Base == "" && legacy.Index == "R14" {
+						return Operand{Kind: OpMem, Mem: legacy}, nil
+					}
+				}
+				return Operand{}, err
+			}
+			operand := Operand{Kind: OpMem, Mem: memory}
+			if address {
+				return Operand{Kind: OpSym, Sym: "$" + operand.String()}, nil
+			}
+			return operand, nil
+		}
+	}
+	if arch == ArchAMD64 && strings.HasPrefix(strings.TrimSpace(s), "$") {
+		original := strings.TrimSpace(s)
+		normalized := normalizeGoGRegister(arch, original)
+		if normalized != original {
+			body := strings.TrimSpace(strings.TrimPrefix(normalized, "$"))
+			if _, matched, err := parseX86SourceRegisterMemory(body); matched {
+				if err != nil {
+					return Operand{}, err
+				}
+				// This parser also serves 386. Preserve the original g token
+				// until the source row knows its actual architecture; an
+				// ignored R14 annotation is legal in 386 constant classes.
+				return Operand{Kind: OpSym, Sym: original}, nil
+			}
+		}
+	}
+	s = normalizeGoGRegister(arch, s)
+	if arch == ArchARM || arch == ArchARM64 {
+		s = normalizeARMParenthesizedRegisters(arch, s)
+	}
+	if arch == ArchARM {
+		if memory, ok := parseARMShiftMemory(s); ok {
+			return Operand{Kind: OpMem, Mem: memory}, nil
+		}
+	}
+	if arch == ArchAMD64 {
+		x86Operand := strings.TrimSpace(s)
+		if !strings.HasPrefix(x86Operand, "$") {
+			if pseudo := x86SymbolPseudoGroup.FindStringSubmatch(x86Operand); pseudo != nil && pseudo[1] != "SP" {
+				return parseOperand(s) // Keep unindexed SB/FP and PC branch roles.
+			}
+			if memory, matched, err := parseX86SourceRegisterMemorySyntax(x86Operand, true); matched {
+				if err != nil {
+					return Operand{}, err
+				}
+				if x86SourceMemoryHasSegment(memory) {
+					// Preserve the independent, existing segment/TLS operand
+					// model. A lexical group is not a native-address contract.
+					return parseOperand(s)
+				}
+				return Operand{Kind: OpMem, Mem: memory}, nil
+			}
+		}
+		reg := Reg(strings.ToUpper(x86Operand))
+		switch reg {
+		case ES, CS, SS, DS:
+			return Operand{Kind: OpReg, Reg: reg}, nil
+		}
+		if _, _, ok := x86MachineRegister(reg); ok {
+			return Operand{Kind: OpReg, Reg: reg}, nil
+		}
+	}
 	if arch == ArchWASM {
 		if reg, ok := parseWASMReg(s); ok {
 			return Operand{Kind: OpReg, Reg: reg}, nil
@@ -434,7 +735,252 @@ func parseOperandForArch(arch Arch, s string) (Operand, error) {
 			}
 		}
 	}
-	return parseOperand(s)
+	op, err := parseOperand(s)
+	if err != nil {
+		return Operand{}, err
+	}
+	if arch == ArchARM64 {
+		preserveARM64PhysicalStackPointer(s, &op)
+	}
+	return op, nil
+}
+
+// Go's frontend assigns a different physical register to g on each ISA.
+// Normalize only register positions, including an
+// address immediate or indirect branch. A symbol such as g(SB) stays intact.
+// The shared x86 parser also serves 386. Unnamed address immediates retain
+// their original g spelling for mode qualification before constant rewriting.
+func normalizeGoGRegister(arch Arch, source string) string {
+	if !strings.Contains(source, "g") {
+		return source
+	}
+	register := ""
+	switch arch {
+	case ArchAMD64:
+		register = "R14"
+	case ArchARM:
+		register = "R10"
+	case ArchARM64:
+		register = "R28"
+	default:
+		return source
+	}
+	s := strings.TrimSpace(source)
+	if strings.HasPrefix(s, "[") && strings.HasSuffix(s, "]") ||
+		strings.HasPrefix(s, "(") && strings.HasSuffix(s, ")") && strings.Contains(s, ",") {
+		parts := splitTopLevelCSV(s[1 : len(s)-1])
+		for i, part := range parts {
+			ends := strings.SplitN(part, "-", 2)
+			for j, end := range ends {
+				ends[j] = normalizeGoGRegisterExpression(strings.TrimSpace(end), register)
+			}
+			parts[i] = strings.Join(ends, "-")
+		}
+		return s[:1] + strings.Join(parts, ",") + s[len(s)-1:]
+	}
+	if strings.HasPrefix(s, "*") && strings.TrimSpace(s[1:]) == "g" {
+		return "*" + register
+	}
+	s = normalizeGoGRegisterExpression(s, register)
+	// ARM writes a shifted register offset before the base, g<<2(R1).
+	// Only a parsed register shift is eligible: g(SB), named FP slots and
+	// ordinary symbolic displacement expressions must not be renamed.
+	if arch == ArchARM && strings.HasSuffix(s, ")") {
+		if open := strings.LastIndexByte(s, '('); open > 0 {
+			prefix := strings.TrimSpace(s[:open])
+			marker := ""
+			if strings.HasPrefix(prefix, "$") {
+				marker, prefix = "$", strings.TrimSpace(prefix[1:])
+			}
+			if _, _, _, _, ok := parseRegShift(prefix); ok {
+				s = marker + normalizeGoGRegisterExpression(prefix, register) + s[open:]
+			}
+		}
+	}
+	for start := 0; start < len(s); {
+		open := strings.IndexByte(s[start:], '(')
+		if open < 0 {
+			break
+		}
+		open += start
+		end := strings.IndexByte(s[open+1:], ')')
+		if end < 0 {
+			break
+		}
+		end += open + 1
+		inner := strings.TrimSpace(s[open+1 : end])
+		replacement := normalizeGoGRegisterExpression(inner, register)
+		if scale := strings.IndexByte(inner, '*'); scale >= 0 && strings.TrimSpace(inner[:scale]) == "g" {
+			replacement = register + inner[scale:]
+		}
+		if replacement != inner {
+			s = s[:open+1] + replacement + s[end:]
+			end = open + 1 + len(replacement)
+		}
+		start = end + 1
+	}
+	return s
+}
+
+// Rewrite only the register terminals in a recognized register expression.
+// This preserves symbols, constant expressions, and an explicitly written R28.
+func normalizeGoGRegisterExpression(source, register string) string {
+	if source == "g" {
+		return register
+	}
+	if _, shift, _, _, ok := parseRegShift(source); ok {
+		at := strings.Index(source, string(shift))
+		left, right := strings.TrimSpace(source[:at]), strings.TrimSpace(source[at+len(shift):])
+		if left == "g" {
+			left = register
+		}
+		if right == "g" {
+			right = register
+		}
+		return left + string(shift) + right
+	}
+	if _, _, _, ok := parseRegExtendShift(source); ok {
+		if dot := strings.IndexByte(source, '.'); strings.TrimSpace(source[:dot]) == "g" {
+			return register + source[dot:]
+		}
+	}
+	if _, _, ok := parseRegExtend(source); ok {
+		if dot := strings.IndexByte(source, '.'); strings.TrimSpace(source[:dot]) == "g" {
+			return register + source[dot:]
+		}
+	}
+	return source
+}
+
+// normalizeARMParenthesizedRegisters implements the numeric register-prefix
+// syntax accepted by Go's ARM assemblers, such as R(3), F(7), and V(16).
+// Keeping this architecture-specific prevents a symbol such as SPR(269) from
+// being mistaken for an ARM general-purpose register.
+func normalizeARMParenthesizedRegisters(arch Arch, source string) string {
+	limits := map[string]int{}
+	switch arch {
+	case ArchARM:
+		limits = map[string]int{"R": 15, "F": 15}
+	case ArchARM64:
+		limits = map[string]int{"R": 30, "F": 31, "V": 31, "Z": 31, "P": 15, "PN": 15}
+	default:
+		return source
+	}
+	prefixes := []string{"PN", "R", "F", "V", "Z", "P"}
+	var out strings.Builder
+	for i := 0; i < len(source); {
+		matched := false
+		for _, prefix := range prefixes {
+			endPrefix := i + len(prefix)
+			if endPrefix >= len(source) || !strings.EqualFold(source[i:endPrefix], prefix) || source[endPrefix] != '(' {
+				continue
+			}
+			if i > 0 && isIdentifierByte(source[i-1]) {
+				continue
+			}
+			close := strings.IndexByte(source[endPrefix+1:], ')')
+			if close < 0 {
+				continue
+			}
+			close += endPrefix + 1
+			numberText := strings.TrimSpace(source[endPrefix+1 : close])
+			number, err := strconv.Atoi(numberText)
+			limit, validPrefix := limits[prefix]
+			if err != nil || !validPrefix || number < 0 || number > limit {
+				continue
+			}
+			out.WriteString(prefix)
+			out.WriteString(strconv.Itoa(number))
+			i = close + 1
+			matched = true
+			break
+		}
+		if matched {
+			continue
+		}
+		out.WriteByte(source[i])
+		i++
+	}
+	return out.String()
+}
+
+func isIdentifierByte(ch byte) bool {
+	return ch == '_' || ch >= '0' && ch <= '9' || ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z'
+}
+
+// Go's arm64 assembler distinguishes the hardware stack pointer RSP from the
+// pseudo stack pointer SP. parseReg historically canonicalizes both to SP, so
+// restore the distinction here where the source spelling is still available.
+// This matters for exact optab validation: (RSP) is a C_ZOREG address, while a
+// named local+0(SP) address is C_ZAUTO, and RSP in a paired data operand
+// encodes register 31 (the zero register) rather than a writable stack pointer.
+func preserveARM64PhysicalStackPointer(source string, op *Operand) {
+	source = strings.TrimSpace(source)
+	switch op.Kind {
+	case OpReg:
+		if strings.EqualFold(source, "RSP") {
+			op.Reg = Reg("RSP")
+		}
+	case OpMem:
+		if op.Mem.Base == SP && op.Mem.OffRaw == "" && strings.HasSuffix(strings.ToUpper(source), "(SP)") {
+			prefix := strings.TrimSpace(source[:len(source)-len("(SP)")])
+			if offset, ok := parseNamedStackConstantOffset(prefix); ok && offset == op.Mem.Off {
+				// The generic parser evaluated the displacement. ARM64's
+				// optabs also need the source name to distinguish C_ZAUTO
+				// from a plain register-relative SP address.
+				op.Mem.OffRaw = prefix
+			}
+		}
+		if strings.Contains(strings.ToUpper(source), "(RSP)") {
+			if op.Mem.Base == SP {
+				op.Mem.Base = Reg("RSP")
+			}
+			if op.Mem.Index == SP {
+				op.Mem.Index = Reg("RSP")
+			}
+		}
+	case OpRegList:
+		if len(source) < 2 {
+			return
+		}
+		inner := strings.TrimSpace(strings.Trim(source, "()[]"))
+		parts := splitTopLevelCSV(inner)
+		index := 0
+		for _, part := range parts {
+			regs, ok := expandRegRange(strings.TrimSpace(part))
+			if !ok {
+				return
+			}
+			if len(regs) == 1 && strings.EqualFold(strings.TrimSpace(part), "RSP") && index < len(op.RegList) {
+				op.RegList[index] = Reg("RSP")
+			}
+			index += len(regs)
+		}
+	}
+}
+
+// ARM shifted offsets can contain parenthesized constant expressions. Retain
+// the complete shift before the final base group, including unresolved macros;
+// the typed address validator, not the generic symbol fallback, checks it.
+func parseARMShiftMemory(s string) (MemRef, bool) {
+	s = strings.TrimSpace(s)
+	open := strings.LastIndexByte(s, '(')
+	if open <= 0 || !strings.HasSuffix(s, ")") {
+		return MemRef{}, false
+	}
+	base, ok := parseReg(strings.TrimSpace(s[open+1 : len(s)-1]))
+	if !ok || !isARMGeneralReg(base) {
+		return MemRef{}, false
+	}
+	prefix := strings.TrimSpace(s[:open])
+	for _, shift := range []ShiftOp{ShiftRotate, ShiftArith, ShiftLeft, ShiftRight} {
+		if i := strings.Index(prefix, string(shift)); i > 0 {
+			if reg, ok := parseReg(strings.TrimSpace(prefix[:i])); ok && isARMGeneralReg(reg) {
+				return MemRef{Base: base, OffRaw: prefix}, true
+			}
+		}
+	}
+	return MemRef{}, false
 }
 
 func parseWASMMem(s string) (mem MemRef, matched bool, err error) {
@@ -491,8 +1037,6 @@ func parseWASMReg(s string) (Reg, bool) {
 func branchRegisterTokenIsLabel(arch Arch, op Op) bool {
 	name := normalizeInstructionOpcode(op)
 	switch arch {
-	case ArchAMD64:
-		return (strings.HasPrefix(name, "J") && name != "JMP") || strings.HasPrefix(name, "LOOP")
 	case ArchARM:
 		return isARMBranchOpcode(name) && name != "BL" && name != "BX" && name != "BLX" && name != "RET"
 	case ArchARM64:
@@ -537,18 +1081,83 @@ func splitLegacyColonOperand(s string) []string {
 }
 
 func splitOpcode(stmt string) (op, rest string) {
-	opEnd := strings.IndexAny(stmt, " \t")
-	if opEnd < 0 {
+	head, err := parseAssemblyOpcode(ArchAMD64, stmt)
+	if err != nil {
+		// Source inspectors cannot admit an invalid header by dropping tokens.
+		// Parse reports the lexical error through its architecture-aware path.
 		return stmt, ""
 	}
-	return strings.TrimSpace(stmt[:opEnd]), strings.TrimSpace(stmt[opEnd:])
+	return head.name, head.rest
+}
+
+type assemblyOpcodeHead struct {
+	name, rest string
+}
+
+// cmd/asm accepts Ident ('.' Ident)* on ARM and x86 before the first
+// operand. Spaces, comments and CPP origins do not delimit that grammar.
+// Keep original operand bytes; only the opcode/suffix tokens are canonicalized.
+func parseAssemblyOpcode(arch Arch, statement string) (assemblyOpcodeHead, error) {
+	reader := newPPGoReader("<opcode>", statement)
+	word, err := reader.next()
+	if err != nil {
+		return assemblyOpcodeHead{}, err
+	}
+	if word.kind != scanner.Ident {
+		return assemblyOpcodeHead{}, fmt.Errorf("instruction expected identifier, found %q", word.text)
+	}
+	head := assemblyOpcodeHead{name: word.text}
+	for {
+		token, err := reader.next()
+		if err != nil {
+			return assemblyOpcodeHead{}, err
+		}
+		if token.kind == scanner.EOF {
+			return head, nil
+		}
+		if token.kind != '.' {
+			head.rest = strings.TrimSpace(statement[reader.scanner.Position.Offset:])
+			return head, nil
+		}
+		if arch != ArchAMD64 && arch != ArchARM && arch != ArchARM64 {
+			return assemblyOpcodeHead{}, fmt.Errorf("instruction suffix is not supported on %s", arch)
+		}
+		suffix, err := reader.next()
+		if err != nil {
+			return assemblyOpcodeHead{}, err
+		}
+		if suffix.kind != scanner.Ident {
+			return assemblyOpcodeHead{}, fmt.Errorf("instruction suffix expected identifier, found %q", suffix.text)
+		}
+		head.name += "." + suffix.text
+	}
 }
 
 func splitSemicolons(line string) []string {
-	parts := strings.Split(line, ";")
-	out := make([]string, 0, len(parts))
-	for _, p := range parts {
-		out = append(out, strings.TrimSpace(p))
+	// cmd/asm scans complete string and character tokens. A separator inside
+	// either token is payload, including after an escaped quote/backslash.
+	// Do not repair a malformed quoted token by splitting its remainder.
+	var out []string
+	var quote byte
+	start := 0
+	for index := 0; index < len(line); index++ {
+		value := line[index]
+		if quote != 0 {
+			if value == '\\' && index+1 < len(line) {
+				index++
+			} else if value == quote {
+				quote = 0
+			}
+			continue
+		}
+		switch value {
+		case '"', '\'':
+			quote = value
+		case ';':
+			out = append(out, strings.TrimSpace(line[start:index]))
+			start = index + 1
+		}
 	}
+	out = append(out, strings.TrimSpace(line[start:]))
 	return out
 }
diff --git a/parser_character_immediate_test.go b/parser_character_immediate_test.go
new file mode 100644
index 000000000..437d65910
--- /dev/null
+++ b/parser_character_immediate_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import "testing"
+
+func TestParseCharacterImmediateAndExpressions(t *testing.T) {
+	for _, tc := range []struct {
+		text string
+		want int64
+	}{
+		{text: "$'\\n'", want: 10},
+		{text: "$'Z'", want: 'Z'},
+		{text: "$'\\x7f'", want: 0x7f},
+		{text: "$'\\u00ff'", want: 0xff},
+		{text: "$'\\u03bb'", want: '\u03bb'},
+		{text: "$'A'+1", want: 'B'},
+		{text: "$('A' * 2)", want: 130},
+	} {
+		t.Run(tc.text, func(t *testing.T) {
+			op, err := parseOperand(tc.text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if op.Kind != OpImm || op.Imm != tc.want || op.ImmRaw != "" {
+				t.Fatalf("parseOperand(%q) = %#v, want immediate %d", tc.text, op, tc.want)
+			}
+		})
+	}
+}
+
+func TestParseRejectsInvalidCharacterImmediate(t *testing.T) {
+	for _, text := range []string{"$''", "$'ab'", "$'\\q'", "$'unterminated"} {
+		t.Run(text, func(t *testing.T) {
+			if _, err := parseOperand(text); err == nil {
+				t.Fatalf("parseOperand(%q) unexpectedly succeeded", text)
+			}
+		})
+	}
+}
+
+func TestParseAssemblyWithCharacterImmediate(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT character(SB),NOSPLIT,$0-0\n\tCMPB (SI), $'\\n'\n\tCMPB AX, $'Z'\n\tMOVD $',', R0\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Instrs[1].Args[1].Imm; got != '\n' {
+		t.Fatalf("newline immediate = %d, want %d", got, '\n')
+	}
+	if got := file.Funcs[0].Instrs[2].Args[1].Imm; got != 'Z' {
+		t.Fatalf("Z immediate = %d, want %d", got, 'Z')
+	}
+	if got := file.Funcs[0].Instrs[3].Args[0].Imm; got != ',' {
+		t.Fatalf("comma immediate = %d, want %d", got, ',')
+	}
+}
diff --git a/parser_data_globl_test.go b/parser_data_globl_test.go
index 877534f81..99853a04d 100644
--- a/parser_data_globl_test.go
+++ b/parser_data_globl_test.go
@@ -61,14 +61,17 @@ GLOBL ·symptr<>(SB), NOPTR, $(machTimebaseInfo__size)
 	if err != nil || string(payload[:5]) != "hello" || len(payload) != 8 || payload[5] != 0 {
 		t.Fatalf("padded string DATA payload = (%v, %v)", payload, err)
 	}
-	if ds := file.Data[2]; ds.Sym != "·symptr<>" || ds.Value != 0 {
-		t.Fatalf("unexpected symbol DATA placeholder: %#v", ds)
+	if ds := file.Data[2]; ds.Sym != "·symptr<>" || ds.Addr != "runtime·main(SB)" || ds.Value != 0 || ds.Payload != nil {
+		t.Fatalf("unexpected symbol DATA relocation descriptor: %#v", ds)
+	}
+	if _, err := dataStmtPayload(file.Data[2]); err == nil {
+		t.Fatal("symbol DATA was converted to a zero byte placeholder")
 	}
 
 	if gs := file.Globl[0]; gs.Sym != "·tab<>" || gs.Flags != "RODATA" || gs.Size != 16 {
 		t.Fatalf("unexpected first GLOBL: %#v", gs)
 	}
-	if gs := file.Globl[1]; gs.Sym != "·symptr<>" || gs.Flags != "NOPTR" || gs.Size != 64 {
+	if gs := file.Globl[1]; gs.Sym != "·symptr<>" || gs.Flags != "NOPTR" || gs.Size != 0 || gs.SizeRaw != "$(machTimebaseInfo__size)" {
 		t.Fatalf("unexpected macro-sized GLOBL: %#v", gs)
 	}
 
@@ -81,6 +84,46 @@ GLOBL ·symptr<>(SB), NOPTR, $(machTimebaseInfo__size)
 	}
 }
 
+func TestParseLegacyTwoOperandGloblDirective(t *testing.T) {
+	file, err := Parse(ArchAMD64, `DATA ·REDMASK51(SB)/8, $0x0007FFFFFFFFFFFF
+GLOBL ·REDMASK51(SB), $8
+DATA ·ROUNDING(SB)/2, $0x137f
+GLOBL ·ROUNDING(SB), $2
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := len(file.Globl), 2; got != want {
+		t.Fatalf("len(Globl) = %d, want %d", got, want)
+	}
+	for i, want := range []GloblStmt{
+		{Sym: "·REDMASK51", Size: 8},
+		{Sym: "·ROUNDING", Size: 2},
+	} {
+		if got := file.Globl[i]; got != want {
+			t.Fatalf("Globl[%d] = %#v, want %#v", i, got, want)
+		}
+	}
+	mod, err := TranslateModule(file, Options{
+		Goarch: "amd64",
+		ResolveSym: func(sym string) string {
+			return "legacy." + strings.TrimPrefix(sym, "·")
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer mod.Dispose()
+	for _, want := range []string{
+		`@legacy.REDMASK51 = global [8 x i8]`,
+		`@legacy.ROUNDING = global [2 x i8]`,
+	} {
+		if ir := mod.String(); !strings.Contains(ir, want) {
+			t.Fatalf("legacy GLOBL translation missing %q:\n%s", want, ir)
+		}
+	}
+}
+
 func TestParseDataRejectsMalformedPayloads(t *testing.T) {
 	for _, stmt := range []string{
 		`·missing(SB)/8 $1`,
diff --git a/parser_g_register_test.go b/parser_g_register_test.go
new file mode 100644
index 000000000..8cbf172b0
--- /dev/null
+++ b/parser_g_register_test.go
@@ -0,0 +1,230 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestParseAMD64GRegisterAlias(t *testing.T) {
+	for _, tc := range []struct {
+		source string
+		want   Operand
+	}{
+		{"g", Operand{Kind: OpReg, Reg: "R14"}},
+		{"*g", Operand{Kind: OpReg, Reg: "R14"}},
+		{"0x30(g)", Operand{Kind: OpMem, Mem: MemRef{Base: "R14", Off: 48}}},
+		{"*(g)", Operand{Kind: OpMem, Mem: MemRef{Base: "R14"}}},
+		{"8(BX)(g*4)", Operand{Kind: OpMem, Mem: MemRef{Base: BX, Index: "R14", Scale: 4, Off: 8}}},
+		{"g<>(SB)(g*8)", Operand{Kind: OpMem, Mem: MemRef{Sym: "g<>(SB)", Index: "R14", Scale: 8}}},
+		{"$8(g)", Operand{Kind: OpSym, Sym: "$8(g)"}},
+		{"g(SB)", Operand{Kind: OpSym, Sym: "g(SB)"}},
+		{"$g(SB)", Operand{Kind: OpSym, Sym: "$g(SB)"}},
+	} {
+		t.Run(tc.source, func(t *testing.T) {
+			got, err := parseOperandForArch(ArchAMD64, tc.source)
+			if err != nil || !reflect.DeepEqual(got, tc.want) {
+				t.Fatalf("parseOperandForArch(%q) = %#v, %v; want %#v", tc.source, got, err, tc.want)
+			}
+		})
+	}
+	for _, tc := range []struct {
+		arch Arch
+		want Reg
+	}{{ArchARM, "R10"}, {ArchARM64, "R28"}, {ArchWASM, "G"}} {
+		got, err := parseOperandForArch(tc.arch, "g")
+		if err != nil || got.Reg != tc.want {
+			t.Errorf("%s g = %#v, %v; want %s", tc.arch, got, err, tc.want)
+		}
+	}
+}
+
+func TestTranslateAMD64GRegisterAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = "TEXT gforms(SB),$0-0\n\tMOVQ 0x30(g), AX\n\tMOVQ g, CX\n\tMOVQ AX, g\n\tMOVQ 8(BX)(g*4), AX\n\tPUSHQ g\n\tPOPQ g\n\tRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir := x86UnboundVoidScalarFormatObject(t, source, "gforms", "amd64", triple)
+			if strings.Contains(ir, "R28") {
+				t.Fatal("amd64 g used ARM64's R28")
+			}
+			compileLLVMToObject(t, llc, triple, "g-alias.ll", "g-alias.o", ir)
+		})
+	}
+	bad := "TEXT bad(SB),$0-0\n\tPUSHL g\n\tRET\n"
+	requireX86GoAssemblerResult(t, "386", bad, false)
+	file, err := Parse(ArchAMD64, bad)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := Translate(file, Options{Goarch: "386", Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+		t.Fatal("386 accepted amd64 g")
+	}
+}
+
+func TestAMD64GRegisterRuntime(t *testing.T) {
+	crossRosetta := runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" && rosettaAvailable()
+	if runtime.GOARCH != "amd64" && !crossRosetta {
+		t.Skip("runtime execution test requires amd64 or Rosetta")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT galias(SB),$0-16
+	MOVQ input+0(FP), g
+	PUSHQ g
+	MOVQ $0, g
+	POPQ g
+	MOVQ 8(g), AX
+	MOVQ AX, ret+8(FP)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var runPrefix []string
+	if crossRosetta {
+		triple, runPrefix = "x86_64-apple-macosx", []string{"/usr/bin/arch", "-x86_64"}
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{
+		"galias": {Name: "galias", Args: []LLVMType{Ptr}, Ret: I64, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}},
+		}},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	const mainC = "#include <stdint.h>\nextern uint64_t galias(uint64_t *);\nint main(void) { uint64_t v[2] = {9, 0x12345678}; return galias(v) == v[1] ? 0 : 1; }\n"
+	compileAndRunRuntimeTestForTarget(t, llc, clang, "g_alias", triple, ir, mainC, runPrefix)
+}
+
+func TestTranslateARMGRegisterAcrossTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = "TEXT gforms(SB),$0-0\n\tMOVW g, R0\n\tMOVW 8(g), R1\n\tMOVW R0, g\n\tRET\n"
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Instrs[2].Args[0]; got.Kind != OpMem || got.Mem.Base != "R10" {
+		t.Fatalf("ARM g memory = %#v; want R10 base", got)
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"gforms": {Name: "gforms", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "arm-g.ll", "arm-g.o", ir)
+		})
+	}
+}
+
+func TestParseARMGRegisterInCompositeOperands(t *testing.T) {
+	for _, shift := range []ShiftOp{ShiftLeft, ShiftRight, ShiftArith, ShiftRotate} {
+		for _, tc := range []struct {
+			source string
+			want   Operand
+		}{
+			{"g" + string(shift) + "2", Operand{Kind: OpRegShift, Reg: "R10", ShiftOp: shift, ShiftAmount: 2}},
+			{"R1" + string(shift) + "g", Operand{Kind: OpRegShift, Reg: "R1", ShiftOp: shift, ShiftReg: "R10"}},
+			{"g" + string(shift) + "g", Operand{Kind: OpRegShift, Reg: "R10", ShiftOp: shift, ShiftReg: "R10"}},
+		} {
+			t.Run(tc.source, func(t *testing.T) {
+				got, err := parseOperandForArch(ArchARM, tc.source)
+				if err != nil || !reflect.DeepEqual(got, tc.want) {
+					t.Fatalf("parse(%q) = %#v, %v; want %#v", tc.source, got, err, tc.want)
+				}
+			})
+		}
+	}
+	for _, tc := range []struct {
+		source string
+		want   Operand
+	}{
+		{"[R8,g,R11]", Operand{Kind: OpRegList, RegList: []Reg{"R8", "R10", "R11"}}},
+		{"[g-R12]", Operand{Kind: OpRegList, RegList: []Reg{"R10", "R11", "R12"}, RegListRange: true}},
+		{"[R8-g]", Operand{Kind: OpRegList, RegList: []Reg{"R8", "R9", "R10"}, RegListRange: true}},
+		{"(g,R12)", Operand{Kind: OpRegList, RegList: []Reg{"R10", "R12"}}},
+		{"g<<2(R1)", Operand{Kind: OpMem, Mem: MemRef{Base: "R1", OffRaw: "R10<<2"}}},
+		{"$g<<2(R1)", Operand{Kind: OpSym, Sym: "$R10<<2(R1)"}},
+		{"g(SB)", Operand{Kind: OpSym, Sym: "g(SB)"}},
+		{"$g(SB)", Operand{Kind: OpSym, Sym: "$g(SB)"}},
+		{"R28<<2", Operand{Kind: OpRegShift, Reg: "R28", ShiftOp: ShiftLeft, ShiftAmount: 2}},
+	} {
+		t.Run(tc.source, func(t *testing.T) {
+			got, err := parseOperandForArch(ArchARM, tc.source)
+			if err != nil || !reflect.DeepEqual(got, tc.want) {
+				t.Fatalf("parse(%q) = %#v, %v; want %#v", tc.source, got, err, tc.want)
+			}
+		})
+	}
+}
+
+func TestTranslateARMCompositeGRegisterAcrossTargets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT compositeG(SB),$0-0\n")
+	for _, shift := range []ShiftOp{ShiftLeft, ShiftRight, ShiftArith, ShiftRotate} {
+		fmt.Fprintf(&source, "\tMOVW g%s2, R0\n\tMOVW R1%sg, R2\n\tMOVW g%sg, R3\n", shift, shift, shift)
+	}
+	source.WriteString("\tMOVM [R8,g,R11], (R0)\n\tMOVM (R0), [g-R12]\n\tMOVM [R8-g], (R0)\n\tMOVW g<<2(R1), R0\n\tRET\n")
+	requireARMGoAssemblerResult(t, source.String(), true)
+	file, err := Parse(ArchARM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple, Sigs: map[string]FuncSig{"compositeG": {Name: "compositeG", Ret: Void}}})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "%reg_R28") {
+				t.Fatal("composite ARM g operand used ARM64's R28")
+			}
+			compileLLVMToObject(t, llc, triple, "composite-g.ll", "composite-g.o", ir)
+		})
+	}
+}
+
+func TestParseARM64GRegisterExpressions(t *testing.T) {
+	for _, tc := range []struct {
+		source string
+		want   Operand
+	}{
+		{"g.UXTW", Operand{Kind: OpRegExtend, Reg: "R28", Ext: ExtendUXTW}},
+		{"g.SXTW<<2", Operand{Kind: OpRegExtend, Reg: "R28", Ext: ExtendSXTW, ShiftOp: ShiftLeft, ShiftAmount: 2}},
+		{"(R0)(g.SXTW<<2)", Operand{Kind: OpMem, Mem: MemRef{Base: "R0", Index: "R28", IndexExt: ExtendSXTW, Scale: 4}}},
+		{"$8(R0)(g.UXTW<<2)", Operand{Kind: OpSym, Sym: "$8(R0)(R28.UXTW<<2)"}},
+	} {
+		t.Run(tc.source, func(t *testing.T) {
+			got, err := parseOperandForArch(ArchARM64, tc.source)
+			if err != nil || !reflect.DeepEqual(got, tc.want) {
+				t.Fatalf("parse(%q) = %#v, %v; want %#v", tc.source, got, err, tc.want)
+			}
+		})
+	}
+	for _, source := range []string{"g(SB)", "$g(SB)", "g<>(SB)", "$g+8(SB)", "g+8(FP)", "$g+8(FP)", "runtime·g(SB)", "gopher(SB)", "R1<<'g'", "R28<<2"} {
+		if got := normalizeGoGRegister(ArchARM, source); got != source {
+			t.Errorf("changed non-alias spelling %q to %q", source, got)
+		}
+	}
+}
diff --git a/parser_globl_zero_addend_test.go b/parser_globl_zero_addend_test.go
new file mode 100644
index 000000000..a0881b387
--- /dev/null
+++ b/parser_globl_zero_addend_test.go
@@ -0,0 +1,322 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// cmd/asm's asmGlobl calls address -> symbolReference -> expr and then
+// validSymbol(..., false). The complete integer expression must evaluate to
+// zero; its spelling is not part of the symbol's identity. These spellings
+// exercise the independent Go grammar, not splitSymPlusOff's implementation.
+var globlZeroAddendCases = []struct{ name, addend string }{
+	{"omitted", ""},
+	{"positive", "+0"},
+	{"negative", "-0"},
+	{"hexadecimal", "+0x0"},
+	{"octal", "+00"},
+	{"binary", "+0b0"},
+	{"explicit_octal", "+0o0"},
+	{"positive_spaces", " + 0 "},
+	{"negative_spaces", " - 0 "},
+	{"subtract", "+(1-1)"},
+	{"multiply_spaces", " + ((8 * 3) - 24) "},
+	{"shift", "+((1<<7)-128)"},
+	{"remainder", "+(17%17)"},
+	{"divide", "+(17/17-1)"},
+	{"bitwise", "+((17&3)^1)"},
+	{"or", "+(0|0)"},
+	{"complement_wrap", "+~0+1"},
+	{"character", "+('A'-65)"},
+	{"nested_sign", "+(-(-0))"},
+}
+
+type globlZeroAddendSymbol struct {
+	name, sourceName, caseName string
+	readOnly, local            bool
+}
+
+func globlZeroAddendSource(withFunction bool) (string, []globlZeroAddendSymbol) {
+	var source strings.Builder
+	var symbols []globlZeroAddendSymbol
+	for index, row := range globlZeroAddendCases {
+		for _, local := range []bool{false, true} {
+			for _, readOnly := range []bool{false, true} {
+				name := fmt.Sprintf("zero_globl_%02d_%t_%t", index, local, readOnly)
+				originalName := name
+				if local {
+					originalName += "<>"
+				}
+				fmt.Fprintf(&source, "DATA %s+0(SB)/8,$0x1122334455667788\n", originalName)
+				fmt.Fprintf(&source, "DATA %s+16(SB)/8,$\"a+0;b\"\n", originalName)
+				fmt.Fprintf(&source, "DATA %s+36(SB)/4,$0xa1b2c3d4\n", originalName)
+				fmt.Fprintf(&source, "DATA %s+71(SB)/1,$0x5a\n", originalName)
+				if readOnly {
+					fmt.Fprintf(&source, "GLOBL %s%s(SB),8,$72\n", originalName, row.addend)
+				} else {
+					// The legacy two-operand spelling has the same address grammar.
+					fmt.Fprintf(&source, "GLOBL %s%s(SB),$72\n", originalName, row.addend)
+				}
+				symbols = append(symbols, globlZeroAddendSymbol{
+					name: name, sourceName: originalName, caseName: row.name,
+					readOnly: readOnly, local: local,
+				})
+			}
+		}
+	}
+	if withFunction {
+		source.WriteString("TEXT ·Probe(SB),4,$0-0\nRET\n")
+	}
+	return source.String(), symbols
+}
+
+func globlZeroAddendInitialBytes() []byte {
+	// This expected image is independent of both source parsers/emitters. It
+	// includes sparse holes, a padded quoted payload and the final extent byte.
+	want := make([]byte, 72)
+	binary.LittleEndian.PutUint64(want, 0x1122334455667788)
+	copy(want[16:24], "a+0;b")
+	binary.LittleEndian.PutUint32(want[36:40], 0xa1b2c3d4)
+	want[71] = 0x5a
+	return want
+}
+
+func TestParseGLOBLZeroAddendFiveArchitectures(t *testing.T) {
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			for _, row := range globlZeroAddendCases {
+				for _, name := range []string{"literal", "literal<>", "·literal", "·literal<>"} {
+					for _, flags := range []string{"", "RODATA,"} {
+						t.Run(row.name+"/"+name+"/"+flags, func(t *testing.T) {
+							baseline, err := Parse(target.arch, "GLOBL "+name+"(SB),"+flags+"$72\n")
+							if err != nil || len(baseline.Globl) != 1 {
+								t.Fatal("the no-addend control must parse", err)
+							}
+							file, err := Parse(target.arch, "GLOBL "+name+row.addend+"(SB),"+flags+"$72\n")
+							if err != nil || len(file.Globl) != 1 {
+								t.Fatal("Go's zero displacement is a legal GLOBL address", err)
+							}
+							if !reflect.DeepEqual(file.Globl, baseline.Globl) {
+								t.Fatalf("zero displacement changed identity, flags or extent: got=%+v want=%+v", file.Globl, baseline.Globl)
+							}
+						})
+					}
+				}
+			}
+		})
+	}
+}
+
+func globlZeroAddendGoObject(t *testing.T, goos, goarch, source string, symbols []globlZeroAddendSymbol) {
+	t.Helper()
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "globl.s"), filepath.Join(directory, "globl.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "literal", "-o", object, input)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS="+goos, "GOARCH="+goarch)
+	listing, commandErr := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, listing, commandErr, ctx.Err(), true, goarch, "literal"); failure != nil {
+		t.Fatalf("actual original GLOBL object: %v\n%s", failure, listing)
+	}
+	inputBytes, err := os.ReadFile(input)
+	if err != nil || !bytes.Equal(inputBytes, []byte(source)) {
+		t.Fatal("the observed original source changed", err)
+	}
+	objectBytes, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	header := strings.Fields(string(bytes.SplitN(objectBytes, []byte("\n"), 2)[0]))
+	if len(header) < 5 || header[0] != "go" || header[1] != "object" ||
+		header[2] != goos || header[3] != goarch || header[4] != runtime.Version() {
+		t.Fatal("the original object does not bind the selected SDK and target", header)
+	}
+	globlZeroAddendCheckGoListing(t, string(listing), symbols)
+	t.Logf("actual GLOBL original object: SDK=%s target=%s/%s symbols=%d source=%x object=%x listing=%x",
+		runtime.Version(), goos, goarch, len(symbols), sha256.Sum256(inputBytes), sha256.Sum256(objectBytes), sha256.Sum256(listing))
+}
+
+func globlZeroAddendCheckGoListing(t *testing.T, listing string, symbols []globlZeroAddendSymbol) {
+	t.Helper()
+	wanted := make(map[string]globlZeroAddendSymbol, len(symbols))
+	for _, symbol := range symbols {
+		wanted[symbol.name] = symbol
+	}
+	seen := make(map[string]bool, len(symbols))
+	lines := strings.Split(listing, "\n")
+	for line, text := range lines {
+		fields := strings.Fields(text)
+		if len(fields) == 0 || !strings.HasPrefix(fields[0], "zero_globl_") {
+			continue
+		}
+		symbol, exists := wanted[fields[0]]
+		if !exists || seen[fields[0]] || len(fields) < 3 {
+			t.Fatal("actual GLOBL has a changed/duplicate symbol identity", text)
+		}
+		kind := "SDATA"
+		if symbol.readOnly {
+			kind = "SRODATA"
+		}
+		if fields[1] != kind || strings.Contains(" "+text+" ", " static ") != symbol.local ||
+			!strings.Contains(" "+text+" ", " size=72 ") {
+			t.Fatal("actual GLOBL changed its static/readonly/extent role", text)
+		}
+		var got []byte
+		for offset := 0; offset < 72; offset += 16 {
+			rowIndex := line + 1 + offset/16
+			if rowIndex >= len(lines) {
+				t.Fatal("actual GLOBL byte dump was truncated", symbol.name)
+			}
+			row := strings.Fields(lines[rowIndex])
+			width := 16
+			if width > 72-offset {
+				width = 72 - offset
+			}
+			if len(row) < width+1 || row[0] != fmt.Sprintf("0x%04x", offset) {
+				t.Fatal("actual GLOBL byte range is missing or reordered", lines[rowIndex])
+			}
+			fragment, err := hex.DecodeString(strings.Join(row[1:width+1], ""))
+			if err != nil {
+				t.Fatal("actual GLOBL byte dump is not hexadecimal", err)
+			}
+			got = append(got, fragment...)
+		}
+		if !bytes.Equal(got, globlZeroAddendInitialBytes()) {
+			t.Fatalf("actual GLOBL %s bytes=%x, want=%x", symbol.name, got, globlZeroAddendInitialBytes())
+		}
+		seen[symbol.name] = true
+	}
+	if len(seen) != len(wanted) {
+		t.Fatalf("actual original GLOBL inventory=%d, want=%d\n%s", len(seen), len(wanted), listing)
+	}
+}
+
+func TestGLOBLZeroAddendOriginalGoObjectsFiveArchitectures(t *testing.T) {
+	source, symbols := globlZeroAddendSource(false)
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			globlZeroAddendGoObject(t, target.goos, target.goarch, source, symbols)
+		})
+	}
+}
+
+func TestGLOBLZeroAddendCompleteObjectsThreeAPIsFiveArchitectures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("the complete GLOBL regression requires exact LLVM22")
+	}
+	source, symbols := globlZeroAddendSource(true)
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			globlZeroAddendGoObject(t, target.goos, target.goarch, source, symbols)
+			file, err := Parse(target.arch, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+			options := Options{Goarch: target.goarch, TargetTriple: target.triple, ResolveSym: dataGlobalAlignmentResolve,
+				Sigs: map[string]FuncSig{"Probe": {Name: "Probe", Ret: Void}}}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var module llvm.Module
+					var err error
+					switch api {
+					case "text":
+						var ir string
+						ir, err = Translate(file, options)
+						if err == nil {
+							module, err = parseIRModuleInContext(ctx, ir)
+						}
+					case "module":
+						module, err = TranslateModuleInContext(ctx, file, options)
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+							GOARCH: target.goarch, TargetTriple: target.triple, ResolveSym: dataGlobalAlignmentResolve})
+						if result != nil {
+							module = result.Module
+						}
+					}
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil || module.IsNil() {
+						t.Fatal("a complete Go-accepted GLOBL program must translate", err)
+					}
+					for _, symbol := range symbols {
+						t.Run(symbol.caseName+"/"+symbol.sourceName, func(t *testing.T) {
+							global := module.NamedGlobal(symbol.name)
+							if global.IsNil() || global.IsDeclaration() || global.IsGlobalConstant() != symbol.readOnly ||
+								(global.Linkage() == llvm.InternalLinkage) != symbol.local ||
+								global.Initializer() != ctx.ConstString(string(globlZeroAddendInitialBytes()), false) {
+								t.Fatalf("zero displacement changed actual bytes/extent/identity/readonly role for %s", symbol.sourceName)
+							}
+						})
+					}
+					for global := module.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
+						if strings.ContainsAny(global.Name(), "+-() \t") || strings.HasSuffix(global.Name(), "<>") {
+							t.Errorf("an offset spelling escaped as a separate data identity: %q", global.Name())
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "globl-zero.ll", "globl-zero.o", module.String())
+				})
+			}
+		})
+	}
+}
+
+func TestGLOBLNonzeroUnknownAndQuotedAddendsDoNotBecomeZero(t *testing.T) {
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			for _, addend := range []string{
+				"+1", "-1", "+(2-1)", "+(0x100000000)",
+				"+UNRESOLVED", "+(UNRESOLVED-UNRESOLVED)", "+(1/0)", "+(1", "+0junk",
+			} {
+				t.Run(addend, func(t *testing.T) {
+					statement := "GLOBL literal<>" + addend + "(SB),8,$72\n"
+					goAssemblerOracleOutput(t, target.goarch, statement, "", false)
+					file, err := Parse(target.arch, statement)
+					if err == nil && (len(file.Globl) != 1 || file.Globl[0].Sym == "literal<>") {
+						t.Fatal("a nonzero or unknown displacement was collapsed into a valid zero-address identity", file.Globl)
+					}
+				})
+			}
+			// Go's symbol grammar begins with scanner.Ident, not a quoted
+			// string. Preserve that distinction instead of using an invalid
+			// quoted symbol as a positive actual-object witness.
+			goAssemblerOracleOutput(t, target.goarch, "GLOBL \"literal+0\"(SB),8,$72\n", "", false)
+		})
+	}
+	for _, name := range []string{`"literal+0"`, `"literal-0"`, `"literal\"+0"`, `"literal\\+0"`} {
+		t.Run(strconv.Quote(name), func(t *testing.T) {
+			for _, addend := range []string{"", "+0", "-0", "+(1-1)"} {
+				got, offset := SplitSymbolOffset(name + addend)
+				if got != name || offset != 0 {
+					t.Fatalf("quoted content was mistaken for an offset: %q -> %q, %d", name+addend, got, offset)
+				}
+			}
+			if global, err := parseGLOBLStmt(name + "(SB),8,$72"); err == nil && global.Sym != name {
+				t.Fatalf("quoted +0 was truncated into another symbol: %+v", global)
+			}
+		})
+	}
+}
diff --git a/parser_go_asm_integer_grammar_public_test.go b/parser_go_asm_integer_grammar_public_test.go
new file mode 100644
index 000000000..60c4601c4
--- /dev/null
+++ b/parser_go_asm_integer_grammar_public_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Every route sees the complete original source. In particular, a parser
+// rejection on one route must not substitute for observing the GoModule route.
+func goASMIntegerGrammarTranslate(ctx llvm.Context, pkg GoPackage, source string, arch Arch, goarch, triple, api string) (llvm.Module, string, error) {
+	if api == "GoModule" {
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: goarch, TargetTriple: triple, ResolveSym: dataGlobalAlignmentResolve,
+		})
+		if result != nil {
+			return result.Module, "", err
+		}
+		return llvm.Module{}, "", err
+	}
+	file, err := Parse(arch, source)
+	if err != nil {
+		return llvm.Module{}, "", err
+	}
+	options := Options{
+		Goarch: goarch, TargetTriple: triple, ResolveSym: dataGlobalAlignmentResolve,
+		Sigs: map[string]FuncSig{"Probe": {Name: "Probe", Ret: Void}},
+	}
+	if api == "text" {
+		ir, err := Translate(file, options)
+		if err != nil {
+			return llvm.Module{}, ir, err
+		}
+		module, err := parseIRModuleInContext(ctx, ir)
+		return module, ir, err
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	return module, "", err
+}
+
+func TestGoASMIntegerGrammarOriginalObjectsAndThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("the complete integer grammar object regression requires exact LLVM22")
+	}
+	for _, target := range dataGlobalAlignmentTargets {
+		t.Run(target.goarch, func(t *testing.T) {
+			pointerSize := 8
+			if target.goarch == "386" || target.goarch == "arm" {
+				pointerSize = 4
+			}
+			source, symbols := goASMIntegerGrammarCompleteSource(pointerSize)
+			// The actual Go listing independently requires every complete
+			// expression-(expected) displacement to identify the same bytes.
+			globlZeroAddendGoObject(t, target.goos, target.goarch, source, symbols)
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, _, err := goASMIntegerGrammarTranslate(ctx, pkg, source, target.arch, target.goarch, target.triple, api)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil || module.IsNil() {
+						t.Fatal("a complete original Go integer-grammar program must translate", err)
+					}
+					for index, row := range goASMIntegerGrammarValues {
+						t.Run(row.name, func(t *testing.T) {
+							var want [8]byte
+							binary.LittleEndian.PutUint64(want[:], row.want)
+							value := module.NamedGlobal(fmt.Sprintf("expr_value_%02d", index))
+							if value.IsNil() || value.IsDeclaration() ||
+								value.Initializer() != ctx.ConstString(string(want[:]), false) {
+								t.Fatal("DATA initializer does not equal the independent original expression", row.expression)
+							}
+							zero := module.NamedGlobal(fmt.Sprintf("zero_globl_expr_%02d", index))
+							if zero.IsNil() || zero.IsDeclaration() || !zero.IsGlobalConstant() ||
+								zero.Linkage() != llvm.InternalLinkage ||
+								zero.Initializer() != ctx.ConstString(string(globlZeroAddendInitialBytes()), false) {
+								t.Fatal("a zero displacement changed the actual declaration identity or complete image")
+							}
+							address := module.NamedGlobal(fmt.Sprintf("expr_address_%02d", index))
+							if address.IsNil() {
+								t.Fatal("the complete original address initializer disappeared")
+							}
+							// wasm owns relocated DATA through module assembly, not
+							// an ordinary LLVM initializer. Validate the same original
+							// address through its shared relocation consumer instead.
+							datum := DataStmt{Addr: symbols[index].sourceName + goASMIntegerZeroOffset(row.expression, row.want) + "(SB)"}
+							name, offset, err := dataAddress(datum)
+							if err != nil || name != symbols[index].sourceName || offset != 0 {
+								t.Fatal("an actual zero SB relocation changed identity", name, offset, err)
+							}
+						})
+					}
+					for global := module.FirstGlobal(); !global.IsNil(); global = llvm.NextGlobal(global) {
+						if strings.ContainsAny(global.Name(), "+-() \t") || strings.HasSuffix(global.Name(), "<>") {
+							t.Errorf("an expression became a spurious data-symbol identity: %q", global.Name())
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "integer-grammar.ll", "integer-grammar.o", module.String())
+				})
+			}
+		})
+	}
+}
+
+func TestGoASMIntegerGrammarRejectedGLOBLIsAtomic(t *testing.T) {
+	type rejection struct{ name, addend string }
+	var rejected []rejection
+	for _, row := range goASMIntegerGrammarValues {
+		if row.want != 0 {
+			rejected = append(rejected, rejection{"nonzero/" + row.name, "+(" + row.expression + ")"})
+		}
+	}
+	for _, row := range goASMIntegerGrammarInvalid {
+		rejected = append(rejected, rejection{"invalid/" + row.name, "+(" + row.expression + ")"})
+	}
+	rejected = append(rejected,
+		rejection{"false-zero/right-shift-recursive-product", "+(8>>1*2)-8"},
+		rejection{"false-zero/quoted-tilde", "+('~'-94)"},
+		rejection{"false-zero/high-bit-division", "+((1<<63)/2)-(1<<62)"},
+	)
+	for _, row := range rejected {
+		t.Run(row.name, func(t *testing.T) {
+			source := "DATA literal<>(SB)/8,$0x1122334455667788\n" +
+				"GLOBL literal<>" + row.addend + "(SB),8,$8\n" +
+				"TEXT ·Probe(SB),4,$0-0\nRET\n"
+			// The grammar is shared by all architectures. A normal, concrete,
+			// source-bound AMD64 diagnostic establishes original rejection;
+			// panic, timeout or an unknown failure is never rejection evidence.
+			goAssemblerOracleOutput(t, "amd64", source, "", false)
+			for _, target := range dataGlobalAlignmentTargets {
+				t.Run(target.goarch, func(t *testing.T) {
+					pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							module, ir, err := goASMIntegerGrammarTranslate(ctx, pkg, source, target.arch, target.goarch, target.triple, api)
+							if !module.IsNil() {
+								defer module.Dispose()
+							}
+							if err == nil || !module.IsNil() || ir != "" {
+								t.Fatalf("original Go rejection created a real symbol/image or partial output: err=%v module=%v text-bytes=%d",
+									err, !module.IsNil(), len(ir))
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestGoASMIntegerGrammarRejectsInvalidSharedConsumers(t *testing.T) {
+	for _, row := range goASMIntegerGrammarInvalid {
+		t.Run(row.name, func(t *testing.T) {
+			t.Run("scalar", func(t *testing.T) {
+				if value, ok := parseImmExpr(row.expression); ok {
+					t.Fatalf("an expression rejected by the official grammar became a numeric value: %#x", value)
+				}
+			})
+			t.Run("DATA-value", func(t *testing.T) {
+				statement := "literal<>(SB)/8,$(" + row.expression + ")"
+				goAssemblerOracleOutput(t, "amd64", "DATA "+statement+"\nGLOBL literal<>(SB),8,$8\n", "", false)
+				if datum, err := parseDATAStmt(ArchAMD64, statement); err == nil {
+					t.Fatal("a rejected expression became a DATA initializer", datum)
+				}
+			})
+			t.Run("DATA-displacement", func(t *testing.T) {
+				// Some cmd/asm errors continue into DATA allocation. Keep the
+				// resulting offset bounded even after an expression diagnostic;
+				// an assembler panic cannot stand in for source rejection.
+				statement := "literal<>+(((" + row.expression + "))&0)(SB)/8,$17"
+				goAssemblerOracleOutput(t, "amd64", "DATA "+statement+"\nGLOBL literal<>(SB),8,$8\n", "", false)
+				if datum, err := parseDATAStmt(ArchAMD64, statement); err == nil && datum.Sym == "literal<>" {
+					t.Fatal("a rejected displacement acquired a real DATA-symbol identity", datum)
+				}
+			})
+			t.Run("SB-address", func(t *testing.T) {
+				address := "literal<>+(" + row.expression + ")(SB)"
+				source := "DATA holder<>(SB)/8,$" + address + "\nGLOBL holder<>(SB),8,$8\nGLOBL literal<>(SB),8,$8\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", false)
+				if name, offset, err := dataAddress(DataStmt{Addr: address}); err == nil {
+					t.Fatal("a rejected expression acquired a valid SB relocation", name, offset)
+				}
+			})
+		})
+	}
+}
diff --git a/parser_go_asm_integer_grammar_test.go b/parser_go_asm_integer_grammar_test.go
new file mode 100644
index 000000000..35aba4a24
--- /dev/null
+++ b/parser_go_asm_integer_grammar_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent cmd/asm expr/term/factor directory. Expected uint64 results
+// are not computed with parseImmExpr or another copy of the implementation.
+// A real Go GLOBL at +(expression)-(expected) must independently accept zero.
+var goASMIntegerGrammarValues = []struct {
+	name, expression string
+	want             uint64
+}{
+	{"zero", "0", 0},
+	{"decimal-underscores", "1_2_3", 123},
+	{"hexadecimal", "0xff", 255},
+	{"binary", "0b1_001", 9},
+	{"explicit-octal", "0o17", 15},
+	{"legacy-octal", "077", 63},
+	{"unary-plus", "+1", 1},
+	{"unary-minus", "-1", ^uint64(0)},
+	{"adjacent-plus", "++1", 1},
+	{"adjacent-minus", "--1", 1},
+	{"nested-signs", "+(-(-1))", 1},
+	{"complement", "~0", ^uint64(0)},
+	{"nested-complement", "~~0", 0},
+	{"uint64-wrap", "0xffff_ffff_ffff_ffff+1", 0},
+	{"rune-tilde", "'~'", 126},
+	{"rune-caret", "'^'", 94},
+	{"rune-plus", "'+'", 43},
+	{"rune-minus", "'-'", 45},
+	{"rune-left-shift-character", "'<'", 60},
+	{"rune-right-shift-character", "'>'", 62},
+	{"rune-divide-character", "'/'", 47},
+	{"rune-comma-character", "','", 44},
+	{"rune-open-parenthesis", "'('", 40},
+	{"rune-close-parenthesis", "')'", 41},
+	{"rune-semicolon-character", "';'", 59},
+	{"rune-double-quote", `'"'`, 34},
+	{"rune-backtick", "'`'", 96},
+	{"rune-hexadecimal-escape", "'\\x7e'", 126},
+	{"rune-unicode-escape", "'\\u007e'", 126},
+	{"rune-unicode", "'世'", 19990},
+	{"rune-escaped-quote", `'\''`, 39},
+	{"rune-escaped-backslash", "'\\\\'", 92},
+	{"parenthesized-products", "(1+2)*(3+4)", 21},
+	{"left-associated-subtraction", "17-3-2", 12},
+	{"product-wrap", "0x8000000000000000*2", 0},
+	{"division", "17/3", 5},
+	{"remainder", "17%3", 2},
+	{"high-bit-divisor", "1/~0", 0},
+	{"high-bit-modulus", "1%~0", 1},
+	{"left-associated-expr", "1|2^3", 0},
+	{"term-before-expr", "17&3^1", 0},
+	{"right-shift-recursive-product", "8>>1*2", 2},
+	{"right-shift-recursive-shift", "64>>1>>2", 64},
+	{"right-shift-recursive-and", "64>>1&3", 32},
+	{"right-shift-recursive-division", "64>>3/2", 32},
+	{"right-shift-recursive-remainder", "64>>3%2", 32},
+	{"right-shift-recursive-left-shift", "64>>1<<2", 4},
+	{"right-shift-consumes-left-shift-remainder", "64>>1<<2*3", 12},
+	{"right-shift-after-product", "8*2>>1*2", 4},
+	{"right-shift-expr-boundary", "64>>3+1", 9},
+	{"left-shift-expr-boundary", "1<<3+1", 9},
+	{"parenthesized-left-shift-term", "(1<<3)*2", 16},
+	{"left-shift-sixty-four", "1<<64", 0},
+	{"right-shift-sixty-four", "1>>64", 0},
+	{"right-shift-recursive-zero-count", "1>>64*0", 1},
+}
+
+var goASMIntegerGrammarInvalid = []struct{ name, expression string }{
+	{"negative-left-shift", "1<<-1"},
+	{"negative-right-shift", "1>>-1"},
+	{"high-bit-division", "~0/2"},
+	{"high-bit-remainder", "~0%2"},
+	{"high-bit-right-shift", "(-1)>>1"},
+	{"computed-high-bit-division", "(1<<63)/2"},
+	{"computed-high-bit-remainder", "(1<<63)%2"},
+	{"computed-high-bit-right-shift", "(1<<63)>>1"},
+	{"division-zero", "1/0"},
+	{"remainder-zero", "1%0"},
+	{"Go-only-and-not", "1&^1"},
+	{"Go-only-and-not-nonzero", "7&^3"},
+	{"Go-only-unary-caret", "^0+1"},
+	{"left-shift-remaining-product", "1<<1*0"},
+	{"left-shift-remaining-and", "1<<1&0"},
+	{"left-shift-remaining-shift", "1<<1<<0"},
+	{"unknown-identifiers", "UNKNOWN-UNKNOWN"},
+	{"unclosed-parenthesis", "(1"},
+	{"remaining-literal", "(1)2"},
+	{"uint64-overflow-literal", "18446744073709551616"},
+	{"float-in-integer-expression", "1.0-1.0"},
+	{"rune-invalid-UTF8-byte", "'\\377'"},
+}
+
+func TestGoASMIntegerGrammarBoundsAndUnresolvedQueryIdentity(t *testing.T) {
+	for _, expression := range []string{
+		strings.Repeat("(", 32) + "1" + strings.Repeat(")", 32),
+		strings.Repeat("+", 32) + "1",
+	} {
+		if value, valid := parseImmExpr(expression); !valid || value != 1 {
+			t.Fatal("ordinary bounded nesting lost its complete numerical value", expression, value, valid)
+		}
+	}
+	for _, row := range []struct{ name, expression string }{
+		{"bytes", "1" + strings.Repeat("/*x*/", 14000)},
+		{"tokens", "1" + strings.Repeat("+1", 3000)},
+		{"depth", strings.Repeat("+", 256) + "1"},
+		{"unknown-then-zero", "UNKNOWN+0"},
+		{"invalid-then-zero", "(1&^1)+0"},
+		{"invalid-shift-then-zero", "(1<<1*0)+0"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			if value, valid := parseImmExpr(row.expression); valid {
+				t.Fatal("an unresolved or over-budget expression acquired a numerical result", value)
+			}
+			original := "literal<>+(" + row.expression + ")"
+			if name, offset := SplitSymbolOffset(original); name != original || offset != 0 {
+				t.Fatal("the public unresolved query lost its original identity", name, offset)
+			}
+			if _, _, valid := parseSBRef(original + "(SB)"); valid {
+				t.Fatal("an unresolved expression acquired an SB reference")
+			}
+			if _, err := parseGLOBLStmt(original + "(SB),8,$8"); err == nil {
+				t.Fatal("an unresolved expression acquired a concrete declaration")
+			}
+		})
+	}
+}
+
+func goASMIntegerZeroOffset(expression string, value uint64) string {
+	return fmt.Sprintf("+(%s)-%d", expression, value)
+}
+
+func TestGoASMIntegerGrammarSharedScalarAndSymbolConsumers(t *testing.T) {
+	for _, row := range goASMIntegerGrammarValues {
+		t.Run(row.name, func(t *testing.T) {
+			t.Run("scalar", func(t *testing.T) {
+				if value, ok := parseImmExpr(row.expression); !ok || value != row.want {
+					t.Fatalf("official integer grammar %q = %#x, %v; want %#x", row.expression, value, ok, row.want)
+				}
+			})
+			t.Run("DATA-value", func(t *testing.T) {
+				datum, err := parseDATAStmt(ArchAMD64, "literal<>(SB)/8,$("+row.expression+")")
+				if err != nil || datum.Sym != "literal<>" || datum.Off != 0 || datum.Value != row.want || datum.Addr != "" || datum.Payload != nil {
+					t.Fatal("DATA did not retain the exact official integer expression", datum, err)
+				}
+			})
+			t.Run("DATA-displacement", func(t *testing.T) {
+				datum, err := parseDATAStmt(ArchAMD64, "literal<>"+goASMIntegerZeroOffset(row.expression, row.want)+"(SB)/8,$17")
+				if err != nil || datum.Sym != "literal<>" || datum.Off != 0 || datum.Value != 17 {
+					t.Fatal("DATA zero displacement changed the underlying symbol/image", datum, err)
+				}
+			})
+			t.Run("SB-displacement", func(t *testing.T) {
+				name, offset, ok := parseSBRef("literal<>+(" + row.expression + ")(SB)")
+				if !ok || name != "literal<>" || uint64(offset) != row.want {
+					t.Fatalf("SB reference lost actual integer addend: %q, %#x, %v; want %#x", name, uint64(offset), ok, row.want)
+				}
+			})
+			t.Run("GLOBL-zero", func(t *testing.T) {
+				global, err := parseGLOBLStmt("literal<>" + goASMIntegerZeroOffset(row.expression, row.want) + "(SB),8,$8")
+				if err != nil || global.Sym != "literal<>" || global.Size != 8 {
+					t.Fatal("a real Go zero displacement lost its declaration identity", global, err)
+				}
+			})
+		})
+	}
+}
+
+func goASMIntegerGrammarCompleteSource(pointerSize int) (string, []globlZeroAddendSymbol) {
+	var source strings.Builder
+	var symbols []globlZeroAddendSymbol
+	for index, row := range goASMIntegerGrammarValues {
+		value := fmt.Sprintf("expr_value_%02d", index)
+		zero := fmt.Sprintf("zero_globl_expr_%02d", index)
+		address := fmt.Sprintf("expr_address_%02d", index)
+		offset := goASMIntegerZeroOffset(row.expression, row.want)
+		fmt.Fprintf(&source, "DATA %s<>(SB)/8,$(%s)\nGLOBL %s<>(SB),8,$8\n", value, row.expression, value)
+		fmt.Fprintf(&source, "DATA %s<>%s(SB)/8,$0x1122334455667788\n", zero, offset)
+		fmt.Fprintf(&source, "DATA %s<>+16(SB)/8,$\"a+0;b\"\n", zero)
+		fmt.Fprintf(&source, "DATA %s<>+36(SB)/4,$0xa1b2c3d4\nDATA %s<>+71(SB)/1,$0x5a\n", zero, zero)
+		fmt.Fprintf(&source, "GLOBL %s<>%s(SB),8,$72\n", zero, offset)
+		fmt.Fprintf(&source, "DATA %s<>(SB)/%d,$%s<>%s(SB)\nGLOBL %s<>(SB),8,$%d\n", address, pointerSize, zero, offset, address, pointerSize)
+		symbols = append(symbols, globlZeroAddendSymbol{name: zero, sourceName: zero + "<>", caseName: row.name, readOnly: true, local: true})
+	}
+	source.WriteString("TEXT ·Probe(SB),4,$0-0\nRET\n")
+	return source.String(), symbols
+}
diff --git a/parser_indirect_marker_test.go b/parser_indirect_marker_test.go
new file mode 100644
index 000000000..7183a03a1
--- /dev/null
+++ b/parser_indirect_marker_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestIndirectMarkerGoBranchForms(t *testing.T) {
+	// Go's shared operand parser accepts '*' before registers and register
+	// memory, including ARM's numeric R(n) spelling. The encoder tables still
+	// decide which operand classes each branch instruction accepts.
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch           Arch
+		goarch, triple string
+		ops, operands  []string
+	}{
+		{
+			ArchAMD64, "386", "i386-unknown-linux-gnu",
+			[]string{"CALL", "JMP"}, []string{"AX", "(BX)", "8(BX)"},
+		},
+		{
+			ArchAMD64, "amd64", "x86_64-unknown-linux-gnu",
+			[]string{"CALL", "JMP"}, []string{"AX", "R10", "(BX)", "8(BX)"},
+		},
+		{
+			ArchARM, "arm", "armv7-unknown-linux-gnueabihf",
+			[]string{"BL", "CALL", "B", "JMP", "BX"}, []string{"(R0)", "0(R(1))", "(g)"},
+		},
+		{
+			ArchARM64, "arm64", "aarch64-unknown-linux-gnu",
+			[]string{"BL", "CALL"}, []string{"R0", "R(1)", "g", "(R0)", "0(R(1))", "(g)", "(RSP)"},
+		},
+		{
+			ArchARM64, "arm64", "aarch64-unknown-linux-gnu",
+			[]string{"B", "JMP"}, []string{"(R0)", "0(R(1))", "(g)", "(RSP)"},
+		},
+	} {
+		for _, op := range target.ops {
+			for _, operand := range target.operands {
+				t.Run(target.goarch+"/"+op+"/"+operand, func(t *testing.T) {
+					var ir [2]string
+					var parsed [2]Operand
+					for i, marker := range []string{"", "*"} {
+						source := fmt.Sprintf("TEXT indirect(SB),4,$0-0\n%s %s%s\nRET\n", op, marker, operand)
+						instructionIndex := 1
+						if target.arch == ArchARM64 {
+							branch, err := parseOperandForArch(ArchARM64, operand)
+							if err != nil {
+								t.Fatal(err)
+							}
+							reg := branch.Reg
+							if branch.Kind == OpMem {
+								reg = branch.Mem.Base
+							}
+							if reg != SP && reg != Reg("RSP") && reg != ZR {
+								spelling := string(reg)
+								if reg == Reg("R28") {
+									spelling = "g"
+								}
+								continuation := ""
+								if op == "BL" || op == "CALL" {
+									continuation = "RET\n"
+								}
+								source = fmt.Sprintf("TEXT indirect(SB),4,$0-0\nADR localTarget,%s\n%s %s%s\n%slocalTarget:\nB (R30)\n", spelling, op, marker, operand, continuation)
+								instructionIndex = 2
+							} else if op == "BL" || op == "CALL" {
+								source = fmt.Sprintf("TEXT indirect(SB),4,$0-0\n%s %s%s\nB (ZR)\n", op, marker, operand)
+							} else {
+								source = fmt.Sprintf("TEXT indirect(SB),4,$0-0\n%s %s%s\n", op, marker, operand)
+							}
+						}
+						requireIndirectMarkerGoAssembly(t, target.goarch, source, true)
+						file, err := Parse(target.arch, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						if i == 1 {
+							for _, extraTriple := range map[string][]string{
+								"386":   {"i686-pc-windows-msvc"},
+								"amd64": {"x86_64-apple-darwin", "x86_64-pc-windows-msvc"},
+								"arm64": {"aarch64-apple-darwin", "aarch64-pc-windows-msvc"},
+							}[target.goarch] {
+								extraIR, err := Translate(file, Options{
+									Goarch: target.goarch, TargetTriple: extraTriple,
+									Sigs: map[string]FuncSig{"indirect": {Name: "indirect", Ret: Void}},
+								})
+								if err != nil {
+									t.Fatal(err)
+								}
+								compileLLVMToObject(t, llc, extraTriple, "indirect.ll", "indirect.o", extraIR)
+							}
+						}
+						parsed[i] = file.Funcs[0].Instrs[instructionIndex].Args[0]
+						// Raw source is diagnostic text in emitted IR comments.
+						file.Funcs[0].Instrs[instructionIndex].Raw = op + " " + operand
+						ir[i], err = Translate(file, Options{
+							Goarch: target.goarch, TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{"indirect": {Name: "indirect", Ret: Void}},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+					if !reflect.DeepEqual(parsed[0], parsed[1]) {
+						t.Fatalf("marker changes typed operand: %#v != %#v", parsed[0], parsed[1])
+					}
+					if indirectMarkerComparableIR(ir[0]) != indirectMarkerComparableIR(ir[1]) {
+						t.Fatal("marker changes generated IR")
+					}
+					compileLLVMToObject(t, llc, target.triple, "indirect.ll", "indirect.o", ir[1])
+				})
+			}
+		}
+	}
+}
+
+func TestIndirectMarkerDoesNotRelaxBranchOperandClasses(t *testing.T) {
+	for _, tc := range []struct {
+		arch                    Arch
+		goarch, triple, command string
+	}{
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "CALL *8(R0)"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "BL *RSP"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "BL *V0"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "CALL *$1"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf", "BX *R0"},
+	} {
+		t.Run(tc.goarch+"/"+tc.command, func(t *testing.T) {
+			source := "TEXT indirect(SB),4,$0-0\n" + tc.command + "\nRET\n"
+			requireIndirectMarkerGoAssembly(t, tc.goarch, source, false)
+			file, err := Parse(tc.arch, source)
+			if err != nil {
+				return
+			}
+			_, err = Translate(file, Options{
+				Goarch: tc.goarch, TargetTriple: tc.triple,
+				Sigs: map[string]FuncSig{"indirect": {Name: "indirect", Ret: Void}},
+			})
+			if err == nil {
+				t.Fatal("accepted branch outside Go's operand classes")
+			}
+		})
+	}
+}
+
+func indirectMarkerComparableIR(ir string) string {
+	// LLVM embeds each independent translation's temporary input filename.
+	var result strings.Builder
+	for _, line := range strings.Split(ir, "\n") {
+		if strings.HasPrefix(line, "; ModuleID =") || strings.HasPrefix(line, "source_filename =") {
+			continue
+		}
+		result.WriteString(line)
+		result.WriteByte('\n')
+	}
+	return result.String()
+}
+
+func TestIndirectMarkerDoesNotEraseSymbolOrImmediateMeaning(t *testing.T) {
+	// Symbol indirection is not the same as a direct symbol call. Do not turn
+	// unsupported forms into a seemingly valid direct branch by stripping '*'.
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64, ArchWASM} {
+		for _, source := range []string{"*target(SB)", "*target", "*$8", "**R0"} {
+			t.Run(fmt.Sprintf("%v/%s", arch, source), func(t *testing.T) {
+				operand, err := parseOperandForArch(arch, source)
+				if err != nil {
+					return
+				}
+				if operand.Kind == OpReg || operand.Kind == OpMem || operand.Kind == OpImm ||
+					operand.Kind == OpSym && !strings.Contains(operand.Sym, "*") ||
+					operand.Kind == OpIdent && !strings.Contains(operand.Ident, "*") {
+					t.Fatalf("indirection erased: %#v", operand)
+				}
+			})
+		}
+	}
+}
+
+func requireIndirectMarkerGoAssembly(t *testing.T, goarch, source string, wantOK bool) {
+	t.Helper()
+	dir := t.TempDir()
+	asm := filepath.Join(dir, "indirect.s")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "indirect.o"), asm)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+goarch)
+	out, err := cmd.CombinedOutput()
+	if (err == nil) != wantOK {
+		t.Fatalf("Go assembler success=%v, want %v for %s:\n%s\n%s", err == nil, wantOK, goarch, source, out)
+	}
+}
diff --git a/parser_label_prefix_test.go b/parser_label_prefix_test.go
new file mode 100644
index 000000000..c13081fa7
--- /dev/null
+++ b/parser_label_prefix_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestParseLabelPrefixFamilyOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch, triple string
+		arch           Arch
+	}{
+		{"386", "i386-unknown-linux-gnu", ArchAMD64},
+		{"amd64", "x86_64-unknown-linux-gnu", ArchAMD64},
+		{"arm", "armv7-unknown-linux-gnueabihf", ArchARM},
+		{"arm64", "aarch64-unknown-linux-gnu", ArchARM64},
+		{"wasm", "wasm32-unknown-unknown", ArchWASM},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			for _, test := range []struct {
+				name, prefix, body string
+				labels             []string
+			}{
+				{"inline", "", "first: next: tail: NOP\n", []string{"first", "next", "tail"}},
+				{"physical_lines", "", "first:\nnext:\ntail:\nNOP\n", []string{"first", "next", "tail"}},
+				{"comments", "", "first:\n// no instruction\nnext: /* still no instruction */ tail: NOP\n", []string{"first", "next", "tail"}},
+				{"semicolons", "", "first:;next:;tail: NOP;", []string{"first", "next", "tail"}},
+				{"object_macro", "#define LABELS first: next:\n", "LABELS tail: NOP\n", []string{"first", "next", "tail"}},
+				{"function_macro", "#define LABELS(a,b) a: b:\n", "LABELS(first,next) tail: NOP\n", []string{"first", "next", "tail"}},
+				{"opcode_names", "", "RET: NOP: tail: NOP\n", []string{"RET", "NOP", "tail"}},
+				{"unicode", "", "一: 二: 三: NOP\n", []string{"一", "二", "三"}},
+				{"internal_names", "", "reg_R0: reg_AX: flags_n: entry: anon_1: NOP\n", []string{"reg_R0", "reg_AX", "flags_n", "entry", "anon_1"}},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					source := test.prefix + "TEXT ·Probe(SB),4,$0-0\n" + test.body + "RET\n"
+					goAssemblerOracleOutput(t, target.goarch, source, "", true)
+					expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{FileName: "labels.s"})
+					if err != nil {
+						t.Fatal(err)
+					}
+					goAssemblerOracleOutput(t, target.goarch, expanded, "", true)
+					for index, input := range []string{source, expanded} {
+						file, err := Parse(target.arch, input)
+						if err != nil {
+							t.Fatalf("label prefix path=%d: %v", index, err)
+						}
+						var labels []string
+						var operations []Op
+						for _, instruction := range file.Funcs[0].Instrs {
+							if instruction.Op == OpLABEL {
+								if len(instruction.Args) != 1 || instruction.Args[0].Kind != OpLabel {
+									t.Fatalf("untyped label: %+v", instruction)
+								}
+								labels = append(labels, instruction.Args[0].Sym)
+							} else {
+								operations = append(operations, instruction.Op)
+							}
+						}
+						if !reflect.DeepEqual(labels, test.labels) || !reflect.DeepEqual(operations, []Op{OpTEXT, "NOP", OpRET}) {
+							t.Fatalf("Go-accepted label prefixes lost their identities: path=%d labels=%v operations=%v", index, labels, operations)
+						}
+						ir, err := Translate(file, Options{
+							Goarch: target.goarch, TargetTriple: target.triple,
+							Sigs: map[string]FuncSig{"·Probe": {Name: "·Probe", Ret: Void}},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "labels.ll", "labels.o", ir)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestParseLabelPrefixOptionalSuffixAndFunctionScopeLikeGo(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		arch   Arch
+	}{
+		{"386", ArchAMD64}, {"amd64", ArchAMD64}, {"arm", ArchARM}, {"arm64", ArchARM64}, {"wasm", ArchWASM},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			t.Run("suffix", func(t *testing.T) {
+				// cmd/asm consumes suffix tokens before a colon, then retains
+				// only the original word as the pending label, not its suffix.
+				const source = "TEXT Probe(SB),4,$0-0\nfirst.EQ.S: NOP\nRET\n"
+				accepted := target.arch != ArchWASM
+				goAssemblerOracleOutput(t, target.goarch, source, "", accepted)
+				file, err := Parse(target.arch, source)
+				if err != nil {
+					if accepted {
+						t.Fatal(err)
+					}
+					return
+				}
+				var labels []string
+				for _, instruction := range file.Funcs[0].Instrs {
+					if instruction.Op == OpLABEL {
+						labels = append(labels, instruction.Args[0].Sym)
+					}
+				}
+				if accepted && !reflect.DeepEqual(labels, []string{"first"}) || !accepted && len(labels) != 0 {
+					t.Fatalf("label suffix differs from original Go grammar: accepted=%t labels=%v", accepted, labels)
+				}
+			})
+			t.Run("function_scope", func(t *testing.T) {
+				const source = "TEXT First(SB),4,$0-0\nlocal: NOP\nRET\nTEXT Second(SB),4,$0-0\nlocal: NOP\nRET\n"
+				goAssemblerOracleOutput(t, target.goarch, source, "", true)
+				file, err := Parse(target.arch, source)
+				if err != nil || len(file.Funcs) != 2 {
+					t.Fatalf("function-local labels were lost: %v", err)
+				}
+				for _, function := range file.Funcs {
+					if function.Instrs[1].Op != OpLABEL || function.Instrs[1].Args[0].Sym != "local" {
+						t.Fatalf("label escaped its original TEXT: %+v", function.Instrs)
+					}
+				}
+			})
+		})
+	}
+}
+
+func TestParseLabelPrefixRejectsOriginalNonIdentifierAndDuplicateNames(t *testing.T) {
+	for _, target := range []struct {
+		goarch string
+		arch   Arch
+	}{
+		{"386", ArchAMD64}, {"amd64", ArchAMD64}, {"arm", ArchARM}, {"arm64", ArchARM64}, {"wasm", ArchWASM},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			for _, test := range []struct{ name, body string }{
+				{"numeric", "1: NOP\n"},
+				{"string", "\"name\": NOP\n"},
+				{"operator", "first+next: NOP\n"},
+				{"missing_name", ": NOP\n"},
+				{"duplicate", "first: first: NOP\n"},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					source := "TEXT ·Probe(SB),4,$0-0\n" + test.body + "RET\n"
+					goAssemblerOracleOutput(t, target.goarch, source, "", false)
+					file, err := Parse(target.arch, source)
+					if err != nil {
+						return
+					}
+					for _, instruction := range file.Funcs[0].Instrs {
+						if instruction.Op == OpLABEL {
+							t.Fatalf("Go-rejected label syntax was admitted: %+v", instruction)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestParseLabelPrefixPendingInstructionBoundariesLikeGo(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		goarch, triple string
+		arch           Arch
+	}{
+		{"386", "i386-unknown-linux-gnu", ArchAMD64},
+		{"amd64", "x86_64-unknown-linux-gnu", ArchAMD64},
+		{"arm", "armv7-unknown-linux-gnueabihf", ArchARM},
+		{"arm64", "aarch64-unknown-linux-gnu", ArchARM64},
+		{"wasm", "wasm32-unknown-unknown", ArchWASM},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			const data = "DATA ·table(SB)/1,$1\nGLOBL ·table(SB),8,$1\n"
+			for _, test := range []struct {
+				name, source string
+				labels       [][]string
+			}{
+				{"text_entry", "entry:\nTEXT Probe(SB),4,$0-0\nNOP\nRET\n", [][]string{{"entry"}}},
+				{"unused_eof", "TEXT Probe(SB),4,$0-0\nNOP\nRET\nunused: unused:\n", [][]string{nil}},
+				{"data_keeps_pending", "TEXT Probe(SB),4,$0-0\nentry:\n" + data + "NOP\nRET\n", [][]string{{"entry"}}},
+				{"text_owns_pending", "TEXT First(SB),4,$0-0\nNOP\nRET\nentry:\n" + data + "TEXT Second(SB),4,$0-0\nNOP\nRET\n", [][]string{nil, {"entry"}}},
+			} {
+				t.Run(test.name, func(t *testing.T) {
+					goAssemblerOracleOutput(t, target.goarch, test.source, "", true)
+					file, err := Parse(target.arch, test.source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var labels [][]string
+					signatures := make(map[string]FuncSig)
+					for _, function := range file.Funcs {
+						var names []string
+						for _, instruction := range function.Instrs {
+							if instruction.Op == OpLABEL {
+								names = append(names, instruction.Args[0].Sym)
+							}
+							if instruction.Op != OpTEXT && instruction.Op != OpLABEL && instruction.Op != "NOP" && instruction.Op != OpRET {
+								t.Fatalf("label or data became an instruction: %+v", instruction)
+							}
+						}
+						labels = append(labels, names)
+						signatures[function.Sym] = FuncSig{Name: function.Sym, Ret: Void}
+					}
+					if !reflect.DeepEqual(labels, test.labels) {
+						t.Fatalf("pending label ownership differs from Go: actual=%v expected=%v", labels, test.labels)
+					}
+					ir, err := Translate(file, Options{Goarch: target.goarch, TargetTriple: target.triple, Sigs: signatures})
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "pending.ll", "pending.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/parser_long_lines_test.go b/parser_long_lines_test.go
new file mode 100644
index 000000000..00b7268fa
--- /dev/null
+++ b/parser_long_lines_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestParseLongAssemblyLinesAndMacroExpansions(t *testing.T) {
+	// Page-padding macros in gomonkey expand a short source line beyond
+	// bufio.Scanner's default 64 KiB limit. Go's token reader has no such
+	// physical-line limit. Test both preprocessing and expanded parsing.
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const count = 16384
+	padding := strings.Repeat("NOP; ", count)
+	var nested strings.Builder
+	nested.WriteString("#define PAD0 NOP;\n")
+	for level := 1; level <= 7; level++ {
+		fmt.Fprintf(&nested, "#define PAD%d %s\n", level, strings.Repeat(fmt.Sprintf("PAD%d; ", level-1), 4))
+	}
+	for _, tc := range []struct {
+		name, source string
+	}{
+		{"physical", "TEXT padding(SB),4,$0-0\n" + padding + "RET\n"},
+		{"definition", "#define PAD " + padding + "\nTEXT padding(SB),4,$0-0\nPAD\nRET\n"},
+		{"nested", nested.String() + "TEXT padding(SB),4,$0-0\nPAD7\nRET\n"},
+	} {
+		for _, target := range []struct {
+			goarch, triple string
+			arch           Arch
+		}{
+			{"386", "i386-unknown-linux-gnu", ArchAMD64},
+			{"amd64", "x86_64-unknown-linux-gnu", ArchAMD64},
+			{"arm", "armv7-unknown-linux-gnueabihf", ArchARM},
+			{"arm64", "aarch64-unknown-linux-gnu", ArchARM64},
+			{"wasm", "wasm32-unknown-unknown", ArchWASM},
+		} {
+			t.Run(tc.name+"/"+target.goarch, func(t *testing.T) {
+				dir := t.TempDir()
+				asm := filepath.Join(dir, "padding.s")
+				if err := os.WriteFile(asm, []byte(tc.source), 0600); err != nil {
+					t.Fatal(err)
+				}
+				cmd := exec.Command("go", "tool", "asm", "-o", filepath.Join(dir, "padding.o"), asm)
+				cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+target.goarch)
+				if out, err := cmd.CombinedOutput(); err != nil {
+					t.Fatalf("Go assembler rejected fixture: %v\n%s", err, out)
+				}
+				file, err := Parse(target.arch, tc.source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != count+2 {
+					t.Fatal("long line was truncated or instructions were lost")
+				}
+				for _, ins := range file.Funcs[0].Instrs[1 : count+1] {
+					if ins.Op != "NOP" {
+						t.Fatalf("unexpected padding instruction %+v", ins)
+					}
+				}
+				ir, err := Translate(file, Options{
+					Goarch: target.goarch, TargetTriple: target.triple,
+					Sigs: map[string]FuncSig{"padding": {Name: "padding", Ret: Void}},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "padding.ll", "padding.o", ir)
+			})
+		}
+	}
+}
+
+func TestParseLongCommentsPreserveFollowingSource(t *testing.T) {
+	for _, source := range []string{
+		"//" + strings.Repeat("comment ", 20000) + "\nTEXT padding(SB),4,$0-0\nRET",
+		"/*" + strings.Repeat("comment ", 20000) + "*/ TEXT padding(SB),4,$0-0\nRET",
+	} {
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 2 || file.Funcs[0].Instrs[1].Op != "RET" {
+			t.Fatal("source after a long comment was lost")
+		}
+	}
+}
diff --git a/parser_named_stack_role_test.go b/parser_named_stack_role_test.go
new file mode 100644
index 000000000..3dc22d3e1
--- /dev/null
+++ b/parser_named_stack_role_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestNamedStackOffsetKeepsItsSourceRole(t *testing.T) {
+	for _, name := range []string{"slot", "UNKNOWN", "槽"} {
+		for _, base := range []string{"SP", "RSP", "ESP", "R1"} {
+			t.Run(name+"/"+base, func(t *testing.T) {
+				memory, ok := parseMem(name + "(" + base + ")")
+				if !ok || memory.OffRaw != name || memory.Off != 0 {
+					t.Fatalf("bare spelling lost its original name: %+v, %t", memory, ok)
+				}
+				if _, constant := parseNamedStackConstantOffset(name); constant {
+					t.Fatal("a bare name is not a resolved constant displacement")
+				}
+			})
+		}
+		for _, offset := range []int64{-8, 0, 4} {
+			spelling := fmt.Sprintf("%s%+d", name, offset)
+			for _, base := range []string{"SP", "RSP", "ESP", "R1"} {
+				t.Run(spelling+"/"+base, func(t *testing.T) {
+					memory, ok := parseMem(spelling + "(" + base + ")")
+					if !ok || memory.Off != offset {
+						t.Fatalf("explicit displacement changed: %+v, %t", memory, ok)
+					}
+					if base == "SP" {
+						if memory.OffRaw != "" {
+							t.Fatal("named pseudo-SP constant was not resolved", memory)
+						}
+					} else if memory.OffRaw != spelling {
+						t.Fatal("physical base acquired NAME_AUTO resolution", memory)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestARM64StackOffsetCannotBorrowNamedPseudoSP(t *testing.T) {
+	for _, name := range []string{"slot", "UNKNOWN", "槽"} {
+		for _, offset := range []int64{-8, 0, 4} {
+			spelling := fmt.Sprintf("%s%+d", name, offset)
+			if offset == 0 {
+				spelling = name
+			}
+			for _, base := range []Reg{SP, "RSP"} {
+				t.Run(spelling+"/"+string(base), func(t *testing.T) {
+					memory := MemRef{Base: base, Off: offset, OffRaw: spelling}
+					_, _, _, err := arm64StackMemoryExtent(Instr{Op: "MOVD"}, memory)
+					if (err == nil) != (base == SP) {
+						t.Fatalf("only an actual pseudo-SP role may resolve a stack name: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/parser_opcode_suffix_test.go b/parser_opcode_suffix_test.go
new file mode 100644
index 000000000..ccd56547b
--- /dev/null
+++ b/parser_opcode_suffix_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// The official line grammar consumes Ident ('.' Ident)* before operands,
+// irrespective of spacing or CPP origins. An opcode-table probe alone does
+// not exercise serialization followed by a second parser.
+func TestParseOpcodeSuffixTokenGrammarGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, test := range []struct {
+		name, goarch, triple, opcode, operands string
+		arch                                   Arch
+	}{
+		{"arm64_postindex", "arm64", "aarch64-unknown-linux-gnu", "STP.P", "(ZR, ZR), 64(R4)", ArchARM64},
+		{"arm64_preindex", "arm64", "aarch64-unknown-linux-gnu", "STP.W", "(R0, R1), -16(R4)", ArchARM64},
+		{"arm_flags", "arm", "armv7-unknown-linux-gnueabihf", "ADD.S", "$255, R0, R1", ArchARM},
+		{"arm_postindex", "arm", "armv7-unknown-linux-gnueabihf", "MOVW.P", "4(R1), R0", ArchARM},
+		{"x86_multiple", "amd64", "x86_64-unknown-linux-gnu", "VADDPD.RN_SAE.Z", "Z3, Z2, K1, Z1", ArchAMD64},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			base, suffix, _ := strings.Cut(test.opcode, ".")
+			for _, variant := range []struct{ name, prefix, opcode string }{
+				{"compact", "", test.opcode},
+				{"spaced", "", strings.ReplaceAll(test.opcode, ".", " . ")},
+				{"comments", "", strings.ReplaceAll(test.opcode, ".", " /*before*/ . /*after*/ ")},
+				{"macro", "#define SUFFIX ." + suffix + "\n", base + " SUFFIX"},
+			} {
+				t.Run(variant.name, func(t *testing.T) {
+					source := variant.prefix + "TEXT Probe(SB),4,$0-0\n" + variant.opcode + " " + test.operands + "\nRET\n"
+					goAssemblerOracleOutput(t, test.goarch, source, "", true)
+					expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{FileName: "suffix.s"})
+					if err != nil {
+						t.Fatal(err)
+					}
+					goAssemblerOracleOutput(t, test.goarch, expanded, "", true)
+					for index, input := range []string{source, expanded} {
+						file, err := Parse(test.arch, input)
+						if err != nil {
+							t.Fatalf("suffix grammar path=%d: %v", index, err)
+						}
+						if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 || file.Funcs[0].Instrs[1].Op != Op(test.opcode) {
+							t.Fatalf("suffix became an operand or was lost: path=%d file=%+v", index, file)
+						}
+						ir, err := Translate(file, Options{
+							Goarch: test.goarch, TargetTriple: test.triple,
+							Sigs: map[string]FuncSig{"Probe": {Name: "Probe", Ret: Void}},
+						})
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, test.triple, "suffix.ll", "suffix.o", ir)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/parser_semicolon_literals_test.go b/parser_semicolon_literals_test.go
new file mode 100644
index 000000000..31f2cfbab
--- /dev/null
+++ b/parser_semicolon_literals_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestSplitSemicolonsRetainsWholeGoQuotedTokens(t *testing.T) {
+	for _, row := range []struct {
+		source string
+		want   []string
+	}{
+		{" ; RET; ;", []string{"", "RET", "", ""}},
+		{`DATA value(SB)/4,$"a;b";RET`, []string{`DATA value(SB)/4,$"a;b"`, "RET"}},
+		{`BYTE $';';RET`, []string{`BYTE $';'`, "RET"}},
+		{`DATA value(SB)/8,$"a\";b";RET`, []string{`DATA value(SB)/8,$"a\";b"`, "RET"}},
+		{`DATA value(SB)/8,$"a\\;b";RET`, []string{`DATA value(SB)/8,$"a\\;b"`, "RET"}},
+		{`DATA value(SB)/8,$"unterminated;`, []string{`DATA value(SB)/8,$"unterminated;`}},
+	} {
+		t.Run(row.source, func(t *testing.T) {
+			if got := splitSemicolons(row.source); !reflect.DeepEqual(got, row.want) {
+				t.Fatalf("quoted token was split: got=%q want=%q", got, row.want)
+			}
+		})
+	}
+}
+
+func TestParseSemicolonStringDataMatchesActualGoFiveArch(t *testing.T) {
+	for _, target := range []struct {
+		name string
+		arch Arch
+	}{
+		{"386", ArchAMD64}, {"amd64", ArchAMD64}, {"arm", ArchARM},
+		{"arm64", ArchARM64}, {"wasm", ArchWASM},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			for _, payload := range []string{";", "a;b", "a\";b", "a\\;b", "//;/*;", "x;\x00;y"} {
+				t.Run(strconv.Quote(payload), func(t *testing.T) {
+					source := fmt.Sprintf("DATA text<>+0(SB)/8,$%s;GLOBL text<>(SB),8,$8\nTEXT Probe(SB),4,$0-0\nRET\n", strconv.Quote(payload))
+					goAssemblerOracleOutput(t, target.name, source, "", true)
+					file, err := Parse(target.arch, source)
+					if err != nil || len(file.Data) != 1 || len(file.Globl) != 1 || len(file.Funcs) != 1 {
+						t.Fatalf("actual Go-accepted quoted DATA lost statement boundaries: %v", err)
+					}
+					if string(file.Data[0].Payload) != payload || file.Data[0].Width != 8 {
+						t.Fatalf("quoted DATA bytes changed: %+v", file.Data[0])
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestSemicolonStringDataThreeAPIsFiveLLVMTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct {
+		goarch, triple string
+		arch           Arch
+	}{
+		{"386", "i386-unknown-linux-gnu", ArchAMD64},
+		{"amd64", "x86_64-unknown-linux-gnu", ArchAMD64},
+		{"arm", "armv7-unknown-linux-gnueabihf", ArchARM},
+		{"arm64", "aarch64-unknown-linux-gnu", ArchARM64},
+		{"wasm", "wasm32-unknown-unknown", ArchWASM},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			pkg := x86AddSubLiteralPackage(t, target.goarch, "func Probe()\n")
+			resolve := func(symbol string) string {
+				return strings.TrimSuffix(strings.TrimPrefix(symbol, "·"), "<>")
+			}
+			for _, payload := range []string{";", "a;b", "a\";b", "a\\;b", "//;/*;", "x;\x00;y"} {
+				t.Run(strconv.Quote(payload), func(t *testing.T) {
+					source := fmt.Sprintf("DATA text<>+0(SB)/8,$%s;GLOBL text<>(SB),8,$8\nTEXT ·Probe(SB),4,$0-0\nRET\n", strconv.Quote(payload))
+					goAssemblerOracleOutput(t, target.goarch, source, "", true)
+					file, err := Parse(target.arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: target.goarch, TargetTriple: target.triple,
+						ResolveSym: resolve, Sigs: map[string]FuncSig{"Probe": {Name: "Probe", Ret: Void}}}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							ctx := llvm.NewContext()
+							defer ctx.Dispose()
+							var module llvm.Module
+							var err error
+							switch api {
+							case "text":
+								var ir string
+								ir, err = Translate(file, options)
+								if err == nil {
+									module, err = parseIRModuleInContext(ctx, ir)
+								}
+							case "module":
+								module, err = TranslateModuleInContext(ctx, file, options)
+							case "GoModule":
+								var result *GoModuleTranslation
+								result, err = translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+									GOARCH: target.goarch, TargetTriple: target.triple, ResolveSym: resolve})
+								if result != nil {
+									module = result.Module
+								}
+							}
+							if !module.IsNil() {
+								defer module.Dispose()
+							}
+							if err != nil || module.IsNil() {
+								t.Fatalf("quoted DATA translation failed: %v", err)
+							}
+							global := module.NamedGlobal("text")
+							if global.IsNil() || global.Initializer().IsNil() || !global.Initializer().IsConstantString() {
+								t.Fatal("quoted DATA lost its initialized byte array")
+							}
+							want := payload + strings.Repeat("\x00", 8-len(payload))
+							if got := global.Initializer().ConstGetAsString(); got != want {
+								t.Fatalf("quoted DATA bytes changed: got=%q want=%q", got, want)
+							}
+							compileLLVMToObject(t, llc, target.triple, "quoted-data.ll", "quoted-data.o", module.String())
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/parser_symbol_offset_spacing_test.go b/parser_symbol_offset_spacing_test.go
new file mode 100644
index 000000000..45ceae15a
--- /dev/null
+++ b/parser_symbol_offset_spacing_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import "testing"
+
+func TestParseSymbolOffsetsWithGoExpressionWhitespace(t *testing.T) {
+	tests := []struct {
+		text string
+		name string
+		off  int64
+		kind OperandKind
+	}{
+		{"z+ 0(FP)", "z", 0, OpFP},
+		{"x + 8(FP)", "x", 8, OpFP},
+		{"y - 16(FP)", "y", -16, OpFP},
+		{"result+(4*2)(FP)", "result", 8, OpFP},
+		{"result+8-4(FP)", "result", 4, OpFP},
+		{"$result + 8(FP)", "result", 8, OpFPAddr},
+	}
+	for _, tt := range tests {
+		t.Run(tt.text, func(t *testing.T) {
+			got, err := parseOperand(tt.text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got.Kind != tt.kind || got.FPName != tt.name || got.FPOffset != tt.off {
+				t.Fatalf("parseOperand(%q) = %+v, want %v %q %+d", tt.text, got, tt.kind, tt.name, tt.off)
+			}
+		})
+	}
+}
+
+func TestSplitSymbolOffsetsWithGoExpressionWhitespace(t *testing.T) {
+	tests := []struct {
+		text string
+		name string
+		off  int64
+	}{
+		{"foo+ 8", "foo", 8},
+		{"foo - 8", "foo", -8},
+		{"foo+(2*4)", "foo", 8},
+		{"foo+8-4", "foo", 4},
+		{"foo-bar", "foo-bar", 0},
+	}
+	for _, tt := range tests {
+		gotName, gotOff := splitSymPlusOff(tt.text)
+		if gotName != tt.name || gotOff != tt.off {
+			t.Errorf("splitSymPlusOff(%q) = %q, %d; want %q, %d", tt.text, gotName, gotOff, tt.name, tt.off)
+		}
+	}
+}
+
+func TestParseFPRejectsUnresolvedOffsets(t *testing.T) {
+	for _, source := range []string{"arg+unknown(FP)", "arg-unknown(FP)"} {
+		if _, _, ok := parseFP(source); ok {
+			t.Errorf("parseFP(%q) accepted an unresolved offset", source)
+		}
+	}
+}
diff --git a/parser_test.go b/parser_test.go
index 90a0d3de1..95a1c660b 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -34,6 +31,16 @@ RET
 	}
 }
 
+func TestParseNormalizesLegacyZeroTextSymbolOffset(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Sqrtf+0(SB),NOSPLIT,$0-8\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := file.Funcs[0].Sym; got != "·Sqrtf" {
+		t.Fatalf("TEXT symbol = %q, want %q", got, "·Sqrtf")
+	}
+}
+
 func TestParseDefineAndSemicolons(t *testing.T) {
 	src := `
 #define X BYTE $0x01; BYTE $0x02
@@ -252,6 +259,46 @@ RET
 	}
 }
 
+func TestParseArithmeticOffsetBeforeBaseRegister(t *testing.T) {
+	file, err := Parse(ArchAMD64, `
+TEXT arithmeticOffset(SB),NOSPLIT,$0-0
+	ADDQ 0+(1*16)(BP), R10
+	MOVQ (-64*1024+104)(SP), AX
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	first := file.Funcs[0].Instrs[1].Args[0]
+	if first.Kind != OpMem || first.Mem.Base != BP || first.Mem.Off != 16 {
+		t.Fatalf("first operand = %#v, want 16(BP)", first)
+	}
+	second := file.Funcs[0].Instrs[2].Args[0]
+	if second.Kind != OpMem || second.Mem.Base != SP || second.Mem.Off != -65432 {
+		t.Fatalf("second operand = %#v, want -65432(SP)", second)
+	}
+}
+
+func TestParseX86TLSPseudoRegisterAndRelocationIndex(t *testing.T) {
+	file, err := Parse(ArchAMD64, `
+TEXT tlsforms(SB),NOSPLIT,$0-0
+	MOVQ TLS, CX
+	MOVQ 0(CX)(TLS*1), BX
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	loadBase := file.Funcs[0].Instrs[1].Args[0]
+	if loadBase.Kind != OpReg || loadBase.Reg != Reg("TLS") {
+		t.Fatalf("TLS source = %#v, want TLS pseudo-register", loadBase)
+	}
+	indexed := file.Funcs[0].Instrs[2].Args[0]
+	if indexed.Kind != OpMem || indexed.Mem.Base != CX || indexed.Mem.Index != Reg("TLS") || indexed.Mem.Scale != 1 {
+		t.Fatalf("TLS relocation memory = %#v, want 0(CX)(TLS*1)", indexed)
+	}
+}
+
 func TestParseFunctionLikeMacroCall(t *testing.T) {
 	src := `
 #define ROUND1(a,b) MOVL a, b; ADDL $1, b
diff --git a/parser_unlinked_prelude_test.go b/parser_unlinked_prelude_test.go
new file mode 100644
index 000000000..1896c3de6
--- /dev/null
+++ b/parser_unlinked_prelude_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestParseIgnoresGoUnlinkedInstructionsBeforeFirstTEXT(t *testing.T) {
+	const source = `
+	VST1.P [V0.D1, V1.D1, V2.D1, V3.D1], 32(R0)
+	RET
+TEXT linked(SB),$0-0
+	MOVD $7, R0
+	RET
+`
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 || file.Funcs[0].Sym != "linked" {
+		t.Fatalf("prelude attached to a linked function: %+v", file.Funcs)
+	}
+	if len(file.UnlinkedPrelude) != 2 || !strings.HasPrefix(file.UnlinkedPrelude[0], "VST1.P") || file.UnlinkedPrelude[1] != "RET" {
+		t.Fatalf("unlinked prelude not retained as evidence: %#v", file.UnlinkedPrelude)
+	}
+	opt := Options{
+		Goarch: "arm64", TargetTriple: arm64LinuxGNUTriple,
+		Sigs: map[string]FuncSig{"linked": {Name: "linked", Ret: I64}},
+	}
+	ir, err := Translate(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Compare with an independently parsed linked-only source. Its return may
+	// use an SSA load rather than a folded constant; that is not a parser bug.
+	const linkedSource = "TEXT linked(SB),$0-0\nMOVD $7,R0\nRET\n"
+	requireARM64GoAssemblerResult(t, linkedSource, true)
+	linked, err := Parse(ArchARM64, linkedSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want, err := Translate(linked, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	withoutModulePath := func(ir string) string {
+		var body strings.Builder
+		for _, line := range strings.Split(ir, "\n") {
+			// LLVM assigns each independent parse a temporary module path.
+			// Ignore only that provenance, not instructions or attributes.
+			if strings.HasPrefix(line, "; ModuleID = ") || strings.HasPrefix(line, "source_filename = ") {
+				continue
+			}
+			body.WriteString(line)
+			body.WriteByte('\n')
+		}
+		return body.String()
+	}
+	if withoutModulePath(ir) != withoutModulePath(want) {
+		t.Fatalf("unlinked prelude changed linked IR:\ngot:\n%s\nwant:\n%s", ir, want)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "unlinked-prelude.ll", "unlinked-prelude.o", ir)
+}
+
+func TestParseStillRejectsSourceWithoutTEXTOrData(t *testing.T) {
+	if _, err := Parse(ArchARM64, "VST1.P [V0.D1, V1.D1], 16(R0)\n"); err == nil {
+		t.Fatal("accepted a source with no linked function or data")
+	}
+}
diff --git a/parser_x86_branch.go b/parser_x86_branch.go
new file mode 100644
index 000000000..14e04a288
--- /dev/null
+++ b/parser_x86_branch.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+import "strings"
+
+// Go's jump parser classifies the original case-sensitive token, not the
+// shared parser's cross-architecture register aliases. This is only syntax:
+// native register, indirect, PC-relative and callee contracts remain separate.
+func parseX86BranchIdentifier(op Op, source string) (Operand, bool) {
+	name := normalizeInstructionOpcode(op)
+	if !strings.HasPrefix(name, "J") && name != "CALL" &&
+		!strings.HasPrefix(name, "LOOP") && name != "XBEGIN" {
+		return Operand{}, false
+	}
+	identifier, bare := parseIdent(source)
+	if !bare {
+		return Operand{}, false
+	}
+	if identifier == "g" {
+		// Preserve the shared parser's existing AMD64 alias. The actual
+		// source mode still owns its distinct 386 applicability checks.
+		return Operand{Kind: OpReg, Reg: "R14"}, true
+	}
+	if x86SymbolGoRegisterName(identifier) || identifier == "SB" || identifier == "FP" || identifier == "PC" {
+		return Operand{Kind: OpReg, Reg: Reg(identifier)}, true
+	}
+	return Operand{Kind: OpIdent, Ident: identifier}, true
+}
diff --git a/parser_x86_branch_namespace_test.go b/parser_x86_branch_namespace_test.go
new file mode 100644
index 000000000..319b559c7
--- /dev/null
+++ b/parser_x86_branch_namespace_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestParseX86BranchLabelsRespectGoRegisterCase(t *testing.T) {
+	// Go's shared jump parser classifies its original, case-sensitive token
+	// before distinguishing JMP, CALL, Jcc, LOOP and transactional branches.
+	var labels []string
+	for _, name := range x86SymbolIndexedActualRegisterNames(t) {
+		labels = append(labels, strings.ToLower(name))
+	}
+	// Cross-architecture names and Intel aliases are not Go x86 registers.
+	labels = append(labels, "R0", "V1", "ZR", "LR", "RAX", "EAX", "Xmm0", "aX", "G", "pc", "fp", "sb")
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"JMP", "CALL", "JEQ", "JEQ $0,", "JEQ $1,", "LOOP", "XBEGIN"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				var source strings.Builder
+				for index, label := range labels {
+					fmt.Fprintf(&source, "TEXT ·branch%d(SB),4,$0-0\n%s %s\n%s:\nRET\n", index, op, label, label)
+				}
+				if op == "CALL" {
+					// Preserve the complete original CALL-label source as a
+					// frontend-only control. Go's x86 encoder cannot consume
+					// local TYPE_BRANCH calls: the retained first attempt exits
+					// 2 with "call without target" and a doasm panic. This is
+					// neither an accepted Go object nor a rejection certificate.
+					t.Log("CALL local labels: parser-only identity; no Go object or execution claim")
+				} else {
+					goAssemblerOracleOutput(t, arch, source.String(), "", true)
+				}
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil || len(file.Funcs) != len(labels) {
+					t.Fatal("complete original label inventory did not parse", err)
+				}
+				for index, function := range file.Funcs {
+					operands := function.Instrs[1].Args
+					operand := operands[len(operands)-1]
+					if operand.Kind != OpIdent || operand.Ident != labels[index] {
+						t.Errorf("Go label %q became a register or changed case: %+v", labels[index], operand)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestParseX86BranchOperandsKeepNativeRegisterIdentity(t *testing.T) {
+	names := append(x86SymbolIndexedActualRegisterNames(t), "SB", "FP", "PC", "g")
+	for _, op := range []string{"JMP", "CALL", "JEQ", "LOOP", "XBEGIN"} {
+		for _, name := range names {
+			operands, err := parseOperandsCSV(ArchAMD64, Op(op), name)
+			want := Reg(name)
+			if name == "g" {
+				want = "R14"
+			}
+			if err != nil || len(operands) != 1 || operands[0].Kind != OpReg || operands[0].Reg != want {
+				t.Errorf("original register token became a local label: %s %s: %+v / %v", op, name, operands, err)
+			}
+		}
+	}
+	for _, op := range []string{"JMP", "CALL"} {
+		for _, spelling := range []string{"*AX", "(AX)", "·target(SB)", "4(PC)"} {
+			operands, err := parseOperandsCSV(ArchAMD64, Op(op), spelling)
+			if err != nil || len(operands) != 1 || operands[0].Kind == OpIdent || operands[0].Kind == OpLabel {
+				t.Errorf("indirect, external or PC-relative source became a bare label: %s %s: %+v / %v", op, spelling, operands, err)
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"JMP", "CALL", "JEQ", "LOOP", "XBEGIN"} {
+			// A label with the same spelling does not override Go's register
+			// namespace. JMP/CALL retain indirect AX; the others reject it.
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-0\n%s AX\nAX:\nRET\n", op)
+			goAssemblerOracleOutput(t, arch, source, "", op == "JMP" || op == "CALL")
+		}
+	}
+}
diff --git a/parser_x86_symbol_index.go b/parser_x86_symbol_index.go
new file mode 100644
index 000000000..7ebf822ce
--- /dev/null
+++ b/parser_x86_symbol_index.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var x86SymbolPseudoGroup = regexp.MustCompile(`\(\s*(FP|SP|SB|PC)\s*\)`)
+var x86SymbolGIndex = regexp.MustCompile(`\(\s*g\s*\*`)
+
+// The group after a named pseudo base is not always an index. Go's operand
+// parser sets Reg for (SI), but Index for (SI*1); a third group supplies Index
+// only when the second supplied Reg. Retain that distinction even where a
+// native encoder rejects or ignores Reg. Parsing does not establish storage.
+func parseX86SymbolIndexedMemory(source string) (memory MemRef, matched bool, err error) {
+	source = strings.TrimSpace(source)
+	group := x86SymbolPseudoGroup.FindStringSubmatchIndex(source)
+	if group == nil || strings.TrimSpace(source[group[1]:]) == "" {
+		return MemRef{}, false, nil
+	}
+	matched = true
+	role := source[group[2]:group[3]]
+	if role == "PC" {
+		return MemRef{}, true, fmt.Errorf("x86 PC-relative branch cannot have an extra address register: %q", source)
+	}
+	prefix := strings.TrimSpace(source[:group[0]])
+	if role == "SP" {
+		if _, constant := parseImmExpr(prefix); prefix == "" || constant {
+			return MemRef{}, false, nil // Physical SP, including decoder syntax.
+		}
+	}
+	name, _, valid := parseFP(prefix + "(FP)")
+	if !valid || name == "" || name[0] >= '0' && name[0] <= '9' || strings.IndexAny(name, "*/&|^%=!$:[]") >= 0 {
+		return MemRef{}, true, fmt.Errorf("x86 indexed pseudo base requires a symbol and constant displacement: %q", source)
+	}
+	memory.Sym = prefix + "(" + role + ")"
+	rest := strings.TrimSpace(source[group[1]:])
+	register, scale, scaled, rest, err := parseX86SymbolRegisterGroup(rest)
+	if err != nil {
+		return MemRef{}, true, err
+	}
+	if scaled {
+		memory.Index, memory.Scale = register, scale
+		if rest != "" {
+			return MemRef{}, true, fmt.Errorf("x86 scaled index must be the final address group: %q", source)
+		}
+		return memory, true, nil
+	}
+	memory.Base = register
+	if rest != "" {
+		register, scale, _, rest, err = parseX86SymbolRegisterGroup(rest)
+		if err != nil {
+			return MemRef{}, true, err
+		}
+		memory.Index, memory.Scale = register, scale
+		if rest != "" {
+			return MemRef{}, true, fmt.Errorf("x86 address has more than a base and index group: %q", source)
+		}
+	}
+	return memory, true, nil
+}
+
+func parseX86SymbolRegisterGroup(source string) (register Reg, scale int64, scaled bool, rest string, err error) {
+	bad := func() (Reg, int64, bool, string, error) {
+		return "", 0, false, "", fmt.Errorf("invalid x86 symbolic address register/scale group: %q", source)
+	}
+	if !strings.HasPrefix(source, "(") {
+		return bad()
+	}
+	end := strings.IndexByte(source, ')')
+	if end < 0 {
+		return bad()
+	}
+	inner := strings.TrimSpace(source[1:end])
+	rest = strings.TrimSpace(source[end+1:])
+	name := inner
+	if before, after, found := strings.Cut(inner, "*"); found {
+		name, scaled = strings.TrimSpace(before), true
+		// parseScale consumes one token's spelling, not an integer expression.
+		// In particular 01, 0x1, +1 and (1) are not the decimal token "1".
+		switch strings.TrimSpace(after) {
+		case "1":
+			scale = 1
+		case "2":
+			scale = 2
+		case "4":
+			scale = 4
+		case "8":
+			scale = 8
+		default:
+			return bad()
+		}
+	}
+	if name == "FP" || name == "SB" || name == "PC" {
+		return "", 0, false, "", fmt.Errorf("%w: a second pseudo register overwrites the original named address role: %q", ErrProbeNeedsContext, source)
+	}
+	if name == "g" {
+		return "", 0, false, "", fmt.Errorf("%w: named x86 g annotation requires its original 386/amd64 source mode", ErrProbeNeedsContext)
+	}
+	if !x86SymbolGoRegisterName(name) {
+		return bad()
+	}
+	return Reg(name), scale, scaled, rest, nil
+}
+
+// This finite spelling grammar is Go's x86.Register inventory, not an LLVM
+// register permission. In particular a named 386 operand can annotate a Reg
+// that the encoder ignores, even when it is not a physical 386 GP register.
+func x86SymbolGoRegisterName(name string) bool {
+	switch name {
+	case "AL", "CL", "DL", "BL", "SPB", "BPB", "SIB", "DIB",
+		"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI",
+		"AH", "CH", "DH", "BH", "CS", "SS", "DS", "ES", "FS", "GS",
+		"GDTR", "IDTR", "LDTR", "MSW", "TASK", "TLS", "MAXREG":
+		return true
+	}
+	for _, bank := range []struct {
+		prefix, suffix string
+		min, max       int
+	}{
+		{"R", "", 8, 15}, {"R", "B", 8, 15},
+		{"F", "", 0, 7}, {"M", "", 0, 7}, {"K", "", 0, 7},
+		{"X", "", 0, 31}, {"Y", "", 0, 31}, {"Z", "", 0, 31},
+		{"CR", "", 0, 15}, {"DR", "", 0, 7}, {"TR", "", 0, 7},
+	} {
+		if !strings.HasPrefix(name, bank.prefix) || !strings.HasSuffix(name, bank.suffix) {
+			continue
+		}
+		number := strings.TrimSuffix(strings.TrimPrefix(name, bank.prefix), bank.suffix)
+		value, err := strconv.Atoi(number)
+		if err == nil && value >= bank.min && value <= bank.max && number == strconv.Itoa(value) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/parser_x86_symbol_index_test.go b/parser_x86_symbol_index_test.go
new file mode 100644
index 000000000..70113da75
--- /dev/null
+++ b/parser_x86_symbol_index_test.go
@@ -0,0 +1,866 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	goparser "go/parser"
+	"go/token"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86SymbolIndexedAddressGoRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			operand     string
+			accepted64  bool
+			base, index Reg
+			scale       int64
+		}{
+			{"dst_base+0(FP)(SI*1)", true, "", SI, 1},
+			{"dst_base + (2 * 4) (FP) (CX * 2)", true, "", CX, 2},
+			{"local-8(SP)(BX*4)", true, "", BX, 4},
+			{"table<>+8(SB)(BX*8)", false, "", BX, 8},
+			{"dst_base(FP)(SI)", false, SI, "", 0},
+			{"dst_base(FP)(SP)", true, SP, "", 0},
+			{"dst_base(FP)(SP)(CX*2)", true, SP, CX, 2},
+			{"dst_base(FP)(SI)(CX*2)", false, SI, CX, 2},
+			{"table<>(SB)(SI)", false, SI, "", 0},
+			{"table<>(SB)(SI)(CX*2)", false, SI, CX, 2},
+		} {
+			t.Run(arch+"/"+row.operand, func(t *testing.T) {
+				source := "TEXT index(SB),4,$0-32\nLEAL " + row.operand + ",AX\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, arch == "386" || row.accepted64)
+				operand, err := parseOperandForArch(ArchAMD64, row.operand)
+				if err != nil || operand.Kind != OpMem || operand.Mem.Sym == "" ||
+					operand.Mem.Base != row.base || operand.Mem.Index != row.index || operand.Mem.Scale != row.scale {
+					t.Fatalf("symbol role/base/index was lost: %+v / %v", operand, err)
+				}
+				copy, err := parseOperandForArch(ArchAMD64, operand.String())
+				if err != nil || !reflect.DeepEqual(copy, operand) {
+					t.Fatalf("typed address round trip changed role: %s => %+v / %v", operand.String(), copy, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressCompleteNamedForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		widths := []string{"W", "L"}
+		if arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, role := range []string{"FP", "SP", "SB"} {
+				for _, prefix := range []string{"arg", "arg+0", "arg-8", "arg + (2 * 4)"} {
+					for _, scale := range []string{"1", "2", "4", "8"} {
+						operand := prefix + "(" + role + ")(CX*" + scale + ")"
+						t.Run(arch+"/"+width+"/"+operand, func(t *testing.T) {
+							source := "TEXT index(SB),4,$0-32\nLEA" + width + " " + operand + ",AX\nRET\n"
+							x86ScalarLiteralExpectedGoListing(t, arch, source, arch == "386" || role != "SB")
+							parsed, err := parseOperandForArch(ArchAMD64, operand)
+							if err != nil || parsed.Kind != OpMem || parsed.Mem.Index != CX || parsed.Mem.Sym != prefix+"("+role+")" {
+								t.Fatalf("named address roles: %+v / %v", parsed, err)
+							}
+							_, err = x86LEAOperandWidth(Instr{Op: Op("LEA" + width), Args: []Operand{parsed, {Kind: OpReg, Reg: AX}}}, arch)
+							if role != "SB" && !errors.Is(err, ErrProbeNeedsContext) || role == "SB" && (err == nil) != (arch == "386") {
+								t.Fatalf("encoding shape borrowed storage permission: %v", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressRejectsMalformedGroups(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operand := range []string{
+			"0(FP)(CX*2)", "0(SB)(CX*2)", "arg+UNKNOWN(FP)(CX*2)",
+			"arg(FP)(AX+CX)",
+			"arg(FP)(CX*2)(DX*4)", "arg(FP)(AX)(CX*2)(DX*4)",
+			"arg(FP)(RAX*2)", "arg(FP)(CX*2)trailing", "arg(FP)(CX*2",
+		} {
+			t.Run(arch+"/"+operand, func(t *testing.T) {
+				source := "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+				if _, err := parseOperandForArch(ArchAMD64, operand); err == nil {
+					t.Fatal("malformed group fell back to an ordinary symbol")
+				}
+			})
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressPseudoOverwriteNeedsContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range [][2]string{{"arg(FP)(FP*2)", "arg(FP)"}, {"arg(FP)(SB*2)", "arg(SB)"}} {
+			source := func(operand string) string {
+				return "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+			}
+			left := x86PackedShiftActualGoBytes(t, arch, source(row[0]))
+			right := x86PackedShiftActualGoBytes(t, arch, source(row[1]))
+			if !bytes.Equal(left, right) {
+				t.Fatalf("actual Go pseudo role overwrite: %v: %x != %x", row, left, right)
+			}
+			if _, err := parseOperandForArch(ArchAMD64, row[0]); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unbound alternate pseudo role did not remain Context: %v", err)
+			}
+		}
+	}
+	operand, err := parseOperandForArch(ArchAMD64, "arg(SB)(SI)(CX)")
+	if err != nil || operand.Kind != OpMem || operand.Mem.Index != CX || operand.Mem.Scale != 0 {
+		t.Fatalf("unscaled third group role was lost: %+v / %v", operand, err)
+	}
+	if err := x86SymbolIndexedMemoryError(operand.Mem, "386"); err == nil {
+		t.Fatal("Go asmidx rejects zero scale; it must not be normalized to one")
+	}
+}
+
+func TestX86SymbolIndexedAddressActualObjectRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		pc := 8
+		if arch == "386" {
+			pc = 4
+		}
+		for _, row := range []struct{ symbolic, physical string }{
+			{"arg+0(FP)(SI*1)", fmt.Sprintf("%d(SP)(SI*1)", pc)},
+			{"arg+(2*4)(FP)(CX*2)", fmt.Sprintf("%d(SP)(CX*2)", pc+8)},
+			{"local+8(SP)(BX*4)", "8(SP)(BX*4)"},
+			{"arg(FP)(SP)(CX*2)", fmt.Sprintf("%d(SP)(CX*2)", pc)},
+		} {
+			source := func(operand string) string {
+				return "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+			}
+			symbolic := x86PackedShiftActualGoBytes(t, arch, source(row.symbolic))
+			physical := x86PackedShiftActualGoBytes(t, arch, source(row.physical))
+			if !bytes.Equal(symbolic, physical) {
+				t.Fatalf("%s Go role changed actual address: %s=%x, %s=%x", arch, row.symbolic, symbolic, row.physical, physical)
+			}
+		}
+		if arch == "386" {
+			for _, address := range []string{"table<>(SB)(CX*4)", "table<>(SB)(SI)(CX*4)"} {
+				source := func(operand string) string {
+					return "TEXT index(SB),4,$0-0\nMOVL $" + operand + ",AX\nRET\n"
+				}
+				left := x86PackedShiftActualGoBytes(t, arch, source(address))
+				right := x86PackedShiftActualGoBytes(t, arch, source("table<>(SB)"))
+				if !bytes.Equal(left, right) {
+					t.Fatalf("386 TYPE_ADDR unexpectedly consumed a base/index: %s: %x != %x", address, left, right)
+				}
+			}
+			// In Go's NAME_PARAM/NAME_EXTERN encoder, Reg is not Index.
+			// The nonscaled second register is discarded, not multiplied by 1.
+			for _, pair := range [][2]string{{"arg(FP)(SI)", "arg(FP)"}, {"table<>(SB)(SI)", "table<>(SB)"}} {
+				source := func(operand string) string {
+					return "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+				}
+				left := x86PackedShiftActualGoBytes(t, arch, source(pair[0]))
+				right := x86PackedShiftActualGoBytes(t, arch, source(pair[1]))
+				if !bytes.Equal(left, right) {
+					t.Fatalf("386 nonscaled annotation became an index: %v: %x != %x", pair, left, right)
+				}
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressActualScaleTokens(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, scale := range []string{"1", "2", "4", "8", "0", "3", "16", "-1", "01", "0x1", "(1)", "1+0"} {
+			t.Run(arch+"/"+scale, func(t *testing.T) {
+				accepted := scale == "1" || scale == "2" || scale == "4" || scale == "8"
+				operand := "arg(FP)(CX*" + scale + ")"
+				source := "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, accepted)
+				parsed, err := parseOperandForArch(ArchAMD64, operand)
+				if accepted && (err != nil || parsed.Kind != OpMem) || !accepted && err == nil {
+					t.Fatalf("scale token accepted=%t: %+v / %v", accepted, parsed, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressControlUsesBranchNotMemory(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CALL", "JMP", "RET"} {
+			var annotated, plain strings.Builder
+			annotated.WriteString("TEXT index(SB),4,$0-0\n")
+			plain.WriteString("TEXT index(SB),4,$0-0\n")
+			for _, name := range x86SymbolIndexedActualRegisterNames(t) {
+				for _, suffix := range []string{"", "*1"} {
+					if suffix != "" {
+						switch name {
+						case "CS", "DS", "ES", "FS", "GS":
+							// prefixof still sees these Index fields after
+							// progedit changes TYPE_MEM to TYPE_BRANCH.
+							continue
+						}
+					}
+					fmt.Fprintf(&annotated, "%s target<>+4(SB)(%s%s)\n", op, name, suffix)
+					fmt.Fprintf(&plain, "%s target<>+4(SB)\n", op)
+				}
+			}
+			annotated.WriteString("RET\n")
+			plain.WriteString("RET\n")
+			if !bytes.Equal(x86PackedShiftActualGoBytes(t, arch, annotated.String()), x86PackedShiftActualGoBytes(t, arch, plain.String())) {
+				t.Fatalf("%s %s TYPE_BRANCH consumed an unused Go register annotation", arch, op)
+			}
+			for name, prefix := range x86SymbolIndexedActualSegmentPrefixes(t, arch) {
+				// NOFRAME keeps the original prefix adjacent to the branch:
+				// this is an object-only source-role oracle, never a call ABI.
+				source := func(operand string) string {
+					return "TEXT index(SB),516,$0-0\n" + op + " " + operand + "\nRET\n"
+				}
+				address := "target<>+4(SB)(" + name + "*1)"
+				got := x86PackedShiftActualGoBytes(t, arch, source(address))
+				want := x86PackedShiftActualGoBytes(t, arch, source("target<>+4(SB)"))
+				if prefix != 0 {
+					want = append([]byte{prefix}, want...)
+				}
+				if !bytes.Equal(got, want) {
+					t.Fatalf("%s %s TYPE_BRANCH prefix differs from actual Go prefixof: %s / %x != %x", arch, op, name, got, want)
+				}
+				file, err := Parse(ArchAMD64, source(address))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := validateResolvedImmediates(ArchAMD64, file.Funcs[0]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("source-encoder branch prefix acquired an entry contract: %v", err)
+				}
+			}
+			for _, register := range []string{"SI", "R11*4"} {
+				source := func(operand string) string {
+					return "TEXT index(SB),4,$0-0\n" + op + " " + operand + "\nRET\n"
+				}
+				address := "target<>+4(SB)(" + register + ")"
+				annotated := x86PackedShiftActualGoBytes(t, arch, source(address))
+				plain := x86PackedShiftActualGoBytes(t, arch, source("target<>+4(SB)"))
+				if !bytes.Equal(annotated, plain) {
+					t.Fatalf("Go named control operand unexpectedly consumed an index: %s %s / %x != %x", arch, op, annotated, plain)
+				}
+				indexedListing, _ := x86ScalarLiteralGoListing(t, arch, source(address))
+				plainListing, _ := x86ScalarLiteralGoListing(t, arch, source("target<>+4(SB)"))
+				relocations := func(listing string) []string {
+					var rows []string
+					for _, line := range strings.Split(listing, "\n") {
+						if line = strings.TrimSpace(line); strings.HasPrefix(line, "rel ") {
+							rows = append(rows, line)
+						}
+					}
+					return rows
+				}
+				left, right := relocations(indexedListing), relocations(plainListing)
+				if len(left) == 0 || !reflect.DeepEqual(left, right) {
+					t.Fatalf("Go named branch relocation changed: %s %s / %v != %v", arch, op, left, right)
+				}
+				file, err := Parse(ArchAMD64, source(address))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := validateResolvedImmediates(ArchAMD64, file.Funcs[0]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("named source branch became an ordinary RIP memory error/permission: %s %s / %v", arch, op, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedControlThreeAPIsRequireEntryContract(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"CALL", "JMP", "RET"} {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func index()\n")
+				source := "TEXT ·index(SB),4,$0-0\n" + op + " target<>+4(SB)(CX*2)\nRET\n"
+				x86ScalarLiteralGoListing(t, target.arch, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(sym string) string { return strings.Replace(sym, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						switch api {
+						case "text":
+							_, err = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, err = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								defer module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								defer result.Module.Dispose()
+							}
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("grouped source branch lost its entry contract: %v", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressPrefixAndPhysicalBanks(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, role := range []string{"FP", "SP", "SB"} {
+			operand := "$arg+8(" + role + ")(CX*2)"
+			source := "TEXT index(SB),4,$0-32\nMOVL " + operand + ",AX\nRET\n"
+			x86ScalarLiteralExpectedGoListing(t, arch, source, arch == "386" || role != "SB")
+			parsed, err := parseOperandForArch(ArchAMD64, operand)
+			if err != nil || parsed.Kind != OpSym || parsed.Sym != operand {
+				t.Fatalf("address prefix became a load: %+v / %v", parsed, err)
+			}
+			if role != "SB" && !errors.Is(unresolvedSymbolicImmediateError(parsed), ErrProbeNeedsContext) {
+				t.Fatal("known FP/AUTO syntax became an unresolved numeric constant")
+			}
+		}
+		for _, index := range []string{"SP", "BP", "SI", "R8", "R12", "X0"} {
+			parsed, err := parseOperandForArch(ArchAMD64, "arg(FP)("+index+"*2)")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = x86LEAOperandWidth(Instr{Op: "LEAL", Args: []Operand{parsed, {Kind: OpReg, Reg: AX}}}, arch)
+			if err == nil {
+				t.Fatalf("%s unbound indexed FP %s acquired permission", arch, index)
+			}
+		}
+	}
+	// The architectural decoder's physical SP+index stays physical. A named
+	// source FP role is never inferred from a byte pattern or its displacement.
+	for _, arch := range []string{"amd64", "386"} {
+		code := x86PackedShiftActualGoBytes(t, arch, "TEXT index(SB),4,$0-32\nLEAL arg(FP)(SI*1),AX\nRET\n")
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		decoded, err := decodeX86RawDirectiveGroup(code, mode, 0, "original Go LEA bytes", nil)
+		if err != nil || len(decoded) != 2 || len(decoded[0].Args) != 2 || decoded[0].Args[0].Kind != OpMem ||
+			decoded[0].Args[0].Mem.Sym != "" || decoded[0].Args[0].Mem.Base != SP || decoded[0].Args[0].Mem.Index != SI {
+			t.Fatalf("%s decoder invented an FP source role: %+v / %v", arch, decoded, err)
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressRecognitionIsArchitectureScoped(t *testing.T) {
+	operand, err := parseOperandForArch(ArchAMD64, "$table(SB)(SI)(CX*2)")
+	if err != nil || operand.Kind != OpSym {
+		t.Fatalf("typed address: %+v / %v", operand, err)
+	}
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64, ArchWASM} {
+		err := unresolvedSymbolicImmediateErrorForArch(operand, arch)
+		if arch == ArchAMD64 && err != nil || arch != ArchAMD64 && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("%s borrowed x86-only operand grammar: %v", arch, err)
+		}
+	}
+	if err := unresolvedSymbolicImmediateError(operand); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unscoped consumer borrowed x86 grammar: %v", err)
+	}
+}
+
+func TestX86SymbolIndexedAddressNonGPAnnotations(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, role := range []string{"FP", "SP", "SB"} {
+			for _, register := range []string{"FS", "GS", "X0"} {
+				operand := "arg(" + role + ")(" + register + ")"
+				t.Run(arch+"/"+operand, func(t *testing.T) {
+					source := func(address string) string {
+						return "TEXT index(SB),4,$0-32\nLEAL " + address + ",AX\nRET\n"
+					}
+					x86ScalarLiteralExpectedGoListing(t, arch, source(operand), arch == "386")
+					parsed, err := parseOperandForArch(ArchAMD64, operand)
+					if err != nil || parsed.Kind != OpMem || parsed.Mem.Base != Reg(register) {
+						t.Fatalf("original non-GP annotation was lost: %+v / %v", parsed, err)
+					}
+					if arch == "386" {
+						annotated := x86PackedShiftActualGoBytes(t, arch, source(operand))
+						plain := x86PackedShiftActualGoBytes(t, arch, source("arg("+role+")"))
+						if !bytes.Equal(annotated, plain) {
+							t.Fatalf("386 encoder consumed the named Reg annotation: %x != %x", annotated, plain)
+						}
+						if role == "SB" {
+							addressSource := func(address string) string {
+								return "TEXT index(SB),4,$0-0\nMOVL $" + address + ",AX\nRET\n"
+							}
+							annotated = x86PackedShiftActualGoBytes(t, arch, addressSource(operand))
+							plain = x86PackedShiftActualGoBytes(t, arch, addressSource("arg(SB)"))
+							if !bytes.Equal(annotated, plain) {
+								t.Fatalf("386 relocated immediate consumed Reg: %x != %x", annotated, plain)
+							}
+						}
+					}
+					err = x86SymbolIndexedMemoryError(parsed.Mem, arch)
+					if arch == "386" && role == "SB" && err != nil ||
+						arch == "386" && role != "SB" && !errors.Is(err, ErrProbeNeedsContext) || arch == "amd64" && err == nil {
+						t.Fatalf("ignored Reg annotation changed the native role or granted frame permission: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86SymbolIndexedActualRegisterNames(t *testing.T) []string {
+	t.Helper()
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "list6.go")
+	file, err := goparser.ParseFile(token.NewFileSet(), path, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	ast.Inspect(file, func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || declaration.Names[0].Name != "Register" {
+			return true
+		}
+		if len(declaration.Values) != 1 {
+			t.Fatal("unexpected Go Register declaration")
+		}
+		array, ok := declaration.Values[0].(*ast.CompositeLit)
+		if !ok {
+			t.Fatal("Go Register is not a literal inventory")
+		}
+		for _, element := range array.Elts {
+			literal, ok := element.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("Go Register contains a nonliteral spelling")
+			}
+			name, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			names = append(names, name)
+		}
+		return false
+	})
+	if len(names) != 201 {
+		t.Fatalf("actual Go x86 Register inventory changed: %d", len(names))
+	}
+	return names
+}
+
+func x86SymbolIndexedActualSegmentPrefixes(t *testing.T, arch string) map[string]byte {
+	t.Helper()
+	file, err := goparser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var function *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if candidate, ok := declaration.(*ast.FuncDecl); ok && candidate.Name.Name == "prefixof" {
+			if function != nil {
+				t.Fatal("duplicate actual Go prefixof")
+			}
+			function = candidate
+		}
+	}
+	if function == nil || function.Body == nil {
+		t.Fatal("actual Go prefixof is missing")
+	}
+	path := func(expression ast.Expr) string {
+		var visit func(ast.Expr) string
+		visit = func(expression ast.Expr) string {
+			switch expression := expression.(type) {
+			case *ast.Ident:
+				return expression.Name
+			case *ast.SelectorExpr:
+				return visit(expression.X) + "." + expression.Sel.Name
+			}
+			return ""
+		}
+		return visit(expression)
+	}
+	suppressed := false
+	prefixes := make(map[string]byte)
+	for _, statement := range function.Body.List {
+		if gate, ok := statement.(*ast.IfStmt); ok {
+			condition, ok := gate.Cond.(*ast.BinaryExpr)
+			if ok && condition.Op == token.EQL && path(condition.X) == "ctxt.Arch.Family" && path(condition.Y) == "sys.I386" {
+				if len(gate.Body.List) == 0 {
+					t.Fatal("empty actual Go I386 prefix gate")
+				}
+				last, ok := gate.Body.List[len(gate.Body.List)-1].(*ast.ReturnStmt)
+				if !ok || gate.Else != nil || len(last.Results) != 1 {
+					t.Fatal("unknown actual Go I386 prefix gate")
+				}
+				zero, ok := last.Results[0].(*ast.BasicLit)
+				if !ok || zero.Kind != token.INT || zero.Value != "0" {
+					t.Fatal("actual Go I386 prefix gate does not suppress the prefix")
+				}
+				suppressed = true
+			}
+		}
+		index, ok := statement.(*ast.SwitchStmt)
+		if !ok || path(index.Tag) != "a.Index" {
+			continue
+		}
+		for _, statement := range index.Body.List {
+			row := statement.(*ast.CaseClause)
+			if len(row.List) != 1 || len(row.Body) != 1 {
+				continue
+			}
+			name := strings.TrimPrefix(path(row.List[0]), "REG_")
+			result, ok := row.Body[0].(*ast.ReturnStmt)
+			if !ok || len(result.Results) != 1 {
+				continue
+			}
+			literal, ok := result.Results[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.INT {
+				t.Fatal("actual Go segment prefix is not a literal")
+			}
+			value, err := strconv.ParseUint(literal.Value, 0, 8)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prefixes[name] = byte(value)
+		}
+	}
+	if !reflect.DeepEqual(prefixes, map[string]byte{"CS": 0x2e, "DS": 0x3e, "ES": 0x26, "FS": 0x64, "GS": 0x65}) {
+		t.Fatalf("actual Go segment prefix inventory changed: %v", prefixes)
+	}
+	if arch == "386" && suppressed {
+		for name := range prefixes {
+			prefixes[name] = 0
+		}
+	}
+	return prefixes
+}
+
+func TestX86SymbolIndexedAddressCompleteIgnoredRegisterInventory(t *testing.T) {
+	prefixes := x86SymbolIndexedActualSegmentPrefixes(t, "386")
+	var annotated, plain strings.Builder
+	annotated.WriteString("TEXT index(SB),4,$0-0\n")
+	plain.WriteString("TEXT index(SB),4,$0-0\n")
+	for _, name := range x86SymbolIndexedActualRegisterNames(t) {
+		operand := "table<>(SB)(" + name + ")"
+		parsed, err := parseOperandForArch(ArchAMD64, operand)
+		if !x86SymbolGoRegisterName(name) || err != nil || parsed.Mem.Base != Reg(name) {
+			t.Fatalf("actual Go Register annotation was lost: %s / %+v / %v", name, parsed, err)
+		}
+		_, err = x86LEAOperandWidth(Instr{Op: "LEAL", Args: []Operand{parsed, {Kind: OpReg, Reg: AX}}}, "386")
+		if name == "TLS" {
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unmodeled Go TLS progedit did not remain Context: %v", err)
+			}
+			// MOVL named(TLS) is rewritten before oclass: unlike ordinary
+			// ignored annotations it performs two native memory reads.
+			source := func(address string) string {
+				return "TEXT index(SB),4,$0-0\nMOVL " + address + ",AX\nRET\n"
+			}
+			if bytes.Equal(x86PackedShiftActualGoBytes(t, "386", source(operand)), x86PackedShiftActualGoBytes(t, "386", source("table<>(SB)"))) {
+				t.Fatal("actual Go named TLS rewrite was lost")
+			}
+		} else {
+			if err != nil {
+				t.Fatalf("ignored Go Reg annotation became a physical-register requirement: %s / %v", name, err)
+			}
+			fmt.Fprintf(&annotated, "LEAL %s,AX\nMOVL %s,AX\n", operand, operand)
+			plain.WriteString("LEAL table<>(SB),AX\nMOVL table<>(SB),AX\n")
+		}
+		fmt.Fprintf(&annotated, "MOVL $%s,AX\n", operand)
+		plain.WriteString("MOVL $table<>(SB),AX\n")
+		switch name {
+		case "CS", "DS", "ES", "FS", "GS":
+			address := "table<>(SB)(" + name + "*1)"
+			source := func(address string) string {
+				return "TEXT index(SB),4,$0-0\nMOVL $" + address + ",AX\nRET\n"
+			}
+			left := x86PackedShiftActualGoBytes(t, "386", source(address))
+			right := x86PackedShiftActualGoBytes(t, "386", source("table<>(SB)"))
+			prefix := prefixes[name]
+			if prefix == 0 && !bytes.Equal(left, right) ||
+				prefix != 0 && (len(left) != len(right)+1 || left[0] != prefix || !bytes.Equal(left[1:], right)) {
+				t.Fatalf("actual Go TYPE_ADDR bytes disagree with its prefixof: %s prefix=%x / %x != %x", name, prefix, left, right)
+			}
+			index, err := parseOperandForArch(ArchAMD64, address)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			ctx.goarch = "386"
+			before := output.Len()
+			if _, err := ctx.addrFromSymbolIndexedAddress(index.Mem); !errors.Is(err, ErrProbeNeedsContext) || output.Len() != before {
+				t.Fatalf("unmodeled TYPE_ADDR prefix emitted IR: %v", err)
+			}
+		default:
+			fmt.Fprintf(&annotated, "MOVL $table<>(SB)(%s*1),AX\n", name)
+			plain.WriteString("MOVL $table<>(SB),AX\n")
+		}
+	}
+	annotated.WriteString("RET\n")
+	plain.WriteString("RET\n")
+	left := x86PackedShiftActualGoBytes(t, "386", annotated.String())
+	right := x86PackedShiftActualGoBytes(t, "386", plain.String())
+	if !bytes.Equal(left, right) {
+		t.Fatalf("386 ignored Reg/TYPE_ADDR Index changed the complete object bytes (lengths %d/%d)", len(left), len(right))
+	}
+	for _, name := range []string{"R0", "R7", "R16", "RAX", "R8W", "F8", "M8", "MM0", "K8", "X32", "Y32", "Z32", "CR16", "DR8", "TR8", "X00", "V0", "PN0", "g", "ax"} {
+		operand := "table<>(SB)(" + name + ")"
+		source := "TEXT index(SB),4,$0-0\nLEAL " + operand + ",AX\nRET\n"
+		x86ScalarLiteralExpectedGoListing(t, "386", source, false)
+		if x86SymbolGoRegisterName(name) {
+			t.Fatalf("unregistered x86 annotation was authorized: %s", name)
+		}
+		if _, err := parseOperandForArch(ArchAMD64, operand); err == nil {
+			t.Fatalf("unregistered x86 annotation was parsed: %s", name)
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressSegmentIndexNeedsContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, role := range []string{"FP", "SP", "SB"} {
+			for _, register := range []string{"CS", "SS", "DS", "ES", "FS", "GS", "X0"} {
+				operand := "arg(" + role + ")(" + register + "*1)"
+				t.Run(arch+"/"+operand, func(t *testing.T) {
+					source := "TEXT index(SB),4,$0-32\nLEAL " + operand + ",AX\nRET\n"
+					accepted := register != "X0" && (arch == "386" || role != "SB")
+					x86ScalarLiteralExpectedGoListing(t, arch, source, accepted)
+					parsed, err := parseOperandForArch(ArchAMD64, operand)
+					if err != nil || parsed.Mem.Index != Reg(register) || parsed.Mem.Base != "" {
+						t.Fatalf("segment index became an ignored Reg annotation: %+v / %v", parsed, err)
+					}
+					err = x86SymbolIndexedMemoryError(parsed.Mem, arch)
+					if accepted && !errors.Is(err, ErrProbeNeedsContext) || !accepted && err == nil {
+						t.Fatalf("unbound segment/VSIB source acquired permission: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedAddressEmptyName(t *testing.T) {
+	for _, prefix := range []string{"", "+0", "-0", "+(2*4)", "   "} {
+		for _, role := range []string{"FP", "SB"} {
+			operand := prefix + "(" + role + ")(SI*1)"
+			for _, arch := range []string{"amd64", "386"} {
+				source := "TEXT index(SB),4,$0-0\nLEAL " + operand + ",AX\nRET\n"
+				x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+			}
+			if _, err := parseOperandForArch(ArchAMD64, operand); err == nil {
+				t.Fatalf("empty symbolic name was accepted: %q", operand)
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedFPDoesNotGrantFramePermission(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, instruction := range []string{
+			"LEAL x+0(FP)(CX*2),AX", "MOVL x+0(FP)(CX*2),AX",
+			"MOVL AX,x+0(FP)(CX*2)", "MOVL $x+0(FP)(CX*2),AX",
+			"LEAL local+8(SP)(CX*2),AX", "MOVL local+8(SP)(CX*2),AX",
+		} {
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				pkg := x86AddSubLiteralPackage(t, target.arch, "func index(x uint32)\n")
+				source := "TEXT ·index(SB),4,$0-4\nMOVL $0,CX\n" + instruction + "\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(sym string) string { return strings.Replace(sym, "·", "literal.", 1) }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+				for _, api := range []string{"text", "module", "GoModule"} {
+					t.Run(api, func(t *testing.T) {
+						context := llvm.NewContext()
+						defer context.Dispose()
+						switch api {
+						case "text":
+							_, err = Translate(file, options)
+						case "module":
+							var module llvm.Module
+							module, err = TranslateModuleInContext(context, file, options)
+							if !module.IsNil() {
+								defer module.Dispose()
+							}
+						case "GoModule":
+							var result *GoModuleTranslation
+							result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+							if result != nil && !result.Module.IsNil() {
+								defer result.Module.Dispose()
+							}
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("new syntax borrowed FP/stack backing permission: %v", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86SymbolIndexedSBThreeAPIsFiveLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			pkg := x86AddSubLiteralPackage(t, target.arch, "func index() uint32\n")
+			var source strings.Builder
+			source.WriteString("DATA ·table<>+0(SB)/8,$7\nGLOBL ·table<>(SB),$32\nTEXT ·index(SB),4,$0-4\nMOVL $1,CX\n")
+			widths := []string{"W", "L"}
+			if target.arch == "amd64" {
+				widths = append(widths, "Q")
+			}
+			for _, width := range widths {
+				fmt.Fprintf(&source, "LEA%s ·table<>(SB),DX\n", width)
+				if target.arch == "386" {
+					for _, scale := range []int{1, 2, 4, 8} {
+						fmt.Fprintf(&source, "LEA%s ·table<>+(2*4)(SB)(CX*%d),DX\n", width, scale)
+					}
+					// SI is not an input to these Go NAME_STATIC instructions.
+					fmt.Fprintf(&source, "LEA%s ·table<>(SB)(SI),DX\n", width)
+					fmt.Fprintf(&source, "LEA%s ·table<>(SB)(SI)(CX*2),DX\n", width)
+				}
+			}
+			source.WriteString("MOVL ·table<>(SB),AX\n")
+			if target.arch == "386" {
+				source.WriteString("MOVL ·table<>(SB)(SI),AX\nMOVL $·table<>(SB)(SI)(CX*4),DX\n")
+				for _, name := range x86SymbolIndexedActualRegisterNames(t) {
+					if name != "TLS" {
+						fmt.Fprintf(&source, "LEAL ·table<>(SB)(%s),DX\nMOVL ·table<>(SB)(%s),AX\n", name, name)
+					}
+					fmt.Fprintf(&source, "MOVL $·table<>(SB)(%s),DX\n", name)
+					switch name {
+					case "CS", "DS", "ES", "FS", "GS":
+						// Source-encoder prefix ambiguity has a Context witness above.
+					default:
+						fmt.Fprintf(&source, "MOVL $·table<>(SB)(%s)(%s*1),DX\n", name, name)
+					}
+				}
+			}
+			source.WriteString("MOVL AX,ret+0(FP)\nRET\n")
+			// Invoke both actual compatibility assemblers, not the current-only
+			// optab helper. No numerical/runtime claim is made for 386 here.
+			x86ScalarLiteralGoListing(t, target.arch, source.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(sym string) string { return strings.Replace(sym, "·", "literal.", 1) }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: sigs}
+			for _, api := range []string{"text", "module", "GoModule"} {
+				t.Run(api, func(t *testing.T) {
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "GoModule":
+						var result *GoModuleTranslation
+						result, err = translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+						if result != nil && !result.Module.IsNil() {
+							defer result.Module.Dispose()
+							ir = result.Module.String()
+						}
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					if strings.Contains(ir, "load i64, ptr %reg_SI") {
+						t.Fatal("386 encoder's discarded Reg became a value dependency")
+					}
+					compileLLVMToObject(t, llc, target.triple, "symbol-index.ll", "symbol-index.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86SymbolIndexedMemoryConsumerRejectsBeforeIR(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, address := range []string{
+			"arg(FP)(CX*2)", "local(SP)(BX*4)", "arg(FP)(AX)(BX*2)",
+			"table(SB)(SP*1)", "table(SB)(X0*1)", "table(SB)(SI)(CX)",
+		} {
+			parsed, err := parseOperandForArch(ArchAMD64, address)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			ctx.goarch = target.arch
+			before := output.Len()
+			if _, err := ctx.addrFromPlainMem(parsed.Mem); err == nil || output.Len() != before {
+				t.Fatalf("%s %s emitted an unproved symbolic pointer: %v", target.triple, address, err)
+			}
+		}
+		if target.arch == "amd64" {
+			for _, address := range []string{"table(SB)(CX*1)", "table(SB)(SI)", "table(SB)(SI)(CX*2)"} {
+				parsed, err := parseOperandForArch(ArchAMD64, address)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				before := output.Len()
+				if _, err := ctx.addrFromPlainMem(parsed.Mem); err == nil || output.Len() != before {
+					t.Fatalf("AMD64 RIP+index became a native address: %s / %v", address, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86SymbolIndexedFPDoesNotBorrowRawReturnOrCallerPermission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, source := range []string{
+			"LEAL arg(FP)(CX*2),AX", "MOVL arg(FP)(CX*2),AX", "MOVL AX,arg(FP)(CX*2)",
+			"LEAL local(SP)(CX*2),AX", "MOVL local(SP)(CX*2),AX", "MOVL AX,local(SP)(CX*2)",
+		} {
+			file, err := Parse(ArchAMD64, "TEXT index(SB),4,$0-8\nMOVL $0,CX\n"+source+"\nBYTE $0xc3\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{Goarch: arch, Sigs: map[string]FuncSig{"index": {Args: []LLVMType{I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}}})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("%s raw RET acquired an indexed named-frame permission: %v", arch, err)
+			}
+		}
+	}
+	assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX", "MOVL $0,SI\nLEAQ x_base+0(FP)(SI*1),SI", 1)
+	pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+	if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("ordinary actual typed caller supplied dynamic FP storage: %v", err)
+	}
+}
diff --git a/preprocess.go b/preprocess.go
index 4bcbbc7d0..8517c7dad 100644
--- a/preprocess.go
+++ b/preprocess.go
@@ -2,9 +2,14 @@ package plan9asm
 
 import (
 	"bufio"
+	"bytes"
 	"fmt"
+	"os"
 	"sort"
+	"strconv"
 	"strings"
+	"text/scanner"
+	"unicode"
 )
 
 type ppMacro struct {
@@ -12,13 +17,164 @@ type ppMacro struct {
 	params []string
 }
 
+// Recognize comments in lexical order: // hides any later /*, and quoted
+// constants hide both. A block comment is whitespace, not token concatenation.
+func stripAssemblyComments(line string, inBlock *bool) string {
+	if !*inBlock && !strings.Contains(line, "/") {
+		return line
+	}
+	var out strings.Builder
+	var quote byte
+	for i := 0; i < len(line); {
+		if *inBlock {
+			end := strings.Index(line[i:], "*/")
+			if end < 0 {
+				break
+			}
+			i += end + 2
+			*inBlock = false
+			continue
+		}
+		ch := line[i]
+		if quote != 0 {
+			out.WriteByte(ch)
+			i++
+			if ch == '\\' && quote != '`' && i < len(line) {
+				out.WriteByte(line[i])
+				i++
+			} else if ch == quote {
+				quote = 0
+			}
+			continue
+		}
+		if ch == '/' && i+1 < len(line) {
+			if line[i+1] == '/' {
+				break
+			}
+			if line[i+1] == '*' {
+				out.WriteByte(' ')
+				*inBlock = true
+				i += 2
+				continue
+			}
+		}
+		if ch == '"' || ch == '\'' || ch == '`' {
+			quote = ch
+		}
+		out.WriteByte(ch)
+		i++
+	}
+	return out.String()
+}
+
 // preprocess applies a very small preprocessor needed for some stdlib asm:
 //   - strips // comments
 //   - ignores #include
 //   - supports #define NAME <body> with optional single-line continuation via '\'
 //   - expands macros only when a statement is exactly NAME
 func preprocess(src string) (string, error) {
+	return preprocessWithDefines(src, nil)
+}
+
+// GoAssemblerDefines returns the predefined symbols cmd/go passes to cmd/asm.
+// The feature values come from the same GO* environment variables used to
+// select files and configure the assembler invocation.
+func GoAssemblerDefines(goos, goarch string) []string {
+	return GoAssemblerDefinesWithEnv(goos, goarch, nil)
+}
+
+// GoAssemblerDefinesWithEnv uses explicit target feature values when env is
+// non-nil. This lets a compiler pass its resolved configuration without
+// mutating the process environment; omitted entries use Go's baseline defaults.
+func GoAssemblerDefinesWithEnv(goos, goarch string, env map[string]string) []string {
+	getenv := os.Getenv
+	if env != nil {
+		getenv = func(name string) string { return env[name] }
+	}
+	defines := []string{}
+	if goos != "" {
+		defines = append(defines, "GOOS_"+goos)
+	}
+	if goarch != "" {
+		defines = append(defines, "GOARCH_"+goarch)
+	}
+	switch goarch {
+	case "386":
+		value := getenv("GO386")
+		if value == "" {
+			value = "sse2"
+		}
+		defines = append(defines, "GO386_"+value)
+	case "amd64":
+		value := getenv("GOAMD64")
+		if value == "" {
+			value = "v1"
+		}
+		defines = append(defines, "GOAMD64_"+value)
+	case "arm":
+		value := getenv("GOARM")
+		if value == "" {
+			value = "7"
+		}
+		if strings.Contains(value, "7") {
+			defines = append(defines, "GOARM_7")
+		}
+		if strings.Contains(value, "6") || strings.Contains(value, "7") {
+			defines = append(defines, "GOARM_6")
+		}
+		defines = append(defines, "GOARM_5")
+	case "arm64":
+		if lse, err := goARM64ProfileLSE(getenv("GOARM64")); err == nil && lse {
+			defines = append(defines, "GOARM64_LSE")
+		}
+	}
+	return defines
+}
+
+// AssemblyPreprocessOptions supplies the real source inputs for preprocessing.
+// ReadInclude resolves an active quoted include using the caller's bounded
+// package/toolchain search. It returns a stable source identity and its bytes;
+// identities are used to diagnose include recursion. An inactive include never
+// calls the resolver, including when its operand is malformed or missing.
+// The API bounds include depth (32); the caller must bound individual/aggregate
+// input bytes and emitted output for its own source inventory/resource budget.
+type AssemblyPreprocessOptions struct {
+	FileName    string
+	Defines     []string
+	ReadInclude func(parent, name string) (fileName string, source []byte, err error)
+}
+
+// PreprocessAssemblySource expands Go assembly macros and active includes with
+// one source-order macro/conditional environment. Unlike the historical Parse
+// path, an unresolved active include is an error, never silently discarded.
+func PreprocessAssemblySource(src string, opt AssemblyPreprocessOptions) (string, error) {
+	return preprocessGoAssembly(src, opt)
+}
+
+func preprocessWithDefines(src string, defines []string) (string, error) {
+	return preprocessAssembly(src, defines, nil)
+}
+
+func preprocessAssembly(src string, defines []string, opt *AssemblyPreprocessOptions) (string, error) {
 	macros := map[string]ppMacro{}
+	for _, name := range defines {
+		name = strings.TrimSpace(name)
+		if name != "" {
+			macros[name] = ppMacro{body: "1"}
+		}
+	}
+	macroNames := []string{}
+	refreshMacroNames := func() {
+		macroNames = macroNames[:0]
+		for name := range macros {
+			macroNames = append(macroNames, name)
+		}
+		// Try longer names first to avoid prefix shadowing.
+		sort.Slice(macroNames, func(i, j int) bool {
+			return len(macroNames[i]) > len(macroNames[j])
+		})
+	}
+	refreshMacroNames()
 
 	type ifState struct {
 		outerActive bool
@@ -26,9 +182,6 @@ func preprocess(src string) (string, error) {
 		inElse      bool
 	}
 	isDefined := func(name string) bool {
-		// For now, only treat previously #defined macros as defined.
-		// This is enough for stdlib asm that uses GOAMD64_v* feature macros;
-		// llgo doesn't define those currently, so they default to false.
 		_, ok := macros[name]
 		return ok
 	}
@@ -60,10 +213,66 @@ func preprocess(src string) (string, error) {
 		return val
 	}
 
-	// First pass: collect #define, build output lines for further parsing.
+	// Expand each instruction while its source-order macro environment is live.
+	// Delaying expansion until EOF would apply later #undef/#define changes to
+	// earlier functions, changing both Go's accepted forms and their semantics.
 	lines := []string{}
+	// Conditional directives emitted by a macro must also use the definitions
+	// in force at its invocation, not the final map after the whole source.
+	expandedConditions := map[int]bool{}
+	appendExpanded := func(line string) {
+		for _, expanded := range expandPPLine(line, macros, macroNames, 0) {
+			trim := strings.TrimSpace(expanded)
+			switch {
+			case strings.HasPrefix(trim, "#ifdef"):
+				name := strings.TrimSpace(strings.TrimPrefix(trim, "#ifdef"))
+				expandedConditions[len(lines)] = isDefined(name)
+			case strings.HasPrefix(trim, "#ifndef"):
+				name := strings.TrimSpace(strings.TrimPrefix(trim, "#ifndef"))
+				expandedConditions[len(lines)] = !isDefined(name)
+			case strings.HasPrefix(trim, "#if"):
+				expr := strings.TrimSpace(strings.TrimPrefix(trim, "#if"))
+				expandedConditions[len(lines)] = evalIfExpr(expr)
+			case strings.HasPrefix(trim, "#elif"):
+				expr := strings.TrimSpace(strings.TrimPrefix(trim, "#elif"))
+				expandedConditions[len(lines)] = evalIfExpr(expr)
+			}
+			lines = append(lines, expanded)
+		}
+	}
 
-	sc := bufio.NewScanner(strings.NewReader(src))
+	newScanner := func(source string) *bufio.Scanner {
+		sc := bufio.NewScanner(strings.NewReader(source))
+		// An in-memory source bounds a physical line, unlike Scanner's 64 KiB
+		// default (Go assembly has no such line-length cap).
+		sc.Buffer(nil, len(source)+1)
+		if opt != nil {
+			// Keep real newline tokens. ScanLines would silently turn a final
+			// unterminated directive into a terminated one.
+			sc.Split(func(data []byte, atEOF bool) (int, []byte, error) {
+				if end := bytes.IndexByte(data, '\n'); end >= 0 {
+					return end + 1, data[:end+1], nil
+				}
+				if atEOF && len(data) > 0 {
+					return len(data), data, nil
+				}
+				return 0, nil, nil
+			})
+		}
+		return sc
+	}
+	sc := newScanner(src)
+	fileName := "<assembly>"
+	if opt != nil && opt.FileName != "" {
+		fileName = opt.FileName
+	}
+	type inputState struct {
+		scanner *bufio.Scanner
+		file    string
+		line    int
+	}
+	inputs := []inputState{}
+	activeFiles := map[string]bool{fileName: true}
 	inBlockComment := false
 	var defName string
 	var defParams []string
@@ -80,7 +289,18 @@ func preprocess(src string) (string, error) {
 		if name == "" {
 			return fmt.Errorf("invalid #define with empty name")
 		}
+		if opt != nil {
+			if _, exists := macros[name]; exists {
+				return fmt.Errorf("redefinition of macro %s", name)
+			}
+			var err error
+			body, err = normalizePPMacroEscapes(body)
+			if err != nil {
+				return err
+			}
+		}
 		macros[name] = ppMacro{body: body, params: defParams}
+		refreshMacroNames()
 		defName = ""
 		defParams = nil
 		defBody.Reset()
@@ -89,55 +309,81 @@ func preprocess(src string) (string, error) {
 	}
 
 	lineno := 0
-	for sc.Scan() {
-		lineno++
-		line := sc.Text()
-		// Strip C-style /* ... */ comments (may span lines). Some stdlib asm uses
-		// these in addition to // comments.
-		for {
-			if inBlockComment {
-				if end := strings.Index(line, "*/"); end >= 0 {
-					line = line[end+2:]
-					inBlockComment = false
-					// Continue scanning in case of multiple comment blocks on one line.
-					continue
-				}
-				// Entire line is within a block comment.
-				line = ""
-				break
+	for {
+		if !sc.Scan() {
+			if err := sc.Err(); err != nil {
+				return "", fmt.Errorf("%s: %w", fileName, err)
 			}
-			start := strings.Index(line, "/*")
-			if start < 0 {
-				break
+			if opt != nil && (defCont || inBlockComment) {
+				return "", fmt.Errorf("%s:%d: unterminated macro continuation or comment", fileName, lineno)
 			}
-			end := strings.Index(line[start+2:], "*/")
-			if end >= 0 {
-				end += start + 2
-				line = line[:start] + line[end+2:]
-				continue
+			if len(inputs) == 0 {
+				break
 			}
-			// Unterminated block comment starts here; keep prefix and drop the rest.
-			line = line[:start]
-			inBlockComment = true
-			break
-		}
-		// Strip // comments after block comments.
-		if idx := strings.Index(line, "//"); idx >= 0 {
-			line = line[:idx]
+			delete(activeFiles, fileName)
+			parent := inputs[len(inputs)-1]
+			inputs = inputs[:len(inputs)-1]
+			sc, fileName, lineno = parent.scanner, parent.file, parent.line
+			continue
 		}
+		lineno++
+		statementFile, statementLine := fileName, lineno
+		rawLine := sc.Text()
+		terminated := opt == nil || strings.HasSuffix(rawLine, "\n")
+		rawLine = strings.TrimSuffix(rawLine, "\n")
+		// C-style preprocessing splices a physical backslash-newline before
+		// removing comments. Record it before the comment pass below can erase
+		// the slash from a continued multi-line #define.
+		physicalContinuation := strings.HasSuffix(strings.TrimRight(rawLine, " \t\r"), "\\")
+		line := stripAssemblyComments(rawLine, &inBlockComment)
 		line = strings.TrimRight(line, " \t")
-		if strings.TrimSpace(line) == "" {
-			if err := flushDefine(); err != nil {
-				return "", fmt.Errorf("line %d: %v", lineno, err)
+		if opt != nil && !terminated && (strings.HasPrefix(strings.TrimSpace(line), "#") || defCont) {
+			// Go's lex.Stack discards an exhausted included tokenizer, not a
+			// newline. Read the parent tokens until a real newline is found.
+			// Tokenizers stay separate: comments cannot cross file boundaries
+			// and identifiers cannot concatenate across those boundaries.
+			for !terminated && len(inputs) > 0 {
+				if inBlockComment {
+					return "", fmt.Errorf("%s:%d: unterminated comment", fileName, lineno)
+				}
+				delete(activeFiles, fileName)
+				parent := inputs[len(inputs)-1]
+				inputs = inputs[:len(inputs)-1]
+				sc, fileName, lineno = parent.scanner, parent.file, parent.line
+				if !sc.Scan() {
+					if err := sc.Err(); err != nil {
+						return "", fmt.Errorf("%s: %w", fileName, err)
+					}
+					continue
+				}
+				lineno++
+				next := sc.Text()
+				terminated = strings.HasSuffix(next, "\n")
+				next = strings.TrimSuffix(next, "\n")
+				line += " " + stripAssemblyComments(next, &inBlockComment)
 			}
-			continue
 		}
-
+		// cmd/asm also accepts historical assembly that places a // comment
+		// after the continuation slash. In that spelling the slash only becomes
+		// the last token after comment removal (for example "MOVQ ... \\ // why").
+		physicalContinuation = physicalContinuation || strings.HasSuffix(line, "\\")
+		if opt != nil {
+			// At file EOF a following parent token can complete a backslash
+			// pair rather than an escaped newline. Decide from the merged
+			// token line, not the exhausted header's last byte alone.
+			physicalContinuation = hasPPContinuation(line)
+		}
+		// A newline within a block comment is not the end of a macro body.
+		// cmd/asm removes the entire comment before parsing #define lines, so
+		// only the newline after the closing */ can terminate the definition.
+		if defCont && inBlockComment {
+			physicalContinuation = true
+		}
 		if defCont {
 			// Continue a definition body on the following line(s).
 			if !active {
 				// Discard bodies from inactive blocks.
-				if strings.HasSuffix(strings.TrimSpace(line), "\\") {
+				if physicalContinuation {
 					continue
 				}
 				if err := flushDefine(); err != nil {
@@ -146,8 +392,8 @@ func preprocess(src string) (string, error) {
 				continue
 			}
 			cont := strings.TrimSpace(line)
-			if strings.HasSuffix(cont, "\\") {
-				// Continuation to the next line.
+			if physicalContinuation {
+				// Comment removal may already have removed the slash.
 				cont = strings.TrimSpace(strings.TrimSuffix(cont, "\\"))
 				defBody.WriteString("\n")
 				defBody.WriteString(cont)
@@ -160,11 +406,101 @@ func preprocess(src string) (string, error) {
 			}
 			continue
 		}
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
 
 		trim := strings.TrimSpace(line)
-		if strings.HasPrefix(trim, "#include") || strings.HasPrefix(trim, "#undef") {
-			// Ignore includes for now. We don't need textflag.h values because
-			// we treat flags as opaque in TEXT.
+		if opt != nil && strings.HasPrefix(trim, "#") {
+			// Tabs are token whitespace as well; do not recognize a directive
+			// by a substring prefix (#includeExtra is not #include).
+			fields := strings.Fields(strings.TrimSpace(trim[1:]))
+			if len(fields) == 0 {
+				return "", fmt.Errorf("%s:%d: invalid preprocessor directive", fileName, lineno)
+			}
+			directive := fields[0]
+			rest := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(trim[1:]), directive))
+			if !active && directive != "ifdef" && directive != "ifndef" && directive != "else" && directive != "endif" && directive != "line" {
+				continue
+			}
+			if !terminated {
+				// cmd/asm alone permits EOF directly after an object-like macro
+				// name. Function-like definitions and nonempty bodies require
+				// an actual newline, as do all other active controls.
+				_, params, body, err := parseMacroDefine(rest)
+				if directive != "define" || err != nil || params != nil || body != "" {
+					return "", fmt.Errorf("%s:%d: #%s requires a terminating newline", statementFile, statementLine, directive)
+				}
+			}
+			switch directive {
+			case "include", "define", "undef":
+			case "ifdef", "ifndef":
+				if !validPPIdentifier(rest) {
+					return "", fmt.Errorf("%s:%d: invalid #%s", fileName, lineno, directive)
+				}
+			case "else", "endif":
+				if rest != "" {
+					return "", fmt.Errorf("%s:%d: unexpected tokens after #%s", fileName, lineno, directive)
+				}
+			case "line":
+				if err := validatePPLine(rest); err != nil {
+					return "", fmt.Errorf("%s:%d: %w", fileName, lineno, err)
+				}
+				continue // source-position metadata, not a machine instruction
+			default:
+				return "", fmt.Errorf("%s:%d: unsupported Go assembly directive #%s", fileName, lineno, directive)
+			}
+			trim = "#" + directive
+			if rest != "" {
+				trim += " " + rest
+			}
+		}
+		if strings.HasPrefix(trim, "#include") {
+			if opt == nil {
+				// Preserve the historical parser behavior. Actual source readers
+				// opt into the strict API rather than inventing missing headers.
+				continue
+			}
+			if !active {
+				continue
+			}
+			rest := strings.TrimSpace(strings.TrimPrefix(trim, "#include"))
+			name, err := strconv.Unquote(rest)
+			if err != nil || !strings.HasPrefix(rest, "\"") {
+				return "", fmt.Errorf("%s:%d: invalid #include: %q", fileName, lineno, line)
+			}
+			if opt.ReadInclude == nil {
+				return "", fmt.Errorf("%s:%d: active #include %q requires a resolver", fileName, lineno, name)
+			}
+			includedName, includedSource, err := opt.ReadInclude(statementFile, name)
+			if err != nil {
+				return "", fmt.Errorf("%s:%d: #include %q: %w", fileName, lineno, name, err)
+			}
+			if includedName == "" {
+				return "", fmt.Errorf("%s:%d: #include %q has no source identity", fileName, lineno, name)
+			}
+			if activeFiles[includedName] || len(inputs) >= 32 {
+				return "", fmt.Errorf("%s:%d: include cycle/depth at %s", fileName, lineno, includedName)
+			}
+			inputs = append(inputs, inputState{sc, fileName, lineno})
+			sc, fileName, lineno = newScanner(string(includedSource)), includedName, 0
+			activeFiles[fileName] = true
+			continue
+		}
+		if strings.HasPrefix(trim, "#undef") {
+			if active {
+				name := strings.TrimSpace(strings.TrimPrefix(trim, "#undef"))
+				if name == "" || strings.ContainsAny(name, " \t") {
+					return "", fmt.Errorf("line %d: invalid #undef: %q", lineno, line)
+				}
+				if opt != nil {
+					if _, exists := macros[name]; !exists || !validPPIdentifier(name) {
+						return "", fmt.Errorf("%s:%d: #undef for undefined macro %s", fileName, lineno, name)
+					}
+				}
+				delete(macros, name)
+				refreshMacroNames()
+			}
 			continue
 		}
 		if strings.HasPrefix(trim, "#ifdef") {
@@ -246,7 +582,7 @@ func preprocess(src string) (string, error) {
 			}
 			defName = name
 			defParams = params
-			if strings.HasSuffix(afterName, "\\") {
+			if physicalContinuation {
 				afterName = strings.TrimSpace(strings.TrimSuffix(afterName, "\\"))
 				defBody.WriteString(afterName)
 				defCont = true
@@ -263,7 +599,7 @@ func preprocess(src string) (string, error) {
 		if !active {
 			continue
 		}
-		lines = append(lines, strings.TrimSpace(line))
+		appendExpanded(strings.TrimSpace(line))
 	}
 	if err := sc.Err(); err != nil {
 		return "", err
@@ -277,31 +613,214 @@ func preprocess(src string) (string, error) {
 		return "", fmt.Errorf("unterminated #if block")
 	}
 
-	// Second pass: expand macro invocations (statement == NAME).
-	macroNames := make([]string, 0, len(macros))
-	for k := range macros {
-		macroNames = append(macroNames, k)
+	// Some Go assembly deliberately places conditionals inside a continued
+	// macro body (runtime's ARM64 BREAK macro is the canonical example). Those
+	// directives become visible only after macro expansion, so evaluate a
+	// second conditional pass instead of leaking them into the instruction
+	// stream.
+	active = true
+	ifStack = nil
+	expandedOpen := []string{}
+	var out strings.Builder
+	for i, line := range lines {
+		trim := strings.TrimSpace(line)
+		if opt != nil && strings.HasPrefix(trim, "#") {
+			fields := strings.Fields(strings.TrimPrefix(trim, "#"))
+			if len(fields) == 0 {
+				return "", fmt.Errorf("invalid macro-expanded preprocessor directive: %s", trim)
+			}
+			conditional := fields[0] == "ifdef" || fields[0] == "ifndef" || fields[0] == "else" || fields[0] == "endif"
+			if !active && !conditional {
+				continue // cmd/asm does not parse inactive include/define operands
+			}
+			if !conditional {
+				return "", fmt.Errorf("unsupported macro-expanded preprocessor directive: %s", trim)
+			}
+			if fields[0] == "ifdef" || fields[0] == "ifndef" {
+				if len(fields) != 2 || !validPPIdentifier(fields[1]) {
+					return "", fmt.Errorf("invalid macro-expanded #%s: %s", fields[0], trim)
+				}
+			} else if len(fields) != 1 {
+				return "", fmt.Errorf("unexpected tokens in macro-expanded #%s: %s", fields[0], trim)
+			}
+		}
+		switch {
+		case strings.HasPrefix(trim, "#ifdef"):
+			name := strings.TrimSpace(strings.TrimPrefix(trim, "#ifdef"))
+			if name == "" {
+				return "", fmt.Errorf("expanded line %d: invalid #ifdef: %q", i+1, line)
+			}
+			st := ifState{outerActive: active, cond: expandedConditions[i]}
+			ifStack = append(ifStack, st)
+			expandedOpen = append(expandedOpen, trim)
+			active = active && st.cond
+			continue
+		case strings.HasPrefix(trim, "#ifndef"):
+			name := strings.TrimSpace(strings.TrimPrefix(trim, "#ifndef"))
+			if name == "" {
+				return "", fmt.Errorf("expanded line %d: invalid #ifndef: %q", i+1, line)
+			}
+			st := ifState{outerActive: active, cond: expandedConditions[i]}
+			ifStack = append(ifStack, st)
+			expandedOpen = append(expandedOpen, trim)
+			active = active && st.cond
+			continue
+		case strings.HasPrefix(trim, "#if"):
+			st := ifState{outerActive: active, cond: expandedConditions[i]}
+			ifStack = append(ifStack, st)
+			expandedOpen = append(expandedOpen, trim)
+			active = active && st.cond
+			continue
+		case strings.HasPrefix(trim, "#elif"):
+			if len(ifStack) == 0 {
+				return "", fmt.Errorf("expanded line %d: stray #elif", i+1)
+			}
+			top := ifStack[len(ifStack)-1]
+			if top.inElse {
+				return "", fmt.Errorf("expanded line %d: #elif after #else", i+1)
+			}
+			if top.cond {
+				active = false
+				continue
+			}
+			top.cond = expandedConditions[i]
+			ifStack[len(ifStack)-1] = top
+			active = top.outerActive && top.cond
+			continue
+		case strings.HasPrefix(trim, "#else"):
+			if len(ifStack) == 0 {
+				return "", fmt.Errorf("expanded line %d: stray #else", i+1)
+			}
+			top := ifStack[len(ifStack)-1]
+			if top.inElse {
+				return "", fmt.Errorf("expanded line %d: duplicate #else", i+1)
+			}
+			top.inElse = true
+			ifStack[len(ifStack)-1] = top
+			active = top.outerActive && !top.cond
+			continue
+		case strings.HasPrefix(trim, "#endif"):
+			if len(ifStack) == 0 {
+				return "", fmt.Errorf("expanded line %d: stray #endif", i+1)
+			}
+			top := ifStack[len(ifStack)-1]
+			ifStack = ifStack[:len(ifStack)-1]
+			expandedOpen = expandedOpen[:len(expandedOpen)-1]
+			active = top.outerActive
+			continue
+		}
+		if active {
+			if opt != nil && strings.HasPrefix(trim, "#") {
+				// The legacy emitter supports conditional directives in macro
+				// bodies. Other generated controls need token-stack processing;
+				// reject them rather than emitting an unconsumed include/define.
+				return "", fmt.Errorf("unsupported macro-expanded preprocessor directive: %s", trim)
+			}
+			out.WriteString(line)
+			out.WriteByte('\n')
+		}
+	}
+	if len(ifStack) != 0 {
+		return "", fmt.Errorf("unterminated expanded #if block: %s", strings.Join(expandedOpen, ", "))
+	}
+	return out.String(), nil
+}
+
+func validPPIdentifier(name string) bool {
+	var s scanner.Scanner
+	s.Init(strings.NewReader(name))
+	s.Mode = scanner.ScanIdents
+	s.IsIdentRune = ppIdentRune
+	s.Error = func(*scanner.Scanner, string) {}
+	return s.Scan() == scanner.Ident && s.TokenText() == name && s.Scan() == scanner.EOF && s.ErrorCount == 0
+}
+
+func hasPPContinuation(line string) bool {
+	line = strings.TrimRight(line, " \t\r")
+	backslashes := 0
+	for i := len(line) - 1; i >= 0 && line[i] == '\\'; i-- {
+		backslashes++
+	}
+	return backslashes%2 != 0
+}
+
+// cmd/asm escapes only a newline or another backslash in macro replacement
+// tokens. Strings/chars remain scanner tokens, so their internal escapes must
+// not be interpreted as preprocessor escapes.
+func normalizePPMacroEscapes(body string) (string, error) {
+	var s scanner.Scanner
+	s.Init(strings.NewReader(body))
+	s.Mode = scanner.ScanChars | scanner.ScanFloats | scanner.ScanIdents | scanner.ScanInts | scanner.ScanStrings
+	s.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
+	s.IsIdentRune = ppIdentRune
+	var scanErr error
+	s.Error = func(_ *scanner.Scanner, message string) {
+		scanErr = fmt.Errorf("invalid macro replacement: %s", message)
 	}
-	// Expand longer names first to reduce prefix shadowing.
-	sort.Slice(macroNames, func(i, j int) bool { return len(macroNames[i]) > len(macroNames[j]) })
 	var out strings.Builder
-	for _, line := range lines {
-		for _, ex := range expandPPLine(line, macros, macroNames, 0) {
-			out.WriteString(ex)
-			out.WriteString("\n")
+	start := 0
+	for tok := s.Scan(); tok != scanner.EOF; tok = s.Scan() {
+		if tok != '\\' {
+			continue
+		}
+		escape := s.Position.Offset
+		next := s.Scan()
+		if next != '\\' && next != '\n' {
+			return "", fmt.Errorf("macro replacement can only escape a backslash or newline")
 		}
+		out.WriteString(body[start:escape])
+		out.WriteRune(next)
+		start = s.Position.Offset + 1
+	}
+	if scanErr != nil {
+		return "", scanErr
+	}
+	if start == 0 {
+		return body, nil
 	}
+	out.WriteString(body[start:])
 	return out.String(), nil
 }
 
+func validatePPLine(rest string) error {
+	var s scanner.Scanner
+	s.Init(strings.NewReader(rest))
+	s.Mode = scanner.ScanInts | scanner.ScanStrings
+	s.Error = func(*scanner.Scanner, string) {}
+	if s.Scan() != scanner.Int {
+		return fmt.Errorf("invalid #line number")
+	}
+	if _, err := strconv.Atoi(s.TokenText()); err != nil {
+		return fmt.Errorf("invalid #line number: %w", err)
+	}
+	if s.Scan() != scanner.String || s.Scan() != scanner.EOF || s.ErrorCount != 0 {
+		return fmt.Errorf("invalid #line filename or trailing tokens")
+	}
+	return nil
+}
+
 func expandPPLine(line string, macros map[string]ppMacro, macroNames []string, depth int) []string {
 	if depth >= 16 {
 		return []string{line}
 	}
+	if strings.Contains(line, "\n") {
+		chunks := strings.Split(line, "\n")
+		out := make([]string, 0, len(chunks))
+		for _, chunk := range chunks {
+			out = append(out, expandPPLine(strings.TrimSpace(chunk), macros, macroNames, depth+1)...)
+		}
+		return out
+	}
 	trimLine := strings.TrimSpace(line)
 	if trimLine == "" {
 		return []string{""}
 	}
+	// Conditional directives embedded in a continued macro are evaluated by
+	// preprocessWithDefines after expansion. Their identifiers are macro names,
+	// not replacement tokens; keep the directive text intact for that pass.
+	if strings.HasPrefix(trimLine, "#") {
+		return []string{trimLine}
+	}
 	for _, name := range macroNames {
 		m := macros[name]
 		if m.params == nil {
@@ -345,24 +864,11 @@ func expandPPLine(line string, macros map[string]ppMacro, macroNames []string, d
 		return expandPPLine(line, macros, macroNames, depth+1)
 	}
 	// Expand object-like macro identifiers inline (e.g. "MOVD NR, R0").
-	if nl, changed := expandIdentMacros(line, macros, macroNames); changed {
+	if nl, changed := expandIdentMacros(line, macros); changed {
 		return expandPPLine(nl, macros, macroNames, depth+1)
 	}
-	// Expand immediate macro refs in-place: $NAME -> $<body>.
-	for _, name := range macroNames {
-		m := macros[name]
-		if m.params != nil {
-			continue
-		}
-		body := strings.TrimSpace(m.body)
-		if body == "" {
-			continue
-		}
-		line = strings.ReplaceAll(line, "$"+name, "$"+body)
-	}
-	// Expand identifiers inside immediate expressions:
-	//   $(Big - 1) -> $(0x433... - 1)
-	line = expandImmExprMacros(line, macros)
+	// Immediate expressions use the same identifier tokens as ordinary
+	// operands. A second substring pass would expand buf again inside buffer.
 	return []string{line}
 }
 
@@ -370,115 +876,52 @@ func ppIsIdentChar(ch byte) bool {
 	return (ch >= 'a' && ch <= 'z') ||
 		(ch >= 'A' && ch <= 'Z') ||
 		(ch >= '0' && ch <= '9') ||
-		ch == '_'
+		ch == '_' || ch >= 0x80
 }
 
-func expandIdentMacros(line string, macros map[string]ppMacro, macroNames []string) (string, bool) {
-	changed := false
-	for _, name := range macroNames {
-		m := macros[name]
-		if m.params != nil {
+func expandIdentMacros(line string, macros map[string]ppMacro) (string, bool) {
+	var tokens scanner.Scanner
+	tokens.Init(strings.NewReader(line))
+	tokens.Mode = scanner.ScanIdents | scanner.ScanInts | scanner.ScanFloats |
+		scanner.ScanChars | scanner.ScanStrings | scanner.ScanRawStrings
+	tokens.IsIdentRune = ppIdentRune
+	// Malformed literals are diagnosed by the parser; do not print an unrelated
+	// scanner diagnostic or transform a partially recognized token sequence.
+	tokens.Error = func(*scanner.Scanner, string) {}
+
+	var out strings.Builder
+	last := 0
+	for token := tokens.Scan(); token != scanner.EOF; token = tokens.Scan() {
+		if token != scanner.Ident {
 			continue
 		}
-		body := strings.TrimSpace(m.body)
-		if body == "" || body == name {
+		name := tokens.TokenText()
+		macro, ok := macros[name]
+		body := strings.TrimSpace(macro.body)
+		if !ok || macro.params != nil || body == "" || body == name {
 			continue
 		}
-		var out strings.Builder
-		i := 0
-		localChanged := false
-		for i < len(line) {
-			j := strings.Index(line[i:], name)
-			if j < 0 {
-				out.WriteString(line[i:])
-				break
-			}
-			j += i
-			k := j + len(name)
-			leftOK := j == 0 || !ppIsIdentChar(line[j-1])
-			rightOK := k >= len(line) || !ppIsIdentChar(line[k])
-			if leftOK && rightOK {
-				out.WriteString(line[i:j])
-				out.WriteString(body)
-				i = k
-				localChanged = true
-				continue
-			}
-			out.WriteString(line[i : j+1])
-			i = j + 1
-		}
-		if localChanged {
-			line = out.String()
-			changed = true
-		}
+		start := tokens.Position.Offset
+		out.WriteString(line[last:start])
+		out.WriteString(body)
+		last = start + len(name)
 	}
-	return line, changed
-}
-
-func expandImmExprMacros(line string, macros map[string]ppMacro) string {
-	var out strings.Builder
-	cur := 0
-	for cur < len(line) {
-		rel := strings.Index(line[cur:], "$(")
-		if rel < 0 {
-			out.WriteString(line[cur:])
-			break
-		}
-		i := cur + rel
-		out.WriteString(line[cur:i])
-
-		j := i + 2
-		depth := 1
-		for ; j < len(line); j++ {
-			switch line[j] {
-			case '(':
-				depth++
-			case ')':
-				depth--
-				if depth == 0 {
-					expr := line[i+2 : j]
-					out.WriteString("$(")
-					out.WriteString(replaceMacroIdents(expr, macros))
-					out.WriteByte(')')
-					cur = j + 1
-					goto next
-				}
-			}
-		}
-		// Unmatched ')': copy the rest unchanged.
-		out.WriteString(line[i:])
-		break
-	next:
+	if last == 0 || tokens.ErrorCount != 0 {
+		return line, false
 	}
-	return out.String()
+	out.WriteString(line[last:])
+	return out.String(), true
 }
 
-func replaceMacroIdents(expr string, macros map[string]ppMacro) string {
-	var out strings.Builder
-	for i := 0; i < len(expr); {
-		ch := expr[i]
-		if isIdentStart(ch) {
-			j := i + 1
-			for j < len(expr) && isIdentPart(expr[j]) {
-				j++
-			}
-			name := expr[i:j]
-			if m, ok := macros[name]; ok && m.params == nil && strings.TrimSpace(m.body) != "" {
-				out.WriteString(strings.TrimSpace(m.body))
-			} else {
-				out.WriteString(name)
-			}
-			i = j
-			continue
-		}
-		out.WriteByte(ch)
-		i++
-	}
-	return out.String()
+// cmd/asm's identifier grammar is not Go's: assembly identifiers also allow
+// the middle dot and division slash, including as their first rune.
+func ppIdentRune(ch rune, index int) bool {
+	return unicode.IsLetter(ch) || ch == '_' || ch == '·' || ch == '∕' ||
+		index > 0 && unicode.IsDigit(ch)
 }
 
 func isIdentStart(ch byte) bool {
-	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch >= 0x80
 }
 
 func isIdentPart(ch byte) bool {
@@ -597,7 +1040,10 @@ func expandInlineMacroCalls(line, name string, m ppMacro) (string, bool) {
 		}
 		j += i
 		// Identifier boundary check on the left side.
-		if j > 0 && isIdentPart(line[j-1]) {
+		// Go assembler symbols commonly prefix package-local names with the
+		// UTF-8 middle dot. Treat non-ASCII bytes as identifier bytes here so a
+		// macro named g expands in g(CX), but not inside TEXT ·g(SB).
+		if j > 0 && ppIsIdentChar(line[j-1]) {
 			out.WriteString(line[i : j+1])
 			i = j + 1
 			continue
diff --git a/preprocess_controls.go b/preprocess_controls.go
new file mode 100644
index 000000000..d243a5a80
--- /dev/null
+++ b/preprocess_controls.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"text/scanner"
+)
+
+// The Go assembly frontend has exactly these eight controls. Generated and
+// physical controls use the same dispatcher and the same live macro state.
+func (input *ppGoInput) control(origin ppGoToken) (bool, error) {
+	index, err := input.beginObservation("control", origin)
+	if err != nil {
+		return false, err
+	}
+	defer input.finishObservation(index)
+	return input.executeControl(origin)
+}
+
+func (input *ppGoInput) executeControl(origin ppGoToken) (bool, error) {
+	token, err := input.raw()
+	if err != nil {
+		return false, err
+	}
+	if token.kind != scanner.Ident {
+		return false, input.errorf("invalid preprocessor directive after '#'")
+	}
+	directive := token.value
+	if event := input.observedEvent(); event != nil {
+		event.Directive = directive
+	}
+	if !input.enabled() && directive != "else" && directive != "endif" &&
+		directive != "ifdef" && directive != "ifndef" && directive != "line" {
+		// Go skips only the control's name here. Macro tokens in the remaining
+		// disabled input still go through Next, including nested controls.
+		return false, nil
+	}
+	if event := input.observedEvent(); event != nil {
+		event.Executed = true
+	}
+	switch directive {
+	case "define":
+		return true, input.define()
+	case "undef":
+		name, err := input.name()
+		if err != nil {
+			return false, err
+		}
+		if _, found := input.macros[name]; !found {
+			return false, input.errorf("#undef for undefined macro: %s", name)
+		}
+		if err := input.newline(directive); err != nil {
+			return false, err
+		}
+		delete(input.macros, name)
+	case "ifdef", "ifndef":
+		name, err := input.name()
+		if err != nil {
+			return false, err
+		}
+		if err := input.newline(directive); err != nil {
+			return false, err
+		}
+		if len(input.conditions) >= 32 {
+			return false, input.errorf("CPP conditional nesting exceeds the explicit 32-level bound")
+		}
+		_, present := input.macros[name]
+		branch := present == (directive == "ifdef")
+		input.conditions = append(input.conditions, input.enabled() && branch)
+	case "else":
+		if err := input.newline(directive); err != nil {
+			return false, err
+		}
+		last := len(input.conditions) - 1
+		if last < 0 {
+			return false, input.errorf("unmatched #else")
+		}
+		if last == 0 || input.conditions[last-1] {
+			input.conditions[last] = !input.conditions[last]
+		}
+	case "endif":
+		if err := input.newline(directive); err != nil {
+			return false, err
+		}
+		if len(input.conditions) == 0 {
+			return false, input.errorf("unmatched #endif")
+		}
+		input.conditions = input.conditions[:len(input.conditions)-1]
+	case "include":
+		return true, input.include(origin)
+	case "line":
+		if err := input.line(); err != nil {
+			return false, err
+		}
+	default:
+		return false, input.errorf("unsupported Go assembly directive #%s", directive)
+	}
+	return true, nil
+}
+
+func (input *ppGoInput) define() error {
+	name, err := input.name()
+	if err != nil {
+		return err
+	}
+	previousColumn := input.last.endCol
+	token, err := input.raw()
+	if err != nil {
+		return err
+	}
+	macro := ppGoMacro{}
+	if token.kind != '\n' && token.kind != scanner.EOF {
+		if token.kind == '(' && token.endCol == previousColumn+1 {
+			macro.parameters = []string{}
+			parameterExpected := true
+			for {
+				token, err = input.raw()
+				if err != nil {
+					return err
+				}
+				if token.kind == ')' {
+					token, err = input.raw()
+					if err != nil {
+						return err
+					}
+					break
+				}
+				switch token.kind {
+				case ',':
+					if parameterExpected {
+						return input.errorf("bad syntax in macro definition: %s", name)
+					}
+					parameterExpected = true
+				case scanner.Ident:
+					if !parameterExpected || containsPPGoParameter(macro.parameters, token.value) {
+						return input.errorf("bad or duplicate argument in macro definition: %s", name)
+					}
+					macro.parameters = append(macro.parameters, token.value)
+					parameterExpected = false
+				default:
+					return input.errorf("bad definition for macro: %s", name)
+				}
+			}
+		}
+		for token.kind != '\n' {
+			if token.kind == scanner.EOF {
+				return input.errorf("missing newline in definition for macro: %s", name)
+			}
+			if token.kind == '\\' {
+				token, err = input.raw()
+				if err != nil {
+					return err
+				}
+				if token.kind != '\n' && token.kind != '\\' {
+					return input.errorf("macro replacement can only escape a backslash or newline: %s", name)
+				}
+			}
+			macro.body = append(macro.body, ppGoRecordedToken(token))
+			token, err = input.raw()
+			if err != nil {
+				return err
+			}
+		}
+	}
+	if _, exists := input.macros[name]; exists {
+		return input.errorf("redefinition of macro: %s", name)
+	}
+	if event := input.observedEvent(); event != nil {
+		event.Function = macro.parameters != nil
+		event.Parameters = ppGoCopyParameters(macro.parameters)
+		macro.definition = event.Ordinal
+	}
+	input.macros[name] = macro
+	return nil
+}
+
+func containsPPGoParameter(parameters []string, name string) bool {
+	for _, parameter := range parameters {
+		if parameter == name {
+			return true
+		}
+	}
+	return false
+}
+
+func (input *ppGoInput) include(origin ppGoToken) error {
+	token, err := input.raw()
+	if err != nil {
+		return err
+	}
+	if token.kind != scanner.String {
+		return input.errorf("invalid #include: expected literal string")
+	}
+	name, err := strconv.Unquote(token.value)
+	if err != nil {
+		return input.errorf("invalid #include: %v", err)
+	}
+	if err := input.newline("include"); err != nil {
+		return err
+	}
+	if input.options.ReadInclude == nil {
+		return input.errorf("active #include %q requires a resolver", name)
+	}
+	if input.includes >= 32 {
+		return input.errorf("include cycle/depth exceeds the explicit 32-level bound")
+	}
+	file, source, err := input.options.ReadInclude(origin.file, name)
+	if err != nil {
+		return fmt.Errorf("%s:%d: #include %q: %w", origin.file, origin.line, name, err)
+	}
+	if file == "" {
+		return input.errorf("active #include %q has no source identity", name)
+	}
+	// Hash and tokenize the same immutable snapshot of the resolver's bytes.
+	sourceText := string(source)
+	if input.observer != nil {
+		if err := input.observer.source(file, sourceText); err != nil {
+			return err
+		}
+		file = input.observer.sources[file].File
+	}
+	reader := newPPGoReader(file, sourceText)
+	if input.observer != nil && input.observer.positions != nil {
+		reader.positionBase = newSDKCPPFileBase(name)
+		reader.positionLine = 1
+	}
+	reader.include = true
+	if event := input.observedEvent(); event != nil {
+		event.Included = file
+		reader.includeEvent = event.Ordinal
+	}
+	if err := input.push(reader); err != nil {
+		return err
+	}
+	input.includes++
+	return nil
+}
+
+func (input *ppGoInput) line() error {
+	number, err := input.raw()
+	if err != nil {
+		return err
+	}
+	if number.kind != scanner.Int {
+		return input.errorf("invalid #line number")
+	}
+	if _, err := strconv.Atoi(number.value); err != nil {
+		return input.errorf("invalid #line number: %v", err)
+	}
+	file, err := input.raw()
+	if err != nil {
+		return err
+	}
+	if file.kind != scanner.String {
+		return input.errorf("invalid #line filename")
+	}
+	if _, err := strconv.Unquote(file.value); err != nil {
+		return input.errorf("invalid #line filename: %v", err)
+	}
+	// The API emits normalized machine source, not diagnostic line metadata.
+	// Keep physical origins for includes instead of trusting logical filenames.
+	if err := input.newline("line"); err != nil {
+		return err
+	}
+	if input.observer != nil && input.observer.positions != nil {
+		reader := input.readers[len(input.readers)-1]
+		logical, _ := strconv.Unquote(file.value)
+		line, _ := strconv.Atoi(number.value)
+		reader.positionBase = &sdkCPPPositionBase{
+			File: logical, Anchor: sdkCPPClampLine(reader.positionLine + 1), Line: uint(line),
+		}
+	}
+	return nil
+}
diff --git a/preprocess_eof_test.go b/preprocess_eof_test.go
new file mode 100644
index 000000000..979850b41
--- /dev/null
+++ b/preprocess_eof_test.go
@@ -0,0 +1,250 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// EOF of an included tokenizer is not EOF of the cmd/asm input stack. These
+// tests compare the original graph, not a version with appended newlines.
+func TestPreprocessAssemblyDirectiveEOFGoOracle(t *testing.T) {
+	const marker = "TEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n"
+	tests := []struct {
+		name, directive, suffix string
+		rootOK                  bool
+	}{
+		{"empty-define", "#define EMPTY", "", true},
+		{"empty-define-comment", "#define EMPTY // final comment", "", true},
+		{"body-define", "#define VALUE 42", "", false},
+		{"function-define", "#define EMPTY()", "", false},
+		{"parameter-define", "#define ID(x) x", "", false},
+		{"ifdef", "#ifdef PRESENT", "#endif\n", false},
+		{"ifndef", "#ifndef ABSENT", "#endif\n", false},
+		{"undef", "#undef PRESENT", "", false},
+		{"else", "#ifdef ABSENT\n#else", "#endif\n", false},
+		{"endif", "#ifdef ABSENT\n#endif", "", false},
+		{"include", "#include \"inner.h\"", "", false},
+		{"line", "#line 337 \"mapped.s\"", "", false},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			for _, placement := range []string{"root", "header-newline", "header-token", "header-root-eof", "nested-header-newline"} {
+				t.Run(placement, func(t *testing.T) {
+					headers := map[string]string{"inner.h": "#define INNER 1\n"}
+					source := "#define PRESENT 1\n" + marker
+					accepted := false
+					switch placement {
+					case "root":
+						source += tc.directive
+						accepted = tc.rootOK
+					case "header-newline":
+						headers["eof.h"] = tc.directive
+						source += "#include \"eof.h\"\n\n" + tc.suffix
+						accepted = true
+					case "header-token":
+						headers["eof.h"] = tc.directive
+						source += "#include \"eof.h\"\nUNEXPECTED\n" + tc.suffix
+						// A macro body (including an empty object-like one) can
+						// consume this token as replacement text until newline.
+						accepted = strings.Contains(tc.name, "define")
+					case "header-root-eof":
+						headers["eof.h"] = tc.directive
+						source += "#include \"eof.h\"\n"
+						accepted = tc.rootOK
+					case "nested-header-newline":
+						headers["eof.h"] = "#include \"leaf.h\"\n"
+						headers["leaf.h"] = tc.directive
+						source += "#include \"eof.h\"\n\n" + tc.suffix
+						accepted = true
+					}
+					assertDirectiveEOFGoOracle(t, source, headers, accepted)
+					got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+						FileName: "entry.s",
+						ReadInclude: func(parent, name string) (string, []byte, error) {
+							body, ok := headers[name]
+							if !ok {
+								return "", nil, fmt.Errorf("missing %s from %s", name, parent)
+							}
+							return name, []byte(body), nil
+						},
+					})
+					if (err == nil) != accepted {
+						t.Fatalf("preprocessor accepted=%t want Go=%t: %v\n%s", err == nil, accepted, err, got)
+					}
+					if accepted && (!strings.Contains(got, "$42") || strings.Contains(got, "UNEXPECTED")) {
+						t.Fatalf("EOF directive leaked/swallowed assembly: %q", got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func assertDirectiveEOFGoOracle(t *testing.T, source string, headers map[string]string, accepted bool) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, body := range headers {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	file := filepath.Join(dir, "entry.s")
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := exec.Command("go", "tool", "asm", "-S", "-p", "eoforacle", "-I", dir, "-o", filepath.Join(dir, "go.o"), file)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+	out, err := command.CombinedOutput()
+	if (err == nil) != accepted {
+		t.Fatalf("original Go EOF oracle accepted=%t want=%t: %v\n%s", err == nil, accepted, err, out)
+	}
+	if accepted && !strings.Contains(string(out), "2a 00 00 00") {
+		t.Fatalf("actual Go marker data bytes missing: %s", out)
+	}
+}
+
+func TestPreprocessAssemblyEOFIncludeRetainsDirectiveOrigin(t *testing.T) {
+	const marker = "TEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n"
+	headers := map[string]string{"eof.h": "#include \"inner.h\"", "inner.h": "#define INNER 1\n"}
+	source := "#include \"eof.h\"\n\n" + marker
+	assertDirectiveEOFGoOracle(t, source, headers, true)
+	var calls []string
+	_, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+		FileName: "entry.s",
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			calls = append(calls, parent+":"+name)
+			body, ok := headers[name]
+			if !ok {
+				return "", nil, fmt.Errorf("missing %s", name)
+			}
+			return name, []byte(body), nil
+		},
+	})
+	if err != nil || strings.Join(calls, ",") != "entry.s:eof.h,eof.h:inner.h" {
+		t.Fatalf("EOF include changed its original source identity: %v %v", calls, err)
+	}
+}
+
+func TestPreprocessAssemblyEOFMacroEscapeGoOracle(t *testing.T) {
+	const marker = "TEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n"
+	for _, tc := range []struct {
+		name, header, parent string
+		accepted             bool
+	}{
+		{"escape-newline", "#define BODY \\", "\nUNUSED\n", true},
+		{"escape-backslash", "#define BODY \\\\", "UNUSED\n", true},
+		{"invalid-escape-token", "#define BODY \\", "UNEXPECTED\n#define AFTER 1\n", false},
+		{"invalid-escape-body", "#define BODY \\oops\n", "\n", false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			headers := map[string]string{"eof.h": tc.header}
+			source := marker + "#include \"eof.h\"\n" + tc.parent
+			assertDirectiveEOFGoOracle(t, source, headers, tc.accepted)
+			got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+				FileName: "entry.s",
+				ReadInclude: func(parent, name string) (string, []byte, error) {
+					return name, []byte(headers[name]), nil
+				},
+			})
+			if (err == nil) != tc.accepted || err == nil && strings.Contains(got, "UNUSED") {
+				t.Fatalf("macro EOF escape differs from Go: accepted=%t want=%t err=%v expanded=%q", err == nil, tc.accepted, err, got)
+			}
+		})
+	}
+}
+
+func TestPreprocessAssemblyEOFMacroQuotedEscapes(t *testing.T) {
+	const header = "#define VALUE \"a\\\\b\""
+	const source = "TEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n#include \"eof.h\"\n\nDATA ·quoted(SB)/3,$VALUE\nGLOBL ·quoted(SB),8,$3\n"
+	assertDirectiveEOFGoOracle(t, source, map[string]string{"eof.h": header}, true)
+	got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+		FileName: "entry.s",
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			return name, []byte(header), nil
+		},
+	})
+	if err != nil || !strings.Contains(got, `DATA ·quoted(SB)/3,$"a\\b"`) {
+		t.Fatalf("macro escape processing changed a quoted token: %q %v", got, err)
+	}
+}
+
+func TestPreprocessAssemblyEOFObjectsFiveArchitectures(t *testing.T) {
+	llc, opt := findLLVM22Tool("llc"), findLLVM22Tool("opt")
+	if llc == "" || opt == "" {
+		t.Fatal("LLVM 22 llc and opt are required")
+	}
+	const source = "#include \"eof.h\"\n\nTEXT ·Probe(SB),$0-0\nRET\nDATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+	const header = "#ifndef ABSENT\n#define VALUE 42\n#endif"
+	for _, tc := range []struct {
+		arch         Arch
+		goarch, goos string
+		triple       string
+	}{
+		{ArchAMD64, "386", "linux", "i386-unknown-linux-gnu"},
+		{ArchAMD64, "amd64", "linux", "x86_64-unknown-linux-gnu"},
+		{ArchARM, "arm", "linux", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "linux", "aarch64-unknown-linux-gnu"},
+		{ArchWASM, "wasm", "js", "wasm32-unknown-unknown"},
+	} {
+		t.Run(tc.goarch, func(t *testing.T) {
+			dir := t.TempDir()
+			if err := os.WriteFile(filepath.Join(dir, "eof.h"), []byte(header), 0600); err != nil {
+				t.Fatal(err)
+			}
+			expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+				FileName: "entry.s",
+				ReadInclude: func(parent, name string) (string, []byte, error) {
+					body, err := os.ReadFile(filepath.Join(dir, name))
+					return name, body, err
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, input := range []struct{ name, body string }{{"original", source}, {"expanded", expanded}} {
+				file := filepath.Join(dir, input.name+".s")
+				if err := os.WriteFile(file, []byte(input.body), 0600); err != nil {
+					t.Fatal(err)
+				}
+				command := exec.Command("go", "tool", "asm", "-S", "-p", "eoforacle", "-I", dir, "-o", filepath.Join(dir, input.name+".o"), file)
+				command.Env = append(os.Environ(), "GOOS="+tc.goos, "GOARCH="+tc.goarch)
+				out, err := command.CombinedOutput()
+				if err != nil || !strings.Contains(string(out), "2a 00 00 00") {
+					t.Fatalf("original/expanded %s Go object: %v\n%s", input.name, err, out)
+				}
+			}
+			parsed, err := Parse(tc.arch, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(parsed, Options{
+				Goarch: tc.goarch, TargetTriple: tc.triple,
+				ResolveSym: testResolveSym("eoforacle"),
+				Sigs:       map[string]FuncSig{"eoforacle.Probe": {Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			ll, optimized := filepath.Join(dir, "eof.ll"), filepath.Join(dir, "eof-o2.ll")
+			if err := os.WriteFile(ll, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if out, err := exec.Command(opt, "-S", "-passes=default<O2>", ll, "-o", optimized).CombinedOutput(); err != nil {
+				t.Fatalf("LLVM 22 optimize: %v\n%s", err, out)
+			}
+			object := filepath.Join(dir, "llvm.o")
+			if out, err := exec.Command(llc, "-mtriple="+tc.triple, "-filetype=obj", optimized, "-o", object).CombinedOutput(); err != nil {
+				t.Fatalf("LLVM 22 object: %v\n%s", err, out)
+			}
+			info, err := os.Stat(object)
+			if err != nil || info.Size() == 0 {
+				t.Fatalf("LLVM object absent/empty: %v", err)
+			}
+			t.Logf("original Go + expanded Go + Parse/Translate/O2/LLVM22 objects: %s %s", tc.goarch, tc.triple)
+		})
+	}
+}
diff --git a/preprocess_go.go b/preprocess_go.go
new file mode 100644
index 000000000..4565a9208
--- /dev/null
+++ b/preprocess_go.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"text/scanner"
+)
+
+func preprocessGoAssembly(src string, options AssemblyPreprocessOptions) (string, error) {
+	return preprocessGoAssemblyObserved(src, options, nil)
+}
+
+func preprocessGoAssemblyObserved(src string, options AssemblyPreprocessOptions, observer *ppGoObservation) (string, error) {
+	file := options.FileName
+	if file == "" {
+		file = "<assembly>"
+	}
+	input := ppGoInput{
+		options: options, readers: []*ppGoReader{newPPGoReader(file, src)},
+		macros: make(map[string]ppGoMacro), bol: true, observer: observer,
+	}
+	if observer != nil && observer.positions != nil {
+		input.readers[0].positionBase = newSDKCPPFileBase(file)
+		input.readers[0].positionLine = 1
+	}
+	if observer != nil {
+		if err := observer.source(file, src); err != nil {
+			return "", err
+		}
+	}
+	for _, definition := range options.Defines {
+		name, value, assigned := strings.Cut(definition, "=")
+		if !assigned {
+			value = "1"
+		}
+		if !validPPIdentifier(name) {
+			return "", fmt.Errorf("invalid predefined CPP macro %q", name)
+		}
+		reader := newPPGoReader("<predefined>", value)
+		macro := ppGoMacro{}
+		for {
+			token, err := reader.next()
+			if err != nil {
+				return "", err
+			}
+			if token.kind == scanner.EOF {
+				break
+			}
+			macro.body = append(macro.body, ppGoRecordedToken(token))
+		}
+		if observer != nil {
+			index, err := input.beginObservation("predefine", ppGoToken{file: "<predefined>", line: 1})
+			if err != nil {
+				return "", err
+			}
+			event := input.observedEvent()
+			event.Name, event.Executed = name, true
+			for _, token := range macro.body {
+				if err := observer.capture(token); err != nil {
+					return "", err
+				}
+			}
+			macro.definition = index + 1
+			input.finishObservation(index)
+		}
+		input.macros[name] = macro
+	}
+	var output strings.Builder
+	var previous ppGoToken
+	statementTokens := 0
+	parserPositionInitialized := false
+	for {
+		token, err := input.next()
+		if err != nil {
+			return "", err
+		}
+		if token.kind == scanner.EOF {
+			if statementTokens != 0 {
+				return "", input.errorf("unexpected instruction EOF: missing newline or semicolon")
+			}
+			break
+		}
+		if token.kind == '#' {
+			// Preserve Input.Next's control-wisp boundary before asking for
+			// another token; cached function-macro lookahead may follow it.
+			continue
+		}
+		if token.kind == ppGoMacroName {
+			// A bare function-like macro is a private Go token, not an
+			// identifier. Relexing its spelling would accept invalid opcodes
+			// and operands which the original assembler rejects.
+			return "", input.errorf("function-like macro %q requires arguments", token.text)
+		}
+		if token.kind == ppGoBuildComment {
+			// Before the parser observes its first non-control token, Go's
+			// diagnostic line is still zero and its errorf suppresses that
+			// first-line CPP/build-comment diagnostic. Preserve this observed
+			// acceptance instead of rejecting every comment after a control.
+			if input.sawCode && parserPositionInitialized {
+				return "", input.errorf("misplaced //go:build comment")
+			}
+			continue
+		}
+		parserPositionInitialized = true
+		if observer != nil && observer.positions != nil {
+			if err := observer.emitSDKPosition(token, input.readers[len(input.readers)-1].positionBase); err != nil {
+				return "", err
+			}
+		}
+		if token.kind != '\n' {
+			input.sawCode = true
+		}
+		if token.kind == '\n' {
+			start := output.Len()
+			if statementTokens != 0 {
+				output.WriteByte('\n')
+			}
+			if observer != nil {
+				if err := observer.emitOutput(token, start, output.Len()); err != nil {
+					return "", err
+				}
+			}
+			previous, statementTokens = ppGoToken{}, 0
+			continue
+		}
+		if statementTokens != 0 && (ppGoTokenNeedsSpace(previous, token) ||
+			statementTokens == 1 && previous.kind == scanner.Ident && token.kind != ':') {
+			output.WriteByte(' ')
+		}
+		start := output.Len()
+		output.WriteString(token.text)
+		if observer != nil {
+			if err := observer.emitOutput(token, start, output.Len()); err != nil {
+				return "", err
+			}
+		}
+		previous = token
+		statementTokens++
+		if token.kind == ';' || token.kind == ':' {
+			statementTokens = 0
+		}
+	}
+	return output.String(), nil
+}
+
+func ppGoTokenNeedsSpace(left, right ppGoToken) bool {
+	word := func(kind rune) bool {
+		return kind == scanner.Ident || kind == scanner.Int || kind == scanner.Float
+	}
+	if word(left.kind) && word(right.kind) {
+		return true
+	}
+	if left.text == "/" && (right.text == "*" || right.text == "/") {
+		return true
+	}
+	// Removing whitespace must not turn separate source tokens into one
+	// shift, rotate, arrow or numeric token on the second lexical pass.
+	if (left.text == "<" && right.text == "<") || (left.text == ">" && right.text == ">") ||
+		(left.text == "-" || left.text == "@") && right.text == ">" {
+		return true
+	}
+	return (left.kind == scanner.Int || left.kind == scanner.Float) && right.text == "." ||
+		left.text == "." && (right.kind == scanner.Int || right.kind == scanner.Float)
+}
diff --git a/preprocess_immediate_test.go b/preprocess_immediate_test.go
new file mode 100644
index 000000000..ad5ae76a0
--- /dev/null
+++ b/preprocess_immediate_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPreprocessImmediateMacrosRespectCompleteTokens(t *testing.T) {
+	for _, test := range []struct{ name, source, want string }{
+		{"named_stack_address", "#define buf buffer-(8+4*16)(SP)\nMOVW $buf, R0\n", "MOVW $buffer-(8+4*16)(SP), R0"},
+		{"identifier_prefix", "#define CONST 33\nMOVQ $CONSTANT, AX\n", "MOVQ $CONSTANT, AX"},
+		{"quoted_string", "#define buf 33\nDATA data(SB)/4, $\"buf\"\n", "DATA data(SB)/4, $\"buf\""},
+		{"character", "#define x 33\nBYTE $'x'\n", "BYTE $'x'"},
+		{"qualified_symbol", "#define value 33\nMOVQ $pkg·value(SB), AX\n", "MOVQ $pkg·value(SB), AX"},
+		{"division_slash_symbol", "#define value 33\nMOVQ $pkg∕value(SB), AX\n", "MOVQ $pkg∕value(SB), AX"},
+		{"middle_dot_symbol", "#define value 33\nMOVQ $·value(SB), AX\n", "MOVQ $·value(SB), AX"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got, err := preprocess(test.source)
+			if err != nil || strings.TrimSpace(got) != test.want {
+				t.Fatalf("preprocess = %q, %v; want complete-token expansion %q", got, err, test.want)
+			}
+		})
+	}
+}
+
+func TestARMImmediateNamedStackMacroRetainsRealAddress(t *testing.T) {
+	const source = `
+#define buf buffer-(8+4*16)(SP)
+TEXT stack_address(SB),$84-0
+MOVW $buf, R0
+RET
+`
+	requireARMGoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	operand := file.Funcs[0].Instrs[1].Args[0]
+	address, ok := parseMem(strings.TrimPrefix(operand.Sym, "$"))
+	if operand.Kind != OpSym || !ok || address.Base != SP || address.Off != -72 {
+		t.Fatalf("named stack address corrupted or replaced with zero: %+v", operand)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"armv5te-unknown-linux-gnueabi", "armv7-unknown-linux-gnueabihf", "thumbv7-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"stack_address": {Name: "stack_address", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !strings.Contains(ir, ", -72") {
+				t.Fatalf("real stack displacement missing:\n%s", ir)
+			}
+			compileLLVMToObject(t, llc, triple, "stack-address.ll", "stack-address.o", ir)
+		})
+	}
+}
diff --git a/preprocess_include_test.go b/preprocess_include_test.go
new file mode 100644
index 000000000..3e2b112bd
--- /dev/null
+++ b/preprocess_include_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestPreprocessAssemblyActiveIncludes(t *testing.T) {
+	const source = `#define OUTER 41
+#ifdef ENABLE
+#include "outer.h"
+#else
+#include invalid missing operand
+#define LEAK 900
+#endif
+#ifdef LEAK
+BAD
+#endif
+VALUE
+#undef VALUE
+#define VALUE 73
+VALUE
+`
+	files := map[string]string{
+		"outer.h": "#ifdef ENABLE\n#include \"inner.h\"\n#endif\n#define VALUE OUTER+INNER\n",
+		"inner.h": "#define INNER 1\n",
+	}
+	var calls []string
+	got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+		FileName: "main.s", Defines: []string{"ENABLE"},
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			calls = append(calls, parent+":"+name)
+			body, ok := files[name]
+			if !ok {
+				return "", nil, fmt.Errorf("missing %s", name)
+			}
+			return name, []byte(body), nil
+		},
+	})
+	if err != nil || strings.TrimSpace(got) != "41+1\n73" {
+		t.Fatalf("preprocess = %q, %v; want real source-order headers", got, err)
+	}
+	if strings.Join(calls, ",") != "main.s:outer.h,outer.h:inner.h" {
+		t.Fatalf("resolver calls = %v", calls)
+	}
+}
+
+func TestPreprocessAssemblyIncludeFailures(t *testing.T) {
+	for _, tc := range []struct{ name, source, want string }{
+		{"no-resolver", "#include \"missing.h\"\n", "resolver"},
+		{"missing", "#include \"missing.h\"\n", "missing header"},
+		{"malformed", "#include notQuoted\n", "invalid #include"},
+		{"trailing", "#include \"h\" garbage\n", "invalid #include"},
+		{"cycle", "#include \"main.s\"\n", "cycle"},
+		{"redefined", "#define A 1\n#define A 2\n", "redefinition"},
+		{"undefined-undef", "#undef A\n", "undefined macro"},
+		{"invalid-ifdef", "#ifdef A garbage\n#endif\n", "invalid #ifdef"},
+		{"unknown-control", "#if A\n#endif\n", "unsupported Go assembly directive"},
+		{"expanded-include", "#define HEADER #include \"h\"\nHEADER\n", "missing header"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			opt := AssemblyPreprocessOptions{FileName: "main.s"}
+			if tc.name != "no-resolver" {
+				opt.ReadInclude = func(parent, name string) (string, []byte, error) {
+					if name == "main.s" {
+						return name, []byte(tc.source), nil
+					}
+					return "", nil, fmt.Errorf("missing header %s", name)
+				}
+			}
+			if _, err := PreprocessAssemblySource(tc.source, opt); err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("error = %v; want %q", err, tc.want)
+			}
+		})
+	}
+	if _, err := preprocess("#include \"legacy.h\"\nRET\n"); err != nil {
+		t.Fatalf("legacy Parse compatibility: %v", err)
+	}
+	if got, err := PreprocessAssemblySource("#ifdef ABSENT\n#include notQuoted\n#endif\nRET\n", AssemblyPreprocessOptions{}); err != nil || strings.TrimSpace(got) != "RET" {
+		t.Fatalf("inactive include = %q, %v", got, err)
+	}
+}
+
+func TestPreprocessAssemblyGoObjectOracle(t *testing.T) {
+	// These are assembler objects, not runtime/ISA coverage. The actual Go
+	// assembler independently consumes the original header graph, then checks
+	// the same data bytes as the emitted source on all supported architectures.
+	for _, target := range []struct{ arch, goos, key, value, define string }{
+		{"amd64", "linux", "GOAMD64", "v1", "GOAMD64_v1"},
+		{"amd64", "linux", "GOAMD64", "v3", "GOAMD64_v3"},
+		{"386", "linux", "GO386", "sse2", "GO386_sse2"},
+		{"386", "linux", "GO386", "softfloat", "GO386_softfloat"},
+		{"arm", "linux", "GOARM", "5", "GOARM_5"},
+		{"arm", "linux", "GOARM", "6,softfloat", "GOARM_6"},
+		{"arm", "linux", "GOARM", "7", "GOARM_7"},
+		{"arm64", "linux", "GOARM64", "v9.1,lse", "GOARM64_LSE"},
+		{"wasm", "js", "", "", "GOARCH_wasm"},
+	} {
+		t.Run(target.arch+"-"+target.value, func(t *testing.T) {
+			dir := t.TempDir()
+			if err := os.Mkdir(filepath.Join(dir, "sub"), 0700); err != nil {
+				t.Fatal(err)
+			}
+			headers := map[string]string{
+				"sub/outer.h": "#include \"inner.h\"\n#define VALUE OUTER+INNER\n",
+				"inner.h":     "#define INNER 2\n",
+			}
+			for name, body := range headers {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			source := "#define OUTER 40\n#ifdef " + target.define + "\n#include \"sub/outer.h\"\n#else\n#include \"absent.h\"\n#define LEAK 1\n#endif\n" +
+				"#ifdef LEAK\nBAD\n#endif\nDATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+			defines := GoAssemblerDefinesWithEnv(target.goos, target.arch, map[string]string{target.key: target.value})
+			if !strings.Contains(","+strings.Join(defines, ",")+",", ","+target.define+",") {
+				t.Fatalf("resolved CPU define %s missing: %v", target.define, defines)
+			}
+			got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+				FileName: "entry.s", Defines: defines,
+				ReadInclude: func(parent, name string) (string, []byte, error) {
+					body, err := os.ReadFile(filepath.Join(dir, name))
+					return name, body, err
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, input := range []struct{ name, body string }{{"original", source}, {"expanded", got}} {
+				path := filepath.Join(dir, input.name+".s")
+				if err := os.WriteFile(path, []byte(input.body), 0600); err != nil {
+					t.Fatal(err)
+				}
+				args := []string{"tool", "asm", "-S", "-p", "oracle", "-I", dir, "-o", filepath.Join(dir, input.name+".o")}
+				for _, define := range defines {
+					args = append(args, "-D", define)
+				}
+				args = append(args, path)
+				command := exec.Command("go", args...)
+				command.Dir = dir
+				command.Env = append(os.Environ(), "GOOS="+target.goos, "GOARCH="+target.arch)
+				out, err := command.CombinedOutput()
+				if err != nil || !strings.Contains(string(out), "2a 00 00 00") {
+					t.Fatalf("%s actual Go object data: %v\n%s", input.name, err, out)
+				}
+			}
+		})
+	}
+}
+
+func TestGoAssemblerDefinesExplicitEnvironment(t *testing.T) {
+	t.Setenv("GOAMD64", "v1")
+	got := GoAssemblerDefinesWithEnv("linux", "amd64", map[string]string{"GOAMD64": "v3"})
+	if strings.Join(got, ",") != "GOOS_linux,GOARCH_amd64,GOAMD64_v3" {
+		t.Fatalf("defines use process rather than resolved configuration: %v", got)
+	}
+}
+
+func TestPreprocessAssemblyGoControlTokenOracle(t *testing.T) {
+	for _, name := range []string{"A·B", "A∕B", "·Start", "∕Start"} {
+		t.Run(name, func(t *testing.T) {
+			source := "#define " + name + " 1\n#ifdef " + name + "\n#define VALUE 42\n#endif\n#undef " + name + "\n#ifndef " + name +
+				"\nDATA ·value(SB)/4,$VALUE\n#endif\nGLOBL ·value(SB),8,$4\n"
+			runGoAssemblyControlOracle(t, source, true)
+			got, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{})
+			if err != nil || !strings.Contains(got, "$42") {
+				t.Fatalf("Go assembly control identifier %q: %q, %v", name, got, err)
+			}
+		})
+	}
+	for _, source := range []string{
+		"#ifdef\n#endif\n", "#ifndef A/B\n#endif\n", "#ifdef 42\n#endif\n",
+		"#define A 1\n#undef A·\n", "#define A 1\n#undef A trailing\n", "#else extra\n", "#endif extra\n",
+		"#line 337\n", "#line nope \"file.s\"\n", "#line 337 \"file.s\" trailing\n",
+	} {
+		runGoAssemblyControlOracle(t, source, false)
+		if _, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{}); err == nil {
+			t.Errorf("Go-rejected preprocessor control accepted: %q", source)
+		}
+	}
+	const validLine = "#line 337 \"source name.s\"\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n"
+	runGoAssemblyControlOracle(t, validLine, true)
+	if got, err := PreprocessAssemblySource(validLine, AssemblyPreprocessOptions{}); err != nil || !strings.Contains(got, "$42") {
+		t.Fatalf("valid Go #line: %q, %v", got, err)
+	}
+	const inactiveExpandedInclude = "#define BODY \\\n#ifdef ABSENT \\\n#include malformed missing operand \\\n#endif\nBODY\nDATA ·value(SB)/4,$42\nGLOBL ·value(SB),8,$4\n"
+	runGoAssemblyControlOracle(t, inactiveExpandedInclude, true)
+	if got, err := PreprocessAssemblySource(inactiveExpandedInclude, AssemblyPreprocessOptions{}); err != nil || !strings.Contains(got, "$42") {
+		t.Errorf("inactive macro-expanded include parsed: %q, %v", got, err)
+	}
+	const invalidExpandedCondition = "#define BODY \\\n#ifdef ABSENT garbage \\\n#endif\nBODY\n"
+	runGoAssemblyControlOracle(t, invalidExpandedCondition, false)
+	if _, err := PreprocessAssemblySource(invalidExpandedCondition, AssemblyPreprocessOptions{}); err == nil {
+		t.Fatal("Go-rejected macro-expanded condition accepted")
+	}
+}
+
+func runGoAssemblyControlOracle(t *testing.T, source string, accepted bool) {
+	t.Helper()
+	dir := t.TempDir()
+	path := filepath.Join(dir, "source.s")
+	if err := os.WriteFile(path, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := exec.Command("go", "tool", "asm", "-S", "-p", "control", "-o", filepath.Join(dir, "go.o"), path)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64")
+	out, err := command.CombinedOutput()
+	if (err == nil) != accepted {
+		t.Fatalf("Go control oracle accepted=%v, want %v: %v\n%s", err == nil, accepted, err, out)
+	}
+	if accepted && !strings.Contains(string(out), "2a 00 00 00") {
+		t.Fatalf("actual Go data bytes missing:\n%s", out)
+	}
+}
diff --git a/preprocess_inventory.go b/preprocess_inventory.go
new file mode 100644
index 000000000..ff741bfb9
--- /dev/null
+++ b/preprocess_inventory.go
@@ -0,0 +1,226 @@
+package plan9asm
+
+import (
+	"fmt"
+	"text/scanner"
+)
+
+// AssemblyCPPToken describes a physical token, not an expanded or accepted
+// assembly instruction. RecordedValue uses the strict preprocessor's recording
+// projection; it is not an independently selected SDK encoder certificate.
+type AssemblyCPPToken struct {
+	Kind          string
+	Text          string
+	RecordedValue string
+	Start         int
+	End           int
+	Line          int
+	Column        int
+	EndColumn     int
+}
+
+// AssemblyCPPMacroDefinition retains lexical definition identity. Parameters
+// is nil for an object macro and non-nil for a function macro, including F().
+type AssemblyCPPMacroDefinition struct {
+	Name        string
+	Function    bool
+	Parameters  []string
+	Replacement []AssemblyCPPToken
+}
+
+// AssemblyCPPSourceRecord is an original physical span. It does not say that
+// a directive or candidate invocation is active, defined or syntactically valid
+// as a translation unit. Text retains comments, adjacency and continuations.
+type AssemblyCPPSourceRecord struct {
+	Kind       string
+	Start      int
+	End        int
+	Line       int
+	EndLine    int
+	Text       string
+	Tokens     []AssemblyCPPToken
+	Definition *AssemblyCPPMacroDefinition
+}
+
+type AssemblyCPPSourceInventory struct {
+	File         string
+	ByteLength   int
+	FinalNewline bool
+	EOF          AssemblyCPPToken
+	Records      []AssemblyCPPSourceRecord
+}
+
+// InspectAssemblyCPPSource is query-only. It neither executes CPP nor grants
+// source, include, frame, ABI or instruction permission. Names select potential
+// physical invocations, including occurrences before a later definition.
+func InspectAssemblyCPPSource(source, file string, invocationNames []string) (AssemblyCPPSourceInventory, error) {
+	result := AssemblyCPPSourceInventory{
+		File: file, ByteLength: len(source), FinalNewline: len(source) != 0 && source[len(source)-1] == '\n',
+		Records: []AssemblyCPPSourceRecord{},
+	}
+	if file == "" || len(source) > 64<<20 || len(invocationNames) > 4096 {
+		return result, fmt.Errorf("physical CPP query requires bounded named source and invocation names")
+	}
+	names := make(map[string]bool, len(invocationNames))
+	for _, name := range invocationNames {
+		if !validPPIdentifier(name) || names[name] {
+			return result, fmt.Errorf("physical CPP query has an invalid or duplicate invocation name")
+		}
+		names[name] = true
+	}
+
+	reader := newPPGoReader(file, source)
+	readLine := func() ([]AssemblyCPPToken, error) {
+		var tokens []AssemblyCPPToken
+		for {
+			physical, err := reader.next()
+			if err != nil {
+				return nil, err
+			}
+			if len(tokens) >= 1<<20 {
+				return nil, fmt.Errorf("physical CPP statement exceeds its token bound")
+			}
+			token := assemblyCPPPhysicalToken(reader, physical)
+			tokens = append(tokens, token)
+			if token.Kind == "newline" || token.Kind == "eof" {
+				return tokens, nil
+			}
+		}
+	}
+	retainedTokens := 0
+	for {
+		tokens, err := readLine()
+		if err != nil {
+			return result, err
+		}
+		directive := len(tokens) > 1 && tokens[0].Text == "#"
+		definition := directive && tokens[1].Kind == "identifier" && tokens[1].Text == "define"
+		for definition && assemblyCPPContinuedLine(tokens) {
+			continued, err := readLine()
+			if err != nil {
+				return result, err
+			}
+			if len(continued) > 1<<20-len(tokens) {
+				return result, fmt.Errorf("physical CPP definition exceeds its token bound")
+			}
+			tokens = append(tokens, continued...)
+		}
+		last := tokens[len(tokens)-1]
+		if last.Kind == "eof" {
+			result.EOF = last
+		}
+		kind := ""
+		if directive {
+			kind = "directive"
+		} else {
+			for _, token := range tokens {
+				if token.Kind == "build_comment" || token.Text == "#" {
+					kind = "lexical_control"
+					break
+				}
+				if token.Kind == "identifier" && names[token.Text] {
+					kind = "candidate"
+				}
+			}
+		}
+		if kind != "" {
+			if len(result.Records) >= 4096 || retainedTokens+len(tokens) > 1<<20 {
+				return result, fmt.Errorf("physical CPP inventory exceeds its record/token bound")
+			}
+			first := tokens[0]
+			record := AssemblyCPPSourceRecord{
+				Kind: kind, Start: first.Start, End: last.End, Line: first.Line,
+				EndLine: last.Line, Text: source[first.Start:last.End], Tokens: tokens,
+			}
+			if definition {
+				record.Definition, err = assemblyCPPPhysicalDefinition(tokens)
+				if err != nil {
+					return result, fmt.Errorf("%s:%d: %w", file, first.Line, err)
+				}
+			}
+			result.Records = append(result.Records, record)
+			retainedTokens += len(tokens)
+		}
+		if last.Kind == "eof" {
+			return result, nil
+		}
+	}
+}
+
+func assemblyCPPPhysicalToken(reader *ppGoReader, physical ppGoToken) AssemblyCPPToken {
+	kind := string(physical.kind)
+	switch physical.kind {
+	case scanner.EOF:
+		kind = "eof"
+	case scanner.Ident:
+		kind = "identifier"
+	case scanner.Int:
+		kind = "integer"
+	case scanner.Float:
+		kind = "float"
+	case scanner.Char:
+		kind = "character"
+	case scanner.String:
+		kind = "string"
+	case scanner.RawString:
+		kind = "raw_string"
+	case ppGoBuildComment:
+		kind = "build_comment"
+	case '\n':
+		kind = "newline"
+	}
+	return AssemblyCPPToken{
+		Kind: kind, Text: physical.text, RecordedValue: ppGoRecordedToken(physical).value,
+		Start: reader.scanner.Position.Offset, End: reader.scanner.Pos().Offset,
+		Line: physical.line, Column: reader.scanner.Position.Column, EndColumn: physical.endCol,
+	}
+}
+
+func assemblyCPPContinuedLine(tokens []AssemblyCPPToken) bool {
+	if tokens[len(tokens)-1].Kind != "newline" {
+		return false
+	}
+	backslashes := 0
+	for index := len(tokens) - 2; index >= 0 && tokens[index].Kind == "\\"; index-- {
+		backslashes++
+	}
+	return backslashes%2 != 0
+}
+
+// This reads definition shape only. Replacement escapes and token execution
+// belong to ppGoInput.define; the original complete token span is kept here.
+func assemblyCPPPhysicalDefinition(tokens []AssemblyCPPToken) (*AssemblyCPPMacroDefinition, error) {
+	if len(tokens) < 4 || tokens[2].Kind != "identifier" {
+		return nil, fmt.Errorf("physical define has no literal macro name")
+	}
+	macro := &AssemblyCPPMacroDefinition{Name: tokens[2].Text}
+	index := 3
+	if tokens[index].Kind == "(" && tokens[index].Column == tokens[2].EndColumn {
+		macro.Function = true
+		macro.Parameters = []string{}
+		index++
+		expectName := true
+		for index < len(tokens) && tokens[index].Kind != ")" {
+			token := tokens[index]
+			if expectName && token.Kind == "identifier" {
+				if containsPPGoParameter(macro.Parameters, token.Text) {
+					return nil, fmt.Errorf("physical define repeats a formal parameter")
+				}
+				macro.Parameters = append(macro.Parameters, token.Text)
+				expectName = false
+			} else if !expectName && token.Kind == "," {
+				expectName = true
+			} else {
+				return nil, fmt.Errorf("physical define has an unregistered formal shape")
+			}
+			index++
+		}
+		if index == len(tokens) || tokens[index].Kind != ")" {
+			return nil, fmt.Errorf("physical define has an incomplete formal list")
+		}
+		index++
+	}
+	end := len(tokens) - 1 // The terminating physical newline/EOF is separate.
+	macro.Replacement = append([]AssemblyCPPToken(nil), tokens[index:end]...)
+	return macro, nil
+}
diff --git a/preprocess_inventory_defines.go b/preprocess_inventory_defines.go
new file mode 100644
index 000000000..d5d2f2eb3
--- /dev/null
+++ b/preprocess_inventory_defines.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"text/scanner"
+)
+
+// AssemblyCPPDriverDefinition preserves an ordered supplied -D string and its
+// object-macro token projection. Replacement positions are relative to the
+// supplied value, not a physical assembly file or an actual command receipt.
+type AssemblyCPPDriverDefinition struct {
+	Text       string
+	Definition AssemblyCPPMacroDefinition
+}
+
+// InspectAssemblyCPPDriverDefinitions is query-only. It does not establish
+// that a driver consumed these definitions, execute CPP, or grant source/ABI
+// authority. The caller must independently bind the exact ordered inputs.
+// Repeated names are retained: stock Go's predefine loop overwrites in order.
+func InspectAssemblyCPPDriverDefinitions(defines []string) ([]AssemblyCPPDriverDefinition, error) {
+	if len(defines) > 4096 {
+		return nil, fmt.Errorf("driver CPP query exceeds its definition bound")
+	}
+	definitions := make([]AssemblyCPPDriverDefinition, 0, len(defines))
+	bytes, tokens := 0, 0
+	for _, text := range defines {
+		if len(text) > 1<<20-bytes {
+			return nil, fmt.Errorf("driver CPP query exceeds its definition byte bound")
+		}
+		bytes += len(text)
+		name, value := text, "1"
+		if index := strings.IndexByte(text, '='); index > 0 {
+			name, value = text[:index], text[index+1:]
+		}
+		// Keep the literal key used by Go's predefine map. A spelling with
+		// surrounding whitespace/comments may tokenize as one Go identifier,
+		// but is not a literal invocation name this raw query can close.
+		if !validPPIdentifier(name) {
+			return nil, fmt.Errorf("driver CPP query needs a literal macro name: %q", name)
+		}
+		definition := AssemblyCPPDriverDefinition{
+			Text: text, Definition: AssemblyCPPMacroDefinition{
+				Name: name, Replacement: []AssemblyCPPToken{},
+			},
+		}
+		reader := newPPGoReader("<driver-definition>", value)
+		for {
+			physical, err := reader.next()
+			if err != nil {
+				return nil, err
+			}
+			if physical.kind == scanner.EOF {
+				break
+			}
+			if tokens >= 1<<20 {
+				return nil, fmt.Errorf("driver CPP query exceeds its replacement token bound")
+			}
+			definition.Definition.Replacement = append(definition.Definition.Replacement,
+				assemblyCPPPhysicalToken(reader, physical))
+			tokens++
+		}
+		definitions = append(definitions, definition)
+	}
+	return definitions, nil
+}
diff --git a/preprocess_inventory_defines_test.go b/preprocess_inventory_defines_test.go
new file mode 100644
index 000000000..0c71510b2
--- /dev/null
+++ b/preprocess_inventory_defines_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestInspectAssemblyCPPDriverDefinitionsPreserveOrderedTokens(t *testing.T) {
+	inputs := []string{"DEFAULT", "EMPTY=", "EMIT=x·first", "EMIT=x∕second /* comment */ << 2\n"}
+	got, err := InspectAssemblyCPPDriverDefinitions(inputs)
+	if err != nil || len(got) != len(inputs) {
+		t.Fatalf("driver definitions lost: %+v %v", got, err)
+	}
+	for index, definition := range got {
+		if definition.Text != inputs[index] || definition.Definition.Function || definition.Definition.Parameters != nil {
+			t.Fatal("exact ordered text or object-macro identity changed")
+		}
+	}
+	if got[0].Definition.Replacement[0].Text != "1" || got[1].Definition.Replacement == nil ||
+		len(got[1].Definition.Replacement) != 0 || got[2].Definition.Name != got[3].Definition.Name {
+		t.Fatal("default, explicit empty or legal duplicate overwrite identity changed")
+	}
+	tokens := got[3].Definition.Replacement
+	if len(tokens) != 4 || tokens[0].Text != "x∕second" || tokens[0].RecordedValue != "x/second" ||
+		tokens[1].Text != "<<" || tokens[3].Kind != "newline" || tokens[0].Start != 0 {
+		t.Fatalf("shared Go scanner/recording projection changed: %+v", tokens)
+	}
+	if got[2].Definition.Replacement[0].RecordedValue != "x.first" {
+		t.Fatal("predefine canonical recording was not preserved")
+	}
+	inputs[0] = "MUTATED"
+	got[3].Definition.Replacement[0].Text = "mutated"
+	got[2].Definition.Name = "mutated"
+	again, err := InspectAssemblyCPPDriverDefinitions([]string{"DEFAULT", "EMPTY=", "EMIT=x·first", "EMIT=x∕second /* comment */ << 2\n"})
+	if err != nil || again[0].Text != "DEFAULT" || again[2].Definition.Name != "EMIT" ||
+		again[3].Definition.Replacement[0].Text != "x∕second" {
+		t.Fatal("query retained caller-owned mutable slices")
+	}
+	empty, err := InspectAssemblyCPPDriverDefinitions(nil)
+	if err != nil || empty == nil || len(empty) != 0 {
+		t.Fatal("empty required driver definition set disappeared")
+	}
+}
+
+func TestInspectAssemblyCPPDriverDefinitionsBoundsAndLexicalFailures(t *testing.T) {
+	cases := map[string][]string{
+		"count":      make([]string, 4097),
+		"bytes":      {"BODY=" + strings.Repeat("x", 1<<20)},
+		"empty name": {""},
+		"assignment": {"=x"},
+		"function":   {"F(x)=x"},
+		"nonliteral": {"NAME /* key is not literal */=1"},
+		"quote":      {"BODY=\"unterminated"},
+	}
+	for name, inputs := range cases {
+		t.Run(name, func(t *testing.T) {
+			got, err := InspectAssemblyCPPDriverDefinitions(inputs)
+			if got != nil || err == nil {
+				t.Fatalf("unbounded/unclosed driver input accepted: %+v %v", got, err)
+			}
+		})
+	}
+	got, err := InspectAssemblyCPPDriverDefinitions([]string{"FLAGS=1=2", "FLAGS=", "FLAGS"})
+	if err != nil || !reflect.DeepEqual([]string{got[0].Text, got[1].Text, got[2].Text}, []string{"FLAGS=1=2", "FLAGS=", "FLAGS"}) {
+		t.Fatalf("query confused first '=' or ordered overwrite semantics: %+v %v", got, err)
+	}
+	boundary := "A=" + strings.Repeat(" ", (1<<20)-2)
+	got, err = InspectAssemblyCPPDriverDefinitions([]string{boundary})
+	if err != nil || len(got) != 1 || got[0].Text != boundary || len(got[0].Definition.Replacement) != 0 {
+		t.Fatalf("exact byte-bound control failed: count=%d err=%v", len(got), err)
+	}
+	duplicates := make([]string, 4096)
+	for index := range duplicates {
+		duplicates[index] = "A=1"
+	}
+	got, err = InspectAssemblyCPPDriverDefinitions(duplicates)
+	if err != nil || len(got) != len(duplicates) {
+		t.Fatalf("legal ordered duplicates at the count bound failed: count=%d err=%v", len(got), err)
+	}
+}
diff --git a/preprocess_inventory_strings.go b/preprocess_inventory_strings.go
new file mode 100644
index 000000000..803e80abe
--- /dev/null
+++ b/preprocess_inventory_strings.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"fmt"
+	"text/scanner"
+)
+
+// InspectAssemblyCPPStringTokens queries physical String tokens and their Make
+// recording projection with the same reader as the strict executor. A token is
+// not an include invocation, an active input or an authenticated source. Raw
+// strings are excluded because Go's include reader requires scanner.String.
+func InspectAssemblyCPPStringTokens(source, file string) ([]AssemblyCPPToken, error) {
+	if file == "" || len(source) > 64<<20 {
+		return nil, fmt.Errorf("CPP String query requires bounded named original bytes")
+	}
+	result := []AssemblyCPPToken{}
+	reader := newPPGoReader(file, source)
+	for {
+		token, err := reader.next()
+		if err != nil {
+			return nil, err
+		}
+		if token.kind == scanner.EOF {
+			return result, nil
+		}
+		if token.kind != scanner.String {
+			continue
+		}
+		if len(result) >= 4096 {
+			return nil, fmt.Errorf("CPP String query exceeds its candidate token bound")
+		}
+		result = append(result, assemblyCPPPhysicalToken(reader, token))
+	}
+}
diff --git a/preprocess_inventory_strings_test.go b/preprocess_inventory_strings_test.go
new file mode 100644
index 000000000..6543797ad
--- /dev/null
+++ b/preprocess_inventory_strings_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestInspectAssemblyCPPStringTokensPhysicalAndRecorded(t *testing.T) {
+	source := "// ignored \"comment.h\"\n" +
+		"#define INCLUDE(file) #include file\n" +
+		"INCLUDE(\"header∕one.h\")\nDATA ·x(SB)/4,$\"data\"\n" +
+		"`raw.h`\n#line 1 \"logical-file\"\n"
+	tokens, err := InspectAssemblyCPPStringTokens(source, "original.s")
+	if err != nil || len(tokens) != 3 {
+		t.Fatalf("physical String query: %+v %v", tokens, err)
+	}
+	if tokens[0].Text != "\"header∕one.h\"" || tokens[0].RecordedValue != "\"header/one.h\"" ||
+		tokens[0].Line != 3 || source[tokens[0].Start:tokens[0].End] != tokens[0].Text {
+		t.Fatalf("physical/recorded operand identity: %+v", tokens[0])
+	}
+	again, err := InspectAssemblyCPPStringTokens(source, "original.s")
+	if err != nil || !reflect.DeepEqual(tokens, again) {
+		t.Fatalf("independent String query: %v", err)
+	}
+	tokens[0].Text = "forged"
+	third, err := InspectAssemblyCPPStringTokens(source, "original.s")
+	if err != nil || !reflect.DeepEqual(again, third) {
+		t.Fatal("query results share caller-mutable state")
+	}
+}
+
+func TestInspectAssemblyCPPStringTokensBoundsAndLexicalErrors(t *testing.T) {
+	for _, source := range []string{
+		strings.Repeat("\"x\"\n", 4097), "\"unterminated\n", strings.Repeat("x", (64<<20)+1),
+	} {
+		if tokens, err := InspectAssemblyCPPStringTokens(source, "source.s"); err == nil || tokens != nil {
+			t.Fatal("unbounded or malformed String source produced a query")
+		}
+	}
+	if tokens, err := InspectAssemblyCPPStringTokens("", ""); err == nil || tokens != nil {
+		t.Fatal("unnamed original source produced a query")
+	}
+	if tokens, err := InspectAssemblyCPPStringTokens("MOVQ $1, AX\n", "source.s"); err != nil || tokens == nil || len(tokens) != 0 {
+		t.Fatal("complete empty String set was not explicit")
+	}
+}
diff --git a/preprocess_inventory_test.go b/preprocess_inventory_test.go
new file mode 100644
index 000000000..bf3bcf9ce
--- /dev/null
+++ b/preprocess_inventory_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestInspectAssemblyCPPSourcePhysicalDefinitionIdentity(t *testing.T) {
+	source := "#define OBJECT (A)\n#define ZERO() x·h\n#define FUNCTION(A,B) A \\\n# include B \\\n\n#define SPACED (P)\n#define COMMENTED/*gap*/(P)\n"
+	got, err := InspectAssemblyCPPSource(source, "header.h", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.File != "header.h" || got.ByteLength != len(source) || !got.FinalNewline || len(got.Records) != 5 {
+		t.Fatalf("physical source inventory differs: %+v", got)
+	}
+	wantNames := []string{"OBJECT", "ZERO", "FUNCTION", "SPACED", "COMMENTED"}
+	for index, record := range got.Records {
+		macro := record.Definition
+		if record.Kind != "directive" || macro == nil || macro.Name != wantNames[index] ||
+			record.Text != source[record.Start:record.End] {
+			t.Fatalf("definition %d lost physical identity: %+v", index, record)
+		}
+		function := index == 1 || index == 2
+		if macro.Function != function || (macro.Parameters != nil) != function {
+			t.Fatalf("definition %s lost object/function adjacency", macro.Name)
+		}
+	}
+	if len(got.Records[1].Definition.Parameters) != 0 ||
+		!reflect.DeepEqual(got.Records[2].Definition.Parameters, []string{"A", "B"}) {
+		t.Fatal("zero-argument/function formals changed")
+	}
+	body := got.Records[1].Definition.Replacement
+	if len(body) != 1 || body[0].Text != "x·h" || body[0].RecordedValue != "x.h" {
+		t.Fatalf("raw and recorded token spellings collapsed: %+v", body)
+	}
+	if !strings.Contains(got.Records[2].Text, "# include B") {
+		t.Fatal("directive-generating replacement disappeared")
+	}
+}
+
+func TestInspectAssemblyCPPSourceCandidateOrderAndEOF(t *testing.T) {
+	source := "F\nMOVQ $1, AX\n#define F() RET\nF()\nF /*not invoked*/\nRET"
+	got, err := InspectAssemblyCPPSource(source, "original.s", []string{"F"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Records) != 4 || got.FinalNewline || got.EOF.Kind != "eof" || got.EOF.Start != len(source) {
+		t.Fatalf("candidate/EOF inventory changed: %+v", got)
+	}
+	for index, line := range []int{1, 3, 4, 5} {
+		if got.Records[index].Line != line || index != 0 && got.Records[index].Start <= got.Records[index-1].End-1 {
+			t.Fatal("physical invocation/definition order changed")
+		}
+	}
+	if got.Records[0].Kind != "candidate" || got.Records[0].Text != "F\n" ||
+		got.Records[3].Text != "F /*not invoked*/\n" {
+		t.Fatal("a potential invocation became an asserted active function call")
+	}
+}
+
+func TestInspectAssemblyCPPSourceBuildCommentsAndTokenBoundaries(t *testing.T) {
+	source := "//go:build amd64\n\nRET; //go:build ignored\n/ * A * /\n/ / B\nSHLQ $1<<2, AX\n"
+	got, err := InspectAssemblyCPPSource(source, "source.s", []string{"A", "B", "SHLQ"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got.Records) != 5 || got.Records[0].Tokens[0].Kind != "build_comment" ||
+		got.Records[1].Tokens[2].Kind != "build_comment" {
+		t.Fatalf("build-comment source role disappeared: %+v", got)
+	}
+	if got.Records[2].Tokens[0].Text != "/" || got.Records[2].Tokens[1].Text != "*" ||
+		got.Records[3].Tokens[0].Text != "/" || got.Records[3].Tokens[1].Text != "/" {
+		t.Fatal("separate comment-seam tokens were re-lexed")
+	}
+	shift := got.Records[4].Tokens[3]
+	if shift.Text != "<<" || shift.End-shift.Start != 2 {
+		t.Fatalf("combined Go tokenizer operator changed: %+v", shift)
+	}
+}
+
+func TestInspectAssemblyCPPSourceRawInactiveAndHeaderEOF(t *testing.T) {
+	for _, source := range []string{
+		"#ifdef NEVER\n#define MISSING() \\\n# include \"missing.h\" \\\n\nMISSING()\n#endif\n",
+		"#define EMPTY", "#ifdef BORROWED", "#include \"literal.h\"",
+		"#line 27 \"logical.h\"\n", "#unknown anything\n",
+	} {
+		t.Run(source, func(t *testing.T) {
+			got, err := InspectAssemblyCPPSource(source, "raw.h", []string{"MISSING"})
+			if err != nil || len(got.Records) == 0 {
+				t.Fatalf("raw inventory became execution/acceptance: %v", err)
+			}
+			for _, record := range got.Records {
+				if record.Text != source[record.Start:record.End] {
+					t.Fatal("physical header source was completed or rewritten")
+				}
+			}
+		})
+	}
+}
+
+func TestInspectAssemblyCPPSourceBoundsAndIndependentQueries(t *testing.T) {
+	source := "#define F(X) X\nMOVQ $123456789, AX\nF(17)\n"
+	first, err := InspectAssemblyCPPSource(source, "source.s", []string{"F"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	second, err := InspectAssemblyCPPSource(source, "source.s", nil)
+	if err != nil || len(first.Records) != 2 || len(second.Records) != 1 {
+		t.Fatalf("query name sets leaked or omitted calls: %v", err)
+	}
+	first.Records[0].Definition.Parameters[0] = "changed"
+	first.Records[0].Tokens[0].Text = "changed"
+	again, err := InspectAssemblyCPPSource(source, "source.s", nil)
+	if err != nil || !reflect.DeepEqual(again, second) {
+		t.Fatal("returned inventory aliases a subsequent query")
+	}
+	for _, names := range [][]string{{"F", "F"}, {""}, {"not-a-name"}} {
+		if _, err := InspectAssemblyCPPSource(source, "source.s", names); err == nil {
+			t.Fatal("invalid or duplicate query names accepted")
+		}
+	}
+	if _, err := InspectAssemblyCPPSource("#define X \"unterminated\n", "source.s", nil); err == nil {
+		t.Fatal("lexical error was hidden by query-only inventory")
+	}
+}
+
+func TestInspectAssemblyCPPSourcePhysicalOffsetsAndConcurrentQueries(t *testing.T) {
+	source := "\ufeff  #define F() x·h\r\n  F()\r\n//go:build amd64"
+	want, err := InspectAssemblyCPPSource(source, "source.s", []string{"F"})
+	if err != nil || len(want.Records) != 3 || want.Records[0].Start != 5 ||
+		want.Records[0].Definition.Replacement[0].RecordedValue != "x.h" {
+		t.Fatalf("BOM/CRLF/Unicode physical identity changed: %+v %v", want, err)
+	}
+	for _, record := range want.Records {
+		if record.Text != source[record.Start:record.End] {
+			t.Fatal("record byte offsets changed under Unicode/CRLF")
+		}
+		for _, token := range record.Tokens {
+			if token.Kind == "eof" {
+				continue
+			}
+			if token.Text != source[token.Start:token.End] {
+				t.Fatalf("token byte offsets changed: %+v", token)
+			}
+		}
+	}
+	var work sync.WaitGroup
+	for index := 0; index < 16; index++ {
+		work.Add(1)
+		go func() {
+			defer work.Done()
+			got, err := InspectAssemblyCPPSource(source, "source.s", []string{"F"})
+			if err != nil || !reflect.DeepEqual(got, want) {
+				t.Errorf("independent query changed under concurrency: %v", err)
+			}
+		}()
+	}
+	work.Wait()
+}
diff --git a/preprocess_macro_controls_test.go b/preprocess_macro_controls_test.go
new file mode 100644
index 000000000..391a6bc6a
--- /dev/null
+++ b/preprocess_macro_controls_test.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+type ppMacroControlFixture struct {
+	name, prefix, replacement, argument, suffix string
+}
+
+func ppMacroControlFixtures() []ppMacroControlFixture {
+	const data = "DATA ·value(SB)/4,$42\n"
+	return []ppMacroControlFixture{
+		{"define", "", "#define VALUE P\n", "42", "DATA ·value(SB)/4,$VALUE\n"},
+		{"undef", "#define LEAK 1\n", "#undef P\n", "LEAK", "#ifndef LEAK\n" + data + "#endif\n"},
+		{"include", "", "#include P\n", `"choice.h"`, "DATA ·value(SB)/4,$VALUE\n"},
+		{"line", "", "#line P \"logical source.s\"\n", "337", data},
+		{"ifdef", "#define PRESENT 1\n", "#ifdef P\n" + data + "#else\nDATA ·value(SB)/4,$13\n#endif\n", "PRESENT", ""},
+		{"ifndef", "", "#ifndef P\n" + data + "#else\nDATA ·value(SB)/4,$13\n#endif\n", "ABSENT", ""},
+		{"open-parent-condition", "#define PRESENT 1\n", "#ifdef P\n", "PRESENT", data + "#else\nDATA ·value(SB)/4,$13\n#endif\n"},
+		{"inactive-invocation", "", "#else\n", "", data + "#endif\n"},
+	}
+}
+
+func ppMacroControlSource(fixture ppMacroControlFixture, style string) string {
+	body, definition, invocation := fixture.replacement, "APPLY", "APPLY"
+	if style == "function" {
+		definition += "(P)"
+		invocation += "(" + fixture.argument + ")"
+	} else {
+		body = strings.ReplaceAll(body, "P", fixture.argument)
+	}
+	if style == "alias" {
+		invocation = "INVOKE"
+	}
+	var source strings.Builder
+	source.WriteString(fixture.prefix)
+	source.WriteString("#define " + definition + " \\\n")
+	for _, line := range strings.Split(strings.TrimSuffix(body, "\n"), "\n") {
+		source.WriteString(line + " \\\n")
+	}
+	source.WriteByte('\n')
+	if style == "alias" {
+		source.WriteString("#define INVOKE APPLY\n")
+	}
+	source.WriteString("TEXT ·Probe(SB),$0-0\nRET\n")
+	if fixture.name == "inactive-invocation" {
+		source.WriteString("#ifdef ABSENT\n")
+	}
+	source.WriteString(invocation + "\n")
+	source.WriteString(fixture.suffix)
+	source.WriteString("GLOBL ·value(SB),8,$4\n")
+	return source.String()
+}
+
+func TestPreprocessAssemblyGeneratedControlGoOracle(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			for _, fixture := range ppMacroControlFixtures() {
+				t.Run(fixture.name, func(t *testing.T) {
+					for _, style := range []string{"object", "alias", "function"} {
+						t.Run(style, func(t *testing.T) {
+							source := ppMacroControlSource(fixture, style)
+							headers := map[string]string{"choice.h": "#define VALUE 42\n"}
+							listing := ppMacroControlGoObject(t, target, source, headers, "original")
+							if !strings.Contains(string(listing), "2a 00 00 00") {
+								t.Fatalf("actual Go did not select the expected marker: %s", listing)
+							}
+							t.Logf("original Go accepted %s %s/%s source_sha=%x listing_sha=%x",
+								target, fixture.name, style, sha256.Sum256([]byte(source)), sha256.Sum256(listing))
+							var includes []string
+							expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+								FileName: "entry.s",
+								ReadInclude: func(parent, name string) (string, []byte, error) {
+									includes = append(includes, parent+":"+name)
+									body, ok := headers[name]
+									if !ok {
+										return "", nil, fmt.Errorf("missing exact header %s", name)
+									}
+									return name, []byte(body), nil
+								},
+							})
+							if err != nil {
+								t.Fatalf("Go-accepted generated control failed preprocessing: %v", err)
+							}
+							if fixture.name == "include" && strings.Join(includes, ",") != "entry.s:choice.h" {
+								t.Fatalf("generated include changed its physical invocation origin: %v", includes)
+							}
+							listing = ppMacroControlGoObject(t, target, expanded, nil, "expanded")
+							if !strings.Contains(string(listing), "2a 00 00 00") {
+								t.Fatalf("expanded Go marker differs from original: %s", listing)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func ppMacroControlGoObject(t *testing.T, target, source string, headers map[string]string, stage string) []byte {
+	t.Helper()
+	directory := t.TempDir()
+	for name, body := range headers {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	file := filepath.Join(directory, "entry.s")
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	parts := strings.Split(target, "/")
+	object := filepath.Join(directory, stage+".o")
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-S", "-p", "macrooracle", "-I", directory,
+		"-o", object, file)
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS="+parts[0], "GOARCH="+parts[1], "GOENV=off", "GOTOOLCHAIN=local")
+	listing, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("%s original-source Go object %s: %v\n%s\nsource:\n%s", stage, target, err, listing, source)
+	}
+	objectBytes, err := os.ReadFile(object)
+	if err != nil || len(objectBytes) == 0 {
+		t.Fatalf("%s Go object %s missing or empty: %v", stage, target, err)
+	}
+	t.Logf("CPP_GO_OBJECT_RECEIPT target=%s stage=%s source_sha=%x object_sha=%x listing_sha=%x",
+		target, stage, sha256.Sum256([]byte(source)), sha256.Sum256(objectBytes), sha256.Sum256(listing))
+	return listing
+}
+
+func TestPreprocessAssemblyTokenBoundaries(t *testing.T) {
+	for _, source := range []string{
+		"MOVQ $1 << 2, AX\n",
+		"MOVQ $1 < < 2, AX\n",
+		"MOVD R1 @ > 2, R0\n",
+		"MOVD R1 - > 2, R0\n",
+		"DATA ·value(SB)/8,$0 .5\n",
+		"DATA ·value(SB)/8,$1 . 0\n",
+		"TEXT ·Probe(SB),$0-0\nloop: MOVQ AX, BX; RET\n",
+		"MOVW R0, R1:R2\n",
+		"DATA ·value(SB)/8,$\"a // b /* c */\"\n",
+	} {
+		expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := ppMacroControlTokens(t, source)
+		normalized := ppMacroControlTokens(t, expanded)
+		if strings.Join(original, "\n") != strings.Join(normalized, "\n") {
+			t.Fatalf("normalization manufactured or removed lexical tokens:\n%q\n%q\n%v\n%v", source, expanded, original, normalized)
+		}
+	}
+}
+
+func ppMacroControlTokens(t *testing.T, source string) []string {
+	t.Helper()
+	reader := newPPGoReader("entry.s", source)
+	var tokens []string
+	for {
+		token, err := reader.next()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if token.kind == scanner.EOF {
+			return tokens
+		}
+		if token.kind != '\n' {
+			tokens = append(tokens, fmt.Sprintf("%d:%s", token.kind, token.value))
+		}
+	}
+}
+
+func TestPreprocessAssemblyGeneratedIncludeRetainsErrorChain(t *testing.T) {
+	witness := fmt.Errorf("exact include error: %w", os.ErrNotExist)
+	const source = "#define INCLUDE #include \"missing.h\" \\\n\nINCLUDE\n"
+	_, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+		FileName: "original.s",
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			if parent != "original.s" || name != "missing.h" {
+				t.Fatalf("unbound generated include origin: %q %q", parent, name)
+			}
+			return "", nil, witness
+		},
+	})
+	if !errors.Is(err, os.ErrNotExist) || !strings.Contains(err.Error(), "original.s:3") {
+		t.Fatalf("generated include lost its original error or physical invocation: %v", err)
+	}
+}
+
+func TestPreprocessAssemblyGeneratedControlLLVMObjectsFiveArchitectures(t *testing.T) {
+	llc, optimizer := findLLVM22Tool("llc"), findLLVM22Tool("opt")
+	if llc == "" || optimizer == "" {
+		t.Fatal("LLVM 22 llc and opt are required")
+	}
+	fixture := ppMacroControlFixture{
+		name: "complete-controls", prefix: "#define LEAK 1\n",
+		replacement: "#include \"choice.h\"\n#undef LEAK\n#ifndef LEAK\n" +
+			"#define VALUE P\n#else\n#define VALUE 13\n#endif\n#line 337 \"logical source.s\"\n",
+		argument: "42", suffix: "DATA ·value(SB)/4,$VALUE\n",
+	}
+	headers := map[string]string{"choice.h": "#ifndef CHOSEN\n#define CHOSEN 1\n#endif\n"}
+	source := ppMacroControlSource(fixture, "function")
+	for _, target := range []struct {
+		arch                 Arch
+		goos, goarch, triple string
+	}{
+		{ArchAMD64, "linux", "386", "i386-unknown-linux-gnu"},
+		{ArchAMD64, "linux", "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchARM, "linux", "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "linux", "arm64", "aarch64-unknown-linux-gnu"},
+		{ArchWASM, "js", "wasm", "wasm32-unknown-unknown"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			platform := target.goos + "/" + target.goarch
+			original := ppMacroControlGoObject(t, platform, source, headers, "original")
+			if !strings.Contains(string(original), "2a 00 00 00") {
+				t.Fatalf("original source marker differs: %s", original)
+			}
+			expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+				FileName: "entry.s",
+				ReadInclude: func(parent, name string) (string, []byte, error) {
+					body, ok := headers[name]
+					if !ok || parent != "entry.s" {
+						return "", nil, fmt.Errorf("missing exact generated include %s from %s", name, parent)
+					}
+					return name, []byte(body), nil
+				},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized := ppMacroControlGoObject(t, platform, expanded, nil, "expanded")
+			if !strings.Contains(string(normalized), "2a 00 00 00") {
+				t.Fatalf("normalized source marker differs: %s", normalized)
+			}
+			parsed, err := Parse(target.arch, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(parsed, Options{
+				Goarch: target.goarch, TargetTriple: target.triple,
+				ResolveSym: testResolveSym("macrooracle"),
+				Sigs:       map[string]FuncSig{"macrooracle.Probe": {Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			if target.goarch == "wasm" && strings.Contains(ir, "blockaddress") {
+				t.Fatal("macro preprocessing introduced a native code address into wasm")
+			}
+			directory := t.TempDir()
+			ll := filepath.Join(directory, "generated.ll")
+			optimized := filepath.Join(directory, "generated-o2.ll")
+			object := filepath.Join(directory, "generated.o")
+			if err := os.WriteFile(ll, []byte(ir), 0600); err != nil {
+				t.Fatal(err)
+			}
+			for _, command := range []struct {
+				name string
+				args []string
+			}{
+				{optimizer, []string{"-S", "-passes=default<O2>", ll, "-o", optimized}},
+				{llc, []string{"-mtriple=" + target.triple, "-filetype=obj", optimized, "-o", object}},
+			} {
+				ctx, cancel := runtimeOracleStageContext(t)
+				process := exec.CommandContext(ctx, command.name, command.args...)
+				output, err := runtimeOracleCombinedOutput(ctx, process)
+				cancel()
+				if err != nil {
+					t.Fatalf("LLVM 22 generated-control pipeline: %v\n%s", err, output)
+				}
+			}
+			info, err := os.Stat(object)
+			if err != nil || info.Size() == 0 {
+				t.Fatalf("LLVM 22 object absent or empty: %v", err)
+			}
+			t.Logf("original Go, normalized Go, Parse/Translate/O2/LLVM22 object: %s source_sha=%x",
+				platform, sha256.Sum256([]byte(source)))
+		})
+	}
+}
diff --git a/preprocess_observation.go b/preprocess_observation.go
new file mode 100644
index 000000000..322aca9ab
--- /dev/null
+++ b/preprocess_observation.go
@@ -0,0 +1,265 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+)
+
+// AssemblyCPPObservation describes one actual preprocessing execution. It is
+// query-only: it supplies neither source authentication nor assembler, ABI or
+// LLVM compilation evidence. Independently recapture the complete inputs before
+// using it in a corpus proof.
+type AssemblyCPPObservation struct {
+	Output  string
+	Defines []string
+	Sources []AssemblyCPPObservedSource
+	Events  []AssemblyCPPEvent
+}
+
+type AssemblyCPPObservedSource struct {
+	File, SHA256 string
+	Bytes        int
+}
+
+type AssemblyCPPObservedPosition struct {
+	// Physical reader/expansion origin, not a logical #line diagnostic name.
+	File string
+	Line int
+}
+
+type AssemblyCPPObservedToken struct {
+	// Kind and RecordedValue are the shared engine's token projection, not
+	// the selected Go SDK's private ScanToken numbers or source acceptance.
+	Kind                rune
+	Text, RecordedValue string
+	Position            AssemblyCPPObservedPosition
+}
+
+// AssemblyCPPOutputToken is an emitted token's physical reader/expansion
+// origin. It is not a logical #line position or an assembler acceptance proof.
+// Expansion and Include reference the accompanying observation's events.
+type AssemblyCPPOutputToken struct {
+	Kind               rune
+	Text               string
+	Start, End         int // Byte span in the exact emitted Output, excluding spacing.
+	Position           AssemblyCPPObservedPosition
+	Expansion, Include int
+}
+
+// Events are ordered by execution, not physical source traversal. Expansion is
+// the invocation event which supplied a generated token; zero denotes physical
+// source. Definition refers to the actual macro-definition event, including -D.
+// Include refers to the active include which opened the physical reader.
+// Invoked distinguishes macro expansion from a bare function-macro reference;
+// Executed distinguishes a dispatched control/reference from a skipped control.
+// Raw skipped-control payloads remain in the separate physical source inventory.
+type AssemblyCPPEvent struct {
+	Ordinal, Expansion, Definition, Include int
+	Kind, Name, Directive                   string
+	Position                                AssemblyCPPObservedPosition
+	EnabledBefore, EnabledAfter             bool
+	DepthBefore, DepthAfter                 int
+	Function                                bool
+	Executed, Invoked                       bool
+	Parameters                              []string
+	Tokens                                  []AssemblyCPPObservedToken
+	Included                                string
+}
+
+// ObserveAssemblyCPP executes exactly the strict preprocessing engine on full
+// source bytes. Failure returns no successful observation. The result retains
+// active includes, inactive invocations and control transitions, not an inferred
+// all-profile branch denominator or acceptance of isolated header fragments.
+func ObserveAssemblyCPP(src string, opt AssemblyPreprocessOptions) (AssemblyCPPObservation, error) {
+	observation, _, err := observeAssemblyCPP(src, opt, false)
+	return observation, err
+}
+
+// ObserveAssemblyCPPOutput additionally retains the complete emitted token
+// tape. This opt-in query leaves ordinary CPP observations and their memory
+// costs unchanged. Consumers must authenticate sources and close operand/ABI
+// obligations themselves; an expansion position supplies no machine effect.
+func ObserveAssemblyCPPOutput(src string, opt AssemblyPreprocessOptions) (AssemblyCPPObservation, []AssemblyCPPOutputToken, error) {
+	return observeAssemblyCPP(src, opt, true)
+}
+
+func observeAssemblyCPP(src string, opt AssemblyPreprocessOptions, retainOutput bool) (AssemblyCPPObservation, []AssemblyCPPOutputToken, error) {
+	// Capture the actual -D inputs before a resolver can mutate its caller's
+	// slice. The same immutable copy supplies the execution and its record.
+	opt.Defines = append([]string(nil), opt.Defines...)
+	observer := newPPGoObservation()
+	observer.retainOutput = retainOutput
+	output, err := preprocessGoAssemblyObserved(src, opt, observer)
+	if err != nil {
+		return AssemblyCPPObservation{}, nil, err
+	}
+	observer.result.Output = output
+	observer.result.Defines = opt.Defines
+	return observer.result, observer.outputTokens, nil
+}
+
+// These observation bounds do not enlarge any existing source, include,
+// recursion, output or corpus budget. The byte quota bounds retained token
+// strings and shared filename storage, not a serialized JSON encoding.
+// Exhaustion is an error, never truncation.
+const (
+	ppGoObservationEvents = 100000
+	ppGoObservationTokens = 1000000
+	ppGoObservationBytes  = 16 << 20
+	ppGoObservationFiles  = 4096
+)
+
+type ppGoObservation struct {
+	result                     AssemblyCPPObservation
+	sources                    map[string]AssemblyCPPObservedSource
+	paths                      map[string]string
+	active, tokens, tokenBytes int
+	eventLimit                 int
+	positions                  *sdkCPPPositionObservation
+	retainOutput               bool
+	outputTokens               []AssemblyCPPOutputToken
+}
+
+func (observer *ppGoObservation) emitOutput(token ppGoToken, start, end int) error {
+	if !observer.retainOutput {
+		return nil
+	}
+	file, err := observer.retainPath(token.file)
+	if err != nil {
+		return err
+	}
+	if err := observer.chargeToken(len(token.text)); err != nil {
+		return err
+	}
+	observer.outputTokens = append(observer.outputTokens, AssemblyCPPOutputToken{
+		Kind: token.kind, Text: token.text, Start: start, End: end,
+		Position:  AssemblyCPPObservedPosition{File: file, Line: token.line},
+		Expansion: token.expansion, Include: token.includeEvent,
+	})
+	return nil
+}
+
+func newPPGoObservation() *ppGoObservation {
+	return &ppGoObservation{
+		sources: make(map[string]AssemblyCPPObservedSource), active: -1,
+		paths:      make(map[string]string),
+		eventLimit: ppGoObservationEvents,
+	}
+}
+
+func (observer *ppGoObservation) source(file, source string) error {
+	file, err := observer.retainPath(file)
+	if err != nil {
+		return err
+	}
+	identity := AssemblyCPPObservedSource{
+		File: file, Bytes: len(source), SHA256: fmt.Sprintf("%x", sha256.Sum256([]byte(source))),
+	}
+	if previous, exists := observer.sources[file]; exists {
+		if previous != identity {
+			return fmt.Errorf("CPP observation source %q changed during execution", file)
+		}
+		return nil
+	}
+	if len(observer.sources) >= ppGoObservationFiles {
+		return fmt.Errorf("CPP observation exceeds the explicit %d-source bound", ppGoObservationFiles)
+	}
+	observer.sources[file] = identity
+	observer.result.Sources = append(observer.result.Sources, identity)
+	return nil
+}
+
+func (input *ppGoInput) beginObservation(kind string, origin ppGoToken) (int, error) {
+	observer := input.observer
+	if observer == nil {
+		return -1, nil
+	}
+	if len(observer.result.Events) >= observer.eventLimit {
+		return -1, input.errorf("CPP observation exceeds the explicit %d-event bound", observer.eventLimit)
+	}
+	if observer.active != -1 {
+		return -1, input.errorf("CPP observation has overlapping raw-token captures")
+	}
+	index := len(observer.result.Events)
+	file, err := observer.retainPath(origin.file)
+	if err != nil {
+		return -1, err
+	}
+	observer.result.Events = append(observer.result.Events, AssemblyCPPEvent{
+		Ordinal: index + 1, Kind: kind, Expansion: origin.expansion, Include: origin.includeEvent,
+		Position:      AssemblyCPPObservedPosition{File: file, Line: origin.line},
+		EnabledBefore: input.enabled(), DepthBefore: len(input.conditions),
+	})
+	observer.active = index
+	return index, nil
+}
+
+func (input *ppGoInput) finishObservation(index int) {
+	if index < 0 {
+		return
+	}
+	event := &input.observer.result.Events[index]
+	event.EnabledAfter, event.DepthAfter = input.enabled(), len(input.conditions)
+	input.observer.active = -1
+}
+
+func (input *ppGoInput) observedEvent() *AssemblyCPPEvent {
+	if input.observer == nil || input.observer.active < 0 {
+		return nil
+	}
+	return &input.observer.result.Events[input.observer.active]
+}
+
+func (observer *ppGoObservation) capture(token ppGoToken) error {
+	if observer.active < 0 {
+		return nil
+	}
+	file, err := observer.retainPath(token.file)
+	if err != nil {
+		return err
+	}
+	if err := observer.chargeToken(len(token.text) + len(token.value)); err != nil {
+		return err
+	}
+	event := &observer.result.Events[observer.active]
+	event.Tokens = append(event.Tokens, AssemblyCPPObservedToken{
+		Kind: token.kind, Text: token.text, RecordedValue: token.value,
+		Position: AssemblyCPPObservedPosition{File: file, Line: token.line},
+	})
+	return nil
+}
+
+func (observer *ppGoObservation) chargeToken(bytes int) error {
+	if observer.tokens >= ppGoObservationTokens || bytes > ppGoObservationBytes-observer.tokenBytes {
+		return fmt.Errorf("CPP observation exceeds its explicit token/byte bound")
+	}
+	observer.tokens++
+	observer.tokenBytes += bytes
+	return nil
+}
+
+// Reader and macro tokens share filenames. Keep one canonical string for each
+// exact name and charge its storage once, including logical SDK #line names.
+// This pool belongs only to the current observation and grants no source role.
+func (observer *ppGoObservation) retainPath(file string) (string, error) {
+	if previous, exists := observer.paths[file]; exists {
+		return previous, nil
+	}
+	if len(file) > ppGoObservationBytes-observer.tokenBytes {
+		return "", fmt.Errorf("CPP observation exceeds its explicit token/byte bound")
+	}
+	observer.tokenBytes += len(file)
+	observer.paths[file] = file
+	return file, nil
+}
+
+func ppGoCopyParameters(parameters []string) []string {
+	if parameters == nil {
+		return nil
+	}
+	result := make([]string, len(parameters))
+	for index, parameter := range parameters {
+		result[index] = parameter
+	}
+	return result
+}
diff --git a/preprocess_observation_path_test.go b/preprocess_observation_path_test.go
new file mode 100644
index 000000000..7ff56aeed
--- /dev/null
+++ b/preprocess_observation_path_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+	"unsafe"
+)
+
+func TestCPPObservationSourcePathBudget(t *testing.T) {
+	source := "TEXT ·Entry(SB),4,$0-0\n" + strings.Repeat("MOVQ $1, AX\n", 40000) + "RET\n"
+	var first string
+	for _, file := range []string{"entry.s", "/" + strings.Repeat("selected-source-directory/", 8) + "entry.s"} {
+		observed, tokens, err := ObserveAssemblyCPPOutput(source, AssemblyPreprocessOptions{FileName: file})
+		if err != nil {
+			t.Fatalf("unchanged bounded source with %d-byte origin: %v", len(file), err)
+		}
+		if first == "" {
+			first = observed.Output
+		} else if observed.Output != first {
+			t.Fatal("changing only the source path changed expanded assembly")
+		}
+		for _, token := range tokens {
+			if token.Position.File != file {
+				t.Fatal("physical source identity was shortened or substituted")
+			}
+		}
+	}
+}
+
+func TestSDKCPPPositionSourcePathBudget(t *testing.T) {
+	file := "/" + strings.Repeat("selected-source-directory/", 8) + "entry.s"
+	source := strings.Repeat("MOVQ $1, AX\n", 15000) + "RET\n"
+	observed, positions, err := observeSDKAssemblyCPP(source, AssemblyPreprocessOptions{FileName: file})
+	if err != nil {
+		t.Fatal("bounded source position tape depends on source path length:", err)
+	}
+	if len(positions.Tokens) == 0 || !strings.Contains(positions.Mapped, file) {
+		t.Fatal("mapped source lost its actual source origin")
+	}
+	for _, token := range positions.Tokens {
+		if token.Position.File != file || token.Position.Base.File != file || token.Position.FinalBase.File != file {
+			t.Fatal("physical or logical filename was shortened or substituted")
+		}
+	}
+	replayed, err := PreprocessAssemblySource(positions.Mapped, AssemblyPreprocessOptions{FileName: file})
+	if err != nil || replayed != observed.Output {
+		t.Fatalf("mapped output no longer replays exactly: %v", err)
+	}
+}
+
+func TestCPPObservationDistinctPathBudget(t *testing.T) {
+	var source strings.Builder
+	for index := 0; index < 34; index++ {
+		fmt.Fprintf(&source, "#include \"header%d.h\"\n", index)
+	}
+	observed, tokens, err := ObserveAssemblyCPPOutput(source.String(), AssemblyPreprocessOptions{
+		FileName: "entry.s",
+		ReadInclude: func(_, name string) (string, []byte, error) {
+			return strings.Repeat("x", 512<<10) + name, []byte("RET\n"), nil
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "bound") || len(tokens) != 0 || !reflect.DeepEqual(observed, AssemblyCPPObservation{}) {
+		t.Fatal("distinct retained filenames escaped the shared byte budget:", err)
+	}
+}
+
+func TestCPPObservationRepeatedIncludePathStorage(t *testing.T) {
+	file := strings.Repeat("selected-source-directory/", 64) + "header.h"
+	observed, tokens, err := ObserveAssemblyCPPOutput(strings.Repeat("#include \"header.h\"\n", 3), AssemblyPreprocessOptions{
+		FileName: "entry.s",
+		ReadInclude: func(_, _ string) (string, []byte, error) {
+			return strings.Clone(file), []byte("RET\n"), nil
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var canonical *byte
+	for _, source := range observed.Sources {
+		if source.File == file {
+			canonical = unsafe.StringData(source.File)
+		}
+	}
+	if canonical == nil {
+		t.Fatal("included source identity is missing")
+	}
+	includes := 0
+	for _, event := range observed.Events {
+		if event.Included == file {
+			includes++
+			if unsafe.StringData(event.Included) != canonical {
+				t.Fatal("repeated include retained an uncharged filename allocation")
+			}
+		}
+	}
+	if includes != 3 {
+		t.Fatalf("included source events = %d, want 3", includes)
+	}
+	for _, token := range tokens {
+		if token.Position.File == file && unsafe.StringData(token.Position.File) != canonical {
+			t.Fatal("output position retained a second filename allocation")
+		}
+	}
+}
diff --git a/preprocess_observation_test.go b/preprocess_observation_test.go
new file mode 100644
index 000000000..2e543ebd8
--- /dev/null
+++ b/preprocess_observation_test.go
@@ -0,0 +1,290 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+func TestPreprocessAssemblyCPPObservationGoObjects(t *testing.T) {
+	for _, target := range []string{"linux/386", "linux/amd64", "linux/arm", "linux/arm64", "js/wasm"} {
+		t.Run(target, func(t *testing.T) {
+			for _, fixture := range ppMacroControlFixtures() {
+				t.Run(fixture.name, func(t *testing.T) {
+					for _, style := range []string{"object", "alias", "function"} {
+						t.Run(style, func(t *testing.T) {
+							source := ppMacroControlSource(fixture, style)
+							headers := map[string]string{"choice.h": "#define VALUE 42\n"}
+							original := ppMacroControlGoObject(t, target, source, headers, "observation-original")
+							if !strings.Contains(string(original), "2a 00 00 00") {
+								t.Fatal("actual original Go object lacks its marker")
+							}
+							options := AssemblyPreprocessOptions{
+								FileName: "entry.s",
+								ReadInclude: func(parent, name string) (string, []byte, error) {
+									body, ok := headers[name]
+									if !ok || parent != "entry.s" {
+										return "", nil, fmt.Errorf("unbound include %s:%s", parent, name)
+									}
+									return name, []byte(body), nil
+								},
+							}
+							plain, err := PreprocessAssemblySource(source, options)
+							if err != nil {
+								t.Fatal(err)
+							}
+							observed, err := ObserveAssemblyCPP(source, options)
+							if err != nil {
+								t.Fatal(err)
+							}
+							if observed.Output != plain {
+								t.Fatalf("observation changed strict CPP output: %q != %q", observed.Output, plain)
+							}
+							ppCheckObservation(t, observed)
+							if len(observed.Events) == 0 || len(observed.Sources) == 0 {
+								t.Fatal("accepted source has no actual execution/source observation")
+							}
+							ppCheckObservedSource(t, observed, "entry.s", source)
+							if fixture.name == "include" {
+								ppCheckObservedSource(t, observed, "choice.h", headers["choice.h"])
+							}
+							normalized := ppMacroControlGoObject(t, target, observed.Output, nil, "observation-normalized")
+							if !strings.Contains(string(normalized), "2a 00 00 00") {
+								t.Fatal("observed CPP changed the actual Go object's marker")
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationTransitions(t *testing.T) {
+	const source = "#define F(x) \\\n#define VALUE x \\\n\n#ifdef ABSENT\nF(13)\n#define DISABLED 1\n#include \"missing.h\"\n#else\nF(42)\n#endif\nDATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+	observed, err := ObserveAssemblyCPP(source, AssemblyPreprocessOptions{FileName: "entry.s"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ppCheckObservation(t, observed)
+	var inactiveInvocation, activeInvocation, generatedDefinition, skippedInclude bool
+	for _, event := range observed.Events {
+		if event.Kind == "invoke" && event.Name == "F" {
+			inactiveInvocation = inactiveInvocation || !event.EnabledBefore
+			activeInvocation = activeInvocation || event.EnabledBefore
+			if !event.Function || event.Definition == 0 {
+				t.Fatalf("lost actual function-macro definition: %+v", event)
+			}
+		}
+		if event.Kind == "control" && event.Directive == "define" && event.Name == "VALUE" {
+			generatedDefinition = generatedDefinition || event.Expansion != 0
+		}
+		if event.Kind == "control" && event.Directive == "include" && !event.EnabledBefore {
+			skippedInclude = true
+			if event.Included != "" {
+				t.Fatal("inactive include invented actual consumption")
+			}
+		}
+	}
+	if !inactiveInvocation || !activeInvocation || !generatedDefinition || !skippedInclude {
+		t.Fatalf("incomplete actual execution transitions: %+v", observed.Events)
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationPredefines(t *testing.T) {
+	defines := []string{"VALUE=13", "VALUE=42"}
+	const source = "DATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+	observed, err := ObserveAssemblyCPP(source, AssemblyPreprocessOptions{FileName: "entry.s", Defines: defines})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ppCheckObservation(t, observed)
+	if !reflect.DeepEqual(observed.Defines, defines) || len(observed.Events) != 3 ||
+		observed.Events[0].Kind != "predefine" || observed.Events[1].Kind != "predefine" ||
+		observed.Events[2].Definition != 2 {
+		t.Fatalf("predefined overwrite/actual macro binding lost: %+v", observed)
+	}
+	defines[0] = "VALUE=99"
+	if observed.Defines[0] != "VALUE=13" {
+		t.Fatal("observation borrowed mutable caller options")
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationIncludes(t *testing.T) {
+	const source = "#include \"guard.h\"\nTEXT ·Probe(SB),$0-0\nRET\n"
+	const header = "#ifndef GUARD\n#define GUARD 1\n#include \"guard.h\"\n#endif\n"
+	options := AssemblyPreprocessOptions{FileName: "entry.s", ReadInclude: func(parent, name string) (string, []byte, error) {
+		if name != "guard.h" || parent != "entry.s" && parent != "guard.h" {
+			return "", nil, fmt.Errorf("unbound include")
+		}
+		return "guard.h", []byte(header), nil
+	}}
+	observed, err := ObserveAssemblyCPP(source, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	plain, err := PreprocessAssemblySource(source, options)
+	if err != nil || plain != observed.Output || len(observed.Sources) != 2 {
+		t.Fatalf("guarded include cycle changed: %+v / %v", observed, err)
+	}
+	ppCheckObservedSource(t, observed, "guard.h", header)
+	var active int
+	for _, event := range observed.Events {
+		if event.Directive == "include" && event.EnabledBefore {
+			active++
+			if event.Included != "guard.h" {
+				t.Fatal("actual include identity missing")
+			}
+		}
+	}
+	if active != 2 {
+		t.Fatalf("lost actual repeated include use: %d", active)
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationFailureIdentity(t *testing.T) {
+	for _, source := range []string{
+		"#define RET(x) x\nTEXT ·Probe(SB),$0-0\nRET\n",
+		"#define F(x) x\n#ifdef ABSENT\nF +\n#endif\nTEXT ·Probe(SB),$0-0\nRET\n",
+		"#include \"missing.h\"\n",
+		"TEXT ·Probe(SB),$0-0\nRET",
+	} {
+		t.Run(fmt.Sprintf("%x", sha256.Sum256([]byte(source))), func(t *testing.T) {
+			options := AssemblyPreprocessOptions{FileName: "entry.s"}
+			_, plainErr := PreprocessAssemblySource(source, options)
+			observed, observedErr := ObserveAssemblyCPP(source, options)
+			if plainErr == nil {
+				// Some parser failures remain invalid normalized machine source;
+				// the query must still return exactly the normal engine's output.
+				plain, err := PreprocessAssemblySource(source, options)
+				if err != nil || observedErr != nil || observed.Output != plain {
+					t.Fatalf("observation changed successful CPP: %v / %v", err, observedErr)
+				}
+				return
+			}
+			if observedErr == nil || observedErr.Error() != plainErr.Error() ||
+				!reflect.DeepEqual(observed, AssemblyCPPObservation{}) {
+				t.Fatalf("observation changed failure or returned a positive trace: %v / %v / %+v", plainErr, observedErr, observed)
+			}
+		})
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationCachedLookahead(t *testing.T) {
+	const source = "#define F(x) x\n#ifdef ABSENT\nF\n\n#endif\nTEXT ·Probe(SB),$0-0\nRET\n"
+	original := ppSemanticGoObject(t, "observation-original-lookahead", source, nil, nil)
+	if !original.accepted {
+		t.Fatalf("original Go did not accept the cached-newline control: %s", original.output)
+	}
+	observed, err := ObserveAssemblyCPP(source, AssemblyPreprocessOptions{FileName: "entry.s"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ppCheckObservation(t, observed)
+	var reference int
+	var peek bool
+	for _, event := range observed.Events {
+		if event.Kind == "invoke" && event.Name == "F" {
+			reference = event.Ordinal
+			if event.Invoked || event.EnabledBefore || !event.Function {
+				t.Fatalf("bare inactive function macro was turned into an invocation: %+v", event)
+			}
+		}
+		if event.Kind == "peek" {
+			peek = true
+			if reference == 0 || event.Expansion != reference || len(event.Tokens) != 1 ||
+				event.Tokens[0].Kind != '\n' || event.Tokens[0].Text != "#" {
+				t.Fatalf("cached token's dispatch/text/lineage changed: %+v", event)
+			}
+		}
+	}
+	if !peek {
+		t.Fatal("cached token consumption is absent from the execution trace")
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationCapturesConsumedDefines(t *testing.T) {
+	defines := []string{"VALUE=42"}
+	options := AssemblyPreprocessOptions{
+		FileName: "entry.s", Defines: defines,
+		ReadInclude: func(parent, name string) (string, []byte, error) {
+			defines[0] = "VALUE=99"
+			return "header.h", []byte("\n"), nil
+		},
+	}
+	const source = "#include \"header.h\"\nDATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+	observed, err := ObserveAssemblyCPP(source, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(observed.Defines, []string{"VALUE=42"}) || !strings.Contains(observed.Output, "$42") {
+		t.Fatalf("trace retained caller mutation rather than consumed -D input: %+v", observed)
+	}
+}
+
+func TestPreprocessAssemblyCPPObservationBoundsAndChangedSource(t *testing.T) {
+	t.Run("changed-include", func(t *testing.T) {
+		calls := 0
+		const source = "#include \"header.h\"\n#include \"header.h\"\n"
+		observed, err := ObserveAssemblyCPP(source, AssemblyPreprocessOptions{
+			FileName: "entry.s", ReadInclude: func(parent, name string) (string, []byte, error) {
+				calls++
+				return "header.h", []byte(fmt.Sprintf("// version %d\n", calls)), nil
+			},
+		})
+		if err == nil || !strings.Contains(err.Error(), "changed during execution") ||
+			!reflect.DeepEqual(observed, AssemblyCPPObservation{}) {
+			t.Fatalf("changed source received a successful observation: %v / %+v", err, observed)
+		}
+	})
+	t.Run("events", func(t *testing.T) {
+		observer := newPPGoObservation()
+		observer.eventLimit = 2
+		output, err := preprocessGoAssemblyObserved("#define X 1\nX\nX\n", AssemblyPreprocessOptions{}, observer)
+		if err == nil || !strings.Contains(err.Error(), "2-event bound") || output != "" || len(observer.result.Events) != 2 {
+			t.Fatalf("event exhaustion was truncated or accepted: output=%q err=%v", output, err)
+		}
+	})
+	for _, bound := range []string{"tokens", "bytes"} {
+		t.Run(bound, func(t *testing.T) {
+			observer := newPPGoObservation()
+			observer.result.Events = []AssemblyCPPEvent{{Ordinal: 1}}
+			observer.active = 0
+			if bound == "tokens" {
+				observer.tokens = ppGoObservationTokens
+			} else {
+				observer.tokenBytes = ppGoObservationBytes
+			}
+			if err := observer.capture(ppGoToken{kind: scanner.Ident, text: "X", value: "X"}); err == nil ||
+				len(observer.result.Events[0].Tokens) != 0 {
+				t.Fatal("exhausted capture silently appended or accepted a token")
+			}
+		})
+	}
+}
+
+func ppCheckObservation(t *testing.T, observation AssemblyCPPObservation) {
+	t.Helper()
+	for index, event := range observation.Events {
+		if event.Ordinal != index+1 || event.Expansion < 0 || event.Expansion >= event.Ordinal ||
+			event.Definition < 0 || event.Definition >= event.Ordinal || event.Include < 0 || event.Include >= event.Ordinal {
+			t.Fatalf("noncanonical event order/lineage: %+v", event)
+		}
+	}
+}
+
+func ppCheckObservedSource(t *testing.T, observation AssemblyCPPObservation, file, source string) {
+	t.Helper()
+	for _, observed := range observation.Sources {
+		if observed.File == file {
+			if observed.Bytes != len(source) || observed.SHA256 != fmt.Sprintf("%x", sha256.Sum256([]byte(source))) {
+				t.Fatalf("source identity mismatch: %+v", observed)
+			}
+			return
+		}
+	}
+	t.Fatalf("missing actual source identity %q", file)
+}
diff --git a/preprocess_output_observation_test.go b/preprocess_output_observation_test.go
new file mode 100644
index 000000000..1e5fa079b
--- /dev/null
+++ b/preprocess_output_observation_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestPreprocessAssemblyCPPOutputPhysicalOrigins(t *testing.T) {
+	const source = "#include \"registers.h\"\n#define register indirect\n#line 900 \"logical-only.s\"\nTEXT ·Probe(SB),4,$0-0\nMOVL $42,register\nRET\n"
+	options := AssemblyPreprocessOptions{FileName: "entry.s", ReadInclude: func(parent, name string) (string, []byte, error) {
+		if parent != "entry.s" || name != "registers.h" {
+			return "", nil, fmt.Errorf("unbound include")
+		}
+		return name, []byte("#define indirect AX\n"), nil
+	}}
+	plain, err := ObserveAssemblyCPP(source, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, tokens, err := ObserveAssemblyCPPOutput(source, options)
+	if err != nil || !reflect.DeepEqual(plain, observed) || len(tokens) == 0 {
+		t.Fatalf("emitted tape changed existing observation: %v", err)
+	}
+	var opcode, register bool
+	previous := 0
+	for _, token := range tokens {
+		if token.Start < previous || token.End < token.Start || token.End > len(observed.Output) {
+			t.Fatalf("invalid emitted byte span: %+v", token)
+		}
+		previous = token.End
+		if token.Kind != '\n' && observed.Output[token.Start:token.End] != token.Text {
+			t.Fatalf("emitted token differs from exact CPP output: %+v", token)
+		}
+		if token.Text == "MOVL" || token.Text == "AX" {
+			if token.Position.File != "entry.s" || token.Position.Line != 5 {
+				t.Fatalf("logical filename or macro-definition line replaced physical invocation: %+v", token)
+			}
+			opcode = opcode || token.Text == "MOVL" && token.Expansion == 0
+			register = register || token.Text == "AX" && token.Expansion > 0
+		}
+	}
+	if !opcode || !register {
+		t.Fatal("physical opcode and transitive register expansion were not both observed")
+	}
+	// The physical-origin query must preserve original Go acceptance and bytes.
+	for _, target := range []string{"linux/386", "linux/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			original := ppMacroControlGoObject(t, target, source, map[string]string{"registers.h": "#define indirect AX\n"}, "output-origin-original")
+			normalized := ppMacroControlGoObject(t, target, observed.Output, nil, "output-origin-normalized")
+			if !strings.Contains(string(original), "2a") || !strings.Contains(string(normalized), "2a") {
+				t.Fatal("original/normalized Go objects lack the immediate marker")
+			}
+		})
+	}
+}
+
+func TestPreprocessAssemblyCPPOutputFailureHasNoTape(t *testing.T) {
+	for _, source := range []string{"#include \"missing.h\"\n", "TEXT ·Probe(SB),4,$0-0\nRET"} {
+		observed, tokens, err := ObserveAssemblyCPPOutput(source, AssemblyPreprocessOptions{FileName: "entry.s"})
+		if err == nil || tokens != nil || !reflect.DeepEqual(observed, AssemblyCPPObservation{}) {
+			t.Fatalf("failed preprocessing supplied an emitted proof: %v / %+v / %+v", err, observed, tokens)
+		}
+	}
+}
diff --git a/preprocess_sdk_positions.go b/preprocess_sdk_positions.go
new file mode 100644
index 000000000..13a7efb46
--- /dev/null
+++ b/preprocess_sdk_positions.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// These positions are a private, opt-in observation of the selected SDK's
+// lexer. Logical filenames never select files or become physical source roles.
+// All existing CPP entry points keep this tape nil and their schema unchanged.
+type sdkCPPPositionBase struct {
+	File         string
+	Anchor, Line uint
+}
+
+type sdkCPPTokenPosition struct {
+	File               string
+	Line               uint
+	Expansion, Include int
+	Base, FinalBase    sdkCPPPositionBase
+	base               *sdkCPPPositionBase
+}
+
+type sdkCPPPositionToken struct {
+	Kind     rune
+	Text     string
+	Position sdkCPPTokenPosition
+}
+
+type sdkCPPPositionObservation struct {
+	Tokens []sdkCPPPositionToken
+	Mapped string
+}
+
+func newSDKCPPFileBase(file string) *sdkCPPPositionBase {
+	return &sdkCPPPositionBase{File: file, Anchor: 1, Line: 1}
+}
+
+// cmd/internal/src.MakePos clamps physical lines before applying a pragma.
+func sdkCPPClampLine(line uint) uint {
+	const maximum = 1<<20 - 2
+	if line > maximum {
+		return maximum
+	}
+	return line
+}
+
+func (reader *ppGoReader) positionToken(token *ppGoToken) {
+	if reader.positionBase == nil {
+		return
+	}
+	token.position = &sdkCPPTokenPosition{File: reader.file, Line: reader.positionLine,
+		Expansion: reader.expansion, Include: reader.includeEvent,
+		Base: *reader.positionBase, base: reader.positionBase}
+}
+
+func (observer *ppGoObservation) emitSDKPosition(token ppGoToken, final *sdkCPPPositionBase) error {
+	if token.position == nil || final == nil {
+		return fmt.Errorf("SDK CPP position has no complete lexer base")
+	}
+	position := *token.position
+	position.FinalBase = *final
+	position.base = nil // The retained tape never aliases mutable reader state.
+	for _, file := range []*string{&position.File, &position.Base.File, &position.FinalBase.File} {
+		retained, err := observer.retainPath(*file)
+		if err != nil {
+			return err
+		}
+		*file = retained
+	}
+	if err := observer.chargeToken(len(token.text)); err != nil {
+		return err
+	}
+	observer.positions.Tokens = append(observer.positions.Tokens, sdkCPPPositionToken{
+		Kind: token.kind, Text: token.text, Position: position,
+	})
+	return nil
+}
+
+func observeSDKAssemblyCPP(src string, opt AssemblyPreprocessOptions) (AssemblyCPPObservation, sdkCPPPositionObservation, error) {
+	opt.Defines = append([]string(nil), opt.Defines...)
+	observer := newPPGoObservation()
+	observer.positions = &sdkCPPPositionObservation{}
+	output, err := preprocessGoAssemblyObserved(src, opt, observer)
+	if err != nil {
+		return AssemblyCPPObservation{}, sdkCPPPositionObservation{}, err
+	}
+	observer.result.Output, observer.result.Defines = output, opt.Defines
+	mapped, err := sdkCPPMappedAssembly(observer.positions.Tokens, ppGoObservationBytes-observer.tokenBytes)
+	if err != nil {
+		return AssemblyCPPObservation{}, sdkCPPPositionObservation{}, err
+	}
+	// A mapped file is not a new program certificate. Independently replay its
+	// complete grammar and retain the actual original/mapped/archive objects.
+	replayed, err := preprocessGoAssembly(mapped, AssemblyPreprocessOptions{FileName: opt.FileName})
+	if err != nil || replayed != output {
+		return AssemblyCPPObservation{}, sdkCPPPositionObservation{}, fmt.Errorf("SDK mapped CPP grammar differs: %v", err)
+	}
+	observer.positions.Mapped = mapped
+	observer.tokenBytes += len(mapped)
+	return observer.result, *observer.positions, nil
+}
+
+func sdkCPPMappedAssembly(tokens []sdkCPPPositionToken, remainingBytes int) (string, error) {
+	var mapped strings.Builder
+	var statement []sdkCPPPositionToken
+	var currentFile string
+	var nextLine uint
+	haveBase := false
+	write := func(part string) error {
+		if len(part) > remainingBytes-mapped.Len() {
+			return fmt.Errorf("SDK mapped CPP exceeds its byte bound: retained=%d additional=%d limit=%d", mapped.Len(), len(part), remainingBytes)
+		}
+		mapped.WriteString(part)
+		return nil
+	}
+	if remainingBytes < 0 {
+		return "", fmt.Errorf("SDK mapped CPP has no remaining byte budget")
+	}
+	for _, token := range tokens {
+		if token.Kind != '\n' {
+			statement = append(statement, token)
+		}
+		if token.Kind != '\n' && token.Kind != ';' && token.Kind != ':' {
+			continue
+		}
+		if len(statement) == 0 {
+			continue
+		}
+		// The parser saves the first instruction's raw lexer line and asks for
+		// its current base only after consuming the statement's terminator.
+		base := token.Position.FinalBase
+		line := sdkCPPClampLine(statement[0].Position.Line)
+		if base.Line == 0 {
+			line = 0
+		} else {
+			// Match src.Pos.RelLine's unsigned arithmetic exactly, including
+			// statements which consume a pragma after their first token.
+			line = base.Line + (line - base.Anchor)
+		}
+		if line >= uint(^uint(0)>>1) {
+			return "", fmt.Errorf("SDK mapped CPP line overflows")
+		}
+		// One physical output line advances the existing logical base by one.
+		// Only reset for a discontinuity (including multiple statements on one
+		// original line), so long physical SDK paths are not repeated for every
+		// consecutive instruction. The original position tape stays complete.
+		if !haveBase || currentFile != base.File || nextLine != line {
+			if err := write(fmt.Sprintf("#line %d %q\n", line+1, base.File)); err != nil {
+				return "", err
+			}
+		}
+		for _, item := range statement {
+			if err := write(item.Text); err != nil {
+				return "", err
+			}
+			if err := write(" "); err != nil {
+				return "", err
+			}
+		}
+		if err := write("\n"); err != nil {
+			return "", err
+		}
+		haveBase, currentFile, nextLine = true, base.File, line+1
+		statement = nil
+	}
+	if len(statement) != 0 {
+		return "", fmt.Errorf("SDK mapped CPP has an unterminated statement")
+	}
+	return mapped.String(), nil
+}
diff --git a/preprocess_sdk_positions_test.go b/preprocess_sdk_positions_test.go
new file mode 100644
index 000000000..34bf40cd2
--- /dev/null
+++ b/preprocess_sdk_positions_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+	"text/scanner"
+)
+
+func TestSDKCPPPositionDefaultProjection(t *testing.T) {
+	raw := `#include "physical.h"
+TEXT ·F(SB),$0
+INNER
+#ifdef ABSENT
+#line 91 "not-an-opened-source.s"
+#endif
+RET
+`
+	opened := 0
+	opt := AssemblyPreprocessOptions{FileName: "original.s", ReadInclude: func(parent, name string) (string, []byte, error) {
+		opened++
+		if parent != "original.s" || name != "physical.h" {
+			t.Fatal("logical metadata became an include origin", parent, name)
+		}
+		return "canonical/physical.h", []byte("#define INNER MOVL $7,AX\n"), nil
+	}}
+	plain, err := ObserveAssemblyCPP(raw, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, positions, err := observeSDKAssemblyCPP(raw, opt)
+	if err != nil || !reflect.DeepEqual(actual, plain) || opened != 2 {
+		t.Fatal("private position hook changed the existing CPP projection", err)
+	}
+	var macro, inactive bool
+	for _, token := range positions.Tokens {
+		if token.Text == "MOVL" {
+			macro = token.Position.Expansion != 0 && token.Position.Base.File == "original.s" && token.Position.Line == 3
+		}
+		if token.Text == "RET" {
+			base := token.Position.Base
+			inactive = base.File == "not-an-opened-source.s" && base.Line == 91 && base.Anchor == 7
+		}
+		if token.Position.base != nil {
+			t.Fatal("retained position tape aliases a private lexer reader")
+		}
+	}
+	if !macro || !inactive {
+		t.Fatal("macro invocation base or inactive #line observation was lost", positions)
+	}
+}
+
+func TestSDKCPPPositionMappedConsecutiveLinesReuseBase(t *testing.T) {
+	file := "sdk/" + strings.Repeat("long-root/", 20) + "source.s"
+	plain, positions, err := observeSDKAssemblyCPP("NOP\nNOP\nNOP\n", AssemblyPreprocessOptions{FileName: file})
+	if err != nil || strings.Count(positions.Mapped, "#line ") != 1 {
+		t.Fatal("consecutive original positions repeated an unchanged filename/base", err, positions.Mapped)
+	}
+	replayed, err := PreprocessAssemblySource(positions.Mapped, AssemblyPreprocessOptions{FileName: file})
+	if err != nil || replayed != plain.Output {
+		t.Fatal("compact source mapping changed original instructions", err)
+	}
+}
+
+func TestSDKCPPPositionMappedDiscontinuitiesResetBase(t *testing.T) {
+	for _, test := range []struct {
+		name, raw string
+		resets    int
+	}{
+		{"physical gap", "NOP\n\nNOP\n", 2},
+		{"same line statements", "NOP; NOP\n", 2},
+		{"label and instruction", "start: NOP\n", 2},
+		{"logical filename", "NOP\n#line 3 \"other.s\"\nNOP\n", 2},
+		{"logical line", "NOP\n#line 79 \"source.s\"\nNOP\n", 2},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			_, positions, err := observeSDKAssemblyCPP(test.raw, AssemblyPreprocessOptions{FileName: "source.s"})
+			if err != nil || strings.Count(positions.Mapped, "#line ") != test.resets {
+				t.Fatal("source mapping discontinuity was omitted", err, positions.Mapped)
+			}
+		})
+	}
+}
+
+func TestSDKCPPPositionMappedExactByteBoundary(t *testing.T) {
+	_, positions, err := observeSDKAssemblyCPP("NOP\nNOP\n", AssemblyPreprocessOptions{FileName: "source.s"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	exact := len(positions.Mapped)
+	for _, limit := range []int{exact - 1, 0, -1} {
+		if mapped, err := sdkCPPMappedAssembly(positions.Tokens, limit); err == nil || mapped != "" {
+			t.Fatal("oversized mapped representation was retained", limit, len(mapped), err)
+		}
+	}
+	if mapped, err := sdkCPPMappedAssembly(positions.Tokens, exact); err != nil || mapped != positions.Mapped {
+		t.Fatal("exact mapped byte boundary was rejected", err)
+	}
+}
+
+func TestSDKCPPPositionIncludeFinalBase(t *testing.T) {
+	_, positions, err := observeSDKAssemblyCPP("#include \"literal.h\"\n\n", AssemblyPreprocessOptions{
+		FileName: "original.s", ReadInclude: func(_, _ string) (string, []byte, error) {
+			return "physical/literal.h", []byte("RET"), nil
+		}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(positions.Tokens) != 2 || positions.Tokens[0].Position.File != "physical/literal.h" ||
+		positions.Tokens[0].Position.Base.File != "literal.h" ||
+		positions.Tokens[1].Position.FinalBase.File != "original.s" ||
+		positions.Mapped != "#line 2 \"original.s\"\nRET \n" {
+		t.Fatal("statement was mapped from its first token's base instead of the final lexer base", positions)
+	}
+}
+
+func TestSDKCPPPositionScratchSharesEventBudgets(t *testing.T) {
+	observer := newPPGoObservation()
+	observer.positions = &sdkCPPPositionObservation{}
+	observer.active = 0
+	observer.result.Events = []AssemblyCPPEvent{{Ordinal: 1}}
+	base := newSDKCPPFileBase("source.s")
+	token := ppGoToken{kind: scanner.Ident, text: "RET", value: "RET", file: "source.s",
+		position: &sdkCPPTokenPosition{File: "source.s", Line: 1, Base: *base, base: base}}
+	observer.tokens = ppGoObservationTokens - 1
+	if observer.capture(token) != nil || observer.emitSDKPosition(token, base) == nil || len(observer.positions.Tokens) != 0 {
+		t.Fatal("private scratch obtained a second token quota")
+	}
+	observer.tokens, observer.tokenBytes = 0, ppGoObservationBytes-1
+	if observer.emitSDKPosition(token, base) == nil {
+		t.Fatal("private scratch obtained a second byte quota")
+	}
+	if _, err := sdkCPPMappedAssembly([]sdkCPPPositionToken{{Kind: scanner.Ident, Text: "RET", Position: *token.position},
+		{Kind: '\n', Position: sdkCPPTokenPosition{FinalBase: *base}}}, 1); err == nil {
+		t.Fatal("mapped bytes escaped the remaining shared budget")
+	}
+}
diff --git a/preprocess_semantic_oracle_test.go b/preprocess_semantic_oracle_test.go
new file mode 100644
index 000000000..f2a69f6d5
--- /dev/null
+++ b/preprocess_semantic_oracle_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type ppSemanticGoResult struct {
+	stage, output string
+	accepted      bool
+}
+
+// These regressions compare two real stock-Go objects or two real stock-Go
+// source rejections. They do not execute the resulting assembly programs.
+func ppSemanticGoObject(t *testing.T, stage, source string, headers map[string]string, defines []string) ppSemanticGoResult {
+	t.Helper()
+	driver, err := exec.LookPath("go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver, err = filepath.Abs(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	directory := t.TempDir()
+	for name, body := range headers {
+		path := filepath.Join(directory, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, []byte(body), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	file, object := filepath.Join(directory, "entry.s"), filepath.Join(directory, "entry.o")
+	if err := os.WriteFile(file, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	environment := append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "GOENV=off", "GOTOOLCHAIN=local", "GOFLAGS=")
+	run := func(arguments ...string) ([]byte, error) {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		command := exec.CommandContext(ctx, driver, arguments...)
+		command.Dir, command.Env = directory, environment
+		return runtimeOracleCombinedOutput(ctx, command)
+	}
+	version, err := run("version")
+	if err != nil {
+		t.Fatalf("actual selected Go version: %v\n%s", err, version)
+	}
+	toolDirectory, err := run("env", "GOTOOLDIR")
+	if err != nil {
+		t.Fatalf("actual selected Go tool directory: %v\n%s", err, toolDirectory)
+	}
+	assemblerName := "asm"
+	if strings.HasSuffix(driver, ".exe") {
+		assemblerName += ".exe"
+	}
+	assembler := filepath.Join(strings.TrimSpace(string(toolDirectory)), assemblerName)
+	driverBytes, err := os.ReadFile(driver)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assemblerBytes, err := os.ReadFile(assembler)
+	if err != nil {
+		t.Fatal(err)
+	}
+	arguments := []string{"tool", "asm", "-S", "-p", "cppsemantic", "-I", directory, "-o", object}
+	for _, definition := range defines {
+		arguments = append(arguments, "-D", definition)
+	}
+	arguments = append(arguments, file)
+	output, commandErr := run(arguments...)
+	exit := 0
+	if commandErr != nil {
+		var actualExit *exec.ExitError
+		if !errors.As(commandErr, &actualExit) || actualExit.ExitCode() != 1 ||
+			!strings.Contains(string(output), file+":") {
+			t.Fatalf("unknown original Go failure, not a source rejection: %v\n%s", commandErr, output)
+		}
+		exit = actualExit.ExitCode()
+	}
+	var objectBytes []byte
+	if exit == 0 {
+		objectBytes, err = os.ReadFile(object)
+		if err != nil || len(objectBytes) == 0 {
+			t.Fatalf("actual accepted Go object missing: %v", err)
+		}
+	}
+	receipt, err := json.Marshal(struct {
+		Stage, Version, Driver, Assembler, DriverSHA, AssemblerSHA string
+		Arguments                                                  []string
+		Source, Object                                             []byte
+		Headers                                                    map[string]string
+		Exit                                                       int
+		Output                                                     string
+	}{stage, strings.TrimSpace(string(version)), driver, assembler,
+		fmt.Sprintf("%x", sha256.Sum256(driverBytes)), fmt.Sprintf("%x", sha256.Sum256(assemblerBytes)),
+		arguments, []byte(source), objectBytes, headers, exit, string(output)})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("CPP_ACTUAL_GO_RECEIPT %s", receipt)
+	return ppSemanticGoResult{stage: stage, output: string(output), accepted: exit == 0}
+}
+
+func ppSemanticCompareAcceptance(t *testing.T, source string, accepted bool) {
+	t.Helper()
+	original := ppSemanticGoObject(t, "original", source, nil, nil)
+	if original.accepted != accepted {
+		t.Fatalf("original source expectation differs from actual Go: %s", original.output)
+	}
+	expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{FileName: "entry.s"})
+	if err != nil {
+		if accepted {
+			t.Fatalf("Go-accepted source was rejected: %v", err)
+		}
+		return
+	}
+	normalized := ppSemanticGoObject(t, "normalized", expanded, nil, nil)
+	if normalized.accepted != original.accepted {
+		t.Fatalf("CPP changed actual Go source acceptance: original=%t normalized=%t\nsource=%q\nnormalized=%q",
+			original.accepted, normalized.accepted, source, expanded)
+	}
+}
+
+func TestPreprocessAssemblyCommentSeamsActualGo(t *testing.T) {
+	for _, test := range []struct{ name, body string }{
+		{"block", "/ * RET * /\n"},
+		{"line", "/ / BAD\n"},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ppSemanticCompareAcceptance(t, "TEXT ·Probe(SB),$0-0\n"+test.body+"RET\n", false)
+		})
+	}
+	t.Run("real-comment-control", func(t *testing.T) {
+		ppSemanticCompareAcceptance(t, "TEXT ·Probe(SB),$0-0\n/* real comment */\nRET\n", true)
+	})
+}
+
+func TestPreprocessAssemblyBuildCommentActualGo(t *testing.T) {
+	for _, test := range []struct {
+		name, source string
+		accepted     bool
+	}{
+		{"after-code", "TEXT ·Probe(SB),$0-0\n//go:build amd64\nRET\n", false},
+		{"first-line-cpp-control", "#define EMPTY\n//go:build amd64\nTEXT ·Probe(SB),$0-0\nRET\n", true},
+		{"after-newline-cpp", "\n#define EMPTY\n//go:build amd64\nTEXT ·Probe(SB),$0-0\nRET\n", false},
+		{"header-control", "//go:build amd64\n\nTEXT ·Probe(SB),$0-0\nRET\n", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ppSemanticCompareAcceptance(t, test.source, test.accepted)
+		})
+	}
+}
+
+func TestPreprocessAssemblyInstructionEOFActualGo(t *testing.T) {
+	t.Run("instruction-eof", func(t *testing.T) {
+		ppSemanticCompareAcceptance(t, "TEXT ·Probe(SB),$0-0\nRET", false)
+	})
+	t.Run("newline-control", func(t *testing.T) {
+		ppSemanticCompareAcceptance(t, "TEXT ·Probe(SB),$0-0\nRET\n", true)
+	})
+	t.Run("empty-define-control", func(t *testing.T) {
+		ppSemanticCompareAcceptance(t, "TEXT ·Probe(SB),$0-0\nRET\n#define EMPTY", true)
+	})
+}
+
+func TestPreprocessAssemblyFunctionMacroLookaheadActualGo(t *testing.T) {
+	const program = "TEXT ·Probe(SB),$0-0\nRET\n"
+	for _, test := range []struct {
+		name, source string
+		accepted     bool
+	}{
+		{"bare-opcode", "#define RET(x) x\n" + program, false},
+		{"bare-register", "#define AX(x) x\nTEXT ·Probe(SB),$0-0\nMOVQ $42, AX\nRET\n", false},
+		{"inactive-newline", "#define F(x) x\n#ifdef ABSENT\nF\n#endif\n" + program, false},
+		{"inactive-punctuation", "#define F(x) x\n#ifdef ABSENT\nF +\n#endif\n" + program, false},
+		{"invoked-control", "#define EMIT(x) x\nTEXT ·Probe(SB),$0-0\nEMIT(RET)\n", true},
+		{"inactive-invoked-control", "#define F() RET\n#ifdef ABSENT\nF()\n#endif\n" + program, true},
+		{"ordinary-identifier-control", "#define F(x) x\n" + program, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ppSemanticCompareAcceptance(t, test.source, test.accepted)
+		})
+	}
+}
+
+func TestPreprocessAssemblyCanonicalIncludeActualGo(t *testing.T) {
+	const marker = "DATA ·value(SB)/4,$VALUE\nGLOBL ·value(SB),8,$4\n"
+	for _, spelling := range []string{"x·h", "x∕h"} {
+		canonical := strings.NewReplacer("·", ".", "∕", "/").Replace(spelling)
+		for _, style := range []string{"function-argument", "predefined", "macro-body"} {
+			t.Run(style+"/"+spelling, func(t *testing.T) {
+				headers := map[string]string{
+					canonical: "#define VALUE 42\n",
+					spelling:  "#define VALUE 13\n",
+				}
+				var source string
+				var defines []string
+				switch style {
+				case "function-argument":
+					source = "#define USE(P) \\\n#include P \\\n\nUSE(\"" + spelling + "\")\n" + marker
+				case "predefined":
+					defines = []string{"USE=#include \"" + spelling + "\"\n"}
+					source = "USE\n" + marker
+				case "macro-body":
+					source = "#define USE \\\n#include \"" + spelling + "\" \\\n\nUSE\n" + marker
+				}
+				original := ppSemanticGoObject(t, "original", source, headers, defines)
+				if !original.accepted || !strings.Contains(original.output, "2a 00 00 00") {
+					t.Fatalf("original Go did not select its canonical include: %s", original.output)
+				}
+				var selected []string
+				expanded, err := PreprocessAssemblySource(source, AssemblyPreprocessOptions{
+					FileName: "entry.s", Defines: defines,
+					ReadInclude: func(parent, name string) (string, []byte, error) {
+						selected = append(selected, name)
+						body, ok := headers[name]
+						if !ok || parent != "entry.s" {
+							return "", nil, fmt.Errorf("unbound include %s from %s", name, parent)
+						}
+						return name, []byte(body), nil
+					},
+				})
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized := ppSemanticGoObject(t, "normalized", expanded, nil, nil)
+				if !normalized.accepted || !strings.Contains(normalized.output, "2a 00 00 00") ||
+					strings.Join(selected, ",") != canonical {
+					t.Fatalf("CPP changed actual include/object identity: selected=%v want=%q\n%s", selected, canonical, normalized.output)
+				}
+			})
+		}
+	}
+}
diff --git a/preprocess_test.go b/preprocess_test.go
index 2e924a861..883514922 100644
--- a/preprocess_test.go
+++ b/preprocess_test.go
@@ -5,6 +5,30 @@ import (
 	"testing"
 )
 
+func TestPreprocessCommentLexicalBoundaries(t *testing.T) {
+	for _, tc := range []struct{ name, source, want string }{
+		{"line-before-block", "//*** assembly header\nTEXT foo(SB),$0-0\nRET\n", "TEXT foo(SB),$0-0\nRET"},
+		{"line-hides-open-block", "// /* not a block\nTEXT foo(SB),$0-0\nRET\n", "TEXT foo(SB),$0-0\nRET"},
+		{"block-token-boundary", "TEXT/* header */foo(SB),$0-0\nRET\n", "TEXT foo(SB),$0-0\nRET"},
+		{"string", "DATA blob(SB)/8, $\"/* // */\" // tail\n", "DATA blob(SB)/8, $\"/* // */\""},
+		{"escaped-string", "DATA blob(SB)/8, $\"\\\"// /*\"\n", "DATA blob(SB)/8, $\"\\\"// /*\""},
+		{"character", "BYTE $'/' /* block */\nBYTE $'\\'' // line\n", "BYTE $'/'\nBYTE $'\\''"},
+		{"multiline-block", "/* // ignored\nstill ignored */ TEXT foo(SB),$0-0\nRET\n", "TEXT foo(SB),$0-0\nRET"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := preprocess(tc.source)
+			if err != nil || strings.TrimSpace(got) != tc.want {
+				t.Fatalf("preprocess = %q, %v; want %q", got, err, tc.want)
+			}
+		})
+	}
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64, ArchWASM} {
+		if _, err := Parse(arch, "//*** reported simd header\nTEXT foo(SB),$0-0\nRET\n"); err != nil {
+			t.Errorf("%s line-comment header: %v", arch, err)
+		}
+	}
+}
+
 func TestPreprocessExpandsFunctionLikeMacrosWithSpaceBeforeParen(t *testing.T) {
 	src := `
 #define ST(dst) MOVQ AX, dst
@@ -31,3 +55,270 @@ TEXT foo(SB),NOSPLIT,$0-0
 		t.Fatalf("expected ROUNDS expansion, got: %q", pp)
 	}
 }
+
+func TestPreprocessExpandsUnicodeFunctionMacroNamesAcceptedByGo(t *testing.T) {
+	for _, source := range []string{`
+#define NEON_TANH_PADÉ(src, dst) MOVD src, dst
+TEXT unicodeMacro(SB),$0-0
+	NEON_TANH_PADÉ(R5, R6)
+	RET
+	`, `
+#define REGÉ R5
+#define MOVEÉ(srcé, dst) MOVD srcé, dst
+TEXT unicodeMacro(SB),$0-0
+	MOVEÉ(REGÉ, R6)
+	RET
+	`} {
+		requireARM64GoAssemblerResult(t, source, true)
+		got, err := preprocess(source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Contains(got, "NEON_TANH_PADÉ") || strings.Contains(got, "MOVEÉ") ||
+			strings.Contains(got, "REGÉ") || !strings.Contains(got, "MOVD R5, R6") {
+			t.Fatalf("Unicode macro was not expanded: %q", got)
+		}
+	}
+}
+
+func TestPreprocessDoesNotExpandFunctionMacroInsideMiddleDotSymbol(t *testing.T) {
+	const src = `
+#define g(r) 0(r)(TLS*1)
+TEXT ·g(SB),NOSPLIT,$0-8
+	MOVQ g(CX), BX
+	RET
+`
+	pp, err := preprocessWithDefines(src, []string{"GOARCH_amd64"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(pp, "TEXT ·g(SB),NOSPLIT,$0-8") {
+		t.Fatalf("function-like macro rewrote a middle-dot function symbol:\n%s", pp)
+	}
+	if !strings.Contains(pp, "MOVQ 0(CX)(TLS*1), BX") {
+		t.Fatalf("function-like macro call in an operand was not expanded:\n%s", pp)
+	}
+	if _, err := Parse(ArchAMD64, src); err != nil {
+		t.Fatalf("Parse rejected a macro whose name matches a middle-dot function symbol: %v", err)
+	}
+}
+
+func TestPreprocessKeepsMultilineDefineAcrossBlockCommentsAndBlankContinuations(t *testing.T) {
+	// C preprocessing splices backslash-newline pairs before removing comments.
+	// Real assembly such as buildbarn/bb-storage relies on that ordering inside
+	// large function-like macros.
+	const src = `
+#define ROUND(dst, src) \
+	MOVQ src, dst \
+	/* Explain the next operation. \
+	 * The comment itself spans physical lines. \
+	 */ \
+	\
+	ADDQ $1, dst
+TEXT macro(SB),$0-0
+	ROUND(AX, BX)
+	RET
+`
+	pp, err := preprocess(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(pp, "\\") {
+		t.Fatalf("physical continuation escaped into preprocessed assembly:\n%s", pp)
+	}
+	for _, want := range []string{"MOVQ BX, AX", "ADDQ $1, AX"} {
+		if !strings.Contains(pp, want) {
+			t.Fatalf("multiline macro omitted %q:\n%s", want, pp)
+		}
+	}
+	if _, err := Parse(ArchAMD64, src); err != nil {
+		t.Fatalf("Parse rejected a Go-assembler-compatible multiline macro: %v\n%s", err, pp)
+	}
+}
+
+func TestPreprocessKeepsDefineAcrossUnsplicedMultilineBlockComment(t *testing.T) {
+	// Go's assembler removes a block comment before recognizing the end of a
+	// macro definition. The comment's physical newlines need no backslashes.
+	const src = `
+#define ROUND(dst) \
+	MOVQ $1, dst; \
+	/* This comment spans
+	   several physical lines
+	*/ \
+	ADDQ $2, dst
+TEXT macro(SB),$0-0
+	ROUND(AX)
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", src, true)
+	pp, err := preprocess(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(pp, "\\") || strings.Contains(pp, "several physical lines") {
+		t.Fatalf("block comment leaked into expanded assembly:\n%s", pp)
+	}
+	for _, want := range []string{"MOVQ $1, AX", "ADDQ $2, AX"} {
+		if !strings.Contains(pp, want) {
+			t.Fatalf("macro expansion omitted %q:\n%s", want, pp)
+		}
+	}
+	if _, err := Parse(ArchAMD64, src); err != nil {
+		t.Fatalf("Parse rejected a Go-assembler-compatible comment in a macro: %v\n%s", err, pp)
+	}
+}
+
+func TestPreprocessKeepsMultilineDefineWhenContinuationPrecedesLineComment(t *testing.T) {
+	// Several Go assembly packages, including IOTA, MinIO HighwayHash, and
+	// go-ethereum, put a line comment after the continuation slash. The Go
+	// assembler's preprocessor accepts this historical spelling.
+	const src = `
+#define ROUND(dst, src) \
+	MOVQ src, dst; \ // copy the input
+	\ // keep this comment-only continuation in the macro
+	ADDQ $1, dst
+TEXT macro(SB),$0-0
+	ROUND(AX, BX)
+	RET
+`
+	pp, err := preprocess(src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(pp, "\\") {
+		t.Fatalf("commented continuation escaped into preprocessed assembly:\n%s", pp)
+	}
+	for _, want := range []string{"MOVQ BX, AX", "ADDQ $1, AX"} {
+		if !strings.Contains(pp, want) {
+			t.Fatalf("multiline macro omitted %q:\n%s", want, pp)
+		}
+	}
+	if _, err := Parse(ArchAMD64, src); err != nil {
+		t.Fatalf("Parse rejected a Go-assembler-compatible commented continuation: %v\n%s", err, pp)
+	}
+}
+
+func TestPreprocessEvaluatesConditionalDirectivesExpandedFromMacro(t *testing.T) {
+	const src = `
+#define BREAK \
+#ifdef GOOS_windows \
+	BRK $0xf000 \
+#else \
+	BRK \
+#endif \
+
+TEXT breakpoint(SB),NOSPLIT,$0-0
+	BREAK
+	RET
+`
+	linux, err := preprocessWithDefines(src, []string{"GOOS_linux", "GOARCH_arm64"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(linux, "#if") || strings.Contains(linux, "#else") || strings.Contains(linux, "#endif") {
+		t.Fatalf("conditional directive escaped from Linux macro expansion:\n%s", linux)
+	}
+	if !strings.Contains(linux, "BRK\n") || strings.Contains(linux, "$0xf000") {
+		t.Fatalf("Linux macro selected the wrong branch:\n%s", linux)
+	}
+
+	windows, err := preprocessWithDefines(src, []string{"GOOS_windows", "GOARCH_arm64"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(windows, "#if") || strings.Contains(windows, "#else") || strings.Contains(windows, "#endif") {
+		t.Fatalf("conditional directive escaped from Windows macro expansion:\n%s", windows)
+	}
+	if !strings.Contains(windows, "BRK $0xf000") {
+		t.Fatalf("Windows macro selected the wrong branch:\n%s", windows)
+	}
+}
+
+func TestPreprocessExpandsMacrosAtInvocationBeforeRedefinition(t *testing.T) {
+	const source = `
+#define V0 X0
+#define BODY(src) VPCMPGTD V0, src, V0
+TEXT early(SB),$0-0
+	BODY(X1)
+	RET
+#undef V0
+#define V0 Z0
+TEXT late(SB),$0-0
+	VPCMPGTD V0, Z1, K1
+	RET
+`
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	got, err := preprocess(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"VPCMPGTD X0, X1, X0",
+		"VPCMPGTD Z0, Z1, K1",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("macro redefinition changed an earlier instruction; missing %q:\n%s", want, got)
+		}
+	}
+	if _, err := Parse(ArchAMD64, source); err != nil {
+		t.Fatalf("Parse rejected the Go-accepted assembly: %v", err)
+	}
+}
+
+func TestPreprocessExpandedConditionUsesInvocationDefinitions(t *testing.T) {
+	const source = `
+#define FEATURE
+#define CONDITIONAL \
+#ifdef FEATURE \
+	MOVQ $1, AX \
+#else \
+	MOVQ $2, AX \
+#endif \
+
+TEXT first(SB),$0-0
+	CONDITIONAL
+	RET
+#undef FEATURE
+TEXT second(SB),$0-0
+	CONDITIONAL
+	RET
+`
+	got, err := preprocess(source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"TEXT first(SB),$0-0\nMOVQ $1, AX\nRET",
+		"TEXT second(SB),$0-0\nMOVQ $2, AX\nRET",
+	} {
+		if !strings.Contains(got, want) {
+			t.Fatalf("expanded condition used the wrong definition epoch; missing %q:\n%s", want, got)
+		}
+	}
+}
+
+func TestGoAssemblerDefinesMatchToolchainFeatureRules(t *testing.T) {
+	t.Setenv("GOAMD64", "v3")
+	if got := strings.Join(GoAssemblerDefines("linux", "amd64"), ","); got != "GOOS_linux,GOARCH_amd64,GOAMD64_v3" {
+		t.Fatalf("amd64 defines = %q", got)
+	}
+	t.Setenv("GOARM", "7,hardfloat")
+	if got := strings.Join(GoAssemblerDefines("linux", "arm"), ","); got != "GOOS_linux,GOARCH_arm,GOARM_7,GOARM_6,GOARM_5" {
+		t.Fatalf("arm defines = %q", got)
+	}
+	t.Setenv("GOARM64", "v8.0,lse")
+	if got := strings.Join(GoAssemblerDefines("windows", "arm64"), ","); got != "GOOS_windows,GOARCH_arm64,GOARM64_LSE" {
+		t.Fatalf("arm64 defines = %q", got)
+	}
+}
+
+func TestGoAssemblerDefinesImplicitARM64LSE(t *testing.T) {
+	for _, value := range []string{"v8.1", "v8.9,crypto", "v9.0", "v9.5,crypto"} {
+		t.Run(value, func(t *testing.T) {
+			t.Setenv("GOARM64", value)
+			if got := strings.Join(GoAssemblerDefines("linux", "arm64"), ","); got != "GOOS_linux,GOARCH_arm64,GOARM64_LSE" {
+				t.Fatalf("GOARM64=%s defines = %q; cmd/go enables mandatory LSE", value, got)
+			}
+		})
+	}
+}
diff --git a/preprocess_tokens.go b/preprocess_tokens.go
new file mode 100644
index 000000000..ab1d072c2
--- /dev/null
+++ b/preprocess_tokens.go
@@ -0,0 +1,367 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/build/constraint"
+	"strings"
+	"text/scanner"
+)
+
+const (
+	ppGoBuildComment rune = -2001
+	ppGoMacroName    rune = -2002
+)
+
+// CPP operates on tokens, not on independent physical lines. A replacement
+// can open a conditional which its parent closes, or define a macro used by a
+// later original instruction. Keep lexical origins separate from #line names.
+type ppGoToken struct {
+	kind                    rune
+	text, value             string
+	file                    string
+	line, endCol            int
+	expansion, includeEvent int
+	position                *sdkCPPTokenPosition
+}
+
+type ppGoReader struct {
+	file                    string
+	scanner                 *scanner.Scanner
+	err                     error
+	tokens                  []ppGoToken
+	index                   int
+	line                    int
+	include                 bool
+	expansion, includeEvent int
+	positionBase            *sdkCPPPositionBase
+	positionLine            uint
+}
+
+func newPPGoReader(file, source string) *ppGoReader {
+	reader := &ppGoReader{file: file}
+	var lexical scanner.Scanner
+	lexical.Init(strings.NewReader(source))
+	lexical.Filename = file
+	lexical.Whitespace = 1<<'\t' | 1<<'\r' | 1<<' '
+	lexical.Mode = scanner.ScanChars | scanner.ScanFloats | scanner.ScanIdents |
+		scanner.ScanInts | scanner.ScanStrings | scanner.ScanComments
+	lexical.IsIdentRune = ppIdentRune
+	lexical.Error = func(scan *scanner.Scanner, message string) {
+		if reader.err == nil {
+			reader.err = fmt.Errorf("CPP %s: %s", scan.Position, message)
+		}
+	}
+	reader.scanner = &lexical
+	return reader
+}
+
+func (reader *ppGoReader) next() (ppGoToken, error) {
+	if reader.scanner == nil {
+		if reader.index == len(reader.tokens) {
+			return ppGoToken{kind: scanner.EOF, file: reader.file, line: reader.line}, nil
+		}
+		token := reader.tokens[reader.index]
+		reader.index++
+		// Go's lex.Slice reports sequential positions even when a generated
+		// #define originally contained a space before its parenthesis.
+		token.file, token.line, token.endCol = reader.file, reader.line, reader.index
+		token.expansion, token.includeEvent = reader.expansion, reader.includeEvent
+		reader.positionToken(&token)
+		return token, nil
+	}
+	var kind rune
+	for {
+		kind = reader.scanner.Scan()
+		if reader.positionBase != nil {
+			if kind == '\n' {
+				reader.positionLine++
+			} else if kind == scanner.Comment {
+				reader.positionLine += uint(strings.Count(reader.scanner.TokenText(), "\n"))
+			}
+		}
+		if kind != scanner.Comment {
+			break
+		}
+		// Go preserves build comments for the assembly parser to check their
+		// position. Ordinary comments disappear without inventing newline tokens.
+		if constraint.IsGoBuild(reader.scanner.TokenText()) {
+			kind = ppGoBuildComment
+			break
+		}
+	}
+	text := reader.scanner.TokenText()
+	if reader.err != nil {
+		return ppGoToken{}, reader.err
+	}
+	// cmd/asm combines these operators before recording macro tokens. Do not
+	// manufacture a shift from two separately scanned angle brackets.
+	if kind == '<' || kind == '>' || kind == '-' || kind == '@' {
+		next := reader.scanner.Peek()
+		if kind == '<' && next == '<' || kind == '>' && next == '>' || (kind == '-' || kind == '@') && next == '>' {
+			reader.scanner.Next()
+			text += string(next)
+		}
+	}
+	token := ppGoToken{
+		kind: kind, text: text, value: text, file: reader.file,
+		line: reader.scanner.Position.Line, endCol: reader.scanner.Pos().Column,
+		includeEvent: reader.includeEvent,
+	}
+	reader.positionToken(&token)
+	return token, nil
+}
+
+// cmd/asm's lex.Make canonicalizes recorded replacement, argument and -D
+// tokens, not physical source tokens. Keep text separately so emitting an
+// identifier containing a dot/slash can retain its original lexical boundary.
+func ppGoRecordedToken(token ppGoToken) ppGoToken {
+	token.value = strings.ReplaceAll(strings.ReplaceAll(token.value, "·", "."), "∕", "/")
+	return token
+}
+
+type ppGoMacro struct {
+	parameters []string
+	body       []ppGoToken
+	definition int
+}
+
+type ppGoInput struct {
+	options    AssemblyPreprocessOptions
+	readers    []*ppGoReader
+	macros     map[string]ppGoMacro
+	conditions []bool
+	bol        bool
+	sawCode    bool
+	includes   int
+	last       ppGoToken
+	text       string
+	peek       *ppGoToken
+	observer   *ppGoObservation
+}
+
+func (input *ppGoInput) raw() (ppGoToken, error) {
+	for {
+		reader := input.readers[len(input.readers)-1]
+		token, err := reader.next()
+		if err != nil {
+			return ppGoToken{}, err
+		}
+		if token.kind != scanner.EOF || len(input.readers) == 1 {
+			input.last = token
+			if input.observer != nil {
+				if err := input.observer.capture(token); err != nil {
+					return ppGoToken{}, err
+				}
+			}
+			return token, nil
+		}
+		if reader.include {
+			input.includes--
+		}
+		input.readers = input.readers[:len(input.readers)-1]
+	}
+}
+
+func (input *ppGoInput) enabled() bool {
+	return len(input.conditions) == 0 || input.conditions[len(input.conditions)-1]
+}
+
+func (input *ppGoInput) errorf(format string, args ...any) error {
+	return fmt.Errorf("%s:%d: %s", input.last.file, input.last.line, fmt.Sprintf(format, args...))
+}
+
+func (input *ppGoInput) push(reader *ppGoReader) error {
+	if len(input.readers) >= 100 {
+		return input.errorf("CPP token-stack recursion exceeds the explicit 100-reader bound")
+	}
+	input.readers = append(input.readers, reader)
+	return nil
+}
+
+func (input *ppGoInput) name() (string, error) {
+	token, err := input.raw()
+	if err != nil {
+		return "", err
+	}
+	if token.kind != scanner.Ident {
+		return "", input.errorf("invalid CPP macro name: %q", token.text)
+	}
+	if event := input.observedEvent(); event != nil {
+		event.Name = token.value
+		if macro, exists := input.macros[token.value]; exists {
+			event.Definition = macro.definition
+		}
+	}
+	return token.value, nil
+}
+
+func (input *ppGoInput) newline(directive string) error {
+	token, err := input.raw()
+	if err != nil {
+		return err
+	}
+	if token.kind != '\n' {
+		return input.errorf("invalid #%s: expected terminating newline, got %q", directive, token.text)
+	}
+	return nil
+}
+
+func (input *ppGoInput) next() (ppGoToken, error) {
+	if input.peek != nil {
+		// Go returns a cached lookahead directly, without macro dispatch,
+		// enabled filtering, or a beginning-of-line update. Its text is the
+		// previous publicly returned token's text, not the raw lookahead's.
+		token := *input.peek
+		if input.observer != nil {
+			index, err := input.beginObservation("peek", token)
+			if err != nil {
+				return ppGoToken{}, err
+			}
+			if err := input.observer.capture(token); err != nil {
+				return ppGoToken{}, err
+			}
+			input.observedEvent().Executed = true
+			input.finishObservation(index)
+		}
+		input.peek = nil
+		input.text = token.text
+		return token, nil
+	}
+	for nesting := 0; nesting < 100; {
+		token, err := input.raw()
+		if err != nil {
+			return ppGoToken{}, err
+		}
+		if token.kind == '#' {
+			if !input.bol {
+				return ppGoToken{}, input.errorf("'#' must be first item on line")
+			}
+			input.bol, err = input.control(token)
+			if err != nil {
+				return ppGoToken{}, err
+			}
+			// Go returns a '#' wisp even for disabled controls. Its parser
+			// uses this to distinguish a header build comment from a late one.
+			input.sawCode = true
+			input.text = "#"
+			return token, nil
+		}
+		if token.kind == scanner.Ident {
+			if macro, exists := input.macros[token.value]; exists {
+				expanded, err := input.invoke(token, macro)
+				if err != nil {
+					return ppGoToken{}, err
+				}
+				if expanded {
+					nesting++
+					continue
+				}
+			}
+		}
+		if token.kind == scanner.EOF && len(input.conditions) != 0 {
+			return ppGoToken{}, input.errorf("unclosed #ifdef or #ifndef")
+		}
+		input.bol = token.kind == '\n'
+		if input.enabled() {
+			input.text = token.text
+			return token, nil
+		}
+	}
+	return ppGoToken{}, input.errorf("recursive macro invocation")
+}
+
+func (input *ppGoInput) invoke(invocation ppGoToken, macro ppGoMacro) (bool, error) {
+	index, err := input.beginObservation("invoke", invocation)
+	if err != nil {
+		return false, err
+	}
+	defer input.finishObservation(index)
+	if event := input.observedEvent(); event != nil {
+		event.Name, event.Definition = invocation.value, macro.definition
+		event.Function = macro.parameters != nil
+		event.Parameters = ppGoCopyParameters(macro.parameters)
+		event.Invoked, event.Executed = true, true
+	}
+	body := macro.body
+	if macro.parameters != nil {
+		opening, err := input.raw()
+		if err != nil {
+			return false, err
+		}
+		if opening.kind != '(' {
+			if event := input.observedEvent(); event != nil {
+				event.Invoked = false
+			}
+			opening.text, opening.value = input.text, input.text
+			opening.expansion = index + 1
+			input.peek = &opening
+			name := ppGoRecordedToken(invocation)
+			name.kind = ppGoMacroName
+			return true, input.push(&ppGoReader{
+				file: opening.file, line: opening.line, tokens: []ppGoToken{name},
+				expansion: index + 1, includeEvent: invocation.includeEvent,
+			})
+		}
+		actuals, err := input.arguments(invocation.value, macro.parameters)
+		if err != nil {
+			return false, err
+		}
+		body = nil
+		for _, token := range macro.body {
+			if replacement := actuals[token.value]; token.kind == scanner.Ident && replacement != nil {
+				body = append(body, replacement...)
+			} else {
+				body = append(body, token)
+			}
+		}
+	}
+	reader := &ppGoReader{
+		file: invocation.file, line: invocation.line, tokens: body,
+		expansion: index + 1, includeEvent: invocation.includeEvent,
+	}
+	if invocation.position != nil {
+		reader.positionBase = invocation.position.base
+		reader.positionLine = invocation.position.Line
+	}
+	return true, input.push(reader)
+}
+
+func (input *ppGoInput) arguments(name string, parameters []string) (map[string][]ppGoToken, error) {
+	var arguments [][]ppGoToken
+	var argument []ppGoToken
+	nesting := 0
+	for {
+		token, err := input.raw()
+		if err != nil {
+			return nil, err
+		}
+		if token.kind == scanner.EOF || token.kind == '\n' {
+			return nil, input.errorf("unterminated arg list invoking macro: %s", name)
+		}
+		if nesting == 0 && (token.kind == ')' || token.kind == ',') {
+			arguments = append(arguments, argument)
+			argument = nil
+			if token.kind == ')' {
+				break
+			}
+			continue
+		}
+		if token.kind == '(' {
+			nesting++
+		} else if token.kind == ')' {
+			nesting--
+		}
+		argument = append(argument, ppGoRecordedToken(token))
+	}
+	if len(parameters) == 0 && len(arguments) == 1 && arguments[0] == nil {
+		arguments = nil
+	}
+	if len(arguments) != len(parameters) {
+		return nil, input.errorf("wrong arg count for macro: %s", name)
+	}
+	actuals := make(map[string][]ppGoToken, len(parameters))
+	for index, parameter := range parameters {
+		actuals[parameter] = arguments[index]
+	}
+	return actuals, nil
+}
diff --git a/repository_portability_test.go b/repository_portability_test.go
new file mode 100644
index 000000000..ae21ef7fe
--- /dev/null
+++ b/repository_portability_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Match concrete home-directory paths, not repository-relative paths or
+// placeholders. Deployment-specific values belong in untracked configuration.
+var personalWorkspacePath = regexp.MustCompile(`(?:/(?:Users|home)/[[:alnum:]_.-]+/|[A-Za-z]:[\\/]+Users[\\/]+[[:alnum:]_.-]+[\\/]|~/(?:source|src|workspace|projects)/)`)
+
+func TestRepositoryDoesNotEmbedPersonalWorkspacePaths(t *testing.T) {
+	err := filepath.WalkDir(".", func(name string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			switch entry.Name() {
+			case ".git", "_out", "vendor", "node_modules", "bin", "data":
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		switch filepath.Ext(name) {
+		case ".go", ".md", ".sh", ".yml", ".yaml", ".json", ".jsonl", ".toml", ".txt", ".ps1", ".plist", ".in":
+		default:
+			return nil
+		}
+		contents, err := os.ReadFile(name)
+		if err != nil {
+			return err
+		}
+		for i, line := range strings.Split(string(contents), "\n") {
+			if personalWorkspacePath.MatchString(line) {
+				t.Errorf("%s:%d embeds a personal workspace path; use a relative path or configurable placeholder", name, i+1)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestPersonalWorkspacePathPolicy(t *testing.T) {
+	for _, tc := range []struct {
+		path string
+		want bool
+	}{
+		{strings.Join([]string{"", "Users", "developer", "project"}, "/"), true},
+		{strings.Join([]string{"", "home", "developer", "project"}, "/"), true},
+		{strings.Join([]string{"C:", "Users", "developer", "project"}, `\`), true},
+		{strings.Join([]string{"~", "source", "project"}, "/"), true},
+		{"testdata/discovery/ledger", false},
+		{"$WORKSPACE/project", false},
+		{"@CHECKOUT_ROOT@/scripts/sync-results.sh", false},
+	} {
+		if got := personalWorkspacePath.MatchString(tc.path); got != tc.want {
+			t.Errorf("path policy detection=%v, want %v", got, tc.want)
+		}
+	}
+}
diff --git a/repository_scope_test.go b/repository_scope_test.go
new file mode 100644
index 000000000..a48e9a8ff
--- /dev/null
+++ b/repository_scope_test.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestRepositorySeparatesExternalCompatibility(t *testing.T) {
+	for _, name := range []string{
+		"cmd/plan9asmcorpus", "cmd/plan9asmdiscover", "internal/discoverymeta",
+		"testdata/discovery", "testdata/corpus",
+		"scripts/check-discovered-library-corpus.sh",
+		"scripts/check-reported-library-corpus.sh",
+	} {
+		if _, err := os.Stat(name); !os.IsNotExist(err) {
+			t.Errorf("external compatibility path must live in llgo-compat/plan9asm: %s (%v)", name, err)
+		}
+	}
+	for _, name := range []string{
+		"cmd/plan9asmscan", "cmd/plan9asmgooracle", "cmd/plan9asmll",
+		"testdata/coverage", "testdata/conformance", "gotoolprofile",
+		"scripts/check-go-asm-coverage.sh", "scripts/check-stdlib-corpus.sh",
+	} {
+		if _, err := os.Stat(name); err != nil {
+			t.Errorf("translator/official regression path must remain: %s: %v", name, err)
+		}
+	}
+	data, err := os.ReadFile(".github/workflows/go-ci.yml")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, external := range []string{"discovered_library", "reported_library", "testdata/discovery", "cmd/plan9asmcorpus"} {
+		if strings.Contains(string(data), external) {
+			t.Errorf("translator CI still depends on external compatibility work: %s", external)
+		}
+	}
+	data, err = os.ReadFile("scripts/check-arm64-plan9-corpus.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(data), "testdata/corpus") || !strings.Contains(string(data), "golang.org/x/arch@v0.31.0") {
+		t.Fatal("official ARM64 decoder gate depends on removed external manifests or lost its pin")
+	}
+}
diff --git a/retjmp_test.go b/retjmp_test.go
index e2b6462e7..237b6b235 100644
--- a/retjmp_test.go
+++ b/retjmp_test.go
@@ -1,6 +1,7 @@
 package plan9asm
 
 import (
+	"errors"
 	"strings"
 	"testing"
 )
@@ -72,11 +73,30 @@ func TestTranslateRetRegister(t *testing.T) {
 	for _, tc := range retjmpArchitectures {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			file, err := Parse(tc.arch, "TEXT ·f(SB),NOSPLIT,$0-0\n\tRET (R27)\n")
+			source := "TEXT ·f(SB),4,$0-0\nRET (R14)\n"
+			switch tc.arch {
+			case ArchARM:
+				requireARMGoAssemblerResult(t, source, true)
+			case ArchARM64:
+				// A register return is ordinary only when source really copied
+				// the caller link into its target. An uninitialized R27 is not.
+				source = "TEXT ·f(SB),4,$0-0\nMOVD R30,R27\nRET (R27)\n"
+				requireARM64GoAssemblerResult(t, source, true)
+			case ArchAMD64:
+				source = "TEXT ·f(SB),4,$0-0\nRET (AX)\n"
+				requireX86GoAssemblerResult(t, "amd64", source, false)
+			}
+			file, err := Parse(tc.arch, source)
 			if err != nil {
 				t.Fatalf("Parse() error = %v", err)
 			}
 			ir, err := Translate(file, retjmpOptions(tc.goarch))
+			if tc.arch == ArchAMD64 {
+				if err == nil {
+					t.Fatal("accepted a register RET that Go's x86 assembler rejects")
+				}
+				return
+			}
 			if err != nil {
 				t.Fatalf("Translate() error = %v", err)
 			}
@@ -87,6 +107,79 @@ func TestTranslateRetRegister(t *testing.T) {
 	}
 }
 
+func TestTranslateARM64RetRegisterRequiresCallerLinkProof(t *testing.T) {
+	const source = "TEXT ·f(SB),4,$0-0\nRET (R27)\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{
+		"aarch64-apple-darwin", "aarch64-unknown-linux-gnu",
+		"aarch64-unknown-linux-musl", "aarch64-pc-windows-msvc",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			opt := retjmpOptions("arm64")
+			opt.TargetTriple = triple
+			if _, err := Translate(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("opaque register return must require context, got %v", err)
+			}
+			linked, err := Parse(ArchARM64, "TEXT ·f(SB),4,$0-0\nMOVD R30,R27\nRET (R27)\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir, err := Translate(linked, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "register-return.ll", "register-return.o", ir)
+		})
+	}
+}
+
+func TestTranslateX86RETRejectsNonGoOperands(t *testing.T) {
+	for _, arch := range []struct {
+		arch Arch
+		name string
+	}{{ArchAMD64, "386"}, {ArchAMD64, "amd64"}} {
+		for _, operand := range []string{"(AX)", "8(SP)", "$16"} {
+			t.Run(arch.name+"/"+operand, func(t *testing.T) {
+				source := "TEXT ·f(SB),4,$0-0\nRET " + operand + "\n"
+				requireX86GoAssemblerResult(t, arch.name, source, false)
+				file, err := Parse(arch.arch, source)
+				if err != nil {
+					return
+				}
+				if _, err := Translate(file, retjmpOptions(arch.name)); err == nil {
+					t.Fatalf("accepted %s RET %s outside Go's ynone row", arch.name, operand)
+				}
+			})
+		}
+	}
+}
+
+func TestTranslateX86RETRegisterRequiresNativeTailContract(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			// Go's obj6 preprocess preserves the register and emits a JMP
+			// after its frame epilogue. Unknown AX must not become ret void.
+			const source = "TEXT ·f(SB),4,$0-0\nRET AX\n"
+			requireX86GoAssemblerResult(t, arch, source, true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if _, err := Translate(file, retjmpOptions(arch)); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("register tail return requires a native contract, got %v", err)
+			}
+		})
+	}
+}
+
 func TestTranslateRetjmpRejectsMultipleTargets(t *testing.T) {
 	for _, tc := range retjmpArchitectures {
 		tc := tc
diff --git a/runtime_c_asm_label_linux_test.go b/runtime_c_asm_label_linux_test.go
new file mode 100644
index 000000000..d35ab15fc
--- /dev/null
+++ b/runtime_c_asm_label_linux_test.go
@@ -0,0 +1,205 @@
+//go:build linux && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This is a tiny first-party C label/link oracle, not a Go ABI, instruction,
+// frame or external-library permission. Linux requires actual GNU and LLVM22
+// compilers; host selection is explicit, and missing tools never become skips.
+func TestCrossLinuxRuntimeMatrixCAsmLabelGNUExactSymbol(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("required LLVM22 clang is missing")
+	}
+	gnu, err := exec.LookPath("x86_64-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("required actual GNU x86_64 ELF compiler:", err)
+	}
+	for _, row := range []struct{ name, symbol string }{
+		{"ordinary", "framefixture.F0"},
+		{"qualified", "example.invalid/framefixture.F0"},
+		{"nested", "example.invalid/project/v2/framefixture.F0"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			directory := t.TempDir()
+			ir := filepath.Join(directory, "original.ll")
+			object := filepath.Join(directory, "original.o")
+			source := fmt.Sprintf("target triple = \"x86_64-unknown-linux-gnu\"\ndefine i64 @%s(i64 %%a, i64 %%b) {\n %%sum = add i64 %%a, %%b\n ret i64 %%sum\n}\n", strconv.Quote(row.symbol))
+			if err := os.WriteFile(ir, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if output, err := runtimeCAsmLabelCommand(t, directory, execution.llc,
+				"-O=0", "-mtriple=x86_64-unknown-linux-gnu", "-filetype=obj", ir, "-o", object); err != nil {
+				t.Fatalf("actual LLVM22 ELF object: %v\n%s", err, output)
+			}
+			runtimeCAsmLabelELF(t, object, row.symbol, true)
+			for _, caller := range []struct {
+				name, compiler, label string
+				arguments             []string
+			}{
+				{"ClangOriginalRawControl", clang, strconv.Quote(row.symbol), []string{"-target", "x86_64-unknown-linux-gnu"}},
+				{"ClangSharedEncoding", clang, runtimeCAsmLabel(row.symbol), []string{"-target", "x86_64-unknown-linux-gnu"}},
+				{"GNUSharedEncoding", gnu, runtimeCAsmLabel(row.symbol), nil},
+			} {
+				t.Run(caller.name, func(t *testing.T) {
+					cPath := filepath.Join(directory, caller.name+".c")
+					callerObject := filepath.Join(directory, caller.name+".o")
+					binary := filepath.Join(directory, caller.name)
+					code := runtimeCAsmLabelPreamble + fmt.Sprintf(`#include <stdint.h>
+extern uint64_t invoke(uint64_t, uint64_t) __asm__(%s);
+int main(void) {
+    if (invoke(17, 25) != 42) return 1;
+    if (invoke(UINT64_MAX, 20) != 19) return 2;
+    return 0;
+}
+`, caller.label)
+					if err := os.WriteFile(cPath, []byte(code), 0600); err != nil {
+						t.Fatal(err)
+					}
+					args := append([]string(nil), caller.arguments...)
+					args = append(args, "-O2", "-c", cPath, "-o", callerObject)
+					if output, err := runtimeCAsmLabelCommand(t, directory, caller.compiler, args...); err != nil {
+						t.Fatalf("actual caller must compile without renaming %q: %v\n%s", row.symbol, err, output)
+					}
+					runtimeCAsmLabelELF(t, callerObject, row.symbol, false)
+					if output, err := runtimeCAsmLabelCommand(t, directory, gnu,
+						"-no-pie", object, callerObject, "-o", binary); err != nil {
+						t.Fatalf("actual exact-symbol object link: %v\n%s", err, output)
+					}
+					runtimeCAsmLabelELF(t, binary, row.symbol, true)
+					if output := execution.run(t, binary); len(output) != 0 {
+						t.Fatalf("actual tiny numerical oracle has unexpected output: %q", output)
+					}
+					t.Logf("C_LABEL_EXACT_SYMBOL_PASS compiler=%s symbol=%q label=%s", caller.name, row.symbol, caller.label)
+				})
+			}
+			if strings.Contains(row.symbol, "/") {
+				t.Run("LegacyRawGNURejectionControl", func(t *testing.T) {
+					cPath := filepath.Join(directory, "raw-gnu.c")
+					callerObject := filepath.Join(directory, "raw-gnu.o")
+					code := fmt.Sprintf("extern unsigned long long invoke(void) __asm__(%s);\nunsigned long long caller(void) { return invoke(); }\n", strconv.Quote(row.symbol))
+					if err := os.WriteFile(cPath, []byte(code), 0600); err != nil {
+						t.Fatal(err)
+					}
+					output, err := runtimeCAsmLabelCommand(t, directory, gnu, "-O2", "-c", cPath, "-o", callerObject)
+					exit, ok := err.(*exec.ExitError)
+					if !ok || exit.ExitCode() != 1 || !strings.Contains(string(output), "invalid operands") {
+						t.Fatalf("unquoted GNU source did not retain its concrete original rejection: %v\n%s", err, output)
+					}
+					t.Logf("C_LABEL_LEGACY_GNU_REJECTION_ONLY symbol=%q source_sha256=%x\n%s", row.symbol, sha256.Sum256([]byte(code)), output)
+				})
+			}
+		})
+	}
+}
+
+func runtimeCAsmLabelCommand(t *testing.T, directory, executable string, arguments ...string) ([]byte, error) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, executable, arguments...)
+	command.Dir = directory
+	t.Logf("ACTUAL_C_LABEL_COMMAND executable=%q argv=%q cwd=%q", executable, arguments, directory)
+	return runtimeOracleCombinedOutput(ctx, command)
+}
+
+func runtimeCAsmLabelELF(t *testing.T, name, exact string, defined bool) {
+	t.Helper()
+	before, err := os.Lstat(name)
+	if err != nil || !before.Mode().IsRegular() || before.Size() <= 0 || before.Size() > 1024*1024 {
+		t.Fatalf("tiny actual ELF artifact is missing, redirected or oversized: %v", err)
+	}
+	descriptor, err := os.Open(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	opened, openErr := descriptor.Stat()
+	if openErr != nil || !os.SameFile(before, opened) || opened.Size() != before.Size() {
+		descriptor.Close()
+		t.Fatal("actual ELF inode/extent changed before bounded read", openErr)
+	}
+	data, readErr := io.ReadAll(io.LimitReader(descriptor, before.Size()+1))
+	closedInfo, statErr := descriptor.Stat()
+	closeErr := descriptor.Close()
+	current, pathErr := os.Lstat(name)
+	if readErr != nil || statErr != nil || closeErr != nil || pathErr != nil ||
+		int64(len(data)) != before.Size() || !os.SameFile(before, closedInfo) || !os.SameFile(before, current) ||
+		closedInfo.Size() != before.Size() || current.Size() != before.Size() ||
+		!closedInfo.ModTime().Equal(before.ModTime()) || !current.ModTime().Equal(before.ModTime()) ||
+		current.Mode() != before.Mode() {
+		t.Fatalf("actual ELF bytes/inode/extent/EOF did not close: %v/%v/%v/%v", readErr, statErr, closeErr, pathErr)
+	}
+	object, err := elf.NewFile(bytes.NewReader(data))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer object.Close()
+	if object.Class != elf.ELFCLASS64 || object.Data != elf.ELFDATA2LSB || object.Machine != elf.EM_X86_64 ||
+		object.Type != elf.ET_REL && object.Type != elf.ET_EXEC {
+		t.Fatalf("actual ELF object role mismatch: %#v", object.FileHeader)
+	}
+	symbols, err := object.Symbols()
+	if err != nil {
+		t.Fatal(err)
+	}
+	matches := 0
+	for _, symbol := range symbols {
+		if symbol.Name == exact {
+			matches++
+			if elf.ST_BIND(symbol.Info) != elf.STB_GLOBAL || (symbol.Section != elf.SHN_UNDEF) != defined {
+				t.Fatalf("actual symbol role changed: %#v", symbol)
+			}
+			if defined && (elf.ST_TYPE(symbol.Info) != elf.STT_FUNC || symbol.Size == 0) {
+				t.Fatalf("actual defined function has no exact executable extent: %#v", symbol)
+			}
+		}
+	}
+	if matches != 1 {
+		t.Fatalf("exact symbol %q has %d entries in complete inventory: %#v", exact, matches, symbols)
+	}
+	if !defined {
+		references := 0
+		for _, section := range object.Sections {
+			if section.Type != elf.SHT_RELA {
+				continue
+			}
+			data, err := section.Data()
+			if err != nil || len(data)%24 != 0 {
+				t.Fatalf("incomplete actual ELF64 relocation inventory: %v bytes=%d", err, len(data))
+			}
+			for offset := 0; offset < len(data); offset += 24 {
+				index := binary.LittleEndian.Uint64(data[offset+8:offset+16]) >> 32
+				if index > uint64(len(symbols)) {
+					t.Fatalf("relocation references missing symbol index %d", index)
+				}
+				if index != 0 && symbols[index-1].Name == exact {
+					references++
+				}
+			}
+		}
+		if references == 0 {
+			t.Fatalf("actual caller has no relocation to exact %q", exact)
+		}
+	}
+	inventory, err := json.Marshal(symbols)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("ACTUAL_C_LABEL_ELF path=%q bytes=%d sha256=%x exact=%q defined=%t symbols=%s", name, len(data), sha256.Sum256(data), exact, defined, inventory)
+}
diff --git a/runtime_c_asm_label_test.go b/runtime_c_asm_label_test.go
new file mode 100644
index 000000000..8dcc6672b
--- /dev/null
+++ b/runtime_c_asm_label_test.go
@@ -0,0 +1,18 @@
+package plan9asm
+
+import "strconv"
+
+// Clang binds the raw LLVM symbol, while GNU emits the label into assembler
+// text, where qualified Go symbols need another quoting layer. Keep those
+// distinct roles without adding quotes to the symbol itself.
+const runtimeCAsmLabelPreamble = `
+#ifdef __clang__
+#define PLAN9ASM_C_ASM_LABEL(name) name
+#else
+#define PLAN9ASM_C_ASM_LABEL(name) "\"" name "\""
+#endif
+`
+
+func runtimeCAsmLabel(symbol string) string {
+	return "PLAN9ASM_C_ASM_LABEL(" + strconv.Quote(symbol) + ")"
+}
diff --git a/runtime_exec_test.go b/runtime_exec_test.go
index 1464867b4..b2fc8bdac 100644
--- a/runtime_exec_test.go
+++ b/runtime_exec_test.go
@@ -1,15 +1,14 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestRuntimeExecAMD64Add(t *testing.T) {
@@ -19,7 +18,7 @@ func TestRuntimeExecAMD64Add(t *testing.T) {
 
 	llc, clang, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
 
 	src := `
@@ -76,7 +75,7 @@ func TestRuntimeExecARM64Add(t *testing.T) {
 
 	llc, clang, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
 
 	src := `
@@ -134,7 +133,7 @@ func TestRuntimeExecAMD64AddlJLE(t *testing.T) {
 
 	llc, clang, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
 
 	src := `
@@ -199,7 +198,7 @@ func TestRuntimeExecAMD64AddlJB(t *testing.T) {
 
 	llc, clang, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
 
 	src := `
@@ -263,7 +262,7 @@ func TestRuntimeExecARM64CmpBLE(t *testing.T) {
 
 	llc, clang, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
 
 	src := `
@@ -335,7 +334,7 @@ func compileAndRunRuntimeTestForTarget(t *testing.T, llc, clang, name, triple, l
 	compileAndRunRuntimeTestWithCompiler(t, llc, compiler, name, triple, ll, mainC, runPrefix)
 }
 
-func compileAndRunRuntimeTestWithCompiler(t *testing.T, llc string, compiler []string, name, triple, ll, mainC string, runPrefix []string) {
+func compileAndRunRuntimeTestWithCompiler(t *testing.T, llc string, compiler []string, name, triple, ll, mainC string, runPrefix []string, optimization ...int) {
 	t.Helper()
 	if len(compiler) == 0 {
 		t.Fatal("empty compiler command")
@@ -349,29 +348,65 @@ func compileAndRunRuntimeTestWithCompiler(t *testing.T, llc string, compiler []s
 	if err := os.WriteFile(llPath, []byte(ll), 0644); err != nil {
 		t.Fatal(err)
 	}
+	if strings.Contains(triple, "windows") {
+		// LLVM-generated Windows objects reference the conventional floating
+		// point marker normally supplied by the MSVC CRT. The MinGW clang used
+		// by CI does not provide it when linking these freestanding test objects.
+		mainC = "int _fltused = 0;\n" + mainC
+	}
 	if err := os.WriteFile(mainPath, []byte(mainC), 0644); err != nil {
 		t.Fatal(err)
 	}
+	processPath := runtimeOracleProcessSource(t, tmp)
 
-	llcCmd := exec.Command(llc, "-mtriple="+triple, "-filetype=obj", llPath, "-o", objPath)
-	if out, err := llcCmd.CombinedOutput(); err != nil {
+	llcArgs := []string{"-mtriple=" + triple, "-relocation-model=pic", "-filetype=obj"}
+	if len(optimization) > 1 || len(optimization) == 1 && optimization[0] != 0 && optimization[0] != 2 {
+		t.Fatal("runtime LLVM optimization must be exactly O0 or O2")
+	}
+	if len(optimization) == 1 {
+		llcArgs = append(llcArgs, fmt.Sprintf("-O=%d", optimization[0]))
+	}
+	llcArgs = append(llcArgs, llPath, "-o", objPath)
+	ctx, cancel := runtimeOracleStageContext(t)
+	llcCmd := exec.CommandContext(ctx, llc, llcArgs...)
+	started := time.Now()
+	out, err := runtimeOracleCombinedOutput(ctx, llcCmd)
+	t.Logf("phase=LLVM-backend elapsed=%s", time.Since(started))
+	cancel()
+	if err != nil {
 		s := string(out)
 		if llcUnsupportedTarget(s) {
-			t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+			t.Fatalf("llc does not support triple %q: %v\n%s", triple, err, strings.TrimSpace(s))
 		}
 		t.Fatalf("llc failed: %v\n%s", err, s)
 	}
 
 	compilerArgs := append([]string(nil), compiler[1:]...)
-	compilerArgs = append(compilerArgs, objPath, mainPath, "-O2", "-o", exePath)
-	compilerCmd := exec.Command(compiler[0], compilerArgs...)
-	if out, err := compilerCmd.CombinedOutput(); err != nil {
+	compilerArgs = append(compilerArgs, objPath, mainPath, processPath, "-O2", "-o", exePath)
+	if !strings.Contains(triple, "windows") {
+		// LLVM may lower floating intrinsics such as roundeven and fma to the C
+		// math library. Darwin provides those symbols through libSystem, while
+		// ELF linkers require an explicit libm dependency.
+		compilerArgs = append(compilerArgs, "-lm")
+	}
+	ctx, cancel = runtimeOracleStageContext(t)
+	compilerCmd := exec.CommandContext(ctx, compiler[0], compilerArgs...)
+	started = time.Now()
+	out, err = runtimeOracleCombinedOutput(ctx, compilerCmd)
+	t.Logf("phase=compile-link elapsed=%s", time.Since(started))
+	cancel()
+	if err != nil {
 		t.Fatalf("compile/link with %s failed: %v\n%s", compiler[0], err, string(out))
 	}
 
-	runArgs := append(append([]string(nil), runPrefix...), exePath)
-	runCmd := exec.Command(runArgs[0], runArgs[1:]...)
-	if out, err := runCmd.CombinedOutput(); err != nil {
+	runArgs := runtimeOracleGuestArguments(t, runPrefix, exePath)
+	ctx, cancel = runtimeOracleStageContext(t)
+	runCmd := exec.CommandContext(ctx, runArgs[0], runArgs[1:]...)
+	started = time.Now()
+	out, err = runtimeOracleCombinedOutput(ctx, runCmd)
+	t.Logf("phase=guest-execution elapsed=%s", time.Since(started))
+	cancel()
+	if err != nil {
 		t.Fatalf("run failed: %v\n%s", err, string(out))
 	}
 }
diff --git a/runtime_native_owner_line_endings_test.go b/runtime_native_owner_line_endings_test.go
new file mode 100644
index 000000000..4f0039136
--- /dev/null
+++ b/runtime_native_owner_line_endings_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+// Go accepts CRLF and LF identically. This copy is for source-policy parsing
+// and mutation controls only, never compiler input or source authentication.
+func normalizeNativeOwnerPolicySource(source []byte) []byte {
+	return bytes.ReplaceAll(source, []byte("\r\n"), []byte("\n"))
+}
+
+func TestNativeOwnerPolicyNormalizationIsLimitedToCRLF(t *testing.T) {
+	source := []byte("a\r\nb\rc\n")
+	before := append([]byte(nil), source...)
+	if got := string(normalizeNativeOwnerPolicySource(source)); got != "a\nb\rc\n" {
+		t.Fatal("policy normalization changed more than CRLF", got)
+	}
+	if !bytes.Equal(source, before) {
+		t.Fatal("source policy adaptation mutated original bytes")
+	}
+}
+
+func TestNativeOwnerPoliciesKeepCRLFSourceAndMutations(t *testing.T) {
+	owners := []struct {
+		name   string
+		path   string
+		policy func([]byte) error
+	}{
+		{"bit-scan", "amd64_scalar_bitscan_execution_linux_amd64_test.go", x86BitScanNativeOwnerPolicy},
+		{"bool", x86ABI0BoolNativeOwnerPath, x86ABI0BoolNativeOwnerPolicy},
+	}
+	for _, owner := range owners {
+		t.Run(owner.name, func(t *testing.T) {
+			source, err := os.ReadFile(owner.path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			lf := strings.ReplaceAll(string(source), "\r\n", "\n")
+			for _, ending := range []struct{ name, newline string }{{"LF", "\n"}, {"CRLF", "\r\n"}} {
+				t.Run(ending.name, func(t *testing.T) {
+					encode := func(text string) []byte {
+						return []byte(strings.ReplaceAll(text, "\n", ending.newline))
+					}
+					if err := owner.policy(encode(lf)); err != nil {
+						t.Fatal("Go-equivalent source line endings changed native ownership", err)
+					}
+					for _, mutation := range []string{
+						strings.Replace(lf, "linux && amd64", "darwin && amd64", 1),
+						strings.Replace(lf, "x87IA32RequireNativeHost(t)", "t.Skip(\"missing tools\")", 1),
+						strings.Replace(lf, "x87IA32RequireNativeHost(t)", "return", 1),
+					} {
+						if err := owner.policy(encode(mutation)); err == nil {
+							t.Fatal("line-ending adaptation admitted changed host/skip/early-return policy")
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/runtime_oracle_binary_output_test.go b/runtime_oracle_binary_output_test.go
new file mode 100644
index 000000000..b6a48b823
--- /dev/null
+++ b/runtime_oracle_binary_output_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestRuntimeOracleWindowsBinaryOutputSetup(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM22 clang required")
+	}
+	directory := t.TempDir()
+	// Only declarations: this checks the Windows-target constructor and its
+	// error branches, not a Windows CRT execution. The byte protocol below
+	// separately runs against the actual host CRT, including Windows CI.
+	for name, contents := range map[string]string{
+		"stdio.h":   "typedef struct FILE FILE;\nextern FILE *stdout, *stderr;\n",
+		"io.h":      "int _fileno(struct FILE*);\nint _setmode(int,int);\n",
+		"fcntl.h":   "#define _O_BINARY 32768\n",
+		"process.h": "__attribute__((noreturn)) void _exit(int);\n",
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	source := runtimeOracleProcessSource(t, directory)
+	irPath := filepath.Join(directory, "process.ll")
+	x86FloatCompareCaptureCommand(t, exec.Command(clang, "-target", "x86_64-pc-windows-msvc", "-nostdinc",
+		"-I", directory, "-O0", "-S", "-emit-llvm", source, "-o", irPath))
+	ir, err := os.ReadFile(irPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(ir)
+	if strings.Count(text, "call i32 @_setmode(") != 2 || !strings.Contains(text, "@stdout") ||
+		!strings.Contains(text, "@stderr") || !strings.Contains(text, "@llvm.global_ctors") ||
+		len(regexp.MustCompile(`icmp eq i32 [^\n]+, -1`).FindAll(ir, -1)) != 2 ||
+		!regexp.MustCompile(`call void @_exit\(i32[^\n]*125\)`).Match(ir) {
+		t.Fatalf("Windows oracle lacks checked binary stdout/stderr setup before main:\n%s", ir)
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixOracleBinaryOutput(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const source = `#include <stdio.h>
+int main(void) {
+    const unsigned char bytes[] = {0x41, 10, 13, 10, 0, 0x1a, 0xff};
+    if (fwrite(bytes, 1, sizeof(bytes), stdout) != sizeof(bytes)) return 1;
+    if (fflush(stdout) != 0) return 2;
+    return 0;
+}
+`
+	output := execution.compileAndRunLLVM(t, "binary_output", "define i32 @unused() { ret i32 0 }\n", source, "-O2")
+	if !bytes.Equal(output, []byte{0x41, 10, 13, 10, 0, 0x1a, 0xff}) {
+		t.Fatalf("oracle transport changed original stdout bytes: %x", output)
+	}
+}
diff --git a/runtime_oracle_command_audit_test.go b/runtime_oracle_command_audit_test.go
new file mode 100644
index 000000000..dbe5866c3
--- /dev/null
+++ b/runtime_oracle_command_audit_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"go/parser"
+	"go/token"
+	"reflect"
+	"testing"
+)
+
+func TestRuntimeOracleCommandAuditDistinguishesTestingRun(t *testing.T) {
+	for _, row := range []struct {
+		name    string
+		imports string
+		source  string
+		unowned []string
+	}{
+		{"test", `"testing"`, `func f(t *testing.T) { t.Run("x", func(t *testing.T) {}) }`, nil},
+		{"benchmark", `"testing"`, `func f(b *testing.B) { b.Run("x", func(b *testing.B) {}) }`, nil},
+		{"renamed_test", `"testing"`, `func f(subject *testing.T) { subject.Run("x", func(t *testing.T) {}) }`, nil},
+		{"renamed_benchmark", `"testing"`, `func f(bench *testing.B) { bench.Run("x", func(b *testing.B) {}) }`, nil},
+		{"import_alias", `unit "testing"`, `func f(bench *unit.B) { bench.Run("x", func(b *unit.B) {}) }`, nil},
+		{"nested_benchmark", `"testing"`, `func f(b *testing.B) { b.Run("x", func(nested *testing.B) { nested.Run("y", func(b *testing.B) {}) }) }`, nil},
+		{"parenthesized_test", `"testing"`, `func f(t *testing.T) { (t).Run("x", func(t *testing.T) {}) }`, nil},
+		{"command_named_test", `"os/exec"`, `func f(t *exec.Cmd) { t.Run() }`, []string{"Run"}},
+		{"command_named_benchmark", `"os/exec"`, `func f(b *exec.Cmd) { b.Run() }`, []string{"Run"}},
+		{"command_methods", `"os/exec"`, `func f(t *exec.Cmd) { t.Output(); t.CombinedOutput(); t.Start() }`, []string{"Output", "CombinedOutput", "Start"}},
+		{"shadow_test", `"testing"; "os/exec"`, `func f(t *testing.T) { { t := exec.Command("x"); t.Run() } }`, []string{"Run"}},
+		{"shadow_benchmark", `"testing"; "os/exec"`, `func f(b *testing.B) { { b := exec.Command("x"); b.Run() } }`, []string{"Run"}},
+		{"command_type_alias", `"os/exec"`, `type B = exec.Cmd; func f(t *B) { t.Run() }`, []string{"Run"}},
+		{"other_testing_package", `testing "example.invalid/testing"`, `func f(t *testing.T) { t.Run() }`, []string{"Run"}},
+		{"local_testing_name", `"os/exec"`, `func f() { testing := struct{ B *exec.Cmd }{exec.Command("x")}; testing.B.Run() }`, []string{"Run"}},
+		{"command_expression", `"os/exec"`, `func f() { exec.Command("x").Run() }`, []string{"Run"}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := "package oracle\nimport (" + row.imports + ")\n" + row.source + "\nfunc owned() { runtimeOracleCombinedOutput(nil, nil) }"
+			file, err := parser.ParseFile(token.NewFileSet(), "oracle_test.go", source, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			consumers, unowned := runtimeOracleCommandConsumers(file)
+			if consumers != 1 || !reflect.DeepEqual(unowned, row.unowned) {
+				t.Fatalf("consumers=%d, unowned=%v; want 1, %v", consumers, unowned, row.unowned)
+			}
+		})
+	}
+}
diff --git a/runtime_oracle_command_other_test.go b/runtime_oracle_command_other_test.go
new file mode 100644
index 000000000..b5b7ed296
--- /dev/null
+++ b/runtime_oracle_command_other_test.go
@@ -0,0 +1,11 @@
+//go:build !unix
+
+package plan9asm
+
+import "os/exec"
+
+// Non-Unix hosts retain the bounded pipe wait and original command failure.
+// The process-group ownership assertion is exercised on Unix runtime lanes.
+func runtimeOracleRun(command *exec.Cmd) error {
+	return command.Run()
+}
diff --git a/runtime_oracle_command_test.go b/runtime_oracle_command_test.go
new file mode 100644
index 000000000..f745c3b40
--- /dev/null
+++ b/runtime_oracle_command_test.go
@@ -0,0 +1,471 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+)
+
+// Machine-readable Go output must not include download progress from stderr.
+// Keep both streams and the actual exit through the existing bounded, owned
+// process implementation. This test helper does not relax production Run.
+func runtimeOracleMachineOutput(ctx context.Context, command *exec.Cmd) ([]byte, []byte, error) {
+	if command == nil || len(command.Args) == 0 || command.Stdin != nil || command.Stdout != nil || command.Stderr != nil {
+		return nil, nil, fmt.Errorf("machine-output oracle requires an unstarted command without stream overrides")
+	}
+	observed, err := goasmcmd.Observe(ctx, command.Dir, command.Env, command.Path, command.Args[1:]...)
+	return observed.Stdout, observed.Stderr, err
+}
+
+// Keep command output and the original exit, but never wait indefinitely for
+// an emulator retaining its parent's pipe. Unix also owns the fresh group.
+func runtimeOracleCombinedOutput(ctx context.Context, command *exec.Cmd) ([]byte, error) {
+	if ctx == nil || command == nil {
+		return nil, fmt.Errorf("runtime oracle requires a command and its context")
+	}
+	if command.Stdout != nil || command.Stderr != nil {
+		return nil, fmt.Errorf("runtime oracle command already has output writers")
+	}
+	var output bytes.Buffer
+	command.Stdout, command.Stderr = &output, &output
+	command.WaitDelay = 2 * time.Second
+	err := runtimeOracleRun(command)
+	if ctx.Err() != nil {
+		err = errors.Join(err, ctx.Err())
+	}
+	return output.Bytes(), err
+}
+
+const (
+	runtimeOracleStageTimeout        = 5 * time.Minute
+	runtimeOracleProofTimeout        = 20 * time.Minute
+	runtimeOracleStageCleanupReserve = 3 * time.Second
+)
+
+func runtimeOracleStageContext(t *testing.T) (context.Context, context.CancelFunc) {
+	t.Helper()
+	deadline, hasDeadline := t.Deadline()
+	return context.WithDeadline(context.Background(), runtimeOracleStageDeadline(time.Now(), deadline, hasDeadline))
+}
+
+func runtimeOracleStageDeadline(now, testDeadline time.Time, hasTestDeadline bool) time.Time {
+	return runtimeOracleBoundedDeadline(now, testDeadline, hasTestDeadline, runtimeOracleStageTimeout)
+}
+
+// Composed source proofs retain one context identity through owner capture,
+// independent object capture, binding and final API/runtime verification.
+// That lease spans multiple stages; it must not expire after the first stage's
+// budget. Individual subprocess/stage limits and cancellation remain intact.
+func runtimeOracleProofContext(t testing.TB) (context.Context, context.CancelFunc) {
+	t.Helper()
+	var deadline time.Time
+	var hasDeadline bool
+	if bounded, ok := t.(interface{ Deadline() (time.Time, bool) }); ok {
+		deadline, hasDeadline = bounded.Deadline()
+	}
+	return context.WithDeadline(context.Background(),
+		runtimeOracleBoundedDeadline(time.Now(), deadline, hasDeadline, runtimeOracleProofTimeout))
+}
+
+func runtimeOracleBoundedDeadline(now, testDeadline time.Time, hasTestDeadline bool, budget time.Duration) time.Time {
+	deadline := now.Add(budget)
+	if hasTestDeadline {
+		// Reserve the existing bounded pipe/group cleanup before testing's
+		// overall deadline. An exhausted budget stays expired: do not launch.
+		latest := testDeadline.Add(-runtimeOracleStageCleanupReserve)
+		if latest.Before(deadline) {
+			deadline = latest
+		}
+	}
+	return deadline
+}
+
+func TestRuntimeOracleCommandRequiresBoundContextAndOutput(t *testing.T) {
+	ctx := context.Background()
+	command := exec.CommandContext(ctx, os.Args[0])
+	for _, test := range []struct {
+		name    string
+		ctx     context.Context
+		command *exec.Cmd
+	}{
+		{name: "no context", command: command},
+		{name: "no command", ctx: ctx},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if output, err := runtimeOracleCombinedOutput(test.ctx, test.command); err == nil || len(output) != 0 {
+				t.Fatalf("unbound runtime command accepted: %v %q", err, output)
+			}
+		})
+	}
+	var existing bytes.Buffer
+	command.Stdout = &existing
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err == nil || len(output) != 0 || command.Stdout != &existing || command.Process != nil {
+		t.Fatalf("runtime command replaced an output writer or ran: %v %q", err, output)
+	}
+
+	expired, cancel := context.WithDeadline(ctx, time.Now().Add(-time.Second))
+	defer cancel()
+	command = exec.CommandContext(expired, os.Args[0])
+	if output, err := runtimeOracleCombinedOutput(expired, command); !errors.Is(err, context.DeadlineExceeded) || len(output) != 0 || command.Process != nil {
+		t.Fatalf("expired command was launched or lost its deadline: %v %q", err, output)
+	}
+}
+
+func TestRuntimeOracleCommandConsumersRetainOwnedExecution(t *testing.T) {
+	// Every Go compiler/executable/emulator command in these native oracles
+	// must use the same bounded lifecycle. Do not just fix the discovering case.
+	for _, name := range []string{
+		"go_ordinary_global_line_map_test.go",
+		"wasm_integer_count_runtime_test.go",
+		"arm64_vector_memory_indexbyte_test.go",
+		"x86_fma3_portable_access_runtime_test.go",
+		"arm_fp_symbol_offset_context_go127_test.go",
+		"arm_symbol_offset_context_go127_test.go",
+		"translate_text_context_test.go",
+		"native_c_tools_darwin_arm64_test.go",
+		"arm64_scalar_conversion_status_runtime_linux_test.go",
+		"toolchain_test.go",
+		"data_global_alignment_link_test.go",
+		"arm64_abi0_byte_region_witness_test.go",
+		"arm64_linux_syscall_effects_go127_test.go",
+		"arm64_linux_syscall_effects_runtime_linux_test.go",
+		"arm64_abi0_byte_region_role_test.go",
+		"arm64_abi0_byte_region_naming_test.go",
+		"arm64_closed_tail_stdlib_test.go",
+		"stdlib_arm64_test_helpers_test.go",
+		"llvm_object_lifecycle_unix_test.go",
+		"runtime_exec_test.go",
+		"runtime_c_asm_label_linux_test.go",
+		"runtime_oracle_fault_core_unix_test.go",
+		"amd64_cmpxchg_fault_observer_test.go",
+		"amd64_cmpxchg_fault_portability_test.go",
+		"runtime_oracle_binary_output_test.go",
+		"amd64_packed_logical_oracle_test.go",
+		"amd64_go_caller_lea_test.go",
+		"amd64_raw_operand_handoff_test.go",
+		"amd64_raw_nop_handoff_test.go",
+		"amd64_scalar_bitcount_test.go",
+		"amd64_movemask_grammar_test.go",
+		"amd64_lower_movnti_test.go",
+		"amd64_movnti_runtime_test.go",
+		"x86_implicit_divide_runtime_test.go",
+		"x86_duplicate_move_runtime_test.go",
+		"x86_duplicate_move_wig_test.go",
+		"x86_blend_minpos_native_test.go",
+		"x86_blend_minpos_mode32_binding_test.go",
+		"x86_named_half_tdd_test.go",
+		"x86_named_half_fault_tdd_test.go",
+		"x86_named_half_raw_tdd_test.go",
+		"x86_scalar_reciprocal_physical_test.go",
+		"x86_packed_reciprocal_native_read_test.go",
+		"x86_unsigned_scalar_integer_float_physical_test.go",
+		"x86_unsigned_scalar_integer_float_named_tuple_test.go",
+		"amd64_raw_packed_sign_test.go",
+		"x86_raw_abs_literal_test.go",
+		"x86_packed_shift_raw_physical_test.go",
+		"x86_vnni_raw_replay_test.go",
+		"amd64_move_half_complete_test.go",
+		"x86_move_half_fault_unix_test.go",
+		"x86_result_bitcount_test.go",
+		"amd64_scalar_lane_original_go_test.go",
+		"amd64_scalar_lane_mode32_test.go",
+		"amd64_source_integer_address_index_test.go",
+		"x86_reciprocal_sib_profile_test.go",
+		"x86_reciprocal_sib_oracle_test.go",
+		"go_translate_test.go",
+		"amd64_go_caller_lea_runtime_test.go",
+		"amd64_raw_lea_runtime_test.go",
+		"amd64_go_caller_acyclic_runtime_test.go",
+		"amd64_go_caller_counted_loop_runtime_test.go",
+		"amd64_go_caller_counted_scc_runtime_test.go",
+		"amd64_fixed_local_runtime_test.go",
+		"amd64_fixed_local_packed_runtime_test.go",
+		"amd64_fixed_local_original_test.go",
+		"amd64_scalar_float_integer_status_runtime_test.go",
+		"x86_scalar_float_integer_native_read_test.go",
+		"x86_scalar_float_integer_original_format_test.go",
+		"x86_scalar_float_integer_raw_source_test.go",
+		"x86_result_initialization_test.go",
+		"x86_result_native_pointer_alias_test.go",
+		"x86_result_auto_runtime_test.go",
+		"x86_result_typed_effects_runtime_test.go",
+		"x86_result_scalar_import_runtime_test.go",
+		"amd64_legacy_packed_move_runtime_test.go",
+		"amd64_legacy_integer_arithmetic_runtime_test.go",
+		"amd64_legacy_logical_memory_test.go",
+		"amd64_packed_word_multiply_runtime_test.go",
+		"amd64_movnti_runtime_test.go",
+		"amd64_packed_align_fault_unix_test.go",
+		"x86_implicit_divide_runtime_test.go",
+		"x86_segment_query_runtime_linux_amd64_test.go",
+		"amd64_dword_product_forms_test.go",
+		"amd64_packed_narrow_independent_runtime_test.go",
+		"x86_explicit_imul_immediate_semantics_test.go",
+		"amd64_fixed_local_frame_test.go",
+		"go_x86_numerical_read_owned_role_test.go",
+		"go_x86_numerical_read_family_test.go",
+		"go_ordinary_global_vector_read_test.go",
+		"go_ordinary_global_vector_runtime_test.go",
+		"go_x86_tls_move_runtime_linux_amd64_go127_test.go",
+		"x86_direct_tail_runtime_linux_amd64_test.go",
+		"x86_direct_tail_386_runtime_linux_amd64_test.go",
+		"x86_direct_tail_followup_runtime_linux_amd64_test.go",
+		"x86_continuation_runtime_linux_amd64_test.go",
+		"x86_abi0_bool_runtime_linux_amd64_test.go",
+		"x86_custom_helper_pointer_runtime_linux_amd64_test.go",
+		"x86_custom_helper_pointer_runtime_fixture_test.go",
+		"x86_direct_tail_object_test.go",
+		"x86_direct_tail_followup_object_test.go",
+		"amd64_tls_move_source_banks_test.go",
+		"amd64_movq_source_alias_test.go",
+		"amd64_movq_source_alias_provenance_test.go",
+		"amd64_movq_source_alias_runtime_linux_amd64_test.go",
+		"go_x86_numerical_read_runtime_test.go",
+		"go_x86_numerical_read_local_runtime_test.go",
+		"go_x86_sdk_asm_data_lifecycle_test.go",
+		"amd64_go_caller_saved_g_runtime_test.go",
+		"amd64_go_caller_logical_runtime_test.go",
+		"amd64_float_add_sub_go_oracle_test.go",
+		"amd64_float_add_sub_literal_runtime_test.go",
+		"amd64_float_compare_oracle_test.go",
+		"amd64_float_compare_original_vector_test.go",
+		"amd64_float_compare_vex_numerical_test.go",
+		"amd64_float_compare_transport_test.go",
+		"amd64_original_sysv_test.go",
+		"amd64_comi_fixture_compile_unix_test.go",
+		"amd64_packed_vector_move_aligned_oracle_unix_test.go",
+		"amd64_float_compare_preflight_portability_test.go",
+		"x86_original_floating_runtime_preflight_policy_test.go",
+		"x86_numerical_vex_gp_boundaries_test.go",
+		"amd64_conformance_native_test.go",
+		"amd64_insert_extract_native_runtime_test.go",
+		"amd64_packed_double_dword_native_test.go",
+		"amd64_packed_narrow_rules_test.go",
+		"amd64_maddword_go_oracle_test.go",
+		"amd64_madd_typed_rules_test.go",
+		"amd64_madd_typed_runtime_test.go",
+		"amd64_timestamp_runtime_test.go",
+		"amd64_cpu_query_consumers_test.go",
+		"amd64_cpu_query_runtime_unix_test.go",
+		"amd64_defined_status_numerical_test.go",
+		"amd64_defined_status_ia32_test.go",
+		"amd64_packed_string_vector_test.go",
+		"amd64_cpu_query_native_reference_test.go",
+		"amd64_cpu_query_linux_amd64_test.go",
+		"amd64_timestamp_linux_amd64_test.go",
+		"amd64_timestamp_rule_consumers_test.go",
+		"amd64_undefined_trap_consumers_test.go",
+		"amd64_undefined_trap_runtime_unix_test.go",
+		"amd64_undefined_trap_linux_amd64_test.go",
+		"amd64_ordering_hint_rule_consumers_test.go",
+		"amd64_raw_minpos_allocator_boundary_test.go",
+		"amd64_ordering_hint_runtime_test.go",
+		"amd64_stack_flags_id_transport_test.go",
+		"amd64_stack_flags_id_native_linux_test.go",
+		"amd64_stack_address_defect_test.go",
+		"amd64_cmpxchg_object_test.go",
+		"amd64_cmpxchg_original_c_runtime_test.go",
+		"amd64_cmpxchg_actual_observation_test.go",
+		"amd64_cmpxchg_original_catalogue_test.go",
+		"amd64_ordering_hint_linux_amd64_test.go",
+		"amd64_lock_scalar_rmw_linux_amd64_test.go",
+		"amd64_lock_scalar_rmw_objects_test.go",
+		"amd64_packed_add_go_oracle_test.go",
+		"amd64_packed_average_original_go_test.go",
+		"amd64_packed_average_raw_test.go",
+		"amd64_auxiliary_carry_runtime_test.go",
+		"amd64_scalar_flag_compare_af_runtime_test.go",
+		"amd64_x87_flag_compare_test.go",
+		"amd64_x87_native_ia32_test.go",
+		"amd64_packed_subtract_go_oracle_test.go",
+		"amd64_packed_integer_compare_go_oracle_test.go",
+		"amd64_packed_integer_compare_linux_amd64_test.go",
+		"amd64_go_caller_maddword_runtime_test.go",
+		"amd64_packed_sad_runtime_test.go",
+		"amd64_conditional_set_runtime_test.go",
+		"amd64_packed_sad_forms_test.go",
+		"x86_sad_raw_width_test.go",
+		"x86_sqrt_raw_contract_test.go",
+		"amd64_signed_integer_scalar_float_go_oracle_test.go",
+		"amd64_float_binary_fp_span_test.go",
+		"amd64_scalar_fp_bit_runtime_test.go",
+		"amd64_legacy_float_memory_test.go",
+		"amd64_horizontal_float_go_oracle_test.go",
+		"amd64_horizontal_integer_memory_runtime_test.go",
+		"amd64_horizontal_integer_full_alias_runtime_test.go",
+		"amd64_horizontal_integer_family_test.go",
+		"amd64_go_caller_horizontal_integer_test.go",
+		"amd64_packed_unpack_go_oracle_test.go",
+		"amd64_packed_zero_extend_runtime_test.go",
+		"amd64_packed_zero_extend_raw_axes_test.go",
+		"amd64_signed_packed_integer_float_runtime_test.go",
+		"amd64_signed_packed_integer_float_resource_unix_test.go",
+		"amd64_signed_packed_integer_float_raw_test.go",
+		"amd64_scalar_vector_literal_test.go",
+		"amd64_scalar_vector_literal_source_test.go",
+		"amd64_scalar_vector_literal_runtime_test.go",
+		"amd64_insert_extract_go_oracle_test.go",
+		"amd64_insert_extract_sdk_source_test.go",
+		"amd64_register_result_runtime_test.go",
+		"amd64_scalar_relocation_runtime_linux_test.go",
+		"amd64_go_caller_vector_zero_test.go",
+		"arm64_local_register_branch_test.go",
+		"arm64_gp_data_runtime_test.go",
+		"arm64_gp_immediate_encoding_test.go",
+		"arm64_lower_permute_test.go",
+		"arm64_lower_move_test.go",
+		"amd64_go_assembler_test.go",
+		"go_assembler_oracle_test.go",
+		"go_assembler_oracle_listing_test.go",
+		"go_assembler_defect_go127_test.go",
+		"go_assembler_oracle_infrastructure_go127_unix_test.go",
+		"arm64_private_structure_runtime_test.go",
+		"arm64_large_frame_runtime_test.go",
+		"arm64_control_gp_move_runtime_test.go",
+		"arm64_go_internal_aggregate_test.go",
+		"arm64_native_scratch_runtime_test.go",
+		"arm64_control_scalar_multiply_runtime_test.go",
+		"arm64_raw_zero_frame_runtime_test.go",
+		"arm64_raw_private_frame_runtime_test.go",
+		"wasm_packed_go_runtime_test.go",
+		"wasm_packed_node_compat_test.go",
+		"arm64_control_memory_width_runtime_test.go",
+		"arm64_raw_context_runtime_test.go",
+		"arm64_sm3_runtime_test.go",
+		"arm64_raw_self_bl_runtime_test.go",
+		"arm64_scalar_minmax_state_test.go",
+		"arm64_scalar_memory_encoding_audit_test.go",
+		"arm64_fp_pair_observation_test.go",
+		"arm64_fp_padding_runtime_test.go",
+		"arm64_result_tail_native_runtime_test.go",
+		"arm64_byte_carrier_consumer_darwin_arm64_test.go",
+		"arm64_byte_carrier_runtime_go127_test.go",
+		"arm64_byte_carrier_two_scalar_runtime_go127_test.go",
+		"arm64_byte_carrier_signed_runtime_go127_test.go",
+		"arm_word_float_scratch_runtime_linux_test.go",
+		"arm_word_float_status_runtime_linux_test.go",
+		"arm64_result_tail_compiler_audit_test.go",
+		"amd64_mov_extension_caller_test.go",
+		"amd64_mov_extension_runtime_test.go",
+		"amd64_raw_movsxd_runtime_test.go",
+		"amd64_float_compare_native_test.go",
+		"amd64_raw_insertps_mode32_test.go",
+		"arm64_scalar_writeback_test.go",
+		"arm64_barrier_encoding_go127_test.go",
+		"arm64_syscall_forms_go127_test.go",
+		"arm64_ret_source_width_test.go",
+		"arm64_opaque_preservation_observation_test.go",
+		"arm64_private_sp_helper_test.go",
+		"preprocess_macro_controls_test.go",
+		"preprocess_semantic_oracle_test.go",
+		"parser_label_prefix_test.go",
+		"parser_opcode_suffix_test.go",
+		"x86_official_binary_witness_test.go",
+		"amd64_fixed_local_conversion_tool_cache_test.go",
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			consumers, unowned := runtimeOracleCommandConsumers(file)
+			for _, method := range unowned {
+				t.Errorf("runtime command bypasses its owned lifecycle: %s", method)
+			}
+			if consumers == 0 {
+				t.Fatal("native oracle has no bounded command consumer")
+			}
+		})
+	}
+}
+
+func runtimeOracleCommandConsumers(file *ast.File) (consumers int, unowned []string) {
+	testingImports := make(map[string]bool)
+	for _, spec := range file.Imports {
+		path, err := strconv.Unquote(spec.Path.Value)
+		if err != nil || path != "testing" {
+			continue
+		}
+		name := "testing"
+		if spec.Name != nil {
+			name = spec.Name.Name
+		}
+		if name != "." && name != "_" {
+			testingImports[name] = true
+		}
+	}
+
+	ast.Inspect(file, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if function, ok := call.Fun.(*ast.Ident); ok {
+			switch function.Name {
+			case "runtimeOracleCombinedOutput", "runtimeOracleMachineOutput", "goAssemblerOracleOutput", "x86FloatCompareCaptureCommand", "numericalLocalRuntimeCommand":
+				consumers++
+				return true
+			}
+		}
+		method, ok := call.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		switch method.Sel.Name {
+		case "CombinedOutput", "Output", "Start", "Run":
+		default:
+			return true
+		}
+		if runtimeOracleTestingRun(method, testingImports) {
+			return true
+		}
+		unowned = append(unowned, method.Sel.Name)
+		return true
+	})
+	return consumers, unowned
+}
+
+func runtimeOracleTestingRun(method *ast.SelectorExpr, testingImports map[string]bool) bool {
+	if method.Sel.Name != "Run" {
+		return false
+	}
+	receiver := method.X
+	for {
+		paren, ok := receiver.(*ast.ParenExpr)
+		if !ok {
+			break
+		}
+		receiver = paren.X
+	}
+	ident, ok := receiver.(*ast.Ident)
+	if !ok || ident.Obj == nil || ident.Obj.Kind != ast.Var {
+		return false
+	}
+	// ParseFile resolves lexical objects, so a command shadowing a testing
+	// parameter cannot inherit the parameter's exemption merely by its name.
+	parameter, ok := ident.Obj.Decl.(*ast.Field)
+	if !ok {
+		return false
+	}
+	pointer, ok := parameter.Type.(*ast.StarExpr)
+	if !ok {
+		return false
+	}
+	typ, ok := pointer.X.(*ast.SelectorExpr)
+	if !ok || (typ.Sel.Name != "T" && typ.Sel.Name != "B") {
+		return false
+	}
+	pkg, ok := typ.X.(*ast.Ident)
+	return ok && pkg.Obj == nil && testingImports[pkg.Name]
+}
diff --git a/runtime_oracle_command_unix_test.go b/runtime_oracle_command_unix_test.go
new file mode 100644
index 000000000..fb0d6370d
--- /dev/null
+++ b/runtime_oracle_command_unix_test.go
@@ -0,0 +1,199 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+)
+
+func runtimeOracleRun(command *exec.Cmd) error {
+	return ownedprocess.Run(command)
+}
+
+func TestRuntimeOracleCommandFixture(t *testing.T) {
+	mode := os.Getenv("PLAN9ASM_RUNTIME_COMMAND_FIXTURE")
+	if mode == "" {
+		return
+	}
+	pidFile := os.Getenv("PLAN9ASM_RUNTIME_COMMAND_CHILD_PID")
+	if pidFile == "" {
+		t.Fatal("runtime command fixture requires its owned child identity")
+	}
+	if mode == "child" {
+		fmt.Println("owned child holds its parent's output pipe")
+		if err := os.WriteFile(pidFile+".ready", []byte(strconv.Itoa(os.Getpid())), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.Rename(pidFile+".ready", pidFile); err != nil {
+			t.Fatal(err)
+		}
+		time.Sleep(30 * time.Second)
+		return
+	}
+	if mode != "parent" && mode != "parent-exit" {
+		t.Fatalf("unknown runtime command fixture %q", mode)
+	}
+	child := exec.Command(os.Args[0], "-test.run=^TestRuntimeOracleCommandFixture$")
+	child.Env = append(os.Environ(), "PLAN9ASM_RUNTIME_COMMAND_FIXTURE=child")
+	child.Stdout, child.Stderr = os.Stdout, os.Stderr
+	if err := child.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer child.Process.Kill()
+	if mode == "parent-exit" {
+		deadline := time.Now().Add(5 * time.Second)
+		for {
+			if _, err := os.Stat(pidFile); err == nil {
+				os.Exit(23)
+			} else if !os.IsNotExist(err) {
+				t.Fatal(err)
+			}
+			if time.Now().After(deadline) {
+				t.Fatal("child did not publish its ready identity")
+			}
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+	time.Sleep(30 * time.Second)
+	if err := child.Wait(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRuntimeOracleCommandCancelsOwnedDescendant(t *testing.T) {
+	pidFile := filepath.Join(t.TempDir(), "owned-child.pid")
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleCommandFixture$")
+	command.Env = append(os.Environ(),
+		"PLAN9ASM_RUNTIME_COMMAND_FIXTURE=parent",
+		"PLAN9ASM_RUNTIME_COMMAND_CHILD_PID="+pidFile,
+	)
+	type result struct {
+		output []byte
+		err    error
+	}
+	done := make(chan result, 1)
+	go func() {
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		done <- result{output: output, err: err}
+	}()
+
+	deadline := time.NewTimer(5 * time.Second)
+	defer deadline.Stop()
+	ticker := time.NewTicker(10 * time.Millisecond)
+	defer ticker.Stop()
+	pid := 0
+	for pid == 0 {
+		select {
+		case <-ticker.C:
+			data, err := os.ReadFile(pidFile)
+			if os.IsNotExist(err) {
+				continue
+			}
+			if err != nil {
+				cancel()
+				t.Fatal(err)
+			}
+			pid, err = strconv.Atoi(string(data))
+			if err != nil || pid <= 1 {
+				cancel()
+				t.Fatalf("invalid owned child identity %q: %v", data, err)
+			}
+		case result := <-done:
+			t.Fatalf("fixture exited before its child was ready: %v\n%s", result.err, result.output)
+		case <-deadline.C:
+			cancel()
+			t.Fatal("owned child did not reach its bounded readiness witness")
+		}
+	}
+	// This exact PID came from this invocation's private readiness file. The
+	// cleanup also makes the unfixed RED safe: never signal the test's group.
+	child, err := os.FindProcess(pid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer child.Kill()
+	cancel()
+	select {
+	case result := <-done:
+		if !errors.Is(result.err, context.Canceled) {
+			t.Fatalf("cancellation lost its error: %v\n%s", result.err, result.output)
+		}
+		if !strings.Contains(string(result.output), "owned child holds") {
+			t.Fatalf("runtime child output was discarded: %q", result.output)
+		}
+	case <-time.After(3 * time.Second):
+		// Unblock the legacy CombinedOutput before reporting its actual RED.
+		_ = child.Kill()
+		select {
+		case <-done:
+		case <-time.After(2 * time.Second):
+			t.Error("parent did not return even after exact-owned child cleanup")
+		}
+		t.Fatal("canceled runtime command left its child holding the output pipe")
+	}
+	runtimeOracleAssertChildStopped(t, pid)
+}
+
+func TestRuntimeOracleCommandCleansDescendantAfterParentExit(t *testing.T) {
+	pidFile := filepath.Join(t.TempDir(), "owned-child.pid")
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleCommandFixture$")
+	command.Env = append(os.Environ(),
+		"PLAN9ASM_RUNTIME_COMMAND_FIXTURE=parent-exit",
+		"PLAN9ASM_RUNTIME_COMMAND_CHILD_PID="+pidFile,
+	)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	data, readErr := os.ReadFile(pidFile)
+	if readErr != nil {
+		t.Fatalf("parent exit lost its owned child identity: %v", readErr)
+	}
+	pid, parseErr := strconv.Atoi(string(data))
+	if parseErr != nil || pid <= 1 {
+		t.Fatalf("invalid owned child identity %q: %v", data, parseErr)
+	}
+	child, findErr := os.FindProcess(pid)
+	if findErr != nil {
+		t.Fatal(findErr)
+	}
+	defer child.Kill()
+	var exit *exec.ExitError
+	if ctx.Err() != nil || !errors.As(err, &exit) || exit.ExitCode() != 23 {
+		t.Fatalf("parent exit was lost or cleanup exceeded its bound: %v\n%s", err, output)
+	}
+	if !strings.Contains(string(output), "owned child holds") {
+		t.Fatalf("parent exit lost its child's output: %q", output)
+	}
+	runtimeOracleAssertChildStopped(t, pid)
+}
+
+func runtimeOracleAssertChildStopped(t *testing.T, pid int) {
+	t.Helper()
+	checkCtx, checkCancel := context.WithTimeout(context.Background(), time.Second)
+	defer checkCancel()
+	state, err := exec.CommandContext(checkCtx, "/bin/ps", "-p", strconv.Itoa(pid), "-o", "stat=").CombinedOutput()
+	if checkCtx.Err() != nil {
+		t.Fatal(checkCtx.Err())
+	}
+	if strings.TrimSpace(string(state)) == "" {
+		var exit *exec.ExitError
+		if !errors.As(err, &exit) || exit.ExitCode() != 1 {
+			t.Fatalf("unknown owned child observation: %v %q", err, state)
+		}
+	} else if err != nil || len(strings.Fields(string(state))) != 1 || strings.TrimSpace(string(state))[0] != 'Z' {
+		t.Fatalf("owned child is still live or has unknown state: %v %q", err, state)
+	}
+}
diff --git a/runtime_oracle_dumpable_linux_test.go b/runtime_oracle_dumpable_linux_test.go
new file mode 100644
index 000000000..7f5092b5d
--- /dev/null
+++ b/runtime_oracle_dumpable_linux_test.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixOracleDisablesCorePipeCollection(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc and clang are required")
+	}
+	const ir = "define i32 @oracle_value() { ret i32 17 }\n"
+	const source = `
+#include <sys/prctl.h>
+#include <sys/wait.h>
+#include <unistd.h>
+extern int oracle_value(void);
+int main(void) {
+    if (prctl(PR_GET_DUMPABLE, 0L, 0L, 0L, 0L) != 0) return 1;
+    pid_t child = fork();
+    if (child < 0) return 2;
+    if (child == 0) {
+        if (prctl(PR_GET_DUMPABLE, 0L, 0L, 0L, 0L) != 0) _exit(3);
+        _exit(oracle_value() == 17 ? 0 : 4);
+    }
+    int status;
+    if (waitpid(child, &status, 0) != child) return 5;
+    return WIFEXITED(status) ? WEXITSTATUS(status) : 6;
+}
+`
+	t.Run("generic", func(t *testing.T) {
+		compileAndRunRuntimeTest(t, llc, clang, "dumpable", ir, source)
+	})
+	t.Run("comparison", func(t *testing.T) {
+		execution := x86FloatCompareExecution{
+			llc: llc, triple: testTargetTriple(runtime.GOOS, runtime.GOARCH),
+			compiler: []string{clang},
+		}
+		execution.compileAndRunLLVM(t, "dumpable", ir, source, "-O2")
+	})
+}
diff --git a/runtime_oracle_fault_core_unix_test.go b/runtime_oracle_fault_core_unix_test.go
new file mode 100644
index 000000000..344cc04db
--- /dev/null
+++ b/runtime_oracle_fault_core_unix_test.go
@@ -0,0 +1,230 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func runtimeOracleFaultC(t *testing.T, name string) string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var found []string
+	ast.Inspect(file, func(node ast.Node) bool {
+		literal, ok := node.(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		value, err := strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.Contains(value, "fork()") {
+			found = append(found, value)
+		}
+		return true
+	})
+	if len(found) != 1 {
+		t.Fatalf("%s: expected one actual fault-child C source, found %d", name, len(found))
+	}
+	return found[0]
+}
+
+func runtimeOracleFaultCorePolicy(source string) error {
+	child := regexp.MustCompile(`if\s*\(\s*(?:child\s*==\s*0|!child)\s*\)\s*\{`)
+	policy := regexp.MustCompile(
+		`^\s*struct\s+rlimit\s+no_core\s*=\s*\{\s*0\s*,\s*0\s*\}\s*;` +
+			`\s*if\s*\(\s*setrlimit\s*\(\s*RLIMIT_CORE\s*,\s*&no_core\s*\)` +
+			`\s*\)\s*_exit\s*\(\s*120\s*\)\s*;`)
+	branches := child.FindAllStringIndex(source, -1)
+	// This is a bounded check for the actual C fixture templates, not a C
+	// parser. An unregistered child predicate must not hide another fork.
+	fork := regexp.MustCompile(`\bfork\s*\(\s*\)`)
+	forks := fork.FindAllStringIndex(source, -1)
+	if len(branches) == 0 || len(branches) != len(forks) {
+		return fmt.Errorf("each actual fork needs one registered child branch: forks=%d branches=%d", len(forks), len(branches))
+	}
+	for index, branch := range branches {
+		if !policy.MatchString(source[branch[1]:]) {
+			return fmt.Errorf("fault child %d must first set both core limits to zero and check failure before invoking its oracle", index+1)
+		}
+	}
+	return nil
+}
+
+func TestRuntimeOracleFaultChildrenDisableCoreDumps(t *testing.T) {
+	for _, name := range []string{
+		"amd64_packed_shift_native_count_runtime_test.go",
+		"amd64_undefined_trap_runtime_unix_test.go",
+		"amd64_cpu_query_runtime_unix_test.go",
+		"amd64_dword_product_fault_runtime_unix_test.go",
+	} {
+		t.Run(name, func(t *testing.T) {
+			source := runtimeOracleFaultC(t, name)
+			if err := runtimeOracleFaultCorePolicy(source); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleFaultCorePolicyChecksEveryChild(t *testing.T) {
+	const valid = `struct rlimit no_core = {0, 0};
+if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+oracle();
+`
+	branch := func(condition, body string) string {
+		return "pid_t child = fork();\nif (" + condition + ") {\n" + body + "}\n"
+	}
+	first := branch("child == 0", valid)
+	cases := []struct {
+		name   string
+		source string
+		valid  bool
+	}{
+		{"no_child", "", false},
+		{"one_checked_child", first, true},
+		{"two_checked_children", first + branch("!child", valid), true},
+		{"three_checked_children", first + first + first, true},
+		{"first_missing_policy", branch("child == 0", "oracle();\n") + first, false},
+		{"second_missing_policy", first + branch("child == 0", "oracle();\n"), false},
+		{"third_missing_policy", first + first + branch("!child", "oracle();\n"), false},
+		{"second_unchecked_limit", first + branch("!child", "struct rlimit no_core = {0, 0};\nsetrlimit(RLIMIT_CORE, &no_core);\noracle();\n"), false},
+		{"second_nonzero_soft_limit", first + branch("!child", strings.Replace(valid, "{0, 0}", "{1, 0}", 1)), false},
+		{"second_nonzero_hard_limit", first + branch("!child", strings.Replace(valid, "{0, 0}", "{0, 1}", 1)), false},
+		{"second_wrong_resource", first + branch("!child", strings.Replace(valid, "RLIMIT_CORE", "RLIMIT_CPU", 1)), false},
+		{"second_wrong_failure_exit", first + branch("!child", strings.Replace(valid, "_exit(120)", "_exit(0)", 1)), false},
+		{"second_late_policy", first + branch("!child", "oracle();\n"+valid), false},
+		{"second_unregistered_branch", first + branch("child != 0", valid), false},
+	}
+	for _, test := range cases {
+		t.Run(test.name, func(t *testing.T) {
+			err := runtimeOracleFaultCorePolicy(test.source)
+			if (err == nil) != test.valid {
+				t.Fatalf("fault-child resource policy: err=%v, want valid=%t", err, test.valid)
+			}
+		})
+	}
+}
+
+// Execute the actual legacy shift fault helper with a harmless callback. Inheriting
+// a nonzero core limit fails without raising a signal or creating a core file.
+func TestRuntimeOracleFaultChildCoreLimitInheritance(t *testing.T) {
+	_, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 tools required")
+	}
+	source := x86PackedShiftLegacyCountCHeader +
+		runtimeOracleFaultC(t, "amd64_packed_shift_native_count_runtime_test.go")
+	source += `
+#include <sys/resource.h>
+
+static void inspect_limits(uint8_t *out, const uint8_t *data, const uint8_t *count, uint64_t seed) {
+    (void)out;
+    (void)data;
+    (void)count;
+    (void)seed;
+    struct rlimit limit;
+    if (getrlimit(RLIMIT_CORE, &limit) || limit.rlim_cur || limit.rlim_max) _exit(91);
+    _exit(0);
+}
+
+int main(int argc, char **argv) {
+    struct rlimit original, parent, after;
+    if (getrlimit(RLIMIT_CORE, &original)) return 10;
+    parent = original;
+    if (argc > 1) {
+        parent.rlim_cur = parent.rlim_max = 0;
+    } else {
+        parent.rlim_cur = parent.rlim_max < 4096 ? parent.rlim_max : 4096;
+    }
+    if (setrlimit(RLIMIT_CORE, &parent)) return 11;
+    uint8_t count[32] = {0};
+    int status = observe_count(inspect_limits, 0, 0, 0, count, 0);
+    int result = status < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0;
+    if (getrlimit(RLIMIT_CORE, &after) || after.rlim_cur != parent.rlim_cur ||
+        after.rlim_max != parent.rlim_max) return 13;
+    if (argc == 1 && setrlimit(RLIMIT_CORE, &original)) return 14;
+    fprintf(stdout, "parent=%llu/%llu child-status=%d\n",
+        (unsigned long long)parent.rlim_cur, (unsigned long long)parent.rlim_max, result);
+    return result;
+}
+`
+	directory := t.TempDir()
+	cPath, executable := filepath.Join(directory, "core.c"), filepath.Join(directory, "core")
+	if err := os.WriteFile(cPath, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(ctx, runtimeOracleNativeCCommand(t, ctx, clang, "-O2", cPath, "-o", executable))
+	cancel()
+	if err != nil {
+		t.Fatalf("compile actual fault helper: %v\n%s", err, output)
+	}
+	for _, mode := range []string{"inherited", "hard-zero"} {
+		t.Run(mode, func(t *testing.T) {
+			var arguments []string
+			if mode == "hard-zero" {
+				arguments = append(arguments, mode)
+			}
+			ctx, cancel := runtimeOracleStageContext(t)
+			output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, executable, arguments...))
+			cancel()
+			if err != nil {
+				t.Fatalf("actual child resource observation: %v\n%s", err, output)
+			}
+			t.Log(strings.TrimSpace(string(output)))
+		})
+	}
+}
+
+// CMPXCHG launches the C driver directly instead of forking. Exercise that
+// driver's actual entry setup with a harmless callback, before any real fault.
+func TestX86CMPXCHGFaultChildCoreLimit(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const callback = `
+static void inspect_limits(unsigned char *p) {
+    struct rlimit limit;
+    if (getrlimit(RLIMIT_CORE, &limit) || limit.rlim_cur || limit.rlim_max) exit(91);
+    *p = 4;
+}
+`
+	source := fmt.Sprintf(x86CMPXCHGFaultReference, "", callback,
+		"{inspect_limits, inspect_limits, 1, 0},")
+	executable := execution.compileLLVM(t, "cmpxchg-core-limit", "", source, "-O2")
+	for _, original := range []int{0, 1} {
+		got, err := x86CMPXCHGObserveFault(t, execution, executable, 0, 0, original)
+		if err != nil || got != "return" {
+			t.Fatalf("actual direct child core limits, original=%d: %s, %v", original, got, err)
+		}
+	}
+}
+
+func TestX86MemoryFaultChildCoreLimit(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const callback = `
+static int inspect_limits(const uint8_t *p) {
+    struct rlimit limit;
+    if (getrlimit(RLIMIT_CORE, &limit) || limit.rlim_cur || limit.rlim_max) return 91;
+    return *p != (uint8_t)((page - 4) * 13 + 17);
+}
+`
+	source := x86MemoryFaultDriver(callback, "{inspect_limits, 4, 3},")
+	executable := execution.compileLLVM(t, "memory-core-limit", "", source, "-O2")
+	if got := x86ObserveMemoryFault(t, execution, executable, 0, 2, 0); got != "return" {
+		t.Fatalf("direct child did not retain zero core limits: %s", got)
+	}
+}
diff --git a/runtime_oracle_fault_observation_test.go b/runtime_oracle_fault_observation_test.go
new file mode 100644
index 000000000..3753d1b17
--- /dev/null
+++ b/runtime_oracle_fault_observation_test.go
@@ -0,0 +1,36 @@
+package plan9asm
+
+// Consume expected hardware faults in the guest, rather than asking nested
+// emulators to core-dump or relay an unhandled signal through fork/waitpid.
+// The handler admits only a synchronous memory fault inside the exact protected
+// region. A normal return, user-raised signal or fault at another address fails.
+// Keep these C bytes shared across current-source and Go20-compatible oracles.
+const numericalRuntimeFaultObservationC = `
+#include <stdatomic.h>
+static _Atomic(uintptr_t) numerical_fault_first, numerical_fault_last;
+static void numerical_fault_observe(int signal_number, siginfo_t *info, void *context) {
+    (void)context;
+    uintptr_t address = info ? (uintptr_t)info->si_addr : 0;
+    if (!info || info->si_signo != signal_number || info->si_code <= 0 ||
+        (signal_number != SIGSEGV && signal_number != SIGBUS) ||
+        address < atomic_load_explicit(&numerical_fault_first,memory_order_relaxed) ||
+        address >= atomic_load_explicit(&numerical_fault_last,memory_order_relaxed)) _exit(121);
+    _exit(123);
+}
+static void numerical_fault_begin(void *region, size_t bytes) {
+    uintptr_t first=(uintptr_t)region, last=first+bytes;
+    if (!bytes || last<first || !atomic_is_lock_free(&numerical_fault_first) ||
+        !atomic_is_lock_free(&numerical_fault_last)) _exit(122);
+    atomic_store_explicit(&numerical_fault_first,first,memory_order_relaxed);
+    atomic_store_explicit(&numerical_fault_last,last,memory_order_relaxed);
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    action.sa_sigaction = numerical_fault_observe;
+    action.sa_flags = SA_SIGINFO;
+    if (sigemptyset(&action.sa_mask) || sigaction(SIGSEGV, &action, 0) ||
+        sigaction(SIGBUS, &action, 0)) _exit(122);
+}
+static int numerical_fault_status(int status) {
+    return WIFEXITED(status) && WEXITSTATUS(status) == 123;
+}
+`
diff --git a/runtime_oracle_go_json_test.go b/runtime_oracle_go_json_test.go
new file mode 100644
index 000000000..2e1e68b82
--- /dev/null
+++ b/runtime_oracle_go_json_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+func TestRuntimeOracleGoJSONRetainsSeparateDownloadDiagnostics(t *testing.T) {
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleGoJSONFixture$")
+	command.Env = append(os.Environ(), "PLAN9ASM_GO_JSON_FIXTURE=1")
+	output, diagnostics, err := runtimeOracleMachineOutput(ctx, command)
+	if err != nil || string(diagnostics) != "go: downloading fixture.invalid/module v1.0.0\n" {
+		t.Fatalf("actual command outcome or diagnostics lost: %v: %q", err, diagnostics)
+	}
+	var actual struct{ ImportPath string }
+	if err := json.Unmarshal(output, &actual); err != nil || actual.ImportPath != "fixture.invalid/module" {
+		t.Fatalf("download diagnostics contaminated machine stdout: %v: %q", err, output)
+	}
+}
+
+func TestRuntimeOracleGoJSONFixture(t *testing.T) {
+	if os.Getenv("PLAN9ASM_GO_JSON_FIXTURE") != "1" {
+		return
+	}
+	_, _ = os.Stderr.WriteString("go: downloading fixture.invalid/module v1.0.0\n")
+	_, _ = os.Stdout.WriteString(`{"ImportPath":"fixture.invalid/module"}`)
+	os.Exit(0)
+}
diff --git a/runtime_oracle_guest_argument_test.go b/runtime_oracle_guest_argument_test.go
new file mode 100644
index 000000000..b20dc09c9
--- /dev/null
+++ b/runtime_oracle_guest_argument_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestRuntimeOracleGuestArgumentConstruction(t *testing.T) {
+	arguments := []string{"numeric", "with space", "", "--option", "quote\"backslash\\", "中文"}
+	for _, runner := range []string{"", "arch", "qemu-aarch64", "qemu-arm", "qemu-i386"} {
+		name := runner
+		if name == "" {
+			name = "native"
+		}
+		t.Run(name, func(t *testing.T) {
+			var prefix []string
+			if runner == "arch" {
+				prefix = []string{"arch", "-x86_64"}
+			} else if runner != "" {
+				prefix = []string{runner, "-L", "/guest-sysroot", "-cpu", "max"}
+			}
+			for _, input := range [][]string{nil, arguments} {
+				beforePrefix := append([]string(nil), prefix...)
+				beforeArguments := append([]string(nil), input...)
+				identity := runtimeOraclePinnedQEMUSHA(runner)
+				got, err := runtimeOracleGuestArgumentsForIdentity(prefix, "/guest-program", input, identity)
+				if err != nil {
+					t.Fatal(err)
+				}
+				want := append(append([]string(nil), prefix...), "/guest-program")
+				if identity != "" {
+					want = append(want, "/guest-program")
+				}
+				want = append(want, input...)
+				if !reflect.DeepEqual(got, want) {
+					t.Fatalf("guest arguments got %q want %q", got, want)
+				}
+				if !reflect.DeepEqual(prefix, beforePrefix) || !reflect.DeepEqual(input, beforeArguments) {
+					t.Fatal("guest argument construction changed its inputs")
+				}
+				got[0] = "changed-result"
+				if !reflect.DeepEqual(prefix, beforePrefix) || !reflect.DeepEqual(input, beforeArguments) {
+					t.Fatal("guest command aliases its inputs")
+				}
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleGuestArgumentIdentityRejection(t *testing.T) {
+	for _, test := range []struct {
+		name, executable, identity string
+		prefix                     []string
+	}{
+		{"empty_executable", "", "", nil},
+		{"empty_runner", "/guest", "", []string{""}},
+		{"missing_identity", "/guest", "", []string{"qemu-aarch64"}},
+		{"version_is_not_identity", "/guest", "qemu-aarch64 version 10.2.3", []string{"qemu-aarch64"}},
+		{"unknown_identity", "/guest", strings.Repeat("0", 64), []string{"qemu-aarch64"}},
+		{"different_arch_identity", "/guest", runtimeOraclePinnedQEMUSHA("qemu-arm"), []string{"qemu-aarch64"}},
+		{"unknown_runner", "/guest", runtimeOraclePinnedQEMUSHA("qemu-arm"), []string{"qemu-other"}},
+		{"native_with_guest_identity", "/guest", runtimeOraclePinnedQEMUSHA("qemu-arm"), nil},
+		{"rosetta_with_guest_identity", "/guest", runtimeOraclePinnedQEMUSHA("qemu-arm"), []string{"arch", "-x86_64"}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if command, err := runtimeOracleGuestArgumentsForIdentity(test.prefix, test.executable, nil, test.identity); err == nil || command != nil {
+				t.Fatalf("invalid identity accepted: %q, %v", command, err)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleGuestRunnerIdentity(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "qemu-aarch64")
+	// A fake name/version is explicitly an invalid fixture, not native proof.
+	for _, content := range []string{"qemu-aarch64 version 10.2.3\n", "changed runner bytes"} {
+		if err := os.WriteFile(path, []byte(content), 0600); err != nil {
+			t.Fatal(err)
+		}
+		identity, err := runtimeOracleGuestRunnerSHA(path)
+		if err != nil || identity != fmt.Sprintf("%x", sha256.Sum256([]byte(content))) {
+			t.Fatalf("exact runner digest: %q, %v", identity, err)
+		}
+		if command, err := runtimeOracleGuestArgumentsForIdentity([]string{path}, "/guest", nil, identity); err == nil || command != nil {
+			t.Fatal("forged or changed runner was accepted")
+		}
+	}
+	for _, invalid := range []string{filepath.Join(dir, "missing"), dir, filepath.Join(dir, "empty"), filepath.Join(dir, "oversize")} {
+		if filepath.Base(invalid) == "empty" {
+			if err := os.WriteFile(invalid, nil, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if filepath.Base(invalid) == "oversize" {
+			file, err := os.Create(invalid)
+			if err != nil {
+				t.Fatal(err)
+			}
+			truncateErr := file.Truncate((64 << 20) + 1)
+			closeErr := file.Close()
+			if truncateErr != nil || closeErr != nil {
+				t.Fatalf("invalid fixture: %v, %v", truncateErr, closeErr)
+			}
+		}
+		if identity, err := runtimeOracleGuestRunnerSHA(invalid); err == nil || identity != "" {
+			t.Fatalf("invalid runner file accepted: %q, %v", identity, err)
+		}
+	}
+}
+
+func TestRuntimeOracleGuestNativeArguments(t *testing.T) {
+	arguments := []string{"-test.run=^TestRuntimeOracleGuestArgumentFixture$", "--", "numeric", "with space", "", "--option", "quote\"backslash\\", "中文"}
+	command := runtimeOracleGuestArguments(t, nil, os.Args[0], arguments...)
+	ctx, cancel := runtimeOracleStageContext(t)
+	child := exec.CommandContext(ctx, command[0], command[1:]...)
+	child.Env = append(os.Environ(), "PLAN9ASM_GUEST_ARGUMENT_FIXTURE=1")
+	output, err := runtimeOracleCombinedOutput(ctx, child)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual native Go argument fixture: %v\n%s", err, output)
+	}
+	var got []string
+	if err := json.Unmarshal(output, &got); err != nil || !reflect.DeepEqual(got, command) {
+		t.Fatalf("actual native argv: got %q want %q, %v", got, command, err)
+	}
+}
+
+func TestRuntimeOracleGuestArgumentFixture(t *testing.T) {
+	if os.Getenv("PLAN9ASM_GUEST_ARGUMENT_FIXTURE") != "1" {
+		return
+	}
+	if err := json.NewEncoder(os.Stdout).Encode(os.Args); err != nil {
+		t.Fatal(err)
+	}
+	os.Exit(0)
+}
diff --git a/runtime_oracle_guest_linux_amd64_test.go b/runtime_oracle_guest_linux_amd64_test.go
new file mode 100644
index 000000000..e372f0207
--- /dev/null
+++ b/runtime_oracle_guest_linux_amd64_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixQEMUOriginalGoAndCArguments(t *testing.T) {
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("required Linux/amd64 QEMU execution counterpart")
+	}
+	arguments := []string{"numeric", "with space", "", "--option", "quote\"backslash\\", "中文"}
+	for _, target := range []struct {
+		arch, compiler, qemu, sysroot string
+	}{
+		{"arm64", "aarch64-linux-gnu-gcc", "qemu-aarch64", "/usr/aarch64-linux-gnu"},
+		{"arm", "arm-linux-gnueabihf-gcc", "qemu-arm", "/usr/arm-linux-gnueabihf"},
+		{"386", "i686-linux-gnu-gcc", "qemu-i386", "/usr/i686-linux-gnu"},
+	} {
+		t.Run(target.arch, func(t *testing.T) {
+			for _, tool := range []string{target.compiler, target.qemu} {
+				if _, err := exec.LookPath(tool); err != nil {
+					t.Fatal("required guest tool:", err)
+				}
+			}
+			dir := t.TempDir()
+			goSource := `package main
+import (
+    "encoding/json"
+    "os"
+)
+func main() {
+    if err := json.NewEncoder(os.Stdout).Encode(os.Args); err != nil {
+        panic(err)
+    }
+}
+`
+			for name, content := range map[string]string{
+				"go.mod":  "module example.com/guest-arguments\n\ngo 1.20\n",
+				"main.go": goSource,
+			} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			goProgram := filepath.Join(dir, "original-go")
+			ctx, cancel := runtimeOracleStageContext(t)
+			build := exec.CommandContext(ctx, "go", "build", "-p=2", "-o", goProgram, ".")
+			build.Dir = dir
+			build.Env = append(os.Environ(), "GOWORK=off", "GOTOOLCHAIN=local", "CGO_ENABLED=0",
+				"GOOS=linux", "GOARCH="+target.arch, "GOARM=7")
+			output, err := runtimeOracleCombinedOutput(ctx, build)
+			cancel()
+			if err != nil {
+				t.Fatalf("actual original Go guest build: %v\n%s", err, output)
+			}
+			prefix := []string{target.qemu, "-L", target.sysroot}
+			command := runtimeOracleGuestArguments(t, prefix, goProgram, arguments...)
+			ctx, cancel = runtimeOracleStageContext(t)
+			output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, command[0], command[1:]...))
+			cancel()
+			if err != nil {
+				t.Fatalf("original Go guest execution: %v\n%s", err, output)
+			}
+			want := append([]string{goProgram}, arguments...)
+			expected, err := json.Marshal(want)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.TrimSpace(string(output)) != string(expected) {
+				t.Errorf("original Go argv got %s want %s", output, expected)
+			}
+
+			cProgram := filepath.Join(dir, "original-c")
+			var constants strings.Builder
+			for _, argument := range append([]string{cProgram}, arguments...) {
+				fmt.Fprintf(&constants, "    %q,\n", argument)
+			}
+			cSource := fmt.Sprintf(`#include <stdio.h>
+#include <string.h>
+static const char *expected[] = {
+%s};
+int main(int argc, char **argv) {
+    int count = sizeof(expected) / sizeof(expected[0]);
+    if (argc != count) {
+        fprintf(stderr, "argc got=%%d want=%%d\n", argc, count);
+        return 1;
+    }
+    for (int i = 0; i < count; i++) {
+        if (strcmp(argv[i], expected[i])) {
+            fprintf(stderr, "argv[%%d] got=%%s want=%%s\n", i, argv[i], expected[i]);
+            return 2;
+        }
+    }
+    return 0;
+}
+`, constants.String())
+			cPath := filepath.Join(dir, "main.c")
+			if err := os.WriteFile(cPath, []byte(cSource), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel = runtimeOracleStageContext(t)
+			output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx,
+				target.compiler, cPath, "-O2", "-o", cProgram))
+			cancel()
+			if err != nil {
+				t.Fatalf("original C guest build: %v\n%s", err, output)
+			}
+			command = runtimeOracleGuestArguments(t, prefix, cProgram, arguments...)
+			ctx, cancel = runtimeOracleStageContext(t)
+			output, err = runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, command[0], command[1:]...))
+			cancel()
+			if err != nil {
+				t.Errorf("original C guest argv: %v\n%s", err, output)
+			}
+		})
+	}
+}
diff --git a/runtime_oracle_guest_test.go b/runtime_oracle_guest_test.go
new file mode 100644
index 000000000..1d464ce0d
--- /dev/null
+++ b/runtime_oracle_guest_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The checksum-pinned Tonistiigi bundle preserves a separate argv[0] even when
+// invoked explicitly, not only through binfmt. Authenticate that transport;
+// neither an executable's name nor a version banner grants this behavior.
+// These are test runners, not production ISA or calling-convention permissions.
+// Match the linux-amd64 deploy/v10.2.3-68 archive pinned by install-ci-qemu.sh.
+func runtimeOraclePinnedQEMUSHA(name string) string {
+	switch name {
+	case "qemu-aarch64":
+		return "52a2e9257e43c59abd033f643f05bed9ee17a2b0f345d742da11b321b9bd548d"
+	case "qemu-arm":
+		return "8c99a0953bdf190626889268b4f8e8cff8160bb7af82fb70c237981a00dc9c02"
+	case "qemu-i386":
+		return "3d5369c56c3b53ffbf3c6e9e9729e949a2bf8817701ba2c33174306184b01bb0"
+	}
+	return ""
+}
+
+func runtimeOracleGuestArguments(t *testing.T, prefix []string, executable string, arguments ...string) []string {
+	t.Helper()
+	identity := ""
+	if len(prefix) != 0 && strings.HasPrefix(filepath.Base(prefix[0]), "qemu-") {
+		path, err := exec.LookPath(prefix[0])
+		if err != nil {
+			t.Fatal("required guest runner:", err)
+		}
+		identity, err = runtimeOracleGuestRunnerSHA(path)
+		if err != nil {
+			t.Fatal("guest runner identity:", err)
+		}
+	}
+	command, err := runtimeOracleGuestArgumentsForIdentity(prefix, executable, arguments, identity)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return command
+}
+
+func runtimeOracleGuestArgumentsForIdentity(prefix []string, executable string, arguments []string, identity string) ([]string, error) {
+	if executable == "" || (len(prefix) != 0 && prefix[0] == "") {
+		return nil, fmt.Errorf("empty guest executable or runner")
+	}
+	preserveArgv0 := false
+	if len(prefix) != 0 && strings.HasPrefix(filepath.Base(prefix[0]), "qemu-") {
+		name := filepath.Base(prefix[0])
+		pinned := runtimeOraclePinnedQEMUSHA(name)
+		if pinned == "" || identity != pinned {
+			return nil, fmt.Errorf("unauthenticated guest runner %q: SHA256 %q", name, identity)
+		}
+		preserveArgv0 = true
+	} else if identity != "" {
+		return nil, fmt.Errorf("unexpected QEMU identity for native execution")
+	}
+	command := append([]string(nil), prefix...)
+	command = append(command, executable)
+	if preserveArgv0 {
+		command = append(command, executable)
+	}
+	return append(command, arguments...), nil
+}
+
+func runtimeOracleGuestRunnerSHA(path string) (string, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+	const limit = 64 << 20
+	before, err := file.Stat()
+	if err != nil {
+		return "", err
+	}
+	if !before.Mode().IsRegular() || before.Size() <= 0 || before.Size() > limit {
+		return "", fmt.Errorf("guest runner must be a nonempty regular file of at most %d bytes", limit)
+	}
+	hash := sha256.New()
+	size, err := io.Copy(hash, io.LimitReader(file, limit+1))
+	if err != nil {
+		return "", err
+	}
+	after, err := file.Stat()
+	if err != nil {
+		return "", err
+	}
+	if size != before.Size() || after.Size() != before.Size() || !after.ModTime().Equal(before.ModTime()) {
+		return "", fmt.Errorf("guest runner changed while authenticating")
+	}
+	if err := file.Close(); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
diff --git a/runtime_oracle_module_version_test.go b/runtime_oracle_module_version_test.go
new file mode 100644
index 000000000..6fe7a7c97
--- /dev/null
+++ b/runtime_oracle_module_version_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestRuntimeOracleModulesUseSupportedLanguageMinimum(t *testing.T) {
+	// These are first-party, Go 1.20-compatible runtime fixtures. Their language
+	// directive must not force a newer compiler than the SDK selected by the
+	// test matrix. External modules and feature-profile originals are separate.
+	for _, source := range []string{
+		"arm64_go_internal_aggregate_test.go",
+		"arm64_raw_private_frame_runtime_test.go",
+		"arm_conditional_flags_runtime_test.go",
+		"arm_kernel_continuation_runtime_test.go",
+		"arm_kernel_helper_test.go",
+		"arm_raw_status_runtime_test.go",
+		"arm_register_address_test.go",
+		"arm_shifter_runtime_test.go",
+		"arm_status_cfg_runtime_test.go",
+		"arm_symbol_memory_test.go",
+		"arm_symbol_scratch_test.go",
+	} {
+		t.Run(source, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), source, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			modules := 0
+			ast.Inspect(file, func(node ast.Node) bool {
+				literal, ok := node.(*ast.BasicLit)
+				if !ok || literal.Kind != token.STRING {
+					return true
+				}
+				value, err := strconv.Unquote(literal.Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if strings.HasPrefix(value, "module ") {
+					modules++
+					if !strings.Contains(value, "\ngo 1.20\n") {
+						t.Errorf("runtime fixture unnecessarily forces a newer SDK: %q", value)
+					}
+				}
+				return true
+			})
+			if modules != 1 {
+				t.Fatalf("expected exactly one literal first-party oracle module, found %d", modules)
+			}
+		})
+	}
+}
diff --git a/runtime_oracle_native_c_test.go b/runtime_oracle_native_c_test.go
new file mode 100644
index 000000000..79255e005
--- /dev/null
+++ b/runtime_oracle_native_c_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// Only native-host C drivers use this helper. Cross-target object compilation
+// retains its independent target/sysroot contract. Callers still select LLVM
+// 22 and own the actual compiler/driver commands through the bounded runner.
+func runtimeOracleNativeCCommand(t *testing.T, ctx context.Context, clang string, arguments ...string) *exec.Cmd {
+	t.Helper()
+	if runtime.GOOS == "darwin" {
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		if err != nil {
+			t.Fatal(err)
+		}
+		arguments = append(flags, arguments...)
+	}
+	return exec.CommandContext(ctx, clang, arguments...)
+}
+
+func TestRuntimeOracleNativeCActualHeadersAndLink(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("LLVM 22 clang required")
+	}
+	directory := t.TempDir()
+	input := filepath.Join(directory, "native.c")
+	executable := filepath.Join(directory, "native")
+	if runtime.GOOS == "windows" {
+		executable += ".exe"
+	}
+	const source = `#include <stdint.h>
+#include <stdio.h>
+int main(void) {
+    uint64_t value = UINT64_C(123456789);
+    return printf("%llu", (unsigned long long)value) != 9;
+}
+`
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := runtimeOracleNativeCCommand(t, ctx, clang, level, input, "-o", executable)
+			x86FloatCompareCaptureCommand(t, command)
+			output := x86FloatCompareCaptureCommand(t, exec.Command(executable))
+			if string(output) != "123456789" {
+				t.Fatalf("actual host C headers/link/runtime changed: %q", output)
+			}
+		})
+	}
+}
diff --git a/runtime_oracle_process_test.go b/runtime_oracle_process_test.go
new file mode 100644
index 000000000..61e09ca68
--- /dev/null
+++ b/runtime_oracle_process_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// Compile process setup as its own translation unit. Its system headers must
+// not precede an oracle's feature macros or change the oracle's C namespace.
+func runtimeOracleProcessSource(t *testing.T, directory string) string {
+	t.Helper()
+	path := filepath.Join(directory, "oracle_process.c")
+	if err := os.WriteFile(path, []byte(runtimeOracleProcessSetupC), 0600); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
+
+func TestCrossLinuxRuntimeMatrixOracleProcessHeaderIsolation(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	// The fixture owns its feature-test macros and C identifiers. Shared
+	// process setup must neither pre-include headers nor occupy this scope.
+	const main = `#define _GNU_SOURCE
+#include <stdint.h>
+#if defined(__linux__)
+#include <sched.h>
+#include <sys/prctl.h>
+#endif
+static int read(void) { return 7; }
+int main(void) {
+#if defined(__linux__)
+    cpu_set_t allowed;
+    CPU_ZERO(&allowed);
+    if (sched_getaffinity(0, sizeof(allowed), &allowed) != 0) return 1;
+    if (CPU_COUNT(&allowed) == 0) return 2;
+    if (prctl(PR_GET_DUMPABLE, 0L, 0L, 0L, 0L) != 0) return 3;
+#endif
+    return read() == 7 ? 0 : 4;
+}
+`
+	const ir = "define i32 @unused() { ret i32 0 }\n"
+	t.Run("shared runtime", func(t *testing.T) {
+		compileAndRunRuntimeTestWithCompiler(t, execution.llc, execution.compiler,
+			"header_isolation", execution.triple, ir, main, execution.prefix)
+	})
+	t.Run("comparison runtime", func(t *testing.T) {
+		execution.compileAndRunLLVM(t, "header_isolation", ir, main, "-O2")
+	})
+}
+
+// Linux ignores RLIMIT_CORE when core_pattern names a pipe collector. Every
+// standalone C oracle opts out before main so its fault children inherit the
+// setting, without changing the Go test process or the machine-wide policy.
+// Keep each child's checked zero rlimit as well for the other Unix platforms.
+// See https://man7.org/linux/man-pages/man5/core.5.html.
+const runtimeOracleProcessSetupC = `
+#if defined(_WIN32)
+#include <stdio.h>
+#include <io.h>
+#include <fcntl.h>
+#include <process.h>
+__attribute__((constructor)) static void plan9asm_oracle_process_setup(void) {
+    if (_setmode(_fileno(stdout), _O_BINARY) == -1 ||
+        _setmode(_fileno(stderr), _O_BINARY) == -1) _exit(125);
+}
+#elif defined(__linux__)
+#include <sys/prctl.h>
+#include <unistd.h>
+__attribute__((constructor)) static void plan9asm_oracle_process_setup(void) {
+    if (prctl(PR_SET_DUMPABLE, 0L, 0L, 0L, 0L) != 0) _exit(125);
+}
+#endif
+`
diff --git a/runtime_oracle_sink_other_test.go b/runtime_oracle_sink_other_test.go
new file mode 100644
index 000000000..96e6ddb5f
--- /dev/null
+++ b/runtime_oracle_sink_other_test.go
@@ -0,0 +1,15 @@
+//go:build !unix
+
+package plan9asm
+
+import (
+	"errors"
+	"os/exec"
+)
+
+// Non-Unix requires our direct-child Kill acknowledgement and abnormal exit;
+// it makes no claim about descendants or a Unix signal identity.
+func runtimeOracleSinkCanceledExit(err error, killedDirectChild bool) bool {
+	var exit *exec.ExitError
+	return killedDirectChild && errors.As(err, &exit) && exit.ExitCode() != 0
+}
diff --git a/runtime_oracle_sink_test.go b/runtime_oracle_sink_test.go
new file mode 100644
index 000000000..42f529e46
--- /dev/null
+++ b/runtime_oracle_sink_test.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// Startup and observation have independent bounds. Only a consumed caller-ready
+// marker starts the complete nonreturning window; it does not identify an ASM PC.
+// Parent expiry or an exit without our direct-child kill witness never passes.
+// Drivers must publish a continuation marker immediately if the target returns:
+// process teardown can outlive the window and is not target nonreturning behavior.
+func runtimeOracleObserveSink(parent context.Context, command func(context.Context) *exec.Cmd, startup, window time.Duration) ([]byte, error) {
+	if parent == nil || command == nil || startup <= 0 || window <= 0 {
+		return nil, fmt.Errorf("sink requires its parent, command and positive bounds")
+	}
+	if err := parent.Err(); err != nil {
+		return nil, err
+	}
+	// time.Now carries a monotonic clock. Factory time and a ready-vs-timer
+	// selection race must not extend this absolute startup budget.
+	startupDeadline := time.Now().Add(startup)
+	ctx, cancel := context.WithCancel(parent)
+	defer cancel()
+	cmd := command(ctx)
+	if cmd == nil || cmd.Process != nil || cmd.Stdout != nil || cmd.Stderr != nil {
+		return nil, fmt.Errorf("sink requires a fresh command without output writers")
+	}
+	if !time.Now().Before(startupDeadline) {
+		return nil, errors.Join(fmt.Errorf("sink command factory exhausted its startup deadline"), parent.Err())
+	}
+	output := &runtimeOracleSinkOutput{ready: make(chan struct{})}
+	cmd.Stdout, cmd.Stderr = output, output
+	cmd.WaitDelay = 2 * time.Second
+	done := make(chan error, 1)
+	go func() { done <- runtimeOracleRun(cmd) }()
+
+	finish := func(cause error) ([]byte, error) {
+		killedDirectChild := false
+		if cause == nil {
+			// A final SIGKILL alone cannot distinguish our cancellation from
+			// a prior crash while a descendant still holds the output pipe.
+			// Readiness publishes Start's Process; failure paths do not read
+			// that concurrently initialized field. Kill must acknowledge this
+			// invocation's owned direct child before group cleanup begins.
+			if cmd.Process == nil {
+				cause = fmt.Errorf("ready sink has no owned direct child")
+			} else if err := cmd.Process.Kill(); err != nil {
+				cause = fmt.Errorf("sink direct-child cancellation was not acknowledged: %w", err)
+			} else {
+				killedDirectChild = true
+			}
+		}
+		cancel()
+		cleanup := time.NewTimer(3 * time.Second)
+		defer cleanup.Stop()
+		var runErr error
+		select {
+		case runErr = <-done:
+		case <-cleanup.C:
+			data, outputErr := output.snapshot()
+			return data, errors.Join(cause, outputErr, fmt.Errorf("sink command cleanup exceeded its bound"))
+		}
+		data, outputErr := output.snapshot()
+		if cause != nil || outputErr != nil || parent.Err() != nil {
+			return data, errors.Join(cause, outputErr, parent.Err(), runErr)
+		}
+		if !runtimeOracleSinkCanceledExit(runErr, killedDirectChild) || string(data) != "entered\n" {
+			return data, errors.Join(fmt.Errorf("sink returned, trapped or changed its output: %q", data), runErr)
+		}
+		return data, nil
+	}
+	finishedEarly := func(err error) ([]byte, error) {
+		data, outputErr := output.snapshot()
+		return data, errors.Join(fmt.Errorf("sink exited before its complete entered window"), err, outputErr, parent.Err())
+	}
+
+	start := time.NewTimer(time.Until(startupDeadline))
+	defer start.Stop()
+	select {
+	case err := <-done:
+		return finishedEarly(err)
+	case <-ctx.Done():
+		return finish(ctx.Err())
+	case <-start.C:
+		return finish(fmt.Errorf("sink entry marker not consumed before startup deadline"))
+	case <-output.ready:
+		start.Stop()
+		if !time.Now().Before(startupDeadline) {
+			return finish(fmt.Errorf("sink entry marker not consumed before startup deadline"))
+		}
+	}
+
+	observe := time.NewTimer(window)
+	defer observe.Stop()
+	select {
+	case err := <-done:
+		return finishedEarly(err)
+	case <-ctx.Done():
+		return finish(ctx.Err())
+	case <-observe.C:
+		// An already available exit cannot be mistaken for our cancellation.
+		select {
+		case err := <-done:
+			return finishedEarly(err)
+		default:
+		}
+		return finish(nil)
+	}
+}
+
+type runtimeOracleSinkOutput struct {
+	mu      sync.Mutex
+	data    bytes.Buffer
+	ready   chan struct{}
+	entered bool
+	err     error
+}
+
+func (output *runtimeOracleSinkOutput) Write(data []byte) (int, error) {
+	output.mu.Lock()
+	defer output.mu.Unlock()
+	const limit = 64 * 1024
+	if output.err != nil {
+		return 0, output.err
+	}
+	if len(data) > limit-output.data.Len() {
+		output.err = fmt.Errorf("sink output exceeds %d bytes", limit)
+		return 0, output.err
+	}
+	count, err := output.data.Write(data)
+	if !output.entered && bytes.HasPrefix(output.data.Bytes(), []byte("entered\n")) {
+		output.entered = true
+		close(output.ready)
+	}
+	return count, err
+}
+
+func (output *runtimeOracleSinkOutput) snapshot() ([]byte, error) {
+	output.mu.Lock()
+	defer output.mu.Unlock()
+	return append([]byte(nil), output.data.Bytes()...), output.err
+}
+
+func TestRuntimeOracleSinkColdStartupDoesNotConsumeObservation(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	start := time.Now()
+	output, err := runtimeOracleObserveSink(ctx, runtimeOracleSinkFixtureCommand("delayed"), time.Second, 80*time.Millisecond)
+	if err != nil || string(output) != "entered\n" {
+		t.Fatalf("cold startup consumed the entered observation: %v output=%q", err, output)
+	}
+	if time.Since(start) < 380*time.Millisecond {
+		t.Fatal("sink was not observed for the full window after entry")
+	}
+}
+
+func TestRuntimeOracleSinkRejectsStartupBudgetConsumedByFactory(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	factory := func(ctx context.Context) *exec.Cmd {
+		time.Sleep(300 * time.Millisecond)
+		return runtimeOracleSinkFixtureCommand("entered")(ctx)
+	}
+	output, err := runtimeOracleObserveSink(ctx, factory, 80*time.Millisecond, 80*time.Millisecond)
+	if err == nil {
+		t.Fatalf("expired startup budget accepted: output=%q", output)
+	}
+	if len(output) != 0 {
+		t.Fatalf("expired factory launched its command: output=%q error=%v", output, err)
+	}
+}
+
+func runtimeOracleSinkFixtureCommand(mode string) func(context.Context) *exec.Cmd {
+	return func(ctx context.Context) *exec.Cmd {
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleSinkFixture$")
+		// A race-instrumented fixture deliberately sleeps in os.Exit by
+		// default. Remove only that artificial exit delay, so the negative
+		// fixtures test real early process exit, not instrumentation sleep.
+		// Actual Go/LLVM assembly oracles do not inherit this override.
+		command.Env = append(os.Environ(), "PLAN9ASM_RUNTIME_SINK_FIXTURE="+mode, "GORACE=atexit_sleep_ms=0")
+		return command
+	}
+}
+
+func TestRuntimeOracleSinkFixture(t *testing.T) {
+	mode := os.Getenv("PLAN9ASM_RUNTIME_SINK_FIXTURE")
+	if mode == "" {
+		return
+	}
+	if mode == "delayed" {
+		time.Sleep(300 * time.Millisecond)
+	}
+	if mode == "missing" {
+		time.Sleep(5 * time.Second)
+		os.Exit(0)
+	}
+	if mode == "early-exit" {
+		os.Exit(0)
+	}
+	if mode == "bad-marker" {
+		fmt.Println("not entered")
+	} else if mode == "split-marker" {
+		fmt.Print("enter")
+		time.Sleep(10 * time.Millisecond)
+		fmt.Print("ed\n")
+	} else if mode == "returned" || mode == "returned-delayed-exit" {
+		// Publish the completed control path in one write. Neither a slow
+		// Windows process teardown nor scheduling after readiness may turn
+		// this completed target into a successful nonreturning observation.
+		fmt.Print("entered\nreturned\n")
+	} else if mode == "trapped" {
+		fmt.Print("entered\ntrapped\n")
+	} else {
+		fmt.Println("entered")
+	}
+	switch mode {
+	case "returned":
+		os.Exit(0)
+	case "returned-delayed-exit":
+		// Simulate teardown after the observed call has returned. Process
+		// liveness alone cannot distinguish this from the target's sink.
+		time.Sleep(300 * time.Millisecond)
+		os.Exit(0)
+	case "trapped":
+		os.Exit(23)
+	case "late-return":
+		time.Sleep(30 * time.Millisecond)
+		fmt.Println("returned")
+		os.Exit(0)
+	case "extra-output":
+		fmt.Fprintln(os.Stderr, "unexpected continuation")
+	case "overflow":
+		fmt.Print(strings.Repeat("x", 64*1024))
+	case "delayed", "entered", "missing", "bad-marker", "split-marker":
+	default:
+		t.Fatalf("unknown sink fixture %q", mode)
+	}
+	time.Sleep(5 * time.Second)
+	os.Exit(0)
+}
+
+func TestRuntimeOracleSinkRejectsMissingEntryAndEarlyExit(t *testing.T) {
+	for _, mode := range []string{"missing", "bad-marker", "early-exit", "returned", "returned-delayed-exit", "trapped", "late-return", "extra-output", "overflow"} {
+		t.Run(mode, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+			output, err := runtimeOracleObserveSink(ctx, runtimeOracleSinkFixtureCommand(mode), time.Second, 100*time.Millisecond)
+			if err == nil {
+				t.Fatalf("invalid sink accepted: %s output=%q", mode, output)
+			}
+			if mode == "returned" || mode == "returned-delayed-exit" || mode == "late-return" {
+				if string(output) != "entered\nreturned\n" || ctx.Err() != nil {
+					t.Fatalf("return witness was lost or replaced by infrastructure failure: %v output=%q", err, output)
+				}
+			}
+			if mode == "extra-output" && !strings.Contains(string(output), "unexpected continuation") {
+				t.Fatalf("sink failure lost its output: %q", output)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleSinkEntryAndSplitMarker(t *testing.T) {
+	for _, mode := range []string{"entered", "split-marker"} {
+		t.Run(mode, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+			defer cancel()
+			output, err := runtimeOracleObserveSink(ctx, runtimeOracleSinkFixtureCommand(mode), time.Second, 80*time.Millisecond)
+			if err != nil || string(output) != "entered\n" {
+				t.Fatalf("complete entered window rejected: %v output=%q", err, output)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleSinkParentDeadlineCannotPass(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+	defer cancel()
+	output, err := runtimeOracleObserveSink(ctx, runtimeOracleSinkFixtureCommand("entered"), time.Second, time.Second)
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("incomplete observation lost its parent deadline: %v output=%q", err, output)
+	}
+}
+
+func TestRuntimeOracleSinkParentCancellationCannotPass(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	readyFactory := func(ctx context.Context) *exec.Cmd {
+		time.AfterFunc(100*time.Millisecond, cancel)
+		return runtimeOracleSinkFixtureCommand("entered")(ctx)
+	}
+	output, err := runtimeOracleObserveSink(ctx, readyFactory, time.Second, time.Second)
+	if !errors.Is(err, context.Canceled) {
+		t.Fatalf("incomplete observation lost parent cancellation: %v output=%q", err, output)
+	}
+}
+
+func TestRuntimeOracleSinkRequiresFreshBoundedCommand(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	for _, test := range []struct {
+		name            string
+		parent          context.Context
+		factory         func(context.Context) *exec.Cmd
+		startup, window time.Duration
+	}{
+		{name: "no parent", factory: runtimeOracleSinkFixtureCommand("entered"), startup: time.Second, window: time.Second},
+		{name: "no factory", parent: ctx, startup: time.Second, window: time.Second},
+		{name: "no startup bound", parent: ctx, factory: runtimeOracleSinkFixtureCommand("entered"), window: time.Second},
+		{name: "no observation bound", parent: ctx, factory: runtimeOracleSinkFixtureCommand("entered"), startup: time.Second},
+		{name: "no command", parent: ctx, factory: func(context.Context) *exec.Cmd { return nil }, startup: time.Second, window: time.Second},
+		{name: "existing output", parent: ctx, factory: func(ctx context.Context) *exec.Cmd {
+			command := runtimeOracleSinkFixtureCommand("entered")(ctx)
+			command.Stdout = os.Stdout
+			return command
+		}, startup: time.Second, window: time.Second},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			output, err := runtimeOracleObserveSink(test.parent, test.factory, test.startup, test.window)
+			if err == nil || len(output) != 0 {
+				t.Fatalf("invalid sink command was launched: %v output=%q", err, output)
+			}
+		})
+	}
+	cancel()
+	if _, err := runtimeOracleObserveSink(ctx, runtimeOracleSinkFixtureCommand("entered"), time.Second, time.Second); !errors.Is(err, context.Canceled) {
+		t.Fatalf("canceled parent launched a sink: %v", err)
+	}
+}
+
+func TestRuntimeOracleSinkOutputOverflowIsFailure(t *testing.T) {
+	output := &runtimeOracleSinkOutput{ready: make(chan struct{})}
+	if _, err := output.Write([]byte("entered\n")); err != nil {
+		t.Fatal(err)
+	}
+	if count, err := output.Write(make([]byte, 64*1024)); err == nil || count != 0 {
+		t.Fatalf("sink overflow accepted: %d %v", count, err)
+	}
+	data, err := output.snapshot()
+	if err == nil || string(data) != "entered\n" {
+		t.Fatalf("sink overflow was erased or its retained output changed: %v %q", err, data)
+	}
+}
diff --git a/runtime_oracle_sink_unix_test.go b/runtime_oracle_sink_unix_test.go
new file mode 100644
index 000000000..9e9896ed6
--- /dev/null
+++ b/runtime_oracle_sink_unix_test.go
@@ -0,0 +1,138 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"syscall"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/ownedprocess"
+)
+
+func runtimeOracleSinkCanceledExit(err error, killedDirectChild bool) bool {
+	var exit *exec.ExitError
+	if !killedDirectChild || errors.Is(err, ownedprocess.ErrCleanup) || !errors.As(err, &exit) {
+		return false
+	}
+	status, ok := exit.Sys().(syscall.WaitStatus)
+	return ok && status.Signaled() && status.Signal() == syscall.SIGKILL
+}
+
+func TestRuntimeOracleSinkCanceledExitRequiresKillWitness(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleSinkKilledFixture$")
+	command.Env = append(os.Environ(), "PLAN9ASM_RUNTIME_KILLED_SINK=self-kill", "GORACE=atexit_sleep_ms=0")
+	err := runtimeOracleRun(command)
+	if ctx.Err() != nil || !runtimeOracleSinkCanceledExit(err, true) {
+		t.Fatalf("fixture did not produce its independent SIGKILL: %v", err)
+	}
+	if runtimeOracleSinkCanceledExit(err, false) {
+		t.Fatal("SIGKILL without this observer's kill witness was accepted")
+	}
+	if runtimeOracleSinkCanceledExit(errors.Join(err, ownedprocess.ErrCleanup), true) {
+		t.Fatal("descendant cleanup failure was accepted")
+	}
+}
+
+func TestRuntimeOracleSinkRejectsPreviouslyKilledParent(t *testing.T) {
+	pidFile := filepath.Join(t.TempDir(), "owned-pipe-holder.pid")
+	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
+	defer cancel()
+	factory := func(ctx context.Context) *exec.Cmd {
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleSinkKilledFixture$")
+		command.Env = append(os.Environ(),
+			"PLAN9ASM_RUNTIME_KILLED_SINK=parent",
+			"PLAN9ASM_RUNTIME_KILLED_SINK_PID="+pidFile,
+			"GORACE=atexit_sleep_ms=0",
+		)
+		return command
+	}
+	output, observeErr := runtimeOracleObserveSink(ctx, factory, time.Second, 300*time.Millisecond)
+	data, err := os.ReadFile(pidFile)
+	if err != nil {
+		t.Fatalf("fixture did not publish its owned descendant: %v; observer=%v output=%q", err, observeErr, output)
+	}
+	pid, err := strconv.Atoi(string(data))
+	if err != nil || pid <= 1 {
+		t.Fatalf("invalid owned descendant identity %q: %v", data, err)
+	}
+	child, err := os.FindProcess(pid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The private identity belongs only to this fixture, including a RED.
+	defer child.Kill()
+	runtimeOracleAssertChildStopped(t, pid)
+	t.Logf("previously killed parent: observer=%v output=%q", observeErr, output)
+	if observeErr == nil || string(output) != "entered\n" {
+		t.Fatalf("previous SIGKILL was accepted as observer cancellation: %v output=%q", observeErr, output)
+	}
+	if !errors.Is(observeErr, os.ErrProcessDone) {
+		t.Fatalf("previous exit was not rejected by the direct-child witness: %v", observeErr)
+	}
+}
+
+func TestRuntimeOracleSinkKilledFixture(t *testing.T) {
+	mode := os.Getenv("PLAN9ASM_RUNTIME_KILLED_SINK")
+	if mode == "" {
+		return
+	}
+	if mode == "self-kill" {
+		if err := syscall.Kill(os.Getpid(), syscall.SIGKILL); err != nil {
+			t.Fatal(err)
+		}
+		os.Exit(24)
+	}
+	pidFile := os.Getenv("PLAN9ASM_RUNTIME_KILLED_SINK_PID")
+	if pidFile == "" {
+		t.Fatal("killed sink requires its private descendant identity")
+	}
+	if mode == "holder" {
+		if err := os.WriteFile(pidFile+".ready", []byte(strconv.Itoa(os.Getpid())), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.Rename(pidFile+".ready", pidFile); err != nil {
+			t.Fatal(err)
+		}
+		time.Sleep(5 * time.Second)
+		os.Exit(0)
+	}
+	if mode != "parent" {
+		t.Fatalf("unknown killed sink fixture %q", mode)
+	}
+	child := exec.Command(os.Args[0], "-test.run=^TestRuntimeOracleSinkKilledFixture$")
+	child.Env = append(os.Environ(), "PLAN9ASM_RUNTIME_KILLED_SINK=holder")
+	child.Stdout, child.Stderr = os.Stdout, os.Stderr
+	if err := child.Start(); err != nil {
+		t.Fatal(err)
+	}
+	defer child.Process.Kill()
+	deadline := time.Now().Add(time.Second)
+	for {
+		if _, err := os.Stat(pidFile); err == nil {
+			break
+		} else if !os.IsNotExist(err) {
+			t.Fatal(err)
+		}
+		if !time.Now().Before(deadline) {
+			t.Fatal("pipe holder did not become ready")
+		}
+		time.Sleep(5 * time.Millisecond)
+	}
+	fmt.Println("entered")
+	// The parent dies independently; its descendant keeps the output pipe
+	// open, so Cmd.Wait has not returned when the observation window ends.
+	if err := syscall.Kill(os.Getpid(), syscall.SIGKILL); err != nil {
+		t.Fatal(err)
+	}
+	os.Exit(24)
+}
diff --git a/runtime_oracle_stage_test.go b/runtime_oracle_stage_test.go
new file mode 100644
index 000000000..8030f6a71
--- /dev/null
+++ b/runtime_oracle_stage_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"testing"
+	"time"
+)
+
+func TestRuntimeOracleStageDeadline(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+	for _, test := range []struct {
+		name     string
+		deadline time.Time
+		has      bool
+		want     time.Time
+	}{
+		{name: "no overall deadline", want: now.Add(5 * time.Minute)},
+		{name: "long overall deadline", deadline: now.Add(20 * time.Minute), has: true, want: now.Add(5 * time.Minute)},
+		{name: "short overall deadline", deadline: now.Add(30 * time.Second), has: true, want: now.Add(27 * time.Second)},
+		{name: "exact reserve boundary", deadline: now.Add(5*time.Minute + 3*time.Second), has: true, want: now.Add(5 * time.Minute)},
+		{name: "only cleanup remains", deadline: now.Add(2 * time.Second), has: true, want: now.Add(-time.Second)},
+		{name: "overall already expired", deadline: now.Add(-10 * time.Second), has: true, want: now.Add(-13 * time.Second)},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := runtimeOracleStageDeadline(now, test.deadline, test.has)
+			if !got.Equal(test.want) {
+				t.Fatalf("stage deadline = %s, want %s", got, test.want)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleStageBudgetsAreIndependent(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+	whole := now.Add(12 * time.Minute)
+	first := runtimeOracleStageDeadline(now, whole, true)
+	second := runtimeOracleStageDeadline(now.Add(4*time.Minute), whole, true)
+	third := runtimeOracleStageDeadline(now.Add(8*time.Minute), whole, true)
+	if !first.Equal(now.Add(5*time.Minute)) || !second.Equal(now.Add(9*time.Minute)) ||
+		!third.Equal(whole.Add(-3*time.Second)) {
+		t.Fatalf("stage budgets did not reset or exceeded whole deadline: %s %s %s", first, second, third)
+	}
+}
+
+func TestRuntimeOracleProofLifetimeKeepsStageAndOverallBounds(t *testing.T) {
+	now := time.Unix(1700000000, 0)
+	whole := now.Add(30 * time.Minute)
+	lease := runtimeOracleBoundedDeadline(now, whole, true, runtimeOracleProofTimeout)
+	if !lease.Equal(now.Add(20 * time.Minute)) {
+		t.Fatal("composed proof lost its finite multi-stage lifetime", lease)
+	}
+	for _, elapsed := range []time.Duration{0, 4 * time.Minute, 8 * time.Minute} {
+		stage := runtimeOracleStageDeadline(now.Add(elapsed), lease, true)
+		if !stage.Equal(now.Add(elapsed + 5*time.Minute)) {
+			t.Fatal("proof lifetime enlarged or consumed a stage budget", elapsed, stage)
+		}
+	}
+	for _, remaining := range []time.Duration{8 * time.Minute, 2 * time.Second, -time.Second} {
+		deadline := runtimeOracleBoundedDeadline(now, now.Add(remaining), true, runtimeOracleProofTimeout)
+		if !deadline.Equal(now.Add(remaining - runtimeOracleStageCleanupReserve)) {
+			t.Fatal("proof lease exceeded the overall deadline or lost cleanup", remaining, deadline)
+		}
+	}
+	ctx, cancel := runtimeOracleProofContext(t)
+	deadline, has := ctx.Deadline()
+	if !has || deadline.After(time.Now().Add(runtimeOracleProofTimeout)) {
+		t.Fatal("actual proof context is unbounded", deadline, has)
+	}
+	cancel()
+	if !errors.Is(ctx.Err(), context.Canceled) {
+		t.Fatal("proof cancellation was lost", ctx.Err())
+	}
+}
+
+func TestRuntimeOracleSourceProofFixturesUseComposedLifetimes(t *testing.T) {
+	// These factories retain live owners after returning. Their consumers run
+	// multiple capture, binding and API checks against the same context; a
+	// command-stage lease incorrectly expires partway through that proof.
+	for _, fixture := range []struct{ file, function string }{
+		{"go_x86_numerical_read_consumer_guard_test.go", "numericalConsumerFactory"},
+		{"go_x86_numerical_read_family_test.go", "numericalExecutionFixture"},
+		{"go_x86_numerical_read_local_test.go", "numericalLocalFactoryWithContext"},
+		{"go_x86_numerical_read_sdk_test.go", "numericalSDKCRC32Request"},
+		{"go_x86_numerical_read_sdk_test.go", "numericalSDKCPURequest"},
+		{"go_x86_sdk_asm_data_live_test.go", "sdkASMDataRequest"},
+	} {
+		t.Run(fixture.function, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), fixture.file, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			proofs, stages, found := 0, 0, false
+			for _, declaration := range file.Decls {
+				function, ok := declaration.(*ast.FuncDecl)
+				if !ok || function.Name.Name != fixture.function {
+					continue
+				}
+				found = true
+				ast.Inspect(function.Body, func(node ast.Node) bool {
+					call, ok := node.(*ast.CallExpr)
+					if !ok {
+						return true
+					}
+					if name, ok := call.Fun.(*ast.Ident); ok {
+						switch name.Name {
+						case "runtimeOracleProofContext":
+							proofs++
+						case "runtimeOracleStageContext":
+							stages++
+						}
+					}
+					return true
+				})
+			}
+			if !found || proofs != 1 || stages != 0 {
+				t.Fatalf("source-proof factory has found=%v proof leases=%d command-stage leases=%d", found, proofs, stages)
+			}
+		})
+	}
+}
+
+func TestRuntimeOracleStageContextUsesActualTestDeadline(t *testing.T) {
+	before := time.Now()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	deadline, found := ctx.Deadline()
+	if !found || deadline.After(time.Now().Add(runtimeOracleStageTimeout)) || deadline.Before(before) {
+		t.Fatalf("missing or unbounded actual stage context: %s, %v", deadline, found)
+	}
+	if whole, found := t.Deadline(); found && deadline.After(whole.Add(-runtimeOracleStageCleanupReserve)) {
+		t.Fatalf("stage consumes its test's cleanup reserve: stage %s, whole %s", deadline, whole)
+	}
+	cancel()
+	if !errors.Is(ctx.Err(), context.Canceled) {
+		t.Fatalf("stage cancellation was lost: %v", ctx.Err())
+	}
+}
+
+func TestRuntimeOracleStageExpiredBudgetDoesNotLaunch(t *testing.T) {
+	now := time.Now()
+	deadline := runtimeOracleStageDeadline(now, now.Add(2*time.Second), true)
+	ctx, cancel := context.WithDeadline(context.Background(), deadline)
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestRuntimeOracleCommandFixture$")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if !errors.Is(err, context.DeadlineExceeded) || len(output) != 0 || command.Process != nil {
+		t.Fatalf("expired stage launched a process or lost its failure: %v %q", err, output)
+	}
+}
+
+func TestRuntimeExecUsesSeparateBoundedStageContexts(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "runtime_exec_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var function *ast.FuncDecl
+	for _, decl := range file.Decls {
+		if candidate, ok := decl.(*ast.FuncDecl); ok && candidate.Name.Name == "compileAndRunRuntimeTestWithCompiler" {
+			function = candidate
+		}
+	}
+	if function == nil {
+		t.Fatal("runtime compilation consumer missing")
+	}
+	contexts, commands, consumers, cancellations := 0, 0, 0, 0
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if ident, ok := call.Fun.(*ast.Ident); ok {
+			switch ident.Name {
+			case "runtimeOracleStageContext":
+				contexts++
+			case "runtimeOracleCombinedOutput":
+				consumers++
+			case "cancel":
+				cancellations++
+			}
+		}
+		if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+			if receiver, ok := method.X.(*ast.Ident); ok && receiver.Name == "exec" {
+				if method.Sel.Name != "CommandContext" {
+					t.Errorf("runtime stage lost its context: exec.%s", method.Sel.Name)
+				}
+				commands++
+			}
+		}
+		return true
+	})
+	if contexts != 3 || commands != 3 || consumers != 3 || cancellations != 3 {
+		t.Fatalf("three independently bounded stages required: context=%d command=%d consumer=%d cancel=%d",
+			contexts, commands, consumers, cancellations)
+	}
+}
diff --git a/runtime_windows_stack_test.go b/runtime_windows_stack_test.go
new file mode 100644
index 000000000..41561f175
--- /dev/null
+++ b/runtime_windows_stack_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"debug/pe"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+// The Windows runtime oracle links with MSYS2/MinGW clang. Large generated
+// functions must call its real stack-probing helper, not the MSVC CRT helper.
+// Cross-compiling this fixture makes the regression visible on every host.
+func TestRuntimeWindowsStackProbeMatchesMinGW(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	const source = `declare void @use_stack(ptr)
+define void @stackprobe() {
+  %stack = alloca [8192 x i8], align 16
+  call void @use_stack(ptr %stack)
+  ret void
+}
+`
+	for _, tc := range []struct {
+		name, triple, symbol string
+	}{
+		{"runtime-mingw", testTargetTriple("windows", "amd64"), "___chkstk_ms"},
+		{"explicit-msvc", "x86_64-pc-windows-msvc", "__chkstk"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			dir := t.TempDir()
+			input, output := filepath.Join(dir, "stack.ll"), filepath.Join(dir, "stack.obj")
+			if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if out, err := exec.Command(llc, "-mtriple="+tc.triple, "-filetype=obj", input, "-o", output).CombinedOutput(); err != nil {
+				t.Fatalf("LLVM 22 compile: %v\n%s", err, out)
+			}
+			object, err := pe.Open(output)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer object.Close()
+			for _, symbol := range object.Symbols {
+				if symbol.Name == tc.symbol && symbol.SectionNumber == 0 {
+					return
+				}
+			}
+			t.Fatalf("%s did not reference the required CRT stack probe %s", tc.triple, tc.symbol)
+		})
+	}
+}
diff --git a/scripts/arm64_plan9_oracle_test.py b/scripts/arm64_plan9_oracle_test.py
new file mode 100644
index 000000000..553f98f6a
--- /dev/null
+++ b/scripts/arm64_plan9_oracle_test.py
@@ -0,0 +1,77 @@
+"""Script delegation checks; historical loop RED remains in Git history.
+
+The actual process/source/object regressions live in internal/goasmoracle and
+cmd/plan9asmgooracle, so the script and root tests consume one classifier.
+"""
+
+import pathlib
+import contextlib
+import json
+import os
+import signal
+import subprocess
+import tempfile
+import unittest
+
+
+class ARM64Plan9OracleScriptTests(unittest.TestCase):
+
+    def test_actual_bash_cli_delegation(self):
+        # This is a controlled Bash delegation regression, not a stock-Go or
+        # source-rejection certificate. Execute the script's exact fragment.
+        script = (pathlib.Path(__file__).resolve().parent / "check-arm64-plan9-corpus.sh").read_text()
+        start = script.index('"$go_path" run "$repo_root/cmd/plan9asmgooracle"')
+        end = script.index('\naccepted_cases=', start)
+        fragment = script[start:end]
+        with tempfile.TemporaryDirectory(prefix="decoder-delegation-") as directory:
+            output = pathlib.Path(directory) / "argv"
+            environment = os.environ.copy()
+            environment.update({"go_path": "delegate", "repo_root": "/fixture repository",
+                                "source_cases": "/fixture cases", "family_file": "/fixture families",
+                                "goroot": "/fixture SDK", "oracle_parent": "/fixture report",
+                                "capture": str(output)})
+            program = 'set -euo pipefail\ndelegate() { printf "%s\\0" "$@" >"$capture"; }\n' + fragment
+            child = subprocess.Popen(["/bin/bash", "-c", program], env=environment,
+                                     stdout=subprocess.PIPE, stderr=subprocess.PIPE, start_new_session=True)
+            pgid = os.getpgid(child.pid)
+            try:
+                stdout, stderr = child.communicate(timeout=5)
+            finally:
+                with contextlib.suppress(ProcessLookupError):
+                    os.killpg(pgid, signal.SIGKILL)
+                child.wait(timeout=2)
+            try:
+                os.killpg(pgid, 0)
+                absent = False
+            except ProcessLookupError:
+                absent = True
+            argv = output.read_bytes().split(b"\x00")[:-1]
+            record = {"role": "controlled-Bash-delegation", "pid": child.pid, "pgid": pgid,
+                      "waited": True, "group_absent": absent, "exit": child.returncode,
+                      "argv": [arg.decode() for arg in argv], "fragment": fragment,
+                      "stdout": stdout.decode(), "stderr": stderr.decode()}
+            evidence = os.environ.get("PLAN9ASM_ORACLE_EVIDENCE_DIR")
+            if evidence:
+                with (pathlib.Path(evidence) / "bash-delegation.json").open("x") as stream:
+                    json.dump(record, stream, indent=2)
+                    stream.write("\n")
+            self.assertTrue(absent, "controlled Bash group not closed")
+            self.assertEqual(child.returncode, 0, record)
+            self.assertEqual(record["argv"], ["run", "/fixture repository/cmd/plan9asmgooracle",
+                                           "-cases=/fixture cases", "-families=/fixture families",
+                                           "-go=delegate", "-goroot=/fixture SDK",
+                                           "-out=/fixture report/go-oracle"])
+
+    def test_shared_owner_and_retained_reports(self):
+        script = (pathlib.Path(__file__).resolve().parent / "check-arm64-plan9-corpus.sh").read_text()
+        for expected in ('/cmd/plan9asmgooracle"', '-go="$go_path" -goroot="$goroot"',
+                         'accepted_cases="$oracle_parent/go-oracle/accepted.txt"',
+                         'full_report="$oracle_parent/full.json"',
+                         'accepted_report="$oracle_parent/accepted.json"'):
+            self.assertIn(expected, script)
+        for forbidden in ("subprocess.DEVNULL", "subprocess.run", "else rejected"):
+            self.assertNotIn(forbidden, script)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)
diff --git a/scripts/benchmark-compile.sh b/scripts/benchmark-compile.sh
new file mode 100755
index 000000000..3cfe156fa
--- /dev/null
+++ b/scripts/benchmark-compile.sh
@@ -0,0 +1,214 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root=$(cd "$(dirname "$0")/.." && pwd)
+go_version=$(go env GOVERSION)
+if [[ ! "$go_version" =~ ^go1[.]27([.]|$) ]]; then
+  echo "compile benchmark requires Go 1.27, got $go_version" >&2
+  exit 1
+fi
+if ! command -v jq >/dev/null 2>&1; then
+  echo "jq not found in PATH" >&2
+  exit 1
+fi
+
+# Resolved relative to the checked-out repository.
+# shellcheck disable=SC1091
+source "$repo_root/scripts/llvm22.sh"
+if ! llc_cmd=$(find_llvm22_llc); then
+  exit 1
+fi
+
+targets_csv=${PLAN9ASM_BENCHMARK_TARGETS:-linux/386,linux/amd64,linux/arm,linux/arm64,js/wasm}
+IFS=',' read -r -a targets <<<"$targets_csv"
+if (( ${#targets[@]} == 0 )); then
+  echo "PLAN9ASM_BENCHMARK_TARGETS must contain at least one GOOS/GOARCH target" >&2
+  exit 2
+fi
+seen_targets=,
+for target in "${targets[@]}"; do
+  if ! [[ "$target" =~ ^[a-z0-9]+/(386|amd64|arm|arm64|wasm)$ ]]; then
+    echo "invalid benchmark target $target" >&2
+    exit 2
+  fi
+  if [[ "$seen_targets" == *",$target,"* ]]; then
+    echo "duplicate benchmark target $target" >&2
+    exit 2
+  fi
+  seen_targets+="$target,"
+done
+
+max_target_seconds=${PLAN9ASM_BENCHMARK_MAX_TARGET_SECONDS:-300}
+max_total_seconds=${PLAN9ASM_BENCHMARK_MAX_TOTAL_SECONDS:-900}
+if ! [[ "$max_target_seconds" =~ ^[1-9][0-9]*$ && "$max_total_seconds" =~ ^[1-9][0-9]*$ ]]; then
+  echo "benchmark time budgets must be positive integer seconds" >&2
+  exit 2
+fi
+
+report_dir=${PLAN9ASM_BENCHMARK_REPORT_DIR:-"$repo_root/_out/compile-benchmark"}
+if [[ -d "$report_dir" ]] && [[ -n "$(find "$report_dir" -mindepth 1 -maxdepth 1 -print -quit)" ]]; then
+  echo "benchmark reports already exist; select a fresh PLAN9ASM_BENCHMARK_REPORT_DIR" >&2
+  exit 2
+fi
+mkdir -p "$report_dir"
+
+tmp_root=$(mktemp -d)
+trap 'rm -rf "$tmp_root"' EXIT
+translator="$tmp_root/plan9asmll"
+
+group_start() {
+  if [[ "${GITHUB_ACTIONS:-}" == "true" ]]; then
+    printf '::group::%s\n' "$1"
+  else
+    printf '==> %s\n' "$1"
+  fi
+}
+
+group_end() {
+  if [[ "${GITHUB_ACTIONS:-}" == "true" ]]; then
+    printf '::endgroup::\n'
+  fi
+}
+
+group_start "build plan9asmll benchmark driver"
+build_start=$SECONDS
+if go build -C "$repo_root/cmd/plan9asmll" -o "$translator" .; then
+  build_status=0
+else
+  build_status=$?
+fi
+build_seconds=$((SECONDS - build_start))
+group_end
+printf 'benchmark driver build: %ds\n' "$build_seconds"
+if (( build_status != 0 )); then
+  exit "$build_status"
+fi
+
+total_wall_seconds=0
+budget_failed=0
+compile_failed=0
+metric_files=()
+for target in "${targets[@]}"; do
+  goos=${target%/*}
+  goarch=${target#*/}
+  target_id="$goos-$goarch"
+  report_path="$report_dir/$target_id.json"
+  metric_path="$tmp_root/$target_id-metric.json"
+
+  group_start "compile benchmark $target"
+  target_start=$SECONDS
+  if "$translator" \
+    -goos="$goos" \
+    -goarch="$goarch" \
+    -patterns=std \
+    -compile \
+    -llc="$llc_cmd" \
+    -strict-load \
+    -keep-going=true \
+    -repo-root="$repo_root" \
+    -out="$tmp_root/llvm/$target_id" \
+    -report="$report_path"; then
+    target_status=0
+  else
+    target_status=$?
+  fi
+  wall_seconds=$((SECONDS - target_start))
+  group_end
+  if (( target_status != 0 )); then
+    echo "compile benchmark $target failed after ${wall_seconds}s" >&2
+  fi
+
+  report_valid=false
+  statistics=null
+  if [[ -f "$report_path" ]] && jq -e --arg goos "$goos" --arg goarch "$goarch" '
+    def count: type == "number" and . >= 0 and . == floor;
+    type == "object" and .goos == $goos and .goarch == $goarch and
+    ([.total_asm, .success, .failed, .not_applicable] | all(count)) and
+    .total_asm > 0 and .success + .failed + .not_applicable <= .total_asm and
+    (.asm_files | type == "array") and (.asm_files | length) == .total_asm and
+    (.asm_files | all(type == "string" and length > 0)) and
+    (.asm_files | unique | length) == .total_asm and
+    ((.fails // []) | type == "array") and ((.fails // []) | length) == .failed and
+    (.duration | type == "string")
+  ' "$report_path" > /dev/null 2> "$report_dir/$target_id-validation.stderr"; then
+    report_valid=true
+    statistics=$(jq -c '{total_asm, success, failed, not_applicable, duration}' "$report_path")
+  else
+    echo "compile benchmark $target has no valid target-bound report; counts remain unknown" >&2
+  fi
+
+  status=failed
+  if (( target_status == 0 )) && [[ "$report_valid" == true ]] &&
+    jq -e '.failed == 0 and .not_applicable == 0 and .success == .total_asm' "$report_path" > /dev/null; then
+    status=passed
+  else
+    compile_failed=1
+    echo "compile benchmark $target requires a successful command and every assembly file compiled" >&2
+  fi
+
+  total_wall_seconds=$((total_wall_seconds + wall_seconds))
+  if (( wall_seconds > max_target_seconds )); then
+    echo "compile benchmark $target exceeded ${max_target_seconds}s budget: ${wall_seconds}s" >&2
+    budget_failed=1
+    status=failed
+  fi
+  printf 'compile benchmark %s: status=%s command_exit=%s wall=%ds statistics=%s\n' \
+    "$target" "$status" "$target_status" "$wall_seconds" "$statistics"
+
+  jq -n \
+    --arg target "$target" \
+    --arg status "$status" \
+    --argjson command_exit "$target_status" \
+    --argjson report_valid "$report_valid" \
+    --argjson wall_seconds "$wall_seconds" \
+    --argjson statistics "$statistics" '
+      {target:$target, status:$status, command_exit:$command_exit,
+       report_valid:$report_valid, wall_seconds:$wall_seconds,
+       tool_duration:$statistics.duration, total_asm:$statistics.total_asm,
+       success:$statistics.success, failed:$statistics.failed,
+       not_applicable:$statistics.not_applicable,
+       unattempted:(if $statistics == null then null else
+         $statistics.total_asm - $statistics.success - $statistics.failed - $statistics.not_applicable
+       end)}
+    ' \
+    >"$metric_path"
+  metric_files+=("$metric_path")
+
+  # The benchmark report is outside tmp_root; compiled IR and objects from
+  # completed targets are not needed by the remaining targets.
+  if [[ -d "$tmp_root/llvm/$target_id" ]]; then
+    rm -r "$tmp_root/llvm/$target_id"
+  fi
+done
+
+jq -s \
+  --arg go_version "$go_version" \
+  --arg llc "$llc_cmd" \
+  --argjson build_seconds "$build_seconds" \
+  --argjson total_wall_seconds "$total_wall_seconds" \
+  --argjson max_target_seconds "$max_target_seconds" \
+  --argjson max_total_seconds "$max_total_seconds" \
+  '{schema_version:2,go_version:$go_version,llc:$llc,build_seconds:$build_seconds,total_wall_seconds:$total_wall_seconds,max_target_seconds:$max_target_seconds,max_total_seconds:$max_total_seconds,all_passed:(all(.status == "passed") and $total_wall_seconds <= $max_total_seconds),targets:.}' \
+  "${metric_files[@]}" >"$report_dir/summary.json"
+
+summary_path="$report_dir/summary.md"
+{
+  printf '### Compile benchmark\n\n'
+  printf '| Target | Status | Exit | Wall | Tool duration | Asm files | Success | N/A | Failed | Unattempted |\n'
+  printf '| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |\n'
+  jq -r '.targets[] | "| \(.target) | \(.status) | \(.command_exit) | \(.wall_seconds)s | \(.tool_duration) | \(.total_asm) | \(.success) | \(.not_applicable) | \(.failed) | \(.unattempted) |"' "$report_dir/summary.json"
+  printf '\nBuild: %ss; target total: %ss; budgets: %ss per target / %ss total.\n' \
+    "$build_seconds" "$total_wall_seconds" "$max_target_seconds" "$max_total_seconds"
+} >"$summary_path"
+cat "$summary_path"
+if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then
+  cat "$summary_path" >>"$GITHUB_STEP_SUMMARY"
+fi
+
+if (( total_wall_seconds > max_total_seconds )); then
+  echo "compile benchmark exceeded ${max_total_seconds}s total budget: ${total_wall_seconds}s" >&2
+  budget_failed=1
+fi
+if (( budget_failed != 0 || compile_failed != 0 )); then
+  exit 1
+fi
diff --git a/scripts/check-arm64-plan9-corpus.sh b/scripts/check-arm64-plan9-corpus.sh
index f49ab2390..598f54dde 100755
--- a/scripts/check-arm64-plan9-corpus.sh
+++ b/scripts/check-arm64-plan9-corpus.sh
@@ -2,7 +2,6 @@
 set -euo pipefail
 
 repo_root=$(cd "$(dirname "$0")/.." && pwd)
-corpus_root="$repo_root/testdata/corpus"
 family_file="$repo_root/testdata/coverage/arm64-go-assembler-families.txt"
 baseline="$repo_root/testdata/coverage/arm64-xarch-plan9-baseline.json"
 cd "$repo_root"
@@ -19,7 +18,10 @@ fi
 tmp_root=$(mktemp -d)
 trap 'rm -rf "$tmp_root"' EXIT
 module_json="$tmp_root/xarch.json"
-go -C "$corpus_root" mod download -json golang.org/x/arch@v0.31.0 >"$module_json"
+# This official Go decoder corpus is independent of external-library manifests.
+# An explicit module@version can be downloaded outside a main module without
+# modifying the translator's go.mod/go.sum or recreating a compatibility ledger.
+GOWORK=off go mod download -C "$tmp_root" -json golang.org/x/arch@v0.31.0 >"$module_json"
 xarch_root=$("$python_cmd" - "$module_json" <<'PY'
 import json
 import sys
@@ -28,7 +30,9 @@ PY
 )
 source_cases="$xarch_root/arm64/arm64asm/testdata/plan9cases.txt"
 
-full_report="$tmp_root/full.json"
+mkdir -p "$repo_root/_out"
+oracle_parent=$(mktemp -d "$repo_root/_out/arm64-plan9-XXXXXX")
+full_report="$oracle_parent/full.json"
 go run "$repo_root/cmd/plan9asmscan" \
   -corpus=arm64-plan9 \
   -input="$source_cases" \
@@ -52,57 +56,26 @@ if changed:
 print(f"x/arch ARM64 Plan 9 decoder corpus: ops={actual['unique_ops']} forms={actual['unique_forms']} supported={actual['supported_forms']} context={actual['context_forms']} unsupported={actual['unsupported_forms']} parse_errors={actual['parse_err_count']}")
 PY
 
-accepted_cases="$tmp_root/accepted.txt"
-"$python_cmd" - "$source_cases" "$family_file" "$accepted_cases" "$(go env GOROOT)" "$tmp_root" <<'PY'
-import os
+go_path=$(command -v go)
+goroot=$("$go_path" env GOROOT)
+# The explicitly selected physical driver/SDK remain one observed role.
+readarray_inputs=$("$python_cmd" - "$go_path" "$goroot" "$source_cases" "$family_file" <<'PY'
 import pathlib
-import re
-import subprocess
 import sys
-
-source_path = pathlib.Path(sys.argv[1])
-family_path = pathlib.Path(sys.argv[2])
-accepted_path = pathlib.Path(sys.argv[3])
-goroot = pathlib.Path(sys.argv[4])
-tmp_root = pathlib.Path(sys.argv[5])
-families = {
-    line.strip()
-    for line in family_path.read_text(encoding="utf-8").splitlines()
-    if line.strip() and not line.lstrip().startswith("#")
-}
-selected = []
-for line in source_path.read_text(encoding="utf-8").splitlines():
-    if "|" not in line:
-        continue
-    _, asm = line.split("|", 1)
-    asm = asm.strip()
-    match = re.match(r"^([A-Z][A-Z0-9.]*)\s", asm)
-    if match and match.group(1).split(".", 1)[0] in families:
-        selected.append(line)
-
-env = os.environ.copy()
-env.update({"GOOS": "linux", "GOARCH": "arm64"})
-source = tmp_root / "probe.s"
-obj = tmp_root / "probe.o"
-accepted = []
-rejected = []
-for number, line in enumerate(selected):
-    _, asm = line.split("|", 1)
-    source.write_text(f'#include "textflag.h"\nTEXT ·probe{number}(SB),NOSPLIT,$0-0\n\t{asm.strip()}\n\tRET\n', encoding="utf-8")
-    result = subprocess.run(
-        ["go", "tool", "asm", "-I", str(goroot / "pkg" / "include"), "-o", str(obj), str(source)],
-        env=env,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    (accepted if result.returncode == 0 else rejected).append(line)
-accepted_path.write_text("\n".join(accepted) + "\n", encoding="utf-8")
-print(f"x/arch required families: selected={len(selected)} native_go_accepted={len(accepted)} decoder_only_rejected={len(rejected)}")
-if not accepted or len(selected) < 300:
-    raise SystemExit("x/arch ARM64 Plan 9 family selection is unexpectedly small")
+for value in sys.argv[1:]:
+    print(pathlib.Path(value).resolve(strict=True))
 PY
+)
+go_path=$(printf '%s\n' "$readarray_inputs" | sed -n '1p')
+goroot=$(printf '%s\n' "$readarray_inputs" | sed -n '2p')
+source_cases=$(printf '%s\n' "$readarray_inputs" | sed -n '3p')
+family_file=$(printf '%s\n' "$readarray_inputs" | sed -n '4p')
+"$go_path" run "$repo_root/cmd/plan9asmgooracle" \
+  -cases="$source_cases" -families="$family_file" \
+  -go="$go_path" -goroot="$goroot" -out="$oracle_parent/go-oracle"
+accepted_cases="$oracle_parent/go-oracle/accepted.txt"
 
-accepted_report="$tmp_root/accepted.json"
+accepted_report="$oracle_parent/accepted.json"
 go run "$repo_root/cmd/plan9asmscan" \
   -corpus=arm64-plan9 \
   -input="$accepted_cases" \
diff --git a/scripts/check-coder-websocket.sh b/scripts/check-coder-websocket.sh
deleted file mode 100755
index e8aa05f65..000000000
--- a/scripts/check-coder-websocket.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root=$(cd "$(dirname "$0")/.." && pwd)
-exec "$repo_root/scripts/check-reported-library-corpus.sh" coder-websocket
diff --git a/scripts/check-go-asm-coverage.sh b/scripts/check-go-asm-coverage.sh
index b85b38877..d51de21b4 100755
--- a/scripts/check-go-asm-coverage.sh
+++ b/scripts/check-go-asm-coverage.sh
@@ -70,6 +70,7 @@ if actual_versions != expected_versions:
         "coverage baseline versions differ: "
         f"expected {sorted(expected_versions)}, got {sorted(actual_versions)}"
     )
+latest_version = max(expected_versions, key=lambda item: int(item.split(".")[1]))
 
 fields = (
     "official_opcodes",
@@ -86,6 +87,8 @@ fields = (
     "encoder_opcodes_observed_in_corpus",
     "coverage_fingerprint",
     "encoder_fingerprint",
+    "encoder_rules",
+    "encoder_rule_fingerprint",
 )
 
 for report_path in report_paths:
@@ -121,6 +124,25 @@ for report_path in report_paths:
             f"missing coverage baseline for {version}/{arch}; "
             "inspect the full JSON report and update the baseline intentionally"
         )
+    # This fingerprints retained AVX table expressions, not resolved constants,
+    # encoder helper implementations, or runtime/ABI correctness.
+    # AVX metadata is independently retained only for x86 so far. Missing
+    # metadata is unknown, never an empty-rule or implementation certificate.
+    # Other architectures retain their existing class/namespace coverage;
+    # do not fabricate full encoding-rule coverage for them.
+    if arch in {"386", "amd64"}:
+        for role, entry in (("report", report), ("baseline", expected)):
+            count = entry.get("encoder_rules")
+            fingerprint = entry.get("encoder_rule_fingerprint")
+            if (
+                type(count) is not int or count <= 0
+                or not isinstance(fingerprint, str)
+                or not re.fullmatch(r"[0-9a-f]{64}", fingerprint)
+            ):
+                raise SystemExit(
+                    f"{version}/{arch}: {role} is missing complete "
+                    "encoder_rules/encoder_rule_fingerprint metadata"
+                )
     changed = [
         field for field in fields
         if report.get(field) != expected.get(field)
@@ -154,13 +176,21 @@ for report_path in report_paths:
             if line.strip() and not line.lstrip().startswith("#")
         }
         catalog = {item["opcode"]: item for item in report["opcode_catalog"]}
-        missing_encoder = sorted(op for op in required if not catalog.get(op, {}).get("encoder_forms"))
-        missing_corpus = sorted(op for op in required if not catalog.get(op, {}).get("observed_in_corpus"))
-        unsupported = sorted(op for op in required if catalog.get(op, {}).get("unsupported_forms"))
-        if missing_encoder or missing_corpus or unsupported:
+        available = required.intersection(catalog)
+        unavailable = sorted(required.difference(available))
+        missing_encoder = sorted(op for op in available if not catalog[op].get("encoder_forms"))
+        missing_corpus = sorted(op for op in available if not catalog[op].get("observed_in_corpus"))
+        unsupported = sorted(op for op in available if catalog[op].get("unsupported_forms"))
+        missing_latest = unavailable if version == latest_version else []
+        if missing_latest or missing_encoder or missing_corpus or unsupported:
             raise SystemExit(
                 f"{version}/arm64: incomplete required Go assembler families: "
-                f"missing_encoder={missing_encoder}, missing_corpus={missing_corpus}, unsupported={unsupported}"
+                f"missing_from_latest={missing_latest}, missing_encoder={missing_encoder}, "
+                f"missing_corpus={missing_corpus}, unsupported={unsupported}"
             )
-        print(f"{version}/arm64: all {len(required)} required opcodes are encoder-defined, observed, and lowerable")
+        print(
+            f"{version}/arm64: all {len(available)} toolchain-available required opcodes "
+            f"are encoder-defined, observed, and lowerable"
+            + (f"; {len(unavailable)} future opcodes are absent from this Go release" if unavailable else "")
+        )
 PY
diff --git a/scripts/check-go-hex.sh b/scripts/check-go-hex.sh
deleted file mode 100755
index 1f95fba08..000000000
--- a/scripts/check-go-hex.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root=$(cd "$(dirname "$0")/.." && pwd)
-exec "$repo_root/scripts/check-reported-library-corpus.sh" go-hex
diff --git a/scripts/check-klauspost-compress.sh b/scripts/check-klauspost-compress.sh
deleted file mode 100755
index d6a80c4ce..000000000
--- a/scripts/check-klauspost-compress.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root=$(cd "$(dirname "$0")/.." && pwd)
-exec "$repo_root/scripts/check-reported-library-corpus.sh" klauspost-compress
diff --git a/scripts/check-reported-library-corpus.sh b/scripts/check-reported-library-corpus.sh
deleted file mode 100755
index 8943dafed..000000000
--- a/scripts/check-reported-library-corpus.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-repo_root=$(cd "$(dirname "$0")/.." && pwd)
-suite=${1:-all}
-if [[ $# -gt 1 ]]; then
-  echo "usage: $0 [suite-id|all]" >&2
-  exit 2
-fi
-
-# Resolved relative to the checked-out repository.
-# shellcheck disable=SC1091
-source "$repo_root/scripts/llvm22.sh"
-if ! llc_cmd=$(find_llvm22_llc); then
-  exit 1
-fi
-
-tmp_root=$(mktemp -d)
-trap 'rm -rf "$tmp_root"' EXIT
-translator="$tmp_root/plan9asmll"
-runner="$tmp_root/plan9asmcorpus"
-go build -C "$repo_root/cmd/plan9asmll" -o "$translator" .
-go build -C "$repo_root" -o "$runner" ./cmd/plan9asmcorpus
-
-check_latest=${PLAN9ASM_CORPUS_CHECK_LATEST:-true}
-"$runner" \
-  -manifest="$repo_root/testdata/corpus/reported-libraries.json" \
-  -corpus-dir="$repo_root/testdata/corpus" \
-  -repo-root="$repo_root" \
-  -translator="$translator" \
-  -llc="$llc_cmd" \
-  -suite="$suite" \
-  -check-latest="$check_latest"
diff --git a/scripts/check-stdlib-corpus.sh b/scripts/check-stdlib-corpus.sh
index 5f58aacba..c31812e6f 100755
--- a/scripts/check-stdlib-corpus.sh
+++ b/scripts/check-stdlib-corpus.sh
@@ -1,6 +1,15 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+instructions_only=false
+if (( $# != 0 )); then
+  if (( $# != 1 )) || [[ "$1" != "--instructions-only" ]]; then
+    echo "usage: $0 [--instructions-only]" >&2
+    exit 2
+  fi
+  instructions_only=true
+fi
+
 repo_root=$(cd "$(dirname "$0")/.." && pwd)
 cd "$repo_root"
 
@@ -174,7 +183,7 @@ if unsupported:
     raise SystemExit(f"{target}: unsupported ops remain: {top}")
 if unsupported_forms:
     top = ", ".join(
-        f"{item['form']} ({item['examples'][0] if item.get('examples') else 'no example'})"
+        f"{item['form']} ({item['errors'][0] if item.get('errors') else item['examples'][0] if item.get('examples') else 'no diagnostic'})"
         for item in unsupported_forms[:12]
     )
     raise SystemExit(f"{target}: unsupported operand forms remain: {top}")
@@ -183,10 +192,23 @@ if parse_errs:
     raise SystemExit(f"{target}: parse errors remain: {top}")
 PY
 
+  # WASM needs complete typed-stack/control context even for instruction checks.
+  if [[ "$instructions_only" == true && "$goarch" != wasm ]]; then
+    rm "$json"
+    continue
+  fi
+
   echo "==> transpile+compile $target_label"
   out_dir="$tmp_root/$target_name-ll"
   meta="$tmp_root/$target_name-meta.json"
-  env "${target_env[@]}" GOTOOLCHAIN=local "$plan9asm_cmd" transpile -goos="$goos" -goarch="$goarch" -dir "$out_dir" -meta "$meta" std >/dev/null
+  transpile_log="$tmp_root/$target_name-transpile.log"
+  if ! env "${target_env[@]}" GOTOOLCHAIN=local "$plan9asm_cmd" transpile \
+    -goos="$goos" -goarch="$goarch" -dir "$out_dir" -meta "$meta" std \
+    >"$transpile_log" 2>&1; then
+    cat "$transpile_log" >&2
+    exit 1
+  fi
+  rm "$transpile_log"
 
   ll_count=$(find "$out_dir" -name '*.ll' | wc -l | tr -d ' ')
   if [ "$ll_count" -eq 0 ]; then
@@ -196,7 +218,11 @@ PY
   echo "compiled corpus $target_label: ll_files=$ll_count"
 
   while IFS= read -r ll; do
-    obj="${ll%.ll}.o"
-    "$llc_cmd" -mtriple="$triple" -filetype=obj "$ll" -o "$obj"
+    "$llc_cmd" -mtriple="$triple" -filetype=obj "$ll" -o "$tmp_root/verify-object.o"
   done < <(find "$out_dir" -name '*.ll' | sort)
+
+  # The corpus only checks object compilation. Keep one reusable object and
+  # release each target's IR and scan output before starting the next target.
+  rm "$tmp_root/verify-object.o" "$json" "$meta"
+  rm -r "$out_dir"
 done
diff --git a/scripts/configure-ci-ubuntu-mirrors.py b/scripts/configure-ci-ubuntu-mirrors.py
new file mode 100644
index 000000000..9262d1c07
--- /dev/null
+++ b/scripts/configure-ci-ubuntu-mirrors.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+"""Replace existing Ubuntu runner mirror lists without changing source roles."""
+
+import pathlib
+import sys
+
+
+def configure(apt_dir, architecture):
+    if architecture in ("amd64", "i386"):
+        archive = "https://archive.ubuntu.com/ubuntu/"
+        security = "https://security.ubuntu.com/ubuntu/"
+    else:
+        archive = security = "https://ports.ubuntu.com/ubuntu-ports/"
+
+    # Keep the source files' suites, components and signing keys, along with
+    # unrelated repositories. Direct-source runners need no new mirror lists.
+    for name, url in (("apt-mirrors.txt", archive),
+                      ("apt-mirrors-security.txt", security)):
+        path = apt_dir / name
+        if path.exists():
+            path.write_text(url + "\n")
+    return archive
+
+
+if __name__ == "__main__":
+    print(configure(pathlib.Path(sys.argv[1]), sys.argv[2]))
diff --git a/scripts/install-ci-llvm22-ubuntu.sh b/scripts/install-ci-llvm22-ubuntu.sh
new file mode 100644
index 000000000..fc48a23f7
--- /dev/null
+++ b/scripts/install-ci-llvm22-ubuntu.sh
@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Every Linux CI lane uses the same LLVM 22 toolchain. Avoid repeatedly
+# downloading it when a self-hosted runner already has all required packages.
+packages=(
+  llvm-22-dev clang-22 libclang-22-dev lld-22
+  libunwind-22-dev libc++-22-dev
+  "$@"
+)
+installed=true
+for package in "${packages[@]}"; do
+  if ! dpkg -s "$package" >/dev/null 2>&1; then
+    installed=false
+    break
+  fi
+done
+
+if [[ "$installed" != true ]]; then
+  script_dir=$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)
+  architecture=$(dpkg --print-architecture)
+  ubuntu_archive=$(sudo python3 "$script_dir/configure-ci-ubuntu-mirrors.py" /etc/apt "$architecture")
+  case "$ubuntu_archive" in
+    https://archive.ubuntu.com/ubuntu/|https://ports.ubuntu.com/ubuntu-ports/) ;;
+    *) echo "invalid Ubuntu archive mirror from configuration helper" >&2; exit 1 ;;
+  esac
+  suite=$(lsb_release -cs)
+  key=/etc/apt/trusted.gpg.d/llvm-snapshot.asc
+  curl -4fsSL --connect-timeout 15 --max-time 60 --retry 2 \
+    https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee "$key" >/dev/null
+  echo "deb https://apt.llvm.org/$suite/ llvm-toolchain-$suite-22 main" |
+    sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null
+
+  apt_options=(
+    -o Acquire::ForceIPv4=true -o APT::Update::Error-Mode=any
+    -o Acquire::Retries=2 -o Acquire::http::Timeout=30 -o Acquire::https::Timeout=30
+  )
+  update() {
+    sudo timeout -k 10s 2m apt-get "${apt_options[@]}" update
+  }
+  install() {
+    sudo timeout -k 10s 4m env DEBIAN_FRONTEND=noninteractive \
+      apt-get "${apt_options[@]}" install -y "${packages[@]}"
+  }
+
+  if ! update || ! install; then
+    # Isolate the fallback sources, retaining the same official architecture
+    # route rather than returning to the runner's unreliable mirror candidates.
+    fallback=/etc/apt/sources.list.d/plan9asm-ci-fallback.list
+    {
+      echo "deb [signed-by=/usr/share/keyrings/ubuntu-archive-keyring.gpg] $ubuntu_archive $suite main universe restricted multiverse"
+      echo "deb [signed-by=/usr/share/keyrings/ubuntu-archive-keyring.gpg] $ubuntu_archive $suite-updates main universe restricted multiverse"
+      echo "deb https://apt.llvm.org/$suite/ llvm-toolchain-$suite-22 main"
+    } | sudo tee "$fallback" >/dev/null
+    apt_options+=(
+      -o "Dir::Etc::sourcelist=$fallback"
+      -o Dir::Etc::sourceparts=-
+    )
+    update
+    install
+  fi
+fi
+
+for tool in llvm-config-22 clang-22 llc-22; do
+  if ! command -v "$tool" >/dev/null 2>&1; then
+    echo "missing LLVM 22 tool after installation: $tool" >&2
+    exit 1
+  fi
+done
+if [[ "$(llvm-config-22 --version)" != 22.* ]]; then
+  echo "llvm-config-22 does not select LLVM 22" >&2
+  exit 1
+fi
+if [[ -n "${GITHUB_ENV:-}" ]]; then
+  echo "PATH=/usr/lib/llvm-22/bin:$PATH" >> "$GITHUB_ENV"
+fi
diff --git a/scripts/install-ci-qemu.sh b/scripts/install-ci-qemu.sh
new file mode 100644
index 000000000..80502f2e0
--- /dev/null
+++ b/scripts/install-ci-qemu.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# QEMU 8.2 misexecutes indexed 64-bit SVE dot products, including writes past
+# the vector register at VL=2048. Upstream fix: qemu/qemu@e6b2fa1b81ac.
+# Use pinned static user-mode binaries, without registering binfmt handlers or
+# replacing any system packages. LLVM remains independently pinned to 22.
+version=10.2.3
+release=deploy/v10.2.3-68
+checksum=8e7d8f4c0c7809fc3fea0085199fd6b16f671e7c73d9bf6bec711e1cb535920a
+if [[ "$(uname -s)/$(uname -m)" != Linux/x86_64 ]]; then
+  echo "cross-runtime QEMU installation requires Linux/x86_64" >&2
+  exit 1
+fi
+
+destination=${1:-"$PWD/_out/qemu-$version-linux-amd64"}
+mkdir -p "$destination"
+destination=$(cd "$destination" && pwd)
+scratch=$(mktemp -d)
+trap 'rm -r "$scratch"' EXIT
+archive="$scratch/qemu.tar.gz"
+curl -fLsS --connect-timeout 15 --max-time 180 --retry 2 \
+  "https://github.com/tonistiigi/binfmt/releases/download/$release/qemu_v${version}_linux-amd64.tar.gz" \
+  -o "$archive"
+echo "$checksum  $archive" | sha256sum --check --status
+
+tools=(qemu-aarch64 qemu-arm qemu-i386)
+tar -xzf "$archive" -C "$scratch" "${tools[@]}"
+for tool in "${tools[@]}"; do
+  if [[ "$("$scratch/$tool" --version)" != "$tool version $version "* ]]; then
+    echo "unexpected version for $tool" >&2
+    exit 1
+  fi
+done
+for tool in "${tools[@]}"; do
+  install -m 0755 "$scratch/$tool" "$destination/$tool"
+done
+if [[ -n "${GITHUB_PATH:-}" ]]; then
+  echo "$destination" >> "$GITHUB_PATH"
+fi
+echo "QEMU $version installed in $destination; prepend this directory to PATH."
diff --git a/scripts/test-arm64-fallback-ci.sh b/scripts/test-arm64-fallback-ci.sh
new file mode 100644
index 000000000..93c7644d4
--- /dev/null
+++ b/scripts/test-arm64-fallback-ci.sh
@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Reuse the registered strict selected-CI protocol. Owner zero executes the one
+# complete rich-CLI root; owner one is explicitly empty, not another execution.
+root=TestFallbackARM64WideFrameCompilesWithLLVM22
+mode=${1:?execute or complete required}
+if [[ ${PLAN9ASM_CROSS_EXEC:-} != 1 ]]; then
+  echo 'ARM64 fallback CI requires PLAN9ASM_CROSS_EXEC=1' >&2
+  exit 1
+fi
+
+run_owner_or_reader() {
+  local output=$1
+  shift
+  go run ./cmd/plan9asmtest -dir cmd/plan9asmll -out "$output" \
+    -ci-selector "^${root}$" -ci-isolate-root "$root" \
+    -shards 2 -timeout 5m "$@"
+}
+
+case "$mode" in
+  execute)
+    base=_out/cross-runtime-owner/arm64-fallback-cross
+    mkdir "$base"
+    mkdir "$base/owners"
+    result=0
+    for owner in 0 1; do
+      run_owner_or_reader "$base/owners/cross-runtime-owner-$owner" -ci-owner "$owner" || result=1
+    done
+    output="$base/complete"
+    ;;
+  complete)
+    base=_out/cross-runtime-partitions/cross-runtime-owner-15/arm64-fallback-cross
+    output=_out/cross-runtime-aggregate/arm64-fallback-cross-completion
+    result=0
+    ;;
+  *)
+    echo 'expected execute or complete' >&2
+    exit 2
+    ;;
+esac
+
+run_owner_or_reader "$output" -verify-ci-partitions "$base/owners" || result=1
+node .github/scripts/audit-arm64-fallback.cjs \
+  "$base/owners/cross-runtime-owner-0/root-0000.stdout" \
+  > "$output-required-tests.json" || result=1
+exit "$result"
diff --git a/scripts/test-linux-cli-module-ci.sh b/scripts/test-linux-cli-module-ci.sh
new file mode 100644
index 000000000..aa4430538
--- /dev/null
+++ b/scripts/test-linux-cli-module-ci.sh
@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+module=${1:?plan9asm or plan9asmll required}
+flavor=${2:?test or coverage required}
+phase=${3:?execute or complete required}
+case "$module" in
+  plan9asm|plan9asmll) ;;
+  *) echo 'unknown Linux CLI module' >&2; exit 1 ;;
+esac
+case "$flavor" in
+  test) flags=() ;;
+  coverage) flags=("-coverprofile=coverage-$module.out") ;;
+  *) echo 'unknown Linux CLI suite' >&2; exit 1 ;;
+esac
+stem="linux-cli-$module-$flavor"
+case "$phase" in
+  execute)
+    if [[ $# != 5 || ! $4 =~ ^[012]$ ]]; then
+      echo 'execute requires one owner and its root part (or -1)' >&2
+      exit 1
+    fi
+    if [[ $4 == 0 ]]; then
+      if ! [[ $5 =~ ^[0-3]$ ]]; then
+        echo 'root owner requires part 0..3' >&2
+        exit 1
+      fi
+      output="_out/$stem-root-$5"
+    else
+      if [[ $5 != -1 ]]; then
+        echo 'profile/rest require part -1' >&2
+        exit 1
+      fi
+      output="_out/$stem-owner-$4"
+    fi
+    args=("-module-owner=$4" "-module-root-partition=$5" "-out=$output")
+    ;;
+  complete)
+    if [[ $# != 3 ]]; then
+      echo 'complete does not execute an owner' >&2
+      exit 1
+    fi
+    args=("-verify-module=_out/linux-cli-$module-$flavor-owners"
+      "-out=_out/$stem-verified")
+    ;;
+  *) echo 'unknown Linux CLI suite phase' >&2; exit 1 ;;
+esac
+if [[ -n ${GOFLAGS:-} ]]; then
+  echo 'Linux CLI module suite requires explicit empty GOFLAGS' >&2
+  exit 1
+fi
+export GOFLAGS= GOENV=off GOWORK=off GOTOOLCHAIN=local GOMAXPROCS=2
+mkdir -p _out
+go run ./cmd/plan9asmtest -module "-dir=cmd/$module" "${args[@]}" \
+  -shards=8 -workers=2 -timeout=30m -module-root-partitions=4 -- "${flags[@]}"
+if [[ $phase == complete && $flavor == coverage ]]; then
+  test -s "cmd/$module/coverage-$module.out"
+fi
diff --git a/scripts/test-module-ci.sh b/scripts/test-module-ci.sh
new file mode 100644
index 000000000..f7ed27e0a
--- /dev/null
+++ b/scripts/test-module-ci.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# One actual inventory: sixteen root parts (32 for race), profile/rest once.
+# Every root owner retains two shards. Nested CLIs and Windows run separately.
+flavor=${1:?test, race or coverage required}
+phase=${2:?execute or complete required}
+flags=()
+root_partitions=16
+shards=32
+case "$flavor" in
+  test) timeout=45m ;;
+  race) timeout=60m; flags=(-race); root_partitions=32; shards=64 ;;
+  coverage) timeout=45m; flags=(-coverprofile=coverage-root.out) ;;
+  *) echo "unknown module suite role" >&2; exit 1 ;;
+esac
+if [[ -n "${GOFLAGS:-}" ]]; then
+  echo "module suite requires explicit empty GOFLAGS" >&2
+  exit 1
+fi
+export GOFLAGS= GOENV=off GOWORK=off GOTOOLCHAIN=local GOMAXPROCS=2
+mkdir -p _out
+args=(-module -out="_out/module-$flavor" -shards=$shards -workers=2
+  "-timeout=$timeout" "-module-root-partitions=$root_partitions")
+case "$phase" in
+  execute)
+    if [[ $# != 4 || ! $3 =~ ^[012]$ ]]; then
+      echo "execute requires one owner and its root part (or -1)" >&2
+      exit 1
+    fi
+    if [[ $3 == 0 ]]; then
+      if ! [[ $4 =~ ^([0-9]|[1-9][0-9])$ ]] || (( $4 >= root_partitions )); then
+        echo "root owner requires part 0..$((root_partitions - 1))" >&2
+        exit 1
+      fi
+    elif [[ $4 != -1 ]]; then
+      echo "profile/rest require part -1" >&2
+      exit 1
+    fi
+    args+=("-module-owner=$3" "-module-root-partition=$4")
+    ;;
+  complete)
+    if [[ $# != 2 ]]; then
+      echo "complete does not execute an owner" >&2
+      exit 1
+    fi
+    args=(-module -out="_out/module-$flavor-verified" -shards=$shards -workers=2
+      "-timeout=$timeout" "-module-root-partitions=$root_partitions"
+      "-verify-module=_out/module-$flavor-owners")
+    ;;
+  *) echo "unknown module suite phase" >&2; exit 1 ;;
+esac
+go run ./cmd/plan9asmtest "${args[@]}" -- "${flags[@]}"
diff --git a/scripts/test-windows-module-ci.sh b/scripts/test-windows-module-ci.sh
new file mode 100644
index 000000000..693383504
--- /dev/null
+++ b/scripts/test-windows-module-ci.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+module=${1:?root, plan9asm or plan9asmll required}
+phase=${2:?execute or complete required}
+case "$module" in
+  root) directory=.; parts=16; shards=64 ;;
+  plan9asm|plan9asmll) directory="cmd/$module"; parts=4; shards=8 ;;
+  *) echo 'unknown Windows module' >&2; exit 1 ;;
+esac
+case "$phase" in
+  execute)
+    if [[ $# != 4 || ! $3 =~ ^[012]$ ]]; then
+      echo 'execute requires one owner and its root part (or -1)' >&2
+      exit 1
+    fi
+    if [[ $3 == 0 ]]; then
+      if ! [[ $4 =~ ^([0-9]|[1-9][0-9])$ ]] || (( $4 >= parts )); then
+        echo 'invalid Windows root partition' >&2
+        exit 1
+      fi
+    elif [[ $4 != -1 ]]; then
+      echo 'non-root owners require part -1' >&2
+      exit 1
+    fi
+    args=("-module-owner=$3" "-module-root-partition=$4"
+      "-out=_out/windows-module-$module")
+    ;;
+  complete)
+    if [[ $# != 2 ]]; then
+      echo 'complete does not execute an owner' >&2
+      exit 1
+    fi
+    args=("-verify-module=_out/windows-module-$module-owners"
+      "-out=_out/windows-module-$module-verified")
+    ;;
+  *) echo 'unknown Windows module phase' >&2; exit 1 ;;
+esac
+
+# The LLVM setup action selects byollvm. Both the inherited and explicit Go
+# build context must match; never clear it and select different helper sources.
+if [[ ${GOFLAGS:-} != -tags=byollvm ]]; then
+  echo 'Windows LLVM module suite requires the declared byollvm context' >&2
+  exit 1
+fi
+export GOENV=off GOWORK=off GOTOOLCHAIN=local GOMAXPROCS=2
+if [[ $(go env GOHOSTOS) != windows ]]; then
+  echo 'Windows module driver requires an actual Windows Go toolchain' >&2
+  exit 1
+fi
+
+# Hosted images can differ in unrelated Git/WSL/search entries. Select the
+# tools before freezing PATH; never teach the aggregate to ignore that input.
+# Keep Git's stable cmd/usr directories, not its changing mingw64/ucrt64 bank.
+posix_directory() {
+  local directory=${1%$'\r'}
+  if [[ -z $directory || $directory == *$'\n'* ]]; then
+    echo 'Windows module tool directory must be one nonempty path' >&2
+    return 1
+  fi
+  cygpath -u "$directory"
+}
+
+go_bin=$(posix_directory "$(go env GOROOT)")/bin
+llvm_config=${LLVM_CONFIG:-llvm-config}
+llvm_version=$("$llvm_config" --version)
+llvm_version=${llvm_version%$'\r'}
+if [[ $llvm_version != 22.* || $llvm_version == *$'\n'* ]]; then
+  echo 'Windows module suite requires the selected LLVM 22' >&2
+  exit 1
+fi
+llvm_bin=$(posix_directory "$("$llvm_config" --bindir)")
+node_bin=$(posix_directory "$(node -p "require('path').dirname(process.execPath)")")
+python_bin=$(posix_directory "$(python -c 'import os, sys; print(os.path.dirname(sys.executable))')")
+jq_path=$(command -v jq)
+system_root=$(posix_directory "${SYSTEMROOT:-${SystemRoot:?Windows system root required}}")
+native_root=$(cygpath -m "$PWD")
+mkdir -p _out
+export PATH="$go_bin:$llvm_bin:$node_bin:$python_bin:${jq_path%/*}:/cmd:/usr/bin:$system_root/System32:$system_root"
+hash -r
+
+go run ./cmd/plan9asmtest -module "-dir=$directory" "${args[@]}" \
+  "-shards=$shards" -workers=2 -timeout=30m "-module-root-partitions=$parts" -- \
+  -tags=byollvm "-coverprofile=$native_root/coverage-windows-$module.out"
+if [[ $phase == complete ]]; then
+  test -s "coverage-windows-$module.out"
+fi
diff --git a/small_coverage_test.go b/small_coverage_test.go
index 67425bcf1..6350ce54a 100644
--- a/small_coverage_test.go
+++ b/small_coverage_test.go
@@ -40,16 +40,6 @@ func TestNeedCFGHelpers(t *testing.T) {
 		t.Fatalf("funcNeedsAMD64CFG(straight-line) = true")
 	}
 
-	if !funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: "MOVD.P"}}}) {
-		t.Fatalf("funcNeedsARM64CFG(dot suffix) = false")
-	}
-	if !funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: "B"}}}) {
-		t.Fatalf("funcNeedsARM64CFG(branch) = false")
-	}
-	if funcNeedsARM64CFG(Func{Instrs: []Instr{{Op: OpTEXT}, {Op: OpMRS}, {Op: OpMOVD, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: "R0"}}}, {Op: OpRET}}}) {
-		t.Fatalf("funcNeedsARM64CFG(linear subset) = true")
-	}
-
 	if !funcNeedsARMCFG(Func{Instrs: []Instr{{Op: "ADD.EQ"}}}) {
 		t.Fatalf("funcNeedsARMCFG(cond exec) = false")
 	}
@@ -96,8 +86,8 @@ func TestAMD64EvalI64Coverage(t *testing.T) {
 	if got, err := c.evalI64(Operand{Kind: OpSym, Sym: "$value<>(SB)"}); err != nil || got == "" {
 		t.Fatalf("evalI64(addr sym) = (%q, %v)", got, err)
 	}
-	if got, err := c.evalI64(Operand{Kind: OpSym, Sym: "bad sym"}); err != nil || got != "0" {
-		t.Fatalf("evalI64(unresolved bare sym) = (%q, %v)", got, err)
+	if _, err := c.evalI64(Operand{Kind: OpSym, Sym: "bad sym"}); err == nil {
+		t.Fatal("evalI64(unresolved bare sym) invented a value")
 	}
 	if _, err := c.evalI64(Operand{Kind: OpLabel, Sym: "loop"}); err == nil {
 		t.Fatalf("evalI64(label) unexpectedly succeeded")
diff --git a/stack_offset_names_test.go b/stack_offset_names_test.go
new file mode 100644
index 000000000..ce0e1956f
--- /dev/null
+++ b/stack_offset_names_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import "testing"
+
+func TestNamedStackOffsetIdentifierLengths(t *testing.T) {
+	for _, name := range []string{"n", "N", "_", "x1", "frameSlot"} {
+		for _, test := range []struct {
+			suffix string
+			want   int64
+		}{
+			{"+8", 8}, {"-8", -8}, {"+(2*4)", 8}, {"-(2*4)", -8},
+		} {
+			source := name + test.suffix
+			if got, ok := parseNamedStackConstantOffset(source); !ok || got != test.want {
+				t.Errorf("%s: offset=%d/%v, want %d", source, got, ok, test.want)
+			}
+			memory, ok := parseMem(source + "(SP)")
+			if !ok || memory.Off != test.want {
+				t.Errorf("%s(SP): memory=%+v/%v, want offset %d", source, memory, ok, test.want)
+			}
+		}
+	}
+	for _, source := range []string{"+8", "-8", "1n+8", "n+", "n+missing"} {
+		if got, ok := parseNamedStackConstantOffset(source); ok {
+			t.Errorf("invalid named offset %q accepted as %d", source, got)
+		}
+	}
+}
+
+func TestARM64SingleCharacterStackSlots(t *testing.T) {
+	source := "TEXT single_stack_names(SB),$32-0\nMOVD R0,n-8(SP)\nMOVD n-8(SP),R1\nRET\n"
+	requireARM64GoAssemblerResult(t, source, true)
+	file, err := Parse(ArchARM64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, triple := range []string{"aarch64-apple-darwin", "aarch64-unknown-linux-gnu", "aarch64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			ir, err := Translate(file, Options{Goarch: "arm64", TargetTriple: triple,
+				Sigs: map[string]FuncSig{"single_stack_names": {Name: "single_stack_names", Ret: Void}},
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			compileLLVMToObject(t, llc, triple, "stack_names.ll", "stack_names.o", ir)
+		})
+	}
+}
diff --git a/stdlib_arm64_test_helpers_test.go b/stdlib_arm64_test_helpers_test.go
index c7d8b5a4c..8ee7a9b98 100644
--- a/stdlib_arm64_test_helpers_test.go
+++ b/stdlib_arm64_test_helpers_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -18,19 +15,20 @@ func testGOROOT(t *testing.T) string {
 	if goroot := os.Getenv("GOROOT"); goroot != "" {
 		return goroot
 	}
-	goroot, err := testGoEnv("GOROOT")
+	goroot, err := testGoEnv(t, "GOROOT")
 	if err != nil || goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatalf("GOROOT not available: %v\n%s", err, goroot)
 	}
 	return goroot
 }
 
-func testGoEnv(key string) (string, error) {
-	out, err := exec.Command("go", "env", key).CombinedOutput()
-	if err != nil {
-		return "", err
-	}
-	return strings.TrimSpace(string(out)), nil
+func testGoEnv(t *testing.T, key string) (string, error) {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "env", key)
+	out, err := runtimeOracleCombinedOutput(ctx, command)
+	return strings.TrimSpace(string(out)), err
 }
 
 func compileLLVMToObject(t *testing.T, llc, triple, llName, objName, ll string) {
@@ -41,12 +39,17 @@ func compileLLVMToObject(t *testing.T, llc, triple, llName, objName, ll string)
 	if err := os.WriteFile(llPath, []byte(ll), 0644); err != nil {
 		t.Fatal(err)
 	}
-	cmd := exec.Command(llc, "-mtriple="+triple, "-filetype=obj", llPath, "-o", objPath)
-	out, err := cmd.CombinedOutput()
+	// These tests validate lowering and object emission, not optimizer quality.
+	// Keep them at the corpus runner's O0 level: several large IR fixtures take
+	// minutes each at llc's default O2 and otherwise time out the full suite.
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, llc, "-O0", "-mtriple="+triple, "-filetype=obj", llPath, "-o", objPath)
+	out, err := runtimeOracleCombinedOutput(ctx, cmd)
 	if err != nil {
 		s := string(out)
 		if llcUnsupportedTarget(s) {
-			t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+			t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
 		}
 		t.Fatalf("llc failed: %v\n%s", err, s)
 	}
diff --git a/stdlib_arm64_typed_native_effects_test.go b/stdlib_arm64_typed_native_effects_test.go
new file mode 100644
index 000000000..35a8cb49f
--- /dev/null
+++ b/stdlib_arm64_typed_native_effects_test.go
@@ -0,0 +1,109 @@
+//go:build go1.27
+// +build go1.27
+
+package plan9asm
+
+import (
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func arm64TypedNativeStdlibPackage(t *testing.T, path, declarations string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "declarations.go", declarations, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := types.Config{Importer: importer.Default(), Sizes: types.SizesFor("gc", "arm64")}
+	pkg, err := conf.Check(path, fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: path, Types: pkg, Syntax: []*ast.File{file}}
+}
+
+func arm64TypedNativeStdlibObject(t *testing.T, sourcePath string) {
+	t.Helper()
+	cmd := exec.Command("go", "tool", "asm", "-p", "runtime",
+		"-I", filepath.Join(testGOROOT(t), "pkg/include"),
+		"-o", filepath.Join(t.TempDir(), "original.o"), sourcePath)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=arm64")
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("Go 1.27 assembler rejected unchanged standard-library source: %v\n%s", err, out)
+	}
+}
+
+func TestStdlibARM64TypedNativeEffectsMemHashCompleteSource(t *testing.T) {
+	goroot := testGOROOT(t)
+	sourcePath := filepath.Join(goroot, "src/internal/runtime/maps/memhash_arm64.s")
+	arm64TypedNativeStdlibObject(t, sourcePath)
+	source, err := os.ReadFile(sourcePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations, err := os.ReadFile(filepath.Join(goroot, "src/internal/runtime/maps/memhash_aes_asm.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := arm64TypedNativeStdlibPackage(t, "internal/runtime/maps", string(declarations))
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			tr, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+				GOARCH: "arm64", GOOS: "linux", TargetTriple: target,
+				ResolveSym: testResolveSym("internal/runtime/maps"),
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer tr.Module.Dispose()
+			if len(tr.Functions) != 3 {
+				t.Fatal("memhash complete source must retain all three functions")
+			}
+			compileLLVMToObject(t, llc, target, "memhash-arm64.ll", "memhash-arm64.o", tr.Module.String())
+		})
+	}
+}
+
+func TestStdlibARM64TypedNativeEffectsMemclrCompleteSource(t *testing.T) {
+	sourcePath := filepath.Join(testGOROOT(t), "src/runtime/memclr_arm64.s")
+	arm64TypedNativeStdlibObject(t, sourcePath)
+	source, err := os.ReadFile(sourcePath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := arm64TypedNativeStdlibPackage(t, "runtime", "package runtime\nimport \"unsafe\"\nfunc memclrNoHeapPointers(ptr unsafe.Pointer,n uintptr)\n")
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range arm64TypedNativeTargets {
+		t.Run(target, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			tr, err := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+				GOARCH: "arm64", GOOS: "linux", TargetTriple: target, ResolveSym: testResolveSym("runtime"),
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer tr.Module.Dispose()
+			compileLLVMToObject(t, llc, target, "memclr-arm64.ll", "memclr-arm64.o", tr.Module.String())
+		})
+	}
+}
diff --git a/stdlib_bytealg_arm_compile_test.go b/stdlib_bytealg_arm_compile_test.go
index 1c2793aa4..18d354738 100644
--- a/stdlib_bytealg_arm_compile_test.go
+++ b/stdlib_bytealg_arm_compile_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -15,15 +12,15 @@ import (
 func TestStdlibInternalBytealg_ARM_Compile(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 	goroot := runtime.GOROOT()
 	if goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatal("GOROOT not available")
 	}
 	sfiles := stdlibBytealgARMSigs(goroot)
 	if len(sfiles) == 0 {
-		t.Skip("internal/bytealg arm asm files not present in this GOROOT")
+		t.Fatal("internal/bytealg arm asm files not present in this GOROOT")
 	}
 	resolve := func(sym string) string {
 		sym = goStripABISuffix(sym)
@@ -76,7 +73,7 @@ func TestStdlibInternalBytealg_ARM_Compile(t *testing.T) {
 				strings.Contains(s, "unknown target triple") ||
 				strings.Contains(s, "unknown target") ||
 				strings.Contains(s, "is not a registered target") {
-				t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+				t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
 			}
 			t.Fatalf("llc failed for %s: %v\n%s", path, err, s)
 		}
diff --git a/stdlib_bytealg_compile_test.go b/stdlib_bytealg_compile_test.go
index 8828d1977..01ce8d51e 100644
--- a/stdlib_bytealg_compile_test.go
+++ b/stdlib_bytealg_compile_test.go
@@ -1,9 +1,7 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"errors"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -12,20 +10,23 @@ import (
 	"testing"
 )
 
-func TestStdlibInternalBytealg_ARM64_Compile(t *testing.T) {
+// This is partial function object coverage, not a complete-file or standard
+// library pass. An ordinary declaration omits memequal_varlen's closure R26
+// input; that genuine missing entry contract remains an explicit negative.
+func TestStdlibInternalBytealg_ARM64_PartialFunctionObjectsAndClosureContext(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := runtime.GOROOT()
 	if goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatal("GOROOT not available")
 	}
 
 	sfiles := stdlibBytealgARM64Sigs(goroot)
 	if len(sfiles) == 0 {
-		t.Skip("internal/bytealg arm64 asm files not present in this GOROOT")
+		t.Fatal("internal/bytealg arm64 asm files not present in this GOROOT")
 	}
 
 	resolve := func(sym string) string {
@@ -55,36 +56,63 @@ func TestStdlibInternalBytealg_ARM64_Compile(t *testing.T) {
 		if err != nil {
 			t.Fatalf("parse %s: %v", path, err)
 		}
-		ll, err := Translate(file, Options{
-			TargetTriple: triple,
-			ResolveSym:   resolve,
-			Sigs:         sigs,
-			Goarch:       "arm64",
-		})
-		if err != nil {
-			t.Fatalf("translate %s: %v", path, err)
+		// These manually reviewed Go transport types are an explicit fixture
+		// contract only for source ABIInternal entries. A classic Frame alone
+		// remains insufficient. This gate compiles objects, not all bytealg
+		// runtime semantics; Count has a separate actual Go/LLVM oracle.
+		for _, fn := range file.Funcs {
+			if !strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+				continue
+			}
+			name := resolve(fn.Sym)
+			sig := sigs[name]
+			sig.ARM64GoRegisterABI, err = arm64GoRegisterABIForSig(sig)
+			if err != nil {
+				t.Fatalf("explicit bytealg fixture contract %s: %v", name, err)
+			}
+			sigs[name] = sig
 		}
+		for _, fn := range file.Funcs {
+			selected := *file
+			selected.Funcs = []Func{fn}
+			ll, err := Translate(&selected, Options{
+				TargetTriple: triple,
+				ResolveSym:   resolve,
+				Sigs:         sigs,
+				Goarch:       "arm64",
+			})
+			if resolve(fn.Sym) == "runtime.memequal_varlen" {
+				if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "R26 read") {
+					t.Fatalf("missing Go closure entry must remain Context, got %v", err)
+				}
+				t.Logf("not an object/file pass: %s requires the missing typed closure R26 entry contract", fn.Sym)
+				continue
+			}
+			if err != nil {
+				t.Fatalf("translate function %s in %s: %v", fn.Sym, path, err)
+			}
 
-		tmp := t.TempDir()
-		llPath := filepath.Join(tmp, filepath.Base(path)+".ll")
-		objPath := filepath.Join(tmp, filepath.Base(path)+".o")
-		if err := os.WriteFile(llPath, []byte(ll), 0644); err != nil {
-			t.Fatal(err)
-		}
-		cmd := exec.Command(llc, "-mtriple="+triple, "-filetype=obj", llPath, "-o", objPath)
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			s := string(out)
-			if strings.Contains(s, "No available targets") ||
-				strings.Contains(s, "no targets are registered") ||
-				strings.Contains(s, "unknown target triple") ||
-				strings.Contains(s, "unknown target") ||
-				strings.Contains(s, "is not a registered target") {
-				t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+			tmp := t.TempDir()
+			llPath := filepath.Join(tmp, filepath.Base(path)+".ll")
+			objPath := filepath.Join(tmp, filepath.Base(path)+".o")
+			if err := os.WriteFile(llPath, []byte(ll), 0644); err != nil {
+				t.Fatal(err)
+			}
+			cmd := exec.Command(llc, "-mtriple="+triple, "-filetype=obj", llPath, "-o", objPath)
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				s := string(out)
+				if strings.Contains(s, "No available targets") ||
+					strings.Contains(s, "no targets are registered") ||
+					strings.Contains(s, "unknown target triple") ||
+					strings.Contains(s, "unknown target") ||
+					strings.Contains(s, "is not a registered target") {
+					t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+				}
+				t.Fatalf("llc failed for %s: %v\n%s", path, err, s)
 			}
-			t.Fatalf("llc failed for %s: %v\n%s", path, err, s)
+			compiled++
 		}
-		compiled++
 	}
 	if compiled == 0 {
 		t.Fatalf("expected at least one successful llc compilation")
@@ -96,7 +124,10 @@ func stdlibBytealgARM64Sigs(goroot string) map[string]map[string]FuncSig {
 		filepath.Join(goroot, "src", "internal", "bytealg", "compare_arm64.s"): {
 			"internal/bytealg.Compare": sigWithClassicFrame("internal/bytealg.Compare", []LLVMType{"{ ptr, i64, i64 }", "{ ptr, i64, i64 }"}, I64),
 			"runtime.cmpstring":        sigWithClassicFrame("runtime.cmpstring", []LLVMType{"{ ptr, i64 }", "{ ptr, i64 }"}, I64),
-			"internal/bytealg.cmpbody": sigWithClassicFrame("internal/bytealg.cmpbody", []LLVMType{Ptr, I64, Ptr, I64}, I64),
+			"internal/bytealg.cmpbody": {
+				Name: "internal/bytealg.cmpbody", Args: []LLVMType{Ptr, I64, Ptr, I64},
+				Ret: I64, ArgRegs: []Reg{"R0", "R1", "R2", "R3"},
+			},
 		},
 		filepath.Join(goroot, "src", "internal", "bytealg", "count_arm64.s"): {
 			"internal/bytealg.Count":       sigWithClassicFrame("internal/bytealg.Count", []LLVMType{"{ ptr, i64, i64 }", "i8"}, I64),
@@ -133,25 +164,29 @@ func stdlibBytealgARM64Sigs(goroot string) map[string]map[string]FuncSig {
 		sfiles[path][resolved] = sig
 	}
 
+	// Private source helpers have documented physical register inputs, not
+	// independently allocated ABI0 argument/result frames. In particular,
+	// memeqbody returns in R0 while the search/count helpers write through
+	// their explicit result pointer. These are test-owned partial contracts.
 	addIfPresent(
 		filepath.Join(goroot, "src", "internal", "bytealg", "equal_arm64.s"),
 		"memeqbody<>",
-		sigWithClassicFrame("internal/bytealg.memeqbody", []LLVMType{Ptr, Ptr, I64}, I1),
+		FuncSig{Args: []LLVMType{Ptr, Ptr, I64}, Ret: I1, ArgRegs: []Reg{"R0", "R1", "R2"}},
 	)
 	addIfPresent(
 		filepath.Join(goroot, "src", "internal", "bytealg", "index_arm64.s"),
 		"indexbody<>",
-		withArgRegs(sigWithClassicFrame("internal/bytealg.indexbody", []LLVMType{Ptr, I64, Ptr, I64, Ptr}, Void), []Reg{"R0", "R1", "R2", "R3", "R9"}),
+		FuncSig{Args: []LLVMType{Ptr, I64, Ptr, I64, Ptr}, Ret: Void, ArgRegs: []Reg{"R0", "R1", "R2", "R3", "R9"}},
 	)
 	addIfPresent(
 		filepath.Join(goroot, "src", "internal", "bytealg", "indexbyte_arm64.s"),
 		"indexbytebody<>",
-		withArgRegs(sigWithClassicFrame("internal/bytealg.indexbytebody", []LLVMType{Ptr, "i8", I64, Ptr}, Void), []Reg{"R0", "R1", "R2", "R8"}),
+		FuncSig{Args: []LLVMType{Ptr, "i8", I64, Ptr}, Ret: Void, ArgRegs: []Reg{"R0", "R1", "R2", "R8"}},
 	)
 	addIfPresent(
 		filepath.Join(goroot, "src", "internal", "bytealg", "count_arm64.s"),
 		"countbytebody<>",
-		withArgRegs(sigWithClassicFrame("internal/bytealg.countbytebody", []LLVMType{Ptr, I64, "i8", Ptr}, Void), []Reg{"R0", "R2", "R1", "R8"}),
+		FuncSig{Args: []LLVMType{Ptr, I64, "i8", Ptr}, Ret: Void, ArgRegs: []Reg{"R0", "R2", "R1", "R8"}},
 	)
 
 	for path := range sfiles {
diff --git a/stdlib_bytealg_parse_test.go b/stdlib_bytealg_parse_test.go
index 659f127aa..bda5333e6 100644
--- a/stdlib_bytealg_parse_test.go
+++ b/stdlib_bytealg_parse_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -13,12 +10,12 @@ import (
 func TestParseStdlibInternalBytealgArm64Compare(t *testing.T) {
 	goroot := runtime.GOROOT()
 	if goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatal("GOROOT not available")
 	}
 	path := filepath.Join(goroot, "src", "internal", "bytealg", "compare_arm64.s")
 	src, err := os.ReadFile(path)
 	if err != nil {
-		t.Skipf("read %s: %v", path, err)
+		t.Fatalf("read %s: %v", path, err)
 	}
 	if _, err := Parse(ArchARM64, string(src)); err != nil {
 		t.Fatalf("parse %s: %v", path, err)
@@ -28,7 +25,7 @@ func TestParseStdlibInternalBytealgArm64Compare(t *testing.T) {
 func TestParseStdlibInternalBytealg_Amd64AndArm64(t *testing.T) {
 	goroot := runtime.GOROOT()
 	if goroot == "" {
-		t.Skip("GOROOT not available")
+		t.Fatal("GOROOT not available")
 	}
 	dir := filepath.Join(goroot, "src", "internal", "bytealg")
 	glob := func(pat string) []string {
@@ -53,7 +50,7 @@ func TestParseStdlibInternalBytealg_Amd64AndArm64(t *testing.T) {
 		}{arch: ArchAMD64, path: p})
 	}
 	if len(files) == 0 {
-		t.Skipf("no bytealg asm files found under %s", dir)
+		t.Fatalf("no bytealg asm files found under %s", dir)
 	}
 
 	for _, f := range files {
diff --git a/stdlib_cpu_arm64_test.go b/stdlib_cpu_arm64_test.go
index 971776115..459619699 100644
--- a/stdlib_cpu_arm64_test.go
+++ b/stdlib_cpu_arm64_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -13,14 +10,14 @@ import (
 func TestStdlibInternalCPU_ARM64_Compile(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := testGOROOT(t)
 	src, err := os.ReadFile(filepath.Join(goroot, "src", "internal", "cpu", "cpu_arm64.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("internal/cpu/cpu_arm64.s not present in this GOROOT")
+			t.Fatal("internal/cpu/cpu_arm64.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
diff --git a/stdlib_cpu_x86_test.go b/stdlib_cpu_x86_test.go
index f36f5521c..1dd9c90d6 100644
--- a/stdlib_cpu_x86_test.go
+++ b/stdlib_cpu_x86_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -15,7 +12,7 @@ import (
 func TestStdlibInternalCPU_X86_CompileX86Triples(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := runtime.GOROOT()
@@ -110,11 +107,11 @@ func TestStdlibInternalCPU_X86_CompileX86Triples(t *testing.T) {
 				if strings.HasPrefix(triple, "x86_64-") {
 					t.Fatalf("translate failed: %v", err)
 				}
-				t.Skipf("translate skipped for non-x86 triple %q: %v", triple, err)
+				t.Fatalf("translate skipped for non-x86 triple %q: %v", triple, err)
 			}
 
 			if !strings.HasPrefix(triple, "x86_64-") {
-				t.Skip("llc compilation only meaningful for x86_64 triples")
+				t.Fatal("llc compilation only meaningful for x86_64 triples")
 			}
 
 			tmp := t.TempDir()
@@ -132,7 +129,7 @@ func TestStdlibInternalCPU_X86_CompileX86Triples(t *testing.T) {
 					strings.Contains(s, "unknown target triple") ||
 					strings.Contains(s, "unknown target") ||
 					strings.Contains(s, "is not a registered target") {
-					t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+					t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
 				}
 				t.Fatalf("llc failed for triple %q: %v\n%s", triple, err, s)
 			}
diff --git a/stdlib_crc32_amd64_test.go b/stdlib_crc32_amd64_test.go
deleted file mode 100644
index 64888d421..000000000
--- a/stdlib_crc32_amd64_test.go
+++ /dev/null
@@ -1,126 +0,0 @@
-//go:build !llgo
-// +build !llgo
-
-package plan9asm
-
-import (
-	"os"
-	"os/exec"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-func TestStdlibHashCRC32_AMD64_Compile(t *testing.T) {
-	_, clang, ok := findLlcAndClang(t)
-	if !ok || clang == "" {
-		t.Skip("clang not found")
-	}
-
-	goroot := runtime.GOROOT()
-	src, err := os.ReadFile(filepath.Join(goroot, "src", "hash", "crc32", "crc32_amd64.s"))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	file, err := Parse(ArchAMD64, string(src))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	resolve := func(sym string) string {
-		if strings.HasPrefix(sym, "·") {
-			return "hash/crc32." + strings.TrimPrefix(sym, "·")
-		}
-		return strings.ReplaceAll(sym, "·", ".")
-	}
-
-	sliceTy := LLVMType("{ ptr, i64, i64 }")
-	ret3 := LLVMType("{ i32, i32, i32 }")
-	sigs := map[string]FuncSig{
-		"hash/crc32.castagnoliSSE42": {
-			Name: "hash/crc32.castagnoliSSE42",
-			Args: []LLVMType{I32, sliceTy},
-			Ret:  I32,
-			Frame: FrameLayout{
-				Params: []FrameSlot{
-					{Offset: 0, Type: I32, Index: 0, Field: -1},
-					{Offset: 8, Type: Ptr, Index: 1, Field: 0},
-					{Offset: 16, Type: I64, Index: 1, Field: 1},
-					{Offset: 24, Type: I64, Index: 1, Field: 2},
-				},
-				Results: []FrameSlot{{Offset: 32, Type: I32, Index: 0, Field: -1}},
-			},
-		},
-		"hash/crc32.castagnoliSSE42Triple": {
-			Name: "hash/crc32.castagnoliSSE42Triple",
-			Args: []LLVMType{I32, I32, I32, sliceTy, sliceTy, sliceTy, I32},
-			Ret:  ret3,
-			Frame: FrameLayout{
-				Params: []FrameSlot{
-					{Offset: 0, Type: I32, Index: 0, Field: -1},
-					{Offset: 4, Type: I32, Index: 1, Field: -1},
-					{Offset: 8, Type: I32, Index: 2, Field: -1},
-					{Offset: 16, Type: Ptr, Index: 3, Field: 0},
-					{Offset: 24, Type: I64, Index: 3, Field: 1},
-					{Offset: 32, Type: I64, Index: 3, Field: 2},
-					{Offset: 40, Type: Ptr, Index: 4, Field: 0},
-					{Offset: 48, Type: I64, Index: 4, Field: 1},
-					{Offset: 56, Type: I64, Index: 4, Field: 2},
-					{Offset: 64, Type: Ptr, Index: 5, Field: 0},
-					{Offset: 72, Type: I64, Index: 5, Field: 1},
-					{Offset: 80, Type: I64, Index: 5, Field: 2},
-					{Offset: 88, Type: I32, Index: 6, Field: -1},
-				},
-				Results: []FrameSlot{
-					{Offset: 96, Type: I32, Index: 0, Field: -1},
-					{Offset: 100, Type: I32, Index: 1, Field: -1},
-					{Offset: 104, Type: I32, Index: 2, Field: -1},
-				},
-			},
-		},
-		"hash/crc32.ieeeCLMUL": {
-			Name: "hash/crc32.ieeeCLMUL",
-			Args: []LLVMType{I32, sliceTy},
-			Ret:  I32,
-			Frame: FrameLayout{
-				Params: []FrameSlot{
-					{Offset: 0, Type: I32, Index: 0, Field: -1},
-					{Offset: 8, Type: Ptr, Index: 1, Field: 0},
-					{Offset: 16, Type: I64, Index: 1, Field: 1},
-					{Offset: 24, Type: I64, Index: 1, Field: 2},
-				},
-				Results: []FrameSlot{{Offset: 32, Type: I32, Index: 0, Field: -1}},
-			},
-		},
-	}
-
-	ll, err := Translate(file, Options{
-		TargetTriple: "x86_64-unknown-linux-gnu",
-		ResolveSym:   resolve,
-		Sigs:         sigs,
-		Goarch:       "amd64",
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(ll, `"target-features"="+crc32,+sse4.2"`) {
-		t.Fatalf("missing crc32 target-features attr:\n%s", ll)
-	}
-	if !strings.Contains(ll, `"target-features"="+pclmul,+sse4.1"`) {
-		t.Fatalf("missing pclmul target-features attr:\n%s", ll)
-	}
-
-	tmp := t.TempDir()
-	llPath := filepath.Join(tmp, "crc32_amd64.ll")
-	objPath := filepath.Join(tmp, "crc32_amd64.o")
-	if err := os.WriteFile(llPath, []byte(ll), 0644); err != nil {
-		t.Fatal(err)
-	}
-	cmd := exec.Command(clang, "-target", "x86_64-unknown-linux-gnu", "-c", llPath, "-o", objPath)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("clang failed: %v\n%s", err, string(out))
-	}
-}
diff --git a/stdlib_math_exp_arm64_test.go b/stdlib_math_exp_arm64_test.go
index 69daac3c9..4cb1acf71 100644
--- a/stdlib_math_exp_arm64_test.go
+++ b/stdlib_math_exp_arm64_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -15,7 +12,7 @@ import (
 func TestStdlibMathExp_ARM64_Compile(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := runtime.GOROOT()
@@ -92,7 +89,7 @@ func TestStdlibMathExp_ARM64_Compile(t *testing.T) {
 					strings.Contains(s, "unknown target triple") ||
 					strings.Contains(s, "unknown target") ||
 					strings.Contains(s, "is not a registered target") {
-					t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+					t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
 				}
 				t.Fatalf("llc failed for %q: %v\n%s", triple, err, s)
 			}
diff --git a/stdlib_runtime_sys_arm64_test.go b/stdlib_runtime_sys_arm64_test.go
index d6f2c372d..9fc27ab68 100644
--- a/stdlib_runtime_sys_arm64_test.go
+++ b/stdlib_runtime_sys_arm64_test.go
@@ -1,5 +1,5 @@
-//go:build !llgo
-// +build !llgo
+//go:build go1.27
+// +build go1.27
 
 package plan9asm
 
@@ -13,14 +13,14 @@ import (
 func TestStdlibInternalRuntimeSys_ARM64_Compile(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := testGOROOT(t)
 	src, err := os.ReadFile(filepath.Join(goroot, "src", "internal", "runtime", "sys", "dit_arm64.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("internal/runtime/sys/dit_arm64.s not present in this GOROOT")
+			t.Fatal("internal/runtime/sys/dit_arm64.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
@@ -71,34 +71,63 @@ func TestStdlibInternalRuntimeSys_ARM64_Compile(t *testing.T) {
 func TestTranslateGoModule_StdlibInternalRuntimeSys_ARM64_Compile(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := testGOROOT(t)
 	src, err := os.ReadFile(filepath.Join(goroot, "src", "internal", "runtime", "sys", "dit_arm64.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("internal/runtime/sys/dit_arm64.s not present in this GOROOT")
+			t.Fatal("internal/runtime/sys/dit_arm64.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
 	pkg := mustGoPackage(t, "internal/runtime/sys", `package sys
+// Go 1.27 ARM64 has 128 bytes of padding followed by ten feature booleans.
+// This supplies the real generated assembler constant; it does not modify
+// the original assembly or substitute its DIT/barrier instructions.
+const offsetARM64HasSB = 138
 func EnableDIT() bool
 func DITEnabled() bool
 func DisableDIT()
 `)
 
-	tr, err := TranslateGoModule(pkg, src, GoModuleOptions{
-		FileName:     "dit_arm64.s",
-		GOOS:         "linux",
-		GOARCH:       "arm64",
-		TargetTriple: arm64LinuxGNUTriple,
-		ResolveSym:   testResolveSym("internal/runtime/sys"),
-	})
-	if err != nil {
-		t.Fatal(err)
+	for _, target := range []struct {
+		goos, triple string
+	}{
+		{"linux", "aarch64-unknown-linux-gnu"},
+		{"linux", "aarch64-unknown-linux-musl"},
+		{"darwin", "aarch64-apple-darwin"},
+		{"windows", "aarch64-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			// Assemble the same complete preprocessed source independently.
+			// No DIT-changing instruction is executed by this object-only test.
+			oracle, err := preprocessWithDefines("#define const_offsetARM64HasSB 138\n"+string(src), GoAssemblerDefines(target.goos, "arm64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			requireARM64GoAssemblerResult(t, oracle, true)
+			tr, err := TranslateGoModule(pkg, src, GoModuleOptions{
+				FileName: "dit_arm64.s", GOOS: target.goos, GOARCH: "arm64",
+				TargetTriple: target.triple, ResolveSym: testResolveSym("internal/runtime/sys"),
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer tr.Module.Dispose()
+			ir := tr.Module.String()
+			if len(tr.Functions) != 3 {
+				t.Fatalf("DIT production translation has %d functions, want all three", len(tr.Functions))
+			}
+			if target.goos == "darwin" {
+				if strings.Contains(ir, "unreachable") {
+					t.Fatal("Darwin barrier fallback is reachable and must retain its caller return")
+				}
+			} else if !strings.Contains(ir, "unreachable") {
+				t.Fatal("non-Darwin dead barrier fallback must not fabricate a native branch or return")
+			}
+			compileLLVMToObject(t, llc, target.triple, "dit-gomod.ll", "dit-gomod.o", ir)
+		})
 	}
-	defer tr.Module.Dispose()
-
-	compileLLVMToObject(t, llc, arm64LinuxGNUTriple, "dit-gomod.ll", "dit-gomod.o", tr.Module.String())
 }
diff --git a/stdlib_sig_test.go b/stdlib_sig_test.go
index ea66a6956..48f8cbd87 100644
--- a/stdlib_sig_test.go
+++ b/stdlib_sig_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
@@ -15,21 +12,21 @@ import (
 func TestStdlibBoringSig_CompileManyTriples(t *testing.T) {
 	llc, _, ok := findLlcAndClang(t)
 	if !ok {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 
 	goroot := runtime.GOROOT()
 	srcOther, err := os.ReadFile(filepath.Join(goroot, "src", "crypto", "internal", "boring", "sig", "sig_other.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("crypto/internal/boring/sig/sig_other.s not present in this GOROOT")
+			t.Fatal("crypto/internal/boring/sig/sig_other.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
 	srcAMD64, err := os.ReadFile(filepath.Join(goroot, "src", "crypto", "internal", "boring", "sig", "sig_amd64.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("crypto/internal/boring/sig/sig_amd64.s not present in this GOROOT")
+			t.Fatal("crypto/internal/boring/sig/sig_amd64.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
@@ -99,7 +96,7 @@ func TestStdlibBoringSig_CompileManyTriples(t *testing.T) {
 						strings.Contains(s, "unknown target triple") ||
 						strings.Contains(s, "unknown target") ||
 						strings.Contains(s, "is not a registered target") {
-						t.Skipf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
+						t.Fatalf("llc does not support triple %q: %s", triple, strings.TrimSpace(s))
 					}
 					t.Fatalf("llc failed for triple %q: %v\n%s", triple, err, s)
 				}
@@ -118,7 +115,7 @@ func TestStdlibBoringSig_TranslateOnly(t *testing.T) {
 	src, err := os.ReadFile(filepath.Join(goroot, "src", "crypto", "internal", "boring", "sig", "sig_amd64.s"))
 	if err != nil {
 		if os.IsNotExist(err) {
-			t.Skip("crypto/internal/boring/sig/sig_amd64.s not present in this GOROOT")
+			t.Fatal("crypto/internal/boring/sig/sig_amd64.s not present in this GOROOT")
 		}
 		t.Fatal(err)
 	}
diff --git a/symbol_offset_context.go b/symbol_offset_context.go
new file mode 100644
index 000000000..b9033d4c5
--- /dev/null
+++ b/symbol_offset_context.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+import "strings"
+
+// A source relocation retains one original symbol plus a signed generated-header
+// integer expression, not a different symbol name or a zero displacement.
+// Call only after the complete instruction's operand/modifier grammar checks.
+func sourceSymbolOffsetNeedsContext(symbol string) bool {
+	source := strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(symbol), "$"))
+	if !strings.HasSuffix(source, "(SB)") {
+		return false
+	}
+	body := strings.TrimSpace(strings.TrimSuffix(source, "(SB)"))
+	name, _, resolved := parseSymbolOffset(body)
+	if resolved || name == "" {
+		return false
+	}
+	identifier := strings.TrimSuffix(name, "<>")
+	if !validPPIdentifier(identifier) {
+		return false
+	}
+	return goIntegerExpressionNeedsContext(strings.TrimSpace(body[len(name):]))
+}
diff --git a/target_backend_guard.go b/target_backend_guard.go
new file mode 100644
index 000000000..e5b72357f
--- /dev/null
+++ b/target_backend_guard.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Goarch selects the source encoder/ABI rules. It is not a backend selector:
+// portable lowering may legitimately target a different LLVM architecture.
+func validateBackendSourceGoarch(file *File, options Options) error {
+	if file == nil || options.Goarch == "" {
+		return nil
+	}
+	valid := true
+	switch file.Arch {
+	case ArchAMD64:
+		valid = options.Goarch == "amd64" || options.Goarch == "386"
+	case ArchARM:
+		valid = options.Goarch == "arm"
+	case ArchARM64:
+		valid = options.Goarch == "arm64"
+	case ArchWASM:
+		valid = options.Goarch == "wasm"
+	}
+	if !valid {
+		return fmt.Errorf("%w: source architecture %q conflicts with Goarch %q",
+			ErrProbeNeedsContext, file.Arch, options.Goarch)
+	}
+	return nil
+}
+
+// validateTranslatedBackend checks the actual returned module, including early
+// native-source returns. Keep target-independent source lowering portable.
+func validateTranslatedBackend(file *File, options Options, module llvm.Module) error {
+	requestedTriple := module.Target()
+	// Match the backend LLVM22 will actually select, including omitted or
+	// reordered fields. Keep the request and source-owner options unchanged.
+	triple := llvmNormalizedTargetTriple(requestedTriple)
+	architecture, _, _ := strings.Cut(triple, "-")
+	// LLVM's x86 intrinsic namespace is target-specific. Check intrinsic IDs
+	// and actual uses: ordinary names and unused declarations stay portable.
+	goarch := options.Goarch
+	if goarch == "" && file != nil && file.Arch == ArchAMD64 {
+		goarch = "amd64" // The same source-mode default as translateIR.
+	}
+	if !x86ScalarFloatIntegerNativeTarget(goarch, triple) {
+		mxcsrTarget := x86ScalarFloatIntegerNativeTarget("amd64", triple) ||
+			x86ScalarFloatIntegerNativeTarget("386", triple)
+		for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+			if function.IntrinsicID() != 0 && !function.FirstUse().IsNil() &&
+				strings.HasPrefix(function.Name(), "llvm.x86.") {
+				// LLVM 22 maps these two intrinsics to an i32 memory operand
+				// in either x86 mode (X86InstrSSE.td). Source pointer width
+				// does not constrain the control register; other families do.
+				if mxcsrTarget && (function.Name() == "llvm.x86.sse.ldmxcsr" ||
+					function.Name() == "llvm.x86.sse.stmxcsr") {
+					continue
+				}
+				return fmt.Errorf("%w: x86 intrinsic %q requires its matching x86 LLVM target, got %q",
+					ErrProbeNeedsContext, function.Name(), requestedTriple)
+			}
+		}
+	}
+	if err := validateTranslatedNativeBackend(file, goarch, triple, module); err != nil {
+		return err
+	}
+	if architecture == "wasm32" || architecture == "wasm64" {
+		for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+			for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+				// A BasicBlock is not an ordinary LLVM constant operand. Its
+				// constant users are BlockAddress values, whether those addresses
+				// are nested in expressions, aggregates, aliases or instructions.
+				// Inspect their actual def-use edges rather than printed names,
+				// source annotations or the spelling of a particular lowerer.
+				for use := block.AsValue().FirstUse(); !use.IsNil(); use = use.NextUse() {
+					if !use.User().IsAConstant().IsNil() {
+						return fmt.Errorf("%w: LLVM target %q cannot represent blockaddress in %q",
+							ErrProbeNeedsContext, requestedTriple, function.Name())
+					}
+				}
+			}
+		}
+	}
+	if arm64ScalarConversionNativeTarget(triple) {
+		return nil
+	}
+	if file != nil && file.Arch == ArchARM64 {
+		// Reuse the complete named/raw family classifier even when a caller
+		// supplies custom attributes. Raw literal-pool words are data, not SVE
+		// instructions. Pure scalable-vector operations also need this check;
+		// they need not contain an llvm.aarch64 intrinsic call.
+		view := arm64NativeTargetCodeView(file)
+		for _, function := range view.Funcs {
+			features := inferFuncTargetFeaturesForGOARCH(view.Arch, options.Goarch, function)
+			for _, feature := range strings.Split(features, ",") {
+				if strings.HasPrefix(feature, "+sve") {
+					return fmt.Errorf("%w: ARM64 SVE requires an explicit AArch64 LLVM target, got %q",
+						ErrProbeNeedsContext, requestedTriple)
+				}
+			}
+		}
+	}
+	// Declarations in an architecture prelude are not executed requirements.
+	// An actually referenced target intrinsic must nevertheless stay on its
+	// backend, including any future lowering not yet in the source classifier.
+	for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+		if strings.HasPrefix(function.Name(), "llvm.aarch64.sve.") && !function.FirstUse().IsNil() {
+			return fmt.Errorf("%w: used ARM64 SVE intrinsic %q requires an AArch64 LLVM target, got %q",
+				ErrProbeNeedsContext, function.Name(), requestedTriple)
+		}
+	}
+	return nil
+}
+
+func validateTranslatedNativeBackend(file *File, goarch, triple string, module llvm.Module) error {
+	if file != nil {
+		// Normal native requests need no instruction walk. Reuse the same
+		// source-mode and endian boundaries as the typed family validators.
+		switch file.Arch {
+		case ArchAMD64:
+			if x86ScalarFloatIntegerNativeTarget(goarch, triple) {
+				return nil
+			}
+		case ArchARM:
+			if armWordFloatNativeTarget(triple) {
+				return nil
+			}
+		case ArchARM64:
+			if arm64ScalarConversionNativeTarget(triple) {
+				return nil
+			}
+		case ArchWASM:
+			architecture, _, _ := strings.Cut(triple, "-")
+			if architecture == "wasm32" {
+				return nil
+			}
+		}
+	}
+	if llvmModuleHasAssembly(module) {
+		return fmt.Errorf("%w: used module assembly requires its matching source LLVM target, got %q",
+			ErrProbeNeedsContext, module.Target())
+	}
+	var scalableVectorKind llvm.TypeKind
+	if file != nil && file.Arch == ArchAMD64 {
+		scalableVectorKind = llvmScalableVectorKind(module.Context())
+	}
+	for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+		for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+			for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+				if file != nil && file.Arch == ArchAMD64 && x86InstructionUsesSegmentMemory(instruction, scalableVectorKind) {
+					return fmt.Errorf("%w: used x86 FS/GS segment memory in %q requires its matching source-mode LLVM target, got %q",
+						ErrProbeNeedsContext, function.Name(), module.Target())
+				}
+				for index := 0; index < instruction.OperandsCount(); index++ {
+					assembly := instruction.Operand(index).IsAInlineAsm()
+					if assembly.IsNil() {
+						continue
+					}
+					info := assembly.InlineAsmInfo()
+					if info.Assembly == "" {
+						// Existing memory and generic-register compiler barriers
+						// compile on x86, ARM64 and WASM without source registers.
+						switch info.Constraints {
+						case "", "~{memory}", "r", "=r,0":
+							continue
+						}
+					}
+					return fmt.Errorf("%w: used native inline assembly in %q requires its matching source LLVM target, got %q",
+						ErrProbeNeedsContext, function.Name(), module.Target())
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// Inspect memory address roles, not pointer-valued results, stored values,
+// declarations, unused constants or address calculations. Native requests
+// return before this walk. Calls with unknown effects conservatively consume
+// their pointer arguments; explicit LLVM memory(none) transport does not.
+func x86InstructionUsesSegmentMemory(instruction llvm.Value, scalableVectorKind llvm.TypeKind) bool {
+	first, end := 0, 1
+	switch instruction.InstructionOpcode() {
+	case llvm.Load, llvm.VAArg:
+	case llvm.Store:
+		first, end = 1, 2
+	case llvm.Call, llvm.Invoke:
+		kind := llvm.AttributeKindID("memory")
+		if attribute := instruction.GetCallSiteEnumAttribute(-1, kind); !attribute.IsNil() && attribute.GetEnumValue() == 0 {
+			return false
+		}
+		if callee := instruction.CalledValue().IsAFunction(); !callee.IsNil() {
+			if attribute := callee.GetEnumFunctionAttribute(kind); !attribute.IsNil() && attribute.GetEnumValue() == 0 {
+				return false
+			}
+		}
+		end = llvmCallArgumentCount(instruction)
+		if end > 2 && !instruction.IsAMemIntrinsic().IsNil() {
+			if length := instruction.Operand(2).IsAConstantInt(); !length.IsNil() && length.IsNull() {
+				return false // A constant-zero transfer performs no source or destination access.
+			}
+		}
+	default:
+		if !llvmInstructionIsAtomicMemory(instruction) {
+			return false
+		}
+	}
+	for index := first; index < end; index++ {
+		typ := instruction.Operand(index).Type()
+		if typ.TypeKind() == llvm.VectorTypeKind || typ.TypeKind() == scalableVectorKind {
+			typ = typ.ElementType()
+		}
+		if typ.TypeKind() == llvm.PointerTypeKind {
+			if space := typ.PointerAddressSpace(); space == 256 || space == 257 {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/target_backend_guard_test.go b/target_backend_guard_test.go
new file mode 100644
index 000000000..2b21937b2
--- /dev/null
+++ b/target_backend_guard_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type targetBackendCase struct {
+	arch   Arch
+	goarch string
+	body   string
+	result bool
+	attrs  string
+}
+
+// Goarch describes the source's Go rules, not the backend architecture.
+// Every entry point must preserve that distinction and the same output guard.
+func targetBackendRequest(t *testing.T, api, triple string, row targetBackendCase) (string, error) {
+	t.Helper()
+	args, declaration := "0", "func backendContract()"
+	sig := FuncSig{Name: "backendContract", Ret: Void, Attrs: row.attrs}
+	if row.result {
+		args, declaration = "8", "func backendContract() uint64"
+		sig.Ret = I64
+		sig.Frame.Results = []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}
+	}
+	source := "TEXT backendContract(SB),4,$0-" + args + "\n" + row.body + "\n"
+	file, err := Parse(row.arch, source)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: row.goarch, TargetTriple: triple,
+		Sigs: map[string]FuncSig{"backendContract": sig}, AnnotateSource: true}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		mod, err := TranslateModuleInContext(ctx, file, options)
+		if mod.IsNil() {
+			return "", err
+		}
+		defer mod.Dispose()
+		return mod.String(), err
+	}
+	pkg := mustGoPackage(t, "backendcontract", "package backendcontract\n"+declaration+"\n")
+	bound, err := translateGoModuleInContext(ctx, pkg,
+		[]byte(strings.Replace(source, "TEXT backendContract", "TEXT ·backendContract", 1)),
+		GoModuleOptions{GOOS: "linux", GOARCH: row.goarch, TargetTriple: triple, AnnotateSource: true})
+	if bound == nil {
+		return "", err
+	}
+	defer bound.Module.Dispose()
+	return bound.Module.String(), err
+}
+
+func TestTargetBackendPortableCrossArchitecture(t *testing.T) {
+	for _, row := range []targetBackendCase{
+		{arch: ArchARM64, goarch: "arm64", body: "MOVD $3, R0 // blockaddress( is only a source comment\nMOVD R0, ret+0(FP)\nRET", result: true},
+		{arch: ArchAMD64, goarch: "amd64", body: "MOVQ $3, ret+0(FP)\nRET", result: true},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", "wasm32-unknown-wasi"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", row.goarch, triple, api), func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, triple, row)
+					if err != nil || ir == "" {
+						t.Fatalf("portable source was confused with backend architecture: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTargetBackendRejectsWasmBlockAddresses(t *testing.T) {
+	for _, op := range []string{"ADR", "ADRP"} {
+		row := targetBackendCase{arch: ArchARM64, goarch: "arm64", result: true,
+			body: op + " target, R0\nMOVD R0, ret+0(FP)\nRET\ntarget:\nRET"}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(op+"/"+api+"/native-control", func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", row)
+				if err != nil || !strings.Contains(ir, "blockaddress(") {
+					t.Fatalf("native control did not retain its real local code address: %v", err)
+				}
+			})
+			for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-unknown-wasi", "wasm64-unknown-unknown"} {
+				t.Run(op+"/"+api+"/"+triple, func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, triple, row)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("WASM received a local code address: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTargetBackendSVENeedsAArch64(t *testing.T) {
+	// Cover native intrinsics, generic scalable operations and raw decoding.
+	// A guard based only on opcode spelling or inferred attributes is incomplete.
+	for _, body := range []string{
+		"CNTB R0\nRET",
+		"WORD $0x0420e3ea\nRET", // CNTB X10.
+		"ZSUB Z1.S, Z2.S, Z3.S\nRET",
+		"WORD $0x05203800\nRET", // DUP Z0.B, W0: generic scalable IR.
+		"ZMATCH Z0.B, Z1.B, P0.Z, P2.B\nRET",
+	} {
+		for _, attrs := range []string{"", "nounwind"} {
+			row := targetBackendCase{arch: ArchARM64, goarch: "arm64", body: body, attrs: attrs}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%s/%s/native-control", body, attrs, api), func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, "aarch64-unknown-linux-gnu", row)
+					if err != nil || ir == "" {
+						t.Fatalf("native SVE control rejected: output=%t err=%v", ir != "", err)
+					}
+				})
+				for _, triple := range []string{"", "x86_64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%s", body, attrs, api, triple), func(t *testing.T) {
+						ir, err := targetBackendRequest(t, api, triple, row)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("SVE escaped to a non-AArch64 or unspecified backend: output=%t err=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestTargetBackendRejectsSourceGoarchMismatch(t *testing.T) {
+	for _, row := range []targetBackendCase{
+		{arch: ArchARM64, goarch: "wasm", body: "RET"},
+		{arch: ArchARM64, goarch: "amd64", body: "RET"},
+		{arch: ArchAMD64, goarch: "arm64", body: "RET"},
+		{arch: ArchAMD64, goarch: "wasm", body: "RET"},
+	} {
+		for _, api := range []string{"text", "module"} {
+			for _, triple := range []string{"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+				t.Run(fmt.Sprintf("%s/%s/%s/%s", row.arch, row.goarch, triple, api), func(t *testing.T) {
+					ir, err := targetBackendRequest(t, api, triple, row)
+					if ir != "" || err == nil {
+						t.Fatalf("source architecture accepted conflicting Goarch: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/target_backend_inline_asm_test.go b/target_backend_inline_asm_test.go
new file mode 100644
index 000000000..bd9e99dcc
--- /dev/null
+++ b/target_backend_inline_asm_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestTargetBackendInitializedCPUQueryRequiresNativeTarget(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		native := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			native = "i386-unknown-linux-gnu"
+		}
+		for _, opcode := range []string{"CPUID", "XGETBV"} {
+			// All implicit dword inputs are initialized. Neither a missing
+			// leaf nor Void/result proof can mask the backend counterexample.
+			source := "TEXT ·Query(SB),4,$0-0\nMOVL $0,AX\nMOVL $0,CX\n" + opcode + "\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+opcode+"/"+api+"/native", func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Query()", arch, native, api)
+					if err != nil || !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(opcode)+"\"") {
+						t.Fatal("initialized native CPU-query control rejected or lost its real asm", err)
+					}
+					x86ResultInitializationObject(t, llc, native, ir, "cpu-query")
+				})
+				for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					t.Run(arch+"/"+opcode+"/"+api+"/"+triple, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Query()", arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("initialized CPU-query inline asm escaped to an unspecified or foreign backend", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestTargetBackendInlineAsmGuardUsesActualValuesAndConstraints(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, row := range []struct {
+		name, body string
+		native     bool
+	}{
+		{"another-opcode", `define void @ordinary() {
+  call void asm sideeffect "pause", "~{memory}"()
+  ret void
+}`, true},
+		{"value-producing-asm", `define i32 @ordinary() {
+  %value = call i32 asm "bswapl $0", "=r,0"(i32 7)
+  ret i32 %value
+}`, true},
+		{"empty-fixed-register", `define i32 @ordinary() {
+  %value = call i32 asm sideeffect "", "={ax}"()
+  ret i32 %value
+}`, true},
+		{"empty-memory-barrier", `define void @ordinary() {
+  call void asm sideeffect "", "~{memory}"()
+  ret void
+}`, false},
+		{"empty-generic-register-use", `define void @ordinary() {
+  call void asm sideeffect "", "r"(i32 7)
+  ret void
+}`, false},
+		{"empty-generic-passthrough", `define i32 @ordinary() {
+  %value = call i32 asm sideeffect "", "=r,0"(i32 7)
+  ret i32 %value
+}`, false},
+		{"ordinary-name-and-string", `@annotation = private constant [6 x i8] c"cpuid\00"
+define i32 @CPUID() { ret i32 7 }`, false},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			t.Run(row.name+"/"+triple, func(t *testing.T) {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := parseIRModuleInContext(ctx, fmt.Sprintf("target triple = %q\n%s\n", triple, row.body))
+				if err != nil {
+					t.Fatal("backend regression has malformed LLVM IR", err)
+				}
+				defer module.Dispose()
+				// A detached, unused InlineAsm constant in this same context is
+				// not a module requirement. Source spelling alone is not one,
+				// either: the guard must follow actual module uses.
+				_ = llvm.InlineAsm(llvm.FunctionType(ctx.VoidType(), nil, false), "cpuid", "~{memory}",
+					true, false, llvm.InlineAsmDialectATT, false)
+				file := &File{Arch: ArchAMD64}
+				if row.name == "ordinary-name-and-string" {
+					file.Funcs = []Func{{Sym: "CPUID", Instrs: []Instr{{Op: OpCPUID}}}}
+				}
+				err = validateTranslatedBackend(file, Options{Goarch: "amd64"}, module)
+				if row.native && triple != "x86_64-unknown-linux-gnu" {
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("used native inline asm or fixed-register constraints escaped the shared backend guard", err)
+					}
+				} else if err != nil {
+					t.Fatal("portable IR, compiler barrier or matching native target was rejected", err)
+				} else if !row.native && triple != "" {
+					x86ResultInitializationObject(t, llc, triple, module.String(), "portable-barrier")
+				}
+			})
+		}
+	}
+}
+
+func TestTargetBackendInlineAsmSourceFamilies(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, source := range []struct {
+		arch           Arch
+		goarch, native string
+	}{
+		{ArchAMD64, "", "x86_64-unknown-linux-gnu"},
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu"},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown"},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", ""} {
+			t.Run(string(source.arch)+"/"+source.goarch+"/"+triple, func(t *testing.T) {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := parseIRModuleInContext(ctx, fmt.Sprintf(`target triple = %q
+define void @ordinary() {
+  call void asm sideeffect "nop", "~{memory}"()
+  ret void
+}
+`, triple))
+				if err != nil {
+					t.Fatal(err)
+				}
+				defer module.Dispose()
+				err = validateTranslatedBackend(&File{Arch: source.arch}, Options{Goarch: source.goarch}, module)
+				if source.native != "" && triple == source.native {
+					if err != nil {
+						t.Fatal("matching source backend rejected native asm", err)
+					}
+					x86ResultInitializationObject(t, llc, triple, module.String(), "source-native-asm")
+				} else if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("source-specific asm escaped its matching backend", err)
+				}
+			})
+		}
+	}
+}
diff --git a/target_backend_module_asm_test.go b/target_backend_module_asm_test.go
new file mode 100644
index 000000000..9d4bac8e7
--- /dev/null
+++ b/target_backend_module_asm_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestTargetBackendModuleAssemblyUsesActualModule(t *testing.T) {
+	for _, source := range []struct {
+		arch           Arch
+		goarch, native string
+	}{
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu"},
+		{ArchWASM, "wasm", "wasm32-unknown-unknown"},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", ""} {
+			for _, assembly := range []string{"", ".byte 0"} {
+				t.Run(source.goarch+"/"+triple+"/"+assembly, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module := ctx.NewModule("actual")
+					defer module.Dispose()
+					module.SetTarget(triple)
+					module.SetInlineAsm(assembly)
+					detached := ctx.NewModule("detached")
+					defer detached.Dispose()
+					detached.SetInlineAsm("cpuid")
+					err := validateTranslatedBackend(&File{Arch: source.arch}, Options{Goarch: source.goarch}, module)
+					if assembly == "" || triple == source.native {
+						if err != nil {
+							t.Fatal("empty or matching module assembly rejected", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("actual module assembly escaped its source backend", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTargetBackendWASMDataModuleAssemblyThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	row := targetBackendCase{arch: ArchWASM, goarch: "wasm", body: "RET\nDATA holder<>+0(SB)/8,$external(SB)\nGLOBL holder<>(SB),16,$8"}
+	for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-unknown-wasi", "", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, triple, row)
+				if strings.HasPrefix(triple, "wasm32-") {
+					if err != nil || !strings.Contains(ir, "module asm") {
+						t.Fatal("matching WASM DATA lost its actual assembly relocation", err)
+					}
+					x86ResultInitializationObject(t, llc, triple, ir, "wasm-data-relocation")
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("WASM DATA module assembly escaped to an unspecified or foreign backend", ir != "", err)
+				}
+			})
+		}
+	}
+}
diff --git a/target_backend_wasm_reordered_triple_test.go b/target_backend_wasm_reordered_triple_test.go
new file mode 100644
index 000000000..5ec259f21
--- /dev/null
+++ b/target_backend_wasm_reordered_triple_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// LLVM22 actually accepts this spelling as a wasm32 target. A source-based
+// or raw-first-field WASM check must not let ARM64 code addresses escape.
+func TestTargetBackendReorderedWASMRejectsBlockAddressThreeAPIs(t *testing.T) {
+	row := targetBackendCase{arch: ArchARM64, goarch: "arm64", result: true,
+		body: "ADR target,R0\nMOVD R0,ret+0(FP)\nRET\ntarget:\nRET"}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := targetBackendRequest(t, api, "unknown-unknown-wasm32", row)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("LLVM's reordered WASM target received blockaddress", ir != "", err)
+			}
+		})
+	}
+}
+
+func TestTargetBackendReorderedWASMPortableThreeAPIsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	const triple = "unknown-unknown-wasm32"
+	row := targetBackendCase{arch: ArchAMD64, goarch: "amd64", result: true,
+		body: "MOVQ $3,ret+0(FP)\nRET"}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := targetBackendRequest(t, api, triple, row)
+			if err != nil || ir == "" || !strings.Contains(ir, "target triple = \""+triple+"\"") {
+				t.Fatal("portable source was rejected or had its actual target rewritten", err)
+			}
+			x86ResultInitializationObject(t, llc, triple, ir, "reordered-wasm-portable")
+		})
+	}
+}
diff --git a/target_backend_wasm_short_triple_test.go b/target_backend_wasm_short_triple_test.go
new file mode 100644
index 000000000..7a2f13e26
--- /dev/null
+++ b/target_backend_wasm_short_triple_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestTargetBackendWASMShortTargetsThreeAPIsActualObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	row := targetBackendCase{arch: ArchWASM, goarch: "wasm",
+		body: "RET\nDATA holder<>+0(SB)/8,$external(SB)\nGLOBL holder<>(SB),16,$8"}
+	for _, target := range []struct {
+		triple string
+		native bool
+	}{
+		{"wasm32-wasi", true},
+		{"wasm32--wasi", true},
+		{"wasm32", true},
+		{"wasm32-unknown-wasi", true},
+		{"wasm32-notreal", true},
+		{"unknown-unknown-wasm32", true},
+		{"", false},
+		{"x86_64-linux-gnu", false},
+		{"aarch64-linux-gnu", false},
+		{"wasm64-wasi", false},
+		{"wasm32bad-wasi", false},
+		{"xwasm32-wasi", false},
+		{"wasm32x-wasi", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, target.triple, row)
+				if !target.native {
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unspecified, foreign or wrong-width target accepted real WASM module assembly", ir != "", err)
+					}
+					return
+				}
+				if err != nil || !strings.Contains(ir, "module asm") ||
+					!strings.Contains(ir, "target triple = \""+target.triple+"\"") {
+					t.Fatal("valid LLVM WASM target was rejected, rewritten or lost its real relocation", err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "wasm-short-target")
+			})
+		}
+	}
+}
+
+func TestTargetBackendWASMShortTargetsKeepSourceModeBoundary(t *testing.T) {
+	for _, goarch := range []string{"386", "amd64", "arm64"} {
+		for _, api := range []string{"text", "module"} {
+			t.Run(goarch+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, "wasm32-wasi",
+					targetBackendCase{arch: ArchWASM, goarch: goarch, body: "RET"})
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("normalized target supplied a conflicting source Goarch", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestTargetBackendWASMShortTargetsKeepBlockAddressBoundary(t *testing.T) {
+	row := targetBackendCase{arch: ArchARM64, goarch: "arm64", result: true,
+		body: "ADR target,R0\nMOVD R0,ret+0(FP)\nRET\ntarget:\nRET"}
+	for _, triple := range []string{"wasm32-wasi", "wasm32--wasi", "wasm32"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := targetBackendRequest(t, api, triple, row)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("short WASM target received blockaddress", ir != "", err)
+				}
+			})
+		}
+	}
+}
diff --git a/target_backend_x86_intrinsics_test.go b/target_backend_x86_intrinsics_test.go
new file mode 100644
index 000000000..dcea45df0
--- /dev/null
+++ b/target_backend_x86_intrinsics_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86BackendMantissaSource(arch string) string {
+	move, bytes, offset := "MOVQ", 16, 8
+	if arch == "386" {
+		move, bytes, offset = "MOVL", 8, 4
+	}
+	return fmt.Sprintf(`TEXT ·Probe(SB),4,$0-%d
+%s out+0(FP),DI
+%s input+%d(FP),SI
+VMOVUPS (SI),Z0
+VMOVUPS (SI),Z1
+VGETMANTPS $0,X1,X0
+VMOVUPS Z0,(DI)
+RET
+`, bytes, move, move, offset)
+}
+
+func TestTargetBackendX86IntrinsicPublicAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source := x86BackendMantissaSource(arch)
+		x86LEAActualTargetGoObject(t, arch, map[string]string{"amd64": "x86_64-unknown-linux-gnu", "386": "i386-unknown-linux-gnu"}[arch], source)
+		for _, triple := range []string{"arm64-apple-macosx", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Probe(out,input *[64]byte)", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "intrinsic") {
+						t.Fatal("complete initialized function escaped its actual x86 intrinsic backend", len(ir), err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTargetBackendPackedStringInitializedPublicAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		matching := testTargetTriple("linux", arch)
+		for _, row := range go127PackedStringCompareSpecs() {
+			source := "TEXT ·Probe(SB),4,$0-0\nPXOR X0,X0\nPXOR X1,X1\nMOVL $16,AX\nMOVL $16,DX\n" +
+				row.op + " $8,X0,X1\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, triple := range []string{matching, "", "aarch64-unknown-linux-gnu"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+row.op+"/"+triple+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Probe()", arch, triple, api)
+						if triple == matching {
+							if err != nil || !strings.Contains(ir, "call ") || !strings.Contains(ir, "@llvm.x86.sse42.pcmp") {
+								t.Fatal("initialized packed-string family lost its explicit native target", err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "intrinsic") {
+							t.Fatal("missing or mismatched target published initialized native-intrinsic IR", len(ir), err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestTargetBackendX86IntrinsicDefaultModeAndModuleCleanup(t *testing.T) {
+	source := x86BackendMantissaSource("amd64")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "backend", "package backend\nfunc Probe(out,input *[64]byte)\n")
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, mode := range []string{"", "amd64"} {
+		for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			t.Run(mode+"/"+triple, func(t *testing.T) {
+				options := Options{Goarch: mode, TargetTriple: triple, Sigs: sigs, ResolveSym: resolve}
+				native := strings.HasPrefix(triple, "x86_64-")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				for attempt := 0; attempt < 3; attempt++ {
+					module, err := TranslateModuleInContext(ctx, file, options)
+					published := !module.IsNil()
+					if published {
+						module.Dispose()
+					}
+					if native {
+						if err != nil || !published {
+							t.Fatal("default source mode lost its explicit matching target", err)
+						}
+					} else if published || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "intrinsic") {
+						t.Fatal("rejected backend published a module or lost its error", err)
+					}
+				}
+				text, err := Translate(file, options)
+				if native && (text == "" || err != nil) || !native && (text != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+					t.Fatal("text and owned-module target boundaries disagree", len(text), err)
+				}
+			})
+		}
+	}
+	// The public completion guard also wraps the direct-module early return.
+	// An x86 source alone must not constrain a genuinely portable module.
+	for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+		t.Run("direct-portable/"+triple, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT portable(SB),4,$0-0\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			options := Options{TargetTriple: triple, Sigs: map[string]FuncSig{"portable": {Name: "portable", Ret: Void}}}
+			for _, translate := range []func(llvm.Context, *File, Options) (llvm.Module, error){
+				translateModuleDirectInContext, TranslateModuleInContext,
+			} {
+				module, err := translate(ctx, file, options)
+				published := !module.IsNil()
+				if published {
+					module.Dispose()
+				}
+				if err != nil || !published {
+					t.Fatal("portable early module return acquired a native backend restriction", err)
+				}
+			}
+		})
+	}
+}
+
+func TestTargetBackendX86IntrinsicNamespaceAndUses(t *testing.T) {
+	for _, row := range []struct {
+		name, declaration, call string
+		x86Intrinsic            bool
+	}{
+		{"llvm.x86.sse.stmxcsr", "declare void @llvm.x86.sse.stmxcsr(ptr)", "call void @llvm.x86.sse.stmxcsr(ptr null)", true},
+		{"llvm.x86.sse.ldmxcsr", "declare void @llvm.x86.sse.ldmxcsr(ptr)", "call void @llvm.x86.sse.ldmxcsr(ptr null)", true},
+		{"llvm.x86.sse.rcp.ps", "declare <4 x float> @llvm.x86.sse.rcp.ps(<4 x float>)", "%v = call <4 x float> @llvm.x86.sse.rcp.ps(<4 x float> zeroinitializer)", true},
+		{"llvm.x86.sha1msg1", "declare <4 x i32> @llvm.x86.sha1msg1(<4 x i32>,<4 x i32>)", "%v = call <4 x i32> @llvm.x86.sha1msg1(<4 x i32> zeroinitializer,<4 x i32> zeroinitializer)", true},
+		{"llvm.x86.application.helper", "declare void @llvm.x86.application.helper()", "call void @llvm.x86.application.helper()", false},
+		{"application.llvm.x86.sse.stmxcsr", "declare void @application.llvm.x86.sse.stmxcsr()", "call void @application.llvm.x86.sse.stmxcsr()", false},
+		{"llvm.ctpop.i64", "declare i64 @llvm.ctpop.i64(i64)", "%v = call i64 @llvm.ctpop.i64(i64 7)", false},
+	} {
+		for _, used := range []bool{false, true} {
+			for _, target := range []struct{ mode, triple string }{
+				{"amd64", "x86_64-unknown-linux-gnu"}, {"386", "i386-unknown-linux-gnu"},
+				{"386", "i686-pc-windows-msvc"}, {"amd64", "aarch64-unknown-linux-gnu"},
+				{"amd64", "wasm32-unknown-unknown"}, {"amd64", ""}, {"386", "x86_64-unknown-linux-gnu"},
+			} {
+				t.Run(fmt.Sprintf("%s/used%t/%s/%s", row.name, used, target.mode, target.triple), func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					call := ""
+					if used {
+						call = row.call
+					}
+					module, err := parseIRModuleInContext(ctx, fmt.Sprintf("target triple = %q\n%s\ndefine void @caller() {\n%s\nret void\n}\n", target.triple, row.declaration, call))
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer module.Dispose()
+					function := module.NamedFunction(row.name)
+					if function.IsNil() || row.x86Intrinsic && function.IntrinsicID() == 0 || strings.Contains(row.name, "application") && function.IntrinsicID() != 0 {
+						t.Fatal("LLVM intrinsic identity assumption changed", row.name)
+					}
+					err = validateTranslatedBackend(&File{Arch: ArchAMD64}, Options{Goarch: target.mode}, module)
+					wantReject := used && row.x86Intrinsic && !x86ScalarFloatIntegerNativeTarget(target.mode, target.triple)
+					if (row.name == "llvm.x86.sse.ldmxcsr" || row.name == "llvm.x86.sse.stmxcsr") &&
+						strings.HasPrefix(target.triple, "x86_64-") {
+						wantReject = false // The i32 MXCSR memory operand is independent of source pointer width.
+					}
+					if wantReject != errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("intrinsic identity/use or source/backend mode classification changed", wantReject, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTargetBackendMXCSRWidthIndependentIntrinsicBoundary(t *testing.T) {
+	for _, row := range []struct {
+		name, declaration, call string
+		widthIndependent        bool
+	}{
+		{"llvm.x86.sse.ldmxcsr", "declare void @llvm.x86.sse.ldmxcsr(ptr)", "call void @llvm.x86.sse.ldmxcsr(ptr null)", true},
+		{"llvm.x86.sse.stmxcsr", "declare void @llvm.x86.sse.stmxcsr(ptr)", "call void @llvm.x86.sse.stmxcsr(ptr null)", true},
+		{"llvm.x86.rdrand.64", "declare {i64,i32} @llvm.x86.rdrand.64()", "%random = call {i64,i32} @llvm.x86.rdrand.64()", false},
+		{"llvm.x86.rdseed.64", "declare {i64,i32} @llvm.x86.rdseed.64()", "%random = call {i64,i32} @llvm.x86.rdseed.64()", false},
+	} {
+		for _, triple := range []string{
+			"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu", "i686-pc-windows-msvc",
+			"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", "",
+		} {
+			for _, used := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/used%t", row.name, triple, used), func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					body := ""
+					if used {
+						body = row.call
+					}
+					module, err := parseIRModuleInContext(ctx, fmt.Sprintf("target triple = %q\n%s\ndefine void @caller() {\n%s\nret void\n}\n", triple, row.declaration, body))
+					if err != nil {
+						t.Fatal(err)
+					}
+					defer module.Dispose()
+					if module.NamedFunction(row.name).IntrinsicID() == 0 {
+						t.Fatal("mode boundary fixture is not an actual LLVM intrinsic")
+					}
+					err = validateTranslatedBackend(&File{Arch: ArchAMD64}, Options{Goarch: "amd64"}, module)
+					native := triple == "x86_64-unknown-linux-gnu" || row.widthIndependent &&
+						(triple == "i386-unknown-linux-gnu" || triple == "i686-pc-windows-msvc")
+					if wantReject := used && !native; wantReject != errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("MXCSR width independence changed another intrinsic's mode boundary", wantReject, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/target_backend_x86_segment_test.go b/target_backend_x86_segment_test.go
new file mode 100644
index 000000000..056ca4aee
--- /dev/null
+++ b/target_backend_x86_segment_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestTargetBackendX86SegmentCompleteGPInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := append(x86GPFaultingReadCases(arch), x86GPSegmentCompareRows(arch)...)
+			var fixtures []x86GPSegmentFixture
+			for _, row := range rows {
+				for _, segment := range []string{"FS", "GS"} {
+					for _, live := range []bool{false, true} {
+						name := fmt.Sprintf("Hardware%d", len(fixtures))
+						fixtures = append(fixtures, x86GPSegmentSource(row, arch, name, segment, "fixed-zero", "", live))
+					}
+				}
+			}
+			x86GPSegmentGoObjects(t, arch, fixtures)
+			for _, fixture := range fixtures {
+				for _, triple := range []string{testTargetTriple("linux", arch), "", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fixture.row.family+"/"+fixture.row.instruction+"/"+fixture.label+"/"+triple+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, arch, triple, api)
+							if triple == testTargetTriple("linux", arch) {
+								if err != nil || !strings.Contains(ir, "ptr addrspace(") {
+									t.Fatal("fully initialized segment source lost its matching target", err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("ACTUAL_SEGMENT_ACCESS_ESCAPED_BACKEND", len(ir), err)
+							}
+						})
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestTargetBackendX86SegmentActualMemoryUses(t *testing.T) {
+	type memoryUse struct {
+		name, declaration, body string
+		hardware                bool
+	}
+	rows := []memoryUse{
+		{"load", "", "%v = load volatile i32, ptr addrspace(SEG) null\nret void", true},
+		{"store", "", "store volatile i32 1, ptr addrspace(SEG) null\nret void", true},
+		{"atomic-rmw", "", "%v = atomicrmw add ptr addrspace(SEG) null, i32 1 seq_cst\nret void", true},
+		{"atomic-cas", "", "%v = cmpxchg ptr addrspace(SEG) null, i32 1, i32 2 seq_cst seq_cst\nret void", true},
+		{"called-address", "declare void @consumer(ptr addrspace(SEG))", "call void @consumer(ptr addrspace(SEG) null)\nret void", true},
+		{"memory-intrinsic", "declare void @llvm.memcpy.pSEG.p0.i64(ptr addrspace(SEG), ptr, i64, i1)",
+			"call void @llvm.memcpy.pSEG.p0.i64(ptr addrspace(SEG) null, ptr null, i64 1, i1 false)\nret void", true},
+		{"memory-source", "declare void @llvm.memcpy.p0.pSEG.i64(ptr, ptr addrspace(SEG), i64, i1)",
+			"call void @llvm.memcpy.p0.pSEG.i64(ptr null, ptr addrspace(SEG) null, i64 1, i1 false)\nret void", true},
+		{"memory-move-source", "declare void @llvm.memmove.p0.pSEG.i64(ptr, ptr addrspace(SEG), i64, i1)",
+			"call void @llvm.memmove.p0.pSEG.i64(ptr null, ptr addrspace(SEG) null, i64 1, i1 false)\nret void", true},
+		{"memory-set", "declare void @llvm.memset.pSEG.i64(ptr addrspace(SEG), i8, i64, i1)",
+			"call void @llvm.memset.pSEG.i64(ptr addrspace(SEG) null, i8 0, i64 1, i1 false)\nret void", true},
+		{"zero-memory-copy", "declare void @llvm.memcpy.pSEG.p0.i64(ptr addrspace(SEG), ptr, i64, i1)",
+			"call void @llvm.memcpy.pSEG.p0.i64(ptr addrspace(SEG) null, ptr null, i64 0, i1 false)\nret void", false},
+		{"zero-memory-move", "declare void @llvm.memmove.p0.pSEG.i64(ptr, ptr addrspace(SEG), i64, i1)",
+			"call void @llvm.memmove.p0.pSEG.i64(ptr null, ptr addrspace(SEG) null, i64 0, i1 true)\nret void", false},
+		{"zero-memory-set", "declare void @llvm.memset.pSEG.i64(ptr addrspace(SEG), i8, i64, i1)",
+			"call void @llvm.memset.pSEG.i64(ptr addrspace(SEG) null, i8 0, i64 0, i1 false)\nret void", false},
+		{"bundle-pointer-transport", "declare void @consumer()",
+			"call void @consumer() [\"deopt\"(ptr addrspace(SEG) null)]\nret void", false},
+		{"pure-pointer-transport", "declare void @consumer(ptr addrspace(SEG)) memory(none)",
+			"call void @consumer(ptr addrspace(SEG) null)\nret void", false},
+		{"pure-callsite-transport", "declare void @consumer(ptr addrspace(SEG))",
+			"call void @consumer(ptr addrspace(SEG) null) memory(none)\nret void", false},
+		{"unused-declaration", "declare void @consumer(ptr addrspace(SEG))", "ret void", false},
+		{"unused-pointer-constant", "@address = private constant ptr addrspace(SEG) null", "ret void", false},
+		{"address-without-access", "", "%v = getelementptr i8, ptr addrspace(SEG) null, i64 1\nret void", false},
+		{"pointer-value-in-ordinary-memory", "", "%v = load ptr addrspace(SEG), ptr null\nret void", false},
+		{"stored-pointer-in-ordinary-memory", "", "store ptr addrspace(SEG) null, ptr null\nret void", false},
+		{"ordinary-load", "", "%v = load volatile i32, ptr null\nret void", false},
+	}
+	for _, length := range []struct {
+		name, typ, value string
+		hardware         bool
+	}{
+		{"zero-wide", "i128", "0", false},
+		{"nonzero-wide", "i128", "18446744073709551616", true},
+		{"unknown", "i64", "%length", true},
+	} {
+		for _, source := range []bool{false, true} {
+			destination, input, suffix := "ptr addrspace(SEG)", "ptr", "pSEG.p0"
+			if source {
+				destination, input, suffix = input, destination, "p0.pSEG"
+			}
+			intrinsic := "llvm.memcpy." + suffix + "." + length.typ
+			declaration := fmt.Sprintf("declare void @%s(%s, %s, %s, i1)", intrinsic, destination, input, length.typ)
+			prefix := ""
+			if length.name == "unknown" {
+				declaration += "\ndeclare i64 @length()"
+				prefix = "%length = call i64 @length()\n"
+			}
+			rows = append(rows, memoryUse{fmt.Sprintf("%s-memory-source=%t", length.name, source), declaration,
+				prefix + fmt.Sprintf("call void @%s(%s null, %s null, %s %s, i1 false)\nret void",
+					intrinsic, destination, input, length.typ, length.value), length.hardware})
+		}
+	}
+	for _, shape := range []struct{ name, width, suffix string }{
+		{"fixed", "2", "v2"}, {"scalable", "vscale x 2", "nxv2"},
+	} {
+		value := "<" + shape.width + " x i32>"
+		mask := "<" + shape.width + " x i1>"
+		pointers := "<" + shape.width + " x ptr addrspace(SEG)>"
+		gather := "llvm.masked.gather." + shape.suffix + "i32." + shape.suffix + "pSEG"
+		scatter := "llvm.masked.scatter." + shape.suffix + "i32." + shape.suffix + "pSEG"
+		rows = append(rows, memoryUse{shape.name + "-gather",
+			fmt.Sprintf("declare %s @%s(%s, i32, %s, %s)", value, gather, pointers, mask, value),
+			fmt.Sprintf("%%v = call %s @%s(%s zeroinitializer, i32 4, %s splat (i1 true), %s zeroinitializer)\nret void",
+				value, gather, pointers, mask, value), true}, memoryUse{shape.name + "-scatter",
+			fmt.Sprintf("declare void @%s(%s, %s, i32, %s)", scatter, value, pointers, mask),
+			fmt.Sprintf("call void @%s(%s zeroinitializer, %s zeroinitializer, i32 4, %s splat (i1 true))\nret void",
+				scatter, value, pointers, mask), true}, memoryUse{shape.name + "-pure-pointer-transport",
+			fmt.Sprintf("declare void @consumer(%s) memory(none)", pointers),
+			fmt.Sprintf("call void @consumer(%s zeroinitializer)\nret void", pointers), false})
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, space := range []int{256, 257} {
+			for _, row := range rows {
+				other := "386"
+				if arch == "386" {
+					other = "amd64"
+				}
+				for _, triple := range []string{testTargetTriple("linux", arch), testTargetTriple("linux", other), "", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					t.Run(fmt.Sprintf("%s/%d/%s/%s", arch, space, row.name, triple), func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						source := fmt.Sprintf("target triple = %q\n%s\ndefine void @ordinary() {\n%s\n}\n", triple, row.declaration, row.body)
+						source = strings.ReplaceAll(source, "SEG", fmt.Sprint(space))
+						module, err := parseIRModuleInContext(ctx, source)
+						if err != nil {
+							t.Fatal("independent hardware-use fixture is invalid LLVM IR", err)
+						}
+						defer module.Dispose()
+						if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+							t.Fatal("independent hardware-use fixture failed LLVM verification", err)
+						}
+						err = validateTranslatedBackend(&File{Arch: ArchAMD64}, Options{Goarch: arch}, module)
+						if row.hardware && triple != testTargetTriple("linux", arch) {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("ACTUAL_SEGMENT_MEMORY_USE_ESCAPED_BACKEND", err)
+							}
+						} else if err != nil {
+							t.Fatal("unused address space, ordinary memory or matching hardware target was rejected", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/target_triple_contract_test.go b/target_triple_contract_test.go
new file mode 100644
index 000000000..56845de0d
--- /dev/null
+++ b/target_triple_contract_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestRuntimeTargetTriplesLLVM22AllArchitectures(t *testing.T) {
+	llc, err := exec.LookPath("llc")
+	if err != nil {
+		t.Fatal("required LLVM22 llc:", err)
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	version, err := exec.CommandContext(ctx, llc, "--version").CombinedOutput()
+	cancel()
+	if err != nil || !strings.Contains(string(version), "LLVM version 22.") {
+		t.Fatalf("required LLVM22 llc: %v\n%s", err, version)
+	}
+	for _, target := range []struct {
+		goos, goarch, triple string
+	}{
+		{"darwin", "amd64", "x86_64-apple-macosx"},
+		{"darwin", "arm64", "arm64-apple-macosx"},
+		{"linux", "386", "i386-unknown-linux-gnu"},
+		{"linux", "amd64", "x86_64-unknown-linux-gnu"},
+		{"linux", "arm", "armv7-unknown-linux-gnueabihf"},
+		{"linux", "arm64", "aarch64-unknown-linux-gnu"},
+		{"windows", "386", "i686-w64-windows-gnu"},
+		{"windows", "amd64", "x86_64-w64-windows-gnu"},
+		{"windows", "arm64", "aarch64-w64-windows-gnu"},
+		{"js", "wasm", "wasm32-unknown-unknown"},
+		{"wasip1", "wasm", "wasm32-unknown-wasi"},
+	} {
+		t.Run(target.goos+"/"+target.goarch, func(t *testing.T) {
+			triple := testTargetTriple(target.goos, target.goarch)
+			if triple != target.triple {
+				t.Errorf("runtime target triple got %q want %q", triple, target.triple)
+			}
+			dir := t.TempDir()
+			input := filepath.Join(dir, "minimal.ll")
+			object := filepath.Join(dir, "minimal.o")
+			if err := os.WriteFile(input, []byte("define void @minimal() { ret void }\n"), 0600); err != nil {
+				t.Fatal(err)
+			}
+			ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+			output, err := exec.CommandContext(ctx, llc, "-mtriple="+triple, "-filetype=obj", input, "-o", object).CombinedOutput()
+			cancel()
+			if err != nil || len(output) != 0 {
+				t.Fatalf("actual LLVM22 target object: %v\n%s", err, output)
+			}
+			info, err := os.Stat(object)
+			if err != nil || !info.Mode().IsRegular() || info.Size() == 0 {
+				t.Fatalf("LLVM22 did not emit a nonempty regular object: %v", err)
+			}
+		})
+	}
+}
+
+func TestRuntimeTargetTriplesRejectUnknownCombinations(t *testing.T) {
+	for _, target := range [][2]string{
+		{"linux", "not-an-arch"}, {"not-an-os", "amd64"},
+		{"darwin", "386"}, {"windows", "arm"},
+		{"linux", "wasm"}, {"js", "amd64"}, {"wasip1", "arm64"},
+	} {
+		t.Run(target[0]+"/"+target[1], func(t *testing.T) {
+			defer func() {
+				failure, ok := recover().(string)
+				want := "unsupported test target " + target[0] + "/" + target[1]
+				if !ok || failure != want {
+					t.Errorf("unknown test target did not explicitly fail before invoking LLVM: %q", failure)
+				}
+			}()
+			_ = testTargetTriple(target[0], target[1])
+		})
+	}
+}
diff --git a/target_triple_test.go b/target_triple_test.go
index 0d642719d..b4680de40 100644
--- a/target_triple_test.go
+++ b/target_triple_test.go
@@ -1,10 +1,7 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 // testTargetTriple returns a practical LLVM target triple for tests.
-// We only need a small set for current coverage.
+// Go's architecture names are not interchangeable with LLVM architecture names.
 func testTargetTriple(goos, goarch string) string {
 	switch goos {
 	case "darwin":
@@ -16,20 +13,37 @@ func testTargetTriple(goos, goarch string) string {
 		}
 	case "linux":
 		switch goarch {
+		case "386":
+			return "i386-unknown-linux-gnu"
 		case "amd64":
 			return "x86_64-unknown-linux-gnu"
+		case "arm":
+			return "armv7-unknown-linux-gnueabihf"
 		case "arm64":
 			return "aarch64-unknown-linux-gnu"
 		}
 	case "windows":
+		// Runtime fixtures link with MSYS2/MinGW clang, not the MSVC CRT.
+		// In particular, their large frames need ___chkstk_ms on amd64.
+		// Explicit MSVC object-compile tests keep their separate triples.
 		switch goarch {
+		case "386":
+			return "i686-w64-windows-gnu"
 		case "amd64":
-			return "x86_64-pc-windows-msvc"
+			return "x86_64-w64-windows-gnu"
 		case "arm64":
-			return "aarch64-pc-windows-msvc"
+			return "aarch64-w64-windows-gnu"
+		}
+	case "js":
+		if goarch == "wasm" {
+			return "wasm32-unknown-unknown"
+		}
+	case "wasip1":
+		if goarch == "wasm" {
+			return "wasm32-unknown-wasi"
 		}
 	}
 
-	// Fallback for unsupported combos in tests.
-	return goarch + "-unknown-" + goos
+	// An invented or empty triple could silently select the host LLVM backend.
+	panic("unsupported test target " + goos + "/" + goarch)
 }
diff --git a/test_discovery_policy_test.go b/test_discovery_policy_test.go
new file mode 100644
index 000000000..85d9e8f51
--- /dev/null
+++ b/test_discovery_policy_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"go/build/constraint"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Tests may need a particular OS or Go API version, but must remain visible to
+// llgo. Until llgo can run a test, execute it with Go instead of hiding it from
+// the other compiler with a source-level exclusion.
+func TestRegressionTestsRemainDiscoverableByLLGo(t *testing.T) {
+	err := filepath.WalkDir(".", func(path string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			if path != "." && (strings.HasPrefix(entry.Name(), ".") || entry.Name() == "_out" || entry.Name() == "testdata" || entry.Name() == "vendor") {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if !strings.HasSuffix(path, "_test.go") {
+			return nil
+		}
+		source, err := os.ReadFile(path)
+		if err != nil {
+			return err
+		}
+		for _, line := range strings.Split(string(source), "\n") {
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "package ") {
+				break
+			}
+			if !constraint.IsGoBuild(line) && !constraint.IsPlusBuild(line) {
+				continue
+			}
+			expression, err := constraint.Parse(line)
+			if err != nil {
+				t.Errorf("%s: invalid build constraint: %v", path, err)
+				continue
+			}
+			if excludesLLGoTests(expression, false) {
+				t.Errorf("%s: tests must remain discoverable by llgo; remove %q", path, line)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func excludesLLGoTests(expression constraint.Expr, negated bool) bool {
+	switch expr := expression.(type) {
+	case *constraint.TagExpr:
+		return expr.Tag == "llgo" && negated
+	case *constraint.NotExpr:
+		return excludesLLGoTests(expr.X, !negated)
+	case *constraint.AndExpr:
+		return excludesLLGoTests(expr.X, negated) || excludesLLGoTests(expr.Y, negated)
+	case *constraint.OrExpr:
+		return excludesLLGoTests(expr.X, negated) || excludesLLGoTests(expr.Y, negated)
+	default:
+		return false
+	}
+}
+
+func TestLLGoTestConstraintPolicy(t *testing.T) {
+	for _, tc := range []struct {
+		expression string
+		want       bool
+	}{
+		{"!llgo", true},
+		{"go1.27 && !llgo", true},
+		{"!windows && !llgo", true},
+		{"!(llgo || windows)", true},
+		{"linux || (darwin && !llgo)", true},
+		{"go1.27 && !windows", false},
+		{"llgo", false},
+		{"linux || darwin", false},
+	} {
+		expression, err := constraint.Parse("//go:build " + tc.expression)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if got := excludesLLGoTests(expression, false); got != tc.want {
+			t.Errorf("constraint %q: exclusion=%v, want %v", tc.expression, got, tc.want)
+		}
+	}
+}
diff --git a/test_tool_cache_lifecycle_test.go b/test_tool_cache_lifecycle_test.go
new file mode 100644
index 000000000..d05261127
--- /dev/null
+++ b/test_tool_cache_lifecycle_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestTestToolCacheLazyLifetime(t *testing.T) {
+	callerCache := t.TempDir()
+	t.Setenv("GOCACHE", callerCache)
+	marker := filepath.Join(callerCache, "caller-owned")
+	if err := os.WriteFile(marker, []byte("retain"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	var unused testToolCache
+	if err := unused.close(); err != nil || unused.path != "" {
+		t.Fatalf("unused cache acquired resources: %v", err)
+	}
+	if _, err := unused.directory(); err == nil {
+		t.Fatal("closed cache was reopened")
+	}
+
+	var cache testToolCache
+	t.Cleanup(func() {
+		if err := cache.close(); err != nil {
+			t.Error(err)
+		}
+	})
+	const callers = 8
+	paths, failures := make(chan string, callers), make(chan error, callers)
+	var group sync.WaitGroup
+	for index := 0; index < callers; index++ {
+		group.Add(1)
+		go func() {
+			defer group.Done()
+			path, err := cache.directory()
+			paths <- path
+			failures <- err
+		}()
+	}
+	group.Wait()
+	close(paths)
+	close(failures)
+	for err := range failures {
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	first := <-paths
+	if first == callerCache {
+		t.Fatal("test cache borrowed the caller's compiler cache")
+	}
+	for path := range paths {
+		if path != first {
+			t.Fatal("concurrent callers acquired different compiler caches")
+		}
+	}
+	if err := cache.close(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(first); !os.IsNotExist(err) {
+		t.Fatalf("owned cache survived cleanup: %v", err)
+	}
+	if _, err := cache.directory(); err == nil {
+		t.Fatal("disposed cache was recreated")
+	}
+	if data, err := os.ReadFile(marker); err != nil || string(data) != "retain" {
+		t.Fatalf("test cache changed the caller's artifacts: %q %v", data, err)
+	}
+
+	t.Run("concurrent close", func(t *testing.T) {
+		var cache testToolCache
+		t.Cleanup(func() {
+			if err := cache.close(); err != nil {
+				t.Error(err)
+			}
+		})
+		path, err := cache.directory()
+		if err != nil {
+			t.Fatal(err)
+		}
+		start := make(chan struct{})
+		type result struct {
+			path string
+			err  error
+		}
+		results := make(chan result, callers)
+		closed := make(chan error, 1)
+		for index := 0; index < callers; index++ {
+			go func() {
+				<-start
+				path, err := cache.directory()
+				results <- result{path, err}
+			}()
+		}
+		go func() {
+			<-start
+			closed <- cache.close()
+		}()
+		close(start)
+		for index := 0; index < callers; index++ {
+			got := <-results
+			if got.err != nil {
+				if !strings.Contains(got.err.Error(), "test compiler cache is closed") || got.path != "" {
+					t.Errorf("unexpected acquisition result: %q %v", got.path, got.err)
+				}
+			} else if got.path != path {
+				t.Errorf("concurrent acquisition changed the owned cache: %q, %q", path, got.path)
+			}
+		}
+		if err := <-closed; err != nil {
+			t.Fatal(err)
+		}
+		if _, err := cache.directory(); err == nil {
+			t.Fatal("concurrent close allowed the cache to reopen")
+		}
+		if _, err := os.Stat(path); !os.IsNotExist(err) {
+			t.Fatalf("concurrent close retained its cache: %v", err)
+		}
+	})
+}
+
+func TestTestToolCacheProcessCleanup(t *testing.T) {
+	const receiptKey = "PLAN9ASM_TEST_TOOL_CACHE_RECEIPT"
+	const replaceKey = "PLAN9ASM_TEST_TOOL_CACHE_REPLACE"
+	if receipt := os.Getenv(receiptKey); receipt != "" {
+		rootTemporary := t.TempDir()
+		for _, key := range []string{"TMPDIR", "TMP", "TEMP"} {
+			t.Setenv(key, rootTemporary)
+		}
+		path, err := fixedLocalProcessToolCache.directory()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(receipt, []byte(path), 0600); err != nil {
+			t.Fatal(err)
+		}
+		if os.Getenv(replaceKey) == "1" {
+			if err := os.Rename(path, filepath.Join(filepath.Dir(receipt), "original")); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Mkdir(path, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.WriteFile(filepath.Join(path, "foreign-owner"), []byte("retain"), 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+		return // The real TestMain must perform cleanup and choose the exit status.
+	}
+	for _, mode := range []string{"normal", "replaced"} {
+		t.Run(mode, func(t *testing.T) {
+			receipt := filepath.Join(t.TempDir(), "cache-path")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestTestToolCacheProcessCleanup$", "-test.count=1")
+			for _, entry := range os.Environ() {
+				key, _, _ := strings.Cut(entry, "=")
+				switch strings.ToUpper(key) {
+				case receiptKey, replaceKey, "TMPDIR", "TMP", "TEMP":
+					continue
+				}
+				command.Env = append(command.Env, entry)
+			}
+			command.Env = append(command.Env, receiptKey+"="+receipt,
+				"TMPDIR="+filepath.Dir(receipt), "TMP="+filepath.Dir(receipt), "TEMP="+filepath.Dir(receipt))
+			if mode == "replaced" {
+				command.Env = append(command.Env, replaceKey+"=1")
+			}
+			output, err := runtimeOracleCombinedOutput(ctx, command)
+			pathBytes, readErr := os.ReadFile(receipt)
+			if readErr != nil {
+				t.Fatalf("child did not create its cache: %v\n%s", readErr, output)
+			}
+			path := string(pathBytes)
+			owned, pathErr := filepath.EvalSymlinks(filepath.Dir(receipt))
+			if pathErr != nil || filepath.Dir(path) != owned || !strings.HasPrefix(filepath.Base(path), "plan9asm-test-compiler-cache-") {
+				t.Fatalf("child cache escaped the parent's owned cleanup directory: %q %v", path, pathErr)
+			}
+			if mode == "normal" {
+				if err != nil {
+					t.Fatalf("normal TestMain cleanup: %v\n%s", err, output)
+				}
+				if _, err := os.Stat(path); !os.IsNotExist(err) {
+					t.Fatalf("TestMain retained its cache: %v", err)
+				}
+				return
+			}
+			if err == nil || !strings.Contains(string(output), "refusing to remove a replaced test compiler cache") {
+				t.Fatalf("cleanup failure did not fail the process: %v\n%s", err, output)
+			}
+			if data, err := os.ReadFile(filepath.Join(path, "foreign-owner")); err != nil || string(data) != "retain" {
+				t.Fatalf("TestMain removed another owner's replacement: %q %v", data, err)
+			}
+		})
+	}
+}
+
+func TestFixedLocalProcessToolCacheKeepsSourcesIndependent(t *testing.T) {
+	for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+		t.Setenv(key, "")
+	}
+	var previous GoAMD64FrameCaptureRequest
+	var cache string
+	for _, name := range []string{"first-root", "second-root"} {
+		t.Run(name, func(t *testing.T) {
+			goAMD64FramePrepareOwnedToolCache(t)
+			_, request := goAMD64FrameSourceFixture(t)
+			if cache != "" && os.Getenv("GOCACHE") != cache {
+				t.Fatal("another root replaced the process-owned compiler cache")
+			}
+			cache = os.Getenv("GOCACHE")
+			if previous.Directory != "" {
+				if previous.Directory == request.Directory {
+					t.Fatal("compiler cache reuse shared original source ownership")
+				}
+				for _, key := range []string{"GOPATH", "GOMODCACHE", "TMPDIR", "GOTMPDIR"} {
+					first, second := "", ""
+					for _, entry := range previous.Environment {
+						if strings.HasPrefix(entry, key+"=") {
+							first = strings.TrimPrefix(entry, key+"=")
+						}
+					}
+					for _, entry := range request.Environment {
+						if strings.HasPrefix(entry, key+"=") {
+							second = strings.TrimPrefix(entry, key+"=")
+						}
+					}
+					if first == "" || second == "" || first == second || second == cache {
+						t.Fatalf("compiler artifacts shared a private %s workspace", key)
+					}
+				}
+			}
+			previous = request
+		})
+		if _, err := os.Stat(cache); err != nil {
+			t.Fatalf("root cleanup removed the process-owned cache: %v", err)
+		}
+	}
+}
diff --git a/test_tool_cache_test.go b/test_tool_cache_test.go
new file mode 100644
index 000000000..7727b8634
--- /dev/null
+++ b/test_tool_cache_test.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"testing"
+)
+
+// This cache is opt-in. In particular, source/cache mutation tests retain
+// their own directories and the caller's global build cache is never changed.
+var fixedLocalProcessToolCache testToolCache
+
+type testToolCache struct {
+	mu        sync.Mutex
+	temporary string
+	path      string
+	info      os.FileInfo
+	closed    bool
+}
+
+func (cache *testToolCache) directory() (string, error) {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+	if cache.closed {
+		return "", fmt.Errorf("test compiler cache is closed")
+	}
+	if cache.path == "" {
+		directory, err := os.MkdirTemp(cache.temporary, "plan9asm-test-compiler-cache-")
+		if err != nil {
+			return "", err
+		}
+		canonical, err := filepath.EvalSymlinks(directory)
+		if err != nil {
+			return "", fmt.Errorf("resolve test compiler cache: %w; cleanup: %v", err, os.RemoveAll(directory))
+		}
+		info, err := os.Lstat(canonical)
+		if err != nil || !info.IsDir() {
+			return "", fmt.Errorf("inspect test compiler cache: %v; cleanup: %v", err, os.RemoveAll(directory))
+		}
+		cache.path, cache.info = canonical, info
+	}
+	info, err := os.Lstat(cache.path)
+	if err != nil || !info.IsDir() || !os.SameFile(cache.info, info) {
+		return "", fmt.Errorf("test compiler cache directory identity changed: %v", err)
+	}
+	return cache.path, nil
+}
+
+func (cache *testToolCache) close() error {
+	cache.mu.Lock()
+	defer cache.mu.Unlock()
+	cache.closed = true
+	if cache.path == "" {
+		return nil
+	}
+	info, err := os.Lstat(cache.path)
+	if err != nil || !info.IsDir() || !os.SameFile(cache.info, info) {
+		return fmt.Errorf("refusing to remove a replaced test compiler cache: %v", err)
+	}
+	if err := os.RemoveAll(cache.path); err != nil {
+		return fmt.Errorf("remove test compiler cache: %w", err)
+	}
+	cache.path, cache.info = "", nil
+	return nil
+}
+
+func TestMain(m *testing.M) {
+	// A root may temporarily redirect TMPDIR/TMP/TEMP into its own TempDir.
+	// That root's cleanup must not own this longer-lived, lazily created cache.
+	fixedLocalProcessToolCache.temporary = os.TempDir()
+	status := m.Run()
+	if err := fixedLocalProcessToolCache.close(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		status = 1
+	}
+	os.Exit(status)
+}
diff --git a/testdata/amd64/linux-syscall/go.mod.txt b/testdata/amd64/linux-syscall/go.mod.txt
new file mode 100644
index 000000000..29c28ac78
--- /dev/null
+++ b/testdata/amd64/linux-syscall/go.mod.txt
@@ -0,0 +1,3 @@
+module example.com/rawsyscall
+
+go 1.20
diff --git a/testdata/amd64/linux-syscall/main.c b/testdata/amd64/linux-syscall/main.c
new file mode 100644
index 000000000..6faf0e585
--- /dev/null
+++ b/testdata/amd64/linux-syscall/main.c
@@ -0,0 +1,81 @@
+#include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+typedef struct { uint64_t ax, dx; } pair;
+typedef pair (*operation)(uint64_t, uint64_t, uint64_t, uint64_t,
+                         uint64_t, uint64_t, uint64_t);
+extern pair Raw(uint64_t, uint64_t, uint64_t, uint64_t,
+                uint64_t, uint64_t, uint64_t);
+int cliteErrno(void) { return errno; }
+
+/* Independent register-addressed kernel oracle, including the actual DX
+ * output. It does not assume DX preservation from the C source variable. */
+static pair original(uint64_t number, uint64_t a1, uint64_t a2, uint64_t a3,
+                     uint64_t a4, uint64_t a5, uint64_t a6) {
+    register uint64_t r10 __asm__("r10") = a4;
+    register uint64_t r8 __asm__("r8") = a5;
+    register uint64_t r9 __asm__("r9") = a6;
+    pair output;
+    __asm__ volatile("syscall"
+        : "=a"(output.ax), "=d"(output.dx)
+        : "0"(number), "D"(a1), "S"(a2), "1"(a3),
+          "r"(r10), "r"(r8), "r"(r9)
+        : "rcx", "r11", "cc", "memory");
+    return output;
+}
+
+static int check(const char *name, operation call) {
+    const uint64_t sentinel = UINT64_C(0x123456789abcdef);
+    int failures = 0;
+    errno = EDOM;
+    pair result = call(39, 0, 0, sentinel, 0, 0, 0);
+    if (result.ax != (uint64_t)getpid() || result.dx != sentinel || errno != EDOM) {
+        fprintf(stderr, "%s getpid ax=%llu dx=%llx errno=%d\n", name,
+                (unsigned long long)result.ax, (unsigned long long)result.dx, errno);
+        failures++;
+    }
+    errno = EDOM;
+    result = call(UINT64_MAX, 0, 0, sentinel, 0, 0, 0);
+    if (result.ax != (uint64_t)-ENOSYS || result.dx != sentinel || errno != EDOM) {
+        fprintf(stderr, "%s invalid ax=%lld dx=%llx errno=%d\n", name,
+                (long long)result.ax, (unsigned long long)result.dx, errno);
+        failures++;
+    }
+    int pipes[2];
+    if (pipe(pipes) != 0) return failures + 1;
+    const char message[] = "raw-syscall-io";
+    const size_t length = sizeof(message) - 1;
+    errno = EDOM;
+    result = call(1, pipes[1], (uintptr_t)message, length, 0, 0, 0);
+    if (result.ax != length || result.dx != length || errno != EDOM) {
+        fprintf(stderr, "%s write ax=%llu dx=%llu errno=%d\n", name,
+                (unsigned long long)result.ax, (unsigned long long)result.dx, errno);
+        failures++;
+    }
+    close(pipes[1]); /* A failed write must produce EOF, never hang this oracle. */
+    unsigned char buffer[32];
+    memset(buffer, 0xa5, sizeof(buffer));
+    errno = EDOM;
+    result = call(0, pipes[0], (uintptr_t)(buffer + 3), length, 0, 0, 0);
+    if (result.ax != length || result.dx != length || errno != EDOM ||
+        memcmp(buffer + 3, message, length) != 0) {
+        fprintf(stderr, "%s read ax=%llu dx=%llu errno=%d\n", name,
+                (unsigned long long)result.ax, (unsigned long long)result.dx, errno);
+        failures++;
+    }
+    for (size_t i = 0; i < sizeof(buffer); i++) {
+        if ((i < 3 || i >= 3 + length) && buffer[i] != 0xa5) failures++;
+    }
+    close(pipes[0]);
+    printf("RAW_SYSCALL_%s calls=4 failures=%d\n", name, failures);
+    return failures;
+}
+
+int main(void) {
+    int reference = check("REFERENCE", original);
+    int translated = check("TRANSLATED", Raw);
+    return reference != 0 || translated != 0;
+}
diff --git a/testdata/amd64/linux-syscall/main.go b/testdata/amd64/linux-syscall/main.go
new file mode 100644
index 000000000..51c4356ea
--- /dev/null
+++ b/testdata/amd64/linux-syscall/main.go
@@ -0,0 +1,52 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"syscall"
+	"unsafe"
+)
+
+func Raw(number, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr)
+
+var kept []byte // The uintptr transport never supplies a GC root itself.
+
+func main() {
+	const sentinel = uintptr(0x123456789abcdef)
+	pid, preserved := Raw(syscall.SYS_GETPID, 0, 0, sentinel, 0, 0, 0)
+	if pid != uintptr(syscall.Getpid()) || preserved != sentinel {
+		panic("getpid/register")
+	}
+	result, preserved := Raw(^uintptr(0), 0, 0, sentinel, 0, 0, 0)
+	if result != ^uintptr(syscall.ENOSYS-1) || preserved != sentinel {
+		panic("raw errno/register")
+	}
+	fmt.Println("ORIGINAL_RAW_SYSCALL_PASS getpid raw-errno preserved-DX")
+	var pipes [2]int
+	if err := syscall.Pipe(pipes[:]); err != nil {
+		panic(err)
+	}
+	defer syscall.Close(pipes[0])
+	message := []byte("raw-syscall-io")
+	kept = make([]byte, 64)
+	copy(kept[32:], message)
+	for index := 0; index < 32; index++ {
+		kept[index] = 0xa5
+	}
+	length := uintptr(len(message))
+	result, preserved = Raw(syscall.SYS_WRITE, uintptr(pipes[1]), uintptr(unsafe.Pointer(&kept[32])), length, 0, 0, 0)
+	syscall.Close(pipes[1])
+	if result != length || preserved != length {
+		panic("write/register")
+	}
+	result, preserved = Raw(syscall.SYS_READ, uintptr(pipes[0]), uintptr(unsafe.Pointer(&kept[3])), length, 0, 0, 0)
+	if result != length || preserved != length || !bytes.Equal(kept[3:3+len(message)], message) {
+		panic("read/register/memory")
+	}
+	for index := 0; index < 32; index++ {
+		if (index < 3 || index >= 3+len(message)) && kept[index] != 0xa5 {
+			panic("buffer canary")
+		}
+	}
+	fmt.Println("ORIGINAL_RAW_SYSCALL_PASS read-write buffers-and-canaries")
+}
diff --git a/testdata/amd64/linux-syscall/raw_amd64.s b/testdata/amd64/linux-syscall/raw_amd64.s
new file mode 100644
index 000000000..757d41f6d
--- /dev/null
+++ b/testdata/amd64/linux-syscall/raw_amd64.s
@@ -0,0 +1,12 @@
+TEXT ·Raw(SB),4,$0-72
+MOVQ number+0(FP), AX
+MOVQ a1+8(FP), DI
+MOVQ a2+16(FP), SI
+MOVQ a3+24(FP), DX
+MOVQ a4+32(FP), R10
+MOVQ a5+40(FP), R8
+MOVQ a6+48(FP), R9
+SYSCALL
+MOVQ AX, r1+56(FP)
+MOVQ DX, r2+64(FP)
+RET
diff --git a/testdata/conformance/amd64/conformance.go b/testdata/conformance/amd64/conformance.go
index 5457bf275..bbe78146c 100644
--- a/testdata/conformance/amd64/conformance.go
+++ b/testdata/conformance/amd64/conformance.go
@@ -18,8 +18,82 @@ func doubleShift32(out *[8]uint32, src, dst, amount uint32)
 
 func doubleShift64(out *[8]uint64, src, dst, amount uint64)
 
+func scalarShiftRotateSemantics(out *[14]uint64, value, count uint64)
+
+func incDecSemantics(out *[12]uint64, value uint64)
+
+func scalarAddSubSemantics(out *[16]uint64, value, source uint64)
+
+func compareExchangeScalarSemantics(out *[24]uint64, memory *[8]uint64, expected, desired uint64)
+
+func compareExchangePairSemantics(out *[9]uint64, memory *uint64, expectedLow, expectedHigh, desiredLow, desiredHigh uint64)
+
+func parallelBitSemantics(out *[8]uint64, mask, source uint64)
+
+func bitTestRegisterSemantics(out *[24]uint64, value, index uint64)
+
+func bitTestMemorySemantics(out *[12]byte, data *[9]uint64)
+
+func packedWordMultiplyAddSemantics(out *[18]int32, a, b *[16]int16)
+
+func packedUnsignedSignedByteMultiplyAddSemantics(out *[32]int16, signed *[32]int8, unsigned *[32]uint8)
+
+// packedDotProductSemantics is executed by the translated LLVM runtime
+// oracle; the native suite assembles the AVX-512 source without requiring the
+// host CPU to execute it.
+func packedDotProductSemantics(out *[64]int32, signedBytes *[64]int8, unsignedBytes *[64]uint8, wordsA, wordsB *[32]int16, accumulator *[16]int32)
+
+func packedIntegerMinMaxSemantics(out *[1024]byte, a, b *[64]byte)
+
+func packedWordMultiplySemantics(out *[64]uint16, a, b *[8]int16)
+
+func packedFloatShuffleSemantics(out *[96]byte, a, b *[32]byte)
+
+func inLaneFloatingPermuteSemantics(out *[144]byte, data, control *[32]byte)
+
+func immediatePackedBlendSemantics(out *[240]byte, a, b *[32]byte)
+
+func packedUnpackSemantics(out *[384]byte, a, b *[32]byte)
+
+func qwordPermuteSemantics(out *[8]uint64, data *[4]uint64)
+
+func qwordVariablePermuteSemantics(out *[8]uint64, data, control *[4]uint64)
+
+func packedFloatMoveVEXSemantics(out *[128]byte, src *[32]byte)
+
+func packedFloatMoveMaskSemantics(out *[688]byte, src, old *[64]byte)
+
+func packedSignExtendMoveVEXSemantics(out *[288]byte, src *[32]byte)
+
+func packedSignExtendMoveMaskSemantics(out *[768]byte, src, old *[64]byte)
+
 func goHexVectorOps(out *[160]byte, a, b *[16]byte)
 
 func goHexWordOps(value, count uint64) uint64
 
 func packedArithmeticShift32(out *[8]int32, src *[4]int32)
+
+func packedSubtractSemantics(out *[80]byte, a, b *[16]byte)
+
+func expandedEcosystemVectors(out *[816]byte, a, b *[16]byte)
+
+func parityBranches(value byte) uint64
+
+func unorderedBranch(value float64) uint64
+
+func packedFloatToDwordModes(out *[20]int32, src *[4]float32)
+
+// sameWidthPackedConversionSemantics is exercised by the translated LLVM
+// runtime oracle. The native Go suite still assembles it, but deliberately
+// does not execute AVX-512 on hosts which may lack that ISA.
+func sameWidthPackedConversionSemantics(out *[576]byte, ints *[16]int32, floats, squares32 *[16]float32, squares64 *[8]float64)
+
+func packedSingleToDouble(out *[4]float64, src *[4]float32)
+
+func conditionalMoveCodes(out, src *[16]uint64)
+
+func fma3Semantics(out *[288]byte, a64, b64, c64 *[2]float64, a32, b32, c32 *[4]float32)
+
+func binaryFloatingSemantics(out *[384]byte, a64, b64 *[2]float64, a32, b32 *[4]float32)
+
+func horizontalFloatingSemantics(out *[192]byte, a32, b32 *[8]float32, a64, b64 *[4]float64)
diff --git a/testdata/conformance/amd64/conformance_amd64.s b/testdata/conformance/amd64/conformance_amd64.s
index 1dfe8e36a..bfc23754a 100644
--- a/testdata/conformance/amd64/conformance_amd64.s
+++ b/testdata/conformance/amd64/conformance_amd64.s
@@ -130,6 +130,970 @@ TEXT ·doubleShift64(SB), NOSPLIT, $0-32
 	SHRQ $7, AX, (BX)
 	RET
 
+// scalarShiftRotateSemantics covers the scalar B/W/L/Q family, rotations,
+// memory destinations, and the Go assembler's W-width double-shift forms.
+TEXT ·scalarShiftRotateSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ value+8(FP), BX
+	MOVQ count+16(FP), CX
+
+	MOVQ BX, AX
+	ROLB CL, AL
+	MOVQ AX, 0(DI)
+	MOVQ BX, AX
+	RORB CL, AL
+	MOVQ AX, 8(DI)
+	MOVQ BX, AX
+	SARB CL, AL
+	MOVQ AX, 16(DI)
+	MOVQ BX, AX
+	SHRB CL, AL
+	MOVQ AX, 24(DI)
+
+	MOVQ BX, AX
+	ROLW CX, AX
+	MOVQ AX, 32(DI)
+	MOVQ BX, AX
+	SARW CL, AX
+	MOVQ AX, 40(DI)
+	MOVQ BX, AX
+	SHLL CX, AX
+	MOVQ AX, 48(DI)
+	MOVQ BX, AX
+	RORQ CL, AX
+	MOVQ AX, 56(DI)
+
+	MOVQ BX, 64(DI)
+	SHRB CL, 64(DI)
+	MOVQ BX, 72(DI)
+	ROLW CX, 72(DI)
+
+	MOVQ BX, AX
+	MOVQ $0xfedcba9876543210, DX
+	SHLW CL, AX, DX
+	MOVQ DX, 80(DI)
+	MOVQ BX, AX
+	MOVQ $0xfedcba9876543210, DX
+	SHRW CX, AX, DX
+	MOVQ DX, 88(DI)
+
+	MOVQ BX, AX
+	SALB $3, AL
+	MOVQ AX, 96(DI)
+	MOVQ BX, AX
+	SARL $3, AX
+	MOVQ AX, 104(DI)
+	RET
+
+// incDecSemantics validates every width, register and memory destinations,
+// 32-bit zero extension, and the INC/DEC flag contract (including preserved CF).
+TEXT ·incDecSemantics(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), DI
+	MOVQ value+8(FP), BX
+	MOVQ BX, AX
+	INCB AL
+	MOVQ AX, 0(DI)
+	MOVQ BX, AX
+	DECB AL
+	MOVQ AX, 8(DI)
+	MOVQ BX, AX
+	INCW AX
+	MOVQ AX, 16(DI)
+	MOVQ BX, AX
+	DECW AX
+	MOVQ AX, 24(DI)
+	MOVQ BX, AX
+	INCL AX
+	MOVQ AX, 32(DI)
+	MOVQ BX, AX
+	DECL AX
+	MOVQ AX, 40(DI)
+	MOVQ BX, AX
+	INCQ AX
+	MOVQ AX, 48(DI)
+	MOVQ BX, AX
+	DECQ AX
+	MOVQ AX, 56(DI)
+	MOVQ BX, 64(DI)
+	INCB 64(DI)
+	MOVQ BX, 72(DI)
+	DECW 72(DI)
+
+	MOVQ $0, 80(DI)
+	MOVQ $0, AX
+	SUBQ $1, AX
+	MOVQ $0x7f, AX
+	INCB AL
+	SETCS 80(DI)
+	SETOS 81(DI)
+	SETMI 82(DI)
+	SETEQ 83(DI)
+	SETPS 84(DI)
+
+	MOVQ $0, 88(DI)
+	MOVQ $1, AX
+	DECB AL
+	SETCS 88(DI)
+	SETOS 89(DI)
+	SETMI 90(DI)
+	SETEQ 91(DI)
+	SETPS 92(DI)
+	RET
+
+// scalarAddSubSemantics validates every scalar width, register and memory
+// destinations, partial-register preservation, L-register zero extension,
+// imm32 sign extension for Q, and all arithmetic condition flags.
+TEXT ·scalarAddSubSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ value+8(FP), BX
+	MOVQ source+16(FP), CX
+
+	MOVQ BX, AX
+	ADDB CL, AL
+	MOVQ AX, 0(DI)
+	MOVQ $0, 8(DI)
+	SETCS 8(DI)
+	SETOS 9(DI)
+	SETEQ 10(DI)
+	SETMI 11(DI)
+	SETPS 12(DI)
+
+	MOVQ BX, 16(DI)
+	SUBB $4294967295, 16(DI)
+	MOVQ $0, 24(DI)
+	SETCS 24(DI)
+	SETOS 25(DI)
+	SETEQ 26(DI)
+	SETMI 27(DI)
+	SETPS 28(DI)
+
+	MOVQ BX, AX
+	ADDW CX, AX
+	MOVQ AX, 32(DI)
+	MOVQ $0, 40(DI)
+	SETCS 40(DI)
+	SETOS 41(DI)
+	SETEQ 42(DI)
+	SETMI 43(DI)
+	SETPS 44(DI)
+
+	MOVQ BX, 48(DI)
+	SUBW $4294967295, 48(DI)
+	MOVQ $0, 56(DI)
+	SETCS 56(DI)
+	SETOS 57(DI)
+	SETEQ 58(DI)
+	SETMI 59(DI)
+	SETPS 60(DI)
+
+	MOVQ BX, AX
+	ADDL CX, AX
+	MOVQ AX, 64(DI)
+	MOVQ $0, 72(DI)
+	SETCS 72(DI)
+	SETOS 73(DI)
+	SETEQ 74(DI)
+	SETMI 75(DI)
+	SETPS 76(DI)
+
+	MOVQ BX, 80(DI)
+	SUBL $4294967295, 80(DI)
+	MOVQ $0, 88(DI)
+	SETCS 88(DI)
+	SETOS 89(DI)
+	SETEQ 90(DI)
+	SETMI 91(DI)
+	SETPS 92(DI)
+
+	MOVQ BX, AX
+	ADDQ CX, AX
+	MOVQ AX, 96(DI)
+	MOVQ $0, 104(DI)
+	SETCS 104(DI)
+	SETOS 105(DI)
+	SETEQ 106(DI)
+	SETMI 107(DI)
+	SETPS 108(DI)
+
+	MOVQ BX, 112(DI)
+	SUBQ $4294967295, 112(DI)
+	MOVQ $0, 120(DI)
+	SETCS 120(DI)
+	SETOS 121(DI)
+	SETEQ 122(DI)
+	SETMI 123(DI)
+	SETPS 124(DI)
+	RET
+
+// compareExchangeScalarSemantics executes success and failure cases for all
+// four widths. Each case records destination, accumulator, then CF/OF/ZF/SF/PF.
+TEXT ·compareExchangeScalarSemantics(SB), NOSPLIT, $0-32
+	MOVQ out+0(FP), DI
+	MOVQ memory+8(FP), SI
+	MOVQ expected+16(FP), BX
+	MOVQ desired+24(FP), CX
+
+	MOVQ BX, AX
+	CMPXCHGB CL, 0(SI)
+	MOVQ 0(SI), DX
+	MOVQ DX, 0(DI)
+	MOVQ AX, 8(DI)
+	MOVQ $0, 16(DI)
+	SETCS 16(DI)
+	SETOS 17(DI)
+	SETEQ 18(DI)
+	SETMI 19(DI)
+	SETPS 20(DI)
+	MOVQ BX, AX
+	CMPXCHGB CL, 8(SI)
+	MOVQ 8(SI), DX
+	MOVQ DX, 24(DI)
+	MOVQ AX, 32(DI)
+	MOVQ $0, 40(DI)
+	SETCS 40(DI)
+	SETOS 41(DI)
+	SETEQ 42(DI)
+	SETMI 43(DI)
+	SETPS 44(DI)
+
+	MOVQ BX, AX
+	CMPXCHGW CX, 16(SI)
+	MOVQ 16(SI), DX
+	MOVQ DX, 48(DI)
+	MOVQ AX, 56(DI)
+	MOVQ $0, 64(DI)
+	SETCS 64(DI)
+	SETOS 65(DI)
+	SETEQ 66(DI)
+	SETMI 67(DI)
+	SETPS 68(DI)
+	MOVQ BX, AX
+	CMPXCHGW CX, 24(SI)
+	MOVQ 24(SI), DX
+	MOVQ DX, 72(DI)
+	MOVQ AX, 80(DI)
+	MOVQ $0, 88(DI)
+	SETCS 88(DI)
+	SETOS 89(DI)
+	SETEQ 90(DI)
+	SETMI 91(DI)
+	SETPS 92(DI)
+
+	MOVQ BX, AX
+	CMPXCHGL CX, 32(SI)
+	MOVQ 32(SI), DX
+	MOVQ DX, 96(DI)
+	MOVQ AX, 104(DI)
+	MOVQ $0, 112(DI)
+	SETCS 112(DI)
+	SETOS 113(DI)
+	SETEQ 114(DI)
+	SETMI 115(DI)
+	SETPS 116(DI)
+	MOVQ BX, AX
+	CMPXCHGL CX, 40(SI)
+	MOVQ 40(SI), DX
+	MOVQ DX, 120(DI)
+	MOVQ AX, 128(DI)
+	MOVQ $0, 136(DI)
+	SETCS 136(DI)
+	SETOS 137(DI)
+	SETEQ 138(DI)
+	SETMI 139(DI)
+	SETPS 140(DI)
+
+	MOVQ BX, AX
+	CMPXCHGQ CX, 48(SI)
+	MOVQ 48(SI), DX
+	MOVQ DX, 144(DI)
+	MOVQ AX, 152(DI)
+	MOVQ $0, 160(DI)
+	SETCS 160(DI)
+	SETOS 161(DI)
+	SETEQ 162(DI)
+	SETMI 163(DI)
+	SETPS 164(DI)
+	MOVQ BX, AX
+	CMPXCHGQ CX, 56(SI)
+	MOVQ 56(SI), DX
+	MOVQ DX, 168(DI)
+	MOVQ AX, 176(DI)
+	MOVQ $0, 184(DI)
+	SETCS 184(DI)
+	SETOS 185(DI)
+	SETEQ 186(DI)
+	SETMI 187(DI)
+	SETPS 188(DI)
+	RET
+
+// compareExchangePairSemantics validates CMPXCHG8B and CMPXCHG16B, including
+// accumulator preservation on success and replacement on failure.
+TEXT ·compareExchangePairSemantics(SB), NOSPLIT, $0-48
+	MOVQ out+0(FP), DI
+	MOVQ memory+8(FP), SI
+	MOVQ expectedLow+16(FP), AX
+	MOVQ expectedHigh+24(FP), DX
+	MOVQ desiredLow+32(FP), BX
+	MOVQ desiredHigh+40(FP), CX
+	CMPXCHG8B 16(SI)
+	MOVQ 16(SI), R8
+	MOVQ R8, 0(DI)
+	MOVQ AX, 8(DI)
+	MOVQ DX, 16(DI)
+	MOVQ $0, 24(DI)
+	SETEQ 24(DI)
+
+	MOVQ expectedLow+16(FP), AX
+	MOVQ expectedHigh+24(FP), DX
+	MOVQ desiredLow+32(FP), BX
+	MOVQ desiredHigh+40(FP), CX
+	CMPXCHG16B 0(SI)
+	MOVQ 0(SI), R8
+	MOVQ 8(SI), R9
+	MOVQ R8, 32(DI)
+	MOVQ R9, 40(DI)
+	MOVQ AX, 48(DI)
+	MOVQ DX, 56(DI)
+	MOVQ $0, 64(DI)
+	SETEQ 64(DI)
+	RET
+
+// parallelBitSemantics validates PDEP/PEXT L/Q semantics, register and memory
+// mask forms, sparse masks, and the required zero extension of L results.
+TEXT ·parallelBitSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ mask+8(FP), AX
+	MOVQ source+16(FP), BX
+	PDEPQ AX, BX, CX
+	MOVQ CX, 0(DI)
+	PDEPQ mask+8(FP), BX, CX
+	MOVQ CX, 8(DI)
+	PEXTQ AX, BX, CX
+	MOVQ CX, 16(DI)
+	PEXTQ mask+8(FP), BX, CX
+	MOVQ CX, 24(DI)
+	MOVQ $-1, CX
+	PDEPL AX, BX, CX
+	MOVQ CX, 32(DI)
+	MOVQ $-1, CX
+	PDEPL mask+8(FP), BX, CX
+	MOVQ CX, 40(DI)
+	MOVQ $-1, CX
+	PEXTL AX, BX, CX
+	MOVQ CX, 48(DI)
+	MOVQ $-1, CX
+	PEXTL mask+8(FP), BX, CX
+	MOVQ CX, 56(DI)
+	RET
+
+// bitTestRegisterSemantics covers every BT/BTC/BTR/BTS width and verifies
+// both CF and the width-specific register write behavior.
+TEXT ·bitTestRegisterSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ value+8(FP), AX
+	BTW $-1, AX
+	MOVQ AX, 0(DI)
+	SETCS 8(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTCW CX, AX
+	MOVQ AX, 16(DI)
+	SETCS 24(DI)
+	MOVQ value+8(FP), AX
+	BTRW $4, AX
+	MOVQ AX, 32(DI)
+	SETCS 40(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTSW CX, AX
+	MOVQ AX, 48(DI)
+	SETCS 56(DI)
+
+	MOVQ value+8(FP), AX
+	BTL $-1, AX
+	MOVQ AX, 64(DI)
+	SETCS 72(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTCL CX, AX
+	MOVQ AX, 80(DI)
+	SETCS 88(DI)
+	MOVQ value+8(FP), AX
+	BTRL $4, AX
+	MOVQ AX, 96(DI)
+	SETCS 104(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTSL CX, AX
+	MOVQ AX, 112(DI)
+	SETCS 120(DI)
+
+	MOVQ value+8(FP), AX
+	BTQ $-1, AX
+	MOVQ AX, 128(DI)
+	SETCS 136(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTCQ CX, AX
+	MOVQ AX, 144(DI)
+	SETCS 152(DI)
+	MOVQ value+8(FP), AX
+	BTRQ $4, AX
+	MOVQ AX, 160(DI)
+	SETCS 168(DI)
+	MOVQ value+8(FP), AX
+	MOVQ index+16(FP), CX
+	BTSQ CX, AX
+	MOVQ AX, 176(DI)
+	SETCS 184(DI)
+	RET
+
+// bitTestMemorySemantics checks the unbounded memory bit string behavior for
+// positive and negative register indexes at W/L/Q widths, plus imm8 masking.
+TEXT ·bitTestMemorySemantics(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), DI
+	MOVQ data+8(FP), BX
+	MOVQ $17, CX
+	BTW CX, 8(BX)
+	SETCS 0(DI)
+	BTCW CX, 8(BX)
+	SETCS 1(DI)
+	MOVQ $-1, CX
+	BTRW CX, 8(BX)
+	SETCS 2(DI)
+	BTSW $-128, 8(BX)
+	SETCS 3(DI)
+
+	MOVQ $33, CX
+	BTL CX, 32(BX)
+	SETCS 4(DI)
+	BTCL CX, 32(BX)
+	SETCS 5(DI)
+	MOVQ $-1, CX
+	BTRL CX, 32(BX)
+	SETCS 6(DI)
+	BTSL $-128, 32(BX)
+	SETCS 7(DI)
+
+	MOVQ $65, CX
+	BTQ CX, 56(BX)
+	SETCS 8(DI)
+	BTCQ CX, 56(BX)
+	SETCS 9(DI)
+	MOVQ $-1, CX
+	BTRQ CX, 56(BX)
+	SETCS 10(DI)
+	BTSQ $-128, 56(BX)
+	SETCS 11(DI)
+	RET
+
+// packedWordMultiplyAddSemantics covers PMADDWL's MMX/XMM rows and
+// VPMADDWD's XMM/YMM rows using signed products and wrapping dword sums.
+TEXT ·packedWordMultiplyAddSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	MOVQ (CX), M0
+	PMADDWL (BX), M0
+	MOVQ M0, 0(DI)
+	EMMS
+	MOVOU (CX), X0
+	PMADDWL (BX), X0
+	MOVOU X0, 8(DI)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPMADDWD X0, X1, X2
+	MOVOU X2, 24(DI)
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPMADDWD Y0, Y1, Y2
+	VMOVDQU Y2, 40(DI)
+	VZEROUPPER
+	RET
+
+// packedUnsignedSignedByteMultiplyAddSemantics verifies the asymmetric
+// signed/unsigned operand order and signed-word saturation for legacy XMM and
+// VEX XMM/YMM PMADDUBSW forms.
+TEXT ·packedUnsignedSignedByteMultiplyAddSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ signed+8(FP), BX
+	MOVQ unsigned+16(FP), CX
+	MOVOU (CX), X0
+	PMADDUBSW (BX), X0
+	MOVOU X0, 0(DI)
+	MOVOU (CX), X1
+	VPMADDUBSW (BX), X1, X2
+	MOVOU X2, 16(DI)
+	VMOVDQU (CX), Y1
+	VPMADDUBSW (BX), Y1, Y2
+	VMOVDQU Y2, 32(DI)
+	VZEROUPPER
+	RET
+
+// packedDotProductSemantics validates unsigned-byte/signed-byte operand
+// order, signed-word products, wrapping accumulation, and both saturating
+// variants. Plan 9's first operand is the signed r/m source for BUSD.
+TEXT ·packedDotProductSemantics(SB), NOSPLIT, $0-48
+	MOVQ out+0(FP), AX
+	MOVQ signedBytes+8(FP), BX
+	MOVQ unsignedBytes+16(FP), CX
+	MOVQ wordsA+24(FP), DX
+	MOVQ wordsB+32(FP), SI
+	MOVQ accumulator+40(FP), DI
+
+	VMOVDQU32 (DI), Z0
+	VMOVDQU8 (CX), Z1
+	VMOVDQU8 (BX), Z2
+	VPDPBUSD Z2, Z1, Z0
+	VMOVDQU32 Z0, 0(AX)
+
+	VMOVDQU32 (DI), Z0
+	VPDPBUSDS Z2, Z1, Z0
+	VMOVDQU32 Z0, 64(AX)
+
+	VMOVDQU32 (DI), Z0
+	VMOVDQU16 (DX), Z1
+	VMOVDQU16 (SI), Z2
+	VPDPWSSD Z2, Z1, Z0
+	VMOVDQU32 Z0, 128(AX)
+
+	VMOVDQU32 (DI), Z0
+	VPDPWSSDS Z2, Z1, Z0
+	VMOVDQU32 Z0, 192(AX)
+	RET
+
+// packedIntegerMinMaxSemantics covers every signed/unsigned B/W/D/Q minimum
+// and maximum in the complete VEX/EVEX family.
+TEXT ·packedIntegerMinMaxSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	VMOVDQU8 (BX), Z0
+	VMOVDQU8 (CX), Z1
+	VPMINSB Z0, Z1, Z2
+	VMOVDQU8 Z2, 0(AX)
+	VPMINUB Z0, Z1, Z2
+	VMOVDQU8 Z2, 64(AX)
+	VPMAXSB Z0, Z1, Z2
+	VMOVDQU8 Z2, 128(AX)
+	VPMAXUB Z0, Z1, Z2
+	VMOVDQU8 Z2, 192(AX)
+	VPMINSW Z0, Z1, Z2
+	VMOVDQU16 Z2, 256(AX)
+	VPMINUW Z0, Z1, Z2
+	VMOVDQU16 Z2, 320(AX)
+	VPMAXSW Z0, Z1, Z2
+	VMOVDQU16 Z2, 384(AX)
+	VPMAXUW Z0, Z1, Z2
+	VMOVDQU16 Z2, 448(AX)
+	VPMINSD Z0, Z1, Z2
+	VMOVDQU32 Z2, 512(AX)
+	VPMINUD Z0, Z1, Z2
+	VMOVDQU32 Z2, 576(AX)
+	VPMAXSD Z0, Z1, Z2
+	VMOVDQU32 Z2, 640(AX)
+	VPMAXUD Z0, Z1, Z2
+	VMOVDQU32 Z2, 704(AX)
+	VPMINSQ Z0, Z1, Z2
+	VMOVDQU64 Z2, 768(AX)
+	VPMINUQ Z0, Z1, Z2
+	VMOVDQU64 Z2, 832(AX)
+	VPMAXSQ Z0, Z1, Z2
+	VMOVDQU64 Z2, 896(AX)
+	VPMAXUQ Z0, Z1, Z2
+	VMOVDQU64 Z2, 960(AX)
+	RET
+
+// inLaneFloatingPermuteSemantics covers immediate and variable-control
+// VPERMILPS/VPERMILPD and makes the Plan 9 control/data operand order visible.
+TEXT ·inLaneFloatingPermuteSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), DI
+	MOVQ data+8(FP), BX
+	MOVQ control+16(FP), CX
+	VPERMILPS $0x1B, (BX), X0
+	MOVOU X0, 0(DI)
+	VPERMILPS $0x1B, (BX), Y0
+	VMOVDQU Y0, 16(DI)
+	VMOVDQU (BX), Y1
+	VPERMILPS (CX), Y1, Y2
+	VMOVDQU Y2, 48(DI)
+	VPERMILPD $0x05, (BX), Y0
+	VMOVDQU Y0, 80(DI)
+	VMOVDQU (BX), Y1
+	VPERMILPD (CX), Y1, Y2
+	VMOVDQU Y2, 112(DI)
+	VZEROUPPER
+	RET
+
+// packedWordMultiplySemantics covers low, signed-high, unsigned-high, and
+// rounded signed-high products in both legacy and VEX forms.
+TEXT ·packedWordMultiplySemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PMULLW X0, X1
+	MOVOU X1, 0(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PMULHW X0, X1
+	MOVOU X1, 16(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PMULHUW X0, X1
+	MOVOU X1, 32(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PMULHRSW X0, X1
+	MOVOU X1, 48(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPMULLW X0, X1, X2
+	MOVOU X2, 64(AX)
+	VPMULHW X0, X1, X2
+	MOVOU X2, 80(AX)
+	VPMULHUW X0, X1, X2
+	MOVOU X2, 96(AX)
+	VPMULHRSW X0, X1, X2
+	MOVOU X2, 112(AX)
+	RET
+
+// packedFloatShuffleSemantics checks the per-128-bit-lane selector rules for
+// packed single and packed double legacy/VEX shuffles.
+TEXT ·packedFloatShuffleSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	SHUFPS $0x1b, X0, X1
+	MOVOU X1, 0(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	SHUFPD $0x02, X0, X1
+	MOVOU X1, 16(AX)
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VSHUFPS $0x1b, Y0, Y1, Y2
+	VMOVDQU Y2, 32(AX)
+	VSHUFPD $0x0a, Y0, Y1, Y2
+	VMOVDQU Y2, 64(AX)
+	VZEROUPPER
+	RET
+
+// immediatePackedBlendSemantics covers every Go 1.27 immediate packed-blend
+// opcode. A non-palindromic mask validates source order, and the Y-width
+// VPBLENDW result validates that its eight mask bits repeat per 128-bit lane.
+TEXT ·immediatePackedBlendSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+
+	MOVOU (CX), X0
+	MOVOU (BX), X1
+	PBLENDW $0xa5, X1, X0
+	MOVOU X0, 0(AX)
+	MOVOU (CX), X0
+	BLENDPS $0xa5, (BX), X0
+	MOVOU X0, 16(AX)
+	MOVOU (CX), X0
+	BLENDPD $0xa5, (BX), X0
+	MOVOU X0, 32(AX)
+
+	MOVOU (CX), X1
+	VPBLENDW $0xa5, (BX), X1, X2
+	MOVOU X2, 48(AX)
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPBLENDW $0xa5, Y0, Y1, Y2
+	VMOVDQU Y2, 64(AX)
+
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPBLENDD $0xa5, X0, X1, X2
+	MOVOU X2, 96(AX)
+	VMOVDQU (CX), Y1
+	VPBLENDD $0xa5, (BX), Y1, Y2
+	VMOVDQU Y2, 112(AX)
+
+	MOVOU (CX), X1
+	VBLENDPS $0xa5, (BX), X1, X2
+	MOVOU X2, 144(AX)
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VBLENDPS $0xa5, Y0, Y1, Y2
+	VMOVDQU Y2, 160(AX)
+
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VBLENDPD $0xa5, X0, X1, X2
+	MOVOU X2, 192(AX)
+	VMOVDQU (CX), Y1
+	VBLENDPD $0xa5, (BX), Y1, Y2
+	VMOVDQU Y2, 208(AX)
+	VZEROUPPER
+	RET
+
+// packedUnpackSemantics covers low/high interleaving for every 8/16/32/64-bit
+// legacy opcode and every Y-width V opcode, including per-128-bit-lane rules.
+TEXT ·packedUnpackSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+
+	MOVOU (CX), X0
+	PUNPCKLBW (BX), X0
+	MOVOU X0, 0(AX)
+	MOVOU (CX), X0
+	PUNPCKHBW (BX), X0
+	MOVOU X0, 16(AX)
+	MOVOU (CX), X0
+	PUNPCKLWL (BX), X0
+	MOVOU X0, 32(AX)
+	MOVOU (CX), X0
+	PUNPCKHWL (BX), X0
+	MOVOU X0, 48(AX)
+	MOVOU (CX), X0
+	PUNPCKLLQ (BX), X0
+	MOVOU X0, 64(AX)
+	MOVOU (CX), X0
+	PUNPCKHLQ (BX), X0
+	MOVOU X0, 80(AX)
+	MOVOU (CX), X0
+	PUNPCKLQDQ (BX), X0
+	MOVOU X0, 96(AX)
+	MOVOU (CX), X0
+	PUNPCKHQDQ (BX), X0
+	MOVOU X0, 112(AX)
+
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPUNPCKLBW Y0, Y1, Y2
+	VMOVDQU Y2, 128(AX)
+	VPUNPCKHBW Y0, Y1, Y2
+	VMOVDQU Y2, 160(AX)
+	VPUNPCKLWD Y0, Y1, Y2
+	VMOVDQU Y2, 192(AX)
+	VPUNPCKHWD Y0, Y1, Y2
+	VMOVDQU Y2, 224(AX)
+	VPUNPCKLDQ Y0, Y1, Y2
+	VMOVDQU Y2, 256(AX)
+	VPUNPCKHDQ Y0, Y1, Y2
+	VMOVDQU Y2, 288(AX)
+	VPUNPCKLQDQ Y0, Y1, Y2
+	VMOVDQU Y2, 320(AX)
+	VPUNPCKHQDQ Y0, Y1, Y2
+	VMOVDQU Y2, 352(AX)
+	VZEROUPPER
+	RET
+
+// qwordPermuteSemantics validates signed immediate selectors for both
+// bit-identical qword permute opcodes using AVX2 instructions.
+TEXT ·qwordPermuteSemantics(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), AX
+	MOVQ data+8(FP), BX
+	VMOVDQU (BX), Y0
+	VPERMQ $-40, Y0, Y2
+	VMOVDQU Y2, 0(AX)
+	VPERMPD $-40, Y0, Y2
+	VMOVDQU Y2, 32(AX)
+	VZEROUPPER
+	RET
+
+// qwordVariablePermuteSemantics validates Plan 9's data,control,destination
+// order. It is assembled natively but only executed through lowered LLVM IR,
+// because the original instructions require AVX-512.
+TEXT ·qwordVariablePermuteSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ data+8(FP), BX
+	MOVQ control+16(FP), CX
+	VMOVDQU (BX), Y0
+	VMOVDQU (CX), Y1
+	VPERMQ Y0, Y1, Y2
+	VMOVDQU Y2, 0(AX)
+	VPERMPD Y0, Y1, Y2
+	VMOVDQU Y2, 32(AX)
+	VZEROUPPER
+	RET
+
+// packedFloatMoveVEXSemantics executes on the native oracle and validates the
+// bit-preserving behavior of all four _yvmovapd opcodes without requiring
+// AVX-512. Aligned moves use register operands so the input pointer may be
+// arbitrarily aligned.
+TEXT ·packedFloatMoveVEXSemantics(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	VMOVDQU (BX), Y0
+	VMOVAPD Y0, Y1
+	VMOVDQU Y1, 0(AX)
+	VMOVAPS Y0, Y1
+	VMOVDQU Y1, 32(AX)
+	VMOVUPD (BX), Y1
+	VMOVUPD Y1, 64(AX)
+	VMOVUPS (BX), Y1
+	VMOVUPS Y1, 96(AX)
+	VZEROUPPER
+	RET
+
+// packedFloatMoveMaskSemantics validates PS dword masks, PD qword masks,
+// merge/zero loads, register moves, and masked memory stores at X/Y/Z widths.
+// Original Go and LLVM objects execute on the required native AVX-512 axis.
+// src/old are 64-byte aligned; out is congruent to 16 modulo 64 so aligned X
+// stores and Z stores at offsets 432/624 all satisfy their physical alignment.
+// Memory stores use merging masks: EVEX.z=1 stores raise #UD and are checked
+// separately by the complete expected-fault Go/LLVM runtime oracle.
+TEXT ·packedFloatMoveMaskSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVW $0xa55a, DX
+	KMOVW DX, K1
+
+	VMOVUPS (CX), X0
+	VMOVUPS (BX), K1, X0
+	VMOVUPS X0, 0(AX)
+	VMOVUPS.Z (BX), K1, X0
+	VMOVUPS X0, 16(AX)
+	VMOVUPS (CX), X0
+	VMOVUPS (BX), X1
+	VMOVAPS X1, K1, X0
+	VMOVUPS X0, 32(AX)
+	VMOVUPS (CX), X0
+	VMOVUPS X0, 48(AX)
+	VMOVUPS (BX), X1
+	VMOVAPS X1, K1, 48(AX)
+
+	VMOVUPD (CX), X0
+	VMOVUPD (BX), K1, X0
+	VMOVUPD X0, 64(AX)
+	VMOVAPD.Z (BX), K1, X0
+	VMOVUPD X0, 80(AX)
+	VMOVUPD (CX), X0
+	VMOVUPD X0, 96(AX)
+	VMOVUPD (BX), X1
+	VMOVAPD X1, K1, 96(AX)
+
+	VMOVAPS (CX), Y0
+	VMOVAPS (BX), K1, Y0
+	VMOVUPS Y0, 112(AX)
+	VMOVAPS.Z (BX), K1, Y0
+	VMOVUPS Y0, 144(AX)
+	VMOVUPS (CX), Y0
+	VMOVUPS Y0, 176(AX)
+	VMOVUPS (BX), Y1
+	VMOVUPS Y1, K1, 176(AX)
+
+	VMOVAPD (CX), Y0
+	VMOVAPD (BX), K1, Y0
+	VMOVUPD Y0, 208(AX)
+	VMOVAPD.Z (BX), K1, Y0
+	VMOVUPD Y0, 240(AX)
+	VMOVUPD (CX), Y0
+	VMOVUPD Y0, 272(AX)
+	VMOVUPD (BX), Y1
+	VMOVUPD Y1, K1, 272(AX)
+
+	VMOVUPS (CX), Z0
+	VMOVUPS (BX), K1, Z0
+	VMOVUPS Z0, 304(AX)
+	VMOVUPS.Z (BX), K1, Z0
+	VMOVUPS Z0, 368(AX)
+	VMOVAPS (CX), Z0
+	VMOVAPS Z0, 432(AX)
+	VMOVAPS (BX), Z1
+	VMOVAPS Z1, K1, 432(AX)
+
+	VMOVUPD (CX), Z0
+	VMOVUPD (BX), K1, Z0
+	VMOVUPD Z0, 496(AX)
+	VMOVUPD.Z (BX), K1, Z0
+	VMOVUPD Z0, 560(AX)
+	VMOVAPD (CX), Z0
+	VMOVAPD Z0, 624(AX)
+	VMOVAPD (BX), Z1
+	VMOVAPD Z1, K1, 624(AX)
+	VZEROUPPER
+	RET
+
+// packedSignExtendMoveVEXSemantics executes all six legacy and all six VEX
+// signed widening opcodes. V forms use register sources to cover the form used
+// by Kyber; legacy forms use exact-width memory sources.
+TEXT ·packedSignExtendMoveVEXSemantics(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVOU (BX), X1
+	PMOVSXBW (BX), X0
+	MOVOU X0, 0(AX)
+	PMOVSXBD (BX), X0
+	MOVOU X0, 16(AX)
+	PMOVSXBQ (BX), X0
+	MOVOU X0, 32(AX)
+	PMOVSXWD (BX), X0
+	MOVOU X0, 48(AX)
+	PMOVSXWQ (BX), X0
+	MOVOU X0, 64(AX)
+	PMOVSXDQ (BX), X0
+	MOVOU X0, 80(AX)
+	VPMOVSXBW X1, Y0
+	VMOVUPD Y0, 96(AX)
+	VPMOVSXBD X1, Y0
+	VMOVUPD Y0, 128(AX)
+	VPMOVSXBQ X1, Y0
+	VMOVUPD Y0, 160(AX)
+	VPMOVSXWD X1, Y0
+	VMOVUPD Y0, 192(AX)
+	VPMOVSXWQ X1, Y0
+	VMOVUPD Y0, 224(AX)
+	VPMOVSXDQ X1, Y0
+	VMOVUPD Y0, 256(AX)
+	VZEROUPPER
+	RET
+
+// packedSignExtendMoveMaskSemantics validates register-source merge masking
+// and exact-width memory-source zero masking for all six EVEX instructions at
+// Z width. It is executed only after LLVM lowering because it requires AVX-512.
+TEXT ·packedSignExtendMoveMaskSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVQ old+16(FP), CX
+	MOVQ $0xa55aa55a, DX
+	KMOVQ DX, K1
+	VMOVUPD (BX), Y1
+	VMOVUPD (CX), Z0
+	VPMOVSXBW Y1, K1, Z0
+	VMOVUPD Z0, 0(AX)
+	VPMOVSXBW.Z (BX), K1, Z0
+	VMOVUPD Z0, 64(AX)
+	MOVOU (BX), X1
+	VMOVUPD (CX), Z0
+	VPMOVSXBD X1, K1, Z0
+	VMOVUPD Z0, 128(AX)
+	VPMOVSXBD.Z (BX), K1, Z0
+	VMOVUPD Z0, 192(AX)
+	VMOVUPD (CX), Z0
+	VPMOVSXBQ X1, K1, Z0
+	VMOVUPD Z0, 256(AX)
+	VPMOVSXBQ.Z (BX), K1, Z0
+	VMOVUPD Z0, 320(AX)
+	VMOVUPD (CX), Z0
+	VPMOVSXWD Y1, K1, Z0
+	VMOVUPD Z0, 384(AX)
+	VPMOVSXWD.Z (BX), K1, Z0
+	VMOVUPD Z0, 448(AX)
+	VMOVUPD (CX), Z0
+	VPMOVSXWQ X1, K1, Z0
+	VMOVUPD Z0, 512(AX)
+	VPMOVSXWQ.Z (BX), K1, Z0
+	VMOVUPD Z0, 576(AX)
+	VMOVUPD (CX), Z0
+	VPMOVSXDQ Y1, K1, Z0
+	VMOVUPD Z0, 640(AX)
+	VPMOVSXDQ.Z (BX), K1, Z0
+	VMOVUPD Z0, 704(AX)
+	VZEROUPPER
+	RET
+
 // goHexVectorOps covers the packed integer forms used by go-hex. Each result
 // occupies one 16-byte block in out, in the order documented by its Go test.
 TEXT ·goHexVectorOps(SB), NOSPLIT, $0-24
@@ -208,3 +1172,657 @@ TEXT ·packedArithmeticShift32(SB), NOSPLIT, $0-16
 	PSRAL $32, X0
 	MOVOU X0, 16(AX)
 	RET
+
+// packedSubtractSemantics covers wrapping and signed/unsigned saturation,
+// including the non-commutative rm,v,destination order of the V forms.
+TEXT ·packedSubtractSemantics(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PSUBSB X1, X0
+	MOVOU X0, 0(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	PSUBSW X1, X0
+	MOVOU X0, 16(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPSUBUSB X1, X0, X2
+	MOVOU X2, 32(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPSUBUSW X1, X0, X2
+	MOVOU X2, 48(AX)
+	MOVOU (BX), X0
+	MOVOU (CX), X1
+	VPSUBQ X1, X0, X2
+	MOVOU X2, 64(AX)
+	RET
+
+// parityBranches validates both halves of the Go assembler's parity branch
+// alias family against TESTB's low-byte even-parity flag.
+TEXT ·parityBranches(SB), NOSPLIT, $0-16
+	MOVBLZX value+0(FP), AX
+	MOVQ $0, DX
+	TESTB AL, AL
+	JP parity_even
+	JMP parity_even_done
+parity_even:
+	ORQ $1, DX
+parity_even_done:
+	TESTB AL, AL
+	JNP parity_odd
+	JMP parity_odd_done
+parity_odd:
+	ORQ $2, DX
+parity_odd_done:
+	MOVQ DX, ret+8(FP)
+	RET
+
+// unorderedBranch validates that UCOMISD sets PF for NaN inputs.
+TEXT ·unorderedBranch(SB), NOSPLIT, $0-16
+	MOVSD value+0(FP), X0
+	UCOMISD X0, X0
+	JP unordered
+	MOVQ $0, ret+8(FP)
+	RET
+unordered:
+	MOVQ $1, ret+8(FP)
+	RET
+
+// packedFloatToDwordModes covers CVTPS2PL's four MXCSR rounding modes and
+// CVTTPS2PL's rounding-mode-independent truncation. It also exercises the
+// STMXCSR/LDMXCSR memory forms through a real Go assembly stack frame.
+TEXT ·packedFloatToDwordModes(SB), NOSPLIT, $8-16
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVOU (BX), X0
+
+	STMXCSR mxcsrOrig-8(SP)
+	MOVL mxcsrOrig-8(SP), DX
+	ANDL $0xffff9fff, DX
+
+	MOVL DX, mxcsrMode-4(SP)
+	LDMXCSR mxcsrMode-4(SP)
+	CVTPS2PL X0, X1
+	MOVOU X1, 0(AX)
+
+	ORL $0x2000, DX
+	MOVL DX, mxcsrMode-4(SP)
+	LDMXCSR mxcsrMode-4(SP)
+	CVTPS2PL X0, X1
+	MOVOU X1, 16(AX)
+
+	ANDL $0xffff9fff, DX
+	ORL $0x4000, DX
+	MOVL DX, mxcsrMode-4(SP)
+	LDMXCSR mxcsrMode-4(SP)
+	CVTPS2PL X0, X1
+	MOVOU X1, 32(AX)
+
+	ORL $0x2000, DX
+	MOVL DX, mxcsrMode-4(SP)
+	LDMXCSR mxcsrMode-4(SP)
+	CVTPS2PL X0, X1
+	MOVOU X1, 48(AX)
+
+	CVTTPS2PL X0, X1
+	MOVOU X1, 64(AX)
+	LDMXCSR mxcsrOrig-8(SP)
+	RET
+
+// sameWidthPackedConversionSemantics covers the five opcodes sharing Go
+// 1.27's _yvcvtdq2ps table. It verifies every conversion mode, both square
+// root lane widths, and all four EVEX explicit-rounding controls.
+TEXT ·sameWidthPackedConversionSemantics(SB), NOSPLIT, $8-40
+	MOVQ out+0(FP), AX
+	MOVQ ints+8(FP), BX
+	MOVQ floats+16(FP), CX
+	MOVQ squares32+24(FP), DX
+	MOVQ squares64+32(FP), SI
+
+	STMXCSR sameWidthMXCSROrig-8(SP)
+	MOVL sameWidthMXCSROrig-8(SP), R9
+	ANDL $0xffff9fff, R9
+	MOVL R9, sameWidthMXCSRNearest-4(SP)
+	LDMXCSR sameWidthMXCSRNearest-4(SP)
+
+	VMOVDQU32 (BX), Z0
+	VCVTDQ2PS Z0, Z1
+	VMOVDQU32 Z1, 0(AX)
+
+	VMOVUPS (CX), Z0
+	VCVTPS2DQ Z0, Z1
+	VMOVDQU32 Z1, 64(AX)
+	VCVTTPS2DQ Z0, Z1
+	VMOVDQU32 Z1, 128(AX)
+
+	VMOVUPS (DX), Z0
+	VSQRTPS Z0, Z1
+	VMOVDQU32 Z1, 192(AX)
+	VMOVUPD (SI), Z0
+	VSQRTPD Z0, Z1
+	VMOVDQU64 Z1, 256(AX)
+
+	VMOVUPS (CX), Z0
+	VCVTPS2DQ.RN_SAE Z0, Z1
+	VMOVDQU32 Z1, 320(AX)
+	VCVTPS2DQ.RD_SAE Z0, Z1
+	VMOVDQU32 Z1, 384(AX)
+	VCVTPS2DQ.RU_SAE Z0, Z1
+	VMOVDQU32 Z1, 448(AX)
+	VCVTPS2DQ.RZ_SAE Z0, Z1
+	VMOVDQU32 Z1, 512(AX)
+
+	LDMXCSR sameWidthMXCSROrig-8(SP)
+	RET
+
+// packedSingleToDouble validates both register and exact-width memory inputs.
+TEXT ·packedSingleToDouble(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVOU (BX), X0
+	CVTPS2PD X0, X1
+	MOVOU X1, 0(AX)
+	CVTPS2PD 8(BX), X1
+	MOVOU X1, 16(AX)
+	RET
+
+// conditionalMoveCodes establishes CF=0, PF=1, ZF=0, SF=1, OF=1, then
+// checks all 16 condition codes using the yml_rl memory-source form.
+TEXT ·conditionalMoveCodes(SB), NOSPLIT, $0-16
+	MOVQ out+0(FP), AX
+	MOVQ src+8(FP), BX
+	MOVQ $0x7fffffffffffffff, R8
+	ADDQ $1, R8
+	MOVQ $-1, CX
+	CMOVQCC 0(BX), CX
+	MOVQ CX, 0(AX)
+	MOVQ $-1, CX
+	CMOVQCS 8(BX), CX
+	MOVQ CX, 8(AX)
+	MOVQ $-1, CX
+	CMOVQEQ 16(BX), CX
+	MOVQ CX, 16(AX)
+	MOVQ $-1, CX
+	CMOVQGE 24(BX), CX
+	MOVQ CX, 24(AX)
+	MOVQ $-1, CX
+	CMOVQGT 32(BX), CX
+	MOVQ CX, 32(AX)
+	MOVQ $-1, CX
+	CMOVQHI 40(BX), CX
+	MOVQ CX, 40(AX)
+	MOVQ $-1, CX
+	CMOVQLE 48(BX), CX
+	MOVQ CX, 48(AX)
+	MOVQ $-1, CX
+	CMOVQLS 56(BX), CX
+	MOVQ CX, 56(AX)
+	MOVQ $-1, CX
+	CMOVQLT 64(BX), CX
+	MOVQ CX, 64(AX)
+	MOVQ $-1, CX
+	CMOVQMI 72(BX), CX
+	MOVQ CX, 72(AX)
+	MOVQ $-1, CX
+	CMOVQNE 80(BX), CX
+	MOVQ CX, 80(AX)
+	MOVQ $-1, CX
+	CMOVQOC 88(BX), CX
+	MOVQ CX, 88(AX)
+	MOVQ $-1, CX
+	CMOVQOS 96(BX), CX
+	MOVQ CX, 96(AX)
+	MOVQ $-1, CX
+	CMOVQPC 104(BX), CX
+	MOVQ CX, 104(AX)
+	MOVQ $-1, CX
+	CMOVQPL 112(BX), CX
+	MOVQ CX, 112(AX)
+	MOVQ $-1, CX
+	CMOVQPS 120(BX), CX
+	MOVQ CX, 120(AX)
+	RET
+
+// fma3Semantics validates all three operand orders, all six arithmetic modes,
+// packed single/double lanes, and scalar upper-lane copying using VEX forms
+// that execute on both the native oracle and the lowered LLVM binary.
+TEXT ·fma3Semantics(SB), NOSPLIT, $0-56
+	MOVQ out+0(FP), AX
+	MOVQ a64+8(FP), BX
+	MOVQ b64+16(FP), CX
+	MOVQ c64+24(FP), DX
+	MOVQ a32+32(FP), SI
+	MOVQ b32+40(FP), DI
+	MOVQ c32+48(FP), R8
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMADD132PD X0, X1, X2
+	VMOVUPD X2, 0(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMADD213PD X0, X1, X2
+	VMOVUPD X2, 16(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMADD231PD X0, X1, X2
+	VMOVUPD X2, 32(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMSUB132PD X0, X1, X2
+	VMOVUPD X2, 48(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFNMADD213PD X0, X1, X2
+	VMOVUPD X2, 64(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFNMSUB231PD X0, X1, X2
+	VMOVUPD X2, 80(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMADDSUB132PD X0, X1, X2
+	VMOVUPD X2, 96(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMSUBADD231PD X0, X1, X2
+	VMOVUPD X2, 112(AX)
+
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFMADD132PS X0, X1, X2
+	VMOVUPS X2, 128(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFMSUB213PS X0, X1, X2
+	VMOVUPS X2, 144(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFNMADD231PS X0, X1, X2
+	VMOVUPS X2, 160(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFNMSUB132PS X0, X1, X2
+	VMOVUPS X2, 176(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFMADDSUB213PS X0, X1, X2
+	VMOVUPS X2, 192(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFMSUBADD231PS X0, X1, X2
+	VMOVUPS X2, 208(AX)
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMADD132SD X0, X1, X2
+	VMOVUPD X2, 224(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMOVUPD (DX), X2
+	VFMSUB213SD X0, X1, X2
+	VMOVUPD X2, 240(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFNMADD231SS X0, X1, X2
+	VMOVUPS X2, 256(AX)
+	VMOVUPS (SI), X0
+	VMOVUPS (DI), X1
+	VMOVUPS (R8), X2
+	VFNMSUB132SS X0, X1, X2
+	VMOVUPS X2, 272(AX)
+	VZEROUPPER
+	RET
+
+// binaryFloatingSemantics covers every operation in the VADD/VSUB/VMUL/
+// VDIV/VMAX/VMIN family for packed and scalar f32/f64 VEX forms. Scalar
+// results also verify that upper lanes come from the second source operand.
+TEXT ·binaryFloatingSemantics(SB), NOSPLIT, $0-40
+	MOVQ out+0(FP), AX
+	MOVQ a64+8(FP), BX
+	MOVQ b64+16(FP), CX
+	MOVQ a32+24(FP), DX
+	MOVQ b32+32(FP), SI
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VADDPD X0, X1, X2
+	VMOVUPD X2, 0(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VSUBPD X0, X1, X2
+	VMOVUPD X2, 16(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMULPD X0, X1, X2
+	VMOVUPD X2, 32(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VDIVPD X0, X1, X2
+	VMOVUPD X2, 48(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMAXPD X0, X1, X2
+	VMOVUPD X2, 64(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMINPD X0, X1, X2
+	VMOVUPD X2, 80(AX)
+
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VADDPS X0, X1, X2
+	VMOVUPS X2, 96(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VSUBPS X0, X1, X2
+	VMOVUPS X2, 112(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMULPS X0, X1, X2
+	VMOVUPS X2, 128(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VDIVPS X0, X1, X2
+	VMOVUPS X2, 144(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMAXPS X0, X1, X2
+	VMOVUPS X2, 160(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMINPS X0, X1, X2
+	VMOVUPS X2, 176(AX)
+
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VADDSD X0, X1, X2
+	VMOVUPD X2, 192(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VSUBSD X0, X1, X2
+	VMOVUPD X2, 208(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMULSD X0, X1, X2
+	VMOVUPD X2, 224(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VDIVSD X0, X1, X2
+	VMOVUPD X2, 240(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMAXSD X0, X1, X2
+	VMOVUPD X2, 256(AX)
+	VMOVUPD (BX), X0
+	VMOVUPD (CX), X1
+	VMINSD X0, X1, X2
+	VMOVUPD X2, 272(AX)
+
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VADDSS X0, X1, X2
+	VMOVUPS X2, 288(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VSUBSS X0, X1, X2
+	VMOVUPS X2, 304(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMULSS X0, X1, X2
+	VMOVUPS X2, 320(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VDIVSS X0, X1, X2
+	VMOVUPS X2, 336(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMAXSS X0, X1, X2
+	VMOVUPS X2, 352(AX)
+	VMOVUPS (DX), X0
+	VMOVUPS (SI), X1
+	VMINSS X0, X1, X2
+	VMOVUPS X2, 368(AX)
+	VZEROUPPER
+	RET
+
+// horizontalFloatingSemantics verifies the 128-bit lane grouping and Plan 9
+// source order for every legacy and VEX horizontal add/subtract operation.
+TEXT ·horizontalFloatingSemantics(SB), NOSPLIT, $0-40
+	MOVQ out+0(FP), AX
+	MOVQ a32+8(FP), BX
+	MOVQ b32+16(FP), CX
+	MOVQ a64+24(FP), DX
+	MOVQ b64+32(FP), SI
+
+	VMOVUPS (BX), Y0
+	VMOVUPS (CX), Y1
+	VHADDPS Y0, Y1, Y2
+	VMOVUPS Y2, 0(AX)
+	VMOVUPS (BX), Y0
+	VMOVUPS (CX), Y1
+	VHSUBPS Y0, Y1, Y2
+	VMOVUPS Y2, 32(AX)
+	VMOVUPD (DX), Y0
+	VMOVUPD (SI), Y1
+	VHADDPD Y0, Y1, Y2
+	VMOVUPD Y2, 64(AX)
+	VMOVUPD (DX), Y0
+	VMOVUPD (SI), Y1
+	VHSUBPD Y0, Y1, Y2
+	VMOVUPD Y2, 96(AX)
+
+	MOVUPS (BX), X0
+	MOVUPS (CX), X1
+	HADDPS X0, X1
+	MOVUPS X1, 128(AX)
+	MOVUPS (BX), X0
+	MOVUPS (CX), X1
+	HSUBPS X0, X1
+	MOVUPS X1, 144(AX)
+	MOVUPD (DX), X0
+	MOVUPD (SI), X1
+	HADDPD X0, X1
+	MOVUPD X1, 160(AX)
+	MOVUPD (DX), X0
+	MOVUPD (SI), X1
+	HSUBPD X0, X1
+	MOVUPD X1, 176(AX)
+	VZEROUPPER
+	RET
+
+// expandedEcosystemVectors covers the packed min/max family plus the scalar
+// VEX move and packed-qword shift forms found by the ecosystem scan.
+TEXT ·expandedEcosystemVectors(SB), NOSPLIT, $0-24
+	MOVQ out+0(FP), AX
+	MOVQ a+8(FP), BX
+	MOVQ b+16(FP), CX
+
+	MOVOU (BX), X0
+	PMINUB (CX), X0
+	MOVOU X0, 0(AX)
+	MOVOU (BX), X0
+	PMINSB (CX), X0
+	MOVOU X0, 16(AX)
+	MOVOU (BX), X0
+	PMINUW (CX), X0
+	MOVOU X0, 32(AX)
+	MOVOU (BX), X0
+	PMINSW (CX), X0
+	MOVOU X0, 48(AX)
+	MOVOU (BX), X0
+	PMINUD (CX), X0
+	MOVOU X0, 64(AX)
+	MOVOU (BX), X0
+	PMINSD (CX), X0
+	MOVOU X0, 80(AX)
+
+	MOVOU (BX), X0
+	PMAXUB (CX), X0
+	MOVOU X0, 96(AX)
+	MOVOU (BX), X0
+	PMAXSB (CX), X0
+	MOVOU X0, 112(AX)
+	MOVOU (BX), X0
+	PMAXUW (CX), X0
+	MOVOU X0, 128(AX)
+	MOVOU (BX), X0
+	PMAXSW (CX), X0
+	MOVOU X0, 144(AX)
+	MOVOU (BX), X0
+	PMAXUD (CX), X0
+	MOVOU X0, 160(AX)
+	MOVOU (BX), X0
+	PMAXSD (CX), X0
+	MOVOU X0, 176(AX)
+
+	MOVOU (BX), X0
+	PSLLQ $13, X0
+	MOVOU X0, 192(AX)
+	MOVOU (BX), X0
+	PSRLQ $64, X0
+	MOVOU X0, 208(AX)
+
+	MOVQ $0x0123456789abcdef, DX
+	VMOVQ DX, X0
+	VMOVQ X0, DX
+	MOVQ DX, 224(AX)
+	VMOVD DX, X0
+	VMOVD X0, DX
+	MOVQ DX, 232(AX)
+	MOVOU X0, 240(AX)
+	MOVOU (BX), X0
+	VMOVQ X0, X1
+	MOVOU X1, 256(AX)
+
+	MOVOU (BX), X0
+	PAVGB (CX), X0
+	MOVOU X0, 272(AX)
+	MOVOU (BX), X0
+	PAVGW (CX), X0
+	MOVOU X0, 288(AX)
+
+	MOVOU (BX), X0
+	PCMPGTB (CX), X0
+	MOVOU X0, 304(AX)
+	MOVOU (BX), X0
+	PCMPGTW (CX), X0
+	MOVOU X0, 320(AX)
+	MOVOU (BX), X0
+	PCMPGTL (CX), X0
+	MOVOU X0, 336(AX)
+	MOVOU (BX), X0
+	PCMPGTQ (CX), X0
+	MOVOU X0, 352(AX)
+
+	MOVOU (BX), X0
+	PSRAW $3, X0
+	MOVOU X0, 368(AX)
+	MOVOU (BX), X0
+	PSRAW (CX), X0
+	MOVOU X0, 384(AX)
+
+	MOVOU (BX), X0
+	UNPCKLPS (CX), X0
+	MOVOU X0, 400(AX)
+	MOVOU (BX), X0
+	UNPCKHPS (CX), X0
+	MOVOU X0, 416(AX)
+	MOVOU (BX), X0
+	UNPCKLPD (CX), X0
+	MOVOU X0, 432(AX)
+	MOVOU (BX), X0
+	UNPCKHPD (CX), X0
+	MOVOU X0, 448(AX)
+
+	PMOVZXBW (BX), X0
+	MOVOU X0, 464(AX)
+	PMOVZXBD (BX), X0
+	MOVOU X0, 480(AX)
+	PMOVZXBQ (BX), X0
+	MOVOU X0, 496(AX)
+	PMOVZXWD (BX), X0
+	MOVOU X0, 512(AX)
+	PMOVZXWQ (BX), X0
+	MOVOU X0, 528(AX)
+	PMOVZXDQ (BX), X0
+	MOVOU X0, 544(AX)
+
+	MOVOU (BX), X0
+	PHADDD (CX), X0
+	MOVOU X0, 560(AX)
+	MOVOU (BX), X0
+	PHADDSW (CX), X0
+	MOVOU X0, 576(AX)
+	MOVOU (BX), X0
+	PHADDW (CX), X0
+	MOVOU X0, 592(AX)
+	MOVOU (BX), X0
+	PHSUBD (CX), X0
+	MOVOU X0, 608(AX)
+	MOVOU (BX), X0
+	PHSUBSW (CX), X0
+	MOVOU X0, 624(AX)
+	MOVOU (BX), X0
+	PHSUBW (CX), X0
+	MOVOU X0, 640(AX)
+
+	PHMINPOSUW (BX), X0
+	MOVOU X0, 656(AX)
+
+	MOVOU (CX), X0
+	MOVOU X0, 672(AX)
+	MOVOU (CX), X0
+	MOVOU (BX), X1
+	LEAQ 672(AX), DI
+	MASKMOVDQU X0, X1
+	MOVOU (CX), X0
+	MOVOU X0, 688(AX)
+	MOVOU (CX), X0
+	MOVOU (BX), X1
+	LEAQ 688(AX), DI
+	VMASKMOVDQU X0, X1
+
+	MOVQ $3, 800(AX)
+	MOVQ $0, 808(AX)
+	MOVOU 800(AX), X1
+	MOVOU (BX), X0
+	PSLLW X1, X0
+	MOVOU X0, 704(AX)
+	MOVOU (BX), X0
+	PSLLL X1, X0
+	MOVOU X0, 720(AX)
+	MOVOU (BX), X0
+	PSLLQ X1, X0
+	MOVOU X0, 736(AX)
+	MOVOU (BX), X0
+	PSRLW X1, X0
+	MOVOU X0, 752(AX)
+	MOVOU (BX), X0
+	PSRLL X1, X0
+	MOVOU X0, 768(AX)
+	MOVOU (BX), X0
+	PSRLQ X1, X0
+	MOVOU X0, 784(AX)
+	VZEROUPPER
+	RET
diff --git a/testdata/conformance/amd64/conformance_test.go b/testdata/conformance/amd64/conformance_test.go
index e39c37503..d5d75d08e 100644
--- a/testdata/conformance/amd64/conformance_test.go
+++ b/testdata/conformance/amd64/conformance_test.go
@@ -2,7 +2,13 @@
 
 package amd64conformance
 
-import "testing"
+import (
+	"encoding/binary"
+	"math"
+	"os"
+	"testing"
+	"unsafe"
+)
 
 func TestByteMemoryDestinations(t *testing.T) {
 	got := [4]byte{0x10, 0xf0, 0x5a, 0xa0}
@@ -114,6 +120,700 @@ func TestDoubleShiftFamily(t *testing.T) {
 	}
 }
 
+func rotateLeft(value uint64, bits uint, count uint64) uint64 {
+	mask := uint64(1)<<bits - 1
+	count %= uint64(bits)
+	value &= mask
+	if count == 0 {
+		return value
+	}
+	return ((value << count) | (value >> (uint64(bits) - count))) & mask
+}
+
+func rotateRight(value uint64, bits uint, count uint64) uint64 {
+	return rotateLeft(value, bits, uint64(bits)-count%uint64(bits))
+}
+
+func replaceLow(value, low uint64, bits uint) uint64 {
+	mask := uint64(1)<<bits - 1
+	return value&^mask | low&mask
+}
+
+func TestScalarShiftRotateSemantics(t *testing.T) {
+	value := uint64(0x8123456789abcdef)
+	wordDst := uint64(0xfedcba9876543210)
+	for count := uint64(0); count < 16; count++ {
+		var got [14]uint64
+		scalarShiftRotateSemantics(&got, value, count)
+		hardwareCount := count & 31
+		byteLogical := uint64(0)
+		byteArithmetic := uint64(0xff)
+		if hardwareCount < 8 {
+			byteLogical = uint64(byte(value)) >> hardwareCount
+			byteArithmetic = uint64(byte(int8(value) >> hardwareCount))
+		}
+		wordCount := count & 15
+		shldw := uint64(uint16(wordDst))
+		shrdw := uint64(uint16(wordDst))
+		if wordCount != 0 {
+			shldw = uint64(uint16(wordDst)<<wordCount | uint16(value)>>(16-wordCount))
+			shrdw = uint64(uint16(wordDst)>>wordCount | uint16(value)<<(16-wordCount))
+		}
+		want := [14]uint64{
+			replaceLow(value, rotateLeft(value, 8, count), 8),
+			replaceLow(value, rotateRight(value, 8, count), 8),
+			replaceLow(value, byteArithmetic, 8),
+			replaceLow(value, byteLogical, 8),
+			replaceLow(value, rotateLeft(value, 16, count), 16),
+			replaceLow(value, uint64(uint16(int16(value)>>hardwareCount)), 16),
+			uint64(uint32(value) << hardwareCount),
+			rotateRight(value, 64, count),
+			replaceLow(value, byteLogical, 8),
+			replaceLow(value, rotateLeft(value, 16, count), 16),
+			replaceLow(wordDst, shldw, 16),
+			replaceLow(wordDst, shrdw, 16),
+			replaceLow(value, uint64(byte(value)<<3), 8),
+			uint64(uint32(int32(value) >> 3)),
+		}
+		if got != want {
+			t.Fatalf("scalarShiftRotateSemantics(%#x, %d) = %#x, want %#x", value, count, got, want)
+		}
+	}
+}
+
+func TestIncDecSemantics(t *testing.T) {
+	for _, value := range []uint64{0, 1, 0x7f, 0xff, 0xffff, 0xffffffff, 0x8123456789abcdef} {
+		var got [12]uint64
+		incDecSemantics(&got, value)
+		want := [12]uint64{
+			replaceLow(value, uint64(byte(value)+1), 8),
+			replaceLow(value, uint64(byte(value)-1), 8),
+			replaceLow(value, uint64(uint16(value)+1), 16),
+			replaceLow(value, uint64(uint16(value)-1), 16),
+			uint64(uint32(value) + 1),
+			uint64(uint32(value) - 1),
+			value + 1,
+			value - 1,
+			replaceLow(value, uint64(byte(value)+1), 8),
+			replaceLow(value, uint64(uint16(value)-1), 16),
+			0x0000000000010101,
+			0x0000000101000001,
+		}
+		if got != want {
+			t.Fatalf("incDecSemantics(%#x) = %#x, want %#x", value, got, want)
+		}
+	}
+}
+
+func referenceScalarAddSub(add bool, bits uint, value, source uint64, registerDestination bool) (uint64, uint64) {
+	mask := ^uint64(0)
+	if bits != 64 {
+		mask = uint64(1)<<bits - 1
+	}
+	destinationLow := value & mask
+	sourceLow := source & mask
+	var resultLow uint64
+	var carry, overflow bool
+	if add {
+		resultLow = (destinationLow + sourceLow) & mask
+		carry = resultLow < destinationLow
+		overflow = (^(destinationLow ^ sourceLow) & (destinationLow ^ resultLow) & (uint64(1) << (bits - 1))) != 0
+	} else {
+		resultLow = (destinationLow - sourceLow) & mask
+		carry = destinationLow < sourceLow
+		overflow = ((destinationLow ^ sourceLow) & (destinationLow ^ resultLow) & (uint64(1) << (bits - 1))) != 0
+	}
+	result := resultLow
+	if bits < 64 && !(registerDestination && bits == 32) {
+		result = value&^mask | resultLow
+	}
+	parity := byte(1)
+	for low := byte(resultLow); low != 0; low &= low - 1 {
+		parity ^= 1
+	}
+	flag := func(value bool) uint64 {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	flags := flag(carry) |
+		flag(overflow)<<8 |
+		flag(resultLow == 0)<<16 |
+		flag(resultLow&(uint64(1)<<(bits-1)) != 0)<<24 |
+		uint64(parity)<<32
+	return result, flags
+}
+
+func TestScalarAddSubSemantics(t *testing.T) {
+	for _, tc := range []struct {
+		value  uint64
+		source uint64
+	}{
+		{0, 0},
+		{^uint64(0), 1},
+		{0x7f, 1},
+		{0x7fff, 1},
+		{0x7fffffff, 1},
+		{0x7fffffffffffffff, 1},
+		{0x8123456789abcdef, 0xfedcba9876543210},
+	} {
+		var got, want [16]uint64
+		scalarAddSubSemantics(&got, tc.value, tc.source)
+		for widthIndex, bits := range []uint{8, 16, 32, 64} {
+			want[widthIndex*4], want[widthIndex*4+1] = referenceScalarAddSub(true, bits, tc.value, tc.source, true)
+			want[widthIndex*4+2], want[widthIndex*4+3] = referenceScalarAddSub(false, bits, tc.value, ^uint64(0), false)
+		}
+		if got != want {
+			t.Fatalf("scalarAddSubSemantics(%#x, %#x) = %#x, want %#x", tc.value, tc.source, got, want)
+		}
+	}
+}
+
+func TestCompareExchangeScalarSemantics(t *testing.T) {
+	const desired = uint64(0xfedcba9876543210)
+	for _, expected := range []uint64{0, ^uint64(0), 0x7f, 0x7fff, 0x7fffffff, 0x7fffffffffffffff, 0x8123456789abcdef} {
+		var memory [8]uint64
+		for widthIndex, bits := range []uint{8, 16, 32, 64} {
+			mask := ^uint64(0)
+			if bits != 64 {
+				mask = uint64(1)<<bits - 1
+			}
+			base := uint64(0xa5a5a5a5a5a5a5a5) &^ mask
+			memory[widthIndex*2] = base | expected&mask
+			memory[widthIndex*2+1] = base | (expected^(uint64(1)<<(bits-1)))&mask
+		}
+		initial := memory
+		var got, want [24]uint64
+		compareExchangeScalarSemantics(&got, &memory, expected, desired)
+		for widthIndex, bits := range []uint{8, 16, 32, 64} {
+			mask := ^uint64(0)
+			if bits != 64 {
+				mask = uint64(1)<<bits - 1
+			}
+			successInitial := initial[widthIndex*2]
+			failureInitial := initial[widthIndex*2+1]
+			outputIndex := widthIndex * 6
+			want[outputIndex] = successInitial&^mask | desired&mask
+			want[outputIndex+1] = expected
+			_, want[outputIndex+2] = referenceScalarAddSub(false, bits, successInitial, expected, true)
+			want[outputIndex+3] = failureInitial
+			switch bits {
+			case 8, 16:
+				want[outputIndex+4] = expected&^mask | failureInitial&mask
+			case 32:
+				want[outputIndex+4] = uint64(uint32(failureInitial))
+			case 64:
+				want[outputIndex+4] = failureInitial
+			}
+			_, want[outputIndex+5] = referenceScalarAddSub(false, bits, expected, failureInitial, true)
+		}
+		if os.Getenv("PLAN9ASM_ROSETTA") == "1" {
+			// Rosetta 2 does not preserve CMPXCHG's architecturally defined CF
+			// and OF results, and clears RAX's high half after a successful
+			// CMPXCHGL even though EAX is not written. Keep the native oracle for
+			// every other result; the LLVM runtime oracle verifies these details.
+			const rosettaUnreliableFlags = uint64(1) | uint64(1)<<8
+			for widthIndex := 0; widthIndex < 4; widthIndex++ {
+				got[widthIndex*6+2] &^= rosettaUnreliableFlags
+				got[widthIndex*6+5] &^= rosettaUnreliableFlags
+				want[widthIndex*6+2] &^= rosettaUnreliableFlags
+				want[widthIndex*6+5] &^= rosettaUnreliableFlags
+			}
+			const cmpxchg32SuccessAccumulator = 2*6 + 1
+			got[cmpxchg32SuccessAccumulator] = uint64(uint32(got[cmpxchg32SuccessAccumulator]))
+			want[cmpxchg32SuccessAccumulator] = uint64(uint32(want[cmpxchg32SuccessAccumulator]))
+		}
+		if got != want {
+			t.Fatalf("compareExchangeScalarSemantics(%#x, %#x) = %#x, want %#x", expected, desired, got, want)
+		}
+	}
+}
+
+func TestCompareExchangePairSemantics(t *testing.T) {
+	const (
+		expectedLow  = uint64(0xaaaaaaaa11223344)
+		expectedHigh = uint64(0xbbbbbbbb55667788)
+		desiredLow   = uint64(0x0123456789abcdef)
+		desiredHigh  = uint64(0xfedcba9876543210)
+	)
+	for _, success := range []bool{true, false} {
+		storage := new([6]uint64)
+		base := uintptr(unsafe.Pointer(&storage[0]))
+		aligned := (base + 15) &^ uintptr(15)
+		memory := (*uint64)(unsafe.Pointer(aligned))
+		view := unsafe.Slice(memory, 4)
+		if success {
+			view[0], view[1] = expectedLow, expectedHigh
+			view[2] = expectedLow&0xffffffff | (expectedHigh&0xffffffff)<<32
+		} else {
+			view[0], view[1] = 0x1020304050607080, 0x90a0b0c0d0e0f001
+			view[2] = 0x8877665544332211
+		}
+		old16Low, old16High, old8 := view[0], view[1], view[2]
+		var got, want [9]uint64
+		compareExchangePairSemantics(&got, memory, expectedLow, expectedHigh, desiredLow, desiredHigh)
+		if success {
+			want = [9]uint64{
+				desiredLow&0xffffffff | (desiredHigh&0xffffffff)<<32,
+				expectedLow, expectedHigh, 1,
+				desiredLow, desiredHigh, expectedLow, expectedHigh, 1,
+			}
+		} else {
+			want = [9]uint64{
+				old8, uint64(uint32(old8)), uint64(uint32(old8 >> 32)), 0,
+				old16Low, old16High, old16Low, old16High, 0,
+			}
+		}
+		if got != want {
+			t.Fatalf("compareExchangePairSemantics(success=%v) = %#x, want %#x", success, got, want)
+		}
+	}
+}
+
+func referencePDEP(mask, source uint64) uint64 {
+	var result uint64
+	for mask != 0 {
+		lowest := mask & -mask
+		if source&1 != 0 {
+			result |= lowest
+		}
+		source >>= 1
+		mask &= mask - 1
+	}
+	return result
+}
+
+func referencePEXT(mask, source uint64) uint64 {
+	var result, outputBit uint64 = 0, 1
+	for mask != 0 {
+		lowest := mask & -mask
+		if source&lowest != 0 {
+			result |= outputBit
+		}
+		outputBit <<= 1
+		mask &= mask - 1
+	}
+	return result
+}
+
+func TestParallelBitDepositExtractSemantics(t *testing.T) {
+	for _, tc := range []struct {
+		mask   uint64
+		source uint64
+	}{
+		{0, 0x0123456789abcdef},
+		{^uint64(0), 0x0123456789abcdef},
+		{0xaaaaaaaaaaaaaaaa, 0x0123456789abcdef},
+		{0x8040201008040201, 0xfedcba9876543210},
+		{0x8000000100000081, ^uint64(0)},
+	} {
+		var got [8]uint64
+		parallelBitSemantics(&got, tc.mask, tc.source)
+		mask32, source32 := uint64(uint32(tc.mask)), uint64(uint32(tc.source))
+		want := [8]uint64{
+			referencePDEP(tc.mask, tc.source), referencePDEP(tc.mask, tc.source),
+			referencePEXT(tc.mask, tc.source), referencePEXT(tc.mask, tc.source),
+			referencePDEP(mask32, source32), referencePDEP(mask32, source32),
+			referencePEXT(mask32, source32), referencePEXT(mask32, source32),
+		}
+		if got != want {
+			t.Fatalf("parallelBitSemantics(%#x, %#x) = %#x, want %#x", tc.mask, tc.source, got, want)
+		}
+	}
+}
+
+func referenceBitTestRegister(stem string, bits int, value, index uint64) (result, carry uint64) {
+	bit := index & uint64(bits-1)
+	carry = (value >> bit) & 1
+	if stem == "BT" {
+		return value, carry
+	}
+	mask := uint64(1) << bit
+	low := value
+	switch stem {
+	case "BTC":
+		low ^= mask
+	case "BTR":
+		low &^= mask
+	case "BTS":
+		low |= mask
+	}
+	switch bits {
+	case 16:
+		return value&^uint64(0xffff) | low&0xffff, carry
+	case 32:
+		return uint64(uint32(low)), carry
+	default:
+		return low, carry
+	}
+}
+
+func TestBitTestRegisterSemantics(t *testing.T) {
+	const value = uint64(0xfedcba9876543210)
+	const index = uint64(21)
+	var got, want [24]uint64
+	bitWidths := []int{16, 32, 64}
+	stems := []string{"BT", "BTC", "BTR", "BTS"}
+	for widthIndex, bits := range bitWidths {
+		for stemIndex, stem := range stems {
+			operandIndex := index
+			switch stem {
+			case "BT":
+				operandIndex = uint64(bits - 1)
+			case "BTR":
+				operandIndex = 4
+			}
+			result, carry := referenceBitTestRegister(stem, bits, value, operandIndex)
+			outIndex := 2 * (widthIndex*len(stems) + stemIndex)
+			want[outIndex], want[outIndex+1] = result, carry
+		}
+	}
+	bitTestRegisterSemantics(&got, value, index)
+	if got != want {
+		t.Fatalf("bitTestRegisterSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestBitTestMemorySemantics(t *testing.T) {
+	data := [9]uint64{
+		^uint64(0), uint64(1) << 17, 0,
+		^uint64(0), uint64(1) << 33, 0,
+		^uint64(0), 0, uint64(1) << 1,
+	}
+	wantData := data
+	wantData[0] &^= uint64(1) << 63
+	wantData[1] = 1
+	wantData[3] &^= uint64(1) << 63
+	wantData[4] = 1
+	wantData[6] &^= uint64(1) << 63
+	wantData[7] = 1
+	wantData[8] = 0
+	var got [12]byte
+	bitTestMemorySemantics(&got, &data)
+	wantCarry := [12]byte{1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0}
+	if got != wantCarry {
+		t.Fatalf("bitTestMemorySemantics() carry = %#v, want %#v", got, wantCarry)
+	}
+	if data != wantData {
+		t.Fatalf("bitTestMemorySemantics() data = %#x, want %#x", data, wantData)
+	}
+}
+
+func referencePackedWordMultiplyAdd(a, b []int16) []int32 {
+	result := make([]int32, len(a)/2)
+	for i := range result {
+		sum := int64(a[2*i])*int64(b[2*i]) + int64(a[2*i+1])*int64(b[2*i+1])
+		result[i] = int32(uint32(sum))
+	}
+	return result
+}
+
+func TestPackedWordMultiplyAddSemantics(t *testing.T) {
+	a := [16]int16{-32768, -32768, -30000, -1, 0, 1, 12345, 32767, 7, -11, 1000, -2000, 22222, -12345, 32767, 32767}
+	b := [16]int16{-32768, -32768, -23456, 32767, -1, 32767, -2345, 32767, -9, 13, -3000, 4000, -11111, 23456, 32767, 32767}
+	var got, want [18]int32
+	first2 := referencePackedWordMultiplyAdd(a[:4], b[:4])
+	first4 := referencePackedWordMultiplyAdd(a[:8], b[:8])
+	first8 := referencePackedWordMultiplyAdd(a[:], b[:])
+	copy(want[0:2], first2)
+	copy(want[2:6], first4)
+	copy(want[6:10], first4)
+	copy(want[10:18], first8)
+	packedWordMultiplyAddSemantics(&got, &a, &b)
+	if got != want {
+		t.Fatalf("packedWordMultiplyAddSemantics() = %v, want %v", got, want)
+	}
+}
+
+func referencePackedUnsignedSignedByteMultiplyAdd(signed []int8, unsigned []uint8) []int16 {
+	result := make([]int16, len(signed)/2)
+	for i := range result {
+		sum := int32(signed[2*i])*int32(unsigned[2*i]) + int32(signed[2*i+1])*int32(unsigned[2*i+1])
+		if sum > 32767 {
+			sum = 32767
+		} else if sum < -32768 {
+			sum = -32768
+		}
+		result[i] = int16(sum)
+	}
+	return result
+}
+
+func TestPackedUnsignedSignedByteMultiplyAddSemantics(t *testing.T) {
+	signed := [32]int8{
+		127, 127, -128, -128, 100, -100, 1, -1,
+		64, -64, 11, 12, -13, 14, 15, -16,
+		31, -32, 33, -34, 35, -36, 37, -38,
+		39, -40, 41, -42, 43, -44, 45, -46,
+	}
+	unsigned := [32]uint8{
+		255, 255, 255, 255, 200, 3, 255, 128,
+		250, 249, 17, 19, 23, 29, 31, 37,
+		41, 43, 47, 53, 59, 61, 67, 71,
+		73, 79, 83, 89, 97, 101, 103, 107,
+	}
+	var got, want [32]int16
+	first8 := referencePackedUnsignedSignedByteMultiplyAdd(signed[:16], unsigned[:16])
+	first16 := referencePackedUnsignedSignedByteMultiplyAdd(signed[:], unsigned[:])
+	copy(want[0:8], first8)
+	copy(want[8:16], first8)
+	copy(want[16:32], first16)
+	packedUnsignedSignedByteMultiplyAddSemantics(&got, &signed, &unsigned)
+	if got != want {
+		t.Fatalf("packedUnsignedSignedByteMultiplyAddSemantics() = %v, want %v", got, want)
+	}
+}
+
+func TestInLaneFloatingPermuteSemantics(t *testing.T) {
+	dataWords := [8]uint32{0x100, 0x101, 0x102, 0x103, 0x104, 0x105, 0x106, 0x107}
+	controlWords := [8]uint32{3, 2, 1, 0, 4, 5, 6, 7}
+	var data, control [32]byte
+	for i := range dataWords {
+		binary.LittleEndian.PutUint32(data[4*i:], dataWords[i])
+		binary.LittleEndian.PutUint32(control[4*i:], controlWords[i])
+	}
+	var got, want [144]byte
+	write32 := func(offset int, value uint32) {
+		binary.LittleEndian.PutUint32(want[offset:], value)
+	}
+	for lane := 0; lane < 4; lane++ {
+		write32(4*lane, dataWords[3-lane])
+	}
+	for lane := 0; lane < 8; lane++ {
+		write32(16+4*lane, dataWords[lane/4*4+3-lane%4])
+		write32(48+4*lane, dataWords[lane/4*4+int(controlWords[lane]&3)])
+	}
+	dataQWords := [4]uint64{}
+	controlQWords := [4]uint64{}
+	for lane := 0; lane < 4; lane++ {
+		dataQWords[lane] = binary.LittleEndian.Uint64(data[8*lane:])
+		controlQWords[lane] = binary.LittleEndian.Uint64(control[8*lane:])
+	}
+	for lane := 0; lane < 4; lane++ {
+		immediateSource := lane/2*2 + int(uint8(0x05)>>uint(lane)&1)
+		variableSource := lane/2*2 + int(controlQWords[lane]>>1&1)
+		binary.LittleEndian.PutUint64(want[80+8*lane:], dataQWords[immediateSource])
+		binary.LittleEndian.PutUint64(want[112+8*lane:], dataQWords[variableSource])
+	}
+	inLaneFloatingPermuteSemantics(&got, &data, &control)
+	if got != want {
+		t.Fatalf("inLaneFloatingPermuteSemantics() = %x, want %x", got, want)
+	}
+}
+
+func TestPackedWordMultiplySemantics(t *testing.T) {
+	a := [8]int16{-32768, -32768, -30000, -1, 0, 1, 12345, 32767}
+	b := [8]int16{-32768, 32767, -23456, 32767, -1, 32767, -2345, 32767}
+	var got, want [64]uint16
+	packedWordMultiplySemantics(&got, &a, &b)
+	for i := range a {
+		product := int32(a[i]) * int32(b[i])
+		unsignedProduct := uint32(uint16(a[i])) * uint32(uint16(b[i]))
+		rounded := (product + 0x4000) >> 15
+		values := [4]uint16{
+			uint16(product),
+			uint16(product >> 16),
+			uint16(unsignedProduct >> 16),
+			uint16(rounded),
+		}
+		for mode, value := range values {
+			want[mode*8+i] = value
+			want[(mode+4)*8+i] = value
+		}
+	}
+	if got != want {
+		t.Fatalf("packedWordMultiplySemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestPackedFloatShuffleSemantics(t *testing.T) {
+	var a, b [32]byte
+	for i := 0; i < 8; i++ {
+		binary.LittleEndian.PutUint32(a[4*i:], uint32(0xa0+i))
+		binary.LittleEndian.PutUint32(b[4*i:], uint32(0xb0+i))
+	}
+	var got, want [96]byte
+	packedFloatShuffleSemantics(&got, &a, &b)
+	put32 := func(offset, value int) {
+		binary.LittleEndian.PutUint32(want[offset:], uint32(value))
+	}
+	for i, value := range []int{0xb3, 0xb2, 0xa1, 0xa0} {
+		put32(4*i, value)
+	}
+	for i, value := range []uint64{0x000000b1000000b0, 0x000000a3000000a2} {
+		binary.LittleEndian.PutUint64(want[16+8*i:], value)
+	}
+	for group := 0; group < 2; group++ {
+		base := group * 4
+		for position, value := range []int{0xb3, 0xb2, 0xa1, 0xa0} {
+			put32(32+4*(base+position), value+base)
+		}
+	}
+	for i, value := range []uint64{0x000000b1000000b0, 0x000000a3000000a2, 0x000000b5000000b4, 0x000000a7000000a6} {
+		binary.LittleEndian.PutUint64(want[64+8*i:], value)
+	}
+	if got != want {
+		t.Fatalf("packedFloatShuffleSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestImmediatePackedBlendSemantics(t *testing.T) {
+	var a, b [32]byte
+	for i := range a {
+		a[i] = byte(0x20 + i)
+		b[i] = byte(0xc0 + i)
+	}
+	var got, want [240]byte
+	immediatePackedBlendSemantics(&got, &a, &b)
+	blocks := []struct {
+		offset, width, laneBytes int
+	}{
+		{0, 16, 2},   // PBLENDW
+		{16, 16, 4},  // BLENDPS
+		{32, 16, 8},  // BLENDPD
+		{48, 16, 2},  // VPBLENDW X
+		{64, 32, 2},  // VPBLENDW Y
+		{96, 16, 4},  // VPBLENDD X
+		{112, 32, 4}, // VPBLENDD Y
+		{144, 16, 4}, // VBLENDPS X
+		{160, 32, 4}, // VBLENDPS Y
+		{192, 16, 8}, // VBLENDPD X
+		{208, 32, 8}, // VBLENDPD Y
+	}
+	const mask = 0xa5
+	for _, block := range blocks {
+		for i := 0; i < block.width; i++ {
+			source := b[i]
+			if mask&(1<<uint((i/block.laneBytes)%8)) != 0 {
+				source = a[i]
+			}
+			want[block.offset+i] = source
+		}
+	}
+	if got != want {
+		t.Fatalf("immediatePackedBlendSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestPackedUnpackSemantics(t *testing.T) {
+	var a, b [32]byte
+	for i := range a {
+		a[i] = byte(0x20 + i)
+		b[i] = byte(0xc0 + i)
+	}
+	var got, want [384]byte
+	packedUnpackSemantics(&got, &a, &b)
+	type unpackBlock struct {
+		offset, width, laneBytes int
+		high                     bool
+	}
+	blocks := []unpackBlock{
+		{0, 16, 1, false}, {16, 16, 1, true},
+		{32, 16, 2, false}, {48, 16, 2, true},
+		{64, 16, 4, false}, {80, 16, 4, true},
+		{96, 16, 8, false}, {112, 16, 8, true},
+		{128, 32, 1, false}, {160, 32, 1, true},
+		{192, 32, 2, false}, {224, 32, 2, true},
+		{256, 32, 4, false}, {288, 32, 4, true},
+		{320, 32, 8, false}, {352, 32, 8, true},
+	}
+	for _, block := range blocks {
+		output := block.offset
+		for group := 0; group < block.width; group += 16 {
+			lanesPerGroup := 16 / block.laneBytes
+			start := 0
+			if block.high {
+				start = lanesPerGroup / 2
+			}
+			for lane := start; lane < start+lanesPerGroup/2; lane++ {
+				input := group + lane*block.laneBytes
+				copy(want[output:], b[input:input+block.laneBytes])
+				output += block.laneBytes
+				copy(want[output:], a[input:input+block.laneBytes])
+				output += block.laneBytes
+			}
+		}
+	}
+	if got != want {
+		t.Fatalf("packedUnpackSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestQwordPermuteSemantics(t *testing.T) {
+	data := [4]uint64{0x10, 0x21, 0x32, 0x43}
+	var got [8]uint64
+	qwordPermuteSemantics(&got, &data)
+	immediate := [4]uint64{data[0], data[2], data[1], data[3]}
+	var want [8]uint64
+	copy(want[0:4], immediate[:])
+	copy(want[4:8], immediate[:])
+	if got != want {
+		t.Fatalf("qwordPermuteSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestPackedFloatMoveVEXSemantics(t *testing.T) {
+	var src [32]byte
+	for i := range src {
+		src[i] = byte(3 + 17*i)
+	}
+	var got, want [128]byte
+	packedFloatMoveVEXSemantics(&got, &src)
+	for block := 0; block < 4; block++ {
+		copy(want[block*32:], src[:])
+	}
+	if got != want {
+		t.Fatalf("packedFloatMoveVEXSemantics() = %#x, want %#x", got, want)
+	}
+}
+
+func TestPackedSignExtendMoveVEXSemantics(t *testing.T) {
+	src := [32]byte{
+		0x00, 0x01, 0x7f, 0x80, 0xff, 0x55, 0xaa, 0x40,
+		0xc0, 0x11, 0xee, 0x33, 0xcc, 0x66, 0x99, 0x22,
+		0xdd, 0x44, 0xbb, 0x77, 0x88, 0x10, 0xf0, 0x20,
+		0xe0, 0x30, 0xd0, 0x50, 0xb0, 0x60, 0xa0, 0x70,
+	}
+	var got, want [288]byte
+	packedSignExtendMoveVEXSemantics(&got, &src)
+	type conversion struct{ inputBits, outputBits int }
+	conversions := []conversion{{8, 16}, {8, 32}, {8, 64}, {16, 32}, {16, 64}, {32, 64}}
+	readSigned := func(offset, bits int) int64 {
+		switch bits {
+		case 8:
+			return int64(int8(src[offset]))
+		case 16:
+			return int64(int16(binary.LittleEndian.Uint16(src[offset:])))
+		default:
+			return int64(int32(binary.LittleEndian.Uint32(src[offset:])))
+		}
+	}
+	write := func(dst []byte, bits int, value int64) {
+		switch bits {
+		case 16:
+			binary.LittleEndian.PutUint16(dst, uint16(value))
+		case 32:
+			binary.LittleEndian.PutUint32(dst, uint32(value))
+		default:
+			binary.LittleEndian.PutUint64(dst, uint64(value))
+		}
+	}
+	for index, conversion := range conversions {
+		for _, block := range []struct{ offset, width int }{{index * 16, 16}, {96 + index*32, 32}} {
+			lanes := block.width * 8 / conversion.outputBits
+			for lane := 0; lane < lanes; lane++ {
+				inputOffset := lane * conversion.inputBits / 8
+				outputOffset := block.offset + lane*conversion.outputBits/8
+				write(want[outputOffset:], conversion.outputBits, readSigned(inputOffset, conversion.inputBits))
+			}
+		}
+	}
+	if got != want {
+		t.Fatalf("packedSignExtendMoveVEXSemantics() = %#x, want %#x", got, want)
+	}
+}
+
 func TestGoHexInstructionFamilies(t *testing.T) {
 	a := [16]byte{}
 	b := [16]byte{}
@@ -182,6 +882,561 @@ func TestPackedArithmeticShiftCountSaturation(t *testing.T) {
 	}
 }
 
+func TestPackedSubtractSemantics(t *testing.T) {
+	a := [16]byte{0x7f, 0x80, 0x64, 0x9c, 0x32, 0xce, 0x00, 0x01, 0xff, 0x00, 0x34, 0x12, 0x00, 0x80, 0xff, 0x7f}
+	b := [16]byte{0xff, 0x01, 0x9c, 0x64, 0xce, 0x32, 0x01, 0x00, 0x01, 0xff, 0x78, 0x56, 0xff, 0x7f, 0x01, 0x80}
+	var got, want [80]byte
+	packedSubtractSemantics(&got, &a, &b)
+	for i := 0; i < 16; i++ {
+		signed := int(int8(a[i])) - int(int8(b[i]))
+		if signed < -128 {
+			signed = -128
+		} else if signed > 127 {
+			signed = 127
+		}
+		want[i] = byte(int8(signed))
+		unsigned := int(a[i]) - int(b[i])
+		if unsigned < 0 {
+			unsigned = 0
+		}
+		want[32+i] = byte(unsigned)
+	}
+	for i := 0; i < 8; i++ {
+		av, bv := binary.LittleEndian.Uint16(a[2*i:]), binary.LittleEndian.Uint16(b[2*i:])
+		signed := int(int16(av)) - int(int16(bv))
+		if signed < -32768 {
+			signed = -32768
+		} else if signed > 32767 {
+			signed = 32767
+		}
+		binary.LittleEndian.PutUint16(want[16+2*i:], uint16(int16(signed)))
+		unsigned := int(av) - int(bv)
+		if unsigned < 0 {
+			unsigned = 0
+		}
+		binary.LittleEndian.PutUint16(want[48+2*i:], uint16(unsigned))
+	}
+	for i := 0; i < 2; i++ {
+		av, bv := binary.LittleEndian.Uint64(a[8*i:]), binary.LittleEndian.Uint64(b[8*i:])
+		binary.LittleEndian.PutUint64(want[64+8*i:], av-bv)
+	}
+	if got != want {
+		t.Fatalf("packedSubtractSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func TestParityBranchSemantics(t *testing.T) {
+	for _, tc := range []struct {
+		value byte
+		want  uint64
+	}{
+		{value: 0x00, want: 1},
+		{value: 0x03, want: 1},
+		{value: 0x01, want: 2},
+		{value: 0x07, want: 2},
+	} {
+		if got := parityBranches(tc.value); got != tc.want {
+			t.Fatalf("parityBranches(%#x) = %d, want %d", tc.value, got, tc.want)
+		}
+	}
+	if got := unorderedBranch(1.25); got != 0 {
+		t.Fatalf("unorderedBranch(finite) = %d, want 0", got)
+	}
+	if got := unorderedBranch(math.NaN()); got != 1 {
+		t.Fatalf("unorderedBranch(NaN) = %d, want 1", got)
+	}
+}
+
+func TestPackedFloatToDwordRoundingModes(t *testing.T) {
+	src := [4]float32{1.5, -1.5, 2.75, -2.75}
+	var got [20]int32
+	packedFloatToDwordModes(&got, &src)
+	want := [20]int32{
+		2, -2, 3, -3,
+		1, -2, 2, -3,
+		2, -1, 3, -2,
+		1, -1, 2, -2,
+		1, -1, 2, -2,
+	}
+	if got != want {
+		t.Fatalf("packedFloatToDwordModes() = %v, want %v", got, want)
+	}
+}
+
+func TestPackedSingleToDoubleSemantics(t *testing.T) {
+	src := [4]float32{1.5, -2.25, 3.125, -4.5}
+	var got [4]float64
+	packedSingleToDouble(&got, &src)
+	want := [4]float64{1.5, -2.25, 3.125, -4.5}
+	if got != want {
+		t.Fatalf("packedSingleToDouble() = %v, want %v", got, want)
+	}
+}
+
+func TestConditionalMoveConditionCodes(t *testing.T) {
+	var src [16]uint64
+	for i := range src {
+		src[i] = uint64(101 + i)
+	}
+	var got [16]uint64
+	conditionalMoveCodes(&got, &src)
+	want := [16]uint64{
+		src[0], ^uint64(0), ^uint64(0), src[3],
+		src[4], src[5], ^uint64(0), ^uint64(0),
+		^uint64(0), src[9], src[10], ^uint64(0),
+		src[12], ^uint64(0), ^uint64(0), src[15],
+	}
+	if got != want {
+		t.Fatalf("conditionalMoveCodes() = %#x, want %#x", got, want)
+	}
+}
+
+func TestFMA3Semantics(t *testing.T) {
+	a64 := [2]float64{2, -3}
+	b64 := [2]float64{5, 7}
+	c64 := [2]float64{11, -13}
+	a32 := [4]float32{2, -3, 4, -5}
+	b32 := [4]float32{5, 7, -11, -13}
+	c32 := [4]float32{17, -19, 23, -29}
+	var got [288]byte
+	fma3Semantics(&got, &a64, &b64, &c64, &a32, &b32, &c32)
+
+	read64 := func(block, lane int) float64 {
+		return math.Float64frombits(binary.LittleEndian.Uint64(got[16*block+8*lane:]))
+	}
+	packed64 := [8][2]float64{}
+	for lane := 0; lane < 2; lane++ {
+		a, b, c := a64[lane], b64[lane], c64[lane]
+		packed64[0][lane] = c*a + b
+		packed64[1][lane] = b*c + a
+		packed64[2][lane] = b*a + c
+		packed64[3][lane] = c*a - b
+		packed64[4][lane] = -(b * c) + a
+		packed64[5][lane] = -(b * a) - c
+		if lane%2 == 0 {
+			packed64[6][lane] = c*a - b
+			packed64[7][lane] = b*a + c
+		} else {
+			packed64[6][lane] = c*a + b
+			packed64[7][lane] = b*a - c
+		}
+	}
+	for block, want := range packed64 {
+		for lane := range want {
+			if value := read64(block, lane); value != want[lane] {
+				t.Fatalf("packed f64 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+
+	read32 := func(block, lane int) float32 {
+		return math.Float32frombits(binary.LittleEndian.Uint32(got[16*block+4*lane:]))
+	}
+	packed32 := [6][4]float32{}
+	for lane := 0; lane < 4; lane++ {
+		a, b, c := a32[lane], b32[lane], c32[lane]
+		packed32[0][lane] = c*a + b
+		packed32[1][lane] = b*c - a
+		packed32[2][lane] = -(b * a) + c
+		packed32[3][lane] = -(c * a) - b
+		if lane%2 == 0 {
+			packed32[4][lane] = b*c - a
+			packed32[5][lane] = b*a + c
+		} else {
+			packed32[4][lane] = b*c + a
+			packed32[5][lane] = b*a - c
+		}
+	}
+	for block, want := range packed32 {
+		for lane := range want {
+			if value := read32(8+block, lane); value != want[lane] {
+				t.Fatalf("packed f32 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+
+	wantScalar64 := [2][2]float64{
+		{c64[0]*a64[0] + b64[0], c64[1]},
+		{b64[0]*c64[0] - a64[0], c64[1]},
+	}
+	for block, want := range wantScalar64 {
+		for lane := range want {
+			if value := read64(14+block, lane); value != want[lane] {
+				t.Fatalf("scalar f64 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+	wantScalar32 := [2][4]float32{
+		{-(b32[0] * a32[0]) + c32[0], c32[1], c32[2], c32[3]},
+		{-(c32[0] * a32[0]) - b32[0], c32[1], c32[2], c32[3]},
+	}
+	for block, want := range wantScalar32 {
+		for lane := range want {
+			if value := read32(16+block, lane); value != want[lane] {
+				t.Fatalf("scalar f32 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+}
+
+func TestBinaryFloatingSemantics(t *testing.T) {
+	a64 := [2]float64{2, -3}
+	b64 := [2]float64{20, 30}
+	a32 := [4]float32{2, -3, 4, -5}
+	b32 := [4]float32{20, 30, -40, -50}
+	var got [384]byte
+	binaryFloatingSemantics(&got, &a64, &b64, &a32, &b32)
+
+	operation64 := func(operation, lane int) float64 {
+		a, b := a64[lane], b64[lane]
+		switch operation {
+		case 0:
+			return b + a
+		case 1:
+			return b - a
+		case 2:
+			return b * a
+		case 3:
+			return b / a
+		case 4:
+			if b > a {
+				return b
+			}
+			return a
+		default:
+			if b < a {
+				return b
+			}
+			return a
+		}
+	}
+	operation32 := func(operation, lane int) float32 {
+		a, b := a32[lane], b32[lane]
+		switch operation {
+		case 0:
+			return b + a
+		case 1:
+			return b - a
+		case 2:
+			return b * a
+		case 3:
+			return b / a
+		case 4:
+			if b > a {
+				return b
+			}
+			return a
+		default:
+			if b < a {
+				return b
+			}
+			return a
+		}
+	}
+	read64 := func(block, lane int) float64 {
+		return math.Float64frombits(binary.LittleEndian.Uint64(got[16*block+8*lane:]))
+	}
+	read32 := func(block, lane int) float32 {
+		return math.Float32frombits(binary.LittleEndian.Uint32(got[16*block+4*lane:]))
+	}
+	for operation := 0; operation < 6; operation++ {
+		for lane := 0; lane < 2; lane++ {
+			if value, want := read64(operation, lane), operation64(operation, lane); value != want {
+				t.Fatalf("packed f64 operation %d lane %d = %v, want %v", operation, lane, value, want)
+			}
+		}
+		for lane := 0; lane < 4; lane++ {
+			if value, want := read32(6+operation, lane), operation32(operation, lane); value != want {
+				t.Fatalf("packed f32 operation %d lane %d = %v, want %v", operation, lane, value, want)
+			}
+		}
+		for lane := 0; lane < 2; lane++ {
+			want := b64[lane]
+			if lane == 0 {
+				want = operation64(operation, 0)
+			}
+			if value := read64(12+operation, lane); value != want {
+				t.Fatalf("scalar f64 operation %d lane %d = %v, want %v", operation, lane, value, want)
+			}
+		}
+		for lane := 0; lane < 4; lane++ {
+			want := b32[lane]
+			if lane == 0 {
+				want = operation32(operation, 0)
+			}
+			if value := read32(18+operation, lane); value != want {
+				t.Fatalf("scalar f32 operation %d lane %d = %v, want %v", operation, lane, value, want)
+			}
+		}
+	}
+}
+
+func TestHorizontalFloatingSemantics(t *testing.T) {
+	a32 := [8]float32{1, 2, 3, 4, 5, 6, 7, 8}
+	b32 := [8]float32{10, 20, 30, 40, 50, 60, 70, 80}
+	a64 := [4]float64{1, 2, 3, 4}
+	b64 := [4]float64{10, 20, 30, 40}
+	var got [192]byte
+	horizontalFloatingSemantics(&got, &a32, &b32, &a64, &b64)
+
+	read32 := func(offset int) float32 {
+		return math.Float32frombits(binary.LittleEndian.Uint32(got[offset:]))
+	}
+	read64 := func(offset int) float64 {
+		return math.Float64frombits(binary.LittleEndian.Uint64(got[offset:]))
+	}
+	packed32 := [2][8]float32{
+		{30, 70, 3, 7, 110, 150, 11, 15},
+		{-10, -10, -1, -1, -10, -10, -1, -1},
+	}
+	for block, want := range packed32 {
+		for lane := range want {
+			if value := read32(32*block + 4*lane); value != want[lane] {
+				t.Fatalf("vector f32 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+	packed64 := [2][4]float64{{30, 3, 70, 7}, {-10, -1, -10, -1}}
+	for block, want := range packed64 {
+		for lane := range want {
+			if value := read64(64 + 32*block + 8*lane); value != want[lane] {
+				t.Fatalf("vector f64 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+	legacy32 := [2][4]float32{{30, 70, 3, 7}, {-10, -10, -1, -1}}
+	for block, want := range legacy32 {
+		for lane := range want {
+			if value := read32(128 + 16*block + 4*lane); value != want[lane] {
+				t.Fatalf("legacy f32 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+	legacy64 := [2][2]float64{{30, 3}, {-10, -1}}
+	for block, want := range legacy64 {
+		for lane := range want {
+			if value := read64(160 + 16*block + 8*lane); value != want[lane] {
+				t.Fatalf("legacy f64 block %d lane %d = %v, want %v", block, lane, value, want[lane])
+			}
+		}
+	}
+}
+
+func TestExpandedEcosystemVectorSemantics(t *testing.T) {
+	a := [16]byte{0x00, 0x7f, 0x80, 0xff, 0x34, 0x12, 0xfe, 0xff, 0x78, 0x56, 0x34, 0x12, 0x00, 0x00, 0x00, 0x80}
+	b := [16]byte{0xff, 0x80, 0x7f, 0x00, 0x78, 0x56, 0x02, 0x00, 0xef, 0xcd, 0xab, 0x90, 0xff, 0xff, 0xff, 0x7f}
+	var got, want [816]byte
+	expandedEcosystemVectors(&got, &a, &b)
+
+	for i := range a {
+		minU, maxU := a[i], a[i]
+		if b[i] < minU {
+			minU = b[i]
+		}
+		if b[i] > maxU {
+			maxU = b[i]
+		}
+		minS, maxS := int8(a[i]), int8(a[i])
+		if int8(b[i]) < minS {
+			minS = int8(b[i])
+		}
+		if int8(b[i]) > maxS {
+			maxS = int8(b[i])
+		}
+		want[i], want[16+i] = minU, byte(minS)
+		want[96+i], want[112+i] = maxU, byte(maxS)
+	}
+	for i := 0; i < 8; i++ {
+		av := binary.LittleEndian.Uint16(a[2*i:])
+		bv := binary.LittleEndian.Uint16(b[2*i:])
+		minU, maxU := av, av
+		if bv < minU {
+			minU = bv
+		}
+		if bv > maxU {
+			maxU = bv
+		}
+		minS, maxS := int16(av), int16(av)
+		if int16(bv) < minS {
+			minS = int16(bv)
+		}
+		if int16(bv) > maxS {
+			maxS = int16(bv)
+		}
+		binary.LittleEndian.PutUint16(want[32+2*i:], minU)
+		binary.LittleEndian.PutUint16(want[48+2*i:], uint16(minS))
+		binary.LittleEndian.PutUint16(want[128+2*i:], maxU)
+		binary.LittleEndian.PutUint16(want[144+2*i:], uint16(maxS))
+	}
+	for i := 0; i < 4; i++ {
+		av := binary.LittleEndian.Uint32(a[4*i:])
+		bv := binary.LittleEndian.Uint32(b[4*i:])
+		minU, maxU := av, av
+		if bv < minU {
+			minU = bv
+		}
+		if bv > maxU {
+			maxU = bv
+		}
+		minS, maxS := int32(av), int32(av)
+		if int32(bv) < minS {
+			minS = int32(bv)
+		}
+		if int32(bv) > maxS {
+			maxS = int32(bv)
+		}
+		binary.LittleEndian.PutUint32(want[64+4*i:], minU)
+		binary.LittleEndian.PutUint32(want[80+4*i:], uint32(minS))
+		binary.LittleEndian.PutUint32(want[160+4*i:], maxU)
+		binary.LittleEndian.PutUint32(want[176+4*i:], uint32(maxS))
+	}
+	for i := 0; i < 2; i++ {
+		binary.LittleEndian.PutUint64(want[192+8*i:], binary.LittleEndian.Uint64(a[8*i:])<<13)
+	}
+	binary.LittleEndian.PutUint64(want[224:], 0x0123456789abcdef)
+	binary.LittleEndian.PutUint64(want[232:], 0x0000000089abcdef)
+	binary.LittleEndian.PutUint32(want[240:], 0x89abcdef)
+	copy(want[256:264], a[:8])
+	for i := range a {
+		want[272+i] = byte((uint16(a[i]) + uint16(b[i]) + 1) >> 1)
+	}
+	for i := 0; i < 8; i++ {
+		av := binary.LittleEndian.Uint16(a[2*i:])
+		bv := binary.LittleEndian.Uint16(b[2*i:])
+		binary.LittleEndian.PutUint16(want[288+2*i:], uint16((uint32(av)+uint32(bv)+1)>>1))
+	}
+	for i := range a {
+		if int8(a[i]) > int8(b[i]) {
+			want[304+i] = 0xff
+		}
+	}
+	for i := 0; i < 8; i++ {
+		if int16(binary.LittleEndian.Uint16(a[2*i:])) > int16(binary.LittleEndian.Uint16(b[2*i:])) {
+			binary.LittleEndian.PutUint16(want[320+2*i:], 0xffff)
+		}
+	}
+	for i := 0; i < 4; i++ {
+		if int32(binary.LittleEndian.Uint32(a[4*i:])) > int32(binary.LittleEndian.Uint32(b[4*i:])) {
+			binary.LittleEndian.PutUint32(want[336+4*i:], 0xffffffff)
+		}
+	}
+	for i := 0; i < 2; i++ {
+		if int64(binary.LittleEndian.Uint64(a[8*i:])) > int64(binary.LittleEndian.Uint64(b[8*i:])) {
+			binary.LittleEndian.PutUint64(want[352+8*i:], ^uint64(0))
+		}
+	}
+	for i := 0; i < 8; i++ {
+		av := int16(binary.LittleEndian.Uint16(a[2*i:]))
+		binary.LittleEndian.PutUint16(want[368+2*i:], uint16(av>>3))
+		binary.LittleEndian.PutUint16(want[384+2*i:], uint16(av>>15))
+	}
+	for lane := 0; lane < 2; lane++ {
+		copy(want[400+lane*8:], a[lane*4:lane*4+4])
+		copy(want[404+lane*8:], b[lane*4:lane*4+4])
+		copy(want[416+lane*8:], a[8+lane*4:12+lane*4])
+		copy(want[420+lane*8:], b[8+lane*4:12+lane*4])
+	}
+	copy(want[432:440], a[0:8])
+	copy(want[440:448], b[0:8])
+	copy(want[448:456], a[8:16])
+	copy(want[456:464], b[8:16])
+	conversions := []struct{ inputBits, outputBits int }{{8, 16}, {8, 32}, {8, 64}, {16, 32}, {16, 64}, {32, 64}}
+	for index, conversion := range conversions {
+		lanes := 128 / conversion.outputBits
+		for lane := 0; lane < lanes; lane++ {
+			inputOffset := lane * conversion.inputBits / 8
+			outputOffset := 464 + index*16 + lane*conversion.outputBits/8
+			switch conversion.outputBits {
+			case 16:
+				binary.LittleEndian.PutUint16(want[outputOffset:], uint16(a[inputOffset]))
+			case 32:
+				value := uint32(a[inputOffset])
+				if conversion.inputBits == 16 {
+					value = uint32(binary.LittleEndian.Uint16(a[inputOffset:]))
+				}
+				binary.LittleEndian.PutUint32(want[outputOffset:], value)
+			case 64:
+				value := uint64(a[inputOffset])
+				if conversion.inputBits == 16 {
+					value = uint64(binary.LittleEndian.Uint16(a[inputOffset:]))
+				} else if conversion.inputBits == 32 {
+					value = uint64(binary.LittleEndian.Uint32(a[inputOffset:]))
+				}
+				binary.LittleEndian.PutUint64(want[outputOffset:], value)
+			}
+		}
+	}
+	clampWord := func(value int32) int16 {
+		if value < -32768 {
+			return -32768
+		}
+		if value > 32767 {
+			return 32767
+		}
+		return int16(value)
+	}
+	for pair := 0; pair < 2; pair++ {
+		a0 := binary.LittleEndian.Uint32(a[8*pair:])
+		a1 := binary.LittleEndian.Uint32(a[8*pair+4:])
+		b0 := binary.LittleEndian.Uint32(b[8*pair:])
+		b1 := binary.LittleEndian.Uint32(b[8*pair+4:])
+		binary.LittleEndian.PutUint32(want[560+4*pair:], a0+a1)
+		binary.LittleEndian.PutUint32(want[568+4*pair:], b0+b1)
+		binary.LittleEndian.PutUint32(want[608+4*pair:], a0-a1)
+		binary.LittleEndian.PutUint32(want[616+4*pair:], b0-b1)
+	}
+	for pair := 0; pair < 4; pair++ {
+		a0 := binary.LittleEndian.Uint16(a[4*pair:])
+		a1 := binary.LittleEndian.Uint16(a[4*pair+2:])
+		b0 := binary.LittleEndian.Uint16(b[4*pair:])
+		b1 := binary.LittleEndian.Uint16(b[4*pair+2:])
+		binary.LittleEndian.PutUint16(want[576+2*pair:], uint16(clampWord(int32(int16(a0))+int32(int16(a1)))))
+		binary.LittleEndian.PutUint16(want[584+2*pair:], uint16(clampWord(int32(int16(b0))+int32(int16(b1)))))
+		binary.LittleEndian.PutUint16(want[592+2*pair:], a0+a1)
+		binary.LittleEndian.PutUint16(want[600+2*pair:], b0+b1)
+		binary.LittleEndian.PutUint16(want[624+2*pair:], uint16(clampWord(int32(int16(a0))-int32(int16(a1)))))
+		binary.LittleEndian.PutUint16(want[632+2*pair:], uint16(clampWord(int32(int16(b0))-int32(int16(b1)))))
+		binary.LittleEndian.PutUint16(want[640+2*pair:], a0-a1)
+		binary.LittleEndian.PutUint16(want[648+2*pair:], b0-b1)
+	}
+	minimum, minimumIndex := uint16(0xffff), uint16(0)
+	for lane := 0; lane < 8; lane++ {
+		value := binary.LittleEndian.Uint16(a[2*lane:])
+		if value < minimum {
+			minimum, minimumIndex = value, uint16(lane)
+		}
+	}
+	binary.LittleEndian.PutUint16(want[656:], minimum)
+	binary.LittleEndian.PutUint16(want[658:], minimumIndex)
+	for block := 0; block < 2; block++ {
+		for lane := range a {
+			want[672+16*block+lane] = b[lane]
+			if int8(b[lane]) < 0 {
+				want[672+16*block+lane] = a[lane]
+			}
+		}
+	}
+	for lane := 0; lane < 8; lane++ {
+		value := binary.LittleEndian.Uint16(a[2*lane:])
+		binary.LittleEndian.PutUint16(want[704+2*lane:], value<<3)
+		binary.LittleEndian.PutUint16(want[752+2*lane:], value>>3)
+	}
+	for lane := 0; lane < 4; lane++ {
+		value := binary.LittleEndian.Uint32(a[4*lane:])
+		binary.LittleEndian.PutUint32(want[720+4*lane:], value<<3)
+		binary.LittleEndian.PutUint32(want[768+4*lane:], value>>3)
+	}
+	for lane := 0; lane < 2; lane++ {
+		value := binary.LittleEndian.Uint64(a[8*lane:])
+		binary.LittleEndian.PutUint64(want[736+8*lane:], value<<3)
+		binary.LittleEndian.PutUint64(want[784+8*lane:], value>>3)
+	}
+	binary.LittleEndian.PutUint64(want[800:], 3)
+	if got != want {
+		t.Fatalf("expandedEcosystemVectors() = %#v, want %#v", got, want)
+	}
+}
+
 func shld32(src, dst, count uint32) uint32 {
 	count &= 31
 	if count == 0 {
diff --git a/testdata/conformance/arm64/conformance.go b/testdata/conformance/arm64/conformance.go
index 98b17b0ed..00e2e91ef 100644
--- a/testdata/conformance/arm64/conformance.go
+++ b/testdata/conformance/arm64/conformance.go
@@ -4,6 +4,22 @@ package arm64conformance
 
 func families(out *[76]uint64, data *[8]uint64)
 
+func scalarFloatSquareRoots(out *[16]byte)
+
+func fusedMultiplyAddSemantics(out *[48]byte)
+
+func pairedAtomicSemantics(out *[23]uint64, data *[9]uint64)
+
+func vectorPermuteSemantics(out *[96]byte, n *[16]byte, m *[16]byte)
+
+func vectorWideningShiftSemantics(out *[128]byte, source *[16]byte)
+
+func scalarExtendSemantics(out *[10]uint64, value uint64)
+
+func vectorCountBitsSemantics(out *[32]byte, source *[16]byte)
+
+func unsignedWideningAddSemantics(out *[96]byte, narrow *[16]byte, addend *[16]byte)
+
 func pairStores(out *[20]uint64, data *[8]uint64)
 
 var pairStoreData [10]uint64
diff --git a/testdata/conformance/arm64/conformance_arm64.s b/testdata/conformance/arm64/conformance_arm64.s
index 331641f19..9a4425a3c 100644
--- a/testdata/conformance/arm64/conformance_arm64.s
+++ b/testdata/conformance/arm64/conformance_arm64.s
@@ -186,6 +186,243 @@ TEXT ·families(SB), NOSPLIT, $0-16
 	FMOVQ F4, 592(R0)
 	RET
 
+// scalarFloatSquareRoots covers scalar S/D constants, F-register copies,
+// F<->general-register bit moves, memory stores, and square roots.
+TEXT ·scalarFloatSquareRoots(SB), NOSPLIT, $0-8
+	MOVD out+0(FP), R0
+	FMOVS $(4.0), F0
+	FSQRTS F0, F1
+	FMOVS F1, 0(R0)
+	FMOVS F1, R1
+	FMOVS R1, F2
+	FMOVS F2, 4(R0)
+	FMOVD $(16.0), F3
+	FSQRTD F3, F4
+	FMOVD F4, 8(R0)
+	RET
+
+// fusedMultiplyAddSemantics distinguishes all four sign variants and both
+// scalar widths. In Go assembler order the operands are Fm, Fa, Fn, Fd.
+TEXT ·fusedMultiplyAddSemantics(SB), NOSPLIT, $0-8
+	MOVD out+0(FP), R0
+	FMOVS $(2.0), F0
+	FMOVS $(5.0), F1
+	FMOVS $(3.0), F2
+	FMADDS F0, F1, F2, F3
+	FMSUBS F0, F1, F2, F4
+	FNMADDS F0, F1, F2, F5
+	FNMSUBS F0, F1, F2, F6
+	FMOVS F3, 0(R0)
+	FMOVS F4, 4(R0)
+	FMOVS F5, 8(R0)
+	FMOVS F6, 12(R0)
+
+	FMOVD $(2.0), F10
+	FMOVD $(5.0), F11
+	FMOVD $(3.0), F12
+	FMADDD F10, F11, F12, F13
+	FMSUBD F10, F11, F12, F14
+	FNMADDD F10, F11, F12, F15
+	FNMSUBD F10, F11, F12, F16
+	FMOVD F13, 16(R0)
+	FMOVD F14, 24(R0)
+	FMOVD F15, 32(R0)
+	FMOVD F16, 40(R0)
+	RET
+
+// vectorPermuteSemantics fixes the Plan 9 Vm,Vn,Vd operand order and all six
+// ZIP/UZP/TRN lane-selection variants with distinguishable byte inputs.
+TEXT ·vectorPermuteSemantics(SB), NOSPLIT, $0-24
+	MOVD out+0(FP), R0
+	MOVD n+8(FP), R1
+	MOVD m+16(FP), R2
+	FMOVQ (R1), F0
+	FMOVQ (R2), F1
+	VZIP1 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 0(R0)
+	VZIP2 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 16(R0)
+	VUZP1 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 32(R0)
+	VUZP2 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 48(R0)
+	VTRN1 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 64(R0)
+	VTRN2 V1.B16, V0.B16, V2.B16
+	FMOVQ F2, 80(R0)
+	RET
+
+// vectorWideningShiftSemantics distinguishes signed/unsigned extension,
+// low/high source halves, and the immediate-shift forms of the family.
+TEXT ·vectorWideningShiftSemantics(SB), NOSPLIT, $0-16
+	MOVD out+0(FP), R0
+	MOVD source+8(FP), R1
+	FMOVQ (R1), F0
+	VUXTL V0.B8, V1.H8
+	FMOVQ F1, 0(R0)
+	VUXTL2 V0.B16, V1.H8
+	FMOVQ F1, 16(R0)
+	VSXTL V0.B8, V1.H8
+	FMOVQ F1, 32(R0)
+	VSXTL2 V0.B16, V1.H8
+	FMOVQ F1, 48(R0)
+	VUSHLL $7, V0.B8, V1.H8
+	FMOVQ F1, 64(R0)
+	VUSHLL2 $1, V0.B16, V1.H8
+	FMOVQ F1, 80(R0)
+	VSSHLL $3, V0.B8, V1.H8
+	FMOVQ F1, 96(R0)
+	VSSHLL2 $2, V0.B16, V1.H8
+	FMOVQ F1, 112(R0)
+	RET
+
+// scalarExtendSemantics distinguishes 64-bit and W-register destinations for
+// every signed and unsigned scalar extend mnemonic in Go's shared optab row.
+TEXT ·scalarExtendSemantics(SB), NOSPLIT, $0-16
+	MOVD out+0(FP), R0
+	MOVD value+8(FP), R1
+	SXTB R1, R2
+	MOVD R2, 0(R0)
+	SXTBW R1, R2
+	MOVD R2, 8(R0)
+	SXTH R1, R2
+	MOVD R2, 16(R0)
+	SXTHW R1, R2
+	MOVD R2, 24(R0)
+	SXTW R1, R2
+	MOVD R2, 32(R0)
+	UXTB R1, R2
+	MOVD R2, 40(R0)
+	UXTBW R1, R2
+	MOVD R2, 48(R0)
+	UXTH R1, R2
+	MOVD R2, 56(R0)
+	UXTHW R1, R2
+	MOVD R2, 64(R0)
+	UXTW R1, R2
+	MOVD R2, 72(R0)
+	RET
+
+TEXT ·vectorCountBitsSemantics(SB), NOSPLIT, $0-16
+	MOVD out+0(FP), R0
+	MOVD source+8(FP), R1
+	FMOVQ (R1), F0
+	VCNT V0.B8, V1.B8
+	FMOVQ F1, 0(R0)
+	VCNT V0.B16, V1.B16
+	FMOVQ F1, 16(R0)
+	RET
+
+TEXT ·unsignedWideningAddSemantics(SB), NOSPLIT, $0-24
+	MOVD out+0(FP), R0
+	MOVD narrow+8(FP), R1
+	MOVD addend+16(FP), R2
+	FMOVQ (R1), F0
+	FMOVQ (R2), F1
+	VUADDW V0.B8, V1.H8, V2.H8
+	FMOVQ F2, 0(R0)
+	VUADDW V0.H4, V1.S4, V2.S4
+	FMOVQ F2, 16(R0)
+	VUADDW V0.S2, V1.D2, V2.D2
+	FMOVQ F2, 32(R0)
+	VUADDW2 V0.B16, V1.H8, V2.H8
+	FMOVQ F2, 48(R0)
+	VUADDW2 V0.H8, V1.S4, V2.S4
+	FMOVQ F2, 64(R0)
+	VUADDW2 V0.S4, V1.D2, V2.D2
+	FMOVQ F2, 80(R0)
+	RET
+
+// pairedAtomicSemantics exercises success and failure paths for both CASP
+// widths and for the load-exclusive/store-exclusive pair family.
+TEXT ·pairedAtomicSemantics(SB), NOSPLIT, $0-16
+	MOVD out+0(FP), R0
+	MOVD data+8(FP), R1
+
+	// CASPD success: compare registers receive the old memory pair and the
+	// destination pair is installed.
+	MOVD $0x11, R2
+	MOVD $0x22, R3
+	MOVD $0xaa, R4
+	MOVD $0xbb, R5
+	MOVD R1, R6
+	CASPD (R2, R3), (R6), (R4, R5)
+	MOVD R2, 0(R0)
+	MOVD R3, 8(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 16(R0)
+	MOVD 8(R6), R8
+	MOVD R8, 24(R0)
+
+	// CASPD failure: memory is unchanged and the compare pair receives its
+	// actual contents.
+	MOVD $0x99, R2
+	MOVD $0x88, R3
+	MOVD $0xcc, R4
+	MOVD $0xdd, R5
+	ADD $16, R1, R6
+	CASPD (R2, R3), (R6), (R4, R5)
+	MOVD R2, 32(R0)
+	MOVD R3, 40(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 48(R0)
+	MOVD 8(R6), R8
+	MOVD R8, 56(R0)
+
+	// CASPW compares the low 32 bits of each register and zero-extends the
+	// loaded pair back into the compare registers.
+	MOVD $0xffffffff00000011, R2
+	MOVD $0xeeeeeeee00000022, R3
+	MOVD $0xdddddddd000000aa, R4
+	MOVD $0xcccccccc000000bb, R5
+	ADD $32, R1, R6
+	CASPW (R2, R3), (R6), (R4, R5)
+	MOVD R2, 64(R0)
+	MOVD R3, 72(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 80(R0)
+
+	MOVD $0xffffffff00000099, R2
+	MOVD $0xeeeeeeee00000088, R3
+	MOVD $0xdddddddd000000cc, R4
+	MOVD $0xcccccccc000000dd, R5
+	ADD $40, R1, R6
+	CASPW (R2, R3), (R6), (R4, R5)
+	MOVD R2, 88(R0)
+	MOVD R3, 96(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 104(R0)
+
+	// A matching LDXP/STXP reservation succeeds.
+	ADD $48, R1, R6
+	LDXP (R6), (R2, R3)
+	MOVD R2, 112(R0)
+	MOVD R3, 120(R0)
+	MOVD $0xcc, R4
+	MOVD $0xdd, R5
+	STXP (R4, R5), (R6), R7
+	MOVD R7, 128(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 136(R0)
+	MOVD 8(R6), R8
+	MOVD R8, 144(R0)
+
+	// An intervening store invalidates an LDAXPW reservation, so STLXPW
+	// reports failure and leaves the intervening value in memory.
+	ADD $64, R1, R6
+	LDAXPW (R6), (R2, R3)
+	MOVD R2, 152(R0)
+	MOVD R3, 160(R0)
+	MOVD $0x000000aa00000099, R8
+	MOVD R8, 0(R6)
+	MOVD $0xcc, R4
+	MOVD $0xdd, R5
+	STLXPW (R4, R5), (R6), R7
+	MOVD R7, 168(R0)
+	MOVD 0(R6), R8
+	MOVD R8, 176(R0)
+	RET
+
 // Check full-width stores, offsets, and both writeback modes.
 TEXT ·pairStores(SB), NOSPLIT, $0-16
 	MOVD out+0(FP), R0
diff --git a/testdata/conformance/arm64/conformance_test.go b/testdata/conformance/arm64/conformance_test.go
index f63d4054e..e5972f4ee 100644
--- a/testdata/conformance/arm64/conformance_test.go
+++ b/testdata/conformance/arm64/conformance_test.go
@@ -3,8 +3,11 @@
 package arm64conformance
 
 import (
+	"encoding/binary"
+	"math"
 	"math/bits"
 	"testing"
+	"unsafe"
 )
 
 func TestFamilies(t *testing.T) {
@@ -19,6 +22,207 @@ func TestFamilies(t *testing.T) {
 	}
 }
 
+func TestScalarFloatSquareRoots(t *testing.T) {
+	var got [16]byte
+	scalarFloatSquareRoots(&got)
+	if value := math.Float32frombits(binary.LittleEndian.Uint32(got[0:4])); value != 2 {
+		t.Fatalf("FSQRTS/FMOVS result = %v, want 2", value)
+	}
+	if value := math.Float32frombits(binary.LittleEndian.Uint32(got[4:8])); value != 2 {
+		t.Fatalf("FMOVS F<->R result = %v, want 2", value)
+	}
+	if value := math.Float64frombits(binary.LittleEndian.Uint64(got[8:16])); value != 4 {
+		t.Fatalf("FSQRTD/FMOVD result = %v, want 4", value)
+	}
+}
+
+func TestFusedMultiplyAddSemantics(t *testing.T) {
+	var got [48]byte
+	fusedMultiplyAddSemantics(&got)
+	want32 := [...]float32{11, -1, -11, 1}
+	for i, want := range want32 {
+		value := math.Float32frombits(binary.LittleEndian.Uint32(got[i*4 : i*4+4]))
+		if value != want {
+			t.Fatalf("fusedMultiplyAddSemantics() float32[%d] = %v, want %v", i, value, want)
+		}
+	}
+	want64 := [...]float64{11, -1, -11, 1}
+	for i, want := range want64 {
+		value := math.Float64frombits(binary.LittleEndian.Uint64(got[16+i*8 : 24+i*8]))
+		if value != want {
+			t.Fatalf("fusedMultiplyAddSemantics() float64[%d] = %v, want %v", i, value, want)
+		}
+	}
+}
+
+func TestVectorPermuteSemantics(t *testing.T) {
+	var n, m [16]byte
+	for i := range n {
+		n[i] = byte(i)
+		m[i] = byte(0x80 + i)
+	}
+	var got [96]byte
+	vectorPermuteSemantics(&got, &n, &m)
+	want := vectorPermuteOracle(n, m)
+	if got != want {
+		t.Fatalf("vectorPermuteSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func vectorPermuteOracle(n, m [16]byte) (out [96]byte) {
+	for i := 0; i < 8; i++ {
+		out[2*i], out[2*i+1] = n[i], m[i]
+		out[16+2*i], out[16+2*i+1] = n[8+i], m[8+i]
+		out[32+i], out[32+8+i] = n[2*i], m[2*i]
+		out[48+i], out[48+8+i] = n[2*i+1], m[2*i+1]
+		out[64+2*i], out[64+2*i+1] = n[2*i], m[2*i]
+		out[80+2*i], out[80+2*i+1] = n[2*i+1], m[2*i+1]
+	}
+	return out
+}
+
+func TestVectorWideningShiftSemantics(t *testing.T) {
+	source := [16]byte{0, 1, 0x7f, 0x80, 0xff, 2, 0x55, 0xaa, 3, 4, 0x40, 0xc0, 0xfe, 0x81, 0x11, 0xee}
+	var got [128]byte
+	vectorWideningShiftSemantics(&got, &source)
+	want := vectorWideningShiftOracle(source)
+	if got != want {
+		t.Fatalf("vectorWideningShiftSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func vectorWideningShiftOracle(source [16]byte) (out [128]byte) {
+	for lane := 0; lane < 8; lane++ {
+		low, high := uint16(source[lane]), uint16(source[8+lane])
+		signedLow, signedHigh := uint16(int16(int8(source[lane]))), uint16(int16(int8(source[8+lane])))
+		values := [...]uint16{
+			low, high, signedLow, signedHigh,
+			low << 7, high << 1, signedLow << 3, signedHigh << 2,
+		}
+		for group, value := range values {
+			binary.LittleEndian.PutUint16(out[group*16+lane*2:], value)
+		}
+	}
+	return out
+}
+
+func TestScalarExtendSemantics(t *testing.T) {
+	value := uint64(0x88776655fedcba98)
+	var got [10]uint64
+	scalarExtendSemantics(&got, value)
+	want := [10]uint64{
+		uint64(int64(int8(value))),
+		uint64(uint32(int32(int8(value)))),
+		uint64(int64(int16(value))),
+		uint64(uint32(int32(int16(value)))),
+		uint64(int64(int32(value))),
+		uint64(uint8(value)),
+		uint64(uint32(uint8(value))),
+		uint64(uint16(value)),
+		uint64(uint32(uint16(value))),
+		uint64(uint32(value)),
+	}
+	if got != want {
+		t.Fatalf("scalarExtendSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func TestVectorCountBitsSemantics(t *testing.T) {
+	source := [16]byte{0, 1, 2, 3, 7, 15, 31, 63, 127, 128, 129, 0xaa, 0x55, 0xfe, 0xff, 0x81}
+	var got, want [32]byte
+	vectorCountBitsSemantics(&got, &source)
+	for i, value := range source {
+		want[16+i] = byte(bits.OnesCount8(value))
+		if i < 8 {
+			want[i] = want[16+i]
+		}
+	}
+	if got != want {
+		t.Fatalf("vectorCountBitsSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func TestUnsignedWideningAddSemantics(t *testing.T) {
+	narrow := [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 0xf1, 0xe2, 0xd3, 0xc4, 0xb5, 0xa6, 0x97, 0x88}
+	addend := [16]byte{0xff, 0x00, 0xfe, 0xff, 0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12}
+	var got, want [96]byte
+	unsignedWideningAddSemantics(&got, &narrow, &addend)
+	for group, narrowBytes := range []int{1, 2, 4, 1, 2, 4} {
+		wideBytes := narrowBytes * 2
+		lanes := 16 / wideBytes
+		sourceOffset := 0
+		if group >= 3 {
+			sourceOffset = 8
+		}
+		for lane := 0; lane < lanes; lane++ {
+			narrowValue := readLittleEndianWidth(narrow[sourceOffset+lane*narrowBytes:], narrowBytes)
+			addendValue := readLittleEndianWidth(addend[lane*wideBytes:], wideBytes)
+			writeLittleEndianWidth(want[group*16+lane*wideBytes:], wideBytes, addendValue+narrowValue)
+		}
+	}
+	if got != want {
+		t.Fatalf("unsignedWideningAddSemantics() = %#v, want %#v", got, want)
+	}
+}
+
+func readLittleEndianWidth(data []byte, width int) uint64 {
+	switch width {
+	case 1:
+		return uint64(data[0])
+	case 2:
+		return uint64(binary.LittleEndian.Uint16(data))
+	case 4:
+		return uint64(binary.LittleEndian.Uint32(data))
+	case 8:
+		return binary.LittleEndian.Uint64(data)
+	default:
+		panic("invalid integer width")
+	}
+}
+
+func writeLittleEndianWidth(data []byte, width int, value uint64) {
+	switch width {
+	case 2:
+		binary.LittleEndian.PutUint16(data, uint16(value))
+	case 4:
+		binary.LittleEndian.PutUint32(data, uint32(value))
+	case 8:
+		binary.LittleEndian.PutUint64(data, value)
+	default:
+		panic("invalid integer width")
+	}
+}
+
+func TestPairedAtomicSemantics(t *testing.T) {
+	var storage [11]uint64
+	start := 0
+	if uintptr(unsafe.Pointer(&storage[0]))%16 != 0 {
+		start = 1
+	}
+	data := (*[9]uint64)(unsafe.Pointer(&storage[start]))
+	*data = [9]uint64{
+		0x11, 0x22,
+		0x33, 0x44,
+		0x0000002200000011,
+		0x0000004400000033,
+		0x55, 0x66,
+		0x0000008800000077,
+	}
+	var got [23]uint64
+	pairedAtomicSemantics(&got, data)
+	want := [23]uint64{
+		0x11, 0x22, 0xaa, 0xbb,
+		0x33, 0x44, 0x33, 0x44,
+		0x11, 0x22, 0x000000bb000000aa,
+		0x33, 0x44, 0x0000004400000033,
+		0x55, 0x66, 0, 0xcc, 0xdd,
+		0x77, 0x88, 1, 0x000000aa00000099,
+	}
+	if got != want {
+		t.Fatalf("pairedAtomicSemantics() = %#v, want %#v", got, want)
+	}
+}
+
 func familyOracle(data [8]uint64) (out [76]uint64) {
 	src, dst := data[0], data[1]
 	out[0] = insert(dst, src, 8, 16, 0)
diff --git a/testdata/conformance/manifest.json b/testdata/conformance/manifest.json
index a51f46e18..ac04d4977 100644
--- a/testdata/conformance/manifest.json
+++ b/testdata/conformance/manifest.json
@@ -103,6 +103,30 @@
         "PSRAL immediate,xmm"
       ]
     },
+    {
+      "id": "amd64-expanded-ecosystem-vector-families",
+      "goarch": "amd64",
+      "asm": "amd64/conformance_amd64.s",
+      "validation": "execute",
+      "forms": [
+        "VMOVQ gpr64,xmm",
+        "VMOVQ xmm,gpr64",
+        "PSLLQ immediate,xmm",
+        "PSRLQ immediate,xmm",
+        "PMINUB memory.gpr64-base,xmm",
+        "PMINSB memory.gpr64-base,xmm",
+        "PMINUW memory.gpr64-base,xmm",
+        "PMINSW memory.gpr64-base,xmm",
+        "PMINUD memory.gpr64-base,xmm",
+        "PMINSD memory.gpr64-base,xmm",
+        "PMAXUB memory.gpr64-base,xmm",
+        "PMAXSB memory.gpr64-base,xmm",
+        "PMAXUW memory.gpr64-base,xmm",
+        "PMAXSW memory.gpr64-base,xmm",
+        "PMAXUD memory.gpr64-base,xmm",
+        "PMAXSD memory.gpr64-base,xmm"
+      ]
+    },
     {
       "id": "arm64-go-assembler-scalar-families",
       "goarch": "arm64",
diff --git a/testdata/corpus/go.mod b/testdata/corpus/go.mod
deleted file mode 100644
index afeb8c693..000000000
--- a/testdata/corpus/go.mod
+++ /dev/null
@@ -1,33 +0,0 @@
-module github.com/xgo-dev/plan9asm/testdata/corpus
-
-go 1.26.0
-
-require (
-	github.com/RoaringBitmap/roaring v1.9.4
-	github.com/anacrolix/mmsg v1.1.1
-	github.com/btcsuite/fastsha256 v0.0.0-20160815193821-637e65642941
-	github.com/cespare/xxhash v1.1.0
-	github.com/cespare/xxhash/v2 v2.3.0
-	github.com/coder/websocket v1.8.15
-	github.com/dchest/siphash v1.2.3
-	github.com/dgryski/go-bits v0.0.0-20180113010104-bd8a69a71dc2
-	github.com/dgryski/go-marvin32 v0.0.0-20240117220238-0d39e8c5a8a9
-	github.com/golang/snappy v1.0.0
-	github.com/klauspost/compress v1.20.1
-	github.com/klauspost/cpuid v1.3.1
-	github.com/klauspost/cpuid/v2 v2.4.0
-	github.com/klauspost/reedsolomon v1.14.2
-	github.com/minio/highwayhash v1.0.4
-	github.com/modern-go/gls v0.0.0-20250215024828-78308f6bb19d
-	github.com/pierrec/lz4/v4 v4.1.33
-	github.com/stevvooe/resumable v0.0.0-20180830230917-22b14a53ba50
-	github.com/tmthrgd/go-bitwise v0.0.0-20190904053232-1430ee983fca
-	github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc
-	github.com/tmthrgd/go-popcount v0.0.0-20190904054823-afb1ace8b04f
-	github.com/zeebo/this v1.0.0
-	golang.org/x/arch v0.31.0
-	golang.org/x/net v0.59.0
-	golang.org/x/sys v0.48.0
-)
-
-require github.com/modern-go/reflect2 v1.0.2 // indirect
diff --git a/testdata/corpus/go.sum b/testdata/corpus/go.sum
deleted file mode 100644
index ac4018eb1..000000000
--- a/testdata/corpus/go.sum
+++ /dev/null
@@ -1,88 +0,0 @@
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/RoaringBitmap/roaring v1.9.4 h1:yhEIoH4YezLYT04s1nHehNO64EKFTop/wBhxv2QzDdQ=
-github.com/RoaringBitmap/roaring v1.9.4/go.mod h1:6AXUsoIEzDTFFQCe1RbGA6uFONMhvejWj5rqITANK90=
-github.com/anacrolix/mmsg v1.1.1 h1:4ce/3I5kM7qSF6T5A8MOmDCfac3UqYlk5Bzh5XsWebM=
-github.com/anacrolix/mmsg v1.1.1/go.mod h1:lPCXEN1eDDQtKktdKEzdw+roswx6wWPpeXAl/WpWVDU=
-github.com/bits-and-blooms/bitset v1.12.0 h1:U/q1fAF7xXRhFCrhROzIfffYnu+dlS38vCZtmFVPHmA=
-github.com/bits-and-blooms/bitset v1.12.0/go.mod h1:7hO7Gc7Pp1vODcmWvKMRA9BNmbv6a/7QIWpPxHddWR8=
-github.com/btcsuite/fastsha256 v0.0.0-20160815193821-637e65642941 h1:kij1x2aL7VE6gtx8KMIt8PGPgI5GV9LgtHFG5KaEMPY=
-github.com/btcsuite/fastsha256 v0.0.0-20160815193821-637e65642941/go.mod h1:QcFA8DZHtuIAdYKCq/BzELOaznRsCvwf4zTPmaYwaig=
-github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/coder/websocket v1.8.15 h1:6B2JPeOGlpff2Uz6vOEH1Vzpi0iUz20A+lPVhPHtNUA=
-github.com/coder/websocket v1.8.15/go.mod h1:NX3SzP+inril6yawo5CQXx8+fk145lPDC6pumgx0mVg=
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dchest/siphash v1.2.3 h1:QXwFc8cFOR2dSa/gE6o/HokBMWtLUaNDVd+22aKHeEA=
-github.com/dchest/siphash v1.2.3/go.mod h1:0NvQU092bT0ipiFN++/rXm69QG9tVxLAlQHIXMPAkHc=
-github.com/dgryski/go-bits v0.0.0-20180113010104-bd8a69a71dc2 h1:2+yip7nN/auel0PDwY7SIaTOxQPI2NwdkZkvpgtc3Pk=
-github.com/dgryski/go-bits v0.0.0-20180113010104-bd8a69a71dc2/go.mod h1:/9UYwwvZuEgp+mQ4960SHWCU1FS+FgdFX+m5ExFByNs=
-github.com/dgryski/go-marvin32 v0.0.0-20240117220238-0d39e8c5a8a9 h1:KOgsh3nPHIgGUJe+oJ5NhC8GpgHiWDd7PagBmerkxOw=
-github.com/dgryski/go-marvin32 v0.0.0-20240117220238-0d39e8c5a8a9/go.mod h1:jqLmu3zlC7A21QyKV/jo2F3W0IvHEAj00ZooZH+Y7jY=
-github.com/golang/snappy v1.0.0 h1:Oy607GVXHs7RtbggtPBnr2RmDArIsAefDwvrdWvRhGs=
-github.com/golang/snappy v1.0.0/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
-github.com/klauspost/compress v1.20.0 h1:a3C1ke2ohxFymNlb2HWAHjDeKCI90scRskErZkR0ezA=
-github.com/klauspost/compress v1.20.0/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
-github.com/klauspost/compress v1.20.1 h1:T7kKElXUMXrUJ2E9QhQhxFtcK5rPyLdsGZvdbLMPdiQ=
-github.com/klauspost/compress v1.20.1/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=
-github.com/klauspost/cpuid v1.3.1 h1:5JNjFYYQrZeKRJ0734q51WCEEn2huer72Dc7K+R/b6s=
-github.com/klauspost/cpuid v1.3.1/go.mod h1:bYW4mA6ZgKPob1/Dlai2LviZJO7KGI3uoWLd42rAQw4=
-github.com/klauspost/cpuid/v2 v2.4.0 h1:S6Hrbc7+ywsr0r+RLapfGBHfyefhCTwEh3A0tV913Dw=
-github.com/klauspost/cpuid/v2 v2.4.0/go.mod h1:19jmZ9mjzoF//ddRSUsv0zfBTJWh3QJh9FNxZTMrGxU=
-github.com/klauspost/reedsolomon v1.14.2 h1:SafJYwpBBQBI6amHUygcjxZjXeN2HpiENHQDwuPWCCQ=
-github.com/klauspost/reedsolomon v1.14.2/go.mod h1:yjqqjgMTQkBUHSG97/rm4zipffCNbCiZcB3kTqr++sQ=
-github.com/minio/highwayhash v1.0.4 h1:asJizugGgchQod2ja9NJlGOWq4s7KsAWr5XUc9Clgl4=
-github.com/minio/highwayhash v1.0.4/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
-github.com/modern-go/gls v0.0.0-20250215024828-78308f6bb19d h1:e3xdlObtriVu9HlrOfYB8Nmy51+DuJy5Hcgsg+x7ixg=
-github.com/modern-go/gls v0.0.0-20250215024828-78308f6bb19d/go.mod h1:I8AX+yW//L8Hshx6+a1m3bYkwXkpsVjA2795vP4f4oQ=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-github.com/mschoch/smat v0.2.0 h1:8imxQsjDm8yFEAVBe7azKmKSgzSkZXDuKkSq9374khM=
-github.com/mschoch/smat v0.2.0/go.mod h1:kc9mz7DoBKqDyiRL7VZN8KvXQMWeTaVnttLRXOlotKw=
-github.com/pierrec/lz4/v4 v4.1.29 h1:CDQY6qZOLI4DW0Nx6R1vRrifrCeQHnNXkMb0hZWXFjg=
-github.com/pierrec/lz4/v4 v4.1.29/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
-github.com/pierrec/lz4/v4 v4.1.30 h1:cchX8N2DVP668WkElI9QMwVyoNabLkq1LofDHFeIrdg=
-github.com/pierrec/lz4/v4 v4.1.30/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
-github.com/pierrec/lz4/v4 v4.1.33 h1:GjG1TJ1V4IzKP8L96muuuDNpTwd7D+l2ccXrjAbe014=
-github.com/pierrec/lz4/v4 v4.1.33/go.mod h1:7SE9MC2STkNtL4PIwGhjmyVwvILaGI9/COYQNBhKM/c=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/stevvooe/resumable v0.0.0-20180830230917-22b14a53ba50 h1:4bT0pPowCpQImewr+BjzfUKcuFW+KVyB8d1OF3b6oTI=
-github.com/stevvooe/resumable v0.0.0-20180830230917-22b14a53ba50/go.mod h1:1pdIZTAHUz+HDKDVZ++5xg/duPlhKAIzw9qy42CWYp4=
-github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/tmthrgd/go-bitwise v0.0.0-20190904053232-1430ee983fca h1:Ns4/7EvYZ7FxKiKnEMkMMAPtoR/ifUgRsvk7lzlOtPY=
-github.com/tmthrgd/go-bitwise v0.0.0-20190904053232-1430ee983fca/go.mod h1:Ba4ek/h+sJUzTQ03ZGD1r0lazhxd7CBoEQzFk/icxxU=
-github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc h1:9lRDQMhESg+zvGYmW5DyG0UqvY96Bu5QYsTLvCHdrgo=
-github.com/tmthrgd/go-hex v0.0.0-20190904060850-447a3041c3bc/go.mod h1:bciPuU6GHm1iF1pBvUfxfsH0Wmnc2VbpgvbI9ZWuIRs=
-github.com/tmthrgd/go-popcount v0.0.0-20190904054823-afb1ace8b04f h1:Phf2p9+twoHct5ZjSTrI8K7iWeSxO4x1p5pShTl0J00=
-github.com/tmthrgd/go-popcount v0.0.0-20190904054823-afb1ace8b04f/go.mod h1:FcUQfrsAsSSqM3n9xf4EtPzB8tWzt58/y0AV+wNNM8Q=
-github.com/zeebo/assert v0.0.0-20181109011804-10f827ce2ed6/go.mod h1:yssERNPivllc1yU3BvpjYI5BUW+zglcz6QWqeVRL5t0=
-github.com/zeebo/this v1.0.0 h1:vUoO1kFs0WMV1oPN5pJbCfvjaL3NxlD7jBurRYKsrE0=
-github.com/zeebo/this v1.0.0/go.mod h1:NamLT9fyihYiE0UyxEpmBm0IYbT+QWThFzOPalRS21o=
-golang.org/x/arch v0.31.0 h1:22MlEb14/O/EPCYHFxsDdv5TuLD5dMjT5e2QeJw4ULk=
-golang.org/x/arch v0.31.0/go.mod h1:KcJSod3cqT2dKcjBxqTyGfbumNikqU9p5tHJinPJnuY=
-golang.org/x/crypto v0.57.0 h1:3ZVCjf8Ggz7zneR/EHRVx68Ctf+2pmIMP2UFhh9cC6M=
-golang.org/x/crypto v0.57.0/go.mod h1:Fdz0i5U6CoizGwLda9DttjSk6qlZo25zYNtR+ycvuZA=
-golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues=
-golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
-golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo=
-golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og=
-golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE=
-golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc=
-golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI=
-golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-rsc.io/pdf v0.1.1 h1:k1MczvYDUvJBe93bYd7wrZLLUEcLZAuF824/I4e5Xr4=
-rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
diff --git a/testdata/corpus/reported-libraries.json b/testdata/corpus/reported-libraries.json
deleted file mode 100644
index a9ac2484f..000000000
--- a/testdata/corpus/reported-libraries.json
+++ /dev/null
@@ -1,797 +0,0 @@
-{
-  "schema_version": 1,
-  "targets": [
-    "darwin/amd64",
-    "darwin/arm64",
-    "linux/386",
-    "linux/amd64",
-    "linux/arm",
-    "linux/arm64",
-    "windows/386",
-    "windows/amd64",
-    "windows/arm64",
-    "js/wasm",
-    "wasip1/wasm"
-  ],
-  "libraries": [
-    {
-      "id": "coder-websocket",
-      "origin": "llgo-issue",
-      "issues": [
-        "https://github.com/xgo-dev/llgo/issues/2464"
-      ],
-      "module": "github.com/coder/websocket",
-      "version": "v1.8.15",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        },
-        "darwin/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        },
-        "linux/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/coder/websocket"]
-        }
-      }
-    },
-    {
-      "id": "klauspost-compress",
-      "origin": "llgo-issue",
-      "issues": [
-        "https://github.com/xgo-dev/llgo/issues/2552"
-      ],
-      "module": "github.com/klauspost/compress",
-      "version": "v1.20.1",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 8,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/internal/cpuinfo",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        },
-        "darwin/arm64": {
-          "asm_files": 6,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        },
-        "linux/amd64": {
-          "asm_files": 8,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/internal/cpuinfo",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        },
-        "linux/arm64": {
-          "asm_files": 6,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        },
-        "windows/amd64": {
-          "asm_files": 8,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/internal/cpuinfo",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        },
-        "windows/arm64": {
-          "asm_files": 6,
-          "packages": [
-            "github.com/klauspost/compress/huff0",
-            "github.com/klauspost/compress/s2",
-            "github.com/klauspost/compress/zstd",
-            "github.com/klauspost/compress/zstd/internal/xxhash"
-          ]
-        }
-      }
-    },
-    {
-      "id": "go-hex",
-      "origin": "llgo-issue",
-      "issues": [
-        "https://github.com/xgo-dev/llgo/issues/2576"
-      ],
-      "module": "github.com/tmthrgd/go-hex",
-      "version": "v0.0.0-20190904060850-447a3041c3bc",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-hex"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-hex"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-hex"]
-        }
-      }
-    },
-    {
-      "id": "roaring-bitmap",
-      "origin": "ecosystem-scan",
-      "module": "github.com/RoaringBitmap/roaring",
-      "version": "v1.9.4",
-      "inventory": {
-        "darwin/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/RoaringBitmap/roaring"]
-        },
-        "linux/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/RoaringBitmap/roaring"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/RoaringBitmap/roaring"]
-        }
-      }
-    },
-    {
-      "id": "btcsuite-fastsha256",
-      "origin": "ecosystem-scan",
-      "module": "github.com/btcsuite/fastsha256",
-      "version": "v0.0.0-20160815193821-637e65642941",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/btcsuite/fastsha256"]
-        },
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/btcsuite/fastsha256"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/btcsuite/fastsha256"]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["github.com/btcsuite/fastsha256"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/btcsuite/fastsha256"]
-        }
-      }
-    },
-    {
-      "id": "dchest-siphash",
-      "origin": "ecosystem-scan",
-      "module": "github.com/dchest/siphash",
-      "version": "v1.2.3",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dchest/siphash"]
-        },
-        "linux/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dchest/siphash"]
-        },
-        "linux/arm": {
-          "asm_files": 1,
-          "packages": ["github.com/dchest/siphash"]
-        },
-        "windows/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dchest/siphash"]
-        }
-      }
-    },
-    {
-      "id": "dgryski-go-bits",
-      "origin": "ecosystem-scan",
-      "module": "github.com/dgryski/go-bits",
-      "version": "v0.0.0-20180113010104-bd8a69a71dc2",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dgryski/go-bits"]
-        },
-        "linux/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dgryski/go-bits"]
-        },
-        "windows/amd64": {
-          "asm_files": 3,
-          "packages": ["github.com/dgryski/go-bits"]
-        }
-      }
-    },
-    {
-      "id": "dgryski-go-marvin32",
-      "origin": "ecosystem-scan",
-      "module": "github.com/dgryski/go-marvin32",
-      "version": "v0.0.0-20240117220238-0d39e8c5a8a9",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/dgryski/go-marvin32"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/dgryski/go-marvin32"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/dgryski/go-marvin32"]
-        }
-      }
-    },
-    {
-      "id": "cespare-xxhash-v2",
-      "origin": "ecosystem-scan",
-      "module": "github.com/cespare/xxhash/v2",
-      "version": "v2.3.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        },
-        "darwin/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        },
-        "linux/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash/v2"]
-        }
-      }
-    },
-    {
-      "id": "klauspost-cpuid-v2",
-      "origin": "ecosystem-scan",
-      "module": "github.com/klauspost/cpuid/v2",
-      "version": "v2.4.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "darwin/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "linux/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/klauspost/cpuid/v2"]
-        }
-      }
-    },
-    {
-      "id": "golang-snappy",
-      "origin": "ecosystem-scan",
-      "module": "github.com/golang/snappy",
-      "version": "v1.0.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        },
-        "darwin/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        },
-        "linux/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        },
-        "windows/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/golang/snappy"]
-        }
-      }
-    },
-    {
-      "id": "pierrec-lz4-v4",
-      "origin": "ecosystem-scan",
-      "module": "github.com/pierrec/lz4/v4",
-      "version": "v4.1.33",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 3,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "darwin/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "linux/amd64": {
-          "asm_files": 3,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "linux/arm": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "linux/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "windows/amd64": {
-          "asm_files": 3,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        },
-        "windows/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/pierrec/lz4/v4/internal/lz4block",
-            "github.com/pierrec/lz4/v4/internal/xxh32"
-          ]
-        }
-      }
-    },
-    {
-      "id": "stevvooe-resumable",
-      "origin": "ecosystem-scan",
-      "module": "github.com/stevvooe/resumable",
-      "version": "v0.0.0-20180830230917-22b14a53ba50",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/stevvooe/resumable/sha256",
-            "github.com/stevvooe/resumable/sha512"
-          ]
-        },
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/stevvooe/resumable/sha256"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/stevvooe/resumable/sha256",
-            "github.com/stevvooe/resumable/sha512"
-          ]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["github.com/stevvooe/resumable/sha256"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/stevvooe/resumable/sha256",
-            "github.com/stevvooe/resumable/sha512"
-          ]
-        }
-      }
-    },
-    {
-      "id": "x-net",
-      "origin": "ecosystem-scan",
-      "module": "golang.org/x/net",
-      "version": "v0.59.0",
-      "inventory": {
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["golang.org/x/net/internal/socket"]
-        }
-      }
-    },
-    {
-      "id": "x-sys",
-      "origin": "ecosystem-scan",
-      "module": "golang.org/x/sys",
-      "version": "v0.48.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 4,
-          "packages": [
-            "golang.org/x/sys/cpu",
-            "golang.org/x/sys/unix"
-          ]
-        },
-        "darwin/arm64": {
-          "asm_files": 4,
-          "packages": [
-            "golang.org/x/sys/cpu",
-            "golang.org/x/sys/unix"
-          ]
-        },
-        "linux/386": {
-          "asm_files": 2,
-          "packages": [
-            "golang.org/x/sys/cpu",
-            "golang.org/x/sys/unix"
-          ]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "golang.org/x/sys/cpu",
-            "golang.org/x/sys/unix"
-          ]
-        },
-        "linux/arm": {
-          "asm_files": 1,
-          "packages": ["golang.org/x/sys/unix"]
-        },
-        "linux/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "golang.org/x/sys/cpu",
-            "golang.org/x/sys/unix"
-          ]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["golang.org/x/sys/cpu"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["golang.org/x/sys/cpu"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["golang.org/x/sys/cpu"]
-        }
-      }
-    },
-    {
-      "id": "anacrolix-mmsg",
-      "origin": "ecosystem-scan",
-      "module": "github.com/anacrolix/mmsg",
-      "version": "v1.1.1",
-      "inventory": {
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/anacrolix/mmsg/socket"]
-        }
-      }
-    },
-    {
-      "id": "klauspost-cpuid-v1",
-      "origin": "ecosystem-scan",
-      "module": "github.com/klauspost/cpuid",
-      "version": "v1.3.1",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "darwin/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "linux/386": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "linux/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "windows/386": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        },
-        "windows/arm64": {
-          "asm_files": 2,
-          "packages": [
-            "github.com/klauspost/cpuid",
-            "github.com/klauspost/cpuid/private"
-          ]
-        }
-      }
-    },
-    {
-      "id": "modern-go-gls",
-      "origin": "ecosystem-scan",
-      "module": "github.com/modern-go/gls",
-      "version": "v0.0.0-20250215024828-78308f6bb19d",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "darwin/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "linux/arm": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "linux/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        },
-        "windows/arm64": {
-          "asm_files": 1,
-          "packages": ["github.com/modern-go/gls"]
-        }
-      }
-    },
-    {
-      "id": "zeebo-this",
-      "origin": "ecosystem-scan",
-      "module": "github.com/zeebo/this",
-      "version": "v1.0.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/zeebo/this"]
-        },
-        "linux/386": {
-          "asm_files": 1,
-          "packages": ["github.com/zeebo/this"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/zeebo/this"]
-        },
-        "windows/386": {
-          "asm_files": 1,
-          "packages": ["github.com/zeebo/this"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/zeebo/this"]
-        }
-      }
-    },
-    {
-      "id": "minio-highwayhash",
-      "origin": "ecosystem-scan",
-      "module": "github.com/minio/highwayhash",
-      "version": "v1.0.4",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        },
-        "darwin/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        },
-        "linux/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        },
-        "windows/arm64": {
-          "asm_files": 2,
-          "packages": ["github.com/minio/highwayhash"]
-        }
-      }
-    },
-    {
-      "id": "klauspost-reedsolomon",
-      "origin": "ecosystem-scan",
-      "module": "github.com/klauspost/reedsolomon",
-      "version": "v1.14.2",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        },
-        "darwin/arm64": {
-          "asm_files": 3,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        },
-        "linux/arm64": {
-          "asm_files": 3,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        },
-        "windows/arm64": {
-          "asm_files": 3,
-          "packages": ["github.com/klauspost/reedsolomon"]
-        }
-      }
-    },
-    {
-      "id": "cespare-xxhash-v1",
-      "origin": "ecosystem-scan",
-      "module": "github.com/cespare/xxhash",
-      "version": "v1.1.0",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash"]
-        },
-        "linux/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash"]
-        },
-        "windows/amd64": {
-          "asm_files": 1,
-          "packages": ["github.com/cespare/xxhash"]
-        }
-      }
-    },
-    {
-      "id": "tmthrgd-go-bitwise",
-      "origin": "ecosystem-scan",
-      "module": "github.com/tmthrgd/go-bitwise",
-      "version": "v0.0.0-20190904053232-1430ee983fca",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 8,
-          "packages": ["github.com/tmthrgd/go-bitwise"]
-        },
-        "linux/amd64": {
-          "asm_files": 8,
-          "packages": ["github.com/tmthrgd/go-bitwise"]
-        },
-        "windows/amd64": {
-          "asm_files": 8,
-          "packages": ["github.com/tmthrgd/go-bitwise"]
-        }
-      }
-    },
-    {
-      "id": "tmthrgd-go-popcount",
-      "origin": "ecosystem-scan",
-      "module": "github.com/tmthrgd/go-popcount",
-      "version": "v0.0.0-20190904054823-afb1ace8b04f",
-      "inventory": {
-        "darwin/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-popcount"]
-        },
-        "linux/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-popcount"]
-        },
-        "windows/amd64": {
-          "asm_files": 2,
-          "packages": ["github.com/tmthrgd/go-popcount"]
-        }
-      }
-    }
-  ]
-}
diff --git a/testdata/coverage/arm64-go-assembler-families.txt b/testdata/coverage/arm64-go-assembler-families.txt
index eb348f8fb..21c975697 100644
--- a/testdata/coverage/arm64-go-assembler-families.txt
+++ b/testdata/coverage/arm64-go-assembler-families.txt
@@ -1,6 +1,25 @@
-# ARM64 opcode families covered by the Go assembler conformance checks.
-# The Go assembler encoder tables and positive testdata define this list's
-# legal operand forms; external packages are regression consumers only.
+# ARM64 opcode families with complete named-form coverage. The Go assembler
+# encoder tables and positive testdata define this list's legal operand forms;
+# external packages are regression consumers only. Raw-encoding completeness
+# is enforced by each family's decoder tests rather than inferred from this list.
+AESD
+AESE
+AESIMC
+AESMC
+SHA1C
+SHA1H
+SHA1M
+SHA1P
+SHA1SU0
+SHA1SU1
+SHA256H
+SHA256H2
+SHA256SU0
+SHA256SU1
+SHA512H
+SHA512H2
+SHA512SU0
+SHA512SU1
 BFI
 BFIW
 BFXIL
@@ -38,6 +57,14 @@ REV16W
 REV32
 ASR
 ASRW
+RBIT
+RBITW
+CLZ
+CLZW
+CLS
+CLSW
+VCLS
+VCLZ
 LSL
 LSLW
 LSR
@@ -46,8 +73,26 @@ ROR
 RORW
 SUBS
 SUBSW
+ADDS
+ADDSW
+BIC
+BICW
+BICS
+BICSW
 TST
 TSTW
+FCCMPS
+FCCMPD
+FCCMPES
+FCCMPED
+FCMPS
+FCMPD
+FCMPES
+FCMPED
+VFMAXV
+VFMINV
+VFMAXNMV
+VFMINNMV
 FMOVQ
 FSTPQ
 MOVB
diff --git a/testdata/coverage/arm64-xarch-plan9-baseline.json b/testdata/coverage/arm64-xarch-plan9-baseline.json
index 797bfcf98..8b43cf262 100644
--- a/testdata/coverage/arm64-xarch-plan9-baseline.json
+++ b/testdata/coverage/arm64-xarch-plan9-baseline.json
@@ -5,10 +5,10 @@
   "source": "arm64/arm64asm/testdata/plan9cases.txt",
   "asm_files": 1,
   "unique_ops": 667,
-  "unique_forms": 1108,
-  "supported_forms": 381,
-  "context_forms": 54,
-  "unsupported_forms": 673,
+  "unique_forms": 1178,
+  "supported_forms": 841,
+  "context_forms": 63,
+  "unsupported_forms": 274,
   "parse_err_count": 0,
-  "coverage_fingerprint": "a71bea198154ac63c55b87085cc0b1e03136ad32b7e0010084d140ee007a8d93"
+  "coverage_fingerprint": "46b0911577a85fede4fbce37e537c10839f52594a7c6c5534df71c025c7d2801"
 }
diff --git a/testdata/coverage/go-asm-baseline.json b/testdata/coverage/go-asm-baseline.json
index eb580370a..30c8d9b57 100644
--- a/testdata/coverage/go-asm-baseline.json
+++ b/testdata/coverage/go-asm-baseline.json
@@ -1,5 +1,5 @@
 {
-  "description": "Official opcode/encoder inventories and concrete-form lowering snapshots for Go 1.20 through Go 1.27. Review full scanner reports before updating.",
+  "description": "Official opcode/encoder inventories and concrete-form lowering snapshots for Go 1.20 through Go 1.27. Form identity retains complete source control suffixes. Review full scanner reports before updating.",
   "schema_version": 2,
   "encoder_union": {
     "386": {
@@ -31,74 +31,78 @@
   "versions": {
     "go1.20": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "c44108e67d2b8dda3d332dbd2f7cbf08c6803cae1cd67712e83dfd999cf073df",
+        "context_forms": 33,
+        "coverage_fingerprint": "8e157f65aed9b48f0c89a9537e6ed7daa9ed637b0b7a83306da51274bb8a0b55",
         "official_opcodes": 1598,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 59,
+        "supported_forms": 23,
+        "unique_forms": 56,
         "unique_ops": 20,
-        "unsupported_forms": 12,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1601,
         "encoder_forms": 4996,
         "encoder_opcodes_observed_in_corpus": 19,
-        "encoder_fingerprint": "e369c64457f20a446a4e5c89736a5bb4a4b63d121710809d547cc171c571bcd1"
+        "encoder_fingerprint": "e369c64457f20a446a4e5c89736a5bb4a4b63d121710809d547cc171c571bcd1",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "074ec6a5f92c839df7173c7c44089a854e7ced6a5b4c67b2aee2327bfccbc63a",
+        "context_forms": 5288,
+        "coverage_fingerprint": "ad0d67f21492cfd4226d27a753bfb0296a2024757a478d597e34220acc23589a",
         "official_opcodes": 1598,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6740,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1472,
+        "unique_forms": 6761,
         "unique_ops": 1454,
-        "unsupported_forms": 5967,
+        "unsupported_forms": 1,
         "encoder_opcodes": 1601,
         "encoder_forms": 4996,
         "encoder_opcodes_observed_in_corpus": 1449,
-        "encoder_fingerprint": "e369c64457f20a446a4e5c89736a5bb4a4b63d121710809d547cc171c571bcd1"
+        "encoder_fingerprint": "e369c64457f20a446a4e5c89736a5bb4a4b63d121710809d547cc171c571bcd1",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "7bd5f9d5b63a18fcdf2695c10bae78e582b3eed7dddbd69c2339bfd63e04438a",
-        "official_opcodes": 179,
+        "context_forms": 83,
+        "coverage_fingerprint": "55dcd36e744f81c129ae468ddd06a9cd36a3d32bc531075bcabc5ffc8c50dfdb",
+        "official_opcodes": 135,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 310,
-        "unique_forms": 498,
+        "supported_forms": 782,
+        "unique_forms": 865,
         "unique_ops": 133,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 142,
         "encoder_forms": 526,
         "encoder_opcodes_observed_in_corpus": 127,
         "encoder_fingerprint": "9233f86c9bec14609e5ebd1bea4750ebc130871e476fb7a7ff07721253812fd2"
       },
       "arm64": {
-        "context_forms": 45,
-        "coverage_fingerprint": "2d6437f9e53e25eef528460c374bcffade0f74a0105aaebbf7713fcc2132ed27",
-        "official_opcodes": 608,
+        "context_forms": 67,
+        "coverage_fingerprint": "c3622576e072c1318616d9bc112a4c8993646385970e6801d81e1dd869138431",
+        "official_opcodes": 535,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 457,
-        "unique_forms": 911,
+        "supported_forms": 920,
+        "unique_forms": 987,
         "unique_ops": 487,
-        "unsupported_forms": 409,
+        "unsupported_forms": 0,
         "encoder_opcodes": 444,
         "encoder_forms": 1397,
         "encoder_opcodes_observed_in_corpus": 393,
         "encoder_fingerprint": "2b453ffe072becde3bf7da18f0839b985e975750355df58c64f055e20c73fd5c"
       },
       "wasm": {
-        "context_forms": 129,
-        "coverage_fingerprint": "c4319d55141b65fb57dcaf794f887ee7598f6f04c54f4f85b47f8049d81ab162",
+        "context_forms": 130,
+        "coverage_fingerprint": "219fd3fd70b1fde86eaa55bc2a1503389e3ecf3c99902bb1736fc28b67014ddd",
         "official_opcodes": 208,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 129,
-        "unique_ops": 78,
+        "unique_forms": 130,
+        "unique_ops": 79,
         "unsupported_forms": 0,
         "encoder_opcodes": 208,
         "encoder_forms": 208,
@@ -108,74 +112,78 @@
     },
     "go1.21": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1599,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "2a0ed5b32f1a31014e35f9476063a5fee389209d941ee1e9b181420cea962a72",
+        "context_forms": 5288,
+        "coverage_fingerprint": "4ec0ca655d99825992cf34398324cb96d91ff4ee44c9949b02ba23ecc30b1912",
         "official_opcodes": 1599,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6741,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1474,
+        "unique_forms": 6762,
         "unique_ops": 1455,
-        "unsupported_forms": 5968,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 1450,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "7bd5f9d5b63a18fcdf2695c10bae78e582b3eed7dddbd69c2339bfd63e04438a",
-        "official_opcodes": 179,
+        "context_forms": 83,
+        "coverage_fingerprint": "55dcd36e744f81c129ae468ddd06a9cd36a3d32bc531075bcabc5ffc8c50dfdb",
+        "official_opcodes": 135,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 310,
-        "unique_forms": 498,
+        "supported_forms": 782,
+        "unique_forms": 865,
         "unique_ops": 133,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 142,
         "encoder_forms": 526,
         "encoder_opcodes_observed_in_corpus": 127,
         "encoder_fingerprint": "9233f86c9bec14609e5ebd1bea4750ebc130871e476fb7a7ff07721253812fd2"
       },
       "arm64": {
-        "context_forms": 45,
-        "coverage_fingerprint": "b41c8147185ffe1f767d123673a31561927f56ec6e18e4a715a631fac898e025",
-        "official_opcodes": 604,
+        "context_forms": 67,
+        "coverage_fingerprint": "294f62da6730d199e1a41fc1d5f15661842d631579d9ae61a454d2fda63a4050",
+        "official_opcodes": 531,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 459,
-        "unique_forms": 945,
+        "supported_forms": 954,
+        "unique_forms": 1021,
         "unique_ops": 487,
-        "unsupported_forms": 441,
+        "unsupported_forms": 0,
         "encoder_opcodes": 444,
         "encoder_forms": 1402,
         "encoder_opcodes_observed_in_corpus": 393,
         "encoder_fingerprint": "28adc02f07122efb10df8e883c3c397c4606e475a23f0ea3ad2e9e91286d6f12"
       },
       "wasm": {
-        "context_forms": 124,
-        "coverage_fingerprint": "291d33fa2e116d5960ca200f69e7459e27751ffd98f7a99dc0e823e2c7a5aa2f",
+        "context_forms": 125,
+        "coverage_fingerprint": "c65007d1bf50a5a9aa9e929360021a2a36beff813e3f4d64341820ea0972ed57",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 124,
-        "unique_ops": 76,
+        "unique_forms": 125,
+        "unique_ops": 77,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -185,74 +193,78 @@
     },
     "go1.22": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1599,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "2a0ed5b32f1a31014e35f9476063a5fee389209d941ee1e9b181420cea962a72",
+        "context_forms": 5288,
+        "coverage_fingerprint": "4ec0ca655d99825992cf34398324cb96d91ff4ee44c9949b02ba23ecc30b1912",
         "official_opcodes": 1599,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6741,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1474,
+        "unique_forms": 6762,
         "unique_ops": 1455,
-        "unsupported_forms": 5968,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 1450,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "7bd5f9d5b63a18fcdf2695c10bae78e582b3eed7dddbd69c2339bfd63e04438a",
-        "official_opcodes": 179,
+        "context_forms": 83,
+        "coverage_fingerprint": "55dcd36e744f81c129ae468ddd06a9cd36a3d32bc531075bcabc5ffc8c50dfdb",
+        "official_opcodes": 135,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 310,
-        "unique_forms": 498,
+        "supported_forms": 782,
+        "unique_forms": 865,
         "unique_ops": 133,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 142,
         "encoder_forms": 526,
         "encoder_opcodes_observed_in_corpus": 127,
         "encoder_fingerprint": "9233f86c9bec14609e5ebd1bea4750ebc130871e476fb7a7ff07721253812fd2"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "04daf93aacdc190ab87a254de0ebf56cf726b2538813d66f6f0a17d3f3ab5119",
-        "official_opcodes": 606,
+        "context_forms": 69,
+        "coverage_fingerprint": "9895d774a41bcd89180991ebed75adaa2c4a0d441223e79c26ff8a19c6647e65",
+        "official_opcodes": 531,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 459,
-        "unique_forms": 947,
+        "supported_forms": 954,
+        "unique_forms": 1023,
         "unique_ops": 488,
-        "unsupported_forms": 441,
+        "unsupported_forms": 0,
         "encoder_opcodes": 444,
         "encoder_forms": 1444,
         "encoder_opcodes_observed_in_corpus": 394,
         "encoder_fingerprint": "3c499e508b24684f72847358aa7278675598d914db644072f57d6c68313f5bdd"
       },
       "wasm": {
-        "context_forms": 126,
-        "coverage_fingerprint": "76c70161154efa069fa712c94993a7b1158f65cbe7b75a5b65e435f434a18c05",
+        "context_forms": 127,
+        "coverage_fingerprint": "bbe9274c75164d41d5ddcd3b463a413869f901676e9f389ef18e931353f6645f",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 126,
-        "unique_ops": 76,
+        "unique_forms": 127,
+        "unique_ops": 77,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -262,74 +274,78 @@
     },
     "go1.23": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1599,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "2a0ed5b32f1a31014e35f9476063a5fee389209d941ee1e9b181420cea962a72",
+        "context_forms": 5288,
+        "coverage_fingerprint": "4ec0ca655d99825992cf34398324cb96d91ff4ee44c9949b02ba23ecc30b1912",
         "official_opcodes": 1599,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6741,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1474,
+        "unique_forms": 6762,
         "unique_ops": 1455,
-        "unsupported_forms": 5968,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 1450,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "7bd5f9d5b63a18fcdf2695c10bae78e582b3eed7dddbd69c2339bfd63e04438a",
-        "official_opcodes": 179,
+        "context_forms": 83,
+        "coverage_fingerprint": "55dcd36e744f81c129ae468ddd06a9cd36a3d32bc531075bcabc5ffc8c50dfdb",
+        "official_opcodes": 135,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 310,
-        "unique_forms": 498,
+        "supported_forms": 782,
+        "unique_forms": 865,
         "unique_ops": 133,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 142,
         "encoder_forms": 526,
         "encoder_opcodes_observed_in_corpus": 127,
         "encoder_fingerprint": "9233f86c9bec14609e5ebd1bea4750ebc130871e476fb7a7ff07721253812fd2"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "ee873d61168b2b73f55a14753d18a16766f9cb4942a317582a836ec957f19146",
-        "official_opcodes": 606,
+        "context_forms": 69,
+        "coverage_fingerprint": "1b798061054c2649d9f42a695039a5585094fb9627db8a1446d0274c1a4fc11b",
+        "official_opcodes": 531,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 460,
-        "unique_forms": 948,
+        "supported_forms": 955,
+        "unique_forms": 1024,
         "unique_ops": 488,
-        "unsupported_forms": 441,
+        "unsupported_forms": 0,
         "encoder_opcodes": 445,
         "encoder_forms": 1445,
         "encoder_opcodes_observed_in_corpus": 394,
         "encoder_fingerprint": "1af2d4424b0480d4a08d0450dc0d0f5580a028a1df4ad5c937fe266bc2be723c"
       },
       "wasm": {
-        "context_forms": 126,
-        "coverage_fingerprint": "76c70161154efa069fa712c94993a7b1158f65cbe7b75a5b65e435f434a18c05",
+        "context_forms": 127,
+        "coverage_fingerprint": "bbe9274c75164d41d5ddcd3b463a413869f901676e9f389ef18e931353f6645f",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 126,
-        "unique_ops": 76,
+        "unique_forms": 127,
+        "unique_ops": 77,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -339,74 +355,78 @@
     },
     "go1.24": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1599,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "2a0ed5b32f1a31014e35f9476063a5fee389209d941ee1e9b181420cea962a72",
+        "context_forms": 5288,
+        "coverage_fingerprint": "4ec0ca655d99825992cf34398324cb96d91ff4ee44c9949b02ba23ecc30b1912",
         "official_opcodes": 1599,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6741,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1474,
+        "unique_forms": 6762,
         "unique_ops": 1455,
-        "unsupported_forms": 5968,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1602,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 1450,
-        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5"
+        "encoder_fingerprint": "ed66f1e1863c5e77ffa40f546092a958697bb7dcc186d88bfa26c49b75cb40c5",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "edb4268d064f26136ec8e070e195e38ae31e1fdb2fe31294e66b068dc57dc1eb",
-        "official_opcodes": 181,
+        "context_forms": 83,
+        "coverage_fingerprint": "8885f542b25f3c9ef44d4cf196a91a7fc8867b3848065b5b4308d9c102396c9e",
+        "official_opcodes": 137,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 312,
-        "unique_forms": 500,
+        "supported_forms": 784,
+        "unique_forms": 867,
         "unique_ops": 135,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 144,
         "encoder_forms": 528,
         "encoder_opcodes_observed_in_corpus": 129,
         "encoder_fingerprint": "d48a5c9ffa187d1b998e7c5b4c447c90a9798cc0b778e7eff5c14f8dd193a108"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "ee873d61168b2b73f55a14753d18a16766f9cb4942a317582a836ec957f19146",
-        "official_opcodes": 606,
+        "context_forms": 69,
+        "coverage_fingerprint": "1b798061054c2649d9f42a695039a5585094fb9627db8a1446d0274c1a4fc11b",
+        "official_opcodes": 531,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 460,
-        "unique_forms": 948,
+        "supported_forms": 955,
+        "unique_forms": 1024,
         "unique_ops": 488,
-        "unsupported_forms": 441,
+        "unsupported_forms": 0,
         "encoder_opcodes": 445,
         "encoder_forms": 1445,
         "encoder_opcodes_observed_in_corpus": 394,
         "encoder_fingerprint": "1af2d4424b0480d4a08d0450dc0d0f5580a028a1df4ad5c937fe266bc2be723c"
       },
       "wasm": {
-        "context_forms": 127,
-        "coverage_fingerprint": "9e11e8231fd1ad9b8b1240b44adfea53c8da35007d1d88b506721b39490d463e",
+        "context_forms": 128,
+        "coverage_fingerprint": "90812e2dba0a04090804578ec18393580db46ea7c717ac3eda761a514476eacb",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 127,
-        "unique_ops": 77,
+        "unique_forms": 128,
+        "unique_ops": 78,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -416,74 +436,78 @@
     },
     "go1.25": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1600,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4998,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c"
+        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "d858d8ff078e13d327ca4f220b2096a6a8d58ca30a28a8ee74115c13be391752",
+        "context_forms": 5288,
+        "coverage_fingerprint": "b5458ea0b13b34fa61c7d00666472a3c0a6fa4e58a1308090564da26304f2878",
         "official_opcodes": 1600,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6742,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1475,
+        "unique_forms": 6763,
         "unique_ops": 1456,
-        "unsupported_forms": 5969,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4998,
         "encoder_opcodes_observed_in_corpus": 1451,
-        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c"
+        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "edb4268d064f26136ec8e070e195e38ae31e1fdb2fe31294e66b068dc57dc1eb",
-        "official_opcodes": 181,
+        "context_forms": 83,
+        "coverage_fingerprint": "8885f542b25f3c9ef44d4cf196a91a7fc8867b3848065b5b4308d9c102396c9e",
+        "official_opcodes": 137,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 312,
-        "unique_forms": 500,
+        "supported_forms": 784,
+        "unique_forms": 867,
         "unique_ops": 135,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 144,
         "encoder_forms": 528,
         "encoder_opcodes_observed_in_corpus": 129,
         "encoder_fingerprint": "d48a5c9ffa187d1b998e7c5b4c447c90a9798cc0b778e7eff5c14f8dd193a108"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "c7188c751d36323903dce2248b35093cd5aeb384ce4f6a5eb0e57b982ac640e5",
-        "official_opcodes": 607,
+        "context_forms": 69,
+        "coverage_fingerprint": "931e2812e23b19713f96ca513adc8a44f27cad9fa535e1fc5d1907193484baf1",
+        "official_opcodes": 532,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 460,
-        "unique_forms": 949,
+        "supported_forms": 956,
+        "unique_forms": 1025,
         "unique_ops": 489,
-        "unsupported_forms": 442,
+        "unsupported_forms": 0,
         "encoder_opcodes": 446,
         "encoder_forms": 1447,
         "encoder_opcodes_observed_in_corpus": 395,
         "encoder_fingerprint": "fed3635d6f0d9c0806b055286ed0ed6a767390c445e0e92ddd7705addcd805dc"
       },
       "wasm": {
-        "context_forms": 127,
-        "coverage_fingerprint": "9e11e8231fd1ad9b8b1240b44adfea53c8da35007d1d88b506721b39490d463e",
+        "context_forms": 128,
+        "coverage_fingerprint": "90812e2dba0a04090804578ec18393580db46ea7c717ac3eda761a514476eacb",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 127,
-        "unique_ops": 77,
+        "unique_forms": 128,
+        "unique_ops": 78,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -493,74 +517,78 @@
     },
     "go1.26": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1600,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4998,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c"
+        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "d858d8ff078e13d327ca4f220b2096a6a8d58ca30a28a8ee74115c13be391752",
+        "context_forms": 5288,
+        "coverage_fingerprint": "b5458ea0b13b34fa61c7d00666472a3c0a6fa4e58a1308090564da26304f2878",
         "official_opcodes": 1600,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6742,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1475,
+        "unique_forms": 6763,
         "unique_ops": 1456,
-        "unsupported_forms": 5969,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4998,
         "encoder_opcodes_observed_in_corpus": 1451,
-        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c"
+        "encoder_fingerprint": "b5e0b0e2b61b69a007f387082aaa2f7c38c7fdc890c8d16c3e5e00e919144d4c",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "edb4268d064f26136ec8e070e195e38ae31e1fdb2fe31294e66b068dc57dc1eb",
-        "official_opcodes": 181,
+        "context_forms": 83,
+        "coverage_fingerprint": "8885f542b25f3c9ef44d4cf196a91a7fc8867b3848065b5b4308d9c102396c9e",
+        "official_opcodes": 137,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 312,
-        "unique_forms": 500,
+        "supported_forms": 784,
+        "unique_forms": 867,
         "unique_ops": 135,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 144,
         "encoder_forms": 528,
         "encoder_opcodes_observed_in_corpus": 129,
         "encoder_fingerprint": "d48a5c9ffa187d1b998e7c5b4c447c90a9798cc0b778e7eff5c14f8dd193a108"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "b71da01b52530fd1222f22169e5838c673f7908d45f3124b8dd76cf0cd9a59a1",
-        "official_opcodes": 613,
+        "context_forms": 69,
+        "coverage_fingerprint": "9638c0fcd8c2f4b1bc9c5b3cdf153a0d6f03b4e335efb681ee4239c0279693ba",
+        "official_opcodes": 538,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 460,
-        "unique_forms": 955,
+        "supported_forms": 962,
+        "unique_forms": 1031,
         "unique_ops": 495,
-        "unsupported_forms": 448,
+        "unsupported_forms": 0,
         "encoder_opcodes": 450,
         "encoder_forms": 1451,
         "encoder_opcodes_observed_in_corpus": 401,
         "encoder_fingerprint": "781616f08759827e37b6214ab42797c9d67ede21f440be768fcdbb59ff374d50"
       },
       "wasm": {
-        "context_forms": 121,
-        "coverage_fingerprint": "4fc7623556cd369953af572e32bd71a947297fce4b1756c151390faec84059f2",
+        "context_forms": 122,
+        "coverage_fingerprint": "86e04970d09f46a0a8a3afb2d4bab58b8f78ac070cedeea297fc07fb0fa38659",
         "official_opcodes": 207,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 121,
-        "unique_ops": 71,
+        "unique_forms": 122,
+        "unique_ops": 72,
         "unsupported_forms": 0,
         "encoder_opcodes": 207,
         "encoder_forms": 207,
@@ -570,74 +598,78 @@
     },
     "go1.27": {
       "386": {
-        "context_forms": 6,
-        "coverage_fingerprint": "9ac7af8e6cf867ac7e4e22669af5cc2db4d74434cca25faf4177e37e55c65dff",
+        "context_forms": 33,
+        "coverage_fingerprint": "1fcb0abe292216cdab749f2c75681118d498289719f947d9b197f21fc1414f1e",
         "official_opcodes": 1600,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 41,
-        "unique_forms": 60,
+        "supported_forms": 24,
+        "unique_forms": 57,
         "unique_ops": 21,
-        "unsupported_forms": 13,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 20,
-        "encoder_fingerprint": "4341ad3acc9a810857665d1941f5f6329b514aeeb62667ac292c46b79fcd1a81"
+        "encoder_fingerprint": "4341ad3acc9a810857665d1941f5f6329b514aeeb62667ac292c46b79fcd1a81",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "amd64": {
-        "context_forms": 6,
-        "coverage_fingerprint": "d858d8ff078e13d327ca4f220b2096a6a8d58ca30a28a8ee74115c13be391752",
+        "context_forms": 5288,
+        "coverage_fingerprint": "b5458ea0b13b34fa61c7d00666472a3c0a6fa4e58a1308090564da26304f2878",
         "official_opcodes": 1600,
         "parse_err_count": 0,
-        "runtime_verified_forms": 35,
-        "supported_forms": 767,
-        "unique_forms": 6742,
+        "runtime_verified_forms": 51,
+        "supported_forms": 1475,
+        "unique_forms": 6763,
         "unique_ops": 1456,
-        "unsupported_forms": 5969,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1603,
         "encoder_forms": 4997,
         "encoder_opcodes_observed_in_corpus": 1451,
-        "encoder_fingerprint": "4341ad3acc9a810857665d1941f5f6329b514aeeb62667ac292c46b79fcd1a81"
+        "encoder_fingerprint": "4341ad3acc9a810857665d1941f5f6329b514aeeb62667ac292c46b79fcd1a81",
+        "encoder_rules": 3568,
+        "encoder_rule_fingerprint": "974e4bdce9e0cf8687008f4dfa8330537cb0f29bac3940cbdfc57b5e0115c36a"
       },
       "arm": {
-        "context_forms": 34,
-        "coverage_fingerprint": "edb4268d064f26136ec8e070e195e38ae31e1fdb2fe31294e66b068dc57dc1eb",
-        "official_opcodes": 181,
+        "context_forms": 83,
+        "coverage_fingerprint": "8885f542b25f3c9ef44d4cf196a91a7fc8867b3848065b5b4308d9c102396c9e",
+        "official_opcodes": 137,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
-        "supported_forms": 312,
-        "unique_forms": 500,
+        "supported_forms": 784,
+        "unique_forms": 867,
         "unique_ops": 135,
-        "unsupported_forms": 154,
+        "unsupported_forms": 0,
         "encoder_opcodes": 144,
         "encoder_forms": 528,
         "encoder_opcodes_observed_in_corpus": 129,
         "encoder_fingerprint": "d48a5c9ffa187d1b998e7c5b4c447c90a9798cc0b778e7eff5c14f8dd193a108"
       },
       "arm64": {
-        "context_forms": 47,
-        "coverage_fingerprint": "5e13a58ed69a0c575affe87e88a65796c217d0a4e7acfdf5f2f3a7c7455d34be",
-        "official_opcodes": 1417,
+        "context_forms": 69,
+        "coverage_fingerprint": "85a47ef9825d6fcb8c9823331925eb8348a88dd3360ca8e0a080e322eb83968d",
+        "official_opcodes": 1342,
         "parse_err_count": 0,
         "runtime_verified_forms": 64,
-        "supported_forms": 462,
-        "unique_forms": 1980,
+        "supported_forms": 2055,
+        "unique_forms": 2124,
         "unique_ops": 1281,
-        "unsupported_forms": 1471,
+        "unsupported_forms": 0,
         "encoder_opcodes": 1253,
         "encoder_forms": 2964,
         "encoder_opcodes_observed_in_corpus": 1187,
         "encoder_fingerprint": "e7ee0302652810d238de58639890b5b04b8b678d4619be4909d6622f666f0026"
       },
       "wasm": {
-        "context_forms": 120,
-        "coverage_fingerprint": "4e31258d9b2a04e72dafc936139407050163282fb04b79e9a0b7c3afe0b6a22f",
+        "context_forms": 121,
+        "coverage_fingerprint": "68370a18d4b274518b59a9b3639db7dc46859464867ce9cc74f9daeb4cd34019",
         "official_opcodes": 463,
         "parse_err_count": 0,
         "runtime_verified_forms": 0,
         "supported_forms": 0,
-        "unique_forms": 120,
-        "unique_ops": 71,
+        "unique_forms": 121,
+        "unique_ops": 72,
         "unsupported_forms": 0,
         "encoder_opcodes": 463,
         "encoder_forms": 463,
diff --git a/testdata/goasm/stack_control_backend_test.go b/testdata/goasm/stack_control_backend_test.go
new file mode 100644
index 000000000..ac9762373
--- /dev/null
+++ b/testdata/goasm/stack_control_backend_test.go
@@ -0,0 +1,58 @@
+// Copied only into an added, owned SDK test overlay. This file never changes
+// Go's encoder, existing tests, tables or source classification.
+package x86
+
+import (
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"encoding/json"
+	"testing"
+)
+
+func TestPlan9asmOriginalDuffSource(t *testing.T) {
+	for _, mode := range []struct {
+		name string
+		arch *obj.LinkArch
+	}{{"amd64", &Linkamd64}, {"386", &Link386}} {
+		for _, operation := range []struct {
+			op           obj.As
+			name, symbol string
+		}{{obj.ADUFFCOPY, "DUFFCOPY", "runtime.duffcopy"}, {obj.ADUFFZERO, "DUFFZERO", "runtime.duffzero"}} {
+			ctxt := obj.Linknew(mode.arch)
+			ctxt.Headtype = objabi.Hlinux
+			ctxt.IsAsm = true
+			ctxt.DiagFunc = func(format string, args ...interface{}) { t.Fatalf(format, args...) }
+			instinit(ctxt)
+			instruction := obj.Prog{Ctxt: ctxt, As: operation.op, Pc: 13,
+				To: obj.Addr{Type: obj.TYPE_ADDR, Sym: ctxt.Lookup(operation.symbol), Offset: 37}}
+			owner := &obj.LSym{Name: "plan9asm.original.duff"}
+			var buffer AsmBuf
+			buffer.asmins(ctxt, owner, &instruction)
+			if len(owner.R) != 1 || owner.R[0].Sym == nil {
+				t.Fatal("actual DUFF encoder did not preserve its symbol relocation", owner.R)
+			}
+			relocation := owner.R[0]
+			displacement := int(relocation.Off) - int(instruction.Pc)
+			if relocation.Type != objabi.R_CALL || displacement < 1 || displacement+4 > buffer.Len() ||
+				buffer.Bytes()[displacement-1] != 0xe8 || relocation.Siz != 4 ||
+				relocation.Sym.Name != operation.symbol || relocation.Add != 37 {
+				t.Fatal("actual original DUFF PC/symbol/addend changed", relocation)
+			}
+			record := struct {
+				Arch, Opcode, Origin string
+				PC                   int64
+				Encoding             []byte
+				Offset, Size, Kind   int
+				Symbol               string
+				Add                  int64
+			}{mode.name, operation.name, "stock-backend", instruction.Pc,
+				append([]byte(nil), buffer.Bytes()...), int(relocation.Off), int(relocation.Siz),
+				int(relocation.Type), relocation.Sym.Name, relocation.Add}
+			encoded, err := json.Marshal(record)
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("PLAN9ASM_SOURCE_DUFF %s", encoded)
+		}
+	}
+}
diff --git a/testdata/goasm/state_system_backend_test.go b/testdata/goasm/state_system_backend_test.go
new file mode 100644
index 000000000..7ec4a60c1
--- /dev/null
+++ b/testdata/goasm/state_system_backend_test.go
@@ -0,0 +1,77 @@
+// Added only through an owned Go test overlay; no SDK source is replaced.
+package x86
+
+import (
+	"bytes"
+	"cmd/internal/obj"
+	"cmd/internal/objabi"
+	"encoding/json"
+	"testing"
+)
+
+func TestPlan9asmOriginalStateSystemBackend(t *testing.T) {
+	for _, mode := range []struct {
+		name string
+		arch *obj.LinkArch
+	}{{"amd64", &Linkamd64}, {"386", &Link386}} {
+		for _, operation := range []struct {
+			name string
+			op   obj.As
+		}{{"FLDENV", AFLDENV}, {"XBEGIN", AXBEGIN}} {
+			t.Run(mode.name+"/"+operation.name, func(t *testing.T) {
+				ctxt := obj.Linknew(mode.arch)
+				ctxt.Headtype, ctxt.IsAsm = objabi.Hlinux, true
+				ctxt.DiagFunc = func(format string, args ...interface{}) { t.Fatalf(format, args...) }
+				instinit(ctxt)
+				instruction := obj.Prog{Ctxt: ctxt, As: operation.op, Pc: 13}
+				expected := []byte{0xd9, 0x26}
+				if operation.op == AFLDENV {
+					// The original Zm_o consumes From. Stock asm's unaryDst
+					// frontend places this same single operand in To instead.
+					instruction.From = obj.Addr{Type: obj.TYPE_MEM, Reg: REG_SI}
+				} else {
+					instruction.To = obj.Addr{Type: obj.TYPE_BRANCH, Sym: ctxt.Lookup("plan9asm.backend.target")}
+					expected = []byte{0xc7, 0xf8, 0, 0, 0, 0}
+				}
+				owner := &obj.LSym{Name: "plan9asm.original.state"}
+				var buffer AsmBuf
+				buffer.asmins(ctxt, owner, &instruction)
+				if !bytes.Equal(buffer.Bytes(), expected) {
+					t.Fatal("original Go backend bytes differ", buffer.Bytes(), expected)
+				}
+				record := struct {
+					Arch, Opcode, Origin string
+					PC                   int64
+					Encoding             []byte
+					Offset, Size, Kind   int
+					KindName             string
+					Symbol               string
+					Add                  int64
+				}{Arch: mode.name, Opcode: operation.name, Origin: "stock-backend",
+					PC: instruction.Pc, Encoding: append([]byte(nil), buffer.Bytes()...)}
+				if operation.op == AFLDENV {
+					if len(owner.R) != 0 {
+						t.Fatal("original FLDENV acquired a relocation", owner.R)
+					}
+				} else {
+					if len(owner.R) != 1 || owner.R[0].Sym == nil {
+						t.Fatal("original XBEGIN lost its unique external relocation", owner.R)
+					}
+					relocation := owner.R[0]
+					if relocation.Type != objabi.R_CALL || relocation.Off != 15 || relocation.Siz != 4 ||
+						relocation.Sym.Name != "plan9asm.backend.target" || relocation.Add != 0 {
+						t.Fatal("original XBEGIN PC/width/type/symbol/addend differ", relocation)
+					}
+					record.Offset, record.Size, record.Kind = int(relocation.Off), int(relocation.Siz), int(relocation.Type)
+					record.KindName = relocation.Type.String()
+					record.Symbol, record.Add = relocation.Sym.Name, relocation.Add
+				}
+				encoded, err := json.Marshal(record)
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Logf("PLAN9ASM_STATE_SYSTEM_BACKEND %s", encoded)
+			})
+		}
+	}
+}
diff --git a/testdata/native/avx512-roots.txt b/testdata/native/avx512-roots.txt
new file mode 100644
index 000000000..e255f18b7
--- /dev/null
+++ b/testdata/native/avx512-roots.txt
@@ -0,0 +1,65 @@
+TestAMD64FPClassRuntimeSemantics
+TestAMD64FixupImmediateRuntimeSemantics
+TestAMD64FloatingRangeDoubleAndScalarRuntimeSemantics
+TestAMD64FloatingRangeRuntimeSemantics
+TestAMD64GetExpRuntimeSemantics
+TestAMD64GetMantRuntimeSemantics
+TestAMD64PackedAbsSignRuntimeSemantics
+TestAMD64ScalarIntegerFloatRuntimeSemantics
+TestAMD64ScalarPrecisionConvertRuntimeSemantics
+TestAMD64ScalarSqrtRuntimeSemantics
+TestAMD64ScaleFRuntimeSemantics
+TestAMD64ScaledRoundRuntimeSemantics
+TestCrossLinuxRuntimeMatrixAMD64ConformanceNativeAVX512
+TestCrossLinuxRuntimeMatrixAMD64PackedDoubleDwordNativeAVX512
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch00
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch01
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch02
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch03
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch04
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch05
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalConversionNativeBatch06
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch00
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch01
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch02
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch03
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch04
+TestCrossLinuxRuntimeMatrixGoAMD64FixedLocalPackedNativeWideBatch05
+TestCrossLinuxRuntimeMatrixX86COMINativeDeadExceptions
+TestCrossLinuxRuntimeMatrixX86COMINativeVectorFlagsEVEX
+TestCrossLinuxRuntimeMatrixX86COMINativeVectorMXCSREVEX
+TestCrossLinuxRuntimeMatrixX86COMIRawNativeCompare
+TestCrossLinuxRuntimeMatrixX86FMA3GoCallerNumericalFamily
+TestCrossLinuxRuntimeMatrixX86FloatingCompareDeadResultEffectsEVEX
+TestCrossLinuxRuntimeMatrixX86FloatingCompareFPScalarByteSpansEVEX
+TestCrossLinuxRuntimeMatrixX86FloatingCompareIndependentIEEEAndMXCSREVEX
+TestCrossLinuxRuntimeMatrixX86InsertExtractMaskedNativeMemory
+TestCrossLinuxRuntimeMatrixX86MoveHalfOriginalGoFlagsDFAliases
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512Status
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart1
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart2
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart3
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart4
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart5
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart6
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeAVX512StatusPart7
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaults
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart1
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart2
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart3
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart4
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart5
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart6
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeDeadFaultsPart7
+TestCrossLinuxRuntimeMatrixX86PackedConversionNativeIndependentC
+TestCrossLinuxRuntimeMatrixX86PackedIntegerCompareOriginalNativeWideBits
+TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedMaskedMemory
+TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedOriginalGo
+TestCrossLinuxRuntimeMatrixX86PackedMoveAlignedRegisterViews
+TestCrossLinuxRuntimeMatrixX86PackedMoveUnalignedOriginalGo
+TestCrossLinuxRuntimeMatrixX86RawScalarFloatToIntegerNative
+TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeVectorDeadFaults
+TestCrossLinuxRuntimeMatrixX86ScalarFloatIntegerNativeVectorMatrix
+TestCrossLinuxRuntimeMatrixX86ScalarSqrtNativeSemantics
+TestX86Reciprocal14NativeFAMD64
+TestX86Reciprocal14NativeVLAMD64
diff --git a/testdata/x86_floating_minmax_native.c b/testdata/x86_floating_minmax_native.c
new file mode 100644
index 000000000..ab7885c2d
--- /dev/null
+++ b/testdata/x86_floating_minmax_native.c
@@ -0,0 +1,220 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+
+@PROTOTYPES@
+@ORIGINALS@
+
+typedef void (*Program)(uint8_t *, const uint8_t *, const uint8_t *, const uint8_t *, uint32_t);
+typedef struct {
+    Program translated, original;
+    unsigned bits, width, carrier;
+    int source, second, destination;
+    bool legacy, scalar, dead, minimum;
+} Kernel;
+
+static const Kernel kernels[] = {@KERNELS@};
+
+static const uint64_t edges32[] = {
+    0, 0x80000000, 0x3f800000, 0xbf800000, 0x7f800000, 0xff800000,
+    0x7fc12345, 0xffc54321, 0x7f812345, 0xff812345,
+    1, 0x80000001, 0x007fffff, 0x807fffff, 0x00800000, 0x80800000
+};
+
+static const uint64_t edges64[] = {
+    0, UINT64_C(0x8000000000000000), UINT64_C(0x3ff0000000000000), UINT64_C(0xbff0000000000000),
+    UINT64_C(0x7ff0000000000000), UINT64_C(0xfff0000000000000),
+    UINT64_C(0x7ff8123456789abc), UINT64_C(0xfff8fedcba987654),
+    UINT64_C(0x7ff0123456789abc), UINT64_C(0xfff0123456789abc),
+    1, UINT64_C(0x8000000000000001), UINT64_C(0x000fffffffffffff),
+    UINT64_C(0x800fffffffffffff), UINT64_C(0x0010000000000000), UINT64_C(0x8010000000000000)
+};
+
+static uint64_t lane(const uint8_t *input, unsigned bytes) {
+    uint64_t value = 0;
+    memcpy(&value, input, bytes);
+    return value;
+}
+
+// Integer-only IEEE ordering avoids contaminating the observed MXCSR with
+// comparisons in the reference. MIN/MAX returns the second Intel operand
+// for equality and either NaN, retaining its sign and payload bits.
+static uint64_t reference(uint64_t a, uint64_t b, unsigned bits, bool minimum, uint32_t csr) {
+    uint64_t sign = UINT64_C(1) << (bits - 1);
+    uint64_t mask = bits == 64 ? UINT64_MAX : UINT64_C(0xffffffff);
+    uint64_t exponent = bits == 64 ? UINT64_C(0x7ff0000000000000) : UINT64_C(0x7f800000);
+    uint64_t fraction = mask & ~(sign | exponent);
+    if (csr & 64) {
+        if (!(a & exponent) && (a & fraction)) a &= sign;
+        if (!(b & exponent) && (b & fraction)) b &= sign;
+    }
+    if (((a & exponent) == exponent && (a & fraction)) ||
+        ((b & exponent) == exponent && (b & fraction)) ||
+        a == b || (!(a & ~sign) && !(b & ~sign))) return b;
+    uint64_t ak = a & sign ? (~a & mask) : a ^ sign;
+    uint64_t bk = b & sign ? (~b & mask) : b ^ sign;
+    return ((ak < bk) == minimum) ? a : b;
+}
+
+static uint32_t get_csr(void) {
+    uint32_t result;
+    __asm__ volatile("stmxcsr %0" : "=m"(result));
+    return result;
+}
+
+static void set_csr(uint32_t value) {
+    __asm__ volatile("ldmxcsr %0" : : "m"(value));
+}
+
+static int signal_at(Program run, const uint8_t *a, const uint8_t *b, const uint8_t *old, uint32_t csr) {
+    pid_t child = fork();
+    if (child < 0) return -1;
+    if (child == 0) {
+        struct rlimit no_core = {0, 0};
+        if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+        _Alignas(32) uint8_t out[64] = {0};
+        run(out, a, b, old, csr);
+        _exit(0);
+    }
+    int status = 0;
+    if (waitpid(child, &status, 0) != child) return -2;
+    if (WIFEXITED(status)) return WEXITSTATUS(status) ? -3 : 0;
+    if (WIFSIGNALED(status) && (WTERMSIG(status) == SIGSEGV || WTERMSIG(status) == SIGBUS)) return 1;
+    if (WIFSIGNALED(status) && WTERMSIG(status) == SIGFPE) return 2;
+    return -4;
+}
+
+static int fault(Program run, const uint8_t *a, const uint8_t *b, const uint8_t *old) {
+    return signal_at(run, a, b, old, 0x1f80);
+}
+
+static void missing_read(uint8_t *out, const uint8_t *a, const uint8_t *b,
+                         const uint8_t *old, uint32_t csr) {
+    (void)out; (void)a; (void)b; (void)old; (void)csr;
+}
+
+static void too_wide(uint8_t *out, const uint8_t *a, const uint8_t *b,
+                     const uint8_t *old, uint32_t csr) {
+    (void)out; (void)a; (void)old; (void)csr;
+    volatile uint64_t result = *(volatile const uint64_t *)b;
+    (void)result;
+}
+
+int main(void) {
+    const uint32_t original_csr = get_csr();
+    long page = sysconf(_SC_PAGESIZE);
+    if (page < 128) return 1;
+    uint8_t *memory = mmap(0, 2 * page, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
+    if (memory == MAP_FAILED || mprotect(memory + page, page, PROT_NONE)) return 2;
+    memset(memory, 0xa5, page);
+    _Alignas(32) uint8_t inputs[3][32];
+    if (fault(missing_read, inputs[0], NULL, inputs[2]) != 0 ||
+        fault(too_wide, inputs[0], memory + page - 4, inputs[2]) != 1) return 3;
+
+    unsigned numerical = 0, faults = 0, exceptions = 0;
+    for (unsigned index = 0; index < sizeof(kernels) / sizeof(kernels[0]); index++) {
+        Kernel k = kernels[index];
+        unsigned bytes = k.bits / 8;
+        const uint64_t *edges = k.bits == 32 ? edges32 : edges64;
+        for (unsigned ai = 0; ai < 16; ai++) for (unsigned bi = 0; bi < 16; bi++) {
+            for (unsigned n = 0; n < 32 / bytes; n++) {
+                uint64_t values[] = {edges[(ai + n) % 16], edges[(bi + 3 * n) % 16],
+                                     edges[(ai + 2 * bi + n + 5) % 16]};
+                for (unsigned v = 0; v < 3; v++) memcpy(inputs[v] + n * bytes, &values[v], bytes);
+            }
+            uint8_t before[sizeof(inputs)];
+            memcpy(before, inputs, sizeof(inputs));
+            for (unsigned controls = 0; controls < 8; controls++) {
+                uint32_t csr = 0x1f80 | ((controls & 1) ? 64 : 0) |
+                               ((controls & 2) ? 0x8000 : 0) | ((controls & 4) ? 63 : 0);
+                uint32_t ambient = 0x1f80 | ((ai & 3) << 13);
+                set_csr(ambient);
+                _Alignas(32) uint8_t original[64] = {0}, translated[64] = {0};
+                k.original(original, inputs[0], inputs[1], inputs[2], csr);
+                if (get_csr() != ambient) return 4;
+                k.translated(translated, inputs[0], inputs[1], inputs[2], csr);
+                uint8_t want[32];
+                memcpy(want, inputs[k.destination], sizeof(want));
+                if (k.carrier == 16) memset(want + 16, 0, 16);
+                if (!k.dead) {
+                    if (!k.legacy) {
+                        memset(want, 0, sizeof(want));
+                        if (k.scalar) memcpy(want, inputs[k.second], 16);
+                    }
+                    unsigned active = k.scalar ? bytes : k.width;
+                    const uint8_t *first = inputs[k.source < 0 ? 1 : k.source];
+                    const uint8_t *second = inputs[k.second];
+                    for (unsigned offset = 0; offset < active; offset += bytes) {
+                        uint64_t value = reference(lane(second + offset, bytes), lane(first + offset, bytes),
+                                                   k.bits, k.minimum, csr);
+                        memcpy(want + offset, &value, bytes);
+                    }
+                }
+                if (memcmp(original, want, 32) || memcmp(translated, original, 48) ||
+                    lane(original + 32, 4) != ambient || lane(original + 40, 4) != 0xc95 ||
+                    (lane(original + 48, 4) & 0xcd5) != 0xc95 ||
+                    lane(original + 44, 4) != csr || get_csr() != ambient ||
+                    memcmp(inputs, before, sizeof(inputs))) {
+                    fprintf(stderr, "MIN/MAX kernel=%u bits=%u width=%u pair=%u/%u controls=%x source=%d second=%d dead=%d\n",
+                            index, k.bits, k.width, ai, bi, csr, k.source, k.second, k.dead);
+                    fprintf(stderr, "original:");
+                    for (unsigned n = 0; n < sizeof(original); n++) fprintf(stderr, " %02x", original[n]);
+                    fprintf(stderr, "\ntranslated:");
+                    for (unsigned n = 0; n < sizeof(translated); n++) fprintf(stderr, " %02x", translated[n]);
+                    fprintf(stderr, "\ninteger reference:");
+                    for (unsigned n = 0; n < sizeof(want); n++) fprintf(stderr, " %02x", want[n]);
+                    fprintf(stderr, "\nambient CSR %x expected %x; inputs changed %d\n", get_csr(), ambient,
+                            memcmp(inputs, before, sizeof(inputs)) != 0);
+                    return 5;
+                }
+                numerical += 2;
+            }
+        }
+        if (k.source < 0) {
+            unsigned width = k.scalar ? bytes : k.width;
+            const uint8_t *addresses[] = {NULL, memory + page - width + 1,
+                                         memory + page - width, memory + page - width - 1, memory + 1};
+            for (unsigned address = 0; address < 5; address++) {
+                int want = address < 2 || (k.legacy && !k.scalar && address >= 3);
+                if (fault(k.original, inputs[0], addresses[address], inputs[2]) != want ||
+                    fault(k.translated, inputs[0], addresses[address], inputs[2]) != want) {
+                    fprintf(stderr, "MIN/MAX fault kernel=%u address=%u width=%u expected=%d\n", index, address, width, want);
+                    return 6;
+                }
+                faults += 2;
+            }
+        }
+        // MIN/MAX signals invalid for both quiet and signaling NaNs. A
+        // denormal input signals unless DAZ is enabled. Dead results retain
+        // the same exception contract; status flags are not pure values.
+        const uint32_t controls[] = {0x1f00, 0x1f00, 0x1e80, 0x1ec0};
+        for (unsigned kind = 0; kind < 4; kind++) {
+            uint64_t value = kind < 2 ? edges[6 + 2 * kind] : 1;
+            for (unsigned v = 0; v < 3; v++) {
+                for (unsigned offset = 0; offset < 32; offset += bytes) {
+                    memcpy(inputs[v] + offset, &value, bytes);
+                }
+            }
+            int want = kind < 3 ? 2 : 0;
+            int original = signal_at(k.original, inputs[0], inputs[1], inputs[2], controls[kind]);
+            int translated = signal_at(k.translated, inputs[0], inputs[1], inputs[2], controls[kind]);
+            if (original != want || translated != want) {
+                fprintf(stderr, "MIN/MAX exception kernel=%u kind=%u expected=%d original=%d translated=%d\n",
+                        index, kind, want, original, translated);
+                return 8;
+            }
+            exceptions += 2;
+        }
+    }
+    set_csr(original_csr);
+    if (munmap(memory, 2 * page)) return 7;
+    printf("%zu MIN/MAX kernels: numerical %u, faults %u, exceptions %u, tripwires 2; failures 0\n",
+           sizeof(kernels) / sizeof(kernels[0]), numerical, faults, exceptions);
+    return 0;
+}
diff --git a/toolchain_test.go b/toolchain_test.go
index 92af9edaf..5e5d92cee 100644
--- a/toolchain_test.go
+++ b/toolchain_test.go
@@ -1,15 +1,14 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
+	"context"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"regexp"
 	"strings"
 	"testing"
+	"time"
 )
 
 func findLlcAndClang(t *testing.T) (llc, clang string, ok bool) {
@@ -23,29 +22,66 @@ func findLlcAndClang(t *testing.T) (llc, clang string, ok bool) {
 var llvm22ToolVersionRE = regexp.MustCompile(`(?im)(?:\bLLVM|\bclang) version 22(?:\.|$)|\bLLD 22(?:\.|$)`)
 
 func findLLVM22Tool(name string) string {
-	var candidates []string
+	bindir := ""
 	if llvmConfig := os.Getenv("LLVM_CONFIG"); llvmConfig != "" {
-		out, err := exec.Command(llvmConfig, "--version").Output()
+		out, err := llvm22ToolOutput(llvmConfig, "--version")
 		if err != nil || !strings.HasPrefix(strings.TrimSpace(string(out)), "22.") {
 			return ""
 		}
-		out, err = exec.Command(llvmConfig, "--bindir").Output()
+		out, err = llvm22ToolOutput(llvmConfig, "--bindir")
 		if err != nil {
 			return ""
 		}
-		candidates = append(candidates, filepath.Join(strings.TrimSpace(string(out)), name))
-	} else {
-		candidates = append(candidates, name+"-22", name)
+		bindir = strings.TrimSpace(string(out))
+		if bindir == "" {
+			return ""
+		}
 	}
-	for _, candidate := range candidates {
+	for _, candidate := range llvm22ToolCandidates(name, bindir) {
 		path, err := exec.LookPath(candidate)
 		if err != nil {
 			continue
 		}
-		out, err := exec.Command(path, "--version").CombinedOutput()
+		out, err := llvm22ToolOutput(path, "--version")
 		if err == nil && llvm22ToolVersionRE.Match(out) {
 			return path
 		}
 	}
 	return ""
 }
+
+func llvm22ToolOutput(executable string, args ...string) ([]byte, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	return runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, executable, args...))
+}
+
+func llvm22ToolCandidates(name, bindir string) []string {
+	var candidates []string
+	if bindir != "" {
+		candidates = append(candidates, filepath.Join(bindir, name))
+		// LLD is a distinct package in several distributions. The configured
+		// LLVM compiler remains authoritative; only linker tools may use an
+		// independently version-checked LLVM 22 installation.
+		switch name {
+		case "wasm-ld", "ld.lld", "ld64.lld", "lld-link":
+			candidates = append(candidates, name+"-22", name,
+				filepath.Join("/opt/homebrew/opt/lld@22/bin", name),
+				filepath.Join("/usr/local/opt/lld@22/bin", name))
+		}
+	} else {
+		candidates = append(candidates, name+"-22", name)
+		// Homebrew keeps versioned LLVM/LLD installations outside PATH. Keep
+		// these explicit candidates version-checked so an unversioned LLVM 23
+		// tool can never become a silent fallback for the LLVM 22 tests.
+		for _, prefix := range []string{
+			"/opt/homebrew/opt/llvm@22/bin",
+			"/opt/homebrew/opt/lld@22/bin",
+			"/usr/local/opt/llvm@22/bin",
+			"/usr/local/opt/lld@22/bin",
+		} {
+			candidates = append(candidates, filepath.Join(prefix, name))
+		}
+	}
+	return candidates
+}
diff --git a/translate.go b/translate.go
index 66d8b5279..19294d979 100644
--- a/translate.go
+++ b/translate.go
@@ -1,10 +1,13 @@
 package plan9asm
 
 import (
+	"errors"
 	"fmt"
 	"regexp"
 	"sort"
 	"strings"
+
+	"github.com/xgo-dev/llvm"
 )
 
 type LLVMType string
@@ -25,6 +28,12 @@ type FuncSig struct {
 	Ret   LLVMType // use Void for void-return
 	Attrs string   // optional function attributes group (e.g. "#0")
 
+	// ARMEntry explicitly selects an address-only physical ARM machine entry.
+	// Args/Frame must be empty and Ret must be Void; those fields describe the
+	// LLVM carrier, not a callable C/Go signature. The checked entry shim alone
+	// supplies its private typed machine-state body. Nil keeps ordinary lowering.
+	ARMEntry *ARMMachineEntry
+
 	// WASMContext is the physical closure-environment parameter carried in
 	// WebAssembly's CTXT pseudo-register. It precedes Args in the LLVM entry but
 	// is not part of the Go function signature, so FrameSlot.Index continues to
@@ -48,12 +57,41 @@ type FuncSig struct {
 	// where helper expects inputs in a custom register assignment.
 	ArgRegs []Reg
 
+	// ARM64GoRegisterABI is an explicit, complete Go ABIInternal register
+	// contract. Nil does not assert a register ABI, even with a classic Frame.
+	// The Go binding derives this only from an actual declaration combined
+	// with an explicit source ABIInternal selector. Manual callers must supply
+	// equivalent evidence. Stack-assigned values are not modeled by this
+	// register-only contract. ArgRegs retains its separate custom ABI meaning.
+	ARM64GoRegisterABI *ARM64GoRegisterABI
+
+	// ARM64ClosureABI is an explicit required hidden carrier. It does not add
+	// an Args element or permit calls which have no matching carrier producer.
+	ARM64ClosureABI *ARM64ClosureABI
+
 	// Frame provides a minimal stack-frame model for resolving name+off(FP)
 	// references in Go/Plan9 assembly into LLVM function args/returns.
 	//
 	// This is intentionally limited to the classic Go assembler convention used
 	// by stdlib .s files (e.g. internal/cpu/cpu_x86.s).
 	Frame FrameLayout
+
+	// Produced from complete actual typed Go callers, never from pointer types
+	// or a manual noalias option. Final normalization independently consumes it.
+	x86CallerRegions *x86GoCallerRegionProof
+	x86FixedLocal    *x86FixedLocalBinding
+	amd64GoArguments *amd64GoArgumentBinding
+
+	// A typed declaration snapshot, not permission to address padding. The
+	// complete original/normalized bit-use proof must independently consume it.
+	arm64FPReadDeclaration   *arm64FPReadDeclaration
+	arm64ABI0Declaration     *arm64ABI0Declaration
+	arm64ABI0TailDeclaration *arm64ABI0TailDeclaration
+	arm64NativeScratch       *arm64ScratchBinding
+
+	// Denial-only provenance: an unresolved 386 bool tail copied its caller's
+	// signature. This is not an independent target declaration or capability.
+	x86BorrowedBoolTail bool
 }
 
 // WASMABI selects the physical ABI used for WebAssembly Plan 9 assembly.
@@ -78,12 +116,42 @@ type FrameSlot struct {
 	Offset int64
 	Type   LLVMType
 	Index  int // index into LLVM function arguments (for Params) or results tuple (for Results)
+	// Name is the source-level Go parameter or result name when available.
+	// It is descriptive metadata, never permission to rewrite the explicit
+	// displacement in a source FP operand.
+	Name string
 	// Field is the index of the extracted field within the argument aggregate.
 	// It is used for classic Go asm slots like b_base+0(FP) when the Go-level
 	// parameter is passed as a struct (string/slice header).
 	//
 	// When Field < 0, the slot refers directly to %arg(Index).
 	Field int
+	// Fields carries a nested extractvalue path for arrays and structs. It is
+	// empty for direct values and one-level aggregates, which continue to use
+	// Field for compatibility with existing callers.
+	Fields []int
+}
+
+func frameSlotFields(slot FrameSlot) []int {
+	if len(slot.Fields) != 0 {
+		return slot.Fields
+	}
+	if slot.Field >= 0 {
+		return []int{slot.Field}
+	}
+	return nil
+}
+
+func frameSlotExtractSuffix(slot FrameSlot) string {
+	fields := frameSlotFields(slot)
+	if len(fields) == 0 {
+		return ""
+	}
+	parts := make([]string, len(fields))
+	for i, field := range fields {
+		parts[i] = fmt.Sprintf("%d", field)
+	}
+	return ", " + strings.Join(parts, ", ")
 }
 
 // X87Mode selects how explicit x87 instructions in 386 Plan 9 assembly are
@@ -106,6 +174,29 @@ func (m X87Mode) valid() bool {
 type Options struct {
 	TargetTriple string
 
+	// X86TLSMoves binds only actual source-encoder NOP effects. It grants no
+	// native TLS address, thread, entry-register, storage or caller contract.
+	X86TLSMoves *GoX86TLSMoveBinding
+
+	// NumericalReads is an opaque live source/object/typed-storage binding.
+	// Only GoX86NumericalReadSource.BindNumericalReads can construct it. It
+	// authorizes its exact scalar reads, never SB addresses, writes or pointers.
+	NumericalReads *GoX86NumericalReadBinding
+
+	// ARM64ByteCarrierSource is an actual sealed original-source owner, not a
+	// FrameLayout or report-derived permission. The bounded private consumer
+	// must independently close native effects and the shared caller backing.
+	ARM64ByteCarrierSource *GoARM64ByteCarrierSource
+
+	// X86TailGroups identifies closed, assembly-only continuation groups. Their
+	// helpers have no callable Go/native entry: the caller must establish that
+	// their addresses are used only for jumps within the group's root. The
+	// group's every indirect JMP must target one of its named helpers. No
+	// helper address may escape to other code or be read as machine-code bytes.
+	// helpers are folded into that root's CFG, preserving its entire machine
+	// state and FP frame. Ordinary TEXT tail calls must not use this option.
+	X86TailGroups []X86TailGroup
+
 	// ResolveSym maps the TEXT symbol (with (SB) trimmed) into the final linker
 	// symbol name to emit in LLVM IR. If nil, the symbol is used as-is.
 	ResolveSym func(sym string) string
@@ -113,7 +204,9 @@ type Options struct {
 	// Sigs maps resolved symbol name -> signature.
 	Sigs map[string]FuncSig
 
-	// Goarch is used for a few arch-specific translations (e.g. x86 CPUID).
+	// Goarch selects Go architecture rules independently of TargetTriple.
+	// An empty value retains the historical amd64 default for ArchAMD64;
+	// 32-bit Go assembly must explicitly select 386.
 	Goarch string
 
 	// WASMABI selects the WebAssembly physical ABI. Its zero value preserves
@@ -128,14 +221,26 @@ type Options struct {
 	// AnnotateSource emits source asm lines as IR comments before lowering each
 	// instruction, for translation debugging.
 	AnnotateSource bool
+
+	// Actual complete Go source before KeepFunc. Private logical CALL lookup;
+	// no source/native permission can be reconstructed through public Options.
+	x86OriginalFile   *File
+	x86BoolCallSource *x86ABI0BoolCallSource
+	goReadOnlyStorage *goReadOnlyStorage
+	// Same-request declarations for ordinary external-tail roots. Public
+	// signature maps cannot recreate the original Go declaration source.
+	goPackage *GoPackage
 }
 
 // Translate converts a parsed Plan 9 asm File into LLVM IR text (`.ll`).
 //
 // The generated text is produced from an llvm.Module to keep textual emission
-// consistent with the LLVM printer.
+// consistent with the LLVM printer. Each text request owns a fresh context and
+// releases its module and context before returning, including failed requests.
 func Translate(file *File, opt Options) (string, error) {
-	mod, err := TranslateModule(file, opt)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod, err := TranslateModuleInContext(ctx, file, opt)
 	if err != nil {
 		return "", err
 	}
@@ -144,24 +249,159 @@ func Translate(file *File, opt Options) (string, error) {
 }
 
 // translateIRText builds textual LLVM IR prior to module parsing.
-func translateIRText(file *File, opt Options) (string, error) {
+func translateIRText(file *File, opt Options) (resultText string, result error) {
+	return translateIRTextWithFixedLocalResult(file, opt, nil)
+}
+
+func translateIRTextWithFixedLocalResult(file *File, opt Options, fixedLocalResult *x86FixedLocalResultSnapshot) (resultText string, result error) {
 	if file == nil {
 		return "", fmt.Errorf("nil file")
 	}
+	if err := opt.goReadOnlyStorage.verify(); err != nil {
+		return "", err
+	}
+	defer func() {
+		if err := opt.goReadOnlyStorage.verify(); err != nil {
+			resultText, result = "", errors.Join(result, err)
+		}
+	}()
+	callOriginal := file
+	if opt.x86OriginalFile != nil {
+		callOriginal = opt.x86OriginalFile
+	}
+	boolCalls := opt.x86BoolCallSource
+	var err error
+	if boolCalls == nil {
+		boolCalls, err = prepareX86ABI0BoolCalls(callOriginal, opt)
+	} else {
+		err = boolCalls.verify()
+	}
+	if err != nil {
+		return "", err
+	}
+	if boolCalls != nil {
+		defer func() {
+			if err := boolCalls.verify(); err != nil {
+				resultText = ""
+				result = errors.Join(result, err)
+			}
+		}()
+	}
+	file, err = PrepareX86DirectTailSource(file, opt)
+	if err != nil {
+		return "", err
+	}
+	if file.x86DirectTails != nil {
+		graph, request := file.x86DirectTails, file
+		defer func() {
+			if err := graph.verify(request, opt); err != nil {
+				resultText = ""
+				result = errors.Join(result, err)
+			}
+		}()
+	}
+	arm64ScratchCalls, err := verifyARM64ScratchBindings(file, opt)
+	if err != nil {
+		return "", err
+	}
+	if len(arm64ScratchCalls) != 0 {
+		original := file
+		defer func() {
+			if _, err := verifyARM64ScratchBindings(original, opt); err != nil {
+				result = fmt.Errorf("%w: late native scratch closure guard: %v", ErrProbeNeedsContext, err)
+			}
+		}()
+	}
+	if file.Arch == ArchAMD64 && opt.Goarch == "" {
+		opt.Goarch = "amd64"
+	}
+	if err := validateARMMachineEntryArchitecture(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateARMWordFloatNativeTarget(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateARM64NativeTargets(file, opt); err != nil {
+		return "", err
+	}
 	if !opt.X87Mode.valid() {
 		return "", fmt.Errorf("invalid x87 mode %d", opt.X87Mode)
 	}
 	if len(file.Funcs) == 0 && len(file.Data) == 0 && len(file.Globl) == 0 {
 		return "", fmt.Errorf("empty file")
 	}
+	if err := validateFileResolvedImmediates(file); err != nil {
+		return "", err
+	}
+	if err := validateX86TLSMoveFile(file, opt.Goarch); err != nil {
+		return "", err
+	}
+	if err := validateX86GPSIMDTransferFile(file, opt.Goarch); err != nil {
+		return "", err
+	}
+	if err := validateX86ScalarLaneFile(file, opt.Goarch); err != nil {
+		return "", err
+	}
+	file, err = normalizeX86RawFile(file, opt.Goarch, opt)
+	if err != nil {
+		return "", err
+	}
+	if err := validateX86ScalarFloatIntegerFile(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateX86PackedConversionFile(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateX86PackedPrecisionFile(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateX86NamedHalfFile(file, opt); err != nil {
+		return "", err
+	}
+	if err := validateX86COMIFile(file, opt); err != nil {
+		return "", err
+	}
+	file, err = normalizeX86SourceIntegerAddresses(file, opt)
+	if err != nil {
+		return "", err
+	}
+	file, err = coalesceX86Continuations(file, opt)
+	if err != nil {
+		return "", err
+	}
+	if graph := file.x86ContinuationGraph; graph != nil {
+		request := file
+		defer func() {
+			if err := graph.verify(request, opt); err != nil {
+				resultText, result = "", errors.Join(result, err)
+			}
+		}()
+	}
+	file, err = prepareARMKernelHelpers(file, opt)
+	if err != nil {
+		return "", err
+	}
+	if err := verifyNormalizedNumericalReads(file, opt); err != nil {
+		return "", err
+	}
 
 	resolve := opt.ResolveSym
 	if resolve == nil {
 		resolve = func(s string) string { return s }
 	}
+	if err := validateARM64ClosureFile(file, opt, resolve); err != nil {
+		return "", err
+	}
+	arm64SourceCalls := captureARM64SourceNoopCalls(file, resolve, opt.Sigs)
+	for symbol, binding := range arm64ScratchCalls {
+		arm64SourceCalls[symbol] = arm64SourceNoopCall{native: binding}
+	}
 	if !opt.WASMABI.valid() {
 		return "", fmt.Errorf("invalid wasm ABI %d", opt.WASMABI)
 	}
+	if err := validateDataRelocations(file, opt.Goarch); err != nil {
+		return "", err
+	}
 	if file.Arch == ArchWASM && opt.WASMABI == WASMABIDirect {
 		for _, fn := range file.Funcs {
 			if !wasmNeedsIncomingContext(fn) {
@@ -185,11 +425,19 @@ func translateIRText(file *File, opt Options) (string, error) {
 	// Keep translate.go as the cross-platform pipeline entry.
 	// Architecture-specific declarations live in arch-specific files.
 	emitArchPrelude(&b, file, resolve, opt.Goarch, opt.WASMABI)
+	lockScalarNamespace := ""
+	bitScanNamespace := ""
+	if file.Arch == ArchAMD64 {
+		lockScalarNamespace = x86LockScalarNamespace(file, opt.Goarch, resolve, opt.Sigs)
+		emitX86LockScalarRMWHelpers(&b, file, opt.Goarch, lockScalarNamespace)
+		bitScanNamespace = x86BitScanNamespace(file, opt.Goarch, resolve, opt.Sigs)
+		emitX86BitScanHelpers(&b, file, opt.Goarch, bitScanNamespace)
+	}
 
-	emitExternSBGlobals(&b, file, resolve, opt.Sigs)
+	emitExternSBGlobals(&b, file, resolve, opt.Sigs, opt.goReadOnlyStorage)
 
 	if len(file.Data) != 0 || len(file.Globl) != 0 {
-		if err := emitDataGlobals(&b, file, resolve); err != nil {
+		if err := emitDataGlobalsWithSigs(&b, file, resolve, opt.Sigs, opt.WASMABI); err != nil {
 			return "", err
 		}
 		b.WriteString("\n")
@@ -198,8 +446,24 @@ func translateIRText(file *File, opt Options) (string, error) {
 	emitExternFuncDecls(&b, file, resolve, opt.Sigs, opt.WASMABI)
 
 	attrRegistry := newFeatureAttrRegistry()
+	// Build the immutable emitted-storage directory once per file. Repeating
+	// the global/signature scan for each TEXT would be quadratic in a corpus.
+	scalarData := x86LoweredScalarDataReads(file, resolve, opt.Sigs, opt.Goarch)
+	staticAddressValues := x86LoweredStaticAddressValues(file, resolve, opt.Sigs, opt.Goarch)
+	shiftLiterals := x86LoweredShiftLiterals(file, resolve, staticAddressValues, opt.Goarch)
+	continuationBudget := &x86ResultFlowBudget{}
 	for i := range file.Funcs {
 		fn := &file.Funcs[i]
+		if file.x86DirectTailHelper(fn.Sym) {
+			continue // Original helper remains a graph node, never an entry.
+		}
+		function := *fn
+		if function.x86ContinuationFlow != nil {
+			function.x86ResultFlowBudget = continuationBudget
+		}
+		if view := file.x86DirectTailView(fn.Sym); view != nil && function.x86FixedLocal == nil {
+			function.x86DirectTailRoot = view
+		}
 		name := resolve(fn.Sym)
 		sig, ok := opt.Sigs[name]
 		if !ok {
@@ -214,35 +478,104 @@ func translateIRText(file *File, opt Options) (string, error) {
 		if sig.Ret == "" {
 			return "", fmt.Errorf("missing return type for %q", name)
 		}
+		if graph := file.x86DirectTails; graph != nil && graph.fixedLocal != nil && sig.x86FixedLocal != nil {
+			if sig.x86FixedLocal.context == nil {
+				return "", goAMD64FrameContext("deferred private root lacks its original context")
+			}
+			if err := sig.x86FixedLocal.context.Err(); err != nil {
+				return "", err
+			}
+			function, err = proveX86FixedLocalRoot(function, sig, graph)
+			if err != nil {
+				return "", err
+			}
+		}
+		if file.Arch == ArchAMD64 && fn.X86RawText != nil {
+			if err := emitX86AddressSensitiveRawText(&b, *fn, sig); err != nil {
+				return "", fmt.Errorf("%s: %w", name, err)
+			}
+			b.WriteString("\n")
+			continue
+		}
+		if file.Arch == ArchAMD64 && amd64IsRelocationAnchor(*fn, sig) {
+			if err := emitX86RelocationAnchor(&b, *fn, sig, resolve, opt.Sigs); err != nil {
+				return "", fmt.Errorf("%s: %w", name, err)
+			}
+			b.WriteString("\n")
+			continue
+		}
 		if err := validateResolvedImmediates(file.Arch, *fn); err != nil {
 			return "", fmt.Errorf("%s: %w", name, err)
 		}
+		if file.Arch == ArchAMD64 {
+			if err := validateAMD64ScalarAddSubFunction(opt.Goarch, *fn); err != nil {
+				return "", fmt.Errorf("%s: %w", name, err)
+			}
+		}
+		sourceSig := sig
+		inferredAttrs := ""
 		if sig.Attrs == "" {
-			sig.Attrs = attrRegistry.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, opt.Goarch, *fn))
+			features := function
+			if function.x86DirectTailRoot != nil {
+				features = function.x86DirectTailRoot.features()
+			}
+			sig.Attrs = attrRegistry.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, opt.Goarch, features))
+			inferredAttrs = sig.Attrs
 		}
-		if file.Arch == ArchARM && funcNeedsARMCFG(*fn) {
+		// ARM is a fully supported target. Always use its architecture-aware CFG
+		// lowerer so even straight-line functions receive the same operand-form
+		// validation; the legacy linear prototype silently accepts unknown forms.
+		if file.Arch == ArchARM {
+			if sig.ARMEntry != nil {
+				if err := translateFuncARMMachineEntry(&b, *fn, sig, resolve, opt.Sigs, opt.TargetTriple, opt.AnnotateSource); err != nil {
+					return "", fmt.Errorf("%s: %w", name, err)
+				}
+				b.WriteString("\n")
+				continue
+			}
 			if err := translateFuncARM(&b, *fn, sig, resolve, opt.Sigs, opt.AnnotateSource); err != nil {
 				return "", fmt.Errorf("%s: %w", name, err)
 			}
 			b.WriteString("\n")
 			continue
 		}
-		if file.Arch == ArchARM64 && funcNeedsARM64CFG(*fn) {
-			if err := translateFuncARM64(&b, *fn, sig, resolve, opt.Sigs, opt.AnnotateSource); err != nil {
+		// Even a tiny MOVD/RET body can replace the caller LR. Every ARM64
+		// function needs the same source-frame and reaching-definition proof;
+		// an opcode whitelist must not select an unchecked prototype.
+		if file.Arch == ArchARM64 {
+			if err := translateFuncARM64WithSourceCallsAndAttrs(&b, *fn, sourceSig, resolve, opt.Sigs, opt.TargetTriple, file.Data, opt.AnnotateSource, arm64SourceCalls, sig.Attrs); err != nil {
 				return "", fmt.Errorf("%s: %w", name, err)
 			}
 			b.WriteString("\n")
 			continue
 		}
-		if file.Arch == ArchAMD64 && (opt.Goarch == "386" || (opt.Goarch == "amd64" && funcNeedsAMD64CFG(*fn))) {
-			if err := translateFuncX86(&b, *fn, sig, resolve, opt.Sigs, opt.Goarch, opt.TargetTriple, opt.X87Mode, opt.AnnotateSource); err != nil {
+		// X86 is fully supported. Always use its architecture-aware CFG lowerer
+		// so straight-line amd64 functions receive the same memory-width and
+		// operand-form semantics as functions containing branches or vector ops.
+		// The old linear prototype could silently reinterpret wide FP-frame stores
+		// as numeric conversions and leave adjacent aggregate result slots unwritten.
+		if file.Arch == ArchAMD64 {
+			if err := translateFuncX86(&b, function, sig, resolve, opt.Sigs, opt.Goarch, opt.TargetTriple, opt.X87Mode, opt.AnnotateSource,
+				x86FunctionSource{
+					goReadOnlyStorage: opt.goReadOnlyStorage,
+					inferredAttrs:     inferredAttrs,
+					fixedLocalResult:  fixedLocalResult,
+					scalarData:        scalarData,
+					shiftLiterals:     shiftLiterals,
+					lockNamespace:     lockScalarNamespace,
+					bitScanNamespace:  bitScanNamespace,
+					boolCalls:         boolCalls,
+					declaration:       sourceSig,
+
+					staticAddressValues: staticAddressValues,
+				}); err != nil {
 				return "", fmt.Errorf("%s: %w", name, err)
 			}
 			b.WriteString("\n")
 			continue
 		}
 		if file.Arch == ArchWASM {
-			if err := translateFuncWASM(&b, *fn, sig, resolve, opt.Sigs, opt.WASMABI, opt.AnnotateSource); err != nil {
+			if err := translateFuncWASM(&b, file, *fn, sig, resolve, opt.Sigs, opt.WASMABI, opt.AnnotateSource); err != nil {
 				return "", fmt.Errorf("%s: %w", name, err)
 			}
 			b.WriteString("\n")
@@ -254,17 +587,38 @@ func translateIRText(file *File, opt Options) (string, error) {
 		b.WriteString("\n")
 	}
 	attrRegistry.emit(&b)
+	if fileUsesX86NonTemporalMetadata(file) {
+		b.WriteString("!0 = !{i32 1}\n\n")
+	}
+	if file.Arch == ArchARM64 {
+		emitUsedARM64Prelude(&b)
+	}
+	if file.Arch == ArchAMD64 && (opt.Goarch == "amd64" || opt.Goarch == "386") {
+		emitUsedAMD64Prelude(&b, opt.Goarch)
+	}
 	return b.String(), nil
 }
 
 func validateResolvedImmediates(arch Arch, fn Func) error {
-	if arch != ArchARM && arch != ArchWASM {
-		return nil
-	}
 	for _, ins := range fn.Instrs {
+		if arch == ArchAMD64 {
+			if err := x86SymbolIndexedControlError(ins); err != nil {
+				return err
+			}
+		}
 		for _, arg := range ins.Args {
-			if arch == ArchARM && arg.Kind == OpImm && arg.ImmRaw != "" {
-				return fmt.Errorf("unresolved symbolic immediate %q", arg.ImmRaw)
+			if arch == ArchAMD64 {
+				if err := validateX86SymbolDisplacement(arg); err != nil {
+					return err
+				}
+			}
+			if err := unresolvedSymbolicImmediateErrorForArch(arg, arch); err != nil {
+				return err
+			}
+			if arch == ArchAMD64 && arg.Kind == OpMem {
+				if err := unresolvedX86MemoryOffsetError(arg.Mem); err != nil {
+					return err
+				}
 			}
 			if arch == ArchWASM && arg.Kind == OpMem && arg.Mem.OffRaw != "" {
 				return fmt.Errorf("unresolved wasm memory offset %q", arg.Mem.OffRaw)
@@ -274,6 +628,78 @@ func validateResolvedImmediates(arch Arch, fn Func) error {
 	return nil
 }
 
+func validateFileResolvedImmediates(file *File) error {
+	if file == nil {
+		return fmt.Errorf("nil file")
+	}
+	if err := validateResolvedGloblSizes(file); err != nil {
+		return err
+	}
+	for _, fn := range file.Funcs {
+		if err := validateResolvedImmediates(file.Arch, fn); err != nil {
+			return fmt.Errorf("%s: %w", fn.Sym, err)
+		}
+	}
+	return nil
+}
+
+func validateResolvedGloblSizes(file *File) error {
+	for _, global := range file.Globl {
+		if global.SizeRaw != "" {
+			return fmt.Errorf("%w: GLOBL %s requires its generated size %q", ErrProbeNeedsContext, global.Sym, global.SizeRaw)
+		}
+		if global.Size < 0 {
+			return fmt.Errorf("GLOBL %s has a negative size", global.Sym)
+		}
+	}
+	return nil
+}
+
+// The parser preserves unresolved expressions for scanners and callers that
+// supply generated headers. A translator must never mistake that marker for
+// its zero-valued Imm field, even when a raw decoder runs before lowering.
+func unresolvedSymbolicImmediateError(op Operand) error {
+	if op.Kind == OpImm && op.ImmRaw != "" {
+		return fmt.Errorf("unresolved symbolic immediate %q", op.ImmRaw)
+	}
+	if op.Kind != OpSym || !strings.HasPrefix(op.Sym, "$") {
+		return nil
+	}
+	address := strings.TrimSpace(strings.TrimPrefix(op.Sym, "$"))
+	if strings.HasSuffix(address, "(SB)") {
+		return nil
+	}
+	if _, _, ok := parseFPAddr(op.Sym); ok {
+		return nil
+	}
+	if memory, matched, err := parseX86SymbolIndexedMemory(address); matched {
+		if err != nil {
+			return err
+		}
+		if strings.HasSuffix(memory.Sym, "(FP)") || strings.HasSuffix(memory.Sym, "(SP)") {
+			return fmt.Errorf("%w: indexed FP/AUTO address needs original frame provenance", ErrProbeNeedsContext)
+		}
+		if _, legacyMemory := parseMem(address); legacyMemory {
+			return nil
+		}
+		return fmt.Errorf("%w: indexed symbol address needs an x86 operand consumer", ErrProbeNeedsContext)
+	}
+	if _, ok := parseMem(address); ok {
+		return nil
+	}
+	return fmt.Errorf("unresolved symbolic immediate %q", op.Sym)
+}
+
+func unresolvedSymbolicImmediateErrorForArch(op Operand, arch Arch) error {
+	if arch == ArchAMD64 && op.Kind == OpSym && strings.HasPrefix(op.Sym, "$") {
+		address := strings.TrimSpace(strings.TrimPrefix(op.Sym, "$"))
+		if memory, matched, err := parseX86SymbolIndexedMemory(address); matched && err == nil && strings.HasSuffix(memory.Sym, "(SB)") {
+			return nil // The final x86 consumer still validates native shape.
+		}
+	}
+	return unresolvedSymbolicImmediateError(op)
+}
+
 func emitExternFuncDecls(b *strings.Builder, file *File, resolve func(string) string, sigs map[string]FuncSig, wasmABI WASMABI) {
 	defined := map[string]bool{}
 	for i := range file.Funcs {
@@ -283,7 +709,7 @@ func emitExternFuncDecls(b *strings.Builder, file *File, resolve func(string) st
 	// Deterministic order for tests/debugging.
 	names := make([]string, 0, len(sigs))
 	for name := range sigs {
-		if defined[name] {
+		if defined[name] || file.isX86Continuation(name, resolve) {
 			continue
 		}
 		names = append(names, name)
@@ -301,6 +727,10 @@ func emitExternFuncDecls(b *strings.Builder, file *File, resolve func(string) st
 		}
 		fmt.Fprintf(b, "declare %s %s(", sig.Ret, llvmGlobal(funcSigSymbol(name, sig)))
 		argIndex := 0
+		if sig.ARM64ClosureABI != nil {
+			fmt.Fprintf(b, "ptr %s", sig.ARM64ClosureABI.llvmAttribute())
+			argIndex++
+		}
 		if sig.WASMContext != "" {
 			b.WriteString(string(sig.WASMContext))
 			argIndex++
@@ -330,7 +760,7 @@ func funcSigSymbol(resolved string, sig FuncSig) string {
 	return resolved
 }
 
-func emitExternSBGlobals(b *strings.Builder, file *File, resolve func(string) string, sigs map[string]FuncSig) {
+func emitExternSBGlobals(b *strings.Builder, file *File, resolve func(string) string, sigs map[string]FuncSig, goStorage ...*goReadOnlyStorage) {
 	resolveSBBase := func(base string) string {
 		base = strings.TrimSpace(base)
 		if base == "" {
@@ -345,6 +775,19 @@ func emitExternSBGlobals(b *strings.Builder, file *File, resolve func(string) st
 	// Collect base symbols of SB refs with numeric offsets. These are almost always
 	// global variables whose address is computed via GEP in the lowering.
 	need := map[string]bool{}
+	numericalExtents := map[string]int64{}
+	if len(goStorage) == 1 && goStorage[0] != nil {
+		for _, object := range goStorage[0].objects {
+			numericalExtents[object.native] = object.size
+		}
+	}
+	for _, sig := range sigs {
+		if binding := sig.x86FixedLocal; binding != nil {
+			for _, object := range binding.globals {
+				numericalExtents[object.native] = object.size
+			}
+		}
+	}
 	defined := map[string]bool{}
 
 	// Anything in DATA/GLOBL will be defined in this module.
@@ -357,21 +800,66 @@ func emitExternSBGlobals(b *strings.Builder, file *File, resolve func(string) st
 	for _, fn := range file.Funcs {
 		defined[resolve(fn.Sym)] = true
 	}
+	for _, d := range file.Data {
+		if d.Addr == "" {
+			continue
+		}
+		base, _, err := dataAddress(d)
+		if err != nil {
+			continue // The relocation grammar gate reports this before emission.
+		}
+		name := resolveDataAddressSymbol(file, base, resolve, sigs)
+		resolved := resolveDataSymbol(base, resolve)
+		if !defined[name] && !defined[resolved] {
+			if !dataAddressIsFunction(file, base, resolve, sigs) {
+				need[name] = true
+			}
+		}
+	}
 
 	for _, fn := range file.Funcs {
 		for _, ins := range fn.Instrs {
+			if cert := ins.x86NumericalRead; cert != nil {
+				if read, _, valid := numericalCertifiedRead(ins, cert.binding.options.Goarch); valid {
+					numericalExtents[read.Variable.NativeName] = read.Variable.Size
+				}
+			}
 			opName := strings.ToUpper(string(ins.Op))
 			for _, arg := range ins.Args {
-				if arg.Kind != OpSym {
+				var s string
+				switch arg.Kind {
+				case OpSym:
+					s = strings.TrimSpace(arg.Sym)
+				case OpMem:
+					s = strings.TrimSpace(arg.Mem.Sym)
+				default:
+					continue
+				}
+				indirect := strings.HasPrefix(s, "*")
+				if indirect {
+					s = strings.TrimSpace(strings.TrimPrefix(s, "*"))
+				}
+				s = strings.TrimSpace(strings.TrimPrefix(s, "$"))
+				if file.Arch == ArchAMD64 {
+					if memory, matched, err := parseX86SymbolIndexedMemory(s); matched {
+						if err != nil {
+							continue // The operand grammar reports this before emission.
+						}
+						s = memory.Sym
+					}
+				}
+				// A grouped PARAM/AUTO reference is not a bare external symbol.
+				// Collect only its named SB base; declaration does not grant
+				// a memory, frame, source-register or control-flow permission.
+				if strings.ContainsAny(s, "()") && !strings.HasSuffix(s, "(SB)") {
 					continue
 				}
-				s := strings.TrimSpace(arg.Sym)
 				base, off, ok := parseSBRef(s)
 				if !ok || base == "" {
 					continue
 				}
 				base = strings.TrimPrefix(base, "$")
-				if off == 0 {
+				if off == 0 && !indirect {
 					// Bare symbol refs are usually global data addresses
 					// (e.g. MOVQ runtime·vdsoGettimeofdaySym(SB), AX). Exclude only
 					// control-flow ops that use symbol operands as branch/call targets.
@@ -397,31 +885,49 @@ func emitExternSBGlobals(b *strings.Builder, file *File, resolve func(string) st
 	if len(need) == 0 {
 		return
 	}
+	names := make([]string, 0, len(need))
 	for name := range need {
-		fmt.Fprintf(b, "%s = external global i8\n", llvmGlobal(name))
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		if extent, found := numericalExtents[name]; found {
+			fmt.Fprintf(b, "%s = external global [%d x i8]\n", llvmGlobal(name), extent)
+		} else {
+			fmt.Fprintf(b, "%s = external global i8\n", llvmGlobal(name))
+		}
 	}
 	b.WriteString("\n")
 }
 
 func emitDataGlobals(b *strings.Builder, file *File, resolve func(string) string) error {
+	return emitDataGlobalsWithSigs(b, file, resolve, nil, WASMABIDirect)
+}
+
+func emitDataGlobalsWithSigs(b *strings.Builder, file *File, resolve func(string) string, sigs map[string]FuncSig, wasmABI WASMABI) error {
+	if err := validateResolvedGloblSizes(file); err != nil {
+		return err
+	}
 	// Merge DATA and GLOBL into resolved symbol -> bytes.
 	type symData struct {
-		size  int64
-		bytes map[int64][]byte // off -> payload
+		size      int64
+		bytes     map[int64][]byte // off -> payload
+		addresses map[int64]DataStmt
+		readOnly  bool
+		local     bool
 	}
 
 	syms := map[string]*symData{}
 
 	resolveData := func(sym string) string {
-		// Heuristic: unqualified plain names in a stdlib .s are package-local.
-		// Reuse ResolveSym's local-name behavior by prefixing a Plan9 middle dot.
-		if strings.Contains(sym, "·") || strings.Contains(sym, "/") || strings.Contains(sym, ".") {
-			return resolve(sym)
-		}
-		return resolve("·" + sym)
+		return resolveAssemblyDataSymbol(sym, resolve)
 	}
 
 	for _, g := range file.Globl {
+		readOnly, err := globlReadOnly(g.Flags)
+		if err != nil {
+			return err
+		}
 		name := resolveData(g.Sym)
 		sd := syms[name]
 		if sd == nil {
@@ -431,6 +937,8 @@ func emitDataGlobals(b *strings.Builder, file *File, resolve func(string) string
 		if g.Size > sd.size {
 			sd.size = g.Size
 		}
+		sd.readOnly = readOnly
+		sd.local = strings.HasSuffix(g.Sym, "<>")
 	}
 
 	for _, d := range file.Data {
@@ -440,15 +948,23 @@ func emitDataGlobals(b *strings.Builder, file *File, resolve func(string) string
 			sd = &symData{bytes: map[int64][]byte{}}
 			syms[name] = sd
 		}
+		sd.local = strings.HasSuffix(d.Sym, "<>")
 		end, err := dataStmtEnd(d)
 		if err != nil {
 			return err
 		}
-		payload, err := dataStmtPayload(d)
-		if err != nil {
-			return err
+		if d.Addr != "" {
+			if sd.addresses == nil {
+				sd.addresses = make(map[int64]DataStmt)
+			}
+			sd.addresses[d.Off] = d
+		} else {
+			payload, err := dataStmtPayload(d)
+			if err != nil {
+				return err
+			}
+			sd.bytes[d.Off] = payload
 		}
-		sd.bytes[d.Off] = payload
 		if end > sd.size {
 			sd.size = end
 		}
@@ -480,14 +996,38 @@ func emitDataGlobals(b *strings.Builder, file *File, resolve func(string) string
 			}
 			copy(buf[off:], p)
 		}
-		align := bestAlign(int64(len(buf)))
-		fmt.Fprintf(b, "%s = constant [%d x i8] %s, align %d\n", llvmGlobal(name), len(buf), llvmI8ArrayInit(buf), align)
+		align := goAssemblyDataAlignment(file.Arch, int64(len(buf)))
+		kind := "global"
+		if sd.readOnly {
+			kind = "constant"
+		}
+		if sd.local {
+			kind = "internal " + kind
+		}
+		if len(sd.addresses) == 0 {
+			fmt.Fprintf(b, "%s = %s [%d x i8] %s, align %d\n", llvmGlobal(name), kind, len(buf), llvmI8ArrayInit(buf), align)
+			continue
+		}
+		if file.Arch == ArchWASM {
+			if err := emitWASMDataRelocations(b, file, name, buf, sd.addresses, resolve, sigs, wasmABI, sd.readOnly, sd.local, align); err != nil {
+				return err
+			}
+			continue
+		}
+		typ, initializer, err := dataRelocationInitializer(file, buf, sd.addresses, resolve, sigs)
+		if err != nil {
+			return err
+		}
+		fmt.Fprintf(b, "%s = %s %s %s, align %d\n", llvmGlobal(name), kind, typ, initializer, align)
+	}
+	if file.Arch == ArchWASM {
+		return emitWASMDataRelocationRoots(b, file, resolve, sigs)
 	}
 	return nil
 }
 
 // Data globals are currently materialized as byte slices and then as LLVM
-// constant arrays. Bound their size so malformed input cannot exhaust the
+// initializer arrays. Bound their size so malformed input cannot exhaust the
 // translator's memory before LLVM sees it. The Go standard library's largest
 // assembly global is only a few KiB.
 const maxDataGlobalSize int64 = 64 << 20
@@ -510,6 +1050,9 @@ func makeDataGlobal(name string, size int64) ([]byte, error) {
 }
 
 func dataStmtPayload(d DataStmt) ([]byte, error) {
+	if d.Addr != "" {
+		return nil, fmt.Errorf("DATA %s: symbol address requires relocation-aware lowering, not a byte placeholder", d.Sym)
+	}
 	if d.Width <= 0 {
 		return nil, fmt.Errorf("DATA %s: invalid width %d", d.Sym, d.Width)
 	}
@@ -582,13 +1125,6 @@ func translateFuncLinear(b *strings.Builder, arch Arch, fn Func, sig FuncSig, an
 	b.WriteString(" {\n")
 	b.WriteString("entry:\n")
 
-	// Fast path: permissive void lowering for marker/stub functions.
-	if sig.Ret == Void {
-		b.WriteString("  ret void\n")
-		b.WriteString("}\n")
-		return nil
-	}
-
 	type ssaVal struct {
 		typ LLVMType
 		val string // either constant ("0") or SSA ("%t1")
@@ -879,10 +1415,10 @@ func translateFuncLinear(b *strings.Builder, arch Arch, fn Func, sig FuncSig, an
 					return ssaVal{typ: I64, val: "0"}, nil
 				}
 				arg := fmt.Sprintf("%%arg%d", idx)
-				if slot.Field >= 0 {
+				if fields := frameSlotFields(slot); len(fields) != 0 {
 					aggTy := sig.Args[idx]
 					name := newTmp()
-					fmt.Fprintf(b, "  %%%s = extractvalue %s %s, %d\n", name, aggTy, arg, slot.Field)
+					fmt.Fprintf(b, "  %%%s = extractvalue %s %s%s\n", name, aggTy, arg, frameSlotExtractSuffix(slot))
 					return ssaVal{typ: slot.Type, val: "%" + name}, nil
 				}
 				return ssaVal{typ: slot.Type, val: arg}, nil
@@ -961,19 +1497,24 @@ func translateFuncLinear(b *strings.Builder, arch Arch, fn Func, sig FuncSig, an
 			continue
 		case OpMRS:
 			// ARM64: MRS <sysreg>, Rn
+			if arch != ArchARM64 {
+				return fmt.Errorf("MRS instruction requires an arm64 architecture")
+			}
+			if len(ins.Args) != 2 {
+				return fmt.Errorf("MRS expects 2 args: %q", ins.Raw)
+			}
 			src, dst := ins.Args[0], ins.Args[1]
 			if src.Kind != OpIdent || dst.Kind != OpReg {
 				return fmt.Errorf("MRS expects ident, reg: %q", ins.Raw)
 			}
-			sysreg := arm64CanonicalSysReg(src.Ident)
-			if v, ok := arm64CompileSafeMRSValue(sysreg); ok {
-				reg[dst.Reg] = ssaVal{typ: I64, val: v}
-				continue
+			sysreg, err := arm64CheckedSystemRegister(src.Ident, true)
+			if err != nil {
+				return err
 			}
 			name := newTmp()
 			// Read system register via inline asm.
 			// Example: call i64 asm "mrs $0, MIDR_EL1", "=r"()
-			fmt.Fprintf(b, "  %%%s = call i64 asm %q, %q()\n", name, "mrs $0, "+sysreg, "=r")
+			fmt.Fprintf(b, "  %%%s = call i64 asm sideeffect %q, %q()\n", name, "mrs $0, "+sysreg, "=r,~{memory}")
 			reg[dst.Reg] = ssaVal{typ: I64, val: "%" + name}
 			continue
 		case OpMOVD:
@@ -1084,9 +1625,14 @@ func translateFuncLinear(b *strings.Builder, arch Arch, fn Func, sig FuncSig, an
 			if err != nil {
 				return err
 			}
-			rhs, err := valueOf(src)
-			if err != nil {
-				return err
+			var rhs ssaVal
+			if (ins.Op == OpADDQ || ins.Op == OpSUBQ) && src.Kind == OpImm {
+				rhs = ssaVal{typ: I64, val: fmt.Sprintf("%d", amd64ScalarAddSubImmediateInt64(src.Imm, 64))}
+			} else {
+				rhs, err = valueOf(src)
+				if err != nil {
+					return err
+				}
 			}
 			lhs, err = emitCast(lhs, I64)
 			if err != nil {
@@ -1194,90 +1740,31 @@ func translateFuncLinear(b *strings.Builder, arch Arch, fn Func, sig FuncSig, an
 				continue
 			}
 
-		case OpCPUID:
-			// x86: CPUID reads EAX/ECX and writes EAX/EBX/ECX/EDX.
-			eax := reg[AX]
-			if eax.typ == "" {
-				z, _ := zero(I32)
-				eax = z
-			} else {
-				var err error
-				eax, err = emitCast(eax, I32)
-				if err != nil {
-					return err
-				}
+		case OpCPUID, OpXGETBV:
+			if arch != ArchAMD64 {
+				return fmt.Errorf("CPU-query instruction requires an x86 architecture")
 			}
-			ecx := reg[CX]
-			if ecx.typ == "" {
-				z, _ := zero(I32)
-				ecx = z
-			} else {
-				var err error
-				ecx, err = emitCast(ecx, I32)
-				if err != nil {
-					return err
-				}
-			}
-			if !isSSA(eax.val) {
-				if err := setReg(AX, eax); err != nil {
-					return err
-				}
-				eax = reg[AX]
+			spec, _, err := x86CPUQueryProperties(ins.Op, ins, "amd64")
+			if err != nil {
+				return err
 			}
-			if !isSSA(ecx.val) {
-				if err := setReg(CX, ecx); err != nil {
-					return err
+			inputs := make([]string, len(spec.inputs))
+			for index, register := range spec.inputs {
+				value := reg[register]
+				if value.typ == "" {
+					value, err = zero(I32)
+				} else {
+					value, err = emitCast(value, I32)
 				}
-				ecx = reg[CX]
-			}
-			call := newTmp()
-			// Return 4x i32 in EAX/EBX/ECX/EDX.
-			fmt.Fprintf(b, "  %%%s = call { i32, i32, i32, i32 } asm sideeffect %q, %q(i32 %s, i32 %s)\n",
-				call,
-				"cpuid",
-				"={ax},={bx},={cx},={dx},{ax},{cx},~{dirflag},~{fpsr},~{flags}",
-				eax.val, ecx.val)
-			ext := func(i int) string {
-				n := newTmp()
-				fmt.Fprintf(b, "  %%%s = extractvalue { i32, i32, i32, i32 } %%%s, %d\n", n, call, i)
-				return "%" + n
-			}
-			reg[AX] = ssaVal{typ: I32, val: ext(0)}
-			reg[BX] = ssaVal{typ: I32, val: ext(1)}
-			reg[CX] = ssaVal{typ: I32, val: ext(2)}
-			reg[DX] = ssaVal{typ: I32, val: ext(3)}
-
-		case OpXGETBV:
-			// x86: XGETBV reads ECX and writes EAX/EDX.
-			ecx := reg[CX]
-			if ecx.typ == "" {
-				z, _ := zero(I32)
-				ecx = z
-			} else {
-				var err error
-				ecx, err = emitCast(ecx, I32)
 				if err != nil {
 					return err
 				}
+				inputs[index] = value.val
+			}
+			outputs := emitX86CPUQuery(b, spec, inputs, newTmp)
+			for index, register := range spec.outputs {
+				reg[register] = ssaVal{typ: I32, val: outputs[index]}
 			}
-			if !isSSA(ecx.val) {
-				if err := setReg(CX, ecx); err != nil {
-					return err
-				}
-				ecx = reg[CX]
-			}
-			call := newTmp()
-			fmt.Fprintf(b, "  %%%s = call { i32, i32 } asm sideeffect %q, %q(i32 %s)\n",
-				call,
-				"xgetbv",
-				"={ax},={dx},{cx},~{dirflag},~{fpsr},~{flags}",
-				ecx.val)
-			eaxN := newTmp()
-			edxN := newTmp()
-			fmt.Fprintf(b, "  %%%s = extractvalue { i32, i32 } %%%s, 0\n", eaxN, call)
-			fmt.Fprintf(b, "  %%%s = extractvalue { i32, i32 } %%%s, 1\n", edxN, call)
-			reg[AX] = ssaVal{typ: I32, val: "%" + eaxN}
-			reg[DX] = ssaVal{typ: I32, val: "%" + edxN}
 
 		case OpRET:
 			// Return value comes either from explicit result slots (name+off(FP))
diff --git a/translate_context_test.go b/translate_context_test.go
new file mode 100644
index 000000000..ed1528aa0
--- /dev/null
+++ b/translate_context_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestTranslateModuleInContextKeepsModuleInCallerContext(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·f(SB),NOSPLIT,$0-0\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for _, annotate := range []bool{false, true} {
+		for i := 0; i < 3; i++ {
+			ctx := llvm.NewContext()
+			mod, err := TranslateModuleInContext(ctx, file, Options{
+				Goarch:         "amd64",
+				TargetTriple:   "x86_64-unknown-linux-gnu",
+				AnnotateSource: annotate,
+				ResolveSym:     func(sym string) string { return strings.TrimPrefix(sym, "·") },
+				Sigs:           map[string]FuncSig{"f": {Name: "f", Ret: Void}},
+			})
+			if err != nil {
+				ctx.Dispose()
+				t.Fatal(err)
+			}
+			if mod.Context() != ctx {
+				mod.Dispose()
+				ctx.Dispose()
+				t.Fatal("module escaped its caller-owned LLVM context")
+			}
+			if err := llvm.VerifyModule(mod, llvm.ReturnStatusAction); err != nil {
+				mod.Dispose()
+				ctx.Dispose()
+				t.Fatal(err)
+			}
+			mod.Dispose()
+			ctx.Dispose()
+		}
+	}
+}
diff --git a/translate_deep_coverage_test.go b/translate_deep_coverage_test.go
index 6d10740b6..8e8eb2371 100644
--- a/translate_deep_coverage_test.go
+++ b/translate_deep_coverage_test.go
@@ -2,6 +2,7 @@ package plan9asm
 
 import (
 	"errors"
+	"regexp"
 	"strings"
 	"testing"
 
@@ -84,20 +85,20 @@ TEXT foo(SB),NOSPLIT,$0-0 // trailing comment
 	}); !changed || !strings.Contains(got, "MOVQ AX, BX") {
 		t.Fatalf("expandInlineMacroCalls() = (%q, %v)", got, changed)
 	}
-	if got, changed := expandIdentMacros("MOVQ VALUE, AX", map[string]ppMacro{"VALUE": {body: "9"}}, []string{"VALUE"}); !changed || got != "MOVQ 9, AX" {
+	if got, changed := expandIdentMacros("MOVQ VALUE, AX", map[string]ppMacro{"VALUE": {body: "9"}}); !changed || got != "MOVQ 9, AX" {
 		t.Fatalf("expandIdentMacros() = (%q, %v)", got, changed)
 	}
-	if got := expandImmExprMacros("MOVQ $(VALUE+1), AX", map[string]ppMacro{"VALUE": {body: "9"}}); got != "MOVQ $(9+1), AX" {
-		t.Fatalf("expandImmExprMacros() = %q", got)
+	if got, changed := expandIdentMacros("MOVQ $(VALUE+1), AX", map[string]ppMacro{"VALUE": {body: "9"}}); !changed || got != "MOVQ $(9+1), AX" {
+		t.Fatalf("expandIdentMacros(immediate expression) = %q, %v", got, changed)
 	}
 	if got := replaceMacroParams("ADDQ a, b", []string{"a", "b"}, []string{"CX", "DX"}); got != "ADDQ CX, DX" {
 		t.Fatalf("replaceMacroParams() = %q", got)
 	}
-	if got := replaceMacroIdents("VALUE+KEEP", map[string]ppMacro{
+	if got, changed := expandIdentMacros("VALUE+KEEP", map[string]ppMacro{
 		"VALUE": {body: "5"},
 		"KEEP":  {body: "AX"},
-	}); got != "5+AX" {
-		t.Fatalf("replaceMacroIdents() = %q", got)
+	}); !changed || got != "5+AX" {
+		t.Fatalf("expandIdentMacros(expression) = %q, %v", got, changed)
 	}
 	if out := expandPPLine("WRAP(AX, BX)", map[string]ppMacro{
 		"WRAP": {body: "PAIR(a, b)", params: []string{"a", "b"}},
@@ -138,6 +139,15 @@ func TestTranslateIRTextCoverage(t *testing.T) {
 			"example.helper": {Name: "example.helper", Args: []LLVMType{I64}, Ret: Void},
 		},
 	}
+	if _, err := translateIRText(file, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unbound external numerical storage did not retain Context: %v", err)
+	}
+	// Preserve the original unbound counterexample above. The independent
+	// successful fixture reads all eight actual same-file numeric bytes;
+	// an unrelated DATA relocation still exercises external declarations.
+	file.Funcs[0].Instrs[1].Args[0].Sym = "tbl(SB)"
+	file.Funcs[0].Instrs[1].Raw = "MOVQ tbl(SB), AX"
+	file.Data = append(file.Data, DataStmt{Sym: "refs", Width: 8, Addr: "other+8(SB)"})
 	ir, err := translateIRText(file, opt)
 	if err != nil {
 		t.Fatalf("translateIRText() error = %v", err)
@@ -199,8 +209,8 @@ func TestTranslateIRTextCoverage(t *testing.T) {
 	}
 	if err := validateResolvedImmediates(ArchAMD64, Func{
 		Instrs: []Instr{{Args: []Operand{{Kind: OpImm, ImmRaw: "$(sym)"}}}},
-	}); err != nil {
-		t.Fatalf("validateResolvedImmediates(amd64) error = %v", err)
+	}); err == nil {
+		t.Fatal("validateResolvedImmediates(amd64) accepted an unresolved constant")
 	}
 
 	var dataIR strings.Builder
@@ -257,14 +267,31 @@ func TestTranslateHelpersCoverage(t *testing.T) {
 		Globl: []GloblStmt{{Sym: "data", Size: 8}},
 		Data:  []DataStmt{{Sym: "data", Off: 0, Width: 8, Value: 1}},
 	}
-	got, err := Translate(file, Options{
+	options := Options{
 		ResolveSym: resolve,
 		Goarch:     "amd64",
 		Sigs: map[string]FuncSig{
 			"example.entry":  {Name: "example.entry", Ret: I64},
 			"example.helper": {Name: "example.helper", Ret: Void},
 		},
-	})
+	}
+	if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("unbound local symbol/call-clobbered AX did not retain Context: %v", err)
+	}
+	// Independent helper-declaration and numeric-data entries: a void call
+	// does not promise to preserve an integer AX result, and data<> is not
+	// the separately defined non-local data object.
+	file.Funcs = []Func{
+		{Sym: "·entry", Instrs: []Instr{file.Funcs[0].Instrs[0], file.Funcs[0].Instrs[2], file.Funcs[0].Instrs[3]}},
+		{Sym: "·readData", Instrs: []Instr{
+			{Op: OpTEXT, Raw: "TEXT ·readData(SB),NOSPLIT,$0-0"},
+			{Op: OpMOVQ, Args: []Operand{{Kind: OpSym, Sym: "data(SB)"}, {Kind: OpReg, Reg: AX}}, Raw: "MOVQ data(SB), AX"},
+			{Op: OpRET, Raw: "RET"},
+		}},
+	}
+	options.Sigs["example.entry"] = FuncSig{Name: "example.entry", Ret: Void}
+	options.Sigs["example.readData"] = FuncSig{Name: "example.readData", Ret: I64}
+	got, err := Translate(file, options)
 	if err != nil {
 		t.Fatalf("Translate() error = %v", err)
 	}
@@ -369,7 +396,7 @@ func TestTranslateModuleDirectAndFallbackCoverage(t *testing.T) {
 		Data:  []DataStmt{{Sym: "blob", Off: 0, Width: 2, Value: 0x2211}},
 		Globl: []GloblStmt{{Sym: "blob", Size: 4}},
 	}
-	mod, err := translateModuleDirect(file, Options{
+	options := Options{
 		ResolveSym: resolve,
 		Goarch:     "amd64",
 		Sigs: map[string]FuncSig{
@@ -385,17 +412,77 @@ func TestTranslateModuleDirectAndFallbackCoverage(t *testing.T) {
 				},
 			},
 		},
-	})
+	}
+	if direct, err := translateModuleDirect(file, options); !errors.Is(err, errDirectModuleUnsupported) {
+		if !direct.IsNil() {
+			direct.Dispose()
+		}
+		t.Fatalf("typed x86 source bypassed complete lowering: %v", err)
+	}
+	if original, err := TranslateModule(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		if !original.IsNil() {
+			original.Dispose()
+		}
+		t.Fatalf("original query fixture acquired a missing scalar ABI0 declaration: %v", err)
+	}
+	// A separately initialized source uses the checked fallback, not the
+	// scalar prototype or its implicit zero-valued registers.
+	initialized := *file
+	initialized.Funcs = append([]Func(nil), file.Funcs...)
+	var instructions []Instr
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == OpTEXT {
+			ins.Raw = "TEXT ·linear(SB),NOSPLIT,$0-8"
+		}
+		if ins.Op == OpCPUID {
+			instructions = append(instructions, Instr{Op: OpMOVL,
+				Args: []Operand{{Kind: OpImm, Imm: 0}, {Kind: OpReg, Reg: CX}}, Raw: "MOVL $0,CX"})
+		}
+		if ins.Op == OpRET {
+			instructions = append(instructions, Instr{Op: OpMOVQ,
+				Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpFP, FPOffset: 0}}, Raw: "MOVQ AX,ret+0(FP)"})
+		}
+		instructions = append(instructions, ins)
+	}
+	initialized.Funcs[0].Instrs = instructions
+	initialized.Funcs[0].ArgSize = 8
+	initializedOptions := options
+	initializedOptions.TargetTriple = "x86_64-unknown-linux-gnu"
+	initializedOptions.Sigs = make(map[string]FuncSig)
+	for name, signature := range options.Sigs {
+		initializedOptions.Sigs[name] = signature
+	}
+	initializedOptions.Sigs["example.linear"] = FuncSig{Name: "example.linear", Ret: I64,
+		Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}
+	mod, err := TranslateModule(&initialized, initializedOptions)
 	if err != nil {
-		t.Fatalf("translateModuleDirect(amd64) error = %v", err)
+		t.Fatalf("TranslateModule(checked initialized amd64 fallback) error = %v", err)
 	}
 	defer mod.Dispose()
 	modIR := mod.String()
 	for _, want := range []string{`@example.linear`, `@example.pair`, `@example.blob`} {
 		if !strings.Contains(modIR, want) {
-			t.Fatalf("missing %q in direct module:\n%s", want, modIR)
+			t.Fatalf("missing %q in checked fallback module:\n%s", want, modIR)
 		}
 	}
+	// Keep an actual independent positive owner for the supported direct
+	// prototype. It neither returns unknown AX nor consumes implicit CPU input.
+	directFile := &File{Arch: ArchAMD64, Funcs: []Func{{Sym: "·direct", Instrs: []Instr{
+		{Op: OpTEXT, Raw: "TEXT ·direct(SB),4,$0-0"},
+		{Op: OpMOVQ, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}, Raw: "MOVQ $1,AX"},
+		{Op: OpRET, Raw: "RET"},
+	}}}}
+	directMod, err := translateModuleDirect(directFile, Options{
+		Goarch: "amd64", ResolveSym: resolve,
+		Sigs: map[string]FuncSig{"example.direct": {Name: "example.direct", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal("independent direct prototype fixture rejected", err)
+	}
+	defer directMod.Dispose()
+	if err := llvm.VerifyModule(directMod, llvm.ReturnStatusAction); err != nil {
+		t.Fatal("direct prototype produced invalid LLVM", err)
+	}
 
 	arm64File := &File{
 		Arch: ArchARM64,
@@ -409,13 +496,21 @@ func TestTranslateModuleDirectAndFallbackCoverage(t *testing.T) {
 			},
 		}},
 	}
-	armMod, err := translateModuleDirect(arm64File, Options{
+	armOptions := Options{
 		ResolveSym: resolve,
 		Goarch:     "arm64",
 		Sigs:       map[string]FuncSig{"example.arm64m": {Name: "example.arm64m", Ret: I64}},
-	})
+	}
+	if direct, err := translateModuleDirect(arm64File, armOptions); err == nil {
+		direct.Dispose()
+		t.Fatal("ARM64 direct prototype bypassed architecture-aware proof")
+	} else if !errors.Is(err, errDirectModuleUnsupported) {
+		t.Fatalf("ARM64 direct path must request checked fallback: %v", err)
+	}
+	armOptions.TargetTriple = "aarch64-unknown-linux-gnu"
+	armMod, err := TranslateModule(arm64File, armOptions)
 	if err != nil {
-		t.Fatalf("translateModuleDirect(arm64) error = %v", err)
+		t.Fatalf("TranslateModule(arm64 checked fallback) error = %v", err)
 	}
 	defer armMod.Dispose()
 	if !strings.Contains(armMod.String(), `@example.arm64m`) {
@@ -433,11 +528,24 @@ func TestTranslateModuleDirectAndFallbackCoverage(t *testing.T) {
 			},
 		}},
 	}
-	fallbackMod, err := TranslateModule(cfgFile, Options{
+	cfgOptions := Options{
 		ResolveSym: resolve,
 		Goarch:     "amd64",
-		Sigs:       map[string]FuncSig{"example.cfg": {Name: "example.cfg", Ret: I64}},
-	})
+		Sigs: map[string]FuncSig{"example.cfg": {Name: "example.cfg", Ret: I64,
+			Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}}}}},
+	}
+	// This positive fallback fixture writes its declared result explicitly;
+	// it does not certify the old prototype's default-zero return behavior.
+	initializedCFG := *cfgFile
+	initializedCFG.Funcs = append([]Func(nil), cfgFile.Funcs...)
+	initializedCFG.Funcs[0].Instrs = append([]Instr(nil), cfgFile.Funcs[0].Instrs[:2]...)
+	initializedCFG.Funcs[0].Instrs = append(initializedCFG.Funcs[0].Instrs,
+		Instr{Op: OpMOVL, Args: []Operand{{Kind: OpImm, Imm: 9}, {Kind: OpReg, Reg: AX}}, Raw: "MOVL $9,AX"},
+		Instr{Op: OpMOVQ, Args: []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpFP, FPOffset: 0}}, Raw: "MOVQ AX,ret+0(FP)"},
+		cfgFile.Funcs[0].Instrs[2])
+	initializedCFG.Funcs[0].ArgSize = 8
+	initializedCFG.Funcs[0].Instrs[0].Raw = "TEXT ·cfg(SB),NOSPLIT,$0-8"
+	fallbackMod, err := TranslateModule(&initializedCFG, cfgOptions)
 	if err != nil {
 		t.Fatalf("TranslateModule(fallback) error = %v", err)
 	}
@@ -580,49 +688,59 @@ func TestTranslateModuleDirectErrorCoverage(t *testing.T) {
 		}
 	}
 
-	ctx := llvm.GlobalContext()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
 	for _, tc := range []struct {
 		name string
+		arch Arch
 		fn   Func
 		sig  FuncSig
 	}{
 		{
 			name: "mrs-arity",
+			arch: ArchARM64,
 			fn:   Func{Sym: "example.bad1", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMRS, Args: []Operand{{Kind: OpIdent, Ident: "MIDR_EL1"}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad1", Ret: I64},
 		},
 		{
 			name: "movd-bad-dst",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad2", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVD, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpIdent, Ident: "label"}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad2", Ret: I64},
 		},
 		{
 			name: "movl-bad-dst",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad3", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVL, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpIdent, Ident: "label"}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad3", Ret: I64},
 		},
 		{
 			name: "addq-bad-dst",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad4", Instrs: []Instr{{Op: OpTEXT}, {Op: OpADDQ, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpIdent, Ident: "label"}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad4", Ret: I64},
 		},
 		{
 			name: "invalid-op-kind",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad5", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVQ, Args: []Operand{{Kind: OpLabel, Sym: "x"}, {Kind: OpReg, Reg: AX}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad5", Ret: I64},
 		},
 		{
 			name: "bad-result-index",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad6", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVQ, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpFP, FPOffset: 8}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad6", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 8, Type: I64, Index: 3}}}},
 		},
 		{
 			name: "bad-fp-read",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad7", Instrs: []Instr{{Op: OpTEXT}, {Op: OpMOVQ, Args: []Operand{{Kind: OpFP, FPOffset: 8}, {Kind: OpReg, Reg: AX}}}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad7", Ret: I64, Frame: FrameLayout{Params: []FrameSlot{{Offset: 8, Type: I64, Index: 9}}}},
 		},
 		{
 			name: "unsupported-insn",
+			arch: ArchAMD64,
 			fn:   Func{Sym: "example.bad8", Instrs: []Instr{{Op: OpTEXT}, {Op: "UNDEF"}, {Op: OpRET}}},
 			sig:  FuncSig{Name: "example.bad8", Ret: I64},
 		},
@@ -630,7 +748,7 @@ func TestTranslateModuleDirectErrorCoverage(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			mod := ctx.NewModule("direct-errors-" + tc.name)
 			defer mod.Dispose()
-			if err := translateFuncLinearModule(mod, ArchAMD64, tc.fn, tc.sig); !errors.Is(err, errDirectModuleUnsupported) {
+			if err := translateFuncLinearModule(mod, tc.arch, tc.fn, tc.sig); !errors.Is(err, errDirectModuleUnsupported) {
 				t.Fatalf("%s error = %v", tc.name, err)
 			}
 		})
@@ -1175,7 +1293,6 @@ func TestTranslateFuncLinearCastAndErrorCoverage(t *testing.T) {
 		}
 		out := b.String()
 		for _, want := range []string{
-			"add i32 0, 0",
 			"call { i32, i32, i32, i32 } asm sideeffect",
 			"call { i32, i32 } asm sideeffect",
 			"zext i32",
@@ -1184,11 +1301,27 @@ func TestTranslateFuncLinearCastAndErrorCoverage(t *testing.T) {
 				t.Fatalf("missing %q in cpux output:\n%s", want, out)
 			}
 		}
+		// The prototype's initial AX/CX values are zero. CPUID replaces CX,
+		// so the following XGETBV must consume that result, not a fabricated
+		// zero or an incidental old temporary-materialization instruction.
+		cpuid := regexp.MustCompile(`(?m)^\s*(%[[:alnum:]_.]+) = call \{ i32, i32, i32, i32 \} asm sideeffect "cpuid", "[^"]*"\(i32 0, i32 0\)`).FindAllStringSubmatch(out, -1)
+		if len(cpuid) != 1 {
+			t.Fatalf("CPUID must consume both prototype zero inputs exactly once:\n%s", out)
+		}
+		cx := regexp.MustCompile(`(?m)^\s*(%[[:alnum:]_.]+) = extractvalue \{ i32, i32, i32, i32 \} `+regexp.QuoteMeta(cpuid[0][1])+`, 2$`).FindAllStringSubmatch(out, -1)
+		if len(cx) != 1 {
+			t.Fatalf("CPUID must retain its actual implicit CX result:\n%s", out)
+		}
+		xgetbv := regexp.MustCompile(`call \{ i32, i32 \} asm sideeffect "xgetbv", "[^"]*"\(i32 `+regexp.QuoteMeta(cx[0][1])+`\)`).FindAllString(out, -1)
+		if len(xgetbv) != 1 {
+			t.Fatalf("XGETBV must consume CPUID's actual CX result exactly once:\n%s", out)
+		}
 	})
 }
 
 func TestTranslateFuncLinearModuleEdgeCoverage(t *testing.T) {
-	ctx := llvm.GlobalContext()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
 
 	t.Run("DirectSuccessAndFallbacks", func(t *testing.T) {
 		mod := ctx.NewModule("direct-edge-success")
@@ -1221,43 +1354,66 @@ func TestTranslateFuncLinearModuleEdgeCoverage(t *testing.T) {
 		}
 	})
 
-	t.Run("DirectCPUXGETBVAndMRS", func(t *testing.T) {
-		mod := ctx.NewModule("direct-edge-cpu-mrs")
-		defer mod.Dispose()
-
-		err := translateFuncLinearModule(mod, ArchARM64, Func{
-			Sym: "example.directcpumrs",
-			Instrs: []Instr{
-				{Op: OpTEXT},
-				{Op: OpMOVD, Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: AX}}, Raw: "MOVD $7, AX"},
-				{Op: OpMOVD, Args: []Operand{{Kind: OpImm, Imm: 11}, {Kind: OpReg, Reg: CX}}, Raw: "MOVD $11, CX"},
+	for _, tc := range []struct {
+		name   string
+		arch   Arch
+		instrs []Instr
+		want   []string
+	}{
+		{
+			name: "DirectCPUXGETBV",
+			arch: ArchAMD64,
+			instrs: []Instr{
+				{Op: OpMOVQ, Args: []Operand{{Kind: OpImm, Imm: 7}, {Kind: OpReg, Reg: AX}}, Raw: "MOVQ $7, AX"},
+				{Op: OpMOVQ, Args: []Operand{{Kind: OpImm, Imm: 11}, {Kind: OpReg, Reg: CX}}, Raw: "MOVQ $11, CX"},
 				{Op: OpCPUID, Raw: "CPUID"},
 				{Op: OpXGETBV, Raw: "XGETBV"},
+			},
+			want: []string{
+				"call { i32, i32, i32, i32 } asm sideeffect \"cpuid\"",
+				"call { i32, i32 } asm sideeffect \"xgetbv\"",
+			},
+		},
+		{
+			name: "DirectMRS",
+			arch: ArchARM64,
+			instrs: []Instr{
 				{Op: OpMRS, Args: []Operand{{Kind: OpIdent, Ident: "MIDR_EL1"}, {Kind: OpReg, Reg: "R0"}}, Raw: "MRS MIDR_EL1, R0"},
 				{Op: OpMRS, Args: []Operand{{Kind: OpIdent, Ident: "TPIDR_EL0"}, {Kind: OpReg, Reg: "R1"}}, Raw: "MRS TPIDR_EL0, R1"},
-				{Op: OpRET},
 			},
-		}, FuncSig{Name: "example.directcpumrs", Ret: I64})
-		if err != nil {
-			t.Fatalf("translateFuncLinearModule(cpu+mrs) error = %v", err)
-		}
+			want: []string{
+				"call i64 asm sideeffect \"mrs $0, S3_3_C13_C0_2\"",
+				"call i64 asm sideeffect \"mrs $0, S3_0_C0_C0_0\"",
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			mod := ctx.NewModule(tc.name)
+			defer mod.Dispose()
 
-		ir := mod.String()
-		for _, want := range []string{
-			"call { i32, i32, i32, i32 } asm sideeffect \"cpuid\"",
-			"call { i32, i32 } asm sideeffect \"xgetbv\"",
-			"call i64 asm \"mrs $0, TPIDR_EL0\"",
-			"ret i64 0",
-		} {
-			if !strings.Contains(ir, want) {
-				t.Fatalf("missing %q in module IR:\n%s", want, ir)
+			instrs := append([]Instr{{Op: OpTEXT}}, tc.instrs...)
+			instrs = append(instrs, Instr{Op: OpRET})
+			err := translateFuncLinearModule(mod, tc.arch, Func{
+				Sym:    "example.directnative",
+				Instrs: instrs,
+			}, FuncSig{Name: "example.directnative", Ret: I64})
+			if err != nil {
+				t.Fatalf("translateFuncLinearModule(%s) error = %v", tc.name, err)
 			}
-		}
-	})
+
+			ir := mod.String()
+			for _, want := range append(tc.want, "ret i64 %") {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("missing %q in module IR:\n%s", want, ir)
+				}
+			}
+		})
+	}
 
 	t.Run("DirectErrors", func(t *testing.T) {
 		cases := []struct {
 			name string
+			arch Arch
 			fn   Func
 			sig  FuncSig
 		}{
@@ -1358,6 +1514,7 @@ func TestTranslateFuncLinearModuleEdgeCoverage(t *testing.T) {
 			},
 			{
 				name: "BadMRSArgs",
+				arch: ArchARM64,
 				fn: Func{
 					Sym:    "badmrs",
 					Instrs: []Instr{{Op: OpTEXT}, {Op: OpMRS, Args: []Operand{{Kind: OpImm, Imm: 1}}, Raw: "MRS $1"}, {Op: OpRET}},
@@ -1366,6 +1523,7 @@ func TestTranslateFuncLinearModuleEdgeCoverage(t *testing.T) {
 			},
 			{
 				name: "BadMRSKinds",
+				arch: ArchARM64,
 				fn: Func{
 					Sym:    "badmrskind",
 					Instrs: []Instr{{Op: OpTEXT}, {Op: OpMRS, Args: []Operand{{Kind: OpImm, Imm: 1}, {Kind: OpReg, Reg: AX}}, Raw: "MRS $1, AX"}, {Op: OpRET}},
@@ -1449,7 +1607,11 @@ func TestTranslateFuncLinearModuleEdgeCoverage(t *testing.T) {
 			t.Run(tc.name, func(t *testing.T) {
 				mod := ctx.NewModule("direct-" + tc.name)
 				defer mod.Dispose()
-				if err := translateFuncLinearModule(mod, ArchAMD64, tc.fn, tc.sig); !errors.Is(err, errDirectModuleUnsupported) {
+				arch := tc.arch
+				if arch == "" {
+					arch = ArchAMD64
+				}
+				if err := translateFuncLinearModule(mod, arch, tc.fn, tc.sig); !errors.Is(err, errDirectModuleUnsupported) {
 					t.Fatalf("translateFuncLinearModule(%s) error = %v", tc.name, err)
 				}
 			})
diff --git a/translate_linear_native_arch_test.go b/translate_linear_native_arch_test.go
new file mode 100644
index 000000000..af1e30e06
--- /dev/null
+++ b/translate_linear_native_arch_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These internal linear consumers predate CFG lowering. Their native opcodes
+// still need a real target architecture; a fabricated mixed-architecture
+// fixture can pass LLVM's IR verifier but cannot produce a machine object.
+func TestTranslateLinearNativeOpcodeArchitectureBoundaries(t *testing.T) {
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64, ArchWASM} {
+		for _, op := range []Op{OpCPUID, OpXGETBV, OpMRS} {
+			for _, api := range []string{"text", "module"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", arch, op, api), func(t *testing.T) {
+					ins := Instr{Op: op, Raw: string(op)}
+					if op == OpMRS {
+						ins.Args = []Operand{{Kind: OpIdent, Ident: "TPIDR_EL0"}, {Kind: OpReg, Reg: "R0"}}
+						ins.Raw = "MRS TPIDR_EL0, R0"
+					}
+					fn := Func{Sym: "native", Instrs: []Instr{ins, {Op: OpRET, Raw: "RET"}}}
+					sig := FuncSig{Name: "native", Ret: Void}
+					var err error
+					var ir string
+					if api == "text" {
+						var output strings.Builder
+						err = translateFuncLinear(&output, arch, fn, sig, false)
+						ir = output.String()
+					} else {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						mod := ctx.NewModule("native-architecture")
+						defer mod.Dispose()
+						err = translateFuncLinearModule(mod, arch, fn, sig)
+						ir = mod.String()
+					}
+					valid := op == OpMRS && arch == ArchARM64 || op != OpMRS && arch == ArchAMD64
+					if (err == nil) != valid {
+						t.Fatalf("native architecture acceptance = %v, valid=%t", err, valid)
+					}
+					if !valid && strings.Contains(ir, "asm sideeffect") {
+						t.Fatal("foreign architecture emitted a native instruction before rejection")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestTranslateLinearNativeOpcodesProduceTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range []struct {
+		arch   Arch
+		triple string
+	}{
+		{ArchAMD64, "x86_64-apple-darwin"},
+		{ArchAMD64, "x86_64-unknown-linux-gnu"},
+		{ArchAMD64, "x86_64-pc-windows-msvc"},
+		{ArchAMD64, "i386-unknown-linux-gnu"},
+		{ArchAMD64, "i686-pc-windows-msvc"},
+		{ArchARM64, "aarch64-apple-darwin"},
+		{ArchARM64, "aarch64-unknown-linux-gnu"},
+		{ArchARM64, "aarch64-pc-windows-msvc"},
+	} {
+		for _, api := range []string{"text", "module"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				instrs := []Instr{{Op: OpCPUID, Raw: "CPUID"}, {Op: OpXGETBV, Raw: "XGETBV"}}
+				if target.arch == ArchARM64 {
+					instrs = []Instr{{
+						Op: OpMRS, Raw: "MRS TPIDR_EL0, R0",
+						Args: []Operand{{Kind: OpIdent, Ident: "TPIDR_EL0"}, {Kind: OpReg, Reg: "R0"}},
+					}}
+				}
+				instrs = append(instrs, Instr{Op: OpRET, Raw: "RET"})
+				fn := Func{Sym: "native", Instrs: instrs}
+				sig := FuncSig{Name: "native", Ret: Void}
+				var ir string
+				if api == "text" {
+					var output strings.Builder
+					if err := translateFuncLinear(&output, target.arch, fn, sig, false); err != nil {
+						t.Fatal(err)
+					}
+					ir = output.String()
+				} else {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					mod := ctx.NewModule("native-object")
+					defer mod.Dispose()
+					if err := translateFuncLinearModule(mod, target.arch, fn, sig); err != nil {
+						t.Fatal(err)
+					}
+					ir = mod.String()
+				}
+				compileLLVMToObject(t, llc, target.triple, "native.ll", "native.o", ir)
+				compileLLVMToObject(t, llc, target.triple, "native-opt.ll", "native-opt.o", x86UndefinedTrapOptimizedIR(t, ir))
+			})
+		}
+	}
+}
diff --git a/translate_module.go b/translate_module.go
index b47932d18..9825db226 100644
--- a/translate_module.go
+++ b/translate_module.go
@@ -3,7 +3,6 @@ package plan9asm
 import (
 	"errors"
 	"fmt"
-	"os"
 
 	"github.com/xgo-dev/llvm"
 )
@@ -12,7 +11,196 @@ import (
 //
 // Caller owns the returned module and should call Dispose when finished.
 func TranslateModule(file *File, opt Options) (llvm.Module, error) {
-	mod, err := translateModuleDirect(file, opt)
+	return TranslateModuleInContext(llvm.GlobalContext(), file, opt)
+}
+
+// TranslateModuleInContext builds the module in a caller-owned LLVM context.
+// Dispose the returned module before disposing ctx. High-volume callers should
+// create a fresh context per file so LLVM can release context-owned caches.
+func TranslateModuleInContext(ctx llvm.Context, file *File, opt Options) (result llvm.Module, resultErr error) {
+	if err := validateBackendSourceGoarch(file, opt); err != nil {
+		return llvm.Module{}, err
+	}
+	// Register first so this also checks early byte-carrier returns, after
+	// every source-owner completion guard. Never return a partial module when
+	// its actual LLVM target cannot represent the emitted operations.
+	defer func() {
+		if result.IsNil() {
+			return
+		}
+		if resultErr == nil && file != nil && file.Arch == ArchARM64 {
+			resultErr = completeARM64SVECountFeatures(result)
+		}
+		if resultErr == nil {
+			resultErr = validateTranslatedBackend(file, opt, result)
+		}
+		if resultErr != nil {
+			result.Dispose()
+			result = llvm.Module{}
+		}
+	}()
+	callOriginal := file
+	if opt.x86OriginalFile != nil {
+		callOriginal = opt.x86OriginalFile
+	}
+	boolCalls := opt.x86BoolCallSource
+	var err error
+	if boolCalls == nil {
+		boolCalls, err = prepareX86ABI0BoolCalls(callOriginal, opt)
+	} else {
+		err = boolCalls.verify()
+	}
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	if boolCalls != nil {
+		opt.x86BoolCallSource = boolCalls
+		defer func() {
+			if err := boolCalls.verify(); err != nil {
+				if !result.IsNil() {
+					result.Dispose()
+				}
+				result = llvm.Module{}
+				resultErr = errors.Join(resultErr, err)
+			}
+		}()
+	}
+	file, err = PrepareX86DirectTailSource(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	if file != nil && file.x86DirectTails != nil {
+		graph, request := file.x86DirectTails, file
+		defer func() {
+			if err := graph.verify(request, opt); err != nil {
+				if !result.IsNil() {
+					result.Dispose()
+				}
+				result = llvm.Module{}
+				resultErr = errors.Join(resultErr, err)
+			}
+		}()
+	}
+	if err := rejectMixedNativeAuthorities(opt.NumericalReads, opt.ARM64ByteCarrierSource); err != nil {
+		return llvm.Module{}, err
+	}
+	if opt.ARM64ByteCarrierSource != nil {
+		return translateARM64ByteCarrierModule(ctx, file, opt)
+	}
+	originalFile, originalOptions := file, opt
+	file, opt, err = freezeTLSMoveInputs(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	defer func() {
+		if err := finishTLSMoves(originalFile, originalOptions); err != nil {
+			if !result.IsNil() {
+				result.Dispose()
+			}
+			result, resultErr = llvm.Module{}, errors.Join(resultErr, err)
+		}
+	}()
+	file, opt, err = freezeNumericalReadInputs(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	defer func() {
+		if err := finishNumericalReads(originalFile, originalOptions); err != nil {
+			if !result.IsNil() {
+				result.Dispose()
+			}
+			result = llvm.Module{}
+			resultErr = errors.Join(resultErr, err)
+		}
+	}()
+	bindings, err := verifyX86FixedLocalBindings(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	file, err = freezeX86FixedLocalFile(file, bindings)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	opt, err = freezeX86FixedLocalOptions(opt, bindings)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	if len(bindings) != 0 {
+		// The actual fixed-local source is independently reparsed, so none of
+		// the earlier certificates survive. Rejoin the current sealed numerical
+		// token by the complete source and exact original instruction ordinal.
+		if err := joinNumericalReadCertificates(file, opt); err != nil {
+			return llvm.Module{}, err
+		}
+	}
+	defer func() {
+		if err := finishX86FixedLocalBindings(bindings); err != nil {
+			if !result.IsNil() {
+				result.Dispose()
+			}
+			result = llvm.Module{}
+			resultErr = errors.Join(resultErr, err)
+		}
+	}()
+	if err := validateARMMachineEntryArchitecture(file, opt); err != nil {
+		return llvm.Module{}, err
+	}
+	if err := validateARMWordFloatNativeTarget(file, opt); err != nil {
+		return llvm.Module{}, err
+	}
+	if err := validateARM64NativeTargets(file, opt); err != nil {
+		return llvm.Module{}, err
+	}
+	resolve := opt.ResolveSym
+	if resolve == nil {
+		resolve = func(symbol string) string { return symbol }
+	}
+	if err := validateARM64ClosureFile(file, opt, resolve); err != nil {
+		return llvm.Module{}, err
+	}
+	if err := validateFileResolvedImmediates(file); err != nil {
+		return llvm.Module{}, err
+	}
+	if err := validateX86TLSMoveFile(file, opt.Goarch); err != nil {
+		return llvm.Module{}, err
+	}
+	if err := validateX86GPSIMDTransferFile(file, opt.Goarch); err != nil {
+		return llvm.Module{}, err
+	}
+	file, err = PrepareGoARM64ABI0TailContinuations(file, opt.Sigs, resolve)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	file, err = normalizeX86RawFile(file, opt.Goarch, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	// The direct emitter may use a derived address view. A textual fallback
+	// must start from the sealed source and derive its own lowering view.
+	sourceForFallback := file
+	file, err = normalizeX86SourceIntegerAddresses(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	file, err = coalesceX86Continuations(file, opt)
+	if err != nil {
+		return llvm.Module{}, err
+	}
+	if graph := file.x86ContinuationGraph; graph != nil {
+		request := file
+		defer func() {
+			if err := graph.verify(request, opt); err != nil {
+				if !result.IsNil() {
+					result.Dispose()
+				}
+				result, resultErr = llvm.Module{}, errors.Join(resultErr, err)
+			}
+		}()
+	}
+	if err := verifyNormalizedNumericalReads(file, opt); err != nil {
+		return llvm.Module{}, err
+	}
+	mod, err := translateModuleDirectInContext(ctx, file, opt)
 	if err == nil {
 		return finishTranslatedModule(file, mod)
 	}
@@ -20,11 +208,21 @@ func TranslateModule(file *File, opt Options) (llvm.Module, error) {
 		return llvm.Module{}, err
 	}
 
-	ir, err := translateIRText(file, opt)
+	var fixedLocalResult *x86FixedLocalResultSnapshot
+	if len(bindings) == 1 {
+		// Share only pure original-source calculations within this call. The
+		// live module completion guard above still runs after every consumer.
+		// freezeX86FixedLocalFile already rejects multiple source owners.
+		fixedLocalResult, err = newX86FixedLocalResultSnapshot(bindings[0], opt.Goarch)
+		if err != nil {
+			return llvm.Module{}, err
+		}
+	}
+	ir, err := translateIRTextWithFixedLocalResult(sourceForFallback, opt, fixedLocalResult)
 	if err != nil {
 		return llvm.Module{}, err
 	}
-	mod, err = parseIRModule(ir)
+	mod, err = parseIRModuleInContext(ctx, ir)
 	if err != nil {
 		return llvm.Module{}, err
 	}
@@ -52,24 +250,13 @@ func finishTranslatedModule(file *File, mod llvm.Module) (llvm.Module, error) {
 }
 
 func parseIRModule(ir string) (llvm.Module, error) {
-	f, err := os.CreateTemp("", "plan9asm-*.ll")
-	if err != nil {
-		return llvm.Module{}, fmt.Errorf("create temp ir file: %w", err)
-	}
-	name := f.Name()
-	_ = f.Close()
-	defer os.Remove(name)
+	return parseIRModuleInContext(llvm.GlobalContext(), ir)
+}
 
-	if err := os.WriteFile(name, []byte(ir), 0644); err != nil {
-		return llvm.Module{}, fmt.Errorf("write temp ir file: %w", err)
-	}
-	buf, err := llvm.NewMemoryBufferFromFile(name)
-	if err != nil {
-		return llvm.Module{}, fmt.Errorf("open temp ir file: %w", err)
-	}
-	// NOTE: do not dispose MemoryBuffer here. In this llvm binding, ParseIR
-	// may take ownership and disposing the buffer can crash.
-	ctx := llvm.GlobalContext()
+func parseIRModuleInContext(ctx llvm.Context, ir string) (llvm.Module, error) {
+	buf := llvmIRMemoryBuffer(ir)
+	// LLVM22 ParseIR consumes this buffer on both success and error. The caller
+	// still owns a successful module and must dispose it before its context.
 	mod, err := (&ctx).ParseIR(buf)
 	if err != nil {
 		return llvm.Module{}, fmt.Errorf("parse generated ir: %w", err)
diff --git a/translate_module_direct.go b/translate_module_direct.go
index f9e56ab8e..d5f4dce65 100644
--- a/translate_module_direct.go
+++ b/translate_module_direct.go
@@ -20,22 +20,31 @@ type directValue struct {
 }
 
 func translateModuleDirect(file *File, opt Options) (llvm.Module, error) {
+	return translateModuleDirectInContext(llvm.GlobalContext(), file, opt)
+}
+
+func translateModuleDirectInContext(ctx llvm.Context, file *File, opt Options) (llvm.Module, error) {
 	if file == nil {
 		return llvm.Module{}, fmt.Errorf("nil file")
 	}
+	if len(file.x86Continuations) != 0 || file.x86DirectTails != nil {
+		return llvm.Module{}, directUnsupportedf("x86 continuations require shared CFG lowering")
+	}
 	if len(file.Funcs) == 0 && len(file.Data) == 0 && len(file.Globl) == 0 {
 		return llvm.Module{}, fmt.Errorf("empty file")
 	}
 	if opt.AnnotateSource {
 		return llvm.Module{}, directUnsupportedf("source annotation requires textual lowering")
 	}
+	if err := validateDataRelocations(file, opt.Goarch); err != nil {
+		return llvm.Module{}, err
+	}
 
 	resolve := opt.ResolveSym
 	if resolve == nil {
 		resolve = func(s string) string { return s }
 	}
 
-	ctx := llvm.GlobalContext()
 	mod := ctx.NewModule("plan9asm")
 	if opt.TargetTriple != "" {
 		mod.SetTarget(opt.TargetTriple)
@@ -50,6 +59,10 @@ func translateModuleDirect(file *File, opt Options) (llvm.Module, error) {
 
 	for i := range file.Funcs {
 		fn := &file.Funcs[i]
+		if fn.X86RawText != nil {
+			mod.Dispose()
+			return llvm.Module{}, directUnsupportedf("address-sensitive x86 raw TEXT requires textual lowering for %s", fn.Sym)
+		}
 		name := resolve(fn.Sym)
 		sig, ok := opt.Sigs[name]
 		if !ok {
@@ -67,22 +80,63 @@ func translateModuleDirect(file *File, opt Options) (llvm.Module, error) {
 			mod.Dispose()
 			return llvm.Module{}, fmt.Errorf("missing return type for %q", name)
 		}
+		if sig.amd64GoArguments != nil {
+			mod.Dispose()
+			return llvm.Module{}, directUnsupportedf("typed AMD64 Go arguments require shared whole-source CFG lowering for %s", name)
+		}
 		if err := validateResolvedImmediates(file.Arch, *fn); err != nil {
 			mod.Dispose()
 			return llvm.Module{}, directUnsupportedf("%s: %v", name, err)
 		}
-		if file.Arch == ArchARM && funcNeedsARMCFG(*fn) {
+		if file.Arch == ArchAMD64 {
+			if err := validateAMD64ScalarAddSubFunction(opt.Goarch, *fn); err != nil {
+				mod.Dispose()
+				return llvm.Module{}, fmt.Errorf("%s: %w", name, err)
+			}
+		}
+		if file.Arch == ArchARM {
 			mod.Dispose()
 			return llvm.Module{}, directUnsupportedf("arm CFG lowering required for %s", name)
 		}
-		if file.Arch == ArchARM64 && funcNeedsARM64CFG(*fn) {
+		if file.Arch == ArchARM64 {
 			mod.Dispose()
 			return llvm.Module{}, directUnsupportedf("arm64 CFG lowering required for %s", name)
 		}
-		if file.Arch == ArchAMD64 && (opt.Goarch == "386" || (opt.Goarch == "amd64" && funcNeedsAMD64CFG(*fn))) {
+		if file.Arch == ArchAMD64 && fn.x86SourceStack != nil && sig.Ret == I1 {
+			mod.Dispose()
+			return llvm.Module{}, directUnsupportedf("physical bool source-stack requires complete CFG lowering for %s", name)
+		}
+		if file.Arch == ArchAMD64 && x86MixedBoolResultNeedsCanonicalRole(sig, sig.Frame.Results) {
+			mod.Dispose()
+			return llvm.Module{}, directUnsupportedf("mixed bool result requires complete canonical role checking for %s", name)
+		}
+		if file.Arch == ArchAMD64 {
+			arch := opt.Goarch
+			if arch == "" {
+				arch = "amd64" // Match the existing textual default without changing sealed Options.
+			}
+			if x86ABI0BoolResultNeedsProof(sig, arch) {
+				mod.Dispose()
+				return llvm.Module{}, directUnsupportedf("ABI0 bool result requires complete canonical byte checking for %s", name)
+			}
+			if x86IntegerFPByteMovesNeedCFG(*fn, sig, arch) || x86TypedFPResultNeedsProof(*fn, sig, arch) {
+				mod.Dispose()
+				return llvm.Module{}, directUnsupportedf("integer FP byte views require shared complete source lowering for %s", name)
+			}
+		}
+		if file.Arch == ArchAMD64 && (opt.Goarch == "386" || (opt.Goarch == "amd64" &&
+			(funcNeedsAMD64CFG(*fn) || x86RegisterBoolResultNeedsProof(*fn, sig, opt.Goarch)))) {
 			mod.Dispose()
 			return llvm.Module{}, directUnsupportedf("x86 CFG lowering required for %s", name)
 		}
+		if file.Arch == ArchAMD64 {
+			for _, ins := range fn.Instrs {
+				if x86ResultCallerAddressDifferenceNeedsProof(ins, sig, opt.Goarch) {
+					mod.Dispose()
+					return llvm.Module{}, directUnsupportedf("x86 complete caller-origin proof required for %s", name)
+				}
+			}
+		}
 		if file.Arch == ArchWASM {
 			mod.Dispose()
 			return llvm.Module{}, directUnsupportedf("wasm stack lowering required for %s", name)
@@ -278,8 +332,11 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 				return directValue{}, directUnsupportedf("FP slot %s invalid arg index %d", op.String(), slot.Index)
 			}
 			arg := args[slot.Index]
-			if slot.Field >= 0 {
-				ev := b.CreateExtractValue(arg, slot.Field, "")
+			if fields := frameSlotFields(slot); len(fields) != 0 {
+				ev := arg
+				for _, field := range fields {
+					ev = b.CreateExtractValue(ev, field, "")
+				}
 				return directValue{typ: slot.Type, val: ev}, nil
 			}
 			return directValue{typ: slot.Type, val: arg}, nil
@@ -305,6 +362,9 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 		case OpBYTE, OpWORD:
 			continue
 		case OpMRS:
+			if arch != ArchARM64 {
+				return fmt.Errorf("MRS instruction requires an arm64 architecture")
+			}
 			if len(ins.Args) != 2 {
 				return directUnsupportedf("MRS expects 2 args")
 			}
@@ -313,16 +373,12 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 				return directUnsupportedf("MRS expects ident, reg: %q", ins.Raw)
 			}
 			i64Ty, _ := llvmTypeFromLLVMType(ctx, I64)
-			sysreg := arm64CanonicalSysReg(src.Ident)
-			if v, ok := arm64CompileSafeMRSValue(sysreg); ok {
-				if v != "0" {
-					return directUnsupportedf("unexpected compile-safe MRS value %q", v)
-				}
-				reg[dst.Reg] = directValue{typ: I64, val: llvm.ConstInt(i64Ty, 0, false)}
-				continue
+			sysreg, err := arm64CheckedSystemRegister(src.Ident, true)
+			if err != nil {
+				return err
 			}
 			asmTy := llvm.FunctionType(i64Ty, nil, false)
-			asmv := llvm.InlineAsm(asmTy, "mrs $0, "+sysreg, "=r", false, false, llvm.InlineAsmDialectATT, false)
+			asmv := llvm.InlineAsm(asmTy, "mrs $0, "+sysreg, "=r,~{memory}", true, false, llvm.InlineAsmDialectATT, false)
 			callv := b.CreateCall(asmTy, asmv, nil, "")
 			reg[dst.Reg] = directValue{typ: I64, val: callv}
 		case OpMOVD, OpMOVQ:
@@ -353,6 +409,9 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 				return directUnsupportedf("MOVL expects 2 args")
 			}
 			src, dst := ins.Args[0], ins.Args[1]
+			if dst.Kind == OpFP && (src.Kind == OpFP || src.Kind == OpMem || src.Kind == OpSym) {
+				return fmt.Errorf("x86 MOVL does not allow memory-to-result-memory: %q", ins.Raw)
+			}
 			v, err := valueOf(src)
 			if err != nil {
 				return err
@@ -383,9 +442,19 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 			if err != nil {
 				return err
 			}
-			rhs, err := valueOf(src)
-			if err != nil {
-				return err
+			var rhs directValue
+			if (ins.Op == OpADDQ || ins.Op == OpSUBQ) && src.Kind == OpImm {
+				i64Ty, typeErr := llvmTypeFromLLVMType(ctx, I64)
+				if typeErr != nil {
+					return typeErr
+				}
+				normalized := amd64ScalarAddSubImmediateInt64(src.Imm, 64)
+				rhs = directValue{typ: I64, val: llvm.ConstInt(i64Ty, uint64(normalized), true)}
+			} else {
+				rhs, err = valueOf(src)
+				if err != nil {
+					return err
+				}
 			}
 			lhs, err = cast(lhs, I64)
 			if err != nil {
@@ -405,82 +474,46 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 				out = b.CreateXor(lhs.val, rhs.val, "")
 			}
 			reg[dst.Reg] = directValue{typ: I64, val: out}
-		case OpCPUID:
-			eax, ok := reg[AX]
-			if !ok {
-				var zerr error
-				eax, zerr = zero(I32)
-				if zerr != nil {
-					return zerr
-				}
-			} else {
-				var cerr error
-				eax, cerr = cast(eax, I32)
-				if cerr != nil {
-					return cerr
-				}
+		case OpCPUID, OpXGETBV:
+			if arch != ArchAMD64 {
+				return fmt.Errorf("CPU-query instruction requires an x86 architecture")
 			}
-			ecx, ok := reg[CX]
-			if !ok {
-				var zerr error
-				ecx, zerr = zero(I32)
-				if zerr != nil {
-					return zerr
-				}
-			} else {
-				var cerr error
-				ecx, cerr = cast(ecx, I32)
-				if cerr != nil {
-					return cerr
-				}
+			spec, _, err := x86CPUQueryProperties(ins.Op, ins, "amd64")
+			if err != nil {
+				return err
 			}
-			i32Ty, _ := llvmTypeFromLLVMType(ctx, I32)
-			retTy := ctx.StructType([]llvm.Type{i32Ty, i32Ty, i32Ty, i32Ty}, false)
-			asmTy := llvm.FunctionType(retTy, []llvm.Type{i32Ty, i32Ty}, false)
-			asmv := llvm.InlineAsm(
-				asmTy,
-				"cpuid",
-				"={ax},={bx},={cx},={dx},{ax},{cx},~{dirflag},~{fpsr},~{flags}",
-				true,
-				false,
-				llvm.InlineAsmDialectATT,
-				false,
-			)
-			callv := b.CreateCall(asmTy, asmv, []llvm.Value{eax.val, ecx.val}, "")
-			reg[AX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 0, "")}
-			reg[BX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 1, "")}
-			reg[CX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 2, "")}
-			reg[DX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 3, "")}
-		case OpXGETBV:
-			ecx, ok := reg[CX]
-			if !ok {
-				var zerr error
-				ecx, zerr = zero(I32)
-				if zerr != nil {
-					return zerr
+			inputs := make([]llvm.Value, len(spec.inputs))
+			for index, register := range spec.inputs {
+				value, exists := reg[register]
+				if !exists {
+					value, err = zero(I32)
+				} else {
+					value, err = cast(value, I32)
 				}
-			} else {
-				var cerr error
-				ecx, cerr = cast(ecx, I32)
-				if cerr != nil {
-					return cerr
+				if err != nil {
+					return err
 				}
+				inputs[index] = value.val
+			}
+			i32Type, err := llvmTypeFromLLVMType(ctx, I32)
+			if err != nil {
+				return err
+			}
+			outputTypes := make([]llvm.Type, len(spec.outputs))
+			for index := range outputTypes {
+				outputTypes[index] = i32Type
+			}
+			inputTypes := make([]llvm.Type, len(spec.inputs))
+			for index := range inputTypes {
+				inputTypes[index] = i32Type
+			}
+			asmType := llvm.FunctionType(ctx.StructType(outputTypes, false), inputTypes, false)
+			assembly := llvm.InlineAsm(asmType, spec.native, spec.constraints(),
+				true, false, llvm.InlineAsmDialectATT, false)
+			call := b.CreateCall(asmType, assembly, inputs, "")
+			for index, register := range spec.outputs {
+				reg[register] = directValue{typ: I32, val: b.CreateExtractValue(call, index, "")}
 			}
-			i32Ty, _ := llvmTypeFromLLVMType(ctx, I32)
-			retTy := ctx.StructType([]llvm.Type{i32Ty, i32Ty}, false)
-			asmTy := llvm.FunctionType(retTy, []llvm.Type{i32Ty}, false)
-			asmv := llvm.InlineAsm(
-				asmTy,
-				"xgetbv",
-				"={ax},={dx},{cx},~{dirflag},~{fpsr},~{flags}",
-				true,
-				false,
-				llvm.InlineAsmDialectATT,
-				false,
-			)
-			callv := b.CreateCall(asmTy, asmv, []llvm.Value{ecx.val}, "")
-			reg[AX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 0, "")}
-			reg[DX] = directValue{typ: I32, val: b.CreateExtractValue(callv, 1, "")}
 		case OpRET:
 			switch {
 			case retTyFn == Void:
@@ -549,18 +582,31 @@ func translateFuncLinearModule(mod llvm.Module, arch Arch, fn Func, sig FuncSig)
 }
 
 func emitDataGlobalsModule(mod llvm.Module, file *File, resolve func(string) string) error {
+	if err := validateResolvedGloblSizes(file); err != nil {
+		return err
+	}
+	for _, data := range file.Data {
+		if data.Addr != "" {
+			// The shared textual route emits real packed relocation constants.
+			// Fall back before adding any partially initialized globals.
+			return directUnsupportedf("DATA symbol addresses require relocation-aware constants")
+		}
+	}
 	type symData struct {
-		size  int64
-		bytes map[int64][]byte
+		size     int64
+		bytes    map[int64][]byte
+		readOnly bool
+		local    bool
 	}
 	syms := map[string]*symData{}
 	resolveData := func(sym string) string {
-		if strings.Contains(sym, "·") || strings.Contains(sym, "/") || strings.Contains(sym, ".") {
-			return resolve(sym)
-		}
-		return resolve("·" + sym)
+		return resolveAssemblyDataSymbol(sym, resolve)
 	}
 	for _, g := range file.Globl {
+		readOnly, err := globlReadOnly(g.Flags)
+		if err != nil {
+			return err
+		}
 		name := resolveData(g.Sym)
 		sd := syms[name]
 		if sd == nil {
@@ -570,6 +616,8 @@ func emitDataGlobalsModule(mod llvm.Module, file *File, resolve func(string) str
 		if g.Size > sd.size {
 			sd.size = g.Size
 		}
+		sd.readOnly = readOnly
+		sd.local = strings.HasSuffix(g.Sym, "<>")
 	}
 	for _, d := range file.Data {
 		name := resolveData(d.Sym)
@@ -578,6 +626,7 @@ func emitDataGlobalsModule(mod llvm.Module, file *File, resolve func(string) str
 			sd = &symData{bytes: map[int64][]byte{}}
 			syms[name] = sd
 		}
+		sd.local = strings.HasSuffix(d.Sym, "<>")
 		end, err := dataStmtEnd(d)
 		if err != nil {
 			return err
@@ -620,8 +669,11 @@ func emitDataGlobalsModule(mod llvm.Module, file *File, resolve func(string) str
 		init := llvm.ConstArray(i8Ty, elems)
 		g := llvm.AddGlobal(mod, arrTy, name)
 		g.SetInitializer(init)
-		g.SetGlobalConstant(true)
-		g.SetAlignment(int(bestAlign(int64(len(buf)))))
+		g.SetGlobalConstant(sd.readOnly)
+		if sd.local {
+			g.SetLinkage(llvm.InternalLinkage)
+		}
+		g.SetAlignment(int(goAssemblyDataAlignment(file.Arch, int64(len(buf)))))
 	}
 	return nil
 }
diff --git a/translate_prelude.go b/translate_prelude.go
index 57bb4ee17..ef8b4c8f0 100644
--- a/translate_prelude.go
+++ b/translate_prelude.go
@@ -1,18 +1,21 @@
 package plan9asm
 
-import "strings"
+import (
+	"fmt"
+	"strings"
+)
 
 func emitArchPrelude(b *strings.Builder, file *File, resolve func(string) string, goarch string, wasmABI WASMABI) {
 	switch file.Arch {
 	case ArchARM:
 		emitARMPrelude(b)
 	case ArchARM64:
-		emitARM64Prelude(b)
+		// Emit only referenced declarations after lowering the complete body.
 	case ArchAMD64:
 		// Keep historical gating to avoid injecting x86-only prelude when
 		// parsing x86 syntax for unrelated targets in tests.
 		if goarch == "amd64" || goarch == "386" {
-			emitAMD64Prelude(b, goarch, file)
+			emitAMD64SourcePrelude(b, file, goarch)
 		}
 	case ArchWASM:
 		emitWASMPrelude(b, file, resolve, wasmABI)
@@ -43,15 +46,22 @@ func emitWASMPrelude(b *strings.Builder, file *File, resolve func(string) string
 		b.WriteString("\n")
 	}
 	want := make(map[string]bool)
+	wantFloatUnary := make(map[string]bool)
+	wantFloatBinary := make(map[string]bool)
+	wantIntegerCount := make(map[string]bool)
 	for _, fn := range file.Funcs {
 		for _, ins := range fn.Instrs {
-			switch normalizeInstructionOpcode(ins.Op) {
-			case "F64FLOOR":
-				want["floor"] = true
-			case "F64CEIL":
-				want["ceil"] = true
-			case "F64TRUNC":
-				want["trunc"] = true
+			op := normalizeInstructionOpcode(ins.Op)
+			if spec, ok := wasmIntegerCountOps[op]; ok {
+				wantIntegerCount[spec.intrinsic+"."+string(spec.typ)] = true
+			}
+			if spec, ok := wasmFloatUnaryOps[op]; ok && spec.intrinsic != "" {
+				wantFloatUnary[string(spec.typ)+"|"+spec.intrinsic] = true
+			}
+			if spec, ok := wasmFloatBinaryOps[op]; ok && spec.intrinsic != "" {
+				wantFloatBinary[string(spec.typ)+"|"+spec.intrinsic] = true
+			}
+			switch op {
 			case "MEMORYCOPY":
 				want["memmove"] = true
 			case "MEMORYFILL":
@@ -66,6 +76,18 @@ func emitWASMPrelude(b *strings.Builder, file *File, resolve func(string) string
 	if want["memmove"] {
 		b.WriteString("declare void @llvm.memmove.p0.p0.i32(ptr, ptr, i32, i1 immarg)\n")
 	}
+	for _, typ := range []LLVMType{I32, I64} {
+		for _, intrinsic := range []string{"ctlz", "cttz", "ctpop"} {
+			name := intrinsic + "." + string(typ)
+			if wantIntegerCount[name] {
+				fmt.Fprintf(b, "declare %s @llvm.%s(%s", typ, name, typ)
+				if intrinsic != "ctpop" {
+					b.WriteString(", i1 immarg")
+				}
+				b.WriteString(")\n")
+			}
+		}
+	}
 	if want["memset"] {
 		b.WriteString("declare void @llvm.memset.p0.i32(ptr, i8, i32, i1 immarg)\n")
 	}
@@ -75,12 +97,23 @@ func emitWASMPrelude(b *strings.Builder, file *File, resolve func(string) string
 	if want["memory.grow"] {
 		b.WriteString("declare i32 @llvm.wasm.memory.grow.i32(i32, i32)\n")
 	}
-	for _, name := range []string{"floor", "ceil", "trunc"} {
-		if want[name] {
-			b.WriteString("declare double @llvm." + name + ".f64(double)\n")
+	for _, typ := range []LLVMType{LLVMType("float"), LLVMType("double")} {
+		bits := "32"
+		if typ == LLVMType("double") {
+			bits = "64"
+		}
+		for _, name := range []string{"fabs", "ceil", "floor", "trunc", "roundeven", "sqrt"} {
+			if wantFloatUnary[string(typ)+"|"+name] {
+				fmt.Fprintf(b, "declare %s @llvm.%s.f%s(%s)\n", typ, name, bits, typ)
+			}
+		}
+		for _, name := range []string{"minimum", "maximum"} {
+			if wantFloatBinary[string(typ)+"|"+name] {
+				fmt.Fprintf(b, "declare %s @llvm.%s.f%s(%s, %s)\n", typ, name, bits, typ, typ)
+			}
 		}
 	}
-	if len(want) != 0 {
+	if len(want) != 0 || len(wantFloatUnary) != 0 || len(wantFloatBinary) != 0 {
 		b.WriteString("\n")
 	}
 }
diff --git a/translate_text_context_test.go b/translate_text_context_test.go
new file mode 100644
index 000000000..fcdb2fce9
--- /dev/null
+++ b/translate_text_context_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+)
+
+func TestTranslateTextOwnsRequestLLVMContext(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "translate.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != "Translate" {
+			continue
+		}
+		var create, translate, disposeContext, disposeModule token.Pos
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				if selector, ok := call.Fun.(*ast.SelectorExpr); ok {
+					if selector.Sel.Name == "GlobalContext" {
+						t.Error("text-only translation must not use shared LLVM GlobalContext")
+					}
+					if selector.Sel.Name == "NewContext" {
+						create = call.Pos()
+					}
+				}
+				if name, ok := call.Fun.(*ast.Ident); ok && name.Name == "TranslateModuleInContext" {
+					translate = call.Pos()
+					if len(call.Args) != 3 {
+						t.Error("text translation lost its complete explicit context request")
+					} else if context, ok := call.Args[0].(*ast.Ident); !ok || context.Name != "ctx" {
+						t.Error("text translation does not use its request-owned context")
+					}
+				}
+			}
+			if deferred, ok := node.(*ast.DeferStmt); ok {
+				if selector, ok := deferred.Call.Fun.(*ast.SelectorExpr); ok && selector.Sel.Name == "Dispose" {
+					if owner, ok := selector.X.(*ast.Ident); ok {
+						switch owner.Name {
+						case "ctx":
+							disposeContext = deferred.Pos()
+						case "mod":
+							disposeModule = deferred.Pos()
+						}
+					}
+				}
+			}
+			return true
+		})
+		if !(create != 0 && create < disposeContext && disposeContext < translate && translate < disposeModule) {
+			t.Fatal("text translation must release its module before its owned context, including error paths")
+		}
+		return
+	}
+	t.Fatal("public text translation entry is missing")
+}
+
+func TestTranslateTextConcurrentRequestsKeepOriginalFile(t *testing.T) {
+	const childKey = "PLAN9ASM_TRANSLATE_TEXT_CONTEXT_CHILD"
+	if os.Getenv(childKey) != "1" {
+		// A native LLVM race may crash rather than return a Go error. Keep that
+		// failure in a bounded owned child, never an unsafe in-process probe.
+		executable, err := os.Executable()
+		if err != nil {
+			t.Fatal(err)
+		}
+		command := exec.Command(executable, "-test.run=^TestTranslateTextConcurrentRequestsKeepOriginalFile$", "-test.count=1")
+		command.Env = append(os.Environ(), childKey+"=1")
+		x86FloatCompareCaptureCommand(t, command)
+		return
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·f(SB),4,$0-0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	original := x86DirectTailSnapshot(file)
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		Sigs:       map[string]FuncSig{"f": {Name: "f", Ret: Void}}}
+	const workers, iterations = 8, 32
+	start := make(chan struct{})
+	failures := make(chan error, workers)
+	var group sync.WaitGroup
+	for worker := 0; worker < workers; worker++ {
+		group.Add(1)
+		go func() {
+			defer group.Done()
+			<-start
+			for iteration := 0; iteration < iterations; iteration++ {
+				ir, err := Translate(file, options)
+				if err != nil || !strings.Contains(ir, "define void @f(") {
+					failures <- fmt.Errorf("concurrent text request failed: %v", err)
+					return
+				}
+				if ir, err := Translate(nil, options); err == nil || ir != "" {
+					failures <- fmt.Errorf("failed text request published an artifact")
+					return
+				}
+			}
+		}()
+	}
+	close(start)
+	group.Wait()
+	close(failures)
+	for err := range failures {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(original, x86DirectTailSnapshot(file)) {
+		t.Fatal("concurrent text requests mutated their shared original source")
+	}
+}
diff --git a/translate_zero_return_test.go b/translate_zero_return_test.go
new file mode 100644
index 000000000..922456840
--- /dev/null
+++ b/translate_zero_return_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This fixture is synthetic LLVM, not original Go assembly or an ABI0
+// declaration. Exercise the existing typed terminator without inventing a
+// source function, native frame, incoming bytes or result-storage permission.
+func implicitZeroReturnFunctionIR(t *testing.T, arch Arch, name string, ret LLVMType) string {
+	t.Helper()
+	var output strings.Builder
+	fmt.Fprintf(&output, "define %s %s() {\nentry:\n", ret, llvmGlobal(name))
+	sig := FuncSig{Ret: ret}
+	switch arch {
+	case ArchAMD64:
+		(&amd64Ctx{b: &output, sig: sig}).lowerRetZero()
+	case ArchARM:
+		(&armCtx{b: &output, sig: sig}).lowerRetZero()
+	case ArchARM64:
+		(&arm64Ctx{b: &output, sig: sig}).lowerRetZero()
+	default:
+		t.Fatal("no register-architecture synthetic zero terminator", arch)
+	}
+	output.WriteString("}\n")
+	return output.String()
+}
+
+func TestImplicitZeroReturnTypesCompileAcrossArchitectures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range []struct {
+		arch           Arch
+		goarch, triple string
+	}{
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu"},
+	} {
+		for _, ret := range []LLVMType{Void, I1, I8, I16, I32, I64, Ptr, "float", "double", "{ i64, double }"} {
+			t.Run(target.goarch+"/"+string(ret), func(t *testing.T) {
+				ir := fmt.Sprintf("target triple = %q\n", target.triple) +
+					implicitZeroReturnFunctionIR(t, target.arch, "zero", ret)
+				compileLLVMToObject(t, llc, target.triple, "zero.ll", "zero.o", ir)
+			})
+		}
+	}
+}
+
+func TestImplicitZeroReturnRuntime(t *testing.T) {
+	arch := ArchARM64
+	if runtime.GOARCH == "amd64" {
+		arch = ArchAMD64
+	} else if runtime.GOARCH != "arm64" {
+		t.Skip("native amd64/arm64 execution; other architectures run in the required cross-runtime matrix")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	ir, main := implicitZeroReturnRuntimeFixture(t, arch, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	compileAndRunRuntimeTest(t, llc, clang, "zero-return", ir, main)
+}
+
+// The required CI cross-runtime job selects the TestCrossLinuxRuntimeMatrix prefix.
+func TestCrossLinuxRuntimeMatrixImplicitZeroReturn(t *testing.T) {
+	if os.Getenv("PLAN9ASM_CROSS_EXEC") != "1" {
+		t.Skip("set PLAN9ASM_CROSS_EXEC=1 for the required Linux cross-runtime matrix")
+	}
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" {
+		t.Fatal("cross-runtime driver requires linux/amd64")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+
+	for _, target := range []struct {
+		arch                                 Arch
+		goarch, triple, compiler, qemu, root string
+	}{
+		{ArchAMD64, "386", "i386-unknown-linux-gnu", "i686-linux-gnu-gcc", "qemu-i386", "/usr/i686-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf", "arm-linux-gnueabihf-gcc", "qemu-arm", "/usr/arm-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu", "aarch64-linux-gnu-gcc", "qemu-aarch64", "/usr/aarch64-linux-gnu"},
+	} {
+		t.Run(target.goarch, func(t *testing.T) {
+			ir, main := implicitZeroReturnRuntimeFixture(t, target.arch, target.triple)
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{target.compiler}, "zero-return-"+target.goarch,
+				target.triple, ir, main, []string{target.qemu, "-L", target.root})
+		})
+	}
+}
+
+func implicitZeroReturnRuntimeFixture(t *testing.T, arch Arch, triple string) (string, string) {
+	t.Helper()
+	var source, declarations, checks strings.Builder
+	fmt.Fprintf(&source, "target triple = %q\n", triple)
+	for i, ret := range []struct {
+		llvm  LLVMType
+		ctype string
+	}{
+		{I1, "_Bool"}, {I8, "int8_t"}, {I16, "int16_t"}, {I32, "int32_t"},
+		{I64, "int64_t"}, {Ptr, "void*"}, {"float", "float"}, {"double", "double"},
+	} {
+		name := fmt.Sprintf("zero%d", i)
+		source.WriteString(implicitZeroReturnFunctionIR(t, arch, name, ret.llvm))
+		fmt.Fprintf(&declarations, "extern %s %s(void);\n", ret.ctype, name)
+		fmt.Fprintf(&checks, "    if (%s() != 0) return %d;\n", name, i+1)
+	}
+	main := "#include <stdint.h>\n" + declarations.String() + "int main(void) {\n" + checks.String() + "    return 0;\n}\n"
+	return source.String(), main
+}
+
+func TestImplicitZeroReturnTypedEmittersRemainSynthetic(t *testing.T) {
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64} {
+		for _, row := range []struct {
+			ret  LLVMType
+			want string
+		}{
+			{Void, "ret void"}, {I1, "ret i1 false"}, {I8, "ret i8 0"},
+			{I16, "ret i16 0"}, {I32, "ret i32 0"}, {I64, "ret i64 0"},
+			{Ptr, "ret ptr null"}, {"float", "ret float 0.000000e+00"},
+			{"double", "ret double 0.000000e+00"}, {"{ i64, double }", "ret { i64, double } zeroinitializer"},
+		} {
+			t.Run(string(arch)+"/"+string(row.ret), func(t *testing.T) {
+				ir := implicitZeroReturnFunctionIR(t, arch, "zero", row.ret)
+				if !strings.Contains(ir, "  "+row.want+"\n") || strings.Contains(ir, "alloca") || strings.Contains(ir, "blockaddress") {
+					t.Fatalf("synthetic typed terminator borrowed storage or has the wrong value:\n%s", ir)
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := parseIRModuleInContext(ctx, ir)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestImplicitZeroReturnRuntimeFixtureRemainsSynthetic(t *testing.T) {
+	for _, target := range []struct {
+		arch         Arch
+		name, triple string
+	}{
+		{ArchAMD64, "386", "i386-unknown-linux-gnu"},
+		{ArchAMD64, "amd64", "x86_64-unknown-linux-gnu"},
+		{ArchARM, "arm", "armv7-unknown-linux-gnueabihf"},
+		{ArchARM64, "arm64", "aarch64-unknown-linux-gnu"},
+	} {
+		t.Run(target.name, func(t *testing.T) {
+			ir, driver := implicitZeroReturnRuntimeFixture(t, target.arch, target.triple)
+			if strings.Count(ir, "define ") != 8 || strings.Count(driver, "extern ") != 8 ||
+				strings.Count(driver, "() != 0") != 8 || !strings.Contains(ir, target.triple) ||
+				strings.Contains(ir, "alloca") || strings.Contains(ir, "blockaddress") {
+				t.Fatal("complete synthetic runtime type/target inventory or source-free boundary changed")
+			}
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := parseIRModuleInContext(ctx, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestImplicitZeroReturnDoesNotAuthorizeOrdinaryABI0Bool(t *testing.T) {
+	t.Run("original-manual-386-I1", func(t *testing.T) {
+		file, err := Parse(ArchAMD64, "TEXT zero(SB),4,$0-0\nNOP\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"zero": {Name: "zero", Ret: I1}}}
+		if ir, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatalf("synthetic emitter fixture acquired an ordinary ABI0 permission: %v", err)
+		}
+	})
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"no source RET", "NOP", false},
+		{"unwritten result", "NOP\nRET", false},
+		{"noncanonical result", "MOVB $2,ret+0(FP)\nRET", false},
+		{"raw context", "BYTE $0x90\nRET", false},
+		{"actual canonical result", "MOVB $1,ret+0(FP)\nRET", true},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-1\n" + row.body + "\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() bool", "386", "i386-unknown-linux-gnu", api)
+				if row.valid && (err != nil || ir == "") || !row.valid && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatalf("ordinary canonical/missing result boundary changed: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestWASMMissingReturnRemainsAnError(t *testing.T) {
+	// Wasm uses a typed value stack, not this register-architecture fallback.
+	// Do not silently replace its missing results or introduce blockaddress.
+	file, err := Parse(ArchWASM, "TEXT missing(SB),4,$0-0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{
+		Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown",
+		Sigs: map[string]FuncSig{"missing": {Name: "missing", Ret: "double"}},
+	})
+	if err == nil || !strings.Contains(err.Error(), "missing double return value") {
+		t.Fatalf("missing wasm return: %v", err)
+	}
+}
diff --git a/types.go b/types.go
index 0c23182d2..f4c315caf 100644
--- a/types.go
+++ b/types.go
@@ -32,17 +32,35 @@ const (
 	SP Reg = "SP"
 	BP Reg = "BP"
 	PC Reg = "PC"
+	ES Reg = "ES"
+	CS Reg = "CS"
+	SS Reg = "SS"
+	DS Reg = "DS"
 	FS Reg = "FS"
 	GS Reg = "GS"
+	// TLS is the x86 thread-local-storage pseudo-register used by the Go
+	// assembler both as a loadable base and as a relocation-only memory index.
+	TLS Reg = "TLS"
 
-	AL Reg = "AL"
-	AH Reg = "AH"
-	BL Reg = "BL"
-	BH Reg = "BH"
-	CL Reg = "CL"
-	CH Reg = "CH"
-	DL Reg = "DL"
-	DH Reg = "DH"
+	AL   Reg = "AL"
+	AH   Reg = "AH"
+	BL   Reg = "BL"
+	BH   Reg = "BH"
+	CL   Reg = "CL"
+	CH   Reg = "CH"
+	DL   Reg = "DL"
+	DH   Reg = "DH"
+	BPB  Reg = "BPB"
+	SIB  Reg = "SIB"
+	DIB  Reg = "DIB"
+	R8B  Reg = "R8B"
+	R9B  Reg = "R9B"
+	R10B Reg = "R10B"
+	R11B Reg = "R11B"
+	R12B Reg = "R12B"
+	R13B Reg = "R13B"
+	R14B Reg = "R14B"
+	R15B Reg = "R15B"
 
 	ZR Reg = "ZR"
 )
@@ -88,6 +106,8 @@ func parseReg(s string) (Reg, bool) {
 		return FS, true
 	case "GS":
 		return GS, true
+	case "TLS":
+		return TLS, true
 	case "AL":
 		return AL, true
 	case "AH":
@@ -104,6 +124,28 @@ func parseReg(s string) (Reg, bool) {
 		return DL, true
 	case "DH":
 		return DH, true
+	case "BPB":
+		return BPB, true
+	case "SIB":
+		return SIB, true
+	case "DIB":
+		return DIB, true
+	case "R8B":
+		return R8B, true
+	case "R9B":
+		return R9B, true
+	case "R10B":
+		return R10B, true
+	case "R11B":
+		return R11B, true
+	case "R12B":
+		return R12B, true
+	case "R13B":
+		return R13B, true
+	case "R14B":
+		return R14B, true
+	case "R15B":
+		return R15B, true
 	case "ZR":
 		return ZR, true
 	case "G":
@@ -141,6 +183,18 @@ func parseReg(s string) (Reg, bool) {
 			return Reg(ss), true
 		}
 	}
+	if strings.HasPrefix(ss, "PN") && len(ss) >= 3 {
+		i := 2
+		for i < len(ss) && ss[i] >= '0' && ss[i] <= '9' {
+			i++
+		}
+		if i > 2 {
+			rest := ss[i:]
+			if rest == "" || strings.HasPrefix(rest, ".") || strings.HasPrefix(rest, "[") {
+				return Reg(ss), true
+			}
+		}
+	}
 	if (strings.HasPrefix(ss, "X") || strings.HasPrefix(ss, "Y") || strings.HasPrefix(ss, "Z") || strings.HasPrefix(ss, "V") || strings.HasPrefix(ss, "F") || strings.HasPrefix(ss, "P")) && len(ss) >= 2 {
 		i := 1
 		for i < len(ss) && ss[i] >= '0' && ss[i] <= '9' {
@@ -152,7 +206,7 @@ func parseReg(s string) (Reg, bool) {
 			if rest == "" {
 				return Reg(ss), true
 			}
-			if strings.HasPrefix(rest, ".") {
+			if strings.HasPrefix(rest, ".") || strings.HasPrefix(ss, "Z") && strings.HasPrefix(rest, "[") {
 				return Reg(ss), true
 			}
 		}
@@ -211,10 +265,11 @@ const (
 type Operand struct {
 	Kind OperandKind
 
-	Imm    int64    // OpImm
-	ImmRaw string   // OpImm unresolved symbolic placeholder, including leading '$'
-	Reg    Reg      // OpReg
-	Ext    ExtendOp // OpRegExtend
+	Imm        int64    // OpImm; floating immediates hold their float64 bit pattern
+	ImmRaw     string   // OpImm unresolved symbolic placeholder, including leading '$'
+	ImmIsFloat bool     // OpImm originated from a floating constant expression
+	Reg        Reg      // OpReg
+	Ext        ExtendOp // OpRegExtend
 	// OpRegShift
 	ShiftOp     ShiftOp
 	ShiftAmount int64
@@ -235,17 +290,18 @@ type Operand struct {
 	//   (R0)(R6)
 	Mem MemRef
 
-	RegList []Reg // OpRegList (e.g. (R4, R8))
+	RegList      []Reg // OpRegList (e.g. (R4, R8))
+	RegListRange bool  // OpRegList originated from one range (e.g. [Z4.Q-Z5.Q])
 }
 
 type MemRef struct {
 	Base     Reg
-	Sym      string // optional symbol-based address, including the (SB) suffix
+	Sym      string // optional named address role, including (SB), (FP), or (SP)
 	Off      int64
 	OffRaw   string   // unresolved symbolic displacement, used by generated wasm go_asm.h offsets
 	Index    Reg      // optional; empty if not present
 	IndexExt ExtendOp // optional ARM64 index extension (UXTW, SXTW, UXTX, or SXTX)
-	Scale    int64    // optional; defaults to 1 when Index is present
+	Scale    int64    // source x86 preserves a missing multiplier as 0; consumers validate their role
 	Segment  Reg      // optional x86 segment override (FS or GS)
 }
 
@@ -255,6 +311,9 @@ func (o Operand) String() string {
 		if o.ImmRaw != "" {
 			return o.ImmRaw
 		}
+		if o.ImmIsFloat {
+			return "$(" + strconv.FormatFloat(math.Float64frombits(uint64(o.Imm)), 'g', -1, 64) + ")"
+		}
 		return fmt.Sprintf("$%d", o.Imm)
 	case OpReg:
 		return string(o.Reg)
@@ -287,10 +346,17 @@ func (o Operand) String() string {
 			segment = fmt.Sprintf("(%s)", o.Mem.Segment)
 		}
 		if o.Mem.Sym != "" {
+			symbol := o.Mem.Sym
+			if o.Mem.Base != "" {
+				symbol += fmt.Sprintf("(%s)", o.Mem.Base)
+			}
+			if o.Mem.Index == "" {
+				return symbol + segment
+			}
 			if o.Mem.Scale == 0 {
-				return fmt.Sprintf("%s(%s)%s", o.Mem.Sym, o.Mem.Index, segment)
+				return fmt.Sprintf("%s(%s)%s", symbol, o.Mem.Index, segment)
 			}
-			return fmt.Sprintf("%s(%s*%d)%s", o.Mem.Sym, o.Mem.Index, o.Mem.Scale, segment)
+			return fmt.Sprintf("%s(%s*%d)%s", symbol, o.Mem.Index, o.Mem.Scale, segment)
 		}
 		offset := fmt.Sprintf("%d", o.Mem.Off)
 		if o.Mem.OffRaw != "" {
@@ -379,18 +445,26 @@ func isSymbolicImmPlaceholder(s string) bool {
 	return strings.ContainsAny(inner, "+-*/%<>&|^ \t")
 }
 
-func parseImmExpr(v string) (uint64, bool) {
-	// Plan9 asm frequently uses C-style unary "~" for bitwise-not in immediates.
-	// Go expressions use "^", so normalize before parsing.
-	exprText := strings.ReplaceAll(strings.TrimSpace(v), "~", "^")
-	if exprText == "" {
+func parseVectorLengthScaleExpr(v string) (int64, bool) {
+	expr := strings.ToUpper(strings.ReplaceAll(strings.TrimSpace(v), " ", ""))
+	for strings.HasPrefix(expr, "(") && strings.HasSuffix(expr, ")") {
+		expr = strings.TrimSpace(expr[1 : len(expr)-1])
+	}
+	sign := int64(1)
+	if strings.HasPrefix(expr, "-") {
+		sign = -1
+		expr = strings.TrimPrefix(expr, "-")
+	} else {
+		expr = strings.TrimPrefix(expr, "+")
+	}
+	if !strings.HasPrefix(expr, "VL*") {
 		return 0, false
 	}
-	expr, err := parser.ParseExpr(exprText)
-	if err != nil {
+	multiplier, err := strconv.ParseInt(strings.TrimPrefix(expr, "VL*"), 10, 64)
+	if err != nil || multiplier < 0 {
 		return 0, false
 	}
-	return evalImmExpr(expr)
+	return sign * multiplier, true
 }
 
 func parseImmFloatExpr(v string) (float64, bool) {
@@ -398,6 +472,12 @@ func parseImmFloatExpr(v string) (float64, bool) {
 	if exprText == "" {
 		return 0, false
 	}
+	// cmd/asm treats each unary sign as a separate token. Go source parsing
+	// instead tokenizes adjacent ++/-- as increment/decrement, so preserve
+	// the actual assembly FLOAT-leaf grammar before the legacy evaluator.
+	if value, valid := parseGoFloatLiteral(exprText); valid {
+		return value, true
+	}
 	expr, err := parser.ParseExpr(exprText)
 	if err != nil {
 		return 0, false
@@ -468,105 +548,20 @@ func evalFloatExpr(e ast.Expr) (float64, bool) {
 	}
 }
 
-func evalImmExpr(e ast.Expr) (uint64, bool) {
-	switch x := e.(type) {
-	case *ast.ParenExpr:
-		return evalImmExpr(x.X)
-	case *ast.BasicLit:
-		if x.Kind != token.INT {
-			return 0, false
-		}
-		if u, err := strconv.ParseUint(x.Value, 0, 64); err == nil {
-			return u, true
-		}
-		n, err := strconv.ParseInt(x.Value, 0, 64)
-		if err != nil {
-			return 0, false
-		}
-		return uint64(n), true
-	case *ast.UnaryExpr:
-		v, ok := evalImmExpr(x.X)
-		if !ok {
-			return 0, false
-		}
-		switch x.Op {
-		case token.ADD:
-			return v, true
-		case token.SUB:
-			return uint64(0) - v, true
-		case token.XOR:
-			return ^v, true
-		default:
-			return 0, false
-		}
-	case *ast.BinaryExpr:
-		lv, ok := evalImmExpr(x.X)
-		if !ok {
-			return 0, false
-		}
-		rv, ok := evalImmExpr(x.Y)
-		if !ok {
-			return 0, false
-		}
-		switch x.Op {
-		case token.ADD:
-			return lv + rv, true
-		case token.SUB:
-			return lv - rv, true
-		case token.MUL:
-			return lv * rv, true
-		case token.QUO:
-			if rv == 0 {
-				return 0, false
-			}
-			return lv / rv, true
-		case token.REM:
-			if rv == 0 {
-				return 0, false
-			}
-			return lv % rv, true
-		case token.SHL:
-			if rv >= 64 {
-				return 0, true
-			}
-			return lv << rv, true
-		case token.SHR:
-			if rv >= 64 {
-				return 0, true
-			}
-			return lv >> rv, true
-		case token.AND:
-			return lv & rv, true
-		case token.OR:
-			return lv | rv, true
-		case token.XOR:
-			return lv ^ rv, true
-		case token.AND_NOT:
-			return lv &^ rv, true
-		default:
-			return 0, false
-		}
-	default:
-		return 0, false
-	}
-}
-
 func parseFP(s string) (name string, off int64, ok bool) {
-	// Minimal: name+off(FP)
-	// Examples: a+0(FP), b+8(FP), ret+16(FP)
+	// Go accepts both name(FP) and name+off(FP) (including a negative
+	// displacement). The omitted displacement is exactly zero; generated
+	// assembly uses that spelling frequently for the first result slot.
 	s = strings.TrimSpace(s)
 	if !strings.HasSuffix(s, "(FP)") {
 		return "", 0, false
 	}
-	base := strings.TrimSuffix(s, "(FP)")
-	plus := strings.LastIndexByte(base, '+')
-	if plus <= 0 || plus == len(base)-1 {
+	base := strings.TrimSpace(strings.TrimSuffix(s, "(FP)"))
+	if base == "" {
 		return "", 0, false
 	}
-	name = strings.TrimSpace(base[:plus])
-	offStr := strings.TrimSpace(base[plus+1:])
-	off, err := strconv.ParseInt(offStr, 0, 64)
-	if err != nil {
+	name, off = splitSymPlusOff(base)
+	if name == "" || strings.IndexAny(name, " \t,()+-") >= 0 {
 		return "", 0, false
 	}
 	return name, off, true
@@ -595,7 +590,10 @@ func parseOperand(s string) (Operand, error) {
 		}
 	}
 	if imm, ok := parseImm(s); ok {
-		op := Operand{Kind: OpImm, Imm: imm}
+		expr := strings.TrimSpace(strings.TrimPrefix(s, "$"))
+		_, integerExpression := parseImmExpr(expr)
+		_, floatingExpression := parseImmFloatExpr(expr)
+		op := Operand{Kind: OpImm, Imm: imm, ImmIsFloat: !integerExpression && floatingExpression}
 		if isSymbolicImmPlaceholder(s) {
 			expr := strings.TrimSpace(strings.TrimPrefix(s, "$"))
 			if _, resolvedInt := parseImmExpr(expr); !resolvedInt {
@@ -642,7 +640,7 @@ func parseOperand(s string) (Operand, error) {
 			}
 			regs = append(regs, rs...)
 		}
-		return Operand{Kind: OpRegList, RegList: regs}, nil
+		return Operand{Kind: OpRegList, RegList: regs, RegListRange: len(parts) == 1 && strings.Contains(parts[0], "-")}, nil
 	}
 	// Register list: (R4, R8)
 	if strings.HasPrefix(s, "(") && strings.HasSuffix(s, ")") && strings.Contains(s, ",") {
@@ -739,6 +737,10 @@ func parseRegShift(s string) (base Reg, sop ShiftOp, amt int64, shiftReg Reg, ok
 		if rr, ok := parseReg(r); ok {
 			return br, candidate, 0, rr, true
 		}
+		// x/arch GoSyntax prints ARM immediate shifts with a dollar sign
+		// (for example R0->$32). Accept that spelling as well as the
+		// existing source form without the prefix.
+		r = strings.TrimPrefix(r, "$")
 		if n, err := strconv.ParseInt(r, 0, 64); err == nil {
 			return br, candidate, n, "", true
 		}
@@ -844,15 +846,129 @@ type Instr struct {
 	Op   Op
 	Args []Operand
 	Raw  string
+	// Set only by an ARM64 machine-code decoder. A physical data instruction
+	// does not acquire Go's named immediate expansion or implicit R27 scratch.
+	arm64Encoded bool
+	// Recomputed from the complete source TEXT's Go frame, never from public
+	// input metadata. FP shadow storage does not thereby become physical SP.
+	arm64ScalarMemoryFrameOffset *int64
+	// Set only after a raw BL's exact same-source PC target is established.
+	// It remains a physical leaf call for Go's pre-WORD prologue selection.
+	arm64RawLocalCall bool
+	// A decoded A64 UDF keeps its encoded imm16 while reusing UNDEF's
+	// terminating semantics. Textual Go UNDEF remains operand-free/#0.
+	arm64RawUndefinedImmediate uint16
+	// Set only after validating a closed, source-local Linux native helper.
+	armKernelCall *armKernelCall
+	// Set only by a validated machine-code decoder. Physical operands need
+	// not obey textual frontend limits (e.g. Go 386's three-operand limit).
+	x86Encoded bool
+	// Physical BYTE/WORD/LONG/QUAD producer origin. Unlike x86Encoded, this
+	// does not relax Go operand grammar. Go's prologue pass cannot see a raw
+	// PUSH/POP when adjusting a later named FP operand.
+	x86SourceRaw *x86SourceRawInstruction
+	// Decoder-only native 63/r scalar copies require actual initialized input
+	// provenance before a raw return. Their MOVL/MOVW spellings do not grant
+	// the older generic scalar frame proof new entry-register permissions.
+	x86RawMOVSXDNeedsCaller bool
+	// Decoder-only CVTPI2PS/PD provenance. Its normalized Go name is shared
+	// with an SSE conversion, but the original instruction reads m64/MMX
+	// and changes physical x87/MMX state. This is a restriction, not an
+	// authorization to use native MMX scratch registers.
+	x86MMXSourceConversion bool
+	// Decoder-only EVEX scalar conversion encoding. Keep its native ISA
+	// requirement even when its low-X operands also have a VEX spelling.
+	x86ScalarFloatIntegerEVEX bool
+	x86PackedNumericEVEX      bool
+	// A physical packed float move can use EVEX with unmasked low X/Y
+	// operands too. Retain that generation for the existing native bridge;
+	// neither this restriction nor its CPU features grant input permission.
+	x86PackedVectorMoveEVEX bool
+	// Preserve physical EVEX generation even without a high bank or SAE suffix.
+	x86ScalarFlagCompareEVEX bool
+	x86SqrtEVEX              bool
+	// MIN/MAX retains low-bank, unmasked physical EVEX independently of its
+	// operand-inferred native encoding and ordinary numerical input facts.
+	x86FloatMinMaxEVEX bool
+	// Scalar precision conversions retain their physical EVEX generation even
+	// when every low-X operand also has an unmasked VEX spelling.
+	x86ScalarPrecisionEVEX bool
+	x86PackedPrecisionEVEX bool
+	// Ordinary F16C/AVX512F half conversions retain an explicit generation;
+	// zero is absent identity, not VEX or raw-only AVX512-FP16 permission.
+	x86NamedHalfEncoding x86RawNamedHalfEncoding
+	// F32/F64 FMA keeps an explicit physical generation. A zero value is not
+	// a VEX observation and does not borrow raw-only FP16's encoded grammar.
+	x86FMA3Encoding x86RawFMA3Encoding
+	// Packed shifts retain actual decoder generation and W, including WIG.
+	// The zero generation is absent identity, not an inferred VEX encoding.
+	x86PackedShiftEncoding x86RawPackedShiftEncoding
+	x86PackedShiftW        bool
+	// Integer dot products retain VEX versus EVEX independently of operand
+	// spelling. This is physical identity, never an incoming data/entry fact.
+	x86PackedDotEncoding x86RawPackedDotEncoding
+	// Set only by the fixed W0/L1 permute128 decoder. False is absent
+	// physical identity, not permission to infer a VEX source from Y names.
+	x86Permute128VEX bool
+	// ABS retains physical EVEX even for unmasked low X/Y operands that
+	// otherwise have a VEX spelling. CPU generation supplies no input facts.
+	x86PackedAbsEVEX bool
+	// Recomputed per-operand source-SP to typed ABI0 slot certificate. Keep
+	// original physical operands intact across repeated normalization.
+	x86SourceStackFP map[int]int64
+	// Recomputed only after the complete source-stack CFG consumes an actual
+	// typed caller-region proof; never a general incoming-pointer permission.
+	x86CallerMemory map[int]x86CallerMemoryAccess
+	// Recomputed only from a live actual-object binding and complete local CFG.
+	// JSON/source spelling and caller-region certificates cannot create it.
+	x86FixedLocalMemory map[int]x86FixedLocalAccess
+	// Factory-only exact scalar numerical read. Its immutable source/native
+	// join is rechecked before and after translation, never inferred from SB.
+	x86NumericalRead *x86NumericalReadCertificate
+	// Literal-only address/read fact from the same live original SDK DATA and
+	// complete source-path proof; never caller or native-frame authority.
+	x86SDKLiteral *x86SDKLiteralCertificate
+	// A decoded near return is a physical C2/C3 instruction, not a Go RET
+	// pseudo-instruction with an automatically generated frame epilogue.
+	x86RawNearReturn *x86RawNearReturnForm
+	// Effective address width for a raw address-size override; zero means
+	// the target's ordinary pointer width.
+	x86AddressBits int
+	// Restriction from the generic decoder: the physical memory address-size
+	// prefix has no width-consuming ordinary lowerer. This is not a positive
+	// certificate. Dedicated typed decoders bind their own address semantics.
+	x86UnboundAddressOverride bool
+	// Segment override on a raw instruction with an implicit register address.
+	x86SegmentPrefix byte
+	// Decoded vector length, separate from register storage width. Narrowing
+	// conversions can write X from either a 128- or 256-bit memory source.
+	x86VectorBytes int
+	// A decoder folded a same-group, unreachable RIP-relative data read. Keep
+	// address-observed raw TEXT bodies on the byte-preserving path instead.
+	x86RIPLiteral bool
+	// A wide source-local constant is materialized as an LLVM data global by
+	// normalizeX86RawFile. Retain its bytes for lowerers that can specialize
+	// the constant without a memory access, after source-layout validation.
+	x86RIPLiteralData []byte
+	// A shared RIP decoder proved this exact read operand and physical width.
+	// The bound source/global must still be rechecked after materialization;
+	// changed exported operands cannot inherit the old decoder proof.
+	x86RIPMemoryRead x86RawStaticRead
+	// A reachable LEA addresses an offset of a source-local raw data suffix.
+	// The suffix is shared by all such LEAs in one raw directive group.
+	x86RIPAddressData  []byte
+	x86RIPAddressOff   int
+	x86RIPAddressGroup int
 }
 
 // DataStmt models a minimal Plan 9 DATA directive:
 //
 //	DATA sym+off(SB)/width, $value
 //
-// Width is in bytes. Integer values are encoded little-endian into the
-// global. String payloads are copied byte-for-byte and zero-padded to Width,
-// matching cmd/asm's DATA string semantics.
+// Width is in bytes. Value holds an integer or an already width-converted
+// IEEE float bit pattern, encoded little-endian into the global. String
+// payloads are copied byte-for-byte and zero-padded to Width, matching
+// cmd/asm's DATA string semantics.
 type DataStmt struct {
 	// Addr retains a symbol-address initializer, including its (SB) suffix.
 	Addr    string
@@ -865,13 +981,15 @@ type DataStmt struct {
 
 // GloblStmt models a minimal Plan 9 GLOBL directive:
 //
-//	GLOBL sym(SB), flags, $size
+// GLOBL sym(SB), $size
+// GLOBL sym(SB), flags, $size
 //
 // Flags are preserved as raw text for now (e.g. "RODATA").
 type GloblStmt struct {
-	Sym   string
-	Flags string
-	Size  int64
+	Sym     string
+	Flags   string
+	Size    int64
+	SizeRaw string // unresolved generated go_asm.h expression; translation rejects it
 }
 
 func parseIdent(s string) (string, bool) {
@@ -948,6 +1066,29 @@ func parseMem(s string) (MemRef, bool) {
 	if !strings.Contains(s, "(") || !strings.Contains(s, ")") {
 		return MemRef{}, false
 	}
+	// A displacement is a Go constant expression and may itself contain
+	// parentheses. Split from the final base-register group before the older
+	// left-to-right address parser so forms such as 0+(1*16)(BP) do not mistake
+	// the expression's first parenthesis for the address base.
+	if strings.HasSuffix(s, ")") {
+		if open := strings.LastIndexByte(s, '('); open > 0 {
+			prefix := strings.TrimSpace(s[:open])
+			baseText := strings.TrimSpace(s[open+1 : len(s)-1])
+			if base, ok := parseReg(baseText); ok {
+				if offset, ok := parseImmExpr(prefix); ok {
+					if base == FS || base == GS {
+						return MemRef{Segment: base, Off: int64(offset)}, true
+					}
+					return MemRef{Base: base, Off: int64(offset)}, true
+				}
+				if base == SP && strings.EqualFold(baseText, "SP") {
+					if offset, ok := parseNamedStackConstantOffset(prefix); ok {
+						return MemRef{Base: SP, Off: offset}, true
+					}
+				}
+			}
+		}
+	}
 
 	parseIndexScale := func(inner string) (idx Reg, ext ExtendOp, scale int64, ok bool) {
 		inner = strings.TrimSpace(inner)
@@ -1042,8 +1183,21 @@ func parseMem(s string) (MemRef, bool) {
 		}
 		return MemRef{Sym: offPart + "(SB)", Index: idx, IndexExt: ext, Scale: scale}, true
 	}
+	// Go's ARM64 SVE vector-offset syntax prints the vector index before the
+	// scalar base, for example (Z6.S.SXTW<<2)(R14). Normalize that spelling to
+	// the MemRef Base/Index model before parseReg accepts the arranged Z name as
+	// an ordinary base register.
+	if offPart == "" && strings.HasPrefix(strings.ToUpper(baseStr), "Z") && strings.HasPrefix(rest, "(") && strings.HasSuffix(rest, ")") {
+		base2 := strings.TrimSpace(strings.TrimSuffix(strings.TrimPrefix(rest, "("), ")"))
+		if base, baseOK := parseReg(base2); baseOK {
+			if index, ext, scale, indexOK := parseIndexScale(baseStr); indexOK {
+				return MemRef{Base: base, Index: index, IndexExt: ext, Scale: scale}, true
+			}
+		}
+	}
 
 	var off int64
+	var offRaw string
 	if offPart != "" {
 		if n, err := strconv.ParseInt(offPart, 0, 64); err == nil {
 			off = n
@@ -1051,8 +1205,10 @@ func parseMem(s string) (MemRef, bool) {
 			off = int64(u)
 		} else {
 			// Stack slots commonly use a descriptive name before their numeric
-			// displacement (for example control-4(SP)). Preserve the displacement;
-			// only an unresolved include-derived expression degrades to zero.
+			// displacement (for example control-4(SP)). Preserve both the source
+			// spelling and displacement so architecture validators can distinguish
+			// named stack slots from plain register-relative memory.
+			offRaw = offPart
 			_, off = splitSymPlusOff(offPart)
 		}
 	}
@@ -1070,6 +1226,16 @@ func parseMem(s string) (MemRef, bool) {
 					mem := MemRef{Base: br, Off: 0}
 					if u, ok := parseImmExpr(baseStr); ok {
 						mem.Off = int64(u)
+					} else if idx, ext, scale, ok := parseIndexScale(baseStr); ok {
+						mem.Index = idx
+						mem.IndexExt = ext
+						mem.Scale = scale
+					} else if _, ok := parseVectorLengthScaleExpr(baseStr); ok {
+						mem.OffRaw = baseStr
+					} else {
+						// Unknown include-derived expressions must remain visible
+						// to validation; they are never evidence for offset zero.
+						mem.OffRaw = baseStr
 					}
 					rem := strings.TrimSpace(rest[j2+1:])
 					if rem == "" {
@@ -1096,9 +1262,13 @@ func parseMem(s string) (MemRef, bool) {
 				if u, ok := parseImmExpr(baseStr); ok {
 					return MemRef{Base: br, Off: int64(u)}, true
 				}
-				// Accept (symExpr)(REG) by degrading symExpr to offset 0 when
-				// include-derived constants are unavailable in preprocessing.
-				return MemRef{Base: br, Off: 0}, true
+				if idx, ext, scale, ok := parseIndexScale(baseStr); ok {
+					return MemRef{Base: br, Index: idx, IndexExt: ext, Scale: scale}, true
+				}
+				if _, ok := parseVectorLengthScaleExpr(baseStr); ok {
+					return MemRef{Base: br, OffRaw: baseStr}, true
+				}
+				return MemRef{Base: br, OffRaw: baseStr}, true
 			}
 		}
 		// Accept off(index*scale) with no base, e.g. -1(AX*2).
@@ -1109,7 +1279,7 @@ func parseMem(s string) (MemRef, bool) {
 		return MemRef{Base: "", Off: off, Index: idx, IndexExt: ext, Scale: scale}, true
 	}
 
-	mem := MemRef{Base: base, Off: off}
+	mem := MemRef{Base: base, Off: off, OffRaw: offRaw}
 	if base == FS || base == GS {
 		mem.Base = ""
 		mem.Segment = base
@@ -1140,6 +1310,27 @@ func parseMem(s string) (MemRef, bool) {
 	return mem, true
 }
 
+// Go stack names are annotations; the numeric expression after their sign
+// determines the actual SP displacement. For example tmpdig-(1*4)(SP) and
+// tmpdig-4(SP) address the same slot. Only an evaluable expression is accepted
+// here, so an unresolved macro cannot silently become offset zero.
+// Bare names retain their spelling for architecture-specific AUTO consumers.
+func parseNamedStackConstantOffset(prefix string) (int64, bool) {
+	prefix = strings.TrimSpace(prefix)
+	if len(prefix) < 3 {
+		return 0, false
+	}
+	sep := strings.IndexAny(prefix[1:], "+-") + 1
+	if sep == 0 || sep >= len(prefix)-1 {
+		return 0, false
+	}
+	if !validPPIdentifier(prefix[:sep]) {
+		return 0, false
+	}
+	offset, ok := parseImmExpr(prefix[sep:])
+	return int64(offset), ok
+}
+
 func splitTopLevelCSV(s string) []string {
 	s = strings.TrimSpace(s)
 	if s == "" {
@@ -1149,8 +1340,21 @@ func splitTopLevelCSV(s string) []string {
 	start := 0
 	par := 0
 	brk := 0
+	var quote byte
 	for i := 0; i < len(s); i++ {
+		if quote != 0 {
+			if s[i] == '\\' && quote != '`' && i+1 < len(s) {
+				i++
+				continue
+			}
+			if s[i] == quote {
+				quote = 0
+			}
+			continue
+		}
 		switch s[i] {
+		case '\'', '"', '`':
+			quote = s[i]
 		case '(':
 			par++
 		case ')':
diff --git a/types_deep_test.go b/types_deep_test.go
index cd45f7e87..93ed56eb4 100644
--- a/types_deep_test.go
+++ b/types_deep_test.go
@@ -99,7 +99,9 @@ func TestTypeHelperCoverage(t *testing.T) {
 		{"7&3", 3, true},
 		{"7|8", 15, true},
 		{"7^3", 4, true},
-		{"7&^3", 4, true},
+		// cmd/asm has unary ~, not Go's &^ operator. The independent
+		// integer-grammar oracle retains 7&^3 as an actual Go rejection.
+		{"7&~3", 4, true},
 		{"~1", ^uint64(1), true},
 		{"1/0", 0, false},
 	} {
@@ -178,9 +180,11 @@ func TestTypeParserEdgeCoverage(t *testing.T) {
 		want bool
 	}{
 		{"arg+8(FP)", true},
+		{"arg(FP)", true},
+		{"arg-8(FP)", true},
 		{"arg+8(SP)", false},
 		{"$ret+16(FP)", true},
-		{"$ret(FP)", false},
+		{"$ret(FP)", true},
 	} {
 		if _, _, ok := parseFP(tc.in); ok != tc.want && tc.in[0] != '$' {
 			t.Fatalf("parseFP(%q) ok = %v, want %v", tc.in, ok, tc.want)
@@ -245,6 +249,14 @@ func TestTypeParserEdgeCoverage(t *testing.T) {
 			t.Fatalf("parseOperand(%q) = (%v, %v), want kind %v", tc.in, err, op.Kind, tc.want)
 		}
 	}
+	rangeOperand, err := parseOperand("[Z4.Q-Z5.Q]")
+	if err != nil || !rangeOperand.RegListRange {
+		t.Fatalf("parseOperand(SVE range) = (%+v, %v), want range provenance", rangeOperand, err)
+	}
+	listOperand, err := parseOperand("[Z4.Q, Z5.Q]")
+	if err != nil || listOperand.RegListRange {
+		t.Fatalf("parseOperand(SVE list) = (%+v, %v), want non-range provenance", listOperand, err)
+	}
 	if reg, ext, ok := parseRegExtend("r3.sxtw"); !ok || reg != "R3" || ext != ExtendSXTW {
 		t.Fatalf("parseRegExtend(r3.sxtw) = (%q, %q, %v)", reg, ext, ok)
 	}
diff --git a/wasm_errors_test.go b/wasm_errors_test.go
index e906b52e2..3caded365 100644
--- a/wasm_errors_test.go
+++ b/wasm_errors_test.go
@@ -135,7 +135,10 @@ func TestTranslateWasmDiagnostics(t *testing.T) {
 		{name: "fill destination cast", body: "F64Load x+0(FP)\nI32Const $1\nI32Const $2\nMemoryFill", sig: frameF64, want: "unsupported wasm cast double to ptr"},
 		{name: "jump arguments", body: "JMP", want: "expects one target"},
 		{name: "call arguments", body: "Call", want: "expects one target"},
-		{name: "unsupported opcode", body: "I32Clz", want: "unsupported wasm instruction"},
+		{name: "count underflow", body: "I32Clz", want: "operand stack underflow"},
+		// Use an intentionally nonexistent name: implemented instruction
+		// families must not invalidate this unsupported-name diagnostic.
+		{name: "unsupported opcode", body: "InvalidWasmOpcode", want: "unsupported wasm instruction"},
 		{name: "unterminated block", body: "Block", want: "unterminated wasm control blocks"},
 	}
 	for _, tc := range tests {
diff --git a/wasm_float_arithmetic_runtime_test.go b/wasm_float_arithmetic_runtime_test.go
new file mode 100644
index 000000000..d29a8dab9
--- /dev/null
+++ b/wasm_float_arithmetic_runtime_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"math"
+	"strings"
+	"testing"
+)
+
+func wasmFloatArithmeticSamples(bits int) []uint64 {
+	values := append([]uint64(nil), wasmFloatBinarySamples(bits)...)
+	if bits == 32 {
+		return append(values, 0x3f000000, 0xbf000000, 0x33800000, 0xb3800000,
+			0x3f800001, 0xbf800001, 0x40000000, 0xc0000000)
+	}
+	return append(values, 0x3fe0000000000000, 0xbfe0000000000000,
+		0x3ca0000000000000, 0xbca0000000000000, 0x3ff0000000000001,
+		0xbff0000000000001, 0x4000000000000000, 0xc000000000000000)
+}
+
+// Use ordinary Go arithmetic at the declared precision, independently of the
+// lowerer. Each expression performs only one operation, with explicit float32
+// rounding where required. NaN signs/payloads follow the permitted Wasm set,
+// not the host's particular NaN choice:
+// https://webassembly.github.io/spec/core/exec/numerics.html#nan-propagation
+func wasmFloatArithmeticReference(name string, a, b uint64) (uint64, int) {
+	exponent, quiet := uint64(0x7ff0000000000000), uint64(1)<<51
+	if strings.HasPrefix(name, "F32") {
+		exponent, quiet = 0x7f800000, 1<<22
+	}
+	isNaN := func(value uint64) bool {
+		return value&exponent == exponent && value&(quiet*2-1) != 0
+	}
+	if isNaN(a) || isNaN(b) {
+		kind := 1
+		if isNaN(a) && a&(quiet*2-1) != quiet || isNaN(b) && b&(quiet*2-1) != quiet {
+			kind = 2
+		}
+		return exponent | quiet, kind
+	}
+
+	operation := name[3:]
+	var result uint64
+	if strings.HasPrefix(name, "F32") {
+		x, y := math.Float32frombits(uint32(a)), math.Float32frombits(uint32(b))
+		var value float32
+		switch operation {
+		case "Add":
+			value = x + y
+		case "Sub":
+			value = x - y
+		case "Mul":
+			value = x * y
+		case "Div":
+			value = x / y
+		default:
+			panic("unknown independent Wasm arithmetic " + name)
+		}
+		result = uint64(math.Float32bits(value))
+	} else {
+		x, y := math.Float64frombits(a), math.Float64frombits(b)
+		var value float64
+		switch operation {
+		case "Add":
+			value = x + y
+		case "Sub":
+			value = x - y
+		case "Mul":
+			value = x * y
+		case "Div":
+			value = x / y
+		default:
+			panic("unknown independent Wasm arithmetic " + name)
+		}
+		result = math.Float64bits(value)
+	}
+	if isNaN(result) {
+		// Invalid operations such as 0/0, Inf-Inf and Inf*0 have no NaN
+		// input; Wasm permits either sign of the canonical NaN only.
+		return exponent | quiet, 1
+	}
+	return result, 0
+}
+
+const wasmFloatArithmeticRuntimeCases = 8 * 2 * 2 * 28 * 28
+
+func wasmFloatArithmeticRuntimeFixture(t *testing.T) (string, string, map[string]FuncSig, string, string, []byte) {
+	t.Helper()
+	return wasmFloatRuntimeFixture(t, wasmFloatArithmeticGoNames(t), wasmFloatArithmeticTypes,
+		wasmFloatArithmeticSamples, wasmFloatArithmeticReference)
+}
+
+func TestWASMFloatArithmeticReferenceBoundaryControls(t *testing.T) {
+	for _, row := range []struct {
+		name    string
+		a, b    uint64
+		want    uint64
+		nanKind int
+	}{
+		{"F32Add", 0x80000000, 0x80000000, 0x80000000, 0},
+		{"F32Sub", 0x80000000, 0, 0x80000000, 0},
+		{"F32Mul", 0x80000000, 0x3f800000, 0x80000000, 0},
+		{"F32Div", 0x3f800000, 0x80000000, 0xff800000, 0},
+		{"F32Add", 0x3f800000, 0x33800000, 0x3f800000, 0},
+		{"F32Add", 0x3f800001, 0x33800000, 0x3f800002, 0},
+		{"F32Mul", 0x7f7fffff, 0x40000000, 0x7f800000, 0},
+		{"F32Div", 1, 0x40000000, 0, 0},
+		{"F32Div", 3, 0x40000000, 2, 0},
+		{"F32Div", 0, 0, 0x7fc00000, 1},
+		{"F32Add", 0xffc00000, 0x3f800000, 0x7fc00000, 1},
+		{"F32Sub", 0x7f800001, 0x3f800000, 0x7fc00000, 2},
+		{"F64Add", 0x8000000000000000, 0x8000000000000000, 0x8000000000000000, 0},
+		{"F64Sub", 0x8000000000000000, 0, 0x8000000000000000, 0},
+		{"F64Mul", 0x8000000000000000, 0x3ff0000000000000, 0x8000000000000000, 0},
+		{"F64Div", 0x3ff0000000000000, 0x8000000000000000, 0xfff0000000000000, 0},
+		{"F64Add", 0x3ff0000000000000, 0x3ca0000000000000, 0x3ff0000000000000, 0},
+		{"F64Add", 0x3ff0000000000001, 0x3ca0000000000000, 0x3ff0000000000002, 0},
+		{"F64Mul", 0x7fefffffffffffff, 0x4000000000000000, 0x7ff0000000000000, 0},
+		{"F64Div", 1, 0x4000000000000000, 0, 0},
+		{"F64Div", 3, 0x4000000000000000, 2, 0},
+		{"F64Sub", 0x7ff0000000000000, 0x7ff0000000000000, 0x7ff8000000000000, 1},
+		{"F64Add", 0xfff8000000000000, 0x3ff0000000000000, 0x7ff8000000000000, 1},
+		{"F64Div", 0x7ff8123456789abc, 0x3ff0000000000000, 0x7ff8000000000000, 2},
+	} {
+		got, nan := wasmFloatArithmeticReference(row.name, row.a, row.b)
+		if got != row.want || nan != row.nanKind {
+			t.Errorf("%s(%x,%x)=%x/NaN%d want=%x/NaN%d",
+				row.name, row.a, row.b, got, nan, row.want, row.nanKind)
+		}
+	}
+}
+
+func TestWASMFloatArithmeticCompleteRuntimeUnion(t *testing.T) {
+	for _, bits := range []int{32, 64} {
+		seen := make(map[uint64]bool)
+		for _, value := range wasmFloatArithmeticSamples(bits) {
+			if seen[value] {
+				t.Fatal("duplicate input shrinks the independent finite/NaN boundary matrix", bits, value)
+			}
+			seen[value] = true
+		}
+		if len(seen) != 28 {
+			t.Fatal("incomplete precision-specific runtime sample axis", bits, len(seen))
+		}
+	}
+	source, original, sigs, _, _, data := wasmFloatArithmeticRuntimeFixture(t)
+	var rows []wasmFloatBinaryRuntimeRow
+	if err := json.Unmarshal(data, &rows); err != nil {
+		t.Fatal(err)
+	}
+	if len(rows) != 32 || len(sigs) != 32 || strings.Count(source, "TEXT ") != 32 || strings.Count(original, "TEXT ") != 32 {
+		t.Fatal("missing whole arithmetic/alias/dead source member", len(rows), len(sigs))
+	}
+	count := 0
+	for _, row := range rows {
+		if len(row.Cases) != 28*28 {
+			t.Fatal("cropped independent arithmetic input matrix", row.Name, len(row.Cases))
+		}
+		count += len(row.Cases)
+	}
+	if count != wasmFloatArithmeticRuntimeCases {
+		t.Fatal("incomplete arithmetic runtime denominator", count)
+	}
+}
+
+func TestWASMFloatArithmeticOriginalGoRuntime(t *testing.T) {
+	_, original, _, _, goSource, _ := wasmFloatArithmeticRuntimeFixture(t)
+	wasmFloatRunOriginal(t, original, goSource, wasmFloatArithmeticRuntimeCases)
+}
+
+func TestWASMFloatArithmeticThreeAPIsFourOptimizationAxesRuntime(t *testing.T) {
+	source, _, sigs, wrappers, _, inputs := wasmFloatArithmeticRuntimeFixture(t)
+	wasmFloatRunLLVM(t, source, sigs, wrappers, inputs, wasmFloatArithmeticRuntimeCases)
+}
diff --git a/wasm_float_arithmetic_test.go b/wasm_float_arithmetic_test.go
new file mode 100644
index 000000000..db4d5c339
--- /dev/null
+++ b/wasm_float_arithmetic_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The selected Go anames/a.out namespace and wasmobj writer define these eight
+// scalar, zero-operand stack operators independently of translator registries.
+func wasmFloatArithmeticGoNames(t *testing.T) []string {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "wasm", "anames.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, match := range regexp.MustCompile(`"(F(?:32|64)(?:Add|Sub|Mul|Div))"`).FindAllSubmatch(data, -1) {
+		names = append(names, string(match[1]))
+	}
+	want := strings.Fields("F32Add F32Sub F32Mul F32Div F64Add F64Sub F64Mul F64Div")
+	if strings.Join(names, " ") != strings.Join(want, " ") {
+		t.Fatal("complete selected-Go arithmetic namespace changed", names)
+	}
+	return names
+}
+
+func wasmFloatArithmeticTypes(name string) (LLVMType, LLVMType, Reg, Reg) {
+	typ, _, first, second := wasmFloatBinaryTestTypes(name)
+	return typ, typ, first, second
+}
+
+func TestWASMFloatArithmeticCompleteGoNamespaceAndObjects(t *testing.T) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, name := range wasmFloatArithmeticGoNames(t) {
+		typ, _, _, _ := wasmFloatArithmeticTypes(name)
+		base := 0
+		if typ == "double" {
+			base = 16
+		}
+		for bank := 0; bank < 16; bank++ {
+			for _, alias := range []bool{false, true} {
+				first := Reg(fmt.Sprintf("F%d", base+bank))
+				second := Reg(fmt.Sprintf("F%d", base+15-bank))
+				if alias {
+					second = first
+				}
+				function := fmt.Sprintf("arithmetic%d", len(sigs))
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\nGet %s\nGet %s\n%s\nReturn\n",
+					function, first, second, name)
+				args, regs := []LLVMType{typ}, []Reg{first}
+				if !alias {
+					args, regs = append(args, typ), append(regs, second)
+				}
+				sigs[function] = FuncSig{Name: function, Args: args, ArgRegs: regs, Ret: typ}
+			}
+		}
+	}
+	if len(sigs) != 256 {
+		t.Fatal("incomplete eight-opcode, sixteen-register, alias matrix", len(sigs))
+	}
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, source.String(), goos)
+	}
+	file, err := Parse(ArchWASM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		want := sigs[fn.Sym]
+		got, err := InferWASMAssemblyFuncSig(fn, fn.Sym)
+		if err != nil || got.Ret != want.Ret || len(got.Args) != len(want.Args) {
+			t.Errorf("complete arithmetic signature for %s: %+v, %v", fn.Sym, got, err)
+			continue
+		}
+		for index := range want.Args {
+			if got.Args[index] != want.Args[index] {
+				t.Errorf("%s argument%d type=%s want=%s", fn.Sym, index, got.Args[index], want.Args[index])
+			}
+		}
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-wasi"} {
+			t.Run(route+"/"+triple, func(t *testing.T) {
+				options := wasmPackedOptions(sigs, WASMABIDirect)
+				options.TargetTriple = triple
+				ir, err := wasmPackedTranslate(t, file, options, route)
+				if err != nil || ir == "" {
+					t.Fatal("complete original Go arithmetic family is not lowerable", err)
+				}
+				wasmFloatArithmeticRequireStrictIR(t, ir)
+				compileLLVMToObject(t, wasmDataTool(t, "llc"), triple, "arithmetic.ll", "arithmetic.o", ir)
+			})
+		}
+	}
+}
+
+func wasmFloatArithmeticRequireStrictIR(t *testing.T, ir string) {
+	t.Helper()
+	if strings.Contains(ir, "blockaddress") ||
+		regexp.MustCompile(`\b(?:fadd|fsub|fmul|fdiv)\s+(?:fast|nnan|ninf|nsz|arcp|contract|afn|reassoc)\b`).MatchString(ir) {
+		t.Fatal("Wasm arithmetic acquired invalid control flow or relaxed IEEE semantics")
+	}
+}
+
+func TestWASMFloatArithmeticRejectsWrongStackAndDeadFormats(t *testing.T) {
+	for _, name := range wasmFloatArithmeticGoNames(t) {
+		typ, _, first, second := wasmFloatArithmeticTypes(name)
+		good := fmt.Sprintf("Get %s\nGet %s\n", first, second)
+		wrong := "F16"
+		if typ == "double" {
+			wrong = "F0"
+		}
+		bodies := []string{
+			name,
+			fmt.Sprintf("Get %s\n%s", first, name),
+			"I32Const $0\nI32Const $1\n" + name,
+			"I64Const $0\nI64Const $1\n" + name,
+			fmt.Sprintf("Get %s\nGet %s\n%s", wrong, second, name),
+			fmt.Sprintf("Get %s\nGet %s\n%s", first, wrong, name),
+			"Get SP\nGet SP\n" + name,
+		}
+		for _, operand := range []string{" $0", " $1.25", " F0", " F0,F1", " 0(SP)", " symbol(SB)", ".invalid"} {
+			bodies = append(bodies, good+name+operand, "RET\n"+name+operand)
+		}
+		for index, body := range bodies {
+			t.Run(fmt.Sprintf("%s/%d", name, index), func(t *testing.T) {
+				file, err := Parse(ArchWASM, "TEXT operation(SB),4,$0-0\n"+body+"\nReturn\n")
+				if err != nil {
+					return // The source parser may reject invalid syntax first.
+				}
+				if got, err := InferWASMAssemblyFuncSig(file.Funcs[0], "operation"); err == nil {
+					t.Errorf("inference accepted an invalid arithmetic stack/format: %+v", got)
+				}
+				for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					options := wasmPackedOptions(map[string]FuncSig{"operation": {Name: "operation", Ret: typ}}, WASMABIDirect)
+					if ir, err := wasmPackedTranslate(t, file, options, route); err == nil || ir != "" {
+						t.Errorf("%s accepted wrong arithmetic stack/format:\n%s", route, body)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestWASMFloatArithmeticTypedGoEntryAndDeadFormats(t *testing.T) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package arithmetic\n")
+	for index, name := range wasmFloatArithmeticGoNames(t) {
+		_, _, first, second := wasmFloatArithmeticTypes(name)
+		fmt.Fprintf(&declarations, "func operation%d()\n", index)
+		fmt.Fprintf(&source, "TEXT ·operation%d(SB),4,$0-0\nGet %s\nGet %s\n%s\nDrop\nRET\n",
+			index, first, second, name)
+	}
+	pkg := mustGoPackage(t, "arithmetic", declarations.String())
+	context := llvm.NewContext()
+	defer context.Dispose()
+	options := GoModuleOptions{GOOS: "js", GOARCH: "wasm", TargetTriple: "wasm32-unknown-unknown",
+		ResolveSym: testResolveSym("arithmetic")}
+	translated, err := translateGoModuleInContext(context, pkg, []byte(source.String()), options)
+	if translated != nil {
+		defer translated.Module.Dispose()
+	}
+	if err != nil || translated == nil {
+		t.Fatal("typed Go arithmetic source is not lowerable", err)
+	}
+	ir := translated.Module.String()
+	wasmFloatArithmeticRequireStrictIR(t, ir)
+	compileLLVMToObject(t, wasmDataTool(t, "llc"), options.TargetTriple, "typed-arithmetic.ll", "typed-arithmetic.o", ir)
+	for _, name := range wasmFloatArithmeticGoNames(t) {
+		malformed := fmt.Sprintf("TEXT ·operation0(SB),4,$0-0\nRET\n%s $1\nRET\n", name)
+		bad, err := translateGoModuleInContext(context, pkg, []byte(malformed), options)
+		if bad != nil {
+			bad.Module.Dispose()
+		}
+		if err == nil || bad != nil {
+			t.Fatalf("typed Go accepted malformed dead %s: %v", name, err)
+		}
+	}
+}
diff --git a/wasm_float_binary.go b/wasm_float_binary.go
new file mode 100644
index 000000000..4eb9c07e8
--- /dev/null
+++ b/wasm_float_binary.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's scalar floating binary families share pure, zero-operand stack grammar.
+// Comparisons produce i32; arithmetic and min/max retain the operand width.
+type wasmFloatBinaryOp struct {
+	typ       LLVMType
+	predicate string
+	intrinsic string
+	operation string
+}
+
+var wasmFloatBinaryOps = map[string]wasmFloatBinaryOp{
+	"F32EQ":  {typ: "float", predicate: "oeq"},
+	"F32NE":  {typ: "float", predicate: "une"},
+	"F32LT":  {typ: "float", predicate: "olt"},
+	"F32GT":  {typ: "float", predicate: "ogt"},
+	"F32LE":  {typ: "float", predicate: "ole"},
+	"F32GE":  {typ: "float", predicate: "oge"},
+	"F64EQ":  {typ: "double", predicate: "oeq"},
+	"F64NE":  {typ: "double", predicate: "une"},
+	"F64LT":  {typ: "double", predicate: "olt"},
+	"F64GT":  {typ: "double", predicate: "ogt"},
+	"F64LE":  {typ: "double", predicate: "ole"},
+	"F64GE":  {typ: "double", predicate: "oge"},
+	"F32MIN": {typ: "float", intrinsic: "minimum"},
+	"F32MAX": {typ: "float", intrinsic: "maximum"},
+	"F64MIN": {typ: "double", intrinsic: "minimum"},
+	"F64MAX": {typ: "double", intrinsic: "maximum"},
+}
+
+var wasmFloatArithmeticOps = map[string]wasmFloatBinaryOp{
+	"F32ADD": {typ: "float", operation: "fadd"},
+	"F32SUB": {typ: "float", operation: "fsub"},
+	"F32MUL": {typ: "float", operation: "fmul"},
+	"F32DIV": {typ: "float", operation: "fdiv"},
+	"F64ADD": {typ: "double", operation: "fadd"},
+	"F64SUB": {typ: "double", operation: "fsub"},
+	"F64MUL": {typ: "double", operation: "fmul"},
+	"F64DIV": {typ: "double", operation: "fdiv"},
+}
+
+func wasmFloatBinaryProperties(op string) (wasmFloatBinaryOp, bool) {
+	if spec, found := wasmFloatBinaryOps[op]; found {
+		return spec, true
+	}
+	spec, found := wasmFloatArithmeticOps[op]
+	return spec, found
+}
+
+func (op wasmFloatBinaryOp) resultType() LLVMType {
+	if op.predicate != "" {
+		return I32
+	}
+	return op.typ
+}
+
+func parseWASMFloatBinary(ins Instr) (wasmFloatBinaryOp, bool, error) {
+	op := normalizeInstructionOpcode(ins.Op)
+	spec, found := wasmFloatBinaryProperties(op)
+	if found && (strings.ToUpper(string(ins.Op)) != op || len(ins.Args) != 0) {
+		return spec, true, fmt.Errorf("%s is a zero-operand WebAssembly stack instruction without suffixes", ins.Op)
+	}
+	return spec, found, nil
+}
diff --git a/wasm_float_binary_runtime_test.go b/wasm_float_binary_runtime_test.go
new file mode 100644
index 000000000..624c6e243
--- /dev/null
+++ b/wasm_float_binary_runtime_test.go
@@ -0,0 +1,388 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type wasmFloatBinaryReference struct {
+	A, B, Want string
+	NaN        int // 0: exact bits, 1: canonical NaN, 2: arithmetic NaN.
+}
+
+func wasmFloatBinarySamples(bits int) []uint64 {
+	if bits == 32 {
+		return []uint64{0, 0x80000000, 1, 0x80000001, 0x007fffff, 0x807fffff,
+			0x00800000, 0x80800000, 0x3f800000, 0xbf800000, 0x7f7fffff, 0xff7fffff,
+			0x7f800000, 0xff800000, 0x7fc00000, 0xffc00000, 0x7fc12345, 0xffc12345,
+			0x7f800001, 0xff800001}
+	}
+	return []uint64{0, 0x8000000000000000, 1, 0x8000000000000001,
+		0x000fffffffffffff, 0x800fffffffffffff, 0x0010000000000000, 0x8010000000000000,
+		0x3ff0000000000000, 0xbff0000000000000, 0x7fefffffffffffff, 0xffefffffffffffff,
+		0x7ff0000000000000, 0xfff0000000000000, 0x7ff8000000000000, 0xfff8000000000000,
+		0x7ff8123456789abc, 0xfff8123456789abc, 0x7ff0000000000001, 0xfff0000000000001}
+}
+
+// Reference the core Wasm relation, not the lowering's predicates/intrinsics.
+// NaN results are a permitted set: exact payload matching to one engine would
+// incorrectly reject other conforming canonical/arithmetic NaN choices.
+func wasmFloatBinaryReferenceValue(name string, a, b uint64) (uint64, int) {
+	sign, exponent, quiet := uint64(1)<<63, uint64(0x7ff0000000000000), uint64(1)<<51
+	x, y := math.Float64frombits(a), math.Float64frombits(b)
+	if strings.HasPrefix(name, "F32") {
+		sign, exponent, quiet = 1<<31, 0x7f800000, 1<<22
+		x, y = float64(math.Float32frombits(uint32(a))), float64(math.Float32frombits(uint32(b)))
+	}
+	isNaN := func(v uint64) bool { return v&exponent == exponent && v&(quiet*2-1) != 0 }
+	nanA, nanB := isNaN(a), isNaN(b)
+	operation := name[3:]
+	if operation == "Min" || operation == "Max" {
+		if nanA || nanB {
+			kind := 1
+			if nanA && a&(quiet*2-1) != quiet || nanB && b&(quiet*2-1) != quiet {
+				kind = 2
+			}
+			return exponent | quiet, kind
+		}
+		if a & ^sign == 0 && b & ^sign == 0 {
+			if operation == "Min" {
+				return a | b, 0
+			}
+			return a & b, 0
+		}
+		if operation == "Min" && x < y || operation == "Max" && x > y {
+			return a, 0
+		}
+		return b, 0
+	}
+	result := false
+	switch operation {
+	case "Eq":
+		result = !nanA && !nanB && x == y
+	case "Ne":
+		result = nanA || nanB || x != y
+	case "Lt":
+		result = !nanA && !nanB && x < y
+	case "Gt":
+		result = !nanA && !nanB && x > y
+	case "Le":
+		result = !nanA && !nanB && x <= y
+	case "Ge":
+		result = !nanA && !nanB && x >= y
+	default:
+		panic("unknown independent Wasm reference operation " + name)
+	}
+	if result {
+		return 1, 0
+	}
+	return 0, 0
+}
+
+type wasmFloatBinaryRuntimeRow struct {
+	Name  string
+	Bits  int
+	Cases []wasmFloatBinaryReference
+}
+
+func wasmFloatBinaryRuntimeFixture(t *testing.T) (string, string, map[string]FuncSig, string, string, []byte) {
+	t.Helper()
+	return wasmFloatRuntimeFixture(t, wasmFloatBinaryGoNames(t), wasmFloatBinaryTestTypes,
+		wasmFloatBinarySamples, wasmFloatBinaryReferenceValue)
+}
+
+// Share the actual ABI adapter, bounded execution and NaN-set checkers across
+// floating families. Each caller supplies its independent full opcode/input
+// inventory and reference; the existing comparison/minmax denominator is fixed.
+func wasmFloatRuntimeFixture(t *testing.T, names []string,
+	types func(string) (LLVMType, LLVMType, Reg, Reg), samples func(int) []uint64,
+	reference func(string, uint64, uint64) (uint64, int)) (string, string, map[string]FuncSig, string, string, []byte) {
+	t.Helper()
+	var source, original, wrapper, goSource strings.Builder
+	goSource.WriteString("package main\nimport (\"encoding/json\";\"fmt\";\"strconv\")\n")
+	sigs := make(map[string]FuncSig)
+	var rows []wasmFloatBinaryRuntimeRow
+	for _, opcode := range names {
+		typ, result, _, _ := types(opcode)
+		bits, base := 32, 0
+		if typ == "double" {
+			bits, base = 64, 16
+		}
+		for _, alias := range []bool{false, true} {
+			for _, dead := range []bool{false, true} {
+				name := fmt.Sprintf("kernel%d", len(rows))
+				first, second := Reg(fmt.Sprintf("F%d", base+15)), Reg(fmt.Sprintf("F%d", base))
+				if alias {
+					second = first
+				}
+				body := fmt.Sprintf("Get %s\nGet %s\n%s\n", first, second, opcode)
+				ret := result
+				if dead {
+					body += "Drop\nI64Const $0\n"
+					ret = I64
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%sReturn\n", name, body)
+				args, regs := []LLVMType{typ}, []Reg{first}
+				if !alias {
+					args, regs = append(args, typ), append(regs, second)
+				}
+				sigs[name] = FuncSig{Name: name, Args: args, ArgRegs: regs, Ret: ret}
+				// This is the original Go ABI adapter, not translated test-only
+				// transport: the exact Get/Get/op/Drop region is shared above.
+				fmt.Fprintf(&original, "TEXT ·%s(SB),4,$0-24\nMOVD $0,ret+16(FP)\nF%dLoad a+0(FP)\nSet %s\n", name, bits, first)
+				if !alias {
+					fmt.Fprintf(&original, "F%dLoad b+8(FP)\nSet %s\n", bits, second)
+				}
+				store := "I32Store"
+				if dead {
+					store = "I64Store"
+				} else if result == typ {
+					store = fmt.Sprintf("F%dStore", bits)
+				}
+				fmt.Fprintf(&original, "Get SP\n%s%s ret+16(FP)\nRET\n", body, store)
+				fmt.Fprintf(&goSource, "func %s(a,b uint64) uint64\n", name)
+				fmt.Fprintf(&wrapper, "define i64 @probe_%s(i64 %%a,i64 %%b){\n", name)
+				integer := "i64"
+				for _, arg := range []string{"a", "b"} {
+					value := "%" + arg
+					if bits == 32 {
+						integer = "i32"
+						fmt.Fprintf(&wrapper, "%%%s32 = trunc i64 %%%s to i32\n", arg, arg)
+						value += "32"
+					}
+					fmt.Fprintf(&wrapper, "%%%sf = bitcast %s %s to %s\n", arg, integer, value, typ)
+				}
+				fmt.Fprintf(&wrapper, "%%value = call %s @%s(%s %%af", ret, name, typ)
+				if !alias {
+					fmt.Fprintf(&wrapper, ",%s %%bf", typ)
+				}
+				wrapper.WriteString(")\n")
+				if dead {
+					wrapper.WriteString("ret i64 %value\n}\n")
+				} else {
+					value := "%value"
+					if result == typ {
+						fmt.Fprintf(&wrapper, "%%raw = bitcast %s %%value to %s\n", typ, integer)
+						value = "%raw"
+					} else {
+						integer = "i32"
+					}
+					if integer == "i32" {
+						fmt.Fprintf(&wrapper, "%%wide = zext i32 %s to i64\n", value)
+						value = "%wide"
+					}
+					fmt.Fprintf(&wrapper, "ret i64 %s\n}\n", value)
+				}
+				row := wasmFloatBinaryRuntimeRow{Name: name, Bits: bits}
+				for _, a := range samples(bits) {
+					for _, b := range samples(bits) {
+						rhs := b
+						if alias {
+							rhs = a
+						}
+						want, nan := reference(opcode, a, rhs)
+						if dead {
+							want, nan = 0, 0
+						}
+						row.Cases = append(row.Cases, wasmFloatBinaryReference{fmt.Sprint(a), fmt.Sprint(b), fmt.Sprint(want), nan})
+					}
+				}
+				rows = append(rows, row)
+			}
+		}
+	}
+	encoded, err := json.Marshal(rows)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fns := make([]string, len(rows))
+	for i, row := range rows {
+		fns[i] = row.Name
+	}
+	fmt.Fprintf(&goSource, "var inputs=%q\nvar functions=[]func(uint64,uint64)uint64{%s}\n", encoded, strings.Join(fns, ","))
+	goSource.WriteString(wasmFloatBinaryGoCheck)
+	return source.String(), original.String(), sigs, wrapper.String(), goSource.String(), encoded
+}
+
+const wasmFloatBinaryGoCheck = `
+type reference struct {
+ A, B, Want string
+ NaN int
+}
+type row struct {
+ Name string
+ Bits int
+ Cases []reference
+}
+
+func number(s string) uint64 {
+ value, err := strconv.ParseUint(s, 10, 64)
+ if err != nil {
+  panic(err)
+ }
+ return value
+}
+
+func main() {
+ var rows []row
+ if err := json.Unmarshal([]byte(inputs), &rows); err != nil {
+  panic(err)
+ }
+ count := 0
+ for i, r := range rows {
+  for _, c := range r.Cases {
+   got := functions[i](number(c.A), number(c.B))
+   want := number(c.Want)
+   good := got == want
+   if c.NaN != 0 {
+    exponent, quiet, sign := uint64(0x7ff0000000000000), uint64(1)<<51, uint64(1)<<63
+    if r.Bits == 32 {
+     exponent, quiet, sign = 0x7f800000, 1<<22, 1<<31
+    }
+    good = got&exponent == exponent && got&quiet != 0 && got & ^(sign|exponent|(quiet*2-1)) == 0
+    if c.NaN == 1 {
+     good = good && got & ^sign == want
+    }
+   }
+   if !good {
+    panic(fmt.Sprintf("%s/%s/%s: %x want %x nan=%d", r.Name, c.A, c.B, got, want, c.NaN))
+   }
+   count++
+  }
+ }
+ fmt.Printf("actual Go Wasm float binary PASS %d\n", count)
+}
+`
+
+func TestWASMFloatBinaryOriginalGoRuntime(t *testing.T) {
+	_, source, _, _, goSource, _ := wasmFloatBinaryRuntimeFixture(t)
+	wasmFloatRunOriginal(t, source, goSource, 25600)
+}
+
+func wasmFloatRunOriginal(t *testing.T, source, goSource string, count int) {
+	t.Helper()
+	dir := t.TempDir()
+	for name, data := range map[string]string{"go.mod": "module float_binary_oracle\ngo 1.20\n", "main.go": goSource, "oracle_wasm.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "build", "-o", "oracle.wasm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOOS=js", "GOARCH=wasm", "GOTOOLCHAIN=local")
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("original Go build: %v\n%s", err, output)
+	}
+	cmd, err := wasmPackedGoRuntimeCommand(ctx, runtime.GOROOT(), wasmPackedNode(t), filepath.Join(dir, "oracle.wasm"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil || strings.TrimSpace(string(output)) != fmt.Sprintf("actual Go Wasm float binary PASS %d", count) {
+		t.Fatalf("original Go runtime: %v\n%s", err, output)
+	}
+	t.Log(strings.TrimSpace(string(output)))
+}
+
+func wasmFloatBinaryCommand(t *testing.T, command string, arguments ...string) string {
+	t.Helper()
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, command, arguments...))
+	if err != nil {
+		t.Fatalf("%s %q: %v\n%s", filepath.Base(command), arguments, err, output)
+	}
+	return string(output)
+}
+
+func TestWASMFloatBinaryThreeAPIsFourOptimizationAxesRuntime(t *testing.T) {
+	source, _, sigs, wrappers, _, inputs := wasmFloatBinaryRuntimeFixture(t)
+	wasmFloatRunLLVM(t, source, sigs, wrappers, inputs, 25600)
+}
+
+func wasmFloatRunLLVM(t *testing.T, source string, sigs map[string]FuncSig, wrappers string, inputs []byte, count int) {
+	t.Helper()
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-wasi"} {
+			options := wasmPackedOptions(sigs, WASMABIDirect)
+			options.TargetTriple = triple
+			ir, err := wasmPackedTranslate(t, file, options, route)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "blockaddress") || strings.Contains(ir, " fcmp fast ") {
+				t.Fatal("Wasm float lowering introduced invalid control flow or relaxed float semantics")
+			}
+			for _, optimize := range []bool{false, true} {
+				for _, backend := range []string{"0", "2"} {
+					t.Run(fmt.Sprintf("%s/%s/IR-O2=%t/llc-O%s", route, triple, optimize, backend), func(t *testing.T) {
+						dir := t.TempDir()
+						input, object, binary := filepath.Join(dir, "input.ll"), filepath.Join(dir, "output.o"), filepath.Join(dir, "output.wasm")
+						if err := os.WriteFile(input, []byte(ir+wrappers), 0600); err != nil {
+							t.Fatal(err)
+						}
+						if optimize {
+							optimized := filepath.Join(dir, "optimized.ll")
+							wasmFloatBinaryCommand(t, wasmDataTool(t, "opt"), "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+							input = optimized
+						}
+						wasmFloatBinaryCommand(t, wasmDataTool(t, "llc"), "-O"+backend, "-filetype=obj", input, "-o", object)
+						if header := wasmFloatBinaryCommand(t, wasmDataTool(t, "llvm-readobj"), "--file-headers", object); !strings.Contains(header, "Format: WASM") {
+							t.Fatalf("not a real Wasm object:\n%s", header)
+						}
+						wasmFloatBinaryCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", object, "-o", binary)
+						inputJSON := filepath.Join(dir, "inputs.json")
+						if err := os.WriteFile(inputJSON, inputs, 0600); err != nil {
+							t.Fatal(err)
+						}
+						output := wasmFloatBinaryCommand(t, wasmPackedNode(t), "-e", wasmFloatBinaryNodeCheck, binary, inputJSON)
+						if strings.TrimSpace(output) != fmt.Sprintf("LLVM Wasm float binary PASS %d", count) {
+							t.Fatalf("runtime failed to consume complete matrix: %s", output)
+						}
+						t.Log(strings.TrimSpace(output))
+					})
+				}
+			}
+		}
+	}
+}
+
+const wasmFloatBinaryNodeCheck = `
+const fs = require('fs');
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]), {}).then(({instance:{exports:e}}) => {
+  const rows = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  let count = 0;
+  for (const row of rows) {
+    const fn = e['probe_' + row.Name];
+    for (const c of row.Cases) {
+      const got = BigInt.asUintN(64, fn(BigInt(c.A), BigInt(c.B)));
+      const want = BigInt(c.Want);
+      let good = got === want;
+      if (c.NaN !== 0) {
+        const exponent = row.Bits === 32 ? 0x7f800000n : 0x7ff0000000000000n;
+        const quiet = 1n << BigInt(row.Bits === 32 ? 22 : 51);
+        const sign = 1n << BigInt(row.Bits - 1);
+        good = (got & exponent) === exponent && (got & quiet) !== 0n &&
+          (got & ~(sign | exponent | (quiet * 2n - 1n))) === 0n;
+        if (c.NaN === 1) good = good && (got & ~sign) === want;
+      }
+      if (!good) throw Error(row.Name + '/' + c.A + '/' + c.B + ': ' + got.toString(16) + ' want ' + want.toString(16) + ' nan=' + c.NaN);
+      count++;
+    }
+  }
+  console.log('LLVM Wasm float binary PASS ' + count);
+}).catch(error => { console.error(error); process.exit(1); });
+`
diff --git a/wasm_float_binary_test.go b/wasm_float_binary_test.go
new file mode 100644
index 000000000..cf447c5cb
--- /dev/null
+++ b/wasm_float_binary_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Discover the whole namespace from the selected Go compiler, independently
+// of the implementation's map and the official corpus's observed mnemonics.
+func wasmFloatBinaryGoNames(t *testing.T) []string {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "wasm", "anames.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, match := range regexp.MustCompile(`"(F(?:32|64)(?:Eq|Ne|Lt|Gt|Le|Ge|Min|Max))"`).FindAllSubmatch(data, -1) {
+		names = append(names, string(match[1]))
+	}
+	if len(names) != 16 {
+		t.Fatalf("selected Go float comparison/minmax namespace changed: %v", names)
+	}
+	return names
+}
+
+func wasmFloatBinaryTestTypes(name string) (LLVMType, LLVMType, Reg, Reg) {
+	typ, first, second := LLVMType("float"), Reg("F0"), Reg("F1")
+	if strings.HasPrefix(name, "F64") {
+		typ, first, second = "double", "F16", "F17"
+	}
+	result := I32
+	if strings.HasSuffix(name, "Min") || strings.HasSuffix(name, "Max") {
+		result = typ
+	}
+	return typ, result, first, second
+}
+
+func TestWASMFloatBinaryWholeGoNamespace(t *testing.T) {
+	for _, name := range wasmFloatBinaryGoNames(t) {
+		t.Run(name, func(t *testing.T) {
+			typ, result, first, second := wasmFloatBinaryTestTypes(name)
+			source := fmt.Sprintf("TEXT operation(SB),4,$0-0\nGet %s\nGet %s\n%s\nReturn\n", first, second, name)
+			wasmDataGoObject(t, source, "js")
+			file, err := Parse(ArchWASM, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := FuncSig{Name: "operation", Args: []LLVMType{typ, typ}, Ret: result, ArgRegs: []Reg{first, second}}
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"operation": sig}, WASMABIDirect), route)
+				if err != nil || ir == "" {
+					t.Errorf("%s actual Go opcode not implemented: %v", route, err)
+				}
+			}
+			inferred, err := InferWASMAssemblyFuncSig(file.Funcs[0], "operation")
+			if err != nil || inferred.Ret != result || len(inferred.Args) != 2 || inferred.Args[0] != typ || inferred.Args[1] != typ {
+				t.Errorf("actual Go stack signature not inferred: %+v, %v", inferred, err)
+			}
+		})
+	}
+}
+
+func TestWASMFloatBinaryRejectsOperandsEvenWhenDead(t *testing.T) {
+	for _, name := range wasmFloatBinaryGoNames(t) {
+		for _, operand := range []string{" $0", " $1.25", " F0", " F0,F1", " 0(SP)", " symbol(SB)"} {
+			for _, dead := range []bool{false, true} {
+				prefix := ""
+				if dead {
+					prefix = "RET\n"
+				}
+				file, err := Parse(ArchWASM, "TEXT operation(SB),4,$0-0\n"+prefix+name+operand+"\nRET\n")
+				if err != nil {
+					continue
+				}
+				for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"operation": {Name: "operation", Ret: Void}}, WASMABIDirect), route)
+					if err == nil || ir != "" {
+						t.Errorf("%s accepted %s%s, dead=%t", route, name, operand, dead)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestWASMFloatBinaryTypedStackAndRegisterMatrix(t *testing.T) {
+	names := wasmFloatBinaryGoNames(t)
+	if len(wasmFloatBinaryOps) != len(names) {
+		t.Fatal("typed family is not the complete, exact Go namespace")
+	}
+	var allSource strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, name := range names {
+		typ, result, first, second := wasmFloatBinaryTestTypes(name)
+		if _, ok := wasmFloatBinaryOps[strings.ToUpper(name)]; !ok {
+			t.Fatalf("official opcode absent from typed grammar: %s", name)
+		}
+		base := 0
+		if typ == "double" {
+			base = 16
+		}
+		for bank := 0; bank < 16; bank++ {
+			for _, alias := range []bool{false, true} {
+				x, y := Reg(fmt.Sprintf("F%d", base+bank)), Reg(fmt.Sprintf("F%d", base+15-bank))
+				if alias {
+					y = x
+				}
+				function := fmt.Sprintf("bank%d", len(sigs))
+				fmt.Fprintf(&allSource, "TEXT %s(SB),4,$0-0\nGet %s\nGet %s\n%s\nDrop\nRET\n", function, x, y, name)
+				sigs[function] = FuncSig{Name: function, Ret: Void}
+			}
+		}
+		good := fmt.Sprintf("Get %s\nGet %s\n", first, second)
+		wrong := "Get F16\n"
+		if typ == "double" {
+			wrong = "Get F0\n"
+		}
+		for _, body := range []string{
+			name,
+			fmt.Sprintf("Get %s\n%s", first, name),
+			"I32Const $0\nI32Const $1\n" + name,
+			"I64Const $0\nI64Const $1\n" + name,
+			wrong + fmt.Sprintf("Get %s\n%s", second, name),
+			fmt.Sprintf("Get %s\n", first) + wrong + name,
+			good + name + ".invalid",
+		} {
+			file, err := Parse(ArchWASM, "TEXT operation(SB),4,$0-0\n"+body+"\nReturn\n")
+			if err != nil {
+				// The source parser owns target-independent suffix rejection.
+				continue
+			}
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"operation": {Name: "operation", Ret: result}}, WASMABIDirect), route)
+				if err == nil || ir != "" {
+					t.Fatalf("%s accepted invalid typed stack:\n%s", route, body)
+				}
+			}
+			if sig, err := InferWASMAssemblyFuncSig(file.Funcs[0], "operation"); err == nil {
+				t.Fatalf("inference accepted invalid typed stack as %+v:\n%s", sig, body)
+			}
+		}
+	}
+	// Every register in both width banks, reversed source order and aliasing
+	// is accepted by actual Go and compiled by each public LLVM route.
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, allSource.String(), goos)
+	}
+	file, err := Parse(ArchWASM, allSource.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIDirect), route)
+		if err != nil {
+			t.Fatal(err)
+		}
+		compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "banks.ll", "banks.o", ir)
+	}
+}
+
+func TestWASMFloatBinaryTypedGoEntryAndDeadFormat(t *testing.T) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package floatbinary\n")
+	for index, name := range wasmFloatBinaryGoNames(t) {
+		_, _, first, second := wasmFloatBinaryTestTypes(name)
+		fmt.Fprintf(&declarations, "func operation%d()\n", index)
+		fmt.Fprintf(&source, "TEXT ·operation%d(SB),4,$0-0\nGet %s\nGet %s\n%s\nDrop\nRET\n", index, first, second, name)
+	}
+	pkg := mustGoPackage(t, "floatbinary", declarations.String())
+	context := llvm.NewContext()
+	defer context.Dispose()
+	options := GoModuleOptions{GOOS: "js", GOARCH: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: testResolveSym("floatbinary")}
+	translated, err := translateGoModuleInContext(context, pkg, []byte(source.String()), options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := translated.Module.String()
+	translated.Module.Dispose()
+	compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "typed-go.ll", "typed-go.o", ir)
+	for _, name := range wasmFloatBinaryGoNames(t) {
+		malformed := fmt.Sprintf("TEXT ·operation0(SB),4,$0-0\nRET\n%s $1\nRET\n", name)
+		translated, err := translateGoModuleInContext(context, pkg, []byte(malformed), options)
+		if translated != nil {
+			translated.Module.Dispose()
+		}
+		if err == nil || translated != nil {
+			t.Fatalf("typed Go accepted malformed dead %s: %v", name, err)
+		}
+	}
+}
diff --git a/wasm_goabi_test.go b/wasm_goabi_test.go
index 03d24d40a..6728a0c91 100644
--- a/wasm_goabi_test.go
+++ b/wasm_goabi_test.go
@@ -59,6 +59,38 @@ TEXT unwind(SB), NOSPLIT, $0-0
 	}
 }
 
+func TestWasmGoABIResumeDispatchOmitsCallsAfterTerminatingTailReturn(t *testing.T) {
+	file, err := Parse(ArchWASM, `TEXT caller(SB), NOSPLIT, $0-0
+	CALL first(SB)
+	RET tail(SB)
+	CALL unreachable(SB)
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := map[string]FuncSig{
+		"caller":      {Name: "caller", Ret: Void},
+		"first":       {Name: "first", Ret: Void},
+		"tail":        {Name: "tail", Ret: Void},
+		"unreachable": {Name: "unreachable", Ret: Void},
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "wasm32-unknown-unknown",
+		Sigs:         sigs,
+		Goarch:       "wasm",
+		WASMABI:      WASMABIGo,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "i32 1, label %wasm_resume_1") {
+		t.Fatalf("reachable CALL is absent from resume dispatch:\n%s", ir)
+	}
+	if strings.Contains(ir, "wasm_resume_2") {
+		t.Fatalf("unreachable CALL leaked into resume dispatch:\n%s", ir)
+	}
+}
+
 func TestWasmRETUNWINDRequiresGoABI(t *testing.T) {
 	file, err := Parse(ArchWASM, "TEXT unwind(SB), NOSPLIT, $0-0\nRETUNWIND\n")
 	if err != nil {
diff --git a/wasm_infer.go b/wasm_infer.go
index 2c57d1bb8..d2540a94d 100644
--- a/wasm_infer.go
+++ b/wasm_infer.go
@@ -28,6 +28,7 @@ func InferWASMAssemblyFuncSig(fn Func, name string) (FuncSig, error) {
 		written    = make(map[Reg]bool)
 		returnType LLVMType
 		controls   []inferControl
+		terminated bool
 	)
 	copyStack := func(values []wasmInferValue) []wasmInferValue {
 		return append([]wasmInferValue(nil), values...)
@@ -76,6 +77,79 @@ func InferWASMAssemblyFuncSig(fn Func, name string) (FuncSig, error) {
 
 	for _, ins := range fn.Instrs {
 		op := normalizeInstructionOpcode(ins.Op)
+		// Validate typed source formats even when the instruction is dead,
+		// matching translateFuncWASM's prepass. Retain these descriptors for
+		// live stack inference instead of parsing them again.
+		vector, vectorKnown, err := parseWASMV128Core(ins)
+		if err != nil {
+			return FuncSig{}, err
+		}
+		count, countKnown, err := parseWASMIntegerCount(ins)
+		if err != nil {
+			return FuncSig{}, err
+		}
+		floating, floatingKnown, err := parseWASMFloatBinary(ins)
+		if err != nil {
+			return FuncSig{}, err
+		}
+		if terminated && op != "ELSE" && op != "END" && op != "LABEL" {
+			continue
+		}
+		if op == "ELSE" || op == "END" {
+			terminated = false
+		}
+		if vectorKnown {
+			spec := vector
+			if len(stack) < spec.inputs {
+				return FuncSig{}, fmt.Errorf("%s: %s requires %d V128 stack operands", name, op, spec.inputs)
+			}
+			for index := 0; index < spec.inputs; index++ {
+				value := pop(op)
+				for reg := range value.regs {
+					if wasmDefaultRegisterType(reg) != wasmV128CoreType {
+						return FuncSig{}, fmt.Errorf("%s: %s register %s does not carry V128", name, op, reg)
+					}
+				}
+				if err := require(value, wasmV128CoreType); err != nil {
+					return FuncSig{}, err
+				}
+			}
+			push(wasmInferValue{typ: spec.resultType()})
+			continue
+		}
+		if countKnown {
+			spec := count
+			if len(stack) == 0 {
+				return FuncSig{}, fmt.Errorf("%s: %s requires one stack operand", name, op)
+			}
+			for reg := range stack[len(stack)-1].regs {
+				typ := wasmDefaultRegisterType(reg)
+				if typ != I32 && typ != I64 {
+					return FuncSig{}, fmt.Errorf("%s: %s register %s is not an integer", name, op, reg)
+				}
+			}
+			if err := typedUnary(op, spec.typ, spec.typ); err != nil {
+				return FuncSig{}, err
+			}
+			continue
+		}
+		if floatingKnown {
+			spec := floating
+			if len(stack) < 2 {
+				return FuncSig{}, fmt.Errorf("%s: %s requires two stack operands", name, op)
+			}
+			for _, value := range stack[len(stack)-2:] {
+				for reg := range value.regs {
+					if wasmDefaultRegisterType(reg) != spec.typ {
+						return FuncSig{}, fmt.Errorf("%s: %s register %s does not carry %s", name, op, reg, spec.typ)
+					}
+				}
+			}
+			if err := typedBinary(op, spec.typ, spec.resultType()); err != nil {
+				return FuncSig{}, err
+			}
+			continue
+		}
 		switch op {
 		case "TEXT", "NOP", "NO_LOCAL_POINTERS", "LABEL":
 		case "GET":
@@ -239,6 +313,7 @@ func InferWASMAssemblyFuncSig(fn Func, name string) (FuncSig, error) {
 				}
 			}
 		case "BR":
+			terminated = true
 			if len(controls) != 0 {
 				control := controls[len(controls)-1]
 				if control.result != "" && len(stack) > len(control.base) {
@@ -250,6 +325,9 @@ func InferWASMAssemblyFuncSig(fn Func, name string) (FuncSig, error) {
 			stack = nil
 		case "DROP":
 			_ = pop(op)
+		case "UNDEF", "UNREACHABLE", "JMP":
+			terminated = true
+			stack = nil
 		case "CALL", "CALLNORESUME", "WASMCALL":
 			// The callee signature is not encoded in the instruction. Values
 			// pushed for it have already constrained the input registers; reset
@@ -257,6 +335,7 @@ func InferWASMAssemblyFuncSig(fn Func, name string) (FuncSig, error) {
 			stack = nil
 			push(wasmInferValue{})
 		case "WASMRETURN", "RET", "RETUNWIND":
+			terminated = true
 			if len(stack) != 0 {
 				v := pop(op)
 				if v.typ != "" {
diff --git a/wasm_infer_test.go b/wasm_infer_test.go
index 83ca9a2e1..38d3deac4 100644
--- a/wasm_infer_test.go
+++ b/wasm_infer_test.go
@@ -149,6 +149,7 @@ func TestInferWasmDiagnostics(t *testing.T) {
 		name string
 		src  string
 		want string
+		ret  LLVMType
 	}{
 		{name: "empty pop remains unknown", src: "Drop\nReturn"},
 		{name: "malformed get is ignored", src: "Get\nReturn"},
@@ -175,7 +176,8 @@ func TestInferWasmDiagnostics(t *testing.T) {
 		{name: "else result", src: "I32Const $1\nIf $1\nI64Const $2\nElse\nI32Const $3\nEnd", want: "conflicting stack types"},
 		{name: "end result", src: "Block $1\nI64Const $1\nEnd", want: "conflicting stack types"},
 		{name: "branch result", src: "Block $1\nI64Const $1\nBr $0", want: "conflicting stack types"},
-		{name: "return types", src: "I32Const $1\nReturn\nI64Const $1\nReturn", want: "conflicting return types"},
+		{name: "return types", src: "I32Const $1\nReturn\nI64Const $1\nReturn", ret: I32},
+		{name: "reachable return types", src: "Get R0\nIf\nI32Const $1\nReturn\nElse\nI64Const $1\nReturn\nEnd", want: "conflicting return types"},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
@@ -183,11 +185,14 @@ func TestInferWasmDiagnostics(t *testing.T) {
 			if err != nil {
 				t.Fatal(err)
 			}
-			_, err = InferWASMAssemblyFuncSig(file.Funcs[0], "helper")
+			got, err := InferWASMAssemblyFuncSig(file.Funcs[0], "helper")
 			if tc.want == "" {
 				if err != nil {
 					t.Fatal(err)
 				}
+				if tc.ret != "" && got.Ret != tc.ret {
+					t.Fatalf("return type = %s, want %s", got.Ret, tc.ret)
+				}
 				return
 			}
 			if err == nil || !strings.Contains(err.Error(), tc.want) {
diff --git a/wasm_integer_count.go b/wasm_integer_count.go
new file mode 100644
index 000000000..b926fddd3
--- /dev/null
+++ b/wasm_integer_count.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type wasmIntegerCountOp struct {
+	typ       LLVMType
+	intrinsic string
+}
+
+// All six Go scalar count operators consume and produce the same integer
+// width. CLZ and CTZ are defined for zero: their result is the bit width.
+var wasmIntegerCountOps = map[string]wasmIntegerCountOp{
+	"I32CLZ":    {I32, "ctlz"},
+	"I32CTZ":    {I32, "cttz"},
+	"I32POPCNT": {I32, "ctpop"},
+	"I64CLZ":    {I64, "ctlz"},
+	"I64CTZ":    {I64, "cttz"},
+	"I64POPCNT": {I64, "ctpop"},
+}
+
+func parseWASMIntegerCount(ins Instr) (wasmIntegerCountOp, bool, error) {
+	op := normalizeInstructionOpcode(ins.Op)
+	spec, found := wasmIntegerCountOps[op]
+	if found && (strings.ToUpper(string(ins.Op)) != op || len(ins.Args) != 0) {
+		return spec, true, fmt.Errorf("%s is a zero-operand WebAssembly stack instruction without suffixes", ins.Op)
+	}
+	return spec, found, nil
+}
diff --git a/wasm_integer_count_runtime_test.go b/wasm_integer_count_runtime_test.go
new file mode 100644
index 000000000..b52f79be0
--- /dev/null
+++ b/wasm_integer_count_runtime_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/bits"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type wasmIntegerCountRow struct {
+	Name  string
+	Cases [][2]string
+}
+
+func wasmIntegerCountFixture(t *testing.T) (string, string, string, map[string]FuncSig, []byte, int) {
+	t.Helper()
+	var source, original, goSource strings.Builder
+	goSource.WriteString("package main\n\nimport \"fmt\"\n\n")
+	var rows []wasmIntegerCountRow
+	sigs := make(map[string]FuncSig)
+	count := 0
+	for _, opcode := range wasmIntegerCountGoNames(t) {
+		name := strings.ToLower(opcode)
+		body := wasmIntegerCountBody(opcode, "R0")
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%sReturn\n", name, body)
+		fmt.Fprintf(&original, "TEXT ·%s(SB),4,$0-16\nMOVD a+0(FP),R0\nGet SP\n%sI64Store ret+8(FP)\nRET\n", name, body)
+		fmt.Fprintf(&goSource, "func %s(a uint64) uint64\n", name)
+		sigs[name] = FuncSig{Name: name, Args: []LLVMType{I64}, ArgRegs: []Reg{"R0"}, Ret: I64}
+		row := wasmIntegerCountRow{Name: name}
+		inputs := []uint64{0, ^uint64(0), 0x5555555555555555, 0xaaaaaaaaaaaaaaaa, 0xffffffff00000000}
+		for bit := uint(0); bit < 64; bit++ {
+			inputs = append(inputs, 1<<bit, ^(uint64(1) << bit))
+		}
+		for _, input := range inputs {
+			leading, trailing, ones := bits.LeadingZeros64(input), bits.TrailingZeros64(input), bits.OnesCount64(input)
+			if strings.HasPrefix(opcode, "I32") {
+				leading, trailing, ones = bits.LeadingZeros32(uint32(input)), bits.TrailingZeros32(uint32(input)), bits.OnesCount32(uint32(input))
+			}
+			want := ones
+			if strings.HasSuffix(opcode, "Clz") {
+				want = leading
+			} else if strings.HasSuffix(opcode, "Ctz") {
+				want = trailing
+			}
+			row.Cases = append(row.Cases, [2]string{fmt.Sprint(input), fmt.Sprint(want)})
+			count++
+		}
+		rows = append(rows, row)
+	}
+	goSource.WriteString("\nfunc main() {\n\tcount := 0\n")
+	for _, row := range rows {
+		for _, sample := range row.Cases {
+			fmt.Fprintf(&goSource, "\tif got := %s(%s); got != %s {\n\t\tpanic(fmt.Sprintf(\"%s/%s: %%d\", got))\n\t}\n\tcount++\n",
+				row.Name, sample[0], sample[1], row.Name, sample[0])
+		}
+	}
+	goSource.WriteString("\tfmt.Printf(\"integer-count PASS %d\\n\", count)\n}\n")
+	if len(rows) != 6 || count != 798 {
+		t.Fatal("complete six-opcode, zero/boundary/every-bit runtime inventory changed", len(rows), count)
+	}
+	data, err := json.Marshal(rows)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source.String(), original.String(), goSource.String(), sigs, data, count
+}
+
+func TestWASMIntegerCountOriginalGoRuntime(t *testing.T) {
+	_, source, goSource, _, _, count := wasmIntegerCountFixture(t)
+	dir := t.TempDir()
+	for name, text := range map[string]string{"go.mod": "module integer_count_oracle\ngo 1.20\n", "main.go": goSource, "oracle_wasm.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "go", "build", "-o", "oracle.wasm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOOS=js", "GOARCH=wasm", "GOTOOLCHAIN=local")
+	if output, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("original Go build: %v\n%s", err, output)
+	}
+	cmd, err := wasmPackedGoRuntimeCommand(ctx, runtime.GOROOT(), wasmPackedNode(t), filepath.Join(dir, "oracle.wasm"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil || strings.TrimSpace(string(output)) != fmt.Sprintf("integer-count PASS %d", count) {
+		t.Fatalf("original Go execution: %v\n%s", err, output)
+	}
+}
+
+func TestWASMIntegerCountLLVMRuntime(t *testing.T) {
+	source, _, _, sigs, inputs, count := wasmIntegerCountFixture(t)
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-wasi"} {
+			options := wasmPackedOptions(sigs, WASMABIDirect)
+			options.TargetTriple = triple
+			ir, err := wasmPackedTranslate(t, file, options, route)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimize := range []bool{false, true} {
+				for _, backend := range []string{"0", "2"} {
+					t.Run(fmt.Sprintf("%s/%s/IR-O2=%t/llc-O%s", route, triple, optimize, backend), func(t *testing.T) {
+						dir := t.TempDir()
+						input, object, binary := filepath.Join(dir, "input.ll"), filepath.Join(dir, "output.o"), filepath.Join(dir, "output.wasm")
+						if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+							t.Fatal(err)
+						}
+						if optimize {
+							optimized := filepath.Join(dir, "optimized.ll")
+							wasmFloatBinaryCommand(t, wasmDataTool(t, "opt"), "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+							input = optimized
+						}
+						wasmFloatBinaryCommand(t, wasmDataTool(t, "llc"), "-O"+backend, "-filetype=obj", input, "-o", object)
+						wasmFloatBinaryCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", object, "-o", binary)
+						inputJSON := filepath.Join(dir, "inputs.json")
+						if err := os.WriteFile(inputJSON, inputs, 0600); err != nil {
+							t.Fatal(err)
+						}
+						output := wasmFloatBinaryCommand(t, wasmPackedNode(t), "-e", wasmIntegerCountNodeCheck, binary, inputJSON)
+						if strings.TrimSpace(output) != fmt.Sprintf("integer-count PASS %d", count) {
+							t.Fatal("execution did not consume the complete input matrix", output)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+const wasmIntegerCountNodeCheck = `
+const fs = require('fs');
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]), {}).then(({instance:{exports:e}}) => {
+  const rows = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  let count = 0;
+  for (const row of rows) {
+    for (const [input, want] of row.Cases) {
+      const got = e[row.Name](BigInt(input));
+      if (got !== BigInt(want)) throw Error(row.Name + '/' + input + ': ' + got + ' want ' + want);
+      count++;
+    }
+  }
+  console.log('integer-count PASS ' + count);
+}).catch(error => { console.error(error); process.exit(1); });
+`
diff --git a/wasm_integer_count_test.go b/wasm_integer_count_test.go
new file mode 100644
index 000000000..4d866d614
--- /dev/null
+++ b/wasm_integer_count_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func wasmIntegerCountGoNames(t *testing.T) []string {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/wasm/anames.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, match := range regexp.MustCompile(`"(I(?:32|64)(?:Clz|Ctz|Popcnt))"`).FindAllSubmatch(data, -1) {
+		names = append(names, string(match[1]))
+	}
+	if len(names) != 6 {
+		t.Fatal("complete Go unary integer-count namespace changed", names)
+	}
+	return names
+}
+
+func wasmIntegerCountBody(name, reg string) string {
+	body := "Get " + reg + "\n"
+	if strings.HasPrefix(name, "I32") {
+		return body + "I32WrapI64\n" + name + "\nI64ExtendI32U\n"
+	}
+	return body + name + "\n"
+}
+
+func TestWASMIntegerCountCompleteGoNamespace(t *testing.T) {
+	if len(wasmIntegerCountOps) != len(wasmIntegerCountGoNames(t)) {
+		t.Fatal("typed count family is not the exact Go namespace")
+	}
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for _, name := range wasmIntegerCountGoNames(t) {
+		for bank := 0; bank < 16; bank++ {
+			function, reg := fmt.Sprintf("count%d", len(sigs)), fmt.Sprintf("R%d", bank)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%sReturn\n", function, wasmIntegerCountBody(name, reg))
+			sigs[function] = FuncSig{Name: function, Args: []LLVMType{I64}, ArgRegs: []Reg{Reg(reg)}, Ret: I64}
+		}
+	}
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, source.String(), goos)
+	}
+	file, err := Parse(ArchWASM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		sig, err := InferWASMAssemblyFuncSig(fn, fn.Sym)
+		if err != nil || sig.Ret != I64 || len(sig.Args) != 1 || sig.Args[0] != I64 {
+			t.Errorf("complete unary stack signature: %+v, %v", sig, err)
+		}
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(route, func(t *testing.T) {
+			ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIDirect), route)
+			if err != nil || ir == "" {
+				t.Fatal("Go unary integer-count family missing", err)
+			}
+			if strings.Contains(ir, "blockaddress") {
+				t.Fatal("Wasm scalar operations introduced blockaddress")
+			}
+			compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "counts.ll", "counts.o", ir)
+		})
+	}
+}
+
+func TestWASMIntegerCountTypedGoEntry(t *testing.T) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package integercount\n")
+	for index, name := range wasmIntegerCountGoNames(t) {
+		fmt.Fprintf(&declarations, "func operation%d()\n", index)
+		fmt.Fprintf(&source, "TEXT ·operation%d(SB),4,$0-0\n%sConst $0\n%s\nDrop\nRET\n", index, name[:3], name)
+	}
+	pkg := mustGoPackage(t, "integercount", declarations.String())
+	context := llvm.NewContext()
+	defer context.Dispose()
+	options := GoModuleOptions{GOOS: "js", GOARCH: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: testResolveSym("integercount")}
+	translated, err := translateGoModuleInContext(context, pkg, []byte(source.String()), options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := translated.Module.String()
+	translated.Module.Dispose()
+	compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "typed-count.ll", "typed-count.o", ir)
+	for _, name := range wasmIntegerCountGoNames(t) {
+		malformed := fmt.Sprintf("TEXT ·operation0(SB),4,$0-0\nRET\n%s $1\nRET\n", name)
+		translated, err := translateGoModuleInContext(context, pkg, []byte(malformed), options)
+		if translated != nil {
+			translated.Module.Dispose()
+		}
+		if err == nil || translated != nil {
+			t.Fatalf("typed Go accepted malformed dead %s: %v", name, err)
+		}
+	}
+}
+
+func TestWASMIntegerCountRequiresTypedStackAndCompleteFormat(t *testing.T) {
+	for _, name := range wasmIntegerCountGoNames(t) {
+		other, result := "I64Const $1\n", I32
+		if strings.HasPrefix(name, "I64") {
+			other, result = "I32Const $1\n", I64
+		}
+		bodies := []string{name, other + name, "Get F0\n" + name, "Get F16\n" + name}
+		for _, operand := range []string{" $0", " R0", " R0,R1", " 0(SP)", ".invalid"} {
+			bodies = append(bodies, name+operand, "RET\n"+name+operand)
+		}
+		for index, body := range bodies {
+			t.Run(fmt.Sprintf("%s/%d", name, index), func(t *testing.T) {
+				file, err := Parse(ArchWASM, "TEXT count(SB),4,$0-0\n"+body+"\nReturn\n")
+				if err != nil {
+					return // Original source syntax can reject before stack typing.
+				}
+				if sig, err := InferWASMAssemblyFuncSig(file.Funcs[0], "count"); err == nil {
+					t.Errorf("inference accepted invalid unary stack as %+v", sig)
+				}
+				for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"count": {Name: "count", Ret: result}}, WASMABIDirect), route)
+					if err == nil || ir != "" {
+						t.Errorf("%s accepted invalid unary stack/format: %s", route, body)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/wasm_ops.go b/wasm_ops.go
index 63fd666b2..4e8437dd7 100644
--- a/wasm_ops.go
+++ b/wasm_ops.go
@@ -1,5 +1,14 @@
 package plan9asm
 
+// Go's wasm MOVB/H/W/D names select unsigned memory widths. The operand
+// values themselves are 64-bit; no signed/U move variants exist in its table.
+var wasmMoveTypes = map[string]LLVMType{
+	"MOVB": I8,
+	"MOVH": I16,
+	"MOVW": I32,
+	"MOVD": I64,
+}
+
 type wasmIntegerOp struct {
 	typ LLVMType
 	op  string
@@ -15,6 +24,28 @@ type wasmMemoryStoreOp struct {
 	storeType LLVMType
 }
 
+type wasmFloatUnaryOp struct {
+	typ       LLVMType
+	intrinsic string
+}
+
+var wasmFloatUnaryOps = map[string]wasmFloatUnaryOp{
+	"F32ABS":     {LLVMType("float"), "fabs"},
+	"F32NEG":     {LLVMType("float"), ""},
+	"F32CEIL":    {LLVMType("float"), "ceil"},
+	"F32FLOOR":   {LLVMType("float"), "floor"},
+	"F32TRUNC":   {LLVMType("float"), "trunc"},
+	"F32NEAREST": {LLVMType("float"), "roundeven"},
+	"F32SQRT":    {LLVMType("float"), "sqrt"},
+	"F64ABS":     {LLVMType("double"), "fabs"},
+	"F64NEG":     {LLVMType("double"), ""},
+	"F64CEIL":    {LLVMType("double"), "ceil"},
+	"F64FLOOR":   {LLVMType("double"), "floor"},
+	"F64TRUNC":   {LLVMType("double"), "trunc"},
+	"F64NEAREST": {LLVMType("double"), "roundeven"},
+	"F64SQRT":    {LLVMType("double"), "sqrt"},
+}
+
 var wasmIntegerBinaryOps = map[string]wasmIntegerOp{
 	"I32ADD":  {I32, "add"},
 	"I32SUB":  {I32, "sub"},
diff --git a/wasm_packed_go120_test.go b/wasm_packed_go120_test.go
new file mode 100644
index 000000000..9197afffd
--- /dev/null
+++ b/wasm_packed_go120_test.go
@@ -0,0 +1,5 @@
+//go:build !go1.21
+
+package plan9asm
+
+var wasmPackedGoPlatforms = []string{"js"}
diff --git a/wasm_packed_go121_test.go b/wasm_packed_go121_test.go
new file mode 100644
index 000000000..651b5b7f1
--- /dev/null
+++ b/wasm_packed_go121_test.go
@@ -0,0 +1,7 @@
+//go:build go1.21
+
+package plan9asm
+
+// wasip1 was introduced in Go 1.21. LLVM objects still cover both wasm
+// targets regardless of which Go toolchain supplies the source oracle.
+var wasmPackedGoPlatforms = []string{"js", "wasip1"}
diff --git a/wasm_packed_go_runtime_helper_test.go b/wasm_packed_go_runtime_helper_test.go
new file mode 100644
index 000000000..e2c78c67c
--- /dev/null
+++ b/wasm_packed_go_runtime_helper_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestWASMPackedGoRuntimeHelperUsesPortableNodeCommand(t *testing.T) {
+	t.Setenv("PLAN9ASM_UNRELATED_HOST_CONTEXT", strings.Repeat("x", 16384))
+	for _, directory := range []string{"lib", "misc"} {
+		t.Run(directory, func(t *testing.T) {
+			root := t.TempDir()
+			dir := filepath.Join(root, directory, "wasm")
+			if err := os.MkdirAll(dir, 0700); err != nil {
+				t.Fatal(err)
+			}
+			for _, name := range []string{"wasm_exec_node.js", "wasm_exec.js"} {
+				// JavaScript files do not require POSIX execute permission,
+				// including in a Windows GOROOT using node.exe.
+				if err := os.WriteFile(filepath.Join(dir, name), []byte("// helper fixture\n"), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			node := filepath.Join(root, "Node Program Files", "node.exe")
+			wasm := filepath.Join(root, "Go Program Files", "oracle.wasm")
+			cmd, err := wasmPackedGoRuntimeCommand(context.Background(), root, node, wasm)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := []string{node, "--stack-size=8192", "-e", wasmPackedNodeBootstrap, filepath.Join(dir, "wasm_exec_node.js"), wasm}
+			if cmd.Path != node || !reflect.DeepEqual(cmd.Args, want) {
+				t.Fatalf("must invoke Node directly with separate arguments, got path=%q args=%q", cmd.Path, cmd.Args)
+			}
+			if cmd.Env == nil || !strings.Contains(strings.Join(cmd.Env, "\n"), "GOMAXPROCS=1") {
+				t.Fatal("Go wasm must explicitly retain its single-P environment")
+			}
+			for _, pair := range cmd.Env {
+				key, _, _ := strings.Cut(pair, "=")
+				switch key {
+				case "GOMAXPROCS", "SYSTEMROOT", "WINDIR", "TMP", "TEMP", "TMPDIR":
+				default:
+					t.Fatalf("unrelated host context leaked into Go wasm: %s", key)
+				}
+			}
+		})
+	}
+}
+
+func TestWASMPackedGoRuntimeHelperRequiresCompleteRegularFiles(t *testing.T) {
+	for _, invalid := range []string{"missing", "node_directory", "missing_companion", "companion_directory"} {
+		t.Run(invalid, func(t *testing.T) {
+			root := t.TempDir()
+			dir := filepath.Join(root, "lib", "wasm")
+			if err := os.MkdirAll(dir, 0700); err != nil {
+				t.Fatal(err)
+			}
+			if invalid == "node_directory" {
+				if err := os.Mkdir(filepath.Join(dir, "wasm_exec_node.js"), 0700); err != nil {
+					t.Fatal(err)
+				}
+			} else if invalid != "missing" {
+				if err := os.WriteFile(filepath.Join(dir, "wasm_exec_node.js"), nil, 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if invalid == "companion_directory" {
+				if err := os.Mkdir(filepath.Join(dir, "wasm_exec.js"), 0700); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if cmd, err := wasmPackedGoRuntimeCommand(context.Background(), root, "node.exe", "oracle.wasm"); err == nil || cmd != nil {
+				t.Fatalf("incomplete runtime must fail without a fake command: cmd=%v err=%v", cmd, err)
+			}
+		})
+	}
+}
+
+func TestWASMPackedGoRuntimeHelperRequiresCommandContext(t *testing.T) {
+	if command, err := wasmPackedGoRuntimeCommand(nil, t.TempDir(), "node", "oracle.wasm"); err == nil || command != nil {
+		t.Fatalf("unbounded runtime command accepted: %v / %v", command, err)
+	}
+}
diff --git a/wasm_packed_go_runtime_test.go b/wasm_packed_go_runtime_test.go
new file mode 100644
index 000000000..8255758f1
--- /dev/null
+++ b/wasm_packed_go_runtime_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This oracle uses the selected Go compiler and that same toolchain's runtime
+// helper. Missing helper files are hard failures, not version-based skips.
+func TestWASMPackedFunctionAddressActualGoRuntime(t *testing.T) {
+	// Hosted runners carry large unrelated environments. The actual Go wasm
+	// runtime has a bounded argv/environment area, unlike the native host.
+	t.Setenv("PLAN9ASM_UNRELATED_HOST_CONTEXT", strings.Repeat("x", 16384))
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	source, _, goSource := wasmPackedRuntimeFixture(t)
+	dir := t.TempDir()
+	for name, data := range map[string]string{"go.mod": "module packed_pc_oracle\ngo 1.20\n", "main.go": goSource, "oracle_wasm.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cmd := exec.CommandContext(ctx, "go", "build", "-o", "oracle.wasm", ".")
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(), "GOWORK=off", "GOOS=js", "GOARCH=wasm", "GOTOOLCHAIN=local")
+	if out, err := runtimeOracleCombinedOutput(ctx, cmd); err != nil {
+		t.Fatalf("actual Go wasm oracle build: %v\n%s", err, out)
+	}
+	cmd, err := wasmPackedGoRuntimeCommand(ctx, runtime.GOROOT(), wasmPackedNode(t), filepath.Join(dir, "oracle.wasm"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	result, err := runtimeOracleCombinedOutput(ctx, cmd)
+	if err != nil {
+		t.Fatalf("actual Go wasm runtime: %v\n%s", err, result)
+	}
+	if strings.TrimSpace(string(result)) != "actual Go packed address + complete MOV widths + dynamic calls + native division PASS" {
+		t.Fatalf("runtime helper exited without executing the complete Go oracle:\n%s", result)
+	}
+	t.Log(strings.TrimSpace(string(result)))
+}
+
+// Old Go's unmodified Node helper assigns its own crypto provider. Current
+// Node exposes that global through a configurable getter without a setter.
+// Preserve the actual provider and property visibility, making only that
+// configurable binding writable before loading the selected SDK's helper.
+// Node -e keeps argv[1] as the helper and argv[2] as the wasm program, exactly
+// as the original wrapper expects. Paths remain separate arguments.
+const wasmPackedNodeBootstrap = `"use strict";
+const descriptor = Object.getOwnPropertyDescriptor(globalThis, "crypto");
+if (descriptor && descriptor.set === undefined &&
+    (typeof descriptor.get === "function" || descriptor.writable === false)) {
+  if (!descriptor.configurable) {
+    throw new Error("Go wasm helper cannot initialize a nonconfigurable read-only crypto binding");
+  }
+  const provider = globalThis.crypto;
+  Object.defineProperty(globalThis, "crypto", {
+    value: provider, writable: true, enumerable: descriptor.enumerable,
+    configurable: descriptor.configurable
+  });
+}
+require(process.argv[1]);
+`
+
+func wasmPackedGoRuntimeCommand(ctx context.Context, root, node, wasm string) (*exec.Cmd, error) {
+	if ctx == nil {
+		return nil, fmt.Errorf("Go wasm runtime requires its bounded command context")
+	}
+	for _, directory := range []string{"lib", "misc"} {
+		dir := filepath.Join(root, directory, "wasm")
+		complete := true
+		for _, name := range []string{"wasm_exec_node.js", "wasm_exec.js"} {
+			info, err := os.Stat(filepath.Join(dir, name))
+			if err != nil || !info.Mode().IsRegular() {
+				complete = false
+				break
+			}
+		}
+		if complete {
+			// These are the arguments of Go's go_js_wasm_exec wrapper,
+			// without invoking its POSIX shell or requiring execute bits.
+			command := exec.CommandContext(ctx, node, "--stack-size=8192", "-e", wasmPackedNodeBootstrap, filepath.Join(dir, "wasm_exec_node.js"), wasm)
+			// These self-contained Go oracles need only a single runtime P
+			// and the host's temporary/system directories. Forwarding CI's
+			// build flags, PATH and unrelated variables overflows Go wasm's
+			// small startup environment area; none are program inputs here.
+			command.Env = []string{"GOMAXPROCS=1"}
+			for _, key := range []string{"SYSTEMROOT", "WINDIR", "TMP", "TEMP", "TMPDIR"} {
+				if value, ok := os.LookupEnv(key); ok {
+					command.Env = append(command.Env, key+"="+value)
+				}
+			}
+			return command, nil
+		}
+	}
+	return nil, fmt.Errorf("selected Go toolchain lacks its required lib/misc wasm runtime JavaScript files")
+}
diff --git a/wasm_packed_node_compat_test.go b/wasm_packed_node_compat_test.go
new file mode 100644
index 000000000..da92d3c1c
--- /dev/null
+++ b/wasm_packed_node_compat_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestWASMPackedGoRuntimeHelperPreservesNodeGlobalCompatibility(t *testing.T) {
+	node := wasmPackedNode(t)
+	for _, tc := range []struct {
+		name, setup, initial, beforeBootstrap string
+		refused                               bool
+	}{
+		{
+			name: "configurable_getter", initial: "original",
+			setup: `Object.defineProperty(globalThis, "crypto", {
+  get() { return source; }, enumerable: true, configurable: true
+});`,
+		},
+		{
+			name: "configurable_readonly_data", initial: "original",
+			setup: `Object.defineProperty(globalThis, "crypto", {
+  value: source, writable: false, enumerable: true, configurable: true
+});`,
+		},
+		{
+			name: "writable_provider", initial: "original",
+			setup: `Object.defineProperty(globalThis, "crypto", {
+  value: source, writable: true, enumerable: true, configurable: true
+});`,
+		},
+		{
+			name: "absent_provider",
+			setup: `delete globalThis.crypto;
+globalThis.__plan9asmOriginalCrypto = undefined;`,
+			// Node installs eval-context builtin getters after --require runs.
+			// Establish this fixture's genuinely absent binding immediately
+			// before the unchanged bootstrap, not merely before eval startup.
+			beforeBootstrap: "delete globalThis.crypto;\n",
+		},
+		{
+			name: "nonconfigurable_getter", refused: true,
+			setup: `Object.defineProperty(globalThis, "crypto", {
+  get() { return source; }, enumerable: true, configurable: false
+});`,
+		},
+		{
+			name: "nonconfigurable_readonly_data", refused: true,
+			setup: `Object.defineProperty(globalThis, "crypto", {
+  value: source, writable: false, enumerable: true, configurable: false
+});`,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			root := t.TempDir()
+			dir := filepath.Join(root, "misc", "wasm")
+			if err := os.MkdirAll(dir, 0700); err != nil {
+				t.Fatal(err)
+			}
+			setup := filepath.Join(root, "node setup.cjs")
+			files := map[string]string{
+				setup: `const source = { provider: "original" };
+globalThis.__plan9asmOriginalCrypto = source;
+` + tc.setup,
+				filepath.Join(dir, "wasm_exec.js"): `module.exports = { fixture: "same-sdk" };`,
+				filepath.Join(dir, "wasm_exec_node.js"): `"use strict";
+const original = globalThis.crypto;
+globalThis.crypto = { provider: "go-runtime" };
+console.log(JSON.stringify({
+  args: process.argv.slice(2), initial: original ? original.provider : "",
+  preserved: original === globalThis.__plan9asmOriginalCrypto,
+  provider: globalThis.crypto.provider,
+  companion: require("./wasm_exec").fixture
+}));`,
+			}
+			for name, data := range files {
+				if err := os.WriteFile(name, []byte(data), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			wasm := filepath.Join(root, "Go Program Files", "oracle.wasm")
+			ctx, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command, err := wasmPackedGoRuntimeCommand(ctx, root, node, wasm)
+			if err != nil {
+				t.Fatal(err)
+			}
+			args := append([]string{"--require", setup}, command.Args[1:]...)
+			if tc.beforeBootstrap != "" {
+				found := false
+				for i := 0; i+1 < len(args); i++ {
+					if args[i] == "-e" && args[i+1] == wasmPackedNodeBootstrap {
+						args[i+1] = tc.beforeBootstrap + args[i+1]
+						found = true
+						break
+					}
+				}
+				if !found {
+					t.Fatal("fixture cannot bind the actual bootstrap environment")
+				}
+			}
+			output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, node, args...))
+			if tc.refused {
+				if !wasmPackedNodeBindingRefused(ctx, output, err) {
+					t.Fatalf("immutable binding must fail before a fake runtime pass: %v\n%s", err, output)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("actual Node cannot load its selected Go runtime helper: %v\n%s", err, output)
+			}
+			var result struct {
+				Args                         []string
+				Initial, Provider, Companion string
+				Preserved                    bool
+			}
+			if err := json.Unmarshal(output, &result); err != nil {
+				t.Fatalf("runtime fixture did not execute: %v\n%s", err, output)
+			}
+			if !reflect.DeepEqual(result.Args, []string{wasm}) || result.Initial != tc.initial ||
+				!result.Preserved || result.Provider != "go-runtime" || result.Companion != "same-sdk" {
+				t.Fatalf("original provider, Go argv or same-SDK module resolution changed: %+v", result)
+			}
+		})
+	}
+}
+
+const wasmPackedImmutableBindingDiagnostic = "Error: Go wasm helper cannot initialize a nonconfigurable read-only crypto binding"
+
+func wasmPackedNodeBindingRefused(ctx context.Context, output []byte, err error) bool {
+	// A wrapped/joined exit may contain cancellation or owned cleanup errors.
+	// Only the actual plain Node exit and its exact bootstrap error line can
+	// establish this refusal, before the selected helper starts executing.
+	exit, ok := err.(*exec.ExitError)
+	text := strings.ReplaceAll(string(output), "\r\n", "\n")
+	return ctx != nil && ctx.Err() == nil && ok && exit.ExitCode() == 1 &&
+		!strings.Contains(text, "\r") &&
+		strings.Count(text, "\n"+wasmPackedImmutableBindingDiagnostic+"\n") == 1 &&
+		!strings.Contains(text, `"companion":"same-sdk"`)
+}
+
+func TestWASMPackedGoRuntimeHelperRejectsUnknownNodeFailures(t *testing.T) {
+	node := wasmPackedNode(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	_, exitOne := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, node, "-e", "process.exit(1)"))
+	_, exitTwo := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, node, "-e", "process.exit(2)"))
+	for code, observed := range map[int]error{1: exitOne, 2: exitTwo} {
+		exit, ok := observed.(*exec.ExitError)
+		if !ok || exit.ExitCode() != code {
+			t.Fatalf("Node fixture did not provide its actual plain exit %d: %v", code, observed)
+		}
+	}
+
+	expired, expire := context.WithCancel(context.Background())
+	expire()
+	diagnostic := []byte("\n" + wasmPackedImmutableBindingDiagnostic + "\n")
+	for _, tc := range []struct {
+		name     string
+		ctx      context.Context
+		output   []byte
+		err      error
+		accepted bool
+	}{
+		{"known_plain_exit", ctx, diagnostic, exitOne, true},
+		{"native_CRLF", ctx, []byte("\r\n" + wasmPackedImmutableBindingDiagnostic + "\r\n"), exitOne, true},
+		{"bare_CR", ctx, []byte("\r" + wasmPackedImmutableBindingDiagnostic + "\r"), exitOne, false},
+		{"embedded_CR", ctx, []byte("\n" + wasmPackedImmutableBindingDiagnostic + "\rforeign\n"), exitOne, false},
+		{"no_context", nil, diagnostic, exitOne, false},
+		{"canceled_context", expired, diagnostic, exitOne, false},
+		{"joined_cleanup", ctx, diagnostic, errors.Join(exitOne, errors.New("owned cleanup failure")), false},
+		{"wrapped_exit", ctx, diagnostic, &os.PathError{Op: "start", Path: "node", Err: exitOne}, false},
+		{"deadline", ctx, diagnostic, context.DeadlineExceeded, false},
+		{"missing_program", ctx, diagnostic, exec.ErrNotFound, false},
+		{"wrong_status", ctx, diagnostic, exitTwo, false},
+		{"successful_status", ctx, diagnostic, nil, false},
+		{"missing_diagnostic", ctx, nil, exitOne, false},
+		{"unrelated_diagnostic", ctx, []byte("Error: Cannot find module\n"), exitOne, false},
+		{"quoted_diagnostic", ctx, []byte("throw new Error(\"" + wasmPackedImmutableBindingDiagnostic + "\");\n"), exitOne, false},
+		{"duplicate_diagnostic", ctx, append(append([]byte{}, diagnostic...), diagnostic...), exitOne, false},
+		{"runtime_already_executed", ctx, append(append([]byte{}, diagnostic...), []byte(`{"companion":"same-sdk"}`)...), exitOne, false},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := wasmPackedNodeBindingRefused(tc.ctx, tc.output, tc.err); got != tc.accepted {
+				t.Fatalf("Node binding refusal=%v, want=%v: %v\n%s", got, tc.accepted, tc.err, tc.output)
+			}
+		})
+	}
+}
diff --git a/wasm_packed_pc_runtime_test.go b/wasm_packed_pc_runtime_test.go
new file mode 100644
index 000000000..0bcb68978
--- /dev/null
+++ b/wasm_packed_pc_runtime_test.go
@@ -0,0 +1,284 @@
+package plan9asm
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func wasmPackedRuntimeFixture(t *testing.T) (string, map[string]FuncSig, string) {
+	t.Helper()
+	var source, goSource strings.Builder
+	source.WriteString(`TEXT ·target(SB),4,$0-0
+MOVD $·calls(SB), R1
+MOVD 0(R1), R0
+Get R0
+I64Const $1
+I64Add
+Set R0
+MOVD R0, 0(R1)
+RET
+GLOBL ·calls(SB),16,$8
+TEXT ·dynamicCall(SB),4,$0-0
+I64Const $·target(SB)
+CALL
+RET
+TEXT ·dynamicJump(SB),4,$0-0
+I64Const $·target(SB)
+JMP
+TEXT ·readCalls(SB),4,$0-8
+MOVD $·calls(SB), R1
+MOVD 0(R1), R0
+MOVD R0, ret+0(FP)
+RET
+`)
+	sigs := map[string]FuncSig{
+		"target": {Name: "target", Ret: Void}, "dynamicCall": {Name: "dynamicCall", Ret: Void}, "dynamicJump": {Name: "dynamicJump", Ret: Void},
+		"readCalls": {Name: "readCalls", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Index: 0, Type: I64}}}},
+	}
+	native, ok := LookupGoWASMNativeFuncSig("runtime.wasmDiv")
+	if !ok {
+		t.Fatal("actual Go native contract absent")
+	}
+	sigs["runtime.wasmDiv"] = native
+	goSource.WriteString("package main\nimport \"fmt\"\nfunc target()\nfunc dynamicCall()\nfunc dynamicJump()\nfunc readCalls() uint64\n")
+	goSource.WriteString("//go:noinline\nfunc nativeDivision(a,b int64)int64{return a/b}\n")
+	var addresses []string
+	for _, target := range []string{"·target", "runtime·wasmDiv"} {
+		for _, addend := range []int64{0, 1, 65535} {
+			for _, opcode := range []string{"I64Const", "I32Const", "MOVB", "MOVH", "MOVW", "MOVD"} {
+				name := fmt.Sprintf("address%d", len(addresses))
+				operand := fmt.Sprintf("$%s%+d(SB)", target, addend)
+				body := opcode + " " + operand + "\n"
+				if strings.HasPrefix(opcode, "MOV") {
+					body = opcode + " " + operand + ", R0\nGet R0\n"
+				} else if opcode == "I32Const" {
+					body += "I64ExtendI32U\n"
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nGet SP\n%sI64Store ret+0(FP)\nRET\n", name, body)
+				fmt.Fprintf(&source, "DATA ·holder%d(SB)/1,$0xa5\nDATA ·holder%d+1(SB)/8,%s\nDATA ·holder%d+9(SB)/1,$0x5a\nGLOBL ·holder%d(SB),24,$16\n", len(addresses), len(addresses), operand, len(addresses), len(addresses))
+				sigs[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Index: 0, Type: I64}}}}
+				fmt.Fprintf(&goSource, "func %s() uint64\n", name)
+				addresses = append(addresses, name)
+			}
+		}
+	}
+	var numeric []string
+	var expected []uint64
+	for _, op := range []string{"MOVB", "MOVH", "MOVW", "MOVD"} {
+		bits := map[string]uint{"MOVB": 8, "MOVH": 16, "MOVW": 32, "MOVD": 64}[op]
+		mask := ^uint64(0)
+		if bits < 64 {
+			mask = (1 << bits) - 1
+		}
+		for _, form := range []string{"constant", "register", "load", "store_low", "store_high", "memory_copy", "constant_store", "address_store"} {
+			name := fmt.Sprintf("numeric%d", len(numeric))
+			body := "MOVD $0x88776655fedcba98, 0(SP)\nMOVD $0x1020304050607080, 8(SP)\n"
+			want := uint64(0x88776655fedcba98)
+			switch form {
+			case "constant":
+				body += op + " $0x88776655fedcba98, R0\n"
+			case "register":
+				body += "MOVD $0x88776655fedcba98, R1\n" + op + " R1, R0\n"
+			case "load":
+				body += op + " 0(SP), R0\n"
+				want &= mask
+			case "store_low", "store_high":
+				body += "MOVD $0xa1b2c3d4e5f60718, R1\n" + op + " R1, 1(SP)\n"
+				if form == "store_low" {
+					body += "MOVD 0(SP), R0\n"
+					want = (want & ^(mask << 8)) | ((uint64(0xa1b2c3d4e5f60718) & mask) << 8)
+				} else {
+					body += "MOVD 8(SP), R0\n"
+					want = 0x1020304050607080
+					if bits == 64 {
+						want = (want & ^uint64(255)) | 0xa1
+					}
+				}
+			case "memory_copy":
+				body += op + " 0(SP), 8(SP)\nMOVD 8(SP), R0\n"
+				want = (uint64(0x1020304050607080) & ^mask) | (want & mask)
+			case "constant_store":
+				body += op + " $0xa1b2c3d4e5f60718, 0(SP)\nMOVD 0(SP), R0\n"
+				want = (want & ^mask) | (uint64(0xa1b2c3d4e5f60718) & mask)
+			case "address_store":
+				body += op + " $·target+65535(SB), 0(SP)\nMOVD 0(SP), R0\n"
+				// The actual function index is assigned by each linker; only the
+				// non-address bytes are fixed in the independent expected value.
+				want &= ^mask
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$16-8\n%sMOVD R0, ret+0(FP)\nRET\n", name, body)
+			sigs[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Index: 0, Type: I64}}}}
+			fmt.Fprintf(&goSource, "func %s() uint64\n", name)
+			numeric, expected = append(numeric, name), append(expected, want)
+		}
+	}
+	goSource.WriteString("func main(){\na:=[]func()uint64{" + strings.Join(addresses, ",") + "}\n")
+	goSource.WriteString("for i,f:=range a {b:=a[(i/18)*18]();v:=f();want:=b+[]uint64{0,1,65535}[(i%18)/6];if i%6==1{want=uint64(uint32(want))};if b<0x10000000||b&65535!=0||v!=want{panic(fmt.Sprintf(\"Go address %d: %x != %x\",i,v,want))}}\n")
+	goSource.WriteString("n:=[]func()uint64{" + strings.Join(numeric, ",") + "}\nw:=[]uint64{")
+	for _, value := range expected {
+		fmt.Fprintf(&goSource, "%d,", value)
+	}
+	goSource.WriteString("}\nfor i,f:=range n{want:=w[i];if i%8==7{bits:=[]uint{8,16,32,64}[i/8];mask:=^uint64(0);if bits<64{mask=(1<<bits)-1};want|=(a[0]()+65535)&mask};if v:=f();v!=want{panic(fmt.Sprintf(\"Go MOV %d: %x != %x\",i,v,want))}}\ndynamicCall();dynamicJump();if readCalls()!=2{panic(\"Go dynamic CALL/JMP count\")};d:=[][2]int64{{81,9},{-81,9},{0,5},{-9223372036854775808,-1}};r:=[]int64{9,-9,0,-9223372036854775808};for i,p:=range d{if nativeDivision(p[0],p[1])!=r[i]{panic(\"actual Go native division\")}};fmt.Println(\"actual Go packed address + complete MOV widths + dynamic calls + native division PASS\")}\n")
+	return source.String(), sigs, goSource.String()
+}
+
+func TestWASMPackedFunctionAddressFirstLoadAndControlRuntime(t *testing.T) {
+	source, sigs, _ := wasmPackedRuntimeFixture(t)
+	source += wasmPackedNativeSource(t)
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, strings.ReplaceAll(source, "NOSPLIT", "4"), goos)
+	}
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(route, func(t *testing.T) {
+			ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIGo), route)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "llvm.global_ctors") || strings.Contains(ir, "blockaddress") {
+				t.Fatal("packed PC translation needs neither constructors nor blockaddress")
+			}
+			ir = strings.Replace(ir, "@SP = external addrspace(1) global i32", "@SP = addrspace(1) global i32 4096", 1)
+			ir += "@target_index = constant i32 ptrtoint (ptr @target to i32)\n@native_index = constant i32 ptrtoint (ptr @\"runtime.wasmDiv\" to i32)\n"
+			for name, sig := range sigs {
+				if sig.WASMNative || name == "target" {
+					continue
+				}
+				ir += fmt.Sprintf("define i64 @probe_%s(){ store i32 4096, ptr addrspace(1) @SP\n %%u=call i32 @%s(i32 0)\n %%v=load i64, ptr inttoptr(i32 4104 to ptr),align 1\n ret i64 %%v }\n", name, name)
+			}
+			for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-wasi"} {
+				input := strings.Replace(ir, "wasm32-unknown-unknown", triple, 1)
+				partial, dir := wasmPackedObject(t, input)
+				for _, tableBase := range []int{1, 65536} {
+					final := filepath.Join(dir, fmt.Sprintf("final-%d.wasm", tableBase))
+					wasmDataCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", "--export-memory", "--export-table", fmt.Sprintf("--table-base=%d", tableBase), partial, "-o", final)
+					out := wasmDataCommand(t, wasmPackedNode(t), "-e", wasmPackedRuntimeNode, final)
+					t.Logf("%s table-base=%d: %s", triple, tableBase, strings.TrimSpace(out))
+				}
+			}
+		})
+	}
+}
+
+func TestWASMPackedFunctionAddressDirectModelRuntime(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("TEXT ·target(SB),4,$0-0\nRET\n")
+	source.WriteString(wasmPackedNativeSource(t))
+	native, ok := LookupGoWASMNativeFuncSig("runtime.wasmDiv")
+	if !ok {
+		t.Fatal("actual Go native contract absent")
+	}
+	sigs := map[string]FuncSig{
+		"target": {Name: "target", Ret: Void}, "runtime.wasmDiv": native,
+	}
+	index := 0
+	for _, target := range []string{"·target", "runtime·wasmDiv"} {
+		fmt.Fprintf(&source, "DATA ·direct%d(SB)/8,$%s(SB)\nGLOBL ·direct%d(SB),24,$8\n", index/18, target, index/18)
+		for _, addend := range []int64{-1, 0, 65535} {
+			for _, opcode := range []string{"I64Const", "I32Const", "MOVB", "MOVH", "MOVW", "MOVD"} {
+				name := fmt.Sprintf("directAddress%d", index)
+				operand := fmt.Sprintf("$%s%+d(SB)", target, addend)
+				body := opcode + " " + operand + "\n"
+				if strings.HasPrefix(opcode, "MOV") {
+					body = opcode + " " + operand + ", R0\n"
+				} else {
+					if opcode == "I32Const" {
+						body += "I64ExtendI32U\n"
+					}
+					body += "Set R0\n"
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\n%sMOVD R0, ret+0(FP)\nRET\n", name, body)
+				sigs[name] = FuncSig{Name: name, Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Index: 0, Type: I64}}}}
+				index++
+			}
+		}
+	}
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, strings.ReplaceAll(source.String(), "NOSPLIT", "4"), goos)
+	}
+	file, err := Parse(ArchWASM, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(route, func(t *testing.T) {
+			ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIDirect), route)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "shl i64") || strings.Contains(ir, "llvm.global_ctors") {
+				t.Fatal("Direct-model function address must remain an unshifted table index")
+			}
+			ir += "@target_index = constant i32 ptrtoint (ptr @target to i32)\n@native_index = constant i32 ptrtoint (ptr @\"runtime.wasmDiv\" to i32)\n"
+			for _, triple := range []string{"wasm32-unknown-unknown", "wasm32-wasi"} {
+				partial, dir := wasmPackedObject(t, strings.Replace(ir, "wasm32-unknown-unknown", triple, 1))
+				relocs := wasmDataCommand(t, wasmDataTool(t, "llvm-readobj"), "--relocations", partial)
+				if !strings.Contains(relocs, "R_WASM_TABLE_INDEX_I64") {
+					t.Fatal("Direct DATA lost its original table-index-I64 relocation")
+				}
+				final := filepath.Join(dir, "direct.wasm")
+				wasmDataCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", "--export-memory", "--export-table", "--table-base=65536", partial, "-o", final)
+				out := wasmDataCommand(t, wasmPackedNode(t), "-e", wasmDirectAddressNode, final)
+				t.Logf("%s: %s", triple, strings.TrimSpace(out))
+			}
+		})
+	}
+}
+
+const wasmDirectAddressNode = `
+const fs=require('fs');
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]),{}).then(({instance:{exports:e}})=>{
+  const v=new DataView(e.memory.buffer);
+  const bases=[BigInt(v.getUint32(e.target_index.value,true)),BigInt(v.getUint32(e.native_index.value,true))];
+  for(let i=0;i<2;i++)if(v.getBigUint64(e['direct'+i].value,true)!==bases[i])throw Error('first host Direct DATA index');
+  for(let i=0;i<36;i++){
+    let want=bases[Math.floor(i/18)]+[-1n,0n,65535n][Math.floor((i%18)/6)];
+    if(i%6===1)want=BigInt.asUintN(32,want);
+    if(BigInt.asUintN(64,e['directAddress'+i]())!==want)throw Error('unshifted Direct address '+i);
+  }
+  if(e['runtime.wasmDiv'](81n,9n)!==9n)throw Error('Direct native primitive');
+  console.log('first Direct DATA + complete address family + native primitive PASS');
+}).catch(e=>{console.error(e);process.exit(1)});
+`
+
+const wasmPackedRuntimeNode = `
+const fs=require('fs');
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]),{}).then(({instance:{exports:e}})=>{
+  const v=new DataView(e.memory.buffer);
+  const bases=[BigInt(v.getUint32(e.target_index.value,true))<<16n,BigInt(v.getUint32(e.native_index.value,true))<<16n];
+  for(let i=0;i<36;i++){
+    const a=e['holder'+i].value,want=bases[Math.floor(i/18)]+[0n,1n,65535n][Math.floor((i%18)/6)];
+    if(v.getUint8(a)!==165||v.getUint8(a+9)!==90||v.getBigUint64(a+1,true)!==want) throw Error('first host-memory packed DATA '+i);
+  }
+  for(let i=0;i<36;i++){
+    let want=bases[Math.floor(i/18)]+[0n,1n,65535n][Math.floor((i%18)/6)];
+    if(i%6===1)want=BigInt.asUintN(32,want);
+    if(BigInt.asUintN(64,e['probe_address'+i]())!==want) throw Error('immediate PC '+i);
+  }
+  const init=0x88776655fedcba98n,high=0x1020304050607080n,value=0xa1b2c3d4e5f60718n;
+  for(let i=0;i<32;i++){
+    const bits=[8n,16n,32n,64n][Math.floor(i/8)],mask=(1n<<bits)-1n,f=i%8;
+    let want=init;
+    if(f===2)want=init&mask;
+    if(f===3)want=BigInt.asUintN(64,(init&~(mask<<8n))|((value&mask)<<8n));
+    if(f===4)want=bits===64n?(high&~255n)|0xa1n:high;
+    if(f===5)want=(high&~mask)|(init&mask);
+    if(f===6)want=(init&~mask)|(value&mask);
+    if(f===7)want=(init&~mask)|((bases[0]+65535n)&mask);
+    if(BigInt.asUintN(64,e['probe_numeric'+i]())!==want)throw Error('MOV width/value '+i);
+  }
+  if(v.getBigUint64(e.calls.value,true)!==0n)throw Error('premature target execution');
+  e.probe_dynamicCall();e.probe_dynamicJump();
+  if(v.getBigUint64(e.calls.value,true)!==2n)throw Error('Go dynamic CALL/JMP target count');
+  for(const [a,b] of [[81n,9n],[-81n,9n],[0n,5n],[-9223372036854775808n,-1n]]){
+    const want=BigInt.asIntN(64,a/b);
+    if(e['runtime.wasmDiv'](a,b)!==want)throw Error('actual source WASMNative primitive');
+  }
+  console.log('first host packed DATA + LLVM MOV numeric + CALL/JMP count + native primitive PASS');
+}).catch(e=>{console.error(e);process.exit(1)});
+`
diff --git a/wasm_packed_pc_test.go b/wasm_packed_pc_test.go
new file mode 100644
index 000000000..998fb19ca
--- /dev/null
+++ b/wasm_packed_pc_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func wasmPackedResolve(symbol string) string {
+	return strings.ReplaceAll(strings.TrimSuffix(strings.TrimPrefix(symbol, "·"), "<>"), "·", ".")
+}
+
+func wasmPackedTranslate(t *testing.T, file *File, options Options, route string) (string, error) {
+	t.Helper()
+	if route == "Translate" {
+		return Translate(file, options)
+	}
+	if route == "TranslateModule" {
+		mod, err := TranslateModule(file, options)
+		if err != nil {
+			return "", err
+		}
+		defer mod.Dispose()
+		return mod.String(), nil
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	mod, err := TranslateModuleInContext(ctx, file, options)
+	if err != nil {
+		return "", err
+	}
+	defer mod.Dispose()
+	return mod.String(), nil
+}
+
+func wasmPackedNativeSource(t *testing.T) string {
+	t.Helper()
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "runtime", "sys_wasm.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := string(data)
+	start := strings.Index(source, "TEXT runtime·wasmDiv(SB)")
+	if start < 0 {
+		t.Fatal("actual Go wasmDiv source absent")
+	}
+	end := strings.Index(source[start+1:], "\nTEXT ")
+	if end < 0 {
+		t.Fatal("actual Go wasmDiv source boundary absent")
+	}
+	return source[start:start+1+end] + "\n"
+}
+
+func wasmPackedOptions(sigs map[string]FuncSig, abi WASMABI) Options {
+	return Options{Goarch: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: wasmPackedResolve, Sigs: sigs, WASMABI: abi}
+}
+
+func TestWASMMoveFamilyMatchesActualGoTable(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "wasm", "anames.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := make(map[string]bool)
+	for _, match := range regexp.MustCompile(`(?m)^\s*"(MOV[A-Z]+)",`).FindAllSubmatch(data, -1) {
+		actual[string(match[1])] = true
+	}
+	if len(actual) != len(wasmMoveTypes) {
+		t.Fatalf("Go MOV family %v differs from typed memory widths %v", actual, wasmMoveTypes)
+	}
+	for opcode := range actual {
+		if _, ok := wasmMoveTypes[opcode]; !ok {
+			t.Errorf("Go MOV format missing: %s", opcode)
+		}
+	}
+}
+
+func TestWASMPackedFunctionAddressFamily(t *testing.T) {
+	for _, native := range []bool{false, true} {
+		for _, addend := range []int64{0, 1, 65535} {
+			for _, opcode := range []string{"I64Const", "I32Const", "MOVD", "MOVW", "MOVH", "MOVB"} {
+				label := fmt.Sprintf("native=%v/%s/addend=%d", native, opcode, addend)
+				t.Run(label, func(t *testing.T) {
+					target := "·target"
+					prefix := "TEXT ·target(SB),4,$0-0\nRET\n"
+					callee := FuncSig{Name: "target", Ret: Void}
+					if native {
+						target, prefix = "runtime·wasmDiv", wasmPackedNativeSource(t)
+						var ok bool
+						callee, ok = LookupGoWASMNativeFuncSig("runtime.wasmDiv")
+						if !ok {
+							t.Fatal("actual native contract absent")
+						}
+					}
+					operand := fmt.Sprintf("$%s%+d(SB)", target, addend)
+					body := opcode + " " + operand + "\n"
+					if strings.HasPrefix(opcode, "MOV") {
+						body = opcode + " " + operand + ", R0\nGet R0\n"
+					} else if opcode == "I32Const" {
+						body += "I64ExtendI32U\n"
+					}
+					source := prefix + "TEXT ·address(SB),4,$0-8\nGet SP\n" + body + "I64Store ret+0(FP)\nRET\n" +
+						fmt.Sprintf("DATA holder<>(SB)/8,%s\nGLOBL holder<>(SB),24,$8\n", operand)
+					for _, goos := range wasmPackedGoPlatforms {
+						wasmDataGoObject(t, strings.ReplaceAll(source, "NOSPLIT", "4"), goos)
+					}
+					file, err := Parse(ArchWASM, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					sigs := map[string]FuncSig{wasmPackedResolve(target): callee, "address": {
+						Name: "address", Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Index: 0, Type: I64}}},
+					}}
+					for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+						ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIGo), route)
+						if err != nil {
+							t.Fatalf("%s actual Go address: %v", route, err)
+						}
+						if strings.Contains(ir, "blockaddress") || strings.Contains(ir, "llvm.global_ctors") || !strings.Contains(ir, "shl i64") {
+							t.Fatalf("%s address is not a statically initialized Go packed PC:\n%s", route, ir)
+						}
+						if strings.Contains(ir, "i32 65536") || strings.Contains(ir, "i64 65536") {
+							t.Fatal("a table index was guessed")
+						}
+						wasmPackedObject(t, ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func wasmPackedObject(t *testing.T, ir string) (string, string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, optimized := filepath.Join(dir, "source.ll"), filepath.Join(dir, "optimized.ll")
+	object, partial := filepath.Join(dir, "source.o"), filepath.Join(dir, "partial.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	wasmDataCommand(t, wasmDataTool(t, "opt"), "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+	wasmDataCommand(t, wasmDataTool(t, "llc"), "-filetype=obj", optimized, "-o", object)
+	wasmDataCommand(t, wasmDataTool(t, "wasm-ld"), "-r", object, "-o", partial)
+	relocs := wasmDataCommand(t, wasmDataTool(t, "llvm-readobj"), "--relocations", partial)
+	if !strings.Contains(relocs, "R_WASM_TABLE_INDEX_I32") {
+		t.Fatalf("partial object lost the real packed table-index relocation:\n%s", relocs)
+	}
+	return partial, dir
+}
+
+func TestWASMPackedFunctionAddressBoundaries(t *testing.T) {
+	for _, addend := range []int64{-1, 65536, 1 << 32, -(1 << 32), 1<<63 - 1, -1 << 63} {
+		for _, opcode := range []string{"DATA", "I64Const", "I32Const", "MOVD", "MOVW", "MOVH", "MOVB"} {
+			t.Run(fmt.Sprintf("%s/%d", opcode, addend), func(t *testing.T) {
+				source := "TEXT ·target(SB),4,$0-0\nRET\n"
+				operand := fmt.Sprintf("$·target%+d(SB)", addend)
+				if opcode == "DATA" {
+					source += fmt.Sprintf("DATA holder(SB)/8,%s\nGLOBL holder(SB),16,$8\n", operand)
+				} else {
+					body := opcode + " " + operand + "\nDrop\n"
+					if strings.HasPrefix(opcode, "MOV") {
+						body = opcode + " " + operand + ", R0\n"
+					}
+					source += "TEXT ·address(SB),4,$0-0\n" + body + "RET\n"
+				}
+				for _, goos := range wasmPackedGoPlatforms {
+					wasmDataGoObject(t, source, goos)
+				}
+				file, err := Parse(ArchWASM, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs := map[string]FuncSig{"target": {Name: "target", Ret: Void}, "address": {Name: "address", Ret: Void}}
+				for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					_, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIGo), route)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s unrepresentable signed addend accepted: %v", route, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestWASMPackedNativeTargetStillRejectsGoControlABI(t *testing.T) {
+	for _, op := range []string{"CALL", "JMP"} {
+		source := wasmPackedNativeSource(t) + "TEXT ·caller(SB),4,$0-0\n" + op + " runtime·wasmDiv(SB)\nRET\n"
+		file, err := Parse(ArchWASM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		native, _ := LookupGoWASMNativeFuncSig("runtime.wasmDiv")
+		for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+			_, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{
+				"runtime.wasmDiv": native, "caller": {Name: "caller", Ret: Void},
+			}, WASMABIGo), route)
+			if err == nil || !strings.Contains(err.Error(), "native WebAssembly signature") {
+				t.Fatalf("%s %s native ABI falsely callable as Go: %v", route, op, err)
+			}
+		}
+	}
+}
+
+func TestWASMPackedFunctionAddressUnboundExternalRemainsContext(t *testing.T) {
+	for _, opcode := range []string{"DATA", "I64Const", "I32Const", "MOVB", "MOVH", "MOVW", "MOVD"} {
+		source := "DATA holder(SB)/8,$external(SB)\nGLOBL holder(SB),16,$8\n"
+		if opcode != "DATA" {
+			body := opcode + " $external(SB)\nDrop\n"
+			if strings.HasPrefix(opcode, "MOV") {
+				body = opcode + " $external(SB), R0\n"
+			}
+			source = "TEXT ·caller(SB),4,$0-0\n" + body + "RET\n"
+		}
+		file, err := Parse(ArchWASM, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, native := range []bool{false, true} {
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				_, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{
+					"external": {Name: "external_alias", Ret: Void, WASMNative: native}, "caller": {Name: "caller", Ret: Void},
+				}, WASMABIGo), route)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("%s %s guessed the external logical PC role: %v", route, opcode, err)
+				}
+			}
+		}
+	}
+}
+
+func TestWASMPackedActualStdlibABIAddress(t *testing.T) {
+	root := runtime.GOROOT()
+	path := filepath.Join(root, "src", "internal", "abi", "abi_test.s")
+	source, err := ReadGoAssemblySource(path, root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	decl, err := os.ReadFile(filepath.Join(root, "src", "internal", "abi", "export_test.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	end := strings.Index(string(decl), "\nvar FuncPCTestFnAddr")
+	if end < 0 {
+		t.Fatal("actual stdlib FuncPCTestFn declaration absent")
+	}
+	pkg := mustGoPackage(t, "internal/abi", string(decl[:end]))
+	resolve := func(symbol string) string {
+		return strings.ReplaceAll(wasmPackedResolve(symbol), "∕", "/")
+	}
+	for _, goos := range []string{"js", "wasip1"} {
+		t.Run(goos, func(t *testing.T) {
+			expanded, err := preprocessWithDefines(string(source), GoAssemblerDefines(goos, "wasm"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, oracleOS := range wasmPackedGoPlatforms {
+				wasmDataGoObject(t, expanded, oracleOS)
+			}
+			file, err := Parse(ArchWASM, expanded)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "wasm", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			triple := "wasm32-unknown-unknown"
+			if goos == "wasip1" {
+				triple = "wasm32-wasi"
+			}
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := wasmPackedTranslate(t, file, Options{Sigs: sigs, ResolveSym: resolve, Goarch: "wasm", TargetTriple: triple, WASMABI: WASMABIGo}, route)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir = strings.Replace(ir, "@SP = external addrspace(1) global i32", "@SP = addrspace(1) global i32 4096", 1)
+				ir += "@index = constant i32 ptrtoint (ptr @\"internal/abi.FuncPCTestFn\" to i32)\n"
+				partial, dir := wasmPackedObject(t, ir)
+				final := filepath.Join(dir, "stdlib.wasm")
+				wasmDataCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", "--export-memory", partial, "-o", final)
+				out := wasmDataCommand(t, wasmPackedNode(t), "-e", `const fs=require('fs');WebAssembly.instantiate(fs.readFileSync(process.argv[1]),{}).then(({instance:{exports:e}})=>{const v=new DataView(e.memory.buffer);const want=BigInt(v.getUint32(e.index.value,true))<<16n;const got=v.getBigUint64(e['internal/abi.FuncPCTestFnAddr'].value,true);if(got!==want)throw Error('original stdlib first-memory PC');console.log('original internal/abi/abi_test.s packed DATA PASS')}).catch(e=>{console.error(e);process.exit(1)});`, final)
+				t.Logf("%s: %s", route, strings.TrimSpace(out))
+			}
+		})
+	}
+}
+
+// A missing required runtime is a hard failure, not a skipped source form.
+func wasmPackedNode(t *testing.T) string {
+	t.Helper()
+	path, err := exec.LookPath("node")
+	if err != nil {
+		t.Fatal("required Node WebAssembly runtime is unavailable")
+	}
+	return path
+}
diff --git a/wasm_stdlib_test.go b/wasm_stdlib_test.go
index 214137eb1..b0cc4e936 100644
--- a/wasm_stdlib_test.go
+++ b/wasm_stdlib_test.go
@@ -1,6 +1,3 @@
-//go:build !llgo
-// +build !llgo
-
 package plan9asm
 
 import (
diff --git a/wasm_symbol_address.go b/wasm_symbol_address.go
new file mode 100644
index 000000000..5e382decd
--- /dev/null
+++ b/wasm_symbol_address.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+import "fmt"
+
+// wasmFunctionAddress separates a source Go logical PC from LLVM's physical
+// function-table index. WASMNative changes the physical signature, not Go's
+// source address: Go's linker assigns packed PCs to every TEXT symbol.
+func wasmFunctionAddress(file *File, symbol string, addend int64, resolve func(string) string, sigs map[string]FuncSig, abi WASMABI) (name string, function, packed bool, err error) {
+	name = resolveDataAddressSymbol(file, symbol, resolve, sigs)
+	function = dataAddressIsFunction(file, symbol, resolve, sigs)
+	if !function || abi != WASMABIGo {
+		return name, function, false, nil
+	}
+	for _, fn := range file.Funcs {
+		resolved := resolve(fn.Sym)
+		if funcSigSymbol(resolved, sigs[resolved]) != name {
+			continue
+		}
+		if addend < 0 || addend >= 1<<16 {
+			return "", true, false, fmt.Errorf("%w: wasm Go function address %s has an unrepresentable packed-PC addend %d", ErrProbeNeedsContext, symbol, addend)
+		}
+		return name, true, true, nil
+	}
+	return "", true, false, fmt.Errorf("%w: wasm Go function address %s requires a source-bound logical-PC contract", ErrProbeNeedsContext, symbol)
+}
diff --git a/wasm_translate.go b/wasm_translate.go
index 4b318f3f9..4f59777f4 100644
--- a/wasm_translate.go
+++ b/wasm_translate.go
@@ -28,7 +28,34 @@ type wasmControlFrame struct {
 // LLVM SSA. The direct ABI maps FP operands through FuncSig.Frame. The Go ABI
 // instead recreates the official compiler's linear-memory stack, register
 // globals, resumable calls, and unwind return protocol.
-func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, wasmABI WASMABI, annotateSource bool) error {
+func translateFuncWASM(b *strings.Builder, file *File, fn Func, sig FuncSig, resolve func(string) string, sigs map[string]FuncSig, wasmABI WASMABI, annotateSource bool) (err error) {
+	// Validate source format before dead-block removal. Pure dead operators may
+	// disappear, but malformed source must not acquire an apparent pass.
+	for _, ins := range fn.Instrs {
+		if _, _, err := parseWASMFloatBinary(ins); err != nil {
+			return err
+		}
+		if _, _, err := parseWASMIntegerCount(ins); err != nil {
+			return err
+		}
+		if _, _, err := parseWASMV128Core(ins); err != nil {
+			return err
+		}
+	}
+	// LLVM's WebAssembly backend cannot lower blockaddress. Keep this as a
+	// lowering invariant so future control-flow or code-pointer work fails here
+	// instead of producing IR that only breaks later in llc.
+	output := b
+	outputStart := b.Len()
+	defer func() {
+		if err != nil {
+			return
+		}
+		if strings.Contains(output.String()[outputStart:], "blockaddress(") {
+			err = fmt.Errorf("wasm lowering emitted unsupported LLVM blockaddress in %s", sig.Name)
+		}
+	}()
+
 	useGoStack := wasmABI == WASMABIGo
 	goABI := useGoStack && !sig.WASMNative
 	physicalRet := sig.Ret
@@ -308,9 +335,9 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 				return wasmValue{}, fmt.Errorf("FP parameter %s has invalid argument index %d", arg, slot.Index)
 			}
 			value := fmt.Sprintf("%%arg%d", slot.Index)
-			if slot.Field >= 0 {
+			if fields := frameSlotFields(slot); len(fields) != 0 {
 				name := newTmp()
-				fmt.Fprintf(b, "  %%%s = extractvalue %s %s, %d\n", name, sig.Args[slot.Index], value, slot.Field)
+				fmt.Fprintf(b, "  %%%s = extractvalue %s %s%s\n", name, sig.Args[slot.Index], value, frameSlotExtractSuffix(slot))
 				value = "%" + name
 			}
 			return wasmValue{typ: slot.Type, val: value}, nil
@@ -382,6 +409,29 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 				return wasmValue{}, fmt.Errorf("unsupported wasm symbol address %s", arg)
 			}
 			base = strings.TrimPrefix(base, "$")
+			if isAddress {
+				name, function, packed, addressErr := wasmFunctionAddress(file, base, offset, resolve, sigs, wasmABI)
+				if addressErr != nil {
+					return wasmValue{}, addressErr
+				}
+				if function {
+					v, err = cast(wasmValue{typ: Ptr, val: llvmGlobal(name)}, I64, false)
+					if err != nil {
+						return wasmValue{}, err
+					}
+					if packed {
+						tmp := newTmp()
+						fmt.Fprintf(b, "  %%%s = shl i64 %s, 16\n", tmp, v.val)
+						v = wasmValue{typ: I64, val: "%" + tmp}
+					}
+					if offset != 0 {
+						tmp := newTmp()
+						fmt.Fprintf(b, "  %%%s = add i64 %s, %d\n", tmp, v.val, offset)
+						v = wasmValue{typ: I64, val: "%" + tmp}
+					}
+					break
+				}
+			}
 			if !strings.ContainsAny(base, "·/.") {
 				base = "·" + base
 			}
@@ -1011,20 +1061,17 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			case "CALL", "CALLNORESUME":
 				pcID++
 				callPCs[i] = pcID
-				if goABI && normalizeInstructionOpcode(ins.Op) == "CALL" {
-					resumeLabels[i] = fmt.Sprintf("wasm_resume_%d", pcID)
-				}
 			}
 		}
 	}
+	var goABIOuter *strings.Builder
 	if goABI {
-		b.WriteString("  switch i32 %pc_b, label %wasm_entry_body [")
-		for i := range fn.Instrs {
-			if label := resumeLabels[i]; label != "" {
-				fmt.Fprintf(b, " i32 %d, label %%%s", callPCs[i], label)
-			}
-		}
-		b.WriteString(" ]\nwasm_entry_body:\n")
+		// Build the function body separately so the entry dispatch can contain
+		// only resume labels that were actually emitted. A terminating tail
+		// return can make a later lexical CALL unreachable.
+		goABIOuter = b
+		b = &strings.Builder{}
+		b.WriteString("wasm_entry_body:\n")
 		if fn.FrameSize != 0 {
 			sp, err := loadRegister(SP)
 			if err != nil {
@@ -1049,6 +1096,38 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 		if blockTerminated && op != "ELSE" && op != "END" && op != "LABEL" {
 			continue
 		}
+		if spec, ok := wasmV128CoreOps[op]; ok {
+			var inputs [3]wasmValue
+			for index := spec.inputs - 1; index >= 0; index-- {
+				value, err := pop(op)
+				if err != nil {
+					return err
+				}
+				if value.typ != wasmV128CoreType || value.stackAddr {
+					return fmt.Errorf("%s requires V128 stack values, got %s", ins.Op, value.typ)
+				}
+				inputs[index] = value
+			}
+			push(emitWASMV128Core(b, newTmp, spec, ins, inputs[:spec.inputs]))
+			continue
+		}
+		if spec, ok := wasmIntegerCountOps[op]; ok {
+			value, err := pop(op)
+			if err != nil {
+				return err
+			}
+			if value.typ != spec.typ || value.stackAddr {
+				return fmt.Errorf("%s expects one %s stack value, got %s", ins.Op, spec.typ, value.typ)
+			}
+			name := newTmp()
+			fmt.Fprintf(b, "  %%%s = call %s @llvm.%s.%s(%s %s", name, spec.typ, spec.intrinsic, spec.typ, spec.typ, value.val)
+			if spec.intrinsic != "ctpop" {
+				b.WriteString(", i1 false") // Zero is defined, never LLVM poison.
+			}
+			b.WriteString(")\n")
+			push(wasmValue{typ: spec.typ, val: "%" + name})
+			continue
+		}
 		if spec, ok := wasmIntegerBinaryOps[op]; ok {
 			if err := emitIntBinary(op, spec.typ, spec.op); err != nil {
 				return err
@@ -1061,6 +1140,86 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			}
 			continue
 		}
+		if spec, ok := wasmFloatBinaryProperties(op); ok {
+			rhs, err := pop(op)
+			if err != nil {
+				return err
+			}
+			lhs, err := pop(op)
+			if err != nil {
+				return err
+			}
+			if lhs.typ != spec.typ || rhs.typ != spec.typ || lhs.stackAddr || rhs.stackAddr {
+				return fmt.Errorf("%s expects two %s stack values, got %s and %s", ins.Op, spec.typ, lhs.typ, rhs.typ)
+			}
+			name := newTmp()
+			if spec.predicate != "" {
+				fmt.Fprintf(b, "  %%%s = fcmp %s %s %s, %s\n", name, spec.predicate, spec.typ, lhs.val, rhs.val)
+				result := newTmp()
+				fmt.Fprintf(b, "  %%%s = zext i1 %%%s to i32\n", result, name)
+				name = result
+			} else {
+				bits := 32
+				if spec.typ == "double" {
+					bits = 64
+				}
+				if spec.operation != "" {
+					// No fast-math flags: signed zero, infinities, gradual
+					// underflow and the declared rounding precision are live.
+					fmt.Fprintf(b, "  %%%s = %s %s %s, %s\n", name, spec.operation, spec.typ, lhs.val, rhs.val)
+				} else {
+					// Unlike minnum/maxnum or ordered select, minimum/maximum
+					// propagate NaNs and order -0 before +0, as Wasm requires.
+					fmt.Fprintf(b, "  %%%s = call %s @llvm.%s.f%d(%s %s, %s %s)\n", name, spec.typ, spec.intrinsic, bits, spec.typ, lhs.val, spec.typ, rhs.val)
+				}
+				// LLVM may fold minimum(x,x) or identity arithmetic to x,
+				// including a signaling NaN. Wasm requires a quiet NaN;
+				// canonical NaN is valid for every permitted input payload.
+				// Integer bits keep optimization from discarding quieting as
+				// a redundant floating-point operation.
+				signless, infinity, canonical := uint64(0x7fffffff), uint64(0x7f800000), uint64(0x7fc00000)
+				if bits == 64 {
+					signless, infinity, canonical = 0x7fffffffffffffff, 0x7ff0000000000000, 0x7ff8000000000000
+				}
+				raw, magnitude, isNaN, selected, normalized := newTmp(), newTmp(), newTmp(), newTmp(), newTmp()
+				fmt.Fprintf(b, "  %%%s = bitcast %s %%%s to i%d\n", raw, spec.typ, name, bits)
+				fmt.Fprintf(b, "  %%%s = and i%d %%%s, %d\n", magnitude, bits, raw, signless)
+				fmt.Fprintf(b, "  %%%s = icmp ugt i%d %%%s, %d\n", isNaN, bits, magnitude, infinity)
+				fmt.Fprintf(b, "  %%%s = select i1 %%%s, i%d %d, i%d %%%s\n", selected, isNaN, bits, canonical, bits, raw)
+				fmt.Fprintf(b, "  %%%s = bitcast i%d %%%s to %s\n", normalized, bits, selected, spec.typ)
+				name = normalized
+			}
+			push(wasmValue{typ: spec.resultType(), val: "%" + name})
+			continue
+		}
+		if spec, ok := wasmFloatUnaryOps[op]; ok {
+			if len(ins.Args) != 0 {
+				return fmt.Errorf("%s is a zero-operand WebAssembly stack instruction", ins.Op)
+			}
+			value, err := pop(op)
+			if err != nil {
+				return err
+			}
+			if value.typ != spec.typ || value.stackAddr {
+				wantType := "f32"
+				if spec.typ == LLVMType("double") {
+					wantType = "f64"
+				}
+				return fmt.Errorf("%s expects %s, got %s", op, wantType, value.typ)
+			}
+			name := newTmp()
+			if spec.intrinsic == "" {
+				fmt.Fprintf(b, "  %%%s = fneg %s %s\n", name, spec.typ, value.val)
+			} else {
+				bits := "32"
+				if spec.typ == LLVMType("double") {
+					bits = "64"
+				}
+				fmt.Fprintf(b, "  %%%s = call %s @llvm.%s.f%s(%s %s)\n", name, spec.typ, spec.intrinsic, bits, spec.typ, value.val)
+			}
+			push(wasmValue{typ: spec.typ, val: "%" + name})
+			continue
+		}
 		if spec, ok := wasmMemoryLoadOps[op]; ok {
 			if len(ins.Args) != 1 {
 				return fmt.Errorf("%s expects one operand", ins.Op)
@@ -1117,7 +1276,7 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			continue
 		}
 		switch op {
-		case "NOP", "NO_LOCAL_POINTERS":
+		case "NOP", "NO_LOCAL_POINTERS", "FUNCDATA", "PCDATA":
 			continue
 		case "LABEL":
 			if len(ins.Args) != 1 {
@@ -1249,15 +1408,31 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			if op == "TEE" {
 				push(v)
 			}
-		case "MOVB", "MOVW", "MOVD":
+		case "MOVB", "MOVH", "MOVW", "MOVD":
 			if len(ins.Args) != 2 {
 				return fmt.Errorf("%s expects source and destination", ins.Op)
 			}
-			width := map[string]LLVMType{"MOVB": I8, "MOVW": I32, "MOVD": I64}[op]
-			v, err := loadOperand(ins.Args[0], width)
+			width := wasmMoveTypes[op]
+			loadWidth := width
+			if ins.Args[0].Kind == OpReg || ins.Args[0].Kind == OpImm || ins.Args[0].Kind == OpFPAddr ||
+				ins.Args[0].Kind == OpSym && strings.HasPrefix(strings.TrimSpace(ins.Args[0].Sym), "$") {
+				// Go MOV widths select memory access size. Register,
+				// immediate and address values retain all 64 bits.
+				loadWidth = I64
+			}
+			v, err := loadOperand(ins.Args[0], loadWidth)
 			if err != nil {
 				return err
 			}
+			if ins.Args[1].Kind != OpReg {
+				v, err = cast(v, width, false)
+				if err != nil {
+					return err
+				}
+			}
+			if ins.Args[1].Kind == OpSym && strings.HasPrefix(strings.TrimSpace(ins.Args[1].Sym), "$") {
+				return fmt.Errorf("%s cannot store into an immediate symbol address", ins.Op)
+			}
 			if err := storeOperand(ins.Args[1], v); err != nil {
 				return err
 			}
@@ -1283,24 +1458,6 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 				return fmt.Errorf("F64Const expects one floating immediate")
 			}
 			push(wasmValue{typ: LLVMType("double"), val: fmt.Sprintf("0x%016X", uint64(ins.Args[0].Imm))})
-		case "F64NE", "F64GT", "F64LT":
-			rhs, err := pop(op)
-			if err != nil {
-				return err
-			}
-			lhs, err := pop(op)
-			if err != nil {
-				return err
-			}
-			if lhs.typ != LLVMType("double") || rhs.typ != LLVMType("double") {
-				return fmt.Errorf("%s expects two f64 values", ins.Op)
-			}
-			pred := map[string]string{"F64NE": "une", "F64GT": "ogt", "F64LT": "olt"}[op]
-			cmp := newTmp()
-			fmt.Fprintf(b, "  %%%s = fcmp %s double %s, %s\n", cmp, pred, lhs.val, rhs.val)
-			out := newTmp()
-			fmt.Fprintf(b, "  %%%s = zext i1 %%%s to i32\n", out, cmp)
-			push(wasmValue{typ: I32, val: "%" + out})
 		case "I64TRUNCF64S", "I64TRUNCF64U":
 			v, err := pop(op)
 			if err != nil {
@@ -1382,18 +1539,6 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			if _, err := pop(op); err != nil {
 				return err
 			}
-		case "F64FLOOR", "F64CEIL", "F64TRUNC":
-			v, err := pop(op)
-			if err != nil {
-				return err
-			}
-			if v.typ != LLVMType("double") || v.stackAddr {
-				return fmt.Errorf("%s expects f64, got %s", op, v.typ)
-			}
-			intrinsic := strings.ToLower(strings.TrimPrefix(op, "F64"))
-			name := newTmp()
-			fmt.Fprintf(b, "  %%%s = call double @llvm.%s.f64(double %s)\n", name, intrinsic, v.val)
-			push(wasmValue{typ: LLVMType("double"), val: "%" + name})
 		case "F64STORE":
 			if len(ins.Args) != 1 || ins.Args[0].Kind != OpFP {
 				return fmt.Errorf("F64Store expects an FP slot")
@@ -1520,6 +1665,9 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 			// Only the Go ABI entry has a PC_B resume switch. Native helpers
 			// still use the linear Go stack for calls, but continue directly
 			// after a normally returning callee.
+			if op == "CALL" && goABI {
+				resumeLabels[insIndex] = fmt.Sprintf("wasm_resume_%d", callPCs[insIndex])
+			}
 			if err := emitGoCall(target, callPCs[insIndex], resumeLabels[insIndex], op == "CALL" && goABI); err != nil {
 				return err
 			}
@@ -1601,6 +1749,18 @@ func translateFuncWASM(b *strings.Builder, fn Func, sig FuncSig, resolve func(st
 		}
 	}
 	b.WriteString("}\n")
+	if goABI {
+		body := b.String()
+		b = goABIOuter
+		b.WriteString("  switch i32 %pc_b, label %wasm_entry_body [")
+		for i := range fn.Instrs {
+			if label := resumeLabels[i]; label != "" {
+				fmt.Fprintf(b, " i32 %d, label %%%s", callPCs[i], label)
+			}
+		}
+		b.WriteString(" ]\n")
+		b.WriteString(body)
+	}
 	return nil
 }
 
@@ -1612,9 +1772,10 @@ func wasmNeedsIncomingContext(fn Func) bool {
 	initialized := false
 	for _, ins := range fn.Instrs {
 		op := strings.ToUpper(string(ins.Op))
+		_, move := wasmMoveTypes[op]
 		for i, arg := range ins.Args {
 			writes := (op == "SET" || op == "TEE") && i == 0 && arg.Kind == OpReg ||
-				(op == "MOVB" || op == "MOVW" || op == "MOVD") && i == 1 && arg.Kind == OpReg
+				move && i == 1 && arg.Kind == OpReg
 			if writes && arg.Reg == Reg("CTXT") {
 				initialized = true
 				continue
diff --git a/wasm_translate_test.go b/wasm_translate_test.go
index e7f8dac83..1e64df2d2 100644
--- a/wasm_translate_test.go
+++ b/wasm_translate_test.go
@@ -5,6 +5,116 @@ import (
 	"testing"
 )
 
+func TestTranslateWasmControlFlowAvoidsLLVMBlockAddress(t *testing.T) {
+	file, err := Parse(ArchWASM, `TEXT noBlockAddress(SB), NOSPLIT, $0-0
+	I32Const $1
+	If
+		I32Const $2
+		Drop
+	Else
+		I32Const $3
+		Drop
+	End
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "wasm32-unknown-unknown",
+		Goarch:       "wasm",
+		Sigs: map[string]FuncSig{
+			"noBlockAddress": {Name: "noBlockAddress", Ret: Void},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "blockaddress(") {
+		t.Fatalf("WebAssembly lowering emitted LLVM blockaddress:\n%s", ir)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "wasm32-unknown-unknown", "wasm-no-blockaddress.ll", "wasm-no-blockaddress.o", ir)
+}
+
+func TestTranslateWasmFloatUnaryFamilyCompleteGo127Forms(t *testing.T) {
+	file, err := Parse(ArchWASM, `
+TEXT floatunary(SB),0,$0-0
+	Get F0
+	F32Abs
+	F32Neg
+	F32Ceil
+	F32Floor
+	F32Trunc
+	F32Nearest
+	F32Sqrt
+	Drop
+	Get F16
+	F64Abs
+	F64Neg
+	F64Ceil
+	F64Floor
+	F64Trunc
+	F64Nearest
+	F64Sqrt
+	Drop
+	FUNCDATA $0, unaryargs(SB)
+	PCDATA $0, $0
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "wasm32-unknown-unknown",
+		Goarch:       "wasm",
+		Sigs:         map[string]FuncSig{"floatunary": {Name: "floatunary", Ret: Void}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"call float @llvm.fabs.f32", "fneg float", "call float @llvm.ceil.f32",
+		"call float @llvm.floor.f32", "call float @llvm.trunc.f32", "call float @llvm.roundeven.f32",
+		"call float @llvm.sqrt.f32", "call double @llvm.fabs.f64", "fneg double",
+		"call double @llvm.ceil.f64", "call double @llvm.floor.f64", "call double @llvm.trunc.f64",
+		"call double @llvm.roundeven.f64", "call double @llvm.sqrt.f64",
+	} {
+		if !strings.Contains(ir, want) {
+			t.Fatalf("wasm floating unary family IR missing %q:\n%s", want, ir)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	compileLLVMToObject(t, llc, "wasm32-unknown-unknown", "wasm-float-unary.ll", "wasm-float-unary.o", ir)
+}
+
+func TestTranslateWasmFloatUnaryFamilyRejectsFormsOutsideGo127Opcodes(t *testing.T) {
+	for _, body := range []string{
+		"F64Sqrt $1",
+		"F32Abs $1",
+		"I64Const $1\nF64Sqrt",
+		"I32Const $1\nF32Nearest",
+	} {
+		file, err := Parse(ArchWASM, "TEXT bad(SB),0,$0-0\n"+body+"\nDrop\nRET\n")
+		if err != nil {
+			continue
+		}
+		if _, err := Translate(file, Options{
+			TargetTriple: "wasm32-unknown-unknown",
+			Goarch:       "wasm",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		}); err == nil {
+			t.Fatalf("Translate accepted wasm unary form outside Go 1.27 opcode semantics:\n%s", body)
+		}
+	}
+}
+
 func TestTranslateOfficialWasmFloorFunctions(t *testing.T) {
 	file, err := Parse(ArchWASM, `
 TEXT ·archFloor(SB),NOSPLIT,$0
diff --git a/wasm_v128_core.go b/wasm_v128_core.go
new file mode 100644
index 000000000..2f0d28e30
--- /dev/null
+++ b/wasm_v128_core.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Reuse the existing V-register carrier. These bitwise operations have one
+// fixed 128-bit type; they do not introduce scalar/vector casts or memory.
+const wasmV128CoreType LLVMType = "<4 x i32>"
+
+type wasmV128CoreOp struct {
+	inputs    int
+	operation string
+}
+
+var wasmV128CoreOps = map[string]wasmV128CoreOp{
+	"V128CONST":     {0, "const"},
+	"V128NOT":       {1, "not"},
+	"V128AND":       {2, "and"},
+	"V128ANDNOT":    {2, "andnot"},
+	"V128OR":        {2, "or"},
+	"V128XOR":       {2, "xor"},
+	"V128BITSELECT": {3, "bitselect"},
+	"V128ANYTRUE":   {1, "anytrue"},
+}
+
+func (op wasmV128CoreOp) resultType() LLVMType {
+	if op.operation == "anytrue" {
+		return I32
+	}
+	return wasmV128CoreType
+}
+
+func parseWASMV128Core(ins Instr) (wasmV128CoreOp, bool, error) {
+	name := normalizeInstructionOpcode(ins.Op)
+	spec, found := wasmV128CoreOps[name]
+	if !found {
+		return spec, false, nil
+	}
+	operands := 0
+	if spec.operation == "const" {
+		operands = 2
+	}
+	if strings.ToUpper(string(ins.Op)) != name || len(ins.Args) != operands {
+		return spec, true, fmt.Errorf("%s requires %d operands and no suffix: %q", name, operands, ins.Raw)
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpImm || operand.ImmIsFloat || operand.ImmRaw != "" {
+			return spec, true, fmt.Errorf("%s requires two resolved 64-bit integer literals: %q", name, ins.Raw)
+		}
+	}
+	return spec, true, nil
+}
+
+// Values arrive in Wasm source order, not pop order: Bitselect's third input
+// is the mask, and Andnot complements only the second input.
+func emitWASMV128Core(b *strings.Builder, newTmp func() string, spec wasmV128CoreOp, ins Instr, inputs []wasmValue) wasmValue {
+	if spec.operation == "const" {
+		low, high := uint64(ins.Args[0].Imm), uint64(ins.Args[1].Imm)
+		value := fmt.Sprintf("<i32 %d, i32 %d, i32 %d, i32 %d>",
+			int32(low), int32(low>>32), int32(high), int32(high>>32))
+		return wasmValue{typ: wasmV128CoreType, val: value}
+	}
+	binary := func(operation, a, c string) string {
+		result := newTmp()
+		fmt.Fprintf(b, "  %%%s = %s %s %s, %s\n", result, operation, wasmV128CoreType, a, c)
+		return "%" + result
+	}
+	invert := func(value string) string {
+		return binary("xor", value, "<i32 -1, i32 -1, i32 -1, i32 -1>")
+	}
+	var result string
+	switch spec.operation {
+	case "not":
+		result = invert(inputs[0].val)
+	case "andnot":
+		result = binary("and", inputs[0].val, invert(inputs[1].val))
+	case "bitselect":
+		mask := inputs[2].val
+		first := binary("and", inputs[0].val, mask)
+		second := binary("and", inputs[1].val, invert(mask))
+		result = binary("or", first, second)
+	case "anytrue":
+		bits, nonzero, integer := newTmp(), newTmp(), newTmp()
+		fmt.Fprintf(b, "  %%%s = bitcast %s %s to i128\n", bits, wasmV128CoreType, inputs[0].val)
+		fmt.Fprintf(b, "  %%%s = icmp ne i128 %%%s, 0\n", nonzero, bits)
+		fmt.Fprintf(b, "  %%%s = zext i1 %%%s to i32\n", integer, nonzero)
+		result = "%" + integer
+	default: // The descriptor's remaining three operations are LLVM bitwise ops.
+		result = binary(spec.operation, inputs[0].val, inputs[1].val)
+	}
+	return wasmValue{typ: spec.resultType(), val: result}
+}
diff --git a/wasm_v128_core_go127_test.go b/wasm_v128_core_go127_test.go
new file mode 100644
index 000000000..7ff9f1d5b
--- /dev/null
+++ b/wasm_v128_core_go127_test.go
@@ -0,0 +1,60 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Go's assembler gained the SIMD namespace in Go 1.27. Its independent
+// original-object/runtime checks must not hide minimum-Go LLVM coverage.
+func TestWASMV128CoreActualGoNamespaceAndObjects(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/wasm/anames.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var names []string
+	for _, match := range regexp.MustCompile(`"(V128(?:Const|Not|And|Andnot|Or|Xor|Bitselect|AnyTrue))"`).FindAllSubmatch(data, -1) {
+		names = append(names, string(match[1]))
+	}
+	if !reflect.DeepEqual(names, wasmV128CoreNames()) {
+		t.Fatalf("complete official V128 core namespace changed: %v", names)
+	}
+	source, _ := wasmV128CoreObjectFixture()
+	for _, goos := range wasmPackedGoPlatforms {
+		wasmDataGoObject(t, source, goos)
+	}
+}
+
+func TestWASMV128CoreOriginalGoRuntime(t *testing.T) {
+	_, source, program, _, _ := wasmV128CoreRuntimeFixture(t)
+	dir := t.TempDir()
+	for name, text := range map[string]string{"go.mod": "module v128_core_oracle\ngo 1.20\n", "main.go": program, "oracle_wasm.s": source} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(text), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "build", "-o", "oracle.wasm", ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOWORK=off", "GOOS=js", "GOARCH=wasm", "GOTOOLCHAIN=local")
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("original Go V128 core build: %v\n%s", err, output)
+	}
+	command, err := wasmPackedGoRuntimeCommand(ctx, runtime.GOROOT(), wasmPackedNode(t), filepath.Join(dir, "oracle.wasm"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || strings.TrimSpace(string(output)) != "V128 core PASS 48" {
+		t.Fatalf("original Go V128 core execution: %v\n%s", err, output)
+	}
+}
diff --git a/wasm_v128_core_infer_test.go b/wasm_v128_core_infer_test.go
new file mode 100644
index 000000000..caac7dc49
--- /dev/null
+++ b/wasm_v128_core_infer_test.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"testing"
+)
+
+// Keep the public inference counterexamples independent of its private dead
+// flag: a source label alone does not create an incoming control-flow edge.
+func TestWASMV128CorePublicInferenceMatchesDeadControl(t *testing.T) {
+	type testCase struct {
+		name, body string
+		accept     bool
+		result     LLVMType
+	}
+	cases := []testCase{
+		{"ret", "RET\nV128Not\nRET\n", true, Void},
+		{"undef", "UNDEF\nV128Not\nRET\n", true, Void},
+		{"unreachable", "Unreachable\nV128Not\nRET\n", true, Void},
+		{"unused-label", "RET\nunused:\nV128Not\nRET\n", true, Void},
+		{"branch", "Block\nBr $0\nV128Not\nEnd\nRET\n", true, Void},
+		{"branch-unused-label", "Block\nBr $0\nunused:\nV128Not\nEnd\nRET\n", true, Void},
+		{"dead-label-constant-does-not-change-ABI", "RET\nunused:\nV128Const $1,$2\nRET\n", true, Void},
+		{"malformed-dead", "UNDEF\nV128Not $1\nRET\n", false, Void},
+		{"malformed-dead-label", "RET\nunused:\nV128Const $1\nRET\n", false, Void},
+		{"live-underflow", "V128Not\nRET\n", false, Void},
+		{"live-wrong-scalar", "I64Const $1\nV128Not\nRET\n", false, Void},
+		{"live-i64-return-ignores-dead-i32", "I64Const $9\nReturn\nI32Const $1\nReturn\n", true, I64},
+	}
+	for _, prefix := range []struct{ name, body string }{
+		{"ret", "RET\n"}, {"ret-unused-label", "RET\nunused:\n"},
+		{"undef", "UNDEF\n"}, {"unreachable", "Unreachable\n"},
+	} {
+		for _, scalar := range []string{"I32Const $1", "I64Const $1", "F64Const $1.0"} {
+			cases = append(cases, testCase{
+				name: prefix.name + "-dead-" + scalar, body: prefix.body + scalar + "\nRET\n", accept: true, result: Void,
+			})
+		}
+	}
+	// Retain every existing typed count and floating binary operation, rather
+	// than using a single mnemonic to represent the complete descriptor paths.
+	for _, family := range [][]string{wasmIntegerCountGoNames(t), wasmFloatBinaryGoNames(t), wasmFloatArithmeticGoNames(t)} {
+		for _, name := range family {
+			cases = append(cases,
+				testCase{name: "typed-dead/" + name, body: "RET\n" + name + "\nRET\n", accept: true, result: Void},
+				testCase{name: "typed-malformed-dead/" + name, body: "RET\n" + name + " $1\nRET\n", result: Void})
+		}
+	}
+	if len(cases) != 84 {
+		t.Fatal("complete dead-control regression inventory changed", len(cases))
+	}
+	for _, row := range cases {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchWASM, "TEXT core(SB),4,$0-0\n"+row.body)
+			if err != nil {
+				t.Fatal("counterexample source must parse independently of the core grammar", err)
+			}
+			sig, inferenceError := InferWASMAssemblyFuncSig(file.Funcs[0], "core")
+			if row.accept {
+				if inferenceError != nil || sig.Ret != row.result || len(sig.Args) != 0 {
+					t.Errorf("dead instruction changed public inference, want %s: %+v, %v", row.result, sig, inferenceError)
+				}
+			} else if inferenceError == nil {
+				t.Error("public inference accepted malformed/live-invalid core source", sig)
+			}
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"core": {Name: "core", Ret: row.result}}, WASMABIDirect), route)
+				if row.accept && (err != nil || ir == "") {
+					t.Errorf("%s lost independent %s lowering control: %v", route, row.result, err)
+				}
+				if !row.accept && (err == nil || ir != "") {
+					t.Errorf("%s accepted malformed/live-invalid core source: %v", route, err)
+				}
+			}
+		})
+	}
+}
diff --git a/wasm_v128_core_runtime_test.go b/wasm_v128_core_runtime_test.go
new file mode 100644
index 000000000..e6a27f4ad
--- /dev/null
+++ b/wasm_v128_core_runtime_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+type wasmV128CoreObservation struct {
+	Name string
+	Want uint32
+}
+
+// Whole-bit Wasm relations, independent of the translator's representation.
+// Core-only observation uses XOR/AnyTrue, not new memory/extraction opcodes.
+func wasmV128CoreReference(name string, a, b, mask [2]uint64) [2]uint64 {
+	var result [2]uint64
+	for half := range result {
+		switch name {
+		case "V128Const":
+			result[half] = a[half]
+		case "V128Not":
+			result[half] = ^a[half]
+		case "V128And":
+			result[half] = a[half] & b[half]
+		case "V128Andnot":
+			result[half] = a[half] &^ b[half]
+		case "V128Or":
+			result[half] = a[half] | b[half]
+		case "V128Xor":
+			result[half] = a[half] ^ b[half]
+		case "V128Bitselect":
+			result[half] = a[half]&mask[half] | b[half]&^mask[half]
+		default:
+			panic("not a vector-result core reference: " + name)
+		}
+	}
+	return result
+}
+
+func wasmV128CoreRuntimeFixture(t *testing.T) (string, string, string, map[string]FuncSig, []byte) {
+	t.Helper()
+	patterns := [][3][2]uint64{
+		{{0, 0}, {0, 0}, {0, 0}},
+		{{^uint64(0), ^uint64(0)}, {0, 0}, {^uint64(0), 0}},
+		{{0, 1 << 63}, {1 << 63, 0}, {0, ^uint64(0)}},
+		{{1, 0}, {0, ^uint64(0)}, {0x5555555555555555, 0xaaaaaaaaaaaaaaaa}},
+		{{0x0123456789abcdef, 0xfedcba9876543210}, {0x89abcdef01234567, 0x76543210fedcba98}, {0xf0f00f0ff0f00f0f, 0x0f0ff0f00f0ff0f0}},
+		{{0x8000000000000000, 0x7fffffffffffffff}, {0x7fffffffffffffff, 0x8000000000000000}, {^uint64(0), ^uint64(0)}},
+	}
+	var source, original, program strings.Builder
+	program.WriteString("package main\nimport \"fmt\"\n")
+	sigs := make(map[string]FuncSig)
+	var rows []wasmV128CoreObservation
+	for _, name := range wasmV128CoreNames() {
+		for _, pattern := range patterns {
+			a, b, mask := pattern[0], pattern[1], pattern[2]
+			function := fmt.Sprintf("core%d", len(rows))
+			body, want := wasmV128CoreBody(name, a, b, mask), uint32(0)
+			if name == "V128AnyTrue" {
+				if a[0] != 0 || a[1] != 0 {
+					want = 1
+				}
+			} else {
+				body += wasmV128CoreConstant(wasmV128CoreReference(name, a, b, mask)) + "V128Xor\nV128AnyTrue\n"
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%sReturn\n", function, body)
+			fmt.Fprintf(&original, "TEXT ·%s(SB),4,$0-4\nGet SP\n%sI32Store ret+0(FP)\nRET\n", function, body)
+			fmt.Fprintf(&program, "func %s() uint32\n", function)
+			sigs[function] = FuncSig{Name: function, Ret: I32}
+			rows = append(rows, wasmV128CoreObservation{Name: function, Want: want})
+		}
+	}
+	if len(rows) != 48 {
+		t.Fatal("complete eight-member, six-pattern observation inventory changed", len(rows))
+	}
+	program.WriteString("func main() {\n")
+	for _, row := range rows {
+		fmt.Fprintf(&program, "if got := %s(); got != %d { panic(fmt.Sprintf(\"%s: %%d\", got)) }\n", row.Name, row.Want, row.Name)
+	}
+	program.WriteString("fmt.Println(\"V128 core PASS 48\")\n}\n")
+	data, err := json.Marshal(rows)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source.String(), original.String(), program.String(), sigs, data
+}
+
+func TestWASMV128CoreThreeAPIsLLVMRuntime(t *testing.T) {
+	source, _, _, sigs, rows := wasmV128CoreRuntimeFixture(t)
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIDirect), route)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, optimize := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/IR-O2=%t", route, optimize), func(t *testing.T) {
+				dir := t.TempDir()
+				input, object, binary := filepath.Join(dir, "input.ll"), filepath.Join(dir, "output.o"), filepath.Join(dir, "output.wasm")
+				if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+					t.Fatal(err)
+				}
+				if optimize {
+					optimized := filepath.Join(dir, "optimized.ll")
+					wasmFloatBinaryCommand(t, wasmDataTool(t, "opt"), "-passes=default<O2>", "-verify-each", "-S", input, "-o", optimized)
+					input = optimized
+				}
+				wasmFloatBinaryCommand(t, wasmDataTool(t, "llc"), "-filetype=obj", input, "-o", object)
+				wasmFloatBinaryCommand(t, wasmDataTool(t, "wasm-ld"), "--no-entry", "--export-all", object, "-o", binary)
+				inputs := filepath.Join(dir, "inputs.json")
+				if err := os.WriteFile(inputs, rows, 0600); err != nil {
+					t.Fatal(err)
+				}
+				output := wasmFloatBinaryCommand(t, wasmPackedNode(t), "-e", wasmV128CoreNodeCheck, binary, inputs)
+				if strings.TrimSpace(output) != "V128 core PASS 48" {
+					t.Fatal("incomplete V128 core execution", output)
+				}
+			})
+		}
+	}
+}
+
+const wasmV128CoreNodeCheck = `
+const fs = require('fs');
+WebAssembly.instantiate(fs.readFileSync(process.argv[1]), {}).then(({instance:{exports:e}}) => {
+  const rows = JSON.parse(fs.readFileSync(process.argv[2], 'utf8'));
+  let count = 0;
+  for (const row of rows) {
+    const got = e[row.Name]();
+    if (got !== row.Want) throw Error(row.Name + ': ' + got + ' want ' + row.Want);
+    count++;
+  }
+  console.log('V128 core PASS ' + count);
+}).catch(error => { console.error(error); process.exit(1); });
+`
diff --git a/wasm_v128_core_test.go b/wasm_v128_core_test.go
new file mode 100644
index 000000000..b5f09e91b
--- /dev/null
+++ b/wasm_v128_core_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This semantic inventory is independent of the translator and host Go's
+// assembler version. LLVM coverage must also run before Go 1.27 added SIMD.
+func wasmV128CoreNames() []string {
+	return []string{"V128Const", "V128Not", "V128And", "V128Andnot", "V128Or", "V128Xor", "V128Bitselect", "V128AnyTrue"}
+}
+
+func wasmV128CoreConstant(value [2]uint64) string {
+	return fmt.Sprintf("V128Const $%d,$%d\n", int64(value[0]), int64(value[1]))
+}
+
+func wasmV128CoreInputs(name string) int {
+	switch name {
+	case "V128Const":
+		return 0
+	case "V128Not", "V128AnyTrue":
+		return 1
+	case "V128Bitselect":
+		return 3
+	default:
+		return 2
+	}
+}
+
+func wasmV128CoreBody(name string, a, b, mask [2]uint64) string {
+	if name == "V128Const" {
+		return wasmV128CoreConstant(a)
+	}
+	body := wasmV128CoreConstant(a)
+	if wasmV128CoreInputs(name) >= 2 {
+		body += wasmV128CoreConstant(b)
+	}
+	if name == "V128Bitselect" {
+		body += wasmV128CoreConstant(mask)
+	}
+	return body + name + "\n"
+}
+
+func wasmV128CoreObjectFixture() (string, map[string]FuncSig) {
+	var source strings.Builder
+	sigs := make(map[string]FuncSig)
+	for index, name := range wasmV128CoreNames() {
+		function := fmt.Sprintf("core%d", index)
+		body := wasmV128CoreBody(name, [2]uint64{1, 2}, [2]uint64{3, 4}, [2]uint64{5, 6})
+		if name != "V128AnyTrue" {
+			body += "V128AnyTrue\n"
+		}
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%sReturn\n", function, body)
+		sigs[function] = FuncSig{Name: function, Ret: I32}
+	}
+	return source.String(), sigs
+}
+
+func TestWASMV128CoreThreeAPIObjects(t *testing.T) {
+	source, sigs := wasmV128CoreObjectFixture()
+	file, err := Parse(ArchWASM, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, function := range file.Funcs {
+		sig, err := InferWASMAssemblyFuncSig(function, function.Sym)
+		if err != nil || len(sig.Args) != 0 || sig.Ret != I32 {
+			t.Errorf("V128 core typed stack inference: %+v, %v", sig, err)
+		}
+	}
+	for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+		t.Run(route, func(t *testing.T) {
+			ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(sigs, WASMABIDirect), route)
+			if err != nil || ir == "" {
+				t.Fatal("V128 core semantic family rejected", err)
+			}
+			if strings.Contains(ir, "blockaddress") {
+				t.Fatal("V128 core introduced an unsupported Wasm code address")
+			}
+			compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "v128-core.ll", "v128-core.o", ir)
+		})
+	}
+}
+
+func TestWASMV128CoreFormatTypedStackAndDeadCode(t *testing.T) {
+	vector := wasmV128CoreConstant([2]uint64{1, 2})
+	for _, name := range wasmV128CoreNames() {
+		var invalid []string
+		instruction := name
+		if name == "V128Const" {
+			instruction += " $1,$2"
+			for _, operands := range []string{"", " $1", " $1,$2,$3", " R0,$1", " $1,R0", " $1.5,$2", " $1,$2.5", " $unresolved,$2", " 0(SP),$2"} {
+				invalid = append(invalid, name+operands, "RET\n"+name+operands)
+			}
+			invalid = append(invalid, name+".Z $1,$2", "RET\n"+name+".Z $1,$2")
+		} else {
+			for _, operands := range []string{" $0", " R0", " R0,R1", " $1,$2", " 0(SP)", ".Z"} {
+				invalid = append(invalid, name+operands, "RET\n"+name+operands)
+			}
+			inputs := wasmV128CoreInputs(name)
+			for count := 0; count < inputs; count++ {
+				invalid = append(invalid, strings.Repeat(vector, count)+name)
+			}
+			for index := 0; index < inputs; index++ {
+				for _, scalar := range []string{"I32Const $1\n", "I64Const $1\n", "F64Const $1.0\n", "Get SP\n"} {
+					invalid = append(invalid, strings.Repeat(vector, index)+scalar+strings.Repeat(vector, inputs-index-1)+name)
+				}
+			}
+		}
+		for index, body := range invalid {
+			t.Run(fmt.Sprintf("%s/invalid%d", name, index), func(t *testing.T) {
+				file, err := Parse(ArchWASM, "TEXT core(SB),4,$0-0\n"+body+"\nRET\n")
+				if err != nil {
+					return // Source parsing may reject an invalid operand first.
+				}
+				for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+					ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"core": {Name: "core", Ret: Void}}, WASMABIDirect), route)
+					if err == nil || ir != "" || errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("%s malformed or wrongly typed core operation was accepted/folded to Context: %v\n%s", route, err, body)
+					}
+				}
+			})
+		}
+		// A valid pure instruction after RET needs format validation, not a
+		// fictitious live stack input. It remains dead in the returned module.
+		t.Run(name+"/valid-dead", func(t *testing.T) {
+			file, err := Parse(ArchWASM, "TEXT core(SB),4,$0-0\nRET\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, route := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				if ir, err := wasmPackedTranslate(t, file, wasmPackedOptions(map[string]FuncSig{"core": {Name: "core", Ret: Void}}, WASMABIDirect), route); err != nil || ir == "" {
+					t.Fatalf("%s valid dead core format rejected: %v", route, err)
+				}
+			}
+		})
+	}
+}
+
+func TestWASMV128CoreTypedGoEntryObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	declarations.WriteString("package v128core\n")
+	for index, name := range wasmV128CoreNames() {
+		body := wasmV128CoreBody(name, [2]uint64{1, 2}, [2]uint64{3, 4}, [2]uint64{5, 6})
+		if name != "V128AnyTrue" {
+			body += "V128AnyTrue\n"
+		}
+		fmt.Fprintf(&declarations, "func core%d() uint32\n", index)
+		fmt.Fprintf(&source, "TEXT ·core%d(SB),4,$0-4\nGet SP\n%sI32Store ret+0(FP)\nRET\n", index, body)
+	}
+	pkg := mustGoPackage(t, "v128core", declarations.String())
+	context := llvm.NewContext()
+	defer context.Dispose()
+	translated, err := translateGoModuleInContext(context, pkg, []byte(source.String()), GoModuleOptions{
+		GOOS: "js", GOARCH: "wasm", TargetTriple: "wasm32-unknown-unknown", ResolveSym: testResolveSym("v128core"),
+	})
+	if translated != nil {
+		defer translated.Module.Dispose()
+	}
+	if err != nil || translated == nil {
+		t.Fatal("typed Go V128 core declaration/body rejected", err)
+	}
+	compileLLVMToObject(t, wasmDataTool(t, "llc"), "wasm32-unknown-unknown", "v128-core-go.ll", "v128-core-go.o", translated.Module.String())
+}
diff --git a/x86_32bit_test.go b/x86_32bit_test.go
index f067208e5..35c6d12e0 100644
--- a/x86_32bit_test.go
+++ b/x86_32bit_test.go
@@ -1,6 +1,8 @@
 package plan9asm
 
 import (
+	"errors"
+	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -34,15 +36,13 @@ func TestTranslate386SymbolIndexedMemory(t *testing.T) {
 		t.Fatal("symbol-indexed address with an empty symbol unexpectedly succeeded")
 	}
 
-	file, err := Parse(ArchAMD64, `
+	const source = `
 GLOBL masks<>(SB), RODATA, $256
 TEXT lookup(SB),NOSPLIT,$0-0
 	PAND masks<>(SB)(BX*8), X1
 	RET
-`)
-	if err != nil {
-		t.Fatal(err)
-	}
+`
+	file, signatures := x86UnboundVoidFormatSource(t, source, "lookup", "386", "i386-pc-windows-gnu")
 	src := file.Funcs[0].Instrs[1].Args[0]
 	if src.Kind != OpMem || src.Mem.Sym != "masks<>(SB)" || src.Mem.Index != BX || src.Mem.Scale != 8 {
 		t.Fatalf("parse symbol-indexed memory = %#v", src)
@@ -50,21 +50,17 @@ TEXT lookup(SB),NOSPLIT,$0-0
 	if got := src.String(); got != "masks<>(SB)(BX*8)" {
 		t.Fatalf("symbol-indexed memory string = %q", got)
 	}
-	ir, err := Translate(file, Options{
-		TargetTriple: "i386-pc-windows-gnu",
-		Goarch:       "386",
-		Sigs: map[string]FuncSig{
-			"lookup": {Name: "lookup", Ret: Void},
-		},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
+	ir := x86ScalarFormatObjectUnit(t, file, signatures, "386", "i386-pc-windows-gnu", 0)
 	if strings.Contains(ir, `masks<>(SB)(BX*8)`) ||
 		!strings.Contains(ir, "ptrtoint ptr @") ||
 		!strings.Contains(ir, "mul i64") {
 		t.Fatalf("symbol-indexed address was not lowered:\n%s", ir)
 	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	compileLLVMToObject(t, llc, "i386-pc-windows-gnu", "symbol-indexed.ll", "symbol-indexed.o", ir)
 }
 
 func TestParse386MMXRegister(t *testing.T) {
@@ -155,8 +151,6 @@ func TestTranslate386RejectsInvalidInstructionForms(t *testing.T) {
 		{name: "cld operand", instruction: "CLD AX", want: "CLD takes no operands"},
 		{name: "std operand", instruction: "STD AX", want: "STD takes no operands"},
 		{name: "rep operand", instruction: "REP AX", want: "REP takes no operands"},
-		{name: "repne movs", instruction: "REPN; MOVSB", want: "REPN is unsupported for MOVSB"},
-		{name: "rep scas", instruction: "REP; SCASB", want: "REP SCASB is not yet supported"},
 		{name: "movsb operand", instruction: "MOVSB AX", want: "MOVSB takes no operands"},
 		{name: "rdtsc operand", instruction: "RDTSC AX", want: "RDTSC takes no operands"},
 		{name: "rdtscp operand", instruction: "RDTSCP AX", want: "RDTSCP takes no operands"},
@@ -170,41 +164,38 @@ func TestTranslate386RejectsInvalidInstructionForms(t *testing.T) {
 		{name: "pushal operand", instruction: "PUSHAL AX", want: "PUSHAL takes no operands"},
 		{name: "popal operand", instruction: "POPAL AX", want: "POPAL takes no operands"},
 		{name: "unmodeled direct sp write", instruction: "XORL AX, SP", want: "direct SP write is unsupported"},
-		{name: "cmpxchg8b destination", instruction: "CMPXCHG8B AX", want: "CMPXCHG8B expects mem"},
-		{name: "cmpxchg8b segment", instruction: "CMPXCHG8B 0(FS)", want: "does not support segment-relative memory"},
 		{name: "fmovd count", instruction: "FMOVD F0", want: "FMOVD expects src, dst"},
-		{name: "fmovd destination", instruction: "FMOVD F0, AX", want: "unsupported x87 double destination"},
-		{name: "fmovdp count", instruction: "FMOVDP F0", want: "FMOVDP expects src, dst"},
-		{name: "fmovdp destination", instruction: "FMOVDP F0, AX", want: "unsupported x87 double destination"},
+		{name: "fmovd destination", instruction: "FMOVD F0, AX", want: "FMOVD expects memory,F0"},
+		{name: "fmovdp count", instruction: "FMOVDP F0", want: "FMOVDP expects F0 source"},
+		{name: "fmovdp destination", instruction: "FMOVDP F0, AX", want: "FMOVDP expects F0 source"},
 		{name: "fmovv count", instruction: "FMOVV AX", want: "FMOVV expects src, dst"},
-		{name: "fmovv destination", instruction: "FMOVV AX, F1", want: "FMOVV expects F0 destination"},
+		{name: "fmovv destination", instruction: "FMOVV AX, F1", want: "FMOVV expects signed integer memory,F0"},
 		{name: "fmovvp count", instruction: "FMOVVP F0", want: "FMOVVP expects src, dst"},
 		{name: "fmovvp source", instruction: "FMOVVP F1, 0(SP)", want: "FMOVVP expects F0 source"},
-		{name: "fmovvp destination", instruction: "FMOVVP F0, AX", want: "unsupported x87 integer destination"},
+		{name: "fmovvp destination", instruction: "FMOVVP F0, AX", want: "FMOVVP expects F0 source"},
 		{name: "fxchd count", instruction: "FXCHD F0", want: "FXCHD expects Fsrc, Fdst"},
 		{name: "fxchd registers", instruction: "FXCHD AX, BX", want: "FXCHD expects x87 registers"},
 		{name: "fdivd count", instruction: "FDIVD F0", want: "FDIVD expects src, dst"},
-		{name: "fdivd destination", instruction: "FDIVD F0, $1", want: "unsupported x87 double destination"},
+		{name: "fdivd destination", instruction: "FDIVD F0, $1", want: "FDIVD expects memory,F0"},
 		{name: "fadddp count", instruction: "FADDDP F0", want: "FADDDP expects src, dst"},
-		{name: "fadddp destination", instruction: "FADDDP F0, $1", want: "unsupported x87 double destination"},
-		{name: "fstcw count", instruction: "FSTCW", want: "FSTCW expects dst"},
-		{name: "fstcw destination", instruction: "FSTCW ret+0(FP)", want: "unsupported x87 word destination"},
-		{name: "fldcw count", instruction: "FLDCW", want: "FLDCW expects src"},
+		{name: "fadddp destination", instruction: "FADDDP F0, $1", want: "FADDDP expects F0 source"},
+		{name: "fstcw count", instruction: "FSTCW", want: "FSTCW expects memory destination"},
+		{name: "fstcw undeclared FP destination", instruction: "FSTCW ret+0(FP)", want: "unsupported FP write slot"},
+		{name: "fldcw count", instruction: "FLDCW", want: "FLDCW expects memory source"},
 		{name: "frndint operand", instruction: "FRNDINT AX", want: "FRNDINT takes no operands"},
 		{name: "fabs operand", instruction: "FABS AX", want: "FABS takes no operands"},
 		{name: "fucomi count", instruction: "FUCOMI F0", want: "FUCOMI expects lhs, rhs"},
 		{name: "ftst operand", instruction: "FTST AX", want: "FTST takes no operands"},
-		{name: "fstsw count", instruction: "FSTSW", want: "FSTSW expects dst"},
-		{name: "fstsw destination", instruction: "FSTSW ret+0(FP)", want: "unsupported x87 word destination"},
+		{name: "fstsw count", instruction: "FSTSW", want: "FSTSW expects memory destination"},
+		{name: "fstsw undeclared FP destination", instruction: "FSTSW ret+0(FP)", want: "unsupported FP write slot"},
 		{name: "fld1 operand", instruction: "FLD1 AX", want: "FLD1 takes no operands"},
-		{name: "x87 on amd64", instruction: "FLD1", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "pushl on amd64", instruction: "PUSHL AX", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "popl on amd64", instruction: "POPL AX", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "pushfl on amd64", instruction: "PUSHFL", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "popfl on amd64", instruction: "POPFL", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "pushal on amd64", instruction: "PUSHAL", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
 		{name: "popal on amd64", instruction: "POPAL", want: "requires GOARCH=386", goarch: "amd64", triple: "x86_64-unknown-linux-gnu"},
-		{name: "vector low destination", instruction: "MOVL X0, $1", want: "MOVL from X reg unsupported dst"},
+		{name: "vector low destination", instruction: "MOVL X0, $1", want: "386 MOVL outside complete Go GP/X transfer grammar"},
 	}
 
 	for _, tt := range tests {
@@ -234,7 +225,7 @@ func TestTranslate386RejectsInvalidInstructionForms(t *testing.T) {
 }
 
 func TestTranslate386ModelsOfficialDirectSPWrites(t *testing.T) {
-	file, err := Parse(ArchAMD64, `TEXT stack(SB),NOSPLIT,$0-0
+	const source = `TEXT stack(SB),NOSPLIT,$0-0
 	MOVL AX, SP
 	SUBL $256, SP
 	ADDL AX, SP
@@ -243,27 +234,36 @@ func TestTranslate386ModelsOfficialDirectSPWrites(t *testing.T) {
 	LEAL 4(SP), SP
 	POPL SP
 	RET
-`)
-	if err != nil {
-		t.Fatal(err)
-	}
-	ir, err := Translate(file, Options{
-		TargetTriple: "i386-unknown-linux-gnu",
-		Goarch:       "386",
-		Sigs:         map[string]FuncSig{"stack": {Name: "stack", Ret: Void}},
-	})
+`
+	file, err := Parse(ArchAMD64, source)
 	if err != nil {
 		t.Fatal(err)
 	}
-	for _, want := range []string{
-		"%local_stack = alloca [770 x i8]",
-		"sub i32",
-		"add i32",
-		"and i32",
-	} {
-		if !strings.Contains(ir, want) {
-			t.Fatalf("386 direct SP lowering missing %q:\n%s", want, ir)
-		}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86OriginalUnbalancedStackGoRejection(t, source, triple)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func stack()", "386", triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original unknown/unbalanced SP acquired a public frame", api, err)
+				}
+			}
+			ir := x86OriginalStackFormatObject(t, file.Funcs[0], Void, "386", triple)
+			for _, want := range []string{"%local_stack = alloca [770 x i8]", "sub i32", "add i32", "and i32"} {
+				if !strings.Contains(ir, want) {
+					t.Fatalf("386 direct SP format lowering missing %q:\n%s", want, ir)
+				}
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+		})
 	}
 }
 
@@ -316,9 +316,10 @@ func Test386LoweringEdgeCases(t *testing.T) {
 	reg := Operand{Kind: OpReg, Reg: AX}
 
 	for _, test := range []struct {
-		name string
-		op   Op
-		args []Operand
+		name  string
+		op    Op
+		args  []Operand
+		lower func(Op, Instr) (bool, bool, error)
 	}{
 		{name: "ADCL operand count", op: "ADCL"},
 		{name: "ADCL source", op: "ADCL", args: []Operand{ident, reg}},
@@ -329,7 +330,7 @@ func Test386LoweringEdgeCases(t *testing.T) {
 		{name: "ANDW operand count", op: "ANDW"},
 		{name: "ANDW source", op: "ANDW", args: []Operand{ident, reg}},
 		{name: "ANDW destination", op: "ANDW", args: []Operand{imm, ident}},
-		{name: "SETEQ destination", op: "SETEQ", args: []Operand{ident}},
+		{name: "SETEQ destination", op: "SETEQ", args: []Operand{ident}, lower: c.lowerConditionalSet},
 		{name: "IMULL source", op: "IMULL", args: []Operand{ident}},
 		{name: "IMULL destination", op: "IMULL", args: []Operand{imm, imm}},
 		{name: "IMULL two-operand source", op: "IMULL", args: []Operand{ident, reg}},
@@ -340,7 +341,11 @@ func Test386LoweringEdgeCases(t *testing.T) {
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			expectError(test.name, func() (bool, bool, error) {
-				return c.lowerArith(test.op, Instr{Raw: test.name, Args: test.args})
+				lower := c.lowerArith
+				if test.lower != nil {
+					lower = test.lower
+				}
+				return lower(test.op, Instr{Raw: test.name, Args: test.args})
 			})
 		})
 	}
@@ -414,16 +419,16 @@ func Test386LoweringErrorPaths(t *testing.T) {
 		return c.lowerArith("POPL", Instr{Raw: "POPL 0(BAD)", Args: []Operand{badMem}})
 	})
 	wantLowerError("SETEQ destination", func() (bool, bool, error) {
-		return c.lowerArith("SETEQ", Instr{Raw: "SETEQ 0(BAD)", Args: []Operand{badMem}})
+		return c.lowerConditionalSet("SETEQ", Instr{Raw: "SETEQ 0(BAD)", Args: []Operand{badMem}})
 	})
 	wantLowerError("CMPXCHG8B destination", func() (bool, bool, error) {
 		return c.lowerAtomic("CMPXCHG8B", Instr{Raw: "CMPXCHG8B 0(BAD)", Args: []Operand{badMem}})
 	})
 	wantLowerError("vector memory destination", func() (bool, bool, error) {
-		return c.lowerVec("MOVL", Instr{Raw: "MOVL X0, 0(BAD)", Args: []Operand{{Kind: OpReg, Reg: "X0"}, badMem}})
+		return c.lowerVectorScalarIntegerMove("MOVL", Instr{Op: "MOVL", Raw: "MOVL X0, 0(BAD)", Args: []Operand{{Kind: OpReg, Reg: "X0"}, badMem}})
 	})
 	wantLowerError("vector symbol destination", func() (bool, bool, error) {
-		return c.lowerVec("MOVL", Instr{Raw: "MOVL X0, (SB)", Args: []Operand{{Kind: OpReg, Reg: "X0"}, badSym}})
+		return c.lowerVectorScalarIntegerMove("MOVL", Instr{Op: "MOVL", Raw: "MOVL X0, (SB)", Args: []Operand{{Kind: OpReg, Reg: "X0"}, badSym}})
 	})
 
 	for _, test := range []struct {
@@ -484,10 +489,23 @@ func Test386LoweringErrorPaths(t *testing.T) {
 	if got, err := resultCtx.evalFPToI64(4); err != nil || got == "" {
 		t.Fatalf("high-word result read = (%q, %v)", got, err)
 	}
-	ok, terminated, err := resultCtx.lowerArith("LEAL", Instr{Raw: "LEAL ret+0(FP), AX", Args: []Operand{{Kind: OpFPAddr, FPOffset: 0}, {Kind: OpReg, Reg: AX}}})
+	// LEA takes the address of a memory operand. OpFPAddr represents
+	// $ret+0(FP), an immediate address that Go does not accept as its source.
+	lea, err := Parse(ArchAMD64, "TEXT resultAddress(SB),$0-8\n\tLEAL ret+0(FP), AX\n\tRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := lea.Funcs[0].Instrs[1]
+	if ins.Args[0].Kind != OpFP {
+		t.Fatalf("LEAL FP source kind = %v, want memory FP operand", ins.Args[0].Kind)
+	}
+	ok, terminated, err := resultCtx.lowerArith("LEAL", ins)
 	if !ok || terminated || err != nil {
 		t.Fatalf("LEAL classic result address = (%v, %v, %v)", ok, terminated, err)
 	}
+	wantLowerError("LEAL immediate FP source", func() (bool, bool, error) {
+		return resultCtx.lowerArith("LEAL", Instr{Raw: "LEAL $ret+0(FP), AX", Args: []Operand{{Kind: OpFPAddr, FPOffset: 0}, {Kind: OpReg, Reg: AX}}})
+	})
 }
 
 func Test386FDirectiveDoesNotAllocateX87State(t *testing.T) {
@@ -532,8 +550,10 @@ func TestAMD64Ignores386ControlInstructions(t *testing.T) {
 }
 
 func TestTranslate386DestinationForms(t *testing.T) {
-	file, err := Parse(ArchAMD64, `
+	const source = `
 TEXT vectorResult(SB),NOSPLIT,$0-4
+	MOVL $1, AX
+	MOVL AX, X0
 	MOVL X0, ret+0(FP)
 	RET
 
@@ -564,11 +584,16 @@ TEXT x87IntegerMemory(SB),NOSPLIT,$0-0
 TEXT x87IntegerSymbol(SB),NOSPLIT,$0-0
 	FMOVVP F0, integerSink(SB)
 	RET
-`)
+`
+	// The standalone assembler helper has no textflag.h include. Resolve only
+	// its standard NOSPLIT flag; every original instruction and operand stays
+	// unchanged in this independent Go-386 object check.
+	goAssemblerOracleOutput(t, "386", strings.ReplaceAll(source, ",NOSPLIT,", ",4,"), "", true)
+	file, err := Parse(ArchAMD64, source)
 	if err != nil {
 		t.Fatal(err)
 	}
-	ir, err := Translate(file, Options{
+	options := Options{
 		TargetTriple: "i386-unknown-linux-gnu",
 		Goarch:       "386",
 		Sigs: map[string]FuncSig{
@@ -584,25 +609,17 @@ TEXT x87IntegerSymbol(SB),NOSPLIT,$0-0
 			"x87IntegerMemory": {Name: "x87IntegerMemory", Ret: Void},
 			"x87IntegerSymbol": {Name: "x87IntegerSymbol", Ret: Void},
 		},
-	})
-	if err != nil {
-		t.Fatal(err)
 	}
-	for _, want := range []string{
-		"store i32 %",
-		"vectorSink",
-		"store double",
-		"doubleSink",
-		"store i16",
-		"controlSink",
-		"store i64",
-		"integerSink",
-	} {
-		if !strings.Contains(ir, want) {
-			t.Fatalf("386 destination-form IR missing %q:\n%s", want, ir)
-		}
+	if _, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original unbacked x87 source did not retain Context", err)
+	}
+	ir := x86CompileOnlyDestinationEmitterModule(t, file, options)
+	check386DestinationFormsIR(t, ir)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
 	}
-	compile386IR(t, ir, "destination_forms")
+	compileLLVMToObject(t, llc, "i386-unknown-linux-gnu", "destination_forms.ll", "destination_forms.o", ir)
 }
 
 func TestTranslate386ClassicAggregateFrame(t *testing.T) {
@@ -649,6 +666,14 @@ func TestTranslate386ClassicAggregateFrame(t *testing.T) {
 }
 
 func TestTranslate386InstructionFamilies(t *testing.T) {
+	// Go's 386 MMX-to-GP transfer is MOVL (the physical MOVD), not the
+	// MOVQ source family or its MOVD/MOVDQ2Q aliases. Check both actual
+	// encoder outcomes before using that transfer in the lowering fixture.
+	goAssemblerOracleOutput(t, "386", "TEXT ·valid(SB),4,$0-0\nMOVL M0,AX\nEMMS\nRET\n", "", true)
+	for _, opcode := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		goAssemblerOracleOutput(t, "386", "TEXT ·invalid(SB),4,$0-0\n"+opcode+" M0,AX\nEMMS\nRET\n", "", false)
+	}
+
 	src := `
 TEXT arith(SB),NOSPLIT,$0-12
 	MOVL a+0(FP), AX
@@ -723,7 +748,7 @@ TEXT atomic64(SB),NOSPLIT,$0-0
 
 TEXT mmxload(SB),NOSPLIT,$0-0
 	MOVQ (SI), M0
-	MOVQ M0, AX
+	MOVL M0, AX
 	EMMS
 	RET
 
@@ -777,7 +802,7 @@ TEXT undefined(SB),NOSPLIT,$0-0
 
 TEXT rawret(SB),NOSPLIT,$0-0
 	BYTE $0xc2
-	WORD $4
+	WORD $0
 	RET
 
 TEXT cpuidProbe(SB),NOSPLIT,$0-0
@@ -839,7 +864,7 @@ TEXT frameAddress(SB),NOSPLIT,$0-12
 			Name: "atomic64", Args: []LLVMType{Ptr, I32, I32, I32, I32}, Ret: I1,
 			ArgRegs: []Reg{SI, AX, DX, BX, CX},
 		},
-		"mmxload":   {Name: "mmxload", Args: []LLVMType{Ptr}, Ret: I64, ArgRegs: []Reg{SI}},
+		"mmxload":   {Name: "mmxload", Args: []LLVMType{Ptr}, Ret: I32, ArgRegs: []Reg{SI}},
 		"vectorlow": {Name: "vectorlow", Args: []LLVMType{Ptr}, Ret: I32, ArgRegs: []Reg{SI}},
 		"split64": {
 			Name: "split64", Args: []LLVMType{I64}, Ret: I64,
@@ -886,27 +911,108 @@ TEXT frameAddress(SB),NOSPLIT,$0-12
 	if err != nil {
 		t.Fatal(err)
 	}
-	ir, err := Translate(file, Options{
+	options := Options{
 		TargetTriple: "i386-unknown-linux-gnu",
 		ResolveSym: func(sym string) string {
 			return strings.TrimPrefix(sym, "·")
 		},
 		Goarch: "386",
 		Sigs:   sigs,
+	}
+	t.Run("complete-original-physical-stack-remains-Context", func(t *testing.T) {
+		ir, err := Translate(file, options)
+		if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "result initialization AUTO") {
+			t.Fatalf("original zero-frame physical-SP/PUSHAL source gained backing: output=%t error=%v", ir != "", err)
+		}
 	})
-	if err != nil {
-		t.Fatal(err)
+	// Keep the complete original file and declarations. This explicitly
+	// selected counterpart does not certify arith's unbound physical stack,
+	// PUSHAL/POPAL or live-stack memory addressing. Nothing may reference it.
+	if len(file.Funcs) != 19 || len(sigs) != 19 {
+		t.Fatal("complete instruction-family TEXT/declaration inventory changed")
+	}
+	for _, fn := range file.Funcs {
+		if fn.Sym == "arith" {
+			continue
+		}
+		for _, ins := range fn.Instrs {
+			if strings.Contains(ins.Raw, "arith") {
+				t.Fatal("partial selection cannot discard a referenced arithmetic TEXT", ins.Raw)
+			}
+		}
+	}
+	var ir string
+	boundedCounterpart := x86X87InstructionFamiliesBoundedCounterpart(t, src)
+	// The old symbolAddress had an external declaration and a bare AX result.
+	// Its separate positive counterpart explicitly supplies same-module DATA
+	// and a complete ABI0 result slot. Do not infer either from a MOV opcode.
+	const oldAddress = "TEXT symbolAddress(SB),NOSPLIT,$0-0\n\tMOVL $someGlobal(SB), AX\n\tRET"
+	const boundedAddress = "TEXT symbolAddress(SB),NOSPLIT,$0-4\n\tMOVL $someGlobal(SB), AX\n\tMOVL AX, ret+0(FP)\n\tRET"
+	if strings.Count(boundedCounterpart, oldAddress) != 1 {
+		t.Fatal("original address counterpart lost its complete source anchor")
+	}
+	boundedCounterpart = "DATA someGlobal(SB)/4,$0\nGLOBL someGlobal(SB),8,$4\n" +
+		strings.Replace(boundedCounterpart, oldAddress, boundedAddress, 1)
+	boundedCounterpart = x86Legacy386StackCounterparts(t, boundedCounterpart)
+	boundedSigs := make(map[string]FuncSig, len(sigs))
+	for name, sig := range sigs {
+		boundedSigs[name] = sig
+	}
+	boundedCounterpart = x86Legacy386RegisterCounterparts(t, boundedCounterpart, boundedSigs)
+	addressSig := boundedSigs["symbolAddress"]
+	addressSig.Frame.Results = []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}
+	boundedSigs["symbolAddress"] = addressSig
+	boundedSigs["stackAdjust"] = FuncSig{
+		Name: "stackAdjust", Args: []LLVMType{I32}, Ret: I32,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+		},
+	}
+	boundedSigs["cpuidProbe"] = FuncSig{
+		Name: "cpuidProbe", Ret: I32,
+		Frame: FrameLayout{
+			Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+		},
+	}
+	t.Run("partial-selection-bounded-counterpart-other-18-TEXTs", func(t *testing.T) {
+		// KeepFunc belongs to the Go-module API. The empty package grants no
+		// Go declaration; every selected signature is exactly the original
+		// explicit manual contract, including custom register assignments,
+		// except the separately documented bounded scratch, DATA and stack
+		// counterparts. Those complete programs explicitly initialize their
+		// inputs and ABI0 outputs; they do not certify the original physical
+		// stack programs. arith and all other selected TEXTs stay intact.
+		pkg := mustGoPackage(t, "families", "package families")
+		result, err := TranslateGoModule(pkg, []byte(boundedCounterpart), GoModuleOptions{
+			GOOS: "linux", GOARCH: "386", TargetTriple: options.TargetTriple,
+			ResolveSym: options.ResolveSym,
+			KeepFunc:   func(text, resolved string) bool { return text != "arith" && resolved != "arith" },
+			ManualSig:  func(resolved string) (FuncSig, bool) { sig, found := boundedSigs[resolved]; return sig, found },
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer result.Module.Dispose()
+		if len(result.Functions) != 18 || len(result.Signatures) != 18 {
+			t.Fatal("partial selection changed the remaining TEXT/signature inventory")
+		}
+		ir = result.Module.String()
+	})
+	if ir == "" {
+		t.Fatal("partial selection did not emit its separate module")
 	}
 	for _, want := range []string{
-		"cmpxchg ptr",
+		`asm sideeffect "lock; cmpxchg8b`,
 		"@__plan9asm_rep_stosl",
-		"@__plan9asm_repne_scasb",
+		"@__plan9asm_rep_scasb",
 		"@__plan9asm_movsb",
 		"@__plan9asm_movsl",
 		`asm sideeffect "fnstcw $0"`,
 		`asm sideeffect "fldcw $0"`,
 		`asm sideeffect "fldl $1; frndint; fstpl $0"`,
-		`asm sideeffect "fldl $1; fistpll $0"`,
+		`asm sideeffect "cmpb $$0, $3; je 1f; fildll $2;`,
+		`1: fldl $1; 2: fistpll $0`,
 		"@llvm.sqrt.f64",
 		"%x87_control = alloca i16",
 		"%local_stack = alloca",
@@ -918,17 +1024,461 @@ TEXT frameAddress(SB),NOSPLIT,$0-12
 		"%flags_id = alloca i1",
 		"%classic_frame = alloca",
 		"ptrtoint ptr @someGlobal to i64",
-		"sub i64 %",
-		", 156",
 	} {
 		if !strings.Contains(ir, want) {
 			t.Fatalf("386 IR missing %q:\n%s", want, ir)
 		}
 	}
-	if strings.Contains(ir, "roundeven") {
+	if strings.Contains(ir, "call double @llvm.roundeven") || strings.Contains(ir, "call float @llvm.roundeven") {
 		t.Fatalf("386 x87 lowering unexpectedly depends on external roundeven:\n%s", ir)
 	}
 	compile386IR(t, ir, "instruction_families")
+	// ADJSP belongs to the original physical-stack format. Keep its complete
+	// emitter-only object separate from the public initialized counterpart.
+	formatIR := x86Legacy386StackFormatObject(t, options.TargetTriple)
+	for _, want := range []string{"sub i64 %", ", 156"} {
+		if !strings.Contains(formatIR, want) {
+			t.Fatalf("original 386 stack format IR missing %q", want)
+		}
+	}
+	compile386IR(t, formatIR, "original_stack_formats")
+	t.Run("independent-bounded-named-AUTO-product", func(t *testing.T) {
+		const bounded = "TEXT ·Bounded(SB),4,$16-12\nMOVL a+0(FP),AX\nMOVL b+4(FP),BX\nIMULL BX\nMOVL AX,spill-8(SP)\nMOVL spill-8(SP),AX\nMOVL AX,ret+8(FP)\nRET\n"
+		const declaration = "func Bounded(a,b uint32) uint32"
+		x86LEAActualTargetGoObject(t, "386", options.TargetTriple, bounded)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, bounded, declaration, "386", options.TargetTriple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ScalarFPNamedConstantResult(t, ir+"define i32 @Probe() { %r = call i32 @Bounded(i32 2,i32 3)\n ret i32 %r }\n", "Probe", []uint64{6})
+				compile386IR(t, ir, "bounded_product_"+api)
+				for name, invalid := range map[string]string{
+					"unknown-input":  strings.Replace(bounded, "MOVL b+4(FP),BX", "NOP", 1),
+					"unwritten-AUTO": strings.Replace(bounded, "MOVL AX,spill-8(SP)", "NOP", 1),
+					"physical-SP":    strings.ReplaceAll(bounded, "spill-8(SP)", "-8(SP)"),
+					"missing-frame":  strings.Replace(bounded, "$16-12", "$0-12", 1),
+					"past-frame":     strings.ReplaceAll(bounded, "spill-8(SP)", "spill-20(SP)"),
+				} {
+					t.Run(name, func(t *testing.T) {
+						output, err := x86ScalarFPBitViewAPI(t, invalid, declaration, "386", options.TargetTriple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || output != "" {
+							t.Fatal("bounded counterpart borrowed initialization or native backing", err)
+						}
+					})
+				}
+			})
+		}
+	})
+}
+
+func TestTranslate386X87MoveFamilyCompleteForms(t *testing.T) {
+	const source = `
+TEXT x87moves(SB),NOSPLIT,$0-0
+	FMOVB 0(SI), F0
+	FMOVBP F0, 0(DI)
+	FMOVD 0(SI), F0
+	FMOVD $(2.928932188134524e-01), F0
+	FMOVD F0, 0(DI)
+	FMOVD F1, F0
+	FMOVD F0, F1
+	FMOVDP F0, 0(DI)
+	FMOVDP F0, F1
+	FMOVF 0(SI), F0
+	FMOVF F0, 0(DI)
+	FMOVFP F0, 0(DI)
+	FMOVL 0(SI), F0
+	FMOVL F0, 0(DI)
+	FMOVLP F0, 0(DI)
+	FMOVV 0(SI), F0
+	FMOVVP F0, 0(DI)
+	FMOVW 0(SI), F0
+	FMOVW F0, 0(DI)
+	FMOVWP F0, 0(DI)
+	FMOVX 0(SI), F0
+	FMOVXP F0, 0(DI)
+	RET
+`
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"x87moves": {Name: "x87moves", Ret: Void}},
+		X87Mode:      X87Software,
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "FMOVB 0(SI), F0") {
+		t.Fatal("complete no-argument move source acquired SI/DI storage or initialized x87 inputs", err)
+	}
+	compile386IR(t, x86X87LowererObjectUnit(t, file, "386", "i386-unknown-linux-gnu"), "x87_move_family_emitter_only")
+}
+
+func TestTranslate386X87MoveFamilyRejectsNonGoForms(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		want        string
+	}{
+		{instruction: "FMOVF F1, F0", want: "FMOVF expects memory,F0, Freg,F0, F0,memory, or F0,Freg"},
+		{instruction: "FMOVFP F1, 0(DI)", want: "FMOVFP expects F0 source and memory or x87-register destination"},
+		{instruction: "FMOVL 0(SI), F1", want: "FMOVL expects signed integer memory,F0 or the registered F0,memory store row"},
+		{instruction: "FMOVLP F0, F1", want: "FMOVLP expects F0 source and signed integer memory destination"},
+		{instruction: "FMOVX F0, F1", want: "FMOVX expects memory source and F0 destination"},
+		{instruction: "FMOVXP F1, 0(DI)", want: "FMOVXP expects F0 source and memory destination"},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			source := "TEXT bad(SB),NOSPLIT,$0-0\n" + test.instruction + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			})
+			if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("Translate(%q) error = %v, want %q", test.instruction, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslate386X87ConstantUnaryAndTranscendentalFamily(t *testing.T) {
+	const source = `
+TEXT x87transcendental(SB),NOSPLIT,$0-0
+	FBLD 0(SI)
+	FBSTP 0(DI)
+	FLD1
+	FLDL2E
+	FLDL2T
+	FLDLG2
+	FLDLN2
+	FLDPI
+	FLDZ
+	F2XM1
+	FABS
+	FCHS
+	FCLEX
+	FCOS
+	FDECSTP
+	FINCSTP
+	FINIT
+	FNOP
+	FPATAN
+	FPREM
+	FPREM1
+	FPTAN
+	FRNDINT
+	FSCALE
+	FSIN
+	FSINCOS
+	FSQRT
+	FTST
+	FXAM
+	FXTRACT
+	FYL2X
+	FYL2XP1
+	RET
+`
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"x87transcendental": {Name: "x87transcendental", Ret: Void}},
+		X87Mode:      X87Software,
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "FBLD 0(SI)") {
+		t.Fatal("complete no-argument transcendental source acquired SI/DI storage or initialized x87 inputs", err)
+	}
+	compile386IR(t, x86X87LowererObjectUnit(t, file, "386", "i386-unknown-linux-gnu"), "x87_transcendental_emitter_only")
+}
+
+func TestTranslate386X87ConstantUnaryAndTranscendentalFamilyRejectsOperands(t *testing.T) {
+	for _, op := range []string{
+		"F2XM1", "FABS", "FCHS", "FCLEX", "FCOS", "FDECSTP", "FINCSTP", "FINIT",
+		"FLD1", "FLDL2E", "FLDL2T", "FLDLG2", "FLDLN2", "FLDPI", "FLDZ", "FNOP",
+		"FPATAN", "FPREM", "FPREM1", "FPTAN", "FRNDINT", "FSCALE", "FSIN", "FSINCOS",
+		"FSQRT", "FTST", "FXAM", "FXTRACT", "FYL2X", "FYL2XP1",
+	} {
+		t.Run(op, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n"+op+" AX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			})
+			if err == nil || !strings.Contains(err.Error(), "takes no operands") {
+				t.Fatalf("Translate(%s AX) error = %v, want no-operand rejection", op, err)
+			}
+		})
+	}
+	for _, test := range []struct {
+		instruction string
+		want        string
+	}{
+		{instruction: "FBLD F0", want: "FBLD expects memory source"},
+		{instruction: "FBSTP AX", want: "FBSTP expects memory destination"},
+	} {
+		file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n"+test.instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(file, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+		if err == nil || !strings.Contains(err.Error(), test.want) {
+			t.Fatalf("Translate(%q) error = %v, want %q", test.instruction, err, test.want)
+		}
+	}
+}
+
+func TestTranslate386X87ArithmeticFamilyCompleteForms(t *testing.T) {
+	var src strings.Builder
+	src.WriteString("TEXT x87arithmetic(SB),NOSPLIT,$0-0\n")
+	for _, stem := range []string{"FADD", "FMUL", "FSUB", "FSUBR", "FDIV", "FDIVR"} {
+		for _, width := range []string{"W", "L", "F"} {
+			fmt.Fprintf(&src, "\t%s%s 0(SI), F0\n", stem, width)
+		}
+		fmt.Fprintf(&src, "\t%sD 0(SI), F0\n", stem)
+		fmt.Fprintf(&src, "\t%sD F1, F0\n", stem)
+		fmt.Fprintf(&src, "\t%sD F0, F1\n", stem)
+		fmt.Fprintf(&src, "\t%sDP F0, F1\n", stem)
+	}
+	src.WriteString("\tRET\n")
+	file, err := Parse(ArchAMD64, src.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"x87arithmetic": {Name: "x87arithmetic", Ret: Void}},
+		X87Mode:      X87Software,
+	})
+	if err != nil {
+		t.Fatalf("Translate(complete x87 arithmetic family) error = %v", err)
+	}
+	compile386IR(t, ir, "x87_arithmetic_family")
+}
+
+func TestTranslate386X87ArithmeticFamilyRejectsNonGoForms(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		want        string
+	}{
+		{instruction: "FADDW F1, F0", want: "FADDW expects memory source and F0 destination"},
+		{instruction: "FMULL 0(SI), F1", want: "FMULL expects memory source and F0 destination"},
+		{instruction: "FSUBF F0, 0(DI)", want: "FSUBF expects memory source and F0 destination"},
+		{instruction: "FDIVD 0(SI), F1", want: "FDIVD expects memory,F0"},
+		{instruction: "FSUBRDP 0(SI), F0", want: "FSUBRDP expects F0 source and x87-register destination"},
+		{instruction: "FDIVRDP F1, F0", want: "FDIVRDP expects F0 source and x87-register destination"},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			})
+			if err == nil || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("Translate(%q) error = %v, want %q", test.instruction, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslate386X87CompareFamilyCompleteForms(t *testing.T) {
+	file, err := Parse(ArchAMD64, `
+TEXT x87compare(SB),NOSPLIT,$0-0
+	FCOMD 0(SI), F0
+	FCOMD F1, F0
+	FCOMD F0, F1
+	FCOMDP 0(SI), F0
+	FCOMDP F1, F0
+	FCOMDP F0, F1
+	FCOMDPP F0, F1
+	FCOMF 0(SI), F0
+	FCOMFP 0(SI), F0
+	FCOML 0(SI), F0
+	FCOMLP 0(SI), F0
+	FCOMW 0(SI), F0
+	FCOMWP 0(SI), F0
+	FCOMI F1, F0
+	FCOMIP F1, F0
+	FUCOM F0, F1
+	FUCOMP F0, F1
+	FUCOMPP F0, F1
+	FUCOMI F0, F1
+	FUCOMIP F0, F1
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"x87compare": {Name: "x87compare", Ret: Void}},
+		X87Mode:      X87Software,
+	})
+	if err != nil {
+		t.Fatalf("Translate(complete x87 compare family) error = %v", err)
+	}
+	compile386IR(t, ir, "x87_compare_family")
+}
+
+func TestTranslate386X87CompareFamilyRejectsNonGoForms(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		want        string
+	}{
+		{instruction: "FCOMF F1, F0", want: "FCOMF expects memory source or x87-register source and F0 destination"},
+		{instruction: "FCOMD 0(SI), F1", want: "FCOMD expects memory source or x87-register source and F0 destination"},
+		{instruction: "FCOMDPP F1, F0", want: "FCOMDPP expects F0 source and x87-register destination"},
+		{instruction: "FCOMI F0, F1", want: "FCOMI expects x87-register source and F0 destination"},
+		{instruction: "FUCOM F1, F0", want: "FUCOM expects F0 source and x87-register destination"},
+		{instruction: "FUCOMIP 0(SI), F0", want: "FUCOMIP expects F0 source and x87-register destination"},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			source := "TEXT bad(SB),NOSPLIT,$0-0\n" + test.instruction + "\nRET\n"
+			goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", false)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			})
+			if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("Translate(%q) error = %v, want %q", test.instruction, err, test.want)
+			}
+		})
+	}
+}
+
+func TestTranslate386LAHFSAHFFamily(t *testing.T) {
+	const source = `
+TEXT flags386(SB),NOSPLIT,$0-0
+	LAHF
+	SAHF
+	RET
+`
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"flags386": {Name: "flags386", Ret: Void}},
+	}
+	if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original uninitialized FLAGS format invented input facts", err)
+	}
+	initialized := strings.Replace(source, "\tLAHF", "\tMOVL $0,AX\n\tCMPL AX,AX\n\tLAHF", 1)
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+initialized, "", true)
+	file, err = Parse(ArchAMD64, initialized)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatalf("Translate(LAHF/SAHF) error = %v", err)
+	}
+	compile386IR(t, ir, "lahf_sahf_family")
+	for _, op := range []string{"LAHF", "SAHF"} {
+		bad, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n"+op+" AX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, err = Translate(bad, Options{
+			TargetTriple: "i386-unknown-linux-gnu",
+			Goarch:       "386",
+			Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+		})
+		if err == nil || !strings.Contains(err.Error(), "takes no operands") {
+			t.Fatalf("Translate(%s AX) error = %v, want no-operand rejection", op, err)
+		}
+	}
+}
+
+func TestTranslate386X87EnvironmentAndControlFamily(t *testing.T) {
+	file, err := Parse(ArchAMD64, `
+TEXT x87environment(SB),NOSPLIT,$0-0
+	FLDCW 0(SI)
+	FLDENV 0(SI)
+	FRSTOR 0(SI)
+	FSAVE 0(DI)
+	FSTCW 0(DI)
+	FSTENV 0(DI)
+	FSTSW 0(DI)
+	FSTSW AX
+	RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{
+		TargetTriple: "i386-unknown-linux-gnu",
+		Goarch:       "386",
+		Sigs:         map[string]FuncSig{"x87environment": {Name: "x87environment", Ret: Void}},
+		X87Mode:      X87Software,
+	})
+	if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "FLDCW 0(SI)") {
+		t.Fatalf("complete no-argument ENV source acquired native SI/DI storage: output=%t error=%v", ir != "", err)
+	}
+	// Typed syntax/object witnesses are independent of the original source's
+	// missing incoming pointers, restore image and native write contracts.
+}
+
+func TestTranslate386X87EnvironmentAndControlFamilyRejectsNonGoForms(t *testing.T) {
+	for _, test := range []struct {
+		instruction string
+		want        string
+	}{
+		{instruction: "FLDCW AX", want: "FLDCW expects memory source"},
+		{instruction: "FLDENV F0", want: "FLDENV expects memory source"},
+		{instruction: "FRSTOR AX", want: "FRSTOR expects memory source"},
+		{instruction: "FSAVE AX", want: "FSAVE expects memory destination"},
+		{instruction: "FSTCW AX", want: "FSTCW expects memory destination"},
+		{instruction: "FSTENV F0", want: "FSTENV expects memory destination"},
+		{instruction: "FSTSW BX", want: "FSTSW expects memory destination or AX"},
+	} {
+		t.Run(test.instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT bad(SB),NOSPLIT,$0-0\n"+test.instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, err = Translate(file, Options{
+				TargetTriple: "i386-unknown-linux-gnu",
+				Goarch:       "386",
+				Sigs:         map[string]FuncSig{"bad": {Name: "bad", Ret: Void}},
+			})
+			if err == nil || !strings.Contains(err.Error(), test.want) {
+				t.Fatalf("Translate(%q) error = %v, want %q", test.instruction, err, test.want)
+			}
+		})
+	}
 }
 
 func TestTranslate386X87Modes(t *testing.T) {
@@ -937,7 +1487,8 @@ func TestTranslate386X87Modes(t *testing.T) {
 		`asm sideeffect "fnstcw $0"`,
 		`asm sideeffect "fldcw $0"`,
 		`asm sideeffect "fldl $1; frndint; fstpl $0"`,
-		`asm sideeffect "fldl $1; fistpll $0"`,
+		`asm sideeffect "cmpb $$0, $3; je 1f; fildll $2;`,
+		`1: fldl $1; 2: fistpll $0`,
 	} {
 		if !strings.Contains(hardware, want) {
 			t.Fatalf("hardware x87 IR missing %q:\n%s", want, hardware)
@@ -986,7 +1537,7 @@ func TestTranslate386X87Modes(t *testing.T) {
 func TestTranslate386X87Codegen(t *testing.T) {
 	llc := findLLVM22Tool("llc")
 	if llc == "" {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 	ir := translate386RoundingIR(t, X87Hardware)
 	dir := t.TempDir()
@@ -1013,7 +1564,7 @@ func TestTranslate386X87Codegen(t *testing.T) {
 			args = append(args, "-filetype=asm", llPath, "-o", asmPath)
 			if output, err := exec.Command(llc, args...).CombinedOutput(); err != nil {
 				if unsupported386Target(string(output)) {
-					t.Skipf("llc lacks 386 target: %s", output)
+					t.Fatalf("llc lacks 386 target: %s", output)
 				}
 				t.Fatalf("llc failed: %v\n%s", err, output)
 			}
@@ -1080,14 +1631,7 @@ func TestTranslate386X87Codegen(t *testing.T) {
 
 func translate386RoundingIR(t *testing.T, mode X87Mode) string {
 	t.Helper()
-	file, err := Parse(ArchAMD64, `TEXT round(SB),NOSPLIT,$0-16
-	FMOVD value+0(FP), F0
-	FSTCW -2(SP)
-	FLDCW -2(SP)
-	FRNDINT
-	FMOVVP F0, ret+8(FP)
-	RET
-`)
+	file, err := Parse(ArchAMD64, x86X87LegacyBoundedRoundingSource(mode))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1185,7 +1729,7 @@ func compile386IR(t *testing.T, ir, name string) {
 	t.Helper()
 	llc := findLLVM22Tool("llc")
 	if llc == "" {
-		t.Skip("llc not found")
+		t.Fatal("llc not found")
 	}
 	tmp := t.TempDir()
 	llPath := filepath.Join(tmp, name+".ll")
@@ -1196,7 +1740,7 @@ func compile386IR(t *testing.T, ir, name string) {
 	cmd := exec.Command(llc, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", llPath, "-o", objPath)
 	if out, err := cmd.CombinedOutput(); err != nil {
 		if unsupported386Target(string(out)) {
-			t.Skipf("llc does not support i386: %s", strings.TrimSpace(string(out)))
+			t.Fatalf("llc does not support i386: %s", strings.TrimSpace(string(out)))
 		}
 		t.Fatalf("llc failed: %v\n%s", err, out)
 	}
@@ -1209,246 +1753,15 @@ func TestRuntimeExec386Core(t *testing.T) {
 	llc := findLLVM22Tool("llc")
 	clang := findLLVM22Tool("clang")
 	if llc == "" || clang == "" {
-		t.Skip("llc/clang not found")
+		t.Fatal("llc/clang not found")
 	}
-	file, err := Parse(ArchAMD64, `
-TEXT addCarry(SB),NOSPLIT,$0-12
-	MOVL a+0(FP), AX
-	MOVL b+4(FP), BX
-	CMPL AX, $0
-	ADCL BX, AX
-	MOVL AX, ret+8(FP)
-	RET
-
-TEXT cpuidProbe(SB),NOSPLIT,$0-0
-	PUSHFL
-	PUSHFL
-	XORL $0x200000, 0(SP)
-	POPFL
-	PUSHFL
-	POPL AX
-	XORL 0(SP), AX
-	POPFL
-	TESTL $0x200000, AX
-	JNE cpuidAvailable
-	MOVL $0, AX
-	RET
-cpuidAvailable:
-	MOVL $1, AX
-	RET
-
-TEXT frameAddress(SB),NOSPLIT,$0-12
-	LEAL a+0(FP), SI
-	MOVL $41, 4(SI)
-	MOVL b+4(FP), AX
-	MOVL AX, ret+8(FP)
-	RET
-
-TEXT copyForward(SB),NOSPLIT,$0-12
-	MOVL dst+0(FP), DI
-	MOVL src+4(FP), SI
-	MOVL n+8(FP), CX
-	CLD
-	REP; MOVSB
-	RET
-
-TEXT copyBackward(SB),NOSPLIT,$0-12
-	MOVL dst+0(FP), DI
-	MOVL src+4(FP), SI
-	MOVL n+8(FP), CX
-	ADDL CX, DI
-	ADDL CX, SI
-	DECL DI
-	DECL SI
-	STD
-	REP; MOVSB
-	CLD
-	RET
-
-TEXT copyBackwardRestoredDF(SB),NOSPLIT,$0-12
-	MOVL dst+0(FP), DI
-	MOVL src+4(FP), SI
-	MOVL n+8(FP), CX
-	ADDL CX, DI
-	ADDL CX, SI
-	DECL DI
-	DECL SI
-	STD
-	PUSHFL
-	CLD
-	POPFL
-	REP; MOVSB
-	CLD
-	RET
-
-TEXT fillWords(SB),NOSPLIT,$0-12
-	MOVL dst+0(FP), DI
-	MOVL value+4(FP), AX
-	MOVL n+8(FP), CX
-	CLD
-	REP; STOSL
-	RET
-
-TEXT findByte(SB),NOSPLIT,$0-16
-	MOVL data+0(FP), DI
-	MOVL n+4(FP), CX
-	MOVL value+8(FP), AX
-	CLD
-	REPN; SCASB
-	MOVL CX, ret+12(FP)
-	RET
-
-TEXT zeroLengthScanPreservesZF(SB),NOSPLIT,$0-8
-	MOVL data+0(FP), DI
-	MOVL $0, CX
-	CMPL AX, AX
-	REPN; SCASB
-	JNE zfLost
-	MOVL $1, AX
-	MOVL AX, ret+4(FP)
-	RET
-zfLost:
-	MOVL $0, AX
-	MOVL AX, ret+4(FP)
-	RET
-
-TEXT negateHasCarry(SB),NOSPLIT,$0-8
-	MOVL value+0(FP), AX
-	NEGL AX
-	SETCS BX
-	MOVL BX, ret+4(FP)
-	RET
-
-TEXT floorValue(SB),NOSPLIT,$0-16
-	FMOVD value+0(FP), F0
-	FSTCW -2(SP)
-	MOVW -2(SP), AX
-	ANDW $0xf3ff, AX
-	ORW $0x0400, AX
-	MOVW AX, -4(SP)
-	FLDCW -4(SP)
-	FRNDINT
-	FLDCW -2(SP)
-	FMOVDP F0, ret+8(FP)
-	RET
-
-TEXT uint32ToFloat64(SB),NOSPLIT,$0-12
-	MOVL value+0(FP), AX
-	MOVL AX, 0(SP)
-	MOVL $0, 4(SP)
-	FMOVV 0(SP), F0
-	FMOVDP F0, ret+4(FP)
-	RET
-
-TEXT cas64(SB),NOSPLIT,$0-0
-	LOCK
-	CMPXCHG8B (SI)
-	SETEQ AX
-	RET
-
-TEXT xadd32(SB),NOSPLIT,$0-12
-	MOVL ptr+0(FP), BX
-	MOVL delta+4(FP), AX
-	MOVL AX, CX
-	LOCK
-	XADDL AX, 0(BX)
-	ADDL CX, AX
-	MOVL AX, ret+8(FP)
-	RET
-
-TEXT identity64(SB),NOSPLIT,$0-16
-	MOVL value_lo+0(FP), AX
-	MOVL AX, ret_lo+8(FP)
-	MOVL value_hi+4(FP), AX
-	MOVL AX, ret_hi+12(FP)
-	RET
-
-TEXT identityFloat64(SB),NOSPLIT,$0-16
-	MOVL value_lo+0(FP), AX
-	MOVL AX, ret_lo+8(FP)
-	MOVL value_hi+4(FP), AX
-	MOVL AX, ret_hi+12(FP)
-	RET
-
-TEXT readFS(SB),NOSPLIT,$0-4
-	MOVL 0x18(FS), AX
-	MOVL AX, ret+0(FP)
-	RET
-
-TEXT roundNearest(SB),NOSPLIT,$0-16
-	FMOVD value+0(FP), F0
-	FRNDINT
-	FMOVDP F0, ret+8(FP)
-	RET
-`)
+	// Keep all eighteen original operations and manual register transports.
+	// Only the separately verified counterpart supplies real local x87 scratch.
+	file, err := Parse(ArchAMD64, runtime386BoundedScratchAssembly(t))
 	if err != nil {
 		t.Fatal(err)
 	}
-	sig := FuncSig{
-		Name: "addCarry", Args: []LLVMType{I32, I32}, Ret: I32,
-		Frame: FrameLayout{
-			Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
-			Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}},
-		},
-	}
-	frameSig := func(name string, args []LLVMType, ret LLVMType, params, results []FrameSlot) FuncSig {
-		return FuncSig{
-			Name: name, Args: args, Ret: ret,
-			Frame: FrameLayout{Params: params, Results: results},
-		}
-	}
-	ir, err := Translate(file, Options{
-		TargetTriple: "i686-pc-windows-msvc",
-		Goarch:       "386",
-		Sigs: map[string]FuncSig{
-			"addCarry":   sig,
-			"cpuidProbe": {Name: "cpuidProbe", Ret: I32},
-			"frameAddress": frameSig("frameAddress", []LLVMType{I32, I32}, I32,
-				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}),
-			"copyForward": frameSig("copyForward", []LLVMType{Ptr, Ptr, I32}, Void,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
-			"copyBackward": frameSig("copyBackward", []LLVMType{Ptr, Ptr, I32}, Void,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
-			"copyBackwardRestoredDF": frameSig("copyBackwardRestoredDF", []LLVMType{Ptr, Ptr, I32}, Void,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
-			"fillWords": frameSig("fillWords", []LLVMType{Ptr, I32, I32}, Void,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
-			"findByte": frameSig("findByte", []LLVMType{Ptr, I32, I32}, I32,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}},
-				[]FrameSlot{{Offset: 12, Type: I32, Index: 0, Field: -1}}),
-			"zeroLengthScanPreservesZF": frameSig("zeroLengthScanPreservesZF", []LLVMType{Ptr}, I32,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}}),
-			"negateHasCarry": frameSig("negateHasCarry", []LLVMType{I32}, I32,
-				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}}),
-			"floorValue": frameSig("floorValue", []LLVMType{LLVMType("double")}, LLVMType("double"),
-				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
-			"uint32ToFloat64": frameSig("uint32ToFloat64", []LLVMType{I32}, LLVMType("double"),
-				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 4, Type: LLVMType("double"), Index: 0, Field: -1}}),
-			"cas64": {
-				Name: "cas64", Args: []LLVMType{Ptr, I32, I32, I32, I32}, Ret: I1,
-				ArgRegs: []Reg{SI, AX, DX, BX, CX},
-			},
-			"xadd32": frameSig("xadd32", []LLVMType{Ptr, I32}, I32,
-				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}),
-			"identity64": frameSig("identity64", []LLVMType{I64}, I64,
-				[]FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}}),
-			"identityFloat64": frameSig("identityFloat64", []LLVMType{LLVMType("double")}, LLVMType("double"),
-				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
-			"readFS": frameSig("readFS", nil, I32, nil,
-				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}),
-			"roundNearest": frameSig("roundNearest", []LLVMType{LLVMType("double")}, LLVMType("double"),
-				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
-				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
-		},
-	})
+	ir, err := Translate(file, runtime386CoreOptions())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1460,72 +1773,7 @@ TEXT roundNearest(SB),NOSPLIT,$0-16
 	if err := os.WriteFile(llPath, []byte(ir), 0o644); err != nil {
 		t.Fatal(err)
 	}
-	const cSource = `
-int _fltused;
-extern int addCarry(int, int);
-extern int cpuidProbe(void);
-extern int frameAddress(int, int);
-extern void copyForward(unsigned char *, const unsigned char *, unsigned int);
-extern void copyBackward(unsigned char *, const unsigned char *, unsigned int);
-extern void copyBackwardRestoredDF(unsigned char *, const unsigned char *, unsigned int);
-extern void fillWords(unsigned int *, unsigned int, unsigned int);
-extern unsigned int findByte(const unsigned char *, unsigned int, unsigned int);
-extern unsigned int zeroLengthScanPreservesZF(const unsigned char *);
-extern unsigned int negateHasCarry(unsigned int);
-extern double floorValue(double);
-extern double uint32ToFloat64(unsigned int);
-extern _Bool cas64(unsigned long long *, unsigned int, unsigned int, unsigned int, unsigned int);
-extern unsigned int xadd32(unsigned int *, unsigned int);
-extern unsigned long long identity64(unsigned long long);
-extern double identityFloat64(double);
-extern unsigned int readFS(void);
-extern double roundNearest(double);
-int main(void) {
-    unsigned int i;
-    const unsigned char source[8] = {1, 2, 3, 4, 5, 6, 7, 8};
-    unsigned char copied[8] = {0};
-    unsigned char overlap[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
-    unsigned char restoredOverlap[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
-    unsigned char forwardOverlap[5] = {1, 2, 3, 4, 5};
-    unsigned int words[4] = {0};
-    __declspec(align(8)) unsigned long long word = 0x1122334455667788ULL;
-    unsigned int atomicWord = 10;
-    if (addCarry(20, 22) != 42) return 11;
-    if (cpuidProbe() != 1) return 12;
-    if (frameAddress(20, 22) != 41) return 13;
-    copyForward(copied, source, 8);
-    for (i = 0; i < 8; i++) if (copied[i] != source[i]) return 14;
-    copyBackward(overlap + 1, overlap, 8);
-    for (i = 0; i < 8; i++) if (overlap[i + 1] != i) return 15;
-    copyBackwardRestoredDF(restoredOverlap + 1, restoredOverlap, 8);
-    for (i = 0; i < 8; i++) if (restoredOverlap[i + 1] != i) return 31;
-    fillWords(words, 0x89abcdefU, 4);
-    for (i = 0; i < 4; i++) if (words[i] != 0x89abcdefU) return 16;
-    if (findByte(source, 8, 4) != 4) return 17;
-    if (findByte(source, 8, 9) != 0) return 18;
-    if (zeroLengthScanPreservesZF(source) != 1) return 32;
-    if (negateHasCarry(0) != 0 || negateHasCarry(7) != 1) return 33;
-    if (floorValue(3.75) != 3.0 || floorValue(-3.25) != -4.0) return 19;
-    if (uint32ToFloat64(0xffffffffU) != 4294967295.0) return 20;
-    if (!cas64(&word, 0x55667788U, 0x11223344U, 0xaabbccddU, 0x99aabbccU)) return 21;
-    if (word != 0x99aabbccaabbccddULL) return 22;
-    if (cas64(&word, 0, 0, 1, 2) || word != 0x99aabbccaabbccddULL) return 23;
-    if (xadd32(&atomicWord, 5) != 15 || atomicWord != 15) return 24;
-    if (identity64(0x8877665544332211ULL) != 0x8877665544332211ULL) return 25;
-    if (identityFloat64(-123.75) != -123.75) return 26;
-    copyForward(forwardOverlap + 1, forwardOverlap, 4);
-    for (i = 0; i < 5; i++) if (forwardOverlap[i] != 1) return 27;
-    if (readFS() == 0) return 28;
-    if (roundNearest(2.5) != 2.0 || roundNearest(3.5) != 4.0 || roundNearest(-1.5) != -2.0) return 29;
-    {
-        union { double f; unsigned long long u; } rounded;
-        rounded.f = roundNearest(-0.5);
-        if (rounded.u != 0x8000000000000000ULL) return 30;
-    }
-    return 0;
-}
-`
-	if err := os.WriteFile(cPath, []byte(cSource), 0o644); err != nil {
+	if err := os.WriteFile(cPath, []byte(runtime386CoreCSource), 0o644); err != nil {
 		t.Fatal(err)
 	}
 	if out, err := exec.Command(llc, "-mtriple=i686-pc-windows-msvc", "-filetype=obj", llPath, "-o", objPath).CombinedOutput(); err != nil {
diff --git a/x86_386_destination_initialization_test.go b/x86_386_destination_initialization_test.go
new file mode 100644
index 000000000..997aa74db
--- /dev/null
+++ b/x86_386_destination_initialization_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Go accepts an X0 store regardless of its incoming value. A bodyless Go
+// declaration does not supply that value: a translated result must instead
+// have all four source bytes initialized by the actual function.
+func TestTranslate386VectorResultRequiresCompleteInitialization(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, fixture := range []struct {
+		name, init string
+		accepted   bool
+	}{
+		{name: "uninitialized"},
+		{name: "partial-gp", init: "MOVB $1,AX\nMOVL AX,X0\n"},
+		{name: "complete-gp", init: "MOVL $1,AX\nMOVL AX,X0\n", accepted: true},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+				t.Run(triple, func(t *testing.T) {
+					source := "TEXT ·value(SB),4,$0-4\n" + fixture.init + "MOVL X0,ret+0(FP)\nRET\n"
+					x86LEAActualTargetGoObject(t, "386", triple, source)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					before := fmt.Sprintf("%#v", file.Funcs)
+					pkg := x86AddSubLiteralPackage(t, "386", "func value() uint32\n")
+					resolve := func(symbol string) string { return strings.Replace(symbol, "·", "literal.", 1) }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: "386", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+					for _, api := range []string{"text", "module", "GoModule"} {
+						t.Run(api, func(t *testing.T) {
+							context := llvm.NewContext()
+							defer context.Dispose()
+							var ir string
+							var err error
+							switch api {
+							case "text":
+								ir, err = Translate(file, options)
+							case "module":
+								var module llvm.Module
+								module, err = TranslateModuleInContext(context, file, options)
+								if !module.IsNil() {
+									defer module.Dispose()
+									ir = module.String()
+								}
+							case "GoModule":
+								var result *GoModuleTranslation
+								result, err = translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+									GOARCH: "386", TargetTriple: triple, ResolveSym: resolve,
+								})
+								if result != nil && !result.Module.IsNil() {
+									defer result.Module.Dispose()
+									ir = result.Module.String()
+								}
+							}
+							if before != fmt.Sprintf("%#v", file.Funcs) {
+								t.Fatal("result initialization check changed the original source")
+							}
+							if !fixture.accepted {
+								if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Fatalf("undefined result acquired a translation: %v\n%s", err, ir)
+								}
+								return
+							}
+							if err != nil || ir == "" {
+								t.Fatalf("initialized result failed: %v", err)
+							}
+							compileLLVMToObject(t, llc, triple, "initialized-result.ll", "initialized-result.o", ir)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_386_destination_store_test.go b/x86_386_destination_store_test.go
new file mode 100644
index 000000000..3ecbf1b1a
--- /dev/null
+++ b/x86_386_destination_store_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Retain every original destination-form body. Only vectorResult has actual
+// typed/initialized input and output; the remaining no-argument bodies are
+// explicitly emitter-only objects, never public translations or executions.
+func x86CompileOnlyDestinationEmitterModule(t *testing.T, original *File, options Options) string {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module := context.NewModule("destination-emitter-observations")
+	defer module.Dispose()
+	for _, function := range original.Funcs {
+		file := &File{Arch: original.Arch, Funcs: []Func{function}}
+		var ir string
+		if function.ArgSize != 0 {
+			var err error
+			ir, err = Translate(file, Options{Goarch: options.Goarch, TargetTriple: options.TargetTriple,
+				Sigs: map[string]FuncSig{function.Sym: options.Sigs[function.Sym]}})
+			if err != nil {
+				t.Fatal("independent typed destination failed", err)
+			}
+		} else {
+			ir = x86ZeroArgumentLowererObjectUnit(t, file, options.Goarch, options.TargetTriple, function.Sym,
+				func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+					if known, terminated, err := consumer.lowerVectorScalarIntegerMove(instruction.Op, instruction); known {
+						return known, terminated, err
+					}
+					if known, terminated, err := consumer.lowerMov(instruction.Op, instruction); known {
+						return known, terminated, err
+					}
+					if known, terminated, err := consumer.lowerVec(instruction.Op, instruction); known {
+						return known, terminated, err
+					}
+					return consumer.lowerX87(instruction.Op, instruction)
+				})
+		}
+		part, err := parseIRModuleInContext(context, ir)
+		if err != nil {
+			if !part.IsNil() {
+				part.Dispose()
+			}
+			t.Fatal("complete original destination body produced invalid IR", err)
+		}
+		// LLVMLinkModules2 consumes part on both success and failure.
+		if err := llvm.LinkModules(module, part); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	return module.String()
+}
+
+func check386DestinationFormsIR(t *testing.T, ir string) {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := verify386DestinationStores(module); err != nil {
+		t.Fatalf("386 destination-store contract: %v\n%s", err, ir)
+	}
+
+	// Valid LLVM mutations must fail the semantic checker, rather than failing
+	// parsing or benefiting from an unrelated store elsewhere in the module.
+	native := destination386Store(module, "vectorMemory", false, -1).String()
+	double := destination386Store(module, "x87DoubleSymbol", false, -1).String()
+	word := destination386Store(module, "x87ControlSymbol", false, -1).String()
+	integer := destination386Store(module, "x87IntegerSymbol", false, -1).String()
+	byte0 := destination386Store(module, "vectorResult", true, 0).String()
+	byte3 := destination386Store(module, "vectorResult", true, 3).Operand(1).String()
+	mutations := []struct{ name, from, to string }{
+		{"native-volatility", native, strings.Replace(native, "store volatile", "store", 1)},
+		{"native-width", native, "store volatile i64 1" + native[strings.IndexByte(native, ','):]},
+		{"symbol-identity", "ptr @\"\\C2\\B7vectorSink\", align 1", "ptr @\"\\C2\\B7doubleSink\", align 1"},
+		{"x87-double-volatility", double, strings.Replace(double, "store ", "store volatile ", 1)},
+		{"x87-word-volatility", word, strings.Replace(word, "store ", "store volatile ", 1)},
+		{"x87-integer-volatility", integer, strings.Replace(integer, "store ", "store volatile ", 1)},
+		{"FP-byte-volatility", byte0, strings.Replace(byte0, "store ", "store volatile ", 1)},
+		{"FP-byte-offset", byte3, strings.Replace(byte3, "i64 3", "i64 2", 1)},
+		{"FP-byte-missing", byte0, "; removed FP byte"},
+	}
+	for _, mutation := range mutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			if strings.Count(ir, mutation.from) != 1 {
+				t.Fatal("mutation does not bind one exact original instruction", mutation.from)
+			}
+			changed := strings.Replace(ir, mutation.from, mutation.to, 1)
+			candidate, err := parseIRModuleInContext(ctx, changed)
+			if !candidate.IsNil() {
+				defer candidate.Dispose()
+			}
+			if err != nil {
+				t.Fatal("mutation is not valid LLVM IR", err)
+			}
+			if err := llvm.VerifyModule(candidate, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("mutation is not a valid LLVM module", err)
+			}
+			if err := verify386DestinationStores(candidate); err == nil {
+				t.Fatal("destination-store mutation escaped its role/width/effect check")
+			}
+		})
+	}
+}
+
+func destination386Store(module llvm.Module, name string, frame bool, offset int) llvm.Value {
+	function := module.NamedFunction(name)
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+			if instruction.IsAStoreInst().IsNil() {
+				continue
+			}
+			pointer := instruction.Operand(1)
+			if !frame && !x86GPSIMDStoreTargetsBackingAlloca(pointer) {
+				return instruction
+			}
+			if frame && instruction.Operand(0).Type().TypeKind() == llvm.IntegerTypeKind &&
+				instruction.Operand(0).Type().IntTypeWidth() == 8 && destination386FrameOffset(pointer, offset) {
+				return instruction
+			}
+		}
+	}
+	return llvm.Value{}
+}
+
+func verify386DestinationStores(module llvm.Module) error {
+	for _, want := range []struct {
+		name     string
+		kind     llvm.TypeKind
+		bits     int
+		volatile bool
+		symbol   string
+	}{
+		{"vectorMemory", llvm.IntegerTypeKind, 32, true, ""},
+		{"vectorSymbol", llvm.IntegerTypeKind, 32, true, "vectorSink"},
+		// These x87 destinations retain their ordinary stores. The SP forms
+		// are compile-only virtual-stack fixtures, not native-backing grants.
+		{"x87DoubleMemory", llvm.DoubleTypeKind, 0, false, ""},
+		{"x87DoubleSymbol", llvm.DoubleTypeKind, 0, false, "doubleSink"},
+		{"x87ControlSymbol", llvm.IntegerTypeKind, 16, false, "controlSink"},
+		{"x87IntegerMemory", llvm.IntegerTypeKind, 64, false, ""},
+		{"x87IntegerSymbol", llvm.IntegerTypeKind, 64, false, "integerSink"},
+	} {
+		function := module.NamedFunction(want.name)
+		if function.IsNil() {
+			return fmt.Errorf("missing function %s", want.name)
+		}
+		stores := 0
+		for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+			for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+				if instruction.IsAStoreInst().IsNil() || x86GPSIMDStoreTargetsBackingAlloca(instruction.Operand(1)) {
+					continue // Do not let register-bank initialization satisfy a destination check.
+				}
+				stores++
+				typ, pointer := instruction.Operand(0).Type(), instruction.Operand(1)
+				if typ.TypeKind() != want.kind || (want.kind == llvm.IntegerTypeKind && typ.IntTypeWidth() != want.bits) ||
+					instruction.IsVolatile() != want.volatile || instruction.Alignment() != 1 {
+					return fmt.Errorf("%s incorrect destination type/width/volatility/alignment: %s", want.name, instruction.String())
+				}
+				if want.symbol != "" {
+					if pointer.IsAGlobalVariable().IsNil() || pointer.Name() != "·"+want.symbol {
+						return fmt.Errorf("%s lost exact SB destination: %s", want.name, instruction.String())
+					}
+				} else if pointer.IsAIntToPtrInst().IsNil() {
+					return fmt.Errorf("%s lost memory destination: %s", want.name, instruction.String())
+				}
+			}
+		}
+		if stores != 1 {
+			return fmt.Errorf("%s destination stores=%d, want one", want.name, stores)
+		}
+	}
+
+	function := module.NamedFunction("vectorResult")
+	if function.IsNil() {
+		return fmt.Errorf("missing vectorResult")
+	}
+	bytes, initialization, returns := [4]bool{}, 0, 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+			if !instruction.IsAReturnInst().IsNil() {
+				returns++
+				if instruction.OperandsCount() != 1 || instruction.Operand(0).Type().TypeKind() != llvm.IntegerTypeKind ||
+					instruction.Operand(0).Type().IntTypeWidth() != 32 || instruction.Operand(0).IsALoadInst().IsNil() ||
+					!destination386FrameOffset(instruction.Operand(0).Operand(0), 0) {
+					return fmt.Errorf("vectorResult lost its i32 FP return load")
+				}
+			}
+			if instruction.IsAStoreInst().IsNil() {
+				continue
+			}
+			pointer := instruction.Operand(1)
+			if !x86GPSIMDStoreTargetsBackingAlloca(pointer) {
+				return fmt.Errorf("vectorResult FP write escaped backing: %s", instruction.String())
+			}
+			if pointer.IsAGetElementPtrInst().IsNil() || pointer.Operand(0).Name() != "classic_frame" {
+				continue
+			}
+			typ := instruction.Operand(0).Type()
+			if typ.TypeKind() != llvm.IntegerTypeKind || instruction.IsVolatile() || instruction.Alignment() != 1 {
+				return fmt.Errorf("vectorResult FP store role changed: %s", instruction.String())
+			}
+			if typ.IntTypeWidth() == 32 && !instruction.Operand(0).IsAConstantInt().IsNil() && instruction.Operand(0).ZExtValue() == 0 && destination386FrameOffset(pointer, 0) {
+				initialization++
+				continue
+			}
+			matched := false
+			for offset := range bytes {
+				if typ.IntTypeWidth() == 8 && destination386FrameOffset(pointer, offset) && !bytes[offset] {
+					bytes[offset], matched = true, true
+					break
+				}
+			}
+			if !matched {
+				return fmt.Errorf("vectorResult FP byte store widened/duplicated/moved: %s", instruction.String())
+			}
+		}
+	}
+	if bytes != [4]bool{true, true, true, true} || initialization != 1 || returns != 1 {
+		return fmt.Errorf("vectorResult incomplete FP bytes/init/return: %v/%d/%d", bytes, initialization, returns)
+	}
+	return nil
+}
+
+func destination386FrameOffset(pointer llvm.Value, offset int) bool {
+	return !pointer.IsAGetElementPtrInst().IsNil() && pointer.OperandsCount() == 3 &&
+		!pointer.Operand(0).IsAAllocaInst().IsNil() && pointer.Operand(0).Name() == "classic_frame" &&
+		!pointer.Operand(1).IsAConstantInt().IsNil() && pointer.Operand(1).SExtValue() == 0 &&
+		!pointer.Operand(2).IsAConstantInt().IsNil() && pointer.Operand(2).SExtValue() == int64(offset)
+}
diff --git a/x86_abi0_bool_arch_test.go b/x86_abi0_bool_arch_test.go
new file mode 100644
index 000000000..ed6346eb8
--- /dev/null
+++ b/x86_abi0_bool_arch_test.go
@@ -0,0 +1,225 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86ABI0BoolArchFixture(arch string) (string, string) {
+	word, lea, move := 8, "LEAQ", "MOVQ"
+	if arch == "386" {
+		word, lea, move = 4, "LEAL", "MOVL"
+	}
+	var source, declarations strings.Builder
+	for index, row := range []struct {
+		declaration, body string
+		args              int
+	}{
+		{"func Value() bool", "MOVB $0,ret+0(FP)", 1},
+		{"func Value() bool", "MOVB $1,ret+0(FP)", 1},
+		{"func Value(x uint32) bool", fmt.Sprintf("MOVL x+0(FP),AX\nCMPL AX,$0\nSETEQ ret+%d(FP)", word), word + 1},
+		{"func Value(x bool) bool", fmt.Sprintf("MOVB x+0(FP),AL\nMOVB AL,ret+%d(FP)", word), word + 1},
+		{"func Value(x bool) bool", fmt.Sprintf("MOVB $2,x+0(FP)\nMOVB x+0(FP),AL\nCMPB AL,$2\nSETEQ ret+%d(FP)", word), word + 1},
+		{"func Value() bool", fmt.Sprintf("%s ret+0(FP),AX\n%s AX,BX\nMOVB $1,(BX)", lea, move), 1},
+		{"func Value(x bool) bool", fmt.Sprintf("%s x+0(FP),AX\nMOVB $2,(AX)\nMOVB (AX),CL\nCMPB CL,$2\nSETEQ ret+%d(FP)", lea, word), word + 1},
+		{"func Value(p *uint32,old,new uint32) bool", fmt.Sprintf("%s p+0(FP),BX\nMOVL old+%d(FP),AX\nMOVL new+%d(FP),CX\nLOCK\nCMPXCHGL CX,(BX)\nSETEQ ret+%d(FP)", move, word, word+4, word+8), word + 9},
+	} {
+		name := fmt.Sprintf("BoolArch%d", index)
+		fmt.Fprintf(&declarations, "%s\n", strings.Replace(row.declaration, "Value", name, 1))
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s\nRET\n", name, row.args, row.body)
+	}
+	for _, condition := range strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS") {
+		name := "Bool" + condition
+		fmt.Fprintf(&declarations, "func %s(x uint32) bool\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOVL x+0(FP),AX\nCMPL AX,$0\n%s ret+%d(FP)\nRET\n", name, word+1, condition, word)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ABI0CanonicalBoolArchitectureObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86ABI0BoolArchFixture(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ABI0CanonicalBoolArchitectureNoncanonicalResults(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, body := range []string{
+			"MOVB $2,ret+0(FP)\nRET", "MOVB $255,ret+0(FP)\nRET",
+			"MOVB $2,AL\nMOVB AL,ret+0(FP)\nRET", "RET",
+			"MOVL $1,AX\nCMPL AX,$0\nJNE missing\nMOVB $1,ret+0(FP)\nmissing:\nRET",
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·Value(SB),4,$0-1\n"+body+"\n",
+					"func Value() bool", target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("noncanonical or missing bool became logical i1: %s/%s/%s: %v", target.triple, api, body, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86AMD64CanonicalBoolDefaultArchitecture(t *testing.T) {
+	for _, arch := range []string{"", "amd64"} {
+		for _, row := range []struct {
+			body string
+			good bool
+		}{
+			{"MOVB $0,ret+0(FP)\nRET", true},
+			{"MOVB $1,ret+0(FP)\nRET", true},
+			{"MOVB $2,ret+0(FP)\nRET", false},
+			{"MOVB $255,ret+0(FP)\nRET", false},
+			{"RET", false},
+			{"NOP", false},
+		} {
+			for _, api := range []string{"text", "module"} {
+				t.Run(arch+"/"+row.body+"/"+api, func(t *testing.T) {
+					_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() bool", row.body)
+					options := Options{Goarch: arch, TargetTriple: "x86_64-unknown-linux-gnu",
+						ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+						Sigs:       map[string]FuncSig{"Value": sig}}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					published := false
+					var err error
+					if api == "text" {
+						var ir string
+						ir, err = Translate(file, options)
+						published = ir != ""
+					} else {
+						module, failure := TranslateModuleInContext(ctx, file, options)
+						err, published = failure, !module.IsNil()
+						if !module.IsNil() {
+							module.Dispose()
+						}
+					}
+					if row.good && (!published || err != nil) || !row.good && (published || !errors.Is(err, ErrProbeNeedsContext)) {
+						t.Fatal("default architecture bypassed canonical ABI0 proof", row.good, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86AMD64CanonicalBoolKeepsManualRegisterTransport(t *testing.T) {
+	for _, arch := range []string{"", "amd64"} {
+		for _, instruction := range []string{"CALL", "JMP"} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Manual(SB),4,$0-0\n"+instruction+" Outside(SB)\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: arch, TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{
+					"Manual": {Name: "Manual", Ret: I1}, "Outside": {Name: "Outside", Ret: I1},
+				}}
+				if source, err := prepareX86ABI0BoolCalls(file, options); source != nil || err != nil {
+					t.Fatal("manual register signature acquired an undeclared ABI0 byte frame", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0CanonicalBoolArchitectureAliasesAndCalls(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, lea, move := x86ResultPointerWord(target.arch), "LEAQ", "MOVQ"
+		if target.arch == "386" {
+			lea, move = "LEAL", "MOVL"
+		}
+		leaf := fmt.Sprintf("TEXT ·leaf(SB),4,$0-%d\nMOVB x+0(FP),AX\nMOVB AX,ret+%d(FP)\nRET\n", word+1, word)
+		call := fmt.Sprintf("MOVB x+0(FP),AX\nMOVB AX,0(SP)\nCALL ·leaf(SB)\nMOVB %d(SP),AX\nMOVB AX,ret+%d(FP)", word, word)
+		for _, row := range []struct {
+			name, body, callee string
+			frame              int
+			good               bool
+		}{
+			{"alias-copy", fmt.Sprintf("%s x+0(FP),AX\n%s AX,DX\nMOVB (DX),BX\nMOVB BX,ret+%d(FP)", lea, move, word), "", 0, true},
+			{"alias-short-copy", fmt.Sprintf("%s x+0(FP),AX\nMOVW AX,DX\nMOVB (DX),BX\nMOVB BX,ret+%d(FP)", lea, word), "", 0, false},
+			{"alias-outside", fmt.Sprintf("%s x+0(FP),AX\nMOVB 1(AX),BX\nMOVB BX,ret+%d(FP)", lea, word), "", 0, false},
+			{"alias-raw-result", fmt.Sprintf("%s x+0(FP),AX\nMOVB $2,(AX)\nMOVB (AX),BX\nMOVB BX,ret+%d(FP)", lea, word), "", 0, false},
+			{"same-file-call", call, leaf, 16, true},
+			{"raw-outgoing-call", strings.Replace(call, "MOVB AX,0(SP)", "MOVB $2,0(SP)", 1), leaf, 16, false},
+			{"missing-outgoing-call", strings.Replace(call, "MOVB AX,0(SP)\n", "", 1), leaf, 16, false},
+			{"call-kills-flags", call + fmt.Sprintf("\nSETEQ ret+%d(FP)", word), leaf, 16, false},
+			{"raw-callee-call", call, strings.Replace(leaf, "MOVB AX,ret+", "MOVB $2,ret+", 1), 16, false},
+			{"same-file-tail", "JMP ·leaf(SB)", leaf, 0, true},
+			{"raw-callee-tail", "JMP ·leaf(SB)", strings.Replace(leaf, "MOVB AX,ret+", "MOVB $2,ret+", 1), 0, false},
+		} {
+			declarations := "func Value(x bool) bool\n"
+			if row.callee != "" {
+				declarations += "func leaf(x bool) bool\n"
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$%d-%d\n%s\n", row.frame, word+1, row.body)
+			if !strings.HasPrefix(row.body, "JMP") {
+				source += "RET\n"
+			}
+			source += row.callee
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("canonical byte alias/call contract changed", row.good, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// This portable oracle exercises the physical byte before canonical RET,
+// independently of native LOCK/CMPXCHG and native Go ABI execution.
+func TestX86AMD64CanonicalBoolTemporaryBytePortable(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	const source = "TEXT ·Value(SB),4,$0-9\nMOVB $2,x+0(FP)\nMOVB x+0(FP),AL\nCMPB AL,$2\nSETEQ ret+8(FP)\nRET\n"
+	// An explicit integer shim avoids borrowing C's _Bool ABI attributes.
+	const shim = `
+define i32 @BoolByteProbe(i32 %input) {
+ %boolean = icmp ne i32 %input, 0
+ %result = call i1 @Value(i1 %boolean)
+ %output = zext i1 %result to i32
+ ret i32 %output
+}
+`
+	const driver = "extern int BoolByteProbe(int);\nint main(void){return BoolByteProbe(0)==1&&BoolByteProbe(1)==1?0:1;}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x bool) bool", "amd64", triple, api)
+			if err != nil {
+				t.Fatal(api, err)
+			}
+			ir += shim
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "bool-byte", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_atomic_sdk_go127_test.go b/x86_abi0_bool_atomic_sdk_go127_test.go
new file mode 100644
index 000000000..a9563e6ef
--- /dev/null
+++ b/x86_abi0_bool_atomic_sdk_go127_test.go
@@ -0,0 +1,201 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86ABI0BoolUnsafeImporter struct{}
+
+func (x86ABI0BoolUnsafeImporter) Import(path string) (*types.Package, error) {
+	if path == "unsafe" {
+		return types.Unsafe, nil
+	}
+	return nil, fmt.Errorf("unexpected actual declaration fixture import %q", path)
+}
+
+// Complete untouched Go files supply actual types without executing cmd/go or
+// manufacturing an SDK source/object observation token. This is pure source/
+// declaration/IR evidence; actual selected graph/native observations are separate.
+func x86ABI0BoolActualAtomicPackage(t *testing.T, path, arch string, files []string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	var syntax []*ast.File
+	for _, name := range files {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(path), name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("actual Go declaration source %s/%s bytes=%d sha256=%x", path, name, len(data), sha256.Sum256(data))
+		file, err := parser.ParseFile(fset, name, data, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+	}
+	config := types.Config{Importer: x86ABI0BoolUnsafeImporter{}, Sizes: types.SizesFor("gc", arch)}
+	pkg, err := config.Check(path, fset, syntax, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: path, Types: pkg, Syntax: syntax}
+}
+
+func TestX86ABI0Mode32CanonicalBoolActualAtomicCompleteSourceNextContext(t *testing.T) {
+	for _, row := range []struct {
+		path, member, boundary string
+		declarations           []string
+		texts                  int
+	}{
+		{"internal/runtime/atomic", "atomic_386.s", "tail callee needs its independent CALL contract", []string{"stubs.go", "atomic_386.go", "unaligned.go"}, 42},
+		{"sync/atomic", "asm.s", "tail target lacks its independent exact canonical declaration/transport", []string{"doc.go", "doc_32.go"}, 36},
+	} {
+		t.Run(row.path, func(t *testing.T) {
+			pkg := x86ABI0BoolActualAtomicPackage(t, row.path, "386", row.declarations)
+			source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(row.path), row.member))
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("complete original assembly %s/%s bytes=%d sha256=%x", row.path, row.member, len(source), sha256.Sum256(source))
+			file, err := ParseWithDefines(ArchAMD64, string(source), GoAssemblerDefines("linux", "386"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(file.Funcs) != row.texts || len(file.Data) != 0 || len(file.Globl) != 0 {
+				t.Fatal("complete actual assembly inventory changed", len(file.Funcs), len(file.Data), len(file.Globl))
+			}
+			resolve := testResolveSym(row.path)
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if row.path == "internal/runtime/atomic" {
+				if !x86ABI0NoArgumentVoidCallRole(sigs[resolve("·panicUnaligned")]) {
+					t.Fatal("actual Go void declaration acquired a bool-return/outgoing contract")
+				}
+				// Complete typed-tail preparation proves Cas's own LOCK/CAS
+				// predicate before aliases can forward it. Cas64's alignment
+				// failure CALL still needs its independent whole-callee contract.
+				if plan, err := prepareX86ABI0BoolCalls(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}); plan != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), row.boundary) {
+					t.Fatal("complete original aliases borrowed an unclosed callee body", err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					published := false
+					var err error
+					if api == "text" {
+						var ir string
+						ir, err = Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+						published = ir != ""
+					} else if api == "module" {
+						var module llvm.Module
+						module, err = TranslateModuleInContext(ctx, file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+						published = !module.IsNil()
+						if published {
+							defer module.Dispose()
+						}
+					} else {
+						module, failure := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{GOARCH: "386", GOOS: "linux", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve})
+						err = failure
+						published = module != nil
+						if module != nil && !module.Module.IsNil() {
+							defer module.Module.Dispose()
+						}
+					}
+					if published || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), row.boundary) {
+						t.Fatal("complete source changed its genuine next unsupported contract", published, err)
+					}
+					t.Log("complete original source still Context, not SDK/object/runtime success:", err)
+				})
+			}
+		})
+	}
+}
+
+// These are the three complete original integer/pointer-CAS functions, not a
+// claim that the entire atomic member has been translated.
+func TestX86AMD64CanonicalBoolActualAtomicCasObjects(t *testing.T) {
+	const path = "internal/runtime/atomic"
+	pkg := x86ABI0BoolActualAtomicPackage(t, path, "amd64", []string{"stubs.go", "atomic_amd64.go", "unaligned.go"})
+	original, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", filepath.FromSlash(path), "atomic_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	start := strings.Index(string(original), "TEXT ·Cas(SB)")
+	end := strings.Index(string(original), "TEXT ·Casint32(SB)")
+	if start < 0 || end <= start {
+		t.Fatal("original integer-CAS function boundaries changed")
+	}
+	source := []byte("#include \"textflag.h\"\n" + string(original[start:end]))
+	t.Logf("untouched integer-CAS source bytes=%d sha256=%x original-member=%x", len(source), sha256.Sum256(source), sha256.Sum256(original))
+	file, err := ParseWithDefines(ArchAMD64, string(source), GoAssemblerDefines("linux", "amd64"))
+	if err != nil || len(file.Funcs) != 3 || file.Funcs[0].Sym != "·Cas" || file.Funcs[1].Sym != "·Cas64" || file.Funcs[2].Sym != "·Casp1" {
+		t.Fatal("complete original integer-CAS inventory changed", err)
+	}
+	resolve := testResolveSym(path)
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, string(source))
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					var ir string
+					var err error
+					options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						module, failure := TranslateModuleInContext(ctx, file, options)
+						err = failure
+						if !module.IsNil() {
+							ir = module.String()
+							module.Dispose()
+						}
+					case "Go":
+						module, failure := translateGoModuleInContext(ctx, pkg, source, GoModuleOptions{
+							GOARCH: "amd64", GOOS: "linux", TargetTriple: triple, ResolveSym: resolve,
+						})
+						err = failure
+						if module != nil && !module.Module.IsNil() {
+							ir = module.Module.String()
+							module.Module.Dispose()
+						}
+					}
+					if err != nil || ir == "" {
+						t.Fatal("original integer-CAS canonical result rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_call_domains_test.go b/x86_abi0_bool_call_domains_test.go
new file mode 100644
index 000000000..74ddc745e
--- /dev/null
+++ b/x86_abi0_bool_call_domains_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ABI0BoolCallDomainState(t *testing.T) (*x86ABI0BoolCallPlan, x86ResultState, []bool) {
+	t.Helper()
+	source := x86ABI0BoolCallAssembly("MOVB $1,0(SP)\nCALL ·callee(SB)\nMOVB 4(SP),AX\nMOVB AX,ret+4(FP)", x86ABI0BoolCallLeaf)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "calldomains", "package calldomains\nfunc caller(p *byte) bool\nfunc callee(x bool) bool\n")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed, err := prepareX86ABI0BoolCalls(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan := observed.callers["·caller"]
+	sig := sigs["caller"]
+	state := x86ResultState{fp: make([]bool, 5), canonicalFP: make([]bool, 5), pointerFP: make(map[int64]bool),
+		boolCalls: plan, boolOutgoing: make([]bool, 5), boolOutgoingCanonical: make([]bool, 5),
+		boolFrameSlots: append(append([]FrameSlot(nil), sig.Frame.Params...), sig.Frame.Results...)}
+	owned := make([]bool, 5)
+	for _, slot := range sig.Frame.Params {
+		if slot.Type != Ptr {
+			t.Fatal("fixture lost its actual declared pointer role")
+		}
+		state.pointerFP[slot.Offset] = true
+		for i := int64(0); i < x86FrameScalarBytes(slot.Type, "386"); i++ {
+			owned[slot.Offset+i] = true
+		}
+	}
+	owned[sig.Frame.Results[0].Offset] = true
+	state.callerAddressFP = state.pointerFP
+	store := x86ScalarLaneInstruction(t, "MOVB $1,0(SP)")
+	if accepted, known := x86ABI0BoolCallStep(1, store, &state, owned, 4, "386"); !accepted || !known {
+		t.Fatal("actual outgoing parameter was not written")
+	}
+	return plan, state, owned
+}
+
+// Replay the existing independent typed producer and its existing after-effect
+// observations. No invented GP, vector, flag or native-entry fact seeds these
+// domains. The actual pointer slot remains opaque/non-numerical.
+func x86ABI0BoolCallDomainEffect(t *testing.T, state *x86ResultState, owned []bool, line string) Instr {
+	t.Helper()
+	ins := x86ScalarLaneInstruction(t, line)
+	addresses, origins, predicate := state.callerAddressGP, state.callerAddressOrigin, state.predicate
+	if !x86ScalarFPResultTransfer(ins, state, owned, 4, "386") {
+		t.Fatal("actual typed producer failed", line)
+	}
+	state.callerAddressGP = x86ResultCallerAddressesAfter(ins, addresses, state.callerAddressFP, "386")
+	state.callerAddressOrigin = x86ResultCallerOriginsAfter(ins, origins, state.callerAddressGP, state.callerAddressFP, "386")
+	state.predicate = x86ResultPredicateAfter(ins, predicate, "386")
+	return ins
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallRevokesAllDerivedDomains(t *testing.T) {
+	for _, domain := range []string{"caller-origin", "scan-pending", "predicate"} {
+		t.Run(domain, func(t *testing.T) {
+			plan, state, owned := x86ABI0BoolCallDomainState(t)
+			switch domain {
+			case "caller-origin":
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "MOVL p+0(FP),SI")
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "LEAL 7(SI),DI")
+				if state.callerAddressOrigin[6] != 1 || state.callerAddressOrigin[7] != 1 || state.gp[6] != 0 || state.gp[7] != 0 {
+					t.Fatal("actual opaque pointer origin was not independently derived")
+				}
+			case "scan-pending":
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "MOVL $1,AX")
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "BSFL AX,BX")
+				if state.bitScanPending.mask == 0 || state.gp[3] != 0 {
+					t.Fatal("pending scan was not tied to an actual unknown destination")
+				}
+			case "predicate":
+				for _, line := range []string{"MOVL $1,AX", "MOVL AX,X0", "VPBROADCASTD X0,Y1", "VPCMPEQB Y1,Y1,Y2", "VPTEST Y2,Y2"} {
+					x86ABI0BoolCallDomainEffect(t, &state, owned, line)
+				}
+				branch := x86ScalarLaneInstruction(t, "JZ zero")
+				state = x86ResultPredicateEdge(state, branch, 0)
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "VPMOVMSKB Y2,DX")
+				if state.predicate.kind != x86ResultNonzeroMaskGP || state.predicate.register != 2 || state.predicate.width != 32 {
+					t.Fatal("typed comparison/test/edge/movemask did not produce its actual bounded relation")
+				}
+			}
+			before := state.clone()
+			var ordinal int
+			for index := range plan.calls {
+				ordinal = index
+			}
+			if accepted, known := x86ABI0BoolCallStep(ordinal, plan.function.Instrs[ordinal], &state, owned, 4, "386"); !accepted || !known {
+				t.Fatal("actual canonical bool CALL was not accepted")
+			}
+			if state.callerAddressOrigin != [16]uint16{} || state.bitScanPending != (x86ResultBitScanPending{}) || state.predicate != (x86ResultPredicate{}) {
+				t.Fatal("CALL retained a derived domain after revoking its machine inputs", domain, state.callerAddressOrigin, state.bitScanPending, state.predicate)
+			}
+			if state.callerAddressFP[0] != before.callerAddressFP[0] || !state.boolOutgoing[0] || !state.boolOutgoingCanonical[0] || !state.boolOutgoing[4] || !state.boolOutgoingCanonical[4] {
+				t.Fatal("domain revoke erased actual readonly entry/parameter or declared result")
+			}
+		})
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallDerivedDomainsThreeAPIs(t *testing.T) {
+	const vector = "MOVL $1,AX\nMOVL AX,X0\nVPBROADCASTD X0,Y1\nVPCMPEQB Y1,Y1,Y2\nVPTEST Y2,Y2\nJZ zero\n"
+	for name, row := range map[string]struct {
+		body, declaration string
+		good              bool
+	}{
+		"stale-origin":           {"MOVB $1,0(SP)\nMOVL p+0(FP),SI\nLEAL 7(SI),DI\nCALL ·callee(SB)\nSUBL SI,DI\nTESTL DI,DI\nSETNE ret+4(FP)", "func caller(p *byte) bool", false},
+		"fresh-origin":           {"MOVB $1,0(SP)\nMOVL p+0(FP),SI\nLEAL 7(SI),DI\nCALL ·callee(SB)\nMOVL p+0(FP),SI\nLEAL 7(SI),DI\nSUBL SI,DI\nTESTL DI,DI\nSETNE ret+4(FP)", "func caller(p *byte) bool", true},
+		"stale-pending-flags":    {"MOVB $1,0(SP)\nMOVL $1,AX\nBSFL AX,BX\nCALL ·callee(SB)\nJZ zero\nTESTL BX,BX\nSETNE ret+4(FP)\nRET\nzero:\nMOVB $0,ret+4(FP)", "func caller(x bool) bool", false},
+		"fresh-scan":             {"MOVB $1,0(SP)\nMOVL $1,AX\nBSFL AX,BX\nCALL ·callee(SB)\nMOVL $1,AX\nBSFL AX,BX\nJZ zero\nTESTL BX,BX\nSETNE ret+4(FP)\nRET\nzero:\nMOVB $0,ret+4(FP)", "func caller(x bool) bool", true},
+		"stale-predicate-vector": {"MOVB $1,0(SP)\n" + vector + "CALL ·callee(SB)\nVPMOVMSKB Y2,DX\nBSFL DX,BX\nTESTL BX,BX\nSETNE ret+4(FP)\nRET\nzero:\nMOVB $0,ret+4(FP)", "func caller(x bool) bool", false},
+		"fresh-predicate":        {"MOVB $1,0(SP)\nCALL ·callee(SB)\n" + vector + "VPMOVMSKB Y2,DX\nBSFL DX,BX\nTESTL BX,BX\nSETNE ret+4(FP)\nRET\nzero:\nMOVB $0,ret+4(FP)", "func caller(x bool) bool", true},
+		"unknown-call-target":    {strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "CALL AX", 1), "func caller(x bool) bool", false},
+		"native-call-target":     {strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "CALL ·callee<ABIInternal>(SB)", 1), "func caller(x bool) bool", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%s/%s", name, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, x86ABI0BoolCallAssembly(row.body, x86ABI0BoolCallLeaf), row.declaration+"\nfunc callee(x bool) bool\n", "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("actual stale/fresh CALL domain boundary", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_abi0_bool_call_flow.go b/x86_abi0_bool_call_flow.go
new file mode 100644
index 000000000..54c0c5aa9
--- /dev/null
+++ b/x86_abi0_bool_call_flow.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+// Outgoing ABI0 bytes are distinct from FP and negative named AUTO. They are
+// observed only at declared one-byte parameter/result offsets of a proved
+// same-file readonly leaf, never from FrameSize alone.
+func x86ABI0BoolCallStep(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	plan := state.boolCalls
+	if plan == nil {
+		return false, false
+	}
+	if ins.Op == "CALL" {
+		sig, known := plan.calls[ordinal]
+		if !known || arch != plan.source.options.Goarch || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+			return false, true
+		}
+		if sig.Ret != Void && !state.shapeOnly && (!state.boolOutgoing[0] || !state.boolOutgoingCanonical[0]) {
+			return false, true
+		}
+		// No caller GP, SIMD, mask, pointer, slot-address or FLAGS state is
+		// preserved by the original CALL, even if logical SSA happens to leave
+		// a register alloca untouched. Void supplies no result byte at all.
+		state.gp = [16]uint8{}
+		state.canonicalGP = [16]uint8{}
+		state.xmm = [32]uint16{}
+		state.vectorUpper = [32]uint64{}
+		state.masks = [8]bool{}
+		state.pointerGP = [16]bool{}
+		state.callerAddressGP = [16]bool{}
+		state.callerAddressOrigin = [16]uint16{}
+		state.bitScanPending = x86ResultBitScanPending{}
+		state.predicate = x86ResultPredicate{}
+		state.resultAddressGP = [16]x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP = new([16]x86ResultSlotAddress)
+		}
+		state.flags = 0
+		state.direction = x86ResultDirectionUnknown
+		if state.x87 != nil {
+			state.x87.revoke()
+		}
+		if sig.Ret == Void {
+			return true, true // No numerical/canonical FP or outgoing byte is new.
+		}
+		offset := int(sig.Frame.Results[0].Offset)
+		state.boolOutgoing[offset], state.boolOutgoingCanonical[offset] = true, true
+		return true, true
+	}
+	sp := false
+	for _, arg := range ins.Args {
+		sp = sp || arg.Kind == OpMem && arg.Mem.Base == SP
+	}
+	if !sp {
+		return false, false
+	}
+	if ins.Op != "MOVB" || len(ins.Args) != 2 || isX86RawDirective(ins) {
+		return false, true
+	}
+	first, last := ins.Args[0], ins.Args[1]
+	for index, arg := range ins.Args {
+		if arg.Kind == OpMem && arg.Mem.Base == SP {
+			if _, valid := x86ABI0BoolOutgoingOffset(arg, plan); !valid {
+				return false, true
+			}
+			width, write, known := x86InstructionMemoryShape(ins, index, arch)
+			if !known || width != 1 || write != (index == 1) {
+				return false, true
+			}
+		}
+	}
+	if offset, valid := x86ABI0BoolOutgoingOffset(last, plan); valid {
+		if first.Kind != OpReg && first.Kind != OpImm {
+			return false, true
+		}
+		if !x86ResultRead(first, 1, state, owned, arch) {
+			return false, true
+		}
+		canonical := false
+		if first.Kind == OpImm {
+			canonical = first.ImmRaw == "" && !first.ImmIsFloat && (first.Imm == 0 || first.Imm == 1)
+		} else {
+			root, mask, valid := x86ResultGP(first.Reg, 1, arch)
+			canonical = valid && state.canonicalGP[root]&mask == mask
+		}
+		state.boolOutgoing[offset], state.boolOutgoingCanonical[offset] = true, canonical
+		return true, true
+	}
+	if offset, valid := x86ABI0BoolOutgoingOffset(first, plan); valid {
+		if last.Kind != OpReg || !state.boolOutgoing[offset] || !x86ResultStore(last, 1, state, owned, resultOffset, arch) {
+			return false, true
+		}
+		root, mask, valid := x86ResultGP(last.Reg, 1, arch)
+		if !valid {
+			return false, true
+		}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[root] = x86ResultSlotAddress{}
+		}
+		state.canonicalGP[root] &^= mask
+		if state.boolOutgoingCanonical[offset] {
+			state.canonicalGP[root] |= mask
+		}
+		return true, true
+	}
+	return false, true
+}
diff --git a/x86_abi0_bool_call_selection_test.go b/x86_abi0_bool_call_selection_test.go
new file mode 100644
index 000000000..2b04b2b2b
--- /dev/null
+++ b/x86_abi0_bool_call_selection_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Complete independent source/type inventories exercise cost selection, not a
+// cropped module or an exception for a particular library or function name.
+func x86ABI0CallSelectionFixture(kind string, fillers int) (string, string) {
+	var source, declarations strings.Builder
+	switch kind {
+	case "integer":
+		source.WriteString("TEXT ·caller(SB),4,$16-4\nCALL ·callee(SB)\nMOVL 0(SP),AX\nMOVL AX,ret+0(FP)\nRET\nTEXT ·callee(SB),4,$0-4\nMOVL $7,ret+0(FP)\nRET\n")
+		declarations.WriteString("func caller() uint32\nfunc callee() uint32\n")
+	case "void":
+		source.WriteString("TEXT ·caller(SB),4,$16-0\nCALL ·callee(SB)\nRET\nTEXT ·callee(SB),4,$0-0\nRET\n")
+		declarations.WriteString("func caller()\nfunc callee()\n")
+	case "opaque-transport":
+		source.WriteString("TEXT ·caller(SB),4,$16-4\nCALL ·callee(SB)\nRET\nTEXT ·callee(SB),4,$0-0\nRET\n")
+		declarations.WriteString("func caller(p *byte)\nfunc callee()\n")
+	case "bool-input-integer-result":
+		source.WriteString("TEXT ·caller(SB),4,$16-8\nCALL ·callee(SB)\nMOVL $7,ret+4(FP)\nRET\nTEXT ·callee(SB),4,$0-0\nRET\n")
+		declarations.WriteString("func caller(x bool) uint32\nfunc callee()\n")
+	case "bool":
+		source.WriteString(x86ABI0BoolCallAssembly(x86ABI0BoolCallBody, x86ABI0BoolCallLeaf))
+		declarations.WriteString(x86ABI0BoolCallDeclarations)
+	default:
+		panic("unknown fixture kind")
+	}
+	// An unrelated genuine bool return is not a bool CALL caller.
+	source.WriteString("TEXT ·unrelated(SB),4,$0-1\nMOVB $1,ret+0(FP)\nRET\n")
+	declarations.WriteString("func unrelated() bool\n")
+	for index := 0; index < fillers; index++ {
+		fmt.Fprintf(&source, "TEXT ·unused%d(SB),4,$0-0\nRET\n", index)
+		fmt.Fprintf(&declarations, "func unused%d()\n", index)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallSelectionKeepsNonboolGoFilter(t *testing.T) {
+	source, declarations := x86ABI0CallSelectionFixture("integer", 0)
+	declarations = strings.Replace(declarations, "func unrelated() bool\n", "", 1)
+	pkg := mustGoPackage(t, "callselect", "package callselect\n"+declarations)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "386", TargetTriple: "i386-unknown-linux-gnu",
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") },
+		KeepFunc:   func(original, _ string) bool { return original != "·unrelated" },
+	})
+	if module != nil && !module.Module.IsNil() {
+		defer module.Module.Dispose()
+	}
+	if err != nil || module == nil {
+		t.Fatal("unselected non-caller acquired a bool source/declaration requirement", err)
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallSelectionKeepsNonboolWholeFiles(t *testing.T) {
+	for _, kind := range []string{"integer", "void", "opaque-transport", "bool-input-integer-result"} {
+		for _, fillers := range []int{0, 254} {
+			source, declarations := x86ABI0CallSelectionFixture(kind, fillers)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/texts%d/%s", kind, fillers+3, api), func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", "i386-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("nonbool CALL acquired unrelated bool source/transport limits", len(ir), err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallSelectionRetainsTrueBoolLimit(t *testing.T) {
+	for _, fillers := range []int{0, 254} {
+		source, declarations := x86ABI0CallSelectionFixture("bool", fillers)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("texts%d/%s", fillers+3, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", "i386-unknown-linux-gnu", api)
+				if fillers == 0 && (err != nil || ir == "") || fillers != 0 && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("actual I1 CALL lost its complete original source bound", fillers+3, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallSelectionRejectsChangingQuery(t *testing.T) {
+	for _, kind := range []string{"unknown-declaration", "one-shot-resolution", "changed-declaration", "changed-original-call"} {
+		t.Run(kind, func(t *testing.T) {
+			file, options := x86ABI0BoolCallParsed(t)
+			if kind == "unknown-declaration" {
+				delete(options.Sigs, "caller")
+			}
+			calls := 0
+			options.ResolveSym = func(symbol string) string {
+				calls++
+				if calls == 1 {
+					switch kind {
+					case "one-shot-resolution":
+						return "outside"
+					case "changed-declaration":
+						sig := options.Sigs["caller"]
+						sig.Ret = I32
+						options.Sigs["caller"] = sig
+					case "changed-original-call":
+						file.Funcs[0].Instrs[3].Op = "NOP"
+					}
+				}
+				return strings.TrimPrefix(symbol, "·")
+			}
+			plan, err := prepareX86ABI0BoolCalls(file, options)
+			if calls == 0 || plan != nil || kind == "unknown-declaration" && err != nil ||
+				kind != "unknown-declaration" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown or changed cost query created a bool source permission", calls, plan != nil, err)
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_call_source.go b/x86_abi0_bool_call_source.go
new file mode 100644
index 000000000..206a6c590
--- /dev/null
+++ b/x86_abi0_bool_call_source.go
@@ -0,0 +1,330 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// This request-local plan observes complete logical source and declarations.
+// It is not a native CALL, tail, frame backing or caller-memory certificate.
+type x86ABI0BoolCallSource struct {
+	origin          *File
+	original        *File
+	signatures      map[string]FuncSig
+	resolved        map[string]string
+	options         Options
+	callers         map[string]*x86ABI0BoolCallPlan
+	budget          x86ResultFlowBudget
+	tailProofs      map[string]bool
+	customGraph     *x86DirectTailGraph
+	customSelection *File
+	customOptions   Options
+}
+
+type x86ABI0BoolCallPlan struct {
+	source           *x86ABI0BoolCallSource
+	function         Func
+	signature        FuncSig
+	emittedSignature *FuncSig        // Only the independently emitted nontransport Attrs projection.
+	calls            map[int]FuncSig // Original instruction ordinals, never helper/root rewrites.
+	bytes            map[int64]bool  // Actual declared outgoing bytes only; padding is absent.
+	tail             *x86ABI0BoolTail
+	registerTail     *x86CustomHelperBoolTail
+}
+
+func x86ABI0BoolCallContext(reason string) error {
+	return fmt.Errorf("%w: logical ABI0 bool CALL: %s", ErrProbeNeedsContext, reason)
+}
+
+func x86ABI0BoolCallsNeeded(file *File, arch string) bool {
+	if file == nil || file.Arch != ArchAMD64 || arch != "386" && arch != "amd64" && arch != "" {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		if x86ABI0BoolFunctionControlNeeded(fn) {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ABI0BoolFunctionControlNeeded(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" || ins.Op == OpJMP && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ABI0BoolCallResolve(options Options, symbol string) string {
+	if options.ResolveSym != nil {
+		return options.ResolveSym(symbol)
+	}
+	return symbol
+}
+
+// A declared logical no-argument void call transports no caller FP bytes and
+// supplies no result knowledge. Its unknown machine effects are revoked even
+// when the actual function happens not to return (for example a Go panic).
+func x86ABI0NoArgumentVoidCallRole(signature FuncSig) bool {
+	return signature.Ret == Void && len(signature.Args) == 0 && len(signature.ArgRegs) == 0 &&
+		len(signature.Frame.Params) == 0 && len(signature.Frame.Results) == 0 &&
+		signature.ARMEntry == nil && signature.ARM64GoRegisterABI == nil && signature.ARM64ClosureABI == nil &&
+		signature.WASMContext == "" && !signature.WASMNative
+}
+
+func prepareX86ABI0BoolCalls(file *File, options Options) (*x86ABI0BoolCallSource, error) {
+	if !x86ABI0BoolCallsNeeded(file, options.Goarch) {
+		return nil, nil
+	}
+	if options.Goarch == "" {
+		options.Goarch = "amd64"
+	}
+	arch := options.Goarch
+	word := x86ResultPointerWord(arch)
+	signatures, err := numericalCloneSignatures(options.Sigs)
+	if err != nil {
+		return nil, err
+	}
+	source := &x86ABI0BoolCallSource{origin: file, original: x86DirectTailSnapshot(file), options: options,
+		signatures: signatures, resolved: make(map[string]string), callers: make(map[string]*x86ABI0BoolCallPlan), tailProofs: make(map[string]bool)}
+	needed := false
+	for _, fn := range source.original.Funcs {
+		if !x86ABI0BoolFunctionControlNeeded(fn) {
+			continue
+		}
+		name := x86ABI0BoolCallResolve(options, fn.Sym)
+		source.resolved[fn.Sym] = name
+		if sig, declared := signatures[name]; declared && x86ABI0BoolResultNeedsProof(sig, arch) && !fixedLocalPrivateLeafCaller(fn, sig) {
+			needed = true
+		}
+	}
+	if !needed {
+		// This callback-bearing type query grants nothing. In particular, a
+		// changed original source/declaration cannot hide a former candidate.
+		if err := source.verify(); err != nil {
+			return nil, err
+		}
+		return nil, nil
+	}
+	if len(file.Funcs) > 256 {
+		return nil, x86ABI0BoolCallContext("complete TEXT inventory exceeds its bound")
+	}
+	byName := make(map[string]Func)
+	resolved := make(map[string]bool)
+	for _, fn := range source.original.Funcs {
+		name, queried := source.resolved[fn.Sym]
+		if !queried {
+			name = x86ABI0BoolCallResolve(options, fn.Sym)
+		}
+		if _, duplicate := byName[fn.Sym]; duplicate || name == "" || resolved[name] {
+			return nil, x86ABI0BoolCallContext("duplicate or aliased original TEXT identity")
+		}
+		byName[fn.Sym], source.resolved[fn.Sym], resolved[name] = fn, name, true
+	}
+	checked := make(map[string]bool)
+	for _, fn := range source.original.Funcs {
+		if !x86ABI0BoolFunctionControlNeeded(fn) {
+			continue
+		}
+		sig, present := signatures[source.resolved[fn.Sym]]
+		if !present || !x86ABI0BoolResultNeedsProof(sig, arch) || fixedLocalPrivateLeafCaller(fn, sig) {
+			continue
+		}
+		if sig.Name != "" && sig.Name != source.resolved[fn.Sym] {
+			return nil, x86ABI0BoolCallContext("caller declaration symbol differs from its actual TEXT")
+		}
+		if arch == "amd64" && !x86ABI0BoolHasCall(fn) && x86DirectTailRootNeeded(fn) {
+			// The ordinary direct-tail consumer owns this complete graph and
+			// its canonical register result. A private tail is not a 386-only
+			// custom helper call and grants no ABI0 bool-frame permission.
+			continue
+		}
+		if !x86ScalarFloatIntegerNativeTarget(arch, options.TargetTriple) {
+			return nil, x86ABI0BoolCallContext("logical target does not have the actual x86 word width")
+		}
+		plan := &x86ABI0BoolCallPlan{source: source, function: fn, signature: sig, calls: make(map[int]FuncSig), bytes: make(map[int64]bool)}
+		plan.signature.Name = source.resolved[fn.Sym]
+		if !x86ABI0BoolHasCall(fn) {
+			if x86DirectTailRootNeeded(fn) {
+				if err := source.prepareCustomRegisterTail(plan); err != nil {
+					return nil, err
+				}
+				source.callers[fn.Sym] = plan
+				continue
+			}
+			tail, err := source.prepareTail(fn, sig, byName, make(map[string]bool))
+			if err != nil {
+				return nil, err
+			}
+			plan.tail = tail
+			if err := plan.replay(); err != nil {
+				return nil, err
+			}
+			source.callers[fn.Sym] = plan
+			continue
+		}
+		for ordinal, ins := range fn.Instrs {
+			if ins.Op != "CALL" {
+				continue
+			}
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				return nil, x86ABI0BoolCallContext("call target is not an exact ordinary SB function")
+			}
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			callee, exists := byName[name]
+			if _, queried := source.resolved[name]; !queried && valid && offset == 0 && !strings.Contains(name, "<") {
+				source.resolved[name] = x86ABI0BoolCallResolve(options, name)
+			}
+			calleeSig, declared := signatures[source.resolved[name]]
+			if valid && offset == 0 && !strings.Contains(name, "<") && declared &&
+				(calleeSig.Name == "" || calleeSig.Name == source.resolved[name]) && x86ABI0NoArgumentVoidCallRole(calleeSig) {
+				plan.calls[ordinal] = calleeSig
+				continue // No readonly bool leaf, outgoing bytes or result fact.
+			}
+			if !valid || offset != 0 || !exists || !declared || strings.Contains(name, "<") ||
+				calleeSig.Name != "" && calleeSig.Name != source.resolved[name] ||
+				!x86ABI0LogicalBoolFrameRole(callee, calleeSig, arch) || len(calleeSig.Args) != 1 || calleeSig.Args[0] != I1 ||
+				len(calleeSig.Frame.Params) != 1 || calleeSig.Frame.Params[0].Type != I1 || calleeSig.Frame.Params[0].Offset != 0 ||
+				calleeSig.Frame.Params[0].Field != -1 || len(calleeSig.Frame.Params[0].Fields) != 0 ||
+				calleeSig.Frame.Results[0].Offset != word || callee.ArgSize != word+1 {
+				return nil, x86ABI0BoolCallContext("callee source, ABI or actual bool-byte declaration is not closed")
+			}
+			if !checked[name] {
+				if err := (&x86ABI0BoolCallPlan{function: callee}).replay(); err != nil {
+					return nil, err
+				}
+				for _, effect := range callee.Instrs {
+					if effect.Op == "CALL" || effect.Op == OpJMP && len(effect.Args) == 1 && effect.Args[0].Kind == OpSym {
+						return nil, x86ABI0BoolCallContext("leaf has an unknown call or external tail effect")
+					}
+				}
+				leaf := callee
+				leaf.x86ResultFlowBudget = &source.budget
+				leaf.x86BoolReadonlyInputs = true
+				if err := checkX86ABI0ResultInitializationAtSource(leaf, calleeSig, arch, func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+					return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+				}, true); err != nil {
+					return nil, err
+				}
+				checked[name] = true
+			}
+			plan.calls[ordinal] = calleeSig
+			plan.bytes[0], plan.bytes[word] = true, true
+		}
+		if len(plan.calls) == 0 {
+			continue
+		}
+		role := fn
+		role.FrameSize = 0
+		if fn.FrameSize < 0 || len(plan.bytes) != 0 && fn.FrameSize < word+1 || fn.FrameSize > 4096 ||
+			!x86ABI0LogicalBoolFrameRole(role, sig, arch) || fn.x86DirectTailRoot != nil {
+			return nil, x86ABI0BoolCallContext("caller lacks its complete bounded ordinary logical frame")
+		}
+		if err := plan.replay(); err != nil {
+			return nil, err
+		}
+		source.callers[fn.Sym] = plan
+	}
+	if err := source.verify(); err != nil {
+		return nil, err
+	}
+	if len(source.callers) == 0 {
+		return nil, nil
+	}
+	if source.customGraph != nil {
+		// Match the continuation producer's complete-file audit before any
+		// selection. The already sealed plan prevents recursive preparation.
+		request := options
+		request.x86BoolCallSource = source
+		if _, err := translateIRText(file, request); err != nil {
+			source.customGraph.revoked.Store(true)
+			return nil, err
+		}
+	}
+	return source, nil
+}
+
+func (source *x86ABI0BoolCallSource) verify() (result error) {
+	defer func() {
+		if result != nil && source.customGraph != nil {
+			source.customGraph.revoked.Store(true)
+		}
+	}()
+	// Resolve callbacks finish before the final source/declaration snapshot.
+	for original, name := range source.resolved {
+		if x86ABI0BoolCallResolve(source.options, original) != name {
+			return x86ABI0BoolCallContext("TEXT resolution changed")
+		}
+	}
+	if !reflect.DeepEqual(source.original, x86DirectTailSnapshot(source.origin)) || !reflect.DeepEqual(source.signatures, source.options.Sigs) {
+		return x86ABI0BoolCallContext("complete original source or declarations changed")
+	}
+	if source.customGraph != nil {
+		if err := source.customGraph.verify(source.origin, source.options); err != nil {
+			return err
+		}
+		if source.customSelection != nil {
+			owned, err := source.ownsCustomRegisterTails(source.customSelection, source.customOptions)
+			if err != nil {
+				return err
+			}
+			if !owned {
+				return x86ABI0BoolCallContext("selected custom helper closure changed")
+			}
+		}
+	}
+	return nil
+}
+
+func (plan *x86ABI0BoolCallPlan) replay() error {
+	var literal strings.Builder
+	for _, ins := range plan.function.Instrs {
+		if ins.Raw == "" || len(ins.Raw) > (1<<20)-literal.Len()-1 {
+			return x86ABI0BoolCallContext("missing or oversized original caller literal")
+		}
+		literal.WriteString(ins.Raw)
+		literal.WriteByte('\n')
+	}
+	parsed, err := Parse(ArchAMD64, literal.String())
+	if err != nil || len(parsed.Funcs) != 1 || len(parsed.Data) != 0 || len(parsed.Globl) != 0 || len(parsed.UnlinkedPrelude) != 0 ||
+		!reflect.DeepEqual(parsed.Funcs[0], plan.function) {
+		return x86ABI0BoolCallContext("caller original TEXT/operand tuple cannot be replayed")
+	}
+	return nil
+}
+
+func (plan *x86ABI0BoolCallPlan) matches(fn Func, sig FuncSig, arch string) bool {
+	fn.x86BoolCalls = nil
+	fn.x86ResultFlowBudget = nil
+	if sig.Name == "" {
+		sig.Name = plan.source.resolved[fn.Sym]
+	}
+	return arch == plan.source.options.Goarch && reflect.DeepEqual(fn, plan.function) &&
+		(reflect.DeepEqual(sig, plan.signature) || plan.emittedSignature != nil && reflect.DeepEqual(sig, *plan.emittedSignature))
+}
+
+func (plan *x86ABI0BoolCallPlan) bindLowering(fn Func, declaration, emitted FuncSig, arch string) bool {
+	// The lowerer already saved this actual declaration before inferring its
+	// target-feature attribute group. Only that one nontransport field may be
+	// projected; name, ABI, slots, native fields and all other fields stay exact.
+	if !plan.matches(fn, declaration, arch) {
+		return false
+	}
+	projected := plan.signature
+	projected.Attrs = emitted.Attrs
+	if !reflect.DeepEqual(projected, emitted) {
+		return false
+	}
+	plan.emittedSignature = &projected
+	return true
+}
+
+func x86ABI0BoolOutgoingOffset(arg Operand, plan *x86ABI0BoolCallPlan) (int, bool) {
+	if plan == nil || arg.Kind != OpMem || arg.Mem.Base != SP || !x86ResultSlotMemory(arg.Mem) || !plan.bytes[arg.Mem.Off] {
+		return 0, false
+	}
+	return int(arg.Mem.Off), true
+}
diff --git a/x86_abi0_bool_call_test.go b/x86_abi0_bool_call_test.go
new file mode 100644
index 000000000..f6262b5a2
--- /dev/null
+++ b/x86_abi0_bool_call_test.go
@@ -0,0 +1,307 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86ABI0BoolCallDeclarations = "func caller(x bool) bool\nfunc callee(x bool) bool\n"
+
+func x86ABI0BoolCallAssembly(caller, callee string) string {
+	return "TEXT ·caller(SB),4,$16-5\n" + caller + "\nRET\nTEXT ·callee(SB),4,$0-5\n" + callee + "\nRET\n"
+}
+
+func x86ABI0BoolCallParsed(t *testing.T) (*File, Options) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, x86ABI0BoolCallAssembly(x86ABI0BoolCallBody, x86ABI0BoolCallLeaf))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "boolcall", "package boolcall\n"+x86ABI0BoolCallDeclarations)
+	resolve := func(s string) string { return strings.TrimPrefix(s, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallOriginalIdentity(t *testing.T) {
+	for name, change := range map[string]func(*File, *Options){
+		"callee-original-literal": func(f *File, _ *Options) { f.Funcs[1].Instrs[2].Raw = "MOVB $3,ret+4(FP)" },
+		"callee-frame-extent":     func(f *File, _ *Options) { f.Funcs[1].ArgSize = 1 },
+		"missing-original-callee": func(f *File, _ *Options) { f.Funcs = f.Funcs[:1] },
+		"resolved-collision":      func(_ *File, o *Options) { o.ResolveSym = func(string) string { return "caller" } },
+		"callee-byte-input": func(_ *File, o *Options) {
+			sig := o.Sigs["callee"]
+			sig.Args = []LLVMType{I8}
+			sig.Frame.Params[0].Type = I8
+			o.Sigs["callee"] = sig
+		},
+		"callee-result-offset": func(_ *File, o *Options) {
+			sig := o.Sigs["callee"]
+			sig.Frame.Results[0].Offset = 3
+			o.Sigs["callee"] = sig
+		},
+		"callee-custom-name":      func(_ *File, o *Options) { sig := o.Sigs["callee"]; sig.Name = "outside"; o.Sigs["callee"] = sig },
+		"caller-short-frame":      func(f *File, _ *Options) { f.Funcs[0].FrameSize = 4 },
+		"caller-original-literal": func(f *File, _ *Options) { f.Funcs[0].Instrs[2].Raw = "MOVB $2,0(SP)" },
+		"target-64":               func(_ *File, o *Options) { o.TargetTriple = "x86_64-unknown-linux-gnu" },
+	} {
+		for _, api := range []string{"text", "module"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				file, opt := x86ABI0BoolCallParsed(t)
+				change(file, &opt)
+				if api == "text" {
+					ir, err := Translate(file, opt)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("source/declaration mutation published text", len(ir), err)
+					}
+				} else {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, err := TranslateModuleInContext(ctx, file, opt)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if !module.IsNil() || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("source/declaration mutation published module", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallPlanStateAndCache(t *testing.T) {
+	file, opt := x86ABI0BoolCallParsed(t)
+	before := x86DirectTailSnapshot(file)
+	source, err := prepareX86ABI0BoolCalls(file, opt)
+	if err != nil || source == nil || !reflect.DeepEqual(before, file) {
+		t.Fatal("plan did not retain unmodified complete source", err)
+	}
+	plan := source.callers["·caller"]
+	fn := file.Funcs[0]
+	if x86ABI0LogicalBoolFrameRole(fn, opt.Sigs["caller"], "386") {
+		t.Fatal("standalone source acquired a CALL role without its plan")
+	}
+	fn.x86BoolCalls = plan
+	if !x86ABI0LogicalBoolFrameRole(fn, opt.Sigs["caller"], "386") {
+		t.Fatal("actual plan lost its logical source")
+	}
+	changed := fn
+	changed.ArgSize++
+	if x86ABI0LogicalBoolFrameRole(changed, opt.Sigs["caller"], "386") {
+		t.Fatal("plan admitted a different original caller")
+	}
+	emitted := plan.signature
+	emitted.Attrs = "#0"
+	if !plan.bindLowering(file.Funcs[0], plan.signature, emitted, "386") || !plan.matches(fn, emitted, "386") {
+		t.Fatal("exact declaration/feature-attribute projection was not retained")
+	}
+	bad := emitted
+	bad.Args = []LLVMType{I8}
+	if plan.bindLowering(file.Funcs[0], plan.signature, bad, "386") || plan.matches(fn, bad, "386") {
+		t.Fatal("feature attrs projection changed actual argument transport")
+	}
+	bad = emitted
+	bad.Name = "outside"
+	if plan.bindLowering(file.Funcs[0], plan.signature, bad, "386") || plan.matches(fn, bad, "386") {
+		t.Fatal("feature attrs projection changed source symbol")
+	}
+	bad = emitted
+	bad.ArgRegs = []Reg{AX}
+	if plan.bindLowering(file.Funcs[0], plan.signature, bad, "386") || plan.matches(fn, bad, "386") {
+		t.Fatal("feature attrs projection changed ABI/native transport")
+	}
+	state := x86ResultState{boolCalls: plan, boolOutgoing: []bool{true, false, false, false, false}, boolOutgoingCanonical: []bool{true, false, false, false, false}}
+	other := state.clone()
+	other.boolOutgoingCanonical[0] = false
+	if !state.boolOutgoingCanonical[0] || state.intersect(other).boolOutgoingCanonical[0] || !state.intersect(other).boolOutgoing[0] {
+		t.Fatal("outgoing NUM/canonical domains conflated or shared mutable state")
+	}
+	// Repeating a call consumes the same independently cached readonly proof;
+	// the source graph's byte/visit envelope is not enlarged or reset.
+	bytes, visits := source.budget.bytes, source.budget.visits
+	for i := 0; i < 2; i++ {
+		if err := source.verify(); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if bytes <= 0 || visits <= 0 || source.budget.bytes != bytes || source.budget.visits != visits {
+		t.Fatal("cached leaf verification recreated its proof/budget")
+	}
+	second, err := Parse(ArchAMD64, x86ABI0BoolCallAssembly(strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "CALL ·callee(SB)\nCALL ·callee(SB)", 1), x86ABI0BoolCallLeaf))
+	if err != nil {
+		t.Fatal(err)
+	}
+	repeated, err := prepareX86ABI0BoolCalls(second, opt)
+	if err != nil || repeated.budget.bytes != bytes || repeated.budget.visits != visits {
+		t.Fatal("each call repeated the cached leaf proof", err)
+	}
+	state.gp[0], state.canonicalGP[0] = 255, 255
+	state.xmm[0], state.vectorUpper[0], state.masks[0] = 65535, ^uint64(0), true
+	state.flags = x86ByteFlagsAll
+	state.pointerGP[0], state.callerAddressGP[0] = true, true
+	state.boolFrameGP = new([16]x86ResultSlotAddress)
+	state.boolFrameGP[0] = x86ResultSlotAddress{start: 0, end: 1, valid: true}
+	var callOrdinal int
+	for ordinal := range plan.calls {
+		callOrdinal = ordinal
+	}
+	if accepted, known := x86ABI0BoolCallStep(callOrdinal, plan.function.Instrs[callOrdinal], &state, nil, 4, "386"); !accepted || !known {
+		t.Fatal("actual canonical outgoing call did not execute its typed effect")
+	}
+	if state.gp[0] != 0 || state.canonicalGP[0] != 0 || state.xmm[0] != 0 || state.vectorUpper[0] != 0 || state.masks[0] || state.flags != 0 ||
+		state.pointerGP[0] || state.callerAddressGP[0] || state.boolFrameGP[0].valid || !state.boolOutgoing[0] || !state.boolOutgoingCanonical[0] || !state.boolOutgoing[4] || !state.boolOutgoingCanonical[4] {
+		t.Fatal("CALL preserved unknown machine effects or failed to write its actual declared result")
+	}
+}
+
+const x86ABI0BoolCallBody = "MOVB x+0(FP),AX\nMOVB AX,0(SP)\nCALL ·callee(SB)\nMOVB 4(SP),AX\nMOVB AX,ret+4(FP)"
+const x86ABI0BoolCallLeaf = "LEAL x+0(FP),AX\nMOVB (AX),BX\nMOVB BX,ret+4(FP)"
+
+func TestX86ABI0Mode32CanonicalBoolSameFileCallThreeAPIs(t *testing.T) {
+	for name, row := range map[string]struct {
+		caller, callee string
+		good           bool
+	}{
+		"readonly-leaf":                  {x86ABI0BoolCallBody, x86ABI0BoolCallLeaf, true},
+		"constant-outgoing":              {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB $1,0(SP)", 1), x86ABI0BoolCallLeaf, true},
+		"two-calls":                      {strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "CALL ·callee(SB)\nCALL ·callee(SB)", 1), x86ABI0BoolCallLeaf, true},
+		"restore-raw-outgoing":           {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB $3,0(SP)\nMOVB 0(SP),AL\nTESTB AL,AL\nSETNE AL\nMOVB AL,0(SP)", 1), x86ABI0BoolCallLeaf, true},
+		"callee-result-alias":            {x86ABI0BoolCallBody, "MOVB x+0(FP),BX\nLEAL ret+4(FP),AX\nMOVB BX,(AX)", true},
+		"raw-outgoing-2":                 {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB $2,0(SP)", 1), x86ABI0BoolCallLeaf, false},
+		"raw-outgoing-3":                 {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB $3,0(SP)", 1), x86ABI0BoolCallLeaf, false},
+		"raw-outgoing-255":               {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB $255,0(SP)", 1), x86ABI0BoolCallLeaf, false},
+		"undefined-outgoing":             {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)\n", "", 1), x86ABI0BoolCallLeaf, false},
+		"padding":                        {strings.Replace(x86ABI0BoolCallBody, "0(SP)", "1(SP)", 1), x86ABI0BoolCallLeaf, false},
+		"wider-outgoing":                 {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVL AX,0(SP)", 1), x86ABI0BoolCallLeaf, false},
+		"unknown-callee":                 {strings.Replace(x86ABI0BoolCallBody, "·callee(SB)", "·outside(SB)", 1), x86ABI0BoolCallLeaf, false},
+		"internal-callee":                {strings.Replace(x86ABI0BoolCallBody, "·callee(SB)", "·callee<ABIInternal>(SB)", 1), x86ABI0BoolCallLeaf, false},
+		"callee-raw-return":              {x86ABI0BoolCallBody, "MOVB $2,ret+4(FP)", false},
+		"callee-input-write":             {x86ABI0BoolCallBody, "MOVB $0,x+0(FP)\n" + x86ABI0BoolCallLeaf, false},
+		"callee-alias-input-write":       {x86ABI0BoolCallBody, "LEAL x+0(FP),AX\nMOVB $1,(AX)\nMOVB $1,ret+4(FP)", false},
+		"callee-recursive":               {x86ABI0BoolCallBody, "CALL ·callee(SB)\nMOVB $1,ret+4(FP)", false},
+		"gp-clobber":                     {strings.Replace(x86ABI0BoolCallBody, "MOVB 4(SP),AX\n", "", 1), x86ABI0BoolCallLeaf, false},
+		"flags-clobber":                  {strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "TESTB AX,AX\nCALL ·callee(SB)\nSETNE ret+4(FP)", 1), x86ABI0BoolCallLeaf, false},
+		"mixed-outgoing":                 {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "TESTB AX,AX\nJE skip\nMOVB AX,0(SP)\nskip:", 1), x86ABI0BoolCallLeaf, false},
+		"pointer-carrier-clobber":        {strings.Replace(x86ABI0BoolCallBody, "MOVB AX,0(SP)", "MOVB AX,0(SP)\nLEAL x+0(FP),DX", 1) + "\nMOVB (DX),BX", x86ABI0BoolCallLeaf, false},
+		"result-overwrite-2":             {x86ABI0BoolCallBody + "\nMOVB $2,ret+4(FP)", x86ABI0BoolCallLeaf, false},
+		"outgoing-load-overwrites-alias": {strings.Replace(x86ABI0BoolCallBody, "CALL ·callee(SB)", "LEAL x+0(FP),DX\nMOVB 0(SP),DL\nMOVB (DX),BX\nMOVB BX,0(SP)\nCALL ·callee(SB)", 1), x86ABI0BoolCallLeaf, false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, x86ABI0BoolCallAssembly(row.caller, row.callee), x86ABI0BoolCallDeclarations, "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("complete same-file canonical call contract", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallFinalCallbacks(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, kind := range []string{"control", "source", "signature", "resolution"} {
+			if api == "Go" && kind == "signature" {
+				continue
+			} // Go derives this private map from the actual declaration.
+			t.Run(api+"/"+kind, func(t *testing.T) {
+				run := func(trigger int, mutation string) (int, bool, error) {
+					file, opt := x86ABI0BoolCallParsed(t)
+					input := []byte(x86ABI0BoolCallAssembly(x86ABI0BoolCallBody, x86ABI0BoolCallLeaf))
+					count := 0
+					opt.ResolveSym = func(symbol string) string {
+						count++
+						name := strings.TrimPrefix(symbol, "·")
+						if count == trigger {
+							switch mutation {
+							case "source":
+								if api == "Go" {
+									input[0] = 'X'
+								} else {
+									file.Funcs[1].Instrs[2].Raw += " // changed"
+								}
+							case "signature":
+								sig := opt.Sigs["callee"]
+								sig.Args = []LLVMType{I8}
+								opt.Sigs["callee"] = sig
+							case "resolution":
+								return "outside"
+							}
+						}
+						return name
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					if api == "text" {
+						ir, err := Translate(file, opt)
+						return count, ir != "", err
+					}
+					if api == "module" {
+						m, err := TranslateModuleInContext(ctx, file, opt)
+						if !m.IsNil() {
+							defer m.Dispose()
+						}
+						return count, !m.IsNil(), err
+					}
+					pkg := mustGoPackage(t, "boolcall", "package boolcall\n"+x86ABI0BoolCallDeclarations)
+					m, err := translateGoModuleInContext(ctx, pkg, input, GoModuleOptions{GOARCH: "386", TargetTriple: opt.TargetTriple, ResolveSym: opt.ResolveSym})
+					if m != nil && !m.Module.IsNil() {
+						defer m.Module.Dispose()
+					}
+					return count, m != nil, err
+				}
+				last, published, err := run(0, "")
+				if err != nil || !published || last == 0 {
+					t.Fatal("complete API baseline did not reach final source guard", last, published, err)
+				}
+				reached, published, err := run(last, kind)
+				if reached != last || kind == "control" && (err != nil || !published) || kind != "control" && (!errors.Is(err, ErrProbeNeedsContext) || published) {
+					t.Fatal("last user callback escaped original source/declaration guard", last, reached, published, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallKeepsWholeSource(t *testing.T) {
+	for _, bad := range []bool{false, true} {
+		t.Run(fmt.Sprint(bad), func(t *testing.T) {
+			leaf := x86ABI0BoolCallLeaf
+			if bad {
+				leaf = "MOVB $3,ret+4(FP)"
+			}
+			pkg := mustGoPackage(t, "boolcall", "package boolcall\n"+x86ABI0BoolCallDeclarations)
+			out, err := TranslateGoModule(pkg, []byte(x86ABI0BoolCallAssembly(x86ABI0BoolCallBody, leaf)), GoModuleOptions{
+				GOARCH: "386", TargetTriple: "i386-unknown-linux-gnu",
+				KeepFunc: func(original, _ string) bool { return original == "·caller" },
+			})
+			if out != nil {
+				defer out.Module.Dispose()
+			}
+			if !bad && (err != nil || out == nil) || bad && (!errors.Is(err, ErrProbeNeedsContext) || out != nil) {
+				t.Fatal("filter hid or removed complete callee contract", bad, err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolCallExistingFloatPredicate(t *testing.T) {
+	body := "MOVSS x+0(FP),X0\nXORPS X1,X1\nCOMISS X1,X0\nSETNE AL\nMOVB AL,0(SP)\nCALL ·callee(SB)\nMOVB 4(SP),AX\nMOVB AX,ret+4(FP)"
+	declarations := "func caller(x float32) bool\nfunc callee(x bool) bool\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86ABI0BoolCallAssembly(body, x86ABI0BoolCallLeaf), declarations, "386", "i386-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("existing typed scalar predicate lost its independently emitted feature attributes", len(ir), err)
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_frame.go b/x86_abi0_bool_frame.go
new file mode 100644
index 000000000..6cdcfe7f3
--- /dev/null
+++ b/x86_abi0_bool_frame.go
@@ -0,0 +1,279 @@
+package plan9asm
+
+import "strings"
+
+// A declared ABI0 bool must retain its physical byte until canonical RET.
+// AMD64 signatures without declared result slots keep their independent
+// register-return convention; this query grants no frame or entry permission.
+func x86ABI0BoolResultNeedsProof(sig FuncSig, arch string) bool {
+	return sig.Ret == I1 && (arch == "386" || arch == "amd64" && len(sig.Frame.Results) != 0)
+}
+
+// This lowering-only logical role extends declared bool-byte transport, not
+// SDK literal/native entry, caller backing or the direct-tail result domain.
+// Actual signature/source producers retain their independent authentication.
+func x86ABI0LogicalBoolFrameRole(fn Func, sig FuncSig, arch string) bool {
+	if x86CustomHelperBoolFrameRole(fn, sig, arch) {
+		return true // Actual root layout and a complete source/result-pointer plan.
+	}
+	if !x86ABI0BoolDeclarationRole(sig, arch) || strings.Contains(fn.Sym, "<") ||
+		fn.FrameSize != 0 && (fn.x86BoolCalls == nil || !fn.x86BoolCalls.matches(fn, sig, arch)) ||
+		len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil {
+		return false
+	}
+	if fn.ArgSize != sig.Frame.Results[0].Offset+1 {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride {
+			return false
+		}
+	}
+	return true
+}
+
+// This bounded typed-layout query grants no source, terminal or FP permission.
+// Native/borrowed target roles are not independent logical bool declarations.
+func x86ABI0BoolDeclarationRole(sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" || sig.Ret != I1 || len(sig.ArgRegs) != 0 || len(sig.Frame.Results) != 1 || sig.ARMEntry != nil ||
+		sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative || sig.x86BorrowedBoolTail {
+		return false
+	}
+	result := sig.Frame.Results[0]
+	if result.Type != I1 || result.Index != 0 || result.Field != -1 || len(result.Fields) != 0 ||
+		result.Offset < 0 || result.Offset >= 4096 || len(sig.Frame.Params) > 4096 || len(sig.Args) > 4096 {
+		return false
+	}
+	represented := make(map[int]bool)
+	roles := make(map[string]bool)
+	occupied := make([]bool, result.Offset)
+	for _, slot := range sig.Frame.Params {
+		width := x86FrameScalarBytes(slot.Type, arch)
+		if width <= 0 || slot.Offset < 0 || slot.Offset > result.Offset-width {
+			return false
+		}
+		role, valid := x86ResultParameterRole(sig.Args, slot)
+		if !valid || roles[role] {
+			return false
+		}
+		roles[role] = true
+		represented[slot.Index] = true
+		for offset := slot.Offset; offset < slot.Offset+width; offset++ {
+			if occupied[offset] {
+				return false
+			}
+			occupied[offset] = true
+		}
+	}
+	return len(represented) == len(sig.Args)
+}
+
+func x86ABI0BoolFrameAliasNeeded(fn Func, arch string) bool {
+	lea := Op("LEAQ")
+	if arch == "386" {
+		lea = "LEAL"
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == lea && len(ins.Args) == 2 && ins.Args[0].Kind == OpFP {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ABI0BoolFrameSlot(state *x86ResultState, offset, width int64, arch string) (FrameSlot, bool) {
+	for _, slot := range state.boolFrameSlots {
+		size := x86FrameScalarBytes(slot.Type, arch)
+		if width > 0 && offset >= slot.Offset && offset <= slot.Offset+size-width {
+			return slot, true
+		}
+	}
+	return FrameSlot{}, false
+}
+
+// Input stores alter the existing private logical parameter copy, not caller
+// memory. A physical bool byte can hold a numeric intermediate until RET; it
+// must not be normalized to I1 merely by a read or write of the shadow slot.
+func x86ABI0BoolFrameNUMTransfer(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64,
+	arch string, transfer x86ResultSourceTransfer) bool {
+	if state.boolReadonlyInputs {
+		for index, arg := range ins.Args {
+			if arg.Kind == OpFP && arg.FPOffset < resultOffset {
+				_, write, known := x86InstructionMemoryShape(ins, index, arch)
+				if !known || write {
+					return false
+				}
+			}
+		}
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil &&
+		form.destination.Kind == OpFP && form.destination.FPOffset < resultOffset {
+		if slot, valid := x86ABI0BoolFrameSlot(state, form.destination.FPOffset, 1, arch); valid && slot.Type == I1 {
+			required := x86ByteConditionFlags(form.condition)
+			if required != 0 && state.flags&required == required {
+				state.fp[form.destination.FPOffset] = true
+				return true
+			}
+		}
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpFP && ins.Args[1].FPOffset < resultOffset {
+		width := x86RawReturnScalarMoveBytes(ins.Op)
+		if slot, valid := x86ABI0BoolFrameSlot(state, ins.Args[1].FPOffset, width, arch); valid && slot.Type == I1 && width == 1 &&
+			(ins.Args[0].Kind == OpImm || ins.Args[0].Kind == OpReg) && x86ResultRead(ins.Args[0], width, state, owned, arch) {
+			state.fp[ins.Args[1].FPOffset] = true
+			return true
+		}
+	}
+	return transfer(ordinal, ins, state, owned, resultOffset, arch)
+}
+
+func x86ABI0BoolFrameTransfer(ordinal int, original Instr, state *x86ResultState, owned []bool, resultOffset int64,
+	arch string, transfer x86ResultSourceTransfer) bool {
+	ins := x86SourceMoveInstruction(original, arch)
+	if accepted, known := x86ABI0BoolCallStep(ordinal, ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	aliases := state.boolFrameGP
+	word := x86ResultPointerWord(arch)
+	lea, move := Op("LEAQ"), Op("MOVQ")
+	if arch == "386" {
+		lea, move = "LEAL", "MOVL"
+	}
+	alias := func(arg Operand) x86ResultSlotAddress {
+		if aliases != nil && arg.Kind == OpReg {
+			if root, _, valid := x86ResultGP(arg.Reg, word, arch); valid {
+				return aliases[root]
+			}
+		}
+		return x86ResultSlotAddress{}
+	}
+	writeAlias := func(destination Operand, value x86ResultSlotAddress) bool {
+		root, _, valid := x86ResultGP(destination.Reg, word, arch)
+		if aliases == nil || destination.Kind != OpReg || !valid || root == 4 || root == 5 || !value.valid {
+			return false
+		}
+		aliases[root] = value
+		state.gp[root], state.canonicalGP[root] = 0, 0
+		state.pointerGP[root], state.callerAddressGP[root] = false, false
+		return true
+	}
+	if len(ins.Args) == 2 {
+		first, last := ins.Args[0], ins.Args[1]
+		if ins.Op == lea && first.Kind == OpFP {
+			if width, err := x86LEAOperandWidth(ins, arch); err != nil || width != word {
+				return false
+			}
+			slot, valid := x86ABI0BoolFrameSlot(state, first.FPOffset, 1, arch)
+			return valid && writeAlias(last, x86ResultSlotAddress{start: slot.Offset, end: slot.Offset + x86FrameScalarBytes(slot.Type, arch), offset: first.FPOffset, valid: true})
+		}
+		if ins.Op == move {
+			if value := alias(first); value.valid {
+				return writeAlias(last, value)
+			}
+		}
+		if ins.Op == lea && first.Kind == OpMem {
+			if value := alias(Operand{Kind: OpReg, Reg: first.Mem.Base}); value.valid {
+				if width, err := x86LEAOperandWidth(ins, arch); err != nil || width != word || !x86ResultSlotMemory(first.Mem) ||
+					first.Mem.Off < value.start-value.offset || first.Mem.Off >= value.end-value.offset {
+					return false
+				}
+				value.offset += first.Mem.Off
+				return writeAlias(last, value)
+			}
+		}
+	}
+	local := original
+	local.Args = append([]Operand(nil), original.Args...)
+	projected := false
+	for index, arg := range ins.Args {
+		if arg.Kind == OpMem {
+			value := alias(Operand{Kind: OpReg, Reg: arg.Mem.Base})
+			if alias(Operand{Kind: OpReg, Reg: arg.Mem.Index}).valid {
+				return false
+			}
+			if !value.valid && !state.shapeOnly {
+				continue
+			}
+			width, write, known := x86InstructionMemoryShape(ins, index, arch)
+			move := x86RawReturnScalarMoveBytes(ins.Op) != 0
+			_, extension, extensionErr := x86ScalarExtensionProperties(ins.Op, ins, arch)
+			_, conditional, conditionalErr := x86ConditionalSetProperties(ins.Op, ins, arch)
+			if aliases == nil || !known || width <= 0 || width > word || !x86ResultSlotMemory(arg.Mem) ||
+				!(move || extension && extensionErr == nil || conditional && conditionalErr == nil) {
+				if value.valid {
+					return false
+				}
+				continue
+			}
+			if !conditional {
+				if len(ins.Args) != 2 {
+					return false
+				}
+				other := ins.Args[1-index]
+				if other.Kind != OpReg && !(index == 1 && other.Kind == OpImm) {
+					return false // A projection never invents a memory-to-memory row.
+				}
+			}
+			if state.shapeOnly && !value.valid {
+				for _, slot := range state.boolFrameSlots {
+					if state.boolReadonlyInputs && write && slot.Offset < resultOffset {
+						continue
+					}
+					if write && slot.Offset < resultOffset && slot.Type != I1 {
+						continue // A numerical input cannot represent a writable bool/result byte.
+					}
+					if size := x86FrameScalarBytes(slot.Type, arch); size >= width {
+						value = x86ResultSlotAddress{start: slot.Offset, end: slot.Offset + size, offset: slot.Offset, valid: true}
+						break
+					}
+				}
+			} else if arg.Mem.Off >= value.start-value.offset && arg.Mem.Off <= value.end-value.offset-width {
+				value.offset += arg.Mem.Off
+			} else {
+				return false
+			}
+			if !value.valid {
+				return false
+			}
+			local.Args[index] = Operand{Kind: OpFP, FPOffset: value.offset}
+			projected = true
+		}
+		if alias(arg).valid && !x86ResultSlotOverwrite(ins, index, arch) {
+			return false // No numerical observation, address return or escape.
+		}
+	}
+	beforeFP, beforeGP := append([]bool(nil), state.canonicalFP...), state.canonicalGP
+	var unprojected x86ResultState
+	if state.shapeOnly && projected {
+		unprojected = state.clone()
+	}
+	if !x86ABI0BoolFrameNUMTransfer(ordinal, local, state, owned, resultOffset, arch, transfer) {
+		// A shape-only unknown base can be a logical alias or an incoming
+		// pointer. If no logical slot represents its width, validate the
+		// original instruction through the supplied transfer instead. This
+		// disposable state never reaches a CFG edge; an actual alias still
+		// requires its exact FP projection and cannot take this alternative.
+		if unprojected.shapeOnly && transfer(ordinal, original, &unprojected, owned, resultOffset, arch) {
+			*state = unprojected
+			return true
+		}
+		return false
+	}
+	state.canonicalFP, state.canonicalGP = x86ABI0CanonicalBytesAfter(local, beforeFP, beforeGP, arch)
+	// The paired lowering transfer may publish a cloned NUM state. Revoke the
+	// aliases in that actual successor, never the pre-transfer array pointer.
+	aliases = state.boolFrameGP
+	if aliases != nil {
+		var live [16]bool
+		for root, value := range aliases {
+			live[root] = value.valid
+		}
+		live = x86ResultCallerAddressesAfter(ins, live, nil, arch)
+		for root := range aliases {
+			if !live[root] {
+				aliases[root] = x86ResultSlotAddress{}
+			}
+		}
+	}
+	return true
+}
diff --git a/x86_abi0_bool_frame_join_test.go b/x86_abi0_bool_frame_join_test.go
new file mode 100644
index 000000000..37b3fc953
--- /dev/null
+++ b/x86_abi0_bool_frame_join_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"testing"
+)
+
+// Reuse the complete previously supported fixture, including all its inputs,
+// direct/aliased stores and same-file caller. No Go assembler/object or runtime
+// command runs here; this is the three public APIs' logical translation axis.
+func TestX86ABI0Mode32CanonicalBoolExistingWholeFrameThreeAPIs(t *testing.T) {
+	const declarations = `func ReadByte(x bool) uint8
+func WriteParam(x bool) bool
+func WriteResult(x bool) bool
+func WriteDirect(x bool) bool
+func BoolCallee(x bool) bool
+func BoolCaller(x bool) bool
+func BoolField(p struct { Pad uint8; Flag bool }) bool
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86BoolFrameSource("386"), declarations, "386", "i386-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("previous complete logical bool frame lost its existing typed input/alias/call role", len(ir), err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolTypedInputAndPrivateAlias(t *testing.T) {
+	for name, row := range map[string]struct {
+		declaration string
+		body        string
+		args        int
+		good        bool
+	}{
+		"direct-input":              {"func view(x bool) bool", "MOVB x+0(FP),AX\nMOVB AX,ret+4(FP)", 5, true},
+		"aggregate-input":           {"func view(p struct{ Pad byte; Flag bool }) bool", "MOVB p_flag+1(FP),AX\nMOVB AX,ret+4(FP)", 5, true},
+		"direct-parameter-store":    {"func view(x bool) bool", "MOVB $0,x+0(FP)\nMOVB x+0(FP),AX\nMOVB AX,ret+4(FP)", 5, true},
+		"alias-input-store":         {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVB $1,(AX)\nMOVB x+0(FP),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-input-read":          {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVB (AX),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-result-store":        {"func view(x bool) bool", "MOVB x+0(FP),BX\nLEAL ret+4(FP),AX\nMOVB BX,(AX)", 5, true},
+		"alias-copy":                {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVL AX,DX\nMOVB (DX),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-affine-copy":         {"func view(x bool) bool", "LEAL x+0(FP),AX\nLEAL 0(AX),DX\nMOVB (DX),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-byte-extension":      {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVBLZX (AX),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-set-input":           {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVL $1,BX\nTESTL BX,BX\nSETNE (AX)\nMOVB x+0(FP),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"direct-raw-read-restore":   {"func view(x bool) bool", "MOVB $2,x+0(FP)\nMOVBLZX x+0(FP),AX\nTESTL AX,AX\nSETNE ret+4(FP)", 5, true},
+		"alias-raw-read-restore":    {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVB $3,(AX)\nMOVB (AX),BX\nTESTB BX,BX\nSETNE ret+4(FP)", 5, true},
+		"numeric-input-is-not-bool": {"func view(x byte) bool", "MOVB x+0(FP),AX\nMOVB AX,ret+4(FP)", 5, false},
+		"parameter-raw-overwrite":   {"func view(x bool) bool", "MOVB $2,x+0(FP)\nMOVB x+0(FP),AX\nMOVB AX,ret+4(FP)", 5, false},
+		"alias-raw-overwrite":       {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVB $3,(AX)\nMOVB (AX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-partial-copy":        {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVW AX,DX\nMOVB (DX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-outside-slot":        {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVB 1(AX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-affine-escape":       {"func view(x bool) bool", "LEAL x+0(FP),AX\nLEAL 1(AX),DX\nMOVB (DX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-wider-read":          {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVWLZX (AX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-set-unknown-flags":   {"func view(x bool) bool", "LEAL x+0(FP),AX\nSETNE (AX)\nMOVB x+0(FP),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-result-escape":       {"func view() bool", "LEAL ret+0(FP),AX\nMOVL AX,ret+0(FP)", 1, false},
+		"alias-all-predecessors":    {"func view(x bool) bool", "MOVL $1,CX\nTESTL CX,CX\nJE other\nLEAL x+0(FP),AX\nJMP joined\nother:\nLEAL x+0(FP),AX\njoined:\nMOVB (AX),BX\nMOVB BX,ret+4(FP)", 5, true},
+		"alias-mixed-predecessors":  {"func view(x bool) bool", "MOVL $1,CX\nTESTL CX,CX\nJE other\nLEAL x+0(FP),AX\nJMP joined\nother:\nLEAL ret+4(FP),AX\njoined:\nMOVB (AX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"alias-overwritten":         {"func view(x bool) bool", "LEAL x+0(FP),AX\nMOVL $0,AX\nMOVB (AX),BX\nMOVB BX,ret+4(FP)", 5, false},
+		"numeric-input-normalized":  {"func view(x byte) bool", "MOVB x+0(FP),AL\nANDB $1,AL\nMOVB AL,ret+4(FP)", 5, true},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\nRET\n", row.args, row.body), row.declaration+"\n", "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("typed logical bool input/private alias contract differs", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolParameterRawBytesRemainPhysical(t *testing.T) {
+	logical := regexp.MustCompile(`trunc i8 [^\n]+ to i1\b`)
+	for _, raw := range []int{2, 3, 255} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%d/%s", raw, api), func(t *testing.T) {
+				body := fmt.Sprintf("TEXT ·view(SB),4,$0-5\nMOVB $%d,x+0(FP)\nMOVB x+0(FP),AL\nTESTB AL,AL\nSETNE ret+4(FP)\nRET\n", raw)
+				ir, err := x86ScalarFPBitViewAPI(t, body, "func view(x bool) bool\n", "386", "i386-unknown-linux-gnu", api)
+				if err != nil || ir == "" || len(logical.FindAllString(ir, -1)) != 1 {
+					t.Fatal("mutable logical bool parameter normalized a physical raw intermediate before RET", err, ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolAliasCloneJoinAndBudget(t *testing.T) {
+	first := x86ResultState{canonicalFP: []bool{true}, fp: []bool{true}, boolFrameGP: new([16]x86ResultSlotAddress)}
+	first.boolFrameGP[0] = x86ResultSlotAddress{start: 0, end: 1, valid: true}
+	second := first.clone()
+	second.boolFrameGP[0].offset = 1
+	if first.boolFrameGP[0].offset != 0 {
+		t.Fatal("mutable alias states shared a clone")
+	}
+	if joined := first.intersect(second); joined.boolFrameGP[0].valid || !joined.fp[0] || !joined.canonicalFP[0] {
+		t.Fatal("mixed slot aliases acquired a must-origin or altered independent NUM/canonical facts")
+	}
+	if joined := first.intersect(x86ResultState{fp: []bool{true}, canonicalFP: []bool{true}}); joined.boolFrameGP[0].valid {
+		t.Fatal("an absent alias domain invented a declared-slot address")
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\nLEAL ret+0(FP),AX\nMOVB $1,(AX)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// One FP byte, one independent canonical byte and sixteen slot aliases
+	// supplement the complete ordinary state, including native MMX.
+	const payload = x86IndependentResultBasePayload + 2 + 16*25
+	const limit = (64 << 20) / 8
+	for _, room := range []int{3*payload - 1, 3 * payload} {
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = &x86ResultFlowBudget{bytes: limit - room}
+		err := checkX86ScalarFPResultInitialization(fn, x86SDKLiteral386Signature(), "386")
+		visits := 0
+		if room == 3*payload {
+			visits = 3
+		}
+		if fn.x86ResultFlowBudget.visits != visits || fn.x86ResultFlowBudget.bytes != limit+3*payload-room+8*payload*visits {
+			t.Fatal("bool alias source work differs from its exact complete-state charge", fn.x86ResultFlowBudget.bytes)
+		}
+		if room == 3*payload && err != nil || room != 3*payload && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("logical alias state escaped the shared byte budget", room, err)
+		}
+	}
+}
diff --git a/x86_abi0_bool_parameter_roles_test.go b/x86_abi0_bool_parameter_roles_test.go
new file mode 100644
index 000000000..b4729c2f8
--- /dev/null
+++ b/x86_abi0_bool_parameter_roles_test.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestX86ABI0Mode32CanonicalBoolKeepsExistingScalarInputRoles(t *testing.T) {
+	for _, row := range []struct {
+		name, declaration, source string
+		good                      bool
+	}{
+		{"opaque-pointer-predicate", "func view(p *byte) bool", "TEXT ·view(SB),4,$0-5\nMOVL p+0(FP),AX\nMOVL AX,BX\nTESTL $15,BX\nSETEQ ret+4(FP)\nRET\n", true},
+		{"float-existing-typed-effect", "func view(x float32) bool", "TEXT ·view(SB),4,$0-5\nMOVSS x+0(FP),X0\nXORPS X1,X1\nCOMISS X1,X0\nSETNE ret+4(FP)\nRET\n", true},
+		{"opaque-pointer-not-numeric", "func view(p *byte) bool", "TEXT ·view(SB),4,$0-5\nMOVL p+0(FP),AX\nMOVB AX,ret+4(FP)\nRET\n", false},
+		{"float-not-canonical", "func view(x float32) bool", "TEXT ·view(SB),4,$0-5\nMOVL x+0(FP),AX\nMOVB AX,ret+4(FP)\nRET\n", false},
+		{"missing-float-byte", "func view(x float32) bool", "TEXT ·view(SB),4,$0-5\nMOVB x+0(FP),AX\nMOVL AX,X0\nXORPS X1,X1\nCOMISS X1,X0\nSETNE ret+4(FP)\nRET\n", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration+"\n", "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("canonical bool contract replaced the independent scalar input/effect role", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_abi0_bool_result.go b/x86_abi0_bool_result.go
new file mode 100644
index 000000000..474114f8f
--- /dev/null
+++ b/x86_abi0_bool_result.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import "strings"
+
+// The first ABI0 bool-byte role is a complete 386 no-argument/zero-frame
+// declaration. Neither this shape query nor its canonical facts authenticate a
+// source, initialize numerical bytes, grant FP backing or describe native entry.
+func x86ABI0SingleByteBoolResultRole(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" || strings.Contains(fn.Sym, "<") || fn.FrameSize != 0 || fn.ArgSize != 1 ||
+		sig.Ret != I1 || len(sig.Args) != 0 || len(sig.ArgRegs) != 0 || len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 1 ||
+		sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative ||
+		len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil {
+		return false
+	}
+	result := sig.Frame.Results[0]
+	return result.Type == I1 && result.Offset == 0 && result.Index == 0 && result.Field == -1 && len(result.Fields) == 0
+}
+
+// NUM reads and stores see the complete physical ABI0 byte. Only RET consumes
+// the logical i1 after the cached complete canonical result proof. The separate
+// physical source-stack seal has its own checked byte-storage handoff; it never
+// changes the public logical role. Other bool/frame roles remain unchanged.
+func (c *amd64Ctx) abi0BoolResultByteStorage() bool {
+	if !c.fpScalarChecked || c.fpScalarCheckErr != nil {
+		return false
+	}
+	if c.fpMixedBoolBytes {
+		return true
+	}
+	if stack := c.sourceStack; stack != nil && stack == c.fpScalarSource.x86SourceStack && stack.scalarResult != nil && c.sig.Ret == I1 {
+		return true // The independent physical producer/consumer already checked its complete byte role.
+	}
+	return x86ABI0LogicalBoolFrameRole(c.fpScalarSource, c.sig, c.goarch)
+}
+
+func x86ABI0CanonicalBoolTransfer(transfer x86ResultSourceTransfer) x86ResultSourceTransfer {
+	return func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		if isX86RawDirective(ins) {
+			return false
+		}
+		if !x86ABI0BoolFrameTransfer(ordinal, ins, state, owned, resultOffset, arch, transfer) {
+			return false
+		}
+		for offset := range state.canonicalFP {
+			state.canonicalFP[offset] = offset < len(state.fp) && state.canonicalFP[offset] && state.fp[offset]
+		}
+		for index := range state.canonicalGP {
+			state.canonicalGP[index] &= state.gp[index]
+		}
+		return true
+	}
+}
+
+// Canonicality is independent of NUM initialization. The consumer must first
+// execute its complete typed transfer, then intersect these byte facts with
+// initialized bytes. Only actual declared slots allocate this bounded FP state.
+func x86ABI0CanonicalBytesAfter(original Instr, beforeFP []bool, beforeGP [16]uint8, arch string) ([]bool, [16]uint8) {
+	ins := x86SourceMoveInstruction(original, arch)
+	nextFP := append([]bool(nil), beforeFP...)
+	nextGP := x86RegisterCanonicalBytesAfter(original, beforeGP, arch)
+	read := func(operand Operand, width int64) uint8 {
+		if width <= 0 || width > 8 {
+			return 0
+		}
+		switch operand.Kind {
+		case OpImm:
+			if operand.ImmRaw == "" && !operand.ImmIsFloat {
+				return fixedLocalConstantBooleans(operand.Imm, width)
+			}
+		case OpReg:
+			if root, _, valid := x86ResultGP(operand.Reg, width, arch); valid {
+				return beforeGP[root] >> fixedLocalBooleanShift(operand.Reg) & uint8((uint16(1)<<uint(width))-1)
+			}
+		case OpFP:
+			if operand.FPOffset >= 0 && operand.FPOffset <= int64(len(beforeFP))-width {
+				var bits uint8
+				for index := int64(0); index < width; index++ {
+					if beforeFP[operand.FPOffset+index] {
+						bits |= 1 << uint(index)
+					}
+				}
+				return bits
+			}
+		}
+		return 0
+	}
+	writeFP := func(operand Operand, width int64, bits uint8) {
+		if operand.Kind != OpFP || operand.FPOffset < 0 || width <= 0 || operand.FPOffset > int64(len(nextFP))-width {
+			return
+		}
+		for index := int64(0); index < width; index++ {
+			nextFP[operand.FPOffset+index] = bits&(1<<uint(index)) != 0
+		}
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil {
+		writeFP(form.destination, 1, 1)
+		return nextFP, nextGP
+	}
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width > 0 && len(ins.Args) == 2 {
+		bits := read(ins.Args[0], width)
+		writeFP(ins.Args[1], width, bits)
+		if ins.Args[0].Kind == OpFP && ins.Args[1].Kind == OpReg {
+			if root, mask, valid := x86ResultGP(ins.Args[1].Reg, width, arch); valid {
+				bits <<= fixedLocalBooleanShift(ins.Args[1].Reg)
+				nextGP[root] = nextGP[root]&^mask | bits&mask
+			}
+		}
+		return nextFP, nextGP
+	}
+	if form, known, err := x86ScalarExtensionProperties(ins.Op, ins, arch); known && err == nil && form.source.Kind == OpFP {
+		from, to := int64(form.spec.sourceBits/8), int64(form.spec.destinationBits/8)
+		bits := read(form.source, from)
+		if !form.spec.signed || bits&(1<<uint(from-1)) != 0 {
+			for index := from; index < to; index++ {
+				bits |= 1 << uint(index)
+			}
+		}
+		if root, mask, valid := x86ResultGP(form.result, to, arch); valid {
+			if to == 4 && arch == "amd64" {
+				mask, bits = 255, bits|240
+			}
+			nextGP[root] = nextGP[root]&^mask | bits&mask
+		}
+		return nextFP, nextGP
+	}
+	// Unknown numeric/vector/mask values never become canonical. The shared
+	// exact memory-shape registry accounts for every possible typed FP write.
+	for index, operand := range ins.Args {
+		if operand.Kind != OpFP {
+			continue
+		}
+		width, write, known := x86InstructionMemoryShape(ins, index, arch)
+		if known && write {
+			writeFP(operand, width, 0)
+		} else if !known {
+			for offset := range nextFP {
+				nextFP[offset] = false
+			}
+		}
+	}
+	return nextFP, nextGP
+}
diff --git a/x86_abi0_bool_result_test.go b/x86_abi0_bool_result_test.go
new file mode 100644
index 000000000..9e165f993
--- /dev/null
+++ b/x86_abi0_bool_result_test.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"testing"
+)
+
+func TestX86ABI0Mode32CanonicalBoolByteResult(t *testing.T) {
+	for _, condition := range amd64RegisterBoolConditions {
+		t.Run(condition, func(t *testing.T) {
+			checkMode32CanonicalBool(t, "MOVL $1,AX\nTESTL AX,AX\n"+condition+" ret+0(FP)", true)
+		})
+	}
+	for _, body := range []string{
+		"MOVB $0,ret+0(FP)",
+		"MOVB $1,ret+0(FP)",
+		"MOVB $1,AL\nMOVB AL,ret+0(FP)",
+		"MOVB $1,ret+0(FP)\nMOVB ret+0(FP),AL\nMOVB AL,ret+0(FP)",
+		"MOVB $2,ret+0(FP)\nMOVBLZX ret+0(FP),AX\nTESTL AX,AX\nSETEQ ret+0(FP)",
+		"MOVB $3,ret+0(FP)\nMOVBLZX ret+0(FP),AX\nTESTL AX,AX\nSETNE ret+0(FP)",
+		"MOVB $2,ret+0(FP)\nMOVB $1,ret+0(FP)",
+		"MOVL $2,AX\nTESTL AX,AX\nJE other\nMOVB $0,ret+0(FP)\nJMP finish\nother:\nMOVB $1,ret+0(FP)\nfinish:",
+	} {
+		checkMode32CanonicalBool(t, body, true)
+	}
+}
+
+func TestX86ABI0Mode32BoolThreeAPIsCannotBypassCanonicalProof(t *testing.T) {
+	for _, raw := range []int{2, 3, 255} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%d/%s", raw, api), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-1\nMOVB $%d,ret+0(FP)\nRET\n", raw)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() bool\n", "386", "i386-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("initialized noncanonical byte escaped the no-probe bool entry guard", len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32BoolIntermediateBytesSurviveThreeAPIs(t *testing.T) {
+	logicalTruncation := regexp.MustCompile(`trunc i8 [^\n]+ to i1\b`)
+	for _, raw := range []int{2, 3, 255} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%d/%s", raw, api), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-1\nMOVB $%d,ret+0(FP)\nMOVBLZX ret+0(FP),AX\nTESTL AX,AX\nSETNE ret+0(FP)\nRET\n", raw)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view() bool\n", "386", "i386-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Fatal("raw initialized byte could not be used before canonical restoration", err)
+				}
+				if count := len(logicalTruncation.FindAllString(ir, -1)); count != 1 {
+					t.Fatal("a numeric bool-slot read/store normalized the physical byte before RET", count, ir)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32BoolWholeCFGAndOverwriteThreeAPIs(t *testing.T) {
+	for name, row := range map[string]struct {
+		body string
+		good bool
+	}{
+		"raw-read-byte-restore":      {"MOVB $255,ret+0(FP)\nMOVB ret+0(FP),AL\nTESTB AL,AL\nSETNE ret+0(FP)", true},
+		"raw-overwrite-restore":      {"MOVB $2,ret+0(FP)\nMOVB $0,ret+0(FP)", true},
+		"high-byte-canonical-copy":   {"MOVB $1,AH\nMOVB AH,ret+0(FP)", true},
+		"all-predecessors-canonical": {"MOVB $3,ret+0(FP)\nMOVL $1,AX\nTESTL AX,AX\nJE other\nMOVB $0,ret+0(FP)\nJMP end\nother:\nSETNE ret+0(FP)\nend:", true},
+		"one-predecessor-raw":        {"MOVL $1,AX\nTESTL AX,AX\nJE other\nMOVB $1,ret+0(FP)\nJMP end\nother:\nMOVB $3,ret+0(FP)\nend:", false},
+		"canonical-slot-overwritten": {"MOVB $1,ret+0(FP)\nMOVB $255,AL\nMOVB AL,ret+0(FP)", false},
+		"raw-copy-is-not-canonical":  {"MOVB $2,ret+0(FP)\nMOVB ret+0(FP),AL\nMOVB AL,ret+0(FP)", false},
+		"unknown-upper-byte":         {"MOVB $1,AL\nMOVB AH,ret+0(FP)", false},
+		"undeclared-slot":            {"MOVB $1,ret+1(FP)\nMOVB $1,ret+0(FP)", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-1\n"+row.body+"\nRET\n", "func view() bool\n", "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("whole-source canonical slot/CFG gate was bypassed", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolRoleAndSourceIdentity(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\nMOVB $1,ret+0(FP)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, sig := file.Funcs[0], x86SDKLiteral386Signature()
+	before, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\nMOVB $1,ret+0(FP)\nRET\n")
+	if err != nil || checkX86ScalarFPResultInitialization(fn, sig, "386") != nil || !reflect.DeepEqual(file, before) {
+		t.Fatal("canonical proof rewrote original Op/Raw/source identities", err)
+	}
+	for name, mutate := range map[string]func(*Func, *FuncSig){
+		"argument":        func(_ *Func, sig *FuncSig) { sig.Args = []LLVMType{I8} },
+		"arg-register":    func(_ *Func, sig *FuncSig) { sig.ArgRegs = []Reg{AX} },
+		"parameter":       func(_ *Func, sig *FuncSig) { sig.Frame.Params = []FrameSlot{{Type: I8}} },
+		"frame":           func(fn *Func, _ *FuncSig) { fn.FrameSize = 8 },
+		"unknown-argsize": func(fn *Func, _ *FuncSig) { fn.ArgSize = -1 },
+		"internal":        func(fn *Func, _ *FuncSig) { fn.Sym = "·entry<ABIInternal>" },
+		"multiple-results": func(_ *Func, sig *FuncSig) {
+			sig.Frame.Results = append(sig.Frame.Results, FrameSlot{Type: I1, Offset: 1})
+		},
+		"result-offset": func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Offset = 1 },
+		"result-index":  func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Index = 1 },
+		"result-field":  func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Field = 0 },
+		"result-type":   func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Type = I8 },
+		"wasm":          func(_ *Func, sig *FuncSig) { sig.WASMNative = true },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn, sig := fn, sig
+			sig.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+			mutate(&fn, &sig)
+			if x86ABI0SingleByteBoolResultRole(fn, sig, "386") || !errors.Is(checkX86ScalarFPResultInitialization(fn, sig, "386"), ErrProbeNeedsContext) {
+				t.Fatal("shape query borrowed a different argument/frame/result role")
+			}
+		})
+	}
+	for _, arch := range []string{"amd64", "arm", "arm64", "wasm", ""} {
+		if x86ABI0SingleByteBoolResultRole(fn, sig, arch) {
+			t.Fatal("386 bool byte invented another architecture's transport", arch)
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalFPCloneJoinAndBudget(t *testing.T) {
+	first := x86ResultState{fp: []bool{true}, canonicalFP: []bool{true}}
+	second := first.clone()
+	second.canonicalFP[0] = false
+	if !first.canonicalFP[0] || !second.fp[0] {
+		t.Fatal("canonical clone aliased its origin or erased NUM initialization")
+	}
+	joined := first.intersect(second)
+	if !joined.fp[0] || joined.canonicalFP[0] {
+		t.Fatal("CFG join merged canonicality with NUM initialization")
+	}
+	if missing := first.intersect(x86ResultState{fp: []bool{true}}); missing.canonicalFP[0] {
+		t.Fatal("a predecessor missing its canonical role invented a bool byte")
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\nMOVB $1,ret+0(FP)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const limit = (64 << 20) / 8
+	// Ordinary state includes every independent domain, including native MMX.
+	// One FP byte and its separately allocated canonical result byte each
+	// count exactly once, without changing the shared limit.
+	const ordinary = x86IndependentResultBasePayload + 1
+	for _, room := range []int{2*(ordinary+1) - 1, 2 * (ordinary + 1)} {
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = &x86ResultFlowBudget{bytes: limit - room}
+		err := checkX86ScalarFPResultInitialization(fn, x86SDKLiteral386Signature(), "386")
+		visits := 0
+		if room == 2*(ordinary+1) {
+			visits = 2
+		}
+		if fn.x86ResultFlowBudget.visits != visits || fn.x86ResultFlowBudget.bytes != limit+2*(ordinary+1)-room+8*(ordinary+1)*visits {
+			t.Fatal("canonical source work differs from its exact complete-state charge", fn.x86ResultFlowBudget.bytes)
+		}
+		if room == 2*(ordinary+1) && err != nil || room != 2*(ordinary+1) && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("canonical FP state received unaccounted extra source work", room, err)
+		}
+	}
+}
+
+func TestX86ABI0Mode32BoolPreflightUsesOneBoundedWholeProof(t *testing.T) {
+	for _, raw := range []int{1, 2} {
+		file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT ·entry(SB),4,$0-1\nMOVB $%d,ret+0(FP)\nRET\n", raw))
+		if err != nil {
+			t.Fatal(err)
+		}
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = &x86ResultFlowBudget{}
+		sig := x86SDKLiteral386Signature()
+		consumer := &amd64Ctx{fpScalarSource: fn, sig: sig, fpResults: sig.Frame.Results, goarch: "386"}
+		first := consumer.validateScalarFPSourceViews()
+		used := *fn.x86ResultFlowBudget
+		second := consumer.validateScalarFPSourceViews()
+		if !consumer.fpScalarChecked || first != second || used != *fn.x86ResultFlowBudget || used.visits == 0 {
+			t.Fatal("bool preflight omitted or repeated its bounded whole-source proof", first, second, used, fn.x86ResultFlowBudget)
+		}
+		if raw == 1 && (first != nil || !consumer.abi0BoolResultByteStorage()) || raw == 2 && (!errors.Is(first, ErrProbeNeedsContext) || consumer.abi0BoolResultByteStorage()) {
+			t.Fatal("physical I8 handling was detached from canonical whole-return validation", raw, first)
+		}
+	}
+}
+
+func TestX86ABI0Mode32InitializedByteIsNotCanonicalBool(t *testing.T) {
+	for _, value := range []int{2, 3, 255} {
+		t.Run(fmt.Sprint(value), func(t *testing.T) {
+			body := fmt.Sprintf("MOVB $%d,ret+0(FP)", value)
+			file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\n"+body+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], x86SDKLiteral386Signature(), "386"); err != nil {
+				t.Fatal("raw numerical byte is initialized independently of canonicality", err)
+			}
+			checkMode32CanonicalBool(t, body, false)
+		})
+	}
+	for _, body := range []string{
+		"MOVB $2,AL\nMOVB AL,ret+0(FP)",
+		"MOVL $1,AX\nTESTL AX,AX\nSETEQ ret+0(FP)\nMOVB $2,ret+0(FP)",
+		"MOVL $1,AX\nTESTL AX,AX\nJE other\nMOVB $1,ret+0(FP)\nJMP finish\nother:\nMOVB $2,ret+0(FP)\nfinish:",
+		"MOVB $1,AH\nMOVB AL,ret+0(FP)",
+		"MOVB $1,AL\nMOVL AX,ret+0(FP)",
+		"SETEQ ret+0(FP)",
+	} {
+		checkMode32CanonicalBool(t, body, false)
+	}
+}
+
+func checkMode32CanonicalBool(t *testing.T, body string, accepted bool) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-1\n"+body+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = checkX86ScalarFPResultInitialization(file.Funcs[0], x86SDKLiteral386Signature(), "386")
+	if accepted && err != nil || !accepted && !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("canonical bool-byte result accepted=%v body=%s: %v", accepted, body, err)
+	}
+}
+
+func TestX86ABI0Mode32CanonicalFactDomainIsIndependent(t *testing.T) {
+	for _, raw := range []int{0, 1, 2, 3, 255} {
+		t.Run(fmt.Sprint(raw), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT ·entry(SB),4,$0-1\nMOVB $%d,ret+0(FP)\nMOVBLZX ret+0(FP),AX\nTESTL AX,AX\nSETEQ ret+0(FP)\nRET\n", raw))
+			if err != nil {
+				t.Fatal(err)
+			}
+			numeric := x86ResultState{fp: []bool{false}}
+			canonicalFP, canonicalGP := []bool{false}, [16]uint8{}
+			for ordinal, ins := range file.Funcs[0].Instrs[1:5] {
+				if !x86ScalarFPResultTransfer(ins, &numeric, []bool{true}, 0, "386") {
+					t.Fatal("independent numerical transfer did not validate the typed instruction", ins.Raw)
+				}
+				canonicalFP, canonicalGP = x86ABI0CanonicalBytesAfter(ins, canonicalFP, canonicalGP, "386")
+				if !numeric.fp[0] || ordinal == 0 && canonicalFP[0] != (raw == 0 || raw == 1) {
+					t.Fatal("canonicality changed numerical byte initialization", raw, ordinal)
+				}
+				lowCanonical := canonicalGP[0]&1 != 0
+				if ordinal == 1 && (numeric.gp[0]&15 != 15 || lowCanonical != (raw == 0 || raw == 1) || canonicalGP[0]&240 != 0) {
+					t.Fatal("FP bool-byte load invented low/high GP canonicality", raw, canonicalGP[0])
+				}
+			}
+			if !canonicalFP[0] {
+				t.Fatal("actual SETcc did not restore the canonical result after raw byte computation")
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_runtime_fixture_test.go b/x86_abi0_bool_runtime_fixture_test.go
new file mode 100644
index 000000000..0d61df185
--- /dev/null
+++ b/x86_abi0_bool_runtime_fixture_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+type x86ABI0Mode32BoolRuntimeRow struct {
+	body string
+	want byte
+}
+
+func x86ABI0Mode32BoolRuntimeRows() []x86ABI0Mode32BoolRuntimeRow {
+	var rows []x86ABI0Mode32BoolRuntimeRow
+	for _, values := range [][2]uint32{{0, 0}, {0, 1}, {1, 0}, {0x7fffffff, 0xffffffff}, {0x80000000, 1}, {0xffffffff, 0}} {
+		a, b := values[0], values[1]
+		r := a - b
+		cf, zf, sf, of := a < b, r == 0, r>>31 != 0, ((a^b)&(a^r))>>31 != 0
+		parity := byte(r)
+		parity ^= parity >> 4
+		parity ^= parity >> 2
+		parity ^= parity >> 1
+		pf := parity&1 == 0
+		want := []bool{!cf, cf, zf, sf == of, !zf && sf == of, !cf && !zf, zf || sf != of, cf || zf, sf != of, sf, !zf, !of, of, !pf, !sf, pf}
+		for index, condition := range amd64RegisterBoolConditions {
+			row := x86ABI0Mode32BoolRuntimeRow{body: fmt.Sprintf("MOVL $%d,AX\nMOVL $%d,BX\nCMPL AX,BX\n%s ret+0(FP)", a, b, condition)}
+			if want[index] {
+				row.want = 1
+			}
+			rows = append(rows, row)
+		}
+	}
+	for _, raw := range []int{2, 3, 255} {
+		rows = append(rows, x86ABI0Mode32BoolRuntimeRow{body: fmt.Sprintf("MOVB $%d,ret+0(FP)\nMOVBLZX ret+0(FP),AX\nTESTL AX,AX\nSETNE ret+0(FP)", raw), want: 1})
+	}
+	return rows
+}
+
+func x86ABI0Mode32BoolRuntimeSource(rows []x86ABI0Mode32BoolRuntimeRow) (assembly, invalid, declarations, observers, observerDeclarations string) {
+	var target, bad, declared, observed, observeDecl strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&target, "TEXT ·Bool%d(SB),4,$0-1\n%s\nRET\n", index, row.body)
+		fmt.Fprintf(&declared, "func Bool%d() bool\n", index)
+	}
+	// These invalid bool representations are observed only by the raw caller,
+	// never called as logical Go bools or normalized by the LLVM bool transport.
+	for index, raw := range []int{2, 3, 255} {
+		fmt.Fprintf(&bad, "TEXT ·Bad%d(SB),4,$0-1\nMOVB $%d,ret+0(FP)\nRET\n", index, raw)
+		fmt.Fprintf(&declared, "func Bad%d() bool\n", index)
+	}
+	for index := 0; index < len(rows)+3; index++ {
+		callee := fmt.Sprintf("Bool%d", index)
+		if index >= len(rows) {
+			callee = fmt.Sprintf("Bad%d", index-len(rows))
+		}
+		fmt.Fprintf(&observeDecl, "func Observe%d() uint64\n", index)
+		fmt.Fprintf(&observed, `TEXT ·Observe%d(SB),4,$16-8
+MOVL $0x5a5a5a5a,0(SP)
+MOVL $0x11223344,4(SP)
+CALL ·%s(SB)
+MOVL 0(SP),AX
+MOVL AX,ret+0(FP)
+MOVL 4(SP),AX
+MOVL AX,ret+4(FP)
+RET
+`, index, callee)
+	}
+	return target.String(), bad.String(), declared.String(), observed.String(), observeDecl.String()
+}
+
+// The portable inventory checks whole fixture members and independent expected
+// outcomes. It is not an assembler, object, native caller or execution receipt.
+func TestX86ABI0Mode32BoolRuntimeFixtureInventory(t *testing.T) {
+	rows := x86ABI0Mode32BoolRuntimeRows()
+	if len(rows) != 99 {
+		t.Fatal("missing SETcc or raw-byte restoration rows", len(rows))
+	}
+	for condition := range amd64RegisterBoolConditions {
+		seen := [2]bool{}
+		for values := 0; values < 6; values++ {
+			seen[rows[16*values+condition].want] = true
+		}
+		if !seen[0] || !seen[1] {
+			t.Fatal("condition lacks independent true/false controls", amd64RegisterBoolConditions[condition])
+		}
+	}
+	assembly, invalid, declarations, observers, observerDecl := x86ABI0Mode32BoolRuntimeSource(rows)
+	for _, member := range []struct {
+		source string
+		prefix string
+		count  int
+	}{{assembly, "Bool", 99}, {invalid, "Bad", 3}, {observers, "Observe", 102}} {
+		file, err := Parse(ArchAMD64, member.source)
+		if err != nil || len(file.Funcs) != member.count || len(file.Data) != 0 || len(file.Globl) != 0 {
+			t.Fatal("complete fixture member changed its TEXT/DATA inventory", member.prefix, err)
+		}
+		for index, fn := range file.Funcs {
+			if fn.Sym != fmt.Sprintf("·%s%d", member.prefix, index) {
+				t.Fatal("complete source member order changed", fn.Sym)
+			}
+		}
+	}
+	if _, err := parser.ParseFile(token.NewFileSet(), "bool.go", "package main\n"+declarations+observerDecl, 0); err != nil {
+		t.Fatal("original Go bool/raw caller declarations are malformed", err)
+	}
+	if strings.Contains(assembly, "·Bad") || strings.Contains(invalid, "·Bool") || strings.Count(observers, "CALL ·Bool") != 99 || strings.Count(observers, "CALL ·Bad") != 3 {
+		t.Fatal("valid and invalid complete original members or raw caller controls were merged/cropped")
+	}
+}
diff --git a/x86_abi0_bool_runtime_linux_amd64_test.go b/x86_abi0_bool_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..4a7498913
--- /dev/null
+++ b/x86_abi0_bool_runtime_linux_amd64_test.go
@@ -0,0 +1,90 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This required owner executes the complete original ABI0 bool-byte target
+// through genuine Go callers and separate raw callers. LLVM crosses C only
+// through explicit i1-to-i32 shims. It supplies no SDK/native-entry authority;
+// local emulation cannot replace native Linux AMD64's kernel i386 counterpart.
+func TestCrossLinuxRuntimeMatrixX86ABI0Mode32CanonicalBoolOriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required LLVM22/i386 bool counterpart tools: llc=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu", compiler: []string{compiler, "-static", "-no-pie"}}
+	rows := x86ABI0Mode32BoolRuntimeRows()
+	assembly, invalid, declarations, observers, observerDecl := x86ABI0Mode32BoolRuntimeSource(rows)
+	var calls, rawChecks, wrappers, prototypes, checks strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&calls, "if Bool%d()!=(%d!=0){panic(\"original Go bool caller row %d\")}; if Observe%d()!=(0x112233445a5a5a00|%d){panic(\"original raw bool byte/seven adjacent canaries row %d\")}; calls+=2\n", index, row.want, index, index, row.want, index)
+		fmt.Fprintf(&wrappers, "\ndefine i32 @Probe%d() {\n %%v=call i1 @Bool%d()\n %%r=zext i1 %%v to i32\n ret i32 %%r\n}\n", index, index)
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(void);\n", index)
+		fmt.Fprintf(&checks, "if(Probe%d()!=%d){fprintf(stderr,\"LLVM bool byte row %d\\n\");return 1;} calls++;\n", index, row.want, index)
+	}
+	for index, raw := range []int{2, 3, 255} {
+		fmt.Fprintf(&rawChecks, "if Observe%d()!=(0x112233445a5a5a00|%d){panic(\"raw invalid bool representation normalized\")}; calls++\n", len(rows)+index, raw)
+	}
+	goDriver := "package main\nimport \"fmt\"\n" + declarations + observerDecl + "\nfunc main(){calls:=0\n" + calls.String() + rawChecks.String() + "fmt.Printf(\"original386 bool bytes/canaries: %d checks\\n\",calls)\n}\n"
+	dir := t.TempDir()
+	for name, contents := range map[string]string{"go.mod": "module boolbyte386\n\ngo 1.20\n", "main.go": goDriver,
+		"bool_386.s": assembly, "invalid_386.s": invalid, "observer_386.s": observers} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original")
+	command := exec.Command("go", "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	originalProgram, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantOriginal := fmt.Sprintf("original386 bool bytes/canaries: %d checks\n", 2*len(rows)+3)
+	if output := x87IA32RunDirect(t, originalProgram, nil, os.Environ()); string(output) != wantOriginal {
+		t.Fatalf("incomplete original Go bool/raw representation axis: %s", output)
+	}
+	// Each original target member remains complete: the valid member and the
+	// three invalid bool TEXTs are separate exact source fixtures. The observer
+	// is an independent native Go caller driver, not a translated helper ABI.
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, invalid, declarations, "386", execution.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+			t.Fatal("raw 2/3/255 byte controls acquired a logical bool transport", api, len(ir), err)
+		}
+	}
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + "\nint main(void){volatile uint32_t canary[2]={0x12345678,0x87654321};unsigned calls=0;\n" + checks.String() +
+		"if(canary[0]!=0x12345678||canary[1]!=0x87654321)return 2;printf(\"LLVM386 canonical bool shims: %u checks\\n\",calls);return 0;}\n"
+	wantLLVM := fmt.Sprintf("LLVM386 canonical bool shims: %d checks\n", len(rows))
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "386", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			executable := execution.compileLLVM(t, "canonical-abi0-bool-386", ir+wrappers.String(), driver, level)
+			translatedProgram, err := x87IA32StaticExecutable(executable)
+			if err != nil {
+				t.Fatal(err)
+			}
+			output := x87IA32RunDirect(t, translatedProgram, nil, os.Environ())
+			if string(output) != wantLLVM {
+				t.Fatalf("incomplete %s/%s logical bool counterpart: %s", api, level, output)
+			}
+		}
+	}
+	t.Log("whole original Go target, actual ABI0 bool callers/raw bytes/seven adjacent canaries; 96 SETcc rows plus raw2/3/255 restoration; three APIs/O0/O2 integer-only LLVM shims. Not C _Bool or SDK-native-entry certification.")
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_abi0_bool_runtime_policy_test.go b/x86_abi0_bool_runtime_policy_test.go
new file mode 100644
index 000000000..9eec66c99
--- /dev/null
+++ b/x86_abi0_bool_runtime_policy_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const x86ABI0BoolNativeOwnerPath = "x86_abi0_bool_runtime_linux_amd64_test.go"
+
+// This portable policy checks the required owner's routes, not its executed
+// semantics or a new native-host certificate on the current test machine.
+func x86ABI0BoolNativeOwnerPolicy(source []byte) error {
+	source = normalizeNativeOwnerPolicySource(source)
+	if !strings.HasPrefix(string(source), "//go:build linux && amd64\n") {
+		return fmt.Errorf("required bool oracle lost its native Linux AMD64 owner")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), x86ABI0BoolNativeOwnerPath, source, 0)
+	if err != nil {
+		return err
+	}
+	var body *ast.BlockStmt
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == "TestCrossLinuxRuntimeMatrixX86ABI0Mode32CanonicalBoolOriginalGoAndLLVM" {
+			if body != nil {
+				return fmt.Errorf("duplicate native bool owner")
+			}
+			body = function.Body
+		}
+	}
+	ident := func(node ast.Node, name string) bool {
+		value, ok := node.(*ast.Ident)
+		return ok && value.Name == name
+	}
+	gate := func(statement ast.Stmt) bool {
+		expression, ok := statement.(*ast.ExprStmt)
+		if !ok {
+			return false
+		}
+		call, ok := expression.X.(*ast.CallExpr)
+		return ok && ident(call.Fun, "x87IA32RequireNativeHost") && len(call.Args) == 1 && ident(call.Args[0], "t")
+	}
+	if body == nil || len(body.List) < 2 || !gate(body.List[0]) || !gate(body.List[len(body.List)-1]) {
+		return fmt.Errorf("native bool owner needs exact before/after host observations")
+	}
+	seals, runs := make(map[string]int), make(map[string]int)
+	gates, compiles := 0, 0
+	var failure error
+	ast.Inspect(body, func(node ast.Node) bool {
+		if failure != nil {
+			return false
+		}
+		switch value := node.(type) {
+		case *ast.ReturnStmt:
+			failure = fmt.Errorf("required native owner inserted a success early return")
+		case *ast.AssignStmt:
+			if len(value.Rhs) != 1 {
+				break
+			}
+			call, ok := value.Rhs[0].(*ast.CallExpr)
+			if !ok || !ident(call.Fun, "x87IA32StaticExecutable") {
+				break
+			}
+			if len(value.Lhs) != 2 || !ident(value.Lhs[1], "err") || len(call.Args) != 1 {
+				failure = fmt.Errorf("static executable seal lost its error or actual artifact")
+				break
+			}
+			program, ok := value.Lhs[0].(*ast.Ident)
+			if !ok || program.Name != "originalProgram" && program.Name != "translatedProgram" ||
+				program.Name == "originalProgram" && !ident(call.Args[0], "original") ||
+				program.Name == "translatedProgram" && !ident(call.Args[0], "executable") {
+				failure = fmt.Errorf("static seal is not bound to its actual original/LLVM artifact")
+				break
+			}
+			seals[program.Name]++
+		case *ast.CallExpr:
+			if ident(value.Fun, "x87IA32RequireNativeHost") {
+				gates++
+			}
+			if ident(value.Fun, "x87IA32RunDirect") {
+				if len(value.Args) != 4 || !ident(value.Args[0], "t") || !ident(value.Args[2], "nil") {
+					failure = fmt.Errorf("direct execution has an unbound argument transport")
+					break
+				}
+				program, ok := value.Args[1].(*ast.Ident)
+				environment, envOK := value.Args[3].(*ast.CallExpr)
+				if !ok || program.Name != "originalProgram" && program.Name != "translatedProgram" || !envOK || len(environment.Args) != 0 {
+					failure = fmt.Errorf("direct execution lost the static artifact/environment")
+					break
+				}
+				method, ok := environment.Fun.(*ast.SelectorExpr)
+				if !ok || !ident(method.X, "os") || method.Sel.Name != "Environ" {
+					failure = fmt.Errorf("direct execution changed the native environment route")
+					break
+				}
+				runs[program.Name]++
+			}
+			if method, ok := value.Fun.(*ast.SelectorExpr); ok {
+				if strings.HasPrefix(method.Sel.Name, "Skip") || method.Sel.Name == "run" || method.Sel.Name == "compileAndRunLLVM" {
+					failure = fmt.Errorf("native owner inserted a skip or general execution transport")
+				}
+				if method.Sel.Name == "compileLLVM" {
+					compiles++
+				}
+			}
+		case *ast.KeyValueExpr:
+			if ident(value.Key, "prefix") || ident(value.Key, "preserveArgv0") {
+				failure = fmt.Errorf("native owner inserted a guest execution transport")
+			}
+		case *ast.BasicLit:
+			if value.Kind == token.STRING {
+				literal, err := strconv.Unquote(value.Value)
+				if err != nil || strings.Contains(literal, "qemu") || literal == "-exec" {
+					failure = fmt.Errorf("native owner inserted an execution fallback")
+				}
+			}
+		}
+		return true
+	})
+	if failure != nil {
+		return failure
+	}
+	if gates != 2 || compiles != 1 || seals["originalProgram"] != 1 || seals["translatedProgram"] != 1 ||
+		runs["originalProgram"] != 1 || runs["translatedProgram"] != 1 {
+		return fmt.Errorf("incomplete actual original/LLVM static direct routes: gates=%d compiles=%d seals=%v runs=%v", gates, compiles, seals, runs)
+	}
+	return nil
+}
+
+func TestX86ABI0Mode32BoolRuntimeNativeOwnerCannotEmulateOrSkip(t *testing.T) {
+	source, err := os.ReadFile(x86ABI0BoolNativeOwnerPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86ABI0BoolNativeOwnerPolicy(source); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86ABI0Mode32BoolRuntimeNativePolicyRejectsMutation(t *testing.T) {
+	source, err := os.ReadFile(x86ABI0BoolNativeOwnerPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = normalizeNativeOwnerPolicySource(source)
+	if err := x86ABI0BoolNativeOwnerPolicy(source); err != nil {
+		t.Fatal("actual owner baseline", err)
+	}
+	const host = "\tx87IA32RequireNativeHost(t)"
+	for name, change := range map[string]struct {
+		old, new string
+		last     bool
+	}{
+		"missing-before":        {host, "\tt.Log(\"missing host\")", false},
+		"missing-after":         {host, "\tt.Log(\"missing host\")", true},
+		"conditional-before":    {host, "\tif true { x87IA32RequireNativeHost(t) }", false},
+		"conditional-after":     {host, "\tif true { x87IA32RequireNativeHost(t) }", true},
+		"early-return":          {host, host + "\n\treturn", false},
+		"skip":                  {host, host + "\n\tt.Skip(\"missing tools\")", false},
+		"guest-prefix":          {"execution := x86FloatCompareExecution{", "execution := x86FloatCompareExecution{prefix: []string{\"guest\"},", false},
+		"emulator":              {host, host + "\n\tt.Log(\"qemu-i386\")", false},
+		"exec-fallback":         {host, host + "\n\tt.Log(\"-exec\")", false},
+		"original-other-seal":   {"x87IA32StaticExecutable(original)", "x87IA32StaticExecutable(executable)", false},
+		"original-other-run":    {"x87IA32RunDirect(t, originalProgram, nil, os.Environ())", "x87IA32RunDirect(t, translatedProgram, nil, os.Environ())", false},
+		"LLVM-general-runner":   {"x87IA32RunDirect(t, translatedProgram, nil, os.Environ())", "execution.run(t, executable)", false},
+		"duplicate-observation": {host, host + "\n" + host, false},
+	} {
+		t.Run(name, func(t *testing.T) {
+			text := string(source)
+			index := strings.Index(text, change.old)
+			if change.last {
+				index = strings.LastIndex(text, change.old)
+			}
+			if index < 0 {
+				t.Fatal("mutation did not match the complete actual owner")
+			}
+			changed := text[:index] + change.new + text[index+len(change.old):]
+			if err := x86ABI0BoolNativeOwnerPolicy([]byte(changed)); err == nil {
+				t.Fatal("native owner policy accepted changed execution/host routes")
+			}
+		})
+	}
+}
diff --git a/x86_abi0_bool_tail.go b/x86_abi0_bool_tail.go
new file mode 100644
index 000000000..91761ca57
--- /dev/null
+++ b/x86_abi0_bool_tail.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// A terminal forwards only existing logical arguments and an independently
+// declared canonical I1 result. It creates no FP writes, GP/FLAGS state,
+// memory origin, physical frame, native entry or C _Bool transport permission.
+type x86ABI0BoolTail struct {
+	target    string
+	signature FuncSig
+}
+
+func x86ABI0BoolHasCall(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ABI0BoolTailTarget(fn Func) (string, bool) {
+	if fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil ||
+		len(fn.Instrs) != 2 || fn.Instrs[0].Op != OpTEXT {
+		return "", false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+			ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return "", false
+		}
+	}
+	ins := fn.Instrs[1]
+	if ins.Op != OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+		return "", false
+	}
+	name, offset, valid := parseSBRef(ins.Args[0].Sym)
+	return name, valid && offset == 0 && !strings.Contains(name, "<")
+}
+
+func x86ABI0BoolTailTransport(left, right FuncSig, arch string) bool {
+	if !x86ABI0BoolDeclarationRole(left, arch) || !x86ABI0BoolDeclarationRole(right, arch) {
+		return false
+	}
+	// Source variable/result names are descriptive, not transport. All actual
+	// offsets, types, field paths, argument order and ABI/native fields remain.
+	project := func(sig FuncSig) FuncSig {
+		sig.Name, sig.Attrs = "", ""
+		sig.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+		sig.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+		for index := range sig.Frame.Params {
+			sig.Frame.Params[index].Name = ""
+		}
+		for index := range sig.Frame.Results {
+			sig.Frame.Results[index].Name = ""
+		}
+		return sig
+	}
+	return reflect.DeepEqual(project(left), project(right))
+}
+
+func (source *x86ABI0BoolCallSource) prepareTail(fn Func, sig FuncSig, byName map[string]Func, visiting map[string]bool) (*x86ABI0BoolTail, error) {
+	arch := source.options.Goarch
+	name, valid := x86ABI0BoolTailTarget(fn)
+	if !valid || !x86ABI0BoolDeclarationRole(sig, arch) ||
+		fn.ArgSize != 0 && fn.ArgSize != sig.Frame.Results[0].Offset+1 {
+		return nil, x86ABI0BoolCallContext("tail lacks an exact zero-frame ordinary canonical terminal")
+	}
+	if _, queried := source.resolved[name]; !queried {
+		source.resolved[name] = x86ABI0BoolCallResolve(source.options, name)
+	}
+	calleeName := source.resolved[name]
+	calleeSig, declared := source.signatures[calleeName]
+	if calleeName == "" || !declared || calleeSig.Name != "" && calleeSig.Name != calleeName ||
+		!x86ABI0BoolTailTransport(sig, calleeSig, arch) {
+		return nil, x86ABI0BoolCallContext("tail target lacks its independent exact canonical declaration/transport")
+	}
+	if callee, exists := byName[name]; exists && !source.tailProofs[name] {
+		if visiting[name] || len(visiting) >= 256 {
+			return nil, x86ABI0BoolCallContext("same-file canonical terminal has a cycle or exceeds the complete source bound")
+		}
+		visiting[name] = true
+		defer delete(visiting, name)
+		if x86ABI0BoolFunctionControlNeeded(callee) {
+			if x86ABI0BoolHasCall(callee) {
+				return nil, x86ABI0BoolCallContext("tail callee needs its independent CALL contract")
+			}
+			if _, err := source.prepareTail(callee, calleeSig, byName, visiting); err != nil {
+				return nil, err
+			}
+		} else {
+			if err := (&x86ABI0BoolCallPlan{function: callee}).replay(); err != nil {
+				return nil, err
+			}
+			callee.x86ResultFlowBudget = &source.budget
+			resolve := func(symbol string) string { return x86ABI0BoolCallResolve(source.options, symbol) }
+			consumer := newX86Ctx(new(strings.Builder), callee, calleeSig, resolve, source.signatures, arch, source.options.TargetTriple, false)
+			consumer.fpScalarData = x86LoweredScalarDataReads(source.original, resolve, source.signatures, arch)
+			consumer.fpShiftLiterals = x86LoweredShiftLiterals(source.original, resolve,
+				x86LoweredStaticAddressValues(source.original, resolve, source.signatures, arch), arch)
+			consumer.goReadOnlyStorage = source.options.goReadOnlyStorage
+			if err := consumer.checkLoweredScalarFPResultInitialization(); err != nil {
+				return nil, err
+			}
+		}
+		source.tailProofs[name] = true // Same cached source/byte/visit budget, never reset.
+	}
+	return &x86ABI0BoolTail{target: calleeName, signature: calleeSig}, nil
+}
+
+func (plan *x86ABI0BoolCallPlan) checkTailTerminal(fn Func, sig FuncSig, arch string) error {
+	if plan.tail == nil || !plan.matches(fn, sig, arch) || !x86ABI0BoolTailTransport(plan.signature, plan.tail.signature, arch) ||
+		!reflect.DeepEqual(plan.source.signatures[plan.tail.target], plan.tail.signature) {
+		return x86ABI0BoolCallContext("tail consumption changed its original source or exact declaration")
+	}
+	return plan.source.verify() // All callbacks precede the final complete source/type snapshot.
+}
diff --git a/x86_abi0_bool_tail_test.go b/x86_abi0_bool_tail_test.go
new file mode 100644
index 000000000..8d3ff682c
--- /dev/null
+++ b/x86_abi0_bool_tail_test.go
@@ -0,0 +1,289 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86ABI0BoolTailAssembly = "TEXT ·wrapper(SB),4,$0\nJMP ·leaf(SB)\nTEXT ·leaf(SB),4,$0-5\nMOVB x+0(FP),AX\nMOVB AX,ret+4(FP)\nRET\n"
+const x86ABI0BoolTailDeclarations = "func wrapper(x bool) bool\nfunc leaf(x bool) bool\n"
+
+func TestX86ABI0Mode32CanonicalBoolTypedTailThreeAPIs(t *testing.T) {
+	for name, row := range map[string]struct {
+		source, declarations string
+		good                 bool
+	}{
+		"actual-samefile":    {x86ABI0BoolTailAssembly, x86ABI0BoolTailDeclarations, true},
+		"declared-Go-target": {strings.Replace(x86ABI0BoolTailAssembly, "TEXT ·leaf(SB),4,$0-5\nMOVB x+0(FP),AX\nMOVB AX,ret+4(FP)\nRET\n", "", 1), x86ABI0BoolTailDeclarations, true},
+		"raw-callee-2":       {strings.Replace(x86ABI0BoolTailAssembly, "MOVB AX,ret+4(FP)", "MOVB $2,ret+4(FP)", 1), x86ABI0BoolTailDeclarations, false},
+		"caller-prior-write": {strings.Replace(x86ABI0BoolTailAssembly, "JMP ·leaf(SB)", "MOVB $1,ret+4(FP)\nJMP ·leaf(SB)", 1), x86ABI0BoolTailDeclarations, false},
+		"callee-result-I8":   {strings.Replace(x86ABI0BoolTailAssembly, "MOVB AX,ret+4(FP)", "MOVB $3,ret+4(FP)", 1), strings.Replace(x86ABI0BoolTailDeclarations, "func leaf(x bool) bool", "func leaf(x bool) uint8", 1), false},
+		"callee-input-I8":    {x86ABI0BoolTailAssembly, strings.Replace(x86ABI0BoolTailDeclarations, "func leaf(x bool)", "func leaf(x uint8)", 1), false},
+		"offset-target":      {strings.Replace(x86ABI0BoolTailAssembly, "JMP ·leaf(SB)", "JMP ·leaf+1(SB)", 1), x86ABI0BoolTailDeclarations, false},
+		"native-target":      {strings.Replace(x86ABI0BoolTailAssembly, "JMP ·leaf(SB)", "JMP ·leaf<ABIInternal>(SB)", 1), x86ABI0BoolTailDeclarations, false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declarations, "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("typed bool terminal did not retain its independent transport/canonical contract", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func x86ABI0BoolTailParsed(t *testing.T) (*File, Options) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, x86ABI0BoolTailAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "tailbool", "package tailbool\n"+x86ABI0BoolTailDeclarations)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+}
+
+func TestX86ABI0Mode32CanonicalBoolTypedTailSourceReplayAndLayouts(t *testing.T) {
+	for name, change := range map[string]func(*File, *Options){
+		"caller-literal":  func(file *File, _ *Options) { file.Funcs[0].Instrs[1].Raw += " // changed" },
+		"callee-literal":  func(file *File, _ *Options) { file.Funcs[1].Instrs[1].Raw += " // changed" },
+		"caller-identity": func(file *File, _ *Options) { file.Funcs[0].Sym = "·other" },
+		"callee-identity": func(file *File, _ *Options) { file.Funcs[1].Sym = "·other" },
+		"callee-input-offset": func(_ *File, options *Options) {
+			sig := options.Sigs["leaf"]
+			sig.Frame.Params[0].Offset = 1
+			options.Sigs["leaf"] = sig
+		},
+		"callee-result-offset": func(_ *File, options *Options) {
+			sig := options.Sigs["leaf"]
+			sig.Frame.Results[0].Offset = 5
+			options.Sigs["leaf"] = sig
+		},
+		"callee-register-role": func(_ *File, options *Options) {
+			sig := options.Sigs["leaf"]
+			sig.ArgRegs = []Reg{AX}
+			options.Sigs["leaf"] = sig
+		},
+		"copied-caller-signature": func(_ *File, options *Options) {
+			sig := options.Sigs["leaf"]
+			sig.x86BorrowedBoolTail = true
+			options.Sigs["leaf"] = sig
+		},
+	} {
+		for _, api := range []string{"text", "module"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				file, options := x86ABI0BoolTailParsed(t)
+				source, err := prepareX86ABI0BoolCalls(file, options)
+				if err != nil || source == nil || source.callers["·wrapper"].tail == nil {
+					t.Fatal("actual canonical terminal source baseline", err)
+				}
+				options.x86BoolCallSource = source
+				change(file, &options)
+				published := false
+				if api == "text" {
+					ir, failure := Translate(file, options)
+					published, err = ir != "", failure
+				} else {
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					module, failure := TranslateModuleInContext(ctx, file, options)
+					published, err = !module.IsNil(), failure
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+				}
+				if published || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed terminal source/type tuple published", published, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolTypedTailCannotBorrowGoCaller(t *testing.T) {
+	x86ABI0BoolTailCannotBorrowGoCaller(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86AMD64CanonicalBoolTypedTailCannotBorrowGoCaller(t *testing.T) {
+	x86ABI0BoolTailCannotBorrowGoCaller(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func x86ABI0BoolTailCannotBorrowGoCaller(t *testing.T, arch, triple string) {
+	t.Helper()
+	source := []byte("TEXT ·wrapper(SB),4,$0\nJMP outside·target(SB)\n")
+	pkg := mustGoPackage(t, "tailbool", "package tailbool\nfunc wrapper(x bool) bool\n")
+	file, err := Parse(ArchAMD64, string(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym("tailbool")
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil || !sigs["outside.target"].x86BorrowedBoolTail {
+		t.Fatal("real unresolved Go target did not retain copied-caller denial", err)
+	}
+	cloned, err := numericalCloneSignatures(sigs)
+	if err != nil || !cloned["outside.target"].x86BorrowedBoolTail {
+		t.Fatal("public metadata copying erased the denial provenance", err)
+	}
+	// The positive declaration is independently derived from the target's
+	// actual Go type, not copied from the caller or reconstructed as a token.
+	calleePackage := mustGoPackage(t, "outside", "package outside\nfunc target(y bool) bool\n")
+	word := x86ResultPointerWord(arch)
+	calleeFile, err := Parse(ArchAMD64, fmt.Sprintf("TEXT ·target(SB),4,$0-%d\nMOVB y+0(FP),AX\nMOVB AX,ret+%d(FP)\nRET\n", word+1, word))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual, err := goSigsForAsmFile(calleePackage, calleeFile, testResolveSym("outside"), arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, supplied := range []bool{false, true} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("actual-declaration=%t/%s", supplied, api), func(t *testing.T) {
+				options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+				if supplied {
+					options.Sigs = map[string]FuncSig{"tailbool.wrapper": sigs["tailbool.wrapper"], "outside.target": actual["outside.target"]}
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				published := false
+				var err error
+				if api == "text" {
+					ir, failure := Translate(file, options)
+					published, err = ir != "", failure
+				} else if api == "module" {
+					module, failure := TranslateModuleInContext(ctx, file, options)
+					published, err = !module.IsNil(), failure
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+				} else {
+					request := GoModuleOptions{GOARCH: arch, TargetTriple: options.TargetTriple, ResolveSym: resolve}
+					if supplied {
+						request.ManualSig = func(name string) (FuncSig, bool) { sig, found := actual[name]; return sig, found }
+					}
+					module, failure := translateGoModuleInContext(ctx, pkg, source, request)
+					published, err = module != nil, failure
+					if module != nil && !module.Module.IsNil() {
+						defer module.Module.Dispose()
+					}
+				}
+				if supplied && (!published || err != nil) || !supplied && (published || !errors.Is(err, ErrProbeNeedsContext)) {
+					t.Fatal("caller-copy substituted for independent actual target declaration", supplied, published, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolTypedTailCacheAndKeepSource(t *testing.T) {
+	file, options := x86ABI0BoolTailParsed(t)
+	source, err := prepareX86ABI0BoolCalls(file, options)
+	if err != nil || source == nil || !source.tailProofs["·leaf"] {
+		t.Fatal("complete source did not close its actual canonical leaf", err)
+	}
+	bytes, visits := source.budget.bytes, source.budget.visits
+	if bytes == 0 || visits == 0 || len(source.callers["·wrapper"].bytes) != 0 {
+		t.Fatal("terminal recreated outgoing backing or omitted the independent leaf proof")
+	}
+	for count := 0; count < 3; count++ {
+		if err := source.verify(); err != nil || source.budget.bytes != bytes || source.budget.visits != visits {
+			t.Fatal("readback repeated its cached byte/visit proof", err)
+		}
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], options.Sigs["wrapper"], "386"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("declaration-only observer borrowed a logical terminal capability", err)
+	}
+	for _, bad := range []bool{false, true} {
+		t.Run(fmt.Sprintf("KeepFunc/callee-raw=%t", bad), func(t *testing.T) {
+			input := x86ABI0BoolTailAssembly
+			if bad {
+				input = strings.Replace(input, "MOVB AX,ret+4(FP)", "MOVB $3,ret+4(FP)", 1)
+			}
+			pkg := mustGoPackage(t, "tailbool", "package tailbool\n"+x86ABI0BoolTailDeclarations)
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := translateGoModuleInContext(ctx, pkg, []byte(input), GoModuleOptions{GOARCH: "386", TargetTriple: options.TargetTriple,
+				ResolveSym: options.ResolveSym, KeepFunc: func(original, _ string) bool { return original == "·wrapper" }})
+			if module != nil && !module.Module.IsNil() {
+				defer module.Module.Dispose()
+			}
+			if !bad && (module == nil || err != nil) || bad && (module != nil || !errors.Is(err, ErrProbeNeedsContext)) {
+				t.Fatal("filter dropped the complete original canonical callee proof", bad, module != nil, err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolTypedTailFinalCallbacks(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, kind := range []string{"control", "source", "signature", "resolution"} {
+			if api == "Go" && kind == "signature" {
+				continue // Go derives the private map from the actual declaration.
+			}
+			t.Run(api+"/"+kind, func(t *testing.T) {
+				run := func(trigger int, mutation string) (int, bool, error) {
+					file, options := x86ABI0BoolTailParsed(t)
+					input := []byte(x86ABI0BoolTailAssembly)
+					calls := 0
+					options.ResolveSym = func(symbol string) string {
+						calls++
+						if calls == trigger {
+							switch mutation {
+							case "source":
+								if api == "Go" {
+									input[0] = 'X'
+								} else {
+									file.Funcs[1].Instrs[1].Raw += " // changed"
+								}
+							case "signature":
+								sig := options.Sigs["leaf"]
+								sig.Frame.Results[0].Offset++
+								options.Sigs["leaf"] = sig
+							case "resolution":
+								return "other"
+							}
+						}
+						return strings.TrimPrefix(symbol, "·")
+					}
+					if api == "text" {
+						ir, err := Translate(file, options)
+						return calls, ir != "", err
+					}
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					if api == "module" {
+						module, err := TranslateModuleInContext(ctx, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+						}
+						return calls, !module.IsNil(), err
+					}
+					pkg := mustGoPackage(t, "tailbool", "package tailbool\n"+x86ABI0BoolTailDeclarations)
+					module, err := translateGoModuleInContext(ctx, pkg, input, GoModuleOptions{GOARCH: "386", TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym})
+					if module != nil && !module.Module.IsNil() {
+						defer module.Module.Dispose()
+					}
+					return calls, module != nil, err
+				}
+				last, published, err := run(0, "")
+				if last == 0 || !published || err != nil {
+					t.Fatal("whole API baseline missed its final source callback", last, published, err)
+				}
+				reached, published, err := run(last, kind)
+				if reached != last || kind == "control" && (!published || err != nil) || kind != "control" && (published || !errors.Is(err, ErrProbeNeedsContext)) {
+					t.Fatal("last terminal callback changed source/declaration and published", last, reached, published, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_abi0_bool_void_call_test.go b/x86_abi0_bool_void_call_test.go
new file mode 100644
index 000000000..fd7343ebd
--- /dev/null
+++ b/x86_abi0_bool_void_call_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86ABI0BoolVoidCallSource = "TEXT ·probe(SB),4,$0-5\nCALL ·notify(SB)\nMOVL x+0(FP),AX\nTESTL AX,AX\nSETNE ret+4(FP)\nRET\nTEXT ·notify(SB),4,$0-0\nRET\n"
+const x86ABI0BoolVoidCallDeclarations = "func probe(x uint32) bool\nfunc notify()\n"
+
+func TestX86ABI0Mode32CanonicalBoolVoidCallThreeAPIs(t *testing.T) {
+	for name, row := range map[string]struct {
+		source, declarations string
+		good                 bool
+	}{
+		"actual-noarg-void": {x86ABI0BoolVoidCallSource, x86ABI0BoolVoidCallDeclarations, true},
+		"declared-Go-void":  {strings.Replace(x86ABI0BoolVoidCallSource, "TEXT ·notify(SB),4,$0-0\nRET\n", "", 1), x86ABI0BoolVoidCallDeclarations, true},
+		"unknown-target":    {strings.Replace(x86ABI0BoolVoidCallSource, "CALL ·notify(SB)", "CALL ·unknown(SB)", 1), x86ABI0BoolVoidCallDeclarations, false},
+		"nonvoid-target": {strings.Replace(x86ABI0BoolVoidCallSource, "TEXT ·notify(SB),4,$0-0\nRET", "TEXT ·notify(SB),4,$0-4\nMOVL $0,ret+0(FP)\nRET", 1),
+			strings.Replace(x86ABI0BoolVoidCallDeclarations, "func notify()", "func notify() uint32", 1), false},
+		"parameter-target": {strings.Replace(x86ABI0BoolVoidCallSource, "TEXT ·notify(SB),4,$0-0", "TEXT ·notify(SB),4,$0-4", 1),
+			strings.Replace(x86ABI0BoolVoidCallDeclarations, "func notify()", "func notify(x uint32)", 1), false},
+		"raw-result-2": {strings.Replace(x86ABI0BoolVoidCallSource, "SETNE ret+4(FP)", "MOVB $2,ret+4(FP)", 1), x86ABI0BoolVoidCallDeclarations, false},
+		"stale-flags":  {strings.Replace(x86ABI0BoolVoidCallSource, "CALL ·notify(SB)\nMOVL x+0(FP),AX\nTESTL AX,AX", "MOVL x+0(FP),AX\nTESTL AX,AX\nCALL ·notify(SB)", 1), x86ABI0BoolVoidCallDeclarations, false},
+		"stale-GP":     {strings.Replace(x86ABI0BoolVoidCallSource, "CALL ·notify(SB)\nMOVL x+0(FP),AX", "MOVL x+0(FP),AX\nCALL ·notify(SB)", 1), x86ABI0BoolVoidCallDeclarations, false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declarations, "386", "i386-unknown-linux-gnu", api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("typed void CALL acquired a bool transport or retained machine state", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0Mode32CanonicalBoolVoidCallHasNoResultOrOutgoingBytes(t *testing.T) {
+	for _, domain := range []string{"caller-origin", "scan-pending", "predicate"} {
+		t.Run(domain, func(t *testing.T) {
+			_, state, owned := x86ABI0BoolCallDomainState(t)
+			file, err := Parse(ArchAMD64, "TEXT ·caller(SB),4,$0-5\nCALL ·notify(SB)\nMOVB $1,ret+4(FP)\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "voiddomains", "package voiddomains\nfunc caller(p *byte) bool\nfunc notify()\n")
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			source, err := prepareX86ABI0BoolCalls(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+			if err != nil || source == nil {
+				t.Fatal("actual independent noarg void declaration lost its source", err)
+			}
+			plan := source.callers["·caller"]
+			state.boolCalls, state.boolOutgoing, state.boolOutgoingCanonical = plan, nil, nil
+			store := x86ScalarLaneInstruction(t, "MOVB $1,ret+4(FP)")
+			if !x86ABI0CanonicalBoolTransfer(func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+			})(2, store, &state, owned, 4, "386") || !state.fp[4] || !state.canonicalFP[4] {
+				t.Fatal("actual prior result byte was not independently written canonical")
+			}
+			switch domain {
+			case "caller-origin":
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "MOVL p+0(FP),SI")
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "LEAL 7(SI),DI")
+				if state.callerAddressOrigin[6] == 0 || state.callerAddressOrigin[7] == 0 {
+					t.Fatal("typed pointer origin producer did not run")
+				}
+			case "scan-pending":
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "MOVL $1,AX")
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "BSFL AX,BX")
+				if state.bitScanPending.mask == 0 {
+					t.Fatal("typed pending scan producer did not run")
+				}
+			case "predicate":
+				for _, line := range []string{"MOVL $1,AX", "MOVL AX,X0", "VPBROADCASTD X0,Y1", "VPCMPEQB Y1,Y1,Y2", "VPTEST Y2,Y2"} {
+					x86ABI0BoolCallDomainEffect(t, &state, owned, line)
+				}
+				state = x86ResultPredicateEdge(state, x86ScalarLaneInstruction(t, "JZ zero"), 0)
+				x86ABI0BoolCallDomainEffect(t, &state, owned, "VPMOVMSKB Y2,DX")
+				if state.predicate.kind != x86ResultNonzeroMaskGP {
+					t.Fatal("typed predicate producer did not run")
+				}
+			}
+			before := state.clone()
+			if accepted, known := x86ABI0BoolCallStep(1, file.Funcs[0].Instrs[1], &state, owned, 4, "386"); !accepted || !known {
+				t.Fatal("actual declared void call was not observed")
+			}
+			if len(plan.bytes) != 0 || len(state.boolOutgoing) != 0 || len(state.boolOutgoingCanonical) != 0 ||
+				!reflect.DeepEqual(state.fp, before.fp) || !reflect.DeepEqual(state.canonicalFP, before.canonicalFP) ||
+				state.callerAddressOrigin != [16]uint16{} || state.bitScanPending != (x86ResultBitScanPending{}) || state.predicate != (x86ResultPredicate{}) ||
+				state.gp != [16]uint8{} || state.canonicalGP != [16]uint8{} || state.xmm != [32]uint16{} || state.vectorUpper != [32]uint64{} ||
+				state.masks != [8]bool{} || state.flags != 0 || state.pointerGP != [16]bool{} || state.callerAddressGP != [16]bool{} {
+				t.Fatal("void call supplied a result/backing fact or retained unknown machine state", domain)
+			}
+		})
+	}
+}
diff --git a/x86_accumulator_sign_extend_effect_test.go b/x86_accumulator_sign_extend_effect_test.go
new file mode 100644
index 000000000..4c627381c
--- /dev/null
+++ b/x86_accumulator_sign_extend_effect_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86AccumulatorSignExtendOracle = []struct {
+	op, prefix, opcode string
+	read, write        int64
+	destination        Reg
+}{
+	{"CBW", "Pe", "0x98", 1, 2, AX},
+	{"CWDE", "Px", "0x98", 2, 4, AX},
+	{"CDQE", "Pw", "0x98", 4, 8, AX},
+	{"CWD", "Pe", "0x99", 2, 2, DX},
+	{"CDQ", "Px", "0x99", 4, 4, DX},
+	{"CQO", "Pw", "0x99", 8, 8, DX},
+}
+
+func TestX86AccumulatorSignExtendCompleteEffectsAndGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete original zero-operand encoder row changed")
+	}
+	for _, row := range x86AccumulatorSignExtendOracle {
+		want := fmt.Sprintf("{A%s, ynone, %s, opBytes{%s}}", row.op, row.prefix, row.opcode)
+		if !strings.Contains(string(data), want) {
+			t.Fatal("independent Go opcode attributes changed", want)
+		}
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := Instr{Op: Op(row.op), Raw: row.op}
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if arch == "386" && row.write == 8 {
+					if !known || err == nil {
+						t.Fatal("Go-rejected physical qword acquired a result effect", known, err)
+					}
+					return
+				}
+				if !known || err != nil || len(effect.operands) != 2 || !effect.requiresResultProof ||
+					effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal("complete implicit AX dependency or preserved FLAGS is absent", effect, known, err)
+				}
+				read, write := effect.operands[0], effect.operands[1]
+				if read.operand.Reg != AX || read.width != row.read || !read.read || read.write ||
+					write.operand.Reg != row.destination || write.width != row.write || write.read || !write.write {
+					t.Fatal("implicit source/destination byte roles diverged", effect)
+				}
+				for missing := int64(-1); missing < row.read; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0] = uint8(1<<uint(row.read) - 1)
+					if missing >= 0 {
+						state.gp[0] &^= 1 << uint(missing)
+					}
+					if got := x86ResultTransfer(ins, &state, nil, 0, arch); got != (missing < 0) {
+						t.Fatal("implicit AX bytes borrowed implementation initialization", missing, got)
+					}
+					if state.flags != x86ByteFlagsAll {
+						t.Fatal("sign extension changed source FLAGS")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86AccumulatorSignExtendVoidNeedsSource(t *testing.T) {
+	x86AccumulatorSignExtendVoidInputs(t, false)
+}
+
+func TestX86AccumulatorSignExtendRawVoidNeedsSource(t *testing.T) {
+	x86AccumulatorSignExtendVoidInputs(t, true)
+}
+
+func x86AccumulatorSignExtendVoidInputs(t *testing.T, raw bool) {
+	t.Helper()
+	for _, row := range x86AccumulatorSignExtendOracle {
+		for _, target := range x86RawReturnTargets {
+			if target.arch == "386" && row.write == 8 {
+				continue // Actual Go mode rejection is checked separately above.
+			}
+			instruction := x86AccumulatorSignExtendSource(t, row.op, target.arch, raw)
+			source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("dead implicit input borrowed a zeroed register", row.op, target.triple, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86AccumulatorSignExtendDispatchRejectsBeforeIR(t *testing.T) {
+	for _, row := range x86AccumulatorSignExtendOracle {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, bad := range []Instr{
+				{Op: "MOVL", Raw: "foreign dispatch"},
+				{Op: Op(row.op), Args: []Operand{{Kind: OpReg, Reg: AX}}, Raw: "extra operand"},
+			} {
+				var ir strings.Builder
+				consumer := &amd64Ctx{b: &ir, goarch: arch}
+				known, terminated, err := consumer.lowerAccumulatorSignExtend(Op(row.op), bad)
+				if !known || terminated || err == nil || ir.Len() != 0 {
+					t.Fatal("invalid complete grammar emitted IR before rejection", row.op, arch, err, ir.String())
+				}
+			}
+		}
+	}
+}
+
+func TestX86AccumulatorSignExtendInitializedFiveTargetObjects(t *testing.T) {
+	x86AccumulatorSignExtendTargetObjects(t, false)
+}
+
+func TestX86AccumulatorSignExtendRawInitializedFiveTargetObjects(t *testing.T) {
+	x86AccumulatorSignExtendTargetObjects(t, true)
+}
+
+func x86AccumulatorSignExtendSource(t *testing.T, op, arch string, raw bool) string {
+	t.Helper()
+	if !raw {
+		return op
+	}
+	code := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+op+"\nRET\n")
+	return x86DwordProductDirectives(code[:len(code)-1])
+}
+
+func x86AccumulatorSignExtendTargetObjects(t *testing.T, raw bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var source, declarations strings.Builder
+			for _, row := range x86AccumulatorSignExtendOracle {
+				if target.arch == "386" && row.write == 8 {
+					continue
+				}
+				fmt.Fprintf(&declarations, "func Value%s() %s\n", row.op, typ)
+				fmt.Fprintf(&source, "TEXT ·Value%s(SB),4,$0-%d\n%s $-1,AX\n%s $7,DX\n%s\n%s %s,ret+0(FP)\nRET\n",
+					row.op, word, move, move, x86AccumulatorSignExtendSource(t, row.op, target.arch, raw), move, row.destination)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized implicit-source family lost its public result", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86AccumulatorSignExtendRawOriginCannotBeRebound(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86AccumulatorSignExtendOracle {
+			if arch == "386" && row.write == 8 {
+				continue
+			}
+			code := x86AccumulatorSignExtendSource(t, row.op, arch, true)
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+code+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawAccumulatorSignExtendSource(ins, arch) {
+				t.Fatal("actual original implicit instruction lost its source identity", row.op, arch)
+			}
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"absent-origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"opcode", func(ins *Instr) {
+					ins.Op = "CBW"
+					if row.op == "CBW" {
+						ins.Op = "CWD"
+					}
+				}},
+				{"operand", func(ins *Instr) { ins.Args = []Operand{{Kind: OpReg, Reg: AX}} }},
+				{"source-operand", func(ins *Instr) { ins.x86SourceRaw.args = []Operand{{Kind: OpReg, Reg: AX}} }},
+				{"vector-width", func(ins *Instr) { ins.x86VectorBytes = 16 }},
+				{"address", func(ins *Instr) { ins.x86AddressBits = 32 }},
+				{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+			} {
+				t.Run(arch+"/"+row.op+"/"+control.name, func(t *testing.T) {
+					changed := ins
+					origin := *ins.x86SourceRaw
+					changed.x86SourceRaw = &origin
+					control.change(&changed)
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					before := state.clone()
+					accepted, known := x86LoweredAccumulatorSignExtendResultStep(changed, &state, nil, 0, arch)
+					// This decoder's ordinary scalar form has no encoded-only
+					// flag. Removing its origin leaves a named instruction: the
+					// paired raw consumer must decline ownership, not accept it.
+					wantKnown := control.name != "absent-origin"
+					if accepted || known != wantKnown || x86RawAccumulatorSignExtendSource(changed, arch) || !reflect.DeepEqual(before, state) {
+						t.Fatal("changed raw origin borrowed implicit GP inputs or writes", accepted, known)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_accumulator_sign_extend_runtime_test.go b/x86_accumulator_sign_extend_runtime_test.go
new file mode 100644
index 000000000..1bc45a873
--- /dev/null
+++ b/x86_accumulator_sign_extend_runtime_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This executes the pure integer lowering on the actual host. Native x86
+// opcode/FLAGS execution remains owned by the original conformance suite.
+func TestX86AccumulatorSignExtendPortableValues(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	for _, row := range x86AccumulatorSignExtendOracle {
+		for _, raw := range []bool{false, true} {
+			name := fmt.Sprintf("Value%s%t", row.op, raw)
+			fmt.Fprintf(&declarations, "func %s(value, old uint64) uint64\n", name)
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t, uint64_t);\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ value+0(FP),AX\nMOVQ old+8(FP),DX\n%s\nMOVQ %s,ret+16(FP)\nRET\n",
+				name, x86AccumulatorSignExtendSource(t, row.op, "amd64", raw), row.destination)
+			high := 0
+			if row.destination == DX {
+				high = 1
+			}
+			fmt.Fprintf(&rows, "{%s, %q, %d, %d, %d},\n", name, name, row.read*8, row.write*8, high)
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static uint64_t reference(uint64_t value, uint64_t old,
+                          int source, int result, int high) {
+    uint64_t inputMask = source == 64 ? UINT64_MAX : (UINT64_C(1) << source) - 1;
+    uint64_t outputMask = result == 64 ? UINT64_MAX : (UINT64_C(1) << result) - 1;
+    int negative = (value & (UINT64_C(1) << (source - 1))) != 0;
+    uint64_t low = high ? (negative ? UINT64_MAX : 0) :
+        (value & inputMask) | (negative ? ~inputMask : 0);
+    if (result == 32) return low & UINT32_MAX;
+    return ((high ? old : value) & ~outputMask) | (low & outputMask);
+}
+static const struct {
+    uint64_t (*run)(uint64_t, uint64_t);
+    const char *name;
+    int source, result, high;
+} cases[] = {
+` + rows.String() + `};
+int main(void) {
+    const uint64_t old[] = {0, UINT64_MAX, UINT64_C(0x1122334455667788)};
+    for (unsigned row = 0; row < sizeof(cases) / sizeof(cases[0]); row++) {
+        for (unsigned bit = 0; bit < 64; bit++) {
+            for (unsigned inverted = 0; inverted < 2; inverted++) {
+                uint64_t value = UINT64_C(1) << bit;
+                if (inverted) value = ~value;
+                for (unsigned seed = 0; seed < sizeof(old) / sizeof(old[0]); seed++) {
+                    uint64_t want = reference(value, old[seed], cases[row].source,
+                                              cases[row].result, cases[row].high);
+                    uint64_t got = cases[row].run(value, old[seed]);
+                    if (got != want) {
+                        fprintf(stderr, "%s bit=%u inverted=%u seed=%u got=%llx want=%llx\n",
+                                cases[row].name, bit, inverted, seed,
+                                (unsigned long long)got, (unsigned long long)want);
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized complete integer source rejected", err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("accumulator-%s-ir%d-%s", api, index, level[1:]), triple, text, main, nil)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_addsub_round_dead_fault_unix_test.go b/x86_addsub_round_dead_fault_unix_test.go
new file mode 100644
index 000000000..451fdaf84
--- /dev/null
+++ b/x86_addsub_round_dead_fault_unix_test.go
@@ -0,0 +1,125 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Portable 64-bit-host access/fault execution only. Original Go objects are
+// observed separately; no original x86 FP/MXCSR or hardware run is implied.
+func TestX86AlternatingRoundDeadMemoryTuplesPortable(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable pointer64 fault owner requires its Linux/amd64 counterpart TestX86AlternatingRoundDeadMemoryTuplesPortable")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, rows strings.Builder
+	for index, row := range []struct {
+		instruction string
+		bytes       int
+		second      bool
+	}{
+		{"VADDSUBPS (AX),X1,X2", 16, true},
+		{"VADDSUBPS (AX),Y1,Y2", 32, true},
+		{"VADDSUBPD (AX),X1,X2", 16, true},
+		{"VADDSUBPD (AX),Y1,Y2", 32, true},
+		{"VROUNDPS $7,(AX),X2", 16, false},
+		{"VROUNDPS $7,(AX),Y2", 32, false},
+		{"VROUNDPD $7,(AX),X2", 16, false},
+		{"VROUNDPD $7,(AX),Y2", 32, false},
+		{"VROUNDSS $7,(AX),X1,X2", 4, true},
+		{"VROUNDSD $7,(AX),X1,X2", 8, true},
+	} {
+		name := fmt.Sprint("DeadAlternatingRound", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ p+0(FP),AX\n", name)
+		if row.second {
+			source.WriteString("VPXOR Y1,Y1,Y1\n")
+		}
+		fmt.Fprintln(&source, row.instruction)
+		source.WriteString("RET\n") // Rounded/arithmetic result and every alias are dead.
+		fmt.Fprintf(&declarations, "func %s(p *byte)\n", name)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t *);\n", name)
+		fmt.Fprintf(&rows, "{%s,%d},\n", name, row.bytes)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes.String() + `
+typedef struct { void (*run)(uint8_t *); unsigned bytes; } Row;
+static const Row rows[] = {` + rows.String() + `};
+int main(void) {
+    long page = sysconf(_SC_PAGESIZE);
+    if (page < 128) return 100;
+    uint8_t *memory = mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if (memory == MAP_FAILED) return 101;
+    memset(memory,0x5a,(size_t)page);
+    if (mprotect(memory,(size_t)page,PROT_READ) || mprotect(memory+page,(size_t)page,PROT_NONE)) return 102;
+    unsigned observations = 0, failures = 0;
+    for (unsigned row=0;row<sizeof(rows)/sizeof(rows[0]);++row) {
+        for (int kind=0;kind<3;++kind) {
+            // NULL; precisely one complete original tuple; one byte short.
+            // In particular scalar4/8 must not overread an X carrier.
+            uint8_t *input = kind==0 ? (uint8_t *)0 : memory+page-rows[row].bytes+(kind==2);
+            int trace[2];
+            if (pipe(trace)) return 103;
+            pid_t child = fork();
+            if (child < 0) return 104;
+            if (!child) {
+                close(trace[0]);
+                struct rlimit limit = {0,0};
+                if (setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+                if (write(trace[1],"E",1)!=1) _exit(121);
+                rows[row].run(input);
+                // Do not read input here: a C probe must not supply the
+                // missing NULL/partial-tuple fault on the kernel's behalf.
+                for (unsigned byte=0;byte<16;++byte) if (memory[byte]!=0x5a) _exit(122);
+                if (write(trace[1],"C",1)!=1) _exit(123);
+                _exit(0);
+            }
+            close(trace[1]);
+            int status=0;
+            pid_t waited;
+            do { waited=waitpid(child,&status,0); } while (waited<0 && errno==EINTR);
+            if (waited!=child) return 105;
+            char observed[3]={0,0,0};
+            ssize_t count=read(trace[0],observed,sizeof(observed));
+            close(trace[0]);
+            int fault=WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS);
+            int normal=WIFEXITED(status) && WEXITSTATUS(status)==0;
+            int expectedFault=kind!=1;
+            if (expectedFault ? !(fault && count==1 && observed[0]=='E') : !(normal && count==2 && observed[0]=='E' && observed[1]=='C')) {
+                fprintf(stderr,"dead-fp row=%u bytes=%u kind=%d status=%x trace=%s count=%ld\n",row,rows[row].bytes,kind,status,observed,(long)count);
+                ++failures;
+            }
+            ++observations;
+        }
+    }
+    if (munmap(memory,(size_t)page*2)) return 106;
+    printf("dead-fp kernels=10 observations=%u\n",observations);
+    return observations==30 ? (failures ? 3 : 0) : 4;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized dead-result source rejected before fault execution; not a semantic fault RED", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "dead-alternating-round", triple, ir, driver)
+		})
+	}
+}
diff --git a/x86_addsub_round_native_gates_test.go b/x86_addsub_round_native_gates_test.go
new file mode 100644
index 000000000..0dc6bc94d
--- /dev/null
+++ b/x86_addsub_round_native_gates_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86AlternatingRoundNativeContinuationBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			text            string
+			vex, pairedRead bool
+			tuple, carrier  int
+		}{
+			{"ADDSUBPS (AX),X1", false, true, 16, 16},
+			{"VADDSUBPS (AX),Y1,Y2", true, true, 32, 32},
+			{"ROUNDPS $7,(AX),X2", false, true, 16, 16},
+			{"VROUNDPS $7,(AX),Y2", true, true, 32, 32},
+			{"ROUNDSS $7,(AX),X2", false, true, 4, 16},
+			{"VROUNDSS $7,(AX),X1,X2", true, true, 4, 16},
+			{"ROUNDSD $7,(AX),X2", false, true, 8, 16},
+			{"VROUNDSD $7,(AX),X1,X2", true, true, 8, 16},
+		} {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				if arch == "386" && (ins.Op == "VROUNDSS" || ins.Op == "VROUNDSD") {
+					if _, known, err := x86RoundProperties(ins, arch); !known || err == nil {
+						t.Fatal("ordinary mode32 scalar four-operand source lost its Go refusal")
+					}
+					return // A source rejection is not a tested native-memory continuation.
+				}
+				round := strings.Contains(row.text, "ROUND")
+				memory, destination := 0, 1
+				if round {
+					memory, destination = 1, len(ins.Args)-1
+				} else if row.vex {
+					destination = 2
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.pointerGP[0] = true
+				// Partial high aliases distinguish legacy preservation from VEX zeroing.
+				state.writeVector(1, 64, 0xffffffff, false)
+				state.writeVector(2, 64, 0xffffffffffff, false)
+				apply := func(i Instr, s *x86ResultState, native bool) (bool, bool) {
+					if round {
+						return x86ResultRoundStep(i, s, nil, arch, native)
+					}
+					return x86ResultAlternatingFloatStep(i, s, nil, arch, native)
+				}
+				for _, change := range []string{"paired", "unpaired", "numeric-base", "missing-index", "raw", "address-size", "segment", "missing-upper"} {
+					current, changed := state.clone(), ins
+					changed.Args = append([]Operand(nil), ins.Args...)
+					native := true
+					switch change {
+					case "unpaired":
+						native = false
+					case "numeric-base":
+						current.pointerGP[0] = false
+						current.gp[0] = 0xff
+					case "missing-index":
+						changed.Args[memory].Mem.Index, changed.Args[memory].Mem.Scale = DX, 2
+					case "raw":
+						changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+					case "address-size":
+						changed.x86AddressBits = 16
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "missing-upper":
+						current.writeVector(1, 64, 0, false)
+						current.writeVector(2, 64, 0, false)
+					}
+					before := current.clone()
+					accepted, known := apply(changed, &current, native)
+					// Encoding selects operand roles and upper aliases. Paired read
+					// permission is independent: legacy memory now has a whole SSE
+					// emitter too. Scalar ROUND propagates only available upper bytes.
+					want := row.pairedRead && (change == "paired" || change == "numeric-base" || change == "missing-upper" && round ||
+						change == "raw" && row.vex && !round)
+					if change == "raw" && row.vex && !round {
+						// This primitive checks exact instruction metadata, not the
+						// original whole producer. Its caller must check replay first.
+						fake := Func{Sym: "fake", Instrs: []Instr{changed}}
+						if err := x86LoweredNumericalProducerReplay(fake, arch); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("fabricated raw primitive acquired whole-source replay", err)
+						}
+					}
+					if !known || accepted != want {
+						t.Fatal("paired source contract or encoding role changed", change, known, accepted, want)
+					}
+					if !accepted {
+						if !reflect.DeepEqual(before, current) {
+							t.Fatal("rejected result changed source state", change)
+						}
+						continue
+					}
+					expected := before.clone()
+					index, _ := amd64VectorRegisterIndex(ins.Args[destination].Reg, row.carrier)
+					defined := x86CallerVectorByteMask(int64(row.carrier))
+					if change == "missing-upper" && round && (strings.HasSuffix(string(ins.Op), "SS") || strings.HasSuffix(string(ins.Op), "SD")) {
+						defined = x86CallerVectorByteMask(int64(row.tuple))
+					}
+					expected.writeVector(index, row.carrier, defined, !row.vex)
+					if !reflect.DeepEqual(current, expected) {
+						t.Fatal("native read changed pointer, FLAGS, unrelated bytes or storage", change)
+					}
+					if x86ResultRead(changed.Args[memory], int64(row.tuple), &current, nil, arch) {
+						t.Fatal("paired read granted later numerical storage", change)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86AlternatingRoundGrammarIsNotModeOrNativeAuthority(t *testing.T) {
+	// Existing VEX ADDSUB grammar accepts Go's high X/Y class in mode32;
+	// numerical transfer independently refuses an inaccessible physical bank.
+	ins := x86ScalarLaneInstruction(t, "VADDSUBPS (AX),Y14,Y15")
+	form, known, err := x86AlternatingFloatProperties(ins, "386")
+	if !known || err != nil || form.byteWidth != 32 || form.memoryBytes != 32 {
+		t.Fatal("original VEX grammar or tuple changed", known, err)
+	}
+	state := x86ResultState{}
+	state.pointerGP[0] = true
+	state.writeVector(14, 64, ^uint64(0), false)
+	before := state.clone()
+	if accepted, known := x86ResultAlternatingFloatStep(ins, &state, nil, "386", true); !known || accepted || !reflect.DeepEqual(before, state) {
+		t.Fatal("grammar authorized a mode32 high physical register")
+	}
+	for _, text := range []string{"VROUNDSS $7,(R8),X1,X2", "VADDSUBPS (R8),Y1,Y2"} {
+		ins := x86ScalarLaneInstruction(t, text)
+		state := x86ResultState{}
+		state.pointerGP[8] = true
+		state.writeVector(1, 64, ^uint64(0), false)
+		before := state.clone()
+		var accepted, known bool
+		if strings.Contains(text, "ROUND") {
+			accepted, known = x86ResultRoundStep(ins, &state, nil, "386", true)
+		} else {
+			accepted, known = x86ResultAlternatingFloatStep(ins, &state, nil, "386", true)
+		}
+		if !known || accepted || !reflect.DeepEqual(before, state) {
+			t.Fatal("memory syntax granted a mode32 R8 pointer", text)
+		}
+	}
+	for _, text := range []string{"VROUNDSS $7,(AX),X8,X2", "VROUNDPD $7,(AX),Y8"} {
+		if _, known, err := x86RoundProperties(x86ScalarLaneInstruction(t, text), "386"); !known || err == nil {
+			t.Fatal("ROUND original mode32 carrier restriction changed", text)
+		}
+	}
+	for _, row := range []struct {
+		text  string
+		tuple int64
+	}{
+		{"VROUNDSS $7,(AX),X1,X2", 4},
+		{"VROUNDSD $7,(AX),X1,X2", 8},
+		{"VROUNDPD $7,(AX),Y2", 32},
+	} {
+		ins := x86ScalarLaneInstruction(t, row.text)
+		// Physical tuple/effect inspection only, not ordinary source or NUM authority.
+		ins.x86Encoded = true
+		form, known, err := x86RoundProperties(ins, "386")
+		effect, effectKnown, effectErr := x86TypedRoundByteEffect(ins.Op, ins, "386")
+		if !known || err != nil || !effectKnown || effectErr != nil || int64(form.memoryBytes) != row.tuple || effect.operands[1].width != row.tuple || !effect.requiresResultProof {
+			t.Fatal("scalar native tuple became a vector carrier or lost its source proof", row.text)
+		}
+		if form.spec.scalar && (len(effect.operands) != 4 || !effect.operands[2].read || effect.operands[2].requiredBytes != (0xffff&^x86CallerVectorByteMask(row.tuple))) {
+			t.Fatal("scalar upper-copy bytes lost their independent typed source obligation", row.text)
+		}
+	}
+	for _, text := range []string{"ADDSUBPS X0,X1", "ADDSUBPD X0,X1", "ROUNDPS $7,X0,X1", "ROUNDPD $7,X0,X1", "ROUNDSS $7,X0,X1", "ROUNDSD $7,X0,X1"} {
+		ins := x86ScalarLaneInstruction(t, text)
+		for _, native := range []bool{false, true} {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.writeVector(0, 64, ^uint64(0), false)
+			state.writeVector(1, 64, ^uint64(0), false)
+			before := state.clone()
+			var accepted, known bool
+			if strings.Contains(text, "ROUND") {
+				accepted, known = x86ResultRoundStep(ins, &state, nil, "386", native)
+			} else {
+				accepted, known = x86ResultAlternatingFloatStep(ins, &state, nil, "386", native)
+			}
+			if !known || !accepted || !reflect.DeepEqual(before, state) {
+				t.Fatal("fully defined legacy registers depended on native read permission or lost aliases", text, native)
+			}
+		}
+	}
+}
diff --git a/x86_adx_effect_test.go b/x86_adx_effect_test.go
new file mode 100644
index 000000000..3d047a7fe
--- /dev/null
+++ b/x86_adx_effect_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ADXSelectedCarryAndEveryInputByte(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			width, flag := 4, uint8(x86ByteFlagCF)
+			if strings.HasSuffix(op, "Q") {
+				width = 8
+			}
+			if strings.HasPrefix(op, "ADOX") {
+				flag = x86ByteFlagOF
+			}
+			ins := x86YMMReadSource(t, op+" AX,BX")
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if !known || err != nil || !effect.requiresResultProof || effect.flagsRead != flag || effect.flagsDefined != flag || effect.flagsKilled != flag {
+				t.Fatal("complete typed carry obligation differs", op, known, err)
+			}
+			for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagOF, x86ByteFlagCF | x86ByteFlagOF} {
+				for missing := -1; missing < width*2; missing++ {
+					t.Run(fmt.Sprintf("%s/%s/flags=%d/missing=%d", arch, op, flags, missing), func(t *testing.T) {
+						state := x86ResultState{flags: flags}
+						state.gp[0], state.gp[3] = uint8((1<<uint(width))-1), uint8((1<<uint(width))-1)
+						if missing >= 0 {
+							index := 0
+							if missing >= width {
+								index = 3
+							}
+							state.gp[index] &^= 1 << uint(missing%width)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						want := missing < 0 && flags&flag != 0
+						if accepted != want || !accepted && !reflect.DeepEqual(before, state) {
+							t.Fatal("ADX borrowed wrong carry/missing byte or changed rejected state", accepted, want)
+						}
+						if accepted {
+							before.gp[3] = 0xff
+							if !reflect.DeepEqual(before, state) {
+								t.Fatal("ADX changed unrelated state or failed dword zero extension")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ADXVoidAndUnusedBoolRequireSelectedCarry(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if target.arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			for _, unusedBool := range []bool{false, true} {
+				for _, seed := range []string{"CF", "OF"} {
+					t.Run(fmt.Sprintf("%s/%s/bool=%t/seed=%s", target.triple, op, unusedBool, seed), func(t *testing.T) {
+						extent, declaration := 0, "func Value()"
+						if unusedBool {
+							extent, declaration = 1, "func Value(unused bool)"
+						}
+						flags := "CLC\n"
+						if seed == "OF" {
+							flags = "MOVL $0x7fffffff,DX\nINCL DX\n"
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVL $7,AX\nMOVL $3,BX\n%s%s AX,BX\nRET\n", extent, flags, op)
+						valid := (seed == "OF") == strings.HasPrefix(op, "ADOX")
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if valid {
+								if err != nil || ir == "" {
+									t.Fatal("initialized selected carry rejected", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unused result/bool borrowed the other carry chain", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ADXRawDefaultModeAndOriginCannotBeRebound(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, op+" AX,BX")+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawADXSource(ins, arch) || ins.x86SourceRaw.addressBits != goWordSize(arch)*8 {
+				t.Fatal("raw ADX lost its exact original default address mode", arch, op)
+			}
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"opcode", func(ins *Instr) {
+					ins.Op = "ADCXL"
+					if ins.x86SourceRaw.op == "ADCXL" {
+						ins.Op = "ADOXL"
+					}
+				}},
+				{"operand", func(ins *Instr) { ins.Args[0].Reg = DX }},
+				{"source-operand", func(ins *Instr) { ins.x86SourceRaw.args[0].Reg = DX }},
+				{"address", func(ins *Instr) { ins.x86AddressBits /= 2 }},
+				{"source-address", func(ins *Instr) { ins.x86SourceRaw.addressBits /= 2 }},
+				{"missing-address", func(ins *Instr) { ins.x86AddressBits = 0 }},
+				{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+				{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+			} {
+				t.Run(arch+"/"+op+"/"+control.name, func(t *testing.T) {
+					changed := ins
+					changed.Args = append([]Operand(nil), ins.Args...)
+					origin := *ins.x86SourceRaw
+					origin.args = append([]Operand(nil), origin.args...)
+					changed.x86SourceRaw = &origin
+					control.change(&changed)
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[3] = 0xff, 0xff
+					before := state.clone()
+					accepted, known := x86LoweredADXResultStep(changed, &state, nil, 0, arch)
+					if accepted || !known || x86RawADXSource(changed, arch) || !reflect.DeepEqual(before, state) {
+						t.Fatal("changed ADX origin/mode borrowed a numerical continuation", accepted, known)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_adx_native_input_test.go b/x86_adx_native_input_test.go
new file mode 100644
index 000000000..b754ee61b
--- /dev/null
+++ b/x86_adx_native_input_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ADXDeadNativeReadsKeepExactWidthAndInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if word == 4 {
+			move = "MOVL"
+		}
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if word == 4 && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			bits := 32
+			if strings.HasSuffix(op, "Q") {
+				bits = 64
+			}
+			for _, raw := range []bool{false, true} {
+				line := op + " 3(AX)(DX*2),BX"
+				if raw {
+					line = x86RawNumericalInstruction(t, target.arch, line)
+				}
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\nMOVL $7,BX\nCMPL BX,BX\n%s\nRET\n", word, move, line)
+				variants := []struct{ name, source string }{
+					{"initialized", source},
+					{"unknown-address", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+					{"numerical-address", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+					{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+					{"unknown-destination", strings.Replace(source, "MOVL $7,BX\nCMPL BX,BX", "MOVL $7,CX\nCMPL CX,CX", 1)},
+					{"unknown-carry", strings.Replace(source, "CMPL BX,BX\n", "", 1)},
+				}
+				for _, variant := range variants {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/%s", target.triple, op, raw, variant.name), func(t *testing.T) {
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, variant.source, "func Value(p *[16]byte)", target.arch, target.triple, api)
+							if variant.name != "initialized" && variant.name != "numerical-address" {
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("dead ADX borrowed an unknown native input", api, err)
+								}
+								continue
+							}
+							if err != nil {
+								t.Fatal("initialized dead native source rejected", api, err)
+							}
+							if variant.name == "numerical-address" {
+								x86RequireNumericNativeSourceContext(t, variant.source, "func Value(p *[16]byte)", target.arch)
+								x86NumericNativeAddressObject(t, ir, target.triple)
+							}
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								// Keep emitter alignment independent from O2's valid
+								// deductions about a fully defined constant address.
+								if strings.Count(text, fmt.Sprintf("load volatile i%d,", bits)) != 1 || !strings.Contains(ir, ", align 1") || strings.Contains(text, "dereferenceable") {
+									t.Fatal("dead native ADX lost its exact unaligned volatile read", api)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_adx_original_fixture_test.go b/x86_adx_original_fixture_test.go
new file mode 100644
index 000000000..99a81751d
--- /dev/null
+++ b/x86_adx_original_fixture_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86ADXOriginalRuntimeSource = `TEXT adxsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+
+	// ADCXL consumes CF, updates only CF, and zero-extends its destination.
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVL $-1, AX
+	MOVL $0, BX
+	ADCXL AX, BX
+	MOVQ BX, 0(DI)
+	SETCS 8(DI)
+	SETOS 9(DI)
+	SETEQ 10(DI)
+	SETMI 11(DI)
+
+	// ADOXL consumes OF, updates only OF, and leaves CF untouched.
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVL $-1, AX
+	MOVL $0, BX
+	ADOXL AX, BX
+	MOVQ BX, 16(DI)
+	SETOS 24(DI)
+	SETCS 25(DI)
+	SETEQ 26(DI)
+	SETMI 27(DI)
+
+	// The Q-width memory form uses CF while preserving OF and ZF.
+	XORQ R8, R8
+	STC
+	MOVQ $-1, 32(DI)
+	MOVQ $0, BX
+	ADCXQ 32(DI), BX
+	MOVQ BX, 40(DI)
+	SETCS 48(DI)
+	SETOS 49(DI)
+	SETEQ 50(DI)
+
+	// ADOXQ memory form consumes OF without changing CF, ZF or SF.
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+	MOVQ $0, BX
+	ADOXQ 32(DI), BX
+	MOVQ BX, 56(DI)
+	SETOS 64(DI)
+	SETCS 65(DI)
+	SETEQ 66(DI)
+	SETMI 67(DI)
+	RET
+`
+
+func x86ADXOriginalRawSource(source string) string {
+	return strings.NewReplacer(
+		"ADCXL AX, BX", "BYTE $0x66; BYTE $0x0f; BYTE $0x38; BYTE $0xf6; BYTE $0xd8",
+		"ADOXL AX, BX", "BYTE $0xf3; BYTE $0x0f; BYTE $0x38; BYTE $0xf6; BYTE $0xd8",
+		"ADCXQ 32(DI), BX", "BYTE $0x66; BYTE $0x48; BYTE $0x0f; BYTE $0x38; BYTE $0xf6; BYTE $0x5f; BYTE $0x20",
+		"ADOXQ 32(DI), BX", "BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0x38; BYTE $0xf6; BYTE $0x5f; BYTE $0x20",
+	).Replace(source)
+}
+
+func TestX86ADXOriginalRuntimeSourceObjects(t *testing.T) {
+	for _, raw := range []bool{false, true} {
+		source := x86ADXOriginalRuntimeSource
+		if raw {
+			source = x86ADXOriginalRawSource(source)
+		}
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(fmt.Sprintf("%s/raw=%t", triple, raw), func(t *testing.T) {
+				x86RawNumericalFamilyObjects(t, source, "func adxsemantics(out *[72]byte)", "amd64", triple)
+			})
+		}
+	}
+}
+
+func TestX86ADXInitializedFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			widths := []string{"L", "Q"}
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+				widths = widths[:1]
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, stem := range []string{"ADCX", "ADOX"} {
+				for _, width := range widths {
+					for _, memory := range []bool{false, true} {
+						for _, raw := range []bool{false, true} {
+							name, input := fmt.Sprintf("Value%d", count), "AX"
+							if memory {
+								input = "(DX)"
+							}
+							line := stem + width + " " + input + ",BX"
+							if raw {
+								line = x86RawNumericalInstruction(t, target.arch, line)
+							}
+							fmt.Fprintf(&declarations, "func %s(value uintptr,input *[8]byte) uintptr\n", name)
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s value+0(FP),AX\n%s input+%d(FP),DX\n%s $-1,BX\nCMPL AX,AX\n%s\n%s BX,ret+%d(FP)\nRET\n", name, word*3, move, move, word, move, line, move, word*2)
+							count++
+						}
+					}
+				}
+			}
+			if count != 8*len(widths) {
+				t.Fatal("complete named/raw register/memory ADX denominator changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
diff --git a/x86_adx_portable_runtime_test.go b/x86_adx_portable_runtime_test.go
new file mode 100644
index 000000000..9ae94968e
--- /dev/null
+++ b/x86_adx_portable_runtime_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86ADXOriginalRuntimeDriver = `
+#include <stdint.h>
+#include <string.h>
+extern void adxsemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[72] = {0};
+  adxsemantics(out);
+  if (load64(out + 0) != 0) return 10;
+  const uint8_t adcx_flags[4] = {1, 1, 0, 1};
+  for (int i = 0; i < 4; i++) if (out[8+i] != adcx_flags[i]) return 20+i;
+  if (load64(out + 16) != 0) return 30;
+  const uint8_t adox_flags[4] = {1, 1, 0, 1};
+  for (int i = 0; i < 4; i++) if (out[24+i] != adox_flags[i]) return 40+i;
+  if (load64(out + 40) != 0) return 50;
+  const uint8_t adcxq_flags[3] = {1, 0, 1};
+  for (int i = 0; i < 3; i++) if (out[48+i] != adcxq_flags[i]) return 60+i;
+  if (load64(out + 56) != 0) return 70;
+  const uint8_t adoxq_flags[4] = {1, 1, 0, 1};
+  for (int i = 0; i < 4; i++) if (out[64+i] != adoxq_flags[i]) return 80+i;
+  return 0;
+}
+`
+
+// This executes the unchanged source's integer values and independent carry
+// chains on the actual host. Native original ADX execution remains required.
+func TestX86ADXOriginalSourcePortableValuesAndCarryChains(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	driver := strings.Replace(x86ADXOriginalRuntimeDriver, "uint8_t out[72] = {0};", "uint8_t storage[74];\n  memset(storage,0xc3,sizeof(storage));\n  uint8_t *out=storage+1;", 1)
+	driver = strings.Replace(driver, "  return 0;", "  if(storage[0]!=0xc3 || storage[73]!=0xc3) return 1;\n  return 0;", 1)
+	if driver == x86ADXOriginalRuntimeDriver || !strings.Contains(driver, "storage[73]") {
+		t.Fatal("independent unaligned driver lost its canaries")
+	}
+	for _, raw := range []bool{false, true} {
+		source := x86ADXOriginalRuntimeSource
+		if raw {
+			source = x86ADXOriginalRawSource(source)
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("raw=%t/%s", raw, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func adxsemantics(out *[72]byte)", "amd64", triple, api)
+				if err != nil {
+					t.Fatal("complete original independent carry-chain source rejected", err)
+				}
+				for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						compileAndRunRuntimeTestForTarget(t, llc, clang, fmt.Sprintf("adx-%t-%s-ir%d-%s", raw, api, index, level[1:]), triple, text, driver, nil)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_aes_native_input_test.go b/x86_aes_native_input_test.go
new file mode 100644
index 000000000..7bd2e8bbc
--- /dev/null
+++ b/x86_aes_native_input_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86AESPairedNativeCompleteFamilyFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			for _, raw := range []bool{false, true} {
+				var source, declarations strings.Builder
+				count := 0
+				for _, name := range x86AESOracleNames {
+					banks := []string{"X"}
+					if strings.HasPrefix(name, "V") && !strings.Contains(name, "IMC") && !strings.Contains(name, "KEYGEN") {
+						banks = append(banks, "Y", "Z")
+					}
+					for _, bank := range banks {
+						operation, destination := x86AESOracleRow(name, "(SI)", bank)
+						if raw {
+							operation = x86RawNumericalInstruction(t, target.arch, operation)
+						}
+						function := fmt.Sprint("AESRead", count)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n"+
+							"MOV%s input+%d(FP),SI\nMOV%s old+%d(FP),BX\nVMOVUPS (BX),Z1\nVMOVUPS (BX),Z2\n"+
+							"PUSH%s $0\nPOPF%s\n%s\nVMOVUPS Z%d,(DI)\nPUSHF%s\nPOP%s AX\nMOV%s AX,64(DI)\nRET\n",
+							function, 3*word, suffix, suffix, word, suffix, 2*word, suffix, suffix, operation,
+							destination, suffix, suffix, suffix)
+						fmt.Fprintf(&declarations, "func %s(out *[80]byte,input,old *[64]byte)\n", function)
+						count++
+					}
+				}
+				if count != 20 {
+					t.Fatal("complete AES/VAES round, inverse-mix and key-assist inventory changed", count)
+				}
+				x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+			}
+		})
+	}
+}
+
+func TestX86AESDeadNativeInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range x86AESOracleNames {
+			operation, _ := x86AESOracleRow(name, "(SI)", "X")
+			for _, raw := range []bool{false, true} {
+				instruction := operation
+				if raw {
+					instruction = x86RawNumericalInstruction(t, target.arch, operation)
+				}
+				source := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("AES borrowed native inputs from Void or unused bool", name, raw, target.triple, declaration, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_aes_native_state_test.go b/x86_aes_native_state_test.go
new file mode 100644
index 000000000..c4d7a6e54
--- /dev/null
+++ b/x86_aes_native_state_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86AESNativePreservesIndependentStateAndStandaloneBoundary(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range x86AESOracleNames {
+			row, destination := x86AESOracleRow(name, "(SI)", "X")
+			ins := x86ScalarLaneInstruction(t, row)
+			for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+				state := x86ResultState{flags: flags, direction: x86ResultDirectionEither}
+				state.pointerGP[6], state.gp[3], state.xmm[1] = true, 0x55, 0xffff
+				state.masks[2], state.vectorUpper[1], state.vectorUpper[2] = true, 0x12340000, 0x56780000
+				before := state.clone()
+				if accepted, known := x86ResultAESStep(ins, &state, nil, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone AES acquired native backing or mutated a failed proof", arch, name)
+				}
+				want := state.clone()
+				want.writeVector(destination, 16, 0xffff, !strings.HasPrefix(name, "V"))
+				if accepted, known := x86LoweredAESResultStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, want) {
+					t.Fatal("AES continuation changed an independent GP, flag, mask or vector alias", arch, name, flags)
+				}
+			}
+		}
+	}
+}
+
+func TestX86AESKeyAssistRequiresOnlyItsNumericalRegisterSubwords(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"AESKEYGENASSIST", "VAESKEYGENASSIST"} {
+			row, _ := x86AESOracleRow(name, "X0", "X")
+			ins := x86ScalarLaneInstruction(t, row)
+			for missing := -1; missing < 16; missing++ {
+				state := x86ResultState{flags: x86ByteFlagAF}
+				state.xmm[0] = 0xf0f0 // Only source dwords one and three contribute.
+				if missing >= 0 {
+					state.xmm[0] &^= 1 << uint(missing)
+				}
+				before := state.clone()
+				defined := uint64(0xffff)
+				if missing >= 0 && missing%8 >= 4 {
+					// Each used input byte contributes to the unrotated and
+					// rotated output dwords in its eight-byte half.
+					half, at := missing/8*8, missing%4
+					defined &^= uint64(1)<<uint(half+at) | uint64(1)<<uint(half+4+(at+3)%4)
+				}
+				want := before.clone()
+				want.writeVector(2, 16, defined, !strings.HasPrefix(name, "V"))
+				accepted, known := x86LoweredAESResultStep(ins, &state, nil, arch)
+				if !known || !accepted || !reflect.DeepEqual(state, want) {
+					t.Fatal("key assist invented used bytes or required irrelevant register data", arch, name, missing, accepted)
+				}
+			}
+		}
+	}
+}
+
+func TestX86AESRawIdentityCannotBorrowPrivateControlOrInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range x86AESOracleNames {
+			row, destination := x86AESOracleRow(name, "(SI)", "X")
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawAESSource(ins, arch) || !x86ResultPreservesPrivateStorage(ins, arch) ||
+				x86PreservesNumericalSourceState(ins) {
+				t.Fatal("exact data-changing AES source lost its distinct private-control role", arch, name)
+			}
+			for _, change := range []func(*Instr){
+				func(ins *Instr) { ins.x86SourceRaw = nil },
+				func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = "X3" },
+				func(ins *Instr) { ins.x86AddressBits = 16 },
+				func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+				func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+				func(ins *Instr) { ins.x86RIPLiteral = true },
+			} {
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				change(&changed)
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.pointerGP[6], state.xmm[1] = true, 0xffff
+				if x86ResultNamedPredicateInstruction(changed) {
+					// Removing all legacy origin metadata is a fresh named
+					// operation, not a forged raw marker. Its paired native
+					// read may use complete numerical address bits.
+					state.pointerGP[6], state.gp[6] = false, 0xff
+				}
+				before := state.clone()
+				accepted, known := x86LoweredAESResultStep(changed, &state, nil, arch)
+				if x86ResultNamedPredicateInstruction(changed) {
+					expected := before.clone()
+					expected.writeVector(destination, 16, 0xffff, !strings.HasPrefix(name, "V"))
+					if !known || !accepted || !reflect.DeepEqual(state, expected) || x86RawAESSource(changed, arch) {
+						t.Fatal("named numerical AES read changed independent state or acquired a raw role", arch, name)
+					}
+					for _, available := range []uint8{0, 1} {
+						partial := before.clone()
+						partial.gp[6] = available
+						unchanged := partial.clone()
+						if accepted, _ := x86LoweredAESResultStep(changed, &partial, nil, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+							t.Fatal("named AES borrowed unknown or partial address bytes", arch, name, available)
+						}
+					}
+					continue
+				}
+				if !known || accepted || !reflect.DeepEqual(state, before) || x86RawAESSource(changed, arch) ||
+					!x86ResultNamedPredicateInstruction(changed) && (x86ResultPreservesPrivateStorage(changed, arch) ||
+						x86ResultDirectionAfterSource(changed, x86ResultDirectionEither, arch) != x86ResultDirectionUnknown) {
+					t.Fatal("changed AES source borrowed numerical inputs or private controls", arch, name)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawImmediateFirstDataRoleBindsTheWholeOriginalInstruction(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"AESKEYGENASSIST", "VAESKEYGENASSIST"} {
+			row, _ := x86AESOracleRow(name, "(SI)", "X")
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if x86RawOrdinaryVectorSource(ins, arch) || !x86RawOrdinaryVectorSourceAt(ins, arch, 1) ||
+				!x86RawAESSource(ins, arch) || x86RawOrdinaryVectorSourceAt(ins, arch, -1) ||
+				x86RawOrdinaryVectorSourceAt(ins, arch, len(ins.Args)) {
+				t.Fatal("immediate-first grammar rewrote the source or borrowed the selector as data", arch, name)
+			}
+			changed := ins
+			changed.Args = append([]Operand(nil), ins.Args...)
+			changed.Args[0].Imm++
+			if x86RawAESSource(changed, arch) || x86RawOrdinaryVectorSourceAt(changed, arch, 1) {
+				t.Fatal("unchanged data operand hid a changed original immediate", arch, name)
+			}
+		}
+	}
+}
diff --git a/x86_aes_unknown_result_test.go b/x86_aes_unknown_result_test.go
new file mode 100644
index 000000000..0e00d98b0
--- /dev/null
+++ b/x86_aes_unknown_result_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86AESDeadRegisterResultsStayUnknownWithoutChangingFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range x86AESOracleNames {
+			row, destination := x86AESOracleRow(name, "X0", "X")
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+			state.xmm[1], state.vectorUpper[destination] = 0xffff, 0x12340000
+			state.pointerGP[6], state.gp[3], state.masks[2] = true, 0x55, true
+			want := state.clone()
+			want.writeVector(destination, 16, 0, !strings.HasPrefix(name, "V"))
+			accepted, known := x86LoweredAESResultStep(x86ScalarLaneInstruction(t, row), &state, nil, arch)
+			if !known || !accepted || !reflect.DeepEqual(state, want) {
+				t.Fatal("dead nontrapping AES result must remain unknown without erasing independent FLAGS", arch, row)
+			}
+		}
+	}
+}
+
+func TestX86AESUnknownRegisterResultsCannotBecomeObservableValues(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range x86AESOracleNames {
+			row, destination := x86AESOracleRow(name, "X0", "X")
+			for _, raw := range []bool{false, true} {
+				instruction := row
+				if raw {
+					instruction = x86RawNumericalInstruction(t, target.arch, row)
+				}
+				for _, observe := range []bool{false, true} {
+					body := "MOVL $1,AX\nMOVL AX,X1\n" + instruction + "\n"
+					if observe {
+						body += fmt.Sprintf("MOVL X%d,AX\nTESTL AX,AX\nSETEQ CX\n", destination)
+					}
+					source := "TEXT ·Value(SB),4,$0-1\n" + body + "RET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(unused bool)", target.arch, target.triple, api)
+						if observe {
+							if target.arch == "amd64" && !raw {
+								x86VectorScratchCodegenControl(t, source, "func Value(unused bool)", target.arch, target.triple, ir, err)
+								continue
+							}
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown AES data escaped through a numerical/control use", target, name, raw, api, err)
+							}
+						} else if err != nil || ir == "" {
+							t.Fatal("dead register AES invented an obligation unrelated to its observable source effects", target, name, raw, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_ah_flags_inputs_test.go b/x86_ah_flags_inputs_test.go
new file mode 100644
index 000000000..9266ff1ad
--- /dev/null
+++ b/x86_ah_flags_inputs_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86AHFlagsCompleteGoFormsAndEffects(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}",
+		"{ALAHF, ynone, Px, opBytes{0x9f}}",
+		"{ASAHF, ynone, Px, opBytes{0x9e, 00, 0x86, 0xe0, 0x50, 0x9d}}",
+	} {
+		if !strings.Contains(string(data), row) {
+			t.Fatal("actual Go complete AH/FLAGS row changed", row)
+		}
+	}
+	const observed = x86ByteFlagCF | x86ByteFlagPF | x86ByteFlagAF | x86ByteFlagZF | x86ByteFlagSF
+	for _, arch := range []string{"386", "amd64"} {
+		code := x86PackedShiftActualGoBytes(t, arch, "TEXT flags(SB),4,$0-0\nLAHF\nSAHF\nRET\n")
+		if !bytes.Equal(code, []byte{0x9f, 0x9e, 0xc3}) {
+			t.Fatalf("%s actual original AH/FLAGS bytes changed: %x", arch, code)
+		}
+		for _, op := range []string{"LAHF", "SAHF"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op)
+				before := ins
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 1 || !effect.requiresResultProof || effect.dynamicMemory {
+					t.Fatal("complete AH/FLAGS family lacks its typed implicit byte effect", effect, known, err)
+				}
+				operand := effect.operands[0]
+				if operand.index != -1 || operand.operand.Kind != OpReg || operand.operand.Reg != AH ||
+					operand.width != 1 || operand.read != (op == "SAHF") || operand.write != (op == "LAHF") {
+					t.Fatal("implicit AH must be exactly the high byte, never AL or the full AX", operand)
+				}
+				if op == "LAHF" && (effect.flagsRead != observed || effect.flagsDefined != 0 || effect.flagsKilled != 0) ||
+					op == "SAHF" && (effect.flagsRead != 0 || effect.flagsDefined != observed || effect.flagsKilled != observed) {
+					t.Fatal("five flag transfers must not consume, create or kill OF", effect)
+				}
+				if !reflect.DeepEqual(ins, before) {
+					t.Fatal("AH/FLAGS effect changed its original instruction")
+				}
+			})
+		}
+	}
+}
+
+func x86AHFlagsCompleteSource(arch string) (string, string) {
+	smallResult, mixedResult := 8, 16
+	if arch == "386" {
+		smallResult, mixedResult = 4, 12
+	}
+	return fmt.Sprintf(`TEXT ·AHLoad(SB),4,$0-12
+MOVL a+0(FP),AX
+MOVL b+4(FP),BX
+CMPL AX,BX
+LAHF
+MOVBLZX AH,AX
+MOVL AX,ret+8(FP)
+RET
+TEXT ·AHStoreAndLoad(SB),4,$0-%d
+MOVW flags+0(FP),AX
+SAHF
+LAHF
+MOVBLZX AH,AX
+MOVL AX,ret+%d(FP)
+RET
+TEXT ·AHPreserveOF(SB),4,$0-%d
+MOVW flags+0(FP),AX
+MOVL a+4(FP),BX
+MOVL b+8(FP),CX
+ADDL CX,BX
+SAHF
+SETOS DL
+LAHF
+MOVBLZX AH,AX
+MOVBLZX DL,DX
+SHLL $8,DX
+ORL DX,AX
+MOVL AX,ret+%d(FP)
+RET
+TEXT ·AHByteOnly(SB),4,$0-%d
+MOVB flags+0(FP),AH
+SAHF
+LAHF
+MOVBLZX AH,AX
+MOVL AX,ret+%d(FP)
+RET
+`, smallResult+4, smallResult, mixedResult+4, mixedResult, smallResult+4, smallResult), `func AHLoad(a,b uint32) uint32
+func AHStoreAndLoad(flags uint16) uint32
+func AHPreserveOF(flags uint16,a,b uint32) uint32
+func AHByteOnly(flags uint8) uint32
+`
+}
+
+func TestX86AHFlagsCompleteSourceFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86AHFlagsCompleteSource(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete AH/FLAGS source lost its numerical proof", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, []string{"AHLoad", "AHStoreAndLoad", "AHPreserveOF", "AHByteOnly"})
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86AHFlagsVoidInputsCannotBorrowImplementationState(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, valid, unknown string }{
+			{"all-five-flags", "MOVL $0,AX\nCMPL AX,AX\nLAHF", "LAHF"},
+			{"carry-is-not-all-flags", "MOVL $0,AX\nCMPL AX,AX\nCLC\nLAHF", "CLC\nLAHF"},
+			{"undefined-AF", "MOVL $0,AX\nCMPL AX,AX\nLAHF", "MOVL $0,AX\nTESTL AX,AX\nLAHF"},
+			{"only-AH-is-read", "MOVB $7,AH\nSAHF\nLAHF", "MOVB $7,AL\nSAHF\nLAHF"},
+			{"unknown-AH", "MOVB $7,AH\nSAHF", "SAHF"},
+			{"OF-is-not-created", "MOVL $0,AX\nCMPL AX,AX\nSAHF\nSETOS AL", "MOVB $7,AH\nSAHF\nSETOS AL"},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				valid := "TEXT ·Value(SB),4,$0-0\n" + row.valid + "\nRET\n"
+				unknown := "TEXT ·Value(SB),4,$0-0\n" + row.unknown + "\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, valid+strings.ReplaceAll(unknown, "Value", "Unknown"), "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, valid, "func Value()", target.arch, target.triple, api); err != nil || ir == "" {
+						t.Fatal("independent initialized AH/FLAGS control rejected", api, err)
+					}
+					if ir, err := x86ScalarFPBitViewAPI(t, unknown, "func Value()", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Error("AH/FLAGS input borrowed implementation state", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86AHFlagsRejectsNonGoFormats(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"LAHF", "SAHF"} {
+			for _, tail := range []string{" AX", " $1", ".Z", ".W"} {
+				t.Run(arch+"/"+op+tail, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-0\n" + op + tail + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch], api)
+						if err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal(fmt.Sprintf("malformed %s%s became a context query: %v", op, tail, err))
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86AHFlagsNumericalBytesAreNotCanonicalBoolWitnesses(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("canonical AH/FLAGS objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			before := [16]uint8{2, 0, 0, 1}
+			load := x86ScalarLaneInstruction(t, "LAHF")
+			store := x86ScalarLaneInstruction(t, "SAHF")
+			want := before
+			want[0] = 0
+			if after := x86RegisterCanonicalBytesAfter(load, before, target.arch); after != want {
+				t.Fatal("LAHF retained canonical AH or revoked an unrelated GP byte", after)
+			}
+			if after := x86RegisterCanonicalBytesAfter(store, before, target.arch); after != before {
+				t.Fatal("SAHF changed a canonical GP byte without a GP output", after)
+			}
+			prefix := "TEXT ·Value(SB),4,$0-1\nMOVL $0,BX\nCMPL BX,BX\nSETEQ AH\n"
+			finish := "MOVB AH,ret+0(FP)\nRET\n"
+			for _, body := range []string{"", "SAHF\n"} {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, prefix+body+finish)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, prefix+body+finish, "func Value() bool", target.arch, target.triple, api)
+					// Both modes now have the independent ordinary ABI0 bool
+					// role. SETcc supplies the actual 0/1 byte; SAHF preserves it.
+					if err != nil || ir == "" {
+						t.Fatal("SETcc's known canonical AH was lost without a GP overwrite", api, body, err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			}
+			for _, body := range []string{
+				prefix + "LAHF\n" + finish,
+				strings.Replace(prefix, "SETEQ AH\n", "", 1) + finish,
+				prefix + "MOVB $2,AH\n" + finish,
+			} {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, body)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, body, "func Value() bool", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("unknown or noncanonical AH retained a canonical bool witness", api, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_ah_flags_runtime_test.go b/x86_ah_flags_runtime_test.go
new file mode 100644
index 000000000..bd19f4990
--- /dev/null
+++ b/x86_ah_flags_runtime_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestX86AHFlagsPortableNumericalValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	source, declarations := x86AHFlagsCompleteSource("amd64")
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t AHLoad(uint32_t,uint32_t);
+extern uint32_t AHStoreAndLoad(uint16_t);
+extern uint32_t AHPreserveOF(uint16_t,uint32_t,uint32_t);
+extern uint32_t AHByteOnly(uint8_t);
+static uint32_t low_flags(uint32_t a,uint32_t b) {
+    uint32_t r=a-b,p=(uint8_t)r;
+    p^=p>>4;p^=p>>2;p^=p>>1;
+    return (a<b)|(((p&1)==0)<<2)|(((a^b^r)>>4&1)<<4)|((r==0)<<6)|((r>>31)<<7)|2;
+}
+int main(void) {
+    const uint32_t edges[]={0,1,15,16,127,128,255,256,65535,65536,0x7fffffff,0x80000000,0xffffffff};
+    for(unsigned seed=0;seed<256;seed++) {
+        uint16_t flags=(uint16_t)(seed<<8)|(seed^255);
+        uint32_t packed=(seed&0xd5)|2;
+        if(AHStoreAndLoad(flags)!=packed||AHByteOnly(seed)!=packed)return 1;
+        for(unsigned i=0;i<sizeof(edges)/sizeof(edges[0]);i++)for(unsigned j=0;j<sizeof(edges)/sizeof(edges[0]);j++) {
+            uint32_t a=edges[i],b=edges[j],sum=a+b;
+            uint32_t overflow=((~(a^b)&(a^sum))>>31)&1;
+            uint32_t got=AHLoad(a,b),combined=AHPreserveOF(flags,a,b);
+            if(got!=low_flags(a,b)||combined!=(packed|(overflow<<8))) {
+                fprintf(stderr,"AH/FLAGS seed=%u a=%x b=%x load=%x expected=%x combined=%x\n",
+                    seed,a,b,got,low_flags(a,b),combined);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal("complete portable AH/FLAGS program rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "ah-flags-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_approximate_math_typed_closure_test.go b/x86_approximate_math_typed_closure_test.go
new file mode 100644
index 000000000..223a7575f
--- /dev/null
+++ b/x86_approximate_math_typed_closure_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86ApproximateMathTestInstruction(member approximateMathTestSpec, source, mode, control string) string {
+	bank, operands := "Z", source+","
+	if member.scalar {
+		bank, operands = "X", operands+"X17,"
+	}
+	op := member.op + control
+	if mode != "plain" {
+		operands += "K1,"
+		if mode == "zero" {
+			op += ".Z"
+		}
+	}
+	return op + " " + operands + bank + "18"
+}
+
+func TestX86ApproximateMathCompleteTypedOfficialRows(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	members := make(map[string]approximateMathTestSpec)
+	for _, member := range go127ApproximateMathSpecs() {
+		members[member.op] = member
+	}
+	rows, formats, seen := 0, 0, make(map[string]int)
+	for _, row := range avx {
+		member, selected := members[row.Opcode]
+		if !selected {
+			continue
+		}
+		rows++
+		seen[member.op]++
+		modes := []string{"plain"}
+		if row.RowIndex == 1 {
+			modes = []string{"merge", "zero"}
+		}
+		bank := "Z"
+		if member.scalar {
+			bank = "X"
+		}
+		for _, mode := range modes {
+			for _, input := range []struct{ source, control string }{
+				{bank + "16", ""}, {bank + "16", ".SAE"}, {"(AX)", ""}, {"(AX)", ".BCST"},
+			} {
+				if member.scalar && input.control == ".BCST" {
+					continue
+				}
+				formats++
+				instruction := x86ApproximateMathTestInstruction(member, input.source, mode, input.control)
+				t.Run(instruction, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, instruction)
+					f, known, err := x86FloatingHelperProperties(ins, "amd64")
+					width, tuple := 64, 64
+					if member.scalar {
+						width = 16
+					}
+					if member.scalar || input.control == ".BCST" {
+						tuple = member.laneBits / 8
+					}
+					if !known || err != nil || f.byteWidth != width || f.spec.bits != member.laneBits ||
+						f.memory >= 0 && f.memoryBytes != tuple || f.properties.sae != (input.control == ".SAE") {
+						t.Fatal("complete original approximation row has no shared typed carrier/tuple/control", f, known, err)
+					}
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+					if !known || err != nil || !effect.requiresResultProof || effect.vector.upperWrite != x86TypedVectorUpperZero ||
+						effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 || len(effect.operands) != len(ins.Args) {
+						t.Fatal("approximation lacks complete typed inputs/outputs or preserved FLAGS", effect, known, err)
+					}
+					for _, operand := range effect.operands {
+						if operand.index == f.destination && operand.read != (mode == "merge") {
+							t.Fatal("zeroing/plain form borrowed an old destination", operand)
+						}
+						if member.scalar && operand.index == f.second &&
+							operand.requiredBytes != 0xffff&^x86CallerVectorByteMask(int64(member.laneBits/8)) {
+							t.Fatal("scalar upper-copy acquired an unused low arithmetic input", operand)
+						}
+					}
+				})
+			}
+		}
+	}
+	if rows != 20 || formats != 108 || len(seen) != 10 {
+		t.Fatal("complete original approximation namespace/row/control closure changed", rows, formats, seen)
+	}
+	for name, count := range seen {
+		if count != 2 {
+			t.Fatal("unmasked/masked source row missing", name, count)
+		}
+	}
+}
+
+func TestX86ApproximateMathSparseNumericalInputsAndPreservedState(t *testing.T) {
+	for _, member := range go127ApproximateMathSpecs() {
+		bank, width, active := "Z", 64, 64
+		if member.scalar {
+			bank, width, active = "X", 16, member.laneBits/8
+		}
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			ins := x86ScalarLaneInstruction(t, x86ApproximateMathTestInstruction(member, bank+"16", mode, ""))
+			for _, mutation := range []string{"complete", "source", "mask", "old-destination", "upper-low", "upper-high"} {
+				if mutation == "mask" && mode == "plain" || strings.HasPrefix(mutation, "upper-") && !member.scalar {
+					continue
+				}
+				t.Run(member.op+"/"+mode+"/"+mutation, func(t *testing.T) {
+					before := x86FloatingHelperInitializedState()
+					switch mutation {
+					case "source":
+						before.writeVector(16, 64, ^uint64(1), false)
+					case "mask":
+						before.masks[1] = false
+					case "old-destination":
+						before.writeVector(18, 64, 0, false)
+					case "upper-low":
+						before.writeVector(17, 64, ^uint64(1), false)
+					case "upper-high":
+						before.writeVector(17, 64, ^(uint64(1) << uint(active)), false)
+					}
+					state := before.clone()
+					accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, "amd64", true)
+					fail := mutation == "source" || mutation == "mask" || mutation == "old-destination" && mode == "merge"
+					if fail {
+						if accepted || !known || !reflect.DeepEqual(state, before) {
+							t.Fatal("missing active source/mask/merge changed or authorized the state", accepted, known)
+						}
+						return
+					}
+					want := before.clone()
+					defined := ^uint64(0)
+					if mutation == "upper-high" {
+						defined &^= uint64(1) << uint(active)
+					}
+					want.writeVector(18, width, defined, false)
+					if !accepted || !known || !reflect.DeepEqual(state, want) {
+						t.Fatal("sparse copied bytes, zero upper aliases or unrelated FLAGS/DF/storage changed", accepted, known)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ApproximateMathInitializedNativeOperandsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	for index, member := range go127ApproximateMathSpecs() {
+		instruction := x86ApproximateMathTestInstruction(member, "(AX)", "zero", "")
+		if !member.scalar {
+			instruction = x86ApproximateMathTestInstruction(member, "(AX)", "zero", ".BCST")
+		}
+		body, declaration := x86PackedAbsSignInitializedInstruction(index, instruction, "amd64", [3]int{16, 17, 18})
+		// Zeroing has no old destination input; the whole output remains observable.
+		body = strings.Replace(body, "VMOVDQU64 (CX),Z18\n", "", 1)
+		// The memory instruction supplies its own active source. Do not
+		// pre-read the same address through an unused register initializer.
+		body = strings.Replace(body, "VMOVDQU64 (AX),Z16\n", "", 1)
+		source.WriteString(body)
+		declarations.WriteString(declaration + "\n")
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+		if err != nil || ir == "" {
+			t.Fatal("fully initialized approximation source did not close its typed proof", api, err)
+		}
+		for _, member := range go127ApproximateMathSpecs() {
+			found := false
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, "asm sideeffect") && strings.Contains(line, strings.ToLower(member.op)+" ") {
+					found = strings.Contains(line, "*m") && strings.Contains(line, "~{memory}") && strings.Contains(line, "~{fpsr}") &&
+						strings.Contains(line, fmt.Sprintf("elementtype([%d x i8])", member.laneBits/8))
+				}
+			}
+			if !found {
+				t.Fatal("native instruction lost its actual scalar/broadcast memory operand or FX-state clobber", member.op)
+			}
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, level)
+		}
+	}
+}
+
+func TestX86ApproximateMathVoidCannotInventActiveInputs(t *testing.T) {
+	for _, member := range go127ApproximateMathSpecs() {
+		bank := "Z"
+		if member.scalar {
+			bank = "X"
+		}
+		instruction := x86ApproximateMathTestInstruction(member, bank+"16", "zero", "")
+		source := "TEXT Missing(SB),4,$0-0\n" + instruction + "\nRET\n"
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewAPI(t, source, "func Missing()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("Void supplied unavailable source/upper/mask numerical inputs", member.op, api, err)
+			}
+		}
+	}
+}
diff --git a/x86_baseline_gp_feature_projection_test.go b/x86_baseline_gp_feature_projection_test.go
new file mode 100644
index 000000000..d3f378c6c
--- /dev/null
+++ b/x86_baseline_gp_feature_projection_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"reflect"
+	"sort"
+	"testing"
+)
+
+func x86CheckBaselineGPFeatureProjection(t *testing.T, arch string, instructions []Instr, want string) {
+	t.Helper()
+	before := cloneX86ReplayInstrs(instructions)
+	if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: instructions}); got != want {
+		t.Fatalf("feature projection = %q, want %q", got, want)
+	}
+	if !reflect.DeepEqual(instructions, before) {
+		t.Fatal("feature inference changed source operands or private metadata")
+	}
+}
+
+func TestX86BaselineGPFeatureFamiliesRetainEmptyProjection(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		// These independent inventories already own complete Go grammar tests.
+		// This projection does not establish initialized values or source roles.
+		var rows []string
+		for _, form := range x86LockScalarOracleForms(arch) {
+			rows = append(rows, form.text)
+		}
+		for alias := range x86ConditionalBranchAliasOracle() {
+			rows = append(rows, alias+" feature_done")
+		}
+		rows = append(rows, "LEAW 8(AX)(BX*2),CX", "LEAL 8(AX)(BX*2),CX",
+			"JMP feature_done", "CALL helper(SB)", "RET")
+		if arch == "amd64" {
+			rows = append(rows, "LEAQ 8(AX)(BX*2),CX")
+		}
+		sort.Strings(rows)
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row)
+				wantFast := instruction.Op != OpCALL // The external SB target keeps its original route.
+				if got := x86BaselineGPFeatureInstruction(instruction.Op, &instruction, arch); got != wantFast {
+					t.Fatal("existing baseline family lost its conservative feature route", got, wantFast)
+				}
+				x86CheckBaselineGPFeatureProjection(t, arch, []Instr{instruction}, "")
+				x86CheckBaselineGPFeatureProjection(t, arch, []Instr{
+					instruction, x86ScalarLaneInstruction(t, "PSHUFB X0,X1"),
+				}, "+ssse3")
+			})
+		}
+	}
+}
+
+func TestX86BaselineGPFeatureProjectionKeepsISAAndVectorRequirements(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ source, want string }{
+			{"MOVBEL (AX),BX", "+movbe"},
+			// POPCNT remains with its existing portable/native family owner;
+			// an empty feature string does not make it a baseline GP candidate.
+			{"POPCNTL AX,BX", ""},
+			{"LZCNTL AX,BX", "+lzcnt"},
+			{"ANDNL AX,BX,CX", "+bmi"},
+			{"BLSIL AX,BX", "+bmi"},
+			{"BEXTRL AX,BX,CX", "+bmi"},
+			{"MULXL AX,BX,CX", "+bmi2"},
+			{"SHLXL AX,BX,CX", "+bmi2"},
+			{"ADCXL AX,BX", "+adx"},
+			{"ADOXL AX,BX", "+adx"},
+			{"XBEGIN 1(PC)", "+rtm"},
+			{"PSHUFB X0,X1", "+ssse3"},
+			{"VCVTSD2SS X0,X1,X2", "+avx"},
+			{"MOVQ X0,X1", ""},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row.source)
+				if x86BaselineGPFeatureInstruction(instruction.Op, &instruction, arch) {
+					t.Fatal("ISA-dependent, vector or MOV input entered the baseline route")
+				}
+				instructions := []Instr{
+					x86ScalarLaneInstruction(t, "ADDL AX,BX"),
+					x86ScalarLaneInstruction(t, "LEAL 8(AX)(BX*2),CX"),
+					x86ScalarLaneInstruction(t, "JEQ feature_done"),
+					instruction,
+					x86ScalarLaneInstruction(t, "RET"),
+				}
+				x86CheckBaselineGPFeatureProjection(t, arch, instructions, row.want)
+			})
+		}
+	}
+}
+
+func TestX86BaselineGPFeatureProjectionRetainsSourceMetadata(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{"ADDL AX,BX", "LEAL 8(AX)(BX*2),CX", "JEQ feature_done"} {
+			for _, change := range []struct {
+				name     string
+				apply    func(*Instr)
+				physical bool
+			}{
+				{"encoded", func(i *Instr) { i.x86Encoded = true }, true},
+				{"raw-origin", func(i *Instr) {
+					i.x86SourceRaw = &x86SourceRawInstruction{op: i.Op, args: append([]Operand(nil), i.Args...)}
+				}, true},
+				{"raw-return", func(i *Instr) { i.x86RawNearReturn = &x86RawNearReturnForm{} }, true},
+				{"address-size", func(i *Instr) { i.x86AddressBits = 16 }, true},
+				{"unbound-address", func(i *Instr) { i.x86UnboundAddressOverride = true }, true},
+				{"segment", func(i *Instr) { i.x86SegmentPrefix = 0x64 }, true},
+				{"numerical-read", func(i *Instr) { i.x86NumericalRead = &x86NumericalReadCertificate{} }, false},
+				{"SDK-literal", func(i *Instr) { i.x86SDKLiteral = &x86SDKLiteralCertificate{} }, false},
+				{"source-stack", func(i *Instr) { i.x86SourceStackFP = map[int]int64{0: 0} }, false},
+				{"caller-memory", func(i *Instr) { i.x86CallerMemory = map[int]x86CallerMemoryAccess{0: {}} }, false},
+				{"private-memory", func(i *Instr) { i.x86FixedLocalMemory = map[int]x86FixedLocalAccess{0: {}} }, false},
+				{"native-memory", func(i *Instr) { i.x86FixedLocalMemory = map[int]x86FixedLocalAccess{0: {nativeInput: true}} }, false},
+			} {
+				t.Run(arch+"/"+row+"/"+change.name, func(t *testing.T) {
+					instruction := x86ScalarLaneInstruction(t, row)
+					change.apply(&instruction)
+					if got := x86BaselineGPFeatureInstruction(instruction.Op, &instruction, arch); got == change.physical {
+						t.Fatal("feature routing confused physical encoding with independent source metadata", got)
+					}
+					// Deliberately empty certificates cannot supply source facts.
+					// Inference must leave them intact for their actual consumers.
+					x86CheckBaselineGPFeatureProjection(t, arch, []Instr{
+						instruction, x86ScalarLaneInstruction(t, "PSHUFB X0,X1"),
+					}, "+ssse3")
+				})
+			}
+		}
+	}
+}
+
+func TestX86BaselineGPFeatureProjectionDoesNotAcceptMalformedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			lea    bool
+		}{
+			{"ADDL AX", false},
+			{"ADDL.Z AX,BX", false},
+			{"ADDL X0,BX", false},
+			{"ADDL (AX),(BX)", false},
+			{"LEAL AX,BX", true},
+			{"LEAL (AX),X0", true},
+			{"LEAL.Z (AX),BX", true},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row.source)
+				if x86BaselineGPFeatureInstruction(instruction.Op, &instruction, arch) {
+					t.Fatal("malformed syntax entered the baseline route")
+				}
+				grammarError := func() error {
+					if row.lea {
+						_, err := x86LEAOperandWidth(instruction, arch)
+						return err
+					}
+					_, known, err := x86LockScalarRMWProperties(instruction.Op, instruction, arch)
+					if !known {
+						t.Fatal("malformed control lost its family registration")
+					}
+					return err
+				}
+				before := grammarError()
+				if before == nil {
+					t.Fatal("malformed control is accepted by its existing family grammar")
+				}
+				x86CheckBaselineGPFeatureProjection(t, arch, []Instr{
+					instruction, x86ScalarLaneInstruction(t, "PSHUFB X0,X1"),
+				}, "+ssse3")
+				if after := grammarError(); after == nil || before.Error() != after.Error() {
+					t.Fatal("feature inference changed the original grammar rejection", before, after)
+				}
+			})
+		}
+		for _, source := range []string{"RET AX", "JMP X0", "JEQ $2,feature_done", "JEQ 1(PC)", "JCXZQ feature_done"} {
+			t.Run(arch+"/original-route/"+source, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, source)
+				if source == "JEQ 1(PC)" {
+					// The text parser already rejects this address. Also retain
+					// the boundary for callers constructing an Instr directly.
+					instruction.Args[0].Mem.Index, instruction.Args[0].Mem.Scale = AX, 1
+				}
+				if x86BaselineGPFeatureInstruction(instruction.Op, &instruction, arch) {
+					t.Fatal("invalid or separately owned branch role entered the baseline route")
+				}
+				x86CheckBaselineGPFeatureProjection(t, arch, []Instr{instruction}, "")
+			})
+		}
+	}
+}
diff --git a/x86_bextr_result_test.go b/x86_bextr_result_test.go
new file mode 100644
index 000000000..14a9d5db5
--- /dev/null
+++ b/x86_bextr_result_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86BEXTRTypedByteEffectExactInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				width := int64(4)
+				if arch == "amd64" && op == "BEXTRQ" {
+					width = 8
+				}
+				ins := x86ScalarLaneInstruction(t, op+" AX,BX,CX")
+				effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+				if err != nil || !known || len(effect.operands) != 3 {
+					t.Fatal("complete BEXTR family lacks its typed input/result effect", known, err)
+				}
+				for ordinal, operand := range effect.operands {
+					bytes := width
+					if ordinal == 0 {
+						bytes = 2 // Only START and LEN, not the rest of the GP.
+					}
+					if operand.index != ordinal || !reflect.DeepEqual(operand.operand, ins.Args[ordinal]) ||
+						operand.width != bytes || operand.read != (ordinal < 2) || operand.write != (ordinal == 2) {
+						t.Fatal("BEXTR changed an input, output or physical mode width", ordinal, operand)
+					}
+				}
+				if effect.flagsRead != 0 || effect.flagsDefined != x86ByteFlagCF|x86ByteFlagOF|x86ByteFlagZF ||
+					effect.flagsKilled != x86ByteFlagsAll || effect.dynamicMemory || !effect.requiresResultProof {
+					t.Fatal("BEXTR invented preserved/defined flags or waived its input obligation", effect)
+				}
+			})
+		}
+	}
+}
+
+func TestX86BEXTRCompleteInitializedSourceObjects(t *testing.T) {
+	x86BitFieldInitializedSourceObjects(t, []string{"BEXTRL", "BEXTRQ"}, "uint16", "MOVW")
+}
+
+func x86BitFieldInitializedSourceObjects(t *testing.T, operations []string, controlType, controlMove string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete BEXTR objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, op := range operations {
+			for _, native := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/native%t", target.triple, op, native), func(t *testing.T) {
+					width, typ, move := 4, "uint32", "MOVL"
+					if target.arch == "amd64" && strings.HasSuffix(op, "Q") {
+						width, typ, move = 8, "uint64", "MOVQ"
+					}
+					offset, result, input, load := width, 2*width, "BX", move
+					parameter := typ
+					if native {
+						word := int(goWordSize(target.arch))
+						offset, result, input = word, 2*word, "(BX)"
+						parameter = "*" + typ
+						if word == 8 {
+							load = "MOVQ"
+						} else {
+							load = "MOVL"
+						}
+					}
+					declaration := fmt.Sprintf("func Value(control %s, source %s) %s", controlType, parameter, typ)
+					body := fmt.Sprintf("%s control+0(FP),AX\n%s source+%d(FP),BX\n%s AX,%s,CX\n%s CX,ret0+%d(FP)\nRET\n",
+						controlMove, load, offset, op, input, move, result)
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized complete bit-field source remains unclosed", op, err)
+							}
+							for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+								if native && !strings.Contains(text, fmt.Sprintf("load volatile i%d, ptr", width*8)) {
+									t.Fatal("bit-field operation lost its exact native read, including mode32 Q", op, width)
+								}
+								for _, level := range []string{"-O0", "-O2"} {
+									x86PackedStringCompileObject(t, llc, target.triple, text, level)
+								}
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BEXTRVoidCannotInventInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			for name, prefix := range map[string]string{
+				"missing START and LEN": "MOVL $7,BX\n",
+				"missing LEN":           "MOVB $4,AL\nMOVL $7,BX\n",
+				"missing source":        "MOVW $0x0804,AX\n",
+			} {
+				t.Run(target.triple+"/"+op+"/"+name, func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\n" + prefix + op + " AX,BX,CX\nRET\n"
+					x86UnboundVoidFormatSource(t, source, "f", target.arch, target.triple)
+				})
+			}
+		}
+	}
+}
+
+func TestX86BEXTRUnusedBoolCannotWaiveInputProof(t *testing.T) {
+	const declaration = "func Value(unused bool)"
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			for _, input := range []string{"BX", "(BX)"} {
+				for _, missing := range []string{"START and LEN", "LEN", "source"} {
+					t.Run(target.triple+"/"+op+"/"+input+"/"+missing, func(t *testing.T) {
+						prefix := "MOVW $0x0804,AX\nMOVL $7,BX\n"
+						switch missing {
+						case "START and LEN":
+							prefix = "MOVL $7,BX\n"
+						case "LEN":
+							prefix = "MOVB $4,AL\nMOVL $7,BX\n"
+						case "source":
+							prefix = "MOVW $0x0804,AX\n"
+						}
+						// The original unused ABI0 bool occupies one byte. It
+						// supplies neither control bytes nor pointer identity.
+						source := "TEXT ·Value(SB),4,$0-1\n" + prefix + op + " AX," + input + ",CX\nRET\n"
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unused bool hid missing BEXTR numerical/address inputs", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_bextr_rules_test.go b/x86_bextr_rules_test.go
new file mode 100644
index 000000000..b0e77c101
--- /dev/null
+++ b/x86_bextr_rules_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BEXTRCompleteIndependentGoRowsAndPhysicalMode(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"var_ybextrl=[]ytab{{zcase:Zvex_v_rm_r,zoffset:2,args:argList{Yrl,Yml,Yrl}},}",
+		"{as:ABEXTRL,ytab:_ybextrl,prefix:Pavx,op:opBytes{avxEscape|vex128|vex0F38|vexW0,0xF7,}},",
+		"{as:ABEXTRQ,ytab:_ybextrl,prefix:Pavx,op:opBytes{avxEscape|vex128|vex0F38|vexW1,0xF7,}},",
+	} {
+		if !strings.Contains(compact, row) {
+			t.Fatal("complete BEXTR Go encoder row/attribute binding changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+op+" AX,BX,CX\nRET\n")
+			want := []byte{0xc4, 0xe2, 0x78, 0xf7, 0xcb, 0xc3}
+			if op == "BEXTRQ" {
+				want[2] = 0xf8
+			}
+			if !bytes.Equal(code, want) {
+				t.Fatalf("%s/%s original Go encoding %x, want %x", arch, op, code, want)
+			}
+			ins := x86ScalarLaneInstruction(t, op+" AX,(BX),CX")
+			width := int64(4)
+			if arch == "amd64" && op == "BEXTRQ" {
+				width = 8
+			}
+			for index := range ins.Args {
+				got, write, valid := x86InstructionMemoryShape(ins, index, arch)
+				if valid != (index == 1) || valid && (got != width || write) {
+					t.Fatal("BEXTR physical source tuple changed", arch, op, index, got, write, valid)
+				}
+			}
+		}
+	}
+}
+
+func TestX86BEXTRCompleteGoRegisterBanks(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		registers := strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+		if arch == "386" {
+			registers = registers[:8]
+		}
+		var source strings.Builder
+		source.WriteString("TEXT f(SB),4,$0-0\n")
+		count := 0
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			for _, control := range registers {
+				for _, input := range registers {
+					for _, output := range registers {
+						row := fmt.Sprintf("%s %s,%s,%s", op, control, input, output)
+						source.WriteString(row + "\n")
+						ins := x86ScalarLaneInstruction(t, row)
+						if _, known, err := x86BEXTRProperties(ins.Op, ins, arch); !known || err != nil {
+							t.Fatal("complete Go GP bank rejected", arch, row, err)
+						}
+						count++
+					}
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		if count != 2*len(registers)*len(registers)*len(registers) {
+			t.Fatal("incomplete register-bank union", arch, count)
+		}
+	}
+}
+
+func TestX86BEXTRResultByteHolesAliasesAndFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			width := int64(4)
+			if arch == "amd64" && op == "BEXTRQ" {
+				width = 8
+			}
+			for _, output := range []string{"AX", "BX", "CX", "SP", "BP"} {
+				ins := x86ScalarLaneInstruction(t, op+" AX,BX,"+output)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					for missing := -1; missing < int(width)+2; missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.gp[0], state.gp[3] = 3, uint8((uint16(1)<<uint(width))-1)
+						if missing < 2 && missing >= 0 {
+							state.gp[0] &^= 1 << uint(missing)
+						} else if missing >= 2 {
+							state.gp[3] &^= 1 << uint(missing-2)
+						}
+						before := state.clone()
+						accept := missing == -1 && output != "SP" && (arch == "386" || output != "BP")
+						if got := consumer.step(ins, &state, nil, 0, arch); got != accept {
+							t.Fatal("BEXTR input/destination boundary changed", arch, op, output, consumer.name, missing, got)
+						}
+						expected := before.clone()
+						if accept {
+							index, _, _ := x86ResultGP(Reg(output), width, arch)
+							expected.gp[index] = 0xff
+							expected.flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF
+						}
+						if !reflect.DeepEqual(state, expected) {
+							t.Fatal("BEXTR changed unrelated state or partially applied a failed effect", arch, op, output, missing)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BEXTRNativeReadAndOpaqueInputsStaySeparate(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+			for _, role := range []string{"paired", "standalone", "missing control byte", "numerical base", "unknown index", "raw", "encoded", "address override", "opaque control"} {
+				t.Run(arch+"/"+op+"/"+role, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+" AX,(BX),CX")
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.pointerGP[3] = 3, true
+					native := true
+					switch role {
+					case "standalone":
+						native = false
+					case "missing control byte":
+						state.gp[0] = 1
+					case "numerical base":
+						state.pointerGP[3], state.gp[3] = false, 0xff
+					case "unknown index":
+						ins.Args[1].Mem.Index, ins.Args[1].Mem.Scale = SI, 4
+					case "raw":
+						ins.x86SourceRaw = &x86SourceRawInstruction{}
+					case "encoded":
+						ins.x86Encoded = true
+					case "address override":
+						ins.x86AddressBits = 32
+					case "opaque control":
+						state.pointerGP[0] = true
+					}
+					before := state.clone()
+					accepted, known := x86ResultScalarBitFieldStep(ins, &state, nil, 0, arch, native)
+					want := role == "paired" || role == "numerical base"
+					if !known || accepted != want || !accepted && !reflect.DeepEqual(state, before) {
+						t.Fatal("BEXTR numerical continuation borrowed an unrelated source role", role, known, accepted)
+					}
+				})
+			}
+			for _, ordinal := range []int{0, 1} {
+				ins := x86ScalarLaneInstruction(t, op+" AX,BX,CX")
+				state := x86ResultState{gp: [16]uint8{0: 0xff, 3: 0xff}}
+				register := []int{0, 3}[ordinal]
+				state.pointerGP[register] = true
+				before := state.clone()
+				if accepted, _ := x86ResultScalarBitFieldStep(ins, &state, nil, 0, arch, true); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("opaque bits became a BEXTR numerical input", arch, op, ordinal)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_bextr_runtime_test.go b/x86_bextr_runtime_test.go
new file mode 100644
index 000000000..a5a9738fa
--- /dev/null
+++ b/x86_bextr_runtime_test.go
@@ -0,0 +1,155 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BEXTROriginalProgramPortableAndObjects(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	const declaration = "func bextrsemantics(out *[56]byte)"
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-macosx", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+x86BEXTROriginalRuntimeSource)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, x86BEXTROriginalRuntimeSource, declaration, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("unchanged original CI source", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, execution.llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("portable/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86BEXTROriginalRuntimeSource, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "original-bextr", text, x86BEXTROriginalRuntimeDriver, level)
+				}
+			}
+		})
+	}
+	t.Log("original Go objects and three-target LLVM objects; actual-host portable values/FLAGS, not native x86 execution")
+}
+
+func TestX86BEXTRPortableCompleteControlsAliasesAndFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows strings.Builder
+	for _, op := range []string{"BEXTRL", "BEXTRQ"} {
+		bits := 32
+		if op == "BEXTRQ" {
+			bits = 64
+		}
+		for _, memory := range []bool{false, true} {
+			for _, destination := range []string{"AX", "BX", "CX"} {
+				name := fmt.Sprintf("Extract%d%t%s", bits, memory, destination)
+				typ, input, cType := "uint64", "BX", "uint64_t"
+				if memory {
+					typ, input, cType = "*uint64", "(BX)", "const uint64_t*"
+				}
+				fmt.Fprintf(&declarations, "func %s(control uint16, source %s, out *[16]byte)\n", name, typ)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVW control+0(FP),AX\nMOVQ source+8(FP),BX\nMOVQ out+16(FP),DI\n", name)
+				source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n")
+				fmt.Fprintf(&source, "%s AX,%s,%s\nMOVQ %s,0(DI)\nSETCS 8(DI)\nSETOS 9(DI)\nSETEQ 10(DI)\nRET\n", op, input, destination, destination)
+				fmt.Fprintf(&prototypes, "extern void %s(uint16_t,%s,uint8_t*);\n", name, cType)
+				// A uniform C wrapper keeps pointer/scalar call types distinct.
+				argument := "value"
+				if memory {
+					argument = "&value"
+				}
+				fmt.Fprintf(&prototypes, "static void call%s(uint16_t control,uint64_t value,uint8_t *out) { %s(control,%s,out); }\n", name, name, argument)
+				fmt.Fprintf(&rows, "{call%s,%d},\n", name, bits)
+			}
+		}
+	}
+	// A dead result and LEN=0 must still perform the entire source read.
+	for _, width := range []struct {
+		op    string
+		bytes int
+	}{{"BEXTRL", 4}, {"BEXTRQ", 8}} {
+		fmt.Fprintf(&source, "TEXT Dead%d(SB),4,$0-8\nMOVQ source+0(FP),BX\nMOVW $0,AX\n%s AX,(BX),CX\nRET\n", width.bytes, width.op)
+		fmt.Fprintf(&declarations, "func Dead%d(source *byte)\n", width.bytes)
+		fmt.Fprintf(&prototypes, "extern void Dead%d(const uint8_t*);\nstatic int fault%d(const uint8_t *p) { Dead%d(p); return 0; }\n", width.bytes, width.bytes, width.bytes)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	valueDriver := strings.ReplaceAll(x86BEXTRPortableValueDriver, "PROTOTYPES", prototypes.String())
+	valueDriver = strings.ReplaceAll(valueDriver, "ROWS", rows.String())
+	faultDriver := x86MemoryFaultDriver(prototypes.String(), "{fault4,4,3},\n{fault8,8,7},\n")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimize := range []bool{false, true} {
+				text := ir
+				if optimize {
+					text = x86MulDivRoundOptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimize, level), func(t *testing.T) {
+						execution.compileAndRunLLVM(t, "bextr-values", text, valueDriver, level)
+						executable := execution.compileLLVM(t, "bextr-faults", text, faultDriver, level)
+						x86CheckMemoryFaultMatrix(t, execution, executable, 2)
+					})
+				}
+			}
+		})
+	}
+	t.Log("all 65,536 START/LEN pairs, source edges, aliases, CF/OF/ZF, canaries and dead read faults; actual-host portable, not native x86")
+}
+
+const x86BEXTRPortableValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+struct kernel {
+    void (*run)(uint16_t,uint64_t,uint8_t*);
+    unsigned bits;
+};
+static const struct kernel kernels[] = { ROWS };
+
+static uint64_t independent_extract(uint64_t value,unsigned bits,unsigned control) {
+    const unsigned start=control&255, length=(control>>8)&255;
+    uint64_t result=0;
+    for (unsigned bit=0;bit<length && start+bit<bits;++bit) {
+        result|=((value>>(start+bit))&1)<<bit;
+    }
+    return result;
+}
+
+int main(void) {
+    static const uint64_t samples[] = {
+        0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0x80000000),UINT64_C(0x0123456789abcdef)
+    };
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        for (unsigned sample=0;sample<sizeof(samples)/sizeof(samples[0]);++sample) {
+            for (unsigned control=0;control<65536;++control) {
+                uint8_t out[32],expected[32];
+                memset(out,0xa5,sizeof(out));
+                memcpy(expected,out,sizeof(out));
+                const uint64_t value=independent_extract(samples[sample],kernels[k].bits,control);
+                memcpy(expected+8,&value,8);
+                expected[16]=0; expected[17]=0; expected[18]=value==0;
+                kernels[k].run((uint16_t)control,samples[sample],out+8);
+                if (memcmp(out,expected,sizeof(out))) {
+                    fprintf(stderr,"BEXTR kernel=%u sample=%u control=%x\n",k,sample,control);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_bittest_fixture_contract_test.go b/x86_bittest_fixture_contract_test.go
new file mode 100644
index 000000000..cf9c1b616
--- /dev/null
+++ b/x86_bittest_fixture_contract_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// The legacy composite fixtures enumerate syntax; they supply no incoming
+// values or external storage. Their original Go object and public Context are
+// distinct from private formatter objects. Initialized three-API/five-target
+// counterparts belong to TestX86BitTestCompleteFormsFiveTargetsThreeAPIs.
+func x86BitTestCompositeFormatObjects(t *testing.T, source, name, arch, triple string) {
+	t.Helper()
+	goAssemblerOracleOutput(t, arch, "#include \"textflag.h\"\n"+source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("original composite bit-test source changed", err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func "+name+"()", arch, triple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("unbound original bit-test source acquired inputs/storage", api, err)
+		}
+	}
+	formats := *file
+	formats.Funcs = append([]Func(nil), file.Funcs...)
+	formats.Funcs[0].Instrs = nil
+	physicalWrites := 0
+	for _, instruction := range file.Funcs[0].Instrs {
+		if form, known, err := x86BitTestProperties(instruction.Op, instruction, arch); known {
+			if err != nil {
+				t.Fatal("original Go bit-test grammar changed", err)
+			}
+			if arch == "386" && form.stem != "BT" && form.destination.Kind == OpReg && form.destination.Reg == SP {
+				// The independent complete-form owner checks the emitter's
+				// explicit physical ESP-write refusal. Keep the original Go
+				// case above, without claiming an object for that entry role.
+				physicalWrites++
+				continue
+			}
+		}
+		formats.Funcs[0].Instrs = append(formats.Funcs[0].Instrs, instruction)
+	}
+	wantPhysical := 0
+	if arch == "386" {
+		wantPhysical = 6
+	}
+	if physicalWrites != wantPhysical {
+		t.Fatal("original physical ESP boundary changed", physicalWrites, wantPhysical)
+	}
+	signatures := map[string]FuncSig{name: {Name: name, Ret: Void}}
+	ir := x86ScalarFormatObjectUnit(t, &formats, signatures, arch, triple, 0)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		x86PackedStringCompileObject(t, llc, triple, ir, level)
+	}
+}
diff --git a/x86_bittest_fp_shadow_test.go b/x86_bittest_fp_shadow_test.go
new file mode 100644
index 000000000..c2495841a
--- /dev/null
+++ b/x86_bittest_fp_shadow_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These literal names and widths are independent of the production descriptor.
+// Go's two complete ybtl rows are Yi8/Yml and Yrl/Yml; only the former has a
+// fixed logical FP envelope. A register-indexed native bit string is separate.
+type x86BitTestFPShadowCase struct {
+	name  string
+	width int
+}
+
+func x86BitTestFPShadowNames(arch string) []x86BitTestFPShadowCase {
+	rows := []x86BitTestFPShadowCase{
+		{"BTW", 2}, {"BTL", 4}, {"BTCW", 2}, {"BTCL", 4},
+		{"BTRW", 2}, {"BTRL", 4}, {"BTSW", 2}, {"BTSL", 4},
+	}
+	if arch == "amd64" {
+		rows = append(rows, x86BitTestFPShadowCase{"BTQ", 8}, x86BitTestFPShadowCase{"BTCQ", 8},
+			x86BitTestFPShadowCase{"BTRQ", 8}, x86BitTestFPShadowCase{"BTSQ", 8})
+	}
+	return rows
+}
+
+func x86BitTestFPShadowReturn(arch string) string {
+	if arch == "386" {
+		return "MOVL x+0(FP),AX\nMOVL AX,ret+8(FP)\nMOVL x+4(FP),DX\nMOVL DX,ret+12(FP)\nRET\n"
+	}
+	return "MOVQ x+0(FP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+}
+
+func TestX86BitTestLogicalFPParameterShadowThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		count := 0
+		for _, row := range x86BitTestFPShadowNames(target.arch) {
+			for offset := 0; offset+row.width <= 8; offset++ {
+				count++
+				source := fmt.Sprintf("TEXT ·value(SB),4,$0-16\n%s $-1,x+%d(FP)\n%s", row.name, offset, x86BitTestFPShadowReturn(target.arch))
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/offset%d/%s", target.triple, row.name, offset, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func value(x uint64) uint64", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("existing exact BIT logical parameter shadow cannot return its complete value", err)
+						}
+					})
+				}
+			}
+		}
+		want := 52
+		if target.arch == "386" {
+			want = 48
+		}
+		if count != want {
+			t.Fatalf("complete independent bit-test/offset denominator changed: %d want %d", count, want)
+		}
+	}
+}
+
+func TestX86BitTestLogicalFPShadowDoesNotGrantOtherStores(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ name, declaration, body string }{
+			{"ordinary-partial-MOV", "func value(x uint64) uint64", "MOVB $17,x+0(FP)"},
+			{"pointer", "func value(x *uint64) uint64", "BTCW $0,x+0(FP)"},
+			{"bool", "func value(x bool,y byte) uint64", "BTCW $0,x+0(FP)"},
+			{"padding", "func value(x byte,y uint64) uint64", "BTCW $0,x+0(FP)"},
+			{"register-index", "func value(x uint64) uint64", "MOVL $0,CX\nBTCW CX,x+0(FP)"},
+			{"uninitialized-result", "func value(x uint64) uint64", "BTCW $0,ret+8(FP)"},
+			{"unknown-native", "func value(x uint64) uint64", "BTCW $0,(AX)"},
+			{"SP-native", "func value(x uint64) uint64", "BTCW $0,(SP)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					pkg := mustGoPackage(t, "bitshadow", "package bitshadow\n"+row.declaration+"\n")
+					sig, err := DeriveGoFuncABI0Signature("value", pkg.Types.Scope().Lookup("value").(*types.Func), arch, types.SizesFor("gc", arch))
+					if err != nil {
+						t.Fatal(err)
+					}
+					result := sig.Frame.Results[0].Offset
+					stores := fmt.Sprintf("MOVL $1,ret+%d(FP)\nMOVL $0,ret+%d(FP)\n", result, result+4)
+					source := fmt.Sprintf("TEXT ·value(SB),4,$0-%d\n%s\n%sRET\n", result+8, row.body, stores)
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, arch, testTargetTriple("linux", arch), api)
+					if err == nil || ir != "" {
+						t.Fatalf("BIT shadow supplied unrelated input/native permission: %v, IR bytes=%d", err, len(ir))
+					}
+				})
+			}
+		}
+		// A public declaration query has no paired logical-field write consumer.
+		pkg := mustGoPackage(t, "bitdecl", "package bitdecl\nfunc value(x uint64) uint64\n")
+		sig, err := DeriveGoFuncABI0Signature("value", pkg.Types.Scope().Lookup("value").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-16\nBTCW $-1,x+0(FP)\n"+x86BitTestFPShadowReturn(arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("public declaration query borrowed the paired shadow writer", err)
+		}
+	}
+}
+
+func TestX86BitTestFPShadowOriginalCompleteGoObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			count := 0
+			for _, row := range x86BitTestFPShadowNames(target.arch) {
+				for offset := 0; offset+row.width <= 8; offset++ {
+					fmt.Fprintf(&source, "TEXT ·bit%d(SB),4,$0-16\n%s $-1,x+%d(FP)\n%s", count, row.name, offset, x86BitTestFPShadowReturn(target.arch))
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("actual original Go object retains %d complete returning BIT-shadow TEXTs; not native execution", count)
+		})
+	}
+}
+
+func TestX86BitTestLogicalFPShadowExactByteEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		pkg := mustGoPackage(t, "bitbytes", "package bitbytes\nfunc value(x uint64) uint64\n")
+		sig, err := DeriveGoFuncABI0Signature("value", pkg.Types.Scope().Lookup("value").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		context := amd64Ctx{sig: sig, fpResults: sig.Frame.Results, goarch: arch}
+		for _, row := range x86BitTestFPShadowNames(arch) {
+			for offset := 0; offset+row.width <= 8; offset++ {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, row.name, offset), func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, fmt.Sprintf("%s $-1,x+%d(FP)", row.name, offset))
+					owned := make([]bool, 16)
+					state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					for index := range owned {
+						owned[index] = true
+						state.fp[index] = index < 8
+					}
+					state.gp[0], state.pointerGP[1], state.callerAddressGP[1] = 0x35, true, true
+					want := state.clone()
+					want.flags = x86ByteFlagZF | x86ByteFlagCF
+					if accepted, known := context.scalarBitTestFPShadowTransfer(ins, &state, owned, arch); !known || !accepted || !reflect.DeepEqual(state, want) {
+						t.Fatal("BIT shadow changed unrelated bytes/FLAGS/DF or opaque identities", accepted, known)
+					}
+					for missing := offset; missing < offset+row.width; missing++ {
+						bad := state.clone()
+						bad.fp[missing] = false
+						before := bad.clone()
+						if accepted, known := context.scalarBitTestFPShadowTransfer(ins, &bad, owned, arch); !known || accepted || !reflect.DeepEqual(bad, before) {
+							t.Fatal("BIT shadow manufactured an unread input byte or changed state on rejection", missing)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_bittest_portable_runtime_test.go b/x86_bittest_portable_runtime_test.go
new file mode 100644
index 000000000..23e203a17
--- /dev/null
+++ b/x86_bittest_portable_runtime_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute the complete BIT numerical/native-memory LLVM model on the actual
+// host. The original Go opcode execution remains owned by the unchanged Linux
+// counterpart; Go object acceptance and portable execution are distinct claims.
+func TestX86BitTestPortableNumericalAndAliases(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, pairs strings.Builder
+	count := 0
+	for _, op := range x86BitTestOracleNames("amd64") {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+		operation := map[string]int{"BT": 0, "BTC": 1, "BTR": 2, "BTS": 3}[op[:len(op)-1]]
+		for _, memory := range []bool{false, true} {
+			for _, index := range []string{"CX", "$-128", "$-1", "$0", "$15", "$16", "$31", "$32", "$63", "$64", "$127", "DX"} {
+				if memory && index == "DX" {
+					continue
+				}
+				name := fmt.Sprintf("portable%d", count)
+				destination, after := "DX", "MOVQ DX,(DI)\n"
+				memoryFlag, mode, immediate := 0, 0, 0
+				if memory {
+					destination, after, memoryFlag = "(DI)", "", 1
+				}
+				if strings.HasPrefix(index, "$") {
+					mode = 1
+					if _, err := fmt.Sscanf(index, "$%d", &immediate); err != nil {
+						t.Fatal(err)
+					}
+				} else if index == "DX" {
+					mode = 2
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ p+0(FP),DI\nMOVQ index+8(FP),CX\nMOVQ value+16(FP),DX\nCMPQ DX,DX\n%s %s,%s\nPUSHFQ\nPOPQ AX\nANDQ $65,AX\n%sMOVQ AX,ret+24(FP)\nRET\n", name, op, index, destination, after)
+				fmt.Fprintf(&declarations, "func %s(p *byte,index int64,value uint64) uint64\n", name)
+				fmt.Fprintf(&prototypes, "extern uint64_t %s(uint8_t*,int64_t,uint64_t);\n", name)
+				fmt.Fprintf(&pairs, "{%s,%d,%d,%d,%d,%d},\n", name, width, operation, memoryFlag, mode, immediate)
+				count++
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	main := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+typedef uint64_t (*program)(uint8_t*,int64_t,uint64_t);
+static const struct { program translated; int width,op,memory,mode,immediate; } pairs[]={
+` + pairs.String() + `};
+int main(void) {
+    const int64_t indexes[]={-255,-129,-128,-65,-64,-33,-32,-17,-16,-1,0,1,15,16,31,32,63,64,65,127,255};
+    const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),
+        UINT64_C(0x55aa0123cdef9876),UINT64_C(0x12345678ffffffff)};
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(unsigned j=0;j<sizeof(indexes)/sizeof(*indexes);++j) {
+            for(unsigned v=0;v<sizeof(values)/sizeof(*values);++v) {
+                uint8_t translated[512],expected[512];
+                for(unsigned b=0;b<sizeof(expected);++b) expected[b]=(uint8_t)(b*71+v*3);
+                memcpy(translated,expected,sizeof(expected));
+                int bits=8*pairs[i].width;
+                uint64_t index=pairs[i].mode==1?(uint64_t)pairs[i].immediate:
+                    pairs[i].mode==2?values[v]:(uint64_t)indexes[j];
+                int64_t offset=0;
+                if(pairs[i].memory && pairs[i].mode!=1) {
+                    int64_t signedIndex=bits==16?(int16_t)index:bits==32?(int32_t)index:(int64_t)index;
+                    offset=(signedIndex>=0?signedIndex/bits:-1-((-1-signedIndex)/bits))*pairs[i].width;
+                }
+                uint64_t old=values[v];
+                if(pairs[i].memory) {
+                    old=0;
+                    memcpy(&old,expected+257+offset,pairs[i].width);
+                }
+                uint64_t selected=UINT64_C(1)<<(index&(bits-1));
+                uint64_t flags=64|!!(old&selected),result=old;
+                if(pairs[i].op==1) result^=selected;
+                if(pairs[i].op==2) result&=~selected;
+                if(pairs[i].op==3) result|=selected;
+                if(pairs[i].memory) {
+                    if(pairs[i].op) memcpy(expected+257+offset,&result,pairs[i].width);
+                } else {
+                    if(pairs[i].op && bits==32) result=(uint32_t)result;
+                    memcpy(expected+257,&result,8);
+                }
+                uint64_t actual=pairs[i].translated(translated+257,indexes[j],values[v]);
+                if(actual!=flags || memcmp(translated,expected,sizeof(expected))) {
+                    fprintf(stderr,"portable bit test=%u index=%lld value=%llx expected flags=%llx LLVM=%llx\n",
+                        i,(long long)indexes[j],(unsigned long long)values[v],(unsigned long long)flags,(unsigned long long)actual);
+                    return 1;
+                }
+            }
+        }
+    }
+    printf("%zu LLVM bit programs x 126 independent whole-memory, alias and CF/ZF checks\n",sizeof(pairs)/sizeof(*pairs));
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						objectIR := ir
+						if optimized {
+							objectIR = x86MulDivRoundOptimize(t, ir)
+						}
+						execution := x86FloatCompareExecution{llc: llc, triple: triple, compiler: []string{clang}}
+						output := execution.compileAndRunLLVM(t, "portable-bit-test", objectIR, main, fmt.Sprintf("-O%d", level))
+						want := fmt.Sprintf("%d LLVM bit programs x 126 independent whole-memory, alias and CF/ZF checks\n", count)
+						if string(output) != want {
+							t.Fatalf("missing portable numerical receipt: %s", output)
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_blend_minpos_complete_source_test.go b/x86_blend_minpos_complete_source_test.go
new file mode 100644
index 000000000..670d276e0
--- /dev/null
+++ b/x86_blend_minpos_complete_source_test.go
@@ -0,0 +1,399 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86BlendMinposCase struct {
+	op, bank, operand string
+	bits, width, dst  int
+	ordinal           int
+	legacy, minimum   bool
+}
+
+// Independent of the production maps: all three legacy/VEX blend pairs,
+// X/Y VEX forms, both source roles and all four original output aliases;
+// the two minimum-position forms additionally use both source aliases.
+func x86BlendMinposCases() []x86BlendMinposCase {
+	var rows []x86BlendMinposCase
+	for _, family := range []struct {
+		legacy, vector string
+		bits           int
+	}{{"BLENDVPS", "VBLENDVPS", 32}, {"BLENDVPD", "VBLENDVPD", 64}, {"PBLENDVB", "VPBLENDVB", 8}} {
+		for _, width := range []int{0, 16, 32} {
+			for _, memory := range []bool{false, true} {
+				for dst := 0; dst < 4; dst++ {
+					row := x86BlendMinposCase{op: family.legacy, bank: "X", operand: "X1", bits: family.bits, width: width, dst: dst, legacy: width == 0}
+					if width != 0 {
+						row.op = family.vector
+					}
+					if width == 32 {
+						row.bank, row.operand = "Y", "Y1"
+					}
+					if memory {
+						row.operand = "(BX)"
+					}
+					rows = append(rows, row)
+				}
+			}
+		}
+	}
+	for _, op := range []string{"PHMINPOSUW", "VPHMINPOSUW"} {
+		for _, operand := range []string{"(BX)", "X1", "X0"} {
+			rows = append(rows, x86BlendMinposCase{op: op, bank: "X", operand: operand, bits: 16, width: 16, legacy: op == "PHMINPOSUW", minimum: true})
+		}
+	}
+	for index := range rows {
+		rows[index].ordinal = index
+	}
+	return rows
+}
+
+func (row x86BlendMinposCase) instruction() string {
+	if row.minimum {
+		return row.op + " " + row.operand + ",X0"
+	}
+	if row.legacy {
+		return fmt.Sprintf("%s X0,%s,X%d", row.op, row.operand, row.dst)
+	}
+	return fmt.Sprintf("%s %s0,%s,%s2,%s%d", row.op, row.bank, row.operand, row.bank, row.bank, row.dst)
+}
+
+func x86BlendMinposOriginalCodes(t *testing.T, rows []x86BlendMinposCase) [][]byte {
+	t.Helper()
+	var body strings.Builder
+	for _, row := range rows {
+		body.WriteString(row.instruction() + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String()+"RET")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("actual Go did not produce every original blend/minimum opcode boundary")
+	}
+	result := make([][]byte, len(rows))
+	for index := range rows {
+		result[index] = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+	}
+	return result
+}
+
+func TestX86BlendMinposCompleteIndependentGoRowsAndAttributes(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []string{
+		"var yblendvpd = []ytab{\n\t{Z_m_r, 1, argList{Yxr0, Yxm, Yxr}},\n}",
+		"var yxm_q4 = []ytab{\n\t{Zm_r, 1, argList{Yxm, Yxr}},\n}",
+	} {
+		if !strings.Contains(string(legacy), table) {
+			t.Fatal("independent complete legacy operand/zcase/offset table changed", table)
+		}
+	}
+	for _, row := range []string{
+		"{ABLENDVPS, yblendvpd, Pq4, opBytes{0x14}},",
+		"{ABLENDVPD, yblendvpd, Pq4, opBytes{0x15}},",
+		"{APBLENDVB, yblendvpd, Pq4, opBytes{0x10}},",
+		"{APHMINPOSUW, yxm_q4, Pq4, opBytes{0x41}},",
+	} {
+		if strings.Count(string(legacy), row) != 1 {
+			t.Fatal("independent full legacy opcode attributes changed", row)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []struct{ name, table, zcase, opcode string }{
+		{"VBLENDVPS", "_yvblendvpd", "Zvex_hr_rm_v_r", "0x4A"},
+		{"VBLENDVPD", "_yvblendvpd", "Zvex_hr_rm_v_r", "0x4B"},
+		{"VPBLENDVB", "_yvblendvpd", "Zvex_hr_rm_v_r", "0x4C"},
+		{"VPHMINPOSUW", "_yvaesimc", "Zvex_rm_v_r", "0x41"},
+	} {
+		count, widths, mapName := 0, []string{"128", "256"}, "vex0F3A"
+		if row.name == "VPHMINPOSUW" {
+			widths, mapName = widths[:1], "vex0F38"
+		}
+		var opbytes []string
+		for _, width := range widths {
+			opbytes = append(opbytes, "avxEscape | vex"+width+" | vex66 | "+mapName+" | vexW0", row.opcode)
+		}
+		for _, rule := range rules {
+			if rule.Opcode != row.name {
+				continue
+			}
+			bank, args := "x", ""
+			if count == 1 {
+				bank = "y"
+			}
+			args = "Y" + bank + "r,Y" + bank + "m,Y" + bank + "r,Y" + bank + "r"
+			if row.name == "VPHMINPOSUW" {
+				args = "Yxm,Yxr"
+			}
+			if count >= len(widths) || rule.RowIndex != count || rule.EncodingOffset != count*2 || rule.ZOffset != 2 ||
+				rule.Ytab != row.table || rule.ZCase != row.zcase || rule.Prefix != "Pavx" ||
+				strings.Join(rule.Classes, ",") != args || strings.Join(rule.OpBytes, ";") != strings.Join(opbytes, ";") {
+				t.Fatal("independent complete VEX row/prefix/offset/attributes changed", row.name, rule)
+			}
+			count++
+		}
+		if count != len(widths) {
+			t.Fatal("complete VEX family row missing", row.name, count)
+		}
+	}
+}
+
+func x86BlendMinposProgram(rows []x86BlendMinposCase, codes [][]byte, arch string, raw bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source, declarations strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("blend%d", row.ordinal)
+		if row.minimum {
+			name = fmt.Sprintf("minpos%d", row.ordinal-72)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s old+0(FP),AX\n%s input+%d(FP),BX\n%s out+%d(FP),DI\n", name, 3*word, move, move, word, move, 2*word)
+			source.WriteString("VMOVUPS (AX),Z0\nVMOVUPS (AX),Z1\n")
+			if row.operand != "(BX)" {
+				fmt.Fprintf(&source, "MOVOU (BX),%s\n", row.operand)
+			}
+			fmt.Fprintf(&declarations, "func %s(old *[64]byte,input *[16]byte,out *[112]byte)\n", name)
+		} else {
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s base+0(FP),AX\n%s source+%d(FP),BX\n%s mask+%d(FP),CX\n%s out+%d(FP),DI\n", name, 4*word, move, move, word, move, 2*word, move, 3*word)
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", register)
+			}
+			transport := "MOVOU"
+			if row.width == 32 {
+				transport = "VMOVUPS"
+			}
+			fmt.Fprintf(&source, "%s (CX),%s0\n%s (BX),%s1\n", transport, row.bank, transport, row.bank)
+			fmt.Fprintf(&declarations, "func %s(base *[64]byte,source,mask *[32]byte,out *[112]byte)\n", name)
+		}
+		if raw {
+			for _, value := range codes[index] {
+				fmt.Fprintf(&source, "BYTE $%#x\n", value)
+			}
+		} else {
+			source.WriteString(row.instruction() + "\n")
+		}
+		fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\nRET\n", row.dst, row.dst, row.dst)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86BlendMinposOriginalDirectoryAndGoBytes(t *testing.T) {
+	rows := x86BlendMinposCases()
+	if len(rows) != 78 {
+		t.Fatal("original blend72/minimum6 directory changed", len(rows))
+	}
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	counts := make(map[string]int)
+	for index, row := range rows {
+		counts[row.op]++
+		code := codes[index]
+		if row.legacy {
+			opcode := map[string]byte{"BLENDVPS": 0x14, "BLENDVPD": 0x15, "PBLENDVB": 0x10, "PHMINPOSUW": 0x41}[row.op]
+			if len(code) < 5 || string(code[:4]) != string([]byte{0x66, 0x0f, 0x38, opcode}) {
+				t.Fatal("independent actual legacy opcode/prefix changed", row.instruction(), code)
+			}
+		} else if len(code) < 4 || code[0] != 0xc4 && code[0] != 0xc5 {
+			t.Fatal("actual VEX instruction lost its generation", row.instruction(), code)
+		}
+	}
+	for _, op := range []string{"BLENDVPS", "BLENDVPD", "PBLENDVB"} {
+		if counts[op] != 8 || counts["V"+op] != 16 {
+			t.Fatal("blend width/source/destination union changed", counts)
+		}
+	}
+	if counts["PHMINPOSUW"] != 3 || counts["VPHMINPOSUW"] != 3 {
+		t.Fatal("minimum-position source aliases changed", counts)
+	}
+	for _, target := range x86RawReturnTargets {
+		// Actual Go accepts the complete original AMD64 sources and the
+		// separately adapted low-bank mode32 raw program. Four-operand
+		// named VEX source has its independent Go rejection below.
+		for _, raw := range []bool{false, true} {
+			selected, selectedCodes := rows, codes
+			if target.arch == "386" && !raw {
+				selected, selectedCodes = nil, nil
+				for index, row := range rows {
+					if row.minimum || row.legacy {
+						selected, selectedCodes = append(selected, row), append(selectedCodes, codes[index])
+					}
+				}
+			}
+			source, _ := x86BlendMinposProgram(selected, selectedCodes, target.arch, raw)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+		}
+	}
+	for _, row := range rows {
+		if !row.legacy && !row.minimum && row.dst == 3 {
+			requireX86GoAssemblerResult(t, "386", "TEXT f(SB),4,$0-0\n"+row.instruction()+"\nRET\n", false)
+		}
+	}
+}
+
+func x86BlendMinposOriginalSourceObjects(t *testing.T, first, end int) {
+	t.Helper()
+	rows := x86BlendMinposCases()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for initialized original blend/minimum objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, raw := range []bool{false, true} {
+			var selected []x86BlendMinposCase
+			var selectedCodes [][]byte
+			for index := first; index < end; index++ {
+				row := rows[index]
+				if target.arch == "386" && !raw && !row.legacy && !row.minimum {
+					continue
+				}
+				selected, selectedCodes = append(selected, row), append(selectedCodes, codes[index])
+			}
+			if len(selected) == 0 {
+				continue // No named four-operand Go.386 row belongs to this batch.
+			}
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				source, declarations := x86BlendMinposProgram(selected, selectedCodes, target.arch, raw)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal("original initialized programs must translate, not be relabeled format-only", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "blend-minpos-original.ll", "blend-minpos-original.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86BlendMinposOriginalInitializedObjectsBatch00(t *testing.T) {
+	x86BlendMinposOriginalSourceObjects(t, 0, 48)
+}
+
+func TestX86BlendMinposOriginalInitializedObjectsBatch01(t *testing.T) {
+	x86BlendMinposOriginalSourceObjects(t, 48, 78)
+}
+
+func TestX86BlendMinposMissingInputsRemainContext(t *testing.T) {
+	rows := x86BlendMinposCases()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	for index, row := range rows {
+		if row.dst != 3 && !row.minimum {
+			continue
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			for _, missing := range []string{"source-pointer", "base-pointer", "mask-pointer"} {
+				if row.minimum && missing == "mask-pointer" {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%s/%s/%s", arch, row.op, row.operand, missing), func(t *testing.T) {
+					source, declaration := x86BlendMinposProgram([]x86BlendMinposCase{row}, [][]byte{codes[index]}, arch, true)
+					move := "MOVQ"
+					if arch == "386" {
+						move = "MOVL"
+					}
+					field, register, offset := "source", "BX", goWordSize(arch)
+					if row.minimum {
+						field = "input"
+					}
+					if missing == "base-pointer" {
+						field, register, offset = "base", "AX", 0
+						if row.minimum {
+							field = "old"
+						}
+					} else if missing == "mask-pointer" {
+						field, register, offset = "mask", "CX", 2*goWordSize(arch)
+					}
+					producer := fmt.Sprintf("%s %s+%d(FP),%s\n", move, field, offset, register)
+					changed := strings.Replace(source, producer, "", 1)
+					if changed == source {
+						t.Fatal("missing-input mutation did not change its actual producer")
+					}
+					x86LEAActualTargetGoObject(t, arch, triple, changed)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw family origin supplied a missing initialized pointer/input", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BlendMinposOriginalRuntimeSourceAndCRemainExact(t *testing.T) {
+	for _, row := range []struct{ file, function, builderHash, oracleHash string }{
+		{"amd64_blend_variable_runtime_test.go", "TestX86VariableBlendMemoryAndViewsRuntime", "5ac3cb2ea8200c04a73be0f43c14a23357abe7e025d7b74fb8830280a2e25324", "a2070b7ebb6419a01be94fb8c0efce84408cfbc6fd2a6f1079e9fbbe6951e28a"},
+		{"amd64_minpos_runtime_test.go", "TestX86MinimumPositionMemoryAndViewsRuntime", "663b299f6c4f9479b33130d6e7ca3a393f199568de3efcae874185f6b2bb1fe0", "5a989e4f9487f00f687d307e4a44607e1f111a709bfdc85d1c9aa1d965398936"},
+	} {
+		data, err := os.ReadFile(row.file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		positions := token.NewFileSet()
+		syntax, err := parser.ParseFile(positions, row.file, data, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		ast.Inspect(syntax, func(node ast.Node) bool {
+			block, ok := node.(*ast.BlockStmt)
+			if !ok {
+				return true
+			}
+			start, end := -1, -1
+			for index, statement := range block.List {
+				text := string(data[positions.Position(statement.Pos()).Offset:positions.Position(statement.End()).Offset])
+				if text == "var source, declarations, checks strings.Builder" {
+					start = positions.Position(statement.Pos()).Offset
+				}
+				if start >= 0 && strings.HasPrefix(text, "file, err := Parse(") && index > 0 {
+					end = positions.Position(block.List[index-1].End()).Offset
+					break
+				}
+			}
+			if start >= 0 && end > start {
+				if found || fmt.Sprintf("%x", sha256.Sum256(data[start:end])) != row.builderHash {
+					t.Fatal("complete original ASM/signature/C-observation builder changed", row.function)
+				}
+				found = true
+			}
+			return true
+		})
+		if !found {
+			t.Fatal("original complete program builder disappeared", row.function)
+		}
+		oracle := x86VariableBlendOracleC
+		if strings.Contains(row.file, "minpos") {
+			oracle = x86MinimumPositionOracleC
+		}
+		if fmt.Sprintf("%x", sha256.Sum256([]byte(oracle))) != row.oracleHash {
+			t.Fatal("original complete independent C values/canaries/guard observations changed", row.function)
+		}
+	}
+}
diff --git a/x86_blend_minpos_effect_replay_test.go b/x86_blend_minpos_effect_replay_test.go
new file mode 100644
index 000000000..075650759
--- /dev/null
+++ b/x86_blend_minpos_effect_replay_test.go
@@ -0,0 +1,279 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86BlendMinposCanonicalRows() []x86BlendMinposCase {
+	var result []x86BlendMinposCase
+	for _, row := range x86BlendMinposCases() {
+		if row.minimum {
+			if row.operand == "X0" {
+				continue
+			}
+		} else if row.legacy && row.dst != 2 || !row.legacy && row.dst != 3 {
+			continue
+		}
+		result = append(result, row)
+	}
+	return result
+}
+
+func TestX86BlendMinposTypedEveryByteMaskAndAliases(t *testing.T) {
+	for _, row := range x86BlendMinposCanonicalRows() {
+		if row.operand == "(BX)" {
+			continue
+		}
+		width, destination := row.width, row.dst
+		if row.legacy || row.minimum {
+			width = 16
+		}
+		for role := 0; role < 4; role++ {
+			t.Run(fmt.Sprintf("%s/%s/role%d", row.op, row.bank, role), func(t *testing.T) {
+				for missing := -1; missing < 64; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward, masks: [8]bool{1: true}}
+					for register := 0; register < 4; register++ {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					if missing >= 0 {
+						state.writeVector(role, 64, ^(uint64(1) << uint(missing)), false)
+					}
+					before := state.clone()
+					instruction := x86ScalarLaneInstruction(t, row.instruction())
+					if !x86ScalarFPResultTransfer(instruction, &state, nil, 0, "amd64") {
+						t.Fatal("complete named typed blend/minimum effect is missing", instruction.Raw)
+					}
+					want := before.vectorBytes(destination)
+					if !row.legacy {
+						want = ^uint64(0)
+					}
+					active := x86CallerVectorByteMask(int64(width))
+					want &^= active
+					if row.minimum {
+						want |= 0xfff8 // bits 127:19 are zero, including byte 3.
+						if before.vectorBytes(1)&0xffff == 0xffff {
+							want |= 7
+						}
+					} else {
+						base := 2
+						for at := 0; at < width; at++ {
+							maskByte := (at/(row.bits/8)+1)*(row.bits/8) - 1
+							known := before.vectorBytes(0)&(uint64(1)<<uint(maskByte)) != 0 &&
+								before.vectorBytes(1)&(uint64(1)<<uint(at)) != 0 && before.vectorBytes(base)&(uint64(1)<<uint(at)) != 0
+							if known {
+								want |= uint64(1) << uint(at)
+							}
+						}
+					}
+					if got := state.vectorBytes(destination); got != want {
+						t.Fatalf("%s role%d byte%d: known=%016x want=%016x", row.instruction(), role, missing, got, want)
+					}
+					for register := 0; register < 4; register++ {
+						if register != destination && state.vectorBytes(register) != before.vectorBytes(register) {
+							t.Fatal("typed blend/minimum wrote a nondestination alias")
+						}
+					}
+					if state.flags != before.flags || state.direction != before.direction ||
+						state.gp != before.gp || state.pointerGP != before.pointerGP || state.callerAddressGP != before.callerAddressGP || state.masks != before.masks {
+						t.Fatal("typed blend/minimum altered unrelated FLAGS, DF, GP, pointer or K state")
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86BlendMinposReplayProgram(row x86BlendMinposCase, code []byte, arch string, raw, memory bool) (string, string) {
+	word, move, suffix := goWordSize(arch), "MOVQ", "Q"
+	if arch == "386" {
+		move, suffix = "MOVL", "L"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),BX\n", 2*word, move, move, word)
+	for register := 0; register < 4; register++ {
+		fmt.Fprintf(&source, "VPXORQ Z%d,Z%d,Z%d\n", register, register, register)
+	}
+	if memory {
+		// The opcode retains its original full native source read; this is
+		// not a preloaded numerical replacement for its faulting access.
+		row.operand = "(BX)"
+	}
+	source.WriteString("MOVL $3,CX\nCMPL CX,$3\nSTD\n")
+	if raw {
+		source.WriteString(x86RawDisplacementDirectives(code))
+	} else {
+		source.WriteString(row.instruction() + "\n")
+	}
+	fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nPUSHF%s\nPOP%s CX\nANDL $0xcd5,CX\nMOVL CX,112(DI)\nCLD\nRET\n", row.dst, suffix, suffix)
+	return source.String(), "func Value(out *[128]byte,input *[32]byte)\n"
+}
+
+func TestX86BlendMinposWholeProducerReplayKeepsOriginalIdentity(t *testing.T) {
+	rows := x86BlendMinposCanonicalRows()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		var prior strings.Builder
+		for index, row := range rows {
+			for _, raw := range []bool{false, true} {
+				if arch == "386" && !raw && !row.legacy && !row.minimum {
+					continue
+				}
+				source, _ := x86BlendMinposReplayProgram(row, codes[index], arch, raw, row.operand == "(BX)")
+				prior.WriteString(strings.Replace(source, "·Value(SB)", fmt.Sprintf("·Prior%d_%t(SB)", index, raw), 1))
+			}
+		}
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String())
+		for index, row := range rows {
+			source, declaration := x86BlendMinposReplayProgram(row, codes[index], arch, true, row.operand == "(BX)")
+			check := x86LegacyFloatReplayCheck(t, arch, source, declaration)
+			if arch == "amd64" || row.legacy || row.minimum {
+				t.Run(arch+"/"+row.instruction()+"/named", func(t *testing.T) {
+					named, _ := x86BlendMinposReplayProgram(row, codes[index], arch, false, row.operand == "(BX)")
+					if err := check(mustParseX86RawReturn(t, named).Funcs[0]); err != nil {
+						t.Fatal("the independently initialized legal named producer must succeed", err)
+					}
+				})
+			}
+			for _, mutation := range []string{"valid", "origin", "replay", "source-spelling", "producer", "snapshot", "operand", "header"} {
+				t.Run(arch+"/"+row.instruction()+"/"+mutation, func(t *testing.T) {
+					file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+					if err != nil || len(file.Funcs) != 1 {
+						t.Fatal("actual original whole raw producer prerequisite", err)
+					}
+					original := file.Funcs[0]
+					if original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("the original raw source lost its independent complete replay")
+					}
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					ordinal := -1
+					for at, instruction := range candidate.Instrs {
+						if instruction.x86SourceRaw != nil && string(instruction.Op) == row.op {
+							if ordinal >= 0 {
+								t.Fatal("ambiguous original blend/minimum row")
+							}
+							ordinal = at
+						}
+					}
+					if ordinal < 0 {
+						t.Fatal("original Go bytes lost their decoded target instruction")
+					}
+					switch mutation {
+					case "origin":
+						candidate.Instrs[ordinal].x86SourceRaw = nil
+					case "replay":
+						candidate.x86RawReplay = nil
+					case "source-spelling":
+						candidate.Instrs[ordinal].Raw += " changed"
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "snapshot":
+						replay := *original.x86RawReplay
+						replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+						replay.normalized[ordinal].Op = "NOP"
+						candidate.x86RawReplay = &replay
+					case "operand":
+						candidate.Instrs[ordinal].Args[len(candidate.Instrs[ordinal].Args)-1].Reg = "X7"
+					case "header":
+						candidate.ArgSize++
+					}
+					err = check(candidate)
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("complete initialized original raw producer must succeed", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited source/origin/whole producer acquired a numerical continuation", err)
+					}
+					if original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("mutating a candidate corrupted the original source seal")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BlendMinposStandaloneNativeMemoryRemainsUnproved(t *testing.T) {
+	for _, row := range x86BlendMinposCanonicalRows() {
+		if row.operand != "(BX)" {
+			continue
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			for register := 0; register < 4; register++ {
+				state.writeVector(register, 64, ^uint64(0), false)
+			}
+			state.pointerGP[3], state.callerAddressGP[3] = true, true
+			before := state.clone()
+			instruction := x86ScalarLaneInstruction(t, row.instruction())
+			if x86ScalarFPResultTransfer(instruction, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+				t.Fatal("declaration-only native blend/minimum read acquired backing or mutated rejection", arch, row.instruction())
+			}
+		}
+	}
+}
+
+func TestX86BlendMinposDeadMemoryRetainsOriginalObservableRead(t *testing.T) {
+	rows := x86BlendMinposCanonicalRows()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	for index, row := range rows {
+		if row.operand != "(BX)" {
+			continue
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			word, move, triple := goWordSize(arch), "MOVQ", "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				move, triple = "MOVL", "i386-unknown-linux-gnu"
+			}
+			for _, raw := range []bool{false, true} {
+				if arch == "386" && !raw && !row.legacy && !row.minimum {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%s/%s/raw=%t", arch, row.op, row.bank, raw), func(t *testing.T) {
+					var source strings.Builder
+					fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s input+0(FP),BX\n", word, move)
+					zero := "PXOR"
+					if !row.legacy {
+						zero = "VXORPS"
+					}
+					for register := 0; register < 4; register++ {
+						if row.legacy {
+							fmt.Fprintf(&source, "%s X%d,X%d\n", zero, register, register)
+						} else {
+							fmt.Fprintf(&source, "%s %s%d,%s%d,%s%d\n", zero, row.bank, register, row.bank, register, row.bank, register)
+						}
+					}
+					if raw {
+						source.WriteString(x86RawDisplacementDirectives(codes[index]))
+					} else {
+						source.WriteString(row.instruction() + "\n")
+					}
+					source.WriteString("RET\n")
+					x86LEAActualTargetGoObject(t, arch, triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Value(input *[32]byte)", arch, triple, api)
+						if err != nil {
+							t.Fatal("dead output/zero mask did not erase the actual source-read obligation", api, err)
+						}
+						if row.legacy {
+							if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, strings.ToLower(row.op)+" ") || !strings.Contains(ir, "~{memory}") {
+								t.Fatal("legacy m128 must retain its actual opcode and alignment/fault behavior", api)
+							}
+						} else if !strings.Contains(ir, fmt.Sprintf("load volatile <%d x i8>", row.width)) &&
+							!strings.Contains(ir, strings.ToLower(row.op)+" ") {
+							t.Fatal("VEX full tuple read was removed for a dead zero-mask result", api)
+						}
+						if strings.Contains(ir, "+avx512") {
+							t.Fatal("isolated SSE4.1/AVX/AVX2 family borrowed an unrelated AVX512 producer", api)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_blend_minpos_format_test.go b/x86_blend_minpos_format_test.go
new file mode 100644
index 000000000..a559fb250
--- /dev/null
+++ b/x86_blend_minpos_format_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A private object unit proves Go operand/emitter formats, not initialized
+// public inputs, storage or native execution. Preserve the entire original
+// actual Go object and all three public Context results before using it.
+func x86UnboundBlendMinposFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("original blend/minimum formats lost their physical source", err)
+	}
+	return x86InstructionFormatObjectUnit(t, normalized, signatures, arch, triple, 0,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			if known, terminated, err := c.lowerVariableBlend(ins.Op, ins); known {
+				return known, terminated, err
+			}
+			return c.lowerPackedUnsignedWordMinimumPosition(ins.Op, ins)
+		})
+}
+
+func x86UnboundBlendMinposProbeObject(t *testing.T, file *File, arch, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	for _, fn := range file.Funcs {
+		text, valid := x86RawReplaySourceText(fn)
+		if !valid {
+			t.Fatal("original raw blend/minimum format source is absent")
+		}
+		source.WriteString(text)
+	}
+	return x86UnboundBlendMinposFormatObject(t, source.String(), arch, triple)
+}
+
+// Go's 386 frontend rejects every named four-operand VEX blend. Preserve
+// that original whole-source rejection with a real diagnostic, not an
+// assembler panic, missing tool, timeout or resource failure. Only the six
+// legal legacy rows enter mode32 named format objects; actual low-bank VEX
+// bytes have their separate complete encoder and initialized object owners.
+func x86BlendMinposOriginal386NamedFormats(t *testing.T, source, triple string) string {
+	t.Helper()
+	goAssemblerOracleOutput(t, "386", "#include \"textflag.h\"\n"+source, "", false)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("original 386 source changed its complete parser role", err)
+	}
+	name := strings.TrimPrefix(file.Funcs[0].Sym, "·")
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func "+name+"()", "386", triple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("Go-rejected named source invented initialized public inputs", api, err)
+		}
+	}
+	var legal strings.Builder
+	legacy, rejected := 0, 0
+	for _, line := range strings.Split(source, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 {
+			continue
+		}
+		if spec, known := amd64VariableBlendSpecs[Op(fields[0])]; known {
+			if spec.vector {
+				goAssemblerOracleOutput(t, "386", "TEXT ·Rejected(SB),4,$0-0\n"+line+"\nRET\n", "", false)
+				rejected++
+				continue
+			}
+			legacy++
+		} else if fields[0] != "TEXT" && fields[0] != "RET" {
+			t.Fatal("original named format directory contains an unrelated source operation", line)
+		}
+		fmt.Fprintln(&legal, line)
+	}
+	if legacy != 6 || rejected != 12 {
+		t.Fatal("original 386 named format classification changed", legacy, rejected)
+	}
+	t.Log("original 386 named source: 6 legal legacy formats, 12 Go-rejected VEX four-operand rows; physical low-bank VEX has separate complete owners")
+	return x86UnboundBlendMinposFormatObject(t, legal.String(), "386", triple)
+}
diff --git a/x86_blend_minpos_math_test.go b/x86_blend_minpos_math_test.go
new file mode 100644
index 000000000..f362bb681
--- /dev/null
+++ b/x86_blend_minpos_math_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This private mathematical companion is not execution of the original
+// alignment/fault program. It decodes the complete unchanged source, checks
+// the exact inventory, and transports m128 through a genuinely unused bank.
+// Keep the original legacy register operation: replacing it by VEX would
+// incorrectly clear the independently observed upper Y/Z destination aliases.
+func x86BlendMinposMathSource(source string, targets, legacyMemory, transports int) (string, error) {
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	if len(file.Data) != 0 || len(file.Globl) != 0 || len(file.UnlinkedPrelude) != 0 || len(file.Funcs) != targets {
+		return "", fmt.Errorf("private blend/minimum math needs its entire expected code-only source")
+	}
+	file, err = normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		return "", err
+	}
+	used := [32]bool{}
+	for _, fn := range file.Funcs {
+		if fn.FrameSize != 0 || fn.ArgSize != 24 && fn.ArgSize != 32 || len(fn.X86RawText) != 0 {
+			return "", fmt.Errorf("private math refuses a changed frame/native source role")
+		}
+		if len(fn.Instrs) < 2 || fn.Instrs[0].Op != OpTEXT || fn.Instrs[len(fn.Instrs)-1].Op != OpRET {
+			return "", fmt.Errorf("private math needs each original complete TEXT/RET program")
+		}
+		if fn.x86RawReplay != nil {
+			if err := fn.x86RawReplay.validate(fn, "amd64"); err != nil {
+				return "", err
+			}
+		}
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				if arg.Kind == OpReg {
+					if index, valid := amd64VectorRegisterIndex(arg.Reg, amd64VectorByteWidth(arg.Reg)); valid {
+						used[index] = true
+					}
+				}
+			}
+		}
+	}
+	scratch := -1
+	for index := 0; index < 8; index++ {
+		if !used[index] {
+			scratch = index
+			break
+		}
+	}
+	if scratch < 0 {
+		return "", fmt.Errorf("complete original math source has no unused mode32 X alias bank")
+	}
+	var result strings.Builder
+	gotTargets, gotLegacy, gotTransports := 0, 0, 0
+	for _, fn := range file.Funcs {
+		fmt.Fprintf(&result, "TEXT %s(SB),4,$0-%d\n", fn.Sym, fn.ArgSize)
+		functionTargets := 0
+		for _, ins := range fn.Instrs {
+			if ins.Op == "TEXT" {
+				continue
+			}
+			form, known, err := x86BlendMinposProperties(ins.Op, ins, "amd64")
+			if known {
+				if err != nil {
+					return "", err
+				}
+				gotTargets++
+				functionTargets++
+				if form.legacy && form.memory {
+					if ins.Args[form.source].Kind != OpMem || ins.Args[form.source].Mem.Sym != "" {
+						return "", fmt.Errorf("private math refuses a different legacy memory role")
+					}
+					fmt.Fprintf(&result, "VMOVDQU %s,X%d\n", ins.Args[form.source], scratch)
+					ins.Args = append([]Operand(nil), ins.Args...)
+					ins.Args[form.source] = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", scratch))}
+					gotLegacy++
+				}
+			} else if ins.Op == "MOVOU" && len(ins.Args) == 2 && ins.Args[0].Kind == OpMem && ins.Args[1].Kind == OpReg {
+				// A plain VEX replacement of MOVOU would lose the old wider
+				// aliases too. Use a separate register-to-register legacy copy.
+				if ins.Args[0].Mem.Sym != "" || !isAMD64XReg(ins.Args[1].Reg) {
+					return "", fmt.Errorf("private math refuses a different legacy transport role")
+				}
+				fmt.Fprintf(&result, "VMOVDQU %s,X%d\n", ins.Args[0], scratch)
+				ins.Args = append([]Operand(nil), ins.Args...)
+				ins.Args[0] = Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("X%d", scratch))}
+				gotTransports++
+			} else if ins.Op != "MOVQ" && ins.Op != "VMOVUPS" && ins.Op != OpRET {
+				return "", fmt.Errorf("private math refuses unrelated source operation %s", ins.Op)
+			}
+			args := make([]string, len(ins.Args))
+			for index, arg := range ins.Args {
+				args[index] = arg.String()
+			}
+			fmt.Fprintf(&result, "%s %s\n", ins.Op, strings.Join(args, ","))
+		}
+		if functionTargets != 1 {
+			return "", fmt.Errorf("private math lost one original opcode per function: %d", functionTargets)
+		}
+	}
+	if gotTargets != targets || gotLegacy != legacyMemory || gotTransports != transports {
+		return "", fmt.Errorf("private math source inventory differs: targets=%d legacy-m128=%d MOVOU=%d", gotTargets, gotLegacy, gotTransports)
+	}
+	return result.String(), nil
+}
+
+func x86BlendMinposPrivateMathCompanion(t *testing.T, source string, targets, legacyMemory, transports int) *File {
+	t.Helper()
+	originalHash := sha256.Sum256([]byte(source))
+	derived, err := x86BlendMinposMathSource(source, targets, legacyMemory, transports)
+	if err != nil {
+		t.Fatal("private mathematical instrumentation rejected the complete original source", err)
+	}
+	file, err := Parse(ArchAMD64, derived)
+	if err != nil || originalHash != sha256.Sum256([]byte(source)) {
+		t.Fatal("private mathematical instrumentation corrupted source/derived grammar", err)
+	}
+	t.Logf("private blend/minimum mathematical companion: original sha256=%x targets=%d legacy-m128 replacements=%d legacy transport replacements=%d; not original opcode alignment/fault execution", originalHash, targets, legacyMemory, transports)
+	return file
+}
+
+// Wide virtual aliases must not accidentally require AVX512 on an ordinary
+// host. Reuse the strict shared test-only feature projection: exact owned
+// definition/profile pairs only, no native asm or active target intrinsic,
+// and no changed body byte. This still does not execute original x86 opcodes.
+func x86BlendMinposMathIR(file *File, ir string) (string, error) {
+	profiles := make(map[string]string)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		if _, duplicate := profiles[name]; duplicate || len(fn.X86RawText) != 0 {
+			return "", fmt.Errorf("private mathematical IR lost its unique ordinary function")
+		}
+		profiles[name] = inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", fn)
+	}
+	return x86PackedShiftPortableFeatureProjection(ir, profiles)
+}
+
+func TestX86BlendMinposPrivateMathTransportAndBoundaries(t *testing.T) {
+	rows := x86BlendMinposCases()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	for _, minimum := range []bool{false, true} {
+		start, end, targets, memory, transports := 0, 72, 72, 12, 96
+		if minimum {
+			start, end, targets, memory, transports = 72, 78, 6, 1, 4
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("minimum=%t/raw=%t", minimum, raw), func(t *testing.T) {
+				source, declarations := x86BlendMinposProgram(rows[start:end], codes[start:end], "amd64", raw)
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				derived, err := x86BlendMinposMathSource(source, targets, memory, transports)
+				if err != nil || strings.Count(derived, "VMOVDQU ") != memory+transports {
+					t.Fatal("exact full-source mathematical companion changed its replacement inventory", err)
+				}
+				// On nonmatching hosts every inserted transport and retained
+				// legacy register operation must stay genuinely portable.
+				file, err := Parse(ArchAMD64, derived)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range []string{"x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu"} {
+					ir, err := x86ScalarFPBitViewAPI(t, derived, declarations, "amd64", triple, "Go")
+					if err != nil {
+						t.Fatal("private companion still contains a native legacy memory bridge", err)
+					}
+					if _, err := x86BlendMinposMathIR(file, ir); err != nil {
+						t.Fatal("private companion lost exact source/IR feature ownership", err)
+					}
+				}
+				for _, mutation := range []string{"inventory", "extra-op", "frame", "no-scratch"} {
+					t.Run(mutation, func(t *testing.T) {
+						changed, count := source, targets
+						switch mutation {
+						case "inventory":
+							count++
+						case "extra-op":
+							changed = strings.Replace(source, "RET", "CPUID\nRET", 1)
+						case "frame":
+							changed = strings.Replace(source, "$0-", "$8-", 1)
+						case "no-scratch":
+							var occupied strings.Builder
+							// Blend uses banks 0-3, but minimum uses only 0-1.
+							// Occupy the entire candidate set, independently of
+							// which banks the original builder already touches.
+							for index := 0; index < 8; index++ {
+								fmt.Fprintf(&occupied, "VMOVUPS Z%d,Z%d\n", index, index)
+							}
+							changed = strings.Replace(source, "RET", occupied.String()+"RET", 1)
+						}
+						output, err := x86BlendMinposMathSource(changed, count, memory, transports)
+						if err == nil || output != "" {
+							t.Fatal("different original source acquired the private mathematical instrumentation", mutation, err)
+						}
+						if mutation == "no-scratch" && !strings.Contains(err.Error(), "no unused mode32 X alias bank") {
+							t.Fatal("occupied scratch banks were rejected for an unrelated source error", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_blend_minpos_mode32_binding_test.go b/x86_blend_minpos_mode32_binding_test.go
new file mode 100644
index 000000000..a00a8fc16
--- /dev/null
+++ b/x86_blend_minpos_mode32_binding_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// The first minimum-position instruction fully defines its output. It must
+// not manufacture a physical high-bank identity for the second instruction
+// on mode32 merely because Go's named encoder accepts that spelling.
+func x86BlendMinposBankProgram(arch string, registers []int) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source, declarations strings.Builder
+	for _, register := range registers {
+		fmt.Fprintf(&source, "TEXT ·Bank%d(SB),4,$0-%d\n%s out+0(FP),DI\nPXOR X0,X0\n"+
+			"VPHMINPOSUW X0,X%d\nVPHMINPOSUW X%d,X0\nMOVOU X0,(DI)\nRET\n",
+			register, word, move, register, register)
+		fmt.Fprintf(&declarations, "func Bank%d(out *[16]byte)\n", register)
+	}
+	return source.String(), declarations.String()
+}
+
+func x86BlendMinposFourOperandProgram(row x86BlendMinposCase, code []byte, arch string, raw bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),BX\n", 2*word, move, move, word)
+	for register := 0; register < 3; register++ {
+		fmt.Fprintf(&source, "VXORPS %s%d,%s%d,%s%d\n", row.bank, register, row.bank, register, row.bank, register)
+	}
+	if raw {
+		source.WriteString(x86RawDisplacementDirectives(code))
+	} else {
+		source.WriteString(row.instruction() + "\n")
+	}
+	fmt.Fprintf(&source, "VMOVUPS %s3,(DI)\nRET\n", row.bank)
+	return source.String(), "func Value(out,input *[32]byte)\n"
+}
+
+func TestX86BlendMinposMode32NamedFourOperandCannotBorrowPhysicalRaw(t *testing.T) {
+	var rows []x86BlendMinposCase
+	for _, row := range x86BlendMinposCanonicalRows() {
+		if !row.legacy && !row.minimum {
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 12 {
+		t.Fatal("complete three-name X/Y register/memory named/raw partition changed")
+	}
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	var input strings.Builder
+	for index, row := range rows {
+		named, _ := x86BlendMinposFourOperandProgram(row, nil, "386", false)
+		goAssemblerOracleOutput(t, "386", named, "", false)
+		for _, value := range codes[index] {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+		x86HandoffOriginalBytes(t, "386", codes[index])
+	}
+	mc, llc := findLLVM22Tool("llvm-mc"), findLLVM22Tool("llc")
+	if mc == "" || llc == "" {
+		t.Fatal("genuine physical low-bank VEX prior and complete objects require LLVM22 llvm-mc/llc")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "x86_64-unknown-linux-gnu"} {
+		stage, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple, "--mattr=+avx2")
+		command.Stdin = strings.NewReader(input.String())
+		output, err := runtimeOracleCombinedOutput(stage, command)
+		cancel()
+		if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+			t.Fatalf("independent low-bank VEX physical prior: %v\n%s", err, output)
+		}
+		for _, name := range []string{"vblendvps", "vblendvpd", "vpblendvb"} {
+			count := 0
+			for _, line := range strings.Split(string(output), "\n") {
+				fields := strings.Fields(line)
+				if len(fields) != 0 && fields[0] == name {
+					count++
+				}
+			}
+			if count != 4 {
+				t.Fatal("LLVM22 lost complete X/Y register/memory physical rows", triple, name, count, string(output))
+			}
+		}
+	}
+	// Complete initialized positive batches retain AMD64's named grammar
+	// and mode32's genuinely decoded physical instruction independently.
+	for _, arch := range []string{"386", "amd64"} {
+		raw := arch == "386"
+		triple := "x86_64-unknown-linux-gnu"
+		if raw {
+			triple = "i386-unknown-linux-gnu"
+		}
+		var source, declarations strings.Builder
+		for index, row := range rows {
+			body, declaration := x86BlendMinposFourOperandProgram(row, codes[index], arch, raw)
+			name := fmt.Sprintf("Variant%d", index)
+			source.WriteString(strings.Replace(body, "·Value(SB)", "·"+name+"(SB)", 1))
+			declarations.WriteString(strings.Replace(declaration, "Value(", name+"(", 1))
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/positive/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("actual physical/raw or legal AMD64 named initialized family failed", err)
+				}
+				compileLLVMToObject(t, llc, triple, "bound-four-operand.ll", "bound-four-operand.o", ir)
+			})
+		}
+	}
+	for index, row := range rows {
+		t.Run(row.instruction(), func(t *testing.T) {
+			named, declaration := x86BlendMinposFourOperandProgram(row, nil, "386", false)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, named, declaration, "386", "i386-unknown-linux-gnu", api)
+					if err == nil || ir != "" {
+						t.Fatal("Go-invalid mode32 named grammar borrowed physical raw permission", err)
+					}
+				})
+			}
+			t.Run("typed-named-grammar", func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				if _, known, err := x86BlendMinposProperties(ins.Op, ins, "386"); !known || err == nil {
+					t.Fatal("typed named grammar accepted Go-rejected mode32 four operands", err)
+				}
+			})
+			t.Run("physical-identity-replay", func(t *testing.T) {
+				source, declaration := x86BlendMinposFourOperandProgram(row, codes[index], "386", true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "386")
+				if err != nil || len(file.Funcs) != 1 || file.Funcs[0].x86RawReplay == nil {
+					t.Fatal("complete physical source lacks its original replay", err)
+				}
+				candidate := file.Funcs[0]
+				candidate.Instrs = cloneX86ReplayInstrs(candidate.Instrs)
+				changed := 0
+				for at := range candidate.Instrs {
+					if candidate.Instrs[at].Op == Op(row.op) {
+						candidate.Instrs[at].x86Encoded = !candidate.Instrs[at].x86Encoded
+						changed++
+					}
+				}
+				if changed != 1 {
+					t.Fatal("physical source target inventory changed", changed)
+				}
+				check := x86LegacyFloatReplayCheck(t, "386", source, declaration)
+				if err := check(candidate); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("edited physical/named projection acquired original source permission", err)
+				}
+			})
+		})
+	}
+}
+
+func TestX86BlendMinposMode32HighNamedNeedsPhysicalBinding(t *testing.T) {
+	registers := []int{8, 9, 10, 11, 12, 13, 14, 15}
+	complete, _ := x86BlendMinposBankProgram("386", registers)
+	// A successful real Go object is only a frontend premise, not evidence
+	// that physical mode32 has distinct X8-X15 registers.
+	x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", complete)
+	for _, register := range registers {
+		t.Run(fmt.Sprintf("X%d", register), func(t *testing.T) {
+			source, declarations := x86BlendMinposBankProgram("386", []int{register})
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", "i386-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("initialized numerical bytes acquired an unbound physical mode32 vector identity", err)
+					}
+				})
+			}
+			for _, instruction := range []string{fmt.Sprintf("VPHMINPOSUW X0,X%d", register), fmt.Sprintf("VPHMINPOSUW X%d,X0", register)} {
+				t.Run(instruction, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, instruction)
+					if _, known, err := x86BlendMinposProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("typed grammar confused Go-accepted spelling with a physical mode32 binding", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BlendMinposSameHighNamedAMD64StillWorks(t *testing.T) {
+	source, declarations := x86BlendMinposBankProgram("amd64", []int{8, 9, 10, 11, 12, 13, 14, 15})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("same initialized AMD64 high bank requires LLVM22 object compilation")
+	}
+	for _, target := range x86AddressMemoryTargets("amd64") {
+		t.Run(target, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", target, api)
+					if err != nil || ir == "" {
+						t.Fatal("physical AMD64 high bank regressed to mode32 Context", err)
+					}
+					compileLLVMToObject(t, llc, target, "high-bank.ll", "high-bank.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86BlendMinposLowBankPhysicalAndInitializedFiveTargets(t *testing.T) {
+	registers := []int{0, 1, 2, 3, 4, 5, 6, 7}
+	var body strings.Builder
+	for _, register := range registers {
+		fmt.Fprintf(&body, "VPHMINPOSUW X0,X%d\nVPHMINPOSUW X%d,X0\n", register, register)
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "386", body.String()+"RET")
+	if len(pcs) != 17 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("actual Go mode32 low-bank directory is incomplete")
+	}
+	for index, register := range registers {
+		for direction, modrm := range []byte{0xc0 | byte(register)<<3, 0xc0 | byte(register)} {
+			at := 2*index + direction
+			want := []byte{0xc4, 0xe2, 0x79, 0x41, modrm}
+			if !bytes.Equal(code[pcs[at]:pcs[at+1]], want) {
+				t.Fatal("Go bytes differ from independent VEX.128.66.0F38.W0 NOVSR low-bank fields", register, direction)
+			}
+		}
+	}
+	x86HandoffOriginalBytes(t, "386", code)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("initialized physical low-bank objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86BlendMinposBankProgram(target.arch, registers)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized physically bound low-bank producer failed", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "low-bank.ll", "low-bank.o", ir)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_blend_minpos_native_linux_amd64_test.go b/x86_blend_minpos_native_linux_amd64_test.go
new file mode 100644
index 000000000..76e6b47c4
--- /dev/null
+++ b/x86_blend_minpos_native_linux_amd64_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Required Linux owners execute the original low-bank Go bytes directly.
+// A portable mathematical companion, emulator or machine object cannot
+// qualify actual Type4 alignment faults and dead/zero-mask native reads.
+func TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaultsAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.compiler = append(execution.compiler, "-mavx2")
+	x86BlendMinposNativeFaults(t, execution, "amd64")
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaults386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required native mode32 tools: LLVM22=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie", "-mavx2"}}
+	x86BlendMinposNativeFaults(t, execution, "386")
+	x87IA32RequireNativeHost(t)
+}
+
+func x86BlendMinposNativeFaults(t *testing.T, execution x86FloatCompareExecution, arch string) {
+	t.Helper()
+	if len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("original blend/minimum faults require direct native execution")
+	}
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "isa.c"), filepath.Join(directory, "isa")
+	if err := os.WriteFile(source, []byte(`#include <stdio.h>
+int main(void) {
+    __builtin_cpu_init();
+    int sse41=!!__builtin_cpu_supports("sse4.1"),avx2=!!__builtin_cpu_supports("avx2");
+    printf("blend/minimum actual native SSE4.1=%d AVX2=%d\n",sse41,avx2);
+    return sse41&&avx2?0:1;
+}
+`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	t.Logf("%s", strings.TrimSpace(string(execution.run(t, executable))))
+	assembly, declarations, codes := x86BlendMinposNativeProgram(t, arch)
+	x86LEAActualTargetGoObject(t, arch, execution.triple, assembly)
+	references, cases := x86BlendMinposNativeReferences(t, codes)
+	driver := x86MemoryFaultSupportC + references + x86BlendMinposNativeModelC +
+		"static const struct blend_minpos_case cases[]={\n" + cases + "};\n" + x86BlendMinposNativeMainC
+	ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, arch, execution.triple, "Go")
+	if err != nil || ir == "" {
+		t.Fatal("complete initialized original blend/minimum program rejected", err)
+	}
+	for _, pipeline := range []struct{ name, body, level string }{
+		{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+		{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			program := execution.compileLLVM(t, "blend-minimum-original-faults", pipeline.body, driver, pipeline.level)
+			var ia32 x87IA32Executable
+			if arch == "386" {
+				ia32 = x86NativeOracleIA32Executable(t, execution, program)
+			}
+			observe := func(row, probe, original int) string {
+				if arch == "386" {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				outcome := x86ObserveMemoryFault(t, execution, program, row, probe, original)
+				if arch == "386" {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return outcome
+			}
+			for index, row := range x86BlendMinposMemoryRows() {
+				for role, name := range []string{"live", "dead"} {
+					for zero := 0; zero < 2; zero++ {
+						t.Run(fmt.Sprintf("%s/%s/%s/maskzero=%d", row.op, row.bank, name, zero), func(t *testing.T) {
+							for probe := 0; probe < 20; probe++ {
+								returns := probe == 2 || probe == 3 || !row.legacy && probe >= 4 && probe <= 18
+								want := observe(4*index+2*role+zero, probe, 1)
+								if returns && want != "return" || !returns && want != "segv" && want != "bus" {
+									t.Fatal("actual Go bytes differ from independent alignment/access oracle", probe, want)
+								}
+								if got := observe(4*index+2*role+zero, probe, 0); got != want {
+									t.Fatal("translated actual opcode/read differs from original bytes", probe, got, want)
+								}
+							}
+							t.Log("blend/minimum original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0")
+						})
+					}
+				}
+			}
+		})
+	}
+}
+
+const x86BlendMinposNativeModelC = `
+typedef void (*blend_minpos_call)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*);
+struct blend_minpos_case {
+    blend_minpos_call translated,original;
+    unsigned width,lane,minimum,legacy,live,zero;
+};
+static void blend_minpos_expected(uint8_t *out,const uint8_t *input,
+        const uint8_t *old,const uint8_t *mask,struct blend_minpos_case k) {
+    if (!k.live) return;
+    if (k.minimum) {
+        unsigned minimum=65535,position=0;
+        for (unsigned i=0;i<8;i++) {
+            unsigned value=(unsigned)input[2*i]|((unsigned)input[2*i+1]<<8);
+            if (value<minimum) {minimum=value;position=i;}
+        }
+        memset(out,0,16);out[0]=(uint8_t)minimum;out[1]=(uint8_t)(minimum>>8);out[2]=(uint8_t)position;
+    } else for (unsigned at=0;at<k.width;at+=k.lane) {
+        const uint8_t *chosen=(mask[at+k.lane-1]&128)?input:old;
+        memcpy(out+at,chosen+at,k.lane);
+    }
+}
+`
+
+const x86BlendMinposNativeMainC = `
+int main(int argc,char **argv) {
+    unsigned row,probe,original;
+    char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&row,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 || sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            row>=sizeof(cases)/sizeof(cases[0]) || probe>=20 || original>1) return 80;
+    int setup=memory_fault_setup(0);
+    if (setup) return setup;
+    struct blend_minpos_case k=cases[row];
+    if ((uintptr_t)guard%32 || page%32) return 81;
+    const uint8_t *input=probe==0?NULL:probe==1?guard+page-k.width+1:
+        probe==2||probe==3?guard+page-k.width:probe==19?guard+page:guard+probe-3;
+    int returns=probe==2||probe==3||(!k.legacy&&probe>=4&&probe<=18);
+    if (probe>=4 && probe<=18 && (uintptr_t)input%16!=probe-3) return 82;
+    if (probe==3 && mprotect(guard,page,PROT_READ)) return 83;
+    uint8_t old[48],mask[48],before_old[48],before_mask[48],out[96],expected[96];
+    for (unsigned i=0;i<48;i++) {
+        old[i]=(uint8_t)(i*31+0x80);mask[i]=k.zero?0:(uint8_t)(i*73+0x80);
+    }
+    memcpy(before_old,old,sizeof(old));memcpy(before_mask,mask,sizeof(mask));
+    memset(out,0xc3,sizeof(out));memset(expected,0xc3,sizeof(expected));
+    if (returns) blend_minpos_expected(expected+1,input,old+1,mask+1,k);
+    expected[65]=1;
+    /* Fix AMD MisAlignSSE's optional MM bit to the common MM=0 mode. */
+    uint32_t fixed_mxcsr=UINT32_C(0x1f80),observed_mxcsr=0;
+    __asm__ volatile("ldmxcsr %0" : : "m"(fixed_mxcsr) : "memory");
+    __asm__ volatile("stmxcsr %0" : "=m"(observed_mxcsr) : : "memory");
+    if (observed_mxcsr!=fixed_mxcsr) return 90;
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 84;
+    (original?k.original:k.translated)(out+1,input,old+1,mask+1);
+    /* Never create a C fault by reading input after unexpected return. */
+    if (!returns) return 85;
+    __asm__ volatile("stmxcsr %0" : "=m"(observed_mxcsr) : : "memory");
+    if (observed_mxcsr!=fixed_mxcsr) return 91;
+    if (memcmp(out,expected,sizeof(out)) || memcmp(old,before_old,sizeof(old)) ||
+            memcmp(mask,before_mask,sizeof(mask))) return 86;
+    for (size_t i=0;i<page;i++) if (guard[i]!=(uint8_t)(i*13+17)) return 87;
+    if (free_guard()) return 88;
+    puts("memory complete");
+    return fflush(stdout)?89:0;
+}
+`
diff --git a/x86_blend_minpos_native_test.go b/x86_blend_minpos_native_test.go
new file mode 100644
index 000000000..49397d38d
--- /dev/null
+++ b/x86_blend_minpos_native_test.go
@@ -0,0 +1,306 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86BlendMinposMemoryRows() []x86BlendMinposCase {
+	var rows []x86BlendMinposCase
+	for _, row := range x86BlendMinposCanonicalRows() {
+		if row.operand == "(BX)" {
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+// A minimum-ISA counterpart, separate from the original 78 programs which
+// deliberately observe Z/Y/X aliases. Actual bytes supply mode32's valid VEX
+// forms without borrowing Go's different four-operand named frontend.
+func x86BlendMinposNativeProgram(t *testing.T, arch string) (string, string, [][]byte) {
+	t.Helper()
+	rows := x86BlendMinposMemoryRows()
+	codes := x86BlendMinposOriginalCodes(t, rows)
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source, declarations strings.Builder
+	for index, row := range rows {
+		for _, role := range []string{"live", "dead"} {
+			name := fmt.Sprintf("BlendMinposNative%d_%s", index, role)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),BX\n%s old+%d(FP),CX\n%s mask+%d(FP),DX\n",
+				name, 4*word, move, move, word, move, 2*word, move, 3*word)
+			fmt.Fprintf(&source, "VMOVUPS (CX),%s2\nVMOVUPS (DX),%s0\nSTC\n", row.bank, row.bank)
+			source.WriteString(x86RawDisplacementDirectives(codes[index]))
+			if role == "live" {
+				fmt.Fprintf(&source, "VMOVUPS %s%d,(DI)\n", row.bank, row.dst)
+			}
+			source.WriteString("SETCS 64(DI)\nRET\n")
+			fmt.Fprintf(&declarations, "func %s(out *[80]byte,input,old,mask *[32]byte)\n", name)
+		}
+	}
+	return source.String(), declarations.String(), codes
+}
+
+// These actual Go byte wrappers share the native driver's generator. They
+// use only SSE4.1/AVX2, never an incidental AVX512 producer or emulator.
+func x86BlendMinposNativeReferences(t *testing.T, codes [][]byte) (string, string) {
+	t.Helper()
+	rows := x86BlendMinposMemoryRows()
+	if len(codes) != len(rows) || len(rows) != 11 {
+		t.Fatal("incomplete independent native blend/minimum byte directory")
+	}
+	var references, cases strings.Builder
+	for index, row := range rows {
+		literal := make([]string, len(codes[index]))
+		for at, value := range codes[index] {
+			literal[at] = fmt.Sprintf("0x%02x", value)
+		}
+		for _, role := range []string{"live", "dead"} {
+			name := fmt.Sprintf("BlendMinposNative%d_%s", index, role)
+			bank := "xmm"
+			if row.width == 32 {
+				bank = "ymm"
+			}
+			assembly := fmt.Sprintf("vmovups (%%1),%%%%%s2\n\tvmovups (%%3),%%%%%s0\n\tstc\n\t.byte %s\n\t", bank, bank, strings.Join(literal, ","))
+			live := 0
+			if role == "live" {
+				assembly += fmt.Sprintf("vmovups %%%%%s%d,(%%2)\n\t", bank, row.dst)
+				live = 1
+			}
+			assembly += "setc 64(%2)"
+			fmt.Fprintf(&references, `extern void %[1]s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*);
+static __attribute__((noinline,used)) void original_%[1]s(uint8_t *out,const uint8_t *input,const uint8_t *old,const uint8_t *mask) {
+    __asm__ volatile(%[2]s : : "b"(input),"r"(old),"r"(out),"r"(mask) : "xmm0","xmm2","xmm3","memory","cc");
+}
+`, name, strconv.Quote(assembly))
+			flag := func(value bool) int {
+				if value {
+					return 1
+				}
+				return 0
+			}
+			width := row.width
+			if row.legacy {
+				width = 16
+			}
+			for zero := 0; zero < 2; zero++ {
+				fmt.Fprintf(&cases, "{%s,original_%s,%d,%d,%d,%d,%d,%d},\n", name, name, width, row.bits/8, flag(row.minimum), flag(row.legacy), live, zero)
+			}
+		}
+	}
+	return references.String(), cases.String()
+}
+
+func TestX86BlendMinposOriginalNativeWrappersCompile(t *testing.T) {
+	clang, objdump := findLLVM22Tool("clang"), findLLVM22Tool("llvm-objdump")
+	if clang == "" || objdump == "" {
+		t.Fatal("original native wrappers require LLVM22 clang and llvm-objdump")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, _, codes := x86BlendMinposNativeProgram(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			references, _ := x86BlendMinposNativeReferences(t, codes)
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					directory := t.TempDir()
+					input, object := filepath.Join(directory, "reference.c"), filepath.Join(directory, "reference.o")
+					if err := os.WriteFile(input, []byte("typedef unsigned char uint8_t;\n"+references), 0600); err != nil {
+						t.Fatal(err)
+					}
+					stage, cancel := runtimeOracleStageContext(t)
+					output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, clang, "--no-default-config",
+						"-target", target.triple, "-nostdinc", "-ffreestanding", "-mavx2", level, "-c", input, "-o", object))
+					cancel()
+					if err != nil {
+						t.Fatalf("original wrapper C/assembly failed: %v\n%s", err, output)
+					}
+					stage, cancel = runtimeOracleStageContext(t)
+					listing, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, objdump, "-d", object))
+					cancel()
+					if err != nil {
+						t.Fatal("independent original wrapper disassembly", err, string(listing))
+					}
+					if count := len(regexp.MustCompile(`(?m)^[0-9a-f]+ <_?original_BlendMinposNative[0-9]+_(?:live|dead)>:\r?\n`).FindAll(listing, -1)); count != 22 {
+						t.Fatal("actual object lost an original live/dead wrapper", count)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BlendMinposNativeBackingAndTargetRemainIndependent(t *testing.T) {
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown"} {
+		t.Run(triple, func(t *testing.T) {
+			source, declarations, _ := x86BlendMinposNativeProgram(t, "amd64")
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("nonmatching target acquired original legacy alignment/fault behavior", err)
+			}
+		})
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86BlendMinposMemoryRows() {
+			if !row.legacy {
+				continue
+			}
+			t.Run(target.triple+"/"+row.op, func(t *testing.T) {
+				instruction := strings.Replace(row.instruction(), "(BX)", "input+0(FP)", 1)
+				source := "TEXT ·Value(SB),4,$0-16\nPXOR X0,X0\nPXOR X2,X2\n" + instruction + "\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(input,other uint64)", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("logical FP bytes acquired actual native m128 storage", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86BlendMinposActualNativeObjectsRetainLegacyDeadReads(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("actual native objects require exact LLVM22 llc and llvm-objdump")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _ := x86BlendMinposNativeProgram(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual initialized original native program rejected", err)
+					}
+					if strings.Contains(ir, "+avx512") {
+						t.Fatal("minimum-ISA original family borrowed AVX512")
+					}
+					for _, pipeline := range []struct{ name, body, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							directory := t.TempDir()
+							input, object := filepath.Join(directory, "native.ll"), filepath.Join(directory, "native.o")
+							if err := os.WriteFile(input, []byte(pipeline.body), 0600); err != nil {
+								t.Fatal(err)
+							}
+							stage, cancel := runtimeOracleStageContext(t)
+							output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, llc,
+								pipeline.level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+							cancel()
+							if err != nil {
+								t.Fatalf("actual native object failed: %v\n%s", err, output)
+							}
+							stage, cancel = runtimeOracleStageContext(t)
+							listing, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, objdump, "-d", object))
+							cancel()
+							if err != nil {
+								t.Fatal("native object disassembly", err, string(listing))
+							}
+							sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?(BlendMinposNative[0-9]+_(?:live|dead))>:\r?\n`).FindAllSubmatchIndex(listing, -1)
+							if len(sections) != 22 {
+								t.Fatal("native object lost an original live/dead function", len(sections))
+							}
+							for index, section := range sections {
+								name := string(listing[section[2]:section[3]])
+								end := len(listing)
+								if index+1 < len(sections) {
+									end = sections[index+1][0]
+								}
+								var ordinal int
+								if _, err := fmt.Sscanf(name, "BlendMinposNative%d_", &ordinal); err != nil || ordinal < 0 || ordinal >= 11 {
+									t.Fatal("unrecognized original function identity", name, err)
+								}
+								row := x86BlendMinposMemoryRows()[ordinal]
+								if row.legacy {
+									pattern := `(?m)\b` + strings.ToLower(row.op) + `[ \t]+[^\r\n]*\([^\r\n]+\),[ \t]*%xmm[0-9]+`
+									if count := len(regexp.MustCompile(pattern).FindAll(listing[section[1]:end], -1)); count != 1 {
+										t.Fatalf("%s lost its sole original legacy faulting read: count=%d\n%s", name, count, listing[section[1]:end])
+									}
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BlendMinposRequiredNativeOwners(t *testing.T) {
+	const file = "x86_blend_minpos_native_linux_amd64_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm64"},
+		{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", file)
+		if err != nil || selected != (target.os == "linux" && target.arch == "amd64") {
+			t.Fatal("required native fault owner selected on an inapplicable host", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), file, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string]bool{
+		"TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaultsAMD64": false,
+		"TestCrossLinuxRuntimeMatrixX86BlendMinposOriginalFaults386":   false,
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		ast.Inspect(function, func(node ast.Node) bool {
+			if selector, ok := node.(*ast.SelectorExpr); ok && strings.HasPrefix(selector.Sel.Name, "Skip") {
+				t.Fatal("required actual native execution acquired an optional skip", function.Name.Name)
+			}
+			return true
+		})
+		if _, found := wanted[function.Name.Name]; !found {
+			continue
+		}
+		host, full := 0, 0
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				if callee, ok := call.Fun.(*ast.Ident); ok {
+					if callee.Name == "x87IA32RequireNativeHost" {
+						host++
+					}
+					if callee.Name == "x86BlendMinposNativeFaults" {
+						full++
+					}
+				}
+			}
+			return true
+		})
+		if host != 2 || full != 1 || wanted[function.Name.Name] {
+			t.Fatal("required owner lost host brackets or its complete fault matrix", function.Name.Name, host, full)
+		}
+		wanted[function.Name.Name] = true
+	}
+	for root, found := range wanted {
+		if !found {
+			t.Fatal("required actual-native owner missing", root)
+		}
+	}
+}
diff --git a/x86_block_extract_store_runtime_test.go b/x86_block_extract_store_runtime_test.go
new file mode 100644
index 000000000..29c8f7c66
--- /dev/null
+++ b/x86_block_extract_store_runtime_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Unmasked block extraction is a portable bit copy. Masked E6NF stores retain
+// their independent required native original-Go/LLVM runtime owner.
+func TestX86BlockExtractUnmaskedStorePortableBytes(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, originalTriple, move, word := "amd64", "x86_64-unknown-linux-gnu", "MOVQ", 8
+	if strconv.IntSize == 32 {
+		arch, originalTriple, move, word = "386", "i386-unknown-linux-gnu", "MOVL", 4
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, row := range x86BlockNativeStoreRows(arch) {
+		if strings.Contains(row, "K1") {
+			continue
+		}
+		chunk, width, _ := x86InsertExtractMaskedMemoryShape(row)
+		for _, selector := range []int{0, 1, 2, 3, 255} {
+			name := fmt.Sprint("Store", count)
+			instruction := strings.Replace(row, "$255", fmt.Sprint("$", selector), 1)
+			fmt.Fprintf(&declarations, "func %s(out, input *byte)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),BX\n%s input+%d(FP),DX\nVMOVUPS (DX),Z1\n%s\nRET\n",
+				name, 2*word, move, move, word, instruction)
+			fmt.Fprintf(&prototypes, "extern void %s(void*,const void*);\n", name)
+			fmt.Fprintf(&rows, "{%s,%d,%d},\n", name, chunk, (selector%(width/chunk))*chunk)
+			count++
+		}
+	}
+	if count != 70 {
+		t.Fatal("incomplete unmasked extraction/selector inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, arch, originalTriple, source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() + `
+static const struct {
+    void (*run)(void*,const void*);
+    unsigned width, offset;
+} cases[] = {
+` + rows.String() + `
+};
+int main(void) {
+    for (unsigned row = 0; row < sizeof(cases)/sizeof(cases[0]); ++row) {
+        for (unsigned sample = 0; sample < 257; ++sample) {
+            uint8_t input[66], original[66], output[66], expected[66];
+            for (unsigned byte = 0; byte < sizeof(input); ++byte)
+                input[byte] = (uint8_t)((byte*31 + sample*17) ^ (sample>>1));
+            memcpy(original, input, sizeof(input));
+            memset(output, 0xa5, sizeof(output));
+            memcpy(expected, output, sizeof(output));
+            memcpy(expected+1, input+1+cases[row].offset, cases[row].width);
+            cases[row].run(output+1, input+1);
+            if (memcmp(output, expected, sizeof(output)) ||
+                memcmp(input, original, sizeof(input))) {
+                fprintf(stderr, "row=%u sample=%u block bytes or canaries differ\n", row, sample);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("initialized unmasked extraction rejected", err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86DwordProductIROptimize(t, text)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "block-extract-store",
+							triple, text, driver, nil, level)
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_bls_input_effect_test.go b/x86_bls_input_effect_test.go
new file mode 100644
index 000000000..85a252870
--- /dev/null
+++ b/x86_bls_input_effect_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86BLSTestNames = []string{"BLSIL", "BLSIQ", "BLSMSKL", "BLSMSKQ", "BLSRL", "BLSRQ"}
+
+func TestX86BLSTypedInputsAndDefinedFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BLSTestNames {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" AX,BX")
+				effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 {
+					t.Fatal("complete BLS family lacks its source/result effect", known, err)
+				}
+				width := int64(4)
+				if arch == "amd64" && strings.HasSuffix(op, "Q") {
+					width = 8
+				}
+				for ordinal, operand := range effect.operands {
+					if operand.index != ordinal || !reflect.DeepEqual(operand.operand, ins.Args[ordinal]) ||
+						operand.width != width || operand.read != (ordinal == 0) || operand.write != (ordinal == 1) {
+						t.Fatal("BLS changed ordered inputs, result or physical-mode width", operand)
+					}
+				}
+				defined := x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+				if effect.flagsRead != 0 || effect.flagsDefined != defined || effect.flagsKilled != x86ByteFlagsAll ||
+					!effect.requiresResultProof || effect.dynamicMemory {
+					t.Fatal("BLS invented incoming, preserved or defined status bits", effect)
+				}
+			})
+		}
+	}
+}
+
+func TestX86BLSVoidNativeInputsCannotBypassWholeProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, unusedBool := range []bool{false, true} {
+			word, move, declaration := int(goWordSize(target.arch)), "MOVQ", "func Value(p *[16]byte)"
+			if word == 4 {
+				move = "MOVL"
+			}
+			extent := word
+			if unusedBool {
+				declaration = "func Value(p *[16]byte, unused bool)"
+				extent++
+			}
+			var original strings.Builder
+			for ordinal, op := range x86BLSTestNames {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\n%s 3(AX)(DX*2),CX\nRET\n", extent, move, op)
+				variants := []struct{ name, source string }{
+					{"initialized", source},
+					{"unknown-pointer", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+					{"numerical-pointer", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+					{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+				}
+				for index, variant := range variants {
+					name := fmt.Sprintf("Value%dCase%d", ordinal, index)
+					original.WriteString(strings.Replace(variant.source, "·Value(SB)", "·"+name+"(SB)", 1))
+				}
+				t.Run(fmt.Sprintf("%s/bool%t/%s", target.triple, unusedBool, op), func(t *testing.T) {
+					for _, variant := range variants {
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, variant.source, declaration, target.arch, target.triple, api)
+							if variant.name == "initialized" || variant.name == "numerical-pointer" {
+								if err != nil || ir == "" {
+									t.Fatal("complete Void BLS native inputs rejected", api, err)
+								}
+								if variant.name == "numerical-pointer" {
+									bits := 32
+									if target.arch == "amd64" && strings.HasSuffix(op, "Q") {
+										bits = 64
+									}
+									if !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", bits)) {
+										t.Fatal("NUM BLS address lost its physical-mode read width", bits)
+									}
+									x86RequireNumericNativeSourceContext(t, variant.source, declaration, target.arch)
+									x86NumericNativeAddressObject(t, ir, target.triple)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Errorf("%s/%s: missing BLS native input bypassed the proof: %v", variant.name, api, err)
+							}
+						}
+					}
+				})
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, original.String())
+		}
+	}
+}
+
+func TestX86BLSInitializedPhysicalWidthsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete BLS objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86BLSTestNames {
+			for _, memory := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/memory%t", target.triple, op, memory), func(t *testing.T) {
+					width, typ, move := 4, "uint32", "MOVL"
+					if target.arch == "amd64" && strings.HasSuffix(op, "Q") {
+						width, typ, move = 8, "uint64", "MOVQ"
+					}
+					parameter, input, load, result := typ, "AX", move, width
+					if target.arch == "amd64" {
+						result = 8 // ABI0 result fields begin at the next native-word boundary.
+					}
+					if memory {
+						parameter, input, result = "*"+typ, "(AX)", int(goWordSize(target.arch))
+						load = "MOVL"
+						if result == 8 {
+							load = "MOVQ"
+						}
+					}
+					declaration := fmt.Sprintf("func Value(source %s) %s", parameter, typ)
+					body := fmt.Sprintf("%s source+0(FP),AX\n%s %s,DX\n%s DX,ret0+%d(FP)\nRET\n", load, op, input, move, result)
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete BLS typed source rejected", api, err)
+						}
+						for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							if memory && !strings.Contains(text, fmt.Sprintf("load volatile i%d, ptr", width*8)) {
+								t.Fatal("BLS lost its exact native read", width)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_bls_original_program_test.go b/x86_bls_original_program_test.go
new file mode 100644
index 000000000..b78f6f4ff
--- /dev/null
+++ b/x86_bls_original_program_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import "testing"
+
+const x86BLSOriginalRuntimeSource = `TEXT blssemantics(SB),$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0, AX
+	BLSIQ AX, BX
+	MOVQ BX, 0(DI)
+	SETCS 48(DI)
+	SETEQ 49(DI)
+	SETMI 50(DI)
+	SETOS 51(DI)
+	MOVQ $0x8000000000000000, AX
+	BLSIQ AX, BX
+	MOVQ BX, 8(DI)
+	MOVQ $0, AX
+	BLSMSKQ AX, BX
+	MOVQ BX, 16(DI)
+	SETCS 52(DI)
+	SETEQ 53(DI)
+	SETMI 54(DI)
+	SETOS 55(DI)
+	MOVQ $10, AX
+	BLSRQ AX, BX
+	MOVQ BX, 24(DI)
+	SETCS 56(DI)
+	SETEQ 57(DI)
+	SETMI 58(DI)
+	SETOS 59(DI)
+	MOVL $0x80000000, AX
+	BLSIL AX, BX
+	MOVQ BX, 32(DI)
+	MOVL $0, AX
+	BLSMSKL AX, BX
+	MOVQ BX, 40(DI)
+	RET
+`
+
+const x86BLSOriginalRuntimeDriver = `
+#include <stdint.h>
+#include <string.h>
+extern void blssemantics(uint8_t *);
+int main(void) {
+  uint8_t out[64] = {0};
+  blssemantics(out);
+  const uint64_t want[6] = {0, UINT64_C(0x8000000000000000), UINT64_MAX, 8, UINT64_C(0x80000000), UINT64_C(0xffffffff)};
+  for (int i = 0; i < 6; i++) {
+    uint64_t got;
+    memcpy(&got, out + i * 8, sizeof(got));
+    if (got != want[i]) return 10 + i;
+  }
+  const uint8_t flags[12] = {0,1,0,0, 1,0,1,0, 0,0,0,0};
+  for (int i = 0; i < 12; i++) if (out[48+i] != flags[i]) return 30+i;
+  return 0;
+}
+`
+
+func TestX86BLSOriginalProgramPortableAndObjects(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	const declaration = "func blssemantics(out *[64]byte)"
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-macosx", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, x86BLSOriginalRuntimeSource)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, x86BLSOriginalRuntimeSource, declaration, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("unchanged original CI source", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, execution.llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("portable/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86BLSOriginalRuntimeSource, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "original-bls", text, x86BLSOriginalRuntimeDriver, level)
+				}
+			}
+		})
+	}
+	t.Log("original Go/LLVM objects and actual-host portable values/FLAGS; not native x86 execution")
+}
diff --git a/x86_bls_rules_test.go b/x86_bls_rules_test.go
new file mode 100644
index 000000000..5b2f340e7
--- /dev/null
+++ b/x86_bls_rules_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BLSCompleteIndependentGoRowsAndPhysicalMode(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := strings.Join(strings.Fields(string(data)), "")
+	if !strings.Contains(compact, "var_yblsil=[]ytab{{zcase:Zvex_rm_r_vo,zoffset:3,args:argList{Yml,Yrl}},}") {
+		t.Fatal("complete Go BLS encoder operand row changed")
+	}
+	families := []struct {
+		name  string
+		digit byte
+		kind  x86BLSKind
+	}{{"BLSI", 3, x86BLSIsolate}, {"BLSMSK", 2, x86BLSMask}, {"BLSR", 1, x86BLSReset}}
+	if len(x86BLSSpecs) != 6 {
+		t.Fatal("BLS spec differs from the complete six-member Go family")
+	}
+	for _, family := range families {
+		for _, width := range []struct {
+			suffix string
+			w      int
+			bits   int
+		}{{"L", 0, 32}, {"Q", 1, 64}} {
+			op := family.name + width.suffix
+			row := fmt.Sprintf("{as:A%s,ytab:_yblsil,prefix:Pavx,op:opBytes{avxEscape|vex128|vex0F38|vexW%d,0xF3,0%d,}},", op, width.w, family.digit)
+			if !strings.Contains(compact, row) {
+				t.Fatal("complete BLS opcode attribute binding changed", row)
+			}
+			if x86BLSSpecs[Op(op)] != (x86BLSSpec{width.bits, family.kind, family.digit}) {
+				t.Fatal("typed BLS attributes disagree with independent Go encoder", op)
+			}
+			for _, arch := range []string{"386", "amd64"} {
+				code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+op+" AX,BX\nRET\n")
+				want := []byte{0xc4, 0xe2, byte(0x60 | width.w<<7), 0xf3, byte(0xc0 | family.digit<<3), 0xc3}
+				if !bytes.Equal(code, want) {
+					t.Fatalf("%s/%s Go bytes %x, want %x", arch, op, code, want)
+				}
+				ins := x86ScalarLaneInstruction(t, op+" (AX),BX")
+				physicalWidth := int64(4)
+				if arch == "amd64" {
+					physicalWidth = int64(width.bits / 8)
+				}
+				for index := range ins.Args {
+					got, write, valid := x86InstructionMemoryShape(ins, index, arch)
+					if valid != (index == 0) || valid && (got != physicalWidth || write) {
+						t.Fatal("BLS source tuple differs from physical mode", arch, op, index, got, write, valid)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BLSResultByteHolesAliasesAndFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BLSTestNames {
+			width := int64(4)
+			if arch == "amd64" && strings.HasSuffix(op, "Q") {
+				width = 8
+			}
+			for _, output := range []string{"AX", "BX", "CX", "SP", "BP"} {
+				ins := x86ScalarLaneInstruction(t, op+" AX,"+output)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					for missing := -1; missing < int(width); missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.gp[0] = uint8((uint16(1) << uint(width)) - 1)
+						if missing >= 0 {
+							state.gp[0] &^= 1 << uint(missing)
+						}
+						before := state.clone()
+						accept := missing == -1 && output != "SP" && (arch == "386" || output != "BP")
+						if got := consumer.step(ins, &state, nil, 0, arch); got != accept {
+							t.Fatal("BLS missing input or destination boundary changed", arch, op, output, consumer.name, missing, got)
+						}
+						want := before.clone()
+						if accept {
+							index, _, _ := x86ResultGP(Reg(output), width, arch)
+							want.gp[index] = 0xff
+							want.flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+						}
+						if !reflect.DeepEqual(state, want) {
+							t.Fatal("BLS changed unrelated state or partially applied failed inputs", arch, op, output, missing)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BLSGrammarRejectsDispatchAndSourceMutation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BLSTestNames {
+			for _, row := range []string{op + ".Z AX,BX", op + " $1,BX", op + " AL,BX", op + " X0,BX", op + " AX,(BX)"} {
+				ins := x86ScalarLaneInstruction(t, row)
+				before := ins
+				before.Args = append([]Operand(nil), ins.Args...)
+				if _, known, err := x86BLSProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Fatal("BLS invalid grammar accepted", arch, row, known, err)
+				}
+				if !reflect.DeepEqual(ins, before) {
+					t.Fatal("BLS grammar mutated original source", row)
+				}
+			}
+			if _, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+op+" (AX)(CX*3),BX\nRET\n"); err == nil {
+				t.Fatal("invalid BLS scale escaped the source parser", arch, op)
+			}
+			memory := x86ScalarLaneInstruction(t, op+" (AX)(CX*2),BX")
+			memory.Args[0].Mem.Scale = 3
+			if _, known, err := x86BLSProperties(memory.Op, memory, arch); !known || err == nil {
+				t.Fatal("invalid BLS scale escaped direct typed validation", arch, op)
+			}
+			ins := x86ScalarLaneInstruction(t, op+" AX,BX")
+			ins.Op = "MOVL"
+			if _, known, err := x86BLSProperties(Op(op), ins, arch); !known || err == nil {
+				t.Fatal("BLS dispatch borrowed another instruction's source", arch, op)
+			}
+		}
+	}
+}
diff --git a/x86_bls_runtime_test.go b/x86_bls_runtime_test.go
new file mode 100644
index 000000000..54a3f1ac0
--- /dev/null
+++ b/x86_bls_runtime_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BLSPortableCompleteFamilyAliasesFlagsAndDeadReads(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows, faults strings.Builder
+	for kind, family := range []string{"BLSI", "BLSMSK", "BLSR"} {
+		for _, bits := range []int{32, 64} {
+			suffix := "L"
+			if bits == 64 {
+				suffix = "Q"
+			}
+			op := family + suffix
+			for ordinal, input := range []string{"AX", "BX", "(AX)"} {
+				name := fmt.Sprintf("%sCase%d", op, ordinal)
+				typ, cType, argument := "uint64", "uint64_t", "value"
+				if ordinal == 2 {
+					typ, cType, argument = "*uint64", "const uint64_t*", "&value"
+				}
+				fmt.Fprintf(&declarations, "func %s(source %s, out *[16]byte)\n", name, typ)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ source+0(FP),AX\nMOVQ AX,BX\nMOVQ out+8(FP),DI\n", name)
+				// Preset every defined status bit oppositely where possible.
+				source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n")
+				fmt.Fprintf(&source, "%s %s,AX\nMOVQ AX,0(DI)\nSETCS 8(DI)\nSETOS 9(DI)\nSETEQ 10(DI)\nSETMI 11(DI)\nRET\n", op, input)
+				fmt.Fprintf(&prototypes, "extern void %s(%s,uint8_t*);\nstatic void call%s(uint64_t value,uint8_t *out) { %s(%s,out); }\n", name, cType, name, name, argument)
+				fmt.Fprintf(&rows, "{call%s,%d,%d},\n", name, bits, kind)
+			}
+			name := "Dead" + op
+			fmt.Fprintf(&declarations, "func %s(source *byte)\n", name)
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ source+0(FP),AX\n%s (AX),BX\nRET\n", name, op)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*);\nstatic int fault%s(const uint8_t *p) { %s(p); return 0; }\n", name, name, name)
+			fmt.Fprintf(&faults, "{fault%s,%d,%d},\n", name, bits/8, bits/8-1)
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	valueDriver := strings.ReplaceAll(x86BLSPortableValueDriver, "PROTOTYPES", prototypes.String())
+	valueDriver = strings.ReplaceAll(valueDriver, "ROWS", rows.String())
+	faultDriver := x86MemoryFaultDriver(prototypes.String(), faults.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimize := range []bool{false, true} {
+				text := ir
+				if optimize {
+					text = x86MulDivRoundOptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimize, level), func(t *testing.T) {
+						execution.compileAndRunLLVM(t, "bls-values", text, valueDriver, level)
+						executable := execution.compileLLVM(t, "bls-dead-reads", text, faultDriver, level)
+						x86CheckMemoryFaultMatrix(t, execution, executable, 6)
+					})
+				}
+			}
+		})
+	}
+	t.Log("six BLS names, independent values, aliases, defined flags, canaries and dead read faults; actual-host portable LLVM execution")
+}
+
+const x86BLSPortableValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+struct kernel {
+    void (*run)(uint64_t,uint8_t*);
+    unsigned bits, kind;
+};
+static const struct kernel kernels[] = { ROWS };
+
+static uint64_t independent_bls(uint64_t source,unsigned bits,unsigned kind) {
+    const uint64_t mask=bits==32 ? UINT64_C(0xffffffff) : UINT64_MAX;
+    source&=mask;
+    unsigned first=0;
+    while (first<bits && !(source&(UINT64_C(1)<<first))) ++first;
+    uint64_t result=0;
+    for (unsigned bit=0;bit<bits;++bit) {
+        const unsigned set=kind==0 ? bit==first :
+            kind==1 ? bit<=first : bit!=first && ((source>>bit)&1);
+        if (set) result|=UINT64_C(1)<<bit;
+    }
+    return result;
+}
+
+int main(void) {
+    static const uint64_t edges[]={0,1,2,10,UINT64_MAX,
+        UINT64_C(0x80000000),UINT64_C(0x8000000000000000)};
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        uint64_t random=UINT64_C(0xa31d5f0986b7c4e2);
+        for (unsigned sample=0;sample<1031;++sample) {
+            random=random*UINT64_C(6364136223846793005)+1;
+            const uint64_t input=sample<7 ? edges[sample] : random;
+            const uint64_t source=kernels[k].bits==32 ? (uint32_t)input : input;
+            const uint64_t value=independent_bls(source,kernels[k].bits,kernels[k].kind);
+            uint8_t out[32],expected[32];
+            memset(out,0xa5,sizeof(out));
+            memcpy(expected,out,sizeof(out));
+            memcpy(expected+8,&value,8);
+            expected[16]=kernels[k].kind==0 ? source!=0 : source==0;
+            expected[17]=0;
+            expected[18]=value==0;
+            expected[19]=(value>>(kernels[k].bits-1))&1;
+            kernels[k].run(input,out+8);
+            if (memcmp(out,expected,sizeof(out))) {
+                fprintf(stderr,"BLS kernel=%u sample=%u\n",k,sample);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_bmi2_original_portable_test.go b/x86_bmi2_original_portable_test.go
new file mode 100644
index 000000000..31d2d328e
--- /dev/null
+++ b/x86_bmi2_original_portable_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BMI2VariableShiftRepairedOriginalPortableValuesAndFlags(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	driver := x86X87FunctionLiteral(t, "amd64_lower_bmi2_shift_test.go",
+		"TestAMD64BMI2VariableShiftRuntimeSemantics", "mainC")
+	for _, raw := range []bool{false, true} {
+		source := x86BMI2VariableShiftRepairedRuntimeSource(t)
+		if raw {
+			lines := strings.Split(source, "\n")
+			count := 0
+			for index, line := range lines {
+				line = strings.TrimSpace(line)
+				if strings.HasPrefix(line, "SHLX") || strings.HasPrefix(line, "SHRX") || strings.HasPrefix(line, "SARX") {
+					lines[index] = x86RawNumericalInstruction(t, "amd64", line)
+					count++
+				}
+			}
+			if count != 5 {
+				t.Fatal("original BMI2 numerical source directory changed", count)
+			}
+			source = strings.Join(lines, "\n")
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("raw=%t/%s", raw, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func bmi2shiftsemantics(out *[48]byte)", "amd64", triple, api)
+				if err != nil {
+					t.Fatal("Go-valid original BMI2 fixture rejected", err)
+				}
+				for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						compileAndRunRuntimeTestForTarget(t, llc, clang,
+							fmt.Sprintf("bmi2-original-%t-%s-%d-%s", raw, api, index, level[1:]), triple, text, driver, nil)
+					}
+				}
+			})
+		}
+	}
+	t.Log("original portable numerical and FLAGS oracle, not original native BMI opcode execution")
+}
diff --git a/x86_bmi2_original_source_test.go b/x86_bmi2_original_source_test.go
new file mode 100644
index 000000000..a53b751e2
--- /dev/null
+++ b/x86_bmi2_original_source_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86BMI2VariableShiftOriginalImmediateIsGoRejected(t *testing.T) {
+	source := x86X87FunctionLiteral(t, "amd64_lower_bmi2_shift_test.go",
+		"TestAMD64BMI2VariableShiftRuntimeSemantics", "source")
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+source, "", false)
+}
+
+func x86BMI2VariableShiftRepairedRuntimeSource(t *testing.T) string {
+	t.Helper()
+	source := x86X87FunctionLiteral(t, "amd64_lower_bmi2_shift_test.go",
+		"TestAMD64BMI2VariableShiftRuntimeSemantics", "source")
+	const invalid = "MOVQ $-81985529216486896, 8(DI)"
+	if strings.Count(source, invalid) != 1 {
+		t.Fatal("original BMI2 fixture lost its identified invalid imm64 store")
+	}
+	return strings.Replace(source, invalid, "MOVQ $-81985529216486896, R9\n\tMOVQ R9, 8(DI)", 1)
+}
+
+func TestX86BMI2VariableShiftRepairedOriginalSourceObjects(t *testing.T) {
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86RawNumericalFamilyObjects(t, x86BMI2VariableShiftRepairedRuntimeSource(t),
+				"func bmi2shiftsemantics(out *[48]byte)", "amd64", triple)
+		})
+	}
+}
diff --git a/x86_bool_tail_routing_test.go b/x86_bool_tail_routing_test.go
new file mode 100644
index 000000000..752cd13be
--- /dev/null
+++ b/x86_bool_tail_routing_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86BoolTailRoutingProgram() (string, string) {
+	var source, declarations strings.Builder
+	for _, condition := range amd64RegisterBoolConditions {
+		name := "Tail" + condition
+		fmt.Fprintf(&source, "TEXT ·%s<ABIInternal>(SB),4,$0-17\nCMPQ AX,BX\nJMP body%s<>(SB)\n"+
+			"TEXT body%s<>(SB),4,$0-0\n%s AL\nMOVBLZX AL,AX\nRET\n", name, name, name, condition)
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) bool\n", name)
+	}
+	return source.String(), declarations.String()
+}
+
+// Explicit standalone encoder permission is not an authenticated Go runtime
+// entry. Retain all original roots/helpers and their relocations as one object.
+func x86BoolTailRoutingGoObject(t *testing.T, source string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "tails.s"), filepath.Join(dir, "tails.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	args := append(arm64ClosureGoAsmArgs(t), "-S", "-o", output, input)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", args...)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "GOTOOLCHAIN=local", "GOFLAGS=")
+	listing, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, output, listing, err, ctx.Err(), true, "amd64"); failure != nil {
+		t.Fatalf("complete original bool-tail Go object: %v\n%s", failure, listing)
+	}
+	if strings.Count(string(listing), " STEXT ") != 32 {
+		t.Fatal("original sixteen roots/helpers were not all assembled")
+	}
+}
+
+func TestX86BoolTailRoutingCompleteConditionsThreeTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source, declarations := x86BoolTailRoutingProgram()
+	x86BoolTailRoutingGoObject(t, source)
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil || strings.Count(ir, "define i1 @Tail") != 16 {
+					t.Fatal("AMD64 canonical tail entered a foreign custom-register proof", err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CustomHelperBoolTailRejectsForeignArchitecture(t *testing.T) {
+	for _, arch := range []string{"", "amd64", "arm64"} {
+		t.Run("mode="+arch, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			options.Goarch = arch
+			source := &x86ABI0BoolCallSource{origin: file, original: x86DirectTailSnapshot(file), options: options}
+			plan := &x86ABI0BoolCallPlan{source: source, function: file.Funcs[0], signature: options.Sigs["compare"]}
+			err := source.prepareCustomRegisterTail(plan)
+			if !errors.Is(err, ErrProbeNeedsContext) || source.customGraph != nil || plan.registerTail != nil {
+				t.Fatal("foreign mode constructed a private 386 graph", err)
+			}
+		})
+	}
+}
+
+func TestX86BoolTailRoutingDefaultModeAndSelectionRechecks(t *testing.T) {
+	for _, arch := range []string{"", "amd64"} {
+		for _, mutation := range []string{"none", "resolver", "source", "declaration"} {
+			t.Run("mode="+arch+"/"+mutation, func(t *testing.T) {
+				assembly, declarations := x86BoolTailRoutingProgram()
+				file, err := Parse(ArchAMD64, assembly)
+				if err != nil {
+					t.Fatal(err)
+				}
+				pkg := mustGoPackage(t, "bitview", "package bitview\n"+declarations)
+				resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				calls := 0
+				options := Options{Goarch: arch, TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs}
+				options.ResolveSym = func(symbol string) string {
+					calls++
+					if calls == 1 {
+						switch mutation {
+						case "resolver":
+							return "foreign"
+						case "source":
+							file.Funcs[0].Instrs[1].Raw += " // changed during selection"
+						case "declaration":
+							sig := sigs[resolve(symbol)]
+							sig.Ret = I32
+							sigs[resolve(symbol)] = sig
+						}
+					}
+					return resolve(symbol)
+				}
+				plan, err := prepareX86ABI0BoolCalls(file, options)
+				if calls == 0 || plan != nil || mutation == "none" && err != nil ||
+					mutation != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("mode routing bypassed complete source/declaration observation", calls, plan != nil, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86BoolTailRoutingPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	source, declarations := x86BoolTailRoutingProgram()
+	var wrappers, prototypes, checks strings.Builder
+	for index, condition := range amd64RegisterBoolConditions {
+		fmt.Fprintf(&wrappers, "define i32 @Probe%d(i64 %%a,i64 %%b) {\n"+
+			"  %%v = call i1 @Tail%s(i64 %%a,i64 %%b)\n  %%r = zext i1 %%v to i32\n  ret i32 %%r\n}\n", index, condition)
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(uint64_t,uint64_t);\n", index)
+		fmt.Fprintf(&checks, "        if (Probe%d(a,b) != want[%d]) {\n"+
+			"            fprintf(stderr, \"tail condition %s a=%%llx b=%%llx\\n\",\n"+
+			"                (unsigned long long)a, (unsigned long long)b);\n            return 1;\n        }\n", index, index, condition)
+	}
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+int main(void) {
+    const uint64_t values[] = {0, 1, 2, 3, UINT64_C(0x8000000000000000),
+        UINT64_C(0x7fffffffffffffff), UINT64_MAX};
+    unsigned seen[16] = {0};
+    for (unsigned i = 0; i < 7; i++) for (unsigned j = 0; j < 7; j++) {
+        uint64_t a = values[i], b = values[j], r = a - b;
+        unsigned cf = a < b, zf = r == 0, sf = r >> 63;
+        unsigned of = ((a ^ b) & (a ^ r)) >> 63;
+        uint8_t parity = r;
+        parity ^= parity >> 4;
+        parity ^= parity >> 2;
+        parity ^= parity >> 1;
+        unsigned pf = (parity & 1) == 0;
+        unsigned want[] = {!cf, cf, zf, sf == of, !zf && sf == of, !cf && !zf,
+            zf || sf != of, cf || zf, sf != of, sf, !zf, !of, of, !pf, !sf, pf};
+        for (unsigned k = 0; k < 16; k++) seen[k] |= 1U << want[k];
+` + checks.String() + `
+    }
+    for (unsigned k = 0; k < 16; k++) if (seen[k] != 3) return 2;
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			input := ir + wrappers.String()
+			for _, text := range []string{input, x86DwordProductIROptimize(t, input)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "bool-tail-routing", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_branch_alias_input_contract_test.go b/x86_branch_alias_input_contract_test.go
new file mode 100644
index 000000000..0dcab9307
--- /dev/null
+++ b/x86_branch_alias_input_contract_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86ConditionalBranchAliasOracle() map[string]string {
+	groups := map[string][]string{
+		"JCC": {"JAE", "JCC", "JHS", "JNB", "JNC"},
+		"JCS": {"JB", "JC", "JCS", "JLO", "JNAE"},
+		"JEQ": {"JE", "JEQ", "JZ"},
+		"JGE": {"JGE", "JNL"},
+		"JGT": {"JG", "JGT", "JNLE"},
+		"JHI": {"JA", "JHI", "JNBE"},
+		"JLE": {"JLE", "JNG"},
+		"JLS": {"JBE", "JLS", "JNA"},
+		"JLT": {"JL", "JLT", "JNGE"},
+		"JMI": {"JMI", "JS"},
+		"JNE": {"JNE", "JNZ"},
+		"JOC": {"JNO", "JOC"},
+		"JOS": {"JO", "JOS"},
+		"JPC": {"JNP", "JPC", "JPO"},
+		"JPL": {"JNS", "JPL"},
+		"JPS": {"JP", "JPE", "JPS"},
+	}
+	aliases := make(map[string]string)
+	for canonical, names := range groups {
+		for _, name := range names {
+			aliases[name] = canonical
+		}
+	}
+	return aliases
+}
+
+func x86ConditionalBranchAliasOriginalSource() string {
+	aliases := x86ConditionalBranchAliasOracle()
+	names := make([]string, 0, len(aliases))
+	for name := range aliases {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+
+	var source strings.Builder
+	source.WriteString("TEXT conditionalbranchaliases(SB),NOSPLIT,$0-0\n")
+	source.WriteString("\tUCOMISD X0, X1\n")
+	for index, name := range names {
+		for hint := -1; hint <= 1; hint++ {
+			label := fmt.Sprintf("branch_alias_%d_%d", index, hint+1)
+			if hint < 0 {
+				fmt.Fprintf(&source, "\t%s %s\n", name, label)
+			} else {
+				fmt.Fprintf(&source, "\t%s $%d, %s\n", name, hint, label)
+			}
+			fmt.Fprintf(&source, "%s:\n", label)
+		}
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func TestX86ConditionalBranchAliasIndependentCompleteGoInventory(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	grammar := "var yjcond = []ytab{\n\t{Zbr, 0, argList{Ybr}},\n\t{Zbr, 0, argList{Yi0, Ybr}},\n\t{Zbr, 1, argList{Yi1, Ybr}},\n}"
+	if !strings.Contains(string(data), grammar) {
+		t.Fatal("complete Go conditional branch target/hint grammar changed")
+	}
+	wantEncoders := map[string]string{
+		"JCC": "0x73,0x83,00",
+		"JCS": "0x72,0x82",
+		"JEQ": "0x74,0x84",
+		"JGE": "0x7d,0x8d",
+		"JGT": "0x7f,0x8f",
+		"JHI": "0x77,0x87",
+		"JLE": "0x7e,0x8e",
+		"JLS": "0x76,0x86",
+		"JLT": "0x7c,0x8c",
+		"JMI": "0x78,0x88",
+		"JNE": "0x75,0x85",
+		"JOC": "0x71,0x81,00",
+		"JOS": "0x70,0x80,00",
+		"JPC": "0x7b,0x8b",
+		"JPL": "0x79,0x89",
+		"JPS": "0x7a,0x8a",
+	}
+	rows := regexp.MustCompile(`\{A(J[A-Z]+),\s*yjcond,\s*([A-Za-z0-9_]+),\s*opBytes\{([^}]*)\}\}`).FindAllStringSubmatch(string(data), -1)
+	encoders := make(map[string]string)
+	aliases := make(map[string]string)
+	for _, row := range rows {
+		if row[2] != "Px" {
+			t.Fatal("conditional branch encoder prefix changed", row)
+		}
+		encoders[row[1]] = strings.Join(strings.Fields(row[3]), "")
+		aliases[row[1]] = row[1]
+	}
+	if len(rows) != 16 || !reflect.DeepEqual(encoders, wantEncoders) {
+		t.Fatal("complete sixteen-row conditional branch encoder directory changed", encoders)
+	}
+
+	frontend, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	registrations := regexp.MustCompile(`instructions\["(J[A-Z]+)"\]\s*=\s*x86\.A(J[A-Z]+)`).FindAllStringSubmatch(string(frontend), -1)
+	for _, registration := range registrations {
+		if _, conditional := encoders[registration[2]]; conditional {
+			aliases[registration[1]] = registration[2]
+		}
+	}
+	if len(aliases) != 45 || !reflect.DeepEqual(aliases, x86ConditionalBranchAliasOracle()) {
+		t.Fatal("complete original Go conditional branch aliases changed", aliases)
+	}
+
+	file, err := Parse(ArchAMD64, x86ConditionalBranchAliasOriginalSource())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := make(map[string][3]int)
+	for _, instruction := range file.Funcs[0].Instrs {
+		if _, conditional := aliases[string(instruction.Op)]; !conditional {
+			continue
+		}
+		form := 0
+		if len(instruction.Args) == 2 {
+			hint := instruction.Args[0]
+			if hint.Kind != OpImm || hint.ImmIsFloat || hint.ImmRaw != "" || hint.Imm < 0 || hint.Imm > 1 {
+				t.Fatal("branch fixture contains a non-Go hint", instruction.Raw)
+			}
+			form = int(hint.Imm) + 1
+		} else if len(instruction.Args) != 1 {
+			t.Fatal("branch fixture lost its target operand", instruction.Raw)
+		}
+		count := counts[string(instruction.Op)]
+		count[form]++
+		counts[string(instruction.Op)] = count
+	}
+	if len(counts) != 45 {
+		t.Fatal("complete branch fixture lost an alias", counts)
+	}
+	for alias, count := range counts {
+		if count != [3]int{1, 1, 1} {
+			t.Fatal("branch fixture must retain every alias/hint exactly once", alias, count)
+		}
+	}
+}
+
+// This private format object emits the unchanged original CFG without claiming
+// initialized entry inputs. Its public APIs must independently retain Context.
+func x86ConditionalBranchAliasOriginalFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	if source != x86ConditionalBranchAliasOriginalSource() {
+		t.Fatal("original conditional branch source or complete 135-row inventory changed")
+	}
+	file, signatures := x86UnboundVoidFormatSource(t, source, "conditionalbranchaliases", arch, triple)
+	function := file.Funcs[0]
+	signature := signatures["conditionalbranchaliases"]
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\n", triple)
+	emitAMD64Prelude(&ir, arch, file)
+	attributes := newFeatureAttrRegistry()
+	features := attributes.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, arch, function))
+	fmt.Fprintf(&ir, "define void @ConditionalBranchAliasFormats() %s {\n", features)
+	consumer := newX86Ctx(&ir, function, signature, func(name string) string { return name }, signatures, arch, triple, false)
+	if err := consumer.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.lowerBlocks(); err != nil {
+		t.Fatal("original named branch CFG format was not emitted", err)
+	}
+	ir.WriteString("}\n")
+	attributes.emit(&ir)
+	if strings.Count(ir.String(), "  br i1 ") != 135 || strings.Count(ir.String(), `asm sideeffect "ucomisd `) != 1 {
+		t.Fatal("original private format object lost a branch or its native FLAGS producer")
+	}
+	return ir.String()
+}
+
+func TestX86ConditionalBranchAliasOriginalAndInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	original := x86ConditionalBranchAliasOriginalSource()
+	initialized := strings.Replace(original, "\tUCOMISD X0, X1\n", "\tPXOR X0, X0\n\tPXOR X1, X1\n\tUCOMISD X0, X1\n", 1)
+	declaration := "func conditionalbranchaliases()\n"
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			ir := x86ConditionalBranchAliasOriginalFormatObject(t, original, target.arch, target.triple)
+			compileLLVMToObject(t, llc, target.triple, "original-branch-alias-formats.ll", "original-branch-alias-formats.o", ir)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+initialized)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, initialized, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized branch source rejected", err)
+					}
+					if strings.Count(ir, "  br i1 ") != 135 || strings.Count(ir, `asm sideeffect "ucomisd `) != 1 {
+						t.Fatal("initialized public object lost an original branch or native FLAGS producer")
+					}
+					compileLLVMToObject(t, llc, target.triple, "initialized-branch-aliases.ll", "initialized-branch-aliases.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86ConditionalBranchAliasFullSourceDoesNotInventCOMIInputs(t *testing.T) {
+	original := x86ConditionalBranchAliasOriginalSource()
+	for _, target := range x86RawReturnTargets {
+		for _, input := range []struct {
+			name, setup string
+		}{
+			{"neither", ""},
+			{"only-X0", "\tPXOR X0, X0\n"},
+			{"only-X1", "\tPXOR X1, X1\n"},
+		} {
+			source := strings.Replace(original, "\tUCOMISD X0, X1\n", input.setup+"\tUCOMISD X0, X1\n", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+input.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func conditionalbranchaliases()\n", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("complete branch source invented a missing COMI scalar input", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_branch_hint_result_test.go b/x86_branch_hint_result_test.go
new file mode 100644
index 000000000..32ea9fd9e
--- /dev/null
+++ b/x86_branch_hint_result_test.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BranchHintCompletePredicateResultObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word := goWordSize(target.arch)
+			var source, declarations strings.Builder
+			count := 0
+			for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+				for hint := 0; hint <= 1; hint++ {
+					name := fmt.Sprintf("Hint%s%d", condition, hint)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOVL a+0(FP),AX\nCMPL AX,AX\n"+
+						"J%s $%d,taken\nMOVL $11,BX\nJMP done\ntaken:\nMOVL $19,BX\ndone:\nMOVL BX,ret+%d(FP)\nRET\n",
+						name, word+4, condition, hint, word)
+					fmt.Fprintf(&declarations, "func %s(a uint32) uint32\n", name)
+					count++
+				}
+			}
+			if count != 32 {
+				t.Fatal("complete conditional hint/FLAGS inventory changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
diff --git a/x86_broadcast_effect_test.go b/x86_broadcast_effect_test.go
new file mode 100644
index 000000000..c75da3e4a
--- /dev/null
+++ b/x86_broadcast_effect_test.go
@@ -0,0 +1,571 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// This directory is independent of the production broadcast grammar.
+var x86BroadcastTestDirectory = []struct {
+	name, table  string
+	bytes, lane  int
+	destinations string
+	source       string
+}{
+	{"VPBROADCASTB", "_yvpbroadcastb", 1, 1, "XYZ", "XG"},
+	{"VPBROADCASTW", "_yvpbroadcastb", 2, 2, "XYZ", "XG"},
+	{"VPBROADCASTD", "_yvpbroadcastb", 4, 4, "XYZ", "XG"},
+	{"VPBROADCASTQ", "_yvpbroadcastb", 8, 8, "XYZ", "XG"},
+	{"VBROADCASTSS", "_yvbroadcastss", 4, 4, "XYZ", "X"},
+	{"VBROADCASTSD", "_yvbroadcastsd", 8, 8, "YZ", "X"},
+	{"VBROADCASTF128", "_yvbroadcastf128", 16, 8, "Y", ""},
+	{"VBROADCASTI128", "_yvbroadcastf128", 16, 8, "Y", ""},
+	{"VBROADCASTF32X2", "_yvbroadcastf32x2", 8, 4, "YZ", "X"},
+	{"VBROADCASTI32X2", "_yvbroadcasti32x2", 8, 4, "XYZ", "X"},
+	{"VBROADCASTF32X4", "_yvbroadcastf32x4", 16, 4, "YZ", ""},
+	{"VBROADCASTF64X2", "_yvbroadcastf32x4", 16, 8, "YZ", ""},
+	{"VBROADCASTI32X4", "_yvbroadcastf32x4", 16, 4, "YZ", ""},
+	{"VBROADCASTI64X2", "_yvbroadcastf32x4", 16, 8, "YZ", ""},
+	{"VBROADCASTF32X8", "_yvbroadcastf32x8", 32, 4, "Z", ""},
+	{"VBROADCASTF64X4", "_yvbroadcastf32x8", 32, 8, "Z", ""},
+	{"VBROADCASTI32X8", "_yvbroadcastf32x8", 32, 4, "Z", ""},
+	{"VBROADCASTI64X4", "_yvbroadcastf32x8", 32, 8, "Z", ""},
+	{"VPBROADCASTMB2Q", "_yvpbroadcastmb2q", 1, 8, "XYZ", "K"},
+	{"VPBROADCASTMW2D", "_yvpbroadcastmb2q", 2, 4, "XYZ", "K"},
+}
+
+func TestX86BroadcastCompleteIndependentGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := func(s string) string { return strings.Join(strings.Fields(s), "") }
+	text := compact(string(data))
+	var actualNames, expectedNames []string
+	for _, match := range regexp.MustCompile("as: A(VP?BROADCAST[A-Z0-9]+)").FindAllStringSubmatch(string(data), -1) {
+		actualNames = append(actualNames, match[1])
+	}
+	for _, spec := range x86BroadcastTestDirectory {
+		expectedNames = append(expectedNames, spec.name)
+	}
+	sort.Strings(actualNames)
+	sort.Strings(expectedNames)
+	if !reflect.DeepEqual(actualNames, expectedNames) {
+		t.Fatalf("whole Go broadcast directory changed: %v", actualNames)
+	}
+	rows := func(z, classes string, advance int) string {
+		return fmt.Sprintf("{zcase:%s,zoffset:%d,args:argList{%s}},", z, advance, classes)
+	}
+	want := map[string]string{}
+	want["_yvbroadcastf128"] = rows("Zvex_rm_v_r", "Ym,Yyr", 2)
+	for _, table := range []string{"_yvbroadcastf32x2", "_yvbroadcastf32x4", "_yvbroadcastf32x8", "_yvbroadcasti32x2", "_yvbroadcastsd", "_yvbroadcastss", "_yvpbroadcastb", "_yvpbroadcastmb2q"} {
+		widths, source := []string{"YyrEvex", "Yzr"}, "Ym"
+		switch table {
+		case "_yvbroadcastf32x2", "_yvbroadcastsd":
+			source = "YxmEvex"
+		case "_yvbroadcasti32x2", "_yvbroadcastss":
+			widths, source = []string{"YxrEvex", "YyrEvex", "Yzr"}, "YxmEvex"
+		case "_yvbroadcastf32x8":
+			widths = []string{"Yzr"}
+		case "_yvpbroadcastb":
+			widths, source = []string{"YxrEvex", "YyrEvex", "Yzr"}, "Yrl"
+		case "_yvpbroadcastmb2q":
+			widths, source = []string{"YxrEvex", "YyrEvex", "Yzr"}, "Yk"
+		}
+		if table == "_yvbroadcastsd" {
+			want[table] += rows("Zvex_rm_v_r", "Yxm,Yyr", 2)
+		}
+		if table == "_yvbroadcastss" || table == "_yvpbroadcastb" {
+			for _, dst := range []string{"Yxr", "Yyr"} {
+				want[table] += rows("Zvex_rm_v_r", "Yxm,"+dst, 2)
+			}
+		}
+		for pass := 0; pass < 2; pass++ {
+			for _, dst := range widths {
+				if table == "_yvpbroadcastmb2q" {
+					want[table] += rows("Zevex_rm_v_r", source+","+dst, 3)
+				} else {
+					want[table] += rows("Zevex_rm_v_r", source+","+dst, 0)
+					want[table] += rows("Zevex_rm_k_r", source+",Yknot0,"+dst, 3)
+				}
+			}
+			if table != "_yvpbroadcastb" {
+				break
+			}
+			source = "YxmEvex"
+		}
+	}
+	for table, expected := range want {
+		found := regexp.MustCompile("(?s)var " + table + " = \\[\\]ytab\\{(.*?)\\n\\}").FindStringSubmatch(string(data))
+		if len(found) != 2 || compact(found[1]) != expected {
+			t.Fatalf("complete %s zcase/offset/classes changed", table)
+		}
+	}
+	vex := func(width int, opcode string) string {
+		return fmt.Sprintf("avxEscape|vex%d|vex66|vex0F38|vexW0,%s,", width, opcode)
+	}
+	evex := func(width int, w, tuple, prefix, opcode string) string {
+		return fmt.Sprintf("avxEscape|evex%d|%s|evex0F38|evex%s,%s,%s,", width, prefix, w, tuple, opcode)
+	}
+	total := 0
+	for _, spec := range x86BroadcastTestDirectory {
+		var code strings.Builder
+		name := spec.name
+		switch {
+		case strings.HasPrefix(name, "VPBROADCAST") && spec.source == "XG":
+			opcode := map[string]string{"VPBROADCASTB": "0x78", "VPBROADCASTW": "0x79", "VPBROADCASTD": "0x58", "VPBROADCASTQ": "0x59"}[name]
+			gp := map[string]string{"VPBROADCASTB": "0x7A", "VPBROADCASTW": "0x7B", "VPBROADCASTD": "0x7C", "VPBROADCASTQ": "0x7C"}[name]
+			w := "W0"
+			if spec.bytes == 8 {
+				w = "W1"
+			}
+			code.WriteString(vex(128, opcode) + vex(256, opcode))
+			for _, width := range []int{128, 256, 512} {
+				code.WriteString(evex(width, w, "evexZeroingEnabled", "evex66", gp))
+			}
+			for _, width := range []int{128, 256, 512} {
+				code.WriteString(evex(width, w, fmt.Sprintf("evexN%d|evexZeroingEnabled", spec.bytes), "evex66", opcode))
+			}
+		case name == "VBROADCASTSS" || name == "VBROADCASTSD":
+			opcode, w := "0x18", "W0"
+			if name == "VBROADCASTSD" {
+				opcode, w = "0x19", "W1"
+			} else {
+				code.WriteString(vex(128, opcode))
+			}
+			code.WriteString(vex(256, opcode))
+			for _, bank := range spec.destinations {
+				code.WriteString(evex(map[rune]int{'X': 128, 'Y': 256, 'Z': 512}[bank], w, fmt.Sprintf("evexN%d|evexZeroingEnabled", spec.bytes), "evex66", opcode))
+			}
+		case spec.source == "K":
+			w, opcode := "W0", "0x3A"
+			if spec.bytes == 1 {
+				w, opcode = "W1", "0x2A"
+			}
+			for _, width := range []int{128, 256, 512} {
+				code.WriteString(evex(width, w, "0", "evexF3", opcode))
+			}
+		case strings.HasSuffix(name, "128"):
+			opcode := "0x1A"
+			if strings.Contains(name, "I") {
+				opcode = "0x5A"
+			}
+			code.WriteString(vex(256, opcode))
+		default:
+			w, opcode := "W0", "0x1A"
+			if strings.Contains(name, "64") {
+				w = "W1"
+			}
+			if strings.HasSuffix(name, "X2") && strings.Contains(name, "32") {
+				opcode = "0x19"
+			}
+			if spec.bytes == 32 {
+				opcode = "0x1B"
+			}
+			if strings.Contains(name, "I") {
+				opcode = map[string]string{"0x19": "0x59", "0x1A": "0x5A", "0x1B": "0x5B"}[opcode]
+			}
+			for _, bank := range spec.destinations {
+				code.WriteString(evex(map[rune]int{'X': 128, 'Y': 256, 'Z': 512}[bank], w, fmt.Sprintf("evexN%d|evexZeroingEnabled", spec.bytes), "evex66", opcode))
+			}
+		}
+		expected := "{as:A" + name + ",ytab:" + spec.table + ",prefix:Pavx,op:opBytes{" + code.String() + "}}"
+		if !strings.Contains(text, expected) {
+			t.Fatalf("complete attributes/opcode row changed: %s", expected)
+		}
+		total += strings.Count(want[spec.table], "{zcase:")
+	}
+	if total != 111 {
+		t.Fatalf("independent row directory: %d", total)
+	}
+}
+
+func TestX86BroadcastBothResultObservers(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, spec := range x86BroadcastTestDirectory {
+			if spec.source != "X" && spec.source != "XG" {
+				continue
+			}
+			for _, bank := range spec.destinations {
+				for _, input := range spec.source {
+					for _, alias := range []bool{false, true} {
+						src, dst, sourceIndex := "X1", fmt.Sprintf("%c2", bank), 1
+						if alias {
+							src, sourceIndex = "X2", 2
+						}
+						if input == 'G' {
+							src, sourceIndex = "AX", 0
+						}
+						for _, masked := range []string{"", "K3,", "Z"} {
+							op, mask := spec.name, masked
+							if masked == "Z" {
+								op, mask = op+".Z", "K3,"
+							}
+							row := op + " " + src + "," + mask + dst
+							t.Run(arch+"/"+row+fmt.Sprint(alias), func(t *testing.T) {
+								ins := x86YMMReadSource(t, row)
+								width := spec.bytes
+								if arch == "386" && spec.name == "VPBROADCASTQ" && input == 'G' {
+									width = 4
+								}
+								for _, consumer := range x86ResultGPSIMDConsumers {
+									state := x86ResultState{flags: x86ByteFlagsAll}
+									state.gp[sourceIndex] = uint8((1 << uint(width)) - 1)
+									state.xmm[sourceIndex] = uint16((1 << uint(width)) - 1)
+									state.xmm[2] |= 0xffff
+									state.masks[3] = true
+									if !consumer.step(ins, &state, nil, 0, arch) || state.xmm[2] != 0xffff || state.flags != x86ByteFlagsAll {
+										t.Fatalf("%s did not close initialized register broadcast %+v", consumer.name, state)
+									}
+									for missing := 0; missing < width; missing++ {
+										state := x86ResultState{flags: x86ByteFlagsAll}
+										state.gp[sourceIndex] = uint8((1 << uint(width)) - 1)
+										state.xmm[sourceIndex] = uint16((1 << uint(width)) - 1)
+										state.masks[3] = true
+										if masked == "K3," {
+											state.xmm[2] |= 0xffff
+										}
+										if input == 'G' {
+											state.gp[sourceIndex] &^= 1 << uint(missing)
+										} else {
+											state.xmm[sourceIndex] &^= 1 << uint(missing)
+										}
+										before := state.clone()
+										if consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(before, state) {
+											t.Fatalf("%s manufactured missing source byte%d", consumer.name, missing)
+										}
+									}
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastDeadResultsRetainCompleteFamilyObligation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, spec := range x86BroadcastTestDirectory {
+			source := "(AX)"
+			if spec.source == "K" {
+				source = "K0"
+			} else if strings.Contains(spec.source, "X") {
+				source = "X1"
+			}
+			row := fmt.Sprintf("%s %s,%c2", spec.name, source, spec.destinations[0])
+			for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+				t.Run(arch+"/"+spec.name+"/"+declaration, func(t *testing.T) {
+					_, file, signature, source := x86ResultInitializationFixture(t, arch, declaration, row+"\nRET\n")
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if !x86TypedFPResultNeedsProof(file.Funcs[0], signature, arch) {
+						t.Fatal("dead broadcast bypassed its whole-source input obligation", row)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BroadcastOriginalFunctionResultClosure(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, typ, index := 8, "MOVQ", "uint64", 11
+		if arch == "386" {
+			word, move, typ, index = 4, "MOVL", "uint32", 3
+		}
+		for _, bad := range []bool{false, true} {
+			body := fmt.Sprintf("%s x+0(FP),AX\nPINSRD $0,AX,X%d\n", move, index)
+			if bad {
+				body = "NOP\n"
+			}
+			body += fmt.Sprintf("VPBROADCASTW X%d,X%d\nVPEXTRQ $0,X%d,BX\n%s BX,ret0+%d(FP)\nRET", index, index, index, move, word)
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x "+typ+") "+typ, body)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				err := check(file.Funcs[0], sig, arch)
+				if bad && !errors.Is(err, ErrProbeNeedsContext) || !bad && err != nil {
+					t.Fatalf("%s bad%t: %v", arch, bad, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastOriginalPhysicalWIGWitness(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\nVPBROADCASTQ AX,X2\nRET\n")
+		want := []byte{0x62, 0xf2, 0xfd, 0x08, 0x7c, 0xd0, 0xc3}
+		if !bytes.Equal(code, want) {
+			t.Fatalf("%s actual bytes%x want%x", arch, code, want)
+		}
+		state := x86ResultState{gp: [16]uint8{15}}
+		ins := x86YMMReadSource(t, "VPBROADCASTQ AX,X2")
+		for _, consumer := range x86ResultGPSIMDConsumers {
+			copy := state.clone()
+			valid := arch == "386"
+			if got := consumer.step(ins, &copy, nil, 0, arch); got != valid {
+				t.Fatalf("%s %s WIG accepted%t want%t", arch, consumer.name, got, valid)
+			}
+		}
+	}
+}
+
+func TestX86BroadcastMode32GPQPhysicalLaneWidth(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nMOVL $1,AX\nVPBROADCASTQ AX,X2\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", Sigs: map[string]FuncSig{
+		"f": {Name: "f", Ret: Void},
+	}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(ir, "insertelement <4 x i32>") || strings.Contains(ir, "insertelement <2 x i64>") {
+		t.Fatal("mode32 original W1 GP broadcast did not use physical WIG dword lanes")
+	}
+}
+
+func TestX86BroadcastRawOriginalMode32GPQWIG(t *testing.T) {
+	code := assembleX87ControlBytes(t, "386", "TEXT f(SB),4,$0-0\nVPBROADCASTQ AX,X2\nRET\n")
+	want := []byte{0x62, 0xf2, 0xfd, 0x08, 0x7c, 0xd0, 0xc3}
+	if !bytes.Equal(code, want) {
+		t.Fatalf("actual Go W1 bytes%x", code)
+	}
+	ins, length, known, err := decodedX86VEXPackedBroadcastInstruction(code[:6], 32)
+	if err != nil || !known || length != 6 {
+		t.Fatalf("actual Go mode32 WIG decoder: known%t length%d err%v", known, length, err)
+	}
+	form, known, err := x86BroadcastProperties(ins.Op, ins, "386")
+	if err != nil || !known || form.sourceBytes != 4 || form.laneBits != 32 {
+		t.Fatalf("physical mode32 GP-Q effect %+v known%t err%v", form, known, err)
+	}
+}
+
+func TestX86BroadcastTypedGrammarCompleteGoWitnesses(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		source.WriteString("TEXT f(SB),4,$0-0\n")
+		for _, spec := range x86BroadcastTestDirectory {
+			inputs := []string{"32(AX)"}
+			for _, kind := range spec.source {
+				inputs = append(inputs, map[rune]string{'X': "X3", 'G': "AX", 'K': "K0"}[kind])
+			}
+			if spec.source == "K" {
+				inputs = inputs[1:]
+			}
+			for _, bank := range spec.destinations {
+				for _, input := range inputs {
+					for _, masking := range []int{0, 1, 2} {
+						if masking != 0 && (spec.source == "K" || strings.HasSuffix(spec.name, "128")) {
+							continue
+						}
+						op, mask := spec.name, ""
+						if masking != 0 {
+							mask = "K7,"
+						}
+						if masking == 2 {
+							op += ".Z"
+						}
+						row := fmt.Sprintf("%s %s,%s%c7", op, input, mask, bank)
+						source.WriteString(row + "\n")
+						t.Run(arch+"/"+row, func(t *testing.T) {
+							ins := x86YMMReadSource(t, row)
+							f, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+							width, lane := spec.bytes, spec.lane*8
+							if arch == "386" && spec.name == "VPBROADCASTQ" && input == "AX" {
+								width, lane = 4, 32
+							}
+							if err != nil || !known || f.sourceBytes != width || f.laneBits != lane ||
+								f.byteWidth != map[rune]int{'X': 16, 'Y': 32, 'Z': 64}[bank] || (f.mask >= 0) != (masking != 0) || f.zeroing != (masking == 2) {
+								t.Fatalf("typed row %+v known%t err%v", f, known, err)
+							}
+						})
+					}
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+	}
+}
+
+func TestX86BroadcastAuthorityAndGrammarControls(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"VPBROADCASTW $1,X0", "VPBROADCASTW Y0,X0", "VPBROADCASTW AL,X0",
+			"VBROADCASTSD AX,Y0", "VBROADCASTSD X0,X0", "VBROADCASTSS.BCST X0,Y0",
+			"VBROADCASTF128 X0,Y0", "VBROADCASTF32X4 X0,Y0", "VBROADCASTF32X2 X0,X0",
+			"VPBROADCASTMB2Q X0,X1", "VPBROADCASTMW2D.Z K1,X1",
+			"VPBROADCASTW.Z X0,X1", "VPBROADCASTW X0,K0,X1",
+		} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + row + "\nRET\n"
+				if row == "VPBROADCASTW.Z X0,X1" {
+					// Go 1.20 emits reserved EVEX.z=1/aaa=0. Observe the
+					// complete original bytes and require raw rejection too;
+					// this is never a supported form or an executable test.
+					x86BroadcastReservedZeroMaskGoObservation(t, arch, source,
+						[]byte{0x62, 0xf2, 0x7d, 0x88, 0x79, 0xc8, 0xc3}, true)
+				} else {
+					goAssemblerOracleOutput(t, arch, source, "", false)
+				}
+				ins := x86YMMReadSource(t, row)
+				if _, known, err := x86BroadcastProperties(ins.Op, ins, arch); !known || err == nil {
+					t.Fatal("Go-rejected form acquired typed effect")
+				}
+			})
+		}
+		for _, row := range []string{"VPBROADCASTW (AX),X2", "VPBROADCASTW x+0(FP),X2", "VBROADCASTF32X4 (AX),Y2", "VPBROADCASTMB2Q K0,X2", "VPBROADCASTW SP,X2", "VPBROADCASTQ BP,X2"} {
+			ins := x86YMMReadSource(t, row)
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{}
+				for index := range state.gp {
+					state.gp[index] = 0xff
+				}
+				for index := range state.xmm {
+					state.xmm[index] = 0xffff
+				}
+				for index := range state.masks {
+					state.masks[index] = true
+				}
+				// K0 is an ordinary initialized data source here, not a
+				// writemask or a grant of native memory permission.
+				ordinary := arch == "386" && row == "VPBROADCASTQ BP,X2" || row == "VPBROADCASTMB2Q K0,X2"
+				if consumer.step(ins, &state, nil, 0, arch) != ordinary {
+					t.Fatalf("%s borrowed native/mask/SP/BP permission: %s", consumer.name, row)
+				}
+			}
+		}
+		for _, row := range []string{"VPBROADCASTW AX,X2", "VPBROADCASTQ AX,Z2"} {
+			ins := x86YMMReadSource(t, row)
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{gp: [16]uint8{255}, pointerGP: [16]bool{true}}
+				before := state.clone()
+				if consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("opaque identity washed into numerical broadcast")
+				}
+			}
+		}
+		for _, row := range []string{"VPBROADCASTW X1,K3,X2", "VPBROADCASTW.Z X1,K3,X2"} {
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{xmm: [32]uint16{1: 65535, 2: 65535}}
+				if consumer.step(x86YMMReadSource(t, row), &state, nil, 0, arch) {
+					t.Fatal("undefined K mask accepted")
+				}
+			}
+		}
+		for missing := 0; missing < 16; missing++ {
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{xmm: [32]uint16{1: 65535, 2: 65535 &^ (1 << uint(missing))}, masks: [8]bool{3: true}}
+				if consumer.step(x86YMMReadSource(t, "VPBROADCASTW X1,K3,X2"), &state, nil, 0, arch) {
+					t.Fatal("unknown inactive merge destination byte accepted")
+				}
+			}
+		}
+	}
+	for _, row := range []string{"VPBROADCASTW X8,X0", "VPBROADCASTQ AX,Y15", "VBROADCASTF128 (AX),Y15", "VBROADCASTF32X2 X20,Y21"} {
+		ins := x86YMMReadSource(t, row)
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+		if _, known, err := x86BroadcastProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("Go object mistaken for physical high-bank binding")
+		}
+	}
+}
+
+func TestX86BroadcastCompleteRegisterBanks(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		limit := 32
+		gps := []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+		if arch == "386" {
+			limit, gps = 8, gps[:8]
+		}
+		for _, spec := range x86BroadcastTestDirectory {
+			if spec.source != "X" && spec.source != "XG" {
+				continue
+			}
+			var sources []Reg
+			for i := 0; i < limit; i++ {
+				sources = append(sources, Reg(fmt.Sprint("X", i)))
+			}
+			if spec.source == "XG" {
+				sources = append(sources, gps...)
+			}
+			for _, src := range sources {
+				for _, bank := range spec.destinations {
+					for dst := 0; dst < limit; dst++ {
+						for masking := 0; masking < 3; masking++ {
+							op, mask := spec.name, ""
+							if masking != 0 {
+								mask = "K7,"
+							}
+							if masking == 2 {
+								op += ".Z"
+							}
+							ins := x86YMMReadSource(t, fmt.Sprintf("%s %s,%s%c%d", op, src, mask, bank, dst))
+							for _, consumer := range x86ResultGPSIMDConsumers {
+								state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{7: true}}
+								for i := range state.gp {
+									state.gp[i] = 255
+								}
+								for i := range state.xmm {
+									state.xmm[i] = 65535
+								}
+								valid := src != SP && (src != BP || arch == "386")
+								if got := consumer.step(ins, &state, nil, 0, arch); got != valid || state.flags != x86ByteFlagsAll {
+									t.Fatalf("%s %s row%s accepted%t want%t", arch, consumer.name, ins.Raw, got, valid)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastOriginalAllPathAndOpaqueControls(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, typ, index := 8, "MOVQ", "uint64", 11
+		if arch == "386" {
+			word, move, typ, index = 4, "MOVL", "uint32", 3
+		}
+		initialize := fmt.Sprintf("PINSRD $0,AX,X%d\n", index)
+		for _, test := range []struct {
+			name, body, decl string
+			valid            bool
+		}{
+			{"both_paths", fmt.Sprintf("CMP%s AX,AX\nJE good\n%sJMP joined\ngood:\n%sjoined:\n", map[string]string{"amd64": "Q", "386": "L"}[arch], initialize, initialize), "", true},
+			{"one_unknown_path", fmt.Sprintf("CMP%s AX,AX\nJE good\nJMP joined\ngood:\n%sjoined:\n", map[string]string{"amd64": "Q", "386": "L"}[arch], initialize), "", false},
+			{"partial_word", fmt.Sprintf("PINSRB $0,AX,X%d\n", index), "", false},
+			{"opaque_pointer", fmt.Sprintf("VPBROADCASTW AX,X%d\n", index), "func Value(x *uint64) " + typ, false},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				decl := test.decl
+				if decl == "" {
+					decl = "func Value(x " + typ + ") " + typ
+				}
+				body := fmt.Sprintf("%s x+0(FP),AX\n", move) + test.body
+				body += fmt.Sprintf("VPBROADCASTW X%d,X%d\nVPEXTRQ $0,X%d,BX\n%s BX,ret0+%d(FP)\nRET", index, index, index, move, word)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, decl, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.valid && err != nil || !test.valid && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("valid%t err%v", test.valid, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_broadcast_forms.go b/x86_broadcast_forms.go
new file mode 100644
index 000000000..0d5eebb7b
--- /dev/null
+++ b/x86_broadcast_forms.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86BroadcastKind uint8
+
+const (
+	x86BroadcastInteger x86BroadcastKind = iota
+	x86BroadcastFloat
+	x86BroadcastBlock
+	x86BroadcastMask
+)
+
+type x86BroadcastForm struct {
+	kind                             x86BroadcastKind
+	sourceBytes, laneBits, byteWidth int
+	destination, mask                int
+	zeroing                          bool
+	vex                              bool // Family has VEX forms; operand/encoding guards still apply.
+}
+
+// Scalar, block and mask-data forms share one Go grammar, not one authority.
+// A validated memory shape supplies neither initialized data nor an envelope.
+func x86BroadcastProperties(op Op, ins Instr, arch string) (x86BroadcastForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(op)), ".")
+	f := x86BroadcastForm{mask: -1, destination: len(ins.Args) - 1}
+	allowGP, allowX, vexOnly := false, true, false
+	widths := map[int]bool{16: true, 32: true, 64: true}
+	switch name {
+	case "VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ":
+		f.kind, allowGP = x86BroadcastInteger, true
+		f.vex = true
+		f.sourceBytes = map[string]int{"VPBROADCASTB": 1, "VPBROADCASTW": 2, "VPBROADCASTD": 4, "VPBROADCASTQ": 8}[name]
+		f.laneBits = f.sourceBytes * 8
+	case "VBROADCASTSS", "VBROADCASTSD":
+		f.kind, f.sourceBytes = x86BroadcastFloat, 4
+		f.vex = true
+		if name == "VBROADCASTSD" {
+			f.sourceBytes, widths = 8, map[int]bool{32: true, 64: true}
+		}
+		f.laneBits = f.sourceBytes * 8
+	default:
+		if spec, known := amd64PackedBlockBroadcastSpecs[name]; known {
+			f.kind, f.sourceBytes, f.laneBits = x86BroadcastBlock, spec.sourceBytes, spec.laneBits
+			allowX, vexOnly, widths = spec.allowXSource, spec.vexMemoryOnly, spec.allowDestinations
+			f.vex = vexOnly
+		} else if spec, known := amd64MaskBroadcastSpecs[Op(name)]; known {
+			f.kind, f.sourceBytes, f.laneBits = x86BroadcastMask, spec.sourceBits/8, spec.laneBits
+		} else {
+			return f, false, nil
+		}
+	}
+	fail := func() (x86BroadcastForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside complete Go broadcast grammar: %q", arch, op, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || ins.Op != "" && !strings.EqualFold(string(op), string(ins.Op)) ||
+		dotted && suffix != "Z" || len(ins.Args) != 2 && len(ins.Args) != 3 {
+		return fail()
+	}
+	f.zeroing = dotted
+	if f.kind == x86BroadcastMask || vexOnly {
+		if dotted || len(ins.Args) != 2 {
+			return fail()
+		}
+	}
+	if len(ins.Args) == 3 {
+		mask, valid := amd64ParseKReg(ins.Args[1].Reg)
+		if ins.Args[1].Kind != OpReg || !valid || mask == 0 {
+			return fail()
+		}
+		f.mask = 1
+	}
+	if f.zeroing && f.mask < 0 {
+		return fail()
+	}
+	dst := ins.Args[f.destination]
+	f.byteWidth = amd64VectorByteWidth(dst.Reg)
+	if !widths[f.byteWidth] || !amd64GoPackedVectorMoveRegister(dst, f.byteWidth, arch) {
+		return fail()
+	}
+	if vexOnly {
+		index, valid := amd64ParseYReg(dst.Reg)
+		if !valid || index >= 16 {
+			return fail()
+		}
+	}
+	src := ins.Args[0]
+	if f.kind == x86BroadcastMask {
+		if _, valid := amd64ParseKReg(src.Reg); src.Kind != OpReg || !valid {
+			return fail()
+		}
+	} else if src.Kind == OpReg {
+		if index, valid := amd64ParseXReg(src.Reg); allowX && valid && index < 32 {
+			// Go selects EVEX for the higher banks. Mode32 still needs a
+			// physical binding, checked below rather than guessed from names.
+		} else if !allowGP || !isX86YrlRegisterForArch(src.Reg, arch) {
+			return fail()
+		} else if arch == "386" && f.sourceBytes == 8 {
+			// Intel's GP-Q opcode 7C ignores EVEX.W outside 64-bit mode:
+			// dword input AND dword lanes. X/memory opcode 59 remains qword.
+			f.sourceBytes, f.laneBits = 4, 32
+		}
+	} else if src.Kind == OpImm && !src.ImmIsFloat && src.ImmRaw == "" &&
+		(f.kind == x86BroadcastInteger && ins.x86Encoded || f.kind == x86BroadcastFloat && ins.x86RIPLiteral) {
+		// A decoder-bound RIP literal is not a named immediate permission.
+	} else if !isAMD64MemoryOperand(src) || !x86PackedShiftMemoryValid(src, arch) {
+		return fail()
+	}
+	return f, true, x86Mode32VectorRegisterContext(ins, arch)
+}
+
+// A broadcast reads its exact scalar/block source and defines the complete
+// destination width. A low-X source cannot stand in for a wider block input.
+func x86ResultBroadcastStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultBroadcastStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultBroadcastStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	return x86ResultBroadcastInputs(ins, state, owned, arch, nativeRead, false)
+}
+
+func x86ResultBroadcastInputs(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead, boundLiteral bool) (bool, bool) {
+	f, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	return x86ResultBroadcastTransfer(ins, f, state, owned, arch, nativeRead, boundLiteral)
+}
+
+// Retain the validated physical form when a source-local consumer projects
+// provenance. The mode32 GP-Q opcode still reads and repeats dword lanes;
+// projecting its identity must not change the captured input or tuple roles.
+func x86ResultBroadcastTransfer(ins Instr, f x86BroadcastForm, state *x86ResultState,
+	owned []bool, arch string, nativeRead, boundLiteral bool) (bool, bool) {
+	dst, valid := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	if !valid || dst >= len(state.xmm) {
+		return false, true
+	}
+	if f.mask >= 0 {
+		mask, valid := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !valid || !state.masks[mask] || !f.zeroing && state.xmm[dst] != 0xffff {
+			return false, true
+		}
+	}
+	required := x86CallerVectorByteMask(int64(f.sourceBytes))
+	src := ins.Args[0]
+	if f.kind == x86BroadcastMask {
+		mask, valid := amd64ParseKReg(src.Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	} else if src.Kind == OpImm {
+		if !boundLiteral {
+			return false, true // Only the complete lowering-bound raw source supplies this input.
+		}
+	} else if src.Kind != OpReg {
+		// Reuse the exact initialized FP/AUTO bytes or the lowering-only
+		// same-file DATA extent. The tuple is the scalar/block input, not
+		// the wider destination. A mask cannot waive any potential input.
+		// Only the paired exact volatile emitter supplies a native continuation;
+		// the standalone query still has no native memory or raw address role.
+		if !isAMD64MemoryOperand(src) || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+			!x86ResultReadWithNativeContinuation(ins, src, int64(f.sourceBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else if index, valid := amd64VectorRegisterIndex(src.Reg, amd64VectorByteWidth(src.Reg)); valid {
+		if index >= len(state.xmm) || state.vectorBytes(index)&required != required {
+			return false, true
+		}
+	} else {
+		// A Yrl source exposes low scalar bits without requiring a byte
+		// alias spelling (e.g. SI in mode32). SP/BP and opaque values still
+		// lack numerical input permission in x86ResultGP.
+		index, _, valid := x86ResultGP(src.Reg, 4, arch)
+		if !valid || state.pointerGP[index] || uint64(state.gp[index])&required != required {
+			return false, true
+		}
+	}
+	// All reads, including an aliased source and masked merge, precede writes.
+	defined := ^uint64(0)
+	if f.mask >= 0 && !f.zeroing {
+		defined &= state.vectorBytes(dst)
+	}
+	state.writeVector(dst, f.byteWidth, defined, false)
+	return true, true
+}
diff --git a/x86_broadcast_memory_result_runtime_test.go b/x86_broadcast_memory_result_runtime_test.go
new file mode 100644
index 000000000..aa45d2688
--- /dev/null
+++ b/x86_broadcast_memory_result_runtime_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute the entire memory-form directory through the result-checking path.
+// The independent byte reference samples the last dword of each X/Y/Z result;
+// this is portable LLVM execution, not original native AVX512 execution.
+func TestX86BroadcastDataResultsLLVMRuntime(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	// These source-local broadcasts use portable byte/vector lowering. Keep
+	// the original AMD64 Go oracle below, but execute LLVM on the actual host;
+	// an x86-only floating comparison transport unnecessarily skipped ARM64.
+	execution := x86FloatCompareExecution{llc: llc, compiler: []string{clang},
+		triple: testTargetTriple(runtime.GOOS, runtime.GOARCH)}
+	rows := x86BroadcastMemoryRows()
+	for start := 0; start < len(rows); start += 64 {
+		end := start + 64
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%d", start/64), func(t *testing.T) {
+			var source, declarations, prototypes, checks strings.Builder
+			source.WriteString(x86ScalarResultDataTable)
+			for index, row := range rows[start:end] {
+				name := fmt.Sprintf("broadcast%d", index)
+				fmt.Fprintf(&declarations, "func %s(mask uint64) uint32\n", name)
+				fmt.Fprintf(&prototypes, "extern uint32_t %s(uint64_t);\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVQ mask+0(FP),CX\nKMOVQ CX,K3\nMOVL $0x91929394,AX\nVPBROADCASTD AX,Z2\n%s\n", name, row)
+				width := 16
+				switch row[len(row)-2] {
+				case 'Y':
+					width = 32
+					source.WriteString("VEXTRACTI128 $1,Y2,X2\n")
+				case 'Z':
+					width = 64
+					source.WriteString("VEXTRACTI32X4 $3,Z2,X2\n")
+				}
+				source.WriteString("VPEXTRD $3,X2,AX\nMOVL AX,ret+8(FP)\nRET\n")
+				op, _, _ := strings.Cut(strings.Fields(row)[0], ".")
+				for _, spec := range x86BroadcastTestDirectory {
+					if spec.name == op {
+						masked, zeroing := 0, 0
+						if strings.Contains(row, "K3,") {
+							masked = 1
+						}
+						if strings.Contains(row, ".Z ") {
+							zeroing = 1
+						}
+						fmt.Fprintf(&checks, "if (check(%s,%d,%d,%d,%d,%d)) return 1;\n", name, width, spec.bytes, spec.lane, masked, zeroing)
+					}
+				}
+			}
+			goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+			main := x86BroadcastDataResultDriver + prototypes.String() + "int main(void) {\n" + checks.String() + "return 0;\n}\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							execution.compileAndRunLLVM(t, "data-broadcast-result", ir, main, level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+const x86BroadcastDataResultDriver = `
+#include <stdint.h>
+#include <stdio.h>
+static int check(uint32_t (*fn)(uint64_t), int width, int bytes, int lane, int masked, int zeroing) {
+  static const uint8_t input[32] = {
+    0xef,0xcd,0xab,0x89,0x67,0x45,0x23,0x01, 0,0,0,0,0,0,0,0,
+    0x10,0x32,0x54,0x76,0x98,0xba,0xdc,0xfe, 0x80,0x70,0x60,0x50,0x40,0x30,0x20,0x10
+  };
+  const uint64_t masks[] = {0,1,5,UINT64_MAX,UINT64_C(1)<<63,UINT64_C(0xaaaaaaaaaaaaaaaa)};
+  for (unsigned sample=0; sample<sizeof(masks)/sizeof(masks[0]); sample++) {
+    uint32_t expected=0;
+    for (int byte=0; byte<4; byte++) {
+      int position=width-4+byte;
+      int enabled=!masked || ((masks[sample]>>(position/lane))&1);
+      uint8_t value=enabled ? input[position%bytes] : zeroing ? 0 : (uint8_t)(UINT32_C(0x91929394)>>(8*byte));
+      expected |= (uint32_t)value<<(8*byte);
+    }
+    uint32_t actual=fn(masks[sample]);
+    if (actual!=expected) {
+      fprintf(stderr,"broadcast width=%d bytes=%d lane=%d masked=%d zero=%d sample=%u got=%08x want=%08x\n",
+              width,bytes,lane,masked,zeroing,sample,actual,expected);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
diff --git a/x86_broadcast_memory_result_test.go b/x86_broadcast_memory_result_test.go
new file mode 100644
index 000000000..5932b6467
--- /dev/null
+++ b/x86_broadcast_memory_result_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The independent directory binds all Go broadcast rows, including the two
+// mask-register-only names. Only the eighteen scalar/block names read memory.
+func x86BroadcastMemoryRows() []string {
+	var rows []string
+	for _, spec := range x86BroadcastTestDirectory {
+		if spec.source == "K" {
+			continue
+		}
+		for _, bank := range spec.destinations {
+			rows = append(rows, fmt.Sprintf("%s table<>+0(SB),%c2", spec.name, bank))
+			if spec.table != "_yvbroadcastf128" {
+				rows = append(rows,
+					fmt.Sprintf("%s table<>+0(SB),K3,%c2", spec.name, bank),
+					fmt.Sprintf("%s.Z table<>+0(SB),K3,%c2", spec.name, bank))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86BroadcastMemoryResultExactSourceBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, spec := range x86BroadcastTestDirectory {
+			if spec.source == "K" {
+				continue
+			}
+			for _, role := range []string{"FP", "AUTO", "DATA"} {
+				t.Run(arch+"/"+spec.name+"/"+role, func(t *testing.T) {
+					address := "x+0(FP)"
+					if role == "AUTO" {
+						address = fmt.Sprintf("local-%d(SP)", spec.bytes)
+					} else if role == "DATA" {
+						address = "table<>+0(SB)"
+					}
+					ins := x86YMMReadSource(t, fmt.Sprintf("%s %s,%c2", spec.name, address, spec.destinations[0]))
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						for missing := -1; missing < spec.bytes; missing++ {
+							state := x86ResultState{fp: make([]bool, spec.bytes), auto: make([]bool, spec.bytes), flags: x86ByteFlagsAll}
+							owned := make([]bool, spec.bytes)
+							for i := range owned {
+								owned[i], state.fp[i], state.auto[i] = true, i != missing, i != missing
+							}
+							if role == "DATA" {
+								extent := spec.bytes
+								if missing >= 0 {
+									extent = missing
+								}
+								state.loweredStaticReads = map[x86StaticSBAddress]int64{{symbol: "table<>"}: int64(extent)}
+							}
+							accepted := consumer.step(ins, &state, owned, int64(spec.bytes), arch)
+							if accepted != (missing == -1) {
+								t.Fatalf("%s missing byte %d: accepted=%t", consumer.name, missing, accepted)
+							}
+							if accepted && (state.vectorBytes(2) != ^uint64(0) || state.flags != x86ByteFlagsAll) {
+								t.Fatal("broadcast lost VEX/EVEX upper zeroing or changed flags")
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BroadcastSameFileDataThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	rows := x86BroadcastMemoryRows()
+	if len(rows) != 104 {
+		t.Fatalf("complete independent memory forms changed: %d", len(rows))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for start := 0; start < len(rows); start += 64 {
+				end := start + 64
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch-%d", start/64), func(t *testing.T) {
+					var source, declarations strings.Builder
+					source.WriteString(x86ScalarResultDataTable)
+					for index, row := range rows[start:end] {
+						fmt.Fprintf(&declarations, "func broadcast%d() uint32\n", index)
+						fmt.Fprintf(&source, "TEXT ·broadcast%d(SB),4,$0-4\n", index)
+						if strings.Contains(row, "K3,") {
+							source.WriteString("MOVL $5,AX\nKMOVD AX,K3\n")
+							if !strings.Contains(row, ".Z ") {
+								source.WriteString("VPXORD Z2,Z2,Z2\n")
+							}
+						}
+						source.WriteString(row + "\nVPEXTRD $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n")
+					}
+					goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("same-file DATA cannot supply the complete typed broadcast read", err)
+							}
+							x86ResultInitializationObject(t, llc, target.triple, ir, "memory-broadcast-"+api)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BroadcastMemoryResultMaskAndAddressBoundaries(t *testing.T) {
+	widths := make(map[string]int)
+	for _, spec := range x86BroadcastTestDirectory {
+		widths[spec.name] = spec.bytes
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86BroadcastMemoryRows() {
+			ins := x86YMMReadSource(t, row)
+			name, _, _ := strings.Cut(string(ins.Op), ".")
+			width := widths[name]
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				for _, mutation := range []string{"complete", "short", "foreign symbol", "negative", "address override", "unbound override", "unknown mask", "unknown merge", "native pointer"} {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.writeVector(2, 64, ^uint64(0), false)
+					state.masks[3] = true
+					address := x86StaticSBAddress{symbol: "table<>"}
+					state.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(width)}
+					probe := ins
+					probe.Args = append([]Operand(nil), ins.Args...)
+					want := mutation == "complete"
+					switch mutation {
+					case "short":
+						state.loweredStaticReads[address]--
+					case "foreign symbol":
+						probe.Args[0] = x86YMMReadSource(t, "MOVQ foreign(SB),AX").Args[0]
+					case "negative":
+						probe.Args[0] = x86YMMReadSource(t, "MOVQ table<>-1(SB),AX").Args[0]
+					case "address override":
+						probe.x86AddressBits = 32
+					case "unbound override":
+						probe.x86UnboundAddressOverride = true
+					case "unknown mask":
+						state.masks[3] = false
+						want = !strings.Contains(row, "K3,")
+					case "unknown merge":
+						state.xmm[2], state.vectorUpper[2] = 0, 0
+						want = !strings.Contains(row, "K3,") || strings.Contains(row, ".Z ")
+					case "native pointer":
+						probe.Args[0] = x86YMMReadSource(t, "MOVQ (AX),BX").Args[0]
+						state.gp[0], state.pointerGP[0] = 255, true
+					}
+					if got := consumer.step(probe, &state, nil, 0, arch); got != want {
+						t.Fatalf("%s %s %s %s: accepted=%t want=%t", arch, consumer.name, row, mutation, got, want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastDataResultDoesNotGrantStandaloneRead(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86BroadcastMemoryRows() {
+			body := "MOVL $1,AX\nKMOVD AX,K3\nVPXORD Z2,Z2,Z2\n" + row +
+				"\nVPEXTRD $0,X2,AX\nMOVL AX,ret0+0(FP)\nRET"
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("standalone query acquired DATA permission: %s: %v", row, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_broadcast_native_fault_test.go b/x86_broadcast_native_fault_test.go
new file mode 100644
index 000000000..0383e53a9
--- /dev/null
+++ b/x86_broadcast_native_fault_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86BroadcastPairedNativeMemoryFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	execution := x86FloatCompareExecution{llc: llc, triple: triple,
+		compiler: []string{clang, "-target", triple}}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := runtimeOracleNativeCCommand(t, ctx, clang, "-target", triple)
+		cancel()
+		execution.compiler = command.Args
+	}
+	arch, move, maskMove, originalTriple := "amd64", "MOVQ", "KMOVQ", "x86_64-unknown-linux-gnu"
+	if strconv.IntSize == 32 {
+		arch, move, maskMove, originalTriple = "386", "MOVL", "KMOVD", "i386-unknown-linux-gnu"
+	}
+	type kernel struct {
+		source, declaration string
+		bytes               int
+	}
+	var kernels []kernel
+	for _, spec := range x86BroadcastTestDirectory {
+		if spec.source == "K" {
+			continue
+		}
+		add := func(masked bool, mask int64) {
+			row := fmt.Sprintf("%s table<>+0(SB),%c2", spec.name, spec.destinations[0])
+			if masked {
+				row = fmt.Sprintf("%s.Z table<>+0(SB),K3,%c2", spec.name, spec.destinations[0])
+			}
+			source, declaration := x86BroadcastNativeFixture(arch, row, true)
+			source = strings.Replace(source, "3(AX)(DX*2)", "(AX)", 1)
+			source = strings.Replace(source, "MOVL $5,CX\nKMOVD CX,K3", fmt.Sprintf("%s $%d,CX\n%s CX,K3", move, mask, maskMove), 1)
+			readBytes := spec.bytes
+			if masked {
+				readBytes = 0
+				width := map[byte]int{'X': 16, 'Y': 32, 'Z': 64}[spec.destinations[0]]
+				for lane := 0; lane < width/spec.lane; lane++ {
+					end := (lane%(spec.bytes/spec.lane) + 1) * spec.lane
+					if uint64(mask)&(uint64(1)<<uint(lane)) != 0 && end > readBytes {
+						readBytes = end
+					}
+				}
+			}
+			kernels = append(kernels, kernel{source, declaration, readBytes})
+		}
+		add(false, 0)
+		if spec.table != "_yvbroadcastf128" {
+			width := map[byte]int{'X': 16, 'Y': 32, 'Z': 64}[spec.destinations[0]]
+			for _, mask := range []int64{0, 1, 2, -1, 1 << uint(spec.bytes/spec.lane), 1 << uint(width/spec.lane)} {
+				add(true, mask)
+			}
+		}
+	}
+	if len(kernels) != 114 {
+		t.Fatal("incomplete scalar/block fault directory", len(kernels))
+	}
+	for start := 0; start < len(kernels); start += 64 {
+		end := start + 64
+		if end > len(kernels) {
+			end = len(kernels)
+		}
+		t.Run(fmt.Sprint("batch-", start/64), func(t *testing.T) {
+			var assembly, declarations, callbacks, rows strings.Builder
+			var required []bool
+			for index, entry := range kernels[start:end] {
+				name := fmt.Sprint("Broadcast", index)
+				assembly.WriteString(strings.ReplaceAll(entry.source, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(entry.declaration, "Value", name) + "\n")
+				fmt.Fprintf(&callbacks, "extern uint32_t %s(const uint8_t*);\n", name)
+				fmt.Fprintf(&callbacks, "static int run%d(const uint8_t *p) { return %s(p)==7 ? 0 : 91; }\n", index, name)
+				accessible := entry.bytes - 1
+				if accessible < 0 {
+					accessible = 0
+				}
+				fmt.Fprintf(&rows, "{run%d,%d,%d},\n", index, entry.bytes, accessible)
+				required = append(required, entry.bytes != 0)
+			}
+			x86LEAActualTargetGoObject(t, arch, originalTriple, assembly.String())
+			ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, execution.triple, "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			driver := x86MemoryFaultDriver(callbacks.String(), rows.String())
+			for _, passes := range []string{"default", "O2"} {
+				text := ir
+				if passes == "O2" {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(passes+level, func(t *testing.T) {
+						executable := execution.compileLLVM(t, "broadcast-fault", text, driver, level)
+						x86CheckMemoryAccessMatrix(t, execution, executable, required)
+					})
+				}
+			}
+		})
+	}
+	t.Log("114 scalar/block kernels; actual-host portable LLVM memory faults, not original AVX512 execution")
+}
diff --git a/x86_broadcast_native_result_test.go b/x86_broadcast_native_result_test.go
new file mode 100644
index 000000000..82a96a8ca
--- /dev/null
+++ b/x86_broadcast_native_result_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Reuse the independent complete Go encoder directory, not production-map keys.
+// The two mask-data broadcasts have no memory row and remain separate.
+func x86BroadcastNativeFixture(arch, row string, dead bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	body := fmt.Sprintf("%s p+0(FP),AX\nMOVL $1,DX\n", move)
+	if strings.Contains(row, "K3,") {
+		body += "MOVL $5,CX\nKMOVD CX,K3\n"
+		if !strings.Contains(row, ".Z ") {
+			body += "VPXORD Z2,Z2,Z2\n"
+		}
+	}
+	body += strings.Replace(row, "table<>+0(SB)", "3(AX)(DX*2)", 1) + "\n"
+	if dead {
+		body += "MOVL $7,AX\n"
+	} else {
+		body += "VPEXTRD $0,X2,AX\n"
+	}
+	body += fmt.Sprintf("MOVL AX,ret+%d(FP)\nRET\n", word)
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word+4, body),
+		"func Value(p *[64]byte) uint32"
+}
+
+func TestX86BroadcastPairedNativeReadCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86BroadcastMemoryRows()
+	if len(rows) != 104 {
+		t.Fatal("independent complete broadcast directory changed", len(rows))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, dead := range []bool{false, true} {
+				for start := 0; start < len(rows); start += 64 {
+					end := start + 64
+					if end > len(rows) {
+						end = len(rows)
+					}
+					t.Run(fmt.Sprintf("dead-%t/batch-%d", dead, start/64), func(t *testing.T) {
+						var assembly, declarations strings.Builder
+						var names []string
+						for index, row := range rows[start:end] {
+							source, declaration := x86BroadcastNativeFixture(target.arch, row, dead)
+							name := fmt.Sprintf("Broadcast%d", index)
+							names = append(names, name)
+							assembly.WriteString(strings.ReplaceAll(source, "Value", name))
+							declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+						}
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+								if err != nil {
+									t.Fatal("complete broadcast lost its paired native input", err)
+								}
+								for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+									x86BroadcastRequireNativeLoads(t, text, names)
+									for _, level := range []string{"-O0", "-O2"} {
+										x86PackedStringCompileObject(t, llc, target.triple, text, level)
+									}
+								}
+							})
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func x86BroadcastRequireNativeLoads(t *testing.T, ir string, names []string) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range names {
+		function := module.NamedFunction(name)
+		if function.IsNil() || function.FirstBasicBlock().IsNil() || !strings.Contains(function.String(), "load volatile") {
+			t.Fatal("live or dead broadcast discarded its original function or native access", name)
+		}
+	}
+}
+
+func TestX86BroadcastPairedNativeReadKeepsSourceAndQueryBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86BroadcastMemoryRows() {
+			source, declaration := x86BroadcastNativeFixture(arch, row, false)
+			body := source[strings.Index(source, "\n")+1:]
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, body)
+			for _, check := range []func(Func, FuncSig, string) error{
+				CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+			} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone query acquired paired native backing", arch, row, err)
+				}
+			}
+			remove := []string{fmt.Sprintf("%s p+0(FP),AX\n", move), "MOVL $1,DX\n"}
+			if strings.Contains(row, "K3,") {
+				remove = append(remove, "KMOVD CX,K3\n")
+				if !strings.Contains(row, ".Z ") {
+					remove = append(remove, "VPXORD Z2,Z2,Z2\n")
+				}
+			}
+			for _, missing := range remove {
+				changed := strings.Replace(source, missing, "", 1)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+					if arch == "amd64" && missing == "VPXORD Z2,Z2,Z2\n" {
+						x86VectorScratchCodegenControl(t, changed, declaration, arch, triple, ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("broadcast invented a missing native input", arch, row, missing, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastMaskDataCompleteResultInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, mask := range []int{0, 3, 7} {
+					row := fmt.Sprintf("%s K%d,%s2", name, mask, bank)
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						for _, consumer := range x86ResultGPSIMDConsumers {
+							for _, known := range []bool{false, true} {
+								state := x86ResultState{flags: x86ByteFlagsAll}
+								state.writeVector(2, 64, 0, false)
+								state.masks[mask] = known
+								before := state.clone()
+								if accepted := consumer.step(x86YMMReadSource(t, row), &state, nil, 0, arch); accepted != known {
+									t.Fatal("mask-data broadcast lost its actual input requirement", consumer.name, known)
+								}
+								if known && (state.vectorBytes(2) != ^uint64(0) || state.flags != before.flags) ||
+									!known && !reflect.DeepEqual(state, before) {
+									t.Fatal("mask-data broadcast invented bits or lost EVEX upper zeroing", consumer.name)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_broadcast_normalization_test.go b/x86_broadcast_normalization_test.go
new file mode 100644
index 000000000..e3f8a6d12
--- /dev/null
+++ b/x86_broadcast_normalization_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86BroadcastMaskDataLowererCaseParity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				t.Run(arch+"/"+op+"/"+bank, func(t *testing.T) {
+					for _, input := range []string{"K0", "K7"} {
+						var expected string
+						for _, spelling := range []string{op, strings.ToLower(op), "Vp" + strings.ToLower(op[2:])} {
+							ins := x86YMMReadSource(t, op+" "+input+","+bank+"3")
+							ins.Op, ins.Raw = Op(spelling), spelling+" "+input+","+bank+"3"
+							c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "caseParity", Ret: Void}, nil)
+							c.goarch = arch
+							func() {
+								defer func() {
+									if panicValue := recover(); panicValue != nil {
+										t.Fatalf("direct mask-data lowerer %q panicked: %v", spelling, panicValue)
+									}
+								}()
+								known, terminated, err := c.lowerMaskRegisterBroadcast(Op(spelling), ins)
+								if err != nil || !known || terminated {
+									t.Fatalf("direct mask-data lowerer %q: known%t terminated%t err%v", spelling, known, terminated, err)
+								}
+							}()
+							if spelling == op {
+								expected = output.String()
+							} else if output.String() != expected {
+								t.Fatalf("%q emitted different numerical/alias IR from uppercase", spelling)
+							}
+							if strings.Contains(output.String(), "i0") {
+								t.Fatalf("%q emitted a zero-width scalar", spelling)
+							}
+							for _, consumer := range x86ResultGPSIMDConsumers {
+								for _, initialized := range []bool{false, true} {
+									state := x86ResultState{flags: x86ByteFlagsAll}
+									index, _ := amd64ParseKReg(ins.Args[0].Reg)
+									state.masks[index] = initialized
+									expected := state.clone()
+									if initialized {
+										expected.writeVector(3, 64, ^uint64(0), false)
+									}
+									if accepted := consumer.step(ins, &state, nil, 0, arch); accepted != initialized || !reflect.DeepEqual(state, expected) {
+										t.Fatalf("%s %q lost actual mask-data input/output effects; initialized%t", consumer.name, spelling, initialized)
+									}
+								}
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BroadcastMaskDataLowerVecRemainsUnknown(t *testing.T) {
+	// K-data uses the preceding dedicated instruction dispatcher, not lowerVec.
+	// Case normalization must not silently add a second admission path here.
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, spelling := range []string{op, strings.ToLower(op)} {
+					c, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "unknownCase", Ret: Void}, nil)
+					c.goarch = arch
+					ins := x86YMMReadSource(t, op+" K7,"+bank+"3")
+					ins.Op = Op(spelling)
+					before := output.String()
+					known, terminated, err := c.lowerVec(Op(spelling), ins)
+					if known || terminated || err != nil || output.String() != before {
+						t.Fatalf("%s %s gained a lowerVec route: known%t terminated%t err%v", arch, spelling, known, terminated, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BroadcastMaskDataRawPrefixReparseAndTruncation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+			for width, bank := range []string{"X", "Y", "Z"} {
+				code := assembleX87ControlBytes(t, arch, fmt.Sprintf("TEXT f(SB),4,$0-0\n%s K7,%s3\nRET\n", op, bank))
+				if !bytes.Equal(code, append(x86MaskBroadcastPhysicalBytes(op, width, 7, 3), 0xc3)) {
+					t.Fatalf("%s %s original physical witness: %x", arch, op, code)
+				}
+				for _, prefixes := range [][]byte{{0x64}, {0x65}, {0x67}, {0x64, 0x65}, {0x65, 0x64, 0x67}, {0x67, 0x64, 0x65}, {0x64, 0x67, 0x64, 0x67}} {
+					physical := append(append([]byte(nil), prefixes...), code[:6]...)
+					_, _, known, err := decodedX86VEXPackedBroadcastInstruction(physical, mode)
+					if !known || err == nil {
+						t.Fatalf("%s %s accumulated prefix%x escaped wrapper: known%t err%v", arch, op, prefixes, known, err)
+					}
+					// Even cleared caller annotations cannot hide actual prefixes:
+					// the delegated K-data branch re-observes the complete bytes.
+					_, _, known, err = decodedX86EVEXPackedBroadcastInstruction(physical, len(prefixes), mode, "", false)
+					if !known || err == nil {
+						t.Fatalf("%s %s lost original prefix index%x: known%t err%v", arch, op, prefixes, known, err)
+					}
+					for length := 0; length < len(physical); length++ {
+						_, _, known, err := decodedX86VEXPackedBroadcastInstruction(physical[:length], mode)
+						if length < len(prefixes)+5 {
+							if known || err != nil {
+								t.Fatalf("%s prefix%x truncated length%d claimed instruction: known%t err%v", op, prefixes, length, known, err)
+							}
+						} else if !known || err == nil {
+							t.Fatalf("%s prefix%x missing ModRM was accepted", op, prefixes)
+						}
+					}
+					if _, err := decodeX86RawDirectiveGroup(physical, mode, 0, "prefix guard", map[string]bool{}); err == nil {
+						t.Fatalf("%s %s prefix%x escaped the full dispatcher", arch, op, prefixes)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_broadcast_objects_test.go b/x86_broadcast_objects_test.go
new file mode 100644
index 000000000..4830991a3
--- /dev/null
+++ b/x86_broadcast_objects_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BroadcastThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+					var body strings.Builder
+					fmt.Fprintf(&body, "%s x+0(FP),AX\nPINSRD $0,AX,X3\nPINSRD $1,AX,X3\n", move)
+					for _, spec := range x86BroadcastTestDirectory {
+						if spec.source != "X" && spec.source != "XG" {
+							continue
+						}
+						for _, input := range spec.source {
+							src := map[rune]string{'X': "X3", 'G': "AX"}[input]
+							for _, bank := range spec.destinations {
+								row := fmt.Sprintf("%s %s,%c3", spec.name, src, bank)
+								emitX86GoEncodedTestInstructionForArch(t, &body, row, raw, target.arch)
+							}
+						}
+					}
+					fmt.Fprintf(&body, "VPEXTRQ $0,X3,BX\n%s BX,ret0+%d(FP)\nRET", move, word)
+					declaration := "func Value(x " + typ + ") " + typ + "\nfunc Mask()\n"
+					_, file, sig, source := x86ResultInitializationFixture(t, target.arch, declaration, body.String())
+					if !raw {
+						for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+							if err := check(file.Funcs[0], sig, target.arch); err != nil {
+								t.Fatal(err)
+							}
+						}
+					}
+					var maskBody strings.Builder
+					maskBody.WriteString("TEXT ·Mask(SB),4,$0-0\nMOVL $42,AX\nKMOVD AX,K3\n")
+					for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+						for _, bank := range []string{"X", "Y", "Z"} {
+							emitX86GoEncodedTestInstructionForArch(t, &maskBody, op+" K3,"+bank+"2", raw, target.arch)
+						}
+					}
+					source += maskBody.String() + "RET\n"
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal(err)
+							}
+							x86ResultInitializationObject(t, llc, target.triple, ir, "register-broadcast-"+api)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+// The raw witness is always produced by the actual SDK in this fixture's mode.
+func emitX86GoEncodedTestInstructionForArch(t *testing.T, source *strings.Builder, row string, raw bool, arch string) {
+	t.Helper()
+	if !raw {
+		source.WriteString(row + "\n")
+		return
+	}
+	code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+	if len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("original object missing RET")
+	}
+	for _, b := range code[:len(code)-1] {
+		fmt.Fprintf(source, "BYTE $%#x\n", b)
+	}
+}
diff --git a/x86_broadcast_runtime_test.go b/x86_broadcast_runtime_test.go
new file mode 100644
index 000000000..75dc51410
--- /dev/null
+++ b/x86_broadcast_runtime_test.go
@@ -0,0 +1,293 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86BroadcastNumericalCase struct {
+	row                                                     string
+	width, sourceBytes, laneBytes, masking, alias, maskData int
+}
+
+func x86BroadcastNumericalCases(original bool) []x86BroadcastNumericalCase {
+	var cases []x86BroadcastNumericalCase
+	for _, spec := range x86BroadcastTestDirectory {
+		if !original && spec.source == "K" {
+			for _, bank := range spec.destinations {
+				cases = append(cases, x86BroadcastNumericalCase{
+					row:         fmt.Sprintf("%s K3,%c2", spec.name, bank),
+					width:       map[rune]int{'X': 16, 'Y': 32, 'Z': 64}[bank],
+					sourceBytes: spec.bytes, laneBytes: spec.lane, maskData: 1,
+				})
+			}
+			continue
+		}
+		if spec.source != "X" && spec.source != "XG" {
+			continue
+		}
+		if original && spec.name != "VBROADCASTSS" && spec.name != "VBROADCASTSD" && !strings.HasPrefix(spec.name, "VPBROADCAST") {
+			continue
+		}
+		for _, bank := range spec.destinations {
+			if original && bank == 'Z' {
+				continue
+			}
+			for _, input := range spec.source {
+				if original && input == 'G' {
+					continue
+				} // Actual AVX512 GP execution is a separate native axis.
+				for alias := 0; alias < 2; alias++ {
+					if input == 'G' && alias != 0 {
+						continue
+					}
+					src := map[rune]string{'X': "X1", 'G': "AX"}[input]
+					if alias != 0 {
+						src = "X2"
+					}
+					for masking := 0; masking < 3; masking++ {
+						if original && masking != 0 {
+							continue
+						}
+						op, mask := spec.name, ""
+						if masking != 0 {
+							mask = "K3,"
+						}
+						if masking == 2 {
+							op += ".Z"
+						}
+						cases = append(cases, x86BroadcastNumericalCase{
+							row:         fmt.Sprintf("%s %s,%s%c2", op, src, mask, bank),
+							width:       map[rune]int{'X': 16, 'Y': 32, 'Z': 64}[bank],
+							sourceBytes: spec.bytes, laneBytes: spec.lane, masking: masking, alias: alias,
+						})
+					}
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func x86BroadcastNumericalSource(t *testing.T, original, raw bool) (string, string, string, string) {
+	t.Helper()
+	var declarations, source, names, metadata strings.Builder
+	bank := "Z"
+	if original {
+		bank = "Y"
+	}
+	for index, test := range x86BroadcastNumericalCases(original) {
+		name := fmt.Sprint("broadcast", index)
+		fmt.Fprintf(&declarations, "func %s(out *[240]byte,src,old *[64]byte,mask uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),R10\nMOVQ src+8(FP),R11\nMOVQ old+16(FP),R12\nMOVQ mask+24(FP),CX\n", name)
+		fmt.Fprintf(&source, "VMOVUPS (R11),%s1\nVMOVUPS (R12),%s2\nMOVQ 0(R11),AX\nMOVQ 8(R11),BX\n", bank, bank)
+		if test.masking != 0 || test.maskData != 0 {
+			source.WriteString("KMOVQ CX,K3\n")
+		}
+		source.WriteString("STMXCSR 232(R10)\nCMPQ AX,BX\n")
+		emitX86GoEncodedTestInstructionForArch(t, &source, test.row, raw, "amd64")
+		fmt.Fprintf(&source, "VMOVUPS %s2,0(R10)\nVMOVUPS Y2,64(R10)\nVMOVUPS X2,96(R10)\n", bank)
+		src := 1
+		if test.alias != 0 {
+			src = 2
+		}
+		fmt.Fprintf(&source, "VMOVUPS %s%d,112(R10)\nVMOVUPS Y%d,176(R10)\nVMOVUPS X%d,208(R10)\n", bank, src, src, src)
+		source.WriteString("SETCS 224(R10)\nSETEQ 225(R10)\nSETMI 226(R10)\nSETOS 227(R10)\nLAHF\nMOVB AH,DL\nMOVB DL,228(R10)\nSTMXCSR 236(R10)\nRET\n")
+		fmt.Fprintf(&names, "%s,", name)
+		fmt.Fprintf(&metadata, "{%d,%d,%d,%d,%d,%d},\n", test.width, test.sourceBytes, test.laneBytes, test.masking, test.alias, test.maskData)
+	}
+	return declarations.String(), source.String(), names.String(), metadata.String()
+}
+
+func TestX86BroadcastOriginalGoNumericalViewsFlagsCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declaration, source, names, metadata := x86BroadcastNumericalSource(t, true, false)
+	driver := strings.ReplaceAll(x86BroadcastOriginalGoDriver, "FUNCTIONS", names)
+	driver = strings.ReplaceAll(driver, "METADATA", metadata)
+	x86WordMultiplyRunOriginalGo(t, execution, "package wordmultiply\n"+declaration, source, driver)
+	t.Log("Original Go: 22 VEX kernels x37 samples; physical 32-byte Y/X aliases, input/output guards, flags and MXCSR. No native AVX512 or 386 claim.")
+}
+
+func TestX86BroadcastLLVMNumericalViewsFlagsCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	cases := x86BroadcastNumericalCases(false)
+	if len(cases) != 174 {
+		t.Fatalf("independent numerical directory%d", len(cases))
+	}
+	var prototypes, rows strings.Builder
+	for index, test := range cases {
+		fmt.Fprintf(&prototypes, "extern void broadcast%d(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", index)
+		fmt.Fprintf(&rows, "{broadcast%d,%d,%d,%d,%d,%d,%d},\n", index, test.width, test.sourceBytes, test.laneBytes, test.masking, test.alias, test.maskData)
+	}
+	main := strings.ReplaceAll(x86BroadcastLLVMDriver, "PROTOTYPES", prototypes.String())
+	main = strings.ReplaceAll(main, "ROWS", rows.String())
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			declaration, source, _, _ := x86BroadcastNumericalSource(t, false, raw)
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR_default_O2=%t", optimized), func(t *testing.T) {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run("backend"+level, func(t *testing.T) {
+							output := execution.compileAndRunLLVM(t, "register-broadcast", text, main, level)
+							if !strings.Contains(string(output), "LLVM_BROADCAST_38628_CASES_PASS") {
+								t.Fatal(string(output))
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86BroadcastMaskDataPhysicalUpperAliasLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var prototypes, rows strings.Builder
+	selected := 0
+	for index, test := range x86BroadcastNumericalCases(false) {
+		if test.maskData == 0 {
+			continue
+		}
+		selected++
+		fmt.Fprintf(&prototypes, "extern void broadcast%d(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", index)
+		fmt.Fprintf(&rows, "{broadcast%d,%d,%d,%d,%d,%d,%d},\n", index, test.width, test.sourceBytes, test.laneBytes, test.masking, test.alias, test.maskData)
+	}
+	if selected != 6 {
+		t.Fatal("incomplete mask-data X/Y/Z numerical directory")
+	}
+	main := strings.ReplaceAll(x86BroadcastLLVMDriver, "PROTOTYPES", prototypes.String())
+	main = strings.ReplaceAll(main, "ROWS", rows.String())
+	main = strings.ReplaceAll(main, "38628", "1332")
+	declaration, source, _, _ := x86BroadcastNumericalSource(t, false, false)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	output := execution.compileAndRunLLVM(t, "mask-data-broadcast", ir, main, "-O0")
+	if !strings.Contains(string(output), "LLVM_BROADCAST_1332_CASES_PASS") {
+		t.Fatal(string(output))
+	}
+}
+
+const x86BroadcastOriginalGoDriver = `package wordmultiply
+import (
+ "encoding/binary"
+ "fmt"
+ "math/bits"
+ "testing"
+ "unsafe"
+)
+func TestOriginal(t *testing.T) {
+ programs := []func(*[240]byte,*[64]byte,*[64]byte,uint64){FUNCTIONS}
+ rules := []struct {width,sourceBytes,laneBytes,masking,alias,maskData int}{METADATA}
+ observations := 0
+ for k,program := range programs {
+  r := rules[k]
+  for sample := 0; sample < 37; sample++ {
+   var src,old [64]byte
+   for i := range src { src[i]=byte(17+i*7+sample*23); old[i]=byte(199-i*3+sample*31) }
+   edges:=[]uint64{0,0x8000000000000000,0x7ff8000012345678,0x7ff0000012345678,0x000000007fc01234,0x000000007f801234,0x7ff0000000000000,0xffffffffffffffff}
+   if sample<len(edges) { binary.LittleEndian.PutUint64(src[:8],edges[sample]);binary.LittleEndian.PutUint64(old[:8],edges[(sample+3)%len(edges)]) }
+   originalSrc,originalOld := src,old
+   var packet,want [272]byte
+   for i := range packet { packet[i]=byte(i*37+91) }
+   want=packet
+   var value [32]byte
+   input := src
+   if r.alias != 0 { input=old }
+   for i := range value { if i<r.width { value[i]=input[i%r.sourceBytes] } }
+   copy(want[16:48],value[:])
+   copy(want[80:112],value[:])
+   copy(want[112:128],value[:16])
+   observed := src[:32]
+   if r.alias != 0 { observed=value[:] }
+   copy(want[128:160],observed)
+   copy(want[192:224],observed)
+   copy(want[224:240],observed[:16])
+   x,y:=binary.LittleEndian.Uint64(src[:8]),binary.LittleEndian.Uint64(src[8:16])
+   d:=x-y
+   bit:=func(v bool)byte { if v { return 1 }; return 0 }
+   cf,zf,sf,of:=bit(x<y),bit(x==y),bit(d>>63!=0),bit(((x^y)&(x^d))>>63!=0)
+   pf,af:=bit(bits.OnesCount8(byte(d))%2==0),bit((x^y^d)&16!=0)
+   want[240],want[241],want[242],want[243]=cf,zf,sf,of
+   want[244]=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7)
+   program((*[240]byte)(unsafe.Pointer(&packet[16])),&src,&old,0)
+   if binary.LittleEndian.Uint32(packet[248:252])!=binary.LittleEndian.Uint32(packet[252:256]) { t.Fatal("MXCSR changed") }
+   copy(want[248:256],packet[248:256])
+   if packet!=want || src!=originalSrc || old!=originalOld { t.Fatalf("kernel%d sample%d got%x want%x",k,sample,packet,want) }
+   observations++
+  }
+ }
+ if len(programs)!=22 || observations!=814 { t.Fatalf("incomplete denominator%d/%d",len(programs),observations) }
+ fmt.Println("ORIGINAL_BROADCAST_814_CASES_PASS")
+}
+`
+
+const x86BroadcastLLVMDriver = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+PROTOTYPES
+typedef struct {
+ void (*program)(uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+ unsigned width,sourceBytes,laneBytes,masking,alias,maskData;
+} rule;
+static const rule rules[]={ROWS};
+int main(void) {
+ const uint64_t masks[]={0,1,2,UINT64_C(0xaaaaaaaa55555555),UINT64_MAX,UINT64_C(1)<<63};
+ unsigned observations=0;
+ for(unsigned k=0;k<sizeof(rules)/sizeof(rules[0]);k++) {
+  const rule r=rules[k];
+  for(unsigned sample=0;sample<37;sample++) for(unsigned m=0;m<6;m++) {
+   uint8_t src[64],old[64],savedSrc[64],savedOld[64];
+   uint8_t packet[272],want[272],value[64];
+   for(unsigned i=0;i<64;i++) {src[i]=(uint8_t)(17+i*7+sample*23);old[i]=(uint8_t)(199-i*3+sample*31);}
+   const uint64_t edges[]={0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff8000012345678),UINT64_C(0x7ff0000012345678),UINT64_C(0x000000007fc01234),UINT64_C(0x000000007f801234),UINT64_C(0x7ff0000000000000),UINT64_MAX};
+   if(sample<8) {memcpy(src,&edges[sample],8);memcpy(old,&edges[(sample+3)%8],8);}
+   memcpy(savedSrc,src,64);memcpy(savedOld,old,64);
+   for(unsigned i=0;i<272;i++) packet[i]=(uint8_t)(i*37+91);
+   memcpy(want,packet,272);
+   const uint8_t *input=r.alias?old:src;
+   for(unsigned i=0;i<64;i++) {
+    unsigned active=!r.masking||((masks[m]>>(i/r.laneBytes))&1);
+    uint8_t computed=input[i%r.sourceBytes];
+    if(r.maskData) computed=i%r.laneBytes<r.sourceBytes?(uint8_t)(masks[m]>>(8*(i%r.laneBytes))):0;
+    value[i]=i>=r.width?0:active?computed:r.masking==2?0:old[i];
+   }
+   memcpy(want+16,value,64);memcpy(want+80,value,32);memcpy(want+112,value,16);
+   const uint8_t *observed=r.alias?value:src;
+   memcpy(want+128,observed,64);memcpy(want+192,observed,32);memcpy(want+224,observed,16);
+   uint64_t x,y;memcpy(&x,src,8);memcpy(&y,src+8,8);
+   uint64_t d=x-y;
+   unsigned cf=x<y,zf=x==y,sf=d>>63,of=((x^y)&(x^d))>>63;
+   unsigned pf=(__builtin_popcount((uint8_t)d)&1)==0,af=((x^y^d)&16)!=0;
+   want[240]=cf;want[241]=zf;want[242]=sf;want[243]=of;
+   want[244]=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7);
+   uint32_t saved=_mm_getcsr(),profile=(uint32_t)(0x1f80|((sample%4)<<13)|(sample%64));
+   _mm_setcsr(profile);
+   r.program(packet+16,src,old,masks[m]);
+   uint32_t before,after;memcpy(&before,packet+248,4);memcpy(&after,packet+252,4);
+   unsigned csrValid=before==profile&&after==profile&&_mm_getcsr()==profile;
+   _mm_setcsr(saved);
+   memcpy(want+248,packet+248,8);
+   if(!csrValid||memcmp(packet,want,272)||memcmp(src,savedSrc,64)||memcmp(old,savedOld,64)) {
+    for(unsigned i=0;i<272;i++) if(packet[i]!=want[i]) fprintf(stderr,"kernel%u sample%u mask%u byte%u got%x want%x\n",k,sample,m,i,packet[i],want[i]);
+    return 1;
+   }
+   observations++;
+  }
+ }
+ if(observations!=38628) return 1;
+ puts("LLVM_BROADCAST_38628_CASES_PASS");
+ return 0;
+}
+`
diff --git a/x86_bzhi_result_test.go b/x86_bzhi_result_test.go
new file mode 100644
index 000000000..52f21bdad
--- /dev/null
+++ b/x86_bzhi_result_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86BZHICompleteGoRowsAndPhysicalInputs(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"var_ybextrl=[]ytab{{zcase:Zvex_v_rm_r,zoffset:2,args:argList{Yrl,Yml,Yrl}},}",
+		"{as:ABZHIL,ytab:_ybextrl,prefix:Pavx,op:opBytes{avxEscape|vex128|vex0F38|vexW0,0xF5,}},",
+		"{as:ABZHIQ,ytab:_ybextrl,prefix:Pavx,op:opBytes{avxEscape|vex128|vex0F38|vexW1,0xF5,}},",
+	} {
+		if !strings.Contains(compact, row) {
+			t.Fatal("complete original BZHI row or opcode attributes changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+op+" AX,BX,CX\nRET\n")
+				want := []byte{0xc4, 0xe2, 0x78, 0xf5, 0xcb, 0xc3}
+				if op == "BZHIQ" {
+					want[2] = 0xf8
+				}
+				if !bytes.Equal(code, want) {
+					t.Fatalf("original %s/%s bytes %x, want %x", arch, op, code, want)
+				}
+				ins := x86ScalarLaneInstruction(t, op+" AX,(BX),CX")
+				width := int64(4)
+				if arch == "amd64" && op == "BZHIQ" {
+					width = 8
+				}
+				effect, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 3 {
+					t.Fatal("complete BZHI family has no typed input/result contract", known, err)
+				}
+				for index, operand := range effect.operands {
+					bytes := width
+					if index == 0 {
+						bytes = 1 // The ISA consumes only the index's low byte.
+					}
+					if operand.index != index || !reflect.DeepEqual(operand.operand, ins.Args[index]) ||
+						operand.width != bytes || operand.read != (index < 2) || operand.write != (index == 2) {
+						t.Fatal("BZHI physical source/control/write dependency changed", operand)
+					}
+					got, write, valid := x86InstructionMemoryShape(ins, index, arch)
+					if valid != (index == 1) || valid && (got != width || write) {
+						t.Fatal("BZHI source tuple disagrees with physical operand size", index, got, write, valid)
+					}
+				}
+				if effect.flagsRead != 0 || effect.flagsDefined != x86ByteFlagCF|x86ByteFlagOF|x86ByteFlagZF|x86ByteFlagSF ||
+					effect.flagsKilled != x86ByteFlagsAll || effect.dynamicMemory || !effect.requiresResultProof {
+					t.Fatal("BZHI invented defined/preserved status or waived source inputs", effect)
+				}
+			})
+		}
+	}
+}
+
+func TestX86BZHICompleteInitializedSourceObjects(t *testing.T) {
+	x86BitFieldInitializedSourceObjects(t, []string{"BZHIL", "BZHIQ"}, "byte", "MOVB")
+}
+
+func TestX86BZHIVoidAndUnusedBoolCannotInventInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			for _, unused := range []bool{false, true} {
+				declaration, extent := "func Value()", 0
+				if unused {
+					declaration, extent = "func Value(unused bool)", 1
+				}
+				prefixes := map[string]string{
+					"initialized": "MOVB $4,AL\nMOVL $7,BX\n",
+					"no-index":    "MOVL $7,BX\n",
+					"high-only":   "MOVB $4,AH\nMOVL $7,BX\n",
+					"no-source":   "MOVB $4,AL\n",
+				}
+				for name, prefix := range prefixes {
+					t.Run(fmt.Sprintf("%s/%s/bool%t/%s", target.triple, op, unused, name), func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s AX,BX,CX\nRET\n", extent, prefix, op)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if name == "initialized" {
+								if err != nil || ir == "" {
+									t.Error("initialized low-byte BZHI control rejected", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("Void or unused bool manufactured BZHI inputs", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86BZHIOriginalProgramPortableAndObjects(t *testing.T) {
+	const owner = "TestAMD64BZHIRuntimeSemanticsAndFlags"
+	source := x86X87FunctionLiteral(t, "amd64_lower_bzhi_test.go", owner, "source")
+	driver := x86X87FunctionLiteral(t, "amd64_lower_bzhi_test.go", owner, "mainC")
+	execution := x86ScalarCountHostExecution(t)
+	const declaration = "func bzhisemantics(out *byte)"
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-macosx", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("unchanged complete original BZHI source", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, execution.llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("portable/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "original-bzhi", text, driver, level)
+				}
+			}
+		})
+	}
+	t.Log("unchanged original literals: Go and three-target LLVM objects plus actual-host portable values/FLAGS; not native x86 execution")
+}
diff --git a/x86_bzhi_rules_test.go b/x86_bzhi_rules_test.go
new file mode 100644
index 000000000..d7bdbc144
--- /dev/null
+++ b/x86_bzhi_rules_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86BZHICompleteRegisterBanks(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		registers := strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+		if arch == "386" {
+			registers = registers[:8]
+		}
+		var original strings.Builder
+		original.WriteString("TEXT f(SB),4,$0-0\n")
+		count := 0
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			for _, control := range registers {
+				for _, source := range registers {
+					for _, destination := range registers {
+						row := fmt.Sprintf("%s %s,%s,%s", op, control, source, destination)
+						original.WriteString(row + "\n")
+						instruction := x86ScalarLaneInstruction(t, row)
+						if _, known, err := x86ScalarBitFieldProperties(instruction.Op, instruction, arch); !known || err != nil {
+							t.Fatal("complete original GP bank rejected", arch, row, err)
+						}
+						count++
+					}
+				}
+			}
+		}
+		original.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		if count != 2*len(registers)*len(registers)*len(registers) {
+			t.Fatal("incomplete original BZHI register bank", arch, count)
+		}
+	}
+}
+
+func TestX86BZHIResultByteHolesAliasesAndFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			width := int64(4)
+			if arch == "amd64" && op == "BZHIQ" {
+				width = 8
+			}
+			for _, source := range []string{"AX", "BX"} {
+				for _, output := range []string{"AX", "BX", "CX", "SP", "BP"} {
+					instruction := x86ScalarLaneInstruction(t, op+" AX,"+source+","+output)
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						for missing := -1; missing < int(width)+1; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+							input, _, _ := x86ResultGP(Reg(source), width, arch)
+							state.gp[0], state.gp[input] = 1, uint8((uint16(1)<<uint(width))-1)
+							if missing == 0 {
+								state.gp[0] &^= 1
+							} else if missing > 0 {
+								state.gp[input] &^= 1 << uint(missing-1)
+							}
+							before := state.clone()
+							accept := missing == -1 && output != "SP" && (arch == "386" || output != "BP")
+							if got := consumer.step(instruction, &state, nil, 0, arch); got != accept {
+								t.Fatal("BZHI input/destination dependency changed", arch, op, source, output, consumer.name, missing, got)
+							}
+							want := before.clone()
+							if accept {
+								index, _, _ := x86ResultGP(Reg(output), width, arch)
+								want.gp[index] = 0xff
+								want.flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+							}
+							if !reflect.DeepEqual(state, want) {
+								t.Fatal("BZHI partially applied a failed effect or changed unrelated state", arch, op, source, output, missing)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86BZHINativeReadAndOpaqueInputsStaySeparate(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"BZHIL", "BZHIQ"} {
+			for _, role := range []string{"paired", "standalone", "missing-index-byte", "numerical-base", "unknown-offset", "raw", "encoded", "address-override", "opaque-control"} {
+				t.Run(arch+"/"+op+"/"+role, func(t *testing.T) {
+					instruction := x86ScalarLaneInstruction(t, op+" AX,(BX),CX")
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.pointerGP[3] = 1, true
+					native := true
+					switch role {
+					case "standalone":
+						native = false
+					case "missing-index-byte":
+						state.gp[0] = 2 // AH is not BZHI's index.
+					case "numerical-base":
+						state.pointerGP[3], state.gp[3] = false, 0xff
+					case "unknown-offset":
+						instruction.Args[1].Mem.Index, instruction.Args[1].Mem.Scale = SI, 4
+					case "raw":
+						instruction.x86SourceRaw = &x86SourceRawInstruction{}
+					case "encoded":
+						instruction.x86Encoded = true
+					case "address-override":
+						instruction.x86AddressBits = 32
+					case "opaque-control":
+						state.pointerGP[0] = true
+					}
+					before := state.clone()
+					accepted, known := x86ResultScalarBitFieldStep(instruction, &state, nil, 0, arch, native)
+					want := role == "paired" || role == "numerical-base"
+					if !known || accepted != want || !accepted && !reflect.DeepEqual(state, before) {
+						t.Fatal("BZHI read continuation borrowed another source role", known, accepted, role)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_bzhi_runtime_test.go b/x86_bzhi_runtime_test.go
new file mode 100644
index 000000000..19497d970
--- /dev/null
+++ b/x86_bzhi_runtime_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86BZHIEveryIndexAliasesFlagsAndDeadReadFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows strings.Builder
+	for _, op := range []string{"BZHIL", "BZHIQ"} {
+		bits := 32
+		if op == "BZHIQ" {
+			bits = 64
+		}
+		for _, memory := range []bool{false, true} {
+			for _, destination := range []string{"AX", "BX", "CX"} {
+				name := fmt.Sprintf("ZeroHigh%d%t%s", bits, memory, destination)
+				parameter, input, cType := "uint64", "BX", "uint64_t"
+				if memory {
+					parameter, input, cType = "*uint64", "(BX)", "const uint64_t*"
+				}
+				fmt.Fprintf(&declarations, "func %s(control uint64, source %s, out *[16]byte)\n", name, parameter)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-24\nMOVQ control+0(FP),AX\nMOVQ source+8(FP),BX\nMOVQ out+16(FP),DI\n", name)
+				source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n")
+				fmt.Fprintf(&source, "%s AX,%s,%s\nMOVQ %s,0(DI)\nSETCS 8(DI)\nSETOS 9(DI)\nSETEQ 10(DI)\nSETMI 11(DI)\nRET\n", op, input, destination, destination)
+				fmt.Fprintf(&prototypes, "extern void %s(uint64_t,%s,uint8_t*);\n", name, cType)
+				argument := "value"
+				if memory {
+					argument = "&value"
+				}
+				fmt.Fprintf(&prototypes, "static void call%s(uint64_t control,uint64_t value,uint8_t *out) {\n", name)
+				prototypes.WriteString("    uint64_t before=value;\n")
+				fmt.Fprintf(&prototypes, "    %s(control,%s,out);\n", name, argument)
+				prototypes.WriteString("    if (value!=before) abort();\n}\n")
+				fmt.Fprintf(&rows, "{call%s,%d},\n", name, bits)
+			}
+		}
+	}
+	for _, width := range []struct {
+		op    string
+		bytes int
+	}{{"BZHIL", 4}, {"BZHIQ", 8}} {
+		// Even an index of zero and an unused result must retain the complete
+		// native source read. No valid pointee or alignment is assumed.
+		fmt.Fprintf(&source, "TEXT Dead%d(SB),4,$0-8\nMOVQ source+0(FP),BX\nMOVB $0,AL\n%s AX,(BX),CX\nRET\n", width.bytes, width.op)
+		fmt.Fprintf(&declarations, "func Dead%d(source *byte)\n", width.bytes)
+		fmt.Fprintf(&prototypes, "extern void Dead%d(const uint8_t*);\nstatic int fault%d(const uint8_t *p) { Dead%d(p); return 0; }\n", width.bytes, width.bytes, width.bytes)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	valueDriver := strings.ReplaceAll(x86BZHIEveryIndexDriver, "PROTOTYPES", prototypes.String())
+	valueDriver = strings.ReplaceAll(valueDriver, "ROWS", rows.String())
+	faultDriver := x86MemoryFaultDriver(prototypes.String(), "{fault4,4,3},\n{fault8,8,7},\n")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86MulDivRoundOptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+						execution.compileAndRunLLVM(t, "bzhi-values", text, valueDriver, level)
+						executable := execution.compileLLVM(t, "bzhi-faults", text, faultDriver, level)
+						x86CheckMemoryFaultMatrix(t, execution, executable, 2)
+					})
+				}
+			}
+		})
+	}
+	t.Log("all256 indices, ignored high control bits, register/native sources, aliases, CF/OF/ZF/SF, canaries and dead read faults; actual-host portable, not native x86")
+}
+
+const x86BZHIEveryIndexDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+PROTOTYPES
+struct kernel {
+    void (*run)(uint64_t,uint64_t,uint8_t*);
+    unsigned bits;
+};
+static const struct kernel kernels[] = { ROWS };
+
+static uint64_t independent_zero_high(uint64_t value,unsigned bits,unsigned index) {
+    uint64_t result=0;
+    for (unsigned bit=0;bit<bits && bit<index;++bit) {
+        result|=((value>>bit)&1)<<bit;
+    }
+    return result;
+}
+
+int main(void) {
+    static const uint64_t samples[] = {
+        0,1,UINT64_MAX,UINT64_C(0x80000000),
+        UINT64_C(0x8000000000000000),UINT64_C(0x0123456789abcdef)
+    };
+    static const uint64_t high[] = {
+        0,UINT64_C(0x0123456789abcd00),UINT64_MAX-255
+    };
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        for (unsigned s=0;s<sizeof(samples)/sizeof(samples[0]);++s) {
+            for (unsigned h=0;h<sizeof(high)/sizeof(high[0]);++h) {
+                for (unsigned index=0;index<256;++index) {
+                    uint8_t out[32],expected[32];
+                    memset(out,0xa5,sizeof(out));
+                    memset(expected,0xa5,sizeof(expected));
+                    unsigned bits=kernels[k].bits;
+                    uint64_t value=independent_zero_high(samples[s],bits,index);
+                    memcpy(expected+8,&value,sizeof(value));
+                    expected[16]=index>=bits;
+                    expected[17]=0;
+                    expected[18]=value==0;
+                    expected[19]=(value>>(bits-1))&1;
+                    kernels[k].run(high[h]|index,samples[s],out+8);
+                    if (memcmp(out,expected,sizeof(out))) {
+                        fprintf(stderr,"BZHI kernel=%u sample=%u high=%u index=%u mismatch\n",k,s,h,index);
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_clmul_native_decoder_boundaries_test.go b/x86_clmul_native_decoder_boundaries_test.go
new file mode 100644
index 000000000..57ad00072
--- /dev/null
+++ b/x86_clmul_native_decoder_boundaries_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import "testing"
+
+func TestX86CLMULNativePhysicalPrefixRegisterAndTruncationBoundaries(t *testing.T) {
+	for _, row := range x86CLMULNativeOriginCases() {
+		for _, mode := range []int{32, 64} {
+			t.Run(row.name()+"/"+map[int]string{32: "386", 64: "amd64"}[mode], func(t *testing.T) {
+				original := row.code()
+				if _, length, known, err := decodedX86RawCLMULInstruction(original, mode); !known || err != nil || length != len(original) {
+					t.Fatal("complete original physical control failed before its boundary checks", known, length, err)
+				}
+				for extent := 0; extent < len(original); extent++ {
+					if _, _, known, err := decodedX86RawCLMULInstruction(original[:extent], mode); known && err == nil {
+						t.Fatal("truncated original prefix/ModRM/immediate acquired a complete source", extent)
+					}
+				}
+				if row.memory {
+					// This is a separate source/address contract, not an ISA
+					// invalidity claim about otherwise valid address-size bytes.
+					changed := append([]byte{0x67}, original...)
+					if _, _, known, err := decodedX86RawCLMULInstruction(changed, mode); !known || err == nil {
+						t.Fatal("unbound native address-size form borrowed the default source contract", known, err)
+					}
+				}
+				if row.encoding == "evex" {
+					for _, control := range []struct {
+						name       string
+						index      int
+						set, clear byte
+					}{
+						{"mask", 3, 1, 0},
+						{"zero", 3, 0x80, 0},
+						{"broadcast", 3, 0x10, 0},
+						{"reserved length", 3, 0x60, 0},
+						{"fixed bit", 2, 0, 4},
+					} {
+						changed := append([]byte(nil), original...)
+						changed[control.index] = changed[control.index]&^control.clear | control.set
+						if _, _, known, err := decodedX86RawCLMULInstruction(changed, mode); !known || err == nil {
+							t.Fatal("reserved CLMUL field acquired a physical source", control.name, known, err)
+						}
+					}
+				}
+				if mode != 32 {
+					return // The complete existing mode64 root owns valid high-bank encodings.
+				}
+				if row.encoding == "legacy" {
+					for _, prefix := range []byte{0x41, 0x44, 0x48} {
+						changed := append([]byte{0x66, prefix}, original[1:]...)
+						if _, _, known, err := decodedX86RawCLMULInstruction(changed, mode); !known || err == nil {
+							t.Fatal("mode32 producer byte was reinterpreted as a legacy REX prefix", prefix, known, err)
+						}
+					}
+					return
+				}
+				// A physical raw binding cannot grant Go's mode32 source a
+				// high register bank. X is exercised only where it actually
+				// selects a register or SIB index, not an ignored VEX reg bit.
+				for _, control := range []struct {
+					name  string
+					index int
+					clear byte
+				}{
+					{"R", 1, 0x80},
+					{"B", 1, 0x20},
+					{"vvvv", 2, 0x40},
+					{"X", 1, 0x40},
+					{"R prime", 1, 0x10},
+					{"V prime", 3, 0x08},
+				} {
+					if row.encoding != "evex" && (control.name == "R prime" || control.name == "V prime" || control.name == "X" && !row.memory) {
+						continue
+					}
+					changed := append([]byte(nil), original...)
+					if control.name == "X" && row.memory {
+						modRM := len(changed) - 2
+						changed[modRM] = changed[modRM]&0x38 | 4
+						// SIB: numerical CX index, pointer BX base, scale one.
+						changed = append(changed[:modRM+1], 0x0b, changed[modRM+1])
+						if _, length, known, err := decodedX86RawCLMULInstruction(changed, mode); !known || err != nil || length != len(changed) {
+							t.Fatal("complete low-bank SIB control failed before its extension check", known, length, err)
+						}
+					}
+					changed[control.index] &^= control.clear
+					if _, _, known, err := decodedX86RawCLMULInstruction(changed, mode); !known || err == nil {
+						t.Fatal("mode32 extended physical field borrowed a low-bank source", control.name, known, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_clmul_native_origin_test.go b/x86_clmul_native_origin_test.go
new file mode 100644
index 000000000..a9f109c10
--- /dev/null
+++ b/x86_clmul_native_origin_test.go
@@ -0,0 +1,374 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+type x86CLMULNativeOriginCase struct {
+	encoding  string
+	width     int
+	w, memory bool
+	immediate byte
+}
+
+// Go has six rows: legacy X, VEX X/Y and EVEX X/Y/Z. Intel SDM
+// 325383-093US Vol. 2B 4-242..244 additionally binds both vector WIG values
+// and their actual mode32 encodings, independently of Go's named arity cap.
+func x86CLMULNativeOriginCases() []x86CLMULNativeOriginCase {
+	var rows []x86CLMULNativeOriginCase
+	for _, encoding := range []string{"legacy", "vex", "evex"} {
+		widths := []int{16}
+		if encoding != "legacy" {
+			widths = append(widths, 32)
+		}
+		if encoding == "evex" {
+			widths = append(widths, 64)
+		}
+		for _, width := range widths {
+			for _, w := range []bool{false, true} {
+				if encoding == "legacy" && w {
+					continue
+				}
+				for _, memory := range []bool{false, true} {
+					for _, immediate := range []byte{0, 1, 16, 17, 238, 239, 254, 255} {
+						rows = append(rows, x86CLMULNativeOriginCase{encoding, width, w, memory, immediate})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86CLMULNativeOriginCase) name() string {
+	return fmt.Sprintf("%s/%d/W%t/memory%t/selector%d", row.encoding, row.width, row.w, row.memory, row.immediate)
+}
+
+func (row x86CLMULNativeOriginCase) sourceInstruction(highDestination bool) string {
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[row.width]
+	source, destination := bank+"0", bank+"2"
+	if row.memory {
+		source = "(BX)"
+	}
+	if highDestination {
+		destination = bank + "18" // Force Go's otherwise indistinguishable EVEX X/Y row.
+	}
+	if row.encoding == "legacy" {
+		return fmt.Sprintf("PCLMULQDQ $%d,%s,X1", row.immediate, source)
+	}
+	return fmt.Sprintf("VPCLMULQDQ $%d,%s,%s1,%s", row.immediate, source, bank, destination)
+}
+
+func (row x86CLMULNativeOriginCase) code() []byte {
+	destination := 2
+	if row.encoding == "legacy" {
+		destination = 1
+	}
+	code := x86RawCLMULCode(row.encoding, row.width, 0, 1, destination, row.immediate)
+	if row.memory {
+		index := len(code) - 2
+		code[index] = code[index]&0x38 | 3 // Original (BX), not a selected-qword load.
+	}
+	if row.w {
+		code[2] |= 0x80
+	}
+	return code
+}
+
+func x86CLMULNativeOriginRequireGoBytes(t *testing.T, rows []x86CLMULNativeOriginCase) {
+	t.Helper()
+	var source strings.Builder
+	for _, row := range rows {
+		source.WriteString(row.sourceInstruction(row.encoding == "evex" && row.width != 64) + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String()+"RET")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("original Go CLMUL row bytes/PCs incomplete")
+	}
+	for index, row := range rows {
+		expected := row.code()
+		if row.encoding != "legacy" {
+			expected[2] &^= 0x80 // Go chooses W0; the independent LLVM22 oracle binds WIG.
+		}
+		if row.encoding == "evex" && row.width != 64 {
+			expected[1] ^= 0x10 // The only difference in Go's forced high-bank witness is R'.
+		}
+		if !bytes.Equal(code[pcs[index]:pcs[index+1]], expected) {
+			t.Fatal("independent original Go complete physical row changed", row.name(), code[pcs[index]:pcs[index+1]], expected)
+		}
+	}
+}
+
+func TestX86CLMULNativeCompletePhysicalGoDirectory(t *testing.T) {
+	rows := x86CLMULNativeOriginCases()
+	if len(rows) != 176 {
+		t.Fatal("complete physical WIG/source/selector directory changed", len(rows))
+	}
+	x86CLMULNativeOriginRequireGoBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range rows {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code())
+				form, known, err := x86CLMULProperties(ins.Op, ins, arch)
+				if !known || err != nil || form.legacy != (row.encoding == "legacy") || form.byteWidth != row.width ||
+					form.immediate != row.immediate || (form.memory >= 0) != row.memory || form.source != 1 {
+					t.Fatal("valid physical CLMUL lost typed selected-qword and whole-memory roles", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CLMULNativePhysicalBytesIndependentLLVM22(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	var input strings.Builder
+	rows := x86CLMULNativeOriginCases()
+	for _, row := range rows {
+		for _, value := range row.code() {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "x86_64-unknown-linux-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+				"--mattr=+pclmul,+avx,+avx512f,+avx512vl,+vpclmulqdq")
+			command.Stdin = strings.NewReader(input.String())
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+				t.Fatalf("independent complete physical CLMUL decoding failed: %v\n%s", err, output)
+			}
+			// LLVM may print one of Intel's four immediate aliases.
+			if count := len(regexp.MustCompile(`\bv?pclmul[a-z]*dq[ \t]+`).FindAll(output, -1)); count != len(rows) {
+				t.Fatalf("independent LLVM22 decoding lost physical CLMUL forms: %d\n%s", count, output)
+			}
+		})
+	}
+}
+
+func x86CLMULNativeOriginSource(row x86CLMULNativeOriginCase, arch, control string, raw, dead, unused bool) (string, string) {
+	word, move, suffix := goWordSize(arch), "MOVQ", "Q"
+	if arch == "386" {
+		move, suffix = "MOVL", "L"
+	}
+	extent, declaration := 3*word, "func Carryless(a,b,out *[144]byte)\n"
+	if unused {
+		extent++
+		declaration = "func Carryless(a,b,out *[144]byte,unused bool)\n"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Carryless(SB),4,$0-%d\n", extent)
+	if control == "numeric address" {
+		source.WriteString("MOVL $42,BX\n")
+	} else if control != "address" {
+		fmt.Fprintf(&source, "%s a+0(FP),BX\n", move)
+	}
+	fmt.Fprintf(&source, "%s b+%d(FP),AX\n%s out+%d(FP),DI\n", move, word, move, 2*word)
+	if !row.memory && control != "first" {
+		source.WriteString("VMOVUPS (BX),Z0\n")
+	}
+	if control != "second" {
+		source.WriteString("VMOVUPS (AX),Z1\n")
+	}
+	source.WriteString("MOVL $3,CX\nCMPL CX,$3\nSTD\n")
+	if raw {
+		for _, value := range row.code() {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+	} else {
+		source.WriteString(row.sourceInstruction(false) + "\n")
+	}
+	if !dead {
+		destination := "Z2"
+		if row.encoding == "legacy" {
+			destination = "Z1"
+		}
+		fmt.Fprintf(&source, "VMOVUPS %s,(DI)\n", destination)
+	}
+	fmt.Fprintf(&source, "PUSHF%s\nPOP%s CX\nANDL $0xcd5,CX\nMOVL CX,128(DI)\nCLD\nRET\n", suffix, suffix)
+	return source.String(), declaration
+}
+
+const x86CLMULNativeOriginBatchSize = 32
+
+func TestX86CLMULNativeInitializedFiveTargetsBatch00(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 0)
+}
+func TestX86CLMULNativeInitializedFiveTargetsBatch01(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 1)
+}
+func TestX86CLMULNativeInitializedFiveTargetsBatch02(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 2)
+}
+func TestX86CLMULNativeInitializedFiveTargetsBatch03(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 3)
+}
+func TestX86CLMULNativeInitializedFiveTargetsBatch04(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 4)
+}
+func TestX86CLMULNativeInitializedFiveTargetsBatch05(t *testing.T) {
+	x86CLMULNativeOriginObjectBatch(t, 5)
+}
+
+func x86CLMULNativeOriginObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	rows := x86CLMULNativeOriginCases()
+	start, end := batch*x86CLMULNativeOriginBatchSize, (batch+1)*x86CLMULNativeOriginBatchSize
+	if start < 0 || start >= len(rows) {
+		t.Fatal("invalid complete CLMUL object batch", batch)
+	}
+	if end > len(rows) {
+		end = len(rows)
+	}
+	rows = rows[start:end]
+	x86CLMULNativeOriginRequireGoBytes(t, rows)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				body, declaration := x86CLMULNativeOriginSource(row, target.arch, "", true, false, false)
+				name := fmt.Sprint("Carryless", start+index)
+				source.WriteString(strings.ReplaceAll(body, "Carryless", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Carryless", name))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original CLMUL lost its exact selected inputs, whole native tuple or defined FLAGS/DF", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "clmul-native-origin.ll", "clmul-native-origin.o", body)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				})
+			}
+		})
+	}
+}
+
+func TestX86CLMULNativeNamedCompleteMemoryAndRegisterControls(t *testing.T) {
+	for _, memory := range []bool{false, true} {
+		t.Run(fmt.Sprint("memory", memory), func(t *testing.T) {
+			var source, declarations strings.Builder
+			index := 0
+			for _, row := range x86CLMULNativeOriginCases() {
+				if row.w || row.memory != memory || row.encoding == "evex" && row.width != 64 {
+					continue // These named low banks select VEX; their physical EVEX controls are above.
+				}
+				body, declaration := x86CLMULNativeOriginSource(row, "amd64", "", false, false, false)
+				name := fmt.Sprint("Carryless", index)
+				index++
+				source.WriteString(strings.ReplaceAll(body, "Carryless", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Carryless", name))
+			}
+			if index != 32 {
+				t.Fatal("complete canonical named legacy/X/Y/Z controls changed", index)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api); ir == "" || err != nil {
+						t.Fatal("complete same-source named CLMUL control failed", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86CLMULNativeVoidAndUnusedBoolKeepInputRoles(t *testing.T) {
+	for _, row := range x86CLMULNativeOriginCases() {
+		for _, control := range []string{"first", "second", "address", "numeric address"} {
+			if control == "first" && row.memory ||
+				(control == "address" || control == "numeric address") && !row.memory {
+				continue
+			}
+			t.Run(row.name()+"/"+control, func(t *testing.T) {
+				for _, arch := range []string{"386", "amd64"} {
+					for _, unused := range []bool{false, true} {
+						// Unknown selected numerical bytes may propagate to dead
+						// results. Native address obligations cannot be discarded.
+						for _, dead := range []bool{false, true} {
+							if dead && (control == "first" || control == "second") {
+								continue
+							}
+							source, declaration := x86CLMULNativeOriginSource(row, arch, control, true, dead, unused)
+							if control == "numeric address" {
+								x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+							}
+							for _, api := range []string{"text", "module", "Go"} {
+								triple := x86AddressMemoryTargets(arch)[0]
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+								if control == "numeric address" {
+									read := fmt.Sprintf("load volatile <%d x i8>", row.width)
+									if row.encoding == "legacy" {
+										read = "asm sideeffect \"pclmulqdq "
+									}
+									if err != nil || !strings.Contains(ir, read) ||
+										row.encoding == "legacy" && !strings.Contains(ir, "~{memory}") {
+										t.Fatal("complete NUM address lost its original CLMUL memory effect", arch, dead, unused, api, err)
+									}
+									x86NumericNativeAddressObject(t, ir, triple)
+									continue
+								}
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("raw CLMUL invented a selected byte or native pointer role", arch, dead, unused, api, err)
+								}
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CLMULNativeInitializedUnusedBoolAndDeadForms(t *testing.T) {
+	rows := x86CLMULNativeOriginCases()
+	for start := 0; start < len(rows); start += x86CLMULNativeOriginBatchSize {
+		end := start + x86CLMULNativeOriginBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint(start/x86CLMULNativeOriginBatchSize), func(t *testing.T) {
+			for _, target := range x86RawReturnTargets {
+				t.Run(target.triple, func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows[start:end] {
+						for _, dead := range []bool{false, true} {
+							body, declaration := x86CLMULNativeOriginSource(row, target.arch, "", true, dead, true)
+							name := fmt.Sprintf("Carryless%dDead%t", start+index, dead)
+							source.WriteString(strings.ReplaceAll(body, "Carryless", name))
+							declarations.WriteString(strings.ReplaceAll(declaration, "Carryless", name))
+						}
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							if ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api); err != nil || ir == "" {
+								t.Fatal("unused bool or dead product changed valid original CLMUL inputs/native access", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_clmul_native_state_test.go b/x86_clmul_native_state_test.go
new file mode 100644
index 000000000..be87697c6
--- /dev/null
+++ b/x86_clmul_native_state_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86CLMULNativeEverySelectedByteAndWholeMemoryRole(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86CLMULNativeOriginCases() {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code())
+				destination := 2
+				if row.encoding == "legacy" {
+					destination = 1
+				}
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						state := x86RawMoveInitializedState()
+						if missing >= 0 {
+							state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+						}
+						expected := state.clone()
+						defined := x86CallerVectorByteMask(int64(row.width))
+						if missing >= 0 && missing < row.width {
+							// Independent SDM selectors: bit4 chooses source0,
+							// bit0 source1; other immediate bits are ignored.
+							selected := int(row.immediate & 1)
+							if input == 0 {
+								selected = int(row.immediate >> 4 & 1)
+							}
+							if (input == 1 || input == 0 && !row.memory) && missing%16/8 == selected {
+								defined &^= uint64(65535) << uint(missing/16*16)
+							}
+						}
+						expected.writeVector(destination, row.width, defined, row.encoding == "legacy")
+						if accepted, known := x86LoweredCLMULStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, expected) {
+							t.Fatal("CLMUL invented a selected qword, consumed an ignored one or changed independent state", input, missing, accepted, known)
+						}
+					}
+				}
+				if row.memory {
+					state := x86RawMoveInitializedState()
+					before := state.clone()
+					if accepted, known := x86ResultCLMULStep(ins, &state, nil, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("standalone result observer acquired paired native memory")
+					}
+					state.pointerGP[3] = false // A paired read can consume complete numerical BX.
+					before = state.clone()
+					if accepted, known := x86LoweredCLMULStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("numerical CLMUL read changed independent state or acquired a pointer role")
+					}
+					for _, available := range []uint8{0, 1} {
+						partial := before.clone()
+						partial.gp[3] = available
+						unchanged := partial.clone()
+						if accepted, _ := x86LoweredCLMULStep(ins, &partial, nil, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+							t.Fatal("CLMUL acquired unknown or partial numerical address bytes", available)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CLMULNativeEditedSelectorAndOriginRejectAtomically(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86CLMULNativeOriginCases() {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, row.code())
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"selector", func(ins *Instr) { ins.Args[0].Imm ^= 1 }},
+					{"ignored selector bit", func(ins *Instr) { ins.Args[0].Imm ^= 2 }},
+					{"source selector", func(ins *Instr) { ins.x86SourceRaw.args[0].Imm ^= 1 }},
+					{"opcode", func(ins *Instr) { ins.Op = "VPXOR" }},
+					{"source opcode", func(ins *Instr) { ins.x86SourceRaw.op = "MOVL" }},
+					{"data", func(ins *Instr) {
+						if row.memory {
+							ins.Args[1].Mem.Off++
+						} else {
+							ins.Args[1].Reg = "X4"
+						}
+					}},
+					{"source data", func(ins *Instr) { ins.x86SourceRaw.args[1] = Operand{} }},
+					{"destination", func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = "X4" }},
+					{"vector width", func(ins *Instr) { ins.x86VectorBytes += 16 }},
+					{"source width", func(ins *Instr) { ins.x86SourceRaw.vectorBytes += 16 }},
+					{"address width", func(ins *Instr) { ins.x86AddressBits = 16 }},
+					{"address override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+					{"raw return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+					{"numerical certificate", func(ins *Instr) { ins.x86NumericalRead = new(x86NumericalReadCertificate) }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					control.edit(&changed)
+					state := x86RawMoveInitializedState()
+					before := state.clone()
+					if accepted, _ := x86LoweredCLMULStep(changed, &state, nil, arch); accepted ||
+						x86RawCLMULSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited selector, tuple or source acquired a CLMUL native result or partially changed state", control.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_comi_compile_only_role_test.go b/x86_comi_compile_only_role_test.go
new file mode 100644
index 000000000..63e517833
--- /dev/null
+++ b/x86_comi_compile_only_role_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/token"
+	"testing"
+)
+
+func TestX86COMICompileOnlyOwnerDoesNotRequireRuntimeTransport(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_comi_fixture_compile_unix_test.go")
+	owner := functions["TestX86COMINativeRuntimeFixturesCompileOnly"]
+	if owner == nil {
+		t.Fatal("missing original complete COMI object/link owner")
+	}
+	calls := fixedLocalLeaseCalls(owner.Body)
+	if calls["fixedLocalPackedCompileOnlyTools"] != 1 || calls["x86FloatCompareExecutionTools"] != 0 {
+		t.Error("complete COMI compilation/linking must reuse the object-only selector, not CPU/emulator execution tools")
+	}
+	for _, function := range []string{"TestX86COMINativeRuntimeFixturesCompileOnly", "x86COMICompileFixture", "x86COMICompileOriginalGo"} {
+		body := functions[function]
+		if body == nil {
+			t.Fatal("missing original object/Go/C compile chain", function)
+		}
+		for name, count := range fixedLocalLeaseCalls(body.Body) {
+			if count != 0 && (name == "t.Skip" || name == "t.Skipf" || name == "execution.run" || name == "execution.compileAndRunLLVM") {
+				t.Error("compile/link-only owner gained a skip or executable claim", function, name)
+			}
+		}
+	}
+}
+
+func TestX86COMICompileOnlyOwnerRetainsAll252OriginalFixtures(t *testing.T) {
+	functions := fixedLocalLeaseFunctions(t, "amd64_comi_fixture_compile_unix_test.go")
+	owner := functions["TestX86COMINativeRuntimeFixturesCompileOnly"]
+	if owner == nil {
+		t.Fatal("missing original complete COMI object/link owner")
+	}
+	calls := fixedLocalLeaseCalls(owner.Body)
+	for name, count := range map[string]int{
+		"x86COMIRawNativeFixture": 1, "x86COMIDeadFaultFixture": 1,
+		"x86ScalarCompareAFRuntimeCases": 1, "x86ScalarCompareAFOriginalFiles": 1,
+		"x86COMIConstantOracle": 1, "x86COMICompileOriginalGo": 2,
+		"x86COMICompileFixture": 4,
+	} {
+		if calls[name] != count {
+			t.Error("original six-fixture/Go-prior inventory changed", name, calls[name], count)
+		}
+	}
+	integers := make(map[string]int)
+	axes := make(map[string]int)
+	ast.Inspect(owner.Body, func(node ast.Node) bool {
+		if value, ok := node.(*ast.BasicLit); ok && value.Kind == token.INT {
+			integers[value.Value]++
+		}
+		if value, ok := node.(*ast.Ident); ok && (value.Name == "x86FloatCompareVEX" || value.Name == "x86FloatCompareEVEX") {
+			axes[value.Name]++
+		}
+		return true
+	})
+	for number, count := range map[string]int{"12": 1, "24": 2, "48": 1, "96": 1, "252": 1} {
+		if integers[number] != count {
+			t.Error("24 raw +12 dead +2x48 FLAGS +24/96 MXCSR original kernels changed", number, integers[number])
+		}
+	}
+	if axes["x86FloatCompareVEX"] != 1 || axes["x86FloatCompareEVEX"] != 2 {
+		t.Error("complete two-generation FLAGS/MXCSR loop was reduced", axes)
+	}
+	fixture := functions["x86COMICompileFixture"]
+	if fixture == nil {
+		t.Fatal("missing complete original fixture compile/link implementation")
+	}
+	for name, count := range map[string]int{
+		"goAssemblerOracleOutput": 1, "x86ScalarFPBitViewAPI": 2,
+		"compileLLVMToObject": 1, "x86FloatCompareCaptureCommand": 2,
+	} {
+		if observed := fixedLocalLeaseCalls(fixture.Body)[name]; observed != count {
+			t.Error("original three-API Linux objects or host C link attachment was reduced", name, observed)
+		}
+	}
+}
diff --git a/x86_comi_original_format_test.go b/x86_comi_original_format_test.go
new file mode 100644
index 000000000..fac83bcc2
--- /dev/null
+++ b/x86_comi_original_format_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Keep the complete original source, Go object and public missing-input
+// Context. Private format objects use the unchanged native COMI lowerer;
+// implementation slots are not numerical, pointer or native-entry witnesses.
+func x86COMIOriginalFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	original, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	file, err := normalizeX86RawFile(original, arch)
+	if err != nil {
+		t.Fatal("complete original COMI formats could not normalize", err)
+	}
+	units := *file
+	units.Funcs = nil
+	physical, unbound := 0, 0
+	for _, function := range file.Funcs {
+		last := len(function.Instrs) - 1
+		if last < 2 || function.Instrs[0].Op != OpTEXT || !x86InstructionFormatTerminal(function.Instrs[last]) {
+			t.Fatal("complete COMI format lost its TEXT/return/fault envelope")
+		}
+		unit := function
+		unit.Instrs = append([]Instr(nil), function.Instrs[:1]...)
+		for _, instruction := range function.Instrs[1:last] {
+			_, known, err := x86COMIProperties(instruction, arch)
+			if !known {
+				t.Fatal("original COMI format contains another instruction", instruction.Raw)
+			}
+			if err != nil {
+				if arch != "386" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 high-X") {
+					t.Fatal("original COMI format became malformed", err)
+				}
+				unbound++ // Original Go accepts it; no physical high-X mode32 object is claimed.
+				continue
+			}
+			unit.Instrs = append(unit.Instrs, instruction)
+			physical++
+		}
+		unit.Instrs = append(unit.Instrs, function.Instrs[last])
+		units.Funcs = append(units.Funcs, unit)
+	}
+	if physical == 0 {
+		t.Fatal("complete original COMI directory lost every physical format")
+	}
+	ir := x86InstructionFormatObjectUnit(t, &units, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return c.lowerVectorScalarFlagCompare(instruction.Op, instruction)
+		})
+	if strings.Count(ir, "~{flags},~{fpsr},~{memory}") != physical {
+		t.Fatal("private format lost an actual whole COMI opcode", physical)
+	}
+	t.Logf("complete original Go/public Context retained; %d physical COMI formats, %d Go-accepted mode32 high-X Context rows; no initialized or native execution claim", physical, unbound)
+	return ir
+}
+
+func x86COMIOriginalProbeFormatObject(t *testing.T, file *File, arch, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	for _, function := range file.Funcs {
+		text, valid := x86RawReplaySourceText(function)
+		if !valid {
+			t.Fatal("original COMI probe lost its complete raw source")
+		}
+		source.WriteString(text)
+	}
+	ir := x86COMIOriginalFormatObject(t, source.String(), arch, triple)
+	if !strings.Contains(ir, "ud2") || !strings.Contains(ir, "unreachable") {
+		t.Fatal("private original COMI probe lost its actual terminal fault")
+	}
+	return ir
+}
+
+func x86COMICompileOriginalFormatObjects(t *testing.T, llc, triple, name, ir string) {
+	t.Helper()
+	for index, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+		compileLLVMToObject(t, llc, triple, fmt.Sprintf("%s-%d.ll", name, index), fmt.Sprintf("%s-%d.o", name, index), body)
+	}
+}
diff --git a/x86_comi_raw_producer_tdd_test.go b/x86_comi_raw_producer_tdd_test.go
new file mode 100644
index 000000000..909d78a80
--- /dev/null
+++ b/x86_comi_raw_producer_tdd_test.go
@@ -0,0 +1,345 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86COMIOriginalProducerObjects(t *testing.T, source, declarations, arch, triple string) {
+	t.Helper()
+	x86LEAActualTargetGoObject(t, arch, triple, source)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original COMI producer objects require LLVM22")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete initialized original COMI producer rejected", err)
+			}
+			optimized := x86DwordProductIROptimize(t, ir)
+			for _, pipeline := range []struct{ body, level string }{
+				{ir, "-O0"}, {ir, "-O2"}, {optimized, "-O2"},
+			} {
+				x86PackedStringCompileObject(t, llc, triple, pipeline.body, pipeline.level)
+			}
+		})
+	}
+}
+
+func TestX86COMIOriginalRawNativeProducerObjectsThreeAMD64Targets(t *testing.T) {
+	source, _, mainC, count := x86COMIRawNativeFixture(t)
+	if count != 24 || strings.Count(source, "TEXT ") != 24 ||
+		strings.Count(source, "VMOVUPS (AX),Z") != 24 || strings.Count(source, "VMOVUPS (BX),Z") != 24 ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(mainC))) != "220d60304277ec428c85b577d20628b7f171bbfda06f92212b16ed3c25a68d48" {
+		t.Fatal("original complete 24-kernel ASM/C inventory changed")
+	}
+	// Retain the actual complete generated source, including original Go bytes,
+	// rather than claiming that a different low-bank or reduced-width program
+	// executed this native oracle. This test compiles objects; it never runs it.
+	t.Logf("original COMI ASM sha256=%x\n%s", sha256.Sum256([]byte(source)), source)
+	t.Logf("original COMI C sha256=%x\n%s", sha256.Sum256([]byte(mainC)), mainC)
+	var declarations strings.Builder
+	for index := 0; index < count; index++ {
+		fmt.Fprintf(&declarations, "func flagcompare%d(a,b,out *byte)\n", index)
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86COMIOriginalProducerObjects(t, source, declarations.String(), "amd64", triple)
+		})
+	}
+}
+
+type x86COMIRawProducerRow struct {
+	op       string
+	encoding string
+	form     string
+	code     []byte
+}
+
+func x86COMIRawProducerRows(t *testing.T) []x86COMIRawProducerRow {
+	t.Helper()
+	var rows []x86COMIRawProducerRow
+	for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, encoding := range []string{"VEX", "EVEX"} {
+			for _, form := range []string{"register", "memory", "sae"} {
+				if encoding == "VEX" && form == "sae" {
+					continue
+				}
+				operation := op + " X1,X0"
+				if form == "memory" {
+					operation = op + " (BX),X0"
+				}
+				if encoding == "EVEX" {
+					// The actual low-bank SAE encoding is an independent Go
+					// prior. Clear only b for plain EVEX and use the exact BX
+					// ModRM for memory; LLVM MC below separately proves both
+					// physical modes, not our decoder or Go's BYTE acceptance.
+					operation = op + ".SAE X1,X0"
+				}
+				code := assembleX87ControlBytes(t, "amd64", "TEXT probe(SB),4,$0-0\n"+operation+"\nRET\n")
+				if len(code) < 2 || code[len(code)-1] != 0xc3 {
+					t.Fatal("actual Go COMI byte capture lost its terminal RET", operation, code)
+				}
+				code = append([]byte(nil), code[:len(code)-1]...)
+				if encoding == "EVEX" {
+					if len(code) != 6 || code[0] != 0x62 || code[3]&0x10 == 0 || code[5] != 0xc1 {
+						t.Fatal("actual Go low-bank SAE physical envelope changed", operation, code)
+					}
+					if form != "sae" {
+						code[3] &^= 0x10
+					}
+					if form == "memory" {
+						code[5] = 0x03 // r/m=BX, no displacement; destination X0.
+					}
+				}
+				for _, mode := range []int{32, 64} {
+					x86NumericalNativeRequireMC(t, code, mode, 1, "+avx,+avx512f,+avx512vl")
+				}
+				rows = append(rows, x86COMIRawProducerRow{op, encoding, form, code})
+			}
+		}
+	}
+	if len(rows) != 20 {
+		t.Fatal("complete four-member VEX/EVEX register/memory/SAE directory changed", len(rows))
+	}
+	return rows
+}
+
+func x86COMIRawProducerProgram(row x86COMIRawProducerRow, arch, name string, raw bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s a+0(FP),AX\n%s b+%d(FP),BX\n%s out+%d(FP),DI\n",
+		name, word*3, move, move, word, move, word*2)
+	for _, register := range []int{0, 1, 2} {
+		fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", register)
+	}
+	source.WriteString("VMOVUPS (BX),Z1\nMOVL $2147483647,CX\nADDL $1,CX\n")
+	if raw {
+		source.WriteString(x86RawDisplacementDirectives(row.code))
+	} else {
+		op, input := row.op, "X1"
+		if row.form == "memory" {
+			input = "(BX)"
+		}
+		if row.form == "sae" {
+			op += ".SAE"
+		}
+		fmt.Fprintf(&source, "%s %s,X0\n", op, input)
+	}
+	source.WriteString("SETEQ (DI)\nSETCS 1(DI)\nSETPS 2(DI)\nSETMI 3(DI)\nSETOS 4(DI)\nVMOVUPS Z0,8(DI)\nVMOVUPS Z1,72(DI)\nRET\n")
+	return source.String(), fmt.Sprintf("func %s(a,b *[64]byte,out *[136]byte)\n", name)
+}
+
+func TestX86COMIRawAndNamedNativeProducerFiveTargetObjects(t *testing.T) {
+	rows := x86COMIRawProducerRows(t)
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				for _, raw := range []bool{false, true} {
+					body, declaration := x86COMIRawProducerProgram(row, target.arch, fmt.Sprintf("Compare%dRaw%t", index, raw), raw)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+				}
+			}
+			x86COMIOriginalProducerObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86COMIRawNativeProducerWholeSourceIdentity(t *testing.T) {
+	rows := x86COMIRawProducerRows(t)
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range rows {
+			source, declaration := x86COMIRawProducerProgram(row, arch, "Value", true)
+			x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], source)
+			check := x86LegacyFloatReplayCheck(t, arch, source, declaration)
+			for _, mutation := range []string{"valid", "origin", "encoded", "generation", "opcode", "operand",
+				"origin-operand", "origin-mode", "missing-replay", "replay-mode", "producer", "spelling",
+				"original-bytes", "decoded-snapshot", "normalized-snapshot", "all-generation-snapshots"} {
+				t.Run(arch+"/"+row.op+"/"+row.encoding+"/"+row.form+"/"+mutation, func(t *testing.T) {
+					file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+					if err != nil || len(file.Funcs) != 1 {
+						t.Fatal("actual Go/LLVM-accepted whole COMI producer failed to normalize", err)
+					}
+					original, ordinal := file.Funcs[0], -1
+					for index, instruction := range original.Instrs {
+						if _, known, _ := x86COMIProperties(instruction, arch); known {
+							if ordinal >= 0 {
+								t.Fatal("ambiguous original COMI producer")
+							}
+							ordinal = index
+						}
+					}
+					if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("original COMI lacks its complete immutable replay")
+					}
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					instruction := &candidate.Instrs[ordinal]
+					switch mutation {
+					case "origin":
+						instruction.x86SourceRaw = nil
+					case "encoded":
+						instruction.x86Encoded = !instruction.x86Encoded
+					case "generation":
+						instruction.x86ScalarFlagCompareEVEX = !instruction.x86ScalarFlagCompareEVEX
+					case "opcode":
+						instruction.Op = "VCOMISS"
+						if row.op == "VCOMISS" {
+							instruction.Op = "VUCOMISS"
+						}
+					case "operand":
+						instruction.Args[0] = Operand{Kind: OpReg, Reg: "X2"}
+					case "origin-operand":
+						instruction.x86SourceRaw.args[1].Reg = "X2"
+					case "origin-mode":
+						instruction.x86SourceRaw.addressBits = 16
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "spelling":
+						instruction.Raw += " changed"
+					default:
+						if mutation != "valid" {
+							replay := *original.x86RawReplay
+							replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+							replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+							switch mutation {
+							case "replay-mode":
+								replay.goarch = "386"
+								if arch == "386" {
+									replay.goarch = "amd64"
+								}
+							case "original-bytes":
+								replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+							case "decoded-snapshot", "all-generation-snapshots":
+								replay.decoded[ordinal].x86ScalarFlagCompareEVEX = !replay.decoded[ordinal].x86ScalarFlagCompareEVEX
+							case "normalized-snapshot":
+								replay.normalized[ordinal].Raw += " changed"
+							}
+							if mutation == "all-generation-snapshots" {
+								instruction.x86ScalarFlagCompareEVEX = !instruction.x86ScalarFlagCompareEVEX
+								replay.normalized[ordinal].x86ScalarFlagCompareEVEX = instruction.x86ScalarFlagCompareEVEX
+							}
+							candidate.x86RawReplay = &replay
+						}
+					}
+					err = check(candidate)
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("complete original COMI native continuation rejected", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited original COMI source borrowed raw/physical identity", mutation, err)
+					}
+					if original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("mutating a clone changed the independent original replay")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86COMIRawNativeProducerCannotInventMissingInputs(t *testing.T) {
+	rows := x86COMIRawProducerRows(t)
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		var prior strings.Builder
+		var cases []struct{ name, source, declaration string }
+		for _, row := range rows {
+			for _, raw := range []bool{false, true} {
+				for _, missing := range []string{"first-pointer", "second-pointer", "output-pointer", "whole-upper-bytes", "future-pointer"} {
+					source, declaration := x86COMIRawProducerProgram(row, arch, fmt.Sprint("Missing", len(cases)), raw)
+					from, to := move+" a+0(FP),AX\n", ""
+					switch missing {
+					case "second-pointer":
+						from = fmt.Sprintf("%s b+%d(FP),BX\n", move, word)
+					case "output-pointer":
+						from = fmt.Sprintf("%s out+%d(FP),DI\n", move, word*2)
+					case "whole-upper-bytes":
+						from, to = "VMOVUPS (AX),Z0\n", "MOVSS (AX),X0\n"
+					}
+					changed := strings.Replace(source, from, to, 1)
+					if missing == "future-pointer" {
+						changed = strings.Replace(changed, "VMOVUPS Z0,8(DI)\n", from+"VMOVUPS Z0,8(DI)\n", 1)
+					}
+					if changed == source {
+						t.Fatal("independent missing-input mutation did not apply")
+					}
+					prior.WriteString(changed)
+					name := fmt.Sprintf("%s/%s/%s/%s/raw=%t/%s", arch, row.op, row.encoding, row.form, raw, missing)
+					cases = append(cases, struct{ name, source, declaration string }{name, changed, declaration})
+				}
+			}
+		}
+		// One complete real object retains all 200 exact named functions,
+		// rather than rebuilding the same selected SDK prior for each API.
+		if len(cases) != 200 {
+			t.Fatal("complete missing-input counterexample inventory changed", len(cases))
+		}
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String())
+		for _, row := range cases {
+			t.Run(row.name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+					if arch == "amd64" && strings.Contains(row.name, "/raw=false/whole-upper-bytes") {
+						x86VectorScratchCodegenControl(t, row.source, row.declaration, arch, x86AddressMemoryTargets(arch)[0], ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("COMI continuation supplied an absent reaching input", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86COMIRawProducerPreservesIndependentSourceDomains(t *testing.T) {
+	rows := x86COMIRawProducerRows(t)
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range rows {
+			t.Run(arch+"/"+row.op+"/"+row.encoding+"/"+row.form, func(t *testing.T) {
+				source, _ := x86COMIRawProducerProgram(row, arch, "Value", true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil || len(file.Funcs) != 1 || file.Funcs[0].x86RawReplay == nil ||
+					file.Funcs[0].x86RawReplay.validate(file.Funcs[0], arch) != nil {
+					t.Fatal("original source-domain fixture lacks its complete raw replay", err)
+				}
+				count := 0
+				for _, instruction := range file.Funcs[0].Instrs {
+					if _, known, _ := x86COMIProperties(instruction, arch); !known {
+						continue
+					}
+					count++
+					if got := x86ResultDirectionAfterSource(instruction, x86ResultDirectionBackward, arch); got != x86ResultDirectionBackward {
+						t.Error("scalar status comparison lost independent DF")
+					}
+					if !x86ResultPreservesPrivateStorage(instruction, arch) {
+						t.Error("scalar status comparison lost existing private stack or ID")
+					}
+					var before [16]bool
+					before[0], before[2], before[3], before[7] = true, true, true, true
+					if got := x86ResultCallerAddressesAfter(instruction, before, nil, arch); got != before {
+						t.Error("scalar status comparison revoked unrelated existing GP identities")
+					}
+				}
+				if count != 1 {
+					t.Fatal("ambiguous source-domain comparison inventory", count)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_comi_rip_literal_obligation_test.go b/x86_comi_rip_literal_obligation_test.go
new file mode 100644
index 000000000..4d2a26156
--- /dev/null
+++ b/x86_comi_rip_literal_obligation_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86COMIRIPLiteralRow struct {
+	op, encoding string
+	code         []byte
+	width        int
+}
+
+func x86COMIRIPLiteralRows(t *testing.T) []x86COMIRIPLiteralRow {
+	t.Helper()
+	var rows []x86COMIRIPLiteralRow
+	var original strings.Builder
+	for _, op := range []string{"VCOMISS", "VCOMISD", "VUCOMISS", "VUCOMISD"} {
+		for _, encoding := range []string{"vex2", "vex3", "evex"} {
+			width := 4
+			if strings.HasSuffix(op, "SD") {
+				width = 8
+			}
+			row := x86COMIRIPLiteralRow{op, encoding, x86RawScalarFlagCompareLiteral(op, encoding), width}
+			// Disassemble only the complete physical instruction. RET and
+			// the source-local scalar pool are independently retained below.
+			x86NumericalNativeRequireMC(t, row.code[:len(row.code)-width-1], 64, 1, "+avx,+avx512f,+avx512vl")
+			original.WriteString(x86COMIRIPLiteralSource(row, fmt.Sprint("Original", len(rows)), "PXOR X0,X0\n"))
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 12 {
+		t.Fatal("complete scalar COMI literal directory changed")
+	}
+	goAssemblerOracleOutput(t, "amd64", original.String(), "", true)
+	return rows
+}
+
+func x86COMIRIPLiteralSource(row x86COMIRIPLiteralRow, name, setup string) string {
+	return "TEXT ·" + name + "(SB),4,$0-0\n" + setup + x86RawDisplacementDirectives(row.code)
+}
+
+func x86COMIRIPLiteralNormalized(t *testing.T, source string) (*File, int) {
+	t.Helper()
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+	if err != nil || len(file.Funcs) != 1 || len(file.Data) != 1 {
+		t.Fatal("complete scalar COMI source lost its actual literal pool", err)
+	}
+	ordinal := -1
+	for index, instruction := range file.Funcs[0].Instrs {
+		if instruction.x86RIPLiteral {
+			if ordinal >= 0 {
+				t.Fatal("ambiguous scalar COMI source literal")
+			}
+			ordinal = index
+		}
+	}
+	if ordinal < 0 || file.Funcs[0].x86RawReplay == nil || file.Funcs[0].x86RawReplay.validate(file.Funcs[0], "amd64") != nil {
+		t.Fatal("complete scalar COMI literal lost its immutable producer")
+	}
+	return file, ordinal
+}
+
+func TestX86COMIRIPLiteralCompleteInitializedSources(t *testing.T) {
+	for _, row := range x86COMIRIPLiteralRows(t) {
+		t.Run(row.op+"/"+row.encoding, func(t *testing.T) {
+			source := x86COMIRIPLiteralSource(row, "Value", "PXOR X0,X0\n")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, target := range x86AddressMemoryTargets("amd64") {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()\n", "amd64", target, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete initialized scalar COMI literal needs its existing DATA/RET owner", err)
+						}
+						if strings.Count(ir, "~{flags},~{fpsr},~{memory}") != 1 || !strings.Contains(ir, fmt.Sprintf("elementtype([%d x i8])", row.width)) {
+							t.Fatal("scalar COMI literal lost its exact whole native read/MXCSR effect")
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86COMIRIPLiteralDoesNotInventInputsOrSourceOwnership(t *testing.T) {
+	for _, row := range x86COMIRIPLiteralRows(t) {
+		t.Run(row.op+"/"+row.encoding, func(t *testing.T) {
+			for _, setup := range []string{"", "MOVB $0,AL\nMOVL AX,X0\n"} {
+				source := x86COMIRIPLiteralSource(row, "Value", setup)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("missing-input-%t/%s", setup != "", api), func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()\n", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar COMI literal supplied missing or partial X0 bytes", err)
+						}
+					})
+				}
+			}
+			source := x86COMIRIPLiteralSource(row, "Value", "PXOR X0,X0\n")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, mutation := range []string{"valid", "origin", "arch", "generation", "encoded", "operand", "tuple",
+				"short-data", "missing-replay", "producer", "original-bytes", "data-bytes", "data-extent"} {
+				t.Run(mutation, func(t *testing.T) {
+					file, ordinal := x86COMIRIPLiteralNormalized(t, source)
+					original := file.Funcs[0]
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					instruction := &candidate.Instrs[ordinal]
+					resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+					signatures := map[string]FuncSig{"Value": {Name: "Value", Ret: Void}}
+					context := amd64Ctx{fpScalarSource: candidate, sig: signatures["Value"], fpSourceSig: signatures["Value"],
+						goarch: "amd64", targetTriple: "x86_64-unknown-linux-gnu", resolve: resolve,
+						fpScalarData: x86LoweredScalarDataReads(file, resolve, signatures, "amd64")}
+					switch mutation {
+					case "origin":
+						instruction.x86SourceRaw = nil
+					case "arch":
+						instruction.x86SourceRaw.comi.arch = "386"
+					case "generation":
+						instruction.x86ScalarFlagCompareEVEX = !instruction.x86ScalarFlagCompareEVEX
+					case "encoded":
+						instruction.x86Encoded = !instruction.x86Encoded
+					case "operand":
+						instruction.Args[0].Sym = "external(SB)"
+					case "tuple":
+						instruction.x86RIPMemoryRead.width--
+					case "short-data":
+						address, valid := x86StaticSBReadAddress(instruction.Args[0], "amd64")
+						if !valid || context.fpScalarData[address] != int64(row.width) {
+							t.Fatal("original literal lacks its exact independent DATA extent")
+						}
+						context.fpScalarData[address]--
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "original-bytes":
+						replay := *original.x86RawReplay
+						replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+						candidate.x86RawReplay = &replay
+					case "data-bytes":
+						file.Data[0].Payload = append([]byte(nil), file.Data[0].Payload...)
+						file.Data[0].Payload[0] ^= 1
+					case "data-extent":
+						file.Data[0].Width--
+						file.Data[0].Payload = append([]byte(nil), file.Data[0].Payload[:len(file.Data[0].Payload)-1]...)
+					}
+					var err error
+					if strings.HasPrefix(mutation, "data-") {
+						if _, err := dataStmtPayload(file.Data[0]); err != nil {
+							t.Fatal("literal mutation is not a valid DATA statement", err)
+						}
+						var ir string
+						ir, err = Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: signatures, ResolveSym: resolve})
+						if ir != "" {
+							t.Fatal("changed literal DATA supplied a public translation")
+						}
+					} else {
+						if mutation != "valid" && mutation != "short-data" && reflect.DeepEqual(candidate, original) {
+							t.Fatal("literal mutation did not alter its original source identity")
+						}
+						context.fpScalarSource = candidate
+						err = context.checkLoweredScalarFPResultInitialization()
+					}
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("existing literal owner lost its complete initialized COMI source", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("COMI literal borrowed missing data or a different source/entry identity", mutation, err)
+					}
+					if original.x86RawReplay.validate(original, "amd64") != nil {
+						t.Fatal("a literal clone mutated its independently sealed original producer")
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_compact_expand_objects_test.go b/x86_compact_expand_objects_test.go
new file mode 100644
index 000000000..d0b1dc149
--- /dev/null
+++ b/x86_compact_expand_objects_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86CompactExpandInitializedWholeFamilyObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for _, op := range x86CompactExpandResultMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, mode := range []string{"unmasked", "merge", "zero"} {
+				for _, alias := range []bool{false, true} {
+					name := fmt.Sprintf("Value%s%s%sAlias%t", op, bank, mode, alias)
+					instruction := x86CompactExpandResultInstruction(op, bank, mode)
+					if alias {
+						instruction = strings.Replace(instruction, bank+"0", bank+"1", 1)
+					}
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\nMOVL $7,AX\nKMOVD AX,K1\n"+
+						"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n%s\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", name, instruction)
+					fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+					names = append(names, name)
+				}
+			}
+		}
+	}
+	if len(names) != 216 {
+		t.Fatal("complete initialized family denominator changed", len(names))
+	}
+	for _, target := range dataRelocationTargets {
+		if target.arch != ArchAMD64 {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			dataRelocationGoObject(t, source.String(), target.goos, target.goarch, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized compact/expand family rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, optimized := range []bool{false, true} {
+						objectIR := ir
+						if optimized {
+							objectIR = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, objectIR, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86CompactExpandRequireAllDefinitions(t *testing.T, ir string, names []string) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range names {
+		function := module.NamedFunction(name)
+		if function.IsNil() || function.FirstBasicBlock().IsNil() {
+			t.Fatal("complete family omitted an original function body", name)
+		}
+	}
+}
diff --git a/x86_compact_logical_fp_results_test.go b/x86_compact_logical_fp_results_test.go
new file mode 100644
index 000000000..0f910ac87
--- /dev/null
+++ b/x86_compact_logical_fp_results_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A complete logical FP span is not one native pointer: Go scalar results
+// have separate LLVM storage. Keep the original Go object and all public APIs
+// independent of the register-only and native-memory emitter observations.
+func TestX86PackedCompressLogicalFPResultsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []string{"VCOMPRESSPS", "VCOMPRESSPD", "VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ"} {
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				for _, mode := range []string{"unmasked", "merge"} {
+					var results []string
+					var body strings.Builder
+					for index := 0; index < width.bytes/8; index++ {
+						results = append(results, fmt.Sprintf("r%d uint64", index))
+						for _, half := range []int{0, 4} {
+							fmt.Fprintf(&body, "MOVL $-1,r%d+%d(FP)\n", index, 8+index*8+half)
+						}
+					}
+					instruction := strings.Replace(x86CompactExpandResultInstruction(opcode, width.bank, mode), width.bank+"1", "r0+8(FP)", 1)
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nKMOVQ mask+0(FP),K1\nVPXORD Z0,Z0,Z0\n%s%s\nRET\n",
+						width.bytes+8, body.String(), instruction)
+					declaration := "func Value(mask uint64) (" + strings.Join(results, ",") + ")"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+opcode+"/"+width.bank+"/"+mode+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete initialized logical result fields failed", err)
+							}
+							if strings.Contains(ir, "call void @llvm.masked.compressstore.") {
+								t.Fatal("independent logical result fields were treated as one native pointer")
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_compact_logical_memory_test.go b/x86_compact_logical_memory_test.go
new file mode 100644
index 000000000..d0fa362e2
--- /dev/null
+++ b/x86_compact_logical_memory_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86CompactExpandLogicalMemoryAvailability(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range x86CompactExpandResultMembers {
+			expand := strings.Contains(opcode, "EXPAND")
+			modes := []string{"unmasked", "merge"}
+			if expand {
+				modes = append(modes, "zero")
+			}
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				for _, mode := range modes {
+					t.Run(arch+"/"+opcode+"/"+width.bank+"/"+mode, func(t *testing.T) {
+						row := x86CompactExpandResultInstruction(opcode, width.bank, mode)
+						from, to := width.bank+"1", "ret+0(FP)"
+						if expand {
+							from, to = width.bank+"0", "input+0(FP)"
+						}
+						instruction := x86ScalarLaneInstruction(t, strings.Replace(row, from, to, 1))
+						state := x86ResultState{fp: make([]bool, width.bytes), masks: [8]bool{1: mode != "unmasked"},
+							flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						owned := make([]bool, width.bytes)
+						for index := range owned {
+							owned[index] = true
+							state.fp[index] = expand || mode != "unmasked"
+						}
+						state.writeVector(0, 64, ^uint64(0), false)
+						state.writeVector(1, 64, ^uint64(0), false)
+						before, expected := state.clone(), state.clone()
+						boundary := int64(0)
+						if expand {
+							boundary = int64(width.bytes)
+							expected.writeVector(1, width.bytes, x86CallerVectorByteMask(int64(width.bytes)), false)
+						} else {
+							for index := range expected.fp {
+								expected.fp[index] = true
+							}
+						}
+						if !x86ResultTransfer(instruction, &state, owned, boundary, arch) || !reflect.DeepEqual(state, expected) {
+							t.Fatal("complete logical memory bytes did not produce the exact family effect", instruction.Raw)
+						}
+						if expand || mode != "unmasked" {
+							for missing := range before.fp {
+								partial := before.clone()
+								partial.fp[missing] = false
+								unchanged := partial.clone()
+								if x86ResultTransfer(instruction, &partial, owned, boundary, arch) || !reflect.DeepEqual(partial, unchanged) {
+									t.Fatal("unknown memory byte became an active read or guaranteed masked write", missing)
+								}
+							}
+						}
+						for missing := range owned {
+							partialOwned := append([]bool(nil), owned...)
+							partialOwned[missing] = false
+							partial := before.clone()
+							if x86ResultTransfer(instruction, &partial, partialOwned, boundary, arch) || !reflect.DeepEqual(partial, before) {
+								t.Fatal("missing field changed part of a rejected logical memory transfer", missing)
+							}
+						}
+						if !expand {
+							partial := before.clone()
+							if x86ResultTransfer(instruction, &partial, owned, int64(width.bytes), arch) || !reflect.DeepEqual(partial, before) {
+								t.Fatal("compact store acquired write permission for incoming FP parameters")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedExpandLogicalFPAcrossScalarFieldsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []string{"VEXPANDPS", "VEXPANDPD", "VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ"} {
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					var arguments []string
+					for index := 0; index < width.bytes/8; index++ {
+						arguments = append(arguments, fmt.Sprintf("a%d uint64", index))
+					}
+					arguments = append(arguments, "mask uint64")
+					declaration := "func Value(" + strings.Join(arguments, ",") + ") uint32"
+					instruction := strings.Replace(x86CompactExpandResultInstruction(opcode, width.bank, mode), width.bank+"0", "a0+0(FP)", 1)
+					extract, register := "", "X1"
+					if width.bytes == 32 {
+						extract, register = "VEXTRACTI128 $1,Y1,X2\n", "X2"
+					} else if width.bytes == 64 {
+						extract, register = "VEXTRACTI32X4 $3,Z1,X2\n", "X2"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nKMOVQ mask+%d(FP),K1\nVPXORD Z1,Z1,Z1\n%s\n%sPEXTRD $3,%s,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+						width.bytes+12, width.bytes, instruction, extract, register, width.bytes+8)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+opcode+"/"+width.bank+"/"+mode+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete Go scalar fields did not supply their logical compact source", err)
+							}
+							if mode != "unmasked" {
+								x86ExpandRequireEveryScalarInput(t, ir, width.bytes/8)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86ExpandRequireEveryScalarInput(t *testing.T, ir string, inputs int) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	function := module.NamedFunction("Value")
+	if function.IsNil() {
+		t.Fatal("logical field observer lost the actual function")
+	}
+	for index := 0; index < inputs; index++ {
+		if function.Param(index).FirstUse().IsNil() {
+			t.Fatal("a full-mask-dependent scalar field was lost behind another field's alloca", index)
+		}
+	}
+}
diff --git a/x86_compact_native_memory_test.go b/x86_compact_native_memory_test.go
new file mode 100644
index 000000000..3e41a2190
--- /dev/null
+++ b/x86_compact_native_memory_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86CompactNativeFixture(arch, op, bank, mode string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	mask := ""
+	if mode != "plain" {
+		mask = "K1,"
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	operation := fmt.Sprintf("%s %s0,%s1(DI)", op, bank, mask)
+	if strings.Contains(op, "EXPAND") {
+		operation = fmt.Sprintf("%s 1(DI),%s%s0\nVMOVDQU64 %s0,65(DI)", op, mask, bank, bank)
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\nMOVL mask+%d(FP),AX\n"+
+		"KMOVD AX,K1\nVPXORD Z0,Z0,Z0\n%s\nMOVL $7,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+		2*word+4, move, word, operation, 2*word)
+	return source, "func Value(p *[128]byte, mask uint32) uint32"
+}
+
+func TestX86CompactNativeMemorySequencesThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for _, op := range x86CompactExpandResultMembers {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if mode == "zero" && !strings.Contains(op, "EXPAND") {
+							continue // EVEX.z memory stores are #UD, not a positive.
+						}
+						body, declaration := x86CompactNativeFixture(target.arch, op, bank, mode)
+						name := fmt.Sprintf("Value%d", len(names))
+						names = append(names, name)
+						source.WriteString(strings.ReplaceAll(body, "Value", name))
+						declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+					}
+				}
+			}
+			if len(names) != 90 {
+				t.Fatal("complete compact memory denominator changed", len(names))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete native compact memory sequence rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					if regexp.MustCompile(`(?m)^  (?:%[^ =]+ = )?call [^\n]*@llvm\.masked\.(?:expandload|compressstore)\.`).MatchString(ir) {
+						t.Fatal("native compact access must retain observable guarded loads/stores")
+					}
+					for _, optimized := range []bool{false, true} {
+						objectIR := ir
+						if optimized {
+							objectIR = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, objectIR, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86CompactNativeMemoryCannotInventSourceOrDestinationFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86CompactExpandResultMembers {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				source, declaration := x86CompactNativeFixture(arch, op, bank, "merge")
+				mutations := map[string]string{
+					"unknown-source": strings.Replace(source, "VPXORD Z0,Z0,Z0", "NOP", 1),
+					"unknown-mask":   strings.Replace(source, "KMOVD AX,K1", "NOP", 1),
+					"unknown-base":   strings.ReplaceAll(source, "(DI)", "(SI)"),
+					"unknown-index":  strings.ReplaceAll(source, "(DI)", "(DI)(SI*1)"),
+					"pointer-index":  strings.ReplaceAll(source, "(DI)", "(DI)(DI*1)"),
+					"missing-result": strings.Replace(source, "MOVL AX,ret+", "// MOVL AX,ret+", 1),
+				}
+				for name, source := range mutations {
+					t.Run(arch+"/"+op+"/"+bank+"/"+name, func(t *testing.T) {
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if arch == "amd64" && name == "unknown-source" {
+								x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+							} else if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("native compact sequence acquired an unknown input/result", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_compact_zero_oracle_test.go b/x86_compact_zero_oracle_test.go
new file mode 100644
index 000000000..c1230999c
--- /dev/null
+++ b/x86_compact_zero_oracle_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// LLVM22 does not fold every constant vector.compress call. Check its actual
+// typed zero inputs instead of requiring a particular optimization spelling.
+// This deliberately small observer is not an instruction interpreter or a
+// native-execution receipt. Unknown/poison values and unrelated calls fail.
+func x86CompactExpandKnownZero(value llvm.Value, depth int) bool {
+	if value.IsNil() || depth == 0 {
+		return false
+	}
+	if !value.IsAConstantInt().IsNil() {
+		return value.ZExtValue() == 0
+	}
+	if !value.IsAConstantAggregateZero().IsNil() {
+		return true
+	}
+	if value.IsAInstruction().IsNil() {
+		return false
+	}
+	switch value.InstructionOpcode() {
+	case llvm.BitCast, llvm.Trunc, llvm.ZExt, llvm.SExt:
+		return x86CompactExpandKnownZero(value.Operand(0), depth-1)
+	case llvm.ExtractElement:
+		vector, index := value.Operand(0), value.Operand(1)
+		return !index.IsAConstantInt().IsNil() && vector.Type().TypeKind() == llvm.VectorTypeKind &&
+			index.ZExtValue() < uint64(vector.Type().VectorSize()) && x86CompactExpandKnownZero(vector, depth-1)
+	case llvm.Call:
+		function := value.CalledValue()
+		if function.IsAFunction().IsNil() || value.OperandsCount() != 4 ||
+			function.IntrinsicID() != llvm.LookupIntrinsicID("llvm.experimental.vector.compress") {
+			return false
+		}
+		mask := value.Operand(1)
+		if mask.Type().TypeKind() != llvm.VectorTypeKind {
+			return false
+		}
+		if mask.IsAConstantAggregateZero().IsNil() {
+			if mask.IsAConstantVector().IsNil() || mask.OperandsCount() != mask.Type().VectorSize() {
+				return false
+			}
+			for index := 0; index < mask.OperandsCount(); index++ {
+				if mask.Operand(index).IsAConstantInt().IsNil() {
+					return false
+				}
+			}
+		}
+		return x86CompactExpandKnownZero(value.Operand(0), depth-1) &&
+			x86CompactExpandKnownZero(value.Operand(2), depth-1)
+	}
+	return false
+}
+
+func x86CompactExpandZeroReturn(t *testing.T, ir string) bool {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	function := module.NamedFunction("Value")
+	if function.IsNil() {
+		t.Fatal("complete compact/expand fixture lost its actual entry")
+	}
+	returns := 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+			if instruction.IsAReturnInst().IsNil() {
+				continue
+			}
+			returns++
+			if instruction.OperandsCount() != 1 || !x86CompactExpandKnownZero(instruction.Operand(0), 16) {
+				return false
+			}
+		}
+	}
+	return returns == 1
+}
+
+func TestX86CompactZeroObserverRejectsNonzeroPoisonAndForeignCalls(t *testing.T) {
+	for _, row := range []struct {
+		name, source, mask, passthrough, callee string
+		index                                   int
+		zero                                    bool
+	}{
+		{"zero", "zeroinitializer", "<i1 true,i1 true,i1 true,i1 false>", "zeroinitializer", "llvm.experimental.vector.compress.v4i32", 0, true},
+		{"nonzero-source", "<i32 1,i32 2,i32 3,i32 4>", "<i1 true,i1 true,i1 true,i1 false>", "zeroinitializer", "llvm.experimental.vector.compress.v4i32", 0, false},
+		{"nonzero-tail", "zeroinitializer", "zeroinitializer", "<i32 1,i32 2,i32 3,i32 4>", "llvm.experimental.vector.compress.v4i32", 0, false},
+		{"poison-mask", "zeroinitializer", "poison", "zeroinitializer", "llvm.experimental.vector.compress.v4i32", 0, false},
+		{"foreign-call", "zeroinitializer", "zeroinitializer", "zeroinitializer", "ordinary_compress", 0, false},
+		{"poison-index", "zeroinitializer", "zeroinitializer", "zeroinitializer", "llvm.experimental.vector.compress.v4i32", 4, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			ir := fmt.Sprintf(`declare <4 x i32> @%s(<4 x i32>,<4 x i1>,<4 x i32>)
+define i32 @Value() {
+  %%packed = call <4 x i32> @%s(<4 x i32> %s,<4 x i1> %s,<4 x i32> %s)
+  %%result = extractelement <4 x i32> %%packed,i32 %d
+  ret i32 %%result
+}
+`, row.callee, row.callee, row.source, row.mask, row.passthrough, row.index)
+			if got := x86CompactExpandZeroReturn(t, ir); got != row.zero {
+				t.Fatal("typed zero observer accepted a nonzero, poison or foreign value", got)
+			}
+		})
+	}
+}
diff --git a/x86_compiler_helper_namespace.go b/x86_compiler_helper_namespace.go
new file mode 100644
index 000000000..bed053107
--- /dev/null
+++ b/x86_compiler_helper_namespace.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Compiler-local naming only. Every original LLVM-reachable source name is
+// reserved; this supplies no declaration, entry, storage or source authority.
+func x86CompilerHelperNamespace(file *File, resolve func(string) string, sigs map[string]FuncSig, family string) string {
+	var names []string
+	reserve := func(symbol string) {
+		names = append(names, symbol)
+	}
+	for name, sig := range sigs {
+		// Signature keys and names are already final LLVM symbols.
+		reserve(name)
+		reserve(sig.Name)
+	}
+	for _, fn := range file.Funcs {
+		name := resolve(fn.Sym)
+		reserve(funcSigSymbol(name, sigs[name]))
+		for _, ins := range fn.Instrs {
+			for _, operand := range ins.Args {
+				symbol := ""
+				if operand.Kind == OpSym {
+					symbol = strings.TrimSpace(strings.TrimPrefix(operand.Sym, "*"))
+				} else if operand.Kind == OpMem {
+					symbol = operand.Mem.Sym
+				}
+				if base, _, ok := parseSBRef(symbol); ok && base != "" {
+					// Only SB identities can become LLVM globals; local branch
+					// labels and FP/AUTO component names never reach ResolveSym.
+					base = strings.TrimPrefix(base, "$")
+					reserve(resolveDataAddressSymbol(file, base, resolve, sigs))
+				}
+			}
+		}
+	}
+	for _, data := range file.Data {
+		reserve(resolveDataSymbol(data.Sym, resolve))
+		if data.Addr != "" {
+			if symbol, _, err := dataAddress(data); err == nil {
+				reserve(resolveDataAddressSymbol(file, symbol, resolve, sigs))
+			}
+		}
+	}
+	for _, global := range file.Globl {
+		reserve(resolveDataSymbol(global.Sym, resolve))
+	}
+	for number := 0; ; number++ {
+		prefix := fmt.Sprintf("__plan9asm_%s_%d_", family, number)
+		collision := false
+		for _, name := range names {
+			if strings.Contains(name, prefix) {
+				collision = true
+				break
+			}
+		}
+		if !collision {
+			return prefix
+		}
+	}
+}
diff --git a/x86_conflict_funnel_contract_test.go b/x86_conflict_funnel_contract_test.go
new file mode 100644
index 000000000..1385873a6
--- /dev/null
+++ b/x86_conflict_funnel_contract_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Keep this inventory independent of implementation maps and operand parsers.
+func x86ConflictFunnelRows() []struct {
+	op       string
+	bits     int
+	unary    bool
+	variable bool
+} {
+	return []struct {
+		op       string
+		bits     int
+		unary    bool
+		variable bool
+	}{
+		{"VPCONFLICTD", 32, true, false},
+		{"VPCONFLICTQ", 64, true, false},
+		{"VPSHLDW", 16, false, false},
+		{"VPSHLDD", 32, false, false},
+		{"VPSHLDQ", 64, false, false},
+		{"VPSHRDW", 16, false, false},
+		{"VPSHRDD", 32, false, false},
+		{"VPSHRDQ", 64, false, false},
+		{"VPSHLDVW", 16, false, true},
+		{"VPSHLDVD", 32, false, true},
+		{"VPSHLDVQ", 64, false, true},
+		{"VPSHRDVW", 16, false, true},
+		{"VPSHRDVD", 32, false, true},
+		{"VPSHRDVQ", 64, false, true},
+	}
+}
+
+func x86ConflictFunnelInstruction(op, bank, first, mask string, unary, variable bool) string {
+	arguments := first + ","
+	if !unary {
+		arguments += bank + "1,"
+		if !variable {
+			arguments = "$255," + arguments
+		}
+	}
+	return op + " " + arguments + mask + bank + "2"
+}
+
+func TestX86ConflictFunnelEveryInputByteAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ConflictFunnelRows() {
+			if arch == "386" && !row.unary && !row.variable {
+				continue // Stock Go's named frontend has a three-operand limit.
+			}
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if arch == "386" && !row.unary && mode != "plain" {
+						continue
+					}
+					t.Run(arch+"/"+row.op+"/"+bank+"/"+mode, func(t *testing.T) {
+						op, mask := row.op, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							op += ".Z"
+						}
+						ins := x86ScalarLaneInstruction(t, x86ConflictFunnelInstruction(op, bank, bank+"0", mask, row.unary, row.variable))
+						width := amd64VectorByteWidth(Reg(bank + "0"))
+						inputs := []int{0}
+						if !row.unary {
+							inputs = append(inputs, 1)
+						}
+						if row.variable || mode == "merge" {
+							inputs = append(inputs, 2)
+						}
+						for _, input := range inputs {
+							for missing := -1; missing < width; missing++ {
+								state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+								for register := 0; register < 3; register++ {
+									state.writeVector(register, 64, ^uint64(0), false)
+								}
+								state.masks[1], state.pointerGP[3], state.gp[1] = true, true, 0x55
+								if missing >= 0 {
+									state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+								}
+								want := state.clone()
+								if missing < 0 {
+									want.writeVector(2, width, x86CallerVectorByteMask(int64(width)), false)
+								}
+								accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+								if accepted != (missing < 0) || !reflect.DeepEqual(state, want) {
+									t.Fatal("complete numerical inputs, upper aliases or independent state changed", input, missing, accepted)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86ConflictFunnelInputObjects(t *testing.T, bank string) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count, batches, inBatch := 0, 0, 0
+			flush := func() {
+				if inBatch == 0 || inBatch > 64 {
+					t.Fatal("invalid bounded family batch", inBatch)
+				}
+				t.Run(fmt.Sprintf("batch%02d", batches), func(t *testing.T) {
+					x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+				})
+				batches++
+				inBatch = 0
+				source.Reset()
+				declarations.Reset()
+			}
+			for _, row := range x86ConflictFunnelRows() {
+				if target.arch == "386" && !row.unary && !row.variable {
+					continue
+				}
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if target.arch == "386" && !row.unary && mode != "plain" {
+						continue
+					}
+					inputs := []string{bank + "0", "(SI)"}
+					if row.bits != 16 {
+						inputs = append(inputs, "broadcast")
+					}
+					for _, input := range inputs {
+						op, mask, operand := row.op, "", input
+						if input == "broadcast" {
+							op, operand = op+".BCST", "(SI)"
+						}
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							op += ".Z"
+						}
+						instruction := x86ConflictFunnelInstruction(op, bank, operand, mask, row.unary, row.variable)
+						name := fmt.Sprint("Value", count)
+						fmt.Fprintf(&declarations, "func %s(out,a,b,old *[64]byte)\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n"+
+							"%s a+%d(FP),SI\n%s b+%d(FP),BX\n%s old+%d(FP),CX\n"+
+							"VMOVUPS (SI),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\n"+
+							"MOVL $-1431655766,AX\nKMOVD AX,K1\nSTC\n%s\nVMOVUPS Z2,(DI)\nRET\n",
+							name, 4*word, move, move, word, move, 2*word, move, 3*word, instruction)
+						count++
+						inBatch++
+						if inBatch == 64 {
+							flush()
+						}
+					}
+				}
+			}
+			want := 114
+			if target.arch == "386" {
+				want = 34
+			}
+			if count != want {
+				t.Fatal("independent complete family/memory/mask inventory changed", count, want)
+			}
+			if inBatch != 0 {
+				flush()
+			}
+			if batches != (want+63)/64 {
+				t.Fatal("incomplete family batch union", batches)
+			}
+		})
+	}
+}
+
+func TestX86ConflictFunnelCompleteXInputObjects(t *testing.T) {
+	x86ConflictFunnelInputObjects(t, "X")
+}
+
+func TestX86ConflictFunnelCompleteYInputObjects(t *testing.T) {
+	x86ConflictFunnelInputObjects(t, "Y")
+}
+
+func TestX86ConflictFunnelCompleteZInputObjects(t *testing.T) {
+	x86ConflictFunnelInputObjects(t, "Z")
+}
+
+func TestX86ConflictFunnelVoidAndUnusedBoolNeedActualInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ConflictFunnelRows() {
+			if target.arch == "386" && !row.unary && !row.variable {
+				continue
+			}
+			for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+				instruction := x86ConflictFunnelInstruction(row.op, "X", "X0", "", row.unary, row.variable)
+				source := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if target.arch == "amd64" && declaration == "func Value(unused bool)" {
+						x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead result silently acquired numerical input bytes", target, row.op, declaration, api, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_continuation_objects_test.go b/x86_continuation_objects_test.go
new file mode 100644
index 000000000..0e372bff2
--- /dev/null
+++ b/x86_continuation_objects_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ContinuationWholeCFGFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("continuation object owner requires LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word := "Q"
+			if target.arch == "386" {
+				word = "L"
+			}
+			for _, dispatch := range []string{"memory", "register", "copied-target"} {
+				t.Run(dispatch, func(t *testing.T) {
+					source, options := x86ContinuationResultFixture(t, target.arch, true)
+					options.TargetTriple = target.triple
+					if dispatch != "memory" {
+						body := " MOV" + word + " (SI),AX\n JMP AX"
+						if dispatch == "copied-target" {
+							body = " MOV" + word + " (SI),AX\n MOV" + word + " AX,CX\n MOV" + word + " $0,AX\n JMP CX"
+						}
+						source = strings.Replace(source, " JMP (SI)", body, 1)
+					}
+					if strings.Count(source, "TEXT ") != 4 || strings.Count(source, "GLOBL ") != 1 {
+						t.Fatal("whole source fixture denominator changed")
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "owned-module"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ContinuationResultAPI(t, source, options, api)
+							if err != nil {
+								t.Fatal(err)
+							}
+							for _, optimized := range []bool{false, true} {
+								input := ir
+								if optimized {
+									input = x86UndefinedTrapOptimizedIR(t, input)
+								}
+								for _, level := range []string{"-O0", "-O2"} {
+									t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+										x86PackedStringCompileObject(t, llc, target.triple, input, level)
+									})
+								}
+							}
+							bad := strings.Replace(source, " MOV"+word+" BX,result+", " MOVB BX,result+", 1)
+							if bad == source {
+								t.Fatal("partial-result negative did not preserve/mutate complete source")
+							}
+							if output, err := x86ContinuationResultAPI(t, bad, options, api); output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("a partial result escaped the coalesced whole-source proof", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_continuation_result.go b/x86_continuation_result.go
new file mode 100644
index 000000000..b5c86a475
--- /dev/null
+++ b/x86_continuation_result.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+type x86ContinuationAddress struct {
+	kind         uint8 // 1: exact table object, 2: opaque code in one root.
+	symbol, root string
+}
+
+type x86ContinuationResultState struct {
+	flow        *x86ContinuationFlow // Immutable, independently authenticated source.
+	gp          [16]x86ContinuationAddress
+	written     []bool // Initializer cells only; never numerical bytes.
+	tablesValid bool   // A possible native alias store revokes future table loads.
+	invalid     bool   // A mismatched CFG state revokes, never panics or invents facts.
+}
+
+func (view *x86ContinuationFlow) bind(fn Func, sig FuncSig, arch string) (accepted bool) {
+	graph := view.graph
+	defer func() {
+		if !accepted && graph != nil {
+			graph.revoked.Store(true)
+		}
+	}()
+	if graph == nil || graph.self != graph || graph.revoked.Load() || graph.arch != arch || graph.flows[fn.Sym] != view ||
+		fn.Sym != view.symbol || !reflect.DeepEqual(graph.original, x86ContinuationSnapshot(graph.origin)) {
+		return false
+	}
+	plan, err := graph.planHash()
+	if err != nil || plan != graph.plan {
+		return false
+	}
+	expected, found := graph.signatures[graph.symbols[fn.Sym]]
+	if expected.Name == "" {
+		expected.Name = graph.symbols[fn.Sym]
+	}
+	if sig.Name == "" {
+		sig.Name = graph.symbols[fn.Sym]
+	}
+	if !found || !reflect.DeepEqual(sig, expected) {
+		return false
+	}
+	plain := fn
+	plain.x86ContinuationFlow, plain.x86ResultFlowBudget = nil, nil
+	copy := x86ContinuationSnapshot(&File{Arch: ArchAMD64, Funcs: []Func{plain}}).Funcs[0]
+	for _, original := range graph.prepared.Funcs {
+		if original.Sym == fn.Sym && reflect.DeepEqual(original, copy) {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *amd64Ctx) checkContinuationResultSource() error {
+	view := c.fpScalarSource.x86ContinuationFlow
+	if view == nil || view.graph == nil || view.graph.triple != c.targetTriple || !view.bind(c.fpScalarSource, c.fpSourceSig, c.goarch) {
+		return x86ContinuationContext("lowering lost its complete coalesced source or actual root declaration")
+	}
+	emitted := c.sig
+	if c.fpSourceSig.Attrs == "" && emitted.Attrs == c.fpFeatureAttrs {
+		emitted.Attrs = "" // Only the renderer's exact independent inference handoff.
+	}
+	if !reflect.DeepEqual(emitted, c.fpSourceSig) {
+		return x86ContinuationContext("emitted declaration differs from its actual root")
+	}
+	return nil
+}
+
+func (state *x86ContinuationResultState) checkReturn() bool {
+	if state.invalid {
+		return false
+	}
+	for _, table := range state.flow.graph.tables {
+		if table.initializer != state.flow.symbol {
+			continue
+		}
+		for index := table.first; index < table.first+table.cells; index++ {
+			if index >= len(state.written) || !state.written[index] {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// Opaque code and table addresses have only these complete full-word effects.
+// A table load relies on the already explicit closed-target contract; it does
+// not assert that an initializer has run or that any code bytes are readable.
+func x86ContinuationResultStep(ordinal int, ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	role := state.continuation
+	if role == nil {
+		return false, false
+	}
+	if role.invalid {
+		return false, true
+	}
+	graph := role.flow.graph
+	word := x86ResultPointerWord(arch)
+	move, lea := Op("MOVQ"), Op("LEAQ")
+	if arch == "386" {
+		move, lea = "MOVL", "LEAL"
+	}
+	form := x86SourceMoveInstruction(ins, arch)
+	register := func(arg Operand) (int, bool) {
+		index, _, ok := x86ResultGP(arg.Reg, word, arch)
+		return index, ok && arg.Kind == OpReg
+	}
+	address := func(arg Operand) x86ContinuationAddress {
+		if index, ok := register(arg); ok {
+			return role.gp[index]
+		}
+		return x86ContinuationAddress{}
+	}
+	write := func(arg Operand, value x86ContinuationAddress) bool {
+		index, ok := register(arg)
+		if !ok {
+			return false
+		}
+		role.gp[index] = value
+		state.gp[index], state.canonicalGP[index] = 0, 0
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		state.callerAddressOrigin[index], state.resultAddressGP[index] = 0, x86ResultSlotAddress{}
+		return true
+	}
+	tableMemory := func(arg Operand) (x86ContinuationTable, int64, bool) {
+		if !role.tablesValid && !state.shapeOnly {
+			return x86ContinuationTable{}, 0, false
+		}
+		if location, ok := x86StaticSBReadAddress(arg, arch); ok {
+			table, exists := graph.tables[location.symbol]
+			return table, location.offset, exists && location.offset >= 0 && location.offset%word == 0 && location.offset <= table.bytes-word
+		}
+		if arg.Kind != OpMem || !x86ResultSlotMemory(arg.Mem) {
+			return x86ContinuationTable{}, 0, false
+		}
+		base := address(Operand{Kind: OpReg, Reg: arg.Mem.Base})
+		if base.kind == 1 {
+			table := graph.tables[base.symbol]
+			return table, arg.Mem.Off, arg.Mem.Off >= 0 && arg.Mem.Off%word == 0 && arg.Mem.Off <= table.bytes-word
+		}
+		if state.shapeOnly {
+			// The source-wide pass checks shape, never a reaching table fact.
+			for _, table := range graph.tables {
+				if table.root == role.flow.root && arg.Mem.Off >= 0 && arg.Mem.Off%word == 0 && arg.Mem.Off <= table.bytes-word {
+					return table, arg.Mem.Off, true
+				}
+			}
+		}
+		return x86ContinuationTable{}, 0, false
+	}
+	if role.flow.indirect[ordinal] {
+		if form.Op != OpJMP || len(form.Args) != 1 {
+			return false, true
+		}
+		if value := address(form.Args[0]); value.kind == 2 && value.root == role.flow.root {
+			return true, true
+		}
+		if table, _, ok := tableMemory(form.Args[0]); ok && table.root == role.flow.root {
+			return true, true
+		}
+		return state.shapeOnly && form.Args[0].Kind == OpReg, true
+	}
+	if len(form.Args) == 2 {
+		first, last := form.Args[0], form.Args[1]
+		if form.Op == lea || form.Op == move && first.Kind == OpSym && strings.HasPrefix(first.Sym, "$") {
+			operand := first
+			if operand.Kind == OpSym {
+				operand.Sym = strings.TrimPrefix(operand.Sym, "$")
+			}
+			if location, ok := x86StaticSBReadAddress(operand, arch); ok {
+				if target, found := graph.addresses[location.symbol]; found {
+					shape := form
+					shape.Op, shape.Args = lea, []Operand{operand, last}
+					width, err := x86LEAOperandWidth(shape, arch)
+					return location.offset == 0 && err == nil && width == word && write(last, x86ContinuationAddress{kind: 2, symbol: location.symbol, root: target.root}), true
+				}
+				if table, found := graph.tables[location.symbol]; found {
+					shape := form
+					shape.Op, shape.Args = lea, []Operand{operand, last}
+					width, err := x86LEAOperandWidth(shape, arch)
+					return location.offset == 0 && err == nil && width == word && write(last, x86ContinuationAddress{kind: 1, symbol: location.symbol, root: table.root}), true
+				}
+			}
+		}
+		if form.Op == move {
+			if state.shapeOnly {
+				if location, ok := x86StaticSBReadAddress(last, arch); ok {
+					table, found := graph.tables[location.symbol]
+					_, gp := register(first)
+					return found && gp && table.initializer == role.flow.symbol && location.offset >= 0 && location.offset%word == 0 && location.offset <= table.bytes-word, true
+				}
+			}
+			if value := address(first); value.kind != 0 {
+				if _, ok := register(last); ok {
+					return write(last, value), true
+				}
+				if location, ok := x86StaticSBReadAddress(last, arch); ok {
+					table, found := graph.tables[location.symbol]
+					if !found || value.kind != 2 || table.root != value.root || table.initializer != role.flow.symbol ||
+						location.offset < 0 || location.offset%word != 0 || location.offset > table.bytes-word {
+						return false, true
+					}
+					role.written[table.first+int(location.offset/word)] = true
+					return true, true
+				}
+				return false, true // No code/table address may escape to data or FP.
+			}
+			if table, _, ok := tableMemory(first); ok {
+				if table.root != role.flow.root {
+					return false, true
+				}
+				return write(last, x86ContinuationAddress{kind: 2, root: table.root}), true
+			}
+		}
+		// Only this paired ordinary scalar store consumes an actual declared
+		// incoming address. It grants no extent, native backing or FP write.
+		width := x86RawReturnScalarMoveBytes(form.Op)
+		if width > 0 && !(width == 8 && arch == "386") && last.Kind == OpMem &&
+			last.Mem.Sym == "" && x86OrdinaryNativeMemoryOperand(last, arch) &&
+			x86ResultIncomingPointerAddressIdentity(last, state, arch) &&
+			(first.Kind == OpReg || first.Kind == OpImm) && x86ResultRead(first, width, state, owned, arch) {
+			role.tablesValid = false // The old Ptr contract is not a noalias promise.
+			return true, true
+		}
+	}
+	return false, false
+}
+
+// An unregistered use cannot turn opaque addresses into initialized values.
+// Complete overwrite is allowed, but every partial/implicit write revokes the
+// entire old identity through the shared typed GP footprint.
+func x86ContinuationOrdinaryUses(ins Instr, state *x86ResultState, arch string) bool {
+	role := state.continuation
+	if role == nil {
+		return true
+	}
+	for index, operand := range ins.Args {
+		memory, static := x86SBMemoryAddressRole(operand, arch)
+		if static {
+			name, _, valid := parseSBRef(memory.Sym)
+			_, table := role.flow.graph.tables[name]
+			_, code := role.flow.graph.addresses[name]
+			if valid && (table || code) {
+				return false // Only the explicit full-word opaque effect may consume it.
+			}
+		}
+		if operand.Kind == OpReg {
+			root, _, ok := x86ResultGP(operand.Reg, 1, arch)
+			if !ok {
+				root, _, ok = x86ResultGP(operand.Reg, x86ResultPointerWord(arch), arch)
+			}
+			if ok && role.gp[root].kind != 0 && !x86ResultSlotOverwrite(ins, index, arch) {
+				return false
+			}
+		}
+		if operand.Kind == OpMem {
+			for _, reg := range []Reg{operand.Mem.Base, operand.Mem.Index} {
+				root, _, ok := x86ResultGP(reg, x86ResultPointerWord(arch), arch)
+				if ok && role.gp[root].kind != 0 {
+					return false
+				}
+			}
+		}
+	}
+	return true
+}
+
+func x86ContinuationRevokeOverwrites(ins Instr, state *x86ResultState, arch string) {
+	if state.continuation == nil {
+		return
+	}
+	var before [16]bool
+	for index, value := range state.continuation.gp {
+		before[index] = value.kind != 0
+	}
+	after := x86ResultCallerAddressesAfter(ins, before, nil, arch)
+	for index := range before {
+		if !after[index] {
+			state.continuation.gp[index] = x86ContinuationAddress{}
+		}
+	}
+}
diff --git a/x86_continuation_result_test.go b/x86_continuation_result_test.go
new file mode 100644
index 000000000..5d19b1b65
--- /dev/null
+++ b/x86_continuation_result_test.go
@@ -0,0 +1,579 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86ContinuationResultFixture(t *testing.T, arch string, vectors bool) (string, Options) {
+	t.Helper()
+	word, size, typ, triple := "Q", 8, "uint64", "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		word, size, typ, triple = "L", 4, "uint32", "i386-unknown-linux-gnu"
+	}
+	source := fmt.Sprintf(`TEXT ·Prepare(SB),$0-0
+ LEA%s ·Advance(SB),AX
+ MOV%s AX,dispatch<>(SB)
+ RET
+GLOBL dispatch<>(SB),16,$%d
+TEXT ·Evaluate(SB),$0-%d
+ MOV%s out+0(FP),DI
+ MOV%s value+%d(FP),BX
+ LEA%s dispatch<>(SB),SI
+ TEST%s BX,BX
+ JMP (SI)
+TEXT ·Advance(SB),$0-0
+ JEQ finished
+ ADD%s $1,BX
+finished:
+ JMP ·Finish(SB)
+TEXT ·Finish(SB),$0-0
+ MOV%s BX,(DI)
+ MOV%s BX,result+%d(FP)
+ RET
+`, word, word, size, size*3, word, word, size, word, word, word, word, word, size*2)
+	if vectors {
+		source = strings.Replace(source, " LEA"+word+" dispatch<>(SB),SI", " MOV"+word+" BX,X0\n MOV"+word+" X0,BX\n LEA"+word+" dispatch<>(SB),SI", 1)
+	}
+	pkg := mustGoPackage(t, "continuationproof", "package p\nfunc Prepare()\nfunc Evaluate(out *"+typ+", value "+typ+") "+typ+"\nfunc Advance()\nfunc Finish()\n")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source, Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs,
+		X86TailGroups: []X86TailGroup{{Root: "·Evaluate", Helpers: []string{"·Advance", "·Finish"}}}}
+}
+
+func x86ContinuationResultAPI(t *testing.T, source string, options Options, api string) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	var module llvm.Module
+	if api == "module" {
+		module, err = TranslateModule(file, options)
+	} else {
+		if api != "owned-module" {
+			t.Fatal("unknown Options API", api)
+		}
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err = TranslateModuleInContext(ctx, file, options)
+	}
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func TestX86ContinuationWholeCFGResultProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, vectors := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(fmt.Sprintf("%s/vectors-%t/%s", arch, vectors, api), func(t *testing.T) {
+					source, options := x86ContinuationResultFixture(t, arch, vectors)
+					ir, err := x86ContinuationResultAPI(t, source, options, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "indirectbr") || !strings.Contains(ir, "blockaddress") || strings.Contains(ir, "define void @Advance") {
+						t.Fatal("lost the actual coalesced root CFG")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ContinuationCodeAddressJoinsRetainOnlyActualRoot(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		for _, api := range []string{"text", "module", "owned-module"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				source, options := x86ContinuationResultFixture(t, arch, false)
+				original := " TEST" + word + " BX,BX\n JMP (SI)"
+				joined := " TEST" + word + " BX,BX\n JEQ chooseFinish\n LEA" + word +
+					" ·Advance(SB),CX\n JMP chosen\nchooseFinish:\n LEA" + word + " ·Finish(SB),CX\nchosen:\n JMP CX"
+				if !strings.Contains(source, original) {
+					t.Fatal("join fixture lost its complete original root")
+				}
+				source = strings.Replace(source, original, joined, 1)
+				if _, err := x86ContinuationResultAPI(t, source, options, api); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+	t.Run("distinct-roots-and-kinds-revoke", func(t *testing.T) {
+		flow := new(x86ContinuationFlow)
+		state := x86ResultState{continuation: &x86ContinuationResultState{flow: flow, tablesValid: true}}
+		state.continuation.gp[0] = x86ContinuationAddress{kind: 2, symbol: "helper", root: "root"}
+		for _, address := range []x86ContinuationAddress{
+			{kind: 2, symbol: "helper", root: "another-root"},
+			{kind: 1, symbol: "helper", root: "root"},
+			{},
+		} {
+			other := state.clone()
+			other.continuation.gp[0] = address
+			for _, joined := range []x86ResultState{state.intersect(other), other.intersect(state)} {
+				if joined.continuation.gp[0] != (x86ContinuationAddress{}) {
+					t.Fatal("join borrowed a distinct root or non-code address")
+				}
+			}
+		}
+	})
+}
+
+func TestX86ContinuationWholeCFGResultRejectsIncomplete(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, size := "Q", 8
+		if arch == "386" {
+			word, size = "L", 4
+		}
+		for _, test := range []struct{ name, from, to string }{
+			{"missing-result", fmt.Sprintf(" MOV%s BX,result+%d(FP)\n", word, size*2), ""},
+			{"partial-result", fmt.Sprintf(" MOV%s BX,result+%d(FP)", word, size*2), fmt.Sprintf(" MOVB BX,result+%d(FP)", size*2)},
+			{"unknown-result", fmt.Sprintf(" MOV%s BX,result+%d(FP)", word, size*2), fmt.Sprintf(" MOV%s CX,result+%d(FP)", word, size*2)},
+			{"unknown-target", " JMP (SI)", " JMP CX"},
+			{"unknown-table-write", " TEST" + word + " BX,BX", " MOV" + word + " $123,(SI)\n TEST" + word + " BX,BX"},
+			{"opaque-as-number", " TEST" + word + " BX,BX", " ADD" + word + " SI,BX\n TEST" + word + " BX,BX"},
+			{"possible-direct-exit", " JEQ finished", " JEQ missing\n JMP finished\nmissing:\n RET"},
+		} {
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, options := x86ContinuationResultFixture(t, arch, false)
+					if !strings.Contains(source, test.from) {
+						t.Fatal("negative mutation does not match the complete source")
+					}
+					source = strings.Replace(source, test.from, test.to, 1)
+					if _, err := x86ContinuationResultAPI(t, source, options, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("incomplete continuation admitted: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ContinuationPreparedIdentityCannotBeCopied(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		change func(*File, *Func, *amd64Ctx)
+	}{
+		{"copy-flow", func(_ *File, fn *Func, c *amd64Ctx) { copy := *fn.x86ContinuationFlow; fn.x86ContinuationFlow = &copy }},
+		{"wrong-owner", func(_ *File, fn *Func, c *amd64Ctx) {
+			copy := *fn.x86ContinuationFlow
+			copy.graph = new(x86ContinuationGraph)
+			fn.x86ContinuationFlow = &copy
+		}},
+		{"changed-instruction", func(_ *File, fn *Func, c *amd64Ctx) {
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			fn.Instrs[1].Raw += " "
+		}},
+		{"wrong-declaration", func(_ *File, fn *Func, c *amd64Ctx) { c.fpSourceSig.Args = []LLVMType{I64, I64} }},
+		{"wrong-target", func(_ *File, fn *Func, c *amd64Ctx) { c.targetTriple = "x86_64-pc-windows-msvc" }},
+		{"wrong-ordinal", func(_ *File, fn *Func, c *amd64Ctx) { fn.x86ContinuationFlow.ordinals[0]++ }},
+		{"private-encoded-role", func(_ *File, fn *Func, c *amd64Ctx) { fn.x86ContinuationFlow.instructions[0].x86Encoded = true }},
+		{"private-segment-role", func(_ *File, fn *Func, c *amd64Ctx) { fn.x86ContinuationFlow.instructions[0].x86SegmentPrefix = 0x64 }},
+		{"wrong-edges", func(_ *File, fn *Func, c *amd64Ctx) {
+			fn.x86ContinuationFlow.edges[0] = append(fn.x86ContinuationFlow.edges[0], 0)
+		}},
+		{"wrong-table", func(_ *File, fn *Func, c *amd64Ctx) {
+			graph := fn.x86ContinuationFlow.graph
+			table := graph.tables["dispatch<>"]
+			table.bytes += 8
+			graph.tables["dispatch<>"] = table
+		}},
+		{"changed-original", func(original *File, _ *Func, _ *amd64Ctx) { original.Funcs[0].Instrs[1].Raw += " " }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source, options := x86ContinuationResultFixture(t, "amd64", false)
+			original, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := coalesceX86Continuations(original, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := prepared.Funcs[1]
+			sig := options.Sigs["Evaluate"]
+			c := newX86Ctx(new(strings.Builder), fn, sig, options.ResolveSym, options.Sigs, options.Goarch, options.TargetTriple, false)
+			test.change(original, &fn, c)
+			c.fpScalarSource = fn
+			if err := c.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("copied or changed source role accepted: %v", err)
+			}
+		})
+	}
+	t.Run("permanent-revocation", func(t *testing.T) {
+		source, options := x86ContinuationResultFixture(t, "amd64", false)
+		original, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		prepared, err := coalesceX86Continuations(original, options)
+		if err != nil {
+			t.Fatal(err)
+		}
+		before := original.Funcs[0].Instrs[1].Raw
+		original.Funcs[0].Instrs[1].Raw += " "
+		fn := prepared.Funcs[1]
+		if fn.x86ContinuationFlow.bind(fn, options.Sigs["Evaluate"], "amd64") {
+			t.Fatal("changed original accepted")
+		}
+		original.Funcs[0].Instrs[1].Raw = before
+		if fn.x86ContinuationFlow.bind(fn, options.Sigs["Evaluate"], "amd64") {
+			t.Fatal("restoring source revived a failed source role")
+		}
+	})
+}
+
+func TestX86ContinuationStateNeverInitializesOpaqueBits(t *testing.T) {
+	source, options := x86ContinuationResultFixture(t, "amd64", false)
+	original, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := coalesceX86Continuations(original, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	view := prepared.Funcs[1].x86ContinuationFlow
+	state := x86ResultState{continuation: &x86ContinuationResultState{flow: view, tablesValid: true, written: make([]bool, view.graph.cells)}}
+	ins := view.instructions[2] // Exact table address, after the two declared FP loads.
+	if accepted, known := x86ContinuationResultStep(view.ordinals[2], ins, &state, nil, "amd64"); !known || !accepted {
+		t.Fatal("table address role missing")
+	}
+	if state.gp != [16]uint8{} || state.pointerGP != [16]bool{} || state.callerAddressGP != [16]bool{} || state.flags != 0 {
+		t.Fatal("opaque table address granted unrelated numerical/pointer/status facts")
+	}
+	copy := state.clone()
+	copy.continuation.gp[6] = x86ContinuationAddress{}
+	copy.continuation.written[0] = true
+	if reflect.DeepEqual(copy.continuation, state.continuation) || state.continuation.gp[6].kind == 0 || state.continuation.written[0] {
+		t.Fatal("clone aliases mutable opaque state")
+	}
+	joined := state.intersect(copy)
+	if joined.continuation.gp[6].kind != 0 || joined.continuation.written[0] {
+		t.Fatal("join invented opaque/table initialization facts")
+	}
+	for _, change := range []func(*x86ResultState){
+		func(s *x86ResultState) { s.continuation = nil },
+		func(s *x86ResultState) { s.continuation.flow = new(x86ContinuationFlow) },
+		func(s *x86ResultState) { s.continuation.written = nil },
+	} {
+		other := state.clone()
+		change(&other)
+		joined := state.intersect(other)
+		if !joined.continuation.invalid || joined.continuation.checkReturn() {
+			t.Fatal("mismatched source-state join retained authority")
+		}
+		joined = other.intersect(state)
+		if joined.continuation == nil || !joined.continuation.invalid || joined.continuation.checkReturn() {
+			t.Fatal("reversed mismatched source-state join retained authority")
+		}
+	}
+}
+
+func TestX86ContinuationTableAndAliasBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, size := "Q", 8
+		if arch == "386" {
+			word, size = "L", 4
+		}
+		for _, test := range []struct {
+			name, from, to string
+			accepted       bool
+		}{
+			{"readonly", ",16,$", ",RODATA|NOPTR,$", false},
+			{"unknown-flags", ",16,$", ",UNKNOWN_FLAG,$", false},
+			{"tls-storage", ",16,$", ",TLSBSS,$", false},
+			{"dupok-storage", ",16,$", ",DUPOK|NOPTR,$", false},
+			{"negative-SB-store", "AX,dispatch<>(SB)", fmt.Sprintf("AX,dispatch<>-%d(SB)", size), false},
+			{"negative-SB-load", " JMP (SI)", fmt.Sprintf(" MOV%s dispatch<>-%d(SB),AX\n JMP AX", word, size), false},
+			{"negative-reg-load", " JMP (SI)", fmt.Sprintf(" JMP -%d(SI)", size), false},
+			{"outside-word", " JMP (SI)", fmt.Sprintf(" JMP %d(SI)", size), false},
+			{"partial-code-load", " JMP (SI)", " MOVW (SI),AX\n JMP AX", false},
+			{"native-alias-store", " JMP (SI)", " MOV" + word + " $0,(DI)\n JMP (SI)", false},
+			{"code-escape", " JMP (SI)", " MOV" + word + " (SI),AX\n MOV" + word + " AX,leak(SB)\n JMP AX", false},
+			{"table-escape", " JMP (SI)", fmt.Sprintf(" MOV%s SI,result+%d(FP)\n JMP (SI)", word, size*2), false},
+			{"base-overwrite", " JMP (SI)", " MOV" + word + " $0,SI\n JMP (SI)", false},
+			{"base-partial-overwrite", " JMP (SI)", " MOVB $0,SI\n JMP (SI)", false},
+			{"table-copy", " LEA" + word + " dispatch<>(SB),SI", " LEA" + word + " dispatch<>(SB),AX\n MOV" + word + " AX,SI\n MOV" + word + " $0,AX", true},
+			{"target-copy", " JMP (SI)", " MOV" + word + " (SI),AX\n MOV" + word + " AX,CX\n MOV" + word + " $0,AX\n JMP CX", true},
+		} {
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, options := x86ContinuationResultFixture(t, arch, false)
+					if !strings.Contains(source, test.from) {
+						t.Fatal("mutation absent")
+					}
+					source = strings.Replace(source, test.from, test.to, 1)
+					_, err := x86ContinuationResultAPI(t, source, options, api)
+					if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("accepted=%t: %v", test.accepted, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ContinuationMemoryBranchReadsActualWord(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source, options := x86ContinuationResultFixture(t, arch, false)
+		for _, api := range []string{"text", "module", "owned-module"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ContinuationResultAPI(t, source, options, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if arch == "386" && strings.Contains(ir, "load i64, ptr %t") {
+					t.Fatal("mode32 indirect memory branch reads eight bytes from a four-byte table cell")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ContinuationCannotSupplyWASMOrGoModuleContract(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, triple := range []string{"wasm32-unknown-unknown", "wasm64-unknown-unknown", "aarch64-unknown-linux-gnu", ""} {
+			source, options := x86ContinuationResultFixture(t, arch, false)
+			options.TargetTriple = triple
+			if ir, err := x86ContinuationResultAPI(t, source, options, "text"); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("%s block-address contract escaped to %q: %v", arch, triple, err)
+			}
+		}
+		source, options := x86ContinuationResultFixture(t, arch, false)
+		options.TargetTriple = "i386-unknown-linux-gnu"
+		if arch == "386" {
+			options.TargetTriple = "x86_64-unknown-linux-gnu"
+		}
+		if _, err := x86ContinuationResultAPI(t, source, options, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("mismatched source/target pointer widths accepted", err)
+		}
+	}
+	source, _ := x86ContinuationResultFixture(t, "amd64", false)
+	pkg := mustGoPackage(t, "continuationproof", "package p\nfunc Prepare()\nfunc Evaluate(out *uint64,value uint64) uint64\nfunc Advance()\nfunc Finish()\n")
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu"})
+	if result != nil && !result.Module.IsNil() {
+		result.Module.Dispose()
+	}
+	if err == nil {
+		t.Fatal("an ordinary GoModule call reconstructed the explicit assembly-only group contract")
+	}
+}
+
+func TestX86ContinuationFinalResolverCannotChangeContract(t *testing.T) {
+	for _, change := range []string{"groups", "derived-plan"} {
+		t.Run(change, func(t *testing.T) {
+			source, options := x86ContinuationResultFixture(t, "amd64", false)
+			original, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := coalesceX86Continuations(original, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			graph := prepared.x86ContinuationGraph
+			calls := 0
+			resolve := options.ResolveSym
+			options.ResolveSym = func(symbol string) string {
+				calls++
+				if calls == len(graph.symbols) {
+					if change == "groups" {
+						options.X86TailGroups[0].Helpers[0] = "wrong"
+					} else {
+						graph.flows["·Evaluate"].edges[0] = []int{0}
+					}
+				}
+				return resolve(symbol)
+			}
+			if err := graph.verify(prepared, options); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("final resolver changed a contract after its last check", err)
+			}
+		})
+	}
+}
+
+func TestX86ContinuationInitializersAndSharedBudget(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, size := "Q", 8
+		if arch == "386" {
+			word, size = "L", 4
+		}
+		for _, complete := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/complete=%t", arch, complete), func(t *testing.T) {
+				source, options := x86ContinuationResultFixture(t, arch, false)
+				source = strings.Replace(source, fmt.Sprintf("GLOBL dispatch<>(SB),16,$%d", size), fmt.Sprintf("GLOBL dispatch<>(SB),NOPTR,$%d", size*2), 1)
+				if complete {
+					source = strings.Replace(source, " RET\n", fmt.Sprintf(" LEA%s ·Finish(SB),CX\n MOV%s CX,dispatch<>+%d(SB)\n RET\n", word, word, size), 1)
+				}
+				_, err := x86ContinuationResultAPI(t, source, options, "text")
+				if complete && err != nil || !complete && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("every actual initializer RET must write the complete table: %v", err)
+				}
+			})
+		}
+	}
+	source, options := x86ContinuationResultFixture(t, "amd64", false)
+	original, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	prepared, err := coalesceX86Continuations(original, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	budget := &x86ResultFlowBudget{}
+	for index, fn := range prepared.Funcs {
+		if index != 0 {
+			budget.visits = 16383
+		}
+		fn.x86ResultFlowBudget = budget
+		sig := options.Sigs[options.ResolveSym(fn.Sym)]
+		c := newX86Ctx(new(strings.Builder), fn, sig, options.ResolveSym, options.Sigs, options.Goarch, options.TargetTriple, false)
+		err := c.checkLoweredScalarFPResultInitialization()
+		if index == 0 && (err != nil || budget.visits == 0) {
+			t.Fatal("initializer did not consume the request's shared work budget", err)
+		}
+		if index != 0 && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("second source flow acquired a fresh visit budget", err)
+		}
+		if index != 0 {
+			break
+		}
+	}
+}
+
+func TestX86ContinuationCodeTableCannotBecomeNumericalStorage(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, read := range []string{
+			"MOVB dispatch<>(SB),BX", "MOVW dispatch<>(SB),BX", "MOVL dispatch<>(SB),BX",
+			"MOVSS dispatch<>(SB),X1\n MOVL X1,BX",
+		} {
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(arch+"/"+strings.Fields(read)[0]+"/"+api, func(t *testing.T) {
+					source, options := x86ContinuationResultFixture(t, arch, false)
+					word := "Q"
+					if arch == "386" {
+						word = "L"
+					}
+					source = strings.Replace(source, " TEST"+word+" BX,BX", " "+read+"\n TEST"+word+" BX,BX", 1)
+					if output, err := x86ContinuationResultAPI(t, source, options, api); output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("code-table bytes acquired numerical storage authority", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ContinuationUnknownABIRequiresObservedPointerWidth(t *testing.T) {
+	for _, triple := range []string{"x86_64-unknown-linux-gnux32", "x86_64-unknown-unknown", "i386-unknown-linux-musl"} {
+		t.Run(triple, func(t *testing.T) {
+			arch := "amd64"
+			if strings.HasPrefix(triple, "i386") {
+				arch = "386"
+			}
+			source, options := x86ContinuationResultFixture(t, arch, false)
+			options.TargetTriple = triple
+			if output, err := x86ContinuationResultAPI(t, source, options, "text"); output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown target ABI borrowed the native code/table word role", err)
+			}
+		})
+	}
+}
+
+func TestX86ContinuationUnrelatedFunctionsDoNotBorrowCodeStorage(t *testing.T) {
+	for _, operand := range []string{"dispatch<>(SB)", "·dispatch<>(SB)", "alias<>(SB)"} {
+		t.Run(operand, func(t *testing.T) {
+			source, options := x86ContinuationResultFixture(t, "amd64", false)
+			source += "TEXT ·Unrelated(SB),$0-0\n MOVB " + operand + ",AX\n RET\n"
+			options.Sigs["Unrelated"] = FuncSig{Ret: Void}
+			resolve := options.ResolveSym
+			options.ResolveSym = func(symbol string) string {
+				if symbol == "·alias<>" {
+					return resolve("·dispatch<>")
+				}
+				return resolve(symbol)
+			}
+			if output, err := x86ContinuationResultAPI(t, source, options, "text"); output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an unrelated unproved function borrowed numerical code-table storage", err)
+			}
+		})
+	}
+	source, options := x86ContinuationResultFixture(t, "amd64", false)
+	source += "TEXT ·Unrelated(SB),$0-0\n MOVQ $7,AX\n RET\n"
+	options.Sigs["Unrelated"] = FuncSig{Ret: Void}
+	if _, err := x86ContinuationResultAPI(t, source, options, "text"); err != nil {
+		t.Fatal("unrelated ordinary source lost its original consumer", err)
+	}
+}
+
+func TestX86ContinuationConcurrentPublicRequestsDoNotMutateSource(t *testing.T) {
+	source, options := x86ContinuationResultFixture(t, "amd64", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := x86ContinuationSnapshot(file)
+	var workers sync.WaitGroup
+	failures := make(chan error, 24)
+	for worker := 0; worker < 6; worker++ {
+		workers.Add(1)
+		go func() {
+			defer workers.Done()
+			for iteration := 0; iteration < 4; iteration++ {
+				if iteration%2 == 0 {
+					_, err := Translate(file, options)
+					if err != nil {
+						failures <- err
+					}
+				} else {
+					ctx := llvm.NewContext()
+					module, err := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						module.Dispose()
+					}
+					ctx.Dispose()
+					if err != nil {
+						failures <- err
+					}
+				}
+			}
+		}()
+	}
+	workers.Wait()
+	close(failures)
+	for err := range failures {
+		t.Error(err)
+	}
+	if !reflect.DeepEqual(before, x86ContinuationSnapshot(file)) || file.x86ContinuationGraph != nil {
+		t.Fatal("concurrent request-local coalescing changed the caller's original File")
+	}
+}
diff --git a/x86_continuation_runtime_linux_amd64_test.go b/x86_continuation_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..07f4a7b68
--- /dev/null
+++ b/x86_continuation_runtime_linux_amd64_test.go
@@ -0,0 +1,84 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// A required native owner, not a host-dependent optional axis. i386 executes
+// through the same Linux AMD64 kernel compatibility ISA as the other native
+// 386 owners. Missing LLVM22/static compiler/execution support fails outright.
+func TestCrossLinuxRuntimeMatrixX86ContinuationWholeCFGOriginalGoAndLLVM(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	i386, err := exec.LookPath("i686-linux-gnu-gcc")
+	if !found || err != nil {
+		t.Fatalf("continuation native owner requires LLVM22 llc/clang and static i386 compiler: %v", err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		dispatches := []string{"memory", "register"}
+		if arch == "386" {
+			dispatches = append(dispatches, "BP-memory", "BP-register", "BP-target")
+		}
+		for _, dispatch := range dispatches {
+			t.Run(arch+"/"+dispatch, func(t *testing.T) {
+				mode := strings.TrimPrefix(dispatch, "BP-")
+				if dispatch == "BP-target" {
+					mode = "register"
+				}
+				source, options, goDriver, cDriver := x86ContinuationRuntimeFixture(t, arch, mode)
+				if dispatch == "BP-target" {
+					source = strings.ReplaceAll(source, "AX", "BP")
+				} else if strings.HasPrefix(dispatch, "BP-") {
+					source = strings.ReplaceAll(source, "SI", "BP")
+				}
+				compiler := []string{clang, "-target", options.TargetTriple, "-no-pie"}
+				if arch == "386" {
+					compiler = []string{i386, "-static", "-no-pie"}
+				}
+				execution := x86FloatCompareExecution{llc: llc, triple: options.TargetTriple, compiler: compiler}
+				dir := t.TempDir()
+				for name, contents := range map[string]string{
+					"go.mod": "module continuationoracle\n\ngo 1.20\n", "main.go": goDriver,
+					"continuation_" + arch + ".s": strings.ReplaceAll(source, "(SB),$0-", "(SB),4,$0-"),
+				} {
+					if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				original := filepath.Join(dir, "original")
+				command := exec.Command("go", "build", "-p=1", "-o", original, ".")
+				command.Dir = dir
+				command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+				x86FloatCompareCaptureCommand(t, command)
+				want := "continuation original/LLVM: 7 independent checks\n"
+				if output := execution.run(t, original); string(output) != want {
+					t.Fatalf("incomplete original Go execution: %s", output)
+				}
+				for _, api := range []string{"text", "module", "owned-module"} {
+					ir, err := x86ContinuationResultAPI(t, source, options, api)
+					if err != nil {
+						t.Fatal(api, err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							output := execution.compileAndRunLLVM(t, "continuation", input, cDriver, level)
+							if string(output) != want {
+								t.Fatalf("%s IR_O2=%t %s incomplete LLVM execution: %s", api, optimized, level, output)
+							}
+							t.Log(api, optimized, level, strings.TrimSpace(string(output)))
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_continuation_runtime_test.go b/x86_continuation_runtime_test.go
new file mode 100644
index 000000000..0f888725d
--- /dev/null
+++ b/x86_continuation_runtime_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Both independent callers use the complete original four-TEXT file. They
+// observe the opaque out pointer, scalar result, zero/nonzero FLAGS edge,
+// GP/X transport, unsigned wrap and neighboring caller canaries separately.
+func x86ContinuationRuntimeFixture(t *testing.T, arch, dispatch string) (string, Options, string, string) {
+	t.Helper()
+	source, options := x86ContinuationResultFixture(t, arch, true)
+	word, typ, ctyp := "Q", "uint64", "uint64_t"
+	values := "0,1,7,0xffffffff,0x100000000,0x8000000000000000,^uint64(0)"
+	cvalues := "0,1,7,UINT64_C(0xffffffff),UINT64_C(0x100000000),UINT64_C(0x8000000000000000),UINT64_MAX"
+	if arch == "386" {
+		word, typ, ctyp = "L", "uint32", "uint32_t"
+		values = "0,1,7,0xffff,0x7fffffff,0x80000000,^uint32(0)"
+		cvalues = "0,1,7,0xffff,0x7fffffff,0x80000000,UINT32_MAX"
+	}
+	if dispatch == "register" {
+		source = strings.Replace(source, " JMP (SI)", " MOV"+word+" (SI),AX\n JMP AX", 1)
+	} else if dispatch != "memory" {
+		t.Fatal("unknown continuation runtime dispatch", dispatch)
+	}
+	goDriver := `package main
+import "fmt"
+func Prepare()
+func Evaluate(out *@WORD, value @WORD) @WORD
+func Advance()
+func Finish()
+func main() {
+ Prepare()
+ calls:=0
+ for _,value:=range []@WORD{@VALUES} {
+  want:=value
+  if value!=0 {want++}
+  out:=[3]@WORD{0x12345678,0,0x87654321}
+  got:=Evaluate(&out[1],value)
+  if got!=want || out[1]!=want || out[0]!=0x12345678 || out[2]!=0x87654321 {
+   panic(fmt.Sprintf("continuation input=%x got=%x want=%x out=%x",value,got,want,out))
+  }
+  calls++
+ }
+ fmt.Printf("continuation original/LLVM: %d independent checks\n",calls)
+}
+`
+	goDriver = strings.NewReplacer("@WORD", typ, "@VALUES", values).Replace(goDriver)
+	cDriver := `#include <stdint.h>
+#include <stdio.h>
+extern void Prepare(void);
+extern @WORD Evaluate(@WORD *, @WORD);
+int main(void) {
+ Prepare();
+ const @WORD values[]={@VALUES};
+ unsigned calls=0;
+ for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+  @WORD value=values[i],want=value+(value!=0);
+  @WORD out[]={0x12345678,0,0x87654321};
+  @WORD got=Evaluate(out+1,value);
+  if(got!=want || out[1]!=want || out[0]!=0x12345678 || out[2]!=0x87654321) {
+   fprintf(stderr,"continuation sample=%u got=%llx want=%llx out=%llx\n",i,(unsigned long long)got,(unsigned long long)want,(unsigned long long)out[1]);
+   return 1;
+  }
+  calls++;
+ }
+ printf("continuation original/LLVM: %u independent checks\n",calls);
+ return 0;
+}
+`
+	cDriver = strings.NewReplacer("@WORD", ctyp, "@VALUES", cvalues).Replace(cDriver)
+	return source, options, goDriver, cDriver
+}
+
+func TestX86ContinuationRuntimeFixtureOwnsCompleteRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, dispatch := range []string{"memory", "register"} {
+			source, options, original, llvm := x86ContinuationRuntimeFixture(t, arch, dispatch)
+			if strings.Count(source, "TEXT ") != 4 || len(options.X86TailGroups) != 1 || len(options.X86TailGroups[0].Helpers) != 2 ||
+				!strings.Contains(source, "X0") || !strings.Contains(source, "JEQ") ||
+				!strings.Contains(original, "got!=want || out[1]!=want") || !strings.Contains(llvm, "got!=want || out[1]!=want") ||
+				strings.Contains(original+llvm, "@WORD") || strings.Contains(original+llvm, "@VALUES") {
+				t.Fatal("runtime fixture lost complete source/independent observable roles")
+			}
+		}
+	}
+}
diff --git a/x86_continuation_source.go b/x86_continuation_source.go
new file mode 100644
index 000000000..35839626b
--- /dev/null
+++ b/x86_continuation_source.go
@@ -0,0 +1,518 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync/atomic"
+)
+
+// This is the explicit X86TailGroups contract, not the independent source-only
+// direct-tail producer. Its addresses denote blocks in one actual fused root;
+// neither the helpers' declarations nor a table cell supplies numerical bytes.
+type x86ContinuationGraph struct {
+	self                       *x86ContinuationGraph
+	origin, original, prepared *File
+	arch, triple               string
+	groups                     []X86TailGroup
+	signatures                 map[string]FuncSig
+	symbols                    map[string]string
+	dataSymbols                map[string]string // Complete SB-use mapping, including aliases without GLOBL.
+	flows                      map[string]*x86ContinuationFlow
+	tables                     map[string]x86ContinuationTable
+	addresses                  map[string]x86Continuation
+	cells                      int
+	plan                       [32]byte
+	revoked                    atomic.Bool
+}
+
+type x86ContinuationTable struct {
+	root, initializer string
+	bytes             int64
+	first, cells      int
+}
+
+type x86ContinuationFlow struct {
+	graph        *x86ContinuationGraph
+	symbol, root string
+	instructions []Instr
+	ordinals     []int
+	edges        [][]int
+	indirect     map[int]bool
+}
+
+func x86ContinuationContext(reason string) error {
+	return fmt.Errorf("%w: x86 continuation: %s", ErrProbeNeedsContext, reason)
+}
+
+func x86ContinuationSnapshot(file *File) *File {
+	copy := arm64ScratchFileSnapshot(file)
+	copy.x86ContinuationGraph = nil
+	copy.x86Continuations = make(map[string]x86Continuation, len(file.x86Continuations))
+	for symbol, address := range file.x86Continuations {
+		copy.x86Continuations[symbol] = address
+	}
+	for i := range copy.Funcs {
+		fn := &copy.Funcs[i]
+		fn.x86ContinuationFlow = nil
+		fn.x86ResultFlowBudget = nil
+		fn.x86IndirectLabels = append([]string(nil), fn.x86IndirectLabels...)
+		fn.x86ContinuationAddresses = make(map[string]x86Continuation, len(file.Funcs[i].x86ContinuationAddresses))
+		for symbol, address := range file.Funcs[i].x86ContinuationAddresses {
+			fn.x86ContinuationAddresses[symbol] = address
+		}
+	}
+	return copy
+}
+
+func sealX86Continuations(original, prepared *File, opt Options) (*File, error) {
+	// Unlike numerical portable IR, an actual block address stored in a native
+	// word needs its source mode and the physical target's pointer width bound.
+	// In particular wasm must never receive blockaddress through an x86 route.
+	profile := map[string]string{
+		"x86_64-apple-darwin": "amd64", "x86_64-unknown-linux-gnu": "amd64", "x86_64-pc-windows-msvc": "amd64",
+		"i386-unknown-linux-gnu": "386", "i686-pc-windows-msvc": "386",
+	}
+	if profile[opt.TargetTriple] != opt.Goarch || opt.Goarch == "" {
+		return nil, x86ContinuationContext("code/table addresses require a matching explicit x86 pointer-width target")
+	}
+	if opt.NumericalReads != nil || opt.X86TLSMoves != nil || opt.ARM64ByteCarrierSource != nil ||
+		len(original.UnlinkedPrelude) != 0 || original.x86DirectTails != nil {
+		return nil, x86ContinuationContext("source/native roles need their independent complete-node association")
+	}
+	graph := &x86ContinuationGraph{origin: original, original: x86ContinuationSnapshot(original),
+		arch: opt.Goarch, triple: opt.TargetTriple, flows: make(map[string]*x86ContinuationFlow),
+		symbols: make(map[string]string), dataSymbols: make(map[string]string), tables: make(map[string]x86ContinuationTable),
+		addresses: make(map[string]x86Continuation)}
+	graph.self = graph
+	var err error
+	graph.signatures, err = numericalCloneSignatures(opt.Sigs)
+	if err != nil {
+		return nil, err
+	}
+	for _, group := range opt.X86TailGroups {
+		graph.groups = append(graph.groups, X86TailGroup{Root: group.Root, Helpers: append([]string(nil), group.Helpers...)})
+	}
+	for symbol, address := range prepared.x86Continuations {
+		graph.addresses[symbol] = address
+	}
+	resolve := opt.ResolveSym
+	if resolve == nil {
+		resolve = func(s string) string { return s }
+	}
+	owners := make(map[string]string)
+	for _, group := range graph.groups {
+		owners[group.Root] = group.Root
+		for _, helper := range group.Helpers {
+			owners[helper] = group.Root
+		}
+	}
+	resolved := make(map[string]bool)
+	for _, fn := range graph.original.Funcs {
+		name := resolve(fn.Sym)
+		if name == "" || resolved[name] {
+			return nil, x86ContinuationContext("ambiguous original TEXT symbol mapping")
+		}
+		resolved[name], graph.symbols[fn.Sym] = true, name
+	}
+	for _, global := range graph.original.Globl {
+		name := resolveAssemblyDataSymbol(global.Sym, resolve)
+		if name == "" || resolved[name] {
+			return nil, x86ContinuationContext("GLOBL/TEXT resolved identity is ambiguous")
+		}
+		resolved[name], graph.symbols[global.Sym] = true, name
+	}
+	observe := func(operand Operand) {
+		if operand.Kind == OpSym {
+			operand.Sym = strings.TrimLeft(operand.Sym, "*$")
+		}
+		memory, valid := x86SBMemoryAddressRole(operand, graph.arch)
+		if !valid {
+			return
+		}
+		name, _, valid := parseSBRef(memory.Sym)
+		if valid {
+			graph.dataSymbols[name] = resolveAssemblyDataSymbol(name, resolve)
+		}
+	}
+	for _, fn := range graph.original.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			for _, operand := range ins.Args {
+				observe(operand)
+			}
+		}
+	}
+	for _, data := range graph.original.Data {
+		observe(Operand{Kind: OpSym, Sym: data.Addr})
+	}
+	if err := graph.collectTables(owners); err != nil {
+		return nil, err
+	}
+	combined := 0
+	for i := range prepared.Funcs {
+		fn := &prepared.Funcs[i]
+		root := owners[fn.Sym]
+		participant := root != ""
+		for _, table := range graph.tables {
+			participant = participant || table.initializer == fn.Sym
+		}
+		if !participant {
+			continue
+		}
+		sig, declared := graph.signatures[graph.symbols[fn.Sym]]
+		if !declared || sig.Ret == I1 {
+			return nil, x86ContinuationContext("root lacks its independent ordinary scalar result role")
+		}
+		for _, slot := range sig.Frame.Results {
+			if slot.Type == I1 {
+				return nil, x86ContinuationContext("bool results need their independent canonical whole-graph role")
+			}
+		}
+		if fn.FrameSize != 0 || fn.X86RawText != nil || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+			fn.x86RawReplay != nil || fn.x86DirectTailRoot != nil || fn.x86BoolCalls != nil {
+			return nil, x86ContinuationContext("native/frame/call role is not a logical continuation")
+		}
+		for _, ins := range fn.Instrs {
+			if isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+				ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 ||
+				len(ins.x86SourceStackFP) != 0 || len(ins.x86CallerMemory) != 0 || len(ins.x86FixedLocalMemory) != 0 ||
+				ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil || ins.Op == OpCALL {
+				return nil, x86ContinuationContext("unbound raw/native/call instruction")
+			}
+			for _, arg := range ins.Args {
+				if arg.Kind == OpReg && x86LogicalSourceFrameRegister(arg.Reg, graph.arch) || arg.Kind == OpFPAddr ||
+					arg.Kind == OpMem && (x86LogicalSourceFrameRegister(arg.Mem.Base, graph.arch) ||
+						x86LogicalSourceFrameRegister(arg.Mem.Index, graph.arch) || arg.Mem.Base == PC) {
+					return nil, x86ContinuationContext("physical frame or PC role is not closed")
+				}
+			}
+		}
+		view, err := graph.flow(*fn, root)
+		if err != nil {
+			return nil, err
+		}
+		combined += len(view.instructions)
+		if combined > 4096 {
+			return nil, x86ContinuationContext("combined source instruction budget exhausted")
+		}
+		graph.flows[fn.Sym], fn.x86ContinuationFlow = view, view
+	}
+	prepared.x86ContinuationGraph = graph
+	graph.prepared = x86ContinuationSnapshot(prepared)
+	if err := graph.auditReferences(); err != nil {
+		return nil, err
+	}
+	graph.plan, err = graph.planHash()
+	if err != nil {
+		return nil, err
+	}
+	if err := graph.verify(prepared, opt); err != nil {
+		return nil, err
+	}
+	return prepared, nil
+}
+
+// Tables are complete private GLOBL objects. Initializer execution order is
+// still the explicit caller's closed-target contract, never inferred from a
+// func() declaration. Every actual initializer RET must separately write all
+// cells with this group's opaque code addresses.
+func (graph *x86ContinuationGraph) collectTables(owners map[string]string) error {
+	word := x86ResultPointerWord(graph.arch)
+	lea, move := Op("LEAQ"), Op("MOVQ")
+	if graph.arch == "386" {
+		lea, move = "LEAL", "MOVL"
+	}
+	for _, fn := range graph.original.Funcs {
+		if owners[fn.Sym] == "" {
+			continue
+		}
+		for _, ins := range fn.Instrs {
+			if ins.Op != lea || len(ins.Args) != 2 {
+				continue
+			}
+			address, ok := x86StaticSBReadAddress(ins.Args[0], graph.arch)
+			if !ok || graph.addresses[address.symbol].root != "" {
+				continue
+			}
+			if !strings.HasSuffix(address.symbol, "<>") || address.offset != 0 {
+				return x86ContinuationContext("table address is not an exact private object")
+			}
+			if old, exists := graph.tables[address.symbol]; exists && old.root != owners[fn.Sym] {
+				return x86ContinuationContext("table belongs to another root")
+			}
+			graph.tables[address.symbol] = x86ContinuationTable{root: owners[fn.Sym]}
+		}
+	}
+	for symbol, table := range graph.tables {
+		matches := 0
+		for _, global := range graph.original.Globl {
+			if global.Sym == symbol {
+				matches++
+				flags := globlFlagName.ReplaceAllStringFunc(global.Flags, func(name string) string {
+					if name == "NOPTR" {
+						return "16"
+					}
+					return name
+				})
+				value, valid := uint64(0), true
+				if strings.TrimSpace(flags) != "" {
+					value, valid = parseImmExpr(flags)
+				}
+				if !valid || value&^16 != 0 {
+					return x86ContinuationContext("table must be mutable unique ordinary storage, with only optional NOPTR")
+				}
+				if global.SizeRaw != "" || global.Size <= 0 || global.Size > 4096 || global.Size%word != 0 {
+					return x86ContinuationContext("table extent is not complete bounded words")
+				}
+				table.bytes = global.Size
+			}
+		}
+		if matches != 1 {
+			return x86ContinuationContext("table has missing or duplicate storage")
+		}
+		for _, data := range graph.original.Data {
+			if data.Sym == symbol {
+				return x86ContinuationContext("table DATA requires its separate relocation contract")
+			}
+		}
+		for _, fn := range graph.original.Funcs {
+			if fn.Sym == symbol {
+				return x86ContinuationContext("table aliases a TEXT")
+			}
+			for _, ins := range fn.Instrs {
+				if len(ins.Args) != 2 {
+					continue
+				}
+				address, ok := x86StaticSBReadAddress(ins.Args[1], graph.arch)
+				if !ok || address.symbol != symbol {
+					continue
+				}
+				if x86SourceMoveInstruction(ins, graph.arch).Op != move || address.offset < 0 || address.offset%word != 0 || address.offset > table.bytes-word || owners[fn.Sym] != "" ||
+					table.initializer != "" && table.initializer != fn.Sym {
+					return x86ContinuationContext("table write is not one exact closed initializer")
+				}
+				table.initializer = fn.Sym
+			}
+		}
+		if table.initializer == "" {
+			return x86ContinuationContext("table has no actual initializer source")
+		}
+		sig, found := graph.signatures[graph.symbols[table.initializer]]
+		if !found || sig.Ret != Void || len(sig.Args) != 0 || len(sig.ArgRegs) != 0 || len(sig.Frame.Params)+len(sig.Frame.Results) != 0 {
+			return x86ContinuationContext("table initializer is not an ordinary zero-argument void root")
+		}
+		table.first, table.cells = graph.cells, int(table.bytes/word)
+		graph.cells += table.cells
+		if graph.cells > 4096 {
+			return x86ContinuationContext("combined table cell budget exhausted")
+		}
+		graph.tables[symbol] = table
+	}
+	return nil
+}
+
+func (graph *x86ContinuationGraph) auditReferences() error {
+	for name, resolved := range graph.dataSymbols {
+		for table := range graph.tables {
+			if name != table && resolved == graph.symbols[table] {
+				return x86ContinuationContext("SB alias has no exact closed-table source identity")
+			}
+		}
+		for helper := range graph.addresses {
+			if resolved == graph.symbols[helper] && name != helper || name == helper && resolved != graph.symbols[helper] {
+				return x86ContinuationContext("SB alias has no exact coalesced code identity")
+			}
+		}
+	}
+	for _, data := range graph.original.Data {
+		name, _, valid := parseSBRef(strings.TrimPrefix(data.Addr, "$"))
+		if _, table := graph.tables[name]; valid && table {
+			return x86ContinuationContext("table address escapes through DATA")
+		}
+	}
+	for _, fn := range graph.original.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			for _, operand := range ins.Args {
+				memory, valid := x86SBMemoryAddressRole(operand, graph.arch)
+				if !valid && operand.Kind == OpSym {
+					memory, valid = x86SBMemoryAddressRole(Operand{Kind: OpSym, Sym: strings.TrimPrefix(operand.Sym, "$")}, graph.arch)
+				}
+				if !valid {
+					continue
+				}
+				name, _, valid := parseSBRef(memory.Sym)
+				_, table := graph.tables[name]
+				_, code := graph.addresses[name]
+				if !valid || !table && !code {
+					continue
+				}
+				participant := graph.flows[fn.Sym] != nil || graph.addresses[fn.Sym].root != ""
+				if !participant {
+					return x86ContinuationContext("code/table reference is outside the complete closed participants")
+				}
+			}
+		}
+	}
+	return nil
+}
+
+// Hash the entire derived plan, not only exported Instr JSON. Private graph
+// copies or changed ordinals/edges/table extents cannot borrow an old source
+// token. This is a private projection, not another source/ABI capability.
+func (graph *x86ContinuationGraph) planHash() ([32]byte, error) {
+	prepared := make(map[string]Func, len(graph.prepared.Funcs))
+	for _, fn := range graph.prepared.Funcs {
+		prepared[fn.Sym] = fn
+	}
+	tables := make(map[string]any, len(graph.tables))
+	for name, table := range graph.tables {
+		tables[name] = []any{table.root, table.initializer, table.bytes, table.first, table.cells}
+	}
+	addresses := make(map[string]any, len(graph.addresses))
+	for name, address := range graph.addresses {
+		addresses[name] = []string{address.root, address.label}
+	}
+	flows := make(map[string]any, len(graph.flows))
+	for name, view := range graph.flows {
+		if view == nil || view.graph != graph {
+			return [32]byte{}, x86ContinuationContext("derived flow has another graph owner")
+		}
+		fn, present := prepared[name]
+		if !present || len(view.instructions) != len(view.ordinals) {
+			return [32]byte{}, x86ContinuationContext("derived flow has no complete source ordinals")
+		}
+		for pc, ins := range view.instructions {
+			ordinal := view.ordinals[pc]
+			if ordinal < 0 || ordinal >= len(fn.Instrs) || !reflect.DeepEqual(ins, fn.Instrs[ordinal]) {
+				return [32]byte{}, x86ContinuationContext("derived instruction lost its exact original normalized tuple")
+			}
+		}
+		flows[name] = []any{view.symbol, view.root, view.instructions, view.ordinals, view.edges, view.indirect}
+	}
+	return x86CallerSourceFingerprint([]any{tables, addresses, flows, graph.cells, graph.dataSymbols})
+}
+
+func (graph *x86ContinuationGraph) flow(fn Func, root string) (*x86ContinuationFlow, error) {
+	view := &x86ContinuationFlow{graph: graph, symbol: fn.Sym, root: root, indirect: make(map[int]bool)}
+	labels := make(map[string]int)
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op == OpTEXT {
+			continue
+		}
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+				return nil, x86ContinuationContext("malformed coalesced label")
+			}
+			if _, duplicate := labels[ins.Args[0].Sym]; duplicate {
+				return nil, x86ContinuationContext("duplicate coalesced label")
+			}
+			labels[ins.Args[0].Sym] = len(view.instructions)
+			continue
+		}
+		view.instructions, view.ordinals = append(view.instructions, ins), append(view.ordinals, ordinal)
+	}
+	var targets []int
+	for _, label := range fn.x86IndirectLabels {
+		target, ok := labels[label]
+		if !ok || target >= len(view.instructions) {
+			return nil, x86ContinuationContext("indirect label is not a complete root block")
+		}
+		targets = append(targets, target)
+	}
+	view.edges = make([][]int, len(view.instructions))
+	for pc, ins := range view.instructions {
+		if ins.Op == OpRET {
+			if len(ins.Args) != 0 {
+				return nil, x86ContinuationContext("nonordinary RET")
+			}
+			continue
+		}
+		next := []int{pc + 1}
+		if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+			args := x86DirectTailBranchArgs(ins)
+			if len(args) != 1 {
+				return nil, x86ContinuationContext("unbound branch operands")
+			}
+			arg := args[0]
+			label := arg.Sym
+			if arg.Kind == OpIdent {
+				label = arg.Ident
+			} else if arg.Kind == OpReg {
+				label = string(arg.Reg)
+			}
+			target, local := labels[label]
+			if !local {
+				if ins.Op != OpJMP || len(targets) == 0 || root == "" || arg.Kind != OpReg && arg.Kind != OpMem {
+					return nil, x86ContinuationContext("external or unresolved continuation branch")
+				}
+				view.indirect[view.ordinals[pc]] = true
+				next = append([]int(nil), targets...)
+			} else if ins.Op == OpJMP {
+				next = []int{target}
+			} else {
+				next = append(next, target)
+			}
+		}
+		for _, target := range next {
+			if target < 0 || target >= len(view.instructions) {
+				return nil, x86ContinuationContext("source falls outside the coalesced root")
+			}
+		}
+		view.edges[pc] = next
+	}
+	return view, nil
+}
+
+func (graph *x86ContinuationGraph) verify(file *File, opt Options) (err error) {
+	defer func() {
+		if err != nil && graph != nil {
+			graph.revoked.Store(true)
+		}
+	}()
+	if graph == nil || graph.self != graph || graph.revoked.Load() || file == nil ||
+		graph.arch != opt.Goarch || graph.triple != opt.TargetTriple ||
+		opt.NumericalReads != nil || opt.X86TLSMoves != nil || opt.ARM64ByteCarrierSource != nil ||
+		!reflect.DeepEqual(graph.groups, opt.X86TailGroups) || !reflect.DeepEqual(graph.signatures, opt.Sigs) ||
+		!reflect.DeepEqual(graph.original, x86ContinuationSnapshot(graph.origin)) ||
+		!reflect.DeepEqual(graph.prepared, x86ContinuationSnapshot(file)) {
+		return x86ContinuationContext("complete source, graph, mode or declarations changed")
+	}
+	plan, planErr := graph.planHash()
+	if planErr != nil || plan != graph.plan {
+		return x86ContinuationContext("derived graph/table/source-ordinal plan changed")
+	}
+	resolve := opt.ResolveSym
+	if resolve == nil {
+		resolve = func(s string) string { return s }
+	}
+	for symbol, expected := range graph.symbols {
+		actual := resolve(symbol)
+		for _, global := range graph.original.Globl {
+			if global.Sym == symbol {
+				actual = resolveAssemblyDataSymbol(symbol, resolve)
+				break
+			}
+		}
+		if actual != expected {
+			return x86ContinuationContext("complete symbol mapping changed")
+		}
+	}
+	for symbol, expected := range graph.dataSymbols {
+		if resolveAssemblyDataSymbol(symbol, resolve) != expected {
+			return x86ContinuationContext("complete SB-use symbol mapping changed")
+		}
+	}
+	plan, planErr = graph.planHash()
+	if planErr != nil || plan != graph.plan || !reflect.DeepEqual(graph.groups, opt.X86TailGroups) ||
+		!reflect.DeepEqual(graph.original, x86ContinuationSnapshot(graph.origin)) || !reflect.DeepEqual(graph.prepared, x86ContinuationSnapshot(file)) ||
+		!reflect.DeepEqual(graph.signatures, opt.Sigs) || graph.revoked.Load() {
+		return x86ContinuationContext("resolver changed source or declarations")
+	}
+	return nil
+}
diff --git a/x86_counter_control.go b/x86_counter_control.go
new file mode 100644
index 000000000..be4dbb291
--- /dev/null
+++ b/x86_counter_control.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86CounterControlSpec struct {
+	halfAddress, decrement bool
+	condition              string
+}
+
+// One complete yloop family owns spelling, count-width and FLAGS roles.
+// These descriptors carry no branch-target, caller, raw or storage authority.
+func x86CounterControlPropertiesForOpcode(op Op) (x86CounterControlSpec, bool) {
+	switch Op(strings.ToUpper(string(op))) {
+	case "JCXZW", "JCXZQ":
+		return x86CounterControlSpec{}, true
+	case "JCXZL":
+		return x86CounterControlSpec{halfAddress: true}, true
+	case "LOOP":
+		return x86CounterControlSpec{decrement: true}, true
+	case "LOOPEQ":
+		return x86CounterControlSpec{decrement: true, condition: "EQ"}, true
+	case "LOOPNE":
+		return x86CounterControlSpec{decrement: true, condition: "NE"}, true
+	default:
+		return x86CounterControlSpec{}, false
+	}
+}
+
+type x86CounterControlForm struct {
+	x86CounterControlSpec
+	bits int
+}
+
+func x86CounterControlProperties(op Op, ins Instr, arch string) (x86CounterControlForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base, _, _ := strings.Cut(name, ".")
+	spec, known := x86CounterControlPropertiesForOpcode(Op(base))
+	form := x86CounterControlForm{x86CounterControlSpec: spec}
+	if !known {
+		return form, false, nil
+	}
+	fail := func(reason string) (x86CounterControlForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch == "" {
+		arch = "amd64" // Preserve the existing x86 source-mode default.
+	}
+	if name != base || arch != "amd64" && arch != "386" || len(ins.Args) != 1 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail("requires its complete mode, identity and one branch target")
+	}
+	target := ins.Args[0]
+	valid := target.Kind == OpLabel && target.Sym != "" || target.Kind == OpIdent && target.Ident != ""
+	if target.Kind == OpMem {
+		memory := target.Mem
+		valid = memory.Base == PC && memory.Sym == "" && memory.OffRaw == "" &&
+			memory.Index == "" && memory.Scale == 0 && memory.IndexExt == "" && memory.Segment == ""
+	}
+	if !valid {
+		return fail("requires an original local label or instruction-relative PC target")
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return form, true, fmt.Errorf("%w: counter control needs its original named address-size and source identity", ErrProbeNeedsContext)
+	}
+	form.bits = int(8 * x86ResultPointerWord(arch))
+	if spec.halfAddress {
+		form.bits /= 2
+	}
+	return form, true, nil
+}
+
+func x86TypedCounterControlByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	form, known, err := x86CounterControlProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true,
+		operands: []x86TypedByteOperand{{index: -1, operand: Operand{Kind: OpReg, Reg: CX},
+			width: int64(form.bits / 8), read: true, write: form.decrement}}}
+	if form.condition != "" {
+		effect.flagsRead = x86ByteFlagZF
+	}
+	return effect, true, nil
+}
+
+func x86ResultCounterControlStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	effect, known, err := x86TypedCounterControlByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	count := effect.operands[0]
+	index, mask, valid := x86ResultGP(CX, count.width, arch)
+	if !valid || !state.shapeOnly && state.pointerGP[index] || state.flags&effect.flagsRead != effect.flagsRead ||
+		!x86ResultRead(count.operand, count.width, state, owned, arch) {
+		return false, true
+	}
+	if count.write {
+		if !x86ResultStore(count.operand, count.width, state, owned, 0, arch) {
+			return false, true
+		}
+		state.canonicalGP[index] &^= mask
+		if count.width == 4 {
+			state.canonicalGP[index] |= 0xf0 // The emitted dword write zeros its upper alias.
+		}
+		state.callerAddressGP[index], state.callerAddressOrigin[index] = false, 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	return true, true // All FLAGS and DF survive; no count value or target fact is invented.
+}
+
+func (c *amd64Ctx) counterControlCondition(form x86CounterControlForm) (string, error) {
+	typ := amd64IntegerTypeForBits(form.bits)
+	value, err := c.evalIntSized(Operand{Kind: OpReg, Reg: CX}, typ)
+	if err != nil {
+		return "", err
+	}
+	comparison := "eq"
+	if form.decrement {
+		next := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = sub %s %s, 1\n", next, typ, value)
+		value, comparison = "%"+next, "ne"
+		if err := c.storeRegSized(CX, typ, value); err != nil {
+			return "", err
+		}
+	}
+	condition := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp %s %s %s, 0\n", condition, comparison, typ, value)
+	if form.condition == "" {
+		return "%" + condition, nil
+	}
+	flags, err := c.x86Condition(form.condition)
+	if err != nil {
+		return "", err
+	}
+	combined := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i1 %%%s, %s\n", combined, condition, flags)
+	return "%" + combined, nil // The decrement never writes machine FLAGS.
+}
diff --git a/x86_counter_control_obligation_test.go b/x86_counter_control_obligation_test.go
new file mode 100644
index 000000000..651f0f1a0
--- /dev/null
+++ b/x86_counter_control_obligation_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Go's yloop rows share a target grammar. Only JCXZL emits address-size
+// override; the historical W/Q spellings both use the source mode's word.
+var x86CounterControlOracle = []struct {
+	op          string
+	bytes       byte
+	decrement   bool
+	zeroFlag    bool
+	halfCounter bool
+}{
+	{"JCXZW", 0xe3, false, false, false},
+	{"JCXZL", 0xe3, false, false, true},
+	{"JCXZQ", 0xe3, false, false, false},
+	{"LOOP", 0xe2, true, false, false},
+	{"LOOPEQ", 0xe1, true, true, false},
+	{"LOOPNE", 0xe0, true, true, false},
+}
+
+func x86CounterControlSource(arch, op, name, omission string, backedge, observe bool) x86GPFaultingFixture {
+	word, move, suffix, typ := 8, "MOVQ", "Q", "uint64"
+	if arch == "386" {
+		word, move, suffix, typ = 4, "MOVL", "L", "uint32"
+	}
+	var body strings.Builder
+	fmt.Fprintf(&body, "%s p+%d(FP),SI\nMOVL (SI),DI\n", move, 2*word)
+	if omission != "counter" {
+		producer := move
+		if omission == "low-word" {
+			producer = "MOVW"
+		} else if omission == "low-dword" {
+			producer = "MOVL"
+		}
+		field, offset := "count", 0
+		if omission == "pointer-counter" {
+			field, offset = "p", 2*word
+		}
+		fmt.Fprintf(&body, "%s %s+%d(FP),CX\n", producer, field, offset)
+	}
+	if omission != "zero-flag" {
+		fmt.Fprintf(&body, "%s seed+%d(FP),AX\nCMP%s AX,$0\n", move, word, suffix)
+	}
+	body.WriteString("STC\n")
+	if backedge {
+		fmt.Fprintf(&body, "%s $0,BX\nagain:\nLEA%s 1(BX),BX\n%s again\n", move, suffix, op)
+	} else {
+		fmt.Fprintf(&body, "%s taken\n%s $200,BX\nJMP done\ntaken:\n%s $100,BX\ndone:\n", op, move, move)
+	}
+	if observe {
+		// Read CF/ZF before arithmetic changes them, and observe both the
+		// branch decision and LOOP's counter write in the returned value.
+		extend := "MOVBQZX"
+		if arch == "386" {
+			extend = "MOVBLZX"
+		}
+		fmt.Fprintf(&body, "SETCS DL\nSETEQ AL\n%s DL,DX\n%s AL,AX\nSHL%s $1,AX\nADD%s DX,AX\nLEA%s (BX)(CX*4),BX\nADD%s AX,BX\n",
+			extend, extend, suffix, suffix, suffix, suffix)
+	}
+	fmt.Fprintf(&body, "%s BX,ret+%d(FP)\nRET\n", move, 3*word)
+	return x86GPFaultingFixture{
+		name: name, source: fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s", name, 4*word, body.String()),
+		declaration: fmt.Sprintf("func %s(count,seed %s,p *uint32) %s", name, typ, typ),
+	}
+}
+
+func x86CounterControlGoObjects(t *testing.T, arch string, fixtures []x86GPFaultingFixture) {
+	t.Helper()
+	for start := 0; start < len(fixtures); start += 32 {
+		end := start + 32
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		var source strings.Builder
+		var names []string
+		for _, fixture := range fixtures[start:end] {
+			source.WriteString(fixture.source)
+			names = append(names, fixture.name)
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal("complete counter source must be accepted by actual Go", err)
+		}
+		code := x86GPSegmentListingBytes(t, listing, names)
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for _, fixture := range fixtures[start:end] {
+			counterBranches := 0
+			for offset := 0; offset < len(code[fixture.name]); {
+				instruction, err := x86asm.Decode(code[fixture.name][offset:], mode)
+				if err != nil || instruction.Len == 0 {
+					t.Fatal("actual Go counter function could not be independently decoded", fixture.name, offset, err)
+				}
+				for _, row := range x86CounterControlOracle {
+					if !strings.Contains(fixture.source, "\n"+row.op+" ") {
+						continue
+					}
+					if byte(instruction.Opcode>>24) == row.bytes {
+						want := mode
+						if row.halfCounter {
+							want /= 2
+						}
+						if instruction.AddrSize != want {
+							t.Fatal("actual Go encoded a different counter address width", fixture.name, instruction, want)
+						}
+						counterBranches++
+					}
+				}
+				offset += instruction.Len
+			}
+			if counterBranches != 1 {
+				t.Fatal("actual Go lost the one complete counter branch", fixture.name, counterBranches)
+			}
+		}
+	}
+}
+
+func TestX86CounterControlCompleteReachingInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var fixtures []x86GPFaultingFixture
+			for _, row := range x86CounterControlOracle {
+				for _, backedge := range []bool{false, true} {
+					if backedge && !row.decrement {
+						continue
+					}
+					for _, omission := range []string{"", "counter", "pointer-counter", "low-word", "low-dword", "zero-flag"} {
+						fixture := x86CounterControlSource(arch, row.op, fmt.Sprintf("Counter%d", len(fixtures)), omission, backedge, false)
+						fixture.accept = omission == "" || omission == "low-dword" ||
+							omission == "zero-flag" && !row.zeroFlag || omission == "low-word" && arch == "386" && row.halfCounter
+						fixture.label = fmt.Sprintf("%s/backedge=%t/%s", row.op, backedge, omission)
+						fixtures = append(fixtures, fixture)
+					}
+				}
+			}
+			x86CounterControlGoObjects(t, arch, fixtures)
+			for _, fixture := range fixtures {
+				t.Run(fixture.label, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, arch, testTargetTriple("linux", arch), api)
+							if fixture.accept {
+								if err != nil || ir == "" {
+									t.Fatal("INITIALIZED_COUNTER_REJECTED", err, fixture.source)
+								}
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("COUNTER_INPUT_NOT_PROVED", err, fixture.source)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86CounterControlCompleteObjectPrograms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var fixtures []x86GPFaultingFixture
+			var source, declarations strings.Builder
+			for _, row := range x86CounterControlOracle {
+				for _, backedge := range []bool{false, true} {
+					if backedge && !row.decrement {
+						continue
+					}
+					fixture := x86CounterControlSource(target.arch, row.op, fmt.Sprintf("Counter%d", len(fixtures)), "", backedge, true)
+					fixtures = append(fixtures, fixture)
+					source.WriteString(fixture.source)
+					declarations.WriteString(fixture.declaration + "\n")
+				}
+			}
+			x86CounterControlGoObjects(t, target.arch, fixtures)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("INITIALIZED_COUNTER_OBJECT_REJECTED", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_counter_control_portable_runtime_test.go b/x86_counter_control_portable_runtime_test.go
new file mode 100644
index 000000000..bd379f1ba
--- /dev/null
+++ b/x86_counter_control_portable_runtime_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86CounterPortableProgram struct {
+	fixture               x86GPFaultingFixture
+	kind                  int
+	half, back, fromCount bool
+}
+
+func x86CounterPortablePrograms(arch string) []x86CounterPortableProgram {
+	word, move, suffix, typ := 8, "MOVQ", "Q", "uint64"
+	if arch == "386" {
+		word, move, suffix, typ = 4, "MOVL", "L", "uint32"
+	}
+	var programs []x86CounterPortableProgram
+	for _, row := range x86CounterControlOracle {
+		for _, back := range []bool{false, true} {
+			if back && !row.decrement {
+				continue
+			}
+			for _, fromCount := range []bool{false, true} {
+				name := fmt.Sprintf("PortableCounter%d", len(programs))
+				fixture := x86CounterControlSource(arch, row.op, name, "", back, true)
+				// The runtime oracle observes only scalar arguments. It needs
+				// neither a synthetic pointer nor a memory-read trigger: the
+				// complete counter effect already requires its NUM inputs.
+				memory := fmt.Sprintf("%s p+%d(FP),SI\nMOVL (SI),DI\n", move, 2*word)
+				if strings.Count(fixture.source, memory) != 1 {
+					panic("counter oracle lost its exact memory prologue")
+				}
+				fixture.source = strings.Replace(fixture.source, memory, "", 1)
+				fixture.source = strings.Replace(fixture.source, fmt.Sprintf("$0-%d\n", 4*word), fmt.Sprintf("$0-%d\n", 3*word), 1)
+				fixture.source = strings.Replace(fixture.source, fmt.Sprintf("ret+%d(FP)", 3*word), fmt.Sprintf("ret+%d(FP)", 2*word), 1)
+				fixture.declaration = fmt.Sprintf("func %s(count,seed %s) %s", name, typ, typ)
+				if fromCount {
+					fixture.source = strings.Replace(fixture.source, "CMP"+suffix+" AX,$0\n", "CMP"+suffix+" CX,$0\n", 1)
+				}
+				kind := 0
+				switch row.op {
+				case "LOOP":
+					kind = 1
+				case "LOOPEQ":
+					kind = 2
+				case "LOOPNE":
+					kind = 3
+				}
+				programs = append(programs, x86CounterPortableProgram{fixture, kind, row.halfCounter, back, fromCount})
+			}
+		}
+	}
+	return programs
+}
+
+func x86CounterPortableDriver(t *testing.T, ir, arch string, programs []x86CounterPortableProgram) string {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer module.Dispose()
+	names := make(map[string]string)
+	for function := module.FirstFunction(); !function.IsNil(); function = llvm.NextFunction(function) {
+		if function.FirstBasicBlock().IsNil() {
+			continue
+		}
+		for _, program := range programs {
+			name := program.fixture.name
+			if function.Name() == name || strings.HasSuffix(function.Name(), "."+name) {
+				if names[name] != "" {
+					t.Fatal("ambiguous actual counter function", name)
+				}
+				names[name] = function.Name()
+			}
+		}
+	}
+	if len(names) != len(programs) {
+		t.Fatal("runtime oracle lost an actual complete source function", len(names), len(programs))
+	}
+	word, bits := "unsigned long long", 64
+	if arch == "386" {
+		word, bits = "unsigned int", 32
+	}
+	var source strings.Builder
+	source.WriteString(runtimeCAsmLabelPreamble)
+	fmt.Fprintf(&source, "typedef %s Word;\nextern int printf(const char*,...);\n", word)
+	for index, program := range programs {
+		symbol := names[program.fixture.name]
+		if runtime.GOOS == "darwin" {
+			symbol = "_" + symbol // __asm__ names the actual Mach-O linker symbol.
+		}
+		fmt.Fprintf(&source, "extern Word function%d(Word,Word) __asm__(%s);\n", index, runtimeCAsmLabel(symbol))
+	}
+	source.WriteString("struct Case { Word(*function)(Word,Word); int kind,half,back,from_count; };\nstatic const struct Case cases[]={\n")
+	for index, program := range programs {
+		bit := func(value bool) int {
+			if value {
+				return 1
+			}
+			return 0
+		}
+		fmt.Fprintf(&source, "{function%d,%d,%d,%d,%d},\n", index, program.kind, bit(program.half), bit(program.back), bit(program.fromCount))
+	}
+	source.WriteString("};\n")
+	fmt.Fprintf(&source, "enum { WORD_BITS=%d };\n", bits)
+	// This independent scalar reference caches the original comparison flags.
+	// In particular, decrementing CX never recomputes ZF or clears STC's CF.
+	source.WriteString(`
+static Word reference(const struct Case *c, Word count, Word seed) {
+    unsigned zf=c->from_count ? count==0 : seed==0;
+    Word marker;
+    if (!c->kind) {
+        Word mask=c->half ? (((Word)1<<(WORD_BITS/2))-1) : ~(Word)0;
+        marker=(count&mask)==0 ? 100 : 200;
+    } else if (c->back) {
+        marker=0;
+        do {
+            marker++;
+            count--;
+        } while (count && (c->kind==1 || (c->kind==2 ? zf : !zf)));
+    } else {
+        count--;
+        unsigned taken=count && (c->kind==1 || (c->kind==2 ? zf : !zf));
+        marker=taken ? 100 : 200;
+    }
+    return marker+count*4+1+zf*2;
+}
+int main(void) {
+    static const unsigned long long inputs[]={
+        0,1,2,3,17,0xffff,0x10000,0xffffffffULL,
+        0x100000000ULL,0x8000000000000000ULL,0xffffffffffffffffULL
+    };
+    unsigned checked=0;
+    for (unsigned i=0;i<sizeof(cases)/sizeof(cases[0]);i++) {
+        for (unsigned j=0;j<sizeof(inputs)/sizeof(inputs[0]);j++) {
+            Word count=(Word)inputs[j];
+            if (cases[i].back && (count==0 || count>17)) continue;
+            for (Word seed=0;seed<2;seed++) {
+                Word want=reference(&cases[i],count,seed);
+                Word got=cases[i].function(count,seed);
+                if (got!=want) {
+                    printf("case=%u count=%llx seed=%llu got=%llx want=%llx\n",
+                           i,(unsigned long long)count,(unsigned long long)seed,
+                           (unsigned long long)got,(unsigned long long)want);
+                    return 1;
+                }
+                checked++;
+            }
+        }
+    }
+    printf("COUNTER_RUNTIME checked=%u\n",checked);
+    return checked==312 ? 0 : 2;
+}
+`)
+	return source.String()
+}
+
+func TestX86CounterControlPortableRuntime(t *testing.T) {
+	llc, clang := findLLVM22Tool("llc"), findLLVM22Tool("clang")
+	if llc == "" || clang == "" {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, arch := range []string{"amd64", "386"} {
+		programs := x86CounterPortablePrograms(arch)
+		var fixtures []x86GPFaultingFixture
+		var assembly, declarations strings.Builder
+		for _, program := range programs {
+			fixtures = append(fixtures, program.fixture)
+			assembly.WriteString(program.fixture.source)
+			declarations.WriteString(program.fixture.declaration + "\n")
+		}
+		x86CounterControlGoObjects(t, arch, fixtures)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized portable counter program rejected", err)
+				}
+				driver := x86CounterPortableDriver(t, ir, arch, programs)
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(level, func(t *testing.T) {
+						directory := t.TempDir()
+						input, main := filepath.Join(directory, "counter.ll"), filepath.Join(directory, "counter.c")
+						object, executable := filepath.Join(directory, "counter.o"), filepath.Join(directory, "counter")
+						if runtime.GOOS == "windows" {
+							executable += ".exe"
+						}
+						for path, contents := range map[string]string{input: ir, main: driver} {
+							if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+								t.Fatal(err)
+							}
+						}
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+triple, "-relocation-model=pic", "-filetype=obj", input, "-o", object))
+						ctx, cancel := runtimeOracleStageContext(t)
+						defer cancel()
+						process := runtimeOracleProcessSource(t, directory)
+						x86FloatCompareCaptureCommand(t, runtimeOracleNativeCCommand(t, ctx, clang, level, object, main, process, "-o", executable))
+						output := x86FloatCompareCaptureCommand(t, exec.Command(executable))
+						if strings.TrimSpace(string(output)) != "COUNTER_RUNTIME checked=312" {
+							t.Fatal("independent counter runtime did not complete every bounded input", string(output))
+						}
+						t.Logf("COUNTER_EXECUTED source=%s host=%s api=%s level=%s cases=312", arch, triple, api, level)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_counter_control_source_owner_test.go b/x86_counter_control_source_owner_test.go
new file mode 100644
index 000000000..b8d23d8ab
--- /dev/null
+++ b/x86_counter_control_source_owner_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86CounterControlCanonicalAndExactFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86CounterControlOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, row.op+" done")
+				var before [16]uint8
+				for index := range before {
+					before[index] = 0xff
+				}
+				want := before
+				if row.decrement {
+					want[1] = 0
+					if arch == "386" {
+						want[1] = 0xf0
+					}
+				}
+				if got := x86RegisterCanonicalBytesAfter(ins, before, arch); got != want {
+					t.Error("counter control retained a stale canonical value or killed an unrelated alias", got, want)
+				}
+				if arch != "amd64" {
+					return // The existing exact caller-length domain is amd64-only.
+				}
+				facts := x86CallerCountedNumbers{regs: map[Reg]x86CallerCountedNumber{
+					CX: {value: 2, known: true, version: 7}, BX: {value: 9, known: true, version: 8}},
+					flags: x86CallerCountedFlags{pc: 3, op: "CMPQ", known: true}, sequence: 10}
+				flags, unrelated := facts.flags, facts.regs[BX]
+				facts.step(4, 0, ins, x86SourceStackState{}, nil)
+				_, count := facts.regs[CX]
+				if count == row.decrement || facts.flags != flags || facts.regs[BX] != unrelated {
+					t.Error("counter control retained its old exact count/version or changed unrelated facts", facts)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CounterControlCallerNumericalInputs(t *testing.T) {
+	for _, row := range x86CounterControlOracle {
+		for _, input := range []struct {
+			name    string
+			mask    uint8
+			pointer bool
+		}{
+			{"missing", 0, false}, {"word", 3, false}, {"dword", 15, false},
+			{"complete", 255, false}, {"opaque", 255, true},
+		} {
+			t.Run(row.op+"/"+input.name, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, row.op+" done")
+				state := x86SourceStackState{known: map[Reg]uint8{CX: input.mask, BX: 255},
+					callers: map[Reg]x86CallerPointerValue{}, numericFlags: true}
+				if input.pointer {
+					state.callers[CX] = x86CallerPointerValue{argument: 0}
+				}
+				want := !input.pointer && (input.mask == 255 || input.mask == 15 && row.halfCounter)
+				_, valid := x86CallerScalarStep(&ins, &state, &x86GoCallerRegionProof{})
+				if valid != want {
+					t.Fatal("registered caller count consumed an absent/opaque/partial numerical input", valid, want)
+				}
+				if valid && row.decrement && state.known[CX] != 255 {
+					t.Fatal("counter write lost its complete numerical result")
+				}
+			})
+		}
+	}
+}
+
+func x86CounterCallerAPI(t *testing.T, pkg GoPackage, file *File, source, api string) (string, error) {
+	t.Helper()
+	resolve := func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return module.String(), nil
+	}
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		FileName: "kernel_amd64.s", GOARCH: "amd64", TargetTriple: options.TargetTriple, ResolveSym: resolve,
+	})
+	if translated != nil && !translated.Module.IsNil() {
+		defer translated.Module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return translated.Module.String(), nil
+}
+
+func TestX86CounterControlRegisteredCallerSource(t *testing.T) {
+	declaration := strings.ReplaceAll(x86CallerFixtureSource, "float32", "uint64")
+	for _, row := range x86CounterControlOracle {
+		for _, input := range []string{"complete", "counter", "pointer-counter", "low-word", "low-dword", "zero-flag"} {
+			t.Run(row.op+"/"+input, func(t *testing.T) {
+				producer := "MOVQ (CX),CX\n"
+				switch input {
+				case "counter":
+					producer = "MOVQ R11,CX\n"
+				case "pointer-counter":
+					producer = ""
+				case "low-word":
+					producer = "MOVW (CX),CX\n"
+				case "low-dword":
+					producer = "MOVL (CX),CX\n"
+				}
+				flags := "MOVL $0,AX\nCMPL AX,$0\n"
+				if input == "zero-flag" {
+					flags = "MOVL $0,AX\n"
+				}
+				body := producer + flags + row.op + " counter_done\nMOVQ $2,BX\nJMP counter_out\n" +
+					"counter_done:\nMOVQ $3,BX\ncounter_out:\nMOVQ BX,(DX)"
+				source := strings.Replace(x86CallerFixtureAssembly, "MOVL $7,AX\nMOVL AX,(DX)", body, 1)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				pkg, file := x86CallerCoreFixture(t, declaration, source)
+				want := input == "complete" || input == "low-dword" || input == "zero-flag" && !row.zeroFlag
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86CounterCallerAPI(t, pkg, file, source, api)
+						if want {
+							if err != nil || ir == "" {
+								t.Fatal("initialized actual caller lost its counter inputs", err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual caller source invented count or ZF input", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86CounterControlRegisteredScalarSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		suffix, typ := "Q", "uint64"
+		if arch == "386" {
+			suffix, typ = "L", "uint32"
+		}
+		for _, row := range x86CounterControlOracle {
+			for _, input := range []string{"complete", "counter", "low-word", "low-dword", "zero-flag", "physical-low-word", "physical-low-dword"} {
+				t.Run(arch+"/"+row.op+"/"+input, func(t *testing.T) {
+					producer := "@MOV @WORD(SP),CX\n"
+					if input == "counter" {
+						producer = ""
+					} else if input == "low-word" {
+						producer = "@MOV @WORD(SP),AX\nMOVW AX,CX\n"
+					} else if input == "low-dword" {
+						producer = "@MOV @WORD(SP),AX\nMOVL AX,CX\n"
+					} else if input == "physical-low-word" {
+						producer = "MOVW @WORD(SP),CX\n"
+					} else if input == "physical-low-dword" {
+						producer = "MOVL @WORD(SP),CX\n"
+					}
+					flags := "@MOV $0,AX\nCMP" + suffix + " AX,$0\n"
+					if input == "zero-flag" {
+						flags = "@MOV $0,AX\n"
+					}
+					body := producer + flags + row.op + " count_done\n@MOV $2,BX\nJMP count_out\n" +
+						"count_done:\n@MOV $3,BX\ncount_out:\n@MOV BX,@RESULT(SP)\nBYTE $0xc3"
+					source, _, _ := x86SourceStackNumericalFixture(arch, body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					want := input == "complete" || input == "low-dword" || input == "zero-flag" && !row.zeroFlag ||
+						input == "low-word" && arch == "386" && row.halfCounter || input == "physical-low-dword" && arch == "386"
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x "+typ+") "+typ, arch, testTargetTriple("linux", arch), api)
+							if want {
+								if err != nil || ir == "" {
+									t.Fatal("initialized scalar source lost its actual physical parameter", err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("scalar source invented count or ZF input", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CounterControlDoesNotBorrowBranchHints(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86CounterControlOracle {
+			for _, hint := range []int{0, 1} {
+				body := fmt.Sprintf("%s $%d,done", row.op, hint)
+				source := "TEXT ·Value(SB),4,$0-0\n" + body + "\ndone:\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				ins := x86PureGPUnknownInstruction(t, body)
+				before := append([]Operand(nil), ins.Args...)
+				if args := x86DirectTailBranchArgs(ins); !reflect.DeepEqual(args, before) {
+					t.Fatal("counter target borrowed a FLAGS-branch hint projection")
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, testTargetTriple("linux", arch), api)
+					if err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("malformed original counter operands were accepted or hidden as Context", err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_cpu_query_input_dependencies_test.go b/x86_cpu_query_input_dependencies_test.go
new file mode 100644
index 000000000..8fccb8e32
--- /dev/null
+++ b/x86_cpu_query_input_dependencies_test.go
@@ -0,0 +1,228 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol. 2, CPUID, INPUT EAX = 0 and INPUT EAX = 80000000H:
+// these maximum-leaf queries have no ECX selector. Unknown and structured
+// leaves keep their ECX input; syntax acceptance alone supplies neither input.
+func TestX86CPUIDLeafDependentInputsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		for _, raw := range []bool{false, true} {
+			query := "CPUID\n"
+			if raw {
+				query = x86RawDisplacementDirectives([]byte{0x0f, 0xa2})
+			}
+			for _, row := range []struct {
+				name, setup string
+				valid       bool
+			}{
+				{"missing-eax", "", false},
+				{"partial-eax", "MOVB $0,AL\n", false},
+				{"basic-max", "MOVL $0,AX\n", true},
+				{"extended-max", "MOVL $0x80000000,AX\n", true},
+				{"signed-extended-max", "MOVL $-2147483648,AX\n", true},
+				{"xor-basic-max", "XORL AX,AX\n", true},
+				{"partial-xor", "XORW AX,AX\n", false},
+				{"unknown-leaf", "MOVL $1,AX\n", false},
+				{"structured-leaf", "MOVL $7,AX\n", false},
+				{"structured-partial-ecx", "MOVL $7,AX\nMOVB $0,CL\n", false},
+				{"structured-complete", "MOVL $7,AX\nMOVL $0,CX\n", true},
+				{"overwritten-leaf", "MOVL $0,AX\nMOVL $7,AX\n", false},
+				{"partial-overwrite", "MOVL $0,AX\nMOVB $7,AL\n", false},
+				{"word-overwrite", "MOVL $0,AX\nMOVW $7,AX\n", false},
+				{"arithmetic-overwrite", "MOVL $0,AX\nINCL AX\n", false},
+				{"unrelated-write", "MOVL $0,AX\nMOVL $7,DX\n", true},
+			} {
+				t.Run(fmt.Sprintf("%s/raw=%t/%s", arch, raw, row.name), func(t *testing.T) {
+					source := "TEXT ·Query(SB),4,$0-4\n" + row.setup + query + "MOVL AX,ret+0(FP)\nRET\n"
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Query() uint32", arch, triple, api)
+						if row.valid {
+							if err != nil || strings.Count(ir, "asm sideeffect \"cpuid\"") != 1 {
+								t.Error("architectural leaf inputs lost the original query/result", api, err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("query invented a missing leaf/subleaf input", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CPUIDLeafDependenciesResultsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, setup string }{
+			{"basic-max", "XORL AX,AX\n"},
+			{"extended-max", "MOVL $0x80000000,AX\n"},
+		} {
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/raw=%t", target.triple, row.name, raw), func(t *testing.T) {
+					query := "CPUID\n"
+					if raw {
+						query = x86RawDisplacementDirectives([]byte{0x0f, 0xa2})
+					}
+					// Keep every architectural output observable, including ECX,
+					// whose incoming value this particular leaf does not consume.
+					source := "TEXT ·Query(SB),4,$0-16\n" + row.setup + query +
+						"MOVL AX,a+0(FP)\nMOVL BX,b+4(FP)\nMOVL CX,c+8(FP)\nMOVL DX,d+12(FP)\nRET\n"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Query() (a,b,c,d uint32)", target.arch, target.triple, api)
+						if err != nil || strings.Count(ir, "asm sideeffect \"cpuid\"") != 1 {
+							t.Error("maximum-leaf query lost its initialized outputs", api, err)
+							continue
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CPUIDLeafFactsJoinAndOverwriteThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		declaration := "func Query(selector uint32) uint32"
+		pkg := mustGoPackage(t, "query", "package query\n"+declaration)
+		sig, err := DeriveGoFuncABI0Signature("Query", pkg.Types.Scope().Lookup("Query").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil || len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Type != I32 {
+			t.Fatal("actual Go ABI0 query result unavailable", err)
+		}
+		resultOffset := sig.Frame.Results[0].Offset
+		triple := "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		for _, row := range []struct {
+			name, body string
+			valid      bool
+		}{
+			{"same-leaf-join", "CMPL selector+0(FP),$0\nJE left\nMOVL $0,AX\nJMP ready\nleft:\nXORL AX,AX\nready:\nCPUID\n", true},
+			{"two-maxima-join", "CMPL selector+0(FP),$0\nJE left\nMOVL $0,AX\nJMP ready\nleft:\nMOVL $0x80000000,AX\nready:\nCPUID\n", true},
+			{"structured-path-join", "CMPL selector+0(FP),$0\nJE left\nMOVL $0,AX\nJMP ready\nleft:\nMOVL $7,AX\nready:\nCPUID\n", false},
+			{"undefined-path-join", "CMPL selector+0(FP),$0\nJE ready\nMOVL $0,AX\nready:\nCPUID\n", false},
+			{"entry-value", "MOVL selector+0(FP),AX\nCPUID\n", false},
+			{"entry-subleaf-defined", "MOVL selector+0(FP),AX\nMOVL $0,CX\nCPUID\n", true},
+			{"overwritten-from-entry", "MOVL $0,AX\nMOVL selector+0(FP),AX\nCPUID\n", false},
+			{"implicit-query-overwrite", "MOVL $0,AX\nRDTSC\nCPUID\n", false},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Query(SB),4,$0-%d\n%sMOVL AX,ret+%d(FP)\nRET\n", resultOffset+4, row.body, resultOffset)
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if row.valid {
+						if err != nil || ir == "" {
+							t.Error("safe leaf join lost its complete result flow", api, err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error("query reused a leaf fact after an unknown write or CFG path", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CPUIDLeafFactTrackingRequiresQuery(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, query := range []string{"", "CPUID", "cpuid"} {
+			t.Run(arch+"/query="+query, func(t *testing.T) {
+				body := "MOVL $0,AX\n"
+				if query != "" {
+					body += "CPUID\nMOVL $0,AX\n"
+				}
+				file, err := Parse(ArchAMD64, "TEXT ·Flow(SB),4,$0-0\n"+body+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for index := range file.Funcs[0].Instrs {
+					if file.Funcs[0].Instrs[index].Op == OpCPUID {
+						file.Funcs[0].Instrs[index].Op = Op(query)
+					}
+				}
+				returns := 0
+				err = checkX86ResultSourceFlow(file.Funcs[0], x86ResultState{}, nil, 0, arch,
+					func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, mode string) bool {
+						return x86ResultTransfer(ins, state, owned, offset, mode)
+					}, func(state x86ResultState, _ int) error {
+						returns++
+						if state.cpuidRootLeaf != (query != "") {
+							return fmt.Errorf("CPUID leaf fact tracking differs from the final source query inventory")
+						}
+						return nil
+					})
+				if err != nil || returns != 1 {
+					t.Fatal("unrelated source flow carried CPUID state or a real query lost it", err, returns)
+				}
+			})
+		}
+	}
+}
+
+func TestX86CPUIDMaximumLeavesCompleteSourceMoveAliases(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	aliases := append([]string{"MOVQ"}, x86OriginalMOVQAliases(t)...)
+	for _, target := range x86RawReturnTargets {
+		for _, alias := range aliases {
+			for _, leaf := range []struct {
+				name, value string
+				root        bool
+			}{
+				{"basic-max", "0", true},
+				{"extended-max", "0x80000000", true},
+				{"high32-basic-max", "0x100000000", true},
+				{"structured-leaf", "7", false},
+			} {
+				t.Run(target.triple+"/"+alias+"/"+leaf.name, func(t *testing.T) {
+					source := "TEXT ·Query(SB),4,$0-4\n" + alias + " $" + leaf.value + ",AX\nCPUID\nMOVL AX,ret+0(FP)\nRET\n"
+					// Go's complete MOVQ source aliases admit their GP/immediate
+					// rows only in mode64; no mode32 or SIMD role is invented.
+					if target.arch == "amd64" {
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					} else {
+						goAssemblerOracleOutput(t, target.arch, source, "", false)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Query() uint32", target.arch, target.triple, api)
+						if target.arch != "amd64" || !leaf.root {
+							if err == nil || ir != "" {
+								t.Error("alias supplied an illegal mode or missing subleaf input", api, err)
+							}
+							continue
+						}
+						if err != nil || strings.Count(ir, "asm sideeffect \"cpuid\"") != 1 {
+							t.Error("original GP source alias lost its architectural leaf dependency", api, err)
+							continue
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_cpu_query_result_test.go b/x86_cpu_query_result_test.go
new file mode 100644
index 000000000..39838cb9a
--- /dev/null
+++ b/x86_cpu_query_result_test.go
@@ -0,0 +1,203 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent architectural EAX/ECX inputs and zero-extended dword outputs.
+// GP domain order is AX, CX, DX, BX; these rows do not use the emitter spec.
+var x86CPUQueryResultOracle = []struct {
+	name            string
+	inputs, outputs []int
+	registers       []string
+	bytes           []byte
+}{
+	{"CPUID", []int{0, 1}, []int{0, 3, 1, 2}, []string{"AX", "BX", "CX", "DX"}, []byte{0x0f, 0xa2}},
+	{"XGETBV", []int{1}, []int{0, 2}, []string{"AX", "DX"}, []byte{0x0f, 0x01, 0xd0}},
+}
+
+func TestX86CPUQueryImplicitNUMEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86CPUQueryResultOracle {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.name)
+				before := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				before.valueStack = &x86ResultValueStack{bytes: []uint8{1, 2, 3, 4, 5, 6, 7, 8}, id: true}
+				before.xmm[3], before.masks[2] = 0x8888, true
+				for index := range before.pointerGP {
+					before.pointerGP[index], before.callerAddressGP[index] = true, true
+				}
+				for _, index := range row.inputs {
+					before.gp[index], before.pointerGP[index] = 0x0f, false
+				}
+				state, want := before.clone(), before.clone()
+				for _, index := range row.outputs {
+					want.gp[index], want.pointerGP[index] = 0xff, false
+				}
+				addresses := before.callerAddressGP
+				for _, index := range row.outputs {
+					addresses[index] = false
+				}
+				if after := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch); after != addresses {
+					t.Error("implicit output footprint retained a stale pointer or killed an input-only address")
+				}
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+					t.Error("query must consume only low dword inputs, define its full outputs and preserve unrelated state")
+				}
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof {
+					t.Error("query inputs must remain mandatory even without a result", err)
+				}
+				for _, input := range row.inputs {
+					for missing := uint(0); missing < 4; missing++ {
+						state := before.clone()
+						state.gp[input] &^= 1 << missing
+						unchanged := state.clone()
+						if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, unchanged) {
+							t.Error("query invented a missing input byte or partially wrote its outputs", input, missing)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CPUQueryVoidRequiresActualInputsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86CPUQueryResultOracle {
+			for _, raw := range []bool{false, true} {
+				body := row.name + "\n"
+				if raw {
+					body = x86RawDisplacementDirectives(row.bytes)
+				}
+				for _, initialization := range []struct {
+					name, source string
+					valid        bool
+				}{
+					{"missing-both", "", false},
+					{"missing-cx", "MOVL $0,AX\n", row.name == "CPUID"},
+					{"partial-cx", "MOVL $0,AX\nMOVB $0,CL\n", row.name == "CPUID"},
+					{"subleaf-missing-cx", "MOVL $7,AX\n", false},
+					{"subleaf-partial-cx", "MOVL $7,AX\nMOVB $0,CL\n", false},
+					{"partial-ax", "MOVB $0,AL\nMOVL $0,CX\n", row.name == "XGETBV"},
+					{"missing-ax", "MOVL $0,CX\n", row.name == "XGETBV"},
+					{"complete", "MOVL $0,AX\nMOVL $0,CX\n", true},
+				} {
+					name := fmt.Sprintf("%s/%s/raw=%t/%s", target.triple, row.name, raw, initialization.name)
+					t.Run(name, func(t *testing.T) {
+						source := "TEXT ·Query(SB),4,$0-0\n" + initialization.source + body + "RET\n"
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Query()", target.arch, target.triple, api)
+							if initialization.valid {
+								if err != nil || !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(row.name)+"\"") {
+									t.Error("initialized query lost its complete native opcode", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("Void query borrowed uninitialized implementation-slot inputs", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CPUQueryRawCompositionRetainsExactOriginalRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86CPUQueryResultOracle {
+			x86RegisterQueryRawCompositionRoles(t, arch, Op(row.name), row.bytes, "MOVL $0,AX\nMOVL $0,CX\n")
+		}
+	}
+}
+
+func TestX86CPUQueryEntryAndJoinInputsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVL", 4, "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			move, word, triple = "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		}
+		for _, row := range x86CPUQueryResultOracle {
+			for _, raw := range []bool{false, true} {
+				body := row.name + "\n"
+				if raw {
+					body = x86RawDisplacementDirectives(row.bytes)
+				}
+				for _, fixture := range []struct {
+					name, declaration, setup string
+					frame                    int
+					valid                    bool
+				}{
+					{"pointer-input", "p *uint32", move + " p+0(FP),CX\nMOVL $0,AX\n", word, row.name == "CPUID"},
+					{"subleaf-pointer-input", "p *uint32", move + " p+0(FP),CX\nMOVL $7,AX\n", word, false},
+					{"unused-bool", "unused bool", "", 1, false},
+					{"initialized-unused-bool", "unused bool", "MOVL $0,AX\nMOVL $0,CX\n", 1, true},
+					{"missing-join", "selector uint32", "MOVL selector+0(FP),AX\nCMPL AX,$0\nJE ready\nMOVL $0,CX\nready:\n", 4, false},
+					{"complete-join", "selector uint32", "MOVL selector+0(FP),AX\nMOVL $0,CX\nCMPL AX,$0\nJE ready\nMOVL $1,CX\nready:\n", 4, true},
+				} {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/%s", arch, row.name, raw, fixture.name), func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Query(SB),4,$0-%d\n%s%sRET\n", fixture.frame, fixture.setup, body)
+						x86LEAActualTargetGoObject(t, arch, triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Query("+fixture.declaration+")", arch, triple, api)
+							if fixture.valid {
+								if err != nil || ir == "" {
+									t.Error("initialized query lost an independent entry/CFG control", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("query invented numerical inputs from pointers, bools or a missing CFG path", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CPUQueryInitializedResultsThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86CPUQueryResultOracle {
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/raw=%t", target.triple, row.name, raw), func(t *testing.T) {
+					var source strings.Builder
+					fmt.Fprintf(&source, "TEXT ·Query(SB),4,$0-%d\nMOVL leaf+0(FP),AX\nMOVL subleaf+4(FP),CX\n", 8+4*len(row.outputs))
+					if raw {
+						source.WriteString(x86RawDisplacementDirectives(row.bytes))
+					} else {
+						source.WriteString(row.name + "\n")
+					}
+					for index, register := range row.registers {
+						fmt.Fprintf(&source, "MOVL %s,out%d+%d(FP)\n", register, index, 8+4*index)
+					}
+					source.WriteString("RET\n")
+					returns := strings.TrimSuffix(strings.Repeat("uint32,", len(row.outputs)), ",")
+					declaration := "func Query(leaf,subleaf uint32) (" + returns + ")"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Error("query lost its initialized implicit outputs", api, err)
+							continue
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_crc32_effects_test.go b/x86_crc32_effects_test.go
new file mode 100644
index 000000000..cc28a53f0
--- /dev/null
+++ b/x86_crc32_effects_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86CRC32SparseNUMFlagsAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86CRC32ResultCases(arch) {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				register := x86ScalarLaneInstruction(t, row.op+" BX,AX")
+				native := x86ScalarLaneInstruction(t, row.op+" -1(DX)(BX*1),AX")
+				bx, _, _ := x86ResultGP(BX, 4, arch)
+				dx, _, _ := x86ResultGP(DX, 4, arch)
+				for mask := 0; mask < 256; mask++ {
+					for _, sourceMask := range []uint8{0, 1, 3, 15, 255} {
+						for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagZF, x86ByteFlagsAll} {
+							state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+							state.gp[0], state.gp[bx] = uint8(mask), sourceMask
+							before := state.clone()
+							accepted := mask&15 == 15 && int(sourceMask)&((1<<uint(row.width))-1) == (1<<uint(row.width))-1
+							if got := x86ScalarFPResultTransfer(register, &state, nil, 0, arch); got != accepted {
+								t.Fatal("CRC did not read exact old-low32 and source bytes", mask, sourceMask, got, accepted)
+							}
+							if accepted {
+								before.gp[0] = 255
+							}
+							if !reflect.DeepEqual(state, before) {
+								t.Fatal("CRC changed unrelated bytes/status/direction", state, before)
+							}
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+						state.gp[0], state.gp[bx], state.pointerGP[dx] = uint8(mask), sourceMask, true
+						before := state.clone()
+						indexMask := uint8(255)
+						if arch == "386" {
+							indexMask = 15
+						}
+						accepted := mask&15 == 15 && sourceMask&indexMask == indexMask
+						if got, known := x86LoweredCRC32NativeRead(native, &state, nil, 0, arch); !known || got != accepted {
+							t.Fatal("native CRC inferred input/address knowledge", mask, sourceMask, got, known)
+						}
+						if accepted {
+							before.gp[0] = 255
+						}
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("native CRC changed unrelated state", state, before)
+						}
+					}
+				}
+				for _, origin := range []string{"raw", "decoded", "address", "segment", "numerical-address", "pointer-accumulator"} {
+					changed := native
+					state := x86ResultState{}
+					state.gp[0], state.gp[bx], state.pointerGP[dx] = 255, 255, true
+					switch origin {
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "decoded":
+						changed.x86Encoded = true
+					case "address":
+						changed.x86AddressBits = 32
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "numerical-address":
+						state.pointerGP[dx], state.gp[dx] = false, 255
+					case "pointer-accumulator":
+						state.pointerGP[0], state.gp[0] = true, 0
+					}
+					before := state.clone()
+					if origin == "numerical-address" {
+						want := before.clone()
+						want.gp[0] = 255
+						if accepted, known := x86LoweredCRC32NativeRead(changed, &state, nil, 0, arch); !known || !accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("numeric CRC source changed exact result or independent state")
+						}
+						continue
+					}
+					if accepted, known := x86LoweredCRC32NativeRead(changed, &state, nil, 0, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("unbound CRC origin gained a conditional read", origin)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CRC32GrammarBanksAndOriginalIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86CRC32ResultCases(arch) {
+			for _, bank := range []string{"source", "destination"} {
+				for _, reg := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH BL BH CL CH DL DH SPB BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B X0 Y0 Z0 K1 M0 FS TLS R16") {
+					t.Run(arch+"/"+row.op+"/"+bank+"/"+reg, func(t *testing.T) {
+						source, dest := reg, "AX"
+						if bank == "destination" {
+							source, dest = "BX", reg
+						}
+						ins := x86ScalarLaneInstruction(t, row.op+" "+source+","+dest)
+						original := ins
+						original.Args = append([]Operand(nil), ins.Args...)
+						gp := strings.Contains(" AX CX DX BX SP BP SI DI ", " "+reg+" ") || arch == "amd64" && strings.Contains(" R8 R9 R10 R11 R12 R13 R14 R15 ", " "+reg+" ")
+						valid := gp
+						if bank == "source" && row.width == 1 {
+							valid = gp && (arch != "386" || reg != "SP") || strings.Contains(" AL AH BL BH CL CH DL DH ", " "+reg+" ") || arch == "amd64" && strings.Contains(" BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B ", " "+reg+" ")
+						}
+						_, known, err := x86CRC32Properties(ins.Op, ins, arch)
+						if !known || (err == nil) != valid || !reflect.DeepEqual(ins, original) {
+							t.Fatal("CRC bank grammar or original identity changed", valid, known, err)
+						}
+						if _, registered, _ := x86TypedGPByteEffect(ins.Op, ins, arch); registered {
+							t.Fatal("NUM grammar leaked into independent raw/caller GP directory")
+						}
+					})
+				}
+			}
+		}
+		for _, source := range []string{"CRC32L $1,AX", "CRC32L $0.5,AX", "CRC32L $table(SB),AX", "CRC32L (BX)(SI*3),AX", "CRC32L (BX)(SP*1),AX", "CRC32L.Z BX,AX", "CRC32L BX", "CRC32L AX,BX,CX"} {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+source+"\nRET\n")
+			if err != nil {
+				continue // Invalid parser syntax never reaches a typed instruction row.
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, known, err := x86CRC32Properties(ins.Op, ins, arch); !known || err == nil {
+				t.Fatal("invalid CRC row granted an effect", arch, source)
+			}
+		}
+	}
+	for _, source := range []string{"CRC32B AH,R8", "CRC32B CH,R8"} {
+		ins := x86ScalarLaneInstruction(t, source)
+		ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+		before := output.String()
+		if known, _, err := ctx.lowerCrc32(ins.Op, ins); !known || !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+			t.Fatal("derived physical SP/BP source acquired a binding", source, err)
+		}
+	}
+}
+
+func TestX86CRC32PhysicalByteNormalizationAndScanner(t *testing.T) {
+	for _, row := range []struct{ source, destination, physical string }{
+		{"SI", "AX", "DH"}, {"DI", "AX", "BH"}, {"BP", "AX", "CH"}, {"SP", "AX", "AH"},
+		{"SI", "R8", "SI"}, {"AH", "R8", "SP"}, {"CH", "R8", "BP"}, {"SIB", "AX", "SIB"},
+	} {
+		ins := x86ScalarLaneInstruction(t, "CRC32B "+row.source+","+row.destination)
+		form, known, err := x86CRC32Properties(ins.Op, ins, "amd64")
+		if !known || err != nil || form.source.Reg != Reg(row.physical) {
+			t.Fatal("typed CRC differs from independently observed original Go bytes", row, form, err)
+		}
+		fn := Func{Instrs: []Instr{ins}}
+		ctx, _ := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Ret: Void}, nil)
+		root := form.source.Reg
+		if base, _, valid := amd64ByteAlias(root); valid {
+			root = base
+		}
+		if !ctx.usedRegs[root] {
+			t.Fatal("register scan omitted actual CRC source", row, root)
+		}
+		ins.x86Encoded = true
+		raw, _, err := x86CRC32Properties(ins.Op, ins, "amd64")
+		if err != nil || raw.source.Reg != ins.Args[0].Reg {
+			t.Fatal("named source byte alias was lent to physical raw syntax", row, raw, err)
+		}
+	}
+}
+
+func TestX86CRC32UnownedMemoryAndProvenanceThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86CRC32ResultCases(target.arch) {
+			for _, memory := range []string{"(SI)", "table(SB)", "-4(SP)", "ret+1(FP)"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.op+"/"+memory+"/"+api, func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-4\nMOVL $0,AX\nMOVL $7,SI\n%s %s,AX\nMOVL AX,ret+0(FP)\nRET\n", row.op, memory)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api)
+						if memory == "(SI)" {
+							if err != nil || strings.Count(ir, fmt.Sprintf("load volatile i%d,", row.width*8)) != 1 {
+								t.Fatal("CRC numeric address lost its exact native source", err)
+							}
+							x86RequireNumericNativeSourceContext(t, source, "func Value() uint32", target.arch)
+							x86NumericNativeAddressObject(t, ir, target.triple)
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("CRC shape supplied native/FP/AUTO/SB backing", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_crc32_encoding_test.go b/x86_crc32_encoding_test.go
new file mode 100644
index 000000000..f9b22c968
--- /dev/null
+++ b/x86_crc32_encoding_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"testing"
+)
+
+func TestX86CRC32CompleteOfficialGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, want := range map[string]string{
+		"ycrc32b": "{Zlitm_r,0,argList{Ymb,Yrl}},",
+		"ycrc32l": "{Zlitm_r,0,argList{Yml,Yrl}},",
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(match) != 2 || regexp.MustCompile(`\s+`).ReplaceAllString(string(match[1]), "") != want {
+			t.Fatal("complete official Go CRC rows changed", table)
+		}
+	}
+	actual := regexp.MustCompile(`\{ACRC32[BWLQ], [^\n]+`).FindAllString(string(data), -1)
+	want := []string{
+		"{ACRC32B, ycrc32b, Px, opBytes{0xf2, 0x0f, 0x38, 0xf0, 0}},",
+		"{ACRC32L, ycrc32l, Px, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},",
+		"{ACRC32Q, ycrc32l, Pw, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},",
+		"{ACRC32W, ycrc32l, Pe, opBytes{0xf2, 0x0f, 0x38, 0xf1, 0}},",
+	}
+	if !reflect.DeepEqual(actual, want) {
+		t.Fatal("complete opcode/table/prefix/byte attributes changed", actual)
+	}
+}
+
+func TestX86CRC32OriginalGoByteViews(t *testing.T) {
+	for _, row := range []struct {
+		arch, instruction string
+		bytes             []byte
+	}{
+		{"amd64", "CRC32B BX,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc3}},
+		{"amd64", "CRC32W BX,AX", []byte{0x66, 0xf2, 0x0f, 0x38, 0xf1, 0xc3}},
+		{"amd64", "CRC32L BX,AX", []byte{0xf2, 0x0f, 0x38, 0xf1, 0xc3}},
+		{"amd64", "CRC32Q BX,AX", []byte{0xf2, 0x48, 0x0f, 0x38, 0xf1, 0xc3}},
+		{"amd64", "CRC32B SI,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc6}},
+		{"amd64", "CRC32B DI,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc7}},
+		{"amd64", "CRC32B BP,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc5}},
+		{"amd64", "CRC32B SP,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc4}},
+		{"amd64", "CRC32B SI,R8", []byte{0xf2, 0x44, 0x0f, 0x38, 0xf0, 0xc6}},
+		{"amd64", "CRC32B AH,R8", []byte{0xf2, 0x44, 0x0f, 0x38, 0xf0, 0xc4}},
+		{"amd64", "CRC32B SIB,AX", []byte{0xf2, 0x40, 0x0f, 0x38, 0xf0, 0xc6}},
+		{"386", "CRC32B BX,AX", []byte{0xf2, 0x0f, 0x38, 0xf0, 0xc3}},
+		{"386", "CRC32W BX,AX", []byte{0x66, 0xf2, 0x0f, 0x38, 0xf1, 0xc3}},
+		{"386", "CRC32L BX,AX", []byte{0xf2, 0x0f, 0x38, 0xf1, 0xc3}},
+		{"386", "CRC32B BP,AX", []byte{0x87, 0xdd, 0xf2, 0x0f, 0x38, 0xf0, 0xc3, 0x87, 0xdd}},
+		{"386", "CRC32B SI,AX", []byte{0x87, 0xde, 0xf2, 0x0f, 0x38, 0xf0, 0xc3, 0x87, 0xde}},
+		{"386", "CRC32B DI,AX", []byte{0x87, 0xdf, 0xf2, 0x0f, 0x38, 0xf0, 0xc3, 0x87, 0xdf}},
+	} {
+		t.Run(row.arch+"/"+row.instruction, func(t *testing.T) {
+			actual := x86OrderingHintGoBytes(t, row.arch, "TEXT crc(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+			if !bytes.Equal(actual, append(append([]byte(nil), row.bytes...), 0xc3)) {
+				t.Fatalf("actual Go byte view %x, independent complete row %x", actual, row.bytes)
+			}
+		})
+	}
+}
diff --git a/x86_crc32_objects_test.go b/x86_crc32_objects_test.go
new file mode 100644
index 000000000..fac9b458e
--- /dev/null
+++ b/x86_crc32_objects_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86CRC32CompleteOriginalGoRegisterBanks(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var bank strings.Builder
+		bank.WriteString("TEXT bank(SB),4,$0-32\n")
+		gp := strings.Fields("AX CX DX BX SP BP SI DI")
+		if arch == "amd64" {
+			gp = append(gp, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15")...)
+		}
+		for _, row := range x86CRC32ResultCases(arch) {
+			sources := append([]string(nil), gp...)
+			if row.width == 1 {
+				sources = append(sources, strings.Fields("AL AH BL BH CL CH DL DH")...)
+				if arch == "amd64" {
+					sources = append(sources, strings.Fields("BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B")...)
+				}
+			}
+			for _, source := range sources {
+				if arch == "386" && row.width == 1 && source == "SP" {
+					continue // The actual Go bad-byte fallback has no direct SP row.
+				}
+				fmt.Fprintf(&bank, "%s %s,AX\n", row.op, source)
+			}
+			for _, destination := range gp {
+				fmt.Fprintf(&bank, "%s BX,%s\n", row.op, destination)
+			}
+			for _, source := range []string{"x+0(FP)", "x+1(FP)", "slot-8(SP)", "table(SB)", "-1(DX)(SI*2)"} {
+				fmt.Fprintf(&bank, "%s %s,AX\n", row.op, source)
+			}
+		}
+		bank.WriteString("RET\n")
+		t.Run(arch+"/complete-bank", func(t *testing.T) {
+			goAssemblerOracleOutput(t, arch, bank.String(), "", true)
+		})
+		for _, instruction := range []string{"CRC32B SPB,AX", "CRC32B X0,AX", "CRC32W AL,AX", "CRC32L AX,AL", "CRC32L AX,(BX)", "CRC32L $1,AX", "CRC32L $x(SB),AX", "CRC32L (BX)(SI*3),AX"} {
+			t.Run(arch+"/invalid/"+instruction, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT bad(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			})
+		}
+		if arch == "386" {
+			for _, instruction := range []string{"CRC32Q BX,AX", "CRC32B SP,AX", "CRC32B R8B,AX", "CRC32L BX,R8"} {
+				t.Run(arch+"/invalid/"+instruction, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT bad(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+				})
+			}
+		}
+	}
+}
+
+func x86CRC32TypedFixture(arch string, row x86CRC32ResultCase, kind string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	declaration, body, frame, args := "func Value() uint32", "", 0, 4
+	switch kind {
+	case "register":
+		body = "MOVL $0x76543210,AX\nMOVL $0x12345678,BX\n" + row.op + " BX,AX\nMOVL AX,ret+0(FP)\n"
+	case "FP":
+		declaration, args = "func Value() (uint32,uint32,uint32,uint32,uint32)", 20
+		body = "MOVL $0x04030201,ret+0(FP)\nMOVL $0x08070605,ret+4(FP)\nMOVL $0x0c0b0a09,ret+8(FP)\nMOVL $0,AX\n" + row.op + " ret+1(FP),AX\nMOVL AX,ret+12(FP)\nMOVL $0,ret+16(FP)\n"
+	case "AUTO":
+		frame = 8
+		body = "MOVL $0x04030201,slot-8(SP)\nMOVL $0x08070605,slot-4(SP)\nMOVL $0,AX\n" + row.op + " slot-8(SP),AX\nMOVL AX,ret+0(FP)\n"
+	case "native", "dead-native":
+		declaration, args = "func Value(crc uint32,p *byte) uint32", 2*word+4
+		body = fmt.Sprintf("MOVL crc+0(FP),AX\n%s p+%d(FP),SI\n%s (SI),AX\n", move, word, row.op)
+		if kind == "dead-native" {
+			body += "MOVL $7,AX\n"
+		}
+		body += fmt.Sprintf("MOVL AX,ret+%d(FP)\n", 2*word)
+	default:
+		panic("unknown complete CRC fixture role")
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$%d-%d\n%sRET\n", frame, args, body), declaration
+}
+
+func TestX86CRC32FiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete CRC32 objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86CRC32ResultCases(target.arch) {
+				for _, kind := range []string{"register", "FP", "AUTO", "native", "dead-native"} {
+					body, declaration := x86CRC32TypedFixture(target.arch, row, kind)
+					name := fmt.Sprintf("CRC%d", count)
+					source.WriteString(strings.ReplaceAll(body, "Value", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+					count++
+				}
+			}
+			want := 20
+			if target.arch == "386" {
+				want = 15
+			}
+			if count != want || strings.Count(source.String(), "TEXT ·") != want {
+				t.Fatal("complete CRC NUM/storage inventory changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != want {
+						t.Fatal("complete CRC source did not retain every function", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_crc32_result_test.go b/x86_crc32_result_test.go
new file mode 100644
index 000000000..6c568ec56
--- /dev/null
+++ b/x86_crc32_result_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86CRC32ResultCase struct {
+	op    string
+	width int
+}
+
+func x86CRC32ResultCases(arch string) []x86CRC32ResultCase {
+	rows := []x86CRC32ResultCase{{"CRC32B", 1}, {"CRC32W", 2}, {"CRC32L", 4}}
+	if arch == "amd64" {
+		rows = append(rows, x86CRC32ResultCase{"CRC32Q", 8})
+	}
+	return rows
+}
+
+func TestX86CRC32WholeResultNUMThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86CRC32ResultCases(target.arch) {
+			for _, scenario := range []string{"known", "unknown-accumulator", "unknown-source", "missing-result", "unused-bool", "unused-address"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.op+"/"+scenario+"/"+api, func(t *testing.T) {
+						result, params, body := 0, "", ""
+						if scenario == "unused-bool" {
+							result, params = goWordSize(target.arch), "flag bool"
+						}
+						if scenario != "unknown-accumulator" && scenario != "unused-bool" && scenario != "unused-address" {
+							body += "MOVL $0x76543210,AX\n"
+						}
+						if scenario != "unknown-source" {
+							body += "MOVL $0x12345678,BX\n"
+						}
+						if scenario == "unused-address" {
+							lea := "LEAQ"
+							if target.arch == "386" {
+								lea = "LEAL"
+							}
+							body += lea + " ret+0(FP),SI\n"
+						}
+						body += row.op + " BX,AX\n"
+						if scenario != "missing-result" {
+							body += fmt.Sprintf("MOVL AX,ret+%d(FP)\n", result)
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", result+4, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value("+params+") uint32", target.arch, target.triple, api)
+						if scenario != "known" {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("CRC source/result obligation bypassed: output=%t error=%v", ir != "", err)
+							}
+						} else if err != nil || ir == "" {
+							t.Fatal("complete initialized CRC result rejected", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CRC32PairedNativeReadVolatile(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range x86CRC32ResultCases(target.arch) {
+			for _, dead := range []bool{false, true} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/dead=%t/%s", target.triple, row.op, dead, api), func(t *testing.T) {
+						body := fmt.Sprintf("MOVL crc+0(FP),AX\n%s p+%d(FP),SI\n%s (SI),AX\n", move, word, row.op)
+						if dead {
+							body += "MOVL $7,AX\n"
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOVL AX,ret+%d(FP)\nRET\n", 2*word+4, body, 2*word)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(crc uint32,p *byte) uint32", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("paired native read rejected", err)
+						}
+						for _, candidate := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							if !strings.Contains(candidate, fmt.Sprintf("load volatile i%d,", row.width*8)) {
+								t.Fatal("exact CRC native read disappeared or became nonvolatile")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CRC32FPExactSourceBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86CRC32ResultCases(target.arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.op+"/"+api, func(t *testing.T) {
+					// All bytes have actual independent typed result fields. The
+					// CRC source starts inside field zero and may cross fields.
+					source := "TEXT ·Value(SB),4,$0-20\nMOVL $0x04030201,ret+0(FP)\nMOVL $0x08070605,ret+4(FP)\nMOVL $0x0c0b0a09,ret+8(FP)\nMOVL $0,AX\n" + row.op + " ret+1(FP),AX\nMOVL AX,ret+12(FP)\nMOVL $0,ret+16(FP)\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() (uint32,uint32,uint32,uint32,uint32)", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete typed interior CRC read rejected", err)
+					}
+					optimized := x86MulDivRoundOptimize(t, ir)
+					value := uint64(0x0908070605040302)
+					if row.width < 8 {
+						value &= uint64(1)<<uint(row.width*8) - 1
+					}
+					// This inspects the independent source-byte transport, not
+					// a claim that LLVM constant-folded or executed CRC itself.
+					if !strings.Contains(optimized, fmt.Sprintf("i%d %d)", row.width*8, value)) {
+						t.Fatalf("CRC lost exact interior source bytes, want %#x:\n%s", value, optimized)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_custom_helper_bool_consumer_test.go b/x86_custom_helper_bool_consumer_test.go
new file mode 100644
index 000000000..6dcc9a3f6
--- /dev/null
+++ b/x86_custom_helper_bool_consumer_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestX86CustomHelperBoolConsumerRequiresExactGraphAndTransport(t *testing.T) {
+	for _, mutation := range []string{
+		"unchanged", "missing-graph", "source", "declaration", "emitted-registers",
+		"emitted-return", "attributes", "supplied-attributes", "mode", "target", "unowned-helper",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			source, err := prepareX86ABI0BoolCalls(file, options)
+			if err != nil || source == nil {
+				t.Fatal("complete actual custom-helper producer failed", err)
+			}
+			sig := options.Sigs["comparebody"]
+			consumer := &amd64Ctx{
+				fpScalarSource: file.Funcs[1], fpSourceSig: sig, sig: sig,
+				fpBoolCallSource: source, goarch: "386", targetTriple: options.TargetTriple,
+			}
+			switch mutation {
+			case "missing-graph":
+				consumer.fpBoolCallSource = nil
+			case "source":
+				consumer.fpScalarSource.Instrs = append([]Instr(nil), file.Funcs[1].Instrs...)
+				consumer.fpScalarSource.Instrs[1].Raw += " // different original helper"
+			case "declaration":
+				consumer.fpSourceSig.ArgRegs = []Reg{CX, DI, AX}
+			case "emitted-registers":
+				consumer.sig.ArgRegs = []Reg{CX, DI, AX}
+			case "emitted-return":
+				consumer.sig.Ret = I1
+			case "attributes":
+				consumer.sig.Attrs = "nounwind"
+			case "supplied-attributes":
+				consumer.fpSourceSig.Attrs = "nounwind"
+			case "mode":
+				consumer.goarch = "amd64"
+			case "target":
+				consumer.targetTriple = "i686-pc-windows-msvc"
+			case "unowned-helper":
+				consumer.fpScalarSource.Sym = "foreign<>"
+			}
+			err = consumer.checkLoweredScalarFPResultInitialization()
+			if mutation == "unchanged" {
+				if err != nil {
+					t.Fatal("proved helper was reinterpreted as ordinary ABI0", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed or missing graph/transport supplied a helper proof", err)
+			}
+		})
+	}
+}
diff --git a/x86_custom_helper_bool_objects_test.go b/x86_custom_helper_bool_objects_test.go
new file mode 100644
index 000000000..af537875f
--- /dev/null
+++ b/x86_custom_helper_bool_objects_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RegisterHelperCanonicalBoolCompleteSETccObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			_, options := x86CustomHelperBoolFixture(t, "", triple)
+			root, helper := options.Sigs["compare"], options.Sigs["comparebody"]
+			options.Sigs = make(map[string]FuncSig)
+			var assembly strings.Builder
+			for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+				name, body := "compare"+condition, "body"+condition
+				fmt.Fprintf(&assembly, "TEXT %s(SB),NOSPLIT,$0-12\nMOVL a+0(FP),SI\nMOVL b+4(FP),DI\n"+
+					"LEAL ret+8(FP),AX\nJMP %s<>(SB)\nTEXT %s<>(SB),NOSPLIT,$0-0\nCMPL SI,DI\nSET%s (AX)\nRET\n", name, body, body, condition)
+				root.Name, helper.Name = name, body
+				options.Sigs[name], options.Sigs[body] = root, helper
+			}
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil || len(file.Funcs) != 32 || len(options.Sigs) != 32 {
+				t.Fatal("complete sixteen-condition root/helper family changed", err)
+			}
+			receipt := x86LEAActualTargetGoObject(t, "386", triple, "#define NOSPLIT 4\n"+assembly.String())
+			t.Logf("actual original Go object: %+v", receipt)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86CustomHelperBoolAPI(t, file, options, api)
+					if err != nil || strings.Count(ir, "call void @body") != 16 {
+						t.Fatal("actual explicit register calls were changed or omitted", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprint("O2=", optimized), func(t *testing.T) {
+							input := ir
+							if optimized {
+								input = x86UndefinedTrapOptimizedIR(t, input)
+							}
+							compileLLVMToObject(t, llc, triple, "register-bool.ll", "register-bool.o", input)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_custom_helper_bool_result.go b/x86_custom_helper_bool_result.go
new file mode 100644
index 000000000..66eee6fab
--- /dev/null
+++ b/x86_custom_helper_bool_result.go
@@ -0,0 +1,361 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// This plan proves the root's actual canonical byte through its complete
+// original helper graph. Helpers retain their independent Void/ArgRegs ABI;
+// no helper receives a copied root frame or an invented I1 result.
+type x86CustomHelperBoolTail struct {
+	view    *x86DirectTailRoot
+	helpers map[string]FuncSig
+	proved  bool
+}
+
+func x86CustomHelperBoolFrameRole(fn Func, sig FuncSig, arch string) bool {
+	plan := fn.x86BoolCalls
+	if arch != "386" || plan == nil || plan.registerTail == nil || !x86ABI0BoolDeclarationRole(sig, arch) ||
+		fn.x86DirectTailRoot != nil && fn.x86DirectTailRoot != plan.registerTail.view {
+		return false
+	}
+	fn.x86DirectTailRoot = nil // Only compare this proof view with its exact original root.
+	end := sig.Frame.Results[0].Offset + 1
+	return fn.FrameSize == 0 && (fn.ArgSize == end || fn.ArgSize == (end+3)&^3) && plan.matches(fn, sig, arch)
+}
+
+func (source *x86ABI0BoolCallSource) prepareCustomRegisterTail(plan *x86ABI0BoolCallPlan) error {
+	fail := func(reason string) error { return x86ABI0BoolCallContext("custom register tail: " + reason) }
+	if source.options.Goarch != "386" || !x86ABI0BoolDeclarationRole(plan.signature, "386") || plan.function.FrameSize != 0 ||
+		source.options.NumericalReads != nil || source.options.X86TLSMoves != nil || source.options.ARM64ByteCarrierSource != nil ||
+		len(source.options.X86TailGroups) != 0 || len(source.original.UnlinkedPrelude) != 0 || len(source.original.x86Continuations) != 0 {
+		return fail("root or native/source role is not closed")
+	}
+	if source.customGraph == nil {
+		helpers := make(map[string]bool)
+		for _, fn := range source.original.Funcs {
+			if strings.HasSuffix(fn.Sym, "<>") {
+				helpers[fn.Sym] = true
+			}
+		}
+		graph, _, err := newX86DirectTailGraph(source.origin, source.options, helpers, "386")
+		if err != nil {
+			return err
+		}
+		source.customGraph = graph
+	}
+	graph := source.customGraph
+	byName := make(map[string]int)
+	for index, fn := range graph.original.Funcs {
+		byName[fn.Sym] = index
+	}
+	root, found := byName[plan.function.Sym]
+	if !found {
+		return fail("root is absent from the original graph")
+	}
+	combined := 0
+	for _, prior := range graph.roots {
+		combined += len(prior.points)
+	}
+	view, err := graph.root(root, byName, 4096-combined, false)
+	if err != nil {
+		return err
+	}
+	tail := &x86CustomHelperBoolTail{view: view, helpers: make(map[string]FuncSig)}
+	for _, point := range view.points {
+		fn := graph.original.Funcs[point.text]
+		if point.text == root {
+			continue
+		}
+		if _, checked := tail.helpers[fn.Sym]; checked {
+			continue
+		}
+		name := graph.symbols[fn.Sym]
+		sig, declared := graph.signatures[name]
+		if !declared || sig.Name != "" && sig.Name != name || !x86CustomHelperBoolSignature(sig) {
+			return fail("helper lacks its complete explicit Void/register declaration")
+		}
+		for _, ins := range fn.Instrs {
+			for _, arg := range ins.Args {
+				if arg.Kind == OpFP || arg.Kind == OpFPAddr {
+					return fail("a custom helper cannot borrow the root FP layout")
+				}
+			}
+		}
+		tail.helpers[fn.Sym] = sig
+	}
+	if len(tail.helpers) == 0 {
+		return fail("complete private helper graph is missing")
+	}
+	for _, external := range view.externalTails {
+		if external {
+			return fail("external terminal needs its independent canonical result contract")
+		}
+	}
+	if !tail.acyclicCalls() {
+		return fail("cyclic custom calls cannot borrow continuation stack behavior")
+	}
+	graph.roots[plan.function.Sym] = view
+	plan.registerTail = tail
+	fn := plan.function
+	fn.x86DirectTailRoot, fn.x86BoolCalls, fn.x86ResultFlowBudget = view, plan, &source.budget
+	if !x86CustomHelperBoolFrameRole(fn, plan.signature, "386") {
+		return fail("root extent disagrees with its actual declared byte")
+	}
+	if err := plan.replay(); err != nil {
+		return err
+	}
+	if err := checkX86ABI0ResultInitializationAtSource(fn, plan.signature, "386",
+		func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			// These complete scalar load/extension families use the existing
+			// exact-width volatile emitters. A continued read defines only its
+			// numerical result, never pointee extent or a reusable memory role.
+			if accepted, known := x86LoweredScalarNativeLoad(ins, state, owned, resultOffset, arch); known {
+				return accepted
+			}
+			if accepted, known := x86LoweredScalarExtensionRead(ins, state, owned, resultOffset, arch); known {
+				return accepted
+			}
+			if accepted, known := x86LoweredLegacyPackedMoveRead(ins, state, owned, resultOffset, arch); known {
+				return accepted
+			}
+			if !x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch) {
+				return false
+			}
+			return tail.transport(ins, state, resultOffset, arch)
+		}, true); err != nil {
+		return err
+	}
+	tail.proved = true
+	return nil
+}
+
+func x86CustomHelperBoolSignature(sig FuncSig) bool {
+	if sig.Ret != Void || len(sig.Args) == 0 || len(sig.Args) > 6 || len(sig.Args) != len(sig.ArgRegs) ||
+		len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0 || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil ||
+		sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative || sig.x86BorrowedBoolTail {
+		return false
+	}
+	seen, pointers := make(map[Reg]bool), 0
+	for index, typ := range sig.Args {
+		if typ != I1 && typ != I8 && typ != I16 && typ != I32 && typ != Ptr {
+			return false
+		}
+		reg := sig.ArgRegs[index]
+		if _, _, valid := x86ResultGP(reg, 4, "386"); !valid || seen[reg] {
+			return false
+		}
+		seen[reg] = true
+		if typ == Ptr {
+			pointers++
+		}
+	}
+	return pointers != 0
+}
+
+func (tail *x86CustomHelperBoolTail) acyclicCalls() bool {
+	edges := make(map[string][]string)
+	for pc, ins := range tail.view.instructions {
+		if ins.Op != OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+			continue
+		}
+		name, _, valid := parseSBRef(ins.Args[0].Sym)
+		if _, helper := tail.helpers[name]; valid && helper {
+			caller := tail.view.graph.original.Funcs[tail.view.points[pc].text].Sym
+			edges[caller] = append(edges[caller], name)
+		}
+	}
+	colors := make(map[string]uint8)
+	var visit func(string) bool
+	visit = func(name string) bool {
+		if colors[name] != 0 {
+			return colors[name] == 2
+		}
+		colors[name] = 1
+		for _, next := range edges[name] {
+			if !visit(next) {
+				return false
+			}
+		}
+		colors[name] = 2
+		return true
+	}
+	for name := range tail.helpers {
+		if !visit(name) {
+			return false
+		}
+	}
+	return true
+}
+
+// A real emitted custom call carries only its declared register inputs. In
+// particular, caller FLAGS, undeclared GP bytes and vector state cannot seed
+// the independently emitted helper. Each pointer retains its actual source
+// role: an exact result-byte alias or an opaque incoming pointer. Neither role
+// grants native backing or numerical address bits.
+func (tail *x86CustomHelperBoolTail) transport(ins Instr, state *x86ResultState, resultOffset int64, arch string) bool {
+	if ins.Op != OpJMP || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+		return true
+	}
+	name, offset, valid := parseSBRef(ins.Args[0].Sym)
+	sig, declared := tail.helpers[name]
+	if !valid || offset != 0 || !declared || state.boolFrameGP == nil {
+		return false
+	}
+	if state.valueStack != nil {
+		if state.valueStack.invalid || len(state.valueStack.bytes) != 0 {
+			return false
+		}
+		state.valueStack.id = false
+	}
+	var gp, canonical [16]uint8
+	var pointers, addresses [16]bool
+	var origins [16]uint16
+	resultAlias := false
+	aliases := new([16]x86ResultSlotAddress)
+	for index, typ := range sig.Args {
+		root, _, _ := x86ResultGP(sig.ArgRegs[index], 4, arch)
+		if typ == Ptr {
+			value := state.boolFrameGP[root]
+			if !value.valid && !state.shapeOnly {
+				if !state.pointerGP[root] || !state.callerAddressGP[root] {
+					return false
+				}
+				pointers[root], addresses[root] = true, true
+				origins[root] = state.callerAddressOrigin[root]
+				continue
+			}
+			if state.shapeOnly && !value.valid {
+				value = x86ResultSlotAddress{start: resultOffset, end: resultOffset + 1, offset: resultOffset, valid: true}
+			}
+			if !value.valid || value.start != resultOffset || value.end != resultOffset+1 || value.offset != resultOffset {
+				return false
+			}
+			aliases[root] = value
+			resultAlias = true
+			continue
+		}
+		width := x86FrameScalarBytes(typ, arch)
+		_, mask, _ := x86ResultGP(sig.ArgRegs[index], width, arch)
+		if !state.shapeOnly && (state.gp[root]&mask != mask || state.boolFrameGP[root].valid ||
+			state.pointerGP[root] || state.callerAddressGP[root] || typ == I1 && state.canonicalGP[root]&mask != mask) {
+			return false
+		}
+		gp[root], canonical[root] = mask, state.canonicalGP[root]&mask
+	}
+	if !resultAlias {
+		return false
+	}
+	state.gp, state.canonicalGP, state.boolFrameGP = gp, canonical, aliases
+	state.pointerGP, state.callerAddressGP = pointers, addresses
+	state.callerAddressOrigin = origins
+	state.resultAddressGP = [16]x86ResultSlotAddress{}
+	state.xmm, state.vectorUpper, state.masks = [32]uint16{}, [32]uint64{}, [8]bool{}
+	state.flags, state.direction = 0, x86ResultDirectionUnknown
+	state.bitScanPending, state.predicate = x86ResultBitScanPending{}, x86ResultPredicate{}
+	return true
+}
+
+func (source *x86ABI0BoolCallSource) ownsCustomRegisterTails(file *File, options Options) (ownedResult bool, result error) {
+	if source.customGraph == nil {
+		return false, nil
+	}
+	defer func() {
+		if result != nil {
+			source.customGraph.revoked.Store(true)
+		}
+	}()
+	if options.Goarch != "386" || !x86ScalarFloatIntegerNativeTarget("386", options.TargetTriple) {
+		return false, x86ABI0BoolCallContext("custom register tail lost its actual 32-bit target")
+	}
+	owned := make(map[string]bool)
+	present := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		present[fn.Sym] = true
+	}
+	for _, plan := range source.callers {
+		if tail := plan.registerTail; tail != nil && tail.proved {
+			for helper := range tail.helpers {
+				owned[helper] = true
+				if present[plan.function.Sym] && !present[helper] {
+					return false, x86ABI0BoolCallContext("selected root lost an actual custom helper definition")
+				}
+			}
+		}
+	}
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") && !owned[fn.Sym] {
+			return false, nil
+		}
+		if x86DirectTailRootNeeded(fn) && !strings.HasSuffix(fn.Sym, "<>") {
+			plan := source.callers[fn.Sym]
+			if plan == nil || plan.registerTail == nil || !plan.registerTail.proved {
+				return false, nil
+			}
+		}
+	}
+	if err := source.customGraph.verify(file, options); err != nil {
+		return false, err
+	}
+	// Keep the actual rendering maps and selected source live through the final
+	// publication checks, not merely the independently cloned proof inventory.
+	source.customSelection, source.customOptions = file, options
+	return true, nil
+}
+
+func (plan *x86ABI0BoolCallPlan) checkCustomRegisterTail(fn Func, sig FuncSig, arch string) error {
+	if plan.registerTail == nil || !plan.registerTail.proved || !x86CustomHelperBoolFrameRole(fn, sig, arch) {
+		return x86ABI0BoolCallContext("custom result-byte proof lost its original source or declaration")
+	}
+	return plan.source.verify()
+}
+
+// The complete graph already checks every helper instruction after transporting
+// only that helper's declared inputs and exact private result-byte address.
+// Reuse that proof only for its original helper and actual emitted declaration;
+// a private symbol or a Void/ArgRegs signature alone grants nothing.
+func (c *amd64Ctx) checkCustomHelperBoolSource() (bool, error) {
+	source := c.fpBoolCallSource
+	if source == nil || !strings.HasSuffix(c.fpScalarSource.Sym, "<>") {
+		return false, nil
+	}
+	for _, plan := range source.callers {
+		tail := plan.registerTail
+		if tail == nil || !tail.proved {
+			continue
+		}
+		expected, present := tail.helpers[c.fpScalarSource.Sym]
+		if !present {
+			continue
+		}
+		fail := func(reason string) (bool, error) {
+			return true, x86ABI0BoolCallContext("custom helper consumer: " + reason)
+		}
+		if c.goarch != "386" || c.targetTriple != source.options.TargetTriple {
+			return fail("actual target differs from the proved graph")
+		}
+		if expected.Name == "" {
+			expected.Name = source.resolved[c.fpScalarSource.Sym]
+		}
+		emitted := expected
+		if expected.Attrs == "" {
+			emitted.Attrs = c.fpFeatureAttrs
+		} else if c.fpFeatureAttrs != "" {
+			return fail("supplied attributes acquired an inferred replacement")
+		}
+		if !reflect.DeepEqual(c.fpSourceSig, expected) || !reflect.DeepEqual(c.sig, emitted) {
+			return fail("actual helper declaration or emitted transport differs")
+		}
+		for _, original := range source.original.Funcs {
+			if original.Sym == c.fpScalarSource.Sym {
+				if !reflect.DeepEqual(original, c.fpScalarSource) {
+					return fail("complete helper source differs")
+				}
+				return true, source.verify()
+			}
+		}
+		return fail("original helper TEXT is missing")
+	}
+	return false, nil
+}
diff --git a/x86_custom_helper_bool_result_test.go b/x86_custom_helper_bool_result_test.go
new file mode 100644
index 000000000..bc699ab6f
--- /dev/null
+++ b/x86_custom_helper_bool_result_test.go
@@ -0,0 +1,349 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CustomHelperBoolFixture(t *testing.T, body, triple string) (*File, Options) {
+	t.Helper()
+	source := "TEXT compare(SB),NOSPLIT,$0-12\n" +
+		"MOVL a+0(FP),SI\nMOVL b+4(FP),DI\nLEAL ret+8(FP),AX\nJMP comparebody<>(SB)\n" +
+		"TEXT comparebody<>(SB),NOSPLIT,$0-0\n" + body + "\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, Options{Goarch: "386", TargetTriple: triple,
+		ResolveSym: func(symbol string) string { return strings.TrimSuffix(symbol, "<>") },
+		Sigs: map[string]FuncSig{
+			"compare": {Name: "compare", Args: []LLVMType{I32, I32}, Ret: I1,
+				Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+					Results: []FrameSlot{{Offset: 8, Type: I1, Index: 0, Field: -1}},
+				}},
+			"comparebody": {Name: "comparebody", Args: []LLVMType{I32, I32, Ptr}, Ret: Void, ArgRegs: []Reg{SI, DI, AX}},
+		},
+	}
+}
+
+func TestX86CustomHelperCanonicalBoolCompleteSETccSource(t *testing.T) {
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(triple+"/SET"+condition+"/"+api, func(t *testing.T) {
+					file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSET"+condition+" (AX)", triple)
+					ir, err := x86CustomHelperBoolAPI(t, file, options, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if !strings.Contains(ir, "call void @comparebody(i32") || !strings.Contains(ir, "define void @comparebody(i32") {
+						t.Fatal("actual independent register ABI helper was removed or retyped", ir)
+					}
+					if signature := options.Sigs["comparebody"]; signature.Ret != Void || fmt.Sprint(signature.ArgRegs) != "[SI DI AX]" {
+						t.Fatal("source proof changed the explicit helper declaration", signature)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86CustomHelperBoolAPI(t *testing.T, file *File, options Options, api string, keep ...func(string, string) bool) (string, error) {
+	t.Helper()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return module.String(), nil
+	}
+	if api != "Go" {
+		t.Fatal("unknown helper API", api)
+	}
+	var declarations strings.Builder
+	declarations.WriteString("package custombool\n")
+	helpers := make(map[string]bool)
+	var assembly strings.Builder
+	for _, fn := range file.Funcs {
+		name := options.ResolveSym(fn.Sym)
+		if strings.HasSuffix(fn.Sym, "<>") {
+			helpers[name] = true
+		} else {
+			fmt.Fprintf(&declarations, "func %s(a,b int32) bool\n", name)
+		}
+		for _, ins := range fn.Instrs {
+			assembly.WriteString(ins.Raw)
+			assembly.WriteByte('\n')
+		}
+	}
+	pkg := mustGoPackage(t, "custombool", declarations.String())
+	request := GoModuleOptions{
+		GOARCH: "386", TargetTriple: options.TargetTriple, ResolveSym: options.ResolveSym,
+		ManualSig: func(name string) (FuncSig, bool) {
+			if helpers[name] {
+				sig, found := options.Sigs[name]
+				return sig, found
+			}
+			return FuncSig{}, false
+		},
+	}
+	if len(keep) != 0 {
+		request.KeepFunc = keep[0]
+	}
+	module, err := translateGoModuleInContext(ctx, pkg, []byte(assembly.String()), request)
+	if module != nil && !module.Module.IsNil() {
+		defer module.Module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return module.Module.String(), nil
+}
+
+func TestX86CustomHelperBoolSelectedClosure(t *testing.T) {
+	for _, complete := range []bool{false, true} {
+		t.Run(fmt.Sprint("complete=", complete), func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			ir, err := x86CustomHelperBoolAPI(t, file, options, "Go", func(symbol, _ string) bool {
+				return complete || symbol == "compare"
+			})
+			if complete && (err != nil || ir == "") || !complete && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+				t.Fatal("a filtered helper cannot become an unproved external result writer", complete, len(ir), err)
+			}
+		})
+	}
+}
+
+func TestX86CustomHelperCanonicalBoolSourcePathsAndUnknowns(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"zero", "MOVB $0,(AX)", true},
+		{"one", "MOVB $1,(AX)", true},
+		{"branch", "CMPL SI,DI\nJE equal\nMOVB $0,(AX)\nJMP done\nequal:\nMOVB $1,(AX)\ndone:", true},
+		{"missing-write", "CMPL SI,DI", false},
+		{"unknown-flags", "SETLT (AX)", false},
+		{"unknown-value", "MOVB CX,(AX)", false},
+		{"noncanonical-two", "MOVB $2,(AX)", false},
+		{"noncanonical-three", "MOVB $3,(AX)", false},
+		{"noncanonical-overwrite", "CMPL SI,DI\nSETLT (AX)\nMOVB $3,(AX)", false},
+		{"missing-path", "CMPL SI,DI\nJE done\nSETLT (AX)\ndone:", false},
+		{"missing-input", "CMPL CX,DI\nSETLT (AX)", false},
+		{"overwide-write", "MOVL $1,(AX)", false},
+		{"padding-write", "MOVB $1,1(AX)", false},
+		{"private-recursion", "CMPL SI,DI\nJE done\nJMP comparebody<>(SB)\ndone:\nSETLT (AX)", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, row.body, "i386-unknown-linux-gnu")
+			ir, err := Translate(file, options)
+			if row.valid && (err != nil || ir == "") || !row.valid && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+				t.Fatal("helper result-pointer canonical proof", row.valid, len(ir), err)
+			}
+		})
+	}
+}
+
+func TestX86CustomHelperCanonicalBoolDeclaredTransportBoundaries(t *testing.T) {
+	for name, change := range map[string]func(*File, *Options){
+		"missing-register": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.ArgRegs = sig.ArgRegs[:2]
+			options.Sigs["comparebody"] = sig
+		},
+		"duplicate-register": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.ArgRegs[1] = SI
+			options.Sigs["comparebody"] = sig
+		},
+		"unknown-argument": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.ArgRegs[0] = CX
+			options.Sigs["comparebody"] = sig
+		},
+		"source-type-is-not-pointer": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.Args[2] = I32
+			options.Sigs["comparebody"] = sig
+		},
+		"borrowed-I1-helper": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.Ret = I1
+			options.Sigs["comparebody"] = sig
+		},
+		"fake-helper-frame": func(_ *File, options *Options) {
+			sig := options.Sigs["comparebody"]
+			sig.Frame.Results = []FrameSlot{{Offset: 8, Type: I1, Index: 0, Field: -1}}
+			options.Sigs["comparebody"] = sig
+		},
+		"native-helper-entry": func(file *File, _ *Options) { file.Funcs[1].X86RawText = []byte{0xc3} },
+		"source-padding":      func(file *File, _ *Options) { file.Funcs[0].Instrs[3].Args[0].FPOffset = 9 },
+		"source-parameter":    func(file *File, _ *Options) { file.Funcs[0].Instrs[3].Args[0].FPOffset = 0 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			change(file, &options)
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unproved helper transport published", len(ir), err)
+			}
+		})
+	}
+}
+
+func TestX86CanonicalBoolResultAliasWithIntegerParameters(t *testing.T) {
+	file, options := x86CustomHelperBoolFixture(t, "", "i386-unknown-linux-gnu")
+	var err error
+	file, err = Parse(ArchAMD64, "TEXT compare(SB),NOSPLIT,$0-9\nMOVL a+0(FP),SI\nMOVL b+4(FP),DI\n"+
+		"LEAL ret+8(FP),AX\nCMPL SI,DI\nSETLT (AX)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	delete(options.Sigs, "comparebody")
+	if _, err := Translate(file, options); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86CustomHelperBoolCannotInheritCallerFlags(t *testing.T) {
+	file, options := x86CustomHelperBoolFixture(t, "SETLT (AX)", "i386-unknown-linux-gnu")
+	var source strings.Builder
+	for _, fn := range file.Funcs {
+		for _, ins := range fn.Instrs {
+			source.WriteString(ins.Raw)
+			source.WriteByte('\n')
+		}
+	}
+	input := strings.Replace(source.String(), "JMP comparebody<>(SB)", "CMPL SI,DI\nJMP comparebody<>(SB)", 1)
+	file, err := Parse(ArchAMD64, input)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("helper inherited caller FLAGS through its independent LLVM entry", len(ir), err)
+	}
+}
+
+func TestX86CustomHelperBoolCompleteSourceRevocation(t *testing.T) {
+	for _, changed := range []string{"root", "helper", "declaration"} {
+		t.Run(changed, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			source, err := prepareX86ABI0BoolCalls(file, options)
+			if err != nil || source == nil || source.callers["compare"].registerTail == nil {
+				t.Fatal("actual complete canonical register-tail producer", err)
+			}
+			var restore func()
+			if changed == "declaration" {
+				sig := options.Sigs["comparebody"]
+				prior := sig.ArgRegs[0]
+				sig.ArgRegs[0] = CX
+				restore = func() { sig.ArgRegs[0] = prior }
+			} else {
+				index := 0
+				if changed == "helper" {
+					index = 1
+				}
+				ins := &file.Funcs[index].Instrs[1]
+				prior := ins.Raw
+				ins.Raw += " // changed complete source"
+				restore = func() { ins.Raw = prior }
+			}
+			if err := source.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed source or register declaration retained its result proof", err)
+			}
+			restore()
+			if err := source.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("restoring old bytes revived a failed graph proof", err)
+			}
+		})
+	}
+}
+
+func TestX86CustomHelperBoolAuditsOrdinaryNonparticipants(t *testing.T) {
+	file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+	other, err := Parse(ArchAMD64, "TEXT other(SB),4,$0-4\nMOVL AX,X0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file.Funcs = append(file.Funcs, other.Funcs...)
+	options.Sigs["other"] = FuncSig{Name: "other", Ret: I32,
+		Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}}}
+	if source, err := prepareX86ABI0BoolCalls(file, options); source != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("whole-source helper proof hid an ordinary unwritten result", source != nil, err)
+	}
+}
+
+func TestX86CustomHelperBoolSelectedPublicationRevocation(t *testing.T) {
+	for _, changed := range []string{"helper-source", "helper-declaration", "missing-helper", "resolver", "target"} {
+		t.Run(changed, func(t *testing.T) {
+			file, options := x86CustomHelperBoolFixture(t, "CMPL SI,DI\nSETLT (AX)", "i386-unknown-linux-gnu")
+			source, err := prepareX86ABI0BoolCalls(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			selected := x86DirectTailSnapshot(file)
+			request := options
+			request.Sigs, err = numericalCloneSignatures(options.Sigs)
+			if err != nil {
+				t.Fatal(err)
+			}
+			changedResolver := false
+			request.ResolveSym = func(symbol string) string {
+				if changedResolver && symbol == "comparebody<>" {
+					return "changed"
+				}
+				return options.ResolveSym(symbol)
+			}
+			if owned, err := source.ownsCustomRegisterTails(selected, request); err != nil || !owned {
+				t.Fatal("bind the actual selected request", owned, err)
+			}
+			var restore func()
+			switch changed {
+			case "helper-source":
+				prior := selected.Funcs[1].Instrs[1].Raw
+				selected.Funcs[1].Instrs[1].Raw += " // changed after selection"
+				restore = func() { selected.Funcs[1].Instrs[1].Raw = prior }
+			case "helper-declaration":
+				sig := request.Sigs["comparebody"]
+				sig.ArgRegs[0] = CX
+				restore = func() { sig.ArgRegs[0] = SI }
+			case "missing-helper":
+				prior := selected.Funcs
+				selected.Funcs = selected.Funcs[:1]
+				restore = func() { selected.Funcs = prior }
+			case "resolver":
+				changedResolver = true
+				restore = func() { changedResolver = false }
+			case "target":
+				request.TargetTriple = "x86_64-unknown-linux-gnu"
+				if owned, err := source.ownsCustomRegisterTails(selected, request); !errors.Is(err, ErrProbeNeedsContext) || owned {
+					t.Fatal("an actual 64-bit target borrowed a 32-bit proof", owned, err)
+				}
+				request.TargetTriple = options.TargetTriple
+				if owned, err := source.ownsCustomRegisterTails(selected, request); !errors.Is(err, ErrProbeNeedsContext) || owned {
+					t.Fatal("restoring a target revived its failed graph", owned, err)
+				}
+				return
+			}
+			if err := source.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("publication lost the selected source/declaration identity", err)
+			}
+			restore()
+			if err := source.verify(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("restoring a selected request revived a failed graph", err)
+			}
+		})
+	}
+}
diff --git a/x86_custom_helper_pointer_roles_test.go b/x86_custom_helper_pointer_roles_test.go
new file mode 100644
index 000000000..891bdf59b
--- /dev/null
+++ b/x86_custom_helper_pointer_roles_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The private helper receives two opaque input pointers and a distinct pointer
+// to the canonical result byte. Their common LLVM type does not make these
+// source roles interchangeable or turn the inputs into numerical register bits.
+func x86CustomPointerHelperSource(t *testing.T, before, body string) (string, string, FuncSig) {
+	t.Helper()
+	declaration := "func Value(p,q *byte,n uint32) bool"
+	_, _, _, source := x86ResultInitializationFixture(t, "386", declaration,
+		"MOVL p+0(FP),SI\nMOVL q+4(FP),DI\nMOVL n+8(FP),BX\n"+
+			"LEAL ret+12(FP),AX\n"+before+"\nJMP pointerbody<>(SB)")
+	source += "TEXT pointerbody<>(SB),4,$0-0\n" + body + "\nRET\n"
+	helper := FuncSig{Name: "pointerbody", Args: []LLVMType{Ptr, Ptr, I32, Ptr},
+		Ret: Void, ArgRegs: []Reg{SI, DI, BX, AX}}
+	return declaration, source, helper
+}
+
+func x86CustomPointerHelperAPI(t *testing.T, source, declaration, triple, api string, helper FuncSig) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "pointerroles", "package pointerroles\n"+declaration)
+	return x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, "386", triple, api,
+		func(name string) (FuncSig, bool) { return helper, name == "pointerbody" })
+}
+
+func TestX86CustomHelperDistinctPointerRoles(t *testing.T) {
+	bodies := map[string]string{
+		"unused-inputs": "CMPL BX,$0\nSETEQ (AX)",
+		"identity":      "CMPL SI,DI\nSETEQ (AX)",
+	}
+	// Complete ordinary scalar load/extension widths in physical 32-bit mode;
+	// the wider Q forms remain independently rejected by the shared grammar.
+	for _, row := range []struct{ move, compare, left, right string }{
+		{"MOVB", "CMPB", "CL", "DL"},
+		{"MOVW", "CMPW", "CX", "DX"},
+		{"MOVL", "CMPL", "CX", "DX"},
+		{"MOVBWSX", "CMPW", "CX", "DX"},
+		{"MOVBWZX", "CMPW", "CX", "DX"},
+		{"MOVBLSX", "CMPL", "CX", "DX"},
+		{"MOVBLZX", "CMPL", "CX", "DX"},
+		{"MOVWLSX", "CMPL", "CX", "DX"},
+		{"MOVWLZX", "CMPL", "CX", "DX"},
+	} {
+		bodies[row.move] = fmt.Sprintf("%s (SI),%s\n%s (DI),%s\n%s %s,%s\nSETEQ (AX)",
+			row.move, row.left, row.move, row.right, row.compare, row.left, row.right)
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for name, body := range bodies {
+			t.Run(triple+"/"+name, func(t *testing.T) {
+				declaration, source, helper := x86CustomPointerHelperSource(t, "", body)
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86CustomPointerHelperAPI(t, source, declaration, triple, api, helper)
+						if err != nil || !strings.Contains(ir, "call void @pointerbody(ptr") {
+							t.Fatal("actual helper input and result pointers were not kept distinct", err)
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM22 llc required")
+						}
+						compileLLVMToObject(t, llc, triple, "helper.ll", "helper.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86CustomHelperPointerRoleBoundaries(t *testing.T) {
+	for _, row := range []struct{ name, before, body string }{
+		{"input-is-not-result", "MOVL SI,AX", "MOVB $1,(AX)"},
+		{"literal-is-not-pointer", "MOVL $1,SI", "MOVB $1,(AX)"},
+		{"partial-input", "MOVB $0,SI", "MOVB $1,(AX)"},
+		{"result-is-not-input", "MOVL AX,SI", "MOVBLZX (SI),CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"pointer-is-not-NUM", "", "MOVL SI,CX\nXORL DI,CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"uninitialized-result-read", "", "MOVBLZX (AX),CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"overwide-result-read", "", "MOVL (AX),CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"unknown-input-address", "", "MOVBLZX (BP),CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"mixed-path-address", "CMPL BX,$0\nJE joined\nMOVL $0,SI\njoined:", "MOVBLZX (SI),CX\nCMPL CX,$0\nSETEQ (AX)"},
+		{"input-write", "", "MOVB $1,(SI)\nMOVB $1,(AX)"},
+		{"result-padding", "", "MOVB $1,1(AX)"},
+		{"noncanonical-result", "", "MOVB $2,(AX)"},
+		{"undeclared-input", "", "CMPL BP,$0\nSETEQ (AX)"},
+		{"caller-flags", "CMPL BX,$0", "SETEQ (AX)"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			declaration, source, helper := x86CustomPointerHelperSource(t, row.before, row.body)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86CustomPointerHelperAPI(t, source, declaration, "i386-unknown-linux-gnu", api, helper)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("helper pointer role escaped its actual source contract", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86CustomHelperWholeVectorInputPointers(t *testing.T) {
+	for _, name := range strings.Fields("MOVOU MOVOA MOVO MOVUPS MOVAPS MOVUPD MOVAPD") {
+		for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+			t.Run(triple+"/"+name, func(t *testing.T) {
+				body := fmt.Sprintf("%s (SI),X0\n%s (DI),X1\nPCMPEQB X1,X0\nPMOVMSKB X0,CX\nCMPL CX,$65535\nSETEQ (AX)", name, name)
+				declaration, source, helper := x86CustomPointerHelperSource(t, "", body)
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86CustomPointerHelperAPI(t, source, declaration, triple, api, helper)
+						if err != nil || ir == "" {
+							t.Fatal("complete original vector read lost its helper input pointer", err)
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM22 llc required")
+						}
+						compileLLVMToObject(t, llc, triple, "vector-helper.ll", "vector-helper.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_custom_helper_pointer_runtime_fixture_test.go b/x86_custom_helper_pointer_runtime_fixture_test.go
new file mode 100644
index 000000000..136dfc3c5
--- /dev/null
+++ b/x86_custom_helper_pointer_runtime_fixture_test.go
@@ -0,0 +1,463 @@
+package plan9asm
+
+import (
+	"debug/elf"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86CustomPointerRuntimeForm struct {
+	name, body string
+	// -1 selects the whole-vector equality oracle; 0..8 select independent
+	// scalar width/extension references in the original-Go and C drivers.
+	scalar  int
+	aligned bool
+}
+
+func x86CustomPointerRuntimeForms() []x86CustomPointerRuntimeForm {
+	var forms []x86CustomPointerRuntimeForm
+	for index, row := range []struct{ move, left, right string }{
+		{"MOVB", "CL", "DL"}, {"MOVW", "CX", "DX"}, {"MOVL", "CX", "DX"},
+		{"MOVBWSX", "CX", "DX"}, {"MOVBWZX", "CX", "DX"},
+		{"MOVBLSX", "CX", "DX"}, {"MOVBLZX", "CX", "DX"},
+		{"MOVWLSX", "CX", "DX"}, {"MOVWLZX", "CX", "DX"},
+	} {
+		// Different old high bytes make partial-register preservation visible.
+		// BX is the caller's independent expected XOR, not pointer bits.
+		body := fmt.Sprintf("MOVL $0x9632a5c7,CX\nMOVL $0x5a87bc91,DX\n%s (SI),%s\n%s (DI),%s\nXORL DX,CX\nCMPL CX,BX\nSETEQ (AX)",
+			row.move, row.left, row.move, row.right)
+		forms = append(forms, x86CustomPointerRuntimeForm{name: row.move, body: body, scalar: index})
+	}
+	for _, name := range strings.Fields("MOVOU MOVOA MOVO MOVUPS MOVAPS MOVUPD MOVAPD") {
+		body := fmt.Sprintf("%s (SI),X0\n%s (DI),X1\nPCMPEQB X1,X0\nPMOVMSKB X0,CX\nCMPL CX,$65535\nSETEQ (AX)", name, name)
+		aligned := name == "MOVOA" || name == "MOVO" || name == "MOVAPS" || name == "MOVAPD"
+		forms = append(forms, x86CustomPointerRuntimeForm{name: name, body: body, scalar: -1, aligned: aligned})
+	}
+	return forms
+}
+
+const x86CustomPointerRuntimeBatchSize = 4
+
+// Keep the exact typed pointer-role fixture producer, including its physical
+// SI/DI/BX/AX transport and complete private helper. Only symbols are renamed
+// to combine four independent complete root/helper pairs in one source unit.
+func x86CustomPointerRuntimeSource(t *testing.T, start int) (assembly, declarations, observers, observerDecl string, helpers map[string]FuncSig) {
+	t.Helper()
+	forms := x86CustomPointerRuntimeForms()
+	if start < 0 || start%x86CustomPointerRuntimeBatchSize != 0 || start+x86CustomPointerRuntimeBatchSize > len(forms) {
+		t.Fatal("invalid complete custom pointer source batch", start)
+	}
+	helpers = make(map[string]FuncSig)
+	for index := start; index < start+x86CustomPointerRuntimeBatchSize; index++ {
+		decl, source, helper := x86CustomPointerHelperSource(t, "", forms[index].body)
+		root, local := fmt.Sprintf("Value%d", index), fmt.Sprintf("pointerbody%d", index)
+		assembly += strings.ReplaceAll(strings.ReplaceAll(source, "Value", root), "pointerbody", local)
+		declarations += strings.ReplaceAll(decl, "Value", root) + "\n"
+		helper.Name = local
+		helpers[local] = helper
+		observerDecl += fmt.Sprintf("func Observe%d(p,q *byte,n uint32) uint64\n", index)
+		// The raw caller observes exactly the callee's actual bool byte and
+		// seven adjacent bytes. Its source is never translated as a Go ABI.
+		observers += fmt.Sprintf(`TEXT ·Observe%d(SB),4,$24-20
+MOVL p+0(FP),CX
+MOVL CX,0(SP)
+MOVL q+4(FP),CX
+MOVL CX,4(SP)
+MOVL n+8(FP),CX
+MOVL CX,8(SP)
+MOVL $0x5a5a5a5a,12(SP)
+MOVL $0x11223344,16(SP)
+CALL ·%s(SB)
+MOVL 12(SP),CX
+MOVL CX,ret+12(FP)
+MOVL 16(SP),CX
+MOVL CX,ret+16(FP)
+RET
+`, index, root)
+	}
+	return
+}
+
+func TestX86CustomPointerRuntimeCompleteBoundedFixture(t *testing.T) {
+	forms := x86CustomPointerRuntimeForms()
+	want := strings.Fields("MOVB MOVW MOVL MOVBWSX MOVBWZX MOVBLSX MOVBLZX MOVWLSX MOVWLZX MOVOU MOVOA MOVO MOVUPS MOVAPS MOVUPD MOVAPD")
+	if len(forms) != len(want) || len(forms)%x86CustomPointerRuntimeBatchSize != 0 {
+		t.Fatal("incomplete scalar/whole128 native fixture", len(forms))
+	}
+	seen := make(map[string]bool)
+	for start := 0; start < len(forms); start += x86CustomPointerRuntimeBatchSize {
+		source, decl, observers, observerDecl, helpers := x86CustomPointerRuntimeSource(t, start)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil || len(file.Funcs) != 8 || len(helpers) != 4 {
+			t.Fatal("batch lost a whole root/helper pair", start, err)
+		}
+		if _, err := parser.ParseFile(token.NewFileSet(), "main.go", "package main\n"+decl+observerDecl, 0); err != nil {
+			t.Fatal(err)
+		}
+		goDriver, _, wrappers := x86CustomPointerRuntimeDrivers(t, start)
+		if _, err := parser.ParseFile(token.NewFileSet(), "main.go", goDriver, 0); err != nil {
+			t.Fatal("original numerical/canary driver is malformed", err)
+		}
+		if !strings.Contains(wrappers, fmt.Sprintf("store i64 %d,", uint64(0x112233445a5a5a5a))) {
+			t.Fatal("LLVM raw helper observer lost its seven adjacent canaries")
+		}
+		observed, err := Parse(ArchAMD64, observers)
+		if err != nil || len(observed.Funcs) != 4 {
+			t.Fatal("batch lost an independent original raw observer", err)
+		}
+		if got := x86CustomPointerRuntimeChecks(start); got != []int{3072, 3072, 938, 272}[start/4] {
+			t.Fatal("independent true/false/value/canary denominator changed", start, got)
+		}
+		for index := start; index < start+4; index++ {
+			form := forms[index]
+			wantScalar := index
+			if index >= 9 {
+				wantScalar = -1
+			}
+			wantAligned := form.name == "MOVOA" || form.name == "MOVO" || form.name == "MOVAPS" || form.name == "MOVAPD"
+			if form.name != want[index] || seen[form.name] || form.scalar != wantScalar || form.aligned != wantAligned {
+				t.Fatal("missing/duplicate native family member", index, form.name)
+			}
+			seen[form.name] = true
+			root, helper := file.Funcs[2*(index-start)], file.Funcs[2*(index-start)+1]
+			if root.Sym != fmt.Sprintf("·Value%d", index) || helper.Sym != fmt.Sprintf("pointerbody%d<>", index) ||
+				!strings.Contains(source, form.body+"\nRET\n") || !strings.Contains(observers, fmt.Sprintf("CALL ·Value%d(SB)", index)) {
+				t.Fatal("native batch did not retain the original complete pair", index)
+			}
+		}
+	}
+}
+
+func x86CustomPointerRuntimeChecks(start int) int {
+	checks := 0
+	for _, form := range x86CustomPointerRuntimeForms()[start : start+4] {
+		if form.scalar >= 0 {
+			checks += 3 * 8 * 8 * 2 * 2 // offsets, value pair, true/false, typed/raw
+		} else if form.aligned {
+			checks += 17 * 2 // equal plus each independent mismatching byte
+		} else {
+			checks += 3 * 17 * 2
+		}
+	}
+	return checks
+}
+
+// This portable axis validates the same complete original Go386 executable and
+// all generated LLVM shims as objects. It does not execute them on another host
+// or stand in for the required native Linux cross-runtime owner below.
+func TestX86CustomPointerRuntimeOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for start := 0; start < len(x86CustomPointerRuntimeForms()); start += x86CustomPointerRuntimeBatchSize {
+		t.Run(fmt.Sprintf("batch%02d", start/4), func(t *testing.T) {
+			original := x86CustomPointerRuntimeOriginal(t, start)
+			object, err := elf.Open(original)
+			if err != nil {
+				t.Fatal(err)
+			}
+			class, machine := object.Class, object.Machine
+			if err := object.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if class != elf.ELFCLASS32 || machine != elf.EM_386 {
+				t.Fatal("original Go oracle is not a real Linux i386 executable", class, machine)
+			}
+			assembly, declarations, _, _, helpers := x86CustomPointerRuntimeSource(t, start)
+			_, _, wrappers := x86CustomPointerRuntimeDrivers(t, start)
+			pkg := mustGoPackage(t, "pointerroles386", "package main\n"+declarations)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, assembly, pkg, "386", "i386-unknown-linux-gnu", api,
+						func(name string) (FuncSig, bool) { sig, ok := helpers[name]; return sig, ok })
+					if err != nil {
+						t.Fatal(err)
+					}
+					dir := t.TempDir()
+					input, output := filepath.Join(dir, "helper.ll"), filepath.Join(dir, "helper.o")
+					if err := os.WriteFile(input, []byte(ir+wrappers), 0600); err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=i386-unknown-linux-gnu", "-filetype=obj", input, "-o", output))
+						if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+							t.Fatalf("actual LLVM i386 object missing: %v", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86CustomPointerRuntimeDrivers(t *testing.T, start int) (goDriver, driver, wrappersIR string) {
+	t.Helper()
+	_, declarations, _, observerDecl, _ := x86CustomPointerRuntimeSource(t, start)
+	var goCalls, prototypes, cCalls, wrappers strings.Builder
+	for index := start; index < start+4; index++ {
+		form := x86CustomPointerRuntimeForms()[index]
+		fmt.Fprintf(&goCalls, "\trun(%q, %d, %t, Value%d, Observe%d)\n", form.name, form.scalar, form.aligned, index, index)
+		aligned := 0
+		if form.aligned {
+			aligned = 1
+		}
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(uint8_t *, uint8_t *, uint32_t);\n"+
+			"extern uint64_t Raw%d(uint8_t *, uint8_t *, uint32_t);\n", index, index)
+		fmt.Fprintf(&cCalls, "    run(\"%s\", %d, %d, Probe%d, Raw%d);\n", form.name, form.scalar, aligned, index, index)
+		fmt.Fprintf(&wrappers, `
+define i32 @Probe%d(ptr %%p, ptr %%q, i32 %%n) {
+  %%v = call i1 @Value%d(ptr %%p, ptr %%q, i32 %%n)
+  %%r = zext i1 %%v to i32
+  ret i32 %%r
+}
+
+define i64 @Raw%d(ptr %%p, ptr %%q, i32 %%n) {
+  %%out = alloca i64, align 8
+  store i64 1234605616519600730, ptr %%out, align 8
+  call void @pointerbody%d(ptr %%p, ptr %%q, i32 %%n, ptr %%out)
+  %%r = load i64, ptr %%out, align 8
+  ret i64 %%r
+}
+`, index, index, index, index)
+	}
+	goDriver = "package main\n\nimport (\n\t\"fmt\"\n\t\"unsafe\"\n)\n\n" + declarations + observerDecl +
+		x86CustomPointerRuntimeGoDriver + "\nfunc main() {\n" + goCalls.String() +
+		"\tfmt.Printf(\"original386 pointer-role checks: %d\\n\", checks)\n}\n"
+	driver = "#include <stdint.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n" + prototypes.String() +
+		x86CustomPointerRuntimeCDriver + "\nint main(void) {\n" + cCalls.String() +
+		"    printf(\"LLVM386 pointer-role checks: %u\\n\", checks);\n    return 0;\n}\n"
+	return goDriver, driver, wrappers.String()
+}
+
+func x86CustomPointerRuntimeOriginal(t *testing.T, start int) string {
+	t.Helper()
+	assembly, _, observers, _, _ := x86CustomPointerRuntimeSource(t, start)
+	goDriver, _, _ := x86CustomPointerRuntimeDrivers(t, start)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{"go.mod": "module pointerroles386\n\ngo 1.20\n", "main.go": goDriver,
+		"helper_386.s": assembly, "observer_386.s": observers} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original")
+	command := exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOTOOLCHAIN=local",
+		"GOOS=linux", "GOARCH=386", "GO386=sse2", "CGO_ENABLED=0", "GOMAXPROCS=2", "GOEXPERIMENT=")
+	x86FloatCompareCaptureCommand(t, command)
+	return original
+}
+
+// These references operate on bytes and Go/C integer conversions, not parsed
+// instructions, LLVM values or a common translator result. A scalar true and
+// false call differ only in the independent expected XOR argument. Vector
+// equality toggles each one of the sixteen input bytes in turn.
+const x86CustomPointerRuntimeGoDriver = `
+var checks int
+
+func view(kind int, b []byte, old uint32) uint32 {
+	u16 := uint16(b[0]) | uint16(b[1])<<8
+	u32 := uint32(u16) | uint32(b[2])<<16 | uint32(b[3])<<24
+	switch kind {
+	case 0:
+		return old&0xffffff00 | uint32(b[0])
+	case 1:
+		return old&0xffff0000 | uint32(u16)
+	case 2:
+		return u32
+	case 3:
+		return old&0xffff0000 | uint32(uint16(int16(int8(b[0]))))
+	case 4:
+		return old&0xffff0000 | uint32(b[0])
+	case 5:
+		return uint32(int32(int8(b[0])))
+	case 6:
+		return uint32(b[0])
+	case 7:
+		return uint32(int32(int16(u16)))
+	case 8:
+		return uint32(u16)
+	}
+	panic("unknown scalar reference")
+}
+
+func run(name string, kind int, aligned bool,
+	logical func(*byte, *byte, uint32) bool,
+	raw func(*byte, *byte, uint32) uint64) {
+	values := [...]uint32{0, 1, 0x7f, 0x80, 0x8001, 0x7fffffff, 0x80000000, 0xffffffff}
+	offsets := []int{0, 1, 3}
+	if aligned {
+		offsets = []int{0}
+	}
+
+	for _, off := range offsets {
+		count := 17
+		if kind >= 0 {
+			count = 64
+		}
+		for sample := 0; sample < count; sample++ {
+			var p, q [64]byte
+			for i := range p {
+				p[i] = byte(17*i + 0x91)
+				q[i] = byte(29*i + 0x43)
+			}
+			pi := 16 + int((-uintptr(unsafe.Pointer(&p[16])))&15) + off
+			qi := 16 + int((-uintptr(unsafe.Pointer(&q[16])))&15) + off
+			if kind >= 0 {
+				a, b := values[sample/8], values[sample%8]
+				for k := 0; k < 4; k++ {
+					p[pi+k] = byte(a >> uint(8*k))
+					q[qi+k] = byte(b >> uint(8*k))
+				}
+			} else {
+				for k := 0; k < 16; k++ {
+					p[pi+k] = byte(31*k + 0x80)
+					q[qi+k] = p[pi+k]
+				}
+				if sample < 16 {
+					q[qi+sample] ^= 0x81
+				}
+			}
+
+			savedP, savedQ := p, q
+			expected := uint32(0)
+			variants := 1
+			if kind >= 0 {
+				expected = view(kind, p[pi:], 0x9632a5c7) ^ view(kind, q[qi:], 0x5a87bc91)
+				variants = 2
+			}
+			for variant := 0; variant < variants; variant++ {
+				n := expected ^ uint32(variant)
+				want := sample == 16
+				if kind >= 0 {
+					want = variant == 0
+				}
+				byteWant := uint64(0)
+				if want {
+					byteWant = 1
+				}
+
+				if got := logical(&p[pi], &q[qi], n); got != want {
+					panic(fmt.Sprintf("%s offset=%d sample=%d variant=%d logical=%t want=%t",
+						name, off, sample, variant, got, want))
+				}
+				checks++
+				if p != savedP || q != savedQ {
+					panic("logical call mutated input/canaries: " + name)
+				}
+
+				if got := raw(&p[pi], &q[qi], n); got != 0x112233445a5a5a00|byteWant {
+					panic(fmt.Sprintf("%s offset=%d sample=%d variant=%d raw=%x",
+						name, off, sample, variant, got))
+				}
+				checks++
+				if p != savedP || q != savedQ {
+					panic("raw call mutated input/canaries: " + name)
+				}
+			}
+		}
+	}
+}
+`
+
+const x86CustomPointerRuntimeCDriver = `
+static unsigned checks;
+
+static uint32_t view(int kind, const uint8_t *b, uint32_t old) {
+    uint16_t u16 = (uint16_t)b[0] | (uint16_t)b[1] << 8;
+    uint32_t u32 = (uint32_t)u16 | (uint32_t)b[2] << 16 | (uint32_t)b[3] << 24;
+    switch (kind) {
+    case 0:
+        return (old & UINT32_C(0xffffff00)) | b[0];
+    case 1:
+        return (old & UINT32_C(0xffff0000)) | u16;
+    case 2:
+        return u32;
+    case 3:
+        return (old & UINT32_C(0xffff0000)) | (uint16_t)(int16_t)(int8_t)b[0];
+    case 4:
+        return (old & UINT32_C(0xffff0000)) | b[0];
+    case 5:
+        return (uint32_t)(int32_t)(int8_t)b[0];
+    case 6:
+        return b[0];
+    case 7:
+        return (uint32_t)(int32_t)(int16_t)u16;
+    case 8:
+        return u16;
+    }
+    fputs("unknown scalar reference\n", stderr);
+    exit(1);
+}
+
+static void run(const char *name, int kind, int aligned,
+    uint32_t (*logical)(uint8_t *, uint8_t *, uint32_t),
+    uint64_t (*raw)(uint8_t *, uint8_t *, uint32_t)) {
+    static const uint32_t values[] = {0, 1, 0x7f, 0x80, 0x8001, 0x7fffffff, 0x80000000, 0xffffffff};
+    static const unsigned offsets[] = {0, 1, 3};
+
+    for (unsigned oi = 0; oi < (aligned ? 1u : 3u); oi++) {
+        unsigned off = offsets[oi], count = kind >= 0 ? 64 : 17;
+        for (unsigned sample = 0; sample < count; sample++) {
+            _Alignas(16) uint8_t p[64], q[64], savedP[64], savedQ[64];
+            unsigned pi = 16 + off, qi = 16 + off;
+            for (unsigned i = 0; i < 64; i++) {
+                p[i] = (uint8_t)(17*i + 0x91);
+                q[i] = (uint8_t)(29*i + 0x43);
+            }
+            if (kind >= 0) {
+                uint32_t a = values[sample/8], b = values[sample%8];
+                for (unsigned k = 0; k < 4; k++) {
+                    p[pi+k] = (uint8_t)(a >> (8*k));
+                    q[qi+k] = (uint8_t)(b >> (8*k));
+                }
+            } else {
+                for (unsigned k = 0; k < 16; k++) {
+                    p[pi+k] = (uint8_t)(31*k + 0x80);
+                    q[qi+k] = p[pi+k];
+                }
+                if (sample < 16) {
+                    q[qi+sample] ^= 0x81;
+                }
+            }
+
+            memcpy(savedP, p, 64);
+            memcpy(savedQ, q, 64);
+            uint32_t expected = 0;
+            unsigned variants = 1;
+            if (kind >= 0) {
+                expected = view(kind, p+pi, 0x9632a5c7) ^ view(kind, q+qi, 0x5a87bc91);
+                variants = 2;
+            }
+            for (unsigned variant = 0; variant < variants; variant++) {
+                uint32_t n = expected ^ variant, want = kind >= 0 ? variant == 0 : sample == 16;
+                uint32_t got = logical(p+pi, q+qi, n);
+                checks++;
+                if (got != want || memcmp(p, savedP, 64) || memcmp(q, savedQ, 64)) {
+                    fprintf(stderr, "%s offset=%u sample=%u variant=%u logical=%u want=%u or input/canary mutation\n",
+                        name, off, sample, variant, got, want);
+                    exit(1);
+                }
+
+                uint64_t observed = raw(p+pi, q+qi, n);
+                checks++;
+                if (observed != (UINT64_C(0x112233445a5a5a00) | want) ||
+                    memcmp(p, savedP, 64) || memcmp(q, savedQ, 64)) {
+                    fprintf(stderr, "%s offset=%u sample=%u variant=%u raw=%llx or input/canary mutation\n",
+                        name, off, sample, variant, (unsigned long long)observed);
+                    exit(1);
+                }
+            }
+        }
+    }
+}
+`
diff --git a/x86_custom_helper_pointer_runtime_linux_amd64_test.go b/x86_custom_helper_pointer_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..05183c9cf
--- /dev/null
+++ b/x86_custom_helper_pointer_runtime_linux_amd64_test.go
@@ -0,0 +1,72 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"testing"
+)
+
+// This new exhaustive owner does not add rows to the existing ABI0 bool-byte
+// owner. Both original Go386 and LLVM ELF32 programs run directly through the
+// native Linux AMD64 kernel; a missing native compatibility ISA fails.
+func TestCrossLinuxRuntimeMatrixX86CustomHelperDistinctPointerRolesOriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required LLVM22/native i386 pointer-role tools: llc=%q compiler=%v", llc, err)
+	}
+	t.Logf("actual i386 compiler: %s", x86FloatCompareCaptureCommand(t, exec.Command(compiler, "--version")))
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie"}}
+	forms := x86CustomPointerRuntimeForms()
+	for start := 0; start < len(forms); start += x86CustomPointerRuntimeBatchSize {
+		t.Run(fmt.Sprintf("batch%02d", start/4), func(t *testing.T) {
+			x86CustomPointerRuntimeBatch(t, execution, start)
+		})
+	}
+	t.Log("16 complete custom386 pointer helpers: nine scalar load/extension forms and seven whole128 names; original Go logical/raw bool calls, independent numerical/byte oracles, full input and result canaries; three LLVM APIs/backend O0/O2. Not a C _Bool or SDK closure certificate.")
+	x87IA32RequireNativeHost(t)
+}
+
+func x86CustomPointerRuntimeBatch(t *testing.T, execution x86FloatCompareExecution, start int) {
+	t.Helper()
+	assembly, declarations, _, _, helpers := x86CustomPointerRuntimeSource(t, start)
+	_, driver, wrappers := x86CustomPointerRuntimeDrivers(t, start)
+	original := x86CustomPointerRuntimeOriginal(t, start)
+	originalProgram, err := x87IA32StaticExecutable(original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantChecks := x86CustomPointerRuntimeChecks(start)
+	wantOriginal := fmt.Sprintf("original386 pointer-role checks: %d\n", wantChecks)
+	if output := x87IA32RunDirect(t, originalProgram, nil, os.Environ()); string(output) != wantOriginal {
+		t.Fatalf("incomplete original Go386 pointer-role batch: %s", output)
+	}
+	pkg := mustGoPackage(t, "pointerroles386", "package main\n"+declarations)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, assembly, pkg, "386", execution.triple, api,
+				func(name string) (FuncSig, bool) { sig, ok := helpers[name]; return sig, ok })
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "custom-pointer-386", ir+wrappers, driver, level)
+					translatedProgram, err := x87IA32StaticExecutable(executable)
+					if err != nil {
+						t.Fatal(err)
+					}
+					want := fmt.Sprintf("LLVM386 pointer-role checks: %d\n", wantChecks)
+					if output := x87IA32RunDirect(t, translatedProgram, nil, os.Environ()); string(output) != want {
+						t.Fatalf("incomplete independent LLVM pointer-role batch: %s", output)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_custom_register_bool_result.go b/x86_custom_register_bool_result.go
new file mode 100644
index 000000000..cec5d1b21
--- /dev/null
+++ b/x86_custom_register_bool_result.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Explicit ArgRegs is a logical translator transport, not Go ABIInternal or
+// ABI0. It supplies only the declared register bytes and an opaque pointer
+// identity; no FP/AUTO, native entry, caller backing or spill storage exists.
+func checkX86CustomRegisterBoolResultInitialization(fn Func, sig FuncSig, arch string, transfer x86ResultSourceTransfer) error {
+	return checkX86LogicalRegisterResultInitialization(fn, sig, arch, transfer, true, false)
+}
+
+// This selector routes the existing no-argument AX return transport to its
+// proof. It supplies no ABI layout, incoming register bytes or frame storage.
+func x86LogicalScalarResultNeedsProof(sig FuncSig, arch string) bool {
+	return arch == "386" && (sig.Ret == I8 || sig.Ret == I16 || sig.Ret == I32) &&
+		len(sig.Args) == 0 && len(sig.ArgRegs) == 0 &&
+		len(sig.Frame.Params) == 0 && len(sig.Frame.Results) == 0
+}
+
+func checkX86LogicalRegisterResultInitialization(fn Func, sig FuncSig, arch string,
+	transfer x86ResultSourceTransfer, canonicalBool, privateStack bool) error {
+	role := "logical scalar register result"
+	validRole := x86LogicalScalarResultNeedsProof(sig, arch)
+	width := x86ResultScalarBytes(sig.Ret, arch)
+	if canonicalBool {
+		role = "custom register bool result"
+		validRole = arch == "386" && sig.Ret == I1 && len(sig.ArgRegs) != 0 &&
+			len(sig.ArgRegs) == len(sig.Args) && len(sig.Args) <= 6
+		width = 1
+	}
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: %s: %s", ErrProbeNeedsContext, role, reason)
+	}
+	if !validRole ||
+		len(sig.Frame.Params) != 0 || len(sig.Frame.Results) != 0 || fn.FrameSize != 0 || fn.ArgSize != 0 ||
+		sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative ||
+		strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+		fn.x86DirectTailRoot != nil || fn.x86BoolCalls != nil || sig.x86BorrowedBoolTail {
+		return fail("requires a complete distinct ordinary mode32 logical register transport")
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+			ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return fail("raw/native source requires its separate contract")
+		}
+	}
+	initial := x86ResultState{}
+	if privateStack {
+		stack, err := x86ResultPrivateFlagsSource(fn, arch)
+		if err != nil {
+			return err
+		}
+		initial.valueStack = stack
+	}
+	occupied := [16]bool{}
+	for index, typ := range sig.Args {
+		width := int64(0)
+		switch typ {
+		case I1, I8:
+			width = 1
+		case I16:
+			width = 2
+		case I32, Ptr:
+			width = 4
+		}
+		reg := sig.ArgRegs[index]
+		root, _, valid := x86ResultGP(reg, 4, arch)
+		if !valid || occupied[root] || width == 0 {
+			return fail("arguments require unique whole-word register assignments and scalar types")
+		}
+		occupied[root] = true
+		if typ == Ptr {
+			initial.pointerGP[root], initial.callerAddressGP[root] = true, true
+			continue
+		}
+		_, mask, valid := x86ResultGP(reg, width, arch)
+		if !valid {
+			return fail("narrow argument has no registered physical byte view")
+		}
+		initial.gp[root] = mask // No unspecified upper byte becomes initialized.
+		if typ == I1 {
+			initial.canonicalGP[root] = mask
+		}
+	}
+	if canonicalBool {
+		original := transfer
+		transfer = func(pc int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			before := state.canonicalGP
+			if !original(pc, ins, state, owned, resultOffset, arch) {
+				return false
+			}
+			state.canonicalGP = x86RegisterCanonicalBytesAfter(ins, before, arch)
+			for index := range state.gp {
+				state.canonicalGP[index] &= state.gp[index]
+			}
+			return true
+		}
+	}
+	return checkX86ResultSourceFlow(fn, initial, nil, 0, arch, transfer,
+		func(state x86ResultState, pc int) error {
+			root, mask, _ := x86ResultGP(AX, width, arch)
+			if state.gp[root]&mask != mask {
+				return fail(fmt.Sprintf("AX low %d result bytes are not initialized on every path to RET %d", width, pc))
+			}
+			if canonicalBool && state.canonicalGP[root]&mask != mask {
+				return fail(fmt.Sprintf("AX low result byte is not initialized and canonical on every path to RET %d", pc))
+			}
+			return nil
+		})
+}
diff --git a/x86_custom_register_bool_result_test.go b/x86_custom_register_bool_result_test.go
new file mode 100644
index 000000000..b7cd0e6f8
--- /dev/null
+++ b/x86_custom_register_bool_result_test.go
@@ -0,0 +1,285 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86CustomRegisterBoolAPI(t *testing.T, body string, sig FuncSig, api string) (string, error) {
+	t.Helper()
+	source := "TEXT ·custom(SB),4,$0-0\n" + body + "\nRET\n"
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		// ManualSig selects a logical custom register assignment. The actual
+		// Go type is retained, but this is not a physical Go caller/entry proof.
+		goTypes := map[LLVMType]string{Ptr: "*uint64", I1: "bool", I8: "uint8", I16: "uint16", I32: "uint32"}
+		var params []string
+		for index, typ := range sig.Args {
+			goType, found := goTypes[typ]
+			if !found {
+				t.Fatal("fixture needs an actual matching scalar Go declaration", typ)
+			}
+			params = append(params, fmt.Sprintf("a%d %s", index, goType))
+		}
+		pkg := mustGoPackage(t, "custom", "package custom\nfunc custom("+strings.Join(params, ",")+") bool\n")
+		module, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+			GOARCH: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve,
+			ManualSig: func(name string) (FuncSig, bool) { return sig, name == "custom" },
+		})
+		if module != nil && !module.Module.IsNil() {
+			defer module.Module.Dispose()
+			return module.Module.String(), err
+		}
+		return "", err
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: map[string]FuncSig{"custom": sig}}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func TestX86Mode32CustomRegisterBoolPairedEffectHasNoNewAuthority(t *testing.T) {
+	for _, op := range []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"} {
+		t.Run(op, func(t *testing.T) {
+			body := op + " CX,(SI)"
+			if op == "CMPXCHG8B" {
+				body = op + " (SI)"
+			}
+			file, err := Parse(ArchAMD64, "TEXT ·custom(SB),4,$0-0\n"+body+"\nSETEQ AX\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			before := x86DirectTailSnapshot(file)
+			observed := false
+			transfer := func(ordinal int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+				if accepted, known := x86LoweredCompareExchangeResultStep(ins, state, owned, arch); known {
+					if !state.shapeOnly {
+						observed = true
+						wantFlags := uint8(x86ByteFlagsAll)
+						if op == "CMPXCHG8B" {
+							wantFlags = x86ByteFlagZF
+						}
+						if !accepted || state.gp[0] != 15 || state.gp[2] != 15 || state.flags != wantFlags ||
+							state.canonicalGP[0] != 0 || len(state.fp) != 0 || len(state.auto) != 0 || len(state.canonicalFP) != 0 || len(state.resultAddressSlots) != 0 {
+							t.Fatal("paired operation invented canonical/high/FP/AUTO/alias facts", state)
+						}
+					}
+					return accepted
+				}
+				return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+			}
+			if err := checkX86CustomRegisterBoolResultInitialization(file.Funcs[0], x86CustomRegisterBoolSignature(), "386", transfer); err != nil || !observed {
+				t.Fatal("actual declared custom entry and full typed effect not reached", err)
+			}
+			if !reflect.DeepEqual(before, file) {
+				t.Fatal("proof rewrote the complete original source")
+			}
+		})
+	}
+	for _, input := range []int{1, 2, 3, 4} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("narrow-implicit-%d/%s", input, api), func(t *testing.T) {
+				sig := x86CustomRegisterBoolSignature()
+				sig.Args[input] = I8
+				if ir, err := x86CustomRegisterBoolAPI(t, "CMPXCHG8B (SI)\nSETEQ AX", sig, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("an implicit CAS input borrowed undeclared upper bytes", input, err)
+				}
+			})
+		}
+	}
+	// The ordinary declaration-only checker must not borrow the private
+	// logical register role or the paired lowering continuation's native read.
+	file, err := Parse(ArchAMD64, "TEXT ·custom(SB),4,$0-0\nCMPXCHG8B (SI)\nSETEQ AX\nRET\n")
+	if err != nil || !errors.Is(CheckX86ABI0ResultInitialization(file.Funcs[0], x86CustomRegisterBoolSignature(), "386"), ErrProbeNeedsContext) {
+		t.Fatal("public ABI0 observer acquired custom register/memory authority", err)
+	}
+}
+
+func x86CustomRegisterBoolSignature() FuncSig {
+	return FuncSig{Name: "custom", Args: []LLVMType{Ptr, I32, I32, I32, I32}, Ret: I1, ArgRegs: []Reg{SI, AX, DX, BX, CX}}
+}
+
+func TestX86Mode32CustomRegisterBoolCanonicalThreeAPIs(t *testing.T) {
+	for _, condition := range amd64RegisterBoolConditions {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(condition+"/"+api, func(t *testing.T) {
+				ir, err := x86CustomRegisterBoolAPI(t, "CMPL AX,BX\n"+condition+" AX", x86CustomRegisterBoolSignature(), api)
+				if err != nil || ir == "" {
+					t.Fatal("complete registered SETcc canonical transport", err)
+				}
+			})
+		}
+	}
+	for name, row := range map[string]struct {
+		body string
+		good bool
+	}{
+		"atomic-original":       {"LOCK\nCMPXCHG8B (SI)\nSETEQ AX", true},
+		"zero":                  {"MOVB $0,AX", true},
+		"one":                   {"MOVB $1,AX", true},
+		"comparison":            {"CMPL AX,BX\nSETNE AX", true},
+		"raw-restored":          {"MOVB $3,AX\nTESTB AX,AX\nSETNE AX", true},
+		"all-edges":             {"CMPL AX,BX\nJE yes\nMOVB $0,AX\nJMP end\nyes:\nMOVB $1,AX\nend:", true},
+		"two":                   {"MOVB $2,AX", false},
+		"three":                 {"MOVB $3,AX", false},
+		"ff":                    {"MOVB $255,AX", false},
+		"integer-entry":         {"MOVB AX,AX", false},
+		"unknown-flags":         {"SETEQ AX", false},
+		"unknown-upper":         {"MOVB $1,AX\nCMPL DI,BX\nSETEQ AX", false},
+		"one-raw-edge":          {"CMPL AX,BX\nJE yes\nMOVB $3,AX\nJMP end\nyes:\nMOVB $1,AX\nend:", false},
+		"frame-not-owned":       {"MOVB $1,ret+0(FP)", false},
+		"call-no-contract":      {"MOVB $1,AX\nCALL other(SB)", false},
+		"cas-not-canonical":     {"CMPXCHG8B (SI)", false},
+		"pair-no-carry":         {"CMPXCHG8B (SI)\nSETCS AX", false},
+		"pair-preserves-carry":  {"CMPL AX,BX\nCMPXCHG8B (SI)\nSETCS AX", true},
+		"register-cas":          {"CMPXCHGL CX,BX\nSETEQ AX", true},
+		"implicit-unknown":      {"MOVB $1,AX\nCMPXCHG8B (DI)\nSETEQ AX", false},
+		"pointer-overwritten":   {"MOVL $0,SI\nCMPXCHG8B (SI)\nSETEQ AX", false},
+		"pointer-index":         {"CMPXCHG8B (SI)(DI*2)\nSETEQ AX", false},
+		"numeric-pointer-mixed": {"CMPXCHGL SI,BX\nSETEQ AX", false},
+		"detached-lock":         {"LOCK\nNOP\nCMPXCHG8B (SI)\nSETEQ AX", false},
+		"split-lock":            {"LOCK\nnext:\nCMPXCHG8B (SI)\nSETEQ AX", false},
+		"cas-slot-not-owned":    {"CMPXCHG8B ret+0(FP)\nSETEQ AX", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(name+"/"+api, func(t *testing.T) {
+				ir, err := x86CustomRegisterBoolAPI(t, row.body, x86CustomRegisterBoolSignature(), api)
+				if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("custom register canonical result/ABI0 separation", row.good, len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86Mode32CustomRegisterBoolRoleAndByteViews(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·custom(SB),4,$0-0\nMOVB $1,AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, sig := file.Funcs[0], x86CustomRegisterBoolSignature()
+	transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+		return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+	}
+	if err := checkX86CustomRegisterBoolResultInitialization(fn, sig, "386", transfer); err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("ordinary-BP-assignment/"+api, func(t *testing.T) {
+			ordinary := x86CustomRegisterBoolSignature()
+			ordinary.ArgRegs[4] = BP
+			if _, err := x86CustomRegisterBoolAPI(t, "CMPL AX,BP\nSETEQ AX", ordinary, api); err != nil {
+				t.Fatal("explicit mode32 BP bytes were mistaken for a native frame", err)
+			}
+		})
+	}
+	for name, mutate := range map[string]func(*Func, *FuncSig){
+		"missing-assignment":   func(_ *Func, sig *FuncSig) { sig.ArgRegs = sig.ArgRegs[:4] },
+		"extra-assignment":     func(_ *Func, sig *FuncSig) { sig.ArgRegs = append(sig.ArgRegs, DI) },
+		"duplicate-register":   func(_ *Func, sig *FuncSig) { sig.ArgRegs[4] = AX },
+		"byte-assignment":      func(_ *Func, sig *FuncSig) { sig.ArgRegs[4] = CL },
+		"stack-register":       func(_ *Func, sig *FuncSig) { sig.ArgRegs[4] = SP },
+		"mode-invalid-byte-BP": func(_ *Func, sig *FuncSig) { sig.ArgRegs[4] = BPB },
+		"out-of-mode":          func(_ *Func, sig *FuncSig) { sig.ArgRegs[4] = "R8" },
+		"wide-input":           func(_ *Func, sig *FuncSig) { sig.Args[4] = I64 },
+		"float-input":          func(_ *Func, sig *FuncSig) { sig.Args[4] = LLVMType("float") },
+		"aggregate-input":      func(_ *Func, sig *FuncSig) { sig.Args[4] = LLVMType("{ i32, i32 }") },
+		"FP-parameter":         func(_ *Func, sig *FuncSig) { sig.Frame.Params = []FrameSlot{{Type: I32, Field: -1}} },
+		"FP-result":            func(_ *Func, sig *FuncSig) { sig.Frame.Results = []FrameSlot{{Type: I1, Field: -1}} },
+		"frame":                func(fn *Func, _ *FuncSig) { fn.FrameSize = 4 },
+		"argsize":              func(fn *Func, _ *FuncSig) { fn.ArgSize = 1 },
+		"internal-selector":    func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" },
+		"raw-source":           func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86Encoded = true },
+		"address-override":     func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86AddressBits = 16 },
+		"segment":              func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86SegmentPrefix = 0x64 },
+		"wasm":                 func(_ *Func, sig *FuncSig) { sig.WASMNative = true },
+		"borrowed-tail":        func(_ *Func, sig *FuncSig) { sig.x86BorrowedBoolTail = true },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed, signature := x86DirectTailSnapshot(file).Funcs[0], sig
+			signature.ArgRegs = append([]Reg(nil), sig.ArgRegs...)
+			signature.Args = append([]LLVMType(nil), sig.Args...)
+			mutate(&changed, &signature)
+			before := x86DirectTailSnapshot(&File{Arch: ArchAMD64, Funcs: []Func{changed}}).Funcs[0]
+			if err := checkX86CustomRegisterBoolResultInitialization(changed, signature, "386", transfer); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("different role obtained register-result permission", err)
+			}
+			if !reflect.DeepEqual(before, changed) {
+				t.Fatal("result proof rewrote the original source")
+			}
+		})
+	}
+	for _, typ := range []LLVMType{I1, I8, I16} {
+		for _, api := range []string{"text", "module", "Go"} {
+			for _, byteRead := range []bool{false, true} {
+				t.Run(fmt.Sprintf("input-%s/low-only=%t/%s", typ, byteRead, api), func(t *testing.T) {
+					signature := x86CustomRegisterBoolSignature()
+					signature.Args[1] = typ
+					body := "CMPL AX,BX\nSETEQ AX"
+					if byteRead {
+						body = "TESTB AX,AX\nSETEQ AX"
+					}
+					ir, err := x86CustomRegisterBoolAPI(t, body, signature, api)
+					if byteRead && (err != nil || ir == "") || !byteRead && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("narrow logical input initialized unspecified upper GP bytes", byteRead, err)
+					}
+				})
+			}
+		}
+	}
+	for _, typ := range []LLVMType{I1, I8} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("incoming-canonical-%s/%s", typ, api), func(t *testing.T) {
+				signature := x86CustomRegisterBoolSignature()
+				signature.Args[1] = typ
+				ir, err := x86CustomRegisterBoolAPI(t, "MOVB AX,AX", signature, api)
+				if typ == I1 && (err != nil || ir == "") || typ == I8 && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+					t.Fatal("initialized byte was confused with actual I1 input", typ, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86Mode32CustomRegisterBoolCompareExchangeEffects(t *testing.T) {
+	for _, op := range []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"} {
+		for _, locked := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/locked=%t/%s", op, locked, api), func(t *testing.T) {
+					body := op + " CX,(SI)"
+					if op == "CMPXCHG8B" {
+						body = op + " (SI)"
+					}
+					if locked {
+						body = "LOCK\n" + body
+					}
+					ir, err := x86CustomRegisterBoolAPI(t, body+"\nSETEQ AX", x86CustomRegisterBoolSignature(), api)
+					want := strings.ToLower(op)
+					if locked {
+						want = "lock; " + want
+					}
+					if err != nil || !strings.Contains(ir, "asm sideeffect \""+want) || !strings.Contains(ir, "=*m") || strings.Contains(ir, " cmpxchg ptr ") {
+						t.Fatal("complete original native memory effect/faults not retained", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_direct_static_register_result.go b/x86_direct_static_register_result.go
new file mode 100644
index 000000000..b4110968a
--- /dev/null
+++ b/x86_direct_static_register_result.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// A zero-argument direct integer result is returned in AX, not in a fictional
+// ABI0 FP slot. This only selects its complete numerical check. Static extents
+// still come from the actual emitted module; raw RET retains its separate
+// original-source, stack and continuation validation.
+func x86DirectStaticRegisterResultCandidate(fn Func, sig FuncSig, arch string) bool {
+	return len(sig.Frame.Results) == 0 && fn.ArgSize == 0 && x86StaticIntegerResultSourceCandidate(fn, sig, arch)
+}
+
+func x86StaticIntegerResultSourceCandidate(fn Func, sig FuncSig, arch string) bool {
+	width := x86ResultScalarBytes(sig.Ret, arch)
+	integer := sig.Ret == I8 || sig.Ret == I16 || sig.Ret == I32 || sig.Ret == I64
+	if arch != "386" && arch != "amd64" || !integer || width <= 0 || width > x86ResultPointerWord(arch) ||
+		len(sig.Args) != 0 || len(sig.Frame.Params) != 0 ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		sig.WASMContext != "" || sig.WASMNative || sig.amd64GoArguments != nil || sig.x86FixedLocal != nil ||
+		sig.x86CallerRegions != nil || sig.x86BorrowedBoolTail ||
+		fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86ContinuationFlow != nil ||
+		fn.x86DirectTailRoot != nil || fn.x86BoolCalls != nil {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if len(ins.Args) == 2 && x86StaticIntegerResultMoveBytes(ins, arch) != 0 {
+			for _, operand := range ins.Args {
+				if _, static := x86StaticSBReadAddress(operand, arch); static {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+// Select the existing scalar or GP/X memory grammar, including Go's qword
+// aliases and VEX memory widths. A format supplies no initialized source,
+// static extent, caller-memory or raw-entry permission.
+func x86StaticIntegerResultMoveBytes(ins Instr, arch string) int64 {
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+		if err != nil || form.mmx || form.spec.rawOnly || form.memory < 0 {
+			return 0
+		}
+		return int64(form.bits / 8)
+	}
+	return x86RawReturnScalarMoveBytes(x86SourceMoveInstruction(ins, arch).Op)
+}
+
+func (c *amd64Ctx) checkStaticIntegerResultInitialization() error {
+	fn, sig, arch := c.fpScalarSource, c.sig, c.goarch
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: direct static integer result: %s", ErrProbeNeedsContext, reason)
+	}
+	if !x86StaticIntegerResultSourceCandidate(fn, sig, arch) {
+		return fail("requires the complete zero-argument scalar/static role")
+	}
+	if fn.x86RawReplay != nil {
+		if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+			return err
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if form := ins.x86RawNearReturn; form != nil {
+			if fn.x86RawReplay == nil || ins.Op != OpRET || !form.nativeWidth || form.cleanup != 0 {
+				return fail("raw return lost its independent native-width source role")
+			}
+			continue
+		}
+		if fn.x86RawReplay != nil {
+			if _, bound := x86StaticIntegerResultRawView(ins, arch); bound {
+				continue // The complete replay and independent raw memory guard remain required.
+			}
+		}
+		if !x86ResultNamedPredicateInstruction(ins) || isX86RawDirective(ins) {
+			return fail("another raw/native instruction needs its own complete effect")
+		}
+	}
+	funcvalReads, err := c.goReadOnlyStorage.funcvalReadsFor(fn)
+	if err != nil {
+		return err
+	}
+	transfer := func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		state.loweredStaticReads = c.fpScalarData
+		state.goReadOnlyRead = c.goReadOnlyStorage.readFor(ins, arch)
+		defer func() { state.loweredStaticReads, state.goReadOnlyRead = nil, nil }()
+		if accepted, known := goFuncvalReadTransfer(funcvalReads, ordinal, ins, state, arch); known {
+			return accepted
+		}
+		if view, bound := x86StaticIntegerResultRawView(ins, arch); bound {
+			ins = view // Local effect dispatch only; never rewrite either sealed source snapshot.
+			if accepted, known := x86ResultUnknownSBAddressStep(ins, state, arch); known {
+				return accepted // A materialized native address does not define numerical bytes.
+			}
+		}
+		if accepted, known := c.scalarStaticAddressValueTransfer(ins, state, owned, arch); known {
+			return accepted // Preserve the independently bound relocation-value producer.
+		}
+		if accepted, known := c.scalarStaticRMWTransfer(ins, state, owned, arch); known {
+			return accepted
+		}
+		if accepted, known := x86ResultUnknownSBAddressStep(ins, state, arch); known {
+			return accepted // Discarded source addresses never become numerical bytes.
+		}
+		width := x86StaticIntegerResultMoveBytes(ins, arch)
+		if width != 0 && len(ins.Args) == 2 {
+			if address, static := x86StaticSBReadAddress(ins.Args[1], arch); static {
+				// Keep the same independently emitted static extent for every
+				// scalar store. A typed X source needs its actual low bytes,
+				// not a GP-register interpretation of the same source operand.
+				if c.fpScalarData[address] < width {
+					return false
+				}
+				if form, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+					return err == nil && form.memoryWrite &&
+						x86ResultGPSIMDTransfer(ins, form, state, owned, resultOffset, arch)
+				}
+				return x86ResultRead(ins.Args[0], width, state, owned, arch)
+			}
+		}
+		return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+	}
+	if !x86DirectStaticRegisterResultCandidate(fn, sig, arch) {
+		// The same exact scalar/static MOV effects compose with the actual
+		// ABI0 declaration. No fabricated FP field supplies a register result,
+		// and no direct-register result can satisfy an unwritten FP result.
+		return checkX86ABI0ResultInitializationAtSource(fn, sig, arch, transfer, true)
+	}
+	return checkX86ResultSourceFlow(fn, x86ResultState{}, nil, 0, arch, transfer,
+		func(state x86ResultState, _ int) error {
+			index, mask, valid := x86ResultGP(AX, x86ResultScalarBytes(sig.Ret, arch), arch)
+			if !valid || state.gp[index]&mask != mask {
+				return fail("AX result bytes are not initialized on every return path")
+			}
+			return nil
+		})
+}
+
+// Only a complete replay-bound scalar RIP read or source-local LEAQ may use
+// the existing named byte effects. The whole-file raw guard separately checks
+// the actual DATA bytes/extent and every native return; this view grants none
+// of those contracts and is never used by standalone declaration queries.
+func x86StaticIntegerResultRawView(ins Instr, arch string) (Instr, bool) {
+	if arch != "amd64" || ins.x86SourceRaw == nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return Instr{}, false
+	}
+	width := x86RawReturnScalarMoveBytes(ins.Op)
+	read := width != 0 && x86RawReturnDecodedReadIdentity(ins) &&
+		ins.x86RIPMemoryRead.source == 0 && ins.x86RIPMemoryRead.width == width &&
+		len(ins.Args) == 2 && ins.Args[1].Kind == OpReg
+	address := ins.Op == "LEAQ" && len(ins.x86RIPAddressData) != 0
+	if !read && !address {
+		return Instr{}, false
+	}
+	view := ins
+	view.x86Encoded, view.x86SourceRaw = false, nil
+	if address {
+		_, _, _, _, address = x86SBLEAWriteShape(view, arch)
+		if !address {
+			return Instr{}, false
+		}
+	}
+	return view, true
+}
diff --git a/x86_direct_tail_386_runtime_linux_amd64_test.go b/x86_direct_tail_386_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..576393327
--- /dev/null
+++ b/x86_direct_tail_386_runtime_linux_amd64_test.go
@@ -0,0 +1,110 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The required Linux AMD64 owner executes this static i386 original and LLVM
+// counterpart through the kernel's compatibility ISA. An emulated local host
+// is only diagnostic; a missing compiler/compatibility entry fails, never skips.
+func TestCrossLinuxRuntimeMatrixX86DirectTail386OriginalGoAndLLVM(t *testing.T) {
+	for _, carrier := range []string{"SI", "BP", "SI-stack", "BP-stack"} {
+		t.Run(carrier, func(t *testing.T) {
+			register := strings.TrimSuffix(carrier, "-stack")
+			source := strings.ReplaceAll(x86DirectTail386ASM, "SI", register)
+			if strings.HasSuffix(carrier, "-stack") {
+				source = strings.Replace(source, " MOVL "+register+",AX", " PUSHL "+register+"\n POPL AX", 1)
+			}
+			x86DirectTail386ExecuteOriginalGoAndLLVM(t, source)
+		})
+	}
+}
+
+func x86DirectTail386ExecuteOriginalGoAndLLVM(t *testing.T, source string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required LLVM22/i386 native counterpart tools: llc=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie"}}
+	dir := t.TempDir()
+	goDriver := `package main
+import "fmt"
+` + x86DirectTail386Go + `
+func main() {
+ values:=[]uint32{0,1,7,0xffff,0x10000,0x7fffffff,0x80000000,0xffffffff}
+ calls:=0
+ for _,a:=range values {
+  if got:=First(a); got!=a+7 {panic(fmt.Sprintf("First got=%x want=%x",got,a+7))}
+  calls++
+  for _,b:=range values {
+   x,y:=uint16(a),uint16(b)
+   if got:=Second(x,y); got!=uint32(x)+uint32(y) {panic(fmt.Sprintf("Second got=%x want=%x",got,uint32(x)+uint32(y)))}
+   calls++
+  }
+ }
+ fmt.Printf("i386 whole direct-tail original/LLVM: %d independent value checks\n",calls)
+}
+`
+	for name, source := range map[string]string{
+		"go.mod": "module directtail386\n\ngo 1.20\n", "main.go": goDriver, "tail_386.s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original")
+	command := exec.Command("go", "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	want := "i386 whole direct-tail original/LLVM: 72 independent value checks\n"
+	if output := execution.run(t, original); string(output) != want {
+		t.Fatalf("incomplete original i386 execution: %s", output)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t First(uint32_t);
+extern uint32_t Second(uint16_t,uint16_t);
+int main(void) {
+    const uint32_t values[]={0,1,7,0xffff,0x10000,0x7fffffff,0x80000000,0xffffffff};
+    volatile uint32_t canaries[]={0x12345678,0x87654321};
+    unsigned calls=0;
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint32_t a=values[i],got=First(a),want=a+7;
+        if(got!=want) {fprintf(stderr,"First sample=%u got=%x want=%x\n",i,got,want);return 1;}
+        calls++;
+        for(unsigned j=0;j<sizeof(values)/sizeof(values[0]);j++) {
+            uint16_t x=(uint16_t)a,y=(uint16_t)values[j];
+            got=Second(x,y);want=(uint32_t)x+y;
+            if(got!=want) {fprintf(stderr,"Second samples=%u,%u got=%x want=%x\n",i,j,got,want);return 1;}
+            calls++;
+        }
+        if(canaries[0]!=0x12345678||canaries[1]!=0x87654321) return 1;
+    }
+    printf("i386 whole direct-tail original/LLVM: %u independent value checks\n",calls);
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, x86DirectTail386Go, "386", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			output := execution.compileAndRunLLVM(t, "whole-direct-tail-386", ir, driver, level)
+			if string(output) != want {
+				t.Fatalf("%s/%s incomplete i386 LLVM counterpart: %s", api, level, output)
+			}
+			t.Log(api, level, strings.TrimSpace(string(output)))
+		}
+	}
+}
diff --git a/x86_direct_tail_external.go b/x86_direct_tail_external.go
new file mode 100644
index 000000000..e2d5ee08a
--- /dev/null
+++ b/x86_direct_tail_external.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// An ordinary external tail is a separate typed call+return, never a helper
+// ABI or a native frame grant. Root argument/result roles must match exactly.
+func (graph *x86DirectTailGraph) ordinaryExternalTail(root int, symbol string) bool {
+	if root < 0 || root >= len(graph.original.Funcs) || strings.Contains(symbol, "<") ||
+		strings.Contains(symbol, "*") || strings.Contains(graph.original.Funcs[root].Sym, "<") {
+		return false
+	}
+	rootSig, rootKnown := graph.signatures[graph.symbols[graph.original.Funcs[root].Sym]]
+	calleeName, known := graph.symbols[symbol]
+	if !known {
+		calleeName, known = graph.externalSymbols[symbol]
+	}
+	calleeSig, calleeKnown := graph.signatures[calleeName]
+	if !rootKnown || !known || calleeName == "" || !calleeKnown || len(rootSig.ArgRegs) != 0 || len(calleeSig.ArgRegs) != 0 ||
+		rootSig.ARMEntry != nil || calleeSig.ARMEntry != nil || rootSig.WASMContext != "" || calleeSig.WASMContext != "" ||
+		len(rootSig.Frame.Results) == 0 || len(calleeSig.Frame.Results) == 0 ||
+		calleeSig.Name != "" && calleeSig.Name != calleeName {
+		return false
+	}
+	role := func(sig FuncSig) FuncSig {
+		sig.Name = ""
+		sig.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+		sig.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+		for index := range sig.Frame.Params {
+			sig.Frame.Params[index].Name = "" // Descriptive, never a physical role.
+		}
+		for index := range sig.Frame.Results {
+			sig.Frame.Results[index].Name = ""
+		}
+		return sig
+	}
+	return reflect.DeepEqual(role(rootSig), role(calleeSig))
+}
diff --git a/x86_direct_tail_external_test.go b/x86_direct_tail_external_test.go
new file mode 100644
index 000000000..5daf1d055
--- /dev/null
+++ b/x86_direct_tail_external_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectTailOrdinaryTypedExternalTerminal(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, width, typ, triple := "Q", 8, "uint64", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, width, typ, triple = "L", 4, "uint32", "i386-unknown-linux-gnu"
+		}
+		source := fmt.Sprintf(`TEXT ·First(SB),NOSPLIT,$0-%d
+ MOV%s a+0(FP),SI
+ CMP%s SI,$0
+ JEQ 2(PC)
+ JMP ·ordinary(SB)
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+ ADD%s $7,SI
+ MOV%s SI,ret+%d(FP)
+ RET
+`, width*2, word, word, word, word, width)
+		for _, ordinary := range []struct {
+			name, declaration string
+			context           bool
+		}{
+			{"same_role", "func ordinary(other " + typ + ") " + typ, false},
+			{"different_arg", "func ordinary(other uint8) " + typ, true},
+			{"different_result", "func ordinary(other " + typ + ") uint8", true},
+			{"missing", "", true},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+ordinary.name+"/"+api, func(t *testing.T) {
+					_, err := x86ScalarFPBitViewAPI(t, source, "func First(a "+typ+") "+typ+"\n"+ordinary.declaration, arch, triple, api)
+					if ordinary.context && !errors.Is(err, ErrProbeNeedsContext) || !ordinary.context && err != nil {
+						t.Fatalf("ordinary typed terminal: %v", err)
+					}
+				})
+			}
+		}
+		for _, target := range []string{"ordinary+1", "ordinary<ABIInternal>", "ordinary<>(SB)", "*ordinary"} {
+			t.Run(arch+"/"+target, func(t *testing.T) {
+				mutated := strings.ReplaceAll(source, "·ordinary(SB)", "·"+strings.TrimSuffix(target, "(SB)")+"(SB)")
+				_, err := x86ScalarFPBitViewAPI(t, mutated, "func First(a "+typ+") "+typ+"\nfunc ordinary(other "+typ+") "+typ, arch, triple, "text")
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("offset/native/unbound terminal accepted", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86DirectTailExternalTerminalRequiresNamedIdentity(t *testing.T) {
+	source, declarations := x86DirectTailFollowupFixture("amd64")
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declarations)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalResolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, normalResolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// An explicit manual caller cannot use an empty mapping/name to recreate
+	// the declaration which the Go producer correctly refuses to synthesize.
+	ordinary := sigs["ordinary"]
+	delete(sigs, "ordinary")
+	ordinary.Name = ""
+	sigs[""] = ordinary
+	resolve := func(symbol string) string {
+		name := strings.TrimPrefix(goStripABISuffix(symbol), "·")
+		if name == "ordinary" {
+			return ""
+		}
+		return name
+	}
+	_, err = PrepareX86DirectTailSource(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("empty external source identity accepted", err)
+	}
+}
diff --git a/x86_direct_tail_fixture_test.go b/x86_direct_tail_fixture_test.go
new file mode 100644
index 000000000..0bd9f862e
--- /dev/null
+++ b/x86_direct_tail_fixture_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Test-owned complete source used by the original-Go, five-target object and
+// runtime counterparts. It grants no source, entry or machine-state authority.
+type x86DirectTailRuntimeFixture struct {
+	assembly, declarations, prototypes, goCalls, cCalls string
+}
+
+func x86DirectTailRuntimeSources(arch string) x86DirectTailRuntimeFixture {
+	var assembly, declarations, prototypes, goCalls, cCalls strings.Builder
+	assembly.WriteString("#include \"textflag.h\"\n")
+	rows := []struct{ name, effect, body string }{
+		{"shared", "NOP", "MOVQ SI,AX\n ADDQ DI,AX"},
+		{"renamed", "NOP", "MOVQ SI,AX\n ADDQ DI,AX"},
+		{"flags", "CMPQ SI,DI", "SETEQ AL\n MOVBLZX AL,AX"},
+		{"vector_flags", "MOVQ SI,X0\n CMPQ SI,DI", "MOVQ X0,AX\n ADCQ DI,AX"},
+		{"zero_extension", "MOVL SI,X0", "MOVQ X0,AX\n ADDQ DI,AX"},
+		{"chain", "NOP", "JMP last%d<>(SB)\nTEXT last%d<>(SB),NOSPLIT,$0-0\n MOVQ SI,AX\n ADDQ DI,AX"},
+		{"diamond", "CMPQ SI,DI", "JE left\n ADDQ $3,DI\n JMP joined%d<>(SB)\nleft:\n ADDQ $5,DI\n JMP joined%d<>(SB)\nTEXT joined%d<>(SB),NOSPLIT,$0-0\n MOVQ SI,AX\n ADDQ DI,AX"},
+	}
+	for index, row := range rows {
+		body := row.body
+		if row.name == "chain" {
+			body = fmt.Sprintf(body, index, index)
+		} else if row.name == "diamond" {
+			body = fmt.Sprintf(body, index, index, index)
+		}
+		fmt.Fprintf(&assembly, `TEXT ·First%d(SB),NOSPLIT,$0-16
+ MOVQ a+0(FP),SI
+ MOVQ $7,DI
+ %s
+ JMP %s%d<>(SB)
+TEXT ·Second%d(SB),NOSPLIT,$0-16
+ MOVL a+0(FP),SI
+ MOVL b+4(FP),DI
+ %s
+ JMP %s%d<>(SB)
+TEXT %s%d<>(SB),NOSPLIT,$0-0
+ %s
+ MOVQ AX,ret+8(FP)
+ RET
+`, index, row.effect, row.name, index, index, row.effect, row.name, index, row.name, index, body)
+		fmt.Fprintf(&declarations, "func First%d(a uint64) uint64\nfunc Second%d(a,b uint32) uint64\n", index, index)
+		fmt.Fprintf(&prototypes, "extern uint64_t First%d(uint64_t);\nextern uint64_t Second%d(uint32_t,uint32_t);\n", index, index)
+		fmt.Fprintf(&goCalls, `
+  if got:=First%d(a); got!=reference(%d,a,7) { panic(fmt.Sprintf("First%d: got=%%x want=%%x",got,reference(%d,a,7))) }
+  for _,value:=range values {
+   x,y:=uint32(a),uint32(value)
+   if got:=Second%d(x,y); got!=reference(%d,uint64(x),uint64(y)) { panic(fmt.Sprintf("Second%d: got=%%x want=%%x",got,reference(%d,uint64(x),uint64(y)))) }
+   calls++
+  }
+  calls++
+`, index, index, index, index, index, index, index, index)
+		fmt.Fprintf(&cCalls, `
+    {uint64_t got=First%d(a),want=reference(%d,a,7);
+     if(got!=want) {fprintf(stderr,"First%d transport failure sample=%%u got=%%llx want=%%llx\n",i,(unsigned long long)got,(unsigned long long)want);return 1;}}
+    for(unsigned j=0;j<sizeof(values)/sizeof(values[0]);j++) {
+        uint32_t x=(uint32_t)a,y=(uint32_t)values[j];
+        uint64_t got=Second%d(x,y),want=reference(%d,x,y);
+        if(got!=want) {fprintf(stderr,"Second%d transport failure samples=%%u,%%u got=%%llx want=%%llx\n",i,j,(unsigned long long)got,(unsigned long long)want);return 1;}
+        calls++;
+    }
+    calls++;
+`, index, index, index, index, index, index)
+	}
+	fixture := x86DirectTailRuntimeFixture{assembly.String(), declarations.String(), prototypes.String(), goCalls.String(), cCalls.String()}
+	if arch == "386" {
+		fixture.assembly = strings.NewReplacer("$0-16", "$0-8", "ret+8(FP)", "ret+4(FP)",
+			"MOVQ", "MOVL", "ADDQ", "ADDL", "ADCQ", "ADCL", "CMPQ", "CMPL").Replace(fixture.assembly)
+		fixture.assembly = strings.ReplaceAll(fixture.assembly, "MOVL a+0(FP),SI\n MOVL b+4(FP),DI", "MOVWLZX a+0(FP),SI\n MOVWLZX b+2(FP),DI")
+		fixture.declarations = strings.ReplaceAll(fixture.declarations, "a,b uint32", "a,b uint16")
+		fixture.declarations = strings.ReplaceAll(fixture.declarations, "uint64", "uint32")
+		// The i386 execution oracle has its own u32/u16 reference and caller
+		// transport. Do not reuse this AMD64-only C/Go driver by type guessing.
+		fixture.prototypes, fixture.goCalls, fixture.cCalls = "", "", ""
+	}
+	return fixture
+}
diff --git a/x86_direct_tail_flow.go b/x86_direct_tail_flow.go
new file mode 100644
index 000000000..f305fa9a7
--- /dev/null
+++ b/x86_direct_tail_flow.go
@@ -0,0 +1,247 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+)
+
+func (graph *x86DirectTailGraph) root(root int, byName map[string]int, limit int, allowPrivateCalls bool) (*x86DirectTailRoot, error) {
+	framed := graph.fixedLocal != nil && graph.fixedLocal.frames[graph.symbols[graph.original.Funcs[root].Sym]]
+	members := map[int]bool{root: true}
+	queue := []int{root}
+	hasCalls := false
+	for len(queue) != 0 {
+		at := queue[0]
+		queue = queue[1:]
+		fn := graph.original.Funcs[at]
+		if graph.goarch == "386" && strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+			return nil, x86DirectTailContext("386 source has no AMD64 register-entry contract")
+		}
+		observedLeaf := framed && graph.helpers[fn.Sym] && graph.fixedLocal.leaves[fn.Sym] != ""
+		if fn.FrameSize != 0 && !(framed && at == root || observedLeaf) || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+			fn.x86RawReplay != nil || len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 ||
+			graph.helpers[fn.Sym] && fn.ArgSize != 0 {
+			return nil, x86DirectTailContext("native/frame/helper argument role is not closed: %s", fn.Sym)
+		}
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpCALL && !allowPrivateCalls {
+				return nil, x86DirectTailContext("custom CALL retains its independent declaration/ABI owner")
+			}
+			if isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+				ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 ||
+				len(ins.x86SourceStackFP) != 0 || len(ins.x86CallerMemory) != 0 || len(ins.x86FixedLocalMemory) != 0 ||
+				ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil {
+				return nil, x86DirectTailContext("raw/call/native effect has no continuation role: %s", ins.Raw)
+			}
+			for _, arg := range ins.Args {
+				if !framed && (arg.Kind == OpReg && x86LogicalSourceFrameRegister(arg.Reg, graph.goarch) ||
+					arg.Kind == OpMem && (x86LogicalSourceFrameRegister(arg.Mem.Base, graph.goarch) ||
+						x86LogicalSourceFrameRegister(arg.Mem.Index, graph.goarch) ||
+						arg.Mem.Base == "PC" && !x86DirectTailPCBranch(ins)) ||
+					arg.Kind == OpFPAddr) {
+					return nil, x86DirectTailContext("physical SP/BP/PC/frame address has no continuation role: %s", ins.Raw)
+				}
+			}
+			if ins.Op == OpCALL && (len(ins.Args) != 1 || ins.Args[0].Kind != OpSym) {
+				return nil, x86DirectTailContext("CALL lacks one original private source target")
+			}
+			if ins.Op != OpJMP && ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym {
+				continue
+			}
+			hasCalls = hasCalls || ins.Op == OpCALL
+			name, offset, valid := parseSBRef(ins.Args[0].Sym)
+			if !valid || offset != 0 {
+				return nil, x86DirectTailContext("indirect/external/missing/offset tail target: %s", ins.Raw)
+			}
+			if !graph.helpers[name] {
+				if ins.Op == OpCALL || !graph.ordinaryExternalTail(root, name) {
+					return nil, x86DirectTailContext("external terminal lacks identical ordinary root ABI0 roles: %s", ins.Raw)
+				}
+				continue
+			}
+			index, found := byName[name]
+			if !found || index < 0 || index >= len(graph.original.Funcs) || graph.original.Funcs[index].Sym != name {
+				return nil, x86DirectTailContext("tail target is not an original source TEXT")
+			}
+			if !members[index] {
+				members[index] = true
+				queue = append(queue, index)
+			}
+		}
+	}
+	view := &x86DirectTailRoot{graph: graph, text: root}
+	starts := make(map[int]int)
+	labels := make(map[int]map[string]int)
+	order := []int{root}
+	for index := range members {
+		if index != root {
+			order = append(order, index)
+		}
+	}
+	sort.Ints(order[1:]) // Original source order without rescanning unrelated TEXTs.
+	for _, index := range order {
+		count := 0
+		for _, ins := range graph.original.Funcs[index].Instrs {
+			if ins.Op != OpTEXT && ins.Op != OpLABEL {
+				count++
+			}
+		}
+		if count == 0 || count > limit-len(view.points) {
+			return nil, x86DirectTailContext("empty/oversized source continuation instruction budget")
+		}
+		starts[index] = len(view.points)
+		labels[index] = make(map[string]int)
+		for ordinal, ins := range graph.original.Funcs[index].Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			if ins.Op == OpLABEL {
+				if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+					return nil, x86DirectTailContext("malformed original local label")
+				}
+				label := ins.Args[0].Sym
+				if _, repeated := labels[index][label]; repeated {
+					return nil, x86DirectTailContext("duplicate original local label")
+				}
+				labels[index][label] = len(view.points)
+				continue
+			}
+			view.points = append(view.points, x86DirectTailPoint{text: index, instruction: ordinal})
+			view.instructions = append(view.instructions, ins)
+			view.ordinals = append(view.ordinals, ordinal)
+		}
+	}
+	view.edges = make([][]int, len(view.points))
+	view.externalTails = make([]bool, len(view.points))
+	for pc, ins := range view.instructions {
+		if ins.Op == OpRET {
+			if len(ins.Args) != 0 {
+				return nil, x86DirectTailContext("nonordinary source RET")
+			}
+			continue
+		}
+		next := []int{pc + 1}
+		if ins.Op == OpJMP || ins.Op == OpCALL || isAMD64ConditionalBranch(ins.Op) {
+			args := x86DirectTailBranchArgs(ins)
+			if len(args) != 1 {
+				return nil, x86DirectTailContext("unbound source branch operands")
+			}
+			arg := args[0]
+			label := arg.Sym
+			if arg.Kind == OpIdent {
+				label = arg.Ident
+			} else if arg.Kind == OpReg {
+				label = string(arg.Reg)
+			}
+			target, found := labels[view.points[pc].text][label]
+			if x86DirectTailPCBranch(ins) {
+				// Go asmJump uses virtual Prog coordinates, not machine-byte
+				// displacements or graph/block coordinates. Labels do not count;
+				// PCDATA/FUNCDATA/PCALIGN do. The view retains exactly those
+				// source Progs in each TEXT. Bound before converting/adding, and
+				// never let a relative edge cross an original TEXT boundary.
+				offset := arg.Mem.Off
+				if offset < -int64(pc) || offset >= int64(len(view.points)-pc) {
+					return nil, x86DirectTailContext("PC branch outside original source instructions")
+				}
+				target, found = pc+int(offset), true
+			}
+			if (ins.Op == OpJMP || ins.Op == OpCALL) && arg.Kind == OpSym {
+				name, offset, valid := parseSBRef(arg.Sym)
+				if ins.Op == OpJMP && valid && offset == 0 && !graph.helpers[name] && graph.ordinaryExternalTail(root, name) {
+					view.externalTails[pc] = true
+					continue // No graph successor: ordinary typed call+return.
+				}
+				index, exists := byName[name]
+				if !valid || !exists || !members[index] || !graph.helpers[name] || offset != 0 {
+					return nil, x86DirectTailContext("unbound private tail node")
+				}
+				target, found = starts[index], true
+			}
+			if !found || target >= len(view.points) || view.points[target].text != view.points[pc].text &&
+				!((ins.Op == OpJMP || ins.Op == OpCALL) && arg.Kind == OpSym) {
+				return nil, x86DirectTailContext("indirect/external/missing source branch")
+			}
+			if ins.Op == OpJMP || ins.Op == OpCALL {
+				next = []int{target}
+			} else {
+				next = append(next, target)
+			}
+		}
+		for index, target := range next {
+			if target < 0 || target >= len(view.points) || index == 0 && ins.Op != OpJMP && ins.Op != OpCALL && view.points[target].text != view.points[pc].text {
+				return nil, x86DirectTailContext("source falls outside its original TEXT continuation")
+			}
+		}
+		view.edges[pc] = next
+	}
+	if hasCalls {
+		return view.expandPrivateCalls(limit)
+	}
+	return view, nil
+}
+
+// Only Go's Ybr source branch role is accepted here. A PC memory/address
+// operand on another instruction supplies no physical native-PC authority.
+func x86DirectTailBranchArgs(ins Instr) []Operand {
+	args := ins.Args
+	_, counter := x86CounterControlPropertiesForOpcode(ins.Op)
+	if isAMD64ConditionalBranch(ins.Op) && !counter && len(args) == 2 &&
+		args[0].Kind == OpImm && args[0].ImmRaw == "" && !args[0].ImmIsFloat &&
+		(args[0].Imm == 0 || args[0].Imm == 1) {
+		return args[1:]
+	}
+	return args
+}
+
+func x86DirectTailPCBranch(ins Instr) bool {
+	if ins.Op != OpJMP && !isAMD64ConditionalBranch(ins.Op) {
+		return false
+	}
+	args := x86DirectTailBranchArgs(ins)
+	if len(args) != 1 || args[0].Kind != OpMem {
+		return false
+	}
+	memory := args[0].Mem
+	return memory.Base == "PC" && memory.OffRaw == "" && memory.Sym == "" && memory.Index == "" &&
+		memory.Scale == 0 && memory.Segment == "" && memory.IndexExt == ""
+}
+
+func (view *x86DirectTailRoot) blocks() []amd64Block {
+	blocks := make([]amd64Block, len(view.points))
+	for pc, point := range view.points {
+		blocks[pc] = amd64Block{name: fmt.Sprintf("p9_tail_%d_%d_%d", point.text, point.instruction, pc),
+			instrs: []Instr{view.instructions[pc]}, synthetic: true}
+	}
+	return blocks
+}
+
+func (view *x86DirectTailRoot) features() Func {
+	fn := view.graph.original.Funcs[view.text]
+	fn.Instrs = view.instructions // A cost/feature projection, never new source.
+	return fn
+}
+
+func (file *File) x86DirectTailHelper(symbol string) bool {
+	return file.x86DirectTails != nil && file.x86DirectTails.helpers[symbol]
+}
+
+func (file *File) x86DirectTailView(symbol string) *x86DirectTailRoot {
+	if file.x86DirectTails == nil || file.x86DirectTails.fixedLocal != nil {
+		return nil
+	}
+	return file.x86DirectTails.roots[symbol]
+}
+
+func x86DirectTailSigNeedsOwnBoolFrame(sig FuncSig, fn Func, goarch string) bool {
+	if goarch == "amd64" && strings.HasSuffix(fn.Sym, "<ABIInternal>") {
+		return false // The existing canonical register proof still applies.
+	}
+	for _, slot := range sig.Frame.Results {
+		if slot.Type == I1 {
+			return true
+		}
+	}
+	return sig.Ret == I1
+}
diff --git a/x86_direct_tail_followup_fixture_test.go b/x86_direct_tail_followup_fixture_test.go
new file mode 100644
index 000000000..1d216507d
--- /dev/null
+++ b/x86_direct_tail_followup_fixture_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// One complete ordinary source file composes the three independent roles.
+// Two differently typed roots share a helper and retain distinct result slots.
+func x86DirectTailFollowupFixture(arch string) (source, declarations string) {
+	word, width, typ := "Q", 8, "uint64"
+	if arch == "386" {
+		word, width, typ = "L", 4, "uint32"
+	}
+	declarations = fmt.Sprintf("func Forward(a %s) %s\nfunc Address(a %s) %s\nfunc Alternate(a,b %s) %s\nfunc Backward(a %s) %s\nfunc ordinary(a %s) %s\n", typ, typ, typ, typ, typ, typ, typ, typ, typ, typ)
+	source = fmt.Sprintf(`TEXT ·Forward(SB),NOSPLIT,$0-%d
+ MOVWORD a+0(FP),SI
+ CMPWORD SI,$0
+ JEQ $1,2(PC)
+ JMP ·ordinary(SB)
+ LEAWORD ret+%d(FP),DI
+ JMP shared<>(SB)
+TEXT ·Address(SB),NOSPLIT,$0-%d
+ MOVWORD a+0(FP),SI
+ LEAWORD ret+%d(FP),DI
+ JMP shared<>(SB)
+TEXT ·Alternate(SB),NOSPLIT,$0-%d
+ MOVWORD a+0(FP),SI
+ MOVWORD b+%d(FP),BX
+ ADDWORD BX,SI
+ LEAWORD ret+%d(FP),DI
+ JMP shared<>(SB)
+TEXT ·Backward(SB),NOSPLIT,$0-%d
+ MOVWORD a+0(FP),SI
+ MOVWORD $0,BX
+start:
+ ADDWORD $1,BX
+ SUBWORD $1,SI
+ JNE -2(PC)
+ LEAWORD ret+%d(FP),DI
+ MOVWORD BX,SI
+ JMP shared<>(SB)
+TEXT shared<>(SB),NOSPLIT,$0-0
+ MOVWORD DI,CX
+ LEAWORD 1(CX),DX
+ LEAWORD -1(DX),CX
+ ADDWORD $7,SI
+ MOVWORD SI,(CX)
+ MOVWORD (CX),BX
+ CMPWORD BX,$0
+ JEQ 2(PC)
+ MOVWORD BX,(CX)
+ RET
+`, 2*width, width, 2*width, width, 3*width, width, 2*width, 2*width, width)
+	// A numeric NOSPLIT flag keeps this independently assembled fixture free
+	// of an implicit textflag.h input; the complete original source is retained.
+	return strings.ReplaceAll(strings.ReplaceAll(source, "WORD", word), "NOSPLIT", "4"), declarations
+}
diff --git a/x86_direct_tail_followup_object_test.go b/x86_direct_tail_followup_object_test.go
new file mode 100644
index 000000000..a32079b8e
--- /dev/null
+++ b/x86_direct_tail_followup_object_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectTailPCCompleteGoBranchRowsAndAliases(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(data), "var yjcond = []ytab{\n\t{Zbr, 0, argList{Ybr}},\n\t{Zbr, 0, argList{Yi0, Ybr}},\n\t{Zbr, 1, argList{Yi1, Ybr}},\n}") {
+		t.Fatal("complete Go conditional Ybr/hint rows changed")
+	}
+	rows := regexp.MustCompile(`\{A(J[A-Z]+), yjcond, Px, opBytes\{[^}]+\}\}`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 16 {
+		t.Fatal("complete Go conditional encoder rows changed", len(rows))
+	}
+	names := make(map[string]bool)
+	for _, row := range rows {
+		names[row[1]] = true
+		if !isAMD64ConditionalBranch(Op(row[1])) {
+			t.Fatal("Go branch row missing source CFG", row)
+		}
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, alias := range regexp.MustCompile(`instructions\["(J[A-Z]+)"\] = x86\.A(J[A-Z]+)`).FindAllStringSubmatch(string(aliases), -1) {
+		if names[alias[2]] {
+			names[alias[1]] = true
+			if !isAMD64ConditionalBranch(Op(alias[1])) {
+				t.Fatal("registered Go Jcc alias missing CFG", alias)
+			}
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		source.WriteString("TEXT ·Value(SB),4,$0-0\n CMPL AX,AX\n")
+		for name := range names {
+			for _, hint := range []string{"", "$0,", "$1,"} {
+				source.WriteString(fmt.Sprintf(" %s %s1(PC)\n", name, hint))
+			}
+		}
+		source.WriteString(" JMP 1(PC)\n RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		for _, malformed := range []string{"JEQ $2,1(PC)", "JEQ $1.0,1(PC)", "JEQ 1(PC)(AX*1)", "JMP $1,1(PC)"} {
+			goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$0-0\n"+malformed+"\n RET\n", "", false)
+		}
+	}
+}
+
+func TestX86DirectTailFollowupOriginalGoAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86DirectTailFollowupFixture(target.arch)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					dir := t.TempDir()
+					input, output := filepath.Join(dir, "followup.ll"), filepath.Join(dir, "followup.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", output))
+					if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+						t.Fatalf("%s/%s missing real LLVM object: %v", api, level, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_direct_tail_followup_runtime_linux_amd64_test.go b/x86_direct_tail_followup_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..6f2b3c6a4
--- /dev/null
+++ b/x86_direct_tail_followup_runtime_linux_amd64_test.go
@@ -0,0 +1,108 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// The Linux AMD64 owner must execute both native ISA modes. Other hosts retain
+// portable objects and source checks; no missing compiler/ISA counts as a pass.
+func TestCrossLinuxRuntimeMatrixX86DirectTailPCResultAliasesAndExternal(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			goType, cType, values := "uint64", "uint64_t", "0,1,7,0x80000000,0xffffffff,0xffffffffffffffff"
+			triple, compiler := "x86_64-unknown-linux-gnu", []string{clang, "-target", "x86_64-unknown-linux-gnu"}
+			checks := 24
+			if arch == "386" {
+				goType, cType, values = "uint32", "uint32_t", "0,1,7,0x80000000,0xffffffff"
+				triple = "i386-unknown-linux-gnu"
+				cross, err := exec.LookPath("i686-linux-gnu-gcc")
+				if err != nil {
+					t.Fatal("native i386 owner requires the static cross compiler", err)
+				}
+				compiler, checks = []string{cross, "-static", "-no-pie"}, 20
+			}
+			execution := x86FloatCompareExecution{llc: llc, triple: triple, compiler: compiler}
+			source, declarations := x86DirectTailFollowupFixture(arch)
+			declarations = strings.Replace(declarations, "func ordinary(a "+goType+") "+goType+"\n",
+				"func ordinary(a "+goType+") "+goType+" {return a*3+11}\n", 1)
+			goDriver := fmt.Sprintf(`package main
+import "fmt"
+%s
+//go:noinline
+func snapshot(p *[2]uint64) [2]uint64 {return *p}
+func main() {
+ values:=[]%s{%s}
+ canaries:=[2]uint64{0x1122334455667788,0xaabbccddeeff0099}
+ before:=snapshot(&canaries)
+ for _,a:=range values {
+  forward:=a*3+11; if a==0 {forward=7}
+  b:=a^%s(0x87654321)
+  n:=(a&7)+1
+  got:=[]%s{Forward(a),Address(a),Alternate(a,b),Backward(n)}
+  want:=[]%s{forward,a+7,a+b+7,n+7}
+  for i:=range got {if got[i]!=want[i] {panic(fmt.Sprintf("case %%d got %%x want %%x",i,got[i],want[i]))}}
+  if snapshot(&canaries)!=before {panic("original caller canary changed")}
+ }
+ fmt.Println("direct-tail followup: %d checks")
+}
+`, declarations, goType, values, goType, goType, goType, checks)
+			dir := t.TempDir()
+			for name, contents := range map[string]string{"go.mod": "module directfollowup\n\ngo 1.20\n", "main.go": goDriver, "tail_" + arch + ".s": source} {
+				if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			original := filepath.Join(dir, "original")
+			command := exec.Command("go", "build", "-p=1", "-o", original, ".")
+			command.Dir = dir
+			command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+			x86FloatCompareCaptureCommand(t, command)
+			want := fmt.Sprintf("direct-tail followup: %d checks\n", checks)
+			if output := execution.run(t, original); string(output) != want {
+				t.Fatalf("incomplete original Go: %s", output)
+			}
+			cDriver := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+typedef %s U;
+extern U Forward(U),Address(U),Alternate(U,U),Backward(U);
+U ordinary(U a) {return a*3+11;}
+int main(void) {
+ const U values[]={%s};
+ volatile uint64_t canaries[]={UINT64_C(0x1122334455667788),UINT64_C(0xaabbccddeeff0099)};
+ for(unsigned v=0;v<sizeof(values)/sizeof(values[0]);v++) {
+  U a=values[v], b=a^(U)0x87654321, n=(a&7)+1;
+  U actual[]={Forward(a),Address(a),Alternate(a,b),Backward(n)};
+  U reference[]={a==0?7:a*3+11,a+7,a+b+7,n+7};
+  for(unsigned i=0;i<4;i++) if(actual[i]!=reference[i]) {fprintf(stderr,"case %%u got %%llx want %%llx\n",i,(unsigned long long)actual[i],(unsigned long long)reference[i]);return 1;}
+  if(canaries[0]!=UINT64_C(0x1122334455667788)||canaries[1]!=UINT64_C(0xaabbccddeeff0099)) return 1;
+ }
+ puts("direct-tail followup: %d checks");
+ return 0;
+}
+`, cType, values, checks)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					if output := execution.compileAndRunLLVM(t, "direct-tail-followup", ir, cDriver, level); string(output) != want {
+						t.Fatalf("%s/%s incomplete LLVM: %s", api, level, output)
+					}
+					t.Log(api, level, strings.TrimSpace(want))
+				}
+			}
+		})
+	}
+}
diff --git a/x86_direct_tail_numerical.go b/x86_direct_tail_numerical.go
new file mode 100644
index 000000000..9ebbe60b3
--- /dev/null
+++ b/x86_direct_tail_numerical.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import "reflect"
+
+// A continuation emits inside its typed root, but a numerical certificate
+// retains its original helper TEXT and instruction. Match the current sealed
+// point instead of changing that certificate into a fictitious root read.
+func (c *amd64Ctx) numericalReadAtOriginalSource(ins Instr, read numericalSBReadFact, block, ordinal int) bool {
+	view := c.directTail
+	if view == nil {
+		return c.sig.Name == read.Function
+	}
+	graph, cert := view.graph, ins.x86NumericalRead
+	if graph == nil || graph.original == nil || graph.revoked.Load() || graph.goarch != c.goarch ||
+		cert == nil || graph.numerical == nil || cert.binding != graph.numerical || ordinal != 0 ||
+		block < 0 || block >= len(view.points) || block >= len(view.instructions) ||
+		view.text < 0 || view.text >= len(graph.original.Funcs) {
+		return false
+	}
+	root := graph.original.Funcs[view.text]
+	if graph.roots[root.Sym] != view || c.sig.Name != graph.symbols[root.Sym] ||
+		view.instructions[block].x86NumericalRead != cert {
+		return false
+	}
+	point := view.points[block]
+	if point.text < 0 || point.text >= len(graph.original.Funcs) {
+		return false
+	}
+	fn := graph.original.Funcs[point.text]
+	if point.instruction < 0 || point.instruction >= len(fn.Instrs) || read.Instruction != point.instruction ||
+		read.Function != graph.symbols[fn.Sym] {
+		return false
+	}
+	original := fn.Instrs[point.instruction]
+	return reflect.DeepEqual(x86DirectTailInstructionSnapshot(ins), original) &&
+		reflect.DeepEqual(x86DirectTailInstructionSnapshot(view.instructions[block]), original) &&
+		reflect.DeepEqual(x86DirectTailInstructionSnapshot(read.Original), original)
+}
+
+func x86DirectTailNumericalRequest(file *File, options Options) (*File, error) {
+	binding := options.NumericalReads
+	if binding == nil {
+		for _, fn := range file.Funcs {
+			for _, ins := range fn.Instrs {
+				if ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil {
+					return nil, x86DirectTailContext("a copied numerical node has no complete live source binding")
+				}
+			}
+		}
+		return x86DirectTailSnapshot(file), nil
+	}
+	if binding.source == nil || binding.source.role != numericalSBSDKSource || binding.source.assembly == nil ||
+		binding.source.literals != nil || len(binding.literalAccesses) != 0 || binding.literalMinimum != nil {
+		return nil, x86DirectTailContext("numerical continuation needs its independent metadata-only original-node role")
+	}
+	frozen, _, err := freezeNumericalReadInputs(file, options)
+	return frozen, err
+}
+
+func (graph *x86DirectTailGraph) joinNumericalNodes(request *File) error {
+	if graph.numerical == nil {
+		return nil
+	}
+	for _, view := range graph.roots {
+		for pc, point := range view.points {
+			original := graph.original.Funcs[point.text].Instrs[point.instruction]
+			actual := request.Funcs[point.text].Instrs[point.instruction]
+			if !reflect.DeepEqual(x86DirectTailInstructionSnapshot(actual), original) {
+				return x86DirectTailContext("numerical continuation original node changed")
+			}
+			if cert := actual.x86NumericalRead; cert != nil {
+				read, _, valid := numericalCertifiedRead(actual, graph.goarch)
+				if !valid || cert.binding != graph.numerical || read.Function != graph.numerical.resolve(request.Funcs[point.text].Sym) ||
+					read.Instruction != point.instruction {
+					return x86DirectTailContext("numerical certificate belongs to another original TEXT/instruction")
+				}
+			}
+			view.instructions[pc] = actual // Immutable request-local original node.
+		}
+	}
+	return nil
+}
+
+func x86DirectTailInstructionSnapshot(ins Instr) Instr {
+	ins.x86NumericalRead, ins.x86SDKLiteral = nil, nil
+	return ins
+}
+
+// JSON freezing drops private fields. Restore only this already verified
+// request's graph views; no public File or helper signature can create them.
+func preserveX86DirectTailNumericalGraph(original, frozen *File, options Options) error {
+	graph := original.x86DirectTails
+	if graph == nil {
+		return nil
+	}
+	if graph.numerical != options.NumericalReads || !reflect.DeepEqual(x86DirectTailSnapshot(original), x86DirectTailSnapshot(frozen)) {
+		return x86DirectTailContext("frozen numerical graph lost its complete original source")
+	}
+	frozen.x86DirectTails = graph
+	for index := range frozen.Funcs {
+		frozen.Funcs[index].x86DirectTailRoot = original.Funcs[index].x86DirectTailRoot
+		frozen.Funcs[index].x86ResultFlowBudget = original.Funcs[index].x86ResultFlowBudget
+	}
+	return graph.verify(frozen, options)
+}
diff --git a/x86_direct_tail_numerical_emitter_test.go b/x86_direct_tail_numerical_emitter_test.go
new file mode 100644
index 000000000..63ac55599
--- /dev/null
+++ b/x86_direct_tail_numerical_emitter_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "testing"
+
+func TestX86DirectTailNumericalEmitterKeepsExactOriginalNode(t *testing.T) {
+	// A pure coordinate model; this cannot restore a live numerical binding.
+	makeEmitter := func() (*amd64Ctx, Instr, numericalSBReadFact) {
+		file, err := Parse(ArchAMD64, "TEXT ·entry(SB),4,$0-0\nJMP worker<>(SB)\nTEXT worker<>(SB),4,$0\nCMPB feature+7(SB),$1\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		binding := &GoX86NumericalReadBinding{}
+		ins := file.Funcs[1].Instrs[1]
+		ins.x86NumericalRead = &x86NumericalReadCertificate{binding: binding}
+		graph := &x86DirectTailGraph{original: file, numerical: binding, goarch: "amd64",
+			symbols: map[string]string{"·entry": "example.entry", "worker<>": "worker<>"}}
+		view := &x86DirectTailRoot{graph: graph, text: 0,
+			points: []x86DirectTailPoint{{text: 1, instruction: 1}}, instructions: []Instr{ins}}
+		graph.roots = map[string]*x86DirectTailRoot{"·entry": view}
+		return &amd64Ctx{directTail: view, goarch: "amd64", sig: FuncSig{Name: "example.entry"}}, ins,
+			numericalSBReadFact{Function: "worker<>", Instruction: 1, Original: file.Funcs[1].Instrs[1]}
+	}
+	c, ins, fact := makeEmitter()
+	if !c.numericalReadAtOriginalSource(ins, fact, 0, 0) {
+		t.Fatal("root emission lost the helper's exact original TEXT/instruction identity")
+	}
+	for _, kind := range []string{"root name", "helper name", "ordinal", "block", "instruction in block", "binding", "node cert", "Raw", "node opcode", "view root", "mode", "revoked"} {
+		t.Run(kind, func(t *testing.T) {
+			c, ins, fact := makeEmitter()
+			block, ordinal := 0, 0
+			switch kind {
+			case "root name":
+				c.sig.Name = "worker<>"
+			case "helper name":
+				fact.Function = "example.entry"
+			case "ordinal":
+				fact.Instruction++
+			case "block":
+				block++
+			case "instruction in block":
+				ordinal++
+			case "binding":
+				c.directTail.graph.numerical = &GoX86NumericalReadBinding{}
+			case "node cert":
+				ins.x86NumericalRead = &x86NumericalReadCertificate{binding: c.directTail.graph.numerical}
+			case "Raw":
+				ins.Raw += " changed"
+			case "node opcode":
+				ins.Op = "MOVB"
+			case "view root":
+				delete(c.directTail.graph.roots, "·entry")
+			case "mode":
+				c.goarch = "386"
+			case "revoked":
+				c.directTail.graph.revoked.Store(true)
+			}
+			if c.numericalReadAtOriginalSource(ins, fact, block, ordinal) {
+				t.Fatal("another original node, root, source or mode borrowed this read")
+			}
+		})
+	}
+	plain := &amd64Ctx{sig: FuncSig{Name: "worker<>"}}
+	if !plain.numericalReadAtOriginalSource(ins, fact, -1, -1) {
+		t.Fatal("ordinary emitter's exact function check changed")
+	}
+	plain.sig.Name = "example.entry"
+	if plain.numericalReadAtOriginalSource(ins, fact, -1, -1) {
+		t.Fatal("a standalone function borrowed helper identity without the source graph")
+	}
+}
diff --git a/x86_direct_tail_object_go127_test.go b/x86_direct_tail_object_go127_test.go
new file mode 100644
index 000000000..e8f91e403
--- /dev/null
+++ b/x86_direct_tail_object_go127_test.go
@@ -0,0 +1,42 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The live current-SDK observer intentionally has a current-Go schema. The
+// portable object/listing test also executes with Go1.20 and never asks this
+// decoder to reinterpret historical object/builtin evidence as current data.
+func TestX86DirectTailCurrentGoPhysicalObjects(t *testing.T) {
+	for _, target := range []struct{ arch, goos string }{
+		{"amd64", "linux"}, {"amd64", "darwin"}, {"amd64", "windows"},
+		{"386", "linux"}, {"386", "windows"},
+	} {
+		t.Run(target.goos+"/"+target.arch, func(t *testing.T) {
+			fixture := x86DirectTailRuntimeSources(target.arch)
+			data, root := x86DirectTailOriginalObject(t, target.arch, target.goos, fixture.assembly)
+			builtin, err := os.ReadFile(filepath.Join(root, "src", "cmd", "internal", "goobj", "builtinlist.go"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			records, err := gostaticstorage.ObserveX86AssemblyText(data, builtin, target.goos+"/"+target.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(records) != 23 {
+				t.Fatalf("original physical TEXT namespace lost records: %d", len(records))
+			}
+			for _, record := range records {
+				if len(record.Code) == 0 {
+					t.Fatal("missing original physical code", record.Name)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_direct_tail_object_test.go b/x86_direct_tail_object_test.go
new file mode 100644
index 000000000..d09123041
--- /dev/null
+++ b/x86_direct_tail_object_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86DirectTailOriginalObject(t *testing.T, arch, goos, source string) ([]byte, string) {
+	t.Helper()
+	root := strings.TrimSpace(string(x86FloatCompareCaptureCommand(t, exec.Command("go", "env", "GOROOT"))))
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "whole.s"), filepath.Join(dir, "whole.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	command := exec.Command("go", "tool", "asm", "-S", "-p", "bitview", "-I", filepath.Join(root, "pkg", "include"), "-o", object, input)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS="+goos, "GOARCH="+arch)
+	listing := string(x86FloatCompareCaptureCommand(t, command))
+	data, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Fourteen original typed roots and nine private TEXTs: seven bodies plus
+	// the original chain and diamond joins. Physical namespace/order remains
+	// exactly Go's; the consumer must not manufacture standalone helper ABIs.
+	headers := 0
+	for _, line := range strings.Split(listing, "\n") {
+		if strings.Contains(line, " STEXT ") {
+			headers++
+			if !strings.Contains(line, " size=") || strings.Contains(line, " size=0 ") {
+				t.Fatal("missing complete original Go code", line)
+			}
+		}
+	}
+	// Older official listings print the native relocation number; current
+	// listings print its name. Bind the numeric spelling to this exact SDK's
+	// generated enum assertion, not a current-schema decoder or guessed value.
+	enum, err := os.ReadFile(filepath.Join(root, "src", "cmd", "internal", "objabi", "reloctype_string.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	callType := regexp.MustCompile(`x\[R_CALL-([0-9]+)\]`).FindAllStringSubmatch(string(enum), -1)
+	if len(callType) != 1 {
+		t.Fatal("selected SDK lacks one exact R_CALL enum assertion")
+	}
+	relocations := strings.Count(listing, " t=R_CALL ") + strings.Count(listing, " t="+callType[0][1]+" ")
+	if len(data) == 0 || headers != 23 || relocations != 17 {
+		t.Fatalf("incomplete original object/listing: bytes=%d TEXTs=%d static-tail relocations=%d", len(data), headers, relocations)
+	}
+	return data, root
+}
+
+func TestX86DirectTailWholeSourceOriginalGoAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for the complete direct-tail source class")
+	}
+	for _, target := range []struct{ arch, goos, triple string }{
+		{"amd64", "linux", "x86_64-unknown-linux-gnu"},
+		{"amd64", "darwin", "x86_64-apple-darwin"},
+		{"amd64", "windows", "x86_64-pc-windows-msvc"},
+		{"386", "linux", "i386-unknown-linux-gnu"},
+		{"386", "windows", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.goos+"/"+target.arch, func(t *testing.T) {
+			fixture := x86DirectTailRuntimeSources(target.arch)
+			x86DirectTailOriginalObject(t, target.arch, target.goos, fixture.assembly)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, fixture.assembly, fixture.declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						dir := t.TempDir()
+						input, output := filepath.Join(dir, "whole.ll"), filepath.Join(dir, "whole.o")
+						if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+							t.Fatal(err)
+						}
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple,
+							"-filetype=obj", input, "-o", output))
+						if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+							t.Fatalf("missing complete LLVM object: %v", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_direct_tail_pc_test.go b/x86_direct_tail_pc_test.go
new file mode 100644
index 000000000..92c1768cf
--- /dev/null
+++ b/x86_direct_tail_pc_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86DirectTailPCRelativeSourceCoordinates(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, triple := "Q", "uint64", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, typ, triple = "L", "uint32", "i386-unknown-linux-gnu"
+		}
+		for _, branch := range []string{"JEQ 2(PC)", "JEQ $0, 2(PC)", "JEQ $1, 2(PC)", "JMP 2(PC)"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+branch+"/"+api, func(t *testing.T) {
+					width := 8
+					if arch == "386" {
+						width = 4
+					}
+					source := fmt.Sprintf(`TEXT ·First(SB),NOSPLIT,$0-%d
+ MOV%s a+0(FP),SI
+ CMP%s SI,$0
+ %s
+ MOV%s $9,SI
+middle:
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+ ADD%s $7,SI
+ MOV%s SI,ret+%d(FP)
+ RET
+`, width*2, word, word, branch, word, word, word, width)
+					pkg := mustGoPackage(t, "example.com/coordinates", "package p\nfunc First(a "+typ+") "+typ)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := testResolveSym(pkg.Path)
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+					var module llvm.Module
+					switch api {
+					case "text":
+						_, err = Translate(file, options)
+					case "module":
+						module, err = TranslateModule(file, options)
+					case "Go":
+						result, goErr := TranslateGoModule(pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: resolve})
+						err = goErr
+						if result != nil {
+							module = result.Module
+						}
+					}
+					if !module.IsNil() {
+						module.Dispose()
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailPCRelativeDoesNotGrantPCAddress(t *testing.T) {
+	for _, branch := range []string{
+		"JEQ -4(PC)", // Would land on TEXT, not a continuation instruction.
+		"JEQ 20(PC)", "JEQ 9223372036854775807(PC)",
+		"JEQ -9223372036854775808(PC)", "JEQ missing(PC)",
+		"JEQ 2(PC)(SI*1)", "JEQ $2, 2(PC)", "JEQ $1.0, 2(PC)",
+		"MOVQ 2(PC),AX", "LEAQ 2(PC),AX", "CALL 2(PC)",
+	} {
+		t.Run(branch, func(t *testing.T) {
+			file, options := x86DirectTailTestInputs(t)
+			file, err := Parse(ArchAMD64, strings.Replace(x86DirectTailTestASM, " JMP shared<>(SB)", " CMPQ SI,$0\n "+branch+"\n JMP shared<>(SB)", 1))
+			if err != nil {
+				return // The parser independently rejects an invalid source role.
+			}
+			_, err = PrepareX86DirectTailSource(file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unclosed PC role accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailPCRelativeOriginalTextBoundary(t *testing.T) {
+	file, err := Parse(ArchAMD64, `TEXT ·First(SB),NOSPLIT,$0-0
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+start:
+ NOP
+ JEQ 3(PC)
+alias:
+ PCDATA $0,$0
+ NOP
+last:
+ RET
+`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	graph := &x86DirectTailGraph{original: file, goarch: "amd64", helpers: map[string]bool{"body<>": true}}
+	view, err := graph.root(0, map[string]int{"·First": 0, "body<>": 1}, 4096, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for pc, ins := range view.instructions {
+		if ins.Op == "JEQ" {
+			target := view.edges[pc][1]
+			if view.instructions[target].Op != OpRET || view.points[target].text != 1 {
+				t.Fatalf("PC counted labels or lost PCDATA: target %+v", view.points[target])
+			}
+		}
+	}
+}
diff --git a/x86_direct_tail_result_address.go b/x86_direct_tail_result_address.go
new file mode 100644
index 000000000..8b8af29f4
--- /dev/null
+++ b/x86_direct_tail_result_address.go
@@ -0,0 +1,223 @@
+package plan9asm
+
+// A logical declared-field address is neither an incoming/native pointer nor
+// numerical bits. The field and its interior offset belong to this root's
+// actual scalar ABI0 layout; another root sharing a helper supplies nothing.
+type x86ResultSlotAddress struct {
+	start, end, offset int64
+	valid              bool
+}
+
+func x86DirectTailResultAddressTransfer(ins Instr, state *x86ResultState, owned []bool, resultOffset int64,
+	arch string, transfer x86ResultSourceTransfer, ordinal int) bool {
+	if len(state.resultAddressSlots) == 0 {
+		return transfer(ordinal, ins, state, owned, resultOffset, arch)
+	}
+	form := x86SourceMoveInstruction(ins, arch) // Dispatch copy, never source identity.
+	word := x86ResultPointerWord(arch)
+	move, lea := Op("MOVQ"), Op("LEAQ")
+	if arch == "386" {
+		move, lea = "MOVL", "LEAL"
+	}
+	address := func(arg Operand) x86ResultSlotAddress {
+		if arg.Kind == OpReg {
+			index, _, ok := x86ResultGP(arg.Reg, word, arch)
+			if ok {
+				return state.resultAddressGP[index]
+			}
+		}
+		return x86ResultSlotAddress{}
+	}
+	writeAddress := func(destination Operand, value x86ResultSlotAddress) bool {
+		if destination.Kind != OpReg {
+			return false
+		}
+		index, _, ok := x86ResultGP(destination.Reg, word, arch)
+		if !ok || !value.valid || arch == "amd64" && index == 14 {
+			return false
+		}
+		state.resultAddressGP[index] = value
+		state.gp[index], state.canonicalGP[index] = 0, 0
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		return true
+	}
+	if len(form.Args) == 2 {
+		first, last := form.Args[0], form.Args[1]
+		if form.Op == lea && first.Kind == OpFP {
+			if width, err := x86LEAOperandWidth(form, arch); err != nil || width != word {
+				return false
+			}
+			for _, slot := range state.resultAddressSlots {
+				if first.FPOffset >= slot.start && first.FPOffset < slot.end {
+					slot.offset = first.FPOffset
+					return writeAddress(last, slot)
+				}
+			}
+			return false // Parameters, padding and neighboring fields are not results.
+		}
+		if form.Op == move {
+			if value := address(first); value.valid {
+				return writeAddress(last, value)
+			}
+		}
+		if form.Op == lea && first.Kind == OpMem {
+			memory := first.Mem
+			if value := address(Operand{Kind: OpReg, Reg: memory.Base}); value.valid {
+				if _, err := x86LEAOperandWidth(form, arch); err != nil || !x86ResultSlotMemory(memory) ||
+					memory.Off < value.start-value.offset || memory.Off >= value.end-value.offset {
+					return false
+				}
+				value.offset += memory.Off
+				return writeAddress(last, value)
+			}
+		}
+	}
+
+	// Only registered scalar effects consume these logical bytes. The
+	// actual lowerer still emits the original source memory operand against
+	// boundFPAddress's real logical backing. No native-memory certificate follows.
+	local := ins
+	local.Args = append([]Operand(nil), ins.Args...)
+	usesSlot, writesSlot := false, false
+	for index, arg := range form.Args {
+		if arg.Kind != OpMem {
+			continue
+		}
+		value := address(Operand{Kind: OpReg, Reg: arg.Mem.Base})
+		if !value.valid && !state.shapeOnly {
+			continue
+		}
+		width := x86ResultSlotMoveBytes(form, arch)
+		if width == 0 || len(form.Args) != 2 || !x86ResultSlotMemory(arg.Mem) {
+			if value.valid {
+				return false
+			}
+			continue
+		}
+		if state.shapeOnly && !value.valid {
+			// Shape validation has no reaching alias. Its representative checks
+			// only the complete scalar form; the fixed point repeats exact field,
+			// offset, initialized bytes and alias checks on every reachable path.
+			for _, slot := range state.resultAddressSlots {
+				if slot.end-slot.start >= width {
+					value = slot
+					value.offset = slot.start
+					break
+				}
+			}
+		} else if arg.Mem.Off >= value.start-value.offset && arg.Mem.Off <= value.end-value.offset-width {
+			value.offset += arg.Mem.Off
+		} else {
+			return false
+		}
+		if !value.valid {
+			return false
+		}
+		local.Args[index] = Operand{Kind: OpFP, FPOffset: value.offset}
+		usesSlot, writesSlot = true, writesSlot || index == 1
+	}
+	if usesSlot {
+		before := state.resultAddressGP
+		writeBoundary := resultOffset
+		if state.logicalFrameParameters {
+			writeBoundary = 0 // Only independently owned numeric bytes in private parameter copies.
+		}
+		if !transfer(ordinal, local, state, owned, writeBoundary, arch) {
+			return false
+		}
+		x86ResultSlotRevokeOverwrites(local, state, before, arch)
+		state.resultAddressWritten = state.resultAddressWritten || writesSlot
+		return true
+	}
+	for index, arg := range form.Args {
+		if arg.Kind == OpMem {
+			if address(Operand{Kind: OpReg, Reg: arg.Mem.Index}).valid {
+				return false
+			}
+			if state.resultAddressWritten && arg.Mem.Sym == "" && form.Op != lea && !x86DirectTailPCBranch(form) {
+				return false // Fresh logical backing cannot hide a native alias read.
+			}
+		}
+		if value := address(arg); value.valid && !x86ResultSlotOverwrite(form, index, arch) {
+			return false // No comparison, numerical/vector transport or escape.
+		}
+	}
+	before := state.resultAddressGP
+	if !transfer(ordinal, ins, state, owned, resultOffset, arch) {
+		return false
+	}
+	x86ResultSlotRevokeOverwrites(ins, state, before, arch)
+	for index, arg := range form.Args {
+		if arg.Kind == OpFP && arg.FPOffset >= resultOffset {
+			state.resultAddressWritten = state.resultAddressWritten || x86ResultSlotDirectWrite(form, index, arch)
+		}
+	}
+	return true
+}
+
+func x86ResultSlotMoveBytes(ins Instr, arch string) int64 {
+	if form, known, err := x86SqrtProperties(ins, arch); known {
+		if err != nil || !form.legacy || !form.scalar || form.memory != 0 {
+			return 0
+		}
+		return int64(form.bits / 8) // Read-only scalar SQRT uses the same exact logical field.
+	}
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known {
+		if err != nil || form.mmx || form.spec.rawOnly || form.memory < 0 {
+			return 0
+		}
+		return int64(form.bits / 8) // Mode32 Q memory/X copies really are 8 bytes.
+	}
+	if form, known, err := amd64ScalarVectorMoveProperties(ins, arch); known {
+		if err != nil || !form.spec.legacy || form.mask >= 0 || form.memory < 0 {
+			return 0
+		}
+		return int64(form.spec.bits / 8)
+	}
+	width := x86RawReturnScalarMoveBytes(ins.Op)
+	if width == 8 && arch == "386" {
+		return 0 // Only the typed X/m64 branch above has a mode32 qword role.
+	}
+	return width
+}
+
+func x86ResultSlotDirectWrite(ins Instr, index int, arch string) bool {
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if operand.index == index && operand.write {
+				return true
+			}
+		}
+	}
+	_, write, known := x86InstructionMemoryShape(ins, index, arch)
+	return known && write
+}
+
+func x86ResultSlotRevokeOverwrites(ins Instr, state *x86ResultState, before [16]x86ResultSlotAddress, arch string) {
+	var live [16]bool
+	for index, value := range before {
+		live[index] = value.valid
+	}
+	live = x86ResultCallerAddressesAfter(ins, live, nil, arch)
+	for index := range before {
+		if !live[index] {
+			state.resultAddressGP[index] = x86ResultSlotAddress{}
+		}
+	}
+}
+
+func x86ResultSlotMemory(memory MemRef) bool {
+	return memory.Sym == "" && memory.OffRaw == "" && memory.Index == "" && memory.Scale == 0 &&
+		memory.Segment == "" && memory.IndexExt == "" && memory.Off == int64(int32(memory.Off))
+}
+
+func x86ResultSlotOverwrite(ins Instr, index int, arch string) bool {
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if operand.index == index {
+				return operand.write && !operand.read
+			}
+		}
+	}
+	return len(ins.Args) == 2 && index == 1 && x86RawReturnScalarMoveBytes(ins.Op) != 0
+}
diff --git a/x86_direct_tail_result_address_test.go b/x86_direct_tail_result_address_test.go
new file mode 100644
index 000000000..1ac003b19
--- /dev/null
+++ b/x86_direct_tail_result_address_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86DirectTailResultAddressFixture(arch, setup, body string) (string, string) {
+	word, typ, width := "Q", "uint64", 8
+	if arch == "386" {
+		word, typ, width = "L", "uint32", 4
+	}
+	source := fmt.Sprintf(`TEXT ·First(SB),NOSPLIT,$0-%d
+ MOV%s a+0(FP),SI
+ LEA%s ret+%d(FP),DI
+ %s
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+ %s
+ RET
+`, width*2, word, word, width, setup, body)
+	return strings.ReplaceAll(source, "WORD", word), "func First(a " + typ + ") " + typ + "\n"
+}
+
+func TestX86DirectTailResultAddressScalarWidthsAndPhysicalBanks(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, offset, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		registers := strings.Fields("AX CX DX BX SI DI R8 R9 R10 R11 R12 R13 R15")
+		if arch == "386" {
+			word, offset, triple = "L", 4, "i386-unknown-linux-gnu"
+			registers = strings.Fields("AX CX DX BX SI DI")
+		}
+		for _, register := range registers {
+			for _, result := range []struct {
+				typ, suffix string
+				width       int
+			}{
+				{"uint8", "B", 1}, {"uint16", "W", 2}, {"uint32", "L", 4},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+register+"/"+result.typ+"/"+api, func(t *testing.T) {
+						source := fmt.Sprintf(`TEXT ·First(SB),4,$0-%d
+ LEA%s ret+%d(FP),%s
+ JMP body<>(SB)
+TEXT body<>(SB),4,$0-0
+ MOV%s $7,(%s)
+ RET
+`, offset+result.width, word, offset, register, result.suffix, register)
+						declaration := "func First(a uint8) " + result.typ
+						if _, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil {
+							t.Fatal(err)
+						}
+					})
+				}
+			}
+		}
+		for _, address := range []string{"a+0(FP)", "padding+2(FP)", "ret+4095(FP)"} {
+			source, declarations := x86DirectTailResultAddressFixture(arch, "NOP", "MOVWORD SI,(DI)")
+			source = strings.ReplaceAll(source, fmt.Sprintf("ret+%d(FP)", offset), address)
+			if _, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("parameter/padding/unbound field acquired an address", address, err)
+			}
+		}
+		if arch == "amd64" {
+			source, declarations := x86DirectTailResultAddressFixture(arch, "LEAQ ret+8(FP),R14", "MOVQ SI,(R14)")
+			if _, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("logical result address acquired Go hidden-register role", err)
+			}
+		}
+	}
+}
+
+func TestX86DirectTailResultAddressOwnTypedStorage(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, test := range []struct{ name, setup, body string }{
+			{"direct", "NOP", "MOVWORD SI,(DI)"},
+			{"copy", "MOVWORD DI,BX", "MOVWORD SI,(BX)"},
+			{"overlap_copy", "MOVWORD DI,BX\n MOVWORD BX,DI", "MOVWORD SI,(DI)"},
+			{"same_slot_LEA", "LEAWORD 1(DI),BX\n LEAWORD -1(BX),BX", "MOVWORD SI,(BX)"},
+			{"same_identity_join", "CMPWORD SI,$0\n JEQ alternate\n MOVWORD DI,BX\n JMP join\nalternate:\n LEAWORD 0(DI),BX\njoin:", "MOVWORD SI,(BX)"},
+			{"write_then_read", "NOP", "MOVWORD SI,(DI)\n MOVWORD (DI),AX\n MOVWORD AX,(DI)"},
+			{"write_then_source_PC", "NOP", "MOVWORD SI,(DI)\n CMPWORD SI,$0\n JEQ 2(PC)\n MOVWORD SI,(DI)"},
+			{"overwritten_address", "MOVWORD $5,DI", "MOVWORD DI,ret+RESULT(FP)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.arch+"/"+target.triple+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, declarations := x86DirectTailResultAddressFixture(target.arch, test.setup, test.body)
+					width := "8"
+					if target.arch == "386" {
+						width = "4"
+					}
+					source = strings.ReplaceAll(source, "RESULT", width)
+					if _, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailResultAddressDoesNotGrantOtherStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, test := range []struct{ name, setup, body string }{
+			{"undefined_value", "NOP", "MOVWORD AX,(DI)"},
+			{"undefined_result_read", "NOP", "MOVWORD (DI),SI\n MOVWORD SI,(DI)"},
+			{"load_overwrites_alias", "NOP", "MOVWORD SI,(DI)\n MOVWORD (DI),DI\n MOVWORD $7,(DI)"},
+			{"parameter_address", "LEAWORD a+0(FP),DI", "MOVWORD SI,(DI)"},
+			{"result_one_past", "LEAWORD ret+RESULT(FP),DI\n LEAWORD 8(DI),DI", "MOVWORD SI,(DI)"},
+			{"out_of_bounds", "NOP", "MOVWORD SI,1(DI)"},
+			{"negative_offset", "NOP", "MOVWORD SI,-1(DI)"},
+			{"overflow_offset", "NOP", "MOVWORD SI,9223372036854775807(DI)"},
+			{"dynamic_index", "MOVWORD $0,CX", "MOVWORD SI,(DI)(CX*1)"},
+			{"lost_copy", "MOVB DI,BL", "MOVWORD SI,(BX)"},
+			{"different_offset_join", "CMPWORD SI,$0\n JEQ alternate\n MOVWORD DI,BX\n JMP join\nalternate:\n LEAWORD 1(DI),BX\njoin:", "MOVWORD SI,(BX)"},
+			{"address_NUM_result", "NOP", "MOVWORD DI,ret+RESULT(FP)"},
+			{"address_vector", "MOVL DI,X0", "MOVWORD SI,(DI)"},
+			{"address_compare", "CMPWORD DI,$0", "MOVWORD SI,(DI)"},
+			{"address_escaped_input", "MOVWORD DI,a+0(FP)", "MOVWORD SI,(DI)"},
+			{"address_escaped_native", "MOVWORD $0,BX", "MOVWORD DI,(BX)\n MOVWORD SI,(DI)"},
+			{"cross_field_LEA", "LEAWORD 8(DI),DI", "MOVWORD SI,(DI)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, declarations := x86DirectTailResultAddressFixture(arch, test.setup, test.body)
+					width := "8"
+					if arch == "386" {
+						width = "4"
+					}
+					source = strings.ReplaceAll(source, "RESULT", width)
+					_, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unclosed result-address role: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailResultAddressNativeAliasOrdering(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, width, typ, triple := "Q", 8, "uint64", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, width, typ, triple = "L", 4, "uint32", "i386-unknown-linux-gnu"
+		}
+		for _, after := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/after_write_%t/%s", arch, after, api), func(t *testing.T) {
+					load, store := " MOVL (BX),AX\n", " MOVWORD SI,(DI)\n"
+					body := load + store
+					if after {
+						body = store + load
+					}
+					source := fmt.Sprintf(`TEXT ·First(SB),NOSPLIT,$0-%d
+ MOV%s p+0(FP),BX
+ MOV%s a+%d(FP),SI
+ LEA%s ret+%d(FP),DI
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+%s RET
+`, width*3, word, word, width, word, width*2, strings.ReplaceAll(body, "WORD", word))
+					declarations := "func First(p *uint32,a " + typ + ") " + typ
+					_, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+					if after && !errors.Is(err, ErrProbeNeedsContext) || !after && err != nil {
+						t.Fatalf("native read ordering after=%t: %v", after, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_direct_tail_result_region.go b/x86_direct_tail_result_region.go
new file mode 100644
index 000000000..ce3b902da
--- /dev/null
+++ b/x86_direct_tail_result_region.go
@@ -0,0 +1,45 @@
+package plan9asm
+
+import "fmt"
+
+// Only a separately closed direct-tail graph may group these logical result
+// fields. This layout query grants no initialization or source permission;
+// the complete graph/byte proof must succeed before the emitter uses it.
+// Contiguous numeric fields get matching backing, never parameter bytes,
+// pointers, bools, padding or a neighboring allocation.
+func x86DirectTailResultRegion(fn Func, sig FuncSig, arch string) (x86ResultSlotAddress, bool) {
+	if fn.x86DirectTailRoot == nil || arch != "amd64" && arch != "386" ||
+		len(sig.Frame.Results) < 2 || len(sig.Frame.Results) > 4096 {
+		return x86ResultSlotAddress{}, false
+	}
+	fields, valid := parseLiteralStructFields(sig.Ret)
+	if !valid || len(fields) != len(sig.Frame.Results) {
+		return x86ResultSlotAddress{}, false
+	}
+	start := sig.Frame.Results[0].Offset
+	end := start
+	for index, slot := range sig.Frame.Results {
+		width := x86ResultScalarBytes(slot.Type, arch)
+		if !x86IntegerResultSlot(slot) || slot.Type != fields[index] || slot.Index != index ||
+			slot.Field != -1 || len(slot.Fields) != 0 || slot.Offset != end ||
+			width <= 0 || slot.Offset < 0 || slot.Offset > 4096-width || (slot.Offset-start)%width != 0 {
+			return x86ResultSlotAddress{}, false
+		}
+		end += width
+	}
+	return x86ResultSlotAddress{start: start, end: end, offset: start, valid: true}, true
+}
+
+func (c *amd64Ctx) emitDirectTailResultRegion(region x86ResultSlotAddress) {
+	width := region.end - region.start
+	name := "%fp_result_region"
+	fmt.Fprintf(c.b, "  %s = alloca [%d x i8], align 8\n", name, width)
+	for _, slot := range c.fpResults {
+		pointer := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = getelementptr inbounds [%d x i8], ptr %s, i32 0, i64 %d\n",
+			pointer, width, name, slot.Offset-region.start)
+		c.fpResAllocaIdx[slot.Index] = "%" + pointer
+		c.fpResAllocaOff[slot.Offset] = "%" + pointer
+		c.storeFPStorage(slot.Type, llvmZeroValue(slot.Type), "%"+pointer, ", align 1", "")
+	}
+}
diff --git a/x86_direct_tail_result_region_test.go b/x86_direct_tail_result_region_test.go
new file mode 100644
index 000000000..968d48f63
--- /dev/null
+++ b/x86_direct_tail_result_region_test.go
@@ -0,0 +1,332 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86DirectTailResultRegionFixture(arch, typ, suffix string, width int) (string, string) {
+	lea := "LEAQ"
+	if arch == "386" {
+		lea = "LEAL"
+	}
+	store := fmt.Sprintf("MOV%s $7,(DI)\nMOV%s $9,%d(DI)", suffix, suffix, width)
+	if width == 8 {
+		// The original mode32 MOVQ memory/X form remains eight bytes.
+		store = "MOVL $7,AX\nMOVL AX,X0\nMOVQ X0,(DI)\n" +
+			"MOVL $9,AX\nMOVL AX,X0\nMOVQ X0,8(DI)"
+	}
+	source := fmt.Sprintf("TEXT ·First(SB),4,$0-%d\n%s first+0(FP),DI\nJMP body<>(SB)\n"+
+		"TEXT body<>(SB),4,$0-0\n%s\nRET\n", 2*width, lea, store)
+	return source, "func First() (first,second " + typ + ")\n"
+}
+
+func TestX86DirectTailContiguousResultRegionThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, width := range []struct {
+			typ, suffix string
+			bytes       int
+		}{{"uint8", "B", 1}, {"uint16", "W", 2}, {"uint32", "L", 4}, {"uint64", "Q", 8}} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+width.typ+"/"+api, func(t *testing.T) {
+					source, declaration := x86DirectTailResultRegionFixture(target.arch, width.typ, width.suffix, width.bytes)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete numerical result fields lack their actual shared backing", err)
+					}
+					if target.arch == "amd64" && !strings.Contains(ir, "alloca ["+fmt.Sprint(2*width.bytes)+" x i8]") {
+						t.Fatal("cross-field result alias did not receive actual contiguous backing")
+					}
+					optimized := x86UndefinedTrapOptimizedIR(t, ir)
+					typ := fmt.Sprintf("i%d", 8*width.bytes)
+					if strings.Contains(optimized, ", "+typ+" 0, 1") {
+						t.Fatal("second result used its zero return-register fallback instead of regional backing")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailResultRegionPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	var source, declarations, wrappers, checks strings.Builder
+	for _, row := range []struct {
+		typ, suffix string
+		width       int
+	}{{"uint8", "B", 1}, {"uint16", "W", 2}, {"uint32", "L", 4}, {"uint64", "Q", 8}} {
+		name := fmt.Sprintf("Region%d", row.width)
+		body, declaration := x86DirectTailResultRegionFixture("amd64", row.typ, row.suffix, row.width)
+		body = strings.ReplaceAll(strings.ReplaceAll(body, "First", name), "body<>", "body"+name+"<>")
+		source.WriteString(body)
+		declarations.WriteString(strings.ReplaceAll(declaration, "First", name))
+		typ := fmt.Sprintf("i%d", 8*row.width)
+		for index := 0; index < 2; index++ {
+			shim := fmt.Sprintf("%sField%d", name, index)
+			fmt.Fprintf(&wrappers, "define i64 @%s() {\n %%pair = call { %s, %s } @%s()\n %%field = extractvalue { %s, %s } %%pair, %d\n",
+				shim, typ, typ, name, typ, typ, index)
+			if row.width < 8 {
+				fmt.Fprintf(&wrappers, " %%wide = zext %s %%field to i64\n ret i64 %%wide\n}\n", typ)
+			} else {
+				wrappers.WriteString(" ret i64 %field\n}\n")
+			}
+			fmt.Fprintf(&checks, "extern uint64_t %s(void);\n", shim)
+		}
+	}
+	// These are virtual numerical/storage semantics on the actual host LLVM
+	// target, not native x86/Go execution or a C aggregate-return ABI claim.
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal(err)
+	}
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + checks.String() + "int main(void) {\n"
+	for _, width := range []int{1, 2, 4, 8} {
+		main += fmt.Sprintf("if (Region%dField0()!=7 || Region%dField1()!=9) { fprintf(stderr, \"result region%d values\\n\"); return 1; }\n", width, width, width)
+	}
+	main += "return 0;\n}\n"
+	for _, optimized := range []bool{false, true} {
+		input := ir + wrappers.String()
+		if optimized {
+			input = x86UndefinedTrapOptimizedIR(t, input)
+		}
+		for _, level := range []int{0, 2} {
+			t.Run(fmt.Sprintf("IR_O2=%t/backendO%d", optimized, level), func(t *testing.T) {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang},
+					"result-region-portable", triple, input, main, nil, level)
+			})
+		}
+	}
+}
+
+func TestX86DirectTailResultRegionFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete result-region objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			for _, row := range []struct {
+				typ, suffix string
+				width       int
+			}{{"uint8", "B", 1}, {"uint16", "W", 2}, {"uint32", "L", 4}, {"uint64", "Q", 8}} {
+				name := fmt.Sprintf("Region%d", row.width)
+				source, declaration := x86DirectTailResultRegionFixture(target.arch, row.typ, row.suffix, row.width)
+				assembly.WriteString(strings.ReplaceAll(strings.ReplaceAll(source, "First", name), "body<>", "body"+name+"<>"))
+				declarations.WriteString(strings.ReplaceAll(declaration, "First", name))
+			}
+			// Four roots and four private helpers are the complete width family.
+			if strings.Count(assembly.String(), "TEXT ") != 8 {
+				t.Fatal("original result-region source inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != 4 {
+						t.Fatal("complete numerical result-region source failed", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86DirectTailResultRegionDoesNotInventOwnedBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ name, from, to string }{
+			{"missing-first", "MOVL $7,(DI)", "NOP"},
+			{"missing-second", "MOVL $9,4(DI)", "NOP"},
+			{"partial-second", "MOVL $9,4(DI)", "MOVB $9,4(DI)"},
+			{"read-before-write", "MOVL $7,(DI)", "MOVL 4(DI),AX\nMOVL $7,(DI)"},
+			{"past-region", "MOVL $9,4(DI)", "MOVL $9,8(DI)"},
+			{"before-region", "MOVL $9,4(DI)", "MOVL $9,-4(DI)"},
+			{"dynamic-index", "MOVL $9,4(DI)", "MOVL $0,CX\nMOVL $9,(DI)(CX*4)"},
+			{"source-extent", "$0-8", "$0-1"},
+			{"address-escape", "MOVL $9,4(DI)", "MOVL DI,(BX)\nMOVL $9,4(DI)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					source, declaration := x86DirectTailResultRegionFixture(arch, "uint32", "L", 4)
+					if strings.Count(source, row.from) != 1 {
+						t.Fatal("mutation not bound to one complete source role")
+					}
+					source = strings.Replace(source, row.from, row.to, 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, testTargetTriple("linux", arch), api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("region acquired missing storage/effects: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailResultRegionLayoutIsNotAuthority(t *testing.T) {
+	makeRole := func() (Func, FuncSig) {
+		return Func{x86DirectTailRoot: &x86DirectTailRoot{}}, FuncSig{
+			Ret: "{ i32, i32 }",
+			Frame: FrameLayout{Results: []FrameSlot{
+				{Offset: 8, Type: I32, Index: 0, Field: -1},
+				{Offset: 12, Type: I32, Index: 1, Field: -1},
+			}},
+		}
+	}
+	for _, row := range []struct {
+		name   string
+		change func(*Func, *FuncSig)
+	}{
+		{"no-graph", func(fn *Func, _ *FuncSig) { fn.x86DirectTailRoot = nil }},
+		{"pointer", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Type = Ptr }},
+		{"bool", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Type = I1 }},
+		{"floating", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Type = "float" }},
+		{"index", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Index = 0 }},
+		{"field", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Field = 0 }},
+		{"field-path", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Fields = []int{0} }},
+		{"gap", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Offset++ }},
+		{"overlap", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Offset-- }},
+		{"negative", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Offset = -4 }},
+		{"overflow", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Offset = 4096 }},
+		{"return-type", func(_ *Func, sig *FuncSig) { sig.Ret = "{ i16, i64 }" }},
+		{"unaligned-relative-field", func(_ *Func, sig *FuncSig) {
+			sig.Ret = "{ i8, i64 }"
+			sig.Frame.Results[0].Type, sig.Frame.Results[0].Offset = I8, 0
+			sig.Frame.Results[1].Type, sig.Frame.Results[1].Offset = I64, 1
+		}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			fn, sig := makeRole()
+			row.change(&fn, &sig)
+			if _, valid := x86DirectTailResultRegion(fn, sig, "amd64"); valid {
+				t.Fatal("a different layout borrowed a contiguous result region")
+			}
+		})
+	}
+	fn, sig := makeRole()
+	region, valid := x86DirectTailResultRegion(fn, sig, "amd64")
+	if !valid || region.start != 8 || region.end != 16 {
+		t.Fatal("exact two-field numerical layout lost its nonzero start")
+	}
+	// A layout and a copied private graph pointer alone cannot create backing.
+	// Production must first consume the complete live source-byte proof.
+	var output strings.Builder
+	context := newX86Ctx(&output, fn, sig, func(s string) string { return s }, nil,
+		"amd64", "x86_64-unknown-linux-gnu", false)
+	if err := context.emitEntryAllocas(); !errors.Is(err, ErrProbeNeedsContext) || strings.Contains(output.String(), "%fp_result_region =") {
+		t.Fatalf("unproved shape allocated result backing: %v", err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/no-FP/"+api, func(t *testing.T) {
+				// Even a fully numerical register state is not a write to the
+				// declared results. No FP instruction triggers a narrower guard.
+				source := "TEXT ·First(SB),4,$0-8\nJMP body<>(SB)\n" +
+					"TEXT body<>(SB),4,$0-0\nMOVL $7,AX\nMOVL $9,BX\nRET\n"
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func First() (a,b uint32)\n", arch, testTargetTriple("linux", arch), api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("register fallback invented logical result writes: %v", err)
+				}
+			})
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("386/invalid-X8/"+api, func(t *testing.T) {
+			source, declaration := x86DirectTailResultRegionFixture("386", "uint32", "L", 4)
+			source = strings.Replace(source, "MOVL $7,(DI)", "MOVL $7,AX\nMOVL AX,X8\nMOVL X8,(DI)", 1)
+			if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", testTargetTriple("linux", "386"), api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("region borrowed a mode64-only vector bank: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailResultRegionRootsAndKeepFuncStayIndependent(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		lea := "LEAQ"
+		if arch == "386" {
+			lea = "LEAL"
+		}
+		for _, variant := range []struct {
+			api  string
+			keep bool
+		}{{"text", false}, {"module", false}, {"Go", false}, {"Go", true}} {
+			api, keep := variant.api, variant.keep
+			for _, missing := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/keep%t/missing%t/%s", arch, keep, missing, api), func(t *testing.T) {
+					declaration := "func First() (a,b uint32)\nfunc Second(prefix uint64) (a,b uint32)\n"
+					header := 16
+					if missing {
+						declaration = strings.Replace(declaration, "Second(prefix uint64) (a,b uint32)", "Second(prefix uint64) (a,b,c uint32)", 1)
+						header = 20
+					}
+					source := fmt.Sprintf("TEXT ·First(SB),4,$0-8\n%s a+0(FP),DI\nJMP shared<>(SB)\n"+
+						"TEXT ·Second(SB),4,$0-%d\n%s a+8(FP),DI\nJMP shared<>(SB)\n"+
+						"TEXT shared<>(SB),4,$0-0\nMOVL $7,(DI)\nMOVL $9,4(DI)\nRET\n", lea, header, lea)
+					pkg := mustGoPackage(t, "regions", "package regions\n"+declaration)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var filter func(string, string) bool
+					if keep {
+						filter = func(original, _ string) bool { return original == "·First" }
+					}
+					options := Options{Goarch: arch, TargetTriple: testTargetTriple("linux", arch), Sigs: sigs, ResolveSym: resolve}
+					context := llvm.NewContext()
+					defer context.Dispose()
+					var ir string
+					switch api {
+					case "text":
+						ir, err = Translate(file, options)
+					case "module":
+						var module llvm.Module
+						module, err = TranslateModuleInContext(context, file, options)
+						if !module.IsNil() {
+							defer module.Dispose()
+							ir = module.String()
+						}
+					case "Go":
+						module, moduleErr := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+							GOARCH: arch, TargetTriple: options.TargetTriple, ResolveSym: resolve, KeepFunc: filter,
+						})
+						err = moduleErr
+						if module != nil && !module.Module.IsNil() {
+							defer module.Module.Dispose()
+							ir = module.Module.String()
+						}
+					}
+					if missing {
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("one root/filter borrowed another result extent: %v", err)
+						}
+					} else if err != nil || strings.Count(ir, "define ") != 2-x86FloatAddSubBoolInt(keep) {
+						t.Fatalf("independent shared-helper roots lost their own storage: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_direct_tail_runtime_linux_amd64_test.go b/x86_direct_tail_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..816a7d1ad
--- /dev/null
+++ b/x86_direct_tail_runtime_linux_amd64_test.go
@@ -0,0 +1,103 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This owner executes the complete ordinary Go ABI0 file, not hand-replayed
+// registers or a zero-argument helper ABI. Other hosts retain the portable
+// source/identity tests; no skip counts as runtime evidence.
+func TestCrossLinuxRuntimeMatrixAMD64DirectTailWholeSourceOriginalGoAndLLVM(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native Linux AMD64 direct-tail owner requires LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	fixture := x86DirectTailRuntimeSources("amd64")
+	goDriver := `package main
+import "fmt"
+` + fixture.declarations + `
+func reference(row int,a,b uint64) uint64 {
+ switch row {
+ case 2: if a==b {return 1}; return 0
+ case 3: result:=a+b; if a<b {result++}; return result
+ case 4: return uint64(uint32(a))+b
+ case 6: if a==b {return a+b+5}; return a+b+3
+ }
+ return a+b
+}
+//go:noinline
+func snapshot(p *[4]uint64) [4]uint64 {return *p}
+func main() {
+ values:=[]uint64{0,1,7,8,0xffffffff,0x100000000,0x8000000000000000,0xffffffffffffffff}
+ canaries:=[4]uint64{0x1122334455667788,0xaabbccddeeff0099,0x9876543210abcdef,0xfedcba9876543210}
+ before:=snapshot(&canaries)
+ calls:=0
+ for _,a:=range values {
+` + fixture.goCalls + `
+  if snapshot(&canaries)!=before {panic("original Go caller canaries changed")}
+ }
+ fmt.Printf("whole direct-tail original/LLVM: %d independent value checks\n",calls)
+}
+`
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module directtail\n\ngo 1.20\n", "main.go": goDriver, "tail_amd64.s": fixture.assembly,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original")
+	command := exec.Command("go", "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	want := "whole direct-tail original/LLVM: 504 independent value checks\n"
+	if output := execution.run(t, original); string(output) != want {
+		t.Fatalf("incomplete actual original Go execution: %s", output)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + fixture.prototypes + `
+static uint64_t reference(unsigned row,uint64_t a,uint64_t b) {
+    if(row==2) return a==b;
+    if(row==3) return a+b+(a<b);
+    if(row==4) return (uint32_t)a+b;
+    if(row==6) return a+b+(a==b?5:3);
+    return a+b;
+}
+int main(void) {
+    const uint64_t values[]={0,1,7,8,UINT64_C(0xffffffff),UINT64_C(0x100000000),UINT64_C(0x8000000000000000),UINT64_MAX};
+    volatile uint64_t canaries[]={UINT64_C(0x1122334455667788),UINT64_C(0x9876543210abcdef)};
+    unsigned calls=0;
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint64_t a=values[i];
+` + fixture.cCalls + `
+        if(canaries[0]!=UINT64_C(0x1122334455667788)||canaries[1]!=UINT64_C(0x9876543210abcdef)) return 1;
+    }
+    printf("whole direct-tail original/LLVM: %u independent value checks\n",calls);
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, fixture.assembly, fixture.declarations, "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, level := range []string{"-O0", "-O2"} {
+			output := execution.compileAndRunLLVM(t, "whole-direct-tail", ir, driver, level)
+			if string(output) != want {
+				t.Fatalf("%s/%s incomplete LLVM execution: %s", api, level, output)
+			}
+			t.Log(api, level, strings.TrimSpace(string(output)))
+		}
+	}
+}
diff --git a/x86_direct_tail_source.go b/x86_direct_tail_source.go
new file mode 100644
index 000000000..3851f5fc6
--- /dev/null
+++ b/x86_direct_tail_source.go
@@ -0,0 +1,490 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"sync/atomic"
+)
+
+// A node keeps the original source coordinates. A continuation is neither a
+// callable function nor a new entry/closure/frame/register capability.
+type x86DirectTailPoint struct {
+	text, instruction int
+}
+
+type x86DirectTailGraph struct {
+	origin          *File
+	original        *File
+	goarch          string
+	revoked         atomic.Bool
+	signatures      map[string]FuncSig
+	symbols         map[string]string
+	externalSymbols map[string]string
+	helpers         map[string]bool
+	roots           map[string]*x86DirectTailRoot
+	texts           map[string]int // Immutable original TEXT lookup; no expanded views.
+	numerical       *GoX86NumericalReadBinding
+	fixedLocal      *x86FixedLocalBinding
+	goPackage       *GoPackage // Same request source, never supplied through public signatures.
+}
+
+type x86DirectTailRoot struct {
+	graph         *x86DirectTailGraph
+	text          int
+	points        []x86DirectTailPoint
+	instructions  []Instr
+	ordinals      []int
+	edges         [][]int
+	externalTails []bool // Exact ordinary typed terminals, never helper ABIs.
+}
+
+func x86DirectTailContext(format string, args ...any) error {
+	return fmt.Errorf("%w: x86 direct-tail source: %s", ErrProbeNeedsContext, fmt.Sprintf(format, args...))
+}
+
+func x86DirectTailSnapshot(file *File) *File {
+	copy := arm64ScratchFileSnapshot(file)
+	copy.x86DirectTails = nil
+	for i := range copy.Funcs {
+		copy.Funcs[i].x86DirectTailRoot = nil
+		copy.Funcs[i].x86ResultFlowBudget = nil
+		copy.Funcs[i].x86BoolCalls = nil
+		copy.Funcs[i].x86BoolReadonlyInputs = false
+		for ordinal := range copy.Funcs[i].Instrs {
+			copy.Funcs[i].Instrs[ordinal] = x86DirectTailInstructionSnapshot(copy.Funcs[i].Instrs[ordinal])
+		}
+	}
+	return copy
+}
+
+// A cost predicate, never a source/entry/state permission. Private source CALL
+// and tail edges share this graph; native/raw calls keep their own consumers.
+func x86DirectTailSourceNeeded(file *File) bool {
+	if file == nil || file.Arch != ArchAMD64 {
+		return false
+	}
+	for _, fn := range file.Funcs {
+		_, pure := x86OrdinaryExternalTailTarget(fn)
+		if pure || x86DirectTailRootNeeded(fn) {
+			return true
+		}
+	}
+	return false
+}
+
+func x86DirectTailRootNeeded(fn Func) bool {
+	return x86DirectTailRootNeededExceptCalls(fn, nil)
+}
+
+func x86DirectTailRootNeededExceptCalls(fn Func, ordinary map[string]bool) bool {
+	return x86DirectTailRootTargets(fn, nil, ordinary)
+}
+
+func x86DirectTailRootTargets(fn Func, helpers, ordinary map[string]bool) bool {
+	for _, ins := range fn.Instrs {
+		if ins.Op != OpJMP && ins.Op != OpCALL || len(ins.Args) != 1 {
+			continue
+		}
+		arg := ins.Args[0]
+		text := arg.Sym
+		if arg.Kind == OpMem {
+			text = arg.Mem.Sym
+		}
+		base, offset, valid := parseSBRef(strings.TrimPrefix(text, "$"))
+		if valid && (helpers == nil && strings.HasSuffix(base, "<>") || helpers[base]) {
+			if ins.Op == OpCALL && arg.Kind == OpSym && offset == 0 && ordinary[base] {
+				continue
+			}
+			return true
+		}
+	}
+	return false
+}
+
+// Routing only: the existing graph must independently close the declaration,
+// exact incoming/result ABI0 roles, source identity and external terminal.
+func x86OrdinaryExternalTailTarget(fn Func) (string, bool) {
+	if fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 ||
+		len(fn.Instrs) != 2 || fn.Instrs[0].Op != OpTEXT {
+		return "", false
+	}
+	jump := fn.Instrs[1]
+	if jump.Op != OpJMP || len(jump.Args) != 1 || jump.Args[0].Kind != OpSym {
+		return "", false
+	}
+	name, offset, valid := parseSBRef(jump.Args[0].Sym)
+	return name, valid && offset == 0 && !strings.HasPrefix(name, "·") && !strings.ContainsAny(name, "<*")
+}
+
+// PrepareX86DirectTailSource audits the complete source before any root filter
+// or module partition. Only request-local copies receive its private graph.
+// The existing actual root signature supplies its logical state/RET contract;
+// a helper signature, zero arguments or matching returns supplies nothing.
+// Private CALL additionally requires a closed helper prologue/return context.
+// Native raw/stack/closure/entry and numerical-source composition stay separate.
+func PrepareX86DirectTailSource(file *File, options Options) (*File, error) {
+	if file == nil {
+		return file, nil
+	}
+	if prepared, handled, err := prepareX86FixedLocalLeafSource(file, options); handled {
+		return prepared, err
+	}
+	calls := options.x86BoolCallSource
+	if calls == nil {
+		var err error
+		calls, err = prepareX86ABI0BoolCalls(file, options)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if calls != nil {
+		owned, err := calls.ownsCustomRegisterTails(file, options)
+		if err != nil || owned {
+			return file, err // Complete canonical graph proof; retain the actual custom calls.
+		}
+	}
+	if file.x86DirectTails != nil {
+		if err := file.x86DirectTails.verify(file, options); err != nil {
+			return nil, err
+		}
+		return file, nil
+	}
+	if file.Arch != ArchAMD64 || len(options.X86TailGroups) != 0 {
+		return file, nil
+	}
+	if !x86DirectTailSourceNeeded(file) {
+		return file, nil
+	}
+	goarch := options.Goarch
+	if goarch == "" {
+		goarch = "amd64"
+	}
+	if goarch != "amd64" && goarch != "386" {
+		return nil, x86DirectTailContext("source graph has no registered x86 mode")
+	}
+	helpers := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		if strings.HasSuffix(fn.Sym, "<>") {
+			helpers[fn.Sym] = true
+		}
+	}
+	pureTail, privateTail := false, false
+	for _, fn := range file.Funcs {
+		_, pure := x86OrdinaryExternalTailTarget(fn)
+		if calls != nil {
+			if plan := calls.callers[fn.Sym]; plan != nil && plan.tail != nil {
+				pure = false // Already checked by the independent canonical bool consumer.
+			}
+		}
+		pureTail = pureTail || pure
+		privateTail = privateTail || x86DirectTailRootNeeded(fn)
+	}
+	if !pureTail && !privateTail {
+		return file, nil // Canonical bool terminals retain their independent consumer.
+	}
+	if len(helpers) == 0 && !pureTail {
+		return nil, x86DirectTailContext("private tail target has no original source TEXT")
+	}
+	if options.X86TLSMoves != nil || options.ARM64ByteCarrierSource != nil ||
+		len(file.UnlinkedPrelude) != 0 || len(file.x86Continuations) != 0 {
+		return nil, x86DirectTailContext("source/native binding needs its independent complete node association")
+	}
+	request, err := x86DirectTailNumericalRequest(file, options)
+	if err != nil {
+		return nil, err
+	}
+	graph, byName, err := newX86DirectTailGraph(file, options, helpers, goarch)
+	if err != nil {
+		return nil, err
+	}
+	ordinary := graph.ordinaryABI0Calls()
+	for helper := range ordinary {
+		delete(helpers, helper)
+	}
+	signatures, resolve := graph.signatures, options.ResolveSym
+	if resolve == nil {
+		resolve = func(symbol string) string { return symbol }
+	}
+	reached := make(map[string]bool)
+	combined := 0
+	for index, fn := range graph.original.Funcs {
+		_, pure := x86OrdinaryExternalTailTarget(fn)
+		pure = pure && !x86ABI0BoolResultNeedsProof(signatures[graph.symbols[fn.Sym]], goarch)
+		if helpers[fn.Sym] || !pure && !x86DirectTailRootNeededExceptCalls(fn, ordinary) {
+			continue
+		}
+		view, err := graph.root(index, byName, 4096-combined, true)
+		if err != nil {
+			return nil, err
+		}
+		if len(view.points) == len(x86DirectTailInstructions(fn)) && !pure {
+			continue // This entry has no edge into the private helper graph.
+		}
+		combined += len(view.points)
+		if combined > 4096 {
+			return nil, x86DirectTailContext("combined source/continuation instruction budget exhausted")
+		}
+		for _, point := range view.points {
+			reached[graph.original.Funcs[point.text].Sym] = true
+		}
+		graph.roots[fn.Sym] = view
+	}
+	for helper := range helpers {
+		if !reached[helper] {
+			return nil, x86DirectTailContext("private helper lacks a closed typed root: %s", helper)
+		}
+	}
+	request.x86DirectTails = graph
+	if err := graph.joinNumericalNodes(request); err != nil {
+		return nil, err
+	}
+	budget := &x86ResultFlowBudget{}
+	for _, view := range graph.roots {
+		fn := graph.original.Funcs[view.text]
+		sig, present := signatures[graph.symbols[fn.Sym]]
+		if !present || sig.Name != "" && sig.Name != graph.symbols[fn.Sym] {
+			return nil, x86DirectTailContext("root lacks its complete typed signature: %s", fn.Sym)
+		}
+		fn.x86DirectTailRoot = view // Local proof view, never the user's Func.
+		fn.x86ResultFlowBudget = budget
+		if x86DirectTailSigNeedsOwnBoolFrame(sig, fn, goarch) {
+			return nil, x86DirectTailContext("ABI0 bool byte needs its independent canonical frame contract")
+		}
+		c := newX86Ctx(new(strings.Builder), fn, sig, resolve, signatures, goarch, options.TargetTriple, false)
+		c.fpScalarData = x86LoweredScalarDataReads(graph.original, resolve, signatures, goarch)
+		c.fpShiftLiterals = x86LoweredShiftLiterals(graph.original, resolve,
+			x86LoweredStaticAddressValues(graph.original, resolve, signatures, goarch), goarch)
+		c.goReadOnlyStorage = options.goReadOnlyStorage
+		if err := c.checkLoweredScalarFPResultInitialization(); err != nil {
+			return nil, err
+		}
+	}
+	if err := graph.verify(request, options); err != nil {
+		return nil, err
+	}
+	// Audit ordinary nonparticipants through their registered consumers, not
+	// the graph's call-free/zero-frame rule. This is the complete unchanged
+	// request, before KeepFunc or partitioning. Existing graph preparation only
+	// verifies here, so shared lowering does not recursively build another graph.
+	if _, err := translateIRText(request, options); err != nil {
+		graph.revoked.Store(true)
+		return nil, err
+	}
+	return request, nil
+}
+
+// Routing only: an already declared bounded Void ABI0 callee retains its own
+// ordinary lowering checks. No declaration is inferred for register helpers.
+// Inspect the captured source/symbols so a resolver cannot change the source
+// before the graph's identity checks. Non-CALL references keep the old graph.
+func (graph *x86DirectTailGraph) ordinaryABI0Calls() map[string]bool {
+	ordinary := make(map[string]bool)
+	for _, fn := range graph.original.Funcs {
+		name := graph.symbols[fn.Sym]
+		sig, found := graph.signatures[name]
+		if graph.helpers[fn.Sym] && found && (sig.Name == "" || sig.Name == name) &&
+			x86BoundedVoidABI0Declaration(fn, sig, graph.goarch) {
+			ordinary[fn.Sym] = true
+		}
+	}
+	for _, fn := range graph.original.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT || ins.Op == OpCALL {
+				continue // auditReferences already checked exact CALL operands.
+			}
+			for _, arg := range ins.Args {
+				if name, _, valid := parseSBRef(arg.Sym); valid {
+					delete(ordinary, name)
+				}
+			}
+		}
+	}
+	return ordinary
+}
+
+func x86BoundedVoidABI0Declaration(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" && arch != "386" || sig.Ret != Void || len(sig.Args) == 0 ||
+		len(sig.Frame.Params) == 0 || sig.WASMNative || sig.x86BorrowedBoolTail ||
+		fn.ArgSize <= 0 || fn.ArgSize > 4096 || len(fn.Instrs) == 0 || fn.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	op, rest := splitOpcode(fn.Instrs[0].Raw)
+	frame, err := parseTEXTFrameSpec(strings.Split(rest, ","))
+	return strings.EqualFold(op, "TEXT") && err == nil && frame.argsSpecified &&
+		frame.frameSize == fn.FrameSize && frame.argSize == fn.ArgSize && x86ABI0FrameLayout(sig, fn.ArgSize, arch)
+}
+
+// Both continuation emission and a separately sealed custom-register result
+// plan use this same complete original source/reference/signature producer.
+func newX86DirectTailGraph(file *File, options Options, helpers map[string]bool, goarch string) (*x86DirectTailGraph, map[string]int, error) {
+	resolve := options.ResolveSym
+	if resolve == nil {
+		resolve = func(symbol string) string { return symbol }
+	}
+	graph := &x86DirectTailGraph{origin: file, original: x86DirectTailSnapshot(file), goarch: goarch, helpers: helpers,
+		symbols: make(map[string]string), externalSymbols: make(map[string]string), roots: make(map[string]*x86DirectTailRoot), numerical: options.NumericalReads,
+		goPackage: options.goPackage}
+	signatures, err := numericalCloneSignatures(options.Sigs)
+	if err != nil {
+		return nil, nil, err
+	}
+	graph.signatures = signatures
+	byName := make(map[string]int)
+	graph.texts = byName
+	resolved := make(map[string]bool)
+	for index, fn := range graph.original.Funcs {
+		name := resolve(fn.Sym)
+		if _, duplicate := byName[fn.Sym]; duplicate || name == "" || resolved[name] {
+			return nil, nil, x86DirectTailContext("missing, duplicate or aliased original TEXT identity")
+		}
+		byName[fn.Sym], graph.symbols[fn.Sym], resolved[name] = index, name, true
+	}
+	for _, fn := range graph.original.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpJMP && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym {
+				if name, offset, valid := parseSBRef(ins.Args[0].Sym); valid && offset == 0 && !helpers[name] {
+					graph.externalSymbols[name] = resolve(name)
+				}
+			}
+		}
+	}
+	if !reflect.DeepEqual(graph.original, x86DirectTailSnapshot(file)) || !reflect.DeepEqual(graph.signatures, options.Sigs) {
+		return nil, nil, x86DirectTailContext("resolver changed complete source or signatures")
+	}
+	if err := graph.auditReferences(); err != nil {
+		return nil, nil, err
+	}
+	if err := graph.verifyPureGoTails(); err != nil {
+		return nil, nil, err
+	}
+	return graph, byName, nil
+}
+
+func x86DirectTailInstructions(fn Func) []x86DirectTailPoint {
+	var points []x86DirectTailPoint
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op != OpTEXT && ins.Op != OpLABEL {
+			points = append(points, x86DirectTailPoint{instruction: ordinal})
+		}
+	}
+	return points
+}
+
+func (graph *x86DirectTailGraph) auditReferences() error {
+	for _, fn := range graph.original.Funcs {
+		for _, ins := range fn.Instrs {
+			if ins.Op == OpTEXT {
+				continue
+			}
+			for _, arg := range ins.Args {
+				text := arg.Sym
+				if arg.Kind == OpMem {
+					text = arg.Mem.Sym
+				}
+				base, offset, valid := parseSBRef(strings.TrimPrefix(text, "$"))
+				if !valid || !graph.helpers[base] {
+					continue
+				}
+				if ins.Op != OpJMP && ins.Op != OpCALL || len(ins.Args) != 1 || arg.Kind != OpSym || offset != 0 || strings.HasPrefix(text, "$") {
+					return x86DirectTailContext("helper address/call/offset escape in %s: %s", fn.Sym, ins.Raw)
+				}
+			}
+		}
+	}
+	for _, data := range graph.original.Data {
+		base, _, valid := parseSBRef(strings.TrimPrefix(data.Addr, "$"))
+		if graph.helpers[data.Sym] || valid && graph.helpers[base] {
+			return x86DirectTailContext("helper address escapes through DATA")
+		}
+	}
+	for _, global := range graph.original.Globl {
+		if graph.helpers[global.Sym] {
+			return x86DirectTailContext("helper TEXT identity also names GLOBL storage")
+		}
+	}
+	return nil
+}
+
+func (graph *x86DirectTailGraph) verify(file *File, options Options) (result error) {
+	if graph != nil {
+		defer func() {
+			if result != nil {
+				graph.revoked.Store(true)
+			}
+		}()
+	}
+	goarch := options.Goarch
+	if goarch == "" {
+		goarch = "amd64"
+	}
+	if graph == nil || graph.origin == nil || graph.original == nil || file == nil ||
+		graph.revoked.Load() || graph.goarch != goarch || file.Arch != ArchAMD64 || len(options.X86TailGroups) != 0 ||
+		options.NumericalReads != graph.numerical || options.X86TLSMoves != nil || options.ARM64ByteCarrierSource != nil ||
+		!reflect.DeepEqual(x86DirectTailSnapshot(graph.origin), graph.original) || !reflect.DeepEqual(graph.signatures, options.Sigs) {
+		return x86DirectTailContext("original complete source/signature identity changed")
+	}
+	if graph.numerical != nil {
+		if err := verifyNumericalReadInputs(graph.origin, options); err != nil {
+			return err
+		}
+		if err := verifyNormalizedNumericalReads(file, options); err != nil {
+			return err
+		}
+	}
+	if err := graph.verifyPureGoTails(); err != nil {
+		return err
+	}
+	before := x86DirectTailSnapshot(file)
+	selected := x86DirectTailSnapshot(file)
+	selected.Funcs = graph.original.Funcs
+	if !reflect.DeepEqual(selected, graph.original) {
+		return x86DirectTailContext("selected complete DATA/GLOBL/prelude identity changed")
+	}
+	seen := make(map[string]bool)
+	for _, fn := range file.Funcs {
+		if seen[fn.Sym] {
+			return x86DirectTailContext("duplicate selected original TEXT")
+		}
+		seen[fn.Sym] = true
+		public := arm64PrivateTailSnapshot(fn)
+		if graph.fixedLocal != nil {
+			if public.x86FixedLocal != nil && public.x86FixedLocal.binding != graph.fixedLocal ||
+				public.x86DirectTailRoot != nil && public.x86DirectTailRoot.graph != graph {
+				return x86DirectTailContext("normalized frame belongs to another source graph")
+			}
+			public.x86FixedLocal, public.x86DirectTailRoot, public.x86RawReplay = nil, nil, nil
+		}
+		for ordinal := range public.Instrs {
+			public.Instrs[ordinal] = x86DirectTailInstructionSnapshot(public.Instrs[ordinal])
+		}
+		found := false
+		for _, original := range graph.original.Funcs {
+			if fn.Sym == original.Sym && reflect.DeepEqual(public, original) {
+				found = true
+			}
+		}
+		if !found {
+			return x86DirectTailContext("selected entry no longer belongs to complete original source")
+		}
+	}
+	resolve := options.ResolveSym
+	if resolve == nil {
+		resolve = func(symbol string) string { return symbol }
+	}
+	for _, fn := range graph.original.Funcs {
+		if resolve(fn.Sym) != graph.symbols[fn.Sym] {
+			return x86DirectTailContext("original source symbol mapping changed")
+		}
+	}
+	for symbol, expected := range graph.externalSymbols {
+		if resolve(symbol) != expected {
+			return x86DirectTailContext("external typed terminal symbol mapping changed")
+		}
+	}
+	if graph.revoked.Load() || !reflect.DeepEqual(x86DirectTailSnapshot(graph.origin), graph.original) || !reflect.DeepEqual(graph.signatures, options.Sigs) ||
+		!reflect.DeepEqual(x86DirectTailSnapshot(file), before) {
+		return x86DirectTailContext("resolver changed source/signatures during verification")
+	}
+	return graph.verifyPureGoTails()
+}
diff --git a/x86_direct_tail_source_test.go b/x86_direct_tail_source_test.go
new file mode 100644
index 000000000..bdd9019af
--- /dev/null
+++ b/x86_direct_tail_source_test.go
@@ -0,0 +1,403 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86DirectTailTestGo = `package p
+func First(a uint64) uint64
+func Second(a, b uint32) uint64
+`
+
+const x86DirectTailTestASM = `TEXT ·First(SB),NOSPLIT,$0-16
+ MOVQ a+0(FP),SI
+ MOVQ $7,DI
+ JMP shared<>(SB)
+TEXT ·Second(SB),NOSPLIT,$0-16
+ MOVL a+0(FP),SI
+ MOVL b+4(FP),DI
+ JMP shared<>(SB)
+TEXT shared<>(SB),NOSPLIT,$0-0
+ MOVQ SI,AX
+ ADDQ DI,AX
+ MOVQ AX,ret+8(FP)
+ RET
+`
+
+func x86DirectTailTestInputs(t *testing.T) (*File, Options) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, x86DirectTailTestASM)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym("example.com/tails")
+	sigs, err := goSigsForAsmFile(mustGoPackage(t, "example.com/tails", x86DirectTailTestGo), file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+}
+
+func TestX86DirectTailCanonicalBoolAndIndependentRootFrames(t *testing.T) {
+	for _, test := range []struct {
+		name, declarations, source string
+		wantContext                bool
+	}{
+		{"canonical_bool", "func First(a uint64) bool", `TEXT ·First<ABIInternal>(SB),NOSPLIT,$0-9
+ MOVQ AX,SI
+ CMPQ SI,$0
+ JMP pred<>(SB)
+TEXT pred<>(SB),NOSPLIT,$0-0
+ SETEQ AL
+ MOVBLZX AL,AX
+ RET
+`, false},
+		{"noncanonical_bool", "func First(a uint64) bool", `TEXT ·First<ABIInternal>(SB),NOSPLIT,$0-9
+ JMP pred<>(SB)
+TEXT pred<>(SB),NOSPLIT,$0-0
+ MOVL $2,AX
+ RET
+`, true},
+		{"unknown_bool_FLAGS", "func First(a uint64) bool", `TEXT ·First<ABIInternal>(SB),NOSPLIT,$0-9
+ JMP pred<>(SB)
+TEXT pred<>(SB),NOSPLIT,$0-0
+ SETEQ AL
+ RET
+`, true},
+		{"unknown_join", "func First(a uint64) uint64", `TEXT ·First<ABIInternal>(SB),NOSPLIT,$0-16
+ CMPQ AX,$0
+ JE shared
+ MOVQ AX,SI
+shared:
+ JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+ MOVQ SI,AX
+ RET
+`, true},
+		{"root_result_offsets_differ", "func First(a uint64) uint64\nfunc Second(a,b uint64) uint64", x86DirectTailTestASM, true},
+		{"root_result_padding", "func First(a uint64) uint64\nfunc Second(a,b uint32) uint32", x86DirectTailTestASM, true},
+		{"pointer_not_NUM", "func First(a *uint64) uint64\nfunc Second(a,b uint32) uint64", x86DirectTailTestASM, true},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(test.name+"/"+triple+"/"+api, func(t *testing.T) {
+					pkg := mustGoPackage(t, "example.com/tails", "package p\n"+test.declarations)
+					resolve := testResolveSym(pkg.Path)
+					file, err := Parse(ArchAMD64, test.source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var module llvm.Module
+					if api == "Go" {
+						tr, goErr := TranslateGoModule(pkg, []byte(test.source), GoModuleOptions{
+							GOARCH: "amd64", TargetTriple: triple, ResolveSym: resolve,
+						})
+						err = goErr
+						if tr != nil {
+							module = tr.Module
+						}
+					} else {
+						sigs, sigErr := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+						if sigErr != nil {
+							t.Fatal(sigErr)
+						}
+						opt := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+						if api == "text" {
+							_, err = Translate(file, opt)
+						} else {
+							module, err = TranslateModule(file, opt)
+						}
+					}
+					if !module.IsNil() {
+						module.Dispose()
+					}
+					if test.wantContext {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("unclosed root state/result acquired continuation: %v", err)
+						}
+					} else if err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailPreparedSourceRejectsMutations(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		mutate func(*File, *File, *Options)
+	}{
+		{"selected_DATA", func(_, prepared *File, _ *Options) { prepared.Data = []DataStmt{{Sym: "extra<>"}} }},
+		{"selected_GLOBL", func(_, prepared *File, _ *Options) { prepared.Globl = []GloblStmt{{Sym: "extra<>"}} }},
+		{"selected_prelude", func(_, prepared *File, _ *Options) { prepared.UnlinkedPrelude = []string{"NOP"} }},
+		{"selected_arch", func(_, prepared *File, _ *Options) { prepared.Arch = ArchARM64 }},
+		{"selected_duplicate", func(_, prepared *File, _ *Options) { prepared.Funcs = append(prepared.Funcs, prepared.Funcs[0]) }},
+		{"original_Raw", func(original, _ *File, _ *Options) { original.Funcs[2].Instrs[1].Raw += " // changed" }},
+		{"selected_Raw", func(_, prepared *File, _ *Options) { prepared.Funcs[2].Instrs[1].Raw += " // changed" }},
+		{"resolver", func(_, _ *File, opt *Options) { opt.ResolveSym = func(s string) string { return "changed." + s } }},
+		{"target_mode", func(_, _ *File, opt *Options) { opt.Goarch = "386" }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			file, opt := x86DirectTailTestInputs(t)
+			prepared, err := PrepareX86DirectTailSource(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			test.mutate(file, prepared, &opt)
+			if _, err := PrepareX86DirectTailSource(prepared, opt); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed complete source/mapping retained graph: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailGoModuleAuditsBeforeKeepFunc(t *testing.T) {
+	for _, test := range []struct {
+		name, source string
+		wantContext  bool
+	}{
+		{"complete", x86DirectTailTestASM, false},
+		{"dropped_root_unknown", strings.Replace(x86DirectTailTestASM, "MOVL b+4(FP),DI", "MOVQ R15,DI", 1), true},
+		{"dead_helper_escape", x86DirectTailTestASM + "TEXT unused<>(SB),NOSPLIT,$0-0\n RET\n", true},
+		{"dead_helper_CALL", x86DirectTailTestASM + "TEXT unused<>(SB),NOSPLIT,$0-0\n CALL foreign(SB)\n RET\n", true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			pkg := mustGoPackage(t, "example.com/tails", x86DirectTailTestGo)
+			tr, err := TranslateGoModule(pkg, []byte(test.source), GoModuleOptions{
+				GOARCH: "amd64", GOOS: "linux", TargetTriple: "x86_64-unknown-linux-gnu",
+				ResolveSym: testResolveSym(pkg.Path), KeepFunc: func(source, _ string) bool { return source == "·First" },
+			})
+			if tr != nil {
+				defer tr.Module.Dispose()
+			}
+			if test.wantContext {
+				if err == nil || tr != nil {
+					t.Fatalf("KeepFunc hid invalid complete source: %v", err)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(tr.Functions) != 1 || tr.Functions[0].TextSymbol != "·First" ||
+				strings.Contains(tr.Module.String(), "shared<>") || strings.Contains(tr.Module.String(), "call i64") {
+				t.Fatalf("private source continuation became a callable/metadata entry: %v", tr.Functions)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailPrepareIsRequestLocal(t *testing.T) {
+	file, opt := x86DirectTailTestInputs(t)
+	before := x86DirectTailSnapshot(file)
+	var wait sync.WaitGroup
+	for i := 0; i < 8; i++ {
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			prepared, err := PrepareX86DirectTailSource(file, opt)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			if prepared == file || file.x86DirectTails != nil || prepared.x86DirectTails == nil {
+				t.Error("graph was not attached exclusively to its request-local copy")
+			}
+		}()
+	}
+	wait.Wait()
+	if !reflect.DeepEqual(file, before) {
+		t.Fatal("concurrent prepares changed original source")
+	}
+}
+
+func TestX86DirectTailOwnedContextsShareOriginalFile(t *testing.T) {
+	file, opt := x86DirectTailTestInputs(t)
+	before := x86DirectTailSnapshot(file)
+	var wait sync.WaitGroup
+	for i := 0; i < 4; i++ {
+		wait.Add(1)
+		go func() {
+			defer wait.Done()
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, opt)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			defer module.Dispose()
+			if strings.Contains(module.String(), "call i64") {
+				t.Error("owned context lost its request-local continuation state")
+			}
+		}()
+	}
+	wait.Wait()
+	if !reflect.DeepEqual(file, before) {
+		t.Fatal("owned contexts mutated their common original File")
+	}
+	// Global-context public APIs retain their existing LLVM ownership boundary;
+	// both independently consume exactly the same unchanged Parse result.
+	if _, err := Translate(file, opt); err != nil {
+		t.Fatal(err)
+	}
+	module, err := TranslateModule(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	module.Dispose()
+}
+
+func TestX86DirectTailPublicationRechecksOriginalSource(t *testing.T) {
+	for _, api := range []string{"text", "module", "context"} {
+		t.Run(api, func(t *testing.T) {
+			file, opt := x86DirectTailTestInputs(t)
+			file.Globl = []GloblStmt{{Sym: "marker<>", Flags: "RODATA", Size: 8}}
+			file.Data = []DataStmt{{Sym: "marker<>", Width: 8, Value: 7}}
+			baseResolve, armed, changed := opt.ResolveSym, false, false
+			opt.ResolveSym = func(symbol string) string {
+				if armed && symbol == "·marker<>" && !changed {
+					changed = true
+					file.Funcs[2].Instrs[1].Raw += " // source changed after prepare"
+				}
+				return baseResolve(symbol)
+			}
+			prepared, err := PrepareX86DirectTailSource(file, opt)
+			if err != nil {
+				t.Fatal(err)
+			}
+			armed = true
+			if api == "text" {
+				ir, err := Translate(prepared, opt)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !changed {
+					t.Fatalf("changed source published text: changed=%t error=%v", changed, err)
+				}
+				return
+			}
+			var module llvm.Module
+			if api == "module" {
+				module, err = TranslateModule(prepared, opt)
+			} else {
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err = TranslateModuleInContext(ctx, prepared, opt)
+			}
+			if !module.IsNil() {
+				module.Dispose()
+			}
+			if !module.IsNil() || !errors.Is(err, ErrProbeNeedsContext) || !changed {
+				t.Fatalf("changed source published module: changed=%t error=%v", changed, err)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailFailedIdentityCannotRevivePreparedGraph(t *testing.T) {
+	file, opt := x86DirectTailTestInputs(t)
+	prepared, err := PrepareX86DirectTailSource(file, opt)
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw := file.Funcs[2].Instrs[1].Raw
+	file.Funcs[2].Instrs[1].Raw += " // changed"
+	if _, err := PrepareX86DirectTailSource(prepared, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed source retained a graph", err)
+	}
+	file.Funcs[2].Instrs[1].Raw = raw
+	if _, err := PrepareX86DirectTailSource(prepared, opt); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("restoring public source revived the rejected graph", err)
+	}
+}
+
+const x86DirectTail386Go = `func First(a uint32) uint32
+func Second(a,b uint16) uint32
+`
+
+const x86DirectTail386ASM = `TEXT ·First(SB),4,$0-8
+ MOVL a+0(FP),SI
+ MOVL $7,DI
+ JMP sibling<>(SB)
+TEXT ·Second(SB),4,$0-8
+ MOVWLZX a+0(FP),SI
+ MOVWLZX b+2(FP),DI
+ JMP sibling<>(SB)
+TEXT sibling<>(SB),4,$0-0
+ MOVL SI,AX
+ ADDL DI,AX
+ MOVL AX,ret+4(FP)
+ RET
+`
+
+func TestX86DirectTail386WholeSourceKeepsItsOwnTypedFrame(t *testing.T) {
+	goAssemblerOracleOutput(t, "386", x86DirectTail386ASM, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86DirectTail386ASM, x86DirectTail386Go, "386", "i386-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "sibling") {
+				t.Fatalf("386 First(a)=a+7 and Second(a,b)=u32(a)+u32(b) retained a separate helper instead of its root state:\n%s", ir)
+			}
+		})
+	}
+}
+
+func TestX86DirectTailUnrelatedFunctionsRetainTheirOwnConsumers(t *testing.T) {
+	for _, row := range []struct{ name, declaration, source string }{
+		{"framed", "func Independent(a uint64) uint64", `TEXT ·Independent(SB),4,$8-16
+ MOVQ a+0(FP),AX
+ MOVQ AX,ret+8(FP)
+ RET
+`},
+		{"CALL", "func Independent() uint64\nfunc Foreign() uint64", `TEXT ·Independent(SB),4,$0-8
+ CALL ·Foreign(SB)
+ MOVQ AX,ret+0(FP)
+ RET
+`},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				declaration := strings.TrimPrefix(x86DirectTailTestGo, "package p\n") + row.declaration
+				// Establish the unrelated function's genuine old consumer before
+				// placing it next to the complete shared-helper source.
+				if _, err := x86ScalarFPBitViewAPI(t, row.source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Fatal("unrelated control is not independently supported", err)
+				}
+				if _, err := x86ScalarFPBitViewAPI(t, x86DirectTailTestASM+row.source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Fatal("tail graph stole an unrelated function's existing consumer", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86DirectTailKeepFuncCannotHideUnsupportedUnrelatedFunction(t *testing.T) {
+	declarations := x86DirectTailTestGo + "func Unsupported(a uint64) bool\n"
+	source := x86DirectTailTestASM + "TEXT ·Unsupported<ABIInternal>(SB),4,$0-9\n MOVL $2,AX\n RET\n"
+	pkg := mustGoPackage(t, "example.com/tails", declarations)
+	for _, keep := range []bool{false, true} {
+		t.Run(fmt.Sprint(keep), func(t *testing.T) {
+			opt := GoModuleOptions{GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)}
+			if keep {
+				opt.KeepFunc = func(symbol, _ string) bool { return symbol == "·First" }
+			}
+			tr, err := TranslateGoModule(pkg, []byte(source), opt)
+			if tr != nil {
+				tr.Module.Dispose()
+			}
+			if !errors.Is(err, ErrProbeNeedsContext) || tr != nil {
+				t.Fatalf("unsupported unrelated source silently disappeared: %v", err)
+			}
+		})
+	}
+}
diff --git a/x86_direction_call_test.go b/x86_direction_call_test.go
new file mode 100644
index 000000000..0f77de966
--- /dev/null
+++ b/x86_direction_call_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ABI0Mode32CanonicalBoolDirectCallRevokesDirection(t *testing.T) {
+	for _, result := range []string{"bool", "void"} {
+		for _, direction := range []string{"CLD", "STD"} {
+			for _, shape := range []bool{false, true} {
+				name := result + "/" + direction + "/reaching"
+				if shape {
+					name = result + "/" + direction + "/source-shape"
+				}
+				t.Run(name, func(t *testing.T) {
+					plan, state, owned := x86ABI0BoolCallDomainState(t)
+					if result == "void" {
+						file, err := Parse(ArchAMD64, x86ABI0BoolVoidCallSource)
+						if err != nil {
+							t.Fatal(err)
+						}
+						pkg := mustGoPackage(t, "directions", "package directions\n"+x86ABI0BoolVoidCallDeclarations)
+						resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+						sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+						if err != nil {
+							t.Fatal(err)
+						}
+						source, err := prepareX86ABI0BoolCalls(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs})
+						if err != nil || source == nil {
+							t.Fatal("actual void CALL observation missing", err)
+						}
+						plan = source.callers["·probe"]
+						state.boolCalls, state.boolOutgoing, state.boolOutgoingCanonical = plan, nil, nil
+					}
+					state.shapeOnly = shape
+					if accepted, known := x86ResultDirectionStep(x86ScalarLaneInstruction(t, direction), &state, "386"); !accepted || !known || state.direction == x86ResultDirectionUnknown {
+						t.Fatal("actual typed DF producer did not run")
+					}
+					before := state.clone()
+					ordinal := -1
+					for index := range plan.calls {
+						ordinal = index
+					}
+					if ordinal < 0 {
+						t.Fatal("complete source CALL member missing")
+					}
+					ins := plan.function.Instrs[ordinal]
+					if accepted, known := x86ABI0BoolCallStep(ordinal+100, ins, &state, owned, 4, "386"); accepted || !known || !reflect.DeepEqual(before, state) {
+						t.Fatal("unknown source CALL acquired a direction/result effect")
+					}
+					// Deliberately call the independent producer without the shared
+					// CFG's post-transfer wrapper. Its own machine-clobber boundary
+					// must revoke DF for both existing result and no-result roles.
+					if accepted, known := x86ABI0BoolCallStep(ordinal, ins, &state, owned, 4, "386"); !accepted || !known || state.direction != x86ResultDirectionUnknown {
+						t.Fatal("direct CALL retained the caller's direction fact", state.direction)
+					}
+					if !reflect.DeepEqual(state.fp, before.fp) || !reflect.DeepEqual(state.canonicalFP, before.canonicalFP) {
+						t.Fatal("direction revocation changed independent caller FP knowledge")
+					}
+					if result == "void" && (len(state.boolOutgoing) != 0 || len(state.boolOutgoingCanonical) != 0) ||
+						result == "bool" && (!state.boolOutgoing[4] || !state.boolOutgoingCanonical[4]) {
+						t.Fatal("DF revocation created or erased a declared outgoing result role")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectionTypedBoolAndVoidWholeCallThreeAPIs(t *testing.T) {
+	for _, result := range []string{"bool", "void"} {
+		for _, direction := range []string{"CLD", "STD"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(result+"/"+direction+"/"+api, func(t *testing.T) {
+					source, declaration := x86ABI0BoolCallAssembly(x86ABI0BoolCallBody, x86ABI0BoolCallLeaf), x86ABI0BoolCallDeclarations
+					target := "CALL ·callee(SB)"
+					if result == "void" {
+						source, declaration, target = x86ABI0BoolVoidCallSource, x86ABI0BoolVoidCallDeclarations, "CALL ·notify(SB)"
+					}
+					source = strings.Replace(source, target, direction+"\n"+target+"\nCLD", 1)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", "i386-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("complete typed CALL/DF composition rejected", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_direction_popf_test.go b/x86_direction_popf_test.go
new file mode 100644
index 000000000..a34dc3452
--- /dev/null
+++ b/x86_direction_popf_test.go
@@ -0,0 +1,183 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectionPOPFCompleteGoFlagStackRows(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete Go no-operand grammar changed")
+	}
+	for _, width := range []struct{ name, prefix string }{{"W", "Pe"}, {"L", "P32"}, {"Q", "Py"}} {
+		for _, action := range []struct{ name, opcode string }{{"PUSHF", "0x9c"}, {"POPF", "0x9d"}} {
+			op := action.name + width.name
+			row := fmt.Sprintf("{A%s, ynone, %s, opBytes{%s}},", op, width.prefix, action.opcode)
+			if strings.Count(string(table), row) != 1 {
+				t.Fatal("complete independent Go FLAGS stack encoding changed", row)
+			}
+			for _, arch := range []string{"amd64", "386"} {
+				_, known, err := x86StackWidthProperties(x86ScalarLaneInstruction(t, op), arch)
+				valid := width.name == "W" || arch == "386" && width.name == "L" || arch == "amd64" && width.name == "Q"
+				if !known || (err == nil) != valid {
+					t.Fatal("typed stack grammar changed source mode", arch, op, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86DirectionPOPFIndependentTransferRevokesPriorFact(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			for direction := x86ResultDirectionUnknown; direction <= x86ResultDirectionEither; direction++ {
+				t.Run(fmt.Sprintf("%s/%s/DF=%d", arch, width, direction), func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nPOPF"+width+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					valid := width == "W" || arch == "386" && width == "L" || arch == "amd64" && width == "Q"
+					checked := false
+					err = checkX86ResultSourceFlow(file.Funcs[0], x86ResultState{direction: direction}, nil, 0, arch,
+						func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+							if spec, known, err := x86StackWidthProperties(ins, arch); known && spec.mode == amd64StackPopFlags {
+								// This independent test-only role accepts a valid restore,
+								// but supplies no private saved-bit observation.
+								return err == nil
+							}
+							return x86ResultTransfer(ins, state, owned, offset, arch)
+						}, func(state x86ResultState, _ int) error {
+							checked = true
+							if state.direction != x86ResultDirectionUnknown {
+								return fmt.Errorf("unobserved POPF retained prior DF=%d", state.direction)
+							}
+							return nil
+						})
+					if valid && (err != nil || !checked) || !valid && (!errors.Is(err, ErrProbeNeedsContext) || checked) {
+						t.Fatal("independent POPF role changed DF or source-mode boundaries", err, checked)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectionPOPFCheckedStackUsesOnlySavedBits(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		widths := []string{"W", "Q"}
+		if arch == "386" {
+			widths = []string{"W", "L"}
+		}
+		for _, width := range widths {
+			for saved := x86ResultDirectionUnknown; saved <= x86ResultDirectionEither; saved++ {
+				for _, savedID := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/DF=%d/ID=%t", arch, width, saved, savedID), func(t *testing.T) {
+						file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nNOP\nPUSHF"+width+"\nNOP\nPOPF"+width+"\nRET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						initial := x86ResultState{direction: saved, flags: 0x15}
+						initial.gp[3] = 0x51
+						checked := false
+						err = checkX86ResultSourceFlow(file.Funcs[0], initial, nil, 0, arch,
+							func(ordinal int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+								if ins.Op == "NOP" {
+									if ordinal == 1 {
+										state.valueStack.id = savedID
+									} else {
+										state.direction, state.flags, state.valueStack.id = x86ResultDirectionForward, x86ByteFlagsAll, true
+									}
+									return true
+								}
+								return x86ResultTransfer(ins, state, owned, offset, arch)
+							}, func(state x86ResultState, _ int) error {
+								checked = true
+								want := x86ResultDirectionUnknown
+								if saved != x86ResultDirectionUnknown {
+									want = x86ResultDirectionEither // The private stack stores definedness, not a chosen bit value.
+								}
+								if state.direction != want || state.flags != initial.flags || state.gp != initial.gp ||
+									state.valueStack.id != (width == "W" || savedID) || len(state.valueStack.bytes) != 0 {
+									return fmt.Errorf("POPF borrowed current rather than saved DF/status/ID facts: DF=%d flags=%02x ID=%t", state.direction, state.flags, state.valueStack.id)
+								}
+								return nil
+							})
+						if err != nil || !checked {
+							t.Fatal(err, checked)
+						}
+					})
+				}
+			}
+			for _, right := range []string{"STD", "NOP"} {
+				t.Run(arch+"/"+width+"/join-"+right, func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\nMOVL $1,AX\nCMPL AX,$0\nJZ right\nCLD\nPUSHF" + width +
+						"\nJMP joined\nright:\n" + right + "\nPUSHF" + width + "\njoined:\nCLD\nPOPF" + width + "\nRET\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					err = checkX86ResultSourceFlow(file.Funcs[0], x86ResultState{}, nil, 0, arch,
+						func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+							return x86ResultTransfer(ins, state, owned, offset, arch)
+						}, func(state x86ResultState, _ int) error {
+							want := x86ResultDirectionEither
+							if right == "NOP" {
+								want = x86ResultDirectionUnknown
+							}
+							if state.direction != want {
+								return fmt.Errorf("saved-bit CFG join became DF=%d, want %d", state.direction, want)
+							}
+							return nil
+						})
+					if err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectionPOPFValueStackCloneJoinSavedFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		widths := []string{"W", "Q"}
+		if arch == "386" {
+			widths = []string{"W", "L"}
+		}
+		for _, width := range widths {
+			t.Run(arch+"/"+width, func(t *testing.T) {
+				state := x86ResultState{direction: x86ResultDirectionEither, flags: 0x15, valueStack: new(x86ResultValueStack)}
+				if !x86ResultTransfer(x86ScalarLaneInstruction(t, "PUSHF"+width), &state, nil, 0, arch) {
+					t.Fatal("actual private PUSHF failed")
+				}
+				clone := state.clone()
+				clone.valueStack.bytes[len(clone.valueStack.bytes)-2] &^= 1 << 2 // Saved physical DF bit 10.
+				if state.valueStack.bytes[len(state.valueStack.bytes)-2]&(1<<2) == 0 {
+					t.Fatal("clone changed the independently saved DF mask")
+				}
+				for index, input := range []x86ResultState{state.clone(), clone.clone(), state.intersect(clone), clone.intersect(state)} {
+					input.direction = x86ResultDirectionForward
+					if !x86ResultTransfer(x86ScalarLaneInstruction(t, "POPF"+width), &input, nil, 0, arch) {
+						t.Fatal("actual private POPF failed")
+					}
+					want := x86ResultDirectionUnknown
+					if index == 0 {
+						want = x86ResultDirectionEither
+					}
+					if input.direction != want || input.flags != state.flags || len(input.valueStack.bytes) != 0 {
+						t.Fatal("clone/join borrowed a current or missing saved fact", index, input.direction)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_direction_sdk_go127_test.go b/x86_direction_sdk_go127_test.go
new file mode 100644
index 000000000..794136806
--- /dev/null
+++ b/x86_direction_sdk_go127_test.go
@@ -0,0 +1,120 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectionOriginalSDKIndexByte386ThreeAPIsCompleteSource(t *testing.T) {
+	root := runtime.GOROOT()
+	dir := filepath.Join(root, "src", "internal", "bytealg")
+	declaration, err := os.ReadFile(filepath.Join(dir, "indexbyte_native.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	source, err := ReadGoAssemblySourceAtGOROOT(filepath.Join(dir, "indexbyte_386.s"), dir, root)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "internal/bytealg", string(declaration))
+	file, err := Parse(ArchAMD64, string(source))
+	if err != nil || len(file.Funcs) != 2 {
+		t.Fatal("complete original SDK member changed", err)
+	}
+	var entries []string
+	for _, function := range file.Funcs {
+		branches := 0
+		for _, instruction := range function.Instrs {
+			if instruction.Op == "JZ" && len(instruction.Args) == 1 && instruction.Args[0].Kind == OpMem {
+				address := instruction.Args[0].Mem
+				if address.Base == "PC" && address.Off == 3 && address.OffRaw == "" && address.Index == "" && address.Sym == "" {
+					branches++
+				}
+			}
+		}
+		if branches != 1 {
+			t.Fatal("complete original TEXT lost its PC-relative conditional branch", function.Sym)
+		}
+		// This is the exact source resolver used by the three-API fixture,
+		// not the package-qualified resolver of importedGlobalReadRequest.
+		name := strings.TrimPrefix(goStripABISuffix(function.Sym), "·")
+		entries = append(entries, name)
+		declaration := pkg.Types.Scope().Lookup(name)
+		if declaration == nil {
+			t.Fatal("complete original declaration disappeared", name)
+		}
+		sig, err := DeriveGoFuncABI0Signature(name, declaration.(*types.Func), "386", types.SizesFor("gc", "386"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, query := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+			err := query(function, sig, "386")
+			if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "instruction 5: REPN") {
+				t.Fatal("original TEXT has not retained the independent repeat contract", name, err)
+			}
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t, string(source), pkg, "386", "i386-unknown-linux-gnu", api)
+			// The unpaired queries above still cannot borrow native repeat
+			// semantics. With that exact continuation, both complete source
+			// entries return -1 on either empty-count edge without inventing ZF.
+			if err != nil || ir == "" {
+				t.Fatal("complete source lost its paired empty-repeat result proof", err)
+			}
+			// LLVM's symbol index checks both actual non-declaration bodies,
+			// including nonempty basic blocks, independent of quote rendering.
+			x86StringMemoryFunctions(t, ir, entries)
+		})
+	}
+}
+
+func TestX86DirectionOriginalGo127CompleteYnoneRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	if !strings.Contains(table, "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete Go ynone operand table changed")
+	}
+	rows := map[string]string{
+		"CLD": "Px, opBytes{0xfc}", "STD": "Px, opBytes{0xfd}",
+		"REP": "Px, opBytes{0xf3}", "REPN": "Px, opBytes{0xf2}",
+	}
+	for _, family := range []struct {
+		name                   string
+		byteOpcode, wideOpcode int
+	}{
+		{"MOVS", 0xa4, 0xa5}, {"STOS", 0xaa, 0xab},
+		{"SCAS", 0xae, 0xaf}, {"CMPS", 0xa6, 0xa7}, {"LODS", 0xac, 0xad},
+	} {
+		for _, width := range []struct{ suffix, prefix string }{{"B", "Pb"}, {"W", "Pe"}, {"L", "Px"}, {"Q", "Pw"}} {
+			opcode := family.wideOpcode
+			if width.suffix == "B" {
+				opcode = family.byteOpcode
+			}
+			rows[family.name+width.suffix] = fmt.Sprintf("%s, opBytes{0x%x}", width.prefix, opcode)
+		}
+	}
+	if len(rows) != 24 || len(x86DirectionControlSpecs) != 2 || len(x86StringSpecs) != 20 {
+		t.Fatal("complete family denominator changed")
+	}
+	for name, row := range rows {
+		matches := regexp.MustCompile(`(?m)^\s*\{A`+name+`,[^\n]+`).FindAllString(table, -1)
+		want := "{A" + name + ", ynone, " + row + "},"
+		if len(matches) != 1 || strings.TrimSpace(matches[0]) != want {
+			t.Fatal("complete original source instruction row changed", name, matches, want)
+		}
+	}
+}
diff --git a/x86_direction_test.go b/x86_direction_test.go
new file mode 100644
index 000000000..6a0b0c688
--- /dev/null
+++ b/x86_direction_test.go
@@ -0,0 +1,298 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectionControlBackendSeparation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, triple := range []string{
+			"i386-unknown-linux-gnu", "x86_64-unknown-linux-gnu",
+			"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown", "",
+		} {
+			for _, direction := range []string{"CLD", "STD"} {
+				t.Run(arch+"/"+triple+"/"+direction, func(t *testing.T) {
+					var output strings.Builder
+					context := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, triple, false)
+					context.directionSlot = "%direction"
+					if known, err := context.lowerDirectionControl(x86ScalarLaneInstruction(t, direction)); !known || err != nil {
+						t.Fatal("valid direction control rejected", err)
+					}
+					want := fmt.Sprintf("  store i1 %t, ptr %%direction\n", direction == "STD")
+					// Independent exact mode/backend directory, not the production
+					// target predicate. No status-FLAGS store is part of this effect.
+					native := arch == "386" && triple == "i386-unknown-linux-gnu" ||
+						arch == "amd64" && triple == "x86_64-unknown-linux-gnu"
+					if native {
+						want += fmt.Sprintf("  call void asm sideeffect %q, \"~{dirflag}\"()\n", strings.ToLower(direction))
+					}
+					if output.String() != want {
+						t.Fatalf("virtual/native DF boundary changed: got=%q want=%q", output.String(), want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectionControlNumericalAndCallerThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, typ := 8, "MOVQ", "uint64"
+		if arch == "386" {
+			word, move, typ = 4, "MOVL", "uint32"
+		}
+		for _, direction := range []string{"CLD", "STD"} {
+			for _, role := range []string{"numeric", "caller-origin"} {
+				t.Run(arch+"/"+direction+"/"+role, func(t *testing.T) {
+					declaration := "func view(x, prior " + typ + ") " + typ + "\n"
+					body := fmt.Sprintf("%s x+0(FP),AX\n%s prior+%d(FP),BX\n%s\nBSFL AX,BX\n%s BX,ret+RESULT(FP)", move, move, word, direction, move)
+					if role == "caller-origin" {
+						declaration = "func view(p *byte) " + typ + "\n"
+						body = fmt.Sprintf("%s p+0(FP),SI\n%s SI,DI\n%s\nSUB%s SI,DI\n%s DI,ret+RESULT(FP)", move, move, direction, strings.TrimPrefix(move, "MOV"), move)
+					}
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, true)
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectionControlCompleteGoGrammarAndRawSeparation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386", "arm64"} {
+		for _, op := range []string{"CLD", "STD"} {
+			for _, tail := range []string{"", " AX", " $1", " (AX)", ".Z"} {
+				t.Run(arch+"/"+op+strings.ReplaceAll(tail, " ", "_"), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+tail)
+					_, known, err := x86DirectionControlProperties(ins.Op, ins, arch)
+					valid := arch != "arm64" && tail == ""
+					if !known || (err == nil) != valid {
+						t.Fatal("direction-control accepted a form outside its complete ynone rows", known, err)
+					}
+					state := x86ResultState{}
+					accepted, recognized := x86ResultDirectionStep(ins, &state, arch)
+					if !recognized || accepted != valid || !valid && state.direction != x86ResultDirectionUnknown {
+						t.Fatal("grammar failure created direction knowledge", accepted, recognized, state.direction)
+					}
+				})
+			}
+		}
+	}
+	for _, mutate := range []struct {
+		name  string
+		apply func(*Instr)
+	}{
+		{"encoded", func(ins *Instr) { ins.x86Encoded = true }},
+		{"source-raw", func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{} }},
+		{"address-size", func(ins *Instr) { ins.x86AddressBits = 32 }},
+		{"unbound-address", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+		{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 1 }},
+	} {
+		t.Run(mutate.name, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, "CLD")
+			mutate.apply(&ins)
+			state := x86ResultState{}
+			if accepted, known := x86ResultDirectionStep(ins, &state, "amd64"); accepted || !known || state.direction != x86ResultDirectionUnknown {
+				t.Fatal("named DF rule lent a raw/native source role")
+			}
+		})
+	}
+}
+
+func TestX86DirectionStateCloneJoinPreservationAndRevocation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CLD", "STD"} {
+			for flags := 0; flags <= int(x86ByteFlagsAll); flags++ {
+				state := x86ResultState{flags: uint8(flags), fp: []bool{true}, canonicalFP: []bool{true}, auto: []bool{true}}
+				state.gp[0], state.canonicalGP[0], state.xmm[0] = 0x51, 1, 0x1234
+				state.pointerGP[6], state.callerAddressGP[6], state.callerAddressOrigin[6] = true, true, 1
+				state.resultAddressGP[7] = x86ResultSlotAddress{start: 8, end: 16, offset: 8, valid: true}
+				before := state.clone()
+				ins := x86ScalarLaneInstruction(t, op)
+				if accepted, known := x86ResultDirectionStep(ins, &state, arch); !accepted || !known {
+					t.Fatal("complete direction setter rejected")
+				}
+				want := x86ResultDirectionForward
+				if op == "STD" {
+					want = x86ResultDirectionBackward
+				}
+				if state.direction != want {
+					t.Fatal("direction value lost", state.direction)
+				}
+				state.direction = before.direction
+				if !reflect.DeepEqual(before, state) || x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch) != before.callerAddressGP {
+					t.Fatal("DF control changed independent numerical/canonical/status/address knowledge")
+				}
+			}
+		}
+	}
+	for _, first := range []x86ResultDirection{0, 1, 2, 3} {
+		for _, second := range []x86ResultDirection{0, 1, 2, 3} {
+			want := first | second
+			if first == 0 || second == 0 {
+				want = 0
+			}
+			state := x86ResultState{direction: first}
+			clone := state.clone()
+			clone.direction = second
+			if state.direction != first || state.intersect(clone).direction != want {
+				t.Fatal("DF join invented a known direction or shared mutable state", first, second)
+			}
+		}
+	}
+	for _, op := range []Op{OpCALL, "POPFW", "POPFL", "POPFQ", "IRETW", "IRETL", "IRETQ"} {
+		if got := x86ResultDirectionAfter(Instr{Op: op}, x86ResultDirectionEither); got != x86ResultDirectionUnknown {
+			t.Fatal("callee/FLAGS restoration retained an unobserved direction", op, got)
+		}
+	}
+	if x86ResultDirectionAfter(Instr{Op: "NOP", x86Encoded: true}, x86ResultDirectionForward) != x86ResultDirectionUnknown ||
+		x86ResultDirectionAfter(Instr{Op: "MOVL"}, x86ResultDirectionBackward) != x86ResultDirectionBackward {
+		t.Fatal("DF revocation was merged with ordinary NUM effects")
+	}
+}
+
+func TestX86DirectionWholeSourceCFGJoinsAndFinalEffectRevocation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name, first, second, last string
+			want                      x86ResultDirection
+		}{
+			{"both-forward", "CLD", "CLD", "", x86ResultDirectionForward},
+			{"mixed-defined", "CLD", "STD", "", x86ResultDirectionEither},
+			{"missing-one-edge", "CLD", "NOP", "", x86ResultDirectionUnknown},
+			{"missing-both", "NOP", "NOP", "", x86ResultDirectionUnknown},
+			{"overwrite-join", "CLD", "STD", "CLD\n", x86ResultDirectionForward},
+			{"accepted-call", "CLD", "STD", "CALL callee(SB)\n", x86ResultDirectionUnknown},
+			{"accepted-flags-restore", "CLD", "STD", "POPFW\n", x86ResultDirectionUnknown},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT entry(SB),4,$0-0\nMOVL $1,AX\nCMPL AX,$0\nJZ right\n%s\nJMP joined\nright:\n%s\njoined:\n%sRET\n", row.first, row.second, row.last)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				checked := false
+				err = checkX86ResultSourceFlow(file.Funcs[0], x86ResultState{}, nil, 0, arch,
+					func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+						// Isolate the shared post-effect hook: an independent private
+						// observer accepting CALL/POPF may not retain DF. This test
+						// transfer is not installed in any production/public role.
+						if ins.Op == OpCALL || ins.Op == "POPFW" {
+							return true
+						}
+						return x86ResultTransfer(ins, state, owned, offset, arch)
+					}, func(state x86ResultState, _ int) error {
+						checked = true
+						if state.direction != row.want {
+							return fmt.Errorf("joined DF=%d, want %d", state.direction, row.want)
+						}
+						return nil
+					})
+				if err != nil || !checked {
+					t.Fatal("complete source DF fact or final revocation lost", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86DirectionMalformedDeadSourceCannotBorrowNumericalProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, malformed := range []string{"CLD AX", "STD $1", "CLD.Z", "STD (AX)"} {
+			t.Run(arch+"/"+strings.ReplaceAll(malformed, " ", "_"), func(t *testing.T) {
+				declaration := "func view(x,prior uint32) uint32\n"
+				body := "JMP good\n" + malformed + "\ngood:\nMOVL x+0(FP),AX\nMOVL prior+4(FP),BX\nBSFL AX,BX\nMOVL BX,ret+RESULT(FP)"
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, false)
+			})
+		}
+	}
+}
+
+func TestX86DirectionLoweredStringCompleteFamilyConsumesDirection(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, kind := range []string{"MOVS", "STOS", "SCAS", "CMPS", "LODS"} {
+			for _, width := range []string{"B", "W", "L", "Q"} {
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					for _, direction := range []string{"CLD", "STD"} {
+						op := Op(kind + width)
+						t.Run(arch+"/"+string(op)+"/"+prefix+"/"+direction, func(t *testing.T) {
+							// Existing emitter-only role: this verifies the virtual DF
+							// handoff, not a repeated-memory or source-query grant.
+							var output strings.Builder
+							ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, "", false)
+							ctx.directionSlot = "%direction"
+							if known, err := ctx.lowerDirectionControl(x86ScalarLaneInstruction(t, direction)); !known || err != nil {
+								t.Fatal(err)
+							}
+							ctx.repeatPrefix = prefix
+							known, _, err := ctx.lowerString(x86ScalarLaneInstruction(t, string(op)))
+							if !known || arch == "386" && width == "Q" && err == nil || !(arch == "386" && width == "Q") && err != nil {
+								t.Fatal("complete string grammar changed", err)
+							}
+							if arch == "386" && width == "Q" {
+								return
+							}
+							ir := output.String()
+							want := "store i1 false, ptr %direction"
+							if direction == "STD" {
+								want = "store i1 true, ptr %direction"
+							}
+							if !strings.Contains(ir, want) || !strings.Contains(ir, "load i1, ptr %direction") || !strings.Contains(ir, "i1 %") || ctx.repeatPrefix != "" {
+								t.Fatal("string helper bypassed actual direction/prefix consumption", ir)
+							}
+							if prefix != "" && (kind == "SCAS" || kind == "CMPS") && strings.Count(ir, "select i1") < 6 {
+								t.Fatal("zero-count repeat discarded incoming six-status flags", ir)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86DirectionControlPreservesSixStatusButGrantsNoEntryFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, direction := range []string{"CLD", "STD"} {
+			for _, field := range []struct{ name, set string }{
+				{"CF", "SETCS"}, {"PF", "SETPS"}, {"AF", ""},
+				{"ZF", "SETEQ"}, {"SF", "SETMI"}, {"OF", "SETOS"},
+			} {
+				if field.set == "" {
+					continue // AF has no SETcc encoding; the byte-state test covers it.
+				}
+				for _, initialized := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/producer=%t", arch, direction, field.name, initialized), func(t *testing.T) {
+						body := direction + "\n" + field.set + " AL\nMOVB AL,ret+RESULT(FP)"
+						if initialized {
+							body = "MOVL $3,AX\nCMPL AX,$1\n" + body
+						}
+						decl := "func view() byte\n"
+						source := x86ResultGPSIMDAdmissionSource(t, arch, decl, body)
+						pkg := mustGoPackage(t, "bitview", "package bitview\n"+decl)
+						sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+						if err != nil {
+							t.Fatal(err)
+						}
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, query := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+							err := query(file.Funcs[0], sig, arch)
+							if initialized && err != nil || !initialized && !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("DF was confused with incoming numerical/status facts", err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_duplicate_move_format_test.go b/x86_duplicate_move_format_test.go
new file mode 100644
index 000000000..19718ce55
--- /dev/null
+++ b/x86_duplicate_move_format_test.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Original Go objects and public Context checks belong to the caller. This
+// private object unit proves formats only, never numerical or physical entry.
+func x86DuplicateMoveFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			form, known, err := x86DuplicateMoveProperties(ins.Op, ins, arch)
+			if errors.Is(err, ErrProbeNeedsContext) && arch == "386" && x86Mode32VectorRegisterContext(ins, arch) != nil {
+				// Go's accepted high X/Y names have no bound mode32 physical
+				// identity. Its preserved object witnesses the actual encoding;
+				// a private vector-format carrier cannot grant that public role.
+				form, known, err = x86DuplicateMoveProperties(ins.Op, ins, "amd64")
+			}
+			if !known || err != nil {
+				return known, false, err
+			}
+			return true, false, c.emitDuplicateMove(ins, form)
+		})
+}
diff --git a/x86_duplicate_move_forms_test.go b/x86_duplicate_move_forms_test.go
new file mode 100644
index 000000000..779984321
--- /dev/null
+++ b/x86_duplicate_move_forms_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86DuplicateMoveEverySelectedByteAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86DuplicateMoveOracle {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if !row.vector && bank != "X" {
+					continue
+				}
+				for _, masking := range []string{"plain", "merge", "zero"} {
+					if !row.vector && masking != "plain" {
+						continue
+					}
+					t.Run(arch+"/"+row.name+"/"+bank+"/"+masking, func(t *testing.T) {
+						op, mask := row.name, ""
+						if masking != "plain" {
+							mask = "K3,"
+						}
+						if masking == "zero" {
+							op += ".Z"
+						}
+						ins := x86YMMReadSource(t, fmt.Sprintf("%s %s0,%s%s2", op, bank, mask, bank))
+						width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+						var required uint64
+						for offset := 0; offset < width; offset++ {
+							lane := offset / row.bytes
+							if lane%2 == 0 != row.odd {
+								required |= uint64(1) << uint(offset)
+							}
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+							fp: []bool{true, false}, auto: []bool{false, true}}
+						state.xmm[0], state.vectorUpper[0] = uint16(required), required&^0xffff
+						state.xmm[2], state.vectorUpper[2] = 0xffff, 0xa55aa55aa55a0000
+						if masking == "merge" {
+							state.vectorUpper[2] = ^uint64(0xffff)
+						}
+						state.masks[3], state.pointerGP[6], state.callerAddressGP[6] = true, true, true
+						state.gp[4], state.canonicalGP[4] = 0x81, 0xa5
+						before, expected := state.clone(), state.clone()
+						expected.xmm[2] = 0xffff
+						if row.vector {
+							expected.vectorUpper[2] = ^uint64(0xffff)
+						}
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, expected) {
+							t.Fatal("selected bytes did not close, or GP/status/DF/storage/aliases changed")
+						}
+						for missing := 0; missing < width; missing++ {
+							if required>>uint(missing)&1 == 0 {
+								continue // These source bytes were deliberately unknown in the positive.
+							}
+							current := before.clone()
+							if missing < 16 {
+								current.xmm[0] &^= 1 << uint(missing)
+							} else {
+								current.vectorUpper[0] &^= uint64(1) << uint(missing)
+							}
+							initial := current.clone()
+							if accepted, known := x86ResultDuplicateMoveStep(ins, &current, nil, arch, false); !known || accepted || !reflect.DeepEqual(current, initial) {
+								t.Fatal("unknown selected byte acquired NUM or partially changed a failed state", missing)
+							}
+						}
+						if got := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch); got != before.callerAddressGP {
+							t.Fatal("vector-only output lost or invented a GP address")
+						}
+						if got := x86RegisterCanonicalBytesAfter(ins, before.canonicalGP, arch); got != before.canonicalGP {
+							t.Fatal("vector-only output changed independent bool canonicality")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86DuplicateMoveGrammarRejectsBeforeAnyIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86DuplicateMoveOracle {
+			original := x86YMMReadSource(t, row.name+" X0,X2")
+			for _, control := range []struct {
+				name string
+				edit func(*Instr)
+			}{
+				{"dispatch", func(ins *Instr) { ins.Op = "MOVL" }},
+				{"suffix", func(ins *Instr) { ins.Op += ".BCST" }},
+				{"missing", func(ins *Instr) { ins.Args = nil }},
+				{"immediate", func(ins *Instr) { ins.Args[0] = Operand{Kind: OpImm, Imm: 0} }},
+				{"gp-source", func(ins *Instr) { ins.Args[0] = Operand{Kind: OpReg, Reg: AX} }},
+				{"gp-output", func(ins *Instr) { ins.Args[1] = Operand{Kind: OpReg, Reg: AX} }},
+				{"memory-output", func(ins *Instr) { ins.Args[1] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}} }},
+				{"width", func(ins *Instr) { ins.Args[0] = Operand{Kind: OpReg, Reg: "Y0"} }},
+				{"mask-zero", func(ins *Instr) { ins.Args = []Operand{ins.Args[0], {Kind: OpReg, Reg: "K0"}, ins.Args[1]} }},
+				{"scale", func(ins *Instr) { ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX, Index: CX, Scale: 3}} }},
+			} {
+				t.Run(arch+"/"+row.name+"/"+control.name, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					control.edit(&ins)
+					var output strings.Builder
+					ctx := &amd64Ctx{b: &output, goarch: arch}
+					if known, terminated, err := ctx.lowerDuplicateMove(Op(row.name), ins); !known || terminated || err == nil || output.Len() != 0 || ctx.tmp != 0 {
+						t.Fatal("malformed grammar emitted or read a source before rejection", err, output.String())
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_duplicate_move_native_driver_test.go b/x86_duplicate_move_native_driver_test.go
new file mode 100644
index 000000000..25a647637
--- /dev/null
+++ b/x86_duplicate_move_native_driver_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import "fmt"
+
+func x86DuplicateNativeValuesC(prototypes, rows string) string {
+	return fmt.Sprintf(x86DuplicateValuesC, prototypes, rows)
+}
+
+const x86DuplicateValuesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+%s
+struct kernel {
+    void (*run)(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);
+    unsigned width,lane,odd,legacy,masked,zeroing;
+};
+static const struct kernel kernels[]={%s};
+static const uint64_t patterns[]={0,UINT64_C(0x8000000000000000),
+    UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),
+    UINT64_C(0x7ff0000000000001),UINT64_C(0x7ff8000000000001),
+    UINT64_C(0x7f8000017fc00001),UINT64_C(0xffffffff11223344)};
+static const uint64_t masks[]={0,1,2,UINT64_C(0x5555555555555555),
+    UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX};
+int main(void) {
+    unsigned count=0,saved=_mm_getcsr();
+    for (unsigned row=0;row<sizeof(kernels)/sizeof(kernels[0]);row++) {
+        struct kernel k=kernels[row];
+        for (unsigned sample=0;sample<16;sample++) for (unsigned m=0;m<6;m++) {
+            _Alignas(64) uint8_t storage[160],old[64],out[96],expected[96];
+            uint8_t *input=storage+(k.legacy&&k.lane==4?0:sample%%16);
+            memset(storage,0xa7,sizeof(storage));
+            for (unsigned i=0;i<64;i++) old[i]=(uint8_t)(sample*19+i*43+0x5a);
+            for (unsigned i=0;i<64;i+=8) {
+                uint64_t word=patterns[(sample+i/8)%%8];
+                for (unsigned j=0;j<8;j++) input[i+j]=(uint8_t)(word>>(j*8));
+            }
+            uint8_t beforeStorage[160],beforeOld[64];
+            memcpy(beforeStorage,storage,sizeof(storage));memcpy(beforeOld,old,sizeof(old));
+            memset(out,0xc3,sizeof(out));memset(expected,0xc3,sizeof(expected));
+            memset(expected,0,64);
+            if (k.legacy) memcpy(expected,old,64);
+            for (unsigned byte=0;byte<k.width;byte++) {
+                unsigned lane=byte/k.lane,selected=k.odd?(lane|1):(lane&~1u);
+                if (!k.masked || (masks[m]>>lane&1)) expected[byte]=input[selected*k.lane+byte%%k.lane];
+                else expected[byte]=k.zeroing?0:old[byte];
+            }
+            uint32_t flags=0x444,profile=0x1f80|((sample%%4)<<13)|(sample%%64);
+            memcpy(expected+64,&flags,4);memcpy(expected+68,&profile,4);
+            _mm_setcsr(profile);
+            kernels[row].run(out,input,old,masks[m]);
+            uint32_t after=_mm_getcsr();_mm_setcsr(saved);
+            if (memcmp(out,expected,sizeof(out)) || after!=profile ||
+                    memcmp(storage,beforeStorage,sizeof(storage)) || memcmp(old,beforeOld,sizeof(old))) {
+                fprintf(stderr,"duplicate row=%%u sample=%%u mask=%%u MXCSR=%%x expected=%%x\n",row,sample,m,after,profile);
+                for (unsigned byte=0;byte<sizeof(out);byte++) if (out[byte]!=expected[byte])
+                    fprintf(stderr,"byte %%u got %%02x want %%02x\n",byte,out[byte],expected[byte]);
+                return 1;
+            }
+            count++;
+        }
+    }
+    printf("duplicate whole64/FLAGS/DF/MXCSR/canary outcomes %%u failures 0\n",count);
+    return 0;
+}
+`
+
+const x86DuplicateOriginalGo = `package oracle
+import (
+    "encoding/binary"
+    "runtime"
+    "testing"
+    "unsafe"
+)
+type kernel struct {
+    run func(*[96]byte,*[64]byte,*[64]byte,uint64)
+    width,lane,odd,legacy,masked,zeroing int
+}
+var kernels=[]kernel{%s}
+func TestOriginal(t *testing.T) {
+    runtime.LockOSThread();defer runtime.UnlockOSThread()
+    saved:=MXCSR(0x1f80);defer MXCSR(saved)
+    patterns:=[]uint64{0,0x8000000000000000,0x7ff0000000000000,0xfff0000000000000,
+        0x7ff0000000000001,0x7ff8000000000001,0x7f8000017fc00001,0xffffffff11223344}
+    masks:=[]uint64{0,1,2,0x5555555555555555,0xaaaaaaaaaaaaaaaa,^uint64(0)}
+    count:=0
+    for row,k:=range kernels {
+        for sample:=0;sample<16;sample++ {for _,mask:=range masks {
+            var storage [128]byte
+            offset:=int((16-uintptr(unsafe.Pointer(&storage[0]))%%16)%%16)
+            input:=(*[64]byte)(unsafe.Pointer(&storage[offset]))
+            var old [64]byte
+            var out,expected [96]byte
+            for i:=range old {old[i]=byte(sample*19+i*43+0x5a)}
+            for i:=0;i<64;i+=8 {binary.LittleEndian.PutUint64(input[i:],patterns[(sample+i/8)%%8])}
+            beforeInput,beforeOld:=*input,old
+            for i:=range out {out[i],expected[i]=0xc3,0xc3}
+            for i:=0;i<32;i++ {expected[i]=0;if k.legacy!=0 {expected[i]=old[i]}}
+            for i:=0;i<k.width;i++ {
+                lane:=i/k.lane;selected:=lane&^1;if k.odd!=0 {selected=lane|1}
+                expected[i]=input[selected*k.lane+i%%k.lane]
+            }
+            profile:=uint32(0x1f80|((sample%%4)<<13)|(sample%%64))
+            binary.LittleEndian.PutUint32(expected[64:],0x444)
+            binary.LittleEndian.PutUint32(expected[68:],profile)
+            MXCSR(profile)
+            k.run(&out,input,&old,mask)
+            after:=MXCSR(saved)
+            if out!=expected || after!=profile || *input!=beforeInput || old!=beforeOld {
+                t.Fatalf("actual Go duplicate row=%%d sample=%%d got=%%x want=%%x MXCSR=%%x/%%x",row,sample,out,expected,after,profile)
+            }
+            count++
+        }}
+    }
+    if len(kernels)!=18 || count!=1728 {t.Fatal("incomplete original Go runtime",len(kernels),count)}
+    t.Logf("actual original Go duplicate whole32/FLAGS/DF/MXCSR/canary outcomes %%d failures 0",count)
+}
+`
+
+func x86DuplicateNativeFaultsC(prototypes, rows string) string {
+	return x86MemoryFaultSupportC + prototypes + `
+struct kernel {
+    void (*run)(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);
+    unsigned bytes,aligned_kind;
+};
+static const struct kernel kernels[]={` + rows + `};
+int main(int argc,char **argv) {
+    unsigned sample,probe,original;char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&sample,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 || sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            sample>=2*sizeof(kernels)/sizeof(kernels[0]) || probe>18 || original>1) return 80;
+    struct kernel k=kernels[sample/2];
+    uint64_t mask=sample%2?UINT64_MAX:0;
+    if (memory_fault_setup(0)) return 81;
+    const uint8_t *input=NULL;
+    if (probe==1) input=guard+page-k.bytes+1;
+    else if (probe==2 || probe==3) input=guard+page-k.bytes;
+    else if (probe>=4) input=guard+probe-3;
+    if (probe==3) {
+#ifdef _WIN32
+        DWORD old;if (!VirtualProtect(guard,page,PAGE_READONLY,&old)) return 82;
+#else
+        if (mprotect(guard,page,PROT_READ)) return 82;
+#endif
+    }
+    _Alignas(64) uint8_t out[96],old[64];
+    memset(out,0xc3,sizeof(out));memset(old,0x5a,sizeof(old));
+    printf("memory enter %u %u %u\n",sample,probe,original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        if (k.aligned_kind==1) __asm__ volatile("movshdup (%0),%%xmm0"::"r"(input):"xmm0","memory");
+        else if (k.aligned_kind==2) __asm__ volatile("movsldup (%0),%%xmm0"::"r"(input):"xmm0","memory");
+        else for (unsigned i=0;i<k.bytes;i++) (void)((const volatile uint8_t *)input)[i];
+    } else k.run(out,input,old,mask);
+    for (unsigned i=0;i<sizeof(out);i++) if (out[i]!=0xc3) return 84;
+    for (unsigned i=0;i<sizeof(old);i++) if (old[i]!=0x5a) return 85;
+    if (free_guard()) return 86;
+    puts("memory complete");
+    return fflush(stdout)?87:0;
+}
+`
+}
diff --git a/x86_duplicate_move_native_linux_amd64_test.go b/x86_duplicate_move_native_linux_amd64_test.go
new file mode 100644
index 000000000..c925c6d6a
--- /dev/null
+++ b/x86_duplicate_move_native_linux_amd64_test.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.compiler = append(execution.compiler, "-msse3")
+	execution.requireAVX(t)
+	x86RunDuplicateMoveNative(t, execution, "amd64")
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86DuplicateMoveOriginalGoAndNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required native mode32 duplicate tools: LLVM22=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie", "-msse3"}}
+	execution.requireAVX(t)
+	x86RunDuplicateMoveNative(t, execution, "386")
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_duplicate_move_native_source_test.go b/x86_duplicate_move_native_source_test.go
new file mode 100644
index 000000000..1aa8b9a0e
--- /dev/null
+++ b/x86_duplicate_move_native_source_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func TestX86DuplicateNativeActualSourceOwnsExactlyOnePackage(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			program := x86BuildDuplicateNativeProgram(arch)
+			for _, fixture := range []struct {
+				name, source, pkg string
+				functions         int
+			}{
+				{"api.go", "package bitview\n" + program.declarations, "bitview", 90},
+				{"original.go", program.originalDeclarations + "func MXCSR(value uint32) uint32\n", "oracle", 19},
+				{"original_test.go", fmt.Sprintf(x86DuplicateOriginalGo, program.originalRows), "oracle", 1},
+			} {
+				t.Run(fixture.name, func(t *testing.T) {
+					file, err := parser.ParseFile(token.NewFileSet(), fixture.name, fixture.source, parser.AllErrors)
+					if err != nil {
+						t.Fatal("actual native fixture is not a valid Go file", err)
+					}
+					functions := 0
+					for _, declaration := range file.Decls {
+						if _, ok := declaration.(*ast.FuncDecl); ok {
+							functions++
+						}
+					}
+					if file.Name.Name != fixture.pkg || functions != fixture.functions {
+						t.Fatal("native declaration inventory changed", file.Name.Name, functions)
+					}
+					for _, broken := range []string{
+						"package other\n" + fixture.source,
+						strings.TrimPrefix(fixture.source, "package "+fixture.pkg+"\n"),
+					} {
+						if _, err := parser.ParseFile(token.NewFileSet(), fixture.name, broken, parser.AllErrors); err == nil {
+							t.Fatal("source guard accepted a duplicate or absent package clause")
+						}
+					}
+				})
+			}
+			if strings.Count(program.source, "TEXT ·Copy") != 60 ||
+				strings.Count(program.source, "TEXT ·DeadCopy") != 30 ||
+				strings.Count(program.originalSource, "TEXT ·Copy") != 18 ||
+				len(program.faultAligned) != 30 {
+				t.Fatal("complete native live/dead/original inventory changed")
+			}
+		})
+	}
+}
+
+func TestX86DivideNativeActualSourceOwnsExactlyOnePackage(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86DivideNativeRows(arch)
+			declarations, original := x86DivideNativeDeclarationSources(rows)
+			for _, fixture := range []struct{ name, source, pkg string }{
+				{"api.go", "package bitview\n" + declarations, "bitview"},
+				{"original.go", original, "oracle"},
+			} {
+				t.Run(fixture.name, func(t *testing.T) {
+					file, err := parser.ParseFile(token.NewFileSet(), fixture.name, fixture.source, parser.AllErrors)
+					if err != nil {
+						t.Fatal("actual division fixture is not a valid Go file", err)
+					}
+					if file.Name.Name != fixture.pkg || len(file.Decls) != len(rows)*2 {
+						t.Fatal("division live/dead declaration inventory changed", file.Name.Name, len(file.Decls))
+					}
+					for _, broken := range []string{
+						"package other\n" + fixture.source,
+						strings.TrimPrefix(fixture.source, "package "+fixture.pkg+"\n"),
+					} {
+						if _, err := parser.ParseFile(token.NewFileSet(), fixture.name, broken, parser.AllErrors); err == nil {
+							t.Fatal("division guard accepted a duplicate or absent package clause")
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_duplicate_move_runtime_test.go b/x86_duplicate_move_runtime_test.go
new file mode 100644
index 000000000..7a2bad43b
--- /dev/null
+++ b/x86_duplicate_move_runtime_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+type x86DuplicateNativeRow struct {
+	name, op, bank      string
+	width, laneBytes    int
+	odd, legacy, memory bool
+	masked, zeroing     bool
+}
+
+func x86DuplicateNativeRows() []x86DuplicateNativeRow {
+	var rows []x86DuplicateNativeRow
+	for _, spec := range x86DuplicateMoveOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if !spec.vector && bank != "X" {
+				continue
+			}
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if !spec.vector && mode != "plain" {
+					continue
+				}
+				for _, memory := range []bool{false, true} {
+					rows = append(rows, x86DuplicateNativeRow{
+						name: fmt.Sprint("Copy", len(rows)), op: spec.name, bank: bank,
+						width: map[string]int{"X": 16, "Y": 32, "Z": 64}[bank], laneBytes: spec.bytes,
+						odd: spec.odd, legacy: !spec.vector, memory: memory,
+						masked: mode != "plain", zeroing: mode == "zero",
+					})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86DuplicateNativeAssembly(row x86DuplicateNativeRow, arch string, originalGo, dead bool) string {
+	word, move, push, pop := 8, "MOVQ", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		word, move, push, pop = 4, "MOVL", "PUSHFL", "POPL"
+	}
+	name, wide, input, operation, mask := row.name, "Z", row.bank+"0", row.op, ""
+	if originalGo {
+		wide = "Y" // The actual Go runtime subset is legacy + VEX, never unexecuted EVEX.
+	}
+	if dead {
+		name = "Dead" + name
+	}
+	if row.memory {
+		input = "(BX)"
+	}
+	if row.masked {
+		mask = "K1,"
+	}
+	if row.zeroing {
+		operation += ".Z"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),AX\n%s input+%d(FP),BX\n%s old+%d(FP),CX\n",
+		name, 3*word+8, move, move, word, move, 2*word)
+	if row.masked {
+		fmt.Fprintf(&source, "KMOVD mask+%d(FP),K1\n", 3*word)
+	}
+	load, store := "VMOVDQU64", "VMOVDQU64"
+	if originalGo {
+		load, store = "VMOVUPS", "VMOVUPS"
+	}
+	if !row.memory {
+		fmt.Fprintf(&source, "%s (BX),%s0\n", load, wide)
+	}
+	fmt.Fprintf(&source, "%s (CX),%s2\nMOVL $3,DX\nCMPL DX,$3\nSTD\n%s %s,%s%s2\n",
+		load, wide, operation, input, mask, row.bank)
+	if dead {
+		source.WriteString("CLD\nRET\n")
+		return source.String()
+	}
+	// ID and unrelated FLAGS bits are intentionally unknown. Project the
+	// declared status/DF bits immediately after POP, while its precise bit
+	// witness is live, then clear DF before any whole-vector memory transport.
+	fmt.Fprintf(&source, "%s\n%s DX\nANDL $0xcd5,DX\nCLD\n%s %s2,(AX)\nMOVL DX,64(AX)\nSTMXCSR 68(AX)\nRET\n",
+		push, pop, store, wide)
+	return source.String()
+}
+
+func TestX86DuplicateMoveIndependentNativeDirectory(t *testing.T) {
+	rows, memory, originalGo := x86DuplicateNativeRows(), 0, 0
+	for _, row := range rows {
+		if row.memory {
+			memory++
+		}
+		if row.legacy || !row.masked && row.width < 64 {
+			originalGo++
+		}
+		if row.width%row.laneBytes != 0 || row.laneBytes != 4 && row.laneBytes != 8 {
+			t.Fatal("invalid independent lane/width directory", row)
+		}
+	}
+	if len(rows) != 60 || memory != 30 || len(rows)+memory > 96 || originalGo != 18 {
+		t.Fatal("complete native/actual-Go matrix changed", len(rows), memory, originalGo)
+	}
+}
+
+func TestX86DuplicateMoveNativeSourceFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			program := x86BuildDuplicateNativeProgram(target.arch)
+			if strings.Count(program.source, "TEXT ·") != 90 {
+				t.Fatal("complete initialized live/dead native source changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, program.source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, program.source, program.declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete native runtime source lost initialized data/FLAGS/MXCSR/storage", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "duplicate-runtime.ll", "duplicate-runtime.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+type x86DuplicateNativeProgram struct {
+	source, declarations, prototypes, cRows, faultRows string
+	originalSource, originalDeclarations, originalRows string
+	faultAligned                                       []bool
+}
+
+// Keep the exact native fixture available to host-independent source checks.
+// Building it must not require an x86 execution host or hide a failed oracle.
+func x86BuildDuplicateNativeProgram(arch string) x86DuplicateNativeProgram {
+	rows := x86DuplicateNativeRows()
+	var source, declarations, prototypes, cRows, faultRows strings.Builder
+	var originalSource, originalDeclarations, originalRows strings.Builder
+	var faultAligned []bool
+	originalDeclarations.WriteString("package oracle\n")
+	flag := func(value bool) int {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	for _, row := range rows {
+		declaration := fmt.Sprintf("func %s(out *[96]byte,input,old *[64]byte,mask uint64)\n", row.name)
+		declarations.WriteString(declaration)
+		source.WriteString(x86DuplicateNativeAssembly(row, arch, false, false))
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", row.name)
+		fields := fmt.Sprintf("%d,%d,%d,%d,%d,%d", row.width, row.laneBytes,
+			flag(row.odd), flag(row.legacy), flag(row.masked), flag(row.zeroing))
+		fmt.Fprintf(&cRows, "{%s,%s},\n", row.name, fields)
+		if row.memory {
+			fmt.Fprintf(&declarations, "func Dead%s(out *[96]byte,input,old *[64]byte,mask uint64)\n", row.name)
+			source.WriteString(x86DuplicateNativeAssembly(row, arch, false, true))
+			fmt.Fprintf(&prototypes, "extern void Dead%s(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", row.name)
+			bytes, aligned := row.width, row.legacy && row.laneBytes == 4
+			if row.laneBytes == 8 && row.width == 16 {
+				bytes = 8
+			}
+			faultAligned = append(faultAligned, aligned)
+			kind := 0
+			if aligned && row.odd {
+				kind = 1
+			} else if aligned {
+				kind = 2
+			}
+			fmt.Fprintf(&faultRows, "{Dead%s,%d,%d},\n", row.name, bytes, kind)
+		}
+		if row.legacy || !row.masked && row.width < 64 {
+			originalSource.WriteString(x86DuplicateNativeAssembly(row, arch, true, false))
+			originalDeclarations.WriteString(declaration)
+			fmt.Fprintf(&originalRows, "{%s,%s},\n", row.name, fields)
+		}
+	}
+	return x86DuplicateNativeProgram{
+		source: source.String(), declarations: declarations.String(),
+		prototypes: prototypes.String(), cRows: cRows.String(), faultRows: faultRows.String(),
+		originalSource: originalSource.String(), originalDeclarations: originalDeclarations.String(),
+		originalRows: originalRows.String(), faultAligned: faultAligned,
+	}
+}
+
+func x86RunDuplicateMoveNative(t *testing.T, execution x86FloatCompareExecution, arch string) {
+	t.Helper()
+	program := x86BuildDuplicateNativeProgram(arch)
+	// All 90 complete source kernels are compiled by Go, including the EVEX
+	// rows. Only the separate 18-row AVX/SSE3 source is claimed as Go execution.
+	goAssemblerOracleOutput(t, arch, program.source, "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, program.source, program.declarations, arch, execution.triple, "Go")
+	if err != nil {
+		t.Fatal("complete original duplicate runtime source rejected", err)
+	}
+	valueDriver := x86DuplicateNativeValuesC(program.prototypes, program.cRows)
+	faultDriver := x86DuplicateNativeFaultsC(program.prototypes, program.faultRows)
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			valueExecutable := execution.compileLLVM(t, "duplicate-values", pipeline.ir, valueDriver, pipeline.level)
+			var output []byte
+			if arch == "386" {
+				output = x87IA32RunDirect(t, x86NativeOracleIA32Executable(t, execution, valueExecutable), nil, os.Environ())
+			} else {
+				output = execution.run(t, valueExecutable)
+			}
+			if string(output) != "duplicate whole64/FLAGS/DF/MXCSR/canary outcomes 5760 failures 0\n" {
+				t.Fatal("independent complete byte model mismatch", string(output))
+			}
+			executable := execution.compileLLVM(t, "duplicate-faults", pipeline.ir, faultDriver, pipeline.level)
+			var ia32 *x87IA32Executable
+			if arch == "386" {
+				program := x86NativeOracleIA32Executable(t, execution, executable)
+				ia32 = &program
+			}
+			for row, aligned := range program.faultAligned {
+				for mask := 0; mask < 2; mask++ {
+					probes := 5
+					if aligned {
+						probes = 19 // Every misaligned residue modulo 16, not just +1.
+					}
+					for probe := 0; probe < probes; probe++ {
+						index := row*2 + mask
+						observe := func(original int) string {
+							if ia32 != nil {
+								if err := ia32.verify(); err != nil {
+									t.Fatal(err)
+								}
+							}
+							result := x86ObserveMemoryFault(t, execution, executable, index, probe, original)
+							if ia32 != nil {
+								if err := ia32.verify(); err != nil {
+									t.Fatal(err)
+								}
+							}
+							return result
+						}
+						want := observe(1)
+						faults := probe < 2 || aligned && probe >= 4
+						if faults && want != "segv" && want != "bus" || !faults && want != "return" {
+							t.Fatal("independent native access had an unexpected result", row, mask, probe, want)
+						}
+						if got := observe(0); got != want {
+							t.Fatal("dead duplicate lost NF tuple or original alignment fault", row, mask, probe, got, want)
+						}
+					}
+				}
+			}
+			t.Logf("duplicate native arch=%s live=60 dead=30 whole64-outcomes=5760 fault-processes=712; legacy original opcode/all mod16, E4NF/E5NF independent full-span references", arch)
+		})
+	}
+	t.Run("OriginalGo", func(t *testing.T) {
+		declarations := program.originalDeclarations + "func MXCSR(value uint32) uint32\n"
+		source := program.originalSource + x86OriginalNativeMXCSRSource(arch)
+		x86RunOriginalGoNativeSource(t, execution, arch, declarations, source,
+			fmt.Sprintf(x86DuplicateOriginalGo, program.originalRows))
+		t.Log("actual original Go legacy/VEX: 18 rows × 16 IEEE/bit patterns × 6 masks = 1728 whole32/FLAGS/DF/MXCSR/canary outcomes; no EVEX execution claim")
+	})
+}
diff --git a/x86_duplicate_move_tdd_test.go b/x86_duplicate_move_tdd_test.go
new file mode 100644
index 000000000..46cd017e6
--- /dev/null
+++ b/x86_duplicate_move_tdd_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This directory is independent of both the existing raw decoder and lowerer.
+// DDUP selects even qwords; SH/SLDUP select odd/even dwords respectively.
+var x86DuplicateMoveOracle = []struct {
+	name   string
+	bytes  int
+	odd    bool
+	vector bool
+}{
+	{"MOVDDUP", 8, false, false}, {"MOVSHDUP", 4, true, false}, {"MOVSLDUP", 4, false, false},
+	{"VMOVDDUP", 8, false, true}, {"VMOVSHDUP", 4, true, true}, {"VMOVSLDUP", 4, false, true},
+}
+
+func TestX86DuplicateMoveCompleteIndependentGoRows(t *testing.T) {
+	read := func(name string) string {
+		t.Helper()
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		return string(data)
+	}
+	legacy, vector := read("asm6.go"), read("avx_optabs.go")
+	for _, table := range []struct{ source, name, rows string }{
+		{legacy, "yxm", `{Zm_r_xm,1,argList{Yxm,Yxr}},`},
+		{vector, "_yvmovddup", `{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yxm,Yxr}},
+{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yym,Yyr}},
+{zcase:Zevex_rm_v_r,zoffset:0,args:argList{YxmEvex,YxrEvex}},
+{zcase:Zevex_rm_k_r,zoffset:3,args:argList{YxmEvex,Yknot0,YxrEvex}},
+{zcase:Zevex_rm_v_r,zoffset:0,args:argList{YymEvex,YyrEvex}},
+{zcase:Zevex_rm_k_r,zoffset:3,args:argList{YymEvex,Yknot0,YyrEvex}},
+{zcase:Zevex_rm_v_r,zoffset:0,args:argList{Yzm,Yzr}},
+{zcase:Zevex_rm_k_r,zoffset:3,args:argList{Yzm,Yknot0,Yzr}},`},
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table.name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(table.source)
+		if len(match) != 2 || strings.Join(strings.Fields(match[1]), "") != strings.Join(strings.Fields(table.rows), "") {
+			t.Fatal("complete duplicate-move Go operand rows changed", table.name)
+		}
+	}
+	for _, row := range []struct{ name, prefix, opcode, scale string }{
+		{"MOVDDUP", "Pf2", "0x12", "evexN8"},
+		{"MOVSHDUP", "Pf3", "0x16", "evexN16"},
+		{"MOVSLDUP", "Pf3", "0x12", "evexN16"},
+	} {
+		if !strings.Contains(legacy, "{A"+row.name+", yxm, "+row.prefix+", opBytes{"+row.opcode+"}}") {
+			t.Fatal("legacy duplicate-move prefix/operation changed", row.name)
+		}
+		match := regexp.MustCompile(`(?s)\{as: AV` + row.name + `, ytab: _yvmovddup, prefix: Pavx, op: opBytes\{(.*?)\n\s*\}\}`).FindStringSubmatch(vector)
+		if len(match) != 2 || strings.Count(match[1], "avxEscape") != 5 ||
+			!strings.Contains(match[1], row.scale+" | evexZeroingEnabled") ||
+			!strings.Contains(match[1], "evexN32 | evexZeroingEnabled") ||
+			!strings.Contains(match[1], "evexN64 | evexZeroingEnabled") {
+			t.Fatal("VEX/EVEX duplicate-move width/mask/memory tuple changed", row.name)
+		}
+	}
+}
+
+func TestX86DuplicateMoveInitializedFamilyFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86DuplicateMoveOracle {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if !row.vector && bank != "X" {
+						continue
+					}
+					for _, masking := range []string{"plain", "merge", "zero"} {
+						if !row.vector && masking != "plain" {
+							continue
+						}
+						for _, memory := range []bool{false, true} {
+							name, operation, mask := fmt.Sprint("Duplicate", count), row.name, ""
+							if masking != "plain" {
+								mask = "K1,"
+							}
+							if masking == "zero" {
+								operation += ".Z"
+							}
+							input := bank + "0"
+							if memory {
+								input = "(BX)"
+							}
+							fmt.Fprintf(&declarations, "func %s(out,input,old *[64]byte,mask uint64)\n", name)
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),AX\n%s input+%d(FP),BX\n%s old+%d(FP),CX\nKMOVD mask+%d(FP),K1\nVMOVDQU64 (BX),Z0\nVMOVDQU64 (CX),Z2\n%s %s,%s%s2\nVMOVDQU64 Z2,(AX)\nRET\n",
+								name, 3*word+8, move, move, word, move, 2*word, 3*word, operation, input, mask, bank)
+							count++
+						}
+					}
+				}
+			}
+			if count != 60 {
+				t.Fatal("complete independent duplicate-move width/mask/source matrix changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original duplicate family lost its result or native read", api, err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "duplicate-family.ll", "duplicate-family.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86DuplicateMoveDeadVoidRetainsInputAndMaskObligations(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86DuplicateMoveOracle {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if !row.vector && bank != "X" {
+					continue
+				}
+				for _, unused := range []bool{false, true} {
+					for _, control := range []string{"source", "mask", "merge"} {
+						if !row.vector && control != "source" {
+							continue
+						}
+						t.Run(fmt.Sprintf("%s/%s/%s/unused=%t/%s", target.triple, row.name, bank, unused, control), func(t *testing.T) {
+							declaration, extent := "func Value()", 0
+							if unused {
+								declaration, extent = "func Value(unused bool)", 1
+							}
+							setup, mask := "VPXORQ Z2,Z2,Z2\n", ""
+							if control != "source" {
+								setup += "VPXORQ Z0,Z0,Z0\n"
+								mask = "K1,"
+								if control == "merge" {
+									setup = "VPXORQ Z0,Z0,Z0\nMOVL $1,AX\nKMOVD AX,K1\n"
+								}
+							}
+							source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s %s0,%s%s2\nRET\n", extent, setup, row.name, bank, mask, bank)
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+								if target.arch == "amd64" && unused && control != "mask" {
+									x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("dead duplicate operation borrowed unknown data/mask/merge bytes", api, err)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86DuplicateMoveDeadMemoryKeepsExactAccessAfterO2(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86DuplicateMoveOracle {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if !row.vector && bank != "X" {
+					continue
+				}
+				t.Run(target.triple+"/"+row.name+"/"+bank, func(t *testing.T) {
+					word, move, operation, mask := goWordSize(target.arch), "MOVQ", row.name, ""
+					if target.arch == "386" {
+						move = "MOVL"
+					}
+					if row.vector {
+						operation, mask = operation+".Z", "K1,"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),SI\nMOVL $0,AX\nKMOVD AX,K1\n%s (SI),%s%s2\nRET\n", word, move, operation, mask, bank)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", target.arch, target.triple, "Go")
+					if err != nil {
+						t.Fatal("actual incoming address did not retain a dead native access", err)
+					}
+					width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+					if row.bytes == 8 && bank == "X" {
+						width = 8
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if !row.vector && row.bytes == 4 {
+							if !strings.Contains(body, `asm sideeffect "`+strings.ToLower(row.name)+` `) || !strings.Contains(body, `~{memory}`) {
+								t.Fatal("legacy Type4 aligned memory fault was replaced by an ordinary or stronger access")
+							}
+						} else if !x86DuplicateMoveExactVolatileRead(body, width) &&
+							!strings.Contains(body, `asm sideeffect "`+strings.ToLower(row.name)+` `) {
+							t.Fatal("E4NF/E5NF dead or zero-mask access vanished or shrank", width, body)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86DuplicateMoveExactVolatileRead(ir string, width int) bool {
+	if strings.Contains(ir, fmt.Sprintf("load volatile i%d", width*8)) ||
+		width == 8 && strings.Contains(ir, "load volatile double") {
+		return true
+	}
+	for _, element := range []struct {
+		name string
+		bits int
+	}{{"i8", 8}, {"i16", 16}, {"i32", 32}, {"i64", 64}, {"float", 32}, {"double", 64}} {
+		if strings.Contains(ir, fmt.Sprintf("load volatile <%d x %s>", width*8/element.bits, element.name)) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/x86_duplicate_move_wig_test.go b/x86_duplicate_move_wig_test.go
new file mode 100644
index 000000000..661964f7d
--- /dev/null
+++ b/x86_duplicate_move_wig_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol. 2B specifies VEX.128/256 WIG for all three opcodes.
+// Go's named optab emits W0, which does not make a raw W1 instruction invalid.
+// These byte witnesses do not use the production or existing raw encoders.
+func x86DuplicateWIGWitnesses(visit func(name, bank string, memory, w bool, code []byte)) {
+	for _, row := range []struct {
+		name           string
+		prefix, opcode byte
+	}{{"VMOVDDUP", 3, 0x12}, {"VMOVSHDUP", 2, 0x16}, {"VMOVSLDUP", 2, 0x12}} {
+		for _, bank := range []string{"X", "Y"} {
+			for _, memory := range []bool{false, true} {
+				for _, w := range []bool{false, true} {
+					bits, operand := byte(0x78|row.prefix), byte(0xd0) // vector0 -> vector2
+					if bank == "Y" {
+						bits |= 4
+					}
+					if memory {
+						operand = 0x13 // (BX) -> vector2
+					}
+					if w {
+						bits |= 0x80
+					}
+					visit(row.name, bank, memory, w, []byte{0xc4, 0xe1, bits, row.opcode, operand})
+				}
+			}
+		}
+	}
+}
+
+func TestDecodeX86DuplicateMoveVEXWIGCompleteShapes(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		count := 0
+		x86DuplicateWIGWitnesses(func(name, bank string, memory, w bool, code []byte) {
+			t.Run(fmt.Sprintf("mode%d/%s/%s/memory=%t/W=%t", mode, name, bank, memory, w), func(t *testing.T) {
+				original := append([]byte(nil), code...)
+				decoded, size, known, err := decodedX86DuplicateMoveInstruction(code, mode)
+				if err != nil || !known || size != len(code) || decoded.Op != Op(name) || len(decoded.Args) != 2 ||
+					decoded.Args[1].Kind != OpReg || decoded.Args[1].Reg != Reg(bank+"2") || !bytes.Equal(code, original) {
+					t.Fatal("official WIG axis changed decoded operation/width/identity", decoded, size, known, err)
+				}
+				if memory {
+					if decoded.Args[0].Kind != OpMem || decoded.Args[0].Mem != (MemRef{Base: BX}) {
+						t.Fatal("WIG memory source changed its exact original address", decoded.Args[0])
+					}
+				} else if decoded.Args[0].Kind != OpReg || decoded.Args[0].Reg != Reg(bank+"0") {
+					t.Fatal("WIG register source changed its original bank", decoded.Args[0])
+				}
+			})
+			count++
+		})
+		if count != 24 {
+			t.Fatal("complete VEX WIG width/address axis changed", count)
+		}
+	}
+}
+
+func TestDecodeX86DuplicateMoveVEXWIGRIPLiteralBoundaries(t *testing.T) {
+	count := 0
+	x86DuplicateWIGWitnesses(func(name, bank string, memory, w bool, witness []byte) {
+		if !memory {
+			return
+		}
+		t.Run(fmt.Sprintf("%s/%s/W=%t", name, bank, w), func(t *testing.T) {
+			width := 16
+			if bank == "Y" {
+				width = 32
+			} else if name == "VMOVDDUP" {
+				width = 8
+			}
+			code := append([]byte(nil), witness...)
+			code[4] = 0x15 // RIP+disp32 -> vector2, not the witness's (BX).
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			for i := 0; i < width; i++ {
+				code = append(code, byte(i*37+3))
+			}
+			original := append([]byte(nil), code...)
+			for _, offset := range []int{0, 3} {
+				t.Run(fmt.Sprintf("offset%d", offset), func(t *testing.T) {
+					input := append(bytes.Repeat([]byte{0x90}, offset), code...)
+					decoded, size, literal, matched, err := decodeX86RawDuplicateMoveRIPData(input, offset, 64)
+					if err != nil || !matched || size != 9 || decoded.Op != Op(name) ||
+						len(decoded.Args) != 2 || decoded.Args[0].Kind != OpSym || decoded.Args[1].Reg != Reg(bank+"2") ||
+						!decoded.x86RIPLiteral || literal != (x86RawLiteralRange{first: offset + 10, last: offset + 10 + width}) ||
+						!bytes.Equal(decoded.x86RIPLiteralData, original[10:]) ||
+						decoded.x86RIPMemoryRead.width != int64(width) ||
+						!bytes.Equal(decoded.x86RIPMemoryRead.object, original[10:]) ||
+						!bytes.Equal(input[offset:], original) {
+						t.Fatal("WIG changed the exact RIP tuple, next-IP, data or immutable source", decoded, size, literal, matched, err)
+					}
+				})
+			}
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, name, map[string]bool{})
+			if err != nil || len(decoded) != 2 || decoded[0].Op != Op(name) ||
+				!decoded[0].x86RIPLiteral || decoded[0].Args[0].Kind != OpSym ||
+				!bytes.Equal(decoded[0].x86RIPLiteralData, original[10:]) || decoded[1].Op != OpRET ||
+				!bytes.Equal(code, original) {
+				t.Fatal("full WIG directive group changed its source-local data or return", decoded, err)
+			}
+			if _, _, _, matched, err := decodeX86RawDuplicateMoveRIPData(code, 0, 32); matched || err != nil {
+				t.Fatal("WIG granted a mode32 absolute address a RIP literal role", matched, err)
+			}
+			absolute, size, matched, err := decodedX86DuplicateMoveInstruction(code, 32)
+			if err != nil || !matched || size != 9 || absolute.Args[0].Kind != OpMem ||
+				absolute.Args[0].Mem != (MemRef{Off: 1}) || absolute.x86RIPLiteral {
+				t.Fatal("mode32 original absolute address changed under WIG", absolute, size, matched, err)
+			}
+			for name, mutate := range map[string]func([]byte) []byte{
+				"truncated tuple": func(input []byte) []byte { return input[:len(input)-1] },
+				"overlap return": func(input []byte) []byte {
+					input[5] = 0
+					return input
+				},
+				"overlap instruction": func(input []byte) []byte {
+					copy(input[5:9], []byte{0xf8, 0xff, 0xff, 0xff})
+					return input
+				},
+				"before source": func(input []byte) []byte {
+					copy(input[5:9], []byte{0xf6, 0xff, 0xff, 0xff})
+					return input
+				},
+				"outside source": func(input []byte) []byte {
+					input[5] = 127
+					return input
+				},
+				"reserved vvvv": func(input []byte) []byte {
+					input[2] &^= 0x08
+					return input
+				},
+				"FS segment":   func(input []byte) []byte { return append([]byte{0x64}, input...) },
+				"GS segment":   func(input []byte) []byte { return append([]byte{0x65}, input...) },
+				"address size": func(input []byte) []byte { return append([]byte{0x67}, input...) },
+			} {
+				t.Run(name, func(t *testing.T) {
+					input := mutate(append([]byte(nil), code...))
+					unchanged := append([]byte(nil), input...)
+					if got, err := decodeX86RawDirectiveGroup(input, 64, 0, name, map[string]bool{}); err == nil {
+						t.Fatal("WIG widened unsafe RIP source permissions", got)
+					}
+					if !bytes.Equal(input, unchanged) {
+						t.Fatal("rejected WIG source mutated its original bytes")
+					}
+				})
+			}
+		})
+		count++
+	})
+	if count != 12 {
+		t.Fatal("incomplete WIG RIP opcode/width/W matrix", count)
+	}
+}
+
+func x86DuplicateWIGOriginalSource() string {
+	var source strings.Builder
+	index := 0
+	x86DuplicateWIGWitnesses(func(_, _ string, _, _ bool, code []byte) {
+		fmt.Fprintf(&source, "TEXT ·WIG%d(SB),4,$0-0\n", index)
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+		source.WriteString("RET\n")
+		index++
+	})
+	return source.String()
+}
+
+func TestTranslateX86DuplicateMoveVEXWIGOriginalFormatsKeepContext(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x86DuplicateWIGOriginalSource()
+			file, signatures := x86UnboundVoidFormatSources(t, source, target.arch, target.triple)
+			normalized, err := normalizeX86RawFile(file, target.arch)
+			if err != nil {
+				t.Fatal("valid WIG bytes could not be normalized without granting raw inputs", err)
+			}
+			ir := x86DuplicateMoveFormatObjectUnit(t, normalized, signatures, target.arch, target.triple)
+			for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				compileLLVMToObject(t, llc, target.triple, "duplicate-wig.ll", "duplicate-wig.o", body)
+			}
+		})
+	}
+}
+
+func TestX86DuplicateMoveVEXWIGIndependentLLVM22Disassembly(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var ir strings.Builder
+			fmt.Fprintf(&ir, "target triple = %q\n", target.triple)
+			index := 0
+			x86DuplicateWIGWitnesses(func(_, _ string, _, _ bool, code []byte) {
+				var operands []string
+				for _, value := range code {
+					operands = append(operands, fmt.Sprintf("%d", value))
+				}
+				fmt.Fprintf(&ir, "define void @WIG%d() {\n call void asm sideeffect %q, \"\"()\n ret void\n}\n",
+					index, ".byte "+strings.Join(operands, ","))
+				index++
+			})
+			directory := t.TempDir()
+			input, object := filepath.Join(directory, "bytes.ll"), filepath.Join(directory, "bytes.o")
+			if err := os.WriteFile(input, []byte(ir.String()), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, llc,
+				"-O2", "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+			cancel()
+			if err != nil {
+				t.Fatalf("exact WIG bytes object failed: %v\n%s", err, output)
+			}
+			stage, cancel = runtimeOracleStageContext(t)
+			output, err = runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, disassembler, "-d", object))
+			cancel()
+			if err != nil {
+				t.Fatalf("independent WIG disassembly failed: %v\n%s", err, output)
+			}
+			for _, name := range []string{"vmovddup", "vmovshdup", "vmovsldup"} {
+				if count := len(regexp.MustCompile(`(?m)\b`+name+`[ \t]+`).FindAll(output, -1)); count != 8 {
+					t.Fatalf("LLVM22 did not independently decode all eight width/address/W forms for %s: %d\n%s", name, count, output)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_dword_product_private_control_test.go b/x86_dword_product_private_control_test.go
new file mode 100644
index 000000000..54fb0f2c9
--- /dev/null
+++ b/x86_dword_product_private_control_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86DwordProductRawPrivateFlagsDoNotInventInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix := goWordSize(target.arch), "Q"
+		if word == 4 {
+			suffix = "L"
+		}
+		for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+			for _, seed := range []string{"", "XORL AX,AX\n", "XORL AX,AX\nCLD\n"} {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nVPXOR X0,X0,X0\nVPXOR X1,X1,X1\n%s%s"+
+					"PUSHF%s\nPOP%s AX\nMOV%s AX,ret+0(FP)\nRET\n", word, seed,
+					x86RawNumericalInstruction(t, target.arch, name+" X0,X1,X2"), suffix, suffix, suffix)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("raw product invented missing full-FLAGS inputs", target.triple, name, seed, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86DwordProductRawPrivateFlagsFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix, move := goWordSize(target.arch), "Q", "MOVQ"
+			if word == 4 {
+				suffix, move = "L", "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86FixedBinaryValueRows(target.arch,
+				[]string{"VPMULDQ", "VPMULUDQ", "VPMULDQ.BCST", "VPMULUDQ.BCST"}) {
+				body, declaration := x86FixedBinaryValueFixture(target.arch, row.op, row.bank, row.mode, false)
+				instruction := ""
+				for _, line := range strings.Split(body, "\n") {
+					if strings.HasPrefix(line, "VPMULDQ") || strings.HasPrefix(line, "VPMULUDQ") {
+						instruction = line
+					}
+				}
+				if instruction == "" {
+					t.Fatal("complete initialized product source lost its operation")
+				}
+				raw := x86RawNumericalInstruction(t, target.arch, instruction)
+				body = strings.Replace(body, fmt.Sprintf("$0-%d", word*2), fmt.Sprintf("$0-%d", word*3), 1)
+				for _, live := range []bool{false, true} {
+					control := fmt.Sprintf("PUSH%s mask+%d(FP)\nPOPF%s\n", suffix, word, suffix)
+					product := raw
+					if live {
+						product = fmt.Sprintf("PUSH%s mask+%d(FP)\n%sPOP%s DX\n", suffix, word, raw, suffix)
+					}
+					capture := fmt.Sprintf("PUSHF%s\nPOP%s CX\n%s CX,ret+%d(FP)\n", suffix, suffix, move, word*2)
+					initialized := strings.Replace(body, instruction, control+product+capture, 1)
+					name := fmt.Sprint("ProductFlags", count)
+					source.WriteString(strings.ReplaceAll(initialized, "Value", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + " uintptr\n")
+					count++
+				}
+			}
+			want := 72
+			if word == 4 {
+				want = 24
+			}
+			if count != want {
+				t.Fatal("complete raw product full/broadcast/mask private-control inventory changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
diff --git a/x86_e4_dead_read_oracle_unix_test.go b/x86_e4_dead_read_oracle_unix_test.go
new file mode 100644
index 000000000..46741b19b
--- /dev/null
+++ b/x86_e4_dead_read_oracle_unix_test.go
@@ -0,0 +1,69 @@
+//go:build darwin || linux
+
+package plan9asm
+
+// E4 is element-granular even for dead results. Families independently supply
+// every actual source tuple, element width and number of mask-selected lanes.
+func x86E4DeadReadFaultOracle(prototypes, metadata string) string {
+	return `
+#include <stdint.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+` + prototypes + `
+typedef void (*Kernel)(const uint8_t *,uint64_t);
+typedef struct { Kernel run; int extent,lane,lanes; } Row;
+static const Row rows[]={
+` + metadata + `
+};
+static int fault(Kernel run,const uint8_t *p,uint64_t mask) {
+  pid_t child=fork();
+  if(child<0) return -1;
+  if(!child) {
+    struct rlimit no_core={0,0};
+    if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+    run(p,mask);
+    _exit(0);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)==0?0:-3;
+  if(WIFSIGNALED(status)) return WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS?1:-4;
+  return -5;
+}
+int main(void) {
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(p==MAP_FAILED || mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  for(long i=0;i<page;i++) p[i]=(uint8_t)(i*17+3);
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    const Row *row=&rows[r];
+    uint64_t outside=row->lanes<64?UINT64_C(1)<<row->lanes:0;
+    struct {const uint8_t *p;uint64_t mask;int want;} cases[]={
+      {0,0,0}, {0,outside,0}, {0,1,1},
+      {p+page-row->extent,UINT64_MAX,0},
+      {p+page-row->extent+1,UINT64_MAX,1},
+      {p+page-row->lane,1,0}, {p+page-row->lane+1,1,1},
+    };
+    for(unsigned c=0;c<sizeof(cases)/sizeof(cases[0]);c++) {
+      int actual=fault(row->run,cases[c].p,cases[c].mask);
+      if(actual!=cases[c].want) {
+        fprintf(stderr,"blend E4 row=%u case=%u extent=%d actual=%d want=%d\n",
+                r,c,row->extent,actual,cases[c].want);
+        return 1;
+      }
+    }
+  }
+  if(mprotect(p,(size_t)page,PROT_READ)) return 1;
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    if(fault(rows[r].run,p+page-rows[r].extent,UINT64_MAX)) return 1;
+  }
+  return munmap(p,(size_t)page*2)?1:0;
+}
+`
+}
diff --git a/x86_elided_scheduler_hook.go b/x86_elided_scheduler_hook.go
new file mode 100644
index 000000000..0b1f68f62
--- /dev/null
+++ b/x86_elided_scheduler_hook.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "strings"
+
+// Consume only the scheduler hooks which callSym already elides. No callable
+// signature, outgoing bytes, result, frame or continuation permission follows.
+func (c *amd64Ctx) loweredElidedSchedulerHookStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	if ins.Op != OpCALL || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym ||
+		!strings.HasSuffix(strings.TrimSpace(ins.Args[0].Sym), "(SB)") || !x86ResultNamedPredicateInstruction(ins) ||
+		len(ins.x86SourceStackFP) != 0 || len(ins.x86CallerMemory) != 0 || len(ins.x86FixedLocalMemory) != 0 ||
+		ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil {
+		return false, false
+	}
+	name, offset, valid := parseSBRef(ins.Args[0].Sym)
+	base, selector, selected := strings.Cut(name, "<")
+	if !valid || offset != 0 || strings.Contains(base, ">") || selected && selector != "ABI0>" && selector != "ABIInternal>" {
+		return false, false
+	}
+	original := strings.TrimSuffix(strings.TrimSpace(ins.Args[0].Sym), "(SB)")
+	callee := strings.ReplaceAll(base, "·", ".")
+	if !arm64ElidesSchedulerHook(callee) || c.resolve(original) != callee {
+		return false, false
+	}
+	if arch != "amd64" && arch != "386" || state.continuation != nil ||
+		state.valueStack != nil && (state.valueStack.invalid || len(state.valueStack.bytes) != 0) {
+		return false, true
+	}
+	// Keep logical FP/AUTO values which were not passed to the hook. Revoke
+	// machine facts conservatively, without changing the existing no-op IR.
+	state.gp, state.canonicalGP = [16]uint8{}, [16]uint8{}
+	state.xmm, state.vectorUpper = [32]uint16{}, [32]uint64{}
+	state.nativeMMX, state.masks = [8]uint8{}, [8]bool{}
+	state.pointerGP, state.callerAddressGP = [16]bool{}, [16]bool{}
+	state.callerAddressOrigin = [16]uint16{}
+	state.resultAddressGP = [16]x86ResultSlotAddress{}
+	if state.boolFrameGP != nil {
+		state.boolFrameGP = new([16]x86ResultSlotAddress)
+	}
+	state.flags, state.direction = 0, x86ResultDirectionUnknown
+	state.predicate, state.bitScanPending = x86ResultPredicate{}, x86ResultBitScanPending{}
+	state.gpBits, state.shiftBits = x86ResultGPBits{}, x86ResultShiftBits{}
+	state.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+	state.stringCount, state.cpuidRootLeaf = x86StringCountUnknown, false
+	if state.x87 != nil {
+		state.x87.revoke()
+	}
+	return true, true
+}
diff --git a/x86_elided_scheduler_hook_test.go b/x86_elided_scheduler_hook_test.go
new file mode 100644
index 000000000..4a3fe7947
--- /dev/null
+++ b/x86_elided_scheduler_hook_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86SchedulerHookFixture(arch string) (string, string) {
+	move, typ, width := "MOVQ", "uint64", 8
+	if arch == "386" {
+		move, typ, width = "MOVL", "uint32", 4
+	}
+	declaration := fmt.Sprintf("func probe(x %s) (a, b %s)", typ, typ)
+	source := fmt.Sprintf("TEXT ·probe(SB),4,$0-%d\nCALL runtime·entersyscall(SB)\n%s x+0(FP),AX\n%s AX,a+%d(FP)\n%s $0,b+%d(FP)\nCALL runtime·exitsyscall(SB)\nRET\n",
+		3*width, move, move, width, move, 2*width)
+	return source, declaration
+}
+
+func x86SchedulerHookAPI(t *testing.T, source, declaration, arch, target, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "scheduler", "package scheduler\n"+declaration+"\n")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := testResolveSym(pkg.Path)
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: target, ResolveSym: resolve, Sigs: signatures}
+	return arm64ScratchSourceAPIWithAssembly(t, pkg, file, options, api, source)
+}
+
+func TestX86ElidedSchedulerHookPairedSource(t *testing.T) {
+	source := x86SchedulerKernelFixture()
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86SchedulerHookAPI(t, source, x86LinuxSyscallDeclaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("elided hooks did not retain the complete initialized syscall path", err)
+			}
+		})
+	}
+}
+
+func x86SchedulerKernelFixture() string {
+	source := strings.Replace(x86LinuxSyscallAssembly, "\n", "\nCALL runtime·entersyscall(SB)\n", 1)
+	return strings.Replace(source, "RET", "CALL runtime·exitsyscall(SB)\nRET", 1)
+}
+
+func TestX86ElidedSchedulerHookPortableSources(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, declaration := x86SchedulerHookFixture(arch)
+		for _, target := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "wasm32-unknown-unknown"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+target+"/"+api, func(t *testing.T) {
+					ir, err := x86SchedulerHookAPI(t, source, declaration, arch, target, api)
+					if err != nil {
+						t.Fatal("existing elided hooks rejected actual initialized frame values", err)
+					}
+					if ir == "" || strings.Contains(ir, "call void @runtime.enter") || strings.Contains(ir, "call void @runtime.exit") {
+						t.Fatal("elided hook became a native runtime call", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ElidedSchedulerHookKeepsSourceBoundaries(t *testing.T) {
+	source, declaration := x86SchedulerKernelFixture(), x86LinuxSyscallDeclaration
+	for _, row := range []struct{ name, before, after string }{
+		{"unknown", "runtime·entersyscall", "runtime·entersyscallblock"},
+		{"other-package", "runtime·entersyscall", "other·entersyscall"},
+		{"offset", "runtime·entersyscall(SB)", "runtime·entersyscall+1(SB)"},
+		{"unknown-selector", "runtime·entersyscall(SB)", "runtime·entersyscall<ABI99>(SB)"},
+		{"stale-register", "MOVQ AX, r1+56(FP)", "CALL runtime·exitsyscall(SB)\nMOVQ AX, r1+56(FP)"},
+		{"private-stack", "CALL runtime·entersyscall(SB)", "PUSHQ $1\nCALL runtime·entersyscall(SB)\nPOPQ BX"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				input := strings.Replace(source, row.before, row.after, 1)
+				ir, err := x86SchedulerHookAPI(t, input, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err == nil || ir != "" {
+					t.Fatalf("hook supplied missing source/call context: output=%t error=%v", ir != "", err)
+				}
+			})
+		}
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "strictscheduler", "package strictscheduler\n"+declaration+"\n")
+	signatures, err := goSigsForAsmFile(pkg, file, testResolveSym(pkg.Path), "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signatures[pkg.Path+".Raw"], "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("standalone query borrowed paired hook handling", err)
+	}
+}
diff --git a/x86_endbranch_encoder_go127_test.go b/x86_endbranch_encoder_go127_test.go
new file mode 100644
index 000000000..130015df4
--- /dev/null
+++ b/x86_endbranch_encoder_go127_test.go
@@ -0,0 +1,37 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86EndBranchCurrentGoEncoderRow(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"varynone=[]ytab{{Zlit,1,argList{}},}",
+		"{AENDBR64,ynone,Pf3,opBytes{0x1e,0xfa}},",
+	} {
+		if !strings.Contains(compact, row) {
+			t.Fatal("complete operand-free Go ENDBR row changed", row)
+		}
+	}
+	if strings.Contains(compact, "{AENDBR32,") {
+		t.Fatal("Go added an ENDBR32 mnemonic; revisit the raw-only contract")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		code := assembleX87ControlBytes(t, arch, "TEXT marker(SB),4,$0-0\nENDBR64\nRET\n")
+		if !bytes.Equal(code, []byte{0xf3, 0x0f, 0x1e, 0xfa, 0xc3}) {
+			t.Fatalf("original Go %s ENDBR bytes changed: %x", arch, code)
+		}
+	}
+}
diff --git a/x86_endbranch_runtime_linux_amd64_test.go b/x86_endbranch_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..a39ebf985
--- /dev/null
+++ b/x86_endbranch_runtime_linux_amd64_test.go
@@ -0,0 +1,7 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86EndBranchNativeState(t *testing.T) {
+	TestX86RawEndBranchRuntimePreservesState(t)
+}
diff --git a/x86_endbranch_state_test.go b/x86_endbranch_state_test.go
new file mode 100644
index 000000000..9cbd0a151
--- /dev/null
+++ b/x86_endbranch_state_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Intel's ENDBR32/64 operations update CET tracking, not numerical registers,
+// FLAGS or memory. Keep the native instruction; these checks grant no CET entry.
+// https://cdrdv2-public.intel.com/874239/252046-082-sdm-change-document.pdf
+func TestX86EndBranchNumericalState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		forms := []Instr{{Op: "ENDBR64"}}
+		for _, last := range []byte{0xfa, 0xfb} {
+			forms = append(forms, x86RawNOPSourceStateInstruction(t, arch, []byte{0xf3, 0x0f, 0x1e, last}))
+		}
+		for index, ins := range forms {
+			t.Run(fmt.Sprintf("%s/form%d", arch, index), func(t *testing.T) {
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					for _, initialized := range []bool{false, true} {
+						state := x86ResultState{fp: []bool{false, true}, valueStack: &x86ResultValueStack{}}
+						if initialized {
+							state.gp[0], state.xmm[0], state.vectorUpper[0] = 0x53, 0x5511, 0xaabbccdd00000000
+							state.pointerGP[3], state.masks[1], state.flags = true, true, x86ByteFlagsAll
+							state.direction, state.valueStack.id = x86ResultDirectionBackward, true
+						}
+						before := state.clone()
+						if !consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+							t.Errorf("ENDBR consumed or invented numerical state: %s initialized=%t", consumer.name, initialized)
+						}
+					}
+				}
+				for _, direction := range []x86ResultDirection{0, 1, 2, 3} {
+					if got := x86ResultDirectionAfter(ins, direction); got != direction {
+						t.Error("ENDBR changed existing DF knowledge", direction, got)
+					}
+				}
+				predicate := x86ResultPredicate{kind: x86ResultComparisonBytes, register: 1, width: 16}
+				if x86ResultPredicateAfter(ins, predicate, arch) != predicate {
+					t.Error("ENDBR revoked an unchanged numerical predicate")
+				}
+				addresses := [16]bool{3: true, 7: true}
+				if x86ResultCallerAddressesAfter(ins, addresses, nil, arch) != addresses {
+					t.Error("ENDBR changed existing address identities")
+				}
+				for _, count := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+					if x86ResultStringCountAfter(ins, count, count, arch) != count {
+						t.Error("ENDBR changed existing CX knowledge")
+					}
+				}
+				state := x86ResultState{valueStack: &x86ResultValueStack{bytes: make([]uint8, 8)}}
+				if !x86ResultValueStackContinuation(ins, &state, arch) {
+					t.Error("ENDBR revoked unrelated private storage")
+				}
+			})
+		}
+	}
+}
+
+func TestX86EndBranchEffectsRequireExactSource(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, last := range []byte{0xfa, 0xfb} {
+			original := x86RawNOPSourceStateInstruction(t, arch, []byte{0xf3, 0x0f, 0x1e, last})
+			for _, mutation := range []string{
+				"opcode", "operands", "origin opcode", "origin operands", "missing origin",
+				"missing encoding", "address", "unbound address", "segment", "raw return",
+			} {
+				t.Run(fmt.Sprintf("%s/%x/%s", arch, last, mutation), func(t *testing.T) {
+					ins := original
+					origin := *original.x86SourceRaw
+					ins.x86SourceRaw = &origin
+					switch mutation {
+					case "opcode":
+						ins.Op = "ENDBR64.Z"
+					case "operands":
+						ins.Args = []Operand{{Kind: OpReg, Reg: AX}}
+					case "origin opcode":
+						origin.op = "SWAPGS"
+					case "origin operands":
+						origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+					case "missing origin":
+						ins.x86SourceRaw = nil
+					case "missing encoding":
+						ins.x86Encoded = false
+					case "address":
+						ins.x86AddressBits = 32
+					case "unbound address":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "raw return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					}
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					before := state.clone()
+					if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("changed physical source gained ENDBR numerical effects")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86EndBranchOriginalRuntimeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The unchanged runtime program uses a 64-bit pointer declaration.
+		}
+		for _, last := range []byte{0xfa, 0xfb} {
+			t.Run(fmt.Sprintf("%s/%x", target.triple, last), func(t *testing.T) {
+				source := fmt.Sprintf(x86EndBranchRuntimeSource, last)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func endbranchstate(out *byte)", target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("unchanged original GP/FLAGS ENDBR program", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86EndBranchPrivateStackState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		for _, last := range []byte{0xfa, 0xfb} {
+			for _, live := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%x/live=%t", arch, last, live), func(t *testing.T) {
+					body := x86RawDisplacementDirectives([]byte{0xf3, 0x0f, 0x1e, last})
+					if live {
+						body = "PUSH" + word + " $7\n" + body + "POP" + word + " AX\n"
+					}
+					file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\n"+body+"RET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, initialized := range []bool{false, true} {
+						state := x86ResultState{valueStack: &x86ResultValueStack{id: initialized}}
+						if initialized {
+							state.direction, state.flags = x86ResultDirectionEither, x86ByteFlagsAll
+						}
+						err := checkX86ResultSourceFlow(fn, state, nil, 0, arch,
+							func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+								return x86ResultTransfer(ins, state, owned, offset, arch)
+							}, func(after x86ResultState, _ int) error {
+								if after.valueStack.id != initialized || after.direction != state.direction || after.flags != state.flags {
+									return fmt.Errorf("ENDBR changed independent private FLAGS/DF/ID")
+								}
+								return nil
+							})
+						if err != nil {
+							t.Fatal(err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86EndBranchCannotCreateInputsOrEntry(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, last := range []byte{0xfa, 0xfb} {
+			marker := x86RawDisplacementDirectives([]byte{0xf3, 0x0f, 0x1e, last})
+			for _, test := range []struct{ name, before, after string }{
+				{"unknown value", "", "MOVL AX,ret+0(FP)\nRET\n"},
+				{"unknown flags", "MOVL $0,AX\n", "SETEQ AL\nMOVL AX,ret+0(FP)\nRET\n"},
+				{"unknown address", "", "MOVL (AX),CX\nMOVL CX,ret+0(FP)\nRET\n"},
+				{"numeric address", "MOVL $0,AX\n", "MOVL (AX),CX\nMOVL CX,ret+0(FP)\nRET\n"},
+				{"unwritten return", "", "RET\n"},
+				{"raw return", "MOVL $7,AX\n", "MOVL AX,ret+0(FP)\nBYTE $0xc3\n"},
+			} {
+				t.Run(fmt.Sprintf("%s/%x/%s", target.triple, last, test.name), func(t *testing.T) {
+					frame := 0
+					if test.name == "raw return" {
+						frame = 8 // Raw RET cannot borrow Go's nonzero-frame epilogue.
+					}
+					source := fmt.Sprintf("TEXT marker(SB),4,$%d-4\n", frame) + test.before + marker + test.after
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func marker() uint32", target.arch, target.triple, api)
+						if test.name == "numeric address" {
+							if err != nil || strings.Count(ir, "load volatile i32,") != 1 {
+								t.Fatal("defined address lost its original faulting dword access", api, err)
+							}
+							x86RequireNumericNativeSourceContext(t, source, "func marker() uint32", target.arch)
+							x86NumericNativeAddressObject(t, ir, target.triple)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("ENDBR supplied missing source facts or native entry", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_enqueue_grammar_test.go b/x86_enqueue_grammar_test.go
new file mode 100644
index 000000000..db3f9651d
--- /dev/null
+++ b/x86_enqueue_grammar_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "testing"
+
+func TestX86EnqueueCompleteAddress16Forms(t *testing.T) {
+	rows := []struct{ base, index Reg }{
+		{BX, SI}, {BX, DI}, {BP, SI}, {BP, DI}, {SI, ""}, {DI, ""}, {BP, ""}, {BX, ""},
+	}
+	for _, prefix := range []byte{0xf2, 0xf3} {
+		for mod := byte(0); mod < 3; mod++ {
+			for rm, row := range rows {
+				code := []byte{0x67, prefix, 0x0f, 0x38, 0xf8, mod<<6 | 7<<3 | byte(rm)}
+				base, index, offset := row.base, row.index, uint16(0)
+				if mod == 1 {
+					code, offset = append(code, 0x80), 0xff80
+				} else if mod == 2 || rm == 6 {
+					code, offset = append(code, 0x00, 0x80), 0x8000
+					if mod == 0 {
+						base = "" // The absolute disp16 row replaces BP only for mod=00.
+					}
+				}
+				ins, length, known, err := decodedX86EnqueueInstruction(code, 32)
+				if err != nil || !known || length != len(code) || len(ins.Args) != 2 ||
+					ins.x86AddressBits != 16 || ins.Args[1].Reg != DI ||
+					ins.Args[0].Mem.Base != base || ins.Args[0].Mem.Index != index || uint16(ins.Args[0].Mem.Off) != offset {
+					t.Fatalf("complete address16 physical row %x: %#v / %v", code, ins, err)
+				}
+				if _, known, err := x86EnqueueProperties(ins.Op, ins, "386"); !known || err != nil {
+					t.Fatal("typed grammar lost a legal original address16 form", ins, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86EnqueueConstructedAddressGrammarBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []Op{"ENQCMD", "ENQCMDS"} {
+			for _, mutation := range []string{"offset-overflow", "offset-underflow", "orphan-scale", "invalid-scale",
+				"stack-index", "foreign-extension", "constructed-memory", "invalid-segment", "invalid-16-bit-base"} {
+				t.Run(arch+"/"+string(op)+"/"+mutation, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, string(op)+" (BX),DI")
+					switch mutation {
+					case "offset-overflow":
+						ins.Args[0].Mem.Off = 1 << 32
+					case "offset-underflow":
+						ins.Args[0].Mem.Off = -1<<31 - 1
+					case "orphan-scale":
+						ins.Args[0].Mem.Scale = 4
+					case "invalid-scale":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+					case "stack-index":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = SP, 1
+					case "foreign-extension":
+						ins.Args[0].Mem.IndexExt = ExtendSXTW
+					case "constructed-memory":
+						ins.Args[0].ImmRaw = "$unknown"
+					case "invalid-segment":
+						ins.Args[0].Mem.Segment = AX
+					case "invalid-16-bit-base":
+						ins.x86AddressBits, ins.Args[0].Mem.Base = 16, AX
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerEnqueue(op, ins)
+					if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+						t.Fatal("unencodable enqueue address emitted IR", known, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_enqueue_result_test.go b/x86_enqueue_result_test.go
new file mode 100644
index 000000000..f480ca366
--- /dev/null
+++ b/x86_enqueue_result_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86EnqueueCompletePhysicalRegisterAddressFamily(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(table), "{AENQCMD") {
+		t.Fatal("Go acquired an enqueue spelling; bind its full encoder rows before changing the oracle")
+	}
+	registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for _, mode := range []int{32, 64} {
+		count := 8
+		if mode == 64 {
+			count = 16
+		}
+		addressSizes := []int{mode}
+		if mode == 64 {
+			addressSizes = append(addressSizes, 32)
+		}
+		for _, addressBits := range addressSizes {
+			for _, prefix := range []byte{0xf2, 0xf3} {
+				for destination := 0; destination < count; destination++ {
+					for base := 0; base < count; base++ {
+						code := []byte{prefix}
+						if addressBits != mode {
+							code = append(code, 0x67)
+						}
+						if mode == 64 {
+							// W is ignored. Independently cover every R/B register bit.
+							code = append(code, 0x48|byte(destination/8)<<2|byte(base/8))
+						}
+						code = append(code, 0x0f, 0x38, 0xf8, 0x40|byte(destination%8)<<3|byte(base%8))
+						if base%8 == 4 {
+							code = append(code, 0x24) // Required SIB: no index, SP/R12 base.
+						}
+						code = append(code, 0x80) // Signed disp8 avoids the RIP/no-base encoding.
+						ins, length, known, err := decodedX86EnqueueInstruction(code, mode)
+						want := Op("ENQCMD")
+						if prefix == 0xf3 {
+							want = "ENQCMDS"
+						}
+						if err != nil || !known || length != len(code) || ins.Op != want || ins.x86AddressBits != addressBits ||
+							len(ins.Args) != 2 || ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != registers[base] ||
+							ins.Args[0].Mem.Off != -128 || ins.Args[0].Mem.Index != "" || ins.Args[1].Reg != registers[destination] {
+							t.Fatalf("complete enqueue register/address form %x in mode %d: %#v / %v", code, mode, ins, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// Intel's complete family is F2/F3 0F 38 F8 /r, m512 and an address-size
+// GP operand. Go has no mnemonic row: the independent Go witnesses use BYTE.
+// Native continuation is not a successful device submission, PASID or CPL proof.
+func x86EnqueuePointerProgram(arch string, prefix byte, before, after string) (string, string) {
+	word, size := "L", 4
+	if arch == "amd64" {
+		word, size = "Q", 8
+	}
+	source := fmt.Sprintf("TEXT ·Enqueue(SB),4,$0-%d\nMOV%s command+0(FP),AX\nMOV%s device+%d(FP),DI\n%s%s%sMOVL $0,AX\nSETEQ AX\nMOVL AX,ret+%d(FP)\nRET\n",
+		2*size+4, word, word, size, before,
+		x86RawDisplacementDirectives([]byte{prefix, 0x0f, 0x38, 0xf8, 0x38}), after, 2*size)
+	return source, "func Enqueue(command, device *[64]byte) uint32"
+}
+
+func TestX86EnqueueInitializedPointersThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, prefix := range []byte{0xf2, 0xf3} {
+			t.Run(fmt.Sprintf("%s/%x", target.triple, prefix), func(t *testing.T) {
+				source, declaration := x86EnqueuePointerProgram(target.arch, prefix, "", "")
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete original raw enqueue pointer/status program", api, err)
+					}
+					op := "enqcmd"
+					if prefix == 0xf3 {
+						op += "s"
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if !strings.Contains(text, "asm sideeffect \""+op+" $1, $2; sete $0\"") ||
+							!strings.Contains(text, "elementtype([64 x i8])") || strings.Contains(text, "llvm.memcpy") {
+							t.Fatal("enqueue lost actual whole command, retry or fault behavior", api)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86EnqueueInputAndFrameBoundariesThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, size := "L", 4
+		if target.arch == "amd64" {
+			word, size = "Q", 8
+		}
+		for _, prefix := range []byte{0xf2, 0xf3} {
+			for _, invalid := range []struct{ name, before, after string }{
+				{"numeric-source", "MOVL $0,AX\n", ""},
+				{"numeric-device", "MOVL $0,DI\n", ""},
+				{"uninitialized-source", "MOV" + word + " BX,AX\n", ""},
+				{"uninitialized-device", "MOV" + word + " BX,DI\n", ""},
+				{"physical-frame", "LEA" + word + " 0(SP),AX\n", ""},
+				{"no-future-read-authority", "", "MOVL (DI),BX\n"},
+			} {
+				t.Run(fmt.Sprintf("%s/%x/%s", target.triple, prefix, invalid.name), func(t *testing.T) {
+					source, declaration := x86EnqueuePointerProgram(target.arch, prefix, invalid.before, invalid.after)
+					if invalid.name == "no-future-read-authority" {
+						// A later actual native read has its own continuation. An
+						// uninitialized third pointer must never inherit device facts.
+						source = strings.Replace(source, "MOVL (DI),BX", "MOVL (BX),CX", 1)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("enqueue acquired missing source/device/frame knowledge", api, err)
+						}
+					}
+				})
+			}
+			// Void cannot evade the same two input-address obligations.
+			source, _ := x86EnqueuePointerProgram(target.arch, prefix, "MOVL $0,AX\n", "")
+			source = strings.Replace(source, fmt.Sprintf("$0-%d", 2*size+4), fmt.Sprintf("$0-%d", 2*size), 1)
+			source = strings.Replace(source, fmt.Sprintf("MOVL AX,ret+%d(FP)\n", 2*size), "", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Enqueue(command, device *[64]byte)", target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("dead enqueue evaded its source inputs", api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86EnqueueGrammarRejectsBeforePartialEmission(t *testing.T) {
+	for _, op := range []Op{"ENQCMD", "ENQCMDS"} {
+		for _, invalid := range []string{"dispatch", "foreign-mode", "address-size", "constructed-destination", "unresolved-offset"} {
+			t.Run(string(op)+"/"+invalid, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, string(op)+" (AX),DI")
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = "amd64"
+				switch invalid {
+				case "dispatch":
+					ins.Op = "NOP"
+				case "foreign-mode":
+					ctx.goarch = "arm64"
+				case "address-size":
+					ins.x86AddressBits = 16
+				case "constructed-destination":
+					ins.Args[1].ImmRaw = "$unknown"
+				case "unresolved-offset":
+					ins.Args[0].Mem.OffRaw = "unknown"
+				}
+				before, temporary := output.String(), ctx.tmp
+				known, terminated, err := ctx.lowerEnqueue(op, ins)
+				if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+					t.Fatal("invalid enqueue emitted partial IR", known, terminated, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_enqueue_source_test.go b/x86_enqueue_source_test.go
new file mode 100644
index 000000000..4b70f5141
--- /dev/null
+++ b/x86_enqueue_source_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86EnqueueRawIdentityAndReadOnlyState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []byte{0xf2, 0xf3} {
+			source, _ := x86EnqueuePointerProgram(arch, prefix, "", "")
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+			if err != nil || len(fn.Instrs) != 8 || fn.Instrs[3].x86SourceRaw == nil {
+				t.Fatal("missing complete raw enqueue source", err)
+			}
+			original := fn.Instrs[3]
+			for _, mutation := range []string{"unchanged", "source", "device", "origin-opcode", "origin-operand",
+				"missing-origin", "encoded", "address-size", "implicit-size", "segment", "unbound", "raw-return"} {
+				t.Run(fmt.Sprintf("%s/%x/%s", arch, prefix, mutation), func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					origin := *original.x86SourceRaw
+					ins.x86SourceRaw = &origin
+					switch mutation {
+					case "source":
+						ins.Args[0].Mem.Off++
+					case "device":
+						ins.Args[1].Reg = BX
+					case "origin-opcode":
+						origin.op = "NOP"
+					case "origin-operand":
+						origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+					case "missing-origin":
+						ins.x86SourceRaw = nil
+					case "encoded":
+						ins.x86Encoded = true
+					case "address-size":
+						ins.x86AddressBits /= 2
+					case "implicit-size":
+						ins.x86AddressBits = 0
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "unbound":
+						ins.x86UnboundAddressOverride = true
+					case "raw-return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					}
+					valid := mutation == "unchanged"
+					state := x86ResultState{direction: x86ResultDirectionBackward,
+						valueStack: &x86ResultValueStack{bytes: []uint8{1, 2, 3, 4}, id: true}}
+					state.pointerGP[0], state.pointerGP[7] = true, true
+					state.callerAddressGP[0], state.callerAddressGP[7] = true, true
+					state.gp[3], state.xmm[2], state.masks[4] = 0x55, 0x1234, true
+					before, want := state.clone(), state.clone()
+					if valid {
+						want.flags = x86ByteFlagsAll
+					}
+					accepted, known := x86LoweredEnqueueResultStep(ins, &state, arch)
+					if !known || accepted != valid || !reflect.DeepEqual(state, want) {
+						t.Fatal("enqueue changed an input register/storage or accepted changed raw identity", accepted, known)
+					}
+					// No paired hardware emission belongs to a declaration query.
+					standalone := before.clone()
+					if x86ResultTransfer(ins, &standalone, nil, 0, arch) || !reflect.DeepEqual(standalone, before) {
+						t.Fatal("standalone observer borrowed native submission")
+					}
+					if valid && (!x86ResultValueStackContinuation(ins, &state, arch) ||
+						x86ResultDirectionAfter(ins, state.direction) != state.direction ||
+						x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch) != before.callerAddressGP) {
+						t.Fatal("enqueue lost independent DF/private cells or read-only address identities")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86EnqueueLivePrivateStackAndMissingResult(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, size := "L", 4
+		if target.arch == "amd64" {
+			word, size = "Q", 8
+		}
+		for _, prefix := range []byte{0xf2, 0xf3} {
+			t.Run(fmt.Sprintf("%s/%x", target.triple, prefix), func(t *testing.T) {
+				source, declaration := x86EnqueuePointerProgram(target.arch, prefix,
+					"MOVL $0x1234,CX\nPUSH"+word+" CX\n", "POP"+word+" BX\n")
+				result := fmt.Sprintf("MOVL AX,ret+%d(FP)\n", 2*size)
+				source = strings.Replace(source, result, fmt.Sprintf("MOVL BX,ret+%d(FP)\n", 2*size), 1)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("enqueue lost a live independent numerical cell", api, err)
+					}
+					missing, _ := x86EnqueuePointerProgram(target.arch, prefix, "", "")
+					missing = strings.Replace(missing, result, "", 1)
+					ir, err = x86ScalarFPBitViewAPI(t, missing, declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("enqueue invented an unwritten ABI result", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_evex_packed_move_fixture_contract_test.go b/x86_evex_packed_move_fixture_contract_test.go
new file mode 100644
index 000000000..433746c10
--- /dev/null
+++ b/x86_evex_packed_move_fixture_contract_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These two builders mechanically retain the old complete format sources.
+// No input producer or native entry contract is implied by their Void headers.
+func x86EVEXPackedIntegerMoveOriginalSource(arch string) string {
+	zregs := []int{0, 21}
+	if arch == "386" {
+		zregs = []int{0, 7}
+	}
+	var src strings.Builder
+	src.WriteString("TEXT evexpackedintegermoveforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+		for _, width := range []string{"X", "Y"} {
+			fmt.Fprintf(&src, "\t%s %s0, %s1\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s20, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s21\n", op, width)
+			fmt.Fprintf(&src, "\t%s %s1, K1, %s2\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s1, K2, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), K3, %s2\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z %s1, K4, %s2\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.Z %s1, K5, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z (AX), K6, %s2\n", op, width)
+		}
+		fmt.Fprintf(&src, "\t%s Z%d, Z%d\n", op, zregs[0], zregs[1])
+		fmt.Fprintf(&src, "\t%s Z%d, (AX)\n", op, zregs[0])
+		fmt.Fprintf(&src, "\t%s (AX), Z%d\n", op, zregs[1])
+		fmt.Fprintf(&src, "\t%s Z%d, K1, Z%d\n", op, zregs[0], zregs[1])
+		fmt.Fprintf(&src, "\t%s.Z Z%d, K2, (AX)\n", op, zregs[0])
+		fmt.Fprintf(&src, "\t%s.Z (AX), K3, Z%d\n", op, zregs[1])
+	}
+	src.WriteString("\tRET\n")
+	return src.String()
+}
+
+func x86EVEXPackedFloat386OriginalSource() string {
+	var src strings.Builder
+	src.WriteString("TEXT packedfloatmoveforms386(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS"} {
+		for _, width := range []string{"X", "Y"} {
+			fmt.Fprintf(&src, "\t%s %s0, %s1\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s20, %s21\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s %s20, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s (AX), %s21\n", op, width)
+			fmt.Fprintf(&src, "\t%s %s20, K1, %s21\n", op, width, width)
+			fmt.Fprintf(&src, "\t%s.Z %s20, K2, (AX)\n", op, width)
+			fmt.Fprintf(&src, "\t%s.Z (AX), K3, %s21\n", op, width)
+		}
+		fmt.Fprintf(&src, "\t%s Z0, Z7\n", op)
+		fmt.Fprintf(&src, "\t%s Z7, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s (AX), Z7\n", op)
+		fmt.Fprintf(&src, "\t%s Z0, K1, Z7\n", op)
+		fmt.Fprintf(&src, "\t%s.Z Z0, K2, (AX)\n", op)
+		fmt.Fprintf(&src, "\t%s.Z (AX), K3, Z7\n", op)
+	}
+	src.WriteString("\tRET\n")
+	return src.String()
+}
+
+func TestX86EVEXPackedMoveOriginalFormatsNeedActualInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			sources := []string{x86EVEXPackedIntegerMoveOriginalSource(target.arch)}
+			if target.arch == "386" {
+				sources = append(sources, x86EVEXPackedFloat386OriginalSource())
+			}
+			for _, source := range sources {
+				// The real original high-bank source is accepted by Go but has
+				// neither numerical inputs nor a physical mode32 bank contract.
+				x86UnboundVoidFormatSources(t, source, target.arch, target.triple)
+				if target.arch == "386" {
+					physical := x86PhysicalMode32ObjectSource(t, source, target.arch)
+					x86UnboundVoidFormatSources(t, physical, target.arch, target.triple)
+				}
+			}
+		})
+	}
+}
+
+// An independent initialized program covers every ordinary direction and
+// mask/merge/zero row for all six integer and four floating EVEX move names.
+// Memory .Z is deliberately separate: its actual encoding raises #UD, as
+// TestX86PackedZeroMemoryStoreActualGoAndLLVM22Encoding independently checks.
+var x86EVEXPackedMoveFixtureNames = []string{
+	"VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64",
+	"VMOVAPD", "VMOVAPS", "VMOVUPD", "VMOVUPS",
+}
+
+func x86EVEXPackedMoveInitializedProgram(arch string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range x86EVEXPackedMoveFixtureNames {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			fmt.Fprintf(&declarations, "func Move%d(p *[80]byte)\n", count)
+			fmt.Fprintf(&source, "TEXT ·Move%d(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $3,CX\nKMOVD CX,K1\n", count, word, move)
+			for _, register := range []int{0, 1, 2} {
+				fmt.Fprintf(&source, "VPXORQ Z%d,Z%d,Z%d\n", register, register, register)
+			}
+			source.WriteString("STC\n")
+			fmt.Fprintf(&source, "%s %s0,%s1\n%s %s0,(AX)\n%s (AX),%s1\n", op, bank, bank, op, bank, op, bank)
+			fmt.Fprintf(&source, "%s %s0,K1,%s2\n%s %s0,K1,(AX)\n%s (AX),K1,%s2\n", op, bank, bank, op, bank, op, bank)
+			fmt.Fprintf(&source, "%s.Z %s0,K1,%s2\n%s.Z (AX),K1,%s2\nSETCS 64(AX)\nRET\n", op, bank, bank, op, bank)
+			count++
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86EVEXPackedMoveInitializedCompleteRowsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for complete initialized EVEX move objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86EVEXPackedMoveInitializedProgram(target.arch)
+			if strings.Count(source, "TEXT ") != 30 || strings.Count(source, "SETCS 64(AX)") != 30 {
+				t.Fatal("complete 30-kernel / 240-row initialized directory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "initialized-evex-moves.ll", "initialized-evex-moves.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86EVEXPackedMoveMissingInputDoesNotBorrowVoid(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86EVEXPackedMoveFixtureNames {
+			for _, missing := range []string{"pointer", "source", "mask"} {
+				t.Run(arch+"/"+op+"/"+missing, func(t *testing.T) {
+					prefix := fmt.Sprintf("%s p+0(FP),AX\nVPXORQ Z0,Z0,Z0\nMOVL $3,CX\nKMOVD CX,K1\n", move)
+					switch missing {
+					case "pointer":
+						prefix = strings.Replace(prefix, move+" p+0(FP),AX\n", "", 1)
+					case "source":
+						prefix = strings.Replace(prefix, "VPXORQ Z0,Z0,Z0\n", "", 1)
+					case "mask":
+						prefix = strings.Replace(prefix, "KMOVD CX,K1\n", "", 1)
+					}
+					source := fmt.Sprintf("TEXT ·Move(SB),4,$0-%d\n%s%s X0,K1,(AX)\nRET\n", word, prefix, op)
+					// Syntactically valid original bytes precede every rejection;
+					// missing tools, malformed source or cleanup are never Context.
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Move(p *[80]byte)", arch, triple, api)
+						if arch == "amd64" && missing == "source" {
+							x86VectorScratchCodegenControl(t, source, "func Move(p *[80]byte)", arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("missing actual EVEX move input acquired a value/address", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86EVEXPackedMoveOriginalSourceDirectoryRemainsExact(t *testing.T) {
+	// Filled from the unchanged complete pre-extraction format builders, not
+	// from decoder/lowerer tables or from an emitted LLVM representation.
+	for _, test := range []struct{ name, source, hash string }{
+		{"integer-amd64", x86EVEXPackedIntegerMoveOriginalSource("amd64"), "acf762edc733f65e7870e0ddfd61142804e97907e3885780cca3fc9ca5c53080"},
+		{"integer-386", x86EVEXPackedIntegerMoveOriginalSource("386"), "b63d779762db243a58a3f038f6257419b90ada7385a75d48c431524afcb09f5e"},
+		{"float-386", x86EVEXPackedFloat386OriginalSource(), "d509224c1e23e5a95863b4157ef8cf2c563f9811467f24cb07a747d4ba058b0f"},
+	} {
+		if got := fmt.Sprintf("%x", sha256.Sum256([]byte(test.source))); got != test.hash {
+			t.Fatal("original complete move source changed", test.name, got, test.hash)
+		}
+	}
+}
diff --git a/x86_exchange_fixture_inputs_test.go b/x86_exchange_fixture_inputs_test.go
new file mode 100644
index 000000000..e83285c4a
--- /dev/null
+++ b/x86_exchange_fixture_inputs_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Preserve every discovering XADD/XCHG instruction. This separate complete
+// source defines its actual GP inputs before each row, since an exchange may
+// otherwise overwrite the register which a later row uses as an address.
+func x86InitializedExchangeFixture(t *testing.T, original string, file *File, arch, name string) x86OriginalGPInitializedFormat {
+	t.Helper()
+	if len(file.Funcs) != 1 {
+		t.Fatal("exchange counterpart requires its complete original function")
+	}
+	data, _, found := strings.Cut(original, "TEXT ")
+	if !found {
+		t.Fatal("exchange counterpart lost its original DATA/TEXT boundary")
+	}
+	move, word := "MOVQ", 8
+	registers := []string{"AX", "BX", "CX", "DX", "R11", "R12"}
+	if arch == "386" {
+		move, word = "MOVL", 4
+		registers = []string{"AX", "BX", "CX", "DX", "BP", "SI", "DI"}
+	}
+	var source strings.Builder
+	source.WriteString(data)
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", name, word)
+	for _, instruction := range file.Funcs[0].Instrs[1:] {
+		if instruction.Op == OpRET {
+			continue
+		}
+		if !strings.HasPrefix(string(instruction.Op), "XADD") && !strings.HasPrefix(string(instruction.Op), "XCHG") {
+			t.Fatal("foreign instruction in original exchange family", instruction.Raw)
+		}
+		for _, register := range registers {
+			fmt.Fprintf(&source, "%s $1,%s\n", move, register)
+		}
+		for _, operand := range instruction.Args {
+			if operand.Kind == OpMem && operand.Mem.Base == BX {
+				fmt.Fprintf(&source, "%s p+0(FP),BX\n", move)
+			}
+		}
+		source.WriteString(instruction.Raw + "\n")
+	}
+	source.WriteString("RET\n")
+	return x86OriginalGPInitializedFormat{source.String(), "func " + name + "(p *[64]byte)"}
+}
diff --git a/x86_explicit_imul_immediate_forms_test.go b/x86_explicit_imul_immediate_forms_test.go
new file mode 100644
index 000000000..603582dd6
--- /dev/null
+++ b/x86_explicit_imul_immediate_forms_test.go
@@ -0,0 +1,204 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The spelling/value directory is an independent source oracle, not an
+// invocation of the production immediate conversion or effect descriptor.
+type x86IMULImmediateCase struct {
+	name, literal string
+	value         int64
+	only386       bool
+}
+
+var x86IMULImmediateCases = []x86IMULImmediateCase{
+	{"Zero", "0", 0, false}, {"One", "1", 1, false},
+	{"MinusOne", "-1", -1, false}, {"Min8", "-128", -128, false},
+	{"Below8", "-129", -129, false}, {"Max8", "127", 127, false},
+	{"Above8", "128", 128, false}, {"MaxU8", "255", 255, false},
+	{"Min16", "-32768", -32768, false}, {"Below16", "-32769", -32769, false},
+	{"Max16", "32767", 32767, false}, {"Above16", "32768", 32768, false},
+	{"MaxU16", "65535", 65535, false}, {"AboveU16", "65536", 65536, false},
+	{"Min32", "-2147483648", -2147483648, false},
+	{"Max32", "2147483647", 2147483647, false},
+	{"Above32", "2147483648", 2147483648, false},
+	{"MaxU32", "4294967295", 4294967295, false},
+	{"Hex32", "0x80000000", 2147483648, false},
+	{"HexU32", "0xffffffff", 4294967295, false},
+	{"NegativeHex32", "-0x80000000", -2147483648, false},
+	{"Binary", "0b11111111", 255, false}, {"Octal", "0377", 255, false},
+	{"ShiftExpression", "(1<<31)", 2147483648, false},
+	{"Uint64MinusOne", "18446744073709551615", -1, false},
+	{"HexUint64MinusOne", "0xffffffffffffffff", -1, false},
+	{"WrappedZero", "4294967296", 4294967296, true},
+	{"WrappedOne", "4294967297", 4294967297, true},
+	{"WrappedMinusOne", "8589934591", 8589934591, true},
+	{"Below32", "-2147483649", -2147483649, true},
+	{"WrappedNegativeZero", "-4294967296", -4294967296, true},
+	{"Max64", "9223372036854775807", 9223372036854775807, true},
+	{"Min64", "-9223372036854775808", -9223372036854775808, true},
+	{"UnsignedSign64", "9223372036854775808", -9223372036854775808, true},
+}
+
+func TestX86ExplicitIMULImmediateCompleteActualGoBytesAndEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, bits := range []int{16, 32, 64} {
+			for _, three := range []bool{false, true} {
+				for _, literal := range x86IMULImmediateCases {
+					suffix := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+					op, operands := "IMUL"+suffix, "$"+literal.literal+",AX"
+					if three {
+						op, operands = "IMUL3"+suffix, "$"+literal.literal+",AX,BX"
+					}
+					instruction := op + " " + operands
+					t.Run(arch+"/"+op+"/"+literal.name, func(t *testing.T) {
+						source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+						accepted := !(arch == "386" && bits == 64 || arch == "amd64" && literal.only386)
+						goAssemblerOracleOutput(t, arch, source, "", accepted)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						before := fmt.Sprintf("%#v", ins)
+						form, recognized, err := x86ExplicitIMULProperties(ins.Op, ins, arch)
+						if !accepted {
+							if !recognized || err == nil {
+								t.Fatal("rejected Go row acquired a typed immediate", form, err)
+							}
+							return
+						}
+						if !recognized || err != nil {
+							t.Fatal("accepted Go row lost its typed immediate", form, err)
+						}
+						value := int64(int32(literal.value))
+						if bits == 16 {
+							value = int64(int16(literal.value))
+						}
+						immediate := form.source
+						if three {
+							immediate = form.immediate
+						}
+						if immediate.Kind != OpImm || immediate.Imm != value {
+							t.Fatalf("descriptor disagrees with encoded immediate: %#v want %d", immediate, value)
+						}
+						effect, recognized, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+						if !recognized || err != nil || effect.operands[0].operand.Imm != value ||
+							effect.flagsDefined != x86ByteFlagCF|x86ByteFlagOF || effect.flagsKilled != x86ByteFlagsAll {
+							t.Fatalf("numeric/flag effect did not consume the same encoded immediate: %#v %v", effect, err)
+						}
+						classValue := literal.value
+						if arch == "386" {
+							classValue = int64(int32(classValue))
+						}
+						var want []byte
+						if bits == 16 {
+							want = append(want, 0x66)
+						} else if bits == 64 {
+							want = append(want, 0x48)
+						}
+						opcode, count := byte(0x69), bits/8
+						if count == 8 {
+							count = 4
+						}
+						if classValue >= -128 && classValue <= 127 {
+							opcode, count = 0x6b, 1
+						}
+						modrm := byte(0xc0)
+						if three {
+							modrm = 0xd8
+						}
+						want = append(want, opcode, modrm)
+						for i := 0; i < count; i++ {
+							want = append(want, byte(uint64(literal.value)>>(8*i)))
+						}
+						want = append(want, 0xc3)
+						code := x86PackedShiftActualGoBytes(t, arch, source)
+						if !bytes.Equal(code, want) {
+							t.Fatalf("actual Go instruction width/value changed: %x want %x", code, want)
+						}
+						if after := fmt.Sprintf("%#v", ins); before != after {
+							t.Fatal("encoded immediate normalization mutated the original instruction")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExplicitIMULImmediateThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			word, typ, move := 8, "uint64", "MOVQ"
+			if target.arch == "386" {
+				word, typ, move = 4, "uint32", "MOVL"
+			}
+			var body strings.Builder
+			fmt.Fprintf(&body, "%s x+0(FP),AX\n%s $3,BX\n", move, move)
+			for _, bits := range []int{16, 32, 64} {
+				if bits == 64 && target.arch == "386" {
+					continue
+				}
+				suffix := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+				for _, literal := range x86IMULImmediateCases {
+					if literal.only386 && target.arch != "386" {
+						continue
+					}
+					fmt.Fprintf(&body, "IMUL%s $%s,BX\nIMUL3%s $%s,AX,BX\n", suffix, literal.literal, suffix, literal.literal)
+				}
+			}
+			fmt.Fprintf(&body, "%s BX,ret0+%d(FP)\nRET", move, word)
+			pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x "+typ+") "+typ, body.String())
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+			before := fmt.Sprintf("%#v %#v", file, sig)
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, ir, "immediate-text")
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, module.String(), "immediate-module")
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "immediate-typed-go")
+			if !reflect.DeepEqual(before, fmt.Sprintf("%#v %#v", file, sig)) {
+				t.Fatal("API consumed immediate semantics by rewriting source or signature")
+			}
+		})
+	}
+}
diff --git a/x86_explicit_imul_immediate_semantics_test.go b/x86_explicit_imul_immediate_semantics_test.go
new file mode 100644
index 000000000..597506623
--- /dev/null
+++ b/x86_explicit_imul_immediate_semantics_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// This independent regression is runnable on the original production code;
+// it does not call the new result/effect descriptor or derive its reference
+// from the immediate conversion used by the emitter.
+func TestX86ExplicitIMULTwoOperandImm32OriginalGoAndLLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	pkg, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint64",
+		"MOVQ x+0(FP),BX\nIMULQ $2147483648,BX\nMOVQ BX,ret0+8(FP)\nRET")
+	_ = pkg
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":        "module imulred\n\ngo 1.20\n",
+		"value.go":      "package imulred\nfunc Value(x uint64) uint64\n",
+		"value_amd64.s": source,
+		"value_test.go": `package imulred
+import "testing"
+func TestOriginal(t *testing.T) {
+ factor:=int64(-2147483648)
+ for _,x:=range []uint64{0,1,0xfaceb00c01234567,0x8000000000000000,0xffffffffffffffff} {
+  want:=x*uint64(factor)
+  if got:=Value(x);got!=want {t.Fatalf("x=%x got=%x want=%x",x,got,want)}
+ }
+}
+`,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") {
+		t.Fatalf("original Go immediate oracle failed: %s", output)
+	}
+	t.Log("original Go accepted IMULQ imm32 and independently matched five initialized inputs")
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: map[string]FuncSig{"Value": sig},
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	reference := `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t Value(uint64_t);
+int main(void) {
+ const uint64_t inputs[]={0,1,UINT64_C(0xfaceb00c01234567),UINT64_C(0x8000000000000000),UINT64_C(0xffffffffffffffff)};
+ for(unsigned i=0;i<5;i++) {
+  uint64_t want=inputs[i]*UINT64_C(0xffffffff80000000),got=Value(inputs[i]);
+  if(got!=want) {fprintf(stderr,"original imm32 x=%llx got=%llx want=%llx\n",(unsigned long long)inputs[i],(unsigned long long)got,(unsigned long long)want);return 1;}
+ }
+ return 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(fmt.Sprint(level), func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "original-imul-imm32", ir, reference, level)
+		})
+	}
+}
diff --git a/x86_explicit_imul_source_shape_test.go b/x86_explicit_imul_source_shape_test.go
new file mode 100644
index 000000000..7f403d6f7
--- /dev/null
+++ b/x86_explicit_imul_source_shape_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ExplicitIMULCompleteGoOpcodeAttributes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	actual := regexp.MustCompile(`(?m)^\s*\{AIMUL(?:3)?[WLQ],.*$`).FindAllString(string(data), -1)
+	expected := []string{
+		`{AIMULL, yimul, Px, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AIMULQ, yimul, Pw, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AIMULW, yimul, Pe, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AIMUL3W, yimul3, Pe, opBytes{0x6b, 00, 0x69, 00}},`,
+		`{AIMUL3L, yimul3, Px, opBytes{0x6b, 00, 0x69, 00}},`,
+		`{AIMUL3Q, yimul3, Pw, opBytes{0x6b, 00, 0x69, 00}},`,
+	}
+	if len(actual) != len(expected) {
+		t.Fatalf("actual Go explicit multiply directory changed: %v", actual)
+	}
+	for index, row := range actual {
+		if strings.TrimSpace(row) != expected[index] {
+			t.Fatalf("actual opcode/table/prefix/bytes changed: %s", row)
+		}
+	}
+}
+
+func TestX86ExplicitIMULSourceRegistrationAndExactMemoryShape(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			for _, row := range x86CallerExplicitIMULRows {
+				instruction := strings.ReplaceAll(row.instruction, "@", suffix)
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					accepted := arch != "386" || suffix != "Q"
+					source := "TEXT ·Shape(SB),4,$0-0\n" + instruction + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", accepted)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					if x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) != accepted {
+						t.Fatal("source registration disagrees with complete explicit Go form")
+					}
+					for index, operand := range ins.Args {
+						if operand.Kind != OpMem {
+							continue
+						}
+						width, write, valid := x86InstructionMemoryShape(ins, index, arch)
+						if valid != accepted || accepted && (write || width != map[string]int64{"W": 2, "L": 4, "Q": 8}[suffix]) {
+							t.Fatalf("exact native source width mismatch: %d %t %t", width, write, valid)
+						}
+						if accepted {
+							x86CallerRecordMemory(&ins, index, width, false)
+							if arch == "amd64" && !x86CallerMemoryCertified(ins, index) {
+								t.Fatal("exact typed read cannot consume its instruction-local certificate")
+							}
+							ins.Args[index].Mem.Off++
+							if x86CallerMemoryCertified(ins, index) {
+								t.Fatal("edited read inherited the old memory certificate")
+							}
+						}
+					}
+					ins.Op += ".BAD"
+					if x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+						t.Fatal("constructed suffix acquired explicit IMUL registration")
+					}
+				})
+			}
+		}
+	}
+	for _, instruction := range []string{"IMULB AX", "IMULW AX", "IMULL AX", "IMULQ AX", "MULQ AX", "DIVQ AX", "IDIVQ AX"} {
+		ins := x86YMMReadSource(t, instruction)
+		if x86SourceStackInstructionKnown(ins, "MOVQ", "Q", "amd64") {
+			t.Fatalf("implicit multiply/divide acquired explicit effects: %s", instruction)
+		}
+	}
+}
diff --git a/x86_explicit_mask_move_complete_test.go b/x86_explicit_mask_move_complete_test.go
new file mode 100644
index 000000000..81a72b311
--- /dev/null
+++ b/x86_explicit_mask_move_complete_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86ExplicitMaskMoveCase struct {
+	name, instruction, bank string
+	width, memory           int
+}
+
+func x86ExplicitMaskMoveIndependentCases() []x86ExplicitMaskMoveCase {
+	var rows []x86ExplicitMaskMoveCase
+	for _, op := range []string{"VMASKMOVPS", "VMASKMOVPD", "VPMASKMOVD", "VPMASKMOVQ"} {
+		for _, width := range []int{16, 32} {
+			bank := map[int]string{16: "X", 32: "Y"}[width]
+			rows = append(rows,
+				x86ExplicitMaskMoveCase{op + bank + "Load", op + " (AX)," + bank + "1," + bank + "2", bank, width, 0},
+				x86ExplicitMaskMoveCase{op + bank + "Store", op + " " + bank + "0," + bank + "1,(AX)", bank, width, 2})
+		}
+	}
+	return rows
+}
+
+func x86ExplicitMaskMoveOriginalRuntime(t *testing.T) string {
+	t.Helper()
+	const filename = "amd64_lower_explicit_mask_move_test.go"
+	file, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"source": "5aa75bf5b240d6245928cc4293d73076be1a04d00ff8da5beed3a8a1dc63d1f7",
+		"mainC":  "381c4b7d0024fc557edd21dcb0a5758516898dd25b001583bf322fd11544db63",
+	}
+	source, owners := "", 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestAMD64ExplicitMaskMoveRuntimeSemantics" {
+			continue
+		}
+		owners++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+				return true
+			}
+			name := value.Names[0].Name
+			expected, found := want[name]
+			if !found {
+				return true
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("original explicit mask move reference lost its exact literal", name)
+			}
+			text, err := strconv.Unquote(literal.Value)
+			if err != nil || fmt.Sprintf("%x", sha256.Sum256([]byte(text))) != expected {
+				t.Fatal("original complete explicit mask move ASM/C changed", name, err)
+			}
+			if name == "source" {
+				source = text
+			}
+			delete(want, name)
+			return true
+		})
+	}
+	if owners != 1 || len(want) != 0 || source == "" {
+		t.Fatal("missing or duplicate original complete explicit mask move runtime")
+	}
+	return source
+}
+
+func TestX86ExplicitMaskMoveOriginalInitializedSourceThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original explicit mask move objects require LLVM22 llc")
+	}
+	source := x86ExplicitMaskMoveOriginalRuntime(t)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func explicitmaskmovesemantics(out,loadmem,data,mask,storemem *byte)", "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual initialized original mask/data/pointer inputs lost the complete family consumer", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ExplicitMaskMoveCompleteTypedEffectsAndSDKWidths(t *testing.T) {
+	rows := x86ExplicitMaskMoveIndependentCases()
+	if len(rows) != 16 {
+		t.Fatal("incomplete four-member X/Y load/store family", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		source.WriteString("TEXT Forms(SB),4,$0-0\n")
+		for _, row := range rows {
+			source.WriteString(row.instruction + "\n")
+		}
+		source.WriteString("RET\n")
+		requireX86GoAssemblerResult(t, arch, source.String(), true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				want := []x86TypedByteOperand{
+					{index: 0, operand: ins.Args[0], width: int64(row.width), read: true},
+					{index: 1, operand: ins.Args[1], width: int64(row.width), read: true},
+					{index: 2, operand: ins.Args[2], width: int64(row.width), write: true},
+				}
+				if !known || err != nil || !effect.requiresResultProof || !reflect.DeepEqual(effect.operands, want) ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 || effect.dynamicMemory {
+					t.Fatal("complete explicit mask family lacks its typed numerical/memory/FLAGS roles", known, err)
+				}
+				if !x86CallerVectorMoveKnown(ins) {
+					t.Fatal("caller shape diverged from the complete explicit mask grammar")
+				}
+				ins.Args = append([]Operand(nil), ins.Args...)
+				ins.Args[row.memory] = Operand{Kind: OpFP}
+				width, write, valid := X86FPAccessBytes(ins, row.memory, arch)
+				if !valid || width != int64(row.width) || write != (row.memory == 2) {
+					t.Fatal("SDK width observer lost the complete possible native tuple", width, write, valid)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveDeadEntriesCannotBorrowImplementationZeros(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch]
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			for _, unusedBool := range []bool{false, true} {
+				declaration, extent := "func Unbound()", 0
+				if unusedBool {
+					declaration, extent = "func Unbound(unused bool)", 1
+				}
+				source := fmt.Sprintf("TEXT ·Unbound(SB),4,$0-%d\n%s\nRET\n", extent, row.instruction)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/unusedBool%t/%s", arch, row.name, unusedBool, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void/unused bool invented mask, address or stored data bytes", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveInitializedCompleteFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete explicit mask move objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			for _, row := range x86ExplicitMaskMoveIndependentCases() {
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s data+%d(FP),BX\n"+
+					"%s mask+%d(FP),CX\n%s out+%d(FP),DX\nVMOVDQU (BX),%s0\nVMOVDQU (CX),%s1\nSTC\n%s\n",
+					row.name, 4*word, move, move, word, move, 2*word, move, 3*word, row.bank, row.bank, row.instruction)
+				if row.memory == 0 {
+					fmt.Fprintf(&source, "VMOVDQU %s2,(DX)\n", row.bank)
+				}
+				fmt.Fprintf(&source, "SETCS %d(DX)\nRET\n", row.width)
+				fmt.Fprintf(&declarations, "func %s(p,data,mask,out *byte)\n", row.name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized explicit mask grammar lost its public NUM/native consumer", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ExplicitMaskMoveKeepsWholeNativeMemoryOpcodeWhenDead(t *testing.T) {
+	for _, row := range x86ExplicitMaskMoveIndependentCases() {
+		t.Run(row.name, func(t *testing.T) {
+			source := fmt.Sprintf("TEXT Dead(SB),4,$0-24\nMOVQ p+0(FP),AX\nMOVQ mask+8(FP),BX\n"+
+				"MOVQ data+16(FP),CX\nVMOVDQU (BX),%s1\nVMOVDQU (CX),%s0\n%s\nRET\n", row.bank, row.bank, row.instruction)
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			file := mustParseX86RawReturn(t, source)
+			sig := FuncSig{Name: "Dead", Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+				Frame: FrameLayout{Params: []FrameSlot{
+					{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+					{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+					{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				}}}
+			// Independent emitter evidence, not a public-entry or executed
+			// fault claim. The public original/initialized owners above are separate.
+			ir := x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"Dead": sig}, "amd64", "x86_64-unknown-linux-gnu", 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				at := strings.Index(text, "@InstructionFormat0(")
+				if at < 0 {
+					t.Fatal("missing independent original instruction body")
+				}
+				body := strings.SplitN(text[at:], "\n}", 2)[0]
+				opcode := strings.ToLower(strings.Fields(row.instruction)[0]) + " "
+				if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, opcode) || !strings.Contains(body, "~{memory}") {
+					t.Fatal("dead mask move lost its exact original native access/fault effect", row.name)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_explicit_mask_move_encoder_test.go b/x86_explicit_mask_move_encoder_test.go
new file mode 100644
index 000000000..475a181a5
--- /dev/null
+++ b/x86_explicit_mask_move_encoder_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ExplicitMaskMoveIndependentCompleteEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, member := range []struct {
+		opcode, store, load string
+		w                   int
+	}{
+		{"VMASKMOVPS", "0x2E", "0x2C", 0}, {"VMASKMOVPD", "0x2F", "0x2D", 0},
+		{"VPMASKMOVD", "0x8E", "0x8C", 0}, {"VPMASKMOVQ", "0x8E", "0x8C", 1},
+	} {
+		var expected []goasmrules.X86AVXRule
+		var encoding []string
+		for index, classes := range []string{"Yxr,Yxr,Ym", "Yyr,Yyr,Ym", "Ym,Yxr,Yxr", "Ym,Yyr,Yyr"} {
+			zcase, opcode := "Zvex_r_v_rm", member.store
+			if index >= 2 {
+				zcase, opcode = "Zvex_rm_v_r", member.load
+			}
+			expected = append(expected, goasmrules.X86AVXRule{Opcode: member.opcode, Ytab: "_yvmaskmovpd", Prefix: "Pavx",
+				Classes: strings.Split(classes, ","), RowIndex: index, ZCase: zcase, ZOffset: 2, EncodingOffset: 2 * index})
+			encoding = append(encoding, fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F38 | vexW%d", 128<<(index%2), member.w), opcode)
+		}
+		for index := range expected {
+			expected[index].OpBytes = encoding
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == member.opcode {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("%s complete original Go row/offset/opcode attributes changed:\ngot %+v\nwant %+v", member.opcode, actual, expected)
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveIndependentNativeISA(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction)
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}})
+				found := make(map[string]bool)
+				for _, feature := range strings.Split(features, ",") {
+					found[feature] = true
+				}
+				want := "+avx"
+				if strings.HasPrefix(string(ins.Op), "VPMASK") {
+					want = "+avx2"
+				}
+				if !found[want] || found["+avx512f"] || found["+avx512vl"] {
+					t.Fatal("isolated explicit mask move lost its own VEX native ISA", row.name, features, want)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_explicit_mask_move_fault_policy_unix_test.go b/x86_explicit_mask_move_fault_policy_unix_test.go
new file mode 100644
index 000000000..8a1896b86
--- /dev/null
+++ b/x86_explicit_mask_move_fault_policy_unix_test.go
@@ -0,0 +1,152 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func x86ExplicitMaskMoveFaultPolicy(header, observer, driver, main string) error {
+	if observer != numericalRuntimeFaultObservationC {
+		return fmt.Errorf("fault observer must retain the shared synchronous address/code policy")
+	}
+	if err := runtimeOracleFaultCorePolicy(driver); err != nil {
+		return err
+	}
+	compact := func(text string) string { return strings.Join(strings.Fields(text), "") }
+	body, application := compact(driver), compact(main)
+	setup := "numerical_fault_begin(protectedPage,protectedBytes);"
+	if !strings.Contains(header, "#include <errno.h>") || !strings.Contains(body, setup) ||
+		strings.Index(body, setup) > strings.Index(body, "test->run(p,data,mask,out);") ||
+		!strings.Contains(application, "observe(test,region+page-extents[e],data,mask,region+page,(size_t)page)") {
+		return fmt.Errorf("actual guard-page range must be bound before invoking the fault child")
+	}
+	if !strings.Contains(body, "do{waited=waitpid(child,&status,0);}while(waited<0&&errno==EINTR);") ||
+		!strings.Contains(body, "if(waited!=child)return-2;") {
+		return fmt.Errorf("fault child must wait for its exact PID and retry EINTR only")
+	}
+	if strings.Contains(body, "WIFSIGNALED") || strings.Contains(body, "WTERMSIG") ||
+		!strings.Contains(body, "if(numerical_fault_status(status))return1;") ||
+		!strings.Contains(body, "if(WIFEXITED(status)&&WEXITSTATUS(status)==0)return0;") {
+		return fmt.Errorf("only the shared owned synchronous-fault receipt may classify a fault")
+	}
+	return nil
+}
+
+func TestX86ExplicitMaskMoveFaultObserverPolicy(t *testing.T) {
+	if err := x86ExplicitMaskMoveFaultPolicy(x86ExplicitMaskMoveActualHostHeader,
+		numericalRuntimeFaultObservationC, x86ExplicitMaskMoveActualHostDriver, x86ExplicitMaskMoveActualHostMain); err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_explicit_mask_move_portable_runtime_unix_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86ExplicitMaskMoveRuntimeOwnerPolicy(file); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func x86ExplicitMaskMoveRuntimeOwnerPolicy(file *ast.File) error {
+	owners, observers, drivers := 0, 0, 0
+	validChain := false
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86ExplicitMaskMoveActualHostValuesAliasesAndFaults" {
+			continue
+		}
+		owners++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if name, ok := node.(*ast.Ident); ok && name.Name == "numericalRuntimeFaultObservationC" {
+				observers++
+			}
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			if !ok || name.Name != "driver" {
+				return true
+			}
+			drivers++
+			var chain []string
+			ast.Inspect(assignment.Rhs[0], func(node ast.Node) bool {
+				if name, ok := node.(*ast.Ident); ok {
+					switch name.Name {
+					case "x86ExplicitMaskMoveActualHostHeader", "numericalRuntimeFaultObservationC", "x86ExplicitMaskMoveActualHostDriver":
+						chain = append(chain, name.Name)
+					}
+				}
+				return true
+			})
+			validChain = strings.Join(chain, ",") == "x86ExplicitMaskMoveActualHostHeader,numericalRuntimeFaultObservationC,x86ExplicitMaskMoveActualHostDriver"
+			return true
+		})
+	}
+	if owners != 1 || observers != 1 || drivers != 1 || !validChain {
+		return fmt.Errorf("actual driver must consume the shared observer once before the oracle: owners=%d observers=%d drivers=%d chain=%t", owners, observers, drivers, validChain)
+	}
+	return nil
+}
+
+func TestX86ExplicitMaskMoveFaultPolicyNegativeControls(t *testing.T) {
+	for _, control := range []string{"missing-observer", "user-signal", "unowned-address", "unbound-page", "late-handler", "late-core-limit", "unchecked-core-limit", "wrong-page", "missing-EINTR", "unchecked-PID", "any-signal"} {
+		t.Run(control, func(t *testing.T) {
+			header, observer := x86ExplicitMaskMoveActualHostHeader, numericalRuntimeFaultObservationC
+			driver, main := x86ExplicitMaskMoveActualHostDriver, x86ExplicitMaskMoveActualHostMain
+			switch control {
+			case "missing-observer":
+				observer = ""
+			case "user-signal":
+				observer = strings.Replace(observer, "info->si_code <= 0", "0", 1)
+			case "unowned-address":
+				observer = strings.Replace(observer, "address < atomic_load_explicit(&numerical_fault_first,memory_order_relaxed)", "0", 1)
+			case "unbound-page":
+				driver = strings.Replace(driver, "numerical_fault_begin(protectedPage,protectedBytes);", "", 1)
+			case "late-handler":
+				driver = strings.Replace(driver, "numerical_fault_begin(protectedPage,protectedBytes);", "", 1)
+				driver = strings.Replace(driver, "test->run(p,data,mask,out);", "test->run(p,data,mask,out);\n        numerical_fault_begin(protectedPage,protectedBytes);", 1)
+			case "late-core-limit":
+				driver = strings.Replace(driver, "struct rlimit no_core={0,0};", "test->run(p,data,mask,out);\n        struct rlimit no_core={0,0};", 1)
+			case "unchecked-core-limit":
+				driver = strings.Replace(driver, "if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);", "setrlimit(RLIMIT_CORE,&no_core);", 1)
+			case "wrong-page":
+				main = strings.Replace(main, "data,mask,region+page,(size_t)page", "data,mask,region,(size_t)page", 1)
+			case "missing-EINTR":
+				driver = strings.Replace(driver, "waited<0 && errno==EINTR", "0", 1)
+			case "unchecked-PID":
+				driver = strings.Replace(driver, "if(waited!=child) return -2;", "", 1)
+			case "any-signal":
+				driver = strings.Replace(driver, "numerical_fault_status(status)", "WIFSIGNALED(status)", 1)
+			}
+			if header == x86ExplicitMaskMoveActualHostHeader && observer == numericalRuntimeFaultObservationC &&
+				driver == x86ExplicitMaskMoveActualHostDriver && main == x86ExplicitMaskMoveActualHostMain {
+				t.Fatal("fault negative control did not mutate its actual source", control)
+			}
+			if err := x86ExplicitMaskMoveFaultPolicy(header, observer, driver, main); err == nil {
+				t.Fatal("weakened resource or unowned fault observation was accepted", control)
+			}
+		})
+	}
+	for _, chain := range []string{
+		"x86ExplicitMaskMoveActualHostHeader+x86ExplicitMaskMoveActualHostDriver",
+		"x86ExplicitMaskMoveActualHostHeader+numericalRuntimeFaultObservationC+numericalRuntimeFaultObservationC+x86ExplicitMaskMoveActualHostDriver",
+		"x86ExplicitMaskMoveActualHostHeader+x86ExplicitMaskMoveActualHostDriver+numericalRuntimeFaultObservationC",
+	} {
+		t.Run("actual-driver/"+chain, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), "control.go", "package plan9asm\n"+
+				"func TestX86ExplicitMaskMoveActualHostValuesAliasesAndFaults(){driver:="+chain+";_=driver}\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86ExplicitMaskMoveRuntimeOwnerPolicy(file); err == nil {
+				t.Fatal("missing/duplicate/reordered actual driver fault observer was accepted")
+			}
+		})
+	}
+}
diff --git a/x86_explicit_mask_move_field_objects_test.go b/x86_explicit_mask_move_field_objects_test.go
new file mode 100644
index 000000000..d6c67dd04
--- /dev/null
+++ b/x86_explicit_mask_move_field_objects_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ExplicitMaskMoveIndependentLogicalFieldObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("explicit mask move value-field objects require LLVM22 llc")
+	}
+	var source, declarations strings.Builder
+	for _, row := range x86ExplicitMaskMoveIndependentCases() {
+		name := row.name + "Fields"
+		fmt.Fprintf(&declarations, "func %s(data,mask [4]uint64)(a,b,c,d uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-96\nVMOVDQU data+0(FP),Y0\nVMOVDQU mask+32(FP),%s1\n", name, row.bank)
+		instruction := strings.Replace(row.instruction, "(AX)", "data+0(FP)", 1)
+		if row.memory == 2 {
+			source.WriteString("VPXOR Y3,Y3,Y3\nVMOVDQU Y3,a+64(FP)\n")
+			instruction = strings.Replace(row.instruction, "(AX)", "a+64(FP)", 1)
+		}
+		source.WriteString(instruction + "\n")
+		if row.memory == 0 {
+			source.WriteString("VMOVDQU Y2,a+64(FP)\n")
+		}
+		source.WriteString("RET\n")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete independent logical fields were treated as contiguous native FP backing", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_explicit_mask_move_grammar_test.go b/x86_explicit_mask_move_grammar_test.go
new file mode 100644
index 000000000..d2ceb74e4
--- /dev/null
+++ b/x86_explicit_mask_move_grammar_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86ExplicitMaskMoveMalformedDispatchBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			for _, control := range []string{"dispatch", "suffix", "arity", "mask-bank", "mask-width", "data-width", "all-registers", "two-memories"} {
+				t.Run(arch+"/"+row.name+"/"+control, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction)
+					op := ins.Op
+					switch control {
+					case "dispatch":
+						ins.Op = "VMASKMOVPS"
+						if ins.Op == op {
+							ins.Op = "VMASKMOVPD"
+						}
+					case "suffix":
+						op += ".Z"
+						ins.Op = op
+					case "arity":
+						ins.Args = ins.Args[:2]
+					case "mask-bank":
+						ins.Args[1].Reg = "K1"
+					case "mask-width":
+						ins.Args[1].Reg = "Z1"
+					case "data-width":
+						ins.Args[2-row.memory].Reg = "Z0"
+					case "all-registers":
+						ins.Args[row.memory] = Operand{Kind: OpReg, Reg: Reg(row.bank + "3")}
+					case "two-memories":
+						ins.Args[2-row.memory] = Operand{Kind: OpMem, Mem: MemRef{Base: BX}}
+					}
+					var output strings.Builder
+					ctx := amd64Ctx{b: &output, goarch: arch, targetTriple: "x86_64-unknown-linux-gnu"}
+					known, terminated, err := ctx.lowerExplicitMaskMove(op, ins)
+					if !known || terminated || err == nil || output.Len() != 0 {
+						t.Fatal("malformed explicit-mask shape/dispatch emitted partial IR", control, err, output.String())
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveRawNeverSuppliesMissingInputsOrEntry(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch]
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			for _, rawReturn := range []bool{false, true} {
+				source := "TEXT ·Unbound(SB),4,$0-0\n" + x86RawDisplacementDirectives(x86ExplicitMaskMoveIndependentBytes(row))
+				if rawReturn {
+					source += "BYTE $0xc3\n"
+				} else {
+					source += "RET\n"
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+row.name+"/rawReturn="+map[bool]string{true: "true", false: "false"}[rawReturn]+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Unbound()", arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw vector-mask bytes supplied missing address/data/mask or return entry", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_explicit_mask_move_inputs_test.go b/x86_explicit_mask_move_inputs_test.go
new file mode 100644
index 000000000..b715d69c6
--- /dev/null
+++ b/x86_explicit_mask_move_inputs_test.go
@@ -0,0 +1,204 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent of the production form: integer and floating spellings select
+// the high bit of each D/Q or PS/PD element, not any of its other bytes.
+func x86ExplicitMaskMoveSignOracle(row x86ExplicitMaskMoveCase) uint64 {
+	lane := 4
+	if strings.HasPrefix(row.instruction, "VMASKMOVPD ") || strings.HasPrefix(row.instruction, "VPMASKMOVQ ") {
+		lane = 8
+	}
+	var required uint64
+	for offset := lane - 1; offset < row.width; offset += lane {
+		required |= uint64(1) << uint(offset)
+	}
+	return required
+}
+
+func x86ExplicitMaskMoveInputState(arch string) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	base, _, _ := x86ResultGP(AX, x86ResultPointerWord(arch), arch)
+	state.pointerGP[base] = true
+	state.gp[3], state.canonicalGP[3], state.pointerGP[3] = 0xa5, 0x11, true
+	state.masks[5] = true
+	state.writeVector(0, 64, ^uint64(0), false)
+	state.writeVector(1, 64, ^uint64(0), false)
+	state.writeVector(2, 64, 0x13579bdf02468ace, false)
+	state.writeVector(3, 64, 0xabcdef1234567890, false)
+	return state
+}
+
+func TestX86ExplicitMaskMoveEverySignDataByteAndUnaffectedState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction)
+				for role := 0; role < 2; role++ {
+					for missing := 0; missing < 64; missing++ {
+						state := x86ExplicitMaskMoveInputState(arch)
+						state.writeVector(role, 64, ^(uint64(1) << uint(missing)), false)
+						want := state.clone()
+						required := x86ExplicitMaskMoveSignOracle(row)
+						if role == 0 {
+							required = 0
+							if row.memory == 2 {
+								required = x86CallerVectorByteMask(int64(row.width))
+							}
+							// Data is operand zero; mask is operand one.
+						}
+						accepted := required&(uint64(1)<<uint(missing)) == 0
+						if accepted && row.memory == 0 {
+							want.writeVector(2, row.width, x86CallerVectorByteMask(int64(row.width)), false)
+						}
+						got, known := x86ResultExplicitMaskMoveStep(ins, &state, nil, 0, arch, true)
+						if !known || got != accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("mask move confused sign/data/upper bytes or changed independent state", role, missing, got, accepted)
+						}
+					}
+				}
+				// A load may alias its actual mask; read the input before clearing
+				// all upper destination views. A store may alias data and mask.
+				aliased := ins
+				aliased.Args = append([]Operand(nil), ins.Args...)
+				aliased.Args[1].Reg = aliased.Args[2-row.memory].Reg
+				state := x86ExplicitMaskMoveInputState(arch)
+				if row.memory == 0 {
+					state.writeVector(2, 64, x86ExplicitMaskMoveSignOracle(row), false)
+				}
+				want := state.clone()
+				if row.memory == 0 {
+					want.writeVector(2, row.width, x86CallerVectorByteMask(int64(row.width)), false)
+				}
+				got, known := x86ResultExplicitMaskMoveStep(aliased, &state, nil, 0, arch, true)
+				if !known || !got || !reflect.DeepEqual(state, want) {
+					t.Fatal("legal same-register vector mask alias lost input-before-output ordering")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveAddressAndStandaloneBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			for _, control := range []string{"standalone", "missing-address", "numeric-not-pointer", "missing-index", "segment", "address-size", "raw-origin", "raw-encoded"} {
+				t.Run(arch+"/"+row.name+"/"+control, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction)
+					state := x86ExplicitMaskMoveInputState(arch)
+					base, full, _ := x86ResultGP(AX, x86ResultPointerWord(arch), arch)
+					native := true
+					switch control {
+					case "standalone":
+						native = false
+					case "missing-address":
+						state.pointerGP[base] = false
+					case "numeric-not-pointer":
+						state.pointerGP[base], state.gp[base] = false, full
+					case "missing-index":
+						ins.Args[row.memory].Mem.Index, ins.Args[row.memory].Mem.Scale = SI, 2
+					case "segment":
+						ins.Args[row.memory].Mem.Segment = FS
+					case "address-size":
+						ins.x86AddressBits = 32
+					case "raw-origin":
+						ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: append([]Operand(nil), ins.Args...)}
+					case "raw-encoded":
+						ins.x86Encoded = true
+					}
+					before := state.clone()
+					got, known := x86ResultExplicitMaskMoveStep(ins, &state, nil, 0, arch, native)
+					if !known || got || !reflect.DeepEqual(before, state) {
+						t.Fatal("mask move invented a numerical address, native source or backing fact", control)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveCallerConsumesActualSignBytesAndBounds(t *testing.T) {
+	for _, row := range x86ExplicitMaskMoveIndependentCases() {
+		for _, control := range []string{"complete", "unknown-sign", "unknown-data", "missing-address", "outside-region"} {
+			t.Run(row.name+"/"+control, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction)
+				state := x86SourceStackState{
+					callers: map[Reg]x86CallerPointerValue{AX: {argument: 0}},
+					vectors: map[Reg]uint64{"Z0": x86CallerVectorByteMask(int64(row.width)), "Z1": x86ExplicitMaskMoveSignOracle(row), "Z2": 0x5555},
+				}
+				kind := x86CallerSliceInput
+				if row.memory == 2 {
+					kind = x86CallerFreshResult
+				}
+				proof := &x86GoCallerRegionProof{arguments: []x86CallerArgumentRegion{{kind: kind, width: int64(row.width)}}}
+				want := control == "complete" || control == "unknown-data" && row.memory == 0
+				switch control {
+				case "unknown-sign":
+					state.vectors["Z1"] = 0
+				case "unknown-data":
+					state.vectors["Z0"] = 0
+				case "missing-address":
+					delete(state.callers, AX)
+				case "outside-region":
+					ins.Args[row.memory].Mem.Off = 1
+					// Slice inputs have their own dynamic bounds; a fixed local
+					// scalar input is enough to test this exact envelope here.
+					if row.memory == 0 {
+						proof.arguments[0].kind = x86CallerLocalLength
+					}
+				}
+				if got := x86CallerVectorMoveStep(&ins, &state, proof); got != want {
+					t.Fatal("caller proof confused numerical sign bytes with source/bounds", fmt.Sprint(got, want))
+				}
+				if want && row.memory == 0 && state.vectors["Z2"] != ^uint64(0) {
+					t.Fatal("caller load did not zero every wider destination alias")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveLogicalFieldsKeepReadWriteRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			for _, control := range []string{"initialized-result", "unknown-result", "parameter", "padding", "static"} {
+				t.Run(arch+"/"+row.name+"/"+control, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction)
+					state := x86ExplicitMaskMoveInputState(arch)
+					state.fp = make([]bool, 2*row.width)
+					owned := make([]bool, len(state.fp))
+					for index := range state.fp {
+						state.fp[index], owned[index] = true, true
+					}
+					ins.Args[row.memory] = Operand{Kind: OpFP, FPOffset: int64(row.width)}
+					want := control == "initialized-result" || control == "parameter" && row.memory == 0
+					switch control {
+					case "unknown-result":
+						for index := row.width; index < len(state.fp); index++ {
+							state.fp[index] = false
+						}
+					case "parameter":
+						ins.Args[row.memory].FPOffset = 0
+					case "padding":
+						owned[len(owned)-1] = false
+					case "static":
+						ins.Args[row.memory] = Operand{Kind: OpSym, Sym: "readonly(SB)"}
+					}
+					before := state.clone()
+					if want && row.memory == 0 {
+						before.writeVector(2, row.width, x86CallerVectorByteMask(int64(row.width)), false)
+					}
+					got, known := x86ResultExplicitMaskMoveStep(ins, &state, owned, int64(row.width), arch, false)
+					if !known || got != want || !reflect.DeepEqual(before, state) {
+						t.Fatal("masked logical memory confused prior NUM with a writable/owned span", control, got, want)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_explicit_mask_move_portable_runtime_unix_test.go b/x86_explicit_mask_move_portable_runtime_unix_test.go
new file mode 100644
index 000000000..5d34f0c7e
--- /dev/null
+++ b/x86_explicit_mask_move_portable_runtime_unix_test.go
@@ -0,0 +1,184 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This integer/page-protection oracle runs on the actual host. Foreign hosts
+// exercise guarded volatile lowering, not native x86 qualification. Matching
+// x86 hosts must actually have AVX2 and enabled XMM/YMM state, or fail.
+func TestX86ExplicitMaskMoveActualHostValuesAliasesAndFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("explicit mask move execution requires LLVM22 llc/clang")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, externs, cases strings.Builder
+	for _, row := range x86ExplicitMaskMoveIndependentCases() {
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ p+0(FP),AX\nMOVQ data+8(FP),BX\n"+
+			"MOVQ mask+16(FP),CX\nMOVQ out+24(FP),DX\nVMOVDQU (BX),%s0\n"+
+			"VMOVDQU (CX),%s1\nSTC\n%s\n", row.name, row.bank, row.bank, row.instruction)
+		if row.memory == 0 {
+			// X loads must also clear the independently observable Y alias.
+			source.WriteString("VMOVDQU Y2,(DX)\n")
+		}
+		source.WriteString("SETCS 32(DX)\nRET\n")
+		fmt.Fprintf(&declarations, "func %s(p,data,mask,out *byte)\n", row.name)
+		fmt.Fprintf(&externs, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,uint8_t*);\n", row.name)
+		lane, store := 4, 0
+		if strings.HasPrefix(row.instruction, "VMASKMOVPD ") || strings.HasPrefix(row.instruction, "VPMASKMOVQ ") {
+			lane = 8
+		}
+		if row.memory == 2 {
+			store = 1
+		}
+		fmt.Fprintf(&cases, "{%s,%d,%d,%d},\n", row.name, row.width, lane, store)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal("actual initialized complete mask move execution source rejected", err)
+	}
+	driver := x86ExplicitMaskMoveActualHostHeader + numericalRuntimeFaultObservationC +
+		x86ExplicitMaskMoveActualHostDriver + externs.String() +
+		"static const struct testcase cases[]={\n" + cases.String() + "};\n" + x86ExplicitMaskMoveActualHostMain
+	for _, pipeline := range []struct {
+		name     string
+		backend  int
+		optimize bool
+	}{{"backend_O0", 0, false}, {"backend_O2", 2, false}, {"IR_O2_backend_O2", 2, true}} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			input := ir
+			if pipeline.optimize {
+				input = x86DwordProductIROptimize(t, input)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "explicit-mask-move", triple,
+				input, driver, nil, pipeline.backend)
+		})
+	}
+	t.Log("16 shapes; every lane-mask value, data canaries, Y aliases/CF and5 masks x3 guard extents x3 pipelines; original Go/native reference execution remains separate")
+}
+
+const x86ExplicitMaskMoveActualHostHeader = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#if defined(__x86_64__) || defined(__i386__)
+#include <cpuid.h>
+#endif
+struct testcase {
+    void (*run)(uint8_t*,const uint8_t*,const uint8_t*,uint8_t*);
+    unsigned width,lane,store;
+};
+`
+
+const x86ExplicitMaskMoveActualHostDriver = `
+static void setmask(uint8_t *mask,unsigned width,unsigned lane,unsigned bits) {
+    for(unsigned i=0;i<32;i++) mask[i]=(uint8_t)(0x35+17*i);
+    for(unsigned i=0;i<width/lane;i++)
+        mask[(i+1)*lane-1]=(uint8_t)((mask[(i+1)*lane-1]&127)|(((bits>>i)&1)<<7));
+}
+static int observe(const struct testcase *test,uint8_t *p,const uint8_t *data,const uint8_t *mask,
+                   uint8_t *protectedPage,size_t protectedBytes) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        uint8_t out[33]={0};
+        numerical_fault_begin(protectedPage,protectedBytes);
+        test->run(p,data,mask,out);
+        _exit(out[32]==1?0:121);
+    }
+    int status=0;
+    pid_t waited;
+    do { waited=waitpid(child,&status,0); } while(waited<0 && errno==EINTR);
+    if(waited!=child) return -2;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(numerical_fault_status(status)) return 1;
+    return -3;
+}
+static int host_preflight(void) {
+#if defined(__x86_64__) || defined(__i386__)
+    unsigned a,b,c,d,avx=0,avx2=0,osxsave=0;
+    uint64_t xcr0=0;
+    if(__get_cpuid(1,&a,&b,&c,&d)) {
+        avx=(c>>28)&1; osxsave=(c>>27)&1;
+        if(osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    if(__get_cpuid_count(7,0,&a,&b,&c,&d)) avx2=(b>>5)&1;
+    printf("EXPLICIT_MASK_MOVE AVX=%u AVX2=%u OSXSAVE=%u XCR0=%llx\n",
+           avx,avx2,osxsave,(unsigned long long)xcr0);
+    fflush(stdout);
+    if(!avx || !avx2 || !osxsave || (xcr0&6)!=6) return 1;
+#endif
+    return 0;
+}
+`
+
+const x86ExplicitMaskMoveActualHostMain = `
+int main(void) {
+    if(host_preflight()) return 1;
+    uint8_t input[34],data[32],mask[32],out[34],memory[34];
+    for(unsigned i=0;i<32;i++) {
+        input[i+1]=(uint8_t)(0x21+7*i);
+        data[i]=(uint8_t)(0xc3-3*i);
+    }
+    for(unsigned n=0;n<sizeof(cases)/sizeof(cases[0]);n++) {
+        const struct testcase *test=cases+n;
+        unsigned lanes=test->width/test->lane;
+        for(unsigned pattern=0;pattern<(1u<<lanes);pattern++) {
+            setmask(mask,test->width,test->lane,pattern);
+            memset(out,0x69,sizeof(out));
+            memset(memory,0x5a,sizeof(memory));
+            test->run(test->store?memory+1:input+1,data,mask,out);
+            if(out[32]!=1 || out[33]!=0x69) return 2;
+            for(unsigned i=0;i<32;i++) {
+                unsigned active=i<test->width && ((pattern>>(i/test->lane))&1);
+                unsigned want=test->store?0x69:(active?input[i+1]:0);
+                if(out[i]!=want) return 3;
+                want=test->store && active?data[i]:0x5a;
+                if(memory[i+1]!=want) return 4;
+            }
+            if(memory[0]!=0x5a || memory[33]!=0x5a) return 5;
+        }
+    }
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 6;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 7;
+    for(unsigned n=0;n<sizeof(cases)/sizeof(cases[0]);n++) {
+        const struct testcase *test=cases+n;
+        unsigned lanes=test->width/test->lane;
+        unsigned masks[]={0,1,1u<<(lanes-1),0x55,(1u<<lanes)-1};
+        unsigned extents[]={0,test->lane,test->width};
+        for(unsigned m=0;m<5;m++) for(unsigned e=0;e<3;e++) {
+            unsigned required=0;
+            setmask(mask,test->width,test->lane,masks[m]);
+            for(unsigned i=0;i<lanes;i++) if((masks[m]>>i)&1) required=(i+1)*test->lane;
+            int got=observe(test,region+page-extents[e],data,mask,region+page,(size_t)page);
+            if(got!=(required>extents[e])) {
+                fprintf(stderr,"case=%u mask=%x extent=%u got=%d required=%u\n",n,masks[m],extents[e],got,required);
+                return 8;
+            }
+        }
+    }
+    if(munmap(region,2*page)) return 9;
+    puts("EXPLICIT_MASK_MOVE_VALUES_ALIASES_CF_AND_ACTIVE_LANE_FAULTS_OK");
+    return 0;
+}
+`
diff --git a/x86_explicit_mask_move_raw_test.go b/x86_explicit_mask_move_raw_test.go
new file mode 100644
index 000000000..46c54d67c
--- /dev/null
+++ b/x86_explicit_mask_move_raw_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independently encode all sixteen VEX memory forms: ModRM.reg is data,
+// VEX.vvvv is the vector mask, and ModRM.r/m is the actual AX address.
+func x86ExplicitMaskMoveIndependentBytes(row x86ExplicitMaskMoveCase) []byte {
+	op := strings.Fields(row.instruction)[0]
+	opcode := map[string]byte{"VMASKMOVPS": 0x2c, "VMASKMOVPD": 0x2d, "VPMASKMOVD": 0x8c, "VPMASKMOVQ": 0x8c}[op]
+	prefix, modrm := byte(0x71), byte(0x10)
+	if row.width == 32 {
+		prefix |= 4
+	}
+	if op == "VPMASKMOVQ" {
+		prefix |= 128
+	}
+	if row.memory == 2 {
+		opcode |= 2
+		modrm = 0
+	}
+	return []byte{0xc4, 0xe2, prefix, opcode, modrm}
+}
+
+func x86ExplicitMaskMoveRawProgram(row x86ExplicitMaskMoveCase, arch string) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s data+%d(FP),BX\n"+
+		"%s mask+%d(FP),CX\nVMOVDQU (BX),%s0\nVMOVDQU (CX),%s1\nSTC\n%sRET\n",
+		row.name, word*3, move, move, word, move, word*2, row.bank, row.bank,
+		x86RawDisplacementDirectives(x86ExplicitMaskMoveIndependentBytes(row)))
+}
+
+func TestX86ExplicitMaskMoveRawPhysicalIdentityAndWholeReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ExplicitMaskMoveIndependentCases() {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				code := x86ExplicitMaskMoveIndependentBytes(row)
+				mode := map[string]int{"386": 32, "amd64": 64}[arch]
+				ins, consumed, known, err := decodedX86ExplicitMaskMoveInstruction(code, mode)
+				want := x86ScalarLaneInstruction(t, row.instruction)
+				if !known || err != nil || consumed != len(code) || ins.Op != want.Op ||
+					!reflect.DeepEqual(ins.Args, want.Args) || !ins.x86Encoded {
+					t.Fatal("complete independently encoded VEX source lost its physical form", known, consumed, ins.Raw, err)
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86ExplicitMaskMoveRawProgram(row, arch)), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				ordinal := len(fn.Instrs) - 2
+				if !x86RawExplicitMaskMoveSource(fn.Instrs[ordinal], arch) {
+					t.Fatal("exact raw vector mask source lost its independent decoded identity")
+				}
+				word := x86ResultPointerWord(arch)
+				sig := FuncSig{Name: row.name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void}
+				for index := 0; index < 3; index++ {
+					sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(index) * word, Type: Ptr, Index: index, Field: -1})
+				}
+				check := func(candidate Func) error {
+					ctx := newX86Ctx(new(strings.Builder), candidate, sig, nil, nil,
+						arch, map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch], false)
+					return ctx.checkLoweredScalarFPResultInitialization()
+				}
+				if err := check(fn); err != nil {
+					t.Fatal("initialized raw source lost its exact paired original-opcode consumer", err)
+				}
+				for _, control := range []struct {
+					name string
+					edit func(*Func)
+				}{
+					{"origin-only", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw = nil }},
+					{"encoded", func(fn *Func) { fn.Instrs[ordinal].x86Encoded = false }},
+					{"snapshot", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw.explicitMaskMove = x86RawExplicitMaskMoveIdentity{} }},
+					{"snapshot-mode", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw.explicitMaskMove.arch = "other" }},
+					{"changed-mask", func(fn *Func) { fn.Instrs[ordinal].Args[1].Reg = Reg(row.bank + "3") }},
+					{"producer", func(fn *Func) { fn.Instrs[1].Raw += " " }},
+					{"missing-replay", func(fn *Func) { fn.x86RawReplay = nil }},
+				} {
+					changed := fn
+					changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+					control.edit(&changed)
+					if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed raw source bypassed the complete real lowering consumer", control.name, err)
+					}
+					if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+						t.Fatal("replay clone modified the sealed original source", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ExplicitMaskMoveInitializedRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete raw explicit mask move objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, row := range x86ExplicitMaskMoveIndependentCases() {
+				source.WriteString(x86ExplicitMaskMoveRawProgram(row, target.arch))
+				fmt.Fprintf(&declarations, "func %s(p,data,mask *byte)\n", row.name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized raw vector-mask source lost its public paired consumer", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_feature_dispatch_test.go b/x86_feature_dispatch_test.go
new file mode 100644
index 000000000..db4df1bbf
--- /dev/null
+++ b/x86_feature_dispatch_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import "testing"
+
+func TestX86FeatureDispatchFamilyBoundaries(t *testing.T) {
+	for _, row := range []struct {
+		instruction, amd64, mode32 string
+	}{
+		{"ANDPS X0,X1", "", ""},
+		{"ANDPS (AX),X1", "+sse", "+sse"},
+		{"ANDPD (AX),X1", "+sse2", "+sse2"},
+		{"PAND (AX),X1", "+sse2", "+sse2"},
+		{"PAND M0,M1", "", ""},
+		{"VPAND Z0,Z1,Z2", "", ""},
+		{"VXORPS.BCST (AX),X1,X2", "", ""},
+		{"VXORPS.Z X0,X1,X2", "", ""},
+		{"VMOVAPS (AX),X1", "+avx", "+avx"},
+		{"VMOVAPS.Z (AX),K1,X1", "+avx512f,+avx512vl", "+avx512f,+avx512vl"},
+		{"VMOVDQA32 (AX),Z1", "+avx512f", "+avx512f"},
+		{"VMOVAPS (AX),X16", "+avx512f,+avx512vl", ""},
+		{"VMOVDQA (AX),X1", "+avx", "+avx"},
+		{"VMOVDQA.Z (AX),K1,X1", "", ""},
+		{"VMOVDQU64 (AX),Z1", "", ""},
+		{"VMOVDQA32.Z X0,K1,(AX)", "", ""},
+		{"VMOVAPS.SAE (AX),X1", "", ""},
+		{"VMOVAPD.Z (AX),K0,X1", "", ""},
+		{"VCVTSD2SS X0,X1,X2", "+avx", "+avx"},
+	} {
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				want := row.amd64
+				if arch == "386" {
+					want = row.mode32
+				}
+				file, err := Parse(ArchAMD64, "TEXT before(SB),4,$0-0\nVCVTSD2SS X0,X1,X2\nRET\n"+
+					"TEXT isolated(SB),4,$0-0\n"+row.instruction+"\nRET\nTEXT after(SB),4,$0-0\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for index, expected := range []string{"+avx", want, ""} {
+					if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[index]); got != expected {
+						t.Fatalf("function %d: got %q, want %q", index, got, expected)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_feature_inference_bench_test.go b/x86_feature_inference_bench_test.go
new file mode 100644
index 000000000..ff575cb07
--- /dev/null
+++ b/x86_feature_inference_bench_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Parsing is excluded. These fixed functions isolate family recognition and
+// feature aggregation; they do not measure lowering or LLVM compilation.
+func BenchmarkX86FeatureInference(b *testing.B) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"MOVL AX,BX",
+			"VPXOR X0,X1,X2",
+			"VMOVUPS Y0,Y1",
+			"PADDL X0,X1",
+			"PSHUFB X0,X1",
+			"VCVTSD2SS X0,X1,X2",
+			"ADDL AX,BX",
+			"LEAL 8(AX)(BX*2),CX",
+			"JEQ feature_done",
+		} {
+			b.Run(arch+"/"+row, func(b *testing.B) {
+				tail := "RET\n"
+				if row == "JEQ feature_done" {
+					tail = "feature_done:\n" + tail
+				}
+				file, err := Parse(ArchAMD64, "TEXT feature(SB),4,$0-0\n"+
+					strings.Repeat(row+"\n", 64)+tail)
+				if err != nil {
+					b.Fatal(err)
+				}
+				b.ReportAllocs()
+				b.ResetTimer()
+				for iteration := 0; iteration < b.N; iteration++ {
+					x86FeatureInferenceBenchmarkSink = inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0])
+				}
+			})
+		}
+	}
+}
+
+var x86FeatureInferenceBenchmarkSink string
+
+// Include analysis, lowering and LLVM verification for one initialized GP
+// function. This is separate from the inference-only benchmark above.
+func BenchmarkX86BaselineGPTranslation(b *testing.B) {
+	source := "TEXT feature(SB),4,$0-0\nMOVL $1,AX\nMOVL $3,BX\n" +
+		strings.Repeat("ADDL AX,BX\nLEAL 8(AX)(BX*2),CX\nJEQ feature_done\n", 64) +
+		"feature_done:\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		b.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+		Sigs: map[string]FuncSig{"feature": {Name: "feature", Ret: Void}}}
+	if _, err := Translate(file, options); err != nil {
+		b.Fatal("benchmark must complete before timing", err)
+	}
+	b.ReportAllocs()
+	b.ResetTimer()
+	for iteration := 0; iteration < b.N; iteration++ {
+		if _, err := Translate(file, options); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/x86_float_compare_format_unit_test.go b/x86_float_compare_format_unit_test.go
new file mode 100644
index 000000000..8d97eb5f2
--- /dev/null
+++ b/x86_float_compare_format_unit_test.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+import "testing"
+
+func x86FloatingCompareUnboundFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	for index, function := range file.Funcs {
+		decoded, err := decodeX86RawDirectives(function, arch)
+		if err != nil {
+			t.Fatal("original format unit lost its complete physical decoder", err)
+		}
+		// Retain the decoder's original raw provenance. This emitter-only
+		// object is not a public source, initialized input or native ABI grant.
+		file.Funcs[index] = decoded
+	}
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			return c.lowerFloatingCompare(ins.Op, ins)
+		})
+}
diff --git a/x86_float_compare_result_bytes_test.go b/x86_float_compare_result_bytes_test.go
new file mode 100644
index 000000000..cfac86a16
--- /dev/null
+++ b/x86_float_compare_result_bytes_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingCompareResultEveryByteMaskAndAlias(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FloatCompareGoForms(arch) {
+			ins := x86ScalarLaneInstruction(t, row)
+			form, known, err := x86FloatCompareProperties(ins, arch)
+			if !known || err != nil {
+				t.Fatal("independent original-Go comparison row lost its grammar", row, err)
+			}
+			width := form.byteWidth
+			if strings.HasSuffix(string(ins.Op), "SS") || strings.HasSuffix(string(ins.Op), "SD") || form.scalar {
+				width = form.bits / 8
+			}
+			required := x86CallerVectorByteMask(int64(width))
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+			state.pointerGP[0], state.gp[1], state.masks[1] = true, 0xff, true
+			for index := 0; index < 32; index++ {
+				pattern := uint64(0xaaaaaaaaaaaaaaaa)
+				if index&1 != 0 {
+					pattern = ^pattern
+				}
+				state.writeVector(index, 64, pattern|required, false)
+			}
+			before := state.clone()
+			if accepted, owned := x86ResultFloatCompareStep(ins, &state, nil, arch, true); !owned || !accepted {
+				t.Fatal("initialized complete comparison failed numerical continuation", arch, row)
+			}
+			expected := before.clone()
+			if form.maskResult {
+				index, _ := amd64ParseKReg(ins.Args[form.destination].Reg)
+				expected.masks[index] = true
+			} else {
+				destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+				second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+				bytes := ^uint64(0)
+				if form.legacy {
+					bytes = before.vectorBytes(destination) | required
+				} else if form.scalar {
+					bytes = ^uint64(0xffff) | required | before.vectorBytes(second)&(0xffff&^required)
+				}
+				expected.writeVector(destination, 64, bytes, false)
+			}
+			if !reflect.DeepEqual(state, expected) {
+				t.Fatal("comparison changed FLAGS, DF, inputs or inactive aliases", arch, row)
+			}
+			for _, ordinal := range []int{form.first, form.second, form.mask} {
+				if ordinal < 0 || ordinal == form.memory {
+					continue
+				}
+				limit := width
+				if ordinal == form.mask {
+					limit = 1
+				}
+				for missing := 0; missing < limit; missing++ {
+					current := before.clone()
+					if ordinal == form.mask {
+						index, _ := amd64ParseKReg(ins.Args[ordinal].Reg)
+						current.masks[index] = false
+					} else {
+						index, _ := amd64VectorRegisterIndex(ins.Args[ordinal].Reg, form.byteWidth)
+						current.writeVector(index, 64, current.vectorBytes(index)&^(uint64(1)<<uint(missing)), false)
+					}
+					initial := current.clone()
+					if accepted, _ := x86ResultFloatCompareStep(ins, &current, nil, arch, true); accepted || !reflect.DeepEqual(current, initial) {
+						t.Fatal("missing comparison byte/mask invented a result or partially changed state", arch, row, ordinal, missing)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatingCompareNativeContinuationRetainsSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FloatCompareGoForms(arch) {
+			ins := x86ScalarLaneInstruction(t, row)
+			form, _, err := x86FloatCompareProperties(ins, arch)
+			if err != nil || form.memory < 0 {
+				continue
+			}
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.pointerGP[0], state.gp[1], state.masks[1] = true, 0xff, true
+			for index := 0; index < 32; index++ {
+				state.writeVector(index, 64, ^uint64(0), false)
+			}
+			for _, change := range []string{"standalone", "pointer", "numeric base", "partial base", "index", "raw", "address size"} {
+				current, changed := state.clone(), ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				native := true
+				switch change {
+				case "standalone":
+					native = false
+				case "pointer", "numeric base", "partial base":
+					current.pointerGP[0] = false
+					if change == "numeric base" {
+						current.gp[0] = 0xff
+					} else if change == "partial base" {
+						current.gp[0] = 1
+					}
+				case "index":
+					changed.Args[form.memory].Mem.Index, changed.Args[form.memory].Mem.Scale = DX, 2
+				case "raw":
+					changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+				case "address size":
+					changed.x86AddressBits = 16
+				}
+				before := current.clone()
+				if change == "numeric base" {
+					expected := before.clone()
+					if form.maskResult {
+						index, _ := amd64ParseKReg(ins.Args[form.destination].Reg)
+						expected.masks[index] = true
+					}
+					accepted, known := x86ResultFloatCompareStep(changed, &current, nil, arch, native)
+					if !known || !accepted || !reflect.DeepEqual(current, expected) {
+						t.Fatal("complete numerical address changed independent comparison state", arch, row)
+					}
+					continue
+				}
+				if accepted, _ := x86ResultFloatCompareStep(changed, &current, nil, arch, native); accepted || !reflect.DeepEqual(current, before) {
+					t.Fatal("unproved comparison supplied native bytes or changed state", arch, row, change)
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatingCompareMaskDestinationDoesNotBorrowOldInput(t *testing.T) {
+	for _, row := range []string{"VCMPPS $0,Z0,Z1,K1,K1", "VCMPSS $255,X0,X1,K1,K1"} {
+		for _, mask := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/known-%t", row, mask), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				state := x86ResultState{}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.masks[1] = mask
+				before := state.clone()
+				accepted, _ := x86ResultFloatCompareStep(ins, &state, nil, "amd64", true)
+				if accepted != mask || !reflect.DeepEqual(state, before) {
+					t.Fatal("K destination initialized its own missing writemask input")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_float_compare_result_test.go b/x86_float_compare_result_test.go
new file mode 100644
index 000000000..c63f57741
--- /dev/null
+++ b/x86_float_compare_result_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These complete source programs do not borrow a caller/frame certificate or
+// zero-initialized implementation slots. The opcode inventory is independent
+// of the shared implementation map; existing Go-row tests own its full grammar.
+func x86FloatingCompareResultPrograms(arch string) (string, string, []string) {
+	var assembly, declarations strings.Builder
+	var names []string
+	for _, opcode := range []string{"CMPPS", "CMPPD", "CMPSS", "CMPSD", "VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		vector := strings.HasPrefix(opcode, "V")
+		scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		if arch == "386" && vector {
+			continue // Named V compares have no Go mode32 row; raw roles stay separate.
+		}
+		banks := []string{"X"}
+		if vector && !scalar {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			for _, mask := range []bool{false, true} {
+				if mask && !vector || !mask && bank == "Z" {
+					continue
+				}
+				name := fmt.Sprint("Compare", len(names))
+				names = append(names, name)
+				fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-4\n", name)
+				zero := "PXOR"
+				if vector {
+					zero = "VXORPS"
+					if bank == "Z" {
+						zero = "VPXORD"
+					}
+				}
+				for _, register := range []int{0, 1} {
+					operands := fmt.Sprintf("%s%d,%s%d", bank, register, bank, register)
+					if vector {
+						operands += fmt.Sprintf(",%s%d", bank, register)
+					}
+					fmt.Fprintf(&assembly, "%s %s\n", zero, operands)
+				}
+				destination := "X1"
+				if vector {
+					destination = bank + "2"
+					if mask {
+						destination = "K2"
+					}
+					fmt.Fprintf(&assembly, "%s $0,%s0,%s1,%s\n", opcode, bank, bank, destination)
+				} else {
+					fmt.Fprintf(&assembly, "%s X0,X1,$0\n", opcode)
+				}
+				if mask {
+					assembly.WriteString("KMOVD K2,AX\n")
+				} else {
+					assembly.WriteString("MOVL " + strings.Replace(destination, bank, "X", 1) + ",AX\n")
+				}
+				assembly.WriteString("MOVL AX,ret+0(FP)\nRET\n")
+			}
+		}
+	}
+	return assembly.String(), declarations.String(), names
+}
+
+func TestX86FloatingCompareCompleteSourceResultObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86FloatingCompareResultPrograms(target.arch)
+			expected := 18
+			if target.arch == "386" {
+				expected = 4
+			}
+			if len(names) != expected {
+				t.Fatal("incomplete independent comparison result inventory", len(names), expected)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete floating compare result lost its typed byte effect", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						if strings.Count(text, "asm sideeffect") < len(names) {
+							t.Fatal("original comparison/MXCSR effects became optional numerical operations")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FloatingCompareVoidCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		original, _, _ := x86FloatingCompareResultPrograms(arch)
+		file, err := Parse(ArchAMD64, original)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for index, function := range file.Funcs {
+			for _, unusedBool := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%d/bool-%t", arch, index, unusedBool), func(t *testing.T) {
+					arguments, declaration := 0, "func Value()"
+					if unusedBool {
+						arguments, declaration = 1, "func Value(unused bool)"
+					}
+					var body strings.Builder
+					fmt.Fprintf(&body, "TEXT ·Value(SB),4,$0-%d\n", arguments)
+					for _, ins := range function.Instrs[1:] {
+						if strings.HasPrefix(string(ins.Op), "CMP") || strings.HasPrefix(string(ins.Op), "VCMP") {
+							body.WriteString(ins.Raw + "\n")
+							break
+						}
+						body.WriteString(ins.Raw + "\n")
+					}
+					body.WriteString("RET\n")
+					source := body.String()
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					first := function.Instrs[1].Raw + "\n"
+					changed := strings.Replace(source, first, "", 1)
+					both := strings.Replace(changed, function.Instrs[2].Raw+"\n", "", 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); ir == "" || err != nil {
+							t.Fatal("initialized Void comparison lost its original native effect", api, err)
+						}
+						for role, missing := range map[string]string{"first source": changed, "both sources": both} {
+							ir, err := x86ScalarFPBitViewAPI(t, missing, declaration, arch, triple, api)
+							if arch == "amd64" && unusedBool {
+								x86VectorScratchCodegenControl(t, missing, declaration, arch, triple, ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void or unused bool supplied undefined comparison bytes", role, api, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_float_compare_runtime_source_objects_test.go b/x86_float_compare_runtime_source_objects_test.go
new file mode 100644
index 000000000..99c2adbfe
--- /dev/null
+++ b/x86_float_compare_runtime_source_objects_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Replay the original complete LLVM runtime fixtures, not cropped instruction
+// probes. Compilation on this host is not native SSE/VEX/EVEX execution.
+func TestX86FloatingCompareOriginalRuntimeProgramsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, opcode := range x86FloatCompareOpcodes() {
+			t.Run(triple+"/"+opcode, func(t *testing.T) {
+				cases := x86FloatCompareOracleCases(opcode)
+				if len(cases) == 0 {
+					t.Fatal("original complete runtime fixture omitted its opcode", opcode)
+				}
+				source, _ := x86FloatCompareOracleAssembly(cases, false)
+				var declarations strings.Builder
+				var names []string
+				for index := range cases {
+					name := fmt.Sprint("compare", index)
+					names = append(names, name)
+					fmt.Fprintf(&declarations, "func %s(out,a,b *[80]byte,mask uint64)\n", name)
+				}
+				x86LEAActualTargetGoObject(t, "amd64", triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api)
+						if err != nil {
+							t.Fatal("complete original floating comparison runtime source remains unclosed", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86CompactExpandRequireAllDefinitions(t, text, names)
+							if strings.Count(text, strings.ToLower(opcode)+" $$") != len(names) {
+								t.Fatal("original whole comparison or dead FP effects disappeared", opcode)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, text, level)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86FloatingCompareOriginalScalarFPRuntimeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	fixtures := x86FloatCompareFPOracles(t)
+	if len(fixtures) != 48 {
+		t.Fatal("incomplete original scalar FP runtime fixture inventory", len(fixtures))
+	}
+	source, _ := x86FloatCompareFPAssembly(fixtures)
+	var declarations strings.Builder
+	var names []string
+	for _, fixture := range fixtures {
+		declarations.WriteString(fixture.declaration)
+		names = append(names, fixture.name)
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("original scalar FP-field runtime source remains unclosed", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_floating_helper_result_test.go b/x86_floating_helper_result_test.go
new file mode 100644
index 000000000..60fb02433
--- /dev/null
+++ b/x86_floating_helper_result_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86FloatingHelperInitializedState() x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	state.gp[3], state.pointerGP[0], state.masks[1] = 0x55, true, true
+	for index := 0; index < 32; index++ {
+		state.writeVector(index, 64, ^uint64(0), false)
+	}
+	return state
+}
+
+func x86FloatingHelperMaskedInstruction(ins Instr, zero bool) Instr {
+	ins.Args = append([]Operand(nil), ins.Args...)
+	last := ins.Args[len(ins.Args)-1]
+	ins.Args = append(ins.Args[:len(ins.Args)-1], Operand{Kind: OpReg, Reg: "K1"}, last)
+	if zero {
+		ins.Op += ".Z"
+	}
+	return ins
+}
+
+func TestX86FloatingHelperEveryNumericalInputMaskAndMergeByte(t *testing.T) {
+	for _, member := range x86FloatingHelperOracleMembers() {
+		banks := []string{member.bank}
+		if !member.scalar && !member.maskResult {
+			banks = []string{"X", "Y", "Z"}
+		}
+		for _, bank := range banks {
+			member.bank = bank
+			original := x86ScalarLaneInstruction(t, x86FloatingHelperOracleInstruction(member, false))
+			width := amd64VectorByteWidth(original.Args[len(original.Args)-1].Reg)
+			if member.maskResult {
+				width = amd64VectorByteWidth(original.Args[1].Reg)
+			}
+			active := width
+			if member.scalar {
+				active = 4
+				if strings.HasSuffix(member.name, "SD") {
+					active = 8
+				}
+			}
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if member.maskResult && mode == "zero" {
+					continue
+				}
+				ins := original
+				if mode != "plain" {
+					ins = x86FloatingHelperMaskedInstruction(ins, mode == "zero")
+				}
+				for _, arch := range []string{"amd64", "386"} {
+					if arch == "386" && len(ins.Args) > 3 {
+						continue
+					}
+					state := x86FloatingHelperInitializedState()
+					before := state.clone()
+					if accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, arch, true); !known || !accepted {
+						t.Fatal("complete initialized helper lost its typed numerical inputs", arch, member.name, bank, mode)
+					}
+					want := before.clone()
+					if member.maskResult {
+						want.masks[2] = true
+					} else {
+						want.writeVector(2, width, ^uint64(0), false)
+					}
+					if !reflect.DeepEqual(state, want) {
+						t.Fatal("helper changed independent inputs, FLAGS, DF, pointers or storage", arch, member.name, bank, mode)
+					}
+					for _, source := range []int{0, 1, 2, -1} {
+						required := source == 0 || source == 1 && member.second || source == 2 &&
+							!member.maskResult && (strings.HasPrefix(member.name, "VFIXUPIMM") || mode == "merge") || source == -1 && mode != "plain"
+						if !required {
+							continue
+						}
+						limit := active
+						if source < 0 {
+							limit = 1
+						}
+						for missing := 0; missing < limit; missing++ {
+							current := before.clone()
+							if source < 0 {
+								current.masks[1] = false
+							} else {
+								current.writeVector(source, 64, current.vectorBytes(source)&^(uint64(1)<<uint(missing)), false)
+							}
+							initial := current.clone()
+							if accepted, _ := x86ResultFloatingHelperStep(ins, &current, nil, arch, true); accepted || !reflect.DeepEqual(current, initial) {
+								t.Fatal("helper invented a missing source/mask/merge byte or partially changed state", arch, member.name, bank, mode, source, missing)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86FloatingHelperScalarPassthroughRemainsSparse(t *testing.T) {
+	for _, member := range x86FloatingHelperOracleMembers() {
+		if !member.scalar || member.maskResult {
+			continue
+		}
+		ins := x86ScalarLaneInstruction(t, x86FloatingHelperOracleInstruction(member, false))
+		active := 4
+		if strings.HasSuffix(member.name, "SD") {
+			active = 8
+		}
+		for missing := 0; missing < 16; missing++ {
+			state := x86FloatingHelperInitializedState()
+			state.writeVector(1, 64, state.vectorBytes(1)&^(uint64(1)<<uint(missing)), false)
+			before := state.clone()
+			accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, "amd64", true)
+			if member.second && missing < active {
+				if accepted || !known || !reflect.DeepEqual(state, before) {
+					t.Fatal("scalar arithmetic supplied a missing low second source", member.name, missing)
+				}
+				continue
+			}
+			want := before.clone()
+			defined := ^uint64(0)
+			if missing >= active {
+				defined &^= uint64(1) << uint(missing)
+			}
+			want.writeVector(2, 16, defined, false)
+			if !accepted || !known || !reflect.DeepEqual(state, want) {
+				t.Fatal("scalar passthrough lost unknown bytes or used ignored low bytes", member.name, missing)
+			}
+		}
+	}
+}
+
+func TestX86FloatingHelperNativeContinuationRetainsItsSourceBoundary(t *testing.T) {
+	for _, member := range x86FloatingHelperOracleMembers() {
+		original := x86ScalarLaneInstruction(t, x86FloatingHelperOracleInstruction(member, true))
+		for _, arch := range []string{"386", "amd64"} {
+			if arch == "386" && len(original.Args) > 3 {
+				continue
+			}
+			for _, mutation := range []string{"valid", "standalone", "pointer", "numerical address", "partial address", "index", "raw", "address size", "source selector"} {
+				ins := original
+				ins.Args = append([]Operand(nil), original.Args...)
+				state := x86FloatingHelperInitializedState()
+				native := true
+				first := 0
+				if member.immediate {
+					first = 1
+				}
+				switch mutation {
+				case "standalone":
+					native = false
+				case "pointer", "numerical address", "partial address":
+					state.pointerGP[0] = false
+					if mutation == "numerical address" {
+						state.gp[0] = 0xff
+					} else if mutation == "partial address" {
+						state.gp[0] = 1
+					}
+				case "index":
+					ins.Args[first].Mem.Index, ins.Args[first].Mem.Scale = DX, 2
+				case "raw":
+					ins.x86SourceRaw = &x86SourceRawInstruction{op: original.Op, args: original.Args}
+				case "address size":
+					ins.x86AddressBits = 16
+				case "source selector":
+					if !member.immediate {
+						continue
+					}
+					ins.Args[0].ImmIsFloat = true
+				}
+				before := state.clone()
+				accepted, known := x86ResultFloatingHelperStep(ins, &state, nil, arch, native)
+				if mutation == "valid" || mutation == "numerical address" {
+					expected := before.clone()
+					if member.maskResult {
+						expected.masks[2] = true
+					}
+					if !accepted || !known || !reflect.DeepEqual(state, expected) {
+						t.Fatal("incoming native pointer lost paired helper continuation", arch, member.name)
+					}
+				} else if accepted || !known || !reflect.DeepEqual(state, before) {
+					t.Fatal("unproved helper input granted native data or changed state", arch, member.name, mutation)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_floating_minmax_inputs_test.go b/x86_floating_minmax_inputs_test.go
new file mode 100644
index 000000000..4f27edba7
--- /dev/null
+++ b/x86_floating_minmax_inputs_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86FloatingMinMaxEveryInputByteAndUpperAlias(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FloatingMinMaxFormats(arch) {
+			if strings.Contains(row, "(AX)") {
+				continue // Native tuples have separate paired-read and literal owners.
+			}
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				f, known, err := x86FloatMinMaxProperties(ins, arch)
+				if !known || err != nil {
+					t.Fatal(row, err)
+				}
+				active := f.byteWidth
+				if f.scalar {
+					active = f.bits / 8
+				}
+				for missing := -1; missing < 193; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.gp[5], state.pointerGP[7], state.callerAddressGP[7], state.masks[1] = 0x53, true, true, true
+					for register := 0; register < 3; register++ {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					want := true
+					if missing == 192 {
+						state.masks[1], want = false, f.mask < 0
+					} else if missing >= 0 {
+						register, bit := missing/64, uint(missing%64)
+						state.writeVector(register, 64, state.vectorBytes(register)&^(uint64(1)<<bit), false)
+						want = int(bit) >= active || register != 0 && register != 1 &&
+							(f.mask < 0 || f.zeroing)
+					}
+					before := state.clone()
+					accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+					if accepted != want {
+						t.Fatal("missing numerical/mask input", row, missing, accepted, want)
+					}
+					if want {
+						index, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+						value := x86CallerVectorByteMask(int64(f.byteWidth))
+						required := x86CallerVectorByteMask(int64(active))
+						if f.legacy {
+							value = before.vectorBytes(index) | required
+						} else if f.scalar {
+							value = required | before.vectorBytes(1)&^required
+						}
+						before.writeVector(index, f.byteWidth, value, f.legacy)
+					}
+					if !reflect.DeepEqual(state, before) {
+						t.Fatal("MIN/MAX invented passthrough bytes or changed unrelated state", row, missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86FloatingMinMaxCallerConsumesSameTypedInputs(t *testing.T) {
+	for _, row := range x86FloatingMinMaxFormats("amd64") {
+		if strings.Contains(row, "(AX)") {
+			continue
+		}
+		ins := x86ScalarLaneInstruction(t, row)
+		f, known, err := x86FloatMinMaxProperties(ins, "amd64")
+		if !known || err != nil || !x86CallerVectorMoveKnown(ins) {
+			t.Fatal("caller lacks the complete MIN/MAX registration", row, err)
+		}
+		for _, missing := range []int{-1, f.first, f.second, f.destination, 4} {
+			state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)},
+				masks: map[Reg]bool{"K1": true}}
+			if missing >= 0 && missing < len(ins.Args) {
+				state.vectors[x86CallerVectorRoot(ins.Args[missing].Reg)] &^= 1
+			}
+			if missing == 4 {
+				state.masks["K1"] = false
+			}
+			before, masks := x86CloneCallerVectorState(state.vectors, state.masks)
+			accepted := x86CallerVectorMoveStep(&ins, &state, nil)
+			want := missing == -1 || missing == f.destination && !f.legacy &&
+				(f.mask < 0 || f.zeroing) || missing == 4 && f.mask < 0
+			if accepted != want || !reflect.DeepEqual(state.masks, masks) || !accepted && !reflect.DeepEqual(state.vectors, before) {
+				t.Fatal("caller invented source, merge or mask bytes", row, missing, accepted, want)
+			}
+		}
+	}
+}
diff --git a/x86_floating_minmax_native_c_test.go b/x86_floating_minmax_native_c_test.go
new file mode 100644
index 000000000..a2def7226
--- /dev/null
+++ b/x86_floating_minmax_native_c_test.go
@@ -0,0 +1,64 @@
+//go:build darwin || (linux && amd64)
+
+package plan9asm
+
+import (
+	"debug/elf"
+	"debug/macho"
+	"os"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// Compile/link the complete original-byte C oracle even without native x86
+// execution. This gate needs no Rosetta, QEMU or AVX-capable host CPU.
+func TestX86FloatingMinMaxNativeCCompileLinkOnly(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	compiler := []string{clang, "-target", triple}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	rows := x86MinMaxNativeCases()
+	if len(rows) != 128 {
+		t.Fatal("complete SSE/VEX native oracle inventory changed", len(rows))
+	}
+	source, declarations, driver := x86MinMaxNativeDriver(t, rows, triple)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: triple, compiler: compiler}
+	binary := execution.compileLLVM(t, "minmax-all-native-c", ir, driver, "-O2")
+	if runtime.GOOS == "darwin" {
+		object, err := macho.Open(binary)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer object.Close()
+		if object.Cpu != macho.CpuAmd64 {
+			t.Fatal("native C oracle linked for a different CPU", object.Cpu)
+		}
+	} else {
+		object, err := elf.Open(binary)
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer object.Close()
+		if object.Machine != elf.EM_X86_64 {
+			t.Fatal("native C oracle linked for a different CPU", object.Machine)
+		}
+	}
+	t.Log("128 original-byte MIN/MAX programs and C oracle compiled+linked; NOT executed")
+}
diff --git a/x86_floating_minmax_native_runtime_unix_test.go b/x86_floating_minmax_native_runtime_unix_test.go
new file mode 100644
index 000000000..02aef78f8
--- /dev/null
+++ b/x86_floating_minmax_native_runtime_unix_test.go
@@ -0,0 +1,353 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// Legacy and VEX are independent of the still-pending EVEX hardware owner.
+// The five register partitions and two memory/base aliases cover operand
+// identity without multiplying the implementation by concrete registers.
+type x86MinMaxNativeCase struct {
+	op                   string
+	bits, width          int
+	carrierWidth         int
+	source, second, dest int
+	registerBase         int
+	legacy, scalar, dead bool
+}
+
+func x86MinMaxNativeCases() []x86MinMaxNativeCase {
+	var rows []x86MinMaxNativeCase
+	for _, member := range x86FloatingMinMaxCases {
+		widths := []int{16}
+		carrierWidth := 16
+		aliases := [][3]int{{1, 2, 2}, {2, 2, 2}, {-1, 2, 2}}
+		if !member.legacy {
+			carrierWidth = 32
+			aliases = [][3]int{{0, 1, 2}, {2, 1, 2}, {0, 2, 2}, {1, 1, 2}, {2, 2, 2}, {-1, 0, 2}, {-1, 2, 2}}
+			if !member.scalar {
+				widths = append(widths, 32)
+			}
+		}
+		for _, width := range widths {
+			for index := 0; index <= len(aliases); index++ {
+				alias := aliases[len(aliases)-1]
+				if index < len(aliases) {
+					alias = aliases[index]
+				}
+				rows = append(rows, x86MinMaxNativeCase{
+					op: member.op, bits: member.bits, width: width,
+					carrierWidth: carrierWidth,
+					source:       alias[0], second: alias[1], dest: alias[2],
+					legacy: member.legacy, scalar: member.scalar, dead: index == len(aliases),
+				})
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86MinMaxNativeCase) operation(memory string) string {
+	bank := "X"
+	if row.width == 32 {
+		bank = "Y"
+	}
+	first := memory
+	if row.source >= 0 {
+		first = fmt.Sprintf("%s%d", bank, row.source+row.registerBase)
+	}
+	if row.legacy {
+		return fmt.Sprintf("%s %s,%s%d", row.op, first, bank, row.dest+row.registerBase)
+	}
+	return fmt.Sprintf("%s %s,%s%d,%s%d", row.op, first, bank, row.second+row.registerBase, bank, row.dest+row.registerBase)
+}
+
+func (row x86MinMaxNativeCase) memoryRegister() string {
+	if row.registerBase != 0 {
+		return "R9"
+	}
+	return "BX"
+}
+
+func x86MinMaxNativeRawCases(rows []x86MinMaxNativeCase) []x86MinMaxNativeCase {
+	result := append([]x86MinMaxNativeCase(nil), rows...)
+	for index := range result {
+		result[index].carrierWidth = 32
+	}
+	for _, row := range rows {
+		row.registerBase = 8
+		row.carrierWidth = 32
+		result = append(result, row)
+	}
+	return result
+}
+
+func (row x86MinMaxNativeCase) body(original bool) string {
+	first, memory, old, control := "AX", "BX", "CX", "MOVL csr+32(FP),DX\nMOVL DX,44(DI)\n"
+	if original {
+		// SysV C arguments: out=DI, a=SI, b=DX, old=CX, csr=R8.
+		first, memory = "SI", "R9"
+		control = "MOVQ DX,R9\nMOVL R8,44(DI)\n"
+	} else if row.registerBase != 0 {
+		memory = row.memoryRegister()
+		control += "MOVQ BX,R9\n"
+	}
+	second := memory
+	if row.source < 0 {
+		// A scalar memory operand must not acquire a preparatory m256 load.
+		second = first
+	}
+	load, bank := "VMOVUPS", "Y"
+	if row.carrierWidth == 16 {
+		// Keep the named SSE/SSE2 owner runnable without AVX state. The
+		// raw owner additionally observes preserved physical Y upper bytes.
+		load, bank = "MOVUPS", "X"
+	}
+	var source strings.Builder
+	source.WriteString(control)
+	for index, input := range []string{first, second, old} {
+		fmt.Fprintf(&source, "%s (%s),%s%d\n", load, input, bank, row.registerBase+index)
+	}
+	// Seed AF explicitly rather than infer it from an emulator's ADD result.
+	// OF still comes from ADD; SAHF sets SF/ZF/AF/PF/CF and preserves OF.
+	source.WriteString("STMXCSR 32(DI)\nLDMXCSR 44(DI)\nMOVL $0x7fffffff,DX\nADDL $1,DX\nMOVB $0x95,AH\nSAHF\nSTD\n")
+	if original {
+		// The independent native observer can retain reserved hardware FLAGS.
+		// Do not turn those unmodeled bits into translator numerical inputs.
+		source.WriteString("PUSHFQ\nPOPQ R10\nMOVL R10,48(DI)\n")
+	}
+	fmt.Fprintln(&source, row.operation("("+memory+")"))
+	source.WriteString("PUSHFQ\nPOPQ DX\nANDL $0xcd5,DX\nCLD\n")
+	if row.dead {
+		fmt.Fprintf(&source, "%s (%s),%s%d\n", load, old, bank, row.dest+row.registerBase)
+	}
+	fmt.Fprintf(&source, "%s %s%d,(DI)\nMOVL DX,40(DI)\nSTMXCSR 36(DI)\nLDMXCSR 32(DI)\n", load, bank, row.dest+row.registerBase)
+	if row.carrierWidth == 32 {
+		source.WriteString("VZEROUPPER\n")
+	}
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func x86MinMaxNativeProgram(rows []x86MinMaxNativeCase) (source, declarations, prototypes, kernels string) {
+	var assembly, decl, c, metadata strings.Builder
+	for index, row := range rows {
+		name, original := fmt.Sprintf("MinMax%d", index), fmt.Sprintf("OriginalMinMax%d", index)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-36\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ old+24(FP),CX\n%s", name, row.body(false))
+		fmt.Fprintf(&decl, "func %s(out *[64]byte,a,b,old *[32]byte,csr uint32)\n", name)
+		fmt.Fprintf(&c, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint32_t);\n", name)
+		fmt.Fprintf(&c, "extern void %s(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint32_t);\n", original)
+		minimum := strings.Contains(row.op, "MIN")
+		fmt.Fprintf(&metadata, "{%s,%s,%d,%d,%d,%d,%d,%d,%t,%t,%t,%t},\n", name, original,
+			row.bits, row.width, row.carrierWidth, row.source, row.second, row.dest, row.legacy, row.scalar, row.dead, minimum)
+	}
+	return assembly.String(), decl.String(), c.String(), metadata.String()
+}
+
+func x86MinMaxNativeDriver(t *testing.T, rows []x86MinMaxNativeCase, triple string) (source, declarations, driver string) {
+	t.Helper()
+	source, declarations, prototypes, kernels := x86MinMaxNativeProgram(rows)
+	var originals strings.Builder
+	for index, row := range rows {
+		original := fmt.Sprintf("OriginalMinMax%d", index)
+		code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+row.body(true))
+		var bytes []string
+		for _, value := range code {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+		}
+		symbol := original
+		if strings.Contains(triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+	}
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	fixture, err := os.ReadFile("testdata/x86_floating_minmax_native.c")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver = strings.NewReplacer("@PROTOTYPES@", prototypes, "@ORIGINALS@", originals.String(), "@KERNELS@", kernels).Replace(string(fixture))
+	return source, declarations, driver
+}
+
+func x86MinMaxNativeRuntime(t *testing.T, legacy bool) {
+	x86MinMaxNativeRuntimeEncoding(t, legacy, false)
+}
+
+// Preserve the same independent hardware/IEEE oracle for named and raw inputs.
+// Only the public translator's spelling of the instruction changes.
+func x86MinMaxNativeRawSource(t *testing.T, source string, rows []x86MinMaxNativeCase) string {
+	t.Helper()
+	encodings := make(map[string]string)
+	for _, row := range rows {
+		operation := row.operation("(" + row.memoryRegister() + ")")
+		if _, exists := encodings[operation]; exists {
+			continue
+		}
+		// NOSPLIT|NOFRAME leaves exactly this operation and its explicit RET.
+		// The x/arch decoder does not supply an independent VEX length oracle.
+		code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),516,$0-0\n"+operation+"\nRET\n")
+		if len(code) < 2 || len(code) > 16 || code[len(code)-1] != 0xc3 {
+			t.Fatal("original MIN/MAX encoding lacks its final RET", operation, code)
+		}
+		if row.legacy {
+			prefix := 0
+			if code[0] == 0x66 || code[0] == 0xf2 || code[0] == 0xf3 {
+				prefix++
+			}
+			if (code[prefix]&0xf0 == 0x40) != (row.registerBase != 0) {
+				t.Fatal("original legacy MIN/MAX lost its low/REX bank witness", operation, code)
+			}
+		} else {
+			prefix := byte(0xc5)
+			if row.registerBase != 0 {
+				prefix = 0xc4
+			}
+			if code[0] != prefix {
+				t.Fatal("original MIN/MAX lost its VEX2/VEX3 witness", operation, code)
+			}
+		}
+		encodings[operation] = x86RawDisplacementDirectives(code[:len(code)-1])
+	}
+	for operation, encoded := range encodings {
+		source = strings.ReplaceAll(source, "\n"+operation+"\n", "\n"+encoded)
+	}
+	if strings.Contains(source, "MIN") || strings.Contains(source, "MAX") {
+		t.Fatal("raw MIN/MAX source retained a named instruction")
+	}
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	return source
+}
+
+func x86MinMaxNativeRuntimeEncoding(t *testing.T, legacy, raw bool) {
+	t.Helper()
+	execution := x86FloatCompareExecutionTools(t)
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+		execution.compiler = append(execution.compiler, flags...)
+	}
+	if raw || !legacy {
+		execution.requireAVX(t)
+	}
+	all := x86MinMaxNativeCases()
+	if len(all) != 128 {
+		t.Fatal("complete eight legacy/eight VEX alias basis changed", len(all))
+	}
+	var rows []x86MinMaxNativeCase
+	for _, row := range all {
+		if row.legacy == legacy {
+			rows = append(rows, row)
+		}
+	}
+	wantCount, numerical, faults, exceptions := 96, 393216, 360, 768
+	if legacy {
+		wantCount, numerical, faults, exceptions = 32, 131072, 160, 256
+	}
+	if len(rows) != wantCount {
+		t.Fatal("complete native alias owner lost rows", legacy, len(rows))
+	}
+	if raw {
+		rows = x86MinMaxNativeRawCases(rows)
+		wantCount *= 2
+		numerical *= 2
+		faults *= 2
+		exceptions *= 2
+	}
+	source, declarations, driver := x86MinMaxNativeDriver(t, rows, execution.triple)
+	if raw {
+		source = x86MinMaxNativeRawSource(t, source, rows)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("O2=%t", optimized), func(t *testing.T) {
+					input, level := ir, "-O0"
+					if optimized {
+						input, level = x86MulDivRoundOptimize(t, ir), "-O2"
+					}
+					output := execution.compileAndRunLLVM(t, "minmax-native", input, driver, level)
+					want := fmt.Sprintf("%d MIN/MAX kernels: numerical %d, faults %d, exceptions %d, tripwires 2; failures 0\n", wantCount, numerical, faults, exceptions)
+					if string(output) != want {
+						t.Fatal("original-byte/LLVM MIN/MAX values, MXCSR, FLAGS or reads differ:", string(output))
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingMinMaxLegacy(t *testing.T) {
+	x86MinMaxNativeRuntime(t, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingMinMaxVEX(t *testing.T) {
+	x86MinMaxNativeRuntime(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingMinMaxRawLegacy(t *testing.T) {
+	x86MinMaxNativeRuntimeEncoding(t, true, true)
+}
+
+func TestCrossLinuxRuntimeMatrixX86FloatingMinMaxRawVEX(t *testing.T) {
+	x86MinMaxNativeRuntimeEncoding(t, false, true)
+}
+
+func TestX86FloatingMinMaxNativeAliasObjects(t *testing.T) {
+	x86MinMaxNativeAliasObjects(t, false)
+}
+
+func TestX86FloatingMinMaxRawNativeAliasObjects(t *testing.T) {
+	x86MinMaxNativeAliasObjects(t, true)
+}
+
+func x86MinMaxNativeAliasObjects(t *testing.T, raw bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86MinMaxNativeCases()
+	if len(rows) != 128 {
+		t.Fatal("complete native source alias inventory changed", len(rows))
+	}
+	if raw {
+		rows = x86MinMaxNativeRawCases(rows)
+	}
+	source, declarations, _, _ := x86MinMaxNativeProgram(rows)
+	if raw {
+		source = x86MinMaxNativeRawSource(t, source, rows)
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+					x86PackedStringCompileObject(t, llc, triple, x86MulDivRoundOptimize(t, ir), "-O2")
+				})
+			}
+		})
+	}
+}
diff --git a/x86_floating_minmax_objects_test.go b/x86_floating_minmax_objects_test.go
new file mode 100644
index 000000000..cb3240f13
--- /dev/null
+++ b/x86_floating_minmax_objects_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86FloatingMinMaxInitializedObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete initialized MIN/MAX objects require LLVM22 llc")
+	}
+	rows := x86FloatingMinMaxFormats(arch)
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	for start := 0; start < len(rows); start += 48 {
+		end := start + 48
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint("batch-", start/48), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index := start; index < end; index++ {
+				ins := x86ScalarLaneInstruction(t, rows[index])
+				f, known, err := x86FloatMinMaxProperties(ins, arch)
+				if !known || err != nil {
+					t.Fatal(rows[index], err)
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[f.byteWidth]
+				fmt.Fprintf(&source, "TEXT ·MinMax%d(SB),4,$0-%d\n%s p+0(FP),AX\n%s out+%d(FP),BX\n",
+					index, 2*word, move, move, word)
+				for register := 0; register < 3; register++ {
+					if f.legacy {
+						fmt.Fprintf(&source, "XORPS X%d,X%d\n", register, register)
+					} else {
+						fmt.Fprintf(&source, "VXORPS %s%d,%s%d,%s%d\n", bank, register, bank, register, bank, register)
+					}
+				}
+				if f.mask >= 0 {
+					source.WriteString("MOVL $85,CX\nKMOVW CX,K1\n")
+				}
+				store := "VMOVUPS"
+				if f.legacy {
+					store = "MOVUPS"
+				}
+				fmt.Fprintf(&source, "%s\n%s %s,(BX)\nRET\n", rows[index], store, ins.Args[f.destination].Reg)
+				fmt.Fprintf(&declarations, "func MinMax%d(p,out *byte)\n", index)
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized MIN/MAX format lost its actual inputs", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						for index := start; index < end; index++ {
+							marker := fmt.Sprintf("@MinMax%d(", index)
+							at := strings.Index(pipeline.ir, marker)
+							if at < 0 {
+								t.Fatal("missing initialized function", marker)
+							}
+							body := strings.SplitN(pipeline.ir[at:], "\n}", 2)[0]
+							op := strings.ToLower(strings.Split(strings.Fields(rows[index])[0], ".")[0])
+							found := 0
+							for _, line := range strings.Split(body, "\n") {
+								if strings.Contains(line, "asm sideeffect") &&
+									(strings.Contains(line, "\""+op+" ") || strings.Contains(line, " "+op+" ")) {
+									found++
+									if !strings.Contains(line, "~{fpsr}") || !strings.Contains(line, "~{memory}") || strings.Contains(line, "~{flags}") {
+										t.Fatal("MIN/MAX lost MXCSR/access effects or changed integer FLAGS", rows[index], line)
+									}
+								}
+							}
+							if found != 1 {
+								t.Fatal("original whole MIN/MAX opcode missing or duplicated", rows[index], found)
+							}
+							if strings.Contains(body, " fcmp ") {
+								t.Fatal("native MIN/MAX was replaced by a pure numerical relation", rows[index])
+							}
+						}
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FloatingMinMaxInitializedLinuxAMD64Objects(t *testing.T) {
+	x86FloatingMinMaxInitializedObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86FloatingMinMaxInitializedDarwinAMD64Objects(t *testing.T) {
+	x86FloatingMinMaxInitializedObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86FloatingMinMaxInitializedWindowsAMD64Objects(t *testing.T) {
+	x86FloatingMinMaxInitializedObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86FloatingMinMaxInitializedLinux386Objects(t *testing.T) {
+	x86FloatingMinMaxInitializedObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86FloatingMinMaxInitializedWindows386Objects(t *testing.T) {
+	x86FloatingMinMaxInitializedObjects(t, "386", "i686-pc-windows-msvc")
+}
diff --git a/x86_floating_minmax_raw_identity_test.go b/x86_floating_minmax_raw_identity_test.go
new file mode 100644
index 000000000..6d8b1d090
--- /dev/null
+++ b/x86_floating_minmax_raw_identity_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86FloatingMinMaxRawCase struct {
+	name, instruction string
+	code              []byte
+	evex              bool
+	width             int
+}
+
+func x86FloatingMinMaxRawCases() []x86FloatingMinMaxRawCase {
+	var rows []x86FloatingMinMaxRawCase
+	for _, member := range x86FloatingMinMaxCases {
+		pp := byte(0)
+		if member.bits == 64 {
+			pp++
+		}
+		if member.scalar {
+			pp += 2
+		}
+		opcode := byte(0x5d)
+		if strings.Contains(member.op, "MAX") {
+			opcode = 0x5f
+		}
+		if member.legacy {
+			code := []byte{0x0f, opcode, 0xd0}
+			if pp != 0 {
+				code = append([]byte{map[byte]byte{1: 0x66, 2: 0xf3, 3: 0xf2}[pp]}, code...)
+			}
+			rows = append(rows, x86FloatingMinMaxRawCase{member.op, member.op + " X0,X2", code, false, 16})
+			continue
+		}
+		for _, generation := range []string{"VEX2", "VEX3", "EVEX"} {
+			for _, width := range []int{16, 32, 64} {
+				if member.scalar && width != 16 || generation != "EVEX" && width == 64 {
+					continue
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				code := encodeX86VEXBinaryFloat(opcode, pp, generation == "VEX3", width == 32, false, 2, 1, 0)
+				if generation == "EVEX" {
+					code = encodeX86EVEXBinaryFloat(opcode, pp, byte(map[int]int{16: 0, 32: 1, 64: 2}[width]), false, false, 0, 2, 1, 0)
+				}
+				rows = append(rows, x86FloatingMinMaxRawCase{
+					fmt.Sprintf("%s_%s_%d", member.op, generation, width),
+					member.op + " " + bank + "0," + bank + "1," + bank + "2", code, generation == "EVEX", width,
+				})
+			}
+		}
+	}
+	return rows
+}
+
+func x86FloatingMinMaxRawSource(row x86FloatingMinMaxRawCase) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", row.name)
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[row.width]
+	for register := 0; register < 3; register++ {
+		if strings.HasPrefix(row.name, "V") {
+			fmt.Fprintf(&source, "VXORPS %s%d,%s%d,%s%d\n", bank, register, bank, register, bank, register)
+		} else {
+			fmt.Fprintf(&source, "XORPS X%d,X%d\n", register, register)
+		}
+	}
+	source.WriteString(x86RawDisplacementDirectives(row.code))
+	source.WriteString("RET\n")
+	return source.String()
+}
+
+func TestX86FloatingMinMaxPhysicalGenerationAndWholeReplay(t *testing.T) {
+	rows := x86FloatingMinMaxRawCases()
+	if len(rows) != 48 {
+		t.Fatal("incomplete independent legacy/VEX2/VEX3/EVEX physical directory", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range rows {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86FloatingMinMaxRawSource(row)), arch)
+				if err != nil {
+					t.Fatal(row.name, err)
+				}
+				fn := file.Funcs[0]
+				ordinal := len(fn.Instrs) - 2
+				ins := fn.Instrs[ordinal]
+				f, known, err := x86FloatMinMaxProperties(ins, arch)
+				if !known || err != nil || !x86RawFloatMinMaxSource(ins, arch) ||
+					ins.x86SourceRaw.floatMinMax.arch != arch || ins.x86FloatMinMaxEVEX != row.evex ||
+					x86FloatMinMaxNativeEVEX(ins, f) != row.evex {
+					t.Fatal("physical MIN/MAX lost its mode/generation snapshot", row.name, err)
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}})
+				if strings.Contains(features, "+avx512f") != row.evex ||
+					strings.Contains(features, "+avx512vl") != (row.evex && !f.scalar && row.width < 64) {
+					t.Fatal("raw MIN/MAX lost its isolated original native ISA", row.name, features)
+				}
+				check := func(fn Func) error {
+					ctx := newX86Ctx(new(strings.Builder), fn, FuncSig{Name: row.name, Ret: Void}, nil, nil,
+						arch, map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch], false)
+					return ctx.checkLoweredScalarFPResultInitialization()
+				}
+				if err := check(fn); err != nil {
+					t.Fatal("complete initialized raw program lost its paired native owner", row.name, err)
+				}
+				for _, control := range []struct {
+					name string
+					edit func(*Func)
+				}{
+					{"origin only", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw = nil }},
+					{"physical generation", func(fn *Func) { fn.Instrs[ordinal].x86FloatMinMaxEVEX = !row.evex }},
+					{"snapshot generation", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw.floatMinMax.evex = !row.evex }},
+					{"absent snapshot", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw.floatMinMax = x86RawFloatMinMaxIdentity{} }},
+					{"producer", func(fn *Func) { fn.Instrs[1].Raw += " " }},
+					{"missing replay", func(fn *Func) { fn.x86RawReplay = nil }},
+				} {
+					changed := fn
+					changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+					control.edit(&changed)
+					if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed physical source bypassed the real lowering consumer", row.name, control.name, err)
+					}
+					if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+						t.Fatal("mutable replay clone corrupted original generation", err)
+					}
+				}
+				if !x86ResultPreservesPrivateStorage(ins, arch) ||
+					x86ResultDirectionAfterSource(ins, x86ResultDirectionBackward, arch) != x86ResultDirectionBackward {
+					t.Fatal("exact MIN/MAX confused numerical writes with independent private or DF state")
+				}
+				var addresses [16]bool
+				addresses[7] = true
+				if x86ResultCallerAddressesAfter(ins, addresses, nil, arch) != addresses {
+					t.Fatal("MIN/MAX changed an independently proved GP identity")
+				}
+			})
+		}
+	}
+}
+
+func TestX86FloatingMinMaxUnmaskedRawGenerationFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete raw MIN/MAX generation objects require LLVM22 llc")
+	}
+	var source, declarations strings.Builder
+	for _, row := range x86FloatingMinMaxRawCases() {
+		source.WriteString(x86FloatingMinMaxRawSource(row))
+		fmt.Fprintf(&declarations, "func %s()\n", row.name)
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized raw generation lost public native translation", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_floating_minmax_result_test.go b/x86_floating_minmax_result_test.go
new file mode 100644
index 000000000..a48974764
--- /dev/null
+++ b/x86_floating_minmax_result_test.go
@@ -0,0 +1,204 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86FloatingMinMaxCase struct {
+	op             string
+	bits           int
+	legacy, scalar bool
+}
+
+// Independent list of the eight yxm opcodes and eight AVX _yvaddpd/_yvaddsd
+// members. MIN/MAX optab attributes enable SAE, not ADD/MUL's ER controls.
+var x86FloatingMinMaxCases = []x86FloatingMinMaxCase{
+	{"MINPS", 32, true, false}, {"MINPD", 64, true, false},
+	{"MINSS", 32, true, true}, {"MINSD", 64, true, true},
+	{"MAXPS", 32, true, false}, {"MAXPD", 64, true, false},
+	{"MAXSS", 32, true, true}, {"MAXSD", 64, true, true},
+	{"VMINPS", 32, false, false}, {"VMINPD", 64, false, false},
+	{"VMINSS", 32, false, true}, {"VMINSD", 64, false, true},
+	{"VMAXPS", 32, false, false}, {"VMAXPD", 64, false, false},
+	{"VMAXSS", 32, false, true}, {"VMAXSD", 64, false, true},
+}
+
+func TestX86FloatingMinMaxIndependentNativeISAProfiles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FloatingMinMaxCases {
+			for _, width := range []int{16, 32, 64} {
+				if (row.legacy || row.scalar) && width != 16 {
+					continue
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				instruction := row.op + " " + bank + "0," + bank + "1," + bank + "2"
+				want := "+avx"
+				if width == 64 {
+					want = "+avx512f"
+				}
+				if row.legacy {
+					instruction = row.op + " X0,X1"
+					want = "+sse"
+					if row.bits == 64 {
+						want = "+sse2"
+					}
+				}
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, row.op, width), func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0])
+					if !strings.Contains(features, want) {
+						t.Fatalf("MIN/MAX borrowed a sibling ISA: want %s in %q", want, features)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FloatingMinMaxCompleteNumericalTransfers(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FloatingMinMaxCases {
+			for _, width := range []int{16, 32, 64} {
+				if (row.legacy || row.scalar) && width != 16 {
+					continue
+				}
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				instruction := row.op + " " + bank + "0," + bank + "1," + bank + "2"
+				if row.legacy {
+					instruction = row.op + " X0,X1"
+				}
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, row.op, width), func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					// Parse retains original TEXT metadata; transfer exactly the
+					// independently specified arithmetic instruction, not TEXT.
+					ins := file.Funcs[0].Instrs[1]
+					if ins.Op != Op(row.op) {
+						t.Fatal("independent MIN/MAX fixture instruction changed", ins.Op)
+					}
+					active := width
+					if row.scalar {
+						active = row.bits / 8
+					}
+					mask := x86CallerVectorByteMask(int64(active))
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.writeVector(0, width, mask, true)
+					state.writeVector(1, width, mask, true)
+					if row.scalar {
+						state.xmm[1] |= 0xa500 // Partly known passthrough, not invented zeros.
+					}
+					want := state
+					destination := 2
+					known := mask
+					if row.scalar {
+						known |= uint64(state.xmm[1]) &^ mask
+					}
+					if row.legacy {
+						destination = 1
+						known |= state.vectorBytes(1)
+					}
+					want.writeVector(destination, width, known, row.legacy)
+					accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+					if !accepted || !reflect.DeepEqual(state, want) {
+						t.Fatalf("MIN/MAX effects: accepted=%t xmm=%v want=%v upper=%v want=%v",
+							accepted, state.xmm, want.xmm, state.vectorUpper, want.vectorUpper)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FloatingMinMaxVoidCannotBorrowImplementationInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86FloatingMinMaxCases {
+			instruction := row.op + " X0,X1,X2"
+			if row.legacy {
+				instruction = row.op + " X0,X1"
+			}
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				t.Run(target.triple+"/"+row.op+"/"+api, func(t *testing.T) {
+					options := Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs:       map[string]FuncSig{"Value": {Name: "Value", Ret: Void}},
+						ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+					ir, err := x86PackedFloatStorageAPI(api, file, options)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead MIN/MAX borrowed implementation vector inputs", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FloatingMinMaxCompleteNativeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("native MIN/MAX objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		counts := make(map[string]int)
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		index := 0
+		for _, row := range x86FloatingMinMaxCases {
+			for _, width := range []int{16, 32, 64} {
+				if (row.legacy || row.scalar) && width != 16 {
+					continue
+				}
+				name := fmt.Sprintf("minmax%d", index)
+				index++
+				counts[row.op]++
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				load := "VMOVUPS"
+				if width == 16 {
+					load = "MOVUPS"
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s a+0(FP),AX\n%s b+%d(FP),BX\n%s out+%d(FP),CX\n",
+					name, 3*word, move, move, word, move, 2*word)
+				fmt.Fprintf(&source, "%s (AX),%s0\n%s (BX),%s1\n", load, bank, load, bank)
+				if row.legacy {
+					fmt.Fprintf(&source, "%s X0,X1\nMOVUPS X1,(CX)\nRET\n", row.op)
+				} else {
+					fmt.Fprintf(&source, "%s %s0,%s1,%s2\n%s %s2,(CX)\nRET\n", row.op, bank, bank, bank, load, bank)
+				}
+				fmt.Fprintf(&declarations, "func %s(a,b,out *byte)\n", name)
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete independent MIN/MAX source", err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for op, count := range counts {
+						if strings.Count(text, "asm sideeffect \""+strings.ToLower(op)+" ") != count {
+							t.Fatal("original MIN/MAX opcode or floating side effects disappeared", op)
+						}
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_fma3_access_receipt_test.go b/x86_fma3_access_receipt_test.go
new file mode 100644
index 000000000..73d6e5e96
--- /dev/null
+++ b/x86_fma3_access_receipt_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The unchanged C parent validates every child's actual wait status before
+// publishing stdout. QEMU diagnostics remain a separate, counted stream:
+// neither missing children nor unrelated stderr may borrow that receipt.
+func x86FMA3PortableAccessReceipt(stdout, stderr []byte, commandErr error, want string, faults int, emulated bool) error {
+	if commandErr != nil {
+		return commandErr
+	}
+	if faults < 0 || faults > 6*len(x86FMA3PortableAccessCases()) {
+		return fmt.Errorf("invalid independent fault inventory")
+	}
+	if !bytes.Equal(stdout, []byte(want)) {
+		return fmt.Errorf("incomplete portable access observation")
+	}
+	if !emulated {
+		if len(stderr) != 0 {
+			return fmt.Errorf("unexpected native access diagnostics")
+		}
+		return nil
+	}
+	const segmentation = "qemu: uncaught target signal 11 (Segmentation fault) - core dumped"
+	const bus = "qemu: uncaught target signal 7 (Bus error) - core dumped"
+	if len(stderr) > faults*(len(segmentation)+1) {
+		return fmt.Errorf("excess guest-child diagnostics")
+	}
+	lines := strings.Split(string(stderr), "\n")
+	if len(lines) != faults+1 || lines[len(lines)-1] != "" {
+		return fmt.Errorf("incomplete guest-child fault inventory")
+	}
+	for _, line := range lines[:faults] {
+		if line != segmentation && line != bus {
+			return fmt.Errorf("unexpected guest-child fault diagnostic")
+		}
+	}
+	return nil
+}
+
+func TestX86FMA3PortableAccessReceiptRetainsExactStreamsAndFaults(t *testing.T) {
+	const want = "portable FMA dead-q: admitted=14 context=0 reference=98 translated=98\n"
+	const diagnostic = "qemu: uncaught target signal 11 (Segmentation fault) - core dumped\n"
+	const bus = "qemu: uncaught target signal 7 (Bus error) - core dumped\n"
+	const faults = 66 // Eleven nonempty rows, three fault probes, two implementations.
+	if len(x86FMA3PortableAccessCases()) != 14 {
+		t.Fatal("complete original case inventory changed")
+	}
+	nonempty := 0
+	for _, row := range x86FMA3PortableAccessCases() {
+		if row.bytes != 0 {
+			nonempty++
+		}
+	}
+	if nonempty*3*2 != faults {
+		t.Fatal("independent full reference/translated fault inventory changed")
+	}
+	for _, test := range []struct {
+		name, stdout, stderr string
+		faults               int
+		emulated, valid      bool
+	}{
+		{"native", want, "", faults, false, true},
+		{"qemu_complete", want, strings.Repeat(diagnostic, faults), faults, true, true},
+		{"qemu_mixed_valid_signals", want, strings.Repeat(diagnostic, faults-1) + bus, faults, true, true},
+		{"missing_receipt", "", strings.Repeat(diagnostic, faults), faults, true, false},
+		{"duplicate_receipt", want + want, strings.Repeat(diagnostic, faults), faults, true, false},
+		{"wrong_case_count", strings.Replace(want, "reference=98", "reference=97", 1), strings.Repeat(diagnostic, faults), faults, true, false},
+		{"truncated_receipt", strings.TrimSuffix(want, "\n"), strings.Repeat(diagnostic, faults), faults, true, false},
+		{"diagnostic_in_stdout", diagnostic + want, strings.Repeat(diagnostic, faults-1), faults, true, false},
+		{"missing_diagnostics", want, "", faults, true, false},
+		{"missing_child", want, strings.Repeat(diagnostic, faults-1), faults, true, false},
+		{"duplicate_child", want, strings.Repeat(diagnostic, faults+1), faults, true, false},
+		{"unknown_stderr", want, "unknown tool failure\n" + strings.Repeat(diagnostic, faults), faults, true, false},
+		{"wrong_signal", want, strings.Repeat(diagnostic, faults-1) + strings.Replace(diagnostic, "signal 11", "signal 4", 1), faults, true, false},
+		{"truncated_diagnostic", want, strings.TrimSuffix(strings.Repeat(diagnostic, faults), "\n"), faults, true, false},
+		{"native_must_not_borrow_qemu", want, strings.Repeat(diagnostic, faults), faults, false, false},
+		{"negative_fault_inventory", want, "", -1, false, false},
+		{"excess_fault_inventory", want, "", 6*14 + 1, false, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			stdout, stderr := []byte(test.stdout), []byte(test.stderr)
+			beforeStdout, beforeStderr := bytes.Clone(stdout), bytes.Clone(stderr)
+			err := x86FMA3PortableAccessReceipt(stdout, stderr, nil, want, test.faults, test.emulated)
+			if (err == nil) != test.valid {
+				t.Errorf("bound stream/fault receipt valid=%t, want %t: %v", err == nil, test.valid, err)
+			}
+			if !bytes.Equal(stdout, beforeStdout) || !bytes.Equal(stderr, beforeStderr) {
+				t.Fatal("receipt parser changed raw evidence")
+			}
+		})
+	}
+	for _, failure := range []error{errors.New("nonzero exit"), errors.New("owned cleanup failure")} {
+		if err := x86FMA3PortableAccessReceipt([]byte(want), []byte(strings.Repeat(diagnostic, faults)), failure, want, faults, true); !errors.Is(err, failure) {
+			t.Fatal("command failure was replaced by a successful receipt", err)
+		}
+	}
+}
diff --git a/x86_fma3_encoder_contract_test.go b/x86_fma3_encoder_contract_test.go
new file mode 100644
index 000000000..283f9565b
--- /dev/null
+++ b/x86_fma3_encoder_contract_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent Intel/Go FMA3 opcode axes. The order changes the encoded opcode,
+// not the three consumed operands. W selects precision; it is not WIG.
+func x86FMA3CheckCompleteEncoderAttributes(t *testing.T) {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, stem := range []struct {
+		name   string
+		opcode int
+		scalar bool
+	}{
+		{"VFMADD", 0x98, true}, {"VFMSUB", 0x9a, true},
+		{"VFNMADD", 0x9c, true}, {"VFNMSUB", 0x9e, true},
+		{"VFMADDSUB", 0x96, false}, {"VFMSUBADD", 0x97, false},
+	} {
+		for orderIndex, order := range []string{"132", "213", "231"} {
+			for _, suffix := range []string{"PS", "PD", "SS", "SD"} {
+				scalar := strings.HasPrefix(suffix, "S")
+				if scalar && !stem.scalar {
+					continue
+				}
+				op := stem.name + order + suffix
+				table, bits, w := "_yvaddpd", 32, 0
+				if strings.HasSuffix(suffix, "D") {
+					bits, w = 64, 1
+				}
+				opcode := stem.opcode + orderIndex*16
+				vexWidths, evexWidths := []int{128, 256}, []int{512, 128, 256}
+				if scalar {
+					table, opcode = "_yvaddsd", opcode+1
+					vexWidths, evexWidths = []int{128}, []int{128}
+				}
+				var expected []goasmrules.X86AVXRule
+				var encoding []string
+				offset := 0
+				add := func(zcase string, advance int, classes string) {
+					expected = append(expected, goasmrules.X86AVXRule{
+						Opcode: op, Ytab: table, Prefix: "Pavx",
+						Classes: strings.Split(classes, ","), RowIndex: len(expected),
+						ZCase: zcase, ZOffset: advance, EncodingOffset: offset,
+					})
+					offset += advance
+				}
+				for _, width := range vexWidths {
+					bank := map[int]string{128: "x", 256: "y"}[width]
+					add("Zvex_rm_v_r", 2, "Y"+bank+"m,Y"+bank+"r,Y"+bank+"r")
+					encoding = append(encoding,
+						fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F38 | vexW%d", width, w),
+						fmt.Sprintf("0x%X", opcode))
+				}
+				for _, width := range evexWidths {
+					bank := map[int]string{128: "x", 256: "y", 512: "z"}[width]
+					memory, register := "Y"+bank+"mEvex", "Y"+bank+"rEvex"
+					if width == 512 {
+						memory, register = "Yzm", "Yzr"
+					}
+					add("Zevex_rm_v_r", 0, memory+","+register+","+register)
+					add("Zevex_rm_v_k_r", 3, memory+","+register+",Yknot0,"+register)
+					attributes := fmt.Sprintf("evexN%d | evexBcstN%d", width/8, bits/8)
+					if scalar {
+						attributes = fmt.Sprintf("evexN%d", bits/8)
+					}
+					if scalar || width == 512 {
+						attributes += " | evexRoundingEnabled"
+					}
+					attributes += " | evexZeroingEnabled"
+					encoding = append(encoding,
+						fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW%d", width, w),
+						attributes, fmt.Sprintf("0x%X", opcode))
+				}
+				for index := range expected {
+					expected[index].OpBytes = encoding
+				}
+				var actual []goasmrules.X86AVXRule
+				for _, rule := range rules {
+					if rule.Opcode == op {
+						actual = append(actual, rule)
+					}
+				}
+				if !reflect.DeepEqual(actual, expected) {
+					t.Fatalf("%s complete original Go encoding changed:\ngot %+v\nwant %+v", op, actual, expected)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_fma3_initialized_axes_objects_test.go b/x86_fma3_initialized_axes_objects_test.go
new file mode 100644
index 000000000..afab5ece6
--- /dev/null
+++ b/x86_fma3_initialized_axes_objects_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// These are orthogonal initialized witnesses, not the full member x format
+// Cartesian product. The original complete 1,836/612 format objects remain in
+// their own tests, and all 60 register/memory/live/dead programs retain their
+// independent source/input proof in TestX86FMA3InitializedRegisterMemoryAndDeadPrograms.
+func x86FMA3InitializedAxisRows(arch string) []string {
+	var rows []string
+	seen := make(map[string]bool)
+	add := func(row string) {
+		if !seen[row] {
+			seen[row] = true
+			rows = append(rows, row)
+		}
+	}
+	for _, op := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+		add(op + " X0,X1,X2")
+	}
+	representatives := map[string]bool{
+		"VFMADD132PS": true, "VFMSUB213PD": true,
+		"VFNMADD231SS": true, "VFNMSUB132SD": true,
+	}
+	for _, row := range x86FMA3NamedFormats(arch) {
+		if representatives[strings.Split(strings.Fields(row)[0], ".")[0]] {
+			add(row)
+		}
+	}
+	if arch == "amd64" {
+		for _, row := range []string{
+			"VFMADD132PS X28,X29,X30", "VFMADD132PS Y28,Y29,Y30", "VFMADD132PS Z28,Z29,Z30",
+			"VFMSUB213PD X28,X29,X30", "VFMSUB213PD Y28,Y29,Y30", "VFMSUB213PD Z28,Z29,Z30",
+			"VFNMADD231SS X28,X29,X30", "VFNMSUB132SD X28,X29,X30",
+		} {
+			add(row)
+		}
+	}
+	return rows
+}
+
+func x86FMA3InitializedAxisSource(arch, name, row string) (string, string) {
+	operands := strings.Split(strings.Fields(row)[1], ",")
+	destination := operands[len(operands)-1]
+	index, _ := strconv.Atoi(destination[1:])
+	// Both owners use consecutive arithmetic registers: 0/1/2, 16/17/18
+	// for official physical rows, or 28/29/30 for the existing axis owner.
+	var lower, raise []string
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for register := 0; register < 3; register++ {
+			original := fmt.Sprintf("%s%d", bank, index-2+register)
+			canonical := fmt.Sprintf("%s%d", bank, register)
+			lower = append(lower, original, canonical)
+			raise = append(raise, canonical, original)
+		}
+	}
+	low := strings.NewReplacer(lower...).Replace(row)
+	source, declaration := x86FMA3InitializedSource(arch, name, low, false)
+	if !strings.Contains(row, "K1") {
+		// A plain VEX witness must not borrow an unrelated mask's AVX512 ISA.
+		source = strings.Replace(source, "MOVL $85,CX\nKMOVW CX,K1\n", "", 1)
+	}
+	if low != row {
+		source = strings.NewReplacer(raise...).Replace(source)
+		// High X registers need the original EVEX input/output transports,
+		// not an impossible legacy SSE MOVUPS/MOVD encoding.
+		source = strings.ReplaceAll(source, "\nMOVUPS ", "\nVMOVUPS ")
+		source = strings.Replace(source, fmt.Sprintf("MOVL X%d,AX\n", index), fmt.Sprintf("VMOVD X%d,AX\n", index), 1)
+	}
+	return source, declaration
+}
+
+func x86FMA3CheckInitializedNativeAxes(t *testing.T, ir string, rows []string) {
+	t.Helper()
+	wanted := make(map[string]int)
+	for _, row := range rows {
+		wanted[strings.ToLower(strings.Split(strings.Fields(row)[0], ".")[0])]++
+	}
+	for op, count := range wanted {
+		found := 0
+		for _, line := range strings.Split(ir, "\n") {
+			if strings.Contains(line, "asm sideeffect") && strings.Contains(line, op+" ") {
+				found++
+				if !strings.Contains(line, "~{memory}") || !strings.Contains(line, "~{fpsr}") || strings.Contains(line, "~{flags}") {
+					t.Fatal("initialized FMA3 lost native access/MXCSR or changed integer FLAGS", op, line)
+				}
+			}
+		}
+		if found != count {
+			t.Fatal("initialized FMA3 lost or duplicated original whole native opcodes", op, found, count)
+		}
+	}
+}
+
+func x86FMA3InitializedAxesObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("initialized FMA3 axes require LLVM22 llc")
+	}
+	rows := x86FMA3InitializedAxisRows(arch)
+	wanted := 178
+	if arch == "386" {
+		wanted = 94
+	}
+	if len(rows) != wanted {
+		t.Fatal("independent initialized FMA3 axis inventory changed", arch, len(rows), wanted)
+	}
+	for start := 0; start < len(rows); start += 48 {
+		end := start + 48
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch%d", start/48), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index := start; index < end; index++ {
+				entry, declaration := x86FMA3InitializedAxisSource(arch, fmt.Sprintf("FMAAxis%d", index), rows[index])
+				source.WriteString(entry)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized FMA3 axis source lost actual inputs or public continuation", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86FMA3CheckInitializedNativeAxes(t, pipeline.ir, rows[start:end])
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+	t.Logf("%s: %d initialized orthogonal FMA3 entries; all 60 members and independent physical axes, not every Cartesian format", triple, len(rows))
+}
+
+func TestX86FMA3InitializedAxesLinuxAMD64Objects(t *testing.T) {
+	x86FMA3InitializedAxesObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86FMA3InitializedAxesDarwinAMD64Objects(t *testing.T) {
+	x86FMA3InitializedAxesObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86FMA3InitializedAxesWindowsAMD64Objects(t *testing.T) {
+	x86FMA3InitializedAxesObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86FMA3InitializedAxesLinux386Objects(t *testing.T) {
+	x86FMA3InitializedAxesObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86FMA3InitializedAxesWindows386Objects(t *testing.T) {
+	x86FMA3InitializedAxesObjects(t, "386", "i686-pc-windows-msvc")
+}
diff --git a/x86_fma3_native_obligations_test.go b/x86_fma3_native_obligations_test.go
new file mode 100644
index 000000000..9ee79f49c
--- /dev/null
+++ b/x86_fma3_native_obligations_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This tests emission obligations separately from numerical initialization.
+// Direct lowerer fragments are not public source, LLVM object, or native CPU
+// execution certificates. Pure llvm.fma cannot preserve MXCSR, a dead native
+// exception, an original masked access, or the exact source instruction.
+func TestX86FMA3OriginalNativeFloatingObligations(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86FMA3NamedFormats(arch)
+		for _, opcode := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				for _, row := range rows {
+					if strings.Split(strings.Fields(row)[0], ".")[0] != opcode {
+						continue
+					}
+					ins := x86ScalarLaneInstruction(t, row)
+					original := ins
+					var output strings.Builder
+					ctx := newX86Ctx(&output, Func{}, FuncSig{Name: "FMA", Ret: Void}, nil, nil,
+						arch, x86AddressMemoryTargets(arch)[0], false)
+					if err := ctx.emitEntryAllocas(); err != nil {
+						t.Fatal(err)
+					}
+					before := output.Len()
+					recognized, terminated, err := ctx.lowerFMA3(ins.Op, ins)
+					if !recognized || terminated || err != nil || !reflect.DeepEqual(ins, original) {
+						t.Fatal("complete named FMA3 emitter changed source or rejected original format", row, err)
+					}
+					fragment := output.String()[before:]
+					var native string
+					for _, line := range strings.Split(fragment, "\n") {
+						if strings.Contains(line, "asm sideeffect") && strings.Contains(line, strings.ToLower(opcode)+" ") {
+							if native != "" {
+								t.Fatal("FMA3 duplicated an original floating instruction", row)
+							}
+							native = line
+						}
+					}
+					if native == "" || !strings.Contains(native, "~{fpsr}") || !strings.Contains(native, "~{memory}") ||
+						strings.Contains(native, "~{flags}") || !strings.Contains(native, ",0,") {
+						t.Fatalf("%s lost original opcode, tied old destination, MXCSR/access effects or preserved FLAGS: native=%q pure-fma=%t ignore-exceptions=%t",
+							row, native, strings.Contains(fragment, "@llvm.fma."), strings.Contains(fragment, "fpexcept.ignore"))
+					}
+					if strings.Contains(fragment, "@llvm.fma.") || strings.Contains(fragment, "fpexcept.ignore") {
+						t.Fatal("native FMA3 was replaced by pure or exception-ignoring numerical arithmetic", row)
+					}
+					width := map[byte]int{'X': 16, 'Y': 32, 'Z': 64}[ins.Args[len(ins.Args)-1].Reg[0]]
+					scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+					bits := 32
+					if strings.HasSuffix(opcode, "SD") || strings.HasSuffix(opcode, "PD") {
+						bits = 64
+					}
+					if strings.Contains(row, "(AX)") {
+						memory := width
+						if scalar || strings.Contains(row, ".BCST") {
+							memory = bits / 8
+						}
+						if !strings.Contains(native, fmt.Sprintf("elementtype([%d x i8])", memory)) ||
+							!strings.Contains(native, ",*m") {
+							t.Fatal("FMA3 lost its original native memory tuple", row, native)
+						}
+					}
+					for _, control := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+						if strings.Contains(row, "."+control) &&
+							!strings.Contains(native, "{"+strings.ToLower(strings.TrimSuffix(control, "_SAE"))+"-sae}") {
+							t.Fatal("FMA3 dropped explicit original rounding/SAE control", row, native)
+						}
+					}
+					if strings.Contains(row, ".Z ") && !strings.Contains(native, "{z}") ||
+						strings.Contains(row, ".BCST") && !strings.Contains(native, fmt.Sprintf("{1to%d}", width*8/bits)) {
+						t.Fatal("FMA3 dropped original masking or broadcast control", row, native)
+					}
+					features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}})
+					evex := width == 64 || len(ins.Args) == 4 || strings.Contains(row, ".BCST") || strings.Contains(row, "_SAE")
+					if evex {
+						if !strings.Contains(features, "+avx512f") || !scalar && width < 64 && !strings.Contains(features, "+avx512vl") {
+							t.Fatal("isolated original EVEX FMA3 borrowed another function's ISA", row, features)
+						}
+					} else if !strings.Contains(features, "+avx") || !strings.Contains(features, "+fma") {
+						t.Fatal("isolated original VEX FMA3 lost AVX/FMA ISA", row, features)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_fma3_portable_access_runtime_test.go b/x86_fma3_portable_access_runtime_test.go
new file mode 100644
index 000000000..74c285754
--- /dev/null
+++ b/x86_fma3_portable_access_runtime_test.go
@@ -0,0 +1,181 @@
+//go:build (darwin && arm64) || (linux && (amd64 || arm64))
+
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// ARM64 hosts execute the portable translation natively. Linux/AMD64 has an
+// explicit AArch64 cross-runtime counterpart in the existing cross matrix.
+// Neither route executes original x86 Go code or certifies x86 FP status.
+func TestCrossLinuxRuntimeMatrixX86FMA3AArch64DeadSourceAccess(t *testing.T) {
+	x86FMA3PortableAccessGoPrior(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	execution := x86FloatCompareExecution{
+		llc: llc, triple: testTargetTriple(runtime.GOOS, "arm64"), compiler: []string{clang},
+	}
+	if runtime.GOARCH == "amd64" {
+		execution.triple = "aarch64-unknown-linux-gnu"
+		execution.compiler = []string{"aarch64-linux-gnu-gcc"}
+		execution.prefix = []string{"qemu-aarch64", "-L", "/usr/aarch64-linux-gnu"}
+		t.Log("explicit AArch64 QEMU access execution, not bare native or x86 execution")
+	} else {
+		t.Log("native ARM64 portable access execution, not original x86 execution")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			var source, declarations, prototypes, metadata strings.Builder
+			admitted, contexts, faults := 0, 0, 0
+			for index, row := range x86FMA3PortableAccessCases() {
+				if row.bytes != 0 {
+					faults += 3 // The independent reference's NULL and two guard probes.
+				}
+				name := fmt.Sprint("Access", index)
+				register, declaration, _ := x86FMA3PortableAccessSource(row, name+"Register", false)
+				if ir, err := x86ScalarFPBitViewAPI(t, register, declaration, "amd64", execution.triple, api); err != nil || ir == "" {
+					t.Fatal("register control did not establish public AArch64 admission", err)
+				}
+				// Keep these controls in the final module even if every access
+				// explicitly remains Context. Reference execution is still real.
+				source.WriteString(register)
+				declarations.WriteString(declaration)
+				program, declaration, instruction := x86FMA3PortableAccessSource(row, name, true)
+				ir, err := x86ScalarFPBitViewAPI(t, program, declaration, "amd64", execution.triple, api)
+				function := "NULL"
+				if x86FMA3PortableAccessContext(t, ir, err, instruction) {
+					contexts++
+				} else {
+					admitted++
+					if row.bytes != 0 {
+						faults += 3 // The translated program's identical fault probes.
+					}
+					function = name
+					source.WriteString(program)
+					declarations.WriteString(declaration)
+					fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *);\n", name)
+				}
+				fmt.Fprintf(&metadata, "{%q,%s,%d},\n", row.name, function, row.bytes)
+			}
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("individually admitted portable accesses failed the complete source join", err)
+			}
+			main := strings.NewReplacer("@PROTOTYPES@", prototypes.String(), "@ROWS@", metadata.String()).Replace(x86FMA3PortableAccessReferenceC)
+			for _, pipeline := range []struct {
+				name, level string
+				optimize    bool
+			}{
+				{"backend_O0", "-O0", false},
+				{"backend_O2", "-O2", false},
+				{"IR_O2/backend_O2", "-O2", true},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					text := ir
+					if pipeline.optimize {
+						text = x86DwordProductIROptimize(t, text)
+					}
+					executable := execution.compileLLVM(t, "fma-portable-dead-access", text, main, pipeline.level)
+					arguments := execution.command(executable)
+					ctx, cancel := runtimeOracleStageContext(t)
+					output, diagnostics, commandErr := runtimeOracleMachineOutput(ctx,
+						exec.CommandContext(ctx, arguments[0], arguments[1:]...))
+					cancel()
+					if len(diagnostics) != 0 {
+						t.Logf("complete guest-child stderr: %q", diagnostics)
+					}
+					want := fmt.Sprintf("portable FMA dead-q: admitted=%d context=%d reference=%d translated=%d\n",
+						admitted, contexts, len(x86FMA3PortableAccessCases())*7, admitted*7)
+					if err := x86FMA3PortableAccessReceipt(output, diagnostics, commandErr, want, faults, len(execution.prefix) != 0); err != nil {
+						t.Fatalf("incomplete independent volatile reference/access execution: %v; stdout=%q stderr=%q want=%q", err, output, diagnostics, want)
+					}
+					t.Log(strings.TrimSpace(string(output)))
+				})
+			}
+		})
+	}
+}
+
+const x86FMA3PortableAccessReferenceC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+@PROTOTYPES@
+typedef void (*Program)(const uint8_t *);
+typedef struct { const char *name; Program translated; unsigned bytes; } Row;
+static const Row rows[] = {@ROWS@};
+
+/* Byte-volatile reads are independent of FMA arithmetic and target vector
+ * lowering. No alignment assumption, uninitialized FP value or earlier read
+ * can manufacture the expected fault. Empty masks select zero bytes. */
+static void reference(const uint8_t *p,unsigned bytes) {
+    for(unsigned i=0;i<bytes;i++) {
+        uint8_t value=*(const volatile uint8_t *)(p+i);
+        (void)value;
+    }
+}
+static int observe(const Row *row,int translated,const uint8_t *p) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        if(translated) row->translated(p); else reference(p,row->bytes);
+        _exit(0);
+    }
+    int status=0;
+    if(waitpid(child,&status,0)!=child) return -2;
+    if(WIFEXITED(status)) return WEXITSTATUS(status)==0?0:-3;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -4;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 1;
+    uint8_t *memory=mmap(NULL,2*(size_t)page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+    if(memory==MAP_FAILED || mprotect(memory+page,(size_t)page,PROT_NONE)) return 2;
+    memset(memory,0,(size_t)page);
+    unsigned admitted=0,contexts=0,references=0,translated=0;
+    for(unsigned i=0;i<sizeof(rows)/sizeof(rows[0]);i++) {
+        const Row *row=&rows[i];
+        admitted+=row->translated!=NULL;
+        contexts+=row->translated==NULL;
+        unsigned width=row->bytes?row->bytes:1;
+        const uint8_t *inputs[]={memory,memory+1,NULL,memory+page,
+            memory+page-(width-1),memory+page-width,memory+page-width-1};
+        for(unsigned probe=0;probe<7;probe++) {
+            int want=row->bytes && probe>=2 && probe<=4;
+            int actual=observe(row,0,inputs[probe]);
+            references++;
+            if(actual!=want) {
+                fprintf(stderr,"volatile reference row=%s probe=%u got=%d want=%d\n",row->name,probe,actual,want);
+                return 3;
+            }
+            if(row->translated) {
+                actual=observe(row,1,inputs[probe]);
+                translated++;
+                if(actual!=want) {
+                    fprintf(stderr,"dead FMA q access row=%s probe=%u got=%d want=%d\n",row->name,probe,actual,want);
+                    return 4;
+                }
+            }
+        }
+    }
+    if(munmap(memory,2*(size_t)page)) return 5;
+    printf("portable FMA dead-q: admitted=%u context=%u reference=%u translated=%u\n",
+        admitted,contexts,references,translated);
+    return 0;
+}
+`
diff --git a/x86_fma3_portable_access_test.go b/x86_fma3_portable_access_test.go
new file mode 100644
index 000000000..457722078
--- /dev/null
+++ b/x86_fma3_portable_access_test.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// These independent witnesses distinguish scalar, packed, broadcast and mask
+// accesses. The pointer q is not used by any producer: a producer fault cannot
+// hide a missing FMA read. Register-only counterparts have identical inputs.
+// This is an access contract, not an x86 MXCSR or original-Go execution oracle.
+type x86FMA3PortableAccessCase struct {
+	name, format string
+	mask         int // -1 means no mask; otherwise K1 receives this constant.
+	bytes        int // Highest selected byte, independently specified below.
+}
+
+func x86FMA3PortableAccessCases() []x86FMA3PortableAccessCase {
+	return []x86FMA3PortableAccessCase{
+		{"scalar32", "VFMADD132SS %s,X1,X2", -1, 4},
+		{"scalar64", "VFMSUB213SD %s,X1,X2", -1, 8},
+		{"packed32", "VFNMADD231PS %s,X1,X2", -1, 16},
+		{"packed64", "VFNMSUB132PD %s,X1,X2", -1, 16},
+		{"scalar32-merge", "VFMADD213SS %s,X1,K1,X2", 1, 4},
+		{"scalar64-zero", "VFMSUB231SD.Z %s,X1,K1,X2", 1, 8},
+		{"packed32-merge", "VFMADD132PS %s,X1,K1,X2", 1, 4},
+		{"packed64-zero", "VFMSUB213PD.Z %s,X1,K1,X2", 1, 8},
+		{"packed32-suppressed", "VFNMADD231PS %s,X1,K1,X2", 0, 0},
+		{"scalar64-suppressed", "VFNMSUB132SD.Z %s,X1,K1,X2", 0, 0},
+		{"broadcast32", "VFMADD132PS.BCST %s,X1,X2", -1, 4},
+		{"broadcast64", "VFMSUB213PD.BCST %s,X1,X2", -1, 8},
+		{"broadcast32-merge", "VFNMADD231PS.BCST %s,X1,K1,X2", 1, 4},
+		{"broadcast64-suppressed", "VFNMSUB132PD.BCST.Z %s,X1,K1,X2", 0, 0},
+	}
+}
+
+func x86FMA3PortableAccessSource(row x86FMA3PortableAccessCase, name string, memory bool) (string, string, string) {
+	format, first := row.format, "(AX)"
+	if !memory {
+		format, first = strings.ReplaceAll(format, ".BCST", ""), "X0"
+	}
+	instruction := fmt.Sprintf(format, first)
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ q+0(FP),AX\n", name)
+	source.WriteString("PXOR X0,X0\nPXOR X1,X1\nPXOR X2,X2\n")
+	if row.mask >= 0 {
+		fmt.Fprintf(&source, "MOVL $%d,CX\nKMOVW CX,K1\n", row.mask)
+	}
+	source.WriteString(instruction + "\nRET\n")
+	return source.String(), fmt.Sprintf("func %s(q *byte)\n", name), instruction
+}
+
+func x86FMA3PortableAccessGoPrior(t *testing.T) {
+	t.Helper()
+	var source strings.Builder
+	for index, row := range x86FMA3PortableAccessCases() {
+		for _, memory := range []bool{false, true} {
+			program, _, _ := x86FMA3PortableAccessSource(row, fmt.Sprintf("Prior%d_%t", index, memory), memory)
+			source.WriteString(program)
+		}
+	}
+	// These are real stock-Go x86 objects. They are not executed on AArch64.
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+}
+
+func x86FMA3PortableAccessContext(t *testing.T, ir string, err error, instruction string) bool {
+	t.Helper()
+	if err == nil {
+		if ir == "" {
+			t.Fatal("successful public translation returned no module")
+		}
+		return false
+	}
+	if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), instruction) {
+		t.Fatalf("not a closed, original-FMA-bound Context: instruction=%q err=%v IR=%q", instruction, err, ir)
+	}
+	t.Log("original FMA access explicitly remains Context:", instruction)
+	return true
+}
+
+func TestX86FMA3AArch64AdmissionAndIndependentAddressSources(t *testing.T) {
+	x86FMA3PortableAccessGoPrior(t)
+	const triple = "aarch64-unknown-linux-gnu"
+	for _, row := range x86FMA3PortableAccessCases() {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source, declaration, _ := x86FMA3PortableAccessSource(row, "Probe", false)
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+				if err != nil || !strings.Contains(ir, "target triple = \""+triple+"\"") {
+					t.Fatal("public source-architecture/target combination is not actually admitted", err)
+				}
+				if strings.Contains(ir, "asm sideeffect \"vfm") || strings.Contains(ir, "asm sideeffect \"vfnm") {
+					t.Fatal("AArch64 control accidentally used an original x86 native instruction")
+				}
+				memory, _, instruction := x86FMA3PortableAccessSource(row, "Probe", true)
+				for _, missing := range []string{"MOVQ q+0(FP),AX\n", "PXOR X1,X1\n", "PXOR X2,X2\n"} {
+					changed := strings.Replace(memory, missing, "", 1)
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", triple, api)
+					if missing == "PXOR X1,X1\n" || missing == "PXOR X2,X2\n" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", triple, ir, err)
+					} else if !x86FMA3PortableAccessContext(t, ir, err, instruction) {
+						t.Fatal("dead FMA borrowed a missing actual pointer/arithmetic input", missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+var x86FMA3PortableVolatileLoad = regexp.MustCompile(`\bload volatile (i[0-9]+|float|double|<[0-9]+ x (?:i[0-9]+|float|double)>),`)
+
+func x86FMA3PortableVolatileBytes(t *testing.T, ir string) int {
+	t.Helper()
+	bytes := 0
+	for _, match := range x86FMA3PortableVolatileLoad.FindAllStringSubmatch(ir, -1) {
+		element, lanes := match[1], 1
+		if strings.HasPrefix(element, "<") {
+			var count string
+			count, element, _ = strings.Cut(strings.Trim(element, "<>"), " x ")
+			var err error
+			lanes, err = strconv.Atoi(count)
+			if err != nil {
+				t.Fatal(err)
+			}
+		}
+		bits := map[string]int{"float": 32, "double": 64}[element]
+		if bits == 0 {
+			var err error
+			bits, err = strconv.Atoi(strings.TrimPrefix(element, "i"))
+			if err != nil || bits%8 != 0 {
+				t.Fatal("unexpected volatile access type", element, err)
+			}
+		}
+		bytes += lanes * bits / 8
+	}
+	return bytes
+}
+
+func TestX86FMA3AArch64DeadInputAccessCannotDisappear(t *testing.T) {
+	x86FMA3PortableAccessGoPrior(t)
+	const triple = "aarch64-unknown-linux-gnu"
+	for _, row := range x86FMA3PortableAccessCases() {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				register, declaration, _ := x86FMA3PortableAccessSource(row, "Probe", false)
+				if ir, err := x86ScalarFPBitViewAPI(t, register, declaration, "amd64", triple, api); err != nil || ir == "" {
+					t.Fatal("register counterpart did not establish actual public target admission", err)
+				}
+				source, _, instruction := x86FMA3PortableAccessSource(row, "Probe", true)
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+				if x86FMA3PortableAccessContext(t, ir, err, instruction) {
+					return
+				}
+				// Constant-mask simplification removes inactive guarded loads.
+				// The separate runtime root observes O0 and O2 as well as IR O2;
+				// counting an unoptimized guarded load would misclassify mask=0.
+				text := x86DwordProductIROptimize(t, ir)
+				if got := x86FMA3PortableVolatileBytes(t, text); got != row.bytes {
+					t.Errorf("IR_O2: dead q access has %d observable bytes, want exactly %d; pure arithmetic/masked.load is not a fault-preserving continuation\n%s",
+						got, row.bytes, text)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_fma3_result_effects_test.go b/x86_fma3_result_effects_test.go
new file mode 100644
index 000000000..fad4fd01f
--- /dev/null
+++ b/x86_fma3_result_effects_test.go
@@ -0,0 +1,252 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86FMA3ResultInputState() x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	state.gp[5], state.pointerGP[7], state.callerAddressGP[7], state.masks[1] = 0x53, true, true, true
+	for register := 0; register < 3; register++ {
+		state.writeVector(register, 64, ^uint64(0), false)
+	}
+	return state
+}
+
+// These expectations use the independent Go syntax inventory and architectural
+// operand roles, never amd64FMA3Specs. All three arithmetic inputs are needed
+// in every 132/213/231 order, including the old destination under zero masking.
+func TestX86FMA3CompleteNamedResultEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86FMA3NamedFormats(arch)
+		for _, opcode := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+			t.Run(arch+"/"+opcode, func(t *testing.T) {
+				for _, row := range rows {
+					if strings.Split(strings.Fields(row)[0], ".")[0] != opcode || strings.Contains(row, "(AX)") {
+						continue
+					}
+					ins := x86ScalarLaneInstruction(t, row)
+					width := map[byte]int{'X': 16, 'Y': 32, 'Z': 64}[ins.Args[0].Reg[0]]
+					active := width
+					scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+					if scalar {
+						active = 4
+						if strings.HasSuffix(opcode, "SD") {
+							active = 8
+						}
+					}
+					masked := len(ins.Args) == 4
+					mandatory := x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, arch)
+					for missing := -2; missing < 193; missing++ {
+						state := x86FMA3ResultInputState()
+						want := true
+						if missing == -2 && scalar {
+							// The other arithmetic inputs cannot supply upper-X bytes.
+							low := x86CallerVectorByteMask(int64(active))
+							state.writeVector(0, 64, low, false)
+							state.writeVector(1, 64, low, false)
+							state.writeVector(2, 64, low|0xa500, false)
+						} else if missing == 192 {
+							state.masks[1], want = false, !masked
+						} else if missing >= 0 {
+							register, bit := missing/64, uint(missing%64)
+							state.writeVector(register, 64, state.vectorBytes(register)&^(uint64(1)<<bit), false)
+							want = int(bit) >= active
+						}
+						before := state.clone()
+						accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != want || !mandatory {
+							t.Fatalf("%s missing=%d: accepted=%t want=%t mandatory=%t", row, missing, accepted, want, mandatory)
+						}
+						if accepted {
+							known := ^uint64(0)
+							if scalar {
+								low := x86CallerVectorByteMask(int64(active))
+								known = low | before.vectorBytes(2)&(0xffff&^low)
+							}
+							before.writeVector(2, width, known, false)
+						}
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("FMA changed FLAGS, addresses, masks, unknown passthrough or unrelated banks", row, missing)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86FMA3InitializedSource(arch, name, row string, dead bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	bank := "X"
+	for _, candidate := range []string{"Y", "Z"} {
+		if strings.Contains(row, candidate+"1") {
+			bank = candidate
+		}
+	}
+	load := "MOVUPS"
+	if bank != "X" {
+		load = "VMOVUPS"
+	}
+	var source strings.Builder
+	frame, declaration := word+4, fmt.Sprintf("func %s(p *byte) uint32\n", name)
+	if dead {
+		frame, declaration = word, fmt.Sprintf("func %s(p *byte)\n", name)
+	}
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n", name, frame, move)
+	for register := 0; register < 3; register++ {
+		fmt.Fprintf(&source, "%s (AX),%s%d\n", load, bank, register)
+	}
+	source.WriteString("MOVL $85,CX\nKMOVW CX,K1\n")
+	source.WriteString(row + "\n")
+	if !dead {
+		fmt.Fprintf(&source, "MOVL X2,AX\nMOVL AX,ret+%d(FP)\n", word)
+	}
+	source.WriteString("RET\n")
+	return source.String(), declaration
+}
+
+func TestX86FMA3InitializedRegisterMemoryAndDeadPrograms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var entries, declarations []string
+		for index, opcode := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+			for _, memory := range []bool{false, true} {
+				for _, dead := range []bool{false, true} {
+					first := "X0"
+					if memory {
+						first = "(AX)"
+					}
+					name := fmt.Sprintf("FMA%d_%t_%t", index, memory, dead)
+					entry, declaration := x86FMA3InitializedSource(arch, name, opcode+" "+first+",X1,X2", dead)
+					entries = append(entries, entry)
+					declarations = append(declarations, declaration)
+				}
+			}
+		}
+		triple := x86AddressMemoryTargets(arch)[0]
+		if len(entries) != 240 {
+			t.Fatal("incomplete independent FMA3 register/memory/live/dead source inventory", len(entries))
+		}
+		for start := 0; start < len(entries); start += 40 {
+			end := start + 40
+			// Independent Go objects precede each bounded public capture.
+			// This is source validity, not LLVM/native execution certification.
+			source := strings.Join(entries[start:end], "")
+			declaration := strings.Join(declarations[start:end], "")
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/batch%d/%s", arch, start/40, api), func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("genuinely initialized complete FMA3 source has no result/effect continuation", err)
+					}
+					for _, opcode := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+						want := strings.Count(source, "\n"+opcode+" ")
+						if found := strings.Count(ir, "asm sideeffect \""+strings.ToLower(opcode)+" "); found != want {
+							t.Fatal("public FMA3 lost original live or dead native instructions", opcode, found, want)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FMA3DoesNotInventInputsOrPhysicalAuthority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				triple := x86AddressMemoryTargets(arch)[0]
+				for _, opcode := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+					bare := "TEXT ·Value(SB),4,$0-0\n" + opcode + " X0,X1,X2\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, bare, "func Value()", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead FMA borrowed implementation-zero arithmetic inputs", opcode, err)
+					}
+				}
+				for _, row := range []string{
+					"VFMADD132PS X0,X1,X2", "VFNMADD213SD (AX),X1,X2",
+					"VFNMSUB231SS.RZ_SAE.Z X0,X1,K1,X2",
+				} {
+					if arch == "386" && strings.Contains(row, "K1") {
+						continue // Go's named four-operand mode32 boundary stays closed.
+					}
+					original, declaration := x86FMA3InitializedSource(arch, "Value", row, true)
+					for _, missing := range []string{"first", "second", "old destination", "mask", "address", "FLAGS"} {
+						changed := original
+						load := "MOVUPS (AX),X"
+						switch missing {
+						case "first":
+							if strings.Contains(row, "(AX)") {
+								continue
+							}
+							changed = strings.Replace(changed, load+"0\n", "", 1)
+						case "second":
+							changed = strings.Replace(changed, load+"1\n", "", 1)
+						case "old destination":
+							changed = strings.Replace(changed, load+"2\n", "", 1)
+						case "mask":
+							if !strings.Contains(row, "K1") {
+								continue
+							}
+							changed = strings.Replace(changed, "KMOVW CX,K1\n", "", 1)
+						case "address":
+							if !strings.Contains(row, "(AX)") {
+								continue
+							}
+							changed = strings.Replace(changed, row, strings.Replace(row, "(AX)", "(BX)", 1), 1)
+						case "FLAGS":
+							changed = strings.Replace(changed, "RET\n", "SETCS DL\nRET\n", 1)
+						}
+						if changed == original {
+							t.Fatal("independent missing-input control did not change source", missing, row)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if arch == "amd64" && (missing == "first" || missing == "second" || missing == "old destination") {
+							x86VectorScratchCodegenControl(t, changed, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("FMA acquired an absent numerical, address, mask or FLAGS fact", row, missing, err)
+						}
+					}
+				}
+			})
+		}
+		for _, row := range []string{
+			"VFMADD132PH X0,X1,X2", "VFMADD213SH X0,X1,X2",
+			"VFMADD231PS X0,X1,K0,X2", "VFMADD231SS.BCST (AX),X1,X2",
+		} {
+			ins := x86ScalarLaneInstruction(t, row)
+			state := x86FMA3ResultInputState()
+			before := state.clone()
+			if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+				t.Fatal("named FMA borrowed raw FP16 or an illegal mask/broadcast role", arch, row)
+			}
+		}
+		code := encodeX86VEXFMA3(0xb9, true, false, 2, 1, 0)
+		raw, length, known, err := decodedX86VEXFMA3Instruction(code, map[string]int{"386": 32, "amd64": 64}[arch])
+		if !known || err != nil || length != len(code) {
+			t.Fatal("independent physical FMA prior failed", arch, err)
+		}
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t,
+			"TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n"), arch)
+		if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 {
+			t.Fatal("independent physical FMA lost its normalized source identity", arch, err)
+		}
+		raw = file.Funcs[0].Instrs[1]
+		if raw.x86SourceRaw == nil {
+			t.Fatal("physical FMA fixture has no original byte identity", arch)
+		}
+		state := x86FMA3ResultInputState()
+		before := state.clone()
+		if x86ScalarFPResultTransfer(raw, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+			t.Fatal("standalone physical instruction borrowed a named FMA source contract", arch)
+		}
+	}
+}
diff --git a/x86_four_source_boundaries_test.go b/x86_four_source_boundaries_test.go
new file mode 100644
index 000000000..0de294c47
--- /dev/null
+++ b/x86_four_source_boundaries_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86FourSourceRejectsMalformedSuffixesBeforeEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86FourSourceOracle {
+			row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: "plain"}
+			original := x86ScalarLaneInstruction(t, row.instruction())
+			for _, suffix := range []string{".", "..", ".Z.", ".Z.Z", ".BCST", ".SAE", ".RN_SAE", ".Z.BCST"} {
+				t.Run(arch+"/"+member.op+suffix, func(t *testing.T) {
+					ins := original
+					ins.Op = Op(member.op + suffix)
+					ins.Raw = strings.Replace(ins.Raw, member.op, string(ins.Op), 1)
+					before := fmt.Sprintf("%#v", ins)
+					if _, known, err := x86FourSourceProperties(ins.Op, ins, arch); !known || err == nil {
+						t.Fatal("trailing or unsupported suffix entered the complete typed grammar", known, err)
+					}
+					if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err == nil {
+						t.Fatal("malformed suffix acquired numerical read/write roles", known, err)
+					}
+					if features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); features != "" {
+						t.Fatal("malformed suffix acquired native ISA attributes", features)
+					}
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					for register := 0; register < 8; register++ {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					pointer, _, _ := x86ResultGP(BX, x86ResultPointerWord(arch), arch)
+					state.pointerGP[pointer] = true
+					state.masks[1] = true
+					old := state.clone()
+					if accepted, known := x86ResultFourSourceStep(ins, &state, nil, arch, true); accepted || !known || !reflect.DeepEqual(old, state) {
+						t.Fatal("malformed suffix mutated fully initialized native state", accepted, known)
+					}
+					if before != fmt.Sprintf("%#v", ins) {
+						t.Fatal("malformed-source observation changed the original instruction")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_four_source_complete_tdd_test.go b/x86_four_source_complete_tdd_test.go
new file mode 100644
index 000000000..a9779756b
--- /dev/null
+++ b/x86_four_source_complete_tdd_test.go
@@ -0,0 +1,412 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Independent ISA/Go directory: every member takes exactly m128, four
+// effective register sources and the old accumulator. SS reads only each
+// source's low dword but preserves the old accumulator's other X bytes.
+var x86FourSourceOracle = []struct {
+	op                  string
+	scalar, dot, negate bool
+}{
+	{"V4FMADDPS", false, false, false}, {"V4FMADDSS", true, false, false},
+	{"V4FNMADDPS", false, false, true}, {"V4FNMADDSS", true, false, true},
+	{"VP4DPWSSD", false, true, false}, {"VP4DPWSSDS", false, true, false},
+}
+
+type x86FourSourceOracleRow struct {
+	op, mode        string
+	first, dest     int
+	scalar, dot     bool
+	missing, unused string
+}
+
+func x86FourSourceOracleRows(arch string) []x86FourSourceOracleRow {
+	var rows []x86FourSourceOracleRow
+	for _, member := range x86FourSourceOracle {
+		for _, first := range []int{0, 2} {
+			for _, destination := range []int{0, 6} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if arch == "386" && mode != "plain" {
+						continue // Go's named 386 frontend has a three-operand cap.
+					}
+					rows = append(rows, x86FourSourceOracleRow{
+						op: member.op, scalar: member.scalar, dot: member.dot,
+						first: first, dest: destination, mode: mode,
+					})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86FourSourceOracleRow) instruction() string {
+	bank, op, mask := "Z", row.op, ""
+	if row.scalar {
+		bank = "X"
+	}
+	if row.mode != "plain" {
+		mask = "K1,"
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	return fmt.Sprintf("%s (BX),[%s%d-%s%d],%s%s%d", op, bank, row.first, bank, row.first+3, mask, bank, row.dest)
+}
+
+func x86FourSourceOriginalRuntimeUnchanged(t *testing.T) {
+	t.Helper()
+	x86FourSourceOriginalProgram(t)
+}
+
+// Historical whole-driver anchor was
+// 8c732301b5e7ad3d1d5154236322b9f3939a347d1f05f0a01bed3ecf9b21d53d.
+// Only the driver may migrate to explicit private mathematical instrumentation;
+// these two unchanged original literals remain the active program contract.
+func x86FourSourceOriginalProgram(t *testing.T) (string, string) {
+	t.Helper()
+	const name = "amd64_lower_four_source_test.go"
+	data, err := os.ReadFile(name)
+	if err != nil {
+		t.Fatal(err)
+	}
+	positions := token.NewFileSet()
+	syntax, err := parser.ParseFile(positions, name, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestAMD64FourSourceRuntimeSemantics" {
+			continue
+		}
+		program := make(map[string]string)
+		for _, statement := range function.Body.List {
+			declaration, ok := statement.(*ast.DeclStmt)
+			if !ok {
+				continue
+			}
+			constants, ok := declaration.Decl.(*ast.GenDecl)
+			if !ok || constants.Tok != token.CONST {
+				continue
+			}
+			for _, specification := range constants.Specs {
+				value, ok := specification.(*ast.ValueSpec)
+				if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+					continue
+				}
+				key := value.Names[0].Name
+				if key != "source" && key != "mainC" {
+					continue
+				}
+				literal, ok := value.Values[0].(*ast.BasicLit)
+				if !ok || literal.Kind != token.STRING || program[key] != "" {
+					t.Fatal("original four-source program lost its single actual source/C literal", key)
+				}
+				program[key], err = strconv.Unquote(literal.Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+		}
+		for key, want := range map[string]string{
+			"source": "c68bfc687ce73e04389fd0e3f57146554f85d3967d9c44c80ac6e1dbefbd5070",
+			"mainC":  "44e5e74ea2f0f24009632362a848a5bc0e9f6c8002e04d8e4310a2f4270bc3a4",
+		} {
+			if fmt.Sprintf("%x", sha256.Sum256([]byte(program[key]))) != want {
+				t.Fatal("the original complete ASM or independent C oracle changed", key)
+			}
+		}
+		return program["source"], program["mainC"]
+	}
+	t.Fatal("the original complete four-source runtime program disappeared")
+	return "", ""
+}
+
+func x86FourSourceInitializedSource(row x86FourSourceOracleRow, arch, name string, dead bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	extent, extra := 4*word+8, ""
+	if row.unused != "" {
+		extent++
+		extra = ",unused bool"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),SI\n%s old+%d(FP),CX\n",
+		name, extent, move, move, word, move, 2*word)
+	if row.missing == "numeric address" {
+		source.WriteString("MOVL $42,BX\n")
+	} else if row.missing != "address" {
+		fmt.Fprintf(&source, "%s memory+%d(FP),BX\n", move, 3*word)
+	}
+	base := row.first &^ 3
+	for register := 0; register < 4; register++ {
+		if row.missing != fmt.Sprint("source", register) {
+			fmt.Fprintf(&source, "VMOVUPS %d(SI),Z%d\n", 64*register, base+register)
+		}
+	}
+	if (row.dest < base || row.dest >= base+4) && row.missing != "old" {
+		fmt.Fprintf(&source, "VMOVUPS (CX),Z%d\n", row.dest)
+	}
+	if row.missing != "mask" {
+		fmt.Fprintf(&source, "KMOVQ mask+%d(FP),K1\n", 4*word)
+	}
+	source.WriteString("STC\n" + row.instruction() + "\n")
+	if !dead {
+		// Full Z observation checks scalar upper-X preservation and EVEX
+		// zeroing above X, not only the computed low scalar lane.
+		fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\n", row.dest)
+	}
+	source.WriteString("SETCS 64(DI)\nRET\n")
+	return source.String(), fmt.Sprintf("func %s(out *[80]byte,input *[256]byte,old *[64]byte,memory *[16]byte,mask uint64%s)\n", name, extra)
+}
+
+func TestX86FourSourceIndependentNamedDirectoryAndGoBytes(t *testing.T) {
+	x86FourSourceOriginalRuntimeUnchanged(t)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86FourSourceOracleRows(arch)
+			want := 72
+			if arch == "386" {
+				want = 24
+			}
+			if len(rows) != want {
+				t.Fatal("independent complete mode/mask/alias directory changed", len(rows))
+			}
+			var body strings.Builder
+			for _, row := range rows {
+				body.WriteString(row.instruction() + "\n")
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, body.String()+"RET")
+			if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+				t.Fatal("the independent original Go opcode/PC directory is incomplete")
+			}
+			for index, row := range rows {
+				instruction := code[pcs[index]:pcs[index+1]]
+				opcode := map[string]byte{"V4FMADDPS": 0x9a, "V4FMADDSS": 0x9b, "V4FNMADDPS": 0xaa,
+					"V4FNMADDSS": 0xab, "VP4DPWSSD": 0x52, "VP4DPWSSDS": 0x53}[row.op]
+				if len(instruction) != 6 || instruction[0] != 0x62 || instruction[1] != 0xf2 || instruction[4] != opcode ||
+					instruction[5] != byte(row.dest<<3)|3 {
+					t.Fatal("Go bytes disagree with the independent EVEX memory/ModRM row", row.instruction(), instruction)
+				}
+			}
+		})
+	}
+}
+
+func TestX86FourSourceCompleteTypedImplicitReadAndWriteRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FourSourceOracleRows(arch) {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("the complete typed family is missing actual input and accumulator obligations", effect, known, err)
+				}
+				memory, old, mask := 0, 0, 0
+				sources := make(map[Reg]int64)
+				for _, operand := range effect.operands {
+					switch operand.index {
+					case 0:
+						if !operand.read || operand.write || operand.width != 16 || !reflect.DeepEqual(operand.operand, ins.Args[0]) {
+							t.Fatal("four-source memory is one complete m128, not a selected dword or vector envelope", operand)
+						}
+						memory++
+					case 1:
+						if operand.operand.Kind != OpReg || !operand.read || operand.write {
+							t.Fatal("effective aligned source block must expose each actual implicit register", operand)
+						}
+						sources[operand.operand.Reg] = operand.width
+					default:
+						if operand.index == len(ins.Args)-1 {
+							width := int64(64)
+							if row.scalar {
+								width = 16
+							}
+							if !operand.read || !operand.write || operand.width != width {
+								t.Fatal("the old accumulator is read even for .Z, with scalar upper-X preservation", operand)
+							}
+							old++
+						} else if len(ins.Args) == 4 && operand.index == 2 {
+							if !operand.read || operand.write || operand.width != 8 || operand.operand.Reg != "K1" {
+								t.Fatal("masked four-source lost its actual K input", operand)
+							}
+							mask++
+						} else {
+							t.Fatal("unobserved operand role", operand)
+						}
+					}
+				}
+				bank, width := "Z", int64(64)
+				if row.scalar {
+					bank, width = "X", 4
+				}
+				wantSources := make(map[Reg]int64)
+				for register := 0; register < 4; register++ {
+					wantSources[Reg(fmt.Sprintf("%s%d", bank, register))] = width
+				}
+				wantMask := 0
+				if row.mode != "plain" {
+					wantMask = 1
+				}
+				if memory != 1 || old != 1 || mask != wantMask || !reflect.DeepEqual(sources, wantSources) {
+					t.Fatal("encoded [2-5] must read the aligned [0-3] block without manufacturing bytes", memory, old, mask, sources)
+				}
+			})
+		}
+	}
+}
+
+func TestX86FourSourceInitializedWholeObjectsFiveTargets(t *testing.T) {
+	x86FourSourceOriginalRuntimeUnchanged(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete four-source objects require exact LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86FourSourceOracleRows(target.arch)
+			for start := 0; start < len(rows); start += 24 {
+				end := start + 24
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch_%02d_%02d", start, end), func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index := start; index < end; index++ {
+						body, declaration := x86FourSourceInitializedSource(rows[index], target.arch, fmt.Sprint("Four", index), false)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("a fully initialized complete four-source program lost its native input/result handoff", err)
+							}
+							for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								compileLLVMToObject(t, llc, target.triple, "four-source-complete.ll", "four-source-complete.o", body)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FourSourceVoidStillOwnsItsTypedInputObligation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86FourSourceOracle {
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused=%t", arch, member.op, unused), func(t *testing.T) {
+					declaration := "func Value()"
+					if unused {
+						declaration = "func Value(unused bool)"
+					}
+					row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: "plain"}
+					_, file, signature, source := x86ResultInitializationFixture(t, arch, declaration, row.instruction()+"\nRET\n")
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if !x86TypedFPResultNeedsProof(file.Funcs[0], signature, arch) {
+						t.Fatal("Void or an unused canonical bool bypassed the complete instruction's input obligations")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FourSourceInitializedDeadVoidAndUnusedBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, member := range x86FourSourceOracle {
+				for _, unused := range []string{"", "bool"} {
+					mode := "plain"
+					if target.arch == "amd64" {
+						mode = "zero"
+					}
+					row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot,
+						first: 2, dest: 6, mode: mode, unused: unused}
+					body, declaration := x86FourSourceInitializedSource(row, target.arch, fmt.Sprintf("Dead%d%s", index, unused), true)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized dead four-source instructions lost their actual inputs or cache/fault/MXCSR obligation", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FourSourceMissingActualInputsRemainContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, member := range x86FourSourceOracle {
+			for _, missing := range []string{"source0", "source1", "source2", "source3", "old", "address", "numeric address", "mask"} {
+				if arch == "386" && missing == "mask" {
+					continue
+				}
+				t.Run(arch+"/"+member.op+"/"+missing, func(t *testing.T) {
+					mode := "plain"
+					if arch == "amd64" {
+						mode = "zero"
+					}
+					row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot,
+						mode: mode, first: 2, dest: 6, missing: missing, unused: "bool"}
+					source, declaration := x86FourSourceInitializedSource(row, arch, "Missing", false)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if missing == "numeric address" {
+							if err != nil || ir == "" {
+								t.Fatal("initialized numeric four-source address lost its native read", api, err)
+							}
+							row.missing = ""
+							original, decl := x86FourSourceInitializedSource(row, arch, "Missing", false)
+							pointerIR, err := x86ScalarFPBitViewAPI(t, original, decl, arch, triple, api)
+							if err != nil {
+								t.Fatal(err)
+							}
+							x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+							x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+							x86NumericNativeAddressObject(t, ir, triple)
+							continue
+						}
+						if arch == "amd64" && (strings.HasPrefix(missing, "source") || missing == "old") {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual aligned-block/old/mask/native-address input was manufactured", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_four_source_go127_test.go b/x86_four_source_go127_test.go
new file mode 100644
index 000000000..927a2b3f9
--- /dev/null
+++ b/x86_four_source_go127_test.go
@@ -0,0 +1,62 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The table oracle is independent of the translator's six semantic entries.
+// A name count alone would miss the tuple, zeroing, LL and mask-row attributes.
+func TestX86FourSourceCompleteOfficialGoEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := make(map[string]int)
+	for _, rule := range rules {
+		if !strings.HasPrefix(rule.Opcode, "V4FM") && !strings.HasPrefix(rule.Opcode, "V4FNM") &&
+			!strings.HasPrefix(rule.Opcode, "VP4DPW") {
+			continue
+		}
+		opcode, exists := map[string]int{
+			"V4FMADDPS": 0x9a, "V4FMADDSS": 0x9b,
+			"V4FNMADDPS": 0xaa, "V4FNMADDSS": 0xab,
+			"VP4DPWSSD": 0x52, "VP4DPWSSDS": 0x53,
+		}[rule.Opcode]
+		if !exists || rule.RowIndex < 0 || rule.RowIndex > 1 {
+			t.Fatal("official four-source family acquired an unobserved name or row", rule)
+		}
+		table, source, destination, length := "_yv4fmaddps", "YzrMulti4", "Yzr", "evex512"
+		if strings.HasSuffix(rule.Opcode, "SS") {
+			table, source, destination, length = "_yv4fmaddss", "YxrEvexMulti4", "YxrEvex", "evex128"
+		}
+		classes, zcase, advance := []string{"Ym", source, destination}, "Zevex_rm_v_r", 0
+		if rule.RowIndex == 1 {
+			classes, zcase, advance = []string{"Ym", source, "Yknot0", destination}, "Zevex_rm_v_k_r", 3
+		}
+		attributes := []string{
+			"avxEscape | " + length + " | evexF2 | evex0F38 | evexW0",
+			"evexN16 | evexZeroingEnabled", fmt.Sprintf("0x%02X", opcode),
+		}
+		if rule.Ytab != table || rule.Prefix != "Pavx" || rule.EncodingOffset != 0 ||
+			rule.ZOffset != advance || rule.ZCase != zcase || !reflect.DeepEqual(rule.Classes, classes) ||
+			!reflect.DeepEqual(rule.OpBytes, attributes) {
+			t.Fatal("complete four-source operand/tuple/mask/zeroing/encoding row changed", rule, attributes)
+		}
+		counts[rule.Opcode]++
+	}
+	want := map[string]int{
+		"V4FMADDPS": 2, "V4FMADDSS": 2, "V4FNMADDPS": 2,
+		"V4FNMADDSS": 2, "VP4DPWSSD": 2, "VP4DPWSSDS": 2,
+	}
+	if !reflect.DeepEqual(counts, want) {
+		t.Fatal("complete six-name twelve-row four-source directory changed", counts)
+	}
+}
diff --git a/x86_four_source_math_instrumentation_test.go b/x86_four_source_math_instrumentation_test.go
new file mode 100644
index 000000000..68f04113b
--- /dev/null
+++ b/x86_four_source_math_instrumentation_test.go
@@ -0,0 +1,387 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Private test-only lane mathematics, retained from the earlier implementation.
+// No production path calls it: it does not certify original MXCSR, sequential
+// exception priority, physical register effects or native memory faults.
+type x86FourSourceMathForm struct {
+	amd64FourSourceForm
+	mask string
+}
+
+func x86FourSourceMathIR(t *testing.T, file *File, signatures map[string]FuncSig, triple string, expected int) string {
+	t.Helper()
+	count := 0
+	ir := x86InstructionFormatObjectUnit(t, file, signatures, "amd64", triple, 0,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			form, known, err := x86FourSourceProperties(ins.Op, ins, "amd64")
+			if known {
+				if err != nil {
+					return true, false, err
+				}
+				count++
+				mathematical := x86FourSourceMathForm{amd64FourSourceForm: form}
+				if form.maskIndex >= 0 {
+					mathematical.mask, err = c.loadK(ins.Args[form.maskIndex].Reg)
+					if err != nil {
+						return true, false, err
+					}
+				}
+				if form.spec.mode == amd64FourSourceFMA {
+					return c.lowerFourSourceFMA(form.spec, mathematical)
+				}
+				return c.lowerFourSourceDotWords(form.spec, mathematical)
+			}
+			terminated, err := c.lowerInstr(0, 0, ins, nil, nil)
+			return true, terminated, err
+		})
+	if count != expected {
+		t.Fatal("private mathematical instrumentation lost a complete original opcode", count, expected)
+	}
+	// These are exact per-function x86 feature groups, not host capabilities.
+	// Remove each complete checked group and all its references only here;
+	// otherwise LLVM could choose a rare/native ISA in this numerical oracle.
+	profiles := make(map[string]int)
+	for _, function := range file.Funcs {
+		features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", function)
+		if features == "" {
+			t.Fatal("private mathematical fixture lost its original x86 feature identity")
+		}
+		profiles[features]++
+	}
+	groups := regexp.MustCompile(`(?m)^attributes (#[0-9]+) = \{ "target-features"="([^"]+)" \}\r?\n`).FindAllStringSubmatch(ir, -1)
+	if len(groups) != len(profiles) {
+		t.Fatal("private mathematical feature-group inventory changed", len(groups), len(profiles))
+	}
+	for _, group := range groups {
+		uses, found := profiles[group[2]]
+		if !found || uses == 0 || strings.Count(ir, group[0]) != 1 {
+			t.Fatal("unobserved private mathematical ISA group", group[2])
+		}
+		ir = strings.Replace(ir, group[0], "", 1)
+		if strings.Count(ir, " "+group[1]) != uses {
+			t.Fatal("private mathematical ISA group lost exact function ownership", group[1], uses)
+		}
+		ir = strings.ReplaceAll(ir, " "+group[1], "")
+		delete(profiles, group[2])
+	}
+	if len(profiles) != 0 || strings.Contains(ir, "target-features") || strings.Contains(ir, " asm ") {
+		t.Fatal("private mathematical IR still contains unchecked native/rare machine behavior")
+	}
+	t.Logf("private four-source mathematical instrumentation: checked replacements=%d; exact x86 feature groups removed=%d; no native inline assembly; not original MXCSR, exception or fault execution", count, len(groups))
+	return ir
+}
+
+func x86FourSourceOriginalMathCompanion(t *testing.T, original, mainC string) {
+	t.Helper()
+	observed, oracle := x86FourSourceOriginalProgram(t)
+	if original != observed || mainC != oracle {
+		t.Fatal("mathematical companion did not consume both complete unchanged original literals")
+	}
+	file, err := x86FourSourceOriginalMathSource(original, mainC)
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures := x86FourSourceOriginalSignatures()
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := x86FourSourceMathIR(t, file, signatures, triple, 8)
+	for index, name := range []string{"foursourcesemantics", "foursourcefaultsuppression"} {
+		old := fmt.Sprint("@InstructionFormat", index, "(")
+		if strings.Count(ir, old) != 1 {
+			t.Fatal("private mathematical C identity lost its single actual function definition", name)
+		}
+		ir = strings.Replace(ir, old, "@"+name+"(", 1)
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("actual-host mathematical companion requires exact LLVM22 llc/clang")
+	}
+	t.Log("original complete ASM/C literals retained; derived fault source has six explicit zero producers and seven portable byte transports; no original rare-ISA execution claim")
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "four-source-original-mathematics", triple, ir, mainC)
+}
+
+// Both positive execution and mutation controls call this actual projector.
+// A changed source returns no partially instrumented file, not a later-stage
+// t.Fatal that could be mistaken for an expected source rejection.
+func x86FourSourceOriginalMathSource(original, mainC string) (*File, error) {
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(original))) != "c68bfc687ce73e04389fd0e3f57146554f85d3967d9c44c80ac6e1dbefbd5070" ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(mainC))) != "44e5e74ea2f0f24009632362a848a5bc0e9f6c8002e04d8e4310a2f4270bc3a4" {
+		return nil, fmt.Errorf("private four-source mathematics needs its two complete unchanged original literals")
+	}
+	// The original fault TEXT lacks initialized source/accumulator inputs. Its
+	// separate public Context remains mandatory. This explicit derived fixture
+	// supplies real producers, rather than relying on C passing mask=0 or on
+	// the emitter's zero-initialized implementation slots.
+	anchor := "\tKMOVQ CX, K1\n\tV4FMADDPS.Z (AX)"
+	if strings.Count(original, anchor) != 1 {
+		return nil, fmt.Errorf("the complete original fault-source instrumentation anchor changed")
+	}
+	var producers strings.Builder
+	for register := 0; register < 6; register++ {
+		fmt.Fprintf(&producers, "\tVPXORD Z%d,Z%d,Z%d\n", register, register, register)
+	}
+	derived := strings.Replace(original, anchor, "\tKMOVQ CX, K1\n"+producers.String()+"\tV4FMADDPS.Z (AX)", 1)
+	file, err := Parse(ArchAMD64, derived)
+	if err != nil || len(file.Funcs) != 2 {
+		return nil, fmt.Errorf("private mathematics lost the complete original two-TEXT program: %v", err)
+	}
+	// Original legacy MOVUPS would select the original native bridge. Here
+	// all seven are explicit portable byte transports. Their upper-alias
+	// difference is outside this instrumented program's C observations; native
+	// alias behavior has independent complete initialized/state/object controls.
+	transports := 0
+	for function := range file.Funcs {
+		for index := range file.Funcs[function].Instrs {
+			ins := &file.Funcs[function].Instrs[index]
+			if ins.Op == "MOVUPS" {
+				if len(ins.Args) != 2 {
+					return nil, fmt.Errorf("unobserved original legacy byte-transport grammar")
+				}
+				ins.Op = "VMOVUPS"
+				ins.Raw = strings.Replace(ins.Raw, "MOVUPS", "VMOVUPS", 1)
+				transports++
+			}
+		}
+	}
+	if transports != 7 || file.Funcs[0].Sym != "foursourcesemantics" || file.Funcs[1].Sym != "foursourcefaultsuppression" {
+		return nil, fmt.Errorf("private mathematics lost its seven byte transports or two original function identities: %d", transports)
+	}
+	return file, nil
+}
+
+func x86FourSourceOriginalSignatures() map[string]FuncSig {
+	result := make(map[string]FuncSig)
+	for _, name := range []string{"foursourcesemantics", "foursourcefaultsuppression"} {
+		result[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, I64}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: I64, Index: 2, Field: -1},
+			}},
+		}
+	}
+	return result
+}
+
+func (c *amd64Ctx) lowerFourSourceFMA(spec amd64FourSourceSpec, form x86FourSourceMathForm) (bool, bool, error) {
+	activeMaskBits := 16
+	if spec.scalar {
+		activeMaskBits = 1
+	}
+	memoryBits, err := c.loadFourSourceMemoryI32(form, activeMaskBits)
+	if err != nil {
+		return true, false, err
+	}
+	memoryName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %s to <4 x float>\n", memoryName, memoryBits)
+	memory := "%" + memoryName
+	if spec.scalar {
+		return c.lowerFourSourceScalarFMA(spec, form, memory)
+	}
+
+	accumulator, err := c.loadFloatingVectorOperand(form.destination, 64, 16, 32)
+	if err != nil {
+		return true, false, err
+	}
+	original := accumulator
+	for sourceIndex := 0; sourceIndex < 4; sourceIndex++ {
+		sourceReg := Operand{Kind: OpReg, Reg: Reg(fmt.Sprintf("Z%d", form.sourceBase+sourceIndex))}
+		source, loadErr := c.loadFloatingVectorOperand(sourceReg, 64, 16, 32)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		factor := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x float> %s, i32 %d\n", factor, memory, sourceIndex)
+		factors := c.splatFMA3Scalar(16, 32, "%"+factor)
+		if spec.negative {
+			negated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = fneg <16 x float> %s\n", negated, source)
+			source = "%" + negated
+		}
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call <16 x float> @llvm.fma.v16f32(<16 x float> %s, <16 x float> %s, <16 x float> %s)\n", result, source, factors, accumulator)
+		accumulator = "%" + result
+	}
+	if form.mask != "" {
+		computedBits := c.newTmp()
+		originalBits := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x float> %s to <16 x i32>\n", computedBits, accumulator)
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x float> %s to <16 x i32>\n", originalBits, original)
+		masked := amd64ApplyI32LaneMask(c, 16, "%"+computedBits, "%"+originalBits, form.mask, form.zeroing)
+		back := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i32> %s to <16 x float>\n", back, masked)
+		accumulator = "%" + back
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x float> %s to <64 x i8>\n", out, accumulator)
+	return true, false, c.storeZ(form.destination.Reg, "%"+out)
+}
+
+func (c *amd64Ctx) lowerFourSourceScalarFMA(spec amd64FourSourceSpec, form x86FourSourceMathForm, memory string) (bool, bool, error) {
+	accumulator, err := c.loadXLowF32(form.destination.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	original := accumulator
+	for sourceIndex := 0; sourceIndex < 4; sourceIndex++ {
+		sourceReg := Reg(fmt.Sprintf("X%d", form.sourceBase+sourceIndex))
+		source, loadErr := c.loadXLowF32(sourceReg)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		if spec.negative {
+			negated := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = fneg float %s\n", negated, source)
+			source = "%" + negated
+		}
+		factor := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <4 x float> %s, i32 %d\n", factor, memory, sourceIndex)
+		result := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = call float @llvm.fma.f32(float %s, float %%%s, float %s)\n", result, source, factor, accumulator)
+		accumulator = "%" + result
+	}
+	if form.mask != "" {
+		bit := amd64MaskBitI1(c, form.mask, 0)
+		fallback := original
+		if form.zeroing {
+			fallback = "0.000000e+00"
+		}
+		selected := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = select i1 %s, float %s, float %s\n", selected, bit, accumulator, fallback)
+		accumulator = "%" + selected
+	}
+	destination, err := c.loadX(form.destination.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	words := c.newTmp()
+	bits := c.newTmp()
+	inserted := c.newTmp()
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i8> %s to <4 x i32>\n", words, destination)
+	fmt.Fprintf(c.b, "  %%%s = bitcast float %s to i32\n", bits, accumulator)
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i32> %%%s, i32 %%%s, i32 0\n", inserted, words, bits)
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %%%s to <16 x i8>\n", out, inserted)
+	return true, false, c.storePackedMoveOperand(form.destination, 16, "%"+out)
+}
+
+func (c *amd64Ctx) lowerFourSourceDotWords(spec amd64FourSourceSpec, form x86FourSourceMathForm) (bool, bool, error) {
+	memoryDwords, err := c.loadFourSourceMemoryI32(form, 16)
+	if err != nil {
+		return true, false, err
+	}
+	memoryName := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <4 x i32> %s to <8 x i16>\n", memoryName, memoryDwords)
+	memory := "%" + memoryName
+	destinationBytes, err := c.loadZ(form.destination.Reg)
+	if err != nil {
+		return true, false, err
+	}
+	original := c.bitcastVectorBytesToIntegerLanes(64, 16, 32, destinationBytes)
+	accumulator := original
+	for sourceIndex := 0; sourceIndex < 4; sourceIndex++ {
+		sourceReg := Reg(fmt.Sprintf("Z%d", form.sourceBase+sourceIndex))
+		sourceBytes, loadErr := c.loadZ(sourceReg)
+		if loadErr != nil {
+			return true, false, loadErr
+		}
+		source := c.bitcastVectorBytesToIntegerLanes(64, 32, 16, sourceBytes)
+		accumulator = c.emitFourSourceDotStep(accumulator, source, memory, sourceIndex, spec.saturating)
+	}
+	if form.mask != "" {
+		accumulator = amd64ApplyI32LaneMask(c, 16, accumulator, original, form.mask, form.zeroing)
+	}
+	out := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = bitcast <16 x i32> %s to <64 x i8>\n", out, accumulator)
+	return true, false, c.storeZ(form.destination.Reg, "%"+out)
+}
+
+func (c *amd64Ctx) loadFourSourceMemoryI32(form x86FourSourceMathForm, activeMaskBits int) (string, error) {
+	if form.mask == "" {
+		bytes, err := c.loadPackedCompareBytes(form.memory, 16)
+		if err != nil {
+			return "", err
+		}
+		return c.bitcastVectorBytesToIntegerLanes(16, 4, 32, bytes), nil
+	}
+	masked := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = and i64 %s, %d\n", masked, form.mask, (uint64(1)<<activeMaskBits)-1)
+	active := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp ne i64 %%%s, 0\n", active, masked)
+	seed := c.newTmp()
+	predicate := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = insertelement <4 x i1> poison, i1 %%%s, i32 0\n", seed, active)
+	fmt.Fprintf(c.b, "  %%%s = shufflevector <4 x i1> %%%s, <4 x i1> poison, <4 x i32> zeroinitializer\n", predicate, seed)
+	pointer, pointerType, intrinsicSuffix, err := c.packedVectorMemoryPointer(form.memory)
+	if err != nil {
+		return "", err
+	}
+	loaded := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = call <4 x i32> @llvm.masked.load.v4i32%s(%s align 1 %s, <4 x i1> %%%s, <4 x i32> zeroinitializer)\n",
+		loaded, intrinsicSuffix, pointerType, pointer, predicate)
+	return "%" + loaded, nil
+}
+
+func (c *amd64Ctx) emitFourSourceDotStep(accumulator, source, memory string, sourceIndex int, saturating bool) string {
+	result := "poison"
+	for lane := 0; lane < 16; lane++ {
+		accumulatorLane := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = extractelement <16 x i32> %s, i32 %d\n", accumulatorLane, accumulator, lane)
+		total := ""
+		if saturating {
+			wide := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = sext i32 %%%s to i64\n", wide, accumulatorLane)
+			total = "%" + wide
+		} else {
+			total = "%" + accumulatorLane
+		}
+		for word := 0; word < 2; word++ {
+			sourceLane := c.newTmp()
+			memoryLane := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = extractelement <32 x i16> %s, i32 %d\n", sourceLane, source, lane*2+word)
+			fmt.Fprintf(c.b, "  %%%s = extractelement <8 x i16> %s, i32 %d\n", memoryLane, memory, sourceIndex*2+word)
+			wideSource := c.newTmp()
+			wideMemory := c.newTmp()
+			bits := 32
+			if saturating {
+				bits = 64
+			}
+			fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i%d\n", wideSource, sourceLane, bits)
+			fmt.Fprintf(c.b, "  %%%s = sext i16 %%%s to i%d\n", wideMemory, memoryLane, bits)
+			product := c.newTmp()
+			next := c.newTmp()
+			fmt.Fprintf(c.b, "  %%%s = mul i%d %%%s, %%%s\n", product, bits, wideSource, wideMemory)
+			fmt.Fprintf(c.b, "  %%%s = add i%d %s, %%%s\n", next, bits, total, product)
+			total = "%" + next
+		}
+		if saturating {
+			total = c.saturateFourSourceI64ToI32(total)
+		}
+		inserted := c.newTmp()
+		fmt.Fprintf(c.b, "  %%%s = insertelement <16 x i32> %s, i32 %s, i32 %d\n", inserted, result, total, lane)
+		result = "%" + inserted
+	}
+	return result
+}
+
+func (c *amd64Ctx) saturateFourSourceI64ToI32(value string) string {
+	above := c.newTmp()
+	capped := c.newTmp()
+	below := c.newTmp()
+	bounded := c.newTmp()
+	narrowed := c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = icmp sgt i64 %s, 2147483647\n", above, value)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 2147483647, i64 %s\n", capped, above, value)
+	fmt.Fprintf(c.b, "  %%%s = icmp slt i64 %%%s, -2147483648\n", below, capped)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %%%s, i64 -2147483648, i64 %%%s\n", bounded, below, capped)
+	fmt.Fprintf(c.b, "  %%%s = trunc i64 %%%s to i32\n", narrowed, bounded)
+	return "%" + narrowed
+}
diff --git a/x86_four_source_math_policy_test.go b/x86_four_source_math_policy_test.go
new file mode 100644
index 000000000..7db8e097e
--- /dev/null
+++ b/x86_four_source_math_policy_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+func x86FourSourceMathDriverPolicy(function *ast.FuncDecl) bool {
+	if function.Body == nil {
+		return false
+	}
+	calls := 0
+	for _, statement := range function.Body.List {
+		if declaration, ok := statement.(*ast.DeclStmt); ok {
+			constants, ok := declaration.Decl.(*ast.GenDecl)
+			if !ok || constants.Tok != token.CONST {
+				return false
+			}
+			continue // Literal identity has its independent complete SHA contract.
+		}
+		expression, ok := statement.(*ast.ExprStmt)
+		if !ok {
+			return false // Conditional, deferred and asynchronous paths are not execution evidence.
+		}
+		call, ok := expression.X.(*ast.CallExpr)
+		if !ok {
+			return false
+		}
+		callee, ok := call.Fun.(*ast.Ident)
+		if !ok || callee.Name != "x86FourSourceOriginalMathCompanion" || len(call.Args) != 3 {
+			return false
+		}
+		for index, expected := range []string{"t", "source", "mainC"} {
+			argument, ok := call.Args[index].(*ast.Ident)
+			if !ok || argument.Name != expected {
+				return false
+			}
+		}
+		calls++
+	}
+	return calls == 1
+}
+
+func TestX86FourSourceOriginalMathDriverIsExplicitAndMandatory(t *testing.T) {
+	x86FourSourceOriginalProgram(t)
+	syntax, err := parser.ParseFile(token.NewFileSet(), "amd64_lower_four_source_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == "TestAMD64FourSourceRuntimeSemantics" {
+			if !x86FourSourceMathDriverPolicy(function) {
+				t.Fatal("the original runtime driver must invoke its explicit mathematical companion with unchanged complete ASM/C, without a native claim or optional skip")
+			}
+			return
+		}
+	}
+	t.Fatal("the original four-source runtime driver is absent")
+}
+
+func TestX86FourSourceMathDriverPolicyRejectsFalseExecution(t *testing.T) {
+	for _, scenario := range []struct {
+		name, body string
+		valid      bool
+	}{
+		{"actual", "x86FourSourceOriginalMathCompanion(t,source,mainC)", true},
+		{"absent", "", false},
+		{"conditioned", "if false { x86FourSourceOriginalMathCompanion(t,source,mainC) }", false},
+		{"deferred", "defer x86FourSourceOriginalMathCompanion(t,source,mainC)", false},
+		{"asynchronous", "go x86FourSourceOriginalMathCompanion(t,source,mainC)", false},
+		{"twice", "x86FourSourceOriginalMathCompanion(t,source,mainC);x86FourSourceOriginalMathCompanion(t,source,mainC)", false},
+		{"wrong ASM", "x86FourSourceOriginalMathCompanion(t,mainC,mainC)", false},
+		{"wrong C", "x86FourSourceOriginalMathCompanion(t,source,source)", false},
+		{"literal replacement", `x86FourSourceOriginalMathCompanion(t,"other",mainC)`, false},
+		{"native claim", "compileAndRunRuntimeTest(t,source,mainC)", false},
+		{"skip", "t.Skip(\"rare ISA absent\");x86FourSourceOriginalMathCompanion(t,source,mainC)", false},
+	} {
+		t.Run(scenario.name, func(t *testing.T) {
+			input := "package fixture\nfunc Observe(){const source=\"source\";const mainC=\"C\";" + scenario.body + "}"
+			syntax, err := parser.ParseFile(token.NewFileSet(), "driver.go", strings.NewReader(input), 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function, ok := syntax.Decls[0].(*ast.FuncDecl)
+			if !ok || x86FourSourceMathDriverPolicy(function) != scenario.valid {
+				t.Fatal("an independent false-execution policy control changed", scenario.valid)
+			}
+		})
+	}
+}
+
+func TestX86FourSourceOriginalMathProjectionBindsAllSourceAndOracleBytes(t *testing.T) {
+	source, oracle := x86FourSourceOriginalProgram(t)
+	if file, err := x86FourSourceOriginalMathSource(source, oracle); err != nil || file == nil || len(file.Funcs) != 2 {
+		t.Fatal("the actual complete original mathematics projector lost its positive control", err)
+	}
+	for _, mutation := range []struct{ name, source, oracle string }{
+		{"source truncation", strings.TrimSuffix(source, "\n"), oracle},
+		{"source append", source + "\n", oracle},
+		{"first missing", source[strings.Index(source, "\nTEXT foursourcefaultsuppression"):], oracle},
+		{"second missing", strings.Split(source, "\nTEXT foursourcefaultsuppression")[0], oracle},
+		{"opcode", strings.Replace(source, "V4FMADDPS", "V4FNMADDPS", 1), oracle},
+		{"mask", strings.Replace(source, "K1, Z5", "K2, Z5", 1), oracle},
+		{"memory", strings.Replace(source, "128(AX)", "124(AX)", 1), oracle},
+		{"source block", strings.Replace(source, "[Z2-Z5]", "[Z4-Z7]", 1), oracle},
+		{"accumulator", strings.Replace(source, "[Z2-Z5], Z4", "[Z2-Z5], Z5", 1), oracle},
+		{"fault producer", strings.Replace(source, "\tKMOVQ CX, K1\n\tV4FMADDPS.Z (AX)", "\tV4FMADDPS.Z (AX)", 1), oracle},
+		{"C replacement", source, "int main(void){return 0;}"},
+		{"C observation", source, strings.Replace(oracle, "return 10", "return 0", 1)},
+		{"C missing fault", source, strings.Replace(oracle, "  foursourcefaultsuppression(0, faultOut, 0);", "", 1)},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			if mutation.source == source && mutation.oracle == oracle {
+				t.Fatal("an independent mutation did not change the actual original input")
+			}
+			file, err := x86FourSourceOriginalMathSource(mutation.source, mutation.oracle)
+			if err == nil || file != nil {
+				t.Fatal("the actual projector consumed changed original source/C or leaked a partial derived program", err)
+			}
+		})
+	}
+}
diff --git a/x86_four_source_math_runtime_test.go b/x86_four_source_math_runtime_test.go
new file mode 100644
index 000000000..7bc16ffc2
--- /dev/null
+++ b/x86_four_source_math_runtime_test.go
@@ -0,0 +1,185 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This C computes finite, sequential lane mathematics independently of the
+// production opcode and byte-domain tables. It does not model ambient MXCSR,
+// exception order or native memory faults; those require the original rare
+// instructions, whose actual objects have a separate complete check.
+const x86FourSourceMathematicalC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <limits.h>
+#include <math.h>
+%s
+struct Kernel {
+  void (*run)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+  unsigned scalar,dot,negative,saturating,alias,mode,dead;
+};
+static const struct Kernel kernels[]={%s};
+struct Bytes { _Alignas(64) uint8_t before[64],value[256],after[64]; };
+static uint32_t u32(const uint8_t *p) { uint32_t v;memcpy(&v,p,4);return v; }
+static int16_t s16(const uint8_t *p) { int16_t v;memcpy(&v,p,2);return v; }
+static float f32(const uint8_t *p) { float v;memcpy(&v,p,4);return v; }
+static void put32(uint8_t *p,uint32_t v) { memcpy(p,&v,4); }
+static const int16_t edges[]={INT16_MIN,-32767,-257,-1,0,1,256,32766,INT16_MAX};
+static const uint64_t masks[]={0,1,UINT64_C(0xaaaa),UINT64_C(0x5555),UINT64_C(0xffff),UINT64_C(1)<<63};
+int main(void) {
+  for(unsigned ki=0;ki<sizeof(kernels)/sizeof(kernels[0]);ki++) {
+    struct Kernel k=kernels[ki];
+    for(unsigned sample=0;sample<97;sample++) for(unsigned mi=0;mi<sizeof(masks)/sizeof(masks[0]);mi++) {
+      struct Bytes input,old,memory,out;
+      memset(&input,0xa7,sizeof(input));memset(&old,0xb9,sizeof(old));
+      memset(&memory,0xd5,sizeof(memory));memset(&out,0xc3,sizeof(out));
+      if(k.dot) {
+        for(unsigned r=0;r<4;r++) for(unsigned lane=0;lane<32;lane++) {
+          int16_t v=edges[(sample+r*3+lane)%%9];memcpy(input.value+r*64+lane*2,&v,2);
+        }
+        for(unsigned word=0;word<8;word++) {
+          int16_t v=edges[(sample+word*2)%%9];memcpy(memory.value+word*2,&v,2);
+        }
+        for(unsigned lane=0;lane<16;lane++) {
+          int32_t v=lane%%3==0?INT32_MAX-(int32_t)sample:lane%%3==1?INT32_MIN+(int32_t)sample:-(int32_t)(sample*13);
+          memcpy(old.value+lane*4,&v,4);
+        }
+      } else {
+        for(unsigned r=0;r<4;r++) for(unsigned lane=0;lane<16;lane++) {
+          uint32_t v=UINT32_C(0x3f800001)+(sample*17+r*23+lane*13);
+          if((sample+r+lane)&1)v^=UINT32_C(0x80000000);
+          put32(input.value+r*64+lane*4,v);
+        }
+        for(unsigned lane=0;lane<16;lane++) put32(old.value+lane*4,UINT32_C(0x40000001)+sample*7+lane*11);
+        for(unsigned step=0;step<4;step++) put32(memory.value+step*4,UINT32_C(0x3f000001)+step*19+sample*3);
+      }
+      struct Bytes beforeInput=input,beforeOld=old,beforeMemory=memory;
+      uint8_t expected[256];memset(expected,0xc3,sizeof(expected));
+      const uint8_t *acc=k.alias?input.value:old.value;
+      if(!k.dead) {
+        if(k.scalar) { memset(expected,0,64);memcpy(expected,acc,16); }
+        for(unsigned lane=0;lane<(k.scalar?1:16);lane++) {
+          unsigned active=!k.mode||((masks[mi]>>lane)&1);
+          if(!active) {
+            if(k.mode==2) memset(expected+lane*4,0,4);
+            else memcpy(expected+lane*4,acc+lane*4,4);
+          } else if(!k.dot) {
+            float value=f32(acc+lane*4);
+            for(unsigned step=0;step<4;step++) {
+              float source=f32(input.value+step*64+lane*4);
+              if(k.negative)source=-source;
+              value=fmaf(source,f32(memory.value+step*4),value);
+            }
+            memcpy(expected+lane*4,&value,4);
+          } else {
+            uint32_t value=u32(acc+lane*4);
+            for(unsigned step=0;step<4;step++) {
+              int64_t sum=(int64_t)s16(input.value+step*64+lane*4)*s16(memory.value+step*4)
+                         +(int64_t)s16(input.value+step*64+lane*4+2)*s16(memory.value+step*4+2);
+              if(k.saturating) {
+                int32_t signedValue;memcpy(&signedValue,&value,4);sum+=signedValue;
+                if(sum>INT32_MAX)sum=INT32_MAX;if(sum<INT32_MIN)sum=INT32_MIN;
+                value=(uint32_t)sum;
+              } else value+=(uint32_t)sum;
+            }
+            put32(expected+lane*4,value);
+          }
+        }
+      }
+      expected[64]=1;
+      k.run(out.value,input.value,old.value,memory.value,masks[mi]);
+      if(memcmp(out.value,expected,sizeof(expected))||memcmp(&input,&beforeInput,sizeof(input))||
+         memcmp(&old,&beforeOld,sizeof(old))||memcmp(&memory,&beforeMemory,sizeof(memory))) {
+        fprintf(stderr,"private mathematical kernel/sample/mask=%%u/%%u/%%llx mismatch\n",ki,sample,(unsigned long long)masks[mi]);return 1;
+      }
+      for(unsigned byte=0;byte<64;byte++) if(out.before[byte]!=0xc3||out.after[byte]!=0xc3)return 2;
+    }
+  }
+  return 0;
+}
+`
+
+func x86FourSourceCompletePrivateMathematics(t *testing.T, memberIndex int) {
+	t.Helper()
+	x86FourSourceOriginalRuntimeUnchanged(t)
+	member := x86FourSourceOracle[memberIndex]
+	var source, prototypes, metadata strings.Builder
+	signatures := make(map[string]FuncSig)
+	count := 0
+	flag := func(value bool) int {
+		if value {
+			return 1
+		}
+		return 0
+	}
+	for mode, masking := range []string{"plain", "merge", "zero"} {
+		for _, destination := range []int{0, 6} {
+			for _, dead := range []bool{false, true} {
+				name := fmt.Sprint("MathFour", count)
+				row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot,
+					first: 2, dest: destination, mode: masking}
+				body, _ := x86FourSourceInitializedSource(row, "amd64", name, dead)
+				source.WriteString(body)
+				signatures[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+						{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+						{Offset: 32, Type: I64, Index: 4, Field: -1},
+					}},
+				}
+				fmt.Fprintf(&prototypes, "extern void InstructionFormat%d(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", count)
+				fmt.Fprintf(&metadata, "{InstructionFormat%d,%d,%d,%d,%d,%d,%d,%d},\n", count,
+					flag(member.scalar), flag(member.dot), flag(member.negate), flag(member.op == "VP4DPWSSDS"),
+					flag(destination == 0), mode, flag(dead))
+				count++
+			}
+		}
+	}
+	if count != 12 {
+		t.Fatal("complete private mode/alias/live/dead mathematical partition changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil || len(file.Funcs) != count {
+		t.Fatal("complete initialized mathematical source lost a function", err)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	ir := x86FourSourceMathIR(t, file, signatures, triple, count)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("actual-host private lane mathematics requires exact LLVM22 llc/clang")
+	}
+	t.Logf("private mathematical oracle %s: 12 complete initialized kernels, 97 finite samples, six mask patterns, all bytes/aliases/CF/input and output canaries; not original native MXCSR/fault execution", member.op)
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "four-source-lane-mathematics", triple, ir,
+		fmt.Sprintf(x86FourSourceMathematicalC, prototypes.String(), metadata.String()))
+}
+
+func TestX86FourSourcePrivateMathematicsPackedFMA(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 0)
+}
+
+func TestX86FourSourcePrivateMathematicsScalarFMA(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 1)
+}
+
+func TestX86FourSourcePrivateMathematicsPackedNegativeFMA(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 2)
+}
+
+func TestX86FourSourcePrivateMathematicsScalarNegativeFMA(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 3)
+}
+
+func TestX86FourSourcePrivateMathematicsDotWrap(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 4)
+}
+
+func TestX86FourSourcePrivateMathematicsDotSaturate(t *testing.T) {
+	x86FourSourceCompletePrivateMathematics(t, 5)
+}
diff --git a/x86_four_source_native_objects_test.go b/x86_four_source_native_objects_test.go
new file mode 100644
index 000000000..d907905b5
--- /dev/null
+++ b/x86_four_source_native_objects_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86FourSourceIsolatedMinimumISAProfiles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86FourSourceOracle {
+			t.Run(arch+"/"+member.op, func(t *testing.T) {
+				row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: "plain"}
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				want := "+avx5124fmaps,+avx512f"
+				if member.dot {
+					want = "+avx5124vnniw,+avx512f"
+				}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); got != want {
+					t.Fatal("isolated four-source opcode borrowed a producer's feature or the sibling rare ISA", got, want)
+				}
+			})
+		}
+	}
+}
+
+func x86FourSourceNativeObjectListing(t *testing.T, llc, objdump, triple, level, ir string) string {
+	t.Helper()
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "four-source.ll"), filepath.Join(directory, "four-source.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, llc,
+		level, "-mtriple="+triple, "-filetype=obj", input, "-o", object))
+	cancel()
+	if err != nil {
+		t.Fatalf("actual four-source machine object: %v\n%s", err, output)
+	}
+	stage, cancel = runtimeOracleStageContext(t)
+	listing, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, objdump, "-d", object))
+	cancel()
+	if err != nil {
+		t.Fatalf("independent LLVM22 four-source disassembly: %v\n%s", err, listing)
+	}
+	return strings.ToLower(string(listing))
+}
+
+// These are actual original-opcode objects, not native execution. In
+// particular, ordinary public runners need not supply Xeon Phi 4FMAPS or
+// 4VNNIW. Portable lane mathematics cannot certify original MXCSR, sequential
+// exception priority or the mask-controlled complete m128 access.
+func TestX86FourSourceLiveAndDeadRetainActualNativeOpcodes(t *testing.T) {
+	x86FourSourceOriginalRuntimeUnchanged(t)
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("original rare-ISA objects require exact LLVM22 llc and llvm-objdump")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			functions := make(map[string]string)
+			for index, member := range x86FourSourceOracle {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if target.arch == "386" && mode != "plain" {
+						continue
+					}
+					for _, dead := range []bool{false, true} {
+						row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot,
+							first: 2, dest: 6, mode: mode}
+						name := fmt.Sprintf("NativeFour%d_%s_%t", index, mode, dead)
+						body, declaration := x86FourSourceInitializedSource(row, target.arch, name, dead)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+						functions[strings.ToLower(name)] = strings.ToLower(member.op)
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original four-source source rejected before actual opcode observation", err)
+					}
+					if strings.Count(ir, " asm sideeffect ") != len(functions) || strings.Count(ir, "~{fpsr}") != len(functions)*4/6 {
+						t.Fatal("complete original opcodes lost memory sideeffects or floating-only ambient MXCSR/exception effects")
+					}
+					for _, pipeline := range []struct{ name, level, body string }{
+						{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+						{"IR_O2_backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							listing := x86FourSourceNativeObjectListing(t, llc, objdump, target.triple, pipeline.level, pipeline.body)
+							sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?(nativefour[0-5]_(?:plain|merge|zero)_(?:false|true))>:\r?\n`).FindAllStringSubmatchIndex(listing, -1)
+							if len(sections) != len(functions) {
+								t.Fatal("actual object lost a complete live/dead original function", len(sections), len(functions))
+							}
+							seen := make(map[string]bool)
+							for index, section := range sections {
+								name := listing[section[2]:section[3]]
+								opcode, found := functions[name]
+								if !found || seen[name] {
+									t.Fatal("unobserved or duplicate physical original function", name)
+								}
+								seen[name] = true
+								end := len(listing)
+								if index+1 < len(sections) {
+									end = sections[index+1][0]
+								}
+								body := listing[section[1]:end]
+								t.Run(name, func(t *testing.T) {
+									pattern := regexp.MustCompile(`\b` + opcode + `\b`)
+									if got := len(pattern.FindAllStringIndex(body, -1)); got != 1 {
+										t.Fatal("this original live/dead function lost its single exact memory opcode", opcode, got)
+									}
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_four_source_original_controls_test.go b/x86_four_source_original_controls_test.go
new file mode 100644
index 000000000..1891b4ca5
--- /dev/null
+++ b/x86_four_source_original_controls_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86FourSourceOriginalDeclarations = `
+func foursourcesemantics(in *[512]byte,out *[272]byte,mask uint64)
+func foursourcefaultsuppression(memory *[16]byte,out *[144]byte,mask uint64)
+`
+
+func TestX86FourSourceOriginalCompleteProgramGoObjectsAndContext(t *testing.T) {
+	source, _ := x86FourSourceOriginalProgram(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("the unchanged original program's format objects require exact LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Original masked four-operand source is not Go's named 386 grammar.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, x86FourSourceOriginalDeclarations, "amd64", target.triple, api)
+					x86VectorScratchCodegenControl(t, source, x86FourSourceOriginalDeclarations, "amd64", target.triple, ir, err)
+				})
+			}
+			file, err := Parse(ArchAMD64, source)
+			if err != nil || len(file.Funcs) != 2 {
+				t.Fatal("the private original format object lost a complete TEXT", err)
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, x86FourSourceOriginalSignatures(), "amd64", target.triple, 0)
+			for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				compileLLVMToObject(t, llc, target.triple, "four-source-original-format.ll", "four-source-original-format.o", body)
+			}
+		})
+	}
+}
+
+func TestX86FourSourceOriginalInitializedFirstTEXTActualObjects(t *testing.T) {
+	original, _ := x86FourSourceOriginalProgram(t)
+	source, _, found := strings.Cut(original, "\nTEXT foursourcefaultsuppression(SB)")
+	if !found || strings.Count(source, "TEXT ") != 1 || !strings.HasSuffix(source, "\tRET\n") {
+		t.Fatal("the original initialized first TEXT was not retained in full")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("the original initialized first TEXT requires exact LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Independent legal 386 family counterparts are separate, not edited originals.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func foursourcesemantics(in *[512]byte,out *[272]byte,mask uint64)", "amd64", target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("the original fully initialized source remains a public positive, not a format or Context fixture", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "four-source-original-inputs.ll", "four-source-original-inputs.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FourSourceHighBanksAndAlignedBlocksActualObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete physical register-bank counterparts require exact LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			firsts, destination := []int{26, 28}, 31
+			if target.arch == "386" {
+				firsts, destination = []int{4}, 6
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, member := range x86FourSourceOracle {
+				for _, first := range firsts {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if target.arch == "386" && mode != "plain" {
+							continue
+						}
+						row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot,
+							first: first, dest: destination, mode: mode}
+						body, declaration := x86FourSourceInitializedSource(row, target.arch, fmt.Sprint("HighFour", count), false)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+						count++
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("the complete valid high/effective aligned block lost its actual original inputs", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "four-source-banks.ll", "four-source-banks.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86FourSourceRequiresOriginalNativeBackingAndTarget(t *testing.T) {
+	for _, member := range x86FourSourceOracle {
+		row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: "plain"}
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown"} {
+			t.Run(member.op+"/"+triple, func(t *testing.T) {
+				source, declaration := x86FourSourceInitializedSource(row, "amd64", "Value", false)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("portable mathematics silently replaced original x86 exception/native-access behavior", api, err)
+					}
+				}
+			})
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(member.op+"/"+arch+"/logical FP", func(t *testing.T) {
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				var source strings.Builder
+				source.WriteString("TEXT ·Value(SB),4,$0-16\n")
+				for register := 0; register < 7; register++ {
+					fmt.Fprintf(&source, "VPXORD Z%d,Z%d,Z%d\n", register, register, register)
+				}
+				source.WriteString(strings.Replace(row.instruction(), "(BX)", "a+0(FP)", 1) + "\nRET\n")
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Value(a,b uint64)", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("two initialized logical FP scalars acquired contiguous original m128 native storage", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_four_source_state_test.go b/x86_four_source_state_test.go
new file mode 100644
index 000000000..fd78e5268
--- /dev/null
+++ b/x86_four_source_state_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86FourSourceKnownState(arch string) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	for register := 0; register < 32; register++ {
+		state.writeVector(register, 64, ^uint64(0), false)
+	}
+	index, _, _ := x86ResultGP(BX, x86ResultPointerWord(arch), arch)
+	state.pointerGP[index] = true
+	state.callerAddressGP[5] = true
+	state.masks[1], state.masks[3] = true, true
+	state.nativeMMX[7] = 0xa5
+	return state
+}
+
+func TestX86FourSourceEveryActualByteAliasesAndAtomicState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86FourSourceOracleRows(arch) {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				before := x86FourSourceKnownState(arch)
+				state := before.clone()
+				if accepted, known := x86ResultFourSourceStep(ins, &state, nil, arch, true); !accepted || !known || !reflect.DeepEqual(state, before) {
+					t.Fatal("complete initialized native bytes changed unrelated vectors/GP/FLAGS/DF/K/storage", accepted, known)
+				}
+				active := 64
+				if row.scalar {
+					active = 4
+				}
+				for role := 0; role < 5; role++ {
+					register := role
+					if role == 4 {
+						register = row.dest
+					}
+					for missing := 0; missing < 64; missing++ {
+						state := before.clone()
+						state.writeVector(register, 64, ^(uint64(1) << uint(missing)), false)
+						initial := state.clone()
+						accepted, known := x86ResultFourSourceStep(ins, &state, nil, arch, true)
+						if missing < active {
+							if accepted || !known || !reflect.DeepEqual(initial, state) {
+								t.Fatal("an actual implicit source or old accumulator byte was invented, or failed transfer was non-atomic", role, register, missing)
+							}
+							continue
+						}
+						want := initial.clone()
+						defined := uint64(0xffff)
+						if register == row.dest && missing < 16 {
+							defined &^= uint64(1) << uint(missing)
+						}
+						want.writeVector(row.dest, 16, defined, false)
+						if !accepted || !known || !reflect.DeepEqual(state, want) {
+							t.Fatal("scalar ignored source bytes or old upper-X passthrough gained NUM or lost EVEX upper zeroing", role, register, missing)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86FourSourceNativeContinuationDoesNotGrantInputsOrOtherRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86FourSourceOracle {
+			mode := "plain"
+			if arch == "amd64" {
+				mode = "zero"
+			}
+			row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: mode}
+			for _, mutation := range []string{"standalone", "missing pointer", "numeric address", "partial address", "unknown index", "mask", "raw", "address size", "physical segment"} {
+				if mutation == "mask" && arch == "386" {
+					continue
+				}
+				t.Run(arch+"/"+member.op+"/"+mutation, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction())
+					state := x86FourSourceKnownState(arch)
+					pointer, mask, _ := x86ResultGP(BX, x86ResultPointerWord(arch), arch)
+					native := true
+					switch mutation {
+					case "standalone":
+						native = false
+					case "missing pointer":
+						state.pointerGP[pointer] = false
+					case "numeric address":
+						state.pointerGP[pointer], state.gp[pointer] = false, mask
+					case "partial address":
+						state.pointerGP[pointer], state.gp[pointer] = false, 1
+					case "unknown index":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 1
+					case "mask":
+						state.masks[1] = false
+					case "raw":
+						ins.x86Encoded = true
+					case "address size":
+						ins.x86AddressBits = 32
+					case "physical segment":
+						ins.x86SegmentPrefix = 0x64
+					}
+					before := state.clone()
+					accepted, known := x86ResultFourSourceStep(ins, &state, nil, arch, native)
+					if !known || accepted != (mutation == "numeric address") || !reflect.DeepEqual(before, state) {
+						t.Fatal("the paired complete opcode created an unbound input/native/caller/entry role", mutation)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FourSourceAllMembersRejectMalformedOperandAndDispatchClasses(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86FourSourceOracle {
+			row := x86FourSourceOracleRow{op: member.op, scalar: member.scalar, dot: member.dot, first: 2, dest: 6, mode: "plain"}
+			original := x86ScalarLaneInstruction(t, row.instruction())
+			for _, mutation := range []string{"register memory", "three range", "five range", "nonconsecutive", "list not range", "other bank", "other destination", "high bank", "arity", "K0", "source dispatch", "SP index", "unresolved offset"} {
+				t.Run(arch+"/"+member.op+"/"+mutation, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					ins.Args[1].RegList = append([]Reg(nil), original.Args[1].RegList...)
+					dispatch := ins.Op
+					switch mutation {
+					case "register memory":
+						ins.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+					case "three range":
+						ins.Args[1].RegList = ins.Args[1].RegList[:3]
+					case "five range":
+						ins.Args[1].RegList = append(ins.Args[1].RegList, ins.Args[1].RegList[3])
+					case "nonconsecutive":
+						ins.Args[1].RegList[1] = ins.Args[1].RegList[0]
+					case "list not range":
+						ins.Args[1].RegListRange = false
+					case "other bank":
+						for index := range ins.Args[1].RegList {
+							ins.Args[1].RegList[index] = Reg(fmt.Sprint("Y", index+2))
+						}
+					case "other destination":
+						ins.Args[2].Reg = "Y6"
+					case "high bank":
+						bank, high := "Z", 32
+						if member.scalar {
+							bank = "X"
+						}
+						if arch == "386" {
+							high = 8
+						}
+						ins.Args[2].Reg = Reg(fmt.Sprint(bank, high))
+					case "arity":
+						ins.Args = ins.Args[:2]
+					case "K0":
+						ins.Args = []Operand{ins.Args[0], ins.Args[1], {Kind: OpReg, Reg: "K0"}, ins.Args[2]}
+					case "source dispatch":
+						dispatch = "V4FMADDPS"
+						if ins.Op == dispatch {
+							dispatch = "VP4DPWSSD"
+						}
+					case "SP index":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = SP, 1
+					case "unresolved offset":
+						ins.Args[0].Mem.OffRaw = "unbound"
+					}
+					if _, known, err := x86FourSourceProperties(dispatch, ins, arch); !known || err == nil {
+						t.Fatal("an invalid source class escaped complete family validation", known, err)
+					}
+					if _, known, err := x86TypedInstructionByteEffect(dispatch, ins, arch); !known || err == nil {
+						t.Fatal("an invalid source class acquired implicit byte effects", known, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_fp16_conversion_grammar_test.go b/x86_fp16_conversion_grammar_test.go
new file mode 100644
index 000000000..269cf3d78
--- /dev/null
+++ b/x86_fp16_conversion_grammar_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86FP16ConversionMalformedDispatchBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for member, op := range x86FP16ConversionResultNames {
+			for _, mutation := range []string{"dispatch", "mask", "destination", "source", "scale", "suffix"} {
+				t.Run(arch+"/"+op+"/"+mutation, func(t *testing.T) {
+					code := x86FP16ConversionResultEncoding(member, 0, true, false, false)
+					file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+					file, err := normalizeX86RawFile(file, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					dispatch := ins.Op
+					switch mutation {
+					case "dispatch":
+						dispatch = Op(x86FP16ConversionResultNames[(member+1)%6])
+					case "mask":
+						ins.Args[len(ins.Args)-2].Reg = "K0"
+					case "destination":
+						ins.Args[len(ins.Args)-1] = Operand{Kind: OpReg, Reg: AX}
+					case "source":
+						ins.Args[0] = Operand{Kind: OpImm, ImmIsFloat: true}
+					case "scale":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+					case "suffix":
+						ins.Op += ".INVALID"
+						dispatch = ins.Op
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerPackedHalfConversion(dispatch, ins)
+					if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+						t.Fatal("invalid FP16 conversion emitted IR", known, terminated, err)
+					}
+					if mutation == "dispatch" && !strings.Contains(err.Error(), "mismatch") {
+						t.Fatal("dispatch mismatch borrowed a different conversion shape", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_fp16_portable_model_test.go b/x86_fp16_portable_model_test.go
new file mode 100644
index 000000000..eeb9bcf10
--- /dev/null
+++ b/x86_fp16_portable_model_test.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These tests intentionally execute the existing cross-target numerical
+// model, even on x86 hosts without AVX512-FP16. Full public source/input checks
+// still run. Retarget only the resulting portable LLVM values to the host;
+// this is neither native FP16 execution nor a host MXCSR/exception oracle.
+// Independent native-object tests use each real x86 target without retargeting.
+func x86FP16NumericalModelIR(t *testing.T, file *File, sigs map[string]FuncSig, triple string) string {
+	t.Helper()
+	const model = "aarch64-unknown-linux-gnu"
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: model, Sigs: sigs})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(ir, "asm sideeffect") || strings.Contains(ir, "target-features") {
+		t.Fatal("portable FP16 model contains native hardware instructions or features")
+	}
+	from := fmt.Sprintf("target triple = %q", model)
+	if strings.Count(ir, from) != 1 {
+		t.Fatal("portable FP16 model lost its exact module target")
+	}
+	return strings.Replace(ir, from, fmt.Sprintf("target triple = %q", triple), 1)
+}
diff --git a/x86_fp_access_bytes.go b/x86_fp_access_bytes.go
new file mode 100644
index 000000000..566992ea5
--- /dev/null
+++ b/x86_fp_access_bytes.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import "strings"
+
+// X86FPAccessBytes observes a registered instruction's full native FP access
+// width. It is not a source, initialization, alignment, caller or translation
+// certificate. Unknown forms return no width; no opcode-suffix inference is
+// used. The actual original assembler and selected declaration remain the
+// diagnostic consumer's independent obligations.
+func X86FPAccessBytes(ins Instr, index int, arch string) (width int64, write, known bool) {
+	if arch != "amd64" && arch != "386" || index < 0 || index >= len(ins.Args) || ins.Args[index].Kind != OpFP {
+		return 0, false, false
+	}
+	// Actual Parse/CPP output uses canonical source opcodes. The observation
+	// does not promote a constructed case-folded identity to original source.
+	if name := string(ins.Op); name != strings.ToUpper(name) || name != strings.TrimSpace(name) {
+		return 0, false, false
+	}
+	// Generic source-stack diagnostics normalize suffixes, but that fallback
+	// cannot certify a constructed scalar opcode which bypassed this grammar.
+	if op := Op(normalizeInstructionOpcode(ins.Op)); x86RawReturnScalarMoveBytes(op) != 0 && ins.Op != op {
+		return 0, false, false
+	}
+	// These three Ym rows observe exactly m16. FINIT/FCLEX and FSTSW AX
+	// have no FP memory access. This supplies only width/direction, never a
+	// known control/status word or an independent caller/storage permission.
+	if form, recognized, err := x86X87WordProperties(ins, arch); recognized {
+		if err != nil || index != 0 || form.operand.Kind != OpFP {
+			return 0, false, false
+		}
+		return 2, form.kind != x86X87LoadControl, true
+	}
+	// x87 memory widths come from the same complete Go value grammar used by
+	// lowering and the private source observer. Operand-free/register forms
+	// have no FP access; malformed integer stores cannot fall through to a
+	// suffix-derived width. Recognition supplies no initialized value or role.
+	if form, recognized, err := x86X87ValueProperties(ins, arch); recognized {
+		if err != nil || form.memoryBytes() == 0 {
+			return 0, false, false
+		}
+		return form.memoryBytes(), index == 1, true
+	}
+	// CMP/TEST have two read-only operands, with opposite immediate positions.
+	// Reuse the complete lowering grammar; observing these widths supplies
+	// neither initialized flags/results nor permission to access native memory.
+	if form, recognized, err := x86ScalarCompareProperties(ins.Op, ins, arch); recognized {
+		if err != nil || form.memory != index {
+			return 0, false, false
+		}
+		return int64(form.bits / 8), false, true
+	}
+	// Broadcast memory reads have their scalar/block width, not the width of
+	// the vector destination. Mask-data broadcasts have no memory form at all.
+	if form, recognized, err := x86BroadcastProperties(ins.Op, ins, arch); recognized {
+		if err != nil || index != 0 || form.kind == x86BroadcastMask {
+			return 0, false, false
+		}
+		return int64(form.sourceBytes), false, true
+	}
+	if effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); recognized {
+		if err != nil {
+			return 0, false, false
+		}
+		for _, operand := range effect.operands {
+			if operand.index == index {
+				return operand.width, operand.write, true
+			}
+		}
+		return 0, false, false
+	}
+	// MOVL/MOVQ/MOVD and the VEX forms have complete Go GP/X memory rows in the
+	// same typed transfer grammar as register copies. Keep the FP observer on
+	// those rows instead of falling through to the GP-only scalar shortcut;
+	// otherwise MOVL X0,value(FP) and its load direction are silently reported
+	// as unknown despite being official formats. Go's MOVD alias shares MOVQ's
+	// eight-byte memory effect on both architectures.
+	if form, recognized, err := x86GPSIMDTransferProperties(ins, arch); recognized {
+		if err != nil || form.memory < 0 || form.memory != index {
+			return 0, false, false
+		}
+		return int64(form.bits / 8), form.memoryWrite, true
+	}
+	// The legacy MMX memory rows use these same opcode widths, but their bank
+	// remains separate from X-register state and caller initialization proofs.
+	if spec, known := x86GPSIMDTransferSpecs[ins.Op]; known && spec.legacy && len(ins.Args) == 2 {
+		other := ins.Args[1-index]
+		if isAMD64MOVDMRegister(other) && x86PackedShiftMemoryValid(ins.Args[index], arch) {
+			return int64(spec.bits / 8), index == 1, true
+		}
+	}
+	op := x86SourceMoveInstruction(ins, arch).Op
+	if op == "MOVB" || op == "MOVW" || op == "MOVL" || op == "MOVQ" {
+		if len(ins.Args) != 2 {
+			return 0, false, false
+		}
+		width = x86RawReturnScalarMoveBytes(op)
+		otherOperand := ins.Args[1-index]
+		if index == 1 && otherOperand.Kind == OpImm && otherOperand.ImmRaw == "" && !otherOperand.ImmIsFloat &&
+			(width != 8 || arch == "amd64" && otherOperand.Imm == int64(int32(otherOperand.Imm))) {
+			return width, true, true
+		}
+		if otherOperand.Kind != OpReg {
+			return 0, false, false
+		}
+		other := ins.Args[1-index].Reg
+		valid := isX86YrlRegisterForArch(other, arch)
+		if width == 1 {
+			valid = isGoYmbRegisterForArch(other, arch)
+		}
+		if !valid || width == 8 && arch == "386" {
+			return 0, false, false
+		}
+		return width, index == 1, true
+	}
+	// The source-stack consumer shares these ordered typed forms. Its own
+	// numerical/pointer/mask authority is not exported by this observation.
+	return x86InstructionMemoryShape(ins, index, arch)
+}
diff --git a/x86_fp_access_bytes_test.go b/x86_fp_access_bytes_test.go
new file mode 100644
index 000000000..6dc5e98b5
--- /dev/null
+++ b/x86_fp_access_bytes_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86FPAccessBytesOrderedForms(t *testing.T) {
+	rows := []struct {
+		instruction string
+		index       int
+		bytes       int64
+		write       bool
+	}{
+		{"MOVB a+0(FP),AL", 0, 1, false}, {"MOVW AX,a+0(FP)", 1, 2, true},
+		{"MOVL a+0(FP),AX", 0, 4, false}, {"MOVQ $7,a+0(FP)", 1, 8, true},
+		{"MOVB $7,a+0(FP)", 1, 1, true}, {"MOVSS a+0(FP),X0", 0, 4, false},
+		{"MOVSD X0,a+0(FP)", 1, 8, true}, {"MOVBQSX a+0(FP),AX", 0, 1, false},
+		{"VMOVSS.Z a+0(FP),K1,X0", 0, 4, false},
+		{"MOVWQZX a+0(FP),AX", 0, 2, false}, {"MOVLQSX a+0(FP),AX", 0, 4, false},
+		{"VPSRLW a+0(FP),Y0,Y1", 0, 16, false},
+		{"VPSRLVD.BCST a+0(FP),Z0,Z1", 0, 4, false},
+		{"VPSUBQ a+0(FP),Y0,Y1", 0, 32, false},
+		{"VPADDD.BCST a+0(FP),Z0,Z1", 0, 4, false},
+		{"VMOVDQU Y0,a+0(FP)", 1, 32, true},
+		{"KMOVW a+0(FP),K1", 0, 2, false},
+	}
+	for _, op := range []string{"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD"} {
+		rows = append(rows, struct {
+			instruction string
+			index       int
+			bytes       int64
+			write       bool
+		}{op + " a+0(FP),X0", 0, 16, false})
+	}
+	for _, row := range rows {
+		t.Run(row.instruction, func(t *testing.T) {
+			source := "TEXT ·probe(SB),4,$0-64\n" + row.instruction + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			width, write, known := X86FPAccessBytes(file.Funcs[0].Instrs[1], row.index, "amd64")
+			if !known || width != row.bytes || write != row.write {
+				t.Fatalf("native operand width/direction = %d/%v/%v, want %d/%v", width, write, known, row.bytes, row.write)
+			}
+		})
+	}
+}
+
+func TestX86FPAccessBytesUnknownDoesNotInferPermission(t *testing.T) {
+	for _, instruction := range []string{
+		"ADDQ a+0(FP),BAD", "ADDQ.Z a+0(FP),AX", "ADDQ a+0(FP),b+8(FP)",
+		"MOVQ a+0(FP),BAD", "MOVQ a+0(FP),Y0", "MOVOU a+0(FP),Y0",
+		"MOVL a+0(FP),M8", "MOVQ a+0(FP),M8", "MOVD a+0(FP),M8",
+		"VMOVD a+0(FP),M0", "VMOVQ M0,a+0(FP)", "MOVL a+0(FP),M0,M1",
+		"MOVQ a+0(FP),b+8(FP)", "MOVQ $1.0,a+0(FP)", "MOVQ $0x100000000,a+0(FP)",
+		"LEAQ a+0(FP),AX", "MOVQ a+0(FP)(SI*1),AX", "MOVQ $a+0(FP),AX",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·probe(SB),4,$0-16\n"+instruction+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			for index := range ins.Args {
+				if width, _, known := X86FPAccessBytes(ins, index, "amd64"); known || width != 0 {
+					t.Fatalf("unknown/malformed/native-address %s inferred bytes: %d/%v", instruction, width, known)
+				}
+			}
+		})
+	}
+	for _, instruction := range []string{"MOVQ a+0(FP),AX", "MOVOU a+0(FP),X8", "MOVL a+0(FP),R8"} {
+		file, err := Parse(ArchAMD64, "TEXT ·probe(SB),4,$0-16\n"+instruction+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if width, _, known := X86FPAccessBytes(file.Funcs[0].Instrs[1], 0, "386"); known || width != 0 {
+			t.Fatalf("unbound 386 physical bank/width %s: %d/%v", instruction, width, known)
+		}
+	}
+}
+
+func TestX86FPAccessBytesScalarRMWOrderedObservation(t *testing.T) {
+	// This independent syntax inventory is checked against the complete Go
+	// ordered tables by TestX86LockScalarRMWCompleteGoTables. Observation of
+	// an FP width is not admission of LOCK on virtual FP storage.
+	for _, arch := range []string{"amd64", "386"} {
+		forms := x86LockScalarOracleForms(arch)
+		for _, stem := range []string{"ADC", "ADD", "AND", "OR", "SBB", "SUB", "XOR"} {
+			widths := "BWL"
+			if arch == "amd64" {
+				widths += "Q"
+			}
+			for _, width := range widths {
+				register := "AX"
+				if width == 'B' {
+					register = "AL"
+				}
+				op := stem + string(width)
+				forms = append(forms, x86LockScalarOracleForm{op, op + " a+0(FP)," + register})
+			}
+		}
+		for _, form := range forms {
+			instruction := strings.Replace(form.text, "1(SI)", "a+0(FP)", 1)
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT ·probe(SB),4,$0-8\n" + instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				before := append([]Operand(nil), ins.Args...)
+				wantWidth := map[byte]int64{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[form.op[len(form.op)-1]]
+				for index, operand := range ins.Args {
+					width, write, known := X86FPAccessBytes(ins, index, arch)
+					if operand.Kind != OpFP {
+						if known || width != 0 || write {
+							t.Fatal("non-FP operand acquired a frame observation", index, width, write, known)
+						}
+						continue
+					}
+					if !known || width != wantWidth || write != (index == len(ins.Args)-1) {
+						t.Fatalf("ordered native FP observation = %d/%t/%t, want %d/%t/true", width, write, known, wantWidth, index == len(ins.Args)-1)
+					}
+				}
+				if !reflect.DeepEqual(ins.Args, before) {
+					t.Fatal("observation changed the original operands")
+				}
+			})
+		}
+	}
+}
+
+func TestX86FPAccessBytesKnownReadDoesNotSupplyInitializedBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			body := "MOVL $0,AX\nADDL ret0+0(FP),AX\nMOVL AX,ret0+0(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			width, write, known := X86FPAccessBytes(file.Funcs[0].Instrs[2], 0, arch)
+			if width != 4 || write || !known {
+				t.Fatal("registered ADDL read lost its native width", width, write, known)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("pure native-width observation granted uninitialized result bytes", err)
+			}
+		})
+	}
+}
+
+func TestX86FPAccessBytesScalarIdentityClosed(t *testing.T) {
+	// Actual original assembler rejection is distinct from constructed API
+	// mutations. Neither can borrow the generic source-stack suffix fallback.
+	goAssemblerOracleOutput(t, "amd64", "TEXT ·probe(SB),4,$0-8\nMOVQ.Z a+0(FP),AX\nRET\n", "", false)
+	file, err := Parse(ArchAMD64, "TEXT ·probe(SB),4,$0-8\nMOVQ a+0(FP),AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, opcode := range []Op{"MOVQ.Z", "movq", " MOVQ"} {
+		ins := file.Funcs[0].Instrs[1]
+		ins.Op = opcode
+		ins.Args = append([]Operand(nil), ins.Args...)
+		ins.Args[1].Reg = "BAD"
+		if width, _, known := X86FPAccessBytes(ins, 0, "amd64"); known || width != 0 {
+			t.Fatalf("constructed scalar identity %q inferred width %d/%v", opcode, width, known)
+		}
+	}
+}
+
+func TestX86FPAliasThreeAPIsFiveObjects(t *testing.T) {
+	for _, target := range []struct{ arch, triple, op, typ string }{
+		{"amd64", "x86_64-apple-darwin", "MOVQ", "uint64"},
+		{"amd64", "x86_64-unknown-linux-gnu", "MOVQ", "uint64"},
+		{"amd64", "x86_64-pc-windows-msvc", "MOVQ", "uint64"},
+		{"386", "i386-unknown-linux-gnu", "MOVL", "uint32"},
+		{"386", "i686-pc-windows-msvc", "MOVL", "uint32"},
+	} {
+		for _, shape := range []string{"scalar", "slice", "array"} {
+			t.Run(target.triple+"/"+shape, func(t *testing.T) {
+				declaration := "func Value(x,y " + target.typ + ") " + target.typ
+				if shape == "slice" {
+					declaration = "func Value(x []" + target.typ + ") " + target.typ
+				} else if shape == "array" {
+					declaration = "func Value(x [2]" + target.typ + ") " + target.typ
+				}
+				fset := token.NewFileSet()
+				syntax, err := parser.ParseFile(fset, "alias.go", "package alias\n"+declaration+"\n", 0)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sizes := types.SizesFor("gc", target.arch)
+				typed, err := (&types.Config{Sizes: sizes}).Check("alias", fset, []*ast.File{syntax}, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig, err := DeriveGoFuncABI0Signature("Value", typed.Scope().Lookup("Value").(*types.Func), target.arch, sizes)
+				if err != nil {
+					t.Fatal(err)
+				}
+				word := sizes.Sizeof(types.Typ[types.Uintptr])
+				result := sig.Frame.Results[0].Offset
+				alias := "x"
+				if shape == "array" {
+					alias = "x_0"
+				}
+				source := fmt.Sprintf("TEXT Value(SB),4,$0-%d\n%s %s+%d(FP),AX\n%s AX,ret+%d(FP)\nRET\n", result+word, target.op, alias, word, target.op, result)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig}}
+				ir, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc required")
+				}
+				compileLLVMToObject(t, llc, target.triple, "alias-text.ll", "alias-text.o", ir)
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "alias-module.ll", "alias-module.o", module.String())
+				pkg := GoPackage{Path: "alias", Types: typed, Syntax: []*ast.File{syntax}}
+				resultModule, err := translateGoModuleInContext(ctx, pkg, []byte(strings.Replace(source, "Value(SB)", "·Value(SB)", 1)), GoModuleOptions{GOARCH: target.arch, Sizes: sizes, TargetTriple: target.triple})
+				if resultModule != nil && !resultModule.Module.IsNil() {
+					defer resultModule.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "alias-go-module.ll", "alias-go-module.o", resultModule.Module.String())
+			})
+		}
+	}
+}
diff --git a/x86_fp_access_identity_test.go b/x86_fp_access_identity_test.go
new file mode 100644
index 000000000..79d96af04
--- /dev/null
+++ b/x86_fp_access_identity_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86FPAccessBytesCompleteSourceIdentity(t *testing.T) {
+	for _, opcode := range []string{
+		"MOVB", "MOVW", "MOVL", "MOVQ",
+		"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD",
+		"MOVSS", "MOVSD", "VMOVSS", "VMOVSD",
+	} {
+		register := "AX"
+		if opcode == "MOVB" {
+			register = "AL"
+		} else if len(opcode) > 4 || opcode == "MOVO" {
+			register = "X0"
+		}
+		canonical := "TEXT ·probe(SB),4,$0-64\n" + opcode + " value+0(FP)," + register + "\nRET\n"
+		file, err := Parse(ArchAMD64, canonical)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, modified := range []string{opcode + ".BAD", strings.ToLower(opcode)} {
+			t.Run(modified, func(t *testing.T) {
+				// These are actual original assembler failures, not inferred
+				// rejection from a framework which omits old SDK execution.
+				source := strings.Replace(canonical, "\n"+opcode+" ", "\n"+modified+" ", 1)
+				goAssemblerOracleOutput(t, "amd64", source, "", false)
+				ins := file.Funcs[0].Instrs[1]
+				ins.Op = Op(modified) // explicit constructed API mutation
+				if width, _, known := X86FPAccessBytes(ins, 0, "amd64"); known || width != 0 {
+					t.Fatalf("unclosed original source identity %q inferred %d/%v", modified, width, known)
+				}
+			})
+		}
+	}
+}
+
+func TestX86FPAccessBytesCompleteGPSIMDMemoryRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+			for _, row := range []struct {
+				name, source string
+				index        int
+				write        bool
+			}{
+				{"load", op + " value+0(FP),X0", 0, false},
+				{"store", op + " X0,value+0(FP)", 1, true},
+			} {
+				t.Run(arch+"/"+row.name+"/"+op, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-64\n" + row.source + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					form, known, err := x86GPSIMDTransferProperties(ins, arch)
+					if !known || err != nil || form.memory != row.index {
+						t.Fatalf("official GP/X memory row not modeled: form=%+v known=%t err=%v", form, known, err)
+					}
+					width, write, known := X86FPAccessBytes(ins, row.index, arch)
+					if !known || write != row.write || width != int64(form.bits/8) {
+						t.Fatalf("FP access differs from GP/X row: width=%d write=%t known=%t form=%+v", width, write, known, form)
+					}
+					wantWidth := int64(8)
+					if op == "MOVL" || op == "VMOVD" {
+						wantWidth = 4
+					}
+					if width != wantWidth {
+						t.Fatalf("native width=%d, want independently selected %d", width, wantWidth)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FPAccessBytesCompleteMMXMemoryRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD"} {
+			wantWidth := int64(8)
+			if op == "MOVL" {
+				wantWidth = 4
+			}
+			for register := 0; register < 8; register++ {
+				bank := fmt.Sprintf("M%d", register)
+				for _, row := range []struct {
+					name, source string
+					index        int
+					write        bool
+				}{
+					{"load", op + " value+0(FP)," + bank, 0, false},
+					{"store", op + " " + bank + ",value+0(FP)", 1, true},
+				} {
+					t.Run(arch+"/"+op+"/"+bank+"/"+row.name, func(t *testing.T) {
+						source := "TEXT ·Value(SB),4,$0-64\n" + row.source + "\nRET\n"
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						width, write, known := X86FPAccessBytes(ins, row.index, arch)
+						if !known || write != row.write || width != wantWidth {
+							t.Fatalf("official MMX memory row is not observed: width=%d write=%t known=%t", width, write, known)
+						}
+						if width, write, known := X86FPAccessBytes(ins, 1-row.index, arch); known || width != 0 || write {
+							t.Fatal("register acquired an FP access", width, write, known)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_fp_alias_runtime_test.go b/x86_fp_alias_runtime_test.go
new file mode 100644
index 000000000..7409db95e
--- /dev/null
+++ b/x86_fp_alias_runtime_test.go
@@ -0,0 +1,94 @@
+//go:build amd64 || (darwin && arm64)
+
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86FPAliasInitializedLLVMCanary(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	fset := token.NewFileSet()
+	syntax, err := parser.ParseFile(fset, "alias.go", "package alias\nfunc Value(x,y uint64) uint64\n", 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sizes := types.SizesFor("gc", "amd64")
+	typed, err := (&types.Config{Sizes: sizes}).Check("alias", fset, []*ast.File{syntax}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := DeriveGoFuncABI0Signature("Value", typed.Scope().Lookup("Value").(*types.Func), "amd64", sizes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := "TEXT Value(SB),4,$0-24\nMOVQ x+8(FP),AX\nMOVQ AX,y+16(FP)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{"Value": sig}}
+	ir, err := Translate(file, options)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	goModule, err := translateGoModuleInContext(ctx, GoPackage{Path: "alias", Types: typed, Syntax: []*ast.File{syntax}},
+		[]byte(strings.Replace(source, "Value(SB)", "·Value(SB)", 1)), GoModuleOptions{GOARCH: "amd64", Sizes: sizes, TargetTriple: triple})
+	if goModule != nil && !goModule.Module.IsNil() {
+		defer goModule.Module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(goModule.Functions) != 1 || goModule.Functions[0].TextSymbol != "·Value" {
+		t.Fatalf("actual typed module symbol mapping missing: %#v", goModule.Functions)
+	}
+	for _, row := range []struct{ name, ir, symbol string }{
+		{"text", ir, "Value"}, {"module", module.String(), "Value"}, {"go-module", goModule.Module.String(), goModule.Functions[0].ResolvedSymbol},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			main := `#include <stdint.h>
+#include <stdio.h>
+extern uint64_t invoke(uint64_t,uint64_t) __asm__("SYMBOL");
+int main(void) {
+    static const uint64_t values[] = {0,1,UINT64_C(0x8000000000000000),UINT64_MAX};
+    volatile struct { uint64_t before,x,y,after; } inputs;
+    for (unsigned i=0;i<4;i++) for (unsigned j=0;j<4;j++) {
+        inputs.before=UINT64_C(0x3141592653589793);
+        inputs.x=values[i]; inputs.y=values[j];
+        inputs.after=UINT64_C(0x2718281828459045);
+        uint64_t result=invoke(inputs.x,inputs.y);
+        if (result!=values[j] || inputs.x!=values[i] || inputs.y!=values[j] ||
+            inputs.before!=UINT64_C(0x3141592653589793) || inputs.after!=UINT64_C(0x2718281828459045)) {
+            fprintf(stderr,"alias/canary failed %u/%u\n",i,j); return 1;
+        }
+    }
+    return 0;
+}
+`
+			symbol := row.symbol
+			if strings.Contains(triple, "apple") {
+				symbol = "_" + symbol // Mach-O's actual external C symbol prefix.
+			}
+			main = strings.Replace(main, "SYMBOL", symbol, 1)
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "fp-alias-"+row.name, triple, row.ir, main, prefix)
+		})
+	}
+}
diff --git a/x86_fp_broadcast_access_test.go b/x86_fp_broadcast_access_test.go
new file mode 100644
index 000000000..105f3cbe3
--- /dev/null
+++ b/x86_fp_broadcast_access_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86FPAccessBytesBroadcastCompleteGoForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			type expected struct {
+				instruction string
+				width       int64
+			}
+			var rows []expected
+			// This independent test directory is checked against every original
+			// Go broadcast opcode/table, not derived from the production grammar.
+			for _, spec := range x86BroadcastTestDirectory {
+				if spec.source == "K" {
+					continue // Mask-data forms have no FP/memory row; reject below.
+				}
+				for _, bank := range spec.destinations {
+					for _, masking := range []string{"", "K1,", "K7,"} {
+						if strings.HasSuffix(spec.name, "128") && masking != "" {
+							continue
+						}
+						op := spec.name
+						if masking == "K7," {
+							op += ".Z"
+						}
+						instruction := fmt.Sprintf("%s a+0(FP),%s%c7", op, masking, bank)
+						fmt.Fprintf(&source, "TEXT form%d(SB),4,$0-32\n%s\nRET\n", len(rows), instruction)
+						rows = append(rows, expected{instruction, int64(spec.bytes)})
+					}
+				}
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, fn := range file.Funcs {
+				ins := fn.Instrs[1]
+				width, write, known := X86FPAccessBytes(ins, 0, arch)
+				if !known || write || width != rows[index].width {
+					t.Errorf("%s = %d/%t/%t, want %d/false/true", rows[index].instruction, width, write, known, rows[index].width)
+				}
+				for operand := 1; operand < len(ins.Args); operand++ {
+					if width, write, known := X86FPAccessBytes(ins, operand, arch); known || write || width != 0 {
+						t.Fatal("vector/mask acquired FP byte ownership", ins.Raw, operand)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86FPAccessBytesBroadcastRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{
+			"VPBROADCASTMB2Q a+0(FP),X0", "VPBROADCASTMW2D a+0(FP),Y0",
+			"VPBROADCASTQ a+0(FP),AX", "VPBROADCASTQ X0,a+0(FP)",
+			"VPBROADCASTQ.Z a+0(FP),Y0", "VPBROADCASTQ a+0(FP),K0,Y0",
+			"VBROADCASTSD a+0(FP),X0", "VBROADCASTF128 a+0(FP),X0",
+			"VBROADCASTI128 a+0(FP),K1,Y0", "VBROADCASTF32X8 a+0(FP),Y0",
+		} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-32\n" + row + "\nRET\n"
+				if row == "VPBROADCASTQ.Z a+0(FP),Y0" {
+					x86FPBroadcastReservedZeroMaskGoObservation(t, arch, source)
+				} else {
+					goAssemblerOracleOutput(t, arch, source, "", false)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				for index := range ins.Args {
+					if width, write, known := X86FPAccessBytes(ins, index, arch); known || write || width != 0 {
+						t.Fatal("invalid broadcast acquired FP bytes", width, write, known)
+					}
+				}
+			})
+		}
+	}
+}
+
+// Go 1.20 emitted EVEX.z=1/aaa=0 for this unchanged source. Current Go
+// diagnoses the absent mask (issue 57952). Neither outcome grants FP bytes:
+// record the actual rejected source or accepted reserved bytes, never execute.
+func x86FPBroadcastReservedZeroMaskGoObservation(t *testing.T, arch, source string) {
+	t.Helper()
+	x86BroadcastReservedZeroMaskGoObservation(t, arch, source, []byte{0x62, 0xf2, 0xfd, 0xa8, 0x59}, false)
+}
+
+func x86BroadcastReservedZeroMaskGoObservation(t *testing.T, arch, source string, expected []byte, exact bool) {
+	t.Helper()
+	directory := t.TempDir()
+	assembly, object := filepath.Join(directory, "reserved.s"), filepath.Join(directory, "reserved.o")
+	if err := os.WriteFile(assembly, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-o", object, assembly)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(assembly, object, output, err, ctx.Err(), err == nil, arch); failure != nil {
+		t.Fatal("unbound original zero-mask outcome", failure)
+	}
+	if err != nil {
+		if !bytes.Contains(output, []byte("mask register must be specified for .Z instructions")) {
+			t.Fatalf("unknown original zero-mask rejection: %s", output)
+		}
+		return
+	}
+	code := assembleX87ControlBytes(t, arch, source)
+	if len(code) == 0 || !bytes.HasPrefix(code, expected) || code[len(code)-1] != 0xc3 || exact && !bytes.Equal(code, expected) {
+		t.Fatalf("accepted original reserved broadcast bytes changed: %x", code)
+	}
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	if _, _, known, err := decodedX86VEXPackedBroadcastInstruction(code, mode); !known || err == nil {
+		t.Fatal("reserved original EVEX bytes acquired semantics", known, err)
+	}
+	t.Logf("ORIGINAL_RESERVED_BROADCAST_OBJECT arch=%s code=%x; not executed or admitted", arch, code)
+}
diff --git a/x86_fp_compare_access_test.go b/x86_fp_compare_access_test.go
new file mode 100644
index 000000000..fca142c80
--- /dev/null
+++ b/x86_fp_compare_access_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Keep this FP consumer on the same complete ycmpb/ycmpl/yxorb/ytestl
+// grammar as lowering, including both memory directions and immediate classes.
+func TestX86FPAccessBytesScalarCompareCompleteForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{"CMP", "TEST"} {
+			for _, suffix := range []string{"B", "W", "L", "Q"} {
+				if arch == "386" && suffix == "Q" {
+					continue // Go's Q rows are independently rejected below.
+				}
+				t.Run(arch+"/"+stem+suffix, func(t *testing.T) {
+					op := stem + suffix
+					rows := []string{"a+0(FP),AX", "AX,a+0(FP)"}
+					for _, immediate := range []string{"0", "127", "128", "-128", "-129", "65535", "2147483648", "4294967295"} {
+						row := "a+0(FP),$" + immediate
+						if stem == "TEST" {
+							row = "$" + immediate + ",a+0(FP)"
+						}
+						rows = append(rows, row)
+					}
+					var source strings.Builder
+					for index, row := range rows {
+						fmt.Fprintf(&source, "TEXT form%d(SB),4,$0-8\n%s %s\nRET\n", index, op, row)
+					}
+					goAssemblerOracleOutput(t, arch, source.String(), "", true)
+					file, err := Parse(ArchAMD64, source.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, fn := range file.Funcs {
+						ins := fn.Instrs[1]
+						before := append([]Operand(nil), ins.Args...)
+						for index, operand := range ins.Args {
+							width, write, known := X86FPAccessBytes(ins, index, arch)
+							want := map[string]int64{"B": 1, "W": 2, "L": 4, "Q": 8}[suffix]
+							if operand.Kind != OpFP {
+								if known || write || width != 0 {
+									t.Fatal("non-FP operand acquired a byte span", ins.Raw, index)
+								}
+							} else if !known || write || width != want {
+								t.Errorf("%s operand %d = %d/%t/%t, want %d/false/true", ins.Raw, index, width, write, known, want)
+							}
+						}
+						if !reflect.DeepEqual(before, ins.Args) {
+							t.Fatal("byte observation changed original operands")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86FPAccessBytesScalarCompareRejectedForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := []string{"CMPB a+0(FP),X0", "TESTL a+0(FP),$1", "CMPL $1,a+0(FP)",
+			"CMPL a+0(FP),b+4(FP)", "TESTW a+0(FP),X0", "CMPW a+0(FP)", "CMPL a+0(FP),AX,CX"}
+		if arch == "386" {
+			rows = append(rows, "CMPQ a+0(FP),AX", "TESTQ AX,a+0(FP)", "CMPL a+0(FP),R8")
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-8\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				for index := range ins.Args {
+					if width, write, known := X86FPAccessBytes(ins, index, arch); known || write || width != 0 {
+						t.Fatal("rejected original compare acquired a byte span", width, write, known)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86FPCompareWidthDoesNotInitializeResult(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, compare := range []string{"CMPL ret0+0(FP),$7", "TESTL $7,ret0+0(FP)"} {
+			t.Run(arch+"/"+compare, func(t *testing.T) {
+				body := compare + "\nMOVL $1,ret0+0(FP)\nRET"
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint32", body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for index, operand := range file.Funcs[0].Instrs[1].Args {
+					if operand.Kind != OpFP {
+						continue
+					}
+					width, write, known := X86FPAccessBytes(file.Funcs[0].Instrs[1], index, arch)
+					if !known || width != 4 || write {
+						t.Fatal("complete read lost its width", width, write, known)
+					}
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("read-only width observation initialized an unwritten result", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_fp_trap_shadow_test.go b/x86_fp_trap_shadow_test.go
new file mode 100644
index 000000000..fcc0e7b5f
--- /dev/null
+++ b/x86_fp_trap_shadow_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TrapOnlyLogicalFPShadowThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, move := range []struct {
+			name  string
+			width int
+		}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}} {
+			if target.arch == "386" && move.width == 8 {
+				continue // Go's GP qword row is mode64-only; X/m64 is separate.
+			}
+			for _, trap := range []string{"UNDEF", "UD2"} {
+				for _, graph := range []string{"linear", "two-trap-branches"} {
+					body := fmt.Sprintf("%s $17,x+0(FP)\n%s\nRET\n", move.name, trap)
+					if graph == "two-trap-branches" {
+						body = fmt.Sprintf("%s $17,x+0(FP)\nCMPL x+0(FP),$0\nJE second\n%s\nsecond:\n%s\nRET\n", move.name, trap, trap)
+					}
+					source := "TEXT ·value(SB),4,$0-16\n" + body
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+move.name+"/"+trap+"/"+graph+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func value(x uint64) uint64", target.arch, target.triple, api)
+							if err != nil || ir == "" || !strings.Contains(ir, `asm sideeffect "ud2"`) || !strings.Contains(ir, "unreachable") {
+								t.Fatal("complete trap-only logical shadow source did not retain its nonreturning fault", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86TrapOnlyLogicalShadowCannotAuthorizeReturningOrUnknownSource(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ name, declaration, body string }{
+			{"ordinary-return", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nMOVL $0,ret+8(FP)\nMOVL $0,ret+12(FP)\nRET"},
+			{"one-normal-path", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nCMPL x+0(FP),$0\nJE normal\nUD2\nnormal:\nMOVL $0,ret+8(FP)\nMOVL $0,ret+12(FP)\nRET"},
+			{"unknown-input", "func value(x uint64) uint64", "MOVB AX,x+0(FP)\nUD2\nRET"},
+			{"pointer", "func value(x *byte) uint64", "MOVB $17,x+0(FP)\nUD2\nRET"},
+			{"bool-cross-field-byte-view", "func value(x bool,y byte) uint64", "MOVW $0x1102,x+0(FP)\nUD2\nRET"},
+			{"padding", "func value(x byte,y uint64) uint64", "MOVW $17,x+0(FP)\nUD2\nRET"},
+			{"native-store", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nMOVB $1,(AX)\nUD2\nRET"},
+			{"unknown-dead-effect", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nUD2\nMOVB (AX),BX\nRET"},
+			{"CALL", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nCALL unbound(SB)\nUD2\nRET"},
+			{"external-tail", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nJMP unbound(SB)\nUD2\nRET"},
+			{"cycle-only", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nagain:\nJMP again\nUD2\nRET"},
+			{"one-cyclic-path", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nCMPL x+0(FP),$0\nJE again\nUD2\nagain:\nJMP again\nRET"},
+			{"one-falloff-path", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nCMPL x+0(FP),$0\nJE outside\nUD2\noutside:\nNOP"},
+			{"raw-trap", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nBYTE $0x0f\nBYTE $0x0b\nRET"},
+			{"malformed-trap", "func value(x uint64) uint64", "MOVB $17,x+0(FP)\nUD2 AX\nRET"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·value(SB),4,$0-32\n"+row.body+"\n", row.declaration, arch, testTargetTriple("linux", arch), api)
+					if err == nil || ir != "" {
+						t.Fatalf("trap syntax authorized a returning/unknown/source-native role: %v, IR bytes=%d", err, len(ir))
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86TrapOnlyFPShadowOriginalGoForms(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			count := 0
+			for _, move := range []string{"MOVB", "MOVW", "MOVL", "MOVQ"} {
+				if move == "MOVQ" && target.arch == "386" {
+					continue
+				}
+				for _, trap := range []string{"UNDEF", "UD2"} {
+					fmt.Fprintf(&source, "TEXT ·trap%d(SB),4,$0-16\n%s $17,x+0(FP)\n%s\nRET\n", count, move, trap)
+					count++
+					fmt.Fprintf(&source, "TEXT ·trap%d(SB),4,$0-16\n%s $17,x+0(FP)\nCMPL x+0(FP),$0\nJE second%d\n%s\nsecond%d:\n%s\nRET\n", count, move, count, trap, count, trap)
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("actual Go accepts all %d complete trap-only forms, including CMP operand order; object-only, not executed", count)
+		})
+	}
+}
+
+func TestX86TrapOnlyCFGRequiresEveryReachableSuccessor(t *testing.T) {
+	for _, row := range []struct {
+		name         string
+		instructions []Instr
+		edges        [][]int
+		reachable    []int
+		valid        bool
+	}{
+		{"linear", []Instr{{Op: "NOP"}, {Op: "UD2"}, {Op: OpRET}}, [][]int{{1}, nil, nil}, []int{0, 1}, true},
+		{"two-traps", []Instr{{Op: "JE"}, {Op: "UD2"}, {Op: "UNDEF"}}, [][]int{{1, 2}, nil, nil}, []int{0, 1, 2}, true},
+		{"one-cycle", []Instr{{Op: "JE"}, {Op: OpJMP}, {Op: "UD2"}}, [][]int{{1, 2}, {1}, nil}, []int{0, 1, 2}, false},
+		{"one-return", []Instr{{Op: "JE"}, {Op: OpRET}, {Op: "UD2"}}, [][]int{{1, 2}, nil, nil}, []int{0, 1, 2}, false},
+		{"nontrap-leaf", []Instr{{Op: "NOP"}}, [][]int{nil}, []int{0}, false},
+		{"invalid-trap", []Instr{{Op: "UD2", Args: []Operand{{Kind: OpReg, Reg: AX}}}}, [][]int{nil}, []int{0}, false},
+	} {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				states := make(map[int]x86ResultState)
+				for _, pc := range row.reachable {
+					states[pc] = x86ResultState{}
+				}
+				if got := x86ResultAllPathsTerminateInTrap(row.instructions, row.edges, states, arch); got != row.valid {
+					t.Fatalf("all-successor termination differs: got %t want %t", got, row.valid)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_fpmov_native_store_contract_test.go b/x86_fpmov_native_store_contract_test.go
new file mode 100644
index 000000000..6c5932401
--- /dev/null
+++ b/x86_fpmov_native_store_contract_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86FPMovNativeDwordStoreExactValueAndDestination(t *testing.T) {
+	for _, destination := range []string{"8(DI)", "example.i32(SB)"} {
+		t.Run(destination, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT native(SB),$0-0\nMOVL AX,"+destination+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			consumer, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Name: "native", Ret: Void}, nil)
+			consumer.goarch, consumer.targetTriple = "amd64", "x86_64-unknown-linux-gnu"
+			if err := consumer.storeReg(AX, "81985529216486895"); err != nil {
+				t.Fatal(err)
+			}
+			if destination == "8(DI)" {
+				if err := consumer.storeReg(DI, "4096"); err != nil {
+					t.Fatal(err)
+				}
+			}
+			before := output.Len()
+			instruction := file.Funcs[0].Instrs[1]
+			known, terminated, err := consumer.lowerMov(instruction.Op, instruction)
+			if !known || terminated || err != nil {
+				t.Fatal("original native MOVL store was not lowered", err)
+			}
+			fragment := output.String()[before:]
+			source := regexp.MustCompile(`(?m)^  (%[A-Za-z0-9_]+) = load i64, ptr ` + regexp.QuoteMeta(consumer.regSlot[AX]) + `$`).FindStringSubmatch(fragment)
+			if source == nil {
+				t.Fatal("native store lost its actual AX value", fragment)
+			}
+			value := regexp.MustCompile(`(?m)^  (%[A-Za-z0-9_]+) = trunc i64 ` + regexp.QuoteMeta(source[1]) + ` to i32$`).FindStringSubmatch(fragment)
+			if value == nil {
+				t.Fatal("native MOVL store lost its low-dword value", fragment)
+			}
+			pointer := `@"example.i32"`
+			if destination == "8(DI)" {
+				base := regexp.MustCompile(`(?m)^  (%[A-Za-z0-9_]+) = load i64, ptr ` + regexp.QuoteMeta(consumer.regSlot[DI]) + `$`).FindStringSubmatch(fragment)
+				if base == nil {
+					t.Fatal("native store lost its DI address", fragment)
+				}
+				offset := regexp.MustCompile(`(?m)^  (%[A-Za-z0-9_]+) = add i64 ` + regexp.QuoteMeta(base[1]) + `, 8$`).FindStringSubmatch(fragment)
+				if offset == nil {
+					t.Fatal("native store changed its eight-byte displacement", fragment)
+				}
+				address := regexp.MustCompile(`(?m)^  (%[A-Za-z0-9_]+) = inttoptr i64 ` + regexp.QuoteMeta(offset[1]) + ` to ptr$`).FindStringSubmatch(fragment)
+				if address == nil {
+					t.Fatal("native store lost its computed destination", fragment)
+				}
+				pointer = address[1]
+			}
+			want := "  store volatile i32 " + value[1] + ", ptr " + pointer + ", align 1\n"
+			if strings.Count(fragment, "  store ") != 1 || !strings.HasSuffix(fragment, want) {
+				t.Fatal("native store lost its exact value, destination, width, volatility or unaligned effect", fragment)
+			}
+		})
+	}
+}
diff --git a/x86_go_imported_tail_test.go b/x86_go_imported_tail_test.go
new file mode 100644
index 000000000..976b9e64b
--- /dev/null
+++ b/x86_go_imported_tail_test.go
@@ -0,0 +1,533 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/importer"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const importedTailDeclarations = `package tail
+import "syscall"
+func Forward(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
+func Forward6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
+`
+
+func importedTailPackage(t *testing.T, arch string) GoPackage {
+	return importedTailPackageSource(t, arch, importedTailDeclarations)
+}
+
+func importedTailPackageSource(t *testing.T, arch, source string) GoPackage {
+	t.Helper()
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "value.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	actualImports := importer.ForCompiler(fset, "gc", func(path string) (io.ReadCloser, error) {
+		ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+		defer cancel()
+		command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), "list", "-p=1", "-export", "-f={{.Export}}", path)
+		command.Env = append(os.Environ(), "GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOPROXY=off", "CGO_ENABLED=0", "GOOS=linux", "GOARCH="+arch)
+		output, err := command.Output()
+		if err != nil {
+			return nil, fmt.Errorf("actual target SDK export %s: %w", path, err)
+		}
+		return os.Open(strings.TrimSpace(string(output)))
+	})
+	typed, err := (&types.Config{Importer: actualImports, Sizes: types.SizesFor("gc", arch)}).Check("example.com/tail", fset, []*ast.File{file}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	imports := make(map[string]*types.Package)
+	for _, dependency := range typed.Imports() {
+		imports[dependency.Path()] = dependency
+	}
+	dependency, err := parser.ParseFile(fset, filepath.Join(runtime.GOROOT(), "src/syscall/syscall_linux.go"), nil, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: typed.Path(), Types: typed, Syntax: []*ast.File{file}, Imports: imports,
+		ImportSyntax: map[string][]*ast.File{"syscall": {dependency}}}
+}
+
+func importedTailAssembly(arch, target string) string {
+	width := 8
+	if arch == "386" {
+		width = 4
+	}
+	return fmt.Sprintf("TEXT ·Forward(SB),4,$0-%d\nJMP syscall·%s(SB)\nTEXT ·Forward6(SB),4,$0-%d\nJMP syscall·%s6(SB)\n", 7*width, target, 10*width, target)
+}
+
+func TestX86GoImportedTailOriginalGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, target := range []string{"Syscall", "RawSyscall"} {
+			t.Run(arch+"/"+target, func(t *testing.T) {
+				directory := t.TempDir()
+				files := map[string]string{
+					"go.mod":                 "module example.com/tail\n\ngo 1.20\n",
+					"value.go":               importedTailDeclarations,
+					"forward_" + arch + ".s": importedTailAssembly(arch, target),
+					"cmd/main.go": `package main
+import ("example.com/tail"; "syscall")
+func main() {
+  pid, _, errno := tail.Forward(syscall.SYS_GETPID,0,0,0)
+  if errno != 0 || pid == 0 || pid != uintptr(syscall.Getpid()) { panic("pid") }
+  result, _, errno := tail.Forward(^uintptr(0),0,0,0)
+  if result != ^uintptr(0) || errno != syscall.ENOSYS { panic("errno") }
+  pid, _, errno = tail.Forward6(syscall.SYS_GETPID,0,0,0,0,0,0)
+  if errno != 0 || pid != uintptr(syscall.Getpid()) { panic("six") }
+}
+`,
+				}
+				for name, source := range files {
+					path := filepath.Join(directory, name)
+					if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(path, []byte(source), 0o600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+				defer cancel()
+				command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), "build", "-p=1", "-mod=readonly", "-o", filepath.Join(directory, "original"), "./cmd")
+				command.Dir = directory
+				command.Env = append(os.Environ(), "GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=", "GOPROXY=off", "CGO_ENABLED=0", "GOOS=linux", "GOARCH="+arch)
+				if output, err := command.CombinedOutput(); err != nil {
+					t.Fatalf("original full package/ELF link: %v\n%s", err, output)
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoImportedTailPublicModule(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, target := range []string{"Syscall", "RawSyscall"} {
+			t.Run(arch+"/"+target, func(t *testing.T) {
+				triple, word := "x86_64-unknown-linux-gnu", "i64"
+				if arch == "386" {
+					triple, word = "i386-unknown-linux-gnu", "i32"
+				}
+				pkg := importedTailPackage(t, arch)
+				tr, err := TranslateGoModule(pkg, []byte(importedTailAssembly(arch, target)), GoModuleOptions{GOOS: "linux", GOARCH: arch, TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path)})
+				if err != nil {
+					t.Fatal("actual declared SDK tail:", err)
+				}
+				defer tr.Module.Dispose()
+				ir := tr.Module.String()
+				for _, entry := range []struct{ root, callee string }{{"Forward", target}, {"Forward6", target + "6"}} {
+					function := tr.Module.NamedFunction(pkg.Path + "." + entry.root)
+					calls := 0
+					for _, block := range function.BasicBlocks() {
+						for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+							if instruction.InstructionOpcode() == llvm.Call {
+								calls++
+								if instruction.CalledValue().Name() != "syscall."+entry.callee || instruction.Type().String() != "{ "+word+", "+word+", "+word+" }" {
+									t.Fatal("lost exact typed imported scalar tuple call", instruction.String())
+								}
+							}
+						}
+					}
+					if calls != 1 {
+						t.Fatalf("%s has %d calls, want its single exact imported tail", entry.root, calls)
+					}
+				}
+				path := filepath.Join(t.TempDir(), "tail.ll")
+				if err := os.WriteFile(path, []byte(ir), 0o600); err != nil {
+					t.Fatal(err)
+				}
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc is required")
+				}
+				for _, level := range []string{"0", "2"} {
+					ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+					command := exec.CommandContext(ctx, llc, "-O="+level, "-filetype=obj", path, "-o", path+level+".o")
+					output, err := command.CombinedOutput()
+					cancel()
+					if err != nil {
+						t.Fatalf("LLVM22 O%s object: %v\n%s", level, err, output)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86GoImportedTailSignatureCollectionKeepsIndependentConsumers(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg := importedTailPackageSource(t, arch, importedTailDeclarations+`
+func Boolean(x bool) bool
+func Numeric(x uint32) uint32
+`)
+			// One real imported numerical tail must not make unrelated assembly
+			// aliases require imports during declaration collection. Their actual
+			// consumers still validate the callee independently before translation.
+			source := importedTailAssembly(arch, "Syscall") + `
+TEXT ·Boolean(SB),4,$0
+JMP outside·boolean(SB)
+TEXT ·Numeric(SB),4,$0
+JMP outside·numeric(SB)
+`
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs, err := goSigsForAsmFile(pkg, file, testResolveSym(pkg.Path), arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal("unrelated alias stole declaration collection", err)
+			}
+			if !sigs["outside.boolean"].x86BorrowedBoolTail {
+				t.Fatal("unresolved bool alias lost its copied-caller denial")
+			}
+			if _, found := sigs["syscall.Syscall"]; !found {
+				t.Fatal("actual selected imported declaration was not collected")
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: arch, TargetTriple: triple, ResolveSym: testResolveSym(pkg.Path)})
+			if translated != nil {
+				translated.Module.Dispose()
+			}
+			if translated != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unresolved alias acquired its caller's declaration", err)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailBoolInputCannotBypassSelectedImport(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg := mustGoPackage(t, "tailinput", "package tailinput\nfunc Forward(flag bool) uint32\n")
+			source := []byte("TEXT ·Forward(SB),4,$0\nJMP outside·target(SB)\n")
+			file, err := Parse(ArchAMD64, string(source))
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := testResolveSym(pkg.Path)
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal("source-only alias declaration collection", err)
+			}
+			if sigs["outside.target"].Ret != I32 || sigs["outside.target"].x86BorrowedBoolTail {
+				t.Fatal("fixture must reach the numerical-result consumer")
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			translated, err := TranslateGoModule(pkg, source, GoModuleOptions{
+				GOOS: "linux", GOARCH: arch, TargetTriple: triple, ResolveSym: resolve})
+			if translated != nil {
+				translated.Module.Dispose()
+			}
+			if translated != nil || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "complete selected typed import") {
+				t.Fatal("bool input bypassed the independent numerical tail declaration", err)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailResolverCannotEraseSourceBeforeCapture(t *testing.T) {
+	for at := 1; at <= 12; at++ {
+		t.Run(fmt.Sprint(at), func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Forward(SB),4,$0\nJMP outside·target(SB)\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "callbacktail", "package callbacktail\nfunc Forward()\n")
+			resolve := testResolveSym(pkg.Path)
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			calls := 0
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: sigs}
+			options.ResolveSym = func(symbol string) string {
+				calls++
+				if calls == at {
+					file.Funcs[0].Instrs[1] = Instr{Op: OpRET, Raw: "RET"}
+				}
+				return resolve(symbol)
+			}
+			prepared, err := PrepareX86DirectTailSource(file, options)
+			if prepared != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("resolver erased the undeclared terminal before source capture", calls, err)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailShapeGuards(t *testing.T) {
+	for _, row := range []struct{ name, old, replacement string }{
+		{"parameter", "trap, a1, a2, a3 uintptr", "trap, a1, a2, a3 uint32"},
+		{"result", "r1, r2 uintptr", "r1, r2 uint32"},
+		{"arity", "trap, a1, a2, a3 uintptr", "trap, a1, a2 uintptr"},
+		{"native caller", "func Forward(", "//llgo:stdcall\nfunc Forward("},
+		{"caller body", "err syscall.Errno)\nfunc Forward6", "err syscall.Errno) { return }\nfunc Forward6"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg := importedTailPackageSource(t, "amd64", strings.Replace(importedTailDeclarations, row.old, row.replacement, 1))
+			translated, err := TranslateGoModule(pkg, []byte(importedTailAssembly("amd64", "Syscall")), GoModuleOptions{
+				GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)})
+			if translated != nil {
+				translated.Module.Dispose()
+			}
+			if err == nil {
+				t.Fatal("nonidentical or native Go tail shape accepted")
+			}
+		})
+	}
+	for _, row := range []struct{ name, old, replacement string }{
+		{"frame", "$0-56", "$8-56"},
+		{"arguments small", "$0-56", "$0-48"},
+		{"arguments large", "$0-56", "$0-64"},
+		{"offset", "syscall·Syscall(SB)", "syscall·Syscall+1(SB)"},
+		{"unknown", "syscall·Syscall(SB)", "syscall·Unknown(SB)"},
+		{"side effect", "JMP syscall·Syscall(SB)", "ADDQ $1, AX\nJMP syscall·Syscall(SB)"},
+		{"native target", "syscall·Syscall(SB)", "syscall·Syscall<ABIInternal>(SB)"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			pkg := importedTailPackage(t, "amd64")
+			source := strings.Replace(importedTailAssembly("amd64", "Syscall"), row.old, row.replacement, 1)
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)})
+			if translated != nil {
+				translated.Module.Dispose()
+			}
+			if err == nil {
+				t.Fatal("unclosed source tail accepted")
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailSourceGuards(t *testing.T) {
+	for _, name := range []string{"missing syntax", "missing import", "wrong import identity", "native package", "native declaration", "renamed declaration", "manual target", "manual caller"} {
+		t.Run(name, func(t *testing.T) {
+			pkg := importedTailPackage(t, "amd64")
+			options := GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)}
+			switch name {
+			case "missing syntax":
+				pkg.ImportSyntax = nil
+			case "missing import":
+				pkg.Imports = nil
+			case "wrong import identity":
+				pkg.Imports["syscall"] = types.NewPackage("syscall", "syscall")
+			case "native package":
+				defer pkg.Imports["syscall"].SetName(pkg.Imports["syscall"].Name())
+				pkg.Imports["syscall"].SetName("C")
+			case "native declaration", "renamed declaration":
+				for _, node := range pkg.ImportSyntax["syscall"][0].Decls {
+					if declaration, ok := node.(*ast.FuncDecl); ok && declaration.Name.Name == "Syscall" {
+						text := "//llgo:cdecl"
+						if name == "renamed declaration" {
+							text = "//go:linkname Syscall C.foo"
+						}
+						declaration.Doc = &ast.CommentGroup{List: []*ast.Comment{{Text: text}}}
+						// Parsed Go syntax records attached directives in both lists.
+						pkg.ImportSyntax["syscall"][0].Comments = append(pkg.ImportSyntax["syscall"][0].Comments, declaration.Doc)
+					}
+				}
+			case "manual target", "manual caller":
+				options.ManualSig = func(symbol string) (FuncSig, bool) {
+					wanted := "syscall.Syscall"
+					if name == "manual caller" {
+						wanted = pkg.Path + ".Forward"
+					}
+					return FuncSig{Name: symbol, Ret: I64}, symbol == wanted
+				}
+			}
+			translated, err := TranslateGoModule(pkg, []byte(importedTailAssembly("amd64", "Syscall")), options)
+			if translated != nil {
+				translated.Module.Dispose()
+			}
+			if err == nil {
+				t.Fatal("source role accepted", name)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailRawManualSignatures(t *testing.T) {
+	pkg := importedTailPackage(t, "amd64")
+	resolve := testResolveSym(pkg.Path)
+	file, err := Parse(ArchAMD64, importedTailAssembly("amd64", "Syscall"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: signatures})
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("manual signatures supplied actual Go declaration source: %v", err)
+	}
+}
+
+func TestX86GoImportedTailUnspecifiedTEXT(t *testing.T) {
+	pkg := importedTailPackage(t, "amd64")
+	source := strings.ReplaceAll(strings.ReplaceAll(importedTailAssembly("amd64", "Syscall"), "$0-56", "$0"), "$0-80", "$0")
+	translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+		GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)})
+	if err != nil {
+		t.Fatal("omitted TEXT metadata must obtain only its actual declared layout", err)
+	}
+	translated.Module.Dispose()
+}
+
+func TestX86GoImportedTailPreservesLocalGoTarget(t *testing.T) {
+	for _, target := range []string{"·scalar", "example.com∕tail·scalar"} {
+		t.Run(target, func(t *testing.T) {
+			pkg := importedTailPackageSource(t, "amd64", `package tail
+func Forward(x uintptr) uintptr
+func scalar(x uintptr) uintptr { return x + 1 }
+`)
+			source := "TEXT ·Forward(SB),4,$0-16\nJMP " + target + "(SB)\n"
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOOS: "linux", GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path)})
+			if err != nil {
+				t.Fatal("existing same-package Go tail regressed", err)
+			}
+			defer translated.Module.Dispose()
+			function := translated.Module.NamedFunction(pkg.Path + ".Forward")
+			calls := 0
+			for _, block := range function.BasicBlocks() {
+				for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+					if instruction.InstructionOpcode() == llvm.Call {
+						calls++
+						if instruction.CalledValue().Name() != pkg.Path+".scalar" || instruction.Type().String() != "i64" {
+							t.Fatal("same-package tail lost its actual Go signature", instruction.String())
+						}
+					}
+				}
+			}
+			if calls != 1 {
+				t.Fatalf("same-package tail has %d calls, want one", calls)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailSelectedDeclarationConsistency(t *testing.T) {
+	for _, role := range []string{"caller", "callee", "resolver mutation"} {
+		t.Run(role, func(t *testing.T) {
+			pkg := importedTailPackage(t, "amd64")
+			resolve := testResolveSym(pkg.Path)
+			wrongSource := "package syscall\nfunc Syscall() uintptr\nfunc Syscall6() uintptr\n"
+			if role == "caller" {
+				wrongSource = "package tail\nfunc Forward() uintptr\nfunc Forward6() uintptr\n"
+			}
+			wrong, err := parser.ParseFile(token.NewFileSet(), "changed.go", wrongSource, parser.ParseComments)
+			if err != nil {
+				t.Fatal(err)
+			}
+			mutate := func() {
+				if role == "caller" {
+					pkg.Syntax = []*ast.File{wrong}
+				} else {
+					pkg.ImportSyntax["syscall"] = []*ast.File{wrong}
+				}
+			}
+			file, err := Parse(ArchAMD64, importedTailAssembly("amd64", "Syscall"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: signatures, goPackage: &pkg}
+			if role == "resolver mutation" {
+				file, err = PrepareX86DirectTailSource(file, options)
+				if err != nil {
+					t.Fatal("valid initial selected declarations", err)
+				}
+				options.ResolveSym = func(symbol string) string {
+					mutate()
+					return resolve(symbol)
+				}
+			} else {
+				mutate()
+			}
+			_, err = Translate(file, options)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("selected declaration changed while typed objects stayed fixed: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailTargetSizedDeclaration(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			pkg := importedTailPackageSource(t, arch, `package tail
+import "unsafe"
+func Forward(x *[unsafe.Sizeof(uintptr(0))]byte) uintptr
+`)
+			sizes := types.SizesFor("gc", arch)
+			if _, err := goX86TailFunction(pkg, "Forward", true, sizes); err != nil {
+				t.Fatal("target-sized actual declaration rejected", err)
+			}
+			wrong := "8"
+			if arch == "amd64" {
+				wrong = "4"
+			}
+			declaration, err := parser.ParseFile(token.NewFileSet(), "changed.go",
+				"package tail\nfunc Forward(x *["+wrong+"]byte) uintptr\n", 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg.Syntax = []*ast.File{declaration}
+			if _, err := goX86TailFunction(pkg, "Forward", true, sizes); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("wrong target-sized array accepted: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86GoImportedTailBodyOnlyImport(t *testing.T) {
+	pkg := importedTailPackageSource(t, "amd64", `package tail
+import "strings"
+//go:noinline
+func scalar(x uintptr) uintptr {
+	if strings.Contains("original", "missing") { return x + 1 }
+	return x
+}
+`)
+	// Go export packages may omit imports used only inside function bodies.
+	// Keep the actual checked function and selected source, changing only this
+	// optional dependency inventory to its valid export-data projection.
+	pkg.Types.SetImports(nil)
+	if _, err := goX86TailFunction(pkg, "scalar", false, types.SizesFor("gc", "amd64")); err != nil {
+		t.Fatal("body-only import rejected an unchanged scalar declaration", err)
+	}
+
+	pkg = importedTailPackage(t, "amd64")
+	pkg.Types.SetImports(nil)
+	if _, err := goX86TailFunction(pkg, "Forward", true, types.SizesFor("gc", "amd64")); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("missing import actually used by the signature supplied a type: %v", err)
+	}
+}
diff --git a/x86_go_panic_terminal_assembly.go b/x86_go_panic_terminal_assembly.go
new file mode 100644
index 000000000..db83e4ada
--- /dev/null
+++ b/x86_go_panic_terminal_assembly.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"path/filepath"
+	"reflect"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// An association query result is not a terminal capability. The ordinal is in
+// the complete original function, before any translator control-flow rewrite.
+type x86GoPanicTerminalAssemblyCall struct {
+	file, function, target string
+	ordinal                int
+	instruction            Instr
+	relocation             gostaticstorage.TextRelocation
+}
+
+func x86GoPanicTerminalAssemblyCalls(pkg GoPackage, bodies []x86GoPanicTerminalCompilerBody,
+	objects *gostaticstorage.SDKASMDataObservation, cpp []AssemblyCPPObservation, positions []sdkCPPPositionObservation,
+	root string, budget *x86ResultFlowBudget,
+) ([]x86GoPanicTerminalAssemblyCall, error) {
+	fail := func(reason string) ([]x86GoPanicTerminalAssemblyCall, error) {
+		return nil, sdkASMDataContext("panic CALL association: %s", reason)
+	}
+	if budget == nil || budget.visits >= 16384 || budget.bytes >= 64<<20 || objects == nil || pkg.SourceSelection == nil ||
+		objects.Protocol != gostaticstorage.ASMDataCPPProtocol || objects.Target != "linux/386" || objects.PackagePath != pkg.Path ||
+		len(objects.Sources) == 0 || len(objects.Sources) != len(cpp) || len(cpp) != len(positions) ||
+		len(objects.Members) != len(cpp)+2 || len(pkg.SourceSelection.SelectedAssemblyFiles) != len(cpp) || len(pkg.SourceSelection.Assembly) != len(cpp) {
+		return fail("missing complete source/member/compiler/shared-budget identity")
+	}
+	declarations, err := x86GoPanicTerminalDeclarations(pkg)
+	if err != nil {
+		return nil, err
+	}
+	declared := make(map[string]x86GoPanicTerminalDeclaration)
+	for _, declaration := range declarations {
+		declared[declaration.nativeName] = declaration
+	}
+	callees := make(map[string]bool)
+	for _, body := range bodies {
+		name := body.declaration.nativeName
+		if body.assemblyABI != 0 || body.text.ABI != 1 || body.text.Name != name || callees[name] || declared[name] != body.declaration {
+			return fail("compiler body differs from its exact selected Go declaration")
+		}
+		matches := 0
+		for _, text := range objects.Members[1].Texts {
+			if text.Name == name && reflect.DeepEqual(text, body.text) {
+				matches++
+			}
+		}
+		if matches != 1 {
+			return fail("compiler body differs from its actual complete archive member")
+		}
+		callees[name] = true
+	}
+	var result []x86GoPanicTerminalAssemblyCall
+	for sourceOrdinal, source := range objects.Sources {
+		filename := pkg.SourceSelection.SelectedAssemblyFiles[sourceOrdinal]
+		file := pkg.SourceSelection.Assembly[filename]
+		if !filepath.IsAbs(filename) || filepath.Clean(filename) != filename || filepath.Base(filename) != source.Name || file == nil {
+			return fail("source route differs from its complete selected assembly")
+		}
+		reparsed, err := Parse(ArchAMD64, cpp[sourceOrdinal].Output)
+		if err != nil || !reflect.DeepEqual(reparsed, file) {
+			return fail("complete original instruction tuple differs from its parsed CPP")
+		}
+		programBytes := len(cpp[sourceOrdinal].Output) + len(positions[sourceOrdinal].Mapped)
+		// This noniterative query charges actual retained source bytes. The
+		// CFG's separate eight-copy initial-state reservation is not a byte
+		// multiplier here; subsequent flow replay shares the same64MiB cap.
+		if programBytes > (64<<20)-budget.bytes {
+			return fail("combined source-graph byte budget exhausted")
+		}
+		budget.bytes += programBytes
+		mapped, err := numericalSDKLiteralSourcePositions(file, cpp[sourceOrdinal].Output, positions[sourceOrdinal])
+		if err != nil {
+			return nil, err
+		}
+		if !reflect.DeepEqual(source.Original.Texts, source.Expanded.Texts) || !reflect.DeepEqual(source.Original.Texts, objects.Members[sourceOrdinal+2].Texts) {
+			return fail("original/mapped/archive complete native TEXT records differ")
+		}
+		order, err := gostaticstorage.ASMSourceTextOrder([]byte(cpp[sourceOrdinal].Output), pkg.Path, source.Original)
+		if err != nil || len(order) != len(file.Funcs) || !reflect.DeepEqual(order, source.TextOrder) {
+			return fail("source TEXT order differs from the actual complete object namespace")
+		}
+		for functionOrdinal, fn := range file.Funcs {
+			if len(fn.Instrs) > 16384-budget.visits {
+				return fail("combined source-graph visit budget exhausted")
+			}
+			budget.visits += len(fn.Instrs)
+			var calls []int
+			candidate := false
+			for ordinal, ins := range fn.Instrs {
+				if ins.Op != "CALL" {
+					continue
+				}
+				calls = append(calls, ordinal)
+				if name, valid := x86GoPanicTerminalCallTarget(ins, pkg.Path); valid && callees[name] {
+					candidate = true
+				}
+			}
+			if !candidate {
+				continue // No facts are granted for ordinary unrelated functions.
+			}
+			association := order[functionOrdinal]
+			text := source.Original.Texts[association.ObjectOrdinal]
+			if text.ABI != 0 || text.Size != int64(len(text.Code)) || len(text.Code) == 0 {
+				return fail("original caller lacks its exact ABI0 code extent")
+			}
+			var relocations []gostaticstorage.TextRelocation
+			for _, relocation := range text.Relocations {
+				if relocation.Type == 7 { // The selected source pins R_CALL independently.
+					relocations = append(relocations, relocation)
+				}
+			}
+			if len(relocations) != len(calls) {
+				return fail("complete source/native CALL inventories differ")
+			}
+			lastPC := int64(-1)
+			for callOrdinal, ordinal := range calls {
+				ins, relocation := fn.Instrs[ordinal], relocations[callOrdinal]
+				target, valid := x86GoPanicTerminalCallTarget(ins, pkg.Path)
+				pc := relocation.Offset - 1
+				if !valid || !relocation.Target.ABIKnown || relocation.Target.ABI != 0 || relocation.Target.Name != target ||
+					relocation.Size != 4 || relocation.Add != 0 || pc < 0 || pc <= lastPC || pc > text.Size-5 || text.Code[pc] != 0xe8 {
+					return fail("source CALL target/ABI/order differs from its original E8 relocation")
+				}
+				for _, other := range text.Relocations {
+					if other != relocation && other.Size != 0 && other.Offset < pc+5 && other.Offset+other.Size > pc {
+						return fail("original CALL overlaps another native relocation")
+					}
+				}
+				matchedPosition := false
+				for _, position := range text.Positions {
+					if position.Start <= pc && position.End >= pc+5 {
+						physical, known := originalGoObjectSourcePath(position.File, root)
+						matchedPosition = known && fmt.Sprintf("%s:%d", physical, position.Line) == mapped[functionOrdinal][ordinal]
+						break
+					}
+				}
+				if !matchedPosition {
+					return fail("original native CALL does not cover its exact source node position")
+				}
+				lastPC = pc
+				if callees[target] {
+					ins.Args = append([]Operand(nil), ins.Args...)
+					result = append(result, x86GoPanicTerminalAssemblyCall{file: filename, function: fn.Sym, target: target,
+						ordinal: ordinal, instruction: ins, relocation: relocation})
+				}
+			}
+		}
+	}
+	return result, nil
+}
+
+func x86GoPanicTerminalCallTarget(ins Instr, pkg string) (string, bool) {
+	if ins.Op != "CALL" || len(ins.Args) != 1 || ins.Args[0].Kind != OpSym || !strings.HasSuffix(ins.Args[0].Sym, "(SB)") {
+		return "", false
+	}
+	name, offset := splitSymPlusOff(strings.TrimSuffix(ins.Args[0].Sym, "(SB)"))
+	if offset != 0 {
+		return "", false
+	}
+	native, abi, valid := numericalFunctionSourceIdentity(name, gosym.PackagePrefix(pkg), "386", numericalSBSDKSource)
+	return native, valid && abi == 0
+}
diff --git a/x86_go_panic_terminal_assembly_test.go b/x86_go_panic_terminal_assembly_test.go
new file mode 100644
index 000000000..4d2564459
--- /dev/null
+++ b/x86_go_panic_terminal_assembly_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+type x86PanicTerminalAssemblyFixture struct {
+	pkg       GoPackage
+	bodies    []x86GoPanicTerminalCompilerBody
+	objects   *gostaticstorage.SDKASMDataObservation
+	cpp       []AssemblyCPPObservation
+	positions []sdkCPPPositionObservation
+}
+
+func x86PanicTerminalAssembly(t *testing.T) x86PanicTerminalAssemblyFixture {
+	t.Helper()
+	pkg, symABI, objects := x86PanicTerminalCompilerFixture(t)
+	filename := filepath.Join(filepath.Dir(pkg.SourceSelection.SelectedGoFiles[0]), "terminal.s")
+	const source = "TEXT ·entry(SB),4,$0-0\nCALL ·arbitraryName(SB)\nNOP\nCALL ·arbitraryName(SB)\nRET\nTEXT ·unrelated(SB),4,$0-0\nRET\n"
+	cpp, positions, err := observeSDKAssemblyCPP(source, AssemblyPreprocessOptions{FileName: filename})
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, cpp.Output)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg.SourceSelection.SelectedAssemblyFiles = []string{filename}
+	pkg.SourceSelection.Assembly = map[string]*File{filename: file}
+	text := gostaticstorage.TextRecord{Name: "terminal.entry", Namespace: gostaticstorage.TextSymbolNonpkgDefinition, ABI: 0, Kind: 1,
+		Size: 12, Code: []byte{0xe8, 0, 0, 0, 0, 0x90, 0xe8, 0, 0, 0, 0, 0xc3},
+		Relocations: []gostaticstorage.TextRelocation{
+			{Offset: 1, Size: 4, Type: 7, Target: gostaticstorage.TextReference{Name: "terminal.arbitraryName", ABI: 0, ABIKnown: true}},
+			{Offset: 7, Size: 4, Type: 7, Target: gostaticstorage.TextReference{Name: "terminal.arbitraryName", ABI: 0, ABIKnown: true}},
+		},
+		Positions: []gostaticstorage.TextPosition{{Start: 0, End: 5, File: filename, Line: 2}, {Start: 5, End: 6, File: filename, Line: 3},
+			{Start: 6, End: 11, File: filename, Line: 4}, {Start: 11, End: 12, File: filename, Line: 5}}}
+	unrelated := gostaticstorage.TextRecord{Name: "terminal.unrelated", Namespace: gostaticstorage.TextSymbolNonpkgDefinition, Index: 1, Relative: 1,
+		ABI: 0, Kind: 1, Size: 1, Code: []byte{0xc3}, Positions: []gostaticstorage.TextPosition{{Start: 0, End: 1, File: filename, Line: 7}}}
+	member := gostaticstorage.ASMDataMember{Flags: 20, Texts: []gostaticstorage.TextRecord{text, unrelated}}
+	order, err := gostaticstorage.ASMSourceTextOrder([]byte(cpp.Output), pkg.Path, member)
+	if err != nil {
+		t.Fatal(err)
+	}
+	objects.Members[2].Texts = []gostaticstorage.TextRecord{x86GoPanicTerminalCloneText(text), x86GoPanicTerminalCloneText(unrelated)}
+	objects.Sources[0].Original, objects.Sources[0].Expanded, objects.Sources[0].TextOrder = member, member, order
+	bodies, err := x86GoPanicTerminalCompilerBodies(pkg, symABI, objects, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return x86PanicTerminalAssemblyFixture{pkg, bodies, objects, []AssemblyCPPObservation{cpp}, []sdkCPPPositionObservation{positions}}
+}
+
+func (fixture x86PanicTerminalAssemblyFixture) query(budget *x86ResultFlowBudget) ([]x86GoPanicTerminalAssemblyCall, error) {
+	return x86GoPanicTerminalAssemblyCalls(fixture.pkg, fixture.bodies, fixture.objects, fixture.cpp, fixture.positions, "", budget)
+}
+
+func TestX86GoPanicTerminalAssemblyKeepsCompleteOriginalOrdinals(t *testing.T) {
+	fixture := x86PanicTerminalAssembly(t)
+	calls, err := fixture.query(&x86ResultFlowBudget{})
+	if err != nil || len(calls) != 2 {
+		t.Fatal("original direct CALLs were not joined to their actual compiler body", calls, err)
+	}
+	file := fixture.pkg.SourceSelection.Assembly[fixture.pkg.SourceSelection.SelectedAssemblyFiles[0]]
+	for index, ordinal := range []int{1, 3} {
+		if calls[index].ordinal != ordinal || calls[index].function != "·entry" || calls[index].target != "terminal.arbitraryName" ||
+			!reflect.DeepEqual(calls[index].instruction, file.Funcs[0].Instrs[ordinal]) || calls[index].relocation.Offset != int64(index*6+1) {
+			t.Fatal("CALL association borrowed another original node/target/native relocation", calls)
+		}
+	}
+	if len(file.Funcs) != 2 || len(file.Funcs[0].Instrs) != 5 || len(file.Funcs[1].Instrs) != 2 {
+		t.Fatal("an association query truncated original post-CALL or unrelated source")
+	}
+}
+
+func TestX86GoPanicTerminalAssemblyRejectsDifferentNodeOrNativeCall(t *testing.T) {
+	for name, mutate := range map[string]func(*x86PanicTerminalAssemblyFixture){
+		"missing-CPP":           func(f *x86PanicTerminalAssemblyFixture) { f.cpp = nil },
+		"missing-position-tape": func(f *x86PanicTerminalAssemblyFixture) { f.positions = nil },
+		"missing-selection":     func(f *x86PanicTerminalAssemblyFixture) { f.pkg.SourceSelection.SelectedAssemblyFiles = nil },
+		"source-opcode": func(f *x86PanicTerminalAssemblyFixture) {
+			f.pkg.SourceSelection.Assembly[f.pkg.SourceSelection.SelectedAssemblyFiles[0]].Funcs[0].Instrs[1].Op = "NOP"
+		},
+		"source-target": func(f *x86PanicTerminalAssemblyFixture) {
+			f.pkg.SourceSelection.Assembly[f.pkg.SourceSelection.SelectedAssemblyFiles[0]].Funcs[0].Instrs[1].Args[0].Sym = "·other"
+		},
+		"private-instruction-field": func(f *x86PanicTerminalAssemblyFixture) {
+			f.pkg.SourceSelection.Assembly[f.pkg.SourceSelection.SelectedAssemblyFiles[0]].Funcs[0].Instrs[1].x86Encoded = true
+		},
+		"CPP-output":          func(f *x86PanicTerminalAssemblyFixture) { f.cpp[0].Output += "NOP\n" },
+		"position-map":        func(f *x86PanicTerminalAssemblyFixture) { f.positions[0].Mapped += "NOP\n" },
+		"physical-order":      func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].TextOrder[0].ObjectOrdinal = 1 },
+		"original-object":     func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].Original.Texts = nil },
+		"expanded-object":     func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].Expanded.Texts = nil },
+		"archive-object":      func(f *x86PanicTerminalAssemblyFixture) { f.objects.Members[2].Texts = nil },
+		"callee-association":  func(f *x86PanicTerminalAssemblyFixture) { f.bodies[0].text.ABI = 0 },
+		"missing-native-CALL": func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].Original.Texts[0].Relocations = nil },
+		"relocation-target": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Target.Name = "terminal.other"
+		},
+		"relocation-ABI": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Target.ABI = 1
+		},
+		"relocation-unknown-ABI": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Target.ABIKnown = false
+		},
+		"relocation-addend": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Add = 1
+		},
+		"relocation-offset": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Offset = 0
+		},
+		"relocation-width": func(f *x86PanicTerminalAssemblyFixture) {
+			f.objects.Sources[0].Original.Texts[0].Relocations[0].Size = 2
+		},
+		"opcode":          func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].Original.Texts[0].Code[0] = 0xe9 },
+		"native-position": func(f *x86PanicTerminalAssemblyFixture) { f.objects.Sources[0].Original.Texts[0].Positions[0].Line = 4 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fixture := x86PanicTerminalAssembly(t)
+			mutate(&fixture)
+			if calls, err := fixture.query(&x86ResultFlowBudget{}); !errors.Is(err, ErrProbeNeedsContext) || len(calls) != 0 {
+				t.Fatal("changed source/ordinal/compiler/native node retained its association", calls, err)
+			}
+		})
+	}
+}
+
+func TestX86GoPanicTerminalAssemblySharesExistingFlowBudget(t *testing.T) {
+	fixture := x86PanicTerminalAssembly(t)
+	for _, budget := range []*x86ResultFlowBudget{nil, {visits: 16384}, {bytes: 64 << 20}} {
+		if calls, err := fixture.query(budget); !errors.Is(err, ErrProbeNeedsContext) || len(calls) != 0 {
+			t.Fatal("missing/exhausted shared source budget returned partial CALL associations", calls, err)
+		}
+	}
+	budget := &x86ResultFlowBudget{}
+	if _, err := fixture.query(budget); err != nil || budget.visits == 0 || budget.bytes == 0 {
+		t.Fatal("association ignored the request-local source proof budget", budget, err)
+	}
+}
+
+func TestX86GoPanicTerminalAssemblyBudgetUsesSharedByteWorkUnits(t *testing.T) {
+	fixture := x86PanicTerminalAssembly(t)
+	budget := &x86ResultFlowBudget{bytes: 8 << 20}
+	work := len(fixture.cpp[0].Output) + len(fixture.positions[0].Mapped)
+	if calls, err := fixture.query(budget); err != nil || len(calls) != 2 || budget.bytes != (8<<20)+work {
+		t.Fatal("noniterative source bytes borrowed the CFG's separate8-copy initial-state reservation", calls, budget, err)
+	}
+	budget.bytes = (64 << 20) - work + 1
+	if calls, err := fixture.query(budget); !errors.Is(err, ErrProbeNeedsContext) || len(calls) != 0 {
+		t.Fatal("association exceeded the unchanged shared64MiB byte-work cap", calls, budget, err)
+	}
+}
diff --git a/x86_go_panic_terminal_body.go b/x86_go_panic_terminal_body.go
new file mode 100644
index 000000000..d302a2b6a
--- /dev/null
+++ b/x86_go_panic_terminal_body.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/types"
+	"strings"
+)
+
+// This pure typed-body observation is not a callee, object, native-entry or
+// non-return capability. Only a separately authenticated actual source/compiler
+// producer may join it to one original CALL and its later emitted operation.
+func x86GoSinglePanicBodies(pkg GoPackage) (map[*types.Func]*ast.FuncDecl, error) {
+	bodies := make(map[*types.Func]*ast.FuncDecl)
+	selected := pkg.SourceSelection
+	if pkg.Types == nil || pkg.Path == "" || pkg.Types.Path() != pkg.Path || selected == nil || selected.Fset == nil || selected.TypesInfo == nil || selected.Sizes == nil {
+		return nil, fmt.Errorf("%w: panic body needs its complete selected typed source", ErrProbeNeedsContext)
+	}
+	if err := x86ValidateCallerSelection(pkg, *selected); err != nil {
+		return nil, fmt.Errorf("%w: panic body selection changed: %v", ErrProbeNeedsContext, err)
+	}
+	for _, file := range pkg.Syntax {
+		for _, declaration := range file.Decls {
+			fn, ok := declaration.(*ast.FuncDecl)
+			if !ok || fn.Recv != nil || fn.Body == nil || len(fn.Body.List) != 1 ||
+				fn.Type.TypeParams != nil && len(fn.Type.TypeParams.List) != 0 {
+				continue
+			}
+			object, valid := selected.TypesInfo.Defs[fn.Name].(*types.Func)
+			if !valid || object.Pkg() != pkg.Types || pkg.Types.Scope().Lookup(fn.Name.Name) != object {
+				return nil, fmt.Errorf("%w: panic body lost its exact selected function object", ErrProbeNeedsContext)
+			}
+			signature, valid := object.Type().(*types.Signature)
+			if !valid || signature.Recv() != nil || signature.Params().Len() != 0 || signature.Results().Len() != 0 || signature.Variadic() {
+				continue
+			}
+			redirected := false
+			if fn.Doc != nil {
+				for _, comment := range fn.Doc.List {
+					redirected = redirected || strings.Contains(comment.Text, "go:linkname") || strings.Contains(comment.Text, "go:wasmimport")
+				}
+			}
+			statement, valid := fn.Body.List[0].(*ast.ExprStmt)
+			if !valid || redirected {
+				continue
+			}
+			call, valid := statement.X.(*ast.CallExpr)
+			if !valid || call.Ellipsis.IsValid() || len(call.Args) != 1 {
+				continue
+			}
+			callee, valid := call.Fun.(*ast.Ident)
+			if !valid || selected.TypesInfo.ObjectOf(callee) != types.Universe.Lookup("panic") {
+				continue
+			}
+			recovers := false
+			ast.Inspect(call, func(node ast.Node) bool {
+				if identifier, ok := node.(*ast.Ident); ok && selected.TypesInfo.ObjectOf(identifier) == types.Universe.Lookup("recover") {
+					recovers = true
+				}
+				return !recovers
+			})
+			if !recovers {
+				bodies[object] = fn
+			}
+		}
+	}
+	return bodies, nil
+}
diff --git a/x86_go_panic_terminal_body_test.go b/x86_go_panic_terminal_body_test.go
new file mode 100644
index 000000000..b3c5559ca
--- /dev/null
+++ b/x86_go_panic_terminal_body_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"testing"
+)
+
+func x86PanicTerminalTypedFixture(t *testing.T, declarations string) GoPackage {
+	t.Helper()
+	source := "package terminal\n" + declarations + "\nfunc Value(x uint32) bool\n"
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "terminal.go", source, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{Types: make(map[ast.Expr]types.TypeAndValue), Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)}
+	sizes := types.SizesFor("gc", "386")
+	pkg, err := (&types.Config{Sizes: sizes}).Check("terminal", fset, []*ast.File{file}, info)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: "terminal", Types: pkg, Syntax: []*ast.File{file}, SourceSelection: &GoSourceSelection{
+		Fset: fset, TypesInfo: info, Sizes: sizes,
+		SelectedGoFiles: []string{"terminal.go"}, GoSources: map[string][]byte{"terminal.go": []byte(source)},
+		SelectedAssemblyFiles: []string{"terminal.s"}, Assembly: map[string]*File{"terminal.s": {Arch: ArchAMD64}},
+	}}
+}
+
+func TestX86GoPanicTerminalSingleTypedBody(t *testing.T) {
+	for _, name := range []string{"abort", "stopHere", "failure", "ordinaryName"} {
+		t.Run(name, func(t *testing.T) {
+			pkg := x86PanicTerminalTypedFixture(t, "func "+name+"(){ panic(\"failure\") }")
+			bodies, err := x86GoSinglePanicBodies(pkg)
+			object := pkg.Types.Scope().Lookup(name)
+			if err != nil || len(bodies) != 1 || bodies[object.(*types.Func)] == nil {
+				t.Fatal("the exact same selected typed builtin-panic body was not observed", name, err)
+			}
+		})
+	}
+}
+
+func TestX86GoPanicTerminalBodyDoesNotInventCalleeAuthority(t *testing.T) {
+	for name, declarations := range map[string]string{
+		"returning":           "func abort(){}",
+		"return":              "func abort(){ return }",
+		"conditional":         "func abort(){ if false { panic(\"failure\") } }",
+		"deferred-recovery":   "func abort(){ defer func(){ recover() }(); panic(\"failure\") }",
+		"deferred-panic":      "func abort(){ defer func(){ panic(\"failure\") }() }",
+		"recover-argument":    "func abort(){ panic(recover()) }",
+		"shadow-panic":        "func panic(x string){}; func abort(){ panic(\"failure\") }",
+		"result":              "func abort() uint32 { panic(\"failure\") }",
+		"argument":            "func abort(x uint32) { panic(x) }",
+		"generic":             "func abort[T any]() { panic(\"failure\") }",
+		"method":              "type T uint32; func (T) abort(){ panic(\"failure\") }",
+		"indirect":            "var p = func(){ panic(\"failure\") }; func abort(){ p() }",
+		"local-alias":         "func abort(){ p:=func(){ panic(\"failure\") }; p() }",
+		"bodyless":            "func abort()",
+		"redirected-linkname": "//go:linkname abort other.target\nfunc abort(){ panic(\"failure\") }",
+		"extra-statement":     "func abort(){ println(\"sideeffect\"); panic(\"failure\") }",
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg := x86PanicTerminalTypedFixture(t, declarations)
+			if bodies, err := x86GoSinglePanicBodies(pkg); err != nil || len(bodies) != 0 {
+				t.Fatal("a returning/recovering/different declaration acquired a terminal body observation", bodies, err)
+			}
+		})
+	}
+	for _, changed := range []string{"source", "AST", "typed-builtin", "package-identity", "missing-selection"} {
+		t.Run(changed, func(t *testing.T) {
+			pkg := x86PanicTerminalTypedFixture(t, "func abort(){ panic(\"failure\") }")
+			switch changed {
+			case "source":
+				pkg.SourceSelection.GoSources["terminal.go"] = []byte("package terminal\nfunc abort(){}\nfunc Value(x uint32) bool\n")
+			case "AST":
+				pkg.Syntax[0].Decls[0].(*ast.FuncDecl).Body.List = nil
+			case "typed-builtin":
+				ast.Inspect(pkg.Syntax[0], func(node ast.Node) bool {
+					if identifier, ok := node.(*ast.Ident); ok && identifier.Name == "panic" {
+						pkg.SourceSelection.TypesInfo.Uses[identifier] = pkg.Types.Scope().Lookup("abort")
+					}
+					return true
+				})
+			case "package-identity":
+				pkg.Path = "different"
+			case "missing-selection":
+				pkg.SourceSelection = nil
+			}
+			if bodies, err := x86GoSinglePanicBodies(pkg); err == nil || len(bodies) != 0 {
+				t.Fatal("changed selected source/AST/type object was accepted", bodies, err)
+			}
+		})
+	}
+}
diff --git a/x86_go_panic_terminal_compiler.go b/x86_go_panic_terminal_compiler.go
new file mode 100644
index 000000000..0b0416d39
--- /dev/null
+++ b/x86_go_panic_terminal_compiler.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"go/types"
+	"path/filepath"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// This pure association observes a compiler body only. It does not authenticate
+// the caller's input, establish its SDK origin or close any assembly CALL.
+type x86GoPanicTerminalCompilerBody struct {
+	declaration x86GoPanicTerminalDeclaration
+	text        gostaticstorage.TextRecord
+	assemblyABI uint16
+}
+
+func x86GoPanicTerminalCompilerBodies(pkg GoPackage, symABI []byte, objects *gostaticstorage.SDKASMDataObservation, root string) ([]x86GoPanicTerminalCompilerBody, error) {
+	declarations, err := x86GoPanicTerminalDeclarations(pkg)
+	if err != nil {
+		return nil, err
+	}
+	if objects == nil || objects.Protocol != gostaticstorage.ASMDataCPPProtocol || objects.PackagePath != pkg.Path ||
+		objects.Target != "linux/386" || pkg.SourceSelection.Sizes.Sizeof(types.Typ[types.Uintptr]) != 4 ||
+		len(objects.Sources) == 0 || len(objects.Sources) > gostaticstorage.ArchiveMemberInventoryLimit-2 ||
+		len(objects.Members) != len(objects.Sources)+2 || objects.Members[0].Name != "__.PKGDEF" ||
+		objects.Members[1].Name != "_go_.o" || objects.Members[1].Flags != 16 {
+		return nil, sdkASMDataContext("panic body lacks its complete actual386 compiler/archive role")
+	}
+	seen := map[string]bool{"__.PKGDEF": true, "_go_.o": true}
+	for ordinal, source := range objects.Sources {
+		if filepath.Base(source.Name) != source.Name || !strings.HasSuffix(source.Name, ".s") || strings.ContainsAny(source.Name, "\\\x00\r\n") {
+			return nil, sdkASMDataContext("panic body assembly selection has a noncanonical source")
+		}
+		// Match the actual SDK packInternal member route, including its exact
+		// byte truncation. This observes a route, never a winning definition.
+		name := strings.TrimSuffix(source.Name, ".s") + ".o"
+		if len(name) > 16 {
+			name = name[:16]
+		}
+		if seen[name] || objects.Members[ordinal+2].Name != name || objects.Members[ordinal+2].Flags != 20 {
+			return nil, sdkASMDataContext("panic body assembly member differs from its full selected route")
+		}
+		seen[name] = true
+	}
+	definitions, references, err := x86GoPanicTerminalSymABI(symABI)
+	if err != nil {
+		return nil, err
+	}
+	texts := make(map[string][]gostaticstorage.TextRecord)
+	storage := make(map[string]bool)
+	for ordinal, member := range objects.Members {
+		for _, definition := range member.Definitions {
+			storage[definition.Name] = true
+		}
+		for _, text := range member.Texts {
+			texts[text.Name] = append(texts[text.Name], text)
+			if ordinal != 1 {
+				storage[text.Name] = true // Any alternative ASM body is ambiguous.
+			}
+		}
+	}
+	var result []x86GoPanicTerminalCompilerBody
+	for _, declaration := range declarations {
+		name := declaration.nativeName
+		if references[name] == 0 {
+			continue // An unrelated ordinary Go function needs no ASM role.
+		}
+		candidates := texts[name]
+		if definitions[name] || references[name] != 1 || storage[name] || len(candidates) != 1 {
+			return nil, sdkASMDataContext("panic declaration has a missing or ambiguous actual compiler definition")
+		}
+		text := candidates[0]
+		// ABIInternal remains ABI1. Only a distinct live selected-source query
+		// can supply the pinned non-regabi386 linker's ABIToVersion join.
+		if text.Namespace != gostaticstorage.TextSymbolSelf || text.Index != text.Relative || text.ABI != 1 || text.Kind != 1 ||
+			text.Flags != 0 || text.Flags2 != 0 || len(text.Hash) != 0 || len(text.Code) == 0 || text.Size != int64(len(text.Code)) || len(text.Positions) == 0 {
+			return nil, sdkASMDataContext("panic declaration differs from its original compiler TEXT identity")
+		}
+		end, panicPosition := int64(0), false
+		for _, position := range text.Positions {
+			filename, valid := originalGoObjectSourcePath(position.File, root)
+			if !valid || filename != declaration.filename || position.Start != end || position.End <= position.Start || position.End > text.Size ||
+				int(position.Line) < declaration.startLine || int(position.Line) > declaration.endLine {
+				return nil, sdkASMDataContext("panic compiler body lost its complete selected declaration positions")
+			}
+			end, panicPosition = position.End, panicPosition || int(position.Line) == declaration.panicLine
+		}
+		if end != text.Size || !panicPosition {
+			return nil, sdkASMDataContext("panic compiler body does not cover the actual typed panic statement")
+		}
+		result = append(result, x86GoPanicTerminalCompilerBody{declaration: declaration, text: x86GoPanicTerminalCloneText(text), assemblyABI: 0})
+	}
+	if len(declarations) != 0 && len(result) == 0 {
+		return nil, sdkASMDataContext("panic declarations lack any actual ABI0 assembler reference")
+	}
+	return result, nil
+}
+
+// This is the selected compiler's complete def/ref grammar, not a noreturn
+// report. Repeated references form an ABI set, exactly as ReadSymABIs does.
+func x86GoPanicTerminalSymABI(data []byte) (map[string]bool, map[string]uint8, error) {
+	definitions, references := make(map[string]bool), make(map[string]uint8)
+	if len(data) > 16<<20 {
+		return nil, nil, sdkASMDataContext("panic SymABI exceeds its complete object byte bound")
+	}
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		fields := strings.Fields(line)
+		if len(fields) != 3 || fields[0] != "def" && fields[0] != "ref" || strings.HasPrefix(fields[1], `"".`) ||
+			strings.ContainsRune(fields[1], '\x00') || fields[2] != "ABI0" && fields[2] != "ABIInternal" {
+			return nil, nil, sdkASMDataContext("panic SymABI has an unknown compiler symbol grammar")
+		}
+		if fields[0] == "def" {
+			definitions[fields[1]] = true
+		} else if fields[2] == "ABI0" {
+			references[fields[1]] |= 1
+		} else {
+			references[fields[1]] |= 2
+		}
+	}
+	return definitions, references, nil
+}
+
+func x86GoPanicTerminalCloneText(text gostaticstorage.TextRecord) gostaticstorage.TextRecord {
+	text.Hash = append([]byte(nil), text.Hash...)
+	text.Code = append([]byte(nil), text.Code...)
+	text.Relocations = append([]gostaticstorage.TextRelocation(nil), text.Relocations...)
+	text.Auxiliary = append([]gostaticstorage.TextAuxiliary(nil), text.Auxiliary...)
+	text.PCFile = append([]byte(nil), text.PCFile...)
+	text.PCLine = append([]byte(nil), text.PCLine...)
+	text.Positions = append([]gostaticstorage.TextPosition(nil), text.Positions...)
+	return text
+}
diff --git a/x86_go_panic_terminal_compiler_test.go b/x86_go_panic_terminal_compiler_test.go
new file mode 100644
index 000000000..b9072e885
--- /dev/null
+++ b/x86_go_panic_terminal_compiler_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"errors"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func x86PanicTerminalCompilerFixture(t *testing.T) (GoPackage, []byte, *gostaticstorage.SDKASMDataObservation) {
+	t.Helper()
+	filename := filepath.Join(t.TempDir(), "body.go")
+	pkg := x86PanicTerminalDeclarationFixture(t, map[string]string{filename: "func arbitraryName(){ panic(\"failure\") }\n"})
+	body := gostaticstorage.TextRecord{Name: "terminal.arbitraryName", Namespace: gostaticstorage.TextSymbolSelf, ABI: 1, Kind: 1,
+		Size: 5, Code: []byte{0xe8, 0, 0, 0, 0}, Positions: []gostaticstorage.TextPosition{{Start: 0, End: 5, File: filename, Line: 2}}}
+	objects := &gostaticstorage.SDKASMDataObservation{Protocol: gostaticstorage.ASMDataCPPProtocol, PackagePath: "terminal", Target: "linux/386",
+		Members: []gostaticstorage.ASMDataMember{{Name: "__.PKGDEF"}, {Name: "_go_.o", Flags: 16, Texts: []gostaticstorage.TextRecord{body}}, {Name: "terminal.o", Flags: 20}},
+		Sources: []gostaticstorage.ASMDataSourceObservation{{Name: "terminal.s"}}}
+	return pkg, []byte("ref terminal.arbitraryName ABI0\ndef terminal.entry ABI0\n"), objects
+}
+
+func TestX86GoPanicTerminalCompilerKeepsActualABIAndOriginalBody(t *testing.T) {
+	pkg, symABI, objects := x86PanicTerminalCompilerFixture(t)
+	bodies, err := x86GoPanicTerminalCompilerBodies(pkg, symABI, objects, "")
+	if err != nil || len(bodies) != 1 || bodies[0].declaration.nativeName != "terminal.arbitraryName" ||
+		!reflect.DeepEqual(bodies[0].text, objects.Members[1].Texts[0]) || bodies[0].text.ABI != 1 {
+		t.Fatal("an ABI0 assembler reference did not retain the actual non-regabi386 compiler ABIInternal body", bodies, err)
+	}
+}
+
+func TestX86GoPanicTerminalCompilerRejectsDifferentIdentity(t *testing.T) {
+	for name, mutate := range map[string]func(*gostaticstorage.SDKASMDataObservation){
+		"target":    func(o *gostaticstorage.SDKASMDataObservation) { o.Target = "linux/amd64" },
+		"package":   func(o *gostaticstorage.SDKASMDataObservation) { o.PackagePath = "other" },
+		"protocol":  func(o *gostaticstorage.SDKASMDataObservation) { o.Protocol = gostaticstorage.ASMDataProtocol },
+		"inventory": func(o *gostaticstorage.SDKASMDataObservation) { o.Members = o.Members[:2] },
+		"compiler-member": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[1].Name = "other.o"
+		},
+		"fake-ABI0": func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].ABI = 0 },
+		"name":      func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Name = "terminal.other" },
+		"namespace": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[1].Texts[0].Namespace = gostaticstorage.TextSymbolHashed
+		},
+		"kind":      func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Kind = 3 },
+		"dupe-weak": func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Flags |= 1 },
+		"linkname":  func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Flags2 |= 16 },
+		"wrapper":   func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Flags2 |= 64 },
+		"empty":     func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Code = nil },
+		"extent":    func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Size++ },
+		"source-file": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[1].Texts[0].Positions[0].File += ".other"
+		},
+		"source-line": func(o *gostaticstorage.SDKASMDataObservation) { o.Members[1].Texts[0].Positions[0].Line++ },
+		"compiler-duplicate": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[1].Texts = append(o.Members[1].Texts, o.Members[1].Texts[0])
+		},
+		"alternative-ASM": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[2].Texts = append(o.Members[2].Texts, o.Members[1].Texts[0])
+		},
+		"DATA-alias": func(o *gostaticstorage.SDKASMDataObservation) {
+			o.Members[2].Definitions = []gostaticstorage.ASMDataDefinition{{Name: "terminal.arbitraryName", Kind: 3}}
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, symABI, objects := x86PanicTerminalCompilerFixture(t)
+			mutate(objects)
+			if bodies, err := x86GoPanicTerminalCompilerBodies(pkg, symABI, objects, ""); !errors.Is(err, ErrProbeNeedsContext) || len(bodies) != 0 {
+				t.Fatal("changed compiler/source/object association was accepted", bodies, err)
+			}
+		})
+	}
+	for name, symABI := range map[string]string{
+		"missing": "", "wrong-ABI": "ref terminal.arbitraryName ABIInternal\n", "wrong-name": "ref terminal.other ABI0\n",
+		"ASM-definition": "ref terminal.arbitraryName ABI0\ndef terminal.arbitraryName ABI0\n",
+		"unknown-schema": "permission terminal.arbitraryName noreturn\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg, _, objects := x86PanicTerminalCompilerFixture(t)
+			if bodies, err := x86GoPanicTerminalCompilerBodies(pkg, []byte(symABI), objects, ""); !errors.Is(err, ErrProbeNeedsContext) || len(bodies) != 0 {
+				t.Fatal("missing/different/handwritten symbol role acquired compiler association", bodies, err)
+			}
+		})
+	}
+}
diff --git a/x86_go_panic_terminal_declaration.go b/x86_go_panic_terminal_declaration.go
new file mode 100644
index 000000000..f3803ce6a
--- /dev/null
+++ b/x86_go_panic_terminal_declaration.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+// A typed-source query result, never a terminal-call capability. The actual
+// SDK issuer must independently associate the declaration with compiler and
+// original assembler objects before retaining any normal-successor role.
+type x86GoPanicTerminalDeclaration struct {
+	name, nativeName, filename string
+	startLine, endLine         int
+	panicLine                  int
+}
+
+func x86GoPanicTerminalDeclarations(pkg GoPackage) ([]x86GoPanicTerminalDeclaration, error) {
+	bodies, err := x86GoSinglePanicBodies(pkg)
+	if err != nil {
+		return nil, err
+	}
+	redirectedLocal, redirectedNative := make(map[string]bool), make(map[string]bool)
+	// Compiler symbol pragmas belong to the complete file, not fn.Doc.
+	// Index them once; unrelated names never lend or remove a callee role.
+	for _, file := range pkg.Syntax {
+		for _, group := range file.Comments {
+			for _, comment := range group.List {
+				fields := strings.Fields(comment.Text)
+				if len(fields) >= 2 && fields[0] == "//go:linkname" {
+					redirectedLocal[fields[1]] = true
+					if len(fields) >= 3 {
+						redirectedNative[fields[2]] = true
+					}
+				}
+			}
+		}
+	}
+	var declarations []x86GoPanicTerminalDeclaration
+	for object, body := range bodies {
+		nativeName := gosym.PackagePrefix(pkg.Path) + "." + object.Name()
+		if redirectedLocal[object.Name()] || redirectedNative[nativeName] {
+			continue
+		}
+		start := pkg.SourceSelection.Fset.Position(body.Pos())
+		end := pkg.SourceSelection.Fset.Position(body.End())
+		panic := pkg.SourceSelection.Fset.Position(body.Body.List[0].Pos())
+		declarations = append(declarations, x86GoPanicTerminalDeclaration{name: object.Name(), nativeName: nativeName,
+			filename: start.Filename, startLine: start.Line, endLine: end.Line, panicLine: panic.Line})
+	}
+	sort.Slice(declarations, func(i, j int) bool { return declarations[i].name < declarations[j].name })
+	return declarations, nil
+}
diff --git a/x86_go_panic_terminal_declaration_test.go b/x86_go_panic_terminal_declaration_test.go
new file mode 100644
index 000000000..ed6d3334c
--- /dev/null
+++ b/x86_go_panic_terminal_declaration_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"sort"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gosym"
+)
+
+func x86PanicTerminalDeclarationFixture(t *testing.T, sources map[string]string) GoPackage {
+	return x86PanicTerminalDeclarationPackageFixture(t, "terminal", sources)
+}
+
+func x86PanicTerminalDeclarationPackageFixture(t *testing.T, packagePath string, sources map[string]string) GoPackage {
+	t.Helper()
+	selected := &GoSourceSelection{Fset: token.NewFileSet(), Sizes: types.SizesFor("gc", "386"),
+		TypesInfo: &types.Info{Types: make(map[ast.Expr]types.TypeAndValue), Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)},
+		GoSources: make(map[string][]byte), SelectedAssemblyFiles: []string{"terminal.s"}, Assembly: map[string]*File{"terminal.s": {Arch: ArchAMD64}}}
+	for filename := range sources {
+		selected.SelectedGoFiles = append(selected.SelectedGoFiles, filename)
+	}
+	sort.Strings(selected.SelectedGoFiles)
+	var syntax []*ast.File
+	for _, filename := range selected.SelectedGoFiles {
+		source := []byte("package terminal\n" + sources[filename])
+		file, err := parser.ParseFile(selected.Fset, filename, source, parser.ParseComments)
+		if err != nil {
+			t.Fatal(err)
+		}
+		syntax = append(syntax, file)
+		selected.GoSources[filename] = source
+	}
+	typed, err := (&types.Config{Sizes: selected.Sizes}).Check(packagePath, selected.Fset, syntax, selected.TypesInfo)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return GoPackage{Path: packagePath, Types: typed, Syntax: syntax, SourceSelection: selected}
+}
+
+func TestX86GoPanicTerminalDeclarationUsesActualPackagePrefix(t *testing.T) {
+	const path = "example.invalid/with.dot"
+	pkg := x86PanicTerminalDeclarationPackageFixture(t, path, map[string]string{"body.go": "func arbitraryName(){ panic(1) }\n"})
+	declarations, err := x86GoPanicTerminalDeclarations(pkg)
+	if err != nil || len(declarations) != 1 || declarations[0].nativeName != gosym.PackagePrefix(path)+".arbitraryName" ||
+		declarations[0].nativeName == path+".arbitraryName" {
+		t.Fatal("selected declaration lost the actual Go object package-prefix encoding", declarations, err)
+	}
+}
+
+func TestX86GoPanicTerminalDeclarationWholeSelectionRedirection(t *testing.T) {
+	for name, redirected := range map[string]string{
+		"detached-local": "//go:linkname abort foreign.target\n\nvar unrelated uint32\n",
+		"exported-local": "//go:linkname abort\n\nvar unrelated uint32\n",
+		"incoming-alias": "//go:linkname redirected terminal.abort\n\nfunc redirected()\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			pkg := x86PanicTerminalDeclarationFixture(t, map[string]string{
+				"body.go":  "func abort(){ panic(\"failure\") }\n",
+				"other.go": redirected,
+			})
+			if declarations, err := x86GoPanicTerminalDeclarations(pkg); err != nil || len(declarations) != 0 {
+				t.Fatal("detached/cross-file symbol redirection acquired an exact Go-body declaration role", declarations, err)
+			}
+		})
+	}
+}
+
+func TestX86GoPanicTerminalDeclarationKeepsUnrelatedFunctionsAndDirectives(t *testing.T) {
+	pkg := x86PanicTerminalDeclarationFixture(t, map[string]string{
+		"body.go":  "func arbitraryName(){ panic(\"failure\") }\nfunc returning(){}\n",
+		"other.go": "//go:linknamestd unrelated\n//go:linkname redirected foreign.target\nfunc redirected()\n",
+	})
+	declarations, err := x86GoPanicTerminalDeclarations(pkg)
+	if err != nil || len(declarations) != 1 || declarations[0].name != "arbitraryName" || declarations[0].nativeName != "terminal.arbitraryName" ||
+		declarations[0].filename != "body.go" || declarations[0].startLine != 2 || declarations[0].endLine != 2 || declarations[0].panicLine != 2 {
+		t.Fatal("unrelated declarations or directive spelling changed the exact typed body query", declarations, err)
+	}
+}
+
+func TestX86GoPanicTerminalDeclarationDetachedSameFile(t *testing.T) {
+	pkg := x86PanicTerminalDeclarationFixture(t, map[string]string{
+		"body.go": "//go:linkname arbitraryName foreign.target\n\nvar unrelated uint32\nfunc arbitraryName(){ panic(\"failure\") }\n",
+	})
+	if declarations, err := x86GoPanicTerminalDeclarations(pkg); err != nil || len(declarations) != 0 {
+		t.Fatal("a file-level directive detached from fn.Doc retained a declaration association", declarations, err)
+	}
+}
diff --git a/x86_go_panic_terminal_link_go127_test.go b/x86_go_panic_terminal_link_go127_test.go
new file mode 100644
index 000000000..0ab4f689b
--- /dev/null
+++ b/x86_go_panic_terminal_link_go127_test.go
@@ -0,0 +1,334 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"debug/elf"
+	"encoding/binary"
+	"encoding/hex"
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// These source facts belong to this object/link oracle, not a source issuer.
+// ABI1 remains ABI1 in the compiler object. On actual non-regabi386 the selected
+// linker normalizes its symbol version; no record or wrapper is fabricated.
+var x86Terminal386CompilerLinkSourcePins = map[string]string{
+	"src/internal/buildcfg/exp.go":                "5825d40b47471bca28a00c0c19215930efef22b758120b6d972da1a955f21fa0",
+	"src/cmd/internal/obj/link.go":                "918978ac6b04e839f5222282b2526230c6ca95b50248456ba9f73e9083258e1f",
+	"src/cmd/compile/internal/ir/func.go":         "185b5f070932048b28c173de6d770ee7415b0490c1130623ab8b69dadd2d8387",
+	"src/cmd/compile/internal/ssagen/abi.go":      "35b5cea74c417723ff4778cea5175d3a7bdd9c58584af163229e9624a1ee709c",
+	"src/cmd/link/internal/sym/symbol.go":         "46ff2bfa4dec86d6c77c09fa5ef8f11f13d49ba55aee30507f4102a9750cfb04",
+	"src/cmd/link/internal/loader/loader.go":      "b85dcd0c6f017f2455ba2d553bc20fd8b29105a98e4b6a6a0293ff32f6eca204",
+	"src/cmd/link/internal/ld/main.go":            "0fe8ad02e4b244bbaa82f14a86aaa005155e43c9ba7492c98c9e9650b86cd41e",
+	"src/cmd/internal/objabi/reloctype_string.go": "6e1a80d8c32bcb6c599a75e08a1e69d54f88a52941a0c831fb37b8e11ce3fc28",
+	"src/cmd/go/internal/work/gc.go":              "13359b8707e78300e8e0ec880b9a8d1af4bafdf32140b56df5f041a52fbc1325",
+	"src/cmd/go/internal/work/shell.go":           "ffc69d476c2cde44a64c26693b2c9aeb42830ac2777f9f538ef268c86d57be2f",
+}
+
+// This is a complete ordinary own-package Go/compiler/assembler/link oracle.
+// It grants no SDK/body/entry or terminal capability, and does not execute the
+// resulting Linux program. Runtime qualification is a separate owner.
+func TestX86GoPanicTerminal386OriginalABICompileAndLink(t *testing.T) {
+	const module = "example.invalid/panicterminal"
+	const packagePath = module + "/callee"
+	const goSource = `package callee
+func ordinaryFailure(){ panic("first failure") }
+func stopHere(){ panic("second failure") }
+func InvokeFirst()
+func InvokeSecond()
+`
+	const assembly = `TEXT ·InvokeFirst(SB),4,$0-0
+CALL ·ordinaryFailure(SB)
+RET
+TEXT ·InvokeSecond(SB),4,$0-0
+CALL ·stopHere(SB)
+RET
+`
+	// Canonicalize only this fresh fixture-owned output directory.
+	directory, err := filepath.EvalSymlinks(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	calleeDirectory := filepath.Join(directory, "callee")
+	if err := os.Mkdir(calleeDirectory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	artifacts := make(map[string][]byte)
+	inputHashes := make(map[string][sha256.Size]byte)
+	read := func(filename string) []byte {
+		info, err := os.Lstat(filename)
+		if err != nil || !info.Mode().IsRegular() || info.Size() > 64<<20 {
+			t.Fatal("oracle input/output is not a bounded regular file", filename, err)
+		}
+		data, err := os.ReadFile(filename)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return data
+	}
+	retainInput := func(filename string) []byte {
+		data := read(filename)
+		inputHashes[filename] = sha256.Sum256(data)
+		return data
+	}
+	verifyInputs := func() {
+		for filename, expected := range inputHashes {
+			if sha256.Sum256(read(filename)) != expected {
+				t.Fatal("selected source/tool changed during the original compile/link oracle", filename)
+			}
+		}
+	}
+	type commandReceipt struct {
+		Arguments   []string
+		Observation goasmcmd.Observation
+		Failure     string
+	}
+	var commands []commandReceipt
+	t.Cleanup(func() {
+		encoded, err := json.MarshalIndent(struct {
+			Commands []commandReceipt
+			Inputs   map[string][sha256.Size]byte
+		}{commands, inputHashes}, "", "  ")
+		if err != nil {
+			t.Error(err)
+			return
+		}
+		artifacts["commands-and-inputs.json"] = encoded
+		if output := os.Getenv("PLAN9ASM_STATIC_STORAGE_ARTIFACT_DIR"); output != "" {
+			output = filepath.Join(output, "386-single-panic-original-link")
+			if err := os.MkdirAll(output, 0700); err != nil {
+				t.Error(err)
+				return
+			}
+			for name, data := range artifacts {
+				if err := os.WriteFile(filepath.Join(output, name), data, 0600); err != nil {
+					t.Error(err)
+				}
+			}
+		}
+	})
+	for name, source := range map[string]string{
+		"go.mod":            "module " + module + "\n\ngo 1.20\n",
+		"main.go":           "package main\nimport \"" + packagePath + "\"\nfunc main(){ callee.InvokeFirst(); callee.InvokeSecond() }\n",
+		"callee/body.go":    goSource,
+		"callee/body_386.s": assembly,
+	} {
+		filename := filepath.Join(directory, filepath.FromSlash(name))
+		if err := os.WriteFile(filename, []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		artifacts[strings.ReplaceAll(name, "/", "-")] = retainInput(filename)
+	}
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	inputHashes[driver] = driverHash
+	// This independent ordinary fixture selects its explicit target profile.
+	// Keep inherited Windows drive-current-directory entries intact too; the
+	// actual env query below verifies the resulting last-value command profile.
+	environment := append(append([]string(nil), os.Environ()...), "GOOS=linux", "GOARCH=386", "GO386=sse2", "GOTOOLCHAIN=local",
+		"GOENV=off", "GOWORK=off", "GOFLAGS=", "GOEXPERIMENT=", "CGO_ENABLED=0", "GOPROXY=off", "GOSUMDB=off")
+	proof, cancel := runtimeOracleProofContext(t)
+	defer cancel()
+	run := func(trace bool, arguments ...string) []byte {
+		verifyInputs()
+		stage, cancel := context.WithTimeout(proof, 2*time.Minute)
+		defer cancel()
+		observed, err := goasmcmd.Observe(stage, directory, environment, driver, arguments...)
+		receipt := commandReceipt{Arguments: append([]string(nil), arguments...), Observation: observed}
+		if err != nil {
+			receipt.Failure = err.Error()
+		}
+		commands = append(commands, receipt)
+		verifyInputs()
+		if err != nil || stage.Err() != nil || !observed.Waited || observed.ExitCode != 0 || !trace && len(observed.Stderr) != 0 {
+			t.Fatalf("actual owned Go compile/link command %v: %v\n%s", arguments, err, observed.Stderr)
+		}
+		return observed.Stdout
+	}
+	actualJSON := run(false, "env", "-json", "GOROOT", "GOTOOLDIR", "GOVERSION", "GOOS", "GOARCH", "GO386", "GOEXPERIMENT", "GOENV", "GOFLAGS", "GOWORK", "GOTOOLCHAIN", "CGO_ENABLED")
+	artifacts["actual-environment.json"] = actualJSON
+	var actual map[string]string
+	if err := json.Unmarshal(actualJSON, &actual); err != nil || actual["GOVERSION"] != runtime.Version() || actual["GOOS"] != "linux" || actual["GOARCH"] != "386" ||
+		actual["GO386"] != "sse2" || actual["GOEXPERIMENT"] != "" || actual["GOENV"] != "" || actual["GOFLAGS"] != "" ||
+		actual["GOWORK"] != "off" || actual["GOTOOLCHAIN"] != "local" || actual["CGO_ENABLED"] != "0" || filepath.Join(actual["GOROOT"], "bin", gotoolchain.HostExecutable("go")) != driver {
+		t.Fatal("actual selected386 compiler/linker profile differs", err)
+	}
+	for _, tool := range []string{"asm", "compile", "link"} {
+		route := strings.TrimSpace(string(run(false, "tool", "-n", tool)))
+		if route != filepath.Join(actual["GOTOOLDIR"], gotoolchain.HostExecutable(tool)) {
+			t.Fatal("selected tool route is not the actual SDK tool", tool, route)
+		}
+		retainInput(route)
+	}
+	for role, expected := range x86Terminal386CompilerLinkSourcePins {
+		data := retainInput(filepath.Join(actual["GOROOT"], filepath.FromSlash(role)))
+		digest := sha256.Sum256(data)
+		if hex.EncodeToString(digest[:]) != expected {
+			t.Fatal("unregistered actual compiler/linker normalization source", role)
+		}
+		artifacts[strings.ReplaceAll(role, "/", "-")] = data
+	}
+	builtin := retainInput(filepath.Join(actual["GOROOT"], "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	selectionJSON := run(false, "list", "-mod=readonly", "-compiled", "-json", "./callee")
+	artifacts["selection.json"] = selectionJSON
+	var selected struct {
+		ImportPath, Dir                  string
+		GoFiles, CompiledGoFiles, SFiles []string
+		Imports                          []string
+		Standard                         bool
+		Module                           *struct{ Path, Dir, GoVersion string }
+	}
+	if err := json.Unmarshal(selectionJSON, &selected); err != nil || selected.Standard || selected.ImportPath != packagePath || selected.Dir != calleeDirectory ||
+		!reflect.DeepEqual(selected.GoFiles, []string{"body.go"}) || !reflect.DeepEqual(selected.SFiles, []string{"body_386.s"}) || len(selected.Imports) != 0 ||
+		len(selected.CompiledGoFiles) != 1 || filepath.Base(selected.CompiledGoFiles[0]) != "body.go" ||
+		selected.Module == nil || selected.Module.Path != module || selected.Module.Dir != directory || selected.Module.GoVersion != "1.20" {
+		t.Fatal("the complete ordinary own-package source selection changed", err)
+	}
+	fset := token.NewFileSet()
+	goFilename, asmFilename := filepath.Join(calleeDirectory, "body.go"), filepath.Join(calleeDirectory, "body_386.s")
+	goBytes := read(goFilename)
+	syntax, err := parser.ParseFile(fset, goFilename, goBytes, parser.ParseComments)
+	if err != nil {
+		t.Fatal(err)
+	}
+	info := &types.Info{Types: make(map[ast.Expr]types.TypeAndValue), Defs: make(map[*ast.Ident]types.Object), Uses: make(map[*ast.Ident]types.Object)}
+	sizes := types.SizesFor("gc", actual["GOARCH"])
+	typed, err := (&types.Config{Sizes: sizes, GoVersion: "go" + selected.Module.GoVersion}).Check(packagePath, fset, []*ast.File{syntax}, info)
+	if err != nil {
+		t.Fatal("the actual selected own-package bodies could not be independently typed", err)
+	}
+	file, err := ParseWithDefines(ArchAMD64, string(read(asmFilename)), GoAssemblerDefinesWithEnv("linux", "386", actual))
+	if err != nil || len(file.Funcs) != 2 {
+		t.Fatal("the complete original two-TEXT own-package source changed", err)
+	}
+	pkg := GoPackage{Path: packagePath, Types: typed, Syntax: []*ast.File{syntax}, SourceSelection: &GoSourceSelection{
+		Fset: fset, Sizes: sizes, TypesInfo: info, SelectedGoFiles: []string{goFilename}, GoSources: map[string][]byte{goFilename: goBytes},
+		SelectedAssemblyFiles: []string{asmFilename}, Assembly: map[string]*File{asmFilename: file}}}
+	if declarations, err := x86GoPanicTerminalDeclarations(pkg); err != nil || len(declarations) != 2 {
+		t.Fatal("the two arbitrary actual bodies are not precisely noarg Void single builtin-panic declarations", declarations, err)
+	}
+	displayTool := func(tool string) string {
+		// This is the pinned work/shell.go joinUnambiguously argument rule.
+		quoted := strconv.Quote(tool)
+		if tool == "" || strings.ContainsAny(tool, " ()>;") || len(quoted) > len(tool)+2 {
+			return quoted
+		}
+		return tool
+	}
+	archiveFile := filepath.Join(directory, "original.a")
+	run(true, "build", "-mod=readonly", "-x", "-a", "-buildmode=archive", "-o", archiveFile, "./callee")
+	buildTrace := commands[len(commands)-1].Observation.Stderr
+	compileRoute := filepath.Join(actual["GOTOOLDIR"], gotoolchain.HostExecutable("compile"))
+	if !bytes.Contains(buildTrace, []byte(displayTool(compileRoute)+" -o ")) || !bytes.Contains(buildTrace, []byte(" -p "+packagePath+" ")) {
+		t.Fatal("the actual archive build did not execute its selected compiler/package route")
+	}
+	artifacts["original.a"] = retainInput(archiveFile)
+	members, err := gostaticstorage.ObserveX86AssemblyArchive(artifacts["original.a"], builtin, "linux/386", selected.SFiles)
+	if err != nil || len(members) != 3 || members[1].Name != "_go_.o" || members[1].Flags != 0 || members[2].Flags != 4 {
+		t.Fatal("complete ordinary compiler/ASM archive observation, without -std or SDK permission", err)
+	}
+	objectFile := filepath.Join(directory, "original.o")
+	run(false, "tool", "asm", "-p", packagePath, "-D", "GOOS_linux", "-D", "GOARCH_386", "-D", "GO386_sse2", "-o", objectFile, filepath.Join(calleeDirectory, "body_386.s"))
+	artifacts["original.o"] = retainInput(objectFile)
+	standalone, err := gostaticstorage.ObserveX86AssemblyText(artifacts["original.o"], builtin, "linux/386")
+	if err != nil || len(standalone) != 2 || !reflect.DeepEqual(standalone, members[2].Texts) {
+		t.Fatal("complete original standalone/driver-assembled objects differ", err)
+	}
+	artifacts["complete-original-records.json"], err = json.MarshalIndent(struct {
+		Members    []gostaticstorage.TextMember
+		Standalone []gostaticstorage.TextRecord
+	}{members, standalone}, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	linkedFile := filepath.Join(directory, "original-linked.elf")
+	run(true, "build", "-mod=readonly", "-x", "-o", linkedFile, ".")
+	linkRoute := filepath.Join(actual["GOTOOLDIR"], gotoolchain.HostExecutable("link"))
+	if !bytes.Contains(commands[len(commands)-1].Observation.Stderr, []byte(displayTool(linkRoute)+" -o ")) {
+		t.Fatal("the actual build did not execute the selected linker")
+	}
+	artifacts["original-linked.elf"] = read(linkedFile)
+	linked, err := elf.NewFile(bytes.NewReader(artifacts["original-linked.elf"]))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer linked.Close()
+	if linked.Class != elf.ELFCLASS32 || linked.Machine != elf.EM_386 || linked.Data != elf.ELFDATA2LSB || linked.Type != elf.ET_EXEC {
+		t.Fatal("the real linked object is not the selected Linux386 executable")
+	}
+	symbols, err := linked.Symbols()
+	if err != nil {
+		t.Fatal(err)
+	}
+	findSymbol := func(name string) elf.Symbol {
+		var matches []elf.Symbol
+		for _, symbol := range symbols {
+			if symbol.Name == name {
+				matches = append(matches, symbol)
+			}
+		}
+		if len(matches) != 1 || elf.ST_TYPE(matches[0].Info) != elf.STT_FUNC {
+			t.Fatal("linked function lacks its exact unique native symbol", name, len(matches))
+		}
+		return matches[0]
+	}
+	for index, row := range []struct{ caller, callee string }{{"InvokeFirst", "ordinaryFailure"}, {"InvokeSecond", "stopHere"}} {
+		t.Run(row.callee, func(t *testing.T) {
+			var bodies []gostaticstorage.TextRecord
+			for _, body := range members[1].Texts {
+				if body.Name == packagePath+"."+row.callee {
+					bodies = append(bodies, body)
+				}
+			}
+			if len(bodies) != 1 || bodies[0].ABI != 1 || bodies[0].Kind != 1 || len(bodies[0].Code) == 0 {
+				t.Fatal("the original compiler ABIInternal body was absent or replaced with ABI0", bodies)
+			}
+			caller := standalone[index]
+			if caller.Name != packagePath+"."+row.caller || caller.ABI != 0 || len(caller.Relocations) != 1 {
+				t.Fatal("the original assembler ABI0 caller or complete relocation inventory changed", caller)
+			}
+			relocation := caller.Relocations[0]
+			if relocation.Type != 7 || relocation.Size != 4 || relocation.Add != 0 || relocation.Offset < 1 || relocation.Offset+4 > int64(len(caller.Code)) ||
+				caller.Code[relocation.Offset-1] != 0xe8 || relocation.Target.Name != bodies[0].Name || !relocation.Target.ABIKnown || relocation.Target.ABI != 0 {
+				t.Fatal("the original complete noarg CALL lacks its genuine ABI0 relocation", relocation)
+			}
+			callerSymbol, bodySymbol := findSymbol(caller.Name), findSymbol(bodies[0].Name)
+			if int(callerSymbol.Section) >= len(linked.Sections) || callerSymbol.Size != uint64(len(caller.Code)) {
+				t.Fatal("linked caller extent or section differs from the original object")
+			}
+			section := linked.Sections[callerSymbol.Section]
+			data, err := section.Data()
+			start := callerSymbol.Value - section.Addr
+			if err != nil || callerSymbol.Value < section.Addr || start > uint64(len(data)) || callerSymbol.Size > uint64(len(data))-start {
+				t.Fatal("linked caller bytes lack their actual complete section extent", err)
+			}
+			code := data[start : start+callerSymbol.Size]
+			offset := int(relocation.Offset)
+			target := int64(callerSymbol.Value) + relocation.Offset + 4 + int64(int32(binary.LittleEndian.Uint32(code[offset:offset+4])))
+			if target < 0 || uint64(target) != bodySymbol.Value || !bytes.Equal(code[:offset], caller.Code[:offset]) || !bytes.Equal(code[offset+4:], caller.Code[offset+4:]) {
+				t.Fatal("actual linker did not resolve the ABI0 CALL to its distinct observed ABI1 Go body", target, bodySymbol.Value)
+			}
+			t.Logf("original compiler ABI=%d ASM caller ABI=%d CALL reference ABI=%d actual linked target=%#x; compile/link only, runtime unexecuted",
+				bodies[0].ABI, caller.ABI, relocation.Target.ABI, bodySymbol.Value)
+		})
+	}
+	verifyInputs()
+}
diff --git a/x86_go_panic_terminal_profile_go127_test.go b/x86_go_panic_terminal_profile_go127_test.go
new file mode 100644
index 000000000..586656284
--- /dev/null
+++ b/x86_go_panic_terminal_profile_go127_test.go
@@ -0,0 +1,74 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+func TestX86GoPanicTerminalAuditedPatchSources(t *testing.T) {
+	roles := x86GoPanicTerminalCompilerSourceRoles()
+	if len(roles) != 14 {
+		t.Fatal("panic compiler/linker source inventory changed", len(roles))
+	}
+	sources := make(map[string][]byte, len(roles))
+	for name := range roles {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(name)))
+		if err != nil {
+			t.Fatal(err)
+		}
+		sources[name] = data
+	}
+	environment := func(version string) map[string]string {
+		return map[string]string{"GOVERSION": version, "GOOS": "linux", "GOARCH": "386", "GO386": "sse2"}
+	}
+	for _, version := range []string{"go1.27.2", "go1.27.3"} {
+		t.Run(version, func(t *testing.T) {
+			seen := make(map[string]bool)
+			err := x86GoPanicTerminalCompilerSources(environment(version), func(name string) ([]byte, error) {
+				seen[name] = true
+				return sources[name], nil
+			})
+			if err != nil || len(seen) != len(roles) {
+				t.Fatal("audited exact patch did not check every original producer file", err, len(seen))
+			}
+		})
+	}
+	for _, version := range []string{"go1.27.2", "go1.27.3"} {
+		for name := range roles {
+			t.Run(version+"/changed/"+name, func(t *testing.T) {
+				seen := false
+				err := x86GoPanicTerminalCompilerSources(environment(version), func(role string) ([]byte, error) {
+					if role == name {
+						seen = true
+						return append(append([]byte(nil), sources[role]...), '\n'), nil
+					}
+					return sources[role], nil
+				})
+				if !seen || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed exact producer bytes were not independently rejected", seen, err)
+				}
+			})
+		}
+		if err := x86GoPanicTerminalCompilerSources(environment(version), func(string) ([]byte, error) {
+			return nil, os.ErrNotExist
+		}); !errors.Is(err, os.ErrNotExist) {
+			t.Fatal("guarded reader failure was hidden", version, err)
+		}
+	}
+	for _, version := range []string{"go1.27.4", "go1.27", "go1.27.3-custom", "devel go1.27.3"} {
+		t.Run("unregistered/"+version, func(t *testing.T) {
+			err := x86GoPanicTerminalCompilerSources(environment(version), func(string) ([]byte, error) {
+				t.Fatal("unregistered patch consulted producer bytes")
+				return nil, nil
+			})
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unaudited patch acquired compiler roles", err)
+			}
+		})
+	}
+}
diff --git a/x86_go_panic_terminal_schema.go b/x86_go_panic_terminal_schema.go
new file mode 100644
index 000000000..ab61da249
--- /dev/null
+++ b/x86_go_panic_terminal_schema.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+)
+
+// These exact source facts bind the selected386 compiler's ABIInternal body,
+// disabled register-ABI wrappers and the linker's ABIToVersion normalization.
+// They do not assert a native entry, GC map, memory extent or non-return role.
+var x86GoPanicTerminal386Schema = map[string]string{
+	"src/internal/buildcfg/exp.go":                "5825d40b47471bca28a00c0c19215930efef22b758120b6d972da1a955f21fa0",
+	"src/cmd/internal/obj/link.go":                "918978ac6b04e839f5222282b2526230c6ca95b50248456ba9f73e9083258e1f",
+	"src/cmd/compile/internal/ir/func.go":         "185b5f070932048b28c173de6d770ee7415b0490c1130623ab8b69dadd2d8387",
+	"src/cmd/compile/internal/ssagen/abi.go":      "35b5cea74c417723ff4778cea5175d3a7bdd9c58584af163229e9624a1ee709c",
+	"src/cmd/link/internal/sym/symbol.go":         "46ff2bfa4dec86d6c77c09fa5ef8f11f13d49ba55aee30507f4102a9750cfb04",
+	"src/cmd/link/internal/loader/loader.go":      "b85dcd0c6f017f2455ba2d553bc20fd8b29105a98e4b6a6a0293ff32f6eca204",
+	"src/cmd/link/internal/ld/main.go":            "0fe8ad02e4b244bbaa82f14a86aaa005155e43c9ba7492c98c9e9650b86cd41e",
+	"src/cmd/internal/objabi/reloctype_string.go": "6e1a80d8c32bcb6c599a75e08a1e69d54f88a52941a0c831fb37b8e11ce3fc28",
+}
+
+func x86GoPanicTerminalCompilerSourceRoles() map[string]string {
+	roles := make(map[string]string, len(x86GoPanicTerminal386Schema)+len(numericalCompilerAliasSchema))
+	for role, hash := range numericalCompilerAliasSchema {
+		roles[role] = hash
+	}
+	for role, hash := range x86GoPanicTerminal386Schema {
+		roles[role] = hash
+	}
+	return roles
+}
+
+func x86GoPanicTerminalCompilerSources(env map[string]string, read func(string) ([]byte, error)) error {
+	version := env["GOVERSION"]
+	if version != "go1.27.1" && version != "go1.27.2" && version != "go1.27.3" ||
+		env["GOOS"] != "linux" || env["GOARCH"] != "386" ||
+		env["GO386"] != "sse2" || env["GOEXPERIMENT"] != "" || read == nil {
+		return sdkASMDataContext("panic association lacks its selected non-regabi386 source/profile")
+	}
+	for role, expected := range x86GoPanicTerminalCompilerSourceRoles() {
+		data, err := read(role)
+		if err != nil {
+			return err
+		}
+		hash := sha256.Sum256(data)
+		if hex.EncodeToString(hash[:]) != expected {
+			return sdkASMDataContext("panic compiler/linker producer source differs: %s", role)
+		}
+	}
+	return nil
+}
diff --git a/x86_go_panic_terminal_source.go b/x86_go_panic_terminal_source.go
new file mode 100644
index 000000000..2748a55cb
--- /dev/null
+++ b/x86_go_panic_terminal_source.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"path/filepath"
+	"reflect"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// These observations are private inputs for a future terminal capability.
+// They neither bind Options nor change a CALL's normal or unwind successors.
+type x86GoPanicTerminalSourceObservation struct {
+	bodies []x86GoPanicTerminalCompilerBody
+	calls  []x86GoPanicTerminalAssemblyCall
+}
+
+func (source *GoX86SDKASMDataSource) panicTerminalObservation(ctx context.Context, budget *x86ResultFlowBudget) (observed *x86GoPanicTerminalSourceObservation, result error) {
+	if source == nil || source.identity != source || source.guard == nil || source.guard != source.originalGuard ||
+		source.captureRole != sdkASMDataOriginalSourceRole || source.request.Target != "linux/386" || budget == nil ||
+		budget.visits >= 16384 || budget.bytes >= 64<<20 {
+		return nil, sdkASMDataContext("panic association requires its original private386 source observation")
+	}
+	if err := source.Verify(ctx); err != nil {
+		return nil, err
+	}
+	// Retain the existing artifact lifetime across private typechecking and the
+	// final callback-bearing Verify. A reentrant Close revokes publication but
+	// cannot delete files underneath the in-flight query.
+	source.mu.Lock()
+	generation, ready := source.generation, source.ready
+	if ready {
+		source.active++
+	}
+	source.mu.Unlock()
+	if !ready {
+		return nil, sdkASMDataContext("panic association source closed before its query")
+	}
+	defer func() {
+		result = errors.Join(result, source.Verify(ctx))
+		source.mu.Lock()
+		if !source.ready || source.generation != generation {
+			result = errors.Join(result, sdkASMDataContext("panic association source revoked before publication"))
+		}
+		source.active--
+		cleanup := source.closePending && source.active == 0
+		source.mu.Unlock()
+		if cleanup {
+			source.operation.Lock()
+			result = errors.Join(result, source.guard.Close())
+			source.operation.Unlock()
+		}
+		if result != nil {
+			observed = nil
+		}
+	}()
+	private, stop, err := sdkASMDataPrivateContext(ctx, source.context, source.originalDeadline)
+	if err != nil {
+		return nil, err
+	}
+	defer stop()
+	source.operation.Lock()
+	defer source.operation.Unlock()
+	if err := x86GoPanicTerminalCompilerSources(source.guard.env, func(role string) ([]byte, error) {
+		return source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role)))
+	}); err != nil {
+		return nil, err
+	}
+	count := len(source.guard.selection.SFiles)
+	if count == 0 || len(source.observation.CPP) != count || len(source.observation.Positions) != count ||
+		len(source.observation.ObjectInputs.Sources) != count || source.observation.Objects == nil ||
+		len(source.observation.Objects.Sources) != count {
+		return nil, sdkASMDataContext("panic association lost its complete actual Go/ASM selection")
+	}
+	pkg, err := source.typedPackage(source.observation.Header.LanguageVersion)
+	if err != nil {
+		return nil, err
+	}
+	for ordinal, name := range source.guard.selection.SFiles {
+		if source.observation.ObjectInputs.Sources[ordinal].Name != name || source.observation.Objects.Sources[ordinal].Name != name {
+			return nil, sdkASMDataContext("panic association changed a complete selected ASM route")
+		}
+	}
+	bodies, err := x86GoPanicTerminalCompilerBodies(pkg, source.observation.Header.SymABI, source.observation.Objects, source.guard.env["GOROOT"])
+	if err != nil {
+		return nil, err
+	}
+	// Reuse the existing complete SDK header-compiler object observer. No new
+	// decoder, caller report, fake ABI0 body or AMD64 wrapper is introduced.
+	generated, err := gostaticstorage.ObserveX86SDKCompilerText(source.observation.Header.CompilerObject,
+		source.observation.ObjectInputs.BuiltinSource, source.request.Target, source.observation.ObjectInputs.Referenced)
+	if err != nil {
+		return nil, sdkASMDataContext("panic association lacks the complete actual header compiler object: %v", err)
+	}
+	if err := x86GoPanicTerminalGeneratedBodies(bodies, generated, source.guard.env["GOROOT"]); err != nil {
+		return nil, err
+	}
+	calls, err := x86GoPanicTerminalAssemblyCalls(pkg, bodies, source.observation.Objects, source.observation.CPP,
+		source.observation.Positions, source.guard.env["GOROOT"], budget)
+	if err != nil {
+		return nil, err
+	}
+	return &x86GoPanicTerminalSourceObservation{bodies: bodies, calls: calls}, errors.Join(private.Err(), source.guard.verifyInputs())
+}
+
+func x86GoPanicTerminalGeneratedBodies(bodies []x86GoPanicTerminalCompilerBody, generated []gostaticstorage.TextRecord, root string) error {
+	index := make(map[string][]gostaticstorage.TextRecord)
+	for _, text := range generated {
+		index[text.Name] = append(index[text.Name], text)
+	}
+	normalize := func(text gostaticstorage.TextRecord) (gostaticstorage.TextRecord, bool) {
+		text = x86GoPanicTerminalCloneText(text)
+		for ordinal := range text.Positions {
+			name, valid := originalGoObjectSourcePath(text.Positions[ordinal].File, root)
+			if !valid {
+				return text, false
+			}
+			text.Positions[ordinal].File = name
+		}
+		return text, true
+	}
+	for _, body := range bodies {
+		candidates := index[body.declaration.nativeName]
+		if len(candidates) != 1 {
+			return sdkASMDataContext("panic body lacks its unique independently compiled source association")
+		}
+		actual, valid := normalize(candidates[0])
+		selected, selectedValid := normalize(body.text)
+		if !valid || !selectedValid || !reflect.DeepEqual(actual, selected) {
+			return sdkASMDataContext("panic body differs between complete header compiler and actual selected archive")
+		}
+	}
+	return nil
+}
diff --git a/x86_go_panic_terminal_source_go127_test.go b/x86_go_panic_terminal_source_go127_test.go
new file mode 100644
index 000000000..51f0cbb2d
--- /dev/null
+++ b/x86_go_panic_terminal_source_go127_test.go
@@ -0,0 +1,128 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"errors"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Pure file reads only: this root executes no Go, LLVM, object or SDK command.
+func TestX86GoPanicTerminalActualSelected386CompilerSchema(t *testing.T) {
+	env := map[string]string{"GOVERSION": "go1.27.2", "GOOS": "linux", "GOARCH": "386", "GO386": "sse2"}
+	read := func(role string) ([]byte, error) {
+		return os.ReadFile(filepath.Join(runtime.GOROOT(), filepath.FromSlash(role)))
+	}
+	if err := x86GoPanicTerminalCompilerSources(env, read); err != nil {
+		t.Fatal("actual selected SDK compiler/linker source schema differs", err)
+	}
+	for role := range x86GoPanicTerminalCompilerSourceRoles() {
+		t.Run(role, func(t *testing.T) {
+			if err := x86GoPanicTerminalCompilerSources(env, func(name string) ([]byte, error) {
+				data, err := read(name)
+				if name == role && err == nil {
+					data[0] ^= 1
+				}
+				return data, err
+			}); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed actual producer bytes retained their registered source role", err)
+			}
+		})
+	}
+}
+
+// Close only at the final verification, after the private association has been
+// computed. An in-flight query owns one lease; its nested Verify owns another.
+type x86PanicTerminalPublicationContext struct {
+	context.Context
+	source *GoX86SDKASMDataSource
+	closed bool
+}
+
+func (ctx *x86PanicTerminalPublicationContext) Err() error {
+	ctx.source.mu.Lock()
+	final := ctx.source.active >= 2
+	ctx.source.mu.Unlock()
+	if final && !ctx.closed {
+		ctx.closed = true
+		if err := ctx.source.Close(); err != nil {
+			return err
+		}
+	}
+	return ctx.Context.Err()
+}
+
+func TestX86GoPanicTerminalOriginal386CompilerAndCALLAssociations(t *testing.T) {
+	for _, name := range []string{"complete-42-TEXT", "owned-source-artifact-revocation", "close-at-final-publication"} {
+		t.Run(name, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, "386", "internal/runtime/atomic")
+			source, err := captureGoX86SDKASMDataSourceRole(ctx, request, sdkASMDataOriginalSourceRole)
+			if err != nil {
+				t.Fatal("complete actual original386 source/compiler/ASM observation", err)
+			}
+			defer source.Close()
+			sdkASMDataDiagnosticRetainNamed(t, "-complete-original", source)
+			if len(source.observation.CPP) != 1 || len(source.observation.Objects.Sources) != 1 ||
+				strings.Count(string(source.observation.ObjectInputs.Sources[0].Original), "\nTEXT ") != 42 ||
+				len(source.observation.Objects.Sources[0].Original.Texts) != 42 {
+				t.Fatal("actual discovering source was truncated or had a different complete selection")
+			}
+			verification := ctx
+			var publication *x86PanicTerminalPublicationContext
+			if name == "close-at-final-publication" {
+				publication = &x86PanicTerminalPublicationContext{Context: ctx, source: source}
+				verification = publication
+			}
+			if name == "owned-source-artifact-revocation" {
+				file := filepath.Join(source.guard.owned, "go_asm.h")
+				original, err := os.ReadFile(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := os.WriteFile(file, append(append([]byte(nil), original...), []byte("\n// changed source artifact\n")...), 0600); err != nil {
+					t.Fatal(err)
+				}
+				observed, err := source.panicTerminalObservation(verification, &x86ResultFlowBudget{})
+				if observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed compiler/source artifact retained an association", observed, err)
+				}
+				if err := os.WriteFile(file, original, 0600); err != nil {
+					t.Fatal(err)
+				}
+				if observed, err := source.panicTerminalObservation(ctx, &x86ResultFlowBudget{}); observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("restoring source artifact bytes revived a revoked association", err)
+				}
+				return
+			}
+			observed, err := source.panicTerminalObservation(verification, &x86ResultFlowBudget{})
+			if publication != nil {
+				if !publication.closed || observed != nil || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Close during final callback published a partial original-source association", observed, err)
+				}
+				return
+			}
+			if err != nil || observed == nil || len(observed.bodies) != 1 || len(observed.calls) != 5 ||
+				observed.bodies[0].declaration.name != "panicUnaligned" || observed.bodies[0].text.ABI != 1 || observed.bodies[0].assemblyABI != 0 {
+				t.Fatal("actual complete42TEXT/SymABI/compiler/ABI0 CALL association differs", observed, err)
+			}
+			wanted := map[string]bool{"·Cas64": true, "·Xadd64": true, "·Xchg64": true, "·Load64": true, "·Store64": true}
+			for _, call := range observed.calls {
+				if !wanted[call.function] || call.target != "internal/runtime/atomic.panicUnaligned" {
+					t.Fatal("original actual CALL inventory lost its source owner/target", call)
+				}
+				delete(wanted, call.function)
+			}
+			if len(wanted) != 0 || source.guard.ready || len(source.observation.Frames) != 0 {
+				t.Fatal("association omitted an original CALL or acquired native frame authority", wanted)
+			}
+			t.Logf("complete original compiler/archive=%s, header=%x,42TEXT/5CALL, compilerABI1/sourceABI0; no capability/CFG/LLVM/runtime qualification",
+				source.observation.Objects.ArchiveSHA256, sha256.Sum256(source.observation.Header.CompilerObject))
+		})
+	}
+}
diff --git a/x86_go_panic_terminal_source_test.go b/x86_go_panic_terminal_source_test.go
new file mode 100644
index 000000000..0e1f9186b
--- /dev/null
+++ b/x86_go_panic_terminal_source_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+func TestX86GoPanicTerminalSourceCannotBeReconstructedFromReports(t *testing.T) {
+	for _, source := range []*GoX86SDKASMDataSource{nil, {}, {ready: true, generation: 1, captureRole: sdkASMDataOriginalSourceRole}} {
+		if source != nil {
+			source.identity = source
+		}
+		if observed, err := source.panicTerminalObservation(context.Background(), &x86ResultFlowBudget{}); !errors.Is(err, ErrProbeNeedsContext) || observed != nil {
+			t.Fatal("a caller value or report acquired a live actual-source association", observed, err)
+		}
+	}
+	actual := &GoX86SDKASMDataSource{}
+	actual.identity = actual
+	copy := new(GoX86SDKASMDataSource)
+	reflect.ValueOf(copy).Elem().Set(reflect.ValueOf(actual).Elem())
+	if observed, err := copy.panicTerminalObservation(context.Background(), &x86ResultFlowBudget{}); !errors.Is(err, ErrProbeNeedsContext) || observed != nil {
+		t.Fatal("copied source acquired original compiler-body association", observed, err)
+	}
+}
+
+func TestX86GoPanicTerminalGeneratedCompilerKeepsWholeBody(t *testing.T) {
+	pkg, symABI, objects := x86PanicTerminalCompilerFixture(t)
+	bodies, err := x86GoPanicTerminalCompilerBodies(pkg, symABI, objects, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86GoPanicTerminalGeneratedBodies(bodies, objects.Members[1].Texts, ""); err != nil {
+		t.Fatal("complete independently generated compiler body did not match its actual selected definition", err)
+	}
+	for name, mutate := range map[string]func(*gostaticstorage.TextRecord){
+		"code":        func(text *gostaticstorage.TextRecord) { text.Code[0] ^= 1 },
+		"ABI":         func(text *gostaticstorage.TextRecord) { text.ABI = 0 },
+		"source":      func(text *gostaticstorage.TextRecord) { text.Positions[0].File += ".other" },
+		"source-line": func(text *gostaticstorage.TextRecord) { text.Positions[0].Line++ },
+		"namespace":   func(text *gostaticstorage.TextRecord) { text.Namespace = gostaticstorage.TextSymbolNonpkgDefinition },
+		"auxiliary": func(text *gostaticstorage.TextRecord) {
+			text.Auxiliary = append(text.Auxiliary, gostaticstorage.TextAuxiliary{Type: 2})
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			text := x86GoPanicTerminalCloneText(objects.Members[1].Texts[0])
+			mutate(&text)
+			if err := x86GoPanicTerminalGeneratedBodies(bodies, []gostaticstorage.TextRecord{text}, ""); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("partial/different fresh compiler body acquired an association", err)
+			}
+		})
+	}
+}
+
+func TestX86GoPanicTerminalCompilerObservationDoesNotAliasInputs(t *testing.T) {
+	pkg, symABI, objects := x86PanicTerminalCompilerFixture(t)
+	bodies, err := x86GoPanicTerminalCompilerBodies(pkg, symABI, objects, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	bodies[0].text.Code[0] ^= 1
+	bodies[0].text.Positions[0].Line++
+	if objects.Members[1].Texts[0].Code[0] != 0xe8 || objects.Members[1].Texts[0].Positions[0].Line != 2 {
+		t.Fatal("returned diagnostic compiler bytes/positions changed the original complete observation")
+	}
+}
+
+func TestX86GoPanicTerminalCompilerSchemaNeedsActual386Producer(t *testing.T) {
+	for name, env := range map[string]map[string]string{
+		"missing":     nil,
+		"version":     {"GOVERSION": "go1.20.14", "GOOS": "linux", "GOARCH": "386", "GO386": "sse2"},
+		"target":      {"GOVERSION": "go1.27.2", "GOOS": "linux", "GOARCH": "amd64", "GO386": "sse2"},
+		"CPU":         {"GOVERSION": "go1.27.2", "GOOS": "linux", "GOARCH": "386", "GO386": "softfloat"},
+		"experiments": {"GOVERSION": "go1.27.2", "GOOS": "linux", "GOARCH": "386", "GO386": "sse2", "GOEXPERIMENT": "regabiwrappers"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := x86GoPanicTerminalCompilerSources(env, func(string) ([]byte, error) { t.Fatal("invalid profile consulted producer bytes"); return nil, nil }); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unobserved target/version/profile acquired an ABI normalization", err)
+			}
+		})
+	}
+}
diff --git a/x86_gp_faulting_read_obligation.go b/x86_gp_faulting_read_obligation.go
new file mode 100644
index 000000000..12309434d
--- /dev/null
+++ b/x86_gp_faulting_read_obligation.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "strings"
+
+// This is only a whole-function proof selector. An effect describes an access;
+// it cannot provide its address, numerical inputs, raw identity or native entry.
+// Keep the general effect directory's caller/frame admission domains unchanged.
+func x86GPFaultingReadNeedsProof(ins Instr, arch string) bool {
+	// Ordinary MOV and native atomics have complete existing grammars, but no
+	// general GP effect registration. Project only their memory-read obligation;
+	// do not register unconditional numerical writes for conditional exchanges.
+	if _, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch); known {
+		return err == nil
+	}
+	if spec, known := amd64ExchangeSpecs[Op(strings.ToUpper(string(ins.Op)))]; known {
+		form, err := parseAMD64ExchangeForm(arch, ins.Op, spec, ins)
+		return err == nil && x86FaultingReadMemoryOperand(form.other)
+	}
+	if form, known, err := x86CompareExchangeProperties(ins.Op, ins, arch); known {
+		return err == nil && !form.spec.pair && x86FaultingReadMemoryOperand(form.destination)
+	}
+	return false
+}
+
+func x86GPByteEffectReadsMemory(effect x86TypedByteEffect) bool {
+	for _, operand := range effect.operands {
+		if operand.read && x86FaultingReadMemoryOperand(operand.operand) {
+			return true // Dynamic bit strings still read; this grants no fixed span.
+		}
+	}
+	return false
+}
+
+func x86FaultingReadMemoryOperand(operand Operand) bool {
+	// FP is a logical byte view, while a symbol address literal is not a load.
+	// Native/virtual SP, segments and source ownership remain separate consumers.
+	return operand.Kind != OpFP && isAMD64MemoryOperand(operand)
+}
diff --git a/x86_gp_faulting_read_obligation_test.go b/x86_gp_faulting_read_obligation_test.go
new file mode 100644
index 000000000..39a053455
--- /dev/null
+++ b/x86_gp_faulting_read_obligation_test.go
@@ -0,0 +1,483 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These are independent source cases, not a production opcode registry or a
+// native-memory certificate. Existing family oracles supply their special rows.
+type x86GPFaultingReadCase struct {
+	family, instruction string
+	bytes               int
+	partner, carry      bool
+	accumulator, index  bool
+	native, write       bool
+	flagsResult         bool
+}
+
+func x86GPFaultingReadCases(arch string) []x86GPFaultingReadCase {
+	var rows []x86GPFaultingReadCase
+	for i, suffix := range "BWLQ" {
+		if arch == "386" && suffix == 'Q' {
+			continue
+		}
+		width := []int{1, 2, 4, 8}[i]
+		for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+			rows = append(rows, x86GPFaultingReadCase{
+				family: "alu", instruction: stem + string(suffix) + " MEM,BX", bytes: width,
+				partner: true, carry: stem == "ADC" || stem == "SBB",
+			})
+		}
+		rows = append(rows, x86GPFaultingReadCase{
+			family: "load", instruction: "MOV" + string(suffix) + " MEM,BX", bytes: width,
+		})
+		for _, stem := range []string{"XCHG", "XADD"} {
+			rows = append(rows, x86GPFaultingReadCase{
+				family: "exchange", instruction: stem + string(suffix) + " BX,MEM",
+				bytes: width, partner: true, native: true, write: true,
+			})
+			if stem == "XCHG" {
+				reverse := rows[len(rows)-1]
+				reverse.instruction = stem + string(suffix) + " MEM,BX"
+				rows = append(rows, reverse)
+			}
+		}
+	}
+	for _, row := range x86ExtensionNativeOracle {
+		if arch == "386" && row.amd64Only {
+			continue
+		}
+		rows = append(rows, x86GPFaultingReadCase{
+			family: "extension", instruction: row.op + " MEM,BX", bytes: row.source,
+		})
+	}
+	for _, op := range x86BitTestOracleNames(arch) {
+		width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[op[len(op)-1]]
+		for _, index := range []string{"$0", "CX"} {
+			rows = append(rows, x86GPFaultingReadCase{
+				family: "bit-test", instruction: op + " " + index + ",MEM", bytes: width,
+				index: index == "CX", write: op[:len(op)-1] != "BT",
+				flagsResult: true,
+			})
+		}
+	}
+	for _, suffix := range "WLQ" {
+		if arch == "386" && suffix == 'Q' {
+			continue
+		}
+		for _, row := range x86CallerExplicitIMULRows {
+			if !strings.Contains(row.instruction, "(DI)") {
+				continue
+			}
+			instruction := strings.ReplaceAll(row.instruction, "@", string(suffix))
+			rows = append(rows, x86GPFaultingReadCase{
+				family: "imul", instruction: strings.Replace(instruction, "(DI)", "MEM", 1),
+				bytes: map[rune]int{'W': 2, 'L': 4, 'Q': 8}[suffix], partner: !row.three,
+			})
+		}
+	}
+	for _, row := range x86CMPXCHGOriginalRows {
+		if row.pair || arch == "386" && row.bits == 64 {
+			continue
+		}
+		rows = append(rows, x86GPFaultingReadCase{
+			family: "cmpxchg", instruction: row.op + " BX,MEM", bytes: row.bits / 8,
+			partner: true, accumulator: true, native: true, write: true,
+		})
+	}
+	return rows
+}
+
+type x86GPFaultingFixture struct {
+	name, source, declaration string
+	label                     string
+	row                       x86GPFaultingReadCase
+	accept                    bool
+}
+
+func x86GPFaultingSource(row x86GPFaultingReadCase, arch, name, omission string, indexed, live bool) x86GPFaultingFixture {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var body strings.Builder
+	if omission == "numeric-base" {
+		fmt.Fprintf(&body, "%s $1,DX\n", move)
+	} else if omission != "base" {
+		fmt.Fprintf(&body, "%s p+0(FP),DX\n", move)
+	}
+	if row.partner && omission != "partner" {
+		fmt.Fprintf(&body, "%s $3,BX\n", move)
+	}
+	if row.accumulator && omission != "accumulator" {
+		fmt.Fprintf(&body, "%s $5,AX\n", move)
+	}
+	if row.index && omission != "bit-index" {
+		fmt.Fprintf(&body, "%s $1,CX\n", move)
+	}
+	address := "(DX)"
+	if indexed {
+		address = "-1(DX)(SI*2)"
+		if omission != "address-index" {
+			fmt.Fprintf(&body, "%s $1,SI\n", move)
+		}
+	}
+	if row.carry && omission != "carry" {
+		body.WriteString("CLC\n")
+	}
+	body.WriteString(strings.Replace(row.instruction, "MEM", address, 1) + "\n")
+	declaration := fmt.Sprintf("func %s(p *[32]byte)", name)
+	args := word
+	if live {
+		result := "BX"
+		if row.flagsResult {
+			body.WriteString("SETCS BL\n")
+		}
+		if row.accumulator {
+			result = "AX"
+		}
+		fmt.Fprintf(&body, "MOVB %s,ret+%d(FP)\n", result, word)
+		declaration += " uint8"
+		args++
+	}
+	body.WriteString("RET\n")
+	label := omission
+	if label == "" {
+		label = "complete"
+	}
+	return x86GPFaultingFixture{
+		name: name, source: fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s", name, args, body.String()),
+		declaration: declaration, label: fmt.Sprintf("live=%t/indexed=%t/%s", live, indexed, label),
+		// Ordinary paired numerical readers accept full NUM address bits.
+		// Original native RMW and flag-only memory owners remain separate.
+		row: row, accept: omission == "" || omission == "numeric-base" && !row.native && !row.flagsResult,
+	}
+}
+
+func x86GPFaultingRename(fixture x86GPFaultingFixture, name string) x86GPFaultingFixture {
+	fixture.source = strings.Replace(fixture.source, "·"+fixture.name+"(SB)", "·"+name+"(SB)", 1)
+	fixture.declaration = strings.Replace(fixture.declaration, "func "+fixture.name+"(", "func "+name+"(", 1)
+	fixture.name = name
+	return fixture
+}
+
+// At most 32 complete functions share one original-Go listing/object. Each
+// fixture keeps its own declaration and tests still translate negatives alone.
+func x86GPFaultingGoBatches(t *testing.T, arch string, fixtures []x86GPFaultingFixture) {
+	t.Helper()
+	for start := 0; start < len(fixtures); start += 32 {
+		end := start + 32
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		var source strings.Builder
+		for _, fixture := range fixtures[start:end] {
+			source.WriteString(fixture.source)
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil || listing == "" {
+			t.Fatal("actual Go must accept every complete source before input classification", err)
+		}
+	}
+	t.Logf("GP_FAULTING_READ_ORIGINAL_GO arch=%s complete_functions=%d", arch, len(fixtures))
+}
+
+func x86GPFaultingInputFixtures(row x86GPFaultingReadCase, arch string, live bool) []x86GPFaultingFixture {
+	var fixtures []x86GPFaultingFixture
+	omissions := []string{"", "base", "numeric-base"}
+	if row.partner {
+		omissions = append(omissions, "partner")
+	}
+	if row.carry {
+		omissions = append(omissions, "carry")
+	}
+	if row.accumulator {
+		omissions = append(omissions, "accumulator")
+	}
+	if row.index {
+		omissions = append(omissions, "bit-index")
+	}
+	for _, omission := range omissions {
+		fixtures = append(fixtures, x86GPFaultingSource(row, arch, "Value", omission, false, live))
+	}
+	fixtures = append(fixtures,
+		x86GPFaultingSource(row, arch, "Value", "", true, live),
+		x86GPFaultingSource(row, arch, "Value", "address-index", true, live))
+	return fixtures
+}
+
+func TestX86GPFaultingReadWholeFunctionInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86GPFaultingReadCases(arch)
+			want := map[string]int{"amd64": 95, "386": 67}[arch]
+			if len(rows) != want {
+				t.Fatal("complete A–G source-mode directory changed", len(rows), want)
+			}
+			var originals []x86GPFaultingFixture
+			for _, row := range rows {
+				for _, live := range []bool{false, true} {
+					for _, fixture := range x86GPFaultingInputFixtures(row, arch, live) {
+						name := fmt.Sprintf("Input%d", len(originals))
+						originals = append(originals, x86GPFaultingRename(fixture, name))
+					}
+				}
+			}
+			x86GPFaultingGoBatches(t, arch, originals)
+			for _, fixture := range originals {
+				t.Run(fixture.row.family+"/"+fixture.row.instruction+"/"+fixture.label, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, arch, testTargetTriple("linux", arch), api)
+							if fixture.accept {
+								if err != nil || ir == "" {
+									t.Fatal("INITIALIZED_POSITIVE_REJECTED", err, fixture.source)
+								}
+								if strings.HasSuffix(fixture.label, "/numeric-base") {
+									if !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", fixture.row.bytes*8)) {
+										t.Fatal("NUM address lost the exact GP faulting read width", fixture.row.bytes)
+									}
+									x86RequireNumericNativeSourceContext(t, fixture.source, fixture.declaration, arch)
+									x86NumericNativeAddressObject(t, ir, testTargetTriple("linux", arch))
+								}
+							} else if err == nil && ir != "" {
+								t.Fatal("MISSING_INPUT_ACCEPTED", fixture.label, fixture.source)
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("WRONG_REJECTION_CLASS", err, fixture.source)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPFaultingReadCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var fixtures []x86GPFaultingFixture
+			for _, row := range x86GPFaultingReadCases(target.arch) {
+				for _, live := range []bool{false, true} {
+					for _, indexed := range []bool{false, true} {
+						name := fmt.Sprintf("Read%d", len(fixtures))
+						fixtures = append(fixtures, x86GPFaultingSource(row, target.arch, name, "", indexed, live))
+					}
+				}
+			}
+			for start := 0; start < len(fixtures); start += 32 {
+				end := start + 32
+				if end > len(fixtures) {
+					end = len(fixtures)
+				}
+				t.Run(fmt.Sprintf("batch%02d", start/32), func(t *testing.T) {
+					batch := fixtures[start:end]
+					x86GPFaultingGoBatches(t, target.arch, batch)
+					var source, declarations strings.Builder
+					var names []string
+					for _, fixture := range batch {
+						source.WriteString(fixture.source)
+						declarations.WriteString(fixture.declaration + "\n")
+						names = append(names, fixture.name)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("INITIALIZED_BATCH_REJECTED", err)
+							}
+							for _, view := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+								bodies := x86StringMemoryFunctions(t, view, names)
+								for _, fixture := range batch {
+									body := bodies[fixture.name]
+									read := fmt.Sprintf("load volatile i%d,", fixture.row.bytes*8)
+									if fixture.row.native {
+										read = "asm sideeffect"
+										opcode := strings.ToLower(strings.Fields(fixture.row.instruction)[0])
+										if !strings.Contains(body, opcode) || !strings.Contains(body, "*m") {
+											t.Fatal("complete function lost its original native memory opcode", fixture.name, body)
+										}
+									}
+									if !strings.Contains(body, read) || fixture.row.write && !fixture.row.native && !strings.Contains(body, "store volatile") {
+										t.Fatal("complete function lost its actual observable read/write", fixture.name, fixture.row.instruction, body)
+									}
+								}
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPFaultingReadNonMemoryControls(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		lea := "LEAQ 3(AX)(CX*2),BX"
+		if target.arch == "386" {
+			lea = "LEAL 3(AX)(CX*2),BX"
+		}
+		var fixtures []x86GPFaultingFixture
+		for index, instruction := range []string{"ADDL CX,BX", "MOVBLZX AX,BX", "IMUL3L $7,AX,BX", "BSWAPL AX", lea, "NOPW (AX)", "NOP"} {
+			name := fmt.Sprintf("Control%d", index)
+			fixtures = append(fixtures, x86GPFaultingFixture{
+				name: name, label: instruction,
+				source:      fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, instruction),
+				declaration: "func " + name + "()",
+			})
+		}
+		x86GPFaultingGoBatches(t, target.arch, fixtures)
+		for _, fixture := range fixtures {
+			t.Run(target.triple+"/"+fixture.label, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("NONFAULTING_CONTROL_REJECTED", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86GPFaultingReadProjectionBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86GPFaultingReadCases(arch) {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				ins := x86YMMReadSource(t, strings.Replace(row.instruction, "MEM", "(DX)", 1))
+				original := ins
+				original.Args = append([]Operand(nil), ins.Args...)
+				gp, gpKnown, gpErr := x86TypedGPByteEffect(ins.Op, ins, arch)
+				universal, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if gpKnown {
+					if gpErr != nil || !known || err != nil {
+						t.Fatal("complete source changed its typed effect domain", gpErr, err)
+					}
+					want := gp
+					want.requiresResultProof = true
+					if !reflect.DeepEqual(universal, want) {
+						t.Fatal("routing projection changed more than its local mandatory bit", gp, universal)
+					}
+				} else if known || err != nil {
+					t.Fatal("private MOV/atomic routing registered a new general effect", known, err)
+				}
+				after, afterKnown, afterErr := x86TypedGPByteEffect(ins.Op, ins, arch)
+				if !reflect.DeepEqual(gp, after) || gpKnown != afterKnown || (gpErr == nil) != (afterErr == nil) ||
+					!reflect.DeepEqual(ins, original) {
+					t.Fatal("routing mutated the GP directory or original operands")
+				}
+			})
+		}
+		for _, instruction := range []string{"ADDL AX,BX", "LEAL 3(AX)(CX*2),BX", "NOPW (AX)"} {
+			ins := x86YMMReadSource(t, instruction)
+			gp, known, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+			universal, universalKnown, universalErr := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if !known || err != nil || !universalKnown || universalErr != nil || !reflect.DeepEqual(gp, universal) {
+				t.Fatal("non-memory GP/LEA/NOP summary changed", arch, instruction)
+			}
+		}
+		ins := x86YMMReadSource(t, "MOVUPS (DX),X1")
+		vector, known, err := x86TypedLegacyPackedMoveByteEffect(ins.Op, ins, arch)
+		universal, universalKnown, universalErr := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+		if !known || err != nil || !universalKnown || universalErr != nil || !reflect.DeepEqual(vector, universal) ||
+			x86GPFaultingReadNeedsProof(ins, arch) {
+			t.Fatal("GP routing expanded the vector effect domain", arch)
+		}
+	}
+}
+
+func TestX86GPFaultingReadUintptrRolePolicy(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		var fixtures []x86GPFaultingFixture
+		seen := make(map[string]bool)
+		for _, row := range x86GPFaultingReadCases(target.arch) {
+			if seen[row.family] {
+				continue
+			}
+			seen[row.family] = true
+			for _, live := range []bool{false, true} {
+				name := fmt.Sprintf("Numeric%d", len(fixtures))
+				fixture := x86GPFaultingSource(row, target.arch, name, "", false, live)
+				fixture.declaration = strings.Replace(fixture.declaration, "*[32]byte", "uintptr", 1)
+				fixtures = append(fixtures, fixture)
+			}
+		}
+		x86GPFaultingGoBatches(t, target.arch, fixtures)
+		for _, fixture := range fixtures {
+			t.Run(target.triple+"/"+fixture.row.family+"/"+fixture.label, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if !fixture.row.native && !fixture.row.flagsResult {
+							if err != nil || !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", fixture.row.bytes*8)) {
+								t.Fatal("uintptr lost its paired exact-width faulting read", err)
+							}
+							x86RequireNumericNativeSourceContext(t, fixture.source, fixture.declaration, target.arch)
+							x86NumericNativeAddressObject(t, ir, target.triple)
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("uintptr supplied a separate native RMW or flag-only memory role", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86GPFaultingReadIMULAddressAlias(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		var fixtures []x86GPFaultingFixture
+		for _, row := range x86GPFaultingReadCases(target.arch) {
+			if row.family != "imul" {
+				continue
+			}
+			three := strings.HasPrefix(row.instruction, "IMUL3")
+			name := fmt.Sprintf("Alias%d", len(fixtures))
+			fixture := x86GPFaultingSource(row, target.arch, name, "partner", false, false)
+			fixture.source = strings.ReplaceAll(fixture.source, "DX", "BX")
+			fixture.accept = three
+			fixtures = append(fixtures, fixture)
+		}
+		x86GPFaultingGoBatches(t, target.arch, fixtures)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				var source, declarations strings.Builder
+				for _, fixture := range fixtures {
+					if !fixture.accept {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("two-operand IMUL obtained old-destination NUM from its pointer role", err)
+						}
+						continue
+					}
+					source.WriteString(fixture.source)
+					declarations.WriteString(fixture.declaration + "\n")
+				}
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("three-operand IMUL overwrites its pointer destination after reading its address", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_gp_segment_read_obligation_test.go b/x86_gp_segment_read_obligation_test.go
new file mode 100644
index 000000000..6e0b6b589
--- /dev/null
+++ b/x86_gp_segment_read_obligation_test.go
@@ -0,0 +1,426 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86GPSegmentFixture struct {
+	x86GPFaultingFixture
+	segment, address, equivalent string
+}
+
+func x86GPSegmentSource(row x86GPFaultingReadCase, arch, name, segment, address, omission string, live bool) x86GPSegmentFixture {
+	kind := address
+	if kind == "fixed-one" {
+		kind = "fixed-zero"
+	}
+	setup, memory := x86SegmentMOVAddress(arch, segment, kind)
+	if address == "fixed-one" {
+		memory = "1(" + segment + ")"
+	}
+	memory = strings.ReplaceAll(memory, "BX", "DX")
+	missing := omission
+	if omission == "offset" {
+		missing = "base"
+	}
+	fixture := x86GPFaultingSource(row, arch, name, missing, false, live)
+	fixture.source = strings.Replace(fixture.source,
+		strings.Replace(row.instruction, "MEM", "(DX)", 1),
+		strings.Replace(row.instruction, "MEM", memory, 1), 1)
+	if omission != "pointer-offset" {
+		fixture.declaration = strings.Replace(fixture.declaration, "*[32]byte", "uintptr", 1)
+	}
+	if setup == "" {
+		move := "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		fixture.source = strings.Replace(fixture.source, move+" p+0(FP),DX\n", "", 1)
+	}
+	fixture.accept = omission == ""
+	fixture.label = fmt.Sprintf("%s/%s/live=%t/%s", segment, address, live, omission)
+	equivalent := ""
+	if strings.HasPrefix(address, "segment-index-scale") {
+		equivalent = fmt.Sprintf("%s/%s/%s/live=%t/%s", row.family, row.instruction, segment, live, omission)
+	}
+	return x86GPSegmentFixture{fixture, segment, address, equivalent}
+}
+
+// Read bytes from the independent real Go assembler listing. This deliberately
+// does not call a production source/operand-normalization observer.
+func x86GPSegmentListingBytes(t *testing.T, listing string, names []string) map[string][]byte {
+	t.Helper()
+	header := regexp.MustCompile(`^(\S+) STEXT\b.*\bsize=(\d+)`)
+	wanted := make(map[string]bool)
+	for _, name := range names {
+		wanted[name] = true
+	}
+	code := make(map[string][]byte)
+	sizes := make(map[string]int)
+	current := ""
+	for _, line := range strings.Split(listing, "\n") {
+		if match := header.FindStringSubmatch(line); len(match) != 0 {
+			current = strings.TrimSuffix(match[1], "<ABI0>")
+			// Go 1.20 retains the empty assembler package name in -S output.
+			current = strings.TrimPrefix(strings.TrimPrefix(current, "literal."), `"".`)
+			if wanted[current] {
+				var err error
+				sizes[current], err = strconv.Atoi(match[2])
+				if err != nil || sizes[current] == 0 {
+					t.Fatal("invalid actual Go text size", line, err)
+				}
+			}
+			continue
+		}
+		if line != "" && line[0] != ' ' && line[0] != '\t' {
+			current = "" // A following data symbol is outside this TEXT body.
+			continue
+		}
+		fields := strings.Fields(line)
+		if !wanted[current] || len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") {
+			continue
+		}
+		var row []byte
+		for _, field := range fields[1:] {
+			if len(field) != 2 {
+				break
+			}
+			value, err := hex.DecodeString(field)
+			if err != nil {
+				break
+			}
+			row = append(row, value[0])
+		}
+		if len(row) == 0 {
+			continue // Source instruction rows are not encoded-byte rows.
+		}
+		offset, err := strconv.ParseUint(strings.TrimPrefix(fields[0], "0x"), 16, 64)
+		if err != nil || int(offset) != len(code[current]) {
+			t.Fatal("noncontiguous actual Go bytes", current, line, err)
+		}
+		code[current] = append(code[current], row...)
+	}
+	for _, name := range names {
+		if len(code[name]) == 0 || len(code[name]) != sizes[name] {
+			t.Fatal("actual Go listing lost a complete source function", name, len(code[name]), sizes[name])
+		}
+	}
+	return code
+}
+
+func x86GPSegmentGoObjects(t *testing.T, arch string, fixtures []x86GPSegmentFixture) map[string][]byte {
+	t.Helper()
+	all := make(map[string][]byte)
+	for start := 0; start < len(fixtures); start += 32 {
+		end := start + 32
+		if end > len(fixtures) {
+			end = len(fixtures)
+		}
+		// The source/object helpers own TempDirs. Give each bounded batch
+		// its own cleanup scope instead of retaining all objects at the root.
+		if !t.Run(fmt.Sprintf("go-source-batch%d", start/32), func(t *testing.T) {
+			var source strings.Builder
+			var names []string
+			for _, fixture := range fixtures[start:end] {
+				source.WriteString(fixture.source)
+				names = append(names, fixture.name)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal("original complete segment source must assemble before classification", err)
+			}
+			for name, code := range x86GPSegmentListingBytes(t, listing, names) {
+				all[name] = code
+			}
+		}) {
+			t.Fatal("original complete segment source batch failed", start, end)
+		}
+	}
+	return all
+}
+
+func TestX86GPFaultingReadSegmentInputs(t *testing.T) {
+	x86GPSegmentInputs(t, x86GPFaultingReadCases, map[string]x86GPSegmentInputCount{
+		"amd64": {95, 9112, 1424, 27336},
+		"386":   {67, 6488, 1012, 19464},
+	})
+}
+
+type x86GPSegmentInputCount struct {
+	rows, fixtures, scaleClasses, apiChecks int
+}
+
+// Hash every original case and role in order, including the source and Go
+// declaration. This is an observation of the test matrix, not a production
+// instruction directory or a substitute for executing its API assertions.
+func x86GPSegmentInputIdentity(fixtures []x86GPSegmentFixture) string {
+	digest := sha256.New()
+	for _, fixture := range fixtures {
+		fmt.Fprintf(digest, "%q\n%q\n%q\n%q\n%q\n%q\n%q\n%t\n%#v\n",
+			fixture.name, fixture.source, fixture.declaration,
+			fixture.segment, fixture.address, fixture.equivalent,
+			fixture.label, fixture.accept, fixture.row)
+	}
+	return fmt.Sprintf("%x", digest.Sum(nil))
+}
+
+func x86GPSegmentInputs(t *testing.T, rows func(string) []x86GPFaultingReadCase, expected map[string]x86GPSegmentInputCount) {
+	t.Helper()
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			want, found := expected[arch]
+			if !found || len(expected) != 2 {
+				t.Fatal("missing independent segment matrix count", arch)
+			}
+			originalRows := rows(arch)
+			if len(originalRows) != want.rows {
+				t.Fatal("complete segment source-row denominator changed", len(originalRows), want.rows)
+			}
+			var fixtures []x86GPSegmentFixture
+			addresses := []string{"fixed-zero", "fixed-one", "fixed", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"}
+			for _, row := range originalRows {
+				for _, segment := range []string{"FS", "GS"} {
+					for _, address := range addresses {
+						omissions := []string{""}
+						if address == "base" || strings.HasPrefix(address, "segment-index-") {
+							omissions = append(omissions, "offset", "pointer-offset")
+						}
+						if row.partner {
+							omissions = append(omissions, "partner")
+						}
+						if row.carry {
+							omissions = append(omissions, "carry")
+						}
+						if row.accumulator {
+							omissions = append(omissions, "accumulator")
+						}
+						if row.index {
+							omissions = append(omissions, "bit-index")
+						}
+						for _, live := range []bool{false, true} {
+							for _, omission := range omissions {
+								name := fmt.Sprintf("Segment%d", len(fixtures))
+								fixtures = append(fixtures, x86GPSegmentSource(row, arch, name, segment, address, omission, live))
+							}
+						}
+					}
+				}
+			}
+			if len(fixtures) != want.fixtures {
+				t.Fatal("complete segment scenario denominator changed", len(fixtures), want.fixtures)
+			}
+			identity := x86GPSegmentInputIdentity(fixtures)
+			goBytes := x86GPSegmentGoObjects(t, arch, fixtures)
+			groups := make(map[string][]byte)
+			groupCount := make(map[string]int)
+			for _, fixture := range fixtures {
+				if fixture.equivalent == "" {
+					continue
+				}
+				if previous := groups[fixture.equivalent]; previous != nil && !bytes.Equal(previous, goBytes[fixture.name]) {
+					t.Fatal("actual Go segment annotation scales changed machine bytes", fixture.equivalent)
+				}
+				groups[fixture.equivalent] = goBytes[fixture.name]
+				groupCount[fixture.equivalent]++
+			}
+			for group, count := range groupCount {
+				if count != 4 {
+					t.Fatal("incomplete actual Go scale equivalence class", group, count)
+				}
+			}
+			if len(groups) != want.scaleClasses {
+				t.Fatal("complete segment scale-class denominator changed", len(groups), want.scaleClasses)
+			}
+			t.Logf("SEGMENT_ACTUAL_GO_ALL_ACCEPTED arch=%s functions=%d scale_classes=%d", arch, len(fixtures), len(groups))
+			bodies := make(map[string]string)
+			executed, verified := 0, 0
+			for start := 0; start < len(fixtures); start += 32 {
+				end := start + 32
+				if end > len(fixtures) {
+					end = len(fixtures)
+				}
+				t.Run(fmt.Sprintf("input-batch%d", start/32), func(t *testing.T) {
+					current := "before first case"
+					t.Cleanup(func() {
+						if t.Failed() {
+							t.Log("SEGMENT_CASE_WHEN_FAILED", current)
+						}
+					})
+					for _, fixture := range fixtures[start:end] {
+						for _, api := range []string{"text", "module", "Go"} {
+							current = fmt.Sprintf("arch=%s function=%s family=%s instruction=%q %s api=%s target=%s",
+								arch, fixture.name, fixture.row.family, fixture.row.instruction, fixture.label, api, testTargetTriple("linux", arch))
+							ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, arch, testTargetTriple("linux", arch), api)
+							executed++
+							if !fixture.accept {
+								if err == nil && ir != "" {
+									t.Error("SEGMENT_MISSING_INPUT_ACCEPTED", current, fixture.source)
+								} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Error("SEGMENT_NEGATIVE_WRONG_CLASS", current, err, fixture.source)
+								} else {
+									verified++
+								}
+								continue
+							}
+							if err != nil || ir == "" {
+								t.Error("SEGMENT_INITIALIZED_POSITIVE_REJECTED", current, err, fixture.source)
+								continue
+							}
+							if fixture.equivalent != "" {
+								body := x86StringMemoryFunction(t, ir, fixture.name)
+								body = strings.ReplaceAll(strings.SplitN(body, "\n", 2)[1], fixture.name, "FUNCTION")
+								key := api + "/" + fixture.equivalent
+								if previous, exists := bodies[key]; exists && previous != body {
+									t.Error("PUBLIC_SEGMENT_SCALE_IR_DIVERGED", current, key, previous, body)
+									continue
+								}
+								bodies[key] = body
+							}
+							verified++
+						}
+					}
+				})
+			}
+			if executed != want.apiChecks || verified != want.apiChecks {
+				t.Error("segment API matrix incomplete", arch, "executed", executed, "verified", verified, "expected", want.apiChecks)
+			}
+			if after := x86GPSegmentInputIdentity(fixtures); after != identity {
+				t.Error("original segment source matrix changed during execution", identity, after)
+			}
+			t.Logf("SEGMENT_MATRIX_CLOSED arch=%s functions=%d api_checks=%d verified=%d source_sha256=%s",
+				arch, len(fixtures), executed, verified, identity)
+		})
+	}
+}
+
+func TestX86GPFaultingReadSegmentObjects(t *testing.T) {
+	x86GPSegmentObjects(t, x86GPFaultingReadCases)
+}
+
+func x86GPSegmentObjects(t *testing.T, rows func(string) []x86GPFaultingReadCase) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var fixtures []x86GPSegmentFixture
+			for _, row := range rows(target.arch) {
+				for _, segment := range []string{"FS", "GS"} {
+					for _, address := range []string{"fixed-zero", "segment-index-scale8"} {
+						name := fmt.Sprintf("Access%d", len(fixtures))
+						fixtures = append(fixtures, x86GPSegmentSource(row, target.arch, name, segment, address, "", false))
+					}
+				}
+			}
+			for start := 0; start < len(fixtures); start += 32 {
+				end := start + 32
+				if end > len(fixtures) {
+					end = len(fixtures)
+				}
+				t.Run(fmt.Sprintf("batch%d", start/32), func(t *testing.T) {
+					batch := fixtures[start:end]
+					x86GPSegmentGoObjects(t, target.arch, batch)
+					var source, declarations strings.Builder
+					var names []string
+					for _, fixture := range batch {
+						source.WriteString(fixture.source)
+						declarations.WriteString(fixture.declaration + "\n")
+						names = append(names, fixture.name)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("SEGMENT_INITIALIZED_BATCH_REJECTED", err)
+							}
+							for _, view := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+								bodies := x86StringMemoryFunctions(t, view, names)
+								for _, fixture := range batch {
+									body := bodies[fixture.name]
+									space := 257
+									if fixture.segment == "GS" {
+										space = 256
+									}
+									if !strings.Contains(body, fmt.Sprintf("ptr addrspace(%d)", space)) ||
+										fixture.row.native && !strings.Contains(body, "asm sideeffect") ||
+										!fixture.row.native && !strings.Contains(body, fmt.Sprintf("load volatile i%d,", fixture.row.bytes*8)) {
+										t.Fatal("complete source lost exact hardware-segment access", fixture.name, body)
+									}
+								}
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86GPSegmentCompareRows(arch string) []x86GPFaultingReadCase {
+	var rows []x86GPFaultingReadCase
+	for i, suffix := range "BWLQ" {
+		if arch == "386" && suffix == 'Q' {
+			continue
+		}
+		for _, stem := range []string{"CMP", "TEST"} {
+			instruction := stem + string(suffix) + " MEM,BX"
+			if stem == "TEST" {
+				instruction = stem + string(suffix) + " BX,MEM"
+			}
+			rows = append(rows, x86GPFaultingReadCase{
+				family: "compare", instruction: instruction,
+				bytes: []int{1, 2, 4, 8}[i], partner: true, flagsResult: true,
+			})
+		}
+	}
+	return rows
+}
+
+func TestX86GPFaultingReadSegmentCompareInputs(t *testing.T) {
+	x86GPSegmentInputs(t, x86GPSegmentCompareRows, map[string]x86GPSegmentInputCount{
+		"amd64": {8, 832, 128, 2496},
+		"386":   {6, 624, 96, 1872},
+	})
+}
+
+func TestX86GPFaultingReadSegmentCompareObjects(t *testing.T) {
+	x86GPSegmentObjects(t, x86GPSegmentCompareRows)
+}
+
+func TestX86GPFaultingReadSegmentDoesNotAdmitPairCAS(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		ops := []string{"CMPXCHG8B", "CMPXCHG16B"}
+		if target.arch == "386" {
+			move, ops = "MOVL", ops[:1]
+		}
+		for _, op := range ops {
+			for _, segment := range []string{"FS", "GS"} {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-0\n%s $1,AX\n%s $2,BX\n%s $3,CX\n%s $4,DX\nCMP%s AX,AX\n%s 0(%s)\nRET\n",
+					move, move, move, move, strings.TrimPrefix(move, "MOV"), op, segment)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+segment+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("scalar segment continuation granted the separate pair-CAS role", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_gp_simd_native_store_contract_test.go b/x86_gp_simd_native_store_contract_test.go
new file mode 100644
index 000000000..3d04dea72
--- /dev/null
+++ b/x86_gp_simd_native_store_contract_test.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Independent named store inventory: Go's MOVD and MOVDQ2Q alias MOVQ,
+// while VMOVQ's memory width stays eight bytes even in mode32.
+var x86GPSIMDNativeStoreRows = []struct {
+	op    string
+	bytes int64
+}{
+	{"MOVL", 4}, {"MOVQ", 8}, {"MOVD", 8}, {"MOVDQ2Q", 8},
+	{"VMOVD", 4}, {"VMOVQ", 8},
+}
+
+func TestX86GPSIMDNativeStoreNumericalContinuation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86GPSIMDNativeStoreRows {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.op+" X0,(BX)")
+				form, known, err := x86GPSIMDTransferProperties(ins, arch)
+				if !known || err != nil || !form.memoryWrite || int64(form.bits/8) != row.bytes {
+					t.Fatal("complete named store grammar changed", form, err)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.pointerGP[3], state.gp[3], state.masks[1] = true, 0xff, true
+				before := state.clone()
+				if !x86ResultGPSIMDTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, before) {
+					t.Fatal("paired exact native store lost its input or changed numerical/storage facts")
+				}
+				if x86ResultGPSIMDTransfer(ins, form, &state, nil, 0, arch) {
+					t.Fatal("standalone observer acquired native write permission")
+				}
+				state = before.clone()
+				state.writeVector(0, 64, uint64(1)<<uint(row.bytes)-1, false)
+				minimal := state.clone()
+				if !x86ResultGPSIMDTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, minimal) {
+					t.Fatal("native store required or invented bytes above its exact scalar width")
+				}
+				for _, mutation := range []string{"physical", "address-size", "segment"} {
+					changed := ins
+					switch mutation {
+					case "physical":
+						changed.x86Encoded = true
+					case "address-size":
+						changed.x86AddressBits = 32
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					}
+					state = before.clone()
+					if x86ResultGPSIMDTransferWithNativeMemory(changed, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, before) {
+						t.Fatal("named store granted an unbound physical access", mutation)
+					}
+				}
+				for missing := int64(-1); missing < row.bytes; missing++ {
+					state = before.clone()
+					if missing < 0 {
+						state.pointerGP[3] = false
+					} else {
+						state.writeVector(0, 64, ^(uint64(1) << uint(missing)), false)
+					}
+					original := state.clone()
+					if x86ResultGPSIMDTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, original) {
+						t.Fatal("missing address/data acquired a native store or changed state", missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+// Retain the original native-read followed by native-store sequence as an
+// initialized positive, independently of missing-data/address controls.
+func TestX86GPSIMDNativeReadStoreCompositionFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range x86GPSIMDNativeStoreRows {
+				assembly, declaration := x86GPSIMDNativeFixture(fmt.Sprint("Copy", index), target.arch, row.op, "(DX)", "X0", 0)
+				load := row.op + " (DX),X0"
+				source.WriteString(strings.Replace(assembly, load, load+"\n"+row.op+" X0,(DX)", 1))
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete paired native read/store rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "load volatile i") != len(x86GPSIMDNativeStoreRows) ||
+							strings.Count(text, "store volatile i") != len(x86GPSIMDNativeStoreRows) {
+							t.Fatal("original separate volatile read/store effects were removed")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86GPSIMDNativeStoreVoidCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple, move, word := "x86_64-unknown-linux-gnu", "MOVQ", 8
+		if arch == "386" {
+			triple, move, word = "i386-unknown-linux-gnu", "MOVL", 4
+		}
+		for _, row := range x86GPSIMDNativeStoreRows {
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool=%t", arch, row.op, unused), func(t *testing.T) {
+					declaration, extent := "func Value(p *byte)", word
+					if unused {
+						declaration, extent = "func Value(p *byte,unused bool)", word+1
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),BX\n%s X0,(BX)\nRET\n", extent, move, row.op)
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if arch == "amd64" {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool invented the stored vector bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86GPSIMDNativeStorePortableBytes(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, originalTriple, move, word := "amd64", "x86_64-unknown-linux-gnu", "MOVQ", 8
+	if strconv.IntSize == 32 {
+		arch, originalTriple, move, word = "386", "i386-unknown-linux-gnu", "MOVL", 4
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	for index, row := range x86GPSIMDNativeStoreRows {
+		name := fmt.Sprint("Store", index)
+		fmt.Fprintf(&declarations, "func %s(p *byte,value uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),BX\nMOVQ value+%d(FP),X0\n%s X0,1(BX)\nRET\n",
+			name, word+8, move, word, row.op)
+		fmt.Fprintf(&prototypes, "extern void %s(void*,uint64_t);\n", name)
+		fmt.Fprintf(&rows, "{%s,%d},\n", name, row.bytes)
+	}
+	x86LEAActualTargetGoObject(t, arch, originalTriple, source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() + `
+static const struct { void (*run)(void*,uint64_t); unsigned width; } cases[] = {
+` + rows.String() + `};
+int main(void) {
+    for (unsigned row = 0; row < sizeof(cases)/sizeof(cases[0]); ++row) {
+        for (unsigned sample = 0; sample < 257; ++sample) {
+            uint8_t output[16], expected[16];
+            uint64_t value = UINT64_C(0x9876543210fedcba) * sample;
+            memset(output, 0xa5, sizeof(output));
+            memcpy(expected, output, sizeof(output));
+            for (unsigned byte = 0; byte < cases[row].width; ++byte)
+                expected[byte+2] = (uint8_t)(value >> (byte*8));
+            cases[row].run(output+1, value);
+            if (memcmp(output, expected, sizeof(output))) {
+                fprintf(stderr, "row=%u sample=%u store width or canary mismatch\n", row, sample);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete numerical native store rejected", err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "gp-simd-native-store",
+							triple, text, driver, nil, level)
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_horizontal_integer_result_test.go b/x86_horizontal_integer_result_test.go
new file mode 100644
index 000000000..68fea70bd
--- /dev/null
+++ b/x86_horizontal_integer_result_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86HorizontalIntegerResultInputsAndUpperAliases(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, opcode := range x86HorizontalIntegerOpcodes {
+			for _, bank := range []string{"legacy", "X", "Y"} {
+				row, width, destination := opcode+" X0,X1", 16, 1
+				if bank != "legacy" {
+					row, destination = "V"+opcode+" "+bank+"0,"+bank+"1,"+bank+"2", 2
+					if bank == "Y" {
+						width = 32
+					}
+				}
+				ins := x86YMMReadSource(t, row)
+				for input := 0; input < 2; input++ {
+					for hole := -1; hole < width; hole++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+						for index := 0; index < 3; index++ {
+							mask := x86CallerVectorByteMask(int64(width))
+							state.writeVector(index, 64, mask|0xa55aa55aa55aa55a, false)
+						}
+						if hole >= 0 {
+							state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(hole)), false)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != (hole < 0) || !accepted && !reflect.DeepEqual(state, before) {
+							t.Fatalf("%s/%s input%d hole%d: accepted=%t", arch, row, input, hole, accepted)
+						}
+						if accepted {
+							want := before.clone()
+							want.writeVector(destination, width, x86CallerVectorByteMask(int64(width)), bank == "legacy")
+							if !reflect.DeepEqual(state, want) {
+								t.Fatal("horizontal result changed unrelated state or upper aliases", arch, row)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86HorizontalIntegerVoidInputsThreeAPIs(t *testing.T) {
+	for _, opcode := range x86HorizontalIntegerOpcodes {
+		for _, bank := range []string{"legacy", "X", "Y"} {
+			row := opcode + " X0,X1"
+			if bank != "legacy" {
+				row = "V" + opcode + " " + bank + "0," + bank + "1," + bank + "2"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				source := "TEXT ·view(SB),4,$0-0\n" + row + "\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("uninitialized horizontal inputs accepted: %s/%s: %v", row, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86HorizontalIntegerInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	index := 0
+	for _, opcode := range x86HorizontalIntegerOpcodes {
+		for _, bank := range []string{"legacy", "X", "Y"} {
+			row := opcode + " X0,X1"
+			if bank != "legacy" {
+				row = "V" + opcode + " " + bank + "0," + bank + "1," + bank + "2"
+			}
+			name := fmt.Sprintf("horizontal%d", index)
+			index++
+			fmt.Fprintf(&declarations, "func %s(value [32]byte)\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-32\nVMOVDQU value+0(FP),Y0\nVMOVDQU value+0(FP),Y1\n%s\nRET\n", name, row)
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_ifma_input_test.go b/x86_ifma_input_test.go
new file mode 100644
index 000000000..95fac3469
--- /dev/null
+++ b/x86_ifma_input_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+func x86IFMACompleteInputObjects(t *testing.T, bank string) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				word, suffix := goWordSize(target.arch), "Q"
+				if word == 4 {
+					suffix = "L"
+				}
+				var source, declarations strings.Builder
+				count := 0
+				for _, name := range []string{"VPMADD52LUQ", "VPMADD52HUQ"} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if target.arch == "386" && !raw && mode != "plain" {
+							continue // Named frontend cap; physical raw rows remain in this matrix.
+						}
+						for _, input := range []string{bank + "0", "(SI)", "broadcast"} {
+							op, mask, operand := name, "", input
+							if input == "broadcast" {
+								op, operand = op+".BCST", "(SI)"
+							}
+							if mode != "plain" {
+								mask = "K1,"
+							}
+							if mode == "zero" {
+								op += ".Z"
+							}
+							instruction := op + " " + operand + "," + bank + "1," + mask + bank + "2"
+							if raw {
+								encoderArch := target.arch
+								if mode != "plain" {
+									encoderArch = "amd64" // Low registers/default SI address have the same physical row.
+								}
+								instruction = x86RawNumericalInstruction(t, encoderArch, instruction)
+							}
+							function := fmt.Sprint("IFMA", count)
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n"+
+								"MOV%s a+%d(FP),SI\nMOV%s b+%d(FP),BX\nMOV%s old+%d(FP),CX\n"+
+								"VMOVUPS (SI),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\n"+
+								"MOVL $-1431655766,AX\nKMOVD AX,K1\nPUSH%s $0\nPOPF%s\n%s\n"+
+								"VMOVUPS Z2,(DI)\nPUSHF%s\nPOP%s AX\nMOV%s AX,64(DI)\nRET\n",
+								function, 4*word, suffix, suffix, word, suffix, 2*word, suffix, 3*word,
+								suffix, suffix, instruction, suffix, suffix, suffix)
+							fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte)\n", function)
+							count++
+						}
+					}
+				}
+				want := 18
+				if target.arch == "386" && !raw {
+					want = 6
+				}
+				if count != want {
+					t.Fatal("complete IFMA source/mask/broadcast inventory changed", count, want)
+				}
+				x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+			})
+		}
+	}
+}
+
+func TestX86IFMACompleteXInputObjects(t *testing.T) { x86IFMACompleteInputObjects(t, "X") }
+func TestX86IFMACompleteYInputObjects(t *testing.T) { x86IFMACompleteInputObjects(t, "Y") }
+func TestX86IFMACompleteZInputObjects(t *testing.T) { x86IFMACompleteInputObjects(t, "Z") }
+
+func TestX86IFMADeadNativeInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+			for _, raw := range []bool{false, true} {
+				instruction := name + " (SI),X1,X2"
+				if raw {
+					instruction = x86RawNumericalInstruction(t, target.arch, instruction)
+				}
+				source := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead IFMA silently discarded its native input access", target, name, raw, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86IFMAPhysicalMode32MaskIsNotANamedFrontendLimit(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc required")
+	}
+	row := "VPMADD52LUQ X0,X1,K1,X2"
+	code := x86OrderingHintGoBytes(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+	var bytes strings.Builder
+	for _, b := range code[:len(code)-1] {
+		fmt.Fprintf(&bytes, "0x%02x ", b)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=i386-unknown-linux-gnu")
+	command.Stdin = strings.NewReader(bytes.String() + "\n")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil || !strings.Contains(strings.ToLower(string(output)), "vpmadd52luq") || strings.Contains(string(output), "warning:") {
+		t.Fatal("independent physical mode32 mask row did not assemble", err, string(output))
+	}
+	if _, n, known, err := decodedX86IFMAInstruction(code, 32); !known || err != nil || n != len(code)-1 {
+		t.Fatal("valid physical mode32 IFMA inherited the named frontend's operand cap", known, n, err)
+	}
+}
diff --git a/x86_ifma_physical_masks_test.go b/x86_ifma_physical_masks_test.go
new file mode 100644
index 000000000..d52c3753c
--- /dev/null
+++ b/x86_ifma_physical_masks_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86IFMAPhysicalMode32RetainsEveryMaskAndWidth(t *testing.T) {
+	count := 0
+	for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for mask := 1; mask <= 7; mask++ {
+				for _, zero := range []bool{false, true} {
+					op := name
+					if zero {
+						op += ".Z"
+					}
+					row := fmt.Sprintf("%s %s0,%s1,K%d,%s2", op, bank, bank, mask, bank)
+					// The named mode32 parser cannot express this physical
+					// four-operand row. Keep the original low-register bytes,
+					// then normalize them in the actual source architecture.
+					bytes := x86RawNumericalInstruction(t, "amd64", row)
+					file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+bytes+"RET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					file, err = normalizeX86RawFile(file, "386")
+					if err != nil {
+						t.Fatal("actual physical mode32 IFMA row rejected", row, err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					form, known, err := x86IFMAProperties(ins.Op, ins, "386")
+					if !known || err != nil || form.mask != 2 || form.zeroing != zero ||
+						ins.Args[form.mask].Reg != Reg(fmt.Sprint("K", mask)) || !x86RawIFMASource(ins, "386") {
+						t.Fatal("physical selector/zeroing was rewritten under named syntax", row, form, err)
+					}
+					count++
+				}
+			}
+		}
+	}
+	if count != 84 {
+		t.Fatal("complete physical IFMA mask/width inventory changed", count)
+	}
+}
+
+func TestX86IFMAStandaloneAndNativeMemoryAuthoritiesRemainSeparate(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"VPMADD52HUQ", "VPMADD52LUQ"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				ins := x86ScalarLaneInstruction(t, name+" (SI),"+bank+"1,"+bank+"2")
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+				state.pointerGP[6], state.gp[3], state.masks[1] = true, 0x55, true
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.writeVector(2, 64, ^uint64(0), false)
+				before := state.clone()
+				if accepted, known := x86ResultIFMAStep(ins, &state, nil, arch); !known || accepted ||
+					!reflect.DeepEqual(state, before) {
+					t.Fatal("standalone IFMA query obtained native memory or changed a failed state", arch, name, bank)
+				}
+				want := before.clone()
+				width := amd64VectorByteWidth(ins.Args[2].Reg)
+				want.writeVector(2, width, x86CallerVectorByteMask(int64(width)), false)
+				if accepted, known := x86LoweredIFMAStep(ins, &state, nil, arch); !known || !accepted ||
+					!reflect.DeepEqual(state, want) {
+					t.Fatal("paired IFMA lost its exact read or changed independent flags/pointer roles", arch, name, bank)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_immediate_blend_family_test.go b/x86_immediate_blend_family_test.go
new file mode 100644
index 000000000..4c118e17c
--- /dev/null
+++ b/x86_immediate_blend_family_test.go
@@ -0,0 +1,384 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Go/SDM directory: three legacy X rows and four VEX X/Y pairs.
+// A register/memory choice expands each of these eleven encoding rows twice.
+// None has EVEX, masks, broadcast, SAE, or a floating-point exception effect.
+type x86ImmediateBlendCase struct {
+	op     string
+	lane   int
+	width  int
+	legacy bool
+	memory bool
+	opcode byte
+}
+
+func x86ImmediateBlendCases() []x86ImmediateBlendCase {
+	var rows []x86ImmediateBlendCase
+	for _, member := range []struct {
+		op     string
+		lane   int
+		opcode byte
+	}{
+		{"PBLENDW", 2, 0x0e}, {"BLENDPS", 4, 0x0c}, {"BLENDPD", 8, 0x0d},
+		{"VPBLENDW", 2, 0x0e}, {"VPBLENDD", 4, 0x02},
+		{"VBLENDPS", 4, 0x0c}, {"VBLENDPD", 8, 0x0d},
+	} {
+		legacy := !strings.HasPrefix(member.op, "V")
+		widths := []int{16}
+		if !legacy {
+			widths = append(widths, 32)
+		}
+		for _, width := range widths {
+			for _, memory := range []bool{false, true} {
+				rows = append(rows, x86ImmediateBlendCase{member.op, member.lane, width, legacy, memory, member.opcode})
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86ImmediateBlendCase) bank() string {
+	if row.width == 32 {
+		return "Y"
+	}
+	return "X"
+}
+
+func (row x86ImmediateBlendCase) instruction(immediate string) string {
+	first := row.bank() + "0"
+	if row.memory {
+		first = "(BX)"
+	}
+	if row.legacy {
+		return fmt.Sprintf("%s $%s,%s,X2", row.op, immediate, first)
+	}
+	return fmt.Sprintf("%s $%s,%s,%s1,%s2", row.op, immediate, first, row.bank(), row.bank())
+}
+
+// Capture all complete original instruction bytes in one independent Go
+// listing. Mode32 VEX uses these actual low-bank bytes, not Go386's rejected
+// four-operand named spelling, and receives a separate LLVM32 physical prior.
+func x86ImmediateBlendOriginalCodes(t *testing.T) [][]byte {
+	t.Helper()
+	rows := x86ImmediateBlendCases()
+	var body strings.Builder
+	for _, row := range rows {
+		fmt.Fprintln(&body, row.instruction("0xa5"))
+	}
+	body.WriteString("RET")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String())
+	if len(rows) != 22 || len(pcs) != 23 || pcs[22] != int64(len(code)-1) || code[len(code)-1] != 0xc3 {
+		t.Fatal("independent complete Go blend byte/PC directory changed", len(rows), pcs, code)
+	}
+	var result [][]byte
+	for index := range rows {
+		result = append(result, append([]byte(nil), code[pcs[index]:pcs[index+1]]...))
+	}
+	for _, mode := range []int{32, 64} {
+		x86NumericalNativeRequireMC(t, code[:pcs[22]], mode, 22, "+sse4.1,+avx2")
+	}
+	return result
+}
+
+func TestX86ImmediateBlendCompleteGoEncodingRowsAndPhysicalPriors(t *testing.T) {
+	root := filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86")
+	legacy, err := os.ReadFile(filepath.Join(root, "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	vector, err := os.ReadFile(filepath.Join(root, "avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := func(source []byte) string { return strings.Join(strings.Fields(string(source)), "") }
+	a, v := compact(legacy), compact(vector)
+	if !strings.Contains(a, "varyxshuf=[]ytab{{Zibm_r,2,argList{Yu8,Yxm,Yxr}},}") {
+		t.Fatal("complete Go legacy immediate/X-memory/X yxshuf row changed")
+	}
+	if !strings.Contains(v, "var_yvblendpd=[]ytab{"+
+		"{zcase:Zvex_i_rm_v_r,zoffset:2,args:argList{Yu8,Yxm,Yxr,Yxr}},"+
+		"{zcase:Zvex_i_rm_v_r,zoffset:2,args:argList{Yu8,Yym,Yyr,Yyr}},}") {
+		t.Fatal("complete ordered Go X/Y immediate blend rows changed")
+	}
+	for _, row := range x86ImmediateBlendCases() {
+		if row.memory || row.width != 16 {
+			continue
+		}
+		if row.legacy {
+			want := fmt.Sprintf("{A%s,yxshuf,Pq,opBytes{0x3a,0x%02x,0}}", row.op, row.opcode)
+			if !strings.Contains(strings.ToLower(a), strings.ToLower(want)) {
+				t.Fatal("independent legacy SSE4.1 registration changed", row.op)
+			}
+		} else {
+			want := fmt.Sprintf("{as:A%s,ytab:_yvblendpd,prefix:Pavx,op:opBytes{"+
+				"avxEscape|vex128|vex66|vex0F3A|vexW0,0x%02x,"+
+				"avxEscape|vex256|vex66|vex0F3A|vexW0,0x%02x,}},", row.op, row.opcode, row.opcode)
+			if !strings.Contains(strings.ToLower(v), strings.ToLower(want)) {
+				t.Fatal("independent complete VEX-only encoding attributes changed", row.op)
+			}
+		}
+	}
+	codes := x86ImmediateBlendOriginalCodes(t)
+	var legacySource, physicalSource strings.Builder
+	legacySource.WriteString("TEXT named(SB),4,$0-0\n")
+	physicalSource.WriteString("TEXT physical(SB),4,$0-0\n")
+	for index, row := range x86ImmediateBlendCases() {
+		if row.legacy {
+			fmt.Fprintln(&legacySource, row.instruction("0xa5"))
+		} else if !row.memory && row.width == 16 {
+			requireX86GoAssemblerResult(t, "386", "TEXT bad(SB),4,$0-0\n"+row.instruction("0xa5")+"\nRET\n", false)
+		}
+		physicalSource.WriteString(x86RawDisplacementDirectives(codes[index]))
+	}
+	legacySource.WriteString("RET\n")
+	physicalSource.WriteString("RET\n")
+	x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", legacySource.String()+physicalSource.String())
+}
+
+func TestX86ImmediateBlendOriginalInitializedConformanceObjects(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const header = "TEXT ·immediatePackedBlendSemantics(SB), NOSPLIT, $0-24\n"
+	start := strings.Index(string(data), header)
+	if start < 0 {
+		t.Fatal("complete original eleven-form immediate blend function missing")
+	}
+	end := strings.Index(string(data[start:]), "\n\tRET\n")
+	if end < 0 {
+		t.Fatal("complete original immediate blend return missing")
+	}
+	source := "#include \"textflag.h\"\n" + string(data[start:start+end+len("\n\tRET\n")])
+	x86PackedFaultProgramObjects(t, source,
+		"func immediatePackedBlendSemantics(out *[240]byte, a,b *[32]byte)")
+}
+
+func x86ImmediateBlendInitializedProgram(row x86ImmediateBlendCase, code []byte, arch, name string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s a+%d(FP),BX\n%s b+%d(FP),CX\n",
+		name, 3*word, move, move, word, move, 2*word)
+	// Explicit numerical producers are independent of the blend itself.
+	fmt.Fprintf(&source, "VMOVUPS (BX),%s0\nVMOVUPS (CX),%s1\nVMOVUPS (CX),%s2\n", row.bank(), row.bank(), row.bank())
+	source.WriteString("MOVL $5,DX\nCMPL DX,$3\nSTD\n")
+	if code == nil {
+		fmt.Fprintln(&source, row.instruction("0xa5"))
+	} else {
+		source.WriteString(x86RawDisplacementDirectives(code))
+	}
+	fmt.Fprintf(&source, "VMOVUPS %s2,(DI)\nSETCS 32(DI)\nSETOS 33(DI)\nCLD\nRET\n", row.bank())
+	return source.String(), fmt.Sprintf("func %s(out *[34]byte, a,b *[32]byte)\n", name)
+}
+
+func TestX86ImmediateBlendInitializedNamedAndRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows, codes := x86ImmediateBlendCases(), x86ImmediateBlendOriginalCodes(t)
+	for _, target := range x86RawReturnTargets {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var source, declarations strings.Builder
+				count := 0
+				for index, row := range rows {
+					if target.arch == "386" && !raw && !row.legacy {
+						continue // The independent Go frontend rejects genuine named four-operand rows.
+					}
+					var code []byte
+					if raw {
+						code = codes[index]
+					}
+					body, declaration := x86ImmediateBlendInitializedProgram(row, code, target.arch, fmt.Sprint("Blend", count))
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+					count++
+				}
+				want := 22
+				if target.arch == "386" && !raw {
+					want = 6
+				}
+				if count != want {
+					t.Fatal("initialized complete family directory changed", count, want)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete initialized immediate blend family rejected", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, "-O0")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImmediateBlendSelectedBytesUpperAliasesAndIndependentState(t *testing.T) {
+	var directory strings.Builder
+	directory.WriteString("TEXT effects(SB),4,$0-0\n")
+	for _, row := range x86ImmediateBlendCases() {
+		if !row.memory {
+			fmt.Fprintln(&directory, row.instruction("0xa5"))
+		}
+	}
+	directory.WriteString("RET\n")
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", directory.String())
+	for _, row := range x86ImmediateBlendCases() {
+		if row.memory {
+			continue
+		}
+		t.Run(fmt.Sprintf("%s/%d", row.op, row.width), func(t *testing.T) {
+			for immediate := 0; immediate < 256; immediate++ {
+				ins := x86ScalarLaneInstruction(t, row.instruction(fmt.Sprint(immediate)))
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil || len(effect.operands) < 2 || !effect.requiresResultProof ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("complete typed immediate blend effect is absent or changes FLAGS", immediate, err)
+				}
+				for _, sparse := range []bool{false, true} {
+					state := x86FloatingHelperInitializedState()
+					second := 1
+					if row.legacy {
+						second = 2
+					}
+					if sparse {
+						state.writeVector(0, 64, 0x5151515151515151, false)
+						state.writeVector(second, 64, 0xa2a2a2a2a2a2a2a2, false)
+					}
+					before := state.clone()
+					var defined uint64
+					for output := 0; output < row.width; output++ {
+						source := second
+						if immediate>>(uint(output/row.lane)%8)&1 != 0 {
+							source = 0
+						}
+						defined |= (before.vectorBytes(source) >> uint(output) & 1) << uint(output)
+					}
+					want := before.clone()
+					want.writeVector(2, row.width, defined, row.legacy)
+					if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, want) {
+						t.Fatal("selector lost actual byte dependencies, aliases, FLAGS, DF, pointers or storage", immediate, sparse)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ImmediateBlendDeadReadsRetainNativeAccessAndMissingInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImmediateBlendCases() {
+			if !row.memory || arch == "386" && !row.legacy {
+				continue
+			}
+			for _, missing := range []string{"none", "pointer", "index"} {
+				t.Run(fmt.Sprintf("%s/%s/%d/%s", arch, row.op, row.width, missing), func(t *testing.T) {
+					prefix := move + " p+0(FP),BX\n"
+					if missing == "pointer" {
+						prefix = ""
+					}
+					operation := row.instruction("0") // No selected memory bytes, but original access still occurs.
+					if missing == "index" {
+						operation = strings.Replace(operation, "(BX)", "(BX)(SI*2)", 1)
+					}
+					for register := 0; register < 3; register++ {
+						prefix += fmt.Sprintf("VPXOR %s%d,%s%d,%s%d\n", row.bank(), register, row.bank(), register, row.bank(), register)
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s\nRET\n", word, prefix, operation)
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[32]byte)", arch, triple, api)
+						if missing != "none" {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("dead blend invented missing native address/index input", api, err)
+							}
+							continue
+						}
+						if err != nil || ir == "" {
+							t.Fatal("dead initialized original memory blend rejected", api, err)
+						}
+						body := x86StringMemoryFunction(t, x86DwordProductIROptimize(t, ir), "Value")
+						if row.legacy {
+							// Type4 legacy m128 alignment faults require the real opcode;
+							// an LLVM load with align16 is only a promise, not a check.
+							if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, strings.ToLower(row.op)) ||
+								!strings.Contains(body, "~{memory}") {
+								t.Fatal("dead legacy blend lost actual opcode/alignment/fault/cache-independent memory access", api)
+							}
+						} else if !strings.Contains(body, "load volatile ") &&
+							(!strings.Contains(body, "asm sideeffect") || !strings.Contains(body, strings.ToLower(row.op)) || !strings.Contains(body, "~{memory}")) {
+							t.Fatal("dead VEX blend lost its exact full native read", api)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImmediateBlendSelectedRegisterInputsCannotBeInvented(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImmediateBlendCases() {
+			if row.memory || arch == "386" && !row.legacy {
+				continue
+			}
+			for _, missing := range []int{-1, 0, 1} {
+				t.Run(fmt.Sprintf("%s/%s/%d/missing=%d", arch, row.op, row.width, missing), func(t *testing.T) {
+					var source strings.Builder
+					fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n", word, move)
+					for sourceIndex, register := range []int{0, 1} {
+						if sourceIndex == missing {
+							continue
+						}
+						if row.legacy && register == 1 {
+							register = 2
+						}
+						fmt.Fprintf(&source, "VPXOR %s%d,%s%d,%s%d\n", row.bank(), register, row.bank(), register, row.bank(), register)
+					}
+					fmt.Fprintf(&source, "%s\nVMOVUPS %s2,(DI)\nRET\n", row.instruction("0xa5"), row.bank())
+					x86LEAActualTargetGoObject(t, arch, triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Value(out *[32]byte)", arch, triple, api)
+						if missing < 0 {
+							if err != nil || ir == "" {
+								t.Fatal("complete explicit numerical source producers rejected", api, err)
+							}
+						} else if arch == "amd64" {
+							x86VectorScratchCodegenControl(t, source.String(), "func Value(out *[32]byte)", arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("a selected source or legacy old-destination byte became numerical without its producer", api, missing, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_immediate_blend_original_formats_test.go b/x86_immediate_blend_original_formats_test.go
new file mode 100644
index 000000000..ed172387b
--- /dev/null
+++ b/x86_immediate_blend_original_formats_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These are the unchanged original format directories, not initialized
+// programs. In particular, neither the native AX address nor vector inputs
+// come from the Void declaration or the emitter's implementation slots.
+func x86ImmediateBlendOriginalBareSource(t *testing.T, arch string) string {
+	t.Helper()
+	if arch == "386" {
+		return `
+TEXT immediatepackedblendforms386(SB),NOSPLIT,$0-0
+	PBLENDW $0, X0, X1
+	PBLENDW $255, (AX), X7
+	BLENDPS $0, X0, X1
+	BLENDPS $255, (AX), X7
+	BLENDPD $0, X0, X1
+	BLENDPD $255, (AX), X7
+	RET
+`
+	}
+	if arch != "amd64" {
+		t.Fatal("original immediate blend directory has no such architecture", arch)
+	}
+	var source strings.Builder
+	source.WriteString("TEXT immediatepackedblendforms(SB),NOSPLIT,$0-0\n")
+	for _, op := range []string{"PBLENDW", "BLENDPS", "BLENDPD"} {
+		fmt.Fprintf(&source, "\t%s $0, X0, X1\n", op)
+		fmt.Fprintf(&source, "\t%s $255, (AX), X15\n", op)
+	}
+	for _, op := range []string{"VPBLENDW", "VPBLENDD", "VBLENDPS", "VBLENDPD"} {
+		fmt.Fprintf(&source, "\t%s $0, X0, X1, X2\n", op)
+		fmt.Fprintf(&source, "\t%s $255, (AX), X1, X15\n", op)
+		fmt.Fprintf(&source, "\t%s $1, Y0, Y1, Y2\n", op)
+		fmt.Fprintf(&source, "\t%s $254, (AX), Y1, Y15\n", op)
+	}
+	source.WriteString("\tRET\n")
+	return source.String()
+}
+
+func x86ImmediateBlendOriginalBareRows(t *testing.T, arch string) (string, []Instr) {
+	t.Helper()
+	source := x86ImmediateBlendOriginalBareSource(t, arch)
+	wantRows, wantHash := 22, "3f692f45ed4ff1cf08ff81919c4fcdf202c915c74016db5d298fea0d805583df"
+	if arch == "386" {
+		wantRows, wantHash = 6, "fde15efad285edfdc316851fe0e561752175a763cc24b684c52d928b916732a2"
+	}
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != wantHash {
+		t.Fatal("original complete immediate blend source changed", arch)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != wantRows+2 {
+		t.Fatal("original TEXT/row/RET inventory changed", arch, err)
+	}
+	return source, file.Funcs[0].Instrs[1 : wantRows+1]
+}
+
+func TestX86ImmediateBlendOriginalBareSourcesKeepGoObjectsAndContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, _ := x86ImmediateBlendOriginalBareRows(t, target.arch)
+			// This helper first captures the actual complete Go object, then
+			// requires all three public APIs to retain the missing-input Context.
+			x86UnboundVoidFormatSources(t, source, target.arch, target.triple)
+		})
+	}
+}
+
+// Keep every original format in Go and LLVM objects without granting missing
+// public inputs. The independently initialized counterpart below covers each
+// original instruction through all three APIs and five physical targets.
+func x86ImmediateBlendOriginalBareFormatObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	source, _ := x86ImmediateBlendOriginalBareRows(t, arch)
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	ir := x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return c.lowerImmediatePackedBlend(instruction.Op, instruction)
+		})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete original blend format objects require LLVM22")
+	}
+	optimized := x86DwordProductIROptimize(t, ir)
+	for _, pipeline := range []struct{ body, level string }{
+		{ir, "-O0"}, {ir, "-O2"}, {optimized, "-O2"},
+	} {
+		x86PackedStringCompileObject(t, llc, triple, pipeline.body, pipeline.level)
+	}
+}
+
+func x86ImmediateBlendOriginalRowInitialized(row Instr, index int, arch string) (string, string) {
+	word, move, high := 8, "MOVQ", "Y15"
+	if arch == "386" {
+		word, move, high = 4, "MOVL", "Y7"
+	}
+	name := fmt.Sprintf("OriginalBlend%d", index)
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s a+%d(FP),AX\n%s b+%d(FP),BX\n",
+		name, word*3, move, move, word, move, word*2)
+	for _, register := range []string{"Y0", "Y1", "Y2", high} {
+		fmt.Fprintf(&source, "VMOVUPS (BX),%s\n", register)
+	}
+	fmt.Fprintln(&source, row.Raw)
+	destination := row.Args[len(row.Args)-1].Reg
+	fmt.Fprintf(&source, "VMOVUPS Y%s,(DI)\nRET\n", destination[1:])
+	return source.String(), fmt.Sprintf("func %s(out,a,b *[32]byte)\n", name)
+}
+
+func TestX86ImmediateBlendEveryOriginalRowHasInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete original-row objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			_, rows := x86ImmediateBlendOriginalBareRows(t, target.arch)
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				body, declaration := x86ImmediateBlendOriginalRowInitialized(row, index, target.arch)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual initialized counterpart lost an original blend row", err)
+					}
+					optimized := x86DwordProductIROptimize(t, ir)
+					for _, pipeline := range []struct{ body, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {optimized, "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.body, pipeline.level)
+					}
+				})
+			}
+			// Remove only a required native input from otherwise identical
+			// initialized programs. A missing address cannot be mistaken for
+			// an absent unrelated vector producer or a faulty test declaration.
+			for index, row := range rows {
+				if row.Args[1].Kind != OpMem {
+					continue
+				}
+				body, declaration := x86ImmediateBlendOriginalRowInitialized(row, index, target.arch)
+				word, move := 8, "MOVQ"
+				if target.arch == "386" {
+					word, move = 4, "MOVL"
+				}
+				missing := strings.Replace(body, fmt.Sprintf("%s a+%d(FP),AX\n", move, word), "", 1)
+				if missing == body {
+					t.Fatal("required native input mutation did not apply")
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, missing, declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original memory blend invented its removed address input", row.Raw, api, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_immediate_blend_raw_replay_test.go b/x86_immediate_blend_raw_replay_test.go
new file mode 100644
index 000000000..638977940
--- /dev/null
+++ b/x86_immediate_blend_raw_replay_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ImmediateBlendRawWholeProducerReplayBoundaries(t *testing.T) {
+	rows, codes := x86ImmediateBlendCases(), x86ImmediateBlendOriginalCodes(t)
+	for _, arch := range []string{"amd64", "386"} {
+		var prior strings.Builder
+		for index, row := range rows {
+			source, _ := x86ImmediateBlendInitializedProgram(row, codes[index], arch, fmt.Sprint("Prior", index))
+			prior.WriteString(source)
+		}
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String())
+		for index, row := range rows {
+			source, declaration := x86ImmediateBlendInitializedProgram(row, codes[index], arch, "Value")
+			check := x86LegacyFloatReplayCheck(t, arch, source, declaration)
+			for _, mutation := range []string{
+				"valid", "origin", "missing-replay", "producer", "opcode", "spelling", "original-bytes", "snapshot",
+			} {
+				t.Run(fmt.Sprintf("%s/%s/%d/memory=%t/%s", arch, row.op, row.width, row.memory, mutation), func(t *testing.T) {
+					file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+					if err != nil || len(file.Funcs) != 1 {
+						t.Fatal("actual Go/LLVM-accepted original whole producer could not decode its physical blend", err)
+					}
+					original, ordinal := file.Funcs[0], -1
+					for position, ins := range original.Instrs {
+						if ins.Op == Op(row.op) && ins.x86SourceRaw != nil {
+							if ordinal >= 0 {
+								t.Fatal("ambiguous original blend instruction")
+							}
+							ordinal = position
+						}
+					}
+					if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("complete original producer lost its sealed raw identity")
+					}
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					instruction := &candidate.Instrs[ordinal]
+					switch mutation {
+					case "origin":
+						instruction.x86SourceRaw = nil
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "opcode":
+						instruction.Op = "BLENDPS"
+						if row.op == "BLENDPS" {
+							instruction.Op = "BLENDPD"
+						}
+					case "spelling":
+						instruction.Raw += " changed"
+					case "original-bytes", "snapshot":
+						replay := *original.x86RawReplay
+						if mutation == "original-bytes" {
+							replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+						} else {
+							replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+							replay.normalized[ordinal].Raw += " changed"
+						}
+						candidate.x86RawReplay = &replay
+					}
+					err = check(candidate)
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("whole initialized original raw blend producer rejected", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("real whole-Func consumer accepted edited original blend/source identity", err)
+					}
+					if original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("mutating a clone corrupted its independently sealed original producer")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImmediateBlendVEXWIGAndReservedWPhysicalForms(t *testing.T) {
+	rows, codes := x86ImmediateBlendCases(), x86ImmediateBlendOriginalCodes(t)
+	for index, row := range rows {
+		if row.legacy {
+			continue
+		}
+		code := append([]byte(nil), codes[index]...)
+		if len(code) < 6 || code[0] != 0xc4 || code[2]&0x80 != 0 {
+			t.Fatal("independent Go instruction lost its W0 VEX envelope", row, code)
+		}
+		code[2] |= 0x80
+		for _, mode := range []int{32, 64} {
+			t.Run(fmt.Sprintf("%s/%d/memory=%t/mode=%d", row.op, row.width, row.memory, mode), func(t *testing.T) {
+				// Intel: three members are WIG; VPBLENDD alone is W0 (#UD at W1).
+				if row.op != "VPBLENDD" {
+					x86NumericalNativeRequireMC(t, code, mode, 1, "+sse4.1,+avx2")
+				}
+				ins, length, known, err := decodedX86ImmediatePackedBlendInstruction(code, mode)
+				if row.op == "VPBLENDD" {
+					if !known || err == nil {
+						t.Fatal("reserved VEX.W1 VPBLENDD acquired valid numerical form", ins, err)
+					}
+				} else if !known || err != nil || length != len(code) || ins.Op != Op(row.op) {
+					t.Fatal("official WIG physical form rejected as frontend named grammar or W0-only", ins, length, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImmediateBlendIntegerExpressionsAndInvalidGrammar(t *testing.T) {
+	for _, row := range x86ImmediateBlendCases() {
+		if row.memory || row.width != 16 {
+			continue
+		}
+		for _, immediate := range []string{"(1<<7)|37", "255-90", "(0xa0|5)", "0xa5+0"} {
+			t.Run(row.op+"/"+immediate, func(t *testing.T) {
+				// Go's full integer grammar is the prior, not our ImmRaw parser.
+				operation := row.instruction(immediate)
+				source := "TEXT ·Value(SB),4,$0-4\nPXOR X0,X0\nPXOR X1,X1\nPXOR X2,X2\n" + operation + "\nMOVL X2,ret+0(FP)\nRET\n"
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+						t.Fatal("actual Go integer expression lost its existing initialized named role", api, err)
+					}
+				}
+			})
+		}
+		for _, suffix := range []string{".", ".Z", ".BCST", ".SAE", ".RN_SAE", ".Z.Z"} {
+			t.Run(row.op+suffix, func(t *testing.T) {
+				operation := strings.Replace(row.instruction("0xa5"), row.op, row.op+suffix, 1)
+				if suffix == "." {
+					_, err := Parse(ArchAMD64, "TEXT invalid(SB),4,$0-0\n"+operation+"\nRET\n")
+					if err == nil || !strings.Contains(err.Error(), "instruction suffix expected identifier") {
+						t.Fatal("actual parser lost its independent trailing-dot rejection", err)
+					}
+					t.Log("original malformed source remains rejected by the parser:", err)
+				}
+				// Exercise the lowerer's independent grammar too, without asking
+				// a helper to parse the very syntax that must already be rejected.
+				ins := x86ScalarLaneInstruction(t, row.instruction("0xa5"))
+				ins.Op, ins.Raw = Op(row.op+suffix), operation
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				before := output.String()
+				known, _, err := ctx.lowerImmediatePackedBlend(ins.Op, ins)
+				if !known || err == nil || output.String() != before {
+					t.Fatal("invalid suffix absent from the complete Go optab emitted a blend", operation, known, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_immediate_compare_values_test.go b/x86_immediate_compare_values_test.go
new file mode 100644
index 000000000..25b4aea3b
--- /dev/null
+++ b/x86_immediate_compare_values_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ImmediateCompareReference(a, b uint64, bits int, unsigned bool, predicate int) bool {
+	if !unsigned {
+		// A sign-bit bias compares arbitrary lane widths without relying on
+		// the host integer's signed width or reproducing an LLVM predicate.
+		a ^= uint64(1) << uint(bits-1)
+		b ^= uint64(1) << uint(bits-1)
+	}
+	switch predicate & 7 {
+	case 0:
+		return a == b
+	case 1:
+		return a < b
+	case 2:
+		return a <= b
+	case 3:
+		return false
+	case 4:
+		return a != b
+	case 5:
+		return a >= b
+	case 6:
+		return a > b
+	default:
+		return true
+	}
+}
+
+func TestX86ImmediatePackedComparePredicatesMasksAndOrder(t *testing.T) {
+	for _, op := range x86ImmediateCompareResultMembers {
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[op[len(op)-1]]
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, predicate := range []int{0, 1, 2, 3, 4, 5, 6, 7, 255} {
+				t.Run(fmt.Sprintf("%s/%s/%d", op, bank, predicate), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-32\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ mask+16(FP),CX\n"+
+						"MOVQ AX,X0\nMOVQ BX,X1\nVPBROADCASTQ X0,Z0\nVPBROADCASTQ X1,Z1\nKMOVQ CX,K2\n"+
+						"%s $%d,%s1,%s0,K2,K2\nKMOVQ K2,AX\nMOVQ AX,ret+24(FP)\nRET\n", op, predicate, bank, bank)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(a,b,mask uint64) uint64", "amd64", "x86_64-unknown-linux-gnu", "text")
+					if err != nil {
+						t.Fatal("complete predicate/mask source", err)
+					}
+					var calls, tupleType strings.Builder
+					var want []uint64
+					for _, values := range [][2]uint64{{0, 0}, {1, 2}, {^uint64(0), 0}, {0x8080808080808080, 0x7f7f7f7f7f7f7f7f}} {
+						for _, mask := range []uint64{0, 1, 0x55aa55aa55aa55aa, ^uint64(0)} {
+							index := len(want)
+							fmt.Fprintf(&calls, " %%r%d = call i64 @Value(i64 %d,i64 %d,i64 %d)\n", index, values[0], values[1], mask)
+							var expected uint64
+							for lane := 0; lane < width*8/bits; lane++ {
+								shift := uint(lane % (64 / bits) * bits)
+								laneMask := ^uint64(0) >> uint(64-bits)
+								a, b := values[0]>>shift&laneMask, values[1]>>shift&laneMask
+								if mask&(uint64(1)<<uint(lane)) != 0 && x86ImmediateCompareReference(a, b, bits, strings.HasPrefix(op, "VPCMPU"), predicate) {
+									expected |= uint64(1) << uint(lane)
+								}
+							}
+							want = append(want, expected)
+						}
+					}
+					// Keep a nonzero observer canary so an all-false result is
+					// a ConstantStruct, not an uninspectable aggregate zero.
+					want = append(want, 0x13579bdf)
+					for range want {
+						if tupleType.Len() != 0 {
+							tupleType.WriteString(", ")
+						}
+						tupleType.WriteString("i64")
+					}
+					typ := "{ " + tupleType.String() + " }"
+					previous := "poison"
+					for index := range want {
+						value := fmt.Sprintf("%%r%d", index)
+						if index == len(want)-1 {
+							value = "324508639"
+						}
+						fmt.Fprintf(&calls, " %%tuple%d = insertvalue %s %s, i64 %s, %d\n", index, typ, previous, value, index)
+						previous = fmt.Sprintf("%%tuple%d", index)
+					}
+					probe := fmt.Sprintf("\ndefine %s @Probe() {\n%s ret %s %s\n}\n", typ, calls.String(), typ, previous)
+					x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", want)
+				})
+			}
+		}
+	}
+}
diff --git a/x86_immediate_control_roles_test.go b/x86_immediate_control_roles_test.go
new file mode 100644
index 000000000..f35ff8c97
--- /dev/null
+++ b/x86_immediate_control_roles_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86ImmediateControlHelpersRetainIntegerBoundaries(t *testing.T) {
+	for bits := 1; bits < 63; bits++ {
+		unsigned, signed := int64(1)<<bits, int64(1)<<(bits-1)
+		for _, value := range []int64{-signed - 1, -signed, -1, 0, signed - 1, signed, unsigned - 1, unsigned} {
+			operand := Operand{Kind: OpImm, Imm: value}
+			if amd64UnsignedImmediate(operand, bits) != (value >= 0 && value < unsigned) ||
+				amd64SignedImmediate(operand, bits) != (value >= -signed && value < signed) {
+				t.Fatal("integer control boundary changed", bits, value)
+			}
+		}
+	}
+	for _, value := range []int64{-129, -128, -1, 0, 127, 128, 255, 256} {
+		if amd64VectorByteShiftImmediate(Operand{Kind: OpImm, Imm: value}) != (value >= -128 && value <= 255) {
+			t.Fatal("encoded byte control boundary changed", value)
+		}
+	}
+}
+
+func TestX86ImmediateControlHelpersRejectNonIntegerRoles(t *testing.T) {
+	for name, check := range map[string]func(Operand) bool{
+		"unsigned": func(operand Operand) bool { return amd64UnsignedImmediate(operand, 8) },
+		"signed":   func(operand Operand) bool { return amd64SignedImmediate(operand, 8) },
+		"byte":     amd64VectorByteShiftImmediate,
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, operand := range []Operand{
+				{Kind: OpImm, Imm: 0, ImmIsFloat: true},
+				{Kind: OpImm, Imm: 0, ImmRaw: "UNRESOLVED"},
+				{Kind: OpReg, Reg: AX},
+				{Kind: OpSym, Sym: "control(SB)"},
+			} {
+				if check(operand) {
+					t.Errorf("control invented a resolved integer from another operand role: %#v", operand)
+				}
+			}
+		})
+	}
+}
+
+func TestX86GFNIImmediateFloatZeroRejectedLikeGo(t *testing.T) {
+	for _, op := range []string{"VGF2P8AFFINEQB", "VGF2P8AFFINEINVQB"} {
+		t.Run(op, func(t *testing.T) {
+			instruction := op + " $0.0,Z0,Z1,Z2"
+			goAssemblerOracleOutput(t, "amd64", "TEXT ·Value(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if _, known, err := x86GFNIProperties(ins.Op, ins, "amd64"); !known || err == nil {
+				t.Fatal("GFNI FLOAT zero became Yu8", err)
+			}
+			positive := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $0,Z0,Z1,Z2", op))
+			if _, known, err := x86GFNIProperties(positive.Op, positive, "amd64"); !known || err != nil {
+				t.Fatal("integer-zero control lost its original format", err)
+			}
+		})
+	}
+}
diff --git a/x86_immediate_shuffle_native_continuation_test.go b/x86_immediate_shuffle_native_continuation_test.go
new file mode 100644
index 000000000..dcb99c6e9
--- /dev/null
+++ b/x86_immediate_shuffle_native_continuation_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The independent complete Go rows and selector oracle live in
+// amd64_immediate_shuffle_family_test.go. This matrix closes the missing
+// ordinary native-read consumer, not a caller, alignment or raw-entry role.
+func x86ImmediateShuffleNativePrograms(arch string) (string, string, int) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range []string{"PSHUFL", "PSHUFD", "PSHUFHW", "PSHUFLW", "VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		legacy := !strings.HasPrefix(op, "V")
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if legacy && bank != "X" {
+				continue
+			}
+			for mode := 0; mode < 3; mode++ {
+				if (legacy || arch == "386") && mode != 0 {
+					continue // Go's named mode32 arity, not a physical raw restriction.
+				}
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && op != "VPSHUFD" {
+						continue
+					}
+					name := fmt.Sprintf("NativeShuffle%d", count)
+					count++
+					suffix, mask := "", ""
+					if broadcast {
+						suffix = ".BCST"
+					}
+					if mode == 2 {
+						suffix += ".Z"
+					}
+					if mode != 0 {
+						mask = "K1,"
+					}
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),AX\n%s out+%d(FP),BX\n"+
+						"KMOVQ mask+%d(FP),K1\nVXORPS X1,X1,X1\nSTC\n%s%s $27,(AX),%s%s1\n"+
+						"VMOVUPS Z1,(BX)\nSETCS 64(BX)\nRET\n",
+						name, 2*word+8, move, move, word, 2*word, op, suffix, mask, bank)
+					fmt.Fprintf(&declarations, "func %s(input,out *byte,mask uint64)\n", name)
+				}
+			}
+		}
+	}
+	return source.String(), declarations.String(), count
+}
+
+func TestX86ImmediateShuffleInitializedNativeReadCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete native shuffle objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, count := x86ImmediateShuffleNativePrograms(target.arch)
+			want := 40
+			if target.arch == "386" {
+				want = 16
+			}
+			if count != want {
+				t.Fatal("complete source-format denominator changed", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized full-tuple/broadcast shuffle lost its paired native read", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "native-shuffle.ll", "native-shuffle.o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ImmediateShuffleNativeReadDoesNotInventInputsOrQueryRights(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source, declarations, count := x86ImmediateShuffleNativePrograms(arch)
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, replacement := range []string{"", move + " $1,AX\n"} {
+			changed := strings.ReplaceAll(source, move+" input+0(FP),AX\n", replacement)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, arch, triple, api)
+				if replacement != "" {
+					if err != nil || ir == "" || !strings.Contains(ir, "load volatile ") {
+						t.Fatal("defined NUM addresses lost the full native shuffle program", arch, api, err)
+					}
+					for index := 0; index < count; index++ {
+						body := x86StringMemoryFunction(t, ir, fmt.Sprintf("NativeShuffle%d", index))
+						if !strings.Contains(body, "load volatile ") &&
+							!(strings.Contains(body, "asm sideeffect") && strings.Contains(body, "~{memory}")) {
+							t.Fatal("NUM shuffle function lost its original tuple access", index)
+						}
+					}
+					x86RequireNumericNativeSourceContext(t, changed, declarations, arch)
+					x86NumericNativeAddressObject(t, ir, triple)
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("native tuple borrowed missing/merely numerical pointer inputs", arch, api, err)
+				}
+			}
+		}
+		instruction := x86ScalarLaneInstruction(t, "VPSHUFD.BCST $27,(AX),Z1")
+		state := x86ResultState{flags: x86ByteFlagsAll}
+		state.pointerGP[0], state.callerAddressGP[0] = true, true
+		if accepted, known := x86ResultImmediateShuffleStep(instruction, &state, nil, arch); accepted || !known {
+			t.Fatal("standalone result query acquired a paired native-read contract", arch, accepted, known)
+		}
+	}
+	for _, mutation := range []struct{ before, after string }{
+		{"KMOVQ mask+16(FP),K1\n", ""},
+		{"VXORPS X1,X1,X1\n", ""},
+	} {
+		source, declarations, _ := x86ImmediateShuffleNativePrograms("amd64")
+		changed := strings.ReplaceAll(source, mutation.before, mutation.after)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+			if mutation.before == "VXORPS X1,X1,X1\n" {
+				x86VectorScratchCodegenControl(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("merge shuffle invented actual mask/old-destination bytes", api, err)
+			}
+		}
+	}
+}
diff --git a/x86_implicit_divide_fault_driver_test.go b/x86_implicit_divide_fault_driver_test.go
new file mode 100644
index 000000000..2982d77a6
--- /dev/null
+++ b/x86_implicit_divide_fault_driver_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+// The reference executes the actual ISA opcode, independently of translated
+// object code. Setup, normal exits and missing exact entry receipts never count
+// as a fault. No signal handler converts #DE into an ordinary successful exit.
+func x86DivideNativeFaultsC(prototypes, rows, samples string) string {
+	return x86MemoryFaultSupportC + prototypes + `
+struct kernel {
+    void (*run)(uint64_t *,uint64_t,uint64_t,uint64_t);
+    unsigned bits,signed_division,memory;
+};
+static const struct kernel kernels[]={
+` + rows + `};
+struct sample {unsigned row; uint64_t low,high,divisor,operand;};
+static const struct sample samples[]={
+` + samples + `};
+` + x86DivideNativeFaultMainC
+}
+
+const x86DivideNativeFaultMainC = `
+#define BYTE_DIV(operation) do { \
+    uint16_t a=(uint16_t)s.low; \
+    uint8_t divisor=(uint8_t)s.operand; \
+    if (k.memory) __asm__ volatile("std; " #operation " (%[input]); cld" \
+        : "+&a"(a) : [input]"r"(input) : "cc","memory"); \
+    else __asm__ volatile("std; " #operation " %[divisor]; cld" \
+        : "+&a"(a) : [divisor]"q"(divisor) : "cc","memory"); \
+} while (0)
+
+#define WIDE_DIV(operation,type) do { \
+    type a=(type)s.low,b=(type)s.high,divisor=(type)s.operand; \
+    if (k.memory) __asm__ volatile("std; " #operation " (%[input]); cld" \
+        : "+&a"(a),"+&d"(b) : [input]"r"(input) : "cc","memory"); \
+    else __asm__ volatile("std; " #operation " %[divisor]; cld" \
+        : "+&a"(a),"+&d"(b) : [divisor]"r"(divisor) : "cc","memory"); \
+} while (0)
+
+int main(int argc,char **argv) {
+    if (argc!=4) return 80;
+    unsigned sample,probe,original;
+    char tail;
+    if (sscanf(argv[1],"%u%c",&sample,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 ||
+            sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            sample>=sizeof(samples)/sizeof(samples[0]) || probe>4 || original>1) return 80;
+    struct sample s=samples[sample];
+    if (s.row>=sizeof(kernels)/sizeof(kernels[0])) return 80;
+    struct kernel k=kernels[s.row];
+    if (probe && !k.memory) return 80;
+    if (memory_fault_setup(0)) return 81;
+    uint64_t out[4]={s.divisor,0,0,0};
+    uint8_t *input=(uint8_t *)out;
+    unsigned bytes=k.bits/8;
+    if (probe==1) input=NULL;
+    else if (probe>=2) {
+        unsigned accessible=probe==2?bytes-1:bytes;
+        input=guard+page-accessible;
+        for (unsigned i=0;i<accessible;i++) input[i]=(uint8_t)(s.divisor>>(8*i));
+        if (probe==4) {
+#ifdef _WIN32
+            DWORD old;
+            if (!VirtualProtect(guard,page,PAGE_READONLY,&old)) return 82;
+#else
+            if (mprotect(guard,page,PROT_READ)) return 82;
+#endif
+        }
+    }
+    printf("memory enter %u %u %u\n",sample,probe,original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        switch (k.bits) {
+        case 8:
+            if (k.signed_division) BYTE_DIV(idivb); else BYTE_DIV(divb);
+            break;
+        case 16:
+            if (k.signed_division) WIDE_DIV(idivw,uint16_t); else WIDE_DIV(divw,uint16_t);
+            break;
+        case 32:
+            if (k.signed_division) WIDE_DIV(idivl,uint32_t); else WIDE_DIV(divl,uint32_t);
+            break;
+#ifndef __i386__
+        case 64:
+            if (k.signed_division) WIDE_DIV(idivq,uint64_t); else WIDE_DIV(divq,uint64_t);
+            break;
+#endif
+        default: return 84;
+        }
+    } else k.run((uint64_t *)input,s.low,s.high,s.divisor);
+    if (free_guard()) return 85;
+    puts("memory complete");
+    return fflush(stdout)?86:0;
+}
+`
diff --git a/x86_implicit_divide_grammar_test.go b/x86_implicit_divide_grammar_test.go
new file mode 100644
index 000000000..1e9f0ed23
--- /dev/null
+++ b/x86_implicit_divide_grammar_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86ImplicitDivideTypedFamilyCompleteGoBanksAndAddresses(t *testing.T) {
+	if len(x86ImplicitDivideSpecs) != len(x86ImplicitDivideOracle) {
+		t.Fatal("typed implicit division directory differs from the independent complete family")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var witnesses strings.Builder
+		witnesses.WriteString("DATA ·cell+0(SB)/8,$3\nGLOBL ·cell(SB),$8\n")
+		count := 0
+		for _, row := range x86ImplicitDivideOracle {
+			spec, known := x86ImplicitDivideSpecs[Op(row.name)]
+			if !known || spec.bits != row.bits || spec.signed != row.signed {
+				t.Fatal("typed implicit division width/sign differs from independent Go rows", row.name)
+			}
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			for _, register := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH BL BH CL CH DL DH BPB SIB DIB R8B R15B X0 Y0 Z0 K1 M0 FS TLS R16") {
+				t.Run(arch+"/"+row.name+"/"+register, func(t *testing.T) {
+					valid := strings.Contains(" AX CX DX BX SP BP SI DI ", " "+register+" ") ||
+						arch == "amd64" && regexp.MustCompile(`^R(?:[89]|1[0-5])$`).MatchString(register)
+					if row.bits == 8 {
+						valid = valid && (arch != "386" || register != "SP") ||
+							strings.Contains(" AL AH BL BH CL CH DL DH ", " "+register+" ") ||
+							arch == "amd64" && strings.Contains(" BPB SIB DIB R8B R15B ", " "+register+" ")
+					}
+					ins := x86YMMReadSource(t, row.name+" "+register)
+					before := ins
+					before.Args = append([]Operand(nil), ins.Args...)
+					_, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch)
+					if !known || (err == nil) != valid || !reflect.DeepEqual(ins, before) {
+						t.Fatal("Go Ymb/Yml register class or original identity changed", valid, err)
+					}
+					if valid {
+						fmt.Fprintf(&witnesses, "TEXT ·Format%d(SB),4,$0-8\n%s\nRET\n", count, ins.Raw)
+						count++
+					}
+				})
+			}
+			for _, memory := range []string{
+				"(AX)", "1(AX)(CX*2)", "-128(BX)(SI*8)", "17", "·cell(SB)",
+				"param+0(FP)", "tmp-8(SP)", "8(AX)(FS)", "8(AX)(GS)",
+			} {
+				t.Run(arch+"/"+row.name+"/"+memory, func(t *testing.T) {
+					ins := x86YMMReadSource(t, row.name+" "+memory)
+					if _, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch); !known || err != nil {
+						t.Fatal("complete memory grammar inferred a missing source permission", err)
+					}
+					fmt.Fprintf(&witnesses, "TEXT ·Format%d(SB),4,$0-8\n%s\nRET\n", count, ins.Raw)
+					count++
+				})
+			}
+		}
+		if count == 0 {
+			t.Fatal("empty complete original Go source-bank/shape inventory")
+		}
+		requireX86GoAssemblerResult(t, arch, witnesses.String(), true)
+	}
+}
+
+func TestX86ImplicitDivideRejectsGrammarBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			original := x86YMMReadSource(t, row.name+" CX")
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"dispatch", func(i *Instr) { i.Op = "MOVL" }},
+				{"suffix", func(i *Instr) { i.Op += ".Z" }},
+				{"missing-source", func(i *Instr) { i.Args = nil }},
+				{"extra-source", func(i *Instr) { i.Args = append(i.Args, Operand{Kind: OpReg, Reg: DX}) }},
+				{"immediate", func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 3} }},
+				{"vector", func(i *Instr) { i.Args[0] = Operand{Kind: OpReg, Reg: "X0"} }},
+				{"SIB-index", func(i *Instr) { i.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX, Index: SP, Scale: 1}} }},
+				{"SIB-scale", func(i *Instr) { i.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX, Index: CX, Scale: 3}} }},
+				{"address-immediate", func(i *Instr) { i.Args[0] = Operand{Kind: OpSym, Sym: "$·cell(SB)"} }},
+			} {
+				t.Run(arch+"/"+row.name+"/"+control.name, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					control.change(&ins)
+					var ir strings.Builder
+					ctx := &amd64Ctx{b: &ir, goarch: arch, targetTriple: triple}
+					known, terminated, err := ctx.lowerScalarMultiplyDivide(Op(row.name), ins)
+					if !known || terminated || err == nil || ir.Len() != 0 || ctx.tmp != 0 {
+						t.Fatal("division emitted before its complete source grammar rejected", known, terminated, err, ir.String())
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_implicit_divide_inputs_test.go b/x86_implicit_divide_inputs_test.go
new file mode 100644
index 000000000..a6a150f95
--- /dev/null
+++ b/x86_implicit_divide_inputs_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86ImplicitDivideInputState(bits int, arch string) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+		fp: []bool{true, false}, auto: []bool{false, true},
+		valueStack: &x86ResultValueStack{bytes: []uint8{255, 255, 255, 255}, id: true}}
+	for index := range state.gp {
+		state.gp[index], state.canonicalGP[index] = 0x80, 0xff
+	}
+	width, accumulator := int64(bits/8), int64(bits/8)
+	if bits == 8 {
+		accumulator = 2
+	}
+	for _, input := range []struct {
+		reg   Reg
+		bytes int64
+	}{{AX, accumulator}, {DX, width}, {BX, width}} {
+		index, mask, _ := x86ResultGP(input.reg, input.bytes, arch)
+		state.gp[index] |= mask
+	}
+	state.pointerGP[6], state.callerAddressGP[6] = true, true
+	state.writeVector(3, 64, 0x5555555555555555, false)
+	state.masks[2] = true
+	return state
+}
+
+func TestX86ImplicitDivideEveryInputByteAndExactOutputState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.name+" BX")
+				before := x86ImplicitDivideInputState(row.bits, arch)
+				state, expected := before.clone(), before.clone()
+				expected.flags = 0
+				width, accumulator := int64(row.bits/8), int64(row.bits/8)
+				writes := []Reg{AX, DX}
+				if row.bits == 8 {
+					accumulator, writes = 2, writes[:1]
+				}
+				for _, register := range writes {
+					bytes := width
+					if row.bits == 8 {
+						bytes = 2
+					}
+					index, mask, _ := x86ResultGP(register, bytes, arch)
+					expected.gp[index] |= mask
+					expected.canonicalGP[index] &^= mask
+					if bytes == 4 {
+						expected.gp[index] = 0xff
+						if arch == "amd64" {
+							expected.canonicalGP[index] |= 0xf0
+						}
+					}
+				}
+				if accepted, known := x86LoweredImplicitDivideStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, expected) {
+					t.Fatal("division invented memory/aliases/canonical bytes or retained undefined status", state.gp, state.flags)
+				}
+				inputs := []struct {
+					reg   Reg
+					bytes int64
+				}{{BX, width}, {AX, accumulator}}
+				if row.bits != 8 {
+					inputs = append(inputs, struct {
+						reg   Reg
+						bytes int64
+					}{DX, width})
+				}
+				for _, input := range inputs {
+					for missing := int64(0); missing < input.bytes; missing++ {
+						t.Run(fmt.Sprintf("%s/byte%d", input.reg, missing), func(t *testing.T) {
+							current := before.clone()
+							index, _, _ := x86ResultGP(input.reg, input.bytes, arch)
+							current.gp[index] &^= 1 << uint(missing)
+							initial := current.clone()
+							if accepted, known := x86LoweredImplicitDivideStep(ins, &current, nil, arch); !known || accepted || !reflect.DeepEqual(current, initial) {
+								t.Fatal("division consumed an unknown input or partially changed rejected state")
+							}
+						})
+					}
+				}
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("standalone NUM query borrowed the native #DE continuation")
+				}
+				for _, change := range []string{"raw", "encoded", "address size", "address override", "segment prefix", "opaque divisor"} {
+					changed, current := ins, before.clone()
+					switch change {
+					case "raw":
+						changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+					case "encoded":
+						changed.x86Encoded = true
+					case "address size":
+						changed.x86AddressBits = 16
+					case "address override":
+						changed.x86UnboundAddressOverride = true
+					case "segment prefix":
+						changed.x86SegmentPrefix = 0x64
+					case "opaque divisor":
+						index, _, _ := x86ResultGP(BX, width, arch)
+						current.gp[index], current.pointerGP[index] = 0, true
+					}
+					initial := current.clone()
+					if accepted, known := x86LoweredImplicitDivideStep(changed, &current, nil, arch); !known || accepted || !reflect.DeepEqual(current, initial) {
+						t.Fatal("division borrowed another entry/source role or mutated failed state", change)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImplicitDivideNativeReadRequiresActualAddressAndNoNewBacking(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.name+" 3(SI)(BX*2)")
+				before := x86ImplicitDivideInputState(row.bits, arch)
+				index, mask, _ := x86ResultGP(BX, x86ResultPointerWord(arch), arch)
+				before.gp[index] = mask
+				state := before.clone()
+				if accepted, known := x86LoweredImplicitDivideStep(ins, &state, nil, arch); !accepted || !known || state.pointerGP != before.pointerGP || !reflect.DeepEqual(state.fp, before.fp) || !reflect.DeepEqual(state.auto, before.auto) {
+					t.Fatal("paired native read did not retain exact input/address/storage obligations")
+				}
+				for _, missing := range []string{"pointer", "index"} {
+					current := before.clone()
+					if missing == "pointer" {
+						current.pointerGP[6], current.gp[6] = false, 0xff
+					} else {
+						current.gp[index] = 0
+					}
+					initial := current.clone()
+					if missing == "pointer" {
+						want := state.clone()
+						want.pointerGP[6], want.gp[6] = false, 0xff
+						if accepted, known := x86LoweredImplicitDivideStep(ins, &current, nil, arch); !accepted || !known || !reflect.DeepEqual(current, want) {
+							t.Fatal("full NUM divide address changed exact output or unrelated facts")
+						}
+					} else if accepted, _ := x86LoweredImplicitDivideStep(ins, &current, nil, arch); accepted || !reflect.DeepEqual(current, initial) {
+						t.Fatal("division gained an address from NUM or an unknown index", missing)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_implicit_divide_logical_fp_boundaries_test.go b/x86_implicit_divide_logical_fp_boundaries_test.go
new file mode 100644
index 000000000..a524a1713
--- /dev/null
+++ b/x86_implicit_divide_logical_fp_boundaries_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func x86LogicalFPDivideVoidSource(t *testing.T, arch, op, divisorType string, offset int64) (string, string) {
+	t.Helper()
+	declaration := "func Value(low,high uint64,divisor " + divisorType + ",tail uint64)"
+	pkg := mustGoPackage(t, "example.invalid/logicalfpdivide", "package logicalfpdivide\n"+declaration+"\n")
+	sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sig.Frame.Params) != 4 || sig.Frame.Params[2].Offset != 16 {
+		t.Fatal("independent typed fixture lost its low/high/divisor argument positions", sig.Frame)
+	}
+	extent := int64(0)
+	for _, slot := range sig.Frame.Params {
+		if end := slot.Offset + x86FrameScalarBytes(slot.Type, arch); end > extent {
+			extent = end
+		}
+	}
+	move := "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s low+0(FP),AX\n%s high+8(FP),DX\n%s divisor%+d(FP)\nRET\n",
+		extent, move, move, op, offset), declaration
+}
+
+type x86LogicalFPDivideMutation struct {
+	name, source, declaration string
+	accepted                  bool
+}
+
+func x86LogicalFPDivideVoidMutations(t *testing.T, arch, op string, bits int, original, declaration string) []x86LogicalFPDivideMutation {
+	t.Helper()
+	move := "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var mutations []x86LogicalFPDivideMutation
+	for _, change := range []string{"missing-AX", "missing-AH", "missing-DX", "hole", "pointer", "negative", "past-frame", "unwritten-result"} {
+		source, decl := original, declaration
+		switch change {
+		case "missing-AX":
+			source = strings.Replace(source, move+" low+0(FP),AX\n", "", 1)
+		case "missing-AH":
+			source = strings.Replace(source, move+" low+0(FP),AX", "MOVB low+0(FP),AL", 1)
+		case "missing-DX":
+			source = strings.Replace(source, move+" high+8(FP),DX\n", "", 1)
+		case "hole":
+			source, decl = x86LogicalFPDivideVoidSource(t, arch, op, "uint8", 17)
+		case "pointer":
+			source, decl = x86LogicalFPDivideVoidSource(t, arch, op, "*byte", 16)
+		case "negative":
+			source, decl = x86LogicalFPDivideVoidSource(t, arch, op, "uint64", -1)
+		case "past-frame":
+			source, decl = x86LogicalFPDivideVoidSource(t, arch, op, "uint64", 128)
+		case "unwritten-result":
+			source, decl = x86LogicalFPDivideSource("Value", op, arch, bits, false)
+			source = strings.Replace(source, "divisor+16(FP)", "quotient+24(FP)", 1)
+		}
+		// On AMD64 a pointer and uint64 have the same physical argument
+		// extent. Their identical assembly bytes must still consume distinct
+		// real Go declaration roles, never a fabricated numerical pointer.
+		if source == original && decl == declaration {
+			t.Fatal("logical FP source mutation did not apply", change)
+		}
+		mutations = append(mutations, x86LogicalFPDivideMutation{change, source, decl, change == "missing-DX" && bits == 8})
+	}
+	return mutations
+}
+
+// Observe each complete body once, not once per public API. Unique TEXT names
+// allow a single original Go object without changing any instruction/offset.
+func x86LogicalFPDivideWholeGoPrior(t *testing.T, arch, triple string, sources []string) {
+	t.Helper()
+	var combined strings.Builder
+	for index, source := range sources {
+		if strings.Count(source, "TEXT ·Value(SB)") != 1 {
+			t.Fatal("logical FP original body lost its unique complete TEXT")
+		}
+		combined.WriteString(strings.Replace(source, "TEXT ·Value(SB)", fmt.Sprintf("TEXT ·Prior%d(SB)", index), 1))
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, combined.String())
+}
+
+func TestX86ImplicitDivideLogicalFPVoidInputsAndIndependentStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				original, declaration := x86LogicalFPDivideVoidSource(t, arch, row.name, "uint64", 16)
+				mutations := x86LogicalFPDivideVoidMutations(t, arch, row.name, row.bits, original, declaration)
+				priors := []string{original}
+				for _, mutation := range mutations {
+					priors = append(priors, mutation.source)
+				}
+				x86LogicalFPDivideWholeGoPrior(t, arch, triple, priors)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, original, declaration, arch, triple, api); err != nil || ir == "" {
+							t.Fatal("dead division must consume its complete owned logical inputs", err)
+						}
+						for _, mutation := range mutations {
+							t.Run(mutation.name, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, mutation.source, mutation.declaration, arch, triple, api)
+								if mutation.accepted {
+									if err != nil || ir == "" {
+										t.Fatal("byte division invented a DX input", err)
+									}
+									return
+								}
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), row.name) {
+									t.Fatal("logical FP division borrowed missing bytes, pointer bits or unrelated Context", mutation.name, err)
+								}
+							})
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImplicitDivideLogicalFPStatusAndDirectionControl(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple, move, push, pop, word := "x86_64-unknown-linux-gnu", "MOVQ", "PUSHFQ", "POPQ", 8
+		if arch == "386" {
+			triple, move, push, pop, word = "i386-unknown-linux-gnu", "MOVL", "PUSHFL", "POPL", 4
+		}
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				declaration := "func Value(low,high,divisor uint64) uintptr"
+				prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s low+0(FP),AX\n%s high+8(FP),DX\n", 24+word, move, move)
+				original := prefix + "STD\n" + row.name + " divisor+16(FP)\n" + push + "\n" + pop + " BX\n" +
+					"AND" + move[3:] + " $0x400,BX\nCLD\n" + move + " BX,ret+24(FP)\nRET\n"
+				reads := []string{"SETCS BX", "SETPS BX", "SETEQ BX", "SETMI BX", "SETOS BX", "LAHF"}
+				statusSources := make(map[string]string)
+				priors := []string{original}
+				for _, read := range reads {
+					result := "BX"
+					if read == "LAHF" {
+						result = "AH"
+					}
+					source := strings.Replace(prefix, fmt.Sprint(24+word), "25", 1) + "CMPL AX,AX\n" +
+						row.name + " divisor+16(FP)\n" + read + "\nMOVB " + result + ",ret+24(FP)\nRET\n"
+					statusSources[read] = source
+					priors = append(priors, source)
+				}
+				x86LogicalFPDivideWholeGoPrior(t, arch, triple, priors)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, original, declaration, arch, triple, api); err != nil || ir == "" {
+							t.Fatal("logical division discarded independently defined DF/private FLAGS transport", err)
+						}
+						for _, read := range reads {
+							t.Run(read, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, statusSources[read], "func Value(low,high,divisor uint64) uint8", arch, triple, api)
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), strings.Fields(read)[0]) {
+									t.Fatal("division exposed undefined status or failed before the observed status reader", read, err)
+								}
+							})
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImplicitDivideLogicalFPDoesNotCreateCrossTargetOrPhysicalStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			for _, sourceKind := range []string{"tmp-8(SP)", "(BP)", "(SI)", "cell(SB)"} {
+				t.Run(arch+"/"+row.name+"/"+sourceKind, func(t *testing.T) {
+					source, declaration := x86LogicalFPDivideVoidSource(t, arch, row.name, "uint64", 16)
+					source = strings.Replace(source, "divisor+16(FP)", sourceKind, 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("logical FP inputs authenticated unowned native/frame/static storage", sourceKind, api, err)
+						}
+					}
+				})
+			}
+			for _, target := range []string{"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown"} {
+				t.Run(arch+"/"+row.name+"/"+target, func(t *testing.T) {
+					source, declaration := x86LogicalFPDivideVoidSource(t, arch, row.name, "uint64", 16)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, target, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("logical FP division replaced native #DE with a portable result", target, api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_implicit_divide_logical_fp_native_test.go b/x86_implicit_divide_logical_fp_native_test.go
new file mode 100644
index 000000000..bd6443458
--- /dev/null
+++ b/x86_implicit_divide_logical_fp_native_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+// This independent directory is portable to inspect, not to execute. The two
+// required Linux owners below execute the complete unmodified FP programs;
+// object compilation or a non-x86 host does not qualify their #DE behavior.
+func TestX86ImplicitDivideLogicalFPNativeDirectoryAndSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86DivideLogicalFPNativeRows(arch)
+			values, faults := x86DivideNativeCases(rows, arch)
+			wantRows, wantValues, wantFaults, offset := 8, 128, 24, 24
+			if arch == "386" {
+				wantRows, wantValues, wantFaults, offset = 6, 96, 18, 20
+			}
+			if len(rows) != wantRows || len(values) != wantValues || len(faults) != wantFaults || len(rows)*2 > 96 {
+				t.Fatal("complete FP native width/signedness/value/#DE directory changed", len(rows), len(values), len(faults))
+			}
+			var assembly strings.Builder
+			for index, row := range rows {
+				name := "DIV"
+				if row.signed {
+					name = "IDIV"
+				}
+				name += map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[row.bits]
+				instruction := fmt.Sprintf("%s divisor+%d(FP)\n", name, offset)
+				if row.source != "FP" || row.memory || strings.Count(row.assembly, instruction) != 2 ||
+					!strings.Contains(row.assembly, fmt.Sprintf("TEXT ·Dead%d(SB)", index)) {
+					t.Fatal("native FP live/dead row lost its original named divisor", row)
+				}
+				valueCount, faultKinds := 0, make(map[string]bool)
+				for _, value := range values {
+					if value.row == index {
+						valueCount++
+					}
+				}
+				for _, fault := range faults {
+					if fault.row == index {
+						faultKinds[fault.fault] = true
+					}
+				}
+				if valueCount != 16 || !faultKinds["zero"] || !faultKinds["overflow"] ||
+					row.signed && (!faultKinds["wide-min/-1"] || !faultKinds["narrow-min/-1"]) {
+					t.Fatal("native FP row omits whole-result or mandatory #DE boundaries", row, valueCount, faultKinds)
+				}
+				assembly.WriteString(row.assembly)
+			}
+			goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+			_, declarations := x86DivideNativeDeclarationSources(rows)
+			original := fmt.Sprintf(x86DivideNativeOriginalGo, "", "")
+			for name, contents := range map[string]string{"value.go": declarations, "value_test.go": original} {
+				if _, err := parser.ParseFile(token.NewFileSet(), name, contents, parser.AllErrors); err != nil {
+					t.Fatal("complete original Go native fixture is not a valid compilation unit", name, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_implicit_divide_logical_fp_objects_test.go b/x86_implicit_divide_logical_fp_objects_test.go
new file mode 100644
index 000000000..3b90072a9
--- /dev/null
+++ b/x86_implicit_divide_logical_fp_objects_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Both dividend halves and the divisor are independent real arguments. The
+// result exposes complete AX/DX: B packs quotient/remainder into AL/AH and
+// retains DX, W retains upper bytes, L clears the upper AMD64 halves.
+func x86LogicalFPDivideSource(name, op, arch string, bits int, registerControl bool) (string, string) {
+	word, move, resultType := 8, "MOVQ", "uint64"
+	if arch == "386" {
+		word, move, resultType = 4, "MOVL", "uint32"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s low+0(FP),AX\n%s high+8(FP),DX\n", name, 24+2*word, move, move)
+	if registerControl {
+		suffix := map[int]string{8: "B", 16: "W", 32: "L", 64: "Q"}[bits]
+		source += "MOV" + suffix + " divisor+16(FP),CX\n" + op + " CX\n"
+	} else {
+		source += op + " divisor+16(FP)\n"
+	}
+	source += fmt.Sprintf("%s AX,quotient+24(FP)\n%s DX,remainder+%d(FP)\nRET\n", move, move, 24+word)
+	return source, fmt.Sprintf("func %s(low,high,divisor uint64) (quotient %s,remainder %s)\n", name, resultType, resultType)
+}
+
+func TestX86ImplicitDivideLogicalFPOriginalGoAndThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("logical FP division original objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var original, controls, declarations strings.Builder
+			members := 0
+			for _, row := range x86ImplicitDivideOracle {
+				if target.arch == "386" && row.bits == 64 {
+					continue
+				}
+				name := fmt.Sprint("LogicalFPDivide", members)
+				source, declaration := x86LogicalFPDivideSource(name, row.name, target.arch, row.bits, false)
+				control, _ := x86LogicalFPDivideSource(name, row.name, target.arch, row.bits, true)
+				original.WriteString(source)
+				controls.WriteString(control)
+				declarations.WriteString(declaration)
+				members++
+			}
+			want := 8
+			if target.arch == "386" {
+				want = 6
+			}
+			if members != want {
+				t.Fatal("complete logical FP width/signedness source inventory changed", members)
+			}
+			// Actual Go proves both whole programs before the public consumers.
+			// The register control changes only divisor transport, not inputs,
+			// dividend widths, output slots or the native division operation.
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, original.String())
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, controls.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					control, err := x86ScalarFPBitViewAPI(t, controls.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || control == "" {
+						t.Fatal("complete register-divisor control failed before logical FP division", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, original.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete owned logical FP divisor lost its original #DE continuation", err)
+					}
+					for _, pipeline := range []struct{ name, ir, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2/backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							if strings.Count(pipeline.ir, "asm sideeffect") != members ||
+								regexp.MustCompile(`\b(?:sdiv|udiv|srem|urem)\b`).MatchString(pipeline.ir) {
+								t.Fatal("logical division lost a mandatory native opcode or became LLVM poison")
+							}
+							x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_implicit_divide_logical_fp_state_test.go b/x86_implicit_divide_logical_fp_state_test.go
new file mode 100644
index 000000000..4242ccff7
--- /dev/null
+++ b/x86_implicit_divide_logical_fp_state_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86LogicalFPDivideExpected(before x86ResultState, bits int, arch string) x86ResultState {
+	expected := before.clone()
+	writes, width := []Reg{AX, DX}, int64(bits/8)
+	if bits == 8 {
+		writes, width = writes[:1], 2 // Quotient AL and remainder AH, not DX.
+	}
+	for _, register := range writes {
+		index, mask, _ := x86ResultGP(register, width, arch)
+		expected.gp[index] |= mask
+		expected.pointerGP[index], expected.callerAddressGP[index] = false, false
+		expected.canonicalGP[index] &^= mask
+		if width == 4 {
+			expected.gp[index] = 255
+			if arch == "amd64" {
+				expected.canonicalGP[index] |= 0xf0
+			}
+		}
+	}
+	expected.flags = 0 // All six status flags are undefined, unlike DF/ID.
+	return expected
+}
+
+func TestX86ImplicitDivideLogicalFPAllInputBytesAndAtomicOutputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		members := 0
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			members++
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				width := int64(row.bits / 8)
+				ins := x86YMMReadSource(t, row.name+" divisor+3(FP)")
+				before := x86ImplicitDivideInputState(row.bits, arch)
+				before.fp = make([]bool, 24)
+				owned := make([]bool, len(before.fp))
+				for at := int64(3); at < 3+width; at++ {
+					before.fp[at], owned[at] = true, true
+				}
+				state := before.clone()
+				if accepted, known := x86LoweredImplicitDivideStep(ins, &state, owned, arch); !known || !accepted ||
+					!reflect.DeepEqual(state, x86LogicalFPDivideExpected(before, row.bits, arch)) {
+					t.Fatal("owned logical divisor lacks the exact paired #DE continuation or changed unrelated state", accepted, known)
+				}
+				for _, role := range []string{"FP value", "FP ownership", "AX", "DX"} {
+					if role == "DX" && row.bits == 8 {
+						continue // B has no implicit DX dividend dependency.
+					}
+					bytes := width
+					if role == "AX" && row.bits == 8 {
+						bytes = 2
+					}
+					for missing := int64(0); missing < bytes; missing++ {
+						t.Run(fmt.Sprintf("missing-%s/byte%d", role, missing), func(t *testing.T) {
+							current, extent := before.clone(), append([]bool(nil), owned...)
+							switch role {
+							case "FP value":
+								current.fp[3+missing] = false
+							case "FP ownership":
+								extent[3+missing] = false
+							default:
+								index, _, _ := x86ResultGP(Reg(role), bytes, arch)
+								current.gp[index] &^= 1 << uint(missing)
+							}
+							initial := current.clone()
+							if accepted, known := x86LoweredImplicitDivideStep(ins, &current, extent, arch); !known || accepted || !reflect.DeepEqual(current, initial) {
+								t.Fatal("division accepted a missing input or partially mutated rejected state", accepted, known)
+							}
+						})
+					}
+				}
+				// Owned bytes do not authorize a standalone numerical division:
+				// only the paired native opcode can preserve zero/overflow #DE.
+				standalone := before.clone()
+				if x86ScalarFPResultTransfer(ins, &standalone, owned, 0, arch) || !reflect.DeepEqual(standalone, before) {
+					t.Fatal("standalone observer borrowed a native division continuation")
+				}
+			})
+		}
+		want := 8
+		if arch == "386" {
+			want = 6
+		}
+		if members != want {
+			t.Fatal("complete signed/unsigned logical FP family directory changed", arch, members)
+		}
+	}
+}
+
+func TestX86ImplicitDivideLogicalFPSourceIdentityAndSpanRejections(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			original := x86YMMReadSource(t, row.name+" divisor+3(FP)")
+			for _, change := range []string{"encoded", "raw", "address-size", "address-override", "segment", "foreign-read", "negative-offset", "out-of-bounds"} {
+				t.Run(arch+"/"+row.name+"/"+change, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					state := x86ImplicitDivideInputState(row.bits, arch)
+					state.fp = make([]bool, 16)
+					owned := make([]bool, len(state.fp))
+					for index := range state.fp {
+						state.fp[index], owned[index] = true, true
+					}
+					switch change {
+					case "encoded":
+						ins.x86Encoded = true
+					case "raw":
+						ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+					case "address-size":
+						ins.x86AddressBits = 16
+					case "address-override":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "foreign-read":
+						ins.x86NumericalRead = &x86NumericalReadCertificate{}
+					case "negative-offset":
+						ins.Args[0].FPOffset = -1
+					case "out-of-bounds":
+						ins.Args[0].FPOffset = int64(len(owned))
+					}
+					before := state.clone()
+					if accepted, _ := x86LoweredImplicitDivideStep(ins, &state, owned, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("logical bytes acquired foreign source identity, extent or partial result state")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_implicit_divide_native_linux_amd64_test.go b/x86_implicit_divide_native_linux_amd64_test.go
new file mode 100644
index 000000000..807f9a507
--- /dev/null
+++ b/x86_implicit_divide_native_linux_amd64_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86RunImplicitDivideNative(t, x86FloatCompareExecutionTools(t), "amd64")
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ImplicitDivideOriginalGoAndNative386(t *testing.T) {
+	x86RunImplicitDivideNative386(t, false)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86RunImplicitDivideNativeRows(t, x86FloatCompareExecutionTools(t), "amd64", x86DivideLogicalFPNativeRows("amd64"))
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ImplicitDivideLogicalFPOriginalGoAndNative386(t *testing.T) {
+	x86RunImplicitDivideNative386(t, true)
+}
+
+func x86RunImplicitDivideNative386(t *testing.T, logicalFP bool) {
+	t.Helper()
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required native mode32 division counterpart tools: LLVM22=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie"}}
+	rows := x86DivideNativeRows("386")
+	if logicalFP {
+		rows = x86DivideLogicalFPNativeRows("386")
+	}
+	x86RunImplicitDivideNativeRows(t, execution, "386", rows)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_implicit_divide_runtime_test.go b/x86_implicit_divide_runtime_test.go
new file mode 100644
index 000000000..7a0898036
--- /dev/null
+++ b/x86_implicit_divide_runtime_test.go
@@ -0,0 +1,499 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math/big"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86DivideNativeRow struct {
+	name, source string
+	bits         int
+	signed       bool
+	memory       bool
+	assembly     string
+}
+
+type x86DivideNativeCase struct {
+	row                    int
+	low, high, divisor     uint64
+	operand, quotient, rem uint64
+	fault                  string
+}
+
+func x86DivideNativeRows(arch string) []x86DivideNativeRow {
+	return x86DivideNativeSourceRows(arch, false)
+}
+
+func x86DivideLogicalFPNativeRows(arch string) []x86DivideNativeRow {
+	return x86DivideNativeSourceRows(arch, true)
+}
+
+func x86DivideNativeSourceRows(arch string, logicalFP bool) []x86DivideNativeRow {
+	word, move, push, pop := 8, "MOVQ", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		word, move, push, pop = 4, "MOVL", "PUSHFL", "POPL"
+	}
+	var rows []x86DivideNativeRow
+	for _, member := range x86ImplicitDivideOracle {
+		if arch == "386" && member.bits == 64 {
+			continue
+		}
+		sources := []string{"CX", "memory", "AX", "DX"}
+		if member.bits == 8 {
+			sources = append(sources, "AH", "BH")
+		}
+		if arch == "386" {
+			sources = append(sources, "BP", "SI", "DI")
+		}
+		if logicalFP {
+			sources = []string{"FP"}
+		}
+		for _, source := range sources {
+			row := x86DivideNativeRow{name: fmt.Sprint("Value", len(rows)), source: source,
+				bits: member.bits, signed: member.signed, memory: source == "memory"}
+			pointer, divisor := "DI", source
+			if source == "DI" {
+				pointer = "SI"
+			}
+			if row.memory {
+				divisor = "(" + pointer + ")"
+			} else if source == "FP" {
+				divisor = fmt.Sprintf("divisor+%d(FP)", word+16)
+			}
+			setup := fmt.Sprintf("%s out+0(FP),%s\n%s low+%d(FP),AX\n%s high+%d(FP),DX\n%s divisor+%d(FP),CX\n",
+				move, pointer, move, word, move, word+8, move, word+16)
+			if source == "BH" {
+				setup += fmt.Sprintf("%s divisor+%d(FP),BX\n", move, word+16)
+			} else if source == "BP" || source == "SI" || source == "DI" {
+				setup += fmt.Sprintf("%s divisor+%d(FP),%s\n", move, word+16, source)
+			}
+			instruction := "STD\n" + member.name + " " + divisor + "\n"
+			var stores strings.Builder
+			for index, register := range []string{"AX", "DX", "BX"} {
+				fmt.Fprintf(&stores, "%s %s,%d(%s)\n", move, register, index*8, pointer)
+				if arch == "386" {
+					fmt.Fprintf(&stores, "MOVL $0,%d(%s)\n", index*8+4, pointer)
+				}
+			}
+			row.assembly = fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s%s%s\n%s BX\n%s $0x400,BX\nCLD\n%sRET\n",
+				row.name, word+24, setup, instruction, push, pop, "AND"+move[3:], stores.String())
+			row.assembly += fmt.Sprintf("TEXT ·Dead%d(SB),4,$0-%d\n%s%sCLD\nRET\n", len(rows), word+24, setup, instruction)
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86DivideNativeEvaluate(row x86DivideNativeRow, index int, low, high, divisor uint64, arch string) x86DivideNativeCase {
+	result := x86DivideNativeCase{row: index, low: low, high: high, divisor: divisor}
+	mask := ^uint64(0)
+	if row.bits != 64 {
+		mask = uint64(1)<<uint(row.bits) - 1
+	}
+	operand := divisor
+	switch row.source {
+	case "AX":
+		operand = low
+	case "DX":
+		operand = high
+	case "AH":
+		operand = low >> 8
+	case "BH":
+		operand = divisor >> 8
+	}
+	result.operand = operand & mask
+	if result.operand == 0 {
+		result.fault = "zero"
+		return result
+	}
+	bits := row.bits * 2
+	numerator := new(big.Int).SetUint64(low & mask)
+	if row.bits == 8 {
+		numerator.SetUint64(low & 0xffff)
+	} else {
+		upper := new(big.Int).Lsh(new(big.Int).SetUint64(high&mask), uint(row.bits))
+		numerator.Or(numerator, upper)
+	}
+	denominator := new(big.Int).SetUint64(result.operand)
+	modulus := new(big.Int).Lsh(big.NewInt(1), uint(row.bits))
+	if row.signed {
+		if numerator.Bit(bits-1) != 0 {
+			numerator.Sub(numerator, new(big.Int).Lsh(big.NewInt(1), uint(bits)))
+		}
+		if denominator.Bit(row.bits-1) != 0 {
+			denominator.Sub(denominator, modulus)
+		}
+	}
+	quotient, remainder := new(big.Int), new(big.Int)
+	quotient.QuoRem(numerator, denominator, remainder)
+	minimum, maximum := new(big.Int), new(big.Int).Sub(new(big.Int).Set(modulus), big.NewInt(1))
+	if row.signed {
+		limit := new(big.Int).Rsh(new(big.Int).Set(modulus), 1)
+		minimum.Neg(limit)
+		maximum.Sub(limit, big.NewInt(1))
+	}
+	if quotient.Cmp(minimum) < 0 || quotient.Cmp(maximum) > 0 {
+		result.fault = "overflow"
+		return result
+	}
+	quotient.Mod(quotient, modulus)
+	remainder.Mod(remainder, modulus)
+	result.quotient, result.rem = quotient.Uint64(), remainder.Uint64()
+	if row.bits == 8 {
+		result.quotient = low&^uint64(0xffff) | result.quotient | result.rem<<8
+		result.rem = high
+	} else if row.bits == 16 {
+		result.quotient |= low &^ mask
+		result.rem |= high &^ mask
+	}
+	if arch == "386" {
+		result.quotient, result.rem = uint64(uint32(result.quotient)), uint64(uint32(result.rem))
+	}
+	return result
+}
+
+func x86DivideNativeCases(rows []x86DivideNativeRow, arch string) (values, faults []x86DivideNativeCase) {
+	seeds := []uint64{0, ^uint64(0), 1, ^uint64(0) - 1, 7, ^uint64(0) - 6,
+		127, ^uint64(0) - 126, 128, ^uint64(0) - 127, 255, ^uint64(0) - 254,
+		256, ^uint64(0) - 255, 257, ^uint64(0) - 256, 0x1122334455667788, 0x8877665544332211}
+	for value := uint64(2); value < 34; value++ {
+		seeds = append(seeds, value, ^uint64(0)-(value-1))
+	}
+	for index, row := range rows {
+		widthMask := ^uint64(0)
+		if row.bits != 64 {
+			widthMask = uint64(1)<<uint(row.bits) - 1
+		}
+		seenFaults, selected := make(map[string]bool), 0
+		seenValues := make(map[[3]uint64]bool)
+		wordMask := ^uint64(0)
+		if arch == "386" {
+			wordMask = 0xffffffff
+		}
+		for _, low := range seeds {
+			chosen := false
+			preferredHigh := uint64(0)
+			if row.signed && low&(uint64(1)<<uint(row.bits-1)) != 0 {
+				preferredHigh = widthMask
+			}
+			for _, high := range []uint64{preferredHigh, 0, widthMask, 1, uint64(1) << uint(row.bits-1)} {
+				for _, divisor := range []uint64{3, ^uint64(0) - 2, 1, ^uint64(0), 7, 0, 0x100, 0x300} {
+					current := x86DivideNativeEvaluate(row, index, low, high, divisor, arch)
+					if current.fault != "" {
+						if !seenFaults[current.fault] {
+							seenFaults[current.fault] = true
+							faults = append(faults, current)
+						}
+					} else if !chosen && selected < 16 {
+						key := [3]uint64{low & wordMask, high & wordMask, current.operand}
+						if !seenValues[key] {
+							seenValues[key] = true
+							values = append(values, current)
+							selected++
+							chosen = true
+						}
+					}
+				}
+			}
+		}
+		if row.signed && (row.source == "CX" || row.source == "FP" || row.memory) {
+			for _, boundary := range []string{"wide-min/-1", "narrow-min/-1"} {
+				low, high := uint64(0), uint64(1)<<uint(row.bits-1)
+				if boundary == "narrow-min/-1" {
+					low, high = uint64(1)<<uint(row.bits-1), widthMask
+				}
+				if row.bits == 8 {
+					low, high = low|high<<8, 0
+				}
+				current := x86DivideNativeEvaluate(row, index, low, high, ^uint64(0), arch)
+				if current.fault != "overflow" {
+					panic("independent signed division overflow boundary is not #DE")
+				}
+				current.fault = boundary
+				faults = append(faults, current)
+			}
+		}
+	}
+	return values, faults
+}
+
+func TestX86ImplicitDivideIndependentNativeVectorDirectory(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86DivideNativeRows(arch)
+		values, faults := x86DivideNativeCases(rows, arch)
+		wantRows, wantValues, wantFaults := 36, 512, 88
+		if arch == "386" {
+			wantRows, wantValues, wantFaults = 46, 688, 104
+		}
+		if len(rows) != wantRows || len(rows)*2 > 96 || len(values) != wantValues || len(faults) != wantFaults {
+			t.Fatal("independent complete source/alias/defined-value/#DE directory changed", arch, len(rows), len(values), len(faults))
+		}
+		for index, row := range rows {
+			count := 0
+			for _, value := range values {
+				if value.row == index {
+					count++
+				}
+			}
+			alwaysFaults := !row.signed && (row.source == "DX" && row.bits != 8 || row.source == "AH")
+			if alwaysFaults && count != 0 || !alwaysFaults && count != 16 {
+				t.Fatal("a source alias disappeared behind an empty value vector", arch, row, count)
+			}
+		}
+	}
+}
+
+func x86DivideNativeDeclarationSources(rows []x86DivideNativeRow) (apiDeclarations, originalFile string) {
+	var declarations strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&declarations, "func %s(out *[4]uint64,low,high,divisor uint64)\nfunc Dead%d(out *[4]uint64,low,high,divisor uint64)\n", row.name, index)
+	}
+	return declarations.String(), "package oracle\n" + declarations.String()
+}
+
+func x86RunImplicitDivideNative(t *testing.T, execution x86FloatCompareExecution, arch string) {
+	t.Helper()
+	x86RunImplicitDivideNativeRows(t, execution, arch, x86DivideNativeRows(arch))
+}
+
+func x86RunImplicitDivideNativeRows(t *testing.T, execution x86FloatCompareExecution, arch string, rows []x86DivideNativeRow) {
+	t.Helper()
+	values, faults := x86DivideNativeCases(rows, arch)
+	var assembly, cRows, cCases, goRows, goCases, faultRows, faultCases strings.Builder
+	declarations, originalDeclarations := x86DivideNativeDeclarationSources(rows)
+	for index, row := range rows {
+		assembly.WriteString(row.assembly)
+		fmt.Fprintf(&cRows, "{ %s },\n", row.name)
+		fmt.Fprintf(&goRows, "%s,\n", row.name)
+		signed, memory := 0, 0
+		if row.signed {
+			signed = 1
+		}
+		if row.memory {
+			memory = 1
+		}
+		fmt.Fprintf(&faultRows, "{ Dead%d,%d,%d,%d },\n", index, row.bits, signed, memory)
+	}
+	for _, value := range values {
+		fmt.Fprintf(&cCases, "{%d,UINT64_C(%d),UINT64_C(%d),UINT64_C(%d),UINT64_C(%d),UINT64_C(%d)},\n", value.row, value.low, value.high, value.divisor, value.quotient, value.rem)
+		fmt.Fprintf(&goCases, "{%d,%d,%d,%d,%d,%d},\n", value.row, value.low, value.high, value.divisor, value.quotient, value.rem)
+	}
+	for _, fault := range faults {
+		fmt.Fprintf(&faultCases, "{%d,UINT64_C(%d),UINT64_C(%d),UINT64_C(%d),UINT64_C(%d)},\n", fault.row, fault.low, fault.high, fault.divisor, fault.operand)
+	}
+	var prototypes strings.Builder
+	for index, row := range rows {
+		fmt.Fprintf(&prototypes, "extern void %s(uint64_t *,uint64_t,uint64_t,uint64_t);\nextern void Dead%d(uint64_t *,uint64_t,uint64_t,uint64_t);\n", row.name, index)
+	}
+	goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations, arch, execution.triple, "Go")
+	if err != nil {
+		t.Fatal("complete original division runtime source rejected", arch, err)
+	}
+	valueDriver := fmt.Sprintf(x86DivideNativeValuesC, prototypes.String(), cRows.String(), cCases.String())
+	faultDriver := x86DivideNativeFaultsC(prototypes.String(), faultRows.String(), faultCases.String())
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			calls := strings.Count(pipeline.ir, `asm sideeffect "div`) + strings.Count(pipeline.ir, `asm sideeffect "idiv`)
+			if calls != len(rows)*2 {
+				t.Fatal("an observable or dead division lost its mandatory native opcode")
+			}
+			valueExecutable := execution.compileLLVM(t, "division-values", pipeline.ir, valueDriver, pipeline.level)
+			var output []byte
+			if arch == "386" {
+				program := x86NativeOracleIA32Executable(t, execution, valueExecutable)
+				output = x87IA32RunDirect(t, program, nil, os.Environ())
+			} else {
+				output = execution.run(t, valueExecutable)
+			}
+			want := fmt.Sprintf("native division whole-register/DF/canary outcomes %d failures 0\n", len(values))
+			if string(output) != want {
+				t.Fatal("independent mathematical whole-register results", string(output), want)
+			}
+			executable := execution.compileLLVM(t, "division-faults", pipeline.ir, faultDriver, pipeline.level)
+			var ia32 *x87IA32Executable
+			if arch == "386" {
+				program := x86NativeOracleIA32Executable(t, execution, executable)
+				ia32 = &program
+			}
+			observe := func(index, probe, original int) string {
+				// A genuine native signal still has to come from the exact
+				// static IA32 file inspected before this direct invocation.
+				if ia32 != nil {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				result := x86ObserveMemoryFault(t, execution, executable, index, probe, original)
+				if ia32 != nil {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return result
+			}
+			for index, fault := range faults {
+				probes := 1
+				if rows[fault.row].memory {
+					probes = 5
+				}
+				for probe := 0; probe < probes; probe++ {
+					want := observe(index, probe, 1)
+					if probe == 1 || probe == 2 {
+						if want != "segv" && want != "bus" {
+							t.Fatal("original memory access did not precede #DE", arch, index, probe, want)
+						}
+					} else if want != "fpe" {
+						t.Fatal("original zero/overflow division did not raise native #DE", arch, index, probe, want)
+					}
+					if got := observe(index, probe, 0); got != want {
+						t.Fatal("dead native division exception class/priority mismatch", arch, index, probe, got, want)
+					}
+				}
+			}
+			if rows[0].source == "FP" {
+				t.Logf("logical FP native arch=%s rows=%d values=%d dead-division-faults=%d; whole AX/DX, DF and canaries; zero/overflow and signed-min/-1 SIGFPE", arch, len(rows), len(values), len(faults))
+			}
+		})
+	}
+	x86RunOriginalGoNativeSource(t, execution, arch, originalDeclarations, assembly.String(),
+		fmt.Sprintf(x86DivideNativeOriginalGo, goRows.String(), goCases.String()))
+	if rows[0].source == "FP" {
+		t.Logf("logical FP actual original Go arch=%s rows=%d values=%d; complete original FP divisor source and whole AX/DX/DF/canary observations", arch, len(rows), len(values))
+	}
+}
+
+func x86NativeOracleIA32Executable(t *testing.T, execution x86FloatCompareExecution, path string) x87IA32Executable {
+	t.Helper()
+	if execution.triple != "i386-unknown-linux-gnu" || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("native IA32 oracle forbids an emulator or guest argv transport")
+	}
+	program, err := x87IA32StaticExecutable(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("native oracle static IA32 ELF bytes=%d sha256=%x", program.size, program.hash)
+	return program
+}
+
+func x86OriginalGoNativeEnvironment(arch string, inherited []string) []string {
+	env := append([]string(nil), inherited...)
+	return append(env, "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOROOT="+runtime.GOROOT(), "GOFLAGS=", "GOEXPERIMENT=", "GOOS=linux",
+		"GOARCH="+arch, "CGO_ENABLED=0", "GOMAXPROCS=2")
+}
+
+func TestX86ImplicitDivideOriginalGoEnvironmentIsBoundToSDK(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		inherited := []string{"PATH=sentinel", "GOROOT=untrusted", "GOENV=untrusted", "GOWORK=untrusted",
+			"GOTOOLCHAIN=auto", "GOFLAGS=-race", "GOEXPERIMENT=untrusted", "GOOS=untrusted",
+			"GOARCH=untrusted", "CGO_ENABLED=1", "GOMAXPROCS=64"}
+		actual := make(map[string]string)
+		for _, entry := range x86OriginalGoNativeEnvironment(arch, inherited) {
+			name, value, _ := strings.Cut(entry, "=")
+			actual[name] = value
+		}
+		for name, want := range map[string]string{
+			"PATH": "sentinel", "GOROOT": runtime.GOROOT(), "GOENV": "off", "GOWORK": "off",
+			"GOTOOLCHAIN": "local", "GOFLAGS": "", "GOEXPERIMENT": "", "GOOS": "linux",
+			"GOARCH": arch, "CGO_ENABLED": "0", "GOMAXPROCS": "2",
+		} {
+			if actual[name] != want {
+				t.Fatalf("%s %s=%q, want %q", arch, name, actual[name], want)
+			}
+		}
+		if inherited[1] != "GOROOT=untrusted" {
+			t.Fatal("oracle environment mutated its caller's inherited environment")
+		}
+	}
+}
+
+// Shared exact-SDK execution is only a test-driver lifecycle. Neither family
+// obtains source, numerical, ABI or native-storage permissions from it.
+func x86RunOriginalGoNativeSource(t *testing.T, execution x86FloatCompareExecution, arch, declarations, assembly, testSource string) {
+	t.Helper()
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module oracle\n\ngo 1.20\n", "value.go": declarations,
+		"value_" + arch + ".s": assembly, "value_test.go": testSource,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(directory, "original.test")
+	goBinary := filepath.Join(runtime.GOROOT(), "bin", "go")
+	env := x86OriginalGoNativeEnvironment(arch, os.Environ())
+	version, err := x87IA32Capture(t, goBinary, []string{"version"}, directory, env)
+	if err != nil || !strings.HasPrefix(string(version), "go version "+runtime.Version()+" ") {
+		t.Fatalf("native oracle SDK identity mismatch: %v\n%s", err, version)
+	}
+	output, err := x87IA32Capture(t, goBinary,
+		[]string{"test", "-p=1", "-vet=off", "-c", "-o", binary, "."}, directory, env)
+	if err != nil || len(output) != 0 {
+		t.Fatalf("original Go native oracle compile failed: %v\n%s", err, output)
+	}
+	arguments := []string{"-test.run=^TestOriginal$", "-test.count=1", "-test.v"}
+	if arch == "386" {
+		program := x86NativeOracleIA32Executable(t, execution, binary)
+		output = x87IA32RunDirect(t, program, arguments, os.Environ())
+	} else {
+		output = execution.run(t, binary, arguments...)
+	}
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatal("original Go has no successful complete mathematical terminal", string(output))
+	}
+}
+
+const x86DivideNativeValuesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+%s
+struct kernel {void (*run)(uint64_t *,uint64_t,uint64_t,uint64_t);};
+static const struct kernel kernels[]={%s};
+struct sample {unsigned row; uint64_t low,high,divisor,quotient,remainder;};
+static const struct sample samples[]={%s};
+int main(void) {
+    unsigned count=0;
+    for (unsigned i=0;i<sizeof(samples)/sizeof(samples[0]);i++) {
+        struct sample s=samples[i];
+        if (s.row>=sizeof(kernels)/sizeof(kernels[0])) return 1;
+        uint64_t actual[]={s.divisor,UINT64_C(0x123456789abcdef0),UINT64_C(0x1122334455667788),UINT64_C(0x9abcdef012345678)};
+        const uint64_t expected[]={s.quotient,s.remainder,0x400,UINT64_C(0x9abcdef012345678)};
+        kernels[s.row].run(actual,s.low,s.high,s.divisor);
+        if (memcmp(actual,expected,sizeof(actual))) {
+            fprintf(stderr,"division row=%%u sample=%%u got=%%llx/%%llx/%%llx expected=%%llx/%%llx\n",s.row,i,
+                (unsigned long long)actual[0],(unsigned long long)actual[1],(unsigned long long)actual[2],
+                (unsigned long long)s.quotient,(unsigned long long)s.remainder);
+            return 1;
+        }
+        count++;
+    }
+    printf("native division whole-register/DF/canary outcomes %%u failures 0\n",count);
+    return 0;
+}
+`
+
+const x86DivideNativeOriginalGo = `package oracle
+import "testing"
+var kernels=[]func(*[4]uint64,uint64,uint64,uint64){%s}
+var samples=[]struct{row int;low,high,divisor,quotient,remainder uint64}{%s}
+func TestOriginal(t *testing.T) {
+    if len(samples)==0 {t.Fatal("empty independent mathematical vector")}
+    for i,s:=range samples {
+        actual:=[4]uint64{s.divisor,0x123456789abcdef0,0x1122334455667788,0x9abcdef012345678}
+        expected:=[4]uint64{s.quotient,s.remainder,0x400,0x9abcdef012345678}
+        kernels[s.row](&actual,s.low,s.high,s.divisor)
+        if actual!=expected {t.Fatalf("division row=%%d sample=%%d got=%%x want=%%x",s.row,i,actual,expected)}
+    }
+    t.Logf("actual Go whole-register/DF/canary outcomes %%d failures 0",len(samples))
+}
+`
diff --git a/x86_implicit_divide_status_test.go b/x86_implicit_divide_status_test.go
new file mode 100644
index 000000000..5c68c560f
--- /dev/null
+++ b/x86_implicit_divide_status_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86ImplicitDivideCannotExposeUndefinedStatus(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ImplicitDivideOracle {
+			if target.arch == "386" && row.bits == 64 {
+				continue
+			}
+			for _, read := range []string{"SETCS BX", "SETPS BX", "SETEQ BX", "SETMI BX", "SETOS BX", "LAHF"} {
+				t.Run(target.triple+"/"+row.name+"/"+read, func(t *testing.T) {
+					body := x86ImplicitDivideInitializedBody(row.name, row.suffix, row.bits, "CX")
+					result := "BX"
+					if read == "LAHF" {
+						result = "AH"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nMOVL $0,AX\nCMPL AX,$0\n%s%s\nMOVB %s,ret+0(FP)\nRET\n", body, read, result)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint8", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("division exposed architecturally undefined status as a source value", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImplicitDividePostTransferFootprintsStayIndependent(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.name+" BX")
+				var addresses [16]bool
+				var canonical [16]uint8
+				for index := range addresses {
+					addresses[index], canonical[index] = true, 255
+				}
+				wantAddress, wantCanonical := addresses, canonical
+				writes, width := []Reg{AX, DX}, int64(row.bits/8)
+				if row.bits == 8 {
+					writes, width = writes[:1], 2
+				}
+				for _, register := range writes {
+					index, mask, _ := x86ResultGP(register, width, arch)
+					wantAddress[index] = false
+					wantCanonical[index] &^= mask
+					if width == 4 && arch == "amd64" {
+						wantCanonical[index] |= 0xf0
+					}
+				}
+				if got := x86ResultCallerAddressesAfter(ins, addresses, nil, arch); got != wantAddress {
+					t.Fatal("implicit output retained a pointer or revoked an unrelated one", got)
+				}
+				if got := x86RegisterCanonicalBytesAfter(ins, canonical, arch); got != wantCanonical {
+					t.Fatal("implicit outputs acquired canonical bool bytes", got)
+				}
+				if _, known, _ := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+					t.Fatal("post-transfer footprint supplied standalone numerical division authority")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_implicit_divide_tdd_test.go b/x86_implicit_divide_tdd_test.go
new file mode 100644
index 000000000..7d863fbc1
--- /dev/null
+++ b/x86_implicit_divide_tdd_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This directory is independent of the lowerer's multiply/divide switch.
+// The byte dividend is AX16, not AL; the remaining dividends are DX:AX.
+var x86ImplicitDivideOracle = []struct {
+	name, suffix string
+	bits         int
+	signed       bool
+}{
+	{"DIVB", "B", 8, false}, {"DIVW", "W", 16, false},
+	{"DIVL", "L", 32, false}, {"DIVQ", "Q", 64, false},
+	{"IDIVB", "B", 8, true}, {"IDIVW", "W", 16, true},
+	{"IDIVL", "L", 32, true}, {"IDIVQ", "Q", 64, true},
+}
+
+func TestX86ImplicitDivideCompleteIndependentGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, expected := range map[string]string{
+		"ydivb": "{Zm_o,2,argList{Ymb}},", "ydivl": "{Zm_o,2,argList{Yml}},",
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(match) != 2 || strings.Join(strings.Fields(string(match[1])), "") != expected {
+			t.Fatal("complete Go implicit division operand class, zcase or offset changed", table)
+		}
+	}
+	actual := regexp.MustCompile(`\{A(?:I?DIV)[BWLQ], [^\n]+`).FindAllString(string(data), -1)
+	want := []string{
+		`{ADIVB, ydivb, Pb, opBytes{0xf6, 06}},`,
+		`{ADIVL, ydivl, Px, opBytes{0xf7, 06}},`,
+		`{ADIVQ, ydivl, Pw, opBytes{0xf7, 06}},`,
+		`{ADIVW, ydivl, Pe, opBytes{0xf7, 06}},`,
+		`{AIDIVB, ydivb, Pb, opBytes{0xf6, 07}},`,
+		`{AIDIVL, ydivl, Px, opBytes{0xf7, 07}},`,
+		`{AIDIVQ, ydivl, Pw, opBytes{0xf7, 07}},`,
+		`{AIDIVW, ydivl, Pe, opBytes{0xf7, 07}},`,
+	}
+	if !reflect.DeepEqual(actual, want) || len(x86ImplicitDivideOracle) != len(want) {
+		t.Fatal("complete Go division family/prefix/extension directory changed", actual)
+	}
+}
+
+func x86ImplicitDivideInitializedBody(name, suffix string, bits int, source string) string {
+	move := "MOV" + suffix
+	body := move + " $7,AX\n"
+	if bits == 8 {
+		body = "MOVW $7,AX\n" // Both AL and AH are mandatory dividend bytes.
+	} else {
+		body += move + " $0,DX\n"
+	}
+	if source == "CX" {
+		body += move + " $3,CX\n"
+	}
+	return body + name + " " + source + "\n"
+}
+
+func TestX86ImplicitDivideInitializedFamilyFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			var assembly, declarations strings.Builder
+			count := 0
+			for _, row := range x86ImplicitDivideOracle {
+				if target.arch == "386" && row.bits == 64 {
+					continue // Stock Go rejects Q in mode32; no supported target is skipped.
+				}
+				for _, source := range []string{"CX", "1(SI)"} {
+					name := fmt.Sprint("Divide", count)
+					fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+					fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\nMOVL $0,AX\n%sMOVL AX,ret+%d(FP)\nRET\n",
+						name, word+4, move, x86ImplicitDivideInitializedBody(row.name, row.suffix, row.bits, source), word)
+					count++
+				}
+			}
+			want := 16
+			if target.arch == "386" {
+				want = 12
+			}
+			if count != want {
+				t.Fatal("complete division direction/width/source matrix changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original division family lost its native continuation", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if regexp.MustCompile(`\b(?:sdiv|udiv|srem|urem)\b`).MatchString(text) || strings.Count(text, "asm sideeffect") != count {
+							t.Fatal("division native #DE/access effects became LLVM poison or optional arithmetic")
+						}
+						compileLLVMToObject(t, llc, target.triple, "implicit-divide.ll", "implicit-divide.o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ImplicitDivideDeadVoidRequiresEveryImplicitInput(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ImplicitDivideOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			for _, unused := range []bool{false, true} {
+				declaration, extent := "func Value()", 0
+				if unused {
+					declaration, extent = "func Value(unused bool)", 1
+				}
+				body := x86ImplicitDivideInitializedBody(row.name, row.suffix, row.bits, "CX")
+				controls := []string{"accumulator", "divisor"}
+				if row.bits != 8 {
+					controls = append(controls, "high-half")
+				} else {
+					controls = append(controls, "AH")
+				}
+				for _, missing := range controls {
+					t.Run(fmt.Sprintf("%s/%s/unused=%t/%s", arch, row.name, unused, missing), func(t *testing.T) {
+						changed := body
+						switch missing {
+						case "accumulator":
+							changed = strings.Replace(changed, "MOV"+row.suffix+" $7,AX\n", "", 1)
+							if row.bits == 8 {
+								changed = strings.Replace(changed, "MOVW $7,AX\n", "", 1)
+							}
+						case "divisor":
+							changed = strings.Replace(changed, "MOV"+row.suffix+" $3,CX\n", "", 1)
+						case "high-half":
+							changed = strings.Replace(changed, "MOV"+row.suffix+" $0,DX\n", "", 1)
+						case "AH":
+							changed = strings.Replace(changed, "MOVW $7,AX\n", "MOVB $7,AL\n", 1)
+						}
+						if changed == body {
+							t.Fatal("missing-input mutation did not change source")
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", extent, changed)
+						x86LEAActualTargetGoObject(t, arch, triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("dead division invented implicit source bytes", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImplicitDivideZeroOverflowAndWideMinCannotDisappear(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		t.Run(arch, func(t *testing.T) {
+			var assembly strings.Builder
+			signatures := make(map[string]FuncSig)
+			count := 0
+			for _, row := range x86ImplicitDivideOracle {
+				if arch == "386" && row.bits == 64 {
+					continue
+				}
+				cases := []string{"zero", "quotient-overflow"}
+				if row.signed {
+					cases = append(cases, "wide-min/-1", "narrow-min/-1")
+				}
+				for _, fault := range cases {
+					name, low, high, divisor := fmt.Sprint("Fault", count), uint64(7), uint64(0), int64(0)
+					if fault != "zero" {
+						divisor = 1
+						if row.signed {
+							low = uint64(1) << uint(row.bits-1)
+						} else {
+							low, high = 0, 1
+						}
+					}
+					if fault == "wide-min/-1" {
+						low, high, divisor = 0, uint64(1)<<uint(row.bits-1), -1
+					} else if fault == "narrow-min/-1" {
+						high, divisor = ^uint64(0), -1
+					}
+					move := "MOV" + row.suffix
+					body := fmt.Sprintf("%s $%#x,AX\n%s $%#x,DX\n", move, low, move, high)
+					if row.bits == 8 {
+						body = fmt.Sprintf("MOVW $%#x,AX\n", (low&255)|(high&255)<<8)
+					}
+					fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-0\n%s%s $%d,CX\n%s CX\nRET\n", name, body, move, divisor, row.name)
+					signatures[name] = FuncSig{Name: name, Ret: Void}
+					count++
+				}
+			}
+			requireX86GoAssemblerResult(t, arch, assembly.String(), true)
+			file, err := Parse(ArchAMD64, assembly.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir := x86ScalarFormatObjectUnit(t, file, signatures, arch, triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				if strings.Count(text, "asm sideeffect") != count || regexp.MustCompile(`\b(?:sdiv|udiv|srem|urem)\b`).MatchString(text) {
+					t.Fatal("zero/overflow #DE or wide-min/-1 became eliminated LLVM poison", arch, count)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_implicit_mask_move_source_test.go b/x86_implicit_mask_move_source_test.go
new file mode 100644
index 000000000..b6e13c896
--- /dev/null
+++ b/x86_implicit_mask_move_source_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86ImplicitMaskMoveOracleNames = []string{
+	"MASKMOVQ", "MASKMOVOU", "MASKMOVDQU", "VMASKMOVDQU",
+}
+
+func x86ImplicitMaskMoveOracleProgram(arch, op, name string) (string, string) {
+	return x86ImplicitMaskMoveOracleRegisters(arch, op, name, 0, 1)
+}
+
+func x86ImplicitMaskMoveOracleRegisters(arch, op, name string, mask, data int) (string, string) {
+	word, move, bank, width := 8, "MOVQ", "X", 16
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	load, closeTags := "MOVOU", ""
+	if op == "MASKMOVQ" {
+		bank, width, load, closeTags = "M", 8, "MOVQ", "EMMS\n"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n"+
+		"%s out+0(FP),DI\n%s mask+%d(FP),AX\n%s data+%d(FP),BX\n"+
+		"%s (AX),%s%d\n%s (BX),%s%d\n%s %s%d,%s%d\n%sSFENCE\nRET\n",
+		name, 3*word, move, move, word, move, 2*word,
+		load, bank, mask, load, bank, data, op, bank, mask, bank, data, closeTags)
+	declaration := fmt.Sprintf("func %s(out,mask,data *[%d]byte)\n", name, width)
+	return source, declaration
+}
+
+func TestX86ImplicitMaskMoveCompleteOfficialRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"varyxr=[]ytab{{Zm_r_xm,1,argList{Yxr,Yxr}},}",
+		"varymr=[]ytab{{Zm_r,1,argList{Ymr,Ymr}},}",
+		"{AMASKMOVOU,yxr,Pe,opBytes{0xf7}}",
+		"{AMASKMOVQ,ymr,Pm,opBytes{0xf7}}",
+	} {
+		if !strings.Contains(table, row) {
+			t.Fatal("complete original implicit-mask-store row changed", row)
+		}
+	}
+	data, err = os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table = strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"var_yvmaskmovdqu=[]ytab{{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yxr,Yxr}},}",
+		"{as:AVMASKMOVDQU,ytab:_yvmaskmovdqu,prefix:Pavx,op:opBytes{avxEscape|vex128|vex66|vex0F|vexW0,0xF7,}}",
+	} {
+		if !strings.Contains(table, row) {
+			t.Fatal("complete original VEX implicit-mask-store row changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index, op := range x86ImplicitMaskMoveOracleNames {
+			program, _ := x86ImplicitMaskMoveOracleProgram(arch, op, fmt.Sprint("Prior", index))
+			source.WriteString(program)
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+	}
+}
+
+// Intel SDM Vol.2B, MASKMOVDQU/MASKMOVQ: even a zero mask can retain
+// implementation-dependent address faults and the non-temporal protocol.
+// Preserve the actual instruction, not a removable llvm.masked.store.
+func TestX86ImplicitMaskMoveInitializedNativeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 required for implicit mask-store objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var operations []string
+			for _, op := range x86ImplicitMaskMoveOracleNames {
+				last := 15
+				if target.arch == "386" || op == "MASKMOVQ" {
+					last = 7
+				}
+				for _, registers := range [][2]int{{0, 1}, {0, last}, {last, 0}} {
+					name := fmt.Sprint("Store", len(operations))
+					program, declaration := x86ImplicitMaskMoveOracleRegisters(target.arch, op, name, registers[0], registers[1])
+					source.WriteString(program)
+					declarations.WriteString(declaration)
+					operations = append(operations, op)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original implicit mask-store lost its own inputs", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for index, op := range operations {
+							body := x86StringMemoryFunction(t, text, fmt.Sprint("Store", index))
+							mnemonic := strings.ToLower(op)
+							if op == "MASKMOVOU" {
+								mnemonic = "maskmovdqu"
+							}
+							if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, mnemonic) ||
+								!strings.Contains(body, "~{memory}") || strings.Contains(body, "call void @llvm.masked.store") {
+								t.Fatal("implicit non-temporal store lost its original access/fault opcode", op)
+							}
+							if op == "MASKMOVQ" && !strings.Contains(body, "emms") {
+								t.Fatal("physical MMX store lost the original x87 tag cleanup")
+							}
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ImplicitMaskMoveUnknownInputsRemainContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, op := range x86ImplicitMaskMoveOracleNames {
+			source, declaration := x86ImplicitMaskMoveOracleProgram(arch, op, "Store")
+			load, bank := "MOVOU", "X"
+			if op == "MASKMOVQ" {
+				load, bank = "MOVQ", "M"
+			}
+			for name, before := range map[string]string{
+				"pointer":      fmt.Sprintf("%s out+0(FP),DI\n", move),
+				"mask-pointer": fmt.Sprintf("%s mask+%d(FP),AX\n", move, word),
+				"data-pointer": fmt.Sprintf("%s data+%d(FP),BX\n", move, 2*word),
+				"mask":         fmt.Sprintf("%s (AX),%s0\n", load, bank),
+				"data":         fmt.Sprintf("%s (BX),%s1\n", load, bank),
+			} {
+				changed := strings.Replace(source, before, "", 1)
+				if changed == source {
+					t.Fatal("missing-input mutation did not change its original program", name)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+op+"/"+name+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, testTargetTriple("linux", arch), api)
+						if arch == "amd64" && op != "MASKMOVQ" && (name == "mask" || name == "data") {
+							x86VectorScratchCodegenControl(t, changed, declaration, arch, testTargetTriple("linux", arch), ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("implicit store invented source bytes or its DI destination", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMaskMoveBareFormsCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ImplicitMaskMoveOracleNames {
+			bank := "X"
+			if op == "MASKMOVQ" {
+				bank = "M"
+			}
+			source := fmt.Sprintf("TEXT ·Store(SB),4,$0-0\n%s %s0,%s1\nRET\n", op, bank, bank)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Store()", arch, testTargetTriple("linux", arch), api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("bare implicit store invented a mask, data or native DI address", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMaskMoveTypedRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86ImplicitMaskMoveOracleNames {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				bank, width := "X", int64(16)
+				if op == "MASKMOVQ" {
+					bank, width = "M", 8
+				}
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s0,%s1", op, bank, bank))
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 || effect.dynamicMemory {
+					t.Fatal("implicit store lacks its mandatory pure typed memory obligation", known, err)
+				}
+				reads, writes := 0, 0
+				for _, operand := range effect.operands {
+					if operand.width != width {
+						t.Fatal("implicit byte mask narrowed its possible native write extent", operand.width)
+					}
+					if operand.read {
+						reads++
+						if operand.write || operand.index < 0 || operand.index > 1 || !reflect.DeepEqual(operand.operand, ins.Args[operand.index]) {
+							t.Fatal("implicit store changed a mask or data source role")
+						}
+					}
+					if operand.write {
+						writes++
+						if operand.index != -1 || !reflect.DeepEqual(operand.operand, Operand{Kind: OpMem, Mem: MemRef{Base: DI}}) {
+							t.Fatal("implicit destination lost its architectural DI address")
+						}
+					}
+				}
+				if reads != 2 || writes != 1 || len(effect.operands) != 3 {
+					t.Fatal("implicit source/write denominator changed", reads, writes)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_implicit_multiply_effects.go b/x86_implicit_multiply_effects.go
new file mode 100644
index 000000000..53ab642b6
--- /dev/null
+++ b/x86_implicit_multiply_effects.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ImplicitMultiplyForm struct {
+	bits   int
+	signed bool
+	source Operand
+}
+
+// The implicit row is ydivb/Ymb for B and ydivl/Yml (yimul's first
+// row for IMUL) for W/L/Q. Explicit IMUL and division retain their consumers.
+func x86ImplicitMultiplyProperties(op Op, ins Instr, arch string) (x86ImplicitMultiplyForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	stem, bits, three, known := x86ScalarMultiplyDivideProperties(name)
+	if !known || three || stem != "MUL" && stem != "IMUL" || stem == "IMUL" && bits != 8 && len(ins.Args) != 1 {
+		return x86ImplicitMultiplyForm{}, false, nil
+	}
+	fail := func(reason string) (x86ImplicitMultiplyForm, bool, error) {
+		return x86ImplicitMultiplyForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || arch == "386" && bits == 64 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) || len(ins.Args) != 1 ||
+		!isX86ScalarMultiplyDivideSource(ins.Args[0], bits, arch) {
+		return fail("requires its complete implicit GP/memory source row")
+	}
+	if err := x86NamedMultiplyMemoryError(ins.Args[0], arch); err != nil {
+		return fail(err.Error())
+	}
+	return x86ImplicitMultiplyForm{bits: bits, signed: stem == "IMUL", source: ins.Args[0]}, true, nil
+}
+
+func x86NamedMultiplyMemoryError(operand Operand, arch string) error {
+	if operand.Kind != OpMem {
+		return nil
+	}
+	memory := operand.Mem
+	if err := x86SymbolIndexedMemoryError(memory, arch); err != nil {
+		return err
+	}
+	if arch == "386" && strings.HasSuffix(memory.Sym, "(SB)") {
+		memory.Base = "" // The Go named-memory row discards Reg, not Index.
+	}
+	if !x86MemoryRegistersValidForArch(memory, arch) || memory.OffRaw != "" ||
+		memory.Index == SP || memory.Index != "" && memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 ||
+		memory.Off != int64(int32(memory.Off)) && !(arch == "386" && memory.Off == int64(uint32(memory.Off))) {
+		return fmt.Errorf("has an unencodable or unresolved memory source")
+	}
+	return nil
+}
+
+// This is a numerical dependency only, not registration in the independent
+// raw-return/source-stack/caller grammars or a paired native-memory read.
+func x86TypedImplicitMultiplyByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86ImplicitMultiplyProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	width := int64(form.bits / 8)
+	effect := x86TypedByteEffect{requiresResultProof: true, flagsDefined: x86ByteFlagCF | x86ByteFlagOF, flagsKilled: x86ByteFlagsAll,
+		operands: []x86TypedByteOperand{
+			{index: 0, operand: form.source, width: width, read: true},
+			{index: -1, operand: Operand{Kind: OpReg, Reg: AX}, width: width, read: true},
+		}}
+	if form.bits == 8 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: -1, operand: Operand{Kind: OpReg, Reg: AX}, width: 2, write: true})
+	} else {
+		for _, register := range []Reg{AX, DX} {
+			effect.operands = append(effect.operands, x86TypedByteOperand{
+				index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: width, write: true})
+		}
+	}
+	return effect, true, nil
+}
+
+// Only ordinary named lowering pairs this conditional numerical result with
+// the exact volatile source load. Reuse the complete implicit effect, not a
+// second opcode, accumulator-width or FLAGS table. Standalone queries and
+// caller/frame/raw registries keep their independent storage obligations.
+func x86LoweredImplicitMultiplyNativeRead(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ImplicitMultiplyProperties(ins.Op, ins, arch)
+	if !known || form.source.Kind != OpMem || form.source.Mem.Sym != "" {
+		return false, false // Existing register, FP/AUTO and static roles remain separate.
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		form.source.Mem.Segment != "" || !x86RegisterAddressedNativeMemoryOperand(form.source, arch) {
+		return false, true
+	}
+	effect, known, err := x86TypedImplicitMultiplyByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, true
+	}
+	// Read the original address and accumulator before either AX or DX is
+	// overwritten. In particular a DX address is not a numerical DX input.
+	for _, operand := range effect.operands {
+		if operand.read && !x86ResultReadWithNativeContinuation(ins, operand.operand, operand.width, state, owned, arch, true) {
+			return false, true
+		}
+	}
+	for _, operand := range effect.operands {
+		if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
diff --git a/x86_implicit_multiply_family_test.go b/x86_implicit_multiply_family_test.go
new file mode 100644
index 000000000..0539661b0
--- /dev/null
+++ b/x86_implicit_multiply_family_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ImplicitMultiplyCompleteOfficialGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, rows := range map[string]string{
+		"ydivb": `{Zm_o,2,argList{Ymb}},`,
+		"ydivl": `{Zm_o,2,argList{Yml}},`,
+		"yimul": `{Zm_o,2,argList{Yml}},{Zib_rr,1,argList{Yi8,Yrl}},{Zil_rr,1,argList{Yi32,Yrl}},{Zm_r,2,argList{Yml,Yrl}},`,
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(match) != 2 || regexp.MustCompile(`\s+`).ReplaceAllString(string(match[1]), "") != rows {
+			t.Fatal("complete actual Go multiply rows changed", table)
+		}
+	}
+	actual := regexp.MustCompile(`\{A(?:I?MUL)[BWLQ], [^\n]+`).FindAllString(string(data), -1)
+	want := []string{
+		`{AIMULB, ydivb, Pb, opBytes{0xf6, 05}},`,
+		`{AIMULL, yimul, Px, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AIMULQ, yimul, Pw, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AIMULW, yimul, Pe, opBytes{0xf7, 05, 0x6b, 0x69, Pm, 0xaf}},`,
+		`{AMULB, ydivb, Pb, opBytes{0xf6, 04}},`,
+		`{AMULL, ydivl, Px, opBytes{0xf7, 04}},`,
+		`{AMULQ, ydivl, Pw, opBytes{0xf7, 04}},`,
+		`{AMULW, ydivl, Pe, opBytes{0xf7, 04}},`,
+	}
+	if !reflect.DeepEqual(actual, want) {
+		t.Fatal("complete opcode/table/prefix/byte-offset attributes changed", actual)
+	}
+}
+
+func TestX86ImplicitMultiplyGrammarBanksAndMemoryBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ImplicitMultiplyCases(arch) {
+			for _, register := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH BL BH CL CH DL DH BPB SIB DIB R8B R15B X0 Y0 Z0 K1 M0 FS TLS R16") {
+				t.Run(arch+"/"+row.op+"/"+register, func(t *testing.T) {
+					ins := Instr{Op: Op(row.op), Args: []Operand{{Kind: OpReg, Reg: Reg(register)}}, Raw: row.op + " " + register}
+					before := ins
+					before.Args = append([]Operand(nil), ins.Args...)
+					gp := strings.Contains(" AX CX DX BX SP BP SI DI ", " "+register+" ") || arch == "amd64" && regexp.MustCompile(`^R(?:[89]|1[0-5])$`).MatchString(register)
+					valid := gp
+					if row.width == 1 {
+						valid = gp && (arch != "386" || register != "SP") || strings.Contains(" AL AH BL BH CL CH DL DH ", " "+register+" ") || arch == "amd64" && strings.Contains(" BPB SIB DIB R8B R15B ", " "+register+" ")
+					}
+					_, known, err := x86ImplicitMultiplyProperties(ins.Op, ins, arch)
+					if !known || (err == nil) != valid || !reflect.DeepEqual(ins, before) {
+						t.Fatal("complete named source bank/identity mismatch", valid, known, err)
+					}
+				})
+			}
+		}
+		for _, instruction := range []string{"MULL $3", "MULL $1.0", "MULL $x(SB)", "MULL", "MULL AX,BX", "IMULB AX,BX", "MULL (AX)(SP*1)", "MULL (AX)(BX*3)", "MULL (AX)(BX)", "MULL $slot+0(FP)"} {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+instruction+"\nRET\n")
+			if err != nil {
+				continue // Malformed source syntax has already been rejected, not granted a typed effect.
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if _, known, err := x86ImplicitMultiplyProperties(ins.Op, ins, arch); !known || err == nil {
+				t.Fatal("invalid implicit form acquired numerical effect", arch, instruction)
+			}
+		}
+		for _, instruction := range []string{"MULL x+1(FP)", "MULL -4(SP)", "MULL 4(AX)(SI*2)", "MULL table(SB)"} {
+			ins := x86YMMReadSource(t, instruction)
+			if _, known, err := x86ImplicitMultiplyProperties(ins.Op, ins, arch); !known || err != nil {
+				t.Fatal("grammar inferred a storage permission/rejected valid memory shape", arch, instruction, err)
+			}
+			state := x86ResultState{}
+			state.gp[0] = 255
+			if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+				t.Fatal("shape alone initialized unowned FP/AUTO/SB/native storage", instruction)
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyIndependentStorageCannotBypassNUM(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move, push, pop, lea := goWordSize(target.arch), "MOVQ", "PUSHQ", "POPQ", "LEAQ"
+		if target.arch == "386" {
+			move, push, pop, lea = "MOVL", "PUSHL", "POPL", "LEAL"
+		}
+		for _, row := range []struct {
+			name, params, storage string
+			writes, knownValid    bool
+		}{
+			{"bool-input", "flag bool", "", true, true},
+			{"bool-input-unwritten", "flag bool", "", false, false},
+			{"unused-result-address", "", fmt.Sprintf("%s ret+0(FP),SI\n", lea), true, true},
+			{"value-stack", "", push + " $7\n" + pop + " SI\n", true, true},
+			{"input-store", "flag uint32", "MOVL $1,flag+0(FP)\n", true, false},
+			{"unbacked-SP", "", move + " $7,-8(SP)\n", true, false},
+		} {
+			for _, initialized := range []bool{false, true} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/initialized=%t/%s", target.triple, row.name, initialized, api), func(t *testing.T) {
+						result := 0
+						if row.params != "" {
+							result = word
+						}
+						body := row.storage
+						if initialized {
+							body += "MOVL $2,AX\nMOVL $3,BX\n"
+						}
+						body += "MULL BX\n"
+						if row.writes {
+							body += fmt.Sprintf("MOVL AX,ret+%d(FP)\n", result)
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", result+4, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value("+row.params+") uint32", target.arch, target.triple, api)
+						if !initialized || !row.knownValid {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("storage syntax substituted for implicit NUM/result proof: output=%t error=%v", ir != "", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("independent checked storage lost a complete product", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyAliasesReadBeforeWriteAndFlags(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, stem := range []string{"MUL", "IMUL"} {
+			for _, source := range []string{"AL", "AH", "AX", "DX", "BP", "SI", "DI"} {
+				if target.arch == "amd64" && source == "BP" {
+					continue // Physical AMD64 frame role, independently rejected below.
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+stem+"/"+source+"/"+api, func(t *testing.T) {
+						body := "MOVL $0x0302,AX\nMOVL $5,DX\n"
+						want := uint64(10)
+						if source == "AL" || source == "AX" {
+							want = 4
+						} else if source == "AH" {
+							want = 6
+						} else if source != "DX" {
+							body += "MOVL $5," + source + "\n"
+						}
+						body += stem + "B " + source + "\nMOVW AX,ret+0(FP)\nRET\n"
+						ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·Value(SB),4,$0-2\n"+body, "func Value() uint16", target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{want})
+					})
+				}
+			}
+			for _, row := range x86ImplicitMultiplyCases(target.arch) {
+				if !strings.HasPrefix(row.op, stem) { // MUL and IMUL have independent sign rules.
+					continue
+				}
+				for _, flag := range []string{"CS", "OS", "EQ", "MI", "PS", "overflow-CS", "overflow-OS"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row.op+"/status"+flag+"/"+api, func(t *testing.T) {
+							move := map[int]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[row.width]
+							input, multiplier, want := "-1", 1, uint64(0)
+							condition := strings.TrimPrefix(flag, "overflow-")
+							if condition != flag {
+								multiplier, want = 2, 1
+								if strings.HasPrefix(row.op, "IMUL") {
+									input = fmt.Sprint((uint64(1) << uint(row.width*8-1)) - 1)
+								}
+							}
+							source := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nCLD\nMOVL $0,AX\nCMPL AX,$0\n%s $%s,AX\n%s $%d,BX\n%s BX\nSET%s CX\nMOVB CX,ret+0(FP)\nRET\n", move, input, move, multiplier, row.op, condition)
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint8", target.arch, target.triple, api)
+							if condition != "CS" && condition != "OS" {
+								if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+									t.Fatal("multiply reused undefined status", err)
+								}
+								return
+							}
+							if err != nil {
+								t.Fatal(err)
+							}
+							x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{want}) // Signed -1*1 has a nonzero high half but no overflow.
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_implicit_multiply_native_effect_test.go b/x86_implicit_multiply_native_effect_test.go
new file mode 100644
index 000000000..28841b068
--- /dev/null
+++ b/x86_implicit_multiply_native_effect_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86ImplicitMultiplyNativeExpected(input x86ResultState, bits int, arch string) x86ResultState {
+	result := input.clone()
+	writes, width := []Reg{AX, DX}, int64(bits/8)
+	if bits == 8 {
+		writes, width = writes[:1], 2 // AL × m8 writes AX16, not DX.
+	}
+	for _, register := range writes {
+		index, mask, _ := x86ResultGP(register, width, arch)
+		result.pointerGP[index] = false
+		result.gp[index] |= mask
+		if width == 4 || width == 8 {
+			result.gp[index] = 255
+		}
+	}
+	result.flags = x86ByteFlagCF | x86ByteFlagOF
+	return result
+}
+
+func TestX86ImplicitMultiplyNativeMemoryEveryByteAndExactOutputState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitMultiplyNativeOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.op+" 1(SI)(BX*2)")
+				ax, needed, _ := x86ResultGP(AX, int64(row.bits/8), arch)
+				bx, _, _ := x86ResultGP(BX, x86ResultPointerWord(arch), arch)
+				si, _, _ := x86ResultGP(SI, x86ResultPointerWord(arch), arch)
+				dx, _, _ := x86ResultGP(DX, x86ResultPointerWord(arch), arch)
+				original := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+					fp: []bool{true, false}, auto: []bool{false, true}}
+				original.gp[bx], original.gp[dx], original.pointerGP[si] = 255, 0x80, true
+				original.masks[2] = true
+				original.writeVector(3, 64, 0x5555555555555555, false)
+				for seed := 0; seed < 256; seed++ {
+					before := original.clone()
+					before.gp[ax] = uint8(seed)
+					state, expected := before.clone(), before.clone()
+					accept := uint8(seed)&needed == needed
+					if accept {
+						expected = x86ImplicitMultiplyNativeExpected(before, row.bits, arch)
+					}
+					got, known := x86LoweredImplicitMultiplyNativeRead(ins, &state, nil, 0, arch)
+					if !known || got != accept || !reflect.DeepEqual(state, expected) {
+						t.Fatal("native multiplication changed its exact byte/FLAGS/storage domain", seed, needed, got, state, expected)
+					}
+				}
+				for _, missing := range []string{"pointer", "unknown-address", "partial-address", "index"} {
+					before := original.clone()
+					before.gp[ax] = 255
+					if missing == "pointer" {
+						before.pointerGP[si], before.gp[si] = false, 255
+					} else if missing == "unknown-address" || missing == "partial-address" {
+						before.pointerGP[si], before.gp[si] = false, 0
+						if missing == "partial-address" {
+							before.gp[si] = 1
+						}
+					} else {
+						before.gp[bx] = 0
+					}
+					state := before.clone()
+					if missing == "pointer" {
+						accepted, known := x86LoweredImplicitMultiplyNativeRead(ins, &state, nil, 0, arch)
+						if !known || !accepted || !reflect.DeepEqual(state, x86ImplicitMultiplyNativeExpected(before, row.bits, arch)) {
+							t.Fatal("complete numerical address changed the product or acquired a pointer role")
+						}
+						continue
+					}
+					if accepted, known := x86LoweredImplicitMultiplyNativeRead(ins, &state, nil, 0, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("a rejected native input invented permission or partially mutated state", missing)
+					}
+				}
+				// A source address can be old DX without numerical DX. Read it
+				// before the implicit high-product write revokes its pointer tag.
+				alias := x86YMMReadSource(t, fmt.Sprintf("%s (DX)", row.op))
+				before := original.clone()
+				before.gp[ax], before.gp[dx], before.pointerGP[dx] = 255, 0, true
+				state := before.clone()
+				if accepted, known := x86LoweredImplicitMultiplyNativeRead(alias, &state, nil, 0, arch); !known || !accepted ||
+					!reflect.DeepEqual(state, x86ImplicitMultiplyNativeExpected(before, row.bits, arch)) {
+					t.Fatal("DX address/result alias was read after write or acquired missing upper bytes")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_implicit_multiply_native_input_test.go b/x86_implicit_multiply_native_input_test.go
new file mode 100644
index 000000000..84f7f5f3e
--- /dev/null
+++ b/x86_implicit_multiply_native_input_test.go
@@ -0,0 +1,297 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Independent of the production properties. The existing official-table root
+// binds all eight rows, while explicit IMUL's two-/three-operand owners remain
+// separate. B consumes AL, writes AX16 and does not write DX.
+var x86ImplicitMultiplyNativeOracle = []struct {
+	op     string
+	bits   int
+	signed bool
+}{
+	{"MULB", 8, false}, {"MULW", 16, false},
+	{"MULL", 32, false}, {"MULQ", 64, false},
+	{"IMULB", 8, true}, {"IMULW", 16, true},
+	{"IMULL", 32, true}, {"IMULQ", 64, true},
+}
+
+func x86ImplicitMultiplyNativeSource(name, op, arch, address, result string, dead bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	base := "BX"
+	if address == "(DX)" {
+		base = "DX"
+	}
+	body := move + " $-1,AX\n" + move + " $0x4321,DX\n" +
+		move + " p+0(FP)," + base + "\n" + move + " $3,CX\n" + op + " " + address + "\n"
+	extent, declaration := word*2, fmt.Sprintf("func %s(p *byte) uintptr", name)
+	if dead {
+		extent, declaration = word, fmt.Sprintf("func %s(p *byte)", name)
+	} else {
+		body += fmt.Sprintf("%s %s,ret+%d(FP)\n", move, result, word)
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%sRET\n", name, extent, body), declaration
+}
+
+func TestX86ImplicitMultiplyNativeMemoryIndependentGoEncoding(t *testing.T) {
+	if len(x86ImplicitMultiplyNativeOracle) != 8 {
+		t.Fatal("complete eight-member implicit multiply directory changed")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ImplicitMultiplyNativeOracle {
+			if arch == "386" && row.bits == 64 {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row.op+" (BX)\nRET\n", "", false)
+				continue
+			}
+			for _, address := range []string{"(BX)", "1(BX)(CX*2)", "(DX)"} {
+				t.Run(arch+"/"+row.op+"/"+address, func(t *testing.T) {
+					var expected []byte
+					if row.bits == 16 {
+						expected = append(expected, 0x66)
+					} else if row.bits == 64 {
+						expected = append(expected, 0x48)
+					}
+					opcode, extension := byte(0xf7), byte(4<<3)
+					if row.bits == 8 {
+						opcode = 0xf6
+					}
+					if row.signed {
+						extension = 5 << 3
+					}
+					expected = append(expected, opcode)
+					switch address {
+					case "(BX)":
+						expected = append(expected, extension|3)
+					case "(DX)":
+						expected = append(expected, extension|2)
+					default:
+						expected = append(expected, extension|0x44, 0x4b, 1)
+					}
+					expected = append(expected, 0xc3)
+					actual := x86OrderingHintGoBytes(t, arch, "TEXT format(SB),4,$0-0\n"+row.op+" "+address+"\nRET\n")
+					if !bytes.Equal(actual, expected) {
+						t.Fatalf("complete original Go memory opcode differs: got=%x want=%x", actual, expected)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyNativeMemoryInitializedThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := x86AddressMemoryTargets(arch)[0]
+		for _, row := range x86ImplicitMultiplyNativeOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			source, declaration := x86ImplicitMultiplyNativeSource("Value", row.op, arch, "(BX)", "AX", false)
+			control := strings.Replace(source, row.op+" (BX)", row.op+" CX", 1)
+			// A real Go object precedes every public consumer. The same initialized
+			// program with only its source changed to a numerical GP must pass first.
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			x86LEAActualTargetGoObject(t, arch, triple, control)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.op+"/"+api, func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, control, declaration, arch, triple, api); err != nil || ir == "" {
+						t.Fatal("independently initialized register control failed before native memory", err)
+					}
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+						t.Fatal("real pointer and accumulator lost their exact native multiply continuation", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyNativeMemoryDeadAccessAndExactWidths(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := x86AddressMemoryTargets(arch)[0]
+		for _, row := range x86ImplicitMultiplyNativeOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			source, declaration := x86ImplicitMultiplyNativeSource("Value", row.op, arch, "1(BX)(CX*2)", "AX", true)
+			// Even an identically zero product with no result must still fault on
+			// its exact source bytes. No claim of fault execution follows from IR.
+			source = strings.Replace(source, "$-1,AX", "$0,AX", 1)
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			move := "MOVQ"
+			if arch == "386" {
+				move = "MOVL"
+			}
+			for _, missing := range []string{"", "accumulator", "pointer", "index"} {
+				changed := source
+				line := map[string]string{
+					"accumulator": move + " $0,AX\n", "pointer": move + " p+0(FP),BX\n", "index": move + " $3,CX\n",
+				}[missing]
+				if missing != "" {
+					changed = strings.Replace(changed, line, "", 1)
+					if changed == source {
+						t.Fatal("dead-input mutation did not change source", missing)
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+row.op+"/missing="+missing+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if missing != "" {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("dead product invented an accumulator, address or index", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("initialized dead native access rejected", err)
+						}
+						for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86ImplicitMultiplyNativeExactReads(t, input, row.bits, 1)
+							if strings.Contains(input, "store volatile") {
+								t.Fatal("dead product invented a memory write")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86ImplicitMultiplyNativeExactReads(t *testing.T, ir string, bits, count int) {
+	t.Helper()
+	needle := fmt.Sprintf("load volatile i%d,", bits)
+	if strings.Count(ir, needle) != count {
+		t.Fatal("native multiplication lost its exact observable source width", bits, count)
+	}
+	alignment := regexp.MustCompile(`\balign 1(?:,|$)`)
+	for _, line := range strings.Split(ir, "\n") {
+		if strings.Contains(line, needle) && !alignment.MatchString(line) {
+			t.Fatal("native multiplication asserted unobserved source alignment", line)
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyNativeMemoryInputsStatusAndAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word := "MOVQ", goWordSize(arch)
+		if arch == "386" {
+			move = "MOVL"
+		}
+		triple := x86AddressMemoryTargets(arch)[0]
+		for _, row := range x86ImplicitMultiplyNativeOracle {
+			if arch == "386" && row.bits == 64 {
+				continue
+			}
+			source, declaration := x86ImplicitMultiplyNativeSource("Value", row.op, arch, "1(BX)(CX*2)", "AX", false)
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, change := range []string{"accumulator", "pointer", "index", "numerical address", "pointer accumulator", "unknown upper accumulator", "CF", "OF", "ZF", "SF", "PF", "AF"} {
+				changed := source
+				valid := change == "CF" || change == "OF" || change == "numerical address"
+				switch change {
+				case "accumulator":
+					changed = strings.Replace(changed, move+" $-1,AX\n", "", 1)
+				case "pointer":
+					changed = strings.Replace(changed, move+" p+0(FP),BX\n", "", 1)
+				case "index":
+					changed = strings.Replace(changed, move+" $3,CX\n", "", 1)
+				case "numerical address":
+					changed = strings.Replace(changed, move+" p+0(FP),BX", move+" $4096,BX", 1)
+				case "pointer accumulator":
+					changed = strings.Replace(changed, move+" $-1,AX", move+" p+0(FP),AX", 1)
+				case "unknown upper accumulator":
+					changed = strings.Replace(changed, move+" $-1,AX", "MOVB $-1,AL", 1)
+					// B consumes only AL, but returning uintptr still observes the
+					// unwritten bytes above AX16. No zeroed implementation slot helps.
+				default:
+					predicate := map[string]string{"CF": "CS", "OF": "OS", "ZF": "EQ", "SF": "MI", "PF": "PS", "AF": ""}[change]
+					observation := "LAHF\nMOVBLZX AH,AX\n"
+					if predicate != "" {
+						observation = "SET" + predicate + " CX\nMOVBLZX CX,AX\n"
+					}
+					changed = strings.Replace(changed, row.op+" 1(BX)(CX*2)", "CMPL AX,AX\n"+row.op+" 1(BX)(CX*2)", 1)
+					changed = strings.Replace(changed, fmt.Sprintf("%s AX,ret+%d(FP)", move, word), observation+fmt.Sprintf("%s AX,ret+%d(FP)", move, word), 1)
+				}
+				if changed == source {
+					t.Fatal("input/status negative did not change its original program", change)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+row.op+"/"+change+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if valid {
+							if err != nil || ir == "" {
+								t.Fatal("multiply lost its only defined status outputs", err)
+							}
+							if change == "numerical address" {
+								pointerIR, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+								if err != nil {
+									t.Fatal(err)
+								}
+								x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+								x86RequireNumericNativeSourceContext(t, changed, declaration, arch)
+								x86NumericNativeAddressObject(t, ir, triple)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("multiply invented input bytes, address authority or undefined FLAGS", err)
+						}
+					})
+				}
+			}
+
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration,
+				strings.SplitN(strings.TrimSuffix(source, "\n"), "\n", 2)[1])
+			original := file.Funcs[0]
+			ordinal := -1
+			for index, ins := range original.Instrs {
+				if string(ins.Op) == row.op {
+					ordinal = index
+					state := x86ResultState{}
+					accumulator, _, _ := x86ResultGP(AX, int64(word), arch)
+					index, _, _ := x86ResultGP(CX, int64(word), arch)
+					pointer, _, _ := x86ResultGP(BX, int64(word), arch)
+					state.gp[accumulator], state.gp[index], state.pointerGP[pointer] = 255, 255, true
+					before := state.clone()
+					if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("standalone query borrowed a paired native source or mutated its rejected state")
+					}
+				}
+			}
+			if ordinal < 0 {
+				t.Fatal("original complete program lost its source ordinal")
+			}
+			for _, change := range []string{"encoded", "raw", "address size", "segment", "raw entry"} {
+				t.Run(arch+"/"+row.op+"/origin/"+change, func(t *testing.T) {
+					changed := original
+					changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					ins := &changed.Instrs[ordinal]
+					switch change {
+					case "encoded":
+						ins.x86Encoded = true
+					case "raw":
+						ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: append([]Operand(nil), ins.Args...)}
+					case "address size":
+						ins.x86AddressBits = 16
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "raw entry":
+						changed.X86RawText = []byte{0xc3}
+					}
+					consumer := amd64Ctx{fpScalarSource: changed, sig: sig, fpSourceSig: sig, goarch: arch, targetTriple: triple}
+					if err := consumer.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("paired multiplication borrowed another raw/physical entry or native source mode", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_implicit_multiply_native_objects_test.go b/x86_implicit_multiply_native_objects_test.go
new file mode 100644
index 000000000..eeb99d785
--- /dev/null
+++ b/x86_implicit_multiply_native_objects_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ImplicitMultiplyNativeMemoryLinuxAMD64Objects(t *testing.T) {
+	x86ImplicitMultiplyNativeObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86ImplicitMultiplyNativeMemoryDarwinAMD64Objects(t *testing.T) {
+	x86ImplicitMultiplyNativeObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86ImplicitMultiplyNativeMemoryWindowsAMD64Objects(t *testing.T) {
+	x86ImplicitMultiplyNativeObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86ImplicitMultiplyNativeMemoryLinux386Objects(t *testing.T) {
+	x86ImplicitMultiplyNativeObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86ImplicitMultiplyNativeMemoryWindows386Objects(t *testing.T) {
+	x86ImplicitMultiplyNativeObjects(t, "386", "i686-pc-windows-msvc")
+}
+
+// Orthogonal witnesses: every family member, base/SIB addressing, both
+// accumulator outputs, and a read-before-write DX address alias. Each capture
+// owns 40 amd64 or 30 mode32 functions, not a repeated full grammar Cartesian.
+func x86ImplicitMultiplyNativeObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var assembly, declarations strings.Builder
+	count := 0
+	for _, row := range x86ImplicitMultiplyNativeOracle {
+		if arch == "386" && row.bits == 64 {
+			continue
+		}
+		for _, address := range []string{"(BX)", "1(BX)(CX*2)", "(DX)"} {
+			for _, output := range []string{"AX", "DX"} {
+				if address == "(DX)" && output == "DX" {
+					continue // B preserves its real pointer; no pointer-to-NUM return.
+				}
+				source, declaration := x86ImplicitMultiplyNativeSource(fmt.Sprint("Product", count), row.op, arch, address, output, false)
+				assembly.WriteString(source)
+				declarations.WriteString(declaration + "\n")
+				count++
+			}
+		}
+	}
+	want := 40
+	if arch == "386" {
+		want = 30
+	}
+	if count != want {
+		t.Fatal("complete native multiply member/alias witness directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, assembly.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, triple, api)
+			if err != nil || strings.Count(ir, "define ") != want {
+				t.Fatal("complete initialized native multiply objects lost their source continuation", err)
+			}
+			optimized := x86DwordProductIROptimize(t, ir)
+			for _, pipeline := range []struct{ name, text, level string }{
+				{"O0", ir, "-O0"}, {"O2", ir, "-O2"}, {"IR-O2/O2", optimized, "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					if strings.Count(pipeline.text, "load volatile i") != want || strings.Contains(pipeline.text, "store volatile") {
+						t.Fatal("complete exact-width reads disappeared or gained stores")
+					}
+					for _, bits := range []int{8, 16, 32, 64} {
+						reads := 10 // Two signedness members times five independent forms.
+						if arch == "386" && bits == 64 {
+							reads = 0
+						}
+						x86ImplicitMultiplyNativeExactReads(t, pipeline.text, bits, reads)
+					}
+					x86PackedStringCompileObject(t, llc, triple, pipeline.text, pipeline.level)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_implicit_multiply_objects_test.go b/x86_implicit_multiply_objects_test.go
new file mode 100644
index 000000000..e16d529bb
--- /dev/null
+++ b/x86_implicit_multiply_objects_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ImplicitMultiplyOriginalGoGrammarAndEncoding(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ImplicitMultiplyCases(arch) {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				code := x86OrderingHintGoBytes(t, arch, "TEXT product(SB),4,$0-0\n"+row.op+" BX\nRET\n")
+				var want []byte
+				if row.width == 2 {
+					want = append(want, 0x66)
+				} else if row.width == 8 {
+					want = append(want, 0x48)
+				}
+				opcode, modrm := byte(0xf7), byte(0xe3)
+				if row.width == 1 {
+					opcode = 0xf6
+				}
+				if strings.HasPrefix(row.op, "IMUL") {
+					modrm += 8
+				}
+				want = append(want, opcode, modrm, 0xc3)
+				if !bytes.Equal(code, want) {
+					t.Fatalf("actual Go implicit row bytes=%x, independent row=%x", code, want)
+				}
+				registers := strings.Fields("AX CX DX BX SP BP SI DI")
+				if arch == "amd64" {
+					registers = append(registers, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15")...)
+				}
+				if row.width == 1 {
+					registers = append(registers, strings.Fields("AL AH BL BH CL CH DL DH")...)
+					if arch == "amd64" {
+						registers = append(registers, strings.Fields("BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B")...)
+					}
+				}
+				var bank strings.Builder
+				bank.WriteString("TEXT bank(SB),4,$0-32\n")
+				for _, register := range registers {
+					if arch == "386" && row.width == 1 && register == "SP" {
+						continue // Go rejects direct SP byte; BP/SI/DI use its BX synthesis.
+					}
+					fmt.Fprintf(&bank, "%s %s\n", row.op, register)
+				}
+				for _, source := range []string{"x+0(FP)", "x+1(FP)", "4(AX)(SI*2)", "table(SB)"} {
+					fmt.Fprintf(&bank, "%s %s\n", row.op, source)
+				}
+				bank.WriteString("RET\n")
+				goAssemblerOracleOutput(t, arch, bank.String(), "", true)
+			})
+		}
+		for _, instruction := range []string{"MULB $1", "IMULB AX,BX", "MULL X0", "MULL $slot+0(FP)", "MULL AX,BX", "MULQ X0"} {
+			t.Run(arch+"/invalid/"+instruction, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			})
+		}
+		if arch == "386" {
+			for _, instruction := range []string{"MULQ AX", "IMULQ AX", "MULB SP", "MULB R8B"} {
+				t.Run(arch+"/invalid/"+instruction, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT invalid(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete implicit product objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			appendFunction := func(body, declaration string) {
+				name := fmt.Sprintf("Product%d", strings.Count(source.String(), "TEXT ·"))
+				source.WriteString(strings.ReplaceAll(body, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+			}
+			for _, row := range x86ImplicitMultiplyCases(target.arch) {
+				appendFunction(row.source, row.declaration)
+			}
+			for _, row := range x86ImplicitMultiplyFPCases(target.arch) {
+				for _, stem := range []string{"MUL", "IMUL"} {
+					body, declaration := x86ImplicitMultiplyFPFixture(row, stem, target.arch)
+					appendFunction(body, declaration)
+				}
+			}
+			count := 40
+			if target.arch == "386" {
+				count = 30
+			}
+			if strings.Count(source.String(), "TEXT ·") != count {
+				t.Fatal("complete implicit product/FP source inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != count {
+						t.Fatal("complete typed product object fixture failed", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_initialized_probe.go b/x86_initialized_probe.go
new file mode 100644
index 000000000..9e20b8796
--- /dev/null
+++ b/x86_initialized_probe.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "fmt"
+
+// InitializedMaskLogicalProbeSequence constructs a counterfactual source probe
+// for the complete K-register logical family. It is not evidence about the
+// original program's inputs, a source binding, or permission to access memory.
+// The returned sequence explicitly initializes only the actual mask inputs and
+// retains the original instruction. Callers must probe/translate it separately.
+func InitializedMaskLogicalProbeSequence(goarch string, ins Instr) ([]Instr, bool, error) {
+	spec, known, err := x86MaskLogicalProperties(ins.Op, ins, goarch)
+	if !known || err != nil {
+		return nil, known, err
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return nil, true, fmt.Errorf("initialized mask logical probe requires an exact named instruction, not raw encoding or address overrides")
+	}
+	inputs := 2
+	if spec.kind == amd64MaskNot {
+		inputs = 1
+	}
+	sequence := []Instr{{
+		Op: "MOVL", Raw: "MOVL $3,AX",
+		Args: []Operand{{Kind: OpImm, Imm: 3}, {Kind: OpReg, Reg: "AX"}},
+	}}
+	seen := make(map[Reg]bool)
+	for _, input := range ins.Args[:inputs] {
+		if seen[input.Reg] {
+			continue
+		}
+		seen[input.Reg] = true
+		sequence = append(sequence, Instr{
+			Op: "KMOVD", Raw: fmt.Sprintf("KMOVD AX,%s", input.Reg),
+			Args: []Operand{{Kind: OpReg, Reg: "AX"}, input},
+		})
+	}
+	return append(sequence, ins), true, nil
+}
diff --git a/x86_initialized_probe_test.go b/x86_initialized_probe_test.go
new file mode 100644
index 000000000..8e3519b60
--- /dev/null
+++ b/x86_initialized_probe_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import "testing"
+
+func TestInitializedMaskLogicalProbeSourceBoundaries(t *testing.T) {
+	for _, source := range []string{
+		"KANDQ K0,K7", "KNOTQ K0,K7,K3", "KANDQ K8,K7,K3",
+		"KANDQ (AX),K7,K3", "KANDQ.Z K0,K7,K3",
+	} {
+		t.Run(source, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, source)
+			if sequence, known, err := InitializedMaskLogicalProbeSequence("amd64", ins); !known || err == nil || sequence != nil {
+				t.Fatal("malformed family acquired initialized source", sequence, known, err)
+			}
+		})
+	}
+	ins := x86ScalarLaneInstruction(t, "KANDQ K0,K7,K3")
+	for _, origin := range []string{"encoded", "raw-source", "address-size", "segment"} {
+		t.Run(origin, func(t *testing.T) {
+			modified := ins
+			switch origin {
+			case "encoded":
+				modified.x86Encoded = true
+			case "raw-source":
+				modified.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+			case "address-size":
+				modified.x86AddressBits = 32
+			case "segment":
+				modified.x86SegmentPrefix = 0x64
+			}
+			if sequence, known, err := InitializedMaskLogicalProbeSequence("amd64", modified); !known || err == nil || sequence != nil {
+				t.Fatal("raw/override origin acquired named initialization", sequence, known, err)
+			}
+		})
+	}
+	if sequence, known, err := InitializedMaskLogicalProbeSequence("arm64", ins); !known || err == nil || sequence != nil {
+		t.Fatal("foreign architecture acquired mask initialization", sequence, known, err)
+	}
+	other := x86ScalarLaneInstruction(t, "PSLLW X1,X0")
+	if sequence, known, err := InitializedMaskLogicalProbeSequence("amd64", other); known || err != nil || sequence != nil {
+		t.Fatal("profile expanded beyond its registered typed family", sequence, known, err)
+	}
+}
diff --git a/x86_inlane_permute_format_test.go b/x86_inlane_permute_format_test.go
new file mode 100644
index 000000000..0909de8d7
--- /dev/null
+++ b/x86_inlane_permute_format_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// An operand/emitter object is not an initialized public program. Preserve
+// the entire actual Go object and all three public Context outcomes first.
+// Go-accepted mode32 high banks remain physical Context, not low-bank aliases.
+func x86InLanePermuteUnboundFormatObject(t *testing.T, source, arch, triple string, wantPhysical, wantContext int) string {
+	t.Helper()
+	return x86ElementPermuteUnboundFormatObject(t, source, arch, triple, wantPhysical, wantContext)
+}
+
+func x86ElementPermuteUnboundFormatObject(t *testing.T, source, arch, triple string, wantPhysical, wantContext int) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("complete original permute formats lost their decoded source", err)
+	}
+	units := *normalized
+	units.Funcs = nil
+	physical, contextual := 0, 0
+	for _, function := range normalized.Funcs {
+		unit := function
+		unit.Instrs = nil
+		for _, instruction := range function.Instrs {
+			if instruction.Op != OpTEXT && instruction.Op != OpRET {
+				_, known, err := x86ElementPermuteProperties(instruction.Op, instruction, arch)
+				if !known {
+					_, known, err = x86Shuffle128BitBlocksProperties(instruction.Op, instruction, arch)
+				}
+				if known && errors.Is(err, ErrProbeNeedsContext) && arch == "386" &&
+					x86Mode32VectorRegisterContext(instruction, arch) != nil {
+					contextual++
+					continue // The original complete Go/Context controls above retain this row.
+				}
+				if !known || err != nil {
+					t.Fatal("original permute row lost its complete typed grammar", instruction.Raw, err)
+				}
+				physical++
+			}
+			unit.Instrs = append(unit.Instrs, instruction)
+		}
+		units.Funcs = append(units.Funcs, unit)
+	}
+	if physical != wantPhysical || contextual != wantContext {
+		t.Fatal("original permute format classification changed", physical, contextual, wantPhysical, wantContext)
+	}
+	t.Logf("complete original Go/public Context retained; %d physical emitter formats and %d Go-accepted mode32 high-bank Context rows; no initialized/native execution claim", physical, contextual)
+	return x86InstructionFormatObjectUnit(t, &units, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			form, known, err := x86ElementPermuteProperties(instruction.Op, instruction, arch)
+			if !known {
+				return c.lowerShuffle128BitBlocks(instruction.Op, instruction)
+			}
+			if !known || err != nil {
+				return known, false, err
+			}
+			return c.lowerElementPermute(form, instruction)
+		})
+}
+
+func x86ElementPermuteCompileFormatObjects(t *testing.T, llc, triple, ir string) {
+	t.Helper()
+	for _, pipeline := range []struct{ ir, level string }{
+		{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+	} {
+		x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+	}
+}
diff --git a/x86_inlane_permute_native_inputs_test.go b/x86_inlane_permute_native_inputs_test.go
new file mode 100644
index 000000000..e0f2b79ad
--- /dev/null
+++ b/x86_inlane_permute_native_inputs_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86InLanePermuteOriginalConformanceThreeAPIObjects(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const header = "TEXT ·inLaneFloatingPermuteSemantics(SB), NOSPLIT, $0-24\n"
+	start := strings.Index(string(data), header)
+	if start < 0 {
+		t.Fatal("complete original in-lane permute function missing")
+	}
+	end := strings.Index(string(data[start:]), "\n\tRET\n")
+	if end < 0 {
+		t.Fatal("complete original in-lane permute return missing")
+	}
+	source := "#include \"textflag.h\"\n" + string(data[start:start+end+len("\n\tRET\n")])
+	x86PackedFaultProgramObjects(t, source,
+		"func inLaneFloatingPermuteSemantics(out *[144]byte, data *[32]byte, control *[32]byte)")
+}
+
+func x86InLanePermuteInitializedSource(arch string) (string, string, int) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range []string{"VPERMILPS", "VPERMILPD"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, immediate := range []bool{false, true} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if arch == "386" && mode != "plain" {
+						continue // Real Go named four-operand rows are not mode32 inputs.
+					}
+					name := fmt.Sprintf("Permute%d", count)
+					fmt.Fprintf(&declarations, "func %s(out *[66]byte, data *[64]byte, control *[64]byte)\n", name)
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s out+0(FP),DI\n%s data+%d(FP),BX\n%s control+%d(FP),CX\n",
+						name, 3*word, move, move, word, move, 2*word)
+					zero := "VPXOR"
+					if bank == "Z" {
+						zero = "VPXORD"
+					}
+					for register := 0; register < 3; register++ {
+						fmt.Fprintf(&source, "%s %s%d,%s%d,%s%d\n", zero, bank, register, bank, register, bank, register)
+					}
+					mask, suffix, memory := "", "", "(CX)"
+					if immediate {
+						memory = "(BX)"
+					}
+					if mode != "plain" {
+						mask = ",K1"
+						value := -1
+						if mode == "zero" {
+							value, suffix = 0, ".BCST.Z"
+						} else {
+							memory = bank + "0"
+						}
+						fmt.Fprintf(&source, "MOVL $%d,AX\nKMOVD AX,K1\n", value)
+					}
+					source.WriteString("MOVL $5,DX\nCMPL DX,$3\nSTD\n")
+					operands := memory + "," + bank + "1"
+					if immediate {
+						operands = "$0x1b," + memory
+					}
+					fmt.Fprintf(&source, "%s%s %s%s,%s2\nVMOVUPS %s2,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nCLD\nRET\n",
+						op, suffix, operands, mask, bank, bank)
+					count++
+				}
+			}
+		}
+	}
+	return source.String(), declarations.String(), count
+}
+
+func TestX86InLanePermuteInitializedCompleteFamilyNativeReads(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, count := x86InLanePermuteInitializedSource(target.arch)
+			want := 36
+			if target.arch == "386" {
+				want = 12
+			}
+			if count != want {
+				t.Fatal("orthogonal initialized family directory changed", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized in-lane permute family rejected", err)
+					}
+					for index := 0; index < count; index++ {
+						body := x86StringMemoryFunction(t, ir, fmt.Sprintf("Permute%d", index))
+						// Plain and zero/BCST functions have only the permute's
+						// input read; preceding vector producers are register XORs.
+						memory := target.arch == "386" || index%3 != 1
+						if memory && !strings.Contains(body, "load volatile ") {
+							t.Fatal("native E4NF tuple/broadcast read can disappear for dead or zero-mask results", index)
+						}
+					}
+					for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86PackedStringCompileObject(t, llc, target.triple, input, "-O0")
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86InLanePermuteRegisterEffectsPreserveIndependentState(t *testing.T) {
+	var directory strings.Builder
+	directory.WriteString("TEXT effectrows(SB),4,$0-0\n")
+	var rows []string
+	for _, op := range []string{"VPERMILPS", "VPERMILPD"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, first := range []string{"$0x1b", bank + "0"} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					mask, suffix := "", ""
+					if mode != "plain" {
+						mask = ",K1"
+					}
+					if mode == "zero" {
+						suffix = ".Z"
+					}
+					row := fmt.Sprintf("%s%s %s,%s1%s,%s2", op, suffix, first, bank, mask, bank)
+					rows = append(rows, row)
+					fmt.Fprintln(&directory, row)
+				}
+			}
+		}
+	}
+	directory.WriteString("RET\n")
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", directory.String())
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if !known || err != nil || len(effect.operands) == 0 || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+				t.Fatal("complete family lacks a typed input/output effect preserving FLAGS", err)
+			}
+			state := x86FloatingHelperInitializedState()
+			before := state.clone()
+			if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+				t.Fatal("initialized register permute lost numerical bytes or changed independent state")
+			}
+			if len(ins.Args) == 4 {
+				state = before.clone()
+				state.masks[1] = false
+				initial := state.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, initial) {
+					t.Fatal("unknown mask acquired a result or partly changed state")
+				}
+			}
+			for source := 0; source < 2; source++ {
+				if ins.Args[0].Kind == OpImm && source == 0 {
+					continue
+				}
+				hole := 0
+				if ins.Args[0].Kind == OpImm && strings.HasPrefix(row, "VPERMILPD") {
+					// Independent SDM selector: imm8=0x1b has low bits 11,
+					// so both outputs in the first pair read qword one.
+					hole = 8
+				}
+				state = before.clone()
+				state.writeVector(source, 64, state.vectorBytes(source)&^(uint64(1)<<uint(hole)), false)
+				initial := state.clone()
+				accepted := x86ResultTransfer(ins, &state, nil, 0, "amd64")
+				width := amd64VectorByteWidth(ins.Args[len(ins.Args)-1].Reg)
+				known := x86CallerVectorByteMask(int64(width))
+				if accepted && state.vectorBytes(2)&known == known || !accepted && !reflect.DeepEqual(state, initial) {
+					t.Fatal("missing selected data/control byte became NUM or failed transfer partly mutated state", source, hole)
+				}
+			}
+		})
+	}
+}
+
+func TestX86InLanePermuteVoidReadsNeedActualInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", 8
+		if target.arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, op := range []string{"VPERMILPS", "VPERMILPD"} {
+			for _, variable := range []bool{false, true} {
+				for _, missing := range []string{"none", "pointer", "index", "data"} {
+					if !variable && missing == "data" {
+						continue
+					}
+					t.Run(fmt.Sprintf("%s/%s/variable=%t/%s", target.triple, op, variable, missing), func(t *testing.T) {
+						prefix := move + " p+0(FP),BX\n"
+						if missing == "pointer" {
+							prefix = ""
+						}
+						address := "(BX)"
+						if missing == "index" {
+							address = "(BX)(DX*2)"
+						}
+						operands := "$0x1b," + address
+						if variable {
+							operands = address + ",X1"
+							if missing != "data" {
+								prefix += "VPXOR X1,X1,X1\n"
+							}
+						}
+						source := fmt.Sprintf("TEXT Value(SB),4,$0-%d\n%s%s %s,X2\nRET\n", word, prefix, op, operands)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", target.arch, target.triple, api)
+								if missing == "none" {
+									if err != nil || !strings.Contains(ir, "load volatile ") {
+										t.Fatal("dead native permute lost its exact observable input read", err)
+									}
+								} else if target.arch == "amd64" && missing == "data" {
+									x86VectorScratchCodegenControl(t, source, "func Value(p *[64]byte)", target.arch, target.triple, ir, err)
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("Void invented a missing pointer/index/numerical input", err)
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_inlane_permute_raw_replay_test.go b/x86_inlane_permute_raw_replay_test.go
new file mode 100644
index 000000000..1adfecb07
--- /dev/null
+++ b/x86_inlane_permute_raw_replay_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Raw VPERMIL is not a newly authorized source role. Its existing physical
+// decoder and private format objects stay separate from initialized named
+// programs. Erasing only a private origin cannot turn the sealed former into
+// the latter; a standalone instruction cannot observe this whole-Func fact.
+func TestX86InLanePermuteOriginOnlyWholeSourceReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPERMILPS", "VPERMILPD"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, immediate := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/immediate=%t", arch, op, bank, immediate), func(t *testing.T) {
+						operation := fmt.Sprintf("%s %s0,%s1,%s2", op, bank, bank, bank)
+						if immediate {
+							operation = fmt.Sprintf("%s $0x1b,%s1,%s2", op, bank, bank)
+						}
+						code, pcs := x86NumericalBoundaryGoBytes(t, arch, operation+"\nRET")
+						if len(pcs) != 2 || pcs[1] != int64(len(code)-1) || code[len(code)-1] != 0xc3 ||
+							(bank == "Z") != (code[0] == 0x62) {
+							t.Fatal("independent Go bytes/PCs lost the complete low-bank VEX X/Y or EVEX Z instruction", pcs, code)
+						}
+						zero := "VPXOR"
+						if bank == "Z" {
+							zero = "VPXORD"
+						}
+						prefix := "TEXT ·Value(SB),4,$0-4\n"
+						for register := 0; register < 3; register++ {
+							prefix += fmt.Sprintf("%s %s%d,%s%d,%s%d\n", zero, bank, register, bank, register, bank, register)
+						}
+						suffix := "MOVL X2,ret+0(FP)\nRET\n"
+						namedSource := prefix + operation + "\n" + suffix
+						rawSource := prefix + x86RawDisplacementDirectives(code[:pcs[1]]) + suffix
+						x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0],
+							strings.Replace(namedSource, "·Value", "·ReplayNamed", 1)+rawSource)
+						strict, check := x86RegisterReplayConsumers(t, arch, namedSource)
+						named := mustParseX86RawReturn(t, namedSource).Funcs[0]
+						if named.x86RawReplay != nil || strict(named) != nil || check(named) != nil {
+							t.Fatal("independent initialized named control must pass its actual strict and lowering consumers")
+						}
+						file, err := normalizeX86RawFile(mustParseX86RawReturn(t, rawSource), arch)
+						if err != nil {
+							t.Fatal("actual complete raw VPERMIL normalization prerequisite", err)
+						}
+						original, ordinal := file.Funcs[0], -1
+						for index, ins := range original.Instrs {
+							if ins.Op == Op(op) && ins.x86SourceRaw != nil {
+								if ordinal >= 0 || ins.x86Encoded {
+									t.Fatal("raw VPERMIL origin-only prerequisite lost its unique nonencoded instruction")
+								}
+								ordinal = index
+							}
+						}
+						if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+							t.Fatal("complete physical source lost its independently sealed replay")
+						}
+						if !errors.Is(strict(original), ErrProbeNeedsContext) || !errors.Is(check(original), ErrProbeNeedsContext) {
+							t.Fatal("untouched raw source unexpectedly borrowed the named initialized-source role")
+						}
+						changed := original
+						changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+						changed.Instrs[ordinal].x86SourceRaw = nil // The sole mutation; do not also change generation.
+						if !x86ResultNamedPredicateInstruction(changed.Instrs[ordinal]) || strict(changed) != nil {
+							t.Fatal("origin-only mutation did not reach the actual strict-numerical-success shortcut")
+						}
+						if changed.x86RawReplay != original.x86RawReplay ||
+							!errors.Is(changed.x86RawReplay.validate(changed, arch), ErrProbeNeedsContext) ||
+							original.x86RawReplay.validate(original, arch) != nil {
+							t.Fatal("origin-only clone changed the original source or failed to retain its restriction")
+						}
+						if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("real whole-source consumer accepted an erased raw VPERMIL origin", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_integer_minmax_contract_test.go b/x86_integer_minmax_contract_test.go
new file mode 100644
index 000000000..6c70622ae
--- /dev/null
+++ b/x86_integer_minmax_contract_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86IntegerMinMaxIndependentRows(arch string) []string {
+	var rows []string
+	for _, op := range []string{
+		"VPMINSB", "VPMINUB", "VPMAXSB", "VPMAXUB",
+		"VPMINSW", "VPMINUW", "VPMAXSW", "VPMAXUW",
+		"VPMINSD", "VPMINUD", "VPMAXSD", "VPMAXUD",
+		"VPMINSQ", "VPMINUQ", "VPMAXSQ", "VPMAXUQ",
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, first := range []string{bank + "0", "(SI)"} {
+				rows = append(rows, op+" "+first+","+bank+"1,"+bank+"2")
+				if arch == "amd64" {
+					rows = append(rows, op+" "+first+","+bank+"1,K1,"+bank+"2",
+						op+".Z "+first+","+bank+"1,K1,"+bank+"2")
+				}
+			}
+			if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+				rows = append(rows, op+".BCST (SI),"+bank+"1,"+bank+"2")
+				if arch == "amd64" {
+					rows = append(rows, op+".BCST (SI),"+bank+"1,K1,"+bank+"2",
+						op+".BCST.Z (SI),"+bank+"1,K1,"+bank+"2")
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86IntegerMinMaxCompleteTypedNamedRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86IntegerMinMaxIndependentRows(arch)
+		want := 120
+		if arch == "amd64" {
+			want = 360
+		}
+		if len(rows) != want {
+			t.Fatal("independent min/max row denominator changed", arch, len(rows))
+		}
+		requireX86GoAssemblerResult(t, arch,
+			"TEXT forms(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", true)
+		for _, row := range rows {
+			ins := x86ScalarLaneInstruction(t, row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if !known || err != nil || !effect.requiresResultProof ||
+				effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+				t.Fatal("complete min/max grammar lacks its typed numerical obligation", row, known, err)
+			}
+		}
+	}
+}
+
+func TestX86IntegerMinMaxPhysicalMode32DoesNotGrantNamedArity(t *testing.T) {
+	rows := x86IntegerMinMaxIndependentRows("amd64")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", strings.Join(rows, "\n")+"\nRET")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("incomplete physical instruction boundaries")
+	}
+	// This observer owns decoded instruction identity, not a raw-return PC
+	// contract. Keep the terminator named while preserving every min/max byte.
+	file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+
+		x86RawDisplacementDirectives(code[:pcs[len(rows)]])+"RET\n")
+	file, err := normalizeX86RawFile(file, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, ins := range file.Funcs[0].Instrs {
+		_, known, err := x86IntegerMinMaxProperties(ins.Op, ins, "386")
+		if !known {
+			continue
+		}
+		if err != nil || !x86RawIntegerMinMaxSource(ins, "386") {
+			t.Fatal("physical mode32 min/max lost its decoded mask form", ins.Raw, err)
+		}
+		count++
+		for _, mutation := range []string{"origin", "encoded", "operand", "address", "segment"} {
+			changed := ins
+			switch mutation {
+			case "origin":
+				changed.x86SourceRaw = nil
+			case "encoded":
+				changed.x86Encoded = false
+			case "operand":
+				changed.Args = append([]Operand(nil), ins.Args...)
+				changed.Args[1] = Operand{Kind: OpReg, Reg: "Z7"}
+			case "address":
+				changed.x86AddressBits = 16
+			case "segment":
+				changed.x86SegmentPrefix = 0x64
+			}
+			if x86RawIntegerMinMaxSource(changed, "386") {
+				t.Fatal("edited physical source borrowed its old shape", ins.Raw, mutation)
+			}
+		}
+		if len(ins.Args) == 4 {
+			named := x86ScalarLaneInstruction(t, string(ins.Op)+" "+
+				strings.Join([]string{ins.Args[0].String(), ins.Args[1].String(),
+					ins.Args[2].String(), ins.Args[3].String()}, ","))
+			if _, _, err := x86IntegerMinMaxProperties(named.Op, named, "386"); err == nil {
+				t.Fatal("physical decoder expanded the named mode32 frontend", named.Raw)
+			}
+		}
+	}
+	if count != len(rows) {
+		t.Fatal("incomplete physical min/max family", count, len(rows))
+	}
+}
+
+func TestX86IntegerMinMaxSelectedBytesAndState(t *testing.T) {
+	for _, row := range x86IntegerMinMaxIndependentRows("amd64") {
+		ins := x86ScalarLaneInstruction(t, row)
+		if ins.Args[0].Kind != OpReg {
+			continue // Native reads retain a separate paired continuation.
+		}
+		width := amd64VectorByteWidth(ins.Args[0].Reg)
+		bits := map[byte]int{'B': 8, 'W': 16, 'D': 32, 'Q': 64}[string(ins.Op)[6]]
+		lane := bits / 8
+		for missingRegister := 0; missingRegister < 3; missingRegister++ {
+			for missingByte := 0; missingByte < 64; missingByte++ {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for register := 0; register < 3; register++ {
+					state.writeVector(register, 64, ^uint64(0), false)
+				}
+				state.writeVector(missingRegister, 64, ^uint64(0)&^(uint64(1)<<uint(missingByte)), false)
+				state.masks[1] = true
+				before := state.clone()
+				if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("unknown data bytes cannot invent instruction effects", row)
+				}
+				want := ^uint64(0)
+				merge := len(ins.Args) == 4 && !strings.HasSuffix(string(ins.Op), ".Z")
+				if missingByte < width && (missingRegister < 2 || merge) {
+					if missingRegister == 2 {
+						want &^= uint64(1) << uint(missingByte)
+					} else {
+						want &^= x86CallerVectorByteMask(int64(lane)) << uint(missingByte/lane*lane)
+					}
+				}
+				if state.vectorBytes(2) != want || state.flags != before.flags ||
+					state.gp != before.gp || state.masks != before.masks {
+					t.Fatal("min/max supplied missing lane bytes or altered unrelated state", row, missingRegister, missingByte)
+				}
+				state.writeVector(2, 64, before.vectorBytes(2), false)
+				if !reflect.DeepEqual(state, before) {
+					t.Fatal("min/max altered unrelated source identities", row)
+				}
+			}
+		}
+	}
+}
+
+func TestX86IntegerMinMaxInitializedPublicFamily(t *testing.T) {
+	var source, declarations strings.Builder
+	for index, op := range x86MinMaxTestOps {
+		name := fmt.Sprint("MinMax", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVQ p+0(FP),SI\n"+
+			"VPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nMOVL $85,CX\nKMOVD CX,K1\n"+
+			"%s (SI),Z1,K1,Z2\nVPEXTRD $0,X2,CX\nMOVL CX,ret+8(FP)\nRET\n", name, op)
+		fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+		if err != nil || ir == "" {
+			t.Fatal("initialized complete min/max family rejected", api, err)
+		}
+	}
+}
diff --git a/x86_integer_minmax_fault_runtime_unix_test.go b/x86_integer_minmax_fault_runtime_unix_test.go
new file mode 100644
index 000000000..721358d44
--- /dev/null
+++ b/x86_integer_minmax_fault_runtime_unix_test.go
@@ -0,0 +1,65 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86IntegerMinMaxDeadE4ReadFaults(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable guard pages require the native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("integer min/max faults require LLVM22 llc and clang")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for batch := 0; batch < 2; batch++ {
+		t.Run(fmt.Sprint("batch-", batch), func(t *testing.T) {
+			var source, declarations, prototypes, metadata strings.Builder
+			count, owned := 0, 0
+			for _, op := range x86MinMaxTestOps {
+				lane := map[byte]int{'B': 1, 'W': 2, 'D': 4, 'Q': 8}[op[6]]
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, broadcast := range []bool{false, true} {
+						if broadcast && lane < 4 {
+							continue
+						}
+						index := count
+						count++
+						if index/36 != batch {
+							continue
+						}
+						owned++
+						name := fmt.Sprint("MinMaxFault", index)
+						width := amd64VectorByteWidth(Reg(bank + "0"))
+						extent, suffix := width, ".Z"
+						if broadcast {
+							extent, suffix = lane, ".BCST.Z"
+						}
+						fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\n"+
+							"KMOVQ mask+8(FP),K1\nVPXORD Z1,Z1,Z1\n%s%s (AX),%s1,K1,%s2\nRET\n",
+							name, op, suffix, bank, bank)
+						fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *,uint64_t);\n", name)
+						fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, extent, lane, width/lane)
+					}
+				}
+			}
+			if count != 72 || owned != 36 {
+				t.Fatal("incomplete or overlapping independent E4 family union", count, owned)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+			if err != nil {
+				t.Fatal("complete original dead E4 source rejected", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, fmt.Sprint("integer_minmax_faults_", batch),
+				triple, ir, x86E4DeadReadFaultOracle(prototypes.String(), metadata.String()))
+		})
+	}
+}
diff --git a/x86_integer_minmax_literal_inputs_test.go b/x86_integer_minmax_literal_inputs_test.go
new file mode 100644
index 000000000..c1919bef8
--- /dev/null
+++ b/x86_integer_minmax_literal_inputs_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86IntegerMinMaxInitializedLiteralPrograms(t *testing.T) []string {
+	t.Helper()
+	var programs []string
+	for _, op := range x86MinMaxTestOps {
+		qword := strings.HasSuffix(op, "Q")
+		for _, evex := range []bool{false, true} {
+			if !evex && qword {
+				continue
+			}
+			for _, width := range []int{16, 32, 64} {
+				if !evex && width == 64 {
+					continue
+				}
+				for _, broadcast := range []bool{false, true} {
+					if broadcast && (!evex || !qword && !strings.HasSuffix(op, "D")) {
+						continue
+					}
+					for mode := 0; mode < 3; mode++ {
+						if !evex && mode != 0 {
+							continue
+						}
+						mask := 0
+						if mode != 0 {
+							mask = 7
+						}
+						code := x86RawMinMaxLiteral(op, evex, width, mask, mode == 2, broadcast)
+						programs = append(programs, fmt.Sprintf("TEXT ·Literal%d(SB),4,$0-0\n"+
+							"VPXORD Z0,Z0,Z0\nMOVL $85,CX\nKMOVD CX,K7\n%s",
+							len(programs), x86RawDisplacementDirectives(code)))
+					}
+				}
+			}
+		}
+	}
+	if len(programs) != 240 {
+		t.Fatal("incomplete VEX/EVEX width, mask and broadcast literal family", len(programs))
+	}
+	return programs
+}
+
+func TestX86IntegerMinMaxInitializedLiteralInputsAndReturn(t *testing.T) {
+	programs := x86IntegerMinMaxInitializedLiteralPrograms(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("initialized min/max literal objects require LLVM22")
+	}
+	for start := 0; start < len(programs); start += 48 {
+		source := strings.Join(programs[start:start+48], "\n")
+		var declarations strings.Builder
+		for index := start; index < start+48; index++ {
+			fmt.Fprintf(&declarations, "func Literal%d()\n", index)
+		}
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("batch-%03d/%s/%s", start, triple, api), func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized RIP constant and canonical raw RET regressed", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86IntegerMinMaxLiteralExactTupleAndMaskRemainRequired(t *testing.T) {
+	for _, source := range x86IntegerMinMaxInitializedLiteralPrograms(t) {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[4]
+		form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, "amd64")
+		address, static := x86StaticSBReadAddress(ins.Args[0], "amd64")
+		if err != nil || !known || !static || len(file.Data) != 1 || len(file.Data[0].Payload) != form.memoryBytes {
+			t.Fatal("original literal lost its whole exact tuple", ins.Raw, err)
+		}
+		for _, mutation := range []string{"none", "tuple", "origin", "encoded", "address", "mask", "short data"} {
+			if mutation == "mask" && form.mask < 0 {
+				continue
+			}
+			changed := ins
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+			state.writeVector(0, 64, ^uint64(0), false)
+			state.masks[7] = mutation != "mask"
+			state.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(form.memoryBytes)}
+			switch mutation {
+			case "tuple":
+				changed.x86RIPMemoryRead.width--
+			case "origin":
+				changed.x86SourceRaw = nil
+			case "encoded":
+				changed.x86Encoded = false
+			case "address":
+				changed.x86AddressBits = 32
+			case "short data":
+				state.loweredStaticReads[address]--
+			}
+			before := state.clone()
+			accepted, recognized := x86ResultIntegerMinMaxStep(changed, &state, nil, "amd64", false)
+			state.loweredStaticReads = nil
+			if !recognized || accepted != (mutation == "none") || !accepted && !reflect.DeepEqual(state, before) {
+				t.Fatal("literal supplied a missing mask, stale identity or incomplete tuple", mutation, ins.Raw)
+			}
+		}
+		missing := strings.Replace(source, "KMOVD CX,K7\n", "", 1)
+		if form.mask >= 0 {
+			if ir, err := x86ScalarFPBitViewAPI(t, missing,
+				"func "+strings.TrimPrefix(file.Funcs[0].Sym, "·")+"()",
+				"amd64", "x86_64-unknown-linux-gnu", "text"); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("canonical raw return supplied an uninitialized mask", err)
+			}
+		}
+	}
+}
diff --git a/x86_integer_minmax_objects_test.go b/x86_integer_minmax_objects_test.go
new file mode 100644
index 000000000..fcff6bc63
--- /dev/null
+++ b/x86_integer_minmax_objects_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86IntegerMinMaxCompleteObjectTarget(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("integer min/max objects require LLVM22")
+	}
+	// All physical mode32 mask forms have low banks and the same original
+	// bytes. Observe them with amd64's four-operand frontend, then independently
+	// assemble the complete mode32 BYTE program, not a fictitious named row.
+	physicalRows := x86IntegerMinMaxIndependentRows("amd64")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", strings.Join(physicalRows, "\n")+"\nRET")
+	if len(pcs) != len(physicalRows)+1 || code[len(code)-1] != 0xc3 {
+		t.Fatal("incomplete independent original instruction byte boundaries")
+	}
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	for _, raw := range []bool{false, true} {
+		rows := x86IntegerMinMaxIndependentRows(arch)
+		if raw {
+			rows = physicalRows
+		}
+		for start := 0; start < len(rows); start += 48 {
+			end := start + 48
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("raw-%t/batch-%04d", raw, start), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index := start; index < end; index++ {
+					name := fmt.Sprint("MinMax", index)
+					fmt.Fprintf(&declarations, "func %s(p *[64]byte) uint32\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\n"+
+						"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nMOVL $85,CX\nKMOVD CX,K1\n",
+						name, word+4, move)
+					if raw {
+						for _, value := range code[pcs[index]:pcs[index+1]] {
+							fmt.Fprintf(&source, "BYTE $%d\n", value)
+						}
+					} else {
+						source.WriteString(rows[index] + "\n")
+					}
+					fmt.Fprintf(&source, "VPEXTRD $0,X2,CX\nMOVL CX,ret+%d(FP)\nRET\n", word)
+				}
+				x86LEAActualTargetGoObject(t, arch, triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete initialized named/raw family rejected", err)
+						}
+						optimized := x86DwordProductIROptimize(t, ir)
+						for _, pipeline := range []struct{ ir, level string }{
+							{ir, "-O0"}, {ir, "-O2"}, {optimized, "-O2"},
+						} {
+							x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86IntegerMinMaxObjectsLinux386(t *testing.T) {
+	x86IntegerMinMaxCompleteObjectTarget(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86IntegerMinMaxObjectsWindows386(t *testing.T) {
+	x86IntegerMinMaxCompleteObjectTarget(t, "386", "i686-pc-windows-msvc")
+}
+
+func TestX86IntegerMinMaxObjectsLinuxAMD64(t *testing.T) {
+	x86IntegerMinMaxCompleteObjectTarget(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86IntegerMinMaxObjectsDarwinAMD64(t *testing.T) {
+	x86IntegerMinMaxCompleteObjectTarget(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86IntegerMinMaxObjectsWindowsAMD64(t *testing.T) {
+	x86IntegerMinMaxCompleteObjectTarget(t, "amd64", "x86_64-pc-windows-msvc")
+}
diff --git a/x86_integer_minmax_translation_bench_test.go b/x86_integer_minmax_translation_bench_test.go
new file mode 100644
index 000000000..cacd13d68
--- /dev/null
+++ b/x86_integer_minmax_translation_bench_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Measure the public Translate call, including its actual module/context
+// lifetime and IR printing. Parsing, Go signature derivation and independent
+// LLVM verification/object compilation belong to the untimed preflight.
+func BenchmarkX86IntegerMinMaxTranslation(b *testing.B) {
+	const triple = "x86_64-unknown-linux-gnu"
+	for _, row := range []struct {
+		name    string
+		witness goasmrules.X86PackedBinaryWitness
+	}{
+		{
+			name: "legacy-XMM",
+			witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: "PMINUB X0,X1", Generation: "legacy",
+				First: "X0", Second: "X1", Destination: "X1", Width: 16,
+			},
+		},
+		{
+			name: "VEX-Y",
+			witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: "VPMINUD Y0,Y1,Y2", Generation: "vex",
+				First: "Y0", Second: "Y1", Destination: "Y2", Width: 32,
+			},
+		},
+		{
+			name: "EVEX-Z-masked",
+			witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: "VPMAXSQ Z0,Z1,K1,Z2", Generation: "evex",
+				First: "Z0", Second: "Z1", Destination: "Z2", Width: 64, Masked: true,
+			},
+		},
+	} {
+		b.Run(row.name, func(b *testing.B) {
+			// Reuse the official min/max row owner's complete initialized
+			// source builder. Retain every input, output and the whole TEXT;
+			// repeat only its operation to make a 32-operation kernel.
+			source, declaration := x86OfficialPackedAssembly([]x86OfficialPackedCase{{witness: row.witness}})
+			instruction := row.witness.Instruction + "\n"
+			if strings.Count(source, instruction) != 1 {
+				b.Fatal("complete row builder lost its one operation")
+			}
+			source = strings.Replace(source, instruction, strings.Repeat(instruction, 32), 1)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil || len(file.Funcs) != 1 || strings.Count(source, instruction) != 32 {
+				b.Fatal("benchmark must retain one complete 32-operation source", err)
+			}
+			fset := token.NewFileSet()
+			syntax, err := parser.ParseFile(fset, "minmax.go", "package minmaxbench\n"+declaration, parser.ParseComments)
+			if err != nil {
+				b.Fatal(err)
+			}
+			config := types.Config{}
+			typed, err := config.Check("minmaxbench", fset, []*ast.File{syntax}, nil)
+			if err != nil {
+				b.Fatal(err)
+			}
+			pkg := GoPackage{Path: "minmaxbench", Types: typed, Syntax: []*ast.File{syntax}}
+			resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+			signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+			if err != nil {
+				b.Fatal(err)
+			}
+			options := Options{Goarch: "amd64", TargetTriple: triple, ResolveSym: resolve, Sigs: signatures}
+			ir, err := Translate(file, options)
+			if err != nil || ir == "" {
+				b.Fatal("complete public translation must succeed before timing", err)
+			}
+			x86IntegerMinMaxBenchmarkPreflight(b, ir, triple)
+			b.Logf("complete sourceSHA256=%x declarationSHA256=%x bytes=%d operations=32 target=%s",
+				sha256.Sum256([]byte(source)), sha256.Sum256([]byte(declaration)), len(source), triple)
+			b.ReportAllocs()
+			b.ResetTimer()
+			for iteration := 0; iteration < b.N; iteration++ {
+				if translated, err := Translate(file, options); err != nil || translated == "" {
+					b.Fatal("timed public translation failed", err)
+				}
+			}
+		})
+	}
+}
+
+func x86IntegerMinMaxBenchmarkPreflight(b *testing.B, ir, triple string) {
+	b.Helper()
+	func() {
+		ctx := llvm.NewContext()
+		defer ctx.Dispose()
+		module, err := parseIRModuleInContext(ctx, ir)
+		if err != nil {
+			b.Fatal("independent preflight ParseIR failed", err)
+		}
+		defer module.Dispose()
+		if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+			b.Fatal("independent preflight VerifyModule failed", err)
+		}
+	}()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		b.Fatal("LLVM22 llc is required for the untimed object preflight")
+	}
+	object := filepath.Join(b.TempDir(), "minmax.o")
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, llc, "-O0", "-filetype=obj", "-mtriple="+triple, "-o", object)
+	command.Stdin = strings.NewReader(ir)
+	if output, err := command.CombinedOutput(); err != nil {
+		b.Fatalf("untimed LLVM22 object preflight failed: %v\n%s", err, output)
+	}
+	if info, err := os.Stat(object); err != nil || info.Size() == 0 {
+		b.Fatal("LLVM22 object preflight produced no object", err)
+	}
+}
diff --git a/x86_integer_self_compare_runtime_test.go b/x86_integer_self_compare_runtime_test.go
new file mode 100644
index 000000000..9706bacce
--- /dev/null
+++ b/x86_integer_self_compare_runtime_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86IntegerSelfComparePortableValuesFlagsAndCanaries(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	rows := x86IntegerSelfCompareCases("amd64")
+	for start := 0; start < len(rows); start += 64 {
+		end := start + 64
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%d", start/64), func(t *testing.T) {
+			var source, declarations, prototypes, kernels strings.Builder
+			for index, row := range rows[start:end] {
+				name := fmt.Sprintf("SelfCompare%d", start+index)
+				ins := x86ScalarLaneInstruction(t, row.row)
+				destination := string(ins.Args[len(ins.Args)-1].Reg)
+				fmt.Fprintf(&declarations, "func %s(out *byte, mask uint64)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,uint64_t);\n", name)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\nMOVQ out+0(FP),DI\nMOVQ mask+8(FP),AX\nKMOVQ AX,K1\n", name)
+				source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n" + row.row + "\n")
+				bits := row.width
+				selected := strings.Contains(string(ins.Op), "EQ")
+				if row.maskResult {
+					lane := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'D': 32, 'Q': 64}[ins.Op[len(ins.Op)-1]]
+					bits = row.width * 8 / lane
+					if ins.Args[0].Kind == OpImm {
+						// Intel's eight integer predicates on x,x: EQ, LT,
+						// LE, false, NE, NLT, NLE, true. High five bits are ignored.
+						selected = [8]bool{true, false, true, false, false, true, false, true}[ins.Args[0].Imm&7]
+					}
+					fmt.Fprintf(&source, "KMOVQ %s,AX\nMOVQ AX,0(DI)\n", destination)
+				} else if row.legacy {
+					// Legacy MOVOU retains a native x86 memory opcode. Extract
+					// both halves instead, so the observer is also portable.
+					for lane := 0; lane < 2; lane++ {
+						fmt.Fprintf(&source, "PEXTRQ $%d,%s,AX\nMOVQ AX,%d(DI)\n", lane, destination, lane*8)
+					}
+				} else {
+					fmt.Fprintf(&source, "VMOVUPS %s,0(DI)\n", destination)
+				}
+				source.WriteString("SETCS 64(DI)\nSETOS 65(DI)\nSETEQ 66(DI)\nSETMI 67(DI)\nRET\n")
+				fmt.Fprintf(&kernels, "{%s,%d,%t,%t,%t},\n", name, bits, selected, row.masked, row.maskResult)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			driver := strings.ReplaceAll(x86IntegerSelfCompareValueDriver, "PROTOTYPES", prototypes.String())
+			driver = strings.ReplaceAll(driver, "KERNELS", kernels.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+				if err != nil {
+					t.Fatal("complete self-initializing programs", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						execution.compileAndRunLLVM(t, "integer-self-compare", text, driver, level)
+					}
+				}
+			}
+		})
+	}
+	t.Log("all24 names, legacy/VEX/EVEX views, masks/aliases, eight predicates and high control bits; actual-host portable, not native AVX512")
+}
+
+const x86IntegerSelfCompareValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+PROTOTYPES
+struct kernel {
+    void (*run)(uint8_t*,uint64_t);
+    unsigned bits;
+    _Bool selected, masked, maskResult;
+};
+static const struct kernel kernels[] = { KERNELS };
+int main(void) {
+    const uint64_t masks[] = {0,1,UINT64_C(0x55aa55aa55aa55aa),UINT64_MAX};
+    const uint8_t flags[] = {1,1,0,1};
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        const struct kernel *kernel=&kernels[k];
+        for (unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);++m) {
+            uint8_t output[96];
+            memset(output,0xa7,sizeof(output));
+            kernel->run(output+1,masks[m]);
+            unsigned size=kernel->maskResult ? 8 : kernel->bits;
+            if (kernel->maskResult) {
+                uint64_t got, want=0;
+                memcpy(&got,output+1,8);
+                if (kernel->selected) {
+                    want=kernel->bits==64 ? UINT64_MAX : (UINT64_C(1)<<kernel->bits)-1;
+                }
+                if (kernel->masked) want&=masks[m];
+                if (got!=want) {
+                    fprintf(stderr,"self-compare kernel=%u mask=%u got=%llx want=%llx\n",
+                        k,m,(unsigned long long)got,(unsigned long long)want);
+                    return 1;
+                }
+            } else {
+                for (unsigned b=0;b<size;++b) {
+                    uint8_t want=kernel->selected ? 0xff : 0;
+                    if (output[1+b]!=want) {
+                        fprintf(stderr,"self-compare kernel=%u mask=%u byte=%u got=%x want=%x\n",
+                            k,m,b,output[1+b],want);
+                        return 1;
+                    }
+                }
+            }
+            if (memcmp(output+65,flags,4) || output[0]!=0xa7) {
+                fprintf(stderr,"self-compare kernel=%u mask=%u status/canary\n",k,m);
+                return 1;
+            }
+            for (unsigned i=1;i<sizeof(output);++i) {
+                if (i<=size || (i>=65 && i<69)) continue;
+                if (output[i]!=0xa7) {
+                    fprintf(stderr,"self-compare kernel=%u mask=%u canary=%u\n",k,m,i);
+                    return 2;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_integer_self_compare_test.go b/x86_integer_self_compare_test.go
new file mode 100644
index 000000000..3107181d3
--- /dev/null
+++ b/x86_integer_self_compare_test.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86IntegerSelfCompareCase struct {
+	row                string
+	width              int
+	legacy, maskResult bool
+	masked, maskAlias  bool
+}
+
+// Enumerate the two complete Go comparison families independently of their
+// implementation maps. The original row/attribute tests own the full tables.
+func x86IntegerSelfCompareCases(arch string) []x86IntegerSelfCompareCase {
+	var rows []x86IntegerSelfCompareCase
+	for _, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ", "PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ"} {
+		rows = append(rows, x86IntegerSelfCompareCase{row: op + " X6,X6", width: 16, legacy: true})
+		vector := "V" + strings.ReplaceAll(op, "L", "D")
+		for _, bank := range []string{"X", "Y"} {
+			width := 16
+			if bank == "Y" {
+				width = 32
+			}
+			for _, destination := range []string{bank + "2", bank + "6"} {
+				rows = append(rows, x86IntegerSelfCompareCase{
+					row: fmt.Sprintf("%s %s6,%s6,%s", vector, bank, bank, destination), width: width,
+				})
+			}
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+			rows = append(rows, x86IntegerSelfCompareCase{
+				row: fmt.Sprintf("%s %s6,%s6,K0", vector, bank, bank), width: width, maskResult: true,
+			})
+			if arch == "amd64" {
+				for _, maskAlias := range []bool{false, true} {
+					destination := "K0"
+					if maskAlias {
+						destination = "K1"
+					}
+					rows = append(rows, x86IntegerSelfCompareCase{
+						row:   fmt.Sprintf("%s %s6,%s6,K1,%s", vector, bank, bank, destination),
+						width: width, maskResult: true, masked: true, maskAlias: maskAlias,
+					})
+				}
+			}
+		}
+	}
+	if arch == "amd64" {
+		for _, op := range x86ImmediateCompareResultMembers {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, immediate := range []int{0, 1, 2, 3, 4, 5, 6, 7, 128, 255} {
+					for _, masked := range []bool{false, true} {
+						mask := ""
+						if masked {
+							mask = "K1,"
+						}
+						rows = append(rows, x86IntegerSelfCompareCase{
+							row:   fmt.Sprintf("%s $%d,%s6,%s6,%sK0", op, immediate, bank, bank, mask),
+							width: map[string]int{"X": 16, "Y": 32, "Z": 64}[bank], maskResult: true, masked: masked,
+						})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86IntegerSelfCompareIndependentImmediateAndBankAxes(t *testing.T) {
+	for _, op := range x86ImmediateCompareResultMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			t.Run(op+"/"+bank, func(t *testing.T) {
+				var source strings.Builder
+				source.WriteString("TEXT f(SB),4,$0-0\n")
+				check := func(immediate, register int) {
+					row := fmt.Sprintf("%s $%d,%s%d,%s%d,K0", op, immediate, bank, register, bank, register)
+					ins := x86ScalarLaneInstruction(t, row)
+					state := x86ResultState{}
+					if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !state.masks[0] {
+						t.Fatal("independent imm8/register axis lost its same-view result", row)
+					}
+					source.WriteString(row + "\n")
+				}
+				for immediate := 0; immediate < 256; immediate++ {
+					check(immediate, 6)
+				}
+				for register := 0; register < 32; register++ {
+					check(0, register)
+				}
+				source.WriteString("RET\n")
+				code := x86PackedShiftActualGoBytes(t, "amd64", source.String())
+				if len(code) != (256+32)*7+1 || code[len(code)-1] != 0xc3 {
+					t.Fatal("original complete EVEX register/imm8 byte layout changed", len(code))
+				}
+				for immediate := 0; immediate < 256; immediate++ {
+					if code[7*immediate] != 0x62 || code[7*immediate+6] != byte(immediate) {
+						t.Fatal("original Go encoded a different imm8", immediate)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86IntegerSelfCompareCompleteNumericalEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86IntegerSelfCompareCases(arch)
+		var original strings.Builder
+		original.WriteString("TEXT f(SB),4,$0-0\n")
+		for _, row := range rows {
+			original.WriteString(row.row + "\n")
+		}
+		original.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.row)
+				effect, known, err := x86TypedPackedIntegerCompareByteEffect(ins.Op, ins, arch)
+				if !known || err != nil {
+					t.Fatal("complete comparison descriptor", effect, err)
+				}
+				for _, operand := range effect.operands {
+					if operand.read && operand.operand.Kind == OpReg && !amd64IsKOperand(operand.operand) {
+						t.Fatal("typed descriptor retains a value dependency on identical integer inputs")
+					}
+				}
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					for _, seeded := range []bool{false, true} {
+						state := x86ResultState{direction: x86ResultDirectionBackward}
+						state.masks[1] = row.masked
+						if seeded {
+							state.vectorUpper[6], state.vectorUpper[2] = 1<<63, 1<<60
+							state.flags, state.pointerGP[7] = x86ByteFlagsAll, true
+						}
+						want := state.clone()
+						if row.maskResult {
+							index := 0
+							if row.maskAlias {
+								index = 1
+							}
+							want.masks[index] = true
+						} else {
+							index := 2
+							if row.legacy || strings.HasSuffix(row.row, "6") {
+								index = 6
+							}
+							want.writeVector(index, row.width, x86CallerVectorByteMask(int64(row.width)), row.legacy)
+						}
+						if !consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+							t.Fatal("same physical integer inputs retained a false numerical dependency or changed unrelated state", consumer.name, seeded)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86IntegerSelfCompareOriginalIdiomThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		register := "X14"
+		if target.arch == "386" {
+			register = "X6"
+		}
+		source := "TEXT Value(SB),4,$0-4\nPCMPEQL " + register + "," + register +
+			"\nPEXTRD $0," + register + ",AX\nMOVL AX,ret+0(FP)\nRET\n"
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("original self-comparison initialization idiom needs no incoming vector value", api, err)
+				}
+				x86ScalarFPNamedConstantResult(t, ir, "Value", []uint64{0xffffffff})
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86IntegerSelfCompareRetainsInputAndSourceBoundaries(t *testing.T) {
+	for _, row := range []string{
+		"PCMPEQL X5,X6", "PCMPGTL X5,X6", "VPCMPEQD X5,X6,X2", "VPCMPGTQ Y5,Y6,Y2",
+		"VPCMPEQB Z5,Z6,K0", "VPCMPD $3,Z5,Z6,K0", "VPCMPUQ $7,Z5,Z6,K0",
+		"PCMPEQL (AX),X6", "VPCMPEQD (AX),Z6,K0", "VPCMPQ $0,(AX),Z6,K0",
+		"VPCMPEQD X6,X6,K1,K0", "VPCMPB $0,Z6,Z6,K1,K0",
+		"CMPPS X6,X6,$0", "VCMPPS $0,Y6,Y6,Y2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{flags: x86ByteFlagsAll, pointerGP: [16]bool{0: true}}
+				before := state.clone()
+				if consumer.step(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+					t.Fatal("self-comparison supplied another input, mask, memory or floating-point role", consumer.name)
+				}
+			}
+		})
+	}
+	for _, mutation := range []string{"encoded", "raw origin", "address size", "unbound address", "segment", "raw return"} {
+		t.Run(mutation, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, "PCMPEQL X6,X6")
+			switch mutation {
+			case "encoded":
+				ins.x86Encoded = true
+			case "raw origin":
+				ins.x86SourceRaw = &x86SourceRawInstruction{op: "PCMPEQL"}
+			case "address size":
+				ins.x86AddressBits = 32
+			case "unbound address":
+				ins.x86UnboundAddressOverride = true
+			case "segment":
+				ins.x86SegmentPrefix = 0x64
+			case "raw return":
+				ins.x86RawNearReturn = new(x86RawNearReturnForm)
+			}
+			state := x86ResultState{}
+			if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+				t.Fatal("named numerical identity manufactured a physical source role")
+			}
+		})
+	}
+}
diff --git a/x86_integer_test_mask_effect_test.go b/x86_integer_test_mask_effect_test.go
new file mode 100644
index 000000000..37103e7ee
--- /dev/null
+++ b/x86_integer_test_mask_effect_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86IntegerTestMaskResultKeepsFlagsVectorsAndInputMaskRoles(t *testing.T) {
+	for _, op := range strings.Fields("VPTESTMB VPTESTMW VPTESTMD VPTESTMQ VPTESTNMB VPTESTNMW VPTESTNMD VPTESTNMQ") {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, destination := range []int{0, 2, 1} {
+				row := fmt.Sprintf("%s %s0,%s1,K1,K%d", op, bank, bank, destination)
+				ins := x86ScalarLaneInstruction(t, row)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil || !effect.requiresResultProof {
+					t.Fatal("complete original mask-result row lost its typed byte effect", row, err)
+				}
+				result := effect.operands[2]
+				if result.index != 3 || result.width != 8 || result.read || !result.write {
+					t.Fatal("output K acquired an old-result read or vector carrier", row, result)
+				}
+				for _, maskKnown := range []bool{false, true} {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.masks[1] = maskKnown
+					before := state.clone()
+					accepted := x86ResultTransfer(ins, &state, nil, 0, "amd64")
+					if maskKnown {
+						before.masks[destination] = true
+					}
+					if accepted != maskKnown || !reflect.DeepEqual(state, before) {
+						t.Fatal("K0 output, mask/output alias, FLAGS/DF or source vectors changed", row, maskKnown, accepted)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_integer_test_mask_fault_unix_test.go b/x86_integer_test_mask_fault_unix_test.go
new file mode 100644
index 000000000..3e8fcef2f
--- /dev/null
+++ b/x86_integer_test_mask_fault_unix_test.go
@@ -0,0 +1,65 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86IntegerTestMaskLiveAndDeadE4ReadFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("test-to-mask faults require LLVM22 llc/clang")
+	}
+	for _, discard := range []bool{false, true} {
+		var source, declarations, prototypes, metadata strings.Builder
+		count := 0
+		for _, row := range x86IntegerTestMaskValueCases() {
+			// The independent full family has 36 full/scalar memory shapes.
+			// K0 and masking are fixed here; both K0/K2 value roles stay in
+			// the numerical owner rather than duplicating the fault matrix.
+			if row.first == 0 || row.masked == 0 || row.destination != "K0" {
+				continue
+			}
+			op, extent := row.op, row.width
+			if row.first == 2 {
+				op, extent = op+".BCST", row.bits/8
+			}
+			name, result := fmt.Sprint("TestMaskFault", count), "KMOVQ K0,AX\n"
+			if discard {
+				result = "MOVQ $0,AX\n"
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ p+0(FP),AX\nKMOVQ mask+8(FP),K1\n"+
+				"VPXORD Z1,Z1,Z1\n%s (AX),%s1,K1,K0\n%sMOVQ AX,ret+16(FP)\nRET\n", name, op, row.bank, result)
+			fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64) uint64\n", name)
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, extent, row.bits/8, row.width*8/row.bits)
+			count++
+		}
+		if count != 36 {
+			t.Fatal("lost a byte/word/dword/qword, width or broadcast fault shape", count)
+		}
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+		driver := x86E4DeadReadFaultOracle(prototypes.String(), metadata.String())
+		const voidKernel = "typedef void (*Kernel)(const uint8_t *,uint64_t);"
+		if strings.Count(driver, voidKernel) != 1 {
+			t.Fatal("shared fault oracle lost its single typed kernel declaration")
+		}
+		// Keep the existing protection/process observer unchanged. The live
+		// function returns its K value; the dead function returns a constant.
+		driver = strings.Replace(driver, voidKernel, "typedef uint64_t (*Kernel)(const uint8_t *,uint64_t);", 1)
+		triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("discard=%t/%s", discard, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+				if err != nil {
+					t.Fatal("initialized memory source rejected before fault observation", err)
+				}
+				x86ConflictFunnelPortableRuntime(t, llc, clang, "integer-test-mask-e4", triple, ir, driver)
+			})
+		}
+	}
+}
diff --git a/x86_integer_test_mask_typed_family_test.go b/x86_integer_test_mask_typed_family_test.go
new file mode 100644
index 000000000..7b48ab0d3
--- /dev/null
+++ b/x86_integer_test_mask_typed_family_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86IntegerTestMaskValueCase struct {
+	op, bank, destination string
+	width, bits, negative int
+	first, masked, pair   int
+}
+
+func x86IntegerTestMaskValueCases() []x86IntegerTestMaskValueCase {
+	var cases []x86IntegerTestMaskValueCase
+	positions := make(map[string]int)
+	key := func(row x86IntegerTestMaskValueCase, negative int) string {
+		return fmt.Sprintf("%d/%d/%d/%d/%d/%s", negative, row.width, row.bits, row.first, row.masked, row.destination)
+	}
+	for _, negative := range []int{0, 1} {
+		for _, lane := range []struct {
+			letter string
+			bits   int
+		}{{"B", 8}, {"W", 16}, {"D", 32}, {"Q", 64}} {
+			op := "VPTESTM" + lane.letter
+			if negative != 0 {
+				op = "VPTESTNM" + lane.letter
+			}
+			for index, bank := range []string{"X", "Y", "Z"} {
+				for first := 0; first < 3; first++ {
+					if first == 2 && lane.bits < 32 {
+						continue
+					}
+					for _, masked := range []int{0, 1} {
+						for _, destination := range []string{"K0", "K2"} {
+							row := x86IntegerTestMaskValueCase{op: op, bank: bank, destination: destination,
+								width: 16 << index, bits: lane.bits, negative: negative, first: first, masked: masked}
+							positions[key(row, negative)] = len(cases)
+							cases = append(cases, row)
+						}
+					}
+				}
+			}
+		}
+	}
+	for index := range cases {
+		cases[index].pair = positions[key(cases[index], 1-cases[index].negative)]
+	}
+	return cases
+}
+
+func TestX86IntegerTestMaskTypedPortableValuesAndMaskRoles(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("test-to-mask values require LLVM22 llc/clang")
+	}
+	cases := x86IntegerTestMaskValueCases()
+	if len(cases) != 240 {
+		t.Fatal("lost an official source/width/mask shape or K0/K2 result", len(cases))
+	}
+	for index, row := range cases {
+		if row.pair < 0 || row.pair >= len(cases) || row.pair == index || cases[row.pair].pair != index ||
+			cases[row.pair].negative == row.negative {
+			t.Fatal("M/NM source catalogue lost its independent complement partner", index, row)
+		}
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	for index, row := range cases {
+		name := fmt.Sprint("IntegerTestMask", index)
+		first, op, predicate := row.bank+"0", row.op, ""
+		if row.first != 0 {
+			first = "(AX)"
+		}
+		if row.first == 2 {
+			op += ".BCST"
+		}
+		maskInput := ""
+		if row.masked != 0 {
+			maskInput, predicate = "KMOVQ mask+16(FP),K1\n", "K1,"
+		}
+		// The destination K0/K2 is never initialized. An output K does not
+		// acquire a merge/old-result dependency from an optional write mask.
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),DX\nMOVQ flags+24(FP),DI\n"+
+			"VMOVUPS (AX),Z0\nVMOVUPS (DX),Z1\n%sSTC\n%s %s,%s1,%s%s\nKMOVQ %s,AX\nSETCS (DI)\nMOVQ AX,ret+32(FP)\nRET\n",
+			name, maskInput, op, first, row.bank, predicate, row.destination, row.destination)
+		fmt.Fprintf(&declarations, "func %s(a,b *[64]byte,mask uint64,flags *byte) uint64\n", name)
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(const uint8_t*,const uint8_t*,uint64_t,uint8_t*);\n", name)
+		fmt.Fprintf(&rows, "{%s,%d,\"%s\",%d,%d,%d,%d,%d},\n", name, row.pair, op,
+			row.width, row.bits, row.negative, row.first, row.masked)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() + `
+typedef struct {
+ uint64_t (*run)(const uint8_t*,const uint8_t*,uint64_t,uint8_t*);
+ unsigned pair;
+ const char *op;
+ unsigned width,bits,negative,first,masked;
+} Row;
+static const Row rows[]={
+` + rows.String() + `};
+static uint64_t load_lane(const uint8_t *p,unsigned bytes) {
+ uint64_t value=0;
+ for(unsigned byte=0;byte<bytes;byte++) value|=(uint64_t)p[byte]<<(8*byte);
+ return value;
+}
+int main(void) {
+ for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+  const Row *p=rows+r;
+  unsigned lane=p->bits/8,lanes=p->width/lane;
+  uint64_t relevant=lanes==64?UINT64_MAX:(UINT64_C(1)<<lanes)-1;
+  const uint64_t masks[]={0,1,UINT64_C(0xa55a9c63f00fc33c),UINT64_MAX,lanes<64?UINT64_C(1)<<lanes:0};
+  for(unsigned sample=0;sample<32;sample++) {
+   uint8_t a[66],b[66],saved_a[66],saved_b[66];
+   memset(a,0xa7,sizeof(a));memset(b,0x91,sizeof(b));
+   for(unsigned byte=0;byte<64;byte++) {
+    uint8_t x=(uint8_t)(byte*13+sample*17+1),y=(uint8_t)(byte*29+sample*37+3);
+    switch(sample&7) {
+     case 0:x=0;y=255;break;
+     case 1:x=255;y=255;break;
+     case 2:y=(uint8_t)~x;break;
+     case 3:y=x;break;
+     case 4:x=128;y=128;break;
+     case 5:x=1;y=1;break;
+     case 6:y=0;break;
+    }
+    a[byte+1]=x;b[byte+1]=y;
+   }
+   memcpy(saved_a,a,sizeof(a));memcpy(saved_b,b,sizeof(b));
+   for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+    uint64_t want=0,active=p->masked?masks[m]&relevant:relevant;
+    for(unsigned j=0;j<lanes;j++) {
+     uint64_t x=load_lane(a+1+(p->first==2?0:j*lane),lane),y=load_lane(b+1+j*lane,lane);
+     unsigned bit=p->negative?(x&y)==0:(x&y)!=0;
+     if((active>>j&1)&&bit) want|=UINT64_C(1)<<j;
+    }
+    uint8_t carry=0xa7,opposite_carry=0x91;
+    uint64_t actual=p->run(a+1,b+1,masks[m],&carry);
+    uint64_t opposite=rows[p->pair].run(a+1,b+1,masks[m],&opposite_carry);
+    if(actual!=want||(actual^opposite)!=active||carry!=1||opposite_carry!=1||
+       memcmp(a,saved_a,sizeof(a))||memcmp(b,saved_b,sizeof(b))) {
+     fprintf(stderr,"test-to-mask row=%u op=%s sample=%u mask=%u got=%llx want=%llx active=%llx\n",
+      r,p->op,sample,m,(unsigned long long)actual,(unsigned long long)want,(unsigned long long)active);
+     return 1;
+    }
+   }
+  }
+ }
+ return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized test-to-mask rejected before numerical comparison", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "integer-test-mask", triple, ir, driver)
+		})
+	}
+}
+
+func TestX86IntegerTestMaskUnknownInputsDoNotBorrowCompareIdentities(t *testing.T) {
+	for _, op := range strings.Fields("VPTESTMB VPTESTMW VPTESTMD VPTESTMQ VPTESTNMB VPTESTNMW VPTESTNMD VPTESTNMQ") {
+		for _, change := range []string{"first", "second", "write mask", "identical unknown"} {
+			body := "VMOVUPS (AX),Z0\nVMOVUPS (AX),Z1\n"
+			instruction := op + " X0,X1,K0\n"
+			switch change {
+			case "first":
+				body = strings.Replace(body, "VMOVUPS (AX),Z0\n", "", 1)
+			case "second":
+				body = strings.Replace(body, "VMOVUPS (AX),Z1\n", "", 1)
+			case "write mask":
+				instruction = op + " X0,X1,K1,K0\n"
+			case "identical unknown":
+				body, instruction = "", op+" X0,X0,K0\n"
+			}
+			source := "TEXT ·UnknownTestMask(SB),4,$0-16\nMOVQ p+0(FP),AX\n" + body + instruction +
+				"KMOVQ K0,AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func UnknownTestMask(p *[64]byte) uint64\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if change != "write mask" {
+					x86VectorScratchCodegenControl(t, source, "func UnknownTestMask(p *[64]byte) uint64\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("test-to-mask invented numerical inputs or used an EQ/GT identity", op, change, api, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_isolated_void_obligation_test.go b/x86_isolated_void_obligation_test.go
new file mode 100644
index 000000000..f53fc4e03
--- /dev/null
+++ b/x86_isolated_void_obligation_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86IsolatedVoidSample struct {
+	name, source, declaration string
+	context                   bool
+	goRejected                bool
+}
+
+// Complete stock-Go programs precede every tested API. There are deliberately
+// no SETcc, vector loads, result stores or unrelated mandatory instructions
+// that could accidentally request the tested family's missing source proof.
+func x86CheckIsolatedVoidSamples(t *testing.T, arch string, samples []x86IsolatedVoidSample) {
+	t.Helper()
+	var original strings.Builder
+	for _, sample := range samples {
+		if !sample.goRejected {
+			original.WriteString(sample.source)
+		}
+	}
+	goAssemblerOracleOutput(t, arch, original.String(), "", true)
+	for _, sample := range samples {
+		if sample.goRejected {
+			// Go386's byte-SP source is not an accepted physical SP row.
+			// Preserve its actual source-bound rejection separately instead
+			// of treating a failed prior as an input-proof defect.
+			goAssemblerOracleOutput(t, arch, sample.source, "", false)
+			continue
+		}
+		function := mustParseX86RawReturn(t, sample.source).Funcs[0]
+		setup := function
+		setup.Instrs = nil
+		for _, instruction := range function.Instrs {
+			_, compare, _ := x86COMIProperties(instruction, arch)
+			_, store, _ := x86ScalarStaticStoreProperties(instruction.Op, instruction, arch)
+			if !compare && !store {
+				setup.Instrs = append(setup.Instrs, instruction)
+			}
+		}
+		if x86TypedFPResultNeedsProof(setup, FuncSig{Ret: Void}, arch) {
+			t.Fatal("fixture contains an unrelated mandatory source-proof instruction", sample.name)
+		}
+	}
+	for _, target := range x86AddressMemoryTargets(arch) {
+		t.Run(target, func(t *testing.T) {
+			for _, sample := range samples {
+				t.Run(sample.name, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, sample.source, sample.declaration, arch, target, api)
+							if sample.goRejected {
+								if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("Go-rejected byte-SP syntax became a source-context or accepted program", err)
+								}
+							} else if sample.context {
+								if arch == "amd64" && strings.HasSuffix(sample.name, "_memory/missing-right") && !strings.Contains(sample.name, "_raw_") {
+									x86VectorScratchCodegenControl(t, sample.source, sample.declaration, arch, target, ir, err)
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("isolated Void instruction acquired absent input or storage authority", err)
+								}
+							} else if strings.HasSuffix(sample.name, "/numeric-pointer") {
+								x86RequireNumericNativeSourceContext(t, sample.source, sample.declaration, arch)
+								width := 4
+								if strings.Contains(sample.name, "SD") {
+									width = 8
+								}
+								if err != nil || !strings.Contains(ir, "asm sideeffect") ||
+									!strings.Contains(ir, fmt.Sprintf("elementtype([%d x i8])", width)) || !strings.Contains(ir, "~{fpsr}") {
+									t.Fatal("numerical address lost isolated COMI's native exact-width read", err)
+								}
+								x86NumericNativeAddressObject(t, ir, target)
+							} else if err != nil || ir == "" {
+								t.Fatal("same isolated Void instruction lost its complete initialized inputs", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86COMIIsolatedVoidRetainsCompleteInputObligations(t *testing.T) {
+	// Independent original Go and LLVM physical priors retain all four raw
+	// VEX/EVEX names, including low-bank EVEX and register-only SAE. Legacy
+	// names use the complete named grammar below, not this new raw permission.
+	rawRows := x86COMIRawProducerRows(t)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			type form struct {
+				label, operation string
+				memory           bool
+			}
+			var forms []form
+			for _, op := range []string{"COMISS", "UCOMISS", "COMISD", "UCOMISD", "VCOMISS", "VUCOMISS", "VCOMISD", "VUCOMISD"} {
+				forms = append(forms, form{op + "_register", op + " X1,X0\n", false},
+					form{op + "_memory", op + " (BX),X0\n", true})
+				if strings.HasPrefix(op, "V") {
+					forms = append(forms, form{op + "_SAE", op + ".SAE X1,X0\n", false})
+				}
+			}
+			for _, row := range rawRows {
+				forms = append(forms, form{row.op + "_raw_" + row.encoding + "_" + row.form,
+					x86RawDisplacementDirectives(row.code), row.form == "memory"})
+			}
+			if len(forms) != 40 {
+				t.Fatal("complete isolated named/raw COMI inventory changed", len(forms))
+			}
+			word, move := goWordSize(arch), "MOVQ"
+			if arch == "386" {
+				move = "MOVL"
+			}
+			var samples []x86IsolatedVoidSample
+			for _, row := range forms {
+				controls := []string{"initialized", "missing-right", "partial-right"}
+				if row.memory {
+					controls = append(controls, "missing-pointer", "numeric-pointer")
+				} else {
+					controls = append(controls, "missing-left", "partial-left", "missing-both")
+				}
+				for _, control := range controls {
+					name := fmt.Sprint("VoidCOMI", len(samples))
+					setup := "MOVL $0,AX\nMOVL AX,X0\nMOVL AX,X1\n"
+					if row.memory {
+						setup += move + " p+0(FP),BX\n"
+					}
+					switch control {
+					case "missing-right", "missing-both":
+						setup = strings.Replace(setup, "MOVL AX,X0\n", "", 1)
+					case "partial-right":
+						setup = strings.Replace(setup, "MOVL AX,X0\n", "MOVB $0,DL\nMOVL DX,X0\n", 1)
+					case "missing-left":
+						setup = strings.Replace(setup, "MOVL AX,X1\n", "", 1)
+					case "partial-left":
+						setup = strings.Replace(setup, "MOVL AX,X1\n", "MOVB $0,DL\nMOVL DX,X1\n", 1)
+					case "missing-pointer":
+						setup = strings.Replace(setup, move+" p+0(FP),BX\n", "", 1)
+					case "numeric-pointer":
+						setup = strings.Replace(setup, move+" p+0(FP),BX\n", move+" $1,BX\n", 1)
+					}
+					if control == "missing-both" {
+						setup = strings.Replace(setup, "MOVL AX,X1\n", "", 1)
+					}
+					extent, declaration := 0, fmt.Sprintf("func %s()\n", name)
+					if row.memory {
+						extent, declaration = word, fmt.Sprintf("func %s(p *byte)\n", name)
+					}
+					source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s%sRET\n", name, extent, setup, row.operation)
+					samples = append(samples, x86IsolatedVoidSample{row.label + "/" + control, source, declaration,
+						control != "initialized" && control != "numeric-pointer", false})
+				}
+			}
+			x86CheckIsolatedVoidSamples(t, arch, samples)
+		})
+	}
+}
+
+func TestX86OwnedScalarMOVIsolatedVoidRetainsInputsAndStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			word, move := goWordSize(arch), "MOVQ"
+			if arch == "386" {
+				move = "MOVL"
+			}
+			var samples []x86IsolatedVoidSample
+			for _, row := range x86OwnedScalarStoreRows(arch) {
+				for _, control := range []string{"initialized", "immediate", "missing", "partial", "pointer", "physical-SP", "readonly", "past-end", "external"} {
+					name := fmt.Sprint("VoidMOV", len(samples))
+					storage := fmt.Sprint("·storage", len(samples))
+					global := "GLOBL " + storage + "(SB),16,$32\n"
+					setup := move + " $0x12345678,AX\n"
+					input, destination := row.register, storage+"+3(SB)"
+					extent, declaration := 0, fmt.Sprintf("func %s()\n", name)
+					switch control {
+					case "immediate":
+						setup, input = "", "$7"
+					case "missing":
+						setup = ""
+					case "partial":
+						setup = "MOVB $7,AL\n"
+						if row.width == 1 && row.first == 0 {
+							setup = "MOVB $7,AH\n" // Define a different byte, never the selected AL.
+						}
+					case "pointer":
+						setup = move + " p+0(FP),AX\n"
+						extent, declaration = word, fmt.Sprintf("func %s(p *byte)\n", name)
+					case "physical-SP":
+						setup, input = "", "SP"
+					case "readonly":
+						global = "GLOBL " + storage + "(SB),8,$32\n"
+					case "past-end":
+						destination = storage + "+32(SB)"
+					case "external":
+						global = ""
+					}
+					source := fmt.Sprintf("%sTEXT ·%s(SB),4,$0-%d\n%s%s %s,%s\nRET\n",
+						global, name, extent, setup, row.op, input, destination)
+					samples = append(samples, x86IsolatedVoidSample{row.op + "/" + row.register + "/" + control,
+						source, declaration, control != "initialized" && control != "immediate",
+						arch == "386" && row.width == 1 && control == "physical-SP"})
+				}
+			}
+			x86CheckIsolatedVoidSamples(t, arch, samples)
+		})
+	}
+}
diff --git a/x86_k_data_mode32_test.go b/x86_k_data_mode32_test.go
new file mode 100644
index 000000000..61834233e
--- /dev/null
+++ b/x86_k_data_mode32_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Primary Intel XED: F2/W1 92/93 aliases to KMOVD32 in32-bit mode.
+// The original Go W1 bytes remain literal even though the GP transfer is32-bit.
+func TestX86KDataMode32GPQEffective32NamedAndRaw(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, row := range []struct {
+		name, instruction, source, declaration string
+		encoding                               []byte
+	}{
+		{"K-to-GP", "KMOVQ K0,BX",
+			"TEXT ·Value(SB),4,$0-12\nKMOVQ a+0(FP),K0\nKMOVQ K0,BX\nMOVL BX,ret+8(FP)\nRET\n",
+			"func Value(a uint64) uint32", []byte{0xc4, 0xe1, 0xfb, 0x93, 0xd8}},
+		{"GP-to-K", "KMOVQ AX,K0",
+			"TEXT ·Value(SB),4,$0-12\nMOVL a+0(FP),AX\nKMOVQ AX,K0\nKMOVQ K0,ret+4(FP)\nRET\n",
+			"func Value(a uint32) uint64", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc0}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			listing, err := x86ScalarLiteralGoListing(t, "386", row.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fixture := x86OfficialPackedCase{
+				row: "independent/K-data/mode32/" + row.name, symbol: "Value", line: 3,
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: row.instruction, Encoding: row.encoding},
+			}
+			if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{fixture}); err != nil {
+				t.Fatal(err)
+			}
+			for _, raw := range []bool{false, true} {
+				name, source := "named", row.source
+				if raw {
+					name = "raw"
+					source = strings.Replace(source, row.instruction+"\n", x86RawDisplacementDirectives(row.encoding), 1)
+				}
+				t.Run(name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, "386", "i386-unknown-linux-gnu", api)
+							if err != nil || ir == "" {
+								t.Fatal("legal32-bit KMOV alias lacks its effective-width contract", err)
+							}
+							effect, known, err := x86TypedMaskMoveByteEffect("KMOVQ", x86ScalarLaneInstruction(t, row.instruction), "386")
+							if !known || err != nil || len(effect.operands) != 2 ||
+								effect.operands[0].width != 4 || effect.operands[1].width != 4 {
+								t.Fatal("typed effect did not bind the effective32-bit GP transfer", known, err, effect)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, "i386-unknown-linux-gnu", ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	// The independent portable integer owner checks values separately; these
+	// objects do not establish native386/AVX512 execution.
+}
+
+func TestX86KDataMode32GPQRejectsMissingNumericalInputs(t *testing.T) {
+	for _, row := range []struct {
+		name, declaration, body, instruction string
+		code                                 []byte
+	}{
+		{"unknown-GP", "func Value(a uint32) uint64", "", "KMOVQ AX,K0", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc0}},
+		{"partial-GP", "func Value(a uint32) uint64", "MOVW a+0(FP),AX\n", "KMOVQ AX,K0", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc0}},
+		{"pointer-GP", "func Value(a *byte) uint64", "MOVL a+0(FP),AX\n", "KMOVQ AX,K0", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc0}},
+		{"unknown-K", "func Value(a uint64) uint32", "", "KMOVQ K0,BX", []byte{0xc4, 0xe1, 0xfb, 0x93, 0xd8}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			store := "KMOVQ K0,ret+4(FP)\n"
+			if row.name == "unknown-K" {
+				store = "MOVL BX,ret+8(FP)\n"
+			}
+			for _, raw := range []bool{false, true} {
+				instruction := row.instruction + "\n"
+				if raw {
+					instruction = x86RawDisplacementDirectives(row.code)
+				}
+				source := "TEXT ·Value(SB),4,$0-12\n" + row.body + instruction + store + "RET\n"
+				x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, "386", "i386-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("mode-effective width invented NUM/K input", raw, api, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86KDataMode32KeepsQNonGP64(t *testing.T) {
+	for _, text := range []string{"KMOVQ K0,K3", "KMOVQ (AX),K3", "KMOVQ K0,(AX)"} {
+		t.Run(text, func(t *testing.T) {
+			effect, known, err := x86TypedMaskMoveByteEffect("KMOVQ", x86ScalarLaneInstruction(t, text), "386")
+			if !known || err != nil || len(effect.operands) != 2 ||
+				effect.operands[0].width != 8 || effect.operands[1].width != 8 {
+				t.Fatal("GP-width normalization truncated a real64-bit K/memory form", known, err, effect)
+			}
+		})
+	}
+}
diff --git a/x86_k_data_mode32_values_test.go b/x86_k_data_mode32_values_test.go
new file mode 100644
index 000000000..b826437f0
--- /dev/null
+++ b/x86_k_data_mode32_values_test.go
@@ -0,0 +1,172 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var x86KDataMode32ValueKernels = []struct {
+	name, input, output, body    string
+	frame, inputBits, outputBits int
+}{
+	{"From32", "uint32", "uint64", "MOVL a+0(FP),AX\nKMOVQ AX,K0\nKMOVQ K0,ret+4(FP)\nRET\n", 12, 32, 64},
+	{"To32", "uint64", "uint32", "KMOVQ a+0(FP),K0\nKMOVQ K0,AX\nMOVL AX,ret+8(FP)\nRET\n", 12, 64, 32},
+	{"From64Low", "uint64", "uint64", "MOVL a+0(FP),AX\nKMOVQ AX,K0\nKMOVQ K0,ret+8(FP)\nRET\n", 16, 64, 64},
+	{"ThroughGP", "uint64", "uint64", "KMOVQ a+0(FP),K0\nKMOVQ K0,AX\nKMOVQ AX,K1\nKMOVQ K1,ret+8(FP)\nRET\n", 16, 64, 64},
+	{"Keep64", "uint64", "uint64", "KMOVQ a+0(FP),K0\nKMOVQ K0,K1\nKMOVQ K1,ret+8(FP)\nRET\n", 16, 64, 64},
+}
+
+func x86KDataMode32ValueSource(t *testing.T) (string, string) {
+	t.Helper()
+	// Preserve W1 and the original Go opcode, including for the legal32-bit
+	// alias. Actual Go must verify these bytes before they replace named text.
+	operations := []struct {
+		instruction string
+		code        []byte
+	}{
+		{"KMOVQ AX,K0", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc0}},
+		{"KMOVQ K0,AX", []byte{0xc4, 0xe1, 0xfb, 0x93, 0xc0}},
+		{"KMOVQ AX,K1", []byte{0xc4, 0xe1, 0xfb, 0x92, 0xc8}},
+		{"KMOVQ K0,K1", []byte{0xc4, 0xe1, 0xf8, 0x90, 0xc8}},
+	}
+	var named, declarations strings.Builder
+	count := 0
+	for _, row := range x86KDataMode32ValueKernels {
+		name := "Named" + row.name
+		body := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s", name, row.frame, row.body)
+		listing, err := x86ScalarLiteralGoListing(t, "386", body)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for offset, instruction := range strings.Split(body, "\n") {
+			for _, operation := range operations {
+				if instruction == operation.instruction {
+					fixture := x86OfficialPackedCase{symbol: name, line: 1 + offset,
+						witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: operation.code}}
+					if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{fixture}); err != nil {
+						t.Fatal(err)
+					}
+					count++
+				}
+			}
+		}
+		named.WriteString(body)
+		for _, prefix := range []string{"Named", "Raw"} {
+			fmt.Fprintf(&declarations, "func %s%s(a %s) %s\n", prefix, row.name, row.input, row.output)
+		}
+	}
+	if count != 6 {
+		t.Fatal("lost original GP/K operations", count)
+	}
+	raw := strings.ReplaceAll(named.String(), "Named", "Raw")
+	for _, operation := range operations {
+		if !strings.Contains(raw, operation.instruction+"\n") {
+			t.Fatal("missing raw counterpart", operation.instruction)
+		}
+		raw = strings.ReplaceAll(raw, operation.instruction+"\n", x86RawDisplacementDirectives(operation.code))
+	}
+	source := named.String() + raw
+	x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", source)
+	return source, declarations.String()
+}
+
+func TestX86KDataMode32GPQPortableIntegerValues(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	source, declarations := x86KDataMode32ValueSource(t)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := parseIRModuleInContext(context, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, row := range x86KDataMode32ValueKernels {
+				for _, prefix := range []string{"Named", "Raw"} {
+					function := module.NamedFunction(prefix + row.name)
+					if function.IsNil() || function.FirstBasicBlock().IsNil() || function.ParamsCount() != 1 ||
+						function.Param(0).Type().TypeKind() != llvm.IntegerTypeKind || function.Param(0).Type().IntTypeWidth() != row.inputBits ||
+						function.GlobalValueType().ReturnType().TypeKind() != llvm.IntegerTypeKind || function.GlobalValueType().ReturnType().IntTypeWidth() != row.outputBits {
+						t.Fatal("portable C ABI differs from actual translated integer types", prefix, row.name)
+					}
+				}
+			}
+			for _, pipeline := range []struct {
+				name, level string
+				optimize    bool
+			}{
+				{"default-O0", "-O0", false}, {"default-O2", "-O2", false}, {"opt-O2", "-O2", true},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					text := ir
+					if pipeline.optimize {
+						text = x86DwordProductIROptimize(t, ir)
+					}
+					execution.compileAndRunLLVM(t, "kmov-mode32-portable", text, x86KDataMode32ValueDriver, pipeline.level)
+				})
+			}
+		})
+	}
+	t.Log("source386 integer semantics executed via matching host C/LLVM widths; no native386/AVX512 execution or memory-fault claim")
+}
+
+const x86KDataMode32ValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#define DECLARE(prefix) \
+    extern uint64_t prefix##From32(uint32_t); \
+    extern uint32_t prefix##To32(uint64_t); \
+    extern uint64_t prefix##From64Low(uint64_t); \
+    extern uint64_t prefix##ThroughGP(uint64_t); \
+    extern uint64_t prefix##Keep64(uint64_t)
+DECLARE(Named);
+DECLARE(Raw);
+struct kernels {
+    uint64_t (*from32)(uint32_t);
+    uint32_t (*to32)(uint64_t);
+    uint64_t (*from64)(uint64_t), (*through)(uint64_t), (*keep)(uint64_t);
+};
+static const struct kernels variants[] = {
+    {NamedFrom32, NamedTo32, NamedFrom64Low, NamedThroughGP, NamedKeep64},
+    {RawFrom32, RawTo32, RawFrom64Low, RawThroughGP, RawKeep64}
+};
+int main(void) {
+    static const uint64_t values[] = {
+        0, 1, UINT64_C(0x7fffffff), UINT64_C(0x80000000),
+        UINT64_C(0xffffffff), UINT64_C(0x100000000),
+        UINT64_C(0xffffffff00000000), UINT64_C(0x0123456789abcdef),
+        UINT64_MAX, UINT64_C(0x8000000000000000),
+        UINT64_C(0x7fffffffffffffff), UINT64_C(0x100000001)
+    };
+    for (unsigned variant = 0; variant < 2; ++variant) {
+        struct kernels k = variants[variant];
+        for (unsigned i = 0; i < sizeof(values)/sizeof(values[0]); ++i) {
+            uint64_t a = values[i], low = (uint32_t)a;
+            uint64_t from32 = k.from32((uint32_t)a);
+            uint32_t to32 = k.to32(a);
+            uint64_t from64 = k.from64(a), through = k.through(a), keep = k.keep(a);
+            if (from32 != low || (uint64_t)to32 != low || from64 != low ||
+                    through != low || keep != a) {
+                fprintf(stderr, "variant=%u case=%u input=%llx from32=%llx "
+                        "to32=%x from64=%llx through=%llx keep=%llx\n",
+                        variant, i, (unsigned long long)a, (unsigned long long)from32,
+                        to32, (unsigned long long)from64,
+                        (unsigned long long)through, (unsigned long long)keep);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_label_namespace_runtime_test.go b/x86_label_namespace_runtime_test.go
new file mode 100644
index 000000000..cb1d0f9ad
--- /dev/null
+++ b/x86_label_namespace_runtime_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RegisterShapedLabelsPortableResults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			result, extent, originalTriple := 8, 12, "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				result, extent, originalTriple = 4, 8, "i386-unknown-linux-gnu"
+			}
+			source := fmt.Sprintf(`TEXT ·Value(SB),4,$0-%d
+MOVL input+0(FP),AX
+TESTL AX,AX
+JEQ x1
+INCL AX
+JMP t1
+x1:
+MOVL $17,AX
+JMP t1
+t1:
+JMP reg_AX
+reg_AX:
+JMP bb_foo
+bb_foo:
+MOVL AX,result+%d(FP)
+RET
+`, extent, result)
+			x86LEAActualTargetGoObject(t, arch, originalTriple, source)
+			const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t Value(uint32_t);
+int main(void) {
+    const uint32_t edges[] = {0,1,2,0x7fffffffU,0x80000000U,0xfffffffeU,0xffffffffU};
+    for (unsigned row=0;row<sizeof(edges)/sizeof(edges[0]);++row) {
+        uint32_t input=edges[row], expected=input ? input+1 : 17;
+        uint32_t actual=Value(input);
+        if (actual!=expected) {
+            fprintf(stderr,"label row=%u input=%u got=%u want=%u\n",row,input,actual,expected);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(input uint32) uint32", arch, execution.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized register-shaped labels lost their source CFG", err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							execution.compileAndRunLLVM(t, "branch-label-namespace", text, driver, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_leave_private_math_linux_amd64_test.go b/x86_leave_private_math_linux_amd64_test.go
new file mode 100644
index 000000000..9c130557b
--- /dev/null
+++ b/x86_leave_private_math_linux_amd64_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+// Actual Linux AMD64/IA32 execution of private LLVM register mathematics only.
+// In particular, this is not execution of an original Go LEAVE/RET stack ABI.
+func TestCrossLinuxRuntimeMatrixX86LeavePrivateEmitterWidthsAndFlags(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("required private LEAVE IA32/AMD64 execution needs LLVM22")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			execution, word := x86FloatCompareExecutionTools(t), 8
+			if arch == "386" {
+				execution = x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+					compiler: []string{"i686-linux-gnu-gcc", "-static", "-no-pie"}}
+				word = 4
+			}
+			if len(execution.prefix) != 0 || execution.preserveArgv0 {
+				t.Fatal("private LEAVE native-width counterpart forbids guest/emulator execution")
+			}
+			source, signatures := x86LeavePrivateWidthProgram(arch)
+			x86LEAActualTargetGoObject(t, arch, execution.triple, source)
+			ir := x86PhysicalSPPrivateEmitter(t, source, signatures, arch, execution.triple)
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+				{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "private-leave-native-width", pipeline.ir, x86LeavePrivateWidthC(word), pipeline.level)
+					var output []byte
+					if arch == "386" {
+						output = x87IA32RunDirect(t, x86NativeOracleIA32Executable(t, execution, executable), nil, os.Environ())
+					} else {
+						output = execution.run(t, executable)
+					}
+					const marker = "PRIVATE_LEAVE_128_WIDTH_VALUES_FLAGS_CANARIES_PASS\n"
+					if string(output) != marker {
+						t.Fatal("private LEAVE width/value/FLAGS/canary observation was incomplete", strings.TrimSpace(string(output)))
+					}
+					t.Logf("private LEAVE numerical completion arch=%s: %s", arch, output)
+				})
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_legacy_386_split_input_float_test.go b/x86_legacy_386_split_input_float_test.go
new file mode 100644
index 000000000..a94eb45b9
--- /dev/null
+++ b/x86_legacy_386_split_input_float_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86Legacy386SplitInputCase struct {
+	name, typ, nonzero string
+	bytes, half        int
+}
+
+// This inventory is independent of the new byte-view selector. The old 386
+// evalFPToI64 reader already bitcasts complete float inputs and obtains an
+// I64/double high word at +4. It never treats an arbitrary offset as that role.
+var x86Legacy386SplitInputCases = []x86Legacy386SplitInputCase{
+	{"natural-I32", "uint32", "1", 4, 0},
+	{"natural-F32", "float32", "0x3FF0000020000000", 4, 0},
+	{"low-I64", "uint64", "4294967297", 8, 0},
+	{"high-I64", "uint64", "4294967297", 8, 4},
+	{"low-F64", "float64", "0x3FF0000100000001", 8, 0},
+	{"high-F64", "float64", "0x3FF0000100000001", 8, 4},
+}
+
+func x86Legacy386SplitInputFloatSource(row x86Legacy386SplitInputCase) (string, string) {
+	result := row.bytes + 8
+	// Both branches initialize the same one-element x87 stack before its
+	// complete floating result store. The tested input word affects control,
+	// so an unresolved-offset zero cannot impersonate the legacy reader.
+	body := fmt.Sprintf("MOVL x+%d(FP),AX\nANDL $1,AX\nTESTL AX,AX\nJEQ one\nFMOVD q+%d(FP),F0\nJMP done\none:\nFLD1\ndone:\nFMOVDP F0,ret+%d(FP)\nRET\n",
+		row.half, row.bytes, result)
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", result+8, body)
+	return source, "func Value(x " + row.typ + ", q float64) float64"
+}
+
+func TestX86Legacy386SplitInputFloatResultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue // This exact old source-half transport is mode32-only.
+		}
+		for _, row := range x86Legacy386SplitInputCases {
+			source, declaration := x86Legacy386SplitInputFloatSource(row)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("existing typed split-input/floating-result consumer was intercepted", err)
+					}
+					inputType := map[string]string{"uint32": "i32", "uint64": "i64", "float32": "float", "float64": "double"}[row.typ]
+					zero := "0"
+					if strings.HasPrefix(row.typ, "float") {
+						zero = "0.000000e+00"
+					}
+					for _, input := range []struct {
+						literal string
+						bits    uint64
+					}{{zero, 0x3ff0000000000000}, {row.nonzero, 0x4000000000000000}} {
+						// This test-owned caller observes exact returned bits after
+						// in-process optimization, not native x87 execution.
+						probe := fmt.Sprintf("\ndefine i64 @Probe() {\n %%r = call double @Value(%s %s, double 2.000000e+00)\n %%b = bitcast double %%r to i64\n ret i64 %%b\n}\n", inputType, input.literal)
+						x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{input.bits})
+					}
+				})
+			}
+		}
+	}
+}
+
+// These views are not intrinsically invalid: they read only bytes of already
+// mapped numerical fields. Their old Context also named the separate missing
+// x87 effect. Keep the exact source shapes, but require real values once that
+// complete effect proof is implemented; no legacy fallback supplies the proof.
+func TestX86Legacy386MappedViewsComposeWithDefinedX87(t *testing.T) {
+	base, declaration := x86Legacy386SplitInputFloatSource(x86Legacy386SplitInputCases[4])
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range []struct {
+			name, source, odd string
+		}{
+			{"interior-offset", strings.Replace(base, "MOVL x+0(FP)", "MOVL x+1(FP)", 1), "0x3FF0000000000100"},
+			// Initialize the unwritten GP bytes independently. Reconstructing
+			// ANDL's defined output from a sparse bit mask is a separate rule.
+			{"byte-view", strings.Replace(base, "MOVL x+0(FP)", "MOVL $0,AX\nMOVB x+0(FP)", 1), "0x3FF0000100000001"},
+			{"word-view", strings.Replace(base, "MOVL x+0(FP)", "MOVL $0,AX\nMOVW x+0(FP)", 1), "0x3FF0000100000001"},
+			{"cross-numeric-fields", strings.Replace(base, "MOVL x+0(FP)", "MOVL x+6(FP)", 1), "0x3FF1000000000000"},
+			{"known-MUL", strings.Replace(base, "ANDL $1,AX", "MOVL $3,BX\nMULL BX\nANDL $1,AX", 1), "0x3FF0000100000001"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("mapped NUM view lacks its independent complete x87 proof", err)
+					}
+					for _, input := range []struct {
+						literal string
+						bits    uint64
+					}{{"0.000000e+00", 0x3ff0000000000000}, {row.odd, 0x4000000000000000}} {
+						probe := fmt.Sprintf("\ndefine i64 @Probe() {\n %%r = call double @Value(double %s, double 2.000000e+00)\n %%b = bitcast double %%r to i64\n ret i64 %%b\n}\n", input.literal)
+						x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{input.bits})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Legacy386SplitInputCannotBypassNewViewOrNUMProof(t *testing.T) {
+	base, declaration := x86Legacy386SplitInputFloatSource(x86Legacy386SplitInputCases[4])
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range []struct {
+			name, source, declaration string
+		}{
+			{"padding", "TEXT ·Value(SB),4,$0-20\nMOVL x+1(FP),AX\nFMOVD q+4(FP),F0\nFMOVDP F0,ret+12(FP)\nRET\n", "func Value(x byte,q float64) float64"},
+			{"cross-pointer", "TEXT ·Value(SB),4,$0-28\nMOVL x+6(FP),AX\nFMOVD q+12(FP),F0\nFMOVDP F0,ret+20(FP)\nRET\n", "func Value(x uint64,p *byte,q float64) float64"},
+			{"missing-result", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nRET\n", declaration},
+			{"unknown-x87-result", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFMOVDP F0,ret+16(FP)\nRET\n", declaration},
+			{"unknown-GP-result", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nMOVL BX,ret+16(FP)\nMOVL $0,ret+20(FP)\nRET\n", declaration},
+			{"partial-result", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nMOVL AX,ret+16(FP)\nRET\n", declaration},
+			{"unknown-MUL-source", strings.Replace(base, "ANDL $1,AX", "MULL BX\nANDL $1,AX", 1), declaration},
+			{"native-store-under-MUL", strings.Replace(base, "ANDL $1,AX", "MOVL $3,BX\nMULL BX\nMOVL AX,0(CX)\nANDL $1,AX", 1), declaration},
+			{"unknown-F1", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFMOVD q+8(FP),F0\nFADDD F1,F0\nFMOVDP F0,ret+16(FP)\nRET\n", declaration},
+			{"pop-underflow", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFMOVDP F0,F0\nFMOVDP F0,ret+16(FP)\nRET\n", declaration},
+			{"joined-missing-F1", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nTESTL AX,AX\nJEQ one\nFLD1\none:\nFLD1\nFADDD F1,F0\nFMOVDP F0,ret+16(FP)\nRET\n", declaration},
+			{"ninth-authored-push", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\n" + strings.Repeat("FLD1\n", 9) + "FMOVDP F0,ret+16(FP)\nRET\n", declaration},
+			{"unknown-status-word", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFTST\nFSTSW AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nFMOVDP F0,F0\nRET\n", declaration},
+			{"entry-status", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFSTSW AX\nANDW $0x4000,AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nRET\n", declaration},
+			{"second-status-capture", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFTST\nFSTSW AX\nFSTSW AX\nANDW $0x4000,AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nFMOVDP F0,F0\nRET\n", declaration},
+			{"undefined-status-bit", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFTST\nFSTSW AX\nANDW $0x8000,AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nFMOVDP F0,F0\nRET\n", declaration},
+			{"status-clobbered-by-arithmetic", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFTST\nFSQRT\nFSTSW AX\nANDW $0x4000,AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nFMOVDP F0,F0\nRET\n", declaration},
+			{"status-register-overwrite", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFLD1\nFTST\nFSTSW AX\nMOVB BX,AH\nANDW $0x4000,AX\nMOVW AX,ret+16(FP)\nMOVW $0,ret+18(FP)\nMOVL $0,ret+20(FP)\nFMOVDP F0,F0\nRET\n", declaration},
+			{"native-x87-store", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFMOVD q+8(FP),F0\nFMOVDP F0,0(CX)\nMOVL $0,ret+16(FP)\nMOVL $0,ret+20(FP)\nRET\n", declaration},
+			{"FINIT-does-not-define-F0", "TEXT ·Value(SB),4,$0-24\nMOVL x+4(FP),AX\nFINIT\nFMOVDP F0,ret+16(FP)\nRET\n", declaration},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("legacy input role supplied an independent missing proof: output=%t, error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_legacy_386_stack_fixture_test.go b/x86_legacy_386_stack_fixture_test.go
new file mode 100644
index 000000000..8640ab653
--- /dev/null
+++ b/x86_legacy_386_stack_fixture_test.go
@@ -0,0 +1,313 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86Legacy386OriginalStackAdjust = `TEXT stackAdjust(SB),NOSPLIT,$0-0
+	PUSHFL
+	ADJSP $156
+	MOVL AX, 152(SP)
+	ADJSP $-156
+	POPFL
+	RET
+`
+
+const x86Legacy386OriginalIDProbe = `TEXT cpuidProbe(SB),NOSPLIT,$0-0
+	PUSHFL
+	PUSHFL
+	XORL $0x200000, 0(SP)
+	POPFL
+	PUSHFL
+	POPL AX
+	XORL 0(SP), AX
+	POPFL
+	TESTL $0x200000, AX
+	JNE cpuidAvailable
+	MOVL $0, AX
+	RET
+cpuidAvailable:
+	MOVL $1, AX
+	RET
+`
+
+const x86Legacy386OriginalStrings = `TEXT strings386(SB),NOSPLIT,$0-0
+	CLD
+	REP; MOVSB
+	STD
+	REP; MOVSL
+	CLD
+	REP; STOSL
+	REPN; SCASB
+	RET
+`
+
+const x86Legacy386OriginalMMXLoad = `TEXT mmxload(SB),NOSPLIT,$0-0
+	MOVQ (SI), M0
+	MOVL M0, AX
+	EMMS
+	RET
+`
+
+// Explicit register assignments in a format fixture do not establish a Go
+// native entry contract. These separate ABI0 counterparts retain every body
+// instruction, load their actual declared inputs and publish a typed result.
+func x86Legacy386RegisterCounterparts(t *testing.T, source string, sigs map[string]FuncSig) string {
+	t.Helper()
+	stringsBody := strings.Replace(x86Legacy386OriginalStrings, "$0-0\n", "$0-16\n"+
+		"\tMOVL src+0(FP),SI\n\tMOVL dst+4(FP),DI\n\tMOVL count+8(FP),CX\n\tMOVL value+12(FP),AX\n", 1)
+	mmxBody := strings.Replace(x86Legacy386OriginalMMXLoad, "$0-0\n", "$0-8\n\tMOVL input+0(FP),SI\n", 1)
+	mmxBody = strings.Replace(mmxBody, "\tRET\n", "\tMOVL AX,ret+4(FP)\n\tRET\n", 1)
+	for _, row := range []struct{ before, after string }{
+		{x86Legacy386OriginalStrings, stringsBody}, {x86Legacy386OriginalMMXLoad, mmxBody},
+	} {
+		if strings.Count(source, row.before) != 1 {
+			t.Fatal("complete original register fixture anchor changed")
+		}
+		source = strings.Replace(source, row.before, row.after, 1)
+	}
+	sigs["strings386"] = FuncSig{Name: "strings386", Args: []LLVMType{Ptr, Ptr, I32, I32}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{
+			{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1},
+			{Offset: 8, Type: I32, Index: 2, Field: -1}, {Offset: 12, Type: I32, Index: 3, Field: -1},
+		}}}
+	sigs["mmxload"] = FuncSig{Name: "mmxload", Args: []LLVMType{Ptr}, Ret: I32,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}},
+		}}
+	return source
+}
+
+func TestX86Legacy386RegisterCounterpartsThreeAPIs(t *testing.T) {
+	sigs := make(map[string]FuncSig)
+	source := x86Legacy386RegisterCounterparts(t, x86Legacy386OriginalStrings+x86Legacy386OriginalMMXLoad, sigs)
+	declarations := "func strings386(src,dst *byte,count,value uint32)\nfunc mmxload(input *byte) uint32\n"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, strings.ReplaceAll(source, ",NOSPLIT,", ",4,"))
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+// These separate programs have explicit inputs, initial FLAGS and result
+// slots. Neither supplies native entry FLAGS or physical-SP backing to an
+// original fixture. The original ADJSP and physical-memory forms stay in the
+// complete emitter-only object below, not in these public execution claims.
+const x86Legacy386InitializedStack = `TEXT stackAdjust(SB),4,$156-8
+	PUSHL $2
+	POPFL
+	MOVL value+0(FP),AX
+	MOVL AX,spill-4(SP)
+	STC
+	PUSHFL
+	CLC
+	POPFL
+	SETCS CL
+	MOVBLZX CL,CX
+	SHLL $8,CX
+	MOVL spill-4(SP),AX
+	ANDL $255,AX
+	ORL CX,AX
+	MOVL AX,ret+4(FP)
+	RET
+`
+
+const x86Legacy386InitializedIDProbe = `TEXT cpuidProbe(SB),4,$0-4
+	PUSHL $2
+	POPFL
+	PUSHFL
+	POPL AX
+	MOVL AX,CX
+	XORL $0x200000,AX
+	PUSHL AX
+	POPFL
+	PUSHFL
+	POPL AX
+	PUSHL CX
+	POPFL
+	XORL CX,AX
+	TESTL $0x200000,AX
+	JNE cpuidAvailable
+	MOVL $0,AX
+	JMP cpuidDone
+cpuidAvailable:
+	MOVL $1,AX
+cpuidDone:
+	MOVL AX,ret+0(FP)
+	RET
+`
+
+func x86Legacy386StackCounterparts(t *testing.T, original string) string {
+	t.Helper()
+	for _, row := range []struct{ original, initialized string }{
+		{x86Legacy386OriginalStackAdjust, x86Legacy386InitializedStack},
+		{x86Legacy386OriginalIDProbe, x86Legacy386InitializedIDProbe},
+	} {
+		if strings.Count(original, row.original) != 1 {
+			t.Fatal("complete original stack fixture anchor changed")
+		}
+		original = strings.Replace(original, row.original, row.initialized, 1)
+	}
+	return original
+}
+
+// Preserve the complete ADJSP and ID sources. The former still needs physical
+// storage. The latter's bounded private FLAGS copies cancel the unknown entry
+// ID bit, so its separately checked logical result needs no native SP backing.
+func x86Legacy386StackFormatObject(t *testing.T, triple string) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, x86Legacy386OriginalStackAdjust+x86Legacy386OriginalIDProbe)
+	if err != nil || len(file.Funcs) != 2 {
+		t.Fatal("complete original stack/ID format inventory changed", err)
+	}
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\n", triple)
+	emitAMD64Prelude(&ir, "386", file)
+	for _, fn := range file.Funcs {
+		ret := Void
+		if fn.Sym == "cpuidProbe" {
+			ret = I32
+		}
+		sig := FuncSig{Name: fn.Sym, Ret: ret}
+		fmt.Fprintf(&ir, "define %s %s() {\n", ret, llvmGlobal(fn.Sym))
+		consumer := newX86Ctx(&ir, fn, sig, func(name string) string { return name }, nil, "386", triple, false)
+		if err := consumer.emitEntryAllocas(); err != nil {
+			t.Fatal(err)
+		}
+		if err := consumer.lowerBlocks(); err != nil {
+			t.Fatal("original source format was not emitted completely", fn.Sym, err)
+		}
+		ir.WriteString("}\n")
+	}
+	return ir.String()
+}
+
+func TestX86Legacy386StackFixturesKeepOriginalContextAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			for _, row := range []struct {
+				name, source string
+				ret          LLVMType
+			}{
+				{"stackAdjust", x86Legacy386OriginalStackAdjust, Void},
+				{"cpuidProbe", x86Legacy386OriginalIDProbe, I32},
+			} {
+				x86LEAActualTargetGoObject(t, "386", triple, strings.ReplaceAll(row.source, ",NOSPLIT,", ",4,"))
+				pkg := mustGoPackage(t, "legacy386", "package legacy386")
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, row.source, pkg, "386", triple, api,
+						func(name string) (FuncSig, bool) {
+							return FuncSig{Name: row.name, Ret: row.ret}, name == row.name
+						})
+					if row.name == "cpuidProbe" {
+						if err != nil {
+							t.Fatal("balanced private ID correlation lost its defined logical result", api, err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, text, level)
+							}
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("original physical stack acquired a public entry/backing contract", row.name, api, err)
+					}
+				}
+			}
+			ir := x86Legacy386StackFormatObject(t, triple)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86Legacy386InitializedStackFixturesThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const declarations = "func stackAdjust(value uint32) uint32\nfunc cpuidProbe() uint32\n"
+	const source = x86Legacy386InitializedStack + x86Legacy386InitializedIDProbe
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized stack/ID program lost its complete source proof", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86Legacy386InitializedStackFixturesPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t stackAdjust(uint32_t);
+extern uint32_t cpuidProbe(void);
+int main(void) {
+    const uint32_t values[]={0,1,7,127,128,255,256,65535,0x12345678,UINT32_MAX};
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        uint32_t v=values[i],want=(v&255)|256;
+        uint32_t got=stackAdjust(v),id=cpuidProbe();
+        if(got!=want||id!=1) {
+            fprintf(stderr,"legacy386 case=%u value=%x got=%x want=%x id=%x\n",i,v,got,want,id);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86Legacy386InitializedStack+x86Legacy386InitializedIDProbe,
+				"func stackAdjust(value uint32) uint32\nfunc cpuidProbe() uint32\n", "386", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Contains(ir, "asm ") {
+				t.Fatal("portable numerical stack test acquired native ISA execution")
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "legacy386-stack-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_legacy_abs_sign_alignment_native_linux_amd64_test.go b/x86_legacy_abs_sign_alignment_native_linux_amd64_test.go
new file mode 100644
index 000000000..459f86d7e
--- /dev/null
+++ b/x86_legacy_abs_sign_alignment_native_linux_amd64_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// These required roots execute actual native opcode bytes. Rosetta/QEMU and
+// an object-only or portable mathematical result cannot qualify legacy #GP.
+func TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaultsAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.compiler = append(execution.compiler, "-mssse3")
+	x86LegacyAbsSignNativeAlignment(t, execution, "amd64")
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaults386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required native ABS/sign mode32 tools: LLVM22=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie", "-mssse3"}}
+	x86LegacyAbsSignNativeAlignment(t, execution, "386")
+	x87IA32RequireNativeHost(t)
+}
+
+func x86LegacyAbsSignNativeAlignment(t *testing.T, execution x86FloatCompareExecution, arch string) {
+	t.Helper()
+	if len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("original legacy alignment exceptions require native direct execution")
+	}
+	// A missing instruction-set prerequisite must fail before SIGILL could be
+	// mistaken for an access exception. AVX is a required unaligned control.
+	directory := t.TempDir()
+	preflight, probe := filepath.Join(directory, "isa.c"), filepath.Join(directory, "isa")
+	if err := os.WriteFile(preflight, []byte(`#include <stdio.h>
+int main(void) {
+    __builtin_cpu_init();
+    int ssse3=!!__builtin_cpu_supports("ssse3"),avx=!!__builtin_cpu_supports("avx");
+    printf("ABS/sign actual native SSSE3=%d AVX=%d\n",ssse3,avx);
+    return ssse3&&avx?0:1;
+}
+`), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, preflight, probe)
+	t.Logf("%s", strings.TrimSpace(string(execution.run(t, probe))))
+	source, declarations := x86AbsSignAlignmentProgram(arch, true)
+	x86LEAActualTargetGoObject(t, arch, execution.triple, source)
+	code := x86AbsSignAlignmentOriginalBytes(t, arch)
+	references, kernels := x86AbsSignAlignmentNativeReferences(t, code)
+	driver := x86MemoryFaultSupportC + references + x86LegacyAbsSignAlignmentNativeC +
+		"static const struct abs_sign_case cases[]={\n" + kernels + "};\n" + x86LegacyAbsSignAlignmentNativeMainC
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, "Go")
+	if err != nil || ir == "" {
+		t.Fatal("original initialized native live/dead program rejected", err)
+	}
+	for _, pipeline := range []struct{ name, body, level string }{
+		{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+		{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "abs-sign-original-alignment", pipeline.body, driver, pipeline.level)
+			var ia32 x87IA32Executable
+			if arch == "386" {
+				ia32 = x86NativeOracleIA32Executable(t, execution, executable)
+			}
+			observe := func(row, probe, original int) string {
+				if arch == "386" {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				outcome := x86ObserveMemoryFault(t, execution, executable, row, probe, original)
+				if arch == "386" {
+					if err := ia32.verify(); err != nil {
+						t.Fatal(err)
+					}
+				}
+				return outcome
+			}
+			for index, row := range x86AbsSignAlignmentRows() {
+				for role, name := range []string{"live", "dead"} {
+					t.Run(row.opcode+"/"+name, func(t *testing.T) {
+						for probe := 0; probe < 20; probe++ {
+							returns := probe == 2 || probe == 3 || !row.legacy && probe >= 4 && probe <= 18
+							want := observe(2*index+role, probe, 1)
+							if returns && want != "return" || !returns && want != "segv" && want != "bus" {
+								t.Fatal("original Go opcode violated independent alignment/access matrix", probe, want)
+							}
+							if got := observe(2*index+role, probe, 0); got != want {
+								t.Fatal("translated native alignment/dead fault differs from original Go bytes", probe, got, want)
+							}
+						}
+						t.Log("ABS/sign original Go bytes and LLVM native alignment/access/CF/MXCSR=0x1f80/canary probes 20 failures 0")
+					})
+				}
+			}
+		})
+	}
+}
+
+const x86LegacyAbsSignAlignmentNativeC = `
+typedef void (*abs_sign_call)(uint8_t*,const uint8_t*,const uint8_t*);
+struct abs_sign_case {
+    abs_sign_call translated,original;
+    unsigned lane,sign,legacy,live;
+};
+static uint32_t abs_sign_read(const uint8_t *p,unsigned lane) {
+    uint32_t value=0;
+    for (unsigned i=0;i<lane;i++) value|=(uint32_t)p[i]<<(8*i);
+    return value;
+}
+static void abs_sign_expected(uint8_t *out,const uint8_t *input,const uint8_t *old,
+        struct abs_sign_case k) {
+    uint32_t sign=UINT32_C(1)<<(k.lane*8-1);
+    uint32_t all=k.lane==4?UINT32_MAX:(UINT32_C(1)<<(k.lane*8))-1;
+    for (unsigned at=0;at<16;at+=k.lane) {
+        uint32_t data=abs_sign_read(k.sign?old+at:input+at,k.lane),value;
+        if (k.sign) {
+            uint32_t control=abs_sign_read(input+at,k.lane);
+            value=!control?0:(control&sign)?(UINT32_C(0)-data)&all:data;
+        } else value=(data&sign)?(UINT32_C(0)-data)&all:data;
+        for (unsigned byte=0;byte<k.lane;byte++) out[at+byte]=(uint8_t)(value>>(8*byte));
+    }
+}
+`
+
+const x86LegacyAbsSignAlignmentNativeMainC = `
+int main(int argc,char **argv) {
+    unsigned row,probe,original;
+    char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&row,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 || sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            row>=sizeof(cases)/sizeof(cases[0]) || probe>=20 || original>1) return 80;
+    int setup=memory_fault_setup(0);
+    if (setup) return setup;
+    if ((uintptr_t)guard%16 || page%16) return 81;
+    struct abs_sign_case k=cases[row];
+    const uint8_t *input=probe==0?NULL:probe==1?guard+page-15:
+        probe==2||probe==3?guard+page-16:probe==19?guard+page:guard+probe-3;
+    int returns=probe==2||probe==3||(!k.legacy&&probe>=4&&probe<=18);
+    if (probe>=4 && probe<=18 && (uintptr_t)input%16!=probe-3) return 82;
+    if (probe==3 && mprotect(guard,page,PROT_READ)) return 83;
+    uint8_t old[48],before_old[48],out[48],expected[48];
+    for (unsigned i=0;i<48;i++) old[i]=(uint8_t)(i*31+0x80);
+    memcpy(before_old,old,sizeof(old));
+    memset(out,0xc3,sizeof(out));memset(expected,0xc3,sizeof(expected));
+    if (returns && k.live) abs_sign_expected(expected+1,input,old+1,k);
+    expected[17]=1;
+    /* AMD MisAlignSSE permits an optional MXCSR.MM bit17. Fix the exact
+       Intel/AMD common MM=0 mode, rather than assuming an inherited value
+       or guessing exception behavior from a vendor name or CPUID alone. */
+    uint32_t fixed_mxcsr=UINT32_C(0x1f80),observed_mxcsr=0;
+    __asm__ volatile("ldmxcsr %0" : : "m"(fixed_mxcsr) : "memory");
+    __asm__ volatile("stmxcsr %0" : "=m"(observed_mxcsr) : : "memory");
+    if (observed_mxcsr!=fixed_mxcsr) return 90;
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 84;
+    (original?k.original:k.translated)(out+1,input,old+1);
+    /* Never read an inaccessible source after an unexpected normal return:
+       that would manufacture a C fault and falsely qualify the opcode. */
+    if (!returns) return 85;
+    __asm__ volatile("stmxcsr %0" : "=m"(observed_mxcsr) : : "memory");
+    if (observed_mxcsr!=fixed_mxcsr) return 91;
+    if (memcmp(out,expected,sizeof(out)) || memcmp(old,before_old,sizeof(old))) return 86;
+    for (size_t i=0;i<page;i++) if (guard[i]!=(uint8_t)(i*13+17)) return 87;
+    if (free_guard()) return 88;
+    puts("memory complete");
+    return fflush(stdout)?89:0;
+}
+`
diff --git a/x86_legacy_abs_sign_alignment_test.go b/x86_legacy_abs_sign_alignment_test.go
new file mode 100644
index 000000000..6538392b9
--- /dev/null
+++ b/x86_legacy_abs_sign_alignment_test.go
@@ -0,0 +1,385 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/build"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86AbsSignAlignmentRow struct {
+	opcode       string
+	bits         int
+	sign, legacy bool
+}
+
+// Type4 has different legacy/VEX alignment rules. Do not derive either the
+// opcode directory or that distinction from the implementation's form table.
+func x86AbsSignAlignmentRows() []x86AbsSignAlignmentRow {
+	var rows []x86AbsSignAlignmentRow
+	for _, vector := range []bool{false, true} {
+		for _, sign := range []bool{false, true} {
+			prefix := "PABS"
+			if sign {
+				prefix = "PSIGN"
+			}
+			if vector {
+				prefix = "V" + prefix
+			}
+			for index, width := range []string{"B", "W", "D"} {
+				rows = append(rows, x86AbsSignAlignmentRow{prefix + width, 8 << index, sign, !vector})
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86AbsSignAlignmentRow) instruction() string {
+	if row.sign && !row.legacy {
+		return row.opcode + " (BX),X0,X0"
+	}
+	return row.opcode + " (BX),X0"
+}
+
+func x86AbsSignAlignmentOriginalBytes(t *testing.T, arch string) [][]byte {
+	t.Helper()
+	rows := x86AbsSignAlignmentRows()
+	var source strings.Builder
+	for _, row := range rows {
+		source.WriteString(row.instruction() + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, arch, source.String()+"RET")
+	if len(pcs) != 13 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("incomplete original Go legacy/VEX alignment opcode inventory")
+	}
+	result := make([][]byte, len(rows))
+	for index, row := range rows {
+		opcode := byte(0x1c + index%3)
+		if row.sign {
+			opcode = byte(0x08 + index%3)
+		}
+		want := []byte{0x66, 0x0f, 0x38, opcode, 0x03}
+		if !row.legacy {
+			want = []byte{0xc4, 0xe2, 0x79, opcode, 0x03}
+		}
+		result[index] = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+		if !bytes.Equal(result[index], want) {
+			t.Fatal("actual Go opcode differs from independent Intel ModRM/prefix row", arch, row.opcode, result[index], want)
+		}
+	}
+	return result
+}
+
+func x86AbsSignAlignmentProgram(arch string, vectorControls bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	rows := x86AbsSignAlignmentRows()
+	if !vectorControls {
+		rows = rows[:6]
+	}
+	var source, declarations strings.Builder
+	for index, row := range rows {
+		for _, role := range []string{"live", "dead"} {
+			name := fmt.Sprintf("AbsAlignment%d_%s", index, role)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),BX\n%s old+%d(FP),CX\nMOVOU (CX),X0\nSTC\n%s\n",
+				name, 3*word, move, move, word, move, 2*word, row.instruction())
+			if role == "live" {
+				source.WriteString("MOVOU X0,(DI)\n")
+			}
+			source.WriteString("SETCS 16(DI)\nRET\n")
+			fmt.Fprintf(&declarations, "func %s(out *[32]byte,input,old *[16]byte)\n", name)
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+// Native runtime and host-independent C-object checks consume this same
+// generator. Quote actual assembly newlines once as a C string literal,
+// rather than stacking raw-Go, fmt and C backslash escape conventions.
+func x86AbsSignAlignmentNativeReferences(t *testing.T, code [][]byte) (string, string) {
+	t.Helper()
+	rows := x86AbsSignAlignmentRows()
+	if len(code) != len(rows) {
+		t.Fatal("native original reference lacks the complete independent byte directory")
+	}
+	var references, kernels strings.Builder
+	for index, row := range rows {
+		literal := make([]string, len(code[index]))
+		for at, value := range code[index] {
+			literal[at] = fmt.Sprintf("0x%02x", value)
+		}
+		for _, role := range []string{"live", "dead"} {
+			name := fmt.Sprintf("AbsAlignment%d_%s", index, role)
+			assembly := "movdqu (%1),%%xmm0\n\tstc\n\t.byte " + strings.Join(literal, ",") + "\n\t"
+			live := 0
+			if role == "live" {
+				assembly += "movdqu %%xmm0,(%2)\n\t"
+				live = 1
+			}
+			assembly += "setc 16(%2)"
+			fmt.Fprintf(&references, `extern void %[1]s(uint8_t*,const uint8_t*,const uint8_t*);
+static __attribute__((noinline,used)) void original_%[1]s(uint8_t *out,const uint8_t *input,const uint8_t *old) {
+    __asm__ volatile(%[2]s : : "b"(input),"r"(old),"r"(out) : "xmm0","memory","cc");
+}
+`, name, strconv.Quote(assembly))
+			legacy, sign := 0, 0
+			if row.legacy {
+				legacy = 1
+			}
+			if row.sign {
+				sign = 1
+			}
+			fmt.Fprintf(&kernels, "{%s,original_%s,%d,%d,%d,%d},\n", name, name, row.bits/8, sign, legacy, live)
+		}
+	}
+	return references.String(), kernels.String()
+}
+
+func TestX86LegacyAbsSignAlignmentIndependentOriginalBytes(t *testing.T) {
+	x86PackedAbsSignOriginalProgramUnchanged(t)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) { x86AbsSignAlignmentOriginalBytes(t, arch) })
+	}
+}
+
+func TestX86LegacyAbsSignAlignmentOriginalCWrappersCompile(t *testing.T) {
+	clang, objdump := findLLVM22Tool("clang"), findLLVM22Tool("llvm-objdump")
+	if clang == "" || objdump == "" {
+		t.Fatal("actual native original wrappers require exact LLVM22 clang and llvm-objdump")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			references, _ := x86AbsSignAlignmentNativeReferences(t, x86AbsSignAlignmentOriginalBytes(t, target.arch))
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					directory := t.TempDir()
+					source, object := filepath.Join(directory, "original.c"), filepath.Join(directory, "original.o")
+					if err := os.WriteFile(source, []byte("typedef unsigned char uint8_t;\n"+references), 0600); err != nil {
+						t.Fatal(err)
+					}
+					// Object-only, freestanding C: no host headers, SDK, libc or
+					// link fallback can hide a wrong 386/AMD64 register constraint.
+					stage, cancel := runtimeOracleStageContext(t)
+					output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, clang, "--no-default-config",
+						"-target", target.triple, "-nostdinc", "-ffreestanding", "-mssse3", level, "-c", source, "-o", object))
+					cancel()
+					if err != nil {
+						t.Fatalf("actual original native C wrappers failed compilation: %v\n%s", err, output)
+					}
+					stage, cancel = runtimeOracleStageContext(t)
+					listing, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, objdump, "-d", object))
+					cancel()
+					if err != nil {
+						t.Fatalf("actual original native C objects failed independent disassembly: %v\n%s", err, listing)
+					}
+					pattern := `(?m)^[0-9a-f]+ <_?original_AbsAlignment[0-9]+_(?:live|dead)>:\r?\n`
+					if got := len(regexp.MustCompile(pattern).FindAll(listing, -1)); got != 24 {
+						t.Fatal("actual C object lost an original live/dead opcode wrapper", got)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86LegacyAbsSignAlignmentNeedsActualNativeBackingAndTarget(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86AbsSignAlignmentRows()[:6] {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.opcode+"/"+api, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-16\nPXOR X0,X0\n" + row.opcode + " a+0(FP),X0\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(a,b uint64)", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("logical FP bytes acquired original native m128 alignment and backing", err)
+					}
+				})
+			}
+		}
+	}
+	for _, triple := range []string{"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown"} {
+		t.Run(triple, func(t *testing.T) {
+			source, declarations := x86AbsSignAlignmentProgram("amd64", false)
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a nonmatching target silently erased original x86 alignment/fault behavior", err)
+			}
+		})
+	}
+}
+
+func TestX86LegacyAbsSignAlignmentRequiredNativeOwners(t *testing.T) {
+	const name = "x86_legacy_abs_sign_alignment_native_linux_amd64_test.go"
+	for _, target := range []struct{ os, arch string }{
+		{"linux", "amd64"}, {"linux", "386"}, {"linux", "arm64"},
+		{"darwin", "amd64"}, {"darwin", "arm64"}, {"windows", "amd64"},
+	} {
+		context := build.Default
+		context.GOOS, context.GOARCH = target.os, target.arch
+		selected, err := context.MatchFile(".", name)
+		if err != nil || selected != (target.os == "linux" && target.arch == "amd64") {
+			t.Fatal("required actual-native fault owner selected on the wrong host", target, selected, err)
+		}
+	}
+	syntax, err := parser.ParseFile(token.NewFileSet(), name, nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wanted := map[string]bool{
+		"TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaultsAMD64": false,
+		"TestCrossLinuxRuntimeMatrixX86LegacyAbsSignOriginalAlignmentFaults386":   false,
+	}
+	for _, declaration := range syntax.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		ast.Inspect(function, func(node ast.Node) bool {
+			if selector, ok := node.(*ast.SelectorExpr); ok && strings.HasPrefix(selector.Sel.Name, "Skip") {
+				t.Fatal("required native ABS/sign execution became an optional skip", function.Name.Name)
+			}
+			return true
+		})
+		if _, found := wanted[function.Name.Name]; !found {
+			continue
+		}
+		host, full := 0, 0
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if call, ok := node.(*ast.CallExpr); ok {
+				if callee, ok := call.Fun.(*ast.Ident); ok {
+					if callee.Name == "x87IA32RequireNativeHost" {
+						host++
+					}
+					if callee.Name == "x86LegacyAbsSignNativeAlignment" {
+						full++
+					}
+				}
+			}
+			return true
+		})
+		if host != 2 || full != 1 || wanted[function.Name.Name] {
+			t.Fatal("required native owner lost host brackets or its entire fault matrix", function.Name.Name, host, full)
+		}
+		wanted[function.Name.Name] = true
+	}
+	for root, found := range wanted {
+		if !found {
+			t.Fatal("required native owner is absent", root)
+		}
+	}
+}
+
+func TestX86LegacyAbsSignAlignmentNativeOracleFixesAndObservesMXCSRMode(t *testing.T) {
+	syntax, err := parser.ParseFile(token.NewFileSet(), "x86_legacy_abs_sign_alignment_native_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source := ""
+	ast.Inspect(syntax, func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || declaration.Names[0].Name != "x86LegacyAbsSignAlignmentNativeMainC" {
+			return true
+		}
+		if len(declaration.Values) != 1 || source != "" {
+			t.Fatal("native MXCSR driver source ownership changed")
+		}
+		literal, ok := declaration.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			t.Fatal("native MXCSR driver is not the actual compiled C source")
+		}
+		source, err = strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return false
+	})
+	load, read := strings.Index(source, "ldmxcsr"), strings.Index(source, "stmxcsr")
+	witness, call := strings.Index(source, `printf("memory enter`), strings.Index(source, "(original?k.original:k.translated)")
+	if !strings.Contains(source, "fixed_mxcsr=UINT32_C(0x1f80)") || load < 0 || read <= load || witness <= read || call <= witness ||
+		strings.Count(source, "stmxcsr") != 2 || strings.LastIndex(source, "stmxcsr") <= call ||
+		strings.Count(source, "observed_mxcsr!=fixed_mxcsr") != 2 {
+		t.Fatal("oracle must fix and observe MM=0 before the exact entry witness and check successful-return MXCSR preservation")
+	}
+}
+
+// Real LLVM22 machine objects, not IR spelling or align16 metadata, must
+// retain each legacy m128 opcode in both live and dead-result functions.
+// Original-process signal behavior is a separate required native owner.
+func TestX86LegacyAbsSignAlignmentActualNativeObjects(t *testing.T) {
+	llc, disassembler := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || disassembler == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required for original native alignment objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86AbsSignAlignmentProgram(target.arch, false)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original legacy source rejected before object examination", err)
+					}
+					for _, pipeline := range []struct{ name, body, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							directory := t.TempDir()
+							input, object := filepath.Join(directory, "alignment.ll"), filepath.Join(directory, "alignment.o")
+							if err := os.WriteFile(input, []byte(pipeline.body), 0600); err != nil {
+								t.Fatal(err)
+							}
+							stage, cancel := runtimeOracleStageContext(t)
+							output, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, llc,
+								pipeline.level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", object))
+							cancel()
+							if err != nil {
+								t.Fatalf("actual native alignment object: %v\n%s", err, output)
+							}
+							stage, cancel = runtimeOracleStageContext(t)
+							listing, err := runtimeOracleCombinedOutput(stage, exec.CommandContext(stage, disassembler, "-d", object))
+							cancel()
+							if err != nil {
+								t.Fatalf("independent LLVM22 disassembly: %v\n%s", err, listing)
+							}
+							sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?(AbsAlignment[0-9]+_(?:live|dead))>:\r?\n`).FindAllSubmatchIndex(listing, -1)
+							if len(sections) != 12 {
+								t.Fatal("actual object lost a complete live/dead original function", len(sections))
+							}
+							for index, section := range sections {
+								name := string(listing[section[2]:section[3]])
+								end := len(listing)
+								if index+1 < len(sections) {
+									end = sections[index+1][0]
+								}
+								body := listing[section[1]:end]
+								t.Run(name, func(t *testing.T) {
+									var row int
+									if _, err := fmt.Sscanf(name, "AbsAlignment%d_", &row); err != nil || row < 0 || row >= 6 {
+										t.Fatal("unexpected physical object function", name, err)
+									}
+									pattern := `(?m)\b` + strings.ToLower(x86AbsSignAlignmentRows()[row].opcode) + `[ \t]+[^\r\n]*\([^\r\n]+\),[ \t]*%xmm[0-9]+`
+									if count := len(regexp.MustCompile(pattern).FindAll(body, -1)); count != 1 {
+										t.Fatalf("original faulting m128 opcode not retained exactly once: %d\n%s", count, body)
+									}
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_legacy_alternating_round_initialized_test.go b/x86_legacy_alternating_round_initialized_test.go
new file mode 100644
index 000000000..7f0c407dc
--- /dev/null
+++ b/x86_legacy_alternating_round_initialized_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Public initialized legacy objects, independently of bare private format
+// units. Every function observes all 64 destination-alias bytes. The four FP
+// variants consume declared numeric parameters, never native pointer reads.
+func TestX86LegacyAlternatingRoundInitializedPublicFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move := "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			appendFunction := func(name, declaration, body string) {
+				// Reuse actual Go ABI0 derivation, including the target's FP
+				// parameter offsets and TEXT extent; do not guess a layout.
+				_, _, function := x86ScalarFPVoidSource(t, declaration, body, target.arch)
+				source.WriteString(strings.Replace(function, "·view(SB)", "·"+name+"(SB)", 1))
+				declarations.WriteString(strings.Replace(declaration, "func view(", "func "+name+"(", 1) + "\n")
+			}
+			const registerDeclaration = "func view(out *[64]byte)"
+			_, registerSignature, _ := x86ScalarFPVoidSource(t, registerDeclaration, "", target.arch)
+			if len(registerSignature.Frame.Params) != 1 {
+				t.Fatal("actual output signature changed")
+			}
+			for index, op := range []string{"ADDSUBPS", "ADDSUBPD", "ROUNDPS", "ROUNDPD", "ROUNDSS", "ROUNDSD"} {
+				instruction := op + " X0,X1"
+				if strings.HasPrefix(op, "ROUND") {
+					instruction = op + " $0,X0,X1"
+				}
+				body := fmt.Sprintf("%s out+%d(FP),AX\nVPXOR Y0,Y0,Y0\nVPXOR Y1,Y1,Y1\n%s\nVMOVUPS Z1,(AX)", move, registerSignature.Frame.Params[0].Offset, instruction)
+				appendFunction(fmt.Sprint("InitializedLegacyRoundRegister", index), registerDeclaration, body)
+			}
+			for _, row := range []struct{ op, typ, scalarMove string }{
+				{"ROUNDSS", "float32", "MOVSS"}, {"ROUNDSD", "float64", "MOVSD"},
+			} {
+				declaration := "func view(out *[64]byte,x " + row.typ + ")"
+				_, signature, _ := x86ScalarFPVoidSource(t, declaration, "", target.arch)
+				if len(signature.Frame.Params) != 2 {
+					t.Fatal("actual scalar parameter signature changed")
+				}
+				for index, viaRegister := range []bool{false, true} {
+					input := fmt.Sprintf("x+%d(FP)", signature.Frame.Params[1].Offset)
+					body := fmt.Sprintf("%s out+%d(FP),AX\nVPXOR Y0,Y0,Y0\nVPXOR Y1,Y1,Y1\n", move, signature.Frame.Params[0].Offset)
+					if viaRegister {
+						body += row.scalarMove + " " + input + ",X0\n"
+						input = "X0"
+					}
+					body += row.op + " $0," + input + ",X1\nVMOVUPS Z1,(AX)"
+					appendFunction(fmt.Sprintf("InitializedLegacy%sFP%d", row.op, index), declaration, body)
+				}
+			}
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil || len(file.Funcs) != 10 {
+				t.Fatal("six register plus four numeric-FP counterparts changed", err)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized legacy register/numeric-FP source rejected", api, err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_legacy_alternating_round_memory_test.go b/x86_legacy_alternating_round_memory_test.go
new file mode 100644
index 000000000..959d7e313
--- /dev/null
+++ b/x86_legacy_alternating_round_memory_test.go
@@ -0,0 +1,248 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86LegacyAlternatingRoundMemoryCase struct {
+	op, instruction string
+	scalar          bool
+	bytes           []byte
+}
+
+func x86LegacyAlternatingRoundMemoryCases() []x86LegacyAlternatingRoundMemoryCase {
+	return []x86LegacyAlternatingRoundMemoryCase{
+		{"ADDSUBPS", "ADDSUBPS (BX),X1", false, []byte{0xf2, 0x0f, 0xd0, 0x0b}},
+		{"ADDSUBPD", "ADDSUBPD (BX),X1", false, []byte{0x66, 0x0f, 0xd0, 0x0b}},
+		{"ROUNDPS", "ROUNDPS $9,(BX),X1", false, []byte{0x66, 0x0f, 0x3a, 0x08, 0x0b, 9}},
+		{"ROUNDPD", "ROUNDPD $9,(BX),X1", false, []byte{0x66, 0x0f, 0x3a, 0x09, 0x0b, 9}},
+		{"ROUNDSS", "ROUNDSS $9,(BX),X1", true, []byte{0x66, 0x0f, 0x3a, 0x0a, 0x0b, 9}},
+		{"ROUNDSD", "ROUNDSD $9,(BX),X1", true, []byte{0x66, 0x0f, 0x3a, 0x0b, 0x0b, 9}},
+	}
+}
+
+// Manual opaque Ptr fields deliberately carry no array/pointee extent. The
+// same explicit ABI0 layout is supplied to all three public APIs.
+func x86LegacyAlternatingRoundMemoryAPI(t *testing.T, source, declarations, arch, triple, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declarations)
+	word := int64(goWordSize(arch))
+	manualCalls := 0
+	manual := func(name string) (FuncSig, bool) {
+		manualCalls++
+		return FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: word, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 2 * word, Type: Ptr, Index: 2, Field: -1},
+			}}}, true
+	}
+	ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, arch, triple, api, manual)
+	if manualCalls == 0 {
+		t.Fatal("opaque-pointer fixture did not consume its explicit manual ABI0 signature")
+	}
+	return ir, err
+}
+
+func x86LegacyAlternatingRoundMemoryAssembly(arch, name string, row x86LegacyAlternatingRoundMemoryCase, wide bool, change string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	base := fmt.Sprintf("%s input+%d(FP),BX\n", move, word)
+	if change == "missing-base" {
+		base = ""
+	} else if change == "numeric-base" {
+		base = move + " $1,BX\n"
+	}
+	bank := "X"
+	if wide {
+		bank = "Z"
+	}
+	seed := "VMOVUPS (CX)," + bank + "1\n"
+	if change == "missing-old" {
+		seed = ""
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),AX\n%s%s old+%d(FP),CX\n%s%s\nVMOVUPS %s1,(AX)\nRET\n",
+		name, 3*word, move, base, move, 2*word, seed, row.instruction, bank)
+	return source, "func " + name + "(out,input,old *byte)\n"
+}
+
+func TestX86LegacyAlternatingMemoryNativeFeature(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"ADDSUBPS", "ADDSUBPD"} {
+			for _, source := range []string{"(BX)", "input+0(FP)", "X0"} {
+				ins := x86ScalarLaneInstruction(t, op+" "+source+",X1")
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}})
+				if strings.Contains(features, "+sse3") != (source == "(BX)") {
+					t.Fatal("only the original native memory opcode requires SSE3", arch, ins, features)
+				}
+			}
+		}
+	}
+}
+
+func TestX86LegacyAlternatingRoundMemoryActualGoBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LegacyAlternatingRoundMemoryCases() {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				got := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+				want := append(append([]byte(nil), row.bytes...), 0xc3)
+				if !bytes.Equal(got, want) {
+					t.Fatalf("original legacy memory opcode/control changed: got=%x want=%x", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyAlternatingRoundMemoryRejectsForeignBackendBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+			for _, row := range x86LegacyAlternatingRoundMemoryCases() {
+				t.Run(arch+"/"+row.op+"/"+triple, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction)
+					ctx, body := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch, ctx.targetTriple = arch, triple
+					before := body.String()
+					var known, terminated bool
+					var err error
+					if strings.HasPrefix(row.op, "ADDSUB") {
+						known, terminated, err = ctx.lowerAlternatingFloatingAddSubtract(ins.Op, ins)
+					} else {
+						known, terminated, err = ctx.lowerRound(ins.Op, ins)
+					}
+					if !known || terminated || !errors.Is(err, ErrProbeNeedsContext) || body.String() != before {
+						t.Fatal("foreign/default legacy memory backend emitted partial IR or acquired native permission", err)
+					}
+				})
+			}
+			// A fully initialized public control avoids an earlier missing-input
+			// rejection being misreported as native backend enforcement.
+			row := x86LegacyAlternatingRoundMemoryCases()[2]
+			source, declaration := x86LegacyAlternatingRoundMemoryAssembly(arch, "LegacyMemoryForeign", row, false, "complete")
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/public/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86LegacyAlternatingRoundMemoryAPI(t, source, declaration, arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("foreign/default public target acquired a native legacy memory function", api, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// These matching-x86 objects are not portable/native runtime acceptance.
+// Observe all64 aliases while keeping the tested source as an opaque Ptr.
+func TestX86LegacyAlternatingRoundOpaquePointerMemoryObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, row := range x86LegacyAlternatingRoundMemoryCases() {
+				one, declaration := x86LegacyAlternatingRoundMemoryAssembly(target.arch, "LegacyMemory"+row.op, row, true, "complete")
+				source.WriteString(one)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86LegacyAlternatingRoundMemoryAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete opaque-pointer legacy source rejected", err)
+					}
+					for _, row := range x86LegacyAlternatingRoundMemoryCases() {
+						if !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(row.op)+" ") {
+							t.Fatal("legacy memory operation lost its original observable instruction", row.op)
+						}
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86LegacyAlternatingRoundMemoryRequiresActualInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86LegacyAlternatingRoundMemoryCases() {
+			changes := []string{"complete", "missing-base", "numeric-base"}
+			if row.scalar || strings.HasPrefix(row.op, "ADDSUB") {
+				changes = append(changes, "missing-old")
+			}
+			for _, change := range changes {
+				t.Run(arch+"/"+row.op+"/"+change, func(t *testing.T) {
+					source, declaration := x86LegacyAlternatingRoundMemoryAssembly(arch, "LegacyMemoryInputs", row, false, change)
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					if change == "numeric-base" {
+						x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86LegacyAlternatingRoundMemoryAPI(t, source, declaration, arch, triple, api)
+						if change == "numeric-base" {
+							if err != nil || !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(row.op)+" ") ||
+								!strings.Contains(ir, "~{memory}") || !strings.Contains(ir, "~{fpsr}") {
+								t.Fatal("complete NUM address lost its original legacy memory/FP effect", api, err)
+							}
+							x86NumericNativeAddressObject(t, ir, triple)
+						} else if change == "complete" {
+							if err != nil || ir == "" {
+								t.Fatal("complete manual Ptr inputs rejected", api, err)
+							}
+						} else if arch == "amd64" && change == "missing-old" {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("missing address/old input borrowed implementation bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyRoundNativeMemoryOnlyNeedsCopiedOldUpper(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, bits := range []int{32, 64} {
+			op := "ROUNDSS"
+			if bits == 64 {
+				op = "ROUNDSD"
+			}
+			ins := x86ScalarLaneInstruction(t, op+" $9,(BX),X1")
+			low := x86CallerVectorByteMask(int64(bits / 8))
+			before := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+			base, _, _ := x86ResultGP(BX, int64(goWordSize(arch)), arch)
+			before.pointerGP[base] = true
+			before.writeVector(1, 64, ^low, false) // Old active bytes are deliberately unknown.
+			for _, native := range []bool{false, true} {
+				state := before.clone()
+				accepted, known := x86ResultRoundStep(ins, &state, nil, arch, native)
+				if !known || accepted != native {
+					t.Fatal("paired legacy scalar read required overwritten old low bytes", arch, op, native, accepted)
+				}
+				want := before.clone()
+				if native {
+					want.writeVector(1, 16, 0xffff, true)
+				}
+				if !reflect.DeepEqual(state, want) {
+					t.Fatal("legacy scalar read changed upper aliases, pointer or FLAGS", arch, op, native)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_legacy_integer_minmax_source_test.go b/x86_legacy_integer_minmax_source_test.go
new file mode 100644
index 000000000..6ddb60bd4
--- /dev/null
+++ b/x86_legacy_integer_minmax_source_test.go
@@ -0,0 +1,340 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent Go legacy directory: yxm/Pe has four SSE2 members; yxm_q4/Pq4
+// has eight SSE4.1 members. Neither table admits MMX or a legacy qword name.
+var x86LegacyIntegerMinMaxMembers = []struct {
+	op     string
+	bits   int
+	map38  bool
+	opcode byte
+}{
+	{"PMINUB", 8, false, 0xda}, {"PMAXUB", 8, false, 0xde},
+	{"PMINSW", 16, false, 0xea}, {"PMAXSW", 16, false, 0xee},
+	{"PMINSB", 8, true, 0x38}, {"PMAXSB", 8, true, 0x3c},
+	{"PMINUW", 16, true, 0x3a}, {"PMAXUW", 16, true, 0x3e},
+	{"PMINSD", 32, true, 0x39}, {"PMAXSD", 32, true, 0x3d},
+	{"PMINUD", 32, true, 0x3b}, {"PMAXUD", 32, true, 0x3f},
+}
+
+func TestX86LegacyIntegerMinMaxCompleteOfficialRowsAndBytes(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pattern := regexp.MustCompile(`\{A(P(?:MIN|MAX)[SU][BWD]), (\w+), (\w+), opBytes\{([^}]+)\}\}`)
+	rows := pattern.FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 12 {
+		t.Fatal("complete legacy integer min/max official denominator changed", len(rows))
+	}
+	for _, table := range []struct{ name, definition string }{
+		{"yxm", "{Zm_r_xm,1,argList{Yxm,Yxr}},"},
+		{"yxm_q4", "{Zm_r,1,argList{Yxm,Yxr}},"},
+	} {
+		definition := regexp.MustCompile(`(?s)var ` + table.name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(data))
+		if len(definition) != 2 || strings.Join(strings.Fields(definition[1]), "") != table.definition {
+			t.Fatal("original Go X-only table changed", table.name)
+		}
+	}
+	for _, member := range x86LegacyIntegerMinMaxMembers {
+		found := 0
+		for _, row := range rows {
+			if row[1] != member.op {
+				continue
+			}
+			table, prefix := "yxm", "Pe"
+			if member.map38 {
+				table, prefix = "yxm_q4", "Pq4"
+			}
+			if row[2] != table || row[3] != prefix || strings.TrimSpace(row[4]) != fmt.Sprintf("0x%02x", member.opcode) {
+				t.Fatal("original opcode/table/prefix changed", row)
+			}
+			found++
+		}
+		if found != 1 {
+			t.Fatal("missing or duplicate original member", member.op, found)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+member.op, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					operand, modrm := "X1", byte(0xc1)
+					if memory {
+						operand, modrm = "(AX)", 0
+					}
+					code, pcs := x86NumericalBoundaryGoBytes(t, arch, member.op+" "+operand+",X0\nRET")
+					want := []byte{0x66, 0x0f}
+					if member.map38 {
+						want = append(want, 0x38)
+					}
+					want = append(want, member.opcode, modrm, 0xc3)
+					if !reflect.DeepEqual(code, want) || len(pcs) != 2 || pcs[1] != int64(len(want)-1) {
+						t.Fatal("complete actual Go opcode/register/m128 boundary changed", code, want, pcs)
+					}
+					mode := 64
+					if arch == "386" {
+						mode = 32
+					}
+					x86NumericalNativeRequireMC(t, code, mode, 2, "+sse2,+sse4.1")
+				}
+				goAssemblerOracleOutput(t, arch, "TEXT Invalid(SB),4,$0-0\n"+member.op+" M0,M1\nRET\n", "", false)
+			})
+		}
+	}
+}
+
+func TestX86LegacyIntegerMinMaxOriginalExpandedConformanceObjects(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	start := strings.Index(string(data), "TEXT ·expandedEcosystemVectors(SB)")
+	if start < 0 {
+		t.Fatal("complete original expanded conformance entry missing")
+	}
+	end := strings.Index(string(data[start:]), "\n\tRET\n")
+	if end < 0 {
+		t.Fatal("complete original expanded conformance return missing")
+	}
+	body := string(data[start : start+end+len("\n\tRET\n")])
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(body))) != "97161386bd3a63d52dbd3a40aa758b4165e9b98f023eecac1449d594900750e3" {
+		t.Fatal("original complete 174-line ASM program changed")
+	}
+	data, err = os.ReadFile("amd64_conformance_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	reference, err := x86SegmentMOVSourceFunction(data, "amd64ConformanceRuntimeC")
+	if err != nil || fmt.Sprintf("%x", sha256.Sum256(reference)) != "41b0fc284d1aea9a9d24d613f84a6f4ad416d25a84dfa9664f81c7f1a9eef1b4" {
+		t.Fatal("original complete C/reference observations changed", err)
+	}
+	x86PackedFaultProgramObjects(t, "#include \"textflag.h\"\n"+body,
+		"func expandedEcosystemVectors(out *[816]byte,a,b *[16]byte)")
+}
+
+func TestX86LegacyIntegerMinMaxEveryByteAliasAndFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var original strings.Builder
+		for _, member := range x86LegacyIntegerMinMaxMembers {
+			fmt.Fprintf(&original, "TEXT Prior%s(SB),4,$0-0\n%s X1,X0\n%s X0,X0\nRET\n", member.op, member.op, member.op)
+		}
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		for _, member := range x86LegacyIntegerMinMaxMembers {
+			for _, source := range []int{0, 1} {
+				row := fmt.Sprintf("%s X%d,X0", member.op, source)
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					instruction := x86ScalarLaneInstruction(t, row)
+					effect, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, arch)
+					if !known || err != nil || !effect.requiresResultProof || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 || len(effect.operands) != 2 {
+						t.Fatal("complete legacy family lacks its two-input RMW/FLAGS owner", known, err)
+					}
+					for index, operand := range effect.operands {
+						if operand.index != index || operand.width != 16 || !operand.read || operand.write != (index == 1) ||
+							!reflect.DeepEqual(operand.operand, instruction.Args[index]) {
+							t.Fatal("legacy byte effect lost its source or RMW destination", operand)
+						}
+					}
+					for input := 0; input < 3; input++ {
+						for missing := -1; missing < 64; missing++ {
+							state := x86FMA3ResultInputState()
+							if missing >= 0 {
+								state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+							}
+							before := state.clone()
+							known := uint64(0xffff)
+							if missing >= 0 && missing < 16 && (input == 0 || input == source) {
+								lane := member.bits / 8
+								known &^= x86CallerVectorByteMask(int64(lane)) << uint(missing/lane*lane)
+							}
+							want := before.clone()
+							want.writeVector(0, 16, known, true)
+							if !x86ResultTransfer(instruction, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+								t.Fatal("min/max invented an input lane or changed upper aliases/GP/FLAGS/DF", input, missing)
+							}
+							if arch == "amd64" {
+								caller := x86SourceStackState{numericFlags: true,
+									bp: x86SourceStackAddress{original: true}, gOriginal: true,
+									known: map[Reg]uint8{AX: 0xff}, callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}},
+									vectors: map[Reg]uint64{"Z0": before.vectorBytes(0), "Z1": before.vectorBytes(1), "Z2": before.vectorBytes(2)},
+									masks:   map[Reg]bool{"K1": true},
+								}
+								wantCaller := x86CloneCallerState(caller)
+								wantCaller.vectors["Z0"] = want.vectorBytes(0)
+								local := instruction
+								if !x86CallerVectorMoveStep(&local, &caller, nil) || !reflect.DeepEqual(caller, wantCaller) {
+									t.Fatal("caller and result lane dependencies disagree", input, missing)
+								}
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyIntegerMinMaxInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete legacy min/max objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, member := range x86LegacyIntegerMinMaxMembers {
+				for _, memory := range []bool{false, true} {
+					first := "X1"
+					if memory {
+						first = "(AX)"
+					}
+					name := fmt.Sprint("LegacyMinMax", count)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s a+%d(FP),AX\n%s b+%d(FP),BX\n"+
+						"VMOVUPS (DI),Z0\nMOVOU (AX),X1\nMOVOU (BX),X0\nMOVL $5,DX\nCMPL DX,$3\nSTD\n"+
+						"%s %s,X0\nVMOVUPS Z0,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nCLD\nRET\n",
+						name, 3*word, move, move, word, move, 2*word, member.op, first)
+					fmt.Fprintf(&declarations, "func %s(out,a,b *byte)\n", name)
+					count++
+				}
+			}
+			if count != 24 {
+				t.Fatal("orthogonal twelve-member register/memory denominator changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized legacy min/max program lost its public owner", err)
+					}
+					for _, pipeline := range []struct{ text, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.text, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86LegacyIntegerMinMaxDeadNativeInputsAndOriginalAccess(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := goWordSize(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		triple := testTargetTriple("linux", arch)
+		for _, member := range x86LegacyIntegerMinMaxMembers {
+			source := fmt.Sprintf("TEXT ·Read(SB),4,$0-%d\n%s input+0(FP),AX\nPXOR X0,X0\n%s (AX),X0\nRET\n", word, move, member.op)
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+member.op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Read(input *byte)", arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized legacy min/max lost its paired dead access", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						body := x86StringMemoryFunction(t, text, "Read")
+						if strings.Count(body, "asm sideeffect \""+strings.ToLower(member.op)+" ($2), $0\"") != 1 ||
+							!strings.Contains(body, "\"=x,0,r,~{memory}\"") || strings.Contains(body, "load volatile <16 x i8>") {
+							t.Fatal("dead m128 lost its one original RMW Type4/alignment access", member.op)
+						}
+					}
+					for _, mutation := range []struct{ name, before, after string }{
+						{"pointer", move + " input+0(FP),AX\n", ""},
+						{"numeric-address", move + " input+0(FP),AX\n", move + " $1,AX\n"},
+						{"partial-address", move + " input+0(FP),AX\n", "MOVB $1,AL\n"},
+						{"old-destination", "PXOR X0,X0\n", ""},
+						{"index", "(AX),X0", "(AX)(CX*2),X0"},
+					} {
+						changed := strings.Replace(source, mutation.before, mutation.after, 1)
+						if changed == source {
+							t.Fatal("missing-input control was not applied", mutation.name)
+						}
+						output, err := x86ScalarFPBitViewAPI(t, changed, "func Read(input *byte)", arch, triple, api)
+						if mutation.name == "numeric-address" {
+							if err != nil || !strings.Contains(output, "asm sideeffect \""+strings.ToLower(member.op)+" ($2), $0\"") {
+								t.Fatal("numerical address lost its original native access", err)
+							}
+							x86RequireNumericNativeSourceContext(t, changed, "func Read(input *byte)", arch)
+							x86NumericNativeAddressObject(t, output, triple)
+							continue
+						}
+						if arch == "amd64" && mutation.name == "old-destination" {
+							x86VectorScratchCodegenControl(t, changed, "func Read(input *byte)", arch, triple, output, err)
+						} else if output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead native min/max invented an old input/address", mutation.name, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyIntegerMinMaxWholeSourceRawRestrictions(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86LegacyIntegerMinMaxMembers {
+			t.Run(arch+"/"+member.op, func(t *testing.T) {
+				operation := member.op + " X1,X0"
+				code, pcs := x86NumericalBoundaryGoBytes(t, arch, operation+"\nRET")
+				if len(pcs) != 2 || pcs[1] != int64(len(code)-1) || code[len(code)-1] != 0xc3 {
+					t.Fatal("complete independent original Go boundary missing", pcs)
+				}
+				prefix := "TEXT ·Value(SB),4,$0-4\nPXOR X0,X0\nPXOR X1,X1\n"
+				suffix := "MOVL X0,ret+0(FP)\nRET\n"
+				namedSource := prefix + operation + "\n" + suffix
+				strict, check := x86RegisterReplayConsumers(t, arch, namedSource)
+				named := mustParseX86RawReturn(t, namedSource).Funcs[0]
+				if strict(named) != nil || check(named) != nil {
+					t.Fatal("genuine initialized named source failed before the raw boundary under review")
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t,
+					prefix+x86RawDisplacementDirectives(code[:pcs[1]])+suffix), arch)
+				if err != nil {
+					t.Fatal("complete actual Go bytes could not normalize", err)
+				}
+				original, ordinal := file.Funcs[0], -1
+				for index, ins := range original.Instrs {
+					if ins.Op == Op(member.op) && ins.x86SourceRaw != nil {
+						if ordinal >= 0 || ins.x86Encoded {
+							t.Fatal("origin-only fixture lost its exact legacy producer")
+						}
+						ordinal = index
+					}
+				}
+				if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("whole original source lost its sealed raw replay")
+				}
+				if err := check(original); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("legacy raw instruction borrowed a named numerical role", err)
+				}
+				changed := original
+				changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+				changed.Instrs[ordinal].x86SourceRaw = nil
+				if !errors.Is(changed.x86RawReplay.validate(changed, arch), ErrProbeNeedsContext) || original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("origin-only mutation lost the independent immutable source restriction")
+				}
+				if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("erased raw origin bypassed the actual whole-source consumer", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_legacy_mmx_original_runtime_test.go b/x86_legacy_mmx_original_runtime_test.go
new file mode 100644
index 000000000..a058d304a
--- /dev/null
+++ b/x86_legacy_mmx_original_runtime_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86LegacyMMXActualRuntimeLiterals(t *testing.T) (string, string) {
+	t.Helper()
+	const filename = "amd64_lower_legacy_mmx_test.go"
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), filename, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	literals := make(map[string]string)
+	owners := 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestAMD64LegacyMMXRuntimeSemantics" {
+			continue
+		}
+		owners++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+				return true
+			}
+			name := value.Names[0].Name
+			if name != "source" && name != "mainC" {
+				return true
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING || literals[name] != "" {
+				t.Fatal("original MMX runtime lost its actual unique literal", name)
+			}
+			literals[name], err = strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			return true
+		})
+	}
+	if owners != 1 || literals["source"] == "" || literals["mainC"] == "" {
+		t.Fatal("missing or duplicate complete original MMX runtime owner")
+	}
+	return literals["source"], literals["mainC"]
+}
+
+func TestX86LegacyMMXOriginalRuntimeHasClosedPhysicalRegion(t *testing.T) {
+	source, reference := x86LegacyMMXActualRuntimeLiterals(t)
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(reference))); got != "486d3a793dca517202c6b20d6ea6a0d0e6b040d3b08a185f74a9a82fdcecba28" {
+		t.Fatal("original complete MMX C reference changed", got)
+	}
+	// The only permitted fixture correction moves this independent incoming
+	// address before MMX and closes MMX with EMMS. Reconstruct the old source
+	// to bind every other byte, not a smaller substitute numerical program.
+	const outSeed = "\tMOVQ out+8(FP), DI\n"
+	const begin = "\tMOVQ AX, M1\n"
+	if strings.Count(source, outSeed) != 1 || strings.Count(source, begin) != 1 || strings.Count(source, "\tEMMS\n") > 1 {
+		t.Fatal("original MMX source changed an input or physical boundary")
+	}
+	original := strings.Replace(source, "\tEMMS\n", "", 1)
+	original = strings.Replace(original, outSeed, "", 1)
+	original = strings.Replace(original, begin, begin+outSeed, 1)
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(original))); got != "7783cda56681fb4d7b2eb5906ada0906dc29ac06609eff12b228b7824e8bc911" {
+		t.Fatal("MMX fixture changed more than the independent seed/EMMS repair", got)
+	}
+	var instructions, effects []string
+	for _, line := range strings.Split(source, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "TEXT ") || line == "RET" {
+			continue
+		}
+		instructions = append(instructions, line)
+		if !strings.HasPrefix(line, "MOVQ value+") && !strings.HasPrefix(line, "MOVQ out+") && line != "EMMS" {
+			effects = append(effects, line)
+		}
+	}
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(strings.Join(effects, "\n")))); got != "485db67989f91f63ee99acffa3d80c576f775453a337791a9da8b94700f1c61c" {
+		t.Fatal("original full MMX/SSE store and fence sequence changed", got)
+	}
+	mmx := regexp.MustCompile(`\bM[0-7]\b`)
+	first, last, count, emms := -1, -1, 0, 0
+	for index, instruction := range instructions {
+		if instruction == "EMMS" {
+			emms++
+		}
+		if mmx.MatchString(instruction) {
+			if first < 0 {
+				first = index
+			}
+			last, count = index, count+1
+		}
+	}
+	if count != 6 || first < 0 || last+1 >= len(instructions) {
+		t.Fatal("incomplete physical MMX operation inventory", count)
+	}
+	for index := first; index <= last; index++ {
+		if !mmx.MatchString(instructions[index]) {
+			t.Fatal("original runtime interrupts physical MMX with an unrelated source operation", instructions[index])
+		}
+	}
+	if emms != 1 || instructions[last+1] != "EMMS" || strings.Index(source, outSeed) > strings.Index(source, begin) {
+		t.Fatal("original MMX runtime lacks prepared inputs and its real immediately following EMMS")
+	}
+}
+
+func TestX86LegacyMMXOriginalRuntimeThreeAPIsAndTargetsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original MMX runtime objects require LLVM22 llc")
+	}
+	source, _ := x86LegacyMMXActualRuntimeLiterals(t)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func legacymmxsemantics(value uint64, out *byte)", "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual initialized original MMX runtime lost its public physical-region owner", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						if !strings.Contains(pipeline.ir, "asm sideeffect") || !strings.Contains(pipeline.ir, "emms") {
+							t.Fatal("original MMX region or its physical cleanup disappeared")
+						}
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_legacy_native_store_continuation_test.go b/x86_legacy_native_store_continuation_test.go
new file mode 100644
index 000000000..1258adfa7
--- /dev/null
+++ b/x86_legacy_native_store_continuation_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LegacyNativeStoreCompletePairedNumericalFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	// Complete whole128 yxmov store namespace, including Go's MOVOA alias.
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, op := range []string{"MOVO", "MOVOA", "MOVOU", "MOVAPS", "MOVAPD", "MOVUPS", "MOVUPD"} {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\nPXOR X0,X0\n%s X0,3(AX)(DX*2)\nMOVL $7,CX\nMOVL CX,ret+%d(FP)\nRET\n",
+					word+4, move, op, word)
+				declaration := "func Value(p *byte) uint32"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete legacy native store lost its paired numerical continuation", api, err)
+					}
+					if strings.Count(ir, "asm sideeffect") != 1 || !strings.Contains(ir, "~{memory}") {
+						t.Fatal("original aligned/unaligned whole128 store lost its exact native effect")
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				}
+				for name, changed := range map[string]string{
+					"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),BX", 1),
+					"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+					"unknown-data":    strings.Replace(source, "PXOR X0,X0\n", "", 1),
+					"numeric-pointer": strings.Replace(source, "MOVL $1,DX", "MOVL $42,AX\nMOVL $1,DX", 1),
+				} {
+					t.Run(name, func(t *testing.T) {
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api)
+							if target.arch == "amd64" && name == "unknown-data" {
+								x86VectorScratchCodegenControl(t, changed, declaration, target.arch, target.triple, ir, err)
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("legacy native store borrowed data/address authority", api, err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_legacy_packed_move_sparse_runtime_test.go b/x86_legacy_packed_move_sparse_runtime_test.go
new file mode 100644
index 000000000..905d8afe2
--- /dev/null
+++ b/x86_legacy_packed_move_sparse_runtime_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86LegacyPackedRegisterMoveSparsePortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var assembly, declarations, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	// Independent bit-preserving source fixtures span both signs and byte
+	// extrema. Every other source-vector byte deliberately remains unknown.
+	for _, row := range []struct {
+		op    string
+		value uint32
+	}{
+		{"MOVOU", 0}, {"MOVOA", 1}, {"MOVO", 127}, {"MOVUPS", 128},
+		{"MOVAPS", 165}, {"MOVUPD", 254}, {"MOVAPD", 255},
+	} {
+		name := "Copy" + row.op
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-4\nMOVL $%d,AX\nPINSRB $7,AX,X0\n%s X0,X1\nPEXTRB $7,X1,AX\nMOVL AX,ret+0(FP)\nRET\n", name, row.value, row.op)
+		fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+		fmt.Fprintf(&driver, "extern uint32_t %s(void);\n", name)
+	}
+	driver.WriteString(`int main(void) {
+    const uint32_t expected[7] = {0, 1, 127, 128, 165, 254, 255};
+    const uint32_t values[7] = {
+        CopyMOVOU(), CopyMOVOA(), CopyMOVO(), CopyMOVUPS(),
+        CopyMOVAPS(), CopyMOVUPD(), CopyMOVAPD()
+    };
+    for (unsigned i = 0; i < 7; ++i) {
+        if (values[i] != expected[i]) {
+            fprintf(stderr, "sparse register copy row=%u got=%u expected=%u\n", i, values[i], expected[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+`)
+	goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+					text := ir
+					if optimized {
+						text = x86DwordProductIROptimize(t, ir)
+					}
+					for _, level := range []int{0, 2} {
+						t.Run(fmt.Sprintf("backend-O%d", level), func(t *testing.T) {
+							compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "sparse-legacy-copy", triple, text, driver.String(), nil, level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_legacy_packed_move_sparse_test.go b/x86_legacy_packed_move_sparse_test.go
new file mode 100644
index 000000000..54a50875d
--- /dev/null
+++ b/x86_legacy_packed_move_sparse_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86LegacyPackedRegisterMoveSparseBytesAndPreservedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LegacyMoveNativeOracle {
+			for _, operands := range []string{"X0,X1", "X1,X1", "X7,X0"} {
+				t.Run(arch+"/"+row.name+"/"+operands, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.name+" "+operands)
+					source, _ := amd64ParseXReg(ins.Args[0].Reg)
+					destination, _ := amd64ParseXReg(ins.Args[1].Reg)
+					masks := []uint16{0, 1, 0x8000, 0xa55a, 0xffff}
+					for missing := 0; missing < 16; missing++ {
+						masks = append(masks, 0xffff&^(uint16(1)<<uint(missing)))
+					}
+					for _, mask := range masks {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.xmm[source] = mask
+						state.vectorUpper[source] = 0x56789abcdef00000
+						state.vectorUpper[destination] = 0xaabcde0123450000
+						state.gp[0], state.canonicalGP[0], state.pointerGP[0] = 0xff, 1, true
+						state.masks[1] = true
+						before, expected := state.clone(), state.clone()
+						expected.xmm[destination] = mask
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, expected) {
+							t.Fatalf("source byte mask %04x was widened or lost, or unrelated state changed", mask)
+						}
+						strict := before.clone()
+						if accepted := x86ResultTransfer(ins, &strict, nil, 0, arch); accepted != (mask == 0xffff) {
+							t.Fatal("private partial-copy effect changed the independent complete-input query", mask, accepted)
+						}
+						if mask != 0xffff {
+							physical := ins
+							physical.x86Encoded = true
+							strict = before.clone()
+							if x86ScalarFPResultTransfer(physical, &strict, nil, 0, arch) || !reflect.DeepEqual(strict, before) {
+								t.Fatal("physical/raw source borrowed the named sparse-copy continuation")
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedRegisterMoveSelectedByteThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		result, extent, triple := 8, 12, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			result, extent, triple = 4, 8, "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86LegacyMoveNativeOracle {
+			for _, selected := range []int{7, 8} {
+				t.Run(fmt.Sprintf("%s/%s/byte%d", arch, row.name, selected), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVB c+0(FP),AX\nPINSRB $7,AX,X0\n%s X0,X1\nPEXTRB $%d,X1,AX\nMOVL AX,ret+%d(FP)\nRET\n", extent, row.name, selected, result)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func view(c byte) uint32\n", arch, triple, api)
+							if selected == 7 {
+								if err != nil || ir == "" {
+									t.Fatal("selected byte lost after a legacy register copy", err)
+								}
+							} else if arch == "amd64" {
+								x86VectorScratchCodegenControl(t, source, "func view(c byte) uint32\n", arch, triple, ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown adjacent source byte became observable", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_legacy_scalar_move_native_test.go b/x86_legacy_scalar_move_native_test.go
new file mode 100644
index 000000000..c3ad919e4
--- /dev/null
+++ b/x86_legacy_scalar_move_native_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These are initialized programs, independently of reciprocal arithmetic.
+// The complete original Go source observes both low-X clearing and Y aliases.
+func TestX86LegacyScalarMoveNativeInputsWidthsAndUpperAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			op, scalar string
+			width      int
+		}{{"MOVSS", "uint32", 32}, {"MOVSD", "uint64", 64}} {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+				}
+				source := fmt.Sprintf("TEXT ·ScalarMove(SB),4,$0-%d\n%s out+0(FP),DI\n%s p+%d(FP),AX\n"+
+					"%s old+%d(FP),BX\nVMOVUPS (BX),Y2\nSTC\n%s (AX),X2\nVMOVUPS Y2,(DI)\nSETCS 32(DI)\nSTMXCSR 36(DI)\nRET\n",
+					3*word, move, move, word, move, 2*word, row.op)
+				declaration := fmt.Sprintf("func ScalarMove(out *[40]byte,p *%s,old *[32]byte)\n", row.scalar)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil {
+							t.Fatal("initialized legacy scalar native source rejected", err)
+						}
+						if strings.Count(ir, fmt.Sprintf("load volatile i%d, ptr", row.width)) != 1 {
+							t.Fatal("native scalar read lost its exact width or mandatory volatile effect")
+						}
+						missing := strings.Replace(source, fmt.Sprintf("%s p+%d(FP),AX\n", move, word), "", 1)
+						if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar native source supplied its own address", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyScalarMoveRegisterAndMemoryByteRules(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			op    string
+			width int
+		}{{"MOVSS", 4}, {"MOVSD", 8}} {
+			for _, source := range []string{"X0", "value+0(FP)"} {
+				t.Run(arch+"/"+row.op+"/"+source, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" "+source+",X2")
+					initial := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll,
+						direction: x86ResultDirectionBackward}
+					initial.xmm[0], initial.xmm[2], initial.vectorUpper[2] = 0xffff, 0x5450, 0x55aa00ff00000000
+					initial.pointerGP[7] = true
+					owned := make([]bool, len(initial.fp))
+					for index := range initial.fp {
+						initial.fp[index] = true
+						owned[index] = true
+					}
+					mask := uint16(1)<<uint(row.width) - 1
+					expected := initial.clone()
+					expected.xmm[2] |= mask
+					if source != "X0" {
+						expected.xmm[2] = 0xffff
+					}
+					state := initial.clone()
+					if !x86ResultTransfer(ins, &state, owned, 0, arch) || !reflect.DeepEqual(state, expected) {
+						t.Fatal("legacy scalar copy lost low width, memory upper-zero or old Y/Z preservation", state, expected)
+					}
+					if source != "X0" {
+						state = initial.clone()
+						if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, initial) {
+							t.Fatal("FP scalar source acquired its missing independent owned layout", state)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_legacy_scalar_native_store_fault_unix_test.go b/x86_legacy_scalar_native_store_fault_unix_test.go
new file mode 100644
index 000000000..c1c43097b
--- /dev/null
+++ b/x86_legacy_scalar_native_store_fault_unix_test.go
@@ -0,0 +1,141 @@
+//go:build (darwin || linux) && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Actual-host LLVM/C execution, not the original six-kernel Go/native owner.
+// The source has only logical integer transport and scalar bit stores: no
+// native SIMD opcode, MXCSR, CPU feature gate or emulator is needed here.
+func TestX86LegacyScalarNativeStoreActualHostValuesAndDeadFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	var source, declarations strings.Builder
+	for _, row := range x86LegacyScalarNativeStoreRows {
+		name := "Dead" + row.op
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ out+0(FP),BX\nMOVQ value+8(FP),X0\n%s X0,(BX)\n%s X0,(BX)\nRET\n",
+			name, row.op, row.op)
+		fmt.Fprintf(&declarations, "func %s(out *byte,value uint64)\n", name)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	driver := x86LegacyScalarNativeStoreFaultHeader + numericalRuntimeFaultObservationC + x86LegacyScalarNativeStoreFaultDriver
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete initialized scalar dead-store program rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				x86LegacyScalarNativeStoreExactIR(t, text, 2)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "legacy_scalar_native_store_faults", triple, ir, driver)
+		})
+	}
+}
+
+const x86LegacyScalarNativeStoreFaultHeader = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+extern void DeadMOVSS(uint8_t *,uint64_t);
+extern void DeadMOVSD(uint8_t *,uint64_t);
+struct row {void (*run)(uint8_t *,uint64_t); size_t width; const char *name;};
+static const struct row rows[]={{DeadMOVSS,4,"MOVSS"},{DeadMOVSD,8,"MOVSD"}};
+`
+
+const x86LegacyScalarNativeStoreFaultDriver = `
+static int observe(const struct row *test,uint8_t *p,uint64_t value,int fault,
+                   uint8_t *protectedPage,size_t protectedBytes) {
+    pid_t child=fork(); if(child<0) return 1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        numerical_fault_begin(protectedPage,protectedBytes);
+        uint8_t before=fault ? 0 : p[-1];
+        test->run(p,value);
+        // Never touch an expected-fault address after the oracle: that
+        // could turn an elided store into a false-positive C-side fault.
+        if(!fault) {
+            for(size_t b=0;b<test->width;b++) {
+                if(p[b]!=(uint8_t)(value>>(8*b))) _exit(124);
+            }
+            if(p[-1]!=before) _exit(125);
+            if((uintptr_t)(p+test->width)<(uintptr_t)protectedPage &&
+               p[test->width]!=0xa5) _exit(126);
+        }
+        _exit(0);
+    }
+    int status=0; pid_t waited;
+    do {waited=waitpid(child,&status,0);} while(waited<0 && errno==EINTR);
+    if(waited!=child) return 1;
+    if(fault ? numerical_fault_status(status) : (WIFEXITED(status)&&WEXITSTATUS(status)==0)) return 0;
+    fprintf(stderr,"%s width=%zu fault=%d value=%llx status=%x\n",
+            test->name,test->width,fault,(unsigned long long)value,status);
+    return 1;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE); if(page<64) return 1;
+    uint8_t *region=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    uint8_t *readonly=mmap(0,(size_t)page,PROT_READ,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED||readonly==MAP_FAILED||mprotect(region+page,(size_t)page,PROT_NONE)) return 1;
+    memset(region,0xa5,(size_t)page);
+    const uint64_t values[]={0,UINT64_MAX,UINT64_C(0x7ff0000000000001),UINT64_C(0x1234567880000001)};
+    for(size_t r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+        const struct row *test=&rows[r];
+        for(size_t v=0;v<sizeof(values)/sizeof(values[0]);v++) {
+            if(observe(test,0,values[v],1,0,1)||
+               observe(test,region+page-test->width,values[v],0,region+page,(size_t)page)||
+               observe(test,region+page-test->width+1,values[v],1,region+page,(size_t)page)||
+               observe(test,region+1,values[v],0,region+page,(size_t)page)||
+               observe(test,readonly,values[v],1,readonly,(size_t)page)) return 2;
+        }
+    }
+    int failed=munmap(region,(size_t)page*2)!=0;
+    failed|=munmap(readonly,(size_t)page)!=0;
+    return failed?3:0;
+}
+`
+
+func TestX86LegacyScalarNativeStoreFaultObserverPolicy(t *testing.T) {
+	if err := runtimeOracleFaultCorePolicy(x86LegacyScalarNativeStoreFaultDriver); err != nil {
+		t.Fatal(err)
+	}
+	for _, control := range []string{"original", "missing-observer", "unchecked-core-limit", "missing-EINTR", "unowned-signal"} {
+		t.Run(control, func(t *testing.T) {
+			driver := x86LegacyScalarNativeStoreFaultDriver
+			switch control {
+			case "missing-observer":
+				driver = strings.Replace(driver, "numerical_fault_begin(protectedPage,protectedBytes);", "", 1)
+			case "unchecked-core-limit":
+				driver = strings.Replace(driver, "if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);", "setrlimit(RLIMIT_CORE,&no_core);", 1)
+			case "missing-EINTR":
+				driver = strings.Replace(driver, "waited<0 && errno==EINTR", "0", 1)
+			case "unowned-signal":
+				driver = strings.Replace(driver, "numerical_fault_status(status)", "WIFSIGNALED(status)", 1)
+			}
+			setup := strings.Index(driver, "numerical_fault_begin(protectedPage,protectedBytes);")
+			valid := runtimeOracleFaultCorePolicy(driver) == nil && setup >= 0 &&
+				setup < strings.Index(driver, "test->run(p,value);") &&
+				strings.Contains(driver, "while(waited<0 && errno==EINTR)") &&
+				strings.Contains(driver, "if(waited!=child) return 1;") &&
+				strings.Contains(driver, "numerical_fault_status(status)") && !strings.Contains(driver, "WIFSIGNALED")
+			if valid != (control == "original") || control != "original" && driver == x86LegacyScalarNativeStoreFaultDriver {
+				t.Fatal("guard-page child lost synchronous owned-address or resource policy", control)
+			}
+		})
+	}
+}
diff --git a/x86_legacy_scalar_native_store_owner_test.go b/x86_legacy_scalar_native_store_owner_test.go
new file mode 100644
index 000000000..4d94581fc
--- /dev/null
+++ b/x86_legacy_scalar_native_store_owner_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// No SETcc, packed move, mask, result or caller owner may accidentally supply
+// the source proof for a legacy scalar store. Its own native-memory grammar
+// must require that proof for both Void and an unused bool parameter.
+func TestX86LegacyScalarNativeStoreOwnsPureVoidInputProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		triple := testTargetTriple("linux", arch)
+		for _, row := range x86LegacyScalarNativeStoreRows {
+			t.Run(arch+"/"+row.op+"/mandatory-owner", func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" X0,(BX)")
+				for _, sig := range []FuncSig{{Ret: Void}, {Args: []LLVMType{I1}, Ret: Void}} {
+					if !x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, sig, arch) {
+						t.Error("native legacy scalar store borrowed another instruction's input-proof owner")
+					}
+				}
+			})
+			for _, unusedBool := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool-%t", arch, row.op, unusedBool), func(t *testing.T) {
+					args := word + row.bytes
+					declaration := fmt.Sprintf("func Value(out *byte,value uint%d", row.bytes*8)
+					if unusedBool {
+						args++
+						declaration += ",unused bool"
+					}
+					declaration += ")"
+					pointer := move + " out+0(FP),BX\n"
+					load := fmt.Sprintf("%s value+%d(FP),X0\n", row.op, word)
+					store := row.op + " X0,(BX)\nRET\n"
+					type control struct {
+						name, body, declaration string
+						valid                   bool
+					}
+					controls := []control{
+						{"initialized", pointer + load + store, declaration, true},
+						{"missing-source", pointer + store, declaration, false},
+						{"missing-pointer", load + store, declaration, false},
+						{"partial-pointer", "MOVW out+0(FP),BX\n" + load + store, declaration, false},
+						{"numerical-pointer", pointer + load + store, strings.Replace(declaration, "out *byte", "out uintptr", 1), false},
+						{"initialized-index", pointer + load + "MOVL $1,DX\n" + strings.Replace(store, "(BX)", "(BX)(DX*2)", 1), declaration, true},
+						{"missing-index", pointer + load + strings.Replace(store, "(BX)", "(BX)(DX*2)", 1), declaration, false},
+						{"partial-index", pointer + load + "MOVW $1,DX\n" + strings.Replace(store, "(BX)", "(BX)(DX*2)", 1), declaration, false},
+					}
+					for missing := 0; missing < row.bytes; missing++ {
+						var partial strings.Builder
+						partial.WriteString(pointer + "MOVL $7,CX\n")
+						for b := 0; b < row.bytes; b++ {
+							if b != missing {
+								fmt.Fprintf(&partial, "PINSRB $%d,CX,X0\n", b)
+							}
+						}
+						partial.WriteString(store)
+						controls = append(controls, control{
+							fmt.Sprintf("missing-source-byte-%d", missing), partial.String(), declaration, false,
+						})
+					}
+					var original strings.Builder
+					for index, test := range controls {
+						fmt.Fprintf(&original, "TEXT ·Value%d(SB),4,$0-%d\n%s", index, args, test.body)
+					}
+					// Every source, including each partial-byte control, must first
+					// be a real complete original Go object on its actual mode.
+					x86LEAActualTargetGoObject(t, arch, triple, original.String())
+					for _, test := range controls {
+						for _, api := range []string{"text", "module", "Go", "default-text", "default-module"} {
+							if arch == "386" && strings.HasPrefix(api, "default-") {
+								continue // Empty Options.Goarch means amd64, never mode32.
+							}
+							t.Run(test.name+"/"+api, func(t *testing.T) {
+								source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", args, test.body)
+								var ir string
+								var err error
+								if strings.HasPrefix(api, "default-") {
+									ir, err = x86IntegerFPDefaultAPI(t, source, test.declaration, triple, strings.TrimPrefix(api, "default-"))
+								} else {
+									ir, err = x86ScalarFPBitViewAPI(t, source, test.declaration, arch, triple, api)
+								}
+								if test.valid {
+									if ir == "" || err != nil {
+										t.Fatal("pure legacy initialized store lost its independent input owner", err)
+									}
+								} else if arch == "amd64" && (test.name == "missing-source" || strings.HasPrefix(test.name, "missing-source-byte-")) {
+									x86VectorScratchCodegenControl(t, source, test.declaration, arch, triple, ir, err)
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("pure legacy store bypassed its own source/address byte proof", ir != "", err)
+								}
+							})
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_legacy_scalar_native_store_test.go b/x86_legacy_scalar_native_store_test.go
new file mode 100644
index 000000000..f3a94512c
--- /dev/null
+++ b/x86_legacy_scalar_native_store_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+var x86LegacyScalarNativeStoreRows = []struct {
+	op    string
+	bytes int
+}{{"MOVSS", 4}, {"MOVSD", 8}}
+
+func TestX86LegacyScalarNativeStoreOriginalFixturesRetained(t *testing.T) {
+	source, err := os.ReadFile("amd64_legacy_scalar_move_alias_runtime_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, want := range map[string]string{
+		"x86LegacyScalarAliasForms":                                "bf44781dcd3cdf3a33b7c01c35e2c6463e140604b3b4216c12e74b17ca31b3ca",
+		"x86LegacyScalarAliasAssembly":                             "aab68b371f34605e1c4a221e2bab6388b2a5606c5b7ff636ba501da2e65dec9a",
+		"x86LegacyScalarAliasActualGoOracle":                       "ef6fd09f452d6c2a4f7ca471866c373d7e1871a8d776bd6b67d20b4239881633",
+		"TestCrossLinuxRuntimeMatrixX86LegacyScalarMoveAliasViews": "dad2ef85bf3fa14661390d430215840d4237ab310255068578150ba4886d66de",
+	} {
+		body, err := x86SegmentMOVSourceFunction(source, name)
+		if err != nil || fmt.Sprintf("%x", sha256.Sum256(body)) != want {
+			t.Fatal("original six-kernel ASM/Go/C/observations changed", name, err)
+		}
+	}
+}
+
+func x86LegacyScalarNativeStoreState(arch string, width int) x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	state.pointerGP[3], state.callerAddressGP[3] = true, true
+	state.gp[1] = uint8(1)<<uint(x86ResultPointerWord(arch)) - 1
+	state.writeVector(1, 64, x86CallerVectorByteMask(int64(width)), false)
+	state.writeVector(7, 64, 0x55aa55aa55aa55aa, false)
+	state.masks[3] = true
+	return state
+}
+
+func TestX86LegacyScalarNativeStoreEveryByteAndPreservedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LegacyScalarNativeStoreRows {
+			ins := x86ScalarLaneInstruction(t, row.op+" X1,-1(BX)(CX*2)")
+			for missing := -1; missing < 64; missing++ {
+				t.Run(fmt.Sprintf("%s/%s/missing%d", arch, row.op, missing), func(t *testing.T) {
+					state := x86LegacyScalarNativeStoreState(arch, row.bytes)
+					if missing >= 0 {
+						state.writeVector(1, 64, x86CallerVectorByteMask(int64(row.bytes))&^(uint64(1)<<uint(missing)), false)
+					}
+					if missing%2 == 0 {
+						state.flags = 0 // A store cannot manufacture unavailable FLAGS.
+					}
+					before := state.clone()
+					accepted, known := x86ResultLegacyScalarMoveStep(ins, &state, nil, 0, arch, true)
+					want := missing < 0 || missing >= row.bytes
+					if !known || accepted != want || !reflect.DeepEqual(state, before) {
+						t.Fatal("exact scalar store borrowed a source byte or changed aliases/FLAGS/storage", accepted, known, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyScalarNativeStoreAddressAndOriginBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LegacyScalarNativeStoreRows {
+			for _, address := range []string{"(BX)", "-1(BX)(CX*1)", "-1(BX)(CX*2)", "-1(BX)(CX*4)", "-1(BX)(CX*8)"} {
+				t.Run(arch+"/"+row.op+"/"+address, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" X1,"+address)
+					state := x86LegacyScalarNativeStoreState(arch, row.bytes)
+					before := state.clone()
+					if accepted, known := x86ResultLegacyScalarMoveStep(ins, &state, nil, 0, arch, true); !accepted || !known || !reflect.DeepEqual(state, before) {
+						t.Fatal("original ordinary pointer/index store was not consumed exactly", accepted, known)
+					}
+				})
+			}
+			registers := []int{0, 7}
+			if arch == "amd64" {
+				registers = append(registers, 15)
+			}
+			for _, register := range registers {
+				t.Run(fmt.Sprintf("%s/%s/source-X%d", arch, row.op, register), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s X%d,(BX)", row.op, register))
+					state := x86LegacyScalarNativeStoreState(arch, row.bytes)
+					state.writeVector(register, 64, x86CallerVectorByteMask(int64(row.bytes)), false)
+					before := state.clone()
+					if accepted, known := x86ResultLegacyScalarMoveStep(ins, &state, nil, 0, arch, true); !accepted || !known || !reflect.DeepEqual(state, before) {
+						t.Fatal("legacy source bank changed native store or alias semantics", register, accepted, known)
+					}
+				})
+			}
+			for _, mutation := range []string{"standalone", "pointer", "index", "pointer-index", "encoded", "raw", "raw-return", "address", "unbound-address", "segment", "segment-memory", "symbol", "numerical-read", "FP-parameter"} {
+				t.Run(arch+"/"+row.op+"/"+mutation, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" X1,-1(BX)(CX*2)")
+					state := x86LegacyScalarNativeStoreState(arch, row.bytes)
+					paired := true
+					switch mutation {
+					case "standalone":
+						paired = false
+					case "pointer":
+						state.pointerGP[3] = false
+						state.gp[3] = 0xff // NUM is not an incoming pointer.
+					case "index":
+						state.gp[1] >>= 1
+					case "pointer-index":
+						state.pointerGP[1], state.gp[1] = true, 0
+					case "encoded":
+						ins.x86Encoded = true
+					case "raw":
+						ins.x86SourceRaw = new(x86SourceRawInstruction)
+					case "raw-return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address":
+						ins.x86AddressBits = 32
+					case "unbound-address":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "segment-memory":
+						ins.Args[1].Mem.Segment = "FS"
+					case "symbol":
+						ins.Args[1].Mem.Sym = "foreign(SB)"
+					case "numerical-read":
+						ins.x86NumericalRead = new(x86NumericalReadCertificate)
+					case "FP-parameter":
+						ins.Args[1] = Operand{Kind: OpFP, FPOffset: 0}
+						state.fp = make([]bool, 16)
+					}
+					before := state.clone()
+					if accepted, _ := x86ResultLegacyScalarMoveStep(ins, &state, make([]bool, 16), 16, arch, paired); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("native scalar store acquired an absent source/address/frame role", mutation)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86LegacyScalarNativeStoreExactIR(t *testing.T, ir string, count int) {
+	t.Helper()
+	for _, scalar := range []string{"(?:float|i32)", "(?:double|i64)"} {
+		pattern := regexp.MustCompile(`(?m)^\s+store volatile ` + scalar + ` [^\n]*, align 1$`)
+		if got := len(pattern.FindAllString(ir, -1)); got != count {
+			t.Fatal("scalar native store lost its exact width, unaligned access or volatility", scalar, got, count)
+		}
+	}
+}
+
+func TestX86LegacyScalarNativeStoreOriginalThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var declarations strings.Builder
+	for _, form := range x86LegacyScalarAliasForms() {
+		fmt.Fprintf(&declarations, "func %s(input,output *byte)\n", form.name)
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, wide := range []int{32, 64} {
+			t.Run(fmt.Sprintf("%s/alias%d", target.triple, wide), func(t *testing.T) {
+				source := x86LegacyScalarAliasAssembly(wide, target.arch)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete original six-kernel typed source rejected", err)
+						}
+						optimized := x86DwordProductIROptimize(t, ir)
+						for _, pipeline := range []struct{ name, ir, backend string }{
+							{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+						} {
+							t.Run(pipeline.name, func(t *testing.T) {
+								x86LegacyScalarNativeStoreExactIR(t, pipeline.ir, 3)
+								x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.backend)
+							})
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LegacyScalarNativeStorePublicInputsAndFramePermissions(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple, move, word := "x86_64-unknown-linux-gnu", "MOVQ", 8
+		if arch == "386" {
+			triple, move, word = "i386-unknown-linux-gnu", "MOVL", 4
+		}
+		for _, row := range x86LegacyScalarNativeStoreRows {
+			prefix := fmt.Sprintf("TEXT ·Store(SB),4,$0-%d\n%s out+0(FP),BX\n%s input+%d(FP),AX\nMOVL $1,CX\n", 2*word, move, move, word)
+			body := row.op + " (AX),X1\nSTC\n" + row.op + " X1,-1(BX)(CX*2)\nSETCS 16(BX)\nRET\n"
+			for _, control := range []struct {
+				name, source, declaration string
+				valid                     bool
+			}{
+				{"initialized", prefix + body, "func Store(out,input *byte)", true},
+				{"numeric-destination", prefix + body, "func Store(out uintptr,input *byte)", false},
+				{"missing-pointer", strings.Replace(prefix, move+" out+0(FP),BX\n", "", 1) + body, "func Store(out,input *byte)", false},
+				{"partial-source", prefix + strings.Replace(body, row.op+" (AX),X1", "PINSRW $0,CX,X1", 1), "func Store(out,input *byte)", false},
+				{"partial-index", strings.Replace(prefix, "MOVL $1,CX", "MOVW $1,CX", 1) + body, "func Store(out,input *byte)", false},
+				{"unknown-FLAGS", prefix + strings.Replace(body, "STC\n", "", 1), "func Store(out,input *byte)", false},
+				{"FP-parameter", prefix + strings.Replace(body, "X1,-1(BX)(CX*2)", "X1,out+0(FP)", 1), "func Store(out,input *byte)", false},
+			} {
+				t.Run(arch+"/"+row.op+"/"+control.name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, triple, control.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, control.source, control.declaration, arch, triple, api)
+						if control.valid {
+							if err != nil || ir == "" {
+								t.Fatal("actual typed scalar store lost incoming pointer/source/FLAGS", api, err)
+							}
+						} else if arch == "amd64" && control.name == "partial-source" {
+							x86VectorScratchCodegenControl(t, control.source, control.declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar native store borrowed missing numerical/FLAGS/frame authority", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_linux_syscall_effects.go b/x86_linux_syscall_effects.go
new file mode 100644
index 000000000..b7a9c8a5b
--- /dev/null
+++ b/x86_linux_syscall_effects.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Linux's normal-return AMD64 syscall convention is separate from libc's
+// errno-setting API. This descriptor supplies no pointer, backing or private
+// frame permission, and is consumed only by target-aware paired lowering.
+func x86LinuxSyscallByteEffect(ins Instr, arch, target string) (x86TypedByteEffect, bool, error) {
+	if ins.Op != "SYSCALL" {
+		return x86TypedByteEffect{}, false, nil
+	}
+	fail := func(reason string) (x86TypedByteEffect, bool, error) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("SYSCALL %s: %q", reason, ins.Raw)
+	}
+	if arch != "amd64" || len(ins.Args) != 0 || !x86ResultNamedPredicateInstruction(ins) {
+		return fail("requires the complete named AMD64 zero-operand form")
+	}
+	parts := strings.Split(llvmNormalizedTargetTriple(target), "-")
+	if len(parts) < 3 || parts[0] != "x86_64" || parts[2] != "linux" {
+		return fail("requires an explicit Linux x86-64 target")
+	}
+	effect := x86TypedByteEffect{requiresResultProof: true, flagsKilled: x86ByteFlagsAll}
+	for _, register := range []Reg{AX, DI, SI, DX, "R10", "R8", "R9"} {
+		effect.operands = append(effect.operands, x86TypedByteOperand{
+			index: -1, operand: Operand{Kind: OpReg, Reg: register}, width: 8, read: true,
+		})
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{
+		index: -1, operand: Operand{Kind: OpReg, Reg: AX}, width: 8, write: true,
+	})
+	return effect, true, nil
+}
+
+func x86LoweredLinuxSyscallStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch, target string) (bool, bool) {
+	effect, known, err := x86LinuxSyscallByteEffect(ins, arch, target)
+	if !known || err != nil {
+		return false, known
+	}
+	for _, operand := range effect.operands {
+		if operand.read && !x86ResultRead(operand.operand, operand.width, state, owned, arch) {
+			return false, true
+		}
+		if operand.read {
+			index, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+			if !valid || state.pointerGP[index] || state.callerAddressGP[index] ||
+				state.resultAddressGP[index].valid || state.boolFrameGP != nil && state.boolFrameGP[index].valid {
+				return false, true // Numerical arguments never expose a logical/private frame to the kernel.
+			}
+		}
+	}
+	// CX contains a native continuation and R11 the physical incoming flags.
+	// LLVM's separately virtualized source flags cannot be recovered from
+	// either host register. No old NUM/canonical/address facts survive there.
+	for _, register := range []Reg{CX, "R11"} {
+		index, _, _ := x86ResultGP(register, 8, arch)
+		state.gp[index] = 0
+	}
+	state.canonicalGP = [16]uint8{}
+	state.pointerGP = [16]bool{}
+	state.callerAddressGP = [16]bool{}
+	state.callerAddressOrigin = [16]uint16{}
+	state.resultAddressGP = [16]x86ResultSlotAddress{}
+	if state.boolFrameGP != nil {
+		state.boolFrameGP = new([16]x86ResultSlotAddress)
+	}
+	state.flags = 0
+	state.direction = x86ResultDirectionUnknown
+	state.predicate = x86ResultPredicate{}
+	state.bitScanPending = x86ResultBitScanPending{}
+	state.gpBits = x86ResultGPBits{}
+	state.shiftBits = x86ResultShiftBits{}
+	state.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+	state.stringCount = x86StringCountUnknown
+	state.cpuidRootLeaf = false
+	for _, operand := range effect.operands {
+		if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	return true, true // AX is the raw numerical return; DX and other input GP words are preserved.
+}
diff --git a/x86_linux_syscall_runtime_linux_amd64_test.go b/x86_linux_syscall_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..72d498c27
--- /dev/null
+++ b/x86_linux_syscall_runtime_linux_amd64_test.go
@@ -0,0 +1,69 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Other hosts compile the independent Go ELF and validate portable source
+// controls. This default Linux owner executes the original and all three
+// translated API paths; no host skip or artifact generation is execution.
+func TestCrossLinuxRuntimeMatrixAMD64LinuxRawSyscall(t *testing.T) {
+	if !t.Run("original-Go-kernel", TestX86LinuxSyscallOriginalGo) {
+		t.Fatal("original Go kernel precondition failed")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	opt := findLLVM22Tool("opt")
+	if !found || opt == "" {
+		t.Fatal("Linux raw syscall runtime requires LLVM22 llc, opt and clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	driver, err := os.ReadFile("testdata/amd64/linux-syscall/main.c")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86LinuxSyscallAssembly, x86LinuxSyscallDeclaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("IR-O%d", level), func(t *testing.T) {
+					directory := t.TempDir()
+					input, output := filepath.Join(directory, "input.ll"), filepath.Join(directory, "optimized.ll")
+					if err := os.WriteFile(input, []byte(ir), 0o600); err != nil {
+						t.Fatal(err)
+					}
+					ctx, cancel := runtimeOracleStageContext(t)
+					command := exec.CommandContext(ctx, opt, "-S", fmt.Sprintf("-passes=default<O%d>", level), input, "-o", output)
+					messages, err := runtimeOracleCombinedOutput(ctx, command)
+					cancel()
+					if err != nil {
+						t.Fatalf("LLVM22 optimization: %v\n%s", err, messages)
+					}
+					optimized, err := os.ReadFile(output)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, backend := range []string{"-O0", "-O2"} {
+						t.Run("backend"+backend, func(t *testing.T) {
+							actual := execution.compileAndRunLLVM(t, "raw-syscall", string(optimized), string(driver), backend)
+							if strings.TrimSpace(string(actual)) != "RAW_SYSCALL_REFERENCE calls=4 failures=0\nRAW_SYSCALL_TRANSLATED calls=4 failures=0" {
+								t.Fatalf("incomplete kernel oracle outcomes: %s", actual)
+							}
+							t.Log("RAW_SYSCALL_KERNEL_PIPELINE_PASS", api, level, backend, strings.TrimSpace(string(actual)))
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_linux_syscall_test.go b/x86_linux_syscall_test.go
new file mode 100644
index 000000000..a52c75611
--- /dev/null
+++ b/x86_linux_syscall_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"context"
+	_ "embed"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86LinuxSyscallDeclaration = `func Raw(number, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr)`
+
+// Complete Linux AMD64 register inputs and the original two-result ABI0 form.
+// DX is both the third argument and a preserved register after normal return.
+//
+//go:embed testdata/amd64/linux-syscall/raw_amd64.s
+var x86LinuxSyscallAssembly string
+
+func TestX86LinuxSyscallOriginalGo(t *testing.T) {
+	directory := t.TempDir()
+	files := make(map[string]string)
+	for _, name := range []string{"go.mod.txt", "main.go", "raw_amd64.s"} {
+		data, err := os.ReadFile(filepath.Join("testdata/amd64/linux-syscall", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if name == "go.mod.txt" {
+			name = "go.mod"
+		}
+		files[name] = string(data)
+	}
+	for name, source := range files {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(source), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin/go"), "build", "-p=1", "-mod=readonly", "-o", filepath.Join(directory, "original"), ".")
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOROOT="+runtime.GOROOT(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0", "GOPROXY=off")
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("original full Go assembly/ELF link: %v\n%s", err, output)
+	}
+	if runtime.GOOS == "linux" && runtime.GOARCH == "amd64" {
+		command = exec.CommandContext(ctx, filepath.Join(directory, "original"))
+		output, err := command.CombinedOutput()
+		if err != nil || !strings.Contains(string(output), "ORIGINAL_RAW_SYSCALL_PASS") {
+			t.Fatalf("original Linux raw kernel semantics: %v\n%s", err, output)
+		}
+		t.Log(strings.TrimSpace(string(output)))
+	}
+}
+
+func TestX86LinuxSyscallPairedResult(t *testing.T) {
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86LinuxSyscallAssembly, x86LinuxSyscallDeclaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal("paired Linux kernel result transfer", err)
+			}
+			if !strings.Contains(ir, "asm sideeffect \"syscall\"") || strings.Contains(ir, "call i64 @syscall(") || strings.Contains(ir, "call i32 @cliteErrno(") {
+				t.Fatal("Linux raw instruction was replaced by a hosted errno-changing wrapper", ir)
+			}
+		})
+	}
+}
+
+// This observes the actual emitter independently of the complete-source audit.
+// Its IR is executed against the raw C oracle; generating it is not a semantic
+// PASS, nor a public native-entry or source-frame authorization.
+func TestX86LinuxSyscallEmitterArtifact(t *testing.T) {
+	registers := []Reg{AX, DI, SI, DX, "R10", "R8", "R9"}
+	fn := Func{}
+	for _, register := range registers {
+		fn.Instrs = append(fn.Instrs, Instr{Op: "MOVQ", Args: []Operand{{Kind: OpReg, Reg: register}, {Kind: OpReg, Reg: register}}})
+	}
+	c, body := newAMD64CtxWithFuncForTest(t, fn, FuncSig{Name: "Raw", Ret: Void}, nil)
+	c.targetTriple = "x86_64-unknown-linux-gnu"
+	parameters := []string{"number", "a1", "a2", "a3", "a4", "a5", "a6"}
+	for index, register := range registers {
+		if err := c.storeReg(register, "%"+parameters[index]); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if accepted, terminated, err := c.lowerSyscall("SYSCALL", Instr{Op: "SYSCALL", Raw: "SYSCALL"}); !accepted || terminated || err != nil {
+		t.Fatal("isolated actual emitter", accepted, terminated, err)
+	}
+	ax, err := c.loadReg(AX)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dx, err := c.loadReg(DX)
+	if err != nil {
+		t.Fatal(err)
+	}
+	first, second := c.newTmp(), c.newTmp()
+	fmt.Fprintf(body, "  %%%s = insertvalue { i64, i64 } poison, i64 %s, 0\n", first, ax)
+	fmt.Fprintf(body, "  %%%s = insertvalue { i64, i64 } %%%s, i64 %s, 1\n  ret { i64, i64 } %%%s\n", second, first, dx, second)
+	declarations := make([]string, len(parameters))
+	for index, name := range parameters {
+		declarations[index] = "i64 %" + name
+	}
+	ir := "target triple = \"x86_64-unknown-linux-gnu\"\ndeclare i64 @syscall(i64,i64,i64,i64,i64,i64,i64)\ndeclare i32 @cliteErrno()\n" +
+		"define { i64, i64 } @Raw(" + strings.Join(declarations, ", ") + ") {\n" + body.String() + "}\n"
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if err != nil {
+		t.Fatal("actual emitter artifact is invalid LLVM", err, ir)
+	}
+	defer module.Dispose()
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("RAW_SYSCALL_EMITTER_IR_BASE64=" + base64.StdEncoding.EncodeToString([]byte(ir)))
+}
+
+func TestX86LinuxSyscallFormAndTarget(t *testing.T) {
+	for _, target := range []string{"x86_64-unknown-linux-gnu", "x86_64-linux-gnu"} {
+		effect, known, err := x86LinuxSyscallByteEffect(Instr{Op: "SYSCALL", Raw: "SYSCALL"}, "amd64", target)
+		if !known || err != nil || !effect.requiresResultProof || len(effect.operands) != 8 || effect.flagsKilled != x86ByteFlagsAll || effect.flagsDefined != 0 {
+			t.Fatal("complete target-aware raw effect", target, known, err, effect)
+		}
+		for index, register := range []Reg{AX, DI, SI, DX, "R10", "R8", "R9"} {
+			operand := effect.operands[index]
+			if !operand.read || operand.write || operand.width != 8 || operand.operand.Kind != OpReg || operand.operand.Reg != register {
+				t.Fatal("kernel input role changed", index, operand)
+			}
+		}
+	}
+	for _, target := range []string{"", "x86_64-apple-darwin", "x86_64-pc-windows-msvc", "x86_64-linux-windows-msvc", "i386-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+		if _, _, err := x86LinuxSyscallByteEffect(Instr{Op: "SYSCALL", Raw: "SYSCALL"}, "amd64", target); err == nil {
+			t.Fatal("unclosed target accepted", target)
+		}
+	}
+}
+
+func TestX86LinuxSyscallInputAndClobberGuards(t *testing.T) {
+	for _, row := range []struct{ name, old, replacement string }{
+		{"undefined SI", "MOVQ a2+16(FP), SI", "NOP"},
+		{"partial SI", "MOVQ a2+16(FP), SI", "MOVB a2+16(FP), SI"},
+		{"CX clobbered", "SYSCALL\nMOVQ AX", "MOVQ $7,CX\nSYSCALL\nMOVQ CX,AX\nMOVQ AX"},
+		{"R11 clobbered", "SYSCALL\nMOVQ AX", "MOVQ $7,R11\nSYSCALL\nMOVQ R11,AX\nMOVQ AX"},
+		{"logical frame escape", "MOVQ a2+16(FP), SI", "LEAQ r1+56(FP), SI"},
+		{"flags unknown", "SYSCALL\nMOVQ AX", "CMPQ DI,SI\nSYSCALL\nJEQ 2(PC)\nNOP\nMOVQ AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := strings.Replace(x86LinuxSyscallAssembly, row.old, row.replacement, 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				_, err := x86ScalarFPBitViewAPI(t, source, x86LinuxSyscallDeclaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unclosed input, physical result or private frame accepted", api, err)
+				}
+			}
+		})
+	}
+	// A Void result cannot suppress the kernel's complete source-input proof.
+	for _, api := range []string{"text", "module", "Go"} {
+		_, err := x86ScalarFPBitViewAPI(t, "TEXT ·Raw(SB),4,$0-0\nSYSCALL\nRET\n", "func Raw()", "amd64", "x86_64-unknown-linux-gnu", api)
+		if !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("dead raw kernel effect acquired uninitialized inputs", api, err)
+		}
+	}
+}
diff --git a/x86_lods_volatile_observer_test.go b/x86_lods_volatile_observer_test.go
new file mode 100644
index 000000000..941054104
--- /dev/null
+++ b/x86_lods_volatile_observer_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Output stores can retain the native MOV's volatile qualifier after inlining.
+// Classify every complete cell and keep all value, address and effect checks.
+func TestX86LODSZeroStoreObserverVolatileAndLineEndingForms(t *testing.T) {
+	observations := 0
+	for _, arch := range []string{"386", "amd64"} {
+		word := 8
+		if arch == "386" {
+			word = 4
+		}
+		bits := 8 * word
+		for _, row := range x86LODSStateCases(arch) {
+			if row.prefix == "" || row.count != 0 {
+				continue
+			}
+			base := x86LODSZeroStoreTemplate(row)
+			expected := x86LODSStateExpected(row)
+			mutations := map[string]string{
+				"wrong-width": strings.Replace(base, fmt.Sprintf("store i%d ", bits), "store i8 ", 1),
+				"missing-CX": strings.Replace(base,
+					fmt.Sprintf("store i%d 0, ptr %%ptr1, align %d\n", bits, word), "", 1),
+				"foreign-store":   base + fmt.Sprintf("store i%d 0, ptr %%foreign, align %d\n", bits, word),
+				"duplicate-store": base + fmt.Sprintf("store i%d 0, ptr %%out, align %d\n", bits, word),
+				"unknown-call":    base + "call void @unknown()\n",
+				"atomic-store":    strings.Replace(base, "store i", "store atomic i", 1),
+				"double-volatile": strings.Replace(base, "store i", "store volatile volatile i", 1),
+			}
+			values := []string{strconv.FormatUint(expected.ax, 10), "%si", "0",
+				strconv.FormatUint(expected.flags, 10)}
+			for index, value := range values {
+				mutations[fmt.Sprintf("cell%d-value", index)] = strings.Replace(base,
+					fmt.Sprintf("store i%d %s,", bits, value), fmt.Sprintf("store i%d 7,", bits), 1)
+			}
+			for _, qualifier := range []string{"ordinary", "volatile"} {
+				for _, ending := range []string{"LF", "CRLF"} {
+					observations++
+					t.Run(arch+"/"+row.name+"/"+qualifier+"/"+ending, func(t *testing.T) {
+						format := func(body string) string {
+							lines := strings.Split(body, "\n")
+							for index, line := range lines {
+								if qualifier == "volatile" && strings.HasPrefix(line, "store i") &&
+									!strings.Contains(line, "ptr %flags_slot,") {
+									lines[index] = strings.Replace(line, "store i", "store volatile i", 1)
+								}
+							}
+							separator := "\n"
+							if ending == "CRLF" {
+								separator = "\r\n"
+							}
+							return strings.Join(lines, separator)
+						}
+						body := format(base)
+						if err := x86LODSCheckZeroOutputStores(body, row); err != nil {
+							t.Error("complete qualified output stores were rejected", err)
+						}
+						for name, changed := range mutations {
+							if changed == base || x86LODSCheckZeroOutputStores(format(changed), row) == nil {
+								t.Error("qualified observer accepted mutation", name)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+	if observations != 112 {
+		t.Fatal("complete qualifier and line-ending matrix changed", observations)
+	}
+}
diff --git a/x86_lods_zero_observer_test.go b/x86_lods_zero_observer_test.go
new file mode 100644
index 000000000..cb2ad101e
--- /dev/null
+++ b/x86_lods_zero_observer_test.go
@@ -0,0 +1,204 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var x86LODSObserverSSA = `%[-A-Za-z0-9._]+`
+
+// This deliberately recognizes only the straight-line four-cell observation
+// emitted by this fixture. It is not an LLVM interpreter or a native execution
+// oracle. In particular, an unclassified store or call cannot be ignored.
+func x86LODSCheckZeroOutputStores(body string, row x86LODSStateCase) error {
+	word := 8
+	if row.arch == "386" {
+		word = 4
+	}
+	bits := 8 * word
+	expected := x86LODSStateExpected(row)
+	ssa := x86LODSObserverSSA
+	assignment := func(expression string) *regexp.Regexp {
+		return regexp.MustCompile(`^(` + ssa + `) = ` + expression + `$`)
+	}
+	outputInteger := assignment(fmt.Sprintf(`ptrtoint ptr %%out to i%d`, bits))
+	sourceInteger := assignment(fmt.Sprintf(`ptrtoint ptr %%source to i%d`, bits))
+	addition := assignment(fmt.Sprintf(`add i%d (%s), (-?[0-9]+)`, bits, ssa))
+	pointer := assignment(fmt.Sprintf(`inttoptr i%d (%s) to ptr`, bits, ssa))
+	privateGEP := assignment(fmt.Sprintf(`getelementptr inbounds(?: nuw)? i8, ptr (%s), i%d ([0-9]+)`, ssa, bits))
+	privateInteger := assignment(fmt.Sprintf(`ptrtoint ptr (%s) to i%d`, ssa, bits))
+	privateAlloca := assignment(`alloca \[256 x i8\], align 1`)
+	// Native output MOVs retain volatile; private numerical cells need not.
+	// Both spellings still require the same complete width/value/address proof.
+	store := regexp.MustCompile(`^store(?: volatile)? i([0-9]+) ([^ ,]+), ptr (` + ssa + `), align ([0-9]+)$`)
+	directionCall := regexp.MustCompile(`^(?:tail )?call void asm sideeffect "(?:cld|std)", "~\{dirflag\}"\(\)(?: #[0-9]+)?$`)
+	lifetimeCall := regexp.MustCompile(`^call void @llvm\.lifetime\.(?:start|end)\.p0\(ptr nonnull (` + ssa + `)\)$`)
+
+	outputInts, sourceInts := map[string]bool{}, map[string]bool{}
+	privateBases, privateOffsets := map[string]bool{}, map[string]int{}
+	outputOffsets, addressOffsets := map[string]int{}, map[string]int{"%out": 0}
+	privateAddresses := map[string]bool{}
+	seen := [4]bool{}
+	privateStores, outputAlloca := 0, false
+	for _, raw := range strings.Split(body, "\n") {
+		line := strings.TrimSpace(raw)
+		if strings.HasPrefix(line, "br ") || strings.HasPrefix(line, "switch ") ||
+			strings.HasPrefix(line, "indirectbr ") || strings.HasPrefix(line, "invoke ") || strings.Contains(line, "callbr ") ||
+			strings.Contains(line, "atomicrmw ") || strings.Contains(line, "cmpxchg ") ||
+			(strings.HasSuffix(line, ":") && line != "entry:") {
+			return fmt.Errorf("observer is not single-entry straight-line: %s", line)
+		}
+		if strings.Contains(line, "call ") && !directionCall.MatchString(line) {
+			match := lifetimeCall.FindStringSubmatch(line)
+			if match == nil || !privateBases[match[1]] {
+				return fmt.Errorf("unclassified observer call: %s", line)
+			}
+		}
+		if line == fmt.Sprintf("%%out = alloca [4 x i%d], align %d", bits, word) {
+			outputAlloca = true
+		}
+		if match := privateAlloca.FindStringSubmatch(line); match != nil {
+			privateBases[match[1]] = true
+		}
+		if match := outputInteger.FindStringSubmatch(line); match != nil {
+			outputInts[match[1]] = true
+		}
+		if match := sourceInteger.FindStringSubmatch(line); match != nil {
+			sourceInts[match[1]] = true
+		}
+		if match := privateGEP.FindStringSubmatch(line); match != nil && privateBases[match[2]] {
+			offset, _ := strconv.Atoi(match[3])
+			privateOffsets[match[1]] = offset
+		}
+		if match := privateInteger.FindStringSubmatch(line); match != nil {
+			if offset, ok := privateOffsets[match[2]]; ok {
+				privateOffsets[match[1]] = offset
+			}
+		}
+		if match := addition.FindStringSubmatch(line); match != nil {
+			delta, _ := strconv.Atoi(match[3])
+			if outputInts[match[2]] {
+				outputOffsets[match[1]] = delta
+			}
+			if offset, ok := privateOffsets[match[2]]; ok && delta == -word {
+				privateOffsets[match[1]] = offset + delta
+			}
+		}
+		if match := pointer.FindStringSubmatch(line); match != nil {
+			if offset, ok := outputOffsets[match[2]]; ok {
+				addressOffsets[match[1]] = offset
+			}
+			if offset, ok := privateOffsets[match[2]]; ok && offset >= 0 && offset+word <= 256 {
+				privateAddresses[match[1]] = true
+			}
+		}
+		if !strings.HasPrefix(line, "store ") {
+			continue
+		}
+		match := store.FindStringSubmatch(line)
+		if match == nil || match[1] != strconv.Itoa(bits) {
+			return fmt.Errorf("unclassified or wrong-width observer store: %s", line)
+		}
+		value, destination := match[2], match[3]
+		if privateAddresses[destination] {
+			privateStores++
+			if privateStores > 1 || value != strconv.FormatUint(expected.flags|2, 10) {
+				return fmt.Errorf("private PUSHF cell changed: %s", line)
+			}
+			continue
+		}
+		offset, ok := addressOffsets[destination]
+		if !ok || offset < 0 || offset%word != 0 || offset >= 4*word || match[4] != strconv.Itoa(word) {
+			return fmt.Errorf("store is not an exact output cell: %s", line)
+		}
+		cell := offset / word
+		if seen[cell] {
+			return fmt.Errorf("output cell written more than once: %s", line)
+		}
+		seen[cell] = true
+		want := []string{strconv.FormatUint(expected.ax, 10), "source", "0", strconv.FormatUint(expected.flags, 10)}[cell]
+		if (cell == 1 && !sourceInts[value]) || (cell != 1 && value != want) {
+			return fmt.Errorf("output cell %d got %s, want %s", cell, value, want)
+		}
+	}
+	if !outputAlloca || seen != [4]bool{true, true, true, true} {
+		return fmt.Errorf("missing fresh output or one of its four complete stores: %t %v", outputAlloca, seen)
+	}
+	return nil
+}
+
+func x86LODSZeroStoreTemplate(row x86LODSStateCase) string {
+	word := 8
+	if row.arch == "386" {
+		word = 4
+	}
+	bits, expected := 8*word, x86LODSStateExpected(row)
+	var body strings.Builder
+	body.WriteString("entry:\n")
+	fmt.Fprintf(&body, "%%out = alloca [4 x i%d], align %d\n", bits, word)
+	fmt.Fprintf(&body, "%%oi = ptrtoint ptr %%out to i%d\n%%si = ptrtoint ptr %%source to i%d\n", bits, bits)
+	fmt.Fprintf(&body, "store i%d %d, ptr %%out, align %d\n", bits, expected.ax, word)
+	for index, value := range []string{"%si", "0", strconv.FormatUint(expected.flags, 10)} {
+		fmt.Fprintf(&body, "%%add%d = add i%d %%oi, %d\n%%ptr%d = inttoptr i%d %%add%d to ptr\nstore i%d %s, ptr %%ptr%d, align %d\n",
+			index, bits, (index+1)*word, index, bits, index, bits, value, index, word)
+	}
+	if row.arch == "386" {
+		body.WriteString("%stack = alloca [256 x i8], align 1\n")
+		body.WriteString("%sp = getelementptr inbounds nuw i8, ptr %stack, i32 72\n")
+		body.WriteString("%spi = ptrtoint ptr %sp to i32\n%pushed = add i32 %spi, -4\n")
+		body.WriteString("%flags_slot = inttoptr i32 %pushed to ptr\n")
+		fmt.Fprintf(&body, "store i32 %d, ptr %%flags_slot, align 1\n", expected.flags|2)
+	}
+	return body.String()
+}
+
+func TestX86LODSZeroStoreObserverRejectsEveryFieldAndUnknownEffect(t *testing.T) {
+	observations := 0
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86LODSStateCases(arch) {
+			if row.prefix == "" || row.count != 0 {
+				continue
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				observations++
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					body := x86LODSZeroStoreTemplate(row)
+					if err := x86LODSCheckZeroOutputStores(body, row); err != nil {
+						t.Fatal("independent correct output template rejected", err)
+					}
+					word := 8
+					if arch == "386" {
+						word = 4
+					}
+					bits := 8 * word
+					for name, changed := range map[string]string{
+						"AX":                 strings.Replace(body, fmt.Sprintf("store i%d %d,", bits, x86LODSStateSeed(arch)), fmt.Sprintf("store i%d 7,", bits), 1),
+						"SI":                 strings.Replace(body, fmt.Sprintf("store i%d %%si,", bits), fmt.Sprintf("store i%d 7,", bits), 1),
+						"CX":                 strings.Replace(body, fmt.Sprintf("store i%d 0,", bits), fmt.Sprintf("store i%d 7,", bits), 1),
+						"FLAGS":              strings.Replace(body, fmt.Sprintf("store i%d %d,", bits, x86LODSStateExpected(row).flags), fmt.Sprintf("store i%d 7,", bits), 1),
+						"offset":             strings.Replace(body, fmt.Sprintf("%%oi, %d", 2*word), fmt.Sprintf("%%oi, %d", 2*word+1), 1),
+						"width":              strings.Replace(body, fmt.Sprintf("store i%d ", bits), "store i8 ", 1),
+						"late-overwrite":     body + fmt.Sprintf("store i%d 7, ptr %%out, align %d\n", bits, word),
+						"missing":            strings.Replace(body, fmt.Sprintf("store i%d 0, ptr %%ptr1, align %d\n", bits, word), "", 1),
+						"unknown-call":       body + "call void @unknown()\n",
+						"branch":             body + "br label %later\nlater:\n",
+						"foreign-store":      body + fmt.Sprintf("store i%d 0, ptr %%other, align %d\n", bits, word),
+						"private-unbound":    body + fmt.Sprintf("store i%d %d, ptr %%unbound_stack, align 1\n", bits, x86LODSStateExpected(row).flags|2),
+						"output-lifetime":    body + "call void @llvm.lifetime.end.p0(ptr nonnull %out)\n",
+						"missing-fresh-base": strings.Replace(body, "alloca [4 x", "alloca [5 x", 1),
+					} {
+						if changed == body || x86LODSCheckZeroOutputStores(changed, row) == nil {
+							t.Fatal("observer failed to reject mutation", name)
+						}
+					}
+				})
+			}
+		}
+	}
+	if observations != 84 {
+		t.Fatal("zero-state three-API observation denominator changed", observations)
+	}
+}
diff --git a/x86_lods_zero_state_llvm_test.go b/x86_lods_zero_state_llvm_test.go
new file mode 100644
index 000000000..a1f6bcd4a
--- /dev/null
+++ b/x86_lods_zero_state_llvm_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+var x86LODSStateTargets sync.Once
+
+// The observer loads a real target pointer from a machine-word output cell.
+// Obtain that layout from the selected LLVM target, not the host or an assumed
+// pointer width, before optimizing either architecture's complete module.
+func x86LODSStateTargetLayout(t *testing.T, ir, triple string, word int) string {
+	t.Helper()
+	x86LODSStateTargets.Do(func() {
+		llvm.InitializeAllTargetInfos()
+		llvm.InitializeAllTargets()
+		llvm.InitializeAllTargetMCs()
+	})
+	target, err := llvm.GetTargetFromTriple(triple)
+	if err != nil {
+		t.Fatal("LODS observer requires its actual LLVM target", err)
+	}
+	machine := target.CreateTargetMachine(triple, "", "", llvm.CodeGenLevelDefault,
+		llvm.RelocDefault, llvm.CodeModelDefault)
+	if machine.C == nil {
+		t.Fatal("LODS observer target machine is missing", triple)
+	}
+	defer machine.Dispose()
+	data := machine.CreateTargetData()
+	defer data.Dispose()
+	if data.PointerSize() != word {
+		t.Fatal("LODS output cells do not match the actual target pointer", triple, data.PointerSize(), word)
+	}
+	if strings.Contains(ir, "target datalayout") {
+		t.Fatal("LODS observer must not replace an existing module layout")
+	}
+	t.Logf("actual LLVM target %s pointer=%d datalayout=%q", triple, word, data.String())
+	return fmt.Sprintf("target datalayout = %q\n", data.String()) + ir
+}
+
+// This test-only LLVM caller observes the actual translated void function's
+// four output cells. Its fresh alloca is not an ASM frame/backing certificate.
+// It compares the opaque source pointer by identity, never as numerical data.
+func x86LODSZeroStateObserver(row x86LODSStateCase) string {
+	typ := "i64"
+	if row.arch == "386" {
+		typ = "i32"
+	}
+	result := fmt.Sprintf("{ %s, i1, %s, %s }", typ, typ, typ)
+	return fmt.Sprintf(`
+define %s @observe_%s(ptr %%source) {
+entry:
+  %%out = alloca [4 x %s]
+  call void @%s(ptr %%out, ptr %%source)
+  %%si_cell = getelementptr [4 x %s], ptr %%out, i32 0, i32 1
+  %%cx_cell = getelementptr [4 x %s], ptr %%out, i32 0, i32 2
+  %%flags_cell = getelementptr [4 x %s], ptr %%out, i32 0, i32 3
+  %%ax = load %s, ptr %%out
+  %%si = load ptr, ptr %%si_cell
+  %%same_si = icmp eq ptr %%si, %%source
+  %%cx = load %s, ptr %%cx_cell
+  %%flags = load %s, ptr %%flags_cell
+  %%r0 = insertvalue %s undef, %s %%ax, 0
+  %%r1 = insertvalue %s %%r0, i1 %%same_si, 1
+  %%r2 = insertvalue %s %%r1, %s %%cx, 2
+  %%r3 = insertvalue %s %%r2, %s %%flags, 3
+  ret %s %%r3
+}
+`, result, row.name, typ, row.name, typ, typ, typ, typ, typ, typ,
+		result, typ, result, result, typ, result, typ, result)
+}
+
+func TestX86LODSZeroCountOriginalGoAndLLVMWholeState(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete LODS state objects require LLVM22 llc")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations := x86LODSStateFixture(arch)
+		goAssemblerOracleOutput(t, arch, source, "", true)
+		triple, word := "x86_64-unknown-linux-gnu", 8
+		if arch == "386" {
+			triple, word = "i386-unknown-linux-gnu", 4
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil {
+					t.Fatal("complete original fixture did not reach its state observer", err)
+				}
+				for _, row := range x86LODSStateCases(arch) {
+					if row.prefix != "" && row.count == 0 {
+						ir += x86LODSZeroStateObserver(row)
+					}
+				}
+				ir = x86LODSStateTargetLayout(t, ir, triple, word)
+				optimized := x86UndefinedTrapOptimizedIR(t, ir)
+				for _, row := range x86LODSStateCases(arch) {
+					// Keep the complete original matrix in this same module. The
+					// nonzero/bare cases are not silently replaced by zero cases.
+					x86StringMemoryFunction(t, optimized, row.name)
+					if row.prefix == "" || row.count != 0 {
+						continue
+					}
+					body := x86StringMemoryFunction(t, optimized, "observe_"+row.name)
+					if err := x86LODSCheckZeroOutputStores(body, row); err != nil {
+						t.Errorf("zero count changed complete AX, source SI, CX or initialized FLAGS: %s/%s/count0/backward=%t\n%v\n%s",
+							arch, row.op, row.backward, err, body)
+					}
+				}
+				for _, stage := range []struct{ name, ir string }{{"ir0", ir}, {"ir2", optimized}} {
+					for _, backend := range []string{"-O0", "-O2"} {
+						t.Run(stage.name+"/backend"+backend[2:], func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, triple, stage.ir, backend)
+						})
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_lods_zero_state_test.go b/x86_lods_zero_state_test.go
new file mode 100644
index 000000000..8b19dfff4
--- /dev/null
+++ b/x86_lods_zero_state_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86LODSStateCase struct {
+	name, arch, op, prefix string
+	width, count           int
+	backward               bool
+}
+
+type x86LODSStateReference struct {
+	ax, cx, flags uint64
+	siDelta       int
+}
+
+func x86LODSStateCases(arch string) []x86LODSStateCase {
+	var cases []x86LODSStateCase
+	for _, width := range []struct {
+		suffix string
+		bytes  int
+	}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+		if arch == "386" && width.bytes == 8 {
+			continue
+		}
+		for _, prefix := range []string{"", "REP", "REPN"} {
+			for _, count := range []int{0, 3} {
+				for _, backward := range []bool{false, true} {
+					cases = append(cases, x86LODSStateCase{
+						name: fmt.Sprintf("lodsstate%d", len(cases)), arch: arch,
+						op: "LODS" + width.suffix, prefix: prefix,
+						width: width.bytes, count: count, backward: backward,
+					})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func x86LODSStateSeed(arch string) uint64 {
+	if arch == "386" {
+		return 0x55667788
+	}
+	return 0x1122334455667788
+}
+
+// The reference models only the explicit initialized fixture state. It never
+// gives an unspecified incoming register byte a value or authenticates memory.
+func x86LODSStateExpected(row x86LODSStateCase) x86LODSStateReference {
+	executions := row.count
+	if row.prefix == "" {
+		executions = 1 // Without REP/REPN, CX does not suppress the instruction.
+	}
+	state := x86LODSStateReference{ax: x86LODSStateSeed(row.arch), cx: uint64(row.count), flags: 0x890}
+	step := row.width
+	if row.backward {
+		step = -step
+		state.flags |= 1 << 10
+	}
+	if executions != 0 {
+		address := 32 + (executions-1)*step
+		var value uint64
+		for index := 0; index < row.width; index++ {
+			value |= uint64(byte((address+index)*37+11)) << (8 * index)
+		}
+		if row.width >= 4 {
+			state.ax = value
+		} else {
+			mask := uint64(1)<<(8*row.width) - 1
+			state.ax = state.ax&^mask | value
+		}
+	}
+	state.siDelta = executions * step
+	if row.prefix != "" {
+		state.cx = 0
+	}
+	return state
+}
+
+func x86LODSStateFixture(arch string) (string, string) {
+	word, move, typ, push, pop := 8, "MOVQ", "uint64", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		word, move, typ, push, pop = 4, "MOVL", "uint32", "PUSHFL", "POPL"
+	}
+	var source, declarations strings.Builder
+	for _, row := range x86LODSStateCases(arch) {
+		fmt.Fprintf(&declarations, "func %s(out *%s, src *byte)\n", row.name, typ)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s src+%d(FP),SI\n",
+			row.name, 2*word, move, move, word)
+		// 0x7f+1 defines all six status flags: AF/SF/OF set, CF/PF/ZF clear.
+		// The subsequent moves preserve them. Every accumulator byte is real
+		// initialized numerical fixture data, including a nonzero AMD64 high32.
+		fmt.Fprintf(&source, "MOVB $127,AL\nADDB $1,AL\n%s $%d,AX\n%s $%d,CX\n",
+			move, x86LODSStateSeed(arch), move, row.count)
+		if row.backward {
+			source.WriteString("STD\n")
+		} else {
+			source.WriteString("CLD\n")
+		}
+		if row.prefix != "" {
+			source.WriteString(row.prefix + "\n")
+		}
+		source.WriteString(row.op + "\n")
+		fmt.Fprintf(&source, "%s AX,0(DI)\n%s SI,%d(DI)\n%s CX,%d(DI)\n%s\n%s AX\n",
+			move, move, word, move, 2*word, push, pop)
+		// Snapshot only the six status bits and DF. The observer does not
+		// invent the remaining native FLAGS bits or claim they are portable.
+		and := "ANDQ"
+		if arch == "386" {
+			and = "ANDL"
+		}
+		fmt.Fprintf(&source, "%s $0xcd5,AX\n%s AX,%d(DI)\nCLD\nRET\n", and, move, 3*word)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86LODSStateCompleteIndependentCases(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		cases := x86LODSStateCases(arch)
+		want := 48
+		if arch == "386" {
+			want = 36
+		}
+		if len(cases) != want {
+			t.Fatal("complete width/prefix/count/direction denominator changed", arch, len(cases))
+		}
+		for _, row := range cases {
+			expected := x86LODSStateExpected(row)
+			if row.prefix != "" && row.count == 0 {
+				if expected.ax != x86LODSStateSeed(arch) || expected.cx != 0 || expected.siDelta != 0 {
+					t.Fatal("a zero iteration cannot create an accumulator write or pointer movement", row, expected)
+				}
+			} else if expected.siDelta == 0 {
+				t.Fatal("unprefixed count zero still executes one element", row, expected)
+			}
+			if row.width == 4 && (row.prefix == "" || row.count != 0) && expected.ax>>32 != 0 {
+				t.Fatal("an executed dword load must zero the AMD64 high half", row, expected)
+			}
+			if expected.flags&^uint64(0xcd5) != 0 || expected.flags&0x8d5 != 0x890 {
+				t.Fatal("fixture invented unspecified FLAGS or changed the initialized six status bits", row, expected)
+			}
+		}
+		source, _ := x86LODSStateFixture(arch)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil || len(file.Funcs) != want {
+			t.Fatal("complete actual source fixture lost a function", arch, err)
+		}
+	}
+}
+
+func TestX86LODSZeroCountDoesNotCreateResultFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, result := range []struct{ typ, store string }{
+				{"uint32", "MOVL AX"}, {"bool", "MOVB AL"},
+			} {
+				body := "MOVL $0,CX\nCLD\n" + prefix + "\nLODSL\n" + result.store + ",ret+0(FP)\nRET"
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() "+result.typ, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("zero iterations manufactured NUM/canonical knowledge from an unspecified accumulator", arch, prefix, result.typ, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_logical_386_bool_numeric_alias_test.go b/x86_logical_386_bool_numeric_alias_test.go
new file mode 100644
index 000000000..3e5c7e9c1
--- /dev/null
+++ b/x86_logical_386_bool_numeric_alias_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// A bool parameter contributes one actual initialized byte to the private
+// classic frame. Its alignment gap does not, and NUM never certifies I1 RET.
+func TestX86Logical386BoolInputHasNumericByteAliases(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86AddressMemoryTargets("386") {
+		for _, row := range []struct{ name, body string }{
+			{"read", "MOVB (AX),BX"},
+			{"copied", "MOVL AX,SI\nMOVB (SI),BX"},
+			{"affine", "LEAL 0(AX),SI\nMOVB (SI),BX"},
+			{"private-raw-byte", "MOVB $2,(AX)\nMOVB (AX),BX"},
+		} {
+			t.Run(target+"/"+row.name, func(t *testing.T) {
+				source := "TEXT ·ReadByte(SB),4,$0-5\nLEAL x+0(FP),AX\n" + row.body + "\nMOVB BX,ret+4(FP)\nRET\n"
+				x86LEAActualTargetGoObject(t, "386", target, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func ReadByte(x bool) uint8", "386", target, api)
+					if err != nil {
+						t.Fatal("actual bool input byte lost its independent numeric view", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86Logical386BoolNumericAliasesKeepByteAndCanonicalBoundaries(t *testing.T) {
+	for _, row := range []struct{ name, body string }{
+		{"padding", "MOVB 1(AX),BX"},
+		{"wide-padding", "MOVW (AX),BX"},
+		{"unwritten-result", "MOVB 4(AX),BX"},
+		{"past-frame", "MOVB 5(AX),BX"},
+		{"partial-copy", "MOVW AX,SI\nMOVB (SI),BX"},
+		{"numeric-address", "TESTL AX,AX\nMOVB (AX),BX"},
+		{"unknown-store", "MOVB DX,(AX)\nMOVB (AX),BX"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source := "TEXT ·ReadByte(SB),4,$0-5\nLEAL x+0(FP),AX\n" + row.body + "\nMOVB BX,ret+4(FP)\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func ReadByte(x bool) uint8", "386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("bool byte granted padding, undefined bytes or address data", err)
+				}
+			})
+		}
+	}
+	for _, value := range []int{2, 3, 255} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("noncanonical-%d/%s", value, api), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·ReadBool(SB),4,$0-5\nLEAL x+0(FP),AX\nMOVB $%d,(AX)\nMOVB (AX),BX\nMOVB BX,ret+4(FP)\nRET\n", value)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func ReadBool(x bool) bool", "386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("numeric byte alias supplied an unproved canonical bool return", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_logical_386_frame_alias_test.go b/x86_logical_386_frame_alias_test.go
new file mode 100644
index 000000000..a8093886f
--- /dev/null
+++ b/x86_logical_386_frame_alias_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86Logical386FrameAliasSource(body string) string {
+	return "TEXT ·FrameAlias(SB),4,$0-12\n" + body + "\nMOVL b+4(FP),AX\nMOVL AX,ret+8(FP)\nRET\n"
+}
+
+func TestX86Logical386FrameAliasesThreeAPIsAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const declaration = "func FrameAlias(a,b uint32) uint32"
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, row := range []struct{ name, body string }{
+			{"byte", "LEAL a+0(FP),SI\nMOVB $41,4(SI)"},
+			{"word", "LEAL a+0(FP),SI\nMOVW $41,4(SI)"},
+			{"long", "LEAL a+0(FP),SI\nMOVL $41,4(SI)"},
+			{"copied", "LEAL a+0(FP),SI\nMOVL SI,DI\nMOVL $41,4(DI)"},
+			{"affine", "LEAL a+0(FP),SI\nLEAL 4(SI),DI\nMOVL $41,(DI)"},
+			{"readback", "LEAL a+0(FP),SI\nMOVL $41,4(SI)\nMOVL 4(SI),BX\nMOVL BX,ret+8(FP)"},
+		} {
+			t.Run(triple+"/"+row.name, func(t *testing.T) {
+				source := x86Logical386FrameAliasSource(row.body)
+				x86LEAActualTargetGoObject(t, "386", triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", triple, api)
+					if err != nil {
+						t.Fatal("ordinary386 logical parameter copies lost a bounded alias", api, err)
+					}
+					if !strings.Contains(ir, "%classic_frame = alloca") {
+						t.Fatal("contiguous logical frame alias has no actual storage")
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86Logical386FrameAliasesCannotEscapeOrInventBytes(t *testing.T) {
+	const declaration = "func FrameAlias(a,b uint32) uint32"
+	for _, row := range []struct{ name, body string }{
+		{"negative", "LEAL a+0(FP),SI\nMOVL $41,-4(SI)"},
+		{"past-end", "LEAL a+0(FP),SI\nMOVL $41,12(SI)"},
+		{"partial-overwrite", "LEAL a+0(FP),SI\nMOVW $0,SI\nMOVL $41,4(SI)"},
+		{"index", "LEAL a+0(FP),SI\nMOVL $0,DI\nMOVL $41,4(SI)(DI*1)"},
+		{"escape", "LEAL a+0(FP),SI\nMOVL SI,ret+8(FP)"},
+		{"numeric-observation", "LEAL a+0(FP),SI\nTESTL SI,SI"},
+		{"unknown-store", "LEAL a+0(FP),SI\nMOVL DX,4(SI)"},
+		{"missing-alias-join", "MOVL a+0(FP),AX\nTESTL AX,AX\nJE joined\nLEAL a+0(FP),SI\njoined:\nMOVL $41,4(SI)"},
+		{"different-alias-join", "MOVL a+0(FP),AX\nTESTL AX,AX\nJE other\nLEAL a+0(FP),SI\nJMP joined\nother:\nLEAL b+4(FP),SI\njoined:\nMOVL $41,4(SI)"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%s/%s", row.name, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, x86Logical386FrameAliasSource(row.body), declaration,
+					"386", "i386-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("logical frame alias invented numerical/address/escape permission", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_logical_amd64_parameter_alias_test.go b/x86_logical_amd64_parameter_alias_test.go
new file mode 100644
index 000000000..7f1f2af8d
--- /dev/null
+++ b/x86_logical_amd64_parameter_alias_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86AMD64ParameterAliasFixture() (string, string, string) {
+	var source, declarations, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdbool.h>\n#include <stdio.h>\n")
+	var checks strings.Builder
+	for index, row := range []struct {
+		input, output, ctype, move string
+		width                      int
+		rawBool                    bool
+	}{
+		{"bool", "uint8", "uint8_t", "MOVB", 1, false},
+		{"uint8", "uint8", "uint8_t", "MOVB", 1, false},
+		{"uint16", "uint16", "uint16_t", "MOVW", 2, false},
+		{"uint32", "uint32", "uint32_t", "MOVL", 4, false},
+		{"uint64", "uint64", "uint64_t", "MOVQ", 8, false},
+		{"bool", "uint8", "uint8_t", "MOVB", 1, true},
+	} {
+		name := fmt.Sprint("ParameterAlias", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nLEAQ x+0(FP),AX\nMOVQ AX,SI\n", name, 8+row.width)
+		if row.rawBool {
+			source.WriteString("MOVB $2,(SI)\n")
+		}
+		fmt.Fprintf(&source, "%s (SI),BX\n%s BX,ret+8(FP)\nRET\n", row.move, row.move)
+		fmt.Fprintf(&declarations, "func %s(x %s) %s\n", name, row.input, row.output)
+		input, want := row.ctype, "value"
+		if row.input == "bool" {
+			input = "bool"
+		}
+		if row.rawBool {
+			want = "2"
+		}
+		fmt.Fprintf(&driver, "extern %s %s(%s);\n", row.ctype, name, input)
+		fmt.Fprintf(&checks, `        {
+            %s value=(%s)values[index];
+            %s got=%s(value);
+            if (got!=(%s)%s) {
+                fprintf(stderr,"parameter alias row=%d input=%%llx got=%%llx\n",
+                    (unsigned long long)value,(unsigned long long)got);
+                return 1;
+            }
+        }
+`, input, input, row.ctype, name, row.ctype, want, index)
+	}
+	driver.WriteString(`int main(void) {
+    const uint64_t values[]={0,1,0x80,255,0x100,0x12345678,UINT64_MAX};
+    for (unsigned index=0;index<sizeof(values)/sizeof(values[0]);++index) {
+`)
+	driver.WriteString(checks.String())
+	driver.WriteString("    }\n    return 0;\n}\n")
+	return source.String(), declarations.String(), driver.String()
+}
+
+func TestX86LogicalAMD64ParameterFieldAliasesThreeTargetsAndAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source, declarations, _ := x86AMD64ParameterAliasFixture()
+	for _, triple := range x86AddressMemoryTargets("amd64") {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("bounded logical parameter field lost its actual backing", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86LogicalAMD64ParameterAliasesKeepSeparateFieldBounds(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"padding", "func Bound(x byte) uint32", "MOVB 1(AX),BX"},
+		{"neighbor", "func Bound(x,y uint32) uint32", "MOVL 4(AX),BX"},
+		{"partial-copy", "func Bound(x uint32) uint32", "MOVL AX,SI\nMOVL (SI),BX"},
+		{"numeric-address", "func Bound(x uint32) uint32", "TESTQ AX,AX\nMOVL (AX),BX"},
+		{"unknown-store", "func Bound(x uint32) uint32", "MOVL DX,(AX)\nMOVL (AX),BX"},
+		{"index", "func Bound(x uint32) uint32", "MOVL $0,SI\nMOVL (AX)(SI*1),BX"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source := "TEXT ·Bound(SB),4,$0-12\nLEAQ x+0(FP),AX\n" + row.body + "\nMOVL BX,ret+8(FP)\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("separate scalar allocas supplied contiguous or numeric address authority", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86LogicalAMD64ParameterAliasesPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	source, declarations, driver := x86AMD64ParameterAliasFixture()
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "parameter-field-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_logical_auto_private_stack_test.go b/x86_logical_auto_private_stack_test.go
new file mode 100644
index 000000000..ed37ecef5
--- /dev/null
+++ b/x86_logical_auto_private_stack_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86LogicalAUTOProjectionRequiresCompleteSource(t *testing.T) {
+	file, sig, _ := x86ResultAUTOFixture(t, "386", "func Value(x uint32) uint32", 32,
+		"MOVL x+0(FP),AX\nMOVL AX,saved-4(SP)\nPUSHL $7\nPOPL BX\nMOVL saved-4(SP),AX\nMOVL AX,ret0+4(FP)\nRET")
+	makeConsumer := func() *amd64Ctx {
+		fn := file.Funcs[0]
+		fn.Instrs = append([]Instr(nil), fn.Instrs...)
+		return newX86Ctx(new(strings.Builder), fn, sig,
+			func(name string) string { return strings.TrimPrefix(name, "·") }, nil,
+			"386", "i386-unknown-linux-gnu", false)
+	}
+	for _, checked := range []bool{false, true} {
+		t.Run(fmt.Sprintf("missing-or-failed-proof-%v", checked), func(t *testing.T) {
+			consumer := makeConsumer()
+			consumer.fpScalarChecked = checked
+			if checked {
+				consumer.fpScalarCheckErr = ErrProbeNeedsContext
+			}
+			if err := consumer.prepareLogicalAUTOStorage(); err != nil || consumer.logicalAUTOExtent != 0 || consumer.logicalAUTOBase != "" {
+				t.Fatal("missing/failed source proof supplied logical storage", err)
+			}
+		})
+	}
+	for _, mutation := range []string{"unchanged", "changed-frame", "changed-literal"} {
+		t.Run(mutation, func(t *testing.T) {
+			consumer := makeConsumer()
+			if err := consumer.scalarFPResultInitialized(); err != nil {
+				t.Fatal("independent complete source rejected", err)
+			}
+			switch mutation {
+			case "changed-frame":
+				consumer.frameSize *= 2
+			case "changed-literal":
+				consumer.fpScalarSource.Instrs[2].Raw = "MOVL AX,-4(SP)"
+			}
+			err := consumer.emitEntryAllocas()
+			if mutation != "unchanged" {
+				if !errors.Is(err, ErrProbeNeedsContext) || consumer.logicalAUTOBase != "" {
+					t.Fatal("changed source revived a cached storage projection", err)
+				}
+				return
+			}
+			if err != nil || consumer.logicalAUTOExtent != 32 || consumer.logicalAUTOBase == "" {
+				t.Fatal("complete ordinary source lost its immutable entry base", err)
+			}
+			for _, memory := range []MemRef{
+				{Base: SP, Off: -33}, {Base: SP}, {Base: SP, Off: -4, OffRaw: "missing"},
+				{Base: SP, Off: -4, Index: AX}, {Base: SP, Off: -4, Scale: 2},
+				{Base: SP, Off: -4, Segment: FS},
+			} {
+				address, recognized, err := consumer.logicalAUTOAddress(memory)
+				if !recognized || !errors.Is(err, ErrProbeNeedsContext) || address != "" {
+					t.Fatal("unbound address borrowed logical AUTO bytes", memory, err)
+				}
+			}
+			// Go's 386 SB Reg annotation is ignored, not a physical SP input.
+			memory := MemRef{Base: SP, Sym: "literal(SB)"}
+			if _, recognized, err := consumer.logicalAUTOAddress(memory); recognized || err != nil {
+				t.Fatal("logical AUTO projection captured an independent static-symbol role", err)
+			}
+		})
+	}
+}
+
+func TestX86LogicalAUTOStaticSPAnnotationKeepsIndependentRole(t *testing.T) {
+	const source = `DATA literal<>+0(SB)/4,$0x12345678
+GLOBL literal<>(SB),8,$4
+TEXT ·StaticAUTO(SB),4,$32-8
+MOVL value+0(FP),AX
+MOVL AX,saved-4(SP)
+PUSHL $7
+POPL BX
+MOVL literal<>(SB)(SP),BX
+MOVL saved-4(SP),AX
+XORL BX,AX
+MOVL AX,ret+4(FP)
+RET
+`
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func StaticAUTO(value uint32) uint32", "386", triple, api)
+				if err != nil {
+					t.Fatal("logical AUTO captured Go's independent ignored SP annotation", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+// The original Go AUTO address is above the post-prologue SP. Private PUSH
+// storage is below it. Keep those distinct even though parsed AUTO offsets
+// are negative. No physical SP/address or native frame permission is supplied.
+func x86LogicalAUTOPrivateStackSources(arch string) (string, string, string) {
+	word, typ, ctype, bytes := "Q", "uint64", "uint64_t", 8
+	if arch == "386" {
+		word, typ, ctype, bytes = "L", "uint32", "uint32_t", 4
+	}
+	var source, declarations, driver strings.Builder
+	fmt.Fprintf(&driver, "#include <stdint.h>\n#include <stdio.h>\ntypedef %s word;\n", ctype)
+	var checks strings.Builder
+	for index, push := range []string{"PUSHW $7", "PUSH" + word + " $7", "PUSHFW", "PUSHF" + word} {
+		pop := "POP" + word + " BX"
+		if index == 0 || index == 2 {
+			pop = "POPW BX"
+		}
+		name := fmt.Sprintf("AutoStack%d", index)
+		fmt.Fprintf(&source, `TEXT ·%s(SB),4,$32-%d
+PUSH%s $2
+POPF%s
+MOV%s value+0(FP),AX
+MOV%s AX,saved-%d(SP)
+%s
+%s
+MOV%s saved-%d(SP),AX
+MOV%s AX,ret+%d(FP)
+RET
+`, name, 2*bytes, word, word, word, word, bytes, push, pop, word, bytes, word, bytes)
+		fmt.Fprintf(&declarations, "func %s(value %s) %s\n", name, typ, typ)
+		fmt.Fprintf(&driver, "extern word %s(word);\n", name)
+		fmt.Fprintf(&checks, `{
+    word got=%s(value);
+    if(got!=value) {
+        fprintf(stderr,"AUTO/private-stack row=%d value=%%llx got=%%llx\n",
+            (unsigned long long)value,(unsigned long long)got);
+        return 1;
+    }
+}
+`, name, index)
+	}
+	driver.WriteString(`int main(void) {
+    const word values[]={0,1,7,255,256,65535,65536,UINT32_MAX,(word)UINT64_MAX,
+        (word)UINT64_C(0x1122334455667788),(word)UINT64_C(0x8000000000000000)};
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++) {
+        word value=values[i];
+`)
+	driver.WriteString(checks.String())
+	driver.WriteString("    }\n    return 0;\n}\n")
+	return source.String(), declarations.String(), driver.String()
+}
+
+func TestX86LogicalAUTOPrivateStackFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _ := x86LogicalAUTOPrivateStackSources(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86LogicalAUTOPrivateStackPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, driver := x86LogicalAUTOPrivateStackSources(arch)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []int{0, 2} {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "auto-private-stack-values", triple, text, driver, nil, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_logical_compare_input_obligation_test.go b/x86_logical_compare_input_obligation_test.go
new file mode 100644
index 000000000..ee566e61a
--- /dev/null
+++ b/x86_logical_compare_input_obligation_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These inventories are independent of the production maps and bind the
+// complete Go logical and packed EQ/GT families. A dead result cannot excuse
+// an unknown native address, even without a KMOV or FP result-store selector.
+func TestX86LogicalCompareVoidNativeInputsCannotBypassWholeProof(t *testing.T) {
+	names := append([]string(nil), x86PackedIntegerCompareTestNames...)
+	for _, group := range x86LogicalNativeGroups {
+		names = append(names, group...)
+	}
+	if len(names) != 48 {
+		t.Fatal("independent logical/compare family inventory changed", len(names))
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, unusedBool := range []bool{false, true} {
+			word, move, declaration := int(goWordSize(target.arch)), "MOVQ", "func Value(p *[128]byte)"
+			if word == 4 {
+				move = "MOVL"
+			}
+			extent := word
+			if unusedBool {
+				declaration = "func Value(p *[128]byte, unused bool)"
+				extent++
+			}
+			var original strings.Builder
+			for ordinal, op := range names {
+				banks := []string{"X"}
+				if strings.HasPrefix(op, "V") {
+					banks = append(banks, "Y")
+					if op != "VPAND" && op != "VPANDN" && op != "VPOR" && op != "VPXOR" {
+						banks = append(banks, "Z")
+					}
+				}
+				for _, bank := range banks {
+					instruction := op + " 3(AX)(DX*2)," + bank + "1"
+					if strings.HasPrefix(op, "V") {
+						destination := bank + "1"
+						if strings.HasPrefix(op, "VPCMP") && bank == "Z" {
+							destination = "K2"
+						}
+						instruction = op + " 3(AX)(DX*2)," + bank + "0," + destination
+					}
+					prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\nVZEROALL\n", extent, move)
+					source := prefix + instruction + "\nRET\n"
+					variants := []struct{ name, source string }{
+						{"initialized", source},
+						{"unknown-pointer", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+						{"numerical-pointer", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+						{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+					}
+					for index, variant := range variants {
+						name := fmt.Sprintf("Value%d%sCase%d", ordinal, bank, index)
+						original.WriteString(strings.Replace(variant.source, "·Value(SB)", "·"+name+"(SB)", 1))
+					}
+					t.Run(fmt.Sprintf("%s/bool%t/%s/%s", target.triple, unusedBool, op, bank), func(t *testing.T) {
+						for _, variant := range variants {
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, variant.source, declaration, target.arch, target.triple, api)
+								if variant.name == "initialized" || variant.name == "numerical-pointer" {
+									if err != nil || ir == "" {
+										t.Fatal("complete Void native inputs rejected", api, err)
+									}
+									if variant.name == "numerical-pointer" {
+										x86RequireNumericNativeSourceContext(t, variant.source, declaration, target.arch)
+										width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+										read := false
+										if !strings.HasPrefix(op, "V") {
+											mnemonic := strings.ToLower(op)
+											if strings.HasPrefix(op, "PCMP") && strings.HasSuffix(op, "L") {
+												mnemonic = strings.TrimSuffix(mnemonic, "l") + "d"
+											}
+											read = strings.Contains(ir, "call <4 x float> asm sideeffect \""+mnemonic+" ") && strings.Contains(ir, "~{memory}")
+										} else {
+											for _, bits := range []int{8, 16, 32, 64} {
+												read = read || strings.Contains(ir, fmt.Sprintf("load volatile <%d x i%d>", width*8/bits, bits))
+											}
+										}
+										if !read {
+											t.Fatal("numerical address lost the compare/logical exact-width native read", variant.name, api, ir)
+										}
+										x86NumericNativeAddressObject(t, ir, target.triple)
+									}
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Errorf("%s/%s: missing native input bypassed the whole proof: %v", variant.name, api, err)
+								}
+							}
+						}
+					})
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, original.String())
+		}
+	}
+}
diff --git a/x86_logical_floating_field_address_runtime_test.go b/x86_logical_floating_field_address_runtime_test.go
new file mode 100644
index 000000000..a5a1c1f25
--- /dev/null
+++ b/x86_logical_floating_field_address_runtime_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86LogicalFloatingFieldAddressPortableExactBits(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	var source, declarations strings.Builder
+	for _, kind := range []string{"float32", "float64"} {
+		extent, move := 16, "MOVSS"
+		if kind == "float64" {
+			move = "MOVSD"
+		} else if arch == "386" {
+			extent = 8
+		}
+		for _, operation := range []string{"Copy", "Zero"} {
+			body, declaration := x86LogicalFloatingFieldCopy(arch, kind, extent)
+			if operation == "Zero" {
+				body = strings.Replace(body, move+" (AX),X0", "PXOR X1,X1\n"+move+" X1,(AX)\n"+move+" (AX),X0", 1)
+			}
+			name := operation + kind
+			source.WriteString(strings.ReplaceAll(body, "Value", name))
+			declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "logical-floating-fields", text, x86LogicalFloatingFieldBitDriver, level)
+				}
+			}
+		})
+	}
+	t.Log("portable LLVM exact bits and private-copy canaries; not native original x86 execution")
+}
+
+const x86LogicalFloatingFieldBitDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern float Copyfloat32(float), Zerofloat32(float);
+extern double Copyfloat64(double), Zerofloat64(double);
+int main(void) {
+    const uint64_t edges[]={0,UINT64_MAX,1,UINT64_C(0x8000000080000000),
+        0x007fffff,0x00800000,0x3f800000,0x7f800000,0xff800000,0x7fc12345,0x7f800123,
+        UINT64_C(0x000fffffffffffff),UINT64_C(0x0010000000000000),
+        UINT64_C(0x3ff0000000000000),UINT64_C(0x7ff0000000000000),
+        UINT64_C(0xfff0000000000000),UINT64_C(0x7ff8000012345678),
+        UINT64_C(0x7ff0000012345678)};
+    for (unsigned row=0;row<sizeof(edges)/sizeof(edges[0])+257;++row) {
+        uint64_t input=row<sizeof(edges)/sizeof(edges[0]) ? edges[row] :
+            row*UINT64_C(0x9e3779b97f4a7c15);
+        uint32_t small=(uint32_t)input;
+        struct {uint64_t left,got[4],right;} output;
+        memset(&output,0xa7,sizeof(output));
+        float f,fs; double d,ds;
+        memcpy(&f,&small,4); memcpy(&d,&input,8);
+        fs=Copyfloat32(f); uint32_t bits;
+        memcpy(&bits,&fs,4); output.got[0]=bits;
+        ds=Copyfloat64(d); memcpy(&output.got[1],&ds,8);
+        fs=Zerofloat32(f); memcpy(&bits,&fs,4); output.got[2]=bits;
+        ds=Zerofloat64(d); memcpy(&output.got[3],&ds,8);
+        uint32_t afterSmall; uint64_t afterLarge;
+        memcpy(&afterSmall,&f,4); memcpy(&afterLarge,&d,8);
+        const uint64_t want[]={small,input,0,0};
+        if (memcmp(output.got,want,sizeof(want)) || afterSmall!=small || afterLarge!=input ||
+            output.left!=UINT64_C(0xa7a7a7a7a7a7a7a7) ||
+            output.right!=UINT64_C(0xa7a7a7a7a7a7a7a7)) {
+            fprintf(stderr,"floating logical field row=%u bits/private-copy/canary\n",row);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_logical_floating_field_address_test.go b/x86_logical_floating_field_address_test.go
new file mode 100644
index 000000000..314f1fde7
--- /dev/null
+++ b/x86_logical_floating_field_address_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86LogicalFloatingFieldCopy(arch, kind string, extent int) (string, string) {
+	lea, result := "LEAQ", 8
+	if arch == "386" {
+		lea = "LEAL"
+		if kind == "float32" {
+			result = 4
+		}
+	}
+	move := "MOVSS"
+	if kind == "float64" {
+		move = "MOVSD"
+	}
+	return fmt.Sprintf("TEXT Value(SB),4,$0-%d\n%s x+0(FP),AX\n%s (AX),X0\n"+
+			"%s ret+%d(FP),BX\n%s X0,(BX)\nRET\n", extent, lea, move, lea, result, move),
+		fmt.Sprintf("func Value(x %s) %s", kind, kind)
+}
+
+// Isolate logical storage from SQRT's arithmetic effect in the unchanged
+// SqrtByAddress reproducer. One field is not a contiguous incoming ABI0 frame.
+func TestX86LogicalFloatingFieldAddressCopyThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []string{"float32", "float64"} {
+			extents := []int{16}
+			if kind == "float32" {
+				if target.arch == "386" {
+					extents = []int{8}
+				} else {
+					extents = []int{12, 16} // Logical end and rounded native allocation.
+				}
+			}
+			for _, extent := range extents {
+				t.Run(fmt.Sprintf("%s/%s/extent-%d", target.triple, kind, extent), func(t *testing.T) {
+					source, declaration := x86LogicalFloatingFieldCopy(target.arch, kind, extent)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil {
+							t.Error("exact typed floating fields lost their private logical storage", api, err)
+							continue
+						}
+						for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LogicalFloatingFieldAddressKeepsIndependentBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []string{"float32", "float64"} {
+			move, wordMove, lea, width, result, extent := "MOVSS", "MOVQ", "LEAQ", 4, 8, 16
+			if kind == "float64" {
+				move, width = "MOVSD", 8
+			}
+			if target.arch == "386" {
+				wordMove, lea = "MOVL", "LEAL"
+				if kind == "float32" {
+					result, extent = 4, 8
+				}
+			}
+			source, declaration := x86LogicalFloatingFieldCopy(target.arch, kind, extent)
+			resultAddress := fmt.Sprintf("ret+%d(FP)", result)
+			for _, mutation := range []struct{ name, before, after string }{
+				{"parameter-one-past", "x+0(FP),AX", fmt.Sprintf("x+%d(FP),AX", width)},
+				{"result-one-past", resultAddress + ",BX", fmt.Sprintf("ret+%d(FP),BX", result+width)},
+				{"uninitialized-result", "x+0(FP),AX", resultAddress + ",AX"},
+				{"cross-field-read", move + " (AX),X0", "MOVUPS (AX),X0"},
+				{"address-as-data", move + " X0,(BX)", wordMove + " AX,X0\n" + move + " X0,(BX)"},
+				{"physical-SP", lea + " x+0(FP),AX\n" + move + " (AX),X0", lea + " x+0(FP),SP\n" + move + " (SP),X0"},
+				{"unknown-store", move + " X0,(BX)", move + " X1,(BX)"},
+				{"indexed-address", move + " (AX),X0", "MOVL $0,CX\n" + move + " (AX)(CX*1),X0"},
+			} {
+				t.Run(target.triple+"/"+kind+"/"+mutation.name, func(t *testing.T) {
+					changed := strings.Replace(source, mutation.before, mutation.after, 1)
+					if changed == source {
+						t.Fatal("negative source mutation was not applied")
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, changed)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api)
+						if target.arch == "amd64" && mutation.name == "unknown-store" {
+							x86VectorScratchCodegenControl(t, changed, declaration, target.arch, target.triple, ir, err)
+							continue
+						}
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("floating field acquired padding, unknown data or native state authority", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+// Parameter fields already have mutable private logical copies, not incoming
+// caller backing. A store confined to that copy is valid, unlike an address
+// escape or a write into padding. Keep the same contract for floating bytes.
+func TestX86LogicalFloatingFieldAddressPrivateParameterCopy(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []string{"float32", "float64"} {
+			t.Run(target.triple+"/"+kind, func(t *testing.T) {
+				extent := 16
+				if target.arch == "386" && kind == "float32" {
+					extent = 8
+				}
+				source, declaration := x86LogicalFloatingFieldCopy(target.arch, kind, extent)
+				move := "MOVSS"
+				if kind == "float64" {
+					move = "MOVSD"
+				}
+				source = strings.Replace(source, move+" (AX),X0", "PXOR X1,X1\n"+move+" X1,(AX)\n"+move+" (AX),X0", 1)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Error("private logical parameter-copy store failed", api, err)
+						continue
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, findLLVM22Tool("llc"), target.triple, ir, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_logical_native_continuation_test.go b/x86_logical_native_continuation_test.go
new file mode 100644
index 000000000..c97401c27
--- /dev/null
+++ b/x86_logical_native_continuation_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent yxm/ymm, _yvandnpd, _yvaddsubpd and _yvblendmpd inventory.
+// Each group retains the legacy X bank; physical MMX has its separate owner.
+var x86LogicalNativeGroups = [][]string{
+	{"ANDPS", "ANDPD", "PAND", "VANDPS", "VANDPD", "VPAND", "VPANDD", "VPANDQ"},
+	{"ANDNPS", "ANDNPD", "PANDN", "VANDNPS", "VANDNPD", "VPANDN", "VPANDND", "VPANDNQ"},
+	{"ORPS", "ORPD", "POR", "VORPS", "VORPD", "VPOR", "VPORD", "VPORQ"},
+	{"XORPS", "XORPD", "PXOR", "VXORPS", "VXORPD", "VPXOR", "VPXORD", "VPXORQ"},
+}
+
+func x86LogicalNativeRows(arch string, groups [][]string) []struct{ op, bank, mode string } {
+	var rows []struct{ op, bank, mode string }
+	for _, group := range groups {
+		for index, op := range group {
+			if index == 5 {
+				// These four integer names are VEX-only: X/Y, no mask or suffix.
+				for _, bank := range []string{"X", "Y"} {
+					rows = append(rows, struct{ op, bank, mode string }{op, bank, "plain"})
+				}
+				continue
+			}
+			rows = append(rows, x86FixedBinaryValueRows(arch, []string{op})...)
+			if index >= 3 {
+				rows = append(rows, x86FixedBinaryValueRows(arch, []string{op + ".BCST"})...)
+			}
+		}
+	}
+	return rows
+}
+
+func x86LogicalNativeGroupObjects(t *testing.T, group int) {
+	t.Helper()
+	x86FixedBinaryCompleteFamilyObjects(t, func(arch string) []struct{ op, bank, mode string } {
+		return x86LogicalNativeRows(arch, x86LogicalNativeGroups[group:group+1])
+	}, 77, 29)
+}
+
+func TestX86LogicalNativeAndCompleteObjects(t *testing.T) {
+	x86LogicalNativeGroupObjects(t, 0)
+}
+
+func TestX86LogicalNativeAndNotCompleteObjects(t *testing.T) {
+	x86LogicalNativeGroupObjects(t, 1)
+}
+
+func TestX86LogicalNativeOrCompleteObjects(t *testing.T) {
+	x86LogicalNativeGroupObjects(t, 2)
+}
+
+func TestX86LogicalNativeXorCompleteObjects(t *testing.T) {
+	x86LogicalNativeGroupObjects(t, 3)
+}
+
+func TestX86LogicalNativeReadCannotBorrowSourceFacts(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, func(arch string) []struct{ op, bank, mode string } {
+		return x86LogicalNativeRows(arch, x86LogicalNativeGroups)
+	})
+}
+
+func TestX86LogicalNativeEmitterRetainsDeadReadEffects(t *testing.T) {
+	rows := x86LogicalNativeRows("amd64", x86LogicalNativeGroups)
+	if len(rows) != 308 {
+		t.Fatal("independent complete native logical inventory changed", len(rows))
+	}
+	for _, row := range rows {
+		t.Run(row.op+"/"+row.bank+"/"+row.mode, func(t *testing.T) {
+			wanted, _, _ := strings.Cut(row.op, ".")
+			bits := 32
+			if strings.HasSuffix(wanted, "PD") || strings.HasSuffix(wanted, "Q") {
+				bits = 64
+			}
+			source, _ := x86FixedBinaryValueFixture("amd64", row.op, row.bank, row.mode, false)
+			file := mustParseX86RawReturn(t, source)
+			var instruction Instr
+			matches := 0
+			for _, ins := range file.Funcs[0].Instrs {
+				name, _, _ := strings.Cut(string(ins.Op), ".")
+				if name == wanted && len(ins.Args) > 0 && ins.Args[0].Kind == OpMem {
+					instruction = ins
+					matches++
+				}
+			}
+			if matches != 1 {
+				t.Fatal("emitter fixture lost its exact original memory operation", matches)
+			}
+			// This is an emitter-only observation, not a caller/NUM certificate.
+			consumer, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+			before := output.Len()
+			known, _, err := consumer.lowerPackedLogicalFamily(instruction.Op, instruction)
+			if !known || err != nil {
+				t.Fatal("valid original logical form rejected by its emitter", instruction.Raw, err)
+			}
+			text := output.String()[before:]
+			if !strings.HasPrefix(row.op, "V") {
+				if !strings.Contains(text, "asm sideeffect \""+strings.ToLower(row.op)) {
+					t.Fatal("legacy dead read lost its original memory opcode", instruction.Raw)
+				}
+				return
+			}
+			if row.mode != "plain" {
+				if !strings.Contains(text, fmt.Sprintf("load volatile i%d", bits)) || !strings.Contains(text, "br i1") {
+					t.Fatal("dead masked logical read lost its E4 conditional volatile access", instruction.Raw)
+				}
+				return
+			}
+			width := amd64VectorByteWidth(Reg(row.bank + "0"))
+			if strings.Contains(row.op, ".BCST") {
+				width = bits / 8
+			}
+			if !strings.Contains(text, fmt.Sprintf("load volatile <%d x i8>", width)) {
+				t.Fatal("dead unmasked logical read lost its complete volatile width", instruction.Raw)
+			}
+		})
+	}
+}
diff --git a/x86_logical_scalar_result_test.go b/x86_logical_scalar_result_test.go
new file mode 100644
index 000000000..38a3b8890
--- /dev/null
+++ b/x86_logical_scalar_result_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// A zero-argument manual signature uses the existing logical AX return
+// transport. It is not an assertion about Go ABI0, ABIInternal or native entry.
+func TestX86Mode32LogicalScalarReturnMustBeInitialized(t *testing.T) {
+	for _, row := range []struct {
+		typ   LLVMType
+		store string
+	}{
+		{I8, "MOVB"}, {I16, "MOVW"}, {I32, "MOVL"},
+	} {
+		for _, sample := range []struct {
+			name, value string
+			pass        bool
+		}{
+			{"initialized", row.store + " $7,AX\n", true},
+			{"missing", "", false},
+			{"wrong-register", row.store + " $7,BX\n", false},
+			{"one-path-only", "MOVL $1,DX\nCMPL DX,$0\nJE done\n" + row.store + " $7,AX\ndone:\n", false},
+		} {
+			// A private bit-preserving FLAGS copy does not expose its unknown
+			// bits. It also cannot manufacture missing AX result bytes.
+			source := "TEXT ·logical(SB),4,$0-0\nPUSHFL\nPOPL CX\n" + sample.value + "RET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sig := FuncSig{Name: "logical", Ret: row.typ}
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", row.typ, sample.name, api), func(t *testing.T) {
+					options := Options{
+						Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+						Sigs:       map[string]FuncSig{"logical": sig},
+						ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+					}
+					ir, err := x86PackedFloatStorageAPI(api, file, options)
+					if sample.pass && (err != nil || ir == "") ||
+						!sample.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("logical AX result proof disagrees with actual reaching bytes", sample.pass, err)
+					}
+				})
+			}
+			if !errors.Is(CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "386"), ErrProbeNeedsContext) {
+				t.Fatal("manual logical return invented a Go ABI0 declaration")
+			}
+		}
+	}
+}
+
+func TestX86Mode32LogicalScalarReturnRoleBoundaries(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·logical(SB),4,$0-0\nMOVL $7,AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+		return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+	}
+	for name, mutate := range map[string]func(*Func, *FuncSig){
+		"wide-result":      func(_ *Func, sig *FuncSig) { sig.Ret = I64 },
+		"pointer-result":   func(_ *Func, sig *FuncSig) { sig.Ret = Ptr },
+		"bool-result":      func(_ *Func, sig *FuncSig) { sig.Ret = I1 },
+		"incoming-value":   func(_ *Func, sig *FuncSig) { sig.Args = []LLVMType{I32} },
+		"register-input":   func(_ *Func, sig *FuncSig) { sig.ArgRegs = []Reg{AX} },
+		"FP-result":        func(_ *Func, sig *FuncSig) { sig.Frame.Results = []FrameSlot{{Type: I32}} },
+		"FP-parameter":     func(_ *Func, sig *FuncSig) { sig.Frame.Params = []FrameSlot{{Type: I32}} },
+		"frame":            func(fn *Func, _ *FuncSig) { fn.FrameSize = 4 },
+		"argsize":          func(fn *Func, _ *FuncSig) { fn.ArgSize = 4 },
+		"internal-entry":   func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" },
+		"raw-source":       func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86Encoded = true },
+		"address-override": func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86AddressBits = 16 },
+		"segment":          func(fn *Func, _ *FuncSig) { fn.Instrs[1].x86SegmentPrefix = 0x64 },
+		"wasm-entry":       func(_ *Func, sig *FuncSig) { sig.WASMNative = true },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn := x86DirectTailSnapshot(file).Funcs[0]
+			sig := FuncSig{Name: "logical", Ret: I32}
+			mutate(&fn, &sig)
+			before := x86DirectTailSnapshot(&File{Arch: ArchAMD64, Funcs: []Func{fn}}).Funcs[0]
+			if err := checkX86LogicalRegisterResultInitialization(fn, sig, "386", transfer, false, false); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("logical return supplied an unrelated entry role", err)
+			}
+			if !reflect.DeepEqual(before, fn) {
+				t.Fatal("logical return proof changed its original source")
+			}
+		})
+	}
+}
+
+func TestX86Mode32LogicalScalarReturnLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("logical scalar result objects require LLVM22 llc")
+	}
+	for _, row := range []struct {
+		typ LLVMType
+		op  string
+	}{{I8, "MOVB"}, {I16, "MOVW"}, {I32, "MOVL"}} {
+		source := "TEXT ·logical(SB),4,$0-0\n" + row.op + " $7,AX\nRET\n"
+		requireX86GoAssemblerResult(t, "386", source, true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+			for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", row.typ, triple, api), func(t *testing.T) {
+					options := Options{
+						Goarch: "386", TargetTriple: triple,
+						Sigs:       map[string]FuncSig{"logical": {Name: "logical", Ret: row.typ}},
+						ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+					}
+					ir, err := x86PackedFloatStorageAPI(api, file, options)
+					if err != nil || ir == "" {
+						t.Fatal("initialized logical AX result", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Mode32LogicalScalarReturnCannotBypassProof(t *testing.T) {
+	for _, body := range []string{"", "MOVL $7,BX\n", "MOVB $7,AX\n", "MOVW $7,AX\n"} {
+		file, err := Parse(ArchAMD64, "TEXT ·logical(SB),4,$0-0\n"+body+"RET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+			t.Run(fmt.Sprintf("%q/%s", body, api), func(t *testing.T) {
+				options := Options{
+					Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+					Sigs:       map[string]FuncSig{"logical": {Name: "logical", Ret: I32}},
+					ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") },
+				}
+				ir, err := x86PackedFloatStorageAPI(api, file, options)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("missing AX bytes escaped through a cost-only proof selector", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_logical_source_bp_test.go b/x86_logical_source_bp_test.go
new file mode 100644
index 000000000..ac7c0ee95
--- /dev/null
+++ b/x86_logical_source_bp_test.go
@@ -0,0 +1,334 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PrivateStackPreservesOnlyUnwrittenGPIdentities(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range strings.Fields("PUSHW POPW PUSHL POPL PUSHQ POPQ PUSHFW POPFW PUSHFL POPFL PUSHFQ POPFQ") {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				args := " BX"
+				if strings.Contains(op, "F") {
+					args = ""
+				}
+				ins := x86ScalarLaneInstruction(t, op+args)
+				before := [16]bool{0: true, 1: true, 2: true, 3: true, 5: arch == "386", 6: true, 7: true}
+				want := before
+				invalid := arch == "386" && strings.HasSuffix(op, "Q") || arch == "amd64" && strings.HasSuffix(op, "L")
+				if invalid {
+					want = [16]bool{}
+				} else if strings.HasPrefix(op, "POP") && !strings.Contains(op, "F") {
+					want[3] = false // Any partial/full POP revokes BX's old identity.
+				}
+				if got := x86ResultCallerAddressesAfter(ins, before, nil, arch); !reflect.DeepEqual(got, want) {
+					t.Fatal("typed stack GP footprint either invented or revoked an unrelated identity", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrdinaryMemoryModeAwareFrameRegisters(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, base := range []Reg{AX, BP, SP} {
+			for _, index := range []Reg{"", AX, BP, SP} {
+				t.Run(arch+"/"+string(base)+"/"+string(index), func(t *testing.T) {
+					memory := MemRef{Base: base, Index: index}
+					if index != "" {
+						memory.Scale = 1
+					}
+					want := base != SP && index != SP && (arch == "386" || base != BP && index != BP)
+					if got := x86OrdinaryNativeMemoryOperand(Operand{Kind: OpMem, Mem: memory}, arch); got != want {
+						t.Fatal("ordinary native address classification differs from the selected GP mode", got, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DirectTailModeAwareBPRegisterRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, width, typ := "Q", 8, "uint64"
+		if target.arch == "386" {
+			word, width, typ = "L", 4, "uint32"
+		}
+		for _, row := range []struct {
+			name, setup, body string
+			complete          bool
+		}{
+			{"numerical", "MOVWORD n+0(FP),BP", "ADDWORD $7,BP\nMOVWORD BP,ret+RESULT(FP)", true},
+			{"helper-write", "NOP", "MOVWORD n+0(FP),BP\nMOVWORD BP,ret+RESULT(FP)", true},
+			{"logical-result-address", "MOVWORD n+0(FP),SI\nLEAWORD ret+RESULT(FP),BP", "MOVWORD SI,(BP)", true},
+			{"private-value-stack", "LEAWORD ret+RESULT(FP),BP", "PUSHWORD n+0(FP)\nMOVWORD $7,(BP)\nPOPWORD AX", true},
+			{"unknown-entry", "NOP", "MOVWORD BP,ret+RESULT(FP)", false},
+			{"partial-word", "MOVW $7,BP", "MOVWORD BP,ret+RESULT(FP)", false},
+			{"unknown-overwrite", "MOVWORD n+0(FP),BP", "MOVWORD CX,BP\nMOVWORD BP,ret+RESULT(FP)", false},
+			{"unbound-memory", "MOVWORD n+0(FP),BP", "MOVWORD (BP),AX\nMOVWORD AX,ret+RESULT(FP)", false},
+			{"physical-SP", "MOVWORD n+0(FP),SP", "MOVWORD SP,ret+RESULT(FP)", false},
+			{"physical-SP-memory", "NOP", "MOVWORD (SP),AX\nMOVWORD AX,ret+RESULT(FP)", false},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf(`TEXT ·Value(SB),NOSPLIT,$0-%d
+%s
+JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+%s
+RET
+`,
+						2*width, row.setup, row.body)
+					source = strings.NewReplacer("WORD", word, "RESULT", fmt.Sprint(width)).Replace(source)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(n "+typ+") "+typ, target.arch, target.triple, api)
+					wantPass := target.arch == "386" && (row.complete || row.name == "unbound-memory")
+					if wantPass {
+						if err != nil || ir == "" {
+							t.Fatal("ordinary mode32 BP lost its source-defined logical role", err)
+						}
+						if row.name == "unbound-memory" {
+							if !strings.Contains(ir, "load volatile i32,") {
+								t.Fatal("defined mode32 BP lost its exact native dword read")
+							}
+							x86RequireNumericNativeSourceContext(t, source, "func Value(n "+typ+") "+typ, target.arch)
+							x86NumericNativeAddressObject(t, ir, target.triple)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("BP classification granted an unbound register/frame/memory role", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86Mode32BPNativeLoadSource(word string, offset int, suffix, widen, setup string) string {
+	// Like the other standalone object fixtures, use Go's numeric NOSPLIT
+	// flag: the independent `go tool asm` oracle has no header include path.
+	return fmt.Sprintf(`TEXT ·Value(SB),4,$0-%d
+%s
+MOV%s (DX),BP
+%s BP,AX
+MOVL AX,X0
+PEXTRD $0,X0,AX
+MOVL AX,ret+%d(FP)
+RET
+`, offset+4, strings.ReplaceAll(setup, "WORD", word), suffix, widen, offset)
+}
+
+func TestX86Mode32BPPairedNativeLoadDefinedBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, offset := "Q", 8
+		if target.arch == "386" {
+			word, offset = "L", 4
+		}
+		for _, width := range []struct{ suffix, widen string }{
+			{"B", "MOVBLZX"}, {"W", "MOVWLZX"}, {"L", "MOVL"},
+		} {
+			for _, row := range []struct {
+				name, setup string
+				complete    bool
+			}{
+				{"incoming-pointer", "MOVWORD p+0(FP),DX", true},
+				{"unknown-pointer", "NOP", false},
+				{"partial-pointer", "MOVW p+0(FP),DX", false},
+				{"numeric-pointer", "MOVL $7,DX", false},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+width.suffix+"/"+row.name+"/"+api, func(t *testing.T) {
+						source := x86Mode32BPNativeLoadSource(word, offset, width.suffix, width.widen, row.setup)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte) uint32", target.arch, target.triple, api)
+						if target.arch == "386" && (row.complete || row.name == "numeric-pointer") {
+							bits := map[string]int{"B": 8, "W": 16, "L": 32}[width.suffix]
+							if err != nil || ir == "" || !strings.Contains(ir, fmt.Sprintf("load volatile i%d,", bits)) {
+								t.Fatal("paired native load lost its ordinary mode32 destination or original fault", err)
+							}
+							if row.name == "numeric-pointer" {
+								x86RequireNumericNativeSourceContext(t, source, "func Value(p *byte) uint32", target.arch)
+								x86NumericNativeAddressObject(t, ir, target.triple)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("paired BP load acquired unknown pointer bytes or a physical frame destination", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LogicalSourcePrivateStackWholeHelperCFG(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, width, typ := "Q", 8, "uint64"
+		if target.arch == "386" {
+			word, width, typ = "L", 4, "uint32"
+		}
+		for _, row := range []struct {
+			name, body string
+			complete   bool
+		}{
+			{"balanced", "PUSHWORD n+0(FP)\nPOPWORD AX\nMOVWORD AX,ret+RESULT(FP)", true},
+			{"unknown-input", "PUSHWORD CX\nPOPWORD AX\nMOVWORD AX,ret+RESULT(FP)", false},
+			{"unbalanced", "PUSHWORD n+0(FP)\nMOVWORD $7,ret+RESULT(FP)", false},
+			{"underflow", "POPWORD AX\nMOVWORD AX,ret+RESULT(FP)", false},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf(`TEXT ·Value(SB),NOSPLIT,$0-%d
+JMP body<>(SB)
+TEXT body<>(SB),NOSPLIT,$0-0
+%s
+RET
+`, 2*width, row.body)
+					source = strings.NewReplacer("WORD", word, "RESULT", fmt.Sprint(width)).Replace(source)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(n "+typ+") "+typ, target.arch, target.triple, api)
+					if row.complete {
+						if err != nil || ir == "" {
+							t.Fatal("private stack features were not discovered in the complete helper CFG", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("private helper stack bypassed its input/depth proof", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86LogicalSourceBPContinuation(t *testing.T, arch, role string) (string, Options) {
+	t.Helper()
+	source, options := x86ContinuationResultFixture(t, arch, true)
+	if register := map[string]string{"numerical": "BX", "code-table": "SI", "output-pointer": "DI"}[role]; register != "" {
+		return strings.ReplaceAll(source, register, "BP"), options
+	}
+	word := "Q"
+	if arch == "386" {
+		word = "L"
+	}
+	body := " MOV" + word + " (SI),BP\n JMP BP"
+	switch role {
+	case "code-target":
+	case "partial-target":
+		body = " MOVW (SI),BP\n JMP BP"
+	case "unknown-target":
+		body = " MOV" + word + " $0,BP\n JMP BP"
+	case "overwritten-target":
+		body = " MOV" + word + " (SI),BP\n MOVB $0,BP\n JMP BP"
+	default:
+		t.Fatal("unknown BP continuation fixture role", role)
+	}
+	return strings.Replace(source, " JMP (SI)", body, 1), options
+}
+
+func TestX86ContinuationModeAwareBPRegisterRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			name     string
+			complete bool
+		}{
+			{"numerical", true},
+			{"code-table", true},
+			{"output-pointer", true},
+			{"code-target", true},
+			{"partial-target", false},
+			{"unknown-target", false},
+			{"overwritten-target", false},
+		} {
+			for _, api := range []string{"text", "module", "owned-module"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source, options := x86LogicalSourceBPContinuation(t, target.arch, row.name)
+					options.TargetTriple = target.triple
+					ir, err := x86ContinuationResultAPI(t, source, options, api)
+					if target.arch == "386" && row.complete {
+						if err != nil || ir == "" {
+							t.Fatal("mode32 BP lost its independently closed continuation role", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("logical continuation admitted the AMD64 physical BP frame", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Mode32BPLogicalSourceOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for mode32 logical BP objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue // This owner explicitly compiles the two mode32 targets.
+		}
+		for _, role := range []string{
+			"direct-tail", "private-stack", "private-result-stack",
+			"native-load-B", "native-load-W", "native-load-L",
+			"numerical", "code-table", "output-pointer", "code-target",
+		} {
+			t.Run(target.triple+"/"+role, func(t *testing.T) {
+				source := strings.ReplaceAll(x86DirectTail386ASM, "SI", "BP")
+				declarations := x86DirectTail386Go
+				ordinary := role == "direct-tail" || strings.HasPrefix(role, "private-") || strings.HasPrefix(role, "native-load-")
+				var options Options
+				switch {
+				case role == "private-stack":
+					source = strings.Replace(source, " MOVL BP,AX", " PUSHL BP\n POPL AX", 1)
+				case role == "private-result-stack":
+					declarations = "func Value(n uint32) uint32"
+					source = `TEXT ·Value(SB),4,$0-8
+LEAL ret+4(FP),BP
+JMP body<>(SB)
+TEXT body<>(SB),4,$0-0
+PUSHL n+0(FP)
+MOVL $7,(BP)
+POPL AX
+RET
+`
+				case strings.HasPrefix(role, "native-load-"):
+					suffix := strings.TrimPrefix(role, "native-load-")
+					widen := map[string]string{"B": "MOVBLZX", "W": "MOVWLZX", "L": "MOVL"}[suffix]
+					source = x86Mode32BPNativeLoadSource("L", 4, suffix, widen, "MOVWORD p+0(FP),DX")
+					declarations = "func Value(p *byte) uint32"
+				case !ordinary:
+					source, options = x86LogicalSourceBPContinuation(t, "386", role)
+					options.TargetTriple = target.triple
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				apis := []string{"text", "module", "owned-module"}
+				if ordinary {
+					apis[2] = "Go"
+				}
+				for _, api := range apis {
+					t.Run(api, func(t *testing.T) {
+						var ir string
+						var err error
+						if ordinary {
+							ir, err = x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+						} else {
+							ir, err = x86ContinuationResultAPI(t, source, options, api)
+						}
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, optimized := range []bool{false, true} {
+							input := ir
+							if optimized {
+								input = x86UndefinedTrapOptimizedIR(t, input)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+									x86PackedStringCompileObject(t, llc, target.triple, input, level)
+								})
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_low_word_result_routing_test.go b/x86_low_word_result_routing_test.go
new file mode 100644
index 000000000..a4d68988a
--- /dev/null
+++ b/x86_low_word_result_routing_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86LowWordSparseProjectionKeepsWholeSourceInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var original strings.Builder
+		original.WriteString("TEXT f(SB),4,$0-0\n")
+		for _, row := range x86WordMultiplyValueRows(arch) {
+			if row.op != "PMULLW" && row.op != "VPMULLW" {
+				continue
+			}
+			instruction := row.op + " X0,X1"
+			if row.op == "VPMULLW" {
+				mask, suffix := "", ""
+				if row.mode != "plain" {
+					mask = "K1,"
+				}
+				if row.mode == "zero" {
+					suffix = ".Z"
+				}
+				instruction = fmt.Sprintf("%s%s %s0,%s1,%s%s2", row.op, suffix, row.bank, row.bank, mask, row.bank)
+			}
+			original.WriteString(instruction + "\n")
+			ins := x86ScalarLaneInstruction(t, instruction)
+			width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+			full := x86CallerVectorByteMask(int64(width))
+			for input := 0; input < 2; input++ {
+				for missing := -1; missing < width; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.masks[1] = true
+					for index := 0; index < 3; index++ {
+						state.xmm[index] = 0xffff
+						state.vectorUpper[index] = (full | 0xa55aa55aa55aa55a) &^ 0xffff
+					}
+					want := full
+					if missing >= 0 {
+						known := state.vectorBytes(input) &^ (uint64(1) << uint(missing))
+						state.xmm[input], state.vectorUpper[input] = uint16(known), known&^0xffff
+						want &^= uint64(3) << uint(missing/2*2)
+					}
+					before := state.clone()
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+						t.Fatal("low-word NUM projection lost a valid sparse lane", arch, instruction, input, missing)
+					}
+					destination := 2
+					if row.op == "PMULLW" {
+						destination = 1
+						want |= before.vectorBytes(destination) &^ full
+					} else {
+						want |= ^full
+					}
+					if state.vectorBytes(destination) != want || state.flags != before.flags || state.direction != before.direction {
+						t.Fatal("sparse low product invented bytes or changed aliases/flags", arch, instruction, input, missing)
+					}
+					private := before.clone()
+					accepted := x86ScalarFPResultTransfer(ins, &private, nil, 0, arch)
+					if accepted != (missing == -1) || !accepted && !reflect.DeepEqual(private, before) {
+						t.Fatal("NUM projection bypassed complete source inputs", arch, instruction, input, missing)
+					}
+				}
+			}
+		}
+		original.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+	}
+}
+
+func TestX86WordMultiplySourceGuardRetainsMarkedLiteralValidation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86WordMultiplyNames {
+			row := op + " X0,X1"
+			if strings.HasPrefix(op, "V") {
+				row = op + " X0,X1,X2"
+			}
+			ins := x86ScalarLaneInstruction(t, row)
+			ins.x86SDKLiteral = &x86SDKLiteralCertificate{}
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.xmm[0], state.xmm[1], state.xmm[2] = 0xffff, 0xffff, 0xffff
+			before := state.clone()
+			if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+				t.Fatal("word source guard bypassed a marked literal's independent validation", arch, op)
+			}
+		}
+	}
+}
diff --git a/x86_lowered_vector_entry_frame_test.go b/x86_lowered_vector_entry_frame_test.go
new file mode 100644
index 000000000..1003fb3e2
--- /dev/null
+++ b/x86_lowered_vector_entry_frame_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86LoweredVectorEntryRequiresTypedLogicalFrame(t *testing.T) {
+	const bare = "TEXT ·Value(SB),4,$0-0\nPEXTRB $0,X0,AX\nTESTL AX,AX\nSETNE CX\nRET\n"
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", bare)
+	for _, row := range []struct {
+		name string
+		sig  FuncSig
+	}{
+		{"synthetic-Void", FuncSig{Name: "Value", Ret: Void}},
+		{"bare-register-result", FuncSig{Name: "Value", Ret: I64}},
+	} {
+		file, err := Parse(ArchAMD64, bare)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, api := range []string{"Translate", "TranslateModule", "TranslateModuleInContext"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+					Sigs:       map[string]FuncSig{"Value": row.sig},
+					ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+				ir, err := x86PackedFloatStorageAPI(api, file, options)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("an empty frame acquired a declared ABI0 scratch choice", err)
+				}
+			})
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("declared-empty-Void/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, bare, "func Value()", "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an empty Go declaration supplied a nonempty logical frame", err)
+			}
+		})
+	}
+	for _, row := range []struct {
+		name, source, declaration string
+	}{
+		{"typed-parameter-Void", strings.Replace(bare, "$0-0", "$0-8", 1), "func Value(unused uint64)"},
+		{"typed-result", "TEXT ·Value(SB),4,$0-4\nPEXTRB $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n", "func Value() uint32"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				x86VectorScratchCodegenControl(t, row.source, row.declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			})
+		}
+	}
+}
diff --git a/x86_lowered_vector_entry_roles_test.go b/x86_lowered_vector_entry_roles_test.go
new file mode 100644
index 000000000..6fbf04210
--- /dev/null
+++ b/x86_lowered_vector_entry_roles_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/ast"
+	goparser "go/parser"
+	"go/token"
+	"strings"
+	"testing"
+)
+
+// This is a test-side field inventory, not a production capability registry.
+// Every semantic role below must remain outside ordinary scratch refinement.
+func x86VectorRefinementRoleControls() []struct {
+	owner, field string
+	change       func(*Func, *FuncSig)
+} {
+	return []struct {
+		owner, field string
+		change       func(*Func, *FuncSig)
+	}{
+		{"FuncSig", "ARMEntry", func(_ *Func, s *FuncSig) { s.ARMEntry = new(ARMMachineEntry) }},
+		{"FuncSig", "WASMContext", func(_ *Func, s *FuncSig) { s.WASMContext = I64 }},
+		{"FuncSig", "WASMNative", func(_ *Func, s *FuncSig) { s.WASMNative = true }},
+		{"FuncSig", "ArgRegs", func(_ *Func, s *FuncSig) { s.ArgRegs = []Reg{AX} }},
+		{"FuncSig", "ARM64GoRegisterABI", func(_ *Func, s *FuncSig) { s.ARM64GoRegisterABI = new(ARM64GoRegisterABI) }},
+		{"FuncSig", "ARM64ClosureABI", func(_ *Func, s *FuncSig) { s.ARM64ClosureABI = new(ARM64ClosureABI) }},
+		{"FuncSig", "x86CallerRegions", func(_ *Func, s *FuncSig) { s.x86CallerRegions = new(x86GoCallerRegionProof) }},
+		{"FuncSig", "x86FixedLocal", func(_ *Func, s *FuncSig) { s.x86FixedLocal = new(x86FixedLocalBinding) }},
+		{"FuncSig", "amd64GoArguments", func(_ *Func, s *FuncSig) { s.amd64GoArguments = new(amd64GoArgumentBinding) }},
+		{"FuncSig", "arm64FPReadDeclaration", func(_ *Func, s *FuncSig) { s.arm64FPReadDeclaration = new(arm64FPReadDeclaration) }},
+		{"FuncSig", "arm64ABI0Declaration", func(_ *Func, s *FuncSig) { s.arm64ABI0Declaration = new(arm64ABI0Declaration) }},
+		{"FuncSig", "arm64ABI0TailDeclaration", func(_ *Func, s *FuncSig) { s.arm64ABI0TailDeclaration = new(arm64ABI0TailDeclaration) }},
+		{"FuncSig", "arm64NativeScratch", func(_ *Func, s *FuncSig) { s.arm64NativeScratch = new(arm64ScratchBinding) }},
+		{"FuncSig", "x86BorrowedBoolTail", func(_ *Func, s *FuncSig) { s.x86BorrowedBoolTail = true }},
+		{"Func", "X86RawText", func(f *Func, _ *FuncSig) { f.X86RawText = []byte{0xc3} }},
+		{"Func", "X86RawAlign", func(f *Func, _ *FuncSig) { f.X86RawAlign = 16 }},
+		{"Func", "x86ContinuationAddresses", func(f *Func, _ *FuncSig) { f.x86ContinuationAddresses = map[string]x86Continuation{"label": {}} }},
+		{"Func", "x86IndirectLabels", func(f *Func, _ *FuncSig) { f.x86IndirectLabels = []string{"label"} }},
+		{"Func", "x86ContinuationFlow", func(f *Func, _ *FuncSig) { f.x86ContinuationFlow = new(x86ContinuationFlow) }},
+		{"Func", "x86SourceStack", func(f *Func, _ *FuncSig) { f.x86SourceStack = new(x86SourceStackProof) }},
+		{"Func", "x86FixedLocal", func(f *Func, _ *FuncSig) { f.x86FixedLocal = new(x86FixedLocalProof) }},
+		{"Func", "arm64PrivateRegisterEntry", func(f *Func, _ *FuncSig) { f.arm64PrivateRegisterEntry = true }},
+		{"Func", "arm64PrivateUnexposedFrame", func(f *Func, _ *FuncSig) { f.arm64PrivateUnexposedFrame = true }},
+		{"Func", "arm64PrivateTailSource", func(f *Func, _ *FuncSig) { f.arm64PrivateTailSource = new(arm64PrivateTailSource) }},
+		{"Func", "arm64PrivateCallSource", func(f *Func, _ *FuncSig) { f.arm64PrivateCallSource = new(arm64PrivateCallSource) }},
+		{"Func", "arm64ABI0TailSource", func(f *Func, _ *FuncSig) { f.arm64ABI0TailSource = new(arm64ABI0TailSource) }},
+		{"Func", "x86RawReplay", func(f *Func, _ *FuncSig) { f.x86RawReplay = new(x86RawReplaySource) }},
+		{"Func", "x86DirectTailRoot", func(f *Func, _ *FuncSig) { f.x86DirectTailRoot = new(x86DirectTailRoot) }},
+		{"Func", "x86BoolCalls", func(f *Func, _ *FuncSig) { f.x86BoolCalls = new(x86ABI0BoolCallPlan) }},
+		{"Func", "x86BoolReadonlyInputs", func(f *Func, _ *FuncSig) { f.x86BoolReadonlyInputs = true }},
+	}
+}
+
+func TestX86LoweredVectorEntryExcludesEveryRegisteredRole(t *testing.T) {
+	for _, row := range x86VectorRefinementRoleControls() {
+		t.Run(row.owner+"/"+row.field, func(t *testing.T) {
+			fn, sig := x86LoweredVectorMaskFixture(t)
+			row.change(&fn, &sig)
+			var output strings.Builder
+			consumer := newX86Ctx(&output, fn, sig, func(name string) string { return strings.TrimPrefix(name, "·") },
+				nil, "amd64", "x86_64-unknown-linux-gnu", false)
+			if err := consumer.scalarFPResultInitialized(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("a registered role acquired ordinary ABI0 scratch refinement", err)
+			}
+		})
+	}
+}
+
+func TestX86LoweredVectorEntryRoleFieldInventory(t *testing.T) {
+	classified := map[string]map[string]bool{
+		"FuncSig": {"Name": true, "Args": true, "Ret": true, "Attrs": true, "Frame": true},
+		"Func": {
+			"Sym": true, "FrameSize": true, "ArgSize": true, "Instrs": true,
+			"x86ResultFlowBudget": true, "arm64PrivateSourceAdded": true, // Resource counters only.
+			"x86SourceStackFailure": true, // Diagnostic only; never a source capability.
+		},
+	}
+	for _, row := range x86VectorRefinementRoleControls() {
+		if classified[row.owner][row.field] {
+			t.Fatal("duplicate or contradictory role classification", row.owner, row.field)
+		}
+		classified[row.owner][row.field] = true
+	}
+	for _, owner := range []struct{ path, name string }{{"translate.go", "FuncSig"}, {"parser.go", "Func"}} {
+		file, err := goparser.ParseFile(token.NewFileSet(), owner.path, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		found := false
+		ast.Inspect(file, func(node ast.Node) bool {
+			declaration, ok := node.(*ast.TypeSpec)
+			if !ok || declaration.Name.Name != owner.name {
+				return true
+			}
+			fields, ok := declaration.Type.(*ast.StructType)
+			if !ok {
+				t.Fatal("role owner is no longer a struct", owner.name)
+			}
+			found = true
+			for _, field := range fields.Fields.List {
+				for _, name := range field.Names {
+					if !classified[owner.name][name.Name] {
+						t.Error("new field requires explicit ordinary/semantic-role/resource classification", owner.name, name.Name)
+					}
+					delete(classified[owner.name], name.Name)
+				}
+			}
+			return false
+		})
+		if !found || len(classified[owner.name]) != 0 {
+			t.Fatal("role inventory is stale or incomplete", owner.name, classified[owner.name])
+		}
+	}
+}
diff --git a/x86_lowered_vector_entry_runtime_test.go b/x86_lowered_vector_entry_runtime_test.go
new file mode 100644
index 000000000..b7033cd8e
--- /dev/null
+++ b/x86_lowered_vector_entry_runtime_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86LoweredVectorEntryOriginalTests = `package oracle
+import "testing"
+func TestOriginalLoweredVectorEntry(t *testing.T) {
+    calls := 0
+    for n := uint64(1); n <= 2; n++ {
+        for first := 0; first < 256; first++ {
+            for _, second := range []byte{0, 127, 128, 255} {
+                input := [2]byte{byte(first), second}
+                before := input
+                invalid := -1
+                for i := 0; i < int(n); i++ {
+                    if input[i] >= 128 { invalid = i; break }
+                }
+                at, ok := MaskTail(&input[0], n)
+                if ok != (invalid < 0) || invalid >= 0 && at != uint64(invalid) {
+                    t.Fatalf("mask n=%d input=%x at=%d ok=%t invalid=%d", n, input, at, ok, invalid)
+                }
+                output := [8]byte{204, 204, 204, 204, 204, 204, 204, 204}
+                want := output
+                want[1] = input[0]
+                if n == 2 { want[2], want[3], want[4] = input[1], input[0], input[1] }
+                RepeatTail(&output[1], &input[0], n)
+                if input != before || output != want {
+                    t.Fatalf("repeat n=%d input=%x output=%x want=%x", n, input, output, want)
+                }
+                calls++
+            }
+        }
+    }
+    if calls != 2048 { t.Fatal("incomplete caller denominator", calls) }
+    t.Logf("actual original Go tail caller pairs=%d; values, invalid-byte indices and canaries pass", calls)
+}
+`
+
+// The declared caller observes at only on failure. No observation depends on
+// an unspecified vector entry byte or the unwritten numerical success result.
+func TestCrossLinuxRuntimeMatrixX86LoweredVectorEntryOriginalGo(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	formatted, err := format.Source([]byte(x86LoweredVectorEntryOriginalTests))
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	for name, data := range map[string]string{
+		"go.mod":        "module oracle\n\ngo 1.20\n",
+		"value.go":      "package oracle\n" + x86LoweredVectorMaskDeclaration + x86LoweredVectorRepeatDeclaration,
+		"value_amd64.s": x86LoweredVectorMaskSource + x86LoweredVectorRepeatSource,
+		"value_test.go": string(formatted),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	binary := filepath.Join(dir, "original.test")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "test", "-c", "-p=1", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOFLAGS=",
+		"CGO_ENABLED=0", "GOARCH=amd64", "GOOS="+runtime.GOOS)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("actual original Go build/asmdecl: %v\n%s", err, output)
+	}
+	if linked, err := x86OriginalGoLinkedAMD64(binary); err != nil || !linked {
+		t.Fatal("original caller must be a current-SDK linked AMD64 executable", linked, err)
+	}
+	output = execution.run(t, binary, "-test.run=^TestOriginalLoweredVectorEntry$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginalLoweredVectorEntry") ||
+		!strings.Contains(string(output), "tail caller pairs=2048") {
+		t.Fatal("missing complete original Go caller results", string(output))
+	}
+	t.Log(strings.TrimSpace(string(output)))
+}
+
+// Keep the mixed tuple inside LLVM and expose only the caller's written
+// component, rather than guessing an external C aggregate ABI.
+const x86LoweredVectorEntryCallerIR = `
+define i64 @ObserveMask(ptr %src, i64 %n) {
+entry:
+  %pair = call { i64, i1 } @MaskTail(ptr %src, i64 %n)
+  %ok = extractvalue { i64, i1 } %pair, 1
+  br i1 %ok, label %success, label %failure
+success:
+  ret i64 -1
+failure:
+  %at = extractvalue { i64, i1 } %pair, 0
+  ret i64 %at
+}
+`
+
+const x86LoweredVectorEntryCallerC = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint64_t ObserveMask(const uint8_t *, uint64_t);
+extern void RepeatTail(uint8_t *, const uint8_t *, uint64_t);
+int main(void) {
+    const uint8_t second[] = {0, 127, 128, 255};
+    unsigned calls = 0;
+    for (uint64_t n = 1; n <= 2; ++n) {
+        for (unsigned first = 0; first < 256; ++first) {
+            for (unsigned sample = 0; sample < 4; ++sample) {
+                uint8_t input[2] = {(uint8_t)first, second[sample]}, before[2];
+                uint8_t output[8], want[8];
+                memcpy(before, input, sizeof input);
+                uint64_t invalid = UINT64_MAX;
+                for (unsigned i = 0; i < n; ++i) {
+                    if (input[i] >= 128) { invalid = i; break; }
+                }
+                uint64_t got = ObserveMask(input, n);
+                if (got != invalid) {
+                    fprintf(stderr, "mask n=%llu first=%u second=%u got=%llu want=%llu\n",
+                        (unsigned long long)n, first, second[sample],
+                        (unsigned long long)got, (unsigned long long)invalid);
+                    return 1;
+                }
+                memset(output, 204, sizeof output);
+                memcpy(want, output, sizeof output);
+                want[1] = input[0];
+                if (n == 2) { want[2] = input[1]; want[3] = input[0]; want[4] = input[1]; }
+                RepeatTail(output + 1, input, n);
+                if (memcmp(input, before, sizeof input) || memcmp(output, want, sizeof output)) {
+                    fprintf(stderr, "repeat/canary n=%llu first=%u second=%u\n",
+                        (unsigned long long)n, first, second[sample]);
+                    return 1;
+                }
+                ++calls;
+            }
+        }
+    }
+    if (calls != 2048) return 1;
+    puts("tail caller pairs=2048 failures=0");
+    return 0;
+}
+`
+
+func TestCrossLinuxRuntimeMatrixX86LoweredVectorEntryCallerValues(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source := x86LoweredVectorMaskSource + x86LoweredVectorRepeatSource
+	declarations := x86LoweredVectorMaskDeclaration + x86LoweredVectorRepeatDeclaration
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("missing ordinary tail caller IR", err)
+			}
+			ir += x86LoweredVectorEntryCallerIR
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+					text := ir
+					if optimized {
+						text = x86DwordProductIROptimize(t, ir)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) {
+							output := execution.compileAndRunLLVM(t, "vector-entry", text, x86LoweredVectorEntryCallerC, level)
+							if string(output) != "tail caller pairs=2048 failures=0\n" {
+								t.Fatal("tail values, invalid indices or escaped canaries differ", string(output))
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_lowered_vector_entry_test.go b/x86_lowered_vector_entry_test.go
new file mode 100644
index 000000000..b84f91df6
--- /dev/null
+++ b/x86_lowered_vector_entry_test.go
@@ -0,0 +1,312 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// Ordinary ABI0 codegen selects one consistent value for undeclared vector
+// scratch. The strict source query still ranges over arbitrary physical entry
+// values. Defined caller projections remain independent of that choice; an
+// explicitly observed scratch value is not all-entry native equivalence.
+const x86LoweredVectorMaskSource = `TEXT ·MaskTail(SB),4,$0-25
+MOVQ src+0(FP),SI
+MOVQ n+8(FP),BX
+CMPQ BX,$2
+JE two
+PINSRB $0,(SI),X0
+JMP check
+two:
+PINSRW $0,(SI),X0
+check:
+MOVQ $16,CX
+SUBQ BX,CX
+MOVW $65535,DX
+SHRW CX,DX
+PMOVMSKB X0,AX
+TESTW AX,DX
+JNZ invalid
+MOVB $1,ok+24(FP)
+RET
+invalid:
+BSFW AX,AX
+MOVQ AX,at+16(FP)
+MOVB $0,ok+24(FP)
+RET
+`
+
+const x86LoweredVectorRepeatSource = `DATA repeat<>+0(SB)/8,$0x0100010001000100
+DATA repeat<>+8(SB)/8,$0x0100010001000100
+GLOBL repeat<>(SB),8,$16
+TEXT ·RepeatTail(SB),4,$0-24
+MOVQ out+0(FP),DI
+MOVQ src+8(FP),SI
+MOVQ n+16(FP),BX
+CMPQ BX,$2
+JE two
+PINSRB $0,(SI),X0
+JMP shuffle
+two:
+PINSRW $0,(SI),X0
+shuffle:
+PSHUFB repeat<>(SB),X0
+CMPQ BX,$2
+JE pair
+PEXTRB $0,X0,(DI)
+RET
+pair:
+PEXTRB $3,X0,3(DI)
+PEXTRB $2,X0,2(DI)
+PEXTRB $1,X0,1(DI)
+PEXTRB $0,X0,(DI)
+RET
+`
+
+const x86LoweredVectorMaskDeclaration = "func MaskTail(src *byte,n uint64) (at uint64,ok bool)\n"
+const x86LoweredVectorRepeatDeclaration = "func RepeatTail(out,src *byte,n uint64)\n"
+
+func x86LoweredVectorMaskFixture(t *testing.T) (Func, FuncSig) {
+	t.Helper()
+	pkg := mustGoPackage(t, "entry", "package entry\n"+x86LoweredVectorMaskDeclaration)
+	sig, err := DeriveGoFuncABI0Signature("MaskTail", pkg.Types.Scope().Lookup("MaskTail").(*types.Func),
+		"amd64", types.SizesFor("gc", "amd64"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := Parse(ArchAMD64, x86LoweredVectorMaskSource)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0], sig
+}
+
+func TestX86LoweredVectorEntryKeepsStrictAuditAndThreeAPIs(t *testing.T) {
+	fn, sig := x86LoweredVectorMaskFixture(t)
+	if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("the standalone query acquired lowering-owned vector initialization", err)
+	}
+	// Isolate vector initialization from the public query's independent lack
+	// of caller-memory contents. Every scalar input here is source-defined.
+	_, _, scalar, _ := x86ResultInitializationFixture(t, "amd64", "func Value(value uint32) uint32", "RET")
+	_, partial, scalar, scalarSource := x86ResultInitializationFixture(t, "amd64", "func Value(value uint32) uint32",
+		fmt.Sprintf("PINSRD $1,value+0(FP),X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET", scalar.Frame.Results[0].Offset))
+	if err := CheckX86ABI0ResultInitialization(partial.Funcs[0], scalar, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("a source-only query borrowed the emitter's initial vector contents", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, fixture := range []struct {
+		name, source, declaration string
+		width                     int
+	}{
+		{"runtime-mask-X", x86LoweredVectorMaskSource, x86LoweredVectorMaskDeclaration, 16},
+		{"runtime-mask-Y", strings.Replace(x86LoweredVectorMaskSource, "PMOVMSKB X0,AX", "VPMOVMSKB Y0,AX", 1), x86LoweredVectorMaskDeclaration, 32},
+		{"runtime-mask-Z", strings.Replace(x86LoweredVectorMaskSource, "PMOVMSKB X0,AX", "VPMOVB2M Z0,K1\nKMOVQ K1,AX", 1), x86LoweredVectorMaskDeclaration, 64},
+		{"repeated-selector", x86LoweredVectorRepeatSource, x86LoweredVectorRepeatDeclaration, 16},
+		{"undeclared-low-lane-refinement", strings.Replace(scalarSource, "·Value", "·Choose", 1), "func Choose(value uint32) uint32\n", 16},
+	} {
+		for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			t.Run(fixture.name+"/"+triple, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", triple, fixture.source)
+				x86RequireNumericNativeSourceContext(t, fixture.source, fixture.declaration, "amd64")
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, "amd64", triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("ordinary ABI0 refinement was blocked by its separate strict audit", err)
+						}
+						if strings.Count(ir, fmt.Sprintf("store <%d x i8> zeroinitializer", fixture.width)) != 1 {
+							t.Fatal("the fixture must retain its actual allocated vector initializer")
+						}
+						for _, width := range []int{16, 32, 64} {
+							if width != fixture.width && strings.Contains(ir, fmt.Sprintf("alloca <%d x i8>", width)) {
+								t.Fatal("a numerical entry observation widened the actual allocation", width)
+							}
+						}
+						x86ResultInitializationObject(t, llc, triple, ir, "vector-entry")
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86LoweredVectorEntryKeepsAddressBoolAndSourceGuards(t *testing.T) {
+	for _, row := range []struct{ name, source string }{
+		{"undefined-address", strings.ReplaceAll(x86LoweredVectorMaskSource, "(SI)", "(R8)")},
+		{"undefined-index", strings.ReplaceAll(x86LoweredVectorMaskSource, "(SI)", "(SI)(R8*1)")},
+		{"undefined-GP-insert", strings.Replace(x86LoweredVectorMaskSource, "PINSRB $0,(SI),X0", "PINSRB $0,R8,X0", 1)},
+		{"noncanonical-success", strings.Replace(x86LoweredVectorMaskSource, "MOVB $1,ok+", "MOVB $2,ok+", 1)},
+		{"noncanonical-failure", strings.Replace(x86LoweredVectorMaskSource, "MOVB $0,ok+", "MOVB $2,ok+", 1)},
+		{"incoming-frame-write", strings.Replace(x86LoweredVectorMaskSource, "check:\n", "check:\nMOVQ $7,src+0(FP)\n", 1)},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, x86LoweredVectorMaskDeclaration,
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				if err == nil || ir != "" {
+					t.Fatal("numerical vector initialization widened an independent source role", api, err)
+				}
+			}
+		})
+	}
+	t.Run("unclosed-CPP", func(t *testing.T) {
+		// Parse's documented legacy compatibility ignores includes. The
+		// source-owning preprocessing API must resolve every active include
+		// before any numerical lowering or vector-entry choice is relevant.
+		text, err := PreprocessAssemblySource("#include \"unbound-vector-entry.h\"\n"+x86LoweredVectorMaskSource,
+			AssemblyPreprocessOptions{FileName: "vector-entry.s"})
+		if err == nil || text != "" || !strings.Contains(err.Error(), "requires a resolver") {
+			t.Fatal("numerical vector initialization bypassed active source preprocessing", err)
+		}
+	})
+	fn, sig := x86LoweredVectorMaskFixture(t)
+	for _, origin := range []string{"raw TEXT", "source stack", "fixed local"} {
+		t.Run(origin, func(t *testing.T) {
+			changed := fn
+			switch origin {
+			case "raw TEXT":
+				changed.X86RawText = []byte{0xc3}
+			case "source stack":
+				changed.x86SourceStack = new(x86SourceStackProof)
+			case "fixed local":
+				changed.x86FixedLocal = new(x86FixedLocalProof)
+			}
+			consumer := amd64Ctx{fpScalarSource: changed, sig: sig, fpSourceSig: sig, goarch: "amd64"}
+			if err := consumer.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("lowering initialization bypassed the independent native source owner", origin, err)
+			}
+		})
+	}
+}
+
+func TestX86LoweredVectorEntryKeepsCachedAuditSeparate(t *testing.T) {
+	fn, sig := x86LoweredVectorMaskFixture(t)
+	budget := new(x86ResultFlowBudget)
+	fn.x86ResultFlowBudget = budget
+	var output strings.Builder
+	consumer := newX86Ctx(&output, fn, sig, func(name string) string { return strings.TrimPrefix(name, "·") },
+		nil, "amd64", "x86_64-unknown-linux-gnu", false)
+	if err := consumer.validateMixedBoolResultRole(); err != nil {
+		t.Fatal("a canonical ordinary bool contract must permit its numerical code generation", err)
+	}
+	strict, used := consumer.fpScalarCheckErr, *budget
+	if !consumer.fpScalarChecked || !errors.Is(strict, ErrProbeNeedsContext) || used.visits == 0 {
+		t.Fatal("code generation erased its independent strict audit", strict, used)
+	}
+	if !consumer.fpMixedBoolBytes || consumer.abi0BoolResultByteStorage() {
+		t.Fatal("a lowering-owned initial value created complete result/frame permissions")
+	}
+	if err := consumer.scalarFPResultInitialized(); err != nil || consumer.fpScalarCheckErr != strict || *budget != used {
+		t.Fatal("a repeated consumer reran or promoted the cached audit", err)
+	}
+	for _, other := range []error{
+		fmt.Errorf("independent failure: %w", strict),
+		errors.Join(strict, errors.New("source guard failed")),
+	} {
+		changed := *consumer
+		changed.fpScalarCheckErr = other
+		if err := changed.scalarFPResultInitialized(); err != other {
+			t.Fatal("a wrapped/joined source failure became a codegen-only outcome", err)
+		}
+	}
+}
+
+// A native whole-bank observer cannot observe a different register realization
+// from the vector slots used by ordinary numerical lowering. This applies even
+// when all vector bytes are defined and no scalar result requires a proof.
+func TestX86LoweredVectorEntryRejectsUnboundPhysicalBankObservers(t *testing.T) {
+	for _, opcode := range []string{"FXSAVE64", "XSAVE64"} {
+		for _, shape := range []string{"partial-result", "defined-void"} {
+			declaration := "func Value(out *byte, value uint32)"
+			initialization := "PXOR X0,X0\n"
+			if shape == "partial-result" {
+				declaration += " uint32"
+				initialization = ""
+			}
+			_, _, signature, _ := x86ResultInitializationFixture(t, "amd64", declaration, "RET")
+			body := "MOVQ out+0(FP),DI\n" + initialization +
+				"PINSRD $1,value+8(FP),X0\nMOVL $3,AX\nXORL DX,DX\n" + opcode + " (DI)\n"
+			if shape == "partial-result" {
+				body += fmt.Sprintf("PEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\n", signature.Frame.Results[0].Offset)
+			}
+			var extent int64
+			for _, slots := range [][]FrameSlot{signature.Frame.Params, signature.Frame.Results} {
+				for _, slot := range slots {
+					if end := slot.Offset + x86FrameScalarBytes(slot.Type, "amd64"); end > extent {
+						extent = end
+					}
+				}
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", extent, body)
+			for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+				t.Run(opcode+"/"+shape+"/"+triple, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "amd64", triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("unbound physical bank observer must keep source context: %v\n%s", err, ir)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LoweredVectorEntryRequiresCompleteAllocationPlan(t *testing.T) {
+	_, _, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(value uint32) uint32", "RET")
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(value uint32) uint32",
+		fmt.Sprintf("PINSRD $1,value+0(FP),X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET", sig.Frame.Results[0].Offset))
+	fn := file.Funcs[0]
+	if len(sig.Frame.Params) != 1 || len(sig.Frame.Results) != 1 {
+		t.Fatal("allocation-plan control lost its complete typed ABI0 frame")
+	}
+	var completeOutput strings.Builder
+	complete := newX86Ctx(&completeOutput, fn, sig, func(name string) string { return strings.TrimPrefix(name, "·") },
+		nil, "amd64", "x86_64-unknown-linux-gnu", false)
+	if err := complete.scalarFPResultInitialized(); err != nil || !errors.Is(complete.fpScalarCheckErr, ErrProbeNeedsContext) || completeOutput.Len() != 0 {
+		t.Fatal("complete typed allocation plan did not reach lowering-only refinement", err)
+	}
+	strict := CheckX86ABI0ResultInitialization(fn, sig, "amd64")
+	if !errors.Is(strict, ErrProbeNeedsContext) {
+		t.Fatal("the original partial vector must retain its strict audit", strict)
+	}
+	for _, row := range []struct {
+		name   string
+		remove func(*amd64Ctx)
+	}{
+		{"GP", func(c *amd64Ctx) { c.usedRegs = nil }},
+		{"X", func(c *amd64Ctx) { c.usedXRegs = nil }},
+		{"Y", func(c *amd64Ctx) { c.usedYRegs = nil }},
+		{"Z", func(c *amd64Ctx) { c.usedZRegs = nil }},
+		{"K", func(c *amd64Ctx) { c.usedKRegs = nil }},
+		{"blocks", func(c *amd64Ctx) { c.blocks = nil }},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			defer func() {
+				if value := recover(); value != nil {
+					t.Errorf("an incomplete lowering allocation plan panicked: %v", value)
+				}
+			}()
+			var output strings.Builder
+			consumer := newX86Ctx(&output, fn, sig, func(name string) string { return strings.TrimPrefix(name, "·") },
+				nil, "amd64", "x86_64-unknown-linux-gnu", false)
+			row.remove(consumer)
+			err := consumer.checkLoweredVectorEntry(fn, sig, "amd64",
+				func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+					return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+				}, strict)
+			if err != strict || output.Len() != 0 {
+				t.Fatal("an incomplete allocation plan replaced its original strict audit", err)
+			}
+		})
+	}
+}
diff --git a/x86_mask_blend_family_tdd_test.go b/x86_mask_blend_family_tdd_test.go
new file mode 100644
index 000000000..494112b39
--- /dev/null
+++ b/x86_mask_blend_family_tdd_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86MaskBlendVoidAndUnusedBoolNeverSupplyInputs(t *testing.T) {
+	for _, row := range x86MaskBlendIndependentRows("amd64") {
+		for _, unusedBool := range []bool{false, true} {
+			declaration, extent := "func Missing()", 0
+			if unusedBool {
+				declaration, extent = "func Missing(unused bool)", 1
+			}
+			source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s\nRET\n", extent, row)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if unusedBool && !strings.Contains(row, "(") && !strings.Contains(row, ",K") {
+					x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Void or unused bool supplied unbound blend inputs", row, unusedBool, api, err)
+				}
+			}
+		}
+	}
+}
+
+// Independent Go _yvblendmpd inventory: six width/mask rows per member,
+// register or memory source, with per-opcode broadcast and zeroing attributes.
+func x86MaskBlendIndependentRows(arch string) []string {
+	var rows []string
+	for _, member := range []struct {
+		op        string
+		broadcast bool
+	}{
+		{"VBLENDMPS", true}, {"VBLENDMPD", true},
+		{"VPBLENDMB", false}, {"VPBLENDMW", false},
+		{"VPBLENDMD", true}, {"VPBLENDMQ", true},
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, first := range []string{bank + "0", "(SI)"} {
+				rows = append(rows, member.op+" "+first+","+bank+"1,"+bank+"2")
+				if arch == "amd64" {
+					rows = append(rows, member.op+" "+first+","+bank+"1,K1,"+bank+"2",
+						member.op+".Z "+first+","+bank+"1,K1,"+bank+"2")
+				}
+			}
+			if member.broadcast {
+				rows = append(rows, member.op+".BCST (SI),"+bank+"1,"+bank+"2")
+				if arch == "amd64" {
+					rows = append(rows, member.op+".BCST (SI),"+bank+"1,K1,"+bank+"2",
+						member.op+".BCST.Z (SI),"+bank+"1,K1,"+bank+"2")
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86MaskBlendCompleteIndependentGoRows(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86MaskBlendIndependentRows(arch)
+		want := 48
+		if arch == "amd64" {
+			want = 144
+		}
+		if len(rows) != want {
+			t.Fatal("independent mask-blend row denominator changed", arch, len(rows))
+		}
+		requireX86GoAssemblerResult(t, arch,
+			"TEXT forms(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", true)
+	}
+}
+
+func TestX86MaskBlendInitializedNamedFamilyFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("mask-blend complete objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			rows := x86MaskBlendIndependentRows(target.arch)
+			for start := 0; start < len(rows); start += 48 {
+				end := start + 48
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index := start; index < end; index++ {
+						name := fmt.Sprintf("Blend%d", index)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\n"+
+							"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nMOVL $85,CX\nKMOVD CX,K1\n"+
+							"%s\nVPEXTRD $0,X2,CX\nMOVL CX,ret+%d(FP)\nRET\n",
+							name, word+4, move, rows[index], word)
+						fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized full mask-blend family lost its public result", err)
+							}
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								for _, level := range []string{"-O0", "-O2"} {
+									x86PackedStringCompileObject(t, llc, target.triple, text, level)
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86MaskBlendSelectedInputsAndIndependentState(t *testing.T) {
+	for _, row := range x86MaskBlendIndependentRows("amd64") {
+		ins := x86ScalarLaneInstruction(t, row)
+		if ins.Args[0].Kind != OpReg {
+			continue // Native memory keeps a separate paired-load obligation.
+		}
+		width := amd64VectorByteWidth(ins.Args[0].Reg)
+		secondRequired := len(ins.Args) == 4 && !strings.HasSuffix(string(ins.Op), ".Z")
+		for missingRegister := 0; missingRegister < 2; missingRegister++ {
+			for missingByte := 0; missingByte < 64; missingByte++ {
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.writeVector(missingRegister, 64, ^uint64(0)&^(uint64(1)<<uint(missingByte)), false)
+					state.masks[1] = true
+					before := state.clone()
+					want := missingByte >= width || missingRegister == 1 && !secondRequired
+					if got := consumer.step(ins, &state, nil, 0, "amd64"); got != want {
+						t.Fatal("mask blend source selection supplied or demanded unrelated bytes", row, consumer.name, missingRegister, missingByte, got, want)
+					}
+					if !want {
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("rejected mask blend modified source state", row)
+						}
+						continue
+					}
+					if state.vectorBytes(2) != ^uint64(0) || state.flags != before.flags || state.gp != before.gp || state.masks != before.masks {
+						t.Fatal("mask blend lost upper-zero aliases or unrelated GP/FLAGS/masks", row)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_mask_blend_fault_runtime_unix_test.go b/x86_mask_blend_fault_runtime_unix_test.go
new file mode 100644
index 000000000..31ecacaf7
--- /dev/null
+++ b/x86_mask_blend_fault_runtime_unix_test.go
@@ -0,0 +1,66 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// E4 reads only active elements, even when the numerical result is dead. This
+// portable guard-page oracle does not qualify original AVX512 execution.
+func TestX86MaskBlendDeadNativeReadFaults(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable guard pages require the native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("mask blend faults require LLVM22 llc and clang")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, member := range []struct {
+		op        string
+		lane      int
+		broadcast bool
+	}{
+		{"VBLENDMPS", 4, true}, {"VBLENDMPD", 8, true},
+		{"VPBLENDMB", 1, false}, {"VPBLENDMW", 2, false},
+		{"VPBLENDMD", 4, true}, {"VPBLENDMQ", 8, true},
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !member.broadcast {
+					continue
+				}
+				op := member.op
+				width := amd64VectorByteWidth(Reg(bank + "0"))
+				extent := width
+				if broadcast {
+					op += ".BCST"
+					extent = member.lane
+				}
+				name := fmt.Sprint("BlendFault", count)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\n"+
+					"KMOVQ mask+8(FP),K1\n%s.Z (AX),%s1,K1,%s2\nRET\n", name, op, bank, bank)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *,uint64_t);\n", name)
+				fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, extent, member.lane, width/member.lane)
+				count++
+			}
+		}
+	}
+	if count != 30 {
+		t.Fatal("incomplete independent E4 memory shape inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal("complete dead E4 source rejected", err)
+	}
+	mainC := x86E4DeadReadFaultOracle(prototypes.String(), metadata.String())
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "mask_blend_dead_faults", triple, ir, mainC)
+}
diff --git a/x86_mask_blend_runtime_test.go b/x86_mask_blend_runtime_test.go
new file mode 100644
index 000000000..872641ebf
--- /dev/null
+++ b/x86_mask_blend_runtime_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// A portable value oracle, not a claim of native AVX512 execution. Each bank
+// retains all source aliases, upper zeros, selection modes and output canaries.
+func x86MaskBlendWholeByteRuntime(t *testing.T, bank string) {
+	t.Helper()
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable values require the native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("mask blend values require LLVM22 llc and clang")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, member := range []struct {
+		op   string
+		lane int
+	}{
+		{"VBLENDMPS", 4}, {"VBLENDMPD", 8},
+		{"VPBLENDMB", 1}, {"VPBLENDMW", 2},
+		{"VPBLENDMD", 4}, {"VPBLENDMQ", 8},
+	} {
+		for mode, suffix := range []string{"", "", ".Z"} {
+			for destination := 0; destination < 3; destination++ {
+				name := fmt.Sprint("Blend", count)
+				mask := ""
+				if mode != 0 {
+					mask = "K1,"
+				}
+				fmt.Fprintf(&declarations, "func %s(out *[193]byte,a,b,old *[64]byte,mask uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\n"+
+					"MOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ old+24(FP),DX\n"+
+					"VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (DX),Z2\n"+
+					"KMOVQ mask+32(FP),K1\nSTC\n%s%s %s0,%s1,%s%s%d\n"+
+					"VMOVUPS Z0,0(DI)\nVMOVUPS Z1,64(DI)\nVMOVUPS Z2,128(DI)\nSETCS 192(DI)\nRET\n",
+					name, member.op, suffix, bank, bank, mask, bank, destination)
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", name)
+				fmt.Fprintf(&metadata, "{%s,%d,%d,%d,%d},\n", name, member.lane,
+					amd64VectorByteWidth(Reg(bank+"0")), mode, destination)
+				count++
+			}
+		}
+	}
+	if count != 54 {
+		t.Fatal("incomplete independent blend/alias inventory", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal("complete mask blend value source rejected", err)
+	}
+	mainC := `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t);
+typedef struct { Kernel run; int lane,width,mode,destination; } Row;
+static const Row rows[]={
+` + metadata.String() + `
+};
+int main(void) {
+  static const uint64_t masks[]={0,UINT64_MAX,UINT64_C(0xa55a5aa5a55a5aa5),UINT64_C(1)<<63,1};
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    const Row *row=&rows[r];
+    for(unsigned trial=0;trial<20;trial++) {
+      uint8_t a[64],b[64],old[64],out[195],want[193];
+      for(unsigned i=0;i<64;i++) {
+        a[i]=(uint8_t)(i*37+trial*23+19);
+        b[i]=(uint8_t)(i*13+trial*43+71);
+        old[i]=(uint8_t)(i*29+trial*17+131);
+      }
+      uint64_t mask=masks[trial%5];
+      memset(out,0xa7,sizeof(out));
+      memcpy(want,a,64);
+      memcpy(want+64,b,64);
+      memcpy(want+128,old,64);
+      want[192]=1;
+      uint8_t *destination=want+row->destination*64;
+      memset(destination,0,64);
+      for(int i=0;i<row->width;i++) {
+        int active=!row->mode || ((mask>>(i/row->lane))&1);
+        destination[i]=active?a[i]:row->mode==2?0:b[i];
+      }
+      row->run(out+1,a,b,old,mask);
+      if(out[0]!=0xa7 || out[194]!=0xa7 || memcmp(out+1,want,sizeof(want))) {
+        fprintf(stderr,"blend row=%u trial=%u width=%d lane=%d mode=%d destination=%d\n",
+                r,trial,row->width,row->lane,row->mode,row->destination);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+`
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "mask_blend_whole_"+bank, triple, ir, mainC)
+}
+
+func TestX86MaskBlendWholeXByteSemantics(t *testing.T) {
+	x86MaskBlendWholeByteRuntime(t, "X")
+}
+
+func TestX86MaskBlendWholeYByteSemantics(t *testing.T) {
+	x86MaskBlendWholeByteRuntime(t, "Y")
+}
+
+func TestX86MaskBlendWholeZByteSemantics(t *testing.T) {
+	x86MaskBlendWholeByteRuntime(t, "Z")
+}
diff --git a/x86_mask_logical_forms.go b/x86_mask_logical_forms.go
new file mode 100644
index 000000000..8d36bdf81
--- /dev/null
+++ b/x86_mask_logical_forms.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+func (spec amd64MaskLogicalSpec) writesFlags() bool {
+	return spec.kind == amd64MaskTest || spec.kind == amd64MaskOrTest
+}
+
+func (spec amd64MaskLogicalSpec) argumentCount() int {
+	if spec.kind == amd64MaskNot || spec.writesFlags() {
+		return 2
+	}
+	return 3
+}
+
+// The complete Go family has only K,K and K,K,K operand shapes. Width,
+// numerical dependencies and FLAGS writes remain independent of that syntax.
+func x86MaskLogicalProperties(op Op, ins Instr, arch string) (amd64MaskLogicalSpec, bool, error) {
+	name, _, suffix := strings.Cut(strings.ToUpper(string(op)), ".")
+	spec, known := amd64MaskLogicalSpecs[Op(name)]
+	if !known {
+		return amd64MaskLogicalSpec{}, false, nil
+	}
+	valid := !suffix && (arch == "amd64" || arch == "386") &&
+		(ins.Op == "" || strings.EqualFold(string(ins.Op), name)) && len(ins.Args) == spec.argumentCount()
+	for _, operand := range ins.Args {
+		valid = valid && amd64IsKOperand(operand)
+	}
+	if !valid {
+		return spec, true, fmt.Errorf("%s %s requires its exact Go K-register form: %q", arch, op, ins.Raw)
+	}
+	return spec, true, nil
+}
+
+func x86MaskLogicalResultStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	spec, known, err := x86MaskLogicalProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86MaskLogicalPreservesStorage(ins) {
+		return false, known
+	}
+	inputs := 2
+	if spec.kind == amd64MaskNot {
+		inputs = 1
+	}
+	// Equal-source XOR/XNOR/ANDN produces a width-bounded constant without
+	// observing the incoming bits. Do not extend that rule to AND/OR/TEST.
+	constant := (spec.kind == amd64MaskXOR || spec.kind == amd64MaskXNOR || spec.kind == amd64MaskAndNot) &&
+		ins.Args[0].Reg == ins.Args[1].Reg
+	if !constant {
+		for _, operand := range ins.Args[:inputs] {
+			index, _ := amd64ParseKReg(operand.Reg)
+			if !state.masks[index] {
+				return false, true
+			}
+		}
+	}
+	if spec.writesFlags() {
+		state.flags = x86ByteFlagsAll
+	} else {
+		destination, _ := amd64ParseKReg(ins.Args[len(ins.Args)-1].Reg)
+		state.masks[destination] = true
+	}
+	return true, true // No GP, vector, DF, memory or unrelated mask writes.
+}
+
+// These K-only forms are identical in both x86 modes and never touch GP,
+// private storage or DF/ID. Their separate transfer still checks every mask
+// input and accounts for FLAGS writes. Raw source must retain the decoder's
+// exact opcode/operands; this grants no native entry, frame or memory role.
+func x86MaskLogicalPreservesStorage(ins Instr) bool {
+	if _, known, err := x86MaskLogicalProperties(ins.Op, ins, "amd64"); !known || err != nil {
+		return false
+	}
+	if ins.x86Encoded || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	return origin == nil || origin.op == ins.Op && reflect.DeepEqual(origin.args, ins.Args)
+}
diff --git a/x86_mask_move_gp_width_values_test.go b/x86_mask_move_gp_width_values_test.go
new file mode 100644
index 000000000..62ea0e339
--- /dev/null
+++ b/x86_mask_move_gp_width_values_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86MaskMoveIntegerKernel struct {
+	name                  string
+	inputBits, outputBits int
+}
+
+// GP word size, K value width and the KMOV memory width are separate axes.
+// The existing Q-only owner, its original sources and fixed byte anchors stay
+// unchanged; this owner extends both GP directions across the complete family.
+func x86MaskMoveGPWidthFixture(t *testing.T, arch string) (string, string, string, []x86MaskMoveIntegerKernel) {
+	t.Helper()
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations, prototypes, checks strings.Builder
+	var kernels []x86MaskMoveIntegerKernel
+	for _, row := range x86ResultMaskMoveWidthOracle {
+		bits := row.bits
+		if bits > 8*word {
+			bits = 8 * word
+		}
+		for _, fromGP := range []bool{true, false} {
+			inputBits, outputBits, result := 64, 8*word, 8
+			direction, instruction := "ToGP", row.op+" K0,AX"
+			body := "KMOVQ a+0(FP),K0\n" + instruction + "\n" + move + " AX,ret+8(FP)\nRET\n"
+			if fromGP {
+				inputBits, outputBits, result = 8*word, 64, word
+				direction, instruction = "FromGP", row.op+" AX,K0"
+				body = move + " a+0(FP),AX\n" + instruction + "\n" + fmt.Sprintf("KMOVQ K0,ret+%d(FP)\nRET\n", result)
+			}
+			for _, raw := range []bool{false, true} {
+				prefix, lowered := "Named", body
+				if raw {
+					prefix = "Raw"
+					lowered = strings.Replace(body, instruction+"\n", x86RawNumericalInstruction(t, arch, instruction), 1)
+				}
+				name := fmt.Sprintf("%s%s%d", prefix, direction, row.bits)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s", name, result+outputBits/8, lowered)
+				fmt.Fprintf(&declarations, "func %s(a uint%d) uint%d\n", name, inputBits, outputBits)
+				fmt.Fprintf(&prototypes, "extern uint%d_t %s(uint%d_t);\n", outputBits, name, inputBits)
+				fmt.Fprintf(&checks, "if(check(\"%s\",%s((uint%d_t)a),a,%d)) return 1;\n", name, name, inputBits, bits)
+				kernels = append(kernels, x86MaskMoveIntegerKernel{name, inputBits, outputBits})
+			}
+		}
+	}
+	// Native K/K and Q-memory transport must retain all 64 bits in both modes.
+	for _, raw := range []bool{false, true} {
+		name, instruction := "NamedKeepQ64", "KMOVQ K0,K1\n"
+		if raw {
+			name, instruction = "RawKeepQ64", x86RawNumericalInstruction(t, arch, "KMOVQ K0,K1")
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nKMOVQ a+0(FP),K0\n%sKMOVQ K1,ret+8(FP)\nRET\n", name, instruction)
+		fmt.Fprintf(&declarations, "func %s(a uint64) uint64\n", name)
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t);\n", name)
+		fmt.Fprintf(&checks, "if(check(\"%s\",%s(a),a,64)) return 1;\n", name, name)
+		kernels = append(kernels, x86MaskMoveIntegerKernel{name, 64, 64})
+	}
+	if len(kernels) != 18 {
+		t.Fatal("incomplete four-width GP and independent Q64 control directory", len(kernels))
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + x86MaskMoveGPWidthValueC +
+		"int main(void) { for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);++i) { uint64_t a=values[i];\n" + checks.String() + "} return 0; }\n"
+	return source.String(), declarations.String(), driver, kernels
+}
+
+func TestX86MaskMoveGPAllWidthsPortableIntegerValues(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			source, declarations, driver, kernels := x86MaskMoveGPWidthFixture(t, arch)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					context := llvm.NewContext()
+					defer context.Dispose()
+					module, err := parseIRModuleInContext(context, ir)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, row := range kernels {
+						function := module.NamedFunction(row.name)
+						if function.IsNil() || function.FirstBasicBlock().IsNil() || function.ParamsCount() != 1 ||
+							function.Param(0).Type().TypeKind() != llvm.IntegerTypeKind || function.Param(0).Type().IntTypeWidth() != row.inputBits ||
+							function.GlobalValueType().ReturnType().TypeKind() != llvm.IntegerTypeKind || function.GlobalValueType().ReturnType().IntTypeWidth() != row.outputBits {
+							t.Fatal("portable integer C ABI differs from actual LLVM signature", row.name)
+						}
+					}
+					for _, pipeline := range []struct {
+						name, level string
+						optimize    bool
+					}{
+						{"default-O0", "-O0", false}, {"default-O2", "-O2", false}, {"opt-O2", "-O2", true},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							text := ir
+							if pipeline.optimize {
+								text = x86DwordProductIROptimize(t, text)
+							}
+							execution.compileAndRunLLVM(t, "kmov-gp-width-values", text, driver, pipeline.level)
+						})
+					}
+				})
+			}
+		})
+	}
+	t.Log("source-mode integer semantics only; no pointer-width retargeting or original native KMOV/AVX512 execution")
+}
+
+const x86MaskMoveGPWidthValueC = `
+static const uint64_t values[]={
+    0,1,UINT64_C(0x7fffffff),UINT64_C(0x80000000),
+    UINT64_C(0xffffffff),UINT64_C(0x100000000),
+    UINT64_C(0xffffffff00000000),UINT64_C(0x0123456789abcdef),
+    UINT64_MAX,UINT64_C(0x8000000000000000),
+    UINT64_C(0x7fffffffffffffff),UINT64_C(0x100000001)
+};
+static int check(const char *name,uint64_t actual,uint64_t input,unsigned bits) {
+    uint64_t mask=bits==64 ? UINT64_MAX : (UINT64_C(1)<<bits)-1;
+    uint64_t expected=input&mask;
+    if(actual!=expected) {
+        fprintf(stderr,"%s input=%llx bits=%u actual=%llx expected=%llx\n",name,
+                (unsigned long long)input,bits,(unsigned long long)actual,(unsigned long long)expected);
+        return 1;
+    }
+    return 0;
+}
+`
diff --git a/x86_mask_move_literal_effect_test.go b/x86_mask_move_literal_effect_test.go
new file mode 100644
index 000000000..dd0b59f4e
--- /dev/null
+++ b/x86_mask_move_literal_effect_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86MaskMoveLiteralProofExactReadWriteRoles(t *testing.T) {
+	forms := []struct {
+		operands        string
+		gpRead, gpWrite bool
+	}{
+		{"AX,K1", true, false}, {"K1,K7", false, false}, {"K1,BX", false, true},
+		{"(DX),K1", false, false}, {"K1,(DX)", false, false},
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			for _, form := range forms {
+				t.Run(arch+"/"+row.op+"/"+form.operands, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" "+form.operands)
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					width := int64(row.bits / 8)
+					if (form.gpRead || form.gpWrite) && width > x86ResultPointerWord(arch) {
+						width = x86ResultPointerWord(arch) // GP WIG; K/memory retain native width.
+					}
+					writeWidth := width
+					if form.gpWrite && writeWidth < x86ResultPointerWord(arch) {
+						writeWidth = x86ResultPointerWord(arch)
+					}
+					want := x86TypedByteEffect{requiresResultProof: true, operands: []x86TypedByteOperand{
+						{index: 0, operand: ins.Args[0], width: width, read: true},
+						{index: 1, operand: ins.Args[1], width: writeWidth, write: true},
+					}}
+					if !known || err != nil || !reflect.DeepEqual(effect, want) {
+						t.Fatal("mask move lost exact data width, destination zeroing or preserved FLAGS", effect, known, err)
+					}
+					state := x86SDKLiteralState{comparison: 1, constant: 16, compared: true}
+					state.gp[0] = x86SDKLiteralUnknownNumber(x86ResultPointerWord(arch))
+					state.gp[1] = x86SDKLiteralValue{width: x86ResultPointerWord(arch), minimum: 0, maximum: 15}
+					state.gp[3] = x86SDKLiteralValue{symbol: "table<>", minimum: 0, maximum: 0}
+					wantState := state
+					if form.gpWrite {
+						wantState.gp[3] = x86SDKLiteralValue{}
+					}
+					if err := x86SDKLiteralTransfer(ins, &state, FuncSig{}, arch, nil); err != nil || !reflect.DeepEqual(state, wantState) {
+						t.Fatal("mask move changed unrelated range, retained overwritten literal or invented memory facts", state, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MaskMoveLiteralCannotEscapeOrPreserveOverwrittenRange(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				state := x86SDKLiteralState{}
+				state.gp[0] = x86SDKLiteralValue{symbol: "table<>"}
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s AX,K1", row.op))
+				if err := x86SDKLiteralTransfer(ins, &state, FuncSig{}, arch, nil); err == nil {
+					t.Fatal("literal address escaped as mask data")
+				}
+				state = x86SDKLiteralState{comparison: 1, constant: 16, compared: true}
+				state.gp[1] = x86SDKLiteralValue{width: x86ResultPointerWord(arch), maximum: 15}
+				ins = x86ScalarLaneInstruction(t, row.op+" K1,CX")
+				if err := x86SDKLiteralTransfer(ins, &state, FuncSig{}, arch, nil); err != nil ||
+					state.compared || state.gp[1] != (x86SDKLiteralValue{}) {
+					t.Fatal("mask destination borrowed the previous index envelope", state, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_mask_move_memory_fault_test.go b/x86_mask_move_memory_fault_test.go
new file mode 100644
index 000000000..2292b1660
--- /dev/null
+++ b/x86_mask_move_memory_fault_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Use the existing directly-owned process observer: no C signal handler, fork
+// driver or new fault framework. A failed access is never followed by a C-side
+// dereference which could disguise an optimized-away translated instruction.
+func TestX86MaskMoveAllMemoryWidthsDeadPortableFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch, move, word, original := "amd64", "MOVQ", 8, "x86_64-unknown-linux-gnu"
+	if strconv.IntSize == 32 {
+		arch, move, word, original = "386", "MOVL", 4, "i386-unknown-linux-gnu"
+	}
+	var source, declarations, callbacks, cases strings.Builder
+	var kernels []struct {
+		name  string
+		bits  int
+		store bool
+	}
+	for _, row := range x86ResultMaskMoveWidthOracle {
+		for _, store := range []bool{false, true} {
+			name, body, arguments := fmt.Sprint("KMemoryDeadLoad", row.bits), row.op+" (AX),K0\nKXORQ K0,K0,K0\n", ""
+			frame := word
+			if store {
+				name, frame, arguments = fmt.Sprint("KMemoryStore", row.bits), word+8, ",value uint64"
+				body = fmt.Sprintf("KMOVQ value+%d(FP),K0\n%s K0,(AX)\n", word, row.op)
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%sRET\n", name, frame, move, body)
+			fmt.Fprintf(&declarations, "func %s(p *uint%d%s)\n", name, row.bits, arguments)
+			argument, storeFlag := "", 0
+			if store {
+				argument, storeFlag = ",UINT64_C(0x8877665544332211)", 1
+			}
+			fmt.Fprintf(&callbacks, "extern void %s(uint%d_t*%s);\n", name, row.bits, strings.ReplaceAll(arguments, "value uint64", "uint64_t"))
+			fmt.Fprintf(&callbacks, `static int run%s(const uint8_t *p) {
+    int full=(uintptr_t)p>(uintptr_t)guard && (uintptr_t)p<=(uintptr_t)(guard+page)-%d;
+    %s((uint%d_t*)p%s);
+    if(full) {
+        for(size_t i=0;i<page;i++) {
+            uint8_t expected=(uint8_t)(i*13+17);
+            if(%d && (uintptr_t)(guard+i)>=(uintptr_t)p && (uintptr_t)(guard+i)<(uintptr_t)p+%d)
+                expected=(uint8_t)(UINT64_C(0x8877665544332211)>>(8*((uintptr_t)(guard+i)-(uintptr_t)p)));
+            if(guard[i]!=expected) return 91;
+        }
+    }
+    return 0;
+}
+`, name, row.bits/8, name, row.bits, argument, storeFlag, row.bits/8)
+			fmt.Fprintf(&cases, "{run%s,%d,%d},\n", name, row.bits/8, row.bits/8-1)
+			kernels = append(kernels, struct {
+				name  string
+				bits  int
+				store bool
+			}{name, row.bits, store})
+		}
+	}
+	if len(kernels) != 8 {
+		t.Fatal("incomplete four-width memory load/store fault directory", len(kernels))
+	}
+	x86LEAActualTargetGoObject(t, arch, original, source.String())
+	driver := x86MemoryFaultDriver(callbacks.String(), cases.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal("bounded original KMOV source rejected before execution", err)
+			}
+			for _, pipeline := range []struct {
+				name, level string
+				optimize    bool
+			}{
+				{"default-O0", "-O0", false}, {"default-O2", "-O2", false}, {"opt-O2", "-O2", true},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					text := ir
+					if pipeline.optimize {
+						text = x86DwordProductIROptimize(t, text)
+					}
+					context := llvm.NewContext()
+					defer context.Dispose()
+					module, err := parseIRModuleInContext(context, text)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, row := range kernels {
+						function := module.NamedFunction(row.name)
+						parameters := 1
+						if row.store {
+							parameters = 2
+						}
+						if function.IsNil() || function.FirstBasicBlock().IsNil() || function.ParamsCount() != parameters ||
+							function.Param(0).Type().TypeKind() != llvm.PointerTypeKind || function.GlobalValueType().ReturnType().TypeKind() != llvm.VoidTypeKind {
+							t.Fatal("actual pointer/void C ABI differs from bounded source", row.name)
+						}
+						if row.store && (function.Param(1).Type().TypeKind() != llvm.IntegerTypeKind || function.Param(1).Type().IntTypeWidth() != 64) {
+							t.Fatal("actual store input is not the declared uint64", row.name)
+						}
+						accesses := 0
+						for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+							for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+								opcode := instruction.InstructionOpcode()
+								if (opcode != llvm.Load && opcode != llvm.Store) || !instruction.IsVolatile() {
+									continue
+								}
+								typ := instruction.Type()
+								if opcode == llvm.Store {
+									typ = instruction.Operand(0).Type()
+								}
+								if (opcode == llvm.Store) != row.store || typ.TypeKind() != llvm.IntegerTypeKind || typ.IntTypeWidth() != row.bits || instruction.Alignment() != 1 {
+									t.Fatal("function lost its exact memory width/direction/alignment", row.name, instruction.String())
+								}
+								accesses++
+							}
+						}
+						if accesses != 1 {
+							t.Fatal("dead native access was removed or duplicated", row.name, accesses)
+						}
+					}
+					executable := execution.compileLLVM(t, "kmov-memory-width-faults", text, driver, pipeline.level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, len(kernels))
+				})
+			}
+		})
+	}
+	t.Log("actual-host translated NULL/partial/full-page faults and complete-page canaries; byte-access reference, not original native KMOV/AVX512 execution")
+}
diff --git a/x86_mask_value_forms.go b/x86_mask_value_forms.go
new file mode 100644
index 000000000..a701a0fd3
--- /dev/null
+++ b/x86_mask_value_forms.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The complete KADD/KSHIFT/KUNPCK grammar has only two source shapes. Width
+// and operation remain independent; sharing a row does not share semantics.
+type x86MaskValueForm struct {
+	spec   amd64MaskArithmeticSpec
+	unpack bool
+}
+
+func x86MaskValueProperties(op Op, ins Instr, arch string) (x86MaskValueForm, bool, error) {
+	spec, arithmetic := amd64MaskArithmeticSpecs[op]
+	bits, unpack := amd64MaskUnpackBits[op]
+	if !arithmetic && !unpack {
+		return x86MaskValueForm{}, false, nil
+	}
+	if unpack {
+		spec.bits = bits
+	}
+	form := x86MaskValueForm{spec: spec, unpack: unpack}
+	fail := func() (x86MaskValueForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s operands are outside Go's mask-value table: %q", arch, op, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" ||
+		ins.Op != "" && Op(strings.ToUpper(string(ins.Op))) != op || len(ins.Args) != 3 {
+		return fail()
+	}
+	first := 0
+	if spec.shift != "" {
+		immediate := ins.Args[0]
+		if !amd64UnsignedImmediate(immediate, 8) {
+			return fail()
+		}
+		first = 1
+	}
+	for _, operand := range ins.Args[first:] {
+		if !amd64IsKOperand(operand) {
+			return fail()
+		}
+	}
+	return form, true, nil
+}
+
+func x86MaskValueResultStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	form, known, err := x86MaskValueProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	first := 0
+	if form.spec.shift != "" {
+		first = 1
+	}
+	for _, operand := range ins.Args[first:2] {
+		index, _ := amd64ParseKReg(operand.Reg)
+		if !state.masks[index] {
+			return false, true
+		}
+	}
+	destination, _ := amd64ParseKReg(ins.Args[2].Reg)
+	state.masks[destination] = true
+	return true, true // All GP, memory, vector and FLAGS knowledge is preserved.
+}
diff --git a/x86_mask_vector_portable_runtime_test.go b/x86_mask_vector_portable_runtime_test.go
new file mode 100644
index 000000000..0f25c4a8f
--- /dev/null
+++ b/x86_mask_vector_portable_runtime_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Keep the discovering source unchanged. Actual-host LLVM execution supplements
+// the native x86/MXCSR owner; portable value parity does not certify that axis.
+func TestX86MaskVectorOriginalProgramsPortableCompleteBytes(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	source, _, _ := x86MaskVectorRuntimeFixture(t)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	var declarations, prototypes, checks strings.Builder
+	count := 0
+	for _, row := range x86OfficialMaskVectorRows(t) {
+		for range []string{"K0", "K7"} {
+			name := fmt.Sprintf("maskvector%d", count)
+			count++
+			fmt.Fprintf(&declarations, "func %s(out,in *byte,mask uint64)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,const uint8_t*,uint64_t);\n", name)
+			width := 16
+			if strings.Contains(row, "Y1") {
+				width = 32
+			} else if strings.Contains(row, "Z1") {
+				width = 64
+			}
+			toVector := strings.HasPrefix(row, "VPMOVM2")
+			lane := strings.TrimPrefix(strings.TrimSuffix(strings.Fields(row)[0], "2M"), "VPMOV")
+			lane = strings.TrimPrefix(lane, "M2")
+			laneBytes := map[string]int{"B": 1, "W": 2, "D": 4, "Q": 8}[lane]
+			if laneBytes == 0 {
+				t.Fatal("unmodeled independent runtime lane", row)
+			}
+			fmt.Fprintf(&checks, "if(check(%s,\"%s\",%d,%d,%t)) return 1;\n", name, name, width, laneBytes, toVector)
+		}
+	}
+	if count != 48 {
+		t.Fatal("incomplete original mask/vector program union", count)
+	}
+	driver := strings.NewReplacer("PROTOTYPES", prototypes.String(), "CHECKS", checks.String()).Replace(x86MaskVectorPortableDriver)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if strings.Count(ir, "define void @") != count {
+				t.Fatal("translation omitted an original mask/vector function")
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "mask-vector-original-portable", text, driver, level)
+				}
+			}
+		})
+	}
+}
+
+const x86MaskVectorPortableDriver = `
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+static int check(void (*program)(uint8_t*,const uint8_t*,uint64_t),
+                 const char *name,unsigned width,unsigned lane,bool toVector) {
+    const uint64_t masks[]={0,1,UINT64_MAX,UINT64_C(0x55aa55aa55aa55aa),UINT64_C(1)<<63};
+    for (unsigned round=0;round<4;++round) for (unsigned m=0;m<5;++m) {
+        uint8_t input[66],original[66],output[84];
+        for (unsigned i=0;i<66;++i) input[i]=(uint8_t)(i*19+round*83+129);
+        memcpy(original,input,sizeof(input));
+        memset(output,0xc3,sizeof(output));
+        program(output+1,input+1,masks[m]);
+        uint64_t gotMask,otherMask,wantMask=masks[m];
+        memcpy(&gotMask,output+65,8);
+        memcpy(&otherMask,output+73,8);
+        if (!toVector) {
+            wantMask=0;
+            for (unsigned element=0;element<width/lane;++element)
+                wantMask|=(uint64_t)(input[1+element*lane+lane-1]>>7)<<element;
+        }
+        if (output[0]!=0xc3 || output[83]!=0xc3 || output[81]!=1 || output[82]!=0 ||
+            gotMask!=wantMask || otherMask!=UINT64_C(0x8123456789abcdef) ||
+            memcmp(input,original,sizeof(input))) {
+            fprintf(stderr,"%s round=%u mask=%u mask/flags/input/canary failure\n",name,round,m);
+            return 1;
+        }
+        for (unsigned i=0;i<64;++i) {
+            uint8_t want=input[1+i];
+            if (toVector) want=i>=width ? 0 : (masks[m]>>(i/lane)&1) ? 255 : 0;
+            if (output[1+i]!=want) {
+                fprintf(stderr,"%s round=%u mask=%u byte=%u got=%x want=%x\n",name,round,m,i,output[1+i],want);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+CHECKS
+    return 0;
+}
+`
diff --git a/x86_mask_vector_result_test.go b/x86_mask_vector_result_test.go
new file mode 100644
index 000000000..8d2e7ff4b
--- /dev/null
+++ b/x86_mask_vector_result_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent lane dependencies: VPMOV*2M reads each lane's sign byte, not
+// unrelated bytes. The production form is used only by the consumer under test.
+func x86MaskVectorSignBytes(row string, width int) uint64 {
+	lane := map[string]int{"B": 1, "W": 2, "D": 4, "Q": 8}[strings.TrimSuffix(strings.TrimPrefix(strings.Fields(row)[0], "VPMOV"), "2M")]
+	if lane == 0 {
+		panic("sign-byte oracle requires a vector-to-mask row")
+	}
+	var required uint64
+	for offset := lane - 1; offset < width; offset += lane {
+		required |= uint64(1) << uint(offset)
+	}
+	return required
+}
+
+func TestX86MaskVectorMissingSignBytesAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86OfficialMaskVectorRows(t) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				toVector := strings.HasPrefix(row, "VPMOVM2")
+				width := 16
+				if strings.Contains(row, "Y1") {
+					width = 32
+				} else if strings.Contains(row, "Z1") {
+					width = 64
+				}
+				for missing := 0; missing < 64; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.masks[2] = true
+					state.writeVector(1, 64, ^(uint64(1) << uint(missing)), false)
+					want := state.clone()
+					required := toVector
+					if !toVector {
+						required = x86MaskVectorSignBytes(row, width)&(uint64(1)<<uint(missing)) != 0
+						if !required {
+							want.masks[1] = true
+						}
+					}
+					if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) == required || !reflect.DeepEqual(state, want) {
+						t.Fatal("missing sign/mask input escaped or irrelevant byte became a dependency", missing)
+					}
+				}
+				for _, raw := range []bool{false, true} {
+					state := x86ResultState{}
+					state.masks[1] = true
+					state.writeVector(1, 64, ^uint64(0), false)
+					before := state.clone()
+					changed := ins
+					if raw {
+						changed.x86Encoded = true
+					} else {
+						changed.Op += ".Z"
+					}
+					if x86ScalarFPResultTransfer(changed, &state, nil, 0, arch) || !reflect.DeepEqual(before, state) {
+						t.Fatal("unbound physical source or reserved suffix borrowed a named numerical effect")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskVectorCompleteNumericalInputsAndUnaffectedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86OfficialMaskVectorRows(t) {
+			for _, mask := range []string{"K0", "K7"} {
+				t.Run(arch+"/"+strings.ReplaceAll(row, "K1", mask), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, strings.ReplaceAll(row, "K1", mask))
+					vector, width := 1, 16
+					if strings.Contains(row, "Y1") {
+						width = 32
+					} else if strings.Contains(row, "Z1") {
+						width = 64
+					}
+					maskIndex := 0
+					if mask == "K7" {
+						maskIndex = 7
+					}
+					toVector := strings.HasPrefix(row, "VPMOVM2")
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.gp[3], state.canonicalGP[3], state.pointerGP[3] = 0xa5, 0x11, true
+					state.masks[2] = true
+					state.writeVector(3, 64, 0x76543210fedcba98, false)
+					known := uint64(0x13579bdf02468ace) &^ x86CallerVectorByteMask(int64(width))
+					if toVector {
+						state.masks[maskIndex] = true
+					} else {
+						known |= x86MaskVectorSignBytes(row, width)
+					}
+					state.writeVector(vector, 64, known, false)
+					want := state.clone()
+					if toVector {
+						want.writeVector(vector, width, x86CallerVectorByteMask(int64(width)), false)
+					} else {
+						want.masks[maskIndex] = true
+					}
+					if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+						t.Fatal("complete mask/vector data effect is missing, over-reads lanes or changes unrelated state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MaskVectorInitializedResultsThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86OfficialMaskVectorRows(t) {
+				for _, mask := range []string{"K0", "K7"} {
+					name := fmt.Sprintf("MaskData%d", count)
+					count++
+					fmt.Fprintf(&declarations, "func %s(x uint64) uint64\n", name)
+					fmt.Fprintf(&source, "TEXT %s(SB),4,$0-16\n", name)
+					if strings.HasPrefix(row, "VPMOVM2") {
+						fmt.Fprintf(&source, "KMOVQ x+0(FP),%s\n%s\nPEXTRD $0,X1,ret+8(FP)\nPEXTRD $1,X1,ret+12(FP)\n", mask, strings.ReplaceAll(row, "K1", mask))
+					} else {
+						fmt.Fprintf(&source, "VPXORD Z1,Z1,Z1\n%s\nKMOVQ %s,ret+8(FP)\n", strings.ReplaceAll(row, "K1", mask), mask)
+					}
+					source.WriteString("RET\n")
+				}
+			}
+			if count != 48 {
+				t.Fatal("incomplete independent Go-row/K0-K7 program union", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Error("initialized mask/vector programs lost their numerical effects", api, err)
+					continue
+				}
+				if strings.Count(ir, "define i64 @") != count {
+					t.Fatal("translation omitted an original mask/vector function", api)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskVectorVoidInputsCannotBorrowImplementationZeros(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86OfficialMaskVectorRows(t) {
+			if !strings.Contains(row, "X1") {
+				continue // The independent unit/object axes already retain every X/Y/Z row.
+			}
+			for _, unusedBool := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/bool-%t", target.triple, row, unusedBool), func(t *testing.T) {
+					declaration, extent := "func Value()", 0
+					if unusedBool {
+						declaration, extent = "func Value(flag bool)", 1
+					}
+					source := fmt.Sprintf("TEXT Value(SB),4,$0-%d\n%s\nRET\n", extent, strings.ReplaceAll(row, "K1", "K0"))
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if target.arch == "amd64" && unusedBool && !strings.HasPrefix(row, "VPMOVM2") {
+							x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("missing source mask/vector data became initialized private zeros", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_mixed_bool_parameter_roles_test.go b/x86_mixed_bool_parameter_roles_test.go
new file mode 100644
index 000000000..57fcaf75b
--- /dev/null
+++ b/x86_mixed_bool_parameter_roles_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// A typed pointer occupies its ABI0 parameter slot even when the function
+// returns only numbers and a bool. The slot is not a numerical input, and the
+// declaration alone supplies no pointee contents or physical caller frame.
+func TestX86MixedBoolResultPointerAndAggregateParametersThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := int64(8), "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct {
+			name, parameter, result string
+			parameterWords          int64
+			read                    string
+		}{
+			{name: "unused-pointer", parameter: "p *uint64", result: "uint64", parameterWords: 1},
+			{name: "read-pointer", parameter: "p *uint64", result: "uint64", parameterWords: 1, read: "pointer"},
+			{name: "unused-slice", parameter: "s []uint64", result: "uintptr", parameterWords: 3},
+			{name: "slice-length", parameter: "s []uint64", result: "uintptr", parameterWords: 3, read: "length"},
+			{name: "unused-string", parameter: "s string", result: "uintptr", parameterWords: 2},
+			{name: "string-length", parameter: "s string", result: "uintptr", parameterWords: 2, read: "length"},
+		} {
+			declaration := fmt.Sprintf("func Value(%s) (n %s, ok bool)", row.parameter, row.result)
+			_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+			resultBytes := word
+			if row.result == "uint64" {
+				resultBytes = 8
+			}
+			resultOffset := row.parameterWords * word
+			if len(sig.Args) != 1 || len(sig.Frame.Params) != int(row.parameterWords) ||
+				len(sig.Frame.Results) != 2 || sig.Frame.Params[0].Type != Ptr ||
+				sig.Frame.Params[0].Offset != 0 || sig.Frame.Results[0].Offset != resultOffset ||
+				sig.Frame.Results[1].Offset != resultOffset+resultBytes {
+				t.Fatalf("%s/%s: actual typed parameter/result layout changed: %+v", arch, row.name, sig)
+			}
+			if row.parameterWords > 1 {
+				expected := LLVMType(fmt.Sprintf("{ ptr, i%d }", 8*word))
+				if row.parameterWords == 3 {
+					expected = LLVMType(fmt.Sprintf("{ ptr, i%d, i%d }", 8*word, 8*word))
+				}
+				if sig.Args[0] != expected {
+					t.Fatalf("%s/%s: aggregate parameter was scalarized: %s", arch, row.name, sig.Args[0])
+				}
+			}
+			var body string
+			switch row.read {
+			case "pointer":
+				body = fmt.Sprintf("%s p+0(FP),AX\n", move)
+				for offset := int64(0); offset < resultBytes; offset += word {
+					body += fmt.Sprintf("%s %d(AX),BX\n%s BX,n+%d(FP)\n", move, offset, move, resultOffset+offset)
+				}
+			case "length":
+				body = fmt.Sprintf("%s s_len+%d(FP),AX\n%s AX,n+%d(FP)\n", move, word, move, resultOffset)
+			default:
+				for offset := int64(0); offset < resultBytes; offset += word {
+					body += fmt.Sprintf("%s $5,n+%d(FP)\n", move, resultOffset+offset)
+				}
+			}
+			body += fmt.Sprintf("MOVB $1,ok+%d(FP)\nRET", resultOffset+resultBytes)
+			_, _, _, source := x86ResultInitializationFixture(t, arch, declaration, body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("ordinary typed mixed result rejected: output=%t error=%v", ir != "", err)
+					}
+					context := llvm.NewContext()
+					defer context.Dispose()
+					module, err := parseIRModuleInContext(context, ir)
+					if !module.IsNil() {
+						defer module.Dispose()
+					}
+					if err != nil {
+						t.Fatal("typed result module did not parse", err)
+					}
+					if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+						t.Fatal("typed result module did not verify", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MixedBoolResultPointerParameterDoesNotGrantNumericalAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := int64(8), "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		declaration := "func Value(p *uint32) (n uintptr, ok bool)"
+		for _, row := range []struct{ name, body string }{
+			{"pointer-bits-as-number", fmt.Sprintf("%s p+0(FP),AX\n%s AX,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET", move, move, word, 2*word)},
+			// Preserve this original source/case ID: $7 defines an address's
+			// numerical bits independently of the unused pointer parameter.
+			{"unknown-address", fmt.Sprintf("%s $7,AX\n%s (AX),BX\n%s BX,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET", move, move, move, word, 2*word)},
+			{"unknown-register-address", fmt.Sprintf("%s (AX),BX\n%s BX,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET", move, move, word, 2*word)},
+			{"partial-register-address", fmt.Sprintf("MOVB $7,AL\n%s (AX),BX\n%s BX,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET", move, move, word, 2*word)},
+			{"noncanonical-bool", fmt.Sprintf("%s $5,n+%d(FP)\nMOVB $2,ok+%d(FP)\nRET", move, word, 2*word)},
+			{"missing-number", fmt.Sprintf("MOVB $1,ok+%d(FP)\nRET", 2*word)},
+		} {
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, row.body)
+			if row.name == "unknown-address" || row.name == "missing-number" {
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("the standalone source/result audit lost its original strict outcome", err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if row.name == "unknown-address" || row.name == "missing-number" {
+						if err != nil || ir == "" {
+							t.Fatal("valid code generation borrowed a pointer fact or was blocked by its separate result audit", err)
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM22 llc required")
+						}
+						x86ResultInitializationObject(t, llc, triple, ir, "ordinary-pointer-tuple")
+						return
+					}
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("pointer layout granted unrelated NUM/canonical authority: output=%t error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_mixed_bool_result.go b/x86_mixed_bool_result.go
new file mode 100644
index 000000000..1b9a22560
--- /dev/null
+++ b/x86_mixed_bool_result.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"unicode"
+)
+
+// Initialized physical bytes are not a canonical bool witness. The existing
+// scalar-I1 consumers retain their own entry/result proofs; an aggregate or
+// contradictory result layout needs an independent complete canonical role.
+// Inspect both declaration and modeled slots so dropping a bool field cannot
+// turn an unregistered role into an ordinary numerical result.
+func x86MixedBoolResultNeedsCanonicalRole(sig FuncSig, modeled []FrameSlot) bool {
+	if sig.Ret == Void {
+		return false
+	}
+	containsBool := func(typ LLVMType) bool {
+		for _, token := range strings.FieldsFunc(string(typ), func(r rune) bool {
+			return unicode.IsSpace(r) || strings.ContainsRune("{}[]<>,", r)
+		}) {
+			if token == string(I1) {
+				return true
+			}
+		}
+		return false
+	}
+	hasBool := containsBool(sig.Ret)
+	for _, slots := range [][]FrameSlot{sig.Frame.Results, modeled} {
+		for _, slot := range slots {
+			hasBool = hasBool || containsBool(slot.Type)
+		}
+	}
+	if !hasBool {
+		return false
+	}
+	if sig.Ret != I1 || len(sig.Frame.Results) > 1 || len(modeled) > 1 {
+		return true
+	}
+	if len(sig.Frame.Results) == 0 && len(modeled) == 0 {
+		return false // A scalar register-result role has no logical FP slots.
+	}
+	return !reflect.DeepEqual(sig.Frame.Results, modeled) || sig.Frame.Results[0].Type != I1
+}
+
+func (c *amd64Ctx) validateMixedBoolResultRole() error {
+	if !x86MixedBoolResultNeedsCanonicalRole(c.sig, c.fpResults) {
+		return nil
+	}
+	if !reflect.DeepEqual(c.sig.Frame.Results, c.fpResults) {
+		return fmt.Errorf("%w: mixed bool result requires an independent canonical result role", ErrProbeNeedsContext)
+	}
+	if c.fpScalarSource.x86FixedLocal == nil {
+		if !x86OrdinaryMixedBoolResultRole(c.fpScalarSource, c.sig, c.goarch) {
+			return fmt.Errorf("%w: mixed bool result requires an ordinary bounded ABI0 declaration", ErrProbeNeedsContext)
+		}
+		if err := c.scalarFPResultInitialized(); err != nil {
+			return err
+		}
+		c.fpMixedBoolBytes = true
+		return nil
+	}
+	// This consumer rechecks the actual declaration, original/normalized source,
+	// all field writes and before/final live binding guards. A pointer alone is
+	// not authority, nor does this add a new aggregate or native-frame producer.
+	return c.scalarFPResultInitialized()
+}
+
+// A source-shape restriction shared by ordinary lowering checks. It supplies
+// no initialized values, source authentication, frame or caller permission.
+func x86OrdinaryScalarCodegenSource(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" && arch != "386" || fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		sig.arm64FPReadDeclaration != nil || sig.arm64ABI0Declaration != nil || sig.arm64ABI0TailDeclaration != nil || sig.arm64NativeScratch != nil ||
+		sig.WASMContext != "" || sig.WASMNative || sig.x86BorrowedBoolTail || sig.amd64GoArguments != nil ||
+		sig.x86FixedLocal != nil || sig.x86CallerRegions != nil || len(fn.X86RawText) != 0 || fn.X86RawAlign != 0 || fn.x86SourceStack != nil ||
+		fn.arm64PrivateRegisterEntry || fn.arm64PrivateUnexposedFrame || fn.arm64PrivateTailSource != nil ||
+		fn.arm64PrivateCallSource != nil || fn.arm64ABI0TailSource != nil ||
+		fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil || fn.x86RawReplay != nil ||
+		len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 || fn.x86BoolCalls != nil || fn.x86BoolReadonlyInputs {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" || isX86RawDirective(ins) || !x86ResultNamedPredicateInstruction(ins) {
+			return false
+		}
+	}
+	return true
+}
+
+// This is a lowering-only logical frame shape, never a native entry, caller
+// extent or source authentication. The complete NUM/canonical flow checker
+// independently validates every typed slot, instruction and path to RET.
+func x86OrdinaryMixedBoolResultRole(fn Func, sig FuncSig, arch string) bool {
+	if !x86OrdinaryScalarTupleResultRole(fn, sig, arch) {
+		return false
+	}
+	for _, slot := range sig.Frame.Results {
+		if slot.Type == I1 {
+			return true
+		}
+	}
+	return false
+}
+
+func x86OrdinaryScalarTupleResultRole(fn Func, sig FuncSig, arch string) bool {
+	fields := x86ScalarTupleResultTypes(sig, arch)
+	if len(fields) == 0 || len(fields) != len(sig.Frame.Results) {
+		return false
+	}
+	if !x86OrdinaryScalarCodegenSource(fn, sig, arch) {
+		return false
+	}
+	end := int64(0)
+	for index, slot := range sig.Frame.Results {
+		width := x86ResultScalarBytes(slot.Type, arch)
+		if width <= 0 || slot.Type != fields[index] || slot.Index != index || slot.Field != -1 || len(slot.Fields) != 0 ||
+			slot.Offset < end || slot.Offset > 4096-width {
+			return false
+		}
+		end = slot.Offset + width
+	}
+	// Omitted TEXT argument size is Go's unknown-size spelling, not an
+	// explicit zero-byte frame. The typed declaration still bounds every
+	// input/result, and an explicit conflicting extent remains invalid.
+	if fn.ArgSize != end && !x86TEXTArgumentsUnspecified(fn) ||
+		len(sig.Frame.Params) > 4096 || len(sig.Args) > 4096 {
+		return false
+	}
+	represented := make(map[int]bool)
+	for _, slot := range sig.Frame.Params {
+		// Parameters include opaque pointer leaves, including slice/string
+		// data. Occupancy is a frame role, not numerical result authority;
+		// the complete flow checker keeps pointer and NUM bytes separate.
+		if _, valid := x86ResultParameterRole(sig.Args, slot); !valid || x86FrameScalarBytes(slot.Type, arch) == 0 {
+			return false
+		}
+		represented[slot.Index] = true
+	}
+	if len(represented) != len(sig.Args) {
+		return false
+	}
+	return true
+}
+
+// Select only the existing flat scalar result kinds. Opaque pointers, nested
+// LLVM aggregates and vectors keep their independent lowering contracts.
+func x86ScalarTupleResultTypes(sig FuncSig, arch string) []LLVMType {
+	fields, valid := parseLiteralStructFields(sig.Ret)
+	if !valid || len(fields) < 2 {
+		return nil
+	}
+	for _, field := range fields {
+		if x86ResultScalarBytes(field, arch) == 0 {
+			return nil
+		}
+	}
+	return fields
+}
+
+func x86MixedBoolCanonicalTransfer(transfer x86ResultSourceTransfer) x86ResultSourceTransfer {
+	return func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		beforeFP, beforeGP := append([]bool(nil), state.canonicalFP...), state.canonicalGP
+		if !transfer(ordinal, ins, state, owned, resultOffset, arch) {
+			return false
+		}
+		state.canonicalFP, state.canonicalGP = x86ABI0CanonicalBytesAfter(ins, beforeFP, beforeGP, arch)
+		for offset := range state.canonicalFP {
+			state.canonicalFP[offset] = state.canonicalFP[offset] && state.fp[offset]
+		}
+		for root := range state.canonicalGP {
+			state.canonicalGP[root] &= state.gp[root]
+		}
+		return true
+	}
+}
diff --git a/x86_mixed_bool_result_test.go b/x86_mixed_bool_result_test.go
new file mode 100644
index 000000000..42c99b74c
--- /dev/null
+++ b/x86_mixed_bool_result_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86MixedBoolResultSource(t *testing.T, arch, other string, boolFirst bool) (string, string) {
+	t.Helper()
+	results := other + ",bool"
+	if boolFirst {
+		results = "bool," + other
+	}
+	declaration := "func Value() (" + results + ")"
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+	var body strings.Builder
+	body.WriteString("MOVL $2,AX\n")
+	for index, slot := range sig.Frame.Results {
+		if slot.Type == I1 {
+			fmt.Fprintf(&body, "MOVB AX,ret%d+%d(FP)\n", index, slot.Offset)
+			continue
+		}
+		width := x86FrameScalarBytes(slot.Type, arch)
+		if width == 8 && arch == "386" {
+			fmt.Fprintf(&body, "MOVL $0,ret%d+%d(FP)\nMOVL $0,ret%d+%d(FP)\n", index, slot.Offset, index, slot.Offset+4)
+		} else {
+			move := map[int64]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+			if move == "" {
+				t.Fatal("actual mixed result field is no longer scalar")
+			}
+			fmt.Fprintf(&body, "%s $0,ret%d+%d(FP)\n", move, index, slot.Offset)
+		}
+	}
+	_, _, _, source := x86ResultInitializationFixture(t, arch, declaration, body.String()+"RET")
+	return source, declaration
+}
+
+func TestX86MixedBoolResultCompleteScalarPartnersThreeAPIs(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, other := range []string{"uint8", "uint16", "uint32", "uint64", "float32", "float64"} {
+			for _, boolFirst := range []bool{false, true} {
+				source, declaration := x86MixedBoolResultSource(t, target.arch, other, boolFirst)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/bool-first=%t/%s", target.triple, other, boolFirst, api), func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+declaration+"\n", target.arch, target.triple)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("mixed bool initialized raw2 became canonical without a result role: output=%t error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86MixedBoolResultRoleCannotDropDeclaredOrModeledBool(t *testing.T) {
+	boolean := []FrameSlot{{Type: I1}}
+	integer := []FrameSlot{{Type: I32}}
+	for _, test := range []struct {
+		name              string
+		ret               LLVMType
+		declared, modeled []FrameSlot
+		needs             bool
+	}{
+		{"scalar-register", I1, nil, nil, false},
+		{"scalar-frame", I1, boolean, boolean, false},
+		{"void-existing-role", Void, boolean, boolean, false},
+		{"integer", I32, integer, integer, false},
+		{"integer-not-i1-prefix", "{ i16, i128 }", nil, nil, false},
+		{"aggregate-missing-layout", "{ i1, i32 }", nil, nil, true},
+		{"aggregate-masked-layout", "{ i1, i32 }", integer, integer, true},
+		{"nested-bool", "{ i32, [2 x i1] }", nil, nil, true},
+		{"declared-bool", I32, boolean, integer, true},
+		{"modeled-bool", I32, integer, boolean, true},
+		{"scalar-dropped-model", I1, boolean, nil, true},
+		{"scalar-dropped-declaration", I1, nil, boolean, true},
+		{"scalar-wrong-layout", I1, integer, integer, true},
+		{"scalar-multiple-fields", I1, append(append([]FrameSlot(nil), boolean...), integer...), boolean, true},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			sig := FuncSig{Ret: test.ret, Frame: FrameLayout{Results: test.declared}}
+			if got := x86MixedBoolResultNeedsCanonicalRole(sig, test.modeled); got != test.needs {
+				t.Fatalf("canonical role needed=%t, want %t", got, test.needs)
+			}
+		})
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch+"/copied-proof-pointer", func(t *testing.T) {
+			slots := []FrameSlot{{Type: I1}, {Type: I32, Offset: 4}}
+			c := amd64Ctx{goarch: arch, sig: FuncSig{Ret: "{ i1, i32 }", Frame: FrameLayout{Results: slots}}, fpResults: slots}
+			c.fpScalarSource.x86FixedLocal = &x86FixedLocalProof{}
+			if err := c.validateMixedBoolResultRole(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("copied fixed-local pointer granted canonical fields: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86MixedBoolResultOrdinaryCanonicalThreeAPIs(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, boolFirst := range []bool{false, true} {
+			declaration := "func Value(n uint32, x bool) (uint32, bool)"
+			input, boolean, number := 4, 12, 8
+			if boolFirst {
+				declaration = "func Value(x bool, n uint32) (bool, uint32)"
+				input, boolean, number = 0, 8, 12
+			}
+			copyBool := fmt.Sprintf("MOVB x+%d(FP),AX\nMOVB AX,ret+%d(FP)\n", input, boolean)
+			storeBool := func(value int) string {
+				return fmt.Sprintf("MOVB $%d,ret+%d(FP)\n", value, boolean)
+			}
+			storeNumber := fmt.Sprintf("MOVL $7,ret+%d(FP)\n", number)
+			roundtrip := storeBool(2) + fmt.Sprintf("MOVL $0,AX\nMOVB ret+%d(FP),AX\nMOVL AX,ret+%d(FP)\n", boolean, number)
+			for _, row := range []struct {
+				name, body string
+				accept     bool
+			}{
+				{"typed-entry-copy", copyBool + storeNumber + "RET", true},
+				{"constant-zero", storeBool(0) + storeNumber + "RET", true},
+				{"constant-one", storeBool(1) + storeNumber + "RET", true},
+				{"physical-byte-roundtrip", roundtrip + storeBool(1) + "RET", true},
+				{"canonical-join", "MOVL $1,AX\nCMPL AX,$0\nJE other\n" + storeBool(0) + "JMP end\nother:\n" + copyBool + "end:\n" + storeNumber + "RET", true},
+				{"raw-two", storeBool(2) + storeNumber + "RET", false},
+				{"unknown-byte", fmt.Sprintf("MOVB DX,ret+%d(FP)\n", boolean) + storeNumber + "RET", false},
+				{"numeric-input-is-not-bool", fmt.Sprintf("MOVL n+%d(FP),AX\nMOVB AX,ret+%d(FP)\n", 4-input, boolean) + storeNumber + "RET", false},
+				{"noncanonical-join", "MOVL $1,AX\nCMPL AX,$0\nJE other\n" + storeBool(2) + "JMP end\nother:\n" + copyBool + "end:\n" + storeNumber + "RET", false},
+				{"missing-number", copyBool + "RET", true},
+				{"partial-number", copyBool + fmt.Sprintf("MOVB $7,ret+%d(FP)\nRET", number), true},
+				{"overwritten-canonical", copyBool + storeBool(2) + storeNumber + "RET", false},
+				{"dead-unknown-effect", copyBool + storeNumber + "JMP end\nCALL ·unknown(SB)\nend:\nRET", false},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/bool-first=%t/%s/%s", target.triple, boolFirst, row.name, api), func(t *testing.T) {
+						_, file, sig, source := x86ResultInitializationFixture(t, target.arch, declaration, row.body)
+						incomplete := row.name == "missing-number" || row.name == "partial-number"
+						if incomplete && !errors.Is(CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch), ErrProbeNeedsContext) {
+							t.Fatal("the original incomplete-result audit disappeared")
+						}
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+declaration+"\n", target.arch, target.triple)
+						if row.accept {
+							if err != nil || ir == "" {
+								t.Fatalf("canonical typed tuple rejected: output=%t error=%v", ir != "", err)
+							}
+							if row.name == "physical-byte-roundtrip" && !strings.Contains(ir, " = zext i8 ") {
+								t.Fatal("intermediate bool byte was normalized before its numerical observation")
+							}
+							if incomplete {
+								llc := findLLVM22Tool("llc")
+								if llc == "" {
+									t.Fatal("LLVM22 llc required")
+								}
+								x86ResultInitializationObject(t, llc, target.triple, ir, "partial-numeric-tuple")
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("unproved tuple accepted: output=%t error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86MixedBoolResultOrdinaryCanonicalRoleBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name   string
+			mutate func(*Func, *FuncSig)
+		}{
+			{"native-frame", func(fn *Func, _ *FuncSig) { fn.FrameSize = 4 }},
+			{"wrong-extent", func(fn *Func, _ *FuncSig) { fn.ArgSize++ }},
+			{"register-entry", func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" }},
+			{"custom-registers", func(_ *Func, sig *FuncSig) { sig.ArgRegs = []Reg{"AX"} }},
+			{"borrowed-bool", func(_ *Func, sig *FuncSig) { sig.x86BorrowedBoolTail = true }},
+			{"raw-text", func(fn *Func, _ *FuncSig) { fn.X86RawText = []byte{0xc3} }},
+			{"source-stack", func(fn *Func, _ *FuncSig) { fn.x86SourceStack = &x86SourceStackProof{} }},
+			{"fixed-local", func(fn *Func, _ *FuncSig) { fn.x86FixedLocal = &x86FixedLocalProof{} }},
+			{"coalesced-flow", func(fn *Func, _ *FuncSig) { fn.x86ContinuationFlow = &x86ContinuationFlow{} }},
+			{"wrong-result-type", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Type = I8 }},
+			{"wrong-result-index", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Index = 1 }},
+			{"nested-result", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Fields = []int{0} }},
+			{"overlapping-results", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Offset = sig.Frame.Results[0].Offset }},
+			{"untyped-bool-entry", func(_ *Func, sig *FuncSig) { sig.Args[0] = I8 }},
+			{"overlapping-parameters", func(_ *Func, sig *FuncSig) { sig.Frame.Params[1].Offset = 0 }},
+			{"unrepresented-argument", func(_ *Func, sig *FuncSig) { sig.Args = append(sig.Args, I32) }},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch,
+					"func Value(x bool, n uint32) (bool, uint32)",
+					"MOVB x+0(FP),AX\nMOVB AX,ret+8(FP)\nMOVL $7,ret+12(FP)\nRET")
+				fn := file.Funcs[0]
+				row.mutate(&fn, &sig)
+				c := &amd64Ctx{goarch: arch, sig: sig, fpResults: sig.Frame.Results, fpScalarSource: fn}
+				if err := c.validateMixedBoolResultRole(); !errors.Is(err, ErrProbeNeedsContext) || c.fpMixedBoolBytes {
+					t.Fatalf("incomplete tuple acquired canonical physical-byte storage: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_mixed_bool_text_extent_test.go b/x86_mixed_bool_text_extent_test.go
new file mode 100644
index 000000000..9656f50f3
--- /dev/null
+++ b/x86_mixed_bool_text_extent_test.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86MixedBoolOmittedTEXTArguments(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range []struct {
+			extent string
+			valid  bool
+		}{
+			{"$0", true},
+			{fmt.Sprintf("$0-%d", 2*word+1), true},
+			{"$0-0", false},
+			{fmt.Sprintf("$0-%d", 2*word), false},
+			{fmt.Sprintf("$0-%d", 3*word), false},
+		} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,%s\n%s $5,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET\n",
+				row.extent, move, word, 2*word)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.extent+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func Value(p *byte) (n uintptr, ok bool)", target.arch, target.triple, api)
+					if row.valid {
+						if err != nil || ir == "" {
+							t.Fatalf("ordinary typed mixed result rejected TEXT extent %s: %v", row.extent, err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("explicit TEXT mismatch gained a frame: output=%t err=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_mmx_original_fixture_objects_test.go b/x86_mmx_original_fixture_objects_test.go
new file mode 100644
index 000000000..cb60d537d
--- /dev/null
+++ b/x86_mmx_original_fixture_objects_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MMXNarrowOriginalFixtureObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	count := 0
+	for _, row := range x86NarrowOracleRows() {
+		if row.bank != "M" {
+			continue
+		}
+		name := fmt.Sprintf("Narrow%d", count)
+		source.WriteString(x86NarrowIndependentAssembly(name, row))
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte,mask,flags uint64,csr uint32)\n", name)
+		count++
+	}
+	if count != 12 {
+		t.Fatal("complete original MMX narrowing fixture denominator changed", count)
+	}
+	x86MMXOriginalFixtureObjects(t, source.String(), declarations.String())
+}
+
+func TestX86MMXWordMaddOriginalLogicalFPFixtureObjects(t *testing.T) {
+	source := x86WordMaddLogicalFPAssembly("Value", 8, 0)
+	x86MMXOriginalFixtureObjects(t, source, "func Value(source [64]byte,out *byte,mask uint64)")
+}
+
+func TestX86MMXOriginalFixturesKeepPhysicalStateBoundary(t *testing.T) {
+	var row x86NarrowOracleRow
+	for _, candidate := range x86NarrowOracleRows() {
+		if candidate.bank == "M" {
+			row = candidate
+			break
+		}
+	}
+	if row.bank != "M" {
+		t.Fatal("original MMX narrowing family disappeared")
+	}
+	setup := "LDMXCSR csr+48(FP)\nPUSHQ flags+40(FP)\nPOPFQ\n"
+	narrow := x86NarrowIndependentAssembly("Value", row)
+	narrow = strings.Replace(narrow, setup, "", 1)
+	narrow = strings.Replace(narrow, "MOVQ (DX),M1\n", "MOVQ (DX),M1\n"+setup, 1)
+	madd := strings.Replace(x86WordMaddLogicalFPAssembly("Value", 8, 0), "EMMS\n", "", 1)
+	for _, control := range []struct{ name, source, declaration string }{
+		{"interrupted-region", narrow, "func Value(out *[80]byte,a,b,old *[64]byte,mask,flags uint64,csr uint32)"},
+		{"missing-emms", madd, "func Value(source [64]byte,out *byte,mask uint64)"},
+	} {
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(control.name+"/"+triple, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", triple, control.source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, control.source, control.declaration, "amd64", triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unclosed physical MMX state was accepted", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86MMXOriginalFixtureObjects(t *testing.T, source, declarations string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("original initialized MMX fixture did not close its physical state", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_mmx_scalar_fixture_source_test.go b/x86_mmx_scalar_fixture_source_test.go
new file mode 100644
index 000000000..9e36a90db
--- /dev/null
+++ b/x86_mmx_scalar_fixture_source_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86LegacyPackedLogicalMMXRuntimeSource = `TEXT legacypackedlogicalsemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	STC
+	MOVQ a+8(FP), M0
+	MOVQ b+16(FP), M1
+	PAND M0, M1
+	MOVQ M1, 0(AX)
+	MOVQ a+8(FP), M0
+	MOVQ b+16(FP), M1
+	PANDN M0, M1
+	MOVQ M1, 8(AX)
+	MOVQ a+8(FP), M0
+	MOVQ b+16(FP), M1
+	POR M0, M1
+	MOVQ M1, 16(AX)
+	MOVQ a+8(FP), M0
+	MOVQ b+16(FP), M1
+	PXOR M0, M1
+	MOVQ M1, 24(AX)
+	EMMS
+	SETCS 32(AX)
+	RET
+`
+
+const x86PADDDGoAliasRuntimeSource = `TEXT padddaliassemantics(SB),$0-24
+	MOVQ out+0(FP), AX
+	STC
+	MOVQ a+8(FP), M0
+	MOVQ b+16(FP), M1
+	PADDD M0, M1
+	MOVQ M1, 0(AX)
+	EMMS
+	SETCS 8(AX)
+	RET
+`
+
+func TestX86MMXOriginalScalarLogicalAndPADDDObjects(t *testing.T) {
+	for _, fixture := range []struct{ name, source, declaration string }{
+		{"logical", x86LegacyPackedLogicalMMXRuntimeSource, "func legacypackedlogicalsemantics(out *byte,a,b uint64)"},
+		{"paddd", x86PADDDGoAliasRuntimeSource, "func padddaliassemantics(out *byte,a,b uint64)"},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			x86MMXOriginalFixtureObjects(t, fixture.source, fixture.declaration)
+		})
+	}
+}
+
+func TestX86MMXAverageOriginalFixtureObjects(t *testing.T) {
+	var rows []x86AverageNumericCase
+	for _, row := range x86AverageNumericCases() {
+		if row.mmx {
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 4 {
+		t.Fatal("complete original MMX average denominator changed", len(rows))
+	}
+	source, _, _ := x86AverageNumericFixture(t, rows)
+	var declarations strings.Builder
+	for index := range rows {
+		fmt.Fprintf(&declarations, "func average%d(out,a,b *byte,mask,flags uint64)\n", index)
+	}
+	x86MMXOriginalFixtureObjects(t, source, declarations.String())
+}
+
+func TestX86MMXWrappingAddOriginalFixtureObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	count := 0
+	for _, op := range []string{"PADDB", "PADDW", "PADDL"} {
+		for _, input := range []string{"M1", "(BX)"} {
+			name := fmt.Sprintf("Add%d", count)
+			source.WriteString(x86PackedAddMMXAssembly(name, op, input))
+			fmt.Fprintf(&declarations, "func %s(out,a,b *byte,mask uint64)\n", name)
+			count++
+		}
+	}
+	if count != 6 {
+		t.Fatal("complete original MMX wrapping add denominator changed", count)
+	}
+	x86MMXOriginalFixtureObjects(t, source.String(), declarations.String())
+}
diff --git a/x86_mmx_shuffle_madd_contract_test.go b/x86_mmx_shuffle_madd_contract_test.go
new file mode 100644
index 000000000..29d59e759
--- /dev/null
+++ b/x86_mmx_shuffle_madd_contract_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// Keep the discovering unclosed format sources in their original tests. These
+// separate programs supply real FP inputs and close the hardware MMX/x87 state.
+func TestX86MMXShuffleMultiplyAddCompleteSourceBoundaries(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	const declaration = "func Value(a,b uint64) uint64"
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []string{"PSHUFW $-128,M0,M1", "PMADDWL M0,M1"} {
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				const inputs = "MOVQ a+0(FP),M0\nMOVQ b+8(FP),M1\n"
+				const finish = "\nMOVQ M1,ret+16(FP)\nEMMS\nRET"
+				body := inputs + row + finish
+				_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+				if target.arch == "386" && strings.HasPrefix(row, "PMADDWL") {
+					// Go's Py1 integer MMX row is mode64-only; PSHUFW's row is not.
+					goAssemblerOracleOutput(t, target.arch, source, "", false)
+					return
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "emms") {
+							t.Fatal("complete initialized MMX source lost its physical region", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					})
+				}
+				for _, change := range []struct{ name, old, replacement string }{
+					{"missing-source", "MOVQ a+0(FP),M0\n", ""},
+					{"unclosed-state", "EMMS\n", ""},
+					{"interleaved-state", row, "MOVL $1,AX\n" + row},
+				} {
+					t.Run(change.name, func(t *testing.T) {
+						original := strings.Replace(source, change.old, change.replacement, 1)
+						if original == source {
+							t.Fatal("negative control did not change its intended source")
+						}
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, original)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, original, declaration, target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("incomplete MMX source borrowed input bytes or hardware state", api, err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_mmx_unpack_closed_leaf_test.go b/x86_mmx_unpack_closed_leaf_test.go
new file mode 100644
index 000000000..ce6d819a0
--- /dev/null
+++ b/x86_mmx_unpack_closed_leaf_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// Reuse the complete unmodified native CI program, not a zero-return or
+// initialized-shadow substitute. The six integer unpack rows each retain
+// their actual native memory and split-FP siblings.
+func TestX86MMXUnpackOriginalNativeSourceThreeAPIsThreeTargetObjects(t *testing.T) {
+	source, signatures, _, _, count := x86PackedUnpackMMXNativeProgram()
+	if count != 6 || len(signatures) != 12 {
+		t.Fatal("complete native MMX unpack family changed", count, len(signatures))
+	}
+	var names []string
+	for name := range signatures {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	var declarations strings.Builder
+	for _, name := range names {
+		parameters := "input *byte,second uint64"
+		if signatures[name].Args[0] != Ptr {
+			parameters = "a,b uint32"
+		}
+		fmt.Fprintf(&declarations, "func %s(%s) uint64\n", name, parameters)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Go's ymm Py1 named integer rows require mode64.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized native MMX source lacks its closed physical-state continuation", err)
+					}
+					if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "emms") {
+						t.Fatal("numerical interleaving alone cannot represent physical MMX/x87 effects")
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86MMXUnpackCannotBorrowInitializedShadowOrUnclosedState(t *testing.T) {
+	const declaration = "func view(input *byte,second uint64) uint64"
+	const body = "MOVQ input+0(FP),AX\nMOVQ second+8(FP),M0\nPUNPCKLBW (AX),M0\nMOVQ M0,ret+16(FP)\nEMMS\nRET\n"
+	for _, row := range []struct{ name, source string }{
+		{"missing-MMX-data", strings.Replace(body, "MOVQ second+8(FP),M0\n", "", 1)},
+		{"missing-address", strings.Replace(body, "MOVQ input+0(FP),AX\n", "", 1)},
+		{"numeric-address", strings.Replace(body, "MOVQ input+0(FP),AX", "MOVQ second+8(FP),AX", 1)},
+		{"unclosed-MMX-state", strings.Replace(body, "EMMS\n", "", 1)},
+	} {
+		source := "TEXT ·view(SB),4,$0-24\n" + row.source
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if row.name == "numeric-address" {
+					if err != nil || !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "punpcklbw") ||
+						!strings.Contains(ir, "~{memory}") || !strings.Contains(ir, "emms") {
+						t.Fatal("defined address lost its original MMX qword access or EMMS", err)
+					}
+					x86RequireNumericNativeSourceContext(t, source, declaration, "amd64")
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("an implementation MMX slot supplied source bytes or caller state", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86MMXVoidCannotHideInputsOrPhysicalState(t *testing.T) {
+	for _, declaration := range []string{"func view()", "func view(unused bool)"} {
+		args := 0
+		if strings.Contains(declaration, "bool") {
+			args = 1
+		}
+		for _, body := range []string{
+			"PUNPCKLBW M1,M0\nEMMS\nRET",
+			"MOVL $1,AX\nMOVL AX,M0\nRET",
+			"MOVQ M0,AX\nEMMS\nRET",
+		} {
+			source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\n", args, body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(declaration+"/"+body+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Void or unused bool hid an unknown MMX input or unclosed hardware state", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_movbe_effect_test.go b/x86_movbe_effect_test.go
new file mode 100644
index 000000000..1957c324e
--- /dev/null
+++ b/x86_movbe_effect_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVBEOrderedInputBytesAndPreservedFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVBEW", "MOVBEWW", "MOVBEL", "MOVBELL", "MOVBEQ", "MOVBEQQ"} {
+			width := int64(x86MOVBEWidths[Op(op)] / 8)
+			if arch == "386" && width == 8 {
+				continue // Both Q spellings have independent Go rejection controls.
+			}
+			for _, store := range []bool{false, true} {
+				line := op + " input+0(FP),BX"
+				if store {
+					line = op + " BX,result+8(FP)"
+				}
+				ins := x86YMMReadSource(t, line)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 2 || !effect.requiresResultProof ||
+					effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal("complete MOVBE directions lack their status-preserving effect", arch, op, known, err)
+				}
+				for index, operand := range effect.operands {
+					if operand.index != index || operand.width != width || operand.read != (index == 0) ||
+						operand.write != (index == 1) || !reflect.DeepEqual(operand.operand, ins.Args[index]) {
+						t.Fatal("MOVBE ordered width or read/write effect differs", operand)
+					}
+				}
+				for missing := -1; missing < int(width); missing++ {
+					t.Run(fmt.Sprintf("%s/%s/store=%t/missing=%d", arch, op, store, missing), func(t *testing.T) {
+						owned := make([]bool, 16)
+						state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll}
+						for index := range owned {
+							owned[index] = true
+							state.fp[index] = index < 8
+						}
+						state.gp[3] = 0xa0 // W preserves unknown old bytes; L zero-extends them.
+						if store {
+							state.gp[3] = 0xff
+						}
+						if missing >= 0 {
+							if store {
+								state.gp[3] &^= 1 << uint(missing)
+							} else {
+								state.fp[missing] = false
+							}
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, owned, 8, arch)
+						if accepted != (missing < 0) {
+							t.Fatal("MOVBE overwrite hid an unknown input byte", accepted)
+						}
+						if accepted {
+							if store {
+								for index := int64(8); index < 8+width; index++ {
+									before.fp[index] = true
+								}
+							} else if width == 2 {
+								before.gp[3] |= 3
+							} else {
+								before.gp[3] = 0xff
+							}
+						}
+						if !reflect.DeepEqual(before, state) {
+							t.Fatal("MOVBE changed FLAGS, unrelated storage or rejected state")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86MOVBERawIdentityCannotSupplyPointerOrNumericalBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVBEW", "MOVBEL", "MOVBEQ"} {
+			if arch == "386" && op == "MOVBEQ" {
+				continue
+			}
+			for _, operands := range []string{"(AX),BX", "BX,(AX)"} {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+
+					x86RawNumericalInstruction(t, arch, op+" "+operands)+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if !x86RawMOVBESource(ins, arch) {
+					t.Fatal("complete original raw MOVBE source not recognized", arch, op, operands)
+				}
+				for _, control := range []struct {
+					name   string
+					change func(*Instr)
+				}{
+					{"origin", func(i *Instr) { i.x86SourceRaw = nil }},
+					{"opcode", func(i *Instr) { i.Op = "MOVL" }},
+					{"operand", func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 1} }},
+					{"source-opcode", func(i *Instr) { i.x86SourceRaw.op = "MOVL" }},
+					{"source-operand", func(i *Instr) { i.x86SourceRaw.args[0].Reg = DX }},
+					{"vector", func(i *Instr) { i.x86VectorBytes = 16 }},
+					{"address", func(i *Instr) { i.x86AddressBits = 16 }},
+					{"override", func(i *Instr) { i.x86UnboundAddressOverride = true }},
+					{"segment", func(i *Instr) { i.x86SegmentPrefix = 0x64 }},
+					{"literal", func(i *Instr) { i.x86RIPLiteral = true }},
+				} {
+					t.Run(arch+"/"+op+"/"+operands+"/"+control.name, func(t *testing.T) {
+						changed := ins
+						changed.Args = append([]Operand(nil), ins.Args...)
+						origin := *ins.x86SourceRaw
+						origin.args = append([]Operand(nil), origin.args...)
+						changed.x86SourceRaw = &origin
+						control.change(&changed)
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.pointerGP[0], state.gp[3] = true, 0xff
+						if control.name == "origin" {
+							// With every physical marker absent this is ordinary
+							// named source, not a malformed encoded instruction.
+							// Its native read may consume complete numerical AX.
+							state.pointerGP[0], state.gp[0] = false, 0xff
+						}
+						before := state.clone()
+						accepted, _ := x86LoweredMOVBEResultStep(changed, &state, nil, 0, arch)
+						if control.name == "origin" && strings.HasPrefix(operands, "(") {
+							if !accepted || x86RawMOVBESource(changed, arch) || !reflect.DeepEqual(before, state) {
+								t.Fatal("named numerical MOVBE read changed state or acquired raw identity")
+							}
+							return
+						}
+						if accepted || x86RawMOVBESource(changed, arch) || !reflect.DeepEqual(before, state) {
+							t.Fatal("changed raw source borrowed a MOVBE continuation", accepted)
+						}
+					})
+				}
+				for _, pointer := range []bool{false, true} {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.pointerGP[0] = 0xff, pointer
+					// A store must consume BX numerically, not just an opaque pointer.
+					if strings.HasPrefix(operands, "BX") {
+						state.pointerGP[3] = true
+					}
+					before := state.clone()
+					accepted, known := x86LoweredMOVBEResultStep(ins, &state, nil, 0, arch)
+					want := !strings.HasPrefix(operands, "BX")
+					expected := before.clone()
+					if want {
+						expected.gp[3] = 0xff
+						if op == "MOVBEW" {
+							expected.gp[3] = 3
+						}
+					}
+					if accepted != want || !known || !reflect.DeepEqual(state, expected) {
+						t.Fatal("numerical address or opaque store input gained memory/data authority", pointer, operands, accepted)
+					}
+					if !pointer && want {
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[0] = available
+							unchanged := partial.clone()
+							if accepted, _ := x86LoweredMOVBEResultStep(ins, &partial, nil, 0, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("MOVBE read acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_movbe_grammar_test.go b/x86_movbe_grammar_test.go
new file mode 100644
index 000000000..78db4658b
--- /dev/null
+++ b/x86_movbe_grammar_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVBECompleteIndependentGoRowsAndAliases(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	table := regexp.MustCompile(`(?s)var ymovbe = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+	if len(table) != 2 || strings.Join(strings.Fields(table[1]), "") !=
+		"{Zlitm_r,3,argList{Ym,Yrl}},{Zlitr_m,3,argList{Yrl,Ym}}," {
+		t.Fatal("complete Go MOVBE directions, zcases or offsets changed")
+	}
+	rows := regexp.MustCompile(`\{A(MOVBE[WLQ]), ymovbe, (P\w+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(text, -1)
+	if len(rows) != 3 {
+		t.Fatal("complete canonical Go MOVBE directory changed", len(rows))
+	}
+	for _, row := range rows {
+		bits, prefix, opcodes := 16, "Pq", "0x38,0xf0,0,0x38,0xf1,0"
+		switch row[1] {
+		case "MOVBEL":
+			bits, prefix = 32, "Pm"
+		case "MOVBEQ":
+			bits, prefix, opcodes = 64, "Pw", "0x0f,0x38,0xf0,0,0x0f,0x38,0xf1,0"
+		}
+		if x86MOVBEWidths[Op(row[1])] != bits || row[2] != prefix ||
+			strings.Join(strings.Fields(row[3]), "") != opcodes {
+			t.Fatal("typed MOVBE width or complete physical encoding differs from Go", row)
+		}
+	}
+	data, err = os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	aliases := regexp.MustCompile(`instructions\["(MOVBE\w+)"\] = x86\.A(MOVBE[WLQ])`).FindAllStringSubmatch(string(data), -1)
+	if len(aliases) != 3 || len(x86MOVBEWidths) != len(rows)+len(aliases) {
+		t.Fatal("complete Go frontend MOVBE aliases missing from typed directory", len(aliases), len(x86MOVBEWidths))
+	}
+	for _, alias := range aliases {
+		if x86MOVBEWidths[Op(alias[1])] != x86MOVBEWidths[Op(alias[2])] {
+			t.Fatal("Go frontend alias has a different typed width", alias)
+		}
+	}
+}
+
+func TestX86MOVBERejectsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"MOVBEW", "MOVBEWW", "MOVBEL", "MOVBELL", "MOVBEQ", "MOVBEQQ"} {
+			for _, direction := range []string{"(AX),BX", "BX,(AX)"} {
+				ins := x86YMMReadSource(t, name+" "+direction)
+				for _, control := range []struct {
+					name   string
+					change func(*Instr)
+				}{
+					{"dispatch", func(i *Instr) { i.Op = "MOVL" }},
+					{"arity", func(i *Instr) { i.Args = i.Args[:1] }},
+					{"first", func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 1} }},
+					{"second", func(i *Instr) { i.Args[1] = Operand{Kind: OpReg, Reg: "X0"} }},
+					{"suffix", func(i *Instr) { i.Op += ".Z" }},
+				} {
+					t.Run(arch+"/"+name+"/"+direction+"/"+control.name, func(t *testing.T) {
+						bad := ins
+						bad.Args = append([]Operand(nil), ins.Args...)
+						control.change(&bad)
+						var ir strings.Builder
+						consumer := &amd64Ctx{b: &ir, goarch: arch}
+						known, terminated, err := consumer.lowerMOVBE(Op(name), bad)
+						if !known || terminated || err == nil || ir.Len() != 0 || consumer.tmp != 0 {
+							t.Fatal("invalid MOVBE emitted before full grammar rejection", known, err, ir.String())
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_movbe_input_objects_test.go b/x86_movbe_input_objects_test.go
new file mode 100644
index 000000000..3b118e408
--- /dev/null
+++ b/x86_movbe_input_objects_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVBEOriginalInvalidImmediateIsGoRejected(t *testing.T) {
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+x86MOVBEOriginalRuntimeSource, "", false)
+}
+
+func TestX86MOVBERepairedOriginalRuntimeSourceObjects(t *testing.T) {
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86RawNumericalFamilyObjects(t, x86MOVBERepairedRuntimeSource(t),
+				"func movesemantics(out *[72]byte)", "amd64", triple)
+		})
+	}
+}
+
+func TestX86MOVBEInitializedWidthsDirectionsAndTargets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			widths := []string{"W", "WW", "L", "LL", "Q", "QQ"}
+			if word == 4 {
+				move, widths = "MOVL", widths[:4]
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, width := range widths {
+				for _, store := range []bool{false, true} {
+					for _, raw := range []bool{false, true} {
+						name, line, result := fmt.Sprint("Value", count), "MOVBE"+width+" (SI),CX", "CX"
+						if store {
+							line, result = "MOVBE"+width+" AX,(SI)", "AX"
+						}
+						if raw {
+							line = x86RawNumericalInstruction(t, target.arch, line)
+						}
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n"+
+							"%s input+0(FP),SI\n%s value+%d(FP),AX\n%s $-1,CX\n"+
+							"%s\n%s %s,ret+%d(FP)\nRET\n",
+							name, word*3, move, move, word, move, line, move, result, word*2)
+						fmt.Fprintf(&declarations, "func %s(input *uint64,value uintptr) uintptr\n", name)
+						count++
+					}
+				}
+			}
+			if count != len(widths)*4 {
+				t.Fatal("complete MOVBE alias/direction/source inventory changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
diff --git a/x86_movbe_native_fault_test.go b/x86_movbe_native_fault_test.go
new file mode 100644
index 000000000..65d55adca
--- /dev/null
+++ b/x86_movbe_native_fault_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVBEDeadAccessPortableFaultBoundaries(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, op := range []string{"MOVBEW", "MOVBEL", "MOVBEQ"} {
+		width := x86MOVBEWidths[Op(op)] / 8
+		for _, store := range []bool{false, true} {
+			for _, raw := range []bool{false, true} {
+				name, line := fmt.Sprint("Dead", count), op+" (AX),BX"
+				if store {
+					line = op + " BX,(AX)"
+				}
+				if raw {
+					line = x86RawNumericalInstruction(t, "amd64", line)
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ p+0(FP),AX\nMOVL $7,BX\n%s\nMOVL $0,BX\nRET\n", name, line)
+				fmt.Fprintf(&declarations, "func %s(p *byte)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*);\nstatic int run%s(const uint8_t *p) { %s(p); return 0; }\n", name, name, name)
+				fmt.Fprintf(&rows, "{run%s,%d,%d},\n", name, width, width-1)
+				count++
+			}
+		}
+	}
+	if count != 12 {
+		t.Fatal("complete named/raw MOVBE read/write fault directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86MemoryFaultDriver(prototypes.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("original dead MOVBE access source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					executable := execution.compileLLVM(t, "movbe-dead-access", text, driver, level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, count)
+				}
+			}
+		})
+	}
+	t.Log("actual-host translated read/write NULL and page extents, not original native MOVBE execution")
+}
diff --git a/x86_movbe_native_input_test.go b/x86_movbe_native_input_test.go
new file mode 100644
index 000000000..ac9e87d2f
--- /dev/null
+++ b/x86_movbe_native_input_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MOVBEDeadNativeAccessKeepsExactWidthAndInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if word == 4 {
+			move = "MOVL"
+		}
+		for _, op := range []string{"MOVBEW", "MOVBEWW", "MOVBEL", "MOVBELL", "MOVBEQ", "MOVBEQQ"} {
+			bits := x86MOVBEWidths[Op(op)]
+			if word == 4 && bits == 64 {
+				continue
+			}
+			for _, store := range []bool{false, true} {
+				for _, raw := range []bool{false, true} {
+					line, effect := op+" 3(AX)(DX*2),BX", "load"
+					if store {
+						line, effect = op+" BX,3(AX)(DX*2)", "store"
+					}
+					if raw {
+						line = x86RawNumericalInstruction(t, target.arch, line)
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n"+
+						"MOVL $1,DX\nMOVL $7,BX\n%s\nMOVL $0,BX\nRET\n", word, move, line)
+					variants := []struct{ name, source string }{
+						{"initialized", source},
+						{"unknown-address", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+						{"numerical-address", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+						{"partial-address", strings.Replace(source, move+" p+0(FP),AX", "MOVB $1,AL", 1)},
+						{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+					}
+					if store {
+						variants = append(variants, struct{ name, source string }{
+							"unknown-value", strings.Replace(source, "MOVL $7,BX\n", "", 1),
+						}, struct{ name, source string }{
+							"pointer-not-value", strings.Replace(source, "MOVL $7,BX", move+" p+0(FP),BX", 1),
+						})
+					}
+					for _, variant := range variants {
+						t.Run(fmt.Sprintf("%s/%s/%s/raw=%t/%s", target.triple, op, effect, raw, variant.name), func(t *testing.T) {
+							pairedNumericalRead := variant.name == "numerical-address" && !store
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, variant.source, "func Value(p *[16]byte)", target.arch, target.triple, api)
+								if variant.name != "initialized" && !pairedNumericalRead {
+									if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+										t.Fatal("dead MOVBE borrowed an unknown address or value", api, err)
+									}
+									continue
+								}
+								if err != nil {
+									t.Fatal("initialized dead MOVBE native access rejected", api, err)
+								}
+								if pairedNumericalRead {
+									x86RequireNumericNativeSourceContext(t, variant.source, "func Value(p *[16]byte)", target.arch)
+									x86NumericNativeAddressObject(t, ir, target.triple)
+								}
+								for pipeline, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+									if strings.Count(text, fmt.Sprintf("%s volatile i%d ", effect, bits)) != 1 &&
+										strings.Count(text, fmt.Sprintf("%s volatile i%d,", effect, bits)) != 1 {
+										t.Fatal("dead MOVBE lost its exact volatile access", api, effect, bits)
+									}
+									// LLVM may infer alignment from the literal address in
+									// the optimized control. The emitter still starts at 1.
+									if (pipeline == 0 || variant.name != "numerical-address") && !strings.Contains(text, ", align 1") || strings.Contains(text, "dereferenceable") {
+										t.Fatal("MOVBE invented memory alignment or backing", api)
+									}
+								}
+								if store {
+									twice := strings.Replace(variant.source, line+"\n", line+"\n"+line+"\n", 1)
+									twiceIR, err := x86ScalarFPBitViewAPI(t, twice, "func Value(p *[16]byte)", target.arch, target.triple, api)
+									if err != nil || strings.Count(x86DwordProductIROptimize(t, twiceIR), fmt.Sprintf("store volatile i%d ", bits)) != 2 {
+										t.Fatal("overwritten MOVBE native store lost its observable access", api, err)
+									}
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_movbe_original_fixture_test.go b/x86_movbe_original_fixture_test.go
new file mode 100644
index 000000000..c2663e31e
--- /dev/null
+++ b/x86_movbe_original_fixture_test.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func x86MOVBERepairedRuntimeSource(t *testing.T) string {
+	t.Helper()
+	source := strings.Replace(x86MOVBEOriginalRuntimeSource, "MOVQ $0xefcdab8967452301, 32(DI)",
+		"MOVQ $0xefcdab8967452301, R9\n\tMOVQ R9, 32(DI)", 1)
+	if source == x86MOVBEOriginalRuntimeSource {
+		t.Fatal("original MOVBE fixture lost its identified invalid imm64 store")
+	}
+	return source
+}
+
+const x86MOVBEOriginalRuntimeSource = `TEXT movesemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVL $0x7fffffff, R8
+	ADDL $1, R8
+	STC
+
+	MOVW $0x3412, 0(DI)
+	MOVQ $0x1122334455667788, AX
+	MOVBEW 0(DI), AX
+	MOVQ AX, 8(DI)
+
+	MOVL $0x78563412, 16(DI)
+	MOVBEL 16(DI), BX
+	MOVQ BX, 24(DI)
+
+	MOVQ $0xefcdab8967452301, 32(DI)
+	MOVBEQ 32(DI), CX
+	MOVQ CX, 40(DI)
+
+	MOVQ $0x1122334455667788, AX
+	MOVBEW AX, 48(DI)
+	MOVBEL AX, 50(DI)
+	MOVBEQ AX, 54(DI)
+
+	SETCS 62(DI)
+	SETOS 63(DI)
+	SETEQ 64(DI)
+	SETMI 65(DI)
+	RET
+`
diff --git a/x86_movbe_portable_runtime_test.go b/x86_movbe_portable_runtime_test.go
new file mode 100644
index 000000000..52726b46f
--- /dev/null
+++ b/x86_movbe_portable_runtime_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+const x86MOVBEOriginalRuntimeDriver = `
+#include <stdint.h>
+#include <string.h>
+extern void movesemantics(uint8_t *);
+static uint64_t load64(const uint8_t *p) {
+  uint64_t value;
+  memcpy(&value, p, sizeof(value));
+  return value;
+}
+int main(void) {
+  uint8_t out[72] = {0};
+  movesemantics(out);
+  if (load64(out+8) != UINT64_C(0x1122334455661234)) return 10;
+  if (load64(out+24) != UINT64_C(0x12345678)) return 11;
+  if (load64(out+40) != UINT64_C(0x0123456789abcdef)) return 12;
+  const uint8_t stores[14] = {0x77,0x88, 0x55,0x66,0x77,0x88, 0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88};
+  if (memcmp(out+48, stores, sizeof(stores)) != 0) return 13;
+  if (out[62] != 1 || out[63] != 1 || out[64] != 0 || out[65] != 1) return 14;
+  return 0;
+}
+`
+
+func TestX86MOVBERepairedOriginalPortableValuesAndFlags(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	driver := strings.Replace(x86MOVBEOriginalRuntimeDriver, "uint8_t out[72] = {0};",
+		"uint8_t storage[74];\n  memset(storage,0xc3,sizeof(storage));\n  uint8_t *out=storage+1;", 1)
+	driver = strings.Replace(driver, "  return 0;",
+		"  if(storage[0]!=0xc3 || storage[73]!=0xc3) return 1;\n  for(int byte=66;byte<72;byte++) if(out[byte]!=0xc3) return 1;\n  return 0;", 1)
+	if driver == x86MOVBEOriginalRuntimeDriver || !strings.Contains(driver, "storage[73]") {
+		t.Fatal("independent unaligned MOVBE driver lost its canaries")
+	}
+	for _, raw := range []bool{false, true} {
+		source := x86MOVBERepairedRuntimeSource(t)
+		if raw {
+			lines := strings.Split(source, "\n")
+			for index, line := range lines {
+				if strings.HasPrefix(strings.TrimSpace(line), "MOVBE") {
+					lines[index] = x86RawNumericalInstruction(t, "amd64", strings.TrimSpace(line))
+				}
+			}
+			source = strings.Join(lines, "\n")
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("raw=%t/%s", raw, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func movesemantics(out *[72]byte)", "amd64", triple, api)
+				if err != nil {
+					t.Fatal("Go-valid original MOVBE fixture rejected", err)
+				}
+				for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						compileAndRunRuntimeTestForTarget(t, llc, clang,
+							fmt.Sprintf("movbe-%t-%s-ir%d-%s", raw, api, index, level[1:]), triple, text, driver, nil)
+					}
+				}
+			})
+		}
+	}
+	t.Log("actual-host portable byte-order values, partial-register preservation, FLAGS and unaligned canaries; not original MOVBE opcode execution")
+}
diff --git a/x86_move_half_command_policy_test.go b/x86_move_half_command_policy_test.go
new file mode 100644
index 000000000..732b41c9c
--- /dev/null
+++ b/x86_move_half_command_policy_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// These two consumers contain no command constructor. Their precise roots
+// delegate to existing bounded owners, whose direct exec checks stay intact.
+func TestX86MoveHalfIndirectRuntimeCommandsRetainOwnedHelpers(t *testing.T) {
+	for _, spec := range []struct {
+		file, root string
+		calls      map[string]int
+	}{
+		{"x86_move_half_runtime_test.go", "TestX86MoveHalfCompleteBytesFlagsAndUpperAliases", map[string]int{
+			"x86MoveHalfValueProgram": 1, "x86LEAActualTargetGoObject": 1,
+			"x86ScalarFPBitViewAPI": 1, "x86ConflictFunnelPortableRuntime": 1,
+		}},
+		{"x86_move_half_native_linux_amd64_test.go", "TestCrossLinuxRuntimeMatrixX86MoveHalfOriginalGoFlagsDFAliases", map[string]int{
+			"x87IA32RequireNativeHost": 2, "x86FloatCompareExecutionTools": 1,
+			"execution.compileC": 1, "execution.run": 1, "execution.compileAndRunLLVM": 1,
+			"x86MoveHalfValueProgram": 1, "x86LEAActualTargetGoObject": 1,
+			"x86ScalarFPBitViewAPI": 1, "x86DwordProductIROptimize": 1, "x86RunOriginalGoNativeSource": 1,
+		}},
+	} {
+		t.Run(spec.file, func(t *testing.T) {
+			file, err := parser.ParseFile(token.NewFileSet(), spec.file, nil, 0)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86CheckHalfIndirectCommandOwner(file, spec.root, spec.calls); err != nil {
+				t.Fatal(err)
+			}
+			for call := range spec.calls {
+				missing := make(map[string]int)
+				for name, count := range spec.calls {
+					missing[name] = count
+				}
+				missing[call]++
+				if err := x86CheckHalfIndirectCommandOwner(file, spec.root, missing); err == nil {
+					t.Fatal("policy accepted a missing or duplicate indirect owner", call)
+				}
+			}
+		})
+	}
+	// Check the extra delegation edge, not only its caller's printed name.
+	// runtime_exec_test.go remains in the unchanged direct-command owner list.
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_conflict_funnel_runtime_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86CheckHalfIndirectCommandOwner(file, "x86ConflictFunnelPortableRuntime",
+		map[string]int{"compileAndRunRuntimeTestWithCompiler": 1, "x86DwordProductIROptimize": 1}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func x86CheckHalfIndirectCommandOwner(file *ast.File, root string, required map[string]int) error {
+	for _, imported := range file.Imports {
+		name, err := strconv.Unquote(imported.Path.Value)
+		if err != nil || name == "os/exec" || name == "syscall" {
+			return fmt.Errorf("indirect owner introduced a direct process package: %s", imported.Path.Value)
+		}
+	}
+	var owner *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == root {
+			if owner != nil || function.Recv != nil || function.Body == nil {
+				return fmt.Errorf("duplicate or unbound indirect root %s", root)
+			}
+			owner = function
+		}
+	}
+	if owner == nil {
+		return fmt.Errorf("missing indirect root %s", root)
+	}
+	var invalid error
+	ast.Inspect(file, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		method, ok := call.Fun.(*ast.SelectorExpr)
+		if !ok {
+			return true
+		}
+		name := method.Sel.Name
+		if name == "Command" || name == "CommandContext" || name == "StartProcess" || name == "ForkExec" ||
+			name == "CombinedOutput" || name == "Output" || name == "Start" || name == "Wait" || name == "Run" {
+			if receiver, ok := method.X.(*ast.Ident); !ok || receiver.Name != "t" || name != "Run" {
+				invalid = fmt.Errorf("indirect owner bypassed its bounded command chain: %s", name)
+			}
+		}
+		return true
+	})
+	if invalid != nil {
+		return invalid
+	}
+	observed := make(map[string]int)
+	ast.Inspect(owner.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		name := ""
+		if function, ok := call.Fun.(*ast.Ident); ok {
+			name = function.Name
+		} else if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+			if receiver, ok := method.X.(*ast.Ident); ok {
+				name = receiver.Name + "." + method.Sel.Name
+			}
+		}
+		if strings.HasPrefix(name, "execution.") && required[name] == 0 {
+			invalid = fmt.Errorf("unregistered execution route in %s: %s", root, name)
+		}
+		if required[name] != 0 {
+			observed[name]++
+		}
+		return true
+	})
+	if invalid != nil {
+		return invalid
+	}
+	if !reflect.DeepEqual(observed, required) {
+		return fmt.Errorf("indirect root %s lost exact bounded helper edges: got %v want %v", root, observed, required)
+	}
+	return nil
+}
+
+func TestX86MoveHalfIndirectCommandPolicyRejectsRawProcesses(t *testing.T) {
+	for _, body := range []string{
+		`import "os/exec"; func Owner(){Bounded();exec.Command("tool")}`,
+		`func Owner(){Bounded();process.Run()}`,
+		`func Owner(){Bounded();os.StartProcess("tool",nil,nil)}`,
+		`func Owner(){Bounded();execution.unowned()}`,
+		`func Owner(){Bounded();Bounded()}`,
+		`func Owner(){}`,
+	} {
+		file, err := parser.ParseFile(token.NewFileSet(), "mutation.go", "package oracle\n"+body, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86CheckHalfIndirectCommandOwner(file, "Owner", map[string]int{"Bounded": 1}); err == nil {
+			t.Fatal("indirect policy accepted an unowned or incomplete command chain", body)
+		}
+	}
+}
diff --git a/x86_move_half_effect_test.go b/x86_move_half_effect_test.go
new file mode 100644
index 000000000..6a45a1728
--- /dev/null
+++ b/x86_move_half_effect_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent source directory: Go shares yxmov with other operations, but
+// the ISA's half selectors and numerical permissions are not a whole-X copy.
+var x86MoveHalfOracle = []struct {
+	op           string
+	high, vector bool
+}{
+	{"MOVLPS", false, false}, {"MOVHPS", true, false},
+	{"MOVLPD", false, false}, {"MOVHPD", true, false},
+	{"VMOVLPS", false, true}, {"VMOVHPS", true, true},
+	{"VMOVLPD", false, true}, {"VMOVHPD", true, true},
+}
+
+func TestX86MoveHalfCompleteIndependentGoRowsAndTypedEffects(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxmov = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n\t{Zr_m_xm, 1, argList{Yxr, Yxm}},\n}") {
+		t.Fatal("complete original Go legacy half-move rows changed")
+	}
+	for _, row := range x86MoveHalfOracle[:4] {
+		prefix, code := "Pm", "0x12, 0x13"
+		if strings.HasSuffix(row.op, "PD") {
+			prefix = "Pe"
+		}
+		if row.high {
+			code = "0x16, 0x17"
+		}
+		if want := fmt.Sprintf("{A%s, yxmov, %s, opBytes{%s}}", row.op, prefix, code); !strings.Contains(string(legacy), want) {
+			t.Fatal("independent legacy half-move encoding changed", want)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VMOVLPS" && rule.Opcode != "VMOVHPS" && rule.Opcode != "VMOVLPD" && rule.Opcode != "VMOVHPD" {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		classes := []string{"Yxr,Ym", "Ym,Yxr,Yxr", "YxrEvex,Ym", "Ym,YxrEvex,YxrEvex"}
+		zcase := []string{"Zvex_r_v_rm", "Zvex_rm_v_r", "Zevex_r_v_rm", "Zevex_rm_v_r"}
+		offsets, advances := []int{0, 2, 4, 7}, []int{2, 2, 3, 3}
+		prefix, w, load, store := "", 0, "0x12", "0x13"
+		if strings.HasSuffix(rule.Opcode, "PD") {
+			prefix, w = " | vex66", 1
+		}
+		if strings.Contains(rule.Opcode, "H") {
+			load, store = "0x16", "0x17"
+		}
+		attributes := []string{
+			"avxEscape | vex128" + prefix + " | vex0F | vexW0", store,
+			"avxEscape | vex128" + prefix + " | vex0F | vexW0", load,
+			fmt.Sprintf("avxEscape | evex128%s | evex0F | evexW%d", strings.ReplaceAll(prefix, "vex66", "evex66"), w), "evexN8", store,
+			fmt.Sprintf("avxEscape | evex128%s | evex0F | evexW%d", strings.ReplaceAll(prefix, "vex66", "evex66"), w), "evexN8", load,
+		}
+		if index >= 4 || rule.RowIndex != index || rule.Ytab != "_yvmovhpd" || rule.Prefix != "Pavx" ||
+			rule.ZCase != zcase[index] || rule.ZOffset != advances[index] || rule.EncodingOffset != offsets[index] ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, attributes) {
+			t.Fatal("independent complete half-move AVX row or N8/W attributes changed", rule)
+		}
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VMOVLPS": 4, "VMOVHPS": 4, "VMOVLPD": 4, "VMOVHPD": 4}) {
+		t.Fatal("complete sixteen AVX half-move rows changed", counts)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86MoveHalfOracle {
+			for _, store := range []bool{false, true} {
+				t.Run(fmt.Sprint(arch, "/", row.op, "/store=", store), func(t *testing.T) {
+					args := "value+0(FP),X2"
+					if row.vector {
+						args = "value+0(FP),X1,X2"
+					}
+					if store {
+						args = "X1,value+0(FP)"
+					}
+					ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+						effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || len(effect.operands) != len(ins.Args) {
+						t.Fatal("complete half-move source/merge/store effect missing", effect, known, err)
+					}
+					for index, operand := range effect.operands {
+						width, read, write := int64(16), index < len(ins.Args)-1, index == len(ins.Args)-1
+						if ins.Args[index].Kind == OpFP {
+							width = 8
+						}
+						if !row.vector && !store && write {
+							read = true // The untouched half remains an independent old input.
+						}
+						if operand.index != index || !reflect.DeepEqual(operand.operand, ins.Args[index]) || operand.width != width || operand.read != read || operand.write != write {
+							t.Fatal("typed envelope does not retain exact memory/selected-register roles", index, operand)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MoveHalfSelectedBytesUpperAliasesAndState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86MoveHalfOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				args, base := "value+0(FP),X2", 2
+				if row.vector {
+					args, base = "value+0(FP),X1,X2", 1
+				}
+				ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+				inputOwned := []bool{true, true, true, true, true, true, true, true}
+				for missing := -1; missing < 16; missing++ {
+					initial := x86ResultState{fp: make([]bool, 8), flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					for offset := int64(0); offset < 8; offset++ {
+						initial.fp[offset] = true
+					}
+					initial.xmm[base] = 0xffff
+					if missing >= 0 {
+						initial.xmm[base] &^= 1 << uint(missing)
+					}
+					initial.vectorUpper[2] = 0x0055aa55ffff0000
+					before, want := initial.clone(), initial.clone()
+					lane := uint(0)
+					if row.high {
+						lane = 8
+					}
+					mask := uint16(0xff) << lane
+					want.xmm[2] = initial.xmm[base]&^mask | mask
+					if row.vector {
+						want.vectorUpper[2] = ^uint64(0xffff)
+					}
+					if !x86ResultTransfer(ins, &initial, inputOwned, 0, arch) || !reflect.DeepEqual(initial, want) {
+						t.Fatal("selected-byte propagation invented unknown merge bytes, lost upper alias, or changed unrelated state", missing, before, initial, want)
+					}
+				}
+				for missing := -1; missing < 16; missing++ {
+					ins := x86ScalarLaneInstruction(t, row.op+" X1,ret0+8(FP)")
+					state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll}
+					state.xmm[1] = 0xffff
+					if missing >= 0 {
+						state.xmm[1] &^= 1 << uint(missing)
+					}
+					before := state.clone()
+					owned := make([]bool, 16)
+					for offset := 8; offset < 16; offset++ {
+						owned[offset] = true
+					}
+					selectedMissing := missing >= 0 && (missing >= 8) == row.high
+					accepted := x86ResultTransfer(ins, &state, owned, 8, arch)
+					if accepted == selectedMissing || selectedMissing && !reflect.DeepEqual(state, before) {
+						t.Fatal("half store borrowed unselected bytes or lost a selected input", missing, accepted)
+					}
+					if accepted {
+						for offset := int64(8); offset < 16; offset++ {
+							before.fp[offset] = true
+						}
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("half store changed unrelated vector/FLAGS/storage state")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MoveHalfInitializedPublicAPIsAndMissingNativeInputs(t *testing.T) {
+	for _, row := range x86MoveHalfOracle {
+		t.Run(row.op, func(t *testing.T) {
+			args := "(DX),X2"
+			if row.vector {
+				args = "(DX),X1,X2"
+			}
+			body := "MOVQ out+0(FP),AX\nMOVQ base+8(FP),CX\nMOVQ half+16(FP),DX\nMOVUPS (CX),X1\nMOVUPS X1,X2\nSTC\n" +
+				row.op + " " + args + "\nMOVUPS X2,(AX)\n" + row.op + " X2,16(AX)\nSETCS 24(AX)\nRET\n"
+			source := "TEXT ·Value(SB),4,$0-24\n" + body
+			declaration := "func Value(out *[32]byte,base *[16]byte,half *uint64)\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Fatal("complete initialized valid half-move source rejected", err)
+					}
+					missing := strings.Replace(source, "MOVQ half+16(FP),DX\n", "", 1)
+					if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Void half move lost its actual native read input", err)
+					}
+					missing = strings.Replace(source, "MOVQ out+0(FP),AX\n", "", 1)
+					if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Void half move lost its actual native write input", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_move_half_fault_unix_test.go b/x86_move_half_fault_unix_test.go
new file mode 100644
index 000000000..b7e11bcf1
--- /dev/null
+++ b/x86_move_half_fault_unix_test.go
@@ -0,0 +1,86 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveHalfDeadNativeReadsAndWritesKeepExactEightByteFaults(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable guard-page oracle needs its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, metadata strings.Builder
+	for index, row := range x86MoveHalfOracle {
+		for _, write := range []bool{false, true} {
+			name, args, store := fmt.Sprintf("DeadHalf%d_%t", index, write), "(AX),X2", 0
+			if row.vector {
+				args = "(AX),X1,X2"
+			}
+			if write {
+				args, store = "X1,(AX)", 1
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ base+8(FP),BX\n"+
+				"VMOVDQU64 (BX),Z1\nVMOVDQU64 Z1,Z2\n%s %s\nRET\n", name, row.op, args)
+			fmt.Fprintf(&declarations, "func %s(p *uint64,base *[64]byte)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(uint64_t *,const uint8_t *);\n", name)
+			fmt.Fprintf(&metadata, "{%s,%d},\n", name, store)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "text")
+	if err != nil {
+		t.Fatal("complete original dead native half-move source rejected", err)
+	}
+	for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+		if strings.Count(body, "load volatile i64, ptr") != 8 || strings.Count(body, "store volatile i64 ") != 8 {
+			t.Fatal("dead native half-move access was elided or changed width")
+		}
+	}
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "move_half_dead_native", triple, ir,
+		fmt.Sprintf(x86MoveHalfDeadMemoryC, prototypes.String(), metadata.String()))
+}
+
+const x86MoveHalfDeadMemoryC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+%s
+struct row {void (*run)(uint64_t *,const uint8_t *); int write;};
+static const struct row rows[]={%s};
+static int observe(struct row row,uint8_t *p,const uint8_t *base) {
+  pid_t child=fork(); if(child<0) return -1;
+  if(!child) {
+    struct rlimit limit={0,0}; if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+    row.run((uint64_t *)p,base); _exit(0);
+  }
+  int status=0; if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+  return WIFSIGNALED(status)&&(WTERMSIG(status)==SIGSEGV||WTERMSIG(status)==SIGBUS)?1:-4;
+}
+int main(void) {
+  long page=sysconf(_SC_PAGESIZE); if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+  uint8_t *ro=mmap(0,(size_t)page,PROT_READ,MAP_PRIVATE|MAP_ANON,-1,0);
+  if(p==MAP_FAILED||ro==MAP_FAILED||mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  uint8_t base[64]; for(unsigned b=0;b<64;b++) base[b]=(uint8_t)(b*19+7);
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+    if(observe(rows[r],0,base)!=1||observe(rows[r],p+page-8,base)!=0||
+       observe(rows[r],p+page-7,base)!=1||observe(rows[r],p+1,base)!=0||
+       observe(rows[r],ro,base)!=rows[r].write) {fprintf(stderr,"half native row=%%u\n",r);return 2;}
+  }
+  return munmap(p,(size_t)page*2)||munmap(ro,(size_t)page)?3:0;
+}
+`
diff --git a/x86_move_half_native_linux_amd64_test.go b/x86_move_half_native_linux_amd64_test.go
new file mode 100644
index 000000000..c9da1fbe1
--- /dev/null
+++ b/x86_move_half_native_linux_amd64_test.go
@@ -0,0 +1,57 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86MoveHalfOriginalGoFlagsDFAliases(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	directory := t.TempDir()
+	preflight, executable := filepath.Join(directory, "native-half-cpu.c"), filepath.Join(directory, "native-half-cpu")
+	const cpu = `#include <stdint.h>
+#include <stdio.h>
+int main(void) {
+  __builtin_cpu_init();
+  int enabled=!!__builtin_cpu_supports("avx512f");
+  printf("half native CPUID/XCR0 AVX512F=%d\n",enabled);
+  if(!enabled) return 1;
+  uint64_t data[8]={0};
+  __asm__ volatile(".byte 0x62,0xf1,0xfe,0x48,0x6f,0x00" :: "a"(data) : "zmm0","memory");
+  return 0;
+}
+`
+	if err := os.WriteFile(preflight, []byte(cpu), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, preflight, executable)
+	if output := execution.run(t, executable); string(output) != "half native CPUID/XCR0 AVX512F=1\n" {
+		t.Fatal("missing actual AVX512F/XCR0 and native Go transport opcode preflight", string(output))
+	}
+	t.Log("half native CPUID/XCR0 AVX512F=1; original EVEX transport opcode executed")
+	source, declarations, prototypes, metadata, goRows := x86MoveHalfValueProgram()
+	x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal("complete original initialized native x86 half-move source rejected", err)
+	}
+	driver := fmt.Sprintf(x86MoveHalfWholeBytesC, prototypes, metadata)
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			if output := execution.compileAndRunLLVM(t, "native-half-complete", pipeline.ir, driver, pipeline.level); len(output) != 0 {
+				t.Fatal("incomplete full-byte/FLAGS/DF native oracle", string(output))
+			}
+			t.Log("half native full64/FLAGS/DF=1/canary outcomes=512; complete original STD/CLD source and all eight named half moves")
+		})
+	}
+	x86RunOriginalGoNativeSource(t, execution, "amd64", "package oracle\n"+declarations, source, fmt.Sprintf(x86MoveHalfOriginalGo, goRows))
+	t.Log("half actual original Go full64/FLAGS/DF=1/canary outcomes=512")
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_move_half_runtime_test.go b/x86_move_half_runtime_test.go
new file mode 100644
index 000000000..db1f06ce3
--- /dev/null
+++ b/x86_move_half_runtime_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveHalfCompleteBytesFlagsAndUpperAliases(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable whole-byte runtime needs its native 64-bit host counterpart")
+	}
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	source, declarations, prototypes, metadata, _ := x86MoveHalfValueProgram()
+	// Always retain the complete original x86 DF source and its Go object.
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	driver := fmt.Sprintf(x86MoveHalfWholeBytesC, prototypes, metadata)
+	if runtime.GOARCH != "amd64" {
+		// STD/CLD are hardware x86 controls, not portable vector operations.
+		// This independent companion projects DF out of its value observation;
+		// the required Linux native owner executes the original with DF=1.
+		source = strings.ReplaceAll(strings.ReplaceAll(source, "STD\n", ""), "CLD\n", "")
+		source = strings.ReplaceAll(source, "ANDL $0xcd5,DX", "ANDL $0x8d5,DX")
+		driver = strings.Replace(driver, "flags=UINT64_C(0xc91)", "flags=UINT64_C(0x891)", 1)
+		t.Log("independent portable half-move companion: DF observation projected to zero; complete original x86 STD/CLD source retained separately, no native-x86 DF execution claim")
+	}
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal("complete initialized half-move value source rejected", err)
+	}
+	x86ConflictFunnelPortableRuntime(t, llc, clang, "move_half_whole_bytes", triple, ir, driver)
+}
+
+func x86MoveHalfValueProgram() (string, string, string, string, string) {
+	var source, declarations, prototypes, metadata, goRows strings.Builder
+	for index, row := range x86MoveHalfOracle {
+		for _, alias := range []bool{false, true} {
+			name, destination := fmt.Sprintf("Half%d_%t", index, alias), 2
+			if alias {
+				destination = 1
+			}
+			args := fmt.Sprintf("(SI),X%d", destination)
+			if row.vector {
+				args = fmt.Sprintf("(SI),X1,X%d", destination)
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),AX\nMOVQ first+8(FP),BX\n"+
+				"MOVQ second+16(FP),CX\nMOVQ half+24(FP),SI\nVMOVDQU64 (BX),Z1\nVMOVDQU64 (CX),Z2\n"+
+				"MOVL $127,DX\nADDB $1,DL\nSTC\nSTD\n%s %s\nSETCS 64(AX)\nPUSHFQ\nPOPQ DX\nANDL $0xcd5,DX\nCLD\n"+
+				"VMOVDQU64 Z%d,(AX)\nMOVQ DX,72(AX)\n%s X%d,88(AX)\nRET\n", name, row.op, args, destination, row.op, destination)
+			fmt.Fprintf(&declarations, "func %s(out *[112]byte,first,second *[64]byte,half *uint64)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint64_t *);\n", name)
+			flag := func(value bool) int {
+				if value {
+					return 1
+				}
+				return 0
+			}
+			fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, flag(row.vector), flag(row.high), flag(alias))
+			fmt.Fprintf(&goRows, "{%s,%t,%t,%t},\n", name, row.vector, row.high, alias)
+		}
+	}
+	return source.String(), declarations.String(), prototypes.String(), metadata.String(), goRows.String()
+}
+
+const x86MoveHalfOriginalGo = `package oracle
+import("bytes";"encoding/binary";"testing")
+func TestOriginal(t *testing.T) {
+  rows:=[]struct{run func(*[112]byte,*[64]byte,*[64]byte,*uint64);vector,high,alias bool}{%s}
+  patterns:=[]uint64{0,^uint64(0),0x8000000000000000,0x7ff0000000000001,0xfff123456789abcd,0x7ff8123456789abc,0xaaaaaaaa55555555,0x0123456789abcdef}
+  outcomes:=0
+  for r,row:=range rows {for sample:=0;sample<32;sample++ {
+    var first,second [64]byte
+    var out,want [112]byte
+    for b:=range first {first[b]=byte(sample*13+b*17);second[b]=byte(sample*23+b*31+7)}
+    for b:=range out {out[b]=0xa5;want[b]=0xa5}
+    half:=patterns[sample%%8];if sample>=8 {half^=uint64(sample)<<21}
+    base:=second;if row.vector||row.alias {base=first};copy(want[:64],base[:])
+    lane:=0;if row.high {lane=8};binary.LittleEndian.PutUint64(want[lane:],half)
+    if row.vector {for b:=16;b<64;b++ {want[b]=0}}
+    want[64]=1;binary.LittleEndian.PutUint64(want[72:],0xc91);binary.LittleEndian.PutUint64(want[88:],half)
+    row.run(&out,&first,&second,&half)
+    if !bytes.Equal(out[:],want[:]) {t.Fatalf("original half row=%%d sample=%%d got=%%x want=%%x",r,sample,out,want)}
+    outcomes++
+  }}
+  if outcomes!=512 {t.Fatal("incomplete original whole64/FLAGS/DF/canary observations",outcomes)}
+}
+`
+
+const x86MoveHalfWholeBytesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+%s
+struct row {void (*run)(uint8_t *,const uint8_t *,const uint8_t *,const uint64_t *); int vector,high,alias;};
+static const struct row rows[]={%s};
+int main(void) {
+  const uint64_t patterns[]={0,UINT64_MAX,UINT64_C(0x8000000000000000),UINT64_C(0x7ff0000000000001),
+    UINT64_C(0xfff123456789abcd),UINT64_C(0x7ff8123456789abc),UINT64_C(0xaaaaaaaa55555555),UINT64_C(0x0123456789abcdef)};
+  unsigned outcomes=0;
+  for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) for(unsigned sample=0;sample<32;sample++) {
+    uint8_t first[64],second[64],out[112],want[112];
+    for(unsigned b=0;b<64;b++) {first[b]=(uint8_t)(sample*13+b*17);second[b]=(uint8_t)(sample*23+b*31+7);}
+    uint64_t half=patterns[sample%%8]^(sample>=8?((uint64_t)sample<<21):0),flags=UINT64_C(0xc91);
+    memset(out,0xa5,sizeof(out)); memset(want,0xa5,sizeof(want));
+    const uint8_t *base=rows[r].vector||rows[r].alias?first:second;
+    memcpy(want,base,64);
+    memcpy(want+rows[r].high*8,&half,8);
+    if(rows[r].vector) memset(want+16,0,48);
+    want[64]=1;
+    memcpy(want+72,&flags,8); memcpy(want+88,&half,8);
+    rows[r].run(out,first,second,&half);
+    if(memcmp(out,want,sizeof(out))) {fprintf(stderr,"half row=%%u sample=%%u\n",r,sample);return 1;}
+    outcomes++;
+  }
+  return outcomes==512?0:2;
+}
+`
diff --git a/x86_move_high_low_typed_test.go b/x86_move_high_low_typed_test.go
new file mode 100644
index 000000000..b9f92c48e
--- /dev/null
+++ b/x86_move_high_low_typed_test.go
@@ -0,0 +1,409 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86HighLowMoveGrammarAndPrivateSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86HighLowMoveOracle {
+			text := row.op + " X0,X1"
+			if row.vector {
+				text += ",X2"
+			}
+			for _, change := range []string{"memory", "Y-bank", "arity", "Z", "unsealed-raw", "mode32-high"} {
+				if change == "mode32-high" && (arch != "386" || !row.vector) {
+					continue
+				}
+				t.Run(arch+"/"+row.op+"/"+change, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, text)
+					switch change {
+					case "memory":
+						ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+					case "Y-bank":
+						ins.Args[0].Reg = "Y0"
+					case "arity":
+						ins.Args = ins.Args[:len(ins.Args)-1]
+					case "Z":
+						ins.Op += ".Z"
+					case "unsealed-raw":
+						ins.x86Encoded = true
+					case "mode32-high":
+						ins.Args[0].Reg = "X16"
+					}
+					if change != "unsealed-raw" {
+						_, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+						if !known || err == nil {
+							t.Fatal("invalid class/suffix/mode lost its typed boundary", known, err)
+						}
+						if change == "mode32-high" && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("physical high bank was conflated with ordinary grammar refusal", err)
+						}
+					}
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					for index := 0; index < 3; index++ {
+						state.writeVector(index, 64, ^uint64(0), false)
+					}
+					before := state.clone()
+					if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("invalid or unsealed source acquired NUM or changed state", change)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86HighLowMoveMode32InitializedRawThreeAPIObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	var names []string
+	for _, row := range []struct {
+		opcode byte
+		op     string
+	}{{0x12, "VMOVHLPS"}, {0x16, "VMOVLHPS"}} {
+		name := "RawMode32" + row.op
+		names = append(names, name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVL out+0(FP),DX\nMOVL input+4(FP),AX\n", name)
+		for index := 1; index <= 6; index++ {
+			fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", index)
+		}
+		for _, encoding := range []struct {
+			kind                string
+			first, second, dest int
+			wig                 bool
+		}{{"VEX2", 1, 2, 3, false}, {"VEX3", 4, 5, 6, true}, {"EVEX", 1, 2, 3, false}} {
+			source.WriteString(x86RawDisplacementDirectives(encodeX86RawVectorHighLowMove(row.opcode, encoding.kind, encoding.first, encoding.second, encoding.dest, encoding.wig)))
+		}
+		source.WriteString("VMOVUPS Z3,(DX)\nVMOVUPS Z6,64(DX)\nRET\n")
+		fmt.Fprintf(&declarations, "func %s(out *[128]byte,input *[64]byte)\n", name)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "386", triple, api)
+					if err != nil {
+						t.Fatal("initialized low-bank whole raw source rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+var x86HighLowMoveOracle = []struct {
+	op           string
+	high, vector bool
+}{
+	{"MOVHLPS", false, false}, {"MOVLHPS", true, false},
+	{"VMOVHLPS", false, true}, {"VMOVLHPS", true, true},
+}
+
+func TestX86HighLowMoveRawIdentityAndInputsRemainBound(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86HighLowMoveOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+				}
+				instruction, destination := row.op+" X0,X1", "Z1"
+				if row.vector {
+					instruction, destination = row.op+" X0,X1,X2", "Z2"
+				}
+				prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s a+0(FP),AX\n%s b+%d(FP),BX\n%s out+%d(FP),DX\n", 3*word, move, move, word, move, 2*word)
+				source := prefix + "VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (BX),Z2\n" + x86RawNumericalInstruction(t, arch, instruction) + "VMOVUPS " + destination + ",(DX)\nRET\n"
+				declaration := "func Value(a,b,out *[64]byte)"
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if _, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil {
+							t.Fatal("initialized actual-Go raw half source rejected", err)
+						}
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(a,b,out uintptr)", arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("integer declaration borrowed pointer/source authority", err)
+						}
+						for _, seed := range []string{"VMOVUPS (AX),Z0\n", "VMOVUPS (BX),Z1\n", move + " out+" + fmt.Sprint(2*word) + "(FP),DX\n"} {
+							changed := strings.Replace(source, seed, "", 1)
+							if changed == source {
+								t.Fatal("negative source was not changed", seed)
+							}
+							if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("raw bytes supplied missing numerical/pointer input", seed, err)
+							}
+						}
+					})
+				}
+				parsed, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := normalizeX86RawFile(parsed, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				function := file.Funcs[0]
+				if function.x86RawReplay == nil || function.x86RawReplay.validate(function, arch) != nil {
+					t.Fatal("original whole source lost its sealed replay")
+				}
+				changedProducer := function
+				changedProducer.Instrs = cloneX86ReplayInstrs(function.Instrs)
+				changedProducer.Instrs[1].Raw += " edited producer"
+				if function.x86RawReplay.validate(changedProducer, arch) == nil {
+					t.Fatal("edited producer borrowed original raw whole-source identity")
+				}
+				var raw Instr
+				for _, ins := range file.Funcs[0].Instrs {
+					if ins.Op == Op(row.op) {
+						raw = ins
+					}
+				}
+				if !x86RawMoveHalfSource(raw, arch) {
+					t.Fatal("original raw instruction lost exact source identity", raw)
+				}
+				for _, mutation := range []string{"args", "source", "width", "address", "segment", "memory"} {
+					t.Run(mutation, func(t *testing.T) {
+						changed := raw
+						changed.Args = append([]Operand(nil), raw.Args...)
+						switch mutation {
+						case "args":
+							changed.Args[0].Reg = "X3"
+						case "source":
+							changed.x86SourceRaw = nil
+							changed.x86Encoded = true
+						case "width":
+							changed.x86VectorBytes++
+						case "address":
+							changed.x86AddressBits = 32
+						case "segment":
+							changed.x86SegmentPrefix = 0x64
+						case "memory":
+							changed.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Base: AX}}
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						for i := 0; i < 4; i++ {
+							state.writeVector(i, 64, ^uint64(0), false)
+						}
+						before := state.clone()
+						accepted, _ := x86ResultMoveHalfStep(changed, &state, nil, 0, arch, true)
+						if x86RawMoveHalfSource(changed, arch) || accepted || !reflect.DeepEqual(state, before) {
+							t.Fatal("changed raw identity acquired source/memory permission", mutation)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86HighLowMoveCompleteTypedByteEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86HighLowMoveOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				text := row.op + " X0,X1"
+				destination := 1
+				if row.vector {
+					text += ",X2"
+					destination = 2
+				}
+				ins := x86ScalarLaneInstruction(t, text)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.dynamicMemory || len(effect.operands) != len(ins.Args) {
+					t.Fatal("complete register-half byte effect missing", effect, known, err)
+				}
+				sourceMask, baseMask := uint64(0xff00), uint64(0xff00)
+				if row.high {
+					sourceMask, baseMask = 0xff, 0xff
+				}
+				for index, operand := range effect.operands {
+					required := uint64(0)
+					if index == 0 {
+						required = sourceMask
+					} else if index == 1 {
+						required = baseMask
+					}
+					if operand.index != index || !reflect.DeepEqual(operand.operand, ins.Args[index]) || operand.width != 16 || operand.read != (index < 2) || operand.write != (index == destination) || operand.requiredBytes != required {
+						t.Fatal("selected halves/base/write were conflated", index, operand)
+					}
+				}
+				upper := x86TypedVectorUpperPreserve
+				if row.vector {
+					upper = x86TypedVectorUpperZero
+				}
+				if effect.vector.upperWrite != upper || effect.vector.memoryAlignment != 0 {
+					t.Fatal("register move acquired memory alignment or wrong upper rule", effect.vector)
+				}
+			})
+		}
+	}
+}
+
+func TestX86HighLowMoveSelectedNUMAndUpperAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86HighLowMoveOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				text := row.op + " X0,X1"
+				destination := 1
+				if row.vector {
+					text += ",X2"
+					destination = 2
+				}
+				ins := x86ScalarLaneInstruction(t, text)
+				for missing := -1; missing < 32; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.vectorUpper[destination] = 0x1a5a012345670000
+					if missing >= 0 {
+						state.xmm[missing/16] &^= 1 << uint(missing%16)
+					}
+					want := state.clone()
+					first, base := state.vectorBytes(0), state.vectorBytes(1)
+					defined := (first>>8)&0xff | base&0xff00
+					if row.high {
+						defined = (base & 0xff) | (first&0xff)<<8
+					}
+					want.xmm[destination] = uint16(defined)
+					if row.vector {
+						want.vectorUpper[destination] = ^uint64(0xffff)
+					}
+					if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+						t.Fatal("half selector invented NUM, changed FLAGS/DF or lost upper aliases", missing, state, want)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86HighLowMoveInitializedPortableBytesAndAliases(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch, move, word, original := "amd64", "MOVQ", 8, "x86_64-unknown-linux-gnu"
+	if strconv.IntSize == 32 {
+		arch, move, word, original = "386", "MOVL", 4, "i386-unknown-linux-gnu"
+	}
+	var source, declarations, prototypes, checks strings.Builder
+	var names []string
+	for _, row := range x86HighLowMoveOracle {
+		for _, alias := range []bool{false, true} {
+			name := fmt.Sprint("HighLow", len(names))
+			names = append(names, name)
+			destination := "X1"
+			if row.vector {
+				destination = "X2"
+			}
+			if alias {
+				destination = "X0"
+			}
+			instruction := row.op + " X0," + destination
+			if row.vector {
+				instruction = row.op + " X0,X1," + destination
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s a+0(FP),AX\n%s b+%d(FP),BX\n%s out+%d(FP),DX\nVMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (BX),Z2\n%s\nVMOVUPS Z%s,(DX)\nRET\n", name, 3*word, move, move, word, move, 2*word, instruction, destination[1:])
+			fmt.Fprintf(&declarations, "func %s(a,b,out *[64]byte)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,const uint8_t*,uint8_t*);\n", name)
+			high, vector, overlap := 0, 0, 0
+			if row.high {
+				high = 1
+			}
+			if row.vector {
+				vector = 1
+			}
+			if alias {
+				overlap = 1
+			}
+			fmt.Fprintf(&checks, "failed|=check(%s,\"%s\",%d,%d,%d);\n", name, name, high, vector, overlap)
+		}
+	}
+	if len(names) != 8 {
+		t.Fatal("complete half/alias directory changed", len(names))
+	}
+	// Preserve the eight named programs, then derive their raw counterparts
+	// from actual Go bytes. No handwritten opcode bytes or C mnemonic oracle.
+	rawSource := strings.ReplaceAll(source.String(), "HighLow", "RawHighLow")
+	operations := map[string]bool{}
+	for _, line := range strings.Split(source.String(), "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 {
+			continue
+		}
+		for _, row := range x86HighLowMoveOracle {
+			if fields[0] == row.op {
+				operations[line] = true
+			}
+		}
+	}
+	if len(operations) != 8 {
+		t.Fatal("original named instructions lost a distinct alias", len(operations))
+	}
+	for instruction := range operations {
+		rawSource = strings.ReplaceAll(rawSource, instruction+"\n", x86RawNumericalInstruction(t, arch, instruction))
+	}
+	source.WriteString(rawSource)
+	declarations.WriteString(strings.ReplaceAll(declarations.String(), "HighLow", "RawHighLow"))
+	prototypes.WriteString(strings.ReplaceAll(prototypes.String(), "HighLow", "RawHighLow"))
+	checks.WriteString(strings.ReplaceAll(checks.String(), "HighLow", "RawHighLow"))
+	for _, name := range append([]string(nil), names...) {
+		names = append(names, "Raw"+name)
+	}
+	if len(names) != 16 {
+		t.Fatal("complete named/raw directory changed", len(names))
+	}
+	x86LEAActualTargetGoObject(t, arch, original, source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() + x86HighLowMoveValueC + "int main(void){int failed=0;\n" + checks.String() + "return failed;}\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86CompactExpandRequireAllDefinitions(t, ir, names)
+			for _, pipeline := range []struct {
+				name, level string
+				optimize    bool
+			}{{"default-O0", "-O0", false}, {"default-O2", "-O2", false}, {"opt-O2", "-O2", true}} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					text := ir
+					if pipeline.optimize {
+						text = x86DwordProductIROptimize(t, text)
+					}
+					execution.compileAndRunLLVM(t, "high-low-pure-byte-values", text, driver, pipeline.level)
+				})
+			}
+		})
+	}
+	t.Log("actual-host translated integer bytes/aliases/canaries; original Go object only, no native SIMD execution claim")
+}
+
+const x86HighLowMoveValueC = `
+static int check(void (*run)(const uint8_t*,const uint8_t*,uint8_t*),const char *name,int high,int vector,int overlap) {
+    for(unsigned round=0;round<3;round++) {
+        uint8_t a[64],b[64],out[66],want[64];
+        for(unsigned i=0;i<64;i++) {a[i]=(uint8_t)(i*13+round*29+3);b[i]=(uint8_t)(0xe9-i*7-round*11);}
+        memset(out,0x69,sizeof(out));
+        const uint8_t *base=overlap&&!vector ? a:b;
+        for(unsigned i=0;i<64;i++) want[i]=i<16 || !vector ? base[i]:0;
+        for(unsigned i=0;i<8;i++) want[(high?8:0)+i]=a[(high?0:8)+i];
+        run(a,b,out+1);
+        if(out[0]!=0x69 || out[65]!=0x69 || memcmp(out+1,want,64)) {
+            fprintf(stderr,"%s round=%u high=%d vector=%d overlap=%d\n",name,round,high,vector,overlap);
+            for(unsigned i=0;i<64;i++) if(out[1+i]!=want[i]) fprintf(stderr,"byte=%u got=%x want=%x\n",i,out[1+i],want[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_move_remainder_mode32_test.go b/x86_move_remainder_mode32_test.go
new file mode 100644
index 000000000..d2ccc5d3d
--- /dev/null
+++ b/x86_move_remainder_mode32_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// These families have different existing contracts. Scalar grammar is not a
+// physical-bank certificate; its NUM domain refuses high banks even when all
+// candidate bytes/masks/native-address roles are supplied independently.
+func x86OfficialMoveRemainderMode32InstructionBoundary(t *testing.T, row string, w goasmrules.X86PackedBinaryWitness) string {
+	t.Helper()
+	ins := x86ScalarLaneInstruction(t, w.Instruction)
+	var output strings.Builder
+	context := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, "386", "i386-unknown-linux-gnu", false)
+	table := strings.Split(row, "/")[3]
+	if table == "_yvmovsd" {
+		form, known, err := amd64ScalarVectorMoveProperties(ins, "386")
+		if !known {
+			t.Fatal("scalar source lost its independent typed grammar", row)
+		}
+		if len(ins.Args) == 4 {
+			if err == nil {
+				t.Fatal("named Go386 four-operand grammar unexpectedly accepted", row)
+			}
+			if known, _, err := context.lowerVectorScalarMove(ins.Op, ins); !known || err == nil || output.Len() != 0 {
+				t.Fatal("rejected scalar arity emitted IR", row, known, err, output.String())
+			}
+			return "grammar"
+		}
+		if err != nil {
+			t.Fatal("actual Go scalar grammar was broadened or narrowed", row, err)
+		}
+		state := x86ResultState{flags: x86ByteFlagsAll}
+		for index := 0; index < 32; index++ {
+			state.writeVector(index, 64, ^uint64(0), false)
+		}
+		for index := range state.masks {
+			state.masks[index] = true
+		}
+		state.pointerGP[0] = true
+		low := ins
+		low.Args = append([]Operand(nil), ins.Args...)
+		for index, arg := range low.Args {
+			if register, valid := amd64ParseXReg(arg.Reg); arg.Kind == OpReg && valid && register >= 16 {
+				low.Args[index].Reg = Reg(fmt.Sprint("X", register-16))
+			}
+		}
+		lowForm, known, err := amd64ScalarVectorMoveProperties(low, "386")
+		control := state.clone()
+		if !known || err != nil || !x86ScalarVectorMoveResultTransfer(low, lowForm, &control, nil, 0, "386", true) {
+			t.Fatal("paired defined low-bank NUM control failed; high rejection is not isolated", row, err)
+		}
+		before := state.clone()
+		if x86ScalarVectorMoveResultTransfer(ins, form, &state, nil, 0, "386", true) || !reflect.DeepEqual(before, state) {
+			t.Fatal("fully defined high scalar bytes bypassed NUM physical-bank refusal", row)
+		}
+		return "NUM"
+	}
+	if table == "_yvmovntdq" || table == "_yvmovntdqa" {
+		form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, "386")
+		if !known {
+			t.Fatal("non-temporal source lost its typed grammar", row)
+		}
+		if w.Width == 512 {
+			if err == nil {
+				t.Fatal("Go386 high Z-bank grammar was broadened", row)
+			}
+			if known, _, err := context.lowerNonTemporalVectorMove(ins.Op, ins); !known || err == nil || output.Len() != 0 {
+				t.Fatal("rejected non-temporal Z grammar emitted IR", row, err, output.String())
+			}
+			return "grammar"
+		}
+		if err != nil || !form.move.ordinaryMemory(ins, "386") {
+			t.Fatal("non-temporal mode control lacks ordinary native memory", row, err)
+		}
+		known, _, err = context.lowerNonTemporalVectorMove(ins.Op, ins)
+		if !known || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 binding") || output.Len() != 0 {
+			t.Fatal("matching-target non-temporal mode guard emitted or borrowed earlier rejection", row, err, output.String())
+		}
+		return "mode"
+	}
+	_, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "386")
+	if !known {
+		_, known, err = x86GPSIMDTransferProperties(ins, "386")
+	}
+	if !known || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 binding") {
+		t.Fatal("half/GP transfer lost its direct typed mode guard", row, known, err)
+	}
+	if _, err := context.lowerInstr(-1, 0, ins, nil, nil); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "physical mode32 binding") || output.Len() != 0 {
+		t.Fatal("half/GP transfer emitted or borrowed non-mode rejection", row, err, output.String())
+	}
+	return "mode"
+}
diff --git a/x86_move_remainder_preflight_test.go b/x86_move_remainder_preflight_test.go
new file mode 100644
index 000000000..21d15b757
--- /dev/null
+++ b/x86_move_remainder_preflight_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// One initialized source per member is a producer/API preflight, not the101
+// source-row ownership proof. It deliberately leaves selection, late EVEX,
+// masks, store directions and386 high-bank/context classification to the
+// complete original-row owner after the existing-helper baseline is observed.
+func TestX86MoveRemainderExistingProducersThreeAPIsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			cases := []struct{ instruction, observation string }{
+				{"VLDDQU (AX),X1", "VMOVD X1,CX"},
+				{"VMASKMOVPD (AX),X0,X1", "VMOVD X1,CX"},
+				{"VMASKMOVPS (AX),X0,X1", "VMOVD X1,CX"},
+				{"VMOVD X1,BX", "MOVL BX,CX"},
+				{"VMOVHLPS X0,X1,X2", "PEXTRD $0,X2,CX"},
+				{"VMOVHPD (AX),X1,X2", "PEXTRD $2,X2,CX"},
+				{"VMOVHPS (AX),X1,X2", "PEXTRD $2,X2,CX"},
+				{"VMOVLHPS X0,X1,X2", "PEXTRD $2,X2,CX"},
+				{"VMOVLPD (AX),X1,X2", "PEXTRD $0,X2,CX"},
+				{"VMOVLPS (AX),X1,X2", "PEXTRD $0,X2,CX"},
+				{"VMOVMSKPD X1,BX", "MOVL BX,CX"},
+				{"VMOVMSKPS X1,BX", "MOVL BX,CX"},
+				{"VMOVNTDQ X1,(AX)", "VMOVD X1,CX"},
+				{"VMOVNTDQA (AX),X1", "VMOVD X1,CX"},
+				{"VMOVNTPD X1,(AX)", "VMOVD X1,CX"},
+				{"VMOVNTPS X1,(AX)", "VMOVD X1,CX"},
+				{"VMOVQ X1,BX", "MOVL BX,CX"},
+				{"VMOVSD X0,X1,X2", "PEXTRD $2,X2,CX"},
+				{"VMOVSS X0,X1,X2", "PEXTRD $1,X2,CX"},
+				{"VPMASKMOVD (AX),X0,X1", "VMOVD X1,CX"},
+				{"VPMASKMOVQ (AX),X0,X1", "VMOVD X1,CX"},
+				{"VPMOVMSKB X1,BX", "MOVL BX,CX"},
+			}
+			var programs []struct{ opcode, name, source, declaration string }
+			members := map[string]bool{}
+			for index, row := range cases {
+				opcode := strings.Fields(row.instruction)[0]
+				if members[opcode] {
+					t.Fatal("duplicated preflight member", opcode)
+				}
+				members[opcode] = true
+				name := fmt.Sprint("MovePreflight", index)
+				// Existing initialized native/vector producer. Initialized full
+				// aliases include every scalar upper/old-low and half base input.
+				initialization := "VMOVUPS (AX),Z0\nVMOVUPS (AX),Z1\nVMOVUPS (AX),Z2\n"
+				body, declaration := x86PackedMoveInitializedInstruction(name, arch, initialization, row.instruction, row.observation)
+				programs = append(programs, struct{ opcode, name, source, declaration string }{opcode, name, body, declaration})
+			}
+			// Reuse the existing implicit-DI producer rather than treating an
+			// absent explicit destination as FLAGS or inventing a memory tuple.
+			name := "MovePreflightImplicit"
+			body, declaration := x86ImplicitMaskMoveOracleProgram(arch, "VMASKMOVDQU", name)
+			programs = append(programs, struct{ opcode, name, source, declaration string }{"VMASKMOVDQU", name, body, declaration})
+			members["VMASKMOVDQU"] = true
+			if len(members) != 23 || len(programs) != 23 {
+				t.Fatal("incomplete producer/member directory", len(members), len(programs))
+			}
+			for _, program := range programs {
+				t.Run(program.opcode, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, triple, program.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, program.source, program.declaration, arch, triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized original member source rejected", err)
+							}
+							x86CompactExpandRequireAllDefinitions(t, ir, []string{program.name})
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	t.Log("member preflight only: original Go source+threeAPI backend O0/O2; no101-row selection, minimum-ISA, new raw, numeric or native-runtime claim")
+}
diff --git a/x86_movemask_selected_bits_runtime_test.go b/x86_movemask_selected_bits_runtime_test.go
new file mode 100644
index 000000000..4a0d3b4e7
--- /dev/null
+++ b/x86_movemask_selected_bits_runtime_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86MoveMaskSelectedBitsPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	_, _, layout, _ := x86ResultInitializationFixture(t, arch, "func Value(value uint32) uint32", "RET")
+	resultOffset := layout.Frame.Results[0].Offset
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t MaskAND(uint32_t);
+extern uint32_t MaskTEST(uint32_t);
+int main(void) {
+    for (uint32_t input = 0; input < 256; ++input) {
+        const uint32_t expected = input >= 128 ? 1 : 0;
+        const uint32_t and_value = MaskAND(input);
+        const uint32_t test_value = MaskTEST(input);
+        if (and_value != expected || test_value != expected) {
+            fprintf(stderr, "input=%u and=%u test=%u expected=%u\n",
+                    input, and_value, test_value, expected);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	// Separate modules keep one form's target-specific backend rejection from
+	// hiding other forms' portable results. This owner requires actual host
+	// execution and never substitutes native x86, an emulator or a passing skip.
+	for _, row := range x86SelectedMoveMaskRows {
+		t.Run(row.op+row.bank, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			for _, observation := range []struct{ name, body string }{
+				{"MaskAND", "ANDL $1,AX\n"},
+				{"MaskTEST", "TESTL $1,AX\nSETNE AL\nMOVBLZX AL,AX\n"},
+			} {
+				// Only this lane's sign byte is source-defined. Every other
+				// vector byte deliberately lacks a NUM initialization fact.
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$0-%d\nMOVL value+0(FP),BX\nPINSRB $%d,BX,X0\n%s %s0,AX\n%sMOVL AX,ret+%d(FP)\nRET\n",
+					observation.name, resultOffset+4, row.laneBytes-1, row.op, row.bank, observation.body, resultOffset)
+				fmt.Fprintf(&declarations, "func %s(value uint32) uint32\n", observation.name)
+			}
+			goAssemblerOracleOutput(t, arch, assembly.String(), "", true)
+			zero := "PXOR X0,X0\n"
+			if row.bank == "Y" {
+				zero = "VPXOR Y0,Y0,Y0\n"
+			}
+			complete := strings.ReplaceAll(assembly.String(), "MOVL value+0(FP),BX", zero+"MOVL value+0(FP),BX")
+			goAssemblerOracleOutput(t, arch, complete, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run("complete-input/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, complete, declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete input isolates the existing backend route", err)
+					}
+				})
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("selected-bit source did not produce portable IR", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+							text := ir
+							if optimized {
+								text = x86DwordProductIROptimize(t, ir)
+							}
+							for _, level := range []int{0, 2} {
+								t.Run(fmt.Sprintf("backend-O%d", level), func(t *testing.T) {
+									compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "movemask-selected-bits", triple, text, driver, nil, level)
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_movemask_selected_bits_test.go b/x86_movemask_selected_bits_test.go
new file mode 100644
index 000000000..af9bf9670
--- /dev/null
+++ b/x86_movemask_selected_bits_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// This independent inventory records physical byte positions, not renderer
+// results. MOVMSKPS/PD use each lane's final sign byte; PMOVMSKB uses every byte.
+var x86SelectedMoveMaskRows = []struct {
+	op, bank         string
+	width, laneBytes int
+}{
+	{"PMOVMSKB", "X", 16, 1}, {"VPMOVMSKB", "X", 16, 1}, {"VPMOVMSKB", "Y", 32, 1},
+	{"MOVMSKPS", "X", 16, 4}, {"VMOVMSKPS", "X", 16, 4}, {"VMOVMSKPS", "Y", 32, 4},
+	{"MOVMSKPD", "X", 16, 8}, {"VMOVMSKPD", "X", 16, 8}, {"VMOVMSKPD", "Y", 32, 8},
+}
+
+func TestX86MoveMaskSelectedOutputBitsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple, stack := "x86_64-unknown-linux-gnu", "Q"
+		if arch == "386" {
+			triple, stack = "i386-unknown-linux-gnu", "L"
+		}
+		_, _, layout, _ := x86ResultInitializationFixture(t, arch, "func Value(value uint8) uint32", "RET")
+		resultOffset := layout.Frame.Results[0].Offset
+		for _, row := range x86SelectedMoveMaskRows {
+			mask := row.op + " " + row.bank + "0,AX\n"
+			seed := fmt.Sprintf("MOVBLZX value+0(FP),BX\nPINSRB $%d,BX,X0\n", row.laneBytes-1)
+			for _, control := range []struct {
+				name, before, between, observe string
+				seed, pass                     bool
+			}{
+				{name: "and-selected", seed: true, pass: true, observe: "ANDL $1,AX\n"},
+				{name: "and-next-unknown", seed: true, observe: "ANDL $3,AX\n"},
+				{name: "unknown-escape", seed: true},
+				{name: "missing-source", observe: "ANDL $1,AX\n"},
+				{name: "constant-zero", pass: true, observe: "ANDL $0,AX\n"},
+				{name: "intervening-nop", seed: true, between: "NOP\n", observe: "ANDL $1,AX\n"},
+				{name: "changed-source", seed: true, between: "PXOR X0,X0\n", observe: "ANDL $1,AX\n"},
+				{name: "overwritten-result", seed: true, between: "MOVL CX,AX\n", observe: "ANDL $1,AX\n"},
+				{name: "test-selected", seed: true, pass: true, observe: "TESTL $1,AX\nSETNE AL\nMOVBLZX AL,AX\n"},
+				{name: "test-selected-byte", seed: true, pass: true, observe: "TESTB $1,AL\nSETNE AL\nMOVBLZX AL,AX\n"},
+				{name: "test-next-unknown", seed: true, observe: "TESTL $3,AX\nSETNE AL\nMOVBLZX AL,AX\n"},
+				{name: "high-byte-is-padding", seed: true, pass: row.laneBytes > 1, observe: "MOVBLZX AH,AX\n"},
+				{name: "selected-bit-eight", before: "MOVBLZX value+0(FP),BX\nPINSRB $8,BX,X0\n", pass: true, observe: "ANDW $256,AX\nMOVWLZX AX,AX\n"},
+				{name: "test-does-not-write-GP", seed: true, observe: "TESTL $1,AX\n"},
+				{name: "dynamic-mask-unproved", seed: true, before: "MOVL $1,CX\n", observe: "TESTL AX,CX\nSETNE AL\nMOVBLZX AL,AX\n"},
+				{name: "movemask-preserves-CF", seed: true, pass: true, before: "MOVL $0,CX\nCMPL CX,$1\n", observe: "SETCS CL\nMOVBLZX CL,AX\n"},
+				{name: "and-defines-CF", seed: true, pass: true, observe: "ANDL $1,AX\nSETCS CL\nMOVBLZX CL,AX\n"},
+				{name: "and-does-not-define-AF", seed: true, observe: "ANDL $1,AX\nPUSHF" + stack + "\nPOP" + stack + " DX\nANDL $16,DX\nMOVL DX,AX\n"},
+			} {
+				t.Run(arch+"/"+row.op+row.bank+"/"+control.name, func(t *testing.T) {
+					prefix := control.before
+					if control.seed {
+						prefix += seed
+					}
+					body := prefix + mask + control.between + control.observe + fmt.Sprintf("MOVL AX,ret+%d(FP)\nRET", resultOffset)
+					_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(value uint8) uint32", body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					t.Run("query", func(t *testing.T) {
+						err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+						if control.pass && err != nil || !control.pass && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("selected bits or flags did not retain their exact dependencies", err)
+						}
+					})
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(value uint8) uint32", arch, triple, api)
+							if arch == "amd64" && !control.pass && control.name != "overwritten-result" && control.name != "and-does-not-define-AF" {
+								x86VectorScratchCodegenControl(t, source, "func Value(value uint8) uint32", arch, triple, ir, err)
+							} else if control.pass && (err != nil || ir == "") || !control.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+								t.Fatal("adjacent observation invented or lost numerical bits", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MoveMaskSelectedBitsKeepSourceAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		_, _, layout, _ := x86ResultInitializationFixture(t, arch, "func Value(value uint8) uint32", "RET")
+		for _, row := range x86SelectedMoveMaskRows {
+			for _, initialize := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s%s/native-input=%t", arch, row.op, row.bank, initialize), func(t *testing.T) {
+					prefix := ""
+					if initialize {
+						prefix = move + " input+0(FP),SI\n"
+					}
+					body := fmt.Sprintf("%sPINSRB $%d,(SI),X0\n%s %s0,AX\nANDL $1,AX\nMOVL AX,ret+%d(FP)\nRET", prefix, row.laneBytes-1, row.op, row.bank, word)
+					_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(input *byte) uint32", body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone query cannot borrow a lowerer's native-read continuation", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(input *byte) uint32", arch, triple, api)
+							if initialize && (err != nil || ir == "") || !initialize && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+								t.Fatal("movemask altered the actual byte-read source requirement", err)
+							}
+						})
+					}
+				})
+			}
+			for _, mutation := range []string{"encoded", "raw-source", "address-override"} {
+				t.Run(arch+"/"+row.op+row.bank+"/"+mutation, func(t *testing.T) {
+					body := fmt.Sprintf("MOVBLZX value+0(FP),BX\nPINSRB $%d,BX,X0\n%s %s0,AX\nANDL $1,AX\nMOVL AX,ret+%d(FP)\nRET", row.laneBytes-1, row.op, row.bank, layout.Frame.Results[0].Offset)
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(value uint8) uint32", body)
+					for index := range file.Funcs[0].Instrs {
+						ins := &file.Funcs[0].Instrs[index]
+						if string(ins.Op) != row.op {
+							continue
+						}
+						switch mutation {
+						case "encoded":
+							ins.x86Encoded = true
+						case "raw-source":
+							ins.x86SourceRaw = new(x86SourceRawInstruction)
+						case "address-override":
+							ins.x86AddressBits = 16
+						}
+					}
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("a physical source borrowed the new named adjacent-bit producer", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MoveMaskSignByteDependenciesAndPreservedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86SelectedMoveMaskRows {
+			for missing := -1; missing < row.width; missing++ {
+				t.Run(fmt.Sprintf("%s/%s%s/missing=%d", arch, row.op, row.bank, missing), func(t *testing.T) {
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagOF}
+					state.writeVector(0, 64, ^uint64(0), false)
+					if missing >= 0 {
+						state.writeVector(0, 64, state.vectorBytes(0)&^(uint64(1)<<uint(missing)), false)
+					}
+					before := state.clone()
+					ins := x86ScalarLaneInstruction(t, row.op+" "+row.bank+"0,AX")
+					accepted, known := x86ResultMoveMaskStep(ins, &state, nil, 0, arch)
+					if !accepted || !known {
+						t.Fatal("legal pure register producer cannot discard partially defined output bits")
+					}
+					want := uint8(0)
+					for byteIndex := 0; byteIndex < 8; byteIndex++ {
+						complete := true
+						for bit := 8 * byteIndex; bit < 8*byteIndex+8; bit++ {
+							if bit < row.width/row.laneBytes && bit*row.laneBytes+row.laneBytes-1 == missing {
+								complete = false
+							}
+						}
+						if complete {
+							want |= 1 << uint(byteIndex)
+						}
+					}
+					if state.gp[0] != want || state.flags != before.flags ||
+						!reflect.DeepEqual(state.xmm, before.xmm) || !reflect.DeepEqual(state.vectorUpper, before.vectorUpper) ||
+						!reflect.DeepEqual(state.masks, before.masks) || !reflect.DeepEqual(state.fp, before.fp) {
+						t.Fatal("movemask widened a partial byte or altered vector/flags/storage", state.gp[0], want)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_multiply_add_input_contract_test.go b/x86_multiply_add_input_contract_test.go
new file mode 100644
index 000000000..3fd2fccf1
--- /dev/null
+++ b/x86_multiply_add_input_contract_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86MultiplyAddInputRows(arch string) []string {
+	var rows []string
+	for _, opcode := range []string{"PMADDWL", "PMADDUBSW"} {
+		rows = append(rows, opcode+" X0,X1", opcode+" (BX),X1")
+	}
+	for _, opcode := range []string{"VPMADDWD", "VPMADDUBSW"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, input := range []string{bank + "0", "(BX)"} {
+				rows = append(rows, opcode+" "+input+","+bank+"1,"+bank+"2")
+				if arch == "amd64" {
+					rows = append(rows, opcode+" "+input+","+bank+"1,K1,"+bank+"2",
+						opcode+".Z "+input+","+bank+"1,K1,"+bank+"2")
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86MultiplyAddVoidCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple, count := "x86_64-unknown-linux-gnu", 40
+		if arch == "386" {
+			triple, count = "i386-unknown-linux-gnu", 16
+		}
+		rows := x86MultiplyAddInputRows(arch)
+		if len(rows) != count {
+			t.Fatal("incomplete independent multiply-add input inventory", arch, len(rows))
+		}
+		var original strings.Builder
+		for i, row := range rows {
+			fmt.Fprintf(&original, "TEXT f%d(SB),4,$0-0\n%s\nRET\n", i, row)
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, original.String())
+		for _, row := range rows {
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool=%t", arch, row, unused), func(t *testing.T) {
+					declaration, extent := "func Value()", 0
+					if unused {
+						declaration, extent = "func Value(unused bool)", 1
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nRET\n", extent, row)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if arch == "amd64" && unused && !strings.Contains(row, "(") && !strings.Contains(row, ",K") {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool supplied absent vector, address or mask inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MultiplyAddInitializedInputsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			for index, row := range x86MultiplyAddInputRows(target.arch) {
+				name := fmt.Sprint("MultiplyAdd", index)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte,a,b [64]byte,mask uint64)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),BX\n", name, word+136, move)
+				fmt.Fprintf(&source, "VMOVUPS a+%d(FP),Z0\nVMOVUPS b+%d(FP),Z1\nVMOVUPS b+%d(FP),Z2\n",
+					word, word+64, word+64)
+				if target.arch == "amd64" {
+					fmt.Fprintf(&source, "KMOVQ mask+%d(FP),K1\n", word+128)
+				}
+				fmt.Fprintf(&source, "%s\nRET\n", row)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized multiply-add family rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86MultiplyAddNumericalStateAndMemoryAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86MultiplyAddInputRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row)
+				initial := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				for index := 0; index < 3; index++ {
+					initial.writeVector(index, 64, ^uint64(0), false)
+				}
+				initial.pointerGP[3], initial.gp[3], initial.masks[1] = true, 0xff, true
+				memory := strings.Contains(row, "(BX)")
+				apply := func(state *x86ResultState) bool {
+					if memory {
+						accepted, known := x86LoweredFixedVectorNativeRead(ins, state, nil, arch)
+						return known && accepted
+					}
+					return x86ResultTransfer(ins, state, nil, 0, arch)
+				}
+				state := initial.clone()
+				if !apply(&state) || !reflect.DeepEqual(state, initial) {
+					t.Fatal("complete inputs lost defined bytes or changed unrelated state")
+				}
+				for _, missing := range []string{"first", "second", "mask"} {
+					if missing == "mask" && !strings.Contains(row, "K1") {
+						continue
+					}
+					state = initial.clone()
+					switch missing {
+					case "first":
+						if memory {
+							state.pointerGP[3] = false
+						} else {
+							state.writeVector(0, 64, 0, false)
+						}
+					case "second":
+						state.writeVector(1, 64, 0, false)
+					case "mask":
+						state.masks[1] = false
+					}
+					before := state.clone()
+					numericalAddress := memory && missing == "first"
+					if accepted := apply(&state); accepted != numericalAddress || !reflect.DeepEqual(state, before) {
+						t.Fatal("missing input acquired an effect or changed state", missing)
+					}
+					if numericalAddress {
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[3] = available
+							unchanged := partial.clone()
+							if apply(&partial) || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("multiply-add acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+				}
+				if memory {
+					state = initial.clone()
+					if x86ResultTransfer(ins, &state, nil, 0, arch) {
+						t.Fatal("standalone observer borrowed the lowering-only native read")
+					}
+				}
+				if strings.HasPrefix(row, "V") {
+					state = initial.clone()
+					state.writeVector(2, 64, 0, false)
+					want := !strings.Contains(row, "K1") || strings.Contains(row, ".Z ")
+					if apply(&state) != want || want && state.vectorBytes(2) != ^uint64(0) {
+						t.Fatal("merge dependency or wider-alias zero definition changed")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_mulx_memory_source_boundaries_test.go b/x86_mulx_memory_source_boundaries_test.go
new file mode 100644
index 000000000..e8edf82d7
--- /dev/null
+++ b/x86_mulx_memory_source_boundaries_test.go
@@ -0,0 +1,95 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MULXMemorySourcesKeepTheirSeparateStorageRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			rows := []string{op + " 4096(SP),CX,DX"}
+			if arch == "amd64" {
+				rows = append(rows, op+" (BP),CX,DX", op+" 1(BX)(BP*2),CX,DX")
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nRET\n")
+			if len(pcs) != len(rows)+1 {
+				t.Fatal("actual Go omitted a physical frame-address source", pcs)
+			}
+			mode, move := 64, "MOVQ"
+			if arch == "386" {
+				mode, move = 32, "MOVL"
+			}
+			x86NumericalVEXGPRequireMC(t, code, mode, len(pcs))
+			type program struct {
+				name, source, declaration string
+				pass                      bool
+			}
+			var programs []program
+			for index, row := range rows {
+				for _, raw := range []bool{false, true} {
+					instruction := row + "\n"
+					if raw {
+						instruction = x86RawDisplacementDirectives(code[pcs[index]:pcs[index+1]])
+					}
+					programs = append(programs, program{
+						name: fmt.Sprintf("frame-source%d/raw=%t", index, raw),
+						source: "TEXT Value(SB),4,$0-0\nMOVL $3,DX\nMOVL $7,BX\n" +
+							instruction + "RET\n",
+						declaration: "func Value()",
+					})
+				}
+			}
+			// Incoming pointers and independently defined numerical indexes
+			// remain distinct from physical SP/BP entry. Mode32 BP is ordinary
+			// GP, so retain both its pointer and numerical-index source roles.
+			for _, base := range []string{"BX", "BP"} {
+				if base == "BP" && arch != "386" {
+					continue
+				}
+				programs = append(programs, program{
+					name: "caller-pointer-" + base,
+					source: fmt.Sprintf("TEXT Value(SB),4,$0-%d\n%s p+0(FP),%s\nMOVL $3,DX\n%s (%s),CX,DX\nRET\n",
+						goWordSize(arch), move, base, op, base),
+					declaration: "func Value(p *[64]byte)", pass: true,
+				})
+			}
+			if arch == "386" {
+				programs = append(programs, program{
+					name: "mode32-numerical-BP-index",
+					source: "TEXT Value(SB),4,$0-4\nMOVL p+0(FP),BX\nMOVL $0,BP\nMOVL $3,DX\n" +
+						op + " 1(BX)(BP*2),CX,DX\nRET\n",
+					declaration: "func Value(p *[64]byte)", pass: true,
+				})
+			}
+			programs = append(programs, program{
+				name:        "owned-DATA-dead-unknown-DX",
+				source:      "TEXT Value(SB),4,$0-0\n" + op + " table(SB),CX,DX\nRET\n",
+				declaration: "func Value()", pass: true,
+			})
+			const data = "DATA table+0(SB)/8,$7\nGLOBL table(SB),8,$8\n"
+			var prior strings.Builder
+			for index, program := range programs {
+				prior.WriteString(strings.Replace(program.source, "TEXT Value(SB)", fmt.Sprintf("TEXT Source%d(SB)", index), 1))
+			}
+			x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String()+data)
+			for _, program := range programs {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+op+"/"+program.name+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, program.source+data, program.declaration,
+							arch, x86AddressMemoryTargets(arch)[0], api)
+						if program.pass {
+							if err != nil || ir == "" {
+								t.Fatal("MULX lost a separately initialized pointer/index or owned DATA source", err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("physical frame memory borrowed virtual stack/BP storage", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_mulx_native_read_tdd_test.go b/x86_mulx_native_read_tdd_test.go
new file mode 100644
index 000000000..cdaecc1c1
--- /dev/null
+++ b/x86_mulx_native_read_tdd_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86MULXTestOps(arch string) []string {
+	if arch == "386" {
+		return []string{"MULXL"}
+	}
+	return []string{"MULXL", "MULXQ"}
+}
+
+// The official table/physical full-family roots separately retain all 28 GP
+// rows. These original Go/LLVM priors bind the exact source/alias forms below
+// before a public API sees the full initialized or missing-input program.
+func x86MULXTestPhysical(t *testing.T, arch, op string) map[string]string {
+	t.Helper()
+	rows := []string{
+		op + " AX,CX,DX", op + " DX,CX,DX", op + " (BX),CX,DX",
+		op + " 1(BX)(SI*2),CX,DX", op + " 1(DX)(SI*2),CX,DX",
+		op + " 1(BX)(SI*2),BX,DX",
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nRET\n")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("actual MULX physical grammar/alias prior omitted a row", pcs)
+	}
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	x86NumericalVEXGPRequireMC(t, code, mode, len(pcs))
+	result := make(map[string]string)
+	for index, row := range rows {
+		result[row] = x86RawDisplacementDirectives(code[pcs[index]:pcs[index+1]])
+	}
+	return result
+}
+
+func x86MULXTestSource(name, arch, op, instruction string, dead bool) (string, string) {
+	word, move, push, pop := goWordSize(arch), "MOVQ", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		move, push, pop = "MOVL", "PUSHFL", "POPL"
+	}
+	width, store := 4, "MOVL"
+	if op == "MULXQ" {
+		width, store = 8, "MOVQ"
+	}
+	body := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n%s out+0(FP),DI\n%s p+%d(FP),BX\n",
+		name, 2*word, move, move, word) + "MOVL $7,AX\nMOVL $3,DX\nMOVL $0,SI\nCMPL AX,$1\nSTD\n" + instruction + "\n"
+	if !dead {
+		body += fmt.Sprintf("%s CX,0(DI)\n%s DX,%d(DI)\n", store, store, width)
+	}
+	body += push + "\n" + pop + " SI\nANDL $0xcd5,SI\nMOVL SI,16(DI)\nCLD\nRET\n"
+	return body, fmt.Sprintf("func %s(out *[32]byte,p *[64]byte)\n", name)
+}
+
+func TestX86MULXNativeMemoryMissingFactsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			physical := x86MULXTestPhysical(t, arch, op)
+			for _, raw := range []bool{false, true} {
+				var prior strings.Builder
+				var programs []string
+				const data = "DATA unused+0(SB)/8,$7\nGLOBL unused(SB),8,$8\n"
+				for index, missing := range []string{"original-Void", "address", "index", "implicit-DX", "opaque-DX-address"} {
+					instruction := op + " 1(BX)(SI*2),CX,DX"
+					if missing == "opaque-DX-address" {
+						instruction = op + " 1(DX)(SI*2),CX,DX"
+					}
+					if missing == "original-Void" {
+						instruction = op + " (BX),CX,DX"
+					}
+					if raw {
+						instruction = physical[instruction]
+					}
+					body, _ := x86MULXTestSource("Value", arch, op, instruction, false)
+					switch missing {
+					case "original-Void":
+						body = "TEXT Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+					case "address":
+						move := "MOVQ"
+						if arch == "386" {
+							move = "MOVL"
+						}
+						body = strings.Replace(body, fmt.Sprintf("%s p+%d(FP),BX\n", move, goWordSize(arch)), "", 1)
+					case "index":
+						body = strings.Replace(body, "MOVL $0,SI\n", "", 1)
+					case "implicit-DX":
+						body = strings.Replace(body, "MOVL $3,DX\n", "", 1)
+					case "opaque-DX-address":
+						move := "MOVQ"
+						if arch == "386" {
+							move = "MOVL"
+						}
+						body = strings.Replace(body, "MOVL $3,DX\n", fmt.Sprintf("%s p+%d(FP),DX\n", move, goWordSize(arch)), 1)
+					}
+					// The unused legitimate DATA stays in every public program;
+					// its presence cannot initialize the unrelated BX address.
+					prior.WriteString(strings.Replace(body, "TEXT Value(SB)", fmt.Sprintf("TEXT Missing%d(SB)", index), 1))
+					programs = append(programs, body+data)
+				}
+				// Establish every original Go body before asking a public API.
+				x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String()+data)
+				for index, text := range programs {
+					declaration := "func Value(out *[32]byte,p *[64]byte)\n"
+					if index == 0 {
+						declaration = "func Value()\n"
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/%s/raw=%t/missing%d/%s", arch, op, raw, index, api), func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, text, declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("MULX borrowed a missing native address, index or implicit numerical DX", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86MULXInitializedNativeReadEffectsFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete MULX source/read objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		widths := make(map[string]int)
+		for _, op := range x86MULXTestOps(target.arch) {
+			physical := x86MULXTestPhysical(t, target.arch, op)
+			for _, raw := range []bool{false, true} {
+				for _, memory := range []bool{false, true} {
+					for _, dead := range []bool{false, true} {
+						instruction := op + " AX,CX,DX"
+						if memory {
+							instruction = op + " 1(BX)(SI*2),CX,DX"
+							if !dead {
+								instruction = op + " 1(BX)(SI*2),BX,DX"
+							}
+						}
+						if raw {
+							instruction = physical[instruction]
+						}
+						name := fmt.Sprint("MULXInput", len(widths))
+						body, declaration := x86MULXTestSource(name, target.arch, op, instruction, dead)
+						if memory && !dead {
+							// The effective address must be consumed before MULX
+							// replaces the old pointer with its low product.
+							store := "MOVL"
+							if op == "MULXQ" {
+								store = "MOVQ"
+							}
+							body = strings.Replace(body, store+" CX,0(DI)", store+" BX,0(DI)", 1)
+						}
+						widths[name] = 0
+						if memory {
+							widths[name] = 32
+							if op == "MULXQ" {
+								widths[name] = 64
+							}
+						}
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+				}
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("fully initialized MULX cannot compose with its actual native inputs", err)
+				}
+				for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for name, bits := range widths {
+						function := x86StringMemoryFunction(t, body, name)
+						if bits == 0 {
+							continue
+						}
+						load := fmt.Sprintf("load volatile i%d,", bits)
+						count := strings.Count(function, load)
+						if count != 1 {
+							t.Fatal("dead or live MULX lost its sole exact unaligned native read", name, bits, count)
+						}
+						for _, line := range strings.Split(function, "\n") {
+							if strings.Contains(line, load) && !strings.Contains(line, "align 1") {
+								t.Fatal("MULX native read invented an alignment contract", name, line)
+							}
+						}
+					}
+					compileLLVMToObject(t, llc, target.triple, "mulx-inputs.ll", "mulx-inputs.o", body)
+				}
+			})
+		}
+	}
+}
+
+func TestX86MULXTypedInputsOutputsAndPreservedFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			x86MULXTestPhysical(t, arch, op)
+			ins := x86YMMReadSource(t, op+" AX,CX,DX")
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if !known || err != nil || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+				t.Fatal("MULX lost complete typed operands or incorrectly changed FLAGS", arch, op, effect, known, err)
+			}
+			reads, writes := make(map[Reg]bool), make(map[Reg]bool)
+			for _, operand := range effect.operands {
+				width := int64(4)
+				if op == "MULXQ" {
+					width = 8
+				}
+				if operand.width != width {
+					t.Fatal("MULX source/output width differs from its physical operand", op, operand)
+				}
+				if operand.read {
+					reads[operand.operand.Reg] = true
+				}
+				if operand.write {
+					writes[operand.operand.Reg] = true
+				}
+			}
+			if !reflect.DeepEqual(reads, map[Reg]bool{AX: true, DX: true}) ||
+				!reflect.DeepEqual(writes, map[Reg]bool{CX: true, DX: true}) {
+				t.Fatal("MULX omitted implicit DX, invented old outputs or lost a product half", reads, writes)
+			}
+		}
+	}
+}
+
+func TestX86MULXMode32PhysicalWIGRetainsOrdinarySourceBoundary(t *testing.T) {
+	x86MULXTestPhysical(t, "386", "MULXQ")
+	for _, row := range []string{"MULXQ AX,CX,DX", "MULXQ (BX),CX,DX"} {
+		code, pcs := x86NumericalBoundaryGoBytes(t, "386", row+"\nRET\n")
+		x86NumericalVEXGPRequireMC(t, code, 32, len(pcs))
+		decoded, size, known, err := decodedX86MULXInstructionWithMemory(code, 32, x86RawMemoryDecoder{physicalPC: true})
+		if !known || err != nil || size != int(pcs[1]) || decoded.Op != "MULXL" {
+			t.Fatal("physical mode32 WIG prior did not remain a dword boundary", decoded, size, err)
+		}
+		if _, _, known, err := decodedX86MULXInstruction(code, 32); !known || err == nil {
+			t.Fatal("physical WIG observation broadened the default raw source entry", known, err)
+		}
+		body, declaration := x86MULXTestSource("Value", "386", "MULXQ", row, true)
+		x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu", body)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, body, declaration, "386", "i386-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("named mode32 Q acquired an ordinary qword role from physical WIG", api, err)
+			}
+		}
+	}
+}
diff --git a/x86_mulx_observable_inputs_test.go b/x86_mulx_observable_inputs_test.go
new file mode 100644
index 000000000..4a4631c3c
--- /dev/null
+++ b/x86_mulx_observable_inputs_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Unknown nontrapping scratch results may remain dead. An ABI result or native
+// store cannot turn those unknown bits into implementation-initialized zeroes.
+func TestX86MULXObservableResultsRequireActualInputsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		for _, op := range x86MULXTestOps(arch) {
+			instruction := op + " AX,CX,BX"
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, instruction+"\nRET\n")
+			if len(pcs) != 2 || pcs[1] != int64(len(code)-1) {
+				t.Fatal("original complete MULX instruction boundary changed", pcs, code)
+			}
+			physical := x86RawDisplacementDirectives(code[:pcs[1]])
+			for _, raw := range []bool{false, true} {
+				for _, use := range []string{"two-FP-results", "Void-native-store", "dead-constant-FP-result"} {
+					for _, input := range []string{"complete", "missing-DX", "missing-source", "partial-DX", "opaque-DX"} {
+						t.Run(fmt.Sprintf("%s/%s/raw=%t/%s/%s", arch, op, raw, use, input), func(t *testing.T) {
+							declaration := "func Value(out *[16]byte,p *[8]byte) (low,high uintptr)"
+							frame := word * 4
+							suffix := fmt.Sprintf("%s CX,low+%d(FP)\n%s BX,high+%d(FP)\nRET\n", move, word*2, move, word*3)
+							prefix := ""
+							if use == "Void-native-store" {
+								declaration, frame = "func Value(out *[16]byte,p *[8]byte)", word*2
+								prefix = fmt.Sprintf("%s out+0(FP),DI\n", move)
+								suffix = fmt.Sprintf("%s CX,0(DI)\n%s BX,%d(DI)\nRET\n", move, move, word)
+							} else if use == "dead-constant-FP-result" {
+								declaration, frame = "func Value(out *[16]byte,p *[8]byte) (result uintptr)", word*3
+								suffix = fmt.Sprintf("%s $23,result+%d(FP)\nRET\n", move, word*2)
+							}
+							if input != "missing-source" {
+								prefix += "MOVL $7,AX\n"
+							}
+							switch input {
+							case "complete", "missing-source":
+								prefix += "MOVL $3,DX\n" // r32 zero-extension also defines the qword input.
+							case "partial-DX":
+								prefix += "MOVW $3,DX\n"
+							case "opaque-DX":
+								prefix += fmt.Sprintf("%s p+%d(FP),DX\n", move, word)
+							}
+							body := instruction + "\n"
+							if raw {
+								body = physical
+							}
+							source := fmt.Sprintf("TEXT Value(SB),4,$0-%d\n", frame) + prefix + body + suffix
+							triple := x86AddressMemoryTargets(arch)[0]
+							x86LEAActualTargetGoObject(t, arch, triple, source)
+							pass := input == "complete" || use == "dead-constant-FP-result" && !raw && input != "opaque-DX"
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+								if pass {
+									if err != nil || ir == "" {
+										t.Fatal("complete inputs or genuinely dead unknown results lost their source contract", api, err)
+									}
+									if use == "dead-constant-FP-result" {
+										x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{23})
+									}
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("observable MULX result borrowed source or implicit DX bytes", api, err)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86MULXUnknownScratchTransferKeepsBothOutputsUnknown(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86YMMReadSource(t, op+" AX,CX,BX")
+				before := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				before.gp[0], before.gp[1], before.gp[3] = 0xff, 0xff, 0xff
+				before.canonicalGP[1], before.canonicalGP[3] = 0xff, 0xff
+				before.pointerGP[1], before.pointerGP[3] = true, true // Old destinations are never inputs.
+				state := before.clone()
+				if accepted, known := x86LoweredMULXResultStep(ins, &state, nil, 0, arch); !accepted || !known {
+					t.Fatal("closed nontrapping scratch operation was rejected")
+				}
+				want := uint8(0xf0)
+				if strings.HasSuffix(op, "Q") {
+					want = 0
+				}
+				if state.gp[1] != want || state.gp[3] != want || state.canonicalGP[1] != want || state.canonicalGP[3] != want ||
+					state.pointerGP[1] || state.pointerGP[3] ||
+					state.flags != before.flags || state.direction != before.direction {
+					t.Fatal("unknown product gained numerical outputs or changed FLAGS/DF", state)
+				}
+				opaque := before.clone()
+				opaque.pointerGP[2] = true
+				original := opaque.clone()
+				if accepted, _ := x86LoweredMULXResultStep(ins, &opaque, nil, 0, arch); accepted || !reflect.DeepEqual(opaque, original) {
+					t.Fatal("unknown-result fallback consumed an opaque pointer or mutated a rejected state")
+				}
+				if !x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, arch) {
+					t.Fatal("Void or missing result declarations bypassed whole-source unknown/result propagation")
+				}
+			})
+		}
+	}
+}
+
+func TestX86MULXObservableBoolCannotBorrowOldCanonicalOutputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			for _, scenario := range []string{"bounded", "unbounded", "missing-DX-bounded"} {
+				t.Run(arch+"/"+op+"/"+scenario, func(t *testing.T) {
+					declaration := "func Value() (bool,uint32)"
+					_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+					var boolean, number int64
+					for _, slot := range sig.Frame.Results {
+						if slot.Type == I1 {
+							boolean = slot.Offset
+						} else {
+							number = slot.Offset
+						}
+					}
+					// Both old outputs are canonical before being overwritten. A
+					// known product is numerical, not necessarily zero or one.
+					body := "MOVL $7,AX\nMOVL $1,CX\nMOVL $1,BX\n"
+					if scenario != "missing-DX-bounded" {
+						body += "MOVL $3,DX\n"
+					}
+					body += op + " AX,CX,BX\n"
+					if scenario != "unbounded" {
+						body += "ANDL $1,CX\n"
+					}
+					body += fmt.Sprintf("MOVL $23,AX\nMOVL AX,ret+%d(FP)\nMOVB CX,ret+%d(FP)\nRET\n", number, boolean)
+					_, _, _, source := x86ResultInitializationFixture(t, arch, declaration, body)
+					triple := x86AddressMemoryTargets(arch)[0]
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if scenario == "bounded" {
+							if err != nil || ir == "" {
+								t.Fatal("complete newly bounded bool/number result rejected", api, err)
+							}
+							x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{1, 23})
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("MULX result borrowed old canonicality or implementation NUM bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_mulx_original_format_test.go b/x86_mulx_original_format_test.go
new file mode 100644
index 000000000..14a5857b8
--- /dev/null
+++ b/x86_mulx_original_format_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Keep the complete original raw sources, actual Go/LLVM physical priors and
+// public Context results. Direct emitter objects describe formats only: their
+// private register slots grant no entry, numerical input or address permission.
+func x86MULXOriginalFormatObject(t *testing.T, source, arch, triple string, rows []string) string {
+	t.Helper()
+	original, err := Parse(ArchAMD64, source)
+	if err != nil || len(original.Funcs) != len(rows) {
+		t.Fatal("original MULX format directory changed", err)
+	}
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	for index, function := range original.Funcs {
+		if len(function.Instrs) < 3 || function.Instrs[0].Op != OpTEXT ||
+			function.Instrs[len(function.Instrs)-1].Op != OpRET {
+			t.Fatal("original MULX format lost its TEXT/RET envelope", function.Sym)
+		}
+		var expected []byte
+		for _, instruction := range function.Instrs[1 : len(function.Instrs)-1] {
+			chunk, err := x86RawDirectiveBytes(instruction)
+			if instruction.Op != "BYTE" || err != nil || len(chunk) != 1 {
+				t.Fatal("original MULX format lost a complete BYTE directive", instruction.Raw, err)
+			}
+			expected = append(expected, chunk...)
+		}
+		expected = append(expected, 0xc3)
+		actual, pcs := x86NumericalBoundaryGoBytes(t, arch, rows[index]+"\nRET")
+		if !bytes.Equal(actual, expected) || len(pcs) != 2 || pcs[1] != int64(len(expected)-1) {
+			t.Fatalf("original MULX bytes differ from actual Go encoding: %s: %x want %x; PCs=%v", rows[index], actual, expected, pcs)
+		}
+		x86NumericalVEXGPRequireMC(t, expected, mode, 2)
+	}
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	// Whole-source rejection must not hide a later absolute-address or other
+	// original row that accidentally acquired its own public source permission.
+	if len(file.Funcs) > 1 {
+		for _, function := range file.Funcs {
+			text, valid := x86RawReplaySourceText(function)
+			if !valid {
+				t.Fatal("original MULX function lost its source", function.Sym)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, text, "func "+function.Sym+"()", arch, triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("one original MULX format invented DX, register or address inputs", function.Sym, api, err)
+				}
+			}
+		}
+	}
+	file, err = normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("original MULX format bytes lost their complete decoder", err)
+	}
+	ir := x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			form, known, err := x86MULXProperties(instruction.Op, instruction, arch)
+			if !known || err != nil {
+				return known, false, err
+			}
+			return true, false, c.emitMULX(form, instruction)
+		})
+	if strings.Count(ir, "define void @InstructionFormat") != len(rows) {
+		t.Fatal("original MULX formats lost an externally visible emitter unit")
+	}
+	for index, row := range rows {
+		body := x86StringMemoryFunction(t, ir, fmt.Sprintf("InstructionFormat%d", index))
+		narrow, wide := "i32", "i64"
+		if strings.HasPrefix(row, "MULXQ ") {
+			narrow, wide = "i64", "i128"
+		}
+		// SIB address calculation may also multiply, but its scale is a
+		// constant, not two independently zero-extended numerical inputs.
+		products := regexp.MustCompile(`(?m)^[\t ]*%[^ \t=]+ = mul `+wide+` (%[^ \t,]+), (%[^ \t,]+)$`).FindAllStringSubmatch(body, -1)
+		if len(products) != 1 {
+			t.Fatal("original MULX format lost its one width-correct unsigned product", row, products)
+		}
+		for _, operand := range products[0][1:] {
+			// Missing private register slots may render as literal zero. That
+			// emitter representation is not a NUM fact: every original public
+			// source above still requires Context, with no input producers added.
+			extension := `(?m)^[\t ]*` + regexp.QuoteMeta(operand) + ` = zext ` + narrow + ` (%[^ \t]+|0) to ` + wide + `$`
+			if !regexp.MustCompile(extension).MatchString(body) {
+				t.Fatal("original MULX product lost an exact zero-extended source", row, operand)
+			}
+		}
+	}
+	return ir
+}
diff --git a/x86_mulx_source_boundaries_test.go b/x86_mulx_source_boundaries_test.go
new file mode 100644
index 000000000..f273410db
--- /dev/null
+++ b/x86_mulx_source_boundaries_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MULXPhysicalFrameOutputsNeedTheirOwnSourceRole(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			rows := []string{op + " AX,BX,DX"}
+			registers := []string{"SP"}
+			if arch == "amd64" {
+				registers = append(registers, "BP")
+			}
+			for _, register := range registers {
+				rows = append(rows, op+" AX,"+register+",DX", op+" AX,BX,"+register)
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nRET\n")
+			if len(pcs) != len(rows)+1 {
+				t.Fatal("actual Go omitted a write-only MULX output row", pcs)
+			}
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			x86NumericalVEXGPRequireMC(t, code, mode, len(pcs))
+			var prior strings.Builder
+			var sources []string
+			for index, row := range rows {
+				for _, raw := range []bool{false, true} {
+					instruction := row + "\n"
+					if raw {
+						instruction = x86RawDisplacementDirectives(code[pcs[index]:pcs[index+1]])
+					}
+					body := "TEXT Value(SB),4,$0-0\nMOVL $7,AX\nMOVL $3,DX\n" + instruction + "RET\n"
+					prior.WriteString(strings.Replace(body, "TEXT Value(SB)", fmt.Sprintf("TEXT Output%d(SB)", len(sources)), 1))
+					sources = append(sources, body)
+				}
+			}
+			// The Go object independently establishes source-format validity;
+			// neither that nor Yrl grants a physical SP/BP return contract.
+			x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String())
+			for index, source := range sources {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/row%d/raw=%t/%s", arch, op, index/2, index%2 == 1, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+						if index < 2 {
+							if err != nil || ir == "" {
+								t.Fatal("ordinary initialized BX/DX product lost its source role", err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("write-only Yrl output borrowed a physical stack/frame role", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86MULXRawContinuationRequiresCompleteOriginalProducer(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86MULXTestOps(arch) {
+			physical := x86MULXTestPhysical(t, arch, op)
+			prefix := "TEXT Value(SB),4,$0-4\nMOVL $7,AX\nMOVL $3,DX\n"
+			suffix := "MOVL CX,ret+0(FP)\nRET\n"
+			named := prefix + op + " AX,CX,DX\n" + suffix
+			source := prefix + physical[op+" AX,CX,DX"] + suffix
+			x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0],
+				strings.Replace(named, "TEXT Value(SB)", "TEXT Named(SB)", 1)+source)
+			strict, check := x86RegisterReplayConsumers(t, arch, named)
+			namedFunction := mustParseX86RawReturn(t, named).Funcs[0]
+			if strict(namedFunction) != nil || check(namedFunction) != nil {
+				t.Fatal("initialized named MULX was not an independent strict positive")
+			}
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+			if err != nil {
+				t.Fatal("original MULX decoding prerequisite", err)
+			}
+			original, ordinal := file.Funcs[0], -1
+			for index, ins := range original.Instrs {
+				if x86RawMULXSource(ins, arch) {
+					ordinal = index
+				}
+			}
+			if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+				t.Fatal("actual initialized MULX lost its complete original replay")
+			}
+			for _, mutation := range []string{
+				"none", "origin", "opcode", "operand", "source-operand", "vector", "address", "override", "segment",
+				"missing replay", "source spelling", "original bytes", "decoded snapshot", "producer",
+			} {
+				t.Run(arch+"/"+op+"/"+mutation, func(t *testing.T) {
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					switch mutation {
+					case "missing replay":
+						candidate.x86RawReplay = nil
+					case "source spelling":
+						candidate.Instrs[ordinal].Raw += " changed"
+					case "original bytes":
+						replay := *original.x86RawReplay
+						replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+						candidate.x86RawReplay = &replay
+					case "decoded snapshot":
+						replay := *original.x86RawReplay
+						replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+						replay.decoded[ordinal].x86SourceRaw = nil
+						candidate.x86RawReplay = &replay
+					case "producer":
+						candidate.Instrs[1].Args[0].Imm = 9
+					default:
+						candidate.Instrs[ordinal] = x86ShiftChoiceMutatedOrigin(candidate.Instrs[ordinal], mutation)
+					}
+					if mutation == "origin" {
+						// Removing origin makes the direct instruction look named;
+						// the whole-Func consumer must retain the sealed restriction.
+						if x86RawMULXSource(candidate.Instrs[ordinal], arch) || strict(candidate) != nil {
+							t.Fatal("origin-only control did not reach genuine strict numerical success")
+						}
+					}
+					err := check(candidate)
+					if mutation == "none" && err != nil || mutation != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("MULX continuation lost whole original producer identity", mutation, err)
+					}
+					if original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("candidate mutation changed the independent original replay")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_named_half_fault_tdd_test.go b/x86_named_half_fault_tdd_test.go
new file mode 100644
index 000000000..93128b3af
--- /dev/null
+++ b/x86_named_half_fault_tdd_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol2A Table2-40 (2-44): EVEX.z on a store raises #UD,
+// including the two named half conversions' E11 class (Vol2C 5-66).
+// This is distinct from Go rejecting SAE with a memory ModRM operand.
+func x86NamedHalfZeroStoreOriginalCodes(t *testing.T) [][]byte {
+	t.Helper()
+	var source strings.Builder
+	for _, bank := range []string{"X", "Y", "Z"} {
+		fmt.Fprintf(&source, "VCVTPS2PH $7,%s1,K1,(AX)\nVCVTPS2PH.Z $7,%s1,K1,(AX)\n", bank, bank)
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String()+"RET\n")
+	if len(pcs) != 7 {
+		t.Fatal("Go did not emit all normal and zero-store opcode boundaries", pcs)
+	}
+	var result [][]byte
+	for index := 0; index < 3; index++ {
+		normal := code[pcs[2*index]:pcs[2*index+1]]
+		zero := code[pcs[2*index+1]:pcs[2*index+2]]
+		if len(normal) != len(zero) || len(zero) < 7 || normal[0] != 0x62 || normal[3]&0x80 != 0 ||
+			zero[3]&0x80 == 0 || zero[3]>>5&3 != byte(index) || zero[5]>>6 == 3 || zero[len(zero)-1] != 7 {
+			t.Fatal("actual Go zero-store lacks its independent width/memory/EVEX.z/imm witness", normal, zero)
+		}
+		for at := range normal {
+			want := normal[at]
+			if at == 3 {
+				want |= 0x80
+			}
+			if zero[at] != want {
+				t.Fatal("Go .Z changed more than the independent EVEX.z bit", normal, zero)
+			}
+		}
+		result = append(result, append([]byte(nil), zero...))
+	}
+	return result
+}
+
+func TestX86NamedHalfZeroStoreOriginalGoAndLLVMEncodingPrior(t *testing.T) {
+	codes := x86NamedHalfZeroStoreOriginalCodes(t)
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("half zero-store physical prior requires LLVM22")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "i386-unknown-linux-gnu"} {
+		for index, code := range codes {
+			for _, zero := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/width%d/zero=%t", triple, index, zero), func(t *testing.T) {
+					var input strings.Builder
+					for at, value := range code {
+						if at == 3 && !zero {
+							value &^= 0x80
+						}
+						fmt.Fprintf(&input, "0x%02x ", value)
+					}
+					stage, cancel := runtimeOracleStageContext(t)
+					command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+						"--mattr=+f16c,+avx512f,+avx512vl")
+					command.Stdin = strings.NewReader(input.String())
+					output, err := runtimeOracleCombinedOutput(stage, command)
+					cancel()
+					invalid := strings.Contains(string(output), "invalid instruction encoding")
+					if err != nil || invalid != zero || !zero && !strings.Contains(string(output), "vcvtps2ph") {
+						t.Fatalf("independent normal/store #UD distinction differs: %v\n%s", err, output)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NamedHalfZeroStoreFaultBeforeInputsThreeAPIFiveTargetObjects(t *testing.T) {
+	codes := x86NamedHalfZeroStoreOriginalCodes(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("named half zero-store objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for index, bank := range []string{"X", "Y", "Z"} {
+				// Go386 rejects the named four-operand spelling. Exact original
+				// low-bank physical bytes remain valid format inputs in mode32.
+				if target.arch == "amd64" {
+					fmt.Fprintf(&source, "TEXT NamedFault%d(SB),4,$0-0\nVCVTPS2PH.Z $7,%s1,K1,(AX)\nRET\n", index, bank)
+					fmt.Fprintf(&declarations, "func NamedFault%d()\n", index)
+					names = append(names, fmt.Sprint("NamedFault", index))
+				}
+				fmt.Fprintf(&source, "TEXT PhysicalFault%d(SB),4,$0-0\n%sRET\n", index, x86RawDisplacementDirectives(codes[index]))
+				fmt.Fprintf(&declarations, "func PhysicalFault%d()\n", index)
+				names = append(names, fmt.Sprint("PhysicalFault", index))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("Go-accepted #UD required unknown data, mask, address or native entry before faulting", err)
+					}
+					for _, module := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						const trap = `call void asm sideeffect "ud2", "~{memory}"()`
+						if strings.Count(module, trap) != len(names) {
+							t.Fatal("half zero-store lost its complete original function inventory")
+						}
+						for _, name := range names {
+							// Unused module declarations are not executed stores.
+							// Inspect every original function, including raw #UD.
+							body := x86StringMemoryFunction(t, module, name)
+							if strings.Count(body, trap) != 1 || !strings.Contains(body, "\n  unreachable\n") ||
+								strings.Contains(body, "llvm.masked.store") || strings.Contains(body, "vcvtps2ph") ||
+								strings.Contains(body, " = load ") {
+								t.Fatal("half zero-store read inputs, performed a store or lost exact #UD", name, body)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "half-zero-store.ll", "half-zero-store.o", module)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NamedHalfZeroStoreFaultPrecedesFPBoundsAndMaskReads(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, immediate := range []int64{0, 7, 255} {
+			ins := x86ScalarLaneInstruction(t, fmt.Sprintf("VCVTPS2PH.Z $%d,%s1,K1,(AX)", immediate, bank))
+			ins.Args[3] = Operand{Kind: OpFP, FPOffset: 1 << 20}
+			context, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+			context.goarch = "amd64"
+			before := output.Len()
+			known, terminal, err := context.lowerPackedHalfConversion(ins.Op, ins)
+			if !known || !terminal || err != nil || output.String()[before:] !=
+				"  call void asm sideeffect \"ud2\", \"~{memory}\"()\n  unreachable\n" {
+				t.Fatal("half #UD evaluated nonexistent FP bounds or unknown vector/K data", bank, immediate, known, terminal, err)
+			}
+		}
+	}
+}
+
+func TestX86NamedHalfSAEMemoryHasActualGoRejectionNotStorePermission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, line := range []string{"VCVTPH2PS.SAE (AX),Z1", "VCVTPS2PH.SAE $0,Z1,(AX)"} {
+			t.Run(arch+"/"+line, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT SAE(SB),4,$0-0\n"+line+"\nRET\n", "", false)
+				ins := x86ScalarLaneInstruction(t, line)
+				context, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				context.goarch = arch
+				before := output.Len()
+				known, terminal, err := context.lowerPackedHalfConversion(ins.Op, ins)
+				if !known || terminal || err == nil || output.Len() != before {
+					t.Fatal("Go-invalid SAE memory emitted IR or acquired a native/mathematical input role", known, terminal, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_named_half_format_test.go b/x86_named_half_format_test.go
new file mode 100644
index 000000000..99c3d7aea
--- /dev/null
+++ b/x86_named_half_format_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Original formats retain actual Go objects and public Context independently
+// of initialized public programs. A visible single-row function prevents a
+// terminal architectural encoding from hiding any later backend format.
+func x86NamedHalfOriginalFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	file, _ := x86UnboundVoidFormatSources(t, source, arch, triple)
+	file, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("complete original half formats lost their physical decoding", err)
+	}
+	units := *file
+	units.Funcs = nil
+	signatures := make(map[string]FuncSig)
+	rows, contextual := 0, 0
+	for _, fn := range file.Funcs {
+		last := len(fn.Instrs) - 1
+		if last < 2 || fn.Instrs[0].Op != OpTEXT || fn.Instrs[last].Op != OpRET {
+			t.Fatal("original half formats lost their TEXT/RET envelope")
+		}
+		for _, ins := range fn.Instrs[1:last] {
+			_, known, err := x86NamedHalfProperties(ins.Op, ins, arch)
+			if !known {
+				t.Fatal("original half format acquired another instruction family", ins.Raw)
+			}
+			rows++
+			if err != nil {
+				if arch != "386" || !errors.Is(err, ErrProbeNeedsContext) ||
+					x86Mode32VectorRegisterContext(ins, arch) == nil {
+					t.Fatal("original half format lost a different grammar or source role", ins.Raw, err)
+				}
+				contextual++
+				continue
+			}
+			name := fmt.Sprint("HalfFormat", rows)
+			unit := fn
+			unit.Sym = name
+			unit.Instrs = []Instr{fn.Instrs[0], ins, fn.Instrs[last]}
+			units.Funcs = append(units.Funcs, unit)
+			signatures[name] = FuncSig{Name: name, Ret: Void}
+		}
+	}
+	ir := x86SingleInstructionFormatObjectUnits(t, &units, signatures, arch, triple,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			return c.lowerPackedHalfConversion(ins.Op, ins)
+		})
+	if rows == 0 || strings.Count(ir, "define void @InstructionFormat") != rows-contextual {
+		t.Fatal("an original half format lost its backend-visible unit", rows, contextual)
+	}
+	t.Logf("%d original half rows retain Go objects/public Context: %d physical mode32-bank Context, %d visible private format objects; no native execution claim",
+		rows, contextual, rows-contextual)
+	return ir
+}
diff --git a/x86_named_half_go127_test.go b/x86_named_half_go127_test.go
new file mode 100644
index 000000000..f33599edb
--- /dev/null
+++ b/x86_named_half_go127_test.go
@@ -0,0 +1,81 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86NamedHalfCompleteEighteenOfficialEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Full ordered rows, including zero advances and VEX signed/unsigned
+	// immediate overlap. An equal row count or shared ytab is not sufficient.
+	type row struct {
+		classes, zcase  string
+		offset, advance int
+	}
+	widen := []row{
+		{"Yxm,Yxr", "Zvex_rm_v_r", 0, 2},
+		{"Yxm,Yyr", "Zvex_rm_v_r", 2, 2},
+		{"YymEvex,Yzr", "Zevex_rm_v_r", 4, 0},
+		{"YymEvex,Yknot0,Yzr", "Zevex_rm_k_r", 4, 3},
+		{"YxmEvex,YxrEvex", "Zevex_rm_v_r", 7, 0},
+		{"YxmEvex,Yknot0,YxrEvex", "Zevex_rm_k_r", 7, 3},
+		{"YxmEvex,YyrEvex", "Zevex_rm_v_r", 10, 0},
+		{"YxmEvex,Yknot0,YyrEvex", "Zevex_rm_k_r", 10, 3},
+	}
+	narrow := []row{
+		{"Yu8,Yxr,Yxm", "Zvex_i_r_rm", 0, 0},
+		{"Yi8,Yxr,Yxm", "Zvex_i_r_rm", 0, 2},
+		{"Yu8,Yyr,Yxm", "Zvex_i_r_rm", 2, 0},
+		{"Yi8,Yyr,Yxm", "Zvex_i_r_rm", 2, 2},
+		{"Yu8,Yzr,YymEvex", "Zevex_i_r_rm", 4, 0},
+		{"Yu8,Yzr,Yknot0,YymEvex", "Zevex_i_r_k_rm", 4, 3},
+		{"Yu8,YxrEvex,YxmEvex", "Zevex_i_r_rm", 7, 0},
+		{"Yu8,YxrEvex,Yknot0,YxmEvex", "Zevex_i_r_k_rm", 7, 3},
+		{"Yu8,YyrEvex,YxmEvex", "Zevex_i_r_rm", 10, 0},
+		{"Yu8,YyrEvex,Yknot0,YxmEvex", "Zevex_i_r_k_rm", 10, 3},
+	}
+	count := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VCVTPH2PS" && rule.Opcode != "VCVTPS2PH" {
+			continue
+		}
+		expected, table, mapName, opcode := widen, "_yvcvtph2ps", "0F38", "0x13"
+		if rule.Opcode == "VCVTPS2PH" {
+			expected, table, mapName, opcode = narrow, "_yvcvtps2ph", "0F3A", "0x1D"
+		}
+		attributes := []string{
+			"avxEscape | vex128 | vex66 | vex" + mapName + " | vexW0", opcode,
+			"avxEscape | vex256 | vex66 | vex" + mapName + " | vexW0", opcode,
+			"avxEscape | evex512 | evex66 | evex" + mapName + " | evexW0",
+			"evexN32 | evexSaeEnabled | evexZeroingEnabled", opcode,
+			"avxEscape | evex128 | evex66 | evex" + mapName + " | evexW0",
+			"evexN8 | evexZeroingEnabled", opcode,
+			"avxEscape | evex256 | evex66 | evex" + mapName + " | evexW0",
+			"evexN16 | evexZeroingEnabled", opcode,
+		}
+		index := count[rule.Opcode]
+		if index >= len(expected) {
+			t.Fatal("unobserved named half encoder row", rule)
+		}
+		want := expected[index]
+		if rule.RowIndex != index || rule.Ytab != table || rule.Prefix != "Pavx" ||
+			rule.ZCase != want.zcase || rule.EncodingOffset != want.offset || rule.ZOffset != want.advance ||
+			strings.Join(rule.Classes, ",") != want.classes || !reflect.DeepEqual(rule.OpBytes, attributes) {
+			t.Fatal("complete named half grammar, generation, tuple, immediate or SAE/zero attributes differ", rule, want)
+		}
+		count[rule.Opcode]++
+	}
+	if !reflect.DeepEqual(count, map[string]int{"VCVTPH2PS": 8, "VCVTPS2PH": 10}) {
+		t.Fatal("complete eighteen-row named half table differs", count)
+	}
+}
diff --git a/x86_named_half_immediate_tdd_test.go b/x86_named_half_immediate_tdd_test.go
new file mode 100644
index 000000000..d7f825d87
--- /dev/null
+++ b/x86_named_half_immediate_tdd_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NamedHalfOriginalIntegerExpressionImmediates(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			cases := []struct {
+				expression string
+				control    int
+				width      int
+			}{
+				{"(1<<2)|3", 7, 16},
+				{"255&7", 7, 64},
+				{"-1+0", -1, 32},
+				{"~0&255", 255, 64},
+				{"(7-3)*2", 8, 16},
+			}
+			if arch == "386" {
+				cases = append(cases, struct {
+					expression string
+					control    int
+					width      int
+				}{"(1<<32)+4", 4, 16})
+			}
+			var source, declarations strings.Builder
+			for index, row := range cases {
+				name := fmt.Sprint("HalfImmediate", index)
+				shape := x86NamedHalfCase{narrow: true, width: row.width, immediate: row.control}
+				body, declaration := x86NamedHalfInitialized(name, arch, shape, false)
+				original := shape.instruction()
+				replacement := strings.Replace(original, fmt.Sprintf("$%d,", row.control), "$"+row.expression+",", 1)
+				if original == replacement || strings.Count(body, original) != 1 {
+					t.Fatal("integer-expression fixture lost its sole original instruction", original, replacement)
+				}
+				source.WriteString(strings.Replace(body, original, replacement, 1))
+				declarations.WriteString(declaration)
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			// The complete original Go program is the grammar prior, before any
+			// API observes its original expression or classified imm8 value.
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if err != nil {
+						t.Fatal("Go-valid half integer expression lost its original native control", err)
+					}
+					for index, row := range cases {
+						x86NamedHalfRequireOriginalControl(t, ir, fmt.Sprint("HalfImmediate", index), row.control)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_named_half_raw_tdd_test.go b/x86_named_half_raw_tdd_test.go
new file mode 100644
index 000000000..ae713ee9f
--- /dev/null
+++ b/x86_named_half_raw_tdd_test.go
@@ -0,0 +1,256 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+type x86NamedHalfRawCase struct {
+	row  x86NamedHalfCase
+	code []byte
+}
+
+// These four low-bank unmasked EVEX literals are independent physical
+// witnesses, not bytes attributed to the overlapping Go named VEX encoder.
+func x86NamedHalfLowEVEX() []x86NamedHalfRawCase {
+	return []x86NamedHalfRawCase{
+		{x86NamedHalfCase{width: 16}, []byte{0x62, 0xf2, 0x7d, 0x08, 0x13, 0xc1}},
+		{x86NamedHalfCase{width: 32}, []byte{0x62, 0xf2, 0x7d, 0x28, 0x13, 0xc1}},
+		{x86NamedHalfCase{narrow: true, width: 16}, []byte{0x62, 0xf3, 0x7d, 0x08, 0x1d, 0xc8, 0}},
+		{x86NamedHalfCase{narrow: true, width: 32}, []byte{0x62, 0xf3, 0x7d, 0x28, 0x1d, 0xc8, 0}},
+	}
+}
+
+func x86NamedHalfLowEVEXPrior(t *testing.T, arch string) {
+	t.Helper()
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("low-bank physical half generation requires LLVM22 llvm-mc")
+	}
+	var source, input strings.Builder
+	for _, row := range x86NamedHalfLowEVEX() {
+		source.WriteString(x86RawDisplacementDirectives(row.code))
+		for _, value := range row.code {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+	}
+	x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], "TEXT LowEVEX(SB),4,$0-0\n"+source.String()+"RET\n")
+	stage, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+x86AddressMemoryTargets(arch)[0],
+		"--mattr=+f16c,+avx512f,+avx512vl")
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	cancel()
+	if err != nil || strings.Contains(string(output), "invalid") || strings.Contains(string(output), "warning") ||
+		strings.Count(string(output), "vcvtph2ps") != 2 || strings.Count(string(output), "vcvtps2ph") != 2 {
+		t.Fatalf("independent low-bank EVEX half physical prior: %v\n%s", err, output)
+	}
+}
+
+func x86NamedHalfRawCases(t *testing.T, arch string) []x86NamedHalfRawCase {
+	t.Helper()
+	var rows []x86NamedHalfCase
+	var source strings.Builder
+	for _, row := range x86NamedHalfCases("amd64") {
+		if arch == "386" && row.high {
+			continue
+		}
+		rows = append(rows, row)
+		source.WriteString(row.instruction() + "\n")
+	}
+	// Capture in AMD64: genuine Go386 four-operand syntax rejection does not
+	// invalidate its independently decoded low-bank physical EVEX counterpart.
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String()+"RET\n")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("incomplete independent ordinary half physical directory")
+	}
+	var result []x86NamedHalfRawCase
+	for index, row := range rows {
+		result = append(result, x86NamedHalfRawCase{row, append([]byte(nil), code[pcs[index]:pcs[index+1]]...)})
+	}
+	x86NamedHalfLowEVEXPrior(t, arch)
+	return append(result, x86NamedHalfLowEVEX()...)
+}
+
+func x86NamedHalfRawInitialized(name, arch string, row x86NamedHalfRawCase) (string, string) {
+	source, declaration := x86NamedHalfInitialized(name, arch, row.row, false)
+	return strings.Replace(source, row.row.instruction()+"\n", x86RawDisplacementDirectives(row.code), 1), declaration
+}
+
+func TestX86NamedHalfRawLowBankPhysicalGenerationIsNotNamedInference(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		x86NamedHalfLowEVEXPrior(t, arch)
+		for _, row := range x86NamedHalfLowEVEX() {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row.row.instruction()+"\nRET\n")
+			for _, physical := range [][]byte{code[:pcs[1]], row.code} {
+				t.Run(fmt.Sprintf("%s/%s/EVEX=%t", arch, row.row.instruction(), physical[0] == 0x62), func(t *testing.T) {
+					ins := x86RawMoveObservedInstruction(t, arch, physical)
+					profile := "," + inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}) + ","
+					evex := physical[0] == 0x62
+					if ins.x86SourceRaw == nil || strings.Contains(profile, ",+avx512f,") != evex ||
+						strings.Contains(profile, ",+avx512vl,") != evex || !evex && !strings.Contains(profile, ",+f16c,") ||
+						strings.Contains(profile, "+avx512fp16") {
+						t.Fatal("ordinary half lost actual VEX/EVEX or borrowed raw-only FP16 generation", physical, profile)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NamedHalfRawInitializedFiveTargetNativeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("ordinary raw half original-native objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86NamedHalfRawCases(t, target.arch)
+			want := 59
+			if target.arch == "386" {
+				want = 51
+			}
+			if len(rows) != want {
+				t.Fatal("incomplete ordinary raw source/control/generation directory", len(rows), want)
+			}
+			var source, declarations strings.Builder
+			functions := make(map[string][]string)
+			for index, row := range rows {
+				name := fmt.Sprint("RawHalf", index)
+				body, declaration := x86NamedHalfRawInitialized(name, target.arch, row)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				functions[name] = []string{row.row.operation()}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized ordinary raw half source cannot compose with its actual producers", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, body, functions)
+						for index, row := range rows {
+							name := fmt.Sprint("RawHalf", index)
+							if row.row.narrow {
+								x86NamedHalfRequireOriginalControl(t, body, name, row.row.immediate)
+							}
+							_, function, found := strings.Cut(body, "define void @"+name+"(")
+							function, _, ended := strings.Cut(function, "\n}")
+							if !found || !ended || strings.Contains(function, "{evex} "+strings.ToLower(row.row.operation())) != (row.code[0] == 0x62) {
+								t.Fatal("raw half native opcode changed its actual physical generation", name, row.code)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "raw-named-half.ll", "raw-named-half.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NamedHalfRawWholeProducerImmutableReplay(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86NamedHalfRawCases(t, arch)
+		// Both ordinary members, physical generations and register/memory
+		// roles. Full format/byte/mask axes already have the object matrix.
+		for _, row := range rows {
+			if row.row.high || row.row.sae || row.row.mask == 2 || row.row.width != 16 || row.row.immediate != 0 {
+				continue
+			}
+			source, declaration := x86NamedHalfRawInitialized("Value", arch, row)
+			x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], source)
+			check := x86LegacyFloatReplayCheck(t, arch, source, declaration)
+			mutations := []string{"valid", "origin", "replay", "mode", "encoded", "width", "operand",
+				"producer", "spelling", "header", "bytes", "decoded-snapshot", "origin-operands"}
+			var alternate Instr
+			if !row.row.memory && row.row.mask == 0 {
+				other := x86NamedHalfLowEVEX()[0].code
+				if row.row.narrow {
+					other = x86NamedHalfLowEVEX()[2].code
+				}
+				if row.code[0] == 0x62 {
+					code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row.row.instruction()+"\nRET\n")
+					other = code[:pcs[1]]
+				}
+				alternate = x86RawMoveObservedInstruction(t, arch, other)
+				mutations = append(mutations, "generation", "generation-snapshot")
+			}
+			for _, mutation := range mutations {
+				t.Run(fmt.Sprintf("%s/%s/EVEX=%t/%s", arch, row.row.instruction(), row.code[0] == 0x62, mutation), func(t *testing.T) {
+					file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+					if err != nil || file.Funcs[0].x86RawReplay == nil {
+						t.Fatal("original ordinary raw half decode/replay prerequisite", err)
+					}
+					original, ordinal := file.Funcs[0], -1
+					for at, ins := range original.Instrs {
+						if ins.x86SourceRaw != nil && strings.Split(string(ins.Op), ".")[0] == row.row.operation() {
+							ordinal = at
+						}
+					}
+					if ordinal < 0 || original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("original half conversion lost its independently sealed source")
+					}
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					ins := &candidate.Instrs[ordinal]
+					switch mutation {
+					case "origin":
+						ins.x86SourceRaw = nil
+					case "replay":
+						candidate.x86RawReplay = nil
+					case "encoded":
+						ins.x86Encoded = !ins.x86Encoded
+					case "width":
+						ins.x86VectorBytes = 7
+					case "operand":
+						ins.Args[len(ins.Args)-1].Reg = "X7"
+					case "producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "spelling":
+						ins.Raw += " changed"
+					case "header":
+						candidate.ArgSize++
+					case "origin-operands":
+						ins.x86SourceRaw.args[0].Reg = "X7"
+					case "generation":
+						replacement := cloneX86ReplayInstrs([]Instr{alternate})[0]
+						replacement.x86SourceRaw = ins.x86SourceRaw
+						*ins = replacement
+					case "generation-snapshot":
+						ins.x86SourceRaw = cloneX86ReplayInstrs([]Instr{alternate})[0].x86SourceRaw
+					case "mode", "bytes", "decoded-snapshot":
+						replay := *original.x86RawReplay
+						if mutation == "mode" {
+							replay.goarch = "arm64"
+						}
+						if mutation == "bytes" {
+							replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+						}
+						if mutation == "decoded-snapshot" {
+							replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+							replay.decoded[ordinal].x86SourceRaw = nil
+						}
+						candidate.x86RawReplay = &replay
+					}
+					err = check(candidate)
+					if mutation == "valid" {
+						if err != nil {
+							t.Fatal("initialized complete ordinary raw half producer must succeed", err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited ordinary raw half/source acquired a paired native continuation", err)
+					}
+					if original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("mutation corrupted the original half replay")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_named_half_rounding_math_test.go b/x86_named_half_rounding_math_test.go
new file mode 100644
index 000000000..fe00ddc38
--- /dev/null
+++ b/x86_named_half_rounding_math_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86NamedHalfOriginalRoundingSourceSHA = "39f24aa8656393c426524904b1e91470673c5b136cca0219bdedeac28e5818f3"
+const x86NamedHalfOriginalRoundingCSHA = "0ad91576f61f4be44cfcbe362e2a49e7a7fc119942c8d513ae9d6e45b1851312"
+
+func x86NamedHalfCheckOriginalRoundingC(t *testing.T, source string) {
+	t.Helper()
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != x86NamedHalfOriginalRoundingCSHA {
+		t.Fatal("original directed-rounding C oracle or sample inventory changed")
+	}
+}
+
+// This private companion checks only the four fixed-rounding value functions.
+// It does not execute their original F16C instructions, observe MXCSR or
+// certify native exceptions. Dynamic imm8 controls 4..7 cannot acquire it.
+// The entire original initialized program is authenticated before changing
+// exactly its four conversion rows to the existing private FP16 math model.
+func x86NamedHalfRoundingMathematicalSource(source string) (string, error) {
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != x86NamedHalfOriginalRoundingSourceSHA {
+		return "", fmt.Errorf("different original source cannot acquire the fixed-rounding mathematical companion")
+	}
+	for rounding := 0; rounding < 4; rounding++ {
+		original := fmt.Sprintf("VCVTPS2PH $%d, Z1, Y0\n", rounding)
+		if strings.Count(source, original) != 1 {
+			return "", fmt.Errorf("original fixed-rounding row is not unique: %d", rounding)
+		}
+		physical := rawFP16Conversion(true, rounding, 0, 0, 1, false, true, false)
+		source = strings.Replace(source, original, x86RawDisplacementDirectives(physical), 1)
+	}
+	return source, nil
+}
+
+func x86NamedHalfRoundingOriginalObjects(t *testing.T, source, llc string) {
+	t.Helper()
+	const triple = "x86_64-unknown-linux-gnu"
+	x86LEAActualTargetGoObject(t, "amd64", triple, source)
+	var declarations strings.Builder
+	for index := 0; index < 4; index++ {
+		fmt.Fprintf(&declarations, "func halfRound%d(input,out *[64]byte)\n", index)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api)
+		if err != nil {
+			t.Fatal("complete original initialized directed-rounding source stopped translating", api, err)
+		}
+		for index := 0; index < 4; index++ {
+			x86NamedHalfRequireOriginalControl(t, ir, fmt.Sprint("halfRound", index), index)
+		}
+		compileLLVMToObject(t, llc, triple, "original-half-rounding.ll", "original-half-rounding.o", ir)
+	}
+	// Objects above are the original program; execution below is explicitly
+	// the separately authenticated private mathematical companion only.
+	t.Log("original directed-rounding Go/three-API native objects retained; runtime is private fixed-rounding mathematics, not original F16C or MXCSR execution")
+}
+
+func TestX86NamedHalfPrivateRoundingCompanionRetainsOriginalBoundaries(t *testing.T) {
+	var source strings.Builder
+	for index := 0; index < 4; index++ {
+		fmt.Fprintf(&source, "TEXT halfRound%d(SB),4,$0-16\nMOVQ input+0(FP), AX\nMOVQ out+8(FP), SI\nVMOVDQU64 (AX), Z1\nVCVTPS2PH $%d, Z1, Y0\nVMOVDQU64 Z0, (SI)\nRET\n", index, index)
+	}
+	original := source.String()
+	companion, err := x86NamedHalfRoundingMathematicalSource(original)
+	if err != nil || strings.Contains(companion, "VCVTPS2PH $") {
+		t.Fatal("original four fixed-rounding rows lost their private companion", err)
+	}
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, companion), "amd64")
+	if err != nil || len(file.Funcs) != 4 {
+		t.Fatal("private mathematical bytes lost their independent FP16 model", err)
+	}
+	for index, fn := range file.Funcs {
+		conversions := 0
+		for _, ins := range fn.Instrs {
+			if !strings.HasPrefix(string(ins.Op), "VCVTPS2PHX.") {
+				continue
+			}
+			want := "VCVTPS2PHX." + []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}[index]
+			if string(ins.Op) != want || !ins.x86Encoded || len(ins.Args) != 2 ||
+				ins.Args[0].Reg != "Z1" || ins.Args[1].Reg != "Y0" {
+				t.Fatal("private companion changed fixed rounding, source, destination or width", ins)
+			}
+			conversions++
+		}
+		if conversions != 1 {
+			t.Fatal("private mathematical companion lost its sole exact conversion", index, conversions)
+		}
+	}
+	for name, changed := range map[string]string{
+		"source":      strings.Replace(original, "(AX), Z1", "(BX), Z1", 1),
+		"input":       strings.Replace(original, "MOVQ input+0(FP), AX\n", "", 1),
+		"destination": strings.Replace(original, "Z1, Y0", "Z1, Y2", 1),
+		"dynamic":     strings.Replace(original, "VCVTPS2PH $0", "VCVTPS2PH $4", 1),
+		"header":      strings.Replace(original, "$0-16", "$0-24", 1),
+		"store":       strings.Replace(original, "VMOVDQU64 Z0, (SI)", "VMOVDQU64 Z2, (SI)", 1),
+		"missing":     "TEXT absent(SB),4,$0-0\nVCVTPS2PH $0,Z1,Y0\nRET\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if changed == original {
+				t.Fatal("private companion negative did not mutate its original source")
+			}
+			if result, err := x86NamedHalfRoundingMathematicalSource(changed); err == nil || result != "" {
+				t.Fatal("another producer acquired private fixed-rounding mathematics", result, err)
+			}
+		})
+	}
+}
diff --git a/x86_named_half_tdd_test.go b/x86_named_half_tdd_test.go
new file mode 100644
index 000000000..a57559fc2
--- /dev/null
+++ b/x86_named_half_tdd_test.go
@@ -0,0 +1,503 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Independent of the production FP16 maps. These are Go's two named F16C /
+// AVX512F conversions, not the six raw-only AVX512-FP16 conversion members.
+type x86NamedHalfCase struct {
+	narrow, memory, high   bool
+	width, mask, immediate int
+	sae                    bool
+}
+
+func x86NamedHalfCases(arch string) []x86NamedHalfCase {
+	var rows []x86NamedHalfCase
+	for _, narrow := range []bool{false, true} {
+		for _, width := range []int{16, 32, 64} {
+			for _, memory := range []bool{false, true} {
+				rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory})
+				if !narrow || arch == "amd64" {
+					rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory, mask: 1})
+					if !narrow || !memory {
+						rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory, mask: 2})
+					}
+				}
+				if width < 64 && arch == "amd64" {
+					rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory, high: true})
+				}
+				if width == 64 && !memory {
+					rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory, sae: true})
+					if !narrow || arch == "amd64" {
+						rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, memory: memory, sae: true, mask: 1})
+						if !memory {
+							rows = append(rows, x86NamedHalfCase{narrow: narrow, width: width, sae: true, mask: 2})
+						}
+					}
+				}
+				if narrow && width < 64 {
+					rows = append(rows, x86NamedHalfCase{narrow: true, width: width, memory: memory, immediate: -1})
+				}
+			}
+		}
+	}
+	// Bit 2 selects MXCSR.RC; bits 1:0 must not select fixed rounding then.
+	for control := 4; control < 8; control++ {
+		rows = append(rows, x86NamedHalfCase{narrow: true, width: 16, immediate: control})
+	}
+	return rows
+}
+
+func (row x86NamedHalfCase) registers() (source, destination int) {
+	if row.high {
+		return 16, 17
+	}
+	return 1, 0
+}
+
+func (row x86NamedHalfCase) operation() string {
+	if row.narrow {
+		return "VCVTPS2PH"
+	}
+	return "VCVTPH2PS"
+}
+
+func (row x86NamedHalfCase) instruction() string {
+	source, destination := row.registers()
+	wide, short := map[int]string{16: "X", 32: "Y", 64: "Z"}[row.width], "X"
+	if row.width == 64 {
+		short = "Y"
+	}
+	op := row.operation()
+	if row.sae {
+		op += ".SAE"
+	}
+	if row.mask == 2 {
+		op += ".Z"
+	}
+	mask := ""
+	if row.mask != 0 {
+		mask = ",K1"
+	}
+	if row.narrow {
+		out := fmt.Sprintf("%s%d", short, destination)
+		if row.memory {
+			out = "80(DI)"
+		}
+		return fmt.Sprintf("%s $%d,%s%d%s,%s", op, row.immediate, wide, source, mask, out)
+	}
+	in := fmt.Sprintf("%s%d", short, source)
+	if row.memory {
+		in = "(AX)"
+	}
+	return fmt.Sprintf("%s %s%s,%s%d", op, in, mask, wide, destination)
+}
+
+func x86NamedHalfGoPrior(t *testing.T, arch string, rows []x86NamedHalfCase) {
+	t.Helper()
+	var source strings.Builder
+	for _, row := range rows {
+		source.WriteString(row.instruction() + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, arch, source.String()+"RET\n")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("actual Go omitted a complete named half conversion boundary", arch, len(pcs), len(rows))
+	}
+	var input strings.Builder
+	for index, row := range rows {
+		instruction := code[pcs[index]:pcs[index+1]]
+		evex := row.width == 64 || row.mask != 0 || row.high || row.sae
+		if len(instruction) < 4 || (instruction[0] == 0x62) != evex {
+			t.Fatal("independent Go generation differs from named shape", row.instruction(), instruction)
+		}
+		for _, value := range instruction {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+	}
+	// LLVM's independent decoder observes the actual complete Go bytes, not
+	// a copy of our decoder's generated opcode or vector-length metadata.
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("named half physical prior requires LLVM22 llvm-mc")
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	stage, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+		"--mattr=+f16c,+avx512f,+avx512vl")
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	cancel()
+	if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+		t.Fatalf("independent named half physical prior: %v\n%s", err, output)
+	}
+	count := strings.Count(string(output), "vcvtph2ps") + strings.Count(string(output), "vcvtps2ph")
+	if count != len(rows) {
+		t.Fatal("LLVM did not independently decode every original Go conversion", arch, count, len(rows), string(output))
+	}
+}
+
+func TestX86NamedHalfOriginalGoAndLLVMPhysicalPriors(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows, want := x86NamedHalfCases(arch), 55
+			if arch == "386" {
+				want = 36
+			}
+			if len(rows) != want {
+				t.Fatal("independent named half control/source/generation inventory changed", arch, len(rows), want)
+			}
+			x86NamedHalfGoPrior(t, arch, rows)
+		})
+	}
+}
+
+func x86NamedHalfInitialized(name, arch string, row x86NamedHalfCase, dead bool) (string, string) {
+	word, move, push, pop := goWordSize(arch), "MOVQ", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		move, push, pop = "MOVL", "PUSHFL", "POPL"
+	}
+	source, destination := row.registers()
+	header := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),AX\n"+
+		"%s old+%d(FP),BX\n%s environment+%d(FP),SI\nMOVL mask+%d(FP),CX\nKMOVW CX,K1\n",
+		name, 4*word+4, move, move, word, move, 2*word, move, 3*word, 4*word)
+	if row.narrow || !row.memory {
+		header += fmt.Sprintf("VMOVUPS (AX),Z%d\n", source)
+	}
+	header += fmt.Sprintf("VMOVUPS (BX),Z%d\nLDMXCSR (SI)\nMOVL $3,DX\nCMPL DX,$1\nSTD\n", destination)
+	tail := ""
+	if !dead {
+		tail = fmt.Sprintf("VMOVUPS Z%d,(DI)\n", destination)
+	}
+	return header + row.instruction() + "\n" + tail + push + "\n" + pop + " DX\n" +
+			"ANDL $0xcd5,DX\nMOVL DX,64(DI)\nSTMXCSR 68(DI)\nCLD\nRET\n",
+		fmt.Sprintf("func %s(out *[128]byte,input,old *[64]byte,environment *uint32,mask uint32)\n", name)
+}
+
+func x86NamedHalfRequireOriginalControl(t *testing.T, ir, name string, control int) {
+	t.Helper()
+	_, body, found := strings.Cut(ir, "define void @"+name+"(")
+	body, _, ended := strings.Cut(body, "\n}")
+	if !found || !ended {
+		t.Fatal("missing actual named half function", name)
+	}
+	count := 0
+	for _, line := range strings.Split(body, "\n") {
+		if !x86ScalarPrecisionNativeEffectLine(line, "VCVTPS2PH") {
+			continue
+		}
+		match := regexp.MustCompile(`\bvcvtps2ph \$\$(-?[0-9]+),`).FindStringSubmatch(line)
+		if match == nil {
+			t.Fatal("actual native half call lost its original immediate", name, line)
+		}
+		immediate, err := strconv.ParseInt(match[1], 10, 16)
+		if err != nil || immediate < -128 || immediate > 255 || byte(immediate) != byte(control) {
+			t.Fatal("native half changed its immediate/MXCSR.RC selection", name, control, match[1], err)
+		}
+		count++
+	}
+	if count != 1 {
+		t.Fatal("actual half function lost its sole original conversion", name, count)
+	}
+}
+
+func TestX86NamedHalfCompleteInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete initialized named half objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86NamedHalfCases(target.arch)
+			x86NamedHalfGoPrior(t, target.arch, rows)
+			var source, declarations strings.Builder
+			functions := make(map[string][]string)
+			for index, row := range rows {
+				name := fmt.Sprint("NamedHalf", index)
+				body, declaration := x86NamedHalfInitialized(name, target.arch, row, false)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				functions[name] = []string{row.operation()}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized original named half family remains unclosed", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, body, functions)
+						for index, row := range rows {
+							if row.narrow {
+								x86NamedHalfRequireOriginalControl(t, body, fmt.Sprint("NamedHalf", index), row.immediate)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "named-half.ll", "named-half.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NamedHalfCompleteTypedInputsOutputsAndFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86NamedHalfCases(arch)
+		x86NamedHalfGoPrior(t, arch, rows)
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("named half conversion lost its complete typed inputs, result or flag preservation", effect, known, err)
+				}
+				reads, writes := make(map[int]bool), make(map[int]bool)
+				source, last := 0, len(ins.Args)-1
+				if row.narrow {
+					source = 1
+				}
+				for _, operand := range effect.operands {
+					if operand.index < 0 || operand.index > last || !reflect.DeepEqual(operand.operand, ins.Args[operand.index]) {
+						t.Fatal("named half effect borrowed an unrelated operand", operand, ins)
+					}
+					reads[operand.index] = reads[operand.index] || operand.read
+					writes[operand.index] = writes[operand.index] || operand.write
+				}
+				for index := range ins.Args {
+					wantRead := index == source || row.mask != 0 && index == last-1 ||
+						row.mask == 1 && index == last && !row.narrow ||
+						row.mask == 1 && index == last && row.narrow && !row.memory
+					if reads[index] != wantRead || writes[index] != (index == last) {
+						t.Fatal("named half effect lost source, K, actual merging register or write role", index, reads, writes)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NamedHalfMinimumISAIsNotSuppliedByUnrelatedProducers(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86NamedHalfCases(arch) {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				profile := "," + inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}) + ","
+				evex := row.width == 64 || row.mask != 0 || row.high || row.sae
+				required := []string{"+avx", "+f16c"}
+				if evex {
+					required = []string{"+avx512f"}
+					if row.width < 64 {
+						required = append(required, "+avx512vl")
+					}
+				}
+				for _, feature := range required {
+					if !strings.Contains(profile, ","+feature+",") {
+						t.Fatal("isolated named half lost its actual generation/ISA carrier", row.instruction(), feature, profile)
+					}
+				}
+				for _, feature := range []string{"+avx512fp16", "+avx512bw", "+avx512dq"} {
+					if strings.Contains(profile, ","+feature+",") {
+						t.Fatal("named half borrowed a different conversion family's ISA", feature, profile)
+					}
+				}
+				if !evex && strings.Contains(profile, "+avx512") {
+					t.Fatal("ordinary F16C input unnecessarily requires AVX512", profile)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NamedHalfEveryActiveByteMergeMaskAndUpperAlias(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86NamedHalfCases(arch)
+		x86NamedHalfGoPrior(t, arch, rows)
+		for _, row := range rows {
+			if row.memory {
+				continue
+			}
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				for _, alias := range []bool{false, true} {
+					ins := x86ScalarLaneInstruction(t, row.instruction())
+					source, destination := row.registers()
+					input, output, carrier := row.width/2, row.width, row.width
+					if row.narrow {
+						input, output, carrier = row.width, row.width/2, 16
+						if row.width == 64 {
+							carrier = 32
+						}
+					}
+					if alias {
+						source = destination
+						index := 0
+						if row.narrow {
+							index = 1
+						}
+						ins.Args[index].Reg = Reg(fmt.Sprint(string(ins.Args[index].Reg)[0:1], source))
+					}
+					for _, missingRegister := range []int{source, destination} {
+						for missing := -1; missing < 64; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+								masks: [8]bool{1: true}}
+							state.pointerGP[3], state.callerAddressGP[6] = true, true
+							state.writeVector(source, 64, ^uint64(0), true)
+							state.writeVector(destination, 64, ^uint64(0), true)
+							if missing >= 0 {
+								state.writeVector(missingRegister, 64, ^(uint64(1) << uint(missing)), true)
+							}
+							before, want := state.clone(), state.clone()
+							valid := state.vectorBytes(source)&x86CallerVectorByteMask(int64(input)) == x86CallerVectorByteMask(int64(input)) &&
+								(row.mask != 1 || state.vectorBytes(destination)&x86CallerVectorByteMask(int64(output)) == x86CallerVectorByteMask(int64(output)))
+							if valid {
+								want.writeVector(destination, carrier, ^uint64(0), false)
+							}
+							accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+							if accepted != valid || !reflect.DeepEqual(state, want) {
+								t.Fatal("named half active input/merge bytes or physical upper-zeroing differ", alias, missingRegister, missing, accepted, valid, before, state, want)
+							}
+						}
+					}
+					if row.mask != 0 {
+						state := x86ResultState{}
+						state.writeVector(source, 64, ^uint64(0), true)
+						state.writeVector(destination, 64, ^uint64(0), true)
+						before := state.clone()
+						if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+							t.Fatal("named half invented an unknown K mask")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NamedHalfMissingInputsRemainContextIncludingVoid(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86NamedHalfCases(arch)
+		x86NamedHalfGoPrior(t, arch, rows)
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				source := "TEXT Value(SB),4,$0-0\n" + row.instruction() + "\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()\n", arch, x86AddressMemoryTargets(arch)[0], api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unknown named half data/address/merge/mask borrowed Void permission", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NamedHalfMode32NamedGrammarAndHighBankRemainIndependent(t *testing.T) {
+	var high []x86NamedHalfCase
+	for _, row := range x86NamedHalfCases("amd64") {
+		if row.high {
+			high = append(high, row)
+		}
+	}
+	var original strings.Builder
+	for _, row := range high {
+		original.WriteString(row.instruction() + "\n")
+	}
+	// The Go frontend accepts these high named rows in 386 mode. That is
+	// not a physical register binding and must not grant numerical facts.
+	x86LEAActualTargetGoObject(t, "386", "i386-unknown-linux-gnu",
+		"TEXT High(SB),4,$0-0\n"+original.String()+"RET\n")
+	for index, row := range high {
+		t.Run(row.instruction(), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction())
+			if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("high Go386 frontend spelling acquired a physical typed form", known, err)
+			}
+			source, declaration := x86NamedHalfInitialized(fmt.Sprint("High", index), "386", row, false)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("named high-bank source borrowed mode32 physical inputs", api, err)
+				}
+			}
+		})
+	}
+	for _, row := range x86NamedHalfCases("amd64") {
+		if !row.narrow || row.mask == 0 {
+			continue
+		}
+		t.Run("four-operands/"+row.instruction(), func(t *testing.T) {
+			source := "TEXT Four(SB),4,$0-0\n" + row.instruction() + "\nRET\n"
+			requireLEANativeGoObject(t, "amd64", source, true)
+			requireLEANativeGoObject(t, "386", source, false)
+			ins := x86ScalarLaneInstruction(t, row.instruction())
+			if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !known || err == nil {
+				t.Fatal("named Go386 four-operand grammar borrowed a physical masked row", known, err)
+			}
+		})
+	}
+}
+
+func TestX86NamedHalfDynamicMXCSRAndDeadEffectsKeepActualOpcode(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("dynamic MXCSR half conversion objects require LLVM22")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := x86AddressMemoryTargets(arch)[0]
+		var source, declarations strings.Builder
+		functions := make(map[string][]string)
+		controls := make(map[string]int)
+		for _, width := range []int{16, 32, 64} {
+			for control := 4; control < 8; control++ {
+				for _, dead := range []bool{false, true} {
+					name := fmt.Sprintf("Dynamic%d_%d_%t", width, control, dead)
+					body, declaration := x86NamedHalfInitialized(name, arch,
+						x86NamedHalfCase{narrow: true, width: width, immediate: control}, dead)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+					functions[name] = []string{"VCVTPS2PH"}
+					controls[name] = control
+				}
+			}
+			for mask := 0; mask < 3; mask++ {
+				name := fmt.Sprintf("DeadRead%d_%d", width, mask)
+				body, declaration := x86NamedHalfInitialized(name, arch,
+					x86NamedHalfCase{width: width, memory: true, mask: mask}, true)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				functions[name] = []string{"VCVTPH2PS"}
+			}
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if err != nil {
+					t.Fatal("initialized dynamic MXCSR or dead conversion remains unclosed", err)
+				}
+				for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					x86ScalarPrecisionRequireNativeEffects(t, body, functions)
+					for name, control := range controls {
+						x86NamedHalfRequireOriginalControl(t, body, name, control)
+					}
+					if strings.Contains(body, "fptrunc ") {
+						t.Fatal("MXCSR.RC controls 4-7 were replaced by fixed LLVM rounding")
+					}
+					compileLLVMToObject(t, llc, triple, "half-dynamic-mxcsr.ll", "half-dynamic-mxcsr.o", body)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_named_segment_memory.go b/x86_named_segment_memory.go
new file mode 100644
index 000000000..8e8b3b6e6
--- /dev/null
+++ b/x86_named_segment_memory.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import "fmt"
+
+// Project only named x86 memory syntax, not a pointer or initialized-byte
+// witness. In Go's encoder an FS/GS Index is a segment annotation: prefixof
+// selects it and asmandsz ignores its Scale. A segment used as Base cannot
+// accompany a real scaled GP Index. Keep the original instruction untouched;
+// each paired consumer uses this same normalized operand for proof/emission.
+func x86NamedSegmentMemorySource(ins Instr, source Operand, arch string) (Operand, bool, error) {
+	if source.Kind != OpMem || !x86ResultNamedPredicateInstruction(ins) {
+		// The physical decoder already supplies normalized segment fields.
+		// It must not be reclassified as named Go syntax or borrow a named
+		// instruction's separate input/source proof.
+		return source, false, nil
+	}
+	memory := source.Mem
+	annotation := memory.Index == FS || memory.Index == GS
+	if memory.Segment == "" && !annotation {
+		return source, false, nil
+	}
+	fail := func() (Operand, bool, error) {
+		return source, true, fmt.Errorf("%w: invalid %s named segment memory: %q", ErrProbeNeedsContext, arch, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" ||
+		ins.x86NumericalRead != nil || memory.Sym != "" || memory.OffRaw != "" || memory.IndexExt != "" {
+		return fail()
+	}
+	if annotation {
+		if memory.Segment != "" || (memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8) {
+			return fail()
+		}
+		memory.Segment, memory.Index, memory.Scale = memory.Index, "", 0
+	}
+	if memory.Segment != FS && memory.Segment != GS || memory.Index != "" || memory.Scale != 0 {
+		return fail()
+	}
+	projected := source
+	projected.Mem = memory
+	if !x86PackedShiftMemoryValid(projected, arch) {
+		return fail()
+	}
+	return projected, true, nil
+}
+
+// This is a mandatory source/result-proof selector, not an admission rule.
+// Even a malformed segment form or physical SP/BP address must reach the
+// complete check rather than disappear behind a MOV-store cost heuristic.
+// Void functions also owe the actual numerical address inputs of dead reads.
+func x86NamedSegmentMOVNeedsProof(ins Instr, arch string) bool {
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg {
+		return false
+	}
+	canonical := x86SourceMoveInstruction(ins, arch)
+	width := x86RawReturnScalarMoveBytes(canonical.Op)
+	if width == 0 {
+		return false
+	}
+	register := ins.Args[1].Reg
+	validRegister := isX86YrlRegisterForArch(register, arch)
+	if width == 1 {
+		validRegister = isGoYmbRegisterForArch(register, arch)
+	}
+	if !validRegister {
+		return false // MMX, SIMD and system-register rows retain their own roles.
+	}
+	_, segment, _ := x86NamedSegmentMemorySource(ins, ins.Args[0], arch)
+	return segment
+}
diff --git a/x86_native_address_bits_store_test.go b/x86_native_address_bits_store_test.go
new file mode 100644
index 000000000..f40386f94
--- /dev/null
+++ b/x86_native_address_bits_store_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86NativeAddressBitsStoreSource(arch, operation string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·CopyBits(SB),4,$0-%d\n%s dst+0(FP),DI\n%s src+%d(FP),SI\n%s SI,1(DI)\nMOVL $7,ret+%d(FP)\nRET\n",
+		2*word+4, move, move, word, operation, 2*word)
+	return source, "func CopyBits(dst,src *byte) uint32"
+}
+
+// Observe a complete native word's actual entry-address bits, not numerical
+// GP initialization, pointee validity, a pointer result or GC/escape safety.
+func TestX86NativeAddressBitsStoreFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		operations := []string{"MOVQ", "MOVD", "MOVDQ2Q"}
+		if target.arch == "386" {
+			operations = []string{"MOVL"}
+		}
+		for _, operation := range operations {
+			t.Run(target.triple+"/"+operation, func(t *testing.T) {
+				source, declaration := x86NativeAddressBitsStoreSource(target.arch, operation)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("closed leaf cannot copy its actual full-word address bits", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeAddressBitsStorePortableValueAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arch, move := "amd64", "MOVQ"
+	if strconv.IntSize == 32 {
+		arch, move = "386", "MOVL"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	source, declaration := x86NativeAddressBitsStoreSource(arch, move)
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint32_t CopyBits(uint8_t*,const uint8_t*);
+int main(void) {
+    const uint8_t input[4]={17,23,31,47};
+    const uint8_t *values[]={input,input+3,NULL};
+    for (unsigned index=0;index<sizeof(values)/sizeof(values[0]);++index) {
+        uint8_t output[sizeof(uintptr_t)+2];
+        memset(output,0xa5,sizeof(output));
+        if (CopyBits(output,values[index])!=7) return 1;
+        uintptr_t observed;
+        memcpy(&observed,output+1,sizeof(observed));
+        if (observed!=(uintptr_t)values[index] || output[0]!=0xa5 || output[sizeof(output)-1]!=0xa5 ||
+            input[0]!=17 || input[1]!=23 || input[2]!=31 || input[3]!=47) {
+            fprintf(stderr,"opaque address-bit copy mismatch row=%u\n",index);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "opaque-address-bit-copy", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86NativeAddressBitsStoreVoidCannotHideUnknownInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, unusedBool := range []bool{false, true} {
+			declaration, extent := "func CopyBits(dst,src *byte)", 2*word
+			if unusedBool {
+				declaration, extent = "func CopyBits(dst,src *byte,unused bool)", 2*word+1
+			}
+			body := fmt.Sprintf("%s dst+0(FP),DI\n%s src+%d(FP),SI\n%s SI,1(DI)\nRET\n", move, move, word, move)
+			for _, row := range []struct{ name, body string }{
+				{"unknown-source", strings.Replace(body, fmt.Sprintf("%s src+%d(FP),SI\n", move, word), "", 1)},
+				{"unknown-destination", strings.Replace(body, move+" dst+0(FP),DI\n", "", 1)},
+				{"partial-source", strings.Replace(body, move+" SI,1(DI)", "MOVW $0,SI\n"+move+" SI,1(DI)", 1)},
+			} {
+				source := fmt.Sprintf("TEXT ·CopyBits(SB),4,$0-%d\n%s", extent, row.body)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/unused-bool=%t/%s", target.triple, row.name, unusedBool, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or an unused bool supplied missing native store input facts", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86NativeAddressBitsStoreCannotCreateOrWidenFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move := "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range []struct {
+			name, instruction string
+			scope, want       bool
+			change            func(*x86ResultState)
+		}{
+			{"whole-word", move + " SI,1(DI)", true, true, nil},
+			{"unbound-scope", move + " SI,1(DI)", false, false, nil},
+			{"unknown-bits", move + " SI,1(DI)", true, false, func(s *x86ResultState) { s.callerAddressGP[6] = false }},
+			{"pointer-only", move + " SI,1(DI)", true, false, func(s *x86ResultState) {
+				s.callerAddressGP[6], s.pointerGP[6] = false, true
+			}},
+			{"unknown-destination", move + " SI,1(DI)", true, false, func(s *x86ResultState) { s.pointerGP[7] = false }},
+			{"unknown-index", move + " SI,1(DI)(BX*2)", true, false, nil},
+			{"narrow-byte", "MOVB SI,1(DI)", true, false, nil},
+			{"narrow-word", "MOVW SI,1(DI)", true, false, nil},
+			{"physical-frame", move + " SP,1(DI)", true, false, func(s *x86ResultState) { s.callerAddressGP[4] = true }},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagCF, direction: x86ResultDirectionBackward}
+				state.pointerGP[7], state.callerAddressGP[6], state.callerAddressOrigin[6] = true, true, 1
+				if row.change != nil {
+					row.change(&state)
+				}
+				before := state.clone()
+				ins := x86ScalarLaneInstruction(t, row.instruction)
+				accepted, _ := x86LoweredScalarNativeStoreWithAddressBits(ins, &state, nil, arch, row.scope)
+				if accepted != row.want || !reflect.DeepEqual(state, before) {
+					t.Fatal("address-bit observation invented NUM, pointer, canonical or FLAGS facts", accepted, row.want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeAddressBitsStoreScopeCannotBorrowOtherEntries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, _ := x86NativeAddressBitsStoreSource(arch, map[string]string{"386": "MOVL", "amd64": "MOVQ"}[arch])
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := file.Funcs[0]
+		sig := FuncSig{Args: []LLVMType{Ptr}, Ret: I32,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}
+		if !x86LeafNativeAddressBitStoreScope(original, sig, arch) {
+			t.Fatal("ordinary typed leaf lost its scope", arch)
+		}
+		for _, row := range []struct {
+			name   string
+			change func(*Func, *FuncSig)
+		}{
+			{"frame", func(fn *Func, _ *FuncSig) { fn.FrameSize = 16 }},
+			{"register-entry", func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" }},
+			{"call", func(fn *Func, _ *FuncSig) { fn.Instrs = append(fn.Instrs, Instr{Op: OpCALL}) }},
+			{"encoded", func(fn *Func, _ *FuncSig) { fn.Instrs[0].x86Encoded = true }},
+			{"numeric-parameter", func(_ *Func, sig *FuncSig) { sig.Args = []LLVMType{I64} }},
+			{"no-typed-entry", func(_ *Func, sig *FuncSig) { sig.Frame.Params = nil }},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				fn, changedSig := original, sig
+				fn.Instrs = append([]Instr(nil), original.Instrs...)
+				row.change(&fn, &changedSig)
+				if x86LeafNativeAddressBitStoreScope(fn, changedSig, arch) {
+					t.Fatal("another entry/storage role acquired a leaf bit-copy scope")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_native_family_owner_oracle_go127_test.go b/x86_native_family_owner_oracle_go127_test.go
new file mode 100644
index 000000000..821f672fb
--- /dev/null
+++ b/x86_native_family_owner_oracle_go127_test.go
@@ -0,0 +1,149 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86NativeFamilyOwnerOracle struct {
+	literal   *x86SDKLiteralCertificate
+	numerical *x86NumericalReadCertificate
+}
+
+// Share actual SDK factory products, not a mock namespace or a fabricated
+// certificate. Every caller retains the complete source/type/object capture,
+// both independent owners, their actual valid API controls and live cleanup.
+func x86CaptureNativeFamilyOwnerOracle(t *testing.T) x86NativeFamilyOwnerOracle {
+	t.Helper()
+	source, err := numericalSDKMapsReadCapture(t, "linux/amd64", "memhash_amd64.s")
+	if err != nil {
+		t.Fatal("actual complete SDK owner/source precondition", err)
+	}
+	ctx := source.sdk.originalContext
+	minimum, err := CaptureGoX86SDKLiteralAlignment(ctx, source.literals.owner)
+	if err != nil {
+		t.Fatal("actual independent SDK literal alignment precondition", err)
+	}
+	t.Cleanup(func() { minimum.Close() })
+	pkg, original, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+	bound, err := source.BindNumericalReadsWithLiteralAlignment(ctx, pkg, original, options, minimum)
+	if err != nil {
+		t.Fatal("complete unchanged SDK numerical/literal binding", err)
+	}
+	frozen, _, err := freezeNumericalReadInputs(original, bound)
+	if err != nil {
+		t.Fatal("complete SDK source/declaration/certificate identity", err)
+	}
+	var owners x86NativeFamilyOwnerOracle
+	var literalOriginal, numericalOriginal Instr
+	for _, function := range frozen.Funcs {
+		for _, instruction := range function.Instrs {
+			if instruction.x86SDKLiteral != nil && owners.literal == nil {
+				if _, valid := certifiedSDKLiteralAccess(instruction, "amd64"); !valid {
+					t.Fatal("actual original SDK literal certificate was not valid before use")
+				}
+				owners.literal, literalOriginal = instruction.x86SDKLiteral, instruction
+			}
+			if instruction.x86NumericalRead != nil && owners.numerical == nil {
+				if _, _, valid := numericalCertifiedRead(instruction, "amd64"); !valid {
+					t.Fatal("actual original mutable SDK read certificate was not valid before use")
+				}
+				owners.numerical, numericalOriginal = instruction.x86NumericalRead, instruction
+			}
+		}
+	}
+	if owners.literal == nil || owners.numerical == nil {
+		t.Fatal("actual complete SDK source lost either independent owner class")
+	}
+	for _, api := range []string{"text", "module", "go-module"} {
+		t.Run("actual-original-SDK/"+api, func(t *testing.T) {
+			if ir := numericalFamilyTranslate(t, api, pkg, original, bound); ir == "" {
+				t.Fatal("actual original whole-SDK valid certificate control emitted no module")
+			}
+		})
+	}
+	t.Cleanup(func() {
+		if _, valid := certifiedSDKLiteralAccess(literalOriginal, "amd64"); !valid {
+			t.Error("foreign-source negative revoked or mutated the independent original literal owner")
+		}
+		if _, _, valid := numericalCertifiedRead(numericalOriginal, "amd64"); !valid {
+			t.Error("foreign-source negative revoked or mutated the independent original numerical owner")
+		}
+	})
+	return owners
+}
+
+func (owners x86NativeFamilyOwnerOracle) checkProgram(t *testing.T, text, declaration, target string) {
+	t.Helper()
+	goAssemblerOracleOutput(t, "amd64", text, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("baseline/"+api, func(t *testing.T) {
+			if _, err := x86ScalarFPBitViewAPI(t, text, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Fatal("complete legitimate source baseline was relabeled or rejected", err)
+			}
+		})
+	}
+	program, err := Parse(ArchAMD64, text)
+	if err != nil {
+		t.Fatal(err)
+	}
+	programPackage := mustGoPackage(t, "ownercontrol", "package ownercontrol\n"+declaration)
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	signatures, err := goSigsForAsmFile(programPackage, program, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	program, err = normalizeX86RawFile(program, "amd64")
+	if err != nil {
+		t.Fatal("complete original raw source identity was not retained", err)
+	}
+	function := program.Funcs[0]
+	expected := x86ScalarLaneInstruction(t, target)
+	ordinal := -1
+	for index, instruction := range function.Instrs {
+		if instruction.Op == expected.Op && reflect.DeepEqual(instruction.Args, expected.Args) {
+			if ordinal != -1 {
+				t.Fatal("ambiguous complete original native-family consumer")
+			}
+			ordinal = index
+		}
+	}
+	if ordinal == -1 {
+		t.Fatal("complete original native-family instruction was not retained", target)
+	}
+	consumer := func(function Func) *amd64Ctx {
+		return newX86Ctx(new(strings.Builder), function, signatures["Value"], resolve, signatures,
+			"amd64", "x86_64-unknown-linux-gnu", false)
+	}
+	if err := consumer(function).checkLoweredScalarFPResultInitialization(); err != nil {
+		t.Fatal("complete unmodified private source control failed before ownership mutation", err)
+	}
+	for _, owner := range []string{"SDKLiteral", "NumericalRead"} {
+		t.Run(owner+"/original-certificate-on-foreign-source", func(t *testing.T) {
+			changed := function
+			changed.Instrs = append([]Instr(nil), function.Instrs...)
+			instruction := &changed.Instrs[ordinal]
+			if owner == "SDKLiteral" {
+				instruction.x86SDKLiteral = owners.literal
+				if _, valid := certifiedSDKLiteralAccess(*instruction, "amd64"); valid {
+					t.Fatal("actual original SDK certificate was forged into a foreign source")
+				}
+			} else {
+				instruction.x86NumericalRead = owners.numerical
+				if _, _, valid := numericalCertifiedRead(*instruction, "amd64"); valid {
+					t.Fatal("actual original mutable-read certificate was forged into a foreign source")
+				}
+			}
+			if err := consumer(changed).checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("family native continuation bypassed the existing owner's invalid complete identity", owner, err)
+			}
+			if !reflect.DeepEqual(program.Funcs[0], function) {
+				t.Fatal("negative changed the complete original source control")
+			}
+		})
+	}
+}
diff --git a/x86_native_gp_store_test.go b/x86_native_gp_store_test.go
new file mode 100644
index 000000000..c2db68214
--- /dev/null
+++ b/x86_native_gp_store_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86NativeGPStoreCompleteWidthsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range []struct {
+			op, register string
+			width        int
+		}{{"MOVB", "AL", 1}, {"MOVW", "AX", 2}, {"MOVL", "AX", 4}, {"MOVQ", "AX", 8}, {"MOVD", "AX", 8}, {"MOVDQ2Q", "AX", 8}} {
+			if row.width > word {
+				continue // Go386 has no ordinary qword GP-to-memory row.
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\n%s value+%d(FP),AX\n%s %s,8(DI)\nMOVL $7,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+				word*2+4, move, move, word, row.op, row.register, word*2)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,value uintptr) uint32", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete numerical GP store lost its paired continuation", err)
+					}
+					if strings.Count(ir, fmt.Sprintf("store volatile i%d ", row.width*8)) != 1 {
+						t.Fatal("the paired emitter did not retain exactly one full native store")
+					}
+					pkg := mustGoPackage(t, "store", "package store\nfunc Value(p *byte,value uintptr) uint32")
+					file := mustParseX86RawReturn(t, source)
+					sigs, err := goSigsForAsmFile(pkg, file, func(name string) string { return strings.TrimPrefix(name, "·") }, target.arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sigs["Value"], target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("a declaration-only query acquired native write authority", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NativeGPStoreOriginalByteAliasesAndUnchangedState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, instruction := range []string{"MOVL AX,(DX)(FS*1)", "MOVL AX,8(GS)", "MOVL AX,table(SB)", "MOVL AX,result+0(FP)", "MOVL AX,local-4(SP)", "MOVL X0,(DX)"} {
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if _, known, _ := x86ScalarNativeStoreProperties(ins.Op, ins, arch); known {
+				t.Fatal("ordinary GP store consumed a separate segment/static/frame/SIMD row", arch, instruction)
+			}
+		}
+	}
+	for ordinal, register := range []string{"AH", "CH", "DH", "BH"} {
+		for _, address := range []string{"(DX)", "(R8)", "(DX)(R9*2)"} {
+			instruction := "MOVB " + register + "," + address
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+instruction+"\nRET\n")
+			want := []byte{0x88, byte(0x22 + ordinal*8), 0xc3}
+			if address == "(R8)" {
+				want = []byte{0x41, 0x88, byte(0x20 + ordinal*8), 0xc3}
+			} else if address == "(DX)(R9*2)" {
+				want = []byte{0x42, 0x88, byte(0x24 + ordinal*8), 0x4a, 0xc3}
+			}
+			if !reflect.DeepEqual(code, want) {
+				t.Fatalf("original Go store byte role changed: %s = %x, want %x", instruction, code, want)
+			}
+			ins := x86ScalarLaneInstruction(t, instruction)
+			form, known, err := x86ScalarNativeStoreProperties(ins.Op, ins, "amd64")
+			effective := Reg(register)
+			if address != "(DX)" {
+				effective = []Reg{SP, BP, SI, DI}[ordinal]
+			}
+			if !known || err != nil || form.source.Kind != OpReg || form.source.Reg != effective || form.bytes != 1 {
+				t.Fatal("typed store disagrees with actual ModRM/REX", form, err)
+			}
+			if address != "(DX)" && ordinal < 2 {
+				context, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Name: "store", Ret: Void}, nil)
+				before := output.String()
+				if err := context.lowerScalarNativeStore(form, ins); !errors.Is(err, ErrProbeNeedsContext) || output.String() != before {
+					t.Fatal("unbound physical SP/BP read emitted a store", err)
+				}
+			}
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		move := "MOVL"
+		if arch == "amd64" {
+			move = "MOVQ"
+		}
+		ins := x86ScalarLaneInstruction(t, move+" AX,-1(DX)(BX*2)")
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+		state.gp[0], state.gp[3], state.pointerGP[2] = 0xff, 0xff, true
+		before := state.clone()
+		if accepted, known := x86LoweredScalarNativeStore(ins, &state, nil, arch); !accepted || !known || !reflect.DeepEqual(state, before) {
+			t.Fatal("native store manufactured or revoked a state fact", arch, state)
+		}
+		for _, mutation := range []string{"physical", "address", "unknown-index", "commuted-pointer", "pointer-data"} {
+			changed, next := ins, before.clone()
+			switch mutation {
+			case "physical":
+				changed.x86Encoded = true
+			case "address":
+				changed.x86AddressBits = 16
+			case "unknown-index":
+				next.gp[3] = 0
+			case "commuted-pointer":
+				next.pointerGP[2], next.gp[2], next.pointerGP[3], next.gp[3] = false, 0xff, true, 0
+			case "pointer-data":
+				next.gp[0], next.pointerGP[0] = 0, true
+			}
+			unchanged := next.clone()
+			if accepted, _ := x86LoweredScalarNativeStore(changed, &next, nil, arch); accepted || !reflect.DeepEqual(next, unchanged) {
+				t.Fatal("native store acquired a foreign permission or changed rejected state", arch, mutation)
+			}
+		}
+	}
+}
+
+func TestX86NativeGPStoreCannotBorrowUnknownOrPointerData(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		body := fmt.Sprintf("%s p+0(FP),DI\n%s value+%d(FP),AX\n%s AX,(DI)\nMOVL $7,ret+%d(FP)\nRET\n", move, move, word, move, word*2)
+		for _, mutation := range []struct {
+			name, body string
+			frame      int
+		}{
+			{"unknown-address", strings.Replace(body, move+" p+0(FP),DI\n", "", 1), 0},
+			{"numerical-address", strings.Replace(body, move+" p+0(FP),DI", fmt.Sprintf("%s value+%d(FP),DI", move, word), 1), 0},
+			{"unknown-data", strings.Replace(body, fmt.Sprintf("%s value+%d(FP),AX\n", move, word), "", 1), 0},
+			{"pointer-data-foreign-frame", strings.Replace(body, fmt.Sprintf("%s value+%d(FP),AX", move, word), move+" p+0(FP),AX", 1), 16},
+			{"partial-data", strings.Replace(body, fmt.Sprintf("%s value+%d(FP),AX", move, word), fmt.Sprintf("MOVB value+%d(FP),AL", word), 1), 0},
+			{"raw-return", strings.Replace(body, "RET", "BYTE $0xc3\nRET", 1), 0},
+		} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$%d-%d\n%s", mutation.frame, word*2+4, mutation.body)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+mutation.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,value uintptr) uint32", target.arch, target.triple, api)
+					if mutation.name == "numerical-address" {
+						if err != nil || !strings.Contains(ir, fmt.Sprintf("store volatile i%d ", word*8)) {
+							t.Fatal("NUM address lost its original scalar write width", err)
+						}
+						x86RequireNumericNativeSourceContext(t, source, "func Value(p *byte,value uintptr) uint32", target.arch)
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("unproved native write data/address/source was admitted", err)
+					}
+				})
+			}
+		}
+		// Preserve the former pointer-data fixture verbatim as an explicit
+		// positive for the independently proved closed-leaf bit-copy scope.
+		pointerBody := strings.Replace(body, fmt.Sprintf("%s value+%d(FP),AX", move, word), move+" p+0(FP),AX", 1)
+		source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word*2+4, pointerBody)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/closed-leaf-pointer-bits/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,value uintptr) uint32", target.arch, target.triple, api); err != nil || ir == "" {
+					t.Fatal("actual complete entry-address bits need no numerical-byte permission", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_native_immediate_store_test.go b/x86_native_immediate_store_test.go
new file mode 100644
index 000000000..333f36ef3
--- /dev/null
+++ b/x86_native_immediate_store_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86NativeImmediateStoreVoidInputsCannotBorrowPrivateSlots(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		valid := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\n%s $3,BX\nMOVL $7,-1(DI)(BX*2)\nRET\n", word, move, move)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, valid, "func Value(p *byte)", target.arch, target.triple, api)
+			if err != nil || strings.Count(ir, "store volatile i32 ") != 1 {
+				t.Fatal("complete Void pointer/index control rejected", api, err)
+			}
+		}
+		for _, row := range []struct {
+			name, setup, address string
+		}{
+			{"unknown-base", "", "(DI)"},
+			{"numeric-base", move + " $64,DI\n", "(DI)"},
+			{"partial-base", "MOVB $1,DI\n", "(DI)"},
+			{"unknown-index", move + " p+0(FP),DI\n", "(DI)(BX*2)"},
+			{"pointer-index", move + " p+0(FP),DI\n" + move + " p+0(FP),BX\n", "(DI)(BX*2)"},
+		} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOVL $7,%s\nRET\n", word, row.setup, row.address)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", target.arch, target.triple, api)
+					if row.name == "numeric-base" {
+						if err != nil || strings.Count(ir, "store volatile i32 7,") != 1 || !strings.Contains(ir, "align 1") {
+							t.Fatal("defined address lost its exact unaligned immediate store", err)
+						}
+						x86RequireNumericNativeSourceContext(t, source, "func Value(p *byte)", target.arch)
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("Void native write acquired an unproved base/index", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NativeImmediateStoreRejectsOutsideGoEncodingClasses(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		instructions := []string{"MOVB $0.0,(DI)", "MOVW $0.0,(DI)", "MOVL $0.0,(DI)", "MOVQ $0.0,(DI)"}
+		if target.arch == "amd64" {
+			for _, op := range []string{"MOVB", "MOVW", "MOVL", "MOVQ", "MOVD", "MOVDQ2Q"} {
+				for _, value := range []string{"-2147483649", "4294967296", "0x0123456789abcdef"} {
+					instructions = append(instructions, op+" $"+value+",(DI)")
+				}
+			}
+		} else {
+			instructions = append(instructions, "MOVQ $1,(DI)", "MOVD $1,(DI)", "MOVDQ2Q $1,(DI)")
+		}
+		for _, instruction := range instructions {
+			t.Run(target.triple+"/"+instruction, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+				requireX86GoAssemblerResult(t, target.arch, source, false)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api); err == nil || errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("native store accepted a non-Go immediate/mode row", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+// Independent witnesses for all four Go Yi32-to-memory rows, including the
+// frontend's two MOVQ aliases. The qword row sign-extends its encoded imm32.
+func x86NativeImmediateStoreFixture(arch string) (string, string, string, int) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations, prototypes, checks strings.Builder
+	count := 0
+	for _, row := range []struct {
+		op    string
+		bytes int
+	}{{"MOVB", 1}, {"MOVW", 2}, {"MOVL", 4}, {"MOVQ", 8}, {"MOVD", 8}, {"MOVDQ2Q", 8}} {
+		if row.bytes > word {
+			continue
+		}
+		values := []int64{-2147483648, -129, -1, 0, 127, 128, 255, 65535, 2147483647, 2147483648, 4294967295}
+		if arch == "386" {
+			values = append(values, -2147483649, 4294967296, 9223372036854775807)
+		}
+		for _, value := range values {
+			name := fmt.Sprintf("ImmediateStore%d", count)
+			count++
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DI\n%s $3,BX\n%s $%d,-1(DI)(BX*2)\nMOVL $7,ret+%d(FP)\nRET\n",
+				name, word+4, move, move, row.op, value, word)
+			fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+			fmt.Fprintf(&prototypes, "extern uint32_t %s(uint8_t*);\n", name)
+			// Reference uses the encoded value, not any lowering helper.
+			encoded := uint64(value)
+			if row.bytes == 8 {
+				encoded = uint64(int64(int32(value)))
+			}
+			fmt.Fprintf(&checks, "memset(actual,0xa7,sizeof(actual));memcpy(expected,actual,sizeof(actual));\n"+
+				"for(unsigned i=0;i<%d;i++)expected[5+i]=(UINT64_C(%d)>>(8*i))&255;\n"+
+				"if(%s(actual)!=7||memcmp(actual,expected,sizeof(actual)))return %d;\n",
+				row.bytes, encoded, name, count)
+		}
+	}
+	driver := "#include <stdint.h>\n#include <string.h>\n" + prototypes.String() +
+		"int main(void){uint8_t actual[32],expected[32];\n" + checks.String() + "return 0;}\n"
+	return source.String(), declarations.String(), driver, count
+}
+
+func TestX86NativeImmediateStoreCompleteGoRowsAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _, count := x86NativeImmediateStoreFixture(target.arch)
+			want := 66
+			if target.arch == "386" {
+				want = 42
+			}
+			if count != want {
+				t.Fatal("complete immediate-store denominator changed", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original immediate-store source rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "store volatile i") != count {
+							t.Fatal("an immediate native write lost its exact volatile effect")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NativeImmediateStorePortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch := "amd64"
+	if runtime.GOARCH == "386" {
+		arch = "386"
+	}
+	source, declarations, driver, _ := x86NativeImmediateStoreFixture(arch)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "native-immediate-store", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_native_lea_address_bits_test.go b/x86_native_lea_address_bits_test.go
new file mode 100644
index 000000000..a371d0ff8
--- /dev/null
+++ b/x86_native_lea_address_bits_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86NativeLEAAddressBitsProgram(arch string) (string, string) {
+	word, move, old := 8, "MOVQ", "0x1122334455667788"
+	if arch == "386" {
+		word, move, old = 4, "MOVL", "0x55667788"
+	}
+	var operations string
+	for index, width := range []string{"W", "L", map[string]string{"amd64": "Q", "386": "L"}[arch]} {
+		operations += fmt.Sprintf("%s $%s,AX\nLEA%s -7(SI)(DX*8),AX\n%s AX,%d(DI)\n", move, old, width, move, index*word)
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n%s base+%d(FP),SI\n"+
+		"MOVL index+%d(FP),DX\nMOVL $0x7fffffff,R8\nADDL $1,R8\nSTC\n%s"+
+		"SETCS %d(DI)\nSETOS %d(DI)\nSETEQ %d(DI)\nSETMI %d(DI)\nRET\n",
+		2*word+4, move, move, word, 2*word, operations, 3*word, 3*word+1, 3*word+2, 3*word+3)
+	if arch == "386" {
+		// The scratch is an ordinary physical GP in both source modes.
+		source = strings.ReplaceAll(source, "R8", "BX")
+	}
+	return source, "func Value(out *[40]byte,base *byte,index uint32)\n"
+}
+
+func TestX86NativeLEAAddressBitsCompleteWidthsAndTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("native LEA address-bit objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		source, declaration := x86NativeLEAAddressBitsProgram(target.arch)
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized original LEA address observations rejected", err)
+				}
+				for _, pipeline := range []struct{ input, level string }{
+					{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+				} {
+					x86PackedStringCompileObject(t, llc, target.triple, pipeline.input, pipeline.level)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeLEAAddressBitsPortableValuesAndStatus(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	const driver = `#include <stdint.h>
+#include <string.h>
+extern void Value(uint8_t *,const uint8_t *,uint32_t);
+int main(void) {
+    uint8_t storage[8]={0};
+    const uintptr_t bases[]={(uintptr_t)storage,0,UINTPTR_MAX-3,UINT32_MAX-3};
+    const uint32_t indexes[]={0,1,UINT32_MAX};
+    for (unsigned b=0;b<4;b++) for (unsigned i=0;i<3;i++) {
+        uint8_t out[40]; memset(out,0xa5,sizeof(out));
+        Value(out,(const uint8_t*)bases[b],indexes[i]);
+        uintptr_t address=bases[b]+(uintptr_t)indexes[i]*8-7;
+        uintptr_t actual[3]; memcpy(actual,out,sizeof(actual));
+        uintptr_t old=sizeof(uintptr_t)==8 ? UINT64_C(0x1122334455667788) : UINT32_C(0x55667788);
+        uintptr_t want16=(old&~(uintptr_t)0xffff)|(address&0xffff);
+        if (actual[0]!=want16 || actual[1]!=(uint32_t)address || actual[2]!=address) return 1;
+        unsigned flags=3*sizeof(uintptr_t);
+        if (out[flags]!=1 || out[flags+1]!=1 || out[flags+2]!=0 || out[flags+3]!=1) return 2;
+        for (unsigned j=flags+4;j<sizeof(out);j++) if (out[j]!=0xa5) return 3;
+    }
+    return 0;
+}
+`
+	source, declaration := x86NativeLEAAddressBitsProgram("amd64")
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete native-address LEA program rejected before portable value execution", err)
+			}
+			for _, pipeline := range []struct {
+				input string
+				level int
+			}{
+				{ir, 0}, {ir, 2}, {x86DwordProductIROptimize(t, ir), 2},
+			} {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "lea-address-bits", triple, pipeline.input, driver, nil, pipeline.level)
+			}
+		})
+	}
+}
+
+func TestX86NativeLEAAddressBitsDoNotInventNumericalOrPointerFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := int64(8), "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, width := range x86NumericalLEAWidths(arch) {
+			t.Run(arch+"/"+width, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, "LEA"+width+" -7(SI)(DX*8),AX")
+				initial := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				initial.gp[0], initial.gp[2] = 0xff, 0xff
+				initial.pointerGP[6], initial.callerAddressGP[6] = true, true
+				initial.pointerGP[7], initial.callerAddressGP[7] = true, true
+				if x86LEAWidth(instruction.Op, arch) >= word {
+					state := initial.clone()
+					accepted, known := x86ResultNativeLEAAddressBitsStep(instruction, &state, nil, arch, true)
+					if accepted || known || !reflect.DeepEqual(state, initial) {
+						t.Fatal("narrow observation intercepted the existing complete pointer consumer")
+					}
+					return
+				}
+				for _, control := range []string{"complete", "no-leaf", "unknown-base", "unknown-index"} {
+					state := initial.clone()
+					if control == "unknown-base" {
+						state.pointerGP[6], state.callerAddressGP[6] = false, false
+					}
+					if control == "unknown-index" {
+						state.gp[2] = 0
+					}
+					before := state.clone()
+					accepted, known := x86ResultNativeLEAAddressBitsStep(instruction, &state, nil, arch, control != "no-leaf")
+					if !known || accepted != (control == "complete") {
+						t.Fatal("native address observation invented a missing source or leaf scope", control, accepted, known)
+					}
+					if !accepted {
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("rejected address observation partially mutated state", control)
+						}
+						continue
+					}
+					if x86ResultRead(Operand{Kind: OpReg, Reg: AX}, word, &state, nil, arch) ||
+						state.pointerGP[0] || state.callerAddressGP[0] || state.flags != before.flags || state.direction != before.direction {
+						t.Fatal("LEA address bits became numerical, pointer or status permissions")
+					}
+					store := x86ScalarLaneInstruction(t, move+" AX,(DI)")
+					for _, leaf := range []bool{false, true} {
+						copy := state.clone()
+						accepted, known := x86LoweredScalarNativeStoreWithAddressBits(store, &copy, nil, arch, leaf)
+						if !known || accepted != leaf || !reflect.DeepEqual(copy, state) {
+							t.Fatal("exact observation supplied a new byte or escaped its native leaf scope", leaf)
+						}
+					}
+					empty := state.clone()
+					empty.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+					if merged := state.intersect(empty); merged.nativeLEAAddressBits.bytes != 0 {
+						t.Fatal("join retained a missing address observation")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeLEAAddressBitsCannotSurviveAConflictingWrite(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		source, declaration := x86NativeLEAAddressBitsProgram(arch)
+		for _, change := range []struct {
+			instruction string
+			complete    bool
+		}{{"MOVB $0,AL", false}, {"MOVW $0,AX", true}, {"MOVB 1(SI),AL", false}} {
+			modified := strings.Replace(source, move+" AX,0(DI)", change.instruction+"\n"+move+" AX,0(DI)", 1)
+			if modified == source {
+				t.Fatal("address observation control did not modify its original producer")
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, modified)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+change.instruction+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, modified, declaration, arch, triple, api)
+					if change.complete {
+						if err != nil || ir == "" {
+							t.Fatal("independent complete numerical overwrite lost its own bytes", err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("an intervening partial write reused stale address-derived bytes", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NativeLEANarrowObserverDoesNotStealFullPointerContinuation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, lea, triple := 8, "MOVQ", "LEAQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, lea, triple = 4, "MOVL", "LEAL", "i386-unknown-linux-gnu"
+		}
+		source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),SI\n"+
+			"MOVL $3,DX\n%s 1(SI)(DX*2),BX\nMOVB (BX),AX\nMOVB AX,(DI)\nRET\n", 2*word, move, move, word, lea)
+		x86LEAActualTargetGoObject(t, arch, triple, source)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(out,input *byte)\n", arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("narrow address observation stole the existing complete pointer continuation", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_native_leaw_logical_df_test.go b/x86_native_leaw_logical_df_test.go
new file mode 100644
index 000000000..b43a69d89
--- /dev/null
+++ b/x86_native_leaw_logical_df_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const (
+	x86NativeLEAWSTDCall = `call void asm sideeffect "std", "~{dirflag}"()`
+	x86NativeLEAWCLDCall = `call void asm sideeffect "cld", "~{dirflag}"()`
+)
+
+// This fixture-only observer is not a source proof or an IR interpreter.
+// Native DF side effects and the logical DF slot are independent outputs of
+// the existing lowerer. Check their complete straight-line lifecycle before
+// isolating the former for the non-x86 companion; never project DF out of the
+// original source, packed FLAGS observation or independent C expectation.
+func x86NativeLEAWCheckLogicalDFBody(body string) error {
+	return x86NativeLEAWCheckTargetDFBody(body, true)
+}
+
+func x86NativeLEAWCheckTargetDFBody(body string, native bool) error {
+	initial := "store i1 false, ptr %direction_backward"
+	backward := "store i1 true, ptr %direction_backward"
+	load := "load i1, ptr %direction_backward"
+	nativeCount := 0
+	if native {
+		nativeCount = 1
+	}
+	for text, count := range map[string]int{
+		"%direction_backward = alloca i1": 1,
+		initial:                           2,
+		backward:                          1,
+		load:                              1,
+		x86NativeLEAWSTDCall:              nativeCount,
+		x86NativeLEAWCLDCall:              nativeCount,
+		"asm sideeffect":                  2 * nativeCount,
+	} {
+		if actual := strings.Count(body, text); actual != count {
+			return fmt.Errorf("DF observation %q count=%d, want %d", text, actual, count)
+		}
+	}
+	previous := -1
+	markers := []string{initial, backward}
+	if native {
+		markers = append(markers, x86NativeLEAWSTDCall)
+	}
+	for _, marker := range append(markers, load) {
+		position := strings.Index(body, marker)
+		if position <= previous {
+			return fmt.Errorf("DF initial/STD/packed observation reordered at %q", marker)
+		}
+		previous = position
+	}
+	clear := strings.LastIndex(body, initial)
+	if clear <= previous || native && strings.Index(body, x86NativeLEAWCLDCall) <= clear {
+		return fmt.Errorf("DF clear is not after its packed observation")
+	}
+	return nil
+}
+
+func x86NativeLEAWRetainedPointerLogicalDF(t *testing.T, ir string, isolateNative bool) string {
+	t.Helper()
+	for _, variant := range []string{"Direct", "Copied", "Alias"} {
+		body := x86StringMemoryFunction(t, ir, "Retain"+variant)
+		if err := x86NativeLEAWCheckLogicalDFBody(body); err != nil {
+			t.Fatal("complete retained-pointer logical/native DF lifecycle changed", variant, err)
+		}
+	}
+	if strings.Count(ir, x86NativeLEAWSTDCall) != 3 || strings.Count(ir, x86NativeLEAWCLDCall) != 3 ||
+		strings.Count(ir, "asm sideeffect") != 6 {
+		t.Fatal("module contains missing, extra or unclassified native direction calls")
+	}
+	if !isolateNative {
+		return ir
+	}
+	// Keep every logical store/load and all numerical/output effects intact.
+	// Required native execution retains the six original sideeffect calls.
+	for call, marker := range map[string]string{
+		x86NativeLEAWSTDCall: "; logical DF companion: native STD isolated",
+		x86NativeLEAWCLDCall: "; logical DF companion: native CLD isolated",
+	} {
+		ir = strings.ReplaceAll(ir, call, marker)
+	}
+	return ir
+}
+
+func TestX86NativeLEAWRetainedPointerLogicalDFInstrumentationIsExact(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations := x86NativeLEAWRetainedPointerBatch(arch, "")
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, x86AddressMemoryTargets(arch)[0], api)
+				if err != nil {
+					t.Fatal("original initialized DF program rejected before driver observation", err)
+				}
+				if native := x86NativeLEAWRetainedPointerLogicalDF(t, ir, false); native != ir {
+					t.Fatal("native driver changed the original LLVM program")
+				}
+				companion := x86NativeLEAWRetainedPointerLogicalDF(t, ir, true)
+				restored := strings.NewReplacer(
+					"; logical DF companion: native STD isolated", x86NativeLEAWSTDCall,
+					"; logical DF companion: native CLD isolated", x86NativeLEAWCLDCall,
+				).Replace(companion)
+				if companion == ir || strings.Contains(companion, "asm sideeffect") || restored != ir {
+					t.Fatal("portable driver did not isolate exactly the checked native calls")
+				}
+				for _, variant := range []string{"Direct", "Copied", "Alias"} {
+					body := x86StringMemoryFunction(t, ir, "Retain"+variant)
+					clear := "store i1 false, ptr %direction_backward"
+					position := strings.LastIndex(body, clear)
+					reordered := body[:position] + strings.Replace(body[position:], clear, "", 1)
+					reordered = strings.Replace(reordered, "load i1, ptr %direction_backward", clear+"\nload i1, ptr %direction_backward", 1)
+					for name, changed := range map[string]string{
+						"backward missing":  strings.Replace(body, "store i1 true, ptr %direction_backward", "", 1),
+						"backward foreign":  strings.Replace(body, "store i1 true, ptr %direction_backward", "store i1 true, ptr %foreign", 1),
+						"packed missing":    strings.Replace(body, "load i1, ptr %direction_backward", "load i1, ptr %foreign", 1),
+						"clear missing":     strings.Replace(body, "store i1 false, ptr %direction_backward", "", 1),
+						"STD missing":       strings.Replace(body, x86NativeLEAWSTDCall, "", 1),
+						"CLD missing":       strings.Replace(body, x86NativeLEAWCLDCall, "", 1),
+						"native reordered":  strings.NewReplacer(x86NativeLEAWSTDCall, x86NativeLEAWCLDCall, x86NativeLEAWCLDCall, x86NativeLEAWSTDCall).Replace(body),
+						"clear before pack": reordered,
+						"native foreign":    body + "\ncall void asm sideeffect \"nop\", \"\"()",
+					} {
+						if changed == body || x86NativeLEAWCheckLogicalDFBody(changed) == nil {
+							t.Fatal("driver accepted incomplete or foreign native/logical DF observation", variant, name)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_native_leaw_retained_pointer_test.go b/x86_native_leaw_retained_pointer_test.go
new file mode 100644
index 000000000..be855b601
--- /dev/null
+++ b/x86_native_leaw_retained_pointer_test.go
@@ -0,0 +1,200 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86NativeLEAWRetainedPointerSource(arch, variant, control string) (string, string) {
+	word, move, suffix, number := goWordSize(arch), "MOVQ", "Q", "0x1122334455667788"
+	if arch == "386" {
+		move, suffix, number = "MOVL", "L", "0x55667788"
+	}
+	var source strings.Builder
+	if control == "foreign address" {
+		source.WriteString("GLOBL oldAddress<>(SB),8,$8\n")
+	}
+	fmt.Fprintf(&source, "TEXT ·Retain(SB),4,$0-%d\n%s out+0(FP),DI\n%s base+%d(FP),SI\nMOVL index+%d(FP),DX\n",
+		3*word+4, move, move, word, 3*word)
+	source.WriteString("MOVL $0x7fffffff,CX\nADDL $1,CX\nSTC\nSTD\n")
+	switch control {
+	case "unknown old":
+		// Direct/copied variants retain an independently valid SI address;
+		// only the unchanged upper destination bytes have no producer.
+	case "numeric upper":
+		fmt.Fprintf(&source, "%s $%s,AX\n", move, number)
+	case "foreign address":
+		lea := "LEAQ"
+		if arch == "386" {
+			lea = "LEAL"
+		}
+		fmt.Fprintf(&source, "%s oldAddress<>(SB),AX\n", lea)
+	default:
+		if variant == "Copied" {
+			fmt.Fprintf(&source, "%s old+%d(FP),BX\n%s BX,AX\n", move, 2*word, move)
+		} else {
+			fmt.Fprintf(&source, "%s old+%d(FP),AX\n", move, 2*word)
+		}
+	}
+	base := "SI"
+	if variant == "Alias" {
+		base = "AX" // Both effective-address reads precede this same destination's partial write.
+	}
+	fmt.Fprintf(&source, "LEAW -7(%s)(DX*8),AX\n", base)
+	if control == "nonadjacent" {
+		source.WriteString("NOP\n")
+	}
+	fmt.Fprintf(&source, "%s AX,1(DI)\n", move)
+	if control == "reuse" {
+		fmt.Fprintf(&source, "%s AX,9(DI)\n", move)
+	} else if control == "dereference" {
+		source.WriteString("MOVB (AX),BX\n")
+	}
+	fmt.Fprintf(&source, "PUSHF%s\nPOP%s CX\nANDL $0xcd5,CX\nMOVL CX,32(DI)\nCLD\nRET\n", suffix, suffix)
+	return source.String(), "func Retain(out *[48]byte,base,old *byte,index uint32)\n"
+}
+
+func x86NativeLEAWRetainedPointerBatch(arch, control string) (string, string) {
+	var source, declarations strings.Builder
+	for _, variant := range []string{"Direct", "Copied", "Alias"} {
+		body, declaration := x86NativeLEAWRetainedPointerSource(arch, variant, control)
+		source.WriteString(strings.ReplaceAll(body, "Retain", "Retain"+variant))
+		declarations.WriteString(strings.ReplaceAll(declaration, "Retain", "Retain"+variant))
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86NativeLEAWRetainedPointerFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for actual retained-pointer LEAW objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86NativeLEAWRetainedPointerBatch(target.arch, "")
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual old typed pointer's unchanged high bytes cannot be observed beside the new LEAW low16", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "retained-pointer-leaw.ll", "retained-pointer-leaw.o", body)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				})
+			}
+		})
+	}
+}
+
+func TestX86NativeLEAWRetainedNumericUpperControls(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations := x86NativeLEAWRetainedPointerBatch(arch, "numeric upper")
+		triple := x86AddressMemoryTargets(arch)[0]
+		x86LEAActualTargetGoObject(t, arch, triple, source)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api); err != nil || ir == "" {
+					t.Fatal("independently initialized numerical upper bytes changed under the same LEAW/store/source extent", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeLEAWRetainedPointerNeedsOldIdentityAndAdjacency(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, variant := range []string{"Direct", "Copied", "Alias"} {
+			for _, control := range []string{"unknown old", "foreign address", "nonadjacent", "reuse", "dereference"} {
+				source, declaration := x86NativeLEAWRetainedPointerSource(arch, variant, control)
+				triple := x86AddressMemoryTargets(arch)[0]
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+variant+"/"+control+"/"+api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unknown/foreign upper bytes or an intervening effect acquired an old typed pointer's one-store observation", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+const x86NativeLEAWRetainedPointerC = `#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+extern void RetainDirect(uint8_t*,const uint8_t*,const uint8_t*,uint32_t);
+extern void RetainCopied(uint8_t*,const uint8_t*,const uint8_t*,uint32_t);
+extern void RetainAlias(uint8_t*,const uint8_t*,const uint8_t*,uint32_t);
+typedef void (*operation)(uint8_t*,const uint8_t*,const uint8_t*,uint32_t);
+int main(void) {
+    const operation programs[]={RetainDirect,RetainCopied,RetainAlias};
+    uint8_t live[16]={0};
+    const uintptr_t bases[]={(uintptr_t)live,0,UINTPTR_MAX-3,UINT32_MAX-3,UINT16_MAX-3};
+    const uintptr_t oldValues[]={(uintptr_t)(live+3),0,UINTPTR_MAX,UINT32_MAX-1,UINT16_MAX+5};
+    const uint32_t indexes[]={0,1,UINT16_MAX,UINT32_MAX};
+    unsigned observations=0;
+    for (unsigned op=0;op<3;op++) for (unsigned b=0;b<5;b++)
+    for (unsigned old=0;old<5;old++) for (unsigned index=0;index<4;index++) {
+        uint8_t packet[80],want[80];
+        memset(packet,0xa5,sizeof(packet)); memcpy(want,packet,sizeof(packet));
+        uintptr_t input=op==2 ? oldValues[old] : bases[b];
+        uintptr_t address=input+(uintptr_t)indexes[index]*8-7;
+        uintptr_t expected=(oldValues[old]&~(uintptr_t)UINT16_MAX)|(address&UINT16_MAX);
+        memcpy(want+17,&expected,sizeof(expected));
+        uint32_t flags=UINT32_C(0xc95); /* ADD signed overflow, STC, STD; known six status plus DF. */
+        memcpy(want+48,&flags,sizeof(flags));
+        programs[op](packet+16,(const uint8_t*)bases[b],(const uint8_t*)oldValues[old],indexes[index]);
+        if (memcmp(packet,want,sizeof(packet))) {
+            fprintf(stderr,"retained-pointer LEAW op=%u base=%u old=%u index=%u\n",op,b,old,index);
+            return 1;
+        }
+        for (unsigned byte=0;byte<sizeof(live);byte++) if (live[byte]) return 2;
+        observations++;
+    }
+    if (observations!=300) return 3;
+    puts("LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS");
+    return 0;
+}
+`
+
+func TestX86NativeLEAWRetainedPointerPortableValuesStatusAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required for retained-pointer LEAW values")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	source, declarations := x86NativeLEAWRetainedPointerBatch(arch, "")
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("retained typed-pointer program rejected before independent value/status/canary execution", err)
+			}
+			native := x86ScalarFloatIntegerNativeTarget(arch, triple)
+			for _, variant := range []string{"Direct", "Copied", "Alias"} {
+				if err := x86NativeLEAWCheckTargetDFBody(x86StringMemoryFunction(t, ir, "Retain"+variant), native); err != nil {
+					t.Fatal("actual target lost its virtual/native direction lifecycle", variant, err)
+				}
+			}
+			for _, pipeline := range []struct {
+				text  string
+				level int
+			}{{ir, 0}, {ir, 2}, {x86DwordProductIROptimize(t, ir), 2}} {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "leaw-retained-pointer", triple, pipeline.text, x86NativeLEAWRetainedPointerC, nil, pipeline.level)
+			}
+		})
+	}
+	t.Log("300 input triples x 3 APIs x 3 pipelines; unmodified actual-target LLVM executes virtual DF, pointer values, status and canaries; physical DF remains separate matching-x86 execution")
+}
diff --git a/x86_native_leaw_retained_runtime_linux_amd64_test.go b/x86_native_leaw_retained_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..c0aa9a130
--- /dev/null
+++ b/x86_native_leaw_retained_runtime_linux_amd64_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Execute the complete actual Go encoder bytes through an explicitly bound
+// ABI0 stack adapter, not a claimed Go entry or a translator memory permission.
+// The unchanged body's PUSHF observes real DF=1 and all six status bits. The
+// adapter also captures real return DF before clearing it defensively; either
+// a missing CLD or a changed stack canary traps instead of corrupting the C ABI.
+func x86NativeLEAWOriginalABI0Adapter(t *testing.T, variant string) string {
+	t.Helper()
+	source, _ := x86NativeLEAWRetainedPointerSource("amd64", variant, "")
+	var bytes []string
+	for _, value := range amd64RegisterBoolOriginalBytes(t, source) {
+		bytes = append(bytes, fmt.Sprintf("0x%02x", value))
+	}
+	name := "Retain" + variant
+	body := "OriginalLEAW" + variant
+	assembly := ".text\n" + body + ":\n.byte " + strings.Join(bytes, ",") + "\n.globl " + name + "\n" + name + ":\n" +
+		"pushq %rbx\nsubq $32,%rsp\n" +
+		"movq %rdi,0(%rsp)\nmovq %rsi,8(%rsp)\nmovq %rdx,16(%rsp)\nmovl %ecx,24(%rsp)\n" +
+		"movl $0x5a5a5a5a,28(%rsp)\ncallq " + body + "\n" +
+		"pushfq\npopq %rax\ncld\ntestq $1024,%rax\njnz .Lbad" + variant + "\n" +
+		"cmpl $0x5a5a5a5a,28(%rsp)\njne .Lbad" + variant + "\n" +
+		"addq $32,%rsp\npopq %rbx\nretq\n.Lbad" + variant + ":\nud2\n"
+	return fmt.Sprintf("__asm__(%q);\n", assembly)
+}
+
+func TestCrossLinuxRuntimeMatrixX86LEAWRetainedPointerOriginalBytesAndNativeDF(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	if len(execution.prefix) != 0 || execution.triple != "x86_64-unknown-linux-gnu" {
+		t.Fatal("retained-pointer native DF needs direct Linux AMD64 execution", execution)
+	}
+	source, declarations := x86NativeLEAWRetainedPointerBatch("amd64", "")
+	x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+	// The numerical model, complete 300 input vectors, FLAGS/DF=1 and byte
+	// canaries remain unchanged. Add only a hardware DF=0 return observation.
+	call := "programs[op](packet+16,(const uint8_t*)bases[b],(const uint8_t*)oldValues[old],indexes[index]);"
+	if strings.Count(x86NativeLEAWRetainedPointerC, call) != 1 {
+		t.Fatal("native DF observer lost the unique original call boundary")
+	}
+	driver := strings.Replace(x86NativeLEAWRetainedPointerC, call, call+`
+        uintptr_t returnFlags;
+        __asm__ volatile("pushfq; popq %0; cld" : "=r"(returnFlags) :: "cc", "memory");
+        if (returnFlags&UINT32_C(0x400)) return 4;`, 1)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("unchanged native source rejected before real DF execution", err)
+			}
+			ir = x86NativeLEAWRetainedPointerLogicalDF(t, ir, false)
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+				{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "retained-leaw-native", pipeline.ir, driver, pipeline.level)
+					if string(output) != "LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS\n" {
+						t.Fatal("native LEAW/FLAGS/DF/canary observation incomplete", string(output))
+					}
+					t.Logf("native retained LEAW LLVM execution: %s", output)
+				})
+			}
+		})
+	}
+	t.Run("OriginalGoBytes", func(t *testing.T) {
+		var adapters strings.Builder
+		for _, variant := range []string{"Direct", "Copied", "Alias"} {
+			adapters.WriteString(x86NativeLEAWOriginalABI0Adapter(t, variant))
+		}
+		// No translated instruction bodies participate in this independent
+		// reference: all three original Go functions execute as actual bytes.
+		ir := "target triple = \"x86_64-unknown-linux-gnu\"\n"
+		output := execution.compileAndRunLLVM(t, "retained-leaw-original", ir, adapters.String()+driver, "-O2")
+		if string(output) != "LEAW_RETAINED_POINTER_300_VALUES_STATUS_CANARIES_PASS\n" {
+			t.Fatal("actual Go bytes did not establish real DF=1/status/canaries and DF=0 return", string(output))
+		}
+		t.Logf("native retained LEAW actual Go bytes execution: %s", output)
+	})
+	t.Log("300 inputs: actual Go bytes/explicit ABI0 stack adapter observe hardware DF=1 inside and DF=0 at return; original native LLVM bodies retain STD/CLD and check packed logical DF/status plus hardware DF=0 return, with all byte canaries")
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_native_leaw_retained_state_test.go b/x86_native_leaw_retained_state_test.go
new file mode 100644
index 000000000..596e2c8dc
--- /dev/null
+++ b/x86_native_leaw_retained_state_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86NativeLEAWRetainedPointerKeepsDisjointByteAndOriginDomains(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := x86ResultPointerWord(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		for _, old := range []string{"caller", "pointer only", "unknown", "numeric"} {
+			for missing := -1; missing < int(word); missing++ {
+				if old != "numeric" && missing != -1 {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%s/missing%d", arch, old, missing), func(t *testing.T) {
+					state := x86RawMoveInitializedState()
+					state.callerAddressFP = map[int64]bool{0: true, word: true, 2 * word: true}
+					state.gp[0], state.canonicalGP[0] = 0, 0
+					state.pointerGP[0] = old == "caller" || old == "pointer only"
+					state.callerAddressGP[0] = old == "caller"
+					if old == "caller" {
+						state.callerAddressOrigin[0] = uint16(2*word + 1)
+					} else if old == "numeric" {
+						state.gp[0] = 0xff
+						if missing >= 0 {
+							state.gp[0] &^= uint8(1) << uint(missing)
+						}
+					}
+					state.gp[6], state.pointerGP[6], state.callerAddressGP[6] = 0, true, true
+					state.callerAddressOrigin[6], state.callerAddressOrigin[7] = uint16(word+1), 1
+					instruction := x86ScalarLaneInstruction(t, "LEAW -7(SI)(DX*8),AX")
+					before, expected := state.clone(), state.clone()
+					observed := uint8(3)
+					if old == "caller" {
+						observed = uint8((uint16(1) << uint(word)) - 1)
+					}
+					expected.gp[0] &^= 3
+					expected.pointerGP[0], expected.callerAddressGP[0], expected.callerAddressOrigin[0] = false, false, 0
+					expected.nativeLEAAddressBits = x86NativeLEAAddressBits{register: 0, bytes: observed}
+					if accepted, known := x86ResultNativeLEAAddressBitsStep(instruction, &state, nil, arch, true); !known || !accepted {
+						t.Fatal("complete new low16 address source lost its independent effect", accepted, known)
+					}
+					// Use the real shared post-consumers: a mixed partial value
+					// must not retain the old full-word caller identity or origin.
+					state.callerAddressGP = x86ResultCallerAddressesAfterTransfer(instruction, before.callerAddressGP,
+						state.callerAddressGP, state.callerAddressFP, arch)
+					state.callerAddressOrigin = x86ResultCallerOriginsAfter(instruction, before.callerAddressOrigin,
+						state.callerAddressGP, state.callerAddressFP, arch)
+					if !reflect.DeepEqual(state, expected) || x86ResultRead(Operand{Kind: OpReg, Reg: AX}, word, &state, nil, arch) {
+						t.Fatal("retained address representation became NUM, pointer, caller origin, canonical or unrelated state")
+					}
+					store := x86ScalarLaneInstruction(t, move+" AX,1(DI)")
+					wanted := old == "caller" || old == "numeric" && missing < 2
+					for _, scoped := range []bool{false, true} {
+						copy := state.clone()
+						accepted, known := x86LoweredScalarNativeStoreWithAddressBits(store, &copy, nil, arch, scoped)
+						if !known || accepted != (scoped && wanted) || !reflect.DeepEqual(copy, state) {
+							t.Fatal("retained bytes escaped their one-store scope or filled a missing old numerical upper byte", scoped, accepted, wanted)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_native_mmx_movemask_test.go b/x86_native_mmx_movemask_test.go
new file mode 100644
index 000000000..ca4516836
--- /dev/null
+++ b/x86_native_mmx_movemask_test.go
@@ -0,0 +1,263 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86NativeMMXMoveMaskByteEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		// SP and amd64 BP have separate physical frame roles. The original
+		// encoding matrix retains those spellings without granting this leaf
+		// a logical GP destination; mode386 BP remains an ordinary GP.
+		registers := []Reg{AX, CX, DX, BX, SI, DI}
+		if arch == "amd64" {
+			registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		} else {
+			registers = append(registers, BP)
+		}
+		for bank := 0; bank < 8; bank++ {
+			for _, destination := range registers {
+				t.Run(fmt.Sprintf("%s/M%d/%s", arch, bank, destination), func(t *testing.T) {
+					instruction := fmt.Sprintf("PMOVMSKB M%d,%s", bank, destination)
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(a uint64) uint32",
+						fmt.Sprintf("MOVQ a+0(FP),M%d\n%s\nEMMS\nMOVL %s,ret+8(FP)\nRET", bank, instruction, destination))
+					plan, err := newX86NativeMMXRegion(file.Funcs[0], sig, arch, x86Legacy127Targets(arch)[0])
+					if err != nil || plan == nil {
+						t.Fatal("MMX_MOVE_MASK_TYPED_REGION_GAP", err)
+					}
+					ordinal := plan.begin + 1 // Parse retains the original TEXT instruction.
+					ins := file.Funcs[0].Instrs[ordinal]
+					if ins.Op != "PMOVMSKB" {
+						t.Fatal("independent transfer fixture lost its original mask operation")
+					}
+					index, _, valid := x86ResultGP(destination, 4, arch)
+					if !valid {
+						t.Fatal("independent GP fixture invalid")
+					}
+					if plan.gpRead[index] || !plan.gpWritten[index] {
+						t.Fatal("write-only mask result acquired an old-GP dependency")
+					}
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagZF, direction: x86ResultDirectionBackward}
+					state.nativeMMX[bank] = 0xff
+					state.canonicalGP[index] = 0xff
+					state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = true, true, 7
+					state.resultAddressGP[index] = x86ResultSlotAddress{start: 8, end: 12, valid: true}
+					state.boolFrameGP = new([16]x86ResultSlotAddress)
+					state.boolFrameGP[index] = state.resultAddressGP[index]
+					before := state.clone()
+					if accepted, known := plan.transfer(ordinal, ins, &state, nil, 8, arch); !accepted || !known {
+						t.Fatal("defined physical MMX source not transferred")
+					}
+					expected := before.clone()
+					expected.gp[index] = 0xff
+					expected.canonicalGP[index] = 0xf0
+					expected.pointerGP[index], expected.callerAddressGP[index], expected.callerAddressOrigin[index] = false, false, 0
+					expected.resultAddressGP[index], expected.boolFrameGP[index] = x86ResultSlotAddress{}, x86ResultSlotAddress{}
+					if !reflect.DeepEqual(expected, state) {
+						t.Fatal("r32 result changed unrelated source/FLAGS or retained pointer/bool facts", state, expected)
+					}
+					for missing := 0; missing < 8; missing++ {
+						state = before.clone()
+						state.nativeMMX[bank] &^= 1 << uint(missing)
+						unchanged := state.clone()
+						if accepted, known := plan.transfer(ordinal, ins, &state, nil, 8, arch); accepted || !known || !reflect.DeepEqual(state, unchanged) {
+							t.Fatal("missing physical source byte supplied a value or mutated state", missing)
+						}
+					}
+					state = before.clone()
+					if accepted, known := x86ResultMoveMaskStep(ins, &state, nil, 8, arch); accepted || !known {
+						t.Fatal("ordinary observer acquired physical MMX")
+					}
+					changed := ins
+					changed.Raw += " // changed"
+					state = before.clone()
+					if accepted, known := plan.transfer(ordinal, changed, &state, nil, 8, arch); accepted || !known {
+						t.Fatal("private source identity changed")
+					}
+				})
+			}
+		}
+	}
+}
+
+func mmxMoveMaskObjectByteError(disassembly, arch string) error {
+	header := regexp.MustCompile(`^[0-9a-f]+ <([^>]+)>:$`)
+	owner := ""
+	seen := map[string]int{}
+	for _, line := range strings.Split(disassembly, "\n") {
+		if match := header.FindStringSubmatch(strings.TrimSpace(line)); match != nil {
+			owner = strings.TrimPrefix(match[1], "_")
+			continue
+		}
+		_, rest, found := strings.Cut(strings.TrimSpace(line), ":")
+		if !found {
+			continue
+		}
+		fields := strings.Fields(rest)
+		var code []byte
+		for len(fields) > 0 && len(fields[0]) == 2 {
+			value, err := strconv.ParseUint(fields[0], 16, 8)
+			if err != nil {
+				break
+			}
+			code, fields = append(code, byte(value)), fields[1:]
+		}
+		if len(fields) == 0 || fields[0] != "pmovmskb" {
+			continue
+		}
+		bank, err := strconv.Atoi(strings.TrimPrefix(owner, "MMXMaskByte"))
+		if !strings.HasPrefix(owner, "MMXMaskByte") || err != nil || bank < 0 || bank > 7 {
+			return fmt.Errorf("unowned target mask: %s", line)
+		}
+		want := []byte{0x44, 0x0f, 0xd7, 0xd0 | byte(bank)}
+		if arch == "386" {
+			want = []byte{0x0f, 0xd7, 0xc0 | byte(bank)}
+		}
+		if !bytes.Equal(want, code) {
+			return fmt.Errorf("%s physical mask bytes=%x want=%x", owner, code, want)
+		}
+		seen[owner]++
+	}
+	for bank := 0; bank < 8; bank++ {
+		name := fmt.Sprintf("MMXMaskByte%d", bank)
+		if seen[name] != 1 {
+			return fmt.Errorf("%s mask count=%d want=1", name, seen[name])
+		}
+	}
+	return nil
+}
+
+func TestX86NativeMMXMoveMaskTargetBytes(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc/objdump required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var originals []x86OfficialPackedCase
+			for bank := 0; bank < 8; bank++ {
+				name := fmt.Sprintf("MMXMaskByte%d", bank)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVQ a+0(FP),M%d\n", name, bank)
+				instruction := fmt.Sprintf("PMOVMSKB M%d,BX", bank)
+				originals = append(originals, x86OfficialPackedCase{symbol: name, line: strings.Count(source.String(), "\n") + 1, witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: []byte{0x0f, 0xd7, 0xd8 | byte(bank)}}})
+				fmt.Fprintln(&source, instruction)
+				source.WriteString("EMMS\nMOVL BX,ret+8(FP)\nRET\n")
+				fmt.Fprintf(&declarations, "func %s(a uint64) uint32\n", name)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, target.arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, originals); err != nil {
+				t.Fatal("original mask physical bytes", err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						disassembly := x86ExchangeObjectDisassembly(t, llc, objdump, target.triple, ir, level)
+						if err := mmxMoveMaskObjectByteError(disassembly, target.arch); err != nil {
+							t.Fatal(err)
+						}
+						// A bank swap between functions must not pass an aggregate count.
+						changed := strings.NewReplacer("MMXMaskByte0", "MMXMaskByte1", "MMXMaskByte1", "MMXMaskByte0").Replace(disassembly)
+						if mmxMoveMaskObjectByteError(changed, target.arch) == nil {
+							t.Fatal("physical-bank/function swap escaped the byte oracle")
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NativeMMXMoveMaskRoleBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, body := range []string{
+			"PMOVMSKB M0,AX\nEMMS",                              // No physical source definition.
+			"MOVQ a+0(FP),M0\nPMOVMSKB M0,AX",                   // No real tag cleanup.
+			"MOVQ a+0(FP),M0\nPMOVMSKB M0,AX\nMOVL $1,CX\nEMMS", // Interrupted physical region.
+			"MOVL $0,AX\nCMPL AX,AX\nMOVQ a+0(FP),M0\nPMOVMSKB M0,AX\nEMMS\nPUSHFQ\nPOPQ AX", // Undefined system FLAGS bits are not an integer.
+		} {
+			if arch == "386" {
+				body = strings.ReplaceAll(strings.ReplaceAll(body, "PUSHFQ", "PUSHFL"), "POPQ AX", "POPL AX")
+			}
+			_, _, _, source := x86ResultInitializationFixture(t, arch, "func Value(a uint64) uint32", body+"\nMOVL AX,ret+8(FP)\nRET")
+			if _, err := x86ScalarLiteralGoListing(t, arch, source); err != nil {
+				t.Fatal("negative is not real original Go", err)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(a uint64) uint32", arch, x86Legacy127Targets(arch)[0], api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("MMX state/input boundary widened", arch, api, body, err)
+				}
+			}
+		}
+		// Void still consumes every physical source byte. An unused result
+		// does not create a numerical MMX bank or dispense with real EMMS.
+		source := "TEXT ·Value(SB),4,$0-8\nPMOVMSKB M0,AX\nEMMS\nRET\n"
+		if _, err := x86ScalarLiteralGoListing(t, arch, source); err != nil {
+			t.Fatal(err)
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(a uint64)", arch, x86Legacy127Targets(arch)[0], api)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatal("Void supplied an undefined physical MMX source", arch, api, err)
+			}
+		}
+	}
+}
+
+func TestX86NativeMMXMoveMaskOriginalGoRegisterBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		registers := []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI"}
+		if arch == "amd64" {
+			registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		}
+		var fixtures []x86OfficialPackedCase
+		for bank := 0; bank < 8; bank++ {
+			for reg, destination := range registers {
+				code := []byte{0x0f, 0xd7, 0xc0 | byte(reg&7)<<3 | byte(bank)}
+				if reg >= 8 {
+					code = append([]byte{0x44}, code...)
+				}
+				fixtures = append(fixtures, x86OfficialPackedCase{witness: goasmrules.X86PackedBinaryWitness{Instruction: fmt.Sprintf("PMOVMSKB M%d,%s", bank, destination), Encoding: code, Destination: destination}})
+			}
+		}
+		for start := 0; start < len(fixtures); start += 32 {
+			end := start + 32
+			if end > len(fixtures) {
+				end = len(fixtures)
+			}
+			batch := append([]x86OfficialPackedCase(nil), fixtures[start:end]...)
+			var source strings.Builder
+			for i := range batch {
+				batch[i].symbol = fmt.Sprintf("MMXMaskBytes%d", start+i)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[i].symbol)
+				batch[i].line = strings.Count(source.String(), "\n") + 1
+				fmt.Fprintln(&source, batch[i].witness.Instruction)
+				source.WriteString("RET\n")
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+}
diff --git a/x86_native_mmx_region.go b/x86_native_mmx_region.go
new file mode 100644
index 000000000..cb483d8a2
--- /dev/null
+++ b/x86_native_mmx_region.go
@@ -0,0 +1,334 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type x86NativeMMXSite struct {
+	instruction Instr
+	word        *x86MMXWordForm
+	integer     *x86LegacyMMXReadForm
+	maskStore   *amd64ImplicitMaskMoveSpec
+	moveMask    *x86MoveMaskForm
+}
+
+// This private source-bound region keeps the real MMX/x87 instructions
+// together through EMMS. Numerical availability remains a separate must-domain;
+// neither a source spelling nor the emitter's private image supplies inputs.
+type x86NativeMMXRegion struct {
+	begin, end        int
+	sites             map[int]x86NativeMMXSite
+	function          [32]byte
+	signature         [32]byte
+	instructions      []Instr
+	arch, triple      string
+	fpExtent          int64
+	fpRead, fpWritten []bool
+	gpRead, gpWritten [16]bool
+	xRead, xWritten   [16]bool
+}
+
+func x86NativeMMXInstruction(ins Instr, arch string) (x86NativeMMXSite, bool, error) {
+	site := x86NativeMMXSite{instruction: ins}
+	if ins.Op == "EMMS" {
+		if len(ins.Args) != 0 {
+			return site, true, fmt.Errorf("%s EMMS expects no operands", arch)
+		}
+		return site, true, nil
+	}
+	if form, known, err := x86MMXWordProperties(ins, arch); known {
+		native := form
+		site.word = &native
+		return site, true, err
+	}
+	if form, known, err := x86LegacyMMXReadProperties(ins, arch); known && form.mmx {
+		native := form
+		site.integer = &native
+		return site, true, err
+	}
+	if spec, known, err := x86ImplicitMaskMoveProperties(ins.Op, ins, arch); known && spec.byteWidth == 8 {
+		native := spec
+		site.maskStore = &native
+		return site, true, err
+	}
+	if form, known, err := x86MoveMaskProperties(ins.Op, ins, arch); known && form.byteWidth == 8 {
+		// Only the matching MMX site needs an escaping form allocation.
+		native := form
+		site.moveMask = &native
+		return site, true, err
+	}
+	return site, false, nil
+}
+
+func newX86NativeMMXRegion(fn Func, sig FuncSig, arch, triple string) (*x86NativeMMXRegion, error) {
+	plan := &x86NativeMMXRegion{begin: -1, end: -1, sites: make(map[int]x86NativeMMXSite), arch: arch, triple: triple}
+	fail := func(reason string) (*x86NativeMMXRegion, error) {
+		return nil, fmt.Errorf("%w: native MMX region: %s", ErrProbeNeedsContext, reason)
+	}
+	for ordinal, ins := range fn.Instrs {
+		site, known, err := x86NativeMMXInstruction(ins, arch)
+		if err != nil {
+			return nil, err
+		}
+		if known {
+			if plan.begin < 0 {
+				plan.begin = ordinal
+			}
+			plan.end = ordinal
+			plan.sites[ordinal] = site
+		}
+	}
+	if plan.begin < 0 {
+		return nil, nil
+	}
+	if !x86ScalarFloatIntegerNativeTarget(arch, triple) || fn.FrameSize != 0 || fn.ArgSize < 0 || fn.ArgSize > 4096 ||
+		len(fn.Instrs) > 512 || strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 || fn.X86RawAlign != 0 ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		sig.WASMContext != "" || sig.WASMNative || sig.x86CallerRegions != nil || sig.x86FixedLocal != nil ||
+		sig.amd64GoArguments != nil || sig.x86BorrowedBoolTail || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86DirectTailRoot != nil || fn.x86RawReplay != nil || fn.x86BoolCalls != nil ||
+		len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 || x86X87ValueFlowNeeded(fn) {
+		return fail("needs its complete ordinary bounded native leaf, not another entry/storage owner")
+	}
+	for ordinal, ins := range fn.Instrs {
+		if !x86ResultNamedPredicateInstruction(ins) || ins.Op == OpCALL || ins.Op == OpJMP ||
+			ins.Op == OpLABEL || isAMD64ConditionalBranch(ins.Op) || ins.x86NumericalRead != nil ||
+			len(ins.x86SourceStackFP) != 0 || len(ins.x86CallerMemory) != 0 || len(ins.x86FixedLocalMemory) != 0 {
+			return fail("a foreign effect or source CFG cannot acquire physical MMX state")
+		}
+		if ordinal >= plan.begin && ordinal <= plan.end {
+			if _, present := plan.sites[ordinal]; !present {
+				return fail("MMX effects must form one uninterrupted region")
+			}
+		}
+	}
+	if fn.Instrs[plan.end].Op != "EMMS" {
+		return fail("every MMX region must close its real x87 tag state with EMMS")
+	}
+	for _, slots := range [][]FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for _, slot := range slots {
+			width := x86FrameScalarBytes(slot.Type, arch)
+			if width == 0 || slot.Offset < 0 || slot.Offset > fn.ArgSize-width {
+				return fail("typed FP layout is not bounded by its actual source TEXT")
+			}
+			if end := slot.Offset + width; end > plan.fpExtent {
+				plan.fpExtent = end
+			}
+		}
+	}
+	plan.fpRead, plan.fpWritten = make([]bool, plan.fpExtent), make([]bool, plan.fpExtent)
+	for _, site := range plan.sites {
+		if site.word != nil {
+			form := site.word
+			if form.nonTemporal && form.destination.Kind == OpFP {
+				return fail("non-temporal FP stores need original native backing, not a private image")
+			}
+			if err := plan.operand(form.source, form.bytes, false); err != nil {
+				return fail(err.Error())
+			}
+			width := form.bytes
+			if form.targetX {
+				width = 16
+			}
+			if err := plan.operand(form.destination, width, true); err != nil {
+				return fail(err.Error())
+			}
+		} else if site.integer != nil {
+			form := site.integer
+			if err := plan.operand(form.source, int64(form.memoryBytes), false); err != nil {
+				return fail(err.Error())
+			}
+		} else if site.moveMask != nil {
+			if err := plan.operand(site.instruction.Args[0], 8, false); err != nil {
+				return fail(err.Error())
+			}
+			if err := plan.operand(site.instruction.Args[1], 4, true); err != nil {
+				return fail(err.Error())
+			}
+		} else if site.maskStore != nil {
+			for _, operand := range site.instruction.Args {
+				if err := plan.operand(operand, 8, false); err != nil {
+					return fail(err.Error())
+				}
+			}
+			if err := plan.operand(Operand{Kind: OpMem, Mem: MemRef{Base: DI}}, 8, true); err != nil {
+				return fail(err.Error())
+			}
+		}
+	}
+	var err error
+	plan.function, err = x86CallerSourceFingerprint(fn)
+	if err != nil {
+		return nil, err
+	}
+	plan.signature, err = x86CallerSourceFingerprint(sig)
+	if err != nil {
+		return nil, err
+	}
+	plan.instructions = cloneX86ReplayInstrs(fn.Instrs)
+	return plan, nil
+}
+
+func (plan *x86NativeMMXRegion) operand(operand Operand, width int64, write bool) error {
+	switch operand.Kind {
+	case OpImm:
+		return nil // Only the independently validated immediate-count row enters here.
+	case OpReg:
+		if _, mmx := amd64ParseMReg(operand.Reg); mmx {
+			return nil
+		}
+		if index, vector := amd64ParseXReg(operand.Reg); vector && index < 16 {
+			plan.xRead[index], plan.xWritten[index] = plan.xRead[index] || !write, plan.xWritten[index] || write
+			return nil
+		}
+		index, _, valid := x86ResultGP(operand.Reg, x86ResultPointerWord(plan.arch), plan.arch)
+		if !valid {
+			return fmt.Errorf("physical frame registers need their independent source contract")
+		}
+		plan.gpRead[index], plan.gpWritten[index] = plan.gpRead[index] || !write, plan.gpWritten[index] || write
+		return nil
+	case OpFP:
+		if width <= 0 || operand.FPOffset < 0 || operand.FPOffset > plan.fpExtent-width {
+			return fmt.Errorf("FP operand exceeds its complete typed byte image")
+		}
+		for offset := operand.FPOffset; offset < operand.FPOffset+width; offset++ {
+			plan.fpRead[offset], plan.fpWritten[offset] = plan.fpRead[offset] || !write, plan.fpWritten[offset] || write
+		}
+		return nil
+	case OpMem:
+		if operand.Mem.Sym != "" || !x86OrdinaryNativeMemoryOperand(operand, plan.arch) {
+			return fmt.Errorf("native memory needs an ordinary complete incoming-pointer address")
+		}
+		for _, reg := range []Reg{operand.Mem.Base, operand.Mem.Index} {
+			if reg != "" {
+				if err := plan.operand(Operand{Kind: OpReg, Reg: reg}, x86ResultPointerWord(plan.arch), false); err != nil {
+					return err
+				}
+			}
+		}
+		return nil
+	}
+	return fmt.Errorf("symbolic/native storage needs its independent source binding")
+}
+
+func (plan *x86NativeMMXRegion) matches(fn Func, sig FuncSig, arch, triple string) bool {
+	if plan == nil || plan.arch != arch || plan.triple != triple || !reflect.DeepEqual(plan.instructions, fn.Instrs) {
+		return false
+	}
+	function, err := x86CallerSourceFingerprint(fn)
+	if err != nil || function != plan.function {
+		return false
+	}
+	signature, err := x86CallerSourceFingerprint(sig)
+	return err == nil && signature == plan.signature
+}
+
+func (plan *x86NativeMMXRegion) matchesInstruction(ordinal int, ins Instr) bool {
+	return plan != nil && ordinal >= 0 && ordinal < len(plan.instructions) && reflect.DeepEqual(plan.instructions[ordinal], ins)
+}
+
+func (plan *x86NativeMMXRegion) transfer(ordinal int, ins Instr, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if plan == nil || ordinal < plan.begin || ordinal > plan.end {
+		return false, false
+	}
+	site, present := plan.sites[ordinal]
+	if !present || state == nil || arch != plan.arch || !plan.matchesInstruction(ordinal, ins) ||
+		!x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if state.shapeOnly || ins.Op == "EMMS" {
+		return true, true // Grammar only, or the actual paired hardware tag operation.
+	}
+	read := func(operand Operand, width int64) bool {
+		if operand.Kind == OpReg {
+			mask := uint8((uint16(1) << uint(width)) - 1)
+			if index, valid := amd64ParseMReg(operand.Reg); valid {
+				return state.nativeMMX[index]&mask == mask
+			}
+			if index, valid := amd64ParseXReg(operand.Reg); valid {
+				return state.xmm[index]&uint16(mask) == uint16(mask)
+			}
+			if index, _, valid := x86ResultGP(operand.Reg, width, arch); valid &&
+				(state.pointerGP[index] || state.callerAddressGP[index]) {
+				return false // Opaque address bits cannot become numeric MMX bytes.
+			}
+		}
+		return x86ResultReadWithNativeContinuation(ins, operand, width, state, owned, arch, true)
+	}
+	if form := site.word; form != nil {
+		if !read(form.source, form.bytes) {
+			return false, true
+		}
+		if form.targetM {
+			index, _ := amd64ParseMReg(form.destination.Reg)
+			state.nativeMMX[index] = 0xff // MOVL clears the remaining high32.
+			return true, true
+		}
+		if form.targetX {
+			index, _ := amd64ParseXReg(form.destination.Reg)
+			state.writeVector(index, 16, 0xffff, true)
+			return true, true
+		}
+		if form.destination.Kind == OpMem {
+			return x86ResultIncomingPointerAddressIdentity(form.destination, state, arch), true
+		}
+		if form.destination.Kind == OpReg {
+			index, _, valid := x86ResultGP(form.destination.Reg, form.bytes, arch)
+			if !valid {
+				return false, true
+			}
+			state.canonicalGP[index] = 0
+			if form.bytes == 4 {
+				state.canonicalGP[index] = 0xf0
+			}
+			state.callerAddressGP[index], state.callerAddressOrigin[index] = false, 0
+			state.resultAddressGP[index] = x86ResultSlotAddress{}
+		}
+		return x86ResultStore(form.destination, form.bytes, state, owned, resultOffset, arch), true
+	}
+	if site.moveMask != nil {
+		if !read(ins.Args[0], 8) {
+			return false, true
+		}
+		index, _, valid := x86ResultGP(ins.Args[1].Reg, 4, arch)
+		if !valid {
+			return false, true
+		}
+		// A physical mask produces a write-only r32. Its upper dword is
+		// zero, never the old pointer, caller address or canonical bool.
+		state.canonicalGP[index] = 0xf0
+		state.callerAddressGP[index], state.callerAddressOrigin[index] = false, 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+		return x86ResultStore(ins.Args[1], 4, state, owned, resultOffset, arch), true
+	}
+	if site.maskStore != nil {
+		for _, operand := range ins.Args {
+			if !read(operand, 8) {
+				return false, true
+			}
+		}
+		return x86ResultIncomingPointerAddressIdentity(Operand{Kind: OpMem, Mem: MemRef{Base: DI}}, state, arch), true
+	}
+	form := site.integer
+	destination, _ := amd64ParseMReg(ins.Args[form.destination].Reg)
+	self := form.source.Kind == OpReg && form.source.Reg == ins.Args[form.destination].Reg
+	zero := self && (form.canonical == "PXOR" || form.canonical == "PANDN" ||
+		strings.HasPrefix(string(form.canonical), "PCMPEQ") || strings.HasPrefix(string(form.canonical), "PCMPGT"))
+	if !zero {
+		width := int64(8)
+		if form.memoryBytes != 0 {
+			width = int64(form.memoryBytes)
+		}
+		if !read(form.source, width) || form.spec.table != x86LegacyMMXShuffle && state.nativeMMX[destination] != 0xff {
+			return false, true
+		}
+	}
+	state.nativeMMX[destination] = 0xff
+	return true, true
+}
diff --git a/x86_native_mmx_region_test.go b/x86_native_mmx_region_test.go
new file mode 100644
index 000000000..61b502782
--- /dev/null
+++ b/x86_native_mmx_region_test.go
@@ -0,0 +1,207 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+const x86NativeMMXTestIntegerNames = `PACKSSLW PACKSSWB PACKUSWB PADDB PADDL PADDW
+	PADDSB PADDSW PADDUSB PADDUSW PAND PANDN POR PXOR PAVGB PAVGW
+	PCMPEQB PCMPEQW PCMPEQL PCMPGTB PCMPGTW PCMPGTL PMADDWL
+	PMULLW PMULHW PMULHUW PMULULQ PUNPCKHBW PUNPCKHWL PUNPCKHLQ
+	PUNPCKLBW PUNPCKLWL PUNPCKLLQ PHADDD PSHUFW
+	PSLLW PSLLL PSLLQ PSRLW PSRLL PSRLQ PSRAW PSRAL`
+
+func x86NativeMMXTestPlan(t *testing.T, instruction string) (*x86NativeMMXRegion, Func, FuncSig) {
+	t.Helper()
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(a uint64) uint64",
+		instruction+"\nEMMS\nRET")
+	fn := file.Funcs[0]
+	plan, err := newX86NativeMMXRegion(fn, sig, "amd64", "x86_64-unknown-linux-gnu")
+	if err != nil || plan == nil {
+		t.Fatal("complete ordinary MMX source lost its private region", err)
+	}
+	return plan, fn, sig
+}
+
+func TestX86NativeMMXCompleteIntegerBankEffects(t *testing.T) {
+	// Independent list, not an iteration over the implementation's map. The
+	// existing Go-table witness also binds every row, prefix and opcode byte.
+	names := strings.Fields(x86NativeMMXTestIntegerNames)
+	if len(names) != 43 || len(x86LegacyMMXReadSpecs) != len(names) {
+		t.Fatal("complete integer MMX family changed")
+	}
+	for _, name := range names {
+		for _, source := range []string{"M1", "BX", "a+0(FP)", "(AX)"} {
+			t.Run(name+"/"+source, func(t *testing.T) {
+				instruction := name + " " + source + ",M0"
+				if name == "PSHUFW" {
+					instruction = name + " $27," + source + ",M0"
+				}
+				plan, fn, _ := x86NativeMMXTestPlan(t, instruction)
+				ordinal := plan.begin
+				ins := fn.Instrs[ordinal]
+				state := x86ResultState{fp: make([]bool, 16), flags: x86ByteFlagsAll,
+					direction: x86ResultDirectionBackward, stringCount: x86StringCountNonzero}
+				owned := make([]bool, 16)
+				for offset := range state.fp {
+					state.fp[offset], owned[offset] = true, true
+				}
+				state.nativeMMX[0], state.nativeMMX[1], state.nativeMMX[3] = 0xff, 0xff, 0xff
+				state.gp[0], state.gp[3], state.pointerGP[0] = 0xff, 0xff, true
+				state.xmm[0], state.vectorUpper[0] = 0x55aa, 0xffff0000
+				before := state.clone()
+				if accepted, known := plan.transfer(ordinal, ins, &state, owned, 8, "amd64"); !accepted || !known || !reflect.DeepEqual(before, state) {
+					t.Fatal("MMX writer changed another register, address, FLAGS or DF domain", accepted, known)
+				}
+				missing := before.clone()
+				switch source {
+				case "M1":
+					missing.nativeMMX[1] = 0x7f
+				case "BX":
+					missing.nativeMMX[3] = 0 // The defined GP BX cannot supply physical M3.
+				case "a+0(FP)":
+					width := 8
+					if name == "PUNPCKLBW" || name == "PUNPCKLWL" || name == "PUNPCKLLQ" {
+						width = 4
+						missing.fp[4] = false // Low unpack must not over-read its m32 source.
+						if accepted, _ := plan.transfer(ordinal, ins, &missing, owned, 8, "amd64"); !accepted {
+							t.Fatal("low unpack incorrectly required the upper m64 bytes")
+						}
+					}
+					missing.fp[width-1] = false
+				case "(AX)":
+					missing.pointerGP[0] = false
+				}
+				unchanged := missing.clone()
+				if accepted, known := plan.transfer(ordinal, ins, &missing, owned, 8, "amd64"); accepted != (source == "(AX)") || !known {
+					t.Fatal("private numerical shadows supplied a missing physical bank or memory source")
+				}
+				if source == "(AX)" {
+					if !reflect.DeepEqual(missing, unchanged) {
+						t.Fatal("numerical MMX read changed an independent state or pointer role")
+					}
+					for _, available := range []uint8{0, 1} {
+						partial := unchanged.clone()
+						partial.gp[0] = available
+						beforePartial := partial.clone()
+						if accepted, _ := plan.transfer(ordinal, ins, &partial, owned, 8, "amd64"); accepted || !reflect.DeepEqual(partial, beforePartial) {
+							t.Fatal("MMX read acquired unknown or partial address bytes", available)
+						}
+					}
+				}
+				missing = before.clone()
+				missing.nativeMMX[0] = 0
+				accepted, known := plan.transfer(ordinal, ins, &missing, owned, 8, "amd64")
+				if !known || accepted != (name == "PSHUFW") {
+					t.Fatal("old MMX destination dependency changed", accepted, known)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NativeMMXWordDoesNotCreatePointerOrCanonicalFacts(t *testing.T) {
+	for _, op := range []string{"MOVL", "MOVQ"} {
+		plan, fn, _ := x86NativeMMXTestPlan(t, op+" M0,AX")
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+		state.nativeMMX[0], state.canonicalGP[0] = 0xff, 0xff
+		state.pointerGP[0], state.callerAddressGP[0], state.callerAddressOrigin[0] = true, true, 7
+		state.resultAddressGP[0] = x86ResultSlotAddress{start: 8, end: 16, valid: true}
+		if accepted, known := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); !accepted || !known {
+			t.Fatal(op, "initialized physical MMX word not transported")
+		}
+		canonical := uint8(0)
+		if op == "MOVL" {
+			canonical = 0xf0 // Only the actually cleared upper dword is known zero.
+		}
+		if state.gp[0] != 0xff || state.canonicalGP[0] != canonical || state.pointerGP[0] ||
+			state.callerAddressGP[0] || state.callerAddressOrigin[0] != 0 || state.resultAddressGP[0].valid ||
+			state.flags != x86ByteFlagsAll || state.direction != x86ResultDirectionForward {
+			t.Fatal(op, "numerical MMX transport retained another source authority")
+		}
+	}
+	plan, fn, _ := x86NativeMMXTestPlan(t, "MOVQ M1,M0")
+	state := x86ResultState{}
+	state.nativeMMX[1] = 0xff
+	if accepted, known := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); accepted || !known {
+		t.Fatal("Go's GP CX encoding borrowed initialized M1")
+	}
+	state.gp[1] = 0xff
+	if accepted, _ := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); !accepted || state.nativeMMX[0] != 0xff {
+		t.Fatal("actual initialized GP CX did not supply Go's selected word row")
+	}
+}
+
+func TestX86NativeMMXRegionBindsSourceSignatureAndTarget(t *testing.T) {
+	plan, fn, sig := x86NativeMMXTestPlan(t, "MOVQ a+0(FP),M0\nMOVQ M0,ret+8(FP)")
+	const triple = "x86_64-unknown-linux-gnu"
+	if !plan.matches(fn, sig, "amd64", triple) {
+		t.Fatal("fresh source-bound region does not match its owner")
+	}
+	changed := fn
+	changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+	changed.Instrs[plan.begin].Args[0].FPOffset++
+	if plan.matches(changed, sig, "amd64", triple) || plan.matches(fn, sig, "386", triple) ||
+		plan.matches(fn, sig, "amd64", "x86_64-pc-windows-msvc") {
+		t.Fatal("MMX region was rebound to changed source or target")
+	}
+	state := x86ResultState{shapeOnly: true}
+	if accepted, known := plan.transfer(plan.begin, changed.Instrs[plan.begin], &state, nil, 8, "amd64"); accepted || !known {
+		t.Fatal("a mutated source operand borrowed an already bound transfer")
+	}
+	changedSig := sig
+	changedSig.Name += "Changed"
+	if plan.matches(fn, changedSig, "amd64", triple) {
+		t.Fatal("MMX region was rebound to another declaration")
+	}
+	for _, row := range []struct{ name, body string }{
+		{"unclosed", "MOVQ a+0(FP),M0\nRET"},
+		{"interleaved", "MOVQ a+0(FP),M0\nMOVQ $1,AX\nEMMS\nRET"},
+		{"call", "MOVQ a+0(FP),M0\nEMMS\nCALL other(SB)\nRET"},
+		{"x87", "FLD1\nMOVQ a+0(FP),M0\nEMMS\nRET"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(a uint64) uint64", row.body)
+			if _, err := newX86NativeMMXRegion(file.Funcs[0], sig, "amd64", triple); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("incomplete source acquired another MMX/x87 role", err)
+			}
+		})
+	}
+	for _, change := range []func(*Func){
+		func(fn *Func) { fn.FrameSize = 16 },
+		func(fn *Func) { fn.Instrs[plan.begin].x86Encoded = true },
+		func(fn *Func) { fn.Instrs[plan.begin].x86AddressBits = 32 },
+	} {
+		changed := fn
+		changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+		change(&changed)
+		if _, err := newX86NativeMMXRegion(changed, sig, "amd64", triple); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("a foreign entry or physical origin borrowed the ordinary MMX region", err)
+		}
+	}
+}
+
+func TestX86NativeMMXSelfZeroAndImmediateCountDependencies(t *testing.T) {
+	for _, op := range strings.Fields("PXOR PANDN PCMPEQB PCMPEQW PCMPEQL PCMPGTB PCMPGTW PCMPGTL") {
+		plan, fn, _ := x86NativeMMXTestPlan(t, op+" M0,M0")
+		state := x86ResultState{}
+		if accepted, known := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); !accepted || !known || state.nativeMMX[0] != 0xff {
+			t.Fatal("self-zero/all-ones physical MMX operation retained a false input dependency", op)
+		}
+	}
+	for _, op := range strings.Fields("PSLLW PSLLL PSLLQ PSRLW PSRLL PSRLQ PSRAW PSRAL") {
+		plan, fn, _ := x86NativeMMXTestPlan(t, fmt.Sprintf("%s $3,M0", op))
+		state := x86ResultState{}
+		if accepted, known := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); accepted || !known {
+			t.Fatal("immediate shift count supplied missing MMX data", op)
+		}
+		state.nativeMMX[0] = 0xff
+		if accepted, _ := plan.transfer(plan.begin, fn.Instrs[plan.begin], &state, nil, 8, "amd64"); !accepted {
+			t.Fatal("complete immediate-count MMX row rejected", op)
+		}
+	}
+}
diff --git a/x86_native_owner_priority_test.go b/x86_native_owner_priority_test.go
new file mode 100644
index 000000000..de45d1ef9
--- /dev/null
+++ b/x86_native_owner_priority_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"testing"
+)
+
+// This is an ordering invariant, not a mnemonic allowlist. A newly added
+// family cannot precede any complete-source owner, even when its own
+// operand grammar would accept the same numerical bytes or native pointer.
+func TestX86ExistingSDKOwnersAreFirstNativeTransferConsumers(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_scalar_fp_native_read.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var found int
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "checkLoweredScalarFPResultInitialization" {
+			continue
+		}
+		for _, statement := range function.Body.List {
+			assignment, ok := statement.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				continue
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			transfer, literal := assignment.Rhs[0].(*ast.FuncLit)
+			if !ok || name.Name != "transfer" || !literal {
+				continue
+			}
+			found++
+			var consumers []string
+			for _, statement := range transfer.Body.List {
+				conditional, ok := statement.(*ast.IfStmt)
+				if !ok {
+					continue
+				}
+				assignment, ok := conditional.Init.(*ast.AssignStmt)
+				if !ok || len(assignment.Rhs) != 1 {
+					t.Fatal("native transfer acquired an unmodeled conditional before its owner invariant")
+				}
+				call, ok := assignment.Rhs[0].(*ast.CallExpr)
+				if !ok {
+					t.Fatal("native transfer consumer lost its direct owned call")
+				}
+				callee, ok := call.Fun.(*ast.Ident)
+				if !ok {
+					t.Fatal("native transfer acquired an unmodeled owner/receiver")
+				}
+				consumers = append(consumers, callee.Name)
+				if len(consumers) == 3 {
+					break
+				}
+			}
+			if !reflect.DeepEqual(consumers, []string{
+				"goFuncvalReadTransfer", "x86ResultSDKLiteralStep", "x86ResultNumericalReadStep",
+			}) {
+				t.Fatal("native family preempted the complete original source owners", consumers)
+			}
+		}
+	}
+	if found != 1 {
+		t.Fatal("missing or duplicate actual private native transfer source", found)
+	}
+}
diff --git a/x86_native_read_store_composition_test.go b/x86_native_read_store_composition_test.go
new file mode 100644
index 000000000..90c69cd5c
--- /dev/null
+++ b/x86_native_read_store_composition_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Keep the complete former immediate-store negatives as initialized positives.
+// The compare/widening read grants no write: its independent paired volatile
+// store still needs both the actual pointer and known numerical source bytes.
+func TestX86NativeCompareAndWideningStoresConsumeIndependentEffects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for index, op := range x86ScalarCompareNames(target.arch) {
+				name := fmt.Sprint("CompareStore", index)
+				compare := x86ScalarCompareInstruction(op, "(DX)", "$1")
+				source.WriteString(x86ScalarComparePointerSource(target.arch, name, "", compare, "MOVL $1,(DX)\n"))
+				fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+				count++
+			}
+			if target.arch == "amd64" {
+				for _, ratio := range x86ZeroExtendTestRatios {
+					for _, prefix := range []string{"P", "VP"} {
+						name := fmt.Sprint("WidenStore", count)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-12\nMOVQ p+0(FP),DX\n%sMOVZX%s (DX),X1\n"+
+							"MOVL $1,(DX)\nPEXTRD $0,X1,AX\nMOVL AX,ret+8(FP)\nRET\n", name, prefix, ratio.suffix)
+						fmt.Fprintf(&declarations, "func %s(p *[32]byte) uint32\n", name)
+						count++
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("separately checked native effects failed to compose", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if strings.Count(text, "store volatile i32 1,") != count {
+						t.Fatal("a complete independent native store was lost", api)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_nontemporal_encoder_test.go b/x86_nontemporal_encoder_test.go
new file mode 100644
index 000000000..2b4c05ff7
--- /dev/null
+++ b/x86_nontemporal_encoder_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86NonTemporalCompleteIndependentEncoderRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	legacy := strings.Join(strings.Fields(string(data)), "")
+	for _, expected := range []string{
+		"varyxr_ml=[]ytab{{Zr_m_xm,1,argList{Yxr,Yml}},}",
+		"varylddqu=[]ytab{{Zm_r,1,argList{Ym,Yxr}},}",
+		"{AMOVNTO,yxr_ml,Pe,opBytes{0xe7}}",
+		"{AMOVNTPD,yxr_ml,Pe,opBytes{0x2b}}",
+		"{AMOVNTPS,yxr_ml,Pm,opBytes{0x2b}}",
+		"{AMOVNTDQA,ylddqu,Pq4,opBytes{0x2a}}",
+	} {
+		if !strings.Contains(legacy, expected) {
+			t.Fatal("complete original Go legacy non-temporal row changed", expected)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []struct {
+		name, table, pp, opcode, opcodeMap, evexW string
+		load                                      bool
+	}{
+		{"VMOVNTDQ", "_yvmovntdq", "66", "0xE7", "0F", "0", false},
+		{"VMOVNTPD", "_yvmovntdq", "66", "0x2B", "0F", "1", false},
+		{"VMOVNTPS", "_yvmovntdq", "", "0x2B", "0F", "0", false},
+		{"VMOVNTDQA", "_yvmovntdqa", "66", "0x2A", "0F38", "0", true},
+	} {
+		var rows []goasmrules.X86AVXRule
+		var opbytes []string
+		offset := 0
+		for index, bank := range []string{"x", "y", "xEvex", "yEvex", "z"} {
+			encoding, width, word, zoffset := "vex", 128, "0", 2
+			if index >= 2 {
+				encoding, word, zoffset = "evex", expected.evexW, 3
+			}
+			if bank == "y" || bank == "yEvex" {
+				width = 256
+			} else if bank == "z" {
+				width = 512
+			}
+			prefix := fmt.Sprintf("avxEscape | %s%d", encoding, width)
+			if expected.pp != "" {
+				prefix += " | " + encoding + expected.pp
+			}
+			prefix += " | " + encoding + expected.opcodeMap + " | " + encoding + "W" + word
+			opbytes = append(opbytes, prefix)
+			if encoding == "evex" {
+				opbytes = append(opbytes, fmt.Sprintf("evexN%d", width/8))
+			}
+			opbytes = append(opbytes, expected.opcode)
+			register := "Y" + strings.Replace(bank, "Evex", "rEvex", 1)
+			if !strings.HasSuffix(bank, "Evex") {
+				register += "r"
+			}
+			classes, zcase := []string{register, "Ym"}, "Z"+encoding+"_r_v_rm"
+			if expected.load {
+				classes, zcase = []string{"Ym", register}, "Z"+encoding+"_rm_v_r"
+			}
+			rows = append(rows, goasmrules.X86AVXRule{
+				Opcode: expected.name, Ytab: expected.table, Prefix: "Pavx", Classes: classes,
+				RowIndex: index, ZCase: zcase, ZOffset: zoffset, EncodingOffset: offset,
+			})
+			offset += zoffset
+		}
+		for index := range rows {
+			rows[index].OpBytes = opbytes
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == expected.name {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, rows) {
+			t.Fatalf("complete original Go non-temporal rows/attributes changed: %s\ngot: %+v\nwant: %+v", expected.name, actual, rows)
+		}
+	}
+}
diff --git a/x86_nontemporal_encoding_test.go b/x86_nontemporal_encoding_test.go
new file mode 100644
index 000000000..7edf56b23
--- /dev/null
+++ b/x86_nontemporal_encoding_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NonTemporalCompleteOriginalNativeBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			mode, last := 32, 7
+			if arch == "amd64" {
+				mode, last = 64, 31
+			}
+			var body strings.Builder
+			for _, row := range x86NonTemporalNativeOracle {
+				if !row.vector {
+					continue
+				}
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, register := range []int{0, last} {
+						for _, memory := range []string{"(AX)", "128(AX)", "-128(AX)(CX*4)", "8(AX)(GS)"} {
+							first, second := fmt.Sprint(bank, register), memory
+							if row.load {
+								first, second = second, first
+							}
+							fmt.Fprintf(&body, "%s %s,%s\n", row.name, first, second)
+						}
+					}
+				}
+			}
+			body.WriteString("RET\n")
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, body.String())
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil || len(boundaries) != len(pcs) || len(pcs) != 97 || len(scalar) != 1 {
+				t.Fatalf("complete original Go non-temporal VEX/EVEX boundaries: count=%d scalar=%d err=%v", len(boundaries), len(scalar), err)
+			}
+			for index, boundary := range boundaries {
+				if boundary.PC != pcs[index] {
+					t.Fatal("non-temporal original Go PC changed", index, boundary, pcs[index])
+				}
+				end := int(boundary.PC) + boundary.Length
+				for cut := int(boundary.PC) + 1; cut < end; cut++ {
+					if _, _, err := x86NumericalNativeBoundaries(code[boundary.PC:cut], mode); err == nil {
+						t.Fatal("truncated non-temporal native encoding accepted", boundary.PC, cut, end)
+					}
+				}
+				if index == len(boundaries)-1 {
+					continue // The only scalar instruction is the original RET.
+				}
+				physical := code[boundary.PC:end]
+				prefix, known := decodeX86RawVectorEncoding(physical)
+				if !known {
+					t.Fatal("original Go non-temporal encoding lost its physical vector prefix")
+				}
+				if !prefix.evex {
+					continue
+				}
+				start := prefix.modRM - 5
+				for _, change := range []string{"mask", "zero", "broadcast", "length", "vvvv", "Vprime", "fixed", "word", "register"} {
+					changed := append([]byte(nil), physical...)
+					switch change {
+					case "mask":
+						changed[start+3] |= 1
+					case "zero":
+						changed[start+3] |= 0x80
+					case "broadcast":
+						changed[start+3] |= 0x10
+					case "length":
+						changed[start+3] |= 0x60
+					case "vvvv":
+						changed[start+2] &^= 8
+					case "Vprime":
+						changed[start+3] &^= 8
+					case "fixed":
+						changed[start+2] &^= 4
+					case "word":
+						changed[start+2] ^= 0x80
+					case "register":
+						changed[prefix.modRM] |= 0xc0
+					}
+					if _, _, err := x86NumericalNativeBoundaries(changed, mode); err == nil {
+						t.Fatal("reserved non-temporal encoding acquired a native boundary", change, physical)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86NonTemporalVEXWIsIgnoredUnlikeEVEX(t *testing.T) {
+	// Intel SDM's four VEX rows are WIG, although Go emits W0. The
+	// independent EVEX mutation controls above require each exact W0/W1.
+	for _, row := range []struct {
+		name string
+		code []byte
+	}{
+		{"VMOVNTDQ", []byte{0xc4, 0xe1, 0x79, 0xe7, 0x03}},
+		{"VMOVNTPD", []byte{0xc4, 0xe1, 0x79, 0x2b, 0x03}},
+		{"VMOVNTPS", []byte{0xc4, 0xe1, 0x78, 0x2b, 0x03}},
+		{"VMOVNTDQA", []byte{0xc4, 0xe2, 0x79, 0x2a, 0x03}},
+	} {
+		for _, mode := range []int{32, 64} {
+			for _, word := range []byte{0, 0x80} {
+				code := append([]byte(nil), row.code...)
+				code[2] |= word
+				ins, length, known, err := decodedX86VEXNonTemporalMoveInstruction(code, mode)
+				if !known || err != nil || ins.Op != Op(row.name) || length != len(code) {
+					t.Fatal("valid physical VEX.WIG form lost its native identity", row.name, mode, word, err)
+				}
+				boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+				if err != nil || len(boundaries) != 1 || len(scalar) != 0 {
+					t.Fatal("VEX.WIG move became a scalar or incomplete native boundary", row.name, mode, word, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_nontemporal_native_test.go b/x86_nontemporal_native_test.go
new file mode 100644
index 000000000..79b67fd6d
--- /dev/null
+++ b/x86_nontemporal_native_test.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent of lowering: all legacy names/Go aliases and both complete AVX
+// tables, including native dead loads and the legacy Yml register #UD rows.
+var x86NonTemporalNativeOracle = []struct {
+	name, native string
+	vector, load bool
+}{
+	{"MOVNTO", "movntdq", false, false},
+	{"MOVNTDQ", "movntdq", false, false},
+	{"MOVNTPD", "movntpd", false, false},
+	{"MOVNTPS", "movntps", false, false},
+	{"MOVNTDQA", "movntdqa", false, true},
+	{"VMOVNTDQ", "vmovntdq", true, false},
+	{"VMOVNTPD", "vmovntpd", true, false},
+	{"VMOVNTPS", "vmovntps", true, false},
+	{"VMOVNTDQA", "vmovntdqa", true, true},
+}
+
+func TestX86NonTemporalVectorNativeByteAndSourceBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86NonTemporalNativeOracle {
+			banks := []string{"X"}
+			if row.vector {
+				banks = []string{"X", "Y", "Z"}
+			}
+			for _, bank := range banks {
+				t.Run(arch+"/"+row.name+"/"+bank, func(t *testing.T) {
+					text := row.name + " " + bank + "1,(AX)"
+					if row.load {
+						text = row.name + " (AX)," + bank + "1"
+					}
+					ins := x86ScalarLaneInstruction(t, text)
+					width := int64(amd64VectorByteWidth(Reg(bank + "1")))
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.pointerGP[0] = true
+					state.writeVector(1, 64, ^uint64(0), false)
+					if row.load {
+						// Sparse old aliases distinguish a new definition from an
+						// accidental no-op and legacy preservation from VEX clearing.
+						state.writeVector(1, 64, 0xaaaaaaaaaaaaaaaa, false)
+					}
+					before := state.clone()
+					expected := before.clone()
+					if row.load {
+						expectedBytes := ^uint64(0)
+						if !row.vector {
+							expectedBytes = before.vectorBytes(1) | x86CallerVectorByteMask(width)
+						}
+						expected.writeVector(1, 64, expectedBytes, false)
+					}
+					if accepted, known := x86ResultNonTemporalVectorStep(ins, &state, nil, 0, arch, true); !known || !accepted || !reflect.DeepEqual(state, expected) {
+						t.Fatal("complete native move changed flags, pointers or unrelated byte domains")
+					}
+					if accepted, _ := x86ResultNonTemporalVectorStep(ins, &state, nil, 0, arch, false); accepted {
+						t.Fatal("standalone query acquired a paired native access")
+					}
+					for _, change := range []string{"pointer", "numeric base", "index", "raw", "address size"} {
+						changed, current := ins, before.clone()
+						changed.Args = append([]Operand(nil), ins.Args...)
+						memory := 1
+						if row.load {
+							memory = 0
+							current.writeVector(1, 64, 0, false)
+						}
+						initial := current.clone()
+						switch change {
+						case "pointer", "numeric base":
+							current.pointerGP[0] = false
+							if change == "numeric base" {
+								current.gp[0] = 0xff
+							}
+							initial = current.clone()
+						case "index":
+							changed.Args[memory].Mem.Index, changed.Args[memory].Mem.Scale = DX, 2
+						case "raw":
+							changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+						case "address size":
+							changed.x86AddressBits = 16
+						}
+						if accepted, known := x86ResultNonTemporalVectorStep(changed, &current, nil, 0, arch, true); !known || accepted || !reflect.DeepEqual(current, initial) {
+							t.Fatal("unproved source supplied native bytes or changed state", change)
+						}
+					}
+					if !row.load {
+						for missing := int64(0); missing < width; missing++ {
+							current := before.clone()
+							current.writeVector(1, 64, ^(uint64(1) << uint(missing)), false)
+							if accepted, _ := x86ResultNonTemporalVectorStep(ins, &current, nil, 0, arch, true); accepted {
+								t.Fatal("non-temporal store invented a missing vector byte", missing)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NonTemporalVectorVoidCannotHideNativeInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86NonTemporalNativeOracle {
+			for _, unusedBool := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/bool-%t", arch, row.name, unusedBool), func(t *testing.T) {
+					source, _ := x86NonTemporalNativeProgram(arch, row.name, "X", 1, row.vector, row.load, true)
+					body := source[strings.Index(source, "\n")+1:]
+					body = strings.Replace(body, fmt.Sprintf("MOVL CX,ret+%d(FP)\n", word), "", 1)
+					arguments, declaration := word, "func Value(p *[64]byte)"
+					if unusedBool {
+						arguments++
+						declaration = "func Value(p *[64]byte,unused bool)"
+					}
+					source = fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", arguments, body)
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+							t.Fatal("complete Void source lost its native effect", api, err)
+						}
+						changed := strings.Replace(source, move+" p+0(FP),AX\n", "", 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool invented its native pointer", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86NonTemporalNativeProgram(arch, name, bank string, register int, vector, load, dead bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	reg := fmt.Sprint(bank, register)
+	body := move + " p+0(FP),AX\n"
+	if load {
+		body += name + " (AX)," + reg + "\n"
+	} else {
+		zero := fmt.Sprintf("PXOR X%d,X%d\n", register, register)
+		if vector {
+			zero = fmt.Sprintf("VXORPS %s,%s,%s\n", reg, reg, reg)
+			if bank == "Z" || register >= 16 {
+				zero = fmt.Sprintf("VPXORD Z%d,Z%d,Z%d\n", register, register, register)
+			}
+		}
+		body += zero + name + " " + reg + ",(AX)\nSFENCE\n"
+	}
+	if load && !dead {
+		if register != 0 {
+			copy := "MOVOU"
+			if vector {
+				copy = "VMOVUPS"
+			}
+			body += fmt.Sprintf("%s X%d,X0\n", copy, register)
+		}
+		body += "MOVL X0,CX\n"
+	} else {
+		body += "MOVL $7,CX\n"
+	}
+	body += fmt.Sprintf("MOVL CX,ret+%d(FP)\nRET\n", word)
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word+4, body),
+		"func Value(p *[64]byte) uint32"
+}
+
+func TestX86NonTemporalVectorNativeCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for _, row := range x86NonTemporalNativeOracle {
+				banks := []string{"X"}
+				if row.vector {
+					banks = []string{"X", "Y", "Z"}
+				}
+				for _, bank := range banks {
+					last := 7
+					if target.arch == "amd64" {
+						last = 15
+						if row.vector {
+							last = 31
+						}
+					}
+					for _, register := range []int{0, last} {
+						deadCases := []bool{false}
+						if row.load {
+							deadCases = append(deadCases, true)
+						}
+						for _, dead := range deadCases {
+							body, declaration := x86NonTemporalNativeProgram(target.arch, row.name, bank,
+								register, row.vector, row.load, dead)
+							name := fmt.Sprint("Stream", len(names))
+							names = append(names, name)
+							source.WriteString(strings.ReplaceAll(body, "Value", name))
+							declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+						}
+					}
+				}
+			}
+			if len(names) != 42 {
+				t.Fatal("incomplete independent non-temporal matrix", len(names))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete non-temporal program lost its native inputs", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						if strings.Count(text, "asm sideeffect") < len(names) {
+							t.Fatal("native alignment/dead-access effects became optional LLVM cache hints")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NonTemporalLegacyRegisterDestinationTrapsBeforeInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range []string{"MOVNTO", "MOVNTDQ", "MOVNTPD", "MOVNTPS"} {
+			for _, destination := range []string{"AX", "DI", "SP"} {
+				t.Run(target.triple+"/"+name+"/"+destination, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-0\n" + name + " X0," + destination + "\nRET\n"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+						if err != nil || !strings.Contains(ir, "ud2") || !strings.Contains(ir, "unreachable") {
+							t.Fatal("invalid native ModRM register destination did not fault before inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_numeric_native_address_runtime_test.go b/x86_numeric_native_address_runtime_test.go
new file mode 100644
index 000000000..1b6df54ae
--- /dev/null
+++ b/x86_numeric_native_address_runtime_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func x86NumericAddressProgram(arch string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations string
+	for _, row := range []struct {
+		name, parameter string
+		indirect, store bool
+	}{
+		{"NumericLoad", "uintptr", false, false},
+		{"IndirectLoad", "*uintptr", true, false},
+		{"NumericStore", "uintptr", false, true},
+		{"IndirectStore", "*uintptr", true, true},
+	} {
+		source += fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n", row.name, word+4, move)
+		if row.indirect {
+			source += move + " (AX),AX\n"
+		}
+		if row.store {
+			source += "MOVL $42,(AX)\nMOVL $42,CX\n"
+		} else {
+			source += "MOVL (AX),CX\n"
+		}
+		source += fmt.Sprintf("MOVL CX,ret0+%d(FP)\nRET\n", word)
+		declarations += fmt.Sprintf("func %s(p %s) uint32\n", row.name, row.parameter)
+	}
+	return source, declarations
+}
+
+const x86NumericAddressPrototypes = `
+#include <stdint.h>
+extern uint32_t NumericLoad(uintptr_t);
+extern uint32_t IndirectLoad(const uintptr_t*);
+extern uint32_t NumericStore(uintptr_t);
+extern uint32_t IndirectStore(const uintptr_t*);
+`
+
+func x86NumericAddressRuntimeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc and clang are required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	execution := x86FloatCompareExecution{llc: llc, triple: triple,
+		compiler: []string{clang, "-target", triple}}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		defer cancel()
+		execution.compiler = runtimeOracleNativeCCommand(t, ctx, clang, "-target", triple).Args
+	}
+	return execution
+}
+
+func TestX86InitializedNumericNativeAddressValues(t *testing.T) {
+	execution := x86NumericAddressRuntimeTools(t)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	source, declarations := x86NumericAddressProgram(arch)
+	driver := x86NumericAddressPrototypes + `
+#include <string.h>
+int main(void) {
+    for (unsigned seed = 0; seed < 257; ++seed) {
+        for (unsigned offset = 0; offset < 4; ++offset) {
+            uint8_t data[16], before[16];
+            for (unsigned i = 0; i < sizeof(data); ++i) data[i] = (uint8_t)(seed + i * 17);
+            memcpy(before, data, sizeof(data));
+            uintptr_t address = (uintptr_t)(data + offset);
+            uint32_t expected;
+            memcpy(&expected, data + offset, sizeof(expected));
+            if (NumericLoad(address) != expected || IndirectLoad(&address) != expected) return 1;
+            if (memcmp(data, before, sizeof(data))) return 2;
+            if (NumericStore(address) != 42) return 3;
+            memcpy(before + offset, &(uint32_t){42}, sizeof(uint32_t));
+            if (memcmp(data, before, sizeof(data))) return 4;
+            memset(data + offset, 0xa5, sizeof(uint32_t));
+            if (IndirectStore(&address) != 42 || memcmp(data, before, sizeof(data))) return 5;
+        }
+    }
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				input := ir
+				if level == "-O2" {
+					input = x86DwordProductIROptimize(t, input)
+				}
+				executable := execution.compileLLVM(t, "numeric-address-values", input, driver, level)
+				execution.run(t, executable)
+			}
+		})
+	}
+}
+
+func TestX86InitializedNumericNativeAddressFaults(t *testing.T) {
+	execution := x86NumericAddressRuntimeTools(t)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	source, declarations := x86NumericAddressProgram(arch)
+	callbacks := x86NumericAddressPrototypes + `
+static int load(const uint8_t *p) {
+    volatile uint32_t value = NumericLoad((uintptr_t)p);
+    (void)value;
+    return 0;
+}
+static int indirect_load(const uint8_t *p) {
+    uintptr_t address = (uintptr_t)p;
+    volatile uint32_t value = IndirectLoad(&address);
+    (void)value;
+    return 0;
+}
+static int store(const uint8_t *p) {
+    return NumericStore((uintptr_t)p) == 42 ? 0 : 91;
+}
+static int indirect_store(const uint8_t *p) {
+    uintptr_t address = (uintptr_t)p;
+    return IndirectStore(&address) == 42 ? 0 : 91;
+}
+`
+	driver := x86MemoryFaultDriver(callbacks, "{load,4,3},{indirect_load,4,3},{store,4,3},{indirect_store,4,3},")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				input := ir
+				if level == "-O2" {
+					input = x86DwordProductIROptimize(t, input)
+				}
+				executable := execution.compileLLVM(t, "numeric-address-faults", input, driver, level)
+				x86CheckMemoryFaultMatrix(t, execution, executable, 4)
+			}
+		})
+	}
+	t.Logf("portable memory execution on %s/%s; no original x86 execution claim", runtime.GOOS, runtime.GOARCH)
+}
diff --git a/x86_numeric_native_address_test.go b/x86_numeric_native_address_test.go
new file mode 100644
index 000000000..663f636e3
--- /dev/null
+++ b/x86_numeric_native_address_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86RequireNumericNativeSourceContext(t *testing.T, source, declaration, arch string) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "numeric", "package numeric\n"+declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		if err := CheckX86ABI0ResultInitialization(fn, signatures[resolve(fn.Sym)], arch); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("paired numerical address became a standalone result or storage proof", err)
+		}
+	}
+}
+
+func x86NumericNativeAddressObject(t *testing.T, ir, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+}
+
+// E4NF may load one typed tuple; masked E4 loads one integer per active
+// lane. Count the potential bytes in either IR representation independently
+// of the production memory-shape parser. This is not an execution count.
+func x86NumericNativeVolatileReadBytes(t *testing.T, ir string) int {
+	t.Helper()
+	bytes := 0
+	for _, match := range regexp.MustCompile(`load volatile (?:i([0-9]+)|<([0-9]+) x i([0-9]+)>),`).FindAllStringSubmatch(ir, -1) {
+		lanes, bits := 1, match[1]
+		if match[2] != "" {
+			var err error
+			lanes, err = strconv.Atoi(match[2])
+			if err != nil {
+				t.Fatal(err)
+			}
+			bits = match[3]
+		}
+		width, err := strconv.Atoi(bits)
+		if err != nil || width%8 != 0 || width <= 0 {
+			t.Fatal("unexpected volatile integer read type", match[0], err)
+		}
+		bytes += lanes * width / 8
+	}
+	return bytes
+}
+
+// A numerical-base variant changes address bits, not the original memory
+// operations. Keep widths, access order/count, volatile markers and exact asm
+// constraints equal to the initialized-pointer counterpart; SSA names differ.
+func x86RequireSameNativeMemoryEffects(t *testing.T, before, after string) {
+	t.Helper()
+	effects := func(ir string) []string {
+		var result []string
+		pattern := regexp.MustCompile(`(?:load|store) volatile (?:<[^>]+>|i[0-9]+|float|double)|asm sideeffect "(?:\\.|[^"\\])*", "(?:\\.|[^"\\])*"`)
+		for _, line := range strings.Split(ir, "\n") {
+			if match := pattern.FindString(line); match != "" {
+				if strings.HasPrefix(match, "asm ") && (!strings.Contains(match, "~{memory}") || strings.Contains(match, `asm sideeffect ""`)) {
+					continue // Register-only FP exceptions and empty barriers are not memory accesses.
+				}
+				result = append(result, match)
+			}
+		}
+		return result
+	}
+	want, got := effects(before), effects(after)
+	if len(want) == 0 || !reflect.DeepEqual(want, got) {
+		t.Fatal("numerical address changed its original native memory effects", want, got)
+	}
+}
+
+// An initialized machine address can arrive as uintptr or as loaded bits.
+// This does not turn it into a logical pointer or prove any pointee bytes.
+func TestX86InitializedNumericNativeAddressesThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := x86ResultPointerWord(target.arch), "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		input := move + " p+0(FP),AX\n"
+		rows := []struct {
+			name, declaration, body string
+			accept                  bool
+		}{
+			{"uintptr-load", "func Value(p uintptr) uint32", input + "MOVL (AX),CX\n", true},
+			{"loaded-address", "func Value(p *uintptr) uint32", input + move + " (AX),AX\nMOVL (AX),CX\n", true},
+			{"uintptr-store", "func Value(p uintptr) uint32", input + "MOVL $42,(AX)\nMOVL $42,CX\n", true},
+			{"loaded-address-store", "func Value(p *uintptr) uint32", input + move + " (AX),AX\nMOVL $42,(AX)\nMOVL $42,CX\n", true},
+			{"known-null-load", "func Value(p uintptr) uint32", move + " $0,AX\nMOVL (AX),CX\n", true},
+			{"unknown-base", "func Value(p uintptr) uint32", "MOVL (AX),CX\n", false},
+			{"partial-base", "func Value(p uintptr) uint32", "MOVB p+0(FP),AX\nMOVL (AX),CX\n", false},
+			{"unknown-store-value", "func Value(p uintptr) uint32", input + "MOVL DX,(AX)\nMOVL $42,CX\n", false},
+		}
+		for _, row := range rows {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				body := row.body + fmt.Sprintf("MOVL CX,ret0+%d(FP)\nRET", word)
+				_, file, sig, source := x86ResultInitializationFixture(t, target.arch, row.declaration, body)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone query acquired a native-memory observation", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+						if !row.accept {
+							if err == nil || ir != "" {
+								t.Fatal("undefined address/value input accepted", err)
+							}
+							return
+						}
+						if err != nil || !strings.Contains(ir, "volatile") {
+							t.Fatal("initialized machine address lost its native memory effect", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numeric_tuple_entry_test.go b/x86_numeric_tuple_entry_test.go
new file mode 100644
index 000000000..ed1ff5615
--- /dev/null
+++ b/x86_numeric_tuple_entry_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Successful lowering may preserve an output-only failure, never turn that
+// failure into a complete source/storage proof. The public query is stricter
+// than this paired transfer, including for native and x87 inputs.
+func x86PartialTupleCodegenControl(t *testing.T, source, declaration, arch, triple, ir string, err error) {
+	t.Helper()
+	if err != nil || ir == "" {
+		t.Fatal("ordinary partial tuple lost code generation", err)
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, "#include \"textflag.h\"\n"+source)
+	x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+	pkg := mustGoPackage(t, "partialtuple", "package partialtuple\n"+declaration)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, fn := range file.Funcs {
+		fn.x86ResultFlowBudget = new(x86ResultFlowBudget)
+		ctx := newX86Ctx(new(strings.Builder), fn, sigs[resolve(fn.Sym)], resolve, sigs, arch, triple, false)
+		if err := ctx.scalarFPResultInitialized(); err != nil {
+			t.Fatal("paired source inputs did not close before the output-only failure", err)
+		}
+		strict, visits := ctx.fpScalarCheckErr, fn.x86ResultFlowBudget.visits
+		if _, exact := strict.(*x86IncompleteResultError); !exact || visits == 0 || ctx.abi0BoolResultByteStorage() {
+			t.Fatal("partial code generation acquired complete-proof storage", strict, visits)
+		}
+		if err := ctx.scalarFPResultInitialized(); err != nil || ctx.fpScalarCheckErr != strict || fn.x86ResultFlowBudget.visits != visits {
+			t.Fatal("a repeated consumer lost the strict cached output failure", err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+		for _, level := range []string{"-O0", "-O2"} {
+			x86PackedStringCompileObject(t, llc, triple, text, level)
+		}
+	}
+}
+
+func TestX86OrdinaryScalarTupleAllPublicRoutesRequireInputs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, initialized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/initialized=%t", arch, initialized), func(t *testing.T) {
+				body := "MOVL $-1,first+0(FP)\nMOVL AX,second+4(FP)\nRET"
+				if initialized {
+					body = "MOVL $7,AX\n" + body
+				}
+				declaration := "func Value() (first,second uint32)"
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				strict := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+				if initialized && strict != nil || !initialized && !errors.Is(strict, ErrProbeNeedsContext) {
+					t.Fatal("the independent source audit changed input availability", strict)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if !initialized {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("a public lowering route supplied an undeclared GP input", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("the initialized original MOVL forms lost code generation", err)
+						}
+						x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{0xffffffff, 7})
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numerical_adx_boundaries_test.go b/x86_numerical_adx_boundaries_test.go
new file mode 100644
index 000000000..86db0a0e7
--- /dev/null
+++ b/x86_numerical_adx_boundaries_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// The independent TestX86ADXGrammarMatchesCompleteGoEncoder owns all four
+// yml_rl/Pq4/Pq4w/Pq5/Pq5w rows. These concrete original-Go/LLVM witnesses
+// require a separate physical-PC consumer, not an invented x86asm scalar op.
+func TestX86NumericalADXCompletePhysicalBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue // Go rejects Q-width ADX outside long mode.
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				var rows []string
+				for _, input := range []string{
+					"AX", "(AX)", "127(AX)", "-128(AX)", "-129(AX)", "128(AX)",
+					"-2147483648(BX)", "2147483647(BX)", "0x12345678",
+					"19(AX)(CX*1)", "19(AX)(CX*2)", "19(AX)(CX*4)", "19(AX)(CX*8)",
+					"8(AX)(FS)", "8(AX)(GS)",
+				} {
+					rows = append(rows, op+" "+input+",DX")
+				}
+				if arch == "amd64" {
+					rows = append(rows, op+" R13,R15", op+" -129(R11)(R9*4),R12")
+				}
+				code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPL AX,$1\nRET")
+				want, mode := 17, 64
+				if arch == "386" {
+					want, mode = 15, 32
+				}
+				if len(rows) != want || len(pcs) != len(rows)+2 {
+					t.Fatal("complete original ADX width/address/REX inventory changed", len(rows), pcs)
+				}
+				// Independently bind the mandatory prefix, map, opcode and
+				// REX.W on every actual instruction before observing its PC.
+				prefix := byte(0x66)
+				if strings.HasPrefix(op, "ADOX") {
+					prefix = 0xf3
+				}
+				for index := range rows {
+					instruction := code[pcs[index]:pcs[index+1]]
+					at := bytes.Index(instruction, []byte{0x0f, 0x38, 0xf6})
+					if at < 1 || !bytes.Contains(instruction[:at], []byte{prefix}) {
+						t.Fatal("actual Go lost an original mandatory ADX prefix/map", rows[index], instruction)
+					}
+					wide := instruction[at-1]&0xf8 == 0x48
+					if wide != strings.HasSuffix(op, "Q") {
+						t.Fatal("mandatory 66 was mistaken for operand width or REX.W was lost", rows[index], instruction)
+					}
+				}
+				x86NumericalNativeRequireMC(t, code, mode, len(pcs), "+adx")
+				boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+				if err != nil || len(boundaries) != len(pcs) || len(scalar) != 2 {
+					t.Fatal("complete legacy ADX native boundaries need a non-scalar observer", boundaries, scalar, err)
+				}
+				for index, pc := range pcs {
+					end := int64(len(code))
+					if index+1 < len(pcs) {
+						end = pcs[index+1]
+					}
+					if boundaries[index] != (x86NumericalNativeBoundary{PC: pc, Length: int(end - pc)}) {
+						t.Fatal("original complete Go ADX PC/length changed", index, boundaries[index], pc, end)
+					}
+					if index < len(rows) {
+						if _, exists := scalar[pc]; exists {
+							t.Fatal("physical ADX boundary acquired an SDK scalar-read role", pc)
+						}
+					}
+				}
+				if scalar[pcs[len(rows)]].Op != x86asm.CMP || scalar[pcs[len(rows)+1]].Op != x86asm.RET {
+					t.Fatal("ADX registration displaced independent scalar CMP/RET", scalar)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NumericalADXRIPBoundaryKeepsSourceRoles(t *testing.T) {
+	for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+		for _, offset := range []int{-17, 17} {
+			t.Run(fmt.Sprintf("%s/%+d", op, offset), func(t *testing.T) {
+				code, pcs, listing := x86NumericalBoundaryGoBytesAndListing(t, "amd64", fmt.Sprintf("%s table%+d(SB),BX\nRET", op, offset))
+				disp, width := 5, 4
+				if strings.HasSuffix(op, "Q") {
+					disp, width = 6, 8
+				}
+				length := int64(disp + 4)
+				if !reflect.DeepEqual(pcs, []int64{0, length}) || len(code) != int(length)+1 {
+					t.Fatalf("actual Go ADX RIP relocation/extent prerequisite differs: %x %v\n%s", code, pcs, listing)
+				}
+				x86NumericalRequirePCRelListing(t, listing, disp, offset)
+				x86NumericalNativeRequireMC(t, code, 64, 2, "+adx")
+				// The existing raw decoder requires real in-group literal bytes,
+				// whereas physical PC observation must not require or patch them.
+				if _, _, _, known, err := decodeX86RawADX(code, 0, 64); !known || err == nil {
+					t.Fatal("unlinked native RIP displacement acquired source-local DATA", known, err)
+				}
+				boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+				if err != nil || !reflect.DeepEqual(boundaries, []x86NumericalNativeBoundary{{PC: 0, Length: int(length)}, {PC: length, Length: 1}}) ||
+					len(scalar) != 1 || scalar[length].Op != x86asm.RET {
+					t.Fatal("native ADX RIP must own only length/PC, not a scalar source", boundaries, scalar, err)
+				}
+				reads, err := numericalNativeReads(code, 64)
+				if err != nil || len(reads) != 0 {
+					t.Fatal("physical ADX invented an SDK numerical-read owner", reads, err)
+				}
+				// Preserve the separate preexisting source-local raw literal
+				// contract, rather than accidentally deleting it to pass a guard.
+				literal := append([]byte(nil), code...)
+				binary.LittleEndian.PutUint32(literal[disp:disp+4], 1)
+				literal = append(literal, bytes.Repeat([]byte{7}, width)...)
+				decoded, err := decodeX86RawDirectiveGroup(literal, 64, 0, op, map[string]bool{})
+				if err != nil || len(decoded) != 2 || decoded[0].Op != Op(op) || len(decoded[0].x86RIPLiteralData) != width {
+					t.Fatal("physical observer changed the original complete raw-literal role", decoded, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86NumericalADXBoundaryGuardsAndMissingInputs(t *testing.T) {
+	for _, op := range []string{"ADCXL", "ADCXQ", "ADOXL", "ADOXQ"} {
+		t.Run(op, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", op+" AX,BX\nRET")
+			code = code[:pcs[1]]
+			x86NumericalNativeRequireMC(t, code, 64, 1, "+adx")
+			at := bytes.Index(code, []byte{0x0f, 0x38, 0xf6})
+			badPrefix := append([]byte(nil), code...)
+			badPrefix[0] = 0xf2
+			badMap := append([]byte(nil), code...)
+			badMap[at+1] = 0x39
+			controls := [][]byte{
+				append([]byte{0xf0}, code...), badPrefix, badMap,
+				append(bytes.Repeat([]byte{0x67}, 16), code...),
+				append(append([]byte(nil), code...), 0xe8, 0, 0, 0, 0, 0xc3),
+			}
+			for cut := 1; cut < len(code); cut++ {
+				controls = append(controls, code[:cut])
+			}
+			for _, control := range controls {
+				for _, prefix := range [][]byte{nil, {0x90, 0xc3}} {
+					whole := append(append([]byte(nil), prefix...), control...)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(whole, 64)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatal("invalid/unreachable/calling ADX TEXT retained a partial observation", whole, err)
+					}
+				}
+			}
+			move := "MOVL"
+			if strings.HasSuffix(op, "Q") {
+				move = "MOVQ"
+			}
+			// Independent status and destination are initialized. The only
+			// absent input is BX's pointer, not a legitimate dead DATA value.
+			source := "TEXT ·Value(SB),4,$0-0\n" + move + " $0,AX\nXORL AX,AX\n" + op + " (BX),AX\nRET\n"
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("a physical ADX boundary granted a missing address/NUM input", api, err)
+				}
+			}
+		})
+	}
+	// In mode32 0x48 is DEC AX, never a Q-width REX prefix on ADX.
+	code, pcs := x86NumericalBoundaryGoBytes(t, "386", "DECL AX\nADCXL AX,BX\nRET")
+	x86NumericalNativeRequireMC(t, code, 32, 3, "+adx")
+	for _, mode := range []int{0, 16, 128} {
+		boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+		if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+			t.Fatal("ADX bytes inferred a physical source mode instead of checking its actual owner", mode, err)
+		}
+	}
+	boundaries, scalar, err := x86NumericalNativeBoundaries(code, 32)
+	if err != nil || len(boundaries) != 3 || len(scalar) != 2 || scalar[pcs[0]].Op != x86asm.DEC || scalar[pcs[2]].Op != x86asm.RET {
+		t.Fatal("mode32 legacy DEC became an ADX Q-prefix/scalar read", boundaries, scalar, err)
+	}
+}
diff --git a/x86_numerical_broadcast128_boundary_test.go b/x86_numerical_broadcast128_boundary_test.go
new file mode 100644
index 000000000..1b3aa8df3
--- /dev/null
+++ b/x86_numerical_broadcast128_boundary_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalBroadcast128OriginalGoBoundaries(t *testing.T) {
+	// Both official _yvbroadcastf128 rows are VEX.256.66.0F38.W0,
+	// memory-only m128 -> Y. Source addresses and physical banks are
+	// orthogonal to the F/I opcode; original Go supplies every byte and PC.
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			mode, last := 32, 7
+			addresses := []string{"(AX)", "-128(AX)", "127(AX)", "-129(AX)", "128(AX)",
+				"(SP)", "(BP)", "(AX)(CX*1)", "32(AX)(CX*2)", "-32(AX)(DX*4)",
+				"305419896(AX)(BX*8)", "64(CX*4)", "305419896", "table+16(SB)", "8(AX)(FS)", "8(AX)(GS)"}
+			if arch == "amd64" {
+				mode, last = 64, 15
+				addresses = append(addresses, "(R8)", "128(R15)(R9*8)", "-129(R12)(R13*2)", "(R13)")
+			}
+			var rows []string
+			for _, op := range []string{"VBROADCASTF128", "VBROADCASTI128"} {
+				for _, address := range addresses {
+					for _, destination := range []int{0, last} {
+						rows = append(rows, fmt.Sprintf("%s %s,Y%d", op, address, destination))
+					}
+				}
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nRET")
+			if len(pcs) != len(rows)+1 {
+				t.Fatal("original Go did not preserve every complete family row", len(rows), len(pcs))
+			}
+			original := bytes.Clone(code)
+			for index, row := range rows {
+				t.Run(fmt.Sprint(index), func(t *testing.T) {
+					instruction := code[pcs[index]:pcs[index+1]]
+					length, err := x86NumericalVectorBoundary(instruction, mode)
+					if err != nil || length != len(instruction) {
+						t.Fatalf("actual Go %s: boundary=%d/%d: %v", row, length, len(instruction), err)
+					}
+					if mode == 64 && strings.Contains(row, "(SB)") {
+						if _, _, known, err := decodedX86VBROADCAST128Instruction(instruction, mode); !known || err == nil {
+							t.Fatal("physical RIP observation granted a raw source address", known, err)
+						}
+					}
+					for end := 0; end < len(instruction); end++ {
+						if _, err := x86NumericalVectorBoundary(instruction[:end], mode); err == nil {
+							t.Fatalf("accepted truncated original %s at %d/%d", row, end, len(instruction))
+						}
+					}
+				})
+			}
+			boundaries, _, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil || len(boundaries) != len(pcs) || !bytes.Equal(code, original) {
+				t.Fatal("complete original machine boundary inventory changed", err, len(boundaries), len(pcs))
+			}
+			for index, boundary := range boundaries {
+				if boundary.PC != pcs[index] {
+					t.Fatal("machine boundary lost its original Go PC", index, boundary, pcs[index])
+				}
+			}
+		})
+	}
+}
+
+func TestX86NumericalBroadcast128RejectsReservedEncodings(t *testing.T) {
+	for _, opcode := range []byte{0x1a, 0x5a} {
+		for _, mode := range []int{32, 64} {
+			for _, row := range []struct {
+				name string
+				code []byte
+			}{
+				{"register", []byte{0xc4, 0xe2, 0x7d, opcode, 0xc1}},
+				{"width128", []byte{0xc4, 0xe2, 0x79, opcode, 0x13}},
+				{"vvvv", []byte{0xc4, 0xe2, 0x75, opcode, 0x13}},
+				{"W1", []byte{0xc4, 0xe2, 0xfd, opcode, 0x13}},
+				{"address_override", []byte{0x67, 0xc4, 0xe2, 0x7d, opcode, 0x13}},
+			} {
+				t.Run(fmt.Sprintf("%x/%d/%s", opcode, mode, row.name), func(t *testing.T) {
+					if _, err := x86NumericalVectorBoundary(row.code, mode); err == nil {
+						t.Fatalf("unregistered physical format became a native boundary: %x", row.code)
+					}
+				})
+			}
+		}
+		for _, prefix := range []byte{0x62, 0xc2, 0xa2} {
+			t.Run(fmt.Sprintf("%x/386/extended_%x", opcode, prefix), func(t *testing.T) {
+				code := []byte{0xc4, prefix, 0x7d, opcode, 0x14, 0x88}
+				if _, err := x86NumericalVectorBoundary(code, 32); err == nil {
+					t.Fatalf("extended physical bank became a 386 boundary: %x", code)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numerical_broadcast_family_boundary_test.go b/x86_numerical_broadcast_family_boundary_test.go
new file mode 100644
index 000000000..c2c8d08ad
--- /dev/null
+++ b/x86_numerical_broadcast_family_boundary_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalBroadcastCompleteOriginalFamily(t *testing.T) {
+	// The same independent directory is checked against every original Go
+	// opcode attribute and ytab row by TestX86BroadcastCompleteIndependentGoRows.
+	// Boundary observation must consume the complete existing broadcast grammar,
+	// even when a particular typed storage consumer supports only VEX forms.
+	for _, arch := range []string{"amd64", "386"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		var sources []string
+		for _, spec := range x86BroadcastTestDirectory {
+			inputs := []string{"65(AX)", "table+16(SB)"}
+			for _, kind := range spec.source {
+				inputs = append(inputs, map[rune]string{'X': "X3", 'G': "AX", 'K': "K0"}[kind])
+			}
+			if spec.source == "K" {
+				inputs = inputs[2:]
+			}
+			destinations := []int{7}
+			if arch == "amd64" && !strings.HasSuffix(spec.name, "128") {
+				destinations = append(destinations, 23) // Force unmasked narrow EVEX too.
+				if strings.Contains(spec.source, "X") {
+					inputs = append(inputs, "X19")
+				}
+			}
+			for _, bank := range spec.destinations {
+				for _, input := range inputs {
+					for masking := 0; masking < 3; masking++ {
+						if masking != 0 && (spec.source == "K" || strings.HasSuffix(spec.name, "128")) {
+							continue
+						}
+						op, mask := spec.name, ""
+						if masking != 0 {
+							mask = "K1,"
+						}
+						if masking == 2 {
+							op += ".Z"
+						}
+						for _, destination := range destinations {
+							sources = append(sources, fmt.Sprintf("%s %s,%s%c%d", op, input, mask, bank, destination))
+						}
+					}
+				}
+			}
+		}
+		code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(sources, "\n")+"\nRET")
+		if len(pcs) != len(sources)+1 {
+			t.Fatal("complete original broadcast inventory changed", len(pcs), len(sources))
+		}
+		original := bytes.Clone(code)
+		for index, source := range sources {
+			t.Run(arch+"/"+source, func(t *testing.T) {
+				instruction := code[pcs[index]:pcs[index+1]]
+				length, err := x86NumericalVectorBoundary(instruction, mode)
+				if err != nil || length != len(instruction) {
+					t.Fatalf("actual Go %s (%x): boundary=%d/%d: %v", source, instruction, length, len(instruction), err)
+				}
+				decoded, size, known, err := decodedX86NumericalBroadcastBoundary(instruction, mode, x86RawMemoryDecoder{})
+				if mode == 64 && strings.Contains(source, "(SB)") {
+					if !known || err == nil {
+						t.Fatal("physical boundary granted a raw RIP address", known, err)
+					}
+				} else if !known || err != nil || size != len(instruction) || string(decoded.Op) != strings.Fields(source)[0] {
+					t.Fatal("shared family lost the existing source decoder identity", decoded, size, known, err)
+				}
+				for end := 0; end < len(instruction); end++ {
+					if _, err := x86NumericalVectorBoundary(instruction[:end], mode); err == nil {
+						t.Fatalf("accepted truncated broadcast at %d/%d", end, len(instruction))
+					}
+				}
+			})
+		}
+		boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+		_, terminal := scalar[pcs[len(pcs)-1]]
+		if err != nil || len(boundaries) != len(pcs) || !bytes.Equal(code, original) || len(scalar) != 1 || !terminal {
+			t.Error("complete broadcast source changed or lacks exact native boundaries", err, len(boundaries), len(pcs))
+			continue
+		}
+		for index, boundary := range boundaries {
+			end := int64(len(code))
+			if index+1 < len(pcs) {
+				end = pcs[index+1]
+			}
+			if boundary.PC != pcs[index] || int64(boundary.Length) != end-pcs[index] {
+				t.Fatal("broadcast boundary lost original Go PC", index, boundary, pcs[index])
+			}
+		}
+	}
+}
diff --git a/x86_numerical_byte_boundaries.go b/x86_numerical_byte_boundaries.go
new file mode 100644
index 000000000..892c7f083
--- /dev/null
+++ b/x86_numerical_byte_boundaries.go
@@ -0,0 +1,226 @@
+package plan9asm
+
+import "golang.org/x/arch/x86/x86asm"
+
+type x86NumericalNativeBoundary struct {
+	PC     int64
+	Length int
+}
+
+// This is a byte-boundary observation, not a raw/source/literal or memory
+// capability. In particular, VEX/EVEX instructions and the separate legacy
+// ADX physical projection are never put into scalar:
+// numerical-read binding still needs a real x86asm scalar decode, its exact
+// original source ordinal, relocation, layout, owner and live source guard.
+// Failure discards the complete observation, including otherwise valid prefixes
+// of the TEXT. Unreachable bytes after RET or a branch are still checked.
+func x86NumericalNativeBoundaries(code []byte, mode int) ([]x86NumericalNativeBoundary, map[int64]x86asm.Inst, error) {
+	if mode != 32 && mode != 64 || len(code) == 0 {
+		return nil, nil, numericalSBContext("empty TEXT or unknown native x86 mode")
+	}
+	var boundaries []x86NumericalNativeBoundary
+	scalar := make(map[int64]x86asm.Inst)
+	for pc := int64(0); pc < int64(len(code)); {
+		remaining := code[pc:]
+		length := 0
+		if x86NumericalVectorPrefix(remaining, mode) {
+			var err error
+			length, err = x86NumericalVectorBoundary(remaining, mode)
+			if err != nil {
+				return nil, nil, numericalSBContext("whole native vector boundary at %d: %v", pc, err)
+			}
+		} else if _, shaLength, known, err := decodedX86SHAInstructionWithMemory(remaining, mode, x86RawMemoryDecoder{physicalPC: true}); known || err != nil {
+			if err != nil {
+				return nil, nil, numericalSBContext("whole native SHA boundary at %d: %v", pc, err)
+			}
+			length = shaLength
+		} else if _, adxLength, _, known, err := decodeX86RawADXWithMemory(remaining, 0, mode, x86RawMemoryDecoder{physicalPC: true}); known || err != nil {
+			if err != nil {
+				return nil, nil, numericalSBContext("whole native ADX boundary at %d: %v", pc, err)
+			}
+			length = adxLength
+		} else {
+			native, err := x86asm.Decode(remaining, mode)
+			if err != nil || native.Op == 0 || native.Op == x86asm.CALL || native.Op == x86asm.LCALL {
+				return nil, nil, numericalSBContext("unknown/calling whole native instruction boundary at %d", pc)
+			}
+			for _, prefix := range native.Prefix {
+				if prefix.IsVEX() || prefix&x86asm.PrefixInvalid != 0 {
+					return nil, nil, numericalSBContext("unbound vector or invalid native prefix at %d", pc)
+				}
+			}
+			length = native.Len
+			scalar[pc] = native
+		}
+		if length <= 0 || length > 15 || length > len(remaining) {
+			return nil, nil, numericalSBContext("invalid complete native instruction length at %d", pc)
+		}
+		boundaries = append(boundaries, x86NumericalNativeBoundary{PC: pc, Length: length})
+		pc += int64(length)
+	}
+	return boundaries, scalar, nil
+}
+
+// Detect even incomplete/unsupported vector prefixes before generic decoding:
+// x/arch can report an unrelated legacy instruction and a wrong positive Len.
+// In mode32, C4/C5/62 with a memory ModRM remain legacy LES/LDS/BOUND.
+func x86NumericalVectorPrefix(code []byte, mode int) bool {
+	for i, value := range code {
+		switch {
+		case value == 0xc4 || value == 0xc5 || value == 0x62:
+			return mode == 64 || i+1 == len(code) || code[i+1]&0xc0 == 0xc0
+		case value == 0x26 || value == 0x2e || value == 0x36 || value == 0x3e ||
+			value == 0x64 || value == 0x65 || value == 0x66 || value == 0x67 ||
+			value == 0xf0 || value == 0xf2 || value == 0xf3 || mode == 64 && value&0xf0 == 0x40:
+			if i == 14 {
+				return false
+			}
+		default:
+			return false
+		}
+	}
+	return false
+}
+
+func x86NumericalVectorBoundary(code []byte, mode int) (int, error) {
+	memory := x86RawMemoryDecoder{physicalPC: true}
+	decoders := [...]func([]byte, int, x86RawMemoryDecoder) (Instr, int, bool, error){
+		decodedX86ANDNInstructionWithMemory,
+		decodedX86BEXTRInstructionWithMemory,
+		decodedX86BLSInstructionWithMemory,
+		decodedX86RawBZHIInstructionWithMemory,
+		decodedX86MULXInstructionWithMemory,
+		decodedX86ParallelBitsInstructionWithMemory,
+		decodedX86RORXInstructionWithMemory,
+		decodedX86BMI2ShiftInstructionWithMemory,
+		decodedX86NumericalConversionBoundary,
+		decodedX86VEXFMA3InstructionWithMemory,
+		decodedX86VEXBinaryFloatInstructionWithMemory,
+		decodedX86NumericalReciprocal14Boundary,
+		decodedX86AESInstructionWithMemory,
+		decodedX86MaskMoveInstructionWithMemory,
+		decodedX86PackedMoveInstructionWithMemory,
+		decodedX86EVEXPackedIntegerMoveInstructionWithMemory,
+		decodedX86VEXNonTemporalMoveInstructionWithMemory,
+		decodedX86VEXPackedFloatLogicalInstructionWithMemory,
+		decodedX86VEXPackedIntegerLogicalInstructionWithMemory,
+		decodedX86EVEXPackedLogicalInstructionWithMemory,
+		decodedX86RawEVEXFloatLogicalInstructionWithMemory,
+		decodedX86VINSERT128InstructionWithMemory,
+		decodedX86EVEXPackedInsertInstructionWithMemory,
+		decodedX86VEXTRACT128InstructionWithMemory,
+		decodedX86Permute128InstructionWithMemory,
+		decodedX86NumericalBroadcastBoundary,
+		decodedX86PackedIntegerCompareInstructionWithMemory,
+		decodedX86PackedIntegerArithmeticInstructionWithMemory,
+		decodedX86PackedAverageInstructionWithMemory,
+		decodedX86PackedIntegerMinMaxInstructionWithMemory,
+		decodedX86PackedMultiplyInstructionWithMemory,
+		decodedX86DwordToQwordMultiplyInstructionWithMemory,
+		decodedX86VEXPackedMADDInstructionWithMemory,
+		decodedX86EVEXPackedMADDInstructionWithMemory,
+		decodedX86PackedUniformShiftInstructionWithMemory,
+		decodedX86PerLaneVariableShiftInstructionWithMemory,
+		decodedX86RawVectorByteShiftInstructionWithMemory,
+		decodedX86VPSHUFBInstructionWithMemory,
+		decodedX86PackedShuffleInstructionWithMemory,
+		decodedX86PackedAlignRightInstructionWithMemory,
+		decodedX86ImmediatePackedBlendInstructionWithMemory,
+		decodedX86VPINSRInstructionWithMemory,
+		decodedX86EVEXVPINSRInstructionWithMemory,
+		decodedX86PackedScalarExtractInstructionWithMemory,
+		decodedX86VMOVQInstructionWithMemory,
+		decodedX86VEXVectorTestInstructionWithMemory,
+	}
+	if ins, length, known, err := decodedX86VEXMoveMaskInstruction(code, mode); known || err != nil {
+		if err == nil && mode == 32 {
+			err = x86Mode32VectorRegisterContext(ins, "386")
+		}
+		return length, err
+	}
+	for _, decode := range decoders {
+		if ins, length, known, err := decode(code, mode, memory); known || err != nil {
+			if err == nil && mode == 32 {
+				err = x86Mode32VectorRegisterContext(ins, "386")
+			}
+			return length, err
+		}
+	}
+	if p, known := decodeX86RawVectorEncoding(code); known && p.mapNumber == 3 && p.pp == 1 && p.opcode == 0x44 {
+		_, length, _, err := decodedX86RawVectorCLMULInstructionWithMemory(code, mode, p, memory)
+		return length, err
+	}
+	// The complete physical EVEX grammar is shared with the source decoder.
+	// Its separate source-syntax validation deliberately cannot interpret RIP.
+	if _, length, known, err := decodedX86TernaryLogicInstructionWithMemory(code, mode, memory); known || err != nil {
+		return length, err
+	}
+	if _, length, known, err := decodedX86VectorZeroInstruction(code, mode); known || err != nil {
+		return length, err
+	}
+	return 0, numericalSBContext("unregistered or truncated whole native VEX/EVEX encoding")
+}
+
+// Only observe complete Go-emitted instruction boundaries. This does not
+// decode raw source or supply a native read/entry/storage capability. Scalar
+// tuple scaling changes the address, never the encoded length; discard the
+// binary transport's operand projection rather than exposing it as a scalar
+// instruction. The independently bound original source owns those operands.
+func decodedX86NumericalReciprocal14Boundary(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	p, matched := decodeX86RawVectorEncoding(code)
+	if !matched || !p.evex || p.mapNumber != 2 || p.opcode < 0x4c || p.opcode > 0x4f {
+		return Instr{}, 0, false, nil
+	}
+	scalar := p.opcode&1 != 0
+	if !scalar && p.upper != 0 || scalar && (p.vectorLength != 0 || p.broadcast) {
+		return Instr{}, 0, true, numericalSBContext("noncanonical Go reciprocal14 source or scalar prefix")
+	}
+	family, suffix, bits := "VRCP14", "PS", 32
+	if p.opcode >= 0x4e {
+		family = "VRSQRT14"
+	}
+	if scalar {
+		suffix = "SS"
+	}
+	if p.w {
+		bits = 64
+		if scalar {
+			suffix = "SD"
+		} else {
+			suffix = "PD"
+		}
+	}
+	_, length, known, err := decodedX86BinaryVectorOperandsWithMemory(code, p, mode, Op(family+suffix), bits, memory)
+	return Instr{}, length, known, err
+}
+
+// Keep the original raw-source dispatch order: EVEX 19/W0 is F32X2, not
+// scalar SD/W1, and 59/W0 is I32X2, not integer Q/W1. The specialized source
+// decoders retain their own reserved-encoding contracts and memory policy.
+func decodedX86NumericalBroadcastBoundary(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	if ins, length, known, err := decodedX86RawBlockBroadcastInstructionWithMemory(code, mode, memory); known || err != nil {
+		return ins, length, known, err
+	}
+	if ins, length, known, err := decodedX86ScalarBroadcastInstructionWithMemory(code, mode, memory); known || err != nil {
+		return ins, length, known, err
+	}
+	return decodedX86VEXPackedBroadcastInstructionWithMemory(code, mode, memory)
+}
+
+func decodedX86NumericalConversionBoundary(code []byte, mode int, memory x86RawMemoryDecoder) (Instr, int, bool, error) {
+	if ins, length, known, err := decodedX86PackedNumericConversionInstructionWithMemory(code, mode, memory); known || err != nil {
+		return ins, length, known, err
+	}
+	p, known := decodeX86RawVectorEncoding(code)
+	if known && p.mapNumber == 1 {
+		switch {
+		case p.opcode == 0x51 && p.pp < 2:
+			return decodedX86SameWidthConversionInstructionWithMemory(code, mode, memory)
+		case p.opcode == 0x5b && p.pp == 0:
+			return decodedX86SameWidthConversionInstructionWithMemory(code, mode, memory)
+		case p.opcode == 0xe6 && p.pp == 2:
+			return decodedX86PackedDoubleDwordInstructionWithMemory(code, mode, memory)
+		}
+	}
+	return Instr{}, 0, false, nil
+}
diff --git a/x86_numerical_byte_boundaries_test.go b/x86_numerical_byte_boundaries_test.go
new file mode 100644
index 000000000..0c45f0611
--- /dev/null
+++ b/x86_numerical_byte_boundaries_test.go
@@ -0,0 +1,416 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Observe original Go bytes and independently listed PCs, not the translator's
+// raw decoder or its typed instruction tables. These fixtures contain one TEXT
+// and no data, alignment directives, or assembler-inserted frame instructions.
+func x86NumericalBoundaryGoBytes(t *testing.T, arch, body string) ([]byte, []int64) {
+	t.Helper()
+	code, pcs, _ := x86NumericalBoundaryGoBytesAndListing(t, arch, body)
+	return code, pcs
+}
+
+func x86NumericalBoundaryGoBytesAndListing(t *testing.T, arch, body string) ([]byte, []int64, []byte) {
+	t.Helper()
+	listing := x86InsertExtractGoListing(t, arch, "TEXT boundary(SB),4,$0-0\n"+body+"\n")
+	var code []byte
+	var pcs []int64
+	for _, line := range strings.Split(string(listing), "\n") {
+		if chunk := x86InsertExtractListedBytes(line); len(chunk) != 0 {
+			fields := strings.Fields(line)
+			pc, err := strconv.ParseInt(fields[0], 0, 64)
+			if err != nil || pc != int64(len(code)) {
+				t.Fatalf("noncontiguous original Go bytes: %s", line)
+			}
+			code = append(code, chunk...)
+		}
+		match := goAMD64FrameRow.FindStringSubmatch(line)
+		if match == nil || strings.HasPrefix(match[3], "TEXT") {
+			continue
+		}
+		pc, err := strconv.ParseInt(match[1], 16, 64)
+		if err != nil || len(pcs) != 0 && pc <= pcs[len(pcs)-1] {
+			t.Fatalf("ambiguous original Go instruction PC: %s", line)
+		}
+		pcs = append(pcs, pc)
+	}
+	if len(code) == 0 || len(pcs) == 0 || pcs[0] != 0 {
+		t.Fatal("missing original Go instruction bytes/PCs")
+	}
+	return code, pcs, listing
+}
+
+func TestX86NumericalNativeBoundariesOriginalGoMixedEVEX(t *testing.T) {
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", "VMOVDQU64 table<>(SB),Z0\nCMPB feature+7(SB),$1\nRET")
+	boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got []int64
+	for _, boundary := range boundaries {
+		got = append(got, boundary.PC)
+	}
+	if !reflect.DeepEqual(got, pcs) || len(scalar) != 2 || scalar[pcs[1]].Op != x86asm.CMP || scalar[pcs[2]].Op != x86asm.RET {
+		t.Fatalf("actual Go boundaries %v, got %+v; scalar=%v", pcs, boundaries, scalar)
+	}
+}
+
+func x86NumericalBoundaryForms(arch string) []string {
+	var rows []string
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, op := range []string{"VMOVAPS", "VMOVAPD", "VMOVUPS", "VMOVUPD", "VMOVDQA", "VMOVDQU", "VMOVDQA32", "VMOVDQA64", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+			legacy := op == "VMOVDQA" || op == "VMOVDQU"
+			if legacy && bank == "Z" {
+				continue
+			}
+			for _, operand := range []string{bank + "1", "(AX)", "-128(AX)(CX*4)", "table+7(SB)", "8(AX)(FS)", "8(AX)(GS)"} {
+				rows = append(rows, fmt.Sprintf("%s %s,%s2", op, operand, bank), fmt.Sprintf("%s %s2,%s", op, bank, operand))
+				if !legacy {
+					rows = append(rows, fmt.Sprintf("%s.Z %s,K7,%s2", op, operand, bank), fmt.Sprintf("%s %s2,K1,%s", op, bank, operand))
+				}
+			}
+		}
+		for _, op := range []string{"VANDPS", "VANDPD", "VANDNPS", "VANDNPD", "VORPS", "VORPD", "VXORPS", "VXORPD", "VPAND", "VPANDN", "VPOR", "VPXOR", "VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"} {
+			legacy := op == "VPAND" || op == "VPANDN" || op == "VPOR" || op == "VPXOR"
+			if legacy && bank == "Z" {
+				continue
+			}
+			for _, operand := range []string{bank + "1", "-64(AX)(CX*2)", "table-4(SB)"} {
+				rows = append(rows, fmt.Sprintf("%s %s,%s2,%s3", op, operand, bank, bank))
+				if !legacy && arch == "amd64" {
+					rows = append(rows, fmt.Sprintf("%s.Z %s,%s2,K7,%s3", op, operand, bank, bank))
+					if operand != bank+"1" {
+						rows = append(rows, fmt.Sprintf("%s.BCST.Z %s,%s2,K7,%s3", op, operand, bank, bank))
+					}
+				}
+			}
+		}
+		if arch == "amd64" {
+			for _, operand := range []string{bank + "31", "table+17(SB)", "-64(AX)(CX*8)"} {
+				for _, immediate := range []int{0, 17, 150, 255} {
+					rows = append(rows, fmt.Sprintf("VPCLMULQDQ $%d,%s,%s30,%s29", immediate, operand, bank, bank))
+					for _, op := range []string{"VPTERNLOGD", "VPTERNLOGQ"} {
+						rows = append(rows, fmt.Sprintf("%s $%d,%s,%s30,%s29", op, immediate, operand, bank, bank),
+							fmt.Sprintf("%s.Z $%d,%s,%s30,K7,%s29", op, immediate, operand, bank, bank))
+						if operand != bank+"31" {
+							rows = append(rows, fmt.Sprintf("%s.BCST.Z $%d,%s,%s30,K1,%s29", op, immediate, operand, bank, bank))
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, family := range []struct {
+		stem, lane, input, output string
+	}{
+		{"F", "128", "X", "Y"}, {"I", "128", "X", "Y"},
+		{"F", "32X4", "X", "Y"}, {"F", "32X4", "X", "Z"},
+		{"F", "64X2", "X", "Y"}, {"F", "64X2", "X", "Z"},
+		{"I", "32X4", "X", "Y"}, {"I", "32X4", "X", "Z"},
+		{"I", "64X2", "X", "Y"}, {"I", "64X2", "X", "Z"},
+		{"F", "32X8", "Y", "Z"}, {"F", "64X4", "Y", "Z"},
+		{"I", "32X8", "Y", "Z"}, {"I", "64X4", "Y", "Z"},
+	} {
+		for _, operand := range []string{family.input + "1", "table+31(SB)", "-128(AX)(CX*4)"} {
+			rows = append(rows, fmt.Sprintf("VEXTRACT%s%s $255,%s2,%s", family.stem, family.lane, family.output, operand))
+			if arch == "amd64" {
+				rows = append(rows, fmt.Sprintf("VINSERT%s%s $255,%s,%s2,%s3", family.stem, family.lane, operand, family.output, family.output))
+				if family.lane != "128" {
+					rows = append(rows, fmt.Sprintf("VINSERT%s%s.Z $255,%s,%s2,K7,%s3", family.stem, family.lane, operand, family.output, family.output),
+						fmt.Sprintf("VEXTRACT%s%s $255,%s2,K7,%s", family.stem, family.lane, family.output, operand))
+				}
+			}
+		}
+	}
+	return append(rows, "PCLMULQDQ $255,X1,X2", "VZEROUPPER", "VZEROALL")
+}
+
+func TestX86NumericalNativeBoundariesWholeFamilyOriginalGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86NumericalBoundaryForms(arch)
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPB feature+7(SB),$1\nRET")
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			original := append([]byte(nil), code...)
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(pcs) != len(rows)+2 || len(boundaries) != len(pcs) || !bytes.Equal(code, original) {
+				t.Fatalf("source rows=%d Go PCs=%d boundaries=%d or bytes changed", len(rows), len(pcs), len(boundaries))
+			}
+			for i, boundary := range boundaries {
+				end := int64(len(code))
+				if i+1 < len(pcs) {
+					end = pcs[i+1]
+				}
+				if boundary.PC != pcs[i] || boundary.Length != int(end-pcs[i]) {
+					t.Fatalf("row %d: boundary %+v, actual Go [%d,%d)", i, boundary, pcs[i], end)
+				}
+				if native, exists := scalar[boundary.PC]; exists {
+					independent, err := x86asm.Decode(code[boundary.PC:], mode)
+					if err != nil || native != independent || native.Len != boundary.Length {
+						t.Fatal("scalar map was not the exact independent x86asm decode", boundary)
+					}
+				}
+				instruction := code[boundary.PC:end]
+				for cut := 1; cut < len(instruction); cut++ {
+					if partial, values, err := x86NumericalNativeBoundaries(instruction[:cut], mode); err == nil || partial != nil || values != nil {
+						t.Fatalf("row %d cut %d of %x accepted: %v", i, cut, instruction, err)
+					}
+				}
+			}
+			t.Logf("actual Go %s: %d complete family forms, every instruction byte cut rejected", arch, len(rows))
+		})
+	}
+}
+
+func TestX86NumericalNativeBoundariesFailuresDiscardAll(t *testing.T) {
+	for name, code := range map[string][]byte{
+		"empty":                nil,
+		"call":                 {0xe8, 0, 0, 0, 0},
+		"indirect-call":        {0xff, 0xd0},
+		"indirect-memory-call": {0xff, 0x10},
+		"far-call":             {0x9a, 0, 0, 0, 0, 0, 0},
+		"far-memory-call":      {0xff, 0x18},
+		"truncated-escape":     {0x0f},
+		"unknown-evex":         {0x62, 0xf1, 0x7c, 0x48, 0xff, 0xc0},
+		"unknown-vex-map2":     {0xc4, 0xe2, 0x79, 0xff, 0xc0},
+		"overlong":             append(bytes.Repeat([]byte{0x64}, 15), 0x90),
+	} {
+		for _, mode := range []int{32, 64} {
+			for _, leading := range [][]byte{nil, {0x90, 0xc3}, {0xeb, 0x7f}} {
+				t.Run(fmt.Sprintf("%s/%d/%x", name, mode, leading), func(t *testing.T) {
+					if len(code) == 0 && len(leading) != 0 {
+						return
+					}
+					whole := append(append([]byte(nil), leading...), code...)
+					got, scalar, err := x86NumericalNativeBoundaries(whole, mode)
+					if !errors.Is(err, ErrProbeNeedsContext) || got != nil || scalar != nil {
+						t.Fatalf("incomplete/forbidden stream acquired a partial proof: %x %+v %v %v", whole, got, scalar, err)
+					}
+				})
+			}
+		}
+	}
+	for _, mode := range []int{0, 16, 128} {
+		if _, _, err := x86NumericalNativeBoundaries([]byte{0x90}, mode); err == nil {
+			t.Fatal("invalid mode accepted", mode)
+		}
+	}
+}
+
+func TestX86NumericalNativeBoundariesMode32LegacyPrefixIdentity(t *testing.T) {
+	for _, opcode := range []byte{0x62, 0xc4, 0xc5} {
+		code := []byte{opcode, 0x00, 0xc3}
+		got, scalar, err := x86NumericalNativeBoundaries(code, 32)
+		if err != nil || len(got) != 2 || got[0].Length != 2 || len(scalar) != 2 {
+			t.Fatalf("mode32 BOUND/LES/LDS confused with EVEX/VEX: %x %+v %v %v", code, got, scalar, err)
+		}
+		if _, _, err := x86NumericalNativeBoundaries(code, 64); err == nil {
+			t.Fatalf("legacy-only bytes became mode64 vector boundary: %x", code)
+		}
+	}
+	// EVEX.R' extends the destination independently of the legacy-vs-EVEX
+	// discriminator. Go syntax acceptance alone cannot bind this high bank.
+	if _, _, err := x86NumericalNativeBoundaries([]byte{0x62, 0xe1, 0x7d, 0x08, 0x6f, 0xc1}, 32); err == nil {
+		t.Fatal("unbound mode32 high vector register accepted")
+	}
+}
+
+func TestX86NumericalNativeBoundariesPhysicalRIPDoesNotGrantSource(t *testing.T) {
+	for _, displacement := range []int32{-2147483648, -1, 0, 2147483647} {
+		code := []byte{0x15, 0, 0, 0, 0}
+		binary.LittleEndian.PutUint32(code[1:], uint32(displacement))
+		for _, segment := range []Reg{"", FS, GS} {
+			physical := x86RawMemoryDecoder{physicalPC: true}
+			for _, scale := range []int{1, 4, 8, 16, 32, 64} {
+				operand, length, err := physical.evex(code, 64, 1, 1, segment, "Z", scale)
+				if err != nil || length != 5 || operand.Kind != OpMem || operand.Mem.Base != "RIP" || operand.Mem.Off != int64(displacement) || operand.Mem.Segment != segment || operand.Mem.Index != "" {
+					t.Fatalf("physical RIP+disp32 not preserved: %x %+v %d %v", code, operand, length, err)
+				}
+				if _, _, err := (x86RawMemoryDecoder{}).evex(code, 64, 1, 1, segment, "Z", scale); err == nil {
+					t.Fatal("default raw memory decoder accepted unbound RIP")
+				}
+				for cut := 1; cut < 5; cut++ {
+					if _, _, err := physical.evex(code[:cut], 64, 0, 0, segment, "Z", scale); err == nil {
+						t.Fatal("truncated original disp32 accepted", cut)
+					}
+				}
+			}
+			absolute, _, err := physical.evex(code, 32, 0, 0, segment, "X", 1)
+			if err != nil || absolute.Mem.Base != "" || absolute.Mem.Off != int64(displacement) {
+				t.Fatal("386 absolute disp32 became RIP", absolute, err)
+			}
+		}
+	}
+}
+
+func TestX86NumericalNativeBoundariesDefaultRawFamiliesRemainStrict(t *testing.T) {
+	for _, family := range []struct {
+		instruction string
+		decode      x86RawInstructionDecoder
+	}{
+		{"VMOVDQU64 table(SB),Z2", decodedX86EVEXPackedIntegerMoveInstruction},
+		{"VMOVAPD table(SB),Z2", decodedX86PackedMoveInstruction},
+		{"VMOVAPS table(SB),Y2", decodedX86PackedMoveInstruction},
+		{"VMOVNTDQ Y2,table(SB)", decodedX86VEXNonTemporalMoveInstruction},
+		{"VMOVNTDQA table(SB),Y2", decodedX86VEXNonTemporalMoveInstruction},
+		{"VMOVNTPD Y2,table(SB)", decodedX86VEXNonTemporalMoveInstruction},
+		{"VMOVNTPS Y2,table(SB)", decodedX86VEXNonTemporalMoveInstruction},
+		{"VPANDD table(SB),Z1,Z2", decodedX86EVEXPackedLogicalInstruction},
+		{"VANDPS table(SB),Z1,Z2", decodedX86RawEVEXFloatLogicalInstruction},
+		{"VANDPD table(SB),Y1,Y2", decodedX86VEXPackedFloatLogicalInstruction},
+		{"VPXOR table(SB),Y1,Y2", decodedX86VEXPackedIntegerLogicalInstruction},
+		{"VPCLMULQDQ $255,table(SB),Z1,Z2", decodedX86RawCLMULInstruction},
+		{"VPCLMULQDQ $255,table(SB),Y1,Y2", decodedX86RawCLMULInstruction},
+		{"VPTERNLOGD $150,table(SB),Z1,Z2", decodedX86TernaryLogicInstruction},
+		{"VINSERTF32X4 $255,table(SB),Z1,Z2", decodedX86EVEXPackedInsertInstruction},
+		{"VINSERTF128 $255,table(SB),Y1,Y2", decodedX86VINSERT128Instruction},
+		{"VEXTRACTF32X4 $255,Z2,table(SB)", decodedX86VEXTRACT128Instruction},
+		{"VEXTRACTF128 $255,Y2,table(SB)", decodedX86VEXTRACT128Instruction},
+		{"VPBROADCASTB table(SB),Y2", decodedX86VEXPackedBroadcastInstruction},
+		{"VPBROADCASTQ.Z table(SB),K7,Z2", decodedX86VEXPackedBroadcastInstruction},
+		{"VPCMPEQB table(SB),Y1,Y2", decodedX86PackedIntegerCompareInstruction},
+		{"VPCMPGTD.BCST table(SB),Z1,K7,K2", decodedX86PackedIntegerCompareInstruction},
+		{"VMOVD table(SB),X2", decodedX86VMOVQInstruction},
+		{"VMOVQ table(SB),X31", decodedX86VMOVQInstruction},
+		{"VPTEST table(SB),Y2", decodedX86VEXVectorTestInstruction},
+		{"VTESTPS table(SB),X2", decodedX86VEXVectorTestInstruction},
+		{"VTESTPD table(SB),Y2", decodedX86VEXVectorTestInstruction},
+	} {
+		t.Run(family.instruction, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", family.instruction+"\nRET")
+			if len(pcs) != 2 {
+				t.Fatal("unexpected original Go expansion", pcs)
+			}
+			if _, _, known, err := family.decode(code, 64); !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatalf("default raw source acquired RIP authority: known=%t err=%v", known, err)
+			}
+			got, scalar, err := x86NumericalNativeBoundaries(code, 64)
+			if err != nil || len(got) != 2 || got[0].Length != int(pcs[1]) || len(scalar) != 1 || scalar[pcs[1]].Op != x86asm.RET {
+				t.Fatalf("byte-only observation lost whole native boundaries: %+v %v %v", got, scalar, err)
+			}
+		})
+	}
+}
+
+func TestX86NumericalNativeBoundariesMalformedEVEXAndImmediateDomain(t *testing.T) {
+	move := []byte{0x62, 0xf1, 0xfe, 0x48, 0x6f, 0x15, 0, 0, 0, 0}
+	for name, mutate := range map[string]func([]byte){
+		"reserved-map":      func(code []byte) { code[1] |= 8 },
+		"missing-fixed-bit": func(code []byte) { code[2] &^= 4 },
+		"reserved-vvvv":     func(code []byte) { code[2] &^= 8 },
+		"reserved-V-prime":  func(code []byte) { code[3] &^= 8 },
+		"reserved-VL":       func(code []byte) { code[3] |= 0x60 },
+		"broadcast-move":    func(code []byte) { code[3] |= 0x10 },
+		"zero-mask-K0":      func(code []byte) { code[3] |= 0x80 },
+		"zero-memory-store": func(code []byte) {
+			code[3] |= 0x81
+			code[4] = 0x7f
+		},
+		"unregistered-opcode": func(code []byte) { code[4] = 0xff },
+	} {
+		t.Run(name, func(t *testing.T) {
+			code := append([]byte(nil), move...)
+			mutate(code)
+			if got, scalar, err := x86NumericalNativeBoundaries(code, 64); err == nil || got != nil || scalar != nil {
+				t.Fatalf("malformed EVEX produced boundaries: %x %+v %v %v", code, got, scalar, err)
+			}
+		})
+	}
+	for _, prefix := range []byte{0x66, 0x67, 0xf0, 0xf2, 0xf3, 0x48} {
+		if _, _, err := x86NumericalNativeBoundaries(append([]byte{prefix}, move...), 64); err == nil {
+			t.Fatal("unbound/forbidden vector prefix accepted", prefix)
+		}
+	}
+	var body strings.Builder
+	for immediate := 0; immediate < 256; immediate++ {
+		for _, instruction := range []string{
+			"VPCLMULQDQ $%d,table(SB),Z1,Z2",
+			"VPTERNLOGD $%d,table(SB),Z1,Z2",
+			"VPTERNLOGQ $%d,table(SB),Z1,Z2",
+			"VINSERTI64X2 $%d,table(SB),Z1,Z2",
+			"VEXTRACTI64X2 $%d,Z2,table(SB)",
+		} {
+			fmt.Fprintf(&body, instruction+"\n", immediate)
+		}
+	}
+	body.WriteString("RET\n")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String())
+	got, scalar, err := x86NumericalNativeBoundaries(code, 64)
+	if err != nil || len(got) != 1281 || len(scalar) != 1 {
+		t.Fatalf("complete original Go imm8 boundaries: count=%d scalar=%d err=%v", len(got), len(scalar), err)
+	}
+	for i, pc := range pcs {
+		if got[i].PC != pc {
+			t.Fatal("original Go immediate row lost its boundary", i, pc, got[i])
+		}
+	}
+}
+
+func TestX86NumericalNativeBoundariesExistingVEXNonTemporal(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var body strings.Builder
+			for _, op := range []string{"VMOVNTDQ", "VMOVNTDQA", "VMOVNTPD", "VMOVNTPS"} {
+				for _, bank := range []string{"X", "Y"} {
+					for _, memory := range []string{"(AX)", "-64(AX)(CX*4)", "table+7(SB)", "8(AX)(GS)"} {
+						first, second := bank+"2", memory
+						if op == "VMOVNTDQA" {
+							first, second = second, first
+						}
+						fmt.Fprintf(&body, "%s %s,%s\n", op, first, second)
+					}
+				}
+			}
+			body.WriteString("RET\n")
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, body.String())
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			// These first two VEX names really exist in x/arch's opcode enum.
+			// The old whole-TEXT loop accepted them: do not shrink that domain.
+			for _, index := range []int{0, 8} {
+				native, err := x86asm.Decode(code[pcs[index]:], mode)
+				if err != nil || native.Op != []x86asm.Op{x86asm.VMOVNTDQ, x86asm.VMOVNTDQA}[index/8] || native.Len != int(pcs[index+1]-pcs[index]) {
+					t.Fatalf("original trusted VEX observation changed: %+v %v", native, err)
+				}
+			}
+			got, scalar, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil || len(got) != len(pcs) || len(scalar) != 1 {
+				t.Fatalf("existing VEX boundary coverage regressed: %+v %v %v", got, scalar, err)
+			}
+			for i, pc := range pcs {
+				if got[i].PC != pc {
+					t.Fatal("original non-temporal Go boundary differs", got[i], pc)
+				}
+				end := int64(len(code))
+				if i+1 < len(pcs) {
+					end = pcs[i+1]
+				}
+				for cut := pc + 1; cut < end; cut++ {
+					if _, _, err := x86NumericalNativeBoundaries(code[pc:cut], mode); err == nil {
+						t.Fatal("non-temporal truncated boundary accepted", pc, cut, end)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_numerical_conversion_boundaries_test.go b/x86_numerical_conversion_boundaries_test.go
new file mode 100644
index 000000000..7cca9a7c5
--- /dev/null
+++ b/x86_numerical_conversion_boundaries_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalConversionBoundariesOriginalCompleteFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := append(x86PackedConversionOracleRows(arch), x86SignedPackedFloatRows(arch)...)
+			var body strings.Builder
+			body.WriteString("RET\n") // Dead source still has exact native boundaries.
+			for _, row := range rows {
+				body.WriteString(row + "\n")
+				if strings.Contains(row, " (AX),") {
+					body.WriteString(strings.Replace(row, " (AX),", " table+7(SB),", 1) + "\n")
+				}
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, body.String())
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var actual []int64
+			for index, boundary := range boundaries {
+				actual = append(actual, boundary.PC)
+				end := int64(len(code))
+				if index+1 < len(pcs) {
+					end = pcs[index+1]
+				}
+				if boundary.PC != pcs[index] || boundary.Length != int(end-pcs[index]) {
+					t.Fatalf("conversion boundary %+v differs from original Go [%d,%d)", boundary, pcs[index], end)
+				}
+				if x86NumericalVectorPrefix(code[boundary.PC:], mode) {
+					if _, found := scalar[boundary.PC]; found {
+						t.Fatal("vector boundary acquired a scalar numerical-read role")
+					}
+				}
+				for cut := boundary.PC + 1; cut < end; cut++ {
+					partial, scalar, err := x86NumericalNativeBoundaries(code[boundary.PC:cut], mode)
+					if !errors.Is(err, ErrProbeNeedsContext) || partial != nil || scalar != nil {
+						t.Fatalf("truncated conversion acquired a partial proof: %x, %v", code[boundary.PC:cut], err)
+					}
+				}
+			}
+			if !reflect.DeepEqual(actual, pcs) {
+				t.Fatal("complete Go listing and machine boundaries disagree")
+			}
+		})
+	}
+}
+
+func TestX86NumericalConversionBoundariesDoNotGrantRawRIP(t *testing.T) {
+	for _, family := range []struct {
+		row    string
+		decode x86RawInstructionDecoder
+	}{
+		{"VCVTDQ2PS table(SB),Y1", decodedX86SameWidthConversionInstruction},
+		{"VCVTDQ2PS table(SB),Z1", decodedX86SameWidthConversionInstruction},
+		{"VCVTDQ2PD table(SB),Y1", decodedX86PackedDoubleDwordInstruction},
+		{"VCVTDQ2PD table(SB),Z1", decodedX86PackedDoubleDwordInstruction},
+		{"VCVTPS2DQ table(SB),Y1", decodedX86PackedNumericConversionInstruction},
+		{"VCVTPS2DQ table(SB),Z1", decodedX86PackedNumericConversionInstruction},
+		{"VCVTTPD2DQY table(SB),X1", decodedX86PackedDoubleDwordInstruction},
+		{"VCVTUQQ2PS table(SB),Y1", decodedX86PackedNumericConversionInstruction},
+	} {
+		t.Run(family.row, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", family.row+"\nRET")
+			if len(pcs) != 2 {
+				t.Fatal("unexpected original Go expansion", pcs)
+			}
+			if _, _, known, err := family.decode(code, 64); !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatalf("source decoder acquired a physical RIP permission: known=%t, %v", known, err)
+			}
+			got, length, known, err := decodedX86NumericalConversionBoundary(code, 64, x86RawMemoryDecoder{physicalPC: true})
+			if err != nil || !known || length != int(pcs[1]) || got.Args[0].Mem.Base != "RIP" {
+				t.Fatalf("observer lost the original physical operand/length: %+v, %d, %v", got, length, err)
+			}
+		})
+	}
+}
+
+func TestX86NumericalConversionBoundariesReservedFields(t *testing.T) {
+	for _, row := range []string{"VCVTDQ2PS (AX),Z1", "VCVTDQ2PD (AX),Z1", "VCVTUQQ2PS (AX),Y1"} {
+		code, _ := x86NumericalBoundaryGoBytes(t, "amd64", row)
+		if len(code) != 6 || code[0] != 0x62 {
+			t.Fatalf("expected an independent EVEX witness for %s: %x", row, code)
+		}
+		for name, mutate := range map[string]func([]byte){
+			"reserved map":      func(b []byte) { b[1] |= 8 },
+			"missing fixed bit": func(b []byte) { b[2] &^= 4 },
+			"reserved vvvv":     func(b []byte) { b[2] &^= 8 },
+			"reserved V prime":  func(b []byte) { b[3] &^= 8 },
+			"reserved VL":       func(b []byte) { b[3] |= 0x60 },
+			"zero K0":           func(b []byte) { b[3] |= 0x80 },
+		} {
+			t.Run(row+"/"+name, func(t *testing.T) {
+				changed := append([]byte(nil), code...)
+				mutate(changed)
+				for _, prefix := range [][]byte{nil, {0x90, 0xc3}} {
+					whole := append(append([]byte(nil), prefix...), changed...)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(whole, 64)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatalf("reserved conversion retained a partial proof: %x, %v", whole, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numerical_floating_boundaries_go127_test.go b/x86_numerical_floating_boundaries_go127_test.go
new file mode 100644
index 000000000..a59da16ba
--- /dev/null
+++ b/x86_numerical_floating_boundaries_go127_test.go
@@ -0,0 +1,139 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// Keep the complete actual SDK source: the old failure occurs in the FMA
+// branch, after valid scalar instructions and several original returns. A
+// cropped live path or text assembled from a replacement fixture misses it.
+func TestX86NumericalNativeBoundariesOriginalCompleteSDKMathExp(t *testing.T) {
+	x86CheckCompleteSDKNativeBoundaries(t, "math", "exp_amd64.s", "math.archExp", []string{
+		"VFNMADD231SD X2, X1, X0", "VFMADD213SD exprodata<>+56(SB), X0, X1", "VADDSD exprodata<>+16(SB), X0, X1",
+	})
+}
+
+func TestX86NumericalNativeBoundariesOriginalCompleteSDKSHA512(t *testing.T) {
+	const pkg = "crypto/internal/fips140/sha512"
+	x86CheckCompleteSDKNativeBoundaries(t, pkg, "sha512block_amd64.s", pkg+".blockAVX2", []string{
+		"VPSHUFB", "VPADDQ", "VPSRLQ", "VPSLLQ", "VPALIGNR", "VPERM2F128",
+	})
+}
+
+func x86CheckCompleteSDKNativeBoundaries(t *testing.T, pkg, filename, symbol string, required []string) {
+	t.Helper()
+	ctx, request := sdkASMDataRequest(t, "amd64", pkg)
+	root := filepath.Dir(filepath.Dir(request.GoBinary))
+	path := filepath.Join(request.Directory, filename)
+	original, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal("complete original SDK source is absent", err)
+	}
+	for _, instruction := range required {
+		if !strings.Contains(string(original), instruction) {
+			t.Fatal("complete original SDK instruction is absent", instruction)
+		}
+	}
+	object := filepath.Join(t.TempDir(), "original.o")
+	listing, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary,
+		"tool", "asm", "-S", "-p", pkg, "-I", filepath.Join(root, "pkg", "include"), "-o", object, path)
+	if err != nil {
+		t.Fatal("actual Go rejected the complete original SDK source", err)
+	}
+	objectBytes, err := os.ReadFile(object)
+	if err != nil || len(objectBytes) == 0 {
+		t.Fatal("complete actual original Go object is absent", err)
+	}
+	builtins, err := os.ReadFile(filepath.Join(root, "src", "cmd", "internal", "goobj", "builtinlist.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	texts, err := gostaticstorage.ObserveX86AssemblyText(objectBytes, builtins, request.Target)
+	if err != nil || len(texts) != 1 || texts[0].Name != symbol ||
+		len(texts[0].Code) == 0 || texts[0].Size != int64(len(texts[0].Code)) {
+		t.Fatal("independent whole original object/TEXT prerequisite failed", err, texts)
+	}
+	code := texts[0].Code
+	var pcs []int64
+	var listed []byte
+	inText := false
+	for _, line := range strings.Split(string(listing), "\n") {
+		if strings.HasPrefix(line, symbol+" STEXT ") || strings.HasPrefix(line, symbol+" STEXTFIPS ") {
+			if inText {
+				t.Fatal("duplicate original TEXT listing")
+			}
+			inText = true
+			continue
+		}
+		if !inText {
+			continue
+		}
+		if line != "" && line[0] != '\t' && line[0] != ' ' {
+			break // DATA symbols are not executable instructions.
+		}
+		if chunk := x86InsertExtractListedBytes(line); len(chunk) != 0 {
+			fields := strings.Fields(line)
+			pc, parseErr := strconv.ParseInt(fields[0], 0, 64)
+			if parseErr != nil || pc != int64(len(listed)) {
+				t.Fatal("noncontiguous complete original Go TEXT listing", line)
+			}
+			listed = append(listed, chunk...)
+		}
+		match := goAMD64FrameRow.FindStringSubmatch(line)
+		if match == nil || strings.HasPrefix(match[3], "TEXT") ||
+			strings.HasPrefix(match[3], "PCDATA") || strings.HasPrefix(match[3], "FUNCDATA") {
+			continue
+		}
+		pc, parseErr := strconv.ParseInt(match[1], 16, 64)
+		if parseErr != nil || len(pcs) != 0 && pc <= pcs[len(pcs)-1] {
+			t.Fatal("ambiguous original Go instruction PC", line)
+		}
+		pcs = append(pcs, pc)
+	}
+	if !inText || len(pcs) == 0 || pcs[0] != 0 || !bytes.Equal(code, listed) {
+		t.Fatal("independent complete original object and listing bytes differ", len(code), len(listed), pcs)
+	}
+	after, err := os.ReadFile(path)
+	if err != nil || !bytes.Equal(original, after) {
+		t.Fatal("complete original SDK source changed", err)
+	}
+	t.Logf("complete original ASM SHA256=%x objectSHA256=%x TEXTbytes=%d originalPCs=%d",
+		sha256.Sum256(original), sha256.Sum256(objectBytes), len(code), len(pcs))
+	boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+	if err != nil {
+		t.Fatal("original Go object lost its complete instruction boundaries", err)
+	}
+	if len(boundaries) != len(pcs) {
+		t.Fatal("whole original source boundary count differs", len(boundaries), len(pcs))
+	}
+	vectorCount := 0
+	for index, boundary := range boundaries {
+		end := int64(len(code))
+		if index+1 < len(pcs) {
+			end = pcs[index+1]
+		}
+		if boundary.PC != pcs[index] || boundary.Length != int(end-pcs[index]) {
+			t.Fatal("whole original source PC/byte boundary changed", index, boundary, pcs[index], end)
+		}
+		if x86NumericalVectorPrefix(code[boundary.PC:end], 64) {
+			if _, exists := scalar[boundary.PC]; exists {
+				t.Fatal("original vector opcode acquired a scalar NUM read", boundary)
+			}
+			vectorCount++
+		}
+	}
+	if vectorCount == 0 || len(scalar)+vectorCount != len(boundaries) {
+		t.Fatal("complete original native-vector branch was omitted", vectorCount, len(scalar), len(boundaries))
+	}
+}
diff --git a/x86_numerical_floating_boundaries_test.go b/x86_numerical_floating_boundaries_test.go
new file mode 100644
index 000000000..0260c963d
--- /dev/null
+++ b/x86_numerical_floating_boundaries_test.go
@@ -0,0 +1,313 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// These syntax inventories predate the numerical-byte observer. They enumerate
+// Go's complete FMA3, binary-floating and SQRT shapes independently of the
+// decoder's opcode maps. Existing family roots bind their complete Go rows and
+// attributes; this consumer must observe their actual physical boundaries too.
+func x86NumericalFloatingBoundaryRows(arch, family string) []string {
+	var rows []string
+	switch family {
+	case "FMA3":
+		rows = x86FMA3NamedFormats(arch)
+	case "arithmetic":
+		rows = append(rows, x86FloatAddSubFormats(arch)...)
+		rows = append(rows, x86FloatMulDivFormats(arch)...)
+		rows = append(rows, x86FloatingMinMaxFormats(arch)...)
+	case "sqrt":
+		rows = x86SqrtInputRows(arch)
+	default:
+		panic("unknown independent floating family")
+	}
+	var complete []string
+	for _, row := range rows {
+		if !strings.HasPrefix(row, "V") {
+			continue // Ordinary legacy boundaries already use independent x86asm.
+		}
+		complete = append(complete, row)
+		if strings.Contains(row, "(AX)") {
+			for _, address := range []string{"-129(AX)(CX*4)", "table+17(SB)"} {
+				complete = append(complete, strings.ReplaceAll(row, "(AX)", address))
+			}
+		} else if arch == "amd64" {
+			// Force the otherwise overlapping unmasked X/Y rows to EVEX,
+			// without copying an exhaustive register Cartesian product.
+			complete = append(complete, strings.NewReplacer(
+				"X0", "X28", "X1", "X29", "X2", "X30",
+				"Y0", "Y28", "Y1", "Y29", "Y2", "Y30",
+				"Z0", "Z28", "Z1", "Z29", "Z2", "Z30").Replace(row))
+		}
+	}
+	return complete
+}
+
+func x86CheckNumericalFloatingBoundaries(t *testing.T, code []byte, pcs []int64, mode, vectors int) {
+	t.Helper()
+	original := append([]byte(nil), code...)
+	boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+	if err != nil {
+		t.Fatal("complete original floating instruction lost its native boundary", err)
+	}
+	if !bytes.Equal(code, original) || len(boundaries) != len(pcs) {
+		t.Fatal("complete original Go instruction bytes or PC inventory changed", len(boundaries), len(pcs))
+	}
+	for index, boundary := range boundaries {
+		end := int64(len(code))
+		if index+1 < len(pcs) {
+			end = pcs[index+1]
+		}
+		if boundary.PC != pcs[index] || boundary.Length != int(end-pcs[index]) {
+			t.Fatalf("row %d: observed %+v, original Go [%d,%d)", index, boundary, pcs[index], end)
+		}
+		instruction := code[boundary.PC:end]
+		if index < vectors {
+			if !x86NumericalVectorPrefix(instruction, mode) {
+				t.Fatalf("original vector row became a legacy instruction: %x", instruction)
+			}
+			if _, exists := scalar[boundary.PC]; exists {
+				t.Fatalf("boundary-only floating instruction acquired a scalar input observation: %x", instruction)
+			}
+		}
+		for cut := 0; cut < len(instruction); cut++ {
+			partial, values, err := x86NumericalNativeBoundaries(instruction[:cut], mode)
+			if !errors.Is(err, ErrProbeNeedsContext) || partial != nil || values != nil {
+				t.Fatalf("incomplete original instruction acquired a partial observation: %x cut=%d: %v", instruction, cut, err)
+			}
+		}
+	}
+	if len(scalar) != len(pcs)-vectors || scalar[pcs[vectors]].Op != x86asm.CMP ||
+		scalar[pcs[vectors+1]].Op != x86asm.RET {
+		t.Fatal("vector boundaries replaced the independent scalar CMP/RET observations", scalar)
+	}
+}
+
+func TestX86NumericalNativeBoundariesCompleteFloatingFamiliesOriginalGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, family := range []string{"FMA3", "arithmetic", "sqrt"} {
+			t.Run(arch+"/"+family, func(t *testing.T) {
+				rows := x86NumericalFloatingBoundaryRows(arch, family)
+				members := make(map[string]bool)
+				for _, row := range rows {
+					members[strings.Split(strings.Fields(row)[0], ".")[0]] = true
+				}
+				want := map[string]int{"FMA3": 60, "arithmetic": 24, "sqrt": 4}[family]
+				if len(rows) == 0 || len(members) != want {
+					t.Fatal("independent complete floating member inventory changed", family, len(members), want)
+				}
+				code, pcs := x86NumericalBoundaryGoBytes(t, arch,
+					strings.Join(rows, "\n")+"\nCMPB feature+7(SB),$1\nRET")
+				if len(pcs) != len(rows)+2 {
+					t.Fatal("actual Go expanded or omitted an independent row", len(rows), len(pcs))
+				}
+				mode := 64
+				if arch == "386" {
+					mode = 32
+				}
+				x86CheckNumericalFloatingBoundaries(t, code, pcs, mode, len(rows))
+				t.Logf("complete actual Go %s %s: members=%d physical rows=%d; every byte cut rejected",
+					arch, family, len(members), len(rows))
+			})
+		}
+	}
+}
+
+func TestX86NumericalFloatingBoundaryRIPIsNotSourceOrNumericalAuthority(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		decode      x86RawInstructionDecoder
+	}{
+		{"VFNMADD231SD table+17(SB),X1,X2", decodedX86VEXFMA3Instruction},
+		{"VFMADD213SD table-17(SB),X1,X2", decodedX86VEXFMA3Instruction},
+		{"VFMADDSUB132PS.BCST.Z table(SB),Z1,K7,Z2", decodedX86VEXFMA3Instruction},
+		{"VADDSD table+17(SB),X1,X2", decodedX86VEXBinaryFloatInstruction},
+		{"VMULPS.BCST.Z table-17(SB),Z1,K7,Z2", decodedX86VEXBinaryFloatInstruction},
+		{"VMINPD.BCST table(SB),Y1,Y2", decodedX86VEXBinaryFloatInstruction},
+		{"VSQRTSD table+17(SB),X1,X2", decodedX86VEXBinaryFloatInstruction},
+		{"VSQRTPS.BCST.Z table-17(SB),K7,Z2", decodedX86SameWidthConversionInstruction},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row.instruction+"\nRET")
+			if len(pcs) != 2 {
+				t.Fatal("original physical RIP source changed its instruction count", pcs)
+			}
+			_, _, known, err := row.decode(code[:pcs[1]], 64)
+			if !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatal("default raw decoder acquired source/literal permission", known, err)
+			}
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+			if err != nil || len(boundaries) != 2 || boundaries[0].Length != int(pcs[1]) ||
+				len(scalar) != 1 || scalar[pcs[1]].Op != x86asm.RET {
+				t.Fatal("physical RIP must provide only a complete byte boundary", boundaries, scalar, err)
+			}
+			var source strings.Builder
+			source.WriteString("TEXT ·Value(SB),4,$0-0\n")
+			for _, value := range code {
+				fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Value()", "amd64",
+					"x86_64-unknown-linux-gnu", api)
+				// The assembler object's relocation is deliberately not linked.
+				// Copying its zero disp32 into BYTE source leaves no actual pool:
+				// this is malformed literal/source rejection, not missing NUM.
+				if ir != "" || err == nil {
+					t.Fatal("an unlinked RIP relocation became a public literal source", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86NumericalFloatingBoundaryCannotCreateLiteralNumericalInputs(t *testing.T) {
+	for _, row := range []struct {
+		name      string
+		opcode    byte
+		prefix    byte
+		width     int
+		evex      bool
+		broadcast bool
+	}{
+		{"LiteralAddSD", 0x58, 3, 16, false, false},
+		{"LiteralMulPS", 0x59, 0, 32, false, false},
+		{"LiteralMinPD", 0x5d, 1, 16, false, false},
+		{"LiteralDivPD", 0x5e, 1, 64, true, false},
+		{"LiteralMaxPS", 0x5f, 0, 32, true, true},
+		{"LiteralSubSS", 0x5c, 2, 16, true, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			code := x86RawBinaryFloatLiteral(row.opcode, row.prefix, row.evex, row.width, row.broadcast)
+			source := x86RawVectorLiteralSource(x86RawVectorLiteralCase{name: row.name, code: code})
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+			if err != nil || len(file.Data) != 1 || len(file.Data[0].Payload) == 0 {
+				t.Fatal("independent complete inline literal/RET prerequisite failed", err)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				declaration := "func " + row.name + "()"
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64",
+					"x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Fatal("complete initialized inline literal positive control failed", api, err)
+				}
+				for _, missing := range []string{"VPXORD Z0,Z0,Z0\n", "KMOVD AX,K7\n"} {
+					if missing == "KMOVD AX,K7\n" && !row.evex {
+						continue
+					}
+					changed := strings.Replace(source, missing, "", 1)
+					if changed == source {
+						t.Fatal("missing-input control did not change the real source", missing)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64",
+						"x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("complete literal bytes invented missing vector/mask NUM inputs", api, missing, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86NumericalFloatingBoundariesRetainCompleteEncodingGuards(t *testing.T) {
+	wrongFMAControl := encodeX86VEXFMA3(0x98, false, false, 2, 1, 0)
+	wrongFMAControl[2] &^= 1 // FMA3 requires the 66 mandatory prefix.
+	wrongFloatWidth := encodeX86EVEXBinaryFloat(0x58, 0, 0, false, false, 0, 2, 1, 0)
+	wrongFloatWidth[2] |= 0x80 // EVEX PS requires W0; WIG is VEX-only.
+	wrongEVEXReserved := encodeX86EVEXFMA3(0x98, false, 0, false, false, 0, 2, 1, 0)
+	wrongEVEXReserved[2] &^= 4
+	scalarFMABroadcast := encodeX86EVEXFMA3(0x99, false, 0, true, false, 0, 2, 1, 0)
+	scalarFMABroadcast[5] = 0x10 // A scalar memory source has no broadcast form.
+	scalarFloatBroadcast := encodeX86EVEXBinaryFloat(0x58, 2, 0, true, false, 0, 2, 1, 0)
+	scalarFloatBroadcast[5] = 0x10
+	packedSqrtReserved := encodeX86VEXBinaryFloat(0x51, 0, true, false, false, 2, 0, 0)
+	packedSqrtReserved[2] ^= 8 // Unary SQRT reserves VEX.vvvv.
+	for name, code := range map[string][]byte{
+		"FMA mandatory prefix": wrongFMAControl,
+		"FMA scalar VEX L":     encodeX86VEXFMA3(0x99, false, true, 2, 1, 0),
+		"FMA reserved EVEX":    wrongEVEXReserved,
+		"FMA reserved length":  encodeX86EVEXFMA3(0x98, false, 3, false, false, 0, 2, 1, 0),
+		"FMA zero without K":   encodeX86EVEXFMA3(0x98, false, 0, false, true, 0, 2, 1, 0),
+		"FMA scalar BCST":      scalarFMABroadcast,
+		"float fixed EVEX W":   wrongFloatWidth,
+		"float scalar VEX L":   encodeX86VEXBinaryFloat(0x58, 2, true, true, false, 2, 1, 0),
+		"float length":         encodeX86EVEXBinaryFloat(0x58, 0, 3, false, false, 0, 2, 1, 0),
+		"float zero without K": encodeX86EVEXBinaryFloat(0x58, 0, 0, false, true, 0, 2, 1, 0),
+		"float scalar BCST":    scalarFloatBroadcast,
+		"packed sqrt vvvv":     packedSqrtReserved,
+	} {
+		for _, mode := range []int{32, 64} {
+			t.Run(fmt.Sprintf("%s/%d", name, mode), func(t *testing.T) {
+				for _, prefix := range [][]byte{nil, {0x90, 0xc3}, {0xeb, 0x7f}} {
+					whole := append(append([]byte(nil), prefix...), code...)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(whole, mode)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatalf("invalid/unreachable floating bytes retained a partial observation: %x %v", whole, err)
+					}
+				}
+			})
+		}
+	}
+	for _, code := range [][]byte{
+		// Keep the mode32 vector discriminator intact; only vvvv/V' selects
+		// an unavailable physical bank. Extended R/B can instead encode LES
+		// or BOUND in that mode and is not an invalid vector witness.
+		encodeX86VEXFMA3(0x98, true, true, 2, 15, 0),
+		encodeX86EVEXFMA3(0xb9, true, 0, false, false, 0, 2, 31, 0),
+		encodeX86VEXBinaryFloat(0x58, 1, true, true, true, 2, 15, 0),
+		encodeX86EVEXBinaryFloat(0x5f, 1, 0, false, false, 0, 2, 31, 0),
+	} {
+		boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+		if err != nil || len(boundaries) != 1 || boundaries[0].Length != len(code) || len(scalar) != 0 {
+			t.Fatal("complete actual mode64 physical bank lost its boundary", boundaries, scalar, err)
+		}
+		if !x86NumericalVectorPrefix(code, 32) {
+			t.Fatal("mode32 negative no longer has a physical vector prefix", code)
+		}
+		if boundaries, scalar, err := x86NumericalNativeBoundaries(code, 32); !errors.Is(err, ErrProbeNeedsContext) ||
+			boundaries != nil || scalar != nil {
+			t.Fatal("physical mode32 acquired an extended vector bank", boundaries, scalar, err)
+		}
+	}
+}
+
+func TestX86NumericalFloatingBoundaryKeepsMode32LegacyDiscriminator(t *testing.T) {
+	// These exact bytes were the incorrect high-bank vector negatives in the
+	// first GREEN candidate. In mode32 they are complete ordinary instructions,
+	// independently decoded by x86asm, not vector encodings with bad registers.
+	for _, fixture := range []struct {
+		code []byte
+		ops  []x86asm.Op
+	}{
+		{[]byte{0xc4, 0x42, 0x8d, 0x98, 0xfd}, []x86asm.Op{x86asm.LES, x86asm.CWDE, x86asm.STD}},
+		{[]byte{0xc4, 0x41, 0x8d, 0x58, 0xfd}, []x86asm.Op{x86asm.LES, x86asm.POP, x86asm.STD}},
+	} {
+		if x86NumericalVectorPrefix(fixture.code, 32) || !x86NumericalVectorPrefix(fixture.code, 64) {
+			t.Fatal("physical legacy/vector discriminator changed", fixture.code)
+		}
+		boundaries, scalar, err := x86NumericalNativeBoundaries(fixture.code, 32)
+		if err != nil || len(boundaries) != len(fixture.ops) || len(scalar) != len(fixture.ops) {
+			t.Fatal("legitimate mode32 legacy sequence lost its complete boundary", boundaries, scalar, err)
+		}
+		pc := 0
+		for index, opcode := range fixture.ops {
+			native, err := x86asm.Decode(fixture.code[pc:], 32)
+			if err != nil || native.Op != opcode || native.Len <= 0 ||
+				boundaries[index].PC != int64(pc) || boundaries[index].Length != native.Len || scalar[int64(pc)] != native {
+				t.Fatal("mode32 scalar identity differs from independent x86asm", index, native, err)
+			}
+			pc += native.Len
+		}
+		if pc != len(fixture.code) {
+			t.Fatal("mode32 observer discarded native legacy bytes", pc, len(fixture.code))
+		}
+	}
+}
diff --git a/x86_numerical_packed_boundaries_test.go b/x86_numerical_packed_boundaries_test.go
new file mode 100644
index 000000000..e711763e4
--- /dev/null
+++ b/x86_numerical_packed_boundaries_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent operation directory; the production raw decoder does not define
+// this test's members. Legal encoding, width and mask axes stay constrained.
+func x86NumericalPackedBoundaryRows(arch string) []string {
+	names := strings.Fields("VPADDB VPADDW VPADDD VPADDQ VPADDSB VPADDSW VPADDUSB VPADDUSW " +
+		"VPSUBB VPSUBW VPSUBD VPSUBQ VPSUBSB VPSUBSW VPSUBUSB VPSUBUSW VPSHUFB " +
+		"VPMULLD VPMULLQ VPMULLW VPMULHW VPMULHUW VPMULHRSW VPMULDQ VPMULUDQ " +
+		"VPAVGB VPAVGW VPMADDWD VPMADDUBSW " +
+		"VPMINSB VPMINUB VPMINSW VPMINUW VPMINSD VPMINUD VPMINSQ VPMINUQ " +
+		"VPMAXSB VPMAXUB VPMAXSW VPMAXUW VPMAXSD VPMAXUD VPMAXSQ VPMAXUQ")
+	if arch == "amd64" {
+		names = append(names, "VPALIGNR") // Go's 386 frontend has no four-operand form.
+	}
+	var rows []string
+	for _, name := range names {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, mask := range []string{"", "K1,", "K7,"} {
+				if arch == "386" && mask != "" {
+					continue
+				}
+				prefix, suffix := "", ""
+				if name == "VPALIGNR" {
+					prefix = "$255,"
+				}
+				if mask == "K7," {
+					suffix = ".Z"
+				}
+				for _, first := range []string{bank + "0", "-128(AX)(CX*4)", "table+17(SB)"} {
+					row := fmt.Sprintf("%s%s %s%s,%s1,%s%s2", name, suffix, prefix, first, bank, mask, bank)
+					rows = append(rows, row)
+					if arch == "amd64" && mask == "" && bank != "Z" {
+						// Force the independent EVEX encoding, not a duplicate VEX spelling.
+						rows = append(rows, strings.NewReplacer(bank+"0", bank+"16", bank+"1", bank+"17", bank+"2", bank+"18").Replace(row))
+					}
+				}
+				minmax := strings.HasPrefix(name, "VPMIN") || strings.HasPrefix(name, "VPMAX")
+				broadcast := name == "VPADDD" || name == "VPADDQ" || name == "VPSUBD" || name == "VPSUBQ" ||
+					name == "VPMULLD" || name == "VPMULLQ" || name == "VPMULDQ" || name == "VPMULUDQ" ||
+					minmax && (strings.HasSuffix(name, "D") || strings.HasSuffix(name, "Q"))
+				if broadcast {
+					rows = append(rows, fmt.Sprintf("%s.BCST%s table+17(SB),%s1,%s%s2", name, suffix, bank, mask, bank))
+				}
+			}
+		}
+	}
+	for _, row := range x86PackedShiftRawCases() {
+		if arch == "386" && row.mask != 0 {
+			continue
+		}
+		instruction := row.instruction()
+		if row.evex && arch == "amd64" {
+			instruction = strings.NewReplacer("X0", "X16", "X1", "X17", "X2", "X18",
+				"Y0", "Y16", "Y1", "Y17", "Y2", "Y18", "Z0", "Z16", "Z1", "Z17", "Z2", "Z18").Replace(instruction)
+		}
+		rows = append(rows, instruction)
+		if row.input != "register" {
+			rows = append(rows, strings.Replace(instruction, "(BX)", "table-17(SB)", 1),
+				strings.Replace(instruction, "(BX)", "128(AX)(CX*4)", 1))
+		}
+	}
+	if arch == "amd64" {
+		for _, row := range x86ImmediateBlendCases() {
+			if row.legacy {
+				continue
+			}
+			instruction := row.instruction("255")
+			rows = append(rows, instruction)
+			if row.memory {
+				rows = append(rows, strings.Replace(instruction, "(BX)", "table-17(SB)", 1),
+					strings.Replace(instruction, "(BX)", "128(AX)(CX*4)", 1))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86NumericalPackedFamiliesOriginalPhysicalBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86NumericalPackedBoundaryRows(arch)
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPL AX,$1\nRET")
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			x86CheckNumericalFloatingBoundaries(t, code, pcs, mode, len(rows))
+			t.Logf("actual Go physical boundaries: mode=%d forms=%d bytes=%d; not translation/runtime evidence", mode, len(rows), len(code))
+		})
+	}
+}
+
+func TestX86NumericalPackedPhysicalMemoryDoesNotGrantRawSource(t *testing.T) {
+	for _, row := range []struct {
+		instruction string
+		decode      func([]byte, int) (Instr, int, bool, error)
+	}{
+		{"VPADDQ table+17(SB),Y1,Y2", decodedX86PackedIntegerArithmeticInstruction},
+		{"VPSUBD.BCST.Z table-17(SB),Z17,K1,Z18", decodedX86PackedIntegerArithmeticInstruction},
+		{"VPSHUFB table+17(SB),Y1,Y2", decodedX86VPSHUFBInstruction},
+		{"VPSHUFB.Z table-17(SB),Z17,K1,Z18", decodedX86VPSHUFBInstruction},
+		{"VPALIGNR $255,table+17(SB),Y1,Y2", decodedX86PackedAlignRightInstruction},
+		{"VPALIGNR.Z $255,table-17(SB),Z17,K1,Z18", decodedX86PackedAlignRightInstruction},
+		{"VPSRLQ table+17(SB),Y1,Y2", decodedX86PackedUniformShiftInstruction},
+		{"VPSRAQ.BCST.Z $255,table-17(SB),K1,Z18", decodedX86PackedUniformShiftInstruction},
+		{"VPSLLVQ table+17(SB),Y1,Y2", decodedX86PerLaneVariableShiftInstruction},
+		{"VPSRAVD.BCST.Z table-17(SB),Z17,K1,Z18", decodedX86PerLaneVariableShiftInstruction},
+		{"VPSLLDQ $255,table+17(SB),X18", decodedX86RawVectorByteShiftInstruction},
+		{"VPSRLDQ $255,table-17(SB),Z18", decodedX86RawVectorByteShiftInstruction},
+		{"VPAVGB table+17(SB),Y1,Y2", decodedX86PackedAverageInstruction},
+		{"VPAVGW.Z table-17(SB),Z17,K1,Z18", decodedX86PackedAverageInstruction},
+		{"VPMINSD table+17(SB),Y1,Y2", decodedX86PackedIntegerMinMaxInstruction},
+		{"VPMAXUQ.BCST.Z table-17(SB),Z17,K1,Z18", decodedX86PackedIntegerMinMaxInstruction},
+		{"VPMULHW table+17(SB),Y1,Y2", decodedX86PackedMultiplyInstruction},
+		{"VPMULLQ.BCST.Z table-17(SB),Z17,K1,Z18", decodedX86PackedMultiplyInstruction},
+		{"VPMULDQ table+17(SB),Y1,Y2", decodedX86DwordToQwordMultiplyInstruction},
+		{"VPMULUDQ.BCST.Z table-17(SB),Z17,K1,Z18", decodedX86DwordToQwordMultiplyInstruction},
+		{"VPMADDWD table+17(SB),Y1,Y2", decodedX86VEXPackedMADDInstruction},
+		{"VPMADDUBSW.Z table-17(SB),Z17,K1,Z18", decodedX86EVEXPackedMADDInstruction},
+		{"VPBLENDD $255,table+17(SB),Y1,Y2", decodedX86ImmediatePackedBlendInstruction},
+		{"VBLENDPD $255,table-17(SB),X1,X2", decodedX86ImmediatePackedBlendInstruction},
+	} {
+		t.Run(row.instruction, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row.instruction+"\nRET")
+			if _, _, known, err := row.decode(code, 64); !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatal("default raw source decoder gained RIP authority", known, err)
+			}
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+			if err != nil || len(boundaries) != 2 || boundaries[0].Length != int(pcs[1]) || len(scalar) != 1 {
+				t.Fatal("physical memory observation lost full instruction or gained scalar inputs", boundaries, scalar, err)
+			}
+			for _, prefix := range []byte{0x66, 0x67, 0xf0, 0xf2, 0xf3, 0x48} {
+				changed := append([]byte{prefix}, code...)
+				if partial, values, err := x86NumericalNativeBoundaries(changed, 64); !errors.Is(err, ErrProbeNeedsContext) || partial != nil || values != nil {
+					t.Fatal("physical memory adapter accepted forbidden prefix or partial observation", prefix, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_numerical_permute128_boundaries_test.go b/x86_numerical_permute128_boundaries_test.go
new file mode 100644
index 000000000..daf90d0f5
--- /dev/null
+++ b/x86_numerical_permute128_boundaries_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// These are orthogonal physical-PC witnesses, not another selector matrix.
+// The independent family root already owns both complete Go rows and every
+// imm8. Neither measuring a native boundary nor seeing RIP supplies a read.
+func TestX86NumericalPermute128CompletePhysicalBoundaries(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required for independent mode32 VPERM2 boundaries")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var rows []string
+			for _, member := range x86Permute128Members {
+				for _, operands := range []string{
+					"$0,Y0,Y1,Y2", "$255,Y7,Y7,Y7", "$136,(AX),Y1,Y2",
+					"$33,127(AX)(CX*4),Y1,Y2", "$33,-129(AX)(CX*8),Y1,Y2",
+					"$255,2147483647(BX),Y1,Y2", "$0,-2147483648(BX),Y1,Y2",
+				} {
+					rows = append(rows, member.op+" "+operands)
+				}
+				if arch == "amd64" {
+					rows = append(rows, member.op+" $255,Y13,Y14,Y15",
+						member.op+" $136,-129(R11)(R9*4),Y13,Y12")
+				}
+			}
+			want := map[string]int{"386": 14, "amd64": 18}[arch]
+			if len(rows) != want {
+				t.Fatal("independent complete physical-axis denominator changed", len(rows), want)
+			}
+			// Go's named mode32 four-operand syntax is not a physical ISA
+			// witness. Obtain exact named AMD64 PCs, then independently check
+			// all low-bank mode32 bytes with LLVM and the real Go BYTE object.
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64",
+				strings.Join(rows, "\n")+"\nCMPL AX,$1\nRET")
+			if len(pcs) != len(rows)+2 {
+				t.Fatal("actual Go expanded or omitted a boundary witness", len(pcs), len(rows))
+			}
+			mode := 64
+			if arch == "386" {
+				mode = 32
+				for index, row := range rows {
+					observed := x86PackedShiftRawSingleMC(t, mc, "i386-unknown-linux-gnu", code[pcs[index]:pcs[index+1]])
+					mnemonic := strings.ToLower(strings.Fields(row)[0])
+					if strings.Contains(observed, "warning") || strings.Contains(observed, "invalid") ||
+						strings.Count(observed, mnemonic) != 1 {
+						t.Fatal("independent LLVM rejected a complete low-bank mode32 witness", row, observed)
+					}
+				}
+				actual, _ := x86NumericalBoundaryGoBytes(t, arch, x86RawDisplacementDirectives(code))
+				if !bytes.Equal(actual, code) {
+					t.Fatal("actual mode32 Go object changed the independently checked physical bytes")
+				}
+			}
+			x86CheckNumericalFloatingBoundaries(t, code, pcs, mode, len(rows))
+		})
+	}
+	for _, member := range x86Permute128Members {
+		for _, control := range []string{"W1", "L0", "pp", "missing-imm", "mode32-high-vvvv"} {
+			t.Run(member.op+"/"+control, func(t *testing.T) {
+				code := encodeX86RawVPERM2X128(member.opcode, 0x21, 0, 1, 2)
+				mode := 64
+				switch control {
+				case "W1":
+					code[2] |= 0x80
+				case "L0":
+					code[2] &^= 4
+				case "pp":
+					code[2] &^= 3
+				case "missing-imm":
+					code = code[:len(code)-1]
+				case "mode32-high-vvvv":
+					mode = 32
+					code = encodeX86RawVPERM2X128(member.opcode, 0x21, 0, 8, 2)
+					if !x86NumericalVectorPrefix(code, mode) {
+						t.Fatal("mode32 negative became a legacy LES/LDS sequence")
+					}
+				}
+				for _, prefix := range [][]byte{nil, {0x90, 0xc3}, {0xeb, 0x7f}} {
+					whole := append(append([]byte(nil), prefix...), code...)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(whole, mode)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatal("malformed or unreachable VPERM2 retained a partial observation", control, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86NumericalPermute128RIPBoundaryIsNotSourceNUM(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for _, offset := range []int{-17, 17} {
+			t.Run(fmt.Sprintf("%s/RIP%+d", member.op, offset), func(t *testing.T) {
+				row := fmt.Sprintf("%s $33,table%+d(SB),Y1,Y2", member.op, offset)
+				code, pcs, listing := x86NumericalBoundaryGoBytesAndListing(t, "amd64", row+"\nRET")
+				expected := []byte{0xc4, 0xe3, 0x75, member.opcode, 0x15, 0, 0, 0, 0, 0x21, 0xc3}
+				// The trailing imm8 is after disp32: cmd/asm subtracts one
+				// from the R_PCREL addend, relative to the relocation's end.
+				if !bytes.Equal(code, expected) || !reflect.DeepEqual(pcs, []int64{0, 10}) {
+					t.Fatalf("actual Go RIP bytes/PCs/relocation prerequisite changed: %x %v\n%s", code, pcs, listing)
+				}
+				x86NumericalRequirePCRelListing(t, listing, 5, offset-1)
+				if _, _, known, err := decodedX86Permute128Instruction(code, 64); !known || err == nil ||
+					!strings.Contains(err.Error(), "RIP-relative") {
+					t.Fatal("default raw decoder acquired a source RIP/literal role", known, err)
+				}
+				boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+				if err != nil || len(boundaries) != 2 || boundaries[0].PC != 0 || boundaries[0].Length != 10 ||
+					boundaries[1].PC != 10 || boundaries[1].Length != 1 || len(scalar) != 1 || scalar[10].Op != x86asm.RET {
+					t.Fatal("physical RIP must supply only the complete native boundary", boundaries, scalar, err)
+				}
+				for cut := 0; cut < 10; cut++ {
+					boundaries, scalar, err := x86NumericalNativeBoundaries(code[:cut], 64)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatal("truncated RIP/imm8 acquired a partial observation", cut, err)
+					}
+				}
+				reads, err := numericalNativeReads(code, 64)
+				if err != nil || len(reads) != 0 {
+					t.Fatal("boundary-only VPERM2 invented an SDK symbolic-read/NUM owner", reads, err)
+				}
+			})
+		}
+		t.Run(member.op+"/no-DATA-or-vector-permission", func(t *testing.T) {
+			const table = "GLOBL table(SB),8,$64\n"
+			source := "TEXT ·Value(SB),4,$0-0\n" + member.op + " $33,table+17(SB),Y1,Y2\nRET\n" + table
+			for offset := 0; offset < 64; offset += 8 {
+				source += fmt.Sprintf("DATA table+%d(SB)/8,$0\n", offset)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("complete Go DATA/source observation created missing vector or literal permissions", api, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_numerical_read_effects.go b/x86_numerical_read_effects.go
new file mode 100644
index 000000000..0dbc7f5f4
--- /dev/null
+++ b/x86_numerical_read_effects.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+// The actual SB source bytes are supplied only by a checked live certificate.
+// All consumers use this same typed shape for the remaining numerical GP and
+// flags effects; no observer turns the global into a pointer or numeric literal.
+func x86NumericalReadEffect(ins Instr, arch string) (x86TypedByteEffect, bool) {
+	_, form, valid := numericalCertifiedRead(ins, arch)
+	if !valid {
+		return x86TypedByteEffect{}, false
+	}
+	if form.spec.vector == x86NumericalSBAES {
+		effect, known, err := x86TypedAESByteEffect(ins.Op, ins, arch)
+		if !known || err != nil {
+			return x86TypedByteEffect{}, false
+		}
+		return numericalVectorRegisterEffect(effect, form.operand), true
+	}
+	if form.spec.vector == x86NumericalSBLogical {
+		logical, _, _ := x86PackedLogicalProperties(ins, arch)
+		effect := x86TypedByteEffect{operands: []x86TypedByteOperand{
+			{index: logical.second, operand: ins.Args[logical.second], width: int64(logical.byteWidth), read: true},
+			{index: logical.destination, operand: ins.Args[logical.destination], width: int64(logical.byteWidth),
+				read: logical.mask >= 0 && !logical.zeroing, write: true},
+		}}
+		return effect, true
+	}
+	partner := x86TypedByteOperand{index: form.partner, operand: ins.Args[form.partner], width: form.spec.gpBytes,
+		read: form.spec.compare, write: !form.spec.compare}
+	effect := x86TypedByteEffect{operands: []x86TypedByteOperand{partner}}
+	if form.spec.compare {
+		effect.flagsDefined, effect.flagsKilled = x86ByteFlagsAll, x86ByteFlagsAll
+	}
+	return effect, true
+}
+
+func numericalVectorRegisterEffect(effect x86TypedByteEffect, memory int) x86TypedByteEffect {
+	registers := effect.operands[:0]
+	for _, operand := range effect.operands {
+		if operand.index != memory {
+			registers = append(registers, operand)
+		}
+	}
+	effect.operands = registers
+	return effect
+}
+
+func x86ResultNumericalReadStep(ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) (bool, bool) {
+	if ins.x86NumericalRead == nil {
+		return false, false
+	}
+	if _, form, valid := numericalCertifiedRead(ins, arch); valid && form.spec.vector != x86NumericalSBScalar {
+		return x86ResultNumericalVectorStep(ins, state, arch, form)
+	}
+	effect, valid := x86NumericalReadEffect(ins, arch)
+	if !valid {
+		return false, true
+	}
+	for _, operand := range effect.operands {
+		if operand.read && !x86ResultRead(operand.operand, operand.width, state, owned, arch) ||
+			operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, offset, arch) {
+			return false, true
+		}
+	}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
+
+func x86CallerNumericalReadStep(ins Instr, state *x86SourceStackState) (bool, bool) {
+	if ins.x86NumericalRead == nil {
+		return false, false
+	}
+	if _, form, valid := numericalCertifiedRead(ins, "amd64"); valid && form.spec.vector != x86NumericalSBScalar {
+		return numericalVectorMapStep(ins, "amd64", form, state.vectors, state.masks), true
+	}
+	effect, valid := x86NumericalReadEffect(ins, "amd64")
+	if !valid {
+		return false, true
+	}
+	for _, operand := range effect.operands {
+		if operand.read && !x86CallerNumericRead(operand.operand, operand.width, state) ||
+			operand.write && !x86CallerNumericWrite(operand.operand.Reg, operand.width, state) {
+			return false, true
+		}
+	}
+	if effect.flagsDefined != 0 {
+		state.numericFlags = true
+	}
+	return true, true
+}
diff --git a/x86_numerical_relocation_listing_test.go b/x86_numerical_relocation_listing_test.go
new file mode 100644
index 000000000..99df66f45
--- /dev/null
+++ b/x86_numerical_relocation_listing_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Older SDK listings print the relocation number instead of its name. Bind
+// that spelling to the selected SDK's generated compile-time enum assertion,
+// not a current object schema or a hard-coded historical relocation number.
+func x86NumericalPCRelEnumKind(source string) (string, error) {
+	assertions := regexp.MustCompile(`(?m)^[\t ]*_ = x\[R_PCREL-([0-9]+)\][\t ]*$`).FindAllStringSubmatch(source, -1)
+	if len(assertions) != 1 {
+		return "", fmt.Errorf("selected SDK lacks one exact R_PCREL enum assertion: got %d", len(assertions))
+	}
+	return assertions[0][1], nil
+}
+
+func x86NumericalPCRelListingRow(listing, numericKind string, offset, addend int) error {
+	var rows []string
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) != 0 && fields[0] == "rel" {
+			rows = append(rows, strings.TrimSpace(line))
+		}
+	}
+	if len(rows) != 1 {
+		return fmt.Errorf("expected one complete relocation row, got %d: %v", len(rows), rows)
+	}
+	named := fmt.Sprintf("rel %d+4 t=R_PCREL table+%d", offset, addend)
+	numeric := fmt.Sprintf("rel %d+4 t=%s table+%d", offset, numericKind, addend)
+	if rows[0] != named && rows[0] != numeric {
+		return fmt.Errorf("unexpected relocation row %q; want %q or %q", rows[0], named, numeric)
+	}
+	return nil
+}
+
+func x86NumericalRequirePCRelListing(t testing.TB, listing []byte, offset, addend int) {
+	t.Helper()
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "objabi", "reloctype_string.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	kind, err := x86NumericalPCRelEnumKind(string(source))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86NumericalPCRelListingRow(string(listing), kind, offset, addend); err != nil {
+		t.Fatalf("actual selected-SDK R_PCREL listing prerequisite: %v\n%s", err, listing)
+	}
+}
+
+func TestX86NumericalPCRelListingEnumIdentity(t *testing.T) {
+	const assertion = "\t_ = x[R_PCREL-93]\n"
+	for _, test := range []struct {
+		name, source, want string
+	}{
+		{"exact", assertion, "93"},
+		{"different-SDK-value", "\t_ = x[R_PCREL-14]\n", "14"},
+		{"missing", "\t_ = x[R_ADDR-93]\n", ""},
+		{"duplicate", assertion + assertion, ""},
+		{"ambiguous", assertion + "\t_ = x[R_PCREL-94]\n", ""},
+		{"wrong-namespace", "\t_ = x[other.R_PCREL-93]\n", ""},
+		{"wrong-array", "\t_ = y[R_PCREL-93]\n", ""},
+		{"comment-only", "// _ = x[R_PCREL-93]\n", ""},
+		{"trailing-expression", "\t_ = x[R_PCREL-93] + 1\n", ""},
+		{"truncated", "\t_ = x[R_PCREL-93\n", ""},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			kind, err := x86NumericalPCRelEnumKind(test.source)
+			if test.want == "" {
+				if err == nil || kind != "" {
+					t.Fatal("unbound SDK relocation enum was accepted", kind, err)
+				}
+			} else if err != nil || kind != test.want {
+				t.Fatal("exact SDK relocation enum was lost", kind, err)
+			}
+		})
+	}
+}
+
+func TestX86NumericalPCRelListingDisplayContracts(t *testing.T) {
+	const named = "rel 5+4 t=R_PCREL table+-18"
+	const numeric = "rel 5+4 t=93 table+-18"
+	for _, test := range []struct {
+		name, listing string
+		accepted      bool
+	}{
+		{"named", "\t" + named + "\n", true},
+		{"selected-SDK-numeric", "\t" + numeric + "\n", true},
+		{"negative-addend-spelling", "rel 5+4 t=R_PCREL table-18\n", false},
+		{"missing", "boundary STEXT size=11\n", false},
+		{"duplicate-named", named + "\n" + named + "\n", false},
+		{"duplicate-numeric", numeric + "\n" + numeric + "\n", false},
+		{"duplicate-mixed", named + "\n" + numeric + "\n", false},
+		{"foreign-numeric", "rel 5+4 t=94 table+-18\n", false},
+		{"foreign-kind", "rel 5+4 t=R_ADDR table+-18\n", false},
+		{"extra-foreign-row", named + "\nrel 0+4 t=R_ADDR other+0\n", false},
+		{"wrong-offset", "rel 6+4 t=R_PCREL table+-18\n", false},
+		{"wrong-size", "rel 5+8 t=R_PCREL table+-18\n", false},
+		{"wrong-symbol", "rel 5+4 t=R_PCREL other+-18\n", false},
+		{"wrong-addend", "rel 5+4 t=R_PCREL table+-17\n", false},
+		{"symbol-prefix", "rel 5+4 t=R_PCREL table2+-18\n", false},
+		{"trailing-fields", named + " unexpected\n", false},
+		{"truncated", "rel 5+4 t=R_PCREL\n", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			err := x86NumericalPCRelListingRow(test.listing, "93", 5, -18)
+			if (err == nil) != test.accepted {
+				t.Fatal("SDK display compatibility changed the exact relocation contract", err)
+			}
+		})
+	}
+	for _, offset := range []int{5, 6} {
+		for _, addend := range []int{-18, -17, 16, 17} {
+			for _, kind := range []string{"R_PCREL", "93"} {
+				listing := fmt.Sprintf("rel %d+4 t=%s table+%d\n", offset, kind, addend)
+				if err := x86NumericalPCRelListingRow(listing, "93", offset, addend); err != nil {
+					t.Fatal("exact opcode-specific displacement/addend was lost", err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_numerical_scalar_lane_boundaries_test.go b/x86_numerical_scalar_lane_boundaries_test.go
new file mode 100644
index 000000000..dbc427861
--- /dev/null
+++ b/x86_numerical_scalar_lane_boundaries_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalScalarLaneOriginalPhysicalBoundaries(t *testing.T) {
+	var rows []string
+	for _, encoding := range []string{"legacy", "VEX", "EVEX"} {
+		prefix, base, destination := "", "X1", "X2"
+		if encoding != "legacy" {
+			prefix = "V"
+		}
+		if encoding == "EVEX" {
+			base, destination = "X20", "X21"
+		}
+		for _, suffix := range []string{"B", "W", "D", "Q"} {
+			for _, transfer := range []string{"AX", "11(BX)(CX*2)", "table+7(SB)", "11(BX)(FS)"} {
+				insert := fmt.Sprintf("%sPINSR%s $255,%s,%s", prefix, suffix, transfer, base)
+				if prefix != "" {
+					insert += "," + destination
+				}
+				rows = append(rows, insert, fmt.Sprintf("%sPEXTR%s $255,%s,%s", prefix, suffix, base, transfer))
+			}
+		}
+		if prefix != "" {
+			// This sibling shares the complete scalar-extract decoder.
+			for _, transfer := range []string{"AX", "11(BX)(CX*2)", "table+7(SB)", "11(BX)(FS)"} {
+				rows = append(rows, fmt.Sprintf("VEXTRACTPS $255,%s,%s", base, transfer))
+			}
+		}
+	}
+	if len(rows) != 104 {
+		t.Fatal("complete scalar-lane physical source inventory changed", len(rows))
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", strings.Join(rows, "\n")+"\nRET")
+	if len(pcs) != len(rows)+1 {
+		t.Fatal("original Go instruction inventory changed", len(pcs), len(rows))
+	}
+	for index, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			instruction := code[pcs[index]:pcs[index+1]]
+			boundaries, scalar, err := x86NumericalNativeBoundaries(instruction, 64)
+			vector := strings.HasPrefix(row, "V")
+			if err != nil || len(boundaries) != 1 || boundaries[0].Length != len(instruction) ||
+				vector && len(scalar) != 0 || !vector && len(scalar) != 1 {
+				t.Fatalf("original scalar-lane boundary %x: %v %v %v", instruction, boundaries, scalar, err)
+			}
+			for cut := 1; cut < len(instruction); cut++ {
+				if boundaries, scalar, err := x86NumericalNativeBoundaries(instruction[:cut], 64); err == nil || boundaries != nil || scalar != nil {
+					t.Fatal("truncated scalar-lane instruction acquired a complete observation", cut, boundaries, scalar, err)
+				}
+			}
+			if vector && strings.Contains(row, "(SB)") {
+				decode := decodedX86PackedScalarExtractInstruction
+				if strings.Contains(row, "PINSR") {
+					decode = decodedX86VPINSRInstruction
+					if instruction[0] == 0x62 {
+						decode = decodedX86EVEXVPINSRInstruction
+					}
+				}
+				if _, _, known, err := decode(instruction, 64); !known || err == nil {
+					t.Fatal("physical RIP boundary granted raw source-layout permission", row, known, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86NumericalScalarLanePhysicalBoundaryGuards(t *testing.T) {
+	for _, row := range []string{"VPINSRB $0,AX,X1,X2", "VPINSRW $0,AX,X1,X2", "VPINSRQ $0,AX,X20,X21", "VPEXTRB $0,X1,AX", "VPEXTRW $0,X20,AX"} {
+		code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row+"\nRET")
+		original := code[:pcs[1]]
+		for _, mutation := range []string{"vector length", "address override", "mandatory prefix"} {
+			t.Run(row+"/"+mutation, func(t *testing.T) {
+				changed := append([]byte(nil), original...)
+				prefix := 2
+				if changed[0] == 0xc5 {
+					prefix = 1
+				}
+				switch mutation {
+				case "vector length":
+					if changed[0] == 0x62 {
+						changed[3] |= 0x20
+					} else {
+						changed[prefix] |= 4
+					}
+				case "address override":
+					changed = append([]byte{0x67}, changed...)
+				case "mandatory prefix":
+					changed[prefix] &^= 3
+				}
+				if boundaries, scalar, err := x86NumericalNativeBoundaries(changed, 64); err == nil || boundaries != nil || scalar != nil {
+					t.Fatal("invalid encoding acquired complete native boundaries", mutation, boundaries, scalar, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numerical_shuffle_boundaries_test.go b/x86_numerical_shuffle_boundaries_test.go
new file mode 100644
index 000000000..4fa58b21f
--- /dev/null
+++ b/x86_numerical_shuffle_boundaries_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalPackedShuffleOriginalPhysicalBoundaries(t *testing.T) {
+	// The independently audited Go table contains all ten encoding rows for
+	// each of the three members. Expand operand roles, not decoder output.
+	original := x86OfficialImmediateShuffleRows(t)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var rows []string
+			for _, row := range original {
+				parts := strings.SplitN(row, " ", 2)
+				args := strings.Split(parts[1], ",")
+				masked := len(args) == 4
+				destination := args[len(args)-1]
+				if arch == "386" && (masked || strings.HasSuffix(destination, "17")) {
+					// Go's 386 frontend rejects four operands; high X/Y names
+					// are source-only aliases, not physical extended registers.
+					continue
+				}
+				evex := masked || strings.HasSuffix(destination, "17") || strings.HasPrefix(destination, "Z")
+				suffixes := []string{""}
+				if masked {
+					suffixes = append(suffixes, ".Z")
+				}
+				inputs := []string{args[1], "-128(AX)(CX*4)", "table+17(SB)", "table-17(SB)"}
+				for index, input := range inputs {
+					args[1] = input
+					for _, suffix := range suffixes {
+						rows = append(rows, parts[0]+suffix+" "+strings.Join(args, ","))
+						if index != 0 && evex && parts[0] == "VPSHUFD" {
+							rows = append(rows, parts[0]+".BCST"+suffix+" "+strings.Join(args, ","))
+						}
+					}
+				}
+			}
+			want, mode := 183, 64
+			if arch == "386" {
+				want, mode = 63, 32
+			}
+			if len(rows) != want {
+				t.Fatal("complete physical shuffle row denominator changed", len(rows), want)
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPL AX,$1\nRET")
+			if len(pcs) != len(rows)+2 {
+				t.Fatal("actual Go expanded or omitted an independent row", len(pcs), len(rows)+2)
+			}
+			x86CheckNumericalFloatingBoundaries(t, code, pcs, mode, len(rows))
+			t.Logf("actual Go physical shuffle boundaries: mode=%d forms=%d; every byte cut rejected, not translation/runtime evidence", mode, len(rows))
+		})
+	}
+}
+
+func TestX86NumericalPackedShufflePhysicalMemoryDoesNotGrantRawSource(t *testing.T) {
+	for _, op := range []string{"VPSHUFD", "VPSHUFHW", "VPSHUFLW"} {
+		rows := []string{
+			op + " $255,table+17(SB),Y1",
+			op + " $255,table-17(SB),X17",
+			op + ".Z $255,table-17(SB),K7,Z1",
+		}
+		if op == "VPSHUFD" {
+			rows = append(rows, op+".BCST.Z $255,table-17(SB),K1,Y1")
+		}
+		for _, row := range rows {
+			t.Run(row, func(t *testing.T) {
+				code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", row+"\nRET")
+				if _, _, known, err := decodedX86PackedShuffleInstruction(code, 64); !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+					t.Fatal("default raw source decoder gained RIP authority", known, err)
+				}
+				boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+				if err != nil || len(boundaries) != 2 || boundaries[0].Length != int(pcs[1]) || len(scalar) != 1 {
+					t.Fatal("physical shuffle observation lost complete imm8 length or gained scalar inputs", boundaries, scalar, err)
+				}
+				for _, prefix := range []byte{0x66, 0x67, 0xf0, 0xf2, 0xf3, 0x48} {
+					changed := append([]byte{prefix}, code...)
+					if partial, values, err := x86NumericalNativeBoundaries(changed, 64); !errors.Is(err, ErrProbeNeedsContext) || partial != nil || values != nil {
+						t.Fatal("physical shuffle accepted forbidden prefix or partial observation", prefix, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_numerical_tail_boundaries_test.go b/x86_numerical_tail_boundaries_test.go
new file mode 100644
index 000000000..1b222d4ab
--- /dev/null
+++ b/x86_numerical_tail_boundaries_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86NumericalNativeTailFamiliesOriginalGoBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var rows []string
+			for _, bank := range []string{"X", "Y"} {
+				for _, op := range []string{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+					for _, src := range []string{"X1", "(AX)", "-64(AX)(CX*4)", "feature+7(SB)"} {
+						rows = append(rows, fmt.Sprintf("%s %s,%s2", op, src, bank))
+					}
+				}
+				for _, op := range []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"} {
+					for _, src := range []string{bank + "1", "(AX)", "-64(AX)(CX*4)", "feature+7(SB)"} {
+						rows = append(rows, fmt.Sprintf("%s %s,%s2,%s3", op, src, bank, bank))
+					}
+				}
+				for _, op := range []string{"VMOVMSKPS", "VMOVMSKPD", "VPMOVMSKB"} {
+					rows = append(rows, fmt.Sprintf("%s %s1,DX", op, bank))
+				}
+				for _, op := range []string{"VPTEST", "VTESTPS", "VTESTPD"} {
+					for _, src := range []string{bank + "1", "(AX)", "-64(AX)(CX*4)", "feature+7(SB)"} {
+						rows = append(rows, fmt.Sprintf("%s %s,%s2", op, src, bank))
+					}
+				}
+			}
+			for _, op := range []string{"VMOVD", "VMOVQ"} {
+				for _, src := range []string{"(AX)", "-64(AX)(CX*4)", "feature+7(SB)"} {
+					rows = append(rows, fmt.Sprintf("%s %s,X2", op, src), fmt.Sprintf("%s X2,%s", op, src))
+				}
+				if op == "VMOVQ" {
+					rows = append(rows, "VMOVQ X1,X2")
+				}
+				if arch == "amd64" || op == "VMOVD" {
+					rows = append(rows, op+" AX,X2", op+" X2,AX")
+				}
+			}
+			if arch == "amd64" {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, op := range []string{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ"} {
+						for _, src := range []string{"AX", "X1", "(AX)", "feature+7(SB)"} {
+							rows = append(rows, fmt.Sprintf("%s.Z %s,K7,%s2", op, src, bank))
+							if bank == "Z" || src == "AX" {
+								rows = append(rows, fmt.Sprintf("%s %s,%s2", op, src, bank))
+							}
+						}
+					}
+					for _, op := range []string{"VPBROADCASTMB2Q", "VPBROADCASTMW2D"} {
+						rows = append(rows, fmt.Sprintf("%s K1,%s2", op, bank))
+					}
+					for _, op := range []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"} {
+						for _, src := range []string{bank + "1", "(AX)", "feature+7(SB)"} {
+							rows = append(rows, fmt.Sprintf("%s %s,%s2,K1", op, src, bank), fmt.Sprintf("%s %s,%s2,K7,K1", op, src, bank))
+							if src != bank+"1" && (strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q")) {
+								rows = append(rows, fmt.Sprintf("%s.BCST %s,%s2,K7,K1", op, src, bank))
+							}
+						}
+					}
+				}
+				rows = append(rows, "VMOVD AX,X31", "VMOVD X31,AX", "VMOVQ AX,X31", "VMOVQ X31,AX", "VMOVQ X31,X30", "VMOVQ feature+7(SB),X31", "VMOVQ X31,feature+7(SB)")
+			}
+			code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPB feature+7(SB),$1\nRET")
+			mode := 64
+			if arch == "386" {
+				mode = 32
+			}
+			boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+			if err != nil {
+				t.Fatal("complete existing native family not observed", err)
+			}
+			var actual []int64
+			for index, boundary := range boundaries {
+				actual = append(actual, boundary.PC)
+				if index >= len(rows) {
+					continue
+				}
+				if _, exists := scalar[boundary.PC]; exists {
+					t.Fatal("vector boundary acquired a scalar numerical read role")
+				}
+				for cut := 1; cut < boundary.Length; cut++ {
+					if values, reads, err := x86NumericalNativeBoundaries(code[boundary.PC:boundary.PC+int64(cut)], mode); err == nil || values != nil || reads != nil {
+						t.Fatal("truncated family acquired a partial observation", index, cut)
+					}
+				}
+			}
+			if !reflect.DeepEqual(pcs, actual) || len(boundaries) != len(rows)+2 || len(scalar) != 2 {
+				t.Fatal("original Go boundary/native scalar identity changed")
+			}
+		})
+	}
+}
+
+func TestX86NumericalNativeTailBroadcastOpcodeIsNotLegacyConfusion(t *testing.T) {
+	// This formerly forbidden stream is actual VPBROADCASTD, not a legacy
+	// instruction after discarding VEX. Observe it only as a complete extent.
+	for _, arch := range []string{"386", "amd64"} {
+		code, pcs := x86NumericalBoundaryGoBytes(t, arch, "VPBROADCASTD X0,X0\nRET")
+		if !bytes.Equal(code, []byte{0xc4, 0xe2, 0x79, 0x58, 0xc0, 0xc3}) || len(pcs) != 2 {
+			t.Fatalf("independent original Go broadcast identity changed: %x %v", code, pcs)
+		}
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		boundaries, scalar, err := x86NumericalNativeBoundaries(code, mode)
+		if err != nil || len(boundaries) != 2 || boundaries[0].Length != 5 || len(scalar) != 1 {
+			t.Fatal("known whole vector extent was confused with a scalar/read grant", boundaries, scalar, err)
+		}
+	}
+}
diff --git a/x86_numerical_vex_gp_boundaries_test.go b/x86_numerical_vex_gp_boundaries_test.go
new file mode 100644
index 000000000..0850c08c2
--- /dev/null
+++ b/x86_numerical_vex_gp_boundaries_test.go
@@ -0,0 +1,353 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// Independent complete Go VEX GP inventory. A ytab's numerical/read/write
+// roles remain distinct; this consumer requests only exact physical PCs.
+var x86NumericalVEXGPFamilies = []struct {
+	stem, table, zcase, prefix, opcode, extension string
+	offset                                        int
+	classes                                       []string
+}{
+	{"ANDN", "_yandnl", "Zvex_rm_v_r", "", "0xF2", "", 2, []string{"Yml", "Yrl", "Yrl"}},
+	{"BEXTR", "_ybextrl", "Zvex_v_rm_r", "", "0xF7", "", 2, []string{"Yrl", "Yml", "Yrl"}},
+	{"BLSI", "_yblsil", "Zvex_rm_r_vo", "", "0xF3", "03", 3, []string{"Yml", "Yrl"}},
+	{"BLSMSK", "_yblsil", "Zvex_rm_r_vo", "", "0xF3", "02", 3, []string{"Yml", "Yrl"}},
+	{"BLSR", "_yblsil", "Zvex_rm_r_vo", "", "0xF3", "01", 3, []string{"Yml", "Yrl"}},
+	{"BZHI", "_ybextrl", "Zvex_v_rm_r", "", "0xF5", "", 2, []string{"Yrl", "Yml", "Yrl"}},
+	{"MULX", "_yandnl", "Zvex_rm_v_r", "vexF2", "0xF6", "", 2, []string{"Yml", "Yrl", "Yrl"}},
+	{"PDEP", "_yandnl", "Zvex_rm_v_r", "vexF2", "0xF5", "", 2, []string{"Yml", "Yrl", "Yrl"}},
+	{"PEXT", "_yandnl", "Zvex_rm_v_r", "vexF3", "0xF5", "", 2, []string{"Yml", "Yrl", "Yrl"}},
+	{"RORX", "_yrorxl", "Zvex_i_rm_r", "vexF2", "0xF0", "", 0, []string{"Yu8", "Yml", "Yrl"}},
+	{"SARX", "_ybextrl", "Zvex_v_rm_r", "vexF3", "0xF7", "", 2, []string{"Yrl", "Yml", "Yrl"}},
+	{"SHLX", "_ybextrl", "Zvex_v_rm_r", "vex66", "0xF7", "", 2, []string{"Yrl", "Yml", "Yrl"}},
+	{"SHRX", "_ybextrl", "Zvex_v_rm_r", "vexF2", "0xF7", "", 2, []string{"Yrl", "Yml", "Yrl"}},
+}
+
+func TestX86NumericalVEXGPCompleteOfficialEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, family := range x86NumericalVEXGPFamilies {
+		for w, suffix := range []string{"L", "Q"} {
+			name, mapName := family.stem+suffix, "vex0F38"
+			if family.stem == "RORX" {
+				mapName = "vex0F3A"
+			}
+			attributes := "avxEscape | vex128 | "
+			if family.prefix != "" {
+				attributes += family.prefix + " | "
+			}
+			encoding := []string{fmt.Sprintf("%s%s | vexW%d", attributes, mapName, w), family.opcode}
+			if family.extension != "" {
+				encoding = append(encoding, family.extension)
+			}
+			first := goasmrules.X86AVXRule{Opcode: name, Ytab: family.table, Prefix: "Pavx",
+				Classes: family.classes, ZCase: family.zcase, ZOffset: family.offset, OpBytes: encoding}
+			want := []goasmrules.X86AVXRule{first}
+			if family.stem == "RORX" {
+				second := first
+				second.RowIndex, second.ZOffset = 1, 2
+				second.Classes = []string{"Yi8", "Yml", "Yrl"}
+				want = append(want, second)
+			}
+			var actual []goasmrules.X86AVXRule
+			for _, rule := range rules {
+				if rule.Opcode == name {
+					actual = append(actual, rule)
+				}
+			}
+			if !reflect.DeepEqual(actual, want) {
+				t.Fatal("complete official GP operand/encoding row differs", name, actual, want)
+			}
+			count += len(actual)
+		}
+	}
+	if len(x86NumericalVEXGPFamilies) != 13 || count != 28 {
+		t.Fatal("complete 26-member/28-row independent VEX GP denominator changed", count)
+	}
+}
+
+func x86NumericalVEXGPRow(stem, suffix, input string) string {
+	arguments := input + ",CX,DX"
+	switch stem {
+	case "BEXTR", "BZHI", "SARX", "SHLX", "SHRX":
+		arguments = "CX," + input + ",DX"
+	case "BLSI", "BLSMSK", "BLSR":
+		arguments = input + ",DX"
+	case "RORX":
+		arguments = "$255," + input + ",DX"
+	}
+	return stem + suffix + " " + arguments
+}
+
+func x86NumericalVEXGPRequireMC(t *testing.T, code []byte, mode, instructions int) {
+	t.Helper()
+	x86NumericalNativeRequireMC(t, code, mode, instructions, "+bmi,+bmi2")
+}
+
+func x86NumericalNativeRequireMC(t *testing.T, code []byte, mode, instructions int, features string) {
+	t.Helper()
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("independent complete native boundary prior requires LLVM22 llvm-mc")
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if mode == 32 {
+		triple = "i386-unknown-linux-gnu"
+	}
+	var input strings.Builder
+	for _, value := range code {
+		fmt.Fprintf(&input, "0x%02x ", value)
+	}
+	input.WriteByte('\n')
+	stage, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple, "--mattr="+features)
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	cancel()
+	text := strings.ToLower(string(output))
+	count := 0
+	for _, line := range strings.Split(text, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) != 0 && !strings.HasPrefix(fields[0], ".") {
+			count++
+		}
+	}
+	if err != nil || strings.Contains(text, "warning") || strings.Contains(text, "invalid") || count != instructions {
+		t.Fatalf("actual Go bytes lack their independent LLVM22 physical prior: count=%d want=%d: %v\n%s", count, instructions, err, output)
+	}
+}
+
+func TestX86NumericalVEXGPCompleteOriginalPhysicalBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, family := range x86NumericalVEXGPFamilies {
+			t.Run(arch+"/"+family.stem, func(t *testing.T) {
+				var rows []string
+				for _, suffix := range []string{"L", "Q"} {
+					for _, input := range []string{
+						"AX", "(AX)", "127(AX)", "-128(AX)", "-129(AX)", "128(AX)",
+						"-2147483648(BX)", "2147483647(BX)", "0x12345678",
+						"19(AX)(CX*1)", "19(AX)(CX*2)", "19(AX)(CX*4)", "19(AX)(CX*8)",
+						"8(AX)(FS)", "8(AX)(GS)",
+					} {
+						rows = append(rows, x86NumericalVEXGPRow(family.stem, suffix, input))
+					}
+					if arch == "amd64" {
+						rows = append(rows,
+							strings.NewReplacer("CX", "R14", "DX", "R15").Replace(x86NumericalVEXGPRow(family.stem, suffix, "R13")),
+							x86NumericalVEXGPRow(family.stem, suffix, "-129(R11)(R9*4)"))
+					}
+					if family.stem == "RORX" {
+						rows = append(rows, strings.Replace(x86NumericalVEXGPRow(family.stem, suffix, "AX"), "$255", "$-1", 1))
+					}
+				}
+				want := map[string]int{"386": 30, "amd64": 34}[arch]
+				if family.stem == "RORX" {
+					want += 2
+				}
+				if len(rows) != want {
+					t.Fatal("complete orthogonal physical GP axis inventory changed", len(rows), want)
+				}
+				code, pcs := x86NumericalBoundaryGoBytes(t, arch, strings.Join(rows, "\n")+"\nCMPL AX,$1\nRET")
+				if len(pcs) != len(rows)+2 {
+					t.Fatal("actual Go omitted or expanded a physical GP witness", len(rows), pcs)
+				}
+				mode := 64
+				if arch == "386" {
+					mode = 32
+				}
+				x86NumericalVEXGPRequireMC(t, code, mode, len(pcs))
+				// Includes mode32 W1: SDM BMI instruction descriptions ignore
+				// that bit outside long mode. This grants no named/raw entry.
+				x86CheckNumericalFloatingBoundaries(t, code, pcs, mode, len(rows))
+			})
+		}
+	}
+}
+
+func TestX86NumericalVEXGPRIPIsOnlyPhysicalBoundary(t *testing.T) {
+	for _, family := range x86NumericalVEXGPFamilies {
+		for _, suffix := range []string{"L", "Q"} {
+			for _, offset := range []int{-17, 17} {
+				t.Run(fmt.Sprintf("%s%s/%+d", family.stem, suffix, offset), func(t *testing.T) {
+					row := x86NumericalVEXGPRow(family.stem, suffix, fmt.Sprintf("table%+d(SB)", offset))
+					code, pcs, listing := x86NumericalBoundaryGoBytesAndListing(t, "amd64", row+"\nRET")
+					length, add := int64(9), offset
+					if family.stem == "RORX" {
+						length, add = 10, offset-1
+					}
+					if !reflect.DeepEqual(pcs, []int64{0, length}) || len(code) != int(length)+1 {
+						t.Fatalf("actual original RIP PC/relocation prior differs: %x %v\n%s", code, pcs, listing)
+					}
+					x86NumericalRequirePCRelListing(t, listing, 5, add)
+					x86NumericalVEXGPRequireMC(t, code, 64, 2)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(code, 64)
+					if err != nil || !reflect.DeepEqual(boundaries, []x86NumericalNativeBoundary{{PC: 0, Length: int(length)}, {PC: length, Length: 1}}) ||
+						len(scalar) != 1 || scalar[length].Op != x86asm.RET {
+						t.Fatal("RIP GP opcode must supply only its whole physical PC", boundaries, scalar, err)
+					}
+					reads, err := numericalNativeReads(code, 64)
+					if err != nil || len(reads) != 0 {
+						t.Fatal("physical GP boundary acquired an SDK scalar/numerical-read role", reads, err)
+					}
+					// The original object's unlinked zero displacement has no
+					// source DATA. It must not become a raw source instruction.
+					original := "TEXT ·Value(SB),4,$0-0\n" + x86RawDisplacementDirectives(code)
+					if _, err := normalizeX86RawFile(mustParseX86RawReturn(t, original), "amd64"); err == nil {
+						t.Fatal("boundary-only RIP permission leaked to the default raw source decoder")
+					}
+				})
+			}
+		}
+		t.Run(family.stem+"/owned-DATA-versus-missing-pointer", func(t *testing.T) {
+			source := "TEXT ·Value(SB),4,$0-0\n" + x86NumericalVEXGPRow(family.stem, "Q", "table(SB)") + "\nRET\n" +
+				"DATA table+0(SB)/8,$7\nGLOBL table(SB),8,$8\n"
+			// This complete DATA was already a legitimate source before the
+			// physical observer existed. BLS/RORX need no extra GP operand;
+			// ordinary nontrapping MULX may leave its dead result unknown.
+			// The other families still lack their explicit CX control/source.
+			ownedAccepted := strings.HasPrefix(family.stem, "BLS") || family.stem == "MULX" || family.stem == "RORX"
+			for _, control := range []struct {
+				name, source string
+				accepted     bool
+			}{
+				{"original-owned-DATA", source, ownedAccepted},
+				// Change only the instruction's address. The unrelated original
+				// DATA cannot supply BX: this exact func Value() has no pointer.
+				{"missing-BX-pointer", strings.Replace(source, "table(SB)", "(BX)", 1), false},
+			} {
+				t.Run(control.name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", control.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, control.source, "func Value()", "amd64", "x86_64-unknown-linux-gnu", api)
+						if control.accepted {
+							if err != nil || ir == "" {
+								t.Fatal("ordinary owned DATA lost its independent preexisting source role", api, err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("physical boundary or unrelated DATA invented a missing GP/pointer input", api, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86NumericalVEXGPBoundariesRetainAllGuards(t *testing.T) {
+	for _, family := range x86NumericalVEXGPFamilies {
+		code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", x86NumericalVEXGPRow(family.stem, "L", "AX")+"\nRET")
+		code = append([]byte(nil), code[:pcs[1]]...)
+		x86NumericalVEXGPRequireMC(t, code, 64, 1)
+		for _, control := range []string{"L1", "address-override", "legacy-prefix", "unknown-map", "mode32-high-vvvv"} {
+			t.Run(family.stem+"/"+control, func(t *testing.T) {
+				changed, mode := append([]byte(nil), code...), 64
+				switch control {
+				case "L1":
+					changed[2] |= 4
+				case "address-override":
+					changed = append([]byte{0x67}, changed...)
+				case "legacy-prefix":
+					changed = append([]byte{0x66}, changed...)
+				case "unknown-map":
+					changed[1] = changed[1]&0xe0 | 0x1f
+				case "mode32-high-vvvv":
+					mode, changed[2] = 32, changed[2]&^0x40
+					if !x86NumericalVectorPrefix(changed, mode) {
+						t.Fatal("mode32 guard accidentally constructed a legacy LES/LDS identity")
+					}
+				}
+				for _, prefix := range [][]byte{nil, {0x90, 0xc3}} {
+					whole := append(append([]byte(nil), prefix...), changed...)
+					boundaries, scalar, err := x86NumericalNativeBoundaries(whole, mode)
+					if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+						t.Fatal("malformed/default-address GP encoding retained a partial observation", whole, err)
+					}
+				}
+			})
+		}
+		t.Run(family.stem+"/every-cut", func(t *testing.T) {
+			for cut := 0; cut < len(code); cut++ {
+				boundaries, scalar, err := x86NumericalNativeBoundaries(append([]byte{0x90, 0xc3}, code[:cut]...), 64)
+				if cut == 0 {
+					continue // The independent NOP/RET prefix alone is complete.
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || boundaries != nil || scalar != nil {
+					t.Fatal("unreachable truncated GP encoding retained its valid prefix", cut, err)
+				}
+			}
+		})
+	}
+	// Physical mode32 C4/C5 memory ModRM prefixes remain LES/LDS, not
+	// malformed BMI. The existing complete legacy-prefix root owns them.
+	for _, code := range [][]byte{{0xc4, 0x00, 0xc3}, {0xc5, 0x00, 0xc3}} {
+		boundaries, scalar, err := x86NumericalNativeBoundaries(code, 32)
+		want := x86asm.LES
+		if code[0] == 0xc5 {
+			want = x86asm.LDS
+		}
+		if err != nil || len(boundaries) != 2 || len(scalar) != 2 || scalar[0].Op != want || scalar[2].Op != x86asm.RET {
+			t.Fatal("mode32 legacy prefix identity was reclassified as VEX GP", code, err)
+		}
+	}
+}
+
+func TestX86NumericalVEXGPPhysicalProjectionPreservesDefaultRawRole(t *testing.T) {
+	for _, row := range []struct {
+		stem    string
+		decode  x86RawInstructionDecoder
+		project func([]byte, int, x86RawMemoryDecoder) (Instr, int, bool, error)
+	}{
+		{"ANDN", decodedX86ANDNInstruction, decodedX86ANDNInstructionWithMemory},
+		{"BLSI", decodedX86BLSInstruction, decodedX86BLSInstructionWithMemory},
+		{"BZHI", decodedX86RawBZHIInstruction, decodedX86RawBZHIInstructionWithMemory},
+		{"MULX", decodedX86MULXInstruction, decodedX86MULXInstructionWithMemory},
+		{"PDEP", decodedX86ParallelBitsInstruction, decodedX86ParallelBitsInstructionWithMemory},
+		{"RORX", decodedX86RORXInstruction, decodedX86RORXInstructionWithMemory},
+		{"SHLX", decodedX86BMI2ShiftInstruction, decodedX86BMI2ShiftInstructionWithMemory},
+	} {
+		t.Run(row.stem, func(t *testing.T) {
+			code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", x86NumericalVEXGPRow(row.stem, "Q", "table+17(SB)")+"\nRET")
+			code = code[:pcs[1]]
+			x86NumericalVEXGPRequireMC(t, code, 64, 1)
+			_, _, known, err := row.decode(code, 64)
+			if !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatal("the original default raw entry gained physical RIP permission", known, err)
+			}
+			_, _, known, err = row.project(code, 64, x86RawMemoryDecoder{})
+			if !known || err == nil || !strings.Contains(err.Error(), "RIP-relative") {
+				t.Fatal("the zero-value memory strategy no longer preserves the raw-source contract", known, err)
+			}
+			instruction, size, known, err := row.project(code, 64, x86RawMemoryDecoder{physicalPC: true})
+			if !known || err != nil || size != len(code) {
+				t.Fatal("the separate physical observer lost an independently decoded instruction", instruction, size, known, err)
+			}
+		})
+	}
+	t.Run("MULX-mode32-WIG-is-not-raw-entry", func(t *testing.T) {
+		code, pcs := x86NumericalBoundaryGoBytes(t, "386", "MULXQ AX,CX,DX\nRET")
+		code = code[:pcs[1]]
+		x86NumericalVEXGPRequireMC(t, code, 32, 1)
+		if _, _, known, err := decodedX86MULXInstruction(code, 32); !known || err == nil {
+			t.Fatal("native-PC WIG observation broadened the old ordinary MULX raw entry", known, err)
+		}
+		instruction, size, known, err := decodedX86MULXInstructionWithMemory(code, 32, x86RawMemoryDecoder{physicalPC: true})
+		if !known || err != nil || size != len(code) || instruction.Op != "MULXL" {
+			t.Fatal("physical mode32 WIG projection acquired a qword operation or lost its real PC", instruction, size, known, err)
+		}
+	})
+}
diff --git a/x86_official_backend_observer_test.go b/x86_official_backend_observer_test.go
new file mode 100644
index 000000000..702a4df06
--- /dev/null
+++ b/x86_official_backend_observer_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// The overlay appends an owned test to an existing test file. Go 1.20's vet
+// reads physical filenames, while current Go resolves the overlay for vet.
+// No original declaration or physical SDK file changes. This observes Go's encoder;
+// it grants no translator, object-decoder or native-entry permission.
+func x86OriginalGoBackendOutput(t *testing.T, fixture, testRoot string) []byte {
+	t.Helper()
+	fixture, err := filepath.Abs(fixture)
+	if err != nil || !strings.HasSuffix(fixture, "_test.go") {
+		t.Fatal("invalid owned SDK backend fixture", fixture, err)
+	}
+	sdk := runtime.GOROOT()
+	directory := filepath.Join(sdk, "src", "cmd", "internal", "obj", "x86")
+	snapshot := func() map[string][32]byte {
+		entries, err := os.ReadDir(directory)
+		if err != nil {
+			t.Fatal(err)
+		}
+		result := map[string][32]byte{}
+		for _, entry := range entries {
+			if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".go") {
+				data, err := os.ReadFile(filepath.Join(directory, entry.Name()))
+				if err != nil {
+					t.Fatal(err)
+				}
+				result[entry.Name()] = sha256.Sum256(data)
+			}
+		}
+		return result
+	}
+	before := snapshot()
+	fixtureBytes, err := os.ReadFile(fixture)
+	if err != nil {
+		t.Fatal(err)
+	}
+	virtual := filepath.Join(directory, "asm_test.go")
+	original, err := os.ReadFile(virtual)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dir := t.TempDir()
+	fixture = filepath.Join(dir, "appended_test.go")
+	if err := os.WriteFile(fixture, x86BackendAppendOriginalTest(t, original, fixtureBytes), 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Log("SDK_VET_OVERLAY_BOUNDARY default vet remains enabled; legacy vet may read the physical original test, so fixture compilation/execution is observed independently")
+	overlay := filepath.Join(dir, "overlay.json")
+	data, err := json.Marshal(struct{ Replace map[string]string }{map[string]string{virtual: fixture}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(overlay, data, 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, 2*time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(sdk, "bin", "go"), "test", "-p=1",
+		"-overlay="+overlay, "cmd/internal/obj/x86", "-run", "^"+regexp.QuoteMeta(testRoot)+"$",
+		"-count=1", "-timeout=90s", "-json")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOROOT="+sdk, "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOFLAGS=", "GOOS="+runtime.GOOS, "GOARCH="+runtime.GOARCH, "CGO_ENABLED=0")
+	output, commandErr := runtimeOracleCombinedOutput(ctx, command)
+	after := snapshot()
+	if len(before) != len(after) {
+		t.Fatal("original SDK source inventory changed during the test-only overlay")
+	}
+	for name, digest := range before {
+		if after[name] != digest {
+			t.Fatal("original SDK source bytes changed during the test-only overlay", name)
+		}
+	}
+	if commandErr != nil || ctx.Err() != nil {
+		t.Fatalf("actual Go backend source observer failed: %v / %v\n%s", commandErr, ctx.Err(), output)
+	}
+	t.Logf("ACTUAL_GO_BACKEND_SOURCE originalSDKGoFiles=%d fixtureSHA=%x outputSHA=%x",
+		len(before), sha256.Sum256(fixtureBytes), sha256.Sum256(output))
+	return output
+}
+
+// Append only owned declarations and missing imports. Keep every original
+// declaration byte-identical, including tests not selected by the observer.
+func x86BackendAppendOriginalTest(t *testing.T, original, fixture []byte) []byte {
+	t.Helper()
+	set := token.NewFileSet()
+	parse := func(name string, source []byte) *ast.File {
+		file, err := parser.ParseFile(set, name, source, 0)
+		if err != nil || file.Name.Name != "x86" {
+			t.Fatal("backend overlay requires original package x86", err)
+		}
+		return file
+	}
+	base, added := parse("original_test.go", original), parse("fixture_test.go", fixture)
+	imports := map[string]string{}
+	for _, item := range base.Imports {
+		name := ""
+		if item.Name != nil {
+			name = item.Name.Name
+		}
+		imports[item.Path.Value] = name
+	}
+	var extra strings.Builder
+	for _, item := range added.Imports {
+		name := ""
+		if item.Name != nil {
+			name = item.Name.Name
+		}
+		if old, exists := imports[item.Path.Value]; exists {
+			if old != name {
+				t.Fatal("backend fixture changes an original import binding", item.Path.Value)
+			}
+			continue
+		}
+		if _, err := strconv.Unquote(item.Path.Value); err != nil {
+			t.Fatal(err)
+		}
+		extra.WriteString("import " + name + " " + item.Path.Value + "\n")
+	}
+	point := set.Position(base.Name.End()).Offset
+	result := append([]byte(nil), original[:point]...)
+	result = append(result, []byte("\n"+extra.String())...)
+	result = append(result, original[point:]...)
+	originalEnd := len(result)
+	for _, declaration := range added.Decls {
+		if group, ok := declaration.(*ast.GenDecl); ok && group.Tok == token.IMPORT {
+			continue
+		}
+		result = append(result, '\n')
+		result = append(result, fixture[set.Position(declaration.Pos()).Offset:set.Position(declaration.End()).Offset]...)
+		result = append(result, '\n')
+	}
+	combined := parse("combined_test.go", result)
+	var originals []ast.Decl
+	for _, declaration := range base.Decls {
+		if group, ok := declaration.(*ast.GenDecl); !ok || group.Tok != token.IMPORT {
+			originals = append(originals, declaration)
+		}
+	}
+	index := 0
+	for _, declaration := range combined.Decls {
+		if group, ok := declaration.(*ast.GenDecl); ok && group.Tok == token.IMPORT {
+			continue
+		}
+		if set.Position(declaration.End()).Offset > originalEnd {
+			break
+		}
+		old := originals[index]
+		if !bytes.Equal(original[set.Position(old.Pos()).Offset:set.Position(old.End()).Offset], result[set.Position(declaration.Pos()).Offset:set.Position(declaration.End()).Offset]) {
+			t.Fatal("backend overlay changed an original declaration")
+		}
+		index++
+	}
+	if index != len(originals) {
+		t.Fatal("backend overlay dropped original declarations", index, len(originals))
+	}
+	t.Logf("APPENDED_TEST_ORIGINAL_DECLARATIONS count=%d sourceSHA=%x overlaySHA=%x", index, sha256.Sum256(original), sha256.Sum256(result))
+	return result
+}
diff --git a/x86_official_binary_witness_test.go b/x86_official_binary_witness_test.go
new file mode 100644
index 000000000..0a5839779
--- /dev/null
+++ b/x86_official_binary_witness_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Official syntax witnesses have no entry inputs. Probe classification may
+// therefore require context; actual lowering remains mandatory independently
+// of that classification. This does not certify a public or runtime entry.
+func x86OfficialBinaryWitnessLowerer(t *testing.T, file *File, arch string) {
+	t.Helper()
+	if err := ProbeInstruction(ArchAMD64, arch, file.Funcs[0].Instrs[1]); err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("actual Go-accepted table witness failed instruction classification: %v", err)
+	}
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	x86ScalarFormatObjectUnit(t, file, map[string]FuncSig{"f": {Name: "f", Ret: Void}}, arch, triple, 0)
+}
+
+func x86OfficialPackedBinaryWitnesses(t *testing.T) map[string][]string {
+	t.Helper()
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	byOpcode := map[string]map[string]bool{}
+	for _, rule := range rules {
+		if rule.Ytab != "_yvandnpd" {
+			continue
+		}
+		witnesses, err := goasmrules.X86PackedBinarySyntaxWitnesses(rule)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if byOpcode[rule.Opcode] == nil {
+			byOpcode[rule.Opcode] = map[string]bool{}
+		}
+		for _, witness := range witnesses {
+			byOpcode[rule.Opcode][witness] = true
+		}
+	}
+	result := map[string][]string{}
+	for opcode, witnesses := range byOpcode {
+		for witness := range witnesses {
+			result[opcode] = append(result[opcode], witness)
+		}
+		sort.Strings(result[opcode])
+	}
+	return result
+}
+
+func TestX86OfficialPackedBinarySourceWitnessesCompileWithGo(t *testing.T) {
+	byOpcode := x86OfficialPackedBinaryWitnesses(t)
+	if len(byOpcode) < 60 {
+		t.Fatal("official packed-binary table inventory is incomplete")
+	}
+	opcodes := make([]string, 0, len(byOpcode))
+	for opcode := range byOpcode {
+		opcodes = append(opcodes, opcode)
+	}
+	sort.Strings(opcodes)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			accepted, maskedFrontendRows := 0, 0
+			for _, opcode := range opcodes {
+				for _, witness := range byOpcode[opcode] {
+					if arch == "386" && strings.Count(witness, ",") == 3 {
+						// This is a separate frontend limitation, not a missing
+						// encoder row or a successful translated object. Its real
+						// Go rejection is checked below for each family opcode.
+						maskedFrontendRows++
+						continue
+					}
+					fmt.Fprintf(&source, "TEXT probe%d(SB),4,$0-0\n%s\nRET\n", accepted, witness)
+					accepted++
+				}
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			t.Logf("actual Go assembled %d complete-table syntax witnesses/%d opcodes; %d masked mode32 candidates have separate frontend refusals; not LLVM/runtime coverage", accepted, len(opcodes), maskedFrontendRows)
+		})
+	}
+	for _, opcode := range opcodes {
+		t.Run("386_masked_frontend/"+opcode, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+opcode+" Z0,Z1,K1,Z2\nRET\n", "", false)
+		})
+	}
+}
+
+func TestX86OfficialWordMultiplyWitnessesReachActualLowerer(t *testing.T) {
+	byOpcode := x86OfficialPackedBinaryWitnesses(t)
+	// These names select a coherent semantic family. All operand formats below
+	// come from the independent Go table, not the lowerer's own spec or a
+	// discovering external library.
+	for _, arch := range []string{"amd64", "386"} {
+		for _, opcode := range []string{"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW"} {
+			witnesses := byOpcode[opcode]
+			if len(witnesses) == 0 {
+				t.Fatalf("actual Go encoder family lacks %s", opcode)
+			}
+			for _, witness := range witnesses {
+				if arch == "386" && strings.Count(witness, ",") == 3 {
+					continue // Independently tested actual frontend refusal above.
+				}
+				t.Run(arch+"/"+witness, func(t *testing.T) {
+					source := "TEXT f(SB),4,$0-0\n" + witness + "\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86OfficialBinaryWitnessLowerer(t, file, arch)
+				})
+			}
+		}
+	}
+}
+
+func TestX86OfficialPackedBinaryWitnessesReachActualLowerer(t *testing.T) {
+	byOpcode := x86OfficialPackedBinaryWitnesses(t)
+	opcodes := make([]string, 0, len(byOpcode))
+	for opcode := range byOpcode {
+		opcodes = append(opcodes, opcode)
+	}
+	sort.Strings(opcodes)
+	if len(opcodes) < 60 {
+		t.Fatal("complete shared grammar has no independent opcode inventory")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		// Bind the entire syntax matrix to an actual original Go object before
+		// asking our lowerers. This avoids deriving the test denominator from
+		// production specs or launching one assembler for every candidate.
+		var source strings.Builder
+		accepted := 0
+		for _, opcode := range opcodes {
+			for _, witness := range byOpcode[opcode] {
+				if arch == "386" && strings.Count(witness, ",") == 3 {
+					continue // Separate required actual frontend refusal test.
+				}
+				fmt.Fprintf(&source, "TEXT probe%d(SB),4,$0-0\n%s\nRET\n", accepted, witness)
+				accepted++
+			}
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		for _, opcode := range opcodes {
+			for _, witness := range byOpcode[opcode] {
+				if arch == "386" && strings.Count(witness, ",") == 3 {
+					continue
+				}
+				t.Run(arch+"/"+witness, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+witness+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86OfficialBinaryWitnessLowerer(t, file, arch)
+				})
+			}
+		}
+		t.Logf("checked %d actual Go-accepted grammar witnesses/%d opcodes on %s; syntax lowering only, not LLVM objects or runtime", accepted, len(opcodes), arch)
+	}
+}
diff --git a/x86_official_bit_count_conflict_rows_test.go b/x86_official_bit_count_conflict_rows_test.go
new file mode 100644
index 000000000..420e6b5e8
--- /dev/null
+++ b/x86_official_bit_count_conflict_rows_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialBitCountConflictRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86PackedBitCountConflictRows, 48, 198, 0, x86OfficialAbsAssembly)
+}
+
+func TestX86OfficialBitCountConflictOldDestinationIsOnlyMergeInput(t *testing.T) {
+	for _, opcode := range []string{"VPOPCNTD", "VPCONFLICTQ"} {
+		for _, zeroing := range []bool{false, true} {
+			op := opcode
+			if zeroing {
+				op += ".Z"
+			}
+			instruction := op + " X16,K1,X18"
+			ins := x86ScalarLaneInstruction(t, instruction)
+			form, numericalOld, known, err := x86FixedVectorValueProperties(ins, "amd64")
+			if !known || err != nil || numericalOld || form.second != -1 || form.destination != 2 ||
+				form.mask != 1 || form.zeroing != zeroing {
+				t.Fatal("unary source acquired a numerical old-destination input", instruction, numericalOld, known, err)
+			}
+			fixtures := []x86OfficialPackedCase{{witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: instruction, Generation: "evex", Width: 128,
+				First: "X16", Destination: "X18", Masked: true, Zeroing: zeroing,
+			}}}
+			source, declaration := x86OfficialAbsAssembly(fixtures)
+			missing := strings.Replace(source, "VMOVDQU64 (CX),Z18\n", "", 1)
+			if source == missing {
+				t.Fatal("old-destination mutation did not remove its actual initialization")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(instruction+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("existing initialized unary transport rejected", err)
+					}
+					ir, err = x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if zeroing {
+						if err != nil || ir == "" {
+							t.Fatal("zeroing unary operation borrowed an unnecessary old destination", err)
+						}
+					} else {
+						x86VectorScratchCodegenControl(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_official_compact_expand_rows_test.go b/x86_official_compact_expand_rows_test.go
new file mode 100644
index 000000000..dbe8f0b81
--- /dev/null
+++ b/x86_official_compact_expand_rows_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialCompactExpandRowsThreeAPIsObjectsAndTerminalFaults(t *testing.T) {
+	cases := x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86CompactExpandRows, 72, 216, 0,
+		x86OfficialMoveAssembly, x86OfficialMoveInspectFaults)
+	terminal := 0
+	for _, fixture := range cases {
+		if fixture.witness.Zeroing && fixture.witness.Destination == "(AX)" {
+			terminal++
+		}
+	}
+	if terminal != 18 || len(cases)-terminal != 198 {
+		t.Fatal("ordinary compact continuations and terminal memory zeroing were conflated", len(cases), terminal)
+	}
+}
+
+// These independent nonzero addresses observe Go's actual compressed disp8.
+// They supplement the canonical 216 witnesses without adding source authority.
+func TestX86OfficialCompactExpandElementDisplacementActualGoBytes(t *testing.T) {
+	var source strings.Builder
+	var cases []x86OfficialPackedCase
+	for _, direction := range []string{"COMPRESS", "EXPAND"} {
+		for index, member := range []string{"B", "W", "D", "Q"} {
+			name := fmt.Sprintf("CompactDisp%d", len(cases))
+			op := "VP" + direction + member
+			instruction := op + " X16,K1,16(AX)"
+			p1, opcode, modrm := byte(0x7d), byte(0x63), byte(0x40)
+			if index&1 != 0 {
+				p1 |= 0x80
+			}
+			if index >= 2 {
+				opcode = 0x8b
+			}
+			if direction == "EXPAND" {
+				instruction, opcode, modrm = op+" 16(AX),K1,X18", 0x62, 0x50
+				if index >= 2 {
+					opcode = 0x89
+				}
+			}
+			line := strings.Count(source.String(), "\n") + 2
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+			cases = append(cases, x86OfficialPackedCase{
+				row: "independent/element-disp8/" + op, symbol: name, line: line,
+				witness: goasmrules.X86PackedBinaryWitness{
+					Instruction: instruction,
+					Encoding:    []byte{0x62, 0xe2, p1, 0x09, opcode, modrm, byte(16 >> index)},
+				},
+			})
+		}
+	}
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source.String())
+	if err != nil {
+		t.Fatal("actual Go element-disp8 anchor failed", err)
+	}
+	if len(cases) != 8 {
+		t.Fatal("both directions need all four actual element scales", len(cases))
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("compressed displacement used vector width or mask population instead of the element scale", err)
+	}
+}
diff --git a/x86_official_conversion76_objects_test.go b/x86_official_conversion76_objects_test.go
new file mode 100644
index 000000000..7033cb622
--- /dev/null
+++ b/x86_official_conversion76_objects_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The signed scalar memory spellings are selected by the earlier VEX row.
+// Their EVEX rows remain selectable through high-register/rounding inputs.
+func x86ConversionEarlierMemoryRow(row goasmrules.X86PackedBinaryRow, w goasmrules.X86PackedBinaryWitness) bool {
+	return strings.Contains(row.ID, "/_yvcvtsd2si/1") && w.Memory
+}
+
+func x86ConversionRowsForObjects(terminal bool) func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+	return func(legacy goasmrules.X86LegacyCatalog, avx []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+		rows, err := goasmrules.X86PrecisionHalfScalarConversionRows(legacy, avx)
+		if err != nil {
+			return nil, err
+		}
+		var selected []goasmrules.X86PackedBinaryRow
+		for _, row := range rows {
+			original := row.Witnesses
+			row.Witnesses = nil
+			for _, w := range original {
+				fault := row.Opcode == "VCVTPS2PH" && w.Zeroing && w.Destination == "(AX)"
+				if fault == terminal && !x86ConversionEarlierMemoryRow(row, w) {
+					row.Witnesses = append(row.Witnesses, w)
+				}
+			}
+			if len(row.Witnesses) != 0 {
+				selected = append(selected, row)
+			}
+		}
+		return selected, nil
+	}
+}
+
+func TestX86OfficialPrecisionHalfScalarConversionRowsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	// This existing direction/kind producer initializes only actual vector,
+	// GP, upper-copy and masked-merge inputs, and stores the real result.
+	x86OfficialPackedRowsObjectsInspect(t, x86ConversionRowsForObjects(false), 76, 287, 0,
+		x86OfficialInsertExtractAssembly, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86OfficialPrecisionHalfConversionTerminalRowsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	assembly := func(cases []x86OfficialPackedCase) (string, string) {
+		var source, declarations strings.Builder
+		for index := range cases {
+			fixture := &cases[index]
+			fixture.symbol = fmt.Sprint("ConversionFault", index)
+			fmt.Fprintf(&declarations, "func %s()\n", fixture.symbol)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", fixture.symbol)
+			fixture.line = strings.Count(source.String(), "\n") + 1
+			fmt.Fprintln(&source, fixture.witness.Instruction)
+			source.WriteString("RET\n")
+		}
+		return source.String(), declarations.String()
+	}
+	x86OfficialPackedRowsObjectsInspect(t, x86ConversionRowsForObjects(true), 3, 3, 0, assembly,
+		func(t *testing.T, ir string, cases []x86OfficialPackedCase) {
+			for _, fixture := range cases {
+				if _, err := x86OfficialMoveFaultBody(ir, fixture.symbol); err != nil {
+					t.Fatal("half terminal read unavailable inputs or retained a continuation", err)
+				}
+			}
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86OfficialScalarConversionEarlierMemorySelection(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86PrecisionHalfScalarConversionRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var earlier []x86OfficialPackedCase
+	for _, row := range rows {
+		for _, w := range row.Witnesses {
+			if !x86ConversionEarlierMemoryRow(row, w) {
+				continue
+			}
+			var selected *goasmrules.X86PackedBinaryWitness
+			for _, candidate := range rows {
+				if candidate.Opcode != row.Opcode || !strings.Contains(candidate.ID, "/_yvcvtsd2si/0") {
+					continue
+				}
+				for _, physical := range candidate.Witnesses {
+					if physical.Instruction == w.Instruction {
+						copy := physical
+						selected = &copy
+					}
+				}
+			}
+			if selected == nil || selected.Generation != "vex" || string(selected.Encoding) == string(w.Encoding) {
+				t.Fatal("late EVEX memory alternative lost its independent earlier row", row.ID, w)
+			}
+			earlier = append(earlier, x86OfficialPackedCase{row: row.ID, witness: *selected})
+		}
+	}
+	if len(earlier) != 8 {
+		t.Fatal("signed scalar partial-shadow observations changed", len(earlier))
+	}
+	source, _ := x86OfficialInsertExtractAssembly(earlier)
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, earlier); err != nil {
+		t.Fatal("stock Go selected a different row than the independent earlier payload", err)
+	}
+}
diff --git a/x86_official_conversion76_rows_test.go b/x86_official_conversion76_rows_test.go
new file mode 100644
index 000000000..9ddb1d871
--- /dev/null
+++ b/x86_official_conversion76_rows_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RemainingConversionPreflightSource(t *testing.T) (string, string) {
+	t.Helper()
+	instructions := strings.Split(strings.TrimSpace(`
+VCVTPD2PS Z16,Y18
+VCVTPD2PSX X16,X18
+VCVTPD2PSY Y16,X18
+VCVTPS2PD Y16,Z18
+VCVTPH2PS Y16,Z18
+VCVTPS2PH $7,Z16,Y18
+VCVTSD2SS X16,X17,X18
+VCVTSS2SD X16,X17,X18
+VCVTSD2SI X16,CX
+VCVTSD2SIQ X16,CX
+VCVTSS2SI X16,CX
+VCVTSS2SIQ X16,CX
+VCVTTSD2SI X16,CX
+VCVTTSD2SIQ X16,CX
+VCVTTSS2SI X16,CX
+VCVTTSS2SIQ X16,CX
+VCVTSD2USIL X16,CX
+VCVTSD2USIQ X16,CX
+VCVTSS2USIL X16,CX
+VCVTSS2USIQ X16,CX
+VCVTTSD2USIL X16,CX
+VCVTTSD2USIQ X16,CX
+VCVTTSS2USIL X16,CX
+VCVTTSS2USIQ X16,CX
+VCVTSI2SDL CX,X17,X18
+VCVTSI2SDQ CX,X17,X18
+VCVTSI2SSL CX,X17,X18
+VCVTSI2SSQ CX,X17,X18
+VCVTUSI2SDL CX,X17,X18
+VCVTUSI2SDQ CX,X17,X18
+VCVTUSI2SSL CX,X17,X18
+VCVTUSI2SSQ CX,X17,X18
+`), "\n")
+	if len(instructions) != 32 {
+		t.Fatal("complete initialized conversion namespace changed", len(instructions))
+	}
+	var source, declarations strings.Builder
+	for index, instruction := range instructions {
+		name := fmt.Sprint("ConversionProbe", index)
+		fields := strings.Fields(instruction)
+		if len(fields) != 2 {
+			t.Fatal("preflight source is not one complete ordinary instruction", instruction)
+		}
+		operands := strings.Split(fields[1], ",")
+		first := operands[0]
+		if strings.HasPrefix(first, "$") {
+			first = operands[1]
+		}
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b *[64]byte,value uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\n", name)
+		if first == "CX" {
+			source.WriteString("MOVQ value+24(FP),CX\n")
+		} else {
+			source.WriteString("MOVQ a+8(FP),AX\nVMOVUPS (AX),Z16\n")
+		}
+		if len(operands) == 3 && operands[1] == "X17" {
+			source.WriteString("MOVQ b+16(FP),BX\nVMOVUPS (BX),Z17\n")
+		}
+		// Only real source and upper-copy inputs are seeded. An unmasked
+		// conversion must not require an invented old GP/vector destination.
+		source.WriteString("STC\n" + instruction + "\n")
+		if operands[len(operands)-1] == "CX" {
+			source.WriteString("MOVQ CX,0(DI)\n")
+		} else {
+			source.WriteString("VMOVUPS Z18,0(DI)\n")
+		}
+		source.WriteString("SETCS 64(DI)\nSTMXCSR 68(DI)\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86RemainingFPConversionInitializedProducerThreeAPIObjects(t *testing.T) {
+	source, declarations := x86RemainingConversionPreflightSource(t)
+	const triple = "x86_64-unknown-linux-gnu"
+	x86LEAActualTargetGoObject(t, "amd64", triple, source)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("initialized input-kind/result-kind producer did not reach its public API", api, err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, ir, level)
+			}
+		})
+	}
+}
+
+func TestX86RemainingFPConversionHalfTerminalKeepsPrefixMemoryObligations(t *testing.T) {
+	for _, result := range []bool{false, true} {
+		frame, returns := 0, ""
+		if result {
+			frame, returns = 8, " uint64"
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			instruction := fmt.Sprintf("VCVTPS2PH.Z $7,%s16,K1,(AX)", bank)
+			base := fmt.Sprintf("TEXT ·HalfTerminal(SB),4,$0-%d\n%s\nRET\n", frame, instruction)
+			declaration := "func HalfTerminal()" + returns + "\n"
+			goAssemblerOracleOutput(t, "amd64", base, "", true)
+			prefixes := []string{"MOVQ (AX),CX\n", "MOVQ $1,CX\nMOVQ CX,(AX)\n"}
+			for _, prefix := range prefixes {
+				candidate := strings.Replace(base, instruction, prefix+instruction, 1)
+				goAssemblerOracleOutput(t, "amd64", candidate, "", true)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("result=%t/%s/%s", result, bank, api), func(t *testing.T) {
+					const triple = "x86_64-unknown-linux-gnu"
+					ir, err := x86ScalarFPBitViewAPI(t, base, declaration, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("valid terminal source must pass before its permission controls", err)
+					}
+					if _, err := x86OfficialMoveFaultBody(ir, "HalfTerminal"); err != nil {
+						t.Fatal("terminal half store read an input or continued", err)
+					}
+					for index, prefix := range prefixes {
+						t.Run([]string{"read", "known-data-store"}[index], func(t *testing.T) {
+							candidate := strings.Replace(base, instruction, prefix+instruction, 1)
+							text, err := x86ScalarFPBitViewAPI(t, candidate, declaration, "amd64", triple, api)
+							if text != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("terminal half opcode authorized an earlier unknown address", api, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_official_evex_binary_remainder_rows_test.go b/x86_official_evex_binary_remainder_rows_test.go
new file mode 100644
index 000000000..1a9f8b2fa
--- /dev/null
+++ b/x86_official_evex_binary_remainder_rows_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86OfficialEVEXBinaryAlwaysOld(opcode string) bool {
+	switch opcode {
+	case "VPERMB", "VPERMW", "VPMULTISHIFTQB", "VPROLVD", "VPROLVQ", "VPRORVD", "VPRORVQ":
+		return false
+	}
+	return true // The independent official scope binds exactly 31 members.
+}
+
+func TestX86OfficialEVEXBinaryRemainderInitializedThreeAPIsObjects(t *testing.T) {
+	for _, role := range []struct {
+		name          string
+		alwaysOld     bool
+		rows, formats int
+		assembly      func([]x86OfficialPackedCase) (string, string)
+	}{
+		{"two-source", false, 42, 171, x86OfficialPackedAssembly},
+		{"always-old-destination", true, 144, 594, x86OfficialFMA3Assembly},
+	} {
+		t.Run(role.name, func(t *testing.T) {
+			build := func(legacy goasmrules.X86LegacyCatalog, avx []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+				rows, err := goasmrules.X86PackedEVEXBinaryRemainderRows(legacy, avx)
+				var selected []goasmrules.X86PackedBinaryRow
+				for _, row := range rows {
+					if x86OfficialEVEXBinaryAlwaysOld(row.Opcode) == role.alwaysOld {
+						selected = append(selected, row)
+					}
+				}
+				return selected, err
+			}
+			// Reuse the existing initialized transports and complete original
+			// Go-byte/three-API/object driver. Native semantics stay separate.
+			x86OfficialPackedRowsObjectsUsing(t, build, role.rows, role.formats, 0, role.assembly)
+		})
+	}
+}
+
+func TestX86OfficialEVEXBinaryInitializerMatchesExistingTypedRoles(t *testing.T) {
+	const members = `VPDPBUSD VPDPBUSDS VPDPWSSD VPDPWSSDS VPMADD52HUQ VPMADD52LUQ
+		VPERMB VPERMW VPERMI2B VPERMI2W VPERMI2D VPERMI2Q VPERMI2PS VPERMI2PD
+		VPERMT2B VPERMT2W VPERMT2D VPERMT2Q VPERMT2PS VPERMT2PD VPMULTISHIFTQB
+		VPROLVD VPROLVQ VPRORVD VPRORVQ VPSHLDVW VPSHLDVD VPSHLDVQ VPSHRDVW VPSHRDVD VPSHRDVQ`
+	ordinary, numericalOld := 0, 0
+	for _, opcode := range strings.Fields(members) {
+		alwaysOld := x86OfficialEVEXBinaryAlwaysOld(opcode)
+		if alwaysOld {
+			numericalOld++
+		} else {
+			ordinary++
+		}
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			op, mask := opcode, ""
+			if mode != "plain" {
+				mask = "K1,"
+			}
+			if mode == "zero" {
+				op += ".Z"
+			}
+			instruction := op + " X16,X17," + mask + "X18"
+			ins := x86ScalarLaneInstruction(t, instruction)
+			needsOld := alwaysOld || mode == "merge"
+			if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64"); known {
+				if err != nil {
+					t.Fatal(instruction, err)
+				}
+				writes := 0
+				for _, operand := range effect.operands {
+					if operand.write {
+						writes++
+						if operand.index != len(ins.Args)-1 || operand.read != needsOld || operand.width != 16 {
+							t.Fatal("initializer role differs from existing typed effect", instruction, operand)
+						}
+					}
+				}
+				if writes != 1 {
+					t.Fatal("typed effect lost the actual destination", instruction, writes)
+				}
+			} else if form, old, known, err := x86FixedVectorValueProperties(ins, "amd64"); !known || err != nil ||
+				old != alwaysOld || form.destination != len(ins.Args)-1 || form.byteWidth != 16 {
+				t.Fatal("initializer role differs from existing indexed-permute form", instruction, old, known, err)
+			}
+			fixture := []x86OfficialPackedCase{{witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: instruction, Generation: "evex", Width: 128,
+				First: "X16", Second: "X17", Destination: "X18", Masked: mode != "plain", Zeroing: mode == "zero",
+			}}}
+			assembly, oldLoad := x86OfficialPackedAssembly, "VMOVUPS (BX),X18\n"
+			if alwaysOld {
+				assembly, oldLoad = x86OfficialFMA3Assembly, "VMOVUPS (AX),X18\n"
+			}
+			source, _ := assembly(fixture)
+			if strings.Contains(source, oldLoad) != needsOld || !strings.Contains(source, instruction+"\n") {
+				t.Fatal("initializer fabricated or omitted a numerical old-destination input", instruction, source)
+			}
+		}
+	}
+	if ordinary != 7 || numericalOld != 24 {
+		t.Fatal("independent input-role partition changed", ordinary, numericalOld)
+	}
+}
+
+func TestX86OfficialEVEXBinaryZeroingCannotSupplyNumericalOldDestination(t *testing.T) {
+	// One original named witness per semantic role: integer dot, IFMA, I2
+	// indices, T2 table and both variable funnel directions. Existing families
+	// continue to own their complete input-byte and native-semantic matrices.
+	for _, opcode := range []string{"VPDPBUSD", "VPMADD52LUQ", "VPERMI2D", "VPERMT2D", "VPSHLDVD", "VPSHRDVQ"} {
+		t.Run(opcode, func(t *testing.T) {
+			instruction := opcode + ".Z X16,X17,K1,X18"
+			source, declaration := x86FMA3InitializedAxisSource("amd64", "OldEVEX", instruction)
+			missing := strings.Replace(source, "VMOVUPS (AX),X18\n", "", 1)
+			if source == missing {
+				t.Fatal("negative did not remove the actual old-destination initialization")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized numerical old-destination control rejected", err)
+					}
+					ir, err = x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					x86VectorScratchCodegenControl(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_official_exchange_rows_test.go b/x86_official_exchange_rows_test.go
new file mode 100644
index 000000000..ca643e224
--- /dev/null
+++ b/x86_official_exchange_rows_test.go
@@ -0,0 +1,495 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Original literal bytes and selected row indices are independent of the
+// source formatter. AX/AX is a genuine opcode-90 NOP, including its L spelling.
+func x86ExchangeOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	type sample struct {
+		row             int
+		operands, bytes string
+	}
+	fixtures := map[string][]sample{
+		"XCHGB": {{0, "CL,BL", "86cb"}, {0, "CL,0(SI)", "860e"}, {1, "0(SI),BL", "861e"}},
+		"XADDB": {{0, "CL,BL", "0fc0cb"}, {0, "CL,0(SI)", "0fc00e"}},
+	}
+	for _, width := range []struct{ suffix, prefix string }{{"W", "66"}, {"L", ""}, {"Q", "48"}} {
+		p := width.prefix
+		fixtures["XCHG"+width.suffix] = []sample{
+			{0, "AX,BX", p + "93"}, {0, "AX,AX", p + "90"}, {1, "BX,AX", p + "93"},
+			{2, "CX,BX", p + "87cb"}, {2, "CX,0(SI)", p + "870e"}, {3, "0(SI),BX", p + "871e"},
+		}
+		fixtures["XADD"+width.suffix] = []sample{{0, "CX,BX", p + "0fc1cb"}, {0, "CX,0(SI)", p + "0fc10e"}}
+	}
+	var cases []x86OfficialPackedCase
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		samples, found := fixtures[entry.Opcode]
+		if !found {
+			continue
+		}
+		if seen[entry.Opcode] {
+			t.Fatal("duplicate exchange source table", entry.Opcode)
+		}
+		seen[entry.Opcode] = true
+		for _, fixture := range samples {
+			code, err := hex.DecodeString(fixture.bytes)
+			if err != nil || fixture.row >= len(entry.Rows) {
+				t.Fatal("independent exchange fixture changed", err)
+			}
+			cases = append(cases, x86OfficialPackedCase{
+				row: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, fixture.row),
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " " + fixture.operands,
+					Destination: strings.Split(fixture.operands, ",")[1], Encoding: code},
+			})
+		}
+	}
+	if len(seen) != 8 || len(cases) != 29 {
+		t.Fatal("independent full exchange byte inventory changed", len(seen), len(cases))
+	}
+	return cases
+}
+
+func TestX86ExchangeOriginalCompleteRowsAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := x86ExchangeOriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			var cases []x86OfficialPackedCase
+			for _, original := range all {
+				if arch == "386" && strings.HasSuffix(strings.Fields(original.witness.Instruction)[0], "Q") {
+					continue
+				}
+				fixture := original
+				fixture.symbol = fmt.Sprint("ExchangeOriginal", len(cases))
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", fixture.symbol)
+				fixture.line = strings.Count(source.String(), "\n") + 1
+				fmt.Fprintln(&source, fixture.witness.Instruction)
+				source.WriteString("RET\n")
+				cases = append(cases, fixture)
+			}
+			want := 29
+			if arch == "386" {
+				want = 21
+			}
+			if len(cases) != want || want > 32 {
+				t.Fatal("complete exchange mode/byte union changed", len(cases), want)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+				t.Fatal("independent original exchange byte/row ownership", err)
+			}
+		})
+	}
+	for _, fixture := range all {
+		if !strings.HasSuffix(strings.Fields(fixture.witness.Instruction)[0], "Q") {
+			continue
+		}
+		t.Run("386-refusal/"+fixture.witness.Instruction, func(t *testing.T) {
+			x86ScalarLiteralExpectedGoListing(t, "386", "TEXT ·NoQ(SB),4,$0-0\n"+fixture.witness.Instruction+"\nRET\n", false)
+		})
+	}
+}
+
+func TestX86OfficialExchangeSourceJoinAndInitializedObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := x86ExchangeOriginalCases(t, catalog)
+	modes := make(map[string][]goasmrules.X86ScalarRMWRow)
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86ExchangeRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		expected := map[string]x86OfficialPackedCase{}
+		for _, fixture := range all {
+			if arch == "386" && strings.HasSuffix(strings.Fields(fixture.witness.Instruction)[0], "Q") {
+				continue
+			}
+			key := fixture.row + "/" + fixture.witness.Instruction
+			if _, found := expected[key]; found {
+				t.Fatal("duplicate independent row/instruction owner", key)
+			}
+			expected[key] = fixture
+		}
+		filtered := 0
+		for _, row := range rows {
+			if row.ModeFiltered != "" {
+				if arch != "386" || !strings.HasSuffix(row.Opcode, "Q") || len(row.Witnesses) != 0 {
+					t.Fatal("source row lost its original mode restriction", row)
+				}
+				filtered++
+				continue
+			}
+			if len(row.Witnesses) == 0 {
+				t.Fatal("unfiltered original exchange row lost its witness", row.ID)
+			}
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				fixture, found := expected[key]
+				if !found || !bytes.Equal(witness.Encoding, fixture.witness.Encoding) || witness.Destination != fixture.witness.Destination {
+					t.Fatal("production exchange view differs from independent original bytes/direction", key, witness, fixture)
+				}
+				delete(expected, key)
+			}
+		}
+		wantFiltered := 0
+		if arch == "386" {
+			wantFiltered = 5
+		}
+		if len(rows) != 18 || len(expected) != 0 || filtered != wantFiltered {
+			t.Fatal("complete exchange source/mode join changed", arch, len(rows), len(expected), filtered)
+		}
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_EXCHANGE_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			word, move := goWordSize(target.arch), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			count := 0
+			for _, fixture := range all {
+				if target.arch == "386" && strings.HasSuffix(strings.Fields(fixture.witness.Instruction)[0], "Q") {
+					continue
+				}
+				name := fmt.Sprint("ExchangeSource", count)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s memory+0(FP),SI\n%s old+%d(FP),BX\n%s input+%d(FP),CX\n%s accumulator+%d(FP),AX\n%s\nXOR%s AX,BX\nXOR%s CX,BX\n%s BX,ret+%d(FP)\nRET\n",
+					name, 5*word, move, move, word, move, 2*word, move, 3*word, fixture.witness.Instruction, move[3:], move[3:], move, 4*word)
+				fmt.Fprintf(&declarations, "func %s(memory *[16]byte,old,input,accumulator uintptr) uintptr\n", name)
+				count++
+			}
+			want := 29
+			if target.arch == "386" {
+				want = 21
+			}
+			if count != want || count > 32 {
+				t.Fatal("initialized exchange whole-source inventory changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized original exchange source rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86ExchangeObjectDisassembly(t *testing.T, llc, objdump, triple, ir, level string) string {
+	t.Helper()
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "exchange.ll"), filepath.Join(dir, "exchange.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", object))
+	bytes, err := os.ReadFile(object)
+	if err != nil || len(bytes) == 0 {
+		t.Fatal("exchange target object missing", err)
+	}
+	listing := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "-d", object))
+	t.Logf("EXCHANGE_TARGET_OBJECT triple=%s level=%s bytes=%d\n%s", triple, level, len(bytes), listing)
+	return string(listing)
+}
+
+func x86ExchangeObjectPrefixError(disassembly, widths string) error {
+	header := regexp.MustCompile(`^[0-9a-f]+ <([^>]+)>:$`)
+	want := map[string]bool{}
+	for _, width := range widths {
+		for _, locked := range []bool{false, true} {
+			want[fmt.Sprintf("Prefix%c_%t", width, locked)] = locked
+		}
+	}
+	seen := map[string]int{}
+	var failures []error
+	owner := ""
+	previousEnd, previousLock := uint64(0), false
+	for _, line := range strings.Split(disassembly, "\n") {
+		if match := header.FindStringSubmatch(strings.TrimSpace(line)); match != nil {
+			owner = strings.TrimPrefix(match[1], "_")
+			previousEnd, previousLock = 0, false
+			continue
+		}
+		address, rest, found := strings.Cut(strings.TrimSpace(line), ":")
+		pc, err := strconv.ParseUint(address, 16, 64)
+		if !found || err != nil {
+			continue
+		}
+		fields := strings.Fields(rest)
+		var code []byte
+		for len(fields) != 0 && len(fields[0]) == 2 {
+			value, err := strconv.ParseUint(fields[0], 16, 8)
+			if err != nil {
+				break
+			}
+			code, fields = append(code, byte(value)), fields[1:]
+		}
+		if len(code) == 0 || len(fields) == 0 {
+			continue
+		}
+		mnemonic := fields[0]
+		if strings.HasPrefix(mnemonic, "xadd") || mnemonic == "lock" && len(fields) > 1 && strings.HasPrefix(fields[1], "xadd") {
+			locked, expected := want[owner]
+			if !expected {
+				failures = append(failures, fmt.Errorf("unowned target exchange instruction %s: %s", owner, line))
+				continue
+			}
+			if mnemonic == "lock" {
+				mnemonic = fields[1]
+			}
+			seen[owner]++
+			actualLock := code[0] == 0xf0 || previousLock && previousEnd == pc
+			if actualLock != locked || mnemonic != "xadd"+strings.ToLower(owner[6:7]) {
+				failures = append(failures, fmt.Errorf("%s locked=%t want=%t: %s", owner, actualLock, locked, line))
+			}
+		}
+		previousEnd = pc + uint64(len(code))
+		previousLock = len(code) == 1 && code[0] == 0xf0 && mnemonic == "lock"
+	}
+	for owner := range want {
+		if seen[owner] != 1 {
+			failures = append(failures, fmt.Errorf("target function %s has %d XADDs, want one", owner, seen[owner]))
+		}
+	}
+	return errors.Join(failures...)
+}
+
+func TestX86ExchangeObjectPrefixReaderBoundaries(t *testing.T) {
+	// LLVM22's actual default disassembly separates f0 from the following
+	// opcode. Keep its observed function/byte shape, including symbol spelling.
+	const listing = "0000 <PrefixB_false>:\n0: 0f c0 07 xaddb %al,(%rdi)\n" +
+		"0003 <PrefixB_true>:\n3: f0 lock\n4: 0f c0 07 xaddb %al,(%rdi)\n"
+	for _, sample := range []struct {
+		name, text string
+		valid      bool
+	}{
+		{"observed", listing, true},
+		{"platform-underscore", strings.ReplaceAll(listing, "<Prefix", "<_Prefix"), true},
+		{"swapped-functions", strings.NewReplacer("PrefixB_false", "PrefixB_true", "PrefixB_true", "PrefixB_false").Replace(listing), false},
+		{"other-next-opcode", strings.Replace(listing, "4: 0f", "4: 90 nop\n5: 0f", 1), false},
+		{"nonadjacent-prefix", strings.Replace(listing, "4: 0f", "5: 0f", 1), false},
+		{"wrong-width", strings.ReplaceAll(listing, "xaddb", "xaddw"), false},
+		{"foreign-owner", strings.Replace(listing, "PrefixB_true", "Other", 1), false},
+	} {
+		t.Run(sample.name, func(t *testing.T) {
+			if err := x86ExchangeObjectPrefixError(sample.text, "B"); (err == nil) != sample.valid {
+				t.Fatal("object prefix reader changed its function/adjacency/width boundary", err)
+			}
+		})
+	}
+}
+
+func TestX86ExchangeMemoryPrefixOriginalAndLLVMObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump are required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			widths := "BWLQ"
+			if target.arch == "386" {
+				widths = "BWL"
+			}
+			var source, declarations strings.Builder
+			var bodies, prefixes []x86OfficialPackedCase
+			for _, width := range widths {
+				for _, locked := range []bool{false, true} {
+					body := fmt.Sprintf("XADD%c CX,1(SI)", width)
+					if width == 'B' {
+						body = "XADDB CL,1(SI)"
+					}
+					if locked {
+						body = "LOCK\n" + body
+					}
+					program, declaration := x86UnlockedScalarRMWFixture(target.arch, body, true)
+					name := fmt.Sprintf("Prefix%c_%t", width, locked)
+					position := strings.Index(program, "\nXADD")
+					if position < 0 {
+						t.Fatal("original source lost its XADD")
+					}
+					line := strings.Count(source.String(), "\n") + strings.Count(program[:position+1], "\n") + 1
+					end := strings.IndexByte(program[position+1:], '\n') + position + 1
+					code := []byte{0x0f, 0xc1, 0x4c, 0x1f, 0xff} // CX,-1(DI)(BX*1).
+					if width == 'B' {
+						code[1] = 0xc0
+					} else if width == 'W' {
+						code = append([]byte{0x66}, code...)
+					} else if width == 'Q' {
+						code = append([]byte{0x48}, code...)
+					}
+					fixture := x86OfficialPackedCase{symbol: name, row: name, line: line,
+						witness: goasmrules.X86PackedBinaryWitness{Instruction: program[position+1 : end], Encoding: code}}
+					bodies = append(bodies, fixture)
+					if locked {
+						fixture.line--
+						fixture.witness.Instruction, fixture.witness.Encoding = "LOCK", []byte{0xf0}
+					}
+					prefixes = append(prefixes, fixture)
+					source.WriteString(strings.Replace(program, "·Value", "·"+name, 1))
+					declarations.WriteString(strings.Replace(declaration, "Value", name, 1) + "\n")
+				}
+			}
+			// Original assembler output retains every explicit prefix, independently
+			// of the translator's template and LLVM's machine encoder.
+			listing, err := x86ScalarLiteralGoListing(t, target.arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, original := range [][]x86OfficialPackedCase{bodies, prefixes} {
+				if err := x86OfficialPackedVerifyListing(listing, original); err != nil {
+					t.Fatal("original Go function lost its exact XADD/prefix bytes", err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized complete bare/LOCK exchange source rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						disassembly := x86ExchangeObjectDisassembly(t, llc, objdump, target.triple, ir, level)
+						if err := x86ExchangeObjectPrefixError(disassembly, widths); err != nil {
+							t.Error("EXCHANGE_ORIGINAL_PREFIX_CHANGED", api, level, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ExchangeHighByteOriginalPhysicalViews(t *testing.T) {
+	for _, stem := range []struct{ name, opcode string }{{"XCHG", "86"}, {"XADD", "0fc0"}} {
+		for _, sample := range []struct {
+			operands, prefix, modrm string
+			context                 bool
+		}{
+			{"AH,AL", "", "e0", false}, {"AL,AH", "", "c4", false}, {"AH,BL", "", "e3", false},
+			{"AH,R8", "41", "e0", true}, {"R8,AH", "44", "c4", true}, {"AH,(R8)", "41", "20", true},
+			{"AH,BPB", "40", "e5", true}, {"BPB,AH", "40", "ec", true}, {"AH,SIB", "40", "e6", true}, {"AH,DIB", "40", "e7", true},
+			{"BL,BPB", "40", "dd", false}, {"BPB,BL", "40", "eb", false},
+		} {
+			operation := stem.name + "B " + sample.operands
+			t.Run(operation, func(t *testing.T) {
+				source := "TEXT ·ExchangeByte(SB),4,$0-0\n" + operation + "\nRET\n"
+				code, err := hex.DecodeString(sample.prefix + stem.opcode + sample.modrm)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fixture := x86OfficialPackedCase{symbol: "ExchangeByte", line: 2, row: operation,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: operation, Encoding: code}}
+				listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{fixture}); err != nil {
+					t.Fatal("actual physical byte-view oracle", err)
+				}
+				instruction := x86ScalarLaneInstruction(t, operation)
+				spec := amd64ExchangeSpecs[instruction.Op]
+				_, err = parseAMD64ExchangeForm("amd64", instruction.Op, spec, instruction)
+				if sample.context && !errors.Is(err, ErrProbeNeedsContext) || !sample.context && err != nil {
+					t.Error("EXCHANGE_HIGH_BYTE_PHYSICAL_VIEW_CHANGED", sample.context, err)
+				}
+			})
+		}
+		t.Run(stem.name+"/LOCK-high-byte-memory", func(t *testing.T) {
+			operation := stem.name + "B AH,(R8)"
+			source := "TEXT ·LockedByte(SB),4,$0-0\nLOCK\n" + operation + "\nRET\n"
+			code, err := hex.DecodeString("41" + stem.opcode + "20")
+			if err != nil {
+				t.Fatal(err)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, original := range []x86OfficialPackedCase{
+				{symbol: "LockedByte", line: 2, row: operation, witness: goasmrules.X86PackedBinaryWitness{Instruction: "LOCK", Encoding: []byte{0xf0}}},
+				{symbol: "LockedByte", line: 3, row: operation, witness: goasmrules.X86PackedBinaryWitness{Instruction: operation, Encoding: code}},
+			} {
+				if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{original}); err != nil {
+					t.Fatal("original LOCK/REX byte view changed", err)
+				}
+			}
+			instruction := x86ScalarLaneInstruction(t, operation)
+			if _, err := parseAMD64ExchangeForm("amd64", instruction.Op, amd64ExchangeSpecs[instruction.Op], instruction); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("LOCK granted an unbound physical high-byte view", err)
+			}
+		})
+	}
+}
+
+func TestX86ExchangeHighBytePublicInputBoundaries(t *testing.T) {
+	for _, sample := range []struct {
+		operation string
+		context   bool
+		memory    bool
+	}{
+		{"XADDB AH,AL", false, false}, {"XADDB AL,AH", false, false}, {"XADDB AH,BL", false, false},
+		{"XADDB AL,R8", false, false}, {"XADDB AH,R8", true, false}, {"XADDB R8,AH", true, false},
+		{"XADDB AH,(R8)", true, true},
+	} {
+		t.Run(sample.operation, func(t *testing.T) {
+			declaration := "func ExchangeInput(memory *[16]byte,seed,old uintptr) uintptr\n"
+			address := "MOVQ old+16(FP),R8\n"
+			if sample.memory {
+				address = "MOVQ memory+0(FP),R8\n"
+			}
+			source := "TEXT ·ExchangeInput(SB),4,$0-32\nMOVQ seed+8(FP),AX\nMOVQ old+16(FP),BX\n" +
+				address + sample.operation + "\nMOVQ AX,ret+24(FP)\nRET\n"
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if sample.context {
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error("unbound original REX byte view acquired NUM", api, err)
+					}
+				} else if err != nil || ir == "" {
+					t.Error("initialized original byte alias lost its public continuation", api, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_official_explicit_simd_objects_test.go b/x86_official_explicit_simd_objects_test.go
new file mode 100644
index 000000000..bb251fc6a
--- /dev/null
+++ b/x86_official_explicit_simd_objects_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func explicitSIMD27InitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if word == 4 {
+		move = "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DX\n%s a+%d(FP),SI\n%s b+%d(FP),DI\n%s input+%d(FP),CX\nMOVOU (SI),X0\nMOVOU (DI),X1\nCMPL CX,CX\n", name, 4*word, move, move, word, move, 2*word, move, 3*word)
+	// AX has exactly one role in each original form. An address used by a
+	// memory form is never also used as the numerical insert source.
+	if strings.Contains(operation, "(AX)") {
+		source += move + " SI,AX\n"
+	} else {
+		source += move + " CX,AX\n"
+	}
+	mmx := strings.Contains(operation, "M0")
+	if mmx {
+		source += "MOVQ (SI),M0\n"
+	}
+	source += operation + "\n"
+	if mmx {
+		source += "EMMS\n"
+	}
+	source += "MOVOU X1,0(DX)\nMOVOU (SI),X2\nMOVOU X2,16(DX)\n"
+	if strings.HasSuffix(operation, ",AX") {
+		store := "MOVL"
+		if strings.HasPrefix(operation, "PEXTRQ ") {
+			store = "MOVQ"
+		}
+		source += store + " AX,32(DX)\n"
+	}
+	source += "SETCS CL\nMOVB CL,40(DX)\nSETEQ CL\nMOVB CL,41(DX)\nRET\n"
+	return source, fmt.Sprintf("func %s(out *[64]byte,a,b *[16]byte,input uintptr)\n", name)
+}
+
+// Original source and byte identity precede LLVM objects. The scalar mask,
+// lane memory access, old vector bytes and MMX state retain separate owners.
+func TestX86LegacyExplicitSIMDInitializedThreeAPIObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := explicitSIMD27OriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		var cases []x86OfficialPackedCase
+		for _, fixture := range originals {
+			op := strings.Fields(fixture.witness.Instruction)[0]
+			if arch == "386" && (op == "PEXTRQ" || op == "PINSRQ") {
+				continue
+			}
+			cases = append(cases, fixture)
+		}
+		x86Legacy127Objects(t, arch, cases, explicitSIMD27InitializedFunction)
+	}
+}
diff --git a/x86_official_explicit_simd_rows_test.go b/x86_official_explicit_simd_rows_test.go
new file mode 100644
index 000000000..cac8d5c7b
--- /dev/null
+++ b/x86_official_explicit_simd_rows_test.go
@@ -0,0 +1,286 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent literal fixtures retain physical directions and Go's first
+// matching PEXTRW register row; the second row is witnessed by memory only.
+func explicitSIMD27OriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	type sample struct {
+		name        string
+		row         int
+		args, codes []string
+	}
+	samples := []sample{
+		{"EXTRACTPS", 0, []string{"$3,X0,AX", "$3,X0,(AX)"}, []string{"660f3a17c003", "660f3a170003"}},
+		{"INSERTPS", 0, []string{"$7,X0,X1", "$7,(AX),X1"}, []string{"660f3a21c807", "660f3a210807"}},
+		{"PEXTRW", 0, []string{"$7,X0,AX"}, []string{"660fc5c007"}},
+		{"PEXTRW", 1, []string{"$7,X0,(AX)"}, []string{"660f3a150007"}},
+		{"PEXTRB", 0, []string{"$7,X0,AX", "$7,X0,(AX)"}, []string{"660f3a14c007", "660f3a140007"}},
+		{"PEXTRD", 0, []string{"$7,X0,AX", "$7,X0,(AX)"}, []string{"660f3a16c007", "660f3a160007"}},
+		{"PEXTRQ", 0, []string{"$7,X0,AX", "$7,X0,(AX)"}, []string{"66480f3a16c007", "66480f3a160007"}},
+		{"PINSRW", 0, []string{"$7,AX,X1", "$7,(AX),X1"}, []string{"660fc4c807", "660fc40807"}},
+		{"PINSRB", 0, []string{"$7,AX,X1", "$7,(AX),X1"}, []string{"660f3a20c807", "660f3a200807"}},
+		{"PINSRD", 0, []string{"$7,AX,X1", "$7,(AX),X1"}, []string{"660f3a22c807", "660f3a220807"}},
+		{"PINSRQ", 0, []string{"$7,AX,X1", "$7,(AX),X1"}, []string{"66480f3a22c807", "66480f3a220807"}},
+		{"CMPPD", 0, []string{"X0,X1,$7", "(AX),X1,$7"}, []string{"660fc2c807", "660fc20807"}},
+		{"CMPPS", 0, []string{"X0,X1,$7", "(AX),X1,$7"}, []string{"0fc2c807", "0fc20807"}},
+		{"CMPSD", 0, []string{"X0,X1,$7", "(AX),X1,$7"}, []string{"f20fc2c807", "f20fc20807"}},
+		{"CMPSS", 0, []string{"X0,X1,$7", "(AX),X1,$7"}, []string{"f30fc2c807", "f30fc20807"}},
+		{"BLENDVPS", 0, []string{"X0,X0,X1", "X0,(AX),X1"}, []string{"660f3814c8", "660f381408"}},
+		{"BLENDVPD", 0, []string{"X0,X0,X1", "X0,(AX),X1"}, []string{"660f3815c8", "660f381508"}},
+		{"PBLENDVB", 0, []string{"X0,X0,X1", "X0,(AX),X1"}, []string{"660f3810c8", "660f381008"}},
+		{"SHA1RNDS4", 0, []string{"$3,X0,X1", "$3,(AX),X1"}, []string{"0f3accc803", "0f3acc0803"}},
+		{"SHA256RNDS2", 0, []string{"X0,X0,X1", "X0,(AX),X1"}, []string{"0f38cbc8", "0f38cb08"}},
+		{"MOVMSKPD", 0, []string{"X0,AX"}, []string{"660f50c0"}},
+		{"MOVMSKPS", 0, []string{"X0,AX"}, []string{"0f50c0"}},
+		{"PMOVMSKB", 0, []string{"X0,AX"}, []string{"660fd7c0"}},
+		{"PMOVMSKB", 1, []string{"M0,AX"}, []string{"0fd7c0"}},
+		{"MOVHLPS", 0, []string{"X0,X1"}, []string{"0f12c8"}},
+		{"MOVLHPS", 0, []string{"X0,X1"}, []string{"0f16c8"}},
+		{"PHMINPOSUW", 0, []string{"X0,X1", "(AX),X1"}, []string{"660f3841c8", "660f384108"}},
+		{"PTEST", 0, []string{"X0,X1", "(AX),X1"}, []string{"660f3817c8", "660f381708"}},
+	}
+	entries := map[string]goasmrules.X86LegacyOpcode{}
+	for _, entry := range catalog.Optab {
+		for _, s := range samples {
+			if entry.Opcode == s.name {
+				entries[s.name] = entry
+			}
+		}
+	}
+	if len(entries) != 26 {
+		t.Fatal("incomplete independent original family", len(entries))
+	}
+	var cases []x86OfficialPackedCase
+	for _, sample := range samples {
+		entry := entries[sample.name]
+		if sample.row >= len(entry.Rows) {
+			t.Fatal("missing original row", sample)
+		}
+		for i, args := range sample.args {
+			code, err := hex.DecodeString(sample.codes[i])
+			if err != nil {
+				t.Fatal(err)
+			}
+			destination := args[strings.LastIndex(args, ",")+1:]
+			if entry.Ytab == "yxcmpi" {
+				destination = "X1"
+			}
+			cases = append(cases, x86OfficialPackedCase{row: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, sample.row), witness: goasmrules.X86PackedBinaryWitness{Instruction: sample.name + " " + args, Encoding: code, Destination: destination}})
+		}
+	}
+	if len(cases) != 48 {
+		t.Fatal("independent whole-family formats changed", len(cases))
+	}
+	return cases
+}
+
+func TestX86LegacyExplicitSIMDCompleteSourceJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := explicitSIMD27OriginalCases(t, catalog)
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86LegacyExplicitSIMDRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expected := map[string]x86OfficialPackedCase{}
+		for _, fixture := range originals {
+			name := strings.Fields(fixture.witness.Instruction)[0]
+			if arch == "386" && (name == "PEXTRQ" || name == "PINSRQ") {
+				continue
+			}
+			key := fixture.row + "/" + fixture.witness.Instruction
+			if _, dup := expected[key]; dup {
+				t.Fatal("duplicate independent fixture", key)
+			}
+			expected[key] = fixture
+		}
+		seen, filtered := map[string]bool{}, 0
+		for _, row := range rows {
+			if seen[row.ID] {
+				t.Fatal("duplicate original source ID", row.ID)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				if arch != "386" || row.Opcode != "PEXTRQ" && row.Opcode != "PINSRQ" || len(row.Witnesses) != 0 {
+					t.Fatal("mode restriction changed", row)
+				}
+				filtered++
+				continue
+			}
+			for _, w := range row.Witnesses {
+				key := row.ID + "/" + w.Instruction
+				fixture, found := expected[key]
+				if !found || !bytes.Equal(w.Encoding, fixture.witness.Encoding) || w.Destination != fixture.witness.Destination {
+					t.Fatal("original source ID/encoding/direction mismatch", key, w, fixture)
+				}
+				delete(expected, key)
+			}
+		}
+		wantFiltered := 0
+		if arch == "386" {
+			wantFiltered = 2
+		}
+		if len(rows) != 28 || filtered != wantFiltered || len(expected) != 0 {
+			t.Fatal("incomplete exact source join", arch, len(rows), filtered, len(expected))
+		}
+		modes[arch] = rows
+	}
+	if _, err := goasmrules.X86LegacyExplicitSIMDRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign mode accepted")
+	}
+	for _, duplicate := range []bool{false, true} {
+		changed := catalog
+		changed.Optab = append([]goasmrules.X86LegacyOpcode(nil), catalog.Optab...)
+		for i, entry := range changed.Optab {
+			if entry.Opcode == "EXTRACTPS" {
+				if duplicate {
+					changed.Optab = append(changed.Optab, entry)
+				} else {
+					changed.Optab = append(changed.Optab[:i], changed.Optab[i+1:]...)
+				}
+				break
+			}
+		}
+		if _, err := goasmrules.X86LegacyExplicitSIMDRows(changed, "amd64"); err == nil {
+			t.Fatal("incomplete/duplicate source accepted", duplicate)
+		}
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_LEGACY_EXPLICIT_SIMD_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+func TestX86LegacyExplicitSIMDOriginalGoBytesAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := explicitSIMD27OriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var accepted []x86OfficialPackedCase
+			for _, original := range originals {
+				name := strings.Fields(original.witness.Instruction)[0]
+				if arch == "386" && (name == "PEXTRQ" || name == "PINSRQ") {
+					t.Run("Q-refusal/"+original.witness.Instruction, func(t *testing.T) {
+						listing, err := x86ScalarLiteralExpectedGoListing(t, arch, "TEXT ·NoQ(SB),4,$0-0\n"+original.witness.Instruction+"\nRET\n", false)
+						t.Logf("ORIGINAL_EXPLICIT_SIMD_Q_REFUSAL source=%q exit=%v diagnostic=%q", original.witness.Instruction, err, listing)
+					})
+					continue
+				}
+				accepted = append(accepted, original)
+			}
+			for start := 0; start < len(accepted); start += 32 {
+				end := start + 32
+				if end > len(accepted) {
+					end = len(accepted)
+				}
+				var source strings.Builder
+				batch := append([]x86OfficialPackedCase(nil), accepted[start:end]...)
+				for i := range batch {
+					batch[i].symbol = fmt.Sprintf("ExplicitSIMD%d", start+i)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[i].symbol)
+					batch[i].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[i].witness.Instruction)
+					source.WriteString("RET\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("independent original SIMD bytes", err)
+				}
+			}
+			want := 48
+			if arch == "386" {
+				want = 44
+			}
+			if len(accepted) != want {
+				t.Fatal("mode inventory changed", len(accepted))
+			}
+		})
+	}
+}
+
+func TestX86LegacyExplicitSIMDOriginalImmediateBoundaries(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := explicitSIMD27OriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			seen := map[string]bool{}
+			var positives []x86OfficialPackedCase
+			for _, fixture := range originals {
+				instruction := fixture.witness.Instruction
+				name := strings.Fields(instruction)[0]
+				if seen[fixture.row] || !strings.Contains(instruction, "$") || arch == "386" && (name == "PEXTRQ" || name == "PINSRQ") {
+					continue
+				}
+				seen[fixture.row] = true
+				values := []int{0, 255, -1, 256}
+				if name == "EXTRACTPS" || name == "SHA1RNDS4" {
+					values = []int{0, 3, -1, 4}
+				} else if strings.HasPrefix(name, "CMP") {
+					values = []int{-128, 127, -129, 128}
+				}
+				start := strings.IndexByte(instruction, '$')
+				end := start
+				for end < len(instruction) && instruction[end] != ',' {
+					end++
+				}
+				for index, value := range values {
+					changed := instruction[:start] + fmt.Sprintf("$%d", value) + instruction[end:]
+					if index >= 2 {
+						t.Run(fmt.Sprintf("%s/%d", fixture.row, value), func(t *testing.T) {
+							listing, err := x86ScalarLiteralExpectedGoListing(t, arch, "TEXT ·ImmediateBound(SB),4,$0-0\n"+changed+"\nRET\n", false)
+							t.Logf("EXPLICIT_SIMD_IMMEDIATE_REFUSAL arch=%s source=%q exit=%v diagnostic=%q", arch, changed, err, listing)
+						})
+						continue
+					}
+					positive := fixture
+					positive.witness.Instruction = changed
+					positive.witness.Encoding = append([]byte(nil), fixture.witness.Encoding...)
+					positive.witness.Encoding[len(positive.witness.Encoding)-1] = byte(value)
+					positives = append(positives, positive)
+				}
+			}
+			if len(positives) > 32 {
+				t.Fatal("immediate batch bound", len(positives))
+			}
+			var source strings.Builder
+			for i := range positives {
+				positives[i].symbol = fmt.Sprintf("ImmediateBound%d", i)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", positives[i].symbol)
+				positives[i].line = strings.Count(source.String(), "\n") + 1
+				fmt.Fprintln(&source, positives[i].witness.Instruction)
+				source.WriteString("RET\n")
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, positives); err != nil {
+				t.Fatal("original immediate boundaries", err)
+			}
+		})
+	}
+}
diff --git a/x86_official_float_binary_rows_test.go b/x86_official_float_binary_rows_test.go
new file mode 100644
index 000000000..5ece0eb88
--- /dev/null
+++ b/x86_official_float_binary_rows_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialAVXFloatBinaryRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86AVXFloatBinaryRows, 132, 684, 0)
+}
+
+func TestX86OfficialFloatBinaryOriginalScalarPPAndSAEBytes(t *testing.T) {
+	var cases []x86OfficialPackedCase
+	for index, anchor := range []struct {
+		instruction, generation, bank string
+		encoding                      []byte
+	}{
+		{"VADDSD X0,X1,X2", "vex", "X", []byte{0xc5, 0xf3, 0x58, 0xd0}},
+		{"VADDSS X0,X1,X2", "vex", "X", []byte{0xc5, 0xf2, 0x58, 0xd0}},
+		{"VDIVSD.RD_SAE X16,X17,X18", "evex", "X", []byte{0x62, 0xa1, 0xf7, 0x30, 0x5e, 0xd0}},
+		{"VMINPD.SAE Z16,Z17,Z18", "evex", "Z", []byte{0x62, 0xa1, 0xf5, 0x50, 0x5d, 0xd0}},
+		{"VMINSD.SAE X16,X17,X18", "evex", "X", []byte{0x62, 0xa1, 0xf7, 0x10, 0x5d, 0xd0}},
+		{"VMAXSS.SAE.Z X16,X17,K1,X18", "evex", "X", []byte{0x62, 0xa1, 0x76, 0x91, 0x5f, 0xd0}},
+	} {
+		first, second, destination := anchor.bank+"0", anchor.bank+"1", anchor.bank+"2"
+		if anchor.generation == "evex" {
+			first, second, destination = anchor.bank+"16", anchor.bank+"17", anchor.bank+"18"
+		}
+		width := 128
+		if anchor.bank == "Z" {
+			width = 512
+		}
+		cases = append(cases, x86OfficialPackedCase{row: fmt.Sprint("independent/float-binary/", index),
+			witness: goasmrules.X86PackedBinaryWitness{
+				Instruction: anchor.instruction, Generation: anchor.generation, Width: width,
+				First: first, Second: second, Destination: destination, Encoding: anchor.encoding,
+				Masked: strings.Contains(anchor.instruction, "K1"), Zeroing: strings.Contains(anchor.instruction, ".Z"),
+			}})
+	}
+	source, _ := x86OfficialPackedAssembly(cases)
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("actual original scalar pp or SAE vector length changed", err)
+	}
+}
+
+func TestX86OfficialFloatBinaryMergeAndZeroingInputs(t *testing.T) {
+	for _, opcode := range []string{"VADDPS", "VMULSD", "VMINPS", "VMAXSD"} {
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			t.Run(opcode+"/"+mode, func(t *testing.T) {
+				op, mask := opcode, ""
+				if mode != "plain" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					op += ".Z"
+				}
+				cases := []x86OfficialPackedCase{{row: "dependency/" + opcode,
+					witness: goasmrules.X86PackedBinaryWitness{
+						Instruction: op + " X16,X17," + mask + "X18", Generation: "evex", Width: 128,
+						First: "X16", Second: "X17", Destination: "X18", Masked: mode != "plain", Zeroing: mode == "zero",
+					}}}
+				source, declaration := x86OfficialPackedAssembly(cases)
+				old := "VMOVUPS (BX),X18\n"
+				if strings.Contains(source, old) != (mode == "merge") {
+					t.Fatal("ordinary floating fixture acquired FMA's unconditional old-destination input", source)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatal("complete ordinary floating inputs lost their positive continuation", err)
+						}
+						missing := []string{"VMOVUPS (AX),X16\n", "VMOVUPS (BX),X17\n"}
+						if mode == "merge" {
+							missing = append(missing, old)
+						}
+						for _, load := range missing {
+							negative := strings.Replace(source, load, "", 1)
+							if negative == source {
+								t.Fatal("missing-input control did not remove its initialization", load)
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+							x86VectorScratchCodegenControl(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_official_fma3_rows_test.go b/x86_official_fma3_rows_test.go
new file mode 100644
index 000000000..a499096df
--- /dev/null
+++ b/x86_official_fma3_rows_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialFMA3RowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86FMA3Rows, 360, 2028, 0, x86OfficialFMA3Assembly)
+}
+
+func x86OfficialFMA3Assembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declarations strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprintf("FMARow%d", index)
+		body, declaration := x86FMA3InitializedAxisSource("amd64", fixture.symbol, fixture.witness.Instruction)
+		for offset, instruction := range strings.Split(body, "\n") {
+			if instruction == fixture.witness.Instruction {
+				fixture.line = line + offset
+			}
+		}
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialFMA3ScalarTupleAndRoundingGoBytes(t *testing.T) {
+	var source strings.Builder
+	var cases []x86OfficialPackedCase
+	line := 1
+	for index, anchor := range []struct {
+		instruction string
+		encoding    []byte
+	}{
+		{"VFMADD132SD.RD_SAE X16,X17,X18", []byte{0x62, 0xa2, 0xf5, 0x30, 0x99, 0xd0}},
+		{"VFMADD132SS.RU_SAE.Z X16,X17,K1,X18", []byte{0x62, 0xa2, 0x75, 0xd1, 0x99, 0xd0}},
+		{"VFNMADD231PS.RN_SAE Z16,Z17,Z18", []byte{0x62, 0xa2, 0x75, 0x10, 0xbc, 0xd0}},
+		{"VFNMSUB132PD.RZ_SAE.Z Z16,Z17,K1,Z18", []byte{0x62, 0xa2, 0xf5, 0xf1, 0x9e, 0xd0}},
+		{"VFMADD132SD 64(AX),X17,X18", []byte{0x62, 0xe2, 0xf5, 0x00, 0x99, 0x50, 0x08}},
+		{"VFMADD132SS 64(AX),X17,X18", []byte{0x62, 0xe2, 0x75, 0x00, 0x99, 0x50, 0x10}},
+	} {
+		name := fmt.Sprintf("FMAByte%d", index)
+		body, _ := x86FMA3InitializedAxisSource("amd64", name, anchor.instruction)
+		fixture := x86OfficialPackedCase{
+			row: "independent/FMA3/" + anchor.instruction, symbol: name,
+			witness: goasmrules.X86PackedBinaryWitness{Instruction: anchor.instruction, Encoding: anchor.encoding},
+		}
+		for offset, instruction := range strings.Split(body, "\n") {
+			if instruction == anchor.instruction {
+				fixture.line = line + offset
+			}
+		}
+		cases = append(cases, fixture)
+		source.WriteString(body)
+		line += strings.Count(body, "\n")
+	}
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("actual original Go bytes lost scalar N4/N8 tuple compression or RC fields", err)
+	}
+}
+
+func TestX86FMA3InitializedAxisSourceOwnsOfficialHighBankOperands(t *testing.T) {
+	for _, instruction := range []string{
+		"VFMADD132PS X16,X17,X18",
+		"VFMADD132PS Y16,Y17,Y18",
+		"VFMADD132PS Z16,Z17,Z18",
+		"VFMADD132SD.RD_SAE X16,X17,X18",
+		"VFMADD132PS.BCST.Z (AX),Z17,K1,Z18",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source, _ := x86FMA3InitializedAxisSource("amd64", "OfficialFMA", instruction)
+			bank := strings.Split(strings.Fields(instruction)[1], ",")[1][:1]
+			for _, register := range []int{16, 17, 18} {
+				if !strings.Contains(source, fmt.Sprintf("VMOVUPS (AX),%s%d\n", bank, register)) {
+					t.Fatal("official high-bank FMA3 lacks an initialized arithmetic source or old destination", source)
+				}
+			}
+			if !strings.Contains(source, instruction+"\n") || !strings.Contains(source, "VMOVD X18,AX\n") {
+				t.Fatal("FMA3 fixture changed the original instruction or its public result continuation", source)
+			}
+			if !strings.Contains(instruction, "K1") && strings.Contains(source, "KMOVW") {
+				t.Fatal("plain FMA3 fixture borrowed an unrelated AVX512 mask", source)
+			}
+		})
+	}
+}
+
+func TestX86OfficialFMA3ZeroingStillRequiresOldDestination(t *testing.T) {
+	for _, instruction := range []string{
+		"VFMADD132PS.Z X0,X1,K1,X2",
+		"VFNMADD231SD.Z X0,X1,K1,X2",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source, declaration := x86FMA3InitializedAxisSource("amd64", "OldFMA", instruction)
+			missing := strings.Replace(source, "MOVUPS (AX),X2\n", "", 1)
+			if missing == source {
+				t.Fatal("old-destination negative did not remove its independent initialization")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("independently initialized zeroing FMA3 lost its positive continuation", err)
+					}
+					ir, err = x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					x86VectorScratchCodegenControl(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_official_fp_immediate_control_rows_test.go b/x86_official_fp_immediate_control_rows_test.go
new file mode 100644
index 000000000..09e72fc0d
--- /dev/null
+++ b/x86_official_fp_immediate_control_rows_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialFloatingImmediateControlRowsInitializedThreeAPIsObjects(t *testing.T) {
+	// The existing FMA producer initializes active old DEST even for plain or
+	// zero-masked FIXUP, plus scalar upper/data sources. No new producer is needed.
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86FloatingImmediateControlRows, 80, 390, 0, x86OfficialFMA3Assembly)
+}
+
+func TestX86OfficialFloatingImmediateControlScalarAndBroadcastTupleGoBytes(t *testing.T) {
+	var cases []x86OfficialPackedCase
+	for _, anchor := range []struct {
+		instruction string
+		encoding    []byte
+	}{
+		{"VGETMANTSS $7,64(AX),X17,X18", []byte{0x62, 0xe3, 0x75, 0x00, 0x27, 0x50, 0x10, 0x07}},
+		{"VGETMANTSD $7,64(AX),X17,X18", []byte{0x62, 0xe3, 0xf5, 0x00, 0x27, 0x50, 0x08, 0x07}},
+		{"VGETMANTPS $7,64(AX),Z18", []byte{0x62, 0xe3, 0x7d, 0x48, 0x26, 0x50, 0x01, 0x07}},
+		{"VGETMANTPD.BCST $7,64(AX),Y18", []byte{0x62, 0xe3, 0xfd, 0x38, 0x26, 0x50, 0x08, 0x07}},
+		{"VFIXUPIMMPS.BCST.Z $7,64(AX),Z17,K1,Z18", []byte{0x62, 0xe3, 0x75, 0xd1, 0x54, 0x50, 0x10, 0x07}},
+		{"VRNDSCALESD.SAE.Z $7,X16,X17,K1,X18", []byte{0x62, 0xa3, 0xf5, 0x91, 0x0b, 0xd0, 0x07}},
+	} {
+		cases = append(cases, x86OfficialPackedCase{
+			row:     "independent/FP-control/" + anchor.instruction,
+			witness: goasmrules.X86PackedBinaryWitness{Instruction: anchor.instruction, Encoding: anchor.encoding},
+		})
+	}
+	source, _ := x86OfficialFMA3Assembly(cases)
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("original Go scalar/full/broadcast tuple or SAE byte identity", err)
+	}
+}
diff --git a/x86_official_gfni_rows_test.go b/x86_official_gfni_rows_test.go
new file mode 100644
index 000000000..bd68f465e
--- /dev/null
+++ b/x86_official_gfni_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialGFNIRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86GFNIRows, 24, 84, 0)
+}
diff --git a/x86_official_gp_bmi_rows_test.go b/x86_official_gp_bmi_rows_test.go
new file mode 100644
index 000000000..42c1cf515
--- /dev/null
+++ b/x86_official_gp_bmi_rows_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The source producer follows scalar operand roles. MULX independently reads
+// DX and stores both results; ordinary ternary operations read CX instead.
+// This is initialized object evidence, not a numerical or FLAGS oracle.
+func x86OfficialGPBMIAssembly(cases []x86OfficialPackedCase, arch string) (string, string) {
+	word, move := 8, "Q"
+	if arch == "386" {
+		word, move = 4, "L"
+	}
+	var source, declarations strings.Builder
+	for index := range cases {
+		fixture := &cases[index]
+		w := fixture.witness
+		mulx := strings.HasPrefix(w.Instruction, "MULX")
+		fixture.symbol = fmt.Sprint("GPBMI", index)
+		results, size := "(result uintptr)", word*5
+		if mulx {
+			results, size = "(low,high uintptr)", word*6
+		}
+		fmt.Fprintf(&declarations, "func %s(memory *[8]byte,a,control,multiplier uintptr) %s\n", fixture.symbol, results)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", fixture.symbol, size)
+		if w.Memory {
+			fmt.Fprintf(&source, "MOV%s memory+0(FP),AX\n", move)
+		} else {
+			fmt.Fprintf(&source, "MOV%s a+%d(FP),AX\n", move, word)
+		}
+		if mulx {
+			fmt.Fprintf(&source, "MOV%s multiplier+%d(FP),DX\n", move, word*3)
+		} else if w.Second != "" {
+			fmt.Fprintf(&source, "MOV%s control+%d(FP),CX\n", move, word*2)
+		}
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, w.Instruction)
+		if mulx {
+			fmt.Fprintf(&source, "MOV%s CX,low+%d(FP)\nMOV%s BX,high+%d(FP)\n", move, word*4, move, word*5)
+		} else {
+			fmt.Fprintf(&source, "MOV%s %s,result+%d(FP)\n", move, w.Destination, word*4)
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialGPBMIRowsSelectedGoBytesThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct {
+		arch, triple    string
+		rows, witnesses int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 28, 56},
+		{"386", "i386-unknown-linux-gnu", 27, 54},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			selected := func(legacy goasmrules.X86LegacyCatalog, avx []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+				rows, err := goasmrules.X86GPBMIRows(legacy, avx)
+				if err != nil || len(rows) != 28 {
+					return nil, fmt.Errorf("complete original GP table has %d rows: %v", len(rows), err)
+				}
+				var ordinary []goasmrules.X86PackedBinaryRow
+				for _, row := range rows {
+					if mode.arch == "386" && row.Opcode == "MULXQ" {
+						continue // Existing physical-WIG Context is owned separately below.
+					}
+					ordinary = append(ordinary, row)
+				}
+				return ordinary, nil
+			}
+			x86OfficialPackedRowsObjectsForTarget(t, mode.arch, mode.triple, selected, mode.rows, mode.witnesses, 0,
+				func(cases []x86OfficialPackedCase) (string, string) {
+					return x86OfficialGPBMIAssembly(cases, mode.arch)
+				},
+				func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+					x86PackedStringCompileObject(t, llc, mode.triple, ir, "-O2")
+				})
+		})
+	}
+}
+
+func TestX86OfficialGPBMIMode32MULXQKeepsPhysicalContext(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86GPBMIRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	observed := 0
+	for _, row := range rows {
+		if row.Opcode != "MULXQ" {
+			continue
+		}
+		for _, w := range row.Witnesses {
+			observed++
+			t.Run(fmt.Sprint(w.Memory), func(t *testing.T) {
+				cases := []x86OfficialPackedCase{{row: row.ID, witness: w}}
+				source, declarations := x86OfficialGPBMIAssembly(cases, "386")
+				listing, err := x86ScalarLiteralGoListing(t, "386", source)
+				if err != nil {
+					t.Fatal("original named mode32 W1 source must be observed", err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+					t.Fatal("mode32 retained the physical VEX.W payload", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", "i386-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("named source must retain its existing physical mode32 Context, not an object/runtime pass", api, err)
+					}
+				}
+			})
+		}
+	}
+	if observed != 2 {
+		t.Fatal("complete mode32 MULXQ original-source alternatives changed", observed)
+	}
+}
+
+func TestX86GPBMIInitializedProducerKeepsActualInputRoles(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86GPBMIRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, probe := range []struct{ opcode, removed string }{
+		{"ANDNQ", "MOVQ control+16(FP),CX\n"},
+		{"BEXTRQ", "MOVQ control+16(FP),CX\n"},
+		{"BLSIQ", "MOVQ a+8(FP),AX\n"},
+		{"MULXQ", "MOVQ multiplier+24(FP),DX\n"},
+		{"RORXQ", "MOVQ a+8(FP),AX\n"},
+	} {
+		t.Run(probe.opcode, func(t *testing.T) {
+			var cases []x86OfficialPackedCase
+			for _, row := range rows {
+				if row.Opcode == probe.opcode {
+					cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: row.Witnesses[0]})
+					break
+				}
+			}
+			if len(cases) != 1 {
+				t.Fatal("independent input-role member missing")
+			}
+			source, declarations := x86OfficialGPBMIAssembly(cases, "amd64")
+			if strings.Count(source, probe.removed) != 1 {
+				t.Fatal("input mutation does not own one actual source initializer", source)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Fatal("complete initialized source must precede missing-input rejection", api, err)
+				}
+				changed := strings.Replace(source, probe.removed, "", 1)
+				if _, err := x86ScalarFPBitViewAPI(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", api); err == nil {
+					t.Fatal("missing actual scalar/implicit input was accepted", api, probe.opcode)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_official_gp_data_flags_cpu_rows_test.go b/x86_official_gp_data_flags_cpu_rows_test.go
new file mode 100644
index 000000000..ea1b7b422
--- /dev/null
+++ b/x86_official_gp_data_flags_cpu_rows_test.go
@@ -0,0 +1,414 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Source ownership is narrower than shared operand tables. In particular,
+// ARPL, INVPCID and FS/GS-base operations retain independent contracts.
+func gpDataFlagsCPU100Member(entry goasmrules.X86LegacyOpcode) bool {
+	switch entry.Ytab {
+	case "yxorb", "ytestl", "ybtl", "ybswap":
+		return true
+	case "ym_rl":
+		return strings.HasPrefix(entry.Opcode, "LEA")
+	case "yrb_mb", "yrl_ml":
+		return strings.HasPrefix(entry.Opcode, "XADD") || strings.HasPrefix(entry.Opcode, "CMPXCHG") ||
+			strings.HasPrefix(entry.Opcode, "MOVNTI") || entry.Opcode == "MOVQL"
+	case "yscond":
+		return entry.Opcode == "CMPXCHG8B" || entry.Opcode == "CMPXCHG16B"
+	case "ycrc32b", "ycrc32l":
+		return strings.HasPrefix(entry.Opcode, "CRC32") || strings.HasPrefix(entry.Opcode, "TZCNT")
+	case "yrdrand":
+		return strings.HasPrefix(entry.Opcode, "RDRAND") || strings.HasPrefix(entry.Opcode, "RDSEED") || entry.Opcode == "RDPID"
+	}
+	return false
+}
+
+// This independent reference models Go's source prefix and Z-case emission.
+// Actual Go objects below validate the model before any production-view join.
+// Strides select a later row; they are not the selected encoding's byte count.
+func gpDataFlagsCPU100OriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows := 0
+	for _, entry := range catalog.Optab {
+		if !gpDataFlagsCPU100Member(entry) {
+			continue
+		}
+		var atoms []byte
+		for _, token := range entry.OpBytes {
+			value, err := strconv.ParseUint(token, 0, 8)
+			if err != nil {
+				t.Fatal("independent GP original byte changed", entry, token, err)
+			}
+			atoms = append(atoms, byte(value))
+		}
+		width := entry.Opcode[len(entry.Opcode)-1]
+		source, destination, accumulator := "CX", "BX", "AX"
+		if width == 'B' {
+			source, destination, accumulator = "CL", "BL", "AL"
+		}
+		for _, row := range entry.Rows {
+			rows++
+			prefixes := map[string][]byte{
+				"Px": {}, "Pb": {}, "Pe": {0x66}, "Pm": {0x0f},
+				"Pq": {0x66, 0x0f}, "Pw": {0x48}, "Pf3": {0xf3, 0x0f},
+			}
+			prefix, found := prefixes[entry.Prefix]
+			if !found || row.UnmatchedOffset < 0 || row.UnmatchedOffset >= len(atoms) {
+				t.Fatal("independent GP original prefix/row changed", entry, row)
+			}
+			code := append([]byte(nil), prefix...)
+			cursor := row.UnmatchedOffset
+			if atoms[cursor] == 0x0f {
+				code = append(code, 0x0f)
+				cursor++
+			}
+			if cursor >= len(atoms) {
+				t.Fatal("missing independent GP opcode", entry, row)
+			}
+			var operands [][2]string
+			switch row.ZCase {
+			case "Zib_", "Zil_":
+				operands = append(operands, [2]string{"$128", accumulator})
+			case "Zibo_m", "Zilo_m":
+				immediate := "$128"
+				if row.Classes[0] == "Yi8" {
+					immediate = "$1"
+				}
+				operands = append(operands, [2]string{immediate, destination}, [2]string{immediate, "0(SI)"})
+			case "Zr_m":
+				// The Go table also admits a MOVNTI register destination.
+				// Like pair CAS below, that CPU-invalid encoding is retained
+				// only as a source observation, never a numerical positive.
+				operands = append(operands, [2]string{source, destination})
+				operands = append(operands, [2]string{source, "0(SI)"})
+			case "Zm_r":
+				// Register/register matches the earlier direction for the
+				// TEST/byte tables. LEA's Ym source is memory syntax only.
+				operands = append(operands, [2]string{"0(SI)", destination})
+			case "Zlitm_r":
+				operands = append(operands, [2]string{source, "BX"}, [2]string{"0(SI)", "BX"})
+			case "Zo_m":
+				if entry.Ytab == "yrdrand" {
+					operands = append(operands, [2]string{"", "BX"})
+				} else {
+					// Go's Ymb also admits register encodings for pair CAS.
+					// These are source observations only; hardware requires
+					// memory and they must not become numerical positives.
+					operands = append(operands, [2]string{"", destination}, [2]string{"", "0(SI)"})
+				}
+			case "Z_rp":
+				operands = append(operands, [2]string{"", "BX"})
+			default:
+				t.Fatal("unmodeled independent GP source Z-case", entry, row)
+			}
+			for _, args := range operands {
+				encoding := append([]byte(nil), code...)
+				memory := args[0] == "0(SI)" || args[1] == "0(SI)"
+				rm := byte(0xc3)
+				if memory {
+					rm = 6
+				}
+				encoding = append(encoding, atoms[cursor])
+				switch row.ZCase {
+				case "Zib_", "Zil_":
+				case "Zibo_m", "Zilo_m", "Zo_m":
+					if cursor+1 >= len(atoms) || atoms[cursor+1] > 7 {
+						t.Fatal("independent opcode extension changed", entry, row)
+					}
+					encoding = append(encoding, rm|atoms[cursor+1]<<3)
+				case "Zr_m":
+					encoding = append(encoding, rm|1<<3)
+				case "Zm_r":
+					encoding = append(encoding, byte(6|3<<3))
+				case "Z_rp":
+					encoding[len(encoding)-1] += 3
+				case "Zlitm_r":
+					literal := atoms[row.UnmatchedOffset:]
+					end := 0
+					for end < len(literal) && literal[end] != 0 {
+						end++
+					}
+					if end == len(literal) || end == 0 {
+						t.Fatal("independent complete literal span changed", entry)
+					}
+					literal = literal[:end]
+					encoding = append(append([]byte(nil), prefix...), literal...)
+					if entry.Prefix == "Pw" {
+						// Mandatory F2/F3 precedes REX, as in Go's final pass.
+						encoding = append([]byte{literal[0], 0x48}, literal[1:]...)
+					}
+					if !memory {
+						rm = 0xc1
+					}
+					encoding = append(encoding, rm|3<<3)
+				}
+				if strings.HasPrefix(args[0], "$") {
+					immediate, err := strconv.ParseInt(args[0][1:], 10, 64)
+					if err != nil {
+						t.Fatal(err)
+					}
+					bytes := 1
+					if width != 'B' && row.Classes[0] != "Yi8" {
+						bytes = 4
+						if width == 'W' {
+							bytes = 2
+						}
+					}
+					for i := 0; i < bytes; i++ {
+						encoding = append(encoding, byte(uint64(immediate)>>uint(8*i)))
+					}
+				}
+				instruction := entry.Opcode + " " + args[1]
+				if args[0] != "" {
+					instruction = entry.Opcode + " " + args[0] + "," + args[1]
+				}
+				cases = append(cases, x86OfficialPackedCase{
+					row:     fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex),
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Destination: args[1], Encoding: encoding},
+				})
+			}
+		}
+	}
+	if rows != 99 && rows != 100 || len(cases) != rows+66 {
+		t.Fatal("independent complete GP source formats changed", rows, len(cases))
+	}
+	return cases
+}
+
+func TestX86GPDataFlagsCPUOriginalGoCompleteBytesAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := gpDataFlagsCPU100OriginalCases(t, catalog)
+	prefixes := map[string]string{}
+	for _, entry := range catalog.Optab {
+		prefixes[entry.Opcode] = entry.Prefix
+	}
+	observations, accepted, refused := 0, 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var positives []x86OfficialPackedCase
+			for _, original := range originals {
+				observations++
+				name := strings.Fields(original.witness.Instruction)[0]
+				if arch != "386" || prefixes[name] != "Pw" {
+					accepted++
+					positives = append(positives, original)
+					continue
+				}
+				refused++
+				t.Run("mode-refusal/"+original.row+"/"+original.witness.Instruction, func(t *testing.T) {
+					source := "TEXT ·NoMode(SB),4,$0-0\n" + original.witness.Instruction + "\nRET\n"
+					listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+					if !strings.Contains(listing, "asmins: illegal 64:") || !strings.Contains(listing, name) {
+						t.Fatal("missing original source mode diagnostic", original, listing)
+					}
+				})
+			}
+			for start := 0; start < len(positives); start += 32 {
+				end := start + 32
+				if end > len(positives) {
+					end = len(positives)
+				}
+				batch := append([]x86OfficialPackedCase(nil), positives[start:end]...)
+				var source strings.Builder
+				for i := range batch {
+					batch[i].symbol = fmt.Sprintf("GPData%d", start+i)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[i].symbol)
+					batch[i].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[i].witness.Instruction)
+					source.WriteString("RET\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal("original complete GP source batch rejected", arch, start, err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("independent original GP row/encoding mismatch", arch, start, err)
+				}
+			}
+		})
+	}
+	if observations != 2*len(originals) || refused != 38 || accepted != observations-38 {
+		t.Fatal("complete GP source mode observation matrix changed", observations, accepted, refused)
+	}
+	t.Logf("GP_DATA_FLAGS_CPU_ACTUAL_GO observations=%d accepted=%d exact_mode_refusals=%d", observations, accepted, refused)
+	// Every production witness is joined to the independently assembled
+	// original ID, instruction, byte encoding and destination. Retain mode
+	// refusals as rows without promoting them to source-encoding witnesses.
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86GPDataFlagsCPURows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expected := map[string]x86OfficialPackedCase{}
+		for _, original := range originals {
+			name := strings.Fields(original.witness.Instruction)[0]
+			if arch == "386" && prefixes[name] == "Pw" {
+				continue
+			}
+			key := original.row + "/" + original.witness.Instruction
+			if _, duplicate := expected[key]; duplicate {
+				t.Fatal("duplicate independent original source witness", key)
+			}
+			expected[key] = original
+		}
+		seen, filtered := map[string]bool{}, 0
+		for _, row := range rows {
+			if seen[row.ID] {
+				t.Fatal("duplicate original source row", row.ID)
+			}
+			seen[row.ID] = true
+			if row.ModeFiltered != "" {
+				if arch != "386" || prefixes[row.Opcode] != "Pw" || len(row.Witnesses) != 0 {
+					t.Fatal("source mode refusal was widened", arch, row)
+				}
+				filtered++
+				continue
+			}
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				original, found := expected[key]
+				if !found || witness.Destination != original.witness.Destination ||
+					!bytes.Equal(witness.Encoding, original.witness.Encoding) {
+					t.Fatal("production source view differs from actual-Go ID/bytes/direction", arch, key, witness, original)
+				}
+				delete(expected, key)
+			}
+		}
+		wantFiltered := 0
+		if arch == "386" {
+			wantFiltered = 22
+		}
+		if len(rows) != 99 && len(rows) != 100 || filtered != wantFiltered || len(expected) != 0 {
+			t.Fatal("incomplete whole GP source join", arch, len(rows), filtered, len(expected))
+		}
+		modes[arch] = rows
+	}
+	if _, err := goasmrules.X86GPDataFlagsCPURows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign source mode accepted")
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_GP_DATA_FLAGS_CPU_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+func TestX86GPDataFlagsCPUOriginalGoImmediateClassBoundaries(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := gpDataFlagsCPU100OriginalCases(t, catalog)
+	entries := map[string]goasmrules.X86LegacyOpcode{}
+	for _, entry := range catalog.Optab {
+		entries[entry.Opcode] = entry
+	}
+	observations, accepted, rejected := 0, 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var positives []x86OfficialPackedCase
+			for _, original := range originals {
+				name := strings.Fields(original.witness.Instruction)[0]
+				entry := entries[name]
+				if !strings.HasSuffix(original.row, "/0") || !strings.Contains(original.witness.Instruction, "$") ||
+					strings.Contains(original.witness.Instruction, "(") || arch == "386" && entry.Prefix == "Pw" {
+					continue
+				}
+				if entry.Ytab != "yxorb" && entry.Ytab != "ytestl" && entry.Ytab != "ybtl" {
+					continue
+				}
+				for _, value := range []int64{-129, -128, -1, 0, 1, 127, 128, 255, 256} {
+					observations++
+					fixture := original
+					comma := strings.IndexByte(original.witness.Instruction, ',')
+					fixture.witness.Instruction = fmt.Sprintf("%s $%d%s", name, value, original.witness.Instruction[comma:])
+					valid := entry.Ytab != "ybtl" || value >= -128 && value <= 127
+					if !valid {
+						rejected++
+						t.Run(fixture.witness.Instruction, func(t *testing.T) {
+							listing, _ := x86ScalarLiteralExpectedGoListing(t, arch,
+								"TEXT ·NoImmediate(SB),4,$0-0\n"+fixture.witness.Instruction+"\nRET\n", false)
+							if !strings.Contains(listing, name) {
+								t.Fatal("missing original immediate-class refusal", fixture.row, listing)
+							}
+						})
+						continue
+					}
+					accepted++
+					bytes := 1
+					if entry.Ytab == "ytestl" {
+						bytes = 4
+						if strings.HasSuffix(name, "W") {
+							bytes = 2
+						}
+					}
+					fixture.witness.Encoding = append([]byte(nil), original.witness.Encoding...)
+					for i := 0; i < bytes; i++ {
+						fixture.witness.Encoding[len(fixture.witness.Encoding)-bytes+i] = byte(uint64(value) >> uint(8*i))
+					}
+					positives = append(positives, fixture)
+				}
+			}
+			for start := 0; start < len(positives); start += 32 {
+				end := start + 32
+				if end > len(positives) {
+					end = len(positives)
+				}
+				batch := append([]x86OfficialPackedCase(nil), positives[start:end]...)
+				var source strings.Builder
+				for i := range batch {
+					batch[i].symbol = fmt.Sprintf("GPImmediate%d", start+i)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[i].symbol)
+					batch[i].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[i].witness.Instruction)
+					source.WriteString("RET\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("original Yi8/Yi32 source-byte boundary mismatch", arch, start, err)
+				}
+			}
+		})
+	}
+	if observations != 369 || accepted != 289 || rejected != 80 {
+		t.Fatal("complete Yi8/Yi32 boundary inventory changed", observations, accepted, rejected)
+	}
+	t.Logf("GP_DATA_FLAGS_CPU_IMMEDIATES observations=%d exact_bytes=%d source_refusals=%d", observations, accepted, rejected)
+}
+
+// MOVQL is Go's 32-bit 0x89 alias. Its source encoding being representable
+// does not prove that the existing named translator dispatch implements it.
+func TestX86GPDataFlagsCPUMOVQLInitializedThreeAPIObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cases []x86OfficialPackedCase
+	for _, original := range gpDataFlagsCPU100OriginalCases(t, catalog) {
+		if strings.HasPrefix(original.witness.Instruction, "MOVQL ") {
+			cases = append(cases, original)
+		}
+	}
+	if len(cases) != 2 {
+		t.Fatal("complete MOVQL original source directions changed", len(cases))
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		x86Legacy127Objects(t, arch, cases, x86ScalarRMRegisterInitializedFunction)
+	}
+}
diff --git a/x86_official_immediate_integer_compare_rows_test.go b/x86_official_immediate_integer_compare_rows_test.go
new file mode 100644
index 000000000..2dc535a94
--- /dev/null
+++ b/x86_official_immediate_integer_compare_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialImmediateIntegerCompareRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86ImmediateIntegerCompareRows, 48, 240, 0)
+}
diff --git a/x86_official_insert_extract_boundaries_test.go b/x86_official_insert_extract_boundaries_test.go
new file mode 100644
index 000000000..d35490d57
--- /dev/null
+++ b/x86_official_insert_extract_boundaries_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86OfficialInsertExtractBoundaryRows(t *testing.T) []goasmrules.X86PackedBinaryRow {
+	t.Helper()
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86InsertExtractRows(legacy, avx)
+	if err != nil || len(rows) != 82 {
+		t.Fatal("complete source boundary directory changed", len(rows), err)
+	}
+	return rows
+}
+
+func x86OfficialInsertExtractTerminalSource(t *testing.T, result bool) (string, string, []x86OfficialPackedCase) {
+	t.Helper()
+	var source, declarations strings.Builder
+	var cases []x86OfficialPackedCase
+	frame, returns := 0, ""
+	if result {
+		frame, returns = 8, " uint64"
+	}
+	for _, row := range x86OfficialInsertExtractBoundaryRows(t) {
+		for _, original := range row.Witnesses {
+			if !original.Masked || original.Zeroing || original.Destination != "(AX)" {
+				continue
+			}
+			witness := original
+			op, operands, found := strings.Cut(witness.Instruction, " ")
+			if !found || len(witness.Encoding) != 7 || witness.Encoding[0] != 0x62 || witness.Encoding[3]&0x80 != 0 {
+				t.Fatal("original masked store is not the expected EVEX source row", row)
+			}
+			witness.Instruction, witness.Zeroing = op+".Z "+operands, true
+			witness.Encoding = append([]byte(nil), original.Encoding...)
+			witness.Encoding[3] |= 0x80
+			name := fmt.Sprint("ExtractUndefined", len(cases))
+			line := strings.Count(source.String(), "\n") + 2
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s\nRET\n", name, frame, witness.Instruction)
+			fmt.Fprintf(&declarations, "func %s()%s\n", name, returns)
+			cases = append(cases, x86OfficialPackedCase{row: row.ID + "/memory-Z", symbol: name, line: line, witness: witness})
+		}
+	}
+	if len(cases) != 12 {
+		t.Fatal("all eight block members and twelve width rows must retain memory-Z observations", len(cases))
+	}
+	return source.String(), declarations.String(), cases
+}
+
+func TestX86OfficialInsertExtractMemoryZeroingTerminalObjects(t *testing.T) {
+	source, declarations, cases := x86OfficialInsertExtractTerminalSource(t, false)
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("stock Go did not emit the original reserved EVEX.z memory bytes", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			const triple = "x86_64-unknown-linux-gnu"
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("Go-encoded architectural #UD must terminate before reading K/vector/address inputs", api, err)
+			}
+			x86OfficialMoveInspectFaults(t, ir, cases)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, ir, level)
+			}
+			for _, foreign := range []string{"aarch64-unknown-linux-gnu", "wasm32-wasi"} {
+				translated, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", foreign, api)
+				if err == nil || translated != "" {
+					t.Fatal("x86 architectural UD2 acquired a foreign backend", foreign, api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86OfficialInsertExtractMemoryZeroingTerminatesLogicalResults(t *testing.T) {
+	source, declarations, cases := x86OfficialInsertExtractTerminalSource(t, true)
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal("logical result signature changed the original terminal instruction bytes", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			const triple = "x86_64-unknown-linux-gnu"
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("terminal #UD cannot require a numerical value for an unreachable return", api, err)
+			}
+			x86OfficialMoveInspectFaults(t, ir, cases)
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, ir, level)
+			}
+		})
+	}
+}
+
+func TestX86InsertExtractMemoryZeroingCannotAuthorizePrefixMemory(t *testing.T) {
+	for _, result := range []bool{false, true} {
+		source, declarations, _ := x86OfficialInsertExtractTerminalSource(t, result)
+		frame := "$0-0\n"
+		if result {
+			frame = "$0-8\n"
+		}
+		for _, prefix := range []struct{ name, source string }{
+			{"read", "MOVQ (AX),CX\n"},
+			{"known-data-store", "MOVQ $1,CX\nMOVQ CX,(AX)\n"},
+		} {
+			candidate := strings.ReplaceAll(source, frame, frame+prefix.source)
+			goAssemblerOracleOutput(t, "amd64", candidate, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("result=%t/%s/%s", result, prefix.name, api), func(t *testing.T) {
+					text, err := x86ScalarFPBitViewAPI(t, candidate, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err == nil || text != "" {
+						t.Fatal("a later terminal instruction granted an earlier unproved memory address", api, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OfficialInsertExtractMode32SourceArityBoundary(t *testing.T) {
+	low := strings.NewReplacer("X16", "X0", "Y16", "Y0", "Z16", "Z0", "X17", "X1", "Y17", "Y1", "Z17", "Z1", "X18", "X2", "Y18", "Y2", "Z18", "Z2")
+	accepted, rejected := 0, 0
+	for _, row := range x86OfficialInsertExtractBoundaryRows(t) {
+		instruction := low.Replace(row.Witnesses[0].Instruction)
+		_, operands, _ := strings.Cut(instruction, " ")
+		want := len(strings.Split(operands, ",")) <= 3
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", "", want)
+		if want {
+			accepted++
+		} else {
+			rejected++
+		}
+	}
+	if accepted != 34 || rejected != 48 {
+		t.Fatal("complete named386 source arity partition changed", accepted, rejected)
+	}
+	t.Log("82 original row projections: 34 low-bank syntax acceptances and 48 concrete frontend arity rejections; not 82 selected encodings or numerical passes")
+}
+
+func TestX86InsertExtractMemoryZeroingHasNoOrdinaryContinuation(t *testing.T) {
+	count := 0
+	for _, row := range x86OfficialInsertExtractBoundaryRows(t) {
+		for _, witness := range row.Witnesses {
+			if !witness.Masked || witness.Zeroing || witness.Destination != "(AX)" {
+				continue
+			}
+			op, operands, _ := strings.Cut(witness.Instruction, " ")
+			ins := x86ScalarLaneInstruction(t, op+".Z "+operands)
+			form, known, err := x86InsertExtractProperties(ins, "amd64")
+			if !known || err != nil || !form.undefinedOpcode() {
+				t.Fatal("original memory-Z form lost its terminal classification", ins, err)
+			}
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.pointerGP[0] = true
+			for i := range state.masks {
+				state.masks[i] = true
+			}
+			for i := 0; i < 32; i++ {
+				state.writeVector(i, 64, ^uint64(0), false)
+			}
+			before := state.clone()
+			if x86ResultBlockTransferWithNativeMemory(ins, form, &state, nil, 0, "amd64", true) ||
+				!reflect.DeepEqual(state, before) {
+				t.Fatal("terminal instruction acquired ordinary native-store or numerical effects", ins)
+			}
+			for _, identity := range []Op{ins.Op, "", "VINSERTF32X4.Z", "UNDEF"} {
+				local := ins
+				local.Op = identity
+				_, trap, err := x86UndefinedTrapProperties(ins.Op, local, "amd64")
+				if (trap && err == nil) != (identity == ins.Op || identity == "") {
+					t.Fatal("terminal dispatch borrowed a different source opcode", ins.Op, identity, err)
+				}
+			}
+			count++
+		}
+	}
+	if count != 12 {
+		t.Fatal("memory-Z continuation controls lost an original width row", count)
+	}
+}
diff --git a/x86_official_insert_extract_rows_test.go b/x86_official_insert_extract_rows_test.go
new file mode 100644
index 000000000..51ff9a7aa
--- /dev/null
+++ b/x86_official_insert_extract_rows_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// This preflight proves observable initialized producers, not per-row encoding
+// ownership. The independent official-row driver must later bind each actual
+// selected source row, including the alternate VPEXTRW shadow observations.
+func TestX86OfficialInsertExtractExistingObservableProducer(t *testing.T) {
+	var instructions []string
+	for _, kind := range []string{"F", "I"} {
+		instructions = append(instructions,
+			"VEXTRACT"+kind+"128 $255,Y0,X2",
+			"VINSERT"+kind+"128 $7,X0,Y1,Y2")
+		for _, chunk := range []struct{ name, register string }{
+			{"32X4", "X"}, {"64X2", "X"}, {"32X8", "Y"}, {"64X4", "Y"},
+		} {
+			instructions = append(instructions,
+				"VEXTRACT"+kind+chunk.name+" $255,Z16,"+chunk.register+"18",
+				"VINSERT"+kind+chunk.name+" $7,"+chunk.register+"16,Z17,Z18")
+		}
+	}
+	instructions = append(instructions, "VEXTRACTPS $255,X16,CX", "VINSERTPS $7,X16,X17,X18")
+	for _, suffix := range []string{"B", "W", "D", "Q"} {
+		instructions = append(instructions, "VPEXTR"+suffix+" $255,X16,CX", "VPINSR"+suffix+" $7,CX,X17,X18")
+	}
+	if len(instructions) != 30 {
+		t.Fatal("complete observable mnemonic producer changed", len(instructions))
+	}
+	var source, declarations strings.Builder
+	for index, instruction := range instructions {
+		name := fmt.Sprint("InsertExtract", index)
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b *[64]byte,value uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ value+24(FP),CX\n", name)
+		low := strings.Contains(instruction, "128 ")
+		if low {
+			source.WriteString("VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\n")
+		} else {
+			source.WriteString("VMOVUPS (AX),Z16\nVMOVUPS (BX),Z17\n")
+		}
+		fmt.Fprintf(&source, "STC\n%s\n", instruction)
+		if strings.HasSuffix(instruction, ",CX") {
+			source.WriteString("MOVQ CX,0(DX)\n")
+		} else if low {
+			source.WriteString("VMOVUPS Z2,0(DX)\n")
+		} else {
+			source.WriteString("VMOVUPS Z18,0(DX)\n")
+		}
+		source.WriteString("SETCS 72(DX)\nRET\n")
+	}
+	const triple = "x86_64-unknown-linux-gnu"
+	x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("real data inputs and observable vector/GP results", api, err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, ir, level)
+			}
+		})
+	}
+}
+
+func x86OfficialInsertExtractShadowTarget(row goasmrules.X86PackedBinaryRow) string {
+	if row.Opcode != "VPEXTRW" {
+		return ""
+	}
+	for _, pair := range [][2]string{{"/2", "/0"}, {"/3", "/1"}, {"/5", "/4"}} {
+		if strings.HasSuffix(row.ID, pair[0]) {
+			// The source row's global ordinal also differs, so locate the
+			// complete earlier row by opcode/table/local ordinal below.
+			return "/VPEXTRW/_yvpextrw" + pair[1]
+		}
+	}
+	return ""
+}
+
+// The canonical bytes name AX for either direction. All pointer-dependent
+// inputs are initialized before an extract redirects AX to the output array.
+func x86OfficialInsertExtractAssembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declarations strings.Builder
+	vectorSeed := func(register string) string {
+		return "Z" + register[1:]
+	}
+	for index := range cases {
+		fixture := &cases[index]
+		w := fixture.witness
+		fixture.symbol = fmt.Sprint("TransferRow", index)
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b *[64]byte,mask uint64)\n", fixture.symbol)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\n", fixture.symbol)
+		if w.First != "(AX)" && w.First != "CX" {
+			fmt.Fprintf(&source, "VMOVUPS (AX),%s\n", vectorSeed(w.First))
+		}
+		if w.Second != "" {
+			fmt.Fprintf(&source, "VMOVUPS (BX),%s\n", vectorSeed(w.Second))
+		}
+		if w.Masked {
+			source.WriteString("MOVQ mask+24(FP),R9\nKMOVQ R9,K1\n")
+			if !w.Zeroing && w.Destination != "(AX)" {
+				fmt.Fprintf(&source, "VMOVUPS (BX),%s\n", vectorSeed(w.Destination))
+			}
+		}
+		if w.First == "CX" {
+			source.WriteString("MOVQ (AX),CX\n")
+		}
+		if w.Destination == "(AX)" {
+			source.WriteString("MOVQ DX,AX\n")
+		}
+		source.WriteString("STC\n")
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, w.Instruction)
+		if w.Destination == "CX" {
+			source.WriteString("MOVQ CX,0(DX)\n")
+		} else if w.Destination != "(AX)" {
+			fmt.Fprintf(&source, "VMOVUPS %s,0(DX)\n", vectorSeed(w.Destination))
+		}
+		source.WriteString("SETCS 72(DX)\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialInsertExtractSelectedRowsThreeAPIObjects(t *testing.T) {
+	selected := func(legacy goasmrules.X86LegacyCatalog, avx []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+		rows, err := goasmrules.X86InsertExtractRows(legacy, avx)
+		if err != nil {
+			return nil, err
+		}
+		if len(rows) != 82 {
+			return nil, fmt.Errorf("complete physical source rows changed: %d", len(rows))
+		}
+		var ordinary []goasmrules.X86PackedBinaryRow
+		for _, row := range rows {
+			if x86OfficialInsertExtractShadowTarget(row) == "" {
+				ordinary = append(ordinary, row)
+			}
+		}
+		return ordinary, nil
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86OfficialPackedRowsObjectsInspect(t, selected, 79, 194, 0, x86OfficialInsertExtractAssembly,
+		func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86OfficialInsertExtractNamedShadowsRetainOriginalBytes(t *testing.T) {
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86InsertExtractRows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, row := range rows {
+		target := x86OfficialInsertExtractShadowTarget(row)
+		if target == "" {
+			continue
+		}
+		if len(row.Witnesses) != 1 {
+			t.Fatal("alternate GP-only physical row changed", row)
+		}
+		shadow := row.Witnesses[0]
+		var earlier *goasmrules.X86PackedBinaryWitness
+		for _, candidate := range rows {
+			if !strings.HasSuffix(candidate.ID, target) {
+				continue
+			}
+			for index := range candidate.Witnesses {
+				if candidate.Witnesses[index].Instruction == shadow.Instruction {
+					earlier = &candidate.Witnesses[index]
+				}
+			}
+		}
+		if earlier == nil || bytes.Equal(earlier.Encoding, shadow.Encoding) {
+			t.Fatal("shadow lacks its distinct original earlier-row bytes", row.ID)
+		}
+		fixture := []x86OfficialPackedCase{{row: row.ID, witness: shadow}}
+		source, _ := x86OfficialInsertExtractAssembly(fixture)
+		listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		observed := fixture[0]
+		observed.witness = *earlier
+		if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{observed}); err != nil {
+			t.Fatal("actual Go no longer selects the original earlier row", row.ID, err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, fixture); err == nil {
+			t.Fatal("shadowed alternate encoding was falsely counted as named Go bytes", row.ID)
+		}
+		count++
+	}
+	if count != 3 {
+		t.Fatal("complete alternate-encoding shadow observations changed", count)
+	}
+}
diff --git a/x86_official_integer_test_mask_rows_test.go b/x86_official_integer_test_mask_rows_test.go
new file mode 100644
index 000000000..6874e812f
--- /dev/null
+++ b/x86_official_integer_test_mask_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialIntegerTestMaskRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86IntegerTestMaskRows, 48, 240, 0)
+}
diff --git a/x86_official_k_data_rows_test.go b/x86_official_k_data_rows_test.go
new file mode 100644
index 000000000..f1f351ff1
--- /dev/null
+++ b/x86_official_k_data_rows_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Compose the existing mask-value, FLAGS and vector transports without a
+// per-opcode initializer. The byte witnesses supply syntax, never input facts.
+func x86OfficialKDataAssembly(arch string, cases []x86OfficialPackedCase) (string, string) {
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	var source, declarations strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		w := fixture.witness
+		fixture.symbol = fmt.Sprint("KData", index)
+		fmt.Fprintf(&declarations, "func %s(out,a,b *byte)\n", fixture.symbol)
+		prefix := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DX\n%s a+%d(FP),AX\n%s b+%d(FP),BX\n",
+			fixture.symbol, 3*word, move, move, word, move, 2*word)
+		gpSeed := ""
+		for input, register := range []string{w.First, w.Second} {
+			if register == "" || strings.Contains(register, "(") {
+				continue
+			}
+			pointer := []string{"AX", "BX"}[input]
+			if _, mask := amd64ParseKReg(Reg(register)); mask {
+				prefix += fmt.Sprintf("KMOVQ (%s),%s\n", pointer, register)
+			} else if isX86YrlRegisterForArch(Reg(register), arch) {
+				gpSeed += fmt.Sprintf("%s (%s),%s\n", move, pointer, register)
+			} else {
+				prefix += fmt.Sprintf("VMOVUPS (%s),%s\n", pointer, register)
+			}
+		}
+		// GP input may replace AX only after every pointer-dependent input.
+		prefix += gpSeed
+		fixture.line = line + strings.Count(prefix, "\n")
+		body := prefix + w.Instruction + "\n"
+		switch {
+		case w.Destination == "":
+			suffix := "Q"
+			if arch == "386" {
+				suffix = "L"
+			}
+			body += fmt.Sprintf("PUSHF%s\nPOP%s CX\nAND%s $0x8d5,CX\n%s CX,(DX)\n", suffix, suffix, suffix, move)
+		case w.MaskResult:
+			body += fmt.Sprintf("KMOVQ %s,(DX)\n", w.Destination)
+		case w.Width != 0:
+			// EVEX writes clear the complete wider alias, not only its low carrier.
+			body += fmt.Sprintf("VMOVUPS Z%s,(DX)\n", w.Destination[1:])
+		case !strings.Contains(w.Destination, "("):
+			body += fmt.Sprintf("%s %s,(DX)\n", move, w.Destination)
+		}
+		body += "RET\n"
+		source.WriteString(body)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialKDataRowsInitializedThreeAPIsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			x86OfficialPackedRowsObjectsForTarget(t, arch, triple, goasmrules.X86KDataRows, 87, 91, 0,
+				func(cases []x86OfficialPackedCase) (string, string) { return x86OfficialKDataAssembly(arch, cases) },
+				func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+					x86PackedStringCompileObject(t, llc, triple, ir, "-O2")
+				})
+		})
+	}
+}
diff --git a/x86_official_leading_immediate_vector_rows_test.go b/x86_official_leading_immediate_vector_rows_test.go
new file mode 100644
index 000000000..b4afbcbcb
--- /dev/null
+++ b/x86_official_leading_immediate_vector_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialLeadingImmediateVectorRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86LeadingImmediateVectorRows, 66, 270, 0, x86OfficialFMA3Assembly)
+}
diff --git a/x86_official_legacy127_source_test.go b/x86_official_legacy127_source_test.go
new file mode 100644
index 000000000..1853719e1
--- /dev/null
+++ b/x86_official_legacy127_source_test.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86Legacy127OriginalCase struct {
+	ID, Instruction string
+	AMD64Only       bool
+}
+
+// This first oracle is independent of the candidate formatter and lowerer.
+// Syntax roles come from the complete original Ytab/class group. It records
+// source acceptance/refusal, not initialized translation or execution.
+func x86Legacy127OriginalCases(t *testing.T) []x86Legacy127OriginalCase {
+	t.Helper()
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cases []x86Legacy127OriginalCase
+	counts := map[string]int{}
+	for _, entry := range catalog.Optab {
+		for _, row := range entry.Rows {
+			args, amd64Only := "", false
+			switch entry.Ytab {
+			case "ymm":
+				if row.RowIndex == 0 {
+					args, amd64Only = "M0,M1", true
+				}
+			case "yps":
+				if row.RowIndex == 0 {
+					args, amd64Only = "M0,M1", true
+				} else if row.RowIndex == 1 {
+					args, amd64Only = "$-1,M1", true
+				}
+			case "yxmov":
+				if row.RowIndex == 0 {
+					args = "(AX),X1"
+				} else {
+					args = "X1,(AX)"
+				}
+			case "yxm":
+				if strings.Contains(" ADDSUBPD ADDSUBPS COMISD COMISS CVTPD2PS CVTPS2PD CVTSD2SS CVTSS2SD HADDPD HADDPS HSUBPD HSUBPS PSADBW RCPPS RCPSS RSQRTPS RSQRTSS SQRTPD SQRTPS SQRTSD SQRTSS UCOMISD UCOMISS ", " "+entry.Opcode+" ") {
+					args = "X0,X1"
+				}
+			case "ycmpl":
+				args = []string{"BX,$1", "AX,$128", "0(SI),$128", "0(SI),BX", "BX,0(SI)"}[row.RowIndex]
+				amd64Only = entry.Prefix == "Pw"
+			case "ycmpb":
+				args = []string{"AL,$128", "0(SI),$128", "0(SI),BL", "BL,0(SI)"}[row.RowIndex]
+			case "ytestl":
+				args = []string{"$128,AX", "$128,0(SI)", "CX,BX", "0(SI),BX"}[row.RowIndex]
+				amd64Only = entry.Prefix == "Pw"
+			}
+			if args == "" {
+				continue
+			}
+			counts[entry.Ytab]++
+			cases = append(cases, x86Legacy127OriginalCase{
+				ID:          fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex),
+				Instruction: entry.Opcode + " " + args, AMD64Only: amd64Only,
+			})
+		}
+	}
+	if len(cases) != 127 || fmt.Sprint(counts) != "map[ycmpb:4 ycmpl:15 ymm:33 yps:16 ytestl:12 yxm:23 yxmov:24]" {
+		t.Fatal("original source format denominator changed", len(cases), counts)
+	}
+	return cases
+}
+
+func x86Legacy127OriginalListing(t *testing.T, arch, source string, wantSuccess bool) string {
+	t.Helper()
+	dir := t.TempDir()
+	asm, object := filepath.Join(dir, "legacy127.s"), filepath.Join(dir, "legacy127.o")
+	if err := os.WriteFile(asm, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	// -e preserves every source-bound refusal in a whole-function batch.
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"),
+		"tool", "asm", "-e", "-S", "-p", "literal", "-o", object, asm)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(asm, object, output, err, ctx.Err(), wantSuccess, arch); failure != nil {
+		t.Fatalf("%v\n%s", failure, output)
+	}
+	if wantSuccess {
+		data, err := os.ReadFile(object)
+		if err != nil || len(data) == 0 {
+			t.Fatal("original Go object missing", err)
+		}
+		t.Logf("ACTUAL_LEGACY127_SOURCE arch=%s sourceSHA=%x objectSHA=%x bytes=%d listingSHA=%x", arch,
+			sha256.Sum256([]byte(source)), sha256.Sum256(data), len(data), sha256.Sum256(output))
+	}
+	return string(output)
+}
+
+func TestX86Legacy127OriginalGoSourceModes(t *testing.T) {
+	cases := x86Legacy127OriginalCases(t)
+	for _, arch := range []string{"amd64", "386"} {
+		for _, accepted := range []bool{true, false} {
+			var selected []x86Legacy127OriginalCase
+			for _, item := range cases {
+				if (arch != "386" || !item.AMD64Only) == accepted {
+					selected = append(selected, item)
+				}
+			}
+			if len(selected) == 0 {
+				continue
+			}
+			for start := 0; start < len(selected); start += 32 {
+				end := start + 32
+				if end > len(selected) {
+					end = len(selected)
+				}
+				t.Run(fmt.Sprintf("%s/accepted=%t/batch%d", arch, accepted, start/32), func(t *testing.T) {
+					var source strings.Builder
+					batch := selected[start:end]
+					for i, item := range batch {
+						fmt.Fprintf(&source, "TEXT ·Legacy127_%d(SB),4,$0-0\n%s\nRET\n", i, item.Instruction)
+					}
+					listing := x86Legacy127OriginalListing(t, arch, source.String(), accepted)
+					for i, item := range batch {
+						if accepted {
+							if !strings.Contains(listing, fmt.Sprintf("Legacy127_%d STEXT", i)) {
+								t.Fatal("accepted batch lost an original function", item.ID)
+							}
+						} else {
+							found := false
+							for _, diagnostic := range strings.Split(listing, "\n") {
+								if strings.Contains(diagnostic, fmt.Sprintf("legacy127.s:%d", 3*i+2)) &&
+									strings.Contains(diagnostic, strings.Fields(item.Instruction)[0]) {
+									found = true
+								}
+							}
+							if !found {
+								t.Fatalf("missing original source-bound mode refusal %s: %s\n%s", item.ID, item.Instruction, listing)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+	if path := os.Getenv("PLAN9ASM_LEGACY127_ORIGINAL_OUTPUT"); path != "" {
+		data, err := json.MarshalIndent(cases, "", "  ")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/x86_official_legacy_cmov_rows_test.go b/x86_official_legacy_cmov_rows_test.go
new file mode 100644
index 000000000..da6bd13a3
--- /dev/null
+++ b/x86_official_legacy_cmov_rows_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialConditionalMoveRowsOriginalBytesAndObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct {
+		arch, triple string
+		count        int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 96},
+		{"386", "i386-unknown-linux-gnu", 64},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			rows, err := goasmrules.X86ConditionalMoveRows(catalog, mode.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var cases []x86OfficialPackedCase
+			for _, row := range rows {
+				if row.ModeFiltered != "" {
+					continue
+				}
+				for _, witness := range row.Witnesses {
+					cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+				}
+			}
+			if len(rows) != 48 || len(cases) != mode.count {
+				t.Fatal("complete conditional row/mode union changed", len(rows), len(cases))
+			}
+			for start := 0; start < len(cases); start += 32 {
+				end := start + 32
+				if end > len(cases) {
+					end = len(cases)
+				}
+				t.Run(fmt.Sprint("batch", start/32), func(t *testing.T) {
+					batch := cases[start:end]
+					var source, declarations strings.Builder
+					for index := range batch {
+						fixture := &batch[index]
+						fixture.symbol = fmt.Sprint("ConditionalOfficial", index)
+						body, declaration := x86ConditionalMoveInitializedFunction(fixture.symbol, fixture.witness.Instruction, "BX", mode.arch)
+						position := strings.Index(body, "\n"+fixture.witness.Instruction+"\n")
+						if position < 0 {
+							t.Fatal("original CMOV producer lost the exact observed instruction")
+						}
+						fixture.line = strings.Count(source.String(), "\n") + strings.Count(body[:position+1], "\n") + 1
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+					listing, err := x86ScalarLiteralGoListing(t, mode.arch, source.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+						t.Fatal("actual original conditional-move row byte identity", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), mode.arch, mode.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized source/old/FLAGS and observable data+preserved status rejected", api, err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, mode.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86OfficialConditionalMoveMode32Refusals(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86ConditionalMoveRows(catalog, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	refused := 0
+	for _, row := range rows {
+		if row.ModeFiltered == "" {
+			continue
+		}
+		refused++
+		for _, source := range []string{"CX", "0(SI)"} {
+			t.Run(row.Opcode+"/"+source, func(t *testing.T) {
+				assembly := "TEXT RefusedConditional(SB),4,$0-0\n" + row.Opcode + " " + source + ",BX\nRET\n"
+				goAssemblerOracleOutput(t, "386", assembly, "", false)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly, "func RefusedConditional()", "386", "i386-unknown-linux-gnu", api)
+					if ir != "" || err == nil {
+						t.Fatal("actual Go mode refusal acquired public translation", api, err)
+					}
+					if errors.Is(err, ErrProbeNeedsContext) {
+						t.Log("mode/source context refusal retained separately from byte/object evidence")
+					}
+				}
+			})
+		}
+	}
+	if refused != 16 {
+		t.Fatal("complete Q-width mode32 source refusal inventory changed", refused)
+	}
+}
diff --git a/x86_official_legacy_condition_rows_test.go b/x86_official_legacy_condition_rows_test.go
new file mode 100644
index 000000000..7ed69f634
--- /dev/null
+++ b/x86_official_legacy_condition_rows_test.go
@@ -0,0 +1,424 @@
+package plan9asm
+
+// These initialized source and original-byte owners keep object coverage
+// distinct from execution. No instruction grants its own numerical inputs,
+// destination backing, FLAGS or physical-stack permission.
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialConditionalInitializedProducerObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "Q", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "L", "i386-unknown-linux-gnu"
+		}
+		var source, declarations strings.Builder
+		count, branches, sets := 0, 0, 0
+		flush := func() {
+			if source.Len() == 0 {
+				return
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized real data/FLAGS/closed-CFG producer", arch, api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			}
+			source.Reset()
+			declarations.Reset()
+		}
+		for _, entry := range catalog.Optab {
+			if entry.Ytab == "yjcond" {
+				if entry.Prefix != "Px" || len(entry.Rows) != 3 {
+					t.Fatal("complete Jcc source schema changed", entry)
+				}
+				for _, row := range entry.Rows {
+					classes := strings.Join(row.Classes, ",")
+					hint := ""
+					switch classes {
+					case "Ybr":
+					case "Yi0,Ybr":
+						hint = "$0,"
+					case "Yi1,Ybr":
+						hint = "$1,"
+					default:
+						t.Fatal("unknown Jcc hint class", row)
+					}
+					name := fmt.Sprintf("Condition%d", count)
+					fmt.Fprintf(&declarations, "func %s(a,b,no,yes uintptr) uintptr\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s a+0(FP),AX\nMOV%s b+%d(FP),BX\nMOV%s no+%d(FP),DX\nMOV%s yes+%d(FP),CX\nCMP%s AX,BX\n%s %staken\nMOV%s DX,CX\ntaken:\nMOV%s CX,ret+%d(FP)\nRET\n",
+						name, word*5, move, move, word, move, word*2, move, word*3, move, entry.Opcode, hint, move, move, word*4)
+					count++
+					branches++
+					if count%32 == 0 {
+						flush()
+					}
+				}
+			} else if entry.Ytab == "yscond" && strings.HasPrefix(entry.Opcode, "SET") {
+				if entry.Prefix != "Pb" || len(entry.Rows) != 1 {
+					t.Fatal("complete SETcc source schema changed", entry)
+				}
+				// Full physical old word is real input. SET itself needs no
+				// old byte; the complete returned word observes preservation.
+				for _, destination := range []string{"AX", "AH", "0(SI)"} {
+					name := fmt.Sprintf("Condition%d", count)
+					if destination == "0(SI)" {
+						fmt.Fprintf(&declarations, "func %s(out *[1]byte,a,b uintptr)\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),SI\nMOV%s a+%d(FP),BX\nMOV%s b+%d(FP),CX\nCMP%s BX,CX\n%s 0(SI)\nRET\n",
+							name, word*3, move, move, word, move, word*2, move, entry.Opcode)
+					} else {
+						fmt.Fprintf(&declarations, "func %s(a,b,old uintptr) uintptr\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s old+%d(FP),AX\nMOV%s a+0(FP),BX\nMOV%s b+%d(FP),CX\nCMP%s BX,CX\n%s %s\nMOV%s AX,ret+%d(FP)\nRET\n",
+							name, word*4, move, word*2, move, move, word, move, entry.Opcode, destination, move, word*3)
+					}
+					count++
+					sets++
+					if count%32 == 0 {
+						flush()
+					}
+				}
+			}
+		}
+		flush()
+		if branches != 48 || sets != 48 || count != 96 {
+			t.Fatal("complete source/producer projection changed", arch, branches, sets, count)
+		}
+	}
+}
+
+func TestX86OfficialConditionalBranchRelaxationBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, registerBytes, storeBytes := 8, "Q", 3, 5
+		if arch == "386" {
+			word, move, registerBytes, storeBytes = 4, "L", 2, 4
+		}
+		var source strings.Builder
+		var cases []x86OfficialPackedCase
+		for _, backward := range []bool{false, true} {
+			for _, outside := range []bool{false, true} {
+				name := fmt.Sprintf("Boundary%d", len(cases))
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s a+0(FP),AX\nMOV%s b+%d(FP),BX\nMOV%s no+%d(FP),DX\nMOV%s yes+%d(FP),CX\n", name, word*5, move, move, word, move, word*2, move, word*3)
+				padding := 127 - registerBytes
+				displacement := 127
+				if backward {
+					// The taken block returns directly: no intervening JMP can
+					// itself relax and change this independent boundary anchor.
+					padding = 128 - (storeBytes + 1 + registerBytes + 2)
+					fmt.Fprintf(&source, "JMP check\ntaken:\nMOV%s CX,ret+%d(FP)\nRET\n", move, word*4)
+					displacement = -128
+				}
+				if outside {
+					padding++
+					displacement++
+					if backward {
+						displacement = -133
+					}
+				}
+				if backward {
+					source.WriteString(strings.Repeat("XCHGL AX,AX\n", padding) + "check:\n")
+				}
+				fmt.Fprintf(&source, "CMP%s AX,BX\n", move)
+				line := strings.Count(source.String(), "\n") + 1
+				source.WriteString("JNE taken\n")
+				if backward {
+					fmt.Fprintf(&source, "MOV%s DX,ret+%d(FP)\nRET\n", move, word*4)
+				} else {
+					fmt.Fprintf(&source, "%sMOV%s DX,CX\ntaken:\nMOV%s CX,ret+%d(FP)\nRET\n", strings.Repeat("XCHGL AX,AX\n", padding), move, move, word*4)
+				}
+				code := []byte{0x75, byte(displacement)}
+				if outside {
+					code = []byte{0x0f, 0x85}
+					for b := 0; b < 4; b++ {
+						code = append(code, byte(uint32(displacement)>>uint(b*8)))
+					}
+				}
+				cases = append(cases, x86OfficialPackedCase{row: fmt.Sprintf("independent/relax/back=%t/outside=%t", backward, outside), symbol: name, line: line,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: "JNE taken", Encoding: code}})
+			}
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("original rel8 endpoint/rel32 relaxation", arch, err)
+		}
+	}
+}
+
+type x86OfficialConditionCase struct {
+	row, opcode string
+	branch      bool
+	witness     goasmrules.X86ConditionWitness
+}
+
+func x86OfficialConditionCases(catalog goasmrules.X86LegacyCatalog, arch string) ([]x86OfficialConditionCase, error) {
+	rows, err := goasmrules.X86ConditionalRows(catalog, arch)
+	if err != nil {
+		return nil, err
+	}
+	var cases []x86OfficialConditionCase
+	for _, row := range rows {
+		for _, w := range row.Witnesses {
+			cases = append(cases, x86OfficialConditionCase{row.ID, row.Opcode, row.Branch, w})
+		}
+	}
+	aliases := x86ConditionalBranchAliasOracle()
+	names := make([]string, 0, len(aliases))
+	for alias, canonical := range aliases {
+		if alias != canonical {
+			names = append(names, alias)
+		}
+	}
+	sort.Strings(names)
+	for _, alias := range names {
+		for _, row := range rows {
+			if row.Opcode != aliases[alias] {
+				continue
+			}
+			for _, w := range row.Witnesses {
+				if w.Layout != "short-forward" {
+					continue
+				}
+				w.Instruction = alias + strings.TrimPrefix(w.Instruction, row.Opcode)
+				cases = append(cases, x86OfficialConditionCase{"alias/" + alias + "/" + row.ID, row.Opcode, true, w})
+			}
+		}
+	}
+	for _, row := range rows {
+		if row.Branch {
+			continue
+		}
+		w := row.Witnesses[0]
+		w.Instruction, w.Layout = row.Opcode+" AL", "AL"
+		cases = append(cases, x86OfficialConditionCase{"alias/AL/" + row.ID, row.Opcode, false, w})
+	}
+	if len(rows) != 64 || len(cases) != 343 || len(names) != 29 {
+		return nil, fmt.Errorf("condition source/canonical/alias closure changed: %d/%d/%d", len(rows), len(cases), len(names))
+	}
+	return cases, nil
+}
+
+func TestX86OfficialConditionalSetOriginalGoByteAliasPaths(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86ConditionalRows(catalog, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		var cases []x86OfficialPackedCase
+		for _, row := range rows {
+			if row.Branch {
+				continue
+			}
+			for index, alias := range []string{"BP", "SI", "DI"} {
+				code := append([]byte(nil), row.Witnesses[0].Encoding...)
+				if arch == "amd64" {
+					code[2] = 0xc5 + byte(index)
+					code = append([]byte{0x40}, code...)
+				} else {
+					// Go's Pb fallback picks BX for the empty SET source:
+					// exchange, reissue the exact byte SET, exchange back.
+					code[2] = 0xc3
+					exchange := []byte{0x87, 0xdd + byte(index)}
+					code = append(append(append([]byte(nil), exchange...), code...), exchange...)
+				}
+				name := fmt.Sprintf("SetAlias%d", len(cases))
+				instruction := row.Opcode + " " + alias
+				line := strings.Count(source.String(), "\n") + 2
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, instruction)
+				cases = append(cases, x86OfficialPackedCase{row: row.ID + "/" + alias, symbol: name, line: line,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: code}})
+			}
+		}
+		if len(cases) != 48 {
+			t.Fatal("complete SETcc byte-alias source paths changed", len(cases))
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("Go byte alias/synthesized sequence identity", arch, err)
+		}
+		t.Logf("%s:48 original SETcc alias statements; byte/sequence observation only, no NUM/FLAGS/frame/native continuation grant", arch)
+	}
+}
+
+func TestX86OfficialConditionalObservableInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "L", 4, "i386-unknown-linux-gnu"
+		}
+		for _, opcode := range []string{"JEQ", "SETNE"} {
+			fixture := x86OfficialConditionCase{row: "independent/input-boundary", opcode: opcode, branch: opcode == "JEQ",
+				witness: goasmrules.X86ConditionWitness{Instruction: opcode + " AH", Layout: "AH"}}
+			if fixture.branch {
+				fixture.witness.Instruction, fixture.witness.Layout = "JEQ taken", "short-forward"
+			}
+			base, decl, _ := x86OfficialConditionAssembly([]x86OfficialConditionCase{fixture}, arch)
+			controls := []struct{ name, remove string }{{"complete", ""}}
+			if fixture.branch {
+				controls = append(controls, struct{ name, remove string }{"unknown-flags", "CMP" + move + " AX,BX\n"},
+					struct{ name, remove string }{"unknown-compare", fmt.Sprintf("MOV%s b+%d(FP),BX\n", move, word)},
+					struct{ name, remove string }{"unknown-yes", fmt.Sprintf("MOV%s yes+%d(FP),CX\n", move, word*3)},
+					struct{ name, remove string }{"unknown-no", fmt.Sprintf("MOV%s no+%d(FP),DX\n", move, word*2)})
+			} else {
+				controls = append(controls, struct{ name, remove string }{"unknown-flags", "CMP" + move + " BX,CX\n"},
+					struct{ name, remove string }{"unknown-compare", fmt.Sprintf("MOV%s b+%d(FP),CX\n", move, word)},
+					struct{ name, remove string }{"unknown-old-upper", fmt.Sprintf("MOV%s old+%d(FP),AX\n", move, word*2)})
+			}
+			for _, control := range controls {
+				t.Run(arch+"/"+opcode+"/"+control.name, func(t *testing.T) {
+					source := base
+					if control.remove != "" {
+						if strings.Count(source, control.remove) != 1 {
+							t.Fatal("mutation is not uniquely bound")
+						}
+						source = strings.Replace(source, control.remove, "", 1)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, decl, arch, triple, api)
+						if control.remove == "" && (err != nil || ir == "") || control.remove != "" && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+							t.Fatal("real input/FLAGS/preserved-byte obligation changed", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86OfficialConditionAssembly(cases []x86OfficialConditionCase, arch string) (string, string, []x86OfficialPackedCase) {
+	word, move := 8, "Q"
+	if arch == "386" {
+		word, move = 4, "L"
+	}
+	var source, declarations strings.Builder
+	var observed []x86OfficialPackedCase
+	for index, fixture := range cases {
+		w := fixture.witness
+		name := fmt.Sprintf("ConditionRow%d", index)
+		line := 0
+		if fixture.branch {
+			fmt.Fprintf(&declarations, "func %s(a,b,no,yes uintptr) uintptr\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s a+0(FP),AX\nMOV%s b+%d(FP),BX\nMOV%s no+%d(FP),DX\nMOV%s yes+%d(FP),CX\n", name, word*5, move, move, word, move, word*2, move, word*3)
+			backward := strings.HasSuffix(w.Layout, "backward")
+			padding := ""
+			if strings.HasPrefix(w.Layout, "near") {
+				padding = strings.Repeat("XCHGL AX,AX\n", 128)
+			}
+			result := "CX"
+			if backward {
+				fmt.Fprintf(&source, "JMP check\ntaken:\nMOV%s CX,DX\nJMP done\n%scheck:\n", move, padding)
+				result = "DX"
+			}
+			fmt.Fprintf(&source, "CMP%s AX,BX\n", move)
+			line = strings.Count(source.String(), "\n") + 1
+			fmt.Fprintln(&source, w.Instruction)
+			if !backward {
+				fmt.Fprintf(&source, "%sMOV%s DX,CX\ntaken:\n", padding, move)
+			} else {
+				source.WriteString("done:\n")
+			}
+			fmt.Fprintf(&source, "MOV%s %s,ret+%d(FP)\nRET\n", move, result, word*4)
+		} else {
+			memory := w.Layout == "0(SI)"
+			if memory {
+				fmt.Fprintf(&declarations, "func %s(out *[1]byte,a,b uintptr)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),SI\nMOV%s a+%d(FP),BX\nMOV%s b+%d(FP),CX\nCMP%s BX,CX\n", name, word*3, move, move, word, move, word*2, move)
+			} else {
+				fmt.Fprintf(&declarations, "func %s(a,b,old uintptr) uintptr\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s old+%d(FP),AX\nMOV%s a+0(FP),BX\nMOV%s b+%d(FP),CX\nCMP%s BX,CX\n", name, word*4, move, word*2, move, move, word, move)
+			}
+			line = strings.Count(source.String(), "\n") + 1
+			fmt.Fprintln(&source, w.Instruction)
+			if !memory {
+				fmt.Fprintf(&source, "MOV%s AX,ret+%d(FP)\n", move, word*3)
+			}
+			source.WriteString("RET\n")
+		}
+		// Go's listing prints the canonical opcode for a frontend alias. The
+		// original spelling stays in witness/source; only the byte observer's
+		// opcode comparison receives the independently bound canonical name.
+		canonical := fixture.opcode + strings.TrimPrefix(w.Instruction, strings.Fields(w.Instruction)[0])
+		observed = append(observed, x86OfficialPackedCase{row: fixture.row + "/" + w.Layout, symbol: name, line: line,
+			witness: goasmrules.X86PackedBinaryWitness{Instruction: canonical, Encoding: w.Encoding}})
+	}
+	return source.String(), declarations.String(), observed
+}
+
+func TestX86OfficialConditionalRowsOriginalBytesAndObservableObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			cases, err := x86OfficialConditionCases(catalog, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			for start := 0; start < len(cases); start += 32 {
+				end := start + 32
+				if end > len(cases) {
+					end = len(cases)
+				}
+				t.Run(fmt.Sprintf("batch%02d", start/32), func(t *testing.T) {
+					source, declarations, observed := x86OfficialConditionAssembly(cases[start:end], arch)
+					listing, err := x86ScalarLiteralGoListing(t, arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := x86OfficialPackedVerifyListing(listing, observed); err != nil {
+						t.Fatal("independent source-row/layout/Go-byte identity", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("real conditional data/byte output continuation", api, err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_official_legacy_float_binary_rows_test.go b/x86_official_legacy_float_binary_rows_test.go
new file mode 100644
index 000000000..3c2236032
--- /dev/null
+++ b/x86_official_legacy_float_binary_rows_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86OfficialLegacyFloatingAssembly(cases []x86OfficialPackedCase, arch string) (string, string) {
+	source, declaration := x86OfficialPackedAssembly(cases)
+	if arch == "386" {
+		// Three pointers plus the existing uint64 mask occupy20 ABI0 bytes.
+		// All literal instructions, vector seeds and result stores are shared.
+		source = strings.NewReplacer(
+			",$0-32\n", ",$0-20\n",
+			"MOVQ out+0(FP),DX\n", "MOVL out+0(FP),DX\n",
+			"MOVQ a+8(FP),AX\n", "MOVL a+4(FP),AX\n",
+			"MOVQ b+16(FP),BX\n", "MOVL b+8(FP),BX\n",
+		).Replace(source)
+	}
+	return source, declaration
+}
+
+// The existing-producer baseline and this row-owned version keep the same
+// complete48 instructions/initialized sources per mode. Actual source row IDs
+// and strict whole-function Go byte verification are added here.
+func TestX86LegacyFloatingBinaryExistingObservableProducer(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"},
+		{"386", "i386-unknown-linux-gnu"},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			x86OfficialPackedRowsObjectsForTarget(t, mode.arch, mode.triple,
+				goasmrules.X86LegacyFloatingBinaryRows, 24, 48, 0,
+				func(cases []x86OfficialPackedCase) (string, string) {
+					return x86OfficialLegacyFloatingAssembly(cases, mode.arch)
+				},
+				func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+					x86PackedStringCompileObject(t, llc, mode.triple, ir, "-O2")
+				})
+		})
+	}
+}
diff --git a/x86_official_legacy_gp_rmw_rows_test.go b/x86_official_legacy_gp_rmw_rows_test.go
new file mode 100644
index 000000000..cd3d12dc5
--- /dev/null
+++ b/x86_official_legacy_gp_rmw_rows_test.go
@@ -0,0 +1,1082 @@
+package plan9asm
+
+// Original source rows, selected Go bytes and initialized API objects are
+// distinct observations. These owners do not establish runtime semantics.
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var legacyGPRMWDraftNames = regexp.MustCompile(`^(ADC|ADD|AND|OR|SBB|SUB|XOR|INC|DEC|NEG|NOT|BTC|BTR|BTS)[BWLQ]$`)
+
+func x86MoveExtensionOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	seen := map[string]bool{}
+	for _, reference := range x86ExtensionNativeOracle {
+		var entry goasmrules.X86LegacyOpcode
+		for _, candidate := range catalog.Optab {
+			if candidate.Opcode == reference.op {
+				entry = candidate
+			}
+		}
+		if entry.Opcode == "" || seen[entry.Opcode] || entry.Ytab != reference.table || entry.Prefix != reference.prefix {
+			t.Fatal("independent original extension source identity changed", reference.op)
+		}
+		seen[entry.Opcode] = true
+		if arch == "386" && reference.amd64Only {
+			continue
+		}
+		prefix := map[string][]byte{"Pm": {0x0f}, "Pq": {0x66, 0x0f}, "Pe": {0x66}, "Pw": {0x48}, "Px": {}}[reference.prefix]
+		code := append([]byte(nil), prefix...)
+		for _, atom := range strings.Split(reference.bytes, ",") {
+			value, err := strconv.ParseUint(strings.TrimSpace(atom), 0, 8)
+			if err != nil {
+				t.Fatal(err)
+			}
+			code = append(code, byte(value))
+		}
+		for _, source := range []struct {
+			operand string
+			modrm   byte
+		}{{"CX", 0xd9}, {"0(SI)", 0x1e}} {
+			cases = append(cases, x86OfficialPackedCase{row: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab),
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " " + source.operand + ",BX", Destination: "BX", Encoding: append(append([]byte(nil), code...), source.modrm)}})
+		}
+	}
+	if len(seen) != 14 || len(cases) != map[string]int{"amd64": 28, "386": 18}[arch] {
+		t.Fatal("complete extension source/mode union changed", arch, len(seen), len(cases))
+	}
+	return cases
+}
+
+func TestX86OfficialMoveExtensionOriginalGoBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86MoveExtensionOriginalCases(t, catalog, arch)
+		t.Run(arch+"/projection", func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarMoveExtensionRows(catalog, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			modes[arch] = rows
+			expected := map[string]goasmrules.X86PackedBinaryWitness{}
+			for _, fixture := range cases {
+				expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+			}
+			for _, row := range rows {
+				for _, witness := range row.Witnesses {
+					key := row.ID + "/" + witness.Instruction
+					original, found := expected[key]
+					if !found || !bytes.Equal(witness.Encoding, original.Encoding) || witness.Destination != original.Destination {
+						t.Fatal("extension row/instruction/bytes/destination join differs", key, witness, original)
+					}
+					delete(expected, key)
+				}
+			}
+			if len(expected) != 0 {
+				t.Fatal("original extension source witness omitted", expected)
+			}
+		})
+		x86ImplicitMulDivOriginalByteBatches(t, arch, cases)
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_MOVE_EXTENSION_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+func TestX86OfficialMoveExtensionInitializedThreeAPIFiveObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		x86Legacy127Objects(t, arch, x86MoveExtensionOriginalCases(t, catalog, arch),
+			func(name, instruction, mode string) (string, string) {
+				return x86ScalarRMRegisterInitializedFunction(name, instruction, mode)
+			})
+	}
+}
+
+func TestX86OfficialMoveExtensionModePhysicalAliasesActualGo(t *testing.T) {
+	observations := 0
+	for _, arch := range []string{"amd64", "386"} {
+		for _, reference := range x86ExtensionNativeOracle {
+			for _, pair := range [][2]string{{"AL", "BX"}, {"AH", "BX"}, {"AH", "R8"}, {"BP", "BX"}, {"SI", "BX"},
+				{"DI", "BX"}, {"SP", "BX"}, {"SPB", "BX"}, {"R8", "BX"}, {"CX", "R8"}} {
+				observations++
+				instruction := reference.op + " " + pair[0] + "," + pair[1]
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					accepted := !(arch == "386" && reference.amd64Only) && pair[0] != "SPB"
+					if reference.table != "ymb_rl" && (pair[0] == "AL" || pair[0] == "AH") ||
+						arch == "386" && (pair[0] == "R8" || pair[1] == "R8" || reference.table == "ymb_rl" && pair[0] == "SP") {
+						accepted = false
+					}
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", "", accepted)
+					if !accepted {
+						return
+					}
+					ins := x86YMMReadSource(t, instruction)
+					form, known, err := x86ScalarExtensionProperties(ins.Op, ins, arch)
+					if !known || err != nil {
+						t.Fatal("Go-valid extension alias lost its existing typed grammar", err)
+					}
+					want := Reg(pair[0])
+					if reference.table == "ymb_rl" && reference.source == 2 && pair[0] == "AL" {
+						want = AX
+					} else if pair[0] == "AH" && (reference.source == 2 || arch == "amd64" && (reference.destination == 8 || pair[1] == "R8")) {
+						want = SP
+					}
+					if form.source.Reg != want || form.spec.sourceBits != reference.source*8 {
+						t.Fatal("physical source/tuple differs from original encoding", form.source.Reg, want, form.spec.sourceBits)
+					}
+					// Syntax/physical projection is not a numerical input proof.
+				})
+			}
+		}
+	}
+	if observations != 280 {
+		t.Fatal("complete source/mode/physical-alias observation matrix changed", observations)
+	}
+}
+
+func x86ImplicitMulDivOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) []x86OfficialPackedCase {
+	t.Helper()
+	numeric := regexp.MustCompile(`^(?:I?MUL|I?DIV)[BWLQ]$`)
+	var cases []x86OfficialPackedCase
+	count := 0
+	for _, entry := range catalog.Optab {
+		if !numeric.MatchString(entry.Opcode) || entry.Ytab != "ydivb" && entry.Ytab != "ydivl" && entry.Ytab != "yimul" {
+			continue
+		}
+		count++
+		width := entry.Opcode[len(entry.Opcode)-1]
+		if arch == "386" && width == 'Q' {
+			continue
+		}
+		opcode, err := strconv.ParseUint(entry.OpBytes[0], 0, 8)
+		if err != nil {
+			t.Fatal(err)
+		}
+		extension, err := strconv.ParseUint(entry.OpBytes[1], 0, 3)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var prefix []byte
+		if width == 'W' {
+			prefix = []byte{0x66}
+		} else if width == 'Q' {
+			prefix = []byte{0x48}
+		}
+		register := "CX"
+		if width == 'B' {
+			register = "CL"
+		}
+		for _, source := range []struct {
+			operand string
+			modrm   byte
+		}{{register, 0xc1}, {"0(SI)", 0x06}} {
+			cases = append(cases, x86OfficialPackedCase{
+				row: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab),
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " " + source.operand,
+					Destination: "AX", Encoding: append(append([]byte(nil), prefix...), byte(opcode), source.modrm|byte(extension)<<3)},
+			})
+		}
+	}
+	if count != 16 || len(cases) != map[string]int{"amd64": 32, "386": 24}[arch] {
+		t.Fatal("complete implicit integer family/mode inventory changed", count, arch, len(cases))
+	}
+	return cases
+}
+
+func x86ImplicitMulDivOriginalByteBatches(t *testing.T, arch string, cases []x86OfficialPackedCase) {
+	t.Helper()
+	for start := 0; start < len(cases); start += 32 {
+		end := start + 32
+		if end > len(cases) {
+			end = len(cases)
+		}
+		t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+			batch := cases[start:end]
+			var source strings.Builder
+			for index := range batch {
+				batch[index].symbol = fmt.Sprintf("ImplicitRow%d", index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[index].symbol)
+				batch[index].line = strings.Count(source.String(), "\n") + 1
+				fmt.Fprintln(&source, batch[index].witness.Instruction)
+				fmt.Fprintln(&source, "RET")
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+				t.Fatal("original implicit row/register/byte encoding differs", err)
+			}
+		})
+	}
+}
+
+func TestX86OfficialImplicitMulDivOriginalGoBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86ImplicitMulDivOriginalCases(t, catalog, arch)
+		t.Run(arch+"/projection", func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarImplicitMulDivRows(catalog, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			modes[arch] = rows
+			expected := map[string]goasmrules.X86PackedBinaryWitness{}
+			for _, fixture := range cases {
+				expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+			}
+			for _, row := range rows {
+				for _, witness := range row.Witnesses {
+					key := row.ID + "/" + witness.Instruction
+					original, found := expected[key]
+					if !found || !bytes.Equal(witness.Encoding, original.Encoding) || witness.Destination != original.Destination {
+						t.Fatal("implicit row/instruction/bytes/destination join differs", key, witness, original)
+					}
+					delete(expected, key)
+				}
+			}
+			if len(expected) != 0 {
+				t.Fatal("implicit original witness omitted", expected)
+			}
+		})
+		x86ImplicitMulDivOriginalByteBatches(t, arch, cases)
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_IMPLICIT_MULDIV_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+func x86ImplicitMulDivInitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "Q"
+	if word == 4 {
+		move = "L"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\nMOV%s memory+%d(FP),SI\n"+
+		"MOV%s low+%d(FP),AX\nMOV%s high+%d(FP),DX\nMOV%s input+%d(FP),CX\n%s\n"+
+		"MOV%s AX,0(DI)\nMOV%s DX,%d(DI)\n",
+		name, 5*word, move, move, word, move, 2*word, move, 3*word, move, 4*word, operation, move, move, word)
+	// Division's undefined status must never become a public output. Product
+	// owners independently observe CF/OF; upper AX/DX bytes remain visible.
+	if !strings.Contains(strings.Fields(operation)[0], "DIV") {
+		source += fmt.Sprintf("SETCS CL\nMOVB CL,%d(DI)\nSETOS CL\nMOVB CL,%d(DI)\n", 2*word, 2*word+1)
+	}
+	return source + "RET\n", fmt.Sprintf("func %s(out *[32]byte,memory *[8]byte,low,high,input uintptr)\n", name)
+}
+
+func TestX86OfficialImplicitMulDivInitializedThreeAPIFiveObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		x86Legacy127Objects(t, arch, x86ImplicitMulDivOriginalCases(t, catalog, arch), x86ImplicitMulDivInitializedFunction)
+	}
+}
+
+func TestX86OfficialImplicitMulDivByteAliasesOriginalGo(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	aliases := []struct {
+		name    string
+		rm, rex byte
+	}{
+		{"AL", 0, 0}, {"CL", 1, 0}, {"DL", 2, 0}, {"BL", 3, 0},
+		{"AH", 4, 0}, {"CH", 5, 0}, {"DH", 6, 0}, {"BH", 7, 0},
+		{"AX", 0, 0}, {"CX", 1, 0}, {"DX", 2, 0}, {"BX", 3, 0},
+		{"SP", 4, 0x40}, {"BP", 5, 0x40}, {"SI", 6, 0x40}, {"DI", 7, 0x40},
+		{"SPB", 4, 0x40}, {"BPB", 5, 0x40}, {"SIB", 6, 0x40}, {"DIB", 7, 0x40},
+	}
+	for index := 8; index < 16; index++ {
+		for _, suffix := range []string{"", "B"} {
+			aliases = append(aliases, struct {
+				name    string
+				rm, rex byte
+			}{fmt.Sprintf("R%d%s", index, suffix), byte(index - 8), 0x41})
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var cases []x86OfficialPackedCase
+		synthesized, refused := 0, 0
+		for _, entry := range catalog.Optab {
+			if entry.Ytab != "ydivb" || !regexp.MustCompile(`^(?:I?MUL|I?DIV)B$`).MatchString(entry.Opcode) {
+				continue
+			}
+			opcode, _ := strconv.ParseUint(entry.OpBytes[0], 0, 8)
+			extension, _ := strconv.ParseUint(entry.OpBytes[1], 0, 3)
+			for _, alias := range aliases {
+				instruction := entry.Opcode + " " + alias.name
+				if alias.name == "SPB" || arch == "386" && alias.rex != 0 {
+					accepted := arch == "386" && (alias.name == "BP" || alias.name == "SI" || alias.name == "DI")
+					if accepted {
+						synthesized++
+					} else {
+						refused++
+					}
+					t.Run(arch+"-special/"+instruction, func(t *testing.T) {
+						// Go synthesizes the three physical byte sources in mode32.
+						// Acceptance is separate from the direct-byte expectations.
+						// Explicit SPB is rejected in both modes; SP remains its
+						// separate legal low-byte spelling in AMD64.
+						goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", "", accepted)
+					})
+					continue
+				}
+				var code []byte
+				if alias.rex != 0 {
+					code = append(code, alias.rex)
+				}
+				code = append(code, byte(opcode), 0xc0|byte(extension)<<3|alias.rm)
+				cases = append(cases, x86OfficialPackedCase{row: entry.Opcode + "/byte-alias",
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: code}})
+			}
+		}
+		if len(aliases) != 36 || len(cases) != map[string]int{"amd64": 140, "386": 48}[arch] ||
+			synthesized != map[string]int{"amd64": 0, "386": 12}[arch] || refused != map[string]int{"amd64": 4, "386": 84}[arch] {
+			t.Fatal("complete byte-bank/mode inventory changed", arch, len(cases), synthesized, refused)
+		}
+		x86ImplicitMulDivOriginalByteBatches(t, arch, cases)
+	}
+}
+
+func TestX86OfficialImplicitMulDivModeAndOperandRefusals(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{}
+	for _, fixture := range x86ImplicitMulDivOriginalCases(t, catalog, "amd64") {
+		name := strings.Fields(fixture.witness.Instruction)[0]
+		if strings.HasSuffix(name, "Q") {
+			t.Run("386-Q/"+fixture.witness.Instruction, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+fixture.witness.Instruction+"\nRET\n", "", false)
+			})
+		}
+		if seen[name] {
+			continue
+		}
+		seen[name] = true
+		for _, source := range []string{"$1", "X0"} {
+			t.Run("invalid/"+name+"/"+source, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+name+" "+source+"\nRET\n", "", false)
+			})
+		}
+	}
+	if len(seen) != 16 {
+		t.Fatal("implicit mode/refusal control lost family members", len(seen))
+	}
+}
+
+// Independent original-table fixture construction. The fixed low registers
+// make ModRM direction explicit; the original payload remains the byte source.
+// These cases establish encoding, not input definedness or memory authority.
+func x86ScalarMultiplyMOVBESourceCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows := 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yimul" && entry.Ytab != "yimul3" && entry.Ytab != "ymovbe" {
+			continue
+		}
+		width := entry.Opcode[len(entry.Opcode)-1]
+		for _, row := range entry.Rows {
+			rows++
+			if arch == "386" && width == 'Q' {
+				continue
+			}
+			var payload []byte
+			for _, atom := range entry.OpBytes {
+				if atom == "Pm" {
+					payload = append(payload, 0x0f)
+					continue
+				}
+				value, err := strconv.ParseUint(atom, 0, 8)
+				if err != nil {
+					t.Fatal("original GP source atom changed", atom, err)
+				}
+				payload = append(payload, byte(value))
+			}
+			var prefix []byte
+			if width == 'W' {
+				prefix = append(prefix, 0x66)
+			}
+			if width == 'Q' {
+				prefix = append(prefix, 0x48)
+			}
+			if entry.Ytab == "ymovbe" && width != 'Q' {
+				prefix = append(prefix, 0x0f)
+			}
+			add := func(operands, destination string, code []byte) {
+				cases = append(cases, x86OfficialPackedCase{
+					row: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex),
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " " + operands,
+						Destination: destination, Encoding: append(append([]byte(nil), prefix...), code...)},
+				})
+			}
+			offset := row.UnmatchedOffset
+			switch entry.Ytab {
+			case "yimul":
+				switch row.RowIndex {
+				case 0:
+					add("CX", "AX", []byte{payload[offset], 0xe9})
+					add("0(SI)", "AX", []byte{payload[offset], 0x2e})
+				case 1, 2:
+					value, size := 1, 1
+					if row.RowIndex == 2 {
+						value, size = 128, 4
+						if width == 'W' {
+							size = 2
+						}
+					}
+					code := []byte{payload[offset], 0xdb}
+					for byteIndex := 0; byteIndex < size; byteIndex++ {
+						code = append(code, byte(value>>uint(byteIndex*8)))
+					}
+					add(fmt.Sprintf("$%d,BX", value), "BX", code)
+				case 3:
+					add("CX,BX", "BX", []byte{payload[offset], payload[offset+1], 0xd9})
+					add("0(SI),BX", "BX", []byte{payload[offset], payload[offset+1], 0x1e})
+				}
+			case "yimul3":
+				value, size := 1, 1
+				if row.RowIndex == 1 {
+					value, size = 128, 4
+					if width == 'W' {
+						size = 2
+					}
+				}
+				for _, input := range []struct {
+					operand string
+					modrm   byte
+				}{{"CX", 0xd9}, {"0(SI)", 0x1e}} {
+					code := []byte{payload[offset], input.modrm}
+					for byteIndex := 0; byteIndex < size; byteIndex++ {
+						code = append(code, byte(value>>uint(byteIndex*8)))
+					}
+					add(fmt.Sprintf("$%d,%s,BX", value, input.operand), "BX", code)
+				}
+			case "ymovbe":
+				code := append([]byte(nil), payload[offset:offset+row.ZOffset+entry.EscapeAdjustment-1]...)
+				if row.RowIndex == 0 {
+					add("0(SI),BX", "BX", append(code, 0x1e))
+				} else {
+					add("CX,0(SI)", "0(SI)", append(code, 0x0e))
+				}
+			}
+		}
+	}
+	if rows != 24 || len(cases) != map[string]int{"amd64": 36, "386": 24}[arch] {
+		t.Fatal("complete original GP source/mode count changed", arch, rows, len(cases))
+	}
+	return cases
+}
+
+func TestX86OfficialScalarMultiplyMOVBEOriginalGoBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86ScalarMultiplyMOVBESourceCases(t, catalog, arch)
+		t.Run(arch+"/projection", func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarMultiplyMOVBERows(catalog, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			modes[arch] = rows
+			expected := map[string]goasmrules.X86PackedBinaryWitness{}
+			for _, fixture := range cases {
+				expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+			}
+			for _, row := range rows {
+				for _, witness := range row.Witnesses {
+					key := row.ID + "/" + witness.Instruction
+					original, found := expected[key]
+					if !found || !bytes.Equal(witness.Encoding, original.Encoding) || witness.Destination != original.Destination {
+						t.Fatal("source row/instruction/encoding/destination join differs", key, witness, original)
+					}
+					delete(expected, key)
+				}
+			}
+			if len(expected) != 0 {
+				t.Fatal("original source witnesses omitted from the production projection", expected)
+			}
+		})
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				batch := cases[start:end]
+				var source strings.Builder
+				for index := range batch {
+					batch[index].symbol = fmt.Sprintf("OriginalGP%d", index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[index].symbol)
+					batch[index].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[index].witness.Instruction)
+					fmt.Fprintln(&source, "RET")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("independent original GP row/bytes mismatch", err)
+				}
+			})
+		}
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_SCALAR_MULTIPLY_MOVBE_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+func TestX86OfficialScalarMultiplyImmediateFirstMatchGoBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var cases []x86OfficialPackedCase
+		for _, value := range []int{-129, -128, 127, 128, 255} {
+			for _, canonical := range x86ScalarMultiplyMOVBESourceCases(t, catalog, arch) {
+				parts := strings.Split(canonical.row, "/")
+				if parts[3] != "yimul" && parts[3] != "yimul3" {
+					continue
+				}
+				row, _ := strconv.Atoi(parts[4])
+				short := value >= -128 && value <= 127
+				if parts[3] == "yimul" && row != map[bool]int{true: 1, false: 2}[short] ||
+					parts[3] == "yimul3" && row != map[bool]int{true: 0, false: 1}[short] {
+					continue
+				}
+				fixture := canonical
+				old := "$128"
+				if short {
+					old = "$1"
+				}
+				fixture.witness.Instruction = strings.Replace(canonical.witness.Instruction, old, fmt.Sprintf("$%d", value), 1)
+				size := 1
+				if !short {
+					size = 4
+					if strings.HasSuffix(parts[2], "W") {
+						size = 2
+					}
+				}
+				code := append([]byte(nil), canonical.witness.Encoding[:len(canonical.witness.Encoding)-size]...)
+				for index := 0; index < size; index++ {
+					code = append(code, byte(value>>uint(index*8)))
+				}
+				fixture.witness.Encoding = code
+				cases = append(cases, fixture)
+			}
+		}
+		if len(cases) != map[string]int{"amd64": 45, "386": 30}[arch] {
+			t.Fatal("complete signed-immediate first-match inventory changed", arch, len(cases))
+		}
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				batch := cases[start:end]
+				var source strings.Builder
+				for index := range batch {
+					batch[index].symbol = fmt.Sprintf("ImmediateGP%d", index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[index].symbol)
+					batch[index].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[index].witness.Instruction)
+					fmt.Fprintln(&source, "RET")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("original Go Yi8/Yi32 first-match or immediate width differs", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86OfficialScalarMultiplyMOVBEModeAndRegisterRefusals(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{}
+	for _, fixture := range x86ScalarMultiplyMOVBESourceCases(t, catalog, "amd64") {
+		instruction := fixture.witness.Instruction
+		if strings.HasSuffix(strings.Fields(instruction)[0], "Q") {
+			t.Run("386-Q/"+fixture.row+"/"+instruction, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+			})
+		}
+		if seen[fixture.row] {
+			continue
+		}
+		seen[fixture.row] = true
+		register := "BX"
+		if strings.Contains(instruction, "CX") {
+			register = "CX"
+		}
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run("high-register/"+arch+"/"+fixture.row, func(t *testing.T) {
+				line := strings.Replace(instruction, register, "R8", 1)
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+line+"\nRET\n", "", arch == "amd64")
+			})
+		}
+		t.Run("high-byte/"+fixture.row, func(t *testing.T) {
+			line := strings.Replace(instruction, register, "AH", 1)
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+line+"\nRET\n", "", false)
+		})
+	}
+	if len(seen) != 24 {
+		t.Fatal("mode and register observation lost an original row", len(seen))
+	}
+}
+
+func x86ScalarMultiplyMOVBEInitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "Q"
+	if word == 4 {
+		move = "L"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\nMOV%s memory+%d(FP),SI\n"+
+		"MOV%s old+%d(FP),AX\nMOV%s AX,BX\nMOV%s AX,DX\nMOV%s input+%d(FP),CX\nCMPL CX,CX\n%s\n"+
+		"MOV%s AX,0(DI)\nMOV%s DX,%d(DI)\nMOV%s BX,%d(DI)\n"+
+		"SETCS CL\nMOVB CL,%d(DI)\nSETOS CL\nMOVB CL,%d(DI)\nRET\n",
+		name, 4*word, move, move, word, move, 2*word, move, move, move, 3*word, operation,
+		move, move, word, move, 2*word, 3*word, 3*word+1)
+	return source, fmt.Sprintf("func %s(out *[32]byte,memory *[8]byte,old,input uintptr)\n", name)
+}
+
+func TestX86OfficialScalarMultiplyMOVBEInitializedThreeAPIFiveObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86ScalarMultiplyMOVBESourceCases(t, catalog, arch)
+		x86Legacy127Objects(t, arch, cases, x86ScalarMultiplyMOVBEInitializedFunction)
+	}
+}
+
+func TestX86OfficialScalarRMWCompleteSourceCarrier(t *testing.T) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86LockScalarEncoderCarrier(source); err != nil {
+		t.Fatal(err)
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, rows := 0, 0
+	for _, entry := range catalog.Optab {
+		if legacyGPRMWDraftNames.MatchString(entry.Opcode) {
+			names++
+			rows += len(entry.Rows)
+		}
+	}
+	if names != 53 || rows != 169 {
+		t.Fatal("complete source family changed", names, rows)
+	}
+}
+
+func TestX86OfficialScalarRMWFirstMatchActualGoBytes(t *testing.T) {
+	// These are source/encoding anchors, deliberately not claimed as observable
+	// translation or numerical execution. Keep the AL/AX original spelling.
+	cases := []struct {
+		instruction string
+		encoding    []byte
+	}{
+		{"ADDB $128,AL", []byte{0x04, 0x80}},
+		{"ADDB $128,AX", []byte{0x80, 0xc0, 0x80}},
+		{"ADDL $1,AX", []byte{0x83, 0xc0, 0x01}},
+		{"ADDL $128,AX", []byte{0x05, 0x80, 0, 0, 0}},
+		{"ADDL $128,BX", []byte{0x81, 0xc3, 0x80, 0, 0, 0}},
+		{"ADDL CX,BX", []byte{0x01, 0xcb}},
+		{"ADDL 0(SI),BX", []byte{0x03, 0x1e}},
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range cases {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + row.instruction + "\nRET\n"
+				actual := x86PackedShiftActualGoBytes(t, arch, source)
+				expected := append(append([]byte(nil), row.encoding...), 0xc3)
+				if !bytes.Equal(actual, expected) {
+					t.Fatalf("original selected row bytes=%x want=%x", actual, expected)
+				}
+			})
+		}
+		for _, row := range []struct {
+			instruction  string
+			short, modrm byte
+		}{
+			{"INCL AX", 0x40, 0xc0}, {"DECL AX", 0x48, 0xc8},
+		} {
+			actual := x86PackedShiftActualGoBytes(t, arch, "TEXT f(SB),4,$0-0\n"+row.instruction+"\nRET\n")
+			expected := []byte{row.short, 0xc3}
+			if arch == "amd64" {
+				expected = []byte{0xff, row.modrm, 0xc3}
+			}
+			if !bytes.Equal(actual, expected) {
+				t.Fatalf("Px1 mode selection %s/%s: %x want=%x", arch, row.instruction, actual, expected)
+			}
+		}
+	}
+}
+
+func TestX86OfficialScalarRMWRegisterCarrySeedObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple, want := 8, "Q", "x86_64-unknown-linux-gnu", 106
+		if arch == "386" {
+			word, move, triple, want = 4, "L", "i386-unknown-linux-gnu", 78
+		}
+		count, batch := 0, 0
+		var source, declarations strings.Builder
+		flush := func() {
+			if source.Len() == 0 {
+				return
+			}
+			// Full sources contain initialized real inputs and two observable
+			// results, not no-result/unused statements or a constant7 return.
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("observable GP producer %s/%s/batch%d: %v", arch, api, batch, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			}
+			source.Reset()
+			declarations.Reset()
+			batch++
+		}
+		for _, entry := range catalog.Optab {
+			op := entry.Opcode
+			if !legacyGPRMWDraftNames.MatchString(op) || arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			width, stem := op[len(op)-1], op[:len(op)-1]
+			operand, destination := "CX", "AX"
+			if width == 'B' {
+				operand, destination = "CL", "AL"
+			}
+			if strings.HasPrefix(stem, "BT") {
+				operand = "$1"
+			}
+			instruction := op + " " + operand + "," + destination
+			if stem == "INC" || stem == "DEC" || stem == "NEG" || stem == "NOT" {
+				instruction = op + " " + destination
+			}
+			for _, seed := range []string{"CLC", "STC"} {
+				name := fmt.Sprintf("GPRMW%d", count)
+				fmt.Fprintf(&declarations, "func %s(old,value uintptr) (data,flags uintptr)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s old+0(FP),AX\nMOV%s value+%d(FP),CX\nCMPL CX,CX\n%s\n%s\n", name, word*4, move, move, word, seed, instruction)
+				// MOV observes actual data without changing status. POP's
+				// partial-bit identity must be consumed by the next AND only.
+				fmt.Fprintf(&source, "MOV%s AX,data+%d(FP)\nPUSHF%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,flags+%d(FP)\nRET\n", move, word*2, move, move, move, x86ScalarRuntimeStatusMask(stem), move, word*3)
+				count++
+				if count%32 == 0 {
+					flush()
+				}
+			}
+		}
+		flush()
+		if count != want {
+			t.Fatal("observable full mnemonic closure changed", arch, count, want)
+		}
+	}
+}
+
+// This adapter gives the GP row its real input/output roles; only the existing
+// byte-listing observer consumes a packed-case shell, with no packed initializer
+// or vector fields granting data, FLAGS or source-storage capabilities.
+func x86OfficialScalarRMWAssembly(cases []x86OfficialPackedCase, witnesses []goasmrules.X86ScalarRMWWitness, arch string) (string, string) {
+	word, move := 8, "Q"
+	if arch == "386" {
+		word, move = 4, "L"
+	}
+	var source, declarations strings.Builder
+	for index, witness := range witnesses {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprintf("GPRow%d", index)
+		stem := strings.Fields(witness.Instruction)[0]
+		stem = stem[:len(stem)-1]
+		memoryResult := witness.Destination == "0(SI)"
+		result, size := "(data,flags uintptr)", word*5
+		if memoryResult {
+			result, size = "(flags uintptr)", word*4
+		}
+		fmt.Fprintf(&declarations, "func %s(memory *[16]byte,old,value uintptr) %s\n", fixture.symbol, result)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),SI\nMOV%s old+%d(FP),AX\nMOV%s AX,BX\nMOV%s value+%d(FP),CX\nCMPL CX,CX\nCLC\n",
+			fixture.symbol, size, move, move, word, move, move, word*2)
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, witness.Instruction)
+		flagOffset := word * 3
+		if !memoryResult {
+			register := "BX"
+			if witness.Destination == "AX" || witness.Destination == "AL" {
+				register = "AX"
+			}
+			fmt.Fprintf(&source, "MOV%s %s,data+%d(FP)\n", move, register, word*3)
+			flagOffset += word
+		}
+		fmt.Fprintf(&source, "PUSHF%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,flags+%d(FP)\nRET\n",
+			move, move, move, x86ScalarRuntimeStatusMask(stem), move, flagOffset)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialScalarRMWRowsSelectedGoBytesThreeAPIsObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct {
+		arch, triple     string
+		selected, shapes int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 167, 278},
+		{"386", "i386-unknown-linux-gnu", 124, 202},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarRMWRows(catalog, mode.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var witnesses []goasmrules.X86ScalarRMWWitness
+			var cases []x86OfficialPackedCase
+			selected := 0
+			for _, row := range rows {
+				if row.ModeFiltered != "" {
+					continue
+				}
+				selected++
+				for _, witness := range row.Witnesses {
+					cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+					witnesses = append(witnesses, witness)
+				}
+			}
+			if len(rows) != 169 || selected != mode.selected || len(witnesses) != mode.shapes {
+				t.Fatal("source/mode/selected denominator changed", len(rows), selected, len(witnesses))
+			}
+			for start := 0; start < len(cases); start += 32 {
+				end := start + 32
+				if end > len(cases) {
+					end = len(cases)
+				}
+				t.Run(fmt.Sprintf("batch%02d", start/32), func(t *testing.T) {
+					batch := cases[start:end]
+					source, declarations := x86OfficialScalarRMWAssembly(batch, witnesses[start:end], mode.arch)
+					listing, err := x86ScalarLiteralGoListing(t, mode.arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+						t.Fatal("actual selected Go byte identity", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declarations, mode.arch, mode.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized data/defined FLAGS continuation", err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, mode.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86OfficialScalarRMWOriginalShadowsAndModeSelection(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86ScalarRMWRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		byName := map[string][]goasmrules.X86ScalarRMWRow{}
+		for _, row := range rows {
+			byName[row.Opcode] = append(byName[row.Opcode], row)
+		}
+		var cases []x86OfficialPackedCase
+		var source strings.Builder
+		add := func(from, selected goasmrules.X86ScalarRMWRow, witness goasmrules.X86ScalarRMWWitness) {
+			name := fmt.Sprintf("Shadow%d", len(cases))
+			line := strings.Count(source.String(), "\n") + 2
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, witness.Instruction)
+			cases = append(cases, x86OfficialPackedCase{row: from.ID + " -> " + selected.ID, symbol: name, line: line,
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+		}
+		for _, entry := range catalog.Optab {
+			group := byName[entry.Opcode]
+			if len(group) == 0 || arch == "386" && entry.Prefix == "Pw" {
+				continue
+			}
+			switch entry.Ytab {
+			case "yxorb":
+				add(group[1], group[0], group[0].Witnesses[0])
+				add(group[3], group[2], group[2].Witnesses[0])
+				// Class match sees AX before Pb converts it to AL. Therefore
+				// this spelling selects generic /digit, not accumulator opcode.
+				alias := group[1].Witnesses[0]
+				alias.Instruction = strings.Replace(alias.Instruction, "BL", "AX", 1)
+				alias.Encoding = append([]byte(nil), alias.Encoding...)
+				alias.Encoding[1] &^= 7
+				add(group[0], group[1], alias)
+			case "yaddl":
+				short := group[0].Witnesses[0]
+				short.Instruction = strings.Replace(short.Instruction, "BX", "AX", 1)
+				short.Encoding = append([]byte(nil), short.Encoding...)
+				short.Encoding[len(short.Encoding)-2] &^= 7
+				add(group[1], group[0], short)
+				add(group[2], group[0], group[0].Witnesses[0])
+				add(group[2], group[1], group[1].Witnesses[0])
+				add(group[4], group[3], group[3].Witnesses[0])
+			case "yincl":
+				if arch == "386" {
+					add(group[1], group[0], group[0].Witnesses[0])
+				} else {
+					add(group[0], group[1], group[1].Witnesses[0])
+				}
+			}
+		}
+		want := 107
+		if arch == "386" {
+			want = 79
+		}
+		if len(cases) != want {
+			t.Fatal("ordered shadow/mode observations changed", arch, len(cases), want)
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("actual Go first-match/alias selection", arch, err)
+		}
+		for _, fixture := range cases {
+			t.Logf("SCALAR_GO_SELECTION arch=%s mapping=%q source=%q encoding=%x", arch, fixture.row,
+				fixture.witness.Instruction, fixture.witness.Encoding)
+		}
+	}
+	// Preserve all45 Q source rows: each has valid amd64 syntax which the actual
+	// 386 assembler must reject independently, rather than one combined failing
+	// source hiding acceptance of another row. These are source rejection only.
+	rows, err := goasmrules.X86ScalarRMWRows(catalog, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	qrows := 0
+	for _, row := range rows {
+		if !strings.HasSuffix(row.Opcode, "Q") {
+			continue
+		}
+		qrows++
+		t.Run(row.ID, func(t *testing.T) {
+			if len(row.Witnesses) == 0 {
+				t.Fatal("valid amd64 source row lost its syntax")
+			}
+			listing, _ := x86ScalarLiteralExpectedGoListing(t, "386", "TEXT f(SB),4,$0-0\n"+row.Witnesses[0].Instruction+"\nRET\n", false)
+			t.Logf("SCALAR_GO_MODE_REJECTION row=%q source=%q diagnostic=%q", row.ID, row.Witnesses[0].Instruction, listing)
+		})
+	}
+	if qrows != 45 {
+		t.Fatal("Q-width mode boundary changed", qrows)
+	}
+}
+
+func TestX86OfficialScalarRMWObservableInputAndFlagBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "L", 4, "i386-unknown-linux-gnu"
+		}
+		body := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOV%s old+0(FP),AX\nMOV%s value+%d(FP),CX\nCMPL CX,CX\nCLC\nANDB CL,AL\nMOV%s AX,data+%d(FP)\nPUSHF%s\nPOP%s AX\nAND%s $2245,AX\nMOV%s AX,flags+%d(FP)\nRET\n", word*4, move, move, word, move, word*2, move, move, move, move, word*3)
+		for _, control := range []struct {
+			name, from, to string
+			pass           bool
+		}{
+			{"complete", "", "", true},
+			{"undefined-AF", "$2245", "$2261", false},
+			{"unmasked-flags", "AND" + move + " $2245,AX\n", "", false},
+			{"expired-popped-bits", "AND" + move + " $2245,AX", "NOP\nAND" + move + " $2245,AX", false},
+			{"missing-old", "MOV" + move + " old+0(FP),AX\n", "", false},
+			{"missing-source", "MOV" + move + fmt.Sprintf(" value+%d(FP),CX\n", word), "", false},
+			{"unknown-carry", "CMPL CX,CX\nCLC\nANDB CL,AL", "ADCB CL,AL", false},
+		} {
+			t.Run(arch+"/"+control.name, func(t *testing.T) {
+				source := body
+				if control.from != "" {
+					if strings.Count(source, control.from) != 1 {
+						t.Fatal("mutation not uniquely source-bound")
+					}
+					source = strings.Replace(source, control.from, control.to, 1)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(old,value uintptr) (data,flags uintptr)", arch, triple, api)
+					if control.pass && (err != nil || ir == "") || !control.pass && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+						t.Fatal("real data/defined-status proof changed", api, control.pass, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_official_legacy_media_rows_test.go b/x86_official_legacy_media_rows_test.go
new file mode 100644
index 000000000..1efff56f4
--- /dev/null
+++ b/x86_official_legacy_media_rows_test.go
@@ -0,0 +1,430 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// These cases follow the original prefix switch and zero-terminated literal
+// span. They are independent of the production witness formatter.
+func x86LegacyLiteralSIMDSourceCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, boundary bool) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	seenPrefixes := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yxshuf" && entry.Ytab != "yaes" {
+			continue
+		}
+		if boundary && (entry.Ytab != "yxshuf" || seenPrefixes[entry.Prefix]) {
+			continue
+		}
+		seenPrefixes[entry.Prefix] = true
+		prefixes := map[string][]byte{"Pq": {0x66, 0x0f}, "Pf2": {0xf2, 0x0f}, "Pf3": {0xf3, 0x0f}, "Pm": {0x0f}, "Px": {}}
+		prefix, found := prefixes[entry.Prefix]
+		if !found {
+			t.Fatal("independent literal SIMD source prefix changed", entry)
+		}
+		payload := append([]byte(nil), prefix...)
+		for index, atom := range entry.OpBytes {
+			value, err := strconv.ParseUint(atom, 0, 8)
+			if err != nil || value == 0 && index != len(entry.OpBytes)-1 {
+				t.Fatal("independent literal SIMD source atom changed", entry, index, err)
+			}
+			if value != 0 {
+				payload = append(payload, byte(value))
+			}
+		}
+		immediates := []int{7}
+		if boundary {
+			immediates = []int{0, 127, 128, 255}
+		}
+		for _, immediate := range immediates {
+			for _, source := range []string{"X0", "(AX)"} {
+				modrm := byte(0xc8)
+				if source == "(AX)" {
+					modrm = 0x08
+				}
+				instruction := entry.Opcode + " " + source + ",X1"
+				code := append(append([]byte(nil), payload...), modrm)
+				if entry.Ytab == "yxshuf" {
+					instruction = fmt.Sprintf("%s $%d,%s,X1", entry.Opcode, immediate, source)
+					code = append(code, byte(immediate))
+				}
+				cases = append(cases, x86OfficialPackedCase{
+					row:     fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab),
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Destination: "X1", Encoding: code},
+				})
+			}
+		}
+	}
+	want := 66
+	if boundary {
+		want = 32 // Four observed prefix classes times two carriers times four Yu8 boundaries.
+	}
+	if len(cases) != want {
+		t.Fatal("complete literal SIMD source/class-boundary inventory changed", len(cases), want)
+	}
+	return cases
+}
+
+func x86LegacyLiteralSIMDCheckGoBatches(t *testing.T, arch string, cases []x86OfficialPackedCase) {
+	t.Helper()
+	for start := 0; start < len(cases); start += 32 {
+		end := start + 32
+		if end > len(cases) {
+			end = len(cases)
+		}
+		t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+			batch := cases[start:end]
+			var source strings.Builder
+			line := 1
+			for index := range batch {
+				fixture := &batch[index]
+				fixture.symbol = fmt.Sprintf("LiteralSIMD%d", start+index)
+				fixture.line = line + 1
+				body := fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", fixture.symbol, fixture.witness.Instruction)
+				source.WriteString(body)
+				line += strings.Count(body, "\n")
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal("actual Go refused complete original literal SIMD source", err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+				t.Fatal("actual Go literal SIMD prefix/terminator/immediate bytes differ", err)
+			}
+		})
+	}
+}
+
+func TestX86OfficialLegacyLiteralSIMDOriginalGoBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := make(map[string][]goasmrules.X86PackedBinaryRow)
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86LegacyLiteralSIMDSourceCases(t, catalog, false)
+		rows, err := goasmrules.X86LegacyLiteralSIMDRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		expected := map[string]goasmrules.X86PackedBinaryWitness{}
+		for _, fixture := range cases {
+			expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+		}
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				original, found := expected[key]
+				if !found || !bytes.Equal(original.Encoding, witness.Encoding) || original.Destination != witness.Destination {
+					t.Fatal("literal SIMD transport differs from independent actual-Go source", key, witness, original)
+				}
+				delete(expected, key)
+			}
+		}
+		if len(rows) != 33 || len(expected) != 0 {
+			t.Fatal("literal SIMD row/witness join omitted or repeated source cases", arch, len(rows), expected)
+		}
+		x86LegacyLiteralSIMDCheckGoBatches(t, arch, cases)
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_LEGACY_LITERAL_SIMD_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86PackedBinaryRow
+		}{catalog, modes})
+	}
+}
+
+func TestX86OfficialLegacyLiteralSIMDGoImmediateAndModeBoundaries(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run("unsigned/"+arch, func(t *testing.T) {
+			x86LegacyLiteralSIMDCheckGoBatches(t, arch, x86LegacyLiteralSIMDSourceCases(t, catalog, true))
+		})
+		seen := map[string]bool{}
+		for _, entry := range catalog.Optab {
+			if entry.Ytab != "yxshuf" || seen[entry.Prefix] {
+				continue
+			}
+			seen[entry.Prefix] = true
+			for _, immediate := range []int{-129, -128, -1, 256} {
+				t.Run(fmt.Sprintf("%s/%s/imm%d", arch, entry.Prefix, immediate), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Bad(SB),4,$0-0\n%s $%d,X0,X1\nRET\n", entry.Opcode, immediate)
+					goAssemblerOracleOutput(t, arch, source, "", false)
+				})
+			}
+		}
+		modes := map[string]bool{}
+		for _, entry := range catalog.Optab {
+			if entry.Ytab != "yxshuf" && entry.Ytab != "yaes" {
+				continue
+			}
+			key := entry.Ytab + "/" + entry.Prefix
+			if modes[key] {
+				continue
+			}
+			modes[key] = true
+			t.Run("high-register/"+arch+"/"+key, func(t *testing.T) {
+				instruction := entry.Opcode + " X8,X1"
+				if entry.Ytab == "yxshuf" {
+					instruction = entry.Opcode + " $7,X8,X1"
+				}
+				source := "TEXT ·Mode(SB),4,$0-0\n" + instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", arch == "amd64")
+			})
+		}
+	}
+}
+
+// Exact original source-format units compile independently of initialized
+// public programs. They do not establish NUM, memory bounds, FP control or
+// numerical/native execution. Those stay with the typed family owners.
+func TestX86OfficialLegacyLiteralSIMDOriginalFormatObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	objects := 0
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86LegacyLiteralSIMDSourceCases(t, catalog, false)
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				var source strings.Builder
+				signatures := map[string]FuncSig{}
+				for index, fixture := range cases[start:end] {
+					name := fmt.Sprintf("LiteralSIMDFormat%d", start+index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, fixture.witness.Instruction)
+					signatures[name] = FuncSig{Name: name, Ret: Void}
+				}
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil || len(file.Funcs) != end-start {
+					t.Fatal("original literal SIMD format functions changed", err)
+				}
+				for _, triple := range x86Legacy127Targets(arch) {
+					ir := x86SingleInstructionFormatObjectUnits(t, file, signatures, arch, triple,
+						func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+							// Reuse the real typed family emitters. This is neither
+							// a raw-byte/inline-assembly substitute nor a public proof.
+							for _, lower := range []func(Op, Instr) (bool, bool, error){
+								consumer.lowerPackedFloatShuffle, consumer.lowerImmediatePackedBlend, consumer.lowerPackedFloatingDot,
+								consumer.lowerPackedSumAbsoluteDifferences, consumer.lowerRound,
+								consumer.lowerVec,
+							} {
+								if known, terminal, err := lower(instruction.Op, instruction); known {
+									return known, terminal, err
+								}
+							}
+							return false, false, nil
+						})
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+						objects++
+					}
+				}
+			})
+		}
+	}
+	if objects != 30 {
+		t.Fatal("complete literal SIMD five-target O0/O2 format matrix changed", objects)
+	}
+}
+
+func x86Legacy127Targets(arch string) []string {
+	if arch == "386" {
+		return []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+	}
+	return []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+}
+
+// Inputs are explicit pointer/scalar parameters. Seeding both X inputs is
+// deliberate initialized context, not a fact inferred from source syntax.
+// MMX has a separate real region, output observation and mandatory EMMS.
+func x86LegacyMediaInitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "Q"
+	if word == 4 {
+		move = "L"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DX\nMOV%s a+%d(FP),AX\nMOV%s b+%d(FP),BX\nMOV%s mask+%d(FP),CX\n"+
+		"MOVOU (AX),X0\nMOVOU (BX),X1\nCMPL CX,CX\n", name, 3*word+8, move, move, word, move, 2*word, move, 3*word)
+	mmx := strings.Contains(operation, "M1")
+	if mmx {
+		source += "MOVQ (AX),M0\nMOVQ (BX),M1\n"
+	}
+	source += operation + "\n"
+	if mmx {
+		source += "MOVQ M1,32(DX)\nEMMS\n"
+	}
+	// Observe the whole X carrier and memory, including scalar/half merge
+	// bytes. COMI observes its defined status rather than a fictitious X write.
+	source += "MOVOU X1,0(DX)\nMOVOU (AX),X2\nMOVOU X2,16(DX)\n" +
+		"SETCS CL\nMOVB CL,40(DX)\nSETEQ CL\nMOVB CL,41(DX)\nSETPS CL\nMOVB CL,42(DX)\nRET\n"
+	return source, fmt.Sprintf("func %s(out *[48]byte,a,b *[16]byte,mask uint64)\n", name)
+}
+
+// This batches complete functions, not a compiler process per source row.
+// Whole-source Go byte identity precedes each three-API O0/O2 object batch.
+func x86Legacy127Objects(t *testing.T, arch string, cases []x86OfficialPackedCase,
+	function func(string, string, string) (string, string)) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for start := 0; start < len(cases); start += 32 {
+		end := start + 32
+		if end > len(cases) {
+			end = len(cases)
+		}
+		t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+			batch := cases[start:end]
+			var source, declarations strings.Builder
+			for index := range batch {
+				fixture := &batch[index]
+				fixture.symbol = fmt.Sprint("Legacy127Row", index)
+				body, declaration := function(fixture.symbol, fixture.witness.Instruction, arch)
+				position := strings.Index(body, "\n"+fixture.witness.Instruction+"\n")
+				if position < 0 || strings.Count(body, "\n"+fixture.witness.Instruction+"\n") != 1 {
+					t.Fatal("initialized producer lost the exact original instruction", fixture.row)
+				}
+				fixture.line = strings.Count(source.String(), "\n") + strings.Count(body[:position+1], "\n") + 1
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+				t.Fatal("actual original source row/prefix/direction/byte identity", err)
+			}
+			for _, target := range x86Legacy127Targets(arch) {
+				t.Run(target, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, target, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized whole-function translation", err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86Legacy127SaveIdentity(t *testing.T, variable string, value interface{}) {
+	t.Helper()
+	if path := os.Getenv(variable); path != "" {
+		data, err := json.MarshalIndent(value, "", "  ")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(path, append(data, '\n'), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func TestX86OfficialLegacyMediaRemainderRowsObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86LegacyMediaRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86LegacyMediaRemainderRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		var cases []x86OfficialPackedCase
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: witness})
+			}
+		}
+		want := 160
+		if arch == "386" {
+			want = 70
+		}
+		if len(rows) != 96 || len(cases) != want {
+			t.Fatal("complete source/mode witness union changed", arch, len(rows), len(cases))
+		}
+		x86Legacy127Objects(t, arch, cases, x86LegacyMediaInitializedFunction)
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_LEGACY_MEDIA_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86LegacyMediaRow
+		}{catalog, modes})
+	}
+}
+
+func TestX86LegacyMediaRemainderInitializedInputsRemainRequired(t *testing.T) {
+	for _, item := range []struct{ operation, removed string }{
+		{"PADDB M0,M1", "MOVQ (BX),M1\n"},
+		{"PADDB M0,M1", "MOVQ (AX),M0\n"},
+		{"PADDB M0,M1", "EMMS\n"},
+		{"CVTSD2SS X0,X1", "MOVOU (BX),X1\n"},
+		{"COMISD X0,X1", "MOVOU (AX),X0\n"},
+	} {
+		t.Run(item.operation+"/"+strings.TrimSpace(item.removed), func(t *testing.T) {
+			source, declaration := x86LegacyMediaInitializedFunction("MediaMissing", item.operation, "amd64")
+			if strings.Count(source, item.removed) != 1 {
+				t.Fatal("negative did not remove exactly one initialized input/state boundary")
+			}
+			source = strings.Replace(source, item.removed, "", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if item.operation != "PADDB M0,M1" {
+					x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("source transport supplied missing NUM/old bytes or MMX state", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86LegacyMediaRemainderVoidAndForeignNativeRemainRejected(t *testing.T) {
+	for _, operation := range []string{"PADDB M0,M1", "COMISD X0,X1", "CVTSD2SS X0,X1"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			source := "TEXT ·MediaVoid(SB),4,$0-0\n" + operation + "\nRET\n"
+			if ir, err := x86ScalarFPBitViewAPI(t, source, "func MediaVoid()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("dead Void result hid uninitialized media inputs", operation, api, err)
+			}
+		}
+	}
+	source, declaration := x86LegacyMediaInitializedFunction("MediaForeign", "PADDB M0,M1", "amd64")
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "aarch64-unknown-linux-gnu", api); err == nil || ir != "" {
+			t.Fatal("source MMX transport supplied foreign native-target permission", api, err)
+		}
+	}
+}
diff --git a/x86_official_legacy_scalar_conversion_objects_test.go b/x86_official_legacy_scalar_conversion_objects_test.go
new file mode 100644
index 000000000..4362999cc
--- /dev/null
+++ b/x86_official_legacy_scalar_conversion_objects_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The original instruction is unchanged. NUM producers, native input pointers
+// and preserved XMM bytes are supplied separately; source rows grant none.
+func TestX86LegacyScalarConversionInitializedThreeAPIObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	fixtures := scalarConversion12OriginalCases(t, catalog)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, fixture := range fixtures {
+				op := strings.Fields(fixture.witness.Instruction)[0]
+				if target.arch == "386" && strings.Contains(op, "SQ") {
+					continue
+				}
+				name := fmt.Sprintf("ScalarConversionObject%d", count)
+				result, store, resultBytes := "uintptr", move+" BX", word
+				if strings.HasSuffix(op, "SS") {
+					result, store, resultBytes = "float32", "MOVSS X1", 4
+				} else if strings.HasSuffix(op, "SD") {
+					result, store, resultBytes = "float64", "MOVSD X1", 8
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\n%s input+%d(FP),CX\nPXOR X0,X0\nPXOR X1,X1\n%s\n%s,ret+%d(FP)\nRET\n",
+					name, 2*word+resultBytes, move, move, word, fixture.witness.Instruction, store, 2*word)
+				fmt.Fprintf(&declarations, "func %s(p *[8]byte,input uintptr) %s\n", name, result)
+				count++
+			}
+			want := 24
+			if target.arch == "386" {
+				want = 12
+			}
+			if count != want || count > 32 {
+				t.Fatal("initialized original conversion inventory changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original scalar conversion rejected", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_official_legacy_scalar_conversion_rows_test.go b/x86_official_legacy_scalar_conversion_rows_test.go
new file mode 100644
index 000000000..46ca13bec
--- /dev/null
+++ b/x86_official_legacy_scalar_conversion_rows_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func scalarConversion12OriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	type sample struct {
+		name, table, prefix string
+		fromFloat           bool
+	}
+	samples := []sample{
+		{"CVTSD2SL", "yxcvfl", "f20f2d", true},
+		{"CVTSD2SQ", "yxcvfq", "f2480f2d", true},
+		{"CVTSS2SL", "yxcvfl", "f30f2d", true},
+		{"CVTSS2SQ", "yxcvfq", "f3480f2d", true},
+		{"CVTTSD2SL", "yxcvfl", "f20f2c", true},
+		{"CVTTSD2SQ", "yxcvfq", "f2480f2c", true},
+		{"CVTTSS2SL", "yxcvfl", "f30f2c", true},
+		{"CVTTSS2SQ", "yxcvfq", "f3480f2c", true},
+		{"CVTSL2SD", "yxcvlf", "f20f2a", false},
+		{"CVTSQ2SD", "yxcvqf", "f2480f2a", false},
+		{"CVTSL2SS", "yxcvlf", "f30f2a", false},
+		{"CVTSQ2SS", "yxcvqf", "f3480f2a", false},
+	}
+	entries := map[string]goasmrules.X86LegacyOpcode{}
+	for _, entry := range catalog.Optab {
+		for _, sample := range samples {
+			if entry.Opcode == sample.name {
+				if _, dup := entries[entry.Opcode]; dup {
+					t.Fatal("duplicate original table")
+				}
+				entries[entry.Opcode] = entry
+			}
+		}
+	}
+	if len(entries) != 12 {
+		t.Fatal("missing complete original conversion family")
+	}
+	var cases []x86OfficialPackedCase
+	for _, sample := range samples {
+		entry := entries[sample.name]
+		if entry.Ytab != sample.table || len(entry.Rows) != 1 {
+			t.Fatal("original row ownership changed", entry)
+		}
+		operands := []string{"CX,X1", "0(SI),X1"}
+		modrm := []string{"c9", "0e"}
+		if sample.fromFloat {
+			operands = []string{"X0,BX", "0(SI),BX"}
+			modrm = []string{"d8", "1e"}
+		}
+		for index, args := range operands {
+			instruction := sample.name + " " + args
+			encoding, err := hex.DecodeString(sample.prefix + modrm[index])
+			if err != nil {
+				t.Fatal(err)
+			}
+			cases = append(cases, x86OfficialPackedCase{row: fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab), witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: encoding, Destination: strings.Split(args, ",")[1]}})
+		}
+	}
+	return cases
+}
+
+func TestX86LegacyScalarConversionOriginalGoBytesAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := scalarConversion12OriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			var cases []x86OfficialPackedCase
+			for _, original := range originals {
+				instruction := original.witness.Instruction
+				wide := strings.Contains(strings.Fields(instruction)[0], "SQ")
+				if arch == "386" && wide {
+					t.Run("Q-refusal/"+instruction, func(t *testing.T) {
+						listing, err := x86ScalarLiteralExpectedGoListing(t, arch, "TEXT ·NoQ(SB),4,$0-0\n"+instruction+"\nRET\n", false)
+						t.Logf("ORIGINAL_SCALAR_CONVERSION_Q_REFUSAL arch=%s source=%q exit=%v diagnostic=%q", arch, instruction, err, listing)
+					})
+					continue
+				}
+				fixture := original
+				fixture.symbol = fmt.Sprintf("ScalarConversion%d", len(cases))
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", fixture.symbol)
+				fixture.line = strings.Count(source.String(), "\n") + 1
+				fmt.Fprintln(&source, instruction)
+				source.WriteString("RET\n")
+				cases = append(cases, fixture)
+			}
+			want := 24
+			if arch == "386" {
+				want = 12
+			}
+			if len(cases) != want || len(cases) > 32 {
+				t.Fatal("whole-mode byte witness inventory changed", len(cases))
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+				t.Fatal("independent original conversion bytes", err)
+			}
+		})
+	}
+}
+
+func TestX86LegacyScalarConversionCompleteSourceJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := scalarConversion12OriginalCases(t, catalog)
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86LegacyScalarConversionRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expected := map[string]x86OfficialPackedCase{}
+		for _, fixture := range originals {
+			if arch == "386" && strings.Contains(strings.Fields(fixture.witness.Instruction)[0], "SQ") {
+				continue
+			}
+			key := fixture.row + "/" + fixture.witness.Instruction
+			if _, duplicate := expected[key]; duplicate {
+				t.Fatal("duplicate independent source fixture", key)
+			}
+			expected[key] = fixture
+		}
+		filtered := 0
+		for _, row := range rows {
+			if row.ModeFiltered != "" {
+				if arch != "386" || !strings.Contains(row.Opcode, "SQ") || len(row.Witnesses) != 0 {
+					t.Fatal("original mode restriction changed", row)
+				}
+				filtered++
+				continue
+			}
+			if len(row.Witnesses) != 2 {
+				t.Fatal("source row lost register/memory alternatives", row)
+			}
+			for _, w := range row.Witnesses {
+				key := row.ID + "/" + w.Instruction
+				original, found := expected[key]
+				if !found || !bytes.Equal(original.witness.Encoding, w.Encoding) || original.witness.Destination != w.Destination {
+					t.Fatal("source ID/bytes/direction differ from independent Go fixture", key, w, original)
+				}
+				delete(expected, key)
+			}
+		}
+		wantFiltered := 0
+		if arch == "386" {
+			wantFiltered = 6
+		}
+		if len(rows) != 12 || filtered != wantFiltered || len(expected) != 0 {
+			t.Fatal("incomplete original scalar conversion mode join", arch, len(rows), filtered, len(expected))
+		}
+		modes[arch] = rows
+	}
+	if _, err := goasmrules.X86LegacyScalarConversionRows(catalog, "arm64"); err == nil {
+		t.Fatal("foreign mode accepted")
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_LEGACY_SCALAR_CONVERSION_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
diff --git a/x86_official_legacy_shift_rotate_rows_test.go b/x86_official_legacy_shift_rotate_rows_test.go
new file mode 100644
index 000000000..644177fa4
--- /dev/null
+++ b/x86_official_legacy_shift_rotate_rows_test.go
@@ -0,0 +1,360 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86LegacyShiftRotateCompleteSourceRecords(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	names, group2, double, q := map[string]bool{}, 0, 0, 0
+	for _, entry := range catalog.Optab {
+		if entry.Ytab != "yshb" && entry.Ytab != "yshl" {
+			continue
+		}
+		names[entry.Opcode] = true
+		group2 += len(entry.Rows)
+		if strings.HasSuffix(entry.Opcode, "Q") {
+			q += len(entry.Rows)
+		}
+	}
+	for _, row := range catalog.Movtab {
+		if row.Code != "movDoubleShift" {
+			continue
+		}
+		if !names[row.Opcode] || row.From3 != "Yrl" || row.To != "Yml" {
+			t.Fatal("foreign double-shift roles", row)
+		}
+		double++
+		if strings.HasSuffix(row.Opcode, "Q") {
+			q++
+		}
+	}
+	if len(names) != 32 || group2 != 120 || double != 18 || q != 38 {
+		t.Fatal("complete legacy closure changed", len(names), group2, double, q)
+	}
+}
+
+func TestX86LegacyShiftRotateFirstMatchAndCLActualGoBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		var cases []x86OfficialPackedCase
+		for _, anchor := range []struct {
+			row  string
+			code []byte
+		}{
+			{"SHLL $0,AX", []byte{0xc1, 0xe0, 0}},
+			{"SHLL $1,AX", []byte{0xd1, 0xe0}},
+			{"SHLL $7,AX", []byte{0xc1, 0xe0, 7}},
+			{"SALL $1,AX", []byte{0xd1, 0xe0}},
+			{"SHLL CL,AX", []byte{0xd3, 0xe0}},
+			{"SHLL CX,AX", []byte{0xd3, 0xe0}},
+			{"SHLB CL,BL", []byte{0xd2, 0xe3}},
+			{"SHLB CX,BL", []byte{0xd2, 0xe3}},
+			{"SHLW $1,AX,BX", []byte{0x66, 0x0f, 0xa4, 0xc3, 1}},
+			{"SHLW $-1,AX,BX", []byte{0x66, 0x0f, 0xa4, 0xc3, 0xff}},
+			{"SHLW CL,AX,BX", []byte{0x66, 0x0f, 0xa5, 0xc3}},
+			{"SHLW CX,AX,BX", []byte{0x66, 0x0f, 0xa5, 0xc3}},
+		} {
+			name := fmt.Sprint("ShiftAnchor", len(cases))
+			line := strings.Count(source.String(), "\n") + 2
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, anchor.row)
+			cases = append(cases, x86OfficialPackedCase{row: "independent/legacy-shift/" + anchor.row, symbol: name, line: line,
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: anchor.row, Encoding: anchor.code}})
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("first-match/SAL/SHL/CL/CX byte identity", arch, err)
+		}
+	}
+}
+
+func TestX86LegacyShiftRotateExistingObservableProducer(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "Q", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "L", "i386-unknown-linux-gnu"
+		}
+		var source, declarations strings.Builder
+		for index, row := range []struct {
+			instruction string
+			mask        uint64
+		}{
+			{"SHLL $0,BX", 0x8d5}, {"SHLL $1,BX", 0x8c5}, {"SHLL $7,BX", 0xc5},
+			{"RCLL CX,BX", 0xd5}, {"SHRB CX,BL", 0xc4},
+			{"SHLW $16,AX,BX", 0xc5}, {"SHLW CX,AX,BX", 0},
+		} {
+			name := fmt.Sprint("ShiftProof", index)
+			fmt.Fprintf(&declarations, "func %s(memory *[16]byte,old,value,count uintptr) (data,flags uintptr)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),SI\nMOV%s old+%d(FP),BX\nMOV%s value+%d(FP),AX\nMOV%s count+%d(FP),CX\nCMPL AX,AX\nCLC\n%s\nMOV%s BX,data+%d(FP)\nPUSHF%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,flags+%d(FP)\nRET\n",
+				name, word*6, move, move, word, move, word*2, move, word*3, row.instruction, move, word*4, move, move, move, row.mask, move, word*5)
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("existing initialized data/count/CF and scoped status producer", arch, api, err)
+			}
+			x86ResultInitializationObject(t, llc, triple, ir, "legacy-shift-existing-"+api)
+		}
+	}
+}
+
+func x86OfficialScalarShiftAssembly(cases []x86OfficialPackedCase, witnesses []goasmrules.X86ScalarRMWWitness, arch string) (string, string) {
+	word, move := 8, "Q"
+	if arch == "386" {
+		word, move = 4, "L"
+	}
+	var source, declarations strings.Builder
+	for index, witness := range witnesses {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprint("ShiftRow", index)
+		opcode, operands, _ := strings.Cut(witness.Instruction, " ")
+		bits := map[byte]int{'B': 8, 'W': 16, 'L': 32, 'Q': 64}[opcode[len(opcode)-1]]
+		choice := bits == 16 && strings.Count(operands, ",") == 2 && !strings.HasPrefix(operands, "$")
+		metadata := x86ShiftMemoryRuntimeMetadata(x86ShiftMemoryOracle{text: witness.Instruction, bits: bits, valueChoice: choice})
+		result, size := "(data,flags uintptr)", word*6
+		if witness.Destination == "0(SI)" {
+			result, size = "(flags uintptr)", word*5
+		}
+		fmt.Fprintf(&declarations, "func %s(memory *[16]byte,old,value,count uintptr) %s\n", fixture.symbol, result)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),SI\nMOV%s old+%d(FP),BX\nMOV%s value+%d(FP),AX\nMOV%s count+%d(FP),CX\nCMPL AX,AX\nCLC\n",
+			fixture.symbol, size, move, move, word, move, word*2, move, word*3)
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, witness.Instruction)
+		flagOffset := word * 4
+		if witness.Destination != "0(SI)" {
+			fmt.Fprintf(&source, "MOV%s BX,data+%d(FP)\n", move, word*4)
+			flagOffset += word
+		}
+		fmt.Fprintf(&source, "PUSHF%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,flags+%d(FP)\nRET\n",
+			move, move, move, metadata.flags, move, flagOffset)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86LegacyShiftRotateRowsSelectedGoBytesThreeAPIObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct {
+		arch, triple     string
+		selected, shapes int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 138, 356},
+		{"386", "i386-unknown-linux-gnu", 100, 264},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarShiftRotateRows(catalog, mode.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var cases []x86OfficialPackedCase
+			var witnesses []goasmrules.X86ScalarRMWWitness
+			selected := 0
+			for _, row := range rows {
+				if row.ModeFiltered != "" {
+					continue
+				}
+				selected++
+				for _, witness := range row.Witnesses {
+					cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+					witnesses = append(witnesses, witness)
+				}
+			}
+			if len(rows) != 138 || selected != mode.selected || len(witnesses) != mode.shapes {
+				t.Fatal("shift source/mode/witness denominator changed", len(rows), selected, len(witnesses))
+			}
+			for start := 0; start < len(cases); start += 32 {
+				end := start + 32
+				if end > len(cases) {
+					end = len(cases)
+				}
+				t.Run(fmt.Sprintf("batch%02d", start/32), func(t *testing.T) {
+					batch := cases[start:end]
+					source, declarations := x86OfficialScalarShiftAssembly(batch, witnesses[start:end], mode.arch)
+					listing, err := x86ScalarLiteralGoListing(t, mode.arch, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+						t.Fatal("selected original Go shift row bytes", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declarations, mode.arch, mode.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized count/data/carry/status continuation", api, err)
+								return
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, mode.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86LegacyShiftRotateShadowsAliasesAndMode(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86ScalarShiftRotateRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		group2, doubles := map[string][]goasmrules.X86ScalarRMWRow{}, map[string][]goasmrules.X86ScalarRMWRow{}
+		for _, row := range rows {
+			if row.ModeFiltered != "" {
+				continue
+			}
+			if strings.HasPrefix(row.ID, "optab/") {
+				group2[row.Opcode] = append(group2[row.Opcode], row)
+			} else {
+				doubles[row.Opcode] = append(doubles[row.Opcode], row)
+			}
+		}
+		var source strings.Builder
+		var cases []x86OfficialPackedCase
+		add := func(from, selected goasmrules.X86ScalarRMWRow) {
+			for _, w := range selected.Witnesses {
+				name := fmt.Sprint("ShiftShadow", len(cases))
+				line := strings.Count(source.String(), "\n") + 2
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", name, w.Instruction)
+				cases = append(cases, x86OfficialPackedCase{row: from.ID + " -> " + selected.ID, symbol: name, line: line,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: w.Instruction, Encoding: w.Encoding}})
+			}
+		}
+		// Original table order owns these alternatives. A matching alternative
+		// is not a second hit on the later source row.
+		for _, entry := range catalog.Optab {
+			g := group2[entry.Opcode]
+			if len(g) == 0 {
+				continue
+			}
+			add(g[1], g[0])
+			if entry.Ytab == "yshl" {
+				add(g[3], g[2])
+			}
+		}
+		for _, entry := range catalog.Movtab {
+			g := doubles[entry.Opcode]
+			if entry.Code == "movDoubleShift" && entry.From == "Ycx" && len(g) != 0 {
+				add(g[2], g[1])
+			}
+		}
+		want := 124
+		if arch == "386" {
+			want = 88
+		}
+		if len(cases) != want {
+			t.Fatal("shadow selection denominator changed", arch, len(cases), want)
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("actual Go shift first-match selection", err)
+		}
+		for _, fixture := range cases {
+			t.Logf("SHIFT_GO_SELECTION arch=%s mapping=%q source=%q encoding=%x", arch, fixture.row, fixture.witness.Instruction, fixture.witness.Encoding)
+		}
+	}
+	rows, err := goasmrules.X86ScalarShiftRotateRows(catalog, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	q := 0
+	for _, row := range rows {
+		if !strings.HasSuffix(row.Opcode, "Q") {
+			continue
+		}
+		q++
+		t.Run(row.ID, func(t *testing.T) {
+			if len(row.Witnesses) == 0 {
+				t.Fatal("Q source lost its valid amd64 spelling")
+			}
+			listing, _ := x86ScalarLiteralExpectedGoListing(t, "386", "TEXT f(SB),4,$0-0\n"+row.Witnesses[0].Instruction+"\nRET\n", false)
+			t.Logf("SHIFT_GO_MODE_REJECTION row=%q source=%q diagnostic=%q", row.ID, row.Witnesses[0].Instruction, listing)
+		})
+	}
+	if q != 38 {
+		t.Fatal("Q source mode boundary changed", q)
+	}
+}
+
+func TestX86LegacyShiftRotateObservableInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "Q", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "L", "i386-unknown-linux-gnu"
+		}
+		for _, control := range []string{"complete", "missing-old", "missing-count", "missing-carry", "missing-double-data", "unmasked-flags", "expired-popped-bits"} {
+			t.Run(arch+"/"+control, func(t *testing.T) {
+				instruction := "RCLL CX,BX"
+				if control == "missing-double-data" {
+					instruction = "SHLL $1,AX,BX"
+				}
+				w := goasmrules.X86ScalarRMWWitness{Instruction: instruction, Destination: "BX"}
+				cases := []x86OfficialPackedCase{{row: "independent/shift-input/" + control}}
+				source, declaration := x86OfficialScalarShiftAssembly(cases, []goasmrules.X86ScalarRMWWitness{w}, arch)
+				from, to := "", ""
+				switch control {
+				case "missing-old":
+					from = fmt.Sprintf("MOV%s old+%d(FP),BX\n", move, word)
+				case "missing-count":
+					from = fmt.Sprintf("MOV%s count+%d(FP),CX\n", move, word*3)
+				case "missing-carry":
+					from = "CMPL AX,AX\nCLC\n"
+				case "missing-double-data":
+					from = fmt.Sprintf("MOV%s value+%d(FP),AX\n", move, word*2)
+				case "unmasked-flags":
+					from = fmt.Sprintf("AND%s $213,AX\n", move)
+				case "expired-popped-bits":
+					from = fmt.Sprintf("POP%s AX\nAND%s", move, move)
+					to = fmt.Sprintf("POP%s AX\nNOP\nAND%s", move, move)
+				}
+				if from != "" {
+					if strings.Count(source, from) != 1 {
+						t.Fatal("mutation not bound to one producer fragment", control, source)
+					}
+					source = strings.Replace(source, from, to, 1)
+				}
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					pass := control == "complete"
+					if pass && (err != nil || ir == "") || !pass && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+						t.Fatal("source count/data/CF/status proof changed", api, control, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_official_legacy_x87_rows_test.go b/x86_official_legacy_x87_rows_test.go
new file mode 100644
index 000000000..0aba75f30
--- /dev/null
+++ b/x86_official_legacy_x87_rows_test.go
@@ -0,0 +1,359 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// These source-shape witnesses prove Go row selection only. They are not
+// initialized public functions or executable x87 values. In particular Go's
+// botch rows can assemble without identifying a valid numerical operation.
+func x86X87OriginalSourceCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows, shadows := 0, 0
+	for _, entry := range catalog.Optab {
+		switch entry.Ytab {
+		case "yfmvx", "yfadd", "yfcmv", "ycompp":
+		default:
+			continue
+		}
+		for _, row := range entry.Rows {
+			rows++
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			if row.UnmatchedOffset < 0 || row.UnmatchedOffset+2 > len(entry.OpBytes) {
+				t.Fatal("original x87 source payload is incomplete", id)
+			}
+			opcode, err := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset], 0, 8)
+			if err != nil {
+				t.Fatal(id, err)
+			}
+			fragment, err := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset+1], 0, 8)
+			if err != nil {
+				t.Fatal(id, err)
+			}
+			appendCase := func(instruction string, modrm byte, displacement ...byte) {
+				code := append([]byte{byte(opcode), modrm}, displacement...)
+				cases = append(cases, x86OfficialPackedCase{row: id,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Encoding: code}})
+			}
+			switch row.ZCase + "/" + strings.Join(row.Classes, ",") {
+			case "Zm_o/Ym,Yf0":
+				appendCase(entry.Opcode+" (AX),F0", byte(fragment<<3))
+				appendCase(entry.Opcode+" 7(AX),F0", byte(0x40|fragment<<3), 7)
+			case "Zm_o/Yrf,Yf0":
+				for _, lane := range []byte{1, 7} {
+					appendCase(fmt.Sprintf("%s F%d,F0", entry.Opcode, lane), byte(0xc0|lane|byte(fragment<<3)))
+				}
+			case "Zo_m/Yf0,Yrf":
+				for _, lane := range []byte{1, 7} {
+					// asmando ORs the full source field fragment. FUCOMPP's
+					// decimal 13 is not a three-bit /digit or a REX extension.
+					appendCase(fmt.Sprintf("%s F0,F%d", entry.Opcode, lane), byte(0xc0|lane|byte(fragment<<3)))
+				}
+			default:
+				t.Fatal("unmodeled original x87 operand shape", id, row)
+			}
+		}
+		if entry.Ytab == "yfadd" {
+			// F0,F0 selects the earlier Yrf,F0 row, never the overlapping
+			// F0,Yrf row. Retain its true source ID as a separate control.
+			row := entry.Rows[1]
+			opcode, firstErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset], 0, 8)
+			fragment, lastErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset+1], 0, 8)
+			if firstErr != nil || lastErr != nil {
+				t.Fatal("alias source payload", firstErr, lastErr)
+			}
+			cases = append(cases, x86OfficialPackedCase{
+				row:     fmt.Sprintf("optab/%d/%s/%s/%d/shadows-row2", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex),
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " F0,F0", Encoding: []byte{byte(opcode), byte(0xc0 | fragment<<3)}},
+			})
+			shadows++
+		}
+	}
+	if rows != 79 || shadows != 8 || len(cases) != 166 {
+		t.Fatal("complete x87 source row/alias union changed", rows, shadows, len(cases))
+	}
+	return cases
+}
+
+func TestX86OfficialLegacyX87OriginalGoRowsAndFirstMatch(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := make(map[string][]goasmrules.X86X87Row)
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86X87OriginalSourceCases(t, catalog)
+		rows, err := goasmrules.X86X87Rows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		expected := make(map[string]x86OfficialPackedCase, len(cases))
+		for _, fixture := range cases {
+			expected[fixture.row+"/"+fixture.witness.Instruction] = fixture
+		}
+		witnesses := 0
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				original, found := expected[row.ID+"/"+witness.Instruction]
+				if !found || !bytes.Equal(original.witness.Encoding, witness.Encoding) {
+					t.Fatal("new x87 transport changed its independent original source witness", row.ID, witness)
+				}
+				witnesses++
+			}
+		}
+		if len(rows) != 79 || witnesses != 158 {
+			t.Fatal("explicit x87 source transport union changed", arch, len(rows), witnesses)
+		}
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				batch := cases[start:end]
+				var source strings.Builder
+				line := 1
+				for index := range batch {
+					fixture := &batch[index]
+					fixture.symbol = fmt.Sprintf("X87Original%d", start+index)
+					fixture.line = line + 1
+					body := fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", fixture.symbol, fixture.witness.Instruction)
+					source.WriteString(body)
+					line += strings.Count(body, "\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal("actual Go did not accept the complete original source-format batch", err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("actual Go x87 source row, full ModRM fragment or first-match bytes differ", err)
+				}
+			})
+		}
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_X87_ROW_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86X87Row
+		}{catalog, modes})
+	}
+}
+
+// These objects exercise the existing instruction emitter, including the botch
+// encodings. They provide neither numerical witnesses nor public input facts.
+// Batch the original operations so compiler count follows format groups rather
+// than the number of source rows, lanes and object targets multiplied together.
+func TestX86OfficialLegacyX87OriginalEmitterObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86X87OriginalSourceCases(t, catalog)
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				var source strings.Builder
+				source.WriteString("TEXT ·X87OriginalEmitter(SB),4,$0-0\n")
+				for _, fixture := range cases[start:end] {
+					source.WriteString("FINIT\n")
+					source.WriteString(fixture.witness.Instruction)
+					source.WriteByte('\n')
+				}
+				source.WriteString("RET\n")
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal("complete original emitter source did not parse", err)
+				}
+				for _, triple := range x86Legacy127Targets(arch) {
+					ir := x86X87LowererObjectUnit(t, file, arch, triple)
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+					}
+				}
+				t.Logf("private emitter only: retained %d exact original row/alias operations; no execution claim", end-start)
+			})
+		}
+	}
+}
+
+func x86X87MoveOriginalSourceCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows, controls := 0, 0
+	for _, entry := range catalog.Optab {
+		switch entry.Ytab {
+		case "yfmvd", "yfmvdp", "yfmvf", "yfmvp":
+		default:
+			continue
+		}
+		for _, row := range entry.Rows {
+			rows++
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			if len(row.Classes) != 2 || row.UnmatchedOffset < 0 || row.UnmatchedOffset+2 > len(entry.OpBytes) {
+				t.Fatal("incomplete original MOVE source row", id)
+			}
+			opcode, firstErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset], 0, 8)
+			fragment, lastErr := strconv.ParseUint(entry.OpBytes[row.UnmatchedOffset+1], 0, 8)
+			if firstErr != nil || lastErr != nil {
+				t.Fatal("original MOVE source payload", id, firstErr, lastErr)
+			}
+			memory := row.Classes[0] == "Ym" || row.Classes[1] == "Ym"
+			for _, lane := range []byte{1, 7} {
+				first, last := fmt.Sprint("F", lane), "F0"
+				code := []byte{byte(opcode), 0xc0 | lane | byte(fragment<<3)}
+				if memory {
+					first, code = "(AX)", []byte{byte(opcode), byte(fragment << 3)}
+					if lane == 7 {
+						first, code = "7(AX)", []byte{byte(opcode), 0x40 | byte(fragment<<3), 7}
+					}
+				}
+				if row.ZCase == "Zo_m" {
+					first, last = last, first
+				}
+				cases = append(cases, x86OfficialPackedCase{row: id,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " " + first + "," + last, Destination: last, Encoding: code}})
+			}
+			// The non-pop F0,F0 alias selects yfmvd row2 before row3.
+			// The pop alias selects yfmvdp's actual register row1.
+			if entry.Ytab == "yfmvd" && row.RowIndex == 2 || entry.Ytab == "yfmvdp" && row.RowIndex == 1 {
+				cases = append(cases, x86OfficialPackedCase{row: id + "/F0-control",
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " F0,F0", Encoding: []byte{byte(opcode), 0xc0 | byte(fragment<<3)}}})
+				controls++
+			}
+		}
+	}
+	if rows != 18 || controls != 2 || len(cases) != 38 {
+		t.Fatal("complete remaining MOVE source union changed", rows, controls, len(cases))
+	}
+	return cases
+}
+
+func TestX86OfficialLegacyX87MoveOriginalGoRowsAndFirstMatch(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := make(map[string][]goasmrules.X86X87Row)
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86X87MoveOriginalSourceCases(t, catalog)
+		rows, err := goasmrules.X86X87MoveRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		expected := make(map[string]goasmrules.X86PackedBinaryWitness, len(cases))
+		for _, fixture := range cases {
+			expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+		}
+		witnesses := 0
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				original, found := expected[key]
+				if !found || !bytes.Equal(original.Encoding, witness.Encoding) || original.Destination != witness.Destination {
+					t.Fatal("MOVE transport differs from the independent actual-Go fixture", key, original, witness)
+				}
+				delete(expected, key)
+				witnesses++
+			}
+		}
+		if len(rows) != 18 || witnesses != 36 || len(expected) != 2 {
+			t.Fatal("complete MOVE row/witness/first-match union changed", arch, len(rows), witnesses, len(expected))
+		}
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				batch := cases[start:end]
+				var source strings.Builder
+				line := 1
+				for index := range batch {
+					fixture := &batch[index]
+					fixture.symbol = fmt.Sprintf("X87MoveOriginal%d", start+index)
+					fixture.line = line + 1
+					body := fmt.Sprintf("TEXT ·%s(SB),4,$0-0\n%s\nRET\n", fixture.symbol, fixture.witness.Instruction)
+					source.WriteString(body)
+					line += strings.Count(body, "\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal("actual Go refused the original MOVE row/alias batch", err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("actual Go MOVE direction, pop or first-match bytes differ", err)
+				}
+			})
+		}
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_X87_MOVE_ROW_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86X87Row
+		}{catalog, modes})
+	}
+}
+
+func TestX86OfficialLegacyX87MoveOriginalEmitterObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	objects := 0
+	for _, arch := range []string{"amd64", "386"} {
+		cases := x86X87MoveOriginalSourceCases(t, catalog)
+		for start := 0; start < len(cases); start += 32 {
+			end := start + 32
+			if end > len(cases) {
+				end = len(cases)
+			}
+			t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+				var source strings.Builder
+				source.WriteString("TEXT ·X87MoveEmitter(SB),4,$0-0\n")
+				for _, fixture := range cases[start:end] {
+					source.WriteString("FINIT\n")
+					source.WriteString(fixture.witness.Instruction)
+					source.WriteByte('\n')
+				}
+				source.WriteString("RET\n")
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, triple := range x86Legacy127Targets(arch) {
+					ir := x86X87LowererObjectUnit(t, file, arch, triple)
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, ir, level)
+						objects++
+					}
+				}
+				t.Logf("private emitter only: retained %d original MOVE row/alias operations; no numerical or execution claim", end-start)
+			})
+		}
+	}
+	if objects != 20 {
+		t.Fatal("complete five-target O0/O2 MOVE object matrix changed", objects)
+	}
+}
diff --git a/x86_official_media_x87_remainder_rows_test.go b/x86_official_media_x87_remainder_rows_test.go
new file mode 100644
index 000000000..0b4c366cb
--- /dev/null
+++ b/x86_official_media_x87_remainder_rows_test.go
@@ -0,0 +1,265 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The reference follows original source prefix, mediaop, literal and asmando
+// emission. It does not invoke a production witness formatter. In particular,
+// non-temporal GP-register destinations are Go-byte observations, not valid
+// CPU instructions or initialized numerical/native positives.
+func mediaX87OriginalSourceCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows := 0
+	for _, entry := range catalog.Optab {
+		switch entry.Ytab {
+		case "yxcvm1", "yxcvm2", "ylddqu", "yxr", "ymr", "yxr_ml", "ymr_ml", "ymrxr", "ymmxmm0f38", "ymshuf", "yfxch", "ystsw":
+		default:
+			continue
+		}
+		atoms := make([]byte, len(entry.OpBytes))
+		for index, token := range entry.OpBytes {
+			value, err := strconv.ParseUint(token, 0, 8)
+			if err != nil {
+				var found bool
+				atoms[index], found = map[string]byte{"Pe": 0x66, "Pm": 0x0f, "Pf2": 0xf2, "Pf3": 0xf3}[token]
+				if !found {
+					t.Fatal("independent original media atom changed", entry, token)
+				}
+			} else {
+				atoms[index] = byte(value)
+			}
+		}
+		for _, row := range entry.Rows {
+			rows++
+			prefix, found := map[string][]byte{
+				"Px": {}, "Pm": {0x0f}, "Pe": {0x66}, "Pf2": {0xf2, 0x0f},
+				"Pf3": {0xf3, 0x0f}, "Pq4": {0x66, 0x0f, 0x38},
+			}[entry.Prefix]
+			cursor := row.UnmatchedOffset
+			if !found || cursor < 0 || cursor >= len(atoms) {
+				t.Fatal("independent original prefix/row offset changed", entry, row)
+			}
+			code := append([]byte(nil), prefix...)
+			if atoms[cursor] == 0x0f {
+				code = append(code, 0x0f)
+				cursor++
+			}
+			if cursor >= len(atoms) {
+				t.Fatal("independent original selected opcode missing", entry, row)
+			}
+			switch row.ZCase {
+			case "Zlit", "Zlitm_r", "Zibm_r":
+				// FSTSW's final literal uses the implicit zero cells of
+				// Go's fixed opBytes array; other rows have an explicit zero.
+				for cursor < len(atoms) && atoms[cursor] != 0 {
+					code = append(code, atoms[cursor])
+					cursor++
+				}
+			case "Zm_r_xm", "Zr_m_xm":
+				mediaPrefix := atoms[cursor]
+				if row.ZOffset != 1 && (mediaPrefix == 0x66 || mediaPrefix == 0x0f || mediaPrefix == 0xf2 || mediaPrefix == 0xf3) {
+					if mediaPrefix != 0x0f {
+						code = append(code, mediaPrefix)
+					}
+					code = append(code, 0x0f)
+					cursor++
+				} else if len(code) == 0 || code[len(code)-1] != 0x0f {
+					code = append(code, 0x0f)
+				}
+				if cursor >= len(atoms) {
+					t.Fatal("independent mediaop missing its selected opcode", entry, row)
+				}
+				code = append(code, atoms[cursor])
+			case "Zm_r", "Zm_o", "Zo_m":
+				code = append(code, atoms[cursor])
+			default:
+				t.Fatal("independent original media Z-case changed", entry, row)
+			}
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			add := func(source, destination string, modrm byte, tail ...byte) {
+				encoding := append([]byte(nil), code...)
+				if row.ZCase != "Zlit" {
+					encoding = append(encoding, modrm)
+				}
+				encoding = append(encoding, tail...)
+				instruction := entry.Opcode + " " + destination
+				if source != "" {
+					instruction = entry.Opcode + " " + source + "," + destination
+				}
+				if entry.Ytab == "ymshuf" {
+					instruction = entry.Opcode + " $7," + source + "," + destination
+					encoding = append(encoding, 7)
+				}
+				cases = append(cases, x86OfficialPackedCase{row: id, witness: goasmrules.X86PackedBinaryWitness{
+					Instruction: instruction, Destination: destination, Encoding: encoding,
+				}})
+			}
+			switch strings.Join(row.Classes, ",") {
+			case "Yxm,Yxr":
+				add("X0", "X1", 0xc8)
+				add("(AX)", "X1", 0x08)
+			case "Yxm,Ymr":
+				add("X0", "M1", 0xc8)
+				add("(AX)", "M1", 0x08)
+			case "Ymm,Yxr":
+				// Memory matches the preceding Yxm,Yxr row. It is
+				// already observed there, never attributed to this row.
+				add("M0", "X1", 0xc8)
+			case "Yxr,Yxr", "Ymr,Yxr":
+				bank := "X0"
+				if row.Classes[0] == "Ymr" {
+					bank = "M0"
+				}
+				add(bank, "X1", 0xc8)
+			case "Ymr,Ymr":
+				add("M0", "M1", 0xc8)
+			case "Ym,Yxr":
+				add("(AX)", "X1", 0x08)
+			case "Yxr,Yml", "Ymr,Yml":
+				bank := "X0"
+				if row.Classes[0] == "Ymr" {
+					bank = "M0"
+				}
+				add(bank, "CX", 0xc1) // Go accepts this CPU-invalid store form.
+				add(bank, "(AX)", 0)
+			case "Ymm,Ymr", "Yi8,Ymm,Ymr":
+				add("M0", "M1", 0xc8)
+				add("(AX)", "M1", 0x08)
+			case "Yf0,Yrf", "Yrf,Yf0":
+				fragment := atoms[row.UnmatchedOffset+1]
+				for _, lane := range []byte{1, 7} {
+					first, last := "F0", fmt.Sprint("F", lane)
+					if row.Classes[0] == "Yrf" {
+						first, last = last, first
+					}
+					add(first, last, 0xc0|lane|fragment<<3)
+				}
+			case "Ym":
+				fragment := atoms[row.UnmatchedOffset+1]
+				add("", "(AX)", fragment<<3)
+				add("", "7(AX)", 0x40|fragment<<3, 7)
+			case "Yax":
+				add("", "AX", 0)
+			default:
+				t.Fatal("independent original media operand classes changed", entry, row)
+			}
+		}
+		if entry.Ytab == "yfxch" {
+			// F0,F0 selects the first direction even though both match.
+			cases = append(cases, x86OfficialPackedCase{
+				row: fmt.Sprintf("optab/%d/%s/yfxch/0/first-match", entry.TableIndex, entry.Opcode),
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode + " F0,F0", Destination: "F0",
+					Encoding: []byte{atoms[0], 0xc0 | atoms[1]<<3}},
+			})
+		}
+	}
+	if rows != 31 || len(cases) != 53 {
+		t.Fatal("complete media/x87 independent source row/case count changed", rows, len(cases))
+	}
+	return cases
+}
+
+func TestX86OfficialMediaX87OriginalGoRowsAndFirstMatch(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		x86LegacyLiteralSIMDCheckGoBatches(t, arch, mediaX87OriginalSourceCases(t, catalog))
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86LegacyMediaX87Rows(catalog, arch)
+		if err != nil {
+			t.Fatal("complete explicit source view failed after independent original-Go observations", arch, err)
+		}
+		expected := map[string]goasmrules.X86PackedBinaryWitness{}
+		for _, original := range mediaX87OriginalSourceCases(t, catalog) {
+			if strings.HasSuffix(original.row, "/first-match") {
+				continue // Independently assembled selection control, not another original row.
+			}
+			expected[original.row+"/"+original.witness.Instruction] = original.witness
+		}
+		witnesses := 0
+		for _, row := range rows {
+			if row.ModeFiltered != "" {
+				t.Fatal("source view filtered an actually assembled canonical mode", arch, row)
+			}
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				original, found := expected[key]
+				if !found || !bytes.Equal(original.Encoding, witness.Encoding) || original.Destination != witness.Destination {
+					t.Fatal("complete media/x87 source transport differs from independent actual Go", arch, key, witness, original)
+				}
+				delete(expected, key)
+				witnesses++
+			}
+		}
+		if len(rows) != 31 || witnesses != 52 || len(expected) != 0 {
+			t.Fatal("complete media/x87 original ID/witness join omitted or repeated source cases", arch, len(rows), witnesses, expected)
+		}
+		modes[arch] = rows
+	}
+	if !t.Failed() {
+		t.Log("MEDIA_X87_ACTUAL_GO original_rows=31 original_cases=52 first_match_controls=1 modes=2 exact_bytes=106")
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_MEDIA_X87_REMAINDER_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86ScalarRMWRow
+		}{catalog, modes})
+	}
+}
+
+func TestX86OfficialMediaX87OriginalGoSignedImmediateBoundaries(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var originals []x86OfficialPackedCase
+	for _, fixture := range mediaX87OriginalSourceCases(t, catalog) {
+		if strings.HasPrefix(fixture.witness.Instruction, "PSHUFW ") {
+			originals = append(originals, fixture)
+		}
+	}
+	if len(originals) != 2 {
+		t.Fatal("complete original PSHUFW carrier set changed", originals)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var accepted []x86OfficialPackedCase
+			for _, value := range []int{-128, -1, 0, 127} {
+				for _, original := range originals {
+					changed := original
+					changed.witness.Instruction = strings.Replace(original.witness.Instruction, "$7,", fmt.Sprintf("$%d,", value), 1)
+					changed.witness.Encoding = append([]byte(nil), original.witness.Encoding...)
+					changed.witness.Encoding[len(changed.witness.Encoding)-1] = byte(value)
+					accepted = append(accepted, changed)
+				}
+			}
+			x86LegacyLiteralSIMDCheckGoBatches(t, arch, accepted)
+			for _, value := range []int{-129, 128, 255, 256} {
+				for _, original := range originals {
+					instruction := strings.Replace(original.witness.Instruction, "$7,", fmt.Sprintf("$%d,", value), 1)
+					t.Run(instruction, func(t *testing.T) {
+						source := "TEXT ·Refused(SB),4,$0-0\n" + instruction + "\nRET\n"
+						listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+						if !strings.Contains(listing, "invalid instruction") || !strings.Contains(listing, "PSHUFW") {
+							t.Fatal("PSHUFW Yi8 refusal did not identify its actual original source grammar", listing)
+						}
+					})
+				}
+			}
+		})
+	}
+	if !t.Failed() {
+		t.Log("MEDIA_X87_SIGNED_IMMEDIATES observations=32 exact_bytes=16 actual_Yi8_refusals=16")
+	}
+}
diff --git a/x86_official_move_remainder_rows_test.go b/x86_official_move_remainder_rows_test.go
new file mode 100644
index 000000000..fc0cc238f
--- /dev/null
+++ b/x86_official_move_remainder_rows_test.go
@@ -0,0 +1,290 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86OfficialMoveRemainderRows(t *testing.T) []goasmrules.X86PackedBinaryRow {
+	t.Helper()
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86MoveRemainderRows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return rows
+}
+
+// Selection belongs to each register/memory alternative. In particular, a
+// load-row register alternative cannot claim the earlier store-row's bytes.
+func x86OfficialMoveRemainderShadowTarget(row goasmrules.X86PackedBinaryRow, w goasmrules.X86PackedBinaryWitness) string {
+	parts := strings.Split(row.ID, "/")
+	index, _ := strconv.Atoi(parts[4])
+	target := -1
+	switch parts[3] {
+	case "_yvmovq":
+		switch index {
+		case 1, 5:
+			if w.Destination == "(AX)" {
+				target = index - 1
+			}
+		case 3, 7:
+			target = index - 2
+			if w.Memory {
+				target++
+			}
+		}
+	case "_yvmovsd":
+		switch index {
+		case 3:
+			target = 0
+		case 10, 11:
+			target = index - 6
+		}
+	}
+	if target < 0 {
+		return ""
+	}
+	return fmt.Sprintf("/%s/%s/%d", row.Opcode, parts[3], target)
+}
+
+func x86OfficialMoveRemainderSelectedRows(rows []goasmrules.X86PackedBinaryRow, vexOnly bool) []goasmrules.X86PackedBinaryRow {
+	var selected []goasmrules.X86PackedBinaryRow
+	for _, row := range rows {
+		copy := row
+		copy.Witnesses = nil
+		for _, w := range row.Witnesses {
+			if x86OfficialMoveRemainderShadowTarget(row, w) == "" && (!vexOnly || w.Generation == "vex") {
+				copy.Witnesses = append(copy.Witnesses, w)
+			}
+		}
+		if len(copy.Witnesses) != 0 {
+			selected = append(selected, copy)
+		}
+	}
+	return selected
+}
+
+// Reuse existing bounded pointer and implicit-DI producers. Syntax fields do
+// not decide semantic output: GP results, memory stores and implicit stores
+// need their own observation. Full aliases also seed old scalar/merge bytes.
+func x86OfficialMoveRemainderAssembly(t *testing.T, arch string, cases []x86OfficialPackedCase) (string, string) {
+	t.Helper()
+	var source, declarations strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprint("MoveRemainder", index)
+		w := fixture.witness
+		parts := strings.Split(fixture.row, "/")
+		table := parts[3]
+		args := strings.Split(strings.Fields(w.Instruction)[1], ",")
+		var body, declaration string
+		if table == "_yvmaskmovdqu" {
+			mask, err := strconv.Atoi(args[0][1:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			data, err := strconv.Atoi(args[1][1:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			body, declaration = x86ImplicitMaskMoveOracleRegisters(arch, "VMASKMOVDQU", fixture.symbol, mask, data)
+		} else {
+			var initialization strings.Builder
+			seeded := map[string]bool{}
+			for _, arg := range args {
+				if len(arg) > 1 && strings.ContainsAny(arg[:1], "XYZ") && !seeded[arg[1:]] {
+					fmt.Fprintf(&initialization, "VMOVUPS (AX),Z%s\n", arg[1:])
+					seeded[arg[1:]] = true
+				}
+			}
+			if w.First == "CX" {
+				move := "MOVQ"
+				if table == "_yvmovd" || arch == "386" {
+					move = "MOVL"
+				}
+				fmt.Fprintf(&initialization, "%s (AX),CX\n", move)
+			}
+			result := w.Destination
+			if result == "(AX)" {
+				result = w.First
+			}
+			observation := "MOVL CX,CX"
+			if result != "CX" {
+				lane := 0
+				if table == "_yvmovhpd" || table == "_yvmovhlps" {
+					ins := x86ScalarLaneInstruction(t, w.Instruction)
+					form, known, err := x86MoveHalfProperties(ins.Op, ins, "amd64")
+					if !known || err != nil {
+						t.Fatal("half observer lost typed lane roles", err)
+					}
+					lane = form.outputLane * 2
+				}
+				observation = fmt.Sprintf("VPEXTRD $%d,X%s,CX", lane, result[1:])
+			}
+			body, declaration = x86PackedMoveInitializedInstruction(fixture.symbol, arch, initialization.String(), w.Instruction, observation)
+		}
+		matches := 0
+		for offset, instruction := range strings.Split(body, "\n") {
+			if instruction == w.Instruction {
+				fixture.line = line + offset
+				matches++
+			}
+		}
+		if matches != 1 {
+			t.Fatal("producer changed or duplicated the original instruction", fixture.row, w.Instruction)
+		}
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialMoveRemainderSelectedRowsThreeAPIObjects(t *testing.T) {
+	selected := func(legacy goasmrules.X86LegacyCatalog, avx []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+		rows, err := goasmrules.X86MoveRemainderRows(legacy, avx)
+		if err != nil {
+			return nil, err
+		}
+		if len(rows) != 101 {
+			return nil, fmt.Errorf("complete original move source rows changed: %d", len(rows))
+		}
+		return x86OfficialMoveRemainderSelectedRows(rows, false), nil
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86OfficialPackedRowsObjectsInspect(t, selected, 93, 105, 0,
+		func(cases []x86OfficialPackedCase) (string, string) {
+			return x86OfficialMoveRemainderAssembly(t, "amd64", cases)
+		}, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86OfficialMoveRemainderNamedShadowsRetainOriginalBytes(t *testing.T) {
+	rows := x86OfficialMoveRemainderRows(t)
+	count, full, partial := 0, 0, 0
+	for _, row := range rows {
+		shadowed := 0
+		for _, shadow := range row.Witnesses {
+			target := x86OfficialMoveRemainderShadowTarget(row, shadow)
+			if target == "" {
+				continue
+			}
+			var earlier *goasmrules.X86PackedBinaryWitness
+			for _, candidate := range rows {
+				if strings.HasSuffix(candidate.ID, target) {
+					for index := range candidate.Witnesses {
+						if candidate.Witnesses[index].Instruction == shadow.Instruction {
+							earlier = &candidate.Witnesses[index]
+						}
+					}
+				}
+			}
+			if earlier == nil || bytes.Equal(earlier.Encoding, shadow.Encoding) {
+				t.Fatal("shadow lost its distinct earlier original encoding", row.ID, shadow.Instruction)
+			}
+			fixtures := []x86OfficialPackedCase{{row: row.ID, witness: shadow}}
+			source, _ := x86OfficialMoveRemainderAssembly(t, "amd64", fixtures)
+			listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed := fixtures[0]
+			observed.witness = *earlier
+			if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{observed}); err != nil {
+				t.Fatal("actual Go changed original first-match selection", row.ID, target, err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, fixtures); err == nil {
+				t.Fatal("earlier bytes falsely counted as the shadowed source row", row.ID)
+			}
+			count++
+			shadowed++
+		}
+		if shadowed == len(row.Witnesses) {
+			full++
+		} else if shadowed != 0 {
+			partial++
+		}
+	}
+	if count != 14 || full != 8 || partial != 2 {
+		t.Fatal("complete move first-match alternatives changed", count, full, partial)
+	}
+}
+
+func TestX86OfficialMoveRemainderMode32LowBankObjectsAndHighBankContext(t *testing.T) {
+	rows := x86OfficialMoveRemainderRows(t)
+	low := func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error) {
+		return x86OfficialMoveRemainderSelectedRows(rows, true), nil
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86OfficialPackedRowsObjectsForTarget(t, "386", "i386-unknown-linux-gnu", low, 54, 58, 0,
+		func(cases []x86OfficialPackedCase) (string, string) {
+			return x86OfficialMoveRemainderAssembly(t, "386", cases)
+		}, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "i386-unknown-linux-gnu", ir, "-O2")
+		})
+	// Go's oclass accepts X/Y16..31 as Evex in 386, but Z8..31 is Yxxx;
+	// its parser also restricts four x86 operands to AMD64. Bind bare bytes or
+	// concrete rejection independently of producer seeds. Neither outcome
+	// supplies unavailable mode32 NUM aliases.
+	count, accepted, rejected := 0, 0, 0
+	boundaries := map[string]int{}
+	for _, row := range x86OfficialMoveRemainderSelectedRows(rows, false) {
+		for _, w := range row.Witnesses {
+			if w.Generation != "evex" {
+				continue
+			}
+			fixtures := []x86OfficialPackedCase{{row: row.ID, witness: w}}
+			source, declaration := x86OfficialMoveRemainderAssembly(t, "386", fixtures)
+			bare := "TEXT ·HighBank(SB),4,$0-0\n" + w.Instruction + "\nRET\n"
+			if w.Width == 512 || len(strings.Split(strings.Fields(w.Instruction)[1], ",")) == 4 {
+				goAssemblerOracleOutput(t, "386", bare, "", false)
+				rejected++
+			} else {
+				listing, err := x86ScalarLiteralGoListing(t, "386", bare)
+				if err != nil {
+					t.Fatal(err)
+				}
+				original := x86OfficialPackedCase{row: row.ID, symbol: "HighBank", line: 2, witness: w}
+				if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{original}); err != nil {
+					t.Fatal("Go386 accepted high-bank spelling changed physical bytes", err)
+				}
+				accepted++
+			}
+			boundaries[x86OfficialMoveRemainderMode32InstructionBoundary(t, row.ID, w)]++
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", "i386-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("mode32 high-bank source borrowed physical encoding as NUM input", row.ID, api, err)
+				}
+			}
+			count++
+		}
+	}
+	if count != 47 {
+		t.Fatal("complete late-EVEX mode32 source-context observations changed", count)
+	}
+	t.Logf("mode32 bare late-EVEX outcomes: %d actual byte identities, %d concrete Go Z-bank/arity rejections; direct mode guards=%d, grammar refusals=%d, paired low/high defined NUM controls=%d; initialized whole-source Context is separate",
+		accepted, rejected, boundaries["mode"], boundaries["grammar"], boundaries["NUM"])
+}
diff --git a/x86_official_move_rows_test.go b/x86_official_move_rows_test.go
new file mode 100644
index 000000000..c8ba84032
--- /dev/null
+++ b/x86_official_move_rows_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialMoveRowsThreeAPIsObjectsAndTerminalFaults(t *testing.T) {
+	cases := x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86PackedMoveRows, 144, 306, 0,
+		x86OfficialMoveAssembly, x86OfficialMoveInspectFaults)
+	faults, copies := 0, 0
+	for _, fixture := range cases {
+		if fixture.witness.Zeroing && fixture.witness.Destination == "(AX)" {
+			faults++
+		}
+		if !fixture.witness.Memory && fixture.witness.Destination != "(AX)" {
+			copies++
+		}
+	}
+	if faults != 30 || len(cases)-faults != 276 || copies != 102 {
+		t.Fatal("ordinary moves, terminal #UD and actual selected register rows were conflated", len(cases), faults, copies)
+	}
+	t.Log("AVX-only: 144 rows / 276 ordinary initialized witnesses + 30 terminal #UD controls; legacy remains separate")
+}
+
+func x86OfficialMoveAssembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declarations strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprint("MoveRow", index)
+		w := fixture.witness
+		var body, declaration string
+		if w.Zeroing && w.Destination == "(AX)" {
+			body = x86PackedZeroStoreInstruction("·"+fixture.symbol, w.Instruction)
+			declaration = fmt.Sprintf("func %s()\n", fixture.symbol)
+		} else {
+			result := w.Destination
+			if result == "(AX)" {
+				result = w.First
+			}
+			initialization := fmt.Sprintf("VMOVUPS (AX),Z%s\n", result[1:])
+			if !w.Memory && w.Destination != "(AX)" {
+				initialization = fmt.Sprintf("VMOVUPS (AX),Z%s\n", w.First[1:]) + initialization
+			}
+			body, declaration = x86PackedMoveInitializedInstruction(fixture.symbol, "amd64", initialization, w.Instruction, "VMOVD X"+result[1:]+",CX")
+		}
+		for offset, instruction := range strings.Split(body, "\n") {
+			if instruction == w.Instruction {
+				fixture.line = line + offset
+			}
+		}
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func x86OfficialMoveInspectFaults(t *testing.T, ir string, cases []x86OfficialPackedCase) {
+	t.Helper()
+	for _, fixture := range cases {
+		w := fixture.witness
+		if !w.Zeroing || w.Destination != "(AX)" {
+			continue
+		}
+		body, err := x86OfficialMoveFaultBody(ir, fixture.symbol)
+		if err != nil {
+			t.Fatal("terminal move lost its owned no-input #UD before object compilation", fixture.row, err)
+		}
+		t.Logf("terminal row=%s symbol=%s bodySHA=%x; one UD2, unreachable, zero input loads", fixture.row, fixture.symbol, sha256.Sum256([]byte(body)))
+	}
+}
+
+func x86OfficialMoveFaultBody(ir, symbol string) (string, error) {
+	definition := regexp.MustCompile(`(?m)^define [^\n]*@` + regexp.QuoteMeta(symbol) + `\(\)[^\n]*\{\n`).FindStringIndex(ir)
+	if definition == nil {
+		return "", fmt.Errorf("fault definition %s has inputs or is absent", symbol)
+	}
+	body, _, closed := strings.Cut(ir[definition[1]:], "\n}")
+	trap := `call void asm sideeffect "ud2", "~{memory}"()`
+	if !closed || strings.Count(body, trap) != 1 || !strings.HasSuffix(strings.TrimSpace(body), "unreachable") ||
+		strings.Contains(body, "load ") || strings.Contains(body, "@llvm.masked.") {
+		return "", fmt.Errorf("fault body %s lost its terminal no-input UD2: %s", symbol, body)
+	}
+	return body, nil
+}
+
+func TestX86OfficialMoveFaultInspectionRejectsAnotherFunctionsTrap(t *testing.T) {
+	const trap = "  call void asm sideeffect \"ud2\", \"~{memory}\"()\n  unreachable"
+	const valid = "define void @Fault() {\nentry:\n" + trap + "\n}\n"
+	if _, err := x86OfficialMoveFaultBody(valid, "Fault"); err != nil {
+		t.Fatal(err)
+	}
+	for _, invalid := range []string{
+		strings.Replace(valid, "@Fault", "@Other", 1) + "define void @Fault() {\n  ret void\n}\n",
+		strings.Replace(valid, "@Fault()", "@Fault(i64 %mask)", 1),
+		strings.Replace(valid, trap, "  %x = load i64, ptr null\n"+trap, 1),
+		strings.Replace(valid, "unreachable", "ret void", 1),
+		strings.Replace(valid, trap, trap+"\n"+trap, 1),
+	} {
+		if _, err := x86OfficialMoveFaultBody(invalid, "Fault"); err == nil {
+			t.Fatal("module-wide trap or input read substituted for the original terminal function", invalid)
+		}
+	}
+}
diff --git a/x86_official_movtab_remainder_rows_test.go b/x86_official_movtab_remainder_rows_test.go
new file mode 100644
index 000000000..7a93af595
--- /dev/null
+++ b/x86_official_movtab_remainder_rows_test.go
@@ -0,0 +1,355 @@
+// This observes Go source bytes; privileged/obsolete forms are never executed.
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Separate source producers share an ID union, never numerical permissions
+// or membership in the other producer's grammar.
+func movtabCompleteSourceJoin(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) map[string]goasmrules.X86ScalarRMWRow {
+	t.Helper()
+	rows, err := goasmrules.X86ScalarShiftRotateRows(catalog, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	joined := map[string]goasmrules.X86ScalarRMWRow{}
+	for _, row := range rows {
+		if strings.HasPrefix(row.ID, "ymovtab/") {
+			joined[row.ID] = row
+		}
+	}
+	if len(joined) != 18 {
+		t.Fatal("original double-shift join changed", len(joined))
+	}
+	remainder, err := goasmrules.X86MovtabRemainderRows(catalog, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range remainder {
+		if _, duplicate := joined[row.ID]; duplicate {
+			t.Fatal("separate source producers duplicated an original ID", row.ID)
+		}
+		joined[row.ID] = row
+	}
+	if len(remainder) != 92 || len(joined) != 110 {
+		t.Fatal("non-TLS source join changed", len(remainder), len(joined))
+	}
+	return joined
+}
+
+func TestX86MovtabRemainderCompleteSourceJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := movtabRemainderOriginalCases(t, catalog)
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			joined := movtabCompleteSourceJoin(t, catalog, arch)
+			count := 0
+			for _, original := range catalog.Movtab {
+				if original.Kind != "encoding" || original.Code == "movDoubleShift" {
+					continue
+				}
+				count++
+				id := fmt.Sprintf("ymovtab/%d/%s/%s", original.TableIndex, original.Opcode, original.Code)
+				t.Run(id, func(t *testing.T) {
+					actual, found := joined[id]
+					if original.Code == "movTLSReg" {
+						// These two remain source-byte gaps. Actual OS/shared
+						// profiles and relocation owners are separate evidence.
+						if found {
+							t.Fatal("TLS metadata was counted as a successful source encoding", actual)
+						}
+						instruction := x86PureGPUnknownInstruction(t, original.Opcode+" TLS,AX")
+						if err := x86SourceTLSMoveError(instruction, arch); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unbound TLS source lost its actual-context boundary", err)
+						}
+						return
+					}
+					if !found {
+						t.Fatal("MOVTAB_REMAINDER_SOURCE_ID_FEATURE_GAP", id)
+					}
+					if actual.ID != id || actual.Opcode != original.Opcode {
+						t.Fatal("source join changed the original row identity", original, actual)
+					}
+					var expected []x86OfficialPackedCase
+					for _, fixture := range originals {
+						if fixture.row == id {
+							expected = append(expected, fixture)
+						}
+					}
+					if len(expected) == 0 {
+						t.Fatal("source join lost its independent original byte reference", id)
+					}
+					if arch == "386" && strings.Contains(expected[0].witness.Instruction, "CR8") {
+						if actual.ModeFiltered == "" || len(actual.Witnesses) != 0 {
+							t.Fatal("386 CR8 original refusal became a successful source encoding", actual)
+						}
+						return
+					}
+					if actual.ModeFiltered != "" || len(actual.Witnesses) != len(expected) {
+						t.Fatal("source witness count, mode or context changed", actual, len(expected))
+					}
+					for index, witness := range actual.Witnesses {
+						fixture := expected[index].witness
+						if witness.Instruction != fixture.Instruction || witness.Destination != fixture.Destination || string(witness.Encoding) != string(fixture.Encoding) {
+							t.Fatal("source join changed original Go syntax, first-match or bytes", witness, fixture)
+						}
+					}
+				})
+			}
+			if count != 94 {
+				t.Fatal("complete remainder source denominator changed", count)
+			}
+			t.Log("MOVTAB_SOURCE_JOIN proven_rows=92 pending_TLS_source_rows=2 original_double_shift_rows=18")
+			for _, original := range catalog.Movtab {
+				if original.Kind != "encoding" || original.Code == "movDoubleShift" || original.Code == "movTLSReg" {
+					continue
+				}
+				id := fmt.Sprintf("ymovtab/%d/%s/%s", original.TableIndex, original.Opcode, original.Code)
+				modes[arch] = append(modes[arch], joined[id])
+			}
+		})
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_MOVTAB_REMAINDER_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86ScalarRMWRow
+		}{catalog, modes})
+	}
+}
+
+func TestX86MovtabRemainderCompleteOriginalSchema(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(catalog.Movtab) != 113 {
+		t.Fatal("complete ymovtab, including sentinel, changed", len(catalog.Movtab))
+	}
+	want := map[string]int{
+		"movLit": 26, "movRegMem": 6, "movMemReg": 6,
+		"movRegMem2op": 27, "movMemReg2op": 27,
+		"movDoubleShift": 18, "movTLSReg": 2,
+	}
+	counts := map[string]int{}
+	for index, row := range catalog.Movtab {
+		if row.TableIndex != index {
+			t.Fatal("original table order changed", row)
+		}
+		if index == 112 {
+			if row.Kind != "sentinel" || row.Opcode != "" || row.OpcodeExpression != "0" ||
+				row.From != "0" || row.From3 != "0" || row.To != "0" || row.Code != "0" || len(row.OpBytes) != 0 {
+				t.Fatal("explicit movtab sentinel changed", row)
+			}
+			continue
+		}
+		if row.Kind != "encoding" || len(row.OpBytes) > 4 ||
+			strings.TrimPrefix(row.OpcodeExpression, "obj.") != "A"+row.Opcode {
+			t.Fatal("original move schema/source identity changed", row)
+		}
+		if _, found := want[row.Code]; !found {
+			t.Fatal("unowned original move code", row)
+		}
+		if row.Code != "movDoubleShift" && row.From3 != "Ynone" {
+			t.Fatal("ordinary fallback move acquired a third source operand", row)
+		}
+		counts[row.Code]++
+	}
+	for code, expected := range want {
+		if counts[code] != expected {
+			t.Fatal("complete move-code source count changed", code, counts[code], expected)
+		}
+	}
+	// The eighteen existing fallback shifts are not eighteen new identities.
+	rows, err := goasmrules.X86ScalarShiftRotateRows(catalog, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	shiftIDs := map[string]bool{}
+	for _, row := range rows {
+		if strings.HasPrefix(row.ID, "ymovtab/") {
+			shiftIDs[row.ID] = true
+		}
+	}
+	for _, original := range catalog.Movtab {
+		if original.Code == "movDoubleShift" {
+			id := fmt.Sprintf("ymovtab/%d/%s/movDoubleShift", original.TableIndex, original.Opcode)
+			if !shiftIDs[id] {
+				t.Fatal("existing double-shift source owner was lost", id)
+			}
+		}
+	}
+	if len(shiftIDs) != 18 {
+		t.Fatal("existing double-shift source union changed", len(shiftIDs))
+	}
+}
+
+// Independent reference for Go's five non-TLS fallback emission branches.
+// No separate per-mnemonic opcode table: original payloads supply the bytes.
+func movtabRemainderOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OfficialPackedCase {
+	t.Helper()
+	var cases []x86OfficialPackedCase
+	rows := 0
+	for _, row := range catalog.Movtab {
+		if row.Kind != "encoding" || row.Code == "movDoubleShift" || row.Code == "movTLSReg" {
+			continue
+		}
+		rows++
+		var payload [4]byte
+		for index, atom := range row.OpBytes {
+			if row.Code == "movLit" && index == 0 && atom == "Pe" {
+				payload[index] = 0x66
+				continue
+			}
+			value, err := strconv.ParseUint(atom, 0, 8)
+			if err != nil {
+				t.Fatal("invalid original source byte atom", row, index, atom, err)
+			}
+			payload[index] = byte(value)
+		}
+		add := func(arguments string, code []byte) {
+			cases = append(cases, x86OfficialPackedCase{
+				row: fmt.Sprintf("ymovtab/%d/%s/%s", row.TableIndex, row.Opcode, row.Code),
+				witness: goasmrules.X86PackedBinaryWitness{
+					Instruction: row.Opcode + " " + arguments,
+					Destination: arguments[strings.LastIndex(arguments, ",")+1:],
+					Encoding:    append([]byte(nil), code...),
+				},
+			})
+		}
+		if row.Code == "movLit" {
+			end := 0
+			for end < len(payload) && payload[end] != 0 {
+				end++
+			}
+			if end == 0 || end == len(payload) {
+				t.Fatal("unterminated or empty segment-stack literal", row)
+			}
+			class := row.From
+			if class == "Ynone" {
+				class = row.To
+			}
+			add(strings.ToUpper(strings.TrimPrefix(class, "Y")), payload[:end])
+			continue
+		}
+		special, ordinary := row.From, row.To
+		toSpecial := row.Code == "movMemReg" || row.Code == "movMemReg2op"
+		if toSpecial {
+			special, ordinary = row.To, row.From
+		}
+		var operands []string
+		switch ordinary {
+		case "Yrl":
+			operands = []string{"BX"}
+		case "Yml":
+			operands = []string{"BX", "0(SI)"}
+		case "Ym":
+			operands = []string{"0(SI)"}
+		default:
+			t.Fatal("unknown ordinary side of original move fallback", row)
+		}
+		special = strings.ToUpper(strings.TrimPrefix(special, "Y"))
+		span := 1
+		if strings.HasSuffix(row.Code, "2op") {
+			span = 2
+		}
+		for _, operand := range operands {
+			modrm := byte(0xc3) // BX
+			if operand == "0(SI)" {
+				modrm = 6
+			}
+			code := append([]byte(nil), payload[:span]...)
+			extension := payload[span]
+			if extension > 7 {
+				// CR8 is carried in REX.R, not REX.W or a Q suffix.
+				if special != "CR8" || extension != 8 {
+					t.Fatal("unknown special-register extension", row)
+				}
+				code = append([]byte{0x44}, code...)
+			}
+			code = append(code, modrm|(extension&7)<<3)
+			arguments := special + "," + operand
+			if toSpecial {
+				arguments = operand + "," + special
+			}
+			add(arguments, code)
+		}
+	}
+	if rows != 92 || len(cases) != 114 {
+		t.Fatal("complete non-TLS move source inventory changed", rows, len(cases))
+	}
+	return cases
+}
+
+func TestX86MovtabRemainderOriginalGoBytesAndModeRefusals(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	originals := movtabRemainderOriginalCases(t, catalog)
+	accepted, refused := 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var positives []x86OfficialPackedCase
+			for _, original := range originals {
+				if arch == "386" && strings.Contains(original.witness.Instruction, "CR8") {
+					refused++
+					t.Run(original.witness.Instruction, func(t *testing.T) {
+						listing, _ := x86ScalarLiteralExpectedGoListing(t, arch,
+							"TEXT ·NoCR8(SB),4,$0-0\n"+original.witness.Instruction+"\nRET\n", false)
+						if !strings.Contains(listing, "asmins: illegal in mode 32:") || !strings.Contains(listing, "CR8") {
+							t.Fatal("missing original 386 REX source refusal", original, listing)
+						}
+					})
+					continue
+				}
+				accepted++
+				positives = append(positives, original)
+			}
+			for start := 0; start < len(positives); start += 32 {
+				end := start + 32
+				if end > len(positives) {
+					end = len(positives)
+				}
+				batch := append([]x86OfficialPackedCase(nil), positives[start:end]...)
+				var source strings.Builder
+				for index := range batch {
+					batch[index].symbol = fmt.Sprintf("MoveRemainder%d", start+index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[index].symbol)
+					operation := strings.Fields(batch[index].witness.Instruction)[0]
+					width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[operation[len(operation)-1]]
+					if strings.HasPrefix(operation, "POP") {
+						fmt.Fprintf(&source, "ADJSP $%d\n", width)
+					}
+					batch[index].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[index].witness.Instruction)
+					if strings.HasPrefix(operation, "PUSH") {
+						fmt.Fprintf(&source, "ADJSP $-%d\n", width)
+					}
+					source.WriteString("RET\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal("original fallback source batch rejected", arch, start, err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("independent fallback source byte mismatch", arch, start, err)
+				}
+			}
+		})
+	}
+	if accepted != 224 || refused != 4 {
+		t.Fatal("original fallback source/mode matrix changed", accepted, refused)
+	}
+}
diff --git a/x86_official_ordinary_move_rows_test.go b/x86_official_ordinary_move_rows_test.go
new file mode 100644
index 000000000..3c05f5566
--- /dev/null
+++ b/x86_official_ordinary_move_rows_test.go
@@ -0,0 +1,397 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86OrdinaryMoveOriginalCase struct {
+	x86OfficialPackedCase
+	original string
+	mode64   bool
+	rewrite  string
+}
+
+// Literal original-Go encodings are independent of the production formatter.
+// In particular the MMX/XMM carriers are not GP numeric permissions, and an
+// address rewrite is explicitly observed as LEA rather than a selected MOV row.
+func x86OrdinaryMoveOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog) []x86OrdinaryMoveOriginalCase {
+	t.Helper()
+	type sample struct {
+		row      int
+		operands string
+		code     string
+	}
+	fixtures := map[string][]sample{
+		"MOVB": {{0, "CL,BL", "88cb"}, {0, "CL,0(SI)", "880e"}, {1, "0(SI),BL", "8a1e"}, {2, "$128,BL", "b380"}, {3, "$128,0(SI)", "c60680"}},
+		"MOVW": {{0, "CX,BX", "6689cb"}, {0, "CX,0(SI)", "66890e"}, {1, "0(SI),BX", "668b1e"}, {2, "$128,BX", "66bb8000"}, {3, "$128,0(SI)", "66c7068000"}, {4, "$slot+0(SP),BX", "668d1c24"}},
+		"MOVL": {{0, "CX,BX", "89cb"}, {0, "CX,0(SI)", "890e"}, {1, "0(SI),BX", "8b1e"}, {2, "$128,BX", "bb80000000"}, {3, "$128,0(SI)", "c70680000000"},
+			{4, "CX,M1", "0f6ec9"}, {4, "0(SI),M1", "0f6e0e"}, {5, "M1,CX", "0f7ec9"}, {5, "M1,0(SI)", "0f7e0e"},
+			{6, "CX,X1", "660f6ec9"}, {6, "0(SI),X1", "660f6e0e"}, {7, "X1,CX", "660f7ec9"}, {7, "X1,0(SI)", "660f7e0e"}, {8, "$slot+0(SP),BX", "8d1c24"}},
+		"MOVQ": {{0, "0(SI),M1", "0f6f0e"}, {1, "M1,0(SI)", "0f7f0e"}, {2, "X0,M1", "f20fd6c8"},
+			{3, "X0,X1", "f30f7ec8"}, {3, "0(SI),X1", "f30f7e0e"}, {4, "X1,0(SI)", "660fd60e"},
+			{5, "CX,BX", "4889cb"}, {5, "CX,0(SI)", "48890e"}, {6, "0(SI),BX", "488b1e"},
+			{7, "$0x1122334455667788,BX", "48bb8877665544332211"}, {8, "$128,0(SI)", "48c70680000000"},
+			{9, "CX,M1", "480f6ec9"}, {10, "M1,CX", "480f7ec9"}, {11, "CX,X1", "66480f6ec9"}, {12, "X1,CX", "66480f7ec9"}, {13, "$slot+0(SP),BX", "488d1c24"}},
+	}
+	var result []x86OrdinaryMoveOriginalCase
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		samples, found := fixtures[entry.Opcode]
+		if !found {
+			continue
+		}
+		if seen[entry.Opcode] {
+			t.Fatal("duplicate original MOV table", entry.Opcode)
+		}
+		seen[entry.Opcode] = true
+		for _, fixture := range samples {
+			index := fixture.row
+			if entry.Opcode == "MOVQ" && len(entry.Rows) == 15 && index >= 7 {
+				index++
+			}
+			code, err := hex.DecodeString(fixture.code)
+			if err != nil || index >= len(entry.Rows) {
+				t.Fatal("independent MOV fixture changed", err)
+			}
+			original := entry.Opcode + " " + fixture.operands
+			selected, rewrite := original, ""
+			if entry.Rows[index].ZCase == "Zaut_r" && entry.Opcode != "MOVW" {
+				selected = "LEA" + entry.Opcode[3:] + " " + strings.TrimPrefix(fixture.operands, "$")
+				rewrite = "original Go progedit rewrites TYPE_ADDR before ymov matching"
+			}
+			result = append(result, x86OrdinaryMoveOriginalCase{
+				x86OfficialPackedCase: x86OfficialPackedCase{row: fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, index),
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: selected, Destination: strings.Split(fixture.operands, ",")[1], Encoding: code}},
+				original: original, mode64: entry.Prefix == "Pw8" && entry.Rows[index].UnmatchedOffset >= 8, rewrite: rewrite,
+			})
+		}
+		if entry.Opcode == "MOVQ" && len(entry.Rows) == 15 {
+			result = append(result, x86OrdinaryMoveOriginalCase{x86OfficialPackedCase: x86OfficialPackedCase{
+				row: fmt.Sprintf("optab/%d/MOVQ/ymovq/7", entry.TableIndex), witness: goasmrules.X86PackedBinaryWitness{
+					Instruction: "MOVQ $-1,BX", Destination: "BX", Encoding: []byte{0x48, 0xc7, 0xc3, 0xff, 0xff, 0xff, 0xff}}},
+				original: "MOVQ $-1,BX", mode64: true})
+		}
+	}
+	if len(seen) != 4 {
+		t.Fatal("missing complete ordinary MOV source table", seen)
+	}
+	return result
+}
+
+func TestX86OrdinaryMoveAddressOriginalAndCanonicalLEASourceOwnership(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	// These literal bytes and the actual Go assembler are independent of the
+	// MOV source formatter. A LEA object does not select a shadowed MOV row.
+	for _, arch := range []string{"amd64", "386"} {
+		for _, sample := range []struct{ width, code, prefix string }{
+			{"W", "668d1c24", "Pe"}, {"L", "8d1c24", "Px"}, {"Q", "488d1c24", "Pw"},
+		} {
+			if arch == "386" && sample.width == "Q" {
+				continue // Original mode32 refusal is independently executed above.
+			}
+			t.Run(arch+"/"+sample.width, func(t *testing.T) {
+				originalID, canonicalID := "", ""
+				for _, entry := range catalog.Optab {
+					if entry.Opcode == "MOV"+sample.width {
+						for _, row := range entry.Rows {
+							if row.ZCase == "Zaut_r" {
+								if originalID != "" || len(row.Classes) != 2 || row.Classes[0] != "Yiauto" || row.Classes[1] != "Yrl" {
+									t.Fatal("original address-MOV row identity changed")
+								}
+								originalID = fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+							}
+						}
+					}
+					if entry.Opcode == "LEA"+sample.width {
+						if canonicalID != "" || entry.Ytab != "ym_rl" || entry.Prefix != sample.prefix || len(entry.Rows) != 1 {
+							t.Fatal("canonical LEA source identity changed")
+						}
+						row := entry.Rows[0]
+						if row.ZCase != "Zm_r" || row.ZOffset != 1 || row.UnmatchedOffset != 0 ||
+							len(row.Classes) != 2 || row.Classes[0] != "Ym" || row.Classes[1] != "Yrl" {
+							t.Fatal("canonical LEA complete row schema changed")
+						}
+						canonicalID = fmt.Sprintf("optab/%d/%s/%s/0", entry.TableIndex, entry.Opcode, entry.Ytab)
+					}
+				}
+				if originalID == "" || canonicalID == "" {
+					t.Fatal("original MOV or independent canonical LEA owner missing")
+				}
+				code, err := hex.DecodeString(sample.code)
+				if err != nil {
+					t.Fatal(err)
+				}
+				original := "MOV" + sample.width + " $slot+0(SP),BX"
+				canonical := "LEA" + sample.width + " slot+0(SP),BX"
+				observed := original
+				if sample.width != "W" {
+					observed = canonical
+				}
+				x86OrdinaryMoveCheckOriginalGo(t, arch, []x86OrdinaryMoveOriginalCase{
+					{x86OfficialPackedCase: x86OfficialPackedCase{row: originalID, witness: goasmrules.X86PackedBinaryWitness{
+						Instruction: observed, Destination: "BX", Encoding: code}}, original: original},
+					{x86OfficialPackedCase: x86OfficialPackedCase{row: canonicalID, witness: goasmrules.X86PackedBinaryWitness{
+						Instruction: canonical, Destination: "BX", Encoding: code}}, original: canonical},
+				})
+				if sample.width == "W" {
+					t.Log("actual original MOVW retains Zaut_r owner", originalID, "; independent LEAW owner", canonicalID)
+				} else {
+					t.Log("actual original MOV front-end rewrite before MOV table selection", originalID, "->", canonicalID, canonical)
+				}
+			})
+		}
+	}
+}
+
+func x86OrdinaryMoveCheckOriginalGo(t *testing.T, arch string, cases []x86OrdinaryMoveOriginalCase) {
+	t.Helper()
+	for start := 0; start < len(cases); start += 32 {
+		end := start + 32
+		if end > len(cases) {
+			end = len(cases)
+		}
+		t.Run(fmt.Sprintf("%s/batch%d", arch, start/32), func(t *testing.T) {
+			var source strings.Builder
+			var originals []x86OfficialPackedCase
+			for index, fixture := range cases[start:end] {
+				fixture.symbol = fmt.Sprintf("OrdinaryMove%d", start+index)
+				fixture.line = strings.Count(source.String(), "\n") + 2
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s\nRET\n", fixture.symbol, fixture.original)
+				originals = append(originals, fixture.x86OfficialPackedCase)
+			}
+			listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+			if err != nil {
+				t.Fatal("original ordinary MOV source fixture failed", err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, originals); err != nil {
+				t.Fatal("original MOV row/direction/first-match bytes differ", err)
+			}
+		})
+	}
+}
+
+func TestX86OfficialOrdinaryMoveCompleteOriginalGo(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := x86OrdinaryMoveOriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		var accepted []x86OrdinaryMoveOriginalCase
+		seen := map[string]bool{}
+		for _, fixture := range all {
+			if arch == "386" && fixture.mode64 {
+				if !seen[fixture.row] {
+					t.Run("386/refusal/"+fixture.row, func(t *testing.T) {
+						goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+fixture.original+"\nRET\n", "", false)
+					})
+				}
+				seen[fixture.row] = true
+				continue
+			}
+			accepted = append(accepted, fixture)
+		}
+		x86OrdinaryMoveCheckOriginalGo(t, arch, accepted)
+	}
+}
+
+func TestX86OfficialOrdinaryMoveCompleteSourceJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := x86OrdinaryMoveOriginalCases(t, catalog)
+	modes := map[string][]goasmrules.X86OrdinaryMoveRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86OrdinaryMoveRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		expected := map[string]x86OrdinaryMoveOriginalCase{}
+		for _, fixture := range all {
+			if arch != "386" || !fixture.mode64 {
+				expected[fixture.row+"/"+fixture.original] = fixture
+			}
+		}
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				key := row.ID + "/" + witness.Instruction
+				original, found := expected[key]
+				if !found || !bytes.Equal(witness.Encoding, original.witness.Encoding) || witness.Destination != original.witness.Destination {
+					t.Fatal("complete MOV row/instruction/bytes/destination join differs", arch, key, witness, original.witness)
+				}
+				if (row.Rewrite != "") != (original.rewrite != "") || row.Rewrite != "" && !strings.HasPrefix(original.witness.Instruction, row.Rewrite+" ") {
+					t.Fatal("original MOV-to-LEA observation lost its rewrite identity", key, row.Rewrite, original.rewrite)
+				}
+				delete(expected, key)
+			}
+		}
+		if len(expected) != 0 {
+			t.Fatal("independent original MOV observations omitted", arch, expected)
+		}
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_ORDINARY_MOVE_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86OrdinaryMoveRow
+	}{catalog, modes})
+}
+
+// All preserved GP/XMM bytes and typed pointer extents are independently
+// initialized. An MMX operand opens a real MMX region and is closed by EMMS.
+// The source-row descriptor supplies none of those facts.
+func x86OrdinaryMoveInitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if word == 4 {
+		move = "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DX\n%s p+%d(FP),SI\n"+
+		"%s old+%d(FP),BX\n%s input+%d(FP),CX\nMOVOU (SI),X0\nMOVOU (SI),X1\nCMPL CX,CX\n",
+		name, 2*word+16, move, move, word, move, 2*word, move, 2*word+8)
+	mmx := strings.Contains(operation, "M1")
+	if mmx {
+		source += "MOVQ (SI),M1\n"
+	}
+	source += operation + "\n"
+	if mmx {
+		source += "MOVQ M1,32(DX)\nEMMS\n"
+	}
+	source += fmt.Sprintf("MOVOU X1,0(DX)\nMOVOU (SI),X2\nMOVOU X2,16(DX)\n"+
+		"%s BX,48(DX)\n%s CX,56(DX)\nSETCS 62(DX)\nSETEQ 63(DX)\nRET\n", move, move)
+	return source, fmt.Sprintf("func %s(out *[64]byte,p *[16]byte,old,input uint64)\n", name)
+}
+
+func TestX86OfficialOrdinaryMoveInitializedThreeAPIFiveObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := x86OrdinaryMoveOriginalCases(t, catalog)
+	for _, arch := range []string{"amd64", "386"} {
+		var cases []x86OfficialPackedCase
+		for _, fixture := range all {
+			if arch == "386" && fixture.mode64 || strings.Contains(fixture.original, "$slot+") {
+				continue
+			}
+			cases = append(cases, fixture.x86OfficialPackedCase)
+		}
+		x86Legacy127Objects(t, arch, cases, x86OrdinaryMoveInitializedFunction)
+	}
+}
+
+func TestX86OfficialOrdinaryMoveSourceRowsDoNotSupplyInputAuthority(t *testing.T) {
+	for _, row := range []struct{ operation, initialization, observation string }{
+		{"MOVB CL,BL", "MOVQ old+0(FP),BX\n", ""},
+		{"MOVW CX,BX", "MOVQ input+8(FP),CX\n", ""},
+		{"MOVL M1,CX", "", "MOVQ CX,ret+16(FP)\n"},
+		{"MOVQ X0,M1", "", "MOVQ M1,ret+16(FP)\nEMMS\n"},
+		{"MOVB 0(SI),BL", "MOVQ old+0(FP),BX\n", ""},
+		{"MOVQ CX,0(SI)", "MOVQ old+0(FP),BX\nMOVQ input+8(FP),CX\n", ""},
+		{"MOVW $slot+0(SP),BX", "MOVQ old+0(FP),BX\n", ""},
+		{"MOVL $slot+0(SP),BX", "", ""},
+		{"MOVQ $slot+0(SP),BX", "", ""},
+	} {
+		t.Run(row.operation, func(t *testing.T) {
+			observation := row.observation
+			if observation == "" {
+				observation = "MOVQ BX,ret+16(FP)\n"
+			}
+			source := "TEXT ·MissingMovInput(SB),4,$0-24\n" + row.initialization + row.operation + "\n" + observation + "RET\n"
+			declaration := "func MissingMovInput(old,input uint64) uint64\n"
+			// The source spelling remains Go-valid even when a numerical input,
+			// bank/state input, pointer or independently owned frame is absent.
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original MOV syntax supplied absent input/source authority", api, ir, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86OfficialOrdinaryMoveOriginalAddressCapturedFrameObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, width := range []string{"W", "L", "Q"} {
+		t.Run(width, func(t *testing.T) {
+			// The bounded local is initialized independently. The address-only
+			// scratch is overwritten before any numerical/result observation;
+			// a partial W/L address must not become a dereferenceable pointer.
+			source := "TEXT ·OrdinaryAddress(SB),4,$16-16\nMOVQ input+0(FP),AX\nMOVQ AX,0(SP)\n" +
+				"MOV" + width + " $slot-16(SP),BX\nMOVQ $0,BX\nMOVQ 0(SP),AX\nMOVQ AX,ret+8(FP)\nRET\n"
+			declaration := "func OrdinaryAddress(input uint64) uint64\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, goos := range []string{"linux", "darwin", "windows"} {
+				t.Run(goos, func(t *testing.T) {
+					triple := testTargetTriple(goos, "amd64")
+					pkg, request, _, options := x86CMOVFixedLocalFixture(t, source, declaration, goos+"/amd64", triple)
+					fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+						if err != nil || ir == "" {
+							t.Fatal("original address MOV with independently captured initialized frame rejected", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, ir, level)
+						}
+					})
+				})
+			}
+		})
+	}
+}
+
+func TestX86OfficialOrdinaryMoveImmediateFirstMatch(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	historicalSignedRow := false
+	for _, entry := range catalog.Optab {
+		if entry.Opcode == "MOVQ" {
+			historicalSignedRow = len(entry.Rows) == 15
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var cases []x86OrdinaryMoveOriginalCase
+		for _, row := range []struct{ instruction, code string }{
+			{"MOVB $-1,BL", "b3ff"}, {"MOVW $65535,BX", "66bbffff"}, {"MOVL $-1,BX", "bbffffffff"},
+		} {
+			code, _ := hex.DecodeString(row.code)
+			cases = append(cases, x86OrdinaryMoveOriginalCase{x86OfficialPackedCase: x86OfficialPackedCase{row: "independent immediate selector", witness: goasmrules.X86PackedBinaryWitness{Instruction: row.instruction, Encoding: code}}, original: row.instruction})
+		}
+		if arch == "amd64" {
+			for _, row := range []struct{ instruction, current, historical string }{
+				{"MOVQ $0,BX", "bb00000000", "48c7c300000000"},
+				{"MOVQ $1,BX", "bb01000000", "48c7c301000000"},
+				{"MOVQ $2147483647,BX", "bbffffff7f", "48c7c3ffffff7f"},
+				{"MOVQ $2147483648,BX", "bb00000080", "bb00000080"},
+				{"MOVQ $4294967295,BX", "bbffffffff", "bbffffffff"},
+				{"MOVQ $4294967296,BX", "48bb0000000001000000", "48bb0000000001000000"},
+				{"MOVQ $-1,BX", "48c7c3ffffffff", "48c7c3ffffffff"},
+				{"MOVQ $-2147483648,BX", "48c7c300000080", "48c7c300000080"},
+				{"MOVQ $-2147483649,BX", "48bbffffff7fffffffff", "48bbffffff7fffffffff"},
+			} {
+				encoding := row.current
+				if historicalSignedRow {
+					encoding = row.historical
+				}
+				code, _ := hex.DecodeString(encoding)
+				cases = append(cases, x86OrdinaryMoveOriginalCase{x86OfficialPackedCase: x86OfficialPackedCase{row: "independent MOVQ shortening", witness: goasmrules.X86PackedBinaryWitness{Instruction: row.instruction, Encoding: code}}, original: row.instruction})
+			}
+		}
+		x86OrdinaryMoveCheckOriginalGo(t, arch, cases)
+	}
+}
diff --git a/x86_official_packed_broadcast_rows_test.go b/x86_official_packed_broadcast_rows_test.go
new file mode 100644
index 000000000..d4717d70b
--- /dev/null
+++ b/x86_official_packed_broadcast_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedBroadcastRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedBroadcastRows, 111, 234, 0)
+}
diff --git a/x86_official_packed_duplicate_rows_test.go b/x86_official_packed_duplicate_rows_test.go
new file mode 100644
index 000000000..d3f872b45
--- /dev/null
+++ b/x86_official_packed_duplicate_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedDuplicateRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86PackedDuplicateRows, 27, 72, 0, x86OfficialAbsAssembly)
+}
diff --git a/x86_official_packed_immediate_shuffle_rows_test.go b/x86_official_packed_immediate_shuffle_rows_test.go
new file mode 100644
index 000000000..ac7b84d09
--- /dev/null
+++ b/x86_official_packed_immediate_shuffle_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedImmediateShuffleRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86PackedImmediateShuffleRows, 34, 95, 0, x86OfficialAbsAssembly)
+}
diff --git a/x86_official_packed_numeric_conversion_rows_test.go b/x86_official_packed_numeric_conversion_rows_test.go
new file mode 100644
index 000000000..6eba1d9c4
--- /dev/null
+++ b/x86_official_packed_numeric_conversion_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedNumericConversionRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedNumericConversionRows, 162, 876, 0)
+}
diff --git a/x86_official_packed_rotate_rows_test.go b/x86_official_packed_rotate_rows_test.go
new file mode 100644
index 000000000..5d6a47819
--- /dev/null
+++ b/x86_official_packed_rotate_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedRotateRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedRotateRows, 48, 216, 0)
+}
diff --git a/x86_official_packed_rows_test.go b/x86_official_packed_rows_test.go
new file mode 100644
index 000000000..de2257570
--- /dev/null
+++ b/x86_official_packed_rows_test.go
@@ -0,0 +1,432 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86OfficialPackedCase struct {
+	row, symbol string
+	line        int
+	witness     goasmrules.X86PackedBinaryWitness
+}
+
+// This joins official table ownership to physical Go bytes and initialized
+// public API translation. It is object coverage, not executed semantics.
+// Existing independent family runtime oracles remain a separate gate.
+func TestX86OfficialPackedRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedBinaryPilotRows, 159, 480, 2)
+}
+
+func TestX86OfficialAverageMultiplyRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedAverageMultiplyRows, 90, 258, 0)
+}
+
+func TestX86OfficialLogicalRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedLogicalRows, 132, 504, 0)
+}
+
+func TestX86OfficialUnpackRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedUnpackRows, 108, 360, 0)
+}
+
+func TestX86OfficialNarrowRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedNarrowRows, 36, 114, 0)
+}
+
+func TestX86OfficialPerLaneShiftRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedPerLaneShiftRows, 64, 236, 0)
+}
+
+func TestX86OfficialSignRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedSignRows, 9, 18, 0)
+}
+
+func TestX86OfficialAbsRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjectsUsing(t, goasmrules.X86PackedAbsRows, 33, 108, 0, x86OfficialAbsAssembly)
+}
+
+func TestX86OfficialHorizontalIntegerRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedHorizontalIntegerRows, 18, 36, 0)
+}
+
+func TestX86OfficialByteShuffleRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedByteShuffleRows, 9, 24, 0)
+}
+
+func TestX86OfficialIntegerCompareRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedIntegerCompareRows, 72, 168, 0)
+}
+
+func TestX86OfficialMaskBlendRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedMaskBlendRows, 36, 144, 0)
+}
+
+func TestX86OfficialMinMaxRowsInitializedThreeAPIsObjects(t *testing.T) {
+	verified := x86OfficialPackedRowsObjects(t, goasmrules.X86PackedIntegerMinMaxRows, 132, 432, 0)
+	narrowEVEX := 0
+	for _, fixture := range verified {
+		w := fixture.witness
+		name := strings.Fields(w.Instruction)[0]
+		if w.Generation == "evex" && w.Width < 512 && !w.Masked && !w.Broadcast && !strings.HasSuffix(name, "Q") {
+			narrowEVEX++
+		}
+	}
+	if narrowEVEX != 48 {
+		t.Fatalf("only %d/48 original unmasked non-Q EVEX X/Y witnesses verified", narrowEVEX)
+	}
+	t.Log("48 non-Q unmasked EVEX X/Y register/memory forms retain their actual Go EVEX bytes through initialized APIs and LLVM objects; low-bank VEX success is not substituted")
+}
+
+func x86OfficialPackedRowsObjects(t *testing.T,
+	buildRows func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error),
+	wantRows, wantFormats, wantAliases int) []x86OfficialPackedCase {
+	t.Helper()
+	return x86OfficialPackedRowsObjectsUsing(t, buildRows, wantRows, wantFormats, wantAliases, x86OfficialPackedAssembly)
+}
+
+func x86OfficialPackedRowsObjectsUsing(t *testing.T,
+	buildRows func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error),
+	wantRows, wantFormats, wantAliases int,
+	assembly func([]x86OfficialPackedCase) (string, string)) []x86OfficialPackedCase {
+	t.Helper()
+	return x86OfficialPackedRowsObjectsInspect(t, buildRows, wantRows, wantFormats, wantAliases, assembly,
+		func(*testing.T, string, []x86OfficialPackedCase) {})
+}
+
+func x86OfficialPackedRowsObjectsInspect(t *testing.T,
+	buildRows func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error),
+	wantRows, wantFormats, wantAliases int,
+	assembly func([]x86OfficialPackedCase) (string, string),
+	inspect func(*testing.T, string, []x86OfficialPackedCase)) []x86OfficialPackedCase {
+	t.Helper()
+	return x86OfficialPackedRowsObjectsForTarget(t, "amd64", "x86_64-unknown-linux-gnu",
+		buildRows, wantRows, wantFormats, wantAliases, assembly, inspect)
+}
+
+func x86OfficialPackedRowsObjectsForTarget(t *testing.T, arch, triple string,
+	buildRows func(goasmrules.X86LegacyCatalog, []goasmrules.X86AVXRule) ([]goasmrules.X86PackedBinaryRow, error),
+	wantRows, wantFormats, wantAliases int,
+	assembly func([]x86OfficialPackedCase) (string, string),
+	inspect func(*testing.T, string, []x86OfficialPackedCase)) []x86OfficialPackedCase {
+	t.Helper()
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := buildRows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cases, aliases []x86OfficialPackedCase
+	for _, row := range rows {
+		for _, witness := range row.Witnesses {
+			cases = append(cases, x86OfficialPackedCase{row: row.ID, witness: witness})
+			if row.Opcode == "PADDL" {
+				witness.Instruction = strings.Replace(witness.Instruction, "PADDL ", "PADDD ", 1)
+				aliases = append(aliases, x86OfficialPackedCase{row: "alias/PADDD/" + row.ID, witness: witness})
+			}
+		}
+	}
+	if len(rows) != wantRows || len(cases) != wantFormats || len(aliases) != wantAliases {
+		t.Fatalf("official binary denominator drift: rows=%d canonical=%d aliases=%d", len(rows), len(cases), len(aliases))
+	}
+	cases = append(cases, aliases...)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	_, driverHash := x86LEAActualSDKDriver(t)
+	t.Logf("row-owned oracle SDK=%s driverSHA=%x; %s only, MMX excluded", runtime.Version(), driverHash, arch)
+	passed := 0
+	for start := 0; start < len(cases); start += 32 {
+		end := start + 32
+		if end > len(cases) {
+			end = len(cases)
+		}
+		batch := cases[start:end]
+		if t.Run(fmt.Sprintf("batch%02d", start/32), func(t *testing.T) {
+			source, declaration := assembly(batch)
+			listing, err := x86ScalarLiteralGoListing(t, arch, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+				t.Fatalf("original Go encoding identity: %v\n%s", err, listing)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					inspect(t, ir, batch)
+					x86ResultInitializationObject(t, llc, triple, ir, api)
+				})
+			}
+		}) {
+			passed += len(batch)
+		}
+	}
+	if passed != len(cases) {
+		t.Fatalf("only %d/%d row-owned formats passed all original-encoding/public-API/object gates", passed, len(cases))
+	}
+	t.Logf("%d canonical rows / %d legal format witnesses plus %d aliases: original Go encoding and row-owned functions through all three public APIs + LLVM22 objects passed; no runtime claim",
+		wantRows, wantFormats, wantAliases)
+	return cases
+}
+
+func x86OfficialAbsAssembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declarations strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		w := fixture.witness
+		registers := [3]int{0, 1, 0}
+		if !w.Memory {
+			registers[0], _ = strconv.Atoi(w.First[1:])
+		}
+		registers[2], _ = strconv.Atoi(w.Destination[1:])
+		body, declaration := x86PackedAbsSignInitializedInstruction(index, w.Instruction, "amd64", registers)
+		fixture.symbol = fmt.Sprint("AbsSign", index)
+		for offset, instruction := range strings.Split(body, "\n") {
+			if instruction == w.Instruction {
+				fixture.line = line + offset
+			}
+		}
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func x86OfficialPackedAssembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declaration strings.Builder
+	line := 1
+	for index := range cases {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprintf("Row%d", index)
+		w := fixture.witness
+		fmt.Fprintf(&declaration, "func %s(out,a,b *byte,mask uint64)\n", fixture.symbol)
+		prefix := fmt.Sprintf("TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\n", fixture.symbol)
+		move := "VMOVUPS"
+		if w.Generation == "legacy" {
+			move = "MOVOU"
+		}
+		seed := ""
+		if !w.Memory && w.First != "" {
+			if _, valid := amd64ParseKReg(Reg(w.First)); valid {
+				seed = fmt.Sprintf("MOVQ (AX),CX\nKMOVQ CX,%s\n", w.First)
+			} else if isX86YrlRegisterForArch(Reg(w.First), "amd64") {
+				seed = fmt.Sprintf("MOVQ (AX),%s\n", w.First)
+			} else {
+				prefix += fmt.Sprintf("%s (AX),%s\n", move, w.First)
+			}
+		}
+		if w.Second != "" {
+			prefix += fmt.Sprintf("%s (BX),%s\n", move, w.Second)
+		}
+		if w.Masked {
+			prefix += "MOVQ mask+24(FP),CX\nKMOVQ CX,K1\n"
+			// A masked K result writes zero for disabled lanes; it never
+			// merges an old destination as a masked vector result does.
+			if !w.Zeroing && !w.MaskResult {
+				prefix += fmt.Sprintf("%s (BX),%s\n", move, w.Destination)
+			}
+		}
+		// Finish pointer-dependent vector/old/mask seeds before a GP input
+		// replaces AX. K data comes from a, independently of the mask argument.
+		prefix += seed
+		fixture.line = line + strings.Count(prefix, "\n")
+		store := move
+		if w.MaskResult {
+			store = "KMOVQ"
+		}
+		body := prefix + w.Instruction + fmt.Sprintf("\n%s %s,(DX)\nRET\n", store, w.Destination)
+		source.WriteString(body)
+		line += strings.Count(body, "\n")
+	}
+	return source.String(), declaration.String()
+}
+
+var x86OfficialPackedListingInstruction = regexp.MustCompile(`^\s*0x([0-9a-f]+)\s+([0-9]+)\s+\(.*:([0-9]+)\)\s+([A-Z0-9._]+)(?:\s|$)`)
+
+func x86OfficialPackedVerifyListing(listing string, cases []x86OfficialPackedCase) error {
+	owners := map[string]x86OfficialPackedCase{}
+	for _, fixture := range cases {
+		owners[fixture.symbol] = fixture
+	}
+	type instruction struct {
+		pc, line int
+		op       string
+	}
+	seen := map[string]bool{}
+	var owner string
+	var code []byte
+	var instructions []instruction
+	size := 0
+	finish := func() error {
+		if owner == "" {
+			return nil
+		}
+		fixture := owners[owner]
+		if len(instructions) < 2 || len(code) != size || size == 0 || code[size-1] != 0xc3 ||
+			instructions[len(instructions)-1].op != "RET" || instructions[len(instructions)-1].pc != size-1 {
+			return fmt.Errorf("%s has incomplete Go instruction/byte boundaries", fixture.row)
+		}
+		matches := 0
+		for index, ins := range instructions {
+			if ins.line != fixture.line {
+				continue
+			}
+			matches++
+			name := strings.Split(strings.Fields(fixture.witness.Instruction)[0], ".")[0]
+			if name == "PADDD" {
+				name = "PADDL" // Go's frontend alias must retain canonical bytes.
+			}
+			if strings.Split(ins.op, ".")[0] != name || index+1 == len(instructions) {
+				return fmt.Errorf("%s has changed/missing original source instruction", fixture.row)
+			}
+			end := instructions[index+1].pc
+			if ins.pc < 0 || end > len(code) || !bytes.Equal(code[ins.pc:end], fixture.witness.Encoding) {
+				return fmt.Errorf("%s %s: original bytes at %d:%d differ from %x", fixture.row,
+					fixture.witness.Instruction, ins.pc, end, fixture.witness.Encoding)
+			}
+		}
+		if matches != 1 {
+			return fmt.Errorf("%s has %d original source-row matches", fixture.row, matches)
+		}
+		seen[owner] = true
+		return nil
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && strings.HasPrefix(fields[1], "STEXT") {
+			if err := finish(); err != nil {
+				return err
+			}
+			symbol := strings.TrimPrefix(fields[0], "literal.")
+			// Historical Go prints an empty local package even with -p.
+			// Accept only these two observed owners, never arbitrary packages.
+			if symbol == fields[0] {
+				symbol = strings.TrimPrefix(fields[0], `"".`)
+			}
+			if fields[1] != "STEXT" && fields[1] != "STEXTFIPS" {
+				return fmt.Errorf("unknown Go text symbol kind %s", fields[1])
+			}
+			if _, ok := owners[symbol]; !ok || seen[symbol] || symbol == fields[0] {
+				return fmt.Errorf("unowned or duplicate Go function %s", fields[0])
+			}
+			owner, code, instructions, size = symbol, nil, nil, 0
+			for _, field := range fields[2:] {
+				if strings.HasPrefix(field, "size=") {
+					value, err := strconv.Atoi(strings.TrimPrefix(field, "size="))
+					if err != nil || value <= 0 || size != 0 {
+						return fmt.Errorf("invalid Go function size: %s", line)
+					}
+					size = value
+				}
+			}
+			continue
+		}
+		// Other object symbols have their own byte columns, not function code.
+		if len(fields) >= 2 && strings.HasPrefix(fields[1], "S") && !strings.HasPrefix(fields[0], "0x") {
+			if err := finish(); err != nil {
+				return err
+			}
+			owner = ""
+		}
+		if owner == "" {
+			continue
+		}
+		if encoded := x86InsertExtractListedBytes(line); len(encoded) != 0 {
+			pc, err := strconv.ParseUint(strings.TrimPrefix(fields[0], "0x"), 16, 32)
+			if err != nil || int(pc) != len(code) {
+				return fmt.Errorf("noncontiguous original Go byte columns: %s", line)
+			}
+			code = append(code, encoded...)
+			continue
+		}
+		match := x86OfficialPackedListingInstruction.FindStringSubmatch(line)
+		if match == nil {
+			continue
+		}
+		pc, pcErr := strconv.ParseUint(match[1], 16, 32)
+		decimal, decimalErr := strconv.ParseUint(match[2], 10, 32)
+		sourceLine, lineErr := strconv.Atoi(match[3])
+		if pcErr != nil || decimalErr != nil || lineErr != nil || pc != decimal || int(pc) >= size {
+			return fmt.Errorf("invalid original Go PC/source row: %s", line)
+		}
+		if match[4] == "TEXT" || match[4] == "FUNCDATA" || match[4] == "PCDATA" {
+			continue
+		}
+		if len(instructions) == 0 && pc != 0 || len(instructions) != 0 && int(pc) <= instructions[len(instructions)-1].pc {
+			return fmt.Errorf("non-increasing original Go instruction PCs: %s", line)
+		}
+		instructions = append(instructions, instruction{int(pc), sourceLine, match[4]})
+	}
+	if err := finish(); err != nil {
+		return err
+	}
+	if len(seen) != len(cases) {
+		return fmt.Errorf("only %d/%d original Go functions verified", len(seen), len(cases))
+	}
+	return nil
+}
+
+func TestX86OfficialPackedRowListingRejectsFalseIdentity(t *testing.T) {
+	cases := []x86OfficialPackedCase{{row: "avx/fixture", symbol: "Row0", line: 2,
+		witness: goasmrules.X86PackedBinaryWitness{Instruction: "VPADDD X16,X17,X18", Encoding: []byte{0x62, 0xa1, 0x75, 0, 0xfe, 0xd0}}}}
+	byteRow := func(hex, ascii string) string {
+		return fmt.Sprintf("  0x0000%-48s  %s\n", " "+hex, ascii)
+	}
+	originalBytes := byteRow("62 a1 75 00 fe d0 c3", "b.u....")
+	listing := `literal.Row0 STEXT nosplit asm size=7 align=0x0 args=0x0 locals=0x0
+  0x0000 00000 (literal.s:1) TEXT literal.Row0(SB), NOSPLIT|NOFRAME, $0-0
+  0x0000 00000 (literal.s:1) FUNCDATA $0, gclocals(SB)
+  0x0000 00000 (literal.s:2) VPADDD X16, X17, X18
+  0x0006 00006 (literal.s:3) RET
+` + originalBytes
+	if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+		t.Fatal(err)
+	}
+	for _, compatible := range []string{
+		strings.ReplaceAll(listing, "literal.Row0", `"".Row0`),
+		strings.Replace(listing, "STEXT ", "STEXTFIPS ", 1),
+	} {
+		if err := x86OfficialPackedVerifyListing(compatible, cases); err != nil {
+			t.Fatal("known SDK listing spelling lost row ownership", err)
+		}
+	}
+	for name, changed := range map[string]string{
+		"unknown text kind":   strings.Replace(listing, "STEXT ", "STEXTFOREIGN ", 1),
+		"VEX instead of EVEX": strings.Replace(listing, originalBytes, byteRow("c5 f1 75 00 fe d0 c3", "..u...."), 1),
+		"register extension":  strings.Replace(listing, "a1 75", "e1 75", 1),
+		"partial instruction": strings.Replace(listing, "0x0006 00006", "0x0005 00005", 1),
+		"wrong source row":    strings.Replace(listing, "literal.s:2", "literal.s:4", 1),
+		"wrong owner":         strings.ReplaceAll(listing, "literal.Row0", "literal.Row1"),
+		"missing owner":       "",
+		"duplicate owner":     listing + listing,
+		"truncated bytes":     strings.Replace(listing, originalBytes, byteRow("62 a1 75 00 fe d0", "b.u..."), 1),
+		"trailing bytes":      strings.Replace(listing, originalBytes, byteRow("62 a1 75 00 fe d0 c3 90", "b.u....."), 1),
+		"byte gap":            strings.Replace(listing, "0x0000 62", "0x0001 62", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := x86OfficialPackedVerifyListing(changed, cases); err == nil {
+				t.Fatal("unverified official row identity accepted")
+			}
+		})
+	}
+}
diff --git a/x86_official_packed_widening_rows_test.go b/x86_official_packed_widening_rows_test.go
new file mode 100644
index 000000000..2ebef4640
--- /dev/null
+++ b/x86_official_packed_widening_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPackedWideningRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedWideningRows, 108, 288, 0)
+}
diff --git a/x86_official_permutation_shuffle_rows_test.go b/x86_official_permutation_shuffle_rows_test.go
new file mode 100644
index 000000000..2cc12fad8
--- /dev/null
+++ b/x86_official_permutation_shuffle_rows_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialPermutationShuffleRowsInitializedThreeAPIsObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86PermutationShuffleRows, 84, 328, 0,
+		x86OfficialPackedAssembly, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86PermutationShuffleInputsAndZeroingStayIndependent(t *testing.T) {
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86PermutationShuffleRows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, row := range rows {
+		if row.Opcode != "VPERMD" && row.Opcode != "VPERMPS" && !strings.HasPrefix(row.Opcode, "VSHUF") {
+			continue
+		}
+		for _, witness := range row.Witnesses {
+			if witness.Width != 512 || !witness.Masked || witness.Memory {
+				continue
+			}
+			fixture := []x86OfficialPackedCase{{row: row.ID, witness: witness}}
+			source, declarations := x86OfficialPackedAssembly(fixture)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Fatal("valid actual inputs must precede missing-input controls", row.ID, witness.Instruction, api, err)
+				}
+				seeds := []string{"VMOVUPS (AX),Z16\n", "VMOVUPS (BX),Z17\n", "KMOVQ CX,K1\n"}
+				if !witness.Zeroing {
+					seeds = append(seeds, "VMOVUPS (BX),Z18\n")
+				}
+				for _, seed := range seeds {
+					changed := strings.Replace(source, seed, "", 1)
+					if changed == source {
+						t.Fatal("missing-input negative did not change its source", seed)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+					if !strings.HasPrefix(seed, "KMOV") {
+						x86VectorScratchCodegenControl(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("missing source/control/mask/merge input gained authority", witness.Instruction, api, seed, err)
+					}
+				}
+			}
+			count++
+		}
+	}
+	if count != 12 {
+		t.Fatal("complete six-member merge/zero input directory changed", count)
+	}
+}
diff --git a/x86_official_scalar_compare_rows_test.go b/x86_official_scalar_compare_rows_test.go
new file mode 100644
index 000000000..04ab878ec
--- /dev/null
+++ b/x86_official_scalar_compare_rows_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86ScalarCompareInitializedFunction(name, operation, arch string) (string, string) {
+	word, move := goWordSize(arch), "Q"
+	if word == 4 {
+		move = "L"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),SI\nMOV%s out+%d(FP),DI\n"+
+		"MOV%s a+%d(FP),AX\nMOV%s b+%d(FP),BX\nMOV%s c+%d(FP),CX\n%s\n"+
+		"MOV%s AX,0(DI)\nMOV%s BX,8(DI)\nMOV%s CX,16(DI)\n"+
+		"SETCS DL\nMOVB DL,24(DI)\nSETEQ DL\nMOVB DL,25(DI)\nSETPS DL\nMOVB DL,26(DI)\n"+
+		"SETMI DL\nMOVB DL,27(DI)\nSETOS DL\nMOVB DL,28(DI)\nRET\n",
+		name, 5*word, move, move, word, move, 2*word, move, 3*word, move, 4*word, operation, move, move, move)
+	return source, fmt.Sprintf("func %s(memory *[8]byte,out *[40]byte,a,b,c uintptr)\n", name)
+}
+
+func TestX86OfficialScalarCompareRowsOriginalBytesObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86ScalarCompareRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		modes[arch] = rows
+		var cases []x86OfficialPackedCase
+		for _, row := range rows {
+			for _, witness := range row.Witnesses {
+				cases = append(cases, x86OfficialPackedCase{row: row.ID,
+					witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+			}
+		}
+		want := 48
+		if arch == "386" {
+			want = 34
+		}
+		if len(rows) != 31 || len(cases) != want {
+			t.Fatal("original compare/test source-mode union changed", arch, len(rows), len(cases))
+		}
+		x86Legacy127Objects(t, arch, cases, x86ScalarCompareInitializedFunction)
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_SCALAR_COMPARE_IDENTITY_OUTPUT", struct {
+			Source goasmrules.X86LegacyCatalog
+			Modes  map[string][]goasmrules.X86ScalarRMWRow
+		}{catalog, modes})
+	}
+}
diff --git a/x86_official_scalar_rm_register_modes_test.go b/x86_official_scalar_rm_register_modes_test.go
new file mode 100644
index 000000000..95850e38c
--- /dev/null
+++ b/x86_official_scalar_rm_register_modes_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"errors"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Source acceptance/refusal observations only. Bare operands do not supply
+// numerical inputs, LLVM object qualification or a native-execution result.
+func TestX86ScalarRMRegisterOriginalSourceModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		accepted, refused, rows := 0, 0, 0
+		for _, entry := range catalog.Optab {
+			if entry.Ytab != "yml_rl" || strings.HasPrefix(entry.Opcode, "CMOV") {
+				continue
+			}
+			rows++
+			for _, input := range []string{"CX", "0(SI)"} {
+				t.Run(arch+"/"+entry.Opcode+"/"+input, func(t *testing.T) {
+					listing, err := x86ExtensionGoListing(t, arch, entry.Opcode+" "+input+",BX")
+					if err == nil {
+						if !strings.Contains(listing, "extension.s:2") || !strings.Contains(listing, "0x0000 ") {
+							t.Fatal("Go succeeded without the original source/byte-column observation", listing)
+						}
+						accepted++
+						t.Log("actual Go source accepted", runtime.Version(), arch, entry.Opcode, input)
+						return
+					}
+					var exit *exec.ExitError
+					if arch == "amd64" || !errors.As(err, &exit) || exit.ExitCode() != 1 ||
+						!strings.Contains(listing, "extension.s:2") || !strings.Contains(listing, entry.Opcode) ||
+						!strings.Contains(listing, "asm:") {
+						t.Fatal("source refusal not established: preserve setup/tool/resource failure separately", err, listing)
+					}
+					refused++
+					t.Log("actual Go source refusal, not an ISA execution or numerical result", runtime.Version(), arch, listing)
+				})
+			}
+		}
+		if rows != 28 || accepted+refused != 56 {
+			t.Fatal("incomplete original source observation denominator", arch, rows, accepted, refused)
+		}
+		if arch == "amd64" && (accepted != 56 || refused != 0) {
+			t.Fatal("ordinary AMD64 official source alternatives changed", accepted, refused)
+		}
+		t.Log("actual source mode totals", runtime.Version(), arch, "accepted", accepted, "refused", refused)
+	}
+}
diff --git a/x86_official_scalar_rm_register_rows_test.go b/x86_official_scalar_rm_register_rows_test.go
new file mode 100644
index 000000000..4b86e3343
--- /dev/null
+++ b/x86_official_scalar_rm_register_rows_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// All inputs have their actual roles: memory is a bounded typed source, BX is
+// the old destination, CX the numerical source, and CMP defines CF/OF. Observe
+// the whole GP result, including preserved bytes and a failed query/zero scan's
+// old destination. Do not read BSF/BSR's undefined non-ZF status bits.
+func x86ScalarRMRegisterInitializedFunction(name, operation, arch string) (string, string) {
+	word, suffix := goWordSize(arch), "Q"
+	if word == 4 {
+		suffix = "L"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),SI\n"+
+		"MOV%s old+%d(FP),BX\nMOV%s input+%d(FP),CX\nCMPL CX,CX\n%s\n"+
+		"MOV%s BX,ret+%d(FP)\nRET\n", name, 4*word, suffix,
+		suffix, word, suffix, 2*word, operation, suffix, 3*word)
+	declaration := fmt.Sprintf("func %s(memory *[8]byte,old,input uintptr) uintptr\n", name)
+	return source, declaration
+}
+
+func TestX86OfficialScalarRMRegisterRowsOriginalBytesAndObjects(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, mode := range []struct {
+		arch, triple string
+		count        int
+	}{
+		{"amd64", "x86_64-unknown-linux-gnu", 56},
+		{"386", "i386-unknown-linux-gnu", 34},
+	} {
+		t.Run(mode.arch, func(t *testing.T) {
+			rows, err := goasmrules.X86ScalarRMRegisterRows(catalog, mode.arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			var cases []x86OfficialPackedCase
+			for _, row := range rows {
+				if row.ModeFiltered != "" {
+					continue
+				}
+				for _, witness := range row.Witnesses {
+					cases = append(cases, x86OfficialPackedCase{row: row.ID,
+						witness: goasmrules.X86PackedBinaryWitness{Instruction: witness.Instruction, Encoding: witness.Encoding}})
+				}
+			}
+			if len(rows) != 28 || len(cases) != mode.count {
+				t.Fatal("complete original scalar row/mode union changed", len(rows), len(cases))
+			}
+			for start := 0; start < len(cases); start += 32 {
+				end := start + 32
+				if end > len(cases) {
+					end = len(cases)
+				}
+				t.Run(fmt.Sprint("batch", start/32), func(t *testing.T) {
+					batch := cases[start:end]
+					var source, declarations strings.Builder
+					for index := range batch {
+						fixture := &batch[index]
+						fixture.symbol = fmt.Sprint("ScalarRMOfficial", index)
+						body, declaration := x86ScalarRMRegisterInitializedFunction(fixture.symbol, fixture.witness.Instruction, mode.arch)
+						position := strings.Index(body, "\n"+fixture.witness.Instruction+"\n")
+						if position < 0 {
+							t.Fatal("original scalar producer lost the exact observed instruction")
+						}
+						fixture.line = strings.Count(source.String(), "\n") + strings.Count(body[:position+1], "\n") + 1
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+					listing, err := x86ScalarLiteralGoListing(t, mode.arch, source.String())
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+						t.Fatal("actual original scalar row byte identity", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), mode.arch, mode.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized scalar source/old destination/status rejected", api, err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, mode.triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86OfficialScalarRMRegisterInitializedInputsRemainRequired(t *testing.T) {
+	for _, item := range []struct{ operation, removed string }{
+		{"ADCXL CX,BX", "CMPL CX,CX\n"},
+		{"ADOXQ CX,BX", "CMPL CX,CX\n"},
+		{"BSFW CX,BX", "MOVQ old+8(FP),BX\n"},
+		{"LARQ CX,BX", "MOVQ old+8(FP),BX\n"},
+		{"MOVWLSX CX,BX", "MOVQ input+16(FP),CX\n"},
+		{"POPCNTL 0(SI),BX", "MOVQ memory+0(FP),SI\n"},
+	} {
+		t.Run(item.operation, func(t *testing.T) {
+			source, declaration := x86ScalarRMRegisterInitializedFunction("ScalarInputs", item.operation, "amd64")
+			if strings.Count(source, item.removed) != 1 {
+				t.Fatal("negative does not remove exactly one original input", item.removed)
+			}
+			changed := strings.Replace(source, item.removed, "", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("source-row syntax supplied a missing numerical/address/flag input", api, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_official_single_source_narrowing_test.go b/x86_official_single_source_narrowing_test.go
new file mode 100644
index 000000000..f1a0e4bfb
--- /dev/null
+++ b/x86_official_single_source_narrowing_test.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialSingleSourceNarrowingRowsThreeAPIsObjectsAndTerminalFaults(t *testing.T) {
+	cases := x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86SingleSourceNarrowingRows, 108, 324, 0,
+		x86OfficialMoveAssembly, x86OfficialMoveInspectFaults)
+	faults := 0
+	for _, fixture := range cases {
+		if fixture.witness.Zeroing && fixture.witness.Destination == "(AX)" {
+			faults++
+		}
+	}
+	if faults != 54 || len(cases)-faults != 270 {
+		t.Fatal("ordinary initialized narrowing and encoded terminal #UD were conflated", len(cases), faults)
+	}
+}
diff --git a/x86_official_special_vector_state_rows_test.go b/x86_official_special_vector_state_rows_test.go
new file mode 100644
index 000000000..bfc89112d
--- /dev/null
+++ b/x86_official_special_vector_state_rows_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// These are initialized source/object witnesses. Independent numerical/native
+// owners retain their own scope; an object pass is not executed semantics.
+func x86OfficialSpecialVectorStateAssembly(t *testing.T, cases []x86OfficialPackedCase) (string, string) {
+	t.Helper()
+	var source, declarations strings.Builder
+	appendBody := func(fixture *x86OfficialPackedCase, body, declaration string) {
+		found := 0
+		for offset, line := range strings.Split(body, "\n") {
+			if line == fixture.witness.Instruction {
+				fixture.line = strings.Count(source.String(), "\n") + offset + 1
+				found++
+			}
+		}
+		if found != 1 {
+			t.Fatal("fixture must contain its exact original source instruction once", fixture.row, fixture.witness.Instruction, found)
+		}
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+	}
+	for index := range cases {
+		fixture := &cases[index]
+		witness := fixture.witness
+		fixture.symbol = fmt.Sprint("SpecialVector", index)
+		opcode := strings.Split(strings.Fields(witness.Instruction)[0], ".")[0]
+		if strings.HasPrefix(opcode, "V4FM") || strings.HasPrefix(opcode, "V4FNM") || strings.HasPrefix(opcode, "VP4DP") {
+			first, err := strconv.Atoi(witness.Second[1:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			destination, err := strconv.Atoi(witness.Destination[1:])
+			if err != nil {
+				t.Fatal(err)
+			}
+			mode := "plain"
+			if witness.Masked {
+				mode = "merge"
+			}
+			if witness.Zeroing {
+				mode = "zero"
+			}
+			row := x86FourSourceOracleRow{op: opcode, first: first, dest: destination, scalar: strings.HasSuffix(opcode, "SS"), mode: mode}
+			body, declaration := x86FourSourceInitializedSource(row, "amd64", fixture.symbol, false)
+			appendBody(fixture, body, declaration)
+			continue
+		}
+		declaration := fmt.Sprintf("func %s(out *[2048]byte,a *[64]byte,b *[256]byte,old *[64]byte,mask uint64,lengthA,lengthB int64)\n", fixture.symbol)
+		var body strings.Builder
+		fmt.Fprintf(&body, "TEXT ·%s(SB),4,$0-56\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\nMOVQ old+24(FP),DX\n", fixture.symbol)
+		zero := opcode == "VZEROALL" || opcode == "VZEROUPPER"
+		state := opcode == "VLDMXCSR" || opcode == "VSTMXCSR"
+		flagOnly := strings.HasPrefix(opcode, "VCOMI") || strings.HasPrefix(opcode, "VUCOMI") ||
+			opcode == "VPTEST" || opcode == "VTESTPD" || opcode == "VTESTPS"
+		packedString := strings.HasPrefix(opcode, "VPCMPESTR") || strings.HasPrefix(opcode, "VPCMPISTR")
+		if zero {
+			// Four affected full aliases are caller-supplied and observed. The existing
+			// whole-bank runtime owner separately checks every register and view.
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&body, "VMOVUPS %d(BX),Z%d\n", register*64, register)
+			}
+		} else if !state {
+			instruction := x86ScalarLaneInstruction(t, witness.Instruction)
+			last := len(instruction.Args) - 1
+			seeded := make(map[int]bool)
+			seed := 0
+			for at, operand := range instruction.Args {
+				if operand.Kind != OpReg || at == last && !flagOnly && !packedString {
+					continue
+				}
+				number, valid := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+				if !valid || seeded[number] {
+					continue
+				}
+				seeded[number] = true
+				pointer, displacement := "AX", 0
+				if seed > 0 {
+					pointer, displacement = "BX", (seed-1)*64
+				}
+				fmt.Fprintf(&body, "VMOVUPS %d(%s),Z%d\n", displacement, pointer, number)
+				seed++
+			}
+			if witness.Masked {
+				body.WriteString("MOVQ mask+32(FP),R9\nKMOVQ R9,K1\n")
+				if !witness.Zeroing && !witness.MaskResult {
+					destination, valid := amd64VectorRegisterIndex(Reg(witness.Destination), amd64VectorByteWidth(Reg(witness.Destination)))
+					if !valid {
+						t.Fatal("masked vector output is not a vector carrier", witness)
+					}
+					if !seeded[destination] {
+						fmt.Fprintf(&body, "VMOVUPS (DX),Z%d\n", destination)
+					}
+				}
+			}
+			if packedString {
+				// BX is the source pointer before EAX/EDX become independent numerical
+				// lengths. No pointer bit is borrowed as an implicit integer input.
+				body.WriteString("MOVQ AX,BX\n")
+				if strings.HasPrefix(opcode, "VPCMPESTR") {
+					body.WriteString("MOVQ lengthA+40(FP),AX\nMOVQ lengthB+48(FP),DX\n")
+				}
+			}
+		}
+		if opcode == "VSTMXCSR" {
+			body.WriteString("MOVQ DI,AX\n")
+		}
+		body.WriteString("MOVL $5,R8\nCMPL R8,$3\n")
+		body.WriteString(witness.Instruction + "\n")
+		switch {
+		case zero:
+			for register := 0; register < 4; register++ {
+				fmt.Fprintf(&body, "VMOVUPS Z%d,%d(DI)\n", register, register*64)
+			}
+		case state:
+			body.WriteString("STMXCSR 64(DI)\n")
+		case packedString:
+			if strings.HasSuffix(opcode, "M") {
+				body.WriteString("VMOVUPS Z0,0(DI)\n")
+			} else {
+				body.WriteString("MOVQ CX,0(DI)\n")
+			}
+		case flagOnly:
+			// The following masked PUSHF observation is the actual result.
+		case witness.MaskResult:
+			fmt.Fprintf(&body, "KMOVQ %s,R9\nMOVQ R9,0(DI)\n", witness.Destination)
+		default:
+			destination, valid := amd64VectorRegisterIndex(Reg(witness.Destination), amd64VectorByteWidth(Reg(witness.Destination)))
+			if !valid {
+				t.Fatal("ordinary output lost its vector carrier", witness)
+			}
+			fmt.Fprintf(&body, "VMOVUPS Z%d,0(DI)\n", destination)
+		}
+		body.WriteString("PUSHFQ\nPOPQ R8\nANDL $0x8d5,R8\nMOVL R8,320(DI)\nSTMXCSR 324(DI)\nRET\n")
+		appendBody(fixture, body.String(), declaration)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialSpecialVectorStateRowsInitializedThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	// The independent per-row source/control count excludes controls belonging
+	// to other encoding blocks in the same opcode payload. The original 1052
+	// whole-payload projection is retained as a failed preparation observation.
+	x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86SpecialVectorStateRows, 237, 886, 0,
+		func(cases []x86OfficialPackedCase) (string, string) {
+			return x86OfficialSpecialVectorStateAssembly(t, cases)
+		}, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
diff --git a/x86_official_stack_control_rows_test.go b/x86_official_stack_control_rows_test.go
new file mode 100644
index 000000000..0248cc715
--- /dev/null
+++ b/x86_official_stack_control_rows_test.go
@@ -0,0 +1,708 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86StackControlRelocation struct {
+	Offset, Size int
+	Kind, Symbol string
+	Add          int64
+}
+
+type x86StackControlSourceWitness struct {
+	goasmrules.X86ScalarRMWWitness
+	Origin      string
+	Relocations []x86StackControlRelocation
+	padding     int
+}
+
+type x86StackControlSourceRow struct {
+	Opcode, ModeFiltered string
+	Witnesses            []x86StackControlSourceWitness
+}
+
+type x86StackControlOriginalCase struct {
+	x86OfficialPackedCase
+	origin      string
+	relocations []x86StackControlRelocation
+	padding     int
+	refused     bool
+}
+
+// Older original backends surround AMD64 DUFF calls with their own BP
+// transport. Capture both the byte declarations and their actual use; their
+// presence is a source fact, not a hard-coded Go-version choice.
+func x86StackControlOriginalDuffFrame(t *testing.T) ([]byte, []byte) {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values, uses := map[string][]byte{}, map[string]int{}
+	for _, declaration := range file.Decls {
+		if group, ok := declaration.(*ast.GenDecl); ok && group.Tok == token.VAR {
+			for _, specification := range group.Specs {
+				specification, ok := specification.(*ast.ValueSpec)
+				if !ok || len(specification.Names) != 1 || len(specification.Values) != 1 {
+					continue
+				}
+				name := specification.Names[0].Name
+				if name != "bpduff1" && name != "bpduff2" {
+					continue
+				}
+				literal, ok := specification.Values[0].(*ast.CompositeLit)
+				if !ok || values[name] != nil {
+					t.Fatal("ambiguous original DUFF BP declaration", name)
+				}
+				for _, element := range literal.Elts {
+					atom, ok := element.(*ast.BasicLit)
+					if !ok || atom.Kind != token.INT {
+						t.Fatal("nonliteral original DUFF BP byte", name)
+					}
+					value, err := strconv.ParseUint(atom.Value, 0, 8)
+					if err != nil {
+						t.Fatal(err)
+					}
+					values[name] = append(values[name], byte(value))
+				}
+			}
+		}
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "doasm" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			call, ok := node.(*ast.CallExpr)
+			if !ok || len(call.Args) != 1 {
+				return true
+			}
+			selector, ok := call.Fun.(*ast.SelectorExpr)
+			if !ok || selector.Sel.Name != "Put" {
+				return true
+			}
+			receiver, ok := selector.X.(*ast.Ident)
+			argument, named := call.Args[0].(*ast.Ident)
+			if ok && named && receiver.Name == "ab" && (argument.Name == "bpduff1" || argument.Name == "bpduff2") {
+				uses[argument.Name]++
+			}
+			return true
+		})
+	}
+	if len(values) == 0 && len(uses) == 0 {
+		return nil, nil
+	}
+	if len(values) != 2 || len(uses) != 2 || uses["bpduff1"] != 1 || uses["bpduff2"] != 1 {
+		t.Fatal("incomplete original DUFF BP source transport", values, uses)
+	}
+	return values["bpduff1"], values["bpduff2"]
+}
+
+func x86StackControlOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) []x86StackControlOriginalCase {
+	t.Helper()
+	var result []x86StackControlOriginalCase
+	duffBefore, duffAfter := x86StackControlOriginalDuffFrame(t)
+	rows := 0
+	for _, entry := range catalog.Optab {
+		switch entry.Ytab {
+		case "ycall", "yloop", "yjmp", "ypopl", "ypushl", "yret", "yduff":
+		default:
+			continue
+		}
+		var payload []byte
+		for _, atom := range entry.OpBytes {
+			value, err := strconv.ParseUint(atom, 0, 8)
+			if err != nil {
+				t.Fatal("original stack/control byte atom", entry.Opcode, atom, err)
+			}
+			payload = append(payload, byte(value))
+		}
+		var prefix []byte
+		if entry.Prefix == "Pe" {
+			prefix = []byte{0x66}
+		} else if entry.Prefix == "Pw" {
+			prefix = []byte{0x48}
+		}
+		for _, operand := range entry.Rows {
+			rows++
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, operand.RowIndex)
+			offset := operand.UnmatchedOffset
+			add := func(arguments string, code []byte, padding int, relocations ...x86StackControlRelocation) {
+				instruction := strings.TrimSpace(entry.Opcode + " " + arguments)
+				origin := "stock-asm"
+				if operand.ZCase == "Zcallduff" {
+					origin = "stock-backend"
+				}
+				result = append(result, x86StackControlOriginalCase{
+					x86OfficialPackedCase: x86OfficialPackedCase{row: id, witness: goasmrules.X86PackedBinaryWitness{
+						Instruction: instruction, Destination: arguments[strings.LastIndex(arguments, ",")+1:],
+						Encoding: append(append([]byte(nil), prefix...), code...),
+					}}, origin: origin, relocations: relocations, padding: padding,
+					refused: entry.Prefix == "P32" && arch == "amd64" || (entry.Prefix == "Py" || entry.Prefix == "Pw") && arch == "386",
+				})
+			}
+			rel := func(kind, symbol string, addend int64, displacement, size int) x86StackControlRelocation {
+				return x86StackControlRelocation{len(prefix) + displacement, size, kind, symbol, addend}
+			}
+			switch operand.ZCase {
+			case "Z_rp", "Zrp_":
+				add("BX", []byte{payload[offset] + 3}, 0)
+			case "Zo_m", "Zm_o", "Zo_m64", "Zcallindreg":
+				operands := []string{"0(SI)"}
+				if operand.ZCase == "Zo_m64" || operand.ZCase == "Zcallindreg" {
+					operands = []string{"BX", "0(SI)"}
+				}
+				if len(operand.Classes) == 2 {
+					operands = []string{"CX,BX"}
+				}
+				for _, arguments := range operands {
+					modrm := byte(6)
+					if strings.HasSuffix(arguments, "BX") {
+						modrm = 0xc3
+					}
+					var relocations []x86StackControlRelocation
+					if operand.ZCase == "Zcallindreg" {
+						relocations = []x86StackControlRelocation{rel("R_CALLIND", "", 0, 0, 0)}
+					}
+					add(arguments, []byte{payload[offset], modrm | payload[offset+1]<<3}, 0, relocations...)
+				}
+			case "Zib_", "Zil_":
+				immediate, width := 7, 1
+				if operand.ZCase == "Zil_" {
+					immediate, width = 300, 4
+					if entry.Prefix == "Pe" {
+						width = 2
+					}
+				}
+				code := []byte{payload[offset]}
+				for index := 0; index < width; index++ {
+					code = append(code, byte(immediate>>uint(index*8)))
+				}
+				add(fmt.Sprintf("$%d", immediate), code, 0)
+			case "Zo_iw":
+				code, arguments := []byte{payload[offset]}, ""
+				if len(operand.Classes) != 0 {
+					code, arguments = append(code, 37, 0), "$37"
+				}
+				add(arguments, code, 0)
+			case "Zcallind":
+				kind := "R_PCREL"
+				if arch == "386" {
+					kind = "R_ADDR"
+				}
+				// checkaddr permits *name(SB), not *name+offset(SB).
+				add("*·Target(SB)", []byte{payload[offset], payload[offset+1], 0, 0, 0, 0}, 0,
+					rel(kind, "literal.Target", 0, 2, 4))
+			case "Zcall", "Zcallduff":
+				arguments, symbol := "·Target+7(SB)", "literal.Target"
+				addend := int64(7)
+				if operand.ZCase == "Zcallduff" {
+					symbol, addend = "runtime."+strings.ToLower(entry.Opcode), 37
+					arguments = "$" + strings.Replace(symbol, ".", "·", 1) + "+37(SB)"
+				}
+				code, displacement := []byte{payload[offset], 0, 0, 0, 0}, 1
+				if operand.ZCase == "Zcallduff" && arch == "amd64" {
+					code = append(append(append([]byte(nil), duffBefore...), code...), duffAfter...)
+					displacement += len(duffBefore)
+				}
+				add(arguments, code, 0, rel("R_CALL", symbol, addend, displacement, 4))
+			case "Zcallcon", "Zjmpcon":
+				opcode := payload[offset]
+				if operand.ZCase == "Zjmpcon" {
+					opcode = payload[offset+1]
+				}
+				add("$37", []byte{opcode, 0, 0, 0, 0}, 0, rel("R_PCREL", "", 37, 1, 4))
+			case "Zloop", "Zjmp":
+				code := []byte{payload[offset], 1}
+				if entry.Opcode == "JCXZL" {
+					code = append([]byte{0x67}, code...)
+				}
+				add("after", code, 1)
+				if operand.ZCase == "Zjmp" {
+					add("after", []byte{payload[offset+1], 160, 0, 0, 0}, 160)
+					add("·Target(SB)", []byte{payload[offset+1], 0, 0, 0, 0}, 0,
+						rel("R_CALL", "literal.Target", 0, 1, 4))
+				}
+			default:
+				t.Fatal("unmodeled original stack/control zcase", entry, operand)
+			}
+		}
+	}
+	if rows != 40 || len(result) != 44 {
+		t.Fatal("complete stack/control source inventory changed", rows, len(result))
+	}
+	return result
+}
+
+func x86StackControlOriginalSource(cases []x86StackControlOriginalCase) (string, []x86StackControlOriginalCase) {
+	var source strings.Builder
+	for index := range cases {
+		fixture := &cases[index]
+		fixture.symbol = fmt.Sprintf("StackControl%d", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),516,$0-0\n", fixture.symbol)
+		operation := strings.Fields(fixture.witness.Instruction)[0]
+		width := 0
+		if strings.HasPrefix(operation, "PUSH") || strings.HasPrefix(operation, "POP") {
+			width = map[byte]int{'W': 2, 'L': 4, 'Q': 8}[operation[len(operation)-1]]
+		}
+		if strings.HasPrefix(operation, "POP") {
+			fmt.Fprintf(&source, "ADJSP $%d\n", width)
+		}
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, fixture.witness.Instruction)
+		if strings.HasPrefix(operation, "PUSH") {
+			fmt.Fprintf(&source, "ADJSP $-%d\n", width)
+		}
+		for index := 0; index < fixture.padding; index++ {
+			source.WriteString("BYTE $144\n")
+		}
+		if fixture.padding != 0 {
+			source.WriteString("after:\n")
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String(), cases
+}
+
+func x86StackControlRelocationEnums(t *testing.T) map[string]string {
+	t.Helper()
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/objabi/reloctype_string.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	result := map[string]string{}
+	for _, kind := range []string{"R_ADDR", "R_PCREL", "R_CALL", "R_CALLIND"} {
+		expression := `(?m)^[\t ]*_ = x\[` + kind + `-([0-9]+)\][\t ]*$`
+		matches := regexp.MustCompile(expression).FindAllStringSubmatch(string(source), -1)
+		if len(matches) != 1 {
+			t.Fatal("selected SDK lacks one exact relocation enum assertion", kind, len(matches))
+		}
+		result[matches[0][1]] = kind
+	}
+	return result
+}
+
+func x86StackControlVerifyListing(listing string, cases []x86StackControlOriginalCase, enums map[string]string) error {
+	var packed []x86OfficialPackedCase
+	owners := map[string]x86StackControlOriginalCase{}
+	for _, fixture := range cases {
+		packed, owners[fixture.symbol] = append(packed, fixture.x86OfficialPackedCase), fixture
+	}
+	if err := x86OfficialPackedVerifyListing(listing, packed); err != nil {
+		return err
+	}
+	var owner string
+	pc, target := -1, -1
+	var observed []x86StackControlRelocation
+	finish := func() error {
+		if owner == "" {
+			return nil
+		}
+		fixture := owners[owner]
+		if pc < 0 {
+			return fmt.Errorf("missing actual source PC: %s", fixture.row)
+		}
+		expected := append([]x86StackControlRelocation(nil), fixture.relocations...)
+		for index := range expected {
+			expected[index].Offset += pc
+		}
+		if !reflect.DeepEqual(observed, expected) {
+			return fmt.Errorf("actual PC/relocation differs for %s: got=%+v want=%+v", fixture.row, observed, expected)
+		}
+		if fixture.padding != 0 && target-pc != len(fixture.witness.Encoding)+fixture.padding {
+			return fmt.Errorf("local branch lost actual target PC for %s: %d -> %d", fixture.row, pc, target)
+		}
+		return nil
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && !strings.HasPrefix(fields[0], "0x") && strings.HasPrefix(fields[1], "S") {
+			if err := finish(); err != nil {
+				return err
+			}
+			owner, pc, target, observed = "", -1, -1, nil
+			if fields[1] == "STEXT" || fields[1] == "STEXTFIPS" {
+				owner = strings.TrimPrefix(strings.TrimPrefix(fields[0], "literal."), `"".`)
+			}
+			continue
+		}
+		if owner == "" {
+			continue
+		}
+		if match := x86OfficialPackedListingInstruction.FindStringSubmatch(line); match != nil {
+			position, _ := strconv.Atoi(match[2])
+			lineNumber, _ := strconv.Atoi(match[3])
+			if lineNumber == owners[owner].line {
+				pc = position
+			}
+			if match[4] == "RET" {
+				target = position
+			}
+		}
+		if len(fields) != 0 && fields[0] == "rel" {
+			if len(fields) != 4 || !strings.HasPrefix(fields[2], "t=") {
+				return fmt.Errorf("malformed complete relocation: %s", line)
+			}
+			var offset, size int
+			if _, err := fmt.Sscanf(fields[1], "%d+%d", &offset, &size); err != nil || fields[1] != fmt.Sprintf("%d+%d", offset, size) {
+				return fmt.Errorf("invalid relocation span: %s", line)
+			}
+			kind := strings.TrimPrefix(fields[2], "t=")
+			if symbolic, found := enums[kind]; found {
+				kind = symbolic
+			}
+			separator := strings.LastIndex(fields[3], "+")
+			if separator < 0 {
+				return fmt.Errorf("missing exact relocation symbol/addend: %s", line)
+			}
+			addend, err := strconv.ParseInt(fields[3][separator+1:], 10, 64)
+			if err != nil {
+				return err
+			}
+			symbol := fields[3][:separator]
+			if strings.HasPrefix(symbol, `"".`) {
+				symbol = "literal." + strings.TrimPrefix(symbol, `"".`)
+			}
+			observed = append(observed, x86StackControlRelocation{offset, size, kind, symbol, addend})
+		}
+	}
+	return finish()
+}
+
+func TestX86StackControlOriginalGoBytesPCAndRelocations(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	enums := x86StackControlRelocationEnums(t)
+	accepted, refused := 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var positives []x86StackControlOriginalCase
+			for _, fixture := range x86StackControlOriginalCases(t, catalog, arch) {
+				if fixture.origin != "stock-asm" {
+					continue
+				}
+				if fixture.refused {
+					refused++
+					t.Run(fixture.row, func(t *testing.T) {
+						source, _ := x86StackControlOriginalSource([]x86StackControlOriginalCase{fixture})
+						listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+						if !strings.Contains(listing, "asmins: illegal") || !strings.Contains(listing, strings.Fields(fixture.witness.Instruction)[0]) {
+							t.Fatal("missing actual mode refusal for original source", fixture.row, listing)
+						}
+					})
+					continue
+				}
+				accepted++
+				positives = append(positives, fixture)
+			}
+			for start := 0; start < len(positives); start += 16 {
+				end := start + 16
+				if end > len(positives) {
+					end = len(positives)
+				}
+				source, batch := x86StackControlOriginalSource(append([]x86StackControlOriginalCase(nil), positives[start:end]...))
+				listing, _ := x86ScalarLiteralGoListing(t, arch, source)
+				if err := x86StackControlVerifyListing(listing, batch, enums); err != nil {
+					t.Fatalf("actual stock-asm bytes/PC/relocations: %v\n%s", err, listing)
+				}
+			}
+		})
+	}
+	if accepted != 70 || refused != 14 {
+		t.Fatal("complete stock-asm source/mode inventory changed", accepted, refused)
+	}
+}
+
+// Preserve the existing source owners and add the separate control grammar.
+// Complete source transport supplies no stack or native caller permissions.
+func x86StackControlExistingSourceJoin(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) map[string]x86StackControlSourceRow {
+	t.Helper()
+	joined := map[string]x86StackControlSourceRow{}
+	for _, load := range []func(goasmrules.X86LegacyCatalog, string) ([]goasmrules.X86ScalarRMWRow, error){
+		goasmrules.X86ScalarRMWRows, goasmrules.X86ScalarRMRegisterRows, goasmrules.X86ZeroOperandRows,
+	} {
+		rows, err := load(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, row := range rows {
+			observed := x86StackControlSourceRow{Opcode: row.Opcode, ModeFiltered: row.ModeFiltered}
+			for _, witness := range row.Witnesses {
+				observed.Witnesses = append(observed.Witnesses, x86StackControlSourceWitness{X86ScalarRMWWitness: witness, Origin: "stock-asm"})
+			}
+			joined[row.ID] = observed
+		}
+	}
+	source, err := goasmrules.LoadX86StackControlSource(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86StackControlRows(catalog, source, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range rows {
+		if _, duplicate := joined[row.ID]; duplicate {
+			t.Fatal("stack/control source widened an old scalar member", row.ID)
+		}
+		observed := x86StackControlSourceRow{Opcode: row.Opcode, ModeFiltered: row.ModeFiltered}
+		for _, witness := range row.Witnesses {
+			converted := x86StackControlSourceWitness{X86ScalarRMWWitness: witness.X86ScalarRMWWitness,
+				Origin: witness.Origin, padding: witness.BranchPadding}
+			for _, relocation := range witness.Relocations {
+				converted.Relocations = append(converted.Relocations, x86StackControlRelocation(relocation))
+			}
+			observed.Witnesses = append(observed.Witnesses, converted)
+		}
+		joined[row.ID] = observed
+	}
+	return joined
+}
+
+func TestX86StackControlCompleteSourceJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86StackControlRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			joined := x86StackControlExistingSourceJoin(t, catalog, arch)
+			expected := map[string][]x86StackControlOriginalCase{}
+			for _, fixture := range x86StackControlOriginalCases(t, catalog, arch) {
+				expected[fixture.row] = append(expected[fixture.row], fixture)
+			}
+			for id, fixtures := range expected {
+				t.Run(id, func(t *testing.T) {
+					actual, found := joined[id]
+					if !found {
+						t.Fatal("STACK_CONTROL_SOURCE_ID_FEATURE_GAP", id)
+					}
+					if actual.Opcode != strings.Fields(fixtures[0].witness.Instruction)[0] {
+						t.Fatal("source opcode disagrees with its complete original ID", id, actual)
+					}
+					if fixtures[0].refused {
+						if actual.ModeFiltered == "" || len(actual.Witnesses) != 0 {
+							t.Fatal("actual mode-refused source became a byte witness", id, actual)
+						}
+						return
+					}
+					if actual.ModeFiltered != "" || len(actual.Witnesses) != len(fixtures) {
+						t.Fatal("complete source witness count changed", id, len(actual.Witnesses), len(fixtures))
+					}
+					for index, observed := range actual.Witnesses {
+						fixture := fixtures[index]
+						if observed.Instruction != fixture.witness.Instruction || observed.Destination != fixture.witness.Destination ||
+							!bytes.Equal(observed.Encoding, fixture.witness.Encoding) || observed.Origin != fixture.origin ||
+							!reflect.DeepEqual(observed.Relocations, fixture.relocations) || observed.padding != fixture.padding {
+							t.Fatal("exact source instruction/bytes/destination/origin/relocations changed", observed, fixture)
+						}
+					}
+				})
+			}
+			if len(expected) != 40 {
+				t.Fatal("source ID denominator changed", len(expected))
+			}
+			source, err := goasmrules.LoadX86StackControlSource(runtime.GOROOT())
+			if err != nil {
+				t.Fatal(err)
+			}
+			modes[arch], err = goasmrules.X86StackControlRows(catalog, source, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	if !t.Failed() {
+		before, after := x86StackControlOriginalDuffFrame(t)
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_STACK_CONTROL_IDENTITY_OUTPUT", struct {
+			Source                goasmrules.X86LegacyCatalog
+			Modes                 map[string][]goasmrules.X86StackControlRow
+			DuffBefore, DuffAfter []byte
+		}{catalog, modes, before, after})
+	}
+}
+
+type x86StackControlBackendRecord struct {
+	Arch, Opcode, Origin string
+	PC                   int64
+	Encoding             []byte
+	Offset, Size, Kind   int
+	Symbol               string
+	Add                  int64
+}
+
+func x86StackControlVerifyBackendRecord(record x86StackControlBackendRecord, arch string, fixture x86StackControlOriginalCase, kind int) error {
+	if record.Arch != arch || record.Opcode != strings.Fields(fixture.witness.Instruction)[0] ||
+		record.Origin != "stock-backend" || fixture.origin != "stock-backend" || record.PC != 13 ||
+		!bytes.Equal(record.Encoding, fixture.witness.Encoding) || len(fixture.relocations) != 1 {
+		return fmt.Errorf("original backend source identity/PC/bytes changed: %+v", record)
+	}
+	expected := fixture.relocations[0]
+	if record.Offset != int(record.PC)+expected.Offset || record.Size != expected.Size || record.Kind != kind ||
+		record.Symbol == "" || record.Symbol != expected.Symbol || record.Add != expected.Add {
+		return fmt.Errorf("original backend relocation identity changed: %+v", record)
+	}
+	return nil
+}
+
+func TestX86StackControlOriginalGoBackendDuffs(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := map[string]x86StackControlOriginalCase{}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, fixture := range x86StackControlOriginalCases(t, catalog, arch) {
+			if fixture.origin == "stock-backend" {
+				expected[arch+"/"+strings.Fields(fixture.witness.Instruction)[0]] = fixture
+			}
+		}
+	}
+	kind := -1
+	for number, name := range x86StackControlRelocationEnums(t) {
+		if name == "R_CALL" {
+			kind, _ = strconv.Atoi(number)
+		}
+	}
+	output := x86OriginalGoBackendOutput(t, "testdata/goasm/stack_control_backend_test.go", "TestPlan9asmOriginalDuffSource")
+	if destination := os.Getenv("PLAN9ASM_STACK_CONTROL_BACKEND_OUTPUT"); destination != "" {
+		if err := os.WriteFile(destination, output, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	seen := map[string]bool{}
+	runs, passes := 0, 0
+	for _, line := range bytes.Split(output, []byte("\n")) {
+		if len(bytes.TrimSpace(line)) == 0 {
+			continue
+		}
+		var event struct{ Action, Test, Output string }
+		if err := json.Unmarshal(line, &event); err != nil {
+			t.Fatal("non-JSON actual backend command output", err, string(line))
+		}
+		if event.Test == "TestPlan9asmOriginalDuffSource" && event.Action == "run" {
+			runs++
+		} else if event.Test == "TestPlan9asmOriginalDuffSource" && event.Action == "pass" {
+			passes++
+		} else if event.Action == "fail" || event.Action == "skip" {
+			t.Fatal("backend observer failed or skipped", event)
+		}
+		const marker = "PLAN9ASM_SOURCE_DUFF "
+		position := strings.Index(event.Output, marker)
+		if event.Action != "output" || position < 0 {
+			continue
+		}
+		if event.Test != "TestPlan9asmOriginalDuffSource" {
+			t.Fatal("backend source marker escaped its owned observer root", event.Test)
+		}
+		var record x86StackControlBackendRecord
+		if err := json.Unmarshal([]byte(strings.TrimSpace(event.Output[position+len(marker):])), &record); err != nil {
+			t.Fatal(err)
+		}
+		key := record.Arch + "/" + record.Opcode
+		fixture, found := expected[key]
+		if !found || seen[key] {
+			t.Fatal("unowned or duplicate actual backend source record", key)
+		}
+		if err := x86StackControlVerifyBackendRecord(record, record.Arch, fixture, kind); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("ACTUAL_STACK_CONTROL_BACKEND %s", strings.TrimSpace(event.Output[position+len(marker):]))
+		seen[key] = true
+	}
+	if runs != 1 || passes != 1 || len(seen) != 4 || len(expected) != 4 {
+		t.Fatal("incomplete actual backend observation", runs, passes, len(seen), len(expected))
+	}
+	t.Log("STACK_CONTROL_BACKEND_SOURCE rows=2 actual_mode_records=4 stock_frontend_successes=0 native_execution=0")
+}
+
+func TestX86StackControlBackendEvidenceRejectsCounterfeits(t *testing.T) {
+	fixture := x86StackControlOriginalCase{origin: "stock-backend",
+		x86OfficialPackedCase: x86OfficialPackedCase{witness: goasmrules.X86PackedBinaryWitness{
+			Instruction: "DUFFCOPY $runtime·duffcopy+37(SB)", Encoding: []byte{0xe8, 0, 0, 0, 0}}},
+		relocations: []x86StackControlRelocation{{1, 4, "R_CALL", "runtime.duffcopy", 37}}}
+	original := x86StackControlBackendRecord{"amd64", "DUFFCOPY", "stock-backend", 13,
+		[]byte{0xe8, 0, 0, 0, 0}, 14, 4, 93, "runtime.duffcopy", 37}
+	if err := x86StackControlVerifyBackendRecord(original, "amd64", fixture, 93); err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*x86StackControlBackendRecord){
+		"nil-symbol":              func(r *x86StackControlBackendRecord) { r.Symbol = "" },
+		"foreign-symbol":          func(r *x86StackControlBackendRecord) { r.Symbol = "runtime.duffzero" },
+		"foreign-relocation":      func(r *x86StackControlBackendRecord) { r.Kind++ },
+		"wrong-addend":            func(r *x86StackControlBackendRecord) { r.Add++ },
+		"wrong-PC":                func(r *x86StackControlBackendRecord) { r.PC++ },
+		"correlated-wrong-PC":     func(r *x86StackControlBackendRecord) { r.PC++; r.Offset++ },
+		"wrong-relocation-offset": func(r *x86StackControlBackendRecord) { r.Offset++ },
+		"wrong-relocation-size":   func(r *x86StackControlBackendRecord) { r.Size = 0 },
+		"frontend-misattribution": func(r *x86StackControlBackendRecord) { r.Origin = "stock-asm" },
+		"foreign-mode":            func(r *x86StackControlBackendRecord) { r.Arch = "386" },
+		"truncated-bytes":         func(r *x86StackControlBackendRecord) { r.Encoding = r.Encoding[:4] },
+		"different-opcode":        func(r *x86StackControlBackendRecord) { r.Encoding = []byte{0xe9, 0, 0, 0, 0} },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := original
+			mutate(&changed)
+			if err := x86StackControlVerifyBackendRecord(changed, "amd64", fixture, 93); err == nil {
+				t.Fatal("counterfeit backend source evidence was accepted", name, changed)
+			}
+		})
+	}
+}
+
+func TestX86StackControlListingRejectsIncompleteRelocations(t *testing.T) {
+	fixture := x86StackControlOriginalCase{origin: "stock-asm",
+		x86OfficialPackedCase: x86OfficialPackedCase{row: "optab/fixture/CALL/ycall/3", symbol: "Row0", line: 2,
+			witness: goasmrules.X86PackedBinaryWitness{Instruction: "CALL ·Target+7(SB)", Destination: "·Target+7(SB)",
+				Encoding: []byte{0xe8, 0, 0, 0, 0}}},
+		relocations: []x86StackControlRelocation{{1, 4, "R_CALL", "literal.Target", 7}}}
+	listing := `literal.Row0 STEXT nosplit asm size=6 align=0x0 args=0x0 locals=0x0
+  0x0000 00000 (literal.s:1) TEXT literal.Row0(SB), NOSPLIT|NOFRAME, $0-0
+  0x0000 00000 (literal.s:2) CALL literal.Target+7(SB)
+  0x0005 00005 (literal.s:3) RET
+` + fmt.Sprintf("  0x0000%-48s  ......\n", " e8 00 00 00 00 c3") + "\trel 1+4 t=R_CALL literal.Target+7\n"
+	enums := map[string]string{"93": "R_CALL"}
+	for _, compatible := range []string{listing, strings.Replace(listing, "t=R_CALL", "t=93", 1),
+		strings.ReplaceAll(listing, "literal.", `"".`)} {
+		if err := x86StackControlVerifyListing(compatible, []x86StackControlOriginalCase{fixture}, enums); err != nil {
+			t.Fatal("complete known SDK listing spelling was lost", err)
+		}
+	}
+	for name, changed := range map[string]string{
+		"missing-relocation":   strings.Replace(listing, "\trel 1+4 t=R_CALL literal.Target+7\n", "", 1),
+		"duplicate-relocation": listing + "\trel 1+4 t=R_CALL literal.Target+7\n",
+		"unknown-numeric-kind": strings.Replace(listing, "t=R_CALL", "t=94", 1),
+		"foreign-kind":         strings.Replace(listing, "t=R_CALL", "t=R_PCREL", 1),
+		"wrong-symbol":         strings.Replace(listing, "t=R_CALL literal.Target", "t=R_CALL literal.Other", 1),
+		"wrong-addend":         strings.Replace(listing, "t=R_CALL literal.Target+7", "t=R_CALL literal.Target+8", 1),
+		"wrong-offset":         strings.Replace(listing, "rel 1+4", "rel 2+4", 1),
+		"wrong-size":           strings.Replace(listing, "rel 1+4", "rel 1+8", 1),
+		"trailing-fields":      strings.Replace(listing, "t=R_CALL literal.Target+7", "t=R_CALL literal.Target+7 extra", 1),
+		"truncated-record":     strings.Replace(listing, "t=R_CALL literal.Target+7", "t=R_CALL", 1),
+		"wrong-PC":             strings.Replace(listing, "0x0005 00005", "0x0004 00004", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := x86StackControlVerifyListing(changed, []x86StackControlOriginalCase{fixture}, enums); err == nil {
+				t.Fatal("unchanged zero bytes concealed invalid PC/relocation evidence", name)
+			}
+		})
+	}
+}
diff --git a/x86_official_state_system_memory_rows_test.go b/x86_official_state_system_memory_rows_test.go
new file mode 100644
index 000000000..947ae7b1f
--- /dev/null
+++ b/x86_official_state_system_memory_rows_test.go
@@ -0,0 +1,551 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The stock assembler's refusal and this original backend observation are
+// independent. Only this actual observer can turn a candidate backend byte
+// sequence into evidence; it grants no numerical or native-entry permission.
+func TestX86StateSystemMemoryOriginalBackend(t *testing.T) {
+	const root = "TestPlan9asmOriginalStateSystemBackend"
+	output := x86OriginalGoBackendOutput(t, "testdata/goasm/state_system_backend_test.go", root)
+	type record struct {
+		Arch, Opcode, Origin string
+		PC                   int64
+		Encoding             []byte
+		Offset, Size, Kind   int
+		KindName, Symbol     string
+		Add                  int64
+	}
+	runs, passes := map[string]int{}, map[string]int{}
+	records := map[string]record{}
+	packagePasses := 0
+	for _, line := range bytes.Split(bytes.TrimSpace(output), []byte{'\n'}) {
+		var event struct{ Action, Test, Output string }
+		if err := json.Unmarshal(line, &event); err != nil {
+			t.Fatal("original backend emitted non-JSON output", err, string(line))
+		}
+		switch event.Action {
+		case "run":
+			runs[event.Test]++
+		case "pass":
+			if event.Test == "" {
+				packagePasses++
+			} else {
+				passes[event.Test]++
+			}
+		case "fail", "skip", "build-fail":
+			t.Fatal("original backend did not complete every owned case", event)
+		}
+		const marker = "PLAN9ASM_STATE_SYSTEM_BACKEND "
+		if position := strings.Index(event.Output, marker); position >= 0 {
+			var actual record
+			if err := json.Unmarshal([]byte(strings.TrimSpace(event.Output[position+len(marker):])), &actual); err != nil {
+				t.Fatal("invalid actual backend record", err)
+			}
+			name := actual.Arch + "/" + actual.Opcode
+			if _, duplicate := records[name]; duplicate || event.Test != root+"/"+name {
+				t.Fatal("backend record lost its unique actual test owner", name, event.Test)
+			}
+			records[name] = actual
+		}
+	}
+	if len(runs) != 5 || len(passes) != 5 || packagePasses != 1 || len(records) != 4 || runs[root] != 1 || passes[root] != 1 {
+		t.Fatal("incomplete actual backend execution", runs, passes, packagePasses, records)
+	}
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	frontend, err := goasmrules.LoadX86UnaryDestinations(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86StateSystemMemoryRows(catalog, frontend, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, opcode := range []string{"FLDENV", "XBEGIN"} {
+			name := arch + "/" + opcode
+			t.Run(name, func(t *testing.T) {
+				actual, found := records[name]
+				if !found || runs[root+"/"+name] != 1 || passes[root+"/"+name] != 1 || actual.Origin != "stock-backend" || actual.PC != 13 {
+					t.Fatal("backend identity or execution differs", name, actual)
+				}
+				if opcode == "XBEGIN" {
+					// The fixture compares Type to the actual SDK objabi.R_CALL;
+					// never share a hard-coded relocation enum across SDKs.
+					if !bytes.Equal(actual.Encoding, []byte{0xc7, 0xf8, 0, 0, 0, 0}) || actual.Offset != 15 || actual.Size != 4 || actual.Kind <= 0 || actual.KindName != "R_CALL" || actual.Symbol != "plan9asm.backend.target" || actual.Add != 0 {
+						t.Fatal("actual external branch encoding or relocation differs", actual)
+					}
+				} else {
+					if !bytes.Equal(actual.Encoding, []byte{0xd9, 0x26}) || actual.Offset != 0 || actual.Size != 0 || actual.Kind != 0 || actual.KindName != "" || actual.Symbol != "" || actual.Add != 0 {
+						t.Fatal("actual FLDENV encoding or absent relocation differs", actual)
+					}
+					joined := 0
+					for _, row := range rows {
+						if row.Opcode == opcode {
+							if row.FrontendRejected == "" || row.ModeFiltered != "" || len(row.Witnesses) != 0 || len(row.BackendWitnesses) != 1 || !bytes.Equal(row.BackendWitnesses[0].Encoding, actual.Encoding) {
+								t.Fatal("backend bytes lost the original frontend boundary", row)
+							}
+							joined++
+						}
+					}
+					if joined != 1 {
+						t.Fatal("actual backend record did not join exactly one original source row", joined)
+					}
+				}
+				t.Logf("ACTUAL_STATE_SYSTEM_BACKEND arch=%s opcode=%s bytes=%x relocation=%s/%d pc=%d", arch, opcode, actual.Encoding, actual.KindName, actual.Kind, actual.PC)
+			})
+		}
+	}
+}
+
+func stateSystemOriginalUnaryDestinations(t *testing.T) map[string]bool {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/obj6.go"), nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	result := map[string]bool{}
+	for _, declaration := range file.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok {
+			continue
+		}
+		for _, spec := range group.Specs {
+			value, ok := spec.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || value.Names[0].Name != "unaryDst" || len(value.Values) != 1 {
+				continue
+			}
+			literal, ok := value.Values[0].(*ast.CompositeLit)
+			if !ok {
+				t.Fatal("original unaryDst is not a complete source literal")
+			}
+			for _, element := range literal.Elts {
+				pair := element.(*ast.KeyValueExpr)
+				key, setting := pair.Key.(*ast.Ident), pair.Value.(*ast.Ident)
+				if !strings.HasPrefix(key.Name, "A") || setting.Name != "true" && setting.Name != "false" {
+					t.Fatal("original unaryDst key/value changed", element)
+				}
+				result[strings.TrimPrefix(key.Name, "A")] = setting.Name == "true"
+			}
+		}
+	}
+	if len(result) == 0 {
+		t.Fatal("actual SDK has no captured unaryDst source roles")
+	}
+	return result
+}
+
+func stateSystemSourceTable(table string) bool {
+	switch table {
+	case "yclflush", "ysvrs_mo", "ysvrs_om", "yin", "yint", "ydivl", "ydivb",
+		"ywrfsbase", "ycrc32l", "yprefetch", "yincq", "yrdrand", "ym_rl",
+		"yrl_m", "yrl_ml", "yxbegin", "yxabort":
+		return true
+	}
+	return false
+}
+
+// This source-only reference follows Go's prefix switch, selected Z-case and
+// final REX insertion. It never calls a production witness formatter and none
+// of these assembled instructions is executed. Privileged and CPU-invalid
+// encodings remain source observations, not numerical/native positives.
+func stateSystemOriginalCases(t *testing.T, catalog goasmrules.X86LegacyCatalog, arch string) ([]x86OfficialPackedCase, []x86OfficialPackedCase, []x86OfficialPackedCase) {
+	t.Helper()
+	var accepted, refused, frontend []x86OfficialPackedCase
+	unary := stateSystemOriginalUnaryDestinations(t)
+	for _, entry := range catalog.Optab {
+		if !stateSystemSourceTable(entry.Ytab) {
+			continue
+		}
+		var atoms []byte
+		for _, token := range entry.OpBytes {
+			value, err := strconv.ParseUint(token, 0, 8)
+			if err != nil {
+				t.Fatal("independent original system byte changed", entry, token, err)
+			}
+			atoms = append(atoms, byte(value))
+		}
+		for _, row := range entry.Rows {
+			id := fmt.Sprintf("optab/%d/%s/%s/%d", entry.TableIndex, entry.Opcode, entry.Ytab, row.RowIndex)
+			prefix, found := map[string][]byte{
+				"Px": {}, "Pb": {}, "P32": {}, "Pe": {0x66}, "Pm": {0x0f},
+				"Pq": {0x66, 0x0f}, "Pf2": {0xf2, 0x0f}, "Pf3": {0xf3, 0x0f},
+				"Pw": {}, "Pfw": {0xf3, 0x0f},
+			}[entry.Prefix]
+			cursor := row.UnmatchedOffset
+			if !found || cursor < 0 || cursor >= len(atoms) {
+				t.Fatal("independent system prefix/row offset changed", entry, row)
+			}
+			code := append([]byte(nil), prefix...)
+			if atoms[cursor] == 0x0f {
+				code = append(code, 0x0f)
+				cursor++
+			}
+			if cursor >= len(atoms) {
+				t.Fatal("independent system selected opcode missing", entry, row)
+			}
+			if row.ZCase == "Zlit" || row.ZCase == "Zlitm_r" {
+				// A missing explicit terminator is valid when Go's fixed
+				// opcode array supplies implicit zero padding, e.g. yin.
+				for end := cursor; end < len(atoms) && atoms[end] != 0; end++ {
+					code = append(code, atoms[end])
+				}
+			} else {
+				code = append(code, atoms[cursor])
+			}
+			if entry.Prefix == "Pw" || entry.Prefix == "Pfw" {
+				position := 0
+				for position < len(code) && (code[position] == 0x66 || code[position] == 0xf2 || code[position] == 0xf3) {
+					position++
+				}
+				code = append(code[:position], append([]byte{0x48}, code[position:]...)...)
+			}
+			var operands [][2]string
+			switch row.ZCase {
+			case "Zm_o", "Zo_m":
+				if len(row.Classes) != 1 {
+					t.Fatal("independent unary system operand arity changed", entry, row)
+				}
+				switch row.Classes[0] {
+				case "Ymb":
+					operands = [][2]string{{"", "BL"}, {"", "0(SI)"}}
+				case "Yml":
+					operands = [][2]string{{"", "BX"}, {"", "0(SI)"}}
+				case "Yrl":
+					operands = [][2]string{{"", "BX"}}
+				case "Ym":
+					operands = [][2]string{{"", "0(SI)"}}
+				default:
+					t.Fatal("independent system register/memory class changed", entry, row)
+				}
+			case "Zr_m":
+				operands = [][2]string{{"CX", "0(SI)"}}
+				if row.Classes[1] == "Yml" {
+					operands = append([][2]string{{"CX", "BX"}}, operands...)
+				}
+			case "Zm_r":
+				operands = [][2]string{{"0(SI)", "BX"}}
+			case "Zlitm_r":
+				operands = [][2]string{{"CX", "BX"}, {"0(SI)", "BX"}}
+			case "Zib_":
+				operands = [][2]string{{"", "$7"}}
+			case "Zlit":
+				operands = [][2]string{{"", ""}}
+			case "Zjmp":
+				// A next-instruction target has an independently known zero
+				// rel32. It is not a numeric target or a new raw permission.
+				operands = [][2]string{{"", "1(PC)"}}
+			default:
+				t.Fatal("independent complete system Z-case changed", entry, row)
+			}
+			for _, args := range operands {
+				encoding := append([]byte(nil), code...)
+				memory := args[0] == "0(SI)" || args[1] == "0(SI)"
+				rm := byte(0xc3)
+				if memory {
+					rm = 6
+				}
+				switch row.ZCase {
+				case "Zm_o", "Zo_m":
+					if cursor+1 >= len(atoms) || atoms[cursor+1] > 7 {
+						t.Fatal("independent system /digit changed", entry, row)
+					}
+					encoding = append(encoding, rm|atoms[cursor+1]<<3)
+				case "Zr_m":
+					encoding = append(encoding, rm|1<<3)
+				case "Zm_r":
+					encoding = append(encoding, byte(6|3<<3))
+				case "Zlitm_r":
+					if !memory {
+						rm = 0xc1
+					}
+					encoding = append(encoding, rm|3<<3)
+				case "Zib_":
+					if entry.Ytab == "yxabort" {
+						encoding = append(encoding, atoms[cursor+1])
+					}
+					encoding = append(encoding, 7)
+				case "Zjmp":
+					encoding = append(encoding, atoms[cursor+1], 0, 0, 0, 0)
+				}
+				instruction := entry.Opcode
+				if args[0] != "" {
+					instruction += " " + args[0] + "," + args[1]
+				} else if args[1] != "" {
+					instruction += " " + args[1]
+				}
+				destination := args[1]
+				if row.ZCase == "Zm_o" || row.ZCase == "Zib_" {
+					destination = ""
+				}
+				fixture := x86OfficialPackedCase{row: id, witness: goasmrules.X86PackedBinaryWitness{
+					Instruction: instruction, Encoding: encoding, Destination: destination,
+				}}
+				if (row.ZCase == "Zm_o" || row.ZCase == "Zo_m") && unary[entry.Opcode] != (row.ZCase == "Zo_m") {
+					frontend = append(frontend, fixture)
+					break // Retained separately: stock frontend and backend slots disagree.
+				}
+				filtered := arch == "amd64" && entry.Prefix == "P32" ||
+					arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Pfw")
+				if filtered {
+					// One original source statement suffices for each refused
+					// row; accepted modes retain all register/memory cases.
+					refused = append(refused, fixture)
+					break
+				}
+				accepted = append(accepted, fixture)
+			}
+		}
+	}
+	want, filtered := 187, 2
+	if arch == "386" {
+		want, filtered = 144, 31
+	}
+	hasRDPID := false
+	for _, entry := range catalog.Optab {
+		hasRDPID = hasRDPID || entry.Opcode == "RDPID"
+	}
+	if !hasRDPID {
+		want--
+	}
+	if len(accepted) != want || len(refused) != filtered || len(frontend) != 1 {
+		t.Fatal("complete independent system source denominator changed", arch, len(accepted), len(refused), len(frontend), want, filtered)
+	}
+	return accepted, refused, frontend
+}
+
+func stateSystemOriginalXBEGINBoundary(t *testing.T, arch string) {
+	t.Helper()
+	const external = "XBEGIN ·ExternalTarget(SB)"
+	source := "TEXT ·SystemExternalBranch(SB),4,$0-0\n" + external + "\nRET\n"
+	listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+	if !strings.Contains(listing, "XBEGIN") || !strings.Contains(listing, "invalid instruction") {
+		t.Fatal("original external XBEGIN lacks its concrete frontend rejection", listing)
+	}
+	// Stock asm preserves an SB target as TYPE_MEM, which does not match Ybr.
+	// Local branches are distinct source positives, including relative fixups.
+	for _, row := range []struct {
+		name, instruction, tail string
+		encoding                []byte
+	}{
+		{"self", "XBEGIN 0(PC)", "", []byte{0xc7, 0xf8, 0xfa, 0xff, 0xff, 0xff}},
+		{"forward", "XBEGIN 2(PC)", "BYTE $0x90\n", []byte{0xc7, 0xf8, 1, 0, 0, 0}},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			body := "TEXT ·LocalBranch(SB),4,$0-0\n" + row.instruction + "\n" + row.tail + "RET\n"
+			actual, _ := x86ScalarLiteralExpectedGoListing(t, arch, body, true)
+			fixture := x86OfficialPackedCase{symbol: "LocalBranch", line: 2, row: "original-XBEGIN-local-rel32",
+				witness: goasmrules.X86PackedBinaryWitness{Instruction: row.instruction, Encoding: row.encoding}}
+			if err := x86OfficialPackedVerifyListing(actual, []x86OfficialPackedCase{fixture}); err != nil {
+				t.Fatal("original local XBEGIN rel32 fixup differs", err)
+			}
+			for _, line := range strings.Split(actual, "\n") {
+				fields := strings.Fields(line)
+				if len(fields) > 0 && fields[0] == "rel" {
+					t.Fatal("local XBEGIN unexpectedly requires an external relocation", line)
+				}
+			}
+		})
+	}
+}
+
+func stateSystemOriginalFrontendFailure(t *testing.T, arch string, fixture x86OfficialPackedCase) {
+	t.Helper()
+	// This known SDK slot mismatch is not an ordinary syntax rejection.
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "frontend.s"), filepath.Join(dir, "frontend.o")
+	body := "TEXT ·SystemFrontend(SB),4,$0-0\n" + fixture.witness.Instruction + "\nRET\n"
+	if err := os.WriteFile(input, []byte(body), 0600); err != nil {
+		t.Fatal(err)
+	}
+	stage, stop := runtimeOracleStageContext(t)
+	defer stop()
+	ctx, cancel := context.WithTimeout(stage, 30*time.Second)
+	defer cancel()
+	command := exec.CommandContext(ctx, filepath.Join(runtime.GOROOT(), "bin", "go"), "tool", "asm", "-S", "-p", "literal", "-o", object, input)
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	exit, ok := err.(*exec.ExitError)
+	if !ok || exit.ExitCode() != 1 || ctx.Err() != nil || !strings.Contains(string(output), "asm: asmand: bad address") {
+		t.Fatalf("actual original From/To mismatch has no exact SDK failure: %v / %v\n%s", err, ctx.Err(), output)
+	}
+	t.Logf("ORIGINAL_FRONTEND_FAILURE_OUTPUT:\n%s", output)
+	strict := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), false, arch)
+	if strict == nil || !strings.Contains(strict.Error(), "infrastructure failure") {
+		t.Fatal("positionless SDK diagnostic became a bound syntax rejection", strict)
+	}
+	// A single failed function need not produce a listing or complete object.
+	// Its source rejection supplies no successful byte witness. The original
+	// backend, when given From directly, has a separate encoding observation.
+	unchanged, readErr := os.ReadFile(input)
+	if readErr != nil || string(unchanged) != body {
+		t.Fatal("owned original frontend source changed", readErr)
+	}
+	t.Logf("STATE_SYSTEM_STOCK_FRONTEND_FAILURE arch=%s id=%s sourceSHA=%x outputSHA=%x; unaryDst and Z-case slots disagree; not assembled or translated", arch, fixture.row, sha256.Sum256([]byte(body)), sha256.Sum256(output))
+}
+
+func TestX86OfficialStateSystemMemoryOriginalGoBytesAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	roles, err := goasmrules.LoadX86UnaryDestinations(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86StateSystemMemoryRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch+"/XBEGIN-source-boundaries", func(t *testing.T) {
+			stateSystemOriginalXBEGINBoundary(t, arch)
+		})
+		accepted, refused, frontend := stateSystemOriginalCases(t, catalog, arch)
+		for _, fixture := range frontend {
+			t.Run(arch+"/frontend-failure/"+fixture.row, func(t *testing.T) {
+				stateSystemOriginalFrontendFailure(t, arch, fixture)
+			})
+		}
+		x86LegacyLiteralSIMDCheckGoBatches(t, arch, accepted)
+		for _, fixture := range refused {
+			t.Run(arch+"/mode-refused/"+fixture.row, func(t *testing.T) {
+				source := "TEXT ·Refused(SB),4,$0-0\n" + fixture.witness.Instruction + "\nRET\n"
+				listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+				opcode := strings.Fields(fixture.witness.Instruction)[0]
+				if !strings.Contains(listing, opcode) ||
+					!strings.Contains(listing, "illegal 64") && !strings.Contains(listing, "illegal in") {
+					t.Fatal("Go mode refusal did not identify the original instruction and source mode", fixture.row, listing)
+				}
+			})
+		}
+		actual, err := goasmrules.X86StateSystemMemoryRows(catalog, roles, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		stateSystemJoinOriginalCases(t, arch, actual, accepted, refused, frontend)
+		modes[arch] = actual
+	}
+	if !t.Failed() {
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_STATE_SYSTEM_MEMORY_IDENTITY_OUTPUT", struct {
+			Source   goasmrules.X86LegacyCatalog
+			Frontend map[string]bool
+			Modes    map[string][]goasmrules.X86StateSystemMemoryRow
+		}{catalog, stateSystemOriginalUnaryDestinations(t), modes})
+	}
+}
+
+func stateSystemJoinOriginalCases(t *testing.T, arch string, rows []goasmrules.X86StateSystemMemoryRow, accepted, modeRefused, frontend []x86OfficialPackedCase) {
+	t.Helper()
+	expected := map[string]goasmrules.X86PackedBinaryWitness{}
+	for _, fixture := range accepted {
+		expected[fixture.row+"/"+fixture.witness.Instruction] = fixture.witness
+	}
+	filtered, rejected := map[string]bool{}, map[string]x86OfficialPackedCase{}
+	for _, fixture := range modeRefused {
+		filtered[fixture.row] = true
+	}
+	for _, fixture := range frontend {
+		rejected[fixture.row] = fixture
+	}
+	seen := map[string]bool{}
+	for _, row := range rows {
+		if seen[row.ID] {
+			t.Fatal("duplicate original state source ID", arch, row.ID)
+		}
+		seen[row.ID] = true
+		if original, found := rejected[row.ID]; found {
+			if row.FrontendRejected == "" || row.ModeFiltered != "" || len(row.Witnesses) != 0 || len(row.BackendWitnesses) != 1 {
+				t.Fatal("frontend failure became a mode/target filter or a successful named-source witness", row)
+			}
+			candidate := row.BackendWitnesses[0]
+			if candidate.Instruction != original.witness.Instruction || candidate.Destination != original.witness.Destination || string(candidate.Encoding) != string(original.witness.Encoding) {
+				t.Fatal("backend candidate differs from the complete original encoding table", row, original)
+			}
+			delete(rejected, row.ID)
+			continue
+		}
+		if filtered[row.ID] {
+			if row.ModeFiltered == "" || row.FrontendRejected != "" || len(row.Witnesses) != 0 || len(row.BackendWitnesses) != 0 {
+				t.Fatal("original mode rejection became a successful source encoding", row)
+			}
+			delete(filtered, row.ID)
+			continue
+		}
+		if row.ModeFiltered != "" || row.FrontendRejected != "" || len(row.BackendWitnesses) != 0 || len(row.Witnesses) == 0 {
+			t.Fatal("valid original source disappeared or changed its origin", row)
+		}
+		for _, witness := range row.Witnesses {
+			key := row.ID + "/" + witness.Instruction
+			original, found := expected[key]
+			if !found || witness.Destination != original.Destination || string(witness.Encoding) != string(original.Encoding) {
+				t.Fatal("state source ID/instruction/encoding/destination differs from actual original Go", arch, row.ID, witness, original)
+			}
+			delete(expected, key)
+		}
+	}
+	if len(expected) != 0 || len(filtered) != 0 || len(rejected) != 0 {
+		t.Fatal("state source projection omitted original cases", arch, len(expected), len(filtered), len(rejected))
+	}
+}
+
+func TestX86OfficialStateSystemMemoryOriginalImmediateBoundaries(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		originals, _, _ := stateSystemOriginalCases(t, catalog, arch)
+		var accepted []x86OfficialPackedCase
+		observed := 0
+		for _, original := range originals {
+			if !strings.Contains(original.witness.Instruction, " $7") {
+				continue
+			}
+			observed++
+			values := []int64{-2147483648, -1, 0, 127, 128, 255, 256, 2147483647, 4294967295}
+			if strings.HasPrefix(original.witness.Instruction, "XABORT ") {
+				values = []int64{0, 1, 127, 128, 255}
+			}
+			for _, value := range values {
+				fixture := original
+				fixture.witness.Instruction = strings.Replace(original.witness.Instruction, "$7", fmt.Sprintf("$%d", value), 1)
+				fixture.witness.Encoding = append([]byte(nil), original.witness.Encoding...)
+				fixture.witness.Encoding[len(fixture.witness.Encoding)-1] = byte(value)
+				accepted = append(accepted, fixture)
+			}
+		}
+		if observed != 8 || len(accepted) != 68 {
+			t.Fatal("complete Yi32/Yu8 system immediate inventory changed", arch, observed, len(accepted))
+		}
+		x86LegacyLiteralSIMDCheckGoBatches(t, arch, accepted)
+		for _, instruction := range []string{"XABORT $-1", "XABORT $256"} {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT ·Refused(SB),4,$0-0\n" + instruction + "\nRET\n"
+				listing, _ := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+				if !strings.Contains(listing, "XABORT") || !strings.Contains(listing, "invalid instruction") {
+					t.Fatal("Go Yu8 refusal did not identify the original instruction", listing)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_official_tls_fallback_rows_test.go b/x86_official_tls_fallback_rows_test.go
new file mode 100644
index 000000000..1662ed0b1
--- /dev/null
+++ b/x86_official_tls_fallback_rows_test.go
@@ -0,0 +1,498 @@
+// Source-only TLS observations, separate from translator/runtime permissions.
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+type x86TLSFallbackSourceIdentity struct {
+	ID, Instruction, Origin, Target, SDKVersion string
+	SourceSHA                                   string
+	SDKSourceSHA                                map[string]string
+	Shared                                      bool
+	Encoding                                    []byte
+	Relocations                                 []string
+}
+
+type x86TLSFallbackSourceObservation struct {
+	x86TLSFallbackSourceIdentity
+	ObjectSHA, ListingSHA                     string
+	sourceBytes, objectBytes, listingBytes    []byte
+	sourceDigest, objectDigest, listingDigest [32]byte
+	requestTarget                             string
+	requestShared                             bool
+}
+
+func x86TLSFallbackOriginalID(t *testing.T, catalog goasmrules.X86LegacyCatalog, opcode string) string {
+	t.Helper()
+	if len(catalog.Movtab) != 113 {
+		t.Fatal("complete original move table changed")
+	}
+	var result string
+	for _, row := range catalog.Movtab {
+		if row.Code != "movTLSReg" || row.Opcode != opcode {
+			continue
+		}
+		if result != "" || row.Kind != "encoding" || row.From != "Ytls" || row.From3 != "Ynone" ||
+			row.To != "Yrl" || strings.TrimPrefix(row.OpcodeExpression, "obj.") != "A"+opcode || len(row.OpBytes) > 4 {
+			t.Fatal("complete original TLS fallback row identity changed", row)
+		}
+		// Implicit zero cells are equivalent to the four explicit zero cells.
+		for _, atom := range row.OpBytes {
+			value, err := strconv.ParseUint(atom, 0, 8)
+			if err != nil || value != 0 {
+				t.Fatal("TLS fallback acquired an opaque nonzero payload", row)
+			}
+		}
+		result = fmt.Sprintf("ymovtab/%d/%s/movTLSReg", row.TableIndex, row.Opcode)
+	}
+	if result == "" {
+		t.Fatal("original TLS fallback source row missing", opcode)
+	}
+	return result
+}
+
+func x86TLSFallbackRelocationLines(t *testing.T, listing string) []string {
+	t.Helper()
+	lines, err := x86TLSFallbackReadRelocations(listing)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return lines
+}
+
+func x86TLSFallbackReadRelocations(listing string) ([]string, error) {
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/objabi/reloctype_string.go"))
+	if err != nil {
+		return nil, err
+	}
+	kinds := map[string]string{}
+	for _, name := range []string{"R_CALL", "R_TLS_IE"} {
+		matches := regexp.MustCompile(`(?m)^[\t ]*_ = x\[`+name+`-([0-9]+)\][\t ]*$`).FindAllStringSubmatch(string(source), -1)
+		if len(matches) != 1 {
+			return nil, fmt.Errorf("selected SDK lacks one exact TLS relocation enum: %s", name)
+		}
+		kinds[matches[0][1]] = name
+	}
+	var result []string
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 0 || fields[0] != "rel" {
+			continue
+		}
+		if len(fields) != 4 || !strings.HasPrefix(fields[2], "t=") {
+			return nil, fmt.Errorf("incomplete actual TLS relocation: %s", line)
+		}
+		if name := kinds[strings.TrimPrefix(fields[2], "t=")]; name != "" {
+			fields[2] = "t=" + name
+		}
+		result = append(result, strings.Join(fields, " "))
+	}
+	return result, nil
+}
+
+func x86TLSFallbackDirectNOP(t *testing.T, listing string) {
+	t.Helper()
+	headers := x86TLSListingTextHeaders([]byte(listing))
+	if len(headers) != 1 || !strings.Contains(headers[0], " size=1 ") {
+		t.Fatal("direct TLS rewrite lost its complete one-byte RET object", headers)
+	}
+	var code []byte
+	nops, returns := 0, 0
+	inside := false
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) >= 2 && !strings.HasPrefix(fields[0], "0x") && strings.HasPrefix(fields[1], "S") {
+			inside = fields[1] == "STEXT"
+		}
+		if !inside {
+			continue
+		}
+		code = append(code, x86InsertExtractListedBytes(line)...)
+		if match := x86OfficialPackedListingInstruction.FindStringSubmatch(line); match != nil &&
+			match[1] == "0000" && match[2] == "00000" {
+			if match[3] == "2" && match[4] == "NOP" {
+				nops++
+			} else if match[3] == "3" && match[4] == "RET" {
+				returns++
+			}
+		}
+	}
+	if !bytes.Equal(code, []byte{0xc3}) || nops != 1 || returns != 1 {
+		t.Fatal("direct TLS NOP must retain its own zero-width source row, not fallback bytes", code, nops, returns)
+	}
+}
+
+func x86TLSFallbackActualProfile(t *testing.T, arch string, shared bool) x86TLSFallbackSourceObservation {
+	t.Helper()
+	opcode := "MOVQ"
+	if arch == "386" {
+		opcode = "MOVL"
+	}
+	instruction := opcode + " TLS,CX"
+	source := "TEXT ·TLSProfile(SB),516,$0-0\n" + instruction + "\nRET\n"
+	listing, object, _ := x86ScalarLiteralGoProfileObject(t, arch, "linux", source, shared, true)
+	end := bytes.IndexByte(object, '\n')
+	if end < 0 {
+		t.Fatal("actual Go object lacks a complete header")
+	}
+	header := strings.Fields(string(object[:end]))
+	if len(header) < 5 || header[0] != "go" || header[1] != "object" || header[2] != "linux" ||
+		header[3] != arch || header[4] != runtime.Version() {
+		t.Fatal("actual original object target/SDK provenance changed", header)
+	}
+	observation := x86TLSFallbackSourceObservation{
+		x86TLSFallbackSourceIdentity: x86TLSFallbackSourceIdentity{Instruction: instruction, Target: "linux/" + arch,
+			SDKVersion: header[4], Shared: shared, SourceSHA: fmt.Sprintf("%x", sha256.Sum256([]byte(source))),
+			SDKSourceSHA: map[string]string{}, Relocations: x86TLSFallbackRelocationLines(t, listing)},
+		ObjectSHA: fmt.Sprintf("%x", sha256.Sum256(object)), ListingSHA: fmt.Sprintf("%x", sha256.Sum256([]byte(listing))),
+		sourceBytes: []byte(source), objectBytes: append([]byte(nil), object...), listingBytes: []byte(listing),
+		sourceDigest: sha256.Sum256([]byte(source)), objectDigest: sha256.Sum256(object), listingDigest: sha256.Sum256([]byte(listing)),
+		requestTarget: "linux/" + arch, requestShared: shared}
+	if artifacts := os.Getenv("PLAN9ASM_TLS_FALLBACK_ARTIFACT_DIR"); artifacts != "" {
+		owner := filepath.Join(artifacts, strings.ReplaceAll(t.Name(), "/", "_"))
+		if err := os.MkdirAll(owner, 0700); err != nil {
+			t.Fatal(err)
+		}
+		directory := filepath.Join(owner, fmt.Sprintf("%s-shared-%v", arch, shared))
+		if err := os.Mkdir(directory, 0700); err != nil {
+			t.Fatal("actual profile evidence must never overwrite an earlier observation", err)
+		}
+		for name, data := range map[string][]byte{"source.s": []byte(source), "original.o": object, "listing.txt": []byte(listing)} {
+			if err := os.WriteFile(filepath.Join(directory, name), data, 0600); err != nil {
+				t.Fatal(err)
+			}
+		}
+	}
+	for _, name := range []string{"cmd/internal/obj/x86/asm6.go", "cmd/internal/obj/x86/obj6.go", "cmd/internal/objabi/reloctype_string.go"} {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", name))
+		if err != nil {
+			t.Fatal(err)
+		}
+		observation.SDKSourceSHA[name] = fmt.Sprintf("%x", sha256.Sum256(data))
+	}
+	var expectedRelocations []string
+	switch {
+	case arch == "386" && !shared:
+		observation.Origin = "stock-asm/movTLSReg"
+		observation.Encoding = []byte{0x65, 0x8b, 0x0d, 0, 0, 0, 0}
+	case arch == "amd64" && shared:
+		observation.Origin = "stock-asm/movTLSReg"
+		observation.Encoding = []byte{0x48, 0x8b, 0x0d, 0, 0, 0, 0}
+		expectedRelocations = []string{"rel 3+4 t=R_TLS_IE +-4"}
+	case arch == "386" && shared:
+		observation.Origin = "stock-asm/movTLSReg/shared386-control"
+		observation.Encoding = []byte{0xe8, 0, 0, 0, 0, 0x8b, 0x89, 0, 0, 0, 0}
+		expectedRelocations = []string{"rel 1+4 t=R_CALL __x86.get_pc_thunk.cx+0", "rel 7+4 t=R_TLS_IE +2"}
+	case arch == "amd64" && !shared:
+		observation.Origin = "stock-asm/progedit-direct-NOP-control"
+		x86TLSFallbackDirectNOP(t, listing)
+	default:
+		t.Fatal("unmodeled source profile", arch, shared)
+	}
+	if !reflect.DeepEqual(observation.Relocations, expectedRelocations) {
+		t.Fatal("actual TLS byte/relocation/profile mismatch", observation, expectedRelocations)
+	}
+	if observation.Origin != "stock-asm/progedit-direct-NOP-control" {
+		fixture := x86OfficialPackedCase{row: "actualTLSProfile", symbol: "TLSProfile", line: 2,
+			witness: goasmrules.X86PackedBinaryWitness{Instruction: instruction, Destination: "CX", Encoding: observation.Encoding}}
+		if err := x86OfficialPackedVerifyListing(listing, []x86OfficialPackedCase{fixture}); err != nil {
+			t.Fatal("actual complete TLS source bytes/PC differ", err)
+		}
+	}
+	if observation.Origin == "stock-asm/movTLSReg" {
+		catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+		if err != nil {
+			t.Fatal(err)
+		}
+		observation.ID = x86TLSFallbackOriginalID(t, catalog, opcode)
+	}
+	t.Logf("ACTUAL_TLS_SOURCE_PROFILE id=%s origin=%s target=%s shared=%t SDK=%s sourceSHA=%s objectSHA=%s listingSHA=%s bytes=%x relocations=%q",
+		observation.ID, observation.Origin, observation.Target, observation.Shared, observation.SDKVersion,
+		observation.SourceSHA, observation.ObjectSHA, observation.ListingSHA, observation.Encoding, observation.Relocations)
+	return observation
+}
+
+func x86TLSFallbackValidateJoin(observation x86TLSFallbackSourceObservation, expectedID string) error {
+	if observation.ID == "" || observation.ID != expectedID || observation.Origin != "stock-asm/movTLSReg" ||
+		observation.SDKVersion != runtime.Version() || len(observation.SourceSHA) != 64 || len(observation.ObjectSHA) != 64 ||
+		len(observation.ListingSHA) != 64 || len(observation.SDKSourceSHA) != 3 {
+		return fmt.Errorf("incomplete actual TLS source/profile provenance")
+	}
+	if observation.Target != observation.requestTarget || observation.Shared != observation.requestShared {
+		return fmt.Errorf("TLS profile no longer matches the actual assembler request")
+	}
+	for _, receipt := range []struct {
+		data   []byte
+		hash   string
+		digest [32]byte
+	}{
+		{observation.sourceBytes, observation.SourceSHA, observation.sourceDigest},
+		{observation.objectBytes, observation.ObjectSHA, observation.objectDigest},
+		{observation.listingBytes, observation.ListingSHA, observation.listingDigest},
+	} {
+		if len(receipt.data) == 0 || sha256.Sum256(receipt.data) != receipt.digest ||
+			fmt.Sprintf("%x", receipt.digest) != receipt.hash {
+			return fmt.Errorf("TLS source receipt digest no longer matches its actual captured bytes")
+		}
+	}
+	expectedSource := "TEXT ·TLSProfile(SB),516,$0-0\n" + observation.Instruction + "\nRET\n"
+	if string(observation.sourceBytes) != expectedSource {
+		return fmt.Errorf("TLS source receipt no longer matches the observed instruction")
+	}
+	end := bytes.IndexByte(observation.objectBytes, '\n')
+	if end < 0 {
+		return fmt.Errorf("TLS source receipt lacks an actual object header")
+	}
+	header := strings.Fields(string(observation.objectBytes[:end]))
+	if len(header) < 5 || header[0] != "go" || header[1] != "object" ||
+		header[2]+"/"+header[3] != observation.Target || header[4] != observation.SDKVersion {
+		return fmt.Errorf("TLS source receipt no longer matches the selected target and SDK")
+	}
+	id := strings.Split(expectedID, "/")
+	instruction := strings.Fields(observation.Instruction)
+	if len(id) != 4 || len(instruction) != 2 || id[0] != "ymovtab" || id[2] != instruction[0] || id[3] != "movTLSReg" {
+		return fmt.Errorf("TLS source identity no longer matches its observed instruction width")
+	}
+	for _, name := range []string{"cmd/internal/obj/x86/asm6.go", "cmd/internal/obj/x86/obj6.go", "cmd/internal/objabi/reloctype_string.go"} {
+		data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", name))
+		if err != nil || observation.SDKSourceSHA[name] != fmt.Sprintf("%x", sha256.Sum256(data)) {
+			return fmt.Errorf("actual TLS profile is no longer bound to the selected SDK source: %s", name)
+		}
+	}
+	var code []byte
+	var relocations []string
+	switch {
+	case observation.Target == "linux/386" && !observation.Shared && observation.Instruction == "MOVL TLS,CX":
+		code = []byte{0x65, 0x8b, 0x0d, 0, 0, 0, 0}
+	case observation.Target == "linux/amd64" && observation.Shared && observation.Instruction == "MOVQ TLS,CX":
+		code = []byte{0x48, 0x8b, 0x0d, 0, 0, 0, 0}
+		relocations = []string{"rel 3+4 t=R_TLS_IE +-4"}
+	default:
+		return fmt.Errorf("a NOP, shared386 control or unrelated source profile cannot join a new fallback ID")
+	}
+	if !bytes.Equal(code, observation.Encoding) || !reflect.DeepEqual(relocations, observation.Relocations) {
+		return fmt.Errorf("TLS metadata lacks its exact actual byte/relocation counterpart")
+	}
+	fixture := x86OfficialPackedCase{row: "actualTLSProfile", symbol: "TLSProfile", line: 2,
+		witness: goasmrules.X86PackedBinaryWitness{Instruction: observation.Instruction, Destination: "CX", Encoding: code}}
+	if err := x86OfficialPackedVerifyListing(string(observation.listingBytes), []x86OfficialPackedCase{fixture}); err != nil {
+		return fmt.Errorf("TLS source bytes and PC no longer match the actual saved listing: %w", err)
+	}
+	actualRelocations, err := x86TLSFallbackReadRelocations(string(observation.listingBytes))
+	if err != nil || !reflect.DeepEqual(actualRelocations, relocations) {
+		return fmt.Errorf("TLS relocations no longer match the actual saved listing: %v", err)
+	}
+	return nil
+}
+
+func TestX86TLSFallbackActualObjectProfiles(t *testing.T) {
+	for _, profile := range []struct {
+		arch   string
+		shared bool
+	}{
+		{"386", false}, {"amd64", true}, {"amd64", false}, {"386", true},
+	} {
+		t.Run(fmt.Sprintf("linux/%s/shared=%v", profile.arch, profile.shared), func(t *testing.T) {
+			observed := x86TLSFallbackActualProfile(t, profile.arch, profile.shared)
+			wantID := profile.arch == "386" && !profile.shared || profile.arch == "amd64" && profile.shared
+			if (observed.ID != "") != wantID {
+				t.Fatal("control profile was counted as a new fallback identity", observed)
+			}
+		})
+	}
+}
+
+// Add only the independently validated contextual source observations.
+// The production source grammar still excludes unbound TLS and grants no
+// runtime, numerical or native authority.
+func x86TLSFallbackSourceUnion(t *testing.T, catalog goasmrules.X86LegacyCatalog, observed []x86TLSFallbackSourceObservation) map[string]bool {
+	t.Helper()
+	result := map[string]bool{}
+	for id := range movtabCompleteSourceJoin(t, catalog, "amd64") {
+		result[id] = true
+	}
+	if len(observed) != 2 {
+		t.Fatal("expected exactly two independently observed TLS fallback identities", len(observed))
+	}
+	for _, observation := range observed {
+		opcode := strings.Fields(observation.Instruction)[0]
+		id := x86TLSFallbackOriginalID(t, catalog, opcode)
+		if err := x86TLSFallbackValidateJoin(observation, id); err != nil {
+			t.Fatal(err)
+		}
+		if result[id] {
+			t.Fatal("duplicate contextual TLS source identity", id)
+		}
+		result[id] = true
+	}
+	return result
+}
+
+func TestX86TLSFallbackCompleteSourceIDJoin(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	observations := []x86TLSFallbackSourceObservation{
+		x86TLSFallbackActualProfile(t, "386", false), x86TLSFallbackActualProfile(t, "amd64", true),
+	}
+	joined := x86TLSFallbackSourceUnion(t, catalog, observations)
+	for _, observation := range observations {
+		t.Run(observation.ID, func(t *testing.T) {
+			opcode := strings.Fields(observation.Instruction)[0]
+			if err := x86TLSFallbackValidateJoin(observation, x86TLSFallbackOriginalID(t, catalog, opcode)); err != nil {
+				t.Fatal(err)
+			}
+			if !joined[observation.ID] {
+				t.Fatal("TLS_FALLBACK_SOURCE_ID_FEATURE_GAP", observation.ID)
+			}
+		})
+	}
+	if !t.Failed() {
+		if len(joined) != 112 {
+			t.Fatal("complete source union including actual contextual TLS observations changed", len(joined))
+		}
+		identities := make([]x86TLSFallbackSourceIdentity, len(observations))
+		for index, observation := range observations {
+			identities[index] = observation.x86TLSFallbackSourceIdentity
+		}
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_TLS_FALLBACK_ACTUAL_OUTPUT", observations)
+		x86Legacy127SaveIdentity(t, "PLAN9ASM_TLS_FALLBACK_SOURCE_OUTPUT", struct {
+			Source   goasmrules.X86LegacyCatalog
+			Observed []x86TLSFallbackSourceIdentity
+		}{catalog, identities})
+	}
+}
+
+func TestX86TLSFallbackSourceProfileCounterfeits(t *testing.T) {
+	original := x86TLSFallbackActualProfile(t, "amd64", true)
+	if err := x86TLSFallbackValidateJoin(original, original.ID); err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*x86TLSFallbackSourceObservation){
+		"lost-shared-profile":     func(o *x86TLSFallbackSourceObservation) { o.Shared = false },
+		"wrong-OS":                func(o *x86TLSFallbackSourceObservation) { o.Target = "darwin/amd64" },
+		"wrong-width":             func(o *x86TLSFallbackSourceObservation) { o.Instruction = "MOVL TLS,CX" },
+		"direct-NOP-origin":       func(o *x86TLSFallbackSourceObservation) { o.Origin = "stock-asm/progedit-direct-NOP-control" },
+		"missing-relocation":      func(o *x86TLSFallbackSourceObservation) { o.Relocations = nil },
+		"wrong-relocation-kind":   func(o *x86TLSFallbackSourceObservation) { o.Relocations = []string{"rel 3+4 t=R_PCREL +-4"} },
+		"wrong-relocation-addend": func(o *x86TLSFallbackSourceObservation) { o.Relocations = []string{"rel 3+4 t=R_TLS_IE +-3"} },
+		"wrong-relocation-PC":     func(o *x86TLSFallbackSourceObservation) { o.Relocations = []string{"rel 2+4 t=R_TLS_IE +-4"} },
+		"missing-object":          func(o *x86TLSFallbackSourceObservation) { o.ObjectSHA = "" },
+		"foreign-source-hash":     func(o *x86TLSFallbackSourceObservation) { o.SourceSHA = strings.Repeat("0", 64) },
+		"foreign-object-hash":     func(o *x86TLSFallbackSourceObservation) { o.ObjectSHA = strings.Repeat("0", 64) },
+		"foreign-listing-hash":    func(o *x86TLSFallbackSourceObservation) { o.ListingSHA = strings.Repeat("0", 64) },
+		"changed-source-bytes":    func(o *x86TLSFallbackSourceObservation) { o.sourceBytes[0] ^= 1 },
+		"changed-object-bytes":    func(o *x86TLSFallbackSourceObservation) { o.objectBytes[0] ^= 1 },
+		"changed-listing-bytes":   func(o *x86TLSFallbackSourceObservation) { o.listingBytes[0] ^= 1 },
+		"wrong-SDK":               func(o *x86TLSFallbackSourceObservation) { o.SDKVersion = "go0.0" },
+		"wrong-SDK-source": func(o *x86TLSFallbackSourceObservation) {
+			o.SDKSourceSHA = map[string]string{"foreign": "", "other": "", "third": ""}
+		},
+		"zero-width-bytes": func(o *x86TLSFallbackSourceObservation) { o.Encoding = nil },
+	} {
+		t.Run(name, func(t *testing.T) {
+			changed := original
+			changed.sourceBytes = append([]byte(nil), original.sourceBytes...)
+			changed.objectBytes = append([]byte(nil), original.objectBytes...)
+			changed.listingBytes = append([]byte(nil), original.listingBytes...)
+			mutate(&changed)
+			if err := x86TLSFallbackValidateJoin(changed, original.ID); err == nil {
+				t.Fatal("metadata/control evidence was counted as a passing source join", name)
+			}
+		})
+	}
+	if err := x86TLSFallbackValidateJoin(original, original.ID); err != nil {
+		t.Fatal("counterfeits must not modify the valid actual observation", err)
+	}
+}
+
+func TestX86TLSFallbackSourceCannotRetagObservedWidth(t *testing.T) {
+	observed := x86TLSFallbackActualProfile(t, "amd64", true)
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	foreign := x86TLSFallbackOriginalID(t, catalog, "MOVL")
+	observed.ID = foreign
+	if err := x86TLSFallbackValidateJoin(observed, foreign); err == nil {
+		t.Fatal("actual MOVQ source observation was retagged as the MOVL fallback row")
+	}
+}
+
+func TestX86TLSFallbackRejectsRetaggedActualControls(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, control := range []struct {
+		name, arch string
+		shared     bool
+	}{
+		{"direct-NOP", "amd64", false},
+		{"shared-386", "386", true},
+		{"changed-actual-relocation", "amd64", true},
+	} {
+		t.Run(control.name, func(t *testing.T) {
+			observed := x86TLSFallbackActualProfile(t, control.arch, control.shared)
+			opcode := "MOVQ"
+			if control.arch == "386" {
+				opcode = "MOVL"
+			}
+			observed.ID = x86TLSFallbackOriginalID(t, catalog, opcode)
+			observed.Origin = "stock-asm/movTLSReg"
+			observed.Shared = control.arch == "amd64"
+			if control.arch == "amd64" {
+				observed.Encoding = []byte{0x48, 0x8b, 0x0d, 0, 0, 0, 0}
+				observed.Relocations = []string{"rel 3+4 t=R_TLS_IE +-4"}
+			} else {
+				observed.Encoding = []byte{0x65, 0x8b, 0x0d, 0, 0, 0, 0}
+				observed.Relocations = nil
+			}
+			if control.name == "changed-actual-relocation" {
+				listing := string(observed.listingBytes)
+				if strings.Count(listing, "+-4") != 1 {
+					t.Fatal("actual shared relocation seed must have one independently observed addend")
+				}
+				observed.listingBytes = []byte(strings.Replace(listing, "+-4", "+-3", 1))
+				observed.ListingSHA = fmt.Sprintf("%x", sha256.Sum256(observed.listingBytes))
+			}
+			if err := x86TLSFallbackValidateJoin(observed, observed.ID); err == nil {
+				t.Fatal("actual control or changed listing was retagged as a fallback source observation")
+			}
+		})
+	}
+}
+
+func TestX86TLSFallbackRejectsChangedActualObject(t *testing.T) {
+	observed := x86TLSFallbackActualProfile(t, "amd64", true)
+	observed.objectBytes = append([]byte(nil), observed.objectBytes...)
+	observed.objectBytes[len(observed.objectBytes)-1] ^= 1
+	observed.ObjectSHA = fmt.Sprintf("%x", sha256.Sum256(observed.objectBytes))
+	if err := x86TLSFallbackValidateJoin(observed, observed.ID); err == nil {
+		t.Fatal("changed actual object and recomputed public digest escaped the captured receipt")
+	}
+}
+
+func TestX86TLSFallbackObservedSourceDoesNotGrantRuntime(t *testing.T) {
+	for _, source := range []struct{ instruction, arch string }{{"MOVL TLS,CX", "386"}, {"MOVQ TLS,CX", "amd64"}} {
+		instruction := x86PureGPUnknownInstruction(t, source.instruction)
+		if err := x86SourceTLSMoveError(instruction, source.arch); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("source proof must not grant TLS/runtime/NUM authority", source, err)
+		}
+	}
+}
diff --git a/x86_official_two_source_immediate_rows_test.go b/x86_official_two_source_immediate_rows_test.go
new file mode 100644
index 000000000..57cf0cb1b
--- /dev/null
+++ b/x86_official_two_source_immediate_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialTwoSourceImmediateShuffleRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86TwoSourceImmediateShuffleRows, 27, 90, 0)
+}
diff --git a/x86_official_uniform_byte_shift_rows_test.go b/x86_official_uniform_byte_shift_rows_test.go
new file mode 100644
index 000000000..0bf6d706e
--- /dev/null
+++ b/x86_official_uniform_byte_shift_rows_test.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86OfficialUniformByteShiftRowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86PackedUniformByteShiftRows, 188, 488, 0)
+}
diff --git a/x86_official_vsib_rows_test.go b/x86_official_vsib_rows_test.go
new file mode 100644
index 000000000..746375a69
--- /dev/null
+++ b/x86_official_vsib_rows_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Initialize the actual index, merge/data and mask inputs independently of the
+// row-byte generator. Every active address is within the caller's data array:
+// the indices are zero and the mask is nonzero. Scatter uses the output array.
+func x86OfficialVSIBAssembly(cases []x86OfficialPackedCase) (string, string) {
+	var source, declarations strings.Builder
+	for index := range cases {
+		fixture := &cases[index]
+		w := fixture.witness
+		fixture.symbol = fmt.Sprint("VSIBRow", index)
+		prefetch := strings.Contains(w.Instruction, "PF")
+		scatter := strings.Contains(w.Instruction, "SCATTER") && !prefetch
+		fmt.Fprintf(&declarations, "func %s(out *[80]byte,data,seed *[64]byte)\n", fixture.symbol)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),DX\n", fixture.symbol)
+		if !scatter {
+			source.WriteString("MOVQ data+8(FP),AX\n")
+		}
+		source.WriteString("MOVQ seed+16(FP),BX\n")
+		if w.Generation == "vex" {
+			fmt.Fprintf(&source, "VPXOR Y%s,Y%s,Y%s\n", w.Second[1:], w.Second[1:], w.Second[1:])
+			source.WriteString("VPXOR Y1,Y1,Y1\nVPCMPEQD Y1,Y1,Y1\n")
+			fmt.Fprintf(&source, "VMOVUPS (BX),Y%s\n", w.Destination[1:])
+		} else {
+			fmt.Fprintf(&source, "VPXORD Z%s,Z%s,Z%s\n", w.Second[1:], w.Second[1:], w.Second[1:])
+			source.WriteString("MOVQ $1,R9\nKMOVQ R9,K1\n")
+			if !prefetch {
+				fmt.Fprintf(&source, "VMOVUPS (BX),Z%s\n", w.Destination[1:])
+			}
+		}
+		if scatter {
+			source.WriteString("MOVQ DX,AX\n")
+		}
+		fixture.line = strings.Count(source.String(), "\n") + 1
+		fmt.Fprintln(&source, w.Instruction)
+		if !prefetch && !scatter {
+			carrier := "Z"
+			if w.Generation == "vex" {
+				carrier = "Y"
+			}
+			fmt.Fprintf(&source, "VMOVUPS %s%s,(DX)\n", carrier, w.Destination[1:])
+		}
+		if w.Generation == "evex" {
+			source.WriteString("KMOVQ K1,64(DX)\n")
+		} else {
+			source.WriteString("VMOVUPS Y1,32(DX)\n")
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86OfficialVSIBRowsInitializedThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86OfficialPackedRowsObjectsInspect(t, goasmrules.X86IndexedMemoryRows, 80, 320, 0,
+		x86OfficialVSIBAssembly, func(t *testing.T, ir string, _ []x86OfficialPackedCase) {
+			x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, "-O2")
+		})
+}
+
+func TestX86VSIBInitializedSourceRequiresActualInputs(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86IndexedMemoryRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range rows {
+		if row.Opcode != "VGATHERDPS" && row.Opcode != "VPSCATTERDD" {
+			continue
+		}
+		// One complete representative per VEX/EVEX and gather/scatter role.
+		if !strings.HasSuffix(row.ID, "/0") && !strings.HasSuffix(row.ID, "/2") {
+			continue
+		}
+		w := row.Witnesses[0]
+		cases := []x86OfficialPackedCase{{row: row.ID, witness: w}}
+		source, declarations := x86OfficialVSIBAssembly(cases)
+		inputs := []string{"MOVQ data+8(FP),AX\n"}
+		if row.Opcode == "VPSCATTERDD" {
+			inputs = []string{"MOVQ DX,AX\n"}
+		}
+		if w.Generation == "vex" {
+			inputs = append(inputs, "VPXOR Y0,Y0,Y0\n", "VPXOR Y1,Y1,Y1\nVPCMPEQD Y1,Y1,Y1\n")
+		} else {
+			inputs = append(inputs, "VPXORD Z16,Z16,Z16\n", "KMOVQ R9,K1\n", "VMOVUPS (BX),Z18\n")
+		}
+		t.Run(row.ID, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Fatal("complete initialized source must precede input mutation", api, err)
+				}
+				for _, removed := range inputs {
+					if strings.Count(source, removed) != 1 {
+						t.Fatal("input mutation does not own one exact initializer", removed)
+					}
+					changed := strings.Replace(source, removed, "", 1)
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+					switch removed {
+					case "VPXOR Y0,Y0,Y0\n", "VPXOR Y1,Y1,Y1\nVPCMPEQD Y1,Y1,Y1\n", "VPXORD Z16,Z16,Z16\n", "VMOVUPS (BX),Z18\n":
+						// VSIB indices and VEX masks are vector values. Their
+						// allocated scratch choice supplies neither the GP base
+						// nor an EVEX K mask, which remain negative controls.
+						x86VectorScratchCodegenControl(t, changed, declarations, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						continue
+					}
+					if err == nil {
+						t.Fatal("missing actual indexed-memory input was accepted", api, removed)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_official_zero_operand_rows_test.go b/x86_official_zero_operand_rows_test.go
new file mode 100644
index 000000000..145e96815
--- /dev/null
+++ b/x86_official_zero_operand_rows_test.go
@@ -0,0 +1,243 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ZeroOperandCompleteSourceView(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	modes := map[string][]goasmrules.X86ScalarRMWRow{}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, err := goasmrules.X86ZeroOperandRows(catalog, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		seen, position, filtered := map[string]bool{}, 0, 0
+		for _, entry := range catalog.Optab {
+			if entry.Ytab != "ynone" {
+				continue
+			}
+			fixture, valid := zeroOperandOriginalCase(t, entry, arch)
+			if position >= len(rows) {
+				t.Fatal("source view omitted original rows", arch, fixture.row)
+			}
+			row := rows[position]
+			position++
+			if row.ID != fixture.row || row.Opcode != entry.Opcode || seen[row.ID] {
+				t.Fatal("source ID/order/name mismatch", arch, row, fixture.row)
+			}
+			seen[row.ID] = true
+			if !valid {
+				if row.ModeFiltered == "" || len(row.Witnesses) != 0 {
+					t.Fatal("mode-refused original row gained a source witness", arch, row)
+				}
+				filtered++
+				continue
+			}
+			if row.ModeFiltered != "" || len(row.Witnesses) != 1 {
+				t.Fatal("legal original row has no exact source witness", arch, row)
+			}
+			witness := row.Witnesses[0]
+			if witness.Instruction != fixture.witness.Instruction || witness.Destination != "" ||
+				!bytes.Equal(witness.Encoding, fixture.witness.Encoding) {
+				t.Fatal("source ID/instruction/literal/destination mismatch", arch, row, fixture)
+			}
+		}
+		wantFiltered := 12
+		if arch == "386" {
+			wantFiltered = 13
+		}
+		if position != len(rows) || position != 139 && position != 140 || filtered != wantFiltered {
+			t.Fatal("complete original source view changed", arch, position, len(rows), filtered)
+		}
+		modes[arch] = rows
+	}
+	for _, arch := range []string{"", "arm64", "amd64x"} {
+		if _, err := goasmrules.X86ZeroOperandRows(catalog, arch); err == nil {
+			t.Fatal("foreign source mode accepted", arch)
+		}
+	}
+	for _, field := range []string{"empty", "duplicate", "capacity"} {
+		changed := catalog
+		changed.Optab = append([]goasmrules.X86LegacyOpcode(nil), catalog.Optab...)
+		switch field {
+		case "empty":
+			changed.Optab = nil
+		case "duplicate":
+			for _, entry := range catalog.Optab {
+				if entry.Ytab == "ynone" {
+					changed.Optab = append(changed.Optab, entry)
+					break
+				}
+			}
+		case "capacity":
+			changed.OpBytesSize = 0
+		}
+		if _, err := goasmrules.X86ZeroOperandRows(changed, "amd64"); err == nil {
+			t.Fatal("invalid complete source catalog accepted", field)
+		}
+	}
+	x86Legacy127SaveIdentity(t, "PLAN9ASM_ZERO_OPERAND_IDENTITY_OUTPUT", struct {
+		Source goasmrules.X86LegacyCatalog
+		Modes  map[string][]goasmrules.X86ScalarRMWRow
+	}{catalog, modes})
+}
+
+// This test-only reference follows the original Go prefix switch and complete
+// zero-terminated opBytes array, independently of the production formatter.
+func zeroOperandOriginalCase(t *testing.T, entry goasmrules.X86LegacyOpcode, arch string) (x86OfficialPackedCase, bool) {
+	t.Helper()
+	fixture := x86OfficialPackedCase{
+		row:     fmt.Sprintf("optab/%d/%s/ynone/0", entry.TableIndex, entry.Opcode),
+		witness: goasmrules.X86PackedBinaryWitness{Instruction: entry.Opcode},
+	}
+	if arch == "amd64" && entry.Prefix == "P32" ||
+		arch == "386" && (entry.Prefix == "Pw" || entry.Prefix == "Py") {
+		return fixture, false
+	}
+	prefixes := map[string][]byte{
+		"Px": {}, "Pb": {}, "P32": {}, "Py": {},
+		"Pm": {0x0f}, "Pe": {0x66}, "Pw": {0x48}, "Pf3": {0xf3, 0x0f},
+	}
+	prefix, found := prefixes[entry.Prefix]
+	if !found {
+		t.Fatal("unobserved original zero-operand prefix", entry)
+	}
+	fixture.witness.Encoding = append([]byte(nil), prefix...)
+	terminated := false
+	for i, atom := range entry.OpBytes {
+		value, err := strconv.ParseUint(atom, 0, 8)
+		if err != nil {
+			t.Fatal("original zero-operand atom changed", entry.Opcode, i, atom, err)
+		}
+		if value == 0 {
+			terminated = true
+		}
+		if !terminated {
+			fixture.witness.Encoding = append(fixture.witness.Encoding, byte(value))
+		}
+	}
+	return fixture, true
+}
+
+// Prefix source rows retain a compatible successor. These functions are
+// assembled as data-producing oracles, never executed. Their existence grants
+// no initialized input, hardware, native-entry or machine-state permission.
+func zeroOperandOriginalContext(opcode string) (before, after string) {
+	// Keep Go's preprocessing delta balanced before the final RET. For a
+	// POP, the matching PUSH precedes the measured original instruction;
+	// for a PUSH, the matching POP follows it. PUSHA/POPA use the same
+	// physical-width pairing even though obj6 tracks only individual pushes.
+	if strings.HasPrefix(opcode, "PUSH") {
+		return "", "POP" + strings.TrimPrefix(opcode, "PUSH") + "\n"
+	}
+	if strings.HasPrefix(opcode, "POP") {
+		return "PUSH" + strings.TrimPrefix(opcode, "POP") + "\n", ""
+	}
+	switch opcode {
+	case "LOCK":
+		return "", "ADDL AX,(BX)\n"
+	case "REP":
+		return "", "MOVSB\n"
+	case "REPN":
+		return "", "CMPSB\n"
+	case "XACQUIRE", "XRELEASE":
+		return "", "LOCK\nADDL AX,(BX)\n"
+	}
+	return "", ""
+}
+
+func TestX86ZeroOperandOriginalGoCompleteBytesAndModes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var entries []goasmrules.X86LegacyOpcode
+	for _, entry := range catalog.Optab {
+		if entry.Ytab == "ynone" {
+			if len(entry.Rows) != 1 || entry.Rows[0].ZCase != "Zlit" || len(entry.Rows[0].Classes) != 0 {
+				t.Fatal("complete original zero-operand row changed", entry)
+			}
+			entries = append(entries, entry)
+		}
+	}
+	if len(entries) != 139 && len(entries) != 140 {
+		t.Fatal("complete SDK zero-operand inventory changed", len(entries))
+	}
+	observed, accepted, refused := 0, 0, 0
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var positives []x86OfficialPackedCase
+			for _, entry := range entries {
+				fixture, valid := zeroOperandOriginalCase(t, entry, arch)
+				observed++
+				if valid {
+					positives = append(positives, fixture)
+					accepted++
+					continue
+				}
+				refused++
+				t.Run("mode-refusal/"+fixture.row, func(t *testing.T) {
+					before, after := zeroOperandOriginalContext(entry.Opcode)
+					source := "TEXT ·NoMode(SB),4,$0-0\n" + before + entry.Opcode + "\n" + after + "RET\n"
+					listing, err := x86ScalarLiteralExpectedGoListing(t, arch, source, false)
+					marker := "asmins: illegal 64:"
+					if entry.Prefix == "P32" {
+						marker = "asmins: illegal in 64-bit mode:"
+					} else if entry.Prefix == "Py" {
+						marker = "asmins: illegal in 32-bit mode:"
+					}
+					matched := false
+					for _, line := range strings.Split(listing, "\n") {
+						if strings.Contains(line, marker) && strings.Contains(line, entry.Opcode) {
+							matched = true
+						}
+					}
+					if !matched || strings.Contains(listing, "unbalanced PUSH/POP") {
+						t.Fatal("source refusal lacks the original opcode/mode diagnostic", fixture.row, arch, marker, listing)
+					}
+					t.Logf("ZERO_OPERAND_ACTUAL_GO_MODE_REFUSAL id=%s mode=%s exit=%v diagnostic=%q", fixture.row, arch, err, listing)
+				})
+			}
+			for start := 0; start < len(positives); start += 32 {
+				end := start + 32
+				if end > len(positives) {
+					end = len(positives)
+				}
+				batch := append([]x86OfficialPackedCase(nil), positives[start:end]...)
+				var source strings.Builder
+				for i := range batch {
+					batch[i].symbol = fmt.Sprintf("ZeroOperand%d", start+i)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", batch[i].symbol)
+					before, after := zeroOperandOriginalContext(batch[i].witness.Instruction)
+					source.WriteString(before)
+					batch[i].line = strings.Count(source.String(), "\n") + 1
+					fmt.Fprintln(&source, batch[i].witness.Instruction)
+					source.WriteString(after)
+					source.WriteString("RET\n")
+				}
+				listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+				if err != nil {
+					t.Fatal("actual Go zero-operand source batch rejected", arch, start, err)
+				}
+				if err := x86OfficialPackedVerifyListing(listing, batch); err != nil {
+					t.Fatal("original zero-operand literal bytes changed", arch, start, err)
+				}
+			}
+		})
+	}
+	if observed != 2*len(entries) || refused != 25 || accepted != 2*len(entries)-25 {
+		t.Fatal("complete original source/mode observation matrix changed", observed, accepted, refused)
+	}
+	t.Logf("ZERO_OPERAND_ACTUAL_GO observations=%d accepted=%d refused=%d", observed, accepted, refused)
+}
diff --git a/x86_optional_avx512_runtime_test.go b/x86_optional_avx512_runtime_test.go
new file mode 100644
index 000000000..3e52ac344
--- /dev/null
+++ b/x86_optional_avx512_runtime_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This subprocess supplies a real process status, never an error-string stand-in.
+func TestX86OptionalAVX512ExitFixture(t *testing.T) {
+	value := os.Getenv("PLAN9ASM_AVX512_EXIT_FIXTURE")
+	if value == "" {
+		return
+	}
+	code, err := strconv.Atoi(value)
+	if err != nil || code < 0 || code > 255 {
+		t.Fatal("invalid fixture exit", value)
+	}
+	os.Exit(code)
+}
+
+func TestX86OptionalAVX512RuntimeRequiresMissingHardwareReceipt(t *testing.T) {
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestX86OptionalAVX512ExitFixture$")
+	command.Env = append(os.Environ(), "PLAN9ASM_AVX512_EXIT_FIXTURE=78")
+	_, unavailable := runtimeOracleCombinedOutput(ctx, command)
+	if status, ok := unavailable.(*exec.ExitError); !ok || status.ExitCode() != 78 {
+		t.Fatal("fixture did not produce an ordinary exit78", unavailable)
+	}
+	const missing = "original-floating profile=1 SSE2=1 AVX=1 OSXSAVE=1 AVX512F=0 AVX512VL=0 FMA=1 SSSE3=1 AVX2=1 XCR0=7\n"
+	for _, code := range []int{0, 77, 79, 80, 81, 82, 255} {
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestX86OptionalAVX512ExitFixture$")
+		command.Env = append(os.Environ(), "PLAN9ASM_AVX512_EXIT_FIXTURE="+strconv.Itoa(code))
+		_, err := runtimeOracleCombinedOutput(ctx, command)
+		if x86OriginalFloatingRuntimeAllowsSkip("auto", 1, []byte(missing), err) {
+			t.Fatal("non-capability process status became a skip", code)
+		}
+	}
+	for _, profile := range []int{1, 2, 3, 4} {
+		receipt := strings.Replace(missing, "profile=1", fmt.Sprintf("profile=%d", profile), 1)
+		for _, mode := range []string{"", "required", "auto", "off", "AUTO"} {
+			t.Run(fmt.Sprintf("profile%d/%s", profile, mode), func(t *testing.T) {
+				if got := x86OriginalFloatingRuntimeAllowsSkip(mode, profile, []byte(receipt), unavailable); got != (mode == "auto") {
+					t.Fatalf("missing CPU policy %q: skip=%t", mode, got)
+				}
+			})
+		}
+	}
+	for _, test := range []struct {
+		name, output string
+		err          error
+	}{
+		{"success", missing, nil},
+		{"error text", missing, errors.New("exit status 78")},
+		{"timeout", missing, errors.Join(unavailable, context.DeadlineExceeded)},
+		{"cancellation", missing, errors.Join(unavailable, context.Canceled)},
+		{"cleanup", missing, errors.Join(unavailable, errors.New("cleanup failed"))},
+		{"no receipt", "", unavailable},
+		{"truncated", strings.TrimSuffix(missing, " XCR0=7\n"), unavailable},
+		{"foreign profile", strings.Replace(missing, "profile=1", "profile=3", 1), unavailable},
+		{"invalid feature", strings.Replace(missing, "AVX512F=0", "AVX512F=2", 1), unavailable},
+		{"duplicate", missing + missing, unavailable},
+		{"extra diagnostic", missing + "loader failed\n", unavailable},
+		{"contradictory success", missing + "ORIGINAL_FLOATING_RUNTIME_CPU_OPCODES_OK\n", unavailable},
+		{"capable host", strings.NewReplacer("AVX512F=0", "AVX512F=1", "AVX512VL=0", "AVX512VL=1", "XCR0=7", "XCR0=e7").Replace(missing), unavailable},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			if x86OriginalFloatingRuntimeAllowsSkip("auto", 1, []byte(test.output), test.err) {
+				t.Fatal("non-hardware failure became a runtime skip")
+			}
+		})
+	}
+	full := strings.NewReplacer("AVX512F=0", "AVX512F=1", "XCR0=7", "XCR0=e7").Replace(missing)
+	if x86OriginalFloatingRuntimeAllowsSkip("auto", 1, []byte(full), unavailable) {
+		t.Fatal("scalar conversion does not require AVX512VL")
+	}
+	for _, profile := range []int{2, 4} {
+		receipt := strings.Replace(full, "profile=1", fmt.Sprintf("profile=%d", profile), 1)
+		if !x86OriginalFloatingRuntimeAllowsSkip("auto", profile, []byte(receipt), unavailable) {
+			t.Fatal("packed profile lost its actual AVX512VL requirement", profile)
+		}
+	}
+	if !x86OriginalFloatingRuntimeAllowsSkip("auto", 1, []byte(strings.Replace(missing, "\n", "\r\n", 1)), unavailable) {
+		t.Fatal("Windows receipt line ending rejected")
+	}
+	for _, profile := range []int{0, 7} {
+		if x86OriginalFloatingRuntimeAllowsSkip("auto", profile, []byte(missing), unavailable) {
+			t.Fatal("unknown profile became optional", profile)
+		}
+	}
+	for _, profile := range []int{5, 6} {
+		receipt := strings.Replace(missing, "profile=1", fmt.Sprintf("profile=%d", profile), 1)
+		if x86OriginalFloatingRuntimeAllowsSkip("auto", profile, []byte(receipt), unavailable) {
+			t.Fatal("explicit RCP14 native qualification became an optional hardware skip", profile)
+		}
+	}
+}
diff --git a/x86_ordinary_bp_cmov_objects_test.go b/x86_ordinary_bp_cmov_objects_test.go
new file mode 100644
index 000000000..153b2d8a1
--- /dev/null
+++ b/x86_ordinary_bp_cmov_objects_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86RequireCMOVVolatileWidth(t *testing.T, ir string, bytes, count int) {
+	t.Helper()
+	// The original byte vector may be folded into the same-width scalar by
+	// real LLVM optimization. Neither widening nor erasing a volatile read is valid.
+	pattern := fmt.Sprintf(`load volatile (?:<%d x i8>|i%d),`, bytes, bytes*8)
+	if got := len(regexp.MustCompile(pattern).FindAllString(ir, -1)); got != count {
+		t.Fatal("CMOV did not preserve the complete unconditional native read width", bytes, got, count)
+	}
+}
+
+func TestX86OrdinaryBPCMOVCompleteFamilyGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	names := x86CMOVOracleNames("386")
+	if len(names) != 32 {
+		t.Fatal("complete W/L x16 condition family changed", len(names))
+	}
+	targets, sources, originals, objects := 0, 0, 0, 0
+	for _, target := range x86OrderingHintTargets {
+		if target.arch != "386" {
+			continue // SP and AMD64 BP remain physical source-frame boundaries.
+		}
+		targets++
+		t.Run(target.triple, func(t *testing.T) {
+			for _, frame := range []int{0, 64} {
+				t.Run(fmt.Sprint(frame), func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, name := range names {
+						for variant, address := range []string{"(BP)", "(SI)(BP*1)"} {
+							function := fmt.Sprintf("cmovBP%d_%d", index, variant)
+							setup := "MOVL p+0(FP),BP\n"
+							if variant == 1 {
+								setup = "MOVL p+0(FP),SI\nMOVL $0,BP\n"
+							}
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$%d-4\n%sMOVL $7,AX\nCMPL AX,$0\n%s %s,AX\nRET\n", function, frame, setup, name, address)
+							fmt.Fprintf(&declarations, "func %s(p *byte)\n", function)
+							sources++
+						}
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					originals++
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), "package ordering\n"+declarations.String(), target.arch, target.triple)
+							if err != nil {
+								t.Fatal("complete ordinary BP CMOV family", err)
+							}
+							for _, optimized := range []bool{false, true} {
+								t.Run(fmt.Sprintf("optimized=%t", optimized), func(t *testing.T) {
+									input := ir
+									if optimized {
+										input = x86MulDivRoundOptimize(t, input)
+									}
+									x86RequireCMOVVolatileWidth(t, input, 2, 32)
+									x86RequireCMOVVolatileWidth(t, input, 4, 32)
+									compileLLVMToObject(t, llc, target.triple, "native-bp-cmov.ll", "native-bp-cmov.o", input)
+									objects++
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	if targets != 2 || sources != 256 || originals != 4 || objects != 24 {
+		t.Fatal("complete CMOV width/condition/address/frame/target/API union changed", targets, sources, originals, objects)
+	}
+	t.Log("32 W/L conditions,256 source functions,4 original Go objects,24 LLVM22 objects; compile-only")
+}
diff --git a/x86_ordinary_bp_native_fixture_test.go b/x86_ordinary_bp_native_fixture_test.go
new file mode 100644
index 000000000..7e4526193
--- /dev/null
+++ b/x86_ordinary_bp_native_fixture_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// These fixtures test native instruction/address classification, not numerical
+// results or pointee backing. All ordinary inputs are explicitly initialized;
+// the unused native read must still retain its original fault/MXCSR effect.
+func x86OrdinaryBPNativeFixture(t *testing.T, arch, name, instruction, address string, frame int) (string, FuncSig, GoPackage) {
+	t.Helper()
+	source := x86OrdinaryBPNativeSource(arch, name, instruction, address, frame)
+	pkg := mustGoPackage(t, "sourceframe", "package sourceframe\nfunc "+name+"(p *byte)\n")
+	object, ok := pkg.Types.Scope().Lookup(name).(*types.Func)
+	if !ok {
+		t.Fatal("missing actual typed void declaration", name)
+	}
+	sig, err := DeriveGoFuncABI0Signature("sourceframe."+name, object, arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return source, sig, pkg
+}
+
+func x86OrdinaryBPNativeSource(arch, name, instruction, address string, frame int) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	setup := move + " p+0(FP),AX\nPXOR X0,X0\nPXOR X1,X1\n"
+	if arch == "386" {
+		if strings.Contains(address, "(BP*") {
+			setup += "MOVL $0,BP\n"
+		} else if strings.Contains(address, "(BP)") {
+			setup += "MOVL AX,BP\n"
+		}
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$%d-%d\n%s%s\nRET\n", name, frame, word, setup, instruction)
+}
+
+func x86RequireOrdinaryBPNativeOutcome(t *testing.T, arch, address, ir string, err error) {
+	t.Helper()
+	// Independent literal matrix expectation: BP is ordinary only in 386 mode.
+	// Do not use the production address classifier to derive its own expected result.
+	if arch == "386" && strings.Contains(address, "BP") && !strings.Contains(address, "SP") {
+		if err != nil {
+			t.Fatal("initialized ordinary mode32 BP lost its native opcode", err)
+		}
+		if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "~{memory}") {
+			t.Fatal("dead numerical output erased the original native memory effect")
+		}
+		return
+	}
+	x86LegacyFloatMemoryRequireContext(t, err)
+}
diff --git a/x86_ordinary_bp_native_objects_test.go b/x86_ordinary_bp_native_objects_test.go
new file mode 100644
index 000000000..a25a7d1c5
--- /dev/null
+++ b/x86_ordinary_bp_native_objects_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func TestX86OrdinaryBPNativeMemoryCompleteFamiliesGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	type row struct{ name, destination string }
+	var scalar []row
+	for _, names := range [][]string{
+		x86LegacyFloatMemoryOpcodes(), x86LegacyLogicalMemoryNames,
+		{"PMADDWL"}, x86WordMultiplyNames[:4], {"PMULLD", "PSHUFB", "CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"},
+	} {
+		for _, name := range names {
+			scalar = append(scalar, row{name, "X0"})
+		}
+	}
+	var conversions []row
+	for _, form := range x86PackedNativeAddressRows() {
+		conversions = append(conversions, row{form.name, form.destination})
+	}
+	// Literal inventory independent of the production family specifications.
+	want := strings.Fields(`ADDPS ADDPD SUBPS SUBPD MULPS MULPD DIVPS DIVPD
+ANDPS ANDPD ANDNPS ANDNPD ORPS ORPD XORPS XORPD PAND PANDN POR PXOR
+PMADDWL PMULLW PMULHW PMULHUW PMULHRSW PMULLD PSHUFB CVTPL2PS CVTPL2PD VCVTDQ2PS VCVTDQ2PD
+CVTPS2PL CVTTPS2PL CVTPD2PL CVTTPD2PL
+VCVTPS2DQ VCVTTPS2DQ VCVTPD2DQX VCVTPD2DQY VCVTTPD2DQX VCVTTPD2DQY
+VCVTPD2QQ VCVTPD2UQQ VCVTTPD2QQ VCVTTPD2UQQ VCVTPS2UDQ VCVTTPS2UDQ
+VCVTUDQ2PS VCVTQQ2PD VCVTUQQ2PD VCVTPS2QQ VCVTPS2UQQ VCVTTPS2QQ
+VCVTTPS2UQQ VCVTUDQ2PD VCVTPD2UDQX VCVTPD2UDQY VCVTTPD2UDQX
+VCVTTPD2UDQY VCVTQQ2PSX VCVTQQ2PSY VCVTUQQ2PSX VCVTUQQ2PSY
+VCVTPD2DQ VCVTTPD2DQ VCVTPD2UDQ VCVTTPD2UDQ VCVTQQ2PS VCVTUQQ2PS`)
+	var got []string
+	for _, form := range append(append([]row(nil), scalar...), conversions...) {
+		got = append(got, form.name)
+	}
+	sort.Strings(got)
+	sort.Strings(want)
+	if len(got) != 69 || !reflect.DeepEqual(got, want) {
+		t.Fatal("complete eight-family native BP opcode inventory changed", got)
+	}
+	for i := 1; i < len(got); i++ {
+		if got[i] == got[i-1] {
+			t.Fatal("duplicate family owner", got[i])
+		}
+	}
+	batches := []struct {
+		name  string
+		frame int
+		rows  []row
+	}{
+		{"scalar-zero", 0, scalar}, {"scalar-frame", 64, scalar},
+		{"conversion-zero", 0, conversions}, {"conversion-frame", 128, conversions},
+	}
+	seen := make(map[string]bool)
+	targets, objects, originals := 0, 0, 0
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue // BP has no ordinary native role on the three AMD64 targets.
+		}
+		targets++
+		t.Run(target.triple, func(t *testing.T) {
+			for _, batch := range batches {
+				t.Run(batch.name, func(t *testing.T) {
+					var source, declarations strings.Builder
+					count := 0
+					for index, form := range batch.rows {
+						for variant, address := range []string{"-32(BP)", "(AX)(BP*1)"} {
+							key := fmt.Sprintf("%s/%s/%d/%s", target.triple, form.name, batch.frame, address)
+							if seen[key] {
+								t.Fatal("native family/frame/address has multiple owners", key)
+							}
+							seen[key] = true
+							name := fmt.Sprintf("nativeBP%d_%d", index, variant)
+							source.WriteString(x86OrdinaryBPNativeSource(target.arch, name, form.name+" "+address+","+form.destination, address, batch.frame))
+							fmt.Fprintf(&declarations, "func %s(p *byte)\n", name)
+							count++
+						}
+					}
+					if count > 76 || count != 2*len(batch.rows) {
+						t.Fatal("bounded complete native batch changed", count)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					originals++
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("complete ordinary BP source failed", err)
+							}
+							for _, optimized := range []bool{false, true} {
+								t.Run(fmt.Sprintf("optimized=%t", optimized), func(t *testing.T) {
+									input := ir
+									if optimized {
+										input = x86MulDivRoundOptimize(t, input)
+									}
+									if strings.Count(input, "asm sideeffect") != count {
+										t.Fatal("dead native outputs lost original memory/exception effects")
+									}
+									compileLLVMToObject(t, llc, target.triple, "native-bp.ll", "native-bp.o", input)
+									objects++
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	if targets != 2 || len(seen) != 552 || originals != 8 || objects != 48 {
+		t.Fatal("complete source/target/frame/three-API/IR-axis union changed", targets, len(seen), originals, objects)
+	}
+	t.Log("complete69 opcodes,552 disjoint source functions,8 original Go objects,48 LLVM22 objects; compile-only, not native execution")
+}
diff --git a/x86_ordinary_result_address.go b/x86_ordinary_result_address.go
new file mode 100644
index 000000000..8548b15a7
--- /dev/null
+++ b/x86_ordinary_result_address.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+// This is a cost predicate, not storage or initialization authority. A named
+// result-field FP LEA must not bypass the cached whole-source
+// proof merely because no GP/X transfer or scalar-vector probe follows it.
+func x86OrdinaryResultAddressNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if (ins.Op == "LEAW" || ins.Op == "LEAL" || ins.Op == "LEAQ") && len(ins.Args) == 2 && ins.Args[0].Kind == OpFP {
+			for _, slot := range sig.Frame.Results {
+				width := x86ResultScalarBytes(slot.Type, arch)
+				if x86OrdinaryNumericAddressSlot(slot) && slot.Offset >= 0 && slot.Offset <= 4096-width &&
+					ins.Args[0].FPOffset >= slot.Offset && ins.Args[0].FPOffset < slot.Offset+width {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+func x86IntegerResultSlot(slot FrameSlot) bool {
+	return slot.Type == I8 || slot.Type == I16 || slot.Type == I32 || slot.Type == I64
+}
+
+// Logical numeric storage has the same byte ownership for integer and floating
+// fields. This does not widen integer-only return, bool or pointer contracts.
+func x86OrdinaryNumericAddressSlot(slot FrameSlot) bool {
+	return x86IntegerResultSlot(slot) || slot.Type == "float" || slot.Type == "double"
+}
+
+// Only the private lowering observer has logical result backing. Its existing
+// typed layout validation and bounded must-state proof remain mandatory. No
+// native incoming frame, parameter address, padding, CALL, raw entry, caller
+// extent, or canonical bool role is inferred here.
+func x86OrdinaryResultAddressRole(fn Func, sig FuncSig, arch string) bool {
+	if !x86OrdinaryResultAddressNeedsProof(fn, sig, arch) || fn.FrameSize != 0 ||
+		len(fn.X86RawText) != 0 || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+		fn.x86RawReplay != nil || len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 {
+		return false
+	}
+	for _, slot := range sig.Frame.Results {
+		if !x86OrdinaryNumericAddressSlot(slot) {
+			return false
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" || isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil ||
+			ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// Ordinary scalar ABI0 parameters have private logical copies, including the
+// physical byte of a bool input. Mode32's classic frame is contiguous; AMD64
+// instead retains each actual field's separate allocation and bounds. Neither
+// role grants canonical bool results, native incoming frames or caller memory.
+func x86OrdinaryParameterAddressRole(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" || !x86OrdinaryParameterAddressNeedsProof(fn, sig, arch) ||
+		fn.FrameSize != 0 || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil ||
+		fn.x86FixedLocal != nil || fn.x86RawReplay != nil || fn.x86DirectTailRoot != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86BoolCalls != nil ||
+		len(fn.x86ContinuationAddresses) != 0 || len(fn.x86IndirectLabels) != 0 {
+		return false
+	}
+	for _, slot := range sig.Frame.Params {
+		if slot.Type != I1 && !x86OrdinaryNumericAddressSlot(slot) {
+			return false
+		}
+	}
+	for _, slot := range sig.Frame.Results {
+		if !x86OrdinaryNumericAddressSlot(slot) {
+			return false
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if ins.Op == "CALL" || isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil ||
+			ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+// Cost routing only: every parameter LEA still needs the complete proof,
+// including narrowed addresses, Void functions and eventual unused values.
+func x86OrdinaryParameterAddressNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" {
+		return false
+	}
+	for _, ins := range fn.Instrs {
+		if (ins.Op == "LEAW" || ins.Op == "LEAL" || ins.Op == "LEAQ") &&
+			len(ins.Args) == 2 && ins.Args[0].Kind == OpFP {
+			for _, slot := range sig.Frame.Params {
+				width := x86FrameScalarBytes(slot.Type, arch)
+				if width > 0 && slot.Offset >= 0 && slot.Offset <= 4096-width &&
+					ins.Args[0].FPOffset >= slot.Offset && ins.Args[0].FPOffset < slot.Offset+width {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
diff --git a/x86_ordinary_result_address_objects_test.go b/x86_ordinary_result_address_objects_test.go
new file mode 100644
index 000000000..b33a65728
--- /dev/null
+++ b/x86_ordinary_result_address_objects_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86OrdinaryResultAddressObjectFixture(arch string) (string, string, int) {
+	word, offset := "Q", 8
+	if arch == "386" {
+		word, offset = "L", 4
+	}
+	cases := []struct {
+		bits int
+		body string
+	}{
+		{8, "MOVB a+0(FP),AL\n MOVB AL,(DI)"},
+		{8, "MOVB $7,AH\n MOVB AH,(DI)"},
+		{16, "MOVW $17,(DI)"},
+		{32, "MOVL $17,AX\n MOVL AX,(DI)"},
+		{64, "MOVL $17,(DI)\n MOVL $19,4(DI)"},
+		{32, "PXOR X0,X0\n MOVL X0,(DI)"},
+		{32, "PXOR X0,X0\n VMOVD X0,(DI)"},
+	}
+	for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q", "VMOVQ"} {
+		cases = append(cases, struct {
+			bits int
+			body string
+		}{64,
+			"PXOR X0,X0\n " + op + " X0,(DI)\n " + op + " (DI),X1\n " + op + " X1,(DI)"})
+	}
+	if arch == "amd64" {
+		cases = append(cases, struct {
+			bits int
+			body string
+		}{64, "MOVQ $0x123456789,AX\n MOVQ AX,(DI)"})
+	}
+	var source, declarations strings.Builder
+	for index, row := range cases {
+		name := fmt.Sprintf("ordinary%d", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n LEA%s ret+%d(FP),DI\n %s\n RET\n", name, offset+row.bits/8, word, offset, row.body)
+		fmt.Fprintf(&declarations, "func %s(a uint8) uint%d\n", name, row.bits)
+	}
+	return source.String(), declarations.String(), len(cases)
+}
+
+func TestX86OrdinaryResultAddressOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, count := x86OrdinaryResultAddressObjectFixture(target.arch)
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			t.Logf("complete original %s source: %d TEXTs, source=%x object=%x SDK=%s", target.arch, count, receipt.Source, receipt.Object, receipt.GoVersion)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("complete source %s: %v", api, err)
+				}
+				for _, level := range []string{"0", "2"} {
+					t.Run(api+"/O"+level, func(t *testing.T) {
+						objectIR := ir
+						if level == "2" {
+							objectIR = x86DwordProductIROptimize(t, ir)
+						}
+						dir := t.TempDir()
+						input, output := filepath.Join(dir, "ordinary.ll"), filepath.Join(dir, "ordinary.o")
+						if err := os.WriteFile(input, []byte(objectIR), 0600); err != nil {
+							t.Fatal(err)
+						}
+						ctx, cancel := runtimeOracleStageContext(t)
+						defer cancel()
+						command := exec.CommandContext(ctx, llc, "-O"+level, "-mtriple="+target.triple, "-filetype=obj", input, "-o", output)
+						if data, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+							t.Fatalf("LLVM22 complete result-address object: %v\n%s", err, data)
+						}
+						if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+							t.Fatalf("LLVM22 complete object absent: %v", err)
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_ordinary_result_address_test.go b/x86_ordinary_result_address_test.go
new file mode 100644
index 000000000..c847c4362
--- /dev/null
+++ b/x86_ordinary_result_address_test.go
@@ -0,0 +1,427 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86OrdinaryResultAddressFixture(arch, setup, body string) (string, string) {
+	word, typ, width := "Q", "uint64", 8
+	if arch == "386" {
+		word, typ, width = "L", "uint32", 4
+	}
+	source := fmt.Sprintf(`TEXT ·First(SB),NOSPLIT,$0-%d
+ MOV%s a+0(FP),SI
+ LEA%s ret+%d(FP),DI
+ %s
+ %s
+ RET
+`, width*2, word, word, width, setup, body)
+	source = strings.ReplaceAll(source, "WORD", word)
+	source = strings.ReplaceAll(source, "RESULT", fmt.Sprint(width))
+	return source, "func First(a " + typ + ") " + typ
+}
+
+func TestX86OrdinaryResultAddressWholeSource(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, test := range []struct{ name, setup, body string }{
+			{"direct_no_probe", "NOP", "MOVWORD SI,(DI)"},
+			{"copy", "MOVWORD DI,BX", "MOVWORD SI,(BX)"},
+			{"overlap", "MOVWORD DI,BX\n MOVWORD BX,DI", "MOVWORD SI,(DI)"},
+			{"interior", "LEAWORD 1(DI),BX\n LEAWORD -1(BX),BX", "MOVWORD SI,(BX)"},
+			{"same_join", "CMPWORD SI,$0\n JEQ alternate\n MOVWORD DI,BX\n JMP join\nalternate:\n LEAWORD 0(DI),BX\njoin:", "MOVWORD SI,(BX)"},
+			{"loop", "MOVL $2,CX\nloop:\n MOVWORD SI,(DI)\n DECL CX\n JNZ loop", "NOP"},
+			{"read_written", "NOP", "MOVWORD SI,(DI)\n MOVWORD (DI),AX\n MOVWORD AX,(DI)"},
+			{"overwritten_alias", "MOVWORD $7,DI", "MOVWORD DI,ret+RESULT(FP)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.arch+"/"+target.triple+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, declaration := x86OrdinaryResultAddressFixture(target.arch, test.setup, test.body)
+					if _, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressNoProbeRejectsUnknown(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			triple = "x86_64-unknown-linux-gnu"
+		}
+		for _, test := range []struct{ name, setup, body string }{
+			{"unknown_GP", "NOP", "MOVWORD AX,(DI)"},
+			{"read_unwritten", "NOP", "MOVWORD (DI),AX\n MOVWORD AX,(DI)"},
+			{"load_kills_alias", "NOP", "MOVWORD SI,(DI)\n MOVWORD (DI),DI\n MOVWORD $7,(DI)"},
+			{"partial_copy", "MOVB DI,BL", "MOVWORD SI,(BX)"},
+			{"different_join", "CMPWORD SI,$0\n JEQ alternate\n MOVWORD DI,BX\n JMP join\nalternate:\n LEAWORD 1(DI),BX\njoin:", "MOVWORD SI,(BX)"},
+			{"address_NUM", "NOP", "MOVWORD DI,ret+RESULT(FP)"},
+			{"address_vector", "MOVL DI,X0", "MOVWORD SI,(DI)"},
+			{"address_compare", "CMPWORD DI,$0", "MOVWORD SI,(DI)"},
+			{"escape_parameter", "MOVWORD DI,a+0(FP)", "MOVWORD SI,(DI)"},
+			{"escape_native", "MOVWORD $0,BX", "MOVWORD DI,(BX)\n MOVWORD SI,(DI)"},
+			{"indexed", "MOVWORD $0,CX", "MOVWORD SI,(DI)(CX*1)"},
+			{"oob", "NOP", "MOVWORD SI,1(DI)"},
+			{"negative", "NOP", "MOVWORD SI,-1(DI)"},
+			{"overflow", "NOP", "MOVWORD SI,9223372036854775807(DI)"},
+			{"cross_field", "LEAWORD 8(DI),DI", "MOVWORD SI,(DI)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, declaration := x86OrdinaryResultAddressFixture(arch, test.setup, test.body)
+					_, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("logical result alias accepted without complete proof: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressScalarTransferWidths(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, offset, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, offset, triple = "L", 4, "i386-unknown-linux-gnu"
+		}
+		for _, test := range []struct {
+			typ, setup, store string
+			bytes             int
+		}{
+			{"uint8", "NOP", "MOVB $7,(DI)", 1},
+			{"uint16", "NOP", "MOVW $7,(DI)", 2},
+			{"uint32", "MOVL $7,AX", "MOVL AX,(DI)", 4},
+			{"uint32", "PXOR X0,X0", "MOVL X0,(DI)", 4},
+			{"uint32", "PXOR X0,X0", "VMOVD X0,(DI)", 4},
+			{"uint64", "PXOR X0,X0", "MOVQ X0,(DI)", 8},
+			{"uint64", "PXOR X0,X0", "MOVD X0,(DI)", 8},
+			{"uint64", "PXOR X0,X0", "MOVDQ2Q X0,(DI)", 8},
+			{"uint64", "PXOR X0,X0", "VMOVQ X0,(DI)", 8},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+test.typ+"/"+test.store+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·First(SB),NOSPLIT,$0-%d\n LEA%s ret+%d(FP),DI\n %s\n %s\n RET\n", offset+test.bytes, word, offset, test.setup, test.store)
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func First(a uint8) "+test.typ, arch, triple, api); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressPrivateProofNotPublicAuthority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		for _, move := range []string{"MOVQ", "MOVD", "MOVDQ2Q", "VMOVQ"} {
+			t.Run(arch+"/"+move, func(t *testing.T) {
+				body := fmt.Sprintf("LEA%s ret+0(FP),DI\n PXOR X0,X0\n %s X0,(DI)\n RET", word, move)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint64", body)
+				before, err := x86CallerSourceFingerprint(file)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("declaration query acquired logical/native storage authority: %v", err)
+				}
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal(err)
+				}
+				if after, err := x86CallerSourceFingerprint(file); err != nil || after != before {
+					t.Fatal("result proof rewrote original Op/Raw/operand identity")
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressNativeAliasOrdering(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, typ, width, triple := "Q", "uint64", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, typ, width, triple = "L", "uint32", 4, "i386-unknown-linux-gnu"
+		}
+		for _, after := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/after_%t/%s", arch, after, api), func(t *testing.T) {
+					load, store := " MOVL (BX),AX\n", " MOV"+word+" SI,(DI)\n"
+					body := load + store
+					if after {
+						body = store + load
+					}
+					source := fmt.Sprintf("TEXT ·First(SB),NOSPLIT,$0-%d\n MOV%s p+0(FP),BX\n MOV%s a+%d(FP),SI\n LEA%s ret+%d(FP),DI\n%s RET\n", width*3, word, word, width, word, width*2, body)
+					_, err := x86ScalarFPBitViewAPI(t, source, "func First(p *uint32,a "+typ+") "+typ, arch, triple, api)
+					if after && !errors.Is(err, ErrProbeNeedsContext) || !after && err != nil {
+						t.Fatalf("logical/native alias ordering after=%t: %v", after, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressPhysicalBanksAndFieldBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, offset, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		registers := strings.Fields("AX CX DX BX SI DI R8 R9 R10 R11 R12 R13 R15")
+		if arch == "386" {
+			word, offset, triple = "L", 4, "i386-unknown-linux-gnu"
+			registers = strings.Fields("AX CX DX BX SI DI")
+		}
+		for _, register := range registers {
+			for _, width := range []int{1, 2, 4, 8} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/bytes_%d/%s", arch, register, width, api), func(t *testing.T) {
+						var body strings.Builder
+						fmt.Fprintf(&body, "TEXT ·First(SB),NOSPLIT,$0-%d\n CMPB a+0(FP),$0\n LEA%s ret+%d(FP),%s\n", offset+width, word, offset, register)
+						for current := 0; current < width; current++ {
+							fmt.Fprintf(&body, " MOVB $7,%d(%s)\n", current, register)
+						}
+						// Address construction/copy/memory transport changes no FLAGS.
+						fmt.Fprintf(&body, " JEQ done\n MOVB $8,(%s)\ndone:\n RET\n", register)
+						if _, err := x86ScalarFPBitViewAPI(t, body.String(), fmt.Sprintf("func First(a uint8) uint%d", width*8), arch, triple, api); err != nil {
+							t.Fatal(err)
+						}
+					})
+				}
+			}
+		}
+		for _, register := range []string{"SP", "BP", "R14", "R16", "AL", "AH", "X0", "M0", "TLS", "FS"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/mode_address_bank/"+register+"/"+api, func(t *testing.T) {
+					source, declaration := x86OrdinaryResultAddressFixture(arch, "NOP", "MOVWORD SI,(DI)")
+					source = strings.ReplaceAll(source, ",DI", ","+register)
+					source = strings.ReplaceAll(source, "(DI)", "("+register+")")
+					_, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					ordinary := arch == "386" && register == "BP"
+					if ordinary && err != nil || !ordinary && err == nil {
+						t.Fatal("result address acquired physical/unknown bank role")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressKeepsUnclosedRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, test := range []struct{ name, setup, body string }{
+			{"CALL", "CALL ·Other(SB)", "MOVWORD SI,(DI)"},
+			{"SP_memory", "MOVL $7,0(SP)", "MOVWORD SI,(DI)"},
+			{"raw", "BYTE $0x90", "MOVWORD SI,(DI)"},
+			{"MMX", "MOVQ M0,(DI)", "MOVWORD SI,(DI)"},
+			{"segment", "MOVW FS,(DI)", "MOVWORD SI,(DI)"},
+			{"uninitialized_X", "MOVL X0,(DI)", "NOP"},
+			{"partial_result", "MOVB $7,(DI)", "NOP"},
+			{"partial_read", "MOVB $7,(DI)", "MOVWORD (DI),AX\n MOVWORD AX,(DI)"},
+			{"unknown_flags", "JEQ done", "MOVWORD SI,(DI)\ndone:"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					source, declaration := x86OrdinaryResultAddressFixture(arch, test.setup, test.body)
+					_, err := x86ScalarFPBitViewAPI(t, source, declaration+"\nfunc Other()", arch, triple, api)
+					if err == nil {
+						t.Fatal("logical result acquired an unclosed entry/store/source role")
+					}
+				})
+			}
+		}
+		for _, address := range []string{"a+0(FP)", "padding+2(FP)", "ret+4095(FP)"} {
+			source, declaration := x86OrdinaryResultAddressFixture(arch, "NOP", "MOVWORD SI,(DI)")
+			offset := 8
+			if arch == "386" {
+				offset = 4
+			}
+			original := source
+			source = strings.ReplaceAll(source, fmt.Sprintf("ret+%d(FP)", offset), address)
+			pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sigs["First"], arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("parameter-only source acquired private result proof: %v", err)
+			}
+			// Keep the actual result-role instruction for this public consumer
+			// class, then overwrite its carrier with the invalid field address.
+			// Parameter-only consumers retain their independent existing route.
+			resultLEA := fmt.Sprintf(" LEA%s ret+%d(FP),DI\n", map[string]string{"386": "L", "amd64": "Q"}[arch], offset)
+			if !strings.Contains(original, resultLEA) {
+				t.Fatal("missing actual result-role instruction")
+			}
+			source = strings.Replace(source, " MOV", resultLEA+" MOV", 1)
+			if _, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("non-result field address %s: %v", address, err)
+			}
+		}
+		source, declaration := x86OrdinaryResultAddressFixture(arch, "NOP", "MOVWORD SI,(DI)")
+		source = strings.ReplaceAll(source, "$0-", "$8-")
+		if _, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, "text"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatalf("framed root acquired zero-frame alias role: %v", err)
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressLayoutAndBudgetRemainExact(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, typ := "Q", "uint64"
+		if arch == "386" {
+			word, typ = "L", "uint32"
+		}
+		_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() "+typ, "LEA"+word+" ret+0(FP),DI\n MOV"+word+" $7,(DI)\n RET")
+		for _, test := range []struct {
+			name   string
+			mutate func(*Func, *FuncSig)
+		}{
+			{"type", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Type = I8 }},
+			{"index", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Index = 1 }},
+			{"field", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Fields = []int{0} }},
+			{"negative", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Offset = -1 }},
+			{"extent", func(fn *Func, _ *FuncSig) { fn.ArgSize = 1 }},
+			{"oversized_CFG", func(fn *Func, _ *FuncSig) { fn.Instrs = append(fn.Instrs, make([]Instr, 4097)...) }},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				fn, changed := file.Funcs[0], sig
+				changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+				test.mutate(&fn, &changed)
+				if err := checkX86ScalarFPResultInitialization(fn, changed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("mutated actual layout/CFG acquired alias authority: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressDistinctFieldsAndRevocation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, offset, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, offset, triple = "L", 4, "i386-unknown-linux-gnu"
+		}
+		for _, test := range []struct {
+			name, body string
+			accept     bool
+		}{
+			{"distinct", "MOVL $7,(DI)\n MOVL $8,(BX)", true},
+			{"full_read", "MOVL $7,(DI)\n MOVL (DI),AX\n MOVL AX,(BX)", true},
+			{"cross_field", "PXOR X0,X0\n MOVQ X0,(DI)", false},
+			{"mixed_join", "CMPB a+0(FP),$0\n JEQ alternate\n MOVWORD DI,AX\n JMP join\nalternate:\n MOVWORD BX,AX\njoin:\n MOVL $7,(AX)\n MOVL $8,(BX)", false},
+			{"missing_join", "CMPB a+0(FP),$0\n JEQ alternate\n MOVWORD DI,AX\n JMP join\nalternate:\n NOP\njoin:\n MOVL $7,(AX)\n MOVL $8,(BX)", false},
+			{"numeric_revoke", "MOVL $0,DI\n MOVL $7,(DI)\n MOVL $8,(BX)", false},
+			{"alias_index", "MOVL $7,(DI)(BX*1)\n MOVL $8,(BX)", false},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+test.name+"/"+api, func(t *testing.T) {
+					body := strings.ReplaceAll(test.body, "WORD", word)
+					source := fmt.Sprintf("TEXT ·First(SB),NOSPLIT,$0-%d\n LEA%s first+%d(FP),DI\n LEA%s second+%d(FP),BX\n %s\n RET\n", offset+8, word, offset, word, offset+4, body)
+					declaration := "func First(a uint8) (first,second uint32)"
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if test.name == "numeric_revoke" {
+						// DI lost its logical result alias. Its independent NUM
+						// store still faults; it does not initialize first(FP).
+						x86PartialTupleCodegenControl(t, source, declaration, arch, triple, ir, err)
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							if !strings.Contains(text, "store volatile i32 7,") {
+								t.Fatal("revoked logical alias lost the exact native faulting store", text)
+							}
+						}
+						return
+					}
+					if test.accept && err != nil || !test.accept && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("distinct-field alias accept=%t: %v", test.accept, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryResultAddressConcurrentOriginalFile(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		source, declaration := x86OrdinaryResultAddressFixture(arch, "MOVWORD DI,BX", "MOVWORD SI,(BX)")
+		pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+		sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		before, err := x86CallerSourceFingerprint(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+		// Translate uses LLVM's global context. Its caller must serialize that
+		// context; concurrent module APIs below each own an independent context.
+		if _, err := Translate(file, options); err != nil {
+			t.Fatal(err)
+		}
+		var group sync.WaitGroup
+		for index := 0; index < 6; index++ {
+			group.Add(1)
+			go func(index int) {
+				defer group.Done()
+				if index%3 == 0 {
+					if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sigs[resolve(file.Funcs[0].Sym)], arch); err != nil {
+						t.Error(err)
+					}
+					return
+				}
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				if index%3 == 1 {
+					module, err := TranslateModuleInContext(ctx, file, options)
+					if !module.IsNil() {
+						module.Dispose()
+					}
+					if err != nil {
+						t.Error(err)
+					}
+					return
+				}
+				module, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple, ResolveSym: resolve})
+				if module != nil && !module.Module.IsNil() {
+					module.Module.Dispose()
+				}
+				if err != nil {
+					t.Error(err)
+				}
+			}(index)
+		}
+		group.Wait()
+		if _, err := Translate(file, options); err != nil {
+			t.Fatal(err)
+		}
+		if after, err := x86CallerSourceFingerprint(file); err != nil || after != before || file.x86DirectTails != nil || file.Funcs[0].x86DirectTailRoot != nil {
+			t.Fatal("private result proof mutated/published state on shared original File")
+		}
+	}
+}
diff --git a/x86_original_floating_runtime_objects_test.go b/x86_original_floating_runtime_objects_test.go
new file mode 100644
index 000000000..4bdc415c3
--- /dev/null
+++ b/x86_original_floating_runtime_objects_test.go
@@ -0,0 +1,364 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// The original Go programs contain KMOVQ, but their runtime owners execute
+// translated LLVM, not the Go machine objects. Observe that actual backend
+// output before inferring a BW requirement from a source spelling.
+func x86OriginalFloatingOpcodeListing(t *testing.T, profile, triple, level, ir string, masked bool, fmas int) {
+	t.Helper()
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("actual floating runtime ISA requires LLVM22 llc and llvm-objdump")
+	}
+	listing := x86FourSourceNativeObjectListing(t, llc, objdump, triple, level, ir)
+	x86OriginalFloatingAuditListing(t, profile, triple, level, listing, masked, fmas)
+}
+
+// Native family owners can inspect the exact object they subsequently execute;
+// the ordinary object owner and its finite ISA contract use the same auditor.
+func x86OriginalFloatingAuditListing(t *testing.T, profile, triple, level, listing string, masked bool, fmas int) {
+	t.Helper()
+	var violations []string
+	if strings.Contains(listing, "<unknown>") || strings.Contains(listing, "invalid") {
+		violations = append(violations, "actual object contains an undecoded instruction:\n"+listing)
+	}
+	rows := regexp.MustCompile(`(?m)^\s*[0-9a-f]+:\s+((?:[0-9a-f]{2}\s+)+)([a-z][a-z0-9.]*)`).FindAllStringSubmatch(listing, -1)
+	if len(rows) == 0 {
+		t.Fatal("actual original floating runtime object has no independent machine instructions", listing)
+	}
+	seen, kmovw, fmaCount := make(map[string]bool), 0, 0
+	for _, row := range rows {
+		op := row[2]
+		seen[op] = true
+		if op == "kmovw" {
+			kmovw++
+		}
+		if strings.HasPrefix(op, "vfm") || strings.HasPrefix(op, "vfnm") {
+			fmaCount++
+		}
+		// BW/DQ opmask transports are not interchangeable with the F-only
+		// same-call KMOVW used by these floating native emitters.
+		if strings.HasPrefix(op, "k") && !x86OriginalFloatingFMaskOpcode(op) {
+			violations = append(violations, "non-F opmask ISA: "+row[0])
+		}
+		code, err := hex.DecodeString(strings.Join(strings.Fields(row[1]), ""))
+		if err != nil || len(code) == 0 {
+			violations = append(violations, fmt.Sprintf("incomplete physical bytes: %s: %v", row[0], err))
+			continue
+		}
+		if code[0] == 0x62 && !x86OriginalFloatingEVEXWithinProfile(profile, op, code) {
+			violations = append(violations, "EVEX outside actual owner profile: "+row[0])
+		}
+	}
+	if masked && kmovw == 0 || fmaCount != fmas {
+		violations = append(violations, fmt.Sprintf("native operation inventory differs: KMOVW=%d masked=%t FMA=%d want=%d", kmovw, masked, fmaCount, fmas))
+	}
+	var inventory []string
+	for op := range seen {
+		inventory = append(inventory, op)
+	}
+	sort.Strings(inventory)
+	t.Logf("actual LLVM22 %s %s %s: %d instructions, KMOVW=%d, FMA=%d, opcodes=%s; object evidence, not CPU execution",
+		profile, triple, level, len(rows), kmovw, fmaCount, strings.Join(inventory, ","))
+	if len(violations) != 0 {
+		t.Fatalf("actual %s %s %s has %d ISA/identity violations:\n%s\ncomplete actual opcode inventory: %s",
+			profile, triple, level, len(violations), strings.Join(violations, "\n"), strings.Join(inventory, ","))
+	}
+}
+
+func x86OriginalFloatingFMaskOpcode(op string) bool {
+	switch op {
+	case "kmovw", "kandw", "kandnw", "korw", "kxorw", "kxnorw", "knotw", "kortestw":
+		return true
+	}
+	return false
+}
+
+// This is a deliberately bounded independent ISA contract for these two
+// original runtime programs, not a general instruction/CPUID classifier.
+// Unknown backend choices require review instead of silently adding a CPU bit.
+func x86OriginalFloatingEVEXWithinProfile(profile, op string, code []byte) bool {
+	estimate := profile == "estimate14-F" || profile == "estimate14-FVL"
+	if !estimate && profile != "scalar-precision" && profile != "fma-caller" || len(code) < 6 || code[0] != 0x62 {
+		return false
+	}
+	known, scalar, fma := false, false, false
+	for _, member := range append(go127FMA3PackedOps(), go127FMA3ScalarOps()...) {
+		if op == strings.ToLower(member) {
+			known, fma = true, true
+			scalar = strings.HasSuffix(member, "SS") || strings.HasSuffix(member, "SD")
+		}
+	}
+	switch op {
+	case "vcvtsd2ss", "vcvtss2sd", "vmovss", "vmovsd":
+		known, scalar = true, true
+	case "vmovaps", "vmovapd", "vmovups", "vmovupd",
+		"vmovdqa32", "vmovdqa64", "vmovdqu32", "vmovdqu64", "vpxord", "vpxorq",
+		"vpandd", "vpandq", "vpandnd", "vpandnq", "vpord", "vporq", "vpternlogd", "vpternlogq",
+		"vbroadcastss", "vbroadcastsd", "vextractf32x4", "vextracti32x4", "vextractf64x4", "vextracti64x4",
+		"vinsertf32x4", "vinserti32x4", "vinsertf64x4", "vinserti64x4", "vshuff32x4", "vshufi32x4",
+		"vshufps", "vshufpd", "vpermilps", "vpermilpd",
+		"vpslld", "vpsllq", "vpsrld", "vpsrlq", "vpsrad", "vpsraq",
+		"vpsllvd", "vpsllvq", "vpsrlvd", "vpsrlvq", "vpsravd", "vpsravq",
+		"vpmovdb", "vpmovdw", "vpmovqb", "vpmovqd", "vpmovqw",
+		"vpmovsdb", "vpmovsdw", "vpmovsqb", "vpmovsqd", "vpmovsqw",
+		"vpmovusdb", "vpmovusdw", "vpmovusqb", "vpmovusqd", "vpmovusqw":
+		known = true
+	}
+	if estimate {
+		if fma {
+			return false
+		}
+		for _, member := range x86Reciprocal14TestMembers {
+			if op == strings.ToLower(member.op) {
+				known, scalar = true, member.scalar
+			}
+		}
+	}
+	if !known {
+		return false
+	}
+	// The disassembler has already validated each complete instruction. LL
+	// is ignored by scalar forms, and is RC (not vector width) for packed
+	// register FMA with embedded rounding; that latter form is always Z512.
+	if scalar || fma && code[3]&0x10 != 0 && code[5]&0xc0 == 0xc0 {
+		return true
+	}
+	length := code[3] >> 5 & 3
+	return length == 2 || (profile == "fma-caller" || profile == "estimate14-FVL") && length < 2
+}
+
+func TestX86OriginalFloatingRuntimeEVEXProfileBoundaries(t *testing.T) {
+	type axis struct {
+		op      string
+		scalar  bool
+		rounder bool
+		memory  bool
+	}
+	rows := []axis{
+		{op: "vmovups"}, {op: "vmovdqa64"}, {op: "vpxord"}, {op: "vfmadd132ps"},
+		{op: "vcvtsd2ss", scalar: true}, {op: "vcvtss2sd", scalar: true},
+		{op: "vfmadd132ss", scalar: true}, {op: "vfmadd132pd", rounder: true},
+		{op: "vfmadd132pd", memory: true},
+	}
+	// Intel SDM Vol.2B PSLL/PSRL/PSRA and Vol.2C VPSLLV/VPSRLV/
+	// VPSRAV independently specify all twelve EVEX D/Q shifts as F for
+	// Z512 and F+VL for X/Y. Uniform/immediate and per-lane count roles
+	// do not turn those into the separate BW word/byte shift operations.
+	for _, stem := range []string{"vpsll", "vpsrl", "vpsra"} {
+		for _, variable := range []string{"", "v"} {
+			for _, lane := range []string{"d", "q"} {
+				rows = append(rows, axis{op: stem + variable + lane})
+			}
+		}
+	}
+	// SDM Vol.2C 5-577..599 gives all five D/Q-source narrowing ratios
+	// with truncation, signed saturation and unsigned saturation. Their LL
+	// field measures the source carrier, not the smaller byte/word result.
+	for _, saturation := range []string{"", "s", "us"} {
+		for _, ratio := range []string{"db", "dw", "qb", "qd", "qw"} {
+			rows = append(rows, axis{op: "vpmov" + saturation + ratio})
+		}
+	}
+	if len(rows) != 36 {
+		t.Fatal("complete original profile, twelve F shifts or fifteen F narrowing names changed", len(rows))
+	}
+	for _, profile := range []string{"scalar-precision", "fma-caller"} {
+		for length := byte(0); length < 4; length++ {
+			for _, row := range rows {
+				t.Run(fmt.Sprintf("%s/%s/memory%t/LL%d", profile, row.op, row.memory, length), func(t *testing.T) {
+					// Synthetic field projection, not an independent valid-encoding
+					// prior. Actual object checks above own complete LLVM decoding.
+					code := []byte{0x62, 0xf1, 0x7c, length << 5, 0x10, 0xc0}
+					if row.rounder {
+						code[3] |= 0x10
+					}
+					if row.memory {
+						code[3] |= 0x10
+						code[5] = 0
+					}
+					want := row.scalar || row.rounder || length == 2 || profile == "fma-caller" && length < 2
+					if x86OriginalFloatingEVEXWithinProfile(profile, row.op, code) != want {
+						t.Fatal("scalar LLIG or Z512 ER granted VL to a packed transport", code, want)
+					}
+				})
+			}
+		}
+		for _, op := range []string{
+			"vpsllw", "vpsrlw", "vpsraw", "vpsllvw", "vpsrlvw", "vpsravw", "vpslldq", "vpsrldq", "vpmullq",
+			"vpmovwb", "vpmovswb", "vpmovuswb",
+		} {
+			if x86OriginalFloatingEVEXWithinProfile(profile, op, []byte{0x62, 0xf1, 0x7c, 0x48, 0x10, 0xc0}) {
+				t.Fatal("F-only D/Q shifts admitted an independent BW word/byte or DQ operation", profile, op)
+			}
+		}
+	}
+	for _, op := range []string{"kmovb", "kmovd", "kmovq", "kaddw", "ktestw", "kandq"} {
+		if x86OriginalFloatingFMaskOpcode(op) {
+			t.Fatal("F-only mask inventory borrowed a BW/DQ opcode", op)
+		}
+	}
+	for _, row := range []struct {
+		profile string
+		code    []byte
+	}{
+		{"unknown", []byte{0x62, 0xf1, 0x7c, 0x48, 0x10, 0xc0}},
+		{"scalar-precision", []byte{0x62, 0xf1, 0x7c, 0x48, 0x10}},
+		{"fma-caller", []byte{0xc4, 0xf1, 0x7c, 0x48, 0x10, 0xc0}},
+	} {
+		if x86OriginalFloatingEVEXWithinProfile(row.profile, "vmovups", row.code) {
+			t.Fatal("profile projection invented a known owner or complete EVEX instruction", row)
+		}
+	}
+}
+
+func x86OriginalFloatingRuntimeObjectPipelines(t *testing.T, profile, triple, ir string, masked bool, fmas int) {
+	t.Helper()
+	for _, pipeline := range []struct{ name, body, level string }{
+		{"O0", ir, "-O0"}, {"O2", ir, "-O2"}, {"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			x86OriginalFloatingOpcodeListing(t, profile, triple, pipeline.level, pipeline.body, masked, fmas)
+		})
+	}
+}
+
+func TestX86OriginalScalarPrecisionRuntimeActualBackendISA(t *testing.T) {
+	source := x86ScalarPrecisionOriginalProgram(t)
+	if strings.Count(source, "KMOVQ mask+40(FP), K1") != 1 {
+		t.Fatal("original Go KMOVQ memory transport changed")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			// Keep the original owner's exact five pointer/one I64 manual ABI0
+			// declaration, not a different typed or caller translation route.
+			frame := FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+				{Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: Ptr, Index: 4, Field: -1},
+				{Offset: 40, Type: I64, Index: 5, Field: -1},
+			}}
+			ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "amd64", Sigs: map[string]FuncSig{
+				"scalarPrecisionConvertSemantics": {Name: "scalarPrecisionConvertSemantics", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+			}})
+			if err != nil {
+				t.Fatal("original scalar runtime translation failed before actual backend ISA observation", err)
+			}
+			x86OriginalFloatingRuntimeObjectPipelines(t, "scalar-precision", triple, ir, true, 0)
+		})
+	}
+}
+
+func x86OriginalFMACallerObjectSource(t *testing.T, formats []string, first int) (string, string) {
+	t.Helper()
+	data, file, set := x86OriginalFloatingPolicyFile(t, "amd64_go_caller_fma3_runtime_test.go")
+	batch := x86OriginalFloatingPolicyFunction(t, file, "runX86FMA3GoCallerNumericalBatch")
+	if fmt.Sprintf("%x", sha256.Sum256(data[set.Position(batch.Pos()).Offset:set.Position(batch.End()).Offset])) !=
+		"671c54ae2be89372425614cf9d9ef893080a25f929ad8e31d3087d69bbb927b7" || len(x86FMA3NamedFormats("amd64")) != 1836 {
+		t.Fatal("complete original FMA runtime builder or 1836-format inventory changed")
+	}
+	var goSource, assembly strings.Builder
+	goSource.WriteString("package caller\nimport \"unsafe\"\n")
+	for index, instruction := range formats {
+		name := fmt.Sprintf("fmacase%d", first+index)
+		base := strings.Split(strings.Fields(instruction)[0], ".")[0]
+		wide := strings.HasSuffix(base, "PD") || strings.HasSuffix(base, "SD")
+		declaration := x86CallerFixtureSource[strings.Index(x86CallerFixtureSource, "//go:noescape"):]
+		declaration = strings.ReplaceAll(declaration, "kernel", name)
+		declaration = strings.Replace(declaration, "func Call(", "func Call"+name+"(", 1)
+		if wide {
+			declaration = strings.ReplaceAll(declaration, "float32", "float64")
+		}
+		goSource.WriteString(declaration)
+		bank := "X"
+		if strings.Contains(instruction, "Y1") {
+			bank = "Y"
+		} else if strings.Contains(instruction, "Z1") {
+			bank = "Z"
+		}
+		body := fmt.Sprintf("VMOVUPS (DI),%s0\nVMOVUPS (SI),%s1\nVMOVUPS 64(SI),%s2\nKMOVQ AX,K1\n", bank, bank, bank)
+		body += strings.ReplaceAll(instruction, "(AX)", "(DI)") + "\n"
+		store := "VMOVSS X2,(DX)"
+		if wide {
+			store = "VMOVSD X2,(DX)"
+		}
+		body += store
+		machine := strings.ReplaceAll(x86CallerFixtureAssembly, "·kernel", "·"+name)
+		machine = strings.Replace(machine, "MOVL $7,AX", "MOVQ (CX),AX", 1)
+		assembly.WriteString(strings.Replace(machine, "MOVL AX,(DX)", body, 1))
+	}
+	return goSource.String(), assembly.String()
+}
+
+func TestX86OriginalFMACallerRuntimeActualBackendISA(t *testing.T) {
+	for _, op := range []string{
+		"vmovdqu8", "vmovdqu16", "vpmovb2m", "vpmovw2m", "vpaddb", "vpsllw",
+		"vxorps", "vxorpd", "vextractf64x2", "vinserti64x2", "vfmadd132ph", "vfmadd132sh",
+	} {
+		if x86OriginalFloatingEVEXWithinProfile("fma-caller", op, []byte{0x62, 0xf1, 0x7c, 0x48, 0x10, 0xc0}) {
+			t.Fatal("object opcode contract admitted an independent BW, DQ or FP16 dependency", op)
+		}
+	}
+	formats := make(map[string]bool)
+	for _, row := range x86FMA3NamedFormats("amd64") {
+		formats[row] = true
+	}
+	var rows []string
+	for _, row := range x86FMA3InitializedAxisRows("amd64") {
+		if formats[row] { // Exclude eight high-bank axes absent from the original owner.
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 170 {
+		t.Fatal("original FMA runtime's complete orthogonal physical/transport inventory changed", len(rows))
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			for first := 0; first < len(rows); first += 64 {
+				end := first + 64
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("batch%d", first/64), func(t *testing.T) {
+					goSource, source := x86OriginalFMACallerObjectSource(t, rows[first:end], first)
+					x86LEAActualTargetGoObject(t, "amd64", triple, source)
+					pkg := x86CallerRuntimePackage(t, goSource, source)
+					ctx := llvm.NewContext()
+					defer ctx.Dispose()
+					translation, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+						FileName: "value_amd64.s", GOARCH: "amd64", TargetTriple: triple,
+						ResolveSym: func(symbol string) string { return strings.Replace(symbol, "·", "caller.", 1) },
+					})
+					if err != nil {
+						t.Fatal("original FMA caller translation failed before backend ISA observation", err)
+					}
+					defer translation.Module.Dispose()
+					masked := false
+					for _, row := range rows[first:end] {
+						masked = masked || strings.Contains(row, "K1")
+					}
+					x86OriginalFloatingRuntimeObjectPipelines(t, "fma-caller", triple, translation.Module.String(), masked, end-first)
+				})
+			}
+		})
+	}
+	t.Log("170 original-owner orthogonal entries, not a new 1836-format Cartesian matrix or native CPU execution receipt")
+}
diff --git a/x86_original_floating_runtime_preflight_policy_test.go b/x86_original_floating_runtime_preflight_policy_test.go
new file mode 100644
index 000000000..43c3c7e1a
--- /dev/null
+++ b/x86_original_floating_runtime_preflight_policy_test.go
@@ -0,0 +1,365 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86OriginalFloatingPolicyFile(t *testing.T, path string) ([]byte, *ast.File, *token.FileSet) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal("original floating allocation preflight is missing", path, err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return data, file, set
+}
+
+func x86OriginalFloatingPolicyFunction(t *testing.T, file *ast.File, name string) *ast.FuncDecl {
+	t.Helper()
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == name {
+			return function
+		}
+	}
+	if strings.HasPrefix(name, "Test") {
+		helper := "qualify" + strings.TrimPrefix(name, "Test")
+		for _, declaration := range file.Decls {
+			if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == helper {
+				ciNativeAVX512RequireWrapper(t, name, helper)
+				return function
+			}
+		}
+	}
+	t.Fatal("original floating runtime owner disappeared", name)
+	return nil
+}
+
+func x86OriginalFloatingPolicyConstants(t *testing.T, node ast.Node) map[string]string {
+	t.Helper()
+	result := make(map[string]string)
+	ast.Inspect(node, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+			return true
+		}
+		literal, ok := value.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		text, err := strconv.Unquote(literal.Value)
+		if err != nil || result[value.Names[0].Name] != "" {
+			t.Fatal("ambiguous original floating runtime literal", err)
+		}
+		result[value.Names[0].Name] = text
+		return true
+	})
+	return result
+}
+
+func TestX86OriginalFloatingRuntimeOwnersKeepAllocationPreflight(t *testing.T) {
+	for _, owner := range []struct {
+		file, root, profile, target, prefix, boundary string
+	}{
+		{"amd64_lower_vcvtss2sd_test.go", "TestAMD64ScalarPrecisionConvertRuntimeSemantics", "scalar-precision",
+			"triple", "runPrefix", "compileAndRunRuntimeTestForTarget"},
+		{"amd64_go_caller_fma3_runtime_test.go", "TestCrossLinuxRuntimeMatrixX86FMA3GoCallerNumericalFamily", "fma-caller",
+			`testTargetTriple(runtime.GOOS, "amd64")`, "runner", "runX86FMA3GoCallerNumericalBatch"},
+	} {
+		t.Run(owner.profile, func(t *testing.T) {
+			data, file, set := x86OriginalFloatingPolicyFile(t, owner.file)
+			function := x86OriginalFloatingPolicyFunction(t, file, owner.root)
+			constants := x86OriginalFloatingPolicyConstants(t, file)
+			if owner.profile == "scalar-precision" {
+				for name, expected := range map[string]string{
+					"source": "55df95012f1cab5b5616e3c1a6a4921ab6af2ddb95381c11ee70198ca68882ab",
+					"mainC":  "e2f9b43bb03c8ea3557f9fc78f758df91129771197e7efc46df6ae4d17d1320d",
+				} {
+					if fmt.Sprintf("%x", sha256.Sum256([]byte(constants[name]))) != expected {
+						t.Fatal("original scalar precision ASM, C or samples changed", name)
+					}
+				}
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", "#include \"textflag.h\"\n"+constants["source"])
+				original, err := Parse(ArchAMD64, constants["source"])
+				if err != nil || len(original.Funcs) != 1 {
+					t.Fatal("complete original scalar precision source changed", err)
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", original.Funcs[0])
+				if !strings.Contains(features, "+avx512f") {
+					t.Fatal("original scalar precision lost its actual native ISA requirement", features)
+				}
+				for _, extra := range []string{"+avx512vl", "+avx512dq", "+avx512bw", "+fma"} {
+					if strings.Contains(features, extra) {
+						t.Fatal("scalar runtime borrowed a stronger ISA profile to hide an opcode error", features)
+					}
+				}
+			} else {
+				batch := x86OriginalFloatingPolicyFunction(t, file, owner.boundary)
+				original := data[set.Position(batch.Pos()).Offset:set.Position(batch.End()).Offset]
+				if fmt.Sprintf("%x", sha256.Sum256(original)) != "671c54ae2be89372425614cf9d9ef893080a25f929ad8e31d3087d69bbb927b7" ||
+					fmt.Sprintf("%x", sha256.Sum256([]byte(constants["x86FMA3CallerCOracle"]))) != "e5e92fdff02fdf254f04b6dcf0a88ec120ff19d152f4ce4b7eddb7191d5f943e" ||
+					len(x86FMA3NamedFormats("amd64")) != 1836 {
+					t.Fatal("complete original FMA source builder, C, 1836 formats or samples changed")
+				}
+			}
+			var calls []*ast.CallExpr
+			boundary := function.End()
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				name, ok := call.Fun.(*ast.Ident)
+				if ok && name.Name == "x86OriginalFloatingRuntimeRequireCPU" {
+					calls = append(calls, call)
+				}
+				if ok && name.Name == owner.boundary && call.Pos() < boundary {
+					boundary = call.Pos()
+				}
+				return true
+			})
+			if len(calls) != 1 || boundary == function.End() || calls[0].End() >= boundary {
+				t.Fatal("original runtime must own one actual-allocation preflight before any original program executes")
+			}
+			topLevel := false
+			for _, statement := range function.Body.List {
+				if expression, ok := statement.(*ast.ExprStmt); ok && expression.X == calls[0] {
+					topLevel = true
+				}
+			}
+			if !topLevel {
+				t.Fatal("actual allocation preflight must not be conditional, deferred or nested in another owner")
+			}
+			var actual bytes.Buffer
+			if err := format.Node(&actual, set, calls[0]); err != nil {
+				t.Fatal(err)
+			}
+			want := fmt.Sprintf("x86OriginalFloatingRuntimeRequireCPU(t, %q, clang, %s, %s)", owner.profile, owner.target, owner.prefix)
+			if actual.String() != want {
+				t.Fatal("preflight substituted the original execution profile, compiler, target or runner", actual.String(), want)
+			}
+		})
+	}
+}
+
+func x86OriginalFloatingPolicyDriver(t *testing.T) (string, string) {
+	t.Helper()
+	_, file, _ := x86OriginalFloatingPolicyFile(t, "x86_original_floating_runtime_preflight_test.go")
+	constants := x86OriginalFloatingPolicyConstants(t, file)
+	state, opcodes := constants["x86OriginalFloatingRuntimeStateC"], constants["x86OriginalFloatingRuntimeOpcodeC"]
+	if state == "" || opcodes == "" {
+		t.Fatal("complete original floating capability predicate or opcode preflight missing")
+	}
+	return state, opcodes
+}
+
+func TestX86OriginalFloatingRuntimeMinimumCapabilityBoundary(t *testing.T) {
+	state, _ := x86OriginalFloatingPolicyDriver(t)
+	_, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 clang required for independent capability boundary execution")
+	}
+	// This executes only the actual pure predicate on the actual host. The
+	// synthetic rows never authorize the separate original native opcodes.
+	const checks = `
+int main(void) {
+    for(unsigned profile=0;profile<8;profile++) for(unsigned flags=0;flags<64;flags++) {
+        unsigned sse2=flags&1,avx=(flags>>1)&1,os=(flags>>2)&1;
+        unsigned f=(flags>>3)&1,vl=(flags>>4)&1,fma=(flags>>5)&1;
+        for(unsigned bits=0;bits<32;bits++) {
+            const unsigned positions[]={1,2,5,6,7}; uint64_t xcr0=0;
+            for(unsigned i=0;i<5;i++) if(bits&(1u<<i)) xcr0|=UINT64_C(1)<<positions[i];
+            int expected=sse2&&avx&&os&&f&&bits==31&&
+                         (profile==1||profile==3||profile==5||(profile==2&&vl&&fma)||((profile==4||profile==6)&&vl));
+            if(original_floating_required_state(profile,sse2,avx,os,f,vl,fma,xcr0)!=expected ||
+               original_floating_required_state(profile,sse2,avx,os,f,vl,fma,xcr0|0x101)!=expected) return 1;
+        }
+    }
+    return 0;
+}
+`
+	execution := x86FloatCompareExecution{triple: testTargetTriple(runtime.GOOS, runtime.GOARCH), compiler: []string{clang}}
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "capability.c"), filepath.Join(directory, "capability")
+	if err := os.WriteFile(source, []byte(state+checks), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	execution.run(t, executable)
+}
+
+func TestX86OriginalFloatingRuntimeBaselineObjectsAndFaultBoundary(t *testing.T) {
+	state, opcodes := x86OriginalFloatingPolicyDriver(t)
+	data, file, _ := x86OriginalFloatingPolicyFile(t, "x86_original_floating_runtime_preflight_test.go")
+	driver := x86OriginalFloatingPolicyFunction(t, file, "x86OriginalFloatingRuntimeRequireCPU")
+	var rendered bytes.Buffer
+	if err := format.Node(&rendered, token.NewFileSet(), driver); err != nil {
+		t.Fatal(err)
+	}
+	for _, forbidden := range []string{".Skip(", "-mavx", "-march=", "x86FloatCompareRuntimeTools"} {
+		if strings.Contains(string(data), forbidden) {
+			t.Fatal("actual CPU diagnostic was replaced by a skip, Linux-only owner or nonbaseline compilation", forbidden)
+		}
+	}
+	compact := strings.Join(strings.Fields(rendered.String()), "")
+	for _, required := range []string{"compileC(t,", "runtimeOracleCombinedOutput(ctx,exec.CommandContext(ctx,", "runtimeOracleStageContext(t)", "prefix:prefix", "triple:triple"} {
+		if !strings.Contains(compact, required) {
+			t.Fatal("preflight lost its original owned execution route", required)
+		}
+	}
+	// The explicit auto policy can skip only the classified capability exit.
+	// Keep every other compiler, opcode, execution and cleanup failure fatal.
+	if strings.Count(string(data), ".Skipf(") != 1 ||
+		!strings.Contains(compact, "ifx86OriginalFloatingRuntimeAllowsSkip(mode,required,output,err){t.Skipf(") ||
+		!strings.Contains(compact, "iferr!=nil{t.Fatalf(") {
+		t.Fatal("optional hardware execution bypassed its receipt or failure boundary")
+	}
+	start := strings.LastIndex(opcodes, "int main(void)")
+	if start < 0 {
+		t.Fatal("actual native preflight main is missing")
+	}
+	main := opcodes[start:]
+	flush, guard := strings.Index(main, "fflush(stdout);"), strings.Index(main, "if (!original_floating_required_state(")
+	if flush < 0 || guard <= flush || strings.Index(main[guard:], "return 78;") < 0 {
+		t.Fatal("real CPU receipt must precede the mandatory missing-capability failure")
+	}
+	for _, opcode := range []string{"original_scalar_precision()", "original_fma_caller()", "original_unsigned_scalar_integer()", "original_packed_abs_sign()"} {
+		if at := strings.Index(main, opcode); at <= guard {
+			t.Fatal("original opcode executes before its actual feature/OS-state proof", opcode)
+		}
+	}
+	for _, required := range []string{"__get_cpuid(1", "__get_cpuid_count(7,0", "if (osxsave)", "xgetbv",
+		"AVX512F=%u", "AVX512VL=%u", "FMA=%u", "XCR0=%llx", "vcvtsd2ss", "vcvtss2sd", "vfmadd"} {
+		if !strings.Contains(opcodes, required) {
+			t.Fatal("actual CPUID/OS-state or original opcode diagnostic is incomplete", required)
+		}
+	}
+	_, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 clang required for baseline preflight objects")
+	}
+	for _, target := range []struct {
+		triple  string
+		windows bool
+	}{
+		{"x86_64-unknown-linux-gnu", false}, {"x86_64-apple-darwin", false}, {"x86_64-pc-windows-msvc", true},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			directory := t.TempDir()
+			if err := os.Mkdir(filepath.Join(directory, "sys"), 0700); err != nil {
+				t.Fatal(err)
+			}
+			resource := "struct rlimit { unsigned long rlim_cur,rlim_max; };\n#define RLIMIT_CORE 917\nint setrlimit(int,const struct rlimit*);\n"
+			if target.windows {
+				resource = "#error original_floating_windows_must_not_include_posix_resource\n"
+			}
+			for name, contents := range map[string]string{
+				"stdint.h":       "typedef unsigned int uint32_t; typedef unsigned long long uint64_t;\n#define UINT64_C(v) v##ULL\n",
+				"stdio.h":        "typedef struct FILE FILE; extern FILE *stdout; int printf(const char*,...); int fflush(FILE*); int puts(const char*);\n",
+				"cpuid.h":        "int __get_cpuid(unsigned,unsigned*,unsigned*,unsigned*,unsigned*); int __get_cpuid_count(unsigned,unsigned,unsigned*,unsigned*,unsigned*,unsigned*);\n",
+				"sys/resource.h": resource,
+			} {
+				if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+					t.Fatal(err)
+				}
+			}
+			for caseID := 0; caseID < 12; caseID++ {
+				profile, level := caseID%6+1, []string{"-O0", "-O2"}[caseID/6]
+				source, object := filepath.Join(directory, "preflight.c"), filepath.Join(directory, "preflight.o")
+				program := fmt.Sprintf("#define REQUIRED_PROFILE %d\n", profile) + state + opcodes
+				if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+					t.Fatal(err)
+				}
+				for _, ir := range []bool{false, true} {
+					output := object
+					args := []string{"-target", target.triple, "-nostdinc", "-I", directory, level, "-c"}
+					if ir {
+						output = filepath.Join(directory, "preflight.ll")
+						args = append(args, "-S", "-emit-llvm")
+					}
+					args = append(args, source, "-o", output)
+					ctx, cancel := runtimeOracleStageContext(t)
+					observed, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, clang, args...))
+					cancel()
+					if err != nil {
+						t.Fatalf("complete baseline preflight profile%d %s: %v\n%s", profile, level, err, observed)
+					}
+					payload, err := os.ReadFile(output)
+					if err != nil || len(payload) == 0 {
+						t.Fatal("actual preflight compiler object/IR missing", err)
+					}
+					if ir {
+						identity := regexp.MustCompile(`(?m)^define [^\n]*@main\([^\n]* #([0-9]+)`).FindSubmatch(payload)
+						if len(identity) != 2 {
+							t.Fatal("actual preflight main lost its independent baseline feature group")
+						}
+						group := regexp.MustCompile(`(?m)^attributes #` + string(identity[1]) + ` = [^\n]*`).Find(payload)
+						if len(group) == 0 || bytes.Contains(group, []byte("+avx")) || bytes.Contains(group, []byte("+fma")) {
+							t.Fatal("preflight main can fault before its CPUID/OS-state guard", string(group))
+						}
+						if profile >= 3 && profile <= 6 {
+							name := "original_unsigned_scalar_integer"
+							required := []string{"+avx512f"}
+							forbidden := []string{"+avx512vl", "+avx512dq", "+avx512bw"}
+							opcodes := []string{"vcvtusi2sdl ", "vcvtusi2sdq ", "vcvtusi2ssl ", "vcvtusi2ssq "}
+							if profile == 4 {
+								name = "original_packed_abs_sign"
+								required = append(required, "+avx512vl", "+ssse3", "+avx2")
+								forbidden = []string{"+avx512dq", "+avx512bw"}
+								opcodes = []string{"vpabsb ", "psignw ", "vpsignd ", "vpabsd ", "vpabsq "}
+							}
+							if profile == 5 || profile == 6 {
+								name = "original_estimate14_f"
+								opcodes = []string{"vrcp14ps ", "vrcp14pd ", "vrsqrt14ps ", "vrsqrt14pd ",
+									"vrcp14ss ", "vrcp14sd ", "vrsqrt14ss ", "vrsqrt14sd "}
+								if profile == 6 {
+									name = "original_estimate14_fvl"
+									required = append(required, "+avx512vl")
+									forbidden = []string{"+avx512dq", "+avx512bw"}
+									opcodes = opcodes[:4]
+								}
+							}
+							probe := regexp.MustCompile(`(?m)^define [^\n]*@` + name + `\([^\n]* #([0-9]+)`).FindSubmatch(payload)
+							if len(probe) != 2 {
+								t.Fatal("actual original-opcode function is missing from the compiled baseline driver", name)
+							}
+							probeGroup := regexp.MustCompile(`(?m)^attributes #` + string(probe[1]) + ` = [^\n]*`).Find(payload)
+							for _, feature := range required {
+								if !bytes.Contains(probeGroup, []byte(feature)) {
+									t.Fatal("actual original-opcode probe lost its independent minimum ISA", name, feature, string(probeGroup))
+								}
+							}
+							for _, feature := range forbidden {
+								if bytes.Contains(probeGroup, []byte(feature)) {
+									t.Fatal("original-opcode probe borrowed a stronger ISA", name, feature, string(probeGroup))
+								}
+							}
+							for _, opcode := range opcodes {
+								if !bytes.Contains(payload, []byte(opcode)) {
+									t.Fatal("compiled actual probe lost an original opcode", name, opcode)
+								}
+							}
+						}
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_original_floating_runtime_preflight_test.go b/x86_original_floating_runtime_preflight_test.go
new file mode 100644
index 000000000..d9d14198d
--- /dev/null
+++ b/x86_original_floating_runtime_preflight_test.go
@@ -0,0 +1,272 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+func x86OriginalFloatingRuntimeAllowsSkip(mode string, profile int, output []byte, err error) bool {
+	// Require a plain process exit. Joined timeout, pipe or cleanup errors are
+	// failures even if one of their causes happens to be exit78.
+	status, ok := err.(*exec.ExitError)
+	if mode != "auto" || !ok || status.ExitCode() != 78 || profile < 1 || profile > 4 {
+		return false
+	}
+	const format = "original-floating profile=%d SSE2=%d AVX=%d OSXSAVE=%d AVX512F=%d AVX512VL=%d FMA=%d SSSE3=%d AVX2=%d XCR0=%x"
+	var actual int
+	var sse2, avx, osxsave, f, vl, fma, ssse3, avx2 uint
+	var xcr0 uint64
+	receipt := strings.TrimSpace(string(output))
+	n, scanErr := fmt.Sscanf(receipt, format, &actual, &sse2, &avx, &osxsave, &f, &vl, &fma, &ssse3, &avx2, &xcr0)
+	if scanErr != nil || n != 10 || actual != profile ||
+		receipt != fmt.Sprintf(format, actual, sse2, avx, osxsave, f, vl, fma, ssse3, avx2, xcr0) {
+		return false
+	}
+	for _, bit := range []uint{sse2, avx, osxsave, f, vl, fma, ssse3, avx2} {
+		if bit > 1 {
+			return false
+		}
+	}
+	capable := sse2 == 1 && avx == 1 && osxsave == 1 && f == 1 && xcr0&0xe6 == 0xe6
+	if profile == 2 {
+		capable = capable && vl == 1 && fma == 1
+	}
+	if profile == 4 {
+		capable = capable && vl == 1 && ssse3 == 1 && avx2 == 1
+	}
+	return !capable
+}
+
+// Diagnose this original owner's actual execution route. These observations
+// cannot authorize another runner or replace the original numerical verdict.
+func x86OriginalFloatingRuntimeRequireCPU(t *testing.T, profile, clang, triple string, prefix []string) {
+	t.Helper()
+	mode := os.Getenv("PLAN9ASM_AVX512_RUNTIME")
+	if mode != "" && mode != "required" && mode != "auto" {
+		t.Fatalf("invalid PLAN9ASM_AVX512_RUNTIME %q: expected required or auto", mode)
+	}
+	var required int
+	switch profile {
+	case "scalar-precision":
+		required = 1
+	case "fma-caller":
+		required = 2
+	case "unsigned-scalar-integer":
+		required = 3
+	case "packed-abs-sign":
+		required = 4
+	case "estimate14-F":
+		required = 5
+	case "estimate14-FVL":
+		required = 6
+	default:
+		t.Fatal("unknown original floating execution profile", profile)
+	}
+	execution := x86FloatCompareExecution{
+		compiler: []string{clang, "-target", triple},
+		triple:   triple,
+		prefix:   prefix,
+	}
+	directory := t.TempDir()
+	source := filepath.Join(directory, "original-floating-preflight.c")
+	executable := filepath.Join(directory, gotoolchain.HostExecutable("original-floating-preflight"))
+	program := fmt.Sprintf("#define REQUIRED_PROFILE %d\n", required) +
+		x86OriginalFloatingRuntimeStateC + x86OriginalFloatingRuntimeOpcodeC
+	if err := os.WriteFile(source, []byte(program), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution.compileC(t, source, executable)
+	command := execution.command(executable)
+	ctx, cancel := runtimeOracleStageContext(t)
+	output, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, command[0], command[1:]...))
+	cancel()
+	t.Logf("actual original floating allocation profile=%s triple=%s prefix=%q: %s", profile, triple, prefix, output)
+	if x86OriginalFloatingRuntimeAllowsSkip(mode, required, output, err) {
+		t.Skipf("AVX512 native execution unavailable (PLAN9ASM_AVX512_RUNTIME=auto); object checks remain required, runtime not verified: %s", strings.TrimSpace(string(output)))
+	}
+	if err != nil {
+		t.Fatalf("original floating CPU/opcode preflight failed: %v\n%s", err, output)
+	}
+}
+
+// Scalar EVEX conversions require F, not packed narrow VL, DQ or BW. The
+// complete FMA owner additionally executes VEX FMA and narrow packed EVEX.
+// ABS/sign needs F/VL plus its independently observed legacy SSSE3/AVX2.
+// Keep this predicate portable so independent negative rows never execute ISA.
+const x86OriginalFloatingRuntimeStateC = `#include <stdint.h>
+static int original_floating_required_state(unsigned profile,unsigned sse2,unsigned avx,
+                                            unsigned osxsave,unsigned f,unsigned vl,
+                                            unsigned fma,uint64_t xcr0) {
+    if (!sse2 || !avx || !osxsave || !f || (xcr0&0xe6)!=0xe6) return 0;
+    return profile==1 || profile==3 || profile==5 || (profile==2 && vl && fma) || ((profile==4 || profile==6) && vl);
+}
+static int original_packed_abs_sign_required_legacy(unsigned ssse3,unsigned avx2) {
+    return ssse3 && avx2;
+}
+`
+
+// Only these independent probe functions have native target attributes. The
+// baseline entry prints real CPUID/XCR0 before any unsupported opcode can run.
+const x86OriginalFloatingRuntimeOpcodeC = `
+#include <stdio.h>
+#include <cpuid.h>
+#if !defined(_WIN32)
+#include <sys/resource.h>
+#endif
+
+__attribute__((target("avx512f")))
+static int original_scalar_precision(void) {
+    uint32_t narrow=1;
+    uint64_t wide=1;
+    unsigned mask=1;
+    __asm__ volatile("vxorps %%xmm0,%%xmm0,%%xmm0; kmovw %2,%%k1; "
+                     "vcvtsd2ss %{rn-sae%},%%xmm0,%%xmm0,%%xmm1%{%%k1%}; vmovss %%xmm1,%0; "
+                     "vcvtss2sd %{sae%},%%xmm0,%%xmm0,%%xmm1%{%%k1%}%{z%}; vmovsd %%xmm1,%1"
+                     : "=m"(narrow),"=m"(wide) : "r"(mask) : "xmm0","xmm1","k1","memory");
+    return narrow==0 && wide==0;
+}
+
+__attribute__((target("avx,fma,avx512f,avx512vl")))
+static int original_fma_caller(void) {
+    uint32_t scalar=1,packed[8];
+    uint64_t wide[8];
+    unsigned mask=0xffff;
+    __asm__ volatile("vxorps %%xmm0,%%xmm0,%%xmm0; "
+                     "vfmadd132ss %%xmm0,%%xmm0,%%xmm0; vmovss %%xmm0,%0; "
+                     "vxorps %%ymm0,%%ymm0,%%ymm0; kmovw %3,%%k1; "
+                     "vfmadd132ps %%ymm0,%%ymm0,%%ymm0%{%%k1%}; vmovups %%ymm0,%1; "
+                     "vpxord %%zmm0,%%zmm0,%%zmm0; "
+                     "vfmadd132pd %%zmm0,%%zmm0,%%zmm0; vmovupd %%zmm0,%2"
+                     : "=m"(scalar),"=m"(packed),"=m"(wide) : "r"(mask) : "zmm0","k1","memory");
+    if (scalar) return 0;
+    for (unsigned i=0;i<8;i++) if (packed[i] || wide[i]) return 0;
+    return 1;
+}
+
+__attribute__((target("avx512f")))
+static int original_unsigned_scalar_integer(void) {
+    uint32_t source32=0xffffffffu,narrow[2]={1,1};
+    uint64_t source64=0xffffffffffffffffULL,wide[2]={1,1};
+    __asm__ volatile("vxorps %%xmm0,%%xmm0,%%xmm0; "
+                     "vcvtusi2sdl %4,%%xmm0,%%xmm1; vmovsd %%xmm1,%0; "
+                     "vcvtusi2sdq %5,%{rz-sae%},%%xmm0,%%xmm1; vmovsd %%xmm1,%1; "
+                     "vcvtusi2ssl %6,%{rd-sae%},%%xmm0,%%xmm1; vmovss %%xmm1,%2; "
+                     "vcvtusi2ssq %5,%{rn-sae%},%%xmm0,%%xmm1; vmovss %%xmm1,%3"
+                     : "=m"(wide[0]),"=m"(wide[1]),"=m"(narrow[0]),"=m"(narrow[1])
+                     : "m"(source32),"r"(source64),"r"(source32) : "xmm0","xmm1","memory");
+    return wide[0]==0x41efffffffe00000ULL && wide[1]==0x43efffffffffffffULL &&
+           narrow[0]==0x4f7fffffu && narrow[1]==0x5f800000u;
+}
+
+__attribute__((target("ssse3,avx2,avx512f,avx512vl")))
+static int original_packed_abs_sign(void) {
+    uint32_t source[16] __attribute__((aligned(64)))={0};
+    uint32_t legacy[4],vex[8],masked[8];
+    uint64_t wide[8];
+    unsigned mask=1;
+    __asm__ volatile("vpxor %%ymm0,%%ymm0,%%ymm0; vpabsb %%xmm0,%%xmm0; "
+                     "psignw %4,%%xmm0; vmovdqu %%xmm0,%0; "
+                     "vpsignd %%ymm0,%%ymm0,%%ymm0; vmovdqu %%ymm0,%1; "
+                     "kmovw %5,%%k1; vpxor %%ymm1,%%ymm1,%%ymm1; "
+                     "vpabsd %4%{1to8%},%%ymm1%{%%k1%}; vmovdqu %%ymm1,%2; "
+                     "vpxord %%zmm0,%%zmm0,%%zmm0; "
+                     "vpabsq %%zmm0,%%zmm1%{%%k1%}%{z%}; vmovdqu64 %%zmm1,%3"
+                     : "=m"(legacy),"=m"(vex),"=m"(masked),"=m"(wide)
+                     : "m"(source),"r"(mask) : "zmm0","zmm1","k1","memory");
+    for (unsigned i=0;i<4;i++) if (legacy[i]) return 0;
+    for (unsigned i=0;i<8;i++) if (vex[i] || masked[i] || wide[i]) return 0;
+    return 1;
+}
+
+__attribute__((target("avx512f")))
+static int original_estimate14_f(void) {
+    uint32_t single[16]; uint64_t wide[8],packed[4][8];
+    for(unsigned i=0;i<16;i++) single[i]=0x3f800000u;
+    for(unsigned i=0;i<8;i++) wide[i]=UINT64_C(0x3ff0000000000000);
+    unsigned mask=1;
+    uint32_t scalar32[2]; uint64_t scalar64[2];
+    __asm__ volatile("vmovups %8,%%zmm0; vmovupd %9,%%zmm1; kmovw %10,%%k1; "
+                     "vrcp14ps %%zmm0,%%zmm2%{%%k1%}%{z%}; vmovups %%zmm2,%0; "
+                     "vrcp14pd %%zmm1,%%zmm2%{%%k1%}%{z%}; vmovups %%zmm2,%1; "
+                     "vrsqrt14ps %%zmm0,%%zmm2%{%%k1%}%{z%}; vmovups %%zmm2,%2; "
+                     "vrsqrt14pd %%zmm1,%%zmm2%{%%k1%}%{z%}; vmovups %%zmm2,%3; "
+                     "vrcp14ss %%xmm0,%%xmm0,%%xmm2%{%%k1%}%{z%}; vmovss %%xmm2,%4; "
+                     "vrcp14sd %%xmm1,%%xmm1,%%xmm2%{%%k1%}%{z%}; vmovsd %%xmm2,%5; "
+                     "vrsqrt14ss %%xmm0,%%xmm0,%%xmm2%{%%k1%}%{z%}; vmovss %%xmm2,%6; "
+                     "vrsqrt14sd %%xmm1,%%xmm1,%%xmm2%{%%k1%}%{z%}; vmovsd %%xmm2,%7; "
+                     : "=m"(packed[0]),"=m"(packed[1]),"=m"(packed[2]),"=m"(packed[3]),"=m"(scalar32[0]),"=m"(scalar64[0]),"=m"(scalar32[1]),"=m"(scalar64[1])
+                     : "m"(single),"m"(wide),"r"(mask) : "zmm0","zmm1","zmm2","k1","memory");
+    for(unsigned i=0;i<4;i++) for(unsigned j=0;j<8;j++) {
+        uint64_t expected=j?0:(i%2?UINT64_C(0x3ff0000000000000):UINT64_C(0x3f800000));
+        if(packed[i][j]!=expected) return 0;
+    }
+    if(scalar32[0]!=0x3f800000u || scalar32[1]!=0x3f800000u || scalar64[0]!=UINT64_C(0x3ff0000000000000) || scalar64[1]!=UINT64_C(0x3ff0000000000000)) return 0;
+    return 1;
+}
+
+__attribute__((target("avx512f,avx512vl")))
+static int original_estimate14_fvl(void) {
+    uint32_t single[16]; uint64_t wide[8],packed[8][8];
+    for(unsigned i=0;i<16;i++) single[i]=0x3f800000u;
+    for(unsigned i=0;i<8;i++) wide[i]=UINT64_C(0x3ff0000000000000);
+    unsigned mask=1;
+    __asm__ volatile("vmovups %8,%%zmm0; vmovupd %9,%%zmm1; kmovw %10,%%k1; "
+                     "vrcp14ps %%xmm0,%%xmm2%{%%k1%}%{z%}; vmovups %%zmm2,%0; "
+                     "vrcp14pd %%xmm1,%%xmm2%{%%k1%}%{z%}; vmovups %%zmm2,%1; "
+                     "vrsqrt14ps %%xmm0,%%xmm2%{%%k1%}%{z%}; vmovups %%zmm2,%2; "
+                     "vrsqrt14pd %%xmm1,%%xmm2%{%%k1%}%{z%}; vmovups %%zmm2,%3; "
+                     "vrcp14ps %%ymm0,%%ymm2%{%%k1%}%{z%}; vmovups %%zmm2,%4; "
+                     "vrcp14pd %%ymm1,%%ymm2%{%%k1%}%{z%}; vmovups %%zmm2,%5; "
+                     "vrsqrt14ps %%ymm0,%%ymm2%{%%k1%}%{z%}; vmovups %%zmm2,%6; "
+                     "vrsqrt14pd %%ymm1,%%ymm2%{%%k1%}%{z%}; vmovups %%zmm2,%7; "
+                     : "=m"(packed[0]),"=m"(packed[1]),"=m"(packed[2]),"=m"(packed[3]),"=m"(packed[4]),"=m"(packed[5]),"=m"(packed[6]),"=m"(packed[7])
+                     : "m"(single),"m"(wide),"r"(mask) : "zmm0","zmm1","zmm2","k1","memory");
+    for(unsigned i=0;i<8;i++) for(unsigned j=0;j<8;j++) {
+        uint64_t expected=j?0:(i%2?UINT64_C(0x3ff0000000000000):UINT64_C(0x3f800000));
+        if(packed[i][j]!=expected) return 0;
+    }
+    return 1;
+}
+
+int main(void) {
+#if !defined(_WIN32)
+    struct rlimit no_core={0,0};
+    if (setrlimit(RLIMIT_CORE,&no_core)) return 77;
+#endif
+    unsigned a,b,c,d,sse2=0,avx=0,osxsave=0,f=0,vl=0,fma=0,ssse3=0,avx2=0;
+    uint64_t xcr0=0;
+    if (__get_cpuid(1,&a,&b,&c,&d)) {
+        sse2=(d>>26)&1; avx=(c>>28)&1; osxsave=(c>>27)&1; fma=(c>>12)&1;
+        ssse3=(c>>9)&1;
+        if (osxsave) {
+            unsigned low,high;
+            __asm__ volatile("xgetbv" : "=a"(low),"=d"(high) : "c"(0));
+            xcr0=((uint64_t)high<<32)|low;
+        }
+    }
+    if (__get_cpuid_count(7,0,&a,&b,&c,&d)) {
+        f=(b>>16)&1; vl=(b>>31)&1;
+        avx2=(b>>5)&1;
+    }
+    unsigned profile=REQUIRED_PROFILE;
+    printf("original-floating profile=%u SSE2=%u AVX=%u OSXSAVE=%u AVX512F=%u AVX512VL=%u FMA=%u SSSE3=%u AVX2=%u XCR0=%llx\n",
+           profile,sse2,avx,osxsave,f,vl,fma,ssse3,avx2,(unsigned long long)xcr0);
+    fflush(stdout);
+    if (!original_floating_required_state(profile,sse2,avx,osxsave,f,vl,fma,xcr0)) return 78;
+    if (profile==4 && !original_packed_abs_sign_required_legacy(ssse3,avx2)) return 78;
+    if (profile==1 && !original_scalar_precision()) return 79;
+    if (profile==2 && !original_fma_caller()) return 80;
+    if (profile==3 && !original_unsigned_scalar_integer()) return 81;
+    if (profile==4 && !original_packed_abs_sign()) return 82;
+    if (profile==5 && !original_estimate14_f()) return 83;
+    if (profile==6 && !original_estimate14_fvl()) return 84;
+    puts("ORIGINAL_FLOATING_RUNTIME_CPU_OPCODES_OK");
+    return 0;
+}
+`
diff --git a/x86_original_native_abi0_fixture_test.go b/x86_original_native_abi0_fixture_test.go
new file mode 100644
index 000000000..303591c09
--- /dev/null
+++ b/x86_original_native_abi0_fixture_test.go
@@ -0,0 +1,223 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// ABI0 starts the result area at a word boundary, even for a uint32 parameter.
+// Actual Go asmdecl independently checks both target modes below. This helper
+// changes only the original-Go fixture's layout, not any translated program.
+func x86OriginalNativeMXCSRSource(arch string) string {
+	result := goWordSize(arch)
+	return fmt.Sprintf("TEXT ·MXCSR(SB),4,$0-%d\nSTMXCSR ret+%d(FP)\nLDMXCSR value+0(FP)\nRET\n", result+4, result)
+}
+
+func x86NativeFixtureASMDecl(t *testing.T, arch, declarations, source string, diagnostic string) {
+	t.Helper()
+	driver, _ := x86LEAActualSDKDriver(t)
+	directory := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":               "module oracle\n\ngo 1.20\n",
+		"value.go":             "package oracle\n" + declarations,
+		"value_" + arch + ".s": source,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "vet", "-asmdecl", "-p=1", ".")
+	command.Dir = directory
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0",
+		"GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off", "GOMAXPROCS=2")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if diagnostic == "" {
+		if err != nil {
+			t.Fatalf("actual Go %s asmdecl rejected the callable original fixture: %v\n%s", arch, err, output)
+		}
+	} else if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 1 || ctx.Err() != nil ||
+		!strings.Contains(string(output), diagnostic) || !strings.Contains(string(output), "value_"+arch+".s:") {
+		t.Fatalf("source-bound actual asmdecl rejection missing (not infrastructure): %v\n%s", err, output)
+	}
+	t.Logf("actual Go asmdecl arch=%s source-sha256=%x expected-diagnostic=%q", arch, sha256.Sum256([]byte(source)), diagnostic)
+}
+
+func x86NativeIndependentReturnLayout(arch string, bytes int) (string, string, int) {
+	word := 8
+	if arch == "386" {
+		word = 4
+	}
+	offset := (bytes + word - 1) / word * word
+	declaration := fmt.Sprintf("func Copy(bits uint%d) (ret uint%d)\n", bytes*8, bytes*8)
+	body := fmt.Sprintf("TEXT ·Copy(SB),4,$0-%d\n", offset+bytes)
+	if bytes == 8 && arch == "386" {
+		body += fmt.Sprintf("MOVL bits_lo+0(FP),AX\nMOVL AX,ret_lo+%d(FP)\nMOVL bits_hi+4(FP),AX\nMOVL AX,ret_hi+%d(FP)\n", offset, offset+4)
+	} else {
+		move := map[int]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[bytes]
+		body += fmt.Sprintf("%s bits+0(FP),AX\n%s AX,ret+%d(FP)\n", move, move, offset)
+	}
+	return body + "RET\n", declaration, offset
+}
+
+func TestX86OriginalNativeABI0ReturnLayoutActualGoPrior(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, bytes := range []int{1, 2, 4, 8} {
+			t.Run(fmt.Sprintf("%s/uint%d", arch, bytes*8), func(t *testing.T) {
+				source, declaration, offset := x86NativeIndependentReturnLayout(arch, bytes)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				x86NativeFixtureASMDecl(t, arch, declaration, source, "")
+				result := "ret"
+				if arch == "386" && bytes == 8 {
+					result = "ret_lo"
+				}
+				wrong := strings.Replace(source, fmt.Sprintf("%s+%d(FP)", result, offset), fmt.Sprintf("%s+%d(FP)", result, offset-1), 1)
+				x86NativeFixtureASMDecl(t, arch, declaration, wrong, fmt.Sprintf("invalid offset %s+%d(FP)", result, offset-1))
+				wrong = strings.Replace(source, fmt.Sprintf("$0-%d", offset+bytes), fmt.Sprintf("$0-%d", offset+bytes+1), 1)
+				x86NativeFixtureASMDecl(t, arch, declaration, wrong, "wrong argument size")
+			})
+		}
+	}
+}
+
+func TestX86OriginalNativeUint32HelpersMatchActualGoABI0(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		// This prior must complete before asking anything about fixture output.
+		prior, declaration, _ := x86NativeIndependentReturnLayout(arch, 4)
+		x86NativeFixtureASMDecl(t, arch, declaration, prior, "")
+		references, declarations := x86ScalarReciprocalOriginalReferences(arch)
+		for _, family := range []struct{ name, source, declaration string }{
+			{"duplicate-MXCSR", x86OriginalNativeMXCSRSource(arch), "func MXCSR(value uint32) uint32\n"},
+			{"reciprocal-all-four-and-MXCSR", references, declarations},
+		} {
+			t.Run(arch+"/"+family.name, func(t *testing.T) {
+				t.Logf("actual original fixture arch=%s family=%s source-sha256=%x", arch, family.name, sha256.Sum256([]byte(family.source)))
+				goAssemblerOracleOutput(t, arch, family.source, "", true)
+				x86NativeFixtureASMDecl(t, arch, family.declaration, family.source, "")
+			})
+		}
+	}
+}
+
+func x86NativeSegmentQuerySourceFormat(t *testing.T) string {
+	t.Helper()
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_segment_query_runtime_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var literal func(ast.Expr) string
+	literal = func(expression ast.Expr) string {
+		switch value := expression.(type) {
+		case *ast.BasicLit:
+			if value.Kind == token.STRING {
+				text, err := strconv.Unquote(value.Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+				return text
+			}
+		case *ast.BinaryExpr:
+			if value.Op == token.ADD {
+				return literal(value.X) + literal(value.Y)
+			}
+		}
+		return ""
+	}
+	var formats []string
+	ast.Inspect(file, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok || len(call.Args) < 2 {
+			return true
+		}
+		format := literal(call.Args[1])
+		if strings.Contains(format, "MOVQ selector+8(FP),AX") && strings.Contains(format, "LAHF\nMOVB AH,8(DI)") {
+			formats = append(formats, format)
+		}
+		return true
+	})
+	if len(formats) != 1 {
+		t.Fatal("actual segment-query source producer lost its unambiguous original format", len(formats))
+	}
+	return formats[0]
+}
+
+func TestX86OriginalNativeSegmentQueryUsesCompleteGoSETccSpelling(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{ASET([A-Z]+), yscond, Pb, opBytes\{0x0f, (0x[0-9a-f]+), 00\}\}`).FindAllStringSubmatch(string(data), -1)
+	conditions := []string{"CC", "CS", "EQ", "GE", "GT", "HI", "LE", "LS", "LT", "MI", "NE", "OC", "OS", "PC", "PL", "PS"}
+	opcodes := []string{"0x93", "0x92", "0x94", "0x9d", "0x9f", "0x97", "0x9e", "0x96", "0x9c", "0x98", "0x95", "0x91", "0x90", "0x9b", "0x99", "0x9a"}
+	if len(rows) != len(conditions) {
+		t.Fatal("complete official yscond directory changed", len(rows))
+	}
+	var prior strings.Builder
+	for index, row := range rows {
+		if row[1] != conditions[index] || row[2] != opcodes[index] {
+			t.Fatal("official SETcc opcode or complete spelling changed", row)
+		}
+		fmt.Fprintf(&prior, "TEXT ·Condition%d(SB),4,$0-0\nSET%s AL\nRET\n", index, row[1])
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil || regexp.MustCompile(`instructions\["SET`).Match(aliases) {
+		t.Fatal("Go SETcc alias namespace changed; inspect the complete official map", err)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		goAssemblerOracleOutput(t, arch, prior.String(), "", true)
+		for _, illegal := range []string{"SETO", "SETNO"} {
+			goAssemblerOracleOutput(t, arch, "TEXT ·Invalid(SB),4,$0-0\n"+illegal+" AL\nRET\n", "", false)
+		}
+	}
+	format := x86NativeSegmentQuerySourceFormat(t)
+	var source, declarations strings.Builder
+	for index, row := range x86SegmentQueryOracle {
+		for role, operand := range []string{"AX", "(SI)", "CX"} {
+			for seed := 0; seed < 2; seed++ {
+				name := fmt.Sprintf("Query%d_%d_%d", index, role, seed)
+				operation := row.op + " " + operand
+				prepare, _ := x86SegmentQueryNativeFlagSeed(seed == 1)
+				if row.bytes != 0 {
+					operation += ",CX"
+				}
+				source.WriteString(fmt.Sprintf(format, name, prepare, operation))
+				fmt.Fprintf(&declarations, "func %s(out *[18]byte,selector,old uint64,p *uint16)\n", name)
+			}
+		}
+	}
+	// The real complete producer must have a valid original Go object before
+	// any translator result can count. No invalid spelling is relabelled Context.
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	seed, _ := x86SegmentQueryNativeFlagSeed(false)
+	if strings.Count(source.String(), seed) != 24 {
+		t.Fatal("complete original zero-overflow seed denominator changed")
+	}
+	legacy := strings.ReplaceAll(source.String(), seed, "XORL DX,DX\nSTC\n")
+	goAssemblerOracleOutput(t, "amd64", legacy, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api+"/all-six-status-inputs", func(t *testing.T) {
+			if ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+				t.Fatal("original Go-compatible complete segment-query observer rejected", err)
+			}
+		})
+		t.Run(api+"/original-XOR-undefined-AF", func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, legacy, declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+			if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "LAHF") {
+				t.Fatal("original XOR's undefined AF became an initialized complete LAHF byte", err)
+			}
+		})
+	}
+}
diff --git a/x86_owned_immediate_store_test.go b/x86_owned_immediate_store_test.go
new file mode 100644
index 000000000..27ca5d2aa
--- /dev/null
+++ b/x86_owned_immediate_store_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Reuse the complete independent Yi32 boundary inventory and its byte/canary
+// reference. Only the actual destination changes from a caller pointer to an
+// explicitly defined module-owned object. C names that object, not defines it.
+func x86OwnedImmediateStoreFixture(t *testing.T, arch string) (source, declarations, driver string, count int) {
+	t.Helper()
+	source, declarations, driver, count = x86NativeImmediateStoreFixture(arch)
+	want := 66
+	if arch == "386" {
+		want = 42
+	}
+	if count != want || strings.Count(source, "-1(DI)(BX*2)") != count ||
+		strings.Count(driver, "int main(void){uint8_t actual[32],expected[32];") != 1 {
+		t.Fatal("complete original immediate boundary/reference inventory changed", count)
+	}
+	source = "GLOBL ·storage(SB),16,$32\n" +
+		strings.ReplaceAll(source, "-1(DI)(BX*2)", "·storage+5(SB)")
+	driver = strings.Replace(driver, "int main(void){uint8_t actual[32],expected[32];",
+		"extern uint8_t storage[32];\nint main(void){uint8_t expected[32];", 1)
+	driver = strings.ReplaceAll(driver, "actual", "storage")
+	if strings.Count(driver, "memset(storage,") != count || strings.Count(driver, "memcmp(storage,") != count ||
+		strings.Count(driver, "extern uint8_t storage[32];") != 1 {
+		t.Fatal("owned counterpart lost full independent expected bytes or canaries")
+	}
+	return
+}
+
+func TestX86OwnedImmediateStoreCompleteGoEncodingValues(t *testing.T) {
+	store := regexp.MustCompile(`(?m)^  store(?: volatile)? i([0-9]+) (-?[0-9]+), ptr [^\n]+, align 1$`)
+	for _, arch := range []string{"386", "amd64"} {
+		source, _, _, count := x86OwnedImmediateStoreFixture(t, arch)
+		goAssemblerOracleOutput(t, arch, source, "", true)
+		file := mustParseX86RawReturn(t, source)
+		seen := 0
+		for _, function := range file.Funcs {
+			for _, instruction := range function.Instrs {
+				if len(instruction.Args) != 2 || instruction.Args[0].Kind != OpImm ||
+					instruction.Args[1].Kind != OpSym || instruction.Args[1].Sym != "·storage+5(SB)" {
+					continue
+				}
+				seen++
+				t.Run(arch+"/"+function.Sym, func(t *testing.T) {
+					width := map[Op]int{"MOVB": 1, "MOVW": 2, "MOVL": 4, "MOVQ": 8, "MOVD": 8, "MOVDQ2Q": 8}[instruction.Op]
+					if width == 0 {
+						t.Fatal("unreviewed original immediate-store opcode", instruction.Op)
+					}
+					context, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+					context.goarch = arch
+					before := output.Len()
+					known, terminated, err := context.lowerMov(instruction.Op, instruction)
+					if !known || terminated || err != nil {
+						t.Fatal("original static immediate format emitter", known, terminated, err)
+					}
+					// This is private format emission, not public source/NUM or
+					// native execution qualification. Observe only this instruction.
+					matches := store.FindAllStringSubmatch(output.String()[before:], -1)
+					if len(matches) != 1 || matches[0][1] != strconv.Itoa(width*8) {
+						t.Fatal("one exact-width immediate store required", output.String()[before:])
+					}
+					value, err := strconv.ParseInt(matches[0][2], 10, 64)
+					if err != nil {
+						t.Fatal(err)
+					}
+					got, want := uint64(value), uint64(instruction.Args[0].Imm)
+					if width == 8 {
+						want = uint64(int64(int32(instruction.Args[0].Imm)))
+					} else {
+						mask := uint64(1)<<(width*8) - 1
+						got, want = got&mask, want&mask
+					}
+					if got != want {
+						t.Fatalf("original Go imm32 encoding differs: %s got %#x want %#x", instruction.Raw, got, want)
+					}
+				})
+			}
+		}
+		if seen != count {
+			t.Fatal("incomplete immediate byte-value inventory", seen, count)
+		}
+	}
+}
+
+func TestX86OwnedImmediateStoreCompleteFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, _, _ := x86OwnedImmediateStoreFixture(t, arch)
+		for _, target := range x86AddressMemoryTargets(arch) {
+			t.Run(target, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, arch, target, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, target, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete original Go immediate boundaries with actual writable storage", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+// Portable LLVM/C values on the actual host, not the stock-Go native ABI.
+// The independent reference still checks every boundary and all 32 canaries.
+func TestX86OwnedImmediateStorePortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch := "amd64"
+	if runtime.GOARCH == "386" {
+		arch = "386"
+	}
+	source, declarations, driver, count := x86OwnedImmediateStoreFixture(t, arch)
+	if count != 66 && arch != "386" || count != 42 && arch == "386" {
+		t.Fatal("complete execution denominator changed", count)
+	}
+	goAssemblerOracleOutput(t, arch, source, "", true)
+	target := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, target, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete owned immediate source rejected", err)
+			}
+			for pipeline, text := range []string{ir, ir, x86DwordProductIROptimize(t, ir)} {
+				level := 2
+				if pipeline == 0 {
+					level = 0
+				}
+				t.Run(fmt.Sprintf("pipeline%d", pipeline), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "owned-immediate-store", target, text, driver, nil, level)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_owned_scalar_store_go127_test.go b/x86_owned_scalar_store_go127_test.go
new file mode 100644
index 000000000..09f0f3ffe
--- /dev/null
+++ b/x86_owned_scalar_store_go127_test.go
@@ -0,0 +1,65 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86OwnedScalarStoreCompleteOfficialGoGrammar(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := regexp.MustCompile(`//[^\n]*`).ReplaceAllString(string(data), "")
+	compact := func(s string) string { return strings.Join(strings.Fields(s), "") }
+	for name, expected := range map[string]string{
+		"ymovb": `{Zr_m,1,argList{Yrb,Ymb}}, {Zm_r,1,argList{Ymb,Yrb}},
+			{Zib_rp,1,argList{Yi32,Yrb}}, {Zibo_m,2,argList{Yi32,Ymb}},`,
+		"ymovw": `{Zr_m,1,argList{Yrl,Yml}}, {Zm_r,1,argList{Yml,Yrl}},
+			{Zil_rp,1,argList{Yi32,Yrl}}, {Zilo_m,2,argList{Yi32,Yml}}, {Zaut_r,2,argList{Yiauto,Yrl}},`,
+		"ymovl": `{Zr_m,1,argList{Yrl,Yml}}, {Zm_r,1,argList{Yml,Yrl}},
+			{Zil_rp,1,argList{Yi32,Yrl}}, {Zilo_m,2,argList{Yi32,Yml}},
+			{Zm_r_xm,1,argList{Yml,Ymr}}, {Zr_m_xm,1,argList{Ymr,Yml}},
+			{Zm_r_xm,2,argList{Yml,Yxr}}, {Zr_m_xm,2,argList{Yxr,Yml}}, {Zaut_r,2,argList{Yiauto,Yrl}},`,
+		"ymovq": `{Zm_r_xm_nr,1,argList{Ym,Ymr}}, {Zr_m_xm_nr,1,argList{Ymr,Ym}},
+			{Zm_r_xm_nr,2,argList{Yxr,Ymr}}, {Zm_r_xm_nr,2,argList{Yxm,Yxr}}, {Zr_m_xm_nr,2,argList{Yxr,Yxm}},
+			{Zr_m,1,argList{Yrl,Yml}}, {Zm_r,1,argList{Yml,Yrl}},
+			{Ziq_rp,1,argList{Yi64,Yrl}}, {Zilo_m,2,argList{Yi32,Yml}},
+			{Zm_r_xm,1,argList{Ymm,Ymr}}, {Zr_m_xm,1,argList{Ymr,Ymm}},
+			{Zm_r_xm,2,argList{Yml,Yxr}}, {Zr_m_xm,2,argList{Yxr,Yml}}, {Zaut_r,1,argList{Yiauto,Yrl}},`,
+	} {
+		block := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+		if len(block) != 2 || compact(block[1]) != compact(expected) {
+			t.Fatal("complete original Go scalar transport table changed", name)
+		}
+	}
+	for _, row := range []string{
+		"{AMOVB,ymovb,Pb,opBytes{0x88,0x8a,0xb0,0xc6,00}}",
+		"{AMOVW,ymovw,Pe,opBytes{0x89,0x8b,0xb8,0xc7,00,0}}",
+		"{AMOVL,ymovl,Px,opBytes{0x89,0x8b,0xb8,0xc7,00,0x6e,0x7e,Pe,0x6e,Pe,0x7e,0}}",
+		"{AMOVQ,ymovq,Pw8,opBytes{0x6f,0x7f,Pf2,0xd6,Pf3,0x7e,Pe,0xd6,0x89,0x8b,0xb8,0xc7,00,0x6e,0x7e,Pe,0x6e,Pe,0x7e,0}}",
+	} {
+		if strings.Count(compact(text), row) != 1 {
+			t.Fatal("original Go opcode/prefix/byte inventory changed", row)
+		}
+	}
+	frontend, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/asm/internal/arch/arch.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+		if strings.Count(string(frontend), fmt.Sprintf(`instructions[%q] = x86.AMOVQ`, alias)) != 1 {
+			t.Fatal("original Go qword source alias changed", alias)
+		}
+		for _, op := range []string{"MOVQ", alias} {
+			goAssemblerOracleOutput(t, "386", "TEXT ·Value(SB),4,$0-0\n"+op+" AX,·storage(SB)\nRET\n", "", false)
+		}
+	}
+}
diff --git a/x86_owned_scalar_store_test.go b/x86_owned_scalar_store_test.go
new file mode 100644
index 000000000..6aa9f633b
--- /dev/null
+++ b/x86_owned_scalar_store_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent GP rows from ymovb/w/l/q. The two Q aliases are source aliases,
+// not mode32 GP transports, MMX identities or separate initialized inputs.
+type x86OwnedScalarStoreRow struct {
+	op, register string
+	width, first int64
+}
+
+func x86OwnedScalarStoreRows(arch string) []x86OwnedScalarStoreRow {
+	rows := []x86OwnedScalarStoreRow{
+		{"MOVB", "AL", 1, 0}, {"MOVB", "AH", 1, 1},
+		{"MOVW", "AX", 2, 0}, {"MOVL", "AX", 4, 0},
+	}
+	if arch == "amd64" {
+		rows = append(rows, x86OwnedScalarStoreRow{"MOVQ", "AX", 8, 0},
+			x86OwnedScalarStoreRow{"MOVD", "AX", 8, 0},
+			x86OwnedScalarStoreRow{"MOVDQ2Q", "AX", 8, 0})
+	}
+	return rows
+}
+
+func x86OwnedScalarStoreSource(row x86OwnedScalarStoreRow, arch, body string) string {
+	move := "MOVL"
+	if arch == "amd64" {
+		move = "MOVQ"
+	}
+	if body == "" {
+		body = fmt.Sprintf("%s $0x12345678,AX\nSTC\n%s %s,·storage+3(SB)\nSETCS BX\n",
+			move, row.op, row.register)
+	}
+	return "GLOBL ·storage(SB),16,$32\nTEXT ·Value(SB),4,$0-0\n" + body + "RET\n"
+}
+
+func TestX86OwnedScalarStoreCompleteInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source, declarations strings.Builder
+		source.WriteString("GLOBL ·storage(SB),16,$32\n")
+		count := 0
+		for _, row := range x86OwnedScalarStoreRows(arch) {
+			for _, immediate := range []bool{false, true} {
+				if immediate && row.register == "AH" {
+					continue // One immediate row per original opcode, not per register spelling.
+				}
+				name := fmt.Sprintf("OwnedStore%d", count)
+				count++
+				input := row.register
+				if immediate {
+					input = "$7"
+				}
+				move := "MOVL"
+				if arch == "amd64" {
+					move = "MOVQ"
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n%s $0x12345678,AX\nSTC\n%s %s,·storage+3(SB)\nSETCS BX\nRET\n",
+					name, move, row.op, input)
+				fmt.Fprintf(&declarations, "func %s()\n", name)
+			}
+		}
+		want := 7
+		if arch == "amd64" {
+			want = 13
+		}
+		if count != want {
+			t.Fatal("complete register/immediate/alias inventory changed", count)
+		}
+		for _, target := range x86AddressMemoryTargets(arch) {
+			t.Run(target, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, arch, target, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, target, api)
+						if err != nil || ir == "" {
+							t.Fatal("fully initialized GP store to actual module-owned writable bytes", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86OwnedScalarStoreCannotInventSourceOrStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86OwnedScalarStoreRows(arch) {
+			original := x86OwnedScalarStoreSource(row, arch, "")
+			move, word := "MOVL", 4
+			if arch == "amd64" {
+				move, word = "MOVQ", 8
+			}
+			for _, mutation := range []string{"external", "readonly", "short", "negative-offset", "past-end",
+				"code-symbol", "relocation-payload", "missing-input", "partial-input", "pointer-input", "missing-flags", "raw-return"} {
+				if mutation == "partial-input" && row.width == 1 {
+					continue // The separate missing-input case removes its sole selected byte.
+				}
+				t.Run(arch+"/"+row.op+"/"+row.register+"/"+mutation, func(t *testing.T) {
+					source, declaration := original, "func Value()\n"
+					switch mutation {
+					case "external":
+						source = strings.TrimPrefix(source, "GLOBL ·storage(SB),16,$32\n")
+					case "readonly":
+						source = strings.Replace(source, ",16,$32", ",8,$32", 1)
+					case "short":
+						source = strings.Replace(source, "$32\n", fmt.Sprintf("$%d\n", row.width+2), 1)
+					case "negative-offset":
+						source = strings.Replace(source, "·storage+3(SB)", "·storage-1(SB)", 1)
+					case "past-end":
+						source = strings.Replace(source, "·storage+3(SB)", "·storage+32(SB)", 1)
+					case "code-symbol":
+						source = strings.Replace(source, "·storage+3(SB)", "·Value(SB)", 1)
+					case "relocation-payload":
+						source = fmt.Sprintf("DATA ·storage+0(SB)/%d,$·other(SB)\nGLOBL ·other(SB),16,$8\n", word) + source
+					case "missing-input":
+						source = strings.Replace(source, move+" $0x12345678,AX\n", "", 1)
+					case "partial-input":
+						source = strings.Replace(source, move+" $0x12345678,AX", "MOVB $7,AL", 1)
+					case "pointer-input":
+						declaration = "func Value(input *byte)\n"
+						source = strings.Replace(source, "$0-0\n", fmt.Sprintf("$0-%d\n", word), 1)
+						source = strings.Replace(source, move+" $0x12345678,AX", move+" input+0(FP),AX", 1)
+					case "missing-flags":
+						source = strings.Replace(source, "STC\n", "", 1)
+					case "raw-return":
+						source = strings.Replace(source, "RET\n", "BYTE $0xc3\nRET\n", 1)
+					}
+					if source == original {
+						t.Fatal("independent negative did not change its source")
+					}
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("owned store invented source/storage/FLAGS/raw permission", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+// This interface lets the test-only revision compile before the independent
+// lowering-local consumer exists. Its absence is an explicit effect-owner RED,
+// not a compiler error or an invented ambient public source capability.
+type x86OwnedScalarStoreConsumer interface {
+	scalarStaticMoveTransfer(Instr, *x86ResultState, []bool, string) (bool, bool)
+}
+
+func TestX86OwnedScalarStoreEveryByteAndNoEscapingFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86OwnedScalarStoreRows(arch) {
+			t.Run(arch+"/"+row.op+"/"+row.register, func(t *testing.T) {
+				source := x86OwnedScalarStoreSource(row, arch, "")
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file := mustParseX86RawReturn(t, source)
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				context := &amd64Ctx{resolve: resolve,
+					fpStaticAddressValues: x86LoweredStaticAddressValues(file, resolve, nil, arch),
+					fpScalarData:          x86LoweredScalarDataReads(file, resolve, nil, arch)}
+				instruction := x86ScalarLaneInstruction(t, row.op+" "+row.register+",·storage+3(SB)")
+				consumer, present := any(context).(x86OwnedScalarStoreConsumer)
+				if !present {
+					t.Fatal("missing lowering-local complete owned scalar MOV consumer")
+				}
+				for missing := int64(-1); missing < row.width; missing++ {
+					for _, flags := range []uint8{0, x86ByteFlagsAll} {
+						state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+						state.gp[0], state.gp[2], state.canonicalGP[2] = 0xff, 0x55, 0xaa
+						state.pointerGP[2], state.callerAddressGP[2] = true, true
+						if missing >= 0 {
+							state.gp[0] &^= 1 << uint(row.first+missing)
+						}
+						before := state.clone()
+						accepted, known := consumer.scalarStaticMoveTransfer(instruction, &state, nil, arch)
+						if !known || accepted != (missing < 0) || !reflect.DeepEqual(state, before) {
+							t.Fatal("selected input byte, unchanged FLAGS/DF or rollback contract", missing, accepted, known)
+						}
+					}
+				}
+				for _, mutation := range []string{"encoded", "address-size", "segment", "opaque-pointer"} {
+					ins := instruction
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.gp[0] = 0xff
+					switch mutation {
+					case "encoded":
+						ins.x86Encoded = true
+					case "address-size":
+						ins.x86AddressBits = 16
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "opaque-pointer":
+						state.pointerGP[0], state.gp[0] = true, 0
+					}
+					before := state.clone()
+					if accepted, _ := consumer.scalarStaticMoveTransfer(ins, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("store borrowed another role or partially mutated rejected state", mutation)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_abs_sign_features_test.go b/x86_packed_abs_sign_features_test.go
new file mode 100644
index 000000000..1dbf2b2a8
--- /dev/null
+++ b/x86_packed_abs_sign_features_test.go
@@ -0,0 +1,138 @@
+package plan9asm
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86AbsSignIndependentFeatures(bits, width int, legacy, evex bool) string {
+	features := []string{"+avx"}
+	if legacy {
+		features = []string{"+sse2", "+ssse3"}
+	} else if evex {
+		features = []string{"+avx512f"}
+		if bits < 32 {
+			features = append(features, "+avx512bw")
+		}
+		if width < 64 {
+			features = append(features, "+avx512vl")
+		}
+	} else if width == 32 {
+		features = []string{"+avx2"}
+	}
+	sort.Strings(features)
+	return strings.Join(features, ",")
+}
+
+func TestX86PackedAbsSignIsolatedCompleteISAProfiles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedAbsSignOracleRows() {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				evex := !row.legacy && !row.sign && (row.bits == 64 || row.width == 64 || row.mode == "merge" || row.mode == "zero" || row.source == "broadcast")
+				want := x86AbsSignIndependentFeatures(row.bits, row.width, row.legacy, evex)
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); got != want {
+					t.Fatal("isolated complete original ISA profile borrowed a sibling, lost a carrier or added AVX512 to a lesser form", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedAbsSignLowBankPhysicalGenerationISAProfiles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for bitsIndex, suffix := range []string{"B", "W", "D", "Q"} {
+			for _, evex := range []bool{false, true} {
+				if bitsIndex == 3 && !evex {
+					continue
+				}
+				for width, bank := range []string{"X", "Y", "Z"} {
+					if width == 2 && !evex {
+						continue
+					}
+					for _, memory := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/VPABS%s/%s/EVEX=%t/memory=%t", arch, suffix, bank, evex, memory), func(t *testing.T) {
+							modrm := byte(0xd0) // destination2, source0 or (AX).
+							if memory {
+								modrm = 0x10
+							}
+							code := []byte{0xc4, 0xe2, 0x79 | byte(width)<<2, 0x1c + byte(bitsIndex), modrm}
+							if evex {
+								p1 := byte(0x7d)
+								if bitsIndex == 3 {
+									p1 |= 0x80
+								}
+								code = []byte{0x62, 0xf2, p1, 0x08 | byte(width)<<5, 0x1c + byte(bitsIndex), modrm}
+							}
+							ins := x86RawMoveObservedInstruction(t, arch, code)
+							want := x86AbsSignIndependentFeatures(8<<bitsIndex, 16<<width, false, evex)
+							if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); got != want {
+								t.Fatal("low-bank unmasked physical EVEX cannot be inferred from a VEX-looking named operand list", got, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAbsSignISAProfilesRejectMalformedOrForeignGeneration(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, instruction := range []string{"PABSB Y0,X1", "PSIGND X0,Y1", "VPABSB X0,Y1", "VPABSW.Z X0,X1", "VPSIGNB Z0,Z1,Z2", "VPABSQ X0,K0,X1"} {
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}); got != "" {
+				t.Fatal("malformed ABS/sign form acquired an ISA profile", instruction, got)
+			}
+		}
+		for _, instruction := range []string{"PABSB X0,X1", "PSIGNW X0,X1", "VPSIGND X0,X1,X2"} {
+			ins := x86ScalarLaneInstruction(t, instruction)
+			ins.x86PackedAbsEVEX = true
+			if _, known, err := x86PackedAbsSignProperties(ins.Op, ins, arch); !known || err == nil ||
+				inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}) != "" {
+				t.Fatal("a foreign physical EVEX tag created an unsupported generation", instruction, err)
+			}
+		}
+	}
+}
+
+// No MOVOU, AVX zero or other sibling supplies a native XMM register class.
+// PSIGN's data is initialized by its existing pure self-XOR transfer; PABS
+// has no old destination input. These are actual Go/LLVM native objects.
+func TestX86PackedAbsSignMinimalLegacyNativeCarrierObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("isolated native ABS/sign carriers require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			move, word := "MOVQ", goWordSize(target.arch)
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			for index, row := range x86AbsSignAlignmentRows()[:6] {
+				fmt.Fprintf(&source, "TEXT ·Isolated%d(SB),4,$0-%d\n%s input+0(FP),BX\n", index, word, move)
+				if row.sign {
+					source.WriteString("PXOR X0,X0\n")
+				}
+				source.WriteString(row.instruction() + "\nRET\n")
+				fmt.Fprintf(&declarations, "func Isolated%d(input *byte)\n", index)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("isolated complete native family lost actual pointer/data inputs", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "isolated-abs-sign.ll", "isolated-abs-sign.o", body)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_packed_abs_sign_go127_test.go b/x86_packed_abs_sign_go127_test.go
new file mode 100644
index 000000000..25b256523
--- /dev/null
+++ b/x86_packed_abs_sign_go127_test.go
@@ -0,0 +1,105 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedAbsSignCompleteOfficialGoRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxm_q4 = []ytab{\n\t{Zm_r, 1, argList{Yxm, Yxr}},\n}") {
+		t.Fatal("Go's legacy ABS/sign class must not acquire Intel's separate MMX encodings")
+	}
+	for index, suffix := range []string{"B", "W", "D"} {
+		for _, spec := range []struct {
+			stem string
+			code int
+		}{{"PABS", 0x1c}, {"PSIGN", 8}} {
+			entry := fmt.Sprintf("{A%s%s, yxm_q4, Pq4, opBytes{0x%02x}}", spec.stem, suffix, spec.code+index)
+			if !strings.Contains(string(legacy), entry) {
+				t.Fatal("complete legacy prefix/opcode/operand row changed", entry)
+			}
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if !strings.HasPrefix(rule.Opcode, "VPABS") && !strings.HasPrefix(rule.Opcode, "VPSIGN") {
+			continue
+		}
+		sign, quad := strings.HasPrefix(rule.Opcode, "VPSIGN"), rule.Opcode == "VPABSQ"
+		index := strings.Index("BWDQ", rule.Opcode[len(rule.Opcode)-1:])
+		if index < 0 || sign && index == 3 {
+			t.Fatal("official ABS/sign mnemonic inventory expanded", rule.Opcode)
+		}
+		opcode, table := 0x1c+index, "_yvmovddup"
+		if sign {
+			opcode, table = 8+index, "_yvaddsubpd"
+		} else if quad {
+			table = "_yvexpandpd"
+		}
+		var bytes []string
+		if !quad {
+			for _, width := range []string{"vex128", "vex256"} {
+				bytes = append(bytes, "avxEscape | "+width+" | vex66 | vex0F38 | vexW0", fmt.Sprintf("0x%02X", opcode))
+			}
+		}
+		if !sign {
+			for at, width := range []string{"evex128", "evex256", "evex512"} {
+				w, attributes := "evexW0", fmt.Sprintf("evexN%d", 16<<at)
+				if quad {
+					w = "evexW1"
+				}
+				if index >= 2 {
+					attributes += fmt.Sprintf(" | evexBcstN%d", 1<<index)
+				}
+				bytes = append(bytes, "avxEscape | "+width+" | evex66 | evex0F38 | "+w,
+					attributes+" | evexZeroingEnabled", fmt.Sprintf("0x%02X", opcode))
+			}
+		}
+		ordinal, offset, zoffset, zcase := rule.RowIndex, rule.RowIndex*2, 2, "Zvex_rm_v_r"
+		var classes []string
+		if !quad && ordinal < 2 {
+			classes = [][]string{{"Yxm", "Yxr"}, {"Yym", "Yyr"}}[ordinal]
+			if sign {
+				classes = append(classes, classes[1])
+			}
+		} else {
+			if !quad {
+				ordinal -= 2
+			}
+			offset, zoffset, zcase = ordinal/2*3, 0, "Zevex_rm_v_r"
+			if !quad {
+				offset += 4
+			}
+			classes = append([]string(nil), [][]string{{"YxmEvex", "YxrEvex"}, {"YymEvex", "YyrEvex"}, {"Yzm", "Yzr"}}[ordinal/2]...)
+			if ordinal%2 != 0 {
+				classes, zoffset, zcase = []string{classes[0], "Yknot0", classes[1]}, 3, "Zevex_rm_k_r"
+			}
+		}
+		if rule.Ytab != table || rule.Prefix != "Pavx" || !reflect.DeepEqual(rule.OpBytes, bytes) ||
+			rule.EncodingOffset != offset || rule.ZOffset != zoffset || rule.ZCase != zcase || !reflect.DeepEqual(rule.Classes, classes) {
+			t.Fatal("complete official ABS/sign operand/encoding/tuple/broadcast/zeroing row changed", rule, classes, bytes)
+		}
+		counts[rule.Opcode]++
+	}
+	want := map[string]int{"VPABSB": 8, "VPABSW": 8, "VPABSD": 8, "VPABSQ": 6, "VPSIGNB": 2, "VPSIGNW": 2, "VPSIGND": 2}
+	if !reflect.DeepEqual(counts, want) {
+		t.Fatal("complete 36 AVX plus six legacy row denominator changed", counts)
+	}
+}
diff --git a/x86_packed_abs_sign_native_backend_test.go b/x86_packed_abs_sign_native_backend_test.go
new file mode 100644
index 000000000..25058690f
--- /dev/null
+++ b/x86_packed_abs_sign_native_backend_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"encoding/hex"
+	"fmt"
+	"regexp"
+	"sort"
+	"strings"
+	"testing"
+)
+
+// This bounded contract observes the original runtime's actual LLVM object,
+// not the stock-Go KMOVQ spelling. The Intel SDM PABS/PSIGN tables distinguish
+// SSSE3, VEX AVX/AVX2, and EVEX F/VL from the independent BW/DQ families.
+func x86PackedAbsSignRuntimeOpcodeWithinProfile(op string, code []byte) bool {
+	if len(code) == 0 {
+		return false
+	}
+	if code[0] == 0x62 {
+		if strings.HasPrefix(op, "vfm") || strings.HasPrefix(op, "vfnm") {
+			return false
+		}
+		if x86OriginalFloatingEVEXWithinProfile("fma-caller", op, code) {
+			return true
+		}
+		if len(code) < 6 || code[3]>>5&3 == 3 {
+			return false
+		}
+		// SDM Table 5-19 names all eight VPCMP predicates. Objdump may
+		// print the pseudo-op instead of the identical D/Q instruction plus
+		// its immediate. Byte/word aliases still require independent BW.
+		for _, suffix := range []string{"d", "q", "ud", "uq"} {
+			for _, predicate := range []string{"eq", "lt", "le", "false", "neq", "nlt", "nle", "true"} {
+				if op == "vpcmp"+predicate+suffix {
+					op = "vpcmp" + suffix
+				}
+			}
+		}
+		for _, member := range strings.Fields(`
+vpabsd vpabsq vpaddd vpaddq vpsubd vpsubq
+vpmovsxbd vpmovsxbq vpmovsxwd vpmovsxwq vpmovsxdq
+vpmovzxbd vpmovzxbq vpmovzxwd vpmovzxwq vpmovzxdq
+vpcmpd vpcmpq vpcmpud vpcmpuq vpcmpeqd vpcmpeqq vpcmpgtd vpcmpgtq
+vpblendmd vpblendmq vpbroadcastd vpbroadcastq vptestmd vptestmq vptestnmd vptestnmq`) {
+			if op == member {
+				return true
+			}
+		}
+		return false
+	}
+	if strings.HasPrefix(op, "k") {
+		return x86OriginalFloatingFMaskOpcode(op)
+	}
+	if code[0] == 0xc4 || code[0] == 0xc5 {
+		for _, member := range strings.Fields(`
+vzeroupper vmovaps vmovapd vmovups vmovupd vmovdqa vmovdqu vmovd vmovq vmovss vmovsd
+vpxor vpand vpandn vpor vxorps vxorpd vandps vandpd vandnps vandnpd vorps vorpd
+vpabsb vpabsw vpabsd vpsignb vpsignw vpsignd
+vpaddb vpaddw vpaddd vpaddq vpsubb vpsubw vpsubd vpsubq
+vpcmpeqb vpcmpeqw vpcmpeqd vpcmpeqq vpcmpgtb vpcmpgtw vpcmpgtd vpcmpgtq
+vpblendvb vpblendw vpblendd vblendps vblendpd vblendvps vblendvpd
+vpshufb vpshufd vpshufhw vpshuflw vshufps vshufpd vpermq vpermd vperm2i128 vperm2f128
+vpsllw vpslld vpsllq vpsrlw vpsrld vpsrlq vpsraw vpsrad vpslldq vpsrldq
+vpsllvd vpsllvq vpsrlvd vpsrlvq vpsravd
+vpbroadcastb vpbroadcastw vpbroadcastd vpbroadcastq vbroadcastss vbroadcastsd
+vextracti128 vextractf128 vinserti128 vinsertf128
+vpextrb vpextrw vpextrd vpextrq vpinsrb vpinsrw vpinsrd vpinsrq
+vpunpcklbw vpunpcklwd vpunpckldq vpunpcklqdq vpunpckhbw vpunpckhwd vpunpckhdq vpunpckhqdq
+vpmovmskb vpmovzxbw vpmovzxbd vpmovzxbq vpmovzxwd vpmovzxwq vpmovzxdq
+vpmovsxbw vpmovsxbd vpmovsxbq vpmovsxwd vpmovsxwq vpmovsxdq
+vpacksswb vpackssdw vpackuswb vpackusdw vptest`) {
+			if op == member {
+				return true
+			}
+		}
+		return false
+	}
+	return !strings.HasPrefix(op, "v")
+}
+
+func TestX86PackedAbsSignRuntimeISAProfileAliases(t *testing.T) {
+	// These are profile field projections, not valid-encoding certificates.
+	// The complete actual three-target object matrix below independently
+	// observes both full bytes and each mnemonic through LLVM22 objdump.
+	evex := []byte{0x62, 0xf3, 0x75, 0x28, 0x1f, 0xc2, 1}
+	for _, suffix := range []string{"d", "q", "ud", "uq", "b", "w", "ub", "uw"} {
+		for _, predicate := range []string{"eq", "lt", "le", "false", "neq", "nlt", "nle", "true"} {
+			op := "vpcmp" + predicate + suffix
+			t.Run(op, func(t *testing.T) {
+				want := suffix == "d" || suffix == "q" || suffix == "ud" || suffix == "uq"
+				if x86PackedAbsSignRuntimeOpcodeWithinProfile(op, evex) != want {
+					t.Fatal("VPCMP predicate alias changed its D/Q F/VL versus byte/word BW requirement", op)
+				}
+			})
+		}
+	}
+	for _, op := range []string{"vpextrb", "vpextrw", "vpextrd", "vpextrq", "vpinsrb", "vpinsrw", "vpinsrd", "vpinsrq"} {
+		t.Run(op, func(t *testing.T) {
+			if !x86PackedAbsSignRuntimeOpcodeWithinProfile(op, []byte{0xc4, 0xe3, 0x79, 0x16, 0xc8, 1}) ||
+				x86PackedAbsSignRuntimeOpcodeWithinProfile(op, evex) {
+				t.Fatal("VEX GP lane transport borrowed its separate EVEX BW/DQ encoding", op)
+			}
+		})
+	}
+}
+
+func TestX86PackedAbsSignRuntimeISAExtensionFamily(t *testing.T) {
+	// LLVM 22's avx512_pmovx_{bd,bq,wd,wq,dq} use F, plus VL for
+	// X/Y destinations. Only bw needs BW; the input element width alone
+	// does not imply that feature. Keep signed and unsigned extensions.
+	// https://github.com/llvm/llvm-project/blob/llvmorg-22.1.8/llvm/lib/Target/X86/X86InstrAVX512.td
+	type witness struct {
+		source, opcode string
+		withinProfile  bool
+	}
+	var cases []witness
+	var source strings.Builder
+	for _, sign := range []string{"S", "Z"} {
+		for _, ratio := range []string{"BW", "BD", "BQ", "WD", "WQ", "DQ"} {
+			op := "VPMOV" + sign + "X" + ratio
+			for _, bank := range []string{"X", "Y", "Z"} {
+				input := "X0"
+				if bank == "Z" && (ratio == "BW" || ratio == "WD" || ratio == "DQ") {
+					input = "Y0"
+				}
+				for _, operand := range []string{input, "8(AX)"} {
+					for _, mask := range []string{"", "merge", "zero"} {
+						name, args := op, operand
+						if mask != "" {
+							args += ",K3"
+						}
+						if mask == "zero" {
+							name += ".Z"
+						}
+						// High destinations select actual EVEX even without a mask.
+						row := name + " " + args + "," + bank + "16"
+						cases = append(cases, witness{row, strings.ToLower(op), ratio != "BW"})
+						fmt.Fprintln(&source, row)
+					}
+				}
+			}
+		}
+	}
+	if len(cases) != 216 {
+		t.Fatal("extension family inventory changed", len(cases))
+	}
+	source.WriteString("RET\n")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String())
+	if len(pcs) != len(cases)+1 || code[pcs[len(cases)]] != 0xc3 {
+		t.Fatal("original Go object lost its complete extension inventory")
+	}
+	x86NumericalNativeRequireMC(t, code, 64, len(pcs), "+avx512f,+avx512vl,+avx512bw")
+	for index, row := range cases {
+		t.Run(row.source, func(t *testing.T) {
+			encoded := code[pcs[index]:pcs[index+1]]
+			if len(encoded) < 6 || encoded[0] != 0x62 {
+				t.Fatal("original source did not select complete EVEX", encoded)
+			}
+			if got := x86PackedAbsSignRuntimeOpcodeWithinProfile(row.opcode, encoded); got != row.withinProfile {
+				t.Fatalf("actual extension changed its F/VL versus BW requirement: %x: got %t", encoded, got)
+			}
+		})
+	}
+}
+
+func TestX86PackedAbsSignOriginalRuntimeActualBackendISA(t *testing.T) {
+	source := x86PackedAbsSignOriginalRuntimeSource(t)
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("actual original ABS/sign ISA requires LLVM22 llc and llvm-objdump")
+	}
+	for _, op := range []string{"kmovb", "kmovq", "vpmovm2q", "vpmullq", "vpabsb", "vpabsw", "vmovdqu8", "vmovdqu16", "vpsllw", "vfmadd132ps", "vfmadd132ph"} {
+		if x86PackedAbsSignRuntimeOpcodeWithinProfile(op, []byte{0x62, 0xf1, 0x7c, 0x48, 0x10, 0xc0}) {
+			t.Fatal("original ABS/sign borrowed an independent BW, DQ, FMA or FP16 opcode", op)
+		}
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			frame := FrameLayout{Params: []FrameSlot{
+				{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1},
+				{Offset: 16, Type: Ptr, Index: 2, Field: -1}, {Offset: 24, Type: Ptr, Index: 3, Field: -1},
+				{Offset: 32, Type: I64, Index: 4, Field: -1},
+			}}
+			ir, err := Translate(file, Options{TargetTriple: triple, Goarch: "amd64", Sigs: map[string]FuncSig{
+				"packedabssign": {Name: "packedabssign", Args: []LLVMType{Ptr, Ptr, Ptr, Ptr, I64}, Ret: Void, Frame: frame},
+			}})
+			if err != nil || ir == "" {
+				t.Fatal("complete original initialized ABS/sign source rejected before ISA observation", err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"O0", "-O0", ir}, {"O2", "-O2", ir}, {"IR_O2_backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					listing := x86FourSourceNativeObjectListing(t, llc, objdump, triple, pipeline.level, pipeline.ir)
+					rows := regexp.MustCompile(`(?m)^\s*[0-9a-f]+:\s+((?:[0-9a-f]{2}\s+)+)([a-z][a-z0-9.]*)`).FindAllStringSubmatch(listing, -1)
+					if len(rows) == 0 || strings.Contains(listing, "<unknown>") || strings.Contains(listing, "invalid") ||
+						len(regexp.MustCompile(`(?m)^[0-9a-f]+ <_?packedabssign>:`).FindAllString(listing, -1)) != 1 ||
+						len(regexp.MustCompile(`\bpsignw\s+[^\n,]*\(`).FindAllString(listing, -1)) != 1 {
+						t.Fatal("original object lost its owned complete function or native Type4 PSIGNW memory operation", listing)
+					}
+					seen, violations := make(map[string]bool), []string{}
+					for _, row := range rows {
+						seen[row[2]] = true
+						code, err := hex.DecodeString(strings.Join(strings.Fields(row[1]), ""))
+						if err != nil || !x86PackedAbsSignRuntimeOpcodeWithinProfile(row[2], code) {
+							violations = append(violations, row[0])
+						}
+					}
+					var inventory []string
+					for op := range seen {
+						inventory = append(inventory, op)
+					}
+					sort.Strings(inventory)
+					t.Logf("actual %s %s original ABS/sign opcodes: %s; objects are not CPU execution", triple, pipeline.name, strings.Join(inventory, ","))
+					if len(violations) != 0 {
+						t.Fatalf("actual ABS/sign object exceeds SSSE3/AVX2/F/VL (no BW/DQ/FMA):\n%s", strings.Join(violations, "\n"))
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_packed_abs_sign_native_preflight_policy_test.go b/x86_packed_abs_sign_native_preflight_policy_test.go
new file mode 100644
index 000000000..0be4b79d1
--- /dev/null
+++ b/x86_packed_abs_sign_native_preflight_policy_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PackedAbsSignOriginalRuntimeSource(t *testing.T) string {
+	t.Helper()
+	data, file, _ := x86OriginalFloatingPolicyFile(t, "amd64_lower_abs_sign_test.go")
+	hashes, err := x86PackedAbsSignOriginalPayloadHashes(data)
+	if err != nil || hashes["source"] != "2c3660ebcce2c3d76fcc556f987f5cddd480557965ad4005c41ef6f4749f9218" ||
+		hashes["mainC"] != "b2867b9896c8afaab063d25ab65aeff74bd4ffa3645791febac92ec62fd19c60" {
+		t.Fatal("complete original ABS/sign ASM, C inputs or observations changed", err)
+	}
+	owner := x86OriginalFloatingPolicyFunction(t, file, "TestAMD64PackedAbsSignRuntimeSemantics")
+	var source string
+	ast.Inspect(owner.Body, func(node ast.Node) bool {
+		assignment, ok := node.(*ast.AssignStmt)
+		if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+			return true
+		}
+		name, ok := assignment.Lhs[0].(*ast.Ident)
+		if !ok || name.Name != "source" {
+			return true
+		}
+		literal, ok := assignment.Rhs[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING || source != "" {
+			t.Fatal("original ABS/sign source lost its unique literal")
+		}
+		source, err = strconv.Unquote(literal.Value)
+		return false
+	})
+	if err != nil || source == "" {
+		t.Fatal("complete original ABS/sign source disappeared", err)
+	}
+	return source
+}
+
+func TestX86PackedAbsSignOriginalRuntimeOwnsAllocationPreflight(t *testing.T) {
+	x86PackedAbsSignOriginalRuntimeSource(t)
+	_, file, set := x86OriginalFloatingPolicyFile(t, "amd64_lower_abs_sign_test.go")
+	owner := x86OriginalFloatingPolicyFunction(t, file, "TestAMD64PackedAbsSignRuntimeSemantics")
+	var calls []*ast.CallExpr
+	boundary := owner.End()
+	ast.Inspect(owner.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		name, ok := call.Fun.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if name.Name == "x86OriginalFloatingRuntimeRequireCPU" {
+			calls = append(calls, call)
+		}
+		if name.Name == "compileAndRunRuntimeTestForTarget" && call.Pos() < boundary {
+			boundary = call.Pos()
+		}
+		return true
+	})
+	if len(calls) != 1 || boundary == owner.End() || calls[0].End() >= boundary {
+		t.Fatal("original ABS/sign runtime needs its own actual-allocation preflight before execution")
+	}
+	topLevel := false
+	for _, statement := range owner.Body.List {
+		if expression, ok := statement.(*ast.ExprStmt); ok && expression.X == calls[0] {
+			topLevel = true
+		}
+	}
+	if !topLevel {
+		t.Fatal("ABS/sign CPU proof cannot be conditional, deferred or borrowed from another owner")
+	}
+	var actual bytes.Buffer
+	if err := format.Node(&actual, set, calls[0]); err != nil {
+		t.Fatal(err)
+	}
+	const want = `x86OriginalFloatingRuntimeRequireCPU(t, "packed-abs-sign", clang, triple, runPrefix)`
+	if actual.String() != want {
+		t.Fatal("ABS/sign preflight changed the actual compiler, profile, target or execution route", actual.String())
+	}
+}
+
+func TestX86PackedAbsSignOriginalRuntimeCompleteOpcodeProfile(t *testing.T) {
+	_, file, _ := x86OriginalFloatingPolicyFile(t, "x86_original_floating_runtime_preflight_test.go")
+	driver := x86OriginalFloatingPolicyFunction(t, file, "x86OriginalFloatingRuntimeRequireCPU")
+	profiles := 0
+	ast.Inspect(driver.Body, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok || len(clause.List) != 1 {
+			return true
+		}
+		literal, ok := clause.List[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING {
+			return true
+		}
+		name, err := strconv.Unquote(literal.Value)
+		if err != nil || name != "packed-abs-sign" {
+			return true
+		}
+		profiles++
+		var body bytes.Buffer
+		for _, statement := range clause.Body {
+			if err := format.Node(&body, token.NewFileSet(), statement); err != nil {
+				t.Fatal(err)
+			}
+		}
+		if strings.Join(strings.Fields(body.String()), "") != "required=4" {
+			t.Fatal("ABS/sign preflight borrowed another owner's capability profile", body.String())
+		}
+		return true
+	})
+	if profiles != 1 {
+		t.Fatal("independent original ABS/sign execution profile missing or duplicated", profiles)
+	}
+	state, opcodes := x86OriginalFloatingPolicyDriver(t)
+	const opening = "__attribute__((target(\"ssse3,avx2,avx512f,avx512vl\")))\nstatic int original_packed_abs_sign(void) {"
+	start := strings.Index(opcodes, opening)
+	if start < 0 || strings.Count(opcodes, "static int original_packed_abs_sign(void)") != 1 {
+		t.Fatal("complete ABS/sign probe requires its own minimum-ISA target function")
+	}
+	rest := opcodes[start+len(opening):]
+	end := strings.Index(rest, "\n}\n")
+	if end < 0 {
+		t.Fatal("complete ABS/sign original-opcode probe disappeared")
+	}
+	probe := rest[:end]
+	for _, opcode := range []string{"psignw ", "vpsignd ", "vpabsd ", "vpabsq ", "kmovw ", "vmovdqu64 ", "%{%%k1%}", "%{z%}"} {
+		if !strings.Contains(probe, opcode) {
+			t.Fatal("ABS/sign probe lost legacy alignment, Y/Z, opmask or result observation", opcode)
+		}
+	}
+	for _, forbidden := range []string{"avx512bw", "avx512dq", "fma", "kmovq "} {
+		if strings.Contains(probe, forbidden) {
+			t.Fatal("ABS/sign probe introduced an independently unnecessary native ISA", forbidden)
+		}
+	}
+	mainStart := strings.LastIndex(opcodes, "int main(void)")
+	if mainStart < 0 {
+		t.Fatal("actual ABS/sign allocation preflight main is missing")
+	}
+	main := opcodes[mainStart:]
+	guard := strings.Index(main, "if (!original_floating_required_state(")
+	legacyGuard := strings.Index(main, "if (profile==4 && !original_packed_abs_sign_required_legacy(ssse3,avx2)) return 78;")
+	call := strings.Index(main, "if (profile==4 && !original_packed_abs_sign()) return 82;")
+	if guard < 0 || legacyGuard <= guard || call <= legacyGuard {
+		t.Fatal("ABS/sign original opcodes must follow actual base and legacy CPUID/XCR0 checks")
+	}
+	for _, fact := range []string{"ssse3=(c>>9)&1", "avx2=(b>>5)&1", "SSSE3=%u", "AVX2=%u"} {
+		if !strings.Contains(main, fact) {
+			t.Fatal("ABS/sign actual-allocation receipt lost a genuine native prerequisite", fact)
+		}
+	}
+	if !strings.Contains(state, "static int original_packed_abs_sign_required_legacy(") {
+		t.Fatal("ABS/sign legacy feature predicate is missing")
+	}
+	_, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 clang required for the independent pure capability boundary")
+	}
+	// These rows run the actual pure predicates on the current host. They do
+	// not execute a native probe or certify the original x86 runtime.
+	const checks = `
+int main(void) {
+    for(unsigned flags=0;flags<128;flags++) for(unsigned bits=0;bits<32;bits++) {
+        unsigned sse2=flags&1,avx=(flags>>1)&1,os=(flags>>2)&1,f=(flags>>3)&1;
+        unsigned vl=(flags>>4)&1,ssse3=(flags>>5)&1,avx2=(flags>>6)&1;
+        const unsigned positions[]={1,2,5,6,7}; uint64_t xcr0=0;
+        for(unsigned i=0;i<5;i++) if(bits&(1u<<i)) xcr0|=UINT64_C(1)<<positions[i];
+        for(unsigned fma=0;fma<2;fma++) {
+            int actual=original_floating_required_state(4,sse2,avx,os,f,vl,fma,xcr0)&&
+                       original_packed_abs_sign_required_legacy(ssse3,avx2);
+            if(actual!=(sse2&&avx&&os&&f&&vl&&ssse3&&avx2&&bits==31)) return 1;
+        }
+    }
+    return 0;
+}
+`
+	directory := t.TempDir()
+	source, executable := filepath.Join(directory, "abs-capability.c"), filepath.Join(directory, "abs-capability")
+	if err := os.WriteFile(source, []byte(state+checks), 0600); err != nil {
+		t.Fatal(err)
+	}
+	execution := x86FloatCompareExecution{triple: testTargetTriple(runtime.GOOS, runtime.GOARCH), compiler: []string{clang}}
+	execution.compileC(t, source, executable)
+	execution.run(t, executable)
+	t.Logf("independent pure ABS/sign prerequisite rows: %d; native execution remains separate", 128*32*2)
+}
diff --git a/x86_packed_abs_sign_original_payload_test.go b/x86_packed_abs_sign_original_payload_test.go
new file mode 100644
index 000000000..a7306d61a
--- /dev/null
+++ b/x86_packed_abs_sign_original_payload_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"testing"
+)
+
+// Executable payloads have their own immutable boundary, independently of the
+// enclosing driver hash. The C literal includes every input and observation.
+func x86PackedAbsSignOriginalPayloadHashes(data []byte) (map[string]string, error) {
+	file, err := parser.ParseFile(token.NewFileSet(), "original-abs-sign.go", data, 0)
+	if err != nil {
+		return nil, err
+	}
+	hashes := make(map[string]string)
+	functions := 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "qualifyAMD64PackedAbsSignRuntimeSemantics" {
+			continue
+		}
+		functions++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || assignment.Tok != token.DEFINE || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			if !ok || name.Name != "source" && name.Name != "mainC" {
+				return true
+			}
+			literal, ok := assignment.Rhs[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING || hashes[name.Name] != "" {
+				err = fmt.Errorf("original ABS/sign payload lost its single literal: %s", name.Name)
+				return false
+			}
+			value, unquoteErr := strconv.Unquote(literal.Value)
+			if unquoteErr != nil {
+				err = unquoteErr
+				return false
+			}
+			hashes[name.Name] = fmt.Sprintf("%x", sha256.Sum256([]byte(value)))
+			return false
+		})
+	}
+	if err != nil {
+		return nil, err
+	}
+	if functions != 1 || len(hashes) != 2 {
+		return nil, fmt.Errorf("original ABS/sign runtime function or complete payload is absent")
+	}
+	return hashes, nil
+}
+
+func TestX86PackedAbsSignOriginalExecutablePayloadIdentity(t *testing.T) {
+	data, err := os.ReadFile("amd64_lower_abs_sign_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"source": "2c3660ebcce2c3d76fcc556f987f5cddd480557965ad4005c41ef6f4749f9218",
+		"mainC":  "b2867b9896c8afaab063d25ab65aeff74bd4ffa3645791febac92ec62fd19c60",
+	}
+	for _, mutation := range []struct{ name, from, to, changed string }{
+		{"original", "", "", ""},
+		{"assembly", "PABSB X0, X0", "PABSW X0, X0", "source"},
+		{"C-input", "i * 29 + 0x80", "i * 31 + 0x80", "mainC"},
+		{"C-observation", "gotAbs64[i] != want", "gotAbs64[i] == want", "mainC"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			changed := data
+			if mutation.changed != "" {
+				changed = bytes.Replace(data, []byte(mutation.from), []byte(mutation.to), 1)
+				if bytes.Equal(changed, data) {
+					t.Fatal("payload mutation was not applied")
+				}
+			}
+			hashes, err := x86PackedAbsSignOriginalPayloadHashes(changed)
+			if err != nil {
+				t.Fatal("payload mutation lost the complete parseable original driver", err)
+			}
+			for role, hash := range want {
+				if (hashes[role] != hash) != (role == mutation.changed) {
+					t.Fatal("independent original ASM/C boundary was lost", role, mutation.changed)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_packed_abs_sign_physical_tdd_test.go b/x86_packed_abs_sign_physical_tdd_test.go
new file mode 100644
index 000000000..449140da1
--- /dev/null
+++ b/x86_packed_abs_sign_physical_tdd_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Intel's complete SIGN encoding table is VEX.128/256.66.0F38.WIG.
+// Go emits W0. A different ignored W bit must not turn valid physical bytes
+// into syntax rejection; neither encoding establishes initialized data/entry.
+func TestX86PackedSignPhysicalWIGKeepsCompleteGoOperandIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		var source strings.Builder
+		var expected []byte
+		source.WriteString("TEXT SignWIG(SB),4,$0-0\n")
+		for index, op := range []string{"VPSIGNB", "VPSIGNW", "VPSIGND"} {
+			for width, bank := range []string{"X", "Y"} {
+				for _, memory := range []bool{false, true} {
+					operand, modrm := bank+"0", byte(0xd0)
+					if memory {
+						operand, modrm = "(AX)", 0x10
+					}
+					fmt.Fprintf(&source, "%s %s,%s1,%s2\n", op, operand, bank, bank)
+					control := byte(0x71 | width<<2) // logical vvvv=1, 66, no extension bits.
+					canonical := []byte{0xc4, 0xe2, control, byte(8 + index), modrm}
+					expected = append(expected, canonical...)
+					for _, w := range []byte{0, 0x80} {
+						code := append([]byte(nil), canonical...)
+						code[2] |= w
+						ins, length, known, err := decodedX86RawPackedSignInstruction(code, mode)
+						if !known || err != nil || length != len(code) || ins.Op != Op(op) || len(ins.Args) != 3 ||
+							ins.Args[1].Reg != Reg(bank+"1") || ins.Args[2].Reg != Reg(bank+"2") ||
+							(ins.Args[0].Kind == OpMem) != memory || !memory && ins.Args[0].Reg != Reg(bank+"0") {
+							t.Fatal("complete physical SIGN WIG class lost actual mode/data/control/destination identity", arch, op, bank, memory, w, ins, err)
+						}
+					}
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		expected = append(expected, 0xc3)
+		if actual := assembleX87ControlBytes(t, arch, source.String()); !bytes.Equal(actual, expected) {
+			t.Fatalf("independent complete Go W0 SIGN bytes differ from physical witness: %s got=%x want=%x", arch, actual, expected)
+		}
+	}
+}
+
+func TestX86PackedAbsPhysicalVEXWIGAndFixedEVEXWidth(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		var source strings.Builder
+		var expected []byte
+		source.WriteString("TEXT AbsWIG(SB),4,$0-0\n")
+		for index, op := range []string{"VPABSB", "VPABSW", "VPABSD"} {
+			for width, bank := range []string{"X", "Y"} {
+				for _, memory := range []bool{false, true} {
+					operand, modrm := bank+"0", byte(0xd0)
+					if memory {
+						operand, modrm = "(AX)", 0x10
+					}
+					fmt.Fprintf(&source, "%s %s,%s2\n", op, operand, bank)
+					canonical := []byte{0xc4, 0xe2, byte(0x79 | width<<2), byte(0x1c + index), modrm}
+					expected = append(expected, canonical...)
+					for _, w := range []byte{0, 0x80} {
+						code := append([]byte(nil), canonical...)
+						code[2] |= w
+						ins, length, known, err := decodedX86RawPackedAbsInstruction(code, mode)
+						if !known || err != nil || length != len(code) || ins.Op != Op(op) || len(ins.Args) != 2 ||
+							ins.Args[1].Reg != Reg(bank+"2") || (ins.Args[0].Kind == OpMem) != memory ||
+							!memory && ins.Args[0].Reg != Reg(bank+"0") {
+							t.Fatal("VEX ABS WIG lost complete operand identity", arch, op, bank, memory, w, ins, err)
+						}
+					}
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		expected = append(expected, 0xc3)
+		if actual := assembleX87ControlBytes(t, arch, source.String()); !bytes.Equal(actual, expected) {
+			t.Fatalf("independent complete Go W0 ABS witness differs: %s got=%x want=%x", arch, actual, expected)
+		}
+		for index := 0; index < 4; index++ {
+			code := encodeX86RawPackedAbs(index, 64, 1, 2, 0, false, false)
+			if _, _, known, err := decodedX86RawPackedAbsInstruction(code, mode); !known || err != nil {
+				t.Fatal("canonical EVEX ABS W0/W1 rejected", index, arch, err)
+			}
+			code[2] ^= 0x80
+			if _, _, known, err := decodedX86RawPackedAbsInstruction(code, mode); !known || err == nil {
+				t.Fatal("VEX WIG rule incorrectly widened fixed EVEX W", index, arch)
+			}
+		}
+	}
+}
+
+func TestX86PackedAbsSignTypedGrammarRejectsNonGoForms(t *testing.T) {
+	for _, line := range []string{
+		"PABSQ X0,X1", "PABSB M0,M1", "PSIGNW M0,M1", "PABSD.Z X0,X1",
+		"VPABSB.BCST (AX),X1", "VPABSW.BCST (AX),Y1", "VPABSQ.BCST X0,X1",
+		"VPABSD X0,Y1", "VPABSQ X0,K0,X1", "VPABSB.Z X0,X1",
+		"VPSIGNB Z0,Z1,Z2", "VPSIGND X0,K1,X1", "VPSIGNW.Z X0,X1,X2", "VPSIGND.BCST (AX),X1,X2",
+	} {
+		t.Run(strings.ReplaceAll(line, " ", "_"), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, line)
+			_, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			wantKnown := !strings.HasPrefix(line, "PABSQ ") // No legacy qword ABS opcode exists.
+			if known != wantKnown || known && err == nil {
+				t.Fatal("known ABS/sign family lacks a closed typed syntax boundary", line, known, err)
+			}
+		})
+	}
+}
diff --git a/x86_packed_abs_sign_portable_projection_test.go b/x86_packed_abs_sign_portable_projection_test.go
new file mode 100644
index 000000000..a208c0c24
--- /dev/null
+++ b/x86_packed_abs_sign_portable_projection_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This private mathematical driver accepts only the complete generated kernels,
+// including every original input/output/FLAGS transport. It removes ISA choices,
+// never operations. The separate original-native/alignment owners are unchanged.
+func x86PackedAbsSignPortableIR(source, ir, arch string) (string, error) {
+	if arch != "386" && arch != "amd64" {
+		return "", fmt.Errorf("portable ABS/sign source has an unknown x86 mode")
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) == 0 {
+		return "", fmt.Errorf("portable ABS/sign source has no complete kernels: %v", err)
+	}
+	rows := x86PackedAbsSignOracleRows()
+	profiles := make(map[string]string)
+	var expected strings.Builder
+	for _, function := range file.Funcs {
+		name := strings.TrimPrefix(function.Sym, "·")
+		index, err := strconv.Atoi(strings.TrimPrefix(name, "AbsSign"))
+		if err != nil || index < 0 || index >= len(rows) || name != fmt.Sprint("AbsSign", index) {
+			return "", fmt.Errorf("portable ABS/sign source has an unobserved kernel: %s", name)
+		}
+		if _, duplicate := profiles[name]; duplicate {
+			return "", fmt.Errorf("portable ABS/sign source repeats a kernel: %s", name)
+		}
+		row := rows[index]
+		body, _ := x86PackedAbsSignInitializedSource(index, row, arch)
+		if row.legacy && row.memory {
+			base := "AX"
+			if row.sign {
+				base = "BX"
+			}
+			// These fixtures use only banks 0..2. Their existing, independently
+			// checked legacy-memory instrumentation selects unused X3 exactly.
+			replacement := fmt.Sprintf("VMOVDQU 0(%s),X3\n%s X3,X2", base, row.op)
+			body = strings.Replace(body, row.instruction(), replacement, 1)
+		}
+		expected.WriteString(body)
+		profiles[name] = inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, function)
+	}
+	if source != expected.String() {
+		return "", fmt.Errorf("portable ABS/sign source changed its complete mathematical/transport effects")
+	}
+	// Reuse the existing exact group/reference and inert-declaration observer.
+	// It rejects actual native calls/assembly instead of deleting their effects.
+	return x86PackedShiftPortableFeatureProjection(ir, profiles)
+}
+
+func x86PackedAbsSignPortableFixture(t *testing.T, start, end int, arch string) (string, string) {
+	t.Helper()
+	rows := x86PackedAbsSignOracleRows()
+	var source, declarations strings.Builder
+	legacyMemory := 0
+	for index := start; index < end; index++ {
+		body, declaration := x86PackedAbsSignInitializedSource(index, rows[index], arch)
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		if rows[index].legacy && rows[index].memory {
+			legacyMemory++
+		}
+	}
+	instrumented := x86PackedAbsSignPortableMemoryInstrumentation(t, source.String(), legacyMemory)
+	return instrumented, declarations.String()
+}
+
+func TestX86PackedAbsSignPortableProjectionCompletePrograms(t *testing.T) {
+	x86PackedAbsSignOriginalProgramUnchanged(t)
+	rows, members := x86PackedAbsSignOracleRows(), make(map[string]bool)
+	for _, row := range rows {
+		members[row.op] = true
+	}
+	if len(rows) != 114 || len(members) != 13 {
+		t.Fatal("independent ABS/sign mathematical denominator changed", len(rows), len(members))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for start := 0; start < len(rows); start += 48 {
+			end := start + 48
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("%s/%d-%d", arch, start, end), func(t *testing.T) {
+				source, declarations := x86PackedAbsSignPortableFixture(t, start, end, arch)
+				triple := "x86_64-pc-windows-msvc"
+				if arch == "386" {
+					triple = "i686-pc-windows-msvc"
+				}
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+						if err != nil || !strings.Contains(ir, `"target-features"=`) {
+							t.Fatal("actual initialized x86 IR lost its independent rare-ISA prerequisite", err)
+						}
+						projected, err := x86PackedAbsSignPortableIR(source, ir, arch)
+						if err != nil || projected == "" || strings.Contains(projected, "target-features") {
+							t.Fatal("actual-host mathematics still selects the original rare x86 ISA", err)
+						}
+						// Independently permit only complete feature-group lines and
+						// their definition-header references to change. All memory,
+						// arithmetic, constants, declarations and generic attrs stay.
+						groups := regexp.MustCompile(`(?m)^attributes (#[0-9]+) = \{ "target-features"="[^"]+" \}\r?\n`)
+						want := groups.ReplaceAllString(ir, "")
+						for _, group := range groups.FindAllStringSubmatch(ir, -1) {
+							headers := regexp.MustCompile(`(?m)^(define [^\r\n]*) ` + regexp.QuoteMeta(group[1]) + ` \{`)
+							want = headers.ReplaceAllString(want, "${1} {")
+						}
+						if projected != want {
+							t.Fatal("portable projection changed more than its exact owned ISA selection")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedAbsSignPortableProjectionRejectsForeignSourceAndIR(t *testing.T) {
+	source, declaration := x86PackedAbsSignPortableFixture(t, 1, 2, "amd64")
+	ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-pc-windows-msvc", "Go")
+	if err != nil {
+		t.Fatal("complete initialized legacy mathematical prerequisite failed", err)
+	}
+	header := regexp.MustCompile(`(?m)^define [^\r\n]*\{`).FindString(ir)
+	group := regexp.MustCompile(`(?m)^attributes (#[0-9]+) = \{ "target-features"="([^"]+)" \}\r?\n`).FindStringSubmatch(ir)
+	if header == "" || len(group) != 3 {
+		t.Fatal("actual production IR has no unique observed definition/ISA group")
+	}
+	inBody := func(line string) string { return strings.Replace(ir, header, header+"\n  "+line, 1) }
+	for name, changed := range map[string]string{
+		"unknown-body-operation":  strings.Replace(source, "\nRET", "\nVZEROUPPER\nRET", 1),
+		"missing-input-transport": strings.Replace(source, "VMOVDQU64 (BX),Z1\n", "", 1),
+		"changed-output-address":  strings.Replace(source, "VMOVDQU64 Z2,(DI)", "VMOVDQU64 Z2,1(DI)", 1),
+		"missing-carry-producer":  strings.Replace(source, "STC\n", "", 1),
+		"duplicate-family-effect": strings.Replace(source, "PABSB X3,X2", "PABSB X3,X2\nPABSB X3,X2", 1),
+		"unknown-extra-function":  source + "TEXT ·Foreign(SB),4,$0-0\nRET\n",
+	} {
+		t.Run("source/"+name, func(t *testing.T) {
+			if changed == source {
+				t.Fatal("independent source mutation was not applied")
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-pc-windows-msvc", changed)
+			if output, err := x86PackedAbsSignPortableIR(changed, ir, "amd64"); err == nil || output != "" {
+				t.Fatal("portable owner accepted different source effects or input transports", err)
+			}
+		})
+	}
+	for name, changed := range map[string]string{
+		"inline-assembly":            inBody(`call void asm sideeffect "nop", ""()`),
+		"native-call":                inBody("%foreign = call i32 @llvm.x86.rdpid()"),
+		"extra-definition":           ir + "define void @Foreign() {\n  ret void\n}\n",
+		"foreign-group-reference":    inBody("call void @Foreign() " + group[1]),
+		"duplicated-feature-group":   ir + group[0],
+		"unobserved-feature-profile": strings.Replace(ir, group[2], group[2]+",+avx512vnni", 1),
+	} {
+		t.Run("IR/"+name, func(t *testing.T) {
+			if changed == ir {
+				t.Fatal("independent IR mutation was not applied")
+			}
+			if output, err := x86PackedAbsSignPortableIR(source, changed, "amd64"); err == nil || output != "" {
+				t.Fatal("portable projection accepted native behavior or unowned ISA references", err)
+			}
+		})
+	}
+}
+
+func TestX86PackedAbsSignPortableRuntimeConsumesCheckedIR(t *testing.T) {
+	data, err := os.ReadFile("x86_packed_abs_sign_runtime_tdd_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "runtime.go", data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	projections, executions := 0, 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86PackedAbsSignWholeBytesMinimumWrapAndFlags" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			if assignment, ok := node.(*ast.AssignStmt); ok && len(assignment.Rhs) == 1 {
+				call, ok := assignment.Rhs[0].(*ast.CallExpr)
+				if ok && fmt.Sprint(call.Fun) == "x86PackedAbsSignPortableIR" && len(call.Args) == 3 &&
+					fmt.Sprint(call.Args[0]) == "instrumented" && fmt.Sprint(call.Args[1]) == "ir" &&
+					fmt.Sprint(call.Args[2]) == "arch" && len(assignment.Lhs) == 2 && fmt.Sprint(assignment.Lhs[0]) == "ir" {
+					projections++
+				}
+			}
+			if call, ok := node.(*ast.CallExpr); ok && fmt.Sprint(call.Fun) == "x86ConflictFunnelPortableRuntime" &&
+				len(call.Args) == 7 && fmt.Sprint(call.Args[5]) == "ir" {
+				executions++
+			}
+			return true
+		})
+	}
+	if projections != 1 || executions != 1 {
+		t.Fatal("original actual-host driver no longer consumes the checked mathematical IR", projections, executions)
+	}
+}
diff --git a/x86_packed_abs_sign_runtime_tdd_test.go b/x86_packed_abs_sign_runtime_tdd_test.go
new file mode 100644
index 000000000..834d9a216
--- /dev/null
+++ b/x86_packed_abs_sign_runtime_tdd_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// The independent integer model runs on the actual development host. This
+// verifies translated values, not original SSSE3/AVX2/AVX512 execution.
+func TestX86PackedAbsSignWholeBytesMinimumWrapAndFlags(t *testing.T) {
+	x86PackedAbsSignOriginalProgramUnchanged(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("portable ABS/sign numerical oracle requires LLVM22 llc/clang")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	rows := x86PackedAbsSignOracleRows()
+	for start := 0; start < len(rows); start += 48 {
+		end := start + 48
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("%d-%d", start, end), func(t *testing.T) {
+			var source, declarations, prototypes, metadata strings.Builder
+			flag := func(value bool) int {
+				if value {
+					return 1
+				}
+				return 0
+			}
+			for index := start; index < end; index++ {
+				row := rows[index]
+				body, declaration := x86PackedAbsSignInitializedSource(index, row, arch)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				fmt.Fprintf(&prototypes, "extern void AbsSign%d(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);\n", index)
+				fmt.Fprintf(&metadata, "{AbsSign%d,%d,%d,%d,%d,%d,%d,%d},\n", index, row.width, row.bits/8,
+					flag(row.sign), flag(row.legacy), flag(row.source == "broadcast"),
+					flag(row.mode == "merge" || row.mode == "zero"), flag(row.mode == "zero"))
+			}
+			original := source.String()
+			x86LEAActualTargetGoObject(t, arch, triple, original)
+			legacyMemory := 0
+			for _, row := range rows[start:end] {
+				if row.legacy && row.memory {
+					legacyMemory++
+				}
+			}
+			// This companion owns mathematics on the actual host, not the
+			// original x86 alignment exception. Preserve legacy writeback by
+			// transporting only the checked memory source through an unused X
+			// bank. Actual native objects/faults have independent owners.
+			instrumented := x86PackedAbsSignPortableMemoryInstrumentation(t, original, legacyMemory)
+			ir, err := x86ScalarFPBitViewAPI(t, instrumented, declarations.String(), arch, triple, "Go")
+			if err != nil {
+				t.Fatal("complete initialized ABS/sign source failed before independent minimum-wrap comparison", err)
+			}
+			ir, err = x86PackedAbsSignPortableIR(instrumented, ir, arch)
+			if err != nil {
+				t.Fatal("portable ABS/sign IR projection failed", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "packed-abs-sign-whole-bytes", triple, ir,
+				fmt.Sprintf(x86PackedAbsSignWholeBytesC, prototypes.String(), metadata.String()))
+		})
+	}
+}
+
+// Instrumentation is deliberately limited to these six original legacy m128
+// instructions. It does not change their opcode to VEX (which would clear
+// upper aliases), infer backing, or claim execution of the original program.
+func x86PackedAbsSignPortableMemoryInstrumentation(t *testing.T, source string, expected int) string {
+	t.Helper()
+	originalHash := sha256.Sum256([]byte(source))
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal("portable ABS/sign instrumentation requires the complete parsed original", err)
+	}
+	used := [8]bool{}
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			for _, arg := range ins.Args {
+				register := string(arg.Reg)
+				if arg.Kind == OpReg && len(register) > 1 && strings.ContainsRune("XYZ", rune(register[0])) {
+					index, err := strconv.Atoi(register[1:])
+					if err != nil {
+						t.Fatal("unrecognized original vector alias", register)
+					}
+					if index < len(used) {
+						used[index] = true
+					}
+				}
+			}
+		}
+	}
+	scratch := -1
+	for index, live := range used {
+		if !live {
+			scratch = index
+			break
+		}
+	}
+	if scratch < 0 {
+		t.Fatal("complete original ABS/sign program has no genuinely unused mode32 X bank")
+	}
+	replacements := make(map[string]string)
+	count := 0
+	for _, function := range file.Funcs {
+		for _, ins := range function.Instrs {
+			switch ins.Op {
+			case "PABSB", "PABSW", "PABSD", "PSIGNB", "PSIGNW", "PSIGND":
+				if len(ins.Args) != 2 {
+					t.Fatal("portable instrumentation requires the exact legacy two-operand grammar", ins)
+				}
+				if ins.Args[0].Kind == OpReg {
+					continue
+				}
+				if ins.Args[0].Kind != OpMem || ins.Args[1].Kind != OpReg || !strings.HasPrefix(string(ins.Args[1].Reg), "X") {
+					t.Fatal("portable instrumentation refuses any different legacy storage/operand role", ins)
+				}
+				key := strings.TrimSpace(ins.Raw)
+				if key == "" {
+					t.Fatal("portable instrumentation lost original source spelling")
+				}
+				// VMOVDQU is the portable unaligned byte transport. MOVOU's
+				// native bridge would itself introduce x86 inline assembly.
+				replacements[key] = fmt.Sprintf("VMOVDQU %s,X%d\n%s X%d,%s", ins.Args[0], scratch, ins.Op, scratch, ins.Args[1])
+				count++
+			}
+		}
+	}
+	if count != expected {
+		t.Fatal("portable original legacy m128 inventory changed", count, expected)
+	}
+	lines := strings.Split(source, "\n")
+	replaced := 0
+	for index, line := range lines {
+		if replacement, found := replacements[strings.TrimSpace(line)]; found {
+			lines[index] = replacement
+			replaced++
+		}
+	}
+	if replaced != expected || originalHash != sha256.Sum256([]byte(source)) {
+		t.Fatal("portable instrumentation did not bind every unchanged original source instruction", replaced, expected)
+	}
+	t.Logf("portable ABS/sign mathematical instrumentation: original sha256=%x checked legacy m128 replacements=%d unused X bank=%d; not original alignment/fault execution", originalHash, replaced, scratch)
+	return strings.Join(lines, "\n")
+}
+
+const x86PackedAbsSignWholeBytesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+%s
+struct kernel {
+    void (*run)(uint8_t*,const uint8_t*,const uint8_t*,const uint8_t*,uint64_t);
+    unsigned width,lane,sign,legacy,broadcast,masked,zeroing;
+};
+static const struct kernel kernels[]={%s};
+static uint64_t read_word(const uint8_t *p,unsigned bytes) {
+    uint64_t value=0;
+    for (unsigned i=0;i<bytes;i++) value|=(uint64_t)p[i]<<(8*i);
+    return value;
+}
+static void write_word(uint8_t *p,unsigned bytes,uint64_t value) {
+    for (unsigned i=0;i<bytes;i++) p[i]=(uint8_t)(value>>(8*i));
+}
+int main(void) {
+    unsigned outcomes=0;
+    for (unsigned row=0;row<sizeof(kernels)/sizeof(kernels[0]);row++) {
+        struct kernel k=kernels[row];
+        unsigned bits=k.lane*8,lanes=k.width/k.lane;
+        uint64_t sign=UINT64_C(1)<<(bits-1),all=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1;
+        const uint64_t patterns[]={0,1,sign-1,sign,all-1,all,UINT64_C(0x1122334455667788)&all};
+        const uint64_t controls[]={all,0,1,sign,sign-1};
+        const uint64_t masks[]={0,1,UINT64_C(1)<<(lanes-1),UINT64_C(0x5555555555555555),
+            UINT64_C(0xaaaaaaaaaaaaaaaa),UINT64_MAX};
+        for (unsigned sample=0;sample<7;sample++) for (unsigned mask=0;mask<6;mask++) {
+            uint8_t input[64],control[64],old[64],out[80],expected[80];
+            for (unsigned at=0;at<64;at+=k.lane) {
+                write_word(input+at,k.lane,patterns[(sample+at/k.lane)%%7]);
+                write_word(control+at,k.lane,controls[(sample+at/k.lane)%%5]);
+                write_word(old+at,k.lane,patterns[(sample+at/k.lane+3)%%7]);
+            }
+            uint8_t beforeInput[64],beforeControl[64],beforeOld[64];
+            memcpy(beforeInput,input,64);memcpy(beforeControl,control,64);memcpy(beforeOld,old,64);
+            memset(out,0xc3,sizeof(out));memset(expected,0xc3,sizeof(expected));
+            memset(expected,0,64);
+            if (k.legacy) memcpy(expected,old,64);
+            for (unsigned lane=0;lane<lanes;lane++) {
+                unsigned at=lane*k.lane;
+                uint64_t data=read_word(k.sign&&k.legacy?old+at:input+(k.broadcast?0:at),k.lane);
+                uint64_t result=(data&sign)?(UINT64_C(0)-data)&all:data;
+                if (k.sign) {
+                    uint64_t c=read_word(control+at,k.lane);
+                    result=!c?0:(c&sign)?(UINT64_C(0)-data)&all:data;
+                }
+                if (k.masked && !(masks[mask]>>lane&1)) result=k.zeroing?0:read_word(old+at,k.lane);
+                write_word(expected+at,k.lane,result);
+            }
+            expected[64]=1;
+            k.run(out,input,control,old,masks[mask]);
+            if (memcmp(out,expected,sizeof(out)) || memcmp(input,beforeInput,64) ||
+                    memcmp(control,beforeControl,64) || memcmp(old,beforeOld,64)) {
+                fprintf(stderr,"ABS/sign row=%%u sample=%%u mask=%%u\n",row,sample,mask);
+                for (unsigned i=0;i<sizeof(out);i++) if (out[i]!=expected[i])
+                    fprintf(stderr,"byte %%u got %%02x want %%02x\n",i,out[i],expected[i]);
+                return 1;
+            }
+            outcomes++;
+        }
+    }
+    if (outcomes!=42*sizeof(kernels)/sizeof(kernels[0])) return 2;
+    printf("portable ABS/sign full64/minimum-wrap/CF/input-output-canary outcomes %%u failures 0\n",outcomes);
+    return 0;
+}
+`
diff --git a/x86_packed_abs_sign_tdd_test.go b/x86_packed_abs_sign_tdd_test.go
new file mode 100644
index 000000000..ede2a4979
--- /dev/null
+++ b/x86_packed_abs_sign_tdd_test.go
@@ -0,0 +1,304 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86PackedAbsSignOracleRow struct {
+	op, bank, mode, source string
+	bits, width            int
+	sign, legacy, memory   bool
+}
+
+// Independent of the emitter: legacy six X-only names, three VEX sign
+// names, and four ABS names with their full EVEX width/mask/broadcast axes.
+// Intel's NP MMX encodings are not Go's yxm_q4 named grammar.
+func x86PackedAbsSignOracleRows() []x86PackedAbsSignOracleRow {
+	var rows []x86PackedAbsSignOracleRow
+	for _, sign := range []bool{false, true} {
+		stem := "PABS"
+		if sign {
+			stem = "PSIGN"
+		}
+		for index, suffix := range []string{"B", "W", "D"} {
+			for _, memory := range []bool{false, true} {
+				rows = append(rows, x86PackedAbsSignOracleRow{op: stem + suffix, bank: "X", bits: 8 << index,
+					width: 16, legacy: true, sign: sign, memory: memory})
+			}
+		}
+	}
+	for index, suffix := range []string{"B", "W", "D", "Q"} {
+		for at, bank := range []string{"X", "Y", "Z"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				for _, source := range []string{"register", "memory", "broadcast"} {
+					if source == "broadcast" && index < 2 {
+						continue
+					}
+					rows = append(rows, x86PackedAbsSignOracleRow{op: "VPABS" + suffix, bank: bank, bits: 8 << index,
+						width: 16 << at, mode: mode, source: source, memory: source != "register"})
+				}
+			}
+		}
+	}
+	for index, suffix := range []string{"B", "W", "D"} {
+		for at, bank := range []string{"X", "Y"} {
+			for _, memory := range []bool{false, true} {
+				rows = append(rows, x86PackedAbsSignOracleRow{op: "VPSIGN" + suffix, bank: bank, bits: 8 << index,
+					width: 16 << at, sign: true, memory: memory})
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86PackedAbsSignOracleRow) instruction() string {
+	op, source, mask := row.op, row.bank+"0", ""
+	if row.sign {
+		source = row.bank + "1"
+	}
+	if row.memory {
+		source = "(AX)"
+		if row.sign {
+			source = "(BX)"
+		}
+	}
+	if row.source == "broadcast" {
+		op += ".BCST"
+	}
+	if row.mode == "merge" || row.mode == "zero" {
+		mask = ",K1"
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	if row.sign && !row.legacy {
+		return fmt.Sprintf("%s %s,%s0,%s2", op, source, row.bank, row.bank)
+	}
+	return fmt.Sprintf("%s %s%s,%s2", op, source, mask, row.bank)
+}
+
+func x86PackedAbsSignOriginalProgramUnchanged(t *testing.T) {
+	t.Helper()
+	file := "amd64_lower_abs_sign_test.go"
+	data, err := os.ReadFile(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	syntax, err := parser.ParseFile(set, file, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range syntax.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == "qualifyAMD64PackedAbsSignRuntimeSemantics" {
+			start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+			// Exclude only the independently audited execution preflight. The
+			// original ASM, C, inputs and every other driver statement retain
+			// their unchanged fingerprint and separate literal-level pins.
+			original := strings.Replace(string(data[start:end]),
+				"\tx86OriginalFloatingRuntimeRequireCPU(t, \"packed-abs-sign\", clang, triple, runPrefix)\n", "", 1)
+			original = strings.Replace(original, "func qualifyAMD64PackedAbsSignRuntimeSemantics(",
+				"func TestAMD64PackedAbsSignRuntimeSemantics(", 1)
+			if fmt.Sprintf("%x", sha256.Sum256([]byte(original))) != "2f3f1858c33eaac4ffc0d298859629e18716b06fbec597aa2a84587d27cf9ed3" {
+				t.Fatal("original initialized ABS/sign source, C oracle or observations changed")
+			}
+			return
+		}
+	}
+	t.Fatal("original packed ABS/sign runtime root disappeared")
+}
+
+func TestX86PackedAbsSignCompleteTypedOperandRoles(t *testing.T) {
+	x86PackedAbsSignOriginalProgramUnchanged(t)
+	rows := x86PackedAbsSignOracleRows()
+	if len(rows) != 114 {
+		t.Fatal("complete independent ABS/sign physical source directory changed", len(rows))
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("complete ABS/sign family lacks typed data/mask/write effects", effect, known, err)
+				}
+				reads, writes := make(map[int]bool), make(map[int]bool)
+				for _, operand := range effect.operands {
+					width := row.width
+					if operand.index == 0 && row.source == "broadcast" {
+						width = row.bits / 8
+					}
+					if operand.operand.Kind == OpReg && operand.operand.Reg == "K1" {
+						width = 8
+					}
+					if operand.index < 0 || operand.index >= len(ins.Args) || operand.width != int64(width) ||
+						!reflect.DeepEqual(operand.operand, ins.Args[operand.index]) {
+						t.Fatal("typed family confused scalar tuple, vector or K width", operand)
+					}
+					reads[operand.index] = reads[operand.index] || operand.read
+					writes[operand.index] = writes[operand.index] || operand.write
+				}
+				last := len(ins.Args) - 1
+				for index := range ins.Args {
+					wantRead := index == 0 || row.sign && index == 1 ||
+						row.mode == "merge" || row.mode == "zero" && index == 1
+					if reads[index] != wantRead || writes[index] != (index == last) {
+						t.Fatal("write-only ABS, PSIGN data, merging old destination or mask dependency changed", index, reads, writes)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedAbsSignUnknownBytesAliasesAndUnchangedState(t *testing.T) {
+	for _, row := range x86PackedAbsSignOracleRows() {
+		if row.memory {
+			continue
+		}
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				original := x86ScalarLaneInstruction(t, row.instruction())
+				for _, alias := range []bool{false, true} {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					if alias {
+						ins.Args[0] = ins.Args[len(ins.Args)-1]
+					}
+					for register := 0; register < 3; register++ {
+						for missing := -1; missing < 64; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward, masks: [8]bool{1: true}}
+							for index := 0; index < 3; index++ {
+								state.writeVector(index, 64, ^uint64(0), true)
+							}
+							state.pointerGP[5], state.callerAddressGP[6] = true, true
+							if missing >= 0 {
+								state.writeVector(register, 64, ^(uint64(1) << uint(missing)), true)
+							}
+							before := state.clone()
+							if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+								t.Fatal("nontrapping unknown dead packed data was rejected instead of remaining unknown", alias, register, missing)
+							}
+							input := register == 0 && !row.sign || row.sign && register == 1 ||
+								row.sign && register == 0 && !row.legacy || row.sign && register == 2 && row.legacy ||
+								row.mode == "merge" && register == 2
+							if alias {
+								input = register == 2 || row.sign && !row.legacy && register == 0
+							}
+							if missing < 0 && state.vectorBytes(2) != ^uint64(0) ||
+								input && missing >= 0 && missing < row.width && state.vectorBytes(2)&(uint64(1)<<uint(missing)) != 0 {
+								t.Fatal("computed output invented an unknown input byte", alias, register, missing)
+							}
+							if row.legacy && state.vectorBytes(2)&^uint64(0xffff) != before.vectorBytes(2)&^uint64(0xffff) ||
+								!row.legacy && state.vectorBytes(2)&^x86CallerVectorByteMask(int64(row.width)) != ^x86CallerVectorByteMask(int64(row.width)) ||
+								state.flags != before.flags || state.direction != before.direction || state.pointerGP != before.pointerGP ||
+								state.callerAddressGP != before.callerAddressGP || state.masks != before.masks {
+								t.Fatal("ABS/sign altered unrelated FLAGS/DF/pointers/masks or upper aliases")
+							}
+							for index := 0; index < 2; index++ {
+								if state.vectorBytes(index) != before.vectorBytes(index) {
+									t.Fatal("ABS/sign wrote a nondestination register")
+								}
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86PackedAbsSignInitializedSource(index int, row x86PackedAbsSignOracleRow, arch string) (string, string) {
+	return x86PackedAbsSignInitializedInstruction(index, row.instruction(), arch, [3]int{0, 1, 2})
+}
+
+func x86PackedAbsSignInitializedInstruction(index int, instruction, arch string, registers [3]int) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	name := fmt.Sprint("AbsSign", index)
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),AX\n%s control+%d(FP),BX\n%s old+%d(FP),CX\n"+
+		"VMOVDQU64 (AX),Z%d\nVMOVDQU64 (BX),Z%d\nVMOVDQU64 (CX),Z%d\nKMOVQ mask+%d(FP),K1\nSTC\n%s\nVMOVDQU64 Z%d,(DI)\nSETCS 64(DI)\nRET\n",
+		name, 4*word+8, move, move, word, move, 2*word, move, 3*word,
+		registers[0], registers[1], registers[2], 4*word, instruction, registers[2])
+	return source, fmt.Sprintf("func %s(out *[80]byte,input,control,old *[64]byte,mask uint64)\n", name)
+}
+
+func TestX86PackedAbsSignInitializedObjectsThreeAPIsFiveTargets(t *testing.T) {
+	x86PackedAbsSignOriginalProgramUnchanged(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete ABS/sign original objects require LLVM22")
+	}
+	rows := x86PackedAbsSignOracleRows()
+	for _, target := range x86RawReturnTargets {
+		for start := 0; start < len(rows); start += 48 {
+			end := start + 48
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("%s/%d-%d", target.triple, start, end), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index := start; index < end; index++ {
+					body, declaration := x86PackedAbsSignInitializedSource(index, rows[index], target.arch)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal("complete initialized ABS/sign family rejected", err)
+						}
+						for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							compileLLVMToObject(t, llc, target.triple, "abs-sign-complete.ll", "abs-sign-complete.o", body)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedAbsSignMaskNativeAndMMXBoundaries(t *testing.T) {
+	for _, row := range x86PackedAbsSignOracleRows() {
+		if !row.memory && row.mode != "merge" && row.mode != "zero" {
+			continue
+		}
+		for _, unusedBool := range []bool{false, true} {
+			extent, declaration := 0, "func Missing()"
+			if unusedBool {
+				extent, declaration = 1, "func Missing(unused bool)"
+			}
+			source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s\nRET\n", extent, row.instruction())
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("dead/Void source invented its missing native address or K input", row.instruction(), unusedBool, api)
+				}
+			}
+		}
+	}
+	for _, op := range []string{"PABSB", "PABSW", "PABSD", "PSIGNB", "PSIGNW", "PSIGND"} {
+		// Intel's NP form is MMX, but Go's only named legacy row is XMM.
+		goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+op+" M0,M1\nRET\n", "", false)
+		ins := x86ScalarLaneInstruction(t, op+" M0,M1")
+		state := x86ResultState{nativeMMX: [8]uint8{0: 0xff, 1: 0xff}, flags: x86ByteFlagsAll}
+		before := state.clone()
+		if x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+			t.Fatal("named XMM family borrowed independent physical MMX/x87 state", op)
+		}
+	}
+}
diff --git a/x86_packed_addsub_input_obligation_test.go b/x86_packed_addsub_input_obligation_test.go
new file mode 100644
index 000000000..c9bb4b27a
--- /dev/null
+++ b/x86_packed_addsub_input_obligation_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The independent Go-row inventories cover all legacy/V add/sub spellings,
+// including PADDD. Routing a Void function must retain native address/index
+// obligations without borrowing an unrelated KMOV or result-store selector.
+func TestX86PackedAddSubVoidNativeInputsCannotBypassWholeProof(t *testing.T) {
+	names := append([]string(nil), x86LegacyIntegerArithmeticTestNames...)
+	for _, member := range x86ResultVectorArithmeticNames {
+		names = append(names, member.name)
+	}
+	if len(names) != 33 {
+		t.Fatal("complete independent legacy/V add-sub inventory changed", len(names))
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, unusedBool := range []bool{false, true} {
+			word, move, declaration := int(goWordSize(target.arch)), "MOVQ", "func Value(p *[128]byte)"
+			if word == 4 {
+				move = "MOVL"
+			}
+			extent := word
+			if unusedBool {
+				declaration = "func Value(p *[128]byte, unused bool)"
+				extent++
+			}
+			var original strings.Builder
+			for ordinal, op := range names {
+				banks := []string{"X"}
+				if strings.HasPrefix(op, "V") {
+					banks = append(banks, "Y", "Z")
+				}
+				for _, bank := range banks {
+					instruction := op + " 3(AX)(DX*2)," + bank + "1"
+					if strings.HasPrefix(op, "V") {
+						instruction = op + " 3(AX)(DX*2)," + bank + "0," + bank + "1"
+					}
+					prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\n", extent, move)
+					source := prefix + "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" + instruction + "\nRET\n"
+					variants := []struct{ name, source string }{
+						{"initialized", source},
+						{"unknown-pointer", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+						{"numerical-pointer", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+						{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+					}
+					for index, variant := range variants {
+						name := fmt.Sprintf("Value%d%sCase%d", ordinal, bank, index)
+						original.WriteString(strings.Replace(variant.source, "·Value(SB)", "·"+name+"(SB)", 1))
+					}
+					// One Go object below binds every original positive/negative
+					// source. Each public query still checks its own function.
+					t.Run(fmt.Sprintf("%s/bool%t/%s/%s", target.triple, unusedBool, op, bank), func(t *testing.T) {
+						for _, variant := range variants {
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, variant.source, declaration, target.arch, target.triple, api)
+								if variant.name == "initialized" || variant.name == "numerical-pointer" {
+									if err != nil || ir == "" {
+										t.Fatal("complete Void native input rejected", api, err)
+									}
+									if variant.name == "numerical-pointer" {
+										originalIR, originalErr := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+										if originalErr != nil {
+											t.Fatal(originalErr)
+										}
+										x86RequireSameNativeMemoryEffects(t, originalIR, ir)
+										x86RequireNumericNativeSourceContext(t, variant.source, declaration, target.arch)
+										x86NumericNativeAddressObject(t, ir, target.triple)
+									}
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Errorf("%s/%s: missing native input bypassed the whole proof: %v", variant.name, api, err)
+								}
+							}
+						}
+					})
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, original.String())
+		}
+	}
+}
diff --git a/x86_packed_align_contract_test.go b/x86_packed_align_contract_test.go
new file mode 100644
index 000000000..304e5f27c
--- /dev/null
+++ b/x86_packed_align_contract_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86PackedAlignRows() []struct {
+	op     string
+	bits   int
+	legacy bool
+} {
+	return []struct {
+		op     string
+		bits   int
+		legacy bool
+	}{
+		{"PALIGNR", 8, true},
+		{"VPALIGNR", 8, false},
+		{"VALIGND", 32, false},
+		{"VALIGNQ", 64, false},
+	}
+}
+
+func x86PackedAlignInstruction(op, first, bank, mask string, immediate, destination int, legacy bool) string {
+	arguments := fmt.Sprintf("$%d,%s,", immediate, first)
+	if !legacy {
+		arguments += bank + "1,"
+	}
+	return op + " " + arguments + mask + fmt.Sprint(bank, destination)
+}
+
+// This independent reference uses byte positions in the ISA concatenation,
+// never a production selector or operand descriptor.
+func x86PackedAlignExpectedKnown(op string, width, immediate int, first, second, old uint64, merge, legacy bool) uint64 {
+	var defined uint64
+	for output := 0; output < width; output++ {
+		at, known := 0, false
+		if op == "PALIGNR" || op == "VPALIGNR" {
+			at = output%16 + immediate
+			if at >= 32 {
+				known = true
+			} else if at < 16 {
+				known = first>>uint(output/16*16+at)&1 != 0
+			} else {
+				known = second>>uint(output/16*16+at-16)&1 != 0
+			}
+		} else {
+			bytes := 4
+			if op == "VALIGNQ" {
+				bytes = 8
+			}
+			at = (output/bytes+(immediate&(width/bytes-1)))*bytes + output%bytes
+			if at < width {
+				known = first>>uint(at)&1 != 0
+			} else {
+				known = second>>uint(at-width)&1 != 0
+			}
+		}
+		if merge {
+			known = known && old>>uint(output)&1 != 0
+		}
+		if known {
+			defined |= uint64(1) << uint(output)
+		}
+	}
+	upper := ^x86CallerVectorByteMask(int64(width))
+	if legacy {
+		upper &= old
+	}
+	return upper | defined
+}
+
+func TestX86PackedAlignSelectedBytesAndUnknownDeadDomain(t *testing.T) {
+	for _, row := range x86PackedAlignRows() {
+		banks := []string{"X", "Y", "Z"}
+		if row.legacy {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if row.legacy && mode != "plain" {
+					continue
+				}
+				for _, alias := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/alias=%t", row.op, bank, mode, alias), func(t *testing.T) {
+						width := amd64VectorByteWidth(Reg(bank + "0"))
+						for immediate := 0; immediate < 256; immediate++ {
+							for _, seed := range []uint64{0, 0x51a9435fa095f037, 0xffffffffffffffff} {
+								state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+									fp: []bool{true, false}, auto: []bool{false, true}}
+								state.writeVector(0, 64, seed, false)
+								state.writeVector(1, 64, seed^0xf037954aa19359a7, false)
+								state.writeVector(2, 64, seed^0xa37b9351b4a78c67, false)
+								state.masks[1], state.pointerGP[3], state.gp[0] = true, true, 0x55
+								destination := 2
+								if alias {
+									destination = 0
+								}
+								op, mask := row.op, ""
+								if mode != "plain" {
+									mask = "K1,"
+								}
+								if mode == "zero" {
+									op += ".Z"
+								}
+								ins := x86ScalarLaneInstruction(t, x86PackedAlignInstruction(op, bank+"0", bank, mask, immediate, destination, row.legacy))
+								first, second, old := state.vectorBytes(0), state.vectorBytes(1), state.vectorBytes(destination)
+								if row.legacy {
+									second = old
+								}
+								want := state.clone()
+								want.writeVector(destination, 64, x86PackedAlignExpectedKnown(row.op, width, immediate,
+									first, second, old, mode == "merge", row.legacy), false)
+								if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, want) {
+									t.Fatal("selector invented bytes, rejected a dead unknown register result or changed independent state", immediate, seed)
+								}
+								caller := x86SourceStackState{
+									vectors: map[Reg]uint64{"Z0": seed, "Z1": seed ^ 0xf037954aa19359a7, "Z2": seed ^ 0xa37b9351b4a78c67},
+									masks:   map[Reg]bool{"K1": true}, known: map[Reg]uint8{AX: 0xff},
+									callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}},
+								}
+								wantCaller := x86CloneCallerState(caller)
+								wantCaller.vectors[Reg(fmt.Sprint("Z", destination))] = x86PackedAlignExpectedKnown(row.op, width, immediate,
+									first, second, old, mode == "merge", row.legacy)
+								form, known, err := x86PackedAlignProperties(ins.Op, ins, "amd64")
+								if !known || err != nil || !x86CallerPackedAlignStep(&ins, form, &caller, nil) || !reflect.DeepEqual(caller, wantCaller) {
+									t.Fatal("caller and result consumers diverged on the independent selector", immediate, seed, err)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedAlignDeadNativeMemoryCannotDisappear(t *testing.T) {
+	for _, row := range x86PackedAlignRows() {
+		banks := []string{"X", "Y", "Z"}
+		if row.legacy {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			t.Run(row.op+"/"+bank, func(t *testing.T) {
+				width := amd64VectorByteWidth(Reg(bank + "0"))
+				op, mask := row.op, "K1,"
+				if row.legacy {
+					mask = ""
+				} else {
+					op += ".Z"
+				}
+				instruction := x86PackedAlignInstruction(op, "(AX)", bank, mask, 255, 2, row.legacy)
+				source := "TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),AX\n" +
+					"MOVL $0,BX\nKMOVD BX,K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n" + instruction + "\nRET\n"
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatal("initialized dead native source lost its paired access", api, err)
+					}
+					optimized := x86DwordProductIROptimize(t, ir)
+					for _, text := range []string{ir, optimized} {
+						if row.legacy {
+							if !strings.Contains(text, "asm sideeffect") || !strings.Contains(text, "palignr $$255") {
+								t.Fatal("legacy alignment/fault opcode was removed or replaced", api)
+							}
+						} else if !strings.Contains(text, fmt.Sprintf("load volatile <%d x i8>", width)) {
+							t.Fatal("E4NF zero-mask/large-count access was removed or narrowed", api)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_align_objects_test.go b/x86_packed_align_objects_test.go
new file mode 100644
index 000000000..c0027aeff
--- /dev/null
+++ b/x86_packed_align_objects_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedAlignCompleteInitializedObjectsFiveTargets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count, batches, pending := 0, 0, 0
+			flush := func() {
+				if pending < 1 || pending > 64 {
+					t.Fatal("invalid bounded align object batch", pending)
+				}
+				t.Run(fmt.Sprint("batch", batches), func(t *testing.T) {
+					x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+				})
+				source.Reset()
+				declarations.Reset()
+				batches++
+				pending = 0
+			}
+			for _, row := range x86PackedAlignRows() {
+				if target.arch == "386" && !row.legacy {
+					continue
+				}
+				banks := []string{"X", "Y", "Z"}
+				if row.legacy {
+					banks = banks[:1]
+				}
+				for _, bank := range banks {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if row.legacy && mode != "plain" {
+							continue
+						}
+						inputs := []string{bank + "0", "(SI)"}
+						if row.bits != 8 {
+							inputs = append(inputs, "broadcast")
+						}
+						for _, input := range inputs {
+							op, operand, mask := row.op, input, ""
+							if input == "broadcast" {
+								op, operand = op+".BCST", "(SI)"
+							}
+							if mode != "plain" {
+								mask = "K1,"
+							}
+							if mode == "zero" {
+								op += ".Z"
+							}
+							name := fmt.Sprint("Align", count)
+							instruction := x86PackedAlignInstruction(op, operand, bank, mask, 17, 2, row.legacy)
+							fmt.Fprintf(&declarations, "func %s(out,a,b,old *[64]byte)\n", name)
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n"+
+								"%s a+%d(FP),SI\n%s b+%d(FP),BX\n%s old+%d(FP),CX\n"+
+								"VMOVUPS (SI),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\n"+
+								"MOVL $-1431655766,AX\nKMOVD AX,K1\nSTC\n%s\nVMOVUPS Z2,(DI)\nRET\n",
+								name, word*4, move, move, word, move, word*2, move, word*3, instruction)
+							count++
+							pending++
+							if pending == 64 {
+								flush()
+							}
+						}
+					}
+				}
+			}
+			want := 74
+			if target.arch == "386" {
+				want = 2
+			}
+			if count != want {
+				t.Fatal("complete family/source/broadcast/mask object union changed", count, want)
+			}
+			if pending != 0 {
+				flush()
+			}
+			if batches != (want+63)/64 {
+				t.Fatal("missing object batch", batches)
+			}
+		})
+	}
+}
+
+func TestX86PackedAlignDeadUnknownIsNotObservableNumericalData(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86PackedAlignRows() {
+			if target.arch == "386" && !row.legacy {
+				continue
+			}
+			for _, immediate := range []int{0, 255} {
+				for _, role := range []string{"void", "unused-bool", "result", "missing-mask", "missing-native-address"} {
+					if row.legacy && role == "missing-mask" {
+						continue
+					}
+					t.Run(fmt.Sprintf("%s/%s/%d/%s", target.triple, row.op, immediate, role), func(t *testing.T) {
+						declaration, header, tail := "func Value()", "$0-0", "RET\n"
+						op, first, mask := row.op, "X0", ""
+						want := true
+						switch role {
+						case "unused-bool":
+							declaration, header = "func Value(unused bool)", "$0-1"
+						case "result":
+							declaration, header = "func Value() uint32", "$0-4"
+							tail = "PEXTRD $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n"
+							want = row.bits == 8 && immediate >= 32
+						case "missing-mask":
+							op, mask, want = op+".Z", "K1,", false
+						case "missing-native-address":
+							first, want = "(AX)", false
+						}
+						instruction := x86PackedAlignInstruction(op, first, "X", mask, immediate, 2, row.legacy)
+						source := "TEXT ·Value(SB),4," + header + "\n" + instruction + "\n" + tail
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if target.arch == "amd64" && role == "result" && !want {
+								x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+							} else if want && (err != nil || ir == "") || !want && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+								t.Fatal("unknown dead data was rejected or became observable NUM/address/mask data", want, api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_packed_average_format_unit_test.go b/x86_packed_average_format_unit_test.go
new file mode 100644
index 000000000..1d7b75028
--- /dev/null
+++ b/x86_packed_average_format_unit_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Object-only instruction units retain every original format row, including
+// MMX and unbound native operands. These are not public translations or runs.
+// Actual typed entry arguments still describe logical FP byte layout only.
+func x86AverageFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+		return c.lowerPackedUnsignedAverage(ins.Op, ins)
+	})
+}
+
+func x86WordMultiplyFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string, frame int64) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, frame, func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+		return c.lowerPackedWordMultiply(ins.Op, ins)
+	})
+}
+
+func x86InstructionFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string,
+	frame int64, lower func(*amd64Ctx, Instr) (bool, bool, error)) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnits(t, file, signatures, arch, triple, frame, false, lower)
+}
+
+// Each visible function owns exactly one original format row. This permits a
+// terminal opcode without allowing it to hide later rows in an unreachable
+// block. The ordinary multi-row format helper retains its stricter contract.
+func x86SingleInstructionFormatObjectUnits(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string,
+	lower func(*amd64Ctx, Instr) (bool, bool, error)) string {
+	t.Helper()
+	for _, function := range file.Funcs {
+		if len(function.Instrs) != 3 || function.Instrs[0].Op != OpTEXT || !x86InstructionFormatTerminal(function.Instrs[2]) {
+			t.Fatal("isolated format function must retain exactly TEXT, one row and its return/fault")
+		}
+	}
+	return x86InstructionFormatObjectUnits(t, file, signatures, arch, triple, 0, true, lower)
+}
+
+func x86InstructionFormatTerminal(instruction Instr) bool {
+	return len(instruction.Args) == 0 &&
+		(instruction.Op == OpRET || instruction.Op == "UD2" || instruction.Op == "UNDEF")
+}
+
+func x86InstructionFormatObjectUnits(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string,
+	frame int64, isolated bool, lower func(*amd64Ctx, Instr) (bool, bool, error)) string {
+	t.Helper()
+	resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\n", triple)
+	emitAMD64Prelude(&ir, arch, file)
+	emitExternSBGlobals(&ir, file, resolve, signatures)
+	if len(file.Data) != 0 || len(file.Globl) != 0 {
+		if err := emitDataGlobalsWithSigs(&ir, file, resolve, signatures, WASMABIDirect); err != nil {
+			t.Fatal("original format unit lost its actual DATA/GLOBL storage", err)
+		}
+	}
+	attributes := newFeatureAttrRegistry()
+	emitted := 0
+	for index, function := range file.Funcs {
+		sig, found := signatures[resolve(function.Sym)]
+		registerI32 := sig.Ret == I32 && len(sig.Frame.Results) == 0
+		scalarResult := (sig.Ret == I8 || sig.Ret == I16 || sig.Ret == I32 || sig.Ret == I64) &&
+			len(sig.Frame.Results) == 1 && sig.Frame.Results[0].Type == sig.Ret
+		if !found || sig.Ret != Void && !registerI32 && !scalarResult || function.FrameSize != frame || len(function.Instrs) < 2 {
+			t.Fatal("instruction format unit lost its complete original return/frame role")
+		}
+		var arguments []string
+		for ordinal, typ := range sig.Args {
+			arguments = append(arguments, fmt.Sprintf("%s %%arg%d", typ, ordinal))
+		}
+		features := attributes.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, arch, function))
+		fmt.Fprintf(&ir, "define %s @InstructionFormat%d(%s) %s {\n", sig.Ret, index, strings.Join(arguments, ", "), features)
+		consumer := newX86Ctx(&ir, function, sig, resolve, signatures, arch, triple, false)
+		if err := consumer.emitEntryAllocas(); err != nil {
+			t.Fatal(err)
+		}
+		terminal := false
+		for ordinal, instruction := range function.Instrs {
+			switch instruction.Op {
+			case OpTEXT:
+				if ordinal != 0 {
+					t.Fatal("format unit has an additional original TEXT")
+				}
+			case OpRET:
+				if ordinal != len(function.Instrs)-1 || len(instruction.Args) != 0 {
+					t.Fatal("format unit lost its original final return")
+				}
+				if terminal {
+					continue
+				}
+				if registerI32 || scalarResult {
+					// Retain the emitter's original AX or declared scalar FP
+					// transport. These format objects prove no initialized result.
+					if err := consumer.lowerRET(); err != nil {
+						t.Fatal(err)
+					}
+				} else {
+					ir.WriteString("  ret void\n")
+				}
+			case "UNDEF", "UD2":
+				if ordinal != len(function.Instrs)-1 || len(instruction.Args) != 0 {
+					t.Fatal("format unit lost its original final fault")
+				}
+				if terminal {
+					continue // An isolated architectural-fault row cannot reach its fault footer.
+				}
+				known, terminated, err := consumer.lowerX86UndefinedTrap(instruction.Op, instruction)
+				if !known || !terminated || err != nil {
+					t.Fatal("original format-unit fault was not emitted", err)
+				}
+			default:
+				known, terminated, err := lower(consumer, instruction)
+				if !known || terminated && (!isolated || ordinal != 1) || err != nil {
+					t.Fatal("complete original instruction format row not emitted", instruction.Raw, err)
+				}
+				terminal = terminated
+				emitted++
+			}
+		}
+		ir.WriteString("}\n")
+	}
+	attributes.emit(&ir)
+	if fileUsesX86NonTemporalMetadata(file) {
+		ir.WriteString("!0 = !{i32 1}\n\n")
+	}
+	t.Logf("all %d original instruction format rows emitted as IR; object compilation belongs to the caller, no public or runtime success claim", emitted)
+	return ir.String()
+}
+
+// The ordinary dispatcher can emit straight-line scalar format units without
+// acquiring a public entry, numerical input or native storage certificate.
+func x86ScalarFormatObjectUnit(t *testing.T, file *File, signatures map[string]FuncSig, arch, triple string, frame int64) string {
+	t.Helper()
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, frame,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			terminated, err := c.lowerInstr(0, 0, instruction, nil, nil)
+			return true, terminated, err
+		})
+}
diff --git a/x86_packed_average_value_fault_unix_test.go b/x86_packed_average_value_fault_unix_test.go
new file mode 100644
index 000000000..85906c3a3
--- /dev/null
+++ b/x86_packed_average_value_fault_unix_test.go
@@ -0,0 +1,112 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+func TestX86PackedAverageE4PortableMemoryFaults(t *testing.T) {
+	x86FixedBinaryE4PortableMemoryFaults(t, x86AverageValueRuntimeProgramWithResult, 90)
+}
+
+func TestX86PackedWordMultiplyE4PortableMemoryFaults(t *testing.T) {
+	x86FixedBinaryE4PortableMemoryFaults(t, x86WordMultiplyValueRuntimeProgram, 180)
+}
+
+func TestX86PackedNarrowE4NFPortableMemoryFaults(t *testing.T) {
+	x86FixedBinaryPortableMemoryFaults(t, x86NarrowValueRuntimeProgram, 270, true)
+}
+
+func x86FixedBinaryE4PortableMemoryFaults(t *testing.T, program func(string, bool) (string, string, string, string), observations int) {
+	t.Helper()
+	x86FixedBinaryPortableMemoryFaults(t, program, observations, false)
+}
+
+func x86FixedBinaryPortableMemoryFaults(t *testing.T, program func(string, bool) (string, string, string, string), observations int, fullTuple bool) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	full := 0
+	if fullTuple {
+		full = 1
+	}
+	for _, discard := range []bool{false, true} {
+		source, declarations, prototypes, rows := program("amd64", discard)
+		driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n#include <errno.h>\n" +
+			"#include <unistd.h>\n#include <signal.h>\n#include <sys/mman.h>\n#include <sys/wait.h>\n#include <sys/resource.h>\n" +
+			numericalRuntimeFaultObservationC + prototypes + "\nstatic const int full_tuple=" + fmt.Sprint(full) + ";\n" + `
+struct kernel {void (*fn)(uint8_t*,uint8_t*,uint8_t*,uint64_t);unsigned width,bits,mode,legacy,operation;};
+static const struct kernel kernels[]={
+` + rows + `};
+static uint8_t *protected_region;
+static size_t protected_bytes;
+static int observe(const struct kernel *kernel,uint8_t *p,uint64_t mask,int fault) {
+    pid_t child=fork();
+    if(child<0)return 1;
+    if(!child) {
+        struct rlimit observed;
+        uint8_t b[67],out[67];
+        memset(b,0xa7,sizeof(b));
+        memset(out,0xc3,sizeof(out));
+        if(getrlimit(RLIMIT_CORE,&observed)||observed.rlim_cur||observed.rlim_max)_exit(120);
+        numerical_fault_begin(p ? protected_region : 0,protected_bytes);
+        kernel->fn(p,b+1,out+1,mask);
+        _exit(0);
+    }
+    int status;
+    pid_t waited;
+    do {waited=waitpid(child,&status,0);}while(waited<0&&errno==EINTR);
+    if(waited!=child)return 1;
+    if(fault ? numerical_fault_status(status) : WIFEXITED(status)&&WEXITSTATUS(status)==0)return 0;
+    fprintf(stderr,"average width=%u bits=%u mode=%u mask=%llx expectedFault=%d status=%x\n",
+        kernel->width,kernel->bits,kernel->mode,(unsigned long long)mask,fault,status);
+    return 1;
+}
+int main(void) {
+    struct rlimit no_core={0,0};
+    if(setrlimit(RLIMIT_CORE,&no_core))return 1;
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128)return 1;
+    uint8_t *storage=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(storage==MAP_FAILED||mprotect(storage+page,page,PROT_NONE))return 1;
+    memset(storage,0xa7,page);
+    protected_region=storage+page;
+    protected_bytes=(size_t)page;
+    unsigned observations=0;
+    for(unsigned row=0;row<sizeof(kernels)/sizeof(kernels[0]);row++) {
+        const struct kernel *k=&kernels[row];
+        if(k->legacy)continue; /* SSE's original aligned m128 opcode is a separate native axis. */
+        unsigned tuple=k->width;
+        if(full_tuple && (k->operation&2))tuple=k->bits/8;
+        if(observe(k,0,0,full_tuple || k->mode==0)||observe(k,0,UINT64_MAX,1)||
+            observe(k,storage+page-tuple,UINT64_MAX,0)||
+            observe(k,storage+page-tuple+1,UINT64_MAX,1)||
+            observe(k,storage+page-k->bits/8,1,full_tuple ? tuple>k->bits/8 : k->mode==0))return 1;
+        observations+=5;
+    }
+    if(observations!=` + fmt.Sprint(observations) + `)return 1;
+    return munmap(storage,2*page)!=0;
+}
+`
+		triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("discard=%t/%s", discard, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("complete typed packed source rejected", err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []int{0, 2} {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "average-e4-faults", triple, text, driver, nil, level)
+					}
+				}
+			})
+		}
+	}
+	t.Logf("all %d VEX/EVEX width/mask rows ×5 boundary controls ×live/dead results per backend, full-tuple=%t; portable LLVM, not native AVX512", observations/5, fullTuple)
+}
diff --git a/x86_packed_average_value_inputs_test.go b/x86_packed_average_value_inputs_test.go
new file mode 100644
index 000000000..49580847e
--- /dev/null
+++ b/x86_packed_average_value_inputs_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent complete Go ymm/Py1 and _yvandnpd inventory, not spec-map keys.
+func x86AverageValueRows(arch string) []struct{ op, bank, mode string } {
+	return x86FixedBinaryValueRows(arch, []string{"PAVGB", "PAVGW", "VPAVGB", "VPAVGW"})
+}
+
+func x86FixedBinaryValueRows(arch string, names []string) []struct{ op, bank, mode string } {
+	var rows []struct{ op, bank, mode string }
+	for _, op := range names {
+		banks := []string{"X", "Y", "Z"}
+		if !strings.HasPrefix(op, "V") {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if mode != "plain" && (arch == "386" || !strings.HasPrefix(op, "V")) {
+					continue // Actual named arity/legacy boundary, not a target skip.
+				}
+				rows = append(rows, struct{ op, bank, mode string }{op, bank, mode})
+			}
+		}
+	}
+	return rows
+}
+
+func x86AverageValueFixture(arch, op, bank, mode string, result bool) (string, string) {
+	return x86FixedBinaryValueFixture(arch, op, bank, mode, result)
+}
+
+func x86FixedBinaryValueFixture(arch, op, bank, mode string, result bool) (string, string) {
+	word, move, maskMove := 8, "MOVQ", "KMOVQ"
+	if arch == "386" {
+		word, move, maskMove = 4, "MOVL", "KMOVD"
+	}
+	instruction := op + " 3(AX)(DX*2)," + bank + "2"
+	if strings.HasPrefix(op, "V") {
+		mask := ""
+		if mode != "plain" {
+			mask = "K1,"
+		}
+		if mode == "zero" {
+			op += ".Z"
+		}
+		instruction = op + " 3(AX)(DX*2)," + bank + "1," + mask + bank + "2"
+	}
+	declaration, finish, extent := "func Value(p *[128]byte,mask uintptr)", "", 2*word
+	if result {
+		declaration += " uint32"
+		extent += 4
+		finish = fmt.Sprintf("PEXTRD $0,X2,AX\nMOVL AX,ret+%d(FP)\n", 2*word)
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\n%s CX,K1\n"+
+		"MOVL $1,DX\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\n%sRET\n",
+		extent, move, move, word, maskMove, instruction, finish), declaration
+}
+
+func TestX86PackedAverageValueCompleteFamilyFiveTargetsThreeAPIs(t *testing.T) {
+	x86FixedBinaryCompleteFamilyObjects(t, x86AverageValueRows, 20, 8)
+}
+
+func x86FixedBinaryCompleteFamilyObjects(t *testing.T, inventory func(string) []struct{ op, bank, mode string }, amd64Count, mode32Count int) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := inventory(target.arch)
+			want := amd64Count
+			if target.arch == "386" {
+				want = mode32Count
+			}
+			if len(rows) != want {
+				t.Fatal("complete original average family denominator changed", len(rows), want)
+			}
+			var source, declarations strings.Builder
+			var names []string
+			for _, row := range rows {
+				for _, result := range []bool{false, true} {
+					body, declaration := x86FixedBinaryValueFixture(target.arch, row.op, row.bank, row.mode, result)
+					name := fmt.Sprintf("AverageValue%d", len(names))
+					names = append(names, name)
+					source.WriteString(strings.ReplaceAll(body, "Value", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete average value source lost its native continuation", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedAverageVoidCannotInventRegisterInputs(t *testing.T) {
+	x86FixedBinaryVoidInputBoundaries(t, x86AverageValueRows)
+}
+
+func x86FixedBinaryVoidInputBoundaries(t *testing.T, inventory func(string) []struct{ op, bank, mode string }) {
+	t.Helper()
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range inventory(arch) {
+			if row.mode != "plain" {
+				continue // Separate native/mask roots retain the complete masked rows.
+			}
+			instruction := row.op + " " + row.bank + "1," + row.bank + "2"
+			if strings.HasPrefix(row.op, "V") {
+				instruction = row.op + " " + row.bank + "0," + row.bank + "1," + row.bank + "2"
+			}
+			for _, missing := range []string{"Z1", "Z2"} {
+				if strings.HasPrefix(row.op, "V") && missing == "Z2" {
+					missing = "Z0" // VEX destination is not an unmasked data input.
+				}
+				t.Run(arch+"/"+instruction+"/"+missing, func(t *testing.T) {
+					prefix := "TEXT ·Value(SB),4,$0-0\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+					valid := prefix + instruction + "\nRET\n"
+					unknown := strings.Replace(valid, fmt.Sprintf("VPXORD %s,%s,%s\n", missing, missing, missing), "", 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, valid, "func Value()", arch, triple, api); err != nil || ir == "" {
+							t.Fatal("fully initialized independent Void control rejected", api, err)
+						}
+						if ir, err := x86ScalarFPBitViewAPI(t, unknown, "func Value()", arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Error("Void average borrowed zeroed implementation inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedAverageNativeInputsStayIndependent(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, x86AverageValueRows)
+}
+
+func x86FixedBinaryNativeInputBoundaries(t *testing.T, inventory func(string) []struct{ op, bank, mode string }) {
+	t.Helper()
+	for _, row := range inventory("amd64") {
+		source, declaration := x86FixedBinaryValueFixture("amd64", row.op, row.bank, row.mode, true)
+		pkg := mustGoPackage(t, "value", "package value\n"+declaration)
+		file := mustParseX86RawReturn(t, source)
+		signatures, err := goSigsForAsmFile(pkg, file, func(name string) string {
+			return strings.TrimPrefix(name, "·")
+		}, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signatures["Value"], "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("declaration-only query borrowed paired native memory authority", row, err)
+		}
+		variants := map[string]string{
+			"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+			"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+			"numeric-pointer": strings.Replace(source, "MOVL $1,DX", "MOVL $42,AX\nMOVL $1,DX", 1),
+		}
+		if row.mode != "plain" {
+			variants["unknown-mask"] = strings.Replace(source, "KMOVQ CX,K1\n", "", 1)
+		}
+		if row.mode == "merge" || !strings.HasPrefix(row.op, "V") {
+			variants["unknown-destination"] = strings.Replace(source, "VPXORD Z2,Z2,Z2\n", "", 1)
+		}
+		if strings.HasPrefix(row.op, "V") {
+			variants["unknown-vector"] = strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+		}
+		for name, changed := range variants {
+			t.Run(row.op+"/"+row.bank+"/"+row.mode+"/"+name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if name == "numeric-pointer" {
+						if err != nil || ir == "" {
+							t.Fatal("complete NUM address lost its paired native access", api, err)
+						}
+						width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+						if strings.HasSuffix(row.op, ".BCST") {
+							base := strings.TrimSuffix(row.op, ".BCST")
+							width = 4
+							if strings.HasSuffix(base, "PD") || strings.HasSuffix(base, "Q") {
+								width = 8
+							}
+							if strings.Contains(base, "UNPCK") {
+								width = x86UnpackTestLaneBytes(base)
+							}
+						}
+						mnemonic := strings.ToLower(row.op)
+						// Go's legacy spellings retain their original hardware opcode.
+						if alias := map[string]string{
+							"PUNPCKLWL": "punpcklwd", "PUNPCKHWL": "punpckhwd",
+							"PUNPCKLLQ": "punpckldq", "PUNPCKHLQ": "punpckhdq",
+							"PMULULQ": "pmuludq", "PACKSSLW": "packssdw",
+							"PADDL": "paddd", "PSUBL": "psubd",
+						}[row.op]; alias != "" {
+							mnemonic = alias
+						}
+						if x86NumericNativeVolatileReadBytes(t, ir) != width &&
+							!(strings.Contains(ir, "asm sideeffect") && strings.Contains(ir, mnemonic) && strings.Contains(ir, "~{memory}")) {
+							t.Fatal("NUM address lost its exact native tuple or original access", row, api)
+						}
+						x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if name == "unknown-vector" || name == "unknown-destination" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("average acquired unknown memory/vector/mask inputs", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_average_value_runtime_test.go b/x86_packed_average_value_runtime_test.go
new file mode 100644
index 000000000..df3c15421
--- /dev/null
+++ b/x86_packed_average_value_runtime_test.go
@@ -0,0 +1,132 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86AverageValueRuntimeProgram(arch string) (string, string, string, string) {
+	return x86AverageValueRuntimeProgramWithResult(arch, false)
+}
+
+func x86AverageValueRuntimeProgramWithResult(arch string, discard bool) (string, string, string, string) {
+	return x86FixedBinaryValueRuntimeProgram(arch, discard, "Average", x86AverageValueRows, func(op string) (int, int) {
+		if strings.HasSuffix(op, "W") {
+			return 16, 0
+		}
+		return 8, 0
+	})
+}
+
+func x86FixedBinaryValueRuntimeProgram(arch string, discard bool, prefix string,
+	inventory func(string) []struct{ op, bank, mode string }, reference func(string) (int, int)) (string, string, string, string) {
+	word, move, maskMove, cWord := 8, "MOVQ", "KMOVQ", "uint64_t"
+	if arch == "386" {
+		word, move, maskMove, cWord = 4, "MOVL", "KMOVD", "uint32_t"
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	for index, row := range inventory(arch) {
+		name := fmt.Sprintf("%s%d", prefix, index)
+		instruction := row.op + " X0,X2"
+		setup, width, mode, legacy := "VMOVUPS (AX),Z0\n", 16, 0, 1
+		if strings.HasPrefix(row.op, "V") {
+			op, mask := row.op, ""
+			setup, legacy = "", 0
+			if row.bank == "Y" {
+				width = 32
+			} else if row.bank == "Z" {
+				width = 64
+			}
+			if row.mode != "plain" {
+				mask, mode = "K1,", 1
+			}
+			if row.mode == "zero" {
+				op, mode = op+".Z", 2
+			}
+			instruction = op + " (AX)," + row.bank + "1," + mask + row.bank + "2"
+		}
+		bits, operation := reference(row.op)
+		finish := "VMOVUPS Z2,(SI)\n"
+		if discard {
+			finish = "" // Preserve every source read and CF observation, discard only the numerical result.
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s a+0(FP),AX\n%s b+%d(FP),BX\n%s out+%d(FP),SI\n"+
+			"%s mask+%d(FP),CX\n%s CX,K1\nVMOVUPS (BX),Z1\nVMOVUPS (BX),Z2\n%sSTC\n%s\n%sSETCS 64(SI)\nRET\n",
+			name, 4*word, move, move, word, move, 2*word, move, 3*word, maskMove, setup, instruction, finish)
+		fmt.Fprintf(&declarations, "func %s(a,b,out *[65]byte,mask uintptr)\n", name)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,uint8_t*,uint8_t*,%s);\n", name, cWord)
+		fmt.Fprintf(&rows, "{%s,%d,%d,%d,%d,%d},\n", name, width, bits, mode, legacy, operation)
+	}
+	return source.String(), declarations.String(), prototypes.String(), rows.String()
+}
+
+func TestX86PackedAverageCompletePortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, cWord := "amd64", "uint64_t"
+	if strconv.IntSize == 32 {
+		arch, cWord = "386", "uint32_t"
+	}
+	source, declarations, prototypes, rows := x86AverageValueRuntimeProgram(arch)
+	x86LEAActualTargetGoObject(t, arch, map[string]string{"amd64": "x86_64-unknown-linux-gnu", "386": "i386-unknown-linux-gnu"}[arch], source)
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes +
+		"typedef " + cWord + " average_word;\n" + `
+struct kernel {void (*fn)(uint8_t*,uint8_t*,uint8_t*,average_word);unsigned width,bits,mode,legacy,operation;};
+static const struct kernel kernels[]={
+` + rows + `};
+int main(void) {
+    const average_word masks[]={0,1,(average_word)0xa55a9c63f00fc33cULL,(average_word)-1};
+    for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++)for(unsigned sample=0;sample<257;sample++) {
+        const struct kernel *p=&kernels[k];
+        uint8_t a[67],b[67],a_before[67],b_before[67],out[67],want[64];
+        for(unsigned i=0;i<67;i++){a[i]=(i*73+sample*29)^sample;b[i]=(i*47+sample*113)^(sample>>1);}
+        memcpy(a_before,a,67);memcpy(b_before,b,67);
+        for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+            memset(out,0xc3,67);
+            memcpy(want,b+1,64);
+            if(!p->legacy)memset(want+p->width,0,64-p->width);
+            unsigned bytes=p->bits/8;
+            for(unsigned lane=0;lane<p->width/bytes;lane++) {
+                unsigned at=lane*bytes;
+                if(p->mode && !(masks[m]>>lane&1)) {
+                    if(p->mode==2)memset(want+at,0,bytes);
+                    continue;
+                }
+                uint32_t left=a[at+1],right=b[at+1];
+                if(bytes==2){left|=(uint32_t)a[at+2]<<8;right|=(uint32_t)b[at+2]<<8;}
+                uint32_t average=(left+right+1)>>1;
+                want[at]=average;
+                if(bytes==2)want[at+1]=average>>8;
+            }
+            p->fn(a+1,b+1,out+1,masks[m]);
+            if(memcmp(out+1,want,64)||out[65]!=1||out[0]!=0xc3||out[66]!=0xc3||
+                memcmp(a,a_before,67)||memcmp(b,b_before,67)) {
+                fprintf(stderr,"average row=%u sample=%u mask=%u width=%u mode=%u legacy=%u\n",k,sample,m,p->width,p->mode,p->legacy);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil {
+				t.Fatal("complete initialized average execution source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "average-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+	t.Log("complete byte/word averages, full 64-byte aliases, merge/zero masks, CF and canaries; portable LLVM, not native AVX512")
+}
diff --git a/x86_packed_compare_lane_execution_test.go b/x86_packed_compare_lane_execution_test.go
new file mode 100644
index 000000000..3375afa1e
--- /dev/null
+++ b/x86_packed_compare_lane_execution_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// Every function initializes only one complete lane in each numerical input.
+// The other lanes remain unknown even though the translated operation covers
+// the original complete X/Y view. Memory operands still read their full tuple.
+func x86CompareLaneValueFixture(memoryForms bool) (string, string, string) {
+	var declarations, source, checks strings.Builder
+	for index, row := range x86CompareLaneCases() {
+		for _, memory := range []bool{false, true} {
+			if memory && !memoryForms {
+				continue
+			}
+			name := fmt.Sprintf("laneCompare%d_%t", index, memory)
+			fmt.Fprintf(&declarations, "func %s(a,b *[32]byte) uint32\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-20\nMOVQ a+0(FP),SI\nMOVQ b+8(FP),DI\n", name)
+			start := 16 - row.bytes
+			for offset := start; offset < 16; offset++ {
+				if !memory {
+					fmt.Fprintf(&source, "PINSRB $%d,%d(SI),X0\n", offset, offset)
+				}
+				fmt.Fprintf(&source, "PINSRB $%d,%d(DI),X%d\n", offset, offset, row.second())
+			}
+			first := row.bank + "0"
+			if memory {
+				first = "(SI)"
+			}
+			source.WriteString(row.instruction(first) + "\n")
+			fmt.Fprintf(&source, "PEXTRB $%d,X2,AX\nMOVL AX,ret+16(FP)\nRET\n", start)
+			fmt.Fprintf(&checks, "    if (checkLane(%s,\"%s\",%d,%d)) return 1;\n",
+				name, name, row.bytes, x86FloatAddSubBoolInt(strings.Contains(row.op, "GT")))
+		}
+	}
+	return declarations.String(), source.String(), checks.String()
+}
+
+func TestX86PackedCompareLaneCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("partial-lane comparison objects require LLVM22 llc")
+	}
+	declarations, source, _ := x86CompareLaneValueFixture(true)
+	if strings.Count(source, "TEXT ") != 48 {
+		t.Fatal("incomplete independent register/full-memory comparison family")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86PackedIntegerCompareAPI(t, source, declarations, "amd64", triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete partial-lane objects", err)
+				}
+				for _, optimized := range []bool{false, true} {
+					input := ir
+					if optimized {
+						input = x86UndefinedTrapOptimizedIR(t, input)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, input, level)
+					}
+				}
+			})
+		}
+	}
+}
+
+// This independent oracle compares unsigned bit patterns with sign-bit bias,
+// avoiding signed C overflow and implementation-defined signed conversion.
+// Plan9 GT compares its second operand against its first operand.
+const x86ComparePartialLaneOracle = `
+static uint64_t laneValue(const uint8_t *p, int bytes) {
+    uint64_t value = 0;
+    for (int i = 0; i < bytes; ++i) value |= (uint64_t)p[i] << (8*i);
+    return value;
+}
+
+static int checkLane(uint32_t (*fn)(const uint8_t *, const uint8_t *),
+                     const char *name, int bytes, int greater) {
+    const uint64_t sign = UINT64_C(1) << (8*bytes-1);
+    const uint64_t limit = bytes == 8 ? UINT64_MAX : (UINT64_C(1) << (8*bytes))-1;
+    const uint64_t values[] = {
+        0, 1, sign-1, sign, limit, UINT64_C(0x5555555555555555) & limit,
+        UINT64_C(0xaaaaaaaaaaaaaaaa) & limit
+    };
+    for (unsigned i = 0; i < sizeof(values)/sizeof(values[0]) + 8*bytes; ++i) {
+        uint64_t first = i < sizeof(values)/sizeof(values[0]) ? values[i] :
+            UINT64_C(1) << (i-sizeof(values)/sizeof(values[0]));
+        for (unsigned j = 0; j < sizeof(values)/sizeof(values[0]); ++j) {
+            uint64_t second = values[j];
+            for (int alignment = 0; alignment < 3; ++alignment) {
+                uint8_t aStorage[40], bStorage[40], savedA[40], savedB[40];
+                memset(aStorage,0xa7,sizeof(aStorage));
+                memset(bStorage,0xb9,sizeof(bStorage));
+                uint8_t *a = aStorage+alignment, *b = bStorage+alignment;
+                int start = 16-bytes;
+                for (int k = 0; k < bytes; ++k) {
+                    a[start+k] = (uint8_t)(first >> (8*k));
+                    b[start+k] = (uint8_t)(second >> (8*k));
+                }
+                memcpy(savedA,aStorage,sizeof(savedA));
+                memcpy(savedB,bStorage,sizeof(savedB));
+                uint64_t av = laneValue(a+start,bytes), bv = laneValue(b+start,bytes);
+                uint32_t want = (greater ? (bv ^ sign) > (av ^ sign) : av == bv) ? 255 : 0;
+                uint32_t got = fn(a,b);
+                if (got != want || memcmp(savedA,aStorage,sizeof(savedA)) ||
+                    memcmp(savedB,bStorage,sizeof(savedB))) {
+                    fprintf(stderr,"%s bytewidth%d first%llx second%llx got%u want%u\n",
+                            name,bytes,(unsigned long long)av,(unsigned long long)bv,got,want);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+
+func TestX86PackedCompareLanePortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("portable partial-lane comparisons require LLVM22 llc/clang")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	compiler := []string{clang}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal(err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	declarations, source, checks := x86CompareLaneValueFixture(false)
+	if strings.Count(source, "TEXT ") != 24 {
+		t.Fatal("incomplete independent portable comparison family")
+	}
+	var prototypes strings.Builder
+	for index := range x86CompareLaneCases() {
+		fmt.Fprintf(&prototypes, "extern uint32_t laneCompare%d_false(const uint8_t *,const uint8_t *);\n", index)
+	}
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() +
+		x86ComparePartialLaneOracle + "\nint main(void) {\n" + checks + "    return 0;\n}\n"
+	// Register EQ/GT lowering is portable LLVM. This is actual numerical
+	// execution on the host, not original-Go native x86/AVX execution credit.
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86PackedIntegerCompareAPI(t, source, declarations, "amd64", triple, api)
+		if err != nil || ir == "" {
+			t.Fatal("complete portable partial-lane source", api, err)
+		}
+		for _, optimized := range []bool{false, true} {
+			input := ir
+			if optimized {
+				input = x86UndefinedTrapOptimizedIR(t, input)
+			}
+			for _, level := range []int{0, 2} {
+				t.Run(fmt.Sprintf("%s/IR_O2=%t/backendO%d", api, optimized, level), func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, compiler,
+						"partial-compare-lanes", triple, input, driver, nil, level)
+				})
+			}
+		}
+	}
+}
diff --git a/x86_packed_compare_lane_test.go b/x86_packed_compare_lane_test.go
new file mode 100644
index 000000000..451fc8010
--- /dev/null
+++ b/x86_packed_compare_lane_test.go
@@ -0,0 +1,271 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86CompareLaneCase struct {
+	op, bank string
+	bytes    int
+	width    int
+	legacy   bool
+}
+
+// Independent of the implementation registry: ymm/yxm_q4 have eight X
+// members; _yvpcmpeqb has two vector-result rows for each of eight V names.
+// Its six EVEX K-result rows remain a different, complete-input domain.
+func x86CompareLaneCases() []x86CompareLaneCase {
+	var rows []x86CompareLaneCase
+	for _, family := range []struct {
+		legacy, vector string
+		bytes          int
+	}{
+		{"PCMPEQB", "VPCMPEQB", 1}, {"PCMPEQW", "VPCMPEQW", 2},
+		{"PCMPEQL", "VPCMPEQD", 4}, {"PCMPEQQ", "VPCMPEQQ", 8},
+		{"PCMPGTB", "VPCMPGTB", 1}, {"PCMPGTW", "VPCMPGTW", 2},
+		{"PCMPGTL", "VPCMPGTD", 4}, {"PCMPGTQ", "VPCMPGTQ", 8},
+	} {
+		rows = append(rows, x86CompareLaneCase{family.legacy, "X", family.bytes, 16, true})
+		rows = append(rows, x86CompareLaneCase{family.vector, "X", family.bytes, 16, false})
+		rows = append(rows, x86CompareLaneCase{family.vector, "Y", family.bytes, 32, false})
+	}
+	return rows
+}
+
+func (row x86CompareLaneCase) instruction(first string) string {
+	if row.legacy {
+		return row.op + " " + first + ",X2"
+	}
+	return row.op + " " + first + "," + row.bank + "1," + row.bank + "2"
+}
+
+func (row x86CompareLaneCase) second() int {
+	if row.legacy {
+		return 2
+	}
+	return 1
+}
+
+func TestX86PackedCompareLaneLoweringDefinedness(t *testing.T) {
+	if len(x86CompareLaneCases()) != 24 {
+		t.Fatal("incomplete independent legacy/VEX vector-result family")
+	}
+	for _, row := range x86CompareLaneCases() {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+row.op+"/"+row.bank, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction(row.bank+"0"))
+				full := uint64(1)<<uint(row.width) - 1
+				for input := 0; input < 2; input++ {
+					for missing := 0; missing < row.width; missing++ {
+						state := x86RawMoveInitializedState()
+						reg := 0
+						if input == 1 {
+							reg = row.second()
+						}
+						state.writeVector(reg, 64, ^(uint64(1) << uint(missing)), false)
+						before, expected := state, state
+						lane := (uint64(1)<<uint(row.bytes) - 1) << uint(missing/row.bytes*row.bytes)
+						expected.writeVector(2, row.width, full&^lane, row.legacy)
+						accepted, known := x86ResultVectorCompareStepWithRead(ins, &state, nil, arch, true)
+						if !known || !accepted || !reflect.DeepEqual(state, expected) {
+							t.Fatalf("input%d byte%d must invalidate exactly its complete comparison lane: accepted=%t known=%t", input, missing, accepted, known)
+						}
+						// A lowering-local numerical projection must not silently
+						// relax the standalone complete-input observer.
+						strict := before
+						if accepted, _ := x86ResultVectorCompareStep(ins, &strict, nil, arch); accepted || !reflect.DeepEqual(strict, before) {
+							t.Fatal("partial lowered bytes escaped into the standalone query")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86CompareLaneSource(row x86CompareLaneCase, memory bool) string {
+	var source strings.Builder
+	source.WriteString("TEXT ·query(SB),4,$0-12\nMOVQ input+0(FP),SI\n")
+	partial := 0
+	first := row.bank + "0"
+	if memory {
+		partial, first = row.second(), "(SI)"
+	} else if row.legacy {
+		source.WriteString("PXOR X2,X2\n")
+	} else {
+		fmt.Fprintf(&source, "VPXOR %s1,%s1,%s1\n", row.bank, row.bank, row.bank)
+	}
+	// Leave every other lane unknown; the final low-X lane works for both
+	// X and Y comparisons without inventing initialized upper-Y contents.
+	for offset := 0; offset < row.bytes; offset++ {
+		fmt.Fprintf(&source, "PINSRB $%d,%d(SI),X%d\n", 16-row.bytes+offset, offset, partial)
+	}
+	source.WriteString(row.instruction(first) + "\n")
+	fmt.Fprintf(&source, "PEXTRB $%d,X2,AX\nMOVL AX,ret+8(FP)\nRET\n", 16-row.bytes)
+	return source.String()
+}
+
+func TestX86PackedCompareLaneCompleteSelectedUses(t *testing.T) {
+	for _, row := range x86CompareLaneCases() {
+		for _, memory := range []bool{false, true} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%s/memory=%t/%s", row.op, row.bank, memory, api), func(t *testing.T) {
+					ir, err := x86PackedIntegerCompareAPI(t, x86CompareLaneSource(row, memory),
+						"func query(input *[32]byte) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("complete selected lane lost its actual input bytes", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedCompareLaneKeepsUnknownUses(t *testing.T) {
+	for _, row := range x86CompareLaneCases() {
+		for _, memory := range []bool{false, true} {
+			source := x86CompareLaneSource(row, memory)
+			partial := 0
+			if memory {
+				partial = row.second()
+			}
+			lastInsert := fmt.Sprintf("PINSRB $15,%d(SI),X%d\n", row.bytes-1, partial)
+			for _, change := range []struct{ name, source string }{
+				{"missing-lane-byte", strings.Replace(source, lastInsert, "", 1)},
+				{"unknown-lane", strings.Replace(source, fmt.Sprintf("PEXTRB $%d,X2,AX", 16-row.bytes), "PEXTRB $0,X2,AX", 1)},
+				{"full-vector-store", strings.Replace(source, "MOVL AX,ret+8(FP)", "MOVOU X2,(SI)\nMOVL AX,ret+8(FP)", 1)},
+				{"missing-native-address", strings.Replace(source, "MOVQ input+0(FP),SI\n", "", 1)},
+			} {
+				if change.source == source {
+					t.Fatal("negative mutation did not change its independent source", change.name)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/memory=%t/%s/%s", row.op, row.bank, memory, change.name, api), func(t *testing.T) {
+						ir, err := x86PackedIntegerCompareAPI(t, change.source,
+							"func query(input *[32]byte) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+						if change.name != "missing-native-address" {
+							x86VectorScratchCodegenControl(t, change.source, "func query(input *[32]byte) uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("partial comparison invented missing data or native address facts", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedCompareLaneRawAndKBoundaries(t *testing.T) {
+	var original []x86RawIntegerCompareOriginCase
+	for _, row := range x86CompareLaneCases() {
+		original = append(original, x86RawIntegerCompareOriginCase{row: row.instruction(row.bank + "0"),
+			bank: row.bank, destination: row.bank + "2", legacy: row.legacy})
+	}
+	codes := x86RawIntegerCompareOriginBytes(t, original)
+	for index, row := range x86CompareLaneCases() {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/raw/"+row.op+"/"+row.bank, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, codes[index])
+				state := x86RawMoveInitializedState()
+				state.xmm[0] &^= 1
+				before := state
+				if accepted, known := x86LoweredPackedIntegerCompareStep(ins, &state, nil, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("raw source projection borrowed the named partial-lane role")
+				}
+			})
+		}
+		if row.legacy || row.bank != "X" {
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, missingMask := range []bool{false, true} {
+				t.Run(fmt.Sprintf("K/%s/%s/missingmask=%t", row.op, bank, missingMask), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" "+bank+"0,"+bank+"1,K1,K2")
+					state := x86RawMoveInitializedState()
+					if missingMask {
+						state.masks[1] = false
+					} else {
+						state.xmm[0] &^= 1
+					}
+					before := state
+					if accepted, known := x86ResultVectorCompareStepWithRead(ins, &state, nil, "amd64", true); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("partial vector bytes or an unknown mask became a completely known K result")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedCompareLaneMemoryNeedsWholeTuple(t *testing.T) {
+	for _, row := range x86CompareLaneCases() {
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+row.op+"/"+row.bank, func(t *testing.T) {
+				for _, available := range []int64{0, int64(row.bytes), int64(row.width - 1)} {
+					ins := x86ScalarLaneInstruction(t, row.instruction("tuple<>(SB)"))
+					state := x86RawMoveInitializedState()
+					state.writeVector(row.second(), 64, uint64(1)<<uint(row.bytes)-1, false)
+					state.loweredStaticReads = map[x86StaticSBAddress]int64{{symbol: "tuple<>"}: available}
+					before := state
+					if accepted, known := x86ResultVectorCompareStepWithRead(ins, &state, nil, arch, true); !known || accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("a partial initialized result reduced the source's original full memory tuple", available)
+					}
+				}
+				ins := x86ScalarLaneInstruction(t, row.instruction("(SI)"))
+				state := x86RawMoveInitializedState()
+				state.writeVector(row.second(), 64, uint64(1)<<uint(row.bytes)-1, false)
+				state.pointerGP[6] = false // A paired native read needs bits, not a logical pointer.
+				before, expected := state.clone(), state.clone()
+				defined := uint64(1)<<uint(row.bytes) - 1
+				expected.writeVector(2, row.width, defined, row.legacy)
+				if accepted, known := x86ResultVectorCompareStepWithRead(ins, &state, nil, arch, true); !known || !accepted || !reflect.DeepEqual(state, expected) {
+					t.Fatal("numerical native comparison invented unrelated bytes or pointer facts")
+				}
+				for _, available := range []uint8{0, 1} {
+					partial := before.clone()
+					partial.gp[6] = available
+					unchanged := partial.clone()
+					if accepted, _ := x86ResultVectorCompareStepWithRead(ins, &partial, nil, arch, true); accepted || !reflect.DeepEqual(partial, unchanged) {
+						t.Fatal("partial comparison borrowed unknown or partial address bytes", available)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedCompareLaneProbeDoesNotProveResult(t *testing.T) {
+	count := 0
+	for _, row := range x86CompareLaneCases() {
+		if row.legacy {
+			continue
+		}
+		count++
+		t.Run(row.op+"/"+row.bank, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction(row.bank+"0"))
+			// The isolated void probe discards its result. Accepting that
+			// IR does not initialize either operand or any low result lane.
+			if err := ProbeInstruction(ArchAMD64, "amd64", ins); err != nil {
+				t.Fatal("unused vector result cannot be retained in IR", err)
+			}
+			memory := x86ScalarLaneInstruction(t, row.instruction("(SI)"))
+			if err := ProbeInstruction(ArchAMD64, "amd64", memory); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("discarding a result invented its memory address", err)
+			}
+			source := "TEXT ·query(SB),4,$0-4\n" + ins.Raw + "\n" +
+				"PEXTRB $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86PackedIntegerCompareAPI(t, source, "func query() uint32\n",
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				x86VectorScratchCodegenControl(t, source, "func query() uint32", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			}
+		})
+	}
+	if count != 16 {
+		t.Fatal("complete X/Y comparison probe family changed", count)
+	}
+}
diff --git a/x86_packed_conversion_object_partition_test.go b/x86_packed_conversion_object_partition_test.go
new file mode 100644
index 000000000..e16257294
--- /dev/null
+++ b/x86_packed_conversion_object_partition_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedConversionPublicObjectPartitionsComplete(t *testing.T) {
+	if x86PackedConversionObjectBatchSize != 48 || x86PackedConversionObjectOwners != 4 {
+		t.Fatal("complete object partition changed its bounded capture or owner inventory")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_packed_conversion_raw_objects_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	functions := make(map[string]*ast.FuncDecl)
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok {
+			functions[function.Name.Name] = function
+		}
+	}
+	owners := make(map[string]bool)
+	for _, target := range []struct{ name, arch, triple string }{
+		{"Linux386", "386", "i386-unknown-linux-gnu"},
+		{"Windows386", "386", "i686-pc-windows-msvc"},
+		{"LinuxAMD64", "amd64", "x86_64-unknown-linux-gnu"},
+		{"DarwinAMD64", "amd64", "x86_64-apple-darwin"},
+		{"WindowsAMD64", "amd64", "x86_64-pc-windows-msvc"},
+	} {
+		rows := x86PackedConversionContinuationRows(target.arch)
+		wantCount := 994
+		if target.arch == "386" {
+			wantCount = 928
+		}
+		if len(rows) != wantCount {
+			t.Fatal("complete original named/raw format denominator changed", target.arch, len(rows), wantCount)
+		}
+		members, unique := make(map[string]bool), make(map[string]bool)
+		seen := make([]int, len(rows))
+		for owner := 0; owner < 4; owner++ {
+			name := fmt.Sprintf("TestX86PackedConversionPublicObjects%sPart%d", target.name, owner)
+			owners[name] = true
+			function := functions[name]
+			if function == nil || function.Body == nil || len(function.Body.List) != 1 {
+				t.Fatal("missing or bypassed complete initialized object owner", name)
+			}
+			statement, ok := function.Body.List[0].(*ast.ExprStmt)
+			if !ok {
+				t.Fatal("object owner did not invoke its complete fixture", name)
+			}
+			call, ok := statement.X.(*ast.CallExpr)
+			if !ok || len(call.Args) != 4 {
+				t.Fatal("object owner changed its complete target/partition arguments", name)
+			}
+			callee, ok := call.Fun.(*ast.Ident)
+			if !ok || callee.Name != "x86PackedConversionPublicObjectOwner" {
+				t.Fatal("object owner did not invoke the real LLVM object driver", name)
+			}
+			argument, ok := call.Args[0].(*ast.Ident)
+			if !ok || argument.Name != "t" {
+				t.Fatal("object owner lost its actual test context", name)
+			}
+			for index, expected := range []string{strconv.Quote(target.arch), strconv.Quote(target.triple), strconv.Itoa(owner)} {
+				literal, ok := call.Args[index+1].(*ast.BasicLit)
+				if !ok || literal.Value != expected {
+					t.Fatal("object owner borrowed another architecture/partition", name, index)
+				}
+			}
+			for ordinal, row := range rows {
+				if ordinal/48%4 != owner {
+					continue
+				}
+				seen[ordinal]++
+				if unique[row] {
+					t.Fatal("duplicate complete named/raw row", target.name, row)
+				}
+				unique[row] = true
+				op, _, _ := strings.Cut(row, " ")
+				base, _, _ := strings.Cut(op, ".")
+				members[base] = true
+			}
+		}
+		for ordinal, count := range seen {
+			if count != 1 {
+				t.Fatal("complete row missing or owned twice", target.name, ordinal, count)
+			}
+		}
+		if len(unique) != len(rows) || len(members) != 42 {
+			t.Fatal("incomplete independent 4+38 initialized object union", target.name, len(unique), len(members))
+		}
+	}
+	for name := range functions {
+		if strings.HasPrefix(name, "TestX86PackedConversionPublicObjects") && !owners[name] {
+			t.Fatal("unregistered or duplicate initialized object owner", name)
+		}
+	}
+	driver := functions["x86PackedConversionPublicObjectOwner"]
+	if driver == nil || driver.Body == nil {
+		t.Fatal("missing real initialized object driver")
+	}
+	calls := make(map[string]int)
+	ast.Inspect(driver.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if callee, ok := call.Fun.(*ast.Ident); ok {
+			calls[callee.Name]++
+		}
+		if callee, ok := call.Fun.(*ast.SelectorExpr); ok &&
+			(callee.Sel.Name == "Skip" || callee.Sel.Name == "Skipf" || callee.Sel.Name == "SkipNow") {
+			t.Fatal("initialized object coverage cannot be replaced with a skip")
+		}
+		return true
+	})
+	for _, required := range []string{
+		"x86PackedConversionContinuationRawRows", "x86LEAActualTargetGoObject", "x86ScalarFPBitViewAPI",
+		"x86DwordProductIROptimize", "x86PackedStringCompileObject",
+	} {
+		if calls[required] != 1 {
+			t.Fatal("driver lost the actual Go/public/LLVM stage", required, calls[required])
+		}
+	}
+	t.Log("20 explicit owners cover every original initialized named/raw row on all five targets; object outcomes remain separately required")
+}
diff --git a/x86_packed_conversion_raw_continuation_test.go b/x86_packed_conversion_raw_continuation_test.go
new file mode 100644
index 000000000..c75e80859
--- /dev/null
+++ b/x86_packed_conversion_raw_continuation_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func TestX86PackedConversionOriginalInitializedNamedRawParity(t *testing.T) {
+	named := x86PackedDoubleDwordOriginalAssembly()
+	raw := x86PackedDoubleDwordRawAssembly(named)
+	if named == raw || strings.Count(raw, "BYTE $") != 20 {
+		t.Fatal("original four-conversion raw counterexample changed")
+	}
+	declaration := "func packeddoubledword(out *byte, doubles *float64, dwords *int32, old *float64, mask uint64)"
+	for _, source := range []string{named, raw} {
+		goAssemblerOracleOutput(t, "amd64", x86PackedDoubleDwordGoAssemblerSource(source), "", true)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			for _, spelling := range []struct{ name, source string }{{"named", named}, {"raw", raw}} {
+				ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Fatalf("same initialized original program, %s conversion identity only: %v", spelling.name, err)
+				}
+				// LLVM's narrowing memory spelling carries the physical Y
+				// source width; it is not the register-source base mnemonic.
+				for _, op := range []string{"vcvtdq2pd", "vcvttpd2dqy", "vcvtpd2dq", "cvtpd2dq"} {
+					if !strings.Contains(ir, op+" ") {
+						t.Fatal("original conversion opcode or exception obligation disappeared", spelling.name, op)
+					}
+				}
+			}
+		})
+	}
+}
+
+// The independent full Go inventories already bind every encoder attribute.
+// These rows join their complete register/memory, width, broadcast, mask and
+// rounding spellings to the same initialized public named/raw program.
+func x86PackedConversionContinuationRows(arch string) []string {
+	rows := append([]string(nil), x86PackedConversionOracleRows(arch)...)
+	for _, row := range x86SignedPackedValueRows() {
+		rows = append(rows, row.op+" "+row.input+","+row.mask+row.bank+"1")
+	}
+	return rows
+}
+
+func x86PackedConversionContinuationFixture(t *testing.T, name, arch, row string) (string, string) {
+	t.Helper()
+	word, move := 8, "MOVQ"
+	high := "VPXORD Z31,Z31,Z31\n"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+		high = ""
+	}
+	ins := x86ScalarLaneInstruction(t, row)
+	destination := ins.Args[len(ins.Args)-1].Reg
+	index := strings.TrimLeft(string(destination), "XYZ")
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n"+
+		"%s p+0(FP),BX\nMOVL $1,CX\nMOVL $1,DX\nKMOVD CX,K1\nKMOVD CX,K7\n"+
+		"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z7,Z7,Z7\n"+
+		"%sSTC\n%s\nVPEXTRD $0,X%s,CX\nMOVL CX,ret+%d(FP)\nRET\n",
+		name, word+4, move, move, high, row, index, word), fmt.Sprintf("func %s(p *byte) uint32\n", name)
+}
+
+func x86PackedConversionContinuationRawRows(t *testing.T, arch string, rows []string) []string {
+	t.Helper()
+	code := x86PackedShiftActualGoBytes(t, arch, "TEXT raw(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\n")
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	var raw []string
+	position := 0
+	for _, row := range rows {
+		_, length, known, err := decodedX86PackedNumericConversionInstruction(code[position:], mode)
+		if !known {
+			_, length, known, err = decodedX86SameWidthConversionInstruction(code[position:], mode)
+		}
+		if !known {
+			_, length, known, err = decodedX86PackedDoubleDwordInstruction(code[position:], mode)
+		}
+		if !known {
+			instruction, decodeErr := x86asm.Decode(code[position:], mode)
+			length, err = instruction.Len, decodeErr
+		}
+		if err != nil || length < 1 || length > len(code)-position {
+			t.Fatal("original complete conversion byte boundary", row, err)
+		}
+		raw = append(raw, strings.TrimSuffix(x86RawDisplacementDirectives(code[position:position+length]), "\n"))
+		position += length
+	}
+	if position != len(code) {
+		t.Fatal("unconsumed original conversion bytes", position, len(code))
+	}
+	return raw
+}
diff --git a/x86_packed_conversion_raw_effects_test.go b/x86_packed_conversion_raw_effects_test.go
new file mode 100644
index 000000000..a81e8aacf
--- /dev/null
+++ b/x86_packed_conversion_raw_effects_test.go
@@ -0,0 +1,338 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86PackedConversionContinuationOracle struct {
+	input, active, destination int
+	legacy, merge              bool
+}
+
+// Expected byte widths come from the independent Go/Intel test inventories,
+// never the production typed forms or the raw adapter under test.
+func x86PackedConversionContinuationEffect(t *testing.T, ins Instr) x86PackedConversionContinuationOracle {
+	t.Helper()
+	base, _, _ := strings.Cut(string(ins.Op), ".")
+	destination := amd64VectorByteWidth(ins.Args[len(ins.Args)-1].Reg)
+	merge := len(ins.Args) == 3 && !strings.HasSuffix(string(ins.Op), ".Z")
+	for _, spec := range x86PackedConversionOracleSpecs() {
+		if spec.name != base {
+			continue
+		}
+		for _, shape := range spec.shapes() {
+			if shape.destination == destination {
+				return x86PackedConversionContinuationOracle{
+					input: shape.lanes * spec.input / 8, active: shape.lanes * spec.output / 8,
+					destination: destination, legacy: spec.legacy, merge: merge,
+				}
+			}
+		}
+		t.Fatal("independent conversion shape missing", ins.Raw)
+	}
+	switch base {
+	case "CVTPL2PS", "VCVTDQ2PS":
+		return x86PackedConversionContinuationOracle{destination, destination, destination, base == "CVTPL2PS", merge}
+	case "CVTPL2PD", "VCVTDQ2PD":
+		return x86PackedConversionContinuationOracle{destination / 2, destination, destination, base == "CVTPL2PD", merge}
+	}
+	t.Fatal("independent 42-member inventory missing", ins.Raw)
+	return x86PackedConversionContinuationOracle{}
+}
+
+func x86PackedConversionContinuationInstructions(t *testing.T, arch string, rows []string) []Instr {
+	t.Helper()
+	raw := x86PackedConversionContinuationRawRows(t, arch, rows)
+	file := mustParseX86RawReturn(t, "TEXT f(SB),4,$0-0\n"+strings.Join(raw, "\n")+"\nRET\n")
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil || len(normalized.Funcs[0].Instrs) != len(rows)+2 {
+		t.Fatal("whole original conversion stream lost its exact row boundaries", arch, err)
+	}
+	return normalized.Funcs[0].Instrs[1 : len(rows)+1]
+}
+
+func x86PackedConversionContinuationState() x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	state.pointerGP[0], state.pointerGP[3] = true, true
+	state.callerAddressGP[0], state.callerAddressGP[3] = true, true
+	state.gp[1], state.gp[2], state.gp[6] = 0xff, 0xff, 0x5a
+	state.masks[1], state.masks[7] = true, true
+	state.valueStack = &x86ResultValueStack{bytes: []uint8{0xa5, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, id: true}
+	for index := 0; index < 32; index++ {
+		state.writeVector(index, 64, ^uint64(0), true)
+	}
+	return state
+}
+
+func TestX86PackedConversionRawEveryInputMaskAndMergeByte(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86PackedConversionContinuationRows(arch)
+			for ordinal, ins := range x86PackedConversionContinuationInstructions(t, arch, rows) {
+				oracle := x86PackedConversionContinuationEffect(t, ins)
+				destination, valid := amd64VectorRegisterIndex(ins.Args[len(ins.Args)-1].Reg, oracle.destination)
+				if !valid || !x86RawPackedConversionSource(ins, arch) {
+					t.Fatal("fresh actual-Go conversion has no exact source identity", rows[ordinal])
+				}
+				state := x86PackedConversionContinuationState()
+				want := state.clone()
+				want.writeVector(destination, oracle.destination, x86CallerVectorByteMask(int64(oracle.destination)), oracle.legacy)
+				accepted, known := x86LoweredPackedConversionResultStep(ins, &state, nil, arch)
+				if !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("conversion changed independent state or lost architectural zero padding/aliases", rows[ordinal], accepted, known)
+				}
+				for _, register := range []int{0, 1, 7, 31} {
+					required := uint64(0)
+					if source := ins.Args[0]; source.Kind == OpReg {
+						index, _ := amd64VectorRegisterIndex(source.Reg, amd64VectorByteWidth(source.Reg))
+						if index == register {
+							required |= x86CallerVectorByteMask(int64(oracle.input))
+						}
+					}
+					if oracle.merge && destination == register {
+						required |= x86CallerVectorByteMask(int64(oracle.active))
+					}
+					for missing := 0; missing < 64; missing++ {
+						rejected := x86PackedConversionContinuationState()
+						rejected.writeVector(register, 64, ^(uint64(1) << uint(missing)), true)
+						before := rejected.clone()
+						accepted, known := x86LoweredPackedConversionResultStep(ins, &rejected, nil, arch)
+						if !known || accepted != (required&(uint64(1)<<uint(missing)) == 0) ||
+							!accepted && !reflect.DeepEqual(rejected, before) {
+							t.Fatal("raw conversion borrowed a missing source/merge byte or changed rejected state", rows[ordinal], register, missing)
+						}
+					}
+				}
+				if len(ins.Args) == 3 {
+					mask, _ := amd64ParseKReg(ins.Args[1].Reg)
+					state := x86PackedConversionContinuationState()
+					state.masks[mask] = false
+					before := state.clone()
+					if accepted, known := x86LoweredPackedConversionResultStep(ins, &state, nil, arch); accepted || !known || !reflect.DeepEqual(state, before) {
+						t.Fatal("raw conversion invented an actual writemask", rows[ordinal])
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedConversionRawIdentityAndNativeBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			rows := x86PackedConversionContinuationRows(arch)
+			for ordinal, original := range x86PackedConversionContinuationInstructions(t, arch, rows) {
+				for _, mutation := range []string{
+					"origin", "absent-physical-identity", "foreign-mode", "opcode", "source", "destination", "mask",
+					"vector-width", "address-size", "unbound-address", "segment", "literal", "native-return", "numerical-read",
+					"EVEX-generation", "MMX-state", "encoded-bit", "standalone", "native-pointer", "numeric-address", "index",
+				} {
+					ins := cloneX86ReplayInstrs([]Instr{original})[0]
+					state := x86PackedConversionContinuationState()
+					switch mutation {
+					case "origin":
+						ins.x86SourceRaw = nil
+					case "absent-physical-identity":
+						ins.x86SourceRaw.packedConversion = x86RawPackedConversionIdentity{}
+					case "foreign-mode":
+						ins.x86SourceRaw.packedConversion.arch = map[string]string{"386": "amd64", "amd64": "386"}[arch]
+					case "opcode":
+						ins.Op = "CVTPL2PS"
+						if original.Op == ins.Op {
+							ins.Op = "CVTPL2PD"
+						}
+					case "source":
+						if ins.Args[0].Kind == OpMem {
+							ins.Args[0].Mem.Off++
+						} else {
+							ins.Args[0].Reg = Reg(string(ins.Args[0].Reg)[:1] + "6")
+						}
+					case "destination":
+						last := len(ins.Args) - 1
+						ins.Args[last].Reg = Reg(string(ins.Args[last].Reg)[:1] + "6")
+					case "mask":
+						if len(ins.Args) != 3 {
+							continue
+						}
+						ins.Args[1].Reg = "K2"
+					case "vector-width":
+						ins.x86VectorBytes ^= 16
+					case "address-size":
+						ins.x86AddressBits = 16
+					case "unbound-address":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "literal":
+						ins.x86RIPLiteral = true
+					case "native-return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "numerical-read":
+						ins.x86NumericalRead = new(x86NumericalReadCertificate)
+					case "EVEX-generation":
+						ins.x86PackedNumericEVEX = !ins.x86PackedNumericEVEX
+					case "MMX-state":
+						ins.x86MMXSourceConversion = !ins.x86MMXSourceConversion
+					case "encoded-bit":
+						ins.x86Encoded = !ins.x86Encoded
+					case "native-pointer", "numeric-address", "index":
+						if ins.Args[0].Kind != OpMem {
+							continue
+						}
+						base, _, valid := x86ResultGP(ins.Args[0].Mem.Base, x86ResultPointerWord(arch), arch)
+						if !valid {
+							t.Fatal("independent native source lost its GP base", rows[ordinal])
+						}
+						if mutation == "index" {
+							if ins.Args[0].Mem.Index == "" {
+								continue
+							}
+							index, _, valid := x86ResultGP(ins.Args[0].Mem.Index, x86ResultPointerWord(arch), arch)
+							if !valid {
+								t.Fatal("independent native source lost its numerical index", rows[ordinal])
+							}
+							state.gp[index] = 0
+						} else {
+							state.pointerGP[base] = false
+							if mutation == "numeric-address" {
+								state.gp[base] = 0xff
+							}
+						}
+					}
+					before := state.clone()
+					var accepted, known bool
+					if mutation == "standalone" {
+						accepted, known = x86ResultSignedPackedFloatStep(ins, &state, nil, arch, false)
+						if !known {
+							accepted, known = x86ResultPackedConversionStep(ins, &state, nil, arch)
+						}
+					} else {
+						accepted, known = x86LoweredPackedConversionResultStep(ins, &state, nil, arch)
+					}
+					// Some original legacy/VEX decoder forms have no encoded
+					// grammar relaxation. Removing their sole raw-origin marker
+					// makes a real named instruction, which this raw-only adapter
+					// must leave to the independent strict named effect.
+					becameNamed := mutation == "origin" && x86ResultNamedPredicateInstruction(ins)
+					if mutation == "numeric-address" {
+						oracle := x86PackedConversionContinuationEffect(t, ins)
+						destination, valid := amd64VectorRegisterIndex(ins.Args[len(ins.Args)-1].Reg, oracle.destination)
+						if !valid {
+							t.Fatal("independent conversion destination missing")
+						}
+						want := before.clone()
+						want.writeVector(destination, oracle.destination, x86CallerVectorByteMask(int64(oracle.destination)), oracle.legacy)
+						if !accepted || !known || !reflect.DeepEqual(state, want) {
+							t.Fatal("numeric conversion address changed independent effects", rows[ordinal], accepted, known)
+						}
+						continue
+					}
+					if accepted || known == becameNamed || !reflect.DeepEqual(before, state) {
+						t.Fatal("conversion borrowed physical identity, native backing or standalone authority", rows[ordinal], mutation, accepted, known)
+					}
+					if becameNamed {
+						accepted, known = x86ResultSignedPackedFloatStep(ins, &state, nil, arch, false)
+						if !known {
+							accepted, known = x86ResultPackedConversionStep(ins, &state, nil, arch)
+						}
+						// Only an initialized register input is a standalone
+						// positive; native memory still has no paired reader.
+						if !known || accepted != (ins.Args[0].Kind == OpReg) || x86RawPackedConversionSource(ins, arch) {
+							t.Fatal("removed origin confused the raw-only and strict named effects", rows[ordinal], accepted, known)
+						}
+					}
+				}
+				copy := cloneX86ReplayInstrs([]Instr{original})[0]
+				copy.x86SourceRaw.packedConversion.evex = !copy.x86SourceRaw.packedConversion.evex
+				copy.x86SourceRaw.args[0] = Operand{}
+				if !x86RawPackedConversionSource(original, arch) {
+					t.Fatal("mutable replay clone changed original physical identity", rows[ordinal])
+				}
+				if !x86ResultPreservesPrivateStorage(original, arch) || x86PreservesNumericalSourceState(original) ||
+					x86ResultDirectionAfterSource(original, x86ResultDirectionEither, arch) != x86ResultDirectionEither ||
+					x86ResultDirectionAfter(original, x86ResultDirectionEither) != x86ResultDirectionUnknown {
+					t.Fatal("conversion confused source-state preservation with inert numerical or standalone authority", rows[ordinal])
+				}
+				state := x86PackedConversionContinuationState()
+				if x86ResultCallerAddressesAfter(original, state.callerAddressGP, nil, arch) != state.callerAddressGP ||
+					!x86ResultValueStackContinuation(original, &state, arch) {
+					t.Fatal("exact conversion revoked independent address or private-storage facts", rows[ordinal])
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedConversionRawVoidAndUnusedBoolNeedInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var rows []string
+		// Use each independent source shape, rather than guessing X for
+		// narrowing members whose source is Y/Z.
+		bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+		for _, spec := range x86PackedConversionOracleSpecs() {
+			shape := spec.shapes()[0]
+			rows = append(rows, spec.name+" "+bank[shape.source]+"0,"+bank[shape.destination]+"1")
+		}
+		for _, op := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+			rows = append(rows, op+" X0,X1")
+		}
+		if len(rows) != 42 {
+			t.Fatal("missing independent dead conversion member", len(rows))
+		}
+		rawRows := x86PackedConversionContinuationRawRows(t, arch, rows)
+		for index, raw := range rawRows {
+			for _, signature := range []struct{ name, extent, declaration string }{
+				{"Void", "0", "func Value()"},
+				{"unusedBool", "1", "func Value(unused bool)"},
+			} {
+				source := "TEXT ·Value(SB),4,$0-" + signature.extent + "\n" + raw + "\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, signature.declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("raw dead conversion acquired missing input bytes", arch, rows[index], signature.name, api, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedConversionOriginalRawPhysicalMetadata(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, code := range [][]byte{
+			{0x62, 0xf1, 0x7c, 0x08, 0x5b, 0xc8},
+			{0x62, 0xf1, 0x7e, 0x08, 0xe6, 0xc8},
+			{0x0f, 0x2a, 0x00}, {0x66, 0x0f, 0x2a, 0x00},
+		} {
+			file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+			normalized, err := normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal("original physical conversion identity", arch, fmt.Sprintf("%x", code), err)
+			}
+			ins := normalized.Funcs[0].Instrs[1]
+			wantMMX := code[0] != 0x62
+			origin := ins.x86SourceRaw
+			if origin == nil || origin.packedConversion.arch != arch || origin.packedConversion.evex == wantMMX ||
+				origin.packedConversion.mmx != wantMMX || ins.x86PackedNumericEVEX == wantMMX || ins.x86MMXSourceConversion != wantMMX {
+				t.Fatal("physical EVEX/MMX generation was inferred from a false default or lost", arch, ins)
+			}
+			if x86RawPackedConversionSource(ins, arch) == wantMMX {
+				t.Fatal("physical MMX source gained an SSE/native numerical continuation", arch, ins)
+			}
+			if err := normalized.Funcs[0].x86RawReplay.validate(normalized.Funcs[0], arch); err != nil {
+				t.Fatal("fresh complete raw replay missing", err)
+			}
+			changed := normalized.Funcs[0]
+			changed.Instrs = cloneX86ReplayInstrs(changed.Instrs)
+			changed.Instrs[1].x86SourceRaw.packedConversion.evex = !origin.packedConversion.evex
+			if changed.x86RawReplay.validate(changed, arch) == nil ||
+				normalized.Funcs[0].x86RawReplay.validate(normalized.Funcs[0], arch) != nil {
+				t.Fatal("changed physical metadata borrowed or mutated immutable whole-source replay")
+			}
+		}
+	}
+}
diff --git a/x86_packed_conversion_raw_objects_test.go b/x86_packed_conversion_raw_objects_test.go
new file mode 100644
index 000000000..341478aaa
--- /dev/null
+++ b/x86_packed_conversion_raw_objects_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const (
+	x86PackedConversionObjectBatchSize = 48
+	x86PackedConversionObjectOwners    = 4
+)
+
+// Scheduling alone is partitioned. Every original row retains initialized
+// named/raw functions, all public APIs and three real LLVM22 object paths.
+// Each synchronous capture owns at most48 functions and releases its objects.
+func x86PackedConversionPublicObjectOwner(t *testing.T, arch, triple string, owner int) {
+	t.Helper()
+	if owner < 0 || owner >= x86PackedConversionObjectOwners {
+		t.Fatal("invalid complete conversion object owner", owner)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86PackedConversionContinuationRows(arch)
+	rawRows := x86PackedConversionContinuationRawRows(t, arch, rows)
+	consumed := 0
+	for batch, start := 0, 0; start < len(rows); batch, start = batch+1, start+x86PackedConversionObjectBatchSize {
+		if batch%x86PackedConversionObjectOwners != owner {
+			continue
+		}
+		end := start + x86PackedConversionObjectBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%04d", start), func(t *testing.T) {
+			var named, raw, declarations strings.Builder
+			for index := start; index < end; index++ {
+				name := fmt.Sprintf("Conversion%d", index)
+				body, declaration := x86PackedConversionContinuationFixture(t, name, arch, rows[index])
+				named.WriteString(body)
+				raw.WriteString(strings.Replace(body, rows[index]+"\n", rawRows[index]+"\n", 1))
+				declarations.WriteString(declaration)
+			}
+			for _, spelling := range []struct{ name, source string }{{"named", named.String()}, {"raw", raw.String()}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, triple, spelling.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations.String(), arch, triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized complete conversion lost its original public path", err)
+							}
+							optimized := x86DwordProductIROptimize(t, ir)
+							for _, pipeline := range []struct{ name, ir, backend string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									if strings.Count(pipeline.ir, "asm sideeffect") != end-start ||
+										strings.Contains(pipeline.ir, " fptosi ") || strings.Contains(pipeline.ir, " fptoui ") {
+										t.Fatal("complete conversion lost native MXCSR/exception or dead effects")
+									}
+									x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.backend)
+								})
+							}
+						})
+					}
+				})
+			}
+			consumed += end - start
+		})
+	}
+	if consumed == 0 {
+		t.Fatal("empty initialized conversion object owner", owner)
+	}
+	t.Logf("%d/%d original rows owned here; named+raw,3 APIs,3 actual LLVM22 object paths, no runtime claim", consumed, len(rows))
+}
+
+func TestX86PackedConversionPublicObjectsLinux386Part0(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i386-unknown-linux-gnu", 0)
+}
+
+func TestX86PackedConversionPublicObjectsLinux386Part1(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i386-unknown-linux-gnu", 1)
+}
+
+func TestX86PackedConversionPublicObjectsLinux386Part2(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i386-unknown-linux-gnu", 2)
+}
+
+func TestX86PackedConversionPublicObjectsLinux386Part3(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i386-unknown-linux-gnu", 3)
+}
+
+func TestX86PackedConversionPublicObjectsWindows386Part0(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i686-pc-windows-msvc", 0)
+}
+
+func TestX86PackedConversionPublicObjectsWindows386Part1(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i686-pc-windows-msvc", 1)
+}
+
+func TestX86PackedConversionPublicObjectsWindows386Part2(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i686-pc-windows-msvc", 2)
+}
+
+func TestX86PackedConversionPublicObjectsWindows386Part3(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "386", "i686-pc-windows-msvc", 3)
+}
+
+func TestX86PackedConversionPublicObjectsLinuxAMD64Part0(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-unknown-linux-gnu", 0)
+}
+
+func TestX86PackedConversionPublicObjectsLinuxAMD64Part1(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-unknown-linux-gnu", 1)
+}
+
+func TestX86PackedConversionPublicObjectsLinuxAMD64Part2(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-unknown-linux-gnu", 2)
+}
+
+func TestX86PackedConversionPublicObjectsLinuxAMD64Part3(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-unknown-linux-gnu", 3)
+}
+
+func TestX86PackedConversionPublicObjectsDarwinAMD64Part0(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-apple-darwin", 0)
+}
+
+func TestX86PackedConversionPublicObjectsDarwinAMD64Part1(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-apple-darwin", 1)
+}
+
+func TestX86PackedConversionPublicObjectsDarwinAMD64Part2(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-apple-darwin", 2)
+}
+
+func TestX86PackedConversionPublicObjectsDarwinAMD64Part3(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-apple-darwin", 3)
+}
+
+func TestX86PackedConversionPublicObjectsWindowsAMD64Part0(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-pc-windows-msvc", 0)
+}
+
+func TestX86PackedConversionPublicObjectsWindowsAMD64Part1(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-pc-windows-msvc", 1)
+}
+
+func TestX86PackedConversionPublicObjectsWindowsAMD64Part2(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-pc-windows-msvc", 2)
+}
+
+func TestX86PackedConversionPublicObjectsWindowsAMD64Part3(t *testing.T) {
+	x86PackedConversionPublicObjectOwner(t, "amd64", "x86_64-pc-windows-msvc", 3)
+}
+
+func TestX86PackedConversionOriginalLowBankEVEXObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, member := range []struct {
+				row  string
+				code []byte
+			}{
+				{"VCVTDQ2PS X0,X1", []byte{0x62, 0xf1, 0x7c, 0x08, 0x5b, 0xc8}},
+				{"VCVTDQ2PD X0,X1", []byte{0x62, 0xf1, 0x7e, 0x08, 0xe6, 0xc8}},
+			} {
+				body, declaration := x86PackedConversionContinuationFixture(t, fmt.Sprintf("OriginalEVEX%d", index), target.arch, member.row)
+				source.WriteString(strings.Replace(body, member.row+"\n", x86RawDisplacementDirectives(member.code), 1))
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || strings.Count(ir, "{evex} vcvtdq2p") != 2 || !strings.Contains(ir, "+avx512vl") {
+					t.Fatal("low-bank original EVEX became VEX or borrowed sibling features", api, err)
+				}
+				for _, pipeline := range []struct{ ir, backend string }{
+					{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+				} {
+					if strings.Count(pipeline.ir, "{evex} vcvtdq2p") != 2 {
+						t.Fatal("IR optimization erased physical EVEX opcode identity", api)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.backend)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_packed_float_shuffle_format_test.go b/x86_packed_float_shuffle_format_test.go
new file mode 100644
index 000000000..7ab6fbb59
--- /dev/null
+++ b/x86_packed_float_shuffle_format_test.go
@@ -0,0 +1,30 @@
+package plan9asm
+
+import "testing"
+
+// Keep each original uninitialized format source and its actual Go object.
+// Three public APIs must retain Context; the direct family emitter supplies
+// only operand/backend objects, never numerical or native-entry permission.
+func x86PackedFloatShuffleUnboundFormatObject(t *testing.T, source, arch, triple string, want int) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	count := 0
+	for _, function := range file.Funcs {
+		for _, instruction := range function.Instrs {
+			if instruction.Op == OpTEXT || instruction.Op == OpRET {
+				continue
+			}
+			if _, known, err := x86PackedFloatShuffleProperties(instruction.Op, instruction, arch); !known || err != nil {
+				t.Fatal("original complete floating-shuffle format row disappeared", instruction.Raw, err)
+			}
+			count++
+		}
+	}
+	if count != want {
+		t.Fatal("complete original floating-shuffle format denominator changed", count, want)
+	}
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return c.lowerPackedFloatShuffle(instruction.Op, instruction)
+		})
+}
diff --git a/x86_packed_float_shuffle_official_test.go b/x86_packed_float_shuffle_official_test.go
new file mode 100644
index 000000000..9509fa87f
--- /dev/null
+++ b/x86_packed_float_shuffle_official_test.go
@@ -0,0 +1,173 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedFloatShuffleCompleteOfficialRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	pattern := regexp.MustCompile(`\{A(SHUFPS|SHUFPD), (\w+), (\w+), opBytes\{([^}]+)\}\}`)
+	rows := pattern.FindAllStringSubmatch(string(legacy), -1)
+	definition := regexp.MustCompile(`(?s)var yxshuf = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(legacy))
+	if len(rows) != 2 || len(definition) != 2 || strings.Join(strings.Fields(definition[1]), "") != "{Zibm_r,2,argList{Yu8,Yxm,Yxr}}," {
+		t.Fatal("complete legacy unsigned-immediate two-source grammar changed", rows)
+	}
+	for _, row := range rows {
+		prefix := "Pm"
+		if row[1] == "SHUFPD" {
+			prefix = "Pq"
+		}
+		if row[2] != "yxshuf" || row[3] != prefix || strings.Join(strings.Fields(row[4]), "") != "0xc6,00" {
+			t.Fatal("unmodeled original legacy opcode/prefix", row)
+		}
+		for _, arch := range []string{"386", "amd64"} {
+			goAssemblerOracleOutput(t, arch, "TEXT Prior(SB),4,$0-0\n"+row[1]+" $255,(AX),X1\nRET\n", "", true)
+		}
+	}
+
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := [][]string{
+		{"Yu8", "Yxm", "Yxr", "Yxr"}, {"Yu8", "Yym", "Yyr", "Yyr"},
+		{"Yu8", "YxmEvex", "YxrEvex", "YxrEvex"}, {"Yu8", "YxmEvex", "YxrEvex", "Yknot0", "YxrEvex"},
+		{"Yu8", "YymEvex", "YyrEvex", "YyrEvex"}, {"Yu8", "YymEvex", "YyrEvex", "Yknot0", "YyrEvex"},
+		{"Yu8", "Yzm", "Yzr", "Yzr"}, {"Yu8", "Yzm", "Yzr", "Yknot0", "Yzr"},
+	}
+	counts := map[string]int{}
+	var source strings.Builder
+	for _, rule := range rules {
+		if rule.Opcode != "VSHUFPS" && rule.Opcode != "VSHUFPD" {
+			continue
+		}
+		index := rule.RowIndex
+		offsets, advances := []int{0, 2, 4, 4, 7, 7, 10, 10}, []int{2, 2, 0, 3, 0, 3, 0, 3}
+		if index < 0 || index >= 8 || rule.Ytab != "_yvgf2p8affineinvqb" || rule.Prefix != "Pavx" ||
+			!reflect.DeepEqual(rule.Classes, classes[index]) || rule.EncodingOffset != offsets[index] || rule.ZOffset != advances[index] || len(rule.OpBytes) != 13 {
+			t.Fatal("unmodeled complete official vector-shuffle row", rule)
+		}
+		generation, bits, zcase := "vex", "128", "Zvex_i_rm_v_r"
+		if index == 1 || index == 4 || index == 5 {
+			bits = "256"
+		} else if index >= 6 {
+			bits = "512"
+		}
+		if index >= 2 {
+			generation, zcase = "evex", "Zevex_i_rm_v_r"
+			if index%2 == 1 {
+				zcase = "Zevex_i_rm_v_k_r"
+			}
+		}
+		terms := []string{"avxEscape", generation + bits}
+		if rule.Opcode == "VSHUFPD" {
+			terms = append(terms, generation+"66")
+		}
+		w := "0"
+		if generation == "evex" && rule.Opcode == "VSHUFPD" {
+			w = "1"
+		}
+		terms = append(terms, generation+"0F", generation+"W"+w)
+		opcode := offsets[index] + 1
+		if rule.ZCase != zcase || !reflect.DeepEqual(strings.Split(rule.OpBytes[offsets[index]], " | "), terms) {
+			t.Fatal("complete generation/W/prefix opcode identity changed", rule)
+		}
+		if generation == "evex" {
+			broadcast := "4"
+			if rule.Opcode == "VSHUFPD" {
+				broadcast = "8"
+			}
+			attributes := "evexN" + map[string]string{"128": "16", "256": "32", "512": "64"}[bits] +
+				" | evexBcstN" + broadcast + " | evexZeroingEnabled"
+			if rule.OpBytes[opcode] != attributes {
+				t.Fatal("complete source/broadcast/masking tuple changed", rule)
+			}
+			opcode++
+		}
+		if strings.ToLower(rule.OpBytes[opcode]) != "0xc6" {
+			t.Fatal("original full shuffle opcode changed", rule)
+		}
+		bank, destination, mask := map[string]string{"128": "X", "256": "Y", "512": "Z"}[bits], 2, ""
+		if generation == "evex" && bits != "512" {
+			destination = 18 // Independently force the unmasked EVEX row.
+		}
+		if len(rule.Classes) == 5 {
+			mask = "K1,"
+		}
+		fmt.Fprintf(&source, "TEXT Prior%s%d(SB),4,$0-0\n%s $255,%s0,%s1,%s%s%d\nRET\n",
+			rule.Opcode, index, rule.Opcode, bank, bank, mask, bank, destination)
+		counts[rule.Opcode]++
+	}
+	if counts["VSHUFPS"] != 8 || counts["VSHUFPD"] != 8 {
+		t.Fatal("complete official 2+16-row denominator changed", counts)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+}
+
+// Intel SDM Vol.2B SHUFPS/SHUFPD specifies VEX.WIG. Go emits W0;
+// independently decode each W0/W1 physical instruction before asking our
+// decoder. This grants neither named mode32 arity nor a numerical raw role.
+func TestX86PackedFloatShuffleVEXWIGIndependentPhysicalPrior(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		mode := 64
+		if arch == "386" {
+			mode = 32
+		}
+		for pp, op := range []string{"VSHUFPS", "VSHUFPD"} {
+			for _, bank := range []string{"X", "Y"} {
+				for _, memory := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/memory=%t", arch, op, bank, memory), func(t *testing.T) {
+						first := bank + "0"
+						if memory {
+							first = "(AX)"
+						}
+						operation := fmt.Sprintf("%s $27,%s,%s1,%s2", op, first, bank, bank)
+						// Named four-operand Go priors belong to AMD64; the same
+						// low-bank machine encoding independently exists in mode32.
+						original, pcs := x86NumericalBoundaryGoBytes(t, "amd64", operation+"\nRET")
+						if len(pcs) != 2 || pcs[1] != int64(len(original)-1) {
+							t.Fatal("original complete Go VEX instruction prior missing", pcs)
+						}
+						p1, modrm := byte(0x70|pp), byte(0xd0)
+						if bank == "Y" {
+							p1 |= 4
+						}
+						if memory {
+							modrm = 0x10
+						}
+						wantGo := []byte{0xc5, 0x80 | p1, 0xc6, modrm, 27, 0xc3}
+						if !reflect.DeepEqual(original, wantGo) {
+							t.Fatal("independent original Go source/operand/imm bytes changed", original, wantGo)
+						}
+						var control Instr
+						for _, w := range []byte{0, 0x80} {
+							code := []byte{0xc4, 0xe1, p1 | w, 0xc6, modrm, 27}
+							x86NumericalNativeRequireMC(t, code, mode, 1, "+avx")
+							ins, consumed, known, err := decodedX86VSHUFPSInstruction(code, mode)
+							if !known || err != nil || consumed != len(code) || ins.Op != Op(op) {
+								t.Fatal("ISA WIG lost a complete physically validated shuffle", w, consumed, known, err)
+							}
+							if w == 0 {
+								control = ins
+							} else if !reflect.DeepEqual(ins.Args, control.Args) {
+								t.Fatal("WIG changed source/destination/immediate identities", control.Args, ins.Args)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_packed_float_shuffle_source_test.go b/x86_packed_float_shuffle_source_test.go
new file mode 100644
index 000000000..4627d3e67
--- /dev/null
+++ b/x86_packed_float_shuffle_source_test.go
@@ -0,0 +1,446 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// These are the four two-source floating shuffles, not the eight single-source
+// PSHUFW/PSHUFD/PSHUFHW/PSHUFLW spellings already covered independently.
+var x86PackedFloatShuffleOracleMembers = []string{"SHUFPS", "SHUFPD", "VSHUFPS", "VSHUFPD"}
+
+type x86PackedFloatShuffleOracleRow struct {
+	op, bank, input, mode string
+}
+
+func x86PackedFloatShuffleOracleRows(arch string) []x86PackedFloatShuffleOracleRow {
+	var rows []x86PackedFloatShuffleOracleRow
+	for _, op := range x86PackedFloatShuffleOracleMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if !strings.HasPrefix(op, "V") && bank != "X" || arch == "386" && strings.HasPrefix(op, "V") {
+				continue // Go's named mode32 frontend cannot encode four operands.
+			}
+			for _, input := range []string{"register", "full", "broadcast"} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if !strings.HasPrefix(op, "V") && (input == "broadcast" || mode != "plain") {
+						continue
+					}
+					rows = append(rows, x86PackedFloatShuffleOracleRow{op, bank, input, mode})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86PackedFloatShuffleOracleRow) instruction(selector, destination int) string {
+	op, first, mask := row.op, row.bank+"0", ""
+	if row.input != "register" {
+		first = "(AX)"
+	}
+	if row.input == "broadcast" {
+		op += ".BCST"
+	}
+	if row.mode != "plain" {
+		mask = "K1,"
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	operands := fmt.Sprintf(" $%d,%s,", selector, first)
+	if strings.HasPrefix(row.op, "V") {
+		operands += row.bank + "1," + mask
+	}
+	return op + operands + fmt.Sprint(row.bank, destination)
+}
+
+func (row x86PackedFloatShuffleOracleRow) program(arch, name string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	destination := 2
+	if !strings.HasPrefix(row.op, "V") {
+		destination = 1
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s a+%d(FP),AX\n%s b+%d(FP),BX\n"+
+		"VMOVUPS (AX),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (DI),Z2\nKMOVQ mask+%d(FP),K1\n"+
+		"MOVL $5,DX\nCMPL DX,$3\nSTD\n%s\nVMOVUPS Z%d,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nCLD\nRET\n",
+		name, 3*word+8, move, move, word, move, 2*word, 3*word, row.instruction(27, destination), destination)
+	return source, "func " + name + "(out,a,b *byte,mask uint64)\n"
+}
+
+func TestX86PackedFloatShuffleOriginalInitializedConformanceObjects(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	start := strings.Index(string(data), "TEXT ·packedFloatShuffleSemantics(SB)")
+	if start < 0 {
+		t.Fatal("original packed-float-shuffle entry missing")
+	}
+	end := strings.Index(string(data[start:]), "\n\tRET\n")
+	if end < 0 {
+		t.Fatal("original complete packed-float-shuffle return missing")
+	}
+	body := string(data[start : start+end+len("\n\tRET\n")])
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(body))) != "d23a93536d2e70b7c8c5367d1778bb95d6ae79495f3e5de22014e9d92d3f0323" {
+		t.Fatal("original complete shuffle ASM/source observations changed")
+	}
+	data, err = os.ReadFile("amd64_conformance_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	reference, err := x86SegmentMOVSourceFunction(data, "amd64ConformanceRuntimeC")
+	if err != nil || fmt.Sprintf("%x", sha256.Sum256(reference)) != "41b0fc284d1aea9a9d24d613f84a6f4ad416d25a84dfa9664f81c7f1a9eef1b4" {
+		t.Fatal("original whole conformance C/reference changed", err)
+	}
+	x86PackedFaultProgramObjects(t, "#include \"textflag.h\"\n"+body,
+		"func packedFloatShuffleSemantics(out *[96]byte,a,b *[32]byte)")
+}
+
+func TestX86PackedFloatShuffleInitializedFamilyFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete floating-shuffle objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86PackedFloatShuffleOracleRows(target.arch)
+			want := 58
+			if target.arch == "386" {
+				want = 4
+			}
+			if len(rows) != want {
+				t.Fatal("orthogonal family/width/memory/mask denominator changed", len(rows), want)
+			}
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				program, declaration := row.program(target.arch, fmt.Sprint("FloatShuffle", index))
+				source.WriteString(program)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized floating-shuffle source lost its typed consumer", err)
+					}
+					for _, pipeline := range []struct{ text, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.text, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+// Intel's selector is independent of the production form: Go's first operand
+// supplies the high PS pair / odd PD lane, and the second supplies low/even.
+func x86PackedFloatShuffleSelectedByte(op string, output, selector int) (input, at int) {
+	laneBytes := 4
+	if strings.HasSuffix(op, "PD") {
+		laneBytes = 8
+	}
+	lane := output / laneBytes
+	input = 1
+	selected := selector >> (2 * (lane % 4)) & 3
+	if laneBytes == 4 {
+		if lane%4 >= 2 {
+			input = 0
+		}
+	} else {
+		input = 1 - lane%2
+		selected = selector >> lane & 1
+	}
+	return input, output/16*16 + selected*laneBytes + output%laneBytes
+}
+
+func TestX86PackedFloatShuffleSelectorsEveryByteAliasesAndFlags(t *testing.T) {
+	for _, row := range x86PackedFloatShuffleOracleRows("amd64") {
+		if row.input != "register" {
+			continue // Memory requires its separately paired physical source.
+		}
+		destinations := []int{0, 1, 2}
+		if !strings.HasPrefix(row.op, "V") {
+			destinations = []int{1}
+		}
+		for _, destination := range destinations {
+			t.Run(row.instruction(27, destination), func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row.instruction(27, destination))
+				effect, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, "amd64")
+				if !known || err != nil || !effect.requiresResultProof || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("complete double-source shuffle lacks a typed result/FLAGS effect", known, err)
+				}
+				width := amd64VectorByteWidth(Reg(row.bank + "0"))
+				check := func(selector, missingInput, missingByte int) {
+					state := x86FMA3ResultInputState()
+					if missingByte >= 0 {
+						state.writeVector(missingInput, 64, state.vectorBytes(missingInput)&^(uint64(1)<<uint(missingByte)), false)
+					}
+					before := state.clone()
+					var defined uint64
+					for output := 0; output < width; output++ {
+						input, at := x86PackedFloatShuffleSelectedByte(row.op, output, selector)
+						available := before.vectorBytes(input)>>uint(at)&1 != 0
+						if row.mode == "merge" {
+							available = available && before.vectorBytes(destination)>>uint(output)&1 != 0
+						}
+						if available {
+							defined |= uint64(1) << uint(output)
+						}
+					}
+					want := before.clone()
+					want.writeVector(destination, width, defined, !strings.HasPrefix(row.op, "V"))
+					ins := x86ScalarLaneInstruction(t, row.instruction(selector, destination))
+					if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, want) {
+						t.Fatal("selector borrowed a byte, lost an alias or changed GP/FLAGS/DF/storage state", selector, missingInput, missingByte)
+					}
+					caller := x86SourceStackState{
+						bp: x86SourceStackAddress{original: true}, gOriginal: true, numericFlags: true,
+						known: map[Reg]uint8{AX: 0xff}, callers: map[Reg]x86CallerPointerValue{DI: {argument: 0}},
+						vectors: map[Reg]uint64{"Z0": before.vectorBytes(0), "Z1": before.vectorBytes(1), "Z2": before.vectorBytes(2)},
+						masks:   map[Reg]bool{"K1": true},
+					}
+					wantCaller := x86CloneCallerState(caller)
+					wantCaller.vectors[Reg(fmt.Sprint("Z", destination))] = want.vectorBytes(destination)
+					if !x86CallerVectorMoveStep(&ins, &caller, nil) || !reflect.DeepEqual(caller, wantCaller) {
+						t.Fatal("caller selector disagreed with exact result-byte dependencies or changed independent state", selector, missingInput, missingByte)
+					}
+				}
+				for selector := 0; selector < 256; selector++ {
+					check(selector, 0, -1)
+				}
+				for input := 0; input < 3; input++ {
+					for missing := 0; missing < 64; missing++ {
+						check(27, input, missing)
+					}
+				}
+				if row.mode != "plain" {
+					state := x86FMA3ResultInputState()
+					state.masks[1] = false
+					before := state.clone()
+					if x86ResultTransfer(instruction, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+						t.Fatal("unknown mask acquired a result or partly mutated state")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedFloatShuffleMissingNativeInputsAndDeadAccess(t *testing.T) {
+	for _, row := range x86PackedFloatShuffleOracleRows("amd64") {
+		if row.input == "register" {
+			continue
+		}
+		t.Run(row.instruction(27, 1), func(t *testing.T) {
+			destination := 2
+			if !strings.HasPrefix(row.op, "V") {
+				destination = 1
+			}
+			operation := row.instruction(27, destination)
+			prefix := "TEXT ·Read(SB),4,$0-16\nMOVQ input+0(FP),AX\nKMOVQ mask+8(FP),K1\nPXOR X1,X1\nVXORPS X2,X2,X2\n"
+			if row.bank != "X" {
+				prefix = strings.Replace(prefix, "PXOR X1,X1\n", "VPXORD Z1,Z1,Z1\n", 1)
+			}
+			baseline := prefix + operation + "\nRET\n"
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", baseline)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, baseline, "func Read(input *byte,mask uint64)", "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("genuine initialized dead native shuffle lost its paired read", err)
+					}
+					width := amd64VectorByteWidth(Reg(row.bank + "0"))
+					if row.input == "broadcast" {
+						width = 4
+						if strings.HasSuffix(row.op, "PD") {
+							width = 8
+						}
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						body := x86StringMemoryFunction(t, text, "Read")
+						if strings.HasPrefix(row.op, "V") {
+							tuple := fmt.Sprintf("<%d x i8>", width)
+							if width == 4 || width == 8 {
+								tuple = fmt.Sprintf("(?:%s|i%d)", tuple, width*8)
+							}
+							read := regexp.MustCompile(`(?m)load volatile ` + tuple + `, [^\n]*align 1(?:\D|$)`)
+							if len(read.FindAllString(body, -1)) != 1 || strings.Count(body, "load volatile ") != 1 ||
+								strings.Contains(body, "@llvm.masked.load") {
+								var accesses []string
+								for _, line := range strings.Split(body, "\n") {
+									if strings.Contains(line, "load volatile ") || strings.Contains(line, "@llvm.masked.load") {
+										accesses = append(accesses, strings.TrimSpace(line))
+									}
+								}
+								t.Fatal("dead E4NF access lost its one unconditional full/broadcast tuple", width, accesses)
+							}
+						} else if !strings.Contains(body, "asm sideeffect") || !strings.Contains(body, strings.ToLower(row.op)) || !strings.Contains(body, "~{memory}") {
+							t.Fatal("legacy m128 lost its original Type4 alignment/access opcode", body)
+						}
+					}
+					mutations := []struct{ name, before, after string }{
+						{"pointer", "MOVQ input+0(FP),AX\n", ""},
+						{"numeric-address", "MOVQ input+0(FP),AX\n", "MOVQ $1,AX\n"},
+						{"index", "(AX)", "(AX)(CX*2)"},
+					}
+					// A memory operand supplies only the first source, never the
+					// selected register source or an independently merging destination.
+					registerSeed := "PXOR X1,X1\n"
+					if row.bank != "X" {
+						registerSeed = "VPXORD Z1,Z1,Z1\n"
+					}
+					mutations = append(mutations, struct{ name, before, after string }{"register-source", registerSeed, ""})
+					if row.mode == "merge" {
+						mutations = append(mutations, struct{ name, before, after string }{"old-destination", "VXORPS X2,X2,X2\n", ""})
+					}
+					if row.mode != "plain" {
+						mutations = append(mutations, struct{ name, before, after string }{"mask", "KMOVQ mask+8(FP),K1\n", ""})
+					}
+					for _, mutation := range mutations {
+						changed := strings.Replace(baseline, mutation.before, mutation.after, 1)
+						if changed == baseline {
+							t.Fatal("independent negative did not change its input", mutation.name)
+						}
+						output, err := x86ScalarFPBitViewAPI(t, changed, "func Read(input *byte,mask uint64)", "amd64", "x86_64-unknown-linux-gnu", api)
+						if mutation.name == "numeric-address" {
+							if err != nil || output == "" {
+								t.Fatal("complete NUM address lost its paired native shuffle", err)
+							}
+							if strings.HasPrefix(row.op, "V") {
+								tuple := fmt.Sprintf("<%d x i8>", width)
+								if width == 4 || width == 8 {
+									tuple = fmt.Sprintf("(?:%s|i%d)", tuple, width*8)
+								}
+								if len(regexp.MustCompile(`load volatile `+tuple+`,`).FindAllString(output, -1)) != 1 {
+									t.Fatal("NUM address changed the full/broadcast shuffle read width", width)
+								}
+							} else if !strings.Contains(output, "asm sideeffect") || !strings.Contains(output, strings.ToLower(row.op)) || !strings.Contains(output, "~{memory}") {
+								t.Fatal("NUM address lost its original legacy access opcode")
+							}
+							x86RequireNumericNativeSourceContext(t, changed, "func Read(input *byte,mask uint64)", "amd64")
+							x86NumericNativeAddressObject(t, output, "x86_64-unknown-linux-gnu")
+						} else if mutation.name == "register-source" || mutation.name == "old-destination" {
+							x86VectorScratchCodegenControl(t, changed, "func Read(input *byte,mask uint64)", "amd64", "x86_64-unknown-linux-gnu", output, err)
+						} else if output != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead shuffle acquired an absent pointer/index/mask", mutation.name, err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedFloatShuffleMissingSelectedBytesCannotReachStore(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86PackedFloatShuffleOracleRows(arch) {
+			if row.input != "register" || row.mode != "plain" || row.bank != "X" {
+				continue
+			}
+			for _, seed := range []string{"", "PXOR X0,X0\n", "PXOR X1,X1\n"} {
+				destination := 2
+				if !strings.HasPrefix(row.op, "V") {
+					destination = 1
+				}
+				source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s out+0(FP),DI\n%s%s\nMOVOU X%d,(DI)\nRET\n",
+					word, move, seed, row.instruction(27, destination), destination)
+				x86LEAActualTargetGoObject(t, arch, testTargetTriple("linux", arch), source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/seed=%q/%s", arch, row.op, seed, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Missing(out *byte)", arch, testTargetTriple("linux", arch), api)
+						if arch == "amd64" {
+							x86VectorScratchCodegenControl(t, source, "func Missing(out *byte)", arch, testTargetTriple("linux", arch), ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("a missing selected source byte reached an observable store", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedFloatShuffleWholeRawOriginReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedFloatShuffleOracleRows(arch) {
+			if row.input != "register" || row.mode != "plain" {
+				continue
+			}
+			t.Run(arch+"/"+row.instruction(27, 1), func(t *testing.T) {
+				destination := 2
+				if !strings.HasPrefix(row.op, "V") {
+					destination = 1
+				}
+				operation := row.instruction(27, destination)
+				code, pcs := x86NumericalBoundaryGoBytes(t, arch, operation+"\nRET")
+				if len(pcs) != 2 || pcs[1] != int64(len(code)-1) || code[len(code)-1] != 0xc3 {
+					t.Fatal("independent original Go shuffle boundary missing", pcs, code)
+				}
+				prefix := "TEXT ·Value(SB),4,$0-4\n"
+				zero := "PXOR"
+				if strings.HasPrefix(row.op, "V") {
+					zero = "VPXORD"
+				}
+				for register := 0; register < 3; register++ {
+					if zero == "PXOR" {
+						prefix += fmt.Sprintf("PXOR X%d,X%d\n", register, register)
+					} else {
+						prefix += fmt.Sprintf("VPXORD %s%d,%s%d,%s%d\n", row.bank, register, row.bank, register, row.bank, register)
+					}
+				}
+				suffix := fmt.Sprintf("MOVL X%d,ret+0(FP)\nRET\n", destination)
+				namedSource := prefix + operation + "\n" + suffix
+				strict, check := x86RegisterReplayConsumers(t, arch, namedSource)
+				named := mustParseX86RawReturn(t, namedSource).Funcs[0]
+				if strict(named) != nil || check(named) != nil {
+					t.Fatal("genuine complete named source failed before the raw restriction under review")
+				}
+				rawSource := prefix + x86RawDisplacementDirectives(code[:pcs[1]]) + suffix
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, rawSource), arch)
+				if err != nil {
+					t.Fatal("complete original raw normalization prior failed", err)
+				}
+				original, ordinal := file.Funcs[0], -1
+				for index, instruction := range original.Instrs {
+					if instruction.Op == Op(row.op) && instruction.x86SourceRaw != nil {
+						if ordinal >= 0 {
+							t.Fatal("ambiguous whole raw producer")
+						}
+						ordinal = index
+					}
+				}
+				if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("original raw producer lost its immutable complete source")
+				}
+				if err := check(original); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw instruction unexpectedly acquired a named producer permission", err)
+				}
+				changed := original
+				changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+				changed.Instrs[ordinal].x86SourceRaw = nil
+				if original.x86RawReplay.validate(original, arch) != nil || !errors.Is(changed.x86RawReplay.validate(changed, arch), ErrProbeNeedsContext) {
+					t.Fatal("origin-only mutation did not preserve the original immutable replay restriction")
+				}
+				if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("erasing only the raw origin bypassed the real whole-source consumer", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_logical_parameter_store_runtime_test.go b/x86_packed_logical_parameter_store_runtime_test.go
new file mode 100644
index 000000000..577101b9b
--- /dev/null
+++ b/x86_packed_logical_parameter_store_runtime_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import "testing"
+
+// Execute the exact discovering Windows source on the actual host through its
+// portable unaligned LLVM operations. This supplements, not skips or replaces,
+// the unchanged original native-x86 runtime test.
+func TestX86PackedLogicalParameterOriginalProgramPortable(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", x86VMOVDQUAggregateFPOriginalSource)
+	const declaration = "func vmovAggregateFP(out *byte,key0,key1,key2,key3 uint32)"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86VMOVDQUAggregateFPOriginalSource, declaration,
+				"amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "packed-private-copy", text, x86PackedLogicalParameterValueDriver, level)
+				}
+			}
+		})
+	}
+}
+
+const x86PackedLogicalParameterValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void vmovAggregateFP(uint8_t*,uint32_t,uint32_t,uint32_t,uint32_t);
+int main(void) {
+    for (uint32_t row=0;row<257;++row) {
+        const uint32_t input[]={row*UINT32_C(0x9e3779b9),~row,row<<24,UINT32_MAX-row};
+        uint32_t original[4]; memcpy(original,input,sizeof(input));
+        uint8_t output[34]; memset(output,0xa7,sizeof(output));
+        vmovAggregateFP(output+1,input[0],input[1],input[2],input[3]);
+        for (unsigned byte=0;byte<16;++byte) {
+            uint8_t want=(uint8_t)(input[byte/4]>>(8*(byte%4)));
+            if (output[1+byte]!=want || output[17+byte]!=0) {
+                fprintf(stderr,"packed private copy row=%u byte=%u\n",row,byte);
+                return 1;
+            }
+        }
+        if (memcmp(input,original,sizeof(input)) || output[0]!=0xa7 || output[33]!=0xa7) {
+            fprintf(stderr,"packed private copy row=%u input/canary\n",row);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_packed_logical_parameter_store_test.go b/x86_packed_logical_parameter_store_test.go
new file mode 100644
index 000000000..43b7efd8b
--- /dev/null
+++ b/x86_packed_logical_parameter_store_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86LogicalPackedStoreCase struct {
+	op, bank string
+	masked   bool
+}
+
+func x86LogicalPackedStoreCases() []x86LogicalPackedStoreCase {
+	var rows []x86LogicalPackedStoreCase
+	for _, op := range []string{"MOVOU", "MOVUPS", "MOVUPD"} {
+		rows = append(rows, x86LogicalPackedStoreCase{op: op, bank: "X"})
+	}
+	for _, op := range []string{"VMOVDQU", "VMOVUPS", "VMOVUPD", "VMOVDQU8", "VMOVDQU16", "VMOVDQU32", "VMOVDQU64"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if op == "VMOVDQU" && bank == "Z" {
+				continue
+			}
+			rows = append(rows, x86LogicalPackedStoreCase{op: op, bank: bank})
+			if op != "VMOVDQU" {
+				rows = append(rows, x86LogicalPackedStoreCase{op: op, bank: bank, masked: true})
+			}
+		}
+	}
+	return rows
+}
+
+func x86LogicalPackedStoreSource(name string, row x86LogicalPackedStoreCase, result bool) (string, string) {
+	var names []string
+	for index := 0; index < 16; index++ {
+		names = append(names, fmt.Sprintf("a%d", index))
+	}
+	declaration := "func " + name + "(" + strings.Join(names, ",") + " uint32)"
+	extent, tail := 64, ""
+	if result {
+		declaration += " uint32"
+		extent, tail = 68, "MOVL a0+0(FP),AX\nMOVL AX,ret+64(FP)\n"
+	}
+	mask := ""
+	if row.masked {
+		mask = ",K1"
+	}
+	return fmt.Sprintf("TEXT %s(SB),4,$0-%d\nMOVL $0x5555,AX\nKMOVW AX,K1\n"+
+		"VPXORD Z0,Z0,Z0\n%s %s0%s,a0+0(FP)\n%sRET\n", name, extent, row.op, row.bank, mask, tail), declaration
+}
+
+// Keep the Windows VMOVDQU counterexample's private-parameter write distinct
+// from native output storage. Batch complete shapes, rather than rebuilding an
+// LLVM module for every operation/width/mask/return combination.
+func TestX86PackedLogicalParameterCopiesCompleteThreeAPIsFiveTargets(t *testing.T) {
+	rows := x86LogicalPackedStoreCases()
+	if len(rows) != 41 {
+		t.Fatal("incomplete whole-vector unaligned store family", len(rows))
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				for _, result := range []bool{false, true} {
+					body, declaration := x86LogicalPackedStoreSource(fmt.Sprintf("Copy%d_%t", index, result), row, result)
+					source.WriteString(body)
+					declarations.WriteString(declaration + "\n")
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Error("initialized private parameter copies lost their logical stores", api, err)
+					continue
+				}
+				if strings.Count(ir, "define void @") != len(rows) || strings.Count(ir, "define i32 @") != len(rows) {
+					t.Fatal("translation omitted an original Void or integer-result program", api)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedLogicalParameterStoresKeepTypedAndPhysicalBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, result := range []bool{false, true} {
+			original, declaration := x86LogicalPackedStoreSource("Value", x86LogicalPackedStoreCase{op: "VMOVDQU32", bank: "X", masked: true}, result)
+			for _, mutation := range []struct{ name, before, after string }{
+				{"unknown-source", "VPXORD Z0,Z0,Z0\n", ""},
+				{"bare-unknown-source", "MOVL $0x5555,AX\nKMOVW AX,K1\nVPXORD Z0,Z0,Z0\nVMOVDQU32 X0,K1,", "VMOVDQU X0,"},
+				{"unknown-mask", "KMOVW AX,K1\n", ""},
+				{"outside-fields", "X0,K1,a0+0(FP)", "X0,K1,a0+60(FP)"},
+				{"native-SP", "X0,K1,a0+0(FP)", "X0,K1,0(SP)"},
+				{"alignment", "VMOVDQU32", "VMOVDQA32"},
+			} {
+				t.Run(fmt.Sprintf("%s/result-%t/%s", target.triple, result, mutation.name), func(t *testing.T) {
+					source := strings.Replace(original, mutation.before, mutation.after, 1)
+					if source == original {
+						t.Fatal("negative source mutation was not applied")
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if target.arch == "amd64" && (mutation.name == "unknown-source" || mutation.name == "bare-unknown-source") {
+							x86VectorScratchCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("private copies supplied unknown data or native storage", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedLogicalParameterStoresExcludePointersBoolsAndHoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, result := range []bool{false, true} {
+			source, _ := x86LogicalPackedStoreSource("Value", x86LogicalPackedStoreCase{op: "VMOVDQU", bank: "X"}, result)
+			for _, fields := range []string{
+				fmt.Sprintf("P *byte; Tail [%d]byte", 64-goWordSize(target.arch)),
+				"B bool; Tail [63]byte",
+				"B byte; W uint32; Tail [56]byte",
+			} {
+				t.Run(fmt.Sprintf("%s/result-%t/%s", target.triple, result, fields), func(t *testing.T) {
+					declaration := "func Value(a0 struct{" + fields + "})"
+					if result {
+						declaration += " uint32"
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("packed logical store overwrote nonnumeric or unowned bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_packed_narrow_value_runtime_test.go b/x86_packed_narrow_value_runtime_test.go
new file mode 100644
index 000000000..7c4925f6d
--- /dev/null
+++ b/x86_packed_narrow_value_runtime_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86NarrowValueRuntimeProgram(arch string, discard bool) (string, string, string, string) {
+	return x86FixedBinaryValueRuntimeProgram(arch, discard, "NarrowValue", x86NarrowValueRows, func(op string) (int, int) {
+		bits, operation := 16, 0
+		if strings.HasPrefix(op, "PACKUS") || strings.HasPrefix(op, "VPACKUS") {
+			operation = 1
+		}
+		if strings.Contains(op, ".BCST") {
+			operation |= 2
+		}
+		if strings.Contains(op, "DW") || op == "PACKSSLW" {
+			bits = 32
+		}
+		return bits, operation
+	})
+}
+
+func TestX86PackedNarrowCompletePortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, cWord := "amd64", "uint64_t"
+	if strconv.IntSize == 32 {
+		arch, cWord = "386", "uint32_t"
+	}
+	source, declarations, prototypes, rows := x86NarrowValueRuntimeProgram(arch, false)
+	x86LEAActualTargetGoObject(t, arch, map[string]string{"amd64": "x86_64-unknown-linux-gnu", "386": "i386-unknown-linux-gnu"}[arch], source)
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes +
+		"typedef " + cWord + " narrow_word;\n" + x86NarrowIndependentCReference + `
+struct kernel {void (*fn)(uint8_t*,uint8_t*,uint8_t*,narrow_word);unsigned width,bits,mode,legacy,operation;};
+static const struct kernel kernels[]={
+` + rows + `};
+int main(void) {
+    const narrow_word masks[]={0,1,(narrow_word)0xa55a9c63f00fc33cULL,(narrow_word)-1};
+    for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++)for(unsigned sample=0;sample<257;sample++) {
+        const struct kernel *p=&kernels[k];
+        uint8_t a[67],b[67],before_a[67],before_b[67],out[67],want[64],packed[64];
+        memset(a,0xa7,sizeof(a));memset(b,0x91,sizeof(b));
+        fill(a+1,p->bits/8,sample,0);fill(b+1,p->bits/8,sample,13);
+        memcpy(before_a,a,sizeof(a));memcpy(before_b,b,sizeof(b));
+        independent_pack(packed,a+1,b+1,p->width,p->bits/8,p->operation&1,p->operation>>1);
+        for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+            memset(out,0xc3,sizeof(out));memcpy(want,b+1,64);
+            if(!p->legacy)memset(want+p->width,0,64-p->width);
+            for(unsigned byte=0;byte<p->width;byte++) {
+                unsigned lane=byte/(p->bits/16);
+                if(!p->mode || (masks[m]>>lane&1))want[byte]=packed[byte];
+                else if(p->mode==2)want[byte]=0;
+            }
+            p->fn(a+1,b+1,out+1,masks[m]);
+            if(memcmp(out+1,want,64)||out[65]!=1||out[0]!=0xc3||out[66]!=0xc3||
+                    memcmp(a,before_a,sizeof(a))||memcmp(b,before_b,sizeof(b))) {
+                fprintf(stderr,"PACK row=%u sample=%u mask=%u width=%u mode=%u legacy=%u operation=%u\n",
+                    k,sample,m,p->width,p->mode,p->legacy,p->operation);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil {
+				t.Fatal("complete initialized packed narrow source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "narrow-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+	t.Log("complete signed/unsigned saturation, 64-byte aliases, broadcast, merge/zero masks, CF and canaries; portable LLVM, not native AVX512")
+}
diff --git a/x86_packed_native_owner_go127_test.go b/x86_packed_native_owner_go127_test.go
new file mode 100644
index 000000000..21440422b
--- /dev/null
+++ b/x86_packed_native_owner_go127_test.go
@@ -0,0 +1,49 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86ExistingSDKOwnersPrecedePackedNativeFamilies(t *testing.T) {
+	owners := x86CaptureNativeFamilyOwnerOracle(t)
+	for _, first := range []string{"X0", "(AX)"} {
+		for _, row := range []struct{ family, instruction string }{
+			{"integer-minmax/VEX-byte", "VPMINSB " + first + ",X1,X2"},
+			{"integer-minmax/VEX", "VPMAXUD " + first + ",X1,X2"},
+			{"integer-minmax/EVEX", "VPMAXUD " + first + ",X1,K1,X2"},
+			{"reduction/legacy-horizontal", "HADDPS " + first + ",X2"},
+			{"reduction/legacy-dot", "DPPS $255," + first + ",X2"},
+			{"reduction/named-VEX", "VDPPS $255," + first + ",X1,X2"},
+			{"mask-blend/float32", "VBLENDMPS " + first + ",X1,K1,X2"},
+			{"mask-blend/float64", "VBLENDMPD " + first + ",X1,K1,X2"},
+			{"mask-blend/byte", "VPBLENDMB " + first + ",X1,K1,X2"},
+			{"mask-blend/word", "VPBLENDMW " + first + ",X1,K1,X2"},
+			{"mask-blend/dword", "VPBLENDMD " + first + ",X1,K1,X2"},
+			{"mask-blend/qword", "VPBLENDMQ " + first + ",X1,K1,X2"},
+		} {
+			t.Run(row.family+"/"+first, func(t *testing.T) {
+				text, declaration := x86PackedNativeOwnerProgram(row.instruction)
+				owners.checkProgram(t, text, declaration, row.instruction)
+			})
+		}
+		t.Run("reduction/raw-VEX/"+first, func(t *testing.T) {
+			modrm := byte(0xd0) // X0, X1, X2: independent VEX.vvvv=1.
+			if first == "(AX)" {
+				modrm = 0x10
+			}
+			bytes := []byte{0xc4, 0xe3, 0x71, 0x40, modrm, 0xff}
+			text, declaration := x86PackedNativeOwnerProgram(x86RawDisplacementDirectives(bytes))
+			owners.checkProgram(t, text, declaration, "VDPPS $255,"+first+",X1,X2")
+		})
+	}
+}
+
+func x86PackedNativeOwnerProgram(instruction string) (string, string) {
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),AX\nMOVQ b+16(FP),BX\n"+
+			"MOVOU (AX),X0\nMOVOU (BX),X1\nMOVOU X1,X2\nMOVL $-1,DX\nKMOVD DX,K1\nSTC\n%s\n"+
+			"MOVOU X2,(DI)\nSETCS 16(DI)\nSTMXCSR 20(DI)\nRET\n", instruction),
+		"func Value(out *[24]byte,a,b *[16]byte)\n"
+}
diff --git a/x86_packed_precision_boundaries_test.go b/x86_packed_precision_boundaries_test.go
new file mode 100644
index 000000000..38217326b
--- /dev/null
+++ b/x86_packed_precision_boundaries_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedPrecisionMaskMergeBytesAndSourceAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86PackedPrecisionOracleRows() {
+			if row.source != "register" || row.mode == "" {
+				continue
+			}
+			for _, missing := range []string{"none", "mask", "active-old", "zeroed-tail"} {
+				t.Run(arch+"/"+row.instruction()+"/"+missing, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.instruction())
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.writeVector(0, 64, ^uint64(0), true)
+					state.writeVector(1, 64, ^uint64(0), true)
+					state.masks[1], state.pointerGP[3], state.callerAddressGP[7] = true, true, true
+					switch missing {
+					case "mask":
+						state.masks[1] = false
+					case "active-old":
+						state.writeVector(1, 64, ^uint64(1), true)
+					case "zeroed-tail":
+						state.writeVector(1, 64, x86CallerVectorByteMask(int64(row.output)), true)
+					}
+					before, want := state.clone(), state.clone()
+					valid := missing != "mask" && (missing != "active-old" || row.mode == "zero")
+					if valid {
+						want.writeVector(1, row.carrier, x86CallerVectorByteMask(int64(row.carrier)), false)
+					}
+					if accepted := x86ResultTransfer(ins, &state, nil, 0, arch); accepted != valid || !reflect.DeepEqual(state, want) {
+						t.Fatal("mask/merge obligation, forced tail zero or unrelated FLAGS/DF/storage changed", missing, accepted, valid, before, state)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedPrecisionInitializedPublicInputsCannotBorrowOtherRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := int(goWordSize(arch)), "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, base := range x86PackedPrecisionBaseRows() {
+			for _, kind := range []string{"register", "native", "FP"} {
+				row := base
+				row.source = kind
+				source, declaration, _ := x86PackedPrecisionProgram(row, 0, arch)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%d/%s/%s", arch, row.op, row.carrier, kind, api), func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+							t.Fatal("legitimate complete source failed before its independent authority negatives", err)
+						}
+						mutations := map[string]string{
+							"output pointer": strings.Replace(source, move+" out+64(FP),DI\n", "", 1),
+						}
+						if kind == "register" {
+							mutations["source vector"] = strings.Replace(source, "VMOVDQU64 (BX),Z0\n", "", 1)
+						} else if kind == "native" {
+							mutations["native address"] = strings.Replace(source, fmt.Sprintf("%s input+%d(FP),BX\n", move, 64+word), "", 1)
+						} else {
+							mutations["pointer bits"] = strings.Replace(source, "value+0(FP)", "out+64(FP)", 1)
+							mutations["undeclared bytes"] = strings.Replace(source, "value+0(FP)", "value+128(FP)", 1)
+						}
+						for name, changed := range mutations {
+							if changed == source {
+								t.Fatal("source/input mutation did not apply", name)
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+							if arch == "amd64" && name == "source vector" {
+								x86VectorScratchCodegenControl(t, changed, declaration, arch, triple, ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("packed precision borrowed undeclared/native/pointer authority", name, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedPrecisionDeadNativeReadsRetainExactE2Opcode(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86PackedPrecisionOracleRows() {
+			if row.source != "native" {
+				continue
+			}
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				declaration := "func view(p *byte)\n"
+				prepare := ""
+				if row.mode != "" {
+					prepare = "MOVL $0,AX\nKMOVD AX,K1\n"
+				}
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s p+0(FP),BX\n%s%s\nRET\n", goWordSize(arch), move, prepare, row.instruction())
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete dead E2 native source lost its paired continuation", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86ScalarPrecisionRequireNativeEffects(t, text, map[string][]string{"view": {x86PackedPrecisionNativeName(row.op)}})
+							memory := fmt.Sprintf("elementtype([%d x i8])", row.sourceBytes())
+							found := false
+							for _, line := range strings.Split(text, "\n") {
+								found = found || x86ScalarPrecisionNativeEffectLine(line, x86PackedPrecisionNativeName(row.op)) && strings.Contains(line, memory)
+							}
+							if !found {
+								t.Fatal("actual E2 opcode lost its complete independent memory tuple", row.sourceBytes())
+							}
+						}
+						missing := strings.Replace(source, move+" p+0(FP),BX\n", "", 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, missing, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or an all-zero mask waived the real address input", err)
+						}
+						if row.mode != "" {
+							missingMask := strings.Replace(source, "KMOVD AX,K1\n", "", 1)
+							if ir, err := x86ScalarFPBitViewAPI(t, missingMask, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("a dead conversion waived its actual mask source", err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedPrecisionForeignTargetCannotClaimNativeMXCSR(t *testing.T) {
+	for _, row := range x86PackedPrecisionBaseRows() {
+		row.source = "register"
+		source, declaration, _ := x86PackedPrecisionProgram(row, 0, "amd64")
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("%s/%d/%s", row.op, row.carrier, api), func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir == "" || err != nil {
+					t.Fatal("native initialized control failed before cross-target qualification", err)
+				}
+				for _, triple := range []string{"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("pure fpext/fptrunc incorrectly certified original x86 MXCSR/exception effects", triple, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedPrecisionStandaloneRawAndPhysicalBanksStayIndependent(t *testing.T) {
+	for _, row := range x86PackedPrecisionBaseRows() {
+		row.source = "register"
+		for _, mutation := range []string{"encoded", "origin", "address-size", "segment", "physical-mode32"} {
+			t.Run(row.instruction()+"/"+mutation, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				arch := "amd64"
+				switch mutation {
+				case "encoded":
+					ins.x86Encoded = true
+				case "origin":
+					ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: append([]Operand(nil), ins.Args...)}
+				case "address-size":
+					ins.x86AddressBits = 32
+				case "segment":
+					ins.x86SegmentPrefix = 0x64
+				case "physical-mode32":
+					arch = "386"
+					ins.Args[len(ins.Args)-1].Reg = Reg(string(ins.Args[len(ins.Args)-1].Reg[:1]) + "16")
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.writeVector(0, 64, ^uint64(0), true)
+				state.writeVector(1, 64, ^uint64(0), true)
+				state.writeVector(16, 64, ^uint64(0), true)
+				before := state.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone numerical query borrowed raw/physical permission", mutation)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_precision_contract_test.go b/x86_packed_precision_contract_test.go
new file mode 100644
index 000000000..549cc4159
--- /dev/null
+++ b/x86_packed_precision_contract_test.go
@@ -0,0 +1,210 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent lane/carrier directory. Narrowing X has eight active output
+// bytes in an X carrier; zeroing that tail is not a read of the old carrier.
+type x86PackedPrecisionOracleRow struct {
+	op, source, control, mode string
+	inputBits, outputBits     int
+	input, output, carrier    int
+	vector, broadcast         bool
+}
+
+func x86PackedPrecisionBaseRows() []x86PackedPrecisionOracleRow {
+	return []x86PackedPrecisionOracleRow{
+		{op: "CVTPS2PD", inputBits: 32, outputBits: 64, input: 8, output: 16, carrier: 16},
+		{op: "CVTPD2PS", inputBits: 64, outputBits: 32, input: 16, output: 8, carrier: 16},
+		{op: "VCVTPS2PD", inputBits: 32, outputBits: 64, input: 8, output: 16, carrier: 16, vector: true},
+		{op: "VCVTPS2PD", inputBits: 32, outputBits: 64, input: 16, output: 32, carrier: 32, vector: true},
+		{op: "VCVTPS2PD", inputBits: 32, outputBits: 64, input: 32, output: 64, carrier: 64, vector: true},
+		{op: "VCVTPD2PSX", inputBits: 64, outputBits: 32, input: 16, output: 8, carrier: 16, vector: true},
+		{op: "VCVTPD2PSY", inputBits: 64, outputBits: 32, input: 32, output: 16, carrier: 16, vector: true},
+		{op: "VCVTPD2PS", inputBits: 64, outputBits: 32, input: 64, output: 32, carrier: 32, vector: true},
+	}
+}
+
+// Orthogonal axes, not their object-compilation Cartesian product. Each
+// legal source, mask, scalar broadcast and SAE/ER control occurs at least once.
+func x86PackedPrecisionOracleRows() []x86PackedPrecisionOracleRow {
+	var rows []x86PackedPrecisionOracleRow
+	for _, base := range x86PackedPrecisionBaseRows() {
+		for _, source := range []string{"register", "native", "FP"} {
+			row := base
+			row.source = source
+			rows = append(rows, row)
+		}
+		if !base.vector {
+			continue
+		}
+		for _, mode := range []string{"merge", "zero"} {
+			row := base
+			row.source, row.mode = "register", mode
+			rows = append(rows, row)
+		}
+		for _, mode := range []string{"", "zero"} {
+			row := base
+			row.source, row.mode, row.broadcast = "native", mode, true
+			rows = append(rows, row)
+		}
+		if base.op == "VCVTPS2PD" && base.carrier == 64 {
+			row := base
+			row.source, row.control = "register", "SAE"
+			rows = append(rows, row)
+		}
+		if base.op == "VCVTPD2PS" {
+			for _, control := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				row := base
+				row.source, row.control = "register", control
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86PackedPrecisionOracleRow) sourceBytes() int {
+	if row.broadcast {
+		return row.inputBits / 8
+	}
+	return row.input
+}
+
+func (row x86PackedPrecisionOracleRow) registers() (source, destination string) {
+	sourceWidth := 16
+	if row.input > 16 {
+		sourceWidth = row.input
+	}
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}
+	return bank[sourceWidth] + "0", bank[row.carrier] + "1"
+}
+
+func (row x86PackedPrecisionOracleRow) instruction() string {
+	source, destination := row.registers()
+	if row.source == "native" {
+		source = "(BX)"
+	} else if row.source == "FP" {
+		source = "value+0(FP)"
+	}
+	op := row.op
+	if row.broadcast {
+		op += ".BCST"
+	} else if row.control != "" {
+		op += "." + row.control
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	mask := ""
+	if row.mode != "" {
+		mask = "K1,"
+	}
+	return op + " " + source + "," + mask + destination
+}
+
+func TestX86PackedPrecisionCompleteTypedSourceAndControlDirectory(t *testing.T) {
+	rows := x86PackedPrecisionOracleRows()
+	if len(rows) != 53 {
+		t.Fatal("independent complete precision directory changed", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		for index, row := range rows {
+			fmt.Fprintf(&source, "TEXT Row%d(SB),4,$0-128\n%s\nRET\n", index, row.instruction())
+		}
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("packed precision lacks its closed typed byte/FLAGS contract", known, err, effect)
+				}
+				reads, writes := make(map[int]bool), make(map[int]bool)
+				for _, operand := range effect.operands {
+					width := int64(row.carrier)
+					if operand.index == 0 {
+						width = int64(row.sourceBytes())
+					} else if operand.operand.Reg == "K1" {
+						width = 8
+					}
+					if operand.index < 0 || operand.index >= len(ins.Args) || operand.width != width ||
+						!reflect.DeepEqual(operand.operand, ins.Args[operand.index]) {
+						t.Fatal("source tuple, K or destination carrier differs from the independent directory", operand)
+					}
+					reads[operand.index] = reads[operand.index] || operand.read
+					writes[operand.index] = writes[operand.index] || operand.write
+				}
+				last := len(ins.Args) - 1
+				for index := range ins.Args {
+					if reads[index] != (index < last || row.mode == "merge") || writes[index] != (index == last) {
+						t.Fatal("precision acquired an old-destination input or lost a source/mask", index, reads, writes)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedPrecisionEveryInputByteAndIndependentAliases(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedPrecisionBaseRows() {
+			for _, sourceKind := range []string{"register", "FP"} {
+				row.source = sourceKind
+				for missing := -1; missing < row.input; missing++ {
+					t.Run(fmt.Sprintf("%s/%s/%d/%s/missing%d", arch, row.op, row.carrier, sourceKind, missing), func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, row.instruction())
+						state := x86ResultState{fp: make([]bool, 64), flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						owned := make([]bool, 64)
+						for at := range owned {
+							state.fp[at], owned[at] = true, true
+						}
+						state.writeVector(0, 64, ^uint64(0), true)
+						state.writeVector(1, 64, 0xa5a55a5af00f1234, true)
+						state.pointerGP[3], state.callerAddressGP[7], state.masks[2] = true, true, true
+						if missing >= 0 {
+							if sourceKind == "FP" {
+								state.fp[missing] = false
+							} else {
+								state.writeVector(0, 64, ^(uint64(1) << uint(missing)), true)
+							}
+						}
+						before, want := state.clone(), state.clone()
+						if missing < 0 {
+							want.writeVector(1, row.carrier, x86CallerVectorByteMask(int64(row.carrier)), !row.vector)
+						}
+						if accepted := x86ResultTransfer(ins, &state, owned, 64, arch); accepted != (missing < 0) || !reflect.DeepEqual(state, want) {
+							t.Fatal("packed precision invented input, lost forced zeros/aliases or changed another state", accepted, missing, before, state, want)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedPrecisionOverlappingCarriersReadBeforeWrite(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86PackedPrecisionBaseRows() {
+			row.source = "register"
+			t.Run(fmt.Sprintf("%s/%s/%d", arch, row.op, row.carrier), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				last := len(ins.Args) - 1
+				ins.Args[last].Reg = Reg(string(ins.Args[last].Reg[:1]) + "0")
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.writeVector(0, 64, x86CallerVectorByteMask(int64(row.input)), true)
+				before, want := state.clone(), state.clone()
+				want.writeVector(0, row.carrier, x86CallerVectorByteMask(int64(row.carrier)), !row.vector)
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+					t.Fatal("same physical source/destination carrier lost input bytes or borrowed unknown upper aliases", before, state, want)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_precision_format_test.go b/x86_packed_precision_format_test.go
new file mode 100644
index 000000000..e4ad7a352
--- /dev/null
+++ b/x86_packed_precision_format_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Preserve every original source row, actual Go object and three-API Context
+// result. A private direct-emitter object proves only the physically bound
+// formats, not initialized source inputs or a native entry. Mode32 high banks
+// remain represented by their unchanged Go object and explicit Context; they
+// are never remapped to another register or claimed as initialized objects.
+func x86PackedPrecisionOriginalFormatObject(t *testing.T, source, name, arch, triple string,
+	raw bool, expectedRows, mode32ContextRows int) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	if raw {
+		var err error
+		file, err = normalizeX86RawFile(file, arch)
+		if err != nil {
+			t.Fatal("complete original packed precision bytes lost their decoder", err)
+		}
+	}
+	local := *file
+	local.Funcs = append([]Func(nil), file.Funcs...)
+	local.Funcs[0].Instrs = nil
+	rows, contextual := 0, 0
+	for _, instruction := range file.Funcs[0].Instrs {
+		if _, known, err := x86PackedPrecisionProperties(instruction.Op, instruction, arch); known {
+			rows++
+			if err != nil {
+				if arch != "386" || !errors.Is(err, ErrProbeNeedsContext) ||
+					x86Mode32VectorRegisterContext(instruction, arch) == nil {
+					t.Fatal("original packed precision format became malformed or lost a different source role", instruction.Raw, err)
+				}
+				contextual++
+				continue
+			}
+		}
+		local.Funcs[0].Instrs = append(local.Funcs[0].Instrs, instruction)
+	}
+	wantContext := 0
+	if arch == "386" {
+		wantContext = mode32ContextRows
+	}
+	if rows != expectedRows || contextual != wantContext ||
+		len(local.Funcs[0].Instrs)+contextual != len(file.Funcs[0].Instrs) {
+		t.Fatal("complete original packed precision format partition changed", rows, expectedRows, contextual, wantContext)
+	}
+	t.Logf("all %d original rows retained in Go objects/public Context: %d physical-bank Context, %d private emitter-only objects; independent initialized public objects have their own owner",
+		rows, contextual, rows-contextual)
+	return x86ScalarFormatObjectUnit(t, &local, signatures, arch, triple, 0)
+}
diff --git a/x86_packed_precision_go127_test.go b/x86_packed_precision_go127_test.go
new file mode 100644
index 000000000..6db189371
--- /dev/null
+++ b/x86_packed_precision_go127_test.go
@@ -0,0 +1,91 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86PackedPrecisionCompleteOfficialRowsAndAttributes(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []string{
+		"var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n}",
+		"{ACVTPS2PD, yxm, Pm, opBytes{0x5a}}", "{ACVTPD2PS, yxm, Pe, opBytes{0x5a}}",
+	} {
+		if !strings.Contains(string(legacy), expected) {
+			t.Fatal("complete legacy packed precision row/prefix/opcode changed", expected)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := make(map[string]int)
+	for _, rule := range rules {
+		var table string
+		var classes [][]string
+		var encoding []string
+		var offsets, advances []int
+		switch rule.Opcode {
+		case "VCVTPS2PD":
+			table = "_yvcvtph2ps"
+			classes = [][]string{{"Yxm", "Yxr"}, {"Yxm", "Yyr"},
+				{"YymEvex", "Yzr"}, {"YymEvex", "Yknot0", "Yzr"},
+				{"YxmEvex", "YxrEvex"}, {"YxmEvex", "Yknot0", "YxrEvex"},
+				{"YxmEvex", "YyrEvex"}, {"YxmEvex", "Yknot0", "YyrEvex"}}
+			encoding = []string{"avxEscape | vex128 | vex0F | vexW0", "0x5A",
+				"avxEscape | vex256 | vex0F | vexW0", "0x5A",
+				"avxEscape | evex512 | evex0F | evexW0", "evexN32 | evexBcstN4 | evexSaeEnabled | evexZeroingEnabled", "0x5A",
+				"avxEscape | evex128 | evex0F | evexW0", "evexN8 | evexBcstN4 | evexZeroingEnabled", "0x5A",
+				"avxEscape | evex256 | evex0F | evexW0", "evexN16 | evexBcstN4 | evexZeroingEnabled", "0x5A"}
+			offsets, advances = []int{0, 2, 4, 4, 7, 7, 10, 10}, []int{2, 2, 0, 3, 0, 3, 0, 3}
+		case "VCVTPD2PSX", "VCVTPD2PSY":
+			table = "_yvcvtpd2dqx"
+			operand, vexWidth, evexWidth, tuple := "Yxm", "vex128", "evex128", "evexN16"
+			if rule.Opcode == "VCVTPD2PSY" {
+				table, operand, vexWidth, evexWidth, tuple = "_yvcvtpd2dqy", "Yym", "vex256", "evex256", "evexN32"
+			}
+			classes = [][]string{{operand, "Yxr"}, {operand + "Evex", "YxrEvex"}, {operand + "Evex", "Yknot0", "YxrEvex"}}
+			encoding = []string{"avxEscape | " + vexWidth + " | vex66 | vex0F | vexW0", "0x5A",
+				"avxEscape | " + evexWidth + " | evex66 | evex0F | evexW1", tuple + " | evexBcstN8 | evexZeroingEnabled", "0x5A"}
+			offsets, advances = []int{0, 2, 2}, []int{2, 0, 3}
+		case "VCVTPD2PS":
+			table = "_yvcvtpd2dq"
+			classes = [][]string{{"Yzm", "YyrEvex"}, {"Yzm", "Yknot0", "YyrEvex"}}
+			encoding = []string{"avxEscape | evex512 | evex66 | evex0F | evexW1",
+				"evexN64 | evexBcstN8 | evexRoundingEnabled | evexZeroingEnabled", "0x5A"}
+			offsets, advances = []int{0, 0}, []int{0, 3}
+		default:
+			continue
+		}
+		index := rule.RowIndex
+		if index < 0 || index >= len(classes) {
+			t.Fatal("unobserved packed precision encoder row", rule)
+		}
+		zcase := "Zevex_rm_v_r"
+		if strings.HasPrefix(encoding[offsets[index]], "avxEscape | vex") {
+			zcase = "Zvex_rm_v_r"
+		} else if len(classes[index]) == 3 {
+			zcase = "Zevex_rm_k_r"
+		}
+		if rule.Ytab != table || rule.Prefix != "Pavx" || rule.ZCase != zcase ||
+			rule.EncodingOffset != offsets[index] || rule.ZOffset != advances[index] ||
+			!reflect.DeepEqual(rule.Classes, classes[index]) || !reflect.DeepEqual(rule.OpBytes, encoding) {
+			t.Fatal("complete packed precision row, tuple, width, SAE/ER or mask attribute changed", rule)
+		}
+		counts[rule.Opcode]++
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VCVTPS2PD": 8, "VCVTPD2PSX": 3, "VCVTPD2PSY": 3, "VCVTPD2PS": 2}) {
+		t.Fatal("six names / eighteen complete official precision rows changed", counts)
+	}
+}
diff --git a/x86_packed_precision_objects_test.go b/x86_packed_precision_objects_test.go
new file mode 100644
index 000000000..2e8d5e4aa
--- /dev/null
+++ b/x86_packed_precision_objects_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedPrecisionOriginal(t *testing.T) (string, string) {
+	t.Helper()
+	const path = "amd64_raw_packed_precision_convert_test.go"
+	const root = "TestX86RawPackedPrecisionConvertRuntimeSemantics"
+	source := x86X87FunctionLiteral(t, path, root, "namedSource")
+	reference := x86X87FunctionLiteral(t, path, root, "mainC")
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != "9164082e7bcb642692d756b595fdd38094cbfd07a24511a609dcfef1dce345cf" ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(reference))) != "5fc9a3c35dd0d671f5e4fc458e874b3a49344831fa215be1a06a83fd78b8b1f3" {
+		t.Fatal("complete original initialized packed precision ASM/C or observations changed")
+	}
+	return source, reference
+}
+
+func x86PackedPrecisionRawOriginal(source string) string {
+	return strings.NewReplacer(
+		"VCVTPS2PD (BX), Y1", "BYTE $0xc5; BYTE $0xfc; BYTE $0x5a; BYTE $0x0b",
+		"VCVTPD2PSY (CX), X2", "BYTE $0xc5; BYTE $0xfd; BYTE $0x5a; BYTE $0x11",
+	).Replace(source)
+}
+
+func TestX86PackedPrecisionOriginalInitializedThreeAPIObjects(t *testing.T) {
+	original, _ := x86PackedPrecisionOriginal(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete original packed precision objects require LLVM22")
+	}
+	const declaration = "func packedprecision(out *[48]byte,singles *[4]float32,doubles *[4]float64)\n"
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", triple, raw), func(t *testing.T) {
+				source := original
+				if raw {
+					source = x86PackedPrecisionRawOriginal(source)
+				}
+				x86LEAActualTargetGoObject(t, "amd64", triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("the original fully initialized packed precision source remains unclosed", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86ScalarPrecisionRequireNativeEffects(t, text,
+								map[string][]string{"packedprecision": {"VCVTPS2PD", "VCVTPD2PS"}})
+							compileLLVMToObject(t, llc, triple, "original-packed-precision.ll", "original-packed-precision.o", text)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+// The first 64 bytes are separately declared scalar fields, not an array
+// allocation or native stack backing. The same source observes every output
+// byte, nonzero old aliases, CF and MXCSR without introducing a DF host axis.
+func x86PackedPrecisionProgram(row x86PackedPrecisionOracleRow, index int, arch string) (source, declaration, name string) {
+	word, move := int(goWordSize(arch)), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	name = fmt.Sprint("PackedPrecision", index)
+	var fields []string
+	fields = append(fields, "value byte")
+	for at := 1; at < 64; at++ {
+		fields = append(fields, fmt.Sprintf("a%d byte", at))
+	}
+	declaration = fmt.Sprintf("func %s(%s,out *[80]byte,input,old *[64]byte,mask uint64)\n", name, strings.Join(fields, ","))
+	prepare := ""
+	if row.source == "register" {
+		prepare = "VMOVDQU64 (BX),Z0\n"
+	}
+	source = fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+64(FP),DI\n%s input+%d(FP),BX\n"+
+		"%s old+%d(FP),DX\n%sVMOVDQU64 (DX),Z1\n"+
+		"MOVL mask+%d(FP),AX\nKMOVD AX,K1\nSTC\n%s\nVMOVDQU64 Z1,(DI)\nSETCS 64(DI)\nSTMXCSR 68(DI)\nRET\n",
+		name, 64+3*word+8, move, move, 64+word, move, 64+2*word, prepare, 64+3*word, row.instruction())
+	return source, declaration, name
+}
+
+func x86PackedPrecisionNativeName(op string) string {
+	if op == "VCVTPD2PSX" || op == "VCVTPD2PSY" {
+		return "VCVTPD2PS"
+	}
+	return op
+}
+
+func TestX86PackedPrecisionOrthogonalInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("packed precision objects require LLVM22")
+	}
+	rows := x86PackedPrecisionOracleRows()
+	if len(rows) != 53 || len(rows) > 64 {
+		t.Fatal("orthogonal complete object directory changed", len(rows))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			functions := make(map[string][]string)
+			for index, row := range rows {
+				body, declaration, name := x86PackedPrecisionProgram(row, index, target.arch)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				functions[name] = []string{x86PackedPrecisionNativeName(row.op)}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized packed precision directory remains unclosed", err)
+					}
+					for _, pipeline := range []struct{ name, level, ir string }{
+						{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+						{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							x86ScalarPrecisionRequireNativeEffects(t, pipeline.ir, functions)
+							x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_packed_precision_raw_identity_test.go b/x86_packed_precision_raw_identity_test.go
new file mode 100644
index 000000000..0c5bf2230
--- /dev/null
+++ b/x86_packed_precision_raw_identity_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PackedPrecisionRawGenerationAndWholeProducerIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for index, row := range x86RawPackedPrecisionForms {
+			t.Run(fmt.Sprintf("%s/%s/LL%d/EVEX=%t", arch, row.op, row.length, row.evex), func(t *testing.T) {
+				name := fmt.Sprint("RawPackedPrecision", index)
+				code := rawPackedPrecisionBytes(row.pp, row.length, row.evex, false)
+				header := "TEXT ·" + name + "(SB),4,$0-0\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+				source := header + x86RawDisplacementDirectives(code) + "RET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil || len(file.Funcs) != 1 {
+					t.Fatal("original complete raw precision producer cannot be decoded", err)
+				}
+				original := file.Funcs[0]
+				ordinal := len(original.Instrs) - 2
+				var addresses [16]bool
+				addresses[3], addresses[7] = true, true
+				t.Run("independent-source-domains", func(t *testing.T) {
+					instruction := original.Instrs[ordinal]
+					if x86ResultDirectionAfterSource(instruction, x86ResultDirectionBackward, arch) != x86ResultDirectionBackward ||
+						!x86ResultPreservesPrivateStorage(instruction, arch) ||
+						x86ResultCallerAddressesAfter(instruction, addresses, nil, arch) != addresses {
+						t.Fatal("bound precision opcode revoked independent DF/ID/private-stack/GP-address facts")
+					}
+				})
+				check := func(fn Func, targetArch string) error {
+					triple := "x86_64-unknown-linux-gnu"
+					if targetArch == "386" {
+						triple = "i386-unknown-linux-gnu"
+					}
+					ctx := newX86Ctx(new(strings.Builder), fn, FuncSig{Name: name, Ret: Void}, nil, nil, targetArch, triple, false)
+					return ctx.checkLoweredScalarFPResultInitialization()
+				}
+				if original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("raw precision decoding did not preserve the whole original producer")
+				}
+				if err := check(original, arch); err != nil {
+					t.Fatal("complete initialized raw precision producer lost its paired numerical continuation", err)
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{original.Instrs[ordinal]}})
+				if strings.Contains(features, "+avx512f") != row.evex || row.evex && row.length < 2 && !strings.Contains(features, "+avx512vl") {
+					t.Fatal("low-bank physical precision generation lost its independent native ISA profile", features, row.evex)
+				}
+				for _, mutation := range []string{"origin", "encoded", "whole-producer", "operand", "vector-width", "missing-replay", "snapshot", "header"} {
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					instruction := &candidate.Instrs[ordinal]
+					switch mutation {
+					case "origin":
+						instruction.x86SourceRaw = nil
+					case "encoded":
+						instruction.x86Encoded = !instruction.x86Encoded
+					case "whole-producer":
+						candidate.Instrs[1].Raw += " changed"
+					case "operand":
+						instruction.Args[0].Reg = Reg(string(instruction.Args[0].Reg[:1]) + "3")
+					case "vector-width":
+						instruction.x86VectorBytes = 7
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					case "snapshot":
+						replay := *original.x86RawReplay
+						replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+						replay.normalized[ordinal].x86SourceRaw = nil
+						candidate.x86RawReplay = &replay
+					case "header":
+						candidate.ArgSize++
+					}
+					if err := check(candidate, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited raw source or producer borrowed the original precision continuation", mutation, err)
+					}
+				}
+				foreign := "amd64"
+				if arch == "amd64" {
+					foreign = "386"
+				}
+				if err := check(original, foreign); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw precision source borrowed another architecture", err)
+				}
+				if original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("negative clone corrupted the original independent producer")
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedPrecisionInvalidFormsMatchActualGo(t *testing.T) {
+	for _, instruction := range []string{
+		"CVTPS2PD Y0,X1", "CVTPD2PS X0,Y1", "CVTPS2PD.SAE X0,X1",
+		"VCVTPS2PD X0,Z1", "VCVTPS2PD.Z X0,X1", "VCVTPS2PD.SAE X0,Y1",
+		"VCVTPS2PD.RN_SAE Y0,Z1", "VCVTPS2PD.BCST X0,Y1", "VCVTPS2PD X0,K0,X1",
+		"VCVTPD2PSY X0,X1", "VCVTPD2PSX Y0,X1", "VCVTPD2PSX X0,Y1",
+		"VCVTPD2PS.RN_SAE (BX),Y1", "VCVTPD2PS.SAE Z0,Y1", "VCVTPD2PSX.RN_SAE X0,X1",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			source := "TEXT rejected(SB),4,$0-0\n" + instruction + "\nRET\n"
+			masklessZero := instruction == "VCVTPS2PD.Z X0,X1"
+			historicalReserved := masklessZero && !goToolchainAtLeast(runtime.Version(), 1, 21)
+			goAssemblerOracleOutput(t, "amd64", source, "", historicalReserved)
+			if masklessZero {
+				// Go 1.20's issue-57952 bug emitted EVEX.z=1/aaa=0.
+				// Those actual bytes are reserved, not an additional legal
+				// format. New Go must retain its ordinary source diagnostic.
+				code := []byte{0x62, 0xf1, 0x7c, 0x88, 0x5a, 0xc8}
+				if historicalReserved {
+					listing := x86InsertExtractGoListing(t, "amd64", source)
+					var observed []byte
+					for _, line := range strings.Split(string(listing), "\n") {
+						observed = append(observed, x86InsertExtractListedBytes(line)...)
+					}
+					if !bytes.Equal(observed, append(append([]byte(nil), code...), 0xc3)) {
+						t.Fatalf("historical reserved precision bytes changed: %x", observed)
+					}
+					t.Logf("%s actual Go object emitted reserved z=1/aaa=0 bytes %x, not a legal form", runtime.Version(), code)
+				}
+				if _, _, known, err := decodedX86PackedPrecisionConvertInstruction(code, 64); !known || err == nil {
+					t.Fatal("reserved precision zeroing acquired raw semantics", known, err)
+				}
+				raw := x86RawINSERTPSSource("rejected", code)
+				goAssemblerOracleOutput(t, "amd64", raw, "", true)
+				for _, program := range []string{source, raw} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, program, "func rejected()\n", "amd64", "x86_64-unknown-linux-gnu", api)
+						if ir != "" || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("reserved named/raw zeroing lost syntax rejection or produced IR", api, err)
+						}
+					}
+				}
+			}
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64"); !known || err == nil {
+				t.Fatal("known precision family lacks a closed independent Go grammar", known, err)
+			}
+		})
+	}
+}
diff --git a/x86_packed_precision_receipt_test.go b/x86_packed_precision_receipt_test.go
new file mode 100644
index 000000000..3578db534
--- /dev/null
+++ b/x86_packed_precision_receipt_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// AT&T needs the source-width alias when an m128/m256 conversion has the same
+// X128 destination. Register/broadcast forms keep their canonical mnemonic.
+// This recognizes only those two aliases and binds the actual same-call *m
+// operand to its independent width; another call or a register input cannot
+// supply the missing memory tuple.
+func x86PackedPrecisionNativeMemoryAlias(assembly, constraints, arguments, operation string) bool {
+	if operation != "VCVTPD2PS" {
+		return false
+	}
+	mnemonic, operands, present := strings.Cut(assembly, " ")
+	width := map[string]int{"vcvtpd2psx": 16, "vcvtpd2psy": 32}[mnemonic]
+	if !present || width == 0 {
+		return false
+	}
+	masked := operands == "$2, $0 {%k1}" || operands == "$2, $0 {%k1} {z}"
+	if operands != "$2, $0" && !masked {
+		return false
+	}
+	want := "=x,0,*m,~{memory},~{fpsr}"
+	if strings.HasPrefix(constraints, "=v,") {
+		want = "=v,0,*m,~{memory},~{fpsr}"
+	}
+	if masked {
+		want = "=v,0,*m,r,~{k1},~{memory},~{fpsr}"
+	}
+	return constraints == want && strings.HasPrefix(arguments, "(<4 x float> ") &&
+		strings.Count(arguments, "elementtype(") == 1 &&
+		strings.Contains(arguments, fmt.Sprintf(", ptr elementtype([%d x i8]) %%", width))
+}
+
+func TestX86PackedPrecisionOpcodeReceiptBindsAliasAndActualTuple(t *testing.T) {
+	for _, alias := range []struct {
+		name  string
+		width int
+	}{{"vcvtpd2psx", 16}, {"vcvtpd2psy", 32}} {
+		for _, mode := range []string{"VEX", "EVEX", "merge", "zero"} {
+			t.Run(alias.name+"/"+mode, func(t *testing.T) {
+				prefix, suffix, constraints, mask := "", "", "=x,0,*m,~{memory},~{fpsr}", ""
+				if mode != "VEX" {
+					prefix, constraints = "{evex} ", "=v,0,*m,~{memory},~{fpsr}"
+				}
+				if mode == "merge" || mode == "zero" {
+					prefix, suffix = "kmovw ${3:k}, %k1; "+prefix, " {%k1}"
+					constraints, mask = "=v,0,*m,r,~{k1},~{memory},~{fpsr}", ", i32 %mask"
+				}
+				if mode == "zero" {
+					suffix += " {z}"
+				}
+				line := fmt.Sprintf("  %%result = tail call <4 x float> asm sideeffect %q, %q(<4 x float> %%old, ptr elementtype([%d x i8]) %%input%s) #4",
+					prefix+alias.name+" $2, $0"+suffix, constraints, alias.width, mask)
+				if !x86ScalarPrecisionNativeEffectLine(line, "VCVTPD2PS") {
+					t.Fatal("actual source-width memory alias was rejected", line)
+				}
+				for _, mutation := range []struct{ name, source string }{
+					{"crossed-width", strings.Replace(line, fmt.Sprint(alias.width, " x i8"), fmt.Sprint(48-alias.width, " x i8"), 1)},
+					{"broadcast-width", strings.Replace(line, fmt.Sprint(alias.width, " x i8"), "8 x i8", 1)},
+					{"extended-alias", strings.Replace(line, alias.name, alias.name+"q", 1)},
+					{"different-opcode", strings.Replace(line, alias.name, "vcvtps2pd", 1)},
+					{"register-constraint", strings.Replace(line, "*m", "v", 1)},
+					{"register-input", strings.Replace(line, fmt.Sprintf("ptr elementtype([%d x i8]) %%input", alias.width), "<4 x float> %input", 1)},
+					{"wrong-source-operand", strings.Replace(line, alias.name+" $2", alias.name+" $1", 1)},
+					{"missing-memory-effect", strings.Replace(line, "~{memory}", "~{cc}", 1)},
+					{"missing-status-effect", strings.Replace(line, "~{fpsr}", "~{cc}", 1)},
+					{"missing-side-effect", strings.Replace(line, "asm sideeffect", "asm", 1)},
+					{"comment", strings.Replace(line, alias.name, "# "+alias.name, 1)},
+					{"another-opcode", strings.Replace(line, alias.name, "nop; "+alias.name, 1)},
+					{"another-tuple-argument", strings.Replace(line, "%input", fmt.Sprintf("%%input, ptr elementtype([%d x i8]) %%extra", alias.width), 1)},
+					{"another-call-width", strings.Replace(line, fmt.Sprint(alias.width, " x i8"), "8 x i8", 1) + "\n" + line},
+				} {
+					t.Run(mutation.name, func(t *testing.T) {
+						if x86ScalarPrecisionNativeEffectLine(mutation.source, "VCVTPD2PS") {
+							t.Fatal("alias receipt borrowed an unbound opcode, input, width or side effect", mutation.source)
+						}
+					})
+				}
+				for _, operation := range []string{"VCVTPS2PD", "VCVTSD2SS", "VCVTSS2SD"} {
+					if x86ScalarPrecisionNativeEffectLine(line, operation) {
+						t.Fatal("an alias was accepted for a different canonical operation", operation)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_reciprocal_native_linux_amd64_test.go b/x86_packed_reciprocal_native_linux_amd64_test.go
new file mode 100644
index 000000000..b86b0e216
--- /dev/null
+++ b/x86_packed_reciprocal_native_linux_amd64_test.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86PackedReciprocalNativeMemoryFaults(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	if len(execution.prefix) != 0 {
+		t.Fatal("packed native faults require direct x86 execution")
+	}
+	source, declaration := x86PackedReciprocalDeadSource()
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	var prototypes, originals, rows, referenceRows strings.Builder
+	for index, row := range x86PackedReciprocalReadCases {
+		// Independent original Go bytes preserve the legacy alignment-fault
+		// contract, unlike a portable volatile-byte reference.
+		code := x86OrderingHintGoBytes(t, "amd64", fmt.Sprintf("TEXT original(SB),4,$0-0\n%s (DI),%s2\nRET\n", row.op, row.bank))
+		var atoms []string
+		for _, value := range code {
+			atoms = append(atoms, fmt.Sprintf("0x%02x", value))
+		}
+		name := fmt.Sprint("Original", index)
+		fmt.Fprintf(&prototypes, "extern void PackedEstimate%d(const uint8_t*);\nextern void %s(const uint8_t*);\n", index, name)
+		fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+name+"\n"+name+":\n.byte "+strings.Join(atoms, ",")+"\n")
+		fmt.Fprintf(&rows, "{PackedEstimate%d,%s,%d},\n", index, name, row.width)
+		fmt.Fprintf(&referenceRows, "{%s,%s,%d},\n", name, name, row.width)
+	}
+	driver := x86MemoryFaultSupportC + prototypes.String() + originals.String() +
+		"struct kernel { void (*translated)(const uint8_t*); void (*original)(const uint8_t*); unsigned width; };\n" +
+		"static const struct kernel kernels[]={" + rows.String() + "};\n" + x86PackedReciprocalNativeFaultMainC
+	// The independent 36 observations belong only to this owner, unchanged
+	// source and native host. Every translated API/pipeline is observed anew.
+	originalDriver := strings.Replace(driver, rows.String(), referenceRows.String(), 1)
+	originalExecutable := execution.compileLLVM(t, "packed-estimate-original-faults", "", originalDriver, "-O0")
+	originalOutcomes := make([][6]string, len(x86PackedReciprocalReadCases))
+	for index, row := range x86PackedReciprocalReadCases {
+		for probe := 0; probe < 6; probe++ {
+			want := x86ObserveMemoryFault(t, execution, originalExecutable, index, probe, 1)
+			fault := probe == 0 || probe == 1 || probe == 5 || probe == 3 && row.legacy
+			if fault && want != "segv" && want != "bus" || !fault && want != "return" {
+				t.Fatal("actual original opcode disagrees with its full-width/alignment fault class", row.op, row.width, probe, want)
+			}
+			originalOutcomes[index][probe] = want
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("initialized native pointer source rejected", err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "packed-estimate-native-faults", pipeline.ir, driver, pipeline.level)
+					for index, row := range x86PackedReciprocalReadCases {
+						for probe, want := range originalOutcomes[index] {
+							if got := x86ObserveMemoryFault(t, execution, executable, index, probe, 0); got != want {
+								t.Fatal("dead packed estimate lost its original native memory/alignment outcome", row.op, row.width, probe, got, want)
+							}
+						}
+					}
+				})
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+const x86PackedReciprocalNativeFaultMainC = `
+int main(int argc,char **argv) {
+    unsigned row,probe,original;char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&row,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 || sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            row>=sizeof(kernels)/sizeof(kernels[0]) || probe>=6 || original>1) return 80;
+    if (memory_fault_setup(0)) return 81;
+    struct kernel k=kernels[row];
+    const uint8_t *input=NULL;
+    if (probe==1) input=guard+page-k.width+1;
+    else if (probe==2 || probe==4) input=guard+page-k.width;
+    else if (probe==3) input=guard+1;
+    else if (probe==5) input=guard+page;
+    if (probe==4 && mprotect(guard,page,PROT_READ)) return 82;
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 83;
+    if (original) k.original(input); else k.translated(input);
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout)?85:0;
+}
+`
diff --git a/x86_packed_reciprocal_native_read_test.go b/x86_packed_reciprocal_native_read_test.go
new file mode 100644
index 000000000..bf18587c0
--- /dev/null
+++ b/x86_packed_reciprocal_native_read_test.go
@@ -0,0 +1,359 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Complete legacy/VEX packed estimate formats, independently of production.
+// Scalar SS estimates and the EVEX 14/28 families have separate owners.
+var x86PackedReciprocalReadCases = []struct {
+	op, bank string
+	width    int
+	legacy   bool
+}{
+	{"RCPPS", "X", 16, true}, {"RSQRTPS", "X", 16, true},
+	{"VRCPPS", "X", 16, false}, {"VRCPPS", "Y", 32, false},
+	{"VRSQRTPS", "X", 16, false}, {"VRSQRTPS", "Y", 32, false},
+}
+
+func TestX86PackedReciprocalBytesAndNativePermissionBoundary(t *testing.T) {
+	for _, row := range x86PackedReciprocalReadCases {
+		t.Run(row.op+row.bank, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.op+" "+row.bank+"0,"+row.bank+"2")
+			mask := x86CallerVectorByteMask(int64(row.width))
+			for missing := -1; missing < row.width; missing++ {
+				initial := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				initial.writeVector(0, row.width, mask, true)
+				initial.writeVector(2, 64, 0x55aa00ff00ff55aa, true)
+				initial.pointerGP[7], initial.masks[1] = true, true
+				if missing >= 0 {
+					initial.writeVector(0, row.width, mask&^(1<<uint(missing)), true)
+				}
+				state, want := initial.clone(), initial.clone()
+				defined := mask
+				if missing >= 0 {
+					defined = 0
+				}
+				want.writeVector(2, row.width, defined, row.legacy)
+				if accepted, known := x86ResultPackedReciprocalStep(ins, &state, nil, "amd64", false); !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("packed estimate invented input bytes or changed unrelated state", missing, state, want)
+				}
+			}
+			ins.Args[0] = x86ScalarLaneInstruction(t, row.op+" (AX),"+row.bank+"2").Args[0]
+			initial := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+			initial.pointerGP[0] = true
+			for _, native := range []bool{false, true} {
+				state := initial.clone()
+				accepted, known := x86ResultPackedReciprocalStep(ins, &state, nil, "amd64", native)
+				if !known || accepted != native {
+					t.Fatal("strict proof acquired native storage or paired native read lost its address", native, accepted, known)
+				}
+				want := initial.clone()
+				if native {
+					want.writeVector(2, row.width, mask, row.legacy)
+				}
+				if !reflect.DeepEqual(state, want) {
+					t.Fatal("native continuation supplied unrelated permissions", state, want)
+				}
+			}
+			for _, mutate := range []func(*Instr, *x86ResultState){
+				func(_ *Instr, s *x86ResultState) { s.pointerGP[0] = false },
+				func(i *Instr, _ *x86ResultState) { i.x86Encoded = true },
+				func(i *Instr, _ *x86ResultState) { i.x86AddressBits = 32 },
+				func(i *Instr, _ *x86ResultState) { i.x86UnboundAddressOverride = true },
+			} {
+				changed, state := ins, initial.clone()
+				mutate(&changed, &state)
+				before := state.clone()
+				if accepted, _ := x86ResultPackedReciprocalStep(changed, &state, nil, "amd64", true); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("native estimate granted a missing pointer, raw entry or address binding")
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedReciprocalRegisterEstimatesRemainPureAndCSE(t *testing.T) {
+	for _, row := range x86PackedReciprocalReadCases {
+		t.Run(row.op+row.bank, func(t *testing.T) {
+			source := "TEXT ·Estimate(SB),4,$0-16\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),AX\n" +
+				fmt.Sprintf("VMOVUPS (AX),%s0\n%s %s0,%s1\n%s %s0,%s2\n", row.bank, row.op, row.bank, row.bank, row.op, row.bank, row.bank)
+			store := "VMOVUPS"
+			if row.legacy {
+				store = "MOVUPS"
+			}
+			source += fmt.Sprintf("%s %s1,(DI)\n%s %s2,32(DI)\nRET\n", store, row.bank, store, row.bank)
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func Estimate(out *[64]byte,input *[32]byte)\n", "amd64", "x86_64-unknown-linux-gnu", "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			intrinsic := "@llvm.x86.sse.rcp.ps("
+			if strings.Contains(row.op, "RSQRT") {
+				intrinsic = "@llvm.x86.sse.rsqrt.ps("
+			}
+			if row.width == 32 {
+				intrinsic = strings.Replace(intrinsic, ".sse.", ".avx.", 1)
+				intrinsic = strings.Replace(intrinsic, ".ps(", ".ps.256(", 1)
+			}
+			before := x86StringMemoryFunction(t, ir, "Estimate")
+			after := x86StringMemoryFunction(t, x86DwordProductIROptimize(t, ir), "Estimate")
+			if strings.Count(before, intrinsic) != 2 || strings.Count(after, intrinsic) != 1 || strings.Contains(before, "asm sideeffect \""+strings.ToLower(row.op)) {
+				t.Fatal("pure register estimate lost its original intrinsic or legal CSE", before, after)
+			}
+		})
+	}
+}
+
+func TestX86PackedReciprocalPublicInstructionCaseNormalization(t *testing.T) {
+	for _, row := range x86PackedReciprocalReadCases {
+		for _, memory := range []bool{false, true} {
+			for _, name := range []string{row.op, strings.ToLower(row.op), strings.ToLower(row.op[:2]) + row.op[2:]} {
+				t.Run(fmt.Sprint(name, row.bank, "/memory=", memory), func(t *testing.T) {
+					operand := row.bank + "0"
+					if memory {
+						operand = "(AX)"
+					}
+					source := fmt.Sprintf("TEXT Estimate(SB),4,$0-8\nMOVQ p+0(FP),AX\n%s %s,%s2\nRET\n", row.op, operand, row.bank)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for index := range file.Funcs[0].Instrs {
+						if file.Funcs[0].Instrs[index].Op == Op(row.op) {
+							file.Funcs[0].Instrs[index].Op = Op(name)
+						}
+					}
+					pkg := mustGoPackage(t, "normalization", "package normalization\nfunc Estimate(p *[32]byte)\n")
+					resolve := func(symbol string) string { return symbol }
+					signatures, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: signatures})
+					if err != nil {
+						t.Fatal("public lowercase instruction lost its original class", err)
+					}
+					body := x86StringMemoryFunction(t, ir, "Estimate")
+					if memory {
+						if !strings.Contains(body, `asm sideeffect "`+strings.ToLower(row.op)+` `) {
+							t.Fatal("case normalization changed native opcode", body)
+						}
+					} else if strings.Contains(row.op, "RSQRT") != strings.Contains(body, ".rsqrt.ps") {
+						t.Fatal("case normalization changed reciprocal versus reciprocal-square-root", body)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedReciprocalNativeFaultOwnerRetainsRequiredExecution(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_packed_reciprocal_native_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	required := map[string]int{
+		"x87IA32RequireNativeHost": 2, "x86FloatCompareExecutionTools": 1, "execution.requireAVX": 1,
+		"goAssemblerOracleOutput": 1, "x86OrderingHintGoBytes": 1, "x86ScalarFPBitViewAPI": 1,
+		"x86DwordProductIROptimize": 1, "execution.compileLLVM": 2, "x86ObserveMemoryFault": 2,
+	}
+	if err := x86CheckHalfIndirectCommandOwner(file, "TestCrossLinuxRuntimeMatrixX86PackedReciprocalNativeMemoryFaults", required); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86PackedReciprocalMode32FrontendAddressNeedsPhysicalBinding(t *testing.T) {
+	for _, row := range x86PackedReciprocalReadCases {
+		if row.legacy {
+			continue
+		}
+		for _, address := range []string{"16(R9)", "4294967295(R9)"} {
+			t.Run(row.op+row.bank+address, func(t *testing.T) {
+				instruction := row.op + " " + address + "," + row.bank + "2"
+				goAssemblerOracleOutput(t, "386", "TEXT format(SB),4,$0-0\n"+instruction+"\nRET\n", "", true)
+				ins := x86ScalarLaneInstruction(t, instruction)
+				if _, known, err := x86PackedReciprocalProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go's accepted mode32 frontend address acquired a physical binding or was mistaken for invalid grammar", known, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedReciprocalNativeReadsPhysicalTargetsAndBackendBoundary(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declaration := x86PackedReciprocalDeadSource()
+			if target.arch == "386" {
+				source = strings.ReplaceAll(strings.ReplaceAll(source, "MOVQ ", "MOVL "), "$0-8", "$0-4")
+			}
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("physical estimate memory source rejected", api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "packed-native.ll", "packed-native.o", ir)
+			}
+		})
+	}
+	source, declaration := x86PackedReciprocalDeadSource()
+	for _, target := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", target, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("native packed estimate crossed its backend boundary", target, api, err)
+			}
+		}
+	}
+}
+
+func TestX86PackedReciprocalTypedInputsAndInitializedPublicSources(t *testing.T) {
+	for _, row := range x86PackedReciprocalReadCases {
+		for _, memory := range []bool{false, true} {
+			first, preload := row.bank+"0", fmt.Sprintf("VMOVUPS (AX),%s0\n", row.bank)
+			if memory {
+				first, preload = "(AX)", ""
+			}
+			instruction := row.op + " " + first + "," + row.bank + "2"
+			t.Run(instruction, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, instruction)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				upper := x86TypedVectorUpperZero
+				if row.legacy {
+					upper = x86TypedVectorUpperPreserve
+				}
+				if !known || err != nil || !effect.requiresResultProof || len(effect.operands) != 2 ||
+					effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.vector.upperWrite != upper {
+					t.Error("packed estimate has no complete typed input/write/alias owner", known, err, effect)
+				} else if source, destination := effect.operands[0], effect.operands[1]; source.index != 0 || !source.read || source.write || source.width != int64(row.width) ||
+					destination.index != 1 || destination.read || !destination.write || destination.width != int64(row.width) ||
+					memory && row.legacy && effect.vector.memoryAlignment != 16 {
+					t.Error("packed estimate confused full input, written bytes or legacy native alignment", effect)
+				}
+				// No target-input preload in the memory case: the operation owns
+				// that read. The old Y value separately exposes legacy upper bytes.
+				source := "TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),AX\nMOVQ old+16(FP),BX\n" +
+					"VMOVUPS (BX),Y2\n" + preload + instruction + "\nVMOVUPS Y2,(DI)\nRET\n"
+				declaration := "func Value(out,input,old *[32]byte)\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				missing := preload
+				if memory {
+					missing = "MOVQ input+8(FP),AX\n"
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+							t.Fatal("initialized packed estimate source rejected", err)
+						}
+						negative := strings.Replace(source, missing, "", 1)
+						if negative == source {
+							t.Fatal("missing-input control lost its actual source")
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if !memory {
+							x86VectorScratchCodegenControl(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("packed estimate supplied an observed numerical source or native address", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func x86PackedReciprocalDeadSource() (string, string) {
+	var source, declarations strings.Builder
+	for index, row := range x86PackedReciprocalReadCases {
+		fmt.Fprintf(&source, "TEXT ·PackedEstimate%d(SB),4,$0-8\nMOVQ input+0(FP),AX\n%s (AX),%s2\nRET\n", index, row.op, row.bank)
+		fmt.Fprintf(&declarations, "func PackedEstimate%d(input *[32]byte)\n", index)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86PackedReciprocalDeadNativeReadsActualOptimizedObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	source, declaration := x86PackedReciprocalDeadSource()
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+		if err != nil {
+			t.Fatal("initialized incoming native pointer rejected", api, err)
+		}
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/IR_O2=%t", api, optimized), func(t *testing.T) {
+				text, level := ir, "-O0"
+				if optimized {
+					text, level = x86DwordProductIROptimize(t, ir), "-O2"
+				}
+				for index, row := range x86PackedReciprocalReadCases {
+					body := x86StringMemoryFunction(t, text, fmt.Sprint("PackedEstimate", index))
+					t.Logf("actual %s/%d IR body:\n%s", row.op, row.width, body)
+					volatile := strings.Contains(body, fmt.Sprintf("load volatile <%d x i8>", row.width))
+					native := strings.Contains(body, fmt.Sprintf("call <%d x float> asm sideeffect", row.width/4)) &&
+						strings.Contains(body, fmt.Sprintf("elementtype([%d x i8])", row.width)) &&
+						strings.Contains(body, "*m") && strings.Contains(body, strings.ToLower(row.op))
+					if !volatile && !native {
+						t.Errorf("dead packed estimate lost its observable full-width native source: %s/%d\n%s", row.op, row.width, body)
+					}
+				}
+				directory := t.TempDir()
+				input, object := filepath.Join(directory, "dead.ll"), filepath.Join(directory, "dead.o")
+				if err := os.WriteFile(input, []byte(text), 0600); err != nil {
+					t.Fatal(err)
+				}
+				x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=x86_64-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+				listing := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "--disassemble", object))
+				objectBytes, err := os.ReadFile(object)
+				if err != nil {
+					t.Fatal(err)
+				}
+				t.Logf("actual LLVM22 %s object SHA256=%x IR SHA256=%x\n%s", level, sha256.Sum256(objectBytes), sha256.Sum256([]byte(text)), listing)
+				sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <(PackedEstimate[0-9]+)>:\n`).FindAllSubmatchIndex(listing, -1)
+				if len(sections) != len(x86PackedReciprocalReadCases) {
+					t.Fatal("dead packed estimate object lost an original function", string(listing))
+				}
+				for index, section := range sections {
+					end := len(listing)
+					if index+1 < len(sections) {
+						end = sections[index+1][0]
+					}
+					body := string(listing[section[1]:end])
+					reads := regexp.MustCompile(`\b(?:v?rcpps|v?rsqrtps|v?mov[a-z0-9]*)\s+[^,\n]*\([^\n)]+\),[^\n]*`).FindAllString(body, -1)
+					bank := "%xmm"
+					if x86PackedReciprocalReadCases[index].width == 32 {
+						bank = "%ymm"
+					}
+					access := false
+					for _, read := range reads {
+						access = access || strings.Contains(read, bank) && !strings.Contains(read, "%rsp") && !strings.Contains(read, "%rbp") && !strings.Contains(read, "%rip")
+					}
+					if !access {
+						t.Errorf("actual object removed the original non-stack native access in %s:\n%s", listing[section[2]:section[3]], body)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_shift_complete_objects_test.go b/x86_packed_shift_complete_objects_test.go
new file mode 100644
index 000000000..001739a33
--- /dev/null
+++ b/x86_packed_shift_complete_objects_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86PackedShiftPhysicalWitness struct {
+	row x86PackedShiftRawCase
+	w   bool
+}
+
+func x86PackedShiftPhysicalWitnesses() []x86PackedShiftPhysicalWitness {
+	var witnesses []x86PackedShiftPhysicalWitness
+	for _, row := range x86PackedShiftRawCases() {
+		witnesses = append(witnesses, x86PackedShiftPhysicalWitness{row: row})
+		if row.wig() {
+			witnesses = append(witnesses, x86PackedShiftPhysicalWitness{row: row, w: true})
+		}
+	}
+	return witnesses
+}
+
+func x86PackedShiftCompletePublicObjects(t *testing.T, arch, triple, source, declarations string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete initialized packed-shift objects require LLVM22 llc")
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, source)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("initialized complete packed-shift source lost its public object consumer", err)
+			}
+			for _, pipeline := range []struct{ name, input, level string }{
+				{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+				{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					x86PackedStringCompileObject(t, llc, triple, pipeline.input, pipeline.level)
+				})
+			}
+		})
+	}
+}
+
+func x86PackedShiftCompletePhysicalObjectPart(t *testing.T, arch, triple string, part int) {
+	t.Helper()
+	rows := x86PackedShiftPhysicalWitnesses()
+	if len(rows) != 850 || part < 0 || part >= 4 {
+		t.Fatal("complete physical object partition changed", len(rows), part)
+	}
+	first, last := len(rows)*part/4, len(rows)*(part+1)/4
+	for start := first; start < last; start += 48 {
+		end := start + 48
+		if end > last {
+			end = last
+		}
+		t.Run(fmt.Sprintf("rows_%d_%d", start, end), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index := start; index < end; index++ {
+				witness := rows[index]
+				program, declaration, _ := witness.row.program(arch, true)
+				if witness.w {
+					program = strings.Replace(program, x86RawDisplacementDirectives(witness.row.code(false)),
+						x86RawDisplacementDirectives(witness.row.code(true)), 1)
+				}
+				name := fmt.Sprint("PhysicalShift", index)
+				source.WriteString(strings.Replace(program, "·Shift(SB)", "·"+name+"(SB)", 1))
+				declarations.WriteString(strings.Replace(declaration, "func Shift(", "func "+name+"(", 1) + "\n")
+			}
+			x86PackedShiftCompletePublicObjects(t, arch, triple, source.String(), declarations.String())
+		})
+	}
+	// This proves initialized public LLVM objects, not execution of original
+	// Go code or positive LLVM-MC recognition of the 54 documented W1 gaps.
+	t.Logf("complete physical interval [%d,%d)/850; <=48 initialized functions/capture; three public APIs and pipelines", first, last)
+}
+
+func TestX86PackedShiftRawCompleteLinux386Part0(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i386-unknown-linux-gnu", 0)
+}
+
+func TestX86PackedShiftRawCompleteLinux386Part1(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i386-unknown-linux-gnu", 1)
+}
+
+func TestX86PackedShiftRawCompleteLinux386Part2(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i386-unknown-linux-gnu", 2)
+}
+
+func TestX86PackedShiftRawCompleteLinux386Part3(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i386-unknown-linux-gnu", 3)
+}
+
+func TestX86PackedShiftRawCompleteWindows386Part0(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i686-pc-windows-msvc", 0)
+}
+
+func TestX86PackedShiftRawCompleteWindows386Part1(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i686-pc-windows-msvc", 1)
+}
+
+func TestX86PackedShiftRawCompleteWindows386Part2(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i686-pc-windows-msvc", 2)
+}
+
+func TestX86PackedShiftRawCompleteWindows386Part3(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "386", "i686-pc-windows-msvc", 3)
+}
+
+func TestX86PackedShiftRawCompleteLinuxAMD64Part0(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-unknown-linux-gnu", 0)
+}
+
+func TestX86PackedShiftRawCompleteLinuxAMD64Part1(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-unknown-linux-gnu", 1)
+}
+
+func TestX86PackedShiftRawCompleteLinuxAMD64Part2(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-unknown-linux-gnu", 2)
+}
+
+func TestX86PackedShiftRawCompleteLinuxAMD64Part3(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-unknown-linux-gnu", 3)
+}
+
+func TestX86PackedShiftRawCompleteDarwinAMD64Part0(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-apple-darwin", 0)
+}
+
+func TestX86PackedShiftRawCompleteDarwinAMD64Part1(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-apple-darwin", 1)
+}
+
+func TestX86PackedShiftRawCompleteDarwinAMD64Part2(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-apple-darwin", 2)
+}
+
+func TestX86PackedShiftRawCompleteDarwinAMD64Part3(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-apple-darwin", 3)
+}
+
+func TestX86PackedShiftRawCompleteWindowsAMD64Part0(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-pc-windows-msvc", 0)
+}
+
+func TestX86PackedShiftRawCompleteWindowsAMD64Part1(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-pc-windows-msvc", 1)
+}
+
+func TestX86PackedShiftRawCompleteWindowsAMD64Part2(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-pc-windows-msvc", 2)
+}
+
+func TestX86PackedShiftRawCompleteWindowsAMD64Part3(t *testing.T) {
+	x86PackedShiftCompletePhysicalObjectPart(t, "amd64", "x86_64-pc-windows-msvc", 3)
+}
+
+func x86PackedShiftOriginal396Objects(t *testing.T, triple string) {
+	t.Helper()
+	kernels := x86PackedShiftOriginalRuntimeDirectory(t, "")
+	if len(kernels) != 396 {
+		t.Fatal("original complete initialized object denominator changed", len(kernels))
+	}
+	for start := 0; start < len(kernels); start += 36 {
+		end := start + 36
+		if end > len(kernels) {
+			end = len(kernels)
+		}
+		t.Run(fmt.Sprintf("kernels_%d_%d", start, end), func(t *testing.T) {
+			var source strings.Builder
+			for _, kernel := range kernels[start:end] {
+				source.WriteString(kernel.source)
+			}
+			x86PackedShiftCompletePublicObjects(t, "amd64", triple, source.String(),
+				x86PackedShiftOriginalDeclarations(kernels[start:end], false))
+		})
+	}
+}
+
+func TestX86PackedShiftOriginal396ObjectsLinuxAMD64(t *testing.T) {
+	x86PackedShiftOriginal396Objects(t, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86PackedShiftOriginal396ObjectsDarwinAMD64(t *testing.T) {
+	x86PackedShiftOriginal396Objects(t, "x86_64-apple-darwin")
+}
+
+func TestX86PackedShiftOriginal396ObjectsWindowsAMD64(t *testing.T) {
+	x86PackedShiftOriginal396Objects(t, "x86_64-pc-windows-msvc")
+}
diff --git a/x86_packed_shift_original_runtime_directory_test.go b/x86_packed_shift_original_runtime_directory_test.go
new file mode 100644
index 000000000..a549c9435
--- /dev/null
+++ b/x86_packed_shift_original_runtime_directory_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86PackedShiftOriginalKernel struct {
+	name, instruction, source string
+	width, lane, operation    int
+	mode, zero, oldCounts     int
+	raw                       bool
+	physical                  x86PackedShiftRawCase
+}
+
+// Keep the complete original 396-kernel protocol, including raw destination1
+// aliasing the count input. Actual Go bytes are captured in one owned assembly
+// invocation per partition, rather than launching 198 independent assemblers.
+func x86PackedShiftOriginalRuntimeDirectory(t *testing.T, memberName string) []x86PackedShiftOriginalKernel {
+	t.Helper()
+	x86PackedShiftRawOriginalUnchanged(t)
+	var kernels []x86PackedShiftOriginalKernel
+	var originalInstructions strings.Builder
+	index, rawRows := 0, 0
+	for _, member := range x86PackedShiftRawMembers {
+		if member.mode != "lane" {
+			continue
+		}
+		operation := 0
+		if strings.HasPrefix(member.op, "VPSRL") {
+			operation = 1
+		} else if strings.HasPrefix(member.op, "VPSRA") {
+			operation = 2
+		}
+		for length, bank := range []string{"X", "Y", "Z"} {
+			for mode := 0; mode < 5; mode++ {
+				if mode == 4 && member.bits == 16 {
+					continue
+				}
+				for _, zero := range []bool{false, true} {
+					if zero && mode < 2 {
+						continue
+					}
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("shift%d", index)
+						index++
+						if memberName != "" && member.op != memberName {
+							continue
+						}
+						input, suffix, mask, destination := "(BX)", "", "", 0
+						row := x86PackedShiftRawCase{member: member, width: 16 << length, input: "memory"}
+						if mode == 0 || mode == 2 {
+							input, row.input = bank+"1", "register"
+						}
+						if mode == 4 {
+							suffix, row.input = ".BCST", "broadcast"
+						}
+						if mode >= 2 {
+							mask, row.mask = "K1,", 1
+						}
+						if zero {
+							suffix, row.mask = suffix+".Z", 2
+						}
+						if raw {
+							destination = 1
+						}
+						instruction := fmt.Sprintf("%s%s %s,%s0,%s%s%d", member.op, suffix, input, bank, mask, bank, destination)
+						kernel := x86PackedShiftOriginalKernel{name: name, instruction: instruction,
+							width: row.width, lane: member.bits / 8, operation: operation, mode: mode, raw: raw}
+						if zero {
+							kernel.zero = 1
+						}
+						if raw && (mode == 0 || mode == 2) {
+							kernel.oldCounts = 1
+						}
+						row.evex = !member.vex || row.width == 64 || row.mask != 0 || row.input == "broadcast"
+						kernel.physical = row
+						kernels = append(kernels, kernel)
+						if raw {
+							originalInstructions.WriteString(instruction + "\n")
+							rawRows++
+						}
+					}
+				}
+			}
+		}
+	}
+	if index != 396 || len(kernels) == 0 || rawRows*2 != len(kernels) {
+		t.Fatal("original complete named/raw partition denominator changed", index, len(kernels), rawRows)
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", originalInstructions.String()+"RET")
+	if len(pcs) != rawRows+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("actual original Go instructions/PC boundaries incomplete", len(pcs), rawRows)
+	}
+	rawIndex := 0
+	for index := range kernels {
+		kernel := &kernels[index]
+		var source strings.Builder
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nMOVQ data+0(FP),AX\nMOVQ counts+8(FP),BX\nMOVQ out+16(FP),DI\nVMOVUPS (AX),Z0\n", kernel.name)
+		if kernel.mode == 0 || kernel.mode == 2 {
+			source.WriteString("VMOVUPS (BX),Z1\n")
+		} else if kernel.raw {
+			source.WriteString("VMOVUPS (AX),Z1\n")
+		}
+		if kernel.mode >= 2 {
+			source.WriteString("KMOVQ mask+24(FP),K1\n")
+		}
+		destination := 0
+		if kernel.raw {
+			destination = 1
+			observed := code[pcs[rawIndex]:pcs[rawIndex+1]]
+			rawIndex++
+			independent := kernel.physical.code(false)
+			modrm := 4
+			if kernel.physical.evex {
+				modrm = 5
+			}
+			independent[modrm] = independent[modrm]&^0x38 | 8 // Original destination1.
+			if !bytes.Equal(observed, independent) {
+				t.Fatal("actual Go bytes differ from the independent original raw kernel", kernel.name, kernel.instruction, observed, independent)
+			}
+			source.WriteString(x86RawDisplacementDirectives(observed))
+		} else {
+			source.WriteString(kernel.instruction + "\n")
+		}
+		fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\nVMOVUPS Y%d,64(DI)\nVMOVUPS X%d,96(DI)\nRET\n", destination, destination, destination)
+		kernel.source = source.String()
+	}
+	return kernels
+}
+
+func x86PackedShiftOriginalDeclarations(kernels []x86PackedShiftOriginalKernel, c bool) string {
+	var declarations strings.Builder
+	for _, kernel := range kernels {
+		if c {
+			fmt.Fprintf(&declarations, "extern void %s(const void*,const void*,void*,uint64_t);\n", kernel.name)
+		} else {
+			fmt.Fprintf(&declarations, "func %s(data,counts,out *byte,mask uint64)\n", kernel.name)
+		}
+	}
+	return declarations.String()
+}
+
+// Evaluate only the original mainC string-concatenation AST. Every literal,
+// lane/reference function and positive guard observation remains byte-for-byte
+// original; only the partition's ordinary extern declarations are substituted.
+func x86PackedShiftOriginalC(t *testing.T, declarations string) string {
+	t.Helper()
+	x86PackedShiftRawOriginalUnchanged(t)
+	file, err := parser.ParseFile(token.NewFileSet(), "amd64_raw_variable_shift_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var evaluate func(ast.Expr) string
+	evaluate = func(expression ast.Expr) string {
+		switch value := expression.(type) {
+		case *ast.BasicLit:
+			text, err := strconv.Unquote(value.Value)
+			if value.Kind != token.STRING || err != nil {
+				t.Fatal("original C lost its exact string literal", err)
+			}
+			return text
+		case *ast.BinaryExpr:
+			if value.Op == token.ADD {
+				return evaluate(value.X) + evaluate(value.Y)
+			}
+		case *ast.Ident:
+			if value.Name == "x86TestGuardPagesC" {
+				return x86TestGuardPagesC
+			}
+		case *ast.CallExpr:
+			selector, ok := value.Fun.(*ast.SelectorExpr)
+			if ok && len(value.Args) == 0 && selector.Sel.Name == "String" {
+				if receiver, ok := selector.X.(*ast.Ident); ok && receiver.Name == "decl" {
+					return declarations
+				}
+			}
+		}
+		t.Fatalf("unrecognized original C composition %T", expression)
+		return ""
+	}
+	var result string
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86VariableShiftMemoryAndViewsRuntime" {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			if ok && name.Name == "mainC" {
+				if result != "" {
+					t.Fatal("duplicate original complete C owner")
+				}
+				result = evaluate(assignment.Rhs[0])
+			}
+			return true
+		})
+	}
+	if result == "" {
+		t.Fatal("original complete C reference disappeared")
+	}
+	return result
+}
diff --git a/x86_packed_shift_original_runtime_unix_test.go b/x86_packed_shift_original_runtime_unix_test.go
new file mode 100644
index 000000000..4686435f5
--- /dev/null
+++ b/x86_packed_shift_original_runtime_unix_test.go
@@ -0,0 +1,279 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86PackedShiftOriginal396ActualHost(t *testing.T, member string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("original complete packed-shift execution requires LLVM22 llc/clang")
+	}
+	kernels := x86PackedShiftOriginalRuntimeDirectory(t, member)
+	want := 48
+	if strings.HasSuffix(member, "W") {
+		want = 36
+	}
+	if len(kernels) != want {
+		t.Fatal("original complete member partition changed", member, len(kernels), want)
+	}
+	var source, declarations, externs, cases strings.Builder
+	for _, kernel := range kernels {
+		source.WriteString(kernel.source)
+		fmt.Fprintf(&cases, "{%s,%q,%d,%d,%d,%d,%d,%d,0},\n", kernel.name, kernel.name,
+			kernel.width, kernel.lane, kernel.operation, kernel.mode, kernel.zero, kernel.oldCounts)
+	}
+	declarations.WriteString(x86PackedShiftOriginalDeclarations(kernels, false))
+	externs.WriteString(x86PackedShiftOriginalDeclarations(kernels, true))
+	// The original 396 kernels are unmodified. Add twelve independent Full
+	// immediate W witnesses per W member to execute the formerly incorrect
+	// E4.nb class, without multiplying the entire physical grammar again.
+	if strings.HasSuffix(member, "W") {
+		uniform := strings.Replace(member, "VW", "W", 1)
+		extra := 0
+		for _, row := range x86PackedShiftRawCases() {
+			if row.member.op != uniform || !row.evex || !row.immediate || row.input != "memory" || row.mask == 0 {
+				continue
+			}
+			for _, raw := range []bool{false, true} {
+				name := fmt.Sprint("fullImmediate", extra)
+				extra++
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ data+0(FP),AX\nMOVQ counts+8(FP),BX\n"+
+					"MOVQ out+16(FP),DI\nVMOVUPS (AX),Z0\nVMOVUPS (AX),Z2\nKMOVQ mask+24(FP),K1\n", name)
+				if raw {
+					source.WriteString(x86RawDisplacementDirectives(row.code(false)))
+				} else {
+					source.WriteString(row.instruction() + "\n")
+				}
+				source.WriteString("VMOVUPS Z2,(DI)\nVMOVUPS Y2,64(DI)\nVMOVUPS X2,96(DI)\nRET\n")
+				fmt.Fprintf(&declarations, "func %s(data,counts,out *byte,mask uint64)\n", name)
+				fmt.Fprintf(&externs, "extern void %s(const void*,const void*,void*,uint64_t);\n", name)
+				operation, zero := 0, 0
+				if uniform == "VPSRLW" {
+					operation = 1
+				} else if uniform == "VPSRAW" {
+					operation = 2
+				}
+				if row.mask == 2 {
+					zero = 1
+				}
+				fmt.Fprintf(&cases, "{%s,%q,%d,2,%d,3,%d,0,1},\n", name, name, row.width, operation, zero)
+			}
+		}
+		if extra != 12 {
+			t.Fatal("complete W Full-immediate regression partition changed", extra)
+		}
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "Go")
+	if err != nil || ir == "" {
+		t.Fatal("actual original complete initialized kernels lost their execution consumer", err)
+	}
+	ir, err = x86PackedShiftPortableIR(source.String(), ir)
+	if err != nil {
+		t.Fatal("actual-host portable packed-shift projection lost exact source/IR ownership", err)
+	}
+	driver := x86PackedShiftOriginalActualHostHeader + x86PackedShiftOriginalC(t, externs.String()) +
+		numericalRuntimeFaultObservationC + x86PackedShiftOriginalActualHostObservation +
+		"static const struct shift_case cases[]={\n" + cases.String() + "};\n" + x86PackedShiftOriginalActualHostMain
+	if err := runtimeOracleFaultCorePolicy(x86PackedShiftOriginalActualHostObservation); err != nil {
+		t.Fatal("actual fault child lost the shared first-action resource policy", err)
+	}
+	for _, pipeline := range []struct {
+		name     string
+		backend  int
+		optimize bool
+	}{{"backend_O0", 0, false}, {"backend_O2", 2, false}, {"IR_O2_backend_O2", 2, true}} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			input := ir
+			if pipeline.optimize {
+				input = x86DwordProductIROptimize(t, input)
+			}
+			compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "original-packed-shift", triple,
+				input, driver, nil, pipeline.backend)
+		})
+	}
+	t.Logf("%s: %d/396 original named/raw kernels, exact original C/96 samples/112-byte aliases/guard observations; <=48 functions; three pipelines; checked actual-host portable LLVM execution on every host, not original Go native qualification", member, len(kernels))
+}
+
+const x86PackedShiftOriginalActualHostHeader = `
+#include <errno.h>
+#include <signal.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+`
+
+const x86PackedShiftOriginalActualHostObservation = `
+struct shift_case {
+    void (*run)(const void*,const void*,void*,uint64_t);
+    const char *name;
+    unsigned width,bytes,operation,mode,zero,oldCounts,fullImmediate;
+};
+static int observe_original_shift(const struct shift_case *test,unsigned readable,uint64_t mask) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        uint8_t data[64],output[114],want[112]={0};
+        memset(data,255,sizeof(data));
+        memset(output,0xa7,sizeof(output));
+        unsigned lanes=test->width/test->bytes;
+        for(unsigned i=0;i<lanes;i++) {
+            unsigned active=test->mode<2 || ((mask>>i)&1);
+            unsigned byte=active?(test->fullImmediate?0:255):(!test->zero && !test->oldCounts?255:0);
+            memset(want+i*test->bytes,byte,test->bytes);
+        }
+        memcpy(want+64,want,32);
+        memcpy(want+96,want,16);
+        numerical_fault_begin(guard+page,page);
+        test->run(data,guard+page-readable,output+1,mask);
+        if(output[0]!=0xa7 || output[113]!=0xa7 || memcmp(output+1,want,112)) _exit(122);
+        for(unsigned i=0;i<64;i++) if(data[i]!=255) _exit(122);
+        _exit(0);
+    }
+    int status=0;
+    pid_t waited;
+    do { waited=waitpid(child,&status,0); } while(waited<0 && errno==EINTR);
+    if(waited!=child) return -2;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(numerical_fault_status(status)) return 1;
+    return -3;
+}
+static int check_full_immediate(const struct shift_case *test) {
+    for(unsigned sample=0;sample<96;sample++) {
+        uint8_t data[64],memory[64],output[112],want[112]={0};
+        for(unsigned i=0;i<64;i++) {
+            data[i]=(uint8_t)(31*i+17*sample);
+            memory[i]=(uint8_t)(71*i+23*sample+128);
+        }
+        unsigned lanes=test->width/test->bytes;
+        uint64_t mask=sample==0?0:sample==1?UINT64_C(1)<<63:sample==2?UINT64_MAX:
+            UINT64_C(0x5a5a01239876cdef)>>(sample%32);
+        for(unsigned i=0;i<lanes;i++) {
+            uint64_t value=(mask>>i)&1?shifted(lane(memory+i*test->bytes,test->bytes),5,16,test->operation):
+                test->zero?0:lane(data+i*test->bytes,test->bytes);
+            memcpy(want+i*test->bytes,&value,test->bytes);
+        }
+        memcpy(want+64,want,32);
+        memcpy(want+96,want,16);
+        test->run(data,memory,output,mask);
+        if(memcmp(output,want,112)) return 1;
+    }
+    return 0;
+}
+static int check_shift_probe(const struct shift_case *test,unsigned readable,uint64_t mask,unsigned required) {
+    int got=observe_original_shift(test,readable,mask);
+    if(got!=(required>readable)) {
+        fprintf(stderr,"%s readable=%u mask=%llx required=%u observation=%d\n",test->name,
+                readable,(unsigned long long)mask,required,got);
+        return 1;
+    }
+    return 0;
+}
+`
+
+const x86PackedShiftOriginalActualHostMain = `
+int main(void) {
+    puts("PACKED_SHIFT_ACTUAL_HOST_PORTABLE_LLVM_NOT_ORIGINAL_GO_NATIVE");
+    fflush(stdout);
+    if(setup_guard()) return 2;
+    memset(guard+page-64,0,64);
+    unsigned original=0,immediate=0,probes=0;
+    for(unsigned n=0;n<sizeof(cases)/sizeof(cases[0]);n++) {
+        const struct shift_case *test=cases+n;
+        if(test->fullImmediate) {
+            if(check_full_immediate(test)) return 3;
+            immediate++;
+        } else {
+            if(check(test->run,test->width,test->bytes,test->operation,test->mode,test->zero,test->oldCounts)) return 4;
+            original++;
+        }
+        unsigned lanes=test->width/test->bytes;
+        uint64_t last=UINT64_C(1)<<(lanes-1);
+        if(test->mode==0 || test->mode==2) {
+            /* The actual original VMOVUPS count producer reads all 64 bytes,
+               even with a zero mask or a narrower shift destination. */
+            if(check_shift_probe(test,63,0,64) || check_shift_probe(test,64,0,64)) return 5;
+            probes+=2;
+        } else if(test->mode==1) {
+            if(check_shift_probe(test,test->width-1,0,test->width) ||
+               check_shift_probe(test,test->width,0,test->width)) return 6;
+            probes+=2;
+        } else {
+            unsigned lastRequired=test->mode==4?test->bytes:test->width;
+            if(check_shift_probe(test,0,0,0) || check_shift_probe(test,0,UINT64_C(1)<<63,0) ||
+               check_shift_probe(test,test->bytes-1,1,test->bytes) ||
+               check_shift_probe(test,test->bytes,1,test->bytes) ||
+               check_shift_probe(test,lastRequired-1,last,lastRequired) ||
+               check_shift_probe(test,lastRequired,last,lastRequired)) return 7;
+            probes+=6;
+        }
+    }
+    if(free_guard()) return 8;
+    printf("PACKED_SHIFT_ORIGINAL_C_VALUES_ALIASES_AND_STRICT_FAULTS_OK original=%u FullImmediate=%u probes=%u\n",
+           original,immediate,probes);
+    return 0;
+}
+`
+
+func TestX86PackedShiftOriginal396CompanionIsPortableAndFaultStrict(t *testing.T) {
+	complete := x86PackedShiftOriginalActualHostHeader + x86PackedShiftOriginalActualHostObservation + x86PackedShiftOriginalActualHostMain
+	for _, native := range []string{"cpuid", "xgetbv", "__asm__", "__x86_64__", "__i386__"} {
+		if strings.Contains(complete, native) {
+			t.Fatal("portable companion gained host ISA qualification instead of checked portable IR", native)
+		}
+	}
+	if strings.Count(complete, "PACKED_SHIFT_ACTUAL_HOST_PORTABLE_LLVM_NOT_ORIGINAL_GO_NATIVE") != 1 ||
+		strings.Count(complete, "numerical_fault_begin(guard+page,page)") != 1 ||
+		!strings.Contains(complete, "waited<0 && errno==EINTR") || !strings.Contains(complete, "waited!=child") ||
+		!strings.Contains(complete, "numerical_fault_status(status)") {
+		t.Fatal("portable companion lost its execution qualification or exact guarded-page observation")
+	}
+	if err := runtimeOracleFaultCorePolicy(x86PackedShiftOriginalActualHostObservation); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSLLVW(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSLLVW")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSLLVD(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSLLVD")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSLLVQ(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSLLVQ")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRLVW(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRLVW")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRLVD(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRLVD")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRLVQ(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRLVQ")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRAVW(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRAVW")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRAVD(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRAVD")
+}
+
+func TestX86PackedShiftOriginal396ActualHostVPSRAVQ(t *testing.T) {
+	x86PackedShiftOriginal396ActualHost(t, "VPSRAVQ")
+}
diff --git a/x86_packed_shift_portable_projection_test.go b/x86_packed_shift_portable_projection_test.go
new file mode 100644
index 000000000..30f9eac2f
--- /dev/null
+++ b/x86_packed_shift_portable_projection_test.go
@@ -0,0 +1,339 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// This test-only projection removes exactly the original functions' checked
+// ISA selection attributes. Their integer operations, guarded volatile accesses,
+// aliases and control flow remain unchanged. It is not native x86 execution.
+func x86PackedShiftPortableIR(source, ir string) (string, error) {
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	file, err = normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		return "", err
+	}
+	profiles := make(map[string]string)
+	for _, function := range file.Funcs {
+		name := strings.TrimPrefix(function.Sym, "·")
+		if _, duplicate := profiles[name]; duplicate || len(function.Instrs) == 0 ||
+			function.Instrs[0].Op != OpTEXT || len(function.X86RawText) != 0 {
+			return "", fmt.Errorf("portable packed-shift source lost its unique ordinary function: %s", name)
+		}
+		shifts := 0
+		for ordinal, instruction := range function.Instrs {
+			switch instruction.Op {
+			case OpTEXT:
+				// Parse binds this sole header to function.Sym. It is not an
+				// executable body operation or a general directive exemption.
+				if ordinal != 0 || len(instruction.Args) != 0 {
+					return "", fmt.Errorf("portable packed-shift TEXT is not its associated first header: %s", name)
+				}
+				continue
+			case "MOVQ", "KMOVQ", "VMOVUPS", "RET":
+				continue
+			}
+			form, recognized, formErr := x86PackedShiftProperties(instruction.Op, instruction, "amd64")
+			if !recognized || formErr != nil || form.legacy || x86PackedShiftHasNativeCount(form) {
+				return "", fmt.Errorf("portable packed-shift source contains an unobserved operation: %s", instruction.Raw)
+			}
+			shifts++
+		}
+		if shifts != 1 {
+			return "", fmt.Errorf("portable packed-shift function lost its single original operation: %s/%d", name, shifts)
+		}
+		profiles[name] = inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", function)
+	}
+	return x86PackedShiftPortableFeatureProjection(ir, profiles)
+}
+
+func x86PackedShiftPortableFeatureProjection(ir string, profiles map[string]string) (string, error) {
+	if len(profiles) == 0 {
+		return "", fmt.Errorf("portable packed-shift IR has no owned functions")
+	}
+	// The production prelude declares native intrinsics even when no function
+	// uses them. Observe complete, singly referenced declarations without
+	// removing any bytes from the actual projected IR. A body use is native.
+	view, declarationGroups, err := x86PackedShiftInertDeclarations(ir)
+	if err != nil {
+		return "", err
+	}
+	if native := regexp.MustCompile(`\basm\b|@llvm\.(?:x86|aarch64|arm|wasm|ppc|riscv)\.|@"|"target-cpu"`).FindStringIndex(view); native != nil {
+		start := strings.LastIndex(view[:native[0]], "\n") + 1
+		end := strings.IndexByte(view[native[1]:], '\n')
+		if end < 0 {
+			end = len(view)
+		} else {
+			end += native[1]
+		}
+		attributes := regexp.MustCompile(`(?m)^attributes [^\r\n]*`).FindAllString(ir, -1)
+		return "", fmt.Errorf("portable packed-shift native guard: token=%q line=%q complete attribute inventory=%q", view[native[0]:native[1]], view[start:end], attributes)
+	}
+	groupPattern := regexp.MustCompile(`(?m)^attributes (#[0-9]+) = \{ "target-features"="([^"]+)" \}\r?\n`)
+	groups := groupPattern.FindAllStringSubmatch(ir, -1)
+	byProfile, byGroup := make(map[string]string), make(map[string]string)
+	for _, group := range groups {
+		if byProfile[group[2]] != "" || byGroup[group[1]] != "" {
+			return "", fmt.Errorf("duplicate portable packed-shift feature group")
+		}
+		byProfile[group[2]], byGroup[group[1]] = group[1], group[2]
+	}
+	genericGroups, err := x86PackedShiftInertDeclarationAttributes(ir, declarationGroups, byGroup)
+	if err != nil {
+		return "", err
+	}
+	if strings.Count(ir, "target-features") != len(groups) {
+		return "", fmt.Errorf("unobserved portable packed-shift attribute group")
+	}
+	definitionPattern := regexp.MustCompile(`(?m)^define [^\r\n]*@([A-Za-z_][A-Za-z0-9_.$]*)\([^\r\n]*\)[^\r\n]*\{`)
+	definitions := definitionPattern.FindAllStringSubmatch(ir, -1)
+	if len(definitions) != len(profiles) {
+		return "", fmt.Errorf("portable packed-shift definition inventory changed: %d/%d", len(definitions), len(profiles))
+	}
+	seen, uses := make(map[string]bool), make(map[string]int)
+	referencePattern := regexp.MustCompile(`#[0-9]+\b`)
+	for _, definition := range definitions {
+		name := definition[1]
+		profile, found := profiles[name]
+		if !found || seen[name] {
+			return "", fmt.Errorf("unowned or duplicate portable packed-shift definition: %s", name)
+		}
+		seen[name] = true
+		references := referencePattern.FindAllString(definition[0], -1)
+		if profile == "" {
+			if len(references) != 0 {
+				return "", fmt.Errorf("feature-free portable packed-shift function gained an attribute: %s", name)
+			}
+			continue
+		}
+		group := byProfile[profile]
+		if group == "" || len(references) != 1 || references[0] != group {
+			return "", fmt.Errorf("portable packed-shift function lost exact ISA ownership: %s", name)
+		}
+		uses[group]++
+	}
+	for _, group := range groups {
+		// Count exact numeric tokens, not prefixes such as #20 and #200.
+		references := regexp.MustCompile(regexp.QuoteMeta(group[1])+`\b`).FindAllString(ir, -1)
+		if uses[group[1]] == 0 || len(references) != uses[group[1]]+1 {
+			return "", fmt.Errorf("portable packed-shift feature group has missing or foreign references: %s", group[1])
+		}
+	}
+	// Only the checked group lines and corresponding definition-header tokens
+	// change. In particular, no memory access or branch can be dropped here.
+	projected := groupPattern.ReplaceAllString(ir, "")
+	projected = definitionPattern.ReplaceAllStringFunc(projected, func(header string) string {
+		return regexp.MustCompile(` #[0-9]+\b`).ReplaceAllString(header, "")
+	})
+	if strings.Contains(projected, "target-features") {
+		return "", fmt.Errorf("portable packed-shift IR retains an unchecked ISA reference")
+	}
+	for _, reference := range referencePattern.FindAllString(projected, -1) {
+		if !genericGroups[reference] {
+			return "", fmt.Errorf("portable packed-shift IR retains an unowned declaration attribute: %s", reference)
+		}
+	}
+	return projected, nil
+}
+
+func x86PackedShiftInertDeclarations(ir string) (string, map[string]int, error) {
+	declarations := regexp.MustCompile(`(?m)^declare [^@\r\n]+(@[A-Za-z_][A-Za-z0-9_.$]*)\(([^@\r\n]*)\)(?: (#[0-9]+))?\r?$`)
+	symbols := regexp.MustCompile(`@[A-Za-z_][A-Za-z0-9_.$]*`).FindAllString(ir, -1)
+	uses := make(map[string]int)
+	for _, symbol := range symbols {
+		uses[symbol]++
+	}
+	groups := make(map[string]int)
+	native := regexp.MustCompile(`^@llvm\.(?:x86|aarch64|arm|wasm|ppc|riscv)\.`)
+	var failure error
+	view := declarations.ReplaceAllStringFunc(ir, func(line string) string {
+		parts := declarations.FindStringSubmatch(line)
+		depth := 0
+		for _, character := range parts[2] {
+			switch character {
+			case '(':
+				depth++
+			case ')':
+				depth--
+			}
+			if depth < 0 {
+				break
+			}
+		}
+		if depth != 0 {
+			failure = fmt.Errorf("portable packed-shift declaration has incomplete parameters: %s", line)
+			return line
+		}
+		if parts[3] != "" {
+			groups[parts[3]]++
+		}
+		if native.MatchString(parts[1]) {
+			if uses[parts[1]] != 1 {
+				failure = fmt.Errorf("portable packed-shift native intrinsic is not an inert unique declaration: %s", parts[1])
+				return line
+			}
+			return ""
+		}
+		return line
+	})
+	return view, groups, failure
+}
+
+func x86PackedShiftInertDeclarationAttributes(ir string, declarationGroups map[string]int, featureGroups map[string]string) (map[string]bool, error) {
+	pattern := regexp.MustCompile(`(?m)^attributes (#[0-9]+) = \{ ([^\r\n]*) \}\r?\n`)
+	groups := pattern.FindAllStringSubmatch(ir, -1)
+	if len(regexp.MustCompile(`(?m)^attributes `).FindAllString(ir, -1)) != len(groups) {
+		return nil, fmt.Errorf("portable packed-shift IR has an incomplete attribute group")
+	}
+	seen, generic := make(map[string]bool), make(map[string]bool)
+	for _, group := range groups {
+		if seen[group[1]] {
+			return nil, fmt.Errorf("portable packed-shift IR has a duplicate attribute identity: %s", group[1])
+		}
+		seen[group[1]] = true
+		if _, feature := featureGroups[group[1]]; feature {
+			continue
+		}
+		// LLVM22 attaches these generic properties to prelude declarations.
+		// The declaration itself must own every reference; no function body or
+		// definition can borrow this group, and no target attribute is accepted.
+		properties := regexp.MustCompile(`memory\((?:none|read|write|readwrite|(?:argmem|inaccessiblemem):[ \t]*(?:read|write|readwrite)(?:,[ \t]*(?:argmem|inaccessiblemem):[ \t]*(?:read|write|readwrite))*)\)`).ReplaceAllString(group[2], "")
+		for _, property := range strings.Fields(properties) {
+			switch property {
+			case "nocallback", "nofree", "nosync", "nounwind", "speculatable", "willreturn", "nocreateundeforpoison", "strictfp":
+			default:
+				return nil, fmt.Errorf("portable packed-shift declaration gained an unobserved attribute: %s", property)
+			}
+		}
+		references := regexp.MustCompile(regexp.QuoteMeta(group[1])+`\b`).FindAllString(ir, -1)
+		if declarationGroups[group[1]] == 0 || len(references) != declarationGroups[group[1]]+1 {
+			return nil, fmt.Errorf("portable packed-shift generic attribute is not owned only by declarations: %s", group[1])
+		}
+		generic[group[1]] = true
+	}
+	return generic, nil
+}
+
+func TestX86PackedShiftPortableUnusedDeclarationsStayInert(t *testing.T) {
+	const declaration = "declare i32 @llvm.x86.rdpid() #0\n"
+	const attributes = "attributes #0 = { nocallback nofree nosync nounwind willreturn }\n"
+	const body = "define void @A(ptr %p) {\n  %v = load volatile i8, ptr %p, align 1\n" +
+		"  store volatile i8 %v, ptr %p, align 1\n  ret void\n}\n"
+	input := declaration + body + attributes
+	profiles := map[string]string{"A": ""}
+	if projected, err := x86PackedShiftPortableFeatureProjection(input, profiles); err != nil || projected != input {
+		t.Error("single unused native declaration and its own generic attributes must remain byte-for-byte inert", err)
+	}
+	shared := input + "declare i32 @llvm.x86.rdpid.extension() #0\n"
+	if projected, err := x86PackedShiftPortableFeatureProjection(shared, profiles); err != nil || projected != shared {
+		t.Error("inert declarations may share their exact generic group without confusing symbol prefixes", err)
+	}
+	for name, changed := range map[string]string{
+		"called-native":          strings.Replace(input, "  ret void", "  %native = call i32 @llvm.x86.rdpid()\n  ret void", 1),
+		"native-address":         input + "@escape = global ptr @llvm.x86.rdpid\n",
+		"duplicate-declaration":  input + declaration,
+		"incomplete-declaration": strings.Replace(input, "@llvm.x86.rdpid() #0", "@llvm.x86.rdpid( #0", 1),
+		"trailing-body":          strings.Replace(input, "@llvm.x86.rdpid() #0", "@llvm.x86.rdpid() #0 call i32 @llvm.x86.rdpid()", 1),
+		"foreign-attribute":      input + "attributes #7 = { nounwind }\n",
+		"definition-attribute":   strings.Replace(input, "@A(ptr %p) {", "@A(ptr %p) #0 {", 1),
+		"native-attribute":       strings.Replace(input, "nocallback nofree nosync nounwind willreturn", `"target-cpu"="skylake-avx512"`, 1),
+		"native-inline-asm":      strings.Replace(input, "  ret void", `  call void asm sideeffect "nop", ""()`+"\n  ret void", 1),
+		"quoted-native-address":  input + "@escape = global ptr @\"llvm.x86.rdpid\"\n",
+		"escaped-native-address": input + "@escape = global ptr @\"llvm\\2Ex86\\2Erdpid\"\n",
+		"native-prefix-call":     strings.Replace(input, "  ret void", "  %native = call i32 @llvm.x86.rdpid.extension()\n  ret void", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			if projected, err := x86PackedShiftPortableFeatureProjection(changed, profiles); err == nil || projected != "" {
+				t.Fatal("unused-declaration policy accepted a native body, address or unrelated attribute", err)
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftPortableProjectionConsumesNormalizedProductionIR(t *testing.T) {
+	const prefix = "TEXT ·Shift(SB),4,$0-32\nMOVQ data+0(FP),AX\nMOVQ counts+8(FP),BX\n" +
+		"MOVQ out+16(FP),DI\nVMOVUPS (AX),Z0\nVMOVUPS (AX),Z2\nKMOVQ mask+24(FP),K1\n"
+	const suffix = "VMOVUPS Z2,(DI)\nVMOVUPS Y2,64(DI)\nVMOVUPS X2,96(DI)\nRET\n"
+	const declaration = "func Shift(data,counts,out *byte,mask uint64)"
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprint("raw_", raw), func(t *testing.T) {
+			operation := "VPSLLVW.Z (BX),X0,K1,X2\n"
+			if raw {
+				operation = x86RawDisplacementDirectives([]byte{0x62, 0xf2, 0xfd, 0x89, 0x12, 0x13})
+			}
+			source := prefix + operation + suffix
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, "amd64")
+			if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 12 || file.Funcs[0].Instrs[0].Op != OpTEXT {
+				t.Fatal("real normalized source lost the associated parser header or complete operation", err)
+			}
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", "Go")
+			if err != nil || ir == "" {
+				t.Fatal("initialized source lost its actual public production consumer", err)
+			}
+			projected, err := x86PackedShiftPortableIR(source, ir)
+			if err != nil || projected != ir || !strings.Contains(projected, "load volatile") || !strings.Contains(projected, "store volatile") {
+				t.Fatal("already portable production IR lost a body effect at its parser header", err)
+			}
+			for name, changed := range map[string]string{
+				"unknown-body":            strings.Replace(source, operation, "CPUID\n"+operation, 1),
+				"other-function":          source + "TEXT ·Other(SB),4,$0-0\nRET\n",
+				"wrong-associated-symbol": strings.Replace(source, "·Shift(SB)", "·Other(SB)", 1),
+			} {
+				t.Run(name, func(t *testing.T) {
+					if output, err := x86PackedShiftPortableIR(changed, ir); err == nil || output != "" {
+						t.Fatal("parser header exemption accepted an unknown body or foreign function", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftPortableProjectionOwnsEveryFunctionAndEffect(t *testing.T) {
+	const body = "entry:\n  %v = load volatile i8, ptr %p, align 1\n  br label %done\ndone:\n  store volatile i8 %v, ptr %p, align 1\n  ret void\n}\n"
+	input := "define void @A(ptr %p) #20 {\n" + body +
+		"define void @B(ptr %p) {\n" + body + "define void @C(ptr %p) #200 {\n" + body +
+		"attributes #20 = { \"target-features\"=\"+avx\" }\n" +
+		"attributes #200 = { \"target-features\"=\"+avx2\" }\n"
+	profiles := map[string]string{"A": "+avx", "B": "", "C": "+avx2"}
+	want := "define void @A(ptr %p) {\n" + body + "define void @B(ptr %p) {\n" + body +
+		"define void @C(ptr %p) {\n" + body
+	if actual, err := x86PackedShiftPortableFeatureProjection(input, profiles); err != nil || actual != want {
+		t.Fatal("portable projection changed an access, branch or function instead of exact ISA attributes", err, actual)
+	}
+	for name, changed := range map[string]string{
+		"missing-group":                 strings.Replace(input, "attributes #20 = { \"target-features\"=\"+avx\" }\n", "", 1),
+		"duplicate-group":               input + "attributes #20 = { \"target-features\"=\"+avx\" }\n",
+		"wrong-function-reference":      strings.Replace(input, "@A(ptr %p) #20", "@A(ptr %p) #200", 1),
+		"unexpected-function-reference": strings.Replace(input, "@B(ptr %p) {", "@B(ptr %p) #20 {", 1),
+		"foreign-reference":             input + "; foreign #20\n",
+		"missing-function":              strings.Replace(input, "@B(ptr %p)", "@Unknown(ptr %p)", 1),
+		"extra-definition":              input + "define void @D() {\nret void\n}\n",
+		"native-asm":                    strings.Replace(input, "ret void", `call void asm sideeffect "nop", ""()`, 1),
+		// The independent b6ef80f8a RED proves that a declaration alone is
+		// inert. This negative must contain an actual native body operation.
+		"native-intrinsic": strings.Replace(input, "ret void", "call void @llvm.x86.sse.pause()\n  ret void", 1) +
+			"declare void @llvm.x86.sse.pause()\n",
+		"extra-attribute": input + "attributes #3 = { nounwind }\n",
+	} {
+		t.Run(name, func(t *testing.T) {
+			if actual, err := x86PackedShiftPortableFeatureProjection(changed, profiles); err == nil || actual != "" {
+				t.Fatal("invalid portable inventory returned partially projected IR", err)
+			}
+		})
+	}
+	withoutFeatures := "define void @B(ptr %p) {\n" + body
+	if actual, err := x86PackedShiftPortableFeatureProjection(withoutFeatures, map[string]string{"B": ""}); err != nil || actual != withoutFeatures {
+		t.Fatal("already portable production IR must remain byte-for-byte unchanged", err)
+	}
+}
diff --git a/x86_packed_shift_raw_complete_test.go b/x86_packed_shift_raw_complete_test.go
new file mode 100644
index 000000000..bf5aee633
--- /dev/null
+++ b/x86_packed_shift_raw_complete_test.go
@@ -0,0 +1,428 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// An independent ISA directory, not an iteration over the implementation map.
+// Go 1.27 _yvandnpd/_yvblendmpd bind the nine per-lane names. The uniform
+// _yvpslld and byte _yvpslldq rows share the count/alias proof, not arithmetic.
+// Intel SDM Vol. 2B PSLL/PSRL/PSRA and PSLLDQ/PSRLDQ additionally specify WIG:
+// VEX uniform, EVEX word uniform, and both vector byte-shift generations.
+// Per-lane W is fixed; an ignored W never authorizes another opcode family.
+type x86PackedShiftRawMember struct {
+	op        string
+	bits      int
+	opcode    byte
+	immediate byte
+	group     byte
+	vex       bool
+	mode      string
+}
+
+var x86PackedShiftRawMembers = []x86PackedShiftRawMember{
+	{"VPSLLVW", 16, 0x12, 0, 0, false, "lane"},
+	{"VPSLLVD", 32, 0x47, 0, 0, true, "lane"},
+	{"VPSLLVQ", 64, 0x47, 0, 0, true, "lane"},
+	{"VPSRLVW", 16, 0x10, 0, 0, false, "lane"},
+	{"VPSRLVD", 32, 0x45, 0, 0, true, "lane"},
+	{"VPSRLVQ", 64, 0x45, 0, 0, true, "lane"},
+	{"VPSRAVW", 16, 0x11, 0, 0, false, "lane"},
+	{"VPSRAVD", 32, 0x46, 0, 0, true, "lane"},
+	{"VPSRAVQ", 64, 0x46, 0, 0, false, "lane"},
+	{"VPSLLW", 16, 0xf1, 0x71, 6, true, "uniform"},
+	{"VPSLLD", 32, 0xf2, 0x72, 6, true, "uniform"},
+	{"VPSLLQ", 64, 0xf3, 0x73, 6, true, "uniform"},
+	{"VPSRLW", 16, 0xd1, 0x71, 2, true, "uniform"},
+	{"VPSRLD", 32, 0xd2, 0x72, 2, true, "uniform"},
+	{"VPSRLQ", 64, 0xd3, 0x73, 2, true, "uniform"},
+	{"VPSRAW", 16, 0xe1, 0x71, 4, true, "uniform"},
+	{"VPSRAD", 32, 0xe2, 0x72, 4, true, "uniform"},
+	{"VPSRAQ", 64, 0xe2, 0x72, 4, false, "uniform"},
+	{"VPSLLDQ", 8, 0x73, 0x73, 7, true, "bytes"},
+	{"VPSRLDQ", 8, 0x73, 0x73, 3, true, "bytes"},
+}
+
+type x86PackedShiftRawCase struct {
+	member    x86PackedShiftRawMember
+	width     int
+	evex      bool
+	immediate bool
+	input     string // register, memory, or broadcast
+	mask      int    // absent, merging K1, or zeroing K1
+}
+
+func x86PackedShiftRawCases() []x86PackedShiftRawCase {
+	var rows []x86PackedShiftRawCase
+	for _, member := range x86PackedShiftRawMembers {
+		for _, evex := range []bool{false, true} {
+			if !evex && !member.vex {
+				continue
+			}
+			widths := []int{16, 32}
+			if evex {
+				widths = append(widths, 64)
+			}
+			for _, width := range widths {
+				immediates := []bool{false}
+				if member.mode == "uniform" {
+					immediates = append(immediates, true)
+				} else if member.mode == "bytes" {
+					immediates = []bool{true}
+				}
+				for _, immediate := range immediates {
+					inputs := []string{"register", "memory"}
+					if !evex && immediate {
+						inputs = []string{"register"} // Go's VEX immediate rows.
+					}
+					if evex && member.bits != 16 && member.mode != "bytes" &&
+						(member.mode == "lane" || immediate) {
+						inputs = append(inputs, "broadcast")
+					}
+					for _, input := range inputs {
+						masks := []int{0}
+						if evex && member.mode != "bytes" {
+							masks = append(masks, 1, 2)
+						}
+						for _, mask := range masks {
+							rows = append(rows, x86PackedShiftRawCase{member, width, evex, immediate, input, mask})
+						}
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86PackedShiftRawCase) name() string {
+	return fmt.Sprintf("%s/%d/EVEX%t/immediate%t/%s/mask%d",
+		row.member.op, row.width, row.evex, row.immediate, row.input, row.mask)
+}
+
+func (row x86PackedShiftRawCase) instruction() string {
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[row.width]
+	count, data, suffix, mask := bank+"1", bank+"0", "", ""
+	if row.member.mode == "uniform" {
+		count = "X1"
+	}
+	if row.immediate {
+		count = "$5"
+		if row.input != "register" {
+			data = "(BX)"
+		}
+	} else if row.input != "register" {
+		count = "(BX)"
+	}
+	if row.input == "broadcast" {
+		suffix = ".BCST"
+	}
+	if row.mask != 0 {
+		mask = "K1,"
+	}
+	if row.mask == 2 {
+		suffix += ".Z"
+	}
+	return fmt.Sprintf("%s%s %s,%s,%s%s2", row.member.op, suffix, count, data, mask, bank)
+}
+
+// Literal low-bank encodings are authored here from the instruction tables.
+// ModRM.reg is destination2 for count forms, /group for immediate forms;
+// vvvv is data0 or immediate destination2. BX is always an actual address.
+func (row x86PackedShiftRawCase) code(wigOne bool) []byte {
+	mapNumber, opcode, modrm, vvvv := byte(1), row.member.opcode, byte(0xd1), byte(0)
+	if row.member.mode == "lane" {
+		mapNumber = 2
+	}
+	if row.input != "register" {
+		modrm = 0x13
+	}
+	if row.immediate {
+		opcode, modrm, vvvv = row.member.immediate, 0xc0|row.member.group<<3, 2
+		if row.input != "register" {
+			modrm = row.member.group<<3 | 3
+		}
+	}
+	w := row.member.mode == "lane" && row.member.bits != 32 ||
+		row.evex && row.member.mode == "uniform" && row.member.bits == 64 || wigOne
+	p1 := (^vvvv&15)<<3 | 1
+	if w {
+		p1 |= 0x80
+	}
+	length := map[int]byte{16: 0, 32: 1, 64: 2}[row.width]
+	code := []byte{0xc4, 0xe0 | mapNumber, p1 | length<<2, opcode, modrm}
+	if row.evex {
+		p2 := byte(8) | length<<5
+		if row.mask != 0 {
+			p2 |= 1
+		}
+		if row.mask == 2 {
+			p2 |= 0x80
+		}
+		if row.input == "broadcast" {
+			p2 |= 0x10
+		}
+		code = []byte{0x62, 0xf0 | mapNumber, p1 | 4, p2, opcode, modrm}
+	}
+	if row.immediate {
+		code = append(code, 5)
+	}
+	return code
+}
+
+func (row x86PackedShiftRawCase) wig() bool {
+	return row.member.mode == "bytes" || row.member.mode == "uniform" && (!row.evex || row.member.bits == 16)
+}
+
+func (row x86PackedShiftRawCase) program(arch string, raw bool) (string, string, FuncSig) {
+	word, move := int64(8), "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Shift(SB),4,$0-%d\n%s data+0(FP),AX\n%s counts+%d(FP),BX\n%s out+%d(FP),DI\n",
+		word*3+4, move, move, word, move, word*2)
+	source.WriteString("VMOVUPS (AX),Z0\nVMOVUPS (AX),Z2\n")
+	if !row.immediate && row.input == "register" {
+		source.WriteString("VMOVUPS (BX),Z1\n")
+	}
+	if row.mask != 0 {
+		fmt.Fprintf(&source, "KMOVD mask+%d(FP),K1\n", word*3)
+	}
+	if raw {
+		source.WriteString(x86RawDisplacementDirectives(row.code(false)))
+	} else {
+		source.WriteString(row.instruction() + "\n")
+	}
+	source.WriteString("VMOVUPS Z2,(DI)\nVMOVUPS Y2,64(DI)\nVMOVUPS X2,96(DI)\nRET\n")
+	sig := FuncSig{Name: "Shift", Args: []LLVMType{Ptr, Ptr, Ptr, I32}, Ret: Void}
+	for index, typ := range sig.Args {
+		sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(index) * word, Type: typ, Index: index, Field: -1})
+	}
+	return source.String(), "func Shift(data,counts,out *byte,mask uint32)", sig
+}
+
+func x86PackedShiftRawOriginalUnchanged(t *testing.T) {
+	t.Helper()
+	var originalMembers []string
+	for _, member := range x86PackedShiftRawMembers {
+		if member.mode == "lane" {
+			originalMembers = append(originalMembers, member.op)
+		}
+	}
+	if !reflect.DeepEqual(x86VariableShiftTestOps, originalMembers) ||
+		fmt.Sprintf("%x", sha256.Sum256([]byte(x86TestGuardPagesC))) != "559a08f4f5e496e4321d167a9f2ef942db8761e035fe9b0fdf236632c4f1956e" {
+		t.Fatal("original nine-member order or complete guard-page C changed")
+	}
+	const filename = "amd64_raw_variable_shift_test.go"
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, filename, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86VariableShiftMemoryAndViewsRuntime" {
+			continue
+		}
+		start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+		if fmt.Sprintf("%x", sha256.Sum256(data[start:end])) != "4b3e75cedc66221ce0e21d473f1263f7c910a9ca3afa767d828fcc47f67f3231" {
+			t.Fatal("original 396 named/raw kernels, complete C, 96 value samples, aliases or guard-page observations changed")
+		}
+		return
+	}
+	t.Fatal("original complete variable-shift runtime disappeared")
+}
+
+func TestX86PackedShiftRawCompleteIndependentDirectory(t *testing.T) {
+	x86PackedShiftRawOriginalUnchanged(t)
+	counts := map[string]int{}
+	for _, row := range x86PackedShiftRawCases() {
+		counts[row.member.mode]++
+		for _, arch := range []string{"386", "amd64"} {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code(false))
+				want := x86ScalarLaneInstruction(t, row.instruction())
+				if ins.Op != want.Op || !reflect.DeepEqual(ins.Args, want.Args) || ins.x86SourceRaw == nil {
+					t.Fatal("complete independent physical shift row lost opcode/operands/origin", ins.Raw, row.instruction())
+				}
+				form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+				if !known || err != nil || form.byteWidth != row.width || form.zeroing != (row.mask == 2) ||
+					form.broadcast != (row.input == "broadcast") || (form.memory >= 0) != (row.input != "register") {
+					t.Fatal("complete shared shift grammar lost a physical shape", known, err)
+				}
+			})
+		}
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"lane": 236, "uniform": 426, "bytes": 16}) {
+		t.Fatal("complete physical row denominator changed", counts)
+	}
+}
+
+func TestX86PackedShiftRawInitializedOriginalProducerClass(t *testing.T) {
+	x86PackedShiftRawOriginalUnchanged(t)
+	// One orthogonal public witness per member, width and source shape.
+	// The full physical/mask matrix has its own source and object owners.
+	for _, row := range x86PackedShiftRawCases() {
+		if row.member.mode != "lane" || !row.evex || row.mask != 0 || row.input == "broadcast" {
+			continue
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name()+"/"+api, func(t *testing.T) {
+				for _, raw := range []bool{false, true} {
+					source, declaration, _ := row.program("amd64", raw)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("same initialized VMOVUPS producers lost the complete paired shift consumer", "raw", raw, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedShiftRawStandaloneCannotBorrowNamedAuthority(t *testing.T) {
+	for _, row := range x86PackedShiftRawCases() {
+		if row.input != "register" {
+			continue
+		}
+		t.Run(row.name(), func(t *testing.T) {
+			ins := x86RawMoveObservedInstruction(t, "amd64", row.code(false))
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+			for index := 0; index < 3; index++ {
+				state.writeVector(index, 64, ^uint64(0), false)
+			}
+			state.masks[1] = true
+			control := state.clone()
+			named := x86ScalarLaneInstruction(t, row.instruction())
+			if accepted, known := x86ResultPackedShiftStep(named, &control, nil, "amd64"); !known || !accepted {
+				t.Fatal("independently initialized genuine named shift lost its existing NUM consumer")
+			}
+			for _, nativeRead := range []bool{false, true} {
+				candidate := state.clone()
+				accepted, known := x86ResultPackedShiftStepWithRead(ins, &candidate, nil, "amd64", nativeRead)
+				if !known || accepted || !reflect.DeepEqual(candidate, state) {
+					t.Fatal("standalone raw shift borrowed named or lowering-local source authority", nativeRead)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftRawWholeReplayAndMissingInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedShiftRawCases() {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				source, _, sig := row.program(arch, true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				ordinal := len(fn.Instrs) - 5
+				if fn.Instrs[ordinal].x86SourceRaw == nil {
+					t.Fatal("exact raw shift disappeared from the complete source")
+				}
+				check := func(candidate Func) error {
+					ctx := newX86Ctx(new(strings.Builder), candidate, sig, nil, nil, arch,
+						map[string]string{"386": "i386-unknown-linux-gnu", "amd64": "x86_64-unknown-linux-gnu"}[arch], false)
+					return ctx.checkLoweredScalarFPResultInitialization()
+				}
+				if err := check(fn); err != nil {
+					t.Fatal("initialized complete raw shift lacks its paired whole-source owner", err)
+				}
+				controls := []struct {
+					name string
+					edit func(*Func)
+				}{
+					{"origin-only", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw = nil }},
+					{"encoding-only", func(fn *Func) { fn.Instrs[ordinal].x86Encoded = !fn.Instrs[ordinal].x86Encoded }},
+					{"missing-whole-replay", func(fn *Func) { fn.x86RawReplay = nil }},
+					{"producer-source", func(fn *Func) { fn.Instrs[1].Raw += " " }},
+					{"operand-after-decode", func(fn *Func) { fn.Instrs[ordinal].Args[len(fn.Instrs[ordinal].Args)-1].Reg = "Z3" }},
+					{"missing-incoming-pointer", func(fn *Func) {
+						fn.Instrs[1] = x86ScalarLaneInstruction(t, "MOVL $42,AX")
+					}},
+				}
+				for _, control := range controls {
+					changed := fn
+					changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+					control.edit(&changed)
+					if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed raw source bypassed the actual whole-function consumer", control.name, err)
+					}
+					if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+						t.Fatal("mutable replay clone damaged the immutable complete source", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedShiftRawPhysicalSnapshotRejectsAtomically(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedShiftRawCases() {
+			t.Run(arch+"/"+row.name(), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code(false))
+				encoding := x86RawPackedShiftVEX
+				if row.evex {
+					encoding = x86RawPackedShiftEVEX
+				}
+				w := row.member.mode == "lane" && row.member.bits != 32 ||
+					row.evex && row.member.mode == "uniform" && row.member.bits == 64
+				if ins.x86PackedShiftEncoding != encoding || ins.x86PackedShiftW != w ||
+					!ins.x86Encoded || !x86RawPackedShiftSource(ins, arch) {
+					t.Fatal("actual generation, W and mode were not captured before source replay", ins.Raw)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				for index := 0; index < 3; index++ {
+					state.writeVector(index, 64, ^uint64(0), false)
+				}
+				state.pointerGP[3], state.masks[1] = true, true
+				before := state.clone()
+				if accepted, known := x86LoweredRawPackedShiftStep(ins, &state, nil, arch); !known || !accepted ||
+					!reflect.DeepEqual(state, before) {
+					t.Fatal("complete original typed inputs lost the paired effect or unrelated state", accepted, known)
+				}
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"missing-origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"missing-snapshot", func(ins *Instr) { ins.x86SourceRaw.packedShift = x86RawPackedShiftIdentity{} }},
+					{"snapshot-mode", func(ins *Instr) { ins.x86SourceRaw.packedShift.arch = "foreign" }},
+					{"snapshot-W", func(ins *Instr) { ins.x86SourceRaw.packedShift.w = !ins.x86SourceRaw.packedShift.w }},
+					{"snapshot-generation", func(ins *Instr) { ins.x86SourceRaw.packedShift.encoding = x86RawPackedShiftAbsent }},
+					{"physical-W", func(ins *Instr) { ins.x86PackedShiftW = !ins.x86PackedShiftW }},
+					{"physical-generation", func(ins *Instr) { ins.x86PackedShiftEncoding = x86RawPackedShiftAbsent }},
+					{"physical-grammar", func(ins *Instr) { ins.x86Encoded = false }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{ins})[0]
+					control.edit(&changed)
+					candidate := before.clone()
+					if accepted, _ := x86LoweredRawPackedShiftStep(changed, &candidate, nil, arch); accepted ||
+						x86RawPackedShiftSource(changed, arch) || !reflect.DeepEqual(candidate, before) {
+						t.Fatal("edited physical snapshot borrowed or partially committed a paired effect", control.name)
+					}
+					if !x86RawPackedShiftSource(ins, arch) {
+						t.Fatal("editing a replay clone mutated the original physical snapshot", control.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_shift_raw_physical_test.go b/x86_packed_shift_raw_physical_test.go
new file mode 100644
index 000000000..c1245ebb9
--- /dev/null
+++ b/x86_packed_shift_raw_physical_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86PackedShiftRawDecode(code []byte, mode int) (Instr, int, bool, error) {
+	for _, decode := range []func([]byte, int) (Instr, int, bool, error){
+		decodedX86PerLaneVariableShiftInstruction,
+		decodedX86PackedUniformShiftInstruction,
+		decodedX86RawVectorByteShiftInstruction,
+	} {
+		if ins, consumed, known, err := decode(code, mode); known {
+			return ins, consumed, known, err
+		}
+	}
+	return Instr{}, 0, false, nil
+}
+
+func TestX86PackedShiftRawCompletePhysicalLLVM22AndWIG(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("independent packed-shift WIG validation requires LLVM22 llvm-mc")
+	}
+	var rows []x86PackedShiftRawCase
+	var input strings.Builder
+	wantMnemonics := map[string]int{}
+	for _, row := range x86PackedShiftRawCases() {
+		values := []bool{false}
+		if row.wig() && !row.llvm22WordCountWIGGap() {
+			rows = append(rows, row)
+			values = append(values, true)
+		}
+		for _, w := range values {
+			for _, value := range row.code(w) {
+				fmt.Fprintf(&input, "0x%02x ", value)
+			}
+			input.WriteByte('\n')
+			wantMnemonics[strings.ToLower(row.member.op)]++
+		}
+	}
+	if len(rows) != 118 || len(wantMnemonics) != 20 {
+		t.Fatal("complete uniform-word/byte WIG directory changed", len(rows), len(wantMnemonics))
+	}
+	count := 0
+	for _, expected := range wantMnemonics {
+		count += expected
+	}
+	if count != 796 {
+		t.Fatal("complete LLVM22-positive physical row denominator changed", count)
+	}
+	for _, mode := range []int{32, 64} {
+		triple := map[int]string{32: "i386-unknown-linux-gnu", 64: "x86_64-unknown-linux-gnu"}[mode]
+		t.Run(triple, func(t *testing.T) {
+			// An external decoder must recognize all 796 positive bytes first.
+			// The 54 valid-but-unrecognized word-count W1 forms have a separate
+			// one-instruction receipt below; none enters this positive batch.
+			// Go choosing W0 is not evidence that W1 is an invalid instruction.
+			stage, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+				"--mattr=+avx,+avx2,+avx512f,+avx512bw,+avx512vl")
+			command.Stdin = strings.NewReader(input.String())
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			cancel()
+			if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+				t.Fatalf("independent LLVM22 rejected complete WIG source bytes: %v\n%s", err, output)
+			}
+			for mnemonic, want := range wantMnemonics {
+				if got := len(regexp.MustCompile(`(?m)\b`+mnemonic+`[ \t]+`).FindAll(output, -1)); got != want {
+					t.Fatalf("independent LLVM22 WIG row count for %s: %d != %d\n%s", mnemonic, got, want, output)
+				}
+			}
+			for _, row := range rows {
+				t.Run(row.name(), func(t *testing.T) {
+					var control Instr
+					for _, w := range []bool{false, true} {
+						code := row.code(w)
+						ins, consumed, known, err := x86PackedShiftRawDecode(code, mode)
+						if !known || err != nil || consumed != len(code) {
+							t.Fatal("ISA WIG does not close the complete typed shift grammar", w, known, consumed, err)
+						}
+						generation := x86RawPackedShiftVEX
+						if row.evex {
+							generation = x86RawPackedShiftEVEX
+						}
+						if !ins.x86Encoded || ins.x86PackedShiftEncoding != generation || ins.x86PackedShiftW != w {
+							t.Fatal("ignored W lost its actual physical generation or bit", w, ins.x86PackedShiftEncoding, ins.x86PackedShiftW)
+						}
+						if !w {
+							control = ins
+						} else if ins.Op != control.Op || !reflect.DeepEqual(ins.Args, control.Args) {
+							t.Fatal("ignored W changed the original shift's semantic operands", ins.Raw, control.Raw)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func (row x86PackedShiftRawCase) llvm22WordCountWIGGap() bool {
+	return row.evex && row.member.mode == "uniform" && row.member.bits == 16 && !row.immediate
+}
+
+func x86PackedShiftRawSingleMC(t *testing.T, mc, triple string, code []byte) string {
+	t.Helper()
+	var input strings.Builder
+	for _, value := range code {
+		fmt.Fprintf(&input, "0x%02x ", value)
+	}
+	input.WriteByte('\n')
+	stage, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+		"--mattr=+avx,+avx2,+avx512f,+avx512bw,+avx512vl")
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("independent one-instruction LLVM22 observation: %v\n%s", err, output)
+	}
+	return string(output)
+}
+
+func TestX86PackedShiftRawSDMWordCountWIGAndLLVM22Difference(t *testing.T) {
+	// Intel SDM 325462-089 Vol.2B 4-443..445 and Intel XED's
+	// datafiles/avx512-skx/skx-isa.xed.txt specify EVEX.WIG F1/D1/E1.
+	// LLVM22 X86InstrAVX512.td avx512_shift_types omits WIG on its W
+	// count branch, although avx512_shift_rmi_w has it. Observe that exact
+	// external decoder difference separately; it is never a positive LLVM
+	// witness or a justification to drop these 54 valid physical shapes.
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("independent word-count WIG observations require LLVM22 llvm-mc")
+	}
+	var rows []x86PackedShiftRawCase
+	for _, row := range x86PackedShiftRawCases() {
+		if row.llvm22WordCountWIGGap() {
+			rows = append(rows, row)
+		}
+	}
+	if len(rows) != 54 {
+		t.Fatal("complete external word-count WIG difference denominator changed", len(rows))
+	}
+	for _, mode := range []int{32, 64} {
+		triple := map[int]string{32: "i386-unknown-linux-gnu", 64: "x86_64-unknown-linux-gnu"}[mode]
+		for _, row := range rows {
+			t.Run(triple+"/"+row.name(), func(t *testing.T) {
+				mnemonic := regexp.MustCompile(`(?m)\b` + strings.ToLower(row.member.op) + `[ \t]+`)
+				control := x86PackedShiftRawSingleMC(t, mc, triple, row.code(false))
+				if strings.Contains(control, "warning") || strings.Contains(control, "invalid") ||
+					len(mnemonic.FindAllString(control, -1)) != 1 {
+					t.Fatal("independent fresh-process W0 prerequisite failed", control)
+				}
+				observation := x86PackedShiftRawSingleMC(t, mc, triple, row.code(true))
+				if !strings.Contains(observation, "warning: invalid instruction encoding") ||
+					strings.Contains(observation, "error:") || mnemonic.MatchString(observation) {
+					t.Fatal("LLVM22 word-count W1 difference changed; audit the independent decoder before updating this receipt", observation)
+				}
+				// A fresh process contains exactly this six-byte instruction. Its
+				// warning cannot desynchronize the subsequent W0/other-family rows.
+				if len(row.code(true)) != 6 {
+					t.Fatal("external decoder difference grew beyond its exact instruction")
+				}
+				var named Instr
+				for _, w := range []bool{false, true} {
+					code := row.code(w)
+					ins, consumed, known, err := x86PackedShiftRawDecode(code, mode)
+					if !known || err != nil || consumed != len(code) {
+						t.Fatal("SDM/XED word-count WIG source is missing from the complete decoder", w, known, consumed, err)
+					}
+					if !ins.x86Encoded || ins.x86PackedShiftEncoding != x86RawPackedShiftEVEX || ins.x86PackedShiftW != w {
+						t.Fatal("word-count WIG lost its original EVEX/W physical snapshot", w, ins.x86PackedShiftEncoding, ins.x86PackedShiftW)
+					}
+					if !w {
+						named = ins
+					} else if ins.Op != named.Op || !reflect.DeepEqual(ins.Args, named.Args) {
+						t.Fatal("ignored word-count W changed its exact semantic operands")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedShiftRawPhysicalRestrictionsStayLocal(t *testing.T) {
+	for _, row := range x86PackedShiftRawCases() {
+		if row.input != "register" || row.mask != 0 {
+			continue
+		}
+		t.Run(row.name(), func(t *testing.T) {
+			valid := row.code(false)
+			if _, consumed, known, err := x86PackedShiftRawDecode(valid, 32); !known || err != nil || consumed != len(valid) {
+				t.Fatal("legitimate low-bank mode32 physical shift rejected", err)
+			}
+			controls := map[string][]byte{
+				"address-override": append([]byte{0x67}, valid...),
+				"truncated":        append([]byte(nil), valid[:len(valid)-1]...),
+			}
+			if row.evex {
+				for _, name := range []string{"fixed-bit", "reserved-length", "zero-without-mask", "physical-register8"} {
+					code := append([]byte(nil), valid...)
+					switch name {
+					case "fixed-bit":
+						code[2] &^= 4
+					case "reserved-length":
+						code[3] |= 0x60
+					case "zero-without-mask":
+						code[3] |= 0x80
+					case "physical-register8":
+						code[1] &^= 0x20 // ModRM.r/m is physically register8.
+					}
+					controls[name] = code
+				}
+			} else {
+				code := append([]byte(nil), valid...)
+				code[1] &^= 0x20
+				controls["physical-register8"] = code
+				if row.immediate {
+					code := append([]byte(nil), valid...)
+					code[4] = row.member.group<<3 | 3
+					controls["VEX-immediate-memory"] = code
+				}
+			}
+			if row.member.mode == "lane" && row.member.bits == 16 {
+				code := append([]byte(nil), valid...)
+				code[2] &^= 0x80
+				controls["per-lane-word-W0"] = code
+			}
+			if row.member.mode == "bytes" && row.evex {
+				code := append([]byte(nil), valid...)
+				code[3] |= 1
+				controls["byte-shift-mask"] = code
+			}
+			for name, code := range controls {
+				if _, _, known, err := x86PackedShiftRawDecode(code, 32); known && err == nil {
+					t.Fatal("malformed or unavailable physical shift became valid", name, code)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_packed_shift_sdm_fault_class_test.go b/x86_packed_shift_sdm_fault_class_test.go
new file mode 100644
index 000000000..69c6fa195
--- /dev/null
+++ b/x86_packed_shift_sdm_fault_class_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import "testing"
+
+func TestX86PackedShiftIndependentSDMFullAndMem128FaultClasses(t *testing.T) {
+	// Intel SDM 325462-089 Vol.2B 4-453..454 distinguishes the complete
+	// tuples, not just the W/D/Q mnemonic: uniform Mem128 counts are E4NF.nb;
+	// immediate Full tuples are E4/E4.nb, including W immediate. Byte shifts
+	// retain E4NF.nb. Per-lane Full/BCST counts retain E4/E4.nb. A numerical
+	// dependency on only the low count qword never narrows a Mem128 access.
+	counts := map[string]int{}
+	for _, row := range x86PackedShiftRawCases() {
+		if row.input == "register" {
+			continue
+		}
+		t.Run(row.name(), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction())
+			form, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+			if !known || err != nil || form.memory < 0 {
+				t.Fatal("independent complete Go memory row lost its typed grammar", err)
+			}
+			class, suppressed, bytes := "per-lane", true, row.width
+			switch row.member.mode {
+			case "uniform":
+				class = "immediate-Full"
+				if !row.immediate {
+					class, suppressed, bytes = "uniform-Mem128", false, 16
+				}
+			case "bytes":
+				class, suppressed = "byte-Full", false
+			}
+			if row.input == "broadcast" {
+				bytes = row.member.bits / 8
+			}
+			counts[class]++
+			if form.faultSuppressed != suppressed || form.memoryBytes != bytes {
+				t.Fatal("SDM Full versus Mem128 exception class or complete tuple changed",
+					class, form.faultSuppressed, suppressed, form.memoryBytes, bytes)
+			}
+		})
+	}
+	if counts["per-lane"] != 145 || counts["immediate-Full"] != 135 ||
+		counts["uniform-Mem128"] != 97 || counts["byte-Full"] != 6 {
+		t.Fatal("complete independently classified memory-form denominator changed", counts)
+	}
+}
diff --git a/x86_packed_shift_unpack_fault_unix_test.go b/x86_packed_shift_unpack_fault_unix_test.go
new file mode 100644
index 000000000..b300cac92
--- /dev/null
+++ b/x86_packed_shift_unpack_fault_unix_test.go
@@ -0,0 +1,50 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+// Reuse the exact discovering native programs, but execute only portable
+// LLVM semantics on the current host. Original native ISA remains a separate
+// required cross-runtime owner. No Rosetta or native-ISA claim follows here.
+func TestX86PackedShiftOriginalFaultProgramPortableMemorySemantics(t *testing.T) {
+	source, signatures, declarations, rows, required := x86PackedShiftFaultProgram()
+	x86PackedFaultProgramPortableMemory(t, source,
+		x86PackedFaultProgramGoDeclarations(signatures, "out,data,count *byte"),
+		declarations, rows, required)
+}
+
+func TestX86PackedUnpackOriginalFaultProgramPortableMemorySemantics(t *testing.T) {
+	source, signatures, declarations, rows := x86PackedUnpackFaultProgram()
+	x86PackedFaultProgramPortableMemory(t, source,
+		x86PackedFaultProgramGoDeclarations(signatures, "input,out *byte"),
+		declarations, rows, []bool{true, true, true, true})
+}
+
+func x86PackedFaultProgramPortableMemory(t *testing.T, source, goDeclarations, prototypes, rows string, required []bool) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	execution := x86FloatCompareExecution{llc: llc, compiler: []string{clang},
+		triple: testTargetTriple(runtime.GOOS, runtime.GOARCH)}
+	driver := x86MemoryFaultDriver(prototypes, rows)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, goDeclarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("original complete program lacks a paired numerical continuation", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					executable := execution.compileLLVM(t, "packed-memory", text, driver, level)
+					x86CheckMemoryAccessMatrix(t, execution, executable, required)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_packed_shift_unpack_native_inputs_test.go b/x86_packed_shift_unpack_native_inputs_test.go
new file mode 100644
index 000000000..4e563bd1a
--- /dev/null
+++ b/x86_packed_shift_unpack_native_inputs_test.go
@@ -0,0 +1,252 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+)
+
+func x86PackedFaultProgramGoDeclarations(signatures map[string]FuncSig, parameters string) string {
+	var declarations strings.Builder
+	var names []string
+	for name := range signatures {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		fmt.Fprintf(&declarations, "func %s(%s)\n", name, parameters)
+	}
+	return declarations.String()
+}
+
+func x86PackedFaultProgramObjects(t *testing.T, source, declarations string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // These exact native source programs have AMD64-only named masks and ABI0 offsets.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("original native fault program lacks a complete paired source proof", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PackedShiftOriginalFaultSourceThreeAPIsThreeTargetObjects(t *testing.T) {
+	source, signatures, _, _, _ := x86PackedShiftFaultProgram()
+	x86PackedFaultProgramObjects(t, source, x86PackedFaultProgramGoDeclarations(signatures, "out,data,count *byte"))
+}
+
+func TestX86PackedUnpackOriginalFaultSourceThreeAPIsThreeTargetObjects(t *testing.T) {
+	source, signatures, _, _ := x86PackedUnpackFaultProgram()
+	x86PackedFaultProgramObjects(t, source, x86PackedFaultProgramGoDeclarations(signatures, "input,out *byte"))
+}
+
+func TestX86PackedShiftUnpackVoidNativeInputsCannotBorrowShadowState(t *testing.T) {
+	for _, row := range []string{
+		"VPSRLW (AX),Y0,Y1", "VPSRLD $1,(AX),Y1",
+		"VPSRLVD.BCST (AX),Y0,Y1", "VPSRLDQ $1,(AX),Y1",
+		"VPUNPCKLBW (AX),Z0,Z1", "VUNPCKHPD.BCST (AX),Z0,Z1",
+		"VPSRLW.Z (AX),Y0,K1,Y1", "VPUNPCKLBW.Z (AX),Z0,K1,Z1",
+	} {
+		for _, target := range x86RawReturnTargets {
+			word, move := 8, "MOVQ"
+			mask := ""
+			if strings.Contains(row, "K1") {
+				if target.arch == "386" {
+					continue // The actual mode32 Go frontend rejects these named masked rows.
+				}
+				mask = "MOVL $0,CX\nKMOVQ CX,K1\n"
+			}
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nVPXORD Z0,Z0,Z0\n%s%s\nRET\n", word, move, mask, row)
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", target.arch, target.triple, api); err != nil || ir == "" {
+						t.Fatal("complete independent native Void control rejected", api, err)
+					}
+					unknown := strings.Replace(source, move+" p+0(FP),AX\n", "", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, unknown, "func Value(p *[64]byte)", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error("unobserved native input acquired an implementation address", api, err)
+					}
+					if mask != "" {
+						unknown = strings.Replace(source, "KMOVQ CX,K1\n", "", 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, unknown, "func Value(p *[64]byte)", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("unobserved native input acquired an implementation mask", api, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedUnpackLegacyMemoryRequiresOriginalNativeOpcode(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			signatures := map[string]FuncSig{}
+			for _, op := range x86CallerUnpackOpcodes() {
+				if strings.HasPrefix(op, "V") {
+					continue
+				}
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s (AX),X1\nRET\n", op, op)
+				signatures[op] = FuncSig{Name: op, Ret: Void}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			file := mustParseX86RawReturn(t, source.String())
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerPackedUnpack(ins.Op, ins) })
+			for _, op := range x86CallerUnpackOpcodes() {
+				if strings.HasPrefix(op, "V") {
+					continue
+				}
+				mnemonic := strings.ToLower(op)
+				mnemonic = strings.NewReplacer("lwl", "lwd", "hwl", "hwd", "llq", "ldq", "hlq", "hdq").Replace(mnemonic)
+				if strings.Count(ir, `asm sideeffect "`+mnemonic+` ($2), $0", "=x,0,r,~{memory}"`) != 1 {
+					t.Error("legacy m128 alignment/fault opcode became an align-1 load", op)
+				}
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86NativePackedBinarySSE1CarrierDoesNotRequireSSE2(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			signatures := map[string]FuncSig{}
+			for index, op := range []string{"ANDPS", "ANDNPS", "ORPS", "XORPS"} {
+				name := fmt.Sprintf("SSE1Carrier%d", index)
+				fmt.Fprintf(&source, "TEXT %s(SB),4,$0-0\n%s (AX),X1\nRET\n", name, op)
+				signatures[name] = FuncSig{Name: name, Ret: Void}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			file := mustParseX86RawReturn(t, source.String())
+			for _, fn := range file.Funcs {
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, target.arch, fn)
+				if features != "+sse" {
+					t.Fatal("isolated original SSE1 opcode acquired a sibling or stronger CPU feature", fn.Sym, features)
+				}
+			}
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) { return c.lowerPackedLogicalFamily(ins.Op, ins) })
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, text, level)
+				}
+			}
+		})
+	}
+}
+
+func x86UnpackValueRows(arch string) []struct{ op, bank, mode string } {
+	names := x86CallerUnpackOpcodes()
+	rows := x86FixedBinaryValueRows(arch, names)
+	for _, op := range names {
+		if !strings.HasPrefix(op, "V") || x86UnpackTestLaneBytes(op) < 4 {
+			continue
+		}
+		for _, row := range x86FixedBinaryValueRows(arch, []string{op}) {
+			row.op += ".BCST"
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func TestX86PackedUnpackInitializedCompleteFamilyFiveTargetsThreeAPIs(t *testing.T) {
+	for batch := 0; batch < 6; batch++ {
+		t.Run(fmt.Sprint(batch), func(t *testing.T) {
+			x86FixedBinaryCompleteFamilyObjects(t, func(arch string) []struct{ op, bank, mode string } {
+				rows, want := x86UnpackValueRows(arch), 192
+				if arch == "386" {
+					want = 72
+				}
+				if len(rows) != want {
+					t.Fatal("complete independent unpack denominator changed", len(rows), want)
+				}
+				return rows[batch*want/6 : (batch+1)*want/6]
+			}, 32, 12)
+		})
+	}
+}
+
+func TestX86PackedUnpackNativeInputsStayIndependent(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, x86UnpackValueRows)
+}
+
+func TestX86PackedShiftLegacyCountInitializedFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			for index, row := range x86LegacyShiftMemoryOpcodes {
+				name := fmt.Sprintf("NativeCount%d", index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s count+0(FP),AX\n%s out+%d(FP),DI\nXORPS X0,X0\n%s (AX),X0\nMOVUPS X0,(DI)\nRET\n",
+					name, 2*word, move, move, word, row.name)
+				fmt.Fprintf(&declarations, "func %s(count,out *[16]byte)\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete original native m128 count source rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, mnemonic := range []string{"psllw", "pslld", "psllq", "psrlw", "psrld", "psrlq"} {
+							if strings.Count(text, `asm sideeffect "`+mnemonic+` ($2), $0"`) != 1 {
+								t.Fatal("complete source lost its actual full m128 count opcode", mnemonic)
+							}
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_packed_sign_extend_format_test.go b/x86_packed_sign_extend_format_test.go
new file mode 100644
index 000000000..36f176647
--- /dev/null
+++ b/x86_packed_sign_extend_format_test.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Keep every original named row as an actual Go object and three public
+// Context observations before emitting any private format objects. Go386
+// accepts high X/Y spellings that have no ordinary physical register role;
+// they stay in the original source, not low-bank aliases in these objects.
+func x86SignExtendOriginalFormatObject(t *testing.T, source, arch, triple string, wantPhysical, wantContext int) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	units := *file
+	units.Funcs = nil
+	physical, contextual := 0, 0
+	for _, function := range file.Funcs {
+		unit := function
+		unit.Instrs = nil
+		for _, instruction := range function.Instrs {
+			if instruction.Op != OpTEXT && instruction.Op != OpRET {
+				_, known, err := x86PackedSignExtendProperties(instruction, arch)
+				if known && errors.Is(err, ErrProbeNeedsContext) && arch == "386" &&
+					x86Mode32VectorRegisterContext(instruction, arch) != nil {
+					contextual++
+					continue
+				}
+				if !known || err != nil {
+					t.Fatal("original signed widening row lost its exact physical grammar", instruction.Raw, err)
+				}
+				physical++
+			}
+			unit.Instrs = append(unit.Instrs, instruction)
+		}
+		units.Funcs = append(units.Funcs, unit)
+	}
+	if physical != wantPhysical || contextual != wantContext {
+		t.Fatal("original signed widening format partition changed", physical, contextual, wantPhysical, wantContext)
+	}
+	t.Logf("all original Go rows/public Context retained; %d physical emitter rows and %d original Go-accepted high-bank Context rows; no initialized/native execution claim", physical, contextual)
+	return x86InstructionFormatObjectUnit(t, &units, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return c.lowerPackedExtendMove(instruction.Op, instruction)
+		})
+}
diff --git a/x86_packed_sign_extend_native_inputs_test.go b/x86_packed_sign_extend_native_inputs_test.go
new file mode 100644
index 000000000..660d33f23
--- /dev/null
+++ b/x86_packed_sign_extend_native_inputs_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Exact-width volatile and conditional-lane IR witnesses are object/source
+// obligations, not a claim that original AVX512 instructions ran on this host.
+func TestX86PackedSignExtendE5DeadReadsAndActualNativeInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		type example struct {
+			name, source, missing string
+			tuple, bits           int
+			masked                bool
+		}
+		var examples []example
+		var prior strings.Builder
+		for _, ratio := range x86PackedSignExtendOracleRatios {
+			for _, shape := range []struct {
+				prefix, bank, mode string
+				width              int
+			}{
+				{"P", "X", "plain", 16}, {"VP", "X", "plain", 16},
+				{"VP", "Y", "plain", 32}, {"VP", "Z", "plain", 64},
+				{"VP", "Z", "merge", 64}, {"VP", "Z", "zero", 64},
+			} {
+				for _, missing := range []string{"none", "pointer", "index", "mask", "old"} {
+					if missing == "mask" && shape.mode == "plain" || missing == "old" && shape.mode != "merge" {
+						continue
+					}
+					name := fmt.Sprint("Native", len(examples))
+					var source strings.Builder
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+%d(FP),DI\n", name, 2*word+4, move, word)
+					if missing != "pointer" {
+						fmt.Fprintf(&source, "%s p+0(FP),BX\n", move)
+					}
+					if missing != "old" {
+						source.WriteString("VPXORD Z1,Z1,Z1\n")
+					}
+					if missing != "mask" {
+						fmt.Fprintf(&source, "MOVL mask+%d(FP),AX\nKMOVD AX,K1\n", 2*word)
+					}
+					op, memory, mask := shape.prefix+"MOVSX"+ratio.suffix, "(BX)", ""
+					if missing == "index" {
+						memory = "(BX)(SI*2)"
+					}
+					if shape.mode != "plain" {
+						mask = "K1,"
+						if shape.mode == "zero" {
+							op += ".Z"
+						}
+					}
+					fmt.Fprintf(&source, "%s %s,%s%s1\n", op, memory, mask, shape.bank)
+					if missing == "old" {
+						// A real complete-width consumer observes inactive merge bytes;
+						// dead unknown bytes alone do not justify an input rejection.
+						source.WriteString("VMOVUPS Z1,(DI)\n")
+					}
+					source.WriteString("RET\n")
+					prior.WriteString(source.String())
+					examples = append(examples, example{name, source.String(), missing,
+						shape.width * ratio.input / ratio.output, ratio.input * 8, shape.mode != "plain"})
+				}
+			}
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, prior.String())
+		for _, row := range examples {
+			t.Run(arch+"/"+row.name+"/"+row.missing, func(t *testing.T) {
+				declaration := fmt.Sprintf("func %s(p,out *[64]byte,mask uint32)", row.name)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, declaration, arch, triple, api)
+					if row.missing != "none" {
+						if arch == "amd64" && row.missing == "old" {
+							x86VectorScratchCodegenControl(t, row.source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead/E5 widening invented a pointer/index/mask/observed merge input", api, err)
+						}
+						continue
+					}
+					if err != nil || ir == "" {
+						t.Fatal("complete original native signed shrinking tuple rejected", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						body := x86StringMemoryFunction(t, text, row.name)
+						witness := fmt.Sprintf("load volatile <%d x i8>", row.tuple)
+						if row.masked {
+							witness = fmt.Sprintf("load volatile i%d", row.bits)
+							if !strings.Contains(body, "br i1") {
+								t.Fatal("E5 did not retain actual conditional input-lane fault suppression", api)
+							}
+						}
+						if !strings.Contains(body, witness) {
+							t.Fatal("dead result lost its exact shrinking native input access", api, witness)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_sign_extend_objects_test.go b/x86_packed_sign_extend_objects_test.go
new file mode 100644
index 000000000..c2e68d144
--- /dev/null
+++ b/x86_packed_sign_extend_objects_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86SignExtendInitializedPrograms(arch string, batch int) (string, string, int) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, ratio := range x86PackedSignExtendOracleRatios[batch*3 : (batch+1)*3] {
+		for _, vector := range []bool{false, true} {
+			for _, width := range []int{16, 32, 64} {
+				if !vector && width != 16 {
+					continue
+				}
+				bank, input := map[int]string{16: "X", 32: "Y", 64: "Z"}[width], "X"
+				if width*ratio.input/ratio.output > 16 {
+					input = "Y"
+				}
+				for _, memory := range []bool{false, true} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if !vector && mode != "plain" {
+							continue
+						}
+						name, op := fmt.Sprint("Signed", count), "PMOVSX"+ratio.suffix
+						if vector {
+							op = "V" + op
+						}
+						first, mask := input+"0", ""
+						if memory {
+							first = "(BX)"
+						}
+						if mode != "plain" {
+							mask = "K1,"
+							if mode == "zero" {
+								op += ".Z"
+							}
+						}
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s data+%d(FP),BX\n%s old+%d(FP),CX\nVMOVUPS (CX),Z1\n",
+							name, 3*word, move, move, word, move, 2*word)
+						if !memory {
+							source.WriteString("VMOVUPS (BX),Z0\n")
+						}
+						// Both all-active and all-inactive constant masks still require
+						// the typed mask/address contract, not zeroed implementation slots.
+						value := -1
+						if mode == "zero" {
+							value = 0
+						}
+						fmt.Fprintf(&source, "MOVL $%d,DX\nKMOVD DX,K1\nMOVL $5,DX\nCMPL DX,$3\nSTD\n%s %s,%s%s1\nVMOVUPS Z1,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nCLD\nRET\n",
+							value, op, first, mask, bank)
+						fmt.Fprintf(&declarations, "func %s(out *[66]byte,data,old *[64]byte)\n", name)
+						count++
+					}
+				}
+			}
+		}
+	}
+	return source.String(), declarations.String(), count
+}
+
+func TestX86PackedSignExtendInitializedFamilyFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for batch := 0; batch < 2; batch++ {
+			t.Run(fmt.Sprintf("%s/batch%d", target.triple, batch), func(t *testing.T) {
+				source, declarations, count := x86SignExtendInitializedPrograms(target.arch, batch)
+				if count != 60 {
+					t.Fatal("complete signed widening batch directory changed", count)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete initialized signed widening family rejected", err)
+						}
+						for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86PackedStringCompileObject(t, llc, target.triple, input, "-O0")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedSignExtendMaskAndOwnedTupleBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, ratio := range x86PackedSignExtendOracleRatios {
+			for _, width := range []int{16, 32, 64} {
+				bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+				for _, zero := range []bool{false, true} {
+					op := "VPMOVSX" + ratio.suffix
+					if zero {
+						op += ".Z"
+					}
+					ins := x86ScalarLaneInstruction(t, op+" value+0(FP),K1,"+bank+"1")
+					t.Run(arch+"/"+ins.Raw, func(t *testing.T) {
+						for missing := -2; missing < 32; missing++ {
+							state := x86FloatingHelperInitializedState()
+							state.fp = make([]bool, 32)
+							owned := make([]bool, 32)
+							for at := range owned {
+								owned[at], state.fp[at] = true, at != missing
+							}
+							if missing == -2 {
+								state.masks[1] = false
+							}
+							before := state.clone()
+							accepted := x86ScalarFPResultTransfer(ins, &state, owned, 32, arch)
+							want := missing != -2 && (missing < 0 || missing >= width*ratio.input/ratio.output)
+							if accepted != want || !accepted && !reflect.DeepEqual(state, before) ||
+								accepted && state.vectorBytes(1) != ^uint64(0) {
+								t.Fatal("a missing mask/actual tuple byte acquired a result or partly mutated state", missing, accepted, want)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedSignExtendRawDoesNotBorrowZeroExtendOrErasedOrigin(t *testing.T) {
+	var body strings.Builder
+	var rows []string
+	for _, ratio := range x86PackedSignExtendOracleRatios {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			source := "X0"
+			if bank == "Z" && ratio.output == 2*ratio.input {
+				source = "Y0"
+			}
+			row := fmt.Sprintf("VPMOVSX%s %s,%s1", ratio.suffix, source, bank)
+			rows = append(rows, row)
+			fmt.Fprintln(&body, row)
+		}
+	}
+	body.WriteString("RET")
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String())
+	if len(rows) != 18 || len(pcs) != 19 || pcs[18] != int64(len(code)-1) || code[len(code)-1] != 0xc3 {
+		t.Fatal("complete independent original raw SX byte/PC directory changed", pcs)
+	}
+	for _, mode := range []int{32, 64} {
+		x86NumericalNativeRequireMC(t, code[:pcs[18]], mode, 18, "+avx2,+avx512f,+avx512bw,+avx512vl")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var prior strings.Builder
+		for index, row := range rows {
+			prefix := "TEXT ·Value(SB),4,$0-4\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+			ending := "MOVL X1,ret+0(FP)\nRET\n"
+			named := prefix + row + "\n" + ending
+			raw := prefix + x86RawDisplacementDirectives(code[pcs[index]:pcs[index+1]]) + ending
+			prior.WriteString(strings.Replace(named, "·Value", fmt.Sprint("·Named", index), 1))
+			prior.WriteString(strings.Replace(raw, "·Value", fmt.Sprint("·Raw", index), 1))
+		}
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], prior.String())
+		for index, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				prefix := "TEXT ·Value(SB),4,$0-4\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+				ending := "MOVL X1,ret+0(FP)\nRET\n"
+				named := prefix + row + "\n" + ending
+				raw := prefix + x86RawDisplacementDirectives(code[pcs[index]:pcs[index+1]]) + ending
+				check := x86LegacyFloatReplayCheck(t, arch, named, "func Value() uint32")
+				if err := check(mustParseX86RawReturn(t, named).Funcs[0]); err != nil {
+					t.Fatal("fully initialized genuine named SX control rejected", err)
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, raw), arch)
+				if err != nil || len(file.Funcs) != 1 {
+					t.Fatal("independently accepted physical SX source failed to normalize", err)
+				}
+				original, ordinal := file.Funcs[0], -1
+				for at, ins := range original.Instrs {
+					if ins.x86SourceRaw != nil && strings.HasPrefix(string(ins.Op), "VPMOVSX") {
+						ordinal = at
+						if x86RawZeroExtendSource(ins, arch) {
+							t.Fatal("raw SX silently acquired an existing ZX identity")
+						}
+					}
+				}
+				if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+					t.Fatal("original physical SX source lost its whole producer seal")
+				}
+				for _, erase := range []bool{false, true} {
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					if erase {
+						candidate.Instrs[ordinal].x86SourceRaw = nil
+					}
+					if err := check(candidate); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("raw SX or an erased origin borrowed ordinary named/ZX numerical permission", erase, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_packed_sign_extend_source_test.go b/x86_packed_sign_extend_source_test.go
new file mode 100644
index 000000000..bc06ad8a3
--- /dev/null
+++ b/x86_packed_sign_extend_source_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// The ratios and 20..25 opcodes come from PMOVSX in the Intel/Go tables,
+// independently of both production membership and zero-extension results.
+var x86PackedSignExtendOracleRatios = []struct {
+	suffix        string
+	input, output int
+}{
+	{"BW", 1, 2}, {"BD", 1, 4}, {"BQ", 1, 8},
+	{"WD", 2, 4}, {"WQ", 2, 8}, {"DQ", 4, 8},
+}
+
+func TestX86PackedSignExtendCompleteOfficialRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := make(map[string]int)
+	for index, ratio := range x86PackedSignExtendOracleRatios {
+		opcode := 0x20 + index
+		legacy := "PMOVSX" + ratio.suffix
+		if !strings.Contains(string(data), fmt.Sprintf("{A%s, yxm_q4, Pq4, opBytes{0x%02x}}", legacy, opcode)) {
+			t.Fatal("original legacy sign-extension row changed", legacy)
+		}
+		member := "V" + legacy
+		table := "_yvbroadcastss"
+		if ratio.output == 2*ratio.input {
+			table = "_yvcvtdq2pd"
+		}
+		var bytes []string
+		for _, bits := range []int{128, 256} {
+			bytes = append(bytes, fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F38 | vexW0", bits), fmt.Sprintf("0x%02x", opcode))
+		}
+		for _, bits := range []int{128, 256, 512} {
+			bytes = append(bytes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW0", bits),
+				fmt.Sprintf("evexN%d | evexZeroingEnabled", bits/8*ratio.input/ratio.output), fmt.Sprintf("0x%02x", opcode))
+		}
+		for _, rule := range rules {
+			if rule.Opcode != member {
+				continue
+			}
+			row := counts[member]
+			if row > 7 || rule.RowIndex != row || rule.Ytab != table || rule.Prefix != "Pavx" ||
+				rule.EncodingOffset != []int{0, 2, 4, 4, 7, 7, 10, 10}[row] ||
+				rule.ZOffset != []int{2, 2, 0, 3, 0, 3, 0, 3}[row] || !reflect.DeepEqual(rule.OpBytes, bytes) {
+				t.Fatal("complete signed widening encoding/tuple attributes changed", member, rule)
+			}
+			classes, zcase := []string{"Yxm", "Yxr"}, "Zvex_rm_v_r"
+			if row == 1 {
+				classes[1] = "Yyr"
+			} else if row >= 2 {
+				classes = []string{"YxmEvex", []string{"YxrEvex", "YyrEvex", "Yzr"}[(row-2)/2]}
+				if row >= 6 && ratio.output == 2*ratio.input {
+					classes[0] = "YymEvex"
+				}
+				zcase = "Zevex_rm_v_r"
+				if row%2 == 1 {
+					classes = []string{classes[0], "Yknot0", classes[1]}
+					zcase = "Zevex_rm_k_r"
+				}
+			}
+			if rule.ZCase != zcase || !reflect.DeepEqual(rule.Classes, classes) {
+				t.Fatal("complete signed widening operand row changed", member, rule)
+			}
+			counts[member]++
+		}
+		if counts[member] != 8 {
+			t.Fatal("complete eight-row VEX/EVEX denominator changed", member, counts[member])
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		source.WriteString("TEXT Prior(SB),4,$0-0\n")
+		for _, ratio := range x86PackedSignExtendOracleRatios {
+			for _, prefix := range []string{"P", "VP"} {
+				// Reuse only the independently specified operand-shape generator;
+				// sign-byte dependencies below are not copied from MOVZX.
+				for _, row := range x86ZeroExtendAcceptedForms(prefix+"MOVSX"+ratio.suffix, arch) {
+					fmt.Fprintln(&source, row)
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		goAssemblerOracleOutput(t, arch, source.String(), "", true)
+	}
+}
+
+func TestX86PackedSignExtendEveryByteAndUpperAliases(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, ratio := range x86PackedSignExtendOracleRatios {
+			for _, prefix := range []string{"P", "VP"} {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					if prefix == "P" && bank != "X" {
+						continue
+					}
+					width, sourceBank := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank], "X"
+					if width*ratio.input/ratio.output > 16 {
+						sourceBank = "Y"
+					}
+					modes := []string{"plain"}
+					if prefix == "VP" {
+						modes = append(modes, "merge", "zero")
+					}
+					for _, mode := range modes {
+						name, mask := prefix+"MOVSX"+ratio.suffix, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							name += ".Z"
+						}
+						for _, destination := range []int{0, 1} {
+							row := fmt.Sprintf("%s %s0,%s%s%d", name, sourceBank, mask, bank, destination)
+							t.Run(arch+"/"+row, func(t *testing.T) {
+								ins := x86ScalarLaneInstruction(t, row)
+								effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+								if !known || err != nil || !effect.requiresResultProof ||
+									effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+									t.Fatal("signed widening lacks its independent typed input obligation", known, err)
+								}
+								for input := 0; input < 3; input++ {
+									for missing := -1; missing < 64; missing++ {
+										state := x86FMA3ResultInputState()
+										if missing >= 0 {
+											state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+										}
+										before := state.clone()
+										var defined uint64
+										for output := 0; output < width; output++ {
+											part := output % ratio.output
+											if part >= ratio.input {
+												part = ratio.input - 1 // Every high byte depends on the sign byte.
+											}
+											at := output/ratio.output*ratio.input + part
+											available := before.vectorBytes(0)>>uint(at)&1 != 0
+											if mode == "merge" {
+												available = available && before.vectorBytes(destination)>>uint(output)&1 != 0
+											}
+											if available {
+												defined |= uint64(1) << uint(output)
+											}
+										}
+										want := before.clone()
+										want.writeVector(destination, width, defined, prefix == "P")
+										if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+											t.Fatal("sign extension invented a sign byte or changed aliases/FLAGS/storage", input, missing)
+										}
+									}
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedSignExtendOriginalCompletePrograms(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, member := range []struct{ name, declaration string }{
+		{"packedSignExtendMoveVEXSemantics", "func packedSignExtendMoveVEXSemantics(out *[288]byte,src *[32]byte)"},
+		{"packedSignExtendMoveMaskSemantics", "func packedSignExtendMoveMaskSemantics(out *[768]byte,src,old *[64]byte)"},
+	} {
+		t.Run(member.name, func(t *testing.T) {
+			start := strings.Index(string(data), "TEXT ·"+member.name+"(SB)")
+			if start < 0 {
+				t.Fatal("original signed widening entry missing")
+			}
+			end := strings.Index(string(data[start:]), "\n\tRET\n")
+			if end < 0 {
+				t.Fatal("original complete signed widening return missing")
+			}
+			x86PackedFaultProgramObjects(t, "#include \"textflag.h\"\n"+string(data[start:start+end+len("\n\tRET\n")]), member.declaration)
+		})
+	}
+}
diff --git a/x86_packed_word_multiply_value_runtime_test.go b/x86_packed_word_multiply_value_runtime_test.go
new file mode 100644
index 000000000..c53e5948e
--- /dev/null
+++ b/x86_packed_word_multiply_value_runtime_test.go
@@ -0,0 +1,100 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func x86WordMultiplyValueRuntimeProgram(arch string, discard bool) (string, string, string, string) {
+	return x86FixedBinaryValueRuntimeProgram(arch, discard, "WordMultiplyValue", x86WordMultiplyValueRows, func(op string) (int, int) {
+		return 16, x86WordMultiplyReferenceMode(op)
+	})
+}
+
+// Mathematical integer reference, independent of the emitter and its spec map.
+// Signed high uses floor division; rounded signed high wraps, never saturates.
+const x86WordMultiplyPortableReference = `
+static uint16_t product(uint16_t a,uint16_t b,unsigned operation) {
+    if(operation==0)return (uint16_t)((uint32_t)a*b);
+    if(operation==2)return (uint16_t)(((uint32_t)a*b)/65536);
+    int64_t x=a<32768?a:(int64_t)a-65536,y=b<32768?b:(int64_t)b-65536;
+    int64_t value=x*y,divisor=65536;
+    if(operation==3){value+=16384;divisor=32768;}
+    return (uint16_t)(value<0?-((-value+divisor-1)/divisor):value/divisor);
+}
+`
+
+func TestX86PackedWordMultiplyCompletePortableValuesAndCanaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, cWord, want := "amd64", "uint64_t", 40
+	if strconv.IntSize == 32 {
+		arch, cWord, want = "386", "uint32_t", 16
+	}
+	source, declarations, prototypes, rows := x86WordMultiplyValueRuntimeProgram(arch, false)
+	x86LEAActualTargetGoObject(t, arch, map[string]string{"amd64": "x86_64-unknown-linux-gnu", "386": "i386-unknown-linux-gnu"}[arch], source)
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes +
+		"typedef " + cWord + " source_word;\n" + x86WordMultiplyPortableReference + `
+struct kernel {void (*fn)(uint8_t*,uint8_t*,uint8_t*,source_word);unsigned width,bits,mode,legacy,operation;};
+static const struct kernel kernels[]={
+` + rows + `};
+int main(void) {
+    const source_word masks[]={0,1,(source_word)0xa55a9c63f00fc33cULL,(source_word)-1};
+    const uint16_t edges[]={0,1,2,0x3fff,0x4000,0x4001,0x7fff,0x8000,0x8001,0xbfff,0xc000,0xfffe,0xffff};
+    if(sizeof(kernels)/sizeof(kernels[0])!=` + fmt.Sprint(want) + `)return 1;
+    for(unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);k++)for(unsigned sample=0;sample<257;sample++) {
+        const struct kernel *p=&kernels[k];
+        uint8_t a[67],b[67],a_before[67],b_before[67],out[67],want[64];
+        memset(a,0xa7,sizeof(a));memset(b,0xb9,sizeof(b));
+        for(unsigned i=0;i<64;i+=2) {
+            uint16_t x=edges[(sample+i/2)%13],y=edges[(sample/13+i/2*3)%13];
+            if(sample>169){x=(uint16_t)(sample*71+i*7919);y=(uint16_t)(sample*13+i*37);}
+            a[i+1]=x;a[i+2]=x>>8;b[i+1]=y;b[i+2]=y>>8;
+        }
+        memcpy(a_before,a,67);memcpy(b_before,b,67);
+        for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);m++) {
+            memset(out,0xc3,67);
+            memcpy(want,b+1,64);
+            if(!p->legacy)memset(want+p->width,0,64-p->width);
+            for(unsigned lane=0;lane<p->width/2;lane++) {
+                unsigned at=lane*2;
+                if(p->mode && !(masks[m]>>lane&1)) {
+                    if(p->mode==2)memset(want+at,0,2);
+                    continue;
+                }
+                uint16_t left=(uint16_t)a[at+1]|(uint16_t)a[at+2]<<8;
+                uint16_t right=(uint16_t)b[at+1]|(uint16_t)b[at+2]<<8;
+                uint16_t value=product(left,right,p->operation);
+                want[at]=value;want[at+1]=value>>8;
+            }
+            p->fn(a+1,b+1,out+1,masks[m]);
+            if(memcmp(out+1,want,64)||out[65]!=1||out[0]!=0xc3||out[66]!=0xc3||
+                memcmp(a,a_before,67)||memcmp(b,b_before,67)) {
+                fprintf(stderr,"word multiply row=%u sample=%u mask=%u width=%u mode=%u legacy=%u\n",k,sample,m,p->width,p->mode,p->legacy);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil {
+				t.Fatal("complete word-multiply execution source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "word-multiply-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+	t.Log("complete eight-member family: integer edges, upper aliases, merge/zero masks, CF and canaries; portable LLVM, not native AVX512")
+}
diff --git a/x86_packed_word_multiply_value_test.go b/x86_packed_word_multiply_value_test.go
new file mode 100644
index 000000000..3d2cd18d1
--- /dev/null
+++ b/x86_packed_word_multiply_value_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import "testing"
+
+// Independent complete ymm/yxm_q4 and _yvandnpd inventory. The three legacy
+// MMX opcodes have their own physical-state boundary, not an invented X input.
+func x86WordMultiplyValueRows(arch string) []struct{ op, bank, mode string } {
+	return x86FixedBinaryValueRows(arch, []string{
+		"PMULLW", "PMULHW", "PMULHUW", "PMULHRSW",
+		"VPMULLW", "VPMULHW", "VPMULHUW", "VPMULHRSW",
+	})
+}
+
+func TestX86PackedWordMultiplyValueCompleteFamilyFiveTargetsThreeAPIs(t *testing.T) {
+	x86FixedBinaryCompleteFamilyObjects(t, x86WordMultiplyValueRows, 40, 16)
+}
+
+func TestX86PackedWordMultiplyVoidCannotInventRegisterInputs(t *testing.T) {
+	x86FixedBinaryVoidInputBoundaries(t, x86WordMultiplyValueRows)
+}
+
+func TestX86PackedWordMultiplyNativeInputsStayIndependent(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, x86WordMultiplyValueRows)
+}
diff --git a/x86_paired_native_dead_source_test.go b/x86_paired_native_dead_source_test.go
new file mode 100644
index 000000000..a72f5231a
--- /dev/null
+++ b/x86_paired_native_dead_source_test.go
@@ -0,0 +1,272 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PairedNativeDeadInputsNeedActualSourceClosure(t *testing.T) {
+	rows := []struct {
+		name, instruction string
+		bytes             int
+	}{
+		{"ternary", "VPTERNLOGD.Z $0,(AX),X1,K7,X2", 16},
+		{"integer-minmax", "VPMAXSD.Z (AX),X1,K7,X2", 16},
+		{"horizontal-reduction", "VHADDPS (AX),X1,X2", 16},
+		{"broadcast", "VPBROADCASTD.Z (AX),K7,X2", 4},
+	}
+	// A real mask value of zero still needs defined address bits. Both original
+	// incoming pointers and complete NUM constants preserve the paired access;
+	// neither can be replaced by undefined or partial source registers.
+	prefix := "MOVQ p+0(FP),AX\nMOVL $0,CX\nKMOVD CX,K7\n" +
+		"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+	for _, row := range rows {
+		for _, dead := range []bool{false, true} {
+			body := row.instruction + "\nRET\n"
+			if dead {
+				body = "JMP finish\n" + row.instruction + "\nfinish:\nRET\n"
+			}
+			control := "TEXT ·Value(SB),4,$0-8\n" + prefix + body
+			changed := strings.Replace(control, "MOVQ p+0(FP),AX", "MOVQ $0,AX", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/dead=%t/%s", row.name, dead, api), func(t *testing.T) {
+					if _, err := x86ScalarFPBitViewAPI(t, control, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Fatal("genuine pointer/mask positive control failed before dead-source comparison", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, changed, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("complete NUM address lost its paired dead/live access", err)
+					}
+					if !dead && x86NumericNativeVolatileReadBytes(t, ir) != row.bytes &&
+						!(strings.Contains(ir, "asm sideeffect") && strings.Contains(ir, strings.ToLower(strings.Split(strings.Fields(row.instruction)[0], ".")[0]))) {
+						t.Fatal("live NUM native source lost its original exact-width access", row.name)
+					}
+					x86RequireNumericNativeSourceContext(t, changed, "func Value(p *byte)", "amd64")
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					for _, replacement := range []string{"", "MOVB $0,AX"} {
+						missing := strings.Replace(control, "MOVQ p+0(FP),AX", replacement, 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, missing, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead/live source acquired undefined or partial address bits", replacement, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DeadExternalSourceKeepsLoopsJoinsAndFutureStateSeparate(t *testing.T) {
+	prefix := "MOVQ p+0(FP),AX\nMOVL $0,CX\nKMOVD CX,K7\nTESTL CX,CX\n"
+	read := "VPTERNLOGD.Z $0,(AX),X1,K7,X2\n"
+	rows := []struct {
+		name, prefix, body string
+		accept             bool
+	}{
+		{"initialized-loop", prefix, "JMP finish\ndead:\n" + read + "JMP dead\nfinish:\nRET\n", true},
+		{"unknown-loop-address", strings.Replace(prefix, "MOVQ p+0(FP),AX", "MOVQ $0,AX", 1), "JMP finish\ndead:\n" + read + "JMP dead\nfinish:\nRET\n", true},
+		{"undefined-loop-address", strings.Replace(prefix, "MOVQ p+0(FP),AX\n", "", 1), "JMP finish\ndead:\n" + read + "JMP dead\nfinish:\nRET\n", false},
+		{"partial-loop-address", strings.Replace(prefix, "MOVQ p+0(FP),AX", "MOVB $0,AX", 1), "JMP finish\ndead:\n" + read + "JMP dead\nfinish:\nRET\n", false},
+		{"separate-components", prefix, "JMP middle\n" + read + "middle:\nJMP finish\n" + read + "finish:\nRET\n", true},
+		{"join-loses-pointer", prefix, "JMP finish\nJE keep\nMOVQ $0,AX\nJMP joined\nkeep:\nNOP\njoined:\n" + read + "finish:\nRET\n", false},
+		{"join-retains-pointer", prefix, "JMP finish\nJE keep\nMOVQ p+0(FP),AX\nJMP joined\nkeep:\nMOVQ p+0(FP),AX\njoined:\n" + read + "finish:\nRET\n", true},
+		{"future-pointer-is-not-entry", strings.Replace(prefix, "MOVQ p+0(FP),AX\n", "", 1), "JMP finish\n" + read + "finish:\nMOVQ p+0(FP),AX\nRET\n", false},
+		{"future-mask-is-not-entry", strings.Replace(prefix, "KMOVD CX,K7\n", "", 1), "JMP finish\n" + read + "finish:\nKMOVD CX,K7\nRET\n", false},
+		{"pure-dead-registers-stay-unknown", "", "JMP finish\nVPTERNLOGD $150,X0,X1,X2\nfinish:\nRET\n", true},
+		{"unrelated-dead-register-component", prefix, "JMP middle\nADDQ $1,DX\nmiddle:\nJMP finish\n" + read + "finish:\nRET\n", true},
+	}
+	for _, row := range rows {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-8\n" + row.prefix + row.body
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+				if row.accept {
+					if err != nil || ir == "" {
+						t.Fatal("source-bound dead proof lost its existing register domain", err)
+					}
+					if row.name == "unknown-loop-address" {
+						x86RequireNumericNativeSourceContext(t, source, "func Value(p *byte)", "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					}
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("dead source borrowed a future or one-path external input", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86DeadExternalSourceBudgetIsSharedAcrossComponents(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+
+		"JMP first\nVPTERNLOGD.Z $0,(AX),X1,K7,X2\nfirst:\n"+
+		"JMP finish\nVPTERNLOGD.Z $0,(AX),X1,K7,X2\nfinish:\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var instructions []Instr
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op != OpTEXT && ins.Op != OpLABEL {
+			instructions = append(instructions, ins)
+		}
+	}
+	if len(instructions) != 5 {
+		t.Fatal("independent two-component fixture changed", len(instructions))
+	}
+	initial := x86ResultState{}
+	ax, _, _ := x86ResultGP("AX", 8, "amd64")
+	initial.pointerGP[ax], initial.masks[7] = true, true
+	for _, row := range []struct {
+		name         string
+		visits, work int
+		accept       bool
+	}{
+		{"closed", 0, 0, true},
+		{"combined-visits", 16381, 0, false},
+		{"combined-bytes", 0, (64 << 20) - 320 - 24, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			reached := map[int]x86ResultState{0: initial.clone(), 2: initial.clone(), 4: initial.clone()}
+			before := map[int]x86ResultState{0: initial.clone(), 2: initial.clone(), 4: initial.clone()}
+			transfer := func(_ int, ins Instr, state *x86ResultState, _ []bool, _ int64, arch string) bool {
+				if state.shapeOnly {
+					t.Fatal("dead closure used a fabricated all-known shape state")
+				}
+				if ins.Op == OpJMP {
+					return true
+				}
+				accepted, known := x86ResultTernaryLogicContinuationStep(ins, state, nil, arch, true)
+				return accepted && known
+			}
+			visits, work := row.visits, row.work
+			// A unit byte envelope isolates the accounting rule; it is not a
+			// claim about actual state size, which the caller independently owns.
+			err := x86ResultCheckDeadExternalInputs(Func{}, instructions, []int{0, 1, 2, 3, 4},
+				[][]int{{2}, {2}, {4}, {4}, nil}, reached, nil, 0, "amd64", transfer, &visits, &work, 1)
+			if row.accept {
+				if err != nil || visits != 4 || work != 352 {
+					t.Fatal("two components did not share one bounded proof", visits, work, err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("per-component reset bypassed the combined function budget", err)
+			}
+			if !reflect.DeepEqual(before, reached) {
+				t.Fatal("dead source facts flowed back into the actual reachable CFG")
+			}
+		})
+	}
+}
+
+func TestX86DeadExternalDetectorUsesTypedAccessesNotAddressSyntax(t *testing.T) {
+	for _, width := range []string{"W", "L", "Q"} {
+		for _, address := range []string{"7(AX)", "7(AX)(CX*8)"} {
+			body := "LEA" + width + " " + address + ",BX"
+			t.Run(body, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, body)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil {
+					t.Fatal("independent typed address-computation control is missing", known, err)
+				}
+				for _, operand := range effect.operands {
+					if operand.operand.Kind == OpMem {
+						t.Fatal("pure address computation acquired a real memory byte effect")
+					}
+				}
+				if x86ResultDeadExternalInputs(ins, "amd64") {
+					t.Fatal("address syntax was mistaken for an external memory access")
+				}
+			})
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(width+"/"+api, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\nJMP finish\nLEA" + width + " (AX),BX\nfinish:\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir == "" || err != nil {
+					t.Fatal("unreachable pure address result lost its existing unknown-register domain", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86DeadExternalSourceRetainsOrdinaryUnknownScratch(t *testing.T) {
+	// The existing lowering fallback, not a dead-source-specific exemption,
+	// owns this operation. Its unknown low bytes must remain unavailable.
+	state := x86ResultState{flags: x86ByteFlagsAll}
+	ax, _, _ := x86ResultGP("AX", 8, "amd64")
+	cx, _, _ := x86ResultGP("CX", 8, "amd64")
+	state.pointerGP[ax] = true
+	if !x86LoweredPureGPUnknownTransfer(x86PureGPUnknownInstruction(t, "ADDL $1,CX"), &state, "amd64") ||
+		state.gp[cx] != 0xf0 || !state.pointerGP[ax] || state.flags != 0 {
+		t.Fatal("existing nontrapping scratch domain changed or invented unknown low bytes", state)
+	}
+	for _, row := range []struct {
+		name, body string
+		accept     bool
+	}{
+		{"unused-scratch", "VPTERNLOGD $0,(AX),Z1,Z2", true},
+		{"scratch-is-address-index", "VPTERNLOGD $0,(AX)(CX*1),Z1,Z2", false},
+		{"scratch-is-mask", "KMOVD CX,K7\nVPTERNLOGD.Z $0,(AX),Z1,K7,Z2", false},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),AX\nJMP finish\n" +
+					"ADDL $1,CX\n" + row.body + "\nfinish:\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+				if row.accept {
+					if err != nil || ir == "" {
+						t.Fatal("unrelated dead scratch operation lost its old unknown-value domain", err)
+					}
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unknown scratch bytes became an external address or mask input", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86TernaryDeadNamedRawMasksAndAddressesRemainObligations(t *testing.T) {
+	for _, row := range x86TernaryCompleteOracleRows() {
+		if !row.memory && row.mask < 0 {
+			continue // A dead unmasked bitwise result may legitimately stay unknown.
+		}
+		for _, spelling := range []string{"named", "raw"} {
+			instruction := strings.Replace(row.row, "$150", "$0", 1)
+			if spelling == "raw" {
+				code := x86TernaryIndependentFixtureBytes(row)
+				code[len(code)-1] = 0
+				instruction = x86RawDisplacementDirectives(code)
+			}
+			instruction = "JMP finish\n" + instruction + "\nfinish:"
+			source, declaration := x86TernaryInitializedFixture("Value", "amd64", instruction)
+			// Establish a real zero mask, not an assumed value in the source
+			// shape state. The unknown base or K role remains independently
+			// required even when no result or active lane consumes the read.
+			source = strings.Replace(source, "MOVL $85,DX", "MOVL $0,DX", 1)
+			changed := source
+			if row.memory {
+				changed = strings.Replace(changed, "MOVQ p+0(FP),AX", "MOVQ $0,AX", 1)
+			} else {
+				changed = strings.Replace(changed, "KMOVD DX,K7\n", "", 1)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(spelling+"/"+row.row+"/"+api, func(t *testing.T) {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Fatal("complete initialized dead-source control lost a legitimate typed role", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if row.memory {
+						if err != nil || ir == "" {
+							t.Fatal("defined dead NUM address lost its source-checked codegen", err)
+						}
+						x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("constant selector, zero mask or dead CFG hid an unbound native input", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_paired_native_family_inputs_test.go b/x86_paired_native_family_inputs_test.go
new file mode 100644
index 000000000..e1fa2b3f4
--- /dev/null
+++ b/x86_paired_native_family_inputs_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// This is a source-input boundary, not a second mnemonic implementation.
+// The separate original-Go and object matrices retain the complete formats.
+func TestX86PairedNativeFamiliesRetainIndependentInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		rows := x86PackedNativeAddressRows()
+		for _, name := range append(x86LegacyFloatMemoryOpcodes(), "PMADDWL", "PMADDUBSW", "PMULLD", "VPMULLD", "VPMULLQ") {
+			rows = append(rows, struct{ name, destination string }{name, "X1"})
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				instruction := row.name + " (AX)," + row.destination
+				if row.name == "VPMULLD" || row.name == "VPMULLQ" {
+					instruction = row.name + " (AX),X0," + row.destination
+				}
+				source := x86OrdinaryBPNativeSource(arch, "Value", instruction, "(AX)", 0)
+				move := "MOVQ"
+				if arch == "386" {
+					move = "MOVL"
+				}
+				variants := map[string]string{
+					"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+					"numeric-pointer": strings.Replace(source, move+" p+0(FP),AX", move+" $42,AX", 1),
+				}
+				if !strings.Contains(row.name, "CVT") {
+					input := "X1"
+					if strings.HasPrefix(row.name, "V") {
+						input = "X0"
+					}
+					variants["unknown-vector"] = strings.Replace(source, "PXOR "+input+","+input+"\n", "", 1)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					originalIR, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", arch, triple, api)
+					if err != nil || originalIR == "" {
+						t.Error("initialized paired native control rejected", api, err)
+					}
+					for name, changed := range variants {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, "func Value(p *byte)", arch, triple, api)
+						if name == "numeric-pointer" {
+							if err != nil || ir == "" {
+								t.Fatal("complete numerical address lost its paired source", api, err)
+							}
+							x86RequireSameNativeMemoryEffects(t, originalIR, ir)
+							x86RequireNumericNativeSourceContext(t, changed, "func Value(p *byte)", arch)
+							x86NumericNativeAddressObject(t, ir, triple)
+						} else if arch == "amd64" && name == "unknown-vector" {
+							x86VectorScratchCodegenControl(t, changed, "func Value(p *byte)", arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("native continuation invented an independent input", api, name, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_partial_numeric_tuple_runtime_test.go b/x86_partial_numeric_tuple_runtime_test.go
new file mode 100644
index 000000000..36ce14a3a
--- /dev/null
+++ b/x86_partial_numeric_tuple_runtime_test.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"testing"
+)
+
+func TestX86OrdinaryNumericTuplePortableDefinedCallerValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, row := range []struct{ typ, move, register, llvm, seed, bits string }{
+		{"uint32", "MOVL", "AX", "i32", "uint32_t", "0, 1, UINT32_C(0x80000000), UINT32_MAX"},
+		{"float64", "MOVSD", "X0", "double", "uint64_t", "0, UINT64_C(0x8000000000000000), UINT64_C(0x3ff8000000000000), UINT64_C(0x7ff8000000000042)"},
+	} {
+		for _, statusFirst := range []bool{true, false} {
+			t.Run(fmt.Sprintf("%s/status-first=%t", row.typ, statusFirst), func(t *testing.T) {
+				declaration, source, sig, _ := x86NumericTuplePartialFixture(t, arch, row.typ, row.move, row.register, statusFirst)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				statusIndex, valueIndex := 0, 1
+				if !statusFirst {
+					statusIndex, valueIndex = 1, 0
+				}
+				statusType := sig.Frame.Results[statusIndex].Type
+				convert := "  %bits = zext i32 %value to i64\n"
+				argument := "i32 %input"
+				if row.llvm == "double" {
+					convert = "  %bits = bitcast double %value to i64\n"
+					argument = "double %payload"
+				}
+				prepare := ""
+				if row.llvm == "double" {
+					prepare = "  %payload = bitcast i64 %input to double\n"
+				}
+				caller := fmt.Sprintf(`
+define i64 @ObserveNumericTuple(i32 %%fail, %s %%input) {
+entry:
+%s  %%pair = call %s @Value(i32 %%fail, %s)
+  %%status = extractvalue %s %%pair, %d
+  %%failed = icmp slt %s %%status, 0
+  br i1 %%failed, label %%failure, label %%success
+failure:
+  %%errorOK = icmp eq %s %%status, -1
+  %%errorResult = select i1 %%errorOK, i64 81985529216486895, i64 0
+  ret i64 %%errorResult
+success:
+  %%successOK = icmp eq %s %%status, 0
+  %%value = extractvalue %s %%pair, %d
+%s  %%result = select i1 %%successOK, i64 %%bits, i64 0
+  ret i64 %%result
+}
+`, map[bool]string{true: "i64", false: "i32"}[row.llvm == "double"], prepare,
+					sig.Ret, argument, sig.Ret, statusIndex, statusType, statusType,
+					statusType, sig.Ret, valueIndex, convert)
+				// The failure branch observes only the written status. Its payload
+				// is neither extracted nor compared, including incidental zeroes.
+				driver := fmt.Sprintf(`#include <stdint.h>
+#include <stdio.h>
+extern uint64_t ObserveNumericTuple(uint32_t, %s);
+int main(void) {
+    const %s input[] = {%s};
+    const uint32_t failure[] = {0, 1, UINT32_MAX};
+    for (unsigned f = 0; f < 3; ++f) {
+        for (unsigned i = 0; i < 4; ++i) {
+            uint64_t want = failure[f] ? UINT64_C(0x0123456789abcdef) : (uint64_t)input[i];
+            uint64_t got = ObserveNumericTuple(failure[f], input[i]);
+            if (got != want) {
+                fprintf(stderr, "numeric tuple fail=%%u row=%%u got=%%llx want=%%llx\n",
+                    failure[f], i, (unsigned long long)got, (unsigned long long)want);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`, row.seed, row.seed, row.bits)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir += caller
+						for _, optimized := range []bool{false, true} {
+							t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+								text := ir
+								if optimized {
+									text = x86DwordProductIROptimize(t, ir)
+								}
+								for _, level := range []int{0, 2} {
+									t.Run(fmt.Sprintf("backend-O%d", level), func(t *testing.T) {
+										compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "numeric-tuple-caller", triple, text, driver, nil, level)
+									})
+								}
+							})
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_partial_numeric_tuple_test.go b/x86_partial_numeric_tuple_test.go
new file mode 100644
index 000000000..0405cddcb
--- /dev/null
+++ b/x86_partial_numeric_tuple_test.go
@@ -0,0 +1,215 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This fixture copies a typed payload on success and writes only the numeric
+// status on failure. Missing payload bytes remain a strict audit failure.
+func x86NumericTuplePartialFixture(t *testing.T, arch, typ, move, register string, statusFirst bool) (string, string, FuncSig, *File) {
+	t.Helper()
+	results := "status int, n " + typ
+	statusIndex, valueIndex := 0, 1
+	if !statusFirst {
+		results, statusIndex, valueIndex = "n "+typ+", status int", 1, 0
+	}
+	declaration := "func Value(fail uint32, x " + typ + ") (" + results + ")"
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+	word := "MOVQ"
+	if arch == "386" {
+		word = "MOVL"
+	}
+	body := fmt.Sprintf(`MOVL fail+%d(FP),AX
+TESTL AX,AX
+JNZ failure
+%s x+%d(FP),%s
+%s %s,n+%d(FP)
+%s $0,status+%d(FP)
+RET
+failure:
+%s $-1,status+%d(FP)
+RET`, sig.Frame.Params[0].Offset, move, sig.Frame.Params[1].Offset, register,
+		move, register, sig.Frame.Results[valueIndex].Offset,
+		word, sig.Frame.Results[statusIndex].Offset, word, sig.Frame.Results[statusIndex].Offset)
+	_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+	return declaration, source, sig, file
+}
+
+func TestX86OrdinaryNumericTuplePartialResultsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct{ typ, move, register string }{
+			{"uint32", "MOVL", "AX"}, {"float64", "MOVSD", "X0"},
+		} {
+			for _, statusFirst := range []bool{true, false} {
+				t.Run(fmt.Sprintf("%s/%s/status-first=%t", arch, row.typ, statusFirst), func(t *testing.T) {
+					declaration, source, sig, file := x86NumericTuplePartialFixture(t, arch, row.typ, row.move, row.register, statusFirst)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					strict := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+					if _, exact := strict.(*x86IncompleteResultError); !exact || !errors.Is(strict, ErrProbeNeedsContext) {
+						t.Fatal("the original missing numerical output audit must remain exact", strict)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("output definedness audit blocked ordinary typed tuple code generation", err)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, ir, level)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryNumericTuplePartialResultsKeepInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		declaration, source, sig, _ := x86NumericTuplePartialFixture(t, arch, "uint32", "MOVL", "AX", true)
+		initial := fmt.Sprintf("MOVL fail+%d(FP),AX", sig.Frame.Params[0].Offset)
+		unwritten := fmt.Sprintf("MOVL n+%d(FP),AX", sig.Frame.Results[1].Offset)
+		for _, row := range []struct{ name, source string }{
+			{"undefined-input", strings.Replace(source, initial, "MOVL BX,AX", 1)},
+			{"unknown-address-read", strings.Replace(source, initial, "MOVL (SI),AX", 1)},
+			{"unknown-address-store", strings.Replace(source, "TESTL AX,AX", "MOVL AX,(SI)\nTESTL AX,AX", 1)},
+			{"unwritten-result-read", strings.Replace(source, initial, unwritten, 1)},
+			{"wrong-extent", strings.Replace(source, fmt.Sprintf("$0-%d", x86NumericTupleArgumentExtent(sig, arch)), fmt.Sprintf("$0-%d", x86NumericTupleArgumentExtent(sig, arch)+1), 1)},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, declaration, arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("missing numerical result authorized input/address/layout facts", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+// This local test-only extent mirrors the independently derived slots, not a
+// new production role or source proof.
+func x86NumericTupleArgumentExtent(sig FuncSig, arch string) int64 {
+	var end int64
+	for _, slot := range sig.Frame.Results {
+		if next := slot.Offset + x86FrameScalarBytes(slot.Type, arch); next > end {
+			end = next
+		}
+	}
+	return end
+}
+
+func TestX86OrdinaryNumericTuplePartialResultsKeepCachedAudit(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		_, _, sig, file := x86NumericTuplePartialFixture(t, arch, "uint32", "MOVL", "AX", true)
+		fn := file.Funcs[0]
+		budget := new(x86ResultFlowBudget)
+		fn.x86ResultFlowBudget = budget
+		ctx := amd64Ctx{sig: sig, fpSourceSig: sig, fpResults: sig.Frame.Results, fpScalarSource: fn, goarch: arch}
+		if err := ctx.scalarFPResultInitialized(); err != nil {
+			t.Fatal("ordinary numerical tuple code generation rejected", arch, err)
+		}
+		strict, visits := ctx.fpScalarCheckErr, budget.visits
+		if _, exact := strict.(*x86IncompleteResultError); !exact || visits == 0 || ctx.abi0BoolResultByteStorage() {
+			t.Fatal("code generation lost its strict failure or acquired complete-proof storage", strict, visits)
+		}
+		if err := ctx.scalarFPResultInitialized(); err != nil || ctx.fpScalarCheckErr != strict || budget.visits != visits {
+			t.Fatal("a repeated consumer discarded the strict cache or reran analysis", err)
+		}
+		for _, other := range []error{fmt.Errorf("wrapped: %w", strict), errors.Join(strict, errors.New("independent source failure"))} {
+			changed := ctx
+			changed.fpScalarCheckErr = other
+			if err := changed.scalarFPResultInitialized(); err != other {
+				t.Fatal("wrapped or joined validation error became output-only", err)
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryNumericTuplePartialResultsRoleBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			name   string
+			mutate func(*Func, *FuncSig)
+		}{
+			{"wrong-result-type", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Type = I8 }},
+			{"wrong-result-index", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Index = 1 }},
+			{"nested-result", func(_ *Func, sig *FuncSig) { sig.Frame.Results[0].Fields = []int{0} }},
+			{"overlapping-results", func(_ *Func, sig *FuncSig) { sig.Frame.Results[1].Offset = sig.Frame.Results[0].Offset }},
+			{"overlapping-parameters", func(_ *Func, sig *FuncSig) { sig.Frame.Params[1].Offset = sig.Frame.Params[0].Offset }},
+			{"unrepresented-argument", func(_ *Func, sig *FuncSig) { sig.Args = append(sig.Args, I32) }},
+			{"native-frame", func(fn *Func, _ *FuncSig) { fn.FrameSize = 4 }},
+			{"register-entry", func(fn *Func, _ *FuncSig) { fn.Sym += "<ABIInternal>" }},
+			{"custom-registers", func(_ *Func, sig *FuncSig) { sig.ArgRegs = []Reg{"AX"} }},
+			{"borrowed-bool", func(_ *Func, sig *FuncSig) { sig.x86BorrowedBoolTail = true }},
+			{"raw-text", func(fn *Func, _ *FuncSig) { fn.X86RawText = []byte{0xc3} }},
+			{"source-stack", func(fn *Func, _ *FuncSig) { fn.x86SourceStack = &x86SourceStackProof{} }},
+			{"fixed-local", func(fn *Func, _ *FuncSig) { fn.x86FixedLocal = &x86FixedLocalProof{} }},
+			{"coalesced-flow", func(fn *Func, _ *FuncSig) { fn.x86ContinuationFlow = &x86ContinuationFlow{} }},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, _, sig, file := x86NumericTuplePartialFixture(t, arch, "uint32", "MOVL", "AX", true)
+				fn := file.Funcs[0]
+				row.mutate(&fn, &sig)
+				ctx := amd64Ctx{sig: sig, fpSourceSig: sig, fpResults: sig.Frame.Results, fpScalarSource: fn, goarch: arch}
+				if err := ctx.scalarFPResultInitialized(); !errors.Is(err, ErrProbeNeedsContext) || ctx.fpScalarCheckErr == nil {
+					t.Fatal("partial tuple acquired an invalid layout or hidden entry role", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrdinaryNumericTupleKeepsOtherResultRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, custom := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/custom-registers=%t", arch, custom), func(t *testing.T) {
+				declaration := "func Value(p *byte) (q *byte,n int)"
+				move := word
+				if custom {
+					declaration, move = "func Value(p uint32) (q uint32,n uint32)", "MOVL"
+				}
+				_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+				body := fmt.Sprintf("%s p+%d(FP),AX\n%s AX,q+%d(FP)\n%s $7,n+%d(FP)\nRET",
+					move, sig.Frame.Params[0].Offset, move, sig.Frame.Results[0].Offset,
+					move, sig.Frame.Results[1].Offset)
+				pkg, _, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				var manual func(string) (FuncSig, bool)
+				if custom {
+					sig.ArgRegs = []Reg{AX}
+					manual = func(string) (FuncSig, bool) { return sig, true }
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, arch, triple, api, manual)
+						if err != nil || ir == "" {
+							t.Fatal("numerical tuple audit changed an independent complete result role", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_partial_result_audit_runtime_test.go b/x86_partial_result_audit_runtime_test.go
new file mode 100644
index 000000000..0369930e5
--- /dev/null
+++ b/x86_partial_result_audit_runtime_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86OrdinaryPartialResultsPortableCallerValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t ObservePartial(uint32_t);
+int main(void) {
+    const uint32_t input[] = {0, 1, 2, UINT32_MAX};
+    const uint32_t expected[] = {99, 42, 42, 42};
+    for (unsigned i = 0; i < 4; ++i) {
+        uint32_t got = ObservePartial(input[i]);
+        if (got != expected[i]) {
+            fprintf(stderr, "partial result row=%u got=%u want=%u\n", i, got, expected[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	for _, boolFirst := range []bool{false, true} {
+		for _, byteOffset := range []int{-1, 0, 1} {
+			name := fmt.Sprintf("bool-first=%t", boolFirst)
+			if byteOffset >= 0 {
+				name = fmt.Sprintf("partial-byte=%d/bool-first=%t", byteOffset, boolFirst)
+			}
+			t.Run(name, func(t *testing.T) {
+				declaration, source, sig, _ := x86PartialResultFixture(t, arch, "uint32", "MOVL", boolFirst)
+				valueIndex, boolIndex := 0, 1
+				if boolFirst {
+					valueIndex, boolIndex = 1, 0
+				}
+				// Only the false branch observes n. The Go source fixture and
+				// independent C values do not require an unwritten success value.
+				caller := fmt.Sprintf(`
+define i32 @ObservePartial(i32 %%input) {
+entry:
+  %%pair = call %s @Value(i32 %%input)
+  %%ok = extractvalue %s %%pair, %d
+  br i1 %%ok, label %%success, label %%failure
+failure:
+  %%n = extractvalue %s %%pair, %d
+  ret i32 %%n
+success:
+  ret i32 99
+}
+`, sig.Ret, sig.Ret, boolIndex, sig.Ret, valueIndex)
+				cSource := driver
+				if byteOffset >= 0 {
+					// The caller observes a written byte while leaving every
+					// unwritten byte unobserved, including an interior-byte store.
+					body := fmt.Sprintf("MOVB $7,n+%d(FP)\nMOVB $1,ok+%d(FP)\nRET",
+						sig.Frame.Results[valueIndex].Offset+int64(byteOffset), sig.Frame.Results[boolIndex].Offset)
+					_, _, _, source = x86ResultInitializationFixture(t, arch, declaration, body)
+					caller = fmt.Sprintf(`
+define i32 @ObservePartial(i32 %%input) {
+entry:
+  %%pair = call %s @Value(i32 %%input)
+  %%n = extractvalue %s %%pair, %d
+  %%shifted = lshr i32 %%n, %d
+  %%byte = and i32 %%shifted, 255
+  ret i32 %%byte
+}
+`, sig.Ret, sig.Ret, valueIndex, byteOffset*8)
+					cSource = strings.Replace(driver, "{99, 42, 42, 42}", "{7, 7, 7, 7}", 1)
+				}
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir += caller
+						for _, optimized := range []bool{false, true} {
+							t.Run(fmt.Sprintf("IR-O2=%t", optimized), func(t *testing.T) {
+								text := ir
+								if optimized {
+									text = x86DwordProductIROptimize(t, ir)
+								}
+								for _, level := range []int{0, 2} {
+									t.Run(fmt.Sprintf("backend-O%d", level), func(t *testing.T) {
+										compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "partial-result-caller", triple, text, cSource, nil, level)
+									})
+								}
+							})
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_partial_result_audit_test.go b/x86_partial_result_audit_test.go
new file mode 100644
index 000000000..2e24ac32a
--- /dev/null
+++ b/x86_partial_result_audit_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PartialResultFixture(t *testing.T, arch, typ, move string, boolFirst bool) (string, string, FuncSig, *File) {
+	t.Helper()
+	results := "n " + typ + ", ok bool"
+	valueIndex, boolIndex := 0, 1
+	if boolFirst {
+		results, valueIndex, boolIndex = "ok bool, n "+typ, 1, 0
+	}
+	declaration := "func Value(fail uint32) (" + results + ")"
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+	value, boolean := sig.Frame.Results[valueIndex].Offset, sig.Frame.Results[boolIndex].Offset
+	write := fmt.Sprintf("%s $42,n+%d(FP)", move, value)
+	if strings.HasPrefix(typ, "float") {
+		write = fmt.Sprintf("XORPS X0,X0\n%s X0,n+%d(FP)", move, value)
+	}
+	body := fmt.Sprintf(`MOVL fail+0(FP),AX
+TESTL AX,AX
+JNZ failure
+MOVB $1,ok+%d(FP)
+RET
+failure:
+%s
+MOVB $0,ok+%d(FP)
+RET`, boolean, write, boolean)
+	_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+	return declaration, source, sig, file
+}
+
+func TestX86OrdinaryPartialResultsRetainStrictAudit(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct{ typ, move string }{
+			{"uint8", "MOVB"}, {"uint16", "MOVW"}, {"uint32", "MOVL"},
+			{"float32", "MOVSS"}, {"float64", "MOVSD"}, {"uint64", "MOVQ"},
+		} {
+			if arch == "386" && row.typ == "uint64" {
+				continue // A Q-width GP store is not an IA32 source format.
+			}
+			for _, boolFirst := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/bool-first=%t", arch, row.typ, boolFirst), func(t *testing.T) {
+					declaration, source, sig, file := x86PartialResultFixture(t, arch, row.typ, row.move, boolFirst)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "result byte") {
+						t.Fatal("the strict audit must retain the actual incomplete-result diagnostic", err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("an independent output audit must not prevent valid ordinary code generation", err)
+							}
+							x86ResultInitializationObject(t, llc, triple, ir, "partial-result")
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryPartialResultsKeepInputAndBoolChecks(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		declaration, source, sig, _ := x86PartialResultFixture(t, arch, "uint32", "MOVL", false)
+		unwritten := fmt.Sprintf("MOVL n+%d(FP),AX", sig.Frame.Results[0].Offset)
+		for _, row := range []struct{ name, source string }{
+			{"undefined-input", strings.Replace(source, "MOVL fail+0(FP),AX", "MOVL BX,AX", 1)},
+			{"noncanonical-success-bool", strings.Replace(source, "MOVB $1,ok+", "MOVB $2,ok+", 1)},
+			{"noncanonical-later-return", strings.Replace(source, "MOVB $0,ok+", "MOVB $2,ok+", 1)},
+			{"unknown-address-read", strings.Replace(source, "MOVL fail+0(FP),AX", "MOVL (SI),AX", 1)},
+			{"unknown-address-store", strings.Replace(source, "TESTL AX,AX", "MOVL AX,(SI)\nTESTL AX,AX", 1)},
+			{"unwritten-result-read", strings.Replace(source, "MOVL fail+0(FP),AX", unwritten, 1)},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, row.source, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("output audit separation must not authorize input bytes, storage, or noncanonical bools", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86OrdinaryPartialResultCodegenKeepsCachedAudit(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		_, _, sig, file := x86PartialResultFixture(t, arch, "uint32", "MOVL", false)
+		budget := new(x86ResultFlowBudget)
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = budget
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		ctx := amd64Ctx{sig: sig, fpSourceSig: sig, fpResults: sig.Frame.Results,
+			fpScalarSource: fn, goarch: arch, targetTriple: triple}
+		if err := ctx.validateMixedBoolResultRole(); err != nil {
+			t.Fatal("the ordinary canonical bool contract must allow code generation", arch, err)
+		}
+		strict, visits := ctx.fpScalarCheckErr, budget.visits
+		if strict == nil || !errors.Is(strict, ErrProbeNeedsContext) || visits == 0 {
+			t.Fatal("code generation discarded the incomplete-result audit", arch, strict, visits)
+		}
+		if err := ctx.scalarFPResultInitialized(); err != nil || ctx.fpScalarCheckErr != strict || budget.visits != visits {
+			t.Fatal("a repeated consumer changed the audit or reran the source analysis", arch, err)
+		}
+		if !ctx.fpMixedBoolBytes || ctx.abi0BoolResultByteStorage() {
+			t.Fatal("an incomplete result acquired complete-proof storage permissions", arch)
+		}
+		for _, other := range []error{
+			fmt.Errorf("different validation failure: %w", strict),
+			errors.Join(strict, errors.New("independent source guard failed")),
+		} {
+			changed := ctx
+			changed.fpScalarCheckErr = other
+			if err := changed.scalarFPResultInitialized(); err != other {
+				t.Fatal("a wrapped or joined validation error became output-only", arch, err)
+			}
+		}
+	}
+}
diff --git a/x86_permutation_shuffle_fault_test.go b/x86_permutation_shuffle_fault_test.go
new file mode 100644
index 000000000..b91bb59b3
--- /dev/null
+++ b/x86_permutation_shuffle_fault_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// E4NF source reads remain observable with zero masking and a dead result.
+// This exercises portable read extents, not original AVX512 hardware.
+func TestX86PermutationShuffleDeadZeroMaskExactTupleFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, callbacks, metadata strings.Builder
+	count := 0
+	for _, op := range []string{"VPERMD", "VPERMPS", "VSHUFF32X4", "VSHUFF64X2", "VSHUFI32X4", "VSHUFI64X2"} {
+		for _, bank := range []string{"Y", "Z"} {
+			for _, broadcast := range []bool{false, true} {
+				name := fmt.Sprint("PermutationAccess", count)
+				width := 32
+				if bank == "Z" {
+					width = 64
+				}
+				args, suffix := "(BX),"+bank+"1,K1,"+bank+"2", ".Z"
+				if broadcast {
+					width, suffix = 4, ".BCST.Z"
+					if strings.HasSuffix(op, "64X2") {
+						width = 8
+					}
+				}
+				if strings.HasPrefix(op, "VSHUF") {
+					args = "$147," + args
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ data+0(FP),BX\nVPXORD Z1,Z1,Z1\nMOVL $0,AX\nKMOVD AX,K1\n%s%s %s\nRET\n", name, op, suffix, args)
+				fmt.Fprintf(&declarations, "func %s(data *[64]byte)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *);\n", name)
+				fmt.Fprintf(&callbacks, "static int run%d(const uint8_t *p) { %s(p); return 0; }\n", count, name)
+				fmt.Fprintf(&metadata, "{run%d,%d,%d},\n", count, width, width-1)
+				count++
+			}
+		}
+	}
+	if count != 24 {
+		t.Fatal("complete E4NF dead/zero tuple directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86MemoryFaultDriver(prototypes.String()+callbacks.String(), metadata.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("dead/zero source continuation", err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+				{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "permutation-shuffle-access", pipeline.ir, driver, pipeline.level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, count)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_permutation_shuffle_values_test.go b/x86_permutation_shuffle_values_test.go
new file mode 100644
index 000000000..02a15325b
--- /dev/null
+++ b/x86_permutation_shuffle_values_test.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This factored portable-value owner covers all six previously unclosed
+// members, both widths and every mask mode. It is not native AVX acceptance.
+func TestX86PermutationShuffleWholeValuesAndUpperAliases(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, op := range []string{"VPERMD", "VPERMPS", "VSHUFF32X4", "VSHUFF64X2", "VSHUFI32X4", "VSHUFI64X2"} {
+		selectors := []int{0}
+		if strings.HasPrefix(op, "VSHUF") {
+			selectors = []int{0, 3, 108, 147}
+		}
+		for _, selector := range selectors {
+			for _, bank := range []string{"Y", "Z"} {
+				for mode := 0; mode < 3; mode++ {
+					name := fmt.Sprint("PermutationValue", count)
+					width, bits := 32, 32
+					if bank == "Z" {
+						width = 64
+					}
+					if strings.HasSuffix(op, "64X2") {
+						bits = 64
+					}
+					variable := op == "VPERMD" || op == "VPERMPS"
+					fmt.Fprintf(&declarations, "func %s(out *[72]byte,a,b *[64]byte,mask uint64)\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ a+8(FP),BX\nMOVQ b+16(FP),CX\nVMOVUPS (CX),%s1\n", name, bank)
+					first, suffix := bank+"0", ""
+					if mode == 0 {
+						fmt.Fprintf(&source, "VMOVUPS (BX),%s0\n", bank)
+					} else {
+						first = "(BX)"
+						source.WriteString("KMOVQ mask+24(FP),K1\n")
+					}
+					if mode != 2 {
+						source.WriteString("VMOVUPS (DI),Z2\n")
+					} else {
+						suffix = ".BCST.Z" // No old destination initialization.
+					}
+					args := first + "," + bank + "1"
+					if !variable {
+						args = fmt.Sprintf("$%d,", selector) + args
+					}
+					if mode != 0 {
+						args += ",K1"
+					}
+					seed := count % 3
+					left, right := []int64{1, -2147483648, 5}[seed], []int64{3, 1, 5}[seed]
+					fmt.Fprintf(&source, "MOVL $%d,DX\nCMPL DX,$%d\n%s%s %s,%s2\nVMOVUPS Z2,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nSETEQ 66(DI)\nRET\n", left, right, op, suffix, args, bank)
+					fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", name)
+					fmt.Fprintf(&metadata, "{%s,%d,%d,%t,%d,%d,%d},\n", name, width, bits/8, variable, mode, selector, 1<<uint(seed))
+					count++
+				}
+			}
+		}
+	}
+	if count != 108 {
+		t.Fatal("complete factored six-member value directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := `
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+struct row { void (*run)(uint8_t *,const uint8_t *,const uint8_t *,uint64_t); unsigned width,element; bool variable; unsigned mode,selector,flags; };
+static const struct row rows[] = { ` + metadata.String() + ` };
+int main(void) {
+    const uint64_t masks[] = {0,1,0x55,0xaa,UINT64_MAX,UINT64_C(1)<<63};
+    unsigned observations=0;
+    for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);++r) {
+        const struct row *row=&rows[r];
+        for(unsigned sample=0;sample<32;++sample) {
+            uint8_t a[64],b[64],a_before[64],b_before[64],first[64];
+            for(unsigned i=0;i<64;++i) { a[i]=(uint8_t)(i*17+sample*31+1); b[i]=(uint8_t)(i*13+sample*29+7); }
+            memcpy(a_before,a,64); memcpy(b_before,b,64); memcpy(first,a,64);
+            if(row->mode==2) for(unsigned i=0;i<64;++i) first[i]=a[i%row->element];
+            for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);++m) {
+                uint8_t output[72],expected[72];
+                for(unsigned i=0;i<72;++i) output[i]=(uint8_t)(i*19+sample*11+3);
+                memcpy(expected,output,72);
+                for(unsigned lane=0;lane<row->width/row->element;++lane) {
+                    if(row->mode && !(masks[m]>>lane&1)) {
+                        if(row->mode==2) memset(expected+lane*row->element,0,row->element);
+                        continue;
+                    }
+                    if(row->variable) {
+                        uint32_t selector; memcpy(&selector,b+lane*4,4);
+                        memcpy(expected+lane*4,first+(selector&(row->width/4-1))*4,4);
+                    } else {
+                        unsigned byte=lane*row->element,block=byte/16,blocks=row->width/16;
+                        unsigned selected=blocks==2 ? (row->selector>>block)&1 : (row->selector>>(block*2))&3;
+                        const uint8_t *input=block<blocks/2 ? b : first;
+                        memcpy(expected+byte,input+selected*16+byte%16,row->element);
+                    }
+                }
+                memset(expected+row->width,0,64-row->width);
+                expected[64]=(row->flags&1)!=0; expected[65]=(row->flags&2)!=0; expected[66]=(row->flags&4)!=0;
+                row->run(output,a,b,masks[m]);
+                if(memcmp(output,expected,72) || memcmp(a,a_before,64) || memcmp(b,b_before,64)) {
+                    fprintf(stderr,"permutation row=%u sample=%u mask=%u value/upper/FLAGS/canary/input mismatch\n",r,sample,m);
+                    return 1;
+                }
+                ++observations;
+            }
+        }
+    }
+    return observations==20736 ? 0 : 2;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("initialized whole-value continuation", err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+				{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "permutation-shuffle-whole-values", pipeline.ir, driver, pipeline.level)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_permute128_complete_test.go b/x86_permute128_complete_test.go
new file mode 100644
index 000000000..ccff9600e
--- /dev/null
+++ b/x86_permute128_complete_test.go
@@ -0,0 +1,259 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Go's _yvperm2f128 has one row per member. Intel SDM Vol.2C 5-494..497
+// requires VEX.256.66.0F3A.W0: W1/L0, EVEX, X/Z and masks are not forms.
+var x86Permute128Members = []struct {
+	op     string
+	opcode byte
+}{{"VPERM2F128", 0x06}, {"VPERM2I128", 0x46}}
+
+func TestX86Permute128IndependentGoRowsAndAllSelectorBytes(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var source strings.Builder
+	var expected []byte
+	for _, member := range x86Permute128Members {
+		count := 0
+		for _, rule := range rules {
+			if rule.Opcode != member.op {
+				continue
+			}
+			if rule.RowIndex != 0 || rule.Ytab != "_yvperm2f128" || rule.Prefix != "Pavx" ||
+				rule.ZCase != "Zvex_i_rm_v_r" || rule.ZOffset != 2 || rule.EncodingOffset != 0 ||
+				strings.Join(rule.Classes, ",") != "Yu8,Yym,Yyr,Yyr" ||
+				!reflect.DeepEqual(rule.OpBytes, []string{"avxEscape | vex256 | vex66 | vex0F3A | vexW0", fmt.Sprintf("0x%02X", member.opcode)}) {
+				t.Fatal("complete independent Go row/encoding changed", rule)
+			}
+			count++
+		}
+		if count != 1 {
+			t.Fatal("official permute128 encoder-row denominator changed", member.op, count)
+		}
+		for immediate := 0; immediate < 256; immediate++ {
+			for _, memory := range []bool{false, true} {
+				operand, modrm := "Y0", byte(0xd0)
+				if memory {
+					operand, modrm = "(AX)", 0x10
+				}
+				fmt.Fprintf(&source, "%s $%d,%s,Y1,Y2\n", member.op, immediate, operand)
+				expected = append(expected, 0xc4, 0xe3, 0x75, member.opcode, modrm, byte(immediate))
+			}
+		}
+	}
+	actual, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String()+"RET")
+	expected = append(expected, 0xc3)
+	if len(pcs) != 1025 || !bytes.Equal(actual, expected) {
+		t.Fatal("actual Go bytes lost a member, r/m form or original imm8 bit", len(pcs), len(actual))
+	}
+}
+
+// Plan9 source one is Intel SRC2; source two is Intel SRC1. Each selected
+// output half copies exactly sixteen bytes. Bits 2/6 are ignored, 3/7 zero.
+func x86Permute128RequiredBytes(immediate int) [2]uint64 {
+	var inputs [2]uint64
+	for output := 0; output < 2; output++ {
+		if immediate&(8<<uint(output*4)) != 0 {
+			continue
+		}
+		selected := immediate >> uint(output*4) & 3
+		source := 1
+		if selected >= 2 {
+			source = 0
+		}
+		inputs[source] |= uint64(0xffff) << uint(selected%2*16)
+	}
+	return inputs
+}
+
+func x86Permute128CheckTransfer(t *testing.T, op string, immediate, destination int, known [3]uint64) {
+	t.Helper()
+	ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,Y0,Y1,Y%d", op, immediate, destination))
+	state := x86FMA3ResultInputState()
+	if immediate&1 != 0 {
+		state.flags = 0
+	}
+	for register, mask := range known {
+		state.writeVector(register, 64, mask, false)
+	}
+	before := state.clone()
+	inputs := x86Permute128RequiredBytes(immediate)
+	want := known[0]&inputs[0] == inputs[0] && known[1]&inputs[1] == inputs[1]
+	accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64")
+	if want {
+		before.writeVector(destination, 32, 0xffffffff, false)
+	}
+	if accepted != want || !reflect.DeepEqual(state, before) {
+		t.Fatal("128-bit selection borrowed an unknown byte, old destination or changed aliases/FLAGS/DF", op, immediate, destination, known, accepted, want)
+	}
+}
+
+func TestX86Permute128AllSelectorsAndTypedByteRoles(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for immediate := 0; immediate < 256; immediate++ {
+			t.Run(fmt.Sprintf("%s/imm%d", member.op, immediate), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,Y0,Y1,Y2", member.op, immediate))
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+				if !known || err != nil || !effect.requiresResultProof || effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal("permute128 has no complete typed byte/FLAGS owner", known, err)
+				}
+				seen := make(map[int]bool)
+				for _, operand := range effect.operands {
+					if operand.index < 1 || operand.index > 3 || seen[operand.index] || operand.width != 32 ||
+						!reflect.DeepEqual(operand.operand, ins.Args[operand.index]) ||
+						operand.write != (operand.index == 3) || operand.index == 3 && operand.read {
+						t.Fatal("permute128 lost its two sources/write-only destination", operand)
+					}
+					seen[operand.index] = true
+				}
+				if len(seen) != 3 || !x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, "amd64") {
+					t.Fatal("Void waived the source-wide input contract")
+				}
+				for _, destination := range []int{0, 1, 2} {
+					for _, inputs := range [][3]uint64{
+						{^uint64(0), ^uint64(0), 0}, {0, 0, 0},
+						{0xffff, ^uint64(0), 0}, {0xffff0000, ^uint64(0), 0},
+						{^uint64(0), 0xffff, 0}, {^uint64(0), 0xffff0000, 0},
+					} {
+						x86Permute128CheckTransfer(t, member.op, immediate, destination, inputs)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86Permute128EverySelectedByteAndDestinationAlias(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for _, immediate := range []int{0x21, 0x32, 0x88} {
+			for _, destination := range []int{0, 1, 2} {
+				t.Run(fmt.Sprintf("%s/imm%d/dst%d", member.op, immediate, destination), func(t *testing.T) {
+					for source := 0; source < 3; source++ {
+						for missing := -1; missing < 64; missing++ {
+							known := [3]uint64{^uint64(0), ^uint64(0), ^uint64(0)}
+							if missing >= 0 {
+								known[source] &^= uint64(1) << uint(missing)
+							}
+							x86Permute128CheckTransfer(t, member.op, immediate, destination, known)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86Permute128OriginalRuntime(t *testing.T) (string, string) {
+	t.Helper()
+	_, _, function := x86PhysicalFixtureSyntax(t, "amd64_lower_permute128_test.go", "TestAMD64Permute128RuntimeSemantics")
+	values := make(map[string]string)
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		value, ok := node.(*ast.ValueSpec)
+		if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+			return true
+		}
+		name := value.Names[0].Name
+		if name != "source" && name != "mainC" {
+			return true
+		}
+		literal, ok := value.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING || values[name] != "" {
+			t.Fatal("original permute128 source/C lost its unique literal", name)
+		}
+		var err error
+		values[name], err = strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return true
+	})
+	for name, want := range map[string]string{
+		"source": "767466b2cbe556c3903ad61f162f4fe7d2d237d66840443ef0fc8d11ac8b09d4",
+		"mainC":  "598ae6f88cd21eb5ff5225b1526e01bf5fb865de4737ddbb48d88cca10b8c43e",
+	} {
+		if fmt.Sprintf("%x", sha256.Sum256([]byte(values[name]))) != want {
+			t.Fatal("complete original permute128 ASM/C/observations changed", name)
+		}
+	}
+	return "#include \"textflag.h\"\n" + values["source"], values["mainC"]
+}
+
+const x86Permute128OriginalDeclarations = "func permute128integer(out,first,second *byte)\nfunc permute128float(out,first,second *byte)"
+
+func TestX86Permute128OriginalInitializedThreeTargetObjects(t *testing.T) {
+	source, _ := x86Permute128OriginalRuntime(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, x86Permute128OriginalDeclarations, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original initialized three-pointer permute128 program lost its owner", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86Permute128VoidDoesNotInventSelectedInputs(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for _, unused := range []bool{false, true} {
+			declaration, size := "func Value()", 0
+			if unused {
+				declaration, size = "func Value(unused bool)", 1
+			}
+			for _, immediate := range []int{0x21, 0x88} {
+				for _, memory := range []bool{false, true} {
+					operand := "Y0"
+					if memory {
+						operand = "(AX)"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s $%d,%s,Y1,Y2\nRET\n", size, member.op, immediate, operand)
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/unused%t/imm%d/memory%t/%s", member.op, unused, immediate, memory, api), func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+							if immediate == 0x88 && !memory {
+								if err != nil || ir == "" {
+									t.Fatal("two immediate-zero register halves require no vector input", err)
+								}
+							} else if unused && !memory {
+								x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void/unused bool fabricated vector bytes or a pointer for zero/dead memory", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_permute128_fault_unix_test.go b/x86_permute128_fault_unix_test.go
new file mode 100644
index 000000000..2d2506d8d
--- /dev/null
+++ b/x86_permute128_fault_unix_test.go
@@ -0,0 +1,137 @@
+//go:build (darwin || linux) && (amd64 || arm64)
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// A pure LLVM/byte companion, not original Go or native AVX/AVX2 execution.
+// Both halves are immediate zero and the result is dead. The original m256
+// operand must nevertheless read all 32 bytes, with no alignment requirement.
+func TestX86Permute128ActualHostDeadZeroTupleFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	var source, declarations strings.Builder
+	for index, member := range x86Permute128Members {
+		name := fmt.Sprint("DeadPermute", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ p+0(FP),AX\n%s $136,(AX),Y1,Y2\nRET\n", name, member.op)
+		fmt.Fprintf(&declarations, "func %s(p *byte)\n", name)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("genuine incoming-pointer dead-zero permute128 rejected", err)
+			}
+			if strings.Contains(ir, " asm ") || strings.Contains(ir, "target-features") {
+				t.Fatal("portable tuple-fault companion contains native execution or an ISA constraint")
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "permute128_dead_zero_faults", triple, ir,
+				x86Permute128FaultHeader+numericalRuntimeFaultObservationC+x86Permute128FaultDriver)
+		})
+	}
+}
+
+const x86Permute128FaultHeader = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+extern void DeadPermute0(const uint8_t *);
+extern void DeadPermute1(const uint8_t *);
+typedef void (*Kernel)(const uint8_t *);
+`
+
+const x86Permute128FaultDriver = `
+static int observe(Kernel run,const uint8_t *p,int fault,
+                   uint8_t *protectedPage,size_t protectedBytes) {
+    pid_t child=fork(); if(child<0) return 1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        numerical_fault_begin(protectedPage,protectedBytes);
+        run(p);
+        // Do not touch p after the kernel: a C-side read must never turn
+        // an elided native access into a false-positive expected fault.
+        _exit(0);
+    }
+    int status=0; pid_t waited;
+    do {waited=waitpid(child,&status,0);} while(waited<0 && errno==EINTR);
+    if(waited!=child) return 1;
+    int rejected=fault ? !numerical_fault_status(status) : !(WIFEXITED(status)&&WEXITSTATUS(status)==0);
+    if(rejected) fprintf(stderr,"permute128 tuple input=%p expected-fault=%d owned=%p+%zu status=%#x\n",
+                         (const void *)p,fault,(void *)protectedPage,protectedBytes,status);
+    return rejected;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE); if(page<64) return 1;
+    uint8_t *region=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    uint8_t *readonly=mmap(0,(size_t)page,PROT_READ,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED||readonly==MAP_FAILED||mprotect(region+page,(size_t)page,PROT_NONE)) return 2;
+    const Kernel rows[]={DeadPermute0,DeadPermute1};
+    int failed=0;
+    for(size_t i=0;i<sizeof(rows)/sizeof(rows[0]);i++) {
+        // Legalization may read either half first. Own exactly the m256
+        // NULL tuple, not a single byte, a whole page or a C-side read.
+        failed|=observe(rows[i],0,1,0,32);
+        failed|=observe(rows[i],region+1,0,region+page,(size_t)page);
+        failed|=observe(rows[i],region+page-32,0,region+page,(size_t)page);
+        failed|=observe(rows[i],region+page-31,1,region+page,(size_t)page);
+        failed|=observe(rows[i],readonly,0,region+page,(size_t)page);
+    }
+    failed|=munmap(region,(size_t)page*2)!=0;
+    failed|=munmap(readonly,(size_t)page)!=0;
+    return failed?3:0;
+}
+`
+
+func TestX86Permute128FaultObserverPolicy(t *testing.T) {
+	for _, control := range []string{
+		"original", "missing-observer", "unowned-signal", "unchecked-core",
+		"missing-EINTR", "narrow-null-span", "oversized-null-span",
+	} {
+		t.Run(control, func(t *testing.T) {
+			driver := x86Permute128FaultDriver
+			switch control {
+			case "missing-observer":
+				driver = strings.Replace(driver, "numerical_fault_begin(protectedPage,protectedBytes);", "", 1)
+			case "unowned-signal":
+				driver = strings.Replace(driver, "!numerical_fault_status(status)", "WIFSIGNALED(status)", 1)
+			case "unchecked-core":
+				driver = strings.Replace(driver, "if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);", "setrlimit(RLIMIT_CORE,&no_core);", 1)
+			case "missing-EINTR":
+				driver = strings.Replace(driver, "while(waited<0 && errno==EINTR)", "while(0)", 1)
+			case "narrow-null-span":
+				driver = strings.Replace(driver, "observe(rows[i],0,1,0,32)", "observe(rows[i],0,1,0,1)", 1)
+			case "oversized-null-span":
+				driver = strings.Replace(driver, "observe(rows[i],0,1,0,32)", "observe(rows[i],0,1,0,33)", 1)
+			}
+			if control != "original" && driver == x86Permute128FaultDriver {
+				t.Fatal("fault policy negative did not change its actual driver")
+			}
+			setup := strings.Index(driver, "numerical_fault_begin(protectedPage,protectedBytes);")
+			valid := runtimeOracleFaultCorePolicy(driver) == nil && setup >= 0 &&
+				setup < strings.Index(driver, "run(p);") &&
+				strings.Contains(driver, "while(waited<0 && errno==EINTR)") &&
+				strings.Contains(driver, "if(waited!=child) return 1;") &&
+				strings.Count(driver, "observe(rows[i],0,1,0,32)") == 1 &&
+				strings.Contains(driver, "numerical_fault_status(status)") && !strings.Contains(driver, "WIFSIGNALED")
+			if valid != (control == "original") {
+				t.Fatal("fault observer lost ownership, core-limit or wait contract", control)
+			}
+		})
+	}
+}
diff --git a/x86_permute128_native_objects_test.go b/x86_permute128_native_objects_test.go
new file mode 100644
index 000000000..a2236296d
--- /dev/null
+++ b/x86_permute128_native_objects_test.go
@@ -0,0 +1,227 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+type x86Permute128OracleRow struct {
+	member, immediate, first, second, destination int
+	memory, raw                                   bool
+}
+
+func (row x86Permute128OracleRow) instruction() string {
+	input := fmt.Sprint("Y", row.first)
+	if row.memory {
+		input = "(AX)"
+	}
+	return fmt.Sprintf("%s $%d,%s,Y%d,Y%d", x86Permute128Members[row.member].op,
+		row.immediate, input, row.second, row.destination)
+}
+
+func (row x86Permute128OracleRow) code() []byte {
+	first := row.first
+	if row.memory {
+		first = 0 // ModRM memory base is AX, not the register-form source bank.
+	}
+	code := encodeX86RawVPERM2X128(x86Permute128Members[row.member].opcode,
+		byte(row.immediate), first, row.second, row.destination)
+	if row.memory {
+		code[4] &= 0x38
+	}
+	return code
+}
+
+func (row x86Permute128OracleRow) program(arch, name string) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s first+%d(FP),AX\n%s second+%d(FP),BX\n",
+		name, 3*word, move, move, word, move, 2*word)
+	if !row.memory {
+		fmt.Fprintf(&source, "VMOVDQU (AX),Y%d\n", row.first)
+	}
+	fmt.Fprintf(&source, "VMOVDQU (BX),Y%d\nSTC\n", row.second)
+	if row.raw {
+		source.WriteString(x86RawDisplacementDirectives(row.code()))
+	} else {
+		source.WriteString(row.instruction() + "\n")
+	}
+	fmt.Fprintf(&source, "VMOVDQU Y%d,(DI)\nSETCS 32(DI)\nRET\n", row.destination)
+	return source.String(), "func " + name + "(out,first,second *byte)\n"
+}
+
+func TestX86Permute128NativeInputsAndAddressRoles(t *testing.T) {
+	for member := range x86Permute128Members {
+		for _, memory := range []bool{false, true} {
+			row := x86Permute128OracleRow{member: member, immediate: 0x21, second: 1, destination: 2, memory: memory}
+			source, declaration := row.program("amd64", "Value")
+			for _, control := range []string{"initialized", "zero", "first", "second", "numeric-address", "index", "FLAGS", "FP-write"} {
+				changed := source
+				switch control {
+				case "zero":
+					changed = strings.ReplaceAll(changed, "VMOVDQU (AX),Y0\n", "")
+					changed = strings.ReplaceAll(changed, "VMOVDQU (BX),Y1\n", "")
+					changed = strings.Replace(changed, "$33,", "$136,", 1)
+				case "first":
+					seed := "VMOVDQU (AX),Y0\n"
+					if memory {
+						seed = "MOVQ first+8(FP),AX\n"
+					}
+					changed = strings.Replace(changed, seed, "", 1)
+				case "second":
+					changed = strings.Replace(changed, "VMOVDQU (BX),Y1\n", "", 1)
+				case "numeric-address":
+					changed = strings.Replace(changed, "MOVQ first+8(FP),AX", "MOVQ $42,AX", 1)
+				case "index":
+					changed = strings.Replace(changed, "(AX)", "(AX)(SI*2)", 1)
+				case "FLAGS":
+					changed = strings.Replace(changed, "STC\n", "", 1)
+				case "FP-write":
+					changed = strings.Replace(changed, "Y2,(DI)", "Y2,first+8(FP)", 1)
+				}
+				if control != "initialized" && changed == source {
+					t.Fatal("independent input mutation did not change source", control)
+				}
+				t.Run(row.instruction()+"/"+control, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", changed)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if control == "initialized" || control == "zero" || control == "numeric-address" && memory {
+							if err != nil || ir == "" {
+								t.Fatal("real initialized permute128 lost its source owner", api, err)
+							}
+							if control == "numeric-address" {
+								if !strings.Contains(ir, "load volatile <32 x i8>") &&
+									!(strings.Contains(ir, "asm sideeffect") && strings.Contains(ir, "~{memory}")) {
+									t.Fatal("NUM address lost its original ymm input access", api)
+								}
+								x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+								x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+							}
+						} else if control == "second" || control == "first" && !memory {
+							x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("permute128 borrowed absent source/address/FLAGS/frame authority", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Permute128DeadZeroStillReadsCompleteNativeTuple(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for _, immediate := range []int{0, 0x21, 0x88, 255} {
+			row := fmt.Sprintf("%s $%d,-1(AX)(CX*4),Y1,Y2", member.op, immediate)
+			t.Run(row, func(t *testing.T) {
+				source := "TEXT PermuteAccess(SB),4,$0-0\n" + row + "\nRET\n"
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				file := mustParseX86RawReturn(t, source)
+				ir := x86SingleInstructionFormatObjectUnits(t, file,
+					map[string]FuncSig{"PermuteAccess": {Name: "PermuteAccess", Ret: Void}},
+					"amd64", "x86_64-unknown-linux-gnu", func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+						return c.lowerVec(ins.Op, ins)
+					})
+				_, body, found := strings.Cut(ir, "define void @InstructionFormat0(")
+				body, _, ended := strings.Cut(body, "\n}")
+				load := regexp.MustCompile(`(?m)^\s+%[^\n]+ = load volatile <32 x i8>, [^\n]*, align 1$`)
+				if !found || !ended || strings.Count(ir, "\ndefine ") != 1 ||
+					len(load.FindAllString(body, -1)) != 1 || strings.Count(body, "load volatile ") != 1 ||
+					strings.Contains(body, "@llvm.masked.load") || strings.Contains(body, "br i1") {
+					t.Fatal("Type6 m256 access was narrowed, masked, conditional or removable for a dead/zero result", body)
+				}
+			})
+		}
+	}
+}
+
+// Each target owns 32 initialized AMD64 or 16 raw mode32 witnesses. Member,
+// r/m, ignored/zero selector bits and aliases are orthogonal representatives;
+// the full 256 selectors and every source byte live in cheap independent roots.
+func TestX86Permute128InitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for member := range x86Permute128Members {
+				for axis, immediate := range []int{0, 0x21, 0x88, 255} {
+					for _, memory := range []bool{false, true} {
+						for _, raw := range []bool{false, true} {
+							if target.arch == "386" && !raw {
+								continue // Named four-operand Go syntax remains rejected.
+							}
+							row := x86Permute128OracleRow{member: member, immediate: immediate,
+								first: 0, second: 1, destination: []int{2, 0, 1, 7}[axis], memory: memory, raw: raw}
+							if target.arch == "amd64" && axis == 3 {
+								row.first, row.second, row.destination = 13, 15, 14
+							}
+							name := fmt.Sprint("Permute", len(names))
+							names = append(names, name)
+							body, declaration := row.program(target.arch, name)
+							source.WriteString(body)
+							declarations.WriteString(declaration)
+						}
+					}
+				}
+			}
+			want := 32
+			if target.arch == "386" {
+				want = 16
+			}
+			if len(names) != want {
+				t.Fatal("complete orthogonal object denominator changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized named/raw permute128 witnesses rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+// This executes the unchanged ordinary ASM/C as portable LLVM on the actual
+// host. It is not an original-Go AVX/AVX2 or native instruction certificate.
+func TestX86Permute128OriginalActualHostLLVMCompanion(t *testing.T) {
+	source, reference := x86Permute128OriginalRuntime(t)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, x86Permute128OriginalDeclarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("original initialized permute128 program rejected", err)
+			}
+			if strings.Contains(ir, " asm ") || strings.Contains(ir, "target-features") {
+				t.Fatal("portable bit-permute companion contains native execution or an ISA constraint")
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "original_permute128_portable", triple, ir, reference)
+		})
+	}
+}
diff --git a/x86_permute128_raw_replay_test.go b/x86_permute128_raw_replay_test.go
new file mode 100644
index 000000000..94ace360e
--- /dev/null
+++ b/x86_permute128_raw_replay_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86Permute128PhysicalModeAndWholeProducerReplay(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required for independent physical VEX prior")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		triple := testTargetTriple("linux", arch)
+		for member := range x86Permute128Members {
+			for _, memory := range []bool{false, true} {
+				row := x86Permute128OracleRow{member: member, immediate: 0x21, second: 1, destination: 2, memory: memory, raw: true}
+				t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+					code := row.code()
+					observed := x86PackedShiftRawSingleMC(t, mc, triple, code)
+					if strings.Contains(observed, "warning") || strings.Contains(observed, "invalid") ||
+						strings.Count(observed, strings.ToLower(x86Permute128Members[member].op)) != 1 {
+						t.Fatal("independent LLVM22 rejected this complete VEX instruction", observed)
+					}
+					actual, _ := x86NumericalBoundaryGoBytes(t, arch, x86RawDisplacementDirectives(code)+"RET")
+					if !bytes.Equal(actual, append(append([]byte(nil), code...), 0xc3)) {
+						t.Fatal("actual Go BYTE object changed the independently decoded VEX bytes", actual, code)
+					}
+					source, declaration := row.program(arch, "Value")
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					decoded, length, known, err := decodedX86Permute128Instruction(code, map[string]int{"386": 32, "amd64": 64}[arch])
+					if !known || err != nil || length != len(code) || decoded.Op != Op(x86Permute128Members[member].op) {
+						t.Fatal("physically valid low-bank VEX form inherited the named frontend cap", known, length, err)
+					}
+					file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+					if err != nil {
+						t.Fatal("complete original physically valid source could not normalize", err)
+					}
+					original, ordinal := file.Funcs[0], -1
+					for i, ins := range original.Instrs {
+						if ins.Op == decoded.Op && ins.x86SourceRaw != nil {
+							ordinal = i
+						}
+					}
+					if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+						t.Fatal("complete immutable raw producer replay disappeared")
+					}
+					state := x86FMA3ResultInputState()
+					state.pointerGP[0] = true
+					state.valueStack = &x86ResultValueStack{bytes: []uint8{0xa5, 0x37}, id: true}
+					before := state.clone()
+					if x86ScalarFPResultTransfer(original.Instrs[ordinal], &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("standalone raw query borrowed a named/native source role")
+					}
+					// This private paired step consumes the exact original above;
+					// it does not stand in for the complete public replay check.
+					ins := original.Instrs[ordinal]
+					expected := before.clone()
+					expected.writeVector(2, 32, 0xffffffff, false)
+					accepted, owned := x86ResultPermute128Step(ins, &state, nil, arch, true)
+					if !accepted || !owned || !reflect.DeepEqual(state, expected) ||
+						x86ResultDirectionAfterSource(ins, before.direction, arch) != before.direction ||
+						!x86ResultPreservesPrivateStorage(ins, arch) ||
+						x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch) != before.callerAddressGP {
+						t.Fatal("paired VEX selection changed FLAGS/DF/ID/private cells or existing GP identities", accepted, owned)
+					}
+					check := x86LegacyFloatReplayCheck(t, arch, source, declaration)
+					for _, mutation := range []string{"original", "origin-only", "missing-replay", "producer", "operand", "encoded", "vector-width", "original-bytes", "generation", "snapshot", "named-forgery"} {
+						t.Run(mutation, func(t *testing.T) {
+							candidate := original
+							candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+							ins := &candidate.Instrs[ordinal]
+							switch mutation {
+							case "origin-only":
+								ins.x86SourceRaw = nil
+							case "missing-replay":
+								candidate.x86RawReplay = nil
+							case "producer":
+								candidate.Instrs[1].Raw += " changed"
+							case "operand":
+								ins.Args[2].Reg = "Y7"
+							case "encoded":
+								ins.x86Encoded = !ins.x86Encoded
+							case "vector-width":
+								ins.x86VectorBytes = 7
+							case "generation":
+								ins.x86Permute128VEX = false
+							case "snapshot":
+								origin := *ins.x86SourceRaw
+								origin.permute128.vex = false
+								ins.x86SourceRaw = &origin
+							case "named-forgery":
+								ins.x86Encoded, ins.x86Permute128VEX, ins.x86SourceRaw, ins.x86VectorBytes = false, false, nil, 0
+							case "original-bytes":
+								replay := *original.x86RawReplay
+								replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+								candidate.x86RawReplay = &replay
+							}
+							failure := check(candidate)
+							if mutation == "original" {
+								if failure != nil {
+									t.Fatal("complete initialized original VEX source lost its paired owner", failure)
+								}
+							} else if !errors.Is(failure, ErrProbeNeedsContext) {
+								t.Fatal("edited physical generation or producer borrowed named source authority", failure)
+							}
+							if original.x86RawReplay.validate(original, arch) != nil {
+								t.Fatal("cloned mutation damaged the sealed original")
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+// This is the exact low-bank encoding formerly rejected by a named Go
+// arity check. Keep it as a physical positive, not a deleted old fixture.
+func TestDecodedX86RawVPERM2X128OriginalMode32LowBank(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		code := encodeX86RawVPERM2X128(member.opcode, 1, 0, 1, 2)
+		actual, _ := x86NumericalBoundaryGoBytes(t, "386", x86RawDisplacementDirectives(code)+"RET")
+		if !bytes.Equal(actual, append(append([]byte(nil), code...), 0xc3)) {
+			t.Fatal("original mode32 BYTE encoding changed", actual, code)
+		}
+		got, length, known, err := decodedX86Permute128Instruction(code, 32)
+		if !known || err != nil || length != len(code) || got.Raw != member.op+" $1, Y0, Y1, Y2" ||
+			!got.x86Encoded || !got.x86Permute128VEX || got.x86VectorBytes != 32 {
+			t.Fatal("original complete physical mode32 form inherited a named Go cap", got, length, known, err)
+		}
+	}
+}
+
+func TestX86Permute128FixedWAndNamedModeBoundaries(t *testing.T) {
+	for _, member := range x86Permute128Members {
+		for _, control := range []string{"W1", "L0", "pp", "truncated-imm", "address-override", "legacy-prefix", "RIP"} {
+			t.Run(fmt.Sprint(member.op, "/", control), func(t *testing.T) {
+				code := encodeX86RawVPERM2X128(member.opcode, 0x21, 0, 1, 2)
+				switch control {
+				case "W1":
+					code[2] |= 0x80
+				case "L0":
+					code[2] &^= 4
+				case "pp":
+					code[2] &^= 3
+				case "truncated-imm":
+					code = code[:len(code)-1]
+				case "address-override":
+					code = append([]byte{0x67}, code...)
+				case "legacy-prefix":
+					code = append([]byte{0x66}, code...)
+				case "RIP":
+					code = []byte{0xc4, 0xe3, 0x75, member.opcode, 0x15, 0, 0, 0, 0, 0x21}
+				}
+				if ins, length, known, err := decodedX86Permute128Instruction(code, 64); known && err == nil {
+					t.Fatal("invalid W/L/prefix or unbound RIP acquired a native instruction", ins, length)
+				}
+			})
+		}
+		for _, row := range []string{
+			member.op + " $0,Y0,Y1,Y2", member.op + " $255,(AX),Y1,Y2",
+		} {
+			requireX86GoAssemblerResult(t, "386", "TEXT InvalidNamed(SB),4,$0-0\n"+row+"\nRET\n", false)
+			assertX86Permute128Rejected(t, "386", "i386-unknown-linux-gnu", row)
+		}
+		// P0's high bits still identify a real VEX prefix in mode32. Do
+		// not confuse unavailable vvvv=8 with a legacy LDS prefix alias.
+		code := encodeX86RawVPERM2X128(member.opcode, 0x21, 0, 8, 2)
+		if ins, length, known, err := decodedX86Permute128Instruction(code, 32); known && err == nil {
+			t.Fatal("mode32 inherited an unavailable high vector input", ins, length)
+		}
+	}
+}
diff --git a/x86_physical_sp_fixture_contract_test.go b/x86_physical_sp_fixture_contract_test.go
new file mode 100644
index 000000000..9a53bbb4d
--- /dev/null
+++ b/x86_physical_sp_fixture_contract_test.go
@@ -0,0 +1,267 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+func x86PhysicalFixtureSyntax(t *testing.T, path, name string) ([]byte, *token.FileSet, *ast.FuncDecl) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	positions := token.NewFileSet()
+	file, err := parser.ParseFile(positions, path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == name {
+			return data, positions, function
+		}
+	}
+	t.Fatal("original physical-SP fixture disappeared", name)
+	return nil, nil, nil
+}
+
+func x86PhysicalFixtureHash(t *testing.T, text, want string) {
+	t.Helper()
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(text))); got != want {
+		t.Fatal("original physical-SP source, C observations or construction changed", got, want)
+	}
+}
+
+func x86LeaveOriginalFixture(t *testing.T) (string, string) {
+	t.Helper()
+	_, _, function := x86PhysicalFixtureSyntax(t, "amd64_lower_implicit_legacy_test.go", "TestAMD64LeaveAndXLATRuntimeSemantics")
+	values := make(map[string]string)
+	ast.Inspect(function.Body, func(node ast.Node) bool {
+		declaration, ok := node.(*ast.ValueSpec)
+		if !ok || len(declaration.Names) != 1 || len(declaration.Values) != 1 {
+			return true
+		}
+		name := declaration.Names[0].Name
+		if name != "source" && name != "mainC" {
+			return true
+		}
+		literal, ok := declaration.Values[0].(*ast.BasicLit)
+		if !ok || literal.Kind != token.STRING || values[name] != "" {
+			t.Fatal("original LEAVE source/C is no longer an independent complete literal", name)
+		}
+		var err error
+		values[name], err = strconv.Unquote(literal.Value)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return true
+	})
+	x86PhysicalFixtureHash(t, values["source"], "7446bb6a394be848c20c77729a90b392adc96fb10a8ff632f58a09753d6e77fe")
+	x86PhysicalFixtureHash(t, values["mainC"], "2cb4195e45e6bf440923af28528d9f4700df9c6b4e85edcfe0ac6ae32ea1b480")
+	return values["source"], values["mainC"]
+}
+
+type x86UnaryPhysicalAlias struct {
+	op, spelling, effective string
+	bits, number            int
+}
+
+// Independent raw ModRM numbering, including wide AH/CH/DH/BH spellings.
+// Reading the production alias function would fail to detect a shared bug.
+func x86UnaryOriginalAliases() []x86UnaryPhysicalAlias {
+	var rows []x86UnaryPhysicalAlias
+	for _, family := range []string{"NEG", "NOT"} {
+		for index, bits := range []int{16, 32, 64} {
+			for _, reg := range []struct {
+				spelling, effective string
+				number              int
+			}{
+				{"AL", "AX", 0}, {"CL", "CX", 1}, {"DL", "DX", 2}, {"BL", "BX", 3},
+				{"AH", "SP", 4}, {"CH", "BP", 5}, {"DH", "SI", 6}, {"BH", "DI", 7},
+				{"BPB", "BP", 5}, {"SIB", "SI", 6}, {"DIB", "DI", 7}, {"R8B", "R8", 8}, {"R15B", "R15", 15},
+			} {
+				rows = append(rows, x86UnaryPhysicalAlias{family + []string{"W", "L", "Q"}[index], reg.spelling, reg.effective, bits, reg.number})
+			}
+		}
+	}
+	return rows
+}
+
+func x86UnaryOriginalFixture(t *testing.T) (string, string) {
+	t.Helper()
+	data, positions, function := x86PhysicalFixtureSyntax(t, "amd64_lower_neg_test.go", "TestAMD64UnaryYmbAliasesRuntime")
+	start, end, cBuilder := -1, -1, ""
+	for _, statement := range function.Body.List {
+		text := string(data[positions.Position(statement.Pos()).Offset:positions.Position(statement.End()).Offset])
+		if strings.HasPrefix(text, "var source, checks strings.Builder") {
+			start = positions.Position(statement.Pos()).Offset
+		}
+		if text == "source.WriteString(\"\\tRET\\n\")" {
+			end = positions.Position(statement.End()).Offset
+		}
+		if strings.HasPrefix(text, "mainC := fmt.Sprintf(") {
+			cBuilder = text
+		}
+	}
+	if start < 0 || end < start {
+		t.Fatal("original complete unary source builder disappeared")
+	}
+	x86PhysicalFixtureHash(t, string(data[start:end]), "795cb722ff6fdbb95e2801dac85c4e608f4bb01db6b2f1f43588a6c81468365a")
+	x86PhysicalFixtureHash(t, cBuilder, "78a78f3e15b40a852b63b5701035a6e97db6528e2d39f3d0068b1fa77e782aee")
+	var source, checks strings.Builder
+	source.WriteString("TEXT unaryaliases(SB),$0-8\n\tMOVQ out+0(FP), R14\n")
+	rows := x86UnaryOriginalAliases()
+	if len(rows) != 78 {
+		t.Fatal("original complete unary alias directory changed", len(rows))
+	}
+	for index, row := range rows {
+		const input uint64 = 0x1122334455667701
+		want := ^input
+		if strings.HasPrefix(row.op, "NEG") {
+			want++
+		}
+		if row.bits == 16 {
+			want = input&^0xffff | want&0xffff
+		} else if row.bits == 32 {
+			want &= 0xffffffff
+		}
+		fmt.Fprintf(&source, "\tMOVQ $%#x, %s\n\t%s %s\n\tMOVQ %s, %d(R14)\n", input, row.effective, row.op, row.spelling, row.effective, index*8)
+		fmt.Fprintf(&checks, "  if (out[%d] != UINT64_C(%#x)) return %d;\n", index, want, index+1)
+	}
+	source.WriteString("\tRET\n")
+	driver := fmt.Sprintf("#include <stdint.h>\nextern void unaryaliases(uint64_t *);\nint main(void) {\n  uint64_t out[%d] = {0};\n  unaryaliases(out);\n%s  return 0;\n}\n", len(rows), checks.String())
+	return source.String(), driver
+}
+
+func TestX86PhysicalSPOriginalProgramsRetainContextAndActualGoBytes(t *testing.T) {
+	leave, _ := x86LeaveOriginalFixture(t)
+	unary, _ := x86UnaryOriginalFixture(t)
+	for _, fixture := range []struct{ source, declaration string }{
+		{leave, "func implicitlegacysemantics(out,data *byte)"},
+		{unary, "func unaryaliases(out *uint64)"},
+	} {
+		x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", "#include \"textflag.h\"\n"+fixture.source)
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("invalid physical SP/FP/RET source acquired public logical ABI authority", api, err)
+			}
+		}
+	}
+	// The actual frameless Go byte stream does not repair the changed SP.
+	// Its later logical data+8(FP) still encodes 16(RSP), now based in data,
+	// not the original caller stack. Do not run this invalid body as a C ABI.
+	// This standalone byte helper has no -I option. Resolve the selected SDK's
+	// real header explicitly, rather than treating its missing include as an
+	// assembler rejection of the original body.
+	header := fmt.Sprintf("#include %q\n", filepath.Join(runtime.GOROOT(), "pkg", "include", "textflag.h"))
+	leaveCode := amd64RegisterBoolOriginalBytes(t, header+leave)
+	left, lateFP, restoresSP := false, false, false
+	var last x86asm.Op
+	for len(leaveCode) != 0 {
+		instruction, err := x86asm.Decode(leaveCode, 64)
+		if err != nil || instruction.Len <= 0 || instruction.Len > len(leaveCode) {
+			t.Fatal("actual complete LEAVE source bytes stopped decoding", err)
+		}
+		leaveCode, last = leaveCode[instruction.Len:], instruction.Op
+		if instruction.Op == x86asm.LEAVE {
+			left = true
+			continue
+		}
+		if left {
+			restoresSP = restoresSP || instruction.Args[0] == x86asm.RSP
+			if memory, ok := instruction.Args[1].(x86asm.Mem); ok {
+				lateFP = lateFP || instruction.Op == x86asm.MOV && instruction.Args[0] == x86asm.RBX &&
+					memory.Base == x86asm.RSP && memory.Disp == 16
+			}
+		}
+	}
+	if !left || !lateFP || restoresSP || last != x86asm.RET {
+		t.Fatal("original Go physical SP/late-FP/RET evidence changed", left, lateFP, restoresSP, last)
+	}
+	code, count := amd64RegisterBoolOriginalBytes(t, unary), 0
+	for len(code) != 0 {
+		instruction, err := x86asm.Decode(code, 64)
+		if err != nil || instruction.Len <= 0 || instruction.Len > len(code) {
+			t.Fatal("actual full unary Go bytes stopped decoding", err)
+		}
+		code = code[instruction.Len:]
+		if instruction.Op != x86asm.NEG && instruction.Op != x86asm.NOT {
+			continue
+		}
+		rows := x86UnaryOriginalAliases()
+		if count >= len(rows) {
+			t.Fatal("actual original byte stream gained a unary row")
+		}
+		row := rows[count]
+		base := map[int]x86asm.Reg{16: x86asm.AX, 32: x86asm.EAX, 64: x86asm.RAX}[row.bits]
+		if instruction.Args[0] != base+x86asm.Reg(row.number) || instruction.DataSize != row.bits ||
+			instruction.Op.String() != row.op[:3] {
+			t.Fatal("actual Go byte alias no longer matches its independent physical register/width", count, row, instruction)
+		}
+		count++
+	}
+	if count != 78 {
+		t.Fatal("actual original unary bytes lost an alias row", count)
+	}
+}
+
+func TestX86PhysicalFrameFamiliesCompleteGoRowsAndNumericalBoundary(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{ALEAVEW, ynone, Pe, opBytes{0xc9}}",
+		"{ALEAVEL, ynone, P32, opBytes{0xc9}}",
+		"{ALEAVEQ, ynone, Py, opBytes{0xc9}}",
+		"{AXLAT, ynone, Px, opBytes{0xd7}}",
+	} {
+		if !strings.Contains(string(data), row) {
+			t.Fatal("independent complete implicit Go opcode attributes changed", row)
+		}
+	}
+	for family, extension := range map[string]string{"NEG": "03", "NOT": "02"} {
+		for _, width := range []struct{ suffix, prefix, opcode string }{
+			{"B", "Pb", "0xf6"}, {"W", "Pe", "0xf7"}, {"L", "Px", "0xf7"}, {"Q", "Pw", "0xf7"},
+		} {
+			row := fmt.Sprintf("{A%s%s, yscond, %s, opBytes{%s, %s}}", family, width.suffix, width.prefix, width.opcode, extension)
+			if !strings.Contains(string(data), row) {
+				t.Fatal("complete unary Go prefix, opcode or /r extension changed", row)
+			}
+			if width.suffix == "B" {
+				continue // AH is actual AX high8 here, not the wide raw ModRM SP alias.
+			}
+			for _, arch := range []string{"amd64", "386"} {
+				if arch == "386" && width.suffix == "Q" {
+					continue // The independent legacy form/rejection roots retain this illegal mode.
+				}
+				for _, spelling := range []string{"AH", "CH", "DH"} {
+					instruction := x86ScalarLaneInstruction(t, family+width.suffix+" "+spelling)
+					state := x86ResultState{flags: x86ByteFlagCF, direction: x86ResultDirectionBackward}
+					for index := range state.gp {
+						state.gp[index] = 0xff
+					}
+					before := state.clone()
+					want := spelling == "DH" || arch == "386" && spelling == "CH"
+					if accepted := x86ResultTransfer(instruction, &state, nil, 0, arch); accepted != want ||
+						!want && !reflect.DeepEqual(state, before) {
+						t.Fatal("wide Ymb alias imported physical SP/BP as ordinary NUM or lost ordinary SI/mode32BP", arch, instruction.Raw, accepted, want)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_physical_sp_private_math_test.go b/x86_physical_sp_private_math_test.go
new file mode 100644
index 000000000..82d93acde
--- /dev/null
+++ b/x86_physical_sp_private_math_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PhysicalSPRequirePublicContext(t *testing.T, source, declarations, arch, triple string) {
+	t.Helper()
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("private physical-SP mathematics acquired an unproved public entry/frame/return", api, err)
+		}
+	}
+}
+
+// Test-only direct emission. Neither this helper nor a native C call into its
+// LLVM output certifies the original physical Go entry, stack or RET. SP/BP
+// here are virtual integer slots and never replace LLVM's real return stack.
+func x86PhysicalSPPrivateEmitter(t *testing.T, source string, signatures map[string]FuncSig, arch, triple string) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return x86ScalarFormatObjectUnit(t, file, signatures, arch, triple, 0)
+}
+
+func x86PhysicalSPRunPrivateMath(t *testing.T, execution x86FloatCompareExecution, name, ir, driver string) {
+	t.Helper()
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+		{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, name, pipeline.ir, driver, pipeline.level)
+		})
+	}
+}
+
+func TestX86PhysicalSPOriginalPrivateEmitterMath(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	leave, leaveC := x86LeaveOriginalFixture(t)
+	unary, unaryC := x86UnaryOriginalFixture(t)
+	for _, fixture := range []struct {
+		name, source, driver string
+		signature            FuncSig
+	}{
+		{"implicitlegacysemantics", leave, leaveC, FuncSig{Name: "implicitlegacysemantics", Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: Ptr, Index: 1, Field: -1}}}}},
+		{"unaryaliases", unary, unaryC, FuncSig{Name: "unaryaliases", Args: []LLVMType{Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}}}}},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			ir := x86PhysicalSPPrivateEmitter(t, fixture.source,
+				map[string]FuncSig{fixture.name: fixture.signature}, "amd64", execution.triple)
+			// Only the C symbol is adapted. Every original source instruction,
+			// input value and C check above remains hash-bound and unchanged.
+			driver := "#define " + fixture.name + " InstructionFormat0\n" + fixture.driver
+			x86PhysicalSPRunPrivateMath(t, execution, "original-private-sp-math", ir, driver)
+		})
+	}
+	t.Log("original LEAVE/XLAT and all 78 Ymb aliases execute only the private virtual-SP emitter mathematics; not original Go/native ABI execution")
+}
+
+func x86LeavePrivateWidthProgram(arch string) (string, map[string]FuncSig) {
+	word, move, wide := 8, "MOVQ", "Q"
+	if arch == "386" {
+		word, move, wide = 4, "MOVL", "L"
+	}
+	var source strings.Builder
+	signatures := make(map[string]FuncSig)
+	for index, suffix := range []string{"W", wide} {
+		name := fmt.Sprint("LeaveWidth", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s data+%d(FP),BP\n"+
+			"MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\nLEAVE%s\n%s BP,0(DI)\n%s SP,%d(DI)\n"+
+			"MOVL $0,AX\nLAHF\nMOVB AH,%d(DI)\nSETOS %d(DI)\nRET\n",
+			name, 2*word, move, move, word, suffix, move, move, word, 2*word, 2*word+1)
+		signatures[name] = FuncSig{Name: name, Args: []LLVMType{Ptr, Ptr}, Ret: Void,
+			Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+				{Offset: int64(word), Type: Ptr, Index: 1, Field: -1}}}}
+	}
+	return source.String(), signatures
+}
+
+func TestX86LeaveCompleteWidthsPrivateObjectsAndPublicContext(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete private LEAVE objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, signatures := x86LeavePrivateWidthProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func LeaveWidth0(out,data *byte)\nfunc LeaveWidth1(out,data *byte)", target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("private LEAVE mathematics acquired an original physical return/frame role", api, err)
+				}
+			}
+			ir := x86PhysicalSPPrivateEmitter(t, source, signatures, target.arch, target.triple)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				compileLLVMToObject(t, llc, target.triple, "private-leave-widths.ll", "private-leave-widths.o", text)
+			}
+		})
+	}
+}
+
+// Mode32 is executed separately on an actual IA32 Linux counterpart. Merely
+// truncating a 64-bit host C pointer would not establish its four-byte model.
+func x86LeavePrivateWidthC(word int) string {
+	typ := "uint64_t"
+	if word == 4 {
+		typ = "uint32_t"
+	}
+	return fmt.Sprintf(`
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef %s word;
+extern void InstructionFormat0(uint8_t *,const uint8_t *);
+extern void InstructionFormat1(uint8_t *,const uint8_t *);
+static word read_word(const uint8_t *p,unsigned bytes) {
+    word value=0;
+    for(unsigned i=0;i<bytes;i++) value|=(word)p[i]<<(8*i);
+    return value;
+}
+
+int main(void) {
+    const uint64_t patterns[]={0,1,UINT64_C(0x8000000000008000),UINT64_MAX};
+    void (*calls[])(uint8_t *,const uint8_t *)={InstructionFormat0,InstructionFormat1};
+    unsigned outcomes=0;
+    for(unsigned row=0;row<2;row++)
+        for(unsigned sample=0;sample<4;sample++)
+            for(unsigned offset=0;offset<16;offset++) {
+                uint8_t data[32],before[32],out[32],want[32];
+                memset(data,0xa7,sizeof(data));
+                memcpy(data+offset,&patterns[sample],sizeof(word));
+                memcpy(before,data,sizeof(data));
+                memset(out,0xc3,sizeof(out));
+                memset(want,0xc3,sizeof(want));
+
+                unsigned bytes=row?sizeof(word):2;
+                word base=(word)(uintptr_t)(data+offset);
+                word mask=bytes==sizeof(word)?(word)-1:UINT16_MAX;
+                word bp=(base&~mask)|(read_word(data+offset,bytes)&mask);
+                word sp=base+bytes;
+                memcpy(want,&bp,sizeof(word));
+                memcpy(want+sizeof(word),&sp,sizeof(word));
+                want[2*sizeof(word)]=0x97;
+                want[2*sizeof(word)+1]=1;
+
+                calls[row](out,data+offset);
+                if(memcmp(out,want,sizeof(out))||memcmp(data,before,sizeof(data))) return 1;
+                outcomes++;
+            }
+    if(outcomes!=128) return 2;
+    puts("PRIVATE_LEAVE_128_WIDTH_VALUES_FLAGS_CANARIES_PASS");
+    return 0;
+}
+`, typ)
+}
+
+func TestX86LeaveAMD64PrivateWidthValuesAndFlagsPortable(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	source, signatures := x86LeavePrivateWidthProgram("amd64")
+	ir := x86PhysicalSPPrivateEmitter(t, source, signatures, "amd64", execution.triple)
+	x86PhysicalSPRunPrivateMath(t, execution, "private-leave-amd64-values", ir, x86LeavePrivateWidthC(8))
+	t.Log("two AMD64 widths use virtual SP/BP mathematics; original Go/native stack ABI is not executed")
+}
diff --git a/x86_physical_sp_private_policy_test.go b/x86_physical_sp_private_policy_test.go
new file mode 100644
index 000000000..2153ef226
--- /dev/null
+++ b/x86_physical_sp_private_policy_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+// Parse the required IA32 counterpart even on ARM64 development hosts. Its
+// host receipts, actual static ELF and owned commands cannot become a skip,
+// object-only result or an implicit QEMU/Rosetta/native Go entry assertion.
+func TestX86LeavePrivateWidthCounterpartRetainsOwnedExecution(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_leave_private_math_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	required := map[string]int{
+		"x87IA32RequireNativeHost": 2, "findLLVM22Tool": 1, "x86FloatCompareExecutionTools": 1,
+		"x86LeavePrivateWidthProgram": 1, "x86LEAActualTargetGoObject": 1, "x86PhysicalSPPrivateEmitter": 1,
+		"x86DwordProductIROptimize": 1, "x86LeavePrivateWidthC": 1, "execution.compileLLVM": 1,
+		"x86NativeOracleIA32Executable": 1, "x87IA32RunDirect": 1, "execution.run": 1,
+	}
+	const root = "TestCrossLinuxRuntimeMatrixX86LeavePrivateEmitterWidthsAndFlags"
+	if err := x86CheckHalfIndirectCommandOwner(file, root, required); err != nil {
+		t.Fatal(err)
+	}
+	for name := range required {
+		changed := make(map[string]int)
+		for name, count := range required {
+			changed[name] = count
+		}
+		changed[name]++
+		if err := x86CheckHalfIndirectCommandOwner(file, root, changed); err == nil {
+			t.Fatal("private LEAVE counterpart accepted a missing or duplicate bounded execution edge", name)
+		}
+	}
+}
diff --git a/x86_pointer_bit_transport_test.go b/x86_pointer_bit_transport_test.go
new file mode 100644
index 000000000..76f8f9ef1
--- /dev/null
+++ b/x86_pointer_bit_transport_test.go
@@ -0,0 +1,188 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86PointerBitTransportOriginalSDKStorepNoWB(t *testing.T) {
+	directory := filepath.Join(runtime.GOROOT(), "src/internal/runtime/atomic")
+	if _, err := os.Stat(directory); os.IsNotExist(err) {
+		directory = filepath.Join(runtime.GOROOT(), "src/runtime/internal/atomic")
+	}
+	assembly, err := os.ReadFile(filepath.Join(directory, "atomic_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations, err := os.ReadFile(filepath.Join(directory, "atomic_amd64.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration := regexp.MustCompile(`(?m)^func StorepNoWB\([^\n]+`).FindString(string(declarations))
+	start := strings.Index(string(assembly), "TEXT ·StorepNoWB(SB)")
+	if start < 0 || declaration == "" {
+		t.Fatal("actual SDK lost its complete StorepNoWB declaration/source")
+	}
+	source := string(assembly[start:])
+	if end := strings.Index(source, "\nTEXT "); end >= 0 {
+		source = source[:end] + "\n"
+	}
+	pkg := importedGlobalPackage(t, "atomic", "amd64",
+		[]string{"package atomic\nimport \"unsafe\"\n" + declaration + "\n"}, map[string]*types.Package{"unsafe": types.Unsafe})
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api)
+				if err != nil {
+					t.Error("unchanged SDK pointer bit transport rejected", api, err)
+					continue
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PointerBitTransportExchangeDoesNotInventResultFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, suffix := int64(8), "Q"
+		if arch == "386" {
+			word, suffix = 4, "L"
+		}
+		for _, operand := range []string{"AX,0(BX)", "0(BX),AX", "BX,0(BX)"} {
+			t.Run(arch+"/"+operand, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "XCHG"+suffix+" "+operand)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				for _, register := range []Reg{AX, BX} {
+					root, _, _ := x86ResultGP(register, word, arch)
+					state.pointerGP[root], state.callerAddressGP[root], state.callerAddressOrigin[root] = true, true, 7
+					state.canonicalGP[root] = 0x55
+					state.resultAddressGP[root] = x86ResultSlotAddress{start: 0, end: word, valid: true}
+				}
+				form, err := parseAMD64ExchangeForm(arch, ins.Op, amd64ExchangeSpecs[ins.Op], ins)
+				if err != nil {
+					t.Fatal(err)
+				}
+				root, mask, _ := x86ResultGP(form.register.Reg, word, arch)
+				before := state.clone()
+				if accepted, known := x86LoweredExchangeResultStep(ins, &state, nil, arch); accepted || !known || !reflect.DeepEqual(state, before) {
+					t.Fatal("unscoped query acquired actual caller pointer-data bits")
+				}
+				want := state.clone()
+				want.gp[root] &^= mask
+				want.canonicalGP[root] &^= mask
+				if word == 4 {
+					want.gp[root] |= 0xf0
+				}
+				want.pointerGP[root], want.callerAddressGP[root], want.callerAddressOrigin[root] = false, false, 0
+				want.resultAddressGP[root] = x86ResultSlotAddress{}
+				if accepted, known := x86LoweredExchangeResultStepWithAddressBits(ins, &state, nil, arch, true); !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("unknown old native memory became NUM/pointer or changed unrelated FLAGS/DF/address roles")
+				}
+			})
+		}
+	}
+}
+
+func TestX86PointerBitTransportFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, suffix := 8, "MOVQ", "Q"
+			if target.arch == "386" {
+				word, move, suffix = 4, "MOVL", "L"
+			}
+			var source, declarations strings.Builder
+			for ordinal, body := range []string{move + " AX,0(BX)", "XCHG" + suffix + " AX,0(BX)",
+				"XCHG" + suffix + " 0(BX),AX", move + " AX,DX\nXCHG" + suffix + " DX,0(BX)",
+				"XCHG" + suffix + " BX,0(BX)", "LOCK\nCMPXCHG" + suffix + " CX,0(BX)"} {
+				name := fmt.Sprintf("Transport%d", ordinal)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s ptr+0(FP),BX\n%s val+%d(FP),AX\n%s desired+%d(FP),CX\n%s\nRET\n",
+					name, 3*word, move, move, word, move, 2*word, body)
+				fmt.Fprintf(&declarations, "func %s(ptr **byte, val, desired *byte)\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete native pointer-data object batch", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86PointerBitTransportCompleteInputRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move, suffix := 8, "MOVQ", "Q"
+		if target.arch == "386" {
+			word, move, suffix = 4, "MOVL", "L"
+		}
+		for _, row := range []struct {
+			name, body, omit string
+			accept           bool
+		}{
+			{"move", move + " AX,0(BX)", "", true},
+			{"exchange", "XCHG" + suffix + " AX,0(BX)", "", true},
+			{"reverse-exchange", "XCHG" + suffix + " 0(BX),AX", "", true},
+			{"copied-exchange", move + " AX,DX\nXCHG" + suffix + " DX,0(BX)", "", true},
+			{"address-value-alias", "XCHG" + suffix + " BX,0(BX)", "", true},
+			{"equal-CAS", "LOCK\nCMPXCHG" + suffix + " CX,0(BX)", "", true},
+			{"missing-value", "XCHG" + suffix + " AX,0(BX)", "value", false},
+			{"missing-address", "XCHG" + suffix + " AX,0(BX)", "address", false},
+			{"partial-value", "MOVB $1,AX\nXCHG" + suffix + " AX,0(BX)", "value", false},
+			{"pointer-is-not-addend", "XADD" + suffix + " AX,0(BX)", "", false},
+			{"pointer-is-not-byte", "XCHGB AX,0(BX)", "", false},
+			{"pointer-is-not-word", "XCHGW AX,0(BX)", "", false},
+			{"dword-data-role", "XCHGL AX,0(BX)", "", target.arch == "386"},
+			{"old-value-not-NUM", "XCHG" + suffix + " AX,0(BX)\n" + move + " AX,0(BX)", "", false},
+			{"old-value-not-pointer", "XCHG" + suffix + " AX,0(BX)\n" + move + " 0(AX),DX", "", false},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				prefix := fmt.Sprintf("%s ptr+0(FP),BX\n%s val+%d(FP),AX\n%s desired+%d(FP),CX\n", move, move, word, move, 2*word)
+				if row.omit == "value" {
+					prefix = strings.Replace(prefix, fmt.Sprintf("%s val+%d(FP),AX\n", move, word), "", 1)
+				}
+				if row.omit == "address" {
+					prefix = strings.Replace(prefix, move+" ptr+0(FP),BX\n", "", 1)
+				}
+				source := fmt.Sprintf("TEXT ·transport(SB),4,$0-%d\n%s%s\nRET\n", 3*word, prefix, row.body)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func transport(ptr **byte, val, desired *byte)", target.arch, target.triple, api)
+					if row.accept {
+						if err != nil || ir == "" {
+							t.Error("actual complete pointer data role rejected", api, err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Error("pointer bit transport expanded NUM or native-address authority", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_pointer_result_transport.go b/x86_pointer_result_transport.go
new file mode 100644
index 000000000..95725ed23
--- /dev/null
+++ b/x86_pointer_result_transport.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+// Preserve the existing opaque-pointer return consumer for a complete,
+// straight-line native-word address transport. This is not numerical result
+// initialization: code/data addresses never become NUM, caller provenance or
+// permission to access their pointees. Any other effect retains its independent
+// whole-source obligation. In particular, a partial or missing result cannot
+// escape the numerical-family routing check merely because its type is ptr.
+func x86OpaqueAddressPointerResultRole(fn Func, sig FuncSig, arch string) bool {
+	if sig.Ret != Ptr || len(sig.Args) != 0 || len(sig.Frame.Params) != 0 ||
+		len(sig.Frame.Results) != 1 || !x86DirectGPFPResultSourceRole(fn, sig, arch) {
+		return false
+	}
+	word := x86ResultPointerWord(arch)
+	result := sig.Frame.Results[0]
+	if result.Type != Ptr || result.Offset != 0 || result.Index != 0 || result.Field != -1 ||
+		len(result.Fields) != 0 || fn.ArgSize != word || len(fn.Instrs) < 3 || len(fn.Instrs) > 4096 ||
+		fn.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	move := Op("MOVQ")
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var defined uint16
+	written := false
+	for index, original := range fn.Instrs[1:] {
+		if !x86ResultNamedPredicateInstruction(original) {
+			return false
+		}
+		if original.Op == OpRET {
+			return written && len(original.Args) == 0 && index == len(fn.Instrs)-2
+		}
+		if original.Op == "NOP" && len(original.Args) == 0 {
+			continue
+		}
+		ins := x86SourceMoveInstruction(original, arch)
+		if ins.Op != move || len(ins.Args) != 2 {
+			return false
+		}
+		first, last := ins.Args[0], ins.Args[1]
+		if _, immediate, destination, known := x86StaticAddressValueMove(original, arch); known && immediate {
+			defined |= 1 << uint(destination)
+			continue // The paired ordinary MOV still emits the actual symbol relocation.
+		}
+		value := first.Kind == OpImm && first.Imm == 0 && first.ImmRaw == "" && !first.ImmIsFloat
+		if first.Kind == OpReg {
+			source, _, valid := x86ResultGP(first.Reg, word, arch)
+			value = valid && defined&(1<<uint(source)) != 0
+		}
+		if !value {
+			return false
+		}
+		switch last.Kind {
+		case OpReg:
+			destination, _, valid := x86ResultGP(last.Reg, word, arch)
+			if !valid {
+				return false
+			}
+			defined |= 1 << uint(destination)
+		case OpFP:
+			if last.FPOffset != result.Offset {
+				return false
+			}
+			written = true
+		default:
+			return false
+		}
+	}
+	return false
+}
diff --git a/x86_pointer_result_transport_test.go b/x86_pointer_result_transport_test.go
new file mode 100644
index 000000000..6210dcda6
--- /dev/null
+++ b/x86_pointer_result_transport_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Retain the three complete TEXT roles from the standard-library FIPS pointer
+// check: one local code definition and two Go-declared opaque pointer results.
+// Register aliases and copies exercise the same complete native-word grammar.
+func x86PointerResultTransportSource(arch string) (string, string) {
+	word, move, moves := 8, "MOVQ", []string{"MOVQ", "MOVD", "MOVDQ2Q"}
+	if arch == "386" {
+		word, move, moves = 4, "MOVL", []string{"MOVL"}
+	}
+	var source, declarations strings.Builder
+	source.WriteString("DATA StaticData<>(SB)/4,$10\nGLOBL StaticData<>(SB),16,$4\n")
+	source.WriteString("TEXT StaticText<>(SB),$0\nRET\n")
+	for _, opcode := range moves {
+		for _, kind := range []string{"Data", "Text"} {
+			for _, copied := range []bool{false, true} {
+				name := fmt.Sprintf("Pointer%s%sCopy%t", opcode, kind, copied)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s $Static%s<>(SB),AX\n", name, word, opcode, kind)
+				register := "AX"
+				if copied {
+					fmt.Fprintf(&source, "%s AX,BX\n", move)
+					register = "BX"
+				}
+				fmt.Fprintf(&source, "%s %s,ret+0(FP)\nRET\n", move, register)
+				fmt.Fprintf(&declarations, "func %s() *byte\n", name)
+			}
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func x86PointerResultTransportAPI(t *testing.T, source, declarations, arch, triple, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declarations)
+	// A file-local TEXT does not imply a signature. This exact fixture owns
+	// the complete zero-argument RET body explicitly; do not infer a helper
+	// ABI from another function's Go declaration or remove the original TEXT.
+	manual := func(name string) (FuncSig, bool) {
+		return FuncSig{Name: name, Ret: Void}, name == "StaticText"
+	}
+	return x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, arch, triple, api, manual)
+}
+
+func TestX86OpaquePointerResultAddressFamilyCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range dataRelocationTargets {
+		if target.arch != ArchAMD64 {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86PointerResultTransportSource(target.goarch)
+			dataRelocationGoObject(t, source, target.goos, target.goarch, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86PointerResultTransportAPI(t, source, declarations, target.goarch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete code/data address lost its existing opaque pointer transport", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						objectIR := ir
+						if optimized {
+							objectIR = x86DwordProductIROptimize(t, ir)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, objectIR, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86OpaquePointerAddressCannotBorrowNumericalOrPartialStorage(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct {
+			name, declaration, body string
+		}{
+			{"code-is-not-a-number", "func Value() uintptr", move + " $StaticText<>(SB),AX\n" + move + " AX,ret+0(FP)"},
+			{"missing-result", "func Value() *byte", move + " $StaticData<>(SB),AX"},
+			{"partial-result", "func Value() *byte", move + " $StaticData<>(SB),AX\nMOVB AX,ret+0(FP)"},
+			{"unknown-copy", "func Value() *byte", move + " $StaticData<>(SB),AX\n" + move + " BX,ret+0(FP)"},
+			{"no-pointee-permission", "func Value() *byte", move + " $StaticData<>(SB),AX\nMOVB (AX),CX\n" + move + " AX,ret+0(FP)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := "DATA StaticData<>(SB)/4,$10\nGLOBL StaticData<>(SB),16,$4\n" +
+						"TEXT StaticText<>(SB),$0\nRET\n" +
+						fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nRET\n", word, row.body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					ir, err := x86PointerResultTransportAPI(t, source, row.declaration, arch, triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("opaque pointer transport acquired numerical, partial or native permissions", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86OpaqueAddressPointerRoleRetainsCompleteSourceBoundary(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move := "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		start, store := move+" $payload<>(SB),AX\n", move+" AX,ret+0(FP)\n"
+		for _, row := range []struct {
+			name, body string
+			accepted   bool
+		}{
+			{"complete", start + store + "RET", true},
+			{"copy", start + move + " AX,BX\n" + move + " BX,ret+0(FP)\nRET", true},
+			{"nil-result", start + move + " $0,ret+0(FP)\nRET", true},
+			{"padding", start + "NOP\n" + store + "RET", true},
+			{"unknown-copy", start + move + " BX,ret+0(FP)\nRET", false},
+			{"partial-source", start + "MOVB $0,AX\n" + store + "RET", false},
+			{"partial-result", start + "MOVB AX,ret+0(FP)\nRET", false},
+			{"missing-result", start + "RET", false},
+			{"early-return", start + "RET\n" + store + "RET", false},
+			{"branch", start + "JMP finish\nfinish:\n" + store + "RET", false},
+			{"native-read", start + "MOVB (AX),BX\n" + store + "RET", false},
+			{"native-write", start + "MOVB $0,(AX)\n" + store + "RET", false},
+			{"call", start + "CALL other(SB)\n" + store + "RET", false},
+			{"physical-stack", start + move + " AX,SP\n" + store + "RET", false},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() *byte", row.body)
+				before := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+				if got := x86OpaqueAddressPointerResultRole(file.Funcs[0], sig, arch); got != row.accepted {
+					t.Fatal("opaque complete transport disagrees with its source boundary", got)
+				}
+				if after := fmt.Sprintf("%#v %#v", file.Funcs[0], sig); after != before {
+					t.Fatal("opaque role changed its original function or declaration")
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("opaque transport supplied a numerical or GC result proof", err)
+				}
+			})
+		}
+		_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() *byte", start+store+"RET")
+		for _, mutation := range []string{"result-offset", "result-width", "result-index", "result-field", "result-path",
+			"argument", "register-entry", "unknown-extent", "private-frame", "raw-input", "missing-TEXT", "oversize-source"} {
+			t.Run(arch+"/"+mutation, func(t *testing.T) {
+				fn, changed := file.Funcs[0], sig
+				fn.Instrs = append([]Instr(nil), fn.Instrs...)
+				changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+				switch mutation {
+				case "result-offset":
+					changed.Frame.Results[0].Offset = 1
+				case "result-width":
+					changed.Frame.Results[0].Type = I32
+				case "result-index":
+					changed.Frame.Results[0].Index = 1
+				case "result-field":
+					changed.Frame.Results[0].Field = 0
+				case "result-path":
+					changed.Frame.Results[0].Fields = []int{0}
+				case "argument":
+					changed.Args = []LLVMType{Ptr}
+				case "register-entry":
+					changed.ArgRegs = []Reg{AX}
+				case "unknown-extent":
+					fn.ArgSize = 0
+				case "private-frame":
+					fn.FrameSize = 8
+				case "raw-input":
+					fn.Instrs[1].x86Encoded = true
+				case "missing-TEXT":
+					fn.Instrs = fn.Instrs[1:]
+				case "oversize-source":
+					fn.Instrs = make([]Instr, 4097)
+				}
+				if x86OpaqueAddressPointerResultRole(fn, changed, arch) {
+					t.Fatal("changed source or ABI metadata borrowed the original pointer role")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_popped_control_bits_test.go b/x86_popped_control_bits_test.go
new file mode 100644
index 000000000..2ae88d37d
--- /dev/null
+++ b/x86_popped_control_bits_test.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86PoppedPartialFlagsCannotInventUnmodeledControls(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			suffix, typ string
+			width       int
+		}{{"W", "uint16", 2}, {"L", "uint32", 4}, {"Q", "uint64", 8}} {
+			if target.arch == "amd64" && row.suffix == "L" || target.arch == "386" && row.suffix == "Q" {
+				continue
+			}
+			for _, producer := range []struct{ name, body string }{
+				{"partial-both-bytes", "MOVL $1,DX\nCMPL DX,DX\nBTW $0,DX\n"},
+				{"complete-high-byte", "MOVL $3,AX\nMULL AX\nCLD\n"},
+			} {
+				for _, control := range []struct {
+					name string
+					bit  uint
+				}{{"TF", 8}, {"IF", 9}, {"IOPL", 12}, {"NT", 14}, {"RF", 16}, {"AC", 18}} {
+					mask := uint64(1) << control.bit
+					// Go's W immediate deliberately truncates high bits to zero.
+					// That is a genuine defined zero, not a control-bit observation.
+					zeroMask := control.bit >= uint(8*row.width)
+					for _, numerical := range []bool{false, true} {
+						push := "PUSHF" + row.suffix
+						if numerical {
+							push = "PUSH" + row.suffix + " $7" // Defined integer data is not ambient FLAGS.
+						}
+						want := zeroMask || numerical
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s\nPOP%s AX\nAND%s $%d,AX\nMOV%s AX,ret+0(FP)\nRET\n", row.width, producer.body, push, row.suffix, row.suffix, mask, row.suffix)
+						goAssemblerOracleOutput(t, target.arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(fmt.Sprintf("%s/%s/%s/%s/numerical=%t/%s", target.triple, row.suffix, producer.name, control.name, numerical, api), func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() "+row.typ, target.arch, target.triple, api)
+								if want && (err != nil || ir == "") || !want && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+									t.Fatal("partial FLAGS acquired an unmodeled native control input or rejected actual NUM data", want, err)
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_popped_mixed_width_test.go b/x86_popped_mixed_width_test.go
new file mode 100644
index 000000000..cd922299f
--- /dev/null
+++ b/x86_popped_mixed_width_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86StackRefinementCloneJoinAndReuse(t *testing.T) {
+	flags := x86ResultState{valueStack: &x86ResultValueStack{
+		bytes: []uint8{0xff, 0xff}, refinable: []uint8{0, 1},
+	}}
+	numeric := x86ResultState{valueStack: &x86ResultValueStack{bytes: []uint8{0xff, 0xff}}}
+	copy := flags.clone()
+	copy.valueStack.refinable[1] = 0
+	if flags.valueStack.refinable[1] != 1 {
+		t.Fatal("refinement masks alias a predecessor")
+	}
+	for _, pair := range [][2]x86ResultState{{flags, numeric}, {numeric, flags}} {
+		joined := pair[0].intersect(pair[1])
+		if !reflect.DeepEqual(joined.valueStack.refinable, []uint8{0, 1}) {
+			t.Fatal("a numeric edge laundered FLAGS-origin control bits", joined.valueStack)
+		}
+		joined.valueStack.refinable[1] = 0
+		if flags.valueStack.refinable[1] != 1 {
+			t.Fatal("joined refinement masks alias a predecessor")
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		storage := 2
+		if arch == "amd64" {
+			storage = 8
+		}
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward,
+			valueStack: &x86ResultValueStack{id: true}}
+		count := x86ResultValueStackLimit(arch) / storage
+		for index := 0; index < count; index++ {
+			instruction := "PUSHW $7"
+			if index%2 == 0 {
+				instruction = "PUSHFW"
+			}
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if accepted, known := x86ResultValueStackStep(ins, &state, nil, 0, arch); !accepted || !known {
+				t.Fatal("bounded complete stack slot rejected", arch, index)
+			}
+		}
+		for index := count - 1; index >= 0; index-- {
+			ins := x86ScalarLaneInstruction(t, "POPW AX")
+			want := uint64(0xffff)
+			if index%2 == 0 {
+				want = 0xcff
+			}
+			if accepted, known := x86ResultValueStackStep(ins, &state, nil, 0, arch); !accepted || !known || state.gpBits.bits&0xffff != want {
+				t.Fatal("source-bit eligibility changed at a stack position", arch, index, state.gpBits)
+			}
+		}
+		if len(state.valueStack.bytes) != 0 || state.valueStack.refinable != nil {
+			t.Fatal("consumed source masks survived an empty stack", arch)
+		}
+		for _, text := range []string{"PUSHW $7", "POPW AX"} {
+			ins := x86ScalarLaneInstruction(t, text)
+			if accepted, known := x86ResultValueStackStep(ins, &state, nil, 0, arch); !accepted || !known {
+				t.Fatal("numeric storage could not reuse a former FLAGS slot", arch, text)
+			}
+		}
+		if state.gpBits.bits&0xffff != 0xffff {
+			t.Fatal("a stale FLAGS mask contaminated reused numeric storage", arch)
+		}
+	}
+}
+
+func TestX86PoppedMixedWidthsRetainOriginalFlagBitPositions(t *testing.T) {
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, row := range []struct {
+			name   string
+			mask   int
+			accept bool
+		}{{"unmodeled-AC", 4, false}, {"modeled-ID", 32, true}} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-4\nPUSHL $0\nPOPFL\nMOVL $3,AX\nMULL AX\nCLD\nPUSHFL\nPOPW BX\nPOPW AX\nANDW $%d,AX\nMOVW AX,ret+0(FP)\nMOVW $0,ret+2(FP)\nRET\n", row.mask)
+			goAssemblerOracleOutput(t, "386", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", "386", triple, api)
+					if row.accept && (err != nil || ir == "") || !row.accept && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("mixed-width flags transport changed an original bit role", row.accept, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_private_call_abi0_test.go b/x86_private_call_abi0_test.go
new file mode 100644
index 000000000..408676b96
--- /dev/null
+++ b/x86_private_call_abi0_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A real bounded ABI0 declaration owns its own FP arguments. It must remain
+// a call, rather than borrowing the caller's register continuation contract.
+func x86PrivateABI0CallFixture(arch string) (string, FuncSig) {
+	word, typ, lea := 8, I64, "LEAQ"
+	if arch == "386" {
+		word, typ, lea = 4, I32, "LEAL"
+	}
+	source := fmt.Sprintf(`TEXT ·Call(SB),4,$0-0
+ CALL helper<>(SB)
+ RET
+TEXT helper<>(SB),4,$0-%d
+ %s arg+0(FP),AX
+ RET
+`, word, lea)
+	return source, FuncSig{Name: "helper", Args: []LLVMType{typ}, Ret: Void,
+		Frame: FrameLayout{Params: []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}}}}
+}
+
+func TestX86PrivateCallPreservesBoundedOrdinaryABI0(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, mixed := range []bool{false, true} {
+			source, sig := x86PrivateABI0CallFixture(arch)
+			declaration := "func Call()\n"
+			if mixed {
+				other, decl := x86PrivateCallSource(arch, "CALL register<>(SB)", "TEXT register<>(SB),4,$0-0\n ADDQ BX,AX\n RET\n")
+				source += other
+				declaration += decl
+			}
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/mixed_%t/%s", arch, mixed, api), func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, arch, triple, api,
+						func(name string) (FuncSig, bool) { return sig, name == sig.Name })
+					if err != nil {
+						t.Fatal("bounded ordinary ABI0 helper rejected:", err)
+					}
+					for _, want := range []string{"define void @helper(", "call void @helper("} {
+						if !strings.Contains(ir, want) {
+							t.Fatalf("ordinary helper lost its independent ABI: missing %q\n%s", want, ir)
+						}
+					}
+					if mixed && (strings.Count(ir, "define ") != 3 || strings.Contains(ir, "@register(")) {
+						t.Fatal("register continuation acquired an independent ABI", ir)
+					}
+					x86ResultInitializationObject(t, llc, triple, ir, api)
+				})
+			}
+		}
+	}
+}
+
+func TestX86PrivateCallOrdinaryABI0DoesNotGrantContinuationRoles(t *testing.T) {
+	for _, row := range []struct {
+		name string
+		edit func(*string, *FuncSig)
+	}{
+		{"no_signature", func(_ *string, sig *FuncSig) { sig.Name = "unrelated" }},
+		{"omitted_extent", func(src *string, _ *FuncSig) { *src = strings.Replace(*src, "$0-8", "$0", 1) }},
+		{"short_extent", func(src *string, _ *FuncSig) { *src = strings.Replace(*src, "$0-8", "$0-4", 1) }},
+		{"no_frame_roles", func(_ *string, sig *FuncSig) { sig.Frame.Params = nil }},
+		{"wrong_parameter", func(_ *string, sig *FuncSig) { sig.Frame.Params[0].Index = 1 }},
+		{"custom_register", func(_ *string, sig *FuncSig) { sig.ArgRegs = []Reg{"AX"} }},
+		{"private_tail", func(src *string, _ *FuncSig) { *src = strings.Replace(*src, "CALL helper", "JMP helper", 1) }},
+		{"mixed_unsafe_graph", func(src *string, _ *FuncSig) {
+			*src += "TEXT ·Other(SB),4,$0-0\n CALL raw<>(SB)\n RET\nTEXT raw<>(SB),4,$0-8\n LEAQ arg+0(FP),AX\n RET\n"
+		}},
+		{"mixed_call_roles", func(src *string, _ *FuncSig) {
+			*src = strings.Replace(*src, "CALL helper<>(SB)", "CALL helper<>(SB)\n CALL raw<>(SB)", 1)
+			*src += "TEXT raw<>(SB),4,$0-0\n RET\n"
+		}},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source, sig := x86PrivateABI0CallFixture("amd64")
+				row.edit(&source, &sig)
+				pkg := mustGoPackage(t, "bitview", "package bitview\nfunc Call()\nfunc Other()")
+				ir, err := x86ScalarFPBitViewPackageAPIWithManual(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api,
+					func(name string) (FuncSig, bool) { return sig, name == sig.Name })
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("independent ABI did not retain its boundary: err=%v\n%s", err, ir)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_private_call_flow.go b/x86_private_call_flow.go
new file mode 100644
index 000000000..645eff0a0
--- /dev/null
+++ b/x86_private_call_flow.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import "strings"
+
+// CALL is a source-control edge only inside this complete source graph.
+// Nonzero roots and frame-unobserving leaves need the original-frame owner.
+// The original instruction/relocation coordinates stay unchanged. Each static
+// callsite gets its own return context; a tail edge keeps that context.
+func (view *x86DirectTailRoot) expandPrivateCalls(limit int) (*x86DirectTailRoot, error) {
+	ranges := make(map[int][2]int)
+	called := make(map[int]bool)
+	for pc, point := range view.points {
+		span, found := ranges[point.text]
+		if !found {
+			span[0] = pc
+		}
+		span[1] = pc + 1
+		ranges[point.text] = span
+		if view.instructions[pc].Op == OpCALL {
+			called[view.points[view.edges[pc][0]].text] = true
+		}
+	}
+	queue := make([]int, 0, len(called))
+	for text := range called {
+		queue = append(queue, text)
+	}
+	for at := 0; at < len(queue); at++ {
+		span := ranges[queue[at]]
+		for pc := span[0]; pc < span[1]; pc++ {
+			for _, target := range view.edges[pc] {
+				text := view.points[target].text
+				if !called[text] {
+					called[text] = true
+					queue = append(queue, text)
+				}
+			}
+		}
+	}
+	for text, span := range ranges {
+		fn := view.graph.original.Funcs[text]
+		framedRoot := view.graph.fixedLocal != nil && text == view.text &&
+			view.graph.fixedLocal.frames[view.graph.symbols[fn.Sym]]
+		_, header := splitOpcode(fn.Instrs[0].Raw)
+		parts := strings.Split(header, ",")
+		if len(parts) != 3 && !framedRoot {
+			return nil, x86DirectTailContext("private CALL needs explicit zero-frame source flags")
+		}
+		flags := map[string]bool{}
+		var err error
+		if len(parts) == 3 {
+			flags, err = nativeFlags(parts[1], "NOSPLIT", "NOFRAME", "DUPOK")
+		}
+		frame, args, frameErr := parseTEXTFrame(parts)
+		if err != nil || !flags["NOSPLIT"] && !framedRoot || frameErr != nil || frame != fn.FrameSize || args != fn.ArgSize {
+			return nil, x86DirectTailContext("private CALL source prologue/frame is not closed: %s", fn.Sym)
+		}
+		hasCall, hasTail := false, false
+		for pc := span[0]; pc < span[1]; pc++ {
+			ins := view.instructions[pc]
+			hasCall = hasCall || ins.Op == OpCALL
+			hasTail = hasTail || ins.Op == OpJMP && len(ins.Args) == 1 && ins.Args[0].Kind == OpSym
+			if _, stack, _ := x86StackWidthProperties(ins, view.graph.goarch); stack {
+				return nil, x86DirectTailContext("private CALL cannot borrow implicit source stack storage")
+			}
+			if called[text] {
+				if view.externalTails[pc] {
+					return nil, x86DirectTailContext("called helper cannot borrow the root's external tail ABI")
+				}
+				for _, operand := range ins.Args {
+					if operand.Kind == OpFP {
+						return nil, x86DirectTailContext("called helper cannot borrow its caller's FP frame")
+					}
+				}
+			}
+		}
+		// Go saves BP on entry to an AMD64 non-leaf, even with $0 locals.
+		// RET restores it; a plain cross-TEXT JMP does not. An explicit NOFRAME
+		// source avoids that hidden push. Register-only CALL/RET preserves FLAGS.
+		if view.graph.goarch == "amd64" && hasCall && hasTail && !flags["NOFRAME"] {
+			return nil, x86DirectTailContext("non-leaf private tail needs explicit NOFRAME")
+		}
+	}
+
+	type returnContext struct{ parent, entry, resume int }
+	type instance struct{ text, context int }
+	contexts := []returnContext{{parent: -1, entry: view.text, resume: -1}}
+	starts := make(map[instance]int)
+	var instances []instance
+	result := &x86DirectTailRoot{graph: view.graph, text: view.text}
+	add := func(key instance) (int, error) {
+		if start, found := starts[key]; found {
+			return start, nil
+		}
+		span := ranges[key.text]
+		count, start := span[1]-span[0], len(result.points)
+		if count <= 0 || count > limit-start {
+			return 0, x86DirectTailContext("private CALL expansion instruction budget exhausted")
+		}
+		starts[key] = start
+		instances = append(instances, key)
+		result.points = append(result.points, view.points[span[0]:span[1]]...)
+		result.instructions = append(result.instructions, view.instructions[span[0]:span[1]]...)
+		result.ordinals = append(result.ordinals, view.ordinals[span[0]:span[1]]...)
+		result.externalTails = append(result.externalTails, view.externalTails[span[0]:span[1]]...)
+		result.edges = append(result.edges, make([][]int, count)...)
+		return start, nil
+	}
+	if _, err := add(instance{view.text, 0}); err != nil {
+		return nil, err
+	}
+	for at := 0; at < len(instances); at++ {
+		key := instances[at]
+		span, start := ranges[key.text], starts[key]
+		for source := span[0]; source < span[1]; source++ {
+			pc := start + source - span[0]
+			ins := view.instructions[source]
+			if ins.Op == OpRET && key.context != 0 {
+				result.edges[pc] = []int{contexts[key.context].resume}
+				continue
+			}
+			context := key.context
+			if ins.Op == OpCALL {
+				callee := view.points[view.edges[source][0]].text
+				if source+1 >= span[1] || callee == key.text {
+					return nil, x86DirectTailContext("private CALL has no continuation or is recursive")
+				}
+				for parent := context; parent >= 0; parent = contexts[parent].parent {
+					if contexts[parent].entry == callee {
+						return nil, x86DirectTailContext("recursive private CALL source")
+					}
+				}
+				context = len(contexts)
+				contexts = append(contexts, returnContext{key.context, callee, pc + 1})
+			}
+			for _, target := range view.edges[source] {
+				text := view.points[target].text
+				targetStart, err := add(instance{text, context})
+				if err != nil {
+					return nil, err
+				}
+				result.edges[pc] = append(result.edges[pc], targetStart+target-ranges[text][0])
+			}
+		}
+	}
+	return result, nil
+}
+
+func (view *x86DirectTailRoot) privateCallTransition(pc int) bool {
+	return view != nil && pc >= 0 && pc < len(view.instructions) && pc < len(view.edges) &&
+		len(view.edges[pc]) == 1 && (view.instructions[pc].Op == OpCALL || view.instructions[pc].Op == OpRET)
+}
diff --git a/x86_private_call_object_test.go b/x86_private_call_object_test.go
new file mode 100644
index 000000000..84ffd2a8a
--- /dev/null
+++ b/x86_private_call_object_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestX86PrivateCallFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for ordinary helper CALL objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declaration := x86PrivateCallWholeSource(target.arch)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					dir := t.TempDir()
+					input, output := filepath.Join(dir, "calls.ll"), filepath.Join(dir, "calls.o")
+					if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+target.triple,
+							"-filetype=obj", input, "-o", output))
+						if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+							t.Fatal("missing complete original-source helper CALL object", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_private_call_runtime_go127_test.go b/x86_private_call_runtime_go127_test.go
new file mode 100644
index 000000000..d74f10f82
--- /dev/null
+++ b/x86_private_call_runtime_go127_test.go
@@ -0,0 +1,59 @@
+//go:build unix && go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"math/bits"
+	"strings"
+	"testing"
+)
+
+// Reuse the complete original-Go/LLVM three-API O0/O2 owner. The only test
+// adaptation fixes Value's second input to seven; helper bodies are unchanged.
+func TestCrossLinuxRuntimeMatrixX86PrivateCallContinuations(t *testing.T) {
+	cases := x86PrivateCallCases()
+	if len(cases) != 11 {
+		t.Fatal("complete ordinary private-call runtime inventory changed", len(cases))
+	}
+	assembly, declarations := x86PrivateCallWholeSource("amd64")
+	assembly = strings.NewReplacer("$0-24", "$0-16", "MOVQ b+8(FP),BX", "MOVQ $7,BX",
+		"ret+16(FP)", "ret+8(FP)").Replace(assembly)
+	declarations = strings.ReplaceAll(declarations, "(a,b uint64)", "(a uint64)")
+	inputs := []uint64{0, 1, 6, 7, 8, 0xffffffff, 0x100000000, ^uint64(0)}
+	expected := make([][]string, len(inputs))
+	for index, input := range inputs {
+		for _, row := range cases {
+			var result uint64
+			switch row.name {
+			case "two_calls":
+				result = bits.RotateLeft64(input+7, 1) + 3
+			case "incoming_flags", "nested_incoming_flags", "outgoing_flags":
+				if input < 7 {
+					result = 1
+				}
+			case "vector_result":
+				result = uint64(uint32(input)) + 7
+			case "nested_return", "nested_noframe_tail":
+				result = input + 8
+			case "called_leaf_tail":
+				result = input + 7
+			case "two_returns":
+				result = input + 1
+				if input < 7 {
+					result = input - 1
+				}
+			case "two_call_flags":
+				if input >= 7 {
+					result = 1
+				}
+			case "two_call_vectors":
+				result = uint64(uint32(input)) + 7
+			default:
+				t.Fatal("missing independent private-call oracle", row.name)
+			}
+			expected[index] = append(expected[index], fmt.Sprintf("%016x", result))
+		}
+	}
+	fixedLocalResultsRuntime(t, assembly, declarations, inputs, expected)
+}
diff --git a/x86_private_call_source_test.go b/x86_private_call_source_test.go
new file mode 100644
index 000000000..597add095
--- /dev/null
+++ b/x86_private_call_source_test.go
@@ -0,0 +1,266 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// All helpers have register-only source contracts, without Go declarations.
+// Only Value owns arguments, results and the ordinary Go entry/return ABI.
+func x86PrivateCallSource(arch, body, helpers string) (string, string) {
+	source := `TEXT ·Value(SB),4,$0-24
+ MOVQ a+0(FP),AX
+ MOVQ b+8(FP),BX
+ ` + body + `
+ MOVQ AX,ret+16(FP)
+ RET
+` + helpers
+	declaration := "func Value(a,b uint64) uint64"
+	if arch == "386" {
+		source = strings.NewReplacer("$0-24", "$0-12", "b+8(FP)", "b+4(FP)", "ret+16(FP)", "ret+8(FP)",
+			"MOVQ", "MOVL", "ADDQ", "ADDL", "SUBQ", "SUBL", "CMPQ", "CMPL", "ROLQ", "ROLL").Replace(source)
+		declaration = strings.ReplaceAll(declaration, "uint64", "uint32")
+	}
+	return source, declaration
+}
+
+func x86PrivateCallCases() []struct{ name, body, helpers string } {
+	return []struct{ name, body, helpers string }{
+		{"two_calls", "CALL helper<>(SB)\n ROLQ $1,AX\n MOVQ $3,BX\n CALL helper<>(SB)",
+			"TEXT helper<>(SB),4,$0-0\n ADDQ BX,AX\n RET\n"},
+		{"incoming_flags", "CMPQ AX,BX\n CALL helper<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+			"TEXT helper<>(SB),4,$0-0\n MOVQ AX,DX\n MOVL BX,X0\n RET\n"},
+		{"nested_incoming_flags", "CMPQ AX,BX\n CALL outer<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+			"TEXT outer<>(SB),4,$0-0\n CALL inner<>(SB)\n RET\nTEXT inner<>(SB),4,$0-0\n MOVQ AX,DX\n RET\n"},
+		{"outgoing_flags", "CALL helper<>(SB)\n SETCS CL\n MOVBLZX CL,AX",
+			"TEXT helper<>(SB),4,$0-0\n CMPQ AX,BX\n RET\n"},
+		{"vector_result", "CALL helper<>(SB)\n MOVL X0,AX\n PSRLDQ $12,X0\n MOVL X0,CX\n ADDQ CX,AX",
+			"TEXT helper<>(SB),4,$0-0\n MOVL BX,X0\n MOVL AX,X1\n PSLLDQ $12,X1\n POR X1,X0\n RET\n"},
+		{"nested_return", "CALL outer<>(SB)", `TEXT outer<>(SB),4,$0-0
+ CALL inner<>(SB)
+ ADDQ $1,AX
+ RET
+TEXT inner<>(SB),4,$0-0
+ ADDQ BX,AX
+ RET
+`},
+		{"nested_noframe_tail", "CALL outer<>(SB)", `TEXT outer<>(SB),516,$0-0
+ CALL inner<>(SB)
+ JMP last<>(SB)
+TEXT inner<>(SB),4,$0-0
+ ADDQ BX,AX
+ RET
+TEXT last<>(SB),4,$0-0
+ ADDQ $1,AX
+ RET
+`},
+		{"called_leaf_tail", "CALL first<>(SB)", `TEXT first<>(SB),4,$0-0
+ JMP last<>(SB)
+TEXT last<>(SB),4,$0-0
+ ADDQ BX,AX
+ RET
+`},
+		{"two_returns", "CALL helper<>(SB)", `TEXT helper<>(SB),4,$0-0
+ CMPQ AX,BX
+ JB less
+ ADDQ $1,AX
+ RET
+less:
+ SUBQ $1,AX
+ RET
+`},
+		{"two_call_flags", "CMPQ AX,BX\n CALL helper<>(SB)\n MOVQ DX,AX\n CMPQ AX,$1\n CALL helper<>(SB)\n MOVQ DX,AX",
+			"TEXT helper<>(SB),4,$0-0\n SETCS CL\n MOVBLZX CL,DX\n RET\n"},
+		{"two_call_vectors", "MOVL AX,X0\n CALL helper<>(SB)\n MOVL X1,AX\n MOVL BX,X0\n CALL helper<>(SB)\n MOVL X1,BX\n ADDQ BX,AX",
+			"TEXT helper<>(SB),4,$0-0\n MOVOU X0,X1\n RET\n"},
+	}
+}
+
+func x86PrivateCallWholeSource(arch string) (string, string) {
+	var assembly, declarations strings.Builder
+	for index, row := range x86PrivateCallCases() {
+		source, declaration := x86PrivateCallSource(arch, row.body, row.helpers)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.NewReplacer("·Value", "·"+name, "<>", fmt.Sprintf("%d<>", index)).Replace(source))
+		declarations.WriteString(strings.Replace(declaration, "Value", name, 1) + "\n")
+	}
+	return assembly.String(), declarations.String()
+}
+
+func TestX86PrivateCallSourceContinuations(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86PrivateCallCases() {
+			source, declaration := x86PrivateCallSource(arch, row.body, row.helpers)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil {
+						t.Fatal("closed ordinary helper call rejected", err)
+					}
+					if strings.Count(ir, "define ") != 1 || strings.Contains(ir, "call void") || strings.Contains(ir, "call i") {
+						t.Fatal("private source continuation acquired a standalone helper ABI", ir)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PrivateCallKeepsOriginalPointsAndReturnSites(t *testing.T) {
+	row := x86PrivateCallCases()[0]
+	source, declaration := x86PrivateCallSource("amd64", row.body, row.helpers)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := x86DirectTailSnapshot(file)
+	resolve := testResolveSym("example.com/privatecalls")
+	sigs, err := goSigsForAsmFile(mustGoPackage(t, "example.com/privatecalls", "package p\n"+declaration), file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sigs) != 1 {
+		t.Fatal("fixture invented helper signatures", sigs)
+	}
+	prepared, err := PrepareX86DirectTailSource(file, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	view := prepared.x86DirectTailView("·Value")
+	if view == nil {
+		t.Fatal("complete call graph was not prepared")
+	}
+	if _, err := view.graph.root(0, map[string]int{"·Value": 0, "helper<>": 1}, 4096, false); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("ordinary CALL support widened the separate custom-register helper route", err)
+	}
+	returns := make(map[int]bool)
+	for pc, point := range view.points {
+		original := file.Funcs[point.text].Instrs[point.instruction]
+		if !reflect.DeepEqual(view.instructions[pc], original) || view.ordinals[pc] != point.instruction {
+			t.Fatal("continuation rewrote original source coordinates", pc, point)
+		}
+		if point.text != view.text && original.Op == OpRET {
+			if len(view.edges[pc]) != 1 {
+				t.Fatal("called helper RET has no unique original callsite continuation", pc, view.edges[pc])
+			}
+			next := view.edges[pc][0]
+			if next < 0 || next >= len(view.points) || view.points[next].text != view.text {
+				t.Fatal("helper RET escaped its real caller", next)
+			}
+			returns[next] = true
+		}
+	}
+	if len(returns) != 2 || !reflect.DeepEqual(file, before) || len(sigs) != 1 {
+		t.Fatal("two callsites merged their returns or mutated source/signatures", returns)
+	}
+	seen := make(map[string]bool)
+	for _, block := range view.blocks() {
+		if seen[block.name] {
+			t.Fatal("duplicated source point reused another callsite's LLVM block", block.name)
+		}
+		seen[block.name] = true
+	}
+	file.Funcs[1].Instrs[1].Raw += " // changed after complete call graph preparation"
+	if _, err := PrepareX86DirectTailSource(prepared, Options{
+		Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs,
+	}); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed original helper retained both prepared callsite copies", err)
+	}
+}
+
+func TestX86PrivateCallAuditsBeforeKeepFunc(t *testing.T) {
+	row := x86PrivateCallCases()[0]
+	complete, declaration := x86PrivateCallSource("amd64", row.body, row.helpers)
+	other, _ := x86PrivateCallSource("amd64", "MOVQ DX,BX\n CALL helper<>(SB)", "")
+	for _, invalid := range []bool{false, true} {
+		t.Run(fmt.Sprint(invalid), func(t *testing.T) {
+			source := complete
+			declarations := declaration
+			if invalid {
+				source += strings.Replace(other, "·Value", "·Other", 1)
+				declarations += "\nfunc Other(a,b uint64) uint64"
+			}
+			pkg := mustGoPackage(t, "example.com/privatecalls", "package p\n"+declarations)
+			translated, err := TranslateGoModule(pkg, []byte(source), GoModuleOptions{
+				GOARCH: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path),
+				KeepFunc: func(source, _ string) bool { return source == "·Value" },
+			})
+			if translated != nil {
+				defer translated.Module.Dispose()
+			}
+			if invalid {
+				if translated != nil || err == nil {
+					t.Fatal("KeepFunc hid a callsite's undefined helper input", err)
+				}
+			} else if err != nil || translated == nil || len(translated.Functions) != 1 {
+				t.Fatal("complete private call source did not retain its sole declared root", err)
+			}
+		})
+	}
+}
+
+func TestX86PrivateCallRejectsUnclosedSource(t *testing.T) {
+	const helper = "TEXT helper<>(SB),4,$0-0\n ADDQ BX,AX\n RET\n"
+	for _, row := range []struct{ name, body, helpers string }{
+		{"missing_input", "CALL helper<>(SB)", strings.Replace(helper, "BX,AX", "DX,AX", 1)},
+		{"second_call_missing_flags", "CMPQ AX,BX\n CALL helper<>(SB)\n MULQ BX\n CALL helper<>(SB)",
+			"TEXT helper<>(SB),4,$0-0\n SETEQ CL\n MOVBLZX CL,AX\n RET\n"},
+		{"no_root_result", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n MOVQ DX,AX\n RET\n"},
+		{"helper_FP", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n MOVQ a+0(FP),AX\n RET\n"},
+		{"helper_result_FP", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n MOVQ AX,ret+16(FP)\n RET\n"},
+		{"helper_SP", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n MOVQ 0(SP),AX\n RET\n"},
+		{"helper_BP", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n MOVQ BP,AX\n RET\n"},
+		{"helper_implicit_stack", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n PUSHQ AX\n POPQ DX\n RET\n"},
+		{"helper_unbalanced_stack", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n PUSHQ AX\n RET\n"},
+		{"helper_raw", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n BYTE $0x90\n RET\n"},
+		{"helper_frame", "CALL helper<>(SB)", strings.Replace(helper, "$0-0", "$8-0", 1)},
+		{"helper_args", "CALL helper<>(SB)", strings.Replace(helper, "$0-0", "$0-8", 1)},
+		{"helper_split", "CALL helper<>(SB)", strings.Replace(helper, ",4,", ",0,", 1)},
+		{"helper_wrapper", "CALL helper<>(SB)", strings.Replace(helper, ",4,", ",36,", 1)},
+		{"recursive", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n CALL helper<>(SB)\n RET\n"},
+		{"mutual_recursive", "CALL helper<>(SB)", "TEXT helper<>(SB),516,$0-0\n CALL other<>(SB)\n RET\nTEXT other<>(SB),516,$0-0\n CALL helper<>(SB)\n RET\n"},
+		{"tail_recursive", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n CALL next<>(SB)\n RET\nTEXT next<>(SB),4,$0-0\n JMP last<>(SB)\nTEXT last<>(SB),4,$0-0\n CALL next<>(SB)\n RET\n"},
+		{"indirect", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n CALL AX\n RET\n"},
+		{"foreign_call", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n CALL foreign(SB)\n RET\n"},
+		{"address_escape", "LEAQ helper<>(SB),CX\n CALL helper<>(SB)", helper},
+		{"offset_call", "CALL helper<>+1(SB)", helper},
+		{"foreign_tail", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n JMP foreign(SB)\n"},
+		{"implicit_BP_tail", "CALL helper<>(SB)", "TEXT helper<>(SB),4,$0-0\n CALL other<>(SB)\n JMP last<>(SB)\nTEXT other<>(SB),4,$0-0\n ADDQ BX,AX\n RET\nTEXT last<>(SB),4,$0-0\n RET\n"},
+		{"root_implicit_BP_tail", "CALL helper<>(SB)\n JMP last<>(SB)", helper + "TEXT last<>(SB),4,$0-0\n MOVQ AX,ret+16(FP)\n RET\n"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				source, declaration := x86PrivateCallSource("amd64", row.body, row.helpers)
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err == nil || ir != "" {
+					t.Fatal("unclosed helper source acquired caller state or entry authority", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivateCallExpansionBudget(t *testing.T) {
+	var helpers strings.Builder
+	for level := 0; level < 13; level++ {
+		fmt.Fprintf(&helpers, "TEXT helper%d<>(SB),516,$0-0\n", level)
+		if level < 12 {
+			fmt.Fprintf(&helpers, "CALL helper%d<>(SB)\nCALL helper%d<>(SB)\n", level+1, level+1)
+		}
+		helpers.WriteString("RET\n")
+	}
+	source, declaration := x86PrivateCallSource("amd64", "CALL helper0<>(SB)", helpers.String())
+	if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", "text"); err == nil || ir != "" || !strings.Contains(err.Error(), "budget") {
+		t.Fatal("compact acyclic source bypassed the existing expanded instruction budget", err)
+	}
+}
diff --git a/x86_private_pointer_stack_budget_test.go b/x86_private_pointer_stack_budget_test.go
new file mode 100644
index 000000000..bac11a8ee
--- /dev/null
+++ b/x86_private_pointer_stack_budget_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86PrivatePointerStackMetadataHasOneCompleteWorkBudget(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			stack, word, limit, endpointBytes, widthBytes := "Q", 8, 504, 64, 8
+			if arch == "386" {
+				stack, word, limit, endpointBytes, widthBytes = "L", 4, 252, 32, 0
+			}
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\nPUSH"+stack+" BX\nPOP"+stack+" AX\nNOP\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := file.Funcs[0]
+			budget := new(x86ResultFlowBudget)
+			fn.x86ResultFlowBudget = budget
+			initial := x86ResultState{valueStack: new(x86ResultValueStack)}
+			initial.pointerGP[3] = true
+			transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+				return x86ResultTransfer(ins, state, owned, offset, arch)
+			}
+			returned := false
+			err = checkX86ResultSourceFlow(fn, initial, nil, 0, arch, transfer, func(state x86ResultState, _ int) error {
+				returned = true
+				if !state.pointerGP[0] || state.gp[0]&uint8((1<<uint(word))-1) != 0 {
+					return fmt.Errorf("whole pointer cell lost its independent opaque role")
+				}
+				return nil
+			})
+			// Four source instructions and four actual must-defined visits.
+			// This is independent logical domain accounting, not sizeof: the
+			// endpoint bitmap spans 504/252 byte positions in 8/4 words, and
+			// only AMD64 additionally has a W/Q virtual-cell identity bitmap.
+			payload := x86IndependentResultBasePayload + limit + 14 + endpointBytes + widthBytes
+			if err != nil || !returned || budget.visits != 4 || budget.bytes != 36*payload {
+				t.Fatal("private endpoint/width metadata escaped the shared source/visit byte budget", budget, payload, err)
+			}
+		})
+	}
+}
+
+func TestX86PrivatePointerStackMutationRevokesEveryOverlappingSpan(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			word := int(x86ResultPointerWord(arch))
+			for changed := 0; changed < 3*word; changed++ {
+				stack := &x86ResultValueStack{bytes: make([]uint8, 3*word)}
+				stack.markPointerCell(word)
+				stack.markPointerCell(3 * word)
+				stack.revokePointerCells(changed, changed+1, word)
+				if stack.pointerCell(word) != (changed >= word) || stack.pointerCell(3*word) != (changed < 2*word) {
+					t.Fatal("byte write revoked the wrong complete pointer span", changed, stack.pointerCells)
+				}
+			}
+			for _, end := range []int{1, 3*word + 1, 512} {
+				stack := &x86ResultValueStack{bytes: make([]uint8, 3*word)}
+				stack.markPointerCell(end)
+				if stack.pointerCellsBounded(arch) {
+					t.Fatal("an absent, partial or beyond-depth source word acquired an endpoint", end)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_private_pointer_stack_objects_runtime_test.go b/x86_private_pointer_stack_objects_runtime_test.go
new file mode 100644
index 000000000..a8bd22ea2
--- /dev/null
+++ b/x86_private_pointer_stack_objects_runtime_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestX86PrivatePointerStackOriginalGThreeTargetObjects(t *testing.T) {
+	source, _ := x86PrivatePointerStackOriginalGFixture(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func galias(input *byte) uint64", "amd64", triple, api)
+					if ir == "" || err != nil {
+						t.Fatal("unchanged initialized g program lost its private pointer cell", err)
+					}
+					for _, pipeline := range []struct{ name, text, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							x86CompactExpandRequireAllDefinitions(t, pipeline.text, []string{"galias"})
+							x86PackedStringCompileObject(t, llc, triple, pipeline.text, pipeline.level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+// The original ASM has an explicit incoming pointer and its original C only
+// observes integer memory. Actual-host LLVM execution is a portable numerical
+// companion, not original-Go execution or an assertion about native runtime g.
+func TestX86PrivatePointerStackOriginalGPortableLLVMCompanion(t *testing.T) {
+	source, mainC := x86PrivatePointerStackOriginalGFixture(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func galias(input *byte) uint64", "amd64", triple, api)
+			if ir == "" || err != nil {
+				t.Fatal("unchanged original explicit-pointer g program rejected", err)
+			}
+			for _, pipeline := range []struct {
+				name, text string
+				level      int
+			}{
+				{"backend_O0", ir, 0}, {"backend_O2", ir, 2},
+				{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), 2},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "private-pointer-g",
+						triple, pipeline.text, mainC, nil, pipeline.level)
+				})
+			}
+		})
+	}
+	t.Log("unchanged original logical ASM/C executed on actual host; not original Go/native-g ABI qualification")
+}
diff --git a/x86_private_pointer_stack_test.go b/x86_private_pointer_stack_test.go
new file mode 100644
index 000000000..b3e4e51ab
--- /dev/null
+++ b/x86_private_pointer_stack_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86PrivatePointerStackOriginalGFixture(t *testing.T) (string, string) {
+	t.Helper()
+	data, err := os.ReadFile("parser_g_register_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "parser_g_register_test.go", data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestAMD64GRegisterRuntime" {
+			continue
+		}
+		start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+		const original = "f7a56465f74e14d6143079a0cf92ff4d373fa904b8f1812e7da8430bcc82b447"
+		if fmt.Sprintf("%x", sha256.Sum256(data[start:end])) != original {
+			t.Fatal("original g input, PUSH/POP, C reference or runtime observation changed")
+		}
+		constants := make(map[string]string)
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+				return true
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return true
+			}
+			text, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			constants[value.Names[0].Name] = text
+			return true
+		})
+		if constants["source"] == "" || constants["mainC"] == "" {
+			t.Fatal("original complete ASM/C fixture disappeared")
+		}
+		return constants["source"], constants["mainC"]
+	}
+	t.Fatal("original g runtime owner disappeared")
+	return "", ""
+}
+
+func x86PrivatePointerStackRegisters(arch string) []string {
+	registers := strings.Fields("AX CX DX BX SI DI")
+	if arch == "386" {
+		return append(registers, "BP") // Ordinary GP in mode32, never AMD64 frame BP.
+	}
+	return append(registers, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15 g")...)
+}
+
+func x86PrivatePointerStackProgram(arch, name, source, destination, body string) (string, string) {
+	move, stack, word, result := "MOVQ", "Q", 8, "uint64"
+	if arch == "386" {
+		move, stack, word, result = "MOVL", "L", 4, "uint32"
+	}
+	if body == "" {
+		body = fmt.Sprintf("PUSH%s %s\n%s $0,%s\nPOP%s %s\n", stack, source, move, source, stack, destination)
+	}
+	assembly := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),%s\n%s%s %d(%s),AX\n%s AX,ret+%d(FP)\nRET\n",
+		name, 2*word, move, source, body, move, word, destination, move, word)
+	return assembly, fmt.Sprintf("func %s(p *byte) %s\n", name, result)
+}
+
+func TestX86PrivatePointerStackOriginalGSourceThreeAPIs(t *testing.T) {
+	source, _ := x86PrivatePointerStackOriginalGFixture(t)
+	control := strings.Replace(source, "\tPUSHQ g\n\tMOVQ $0, g\n\tPOPQ g\n", "", 1)
+	if control == source {
+		t.Fatal("independent direct-pointer positive control did not change the original roundtrip")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, control, "func galias(input *byte) uint64", "amd64", triple, api); ir == "" || err != nil {
+					t.Fatal("explicit Ptr-to-g direct-source control failed before private transport", err)
+				}
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func galias(input *byte) uint64", "amd64", triple, api); ir == "" || err != nil {
+					t.Fatal("private full-word roundtrip lost an already established opaque incoming pointer", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivatePointerStackCompleteGPSourceAndDestinationRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		registers := x86PrivatePointerStackRegisters(arch)
+		for index, source := range registers {
+			// All source and result banks, same and distinct destinations. The
+			// ordered-role axis does not require another GP Cartesian product.
+			for _, destination := range []string{source, registers[(index+1)%len(registers)]} {
+				assembly, declaration := x86PrivatePointerStackProgram(arch, "Value", source, destination, "")
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+source+"-"+destination+"/"+api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, assembly, declaration, arch, triple, api); ir == "" || err != nil {
+							t.Fatal("whole native-word opaque transport depends on a particular GP alias", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PrivatePointerStackClosedCellsKeepCloneAndJoinRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			stack, word := "Q", int64(8)
+			if arch == "386" {
+				stack, word = "L", 4
+			}
+			bx, _, _ := x86ResultGP("BX", word, arch)
+			ax, mask, _ := x86ResultGP("AX", word, arch)
+			push, pop := x86ScalarLaneInstruction(t, "PUSH"+stack+" BX"), x86ScalarLaneInstruction(t, "POP"+stack+" AX")
+			makeSaved := func(pointer bool) x86ResultState {
+				state := x86ResultState{valueStack: new(x86ResultValueStack)}
+				state.pointerGP[bx] = pointer
+				state.callerAddressGP[bx] = true // Deliberately separate: the new tag must not transport it.
+				if !pointer {
+					state.gp[bx] = 0xff
+				}
+				if accepted, known := x86ResultValueStackStep(push, &state, nil, 0, arch); !known || !accepted {
+					t.Fatal("ordinary full-word private PUSH control failed")
+				}
+				return state
+			}
+			for _, paired := range []bool{false, true} {
+				left, right := makeSaved(true), makeSaved(paired)
+				joined := left.intersect(right)
+				if accepted, known := x86ResultValueStackStep(pop, &joined, nil, 0, arch); !known || !accepted || joined.pointerGP[ax] != paired {
+					t.Fatal("private cell join invented or discarded a must-pointer role", paired)
+				}
+				if joined.callerAddressGP[ax] || paired && joined.gp[ax]&mask != 0 {
+					t.Fatal("restoring opaque address bits invented numerical pointer bytes")
+				}
+				clone := left.clone()
+				if accepted, known := x86ResultValueStackStep(pop, &clone, nil, 0, arch); !known || !accepted || !clone.pointerGP[ax] || len(left.valueStack.bytes) != int(word) {
+					t.Fatal("mutable private POP corrupted the original saved cell or lost its role")
+				}
+			}
+		})
+	}
+}
+
+func TestX86PrivatePointerStackCannotInventAddressOrEntryAuthority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple, stack, move, word := "x86_64-unknown-linux-gnu", "Q", "MOVQ", 8
+		if arch == "386" {
+			triple, stack, move, word = "i386-unknown-linux-gnu", "L", "MOVL", 4
+		}
+		for _, row := range []struct{ name, body string }{
+			{"unknown", "PUSH" + stack + " CX\nPOP" + stack + " BX\n"},
+			{"numeric", move + " $1,CX\nPUSH" + stack + " CX\nPOP" + stack + " BX\n"},
+			{"partial-pointer", "PUSHW BX\n" + move + " $0,BX\nPOPW BX\n"},
+			{"flags-not-pointer", "PUSHF" + stack + "\nPOP" + stack + " BX\n"},
+			{"pointer-as-numeric", "PUSH" + stack + " BX\nPOP" + stack + " AX\n" + move + " AX,ret+" + strconv.Itoa(word) + "(FP)\nRET\n"},
+			{"physical-SP", "PUSH" + stack + " BX\nPOP" + stack + " SP\n"},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				assembly, declaration := x86PrivatePointerStackProgram(arch, "Value", "BX", "BX", row.body)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly, declaration, arch, triple, api)
+					if row.name == "numeric" {
+						if err != nil || strings.Count(ir, fmt.Sprintf("load volatile i%d,", word*8)) != 1 {
+							t.Fatal("whole private NUM cell lost its exact paired read", api, err)
+						}
+						x86RequireNumericNativeSourceContext(t, assembly, declaration, arch)
+						x86NumericNativeAddressObject(t, ir, triple)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("private cells created a missing pointer, numerical result or physical stack contract", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PrivatePointerStackNestedMixedAndMutatedCells(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple, stack, move := "x86_64-unknown-linux-gnu", "Q", "MOVQ"
+		if arch == "386" {
+			triple, stack, move = "i386-unknown-linux-gnu", "L", "MOVL"
+		}
+		push, pop := "PUSH"+stack+" ", "POP"+stack+" "
+		rows := []struct {
+			name, body string
+			accept     bool
+		}{
+			{"nested-whole", push + "BX\n" + push + "$7\n" + pop + "DX\n" + pop + "AX\n", true},
+			{"nested-narrow", push + "BX\nPUSHW $9\nPOPW DX\n" + pop + "AX\n", true},
+			{"partial-cell-recombined", push + "BX\nPOPW DX\nPUSHW $9\n" + pop + "AX\n", false},
+			{"flags-roundtrip-is-not-pointer", push + "BX\nPOPF" + stack + "\nPUSHF" + stack + "\n" + pop + "AX\n", false},
+		}
+		branch := move + " $0,CX\nTESTL CX,CX\nJE alternate\n" + push + "BX\nJMP joined\nalternate:\n"
+		rows = append(rows,
+			struct {
+				name, body string
+				accept     bool
+			}{"both-paths-pointer", branch + push + "BX\njoined:\n" + pop + "AX\n", true},
+			struct {
+				name, body string
+				accept     bool
+			}{"one-path-numeric", branch + push + "$1\njoined:\n" + pop + "AX\n", false})
+		if arch == "386" {
+			rows = append(rows, struct {
+				name, body string
+				accept     bool
+			}{"private-byte-mutated", push + "BX\nXORL $1,(SP)\n" + pop + "AX\n", false})
+		}
+		for _, row := range rows {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					assembly, declaration := x86PrivatePointerStackProgram(arch, "Value", "BX", "AX", row.body)
+					ir, err := x86ScalarFPBitViewAPI(t, assembly, declaration, arch, triple, api)
+					if row.accept {
+						if ir == "" || err != nil {
+							t.Fatal("complete source-owned private pointer cell was lost", err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("partial, mutated or one-path cell invented a complete opaque pointer", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_probe_context_test.go b/x86_probe_context_test.go
new file mode 100644
index 000000000..67ec5d3fe
--- /dev/null
+++ b/x86_probe_context_test.go
@@ -0,0 +1,24 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestProbe386LegacyImmediateJumpRequiresLayoutContext(t *testing.T) {
+	const source = "TEXT legacyJump(SB),$0-0\n\tJMP $4\n"
+	requireX86GoAssemblerResult(t, "386", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	instruction := file.Funcs[0].Instrs[1]
+	err = ProbeInstruction(ArchAMD64, "386", instruction)
+	if !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatalf("ProbeInstruction(JMP $4) error = %v, want ErrProbeNeedsContext", err)
+	}
+	if !strings.Contains(err.Error(), "JMP $4") || !strings.Contains(err.Error(), "layout") {
+		t.Fatalf("context error does not explain the legacy relocation: %v", err)
+	}
+}
diff --git a/x86_probe_vector_scratch_test.go b/x86_probe_vector_scratch_test.go
new file mode 100644
index 000000000..1e5a0bdef
--- /dev/null
+++ b/x86_probe_vector_scratch_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestX86ProbeDoesNotBorrowDeclaredVectorScratch(t *testing.T) {
+	for _, body := range []string{
+		"VADDSUBPD X2,X9,X2", "VADDSUBPD Y2,Y15,Y2",
+		"VCVTTPS2DQ X2,X2", "SQRTSS X2,X2",
+		"VPMOVB2M Z6,K1", "VROUNDSS $7,X2,X9,X2",
+	} {
+		t.Run("unknown/"+body, func(t *testing.T) {
+			source := "TEXT probe(SB),4,$0-0\n" + body + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 {
+				t.Fatal("the independent official source fixture must parse completely", err)
+			}
+			fn := file.Funcs[0]
+			sig := FuncSig{Name: fn.Sym, Ret: Void}
+			if !x86TypedFPResultNeedsProof(fn, sig, "amd64") {
+				t.Fatal("the fixture must exercise an existing mandatory numerical-input route")
+			}
+			if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("the strict source audit must keep the original entry unknown", err)
+			}
+			instruction := fn.Instrs[1]
+			for _, api := range []string{"instruction", "sequence"} {
+				t.Run(api, func(t *testing.T) {
+					var err error
+					if api == "instruction" {
+						err = ProbeInstruction(ArchAMD64, "amd64", instruction)
+					} else {
+						err = ProbeInstructionSequence(ArchAMD64, "amd64", []Instr{instruction})
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("a synthetic probe borrowed ordinary codegen's scratch realization", err)
+					}
+				})
+			}
+		})
+	}
+	// Preserve old grammar-only positives as well as genuinely source-defined
+	// sequences. Probe success remains IR-generation evidence, not execution.
+	for _, body := range []string{"MOVL $7,AX", "PXOR X0,X0", "PUNPCKLQDQ X0,X0", "UNDEF",
+		"SHLL $4,BX", "VPCMPEQB X2,X9,X2",
+		"PXOR X0,X0\nVADDSUBPD X0,X0,X1"} {
+		t.Run("existing-positive/"+body, func(t *testing.T) {
+			source := "TEXT probe(SB),4,$0-0\n" + body + "\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			instructions := file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1]
+			if err := ProbeInstructionSequence(ArchAMD64, "amd64", instructions); err != nil {
+				t.Fatal("an existing or initialized probe lost its original classification", err)
+			}
+		})
+	}
+	for _, body := range []string{"VADDSUBPD X0,X1", "VADDSUBPD.Z X0,X1,X2", "NOT_AN_X86_OPCODE"} {
+		t.Run("grammar-error/"+body, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+body+"\nRET\n")
+			if err != nil {
+				t.Fatal("this control must reach the actual lowering grammar", err)
+			}
+			err = ProbeInstructionSequence(ArchAMD64, "amd64", file.Funcs[0].Instrs[1:2])
+			if err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("an original grammar error was hidden behind source context", err)
+			}
+		})
+	}
+}
diff --git a/x86_qword_lookup_input_test.go b/x86_qword_lookup_input_test.go
new file mode 100644
index 000000000..69240e7f2
--- /dev/null
+++ b/x86_qword_lookup_input_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86QwordLookupCompleteInputObjects(t *testing.T, bank string, raw bool) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, name := range []string{"VPMULTISHIFTQB", "VPSHUFBITQMB"} {
+				modes := []string{"plain"}
+				if target.arch == "amd64" || raw {
+					modes = append(modes, "merge")
+					if name == "VPMULTISHIFTQB" {
+						modes = append(modes, "zero")
+					}
+				}
+				for _, mode := range modes {
+					inputs := []string{bank + "0", "(SI)"}
+					if name == "VPMULTISHIFTQB" {
+						inputs = append(inputs, "broadcast")
+					}
+					for _, input := range inputs {
+						op, mask, operand := name, "", input
+						if input == "broadcast" {
+							op, operand = op+".BCST", "(SI)"
+						}
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							op += ".Z"
+						}
+						destination, store := bank+"2", "VMOVUPS Z2,(DI)\n"
+						if name == "VPSHUFBITQMB" {
+							destination, store = "K3", "KMOVQ K3,(DI)\n"
+						}
+						instruction := op + " " + operand + "," + bank + "1," + mask + destination
+						if raw {
+							encoderArch := target.arch
+							if mode != "plain" {
+								encoderArch = "amd64" // Low-register physical row, not named mode32 syntax.
+							}
+							instruction = x86RawNumericalInstruction(t, encoderArch, instruction)
+						}
+						function := fmt.Sprint("Lookup", count)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n"+
+							"MOV%s a+%d(FP),SI\nMOV%s b+%d(FP),BX\nMOV%s old+%d(FP),CX\n"+
+							"VMOVUPS (SI),Z0\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z2\n"+
+							"MOVL $-1431655766,AX\nKMOVD AX,K1\nPUSH%s $0\nPOPF%s\n%s\n"+
+							"%sPUSHF%s\nPOP%s AX\nMOV%s AX,64(DI)\nRET\n",
+							function, 4*word, suffix, suffix, word, suffix, 2*word, suffix, 3*word,
+							suffix, suffix, instruction, store, suffix, suffix, suffix)
+						fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b,old *[64]byte)\n", function)
+						count++
+					}
+				}
+			}
+			want := 13
+			if target.arch == "386" && !raw {
+				want = 5
+			}
+			if count != want {
+				t.Fatal("complete named qword lookup source/mask inventory changed", count, want)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86QwordLookupCompleteXInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "X", false)
+}
+func TestX86QwordLookupCompleteYInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "Y", false)
+}
+func TestX86QwordLookupCompleteZInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "Z", false)
+}
+
+func TestX86QwordLookupCompleteRawXInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "X", true)
+}
+func TestX86QwordLookupCompleteRawYInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "Y", true)
+}
+func TestX86QwordLookupCompleteRawZInputObjects(t *testing.T) {
+	x86QwordLookupCompleteInputObjects(t, "Z", true)
+}
+
+func TestX86QwordLookupPhysicalMode32Masks(t *testing.T) {
+	count := 0
+	for _, name := range []string{"VPMULTISHIFTQB", "VPSHUFBITQMB"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for mask := 1; mask <= 7; mask++ {
+				destination := bank + "2"
+				if name == "VPSHUFBITQMB" {
+					destination = "K3"
+				}
+				row := fmt.Sprintf("%s %s0,%s1,K%d,%s", name, bank, bank, mask, destination)
+				bytes := x86RawNumericalInstruction(t, "amd64", row)
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+bytes+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, "386")
+				if err != nil {
+					t.Fatal("physical mode32 lookup inherited missing decoding or a named operand cap", row, err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, known, err := x86QwordLookupProperties(ins.Op, ins, "386")
+				if !known || err != nil || form.mask != 2 || ins.Args[form.mask].Reg != Reg(fmt.Sprint("K", mask)) {
+					t.Fatal("physical lookup mask/width identity changed", row, form, err)
+				}
+				count++
+			}
+		}
+	}
+	if count != 42 {
+		t.Fatal("complete physical lookup mask/width inventory changed", count)
+	}
+}
+
+func TestX86QwordLookupDeadNativeInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, instruction := range []string{"VPMULTISHIFTQB (SI),X1,X2", "VPSHUFBITQMB (SI),X1,K3"} {
+			for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					source := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead qword lookup silently discarded its actual source inputs", target, instruction, api, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_qword_lookup_memory_test.go b/x86_qword_lookup_memory_test.go
new file mode 100644
index 000000000..e3171c6f4
--- /dev/null
+++ b/x86_qword_lookup_memory_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86QwordLookupZeroMasksRetainDistinctNativeReadShapes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix := goWordSize(target.arch), "Q"
+		if word == 4 {
+			suffix = "L"
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			width := amd64VectorByteWidth(Reg(bank + "0"))
+			for _, row := range []struct {
+				instruction string
+				bytes       int
+				suppressed  bool
+			}{
+				{instruction: "VPMULTISHIFTQB (AX)," + bank + "1," + bank + "2", bytes: width},
+				{instruction: "VPMULTISHIFTQB.BCST (AX)," + bank + "1," + bank + "2", bytes: 8},
+			} {
+				// Named mode32 cannot express four operands. Its complete
+				// unmasked full/broadcast reads still execute on both targets.
+				checkQwordLookupReadShape(t, target.arch, target.triple, word, suffix, row.instruction, row.bytes, row.suppressed)
+			}
+			if target.arch == "amd64" {
+				for _, row := range []struct {
+					instruction string
+					bytes       int
+					suppressed  bool
+				}{
+					{instruction: "VPMULTISHIFTQB.Z (AX)," + bank + "1,K1," + bank + "2", bytes: width},
+					{instruction: "VPMULTISHIFTQB.BCST.Z (AX)," + bank + "1,K1," + bank + "2", bytes: 8},
+					{instruction: "VPSHUFBITQMB (AX)," + bank + "1,K1,K3", suppressed: true},
+				} {
+					checkQwordLookupReadShape(t, target.arch, target.triple, word, suffix, row.instruction, row.bytes, row.suppressed)
+				}
+			}
+		}
+	}
+}
+
+func checkQwordLookupReadShape(t *testing.T, arch, triple string, word int, suffix, instruction string, width int, suppressed bool) {
+	t.Helper()
+	for _, api := range []string{"text", "module", "Go"} {
+		source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOV%s p+0(FP),AX\n"+
+			"MOVL $0,BX\nKMOVD BX,K1\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nRET\n", word, suffix, instruction)
+		ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", arch, triple, api)
+		if err != nil {
+			t.Fatal("complete dead-read source rejected", arch, instruction, api, err)
+		}
+		optimized := x86DwordProductIROptimize(t, ir)
+		if suppressed {
+			if !strings.Contains(ir, "load volatile i8") || strings.Contains(optimized, "load volatile") {
+				t.Fatal("zero K mask failed to suppress only the bit-control byte reads", instruction, api)
+			}
+		} else {
+			load := fmt.Sprintf("load volatile <%d x i8>", width)
+			if strings.Count(ir, load) != 1 || strings.Count(optimized, load) != 1 {
+				t.Fatal("dead or zero-masked multishift lost its complete native tuple", instruction, api, width)
+			}
+		}
+	}
+}
diff --git a/x86_qword_permute_complete_test.go b/x86_qword_permute_complete_test.go
new file mode 100644
index 000000000..e4c9ddf28
--- /dev/null
+++ b/x86_qword_permute_complete_test.go
@@ -0,0 +1,262 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent inventory: Go's complete _yvpermq, not the translator's table.
+// Intel SDM Vol.2C 5-522..525 and 5-529..532 specify five encodings per
+// member, no X form or FP exception, and E4NF for every EVEX memory form.
+func TestX86QwordPermuteCompleteOfficialRowsAndAttributes(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := []string{
+		"Yu8,Yym,Yyr", "Yi8,Yym,Yyr", "Yu8,YymEvex,YyrEvex",
+		"Yu8,YymEvex,Yknot0,YyrEvex", "Yu8,Yzm,Yzr", "Yu8,Yzm,Yknot0,Yzr",
+		"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex",
+		"Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr",
+	}
+	zcases := []string{"Zvex_i_rm_r", "Zvex_i_rm_r", "Zevex_i_rm_r", "Zevex_i_rm_k_r",
+		"Zevex_i_rm_r", "Zevex_i_rm_k_r", "Zevex_rm_v_r", "Zevex_rm_v_k_r", "Zevex_rm_v_r", "Zevex_rm_v_k_r"}
+	offsets := []int{0, 0, 2, 2, 5, 5, 8, 8, 11, 11}
+	advances := []int{0, 2, 0, 3, 0, 3, 0, 3, 0, 3}
+	for _, member := range []struct{ name, immediate, variable string }{
+		{"VPERMQ", "0x00", "0x36"}, {"VPERMPD", "0x01", "0x16"},
+	} {
+		want := []string{
+			"avxEscape | vex256 | vex66 | vex0F3A | vexW1", member.immediate,
+			"avxEscape | evex256 | evex66 | evex0F3A | evexW1", "evexN32 | evexBcstN8 | evexZeroingEnabled", member.immediate,
+			"avxEscape | evex512 | evex66 | evex0F3A | evexW1", "evexN64 | evexBcstN8 | evexZeroingEnabled", member.immediate,
+			"avxEscape | evex256 | evex66 | evex0F38 | evexW1", "evexN32 | evexBcstN8 | evexZeroingEnabled", member.variable,
+			"avxEscape | evex512 | evex66 | evex0F38 | evexW1", "evexN64 | evexBcstN8 | evexZeroingEnabled", member.variable,
+		}
+		count := 0
+		for _, rule := range rules {
+			if rule.Opcode != member.name {
+				continue
+			}
+			if count >= len(classes) || rule.RowIndex != count || rule.Ytab != "_yvpermq" || rule.Prefix != "Pavx" ||
+				strings.Join(rule.Classes, ",") != classes[count] || rule.ZCase != zcases[count] ||
+				rule.EncodingOffset != offsets[count] || rule.ZOffset != advances[count] || !reflect.DeepEqual(rule.OpBytes, want) {
+				t.Fatal("complete official qword-permute row/attribute changed", member.name, rule)
+			}
+			count++
+		}
+		if count != 10 {
+			t.Fatal("official qword-permute denominator changed", member.name, count)
+		}
+	}
+}
+
+type x86QwordPermuteOracleRow struct {
+	op, bank, mode, input string
+	immediate             bool
+}
+
+func x86QwordPermuteOracleRows(arch string) []x86QwordPermuteOracleRow {
+	var rows []x86QwordPermuteOracleRow
+	for _, op := range []string{"VPERMQ", "VPERMPD"} {
+		for _, bank := range []string{"Y", "Z"} {
+			for _, immediate := range []bool{true, false} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if arch == "386" && mode != "plain" {
+						continue // Go's named frontend rejects four operands; physical EVEX is separate.
+					}
+					for _, input := range []string{"register", "memory", "broadcast"} {
+						rows = append(rows, x86QwordPermuteOracleRow{op, bank, mode, input, immediate})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86QwordPermuteOracleRow) width() int {
+	if row.bank == "Z" {
+		return 64
+	}
+	return 32
+}
+
+func (row x86QwordPermuteOracleRow) instruction() string {
+	input, suffix, mask := row.bank+"0", "", ""
+	if row.input != "register" {
+		input = "(BX)"
+	}
+	if row.input == "broadcast" {
+		suffix = ".BCST"
+	}
+	if row.mode != "plain" {
+		mask = ",K1"
+	}
+	if row.mode == "zero" {
+		suffix += ".Z"
+	}
+	operands := input + "," + row.bank + "1"
+	if row.immediate {
+		operands = "$216," + input
+	}
+	return row.op + suffix + " " + operands + mask + "," + row.bank + "2"
+}
+
+func TestX86QwordPermuteCompleteTypedByteEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86QwordPermuteOracleRows(arch)
+		var source strings.Builder
+		source.WriteString("TEXT effectrows(SB),4,$0-0\n")
+		for _, row := range rows {
+			fmt.Fprintln(&source, row.instruction())
+		}
+		source.WriteString("RET\n")
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], source.String())
+		want := 72
+		if arch == "386" {
+			want = 24
+		}
+		if len(rows) != want {
+			t.Fatal("complete independent shape denominator changed", arch, len(rows), want)
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("complete qword-permute shape lacks a mandatory typed/FLAGS owner", known, err)
+				}
+				sourceIndex, destination := 0, len(ins.Args)-1
+				if row.immediate {
+					sourceIndex = 1
+				}
+				seen := make(map[int]bool)
+				for _, operand := range effect.operands {
+					index := operand.index
+					if index < 0 || index >= len(ins.Args) || seen[index] || !reflect.DeepEqual(operand.operand, ins.Args[index]) {
+						t.Fatal("typed byte descriptor changed or duplicated an original operand", operand)
+					}
+					seen[index] = true
+					width := row.width()
+					if index == sourceIndex && row.input == "broadcast" || row.mode != "plain" && index == 2 {
+						width = 8
+					}
+					read := index != destination || row.mode == "merge"
+					if operand.width != int64(width) || operand.read != read || operand.write != (index == destination) {
+						t.Fatal("data/control/mask/old-destination byte roles changed", operand)
+					}
+				}
+				wantOperands := len(ins.Args)
+				if row.immediate {
+					wantOperands--
+				}
+				if len(seen) != wantOperands || row.immediate && seen[0] ||
+					!x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, arch) {
+					t.Fatal("Void or immediate classification bypassed actual input obligations", seen)
+				}
+			})
+		}
+	}
+}
+
+// Immediate control is repeated per 256-bit block, not VPERMIL's 128-bit
+// block. The oracle below is independent of the emitter's lane selector.
+func x86QwordPermuteDefinedBytes(source uint64, width, selector int) uint64 {
+	var defined uint64
+	for output := 0; output < width; output++ {
+		lane := output / 8
+		selected := lane/4*4 + ((selector >> uint(2*(lane%4))) & 3)
+		if source>>uint(selected*8+output%8)&1 != 0 {
+			defined |= uint64(1) << uint(output)
+		}
+	}
+	return defined
+}
+
+func TestX86QwordPermuteAllImmediateSelectorsAndEveryByte(t *testing.T) {
+	for _, op := range []string{"VPERMQ", "VPERMPD"} {
+		for _, bank := range []string{"Y", "Z"} {
+			t.Run(op+"/"+bank, func(t *testing.T) {
+				width := 32
+				if bank == "Z" {
+					width = 64
+				}
+				for selector := 0; selector < 256; selector++ {
+					// Alternate a separate destination and a destructive data alias.
+					destination := 2
+					if selector&1 != 0 {
+						destination = 0
+					}
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,%s0,%s%d", op, selector, bank, bank, destination))
+					for missing := -1; missing < width; missing++ {
+						state := x86FMA3ResultInputState()
+						if missing >= 0 {
+							state.writeVector(0, 64, state.vectorBytes(0)&^(uint64(1)<<uint(missing)), false)
+						}
+						before := state.clone()
+						defined := x86QwordPermuteDefinedBytes(state.vectorBytes(0), width, selector)
+						want := before.clone()
+						want.writeVector(destination, width, defined, false)
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, want) {
+							t.Fatal("immediate selector invented bytes or lost upper aliases/FLAGS/DF/private state", selector, missing, destination)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86QwordPermuteVariableMaskAndMergeActualInputs(t *testing.T) {
+	for _, row := range x86QwordPermuteOracleRows("amd64") {
+		if row.input != "register" {
+			continue
+		}
+		for destination := 0; destination < 3; destination++ {
+			instruction := strings.TrimSuffix(row.instruction(), row.bank+"2") + fmt.Sprint(row.bank, destination)
+			t.Run(instruction, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, instruction)
+				for source := -1; source < 3; source++ {
+					for missing := 0; missing < row.width(); missing++ {
+						if source == -1 && (row.mode == "plain" || missing != 0) {
+							continue
+						}
+						state := x86FMA3ResultInputState()
+						if source == -1 {
+							state.masks[1] = false
+						} else {
+							state.writeVector(source, 64, state.vectorBytes(source)&^(uint64(1)<<uint(missing)), false)
+						}
+						before := state.clone()
+						accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64")
+						if source == -1 || !row.immediate && (source == 0 || source == 1 && missing%8 == 0) {
+							if accepted || !reflect.DeepEqual(state, before) {
+								t.Fatal("missing actual mask/data/low control byte was invented or partly wrote state", source, missing)
+							}
+							continue
+						}
+						defined := x86CallerVectorByteMask(int64(row.width()))
+						if row.immediate {
+							defined = x86QwordPermuteDefinedBytes(before.vectorBytes(0), row.width(), 216)
+						}
+						if row.mode == "merge" {
+							defined &= before.vectorBytes(destination)
+						}
+						want := before.clone()
+						want.writeVector(destination, row.width(), defined, false)
+						if !accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("unused high control bits/zero old destination or selected data changed state", source, missing)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_qword_permute_native_inputs_test.go b/x86_qword_permute_native_inputs_test.go
new file mode 100644
index 000000000..e6fe89d82
--- /dev/null
+++ b/x86_qword_permute_native_inputs_test.go
@@ -0,0 +1,291 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86QwordPermuteOriginalConformanceThreeAPIObjects(t *testing.T) {
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, member := range []struct{ name, declaration string }{
+		{"qwordPermuteSemantics", "func qwordPermuteSemantics(out *[8]uint64,data *[4]uint64)"},
+		{"qwordVariablePermuteSemantics", "func qwordVariablePermuteSemantics(out *[8]uint64,data,control *[4]uint64)"},
+	} {
+		t.Run(member.name, func(t *testing.T) {
+			start := strings.Index(string(data), "TEXT ·"+member.name+"(SB),")
+			if start < 0 {
+				t.Fatal("complete original qword-permute function missing")
+			}
+			end := strings.Index(string(data[start:]), "\n\tRET\n")
+			if end < 0 {
+				t.Fatal("complete original qword-permute return missing")
+			}
+			source := "#include \"textflag.h\"\n" + string(data[start:start+end+len("\n\tRET\n")])
+			x86PackedFaultProgramObjects(t, source, member.declaration)
+		})
+	}
+}
+
+func (row x86QwordPermuteOracleRow) program(arch, name string, dead bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s data+%d(FP),BX\n",
+		name, 2*word, move, move, word)
+	for index := 0; index < 3; index++ {
+		fmt.Fprintf(&source, "VPXORD Z%d,Z%d,Z%d\n", index, index, index)
+	}
+	if row.mode != "plain" {
+		mask := -1
+		if row.mode == "zero" {
+			mask = 0
+		}
+		fmt.Fprintf(&source, "MOVL $%d,AX\nKMOVD AX,K1\n", mask)
+	}
+	source.WriteString("MOVL $5,DX\nCMPL DX,$3\n")
+	source.WriteString(row.instruction() + "\n")
+	if !dead {
+		// All 64 bytes observe Y upper-zeroing as well as the actual output.
+		source.WriteString("VMOVUPS Z2,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\n")
+	}
+	source.WriteString("RET\n")
+	return source.String(), fmt.Sprintf("func %s(out *[66]byte,data *[64]byte)\n", name)
+}
+
+func x86QwordPermuteRequireRead(t *testing.T, body string, bytes int) {
+	t.Helper()
+	pattern := fmt.Sprintf(`(?m)^\s+%%[^\n]+ = load volatile <%d x i8>, [^\n]*, align 1$`, bytes)
+	if len(regexp.MustCompile(pattern).FindAllString(body, -1)) != 1 || strings.Count(body, "load volatile ") != 1 ||
+		strings.Contains(body, "@llvm.masked.load") || strings.Contains(body, "br i1") {
+		t.Fatal("E4NF native tuple was removable, narrowed or mask-dependent", bytes, body)
+	}
+}
+
+// The complete 72/24 form witnesses are objects once per API/target, not the
+// Cartesian product of selectors, missing bytes and backend objects.
+func TestX86QwordPermuteInitializedFiveTargetObjectsAndExactReads(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86QwordPermuteOracleRows(target.arch)
+			var source, declarations strings.Builder
+			var names []string
+			for index, row := range rows {
+				name := fmt.Sprint("Permute", index)
+				names = append(names, name)
+				body, declaration := row.program(target.arch, name, false)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized qword-permute family rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					optimized := x86DwordProductIROptimize(t, ir)
+					for index, row := range rows {
+						if row.input == "register" {
+							continue
+						}
+						bytes := row.width()
+						if row.input == "broadcast" {
+							bytes = 8
+						}
+						for _, input := range []string{ir, optimized} {
+							x86QwordPermuteRequireRead(t, x86StringMemoryFunction(t, input, names[index]), bytes)
+						}
+					}
+					for _, pipeline := range []struct{ ir, level string }{{ir, "-O0"}, {ir, "-O2"}, {optimized, "-O2"}} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86QwordPermuteVoidDeadAndZeroMaskNeedActualInputs(t *testing.T) {
+	for _, row := range x86QwordPermuteOracleRows("amd64") {
+		if row.input == "register" || row.mode == "merge" {
+			continue
+		}
+		for _, missing := range []string{"none", "pointer", "numeric-address", "partial-address", "index", "control", "mask"} {
+			if missing == "control" && row.immediate || missing == "mask" && row.mode == "plain" {
+				continue
+			}
+			source, declaration := row.program("amd64", "Value", true)
+			switch missing {
+			case "pointer":
+				source = strings.Replace(source, "MOVQ data+8(FP),BX\n", "", 1)
+			case "numeric-address":
+				source = strings.Replace(source, "MOVQ data+8(FP),BX", "MOVQ $42,BX", 1)
+			case "partial-address":
+				source = strings.Replace(source, "MOVQ data+8(FP),BX", "MOVB $42,BL", 1)
+			case "index":
+				source = strings.Replace(source, "(BX)", "(BX)(SI*2)", 1)
+			case "control":
+				source = strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+			case "mask":
+				source = strings.Replace(source, "KMOVD AX,K1\n", "", 1)
+			}
+			t.Run(row.instruction()+"/"+missing, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if missing == "none" || missing == "numeric-address" {
+						if err != nil || ir == "" {
+							t.Fatal("dead initialized native read lacks its paired source", api, err)
+						}
+						bytes := row.width()
+						if row.input == "broadcast" {
+							bytes = 8
+						}
+						x86QwordPermuteRequireRead(t, x86StringMemoryFunction(t, ir, "Value"), bytes)
+						if missing == "numeric-address" {
+							x86RequireNumericNativeSourceContext(t, source, declaration, "amd64")
+							x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+						}
+					} else if missing == "control" {
+						x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Void/zero mask invented a missing actual native address/control/mask", api, missing, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86QwordPermuteRawOriginReplayAndMode32GrammarStaySeparate(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPERMQ", "VPERMPD"} {
+			for _, bank := range []string{"Y", "Z"} {
+				for _, immediate := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/immediate%t", arch, op, bank, immediate), func(t *testing.T) {
+						row := x86QwordPermuteOracleRow{op, bank, "plain", "register", immediate}
+						code, pcs := x86NumericalBoundaryGoBytes(t, arch, row.instruction()+"\nRET")
+						if len(pcs) != 2 || pcs[1] != int64(len(code)-1) || code[len(code)-1] != 0xc3 {
+							t.Fatal("actual original physical instruction/RET prior changed", code, pcs)
+						}
+						prefix := "TEXT ·Value(SB),4,$0-4\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+						suffix := "MOVL X2,ret+0(FP)\nRET\n"
+						namedSource := prefix + row.instruction() + "\n" + suffix
+						strict, lowered := x86RegisterReplayConsumers(t, arch, namedSource)
+						named := mustParseX86RawReturn(t, namedSource).Funcs[0]
+						if strict(named) != nil || lowered(named) != nil || named.x86RawReplay != nil {
+							t.Fatal("actual fully initialized named register source lost its existing numerical role")
+						}
+						file, err := normalizeX86RawFile(mustParseX86RawReturn(t, prefix+x86RawDisplacementDirectives(code[:pcs[1]])+suffix), arch)
+						if err != nil {
+							t.Fatal("complete actual raw source normalization failed", err)
+						}
+						original, ordinal := file.Funcs[0], -1
+						for index, ins := range original.Instrs {
+							if ins.Op == Op(op) && ins.x86SourceRaw != nil {
+								ordinal = index
+							}
+						}
+						if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil ||
+							!errors.Is(lowered(original), ErrProbeNeedsContext) {
+							t.Fatal("raw identity supplied an unowned initialized numerical entry")
+						}
+						changed := original
+						changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+						changed.Instrs[ordinal].x86SourceRaw = nil
+						if strict(changed) != nil || !errors.Is(lowered(changed), ErrProbeNeedsContext) || original.x86RawReplay.validate(original, arch) != nil {
+							t.Fatal("erasing an origin bypassed the immutable complete producer or altered its original")
+						}
+					})
+				}
+			}
+		}
+	}
+	for _, op := range []string{"VPERMQ", "VPERMPD"} {
+		for _, operands := range []string{"$216,Y0,K1,Y2", "Y0,Y1,K1,Y2", "$216,Z0,K1,Z2", "Z0,Z1,K1,Z2"} {
+			source := "TEXT physical(SB),4,$0-0\n" + op + ".Z " + operands + "\nRET\n"
+			code := assembleX87ControlBytes(t, "amd64", source)
+			decoded, length, recognized, err := decodedX86RawQwordPermuteInstruction(code, 32)
+			if !recognized || err != nil || length != len(code)-1 || string(decoded.Op) != op+".Z" || len(decoded.Args) != 4 {
+				t.Fatal("low-bank mode32 physical EVEX masked prior was lost", op, operands, code, decoded, err)
+			}
+			requireX86GoAssemblerResult(t, "386", source, false)
+		}
+	}
+}
+
+func TestX86QwordPermuteInvalidNamedFormsMatchActualGo(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"VPERMQ", "VPERMPD"} {
+			for _, operands := range []string{
+				"$-129,Y0,Y2", "$256,Y0,Y2", "$1.5,Y0,Y2", "$-1,Z0,Z2",
+				"$0,X0,X2", "X0,X1,X2", "$0,Y0,Z2", "Y0,Z1,Z2", "Y0,(AX),Y2",
+				"Y0,Y1,(AX)", "$0,Y0,K0,Y2", "Y0,Y1,K0,Y2",
+			} {
+				instruction := op + " " + operands
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+					requireX86GoAssemblerResult(t, arch, source, false)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+						if err == nil || ir != "" {
+							t.Fatal("Go-rejected named operand form acquired a public body", api, err)
+						}
+					}
+				})
+			}
+			for _, instruction := range []string{
+				op + ".Z $0,Y0,Y2", op + ".Z Y0,Y1,Y2", op + ".BCST $0,Y0,Y2",
+				op + ".BCST Y0,Y1,Y2", op + ".SAE $0,Y0,Y2", op + ".RN_SAE Y0,Y1,Y2",
+			} {
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-0\n" + instruction + "\nRET\n"
+					requireX86GoAssemblerResult(t, arch, source, false)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+						if err == nil || ir != "" {
+							t.Fatal("reserved suffix acquired native or numerical permission", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86QwordPermuteUnboundFormatsRetainContextAndPhysicalObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT ·Format(SB),4,$0-0\n")
+			for _, row := range x86QwordPermuteOracleRows(target.arch) {
+				fmt.Fprintln(&source, row.instruction())
+			}
+			source.WriteString("RET\n")
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			ir := x86InstructionFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0,
+				func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerQwordPermute(ins.Op, ins)
+				})
+			x86PackedStringCompileObject(t, llc, target.triple, ir, "-O0")
+		})
+	}
+}
diff --git a/x86_qword_permute_runtime_test.go b/x86_qword_permute_runtime_test.go
new file mode 100644
index 000000000..46f32840f
--- /dev/null
+++ b/x86_qword_permute_runtime_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Portable LLVM values and access extents are independent of original AVX2/
+// AVX512 execution. The original native conformance owners remain unchanged.
+func TestX86QwordPermuteWholeVectorPortableValuesAndUpperAliases(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, metadata strings.Builder
+	rows := x86QwordPermuteOracleRows("amd64")
+	for index, row := range rows {
+		name := fmt.Sprint("Value", index)
+		destination := 2
+		if row.mode != "merge" {
+			destination = index % 3
+		}
+		instruction := strings.TrimSuffix(row.instruction(), row.bank+"2") + fmt.Sprint(row.bank, destination)
+		fmt.Fprintf(&declarations, "func %s(out *[68]byte,data,control *[64]byte,mask uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ data+8(FP),BX\nMOVQ control+16(FP),CX\n", name)
+		if row.input == "register" {
+			fmt.Fprintf(&source, "VMOVUPS (BX),%s0\n", row.bank)
+		}
+		if !row.immediate {
+			fmt.Fprintf(&source, "VMOVUPS (CX),%s1\n", row.bank)
+		}
+		if row.mode == "merge" {
+			source.WriteString("VMOVUPS (DI),Z2\n")
+		}
+		if row.mode != "plain" {
+			source.WriteString("KMOVQ mask+24(FP),K1\n")
+		}
+		fmt.Fprintf(&source, "MOVL $5,DX\nCMPL DX,$3\n%s\nVMOVUPS Z%d,(DI)\nSETCS 64(DI)\nSETOS 65(DI)\nRET\n", instruction, destination)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,uint64_t);\n", name)
+		fmt.Fprintf(&metadata, "{%s,%d,%t,%t,%d},\n", name, row.width()/8, row.immediate, row.input == "broadcast", map[string]int{"plain": 0, "merge": 1, "zero": 2}[row.mode])
+	}
+	if len(rows) != 72 {
+		t.Fatal("portable full-family value directory changed", len(rows))
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := `
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+struct row { void (*run)(uint8_t *,const uint8_t *,const uint8_t *,uint64_t); unsigned lanes; bool immediate,broadcast; unsigned mode; };
+static const struct row rows[] = { ` + metadata.String() + ` };
+int main(void) {
+    const uint64_t masks[] = {0,1,0x55,0xaa,UINT64_MAX,UINT64_C(1)<<63};
+    unsigned observations=0;
+    for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);++r) {
+        const struct row *row=&rows[r];
+        for(unsigned sample=0;sample<32;++sample) {
+            uint64_t data[8],control[8],data_before[8],control_before[8];
+            for(unsigned lane=0;lane<8;++lane) {
+                data[lane]=UINT64_C(0x9e3779b97f4a7c15)*(1+lane+sample*8);
+                control[lane]=(UINT64_C(0xfedcba9876543200)*(1+sample)) | ((lane*3+sample)&7);
+            }
+            memcpy(data_before,data,sizeof(data));
+            memcpy(control_before,control,sizeof(control));
+            for(unsigned m=0;m<sizeof(masks)/sizeof(masks[0]);++m) {
+                uint8_t output[68],expected[68];
+                for(unsigned byte=0;byte<sizeof(output);++byte) output[byte]=(uint8_t)(byte*13+sample*7+3);
+                memcpy(expected,output,sizeof(output));
+                for(unsigned lane=0;lane<row->lanes;++lane) {
+                    if(row->mode && !(masks[m]>>lane&1)) {
+                        if(row->mode==2) memset(expected+lane*8,0,8);
+                    } else {
+                        unsigned selected=row->broadcast ? 0 : row->immediate ?
+                            lane/4*4+((216>>(2*(lane%4)))&3) : (unsigned)(control[lane]&(row->lanes-1));
+                        memcpy(expected+lane*8,&data[selected],8);
+                    }
+                }
+                memset(expected+row->lanes*8,0,64-row->lanes*8);
+                expected[64]=expected[65]=0;
+                row->run(output,(const uint8_t *)data,(const uint8_t *)control,masks[m]);
+                if(memcmp(output,expected,sizeof(output)) || memcmp(data,data_before,sizeof(data)) || memcmp(control,control_before,sizeof(control))) {
+                    fprintf(stderr,"qword permute row=%u sample=%u mask=%u whole64/FLAGS/canary/input mismatch\n",r,sample,m);
+                    return 1;
+                }
+                ++observations;
+            }
+        }
+    }
+    return observations==13824 ? 0 : 2;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("initialized portable whole-vector program rejected", err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					execution.compileAndRunLLVM(t, "qword-permute-whole-values", pipeline.ir, driver, pipeline.level)
+				})
+			}
+		})
+	}
+}
+
+func TestX86QwordPermuteDeadAndZeroMaskExactNativeAccessFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, callbacks, metadata strings.Builder
+	count := 0
+	for _, row := range x86QwordPermuteOracleRows("amd64") {
+		if row.input == "register" || row.mode == "merge" {
+			continue
+		}
+		for _, mask := range []int{0, -1} {
+			if row.mode == "plain" && mask == -1 {
+				continue
+			}
+			name := fmt.Sprint("Access", count)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVQ data+0(FP),BX\nVPXORD Z1,Z1,Z1\nMOVL $%d,AX\nKMOVD AX,K1\n%s\nRET\n", name, mask, row.instruction())
+			fmt.Fprintf(&declarations, "func %s(data *[64]byte)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t *);\n", name)
+			fmt.Fprintf(&callbacks, "static int run%d(const uint8_t *p) { %s(p); return 0; }\n", count, name)
+			bytes := row.width()
+			if row.input == "broadcast" {
+				bytes = 8
+			}
+			fmt.Fprintf(&metadata, "{run%d,%d,%d},\n", count, bytes, bytes-1)
+			count++
+		}
+	}
+	if count != 48 {
+		t.Fatal("complete dead E4NF tuple/mask directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86MemoryFaultDriver(prototypes.String()+callbacks.String(), metadata.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("dead native read lacks its original input source", err)
+			}
+			for _, pipeline := range []struct{ name, ir, level string }{
+				{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "qword-permute-access", pipeline.ir, driver, pipeline.level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, count)
+				})
+			}
+		})
+	}
+	// This is actual-host portable extent evidence, not original AVX512 execution.
+}
diff --git a/x86_random_result_test.go b/x86_random_result_test.go
new file mode 100644
index 000000000..02ad8ad8c
--- /dev/null
+++ b/x86_random_result_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These are the independent yrdrand opcode rows, not the production grammar.
+var x86RandomResultOracle = []struct {
+	op, prefix string
+	width      int64
+	extension  byte
+}{
+	{"RDRANDW", "Pe", 2, 6}, {"RDRANDL", "Px", 4, 6}, {"RDRANDQ", "Pw", 8, 6},
+	{"RDSEEDW", "Pe", 2, 7}, {"RDSEEDL", "Px", 4, 7}, {"RDSEEDQ", "Pw", 8, 7},
+}
+
+func x86RandomOracleBytes(width int64, extension byte, register int) []byte {
+	var code []byte
+	if width == 2 {
+		code = append(code, 0x66)
+	}
+	rex := byte(0x40)
+	if width == 8 {
+		rex |= 8
+	}
+	if register >= 8 {
+		rex |= 1
+	}
+	if rex != 0x40 {
+		code = append(code, rex)
+	}
+	return append(code, 0x0f, 0xc7, 0xc0|extension<<3|byte(register&7))
+}
+
+func TestX86HardwareRandomCompleteGoRowsAndPhysicalRegisters(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(table), "var yrdrand = []ytab{\n\t{Zo_m, 2, argList{Yrl}},\n}") {
+		t.Fatal("complete Go yrdrand operand row changed")
+	}
+	registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for _, arch := range []string{"386", "amd64"} {
+		var source strings.Builder
+		var expected []byte
+		source.WriteString("TEXT random(SB),4,$0-0\n")
+		for _, row := range x86RandomResultOracle {
+			want := fmt.Sprintf("{A%s, yrdrand, %s, opBytes{0x0f, 0xc7, 0%d}}", row.op, row.prefix, row.extension)
+			if !strings.Contains(string(table), want) {
+				t.Fatal("complete Go random encoding changed", row.op)
+			}
+			if arch == "386" && row.width == 8 {
+				continue // Go has no Q operand row in this source mode.
+			}
+			for index, register := range registers {
+				if arch == "386" && index >= 8 {
+					break
+				}
+				fmt.Fprintf(&source, "%s %s\n", row.op, register)
+				code := x86RandomOracleBytes(row.width, row.extension, index)
+				expected = append(expected, code...)
+				file, err := Parse(ArchAMD64, "TEXT random(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+				if err != nil || len(fn.Instrs) != 3 || fn.Instrs[1].Op != Op(row.op) ||
+					!reflect.DeepEqual(fn.Instrs[1].Args, []Operand{{Kind: OpReg, Reg: register}}) {
+					t.Fatal("independent physical random encoding lost its whole form", arch, row.op, register, err)
+				}
+			}
+		}
+		source.WriteString("RET\n")
+		expected = append(expected, 0xc3)
+		if actual := assembleX87ControlBytes(t, arch, source.String()); !bytes.Equal(actual, expected) {
+			t.Fatalf("%s original Go physical register/width encodings differ: %x / %x", arch, actual, expected)
+		}
+	}
+}
+
+func TestX86HardwareRandomEveryRegisterByteAndStatusEffect(t *testing.T) {
+	registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RandomResultOracle {
+			if arch == "386" && row.width == 8 {
+				continue
+			}
+			for index, register := range registers {
+				if arch == "386" && index >= 8 {
+					break
+				}
+				t.Run(arch+"/"+row.op+"/"+string(register), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" "+string(register))
+					for _, prior := range []uint8{0, 0xa5, 0xff} {
+						state := x86ResultState{direction: x86ResultDirectionBackward}
+						state.gp[index], state.pointerGP[index] = prior, true
+						state.xmm[3], state.masks[2] = 0x1234, true
+						state.valueStack = &x86ResultValueStack{bytes: []uint8{1, 2, 3, 4}, id: true}
+						want := state.clone()
+						// Physical SP, and AMD64 BP, are not ordinary NUM destinations.
+						valid := register != SP && !(arch == "amd64" && register == BP)
+						if valid {
+							want.flags = 0x3f
+							want.pointerGP[index] = false
+							want.gp[index] = 0xff
+							if row.width == 2 {
+								want.gp[index] = prior | 3
+							}
+						}
+						if x86ResultTransfer(ins, &state, nil, 0, arch) != valid || !reflect.DeepEqual(state, want) {
+							t.Error("random must define only written bytes and six FLAGS, preserving unrelated state", prior)
+						}
+					}
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || !effect.requiresResultProof || effect.flagsRead != 0 ||
+						effect.flagsDefined != 0x3f || effect.flagsKilled != 0x3f || len(effect.operands) != 1 ||
+						effect.operands[0].read || !effect.operands[0].write || effect.operands[0].width != row.width {
+						t.Error("missing complete write-only typed random effect", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86HardwareRandomDispatchIdentityBeforeEmission(t *testing.T) {
+	for _, row := range x86RandomResultOracle {
+		for _, invalid := range []string{"dispatch", "suffix", "constructed-operand", "foreign-mode"} {
+			t.Run(row.op+"/"+invalid, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" AX")
+				op := ins.Op
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = "amd64"
+				switch invalid {
+				case "dispatch":
+					ins.Op = "NOP"
+				case "suffix":
+					op += ".Z"
+				case "constructed-operand":
+					ins.Args[0].ImmRaw = "$unknown"
+				case "foreign-mode":
+					ctx.goarch = "arm64"
+				}
+				before, temporary := output.String(), ctx.tmp
+				known, terminated, err := ctx.lowerHardwareRandom(op, ins)
+				if !known || terminated || err == nil || before != output.String() || temporary != ctx.tmp {
+					t.Error("invalid random dispatch emitted partial IR", known, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86HardwareRandomInitializedThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, value, size := "L", "uint32", 4
+			if target.arch == "amd64" {
+				word, value, size = "Q", "uint64", 8
+			}
+			var source, declarations strings.Builder
+			for _, row := range x86RandomResultOracle {
+				if target.arch == "386" && row.width == 8 {
+					continue
+				}
+				for _, raw := range []bool{false, true} {
+					name := fmt.Sprintf("%s%t", row.op, raw)
+					body := row.op + " BX\n"
+					if raw {
+						body = x86RawDisplacementDirectives(x86RandomOracleBytes(row.width, row.extension, 3))
+					}
+					fmt.Fprintf(&declarations, "func %s(seed %s) (%s,%s)\n", name, value, value, value)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s seed+0(FP),BX\nPUSH%s $0x8d7\nPOPF%s\n%sPUSHF%s\nPOP%s AX\nMOV%s BX,value+%d(FP)\nMOV%s AX,status+%d(FP)\nRET\n",
+						name, 3*size, word, word, word, body, word, word, word, size, word, 2*size)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized random value/FLAGS program", api, err)
+				}
+				for _, row := range x86RandomResultOracle {
+					if target.arch == "386" && row.width == 8 {
+						continue
+					}
+					intrinsic := fmt.Sprintf("@llvm.x86.%s.%d()", strings.ToLower(row.op[:len(row.op)-1]), row.width*8)
+					if !strings.Contains(ir, intrinsic) {
+						t.Fatal("actual hardware random intrinsic missing", intrinsic)
+					}
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86HardwareRandomCannotSupplyFrameOrMissingResult(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86RandomResultOracle {
+			if target.arch == "386" && row.width == 8 {
+				continue
+			}
+			for _, invalid := range []struct{ name, body, declaration string }{
+				{"stack", row.op + " SP\n", "func Value()"},
+				{"missing-result", row.op + " BX\n", "func Value() uint32"},
+				{"missing-upper", row.op + " BX\nMOVL BX,ret+0(FP)\n", "func Value() uint32"},
+			} {
+				if invalid.name == "missing-upper" && row.width != 2 {
+					continue
+				}
+				t.Run(target.triple+"/"+row.op+"/"+invalid.name, func(t *testing.T) {
+					extent := 4
+					if invalid.name == "stack" {
+						extent = 0
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", extent, invalid.body)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, invalid.declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("random invented an entry/result/upper-byte role", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_random_source_test.go b/x86_random_source_test.go
new file mode 100644
index 000000000..0af41f85c
--- /dev/null
+++ b/x86_random_source_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86HardwareRandomRawIdentityAndStorageBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RandomResultOracle {
+			if arch == "386" && row.width == 8 {
+				continue
+			}
+			source := "TEXT random(SB),4,$0-0\n" +
+				x86RawDisplacementDirectives(x86RandomOracleBytes(row.width, row.extension, 3)) + "RET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+			if err != nil || len(fn.Instrs) != 3 || fn.Instrs[1].x86SourceRaw == nil {
+				t.Fatal("missing complete decoder source", err)
+			}
+			original := fn.Instrs[1]
+			for _, mutation := range []string{"unchanged", "operand", "origin-opcode", "origin-operand",
+				"encoded", "address-size", "segment", "unbound-address", "raw-return", "constructed-operand"} {
+				t.Run(arch+"/"+row.op+"/"+mutation, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					origin := *original.x86SourceRaw
+					ins.x86SourceRaw = &origin
+					switch mutation {
+					case "operand":
+						ins.Args[0].Reg = AX
+					case "origin-opcode":
+						origin.op = "NOP"
+					case "origin-operand":
+						origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+					case "encoded":
+						ins.x86Encoded = true
+					case "address-size":
+						ins.x86AddressBits = 32
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "unbound-address":
+						ins.x86UnboundAddressOverride = true
+					case "raw-return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "constructed-operand":
+						ins.Args[0].ImmRaw = "$unknown"
+					}
+					valid := mutation == "unchanged"
+					state := x86ResultState{direction: x86ResultDirectionBackward,
+						valueStack: &x86ResultValueStack{bytes: []uint8{1, 2, 3, 4}, id: true}}
+					state.callerAddressGP[3], state.callerAddressGP[7] = true, true
+					if x86RegisterQueryPreservesSourceState(ins) != valid {
+						t.Fatal("random acquired a mismatched storage identity")
+					}
+					if valid {
+						addresses := state.callerAddressGP
+						addresses[3] = false
+						if !x86ResultValueStackContinuation(ins, &state, arch) ||
+							x86ResultDirectionAfter(ins, state.direction) != state.direction ||
+							x86ResultCallerAddressesAfter(ins, state.callerAddressGP, nil, arch) != addresses {
+							t.Fatal("random lost private storage/DF or its exact GP overwrite footprint")
+						}
+					}
+					before := state.clone()
+					if x86ResultTransfer(ins, &state, nil, 0, arch) != valid || !valid && !reflect.DeepEqual(state, before) {
+						t.Fatal("mismatched random acquired numerical outputs or partially updated state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86HardwareRandomOriginalStatusWriterSource(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86RandomResultOracle {
+			if target.arch == "386" && row.width == 8 {
+				continue
+			}
+			t.Run(target.triple+"/"+row.op, func(t *testing.T) {
+				// This is exactly the discovering fixture, not a replacement seed.
+				source := x86DefinedZeroAFSource(target.arch, "status", row.op+" BX")
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func status()", target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "store i1 false, ptr %flags_af") != 2 {
+						t.Fatal("original initialized status source still fails", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86HardwareRandomLivePrivateStackAndCanonicalResult(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := "L"
+		if target.arch == "amd64" {
+			word = "Q"
+		}
+		for _, row := range x86RandomResultOracle {
+			if target.arch == "386" && row.width == 8 {
+				continue
+			}
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/raw=%t", target.triple, row.op, raw), func(t *testing.T) {
+					body := row.op + " AX\n"
+					if raw {
+						body = x86RawDisplacementDirectives(x86RandomOracleBytes(row.width, row.extension, 0))
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nMOVL $1,AX\nPUSH%s AX\n%sPOP%s BX\nMOVB BX,ret+0(FP)\nRET\n", word, body, word)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						// A preserved numerical private stack is not a canonical bool
+						// transport. Use its numerical byte, then independently reject
+						// a random value that overwrote a previous canonical constant.
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint8", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("random lost a live independent private stack", api, err)
+						}
+						bad := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nMOVL $1,AX\n%sMOVB AX,ret+0(FP)\nRET\n", body)
+						ir, err = x86ScalarFPBitViewAPI(t, bad, "func Value() bool", target.arch, target.triple, api)
+						if err == nil || ir != "" {
+							t.Fatal("random result retained an overwritten canonical bool", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_abs_literal.go b/x86_raw_abs_literal.go
new file mode 100644
index 000000000..5e728512c
--- /dev/null
+++ b/x86_raw_abs_literal.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+// Physical generation belongs to the decoder's original source, not a low
+// register spelling or a later numerical-input permission.
+type x86RawPackedAbsIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86PackedAbsRawIdentity(ins Instr, arch string) x86RawPackedAbsIdentity {
+	form, known, err := x86PackedAbsSignProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.legacy || form.spec.sign {
+		return x86RawPackedAbsIdentity{}
+	}
+	return x86RawPackedAbsIdentity{arch, ins.x86Encoded, ins.x86PackedAbsEVEX}
+}
+
+// All four VPABS names retain the existing typed grammar and exact full or
+// broadcast tuple. Only a replay-bound mode64 RIP literal participates: this
+// supplies no ordinary-pointer, raw-entry, caller or standalone-query role.
+func x86RawPackedAbsLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceIdentity(ins, arch) {
+		return false
+	}
+	origin := ins.x86SourceRaw
+	if origin.packedAbs.arch != arch || origin.packedAbs != x86PackedAbsRawIdentity(ins, arch) {
+		return false
+	}
+	form, known, err := x86PackedAbsSignProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.legacy && !form.spec.sign && form.memory == form.first &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
diff --git a/x86_raw_abs_literal_test.go b/x86_raw_abs_literal_test.go
new file mode 100644
index 000000000..08aaf39ad
--- /dev/null
+++ b/x86_raw_abs_literal_test.go
@@ -0,0 +1,237 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent physical directory: Go's three VEX B/W/D names with WIG,
+// and four EVEX B/W/D/Q names with every width, mask role and memory tuple.
+// Each displacement points past the original encoded RET to complete data.
+func x86RawAbsLiteralCases() []x86RawVectorLiteralCase {
+	var rows []x86RawVectorLiteralCase
+	for index, suffix := range []string{"B", "W", "D", "Q"} {
+		lane := 1 << uint(index)
+		add := func(width, mask int, evex, w, broadcast bool) {
+			length := map[int]byte{16: 0, 32: 1, 64: 2}[width]
+			var code []byte
+			if evex {
+				p1, p2 := byte(0x7d), byte(0x08)|length<<5|byte(mask)
+				if w {
+					p1 |= 0x80
+				}
+				if mask == 7 {
+					p2 |= 0x80
+				}
+				if broadcast {
+					p2 |= 0x10
+				}
+				code = []byte{0x62, 0xf2, p1, p2, byte(0x1c + index), 0x15}
+			} else {
+				p1 := byte(0x79) | length<<2
+				if w {
+					p1 |= 0x80
+				}
+				code = []byte{0xc4, 0xe2, p1, byte(0x1c + index), 0x15}
+			}
+			code = append(code, 1, 0, 0, 0, 0xc3)
+			size := width
+			if broadcast {
+				size = lane
+			}
+			for at := 0; at < size; at++ {
+				code = append(code, byte(at*23+0x85))
+			}
+			rows = append(rows, x86RawVectorLiteralCase{
+				name: fmt.Sprintf("Abs%s_%d_K%d_EVEX%t_W%t_BCST%t", suffix, width, mask, evex, w, broadcast),
+				code: code, mask: mask,
+			})
+		}
+		for _, width := range []int{16, 32, 64} {
+			if index < 3 && width < 64 {
+				add(width, 0, false, false, false)
+				add(width, 0, false, true, false)
+			}
+			for _, mask := range []int{0, 3, 7} {
+				add(width, mask, true, index == 3, false)
+				if index >= 2 {
+					add(width, mask, true, index == 3, true)
+				}
+			}
+		}
+	}
+	if len(rows) != 66 {
+		panic("independent complete ABS literal directory changed")
+	}
+	return rows
+}
+
+func TestX86RawAbsLiteralActualPhysicalRows(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("independent ABS physical prior requires LLVM22 llvm-mc")
+	}
+	var input strings.Builder
+	want := make(map[string]int)
+	for _, row := range x86RawAbsLiteralCases() {
+		size := 9
+		if row.code[0] == 0x62 {
+			size = 10
+		}
+		for _, value := range row.code[:size] {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+		suffix := strings.Split(strings.TrimPrefix(row.name, "Abs"), "_")[0]
+		want["vpabs"+strings.ToLower(suffix)]++
+	}
+	stage, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(stage, mc, "--disassemble", "--triple=x86_64-unknown-linux-gnu",
+		"--mattr=+avx2,+avx512f,+avx512bw,+avx512vl")
+	command.Stdin = strings.NewReader(input.String())
+	output, err := runtimeOracleCombinedOutput(stage, command)
+	if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+		t.Fatalf("independent complete ABS physical prior failed: %v\n%s", err, output)
+	}
+	for mnemonic, count := range want {
+		if strings.Count(string(output), mnemonic) != count {
+			t.Fatal("physical ABS opcode count changed", mnemonic, count)
+		}
+	}
+}
+
+func TestX86RawAbsLiteralCompleteLinuxObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-unknown-linux-gnu", x86RawAbsLiteralCases())
+}
+
+func TestX86RawAbsLiteralCompleteDarwinObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-apple-darwin", x86RawAbsLiteralCases())
+}
+
+func TestX86RawAbsLiteralCompleteWindowsObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-pc-windows-msvc", x86RawAbsLiteralCases())
+}
+
+func x86RawAbsLiteralNormalized(t *testing.T, row x86RawVectorLiteralCase) (*File, Instr) {
+	t.Helper()
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawVectorLiteralSource(row)), "amd64")
+	if err != nil || len(file.Funcs) != 1 || len(file.Data) != 1 {
+		t.Fatal("original ABS literal lost its one complete DATA body", row.name, err)
+	}
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.x86RIPLiteral {
+			return file, ins
+		}
+	}
+	t.Fatal("original ABS literal has no exact decoded source", row.name)
+	return nil, Instr{}
+}
+
+func TestX86RawAbsLiteralExactTupleMasksAndPreservedState(t *testing.T) {
+	for _, row := range x86RawAbsLiteralCases() {
+		t.Run(row.name, func(t *testing.T) {
+			_, ins := x86RawAbsLiteralNormalized(t, row)
+			form, known, err := x86PackedAbsSignProperties(ins.Op, ins, "amd64")
+			if !known || err != nil || !x86RawResultLiteralForm(ins, "amd64") || x86RawResultLiteralForm(ins, "386") {
+				t.Fatal("complete ABS literal lost its exact mode64 typed role", err)
+			}
+			address, valid := x86StaticSBReadAddress(ins.Args[0], "amd64")
+			if !valid {
+				t.Fatal("original ABS literal has no independently bound DATA address")
+			}
+			original := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+				loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(form.memoryBytes)}}
+			original.masks[3], original.masks[7] = true, true
+			original.writeVector(2, 64, 0x55aa55aa55aa55aa, false)
+			state, want := original, original
+			initialized := ^uint64(0)
+			if row.mask == 3 {
+				initialized = original.vectorBytes(2) | ^x86CallerVectorByteMask(int64(form.byteWidth))
+			}
+			want.writeVector(2, 64, initialized, false)
+			if accepted, recognized := x86ResultPackedAbsSignStep(ins, &state, nil, "amd64", false); !accepted || !recognized || !reflect.DeepEqual(state, want) {
+				t.Fatal("literal invented merge bytes or changed unrelated aliases/FLAGS/DF")
+			}
+			for size := 0; size < form.memoryBytes; size++ {
+				state = original
+				state.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(size)}
+				before := state
+				if accepted, recognized := x86ResultPackedAbsSignStep(ins, &state, nil, "amd64", false); accepted || !recognized || !reflect.DeepEqual(state, before) {
+					t.Fatal("ABS literal borrowed a missing full/broadcast tuple byte", size)
+				}
+			}
+			if row.mask != 0 {
+				state = original
+				state.masks[row.mask] = false
+				before := state
+				if accepted, _ := x86ResultPackedAbsSignStep(ins, &state, nil, "amd64", false); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("ABS literal borrowed a missing numerical mask")
+				}
+			}
+			changed := ins
+			changed.x86PackedAbsEVEX = !changed.x86PackedAbsEVEX
+			if x86RawResultLiteralForm(changed, "amd64") {
+				t.Fatal("ABS literal forgot its original physical generation")
+			}
+		})
+	}
+}
+
+func TestX86RawAbsLiteralKeepsOriginalDataAndReturnAuthority(t *testing.T) {
+	rows := x86RawAbsLiteralCases()
+	for _, index := range []int{0, 4, 30, len(rows) - 1} {
+		row := rows[index]
+		source := x86RawVectorLiteralSource(row)
+		for _, changed := range []string{
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, changed, "func "+row.name+"()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("complete ABS literal invented a raw-return frame", row.name, api, err)
+				}
+			}
+		}
+		for _, change := range []string{"DATA", "operand", "opcode", "origin", "generation"} {
+			file, _ := x86RawAbsLiteralNormalized(t, row)
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone query borrowed the lowering's static byte owner", err)
+			}
+			if change == "DATA" {
+				file.Data[0].Payload[0] ^= 1
+			} else {
+				for at := range file.Funcs[0].Instrs {
+					ins := &file.Funcs[0].Instrs[at]
+					if !ins.x86RIPLiteral {
+						continue
+					}
+					switch change {
+					case "operand":
+						ins.Args[0].Sym += "foreign"
+					case "opcode":
+						ins.Op = "VPABSW"
+						if strings.HasPrefix(row.name, "AbsW_") {
+							ins.Op = "VPABSD"
+						}
+					case "origin":
+						ins.x86SourceRaw = nil
+					case "generation":
+						ins.x86PackedAbsEVEX = !ins.x86PackedAbsEVEX
+					}
+					break
+				}
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+				ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed ABS literal borrowed original DATA/source identity", row.name, change, err)
+			}
+		}
+	}
+}
diff --git a/x86_raw_addsub_replay_test.go b/x86_raw_addsub_replay_test.go
new file mode 100644
index 000000000..b0661256a
--- /dev/null
+++ b/x86_raw_addsub_replay_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86RawReplayNormalizationModeAliases(t *testing.T) {
+	const source = "TEXT Value(SB),4,$0-0\nBYTE $0x90\nRET\n"
+	for _, first := range []string{"", "amd64", "386"} {
+		original := mustParseX86RawReturn(t, source)
+		normalized, err := normalizeX86RawFile(original, first)
+		if err != nil || normalized.Funcs[0].x86RawReplay == nil {
+			t.Fatal("original raw mode prerequisite", first, err)
+		}
+		for _, second := range []string{"", "amd64", "386"} {
+			t.Run(first+"/to/"+second, func(t *testing.T) {
+				_, err := normalizeX86RawFile(normalized, second)
+				compatible := (first == "386") == (second == "386")
+				if compatible && err != nil || !compatible && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("default AMD64 alias or explicit source-mode identity changed", first, second, err)
+				}
+				if normalized.Funcs[0].x86RawReplay.goarch != first {
+					t.Fatal("normalization rewrote the retained source mode")
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawAddSubPublicWholeProducerReplay(t *testing.T) {
+	// Exact source and by-value declaration from the independently initialized
+	// raw positive. Both vectors are actual typed numeric inputs, not pointers.
+	const source = "TEXT Value(SB),4,$0-48\nMOVUPD a+0(FP),X0\nMOVUPD b+16(FP),X1\n" +
+		"LONG $0xc1d0f9c5\nMOVUPD X0,ret+32(FP)\nRET\n"
+	const declaration = "func Value(a,b [16]byte) [16]byte"
+	pkg := mustGoPackage(t, "addsubreplay", "package addsubreplay\n"+declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	for _, target := range x86RawReturnTargets {
+		requireX86GoAssemblerResult(t, target.arch, source, true)
+		parsed := mustParseX86RawReturn(t, source)
+		signatures, err := goSigsForAsmFile(pkg, parsed, resolve, target.arch, nil, nil, nil)
+		if err != nil {
+			t.Fatal("actual by-value declaration/frame prerequisite", err)
+		}
+		normalized, err := normalizeX86RawFile(parsed, target.arch)
+		if err != nil || len(normalized.Funcs) != 1 {
+			t.Fatal("original raw producer normalization prerequisite", err)
+		}
+		original, ordinal := normalized.Funcs[0], -1
+		for index, ins := range original.Instrs {
+			if ins.Op == "VADDSUBPD" && ins.x86SourceRaw != nil {
+				if ordinal >= 0 {
+					t.Fatal("ambiguous original raw arithmetic")
+				}
+				ordinal = index
+			}
+		}
+		if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, target.arch) != nil {
+			t.Fatal("original producer lost its independently sealed source replay")
+		}
+		for _, change := range []string{"valid", "origin", "origin-and-opcode", "origin-and-operand", "missing-replay"} {
+			for _, api := range []string{"text", "module"} {
+				t.Run(target.triple+"/"+change+"/"+api, func(t *testing.T) {
+					candidate := original
+					candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+					ins := &candidate.Instrs[ordinal]
+					if strings.HasPrefix(change, "origin") {
+						ins.x86SourceRaw = nil
+						if !x86ResultNamedPredicateInstruction(*ins) {
+							t.Fatal("origin mutation did not isolate the otherwise named instruction")
+						}
+					}
+					switch change {
+					case "origin-and-opcode":
+						ins.Op = "VADDSUBPS" // Same initialized input/output carriers.
+					case "origin-and-operand":
+						ins.Args[0].Reg = "X0" // X0 is fully defined by a, unlike an invented X7.
+					case "missing-replay":
+						candidate.x86RawReplay = nil
+					}
+					if err := x86LoweredNumericalProducerReplay(candidate, target.arch); (change == "valid" && err != nil) ||
+						(change != "valid" && !errors.Is(err, ErrProbeNeedsContext)) {
+						t.Fatal("whole producer replay precondition changed", err)
+					}
+					file := *normalized
+					file.Funcs = []Func{candidate}
+					options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: signatures}
+					var ir string
+					var callErr error
+					if api == "text" {
+						ir, callErr = Translate(&file, options)
+					} else {
+						context := llvm.NewContext()
+						module, err := TranslateModuleInContext(context, &file, options)
+						callErr = err
+						if !module.IsNil() {
+							ir = module.String()
+							module.Dispose()
+						}
+						context.Dispose()
+					}
+					if change == "valid" {
+						if callErr != nil || ir == "" {
+							t.Fatal("independently initialized original raw producer rejected", callErr)
+						}
+					} else if ir != "" || !errors.Is(callErr, ErrProbeNeedsContext) {
+						t.Fatal("public API accepted an erased or edited original raw producer", callErr)
+					}
+					if original.x86RawReplay.validate(original, target.arch) != nil {
+						t.Fatal("candidate mutation corrupted the retained original replay")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_arithmetic_literal_result_test.go b/x86_raw_arithmetic_literal_result_test.go
new file mode 100644
index 000000000..0552f15c1
--- /dev/null
+++ b/x86_raw_arithmetic_literal_result_test.go
@@ -0,0 +1,191 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawArithmeticLiteralCase struct {
+	x86RawVectorLiteralCase
+	op                 string
+	width, tuple, lane int
+}
+
+// Go's complete _yvandnpd rows have independent opcode-specific W and
+// broadcast attributes. Keep wrapping and signed/unsigned saturation names
+// explicit here rather than deriving witnesses from the production registry.
+func x86RawArithmeticLiteralCases() []x86RawArithmeticLiteralCase {
+	var rows []x86RawArithmeticLiteralCase
+	for _, operation := range []struct {
+		name   string
+		opcode byte
+		lane   int
+	}{
+		{"VPADDB", 0xfc, 1}, {"VPADDW", 0xfd, 2}, {"VPADDD", 0xfe, 4}, {"VPADDQ", 0xd4, 8},
+		{"VPADDSB", 0xec, 1}, {"VPADDSW", 0xed, 2}, {"VPADDUSB", 0xdc, 1}, {"VPADDUSW", 0xdd, 2},
+		{"VPSUBB", 0xf8, 1}, {"VPSUBW", 0xf9, 2}, {"VPSUBD", 0xfa, 4}, {"VPSUBQ", 0xfb, 8},
+		{"VPSUBSB", 0xe8, 1}, {"VPSUBSW", 0xe9, 2}, {"VPSUBUSB", 0xd8, 1}, {"VPSUBUSW", 0xd9, 2},
+	} {
+		for _, generation := range []string{"VEX2", "VEX3", "EVEX"} {
+			widths, masks := []int{16, 32}, []int{0}
+			if generation == "EVEX" {
+				widths, masks = []int{16, 32, 64}, []int{0, 3, 7}
+			}
+			for length, width := range widths {
+				for _, mask := range masks {
+					broadcasts := []bool{false}
+					if generation == "EVEX" && operation.lane >= 4 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						row := x86RawArithmeticLiteralCase{op: operation.name, width: width, tuple: width, lane: operation.lane}
+						row.name = fmt.Sprintf("%s%s_%d_%d_%t", operation.name, generation, width, mask, broadcast)
+						row.mask = mask
+						switch generation {
+						case "VEX2":
+							row.code = []byte{0xc5, 0xf9 | byte(length<<2)}
+						case "VEX3":
+							row.code = []byte{0xc4, 0xe1, 0x79 | byte(length<<2)}
+						case "EVEX":
+							w := byte(0)
+							if operation.lane == 8 {
+								w = 0x80
+							}
+							row.code = []byte{0x62, 0xf1, 0x7d | w, 0x08 | byte(length<<5) | byte(mask)}
+							if broadcast {
+								row.code[3] |= 0x10
+								row.op += ".BCST"
+								row.tuple = operation.lane
+							}
+							if mask == 7 {
+								row.code[3] |= 0x80
+								row.op += ".Z"
+							}
+						}
+						row.code = append(row.code, operation.opcode, 0x15, 1, 0, 0, 0, 0xc3)
+						for index := 0; index < row.tuple; index++ {
+							row.code = append(row.code, byte(index*29+11))
+						}
+						rows = append(rows, row)
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawArithmeticLiteralObjects(t *testing.T, triple string) {
+	t.Helper()
+	rows := x86RawArithmeticLiteralCases()
+	if len(rows) != 244 {
+		t.Fatal("incomplete independent add/sub literal directory", len(rows))
+	}
+	programs := make([]x86RawVectorLiteralCase, len(rows))
+	for index, row := range rows {
+		programs[index] = row.x86RawVectorLiteralCase
+	}
+	x86RawVectorLiteralObjects(t, triple, programs)
+}
+
+func TestX86RawArithmeticLiteralLinuxObjects(t *testing.T) {
+	x86RawArithmeticLiteralObjects(t, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86RawArithmeticLiteralDarwinObjects(t *testing.T) {
+	x86RawArithmeticLiteralObjects(t, "x86_64-apple-darwin")
+}
+
+func TestX86RawArithmeticLiteralWindowsObjects(t *testing.T) {
+	x86RawArithmeticLiteralObjects(t, "x86_64-pc-windows-msvc")
+}
+
+func TestX86RawArithmeticLiteralKeepsLaneAndTupleDependencies(t *testing.T) {
+	for _, row := range x86RawArithmeticLiteralCases() {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawVectorLiteralSource(row.x86RawVectorLiteralCase)), "amd64")
+		if err != nil {
+			t.Fatal(row.name, err)
+		}
+		for _, ins := range file.Funcs[0].Instrs {
+			if !ins.x86RIPLiteral {
+				continue
+			}
+			if string(ins.Op) != row.op || !x86RawArithmeticLiteralForm(ins, "amd64") ||
+				ins.x86RIPMemoryRead.source != 0 || ins.x86RIPMemoryRead.width != int64(row.tuple) {
+				t.Fatal("arithmetic literal changed its independent opcode/tuple", row.name)
+			}
+			if x86RawArithmeticLiteralForm(ins, "386") {
+				t.Fatal("mode32 borrowed an AMD64 RIP input", row.name)
+			}
+			address, valid := x86StaticSBReadAddress(ins.Args[0], "amd64")
+			if !valid {
+				t.Fatal("literal lost its DATA identity", row.name)
+			}
+			for _, input := range []int{0, 2} {
+				for missing := -1; missing < row.width; missing++ {
+					state := x86ResultState{flags: 0x3f,
+						loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(row.tuple)}}
+					state.masks[3], state.masks[7] = true, true
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(2, 64, ^uint64(0), false)
+					want := ^uint64(0)
+					if missing >= 0 {
+						state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+						if input == 0 {
+							for at := missing / row.lane * row.lane; at < (missing/row.lane+1)*row.lane; at++ {
+								want &^= uint64(1) << uint(at)
+							}
+						} else if row.mask == 3 {
+							want &^= uint64(1) << uint(missing)
+						}
+					}
+					if accepted, known := x86ResultVectorArithmeticStep(ins, &state, nil, "amd64"); !accepted || !known ||
+						state.vectorBytes(2) != want || state.flags != 0x3f {
+						t.Fatal("arithmetic invented source/merge bytes or changed FLAGS", row.name, input, missing)
+					}
+					state.loweredStaticReads[address]--
+					if accepted, _ := x86ResultVectorArithmeticStep(ins, &state, nil, "amd64"); accepted {
+						t.Fatal("arithmetic accepted an incomplete tuple", row.name)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawArithmeticLiteralKeepsMasksAndSourceBoundaries(t *testing.T) {
+	for _, row := range x86RawArithmeticLiteralCases() {
+		source := x86RawVectorLiteralSource(row.x86RawVectorLiteralCase)
+		changes := []string{
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+		}
+		if row.mask != 0 {
+			changes = append(changes, strings.Replace(source, fmt.Sprintf("KMOVD AX,K%d\n", row.mask), "", 1))
+		}
+		for _, changed := range changes {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, "func "+row.name+"()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("literal waived an independent mask/return obligation", row.name, api, err)
+				}
+			}
+		}
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil || len(file.Data) != 1 {
+			t.Fatal(row.name, err)
+		}
+		if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("standalone query borrowed the arithmetic DATA owner", row.name, err)
+		}
+		file.Data[0].Payload[0] ^= 1
+		options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+			ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+		if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("arithmetic accepted changed original DATA", row.name, err)
+		}
+	}
+}
diff --git a/x86_raw_binary_float_literal_inputs_test.go b/x86_raw_binary_float_literal_inputs_test.go
new file mode 100644
index 000000000..5f60f613c
--- /dev/null
+++ b/x86_raw_binary_float_literal_inputs_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86BinaryFloatLiteralInput(t *testing.T, row x86RawVectorLiteralCase) (*File, Instr) {
+	t.Helper()
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawVectorLiteralSource(row)), "amd64")
+	if err != nil || len(file.Data) != 1 {
+		t.Fatal("binary floating source lost its actual DATA pool", row.name, err)
+	}
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.x86RIPLiteral {
+			// These are intentionally distinct source coordinates: replay
+			// owns the pre-relocation decoder operand; the module read owns
+			// the actual allocated DATA symbol and complete source tuple.
+			pending := Operand{Kind: OpSym, Sym: "·__plan9asm_raw_literal_pending(SB)"}
+			if ins.x86SourceRaw == nil || !reflect.DeepEqual(ins.x86SourceRaw.args[0], pending) ||
+				ins.Args[0].Sym == pending.Sym || ins.Args[0].Sym != ins.x86RIPMemoryRead.symbol {
+				t.Fatal("decoder and module literal coordinates lost their independent binding", row.name)
+			}
+			return file, ins
+		}
+	}
+	t.Fatal("missing original RIP operand", row.name)
+	return nil, Instr{}
+}
+
+func TestX86RawBinaryFloatLiteralEveryInputByteAndTuple(t *testing.T) {
+	for _, row := range x86RawBinaryFloatInitializedLiteralCases(t) {
+		t.Run(row.name, func(t *testing.T) {
+			_, ins := x86BinaryFloatLiteralInput(t, row)
+			base := strings.Split(string(ins.Op), ".")[0]
+			sqrt := strings.HasPrefix(base, "VSQRT")
+			scalar := strings.HasSuffix(base, "SS") || strings.HasSuffix(base, "SD")
+			bits := 32
+			if strings.HasSuffix(base, "PD") || strings.HasSuffix(base, "SD") {
+				bits = 64
+			}
+			width := amd64VectorByteWidth(ins.Args[len(ins.Args)-1].Reg)
+			active, tuple := width, width
+			if scalar {
+				active = bits / 8
+			}
+			if scalar || strings.Contains(string(ins.Op), ".BCST") {
+				tuple = bits / 8
+			}
+			address, valid := x86StaticSBReadAddress(ins.Args[0], "amd64")
+			if !valid || !x86RawBinaryFloatLiteralForm(ins, "amd64") || x86RawBinaryFloatLiteralForm(ins, "386") ||
+				ins.x86RIPMemoryRead.width != int64(tuple) {
+				t.Fatal("typed literal lost its independent source or complete tuple", row.name)
+			}
+			for missing := -1; missing < 64; missing++ {
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+					loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(tuple)}}
+				state.gp[5], state.pointerGP[7], state.callerAddressGP[7], state.masks[7] = 0x53, true, true, true
+				input := ^uint64(0)
+				if missing >= 0 {
+					input &^= uint64(1) << uint(missing)
+				}
+				state.writeVector(0, 64, input, false)
+				before := state // Keep this instruction's transient DATA scope, unlike a CFG clone.
+				accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64")
+				// SQRT's second source only transports scalar upper X bytes;
+				// unknown passthrough stays unknown, not a missing arithmetic input.
+				want := missing < 0 || sqrt || missing >= active
+				if accepted != want {
+					t.Fatal("literal invented a missing binary input byte", row.name, missing, accepted, want)
+				}
+				if want {
+					value := x86CallerVectorByteMask(int64(width))
+					if scalar {
+						required := x86CallerVectorByteMask(int64(active))
+						value = required | input&(0xffff&^required)
+					}
+					before.writeVector(0, width, value, false)
+				}
+				if !reflect.DeepEqual(state, before) {
+					t.Fatal("literal changed FLAGS/addresses or invented passthrough bytes", row.name, missing)
+				}
+			}
+			for _, control := range []string{"short DATA", "missing mask"} {
+				if control == "missing mask" && len(ins.Args) != 4 {
+					continue
+				}
+				state := x86ResultState{loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(tuple)}}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.masks[7] = control != "missing mask"
+				if control == "short DATA" {
+					state.loweredStaticReads[address]--
+				}
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("literal waived an actual DATA or mask input", row.name, control)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawBinaryFloatLiteralSourceAndPublicBoundaries(t *testing.T) {
+	for _, row := range x86RawBinaryFloatInitializedLiteralCases(t) {
+		t.Run(row.name, func(t *testing.T) {
+			file, ins := x86BinaryFloatLiteralInput(t, row)
+			for _, control := range []struct {
+				name string
+				edit func(*Instr)
+			}{
+				{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"original opcode", func(ins *Instr) { ins.x86SourceRaw.op = "VADDPS" }},
+				{"original operand", func(ins *Instr) { ins.x86SourceRaw.args[0].Sym += "changed" }},
+				{"width", func(ins *Instr) { ins.x86VectorBytes++ }},
+				{"encoded", func(ins *Instr) { ins.x86Encoded = false }},
+				{"tuple", func(ins *Instr) { ins.x86RIPMemoryRead.width-- }},
+				{"address", func(ins *Instr) { ins.x86AddressBits = 32 }},
+				{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+			} {
+				changed := cloneX86ReplayInstrs([]Instr{ins})[0]
+				control.edit(&changed)
+				if control.name == "original opcode" && ins.Op == "VADDPS" {
+					changed.x86SourceRaw.op = "VMULPS"
+				}
+				if x86RawBinaryFloatLiteralForm(changed, "amd64") || !x86RawBinaryFloatLiteralForm(ins, "amd64") {
+					t.Fatal("changed literal borrowed or corrupted original identity", row.name, control.name)
+				}
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone declaration acquired a same-module DATA owner", row.name, err)
+			}
+			source := x86RawVectorLiteralSource(row)
+			changes := []string{
+				strings.Replace(source, "$0-0", "$16-0", 1),
+				strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+			}
+			if !strings.HasPrefix(string(ins.Op), "VSQRT") {
+				changes = append(changes, strings.Replace(source, "VPXORD Z0,Z0,Z0\n", "", 1))
+			}
+			if len(ins.Args) == 4 {
+				changes = append(changes, strings.Replace(source, "KMOVD AX,K7\n", "", 1))
+			}
+			for _, changed := range changes {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, "func "+row.name+"()", "amd64", "x86_64-unknown-linux-gnu", api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("literal waived actual inputs or raw return/storage closure", row.name, api, err)
+					}
+				}
+			}
+			file.Data[0].Payload[0] ^= 1
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+				ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("literal accepted changed original DATA", row.name, err)
+			}
+		})
+	}
+}
diff --git a/x86_raw_binary_float_literal_objects_test.go b/x86_raw_binary_float_literal_objects_test.go
new file mode 100644
index 000000000..d5fd47488
--- /dev/null
+++ b/x86_raw_binary_float_literal_objects_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// Cover the complete memory-literal encoding directory independently of the
+// old uninitialized format fixture: six packed/scalar binary operations and
+// scalar square root, both refining precisions, VEX/EVEX widths and broadcast.
+// The existing constructor keeps the original opcode, raw RET and exact pool.
+func x86RawBinaryFloatInitializedLiteralCases(t *testing.T) []x86RawVectorLiteralCase {
+	t.Helper()
+	var rows []x86RawVectorLiteralCase
+	for _, opcode := range []byte{0x51, 0x58, 0x59, 0x5c, 0x5d, 0x5e, 0x5f} {
+		for pp := byte(0); pp < 4; pp++ {
+			if opcode == 0x51 && pp < 2 {
+				continue
+			}
+			for _, evex := range []bool{false, true} {
+				widths := []int{16, 32}
+				if evex {
+					widths = append(widths, 64)
+				}
+				if pp >= 2 {
+					widths = []int{16}
+				}
+				for _, width := range widths {
+					broadcasts := []bool{false}
+					if evex && pp < 2 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						rows = append(rows, x86RawVectorLiteralCase{
+							name: fmt.Sprintf("Literal_%x_%d_%t_%d_%t", opcode, pp, evex, width, broadcast),
+							code: x86RawBinaryFloatLiteral(opcode, pp, evex, width, broadcast),
+						})
+					}
+				}
+			}
+		}
+	}
+	if len(rows) != 124 {
+		t.Fatal("incomplete binary/scalar floating RIP directory", len(rows))
+	}
+	return rows
+}
+
+func TestX86RawBinaryFloatInitializedLiteralLinuxObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-unknown-linux-gnu", x86RawBinaryFloatInitializedLiteralCases(t))
+}
+
+func TestX86RawBinaryFloatInitializedLiteralDarwinObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-apple-darwin", x86RawBinaryFloatInitializedLiteralCases(t))
+}
+
+func TestX86RawBinaryFloatInitializedLiteralWindowsObjects(t *testing.T) {
+	x86RawVectorLiteralObjects(t, "x86_64-pc-windows-msvc", x86RawBinaryFloatInitializedLiteralCases(t))
+}
diff --git a/x86_raw_broadcast_origin_test.go b/x86_raw_broadcast_origin_test.go
new file mode 100644
index 000000000..9d53eaa19
--- /dev/null
+++ b/x86_raw_broadcast_origin_test.go
@@ -0,0 +1,348 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawBroadcastOriginCase struct {
+	row, source, bank string
+	bytes, lane       int
+	masked, zero      bool
+}
+
+// Expand the independent twenty-name Go encoder directory, not production
+// registry keys. Memory, X, GP and K-data sources retain distinct roles even
+// when their canonical spelling happens to select the same destination bank.
+func x86RawBroadcastOriginCases() []x86RawBroadcastOriginCase {
+	var rows []x86RawBroadcastOriginCase
+	for _, spec := range x86BroadcastTestDirectory {
+		var sources []string
+		if spec.source == "K" {
+			sources = []string{"K1"}
+		} else {
+			sources = []string{"(SI)"}
+			if strings.Contains(spec.source, "X") {
+				sources = append(sources, "X1")
+			}
+			if strings.Contains(spec.source, "G") {
+				sources = append(sources, "AX")
+			}
+		}
+		for _, bank := range spec.destinations {
+			for _, source := range sources {
+				for _, mask := range []string{"", "merge", "zero"} {
+					if mask != "" && (spec.source == "K" || spec.table == "_yvbroadcastf128") {
+						continue
+					}
+					name, operands := spec.name, source+","
+					if mask != "" {
+						operands += "K3,"
+					}
+					if mask == "zero" {
+						name += ".Z"
+					}
+					rows = append(rows, x86RawBroadcastOriginCase{
+						row: name + " " + operands + string(bank) + "2", source: source,
+						bank: string(bank), bytes: spec.bytes, lane: spec.lane,
+						masked: mask != "", zero: mask == "zero",
+					})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawBroadcastOriginBytes(t *testing.T, rows []x86RawBroadcastOriginCase) [][]byte {
+	t.Helper()
+	var body strings.Builder
+	for _, row := range rows {
+		body.WriteString(row.row + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String()+"RET")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("incomplete independent original Go broadcast bytes/PCs")
+	}
+	result := make([][]byte, len(rows))
+	for index := range rows {
+		result[index] = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+	}
+	return result
+}
+
+func x86RawBroadcastOriginSource(row x86RawBroadcastOriginCase, code []byte, arch, control string, dead bool) (string, string) {
+	word, move, suffix := goWordSize(arch), "MOVQ", "Q"
+	if arch == "386" {
+		move, suffix = "MOVL", "L"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Broadcast(SB),4,$0-%d\n", 3*word+16)
+	if control == "numeric address" {
+		source.WriteString("MOVL $42,SI\n")
+	} else if control != "address" {
+		fmt.Fprintf(&source, "%s a+0(FP),SI\n", move)
+	}
+	fmt.Fprintf(&source, "%s old+%d(FP),BX\n%s out+%d(FP),DI\n", move, word, move, 2*word)
+	if control != "mask" {
+		fmt.Fprintf(&source, "KMOVQ mask+%d(FP),K3\n", 3*word)
+	}
+	if control != "first" || row.source != "AX" {
+		fmt.Fprintf(&source, "%s scalar+%d(FP),AX\n", move, 3*word+8)
+	}
+	if control != "first" || row.source != "K1" {
+		fmt.Fprintf(&source, "KMOVQ scalar+%d(FP),K1\n", 3*word+8)
+	}
+	if row.source == "X1" && control != "first" {
+		source.WriteString("VMOVUPS (SI),Z1\n")
+	}
+	if control != "merge" {
+		source.WriteString("VMOVUPS (BX),Z2\n")
+	}
+	// Defined status and DF survive all broadcast forms. Keep the original
+	// opcode between the producer and the adjacent defined-only observation.
+	// Unused Go results must not erase its input or native access obligations.
+	source.WriteString("MOVL $3,CX\nCMPL CX,$3\nSTD\n")
+	if control == "named" {
+		source.WriteString(row.row + "\n")
+	} else {
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+	}
+	if !dead {
+		source.WriteString("VMOVUPS Z2,(DI)\n")
+		if row.source == "X1" {
+			source.WriteString("VMOVUPS Z1,64(DI)\n")
+		}
+	}
+	fmt.Fprintf(&source, "PUSHF%s\nPOP%s CX\nANDL $0xcd5,CX\nMOVL CX,128(DI)\nCLD\nRET\n", suffix, suffix)
+	return source.String(), "func Broadcast(a,old,out *[144]byte,mask,scalar uint64)\n"
+}
+
+func x86RawBroadcastUnusedBoolSource(source, declaration, arch string) (string, string) {
+	extent := 3*goWordSize(arch) + 16
+	source = strings.Replace(source, fmt.Sprintf("$0-%d\n", extent), fmt.Sprintf("$0-%d\n", extent+1), 1)
+	declaration = strings.Replace(declaration, "scalar uint64)", "scalar uint64,unused bool)", 1)
+	return source, declaration
+}
+
+func TestX86RawBroadcastCompleteIndependentOriginDirectory(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	if len(rows) != 212 {
+		t.Fatal("complete scalar/block/K-data broadcast directory changed", len(rows))
+	}
+	seen, sources := make(map[string]bool), make(map[string]int)
+	for _, row := range rows {
+		if seen[row.row] {
+			t.Fatal("duplicate independent broadcast row", row.row)
+		}
+		seen[row.row], sources[row.source] = true, sources[row.source]+1
+	}
+	if sources["(SI)"] != 104 || sources["X1"] != 66 || sources["AX"] != 36 || sources["K1"] != 6 {
+		t.Fatal("independent source-role matrix changed", sources)
+	}
+	code := x86RawBroadcastOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, code[index])
+				form, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+				bytes, lane := row.bytes, row.lane
+				if arch == "386" && strings.HasPrefix(row.row, "VPBROADCASTQ") && row.source == "AX" {
+					bytes, lane = 4, 4 // GP-only opcode 7C physically ignores W in mode32.
+				}
+				if !known || err != nil || string(ins.Op) != strings.Fields(row.row)[0] ||
+					form.sourceBytes != bytes || form.laneBits != lane*8 ||
+					form.byteWidth != map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank] ||
+					(form.mask >= 0) != row.masked || form.zeroing != row.zero ||
+					ins.Args[form.destination].Reg != Reg(row.bank+"2") ||
+					(row.source == "(SI)") != (ins.Args[0].Kind == OpMem) ||
+					(row.source != "(SI)" && ins.Args[0].Reg != Reg(row.source)) {
+					t.Fatal("original Go bytes lost their complete independent typed broadcast roles", err)
+				}
+			})
+		}
+	}
+}
+
+const x86RawBroadcastOriginBatchSize = 32
+
+// These controls use exactly the same pointers, numeric scalar/K inputs,
+// complete old vector, output views and defined FLAGS/DF observation. Only the
+// broadcast representation changes, so a raw whole-source diagnostic at a
+// preceding named VMOVUPS cannot establish that load as the actual cause.
+func TestX86RawBroadcastSameSourceNamedControls(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	for start := 0; start < len(rows); start += x86RawBroadcastOriginBatchSize {
+		end := start + x86RawBroadcastOriginBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint(start/x86RawBroadcastOriginBatchSize), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows[start:end] {
+				body, declaration := x86RawBroadcastOriginSource(row, nil, "amd64", "named", false)
+				name := fmt.Sprint("Broadcast", start+index)
+				source.WriteString(strings.ReplaceAll(body, "Broadcast", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Broadcast", name))
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("same-source named broadcast lost initialized inputs, native views or defined FLAGS/DF", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawBroadcastInitializedFiveTargetsBatch00(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 0)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch01(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 1)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch02(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 2)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch03(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 3)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch04(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 4)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch05(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 5)
+}
+func TestX86RawBroadcastInitializedFiveTargetsBatch06(t *testing.T) {
+	x86RawBroadcastOriginObjectBatch(t, 6)
+}
+
+func x86RawBroadcastOriginObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	rows := x86RawBroadcastOriginCases()
+	start, end := batch*x86RawBroadcastOriginBatchSize, (batch+1)*x86RawBroadcastOriginBatchSize
+	if start < 0 || start >= len(rows) {
+		t.Fatal("invalid original broadcast object batch", batch)
+	}
+	if end > len(rows) {
+		end = len(rows)
+	}
+	rows = rows[start:end]
+	code := x86RawBroadcastOriginBytes(t, rows)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				body, declaration := x86RawBroadcastOriginSource(row, code[index], target.arch, "", false)
+				name := fmt.Sprint("Broadcast", start+index)
+				source.WriteString(strings.ReplaceAll(body, "Broadcast", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Broadcast", name))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original broadcast cannot compose with native views and defined FLAGS/DF", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "broadcast-origin.ll", "broadcast-origin.o", body)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawBroadcastVoidAndUnusedBoolCannotBorrowInputs(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	code := x86RawBroadcastOriginBytes(t, rows)
+	for index, row := range rows {
+		for _, control := range []string{"first", "merge", "mask", "address", "numeric address"} {
+			if control == "first" && row.source == "(SI)" || control == "merge" && (!row.masked || row.zero) ||
+				control == "mask" && !row.masked ||
+				(control == "address" || control == "numeric address") && row.source != "(SI)" {
+				continue
+			}
+			t.Run(row.row+"/"+control, func(t *testing.T) {
+				for _, arch := range []string{"386", "amd64"} {
+					for _, dead := range []bool{false, true} {
+						source, declaration := x86RawBroadcastOriginSource(row, code[index], arch, control, dead)
+						for _, unused := range []bool{false, true} {
+							body, decl := source, declaration
+							if unused {
+								body, decl = x86RawBroadcastUnusedBoolSource(body, decl, arch)
+							}
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, body, decl, arch, x86AddressMemoryTargets(arch)[0], api)
+								if control == "numeric address" {
+									x86RequireNumericNativeSourceContext(t, body, decl, arch)
+									read := fmt.Sprintf("load volatile <%d x i8>", row.bytes)
+									if row.masked && row.bytes > row.lane {
+										read = fmt.Sprintf("load volatile i%d,", row.lane*8)
+									}
+									if err != nil || !strings.Contains(ir, read) {
+										t.Fatal("numerical address lost the broadcast's exact scalar/block read", arch, dead, unused, api, err)
+									}
+									x86NumericNativeAddressObject(t, ir, x86AddressMemoryTargets(arch)[0])
+								} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("dead/unused-bool broadcast acquired missing scalar, vector, mask, old result or native pointer facts", arch, dead, unused, api, err)
+								}
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+// Legal storage extent is an independent positive, not an accidental negative
+// caused by appending a bool to the declaration without updating TEXT.
+func TestX86RawBroadcastInitializedUnusedBoolAndDeadAllSourceForms(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	code := x86RawBroadcastOriginBytes(t, rows)
+	for start := 0; start < len(rows); start += x86RawBroadcastOriginBatchSize {
+		end := start + x86RawBroadcastOriginBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint(start/x86RawBroadcastOriginBatchSize), func(t *testing.T) {
+			for _, target := range x86RawReturnTargets {
+				t.Run(target.triple, func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows[start:end] {
+						for _, dead := range []bool{false, true} {
+							body, declaration := x86RawBroadcastOriginSource(row, code[start+index], target.arch, "", dead)
+							body, declaration = x86RawBroadcastUnusedBoolSource(body, declaration, target.arch)
+							name := fmt.Sprintf("Broadcast%dDead%t", start+index, dead)
+							source.WriteString(strings.ReplaceAll(body, "Broadcast", name))
+							declarations.WriteString(strings.ReplaceAll(declaration, "Broadcast", name))
+						}
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("unused bool or dead output changed a completely initialized original broadcast", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_raw_broadcast_result_test.go b/x86_raw_broadcast_result_test.go
new file mode 100644
index 000000000..ccfb2f37f
--- /dev/null
+++ b/x86_raw_broadcast_result_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawBroadcastResultCase struct {
+	name string
+	code []byte
+}
+
+// Independent physical witnesses cover all scalar integer/float VEX and EVEX
+// widths, no mask / merge / zero, plus both VEX 128-bit block broadcasts.
+func x86RawBroadcastResultCases() []x86RawBroadcastResultCase {
+	var rows []x86RawBroadcastResultCase
+	for _, encoding := range []string{"VEX", "EVEX"} {
+		for _, width := range []int{128, 256, 512} {
+			for _, mask := range []int{0, 3, 7} {
+				if encoding == "VEX" && (width == 512 || mask != 0) {
+					continue
+				}
+				for _, op := range []Op{"VPBROADCASTB", "VPBROADCASTW", "VPBROADCASTD", "VPBROADCASTQ", "VBROADCASTSS", "VBROADCASTSD"} {
+					if op == "VBROADCASTSD" && width == 128 {
+						continue
+					}
+					var code []byte
+					if strings.HasPrefix(string(op), "VP") {
+						code, _ = x86RawBroadcastLiteral(op, encoding, width, mask, mask == 7)
+					} else {
+						code, _ = x86RawScalarFloatBroadcastLiteral(op == "VBROADCASTSD", encoding == "EVEX", width, mask, mask == 7)
+					}
+					rows = append(rows, x86RawBroadcastResultCase{
+						name: fmt.Sprintf("%s_%s_%d_%d", op, encoding, width, mask), code: code,
+					})
+				}
+			}
+		}
+	}
+	return append(rows,
+		x86RawBroadcastResultCase{"VBROADCASTF128", x86RawVBROADCASTF128Literal()},
+		x86RawBroadcastResultCase{"VBROADCASTI128", x86RawVBROADCASTI128Literal()},
+	)
+}
+
+func x86RawBroadcastResultSource(row x86RawBroadcastResultCase, initialized bool) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", row.name)
+	if initialized {
+		source.WriteString("MOVL $5,AX\nKMOVD AX,K3\nKMOVD AX,K7\nVPXORD Z0,Z0,Z0\nVPXORD Z2,Z2,Z2\n")
+	}
+	for _, value := range row.code {
+		fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+	}
+	return source.String()
+}
+
+func TestX86RawBroadcastLiteralInitializedCompleteFamily(t *testing.T) {
+	rows := x86RawBroadcastResultCases()
+	if len(rows) != 64 {
+		t.Fatal("independent literal family changed", len(rows))
+	}
+	var source, declarations strings.Builder
+	for _, row := range rows {
+		source.WriteString(x86RawBroadcastResultSource(row, true))
+		fmt.Fprintf(&declarations, "func %s()\n", row.name)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // RIP-relative addressing is an actual mode64 encoding role.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("source-local broadcast lost exact literal/mask/merge inputs", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawBroadcastLiteralKeepsMissingInputsAndSourceIdentity(t *testing.T) {
+	for _, row := range x86RawBroadcastResultCases() {
+		source := x86RawBroadcastResultSource(row, true)
+		declaration := "func " + row.name + "()"
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("standalone declaration query acquired a source-literal role", row.name, err)
+		}
+		for _, instruction := range file.Funcs[0].Instrs {
+			if !instruction.x86RIPLiteral {
+				continue
+			}
+			if instruction.Args[0].Kind == OpImm {
+				instruction.Args[0].Imm ^= 1
+			} else {
+				instruction.Args[0].Sym += "changed"
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+				ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed normalized literal borrowed original source", row.name, err)
+			}
+			break
+		}
+		if !strings.HasSuffix(row.name, "_3") && !strings.HasSuffix(row.name, "_7") {
+			continue
+		}
+		variants := []string{
+			x86RawBroadcastResultSource(row, false),
+			strings.NewReplacer("KMOVD AX,K3\n", "", "KMOVD AX,K7\n", "").Replace(source),
+		}
+		if strings.HasSuffix(row.name, "_3") {
+			variants = append(variants, strings.NewReplacer("VPXORD Z0,Z0,Z0\n", "", "VPXORD Z2,Z2,Z2\n", "").Replace(source))
+		}
+		for _, changed := range variants {
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration,
+					"amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("constant input invented a missing mask or merge vector", row.name, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawBroadcastLiteralKeepsReturnAndDataBoundaries(t *testing.T) {
+	for _, row := range x86RawBroadcastResultCases() {
+		source := x86RawBroadcastResultSource(row, true)
+		declaration := "func " + row.name + "()"
+		for _, changed := range []string{
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "MOVL $5,AX", "MOVQ $0,SP\nMOVL $5,AX", 1),
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("literal broadcast waived an independent raw-return frame", row.name, api, err)
+				}
+			}
+		}
+		if !strings.HasSuffix(row.name, "128") {
+			continue // Only the block forms materialize a separate DATA object.
+		}
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil || len(file.Data) != 1 {
+			t.Fatal("block literal lost its actual data object", row.name, err)
+		}
+		file.Data[0].Payload[0] ^= 1
+		options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+			ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+		if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("changed DATA borrowed the original literal bytes", row.name, err)
+		}
+	}
+}
diff --git a/x86_raw_broadcast_state_test.go b/x86_raw_broadcast_state_test.go
new file mode 100644
index 000000000..e518a8b8a
--- /dev/null
+++ b/x86_raw_broadcast_state_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func x86RawBroadcastInitializedState() x86ResultState {
+	state := x86RawMoveInitializedState()
+	state.pointerGP[6], state.callerAddressGP[6] = true, true // The independent ordinary source is SI.
+	return state
+}
+
+func TestX86RawBroadcastEveryInputByteAndIndependentState(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	code := x86RawBroadcastOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for ordinal, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, code[ordinal])
+				width, inputBytes := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank], row.bytes
+				if arch == "386" && row.source == "AX" && row.bytes == 8 {
+					inputBytes = 4 // The original opcode 7C/W1 has a physical r32 input here.
+				}
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						state := x86RawBroadcastInitializedState()
+						if missing >= 0 {
+							state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+						}
+						before, expected := state.clone(), state.clone()
+						wanted := !(missing >= 0 && (input == 1 && row.source == "X1" && missing < inputBytes ||
+							input == 2 && row.masked && !row.zero && missing < 16))
+						if wanted {
+							defined := ^uint64(0)
+							if row.masked && !row.zero {
+								// Existing typed effects retain unknown inactive upper
+								// bytes, rather than initializing an unobserved alias.
+								defined &= state.vectorBytes(2)
+							}
+							expected.writeVector(2, width, defined, false)
+						}
+						accepted, known := x86LoweredRawBroadcastStep(ins, &state, nil, arch)
+						if !known || accepted != wanted || wanted && !reflect.DeepEqual(state, expected) ||
+							!wanted && !reflect.DeepEqual(state, before) {
+							t.Fatal("raw broadcast invented a scalar/block/old byte, changed independent state or partially committed rejection", input, missing, accepted, wanted)
+						}
+					}
+				}
+				if row.source == "AX" {
+					for missing := -1; missing < 8; missing++ {
+						state := x86RawBroadcastInitializedState()
+						if missing >= 0 {
+							state.gp[0] &^= uint8(1) << uint(missing)
+						}
+						before, expected := state.clone(), state.clone()
+						wanted := missing < 0 || missing >= inputBytes
+						if wanted {
+							expected.writeVector(2, width, ^uint64(0), false)
+						}
+						accepted, known := x86LoweredRawBroadcastStep(ins, &state, nil, arch)
+						if !known || accepted != wanted || wanted && !reflect.DeepEqual(state, expected) ||
+							!wanted && !reflect.DeepEqual(state, before) {
+							t.Fatal("raw broadcast consumed the wrong physical GP bytes or changed independent state", missing, accepted, wanted)
+						}
+					}
+				}
+				for _, control := range []string{"mask", "K data", "native address", "GP pointer"} {
+					if control == "mask" && !row.masked || control == "K data" && row.source != "K1" ||
+						control == "native address" && row.source != "(SI)" || control == "GP pointer" && row.source != "AX" {
+						continue
+					}
+					state := x86RawBroadcastInitializedState()
+					switch control {
+					case "mask":
+						state.masks[3] = false
+					case "K data":
+						state.masks[1] = false
+					case "native address":
+						state.pointerGP[6] = false // Complete numerical SI supplies only the paired access.
+					case "GP pointer":
+						state.pointerGP[0] = true // Opaque pointer AX is not numerical scalar input.
+					}
+					before := state.clone()
+					if accepted, known := x86LoweredRawBroadcastStep(ins, &state, nil, arch); !known || accepted != (control == "native address") || !reflect.DeepEqual(state, before) {
+						t.Fatal("raw broadcast borrowed an independent input role", control)
+					}
+					if control == "native address" {
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[6] = available
+							unchanged := partial.clone()
+							if accepted, _ := x86LoweredRawBroadcastStep(ins, &partial, nil, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("raw broadcast acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawBroadcastEditedOriginRejectsAtomically(t *testing.T) {
+	rows := x86RawBroadcastOriginCases()
+	code := x86RawBroadcastOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for ordinal, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, code[ordinal])
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"opcode", func(ins *Instr) { ins.Op = "VPBROADCASTB" }},
+					{"operand", func(ins *Instr) {
+						if row.source == "(SI)" {
+							ins.Args[0].Mem.Off++
+						} else {
+							ins.Args[0].Reg = "DX"
+						}
+					}},
+					{"destination", func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = Reg(row.bank + "4") }},
+					{"source opcode", func(ins *Instr) { ins.x86SourceRaw.op = "MOVL" }},
+					{"source operand", func(ins *Instr) { ins.x86SourceRaw.args[0] = Operand{} }},
+					{"vector width", func(ins *Instr) { ins.x86VectorBytes += 16 }},
+					{"source width", func(ins *Instr) { ins.x86SourceRaw.vectorBytes += 16 }},
+					{"address width", func(ins *Instr) { ins.x86AddressBits = 16 }},
+					{"address override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+					{"raw return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+					{"numerical certificate", func(ins *Instr) { ins.x86NumericalRead = new(x86NumericalReadCertificate) }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					control.edit(&changed)
+					// Make the opcode mutation real for the B member as well.
+					if control.name == "opcode" && original.Op == changed.Op {
+						changed.Op = "VPBROADCASTW"
+					}
+					state := x86RawBroadcastInitializedState()
+					before := state.clone()
+					if accepted, _ := x86LoweredRawBroadcastStep(changed, &state, nil, arch); accepted ||
+						x86RawBroadcastSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited raw broadcast acquired or partially committed a typed/native effect", control.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_byte_shift_literal_result_test.go b/x86_raw_byte_shift_literal_result_test.go
new file mode 100644
index 000000000..b8ac14af6
--- /dev/null
+++ b/x86_raw_byte_shift_literal_result_test.go
@@ -0,0 +1,144 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawByteShiftLiteralBytes(left bool, width, destination, count int) []byte {
+	code := encodeX86RawVectorByteShift(left, true, width, 0, destination, byte(count))
+	code[len(code)-2] = code[len(code)-2]&0x38 | 0x05
+	code = append(code[:len(code)-1], 1, 0, 0, 0, byte(count), 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*19+9))
+	}
+	return code
+}
+
+func x86RawByteShiftLiteralSource(name string, code []byte) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", name)
+	for _, value := range code {
+		fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+	}
+	return source.String()
+}
+
+// Go's _yvpslldq has register-only VEX rows and three EVEX memory rows.
+// These original mode64 bytes cover both directions, all memory tuple widths,
+// low/high destinations and the lane/zero boundary counts. The full byte
+// selector domain is independently checked below, without a giant LLVM module.
+func TestX86RawByteShiftLiteralCompleteObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	rows := 0
+	for _, left := range []bool{false, true} {
+		for _, width := range []int{16, 32, 64} {
+			for _, destination := range []int{0, 31} {
+				for _, count := range []int{0, 1, 7, 15, 16, 17, 255} {
+					name := fmt.Sprintf("Shift%d", rows)
+					rows++
+					source.WriteString(x86RawByteShiftLiteralSource(name, x86RawByteShiftLiteralBytes(left, width, destination, count)))
+					fmt.Fprintf(&declarations, "func %s()\n", name)
+				}
+			}
+		}
+	}
+	if rows != 84 {
+		t.Fatal("incomplete independent shift directory", rows)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("exact byte-shift literal tuple was lost", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawByteShiftLiteralEverySelectorAndExtent(t *testing.T) {
+	for _, left := range []bool{false, true} {
+		for _, width := range []int{16, 32, 64} {
+			for count := 0; count < 256; count++ {
+				code := x86RawByteShiftLiteralBytes(left, width, 31, count)
+				decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "Shift", map[string]bool{})
+				if err != nil || len(decoded) != 2 {
+					t.Fatal("complete physical literal failed to decode", left, width, count, err)
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawByteShiftLiteralSource("Shift", code)), "amd64")
+				if err != nil || len(file.Funcs[0].Instrs) != 3 || file.Funcs[0].Instrs[0].Op != OpTEXT ||
+					file.Funcs[0].Instrs[2].Op != OpRET {
+					t.Fatal("literal lost its complete source replay", left, width, count, err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, known, err := x86PackedShiftProperties(ins.Op, ins, "amd64")
+				if !known || err != nil || form.memoryBytes != width || form.countOperand.Imm != int64(count) ||
+					form.countMode != x86PackedShiftBytes || form.left != left || !x86RawByteShiftLiteralForm(ins, "amd64") ||
+					x86RawByteShiftLiteralForm(ins, "386") {
+					t.Fatal("literal/selector changed its typed identity", left, width, count, err)
+				}
+				address, valid := x86StaticSBReadAddress(ins.Args[1], "amd64")
+				if !valid {
+					t.Fatal("literal has no DATA address")
+				}
+				state := x86ResultState{flags: 0x3f, loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(width)}}
+				if accepted, known := x86ResultPackedShiftStep(ins, &state, nil, "amd64"); !accepted || !known ||
+					state.vectorBytes(31) != ^uint64(0) || state.flags != 0x3f {
+					t.Fatal("exact constant did not define output bytes", left, width, count)
+				}
+				state.loweredStaticReads[address]--
+				if accepted, _ := x86ResultPackedShiftStep(ins, &state, nil, "amd64"); accepted {
+					t.Fatal("even a saturating count requires the entire memory tuple", left, width, count)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawByteShiftLiteralKeepsSourceAndReturnBoundaries(t *testing.T) {
+	for _, left := range []bool{false, true} {
+		for _, width := range []int{16, 32, 64} {
+			source := x86RawByteShiftLiteralSource("Shift", x86RawByteShiftLiteralBytes(left, width, 0, 255))
+			for _, changed := range []string{
+				strings.Replace(source, "$0-0", "$16-0", 1),
+				strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, changed, "func Shift()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("constant-zero result waived a raw-return frame", left, width, api, err)
+					}
+				}
+			}
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+			if err != nil || len(file.Data) != 1 {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: "Shift", Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone query borrowed the lowering-only DATA owner", left, width, err)
+			}
+			file.Data[0].Payload[0] ^= 1
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:       map[string]FuncSig{"Shift": {Name: "Shift", Ret: Void}},
+				ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("constant-zero result waived changed original DATA", left, width, err)
+			}
+		}
+	}
+}
diff --git a/x86_raw_compact_input_test.go b/x86_raw_compact_input_test.go
new file mode 100644
index 000000000..f412eca96
--- /dev/null
+++ b/x86_raw_compact_input_test.go
@@ -0,0 +1,255 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86RawCompactInputObjects(t *testing.T, bank string, expand bool) {
+	t.Helper()
+	members := []string{"VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ", "VCOMPRESSPS", "VCOMPRESSPD"}
+	if expand {
+		members = []string{"VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ", "VEXPANDPS", "VEXPANDPD"}
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, member := range members {
+				for _, memory := range []bool{false, true} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if memory && !expand && mode == "zero" {
+							continue // Reserved EVEX.z memory stores have their own #UD oracle.
+						}
+						op, mask := member, ""
+						if mode != "plain" {
+							mask = "K1,"
+						}
+						if mode == "zero" {
+							op += ".Z"
+						}
+						first, last := bank+"2", bank+"3"
+						if memory {
+							if expand {
+								first = "1(SI)"
+							} else {
+								last = "1(DI)"
+							}
+						}
+						row := op + " " + first + "," + mask + last
+						// The low-bank bytes have the same physical meaning in both
+						// modes; Go's named frontend is not the raw decoder oracle.
+						literal := x86RawNumericalInstruction(t, "amd64", row)
+						name := fmt.Sprint("Compact", count)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n"+
+							"MOV%s out+0(FP),DI\nMOV%s input+%d(FP),SI\nMOV%s old+%d(FP),BX\n"+
+							"VMOVUPS (SI),Z2\nVMOVUPS (BX),Z3\nKXNORQ K1,K1,K1\n"+
+							"%s\nVMOVUPS Z3,65(DI)\nRET\n", name, 3*word,
+							suffix, suffix, word, suffix, 2*word, literal)
+						fmt.Fprintf(&declarations, "func %s(out *[144]byte,input,old *[64]byte)\n", name)
+						count++
+					}
+				}
+			}
+			want := 30
+			if expand {
+				want = 36
+			}
+			if count != want {
+				t.Fatal("independent full raw compact/expand inventory changed", count, want)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86RawCompressCompleteXInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "X", false)
+}
+
+func TestX86RawCompressCompleteYInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "Y", false)
+}
+
+func TestX86RawCompressCompleteZInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "Z", false)
+}
+
+func TestX86RawExpandCompleteXInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "X", true)
+}
+
+func TestX86RawExpandCompleteYInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "Y", true)
+}
+
+func TestX86RawExpandCompleteZInputObjects(t *testing.T) {
+	x86RawCompactInputObjects(t, "Z", true)
+}
+
+func TestX86RawCompactPhysicalMode32Masks(t *testing.T) {
+	count := 0
+	for _, member := range []string{
+		"VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ", "VCOMPRESSPS", "VCOMPRESSPD",
+		"VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ", "VEXPANDPS", "VEXPANDPD",
+	} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for mask := 1; mask <= 7; mask++ {
+				row := fmt.Sprintf("%s %s2,K%d,%s3", member, bank, mask, bank)
+				literal := x86RawNumericalInstruction(t, "amd64", row)
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+literal+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, "386")
+				if err != nil {
+					t.Fatal("valid physical low-bank encoding inherited a named frontend limit", row, err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				form, known, err := x86PackedCompactProperties(ins.Op, ins, "386")
+				if !known || err != nil || form.mask != 1 || ins.Args[1].Reg != Reg(fmt.Sprint("K", mask)) {
+					t.Fatal("raw mask/operand identity changed", row, form, err)
+				}
+				count++
+			}
+		}
+	}
+	if count != 252 {
+		t.Fatal("complete physical compact mask inventory changed", count)
+	}
+}
+
+func TestX86RawCompactDeadInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, member := range []string{
+		"VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ", "VCOMPRESSPS", "VCOMPRESSPD",
+		"VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ", "VEXPANDPS", "VEXPANDPD",
+	} {
+		for _, memory := range []bool{false, true} {
+			first, last := "X2", "X3"
+			if memory {
+				if strings.Contains(member, "EXPAND") {
+					first = "(SI)"
+				} else {
+					last = "(DI)"
+				}
+			}
+			literal := x86RawNumericalInstruction(t, "amd64", member+" "+first+",K1,"+last)
+			for _, target := range x86RawReturnTargets {
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						source := "TEXT ·Value(SB),4,$0\n" + literal + "RET\n"
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw compact inputs borrowed an implementation zero", target, member, memory, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawCompactOriginalIdentityAndEveryInputByte(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86CompactExpandResultMembers {
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				for _, mode := range []string{"merge", "zero"} {
+					t.Run(arch+"/"+member+"/"+width.bank+"/"+mode, func(t *testing.T) {
+						op := member
+						if mode == "zero" {
+							op += ".Z"
+						}
+						row := fmt.Sprintf("%s %s2,K1,%s3", op, width.bank, width.bank)
+						literal := x86RawNumericalInstruction(t, "amd64", row)
+						file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+literal+"RET\n")
+						if err != nil {
+							t.Fatal(err)
+						}
+						file, err = normalizeX86RawFile(file, arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.masks[1] = true
+						state.writeVector(2, 64, ^uint64(0), false)
+						state.writeVector(4, 64, ^uint64(0), false)
+						if mode == "merge" {
+							state.writeVector(3, 64, ^uint64(0), false)
+						}
+						before := state.clone()
+						if accepted, known := x86ResultCompactExpandMemoryStep(ins, &state, nil, 0, arch, true); !known || !accepted {
+							t.Fatal("complete physical inputs lost their paired continuation", row)
+						}
+						expected := before.clone()
+						expected.writeVector(3, width.bytes, x86CallerVectorByteMask(int64(width.bytes)), false)
+						if !reflect.DeepEqual(state, expected) {
+							t.Fatal("raw compact changed unrelated state or failed to clear wider aliases")
+						}
+						strict := before.clone()
+						if accepted, known := x86ResultCompactExpandMemoryStep(ins, &strict, nil, 0, arch, false); !known || accepted || !reflect.DeepEqual(strict, before) {
+							t.Fatal("standalone observer borrowed a lowering-only raw view")
+						}
+						for _, input := range []int{2, 3} {
+							if input == 3 && mode == "zero" {
+								continue // Zeroing does not consume old merge bytes.
+							}
+							for missing := 0; missing < width.bytes; missing++ {
+								current := before.clone()
+								current.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+								initial := current.clone()
+								if accepted, known := x86ResultCompactExpandMemoryStep(ins, &current, nil, 0, arch, true); !known || accepted || !reflect.DeepEqual(current, initial) {
+									t.Fatal("raw compact consumed a missing input byte", input, missing)
+								}
+							}
+						}
+						for _, mutation := range []string{"mask", "record", "opcode", "operand", "vector-width", "address-size", "override", "segment", "RIP"} {
+							changed, current := ins, before.clone()
+							changed.Args = append([]Operand(nil), ins.Args...)
+							switch mutation {
+							case "mask":
+								current.masks[1] = false
+							case "record":
+								// Keep an encoded origin while removing its record.
+								// Removing both denotes an ordinary valid named row.
+								changed.x86Encoded = true
+								changed.x86SourceRaw = nil
+							case "opcode":
+								changed.Op = Op(member + ".Z")
+								if mode == "zero" {
+									changed.Op = Op(member)
+								}
+							case "operand":
+								changed.Args[0].Reg = Reg(width.bank + "4")
+							case "vector-width":
+								changed.x86VectorBytes ^= 16
+							case "address-size":
+								changed.x86AddressBits = 16
+							case "override":
+								changed.x86UnboundAddressOverride = true
+							case "segment":
+								changed.x86SegmentPrefix = 0x64
+							case "RIP":
+								changed.x86RIPLiteral = true
+							}
+							initial := current.clone()
+							if accepted, known := x86ResultCompactExpandMemoryStep(changed, &current, nil, 0, arch, true); !known || accepted || !reflect.DeepEqual(current, initial) {
+								t.Fatal("unbound raw origin or mask changed numerical state", mutation)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_extend_original_inputs_test.go b/x86_raw_extend_original_inputs_test.go
new file mode 100644
index 000000000..9ce716913
--- /dev/null
+++ b/x86_raw_extend_original_inputs_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawExtendOriginalInputSource(t *testing.T, block bool) string {
+	t.Helper()
+	name := "TestTranslateRawEVEXPackedExtendWeaviateRegression"
+	want := "a5c6fa0843f6aa5ce29bd383ca176aa4c00ab8316c9886efb214d3b9ac6447cb"
+	if block {
+		name = "TestTranslateRawVEXPackedExtendWeaviateBlockRegression"
+		want = "c16c5124003d8cf18163d034586f7676da643493c7f4c58fab043a88676e74c3"
+	}
+	source := x86X87FunctionLiteral(t, "amd64_raw_packed_extend_test.go", name, "source")
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != want {
+		t.Fatal("original complete packed-extend block changed", name)
+	}
+	return source
+}
+
+func TestX86RawExtendOriginalMissingInputsRemainContext(t *testing.T) {
+	for _, block := range []bool{false, true} {
+		source := x86RawExtendOriginalInputSource(t, block)
+		file := mustParseX86RawReturn(t, source)
+		if len(file.Funcs) != 1 {
+			t.Fatal("original packed-extend entry lost its identity")
+		}
+		name := file.Funcs[0].Sym
+		for _, target := range x86RawReturnTargets {
+			t.Run(fmt.Sprintf("block=%t/%s", block, target.triple), func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func "+name+"()", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original bare block invented its native address/vector inputs", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawExtendOriginalInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, block := range []bool{false, true} {
+		original := x86RawExtendOriginalInputSource(t, block)
+		header, body, found := strings.Cut(original, "\n")
+		if !found || !strings.Contains(header, "$0-0") {
+			t.Fatal("original complete packed-extend source lost its TEXT")
+		}
+		name := mustParseX86RawReturn(t, original).Funcs[0].Sym
+		for _, target := range x86RawReturnTargets {
+			t.Run(fmt.Sprintf("block=%t/%s", block, target.triple), func(t *testing.T) {
+				word, move := 8, "MOVQ"
+				if target.arch == "386" {
+					word, move = 4, "MOVL"
+				}
+				// Keep every original opcode and RET. Only this distinct
+				// counterpart imports the missing SI/DI pointers, defines the
+				// actual AX index and initializes all vector accumulators.
+				prefix := fmt.Sprintf("%s\n%s a+0(FP),SI\n%s b+%d(FP),DI\nMOVL $0,AX\nVZEROALL\n",
+					strings.Replace(header, "$0-0", fmt.Sprintf("$0-%d", 2*word), 1), move, move, word)
+				source := prefix + body
+				declaration := "func " + name + "(a,b *[128]byte)"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original-byte initialized block lost its paired native reader", api, err)
+					}
+					if block && strings.Count(ir, "asm sideeffect \"vcvtdq2ps") != 4 {
+						t.Fatal("original complete block lost its four floating conversions")
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "extend-original-"+api)
+					x86ResultInitializationObject(t, llc, target.triple, x86SignedIntegerFloatOptimize(t, ir), "extend-original-"+api+"-O2")
+				}
+			})
+		}
+	}
+}
+
+// Orthogonal raw objects exercise all six unsigned ratios, both source roles
+// and all five VEX/EVEX widths. Existing independent encoder and typed-byte
+// matrices own the full mask/register/address Cartesian axes separately.
+func TestX86RawZeroExtendOrthogonalInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for opcode := byte(0x30); opcode <= 0x35; opcode++ {
+				for shape := 0; shape < 5; shape++ {
+					for _, memory := range []bool{false, true} {
+						name := fmt.Sprintf("WidenRaw%d", count)
+						count++
+						code := []byte{0xc4, 0xe2, 0x79 | byte(shape)<<2, opcode, 0xc8}
+						if shape >= 2 {
+							control := byte(0x09 | (shape-2)<<5)
+							if shape == 3 {
+								control |= 0x80
+							}
+							code = []byte{0x62, 0xf2, 0x7d, control, opcode, 0xc8}
+						}
+						if memory {
+							code[len(code)-1] = 0x08 // Exact mN at the imported AX pointer.
+						}
+						// Only banks 0/1 are read. Their VEX zero producers also
+						// define the wider aliases without clearing sixteen banks
+						// in every independent object witness.
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nVPXOR Y0,Y0,Y0\nVPXOR Y1,Y1,Y1\nMOVL $5,AX\nKMOVD AX,K1\n%s p+0(FP),AX\n", name, word, move)
+						for _, value := range code {
+							fmt.Fprintf(&source, "BYTE $%#x\n", value)
+						}
+						source.WriteString("RET\n")
+						fmt.Fprintf(&declarations, "func %s(p *[32]byte)\n", name)
+					}
+				}
+			}
+			if count != 60 {
+				t.Fatal("incomplete independent raw unsigned widening directory", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized raw widening family lost its source owner", api, err)
+				}
+				for _, text := range []string{ir, x86SignedIntegerFloatOptimize(t, ir)} {
+					if !strings.Contains(text, "load volatile ") {
+						t.Fatal("dead widening results discarded their observable input reads")
+					}
+					x86ResultInitializationObject(t, llc, target.triple, text, "raw-widen-"+api)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_float_compare_literal_test.go b/x86_raw_float_compare_literal_test.go
new file mode 100644
index 000000000..2daaa982f
--- /dev/null
+++ b/x86_raw_float_compare_literal_test.go
@@ -0,0 +1,218 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86RawFloatCompareLiteralCase struct {
+	x86RawVectorLiteralCase
+	op                               string
+	width, tuple, input, immediateAt int
+	maskResult                       bool
+}
+
+// Independent _yvcmppd/_yvcmpsd memory witnesses. Register-only SAE is not a
+// literal form; K-result comparisons never acquire vector merge/zero semantics.
+func x86RawFloatCompareLiteralCases() []x86RawFloatCompareLiteralCase {
+	var rows []x86RawFloatCompareLiteralCase
+	for pp, operation := range []string{"VCMPPS", "VCMPPD", "VCMPSS", "VCMPSD"} {
+		for _, generation := range []string{"VEX2", "VEX3", "EVEX"} {
+			widths, masks := []int{16, 32}, []int{0}
+			if generation == "EVEX" {
+				widths, masks = []int{16, 32, 64}, []int{0, 3, 7}
+			}
+			if pp >= 2 {
+				widths = []int{16}
+			}
+			for length, width := range widths {
+				for _, mask := range masks {
+					broadcasts := []bool{false}
+					if generation == "EVEX" && pp < 2 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						row := x86RawFloatCompareLiteralCase{op: operation, width: width, tuple: width, input: width}
+						row.name = fmt.Sprintf("%s%s_%d_%d_%t", operation, generation, width, mask, broadcast)
+						row.mask, row.maskResult = mask, generation == "EVEX"
+						if pp >= 2 || broadcast {
+							row.tuple = 4
+							if pp&1 != 0 {
+								row.tuple = 8
+							}
+						}
+						if pp >= 2 {
+							row.input = row.tuple
+						}
+						switch generation {
+						case "VEX2":
+							row.code = []byte{0xc5, 0xf8 | byte(length<<2) | byte(pp)}
+						case "VEX3":
+							row.code = []byte{0xc4, 0xe1, 0x78 | byte(length<<2) | byte(pp)}
+						case "EVEX":
+							w := byte(0)
+							if pp&1 != 0 {
+								w = 0x80
+							}
+							row.code = []byte{0x62, 0xf1, 0x7c | w | byte(pp), 0x08 | byte(length<<5) | byte(mask)}
+							if broadcast {
+								row.code[3] |= 0x10
+								row.op += ".BCST"
+							}
+						}
+						row.code = append(row.code, 0xc2, 0x15, 1, 0, 0, 0, 12, 0xc3)
+						row.immediateAt = len(row.code) - 2
+						for index := 0; index < row.tuple; index++ {
+							row.code = append(row.code, byte(index*41+15))
+						}
+						rows = append(rows, row)
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawFloatCompareLiteralObjects(t *testing.T, triple string) {
+	t.Helper()
+	rows := x86RawFloatCompareLiteralCases()
+	if len(rows) != 54 {
+		t.Fatal("incomplete independent floating comparison literal directory", len(rows))
+	}
+	var programs []x86RawVectorLiteralCase
+	for _, row := range rows {
+		for _, selector := range []byte{0, 12, 255} {
+			program := row.x86RawVectorLiteralCase
+			program.name += fmt.Sprintf("_%d", selector)
+			program.code = append([]byte(nil), program.code...)
+			program.code[row.immediateAt] = selector
+			programs = append(programs, program)
+		}
+	}
+	x86RawVectorLiteralObjects(t, triple, programs)
+}
+
+func TestX86RawFloatCompareLiteralLinuxObjects(t *testing.T) {
+	x86RawFloatCompareLiteralObjects(t, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86RawFloatCompareLiteralDarwinObjects(t *testing.T) {
+	x86RawFloatCompareLiteralObjects(t, "x86_64-apple-darwin")
+}
+
+func TestX86RawFloatCompareLiteralWindowsObjects(t *testing.T) {
+	x86RawFloatCompareLiteralObjects(t, "x86_64-pc-windows-msvc")
+}
+
+func TestX86RawFloatCompareLiteralEverySelector(t *testing.T) {
+	for _, row := range x86RawFloatCompareLiteralCases() {
+		for selector := 0; selector < 256; selector++ {
+			code := append([]byte(nil), row.code...)
+			code[row.immediateAt] = byte(selector)
+			decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, row.name, map[string]bool{})
+			if err != nil || len(decoded) != 2 {
+				t.Fatal(row.name, selector, err)
+			}
+			form, known, err := x86FloatCompareProperties(decoded[0], "amd64")
+			if err != nil || !known || string(decoded[0].Op) != row.op ||
+				int(form.immediate) != selector || form.byteWidth != row.width ||
+				form.memoryBytes != row.tuple || form.maskResult != row.maskResult {
+				t.Fatal("literal lost complete selector, generation or tuple", row.name, selector, err)
+			}
+		}
+	}
+}
+
+func TestX86RawFloatCompareLiteralEveryInputByteAndTuple(t *testing.T) {
+	for _, row := range x86RawFloatCompareLiteralCases() {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawVectorLiteralSource(row.x86RawVectorLiteralCase)), "amd64")
+		if err != nil {
+			t.Fatal(row.name, err)
+		}
+		for _, ins := range file.Funcs[0].Instrs {
+			if !ins.x86RIPLiteral {
+				continue
+			}
+			address, valid := x86StaticSBReadAddress(ins.Args[1], "amd64")
+			if !valid || !x86RawFloatCompareLiteralForm(ins, "amd64") {
+				t.Fatal("comparison lost decoder-bound DATA", row.name)
+			}
+			if x86RawFloatCompareLiteralForm(ins, "386") {
+				t.Fatal("mode32 borrowed an AMD64 RIP input", row.name)
+			}
+			for missing := -1; missing < row.width; missing++ {
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+					loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(row.tuple)}}
+				state.masks[3], state.masks[7] = true, true
+				input := ^uint64(0)
+				if missing >= 0 {
+					input &^= uint64(1) << uint(missing)
+				}
+				state.writeVector(0, 64, input, false)
+				// Compare inside this instruction-local DATA scope. The ordinary
+				// CFG clone deliberately discards that transient read permission.
+				before := state
+				accepted, known := x86ResultFloatCompareStep(ins, &state, nil, "amd64", false)
+				want := missing < 0 || missing >= row.input
+				if !known || accepted != want {
+					t.Fatal("raw comparison lost required or passthrough input", row.name, missing, accepted)
+				}
+				expected := before
+				if want {
+					if row.maskResult {
+						expected.masks[2] = true
+					} else {
+						expected.writeVector(2, 64, input, false)
+					}
+				}
+				if !reflect.DeepEqual(state, expected) {
+					t.Fatal("comparison changed FLAGS, masks or source/result aliases", row.name, missing)
+				}
+				before.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(row.tuple - 1)}
+				if accepted, _ := x86ResultFloatCompareStep(ins, &before, nil, "amd64", false); accepted {
+					t.Fatal("comparison borrowed missing literal bytes", row.name)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawFloatCompareLiteralKeepsInputsAndSourceBoundaries(t *testing.T) {
+	for _, row := range x86RawFloatCompareLiteralCases() {
+		source := x86RawVectorLiteralSource(row.x86RawVectorLiteralCase)
+		changes := []string{
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+			strings.Replace(source, "VPXORD Z0,Z0,Z0\n", "", 1),
+		}
+		if row.mask != 0 {
+			changes = append(changes, strings.Replace(source, fmt.Sprintf("KMOVD AX,K%d\n", row.mask), "", 1))
+		}
+		for _, changed := range changes {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, "func "+row.name+"()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("literal waived input or return contract", row.name, api, err)
+				}
+			}
+		}
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil || len(file.Data) != 1 {
+			t.Fatal(row.name, err)
+		}
+		if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("standalone query borrowed comparison DATA", row.name, err)
+		}
+		file.Data[0].Payload[0] ^= 1
+		options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+			ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+		if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("comparison accepted changed original DATA", row.name, err)
+		}
+	}
+}
diff --git a/x86_raw_fma3_initialized_test.go b/x86_raw_fma3_initialized_test.go
new file mode 100644
index 000000000..7bdbfed0e
--- /dev/null
+++ b/x86_raw_fma3_initialized_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawFMA3InitializedSource(row x86RawFMA3SourceCase, arch, name, control string, dead bool) (string, string) {
+	word, move, suffix := goWordSize(arch), "MOVQ", "Q"
+	if arch == "386" {
+		move, suffix = "MOVL", "L"
+	}
+	first, second, destination := row.registers()
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", name, 4*word+8)
+	for index, input := range []struct{ name, register string }{
+		{"first", "AX"}, {"second", "BX"}, {"old", "CX"}, {"out", "DI"},
+	} {
+		if control == "address" && index == 0 {
+			continue
+		}
+		if control == "numeric address" && index == 0 {
+			source.WriteString("MOVL $42,AX\n")
+			continue
+		}
+		fmt.Fprintf(&source, "%s %s+%d(FP),%s\n", move, input.name, index*word, input.register)
+	}
+	if !row.memory && control != "first" {
+		fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", first)
+	}
+	if control != "second" {
+		fmt.Fprintf(&source, "VMOVUPS (BX),Z%d\n", second)
+	}
+	if control != "old" {
+		fmt.Fprintf(&source, "VMOVUPS (CX),Z%d\n", destination)
+	}
+	if control != "mask" {
+		fmt.Fprintf(&source, "KMOVW mask+%d(FP),K1\n", 4*word)
+	}
+	source.WriteString("MOVL $3,DX\nCMPL DX,$3\nSTD\n")
+	if control == "named" {
+		source.WriteString(row.instruction() + "\n")
+	} else {
+		source.WriteString(x86RawDisplacementDirectives(row.code()))
+	}
+	if !dead {
+		fmt.Fprintf(&source, "VMOVUPS Z%d,(DI)\n", destination)
+	}
+	fmt.Fprintf(&source, "PUSHF%s\nPOP%s DX\nANDL $0xcd5,DX\nMOVL DX,64(DI)\nCLD\nRET\n", suffix, suffix)
+	declaration := fmt.Sprintf("func %s(first,second,old,out *[128]byte,mask uint64)\n", name)
+	return source.String(), declaration
+}
+
+// One representative per name plus twelve orthogonal memory/mask/BCST/ER
+// witnesses. The complete 528-row directory is exercised by the independent
+// physical prior and typed tests, not an unbounded object Cartesian product.
+func x86RawFMA3ObjectCases() []x86RawFMA3SourceCase {
+	var rows []x86RawFMA3SourceCase
+	seen := make(map[string]bool)
+	for _, row := range x86RawFMA3SourceCases() {
+		if seen[row.op] {
+			continue
+		}
+		seen[row.op] = true
+		row.evex = len(rows)%2 != 0
+		rows = append(rows, row)
+	}
+	for _, order := range []string{"132", "213", "231"} {
+		for _, suffix := range []string{"PS", "PD", "SS", "SD"} {
+			for _, candidate := range x86RawFMA3SourceCases() {
+				if candidate.op != "VFMADD"+order+suffix || candidate.high {
+					continue
+				}
+				if candidate.scalar() && candidate.control == "RU_SAE" ||
+					!candidate.scalar() && candidate.control == "BCST" {
+					rows = append(rows, candidate)
+					break
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86RawFMA3SameSourceNamedInitializedControls(t *testing.T) {
+	rows := x86RawFMA3ObjectCases()
+	if len(rows) != 72 {
+		t.Fatal("bounded complete-name object directory changed", len(rows))
+	}
+	var source, declarations strings.Builder
+	for index, row := range rows {
+		body, declaration := x86RawFMA3InitializedSource(row, "amd64", fmt.Sprint("Control", index), "named", index%2 != 0)
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("same-source named FMA lost initialized arithmetic, native pointer, mask or FLAGS facts", err)
+			}
+		})
+	}
+}
+
+func TestX86RawFMA3InitializedFiveTargetsBatch00(t *testing.T) {
+	x86RawFMA3InitializedObjectBatch(t, 0)
+}
+
+func TestX86RawFMA3InitializedFiveTargetsBatch01(t *testing.T) {
+	x86RawFMA3InitializedObjectBatch(t, 1)
+}
+
+func x86RawFMA3InitializedObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	rows := x86RawFMA3ObjectCases()
+	if len(rows) != 72 || batch < 0 || batch > 1 {
+		t.Fatal("incomplete bounded original raw FMA object directory", len(rows), batch)
+	}
+	rows = rows[batch*36 : (batch+1)*36]
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			expected := make(map[string]int)
+			forced := make(map[string]int)
+			for index, row := range rows {
+				body, declaration := x86RawFMA3InitializedSource(row, target.arch,
+					fmt.Sprint("RawFMA", batch*36+index), "", index%2 != 0)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				expected[strings.ToLower(row.op)]++
+				if row.evex && row.bank != "Z" && row.mask == 0 && row.control == "" {
+					forced[strings.ToLower(row.op)]++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized original raw FMA has no paired native result continuation", err)
+					}
+					for name, want := range expected {
+						count, force := 0, 0
+						for _, line := range strings.Split(ir, "\n") {
+							if !strings.Contains(line, "asm sideeffect") || !strings.Contains(line, name+" ") {
+								continue
+							}
+							count++
+							if strings.Contains(line, "{evex} "+name+" ") {
+								force++
+							}
+							if !strings.Contains(line, "~{fpsr}") || !strings.Contains(line, "~{memory}") || strings.Contains(line, "~{flags}") {
+								t.Fatal("raw FMA lost native exceptions/access or changed FLAGS", name, line)
+							}
+						}
+						if count != want || force != forced[name] {
+							t.Fatal("raw FMA lost a live/dead opcode or its physical generation", name, count, want, force, forced[name])
+						}
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "raw-fma-source.ll", "raw-fma-source.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawFMA3DeadAndUnusedBoolRequireActualInputs(t *testing.T) {
+	for _, row := range x86RawFMA3ObjectCases() {
+		for _, control := range []string{"", "first", "second", "old", "mask", "address", "numeric address"} {
+			if control == "first" && row.memory || control == "mask" && row.mask == 0 ||
+				(control == "address" || control == "numeric address") && !row.memory {
+				continue
+			}
+			t.Run(row.instruction()+"/"+control, func(t *testing.T) {
+				for _, arch := range []string{"386", "amd64"} {
+					for _, unused := range []bool{false, true} {
+						source, declaration := x86RawFMA3InitializedSource(row, arch, "Value", control, true)
+						if unused {
+							extent := 4*goWordSize(arch) + 8
+							source = strings.Replace(source, fmt.Sprintf("$0-%d\n", extent), fmt.Sprintf("$0-%d\n", extent+1), 1)
+							declaration = strings.Replace(declaration, "mask uint64)", "mask uint64,unused bool)", 1)
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+							if control == "" {
+								if err != nil || ir == "" {
+									t.Fatal("complete dead/unused-bool raw FMA must remain a positive", arch, unused, api, err)
+								}
+							} else if control == "numeric address" {
+								x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+								width := 4
+								if strings.HasSuffix(row.op, "PD") {
+									width = 8
+								}
+								if err != nil || !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, strings.ToLower(row.op)+" ") ||
+									!strings.Contains(ir, fmt.Sprintf("elementtype([%d x i8])", width)) ||
+									!strings.Contains(ir, "~{memory}") || !strings.Contains(ir, "~{fpsr}") {
+									t.Fatal("numerical address lost raw FMA's native scalar broadcast and FP effects", arch, unused, api, err)
+								}
+								x86NumericNativeAddressObject(t, ir, x86AddressMemoryTargets(arch)[0])
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("raw FMA acquired an absent arithmetic input, old destination, mask or native pointer", arch, unused, api, err)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_fma3_native_boundary_test.go b/x86_raw_fma3_native_boundary_test.go
new file mode 100644
index 000000000..0031ba321
--- /dev/null
+++ b/x86_raw_fma3_native_boundary_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86RawFMA3PhysicalSnapshotRejectsAbsentAndEditedIdentity(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawFMA3ObjectCases()[:60] {
+			original := x86RawMoveObservedInstruction(t, arch, row.code())
+			if !x86RawFMA3Source(original, arch) {
+				t.Fatal("original physical source lost its complete FMA identity", arch, row.op)
+			}
+			for _, mutation := range []string{
+				"origin", "snapshot", "snapshot mode", "snapshot generation", "snapshot grammar",
+				"generation", "physical generation absent", "grammar", "both generations absent", "vector width", "operand",
+			} {
+				t.Run(arch+"/"+row.op+"/"+mutation, func(t *testing.T) {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					switch mutation {
+					case "origin":
+						changed.x86SourceRaw = nil
+					case "snapshot":
+						changed.x86SourceRaw.fma3 = x86RawFMA3Identity{}
+					case "snapshot mode":
+						changed.x86SourceRaw.fma3.arch = "arm64"
+					case "snapshot generation":
+						changed.x86SourceRaw.fma3.encoding = x86RawFMA3Absent
+					case "snapshot grammar":
+						changed.x86SourceRaw.fma3.encoded = !changed.x86SourceRaw.fma3.encoded
+					case "generation":
+						changed.x86FMA3Encoding = x86RawFMA3VEX
+						if original.x86FMA3Encoding == changed.x86FMA3Encoding {
+							changed.x86FMA3Encoding = x86RawFMA3EVEX
+						}
+					case "grammar":
+						changed.x86Encoded = !changed.x86Encoded
+					case "physical generation absent":
+						changed.x86FMA3Encoding = x86RawFMA3Absent
+					case "both generations absent":
+						changed.x86FMA3Encoding = x86RawFMA3Absent
+						changed.x86SourceRaw.fma3.encoding = x86RawFMA3Absent
+					case "vector width":
+						changed.x86VectorBytes = 7
+					case "operand":
+						changed.Args[1].Reg = "X7"
+					}
+					if x86RawFMA3EncodingSource(changed, arch) || x86RawFMA3Source(changed, arch) {
+						t.Fatal("absent or edited physical snapshot supplied an original FMA source")
+					}
+					if !x86RawFMA3Source(original, arch) {
+						t.Fatal("mutating a clone corrupted its independent original snapshot")
+					}
+				})
+			}
+		}
+	}
+}
+
+// This batch authorizes matching-x86 original opcodes only. A complete raw
+// producer is not a portable MXCSR/dead-read certificate, and cannot borrow
+// the ordinary named mathematical fallback or raw-only FP16 owner.
+func TestX86RawFMA3InitializedNonmatchingTargetKeepsNativeBoundary(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []x86RawFMA3SourceCase{
+			{op: "VFMADD132PS", opcode: 0x98, bank: "X"},
+			{op: "VFMADD213SD", opcode: 0xa9, bank: "X", evex: true},
+		} {
+			for _, memory := range []bool{false, true} {
+				row.memory = memory
+				source, declaration := x86RawFMA3InitializedSource(row, arch, "Value", "", true)
+				// Establish a real matching native owner for the identical source;
+				// negative controls cannot pass merely due to absent raw support.
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/memory=%t/%s", arch, row.op, memory, api), func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86AddressMemoryTargets(arch)[0], api); err != nil || ir == "" {
+							t.Fatal("complete matching native raw FMA positive failed", err)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, "aarch64-unknown-linux-gnu", api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), row.op) {
+							t.Fatal("raw original FMA silently entered the cross-ISA pure arithmetic/dead-read path", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fma3_originals_test.go b/x86_raw_fma3_originals_test.go
new file mode 100644
index 000000000..3f8149bcc
--- /dev/null
+++ b/x86_raw_fma3_originals_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86RawFMA3OriginalWeaviateSource(t *testing.T, evex bool) string {
+	t.Helper()
+	name, want := "TestTranslateRawVEXFMA3WeaviateRegression", "b1b467465fbfe860657c51db717516f4be905f166fbae74d3da6f6c375c906b6"
+	if evex {
+		name, want = "TestTranslateRawEVEXFMA3WeaviateRegression", "4b76cad69ad7c5d6269277dbdf85e52f0aa902eff23512f90ee9483687889ff1"
+	}
+	data, err := os.ReadFile("amd64_raw_vex_fma3_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "original-fma.go", data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var source string
+	for _, declaration := range file.Decls {
+		function, valid := declaration.(*ast.FuncDecl)
+		if !valid || function.Name.Name != name {
+			continue
+		}
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, valid := node.(*ast.ValueSpec)
+			if !valid || len(value.Names) != 1 || value.Names[0].Name != "source" || len(value.Values) != 1 {
+				return true
+			}
+			literal, valid := value.Values[0].(*ast.BasicLit)
+			if !valid || literal.Kind != token.STRING || source != "" {
+				t.Fatal("original Weaviate source lost its single literal")
+			}
+			source, err = strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			return false
+		})
+	}
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != want {
+		t.Fatal("the complete original Weaviate assembly literal changed", name)
+	}
+	return source
+}
+
+func TestX86RawFMA3OriginalWeaviateInputsAndInitializedCounterparts(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, evex := range []bool{false, true} {
+		source := x86RawFMA3OriginalWeaviateSource(t, evex)
+		header, body, found := strings.Cut(source, "\n")
+		if !found {
+			t.Fatal("original complete source lost its TEXT")
+		}
+		name, registers, code := "rawFMA", []int{3, 4}, []byte{0xc4, 0xe2, 0x5d, 0x98, 0x1e, 0xc3}
+		if evex {
+			name, registers, code = "rawFMAEVEX", []int{1, 9}, []byte{0x62, 0xd2, 0x35, 0x48, 0xb8, 0xc9, 0xc3}
+		}
+		actual, _ := x86NumericalBoundaryGoBytes(t, "amd64", body)
+		if !bytes.Equal(actual, code) {
+			t.Fatal("original Weaviate bytes changed independently of the decoder", evex, actual, code)
+		}
+		var prefix strings.Builder
+		prefix.WriteString(strings.Replace(header, "$0-0", "$0-8", 1) + "\nMOVQ p+0(FP),SI\nMOVQ p+0(FP),AX\n")
+		for _, register := range registers {
+			fmt.Fprintf(&prefix, "VMOVUPS (AX),Z%d\n", register)
+		}
+		initialized := prefix.String() + body
+		for _, target := range x86RawReturnTargets {
+			if target.arch != "amd64" {
+				continue // The original EVEX literal physically uses bank9.
+			}
+			t.Run(fmt.Sprintf("EVEX=%t/%s", evex, target.triple), func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", target.triple, source)
+				x86LEAActualTargetGoObject(t, "amd64", target.triple, initialized)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func "+name+"()", "amd64", target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unchanged bare original source acquired absent machine inputs", err)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, initialized, "func "+name+"(p *[128]byte)", "amd64", target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("independent complete original-byte counterpart must translate", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "weaviate-initialized.ll", "weaviate-initialized.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func x86RawFMA3InitializedRIPSource(initialized bool) (string, string) {
+	var source, declarations strings.Builder
+	for index, row := range x86RawFMA3ObjectCases()[:60] {
+		width := 32
+		if row.scalar() {
+			width = 16
+		} else if row.evex {
+			width = 64
+		}
+		code := x86RawFMA3Literal(row.opcode, strings.HasSuffix(row.op, "D"), row.evex, width, row.evex && !row.scalar())
+		fmt.Fprintf(&source, "TEXT ·LiteralFMA%d(SB),4,$0-8\n", index)
+		fmt.Fprintf(&declarations, "func LiteralFMA%d(mask uint64)\n", index)
+		if initialized {
+			source.WriteString("KMOVW mask+0(FP),K7\nVPXORD Z0,Z0,Z0\n")
+		}
+		source.WriteString(x86RawDisplacementDirectives(code))
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86RawFMA3InitializedRIPWholeSourceAndRawReturn(t *testing.T) {
+	source, declarations := x86RawFMA3InitializedRIPSource(true)
+	file := mustParseX86RawReturn(t, source)
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil || len(normalized.Funcs) != 60 || len(normalized.Data) != 60 {
+		t.Fatal("complete initialized RIP source lost original data or functions", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // These are original 64-bit RIP-relative encodings, not absolute mode32 addresses.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("valid original-byte RIP inputs and canonical raw RET must retain their existing complete roles", err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "fma-rip-inputs.ll", "fma-rip-inputs.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawFMA3RIPSourceCannotBorrowOldDestinationOrMask(t *testing.T) {
+	source, declaration := x86RawFMA3InitializedRIPSource(true)
+	for _, control := range []string{"old", "mask", "both"} {
+		t.Run(control, func(t *testing.T) {
+			changed := source
+			if control != "mask" {
+				changed = strings.ReplaceAll(changed, "VPXORD Z0,Z0,Z0\n", "")
+			}
+			if control != "old" {
+				changed = strings.ReplaceAll(changed, "KMOVW mask+0(FP),K7\n", "")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("a bound RIP DATA image/RET supplied absent old destination or mask", api, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_fma3_private_flags_test.go b/x86_raw_fma3_private_flags_test.go
new file mode 100644
index 000000000..9f297256a
--- /dev/null
+++ b/x86_raw_fma3_private_flags_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// The saved FLAGS are live across the actual instruction, not synthesized
+// after it. FMA changes vector data and MXCSR, but not DF or private storage.
+func TestX86RawFMA3PrivateFlagsSpanNativeInstruction(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		suffix := "Q"
+		if arch == "386" {
+			suffix = "L"
+		}
+		var original strings.Builder
+		var cases []struct{ name, source, declaration, control string }
+		for _, row := range []x86RawFMA3SourceCase{
+			{op: "VFMADD132PS", opcode: 0x98, bank: "X"},
+			{op: "VFNMADD231SD", opcode: 0xbd, bank: "X", evex: true},
+		} {
+			for _, control := range []string{"named", "raw", "first", "second", "old"} {
+				name := row.op + control
+				source, declaration := x86RawFMA3InitializedSource(row, arch, name, control, true)
+				push := "PUSHF" + suffix + "\n"
+				if strings.Count(source, push) != 1 || strings.Count(source, "STD\n") != 1 {
+					t.Fatal("saved FLAGS witness lost its exact placement")
+				}
+				source = strings.Replace(source, push, "", 1)
+				source = strings.Replace(source, "STD\n", "STD\n"+push, 1)
+				original.WriteString(source)
+				cases = append(cases, struct{ name, source, declaration, control string }{name, source, declaration, control})
+			}
+		}
+		// These are original complete programs, including missing-register
+		// negatives; Go's assembler permits those encodings but supplies no values.
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], original.String())
+		for _, row := range cases {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+					if row.control == "named" || row.control == "raw" {
+						if err != nil || ir == "" {
+							t.Fatal("initialized FMA revoked saved FLAGS or the independently defined DF", err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("saved FLAGS or an exact origin supplied an absent FMA arithmetic input", err)
+					}
+				})
+			}
+		}
+
+		t.Run(arch+"/complete-physical-family-state", func(t *testing.T) {
+			push := x86ScalarLaneInstruction(t, "PUSHF"+suffix)
+			for index, row := range x86RawFMA3SourceCases() {
+				if arch == "386" && row.high {
+					continue // The independently checked physical directory excludes these banks.
+				}
+				ins := x86RawMoveObservedInstruction(t, arch, row.code())
+				for _, direction := range []x86ResultDirection{
+					x86ResultDirectionUnknown, x86ResultDirectionForward,
+					x86ResultDirectionBackward, x86ResultDirectionEither,
+				} {
+					state := x86FMA3ResultInputState()
+					state.pointerGP[0], state.direction = true, direction
+					state.valueStack = &x86ResultValueStack{id: true}
+					first, second, destination := row.registers()
+					for _, register := range []int{first, second, destination} {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					if accepted, known := x86ResultValueStackStep(push, &state, nil, 0, arch); !known || !accepted {
+						t.Fatal("independent initialized FLAGS push prerequisite failed")
+					}
+					before := state.clone()
+					if !x86ResultValueStackContinuation(ins, &state, arch) ||
+						x86ResultDirectionAfterSource(ins, state.direction, arch) != direction ||
+						x86PreservesNumericalSourceState(ins) {
+						t.Fatal("exact FMA lost private control or acquired an inert-data role", arch, index, row.instruction(), direction)
+					}
+					accepted, known := x86ResultFMA3Step(ins, &state, nil, arch, true)
+					if !known || !accepted || state.flags != before.flags || state.direction != before.direction ||
+						!reflect.DeepEqual(state.valueStack, before.valueStack) {
+						t.Fatal("FMA changed saved bytes, ID, FLAGS or DF", arch, index, row.instruction())
+					}
+					for _, missing := range []int{first, second, destination} {
+						if row.memory && missing == first {
+							continue // That ordered source is the independently supplied native memory.
+						}
+						unknown := before.clone()
+						unknown.writeVector(missing, 64, 0, false)
+						unchanged := unknown.clone()
+						accepted, known := x86ResultFMA3Step(ins, &unknown, nil, arch, true)
+						if !known || accepted || !reflect.DeepEqual(unknown, unchanged) {
+							t.Fatalf("saved FLAGS initialized an absent vector source: %s row=%d register=%d", arch, index, missing)
+						}
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_fma3_replay_test.go b/x86_raw_fma3_replay_test.go
new file mode 100644
index 000000000..c52fe9278
--- /dev/null
+++ b/x86_raw_fma3_replay_test.go
@@ -0,0 +1,177 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86RawFMA3RegisterProgram(row x86RawFMA3SourceCase, raw bool) string {
+	first, second, destination := row.registers()
+	var source strings.Builder
+	source.WriteString("TEXT ·Value(SB),4,$0-4\n")
+	for _, register := range []int{first, second, destination} {
+		fmt.Fprintf(&source, "VPXORD Z%d,Z%d,Z%d\n", register, register, register)
+	}
+	source.WriteString("MOVL $85,AX\nKMOVW AX,K1\n")
+	if raw {
+		source.WriteString(x86RawDisplacementDirectives(row.code()))
+	} else {
+		source.WriteString(row.instruction() + "\n")
+	}
+	fmt.Fprintf(&source, "MOVL X%d,ret+0(FP)\nRET\n", destination)
+	return source.String()
+}
+
+func x86RawFMA3OriginalFunction(t *testing.T, source, arch string) (Func, int) {
+	t.Helper()
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("complete original raw FMA decode prerequisite", err)
+	}
+	function, ordinal := file.Funcs[0], -1
+	for index, ins := range function.Instrs {
+		base := strings.Split(string(ins.Op), ".")[0]
+		if ins.x86SourceRaw != nil && (strings.HasPrefix(base, "VFM") || strings.HasPrefix(base, "VFNM")) {
+			if ordinal >= 0 {
+				t.Fatal("ambiguous original arithmetic instruction")
+			}
+			ordinal = index
+		}
+	}
+	if ordinal < 0 || function.x86RawReplay == nil || function.x86RawReplay.validate(function, arch) != nil {
+		t.Fatal("original whole FMA producer lost its exact sealed replay")
+	}
+	return function, ordinal
+}
+
+func TestX86RawFMA3WholeRegisterAndMemoryProducerReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, memory := range []bool{false, true} {
+			for _, row := range x86RawFMA3ObjectCases()[:60] {
+				row.memory = memory
+				source, declaration := x86RawFMA3InitializedSource(row, arch, "Value", "", false)
+				named, _ := x86RawFMA3InitializedSource(row, arch, "Value", "named", false)
+				if !memory {
+					source, named = x86RawFMA3RegisterProgram(row, true), x86RawFMA3RegisterProgram(row, false)
+					declaration = "func Value() uint32"
+				}
+				check := x86LegacyFloatReplayCheck(t, arch, named, declaration)
+				t.Run(fmt.Sprintf("%s/%s/EVEX=%t/memory=%t/named", arch, row.op, row.evex, memory), func(t *testing.T) {
+					function := mustParseX86RawReturn(t, named).Funcs[0]
+					if function.x86RawReplay != nil || check(function) != nil {
+						t.Fatal("legal independent named FMA producer lost its existing contract")
+					}
+				})
+				for _, mutation := range []string{
+					"valid", "origin", "origin-and-opcode", "origin-and-producer", "origin-and-spelling",
+					"missing-replay", "source-spelling", "original-bytes", "decoded-snapshot",
+					"normalized-snapshot", "header", "generation", "origin-operands", "vector-width",
+				} {
+					t.Run(fmt.Sprintf("%s/%s/EVEX=%t/memory=%t/%s", arch, row.op, row.evex, memory, mutation), func(t *testing.T) {
+						original, ordinal := x86RawFMA3OriginalFunction(t, source, arch)
+						candidate := original
+						candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+						instruction := &candidate.Instrs[ordinal]
+						if mutation == "origin" || strings.HasPrefix(mutation, "origin-and-") {
+							instruction.x86SourceRaw = nil
+						}
+						switch mutation {
+						case "origin-and-opcode":
+							instruction.Op = "VFMSUB132PS"
+							if row.op == string(instruction.Op) {
+								instruction.Op = "VFMADD132PS"
+							}
+						case "origin-and-producer":
+							candidate.Instrs[1].Raw += " changed"
+						case "origin-and-spelling", "source-spelling":
+							instruction.Raw += " changed"
+						case "missing-replay":
+							candidate.x86RawReplay = nil
+						case "original-bytes", "decoded-snapshot", "normalized-snapshot":
+							replay := *original.x86RawReplay
+							switch mutation {
+							case "original-bytes":
+								replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+							case "decoded-snapshot":
+								replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+								replay.decoded[ordinal].x86SourceRaw = nil
+							case "normalized-snapshot":
+								replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+								replay.normalized[ordinal].Raw += " changed"
+							}
+							candidate.x86RawReplay = &replay
+						case "header":
+							candidate.ArgSize++
+						case "generation":
+							instruction.x86Encoded = !instruction.x86Encoded
+						case "origin-operands":
+							instruction.x86SourceRaw.args[1].Reg = "X7"
+						case "vector-width":
+							instruction.x86VectorBytes = 7
+						}
+						err := check(candidate)
+						if mutation == "valid" {
+							if err != nil {
+								t.Fatal("the original initialized whole raw FMA producer must succeed", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual whole-Func consumer accepted an edited original FMA/producer identity", err)
+						}
+						if original.x86RawReplay.validate(original, arch) != nil {
+							t.Fatal("mutating a clone corrupted its original independently sealed producer")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawFMA3OriginCannotSupplyMissingRegisterBytes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawFMA3ObjectCases()[:60] {
+			for _, missing := range []int{0, 1, 2} {
+				t.Run(fmt.Sprintf("%s/%s/input=%d", arch, row.op, missing), func(t *testing.T) {
+					source := x86RawFMA3RegisterProgram(row, true)
+					line := fmt.Sprintf("VPXORD Z%d,Z%d,Z%d\n", missing, missing, missing)
+					changed := strings.Replace(source, line, "", 1)
+					if changed == source {
+						t.Fatal("missing-input mutation did not remove its actual producer")
+					}
+					function, _ := x86RawFMA3OriginalFunction(t, changed, arch)
+					check := x86LegacyFloatReplayCheck(t, arch, changed, "func Value() uint32")
+					if err := check(function); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("an exact raw origin initialized an absent explicit or old-destination input", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawFMA3DoesNotBorrowFP16OrStandaloneNamedPermission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawFMA3ObjectCases()[:60] {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code())
+				state := x86FMA3ResultInputState()
+				before := state.clone()
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("standalone raw F32/F64 acquired ordinary named numerical permission")
+				}
+				if _, valid := x86RawFP16FMASourceForm(ins, arch); valid {
+					t.Fatal("ordinary F32/F64 encoding borrowed the existing raw-only FP16 owner")
+				}
+			})
+		}
+		for opcode := range rawFP16FMAOps() {
+			ins := x86RawMoveObservedInstruction(t, arch, x86FP16FMAResultEncoding(opcode, 0, false, false, false))
+			if form, valid := x86RawFP16FMASourceForm(ins, arch); !valid || !form.spec.rawOnly {
+				t.Fatal("ordinary raw FMA work revoked or relabelled the separate FP16 physical owner", opcode)
+			}
+		}
+	}
+}
diff --git a/x86_raw_fma3_source_test.go b/x86_raw_fma3_source_test.go
new file mode 100644
index 000000000..b5a1dc910
--- /dev/null
+++ b/x86_raw_fma3_source_test.go
@@ -0,0 +1,214 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+type x86RawFMA3SourceCase struct {
+	op, bank, control string
+	opcode            byte
+	evex, memory      bool
+	mask              int
+	zero, high        bool
+}
+
+// Independent Go _yvaddpd/_yvaddsd and FMA opcode axes. Physical low-bank
+// unmasked EVEX is intentionally distinct from the named spelling's VEX choice.
+// Do not derive this inventory from the production decoder or FMA registry.
+func x86RawFMA3SourceCases() []x86RawFMA3SourceCase {
+	var rows []x86RawFMA3SourceCase
+	for _, family := range []struct {
+		stem   string
+		opcode byte
+		scalar bool
+	}{
+		{"VFMADD", 0x98, true}, {"VFMSUB", 0x9a, true},
+		{"VFNMADD", 0x9c, true}, {"VFNMSUB", 0x9e, true},
+		{"VFMADDSUB", 0x96, false}, {"VFMSUBADD", 0x97, false},
+	} {
+		for orderIndex, order := range []string{"132", "213", "231"} {
+			for _, suffix := range []string{"PS", "PD", "SS", "SD"} {
+				scalar := strings.HasPrefix(suffix, "S")
+				if scalar && !family.scalar {
+					continue
+				}
+				row := x86RawFMA3SourceCase{
+					op: family.stem + order + suffix, bank: "X",
+					opcode: family.opcode + byte(orderIndex*16),
+				}
+				if scalar {
+					row.opcode++
+				}
+				rows = append(rows, row)
+				row.evex = true
+				rows = append(rows, row)
+				row.high = true
+				rows = append(rows, row)
+				row.high = false
+				if !scalar {
+					row.evex, row.bank, row.memory = false, "Y", true
+					rows = append(rows, row)
+					row.evex, row.memory, row.mask = true, false, 1
+					rows = append(rows, row)
+					row.bank, row.memory, row.control, row.zero = "Z", true, "BCST", true
+					rows = append(rows, row)
+				}
+				row.evex, row.memory, row.mask, row.zero = true, false, 1, true
+				for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					row.control = rounding
+					rows = append(rows, row)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86RawFMA3SourceCase) scalar() bool {
+	return strings.HasSuffix(row.op, "SS") || strings.HasSuffix(row.op, "SD")
+}
+
+func (row x86RawFMA3SourceCase) registers() (int, int, int) {
+	if row.high {
+		return 20, 21, 22
+	}
+	return 0, 1, 2
+}
+
+func (row x86RawFMA3SourceCase) instruction() string {
+	first, second, destination := row.registers()
+	name, source := row.op, fmt.Sprint(row.bank, first)
+	if row.memory {
+		source = "(AX)"
+	}
+	if row.control != "" {
+		name += "." + row.control
+	}
+	if row.zero {
+		name += ".Z"
+	}
+	mask := ""
+	if row.mask != 0 {
+		mask = fmt.Sprintf("K%d,", row.mask)
+	}
+	return fmt.Sprintf("%s %s,%s%d,%s%s%d", name, source, row.bank, second, mask, row.bank, destination)
+}
+
+func (row x86RawFMA3SourceCase) code() []byte {
+	first, second, destination := row.registers()
+	width64 := strings.HasSuffix(row.op, "D")
+	length := byte(map[string]int{"X": 0, "Y": 1, "Z": 2}[row.bank])
+	var code []byte
+	if row.evex {
+		if row.control != "" && row.control != "BCST" {
+			length = byte(map[string]int{"RN_SAE": 0, "RD_SAE": 1, "RU_SAE": 2, "RZ_SAE": 3}[row.control])
+		}
+		code = encodeX86EVEXFMA3(row.opcode, width64, length,
+			row.control != "", row.zero, row.mask, destination, second, first)
+	} else {
+		code = encodeX86VEXFMA3(row.opcode, width64, row.bank == "Y", destination, second, first)
+	}
+	if row.memory {
+		code[1] |= 0x60 // AX base has neither B nor X extension.
+		code[len(code)-1] = byte(destination&7) << 3
+	}
+	return code
+}
+
+func TestX86RawFMA3OriginalGoBytesAndCompleteDirectory(t *testing.T) {
+	x86FMA3CheckCompleteEncoderAttributes(t)
+	rows := x86RawFMA3SourceCases()
+	if len(rows) != 528 {
+		t.Fatal("incomplete independent 60-name physical FMA directory", len(rows))
+	}
+	names, seen := make(map[string]bool), make(map[string]bool)
+	var source strings.Builder
+	var expected []byte
+	count := 0
+	for _, row := range rows {
+		key := fmt.Sprintf("%s/EVEX=%t", row.instruction(), row.evex)
+		if seen[key] {
+			t.Fatal("duplicate independent physical case", key)
+		}
+		seen[key], names[row.op] = true, true
+		if row.evex && !row.high && row.bank == "X" && row.mask == 0 {
+			continue // Named low-bank unmasked X necessarily selects VEX.
+		}
+		source.WriteString(row.instruction() + "\n")
+		expected = append(expected, row.code()...)
+		count++
+	}
+	actual, pcs := x86NumericalBoundaryGoBytes(t, "amd64", source.String()+"RET")
+	expected = append(expected, 0xc3)
+	if len(names) != 60 || count != 468 || len(pcs) != count+1 || !bytes.Equal(actual, expected) {
+		t.Fatal("actual original Go FMA encodings differ from complete independent physical bytes", len(names), count, len(pcs))
+	}
+}
+
+func TestX86RawFMA3PhysicalBytesIndependentLLVM22(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			expected := make(map[string]int)
+			for _, row := range x86RawFMA3SourceCases() {
+				if row.high && arch == "386" {
+					continue // Physical mode32 has only banks 0..7.
+				}
+				for _, value := range row.code() {
+					fmt.Fprintf(&source, "0x%02x ", value)
+				}
+				source.WriteByte('\n')
+				expected[strings.ToLower(row.op)]++
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(stage, mc, "--disassemble",
+				"--triple="+x86AddressMemoryTargets(arch)[0], "--mattr=+avx,+fma,+avx512f,+avx512vl")
+			command.Stdin = strings.NewReader(source.String())
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+				t.Fatalf("independent physical FMA prior failed: %v\n%s", err, output)
+			}
+			for name, want := range expected {
+				if count := len(regexp.MustCompile(`\b`+name+`[ \t]+`).FindAll(output, -1)); count != want {
+					t.Fatal("independent LLVM22 physical FMA directory is incomplete", name, count, want)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawFMA3PhysicalGenerationAndIsolatedISA(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawFMA3SourceCases() {
+			if row.high && arch == "386" {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%s/EVEX=%t", arch, row.instruction(), row.evex), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code())
+				form, known, err := amd64FMA3Properties(ins, arch)
+				if !known || err != nil || string(ins.Op) != strings.Fields(row.instruction())[0] {
+					t.Fatal("physical FMA lost its independent complete typed grammar", err)
+				}
+				if x86FMA3NativeEVEX(ins, form) != row.evex {
+					t.Error("physical low-bank generation was inferred from a named spelling")
+				}
+				features := "," + inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}) + ","
+				if strings.Contains(features, ",+avx512f,") != row.evex ||
+					strings.Contains(features, ",+avx512vl,") != (row.evex && !row.scalar() && row.bank != "Z") ||
+					!row.evex && (!strings.Contains(features, ",+avx,") || !strings.Contains(features, ",+fma,")) {
+					t.Error("isolated original physical FMA acquired a foreign ISA profile", features)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_fp16_binary_grammar_test.go b/x86_raw_fp16_binary_grammar_test.go
new file mode 100644
index 000000000..b475b2403
--- /dev/null
+++ b/x86_raw_fp16_binary_grammar_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RawFP16BinaryMalformedBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for opcode := range rawFP16BinaryOpcodes {
+				for _, mutation := range []string{"dispatch", "mask", "destination", "source", "scale", "displacement", "extension", "suffix", "empty-suffix"} {
+					t.Run(fmt.Sprintf("%s/%x/scalar%t/%s", arch, opcode, scalar, mutation), func(t *testing.T) {
+						code := x86FP16BinaryResultEncoding(opcode, 0, scalar, true, false, 1)
+						file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+						file, err := normalizeX86RawFile(file, arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						dispatch := ins.Op
+						switch mutation {
+						case "dispatch":
+							dispatch = "VADDPH"
+							if ins.Op == dispatch {
+								dispatch = "VSUBPH"
+							}
+						case "mask":
+							ins.Args[2].Reg = "K0"
+						case "destination":
+							ins.Args[3] = Operand{Kind: OpReg, Reg: AX}
+						case "source":
+							ins.Args[0] = Operand{Kind: OpImm, ImmIsFloat: true}
+						case "scale":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+						case "displacement":
+							ins.Args[0].Mem.OffRaw = "unresolved"
+						case "extension":
+							ins.Args[0].Mem.IndexExt = "invalid"
+						case "suffix":
+							ins.Op += ".INVALID"
+							dispatch = ins.Op
+						case "empty-suffix":
+							ins.Op += "."
+							dispatch = ins.Op
+						}
+						ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+						ctx.goarch = arch
+						before, temporary := output.String(), ctx.tmp
+						known, terminated, err := ctx.lowerBinaryFloating(dispatch, ins)
+						if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+							t.Fatal("malformed FP16 binary emitted IR", known, terminated, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_binary_result_test.go b/x86_raw_fp16_binary_result_test.go
new file mode 100644
index 000000000..fb2f5e657
--- /dev/null
+++ b/x86_raw_fp16_binary_result_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86FP16BinaryResultEncoding(opcode, length byte, scalar, memory, control bool, mask int) []byte {
+	encode := encodeRawFP16Binary
+	if scalar {
+		encode = encodeRawFP16ScalarBinary
+	}
+	code := encode(opcode, length, 2, 1, 0, 1, memory, control, mask == 2)
+	if memory {
+		code[len(code)-1] = 0
+	}
+	if mask == 0 {
+		code[3] &^= 7
+	}
+	return code
+}
+
+// Independent MAP5 opcode/control matrix: six operations, packed and scalar.
+// MIN/MAX use SAE (LL ignored), whereas arithmetic has four rounding modes.
+func x86FP16BinaryResultFixtures(t *testing.T, arch string, scalar bool, batch int) (string, string, map[string]x86RawFP16ObjectEncoding) {
+	t.Helper()
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	encodings := make(map[string]x86RawFP16ObjectEncoding)
+	variants := 0
+	for _, opcode := range []byte{0x58, 0x59, 0x5c, 0x5d, 0x5e, 0x5f} {
+		for length := byte(0); length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if scalar && memory && control || !scalar && length == 3 && (memory || !control) {
+						continue
+					}
+					for mask := 0; mask < 3; mask++ {
+						selected := variants%3 == batch
+						variants++
+						if !selected {
+							continue
+						}
+						name := fmt.Sprintf("halfBinary%d", len(encodings))
+						maskMove := "kmovw"
+						if !scalar && (length == 2 || !memory && control) {
+							maskMove = "kmovd"
+						}
+						if mask == 0 {
+							maskMove = ""
+						}
+						encodings[name] = x86RawFP16ObjectEncoding{
+							code:          x86FP16BinaryResultEncoding(opcode, length, scalar, memory, control, mask),
+							lengthIgnored: scalar && !control || (opcode == 0x5d || opcode == 0x5f) && control && !memory,
+							maskMove:      maskMove,
+						}
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s p+0(FP),AX\n", name, word+4, move)
+						source.WriteString("MOVL $1,CX\nKMOVD CX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n")
+						source.WriteString(x86RawDisplacementDirectives(encodings[name].code))
+						fmt.Fprintf(&source, "MOVL X0,DX\nMOVL DX,ret+%d(FP)\nRET\n", word)
+						fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+					}
+				}
+			}
+		}
+	}
+	want := 234
+	if scalar {
+		want = 216
+	}
+	if variants != want || len(encodings) != want/3 {
+		t.Fatal("incomplete independent FP16 binary physical partition", variants, len(encodings))
+	}
+	return source.String(), declarations.String(), encodings
+}
+
+func TestX86RawFP16PackedBinaryNativeObjects(t *testing.T) {
+	x86FP16BinaryInitializedObjects(t, false)
+}
+
+func TestX86RawFP16ScalarBinaryNativeObjects(t *testing.T) {
+	x86FP16BinaryInitializedObjects(t, true)
+}
+
+func x86FP16BinaryInitializedObjects(t *testing.T, scalar bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for batch := 0; batch < 3; batch++ {
+			t.Run(fmt.Sprintf("%s/batch%d", target.triple, batch), func(t *testing.T) {
+				source, declarations, encodings := x86FP16BinaryResultFixtures(t, target.arch, scalar, batch)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized complete FP16 binary inputs", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "asm sideeffect") != len(encodings) {
+							t.Fatal("FP16 binary lost an original native arithmetic effect", api)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86RawFP16CheckObject(t, llc, target.triple, text, level, encodings)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawFP16BinaryCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for opcode := range rawFP16BinaryOpcodes {
+				for _, memory := range []bool{false, true} {
+					for mask := 0; mask < 3; mask++ {
+						t.Run(fmt.Sprintf("%s/%x/scalar%t/memory%t/mask%d", arch, opcode, scalar, memory, mask), func(t *testing.T) {
+							code := x86FP16BinaryResultEncoding(opcode, 0, scalar, memory, false, mask)
+							source := "TEXT Value(SB),4,$0-0\n" + x86RawDisplacementDirectives(code) + "RET\n"
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("Void FP16 binary invented source, merge or mask inputs", api, err)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_binary_runtime_test.go b/x86_raw_fp16_binary_runtime_test.go
new file mode 100644
index 000000000..9612c5e48
--- /dev/null
+++ b/x86_raw_fp16_binary_runtime_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute portable values separately from native opcode/MXCSR qualification.
+// Independent raw-bit references retain MIN/MAX's second-source NaNs and zeros.
+func TestX86RawFP16BinaryPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	var source, declarations, cases strings.Builder
+	sigs := make(map[string]FuncSig)
+	for mode, opcode := range []byte{0x58, 0x5c, 0x59, 0x5e, 0x5d, 0x5f} {
+		for _, scalar := range []bool{false, true} {
+			for length := byte(0); length < 3; length++ {
+				if scalar && length != 0 {
+					continue
+				}
+				for _, broadcast := range []bool{false, true} {
+					if scalar && broadcast {
+						continue
+					}
+					for mask := 1; mask <= 2; mask++ {
+						name := fmt.Sprintf("binary%d", len(sigs))
+						fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\n", name)
+						source.WriteString("MOVQ input+0(FP),DI\nMOVQ memory+8(FP),AX\nMOVQ out+16(FP),SI\nMOVQ mask+24(FP),CX\n")
+						source.WriteString("KMOVQ CX,K1\nVMOVDQU64 (DI),Z0\nVMOVDQU64 64(DI),Z2\n")
+						code := x86FP16BinaryResultEncoding(opcode, length, scalar, true, broadcast, mask)
+						source.WriteString(x86RawDisplacementDirectives(code))
+						source.WriteString("VMOVDQU64 Z0,(SI)\nRET\n")
+						sigs[name] = FuncSig{
+							Name: name, Args: []LLVMType{Ptr, Ptr, Ptr, I64}, Ret: Void, Attrs: "nounwind",
+							Frame: FrameLayout{Params: []FrameSlot{
+								{Offset: 0, Type: Ptr, Index: 0, Field: -1},
+								{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+								{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+								{Offset: 24, Type: I64, Index: 3, Field: -1},
+							}},
+						}
+						lanes, scalarFlag, broadcastFlag := 8<<length, 0, 0
+						if scalar {
+							lanes, scalarFlag = 1, 1
+						}
+						if broadcast {
+							broadcastFlag = 1
+						}
+						fmt.Fprintf(&declarations, "extern void %s(const void *, const void *, void *, uint64_t);\n", name)
+						fmt.Fprintf(&cases, "{%s,%d,%d,%d,%d,%d},\n", name, mode, lanes, scalarFlag, broadcastFlag, mask-1)
+					}
+				}
+			}
+		}
+	}
+	if len(sigs) != 84 {
+		t.Fatal("incomplete portable binary value inventory", len(sigs))
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := x86FP16NumericalModelIR(t, file, sigs, testTargetTriple(runtime.GOOS, runtime.GOARCH))
+	mainC := "#include <stdint.h>\n#include <stddef.h>\n#include <stdio.h>\n#include <string.h>\n" + declarations.String() + x86TestGuardPagesC + `
+typedef void (*operation)(const void *, const void *, void *, uint64_t);
+struct binary_case { operation run; int mode, lanes, scalar, broadcast, zero; };
+static const struct binary_case cases[] = {
+` + cases.String() + `};
+
+static int half_nan(uint16_t bits) {
+    return (bits & 0x7c00) == 0x7c00 && (bits & 0x03ff) != 0;
+}
+
+static double from_half(uint16_t bits) {
+    _Float16 value;
+    memcpy(&value, &bits, 2);
+    return value;
+}
+
+static uint16_t reference(int mode, uint16_t left, uint16_t right) {
+    if (mode >= 4 && (half_nan(left) || half_nan(right))) return right;
+    double a = from_half(left), b = from_half(right);
+    if (mode == 4) return a < b ? left : right;
+    if (mode == 5) return a > b ? left : right;
+    double value = mode == 0 ? a+b : mode == 1 ? a-b : mode == 2 ? a*b : a/b;
+    _Float16 result = (_Float16)value;
+    uint16_t bits;
+    memcpy(&bits, &result, 2);
+    return bits;
+}
+
+int main(void) {
+    if (setup_guard()) return 1;
+    const uint16_t left[]  = {0x3c00,0x4000,0xbc00,0x4400,1,0x8000,0,0x7bff};
+    const uint16_t right[] = {0x4000,0x3c00,0x4000,0x3800,0x3c00,0,0x8000,0x3800};
+    const uint64_t masks[] = {0,1,0xaaaaaaaa,0xffff0000,0x80000000,0xffffffff,UINT64_C(1)<<60};
+    uint16_t input[64], memory[32], output[34];
+    for (size_t ci = 0; ci < sizeof(cases)/sizeof(cases[0]); ci++) {
+        struct binary_case test = cases[ci];
+        for (int scenario = 0; scenario < 8; scenario++) {
+            for (int lane = 0; lane < 32; lane++) {
+                input[lane] = (uint16_t)(0x1000+lane);
+                input[32+lane] = left[(scenario+lane)%8];
+                memory[lane] = right[(scenario+lane)%8];
+                if (test.mode >= 4 && scenario >= 4) {
+                    if (scenario & 1) input[32+lane] = 0x7d11;
+                    if (scenario & 2) memory[lane] = 0x7e35;
+                }
+            }
+            for (size_t mi = 0; mi < sizeof(masks)/sizeof(masks[0]); mi++) {
+                uint64_t mask = masks[mi];
+                const void *pointer = memory;
+                if ((mask & ((UINT64_C(1)<<test.lanes)-1)) == 0) pointer = NULL;
+                if (mask == 1) {
+                    memcpy(guard+page-3,memory,2);
+                    pointer = guard+page-3;
+                }
+                memset(output,0xcc,sizeof(output));
+                test.run(input,pointer,output+1,mask);
+                if (output[0] != 0xcccc || output[33] != 0xcccc) return 3;
+                for (int lane = 0; lane < 32; lane++) {
+                    uint16_t want = 0;
+                    int active = lane < test.lanes && ((mask>>lane)&1);
+                    if (active) want = reference(test.mode,input[32+lane],memory[test.broadcast?0:lane]);
+                    else if (lane < test.lanes && !test.zero) want = input[lane];
+                    else if (test.scalar && lane > 0 && lane < 8) want = input[32+lane];
+                    uint16_t got = output[lane+1];
+                    if (test.mode < 4 && active && half_nan(want) && half_nan(got)) continue;
+                    if (got != want) {
+                        fprintf(stderr,"case %zu scenario %d mask %llx lane %d: %04x != %04x\n",
+                            ci,scenario,(unsigned long long)mask,lane,got,want);
+                        return 2;
+                    }
+                }
+            }
+        }
+    }
+    return free_guard();
+}
+`
+	compileAndRunRuntimeTest(t, llc, clang, "fp16_binary_values", ir, mainC)
+}
diff --git a/x86_raw_fp16_binary_state_test.go b/x86_raw_fp16_binary_state_test.go
new file mode 100644
index 000000000..d1f688f5a
--- /dev/null
+++ b/x86_raw_fp16_binary_state_test.go
@@ -0,0 +1,108 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawFP16BinaryExactInputsAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for opcode := range rawFP16BinaryOpcodes {
+				for length := byte(0); length < 3; length++ {
+					for _, memory := range []bool{false, true} {
+						for mask := 0; mask < 3; mask++ {
+							t.Run(fmt.Sprintf("%s/%x/scalar%t/VL%d/memory%t/mask%d", arch, opcode, scalar, length, memory, mask), func(t *testing.T) {
+								code := x86FP16BinaryResultEncoding(opcode, length, scalar, memory, false, mask)
+								file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+								file, err := normalizeX86RawFile(file, arch)
+								if err != nil {
+									t.Fatal(err)
+								}
+								ins := file.Funcs[0].Instrs[1]
+								form, err := x86FloatBinaryOperandProperties(ins, arch, 16, false, scalar, false, "FP16 binary")
+								if err != nil {
+									t.Fatal(err)
+								}
+								width, input := 16<<length, 16<<length
+								if scalar {
+									width, input = 16, 2
+								}
+								state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+								state.pointerGP[0], state.callerAddressGP[0], state.masks[1] = true, true, true
+								state.gp[2] = 0xa5
+								for reg := 0; reg < 3; reg++ {
+									state.writeVector(reg, 64, ^uint64(0), false)
+								}
+								if scalar {
+									state.writeVector(0, 64, 3, false)
+									state.writeVector(1, 64, 3, false)
+									state.writeVector(2, 64, 0xa55b, false)
+								}
+								before, want := state.clone(), state.clone()
+								value := ^uint64(0)
+								if scalar {
+									value = 0xa55b // Upper X knowledge comes from the second source, not old destination.
+								}
+								want.writeVector(0, width, value, false)
+								if !x86ScalarFPFloatBinaryTransferWithRead(ins, form, &state, nil, arch, true) || !reflect.DeepEqual(state, want) {
+									t.Fatal("FP16 binary lost source/passthrough bytes or changed unrelated state")
+								}
+
+								standalone := before.clone()
+								caller := x86SourceStackState{vectors: map[Reg]uint64{
+									"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+								if x86ScalarFPFloatBinaryTransfer(ins, form, &standalone, nil, arch) ||
+									x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &caller, nil) {
+									t.Fatal("FP16 binary borrowed standalone or caller input permission")
+								}
+								for _, mutation := range []string{"mask", "first", "second", "destination", "origin", "length", "address", "segment", "return", "literal", "operand"} {
+									if mutation == "mask" && mask == 0 {
+										continue
+									}
+									changed, rejected := ins, before.clone()
+									switch mutation {
+									case "mask":
+										rejected.masks[1] = false
+									case "first", "second", "destination":
+										reg := map[string]int{"first": 1, "second": 2, "destination": 0}[mutation]
+										if mutation == "first" && memory {
+											rejected.pointerGP[0] = false
+										} else {
+											rejected.writeVector(reg, 64, rejected.vectorBytes(reg)&^(uint64(1)<<uint(input-1)), false)
+										}
+									case "origin":
+										changed.x86SourceRaw = nil
+									case "length":
+										changed.x86VectorBytes ^= 16
+									case "address":
+										changed.x86AddressBits = 16
+									case "segment":
+										changed.x86SegmentPrefix = 0x64
+									case "return":
+										changed.x86RawNearReturn = new(x86RawNearReturnForm)
+									case "literal":
+										changed.x86RIPLiteral = true
+									case "operand":
+										changed.Args = append([]Operand(nil), ins.Args...)
+										changed.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+									}
+									original := rejected.clone()
+									accepted := x86ScalarFPFloatBinaryTransferWithRead(changed, form, &rejected, nil, arch, true)
+									if mutation == "destination" && mask != 1 {
+										if !accepted || !reflect.DeepEqual(rejected, want) {
+											t.Fatal("unmasked/zeroing binary incorrectly depends on old destination")
+										}
+									} else if accepted || !reflect.DeepEqual(original, rejected) {
+										t.Fatal("FP16 binary invented input or original-source facts", mutation)
+									}
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_conversion_object_test.go b/x86_raw_fp16_conversion_object_test.go
new file mode 100644
index 000000000..b05c7c9bd
--- /dev/null
+++ b/x86_raw_fp16_conversion_object_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"encoding/hex"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+type x86RawFP16ObjectEncoding struct {
+	code          []byte
+	lengthIgnored bool
+	maskMove      string
+}
+
+// Compare actual LLVM object fields with independent original physical bytes.
+// Register allocation may change register numbers, but not opcode, source role,
+// vector length, mask, zeroing, broadcast or ER/SAE controls. Scalar LLIG and
+// widening register-SAE LL are intentionally ignored by the ISA.
+func x86RawFP16CheckObject(t *testing.T, llc, triple, ir, level string, want map[string]x86RawFP16ObjectEncoding) {
+	t.Helper()
+	disassembler := findLLVM22Tool("llvm-objdump")
+	if disassembler == "" {
+		t.Fatal("LLVM22 disassembler required")
+	}
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "fp16.ll"), filepath.Join(dir, "fp16.o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple="+triple, "-filetype=obj", input, "-o", object))
+	listing := x86FloatCompareCaptureCommand(t, exec.Command(disassembler, "--disassemble", object))
+	sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <_?((?:conversion|halfSqrt|halfFMA|halfBinary)[0-9]+)>:\n`).FindAllSubmatchIndex(listing, -1)
+	seen := make(map[string]bool)
+	for index, section := range sections {
+		name := string(listing[section[2]:section[3]])
+		expected, found := want[name]
+		if !found || seen[name] {
+			t.Fatal("unexpected or duplicated FP16 object symbol", name)
+		}
+		end := len(listing)
+		if index+1 < len(sections) {
+			end = sections[index+1][0]
+		}
+		operations, masks := 0, 0
+		for _, line := range strings.Split(string(listing[section[1]:end]), "\n") {
+			if strings.Contains(line, "kmovw") || strings.Contains(line, "kmovd") {
+				if !strings.Contains(line, expected.maskMove) {
+					t.Fatal("FP16 operation changed its full active mask width", name, line)
+				}
+				masks++
+			}
+			fields := strings.Fields(line)
+			if len(fields) < 7 || !strings.HasSuffix(fields[0], ":") {
+				continue
+			}
+			var code []byte
+			for _, field := range fields[1:] {
+				if len(field) != 2 {
+					break
+				}
+				value, err := hex.DecodeString(field)
+				if err != nil {
+					break
+				}
+				code = append(code, value[0])
+			}
+			if len(code) < 6 || code[0] != 0x62 || code[1]&7 < 5 {
+				continue
+			}
+			operations++
+			original := expected.code
+			register := code[5]&0xc0 == 0xc0
+			if code[1]&7 != original[1]&7 || code[2]&0x87 != original[2]&0x87 ||
+				code[3]&0x97 != original[3]&0x97 || code[4] != original[4] ||
+				register != (original[5]&0xc0 == 0xc0) {
+				t.Fatalf("%s changed native FP16 opcode, mask, zeroing or source/control role: %x versus %x", name, code, original)
+			}
+			if !expected.lengthIgnored && code[3]&0x60 != original[3]&0x60 {
+				t.Fatalf("%s changed native source width or rounding: %x versus %x", name, code, original)
+			}
+		}
+		wantMasks := 1
+		if expected.maskMove == "" {
+			wantMasks = 0
+		}
+		if operations != 1 || masks != wantMasks {
+			t.Fatal("object did not retain exactly one original FP16 operation and full mask", name, operations, masks)
+		}
+		seen[name] = true
+	}
+	if len(seen) != len(want) {
+		t.Fatal("incomplete native FP16 object inventory", len(seen), len(want))
+	}
+}
diff --git a/x86_raw_fp16_conversion_result_test.go b/x86_raw_fp16_conversion_result_test.go
new file mode 100644
index 000000000..5ff08df22
--- /dev/null
+++ b/x86_raw_fp16_conversion_result_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Intel FP16 sections 5.10, 5.16, 5.18, 5.19, 5.21 and 5.24.
+// These are physical map5/map6 forms, not Go named-opcode registrations.
+// https://cdrdv2-public.intel.com/678970/intel-avx512-fp16.pdf
+var x86FP16ConversionResultNames = []string{
+	"VCVTPH2PSX", "VCVTPS2PHX", "VCVTSH2SS", "VCVTSS2SH", "VCVTSH2SD", "VCVTSD2SH",
+}
+
+func x86FP16ConversionResultEncoding(member, length int, memory, control, zero bool) []byte {
+	var code []byte
+	if member < 2 {
+		code = rawFP16Conversion(member == 1, length, 1, 0, 1, memory, control, zero)
+	} else {
+		code = rawFP16ScalarConversion(member-2, length, 2, 1, 0, 1, memory, control, zero)
+	}
+	if memory {
+		code[len(code)-1] = 0 // Actual incoming AX pointer, without a guessed extent.
+	}
+	return code
+}
+
+func x86FP16ConversionResultFixture(name, arch string, member, length int, memory, control, zero bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	code := x86FP16ConversionResultEncoding(member, length, memory, control, zero)
+	source := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n%s p+0(FP),AX\n", name, word+4, move) +
+		"MOVL $1,CX\nKMOVD CX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n" +
+		x86RawDisplacementDirectives(code) +
+		fmt.Sprintf("MOVL X0,DX\nMOVL DX,ret+%d(FP)\nRET\n", word)
+	return source, fmt.Sprintf("func %s(p *byte) uint32\n", name)
+}
+
+func TestX86RawFP16ConversionInitializedNativeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for batch := 0; batch < 2; batch++ {
+			t.Run(fmt.Sprintf("%s/batch%d", target.triple, batch), func(t *testing.T) {
+				var source, declarations strings.Builder
+				encodings := make(map[string]x86RawFP16ObjectEncoding)
+				count := 0
+				for member := range x86FP16ConversionResultNames {
+					if member%2 != batch {
+						continue
+					}
+					for length := 0; length < 4; length++ {
+						for _, memory := range []bool{false, true} {
+							for _, control := range []bool{false, true} {
+								if member < 2 && length == 3 && (memory || !control) || member >= 2 && memory && control {
+									continue
+								}
+								for _, zero := range []bool{false, true} {
+									name := fmt.Sprintf("conversion%d", count)
+									asm, declaration := x86FP16ConversionResultFixture(name, target.arch, member, length, memory, control, zero)
+									encodings[name] = x86RawFP16ObjectEncoding{
+										code:          x86FP16ConversionResultEncoding(member, length, memory, control, zero),
+										lengthIgnored: member >= 2 && (!control || member%2 == 0) || member == 0 && !memory && control,
+										maskMove:      "kmovw",
+									}
+									source.WriteString(asm)
+									declarations.WriteString(declaration)
+									count++
+								}
+							}
+						}
+					}
+				}
+				if count != 74 {
+					t.Fatal("incomplete conversion controls, LLIG, masks or source axes", count)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized complete raw conversion family", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "asm sideeffect") != count {
+							t.Fatal("conversion lost its original MXCSR/exception effect", api)
+						}
+						for member, op := range x86FP16ConversionResultNames {
+							if member%2 != batch {
+								continue
+							}
+							if !strings.Contains(text, strings.ToLower(op)+" ") {
+								t.Fatal("missing original native conversion", api, op)
+							}
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86RawFP16CheckObject(t, llc, target.triple, text, level, encodings)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawFP16ConversionCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for member, op := range x86FP16ConversionResultNames {
+			for _, memory := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/memory=%t", arch, op, memory), func(t *testing.T) {
+					code := x86RawDisplacementDirectives(x86FP16ConversionResultEncoding(member, 0, memory, false, false))
+					bare := "TEXT Value(SB),4,$0-0\n" + code + "RET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, bare, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void raw conversion borrowed unknown inputs or masks", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_conversion_state_test.go b/x86_raw_fp16_conversion_state_test.go
new file mode 100644
index 000000000..79a811c11
--- /dev/null
+++ b/x86_raw_fp16_conversion_state_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawFP16ConversionExactSourceAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for member, op := range x86FP16ConversionResultNames {
+			for length := 0; length < 3; length++ {
+				for _, memory := range []bool{false, true} {
+					for _, zero := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%s/VL%d/memory=%t/zero=%t", arch, op, length, memory, zero), func(t *testing.T) {
+							code := x86FP16ConversionResultEncoding(member, length, memory, false, zero)
+							file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+							file, err := normalizeX86RawFile(file, arch)
+							if err != nil {
+								t.Fatal(err)
+							}
+							ins := file.Funcs[0].Instrs[1]
+							inputBytes := []int{8 << length, 16 << length, 2, 4, 2, 8}[member]
+							outputBytes := []int{16 << length, 8 << length, 4, 2, 8, 2}[member]
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+							state.pointerGP[0], state.callerAddressGP[0], state.masks[1] = true, true, true
+							state.gp[2] = 0xa5
+							state.writeVector(0, 64, ^uint64(0), false)
+							state.writeVector(1, 64, ^uint64(0), false)
+							state.writeVector(2, 64, 0xa55a, false)
+							before := state.clone()
+							want := before.clone()
+							value, width := ^uint64(0), 64
+							if member >= 2 {
+								low := x86CallerVectorByteMask(int64(outputBytes))
+								value, width = low|0xa55a&^low, 16
+							}
+							want.writeVector(0, width, value, false)
+							accepted, known := x86LoweredFP16ConversionStep(ins, &state, nil, arch)
+							if !accepted || !known || !reflect.DeepEqual(state, want) {
+								t.Fatal("conversion invented passthrough bytes or changed unrelated state", accepted, known)
+							}
+							for _, mutation := range []string{"mask", "input", "merge", "origin", "length", "address", "segment", "return", "literal", "operand"} {
+								if mutation == "merge" && zero {
+									continue
+								}
+								changed, rejected := ins, before.clone()
+								switch mutation {
+								case "mask":
+									rejected.masks[1] = false
+								case "input":
+									if memory {
+										rejected.pointerGP[0] = false
+									} else {
+										rejected.writeVector(1, 64, ^(uint64(1) << uint(inputBytes-1)), false)
+									}
+								case "merge":
+									rejected.writeVector(0, 64, ^(uint64(1) << uint(outputBytes-1)), false)
+								case "origin":
+									changed.x86SourceRaw = nil
+								case "length":
+									changed.x86VectorBytes ^= 16
+								case "address":
+									changed.x86AddressBits = 16
+								case "segment":
+									changed.x86SegmentPrefix = 0x64
+								case "return":
+									changed.x86RawNearReturn = new(x86RawNearReturnForm)
+								case "literal":
+									changed.x86RIPLiteral = true
+								case "operand":
+									changed.Args = append([]Operand(nil), ins.Args...)
+									changed.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+								}
+								original := rejected.clone()
+								accepted, known := x86LoweredFP16ConversionStep(changed, &rejected, nil, arch)
+								if accepted || !known || !reflect.DeepEqual(original, rejected) {
+									t.Fatal("conversion borrowed a missing input or stale source identity", mutation)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_fma_grammar_test.go b/x86_raw_fp16_fma_grammar_test.go
new file mode 100644
index 000000000..70ba00525
--- /dev/null
+++ b/x86_raw_fp16_fma_grammar_test.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RawFP16FMAMalformedBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for opcode, op := range rawFP16FMAOps() {
+			for _, mutation := range []string{"dispatch", "mask", "destination", "source", "scale", "displacement", "extension", "suffix", "empty-suffix"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", arch, op, mutation), func(t *testing.T) {
+					code := x86FP16FMAResultEncoding(opcode, 0, true, false, false)
+					file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+					file, err := normalizeX86RawFile(file, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					dispatch := ins.Op
+					switch mutation {
+					case "dispatch":
+						dispatch = "VFMADD132PH"
+						if ins.Op == dispatch {
+							dispatch = "VFMSUB132PH"
+						}
+					case "mask":
+						ins.Args[2].Reg = "K0"
+					case "destination":
+						ins.Args[3] = Operand{Kind: OpReg, Reg: AX}
+					case "source":
+						ins.Args[0] = Operand{Kind: OpImm, ImmIsFloat: true}
+					case "scale":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+					case "displacement":
+						ins.Args[0].Mem.OffRaw = "unresolved"
+					case "extension":
+						ins.Args[0].Mem.IndexExt = "invalid"
+					case "suffix":
+						ins.Op += ".INVALID"
+						dispatch = ins.Op
+					case "empty-suffix":
+						ins.Op += "."
+						dispatch = ins.Op
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerFMA3(dispatch, ins)
+					if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+						t.Fatal("malformed FP16 FMA emitted IR", known, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_fma_result_test.go b/x86_raw_fp16_fma_result_test.go
new file mode 100644
index 000000000..733488b83
--- /dev/null
+++ b/x86_raw_fp16_fma_result_test.go
@@ -0,0 +1,141 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Intel FP16 sections 5.44-5.49: all 30 multiply-add names, three orders,
+// packed/scalar forms, memory/broadcast, LLIG and all four rounding controls.
+// https://cdrdv2-public.intel.com/678970/intel-avx512-fp16.pdf
+func x86FP16FMAResultEncoding(opcode, length byte, memory, control, zero bool) []byte {
+	code := encodeRawFP16FMA(opcode, length, 2, 1, 0, 1, memory, control, zero)
+	if memory {
+		code[len(code)-1] = 0
+	}
+	return code
+}
+
+func x86FP16FMAResultFixtures(t *testing.T, arch string, order, batch int) (string, string, map[string]x86RawFP16ObjectEncoding) {
+	t.Helper()
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	encodings := make(map[string]x86RawFP16ObjectEncoding)
+	variants := 0
+	ops := rawFP16FMAOps()
+	if len(ops) != 30 {
+		t.Fatal("incomplete independent FP16 FMA family", len(ops))
+	}
+	for _, opcode := range x86FMA3Opcodes() {
+		if int(opcode>>4)-9 != order {
+			continue
+		}
+		scalar := strings.HasSuffix(string(ops[opcode]), "SH")
+		for length := byte(0); length < 4; length++ {
+			for _, memory := range []bool{false, true} {
+				for _, control := range []bool{false, true} {
+					if scalar && memory && control || !scalar && length == 3 && (memory || !control) {
+						continue
+					}
+					for _, masked := range []bool{false, true} {
+						for _, zero := range []bool{false, true} {
+							if zero && !masked {
+								continue
+							}
+							selected := variants%6 == batch
+							variants++
+							if !selected {
+								continue
+							}
+							name := fmt.Sprintf("halfFMA%d", len(encodings))
+							maskMove := "kmovw"
+							if !scalar && (length == 2 || !memory && control) {
+								maskMove = "kmovd"
+							}
+							code := x86FP16FMAResultEncoding(opcode, length, memory, control, zero)
+							if !masked {
+								code[3] &^= 7
+								maskMove = ""
+							}
+							encodings[name] = x86RawFP16ObjectEncoding{
+								code: code, lengthIgnored: scalar && !control, maskMove: maskMove,
+							}
+							fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s p+0(FP),AX\n", name, word+4, move)
+							source.WriteString("MOVL $1,CX\nKMOVD CX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n")
+							source.WriteString(x86RawDisplacementDirectives(code))
+							fmt.Fprintf(&source, "MOVL X0,DX\nMOVL DX,ret+%d(FP)\nRET\n", word)
+							fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+						}
+					}
+				}
+			}
+		}
+	}
+	if variants != 378 || len(encodings) != 63 {
+		t.Fatal("incomplete independent FP16 FMA physical partition", variants, len(encodings))
+	}
+	return source.String(), declarations.String(), encodings
+}
+
+func TestX86RawFP16FMA132NativeObjects(t *testing.T) { x86FP16FMAInitializedObjects(t, 0) }
+func TestX86RawFP16FMA213NativeObjects(t *testing.T) { x86FP16FMAInitializedObjects(t, 1) }
+func TestX86RawFP16FMA231NativeObjects(t *testing.T) { x86FP16FMAInitializedObjects(t, 2) }
+
+func x86FP16FMAInitializedObjects(t *testing.T, order int) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for batch := 0; batch < 6; batch++ {
+			t.Run(fmt.Sprintf("%s/batch%d", target.triple, batch), func(t *testing.T) {
+				source, declarations, encodings := x86FP16FMAResultFixtures(t, target.arch, order, batch)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized complete FP16 FMA inputs", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "asm sideeffect") != 63 {
+							t.Fatal("FP16 FMA lost an original native arithmetic effect", api)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86RawFP16CheckObject(t, llc, target.triple, text, level, encodings)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawFP16FMACannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for opcode, op := range rawFP16FMAOps() {
+			for _, memory := range []bool{false, true} {
+				for _, masked := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/memory%t/masked%t", arch, op, memory, masked), func(t *testing.T) {
+						code := x86FP16FMAResultEncoding(opcode, 0, memory, false, masked)
+						if !masked {
+							code[3] &^= 7
+						}
+						bare := "TEXT Value(SB),4,$0-0\n" + x86RawDisplacementDirectives(code) + "RET\n"
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, bare, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void FP16 FMA invented source, old destination or mask inputs", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_fma_state_test.go b/x86_raw_fp16_fma_state_test.go
new file mode 100644
index 000000000..36f722db0
--- /dev/null
+++ b/x86_raw_fp16_fma_state_test.go
@@ -0,0 +1,104 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawFP16FMAExactInputsAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for opcode, op := range rawFP16FMAOps() {
+			for length := byte(0); length < 3; length++ {
+				for _, memory := range []bool{false, true} {
+					for mask := 0; mask < 3; mask++ {
+						t.Run(fmt.Sprintf("%s/%s/VL%d/memory%t/mask%d", arch, op, length, memory, mask), func(t *testing.T) {
+							code := x86FP16FMAResultEncoding(opcode, length, memory, false, mask == 2)
+							if mask == 0 {
+								code[3] &^= 7
+							}
+							file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+							file, err := normalizeX86RawFile(file, arch)
+							if err != nil {
+								t.Fatal(err)
+							}
+							ins := file.Funcs[0].Instrs[1]
+							width, input := 16<<length, 16<<length
+							scalar := strings.HasSuffix(string(op), "SH")
+							if scalar {
+								width, input = 16, 2
+							}
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+							state.pointerGP[0], state.callerAddressGP[0], state.masks[1] = true, true, true
+							state.gp[2] = 0xa5
+							for reg := 0; reg < 3; reg++ {
+								state.writeVector(reg, 64, ^uint64(0), false)
+							}
+							if scalar {
+								state.writeVector(0, 64, 0xa55b, false)
+								state.writeVector(1, 64, 3, false)
+								state.writeVector(2, 64, 3, false)
+							}
+							before, want := state.clone(), state.clone()
+							value := ^uint64(0)
+							if scalar {
+								value = 0xa55b // Preserve unknown upper X bytes, not the second source.
+							}
+							want.writeVector(0, width, value, false)
+							accepted, known := x86LoweredFP16FMAStep(ins, &state, nil, arch)
+							if !accepted || !known || !reflect.DeepEqual(state, want) {
+								t.Fatal("FMA changed unrelated state or lost exact input/passthrough bytes", accepted, known)
+							}
+
+							caller := x86SourceStackState{vectors: map[Reg]uint64{
+								"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+							standalone := before.clone()
+							if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &caller, nil) ||
+								x86ScalarFPResultTransfer(ins, &standalone, nil, -1, arch) {
+								t.Fatal("raw FMA borrowed a caller or standalone query contract")
+							}
+							for _, mutation := range []string{"mask", "first", "second", "destination", "origin", "length", "address", "segment", "return", "literal", "operand"} {
+								if mutation == "mask" && mask == 0 {
+									continue
+								}
+								changed, rejected := ins, before.clone()
+								switch mutation {
+								case "mask":
+									rejected.masks[1] = false
+								case "first", "second", "destination":
+									reg := map[string]int{"first": 1, "second": 2, "destination": 0}[mutation]
+									if mutation == "first" && memory {
+										rejected.pointerGP[0] = false
+									} else {
+										rejected.writeVector(reg, 64, rejected.vectorBytes(reg)&^(uint64(1)<<uint(input-1)), false)
+									}
+								case "origin":
+									changed.x86SourceRaw = nil
+								case "length":
+									changed.x86VectorBytes ^= 16
+								case "address":
+									changed.x86AddressBits = 16
+								case "segment":
+									changed.x86SegmentPrefix = 0x64
+								case "return":
+									changed.x86RawNearReturn = new(x86RawNearReturnForm)
+								case "literal":
+									changed.x86RIPLiteral = true
+								case "operand":
+									changed.Args = append([]Operand(nil), ins.Args...)
+									changed.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+								}
+								original := rejected.clone()
+								accepted, known := x86LoweredFP16FMAStep(changed, &rejected, nil, arch)
+								if accepted || !known || !reflect.DeepEqual(original, rejected) {
+									t.Fatal("FMA invented input or original-source facts", mutation)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_sqrt_grammar_test.go b/x86_raw_fp16_sqrt_grammar_test.go
new file mode 100644
index 000000000..0df04f19f
--- /dev/null
+++ b/x86_raw_fp16_sqrt_grammar_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RawFP16SqrtMalformedBeforeIR(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for _, mutation := range []string{"dispatch", "mask", "destination", "source", "scale", "displacement", "extension", "suffix"} {
+				t.Run(fmt.Sprintf("%s/scalar%t/%s", arch, scalar, mutation), func(t *testing.T) {
+					code := x86FP16SqrtResultEncoding(scalar, 0, true, false, false)
+					file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+					file, err := normalizeX86RawFile(file, arch)
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					dispatch := ins.Op
+					switch mutation {
+					case "dispatch":
+						dispatch = "VSQRTPH"
+						if !scalar {
+							dispatch = "VSQRTSH"
+						}
+					case "mask":
+						ins.Args[len(ins.Args)-2].Reg = "K0"
+					case "destination":
+						ins.Args[len(ins.Args)-1] = Operand{Kind: OpReg, Reg: AX}
+					case "source":
+						ins.Args[0] = Operand{Kind: OpImm, ImmIsFloat: true}
+					case "scale":
+						ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+					case "displacement":
+						ins.Args[0].Mem.OffRaw = "unresolved"
+					case "extension":
+						ins.Args[0].Mem.IndexExt = "invalid"
+					case "suffix":
+						ins.Op += ".INVALID"
+						dispatch = ins.Op
+					}
+					ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					ctx.goarch = arch
+					before, temporary := output.String(), ctx.tmp
+					known, terminated, err := ctx.lowerSqrt(dispatch, ins)
+					if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+						t.Fatal("malformed raw sqrt emitted IR or escaped its family", known, terminated, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_sqrt_result_test.go b/x86_raw_fp16_sqrt_result_test.go
new file mode 100644
index 000000000..025c3ca53
--- /dev/null
+++ b/x86_raw_fp16_sqrt_result_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Intel FP16 sections 5.74/5.75: independent packed/scalar, VL/LLIG,
+// memory/broadcast, merge/zero and all four embedded rounding controls.
+// https://cdrdv2-public.intel.com/678970/intel-avx512-fp16.pdf
+func x86FP16SqrtResultEncoding(scalar bool, length byte, memory, control, zero bool) []byte {
+	code := rawFP16PackedSqrt(length, 1, 0, 1, memory, control, zero)
+	if scalar {
+		code = encodeRawFP16ScalarBinary(0x51, length, 2, 1, 0, 1, memory, control, zero)
+	}
+	if memory {
+		code[len(code)-1] = 0
+	}
+	return code
+}
+
+func TestX86RawFP16SqrtInitializedNativeObjects(t *testing.T) {
+	x86RawFP16SqrtInitializedObjects(t, true)
+}
+
+func TestX86RawFP16SqrtUnmaskedNativeObjects(t *testing.T) {
+	x86RawFP16SqrtInitializedObjects(t, false)
+}
+
+func x86RawFP16SqrtInitializedObjects(t *testing.T, masked bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			encodings := make(map[string]x86RawFP16ObjectEncoding)
+			count := 0
+			for _, scalar := range []bool{false, true} {
+				for length := byte(0); length < 4; length++ {
+					for _, memory := range []bool{false, true} {
+						for _, control := range []bool{false, true} {
+							if !scalar && length == 3 && (memory || !control) || scalar && memory && control {
+								continue
+							}
+							for _, zero := range []bool{false, true} {
+								if zero && !masked {
+									continue
+								}
+								name := fmt.Sprintf("halfSqrt%d", count)
+								maskMove := "kmovw"
+								if !scalar && (length == 2 || !memory && control) {
+									maskMove = "kmovd"
+								}
+								code := x86FP16SqrtResultEncoding(scalar, length, memory, control, zero)
+								if !masked {
+									code[3] &^= 7
+									maskMove = ""
+								}
+								encodings[name] = x86RawFP16ObjectEncoding{
+									code: code, lengthIgnored: scalar && !control, maskMove: maskMove,
+								}
+								fmt.Fprintf(&source, "TEXT %s(SB),4,$0-%d\n%s p+0(FP),AX\n", name, word+4, move)
+								source.WriteString("MOVL $1,CX\nKMOVD CX,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n")
+								source.WriteString(x86RawDisplacementDirectives(code))
+								fmt.Fprintf(&source, "MOVL X0,DX\nMOVL DX,ret+%d(FP)\nRET\n", word)
+								fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+								count++
+							}
+						}
+					}
+				}
+			}
+			want, wideMasks := 50, 14
+			if !masked {
+				want, wideMasks = 25, 0
+			}
+			if count != want {
+				t.Fatal("incomplete independent FP16 SQRT physical forms", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized raw FP16 SQRT family", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if strings.Count(text, "asm sideeffect") != count || !strings.Contains(text, "vsqrtph ") || !strings.Contains(text, "vsqrtsh ") {
+						t.Fatal("FP16 SQRT lost its native rounding/exception effect", api)
+					}
+					// ZMM holds 32 half lanes: a word-sized mask load would
+					// silently discard lanes 16-31. ER also selects ZMM.
+					if strings.Count(text, "kmovd ${3:k}, %k1;") != wideMasks {
+						t.Fatal("FP16 Z square roots truncated the 32-lane mask", api)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86RawFP16CheckObject(t, llc, target.triple, text, level, encodings)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawFP16SqrtCannotInventInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for _, memory := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/scalar%t/memory%t", arch, scalar, memory), func(t *testing.T) {
+					code := x86RawDisplacementDirectives(x86FP16SqrtResultEncoding(scalar, 0, memory, false, false))
+					bare := "TEXT Value(SB),4,$0-0\n" + code + "RET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, bare, "func Value()", arch, x86AddressMemoryTargets(arch)[0], api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void FP16 SQRT borrowed unknown input or mask", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_fp16_sqrt_state_test.go b/x86_raw_fp16_sqrt_state_test.go
new file mode 100644
index 000000000..7f1be9e0b
--- /dev/null
+++ b/x86_raw_fp16_sqrt_state_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawFP16SqrtExactSourceAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, scalar := range []bool{false, true} {
+			for length := byte(0); length < 3; length++ {
+				for _, memory := range []bool{false, true} {
+					for _, zero := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/scalar%t/VL%d/memory%t/zero%t", arch, scalar, length, memory, zero), func(t *testing.T) {
+							code := x86FP16SqrtResultEncoding(scalar, length, memory, false, zero)
+							file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+							file, err := normalizeX86RawFile(file, arch)
+							if err != nil {
+								t.Fatal(err)
+							}
+							ins := file.Funcs[0].Instrs[1]
+							caller := x86SourceStackState{vectors: map[Reg]uint64{
+								"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+							if x86CallerVectorMoveKnown(ins) || x86CallerVectorMoveStep(&ins, &caller, nil) {
+								t.Fatal("raw sqrt acquired a standalone caller contract")
+							}
+							width, input := 16<<length, 16<<length
+							if scalar {
+								width, input = 16, 2
+							}
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+							state.pointerGP[0], state.callerAddressGP[0], state.masks[1] = true, true, true
+							state.gp[2] = 0xa5
+							state.writeVector(0, 64, ^uint64(0), false)
+							state.writeVector(1, 64, ^uint64(0), false)
+							state.writeVector(2, 64, 0xa55a, false)
+							before, want := state.clone(), state.clone()
+							value := ^uint64(0)
+							if scalar {
+								value = 3 | 0xa55a&^3
+							}
+							want.writeVector(0, width, value, false)
+							accepted, known := x86ResultSqrtStep(ins, &state, nil, arch, true)
+							if !accepted || !known || !reflect.DeepEqual(state, want) {
+								t.Fatal("raw sqrt lost exact input, passthrough or unrelated state", accepted, known)
+							}
+							for _, mutation := range []string{"mask", "input", "merge", "origin", "length", "address", "segment", "return", "literal", "operand", "standalone"} {
+								if mutation == "merge" && zero {
+									continue
+								}
+								changed, rejected, native := ins, before.clone(), true
+								switch mutation {
+								case "mask":
+									rejected.masks[1] = false
+								case "input":
+									if memory {
+										rejected.pointerGP[0] = false
+									} else {
+										rejected.writeVector(1, 64, ^(uint64(1) << uint(input-1)), false)
+									}
+								case "merge":
+									rejected.writeVector(0, 64, ^(uint64(1) << uint(input-1)), false)
+								case "origin":
+									changed.x86SourceRaw = nil
+								case "length":
+									changed.x86VectorBytes ^= 16
+								case "address":
+									changed.x86AddressBits = 16
+								case "segment":
+									changed.x86SegmentPrefix = 0x64
+								case "return":
+									changed.x86RawNearReturn = new(x86RawNearReturnForm)
+								case "literal":
+									changed.x86RIPLiteral = true
+								case "operand":
+									changed.Args = append([]Operand(nil), ins.Args...)
+									changed.Args[0] = Operand{Kind: OpReg, Reg: "X7"}
+								case "standalone":
+									native = false
+								}
+								original := rejected.clone()
+								accepted, known := x86ResultSqrtStep(changed, &rejected, nil, arch, native)
+								if accepted || !known || !reflect.DeepEqual(original, rejected) {
+									t.Fatal("raw sqrt borrowed missing input or unbound source", mutation)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_integer_compare_literal_test.go b/x86_raw_integer_compare_literal_test.go
new file mode 100644
index 000000000..3a3fd747c
--- /dev/null
+++ b/x86_raw_integer_compare_literal_test.go
@@ -0,0 +1,223 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawIntegerCompareLiteralCase struct {
+	name, op           string
+	width, tuple, mask int
+	maskResult         bool
+	code               []byte
+}
+
+// Independent _yvpcmpeqb witnesses include its two VEX and six EVEX rows,
+// each opcode's full/broadcast tuple, and both VEX prefixes where encodable.
+// The production opcode registry does not supply these bytes or cardinality.
+func x86RawIntegerCompareLiteralCases() []x86RawIntegerCompareLiteralCase {
+	var rows []x86RawIntegerCompareLiteralCase
+	for _, operation := range []struct {
+		name      string
+		opcode    byte
+		mapNumber byte
+		laneBytes int
+	}{
+		{"VPCMPEQB", 0x74, 1, 1}, {"VPCMPEQW", 0x75, 1, 2},
+		{"VPCMPEQD", 0x76, 1, 4}, {"VPCMPEQQ", 0x29, 2, 8},
+		{"VPCMPGTB", 0x64, 1, 1}, {"VPCMPGTW", 0x65, 1, 2},
+		{"VPCMPGTD", 0x66, 1, 4}, {"VPCMPGTQ", 0x37, 2, 8},
+	} {
+		for _, generation := range []string{"VEX2", "VEX3", "EVEX"} {
+			if generation == "VEX2" && operation.mapNumber != 1 {
+				continue
+			}
+			widths, masks := []int{16, 32}, []int{0}
+			if generation == "EVEX" {
+				widths, masks = []int{16, 32, 64}, []int{0, 3, 7}
+			}
+			for length, width := range widths {
+				for _, mask := range masks {
+					broadcasts := []bool{false}
+					if generation == "EVEX" && operation.laneBytes >= 4 {
+						broadcasts = append(broadcasts, true)
+					}
+					for _, broadcast := range broadcasts {
+						row := x86RawIntegerCompareLiteralCase{
+							name: fmt.Sprintf("%s%s_%d_%d_%t", operation.name, generation, width, mask, broadcast),
+							op:   operation.name, width: width, tuple: width, mask: mask, maskResult: generation == "EVEX",
+						}
+						switch generation {
+						case "VEX2":
+							row.code = []byte{0xc5, 0xf9 | byte(length<<2)}
+						case "VEX3":
+							row.code = []byte{0xc4, 0xe0 | operation.mapNumber, 0x79 | byte(length<<2)}
+						case "EVEX":
+							w := byte(0)
+							if operation.laneBytes == 8 {
+								w = 0x80
+							}
+							row.code = []byte{0x62, 0xf0 | operation.mapNumber, 0x7d | w, 0x08 | byte(length<<5) | byte(mask)}
+							if broadcast {
+								row.code[3] |= 0x10
+								row.op += ".BCST"
+								row.tuple = operation.laneBytes
+							}
+						}
+						// RIP source, vector input 0, destination vector 2 or K2.
+						row.code = append(row.code, operation.opcode, 0x15, 1, 0, 0, 0, 0xc3)
+						for index := 0; index < row.tuple; index++ {
+							row.code = append(row.code, byte(index*17+5))
+						}
+						rows = append(rows, row)
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawIntegerCompareLiteralSource(row x86RawIntegerCompareLiteralCase) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", row.name)
+	source.WriteString("VPXORD Z0,Z0,Z0\nMOVL $5,AX\nKMOVD AX,K3\nKMOVD AX,K7\n")
+	for _, value := range row.code {
+		fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+	}
+	return source.String()
+}
+
+func x86RawIntegerCompareLiteralObjects(t *testing.T, triple string) {
+	t.Helper()
+	rows := x86RawIntegerCompareLiteralCases()
+	if len(rows) != 136 {
+		t.Fatal("incomplete independent integer compare literal directory", len(rows))
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for start := 0; start < len(rows); start += 64 {
+		end := start + 64
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch%d", start/64), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, row := range rows[start:end] {
+				source.WriteString(x86RawIntegerCompareLiteralSource(row))
+				fmt.Fprintf(&declarations, "func %s()\n", row.name)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("bound integer comparison lost its literal tuple", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawIntegerCompareLiteralLinuxObjects(t *testing.T) {
+	x86RawIntegerCompareLiteralObjects(t, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86RawIntegerCompareLiteralDarwinObjects(t *testing.T) {
+	x86RawIntegerCompareLiteralObjects(t, "x86_64-apple-darwin")
+}
+
+func TestX86RawIntegerCompareLiteralWindowsObjects(t *testing.T) {
+	x86RawIntegerCompareLiteralObjects(t, "x86_64-pc-windows-msvc")
+}
+
+func TestX86RawIntegerCompareLiteralEveryInputByteAndTuple(t *testing.T) {
+	for _, row := range x86RawIntegerCompareLiteralCases() {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawIntegerCompareLiteralSource(row)), "amd64")
+		if err != nil {
+			t.Fatal(row.name, err)
+		}
+		for _, ins := range file.Funcs[0].Instrs {
+			if !ins.x86RIPLiteral {
+				continue
+			}
+			form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, "amd64")
+			if !known || err != nil || string(ins.Op) != row.op || form.byteWidth != row.width ||
+				form.memoryBytes != row.tuple || form.maskResult != row.maskResult ||
+				!x86RawIntegerCompareLiteralForm(ins, "amd64") || x86RawIntegerCompareLiteralForm(ins, "386") {
+				t.Fatal("original bytes changed their independent tuple/destination role", row.name, err)
+			}
+			address, valid := x86StaticSBReadAddress(form.source, "amd64")
+			if !valid {
+				t.Fatal("literal lost its DATA identity", row.name)
+			}
+			for missing := -1; missing < row.width; missing++ {
+				state := x86ResultState{flags: 0x3f,
+					loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(row.tuple)}}
+				state.masks[3], state.masks[7] = true, true
+				bytes := ^uint64(0)
+				if missing >= 0 {
+					bytes &^= uint64(1) << uint(missing)
+				}
+				state.writeVector(0, 64, bytes, false)
+				accepted, known := x86ResultVectorCompareStep(ins, &state, nil, "amd64")
+				if !known || accepted != (missing < 0) || state.flags != 0x3f {
+					t.Fatal("comparison invented an input byte or changed FLAGS", row.name, missing)
+				}
+				if accepted && (row.maskResult && !state.masks[2] || !row.maskResult && state.vectorBytes(2) != ^uint64(0)) {
+					t.Fatal("comparison lost its mask/vector destination", row.name)
+				}
+				state.loweredStaticReads[address]--
+				if accepted, _ := x86ResultVectorCompareStep(ins, &state, nil, "amd64"); accepted {
+					t.Fatal("comparison accepted an incomplete tuple", row.name)
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawIntegerCompareLiteralKeepsMissingInputsAndSource(t *testing.T) {
+	for _, row := range x86RawIntegerCompareLiteralCases() {
+		source := x86RawIntegerCompareLiteralSource(row)
+		changes := []string{
+			strings.Replace(source, "VPXORD Z0,Z0,Z0\n", "", 1),
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "BYTE ", "MOVQ $0,SP\nBYTE ", 1),
+		}
+		if row.mask != 0 {
+			changes = append(changes, strings.Replace(source, fmt.Sprintf("KMOVD AX,K%d\n", row.mask), "", 1))
+		}
+		for _, changed := range changes {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, "func "+row.name+"()", "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("literal waived an independent input/return obligation", row.name, api, err)
+				}
+			}
+		}
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+		if err != nil || len(file.Data) != 1 {
+			t.Fatal(row.name, err)
+		}
+		if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("standalone comparison query borrowed the DATA owner", row.name, err)
+		}
+		file.Data[0].Payload[0] ^= 1
+		options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+			Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+			ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+		if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("comparison accepted changed original DATA", row.name, err)
+		}
+	}
+}
diff --git a/x86_raw_integer_compare_origin_test.go b/x86_raw_integer_compare_origin_test.go
new file mode 100644
index 000000000..52f54c860
--- /dev/null
+++ b/x86_raw_integer_compare_origin_test.go
@@ -0,0 +1,333 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawIntegerCompareOriginCase struct {
+	row, bank, destination string
+	legacy, memory, mask   bool
+}
+
+// Independent ymm/yxm_q4 and ordered _yvpcmpeqb directory. The six MMX
+// members retain their separate complete native-MMX region owner; this adapter
+// must not project those physical x87-tag effects into ordinary vector bytes.
+func x86RawIntegerCompareOriginCases() []x86RawIntegerCompareOriginCase {
+	var rows []x86RawIntegerCompareOriginCase
+	for _, name := range x86PackedIntegerCompareTestNames[:8] {
+		for _, memory := range []bool{false, true} {
+			first := "X1"
+			if memory {
+				first = "(BX)"
+			}
+			rows = append(rows, x86RawIntegerCompareOriginCase{name + " " + first + ",X2", "X", "X2", true, memory, false})
+		}
+	}
+	for _, name := range x86PackedIntegerCompareTestNames[8:] {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, memory := range []bool{false, true} {
+				first := bank + "1"
+				if memory {
+					first = "(BX)"
+				}
+				if bank != "Z" {
+					rows = append(rows, x86RawIntegerCompareOriginCase{name + " " + first + "," + bank + "0," + bank + "2", bank, bank + "2", false, memory, false})
+				}
+				for _, masked := range []bool{false, true} {
+					mask := ""
+					if masked {
+						mask = "K1,"
+					}
+					operands := first + "," + bank + "0," + mask + "K2"
+					rows = append(rows, x86RawIntegerCompareOriginCase{name + " " + operands, bank, "K2", false, memory, masked})
+					if memory && (strings.HasSuffix(name, "D") || strings.HasSuffix(name, "Q")) {
+						rows = append(rows, x86RawIntegerCompareOriginCase{name + ".BCST " + operands, bank, "K2", false, true, masked})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawIntegerCompareOriginBytes(t *testing.T, rows []x86RawIntegerCompareOriginCase) [][]byte {
+	t.Helper()
+	var body strings.Builder
+	for _, row := range rows {
+		body.WriteString(row.row + "\n")
+	}
+	// Low physical registers have identical encodings in both modes. Observe
+	// actual Go AMD64 bytes once; its named frontend, unlike the machine,
+	// permits the four-operand EVEX rows. Original 386 BYTE objects remain
+	// independent required witnesses, not named-386 arity permission.
+	code, pcs := x86NumericalBoundaryGoBytes(t, "amd64", body.String()+"RET")
+	if len(pcs) != len(rows)+1 || code[len(code)-1] != 0xc3 {
+		t.Fatal("incomplete independent original Go comparison bytes/PCs")
+	}
+	result := make([][]byte, len(rows))
+	for index := range rows {
+		result[index] = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+	}
+	return result
+}
+
+func x86RawIntegerCompareOriginSource(row x86RawIntegerCompareOriginCase, code []byte, arch, control string) (string, string) {
+	word, suffix, move := goWordSize(arch), "Q", "MOVQ"
+	if arch == "386" {
+		suffix, move = "L", "MOVL"
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Compare(SB),4,$0-%d\n%s a+0(FP),AX\n", 3*word+8, move)
+	if control == "numeric address" {
+		source.WriteString("MOVL $42,BX\n")
+	} else if control != "address" {
+		fmt.Fprintf(&source, "%s b+%d(FP),BX\n", move, word)
+	}
+	fmt.Fprintf(&source, "%s out+%d(FP),DI\n", move, 2*word)
+	if control != "mask" {
+		fmt.Fprintf(&source, "KMOVD mask+%d(FP),K1\n", 3*word)
+	}
+	if control != "second" || row.legacy {
+		source.WriteString("VMOVUPS (AX),Z0\n")
+	}
+	if control != "second" || !row.legacy {
+		source.WriteString("VMOVUPS (AX),Z2\n")
+	}
+	if !row.memory && control != "first" {
+		source.WriteString("VMOVUPS (BX),Z1\n")
+	}
+	// All six status flags and DF have real producers. An integer compare
+	// changes none of them; the adjacent masked PUSHF observation consumes
+	// only these defined bits, not unknown reserved/privileged FLAGS bits.
+	source.WriteString("MOVL $3,CX\nCMPL CX,$3\nSTD\n")
+	if control == "named" {
+		source.WriteString(row.row + "\n")
+	} else {
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+	}
+	if row.destination == "K2" {
+		source.WriteString("KMOVQ K2,(DI)\nVMOVUPS Z0,16(DI)\n")
+	} else {
+		source.WriteString("VMOVUPS Z2,(DI)\n")
+	}
+	fmt.Fprintf(&source, "PUSHF%s\nPOP%s CX\nANDL $0xcd5,CX\nMOVL CX,96(DI)\nCLD\nRET\n", suffix, suffix)
+	return source.String(), "func Compare(a,b,out *[128]byte,mask uint64)\n"
+}
+
+func x86RawIntegerCompareUnusedBoolSource(source, declaration, arch string) (string, string) {
+	extent := 3*goWordSize(arch) + 8
+	source = strings.Replace(source, fmt.Sprintf("$0-%d\n", extent), fmt.Sprintf("$0-%d\n", extent+1), 1)
+	declaration = strings.Replace(declaration, "mask uint64)", "mask uint64,unused bool)", 1)
+	return source, declaration
+}
+
+func TestX86RawIntegerCompareCompleteIndependentOriginDirectory(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	if len(rows) != 168 {
+		t.Fatal("complete legacy/VEX/EVEX/K/broadcast directory changed", len(rows))
+	}
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		if seen[row.row] {
+			t.Fatal("duplicate independent comparison row", row.row)
+		}
+		seen[row.row] = true
+	}
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, code[index])
+				form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch)
+				if !known || err != nil || string(ins.Op) != strings.Fields(row.row)[0] ||
+					form.byteWidth != map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank] ||
+					form.broadcast != strings.Contains(row.row, ".BCST ") || form.legacy != row.legacy || form.mmx ||
+					(form.memory >= 0) != row.memory || (form.mask >= 0) != row.mask ||
+					ins.Args[form.destination].Reg != Reg(row.destination) {
+					t.Fatal("original Go bytes lost their complete independent typed comparison roles", err)
+				}
+			})
+		}
+	}
+}
+
+// Use exactly the same initialized loads, fields, result uses and defined-only
+// FLAGS/DF observation. Only the compare's original representation changes.
+// This independently distinguishes its raw-origin gap from an earlier named
+// native load that a whole-source diagnostic might otherwise report first.
+func TestX86RawIntegerCompareSameSourceNamedControls(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	for start := 0; start < len(rows); start += x86RawIntegerCompareOriginBatchSize {
+		end := start + x86RawIntegerCompareOriginBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint(start/x86RawIntegerCompareOriginBatchSize), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows[start:end] {
+				body, declaration := x86RawIntegerCompareOriginSource(row, nil, "amd64", "named")
+				name := fmt.Sprint("Compare", start+index)
+				source.WriteString(strings.ReplaceAll(body, "Compare", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Compare", name))
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("same-source named control lost an initialized load, input or defined-only FLAGS/DF observation", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+const x86RawIntegerCompareOriginBatchSize = 32
+
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch00(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 0)
+}
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch01(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 1)
+}
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch02(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 2)
+}
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch03(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 3)
+}
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch04(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 4)
+}
+func TestX86RawIntegerCompareInitializedFiveTargetsBatch05(t *testing.T) {
+	x86RawIntegerCompareOriginObjectBatch(t, 5)
+}
+
+func x86RawIntegerCompareOriginObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	rows := x86RawIntegerCompareOriginCases()
+	start, end := batch*x86RawIntegerCompareOriginBatchSize, (batch+1)*x86RawIntegerCompareOriginBatchSize
+	if start < 0 || start >= len(rows) {
+		t.Fatal("invalid original comparison object batch", batch)
+	}
+	if end > len(rows) {
+		end = len(rows)
+	}
+	rows = rows[start:end]
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				body, declaration := x86RawIntegerCompareOriginSource(row, code[index], target.arch, "")
+				name := fmt.Sprint("Compare", start+index)
+				source.WriteString(strings.ReplaceAll(body, "Compare", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Compare", name))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized original comparison cannot compose with named native views and defined FLAGS/DF", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "compare-origin.ll", "compare-origin.o", body)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawIntegerCompareVoidAndUnusedBoolCannotBorrowInputs(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	for index, row := range rows {
+		for _, control := range []string{"first", "second", "mask", "address", "numeric address"} {
+			if control == "first" && row.memory || control == "mask" && !row.mask ||
+				(control == "address" || control == "numeric address") && !row.memory {
+				continue
+			}
+			t.Run(row.row+"/"+control, func(t *testing.T) {
+				for _, arch := range []string{"386", "amd64"} {
+					source, declaration := x86RawIntegerCompareOriginSource(row, code[index], arch, control)
+					for _, unused := range []bool{false, true} {
+						body, decl := source, declaration
+						if unused {
+							body, decl = x86RawIntegerCompareUnusedBoolSource(body, decl, arch)
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, body, decl, arch, x86AddressMemoryTargets(arch)[0], api)
+							if control == "numeric address" {
+								if err != nil || ir == "" {
+									t.Fatal("initialized raw compare address lost its paired native read", api, err)
+								}
+								original, signature := x86RawIntegerCompareOriginSource(row, code[index], arch, "")
+								if unused {
+									original, signature = x86RawIntegerCompareUnusedBoolSource(original, signature, arch)
+								}
+								pointerIR, err := x86ScalarFPBitViewAPI(t, original, signature, arch, x86AddressMemoryTargets(arch)[0], api)
+								if err != nil {
+									t.Fatal(err)
+								}
+								x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+								x86RequireNumericNativeSourceContext(t, body, decl, arch)
+								x86NumericNativeAddressObject(t, ir, x86AddressMemoryTargets(arch)[0])
+								continue
+							}
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("dead/unused-bool compare acquired missing data, mask or native pointer facts", arch, unused, api, err)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawIntegerCompareInitializedUnusedBoolAllSourceForms(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	for start := 0; start < len(rows); start += x86RawIntegerCompareOriginBatchSize {
+		end := start + x86RawIntegerCompareOriginBatchSize
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint(start/x86RawIntegerCompareOriginBatchSize), func(t *testing.T) {
+			for _, target := range x86RawReturnTargets {
+				t.Run(target.triple, func(t *testing.T) {
+					var source, declarations strings.Builder
+					for index, row := range rows[start:end] {
+						body, declaration := x86RawIntegerCompareOriginSource(row, code[start+index], target.arch, "")
+						body, declaration = x86RawIntegerCompareUnusedBoolSource(body, declaration, target.arch)
+						name := fmt.Sprint("Compare", start+index)
+						source.WriteString(strings.ReplaceAll(body, "Compare", name))
+						declarations.WriteString(strings.ReplaceAll(declaration, "Compare", name))
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("unused bool changed a completely initialized raw comparison with its exact source extent", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_raw_integer_compare_state_test.go b/x86_raw_integer_compare_state_test.go
new file mode 100644
index 000000000..b062bec6c
--- /dev/null
+++ b/x86_raw_integer_compare_state_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawIntegerCompareEveryInputByteAndIndependentState(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for ordinal, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, code[ordinal])
+				width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+				second := 0
+				if row.legacy {
+					second = 2
+				}
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						state := x86RawMoveInitializedState()
+						state.masks[2] = false // K destinations are write-only, including masked compares.
+						if missing >= 0 {
+							state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+						}
+						before, expected := state.clone(), state.clone()
+						wanted := missing < 0 || missing >= width || input != second && (row.memory || input != 1)
+						if wanted {
+							if row.destination == "K2" {
+								expected.masks[2] = true
+							} else {
+								expected.writeVector(2, width, x86CallerVectorByteMask(int64(width)), row.legacy)
+							}
+						}
+						accepted, known := x86LoweredPackedIntegerCompareStep(ins, &state, nil, arch)
+						if !known || accepted != wanted || wanted && !reflect.DeepEqual(state, expected) ||
+							!wanted && !reflect.DeepEqual(state, before) {
+							t.Fatal("raw compare invented input, merged K output, erased an alias or changed independent FLAGS/DF/storage", input, missing, accepted, wanted)
+						}
+					}
+				}
+				for _, control := range []string{"mask", "native address"} {
+					if control == "mask" && !row.mask || control == "native address" && !row.memory {
+						continue
+					}
+					state := x86RawMoveInitializedState()
+					if control == "mask" {
+						state.masks[1] = false
+					} else {
+						state.pointerGP[3] = false // Complete NUM permits only the paired native read.
+					}
+					before := state.clone()
+					if accepted, known := x86LoweredPackedIntegerCompareStep(ins, &state, nil, arch); !known || accepted != (control == "native address") || !reflect.DeepEqual(state, before) {
+						t.Fatal("raw compare borrowed an unknown mask or native address", control)
+					}
+					if control == "native address" {
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[3] = available
+							unchanged := partial.clone()
+							if accepted, _ := x86LoweredPackedIntegerCompareStep(ins, &partial, nil, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("raw comparison acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawIntegerCompareEditedOriginRejectsAtomically(t *testing.T) {
+	rows := x86RawIntegerCompareOriginCases()
+	code := x86RawIntegerCompareOriginBytes(t, rows)
+	for _, arch := range []string{"386", "amd64"} {
+		for ordinal, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, code[ordinal])
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"opcode", func(ins *Instr) {
+						if strings.Contains(string(ins.Op), "EQ") {
+							ins.Op = Op(strings.Replace(string(ins.Op), "EQ", "GT", 1))
+						} else {
+							ins.Op = Op(strings.Replace(string(ins.Op), "GT", "EQ", 1))
+						}
+					}},
+					{"operand", func(ins *Instr) {
+						if row.memory {
+							ins.Args[0].Mem.Off++
+						} else {
+							ins.Args[0].Reg = Reg(row.bank + "4")
+						}
+					}},
+					{"source opcode", func(ins *Instr) { ins.x86SourceRaw.op = "MOVL" }},
+					{"source operand", func(ins *Instr) { ins.x86SourceRaw.args[0] = Operand{} }},
+					{"vector width", func(ins *Instr) { ins.x86VectorBytes += 16 }},
+					{"source width", func(ins *Instr) { ins.x86SourceRaw.vectorBytes += 16 }},
+					{"address width", func(ins *Instr) { ins.x86AddressBits = 16 }},
+					{"address override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+					{"raw return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+					{"numerical certificate", func(ins *Instr) { ins.x86NumericalRead = new(x86NumericalReadCertificate) }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					control.edit(&changed)
+					state := x86RawMoveInitializedState()
+					before := state.clone()
+					if accepted, _ := x86LoweredPackedIntegerCompareStep(changed, &state, nil, arch); accepted ||
+						x86RawPackedIntegerCompareSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited raw compare borrowed or partially committed a paired typed/native effect", control.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_legacy_float_compare_boundaries_test.go b/x86_raw_legacy_float_compare_boundaries_test.go
new file mode 100644
index 000000000..43ff42b90
--- /dev/null
+++ b/x86_raw_legacy_float_compare_boundaries_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86RawLegacyFloatCompareState() x86ResultState {
+	state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+	state.pointerGP[0], state.pointerGP[3], state.callerAddressGP[0] = true, true, true
+	state.gp[1], state.masks[7] = 0xff, true
+	state.valueStack = &x86ResultValueStack{bytes: []uint8{0xff, 0xa5, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff}, id: true}
+	state.writeVector(0, 64, ^uint64(0), false)
+	state.writeVector(1, 64, ^uint64(0), false)
+	return state
+}
+
+func TestX86RawLegacyFloatingCompareEveryByteAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					ins := x86RawMoveObservedInstruction(t, arch, row.code(memory, 255))
+					for input := 0; input < 2; input++ {
+						for missing := -1; missing < 64; missing++ {
+							state := x86RawLegacyFloatCompareState()
+							if missing >= 0 {
+								state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+							}
+							before, want := state.clone(), state.clone()
+							accept := missing < 0 || missing >= row.input || memory && input == 1
+							if accept {
+								want.writeVector(0, 16, before.vectorBytes(0)|x86CallerVectorByteMask(int64(row.input)), true)
+							}
+							accepted, known := x86ResultFloatCompareStep(ins, &state, nil, arch, true)
+							if !known || accepted != accept || !reflect.DeepEqual(state, want) {
+								t.Fatal("raw compare lost a required input, preserved unknown byte or independent state", memory, input, missing, accepted)
+							}
+						}
+					}
+					if memory {
+						state := x86RawLegacyFloatCompareState()
+						state.pointerGP[3], state.gp[3] = false, 0xff
+						before := state.clone()
+						if accepted, known := x86ResultFloatCompareStep(ins, &state, nil, arch, true); !known || !accepted || !reflect.DeepEqual(state, before) {
+							t.Fatal("numerical comparison changed independent state or acquired pointer identity")
+						}
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[3] = available
+							unchanged := partial.clone()
+							if accepted, _ := x86ResultFloatCompareStep(ins, &partial, nil, arch, true); accepted || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("raw float comparison acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+					if !x86ResultPreservesPrivateStorage(ins, arch) ||
+						x86ResultDirectionAfterSource(ins, x86ResultDirectionBackward, arch) != x86ResultDirectionBackward ||
+						x86ResultCallerAddressesAfter(ins, [16]bool{true}, nil, arch) != [16]bool{true} ||
+						x86PreservesNumericalSourceState(ins) {
+						t.Fatal("data-changing compare lost independent controls or became an inert instruction")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareRejectsEditedIdentityAtomically(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, row.code(true, 128))
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					// This is an encoded instruction without a source witness,
+					// not an origin-only mutation. Legacy decoding does not set
+					// x86Encoded; erasing only origin can look exactly named.
+					{"unbound-encoded", func(ins *Instr) { ins.x86SourceRaw, ins.x86Encoded = nil, true }},
+					{"snapshot", func(ins *Instr) { ins.x86SourceRaw.legacyFloatCompare = x86RawLegacyFloatCompareIdentity{} }},
+					{"mode", func(ins *Instr) { ins.x86SourceRaw.legacyFloatCompare.arch = "arm64" }},
+					{"generation", func(ins *Instr) { ins.x86Encoded = !ins.x86Encoded }},
+					{"opcode", func(ins *Instr) {
+						ins.Op = "CMPPS"
+						if row.op == "CMPPS" {
+							ins.Op = "CMPPD"
+						}
+					}},
+					{"selector", func(ins *Instr) { ins.Args[2].Imm++ }},
+					{"destination", func(ins *Instr) { ins.Args[1].Reg = "X2" }},
+					{"memory", func(ins *Instr) { ins.Args[0].Mem.Off++ }},
+					{"origin-selector", func(ins *Instr) { ins.x86SourceRaw.args[2].Imm++ }},
+					{"width", func(ins *Instr) { ins.x86VectorBytes += 16 }},
+					{"address-width", func(ins *Instr) { ins.x86AddressBits = 16 }},
+					{"address-override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+					{"return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+					{"numerical-read", func(ins *Instr) { ins.x86NumericalRead = new(x86NumericalReadCertificate) }},
+				} {
+					t.Run(control.name, func(t *testing.T) {
+						changed := cloneX86ReplayInstrs([]Instr{original})[0]
+						control.edit(&changed)
+						state := x86RawLegacyFloatCompareState()
+						before := state.clone()
+						if accepted, _ := x86ResultFloatCompareStep(changed, &state, nil, arch, true); accepted ||
+							x86RawLegacyFloatCompareSource(changed, arch) || !reflect.DeepEqual(state, before) {
+							t.Fatal("changed raw identity acquired numerical input, native or independent DATA permission", control.name)
+						}
+					})
+				}
+				if !x86RawLegacyFloatCompareSource(original, arch) {
+					t.Fatal("editing a mutable clone corrupted the immutable original mode snapshot")
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareNeedsWholeReplayAndActualInputs(t *testing.T) {
+	for _, row := range x86RawLegacyFloatCompareOracles {
+		for _, memory := range []bool{false, true} {
+			t.Run(row.op+"/memory="+map[bool]string{false: "false", true: "true"}[memory], func(t *testing.T) {
+				prefix := "TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),BX\nPXOR X0,X0\nPXOR X1,X1\n"
+				source := prefix + x86RawDisplacementDirectives(row.code(memory, 8)) + "RET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api); ir == "" || err != nil {
+						t.Fatal("initialized Void compare lost its original dead native exception effect", api, err)
+					}
+					for _, producer := range []string{"PXOR X0,X0\n", "PXOR X1,X1\n", "MOVQ p+0(FP),BX\n"} {
+						if memory && producer == "PXOR X1,X1\n" || !memory && producer == "MOVQ p+0(FP),BX\n" {
+							continue
+						}
+						changed := strings.Replace(source, producer, "", 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, changed, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead or reserved-selector compare borrowed a missing native input", producer, api, err)
+						}
+					}
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+				if err != nil || file.Funcs[0].x86RawReplay == nil {
+					t.Fatal("original raw source lost immutable whole replay", err)
+				}
+				original := file.Funcs[0]
+				if err := original.x86RawReplay.validate(original, "amd64"); err != nil {
+					t.Fatal("original replay did not bind its ordinary producers", err)
+				}
+				changed := original
+				changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+				changed.Instrs[2].Op = "XORPS" // Equivalent zero producer, different original source.
+				if changed.x86RawReplay.validate(changed, "amd64") == nil || original.x86RawReplay.validate(original, "amd64") != nil {
+					t.Fatal("rewritten producer borrowed or mutated the original immutable source replay")
+				}
+				// validate alone only tests the private replay object. Exercise
+				// the actual whole-Func consumer that must enforce this identity.
+				check := x86LegacyFloatReplayCheck(t, "amd64", source, "func Value(p *byte)")
+				if check(original) != nil || !errors.Is(check(changed), ErrProbeNeedsContext) {
+					t.Fatal("actual lowering consumer failed to retain its original complete-source replay restriction")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_legacy_float_compare_continuation_test.go b/x86_raw_legacy_float_compare_continuation_test.go
new file mode 100644
index 000000000..dbb9dd259
--- /dev/null
+++ b/x86_raw_legacy_float_compare_continuation_test.go
@@ -0,0 +1,180 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This directory is independent of the production compare map. Legacy SSE
+// has one X-result shape, signed Yi8 syntax and four refining prefixes. Intel
+// SDM Vol.2A CMPPS/PD/SS/SD and Intel XED xed-isa.txt distinguish packed m128
+// alignment/SSE_TYPE_2 from scalar m32/m64/SSE_TYPE_3 and preserve MXCSR.
+// Selectors 8..255 remain original bytes, not invented IEEE truth tables.
+type x86RawLegacyFloatCompareOracle struct {
+	op     string
+	prefix byte
+	input  int
+}
+
+var x86RawLegacyFloatCompareOracles = []x86RawLegacyFloatCompareOracle{
+	{"CMPPS", 0, 16}, {"CMPPD", 0x66, 16},
+	{"CMPSS", 0xf3, 4}, {"CMPSD", 0xf2, 8},
+}
+
+func (row x86RawLegacyFloatCompareOracle) code(memory bool, predicate byte) []byte {
+	var code []byte
+	if row.prefix != 0 {
+		code = append(code, row.prefix)
+	}
+	modrm := byte(0xc1) // destination X0, source X1
+	if memory {
+		modrm = 0x03 // destination X0, source (BX)
+	}
+	return append(code, 0x0f, 0xc2, modrm, predicate)
+}
+
+func x86RawLegacyFloatCompareOriginalProgramsUnchanged(t *testing.T) {
+	t.Helper()
+	const path = "amd64_raw_compare_float_test.go"
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expected := map[string]string{
+		"TestCrossLinuxRuntimeMatrixX86RawLegacyFloatingCompareRuntime": "8790480bde539b865752ea02cb0759b7346b9ae77c9462aefe33a3c1bedbb687",
+		"x86RawLegacyFloatingCompareOriginalKernel":                     "bdab858ff28514acd7c91f5ec34c41d49ad5e8543076c20406c734ccf9360211",
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		hash, owned := expected[function.Name.Name]
+		if !owned {
+			continue
+		}
+		start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+		if fmt.Sprintf("%x", sha256.Sum256(data[start:end])) != hash {
+			t.Fatal("original complete raw compare ASM/C, full imm8 or MXCSR observations changed", function.Name.Name)
+		}
+		delete(expected, function.Name.Name)
+	}
+	if len(expected) != 0 {
+		t.Fatal("original raw compare runtime or exact-byte kernel disappeared", expected)
+	}
+}
+
+func TestX86RawLegacyFloatingCompareCompleteGoEncoderRows(t *testing.T) {
+	x86RawLegacyFloatCompareOriginalProgramsUnchanged(t)
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	const grammar = "var yxcmpi = []ytab{\n\t{Zm_r_i_xm, 2, argList{Yxm, Yxr, Yi8}},\n}"
+	if !strings.Contains(string(data), grammar) {
+		t.Fatal("complete legacy compare zcase, byte offset or operand classes changed")
+	}
+	for _, row := range []string{
+		"{ACMPPS, yxcmpi, Pm, opBytes{0xc2, 0}},",
+		"{ACMPPD, yxcmpi, Px, opBytes{Pe, 0xc2}},",
+		"{ACMPSS, yxcmpi, Px, opBytes{Pf3, 0xc2}},",
+		"{ACMPSD, yxcmpi, Px, opBytes{Pf2, 0xc2}},",
+	} {
+		if !strings.Contains(string(data), row) {
+			t.Fatal("legacy compare lost an original opcode/refining-prefix row", row)
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareInitializedOriginalProducers(t *testing.T) {
+	x86RawLegacyFloatCompareOriginalProgramsUnchanged(t)
+	for _, row := range x86RawLegacyFloatCompareOracles {
+		for _, memory := range []bool{false, true} {
+			input := "X1"
+			if memory {
+				input = "(BX)"
+			}
+			prefix := "TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),DI\n" +
+				"MOVQ left+8(FP),AX\nMOVQ right+16(FP),BX\nMOVOU (AX),X0\nMOVOU (BX),X1\n"
+			named := prefix + row.op + " " + input + ",X0,$0\nMOVOU X0,(DI)\nRET\n"
+			raw := prefix + x86RawDisplacementDirectives(row.code(memory, 0)) + "MOVOU X0,(DI)\nRET\n"
+			// Retain the discovering runtime's ordinary MOVOU producers and
+			// output. Only the compare spelling changes, never its initialization.
+			goAssemblerOracleOutput(t, "amd64", named+strings.Replace(raw, "·Value", "·RawValue", 1), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/memory=%t/%s", row.op, memory, api), func(t *testing.T) {
+					for _, program := range []struct{ name, source string }{{"named", named}, {"raw", raw}} {
+						ir, err := x86ScalarFPBitViewAPI(t, program.source, "func Value(out,left,right *byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatal("same initialized source lost its paired native compare continuation", program.name, err)
+						}
+						if !strings.Contains(ir, "asm sideeffect \""+strings.ToLower(row.op)+" $$0,") ||
+							!strings.Contains(ir, "~{memory},~{fpsr}") {
+							t.Fatal("original whole comparison or its native exceptions/access effects disappeared", program.name)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareEverySelectorRetainsTypedState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					for selector := 0; selector < 256; selector++ {
+						decoded, err := decodeX86RawDirectives(rawX86Function(row.code(memory, byte(selector))), arch)
+						if err != nil || len(decoded.Instrs) != 1 {
+							t.Fatal("independent complete prefix/opcode/imm8 failed to decode", memory, selector, err)
+						}
+						ins := decoded.Instrs[0]
+						if ins.Op != Op(row.op) || len(ins.Args) != 3 || ins.Args[2].Imm != int64(int8(selector)) || ins.x86SourceRaw == nil {
+							t.Fatal("raw source lost its original signed spelling, full selector or decoder identity", ins)
+						}
+						active := x86CallerVectorByteMask(int64(row.input))
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						bx, _, _ := x86ResultGP("BX", x86ResultPointerWord(arch), arch)
+						state.pointerGP[bx], state.masks[7] = true, true
+						state.writeVector(0, 64, 0xa5a5a5a5a5a5a5a5|active, false)
+						state.writeVector(1, 64, 0x5a5a5a5a5a5a5a5a|active, false)
+						before := state.clone()
+						local := ins
+						local.x86Encoded, local.x86SourceRaw = false, nil
+						control := before.clone()
+						if accepted, known := x86ResultFloatCompareStep(local, &control, nil, arch, true); !known || !accepted {
+							t.Fatal("named full-selector positive control failed before raw continuation", memory, selector)
+						}
+						want := before.clone()
+						want.writeVector(0, 16, before.vectorBytes(0)|active, true)
+						if !reflect.DeepEqual(control, want) {
+							t.Fatal("named comparison changed original scalar passthrough, wider aliases or FLAGS", memory, selector)
+						}
+						if accepted, known := x86ResultFloatCompareStep(ins, &state, nil, arch, true); !known || !accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("exact legacy raw compare did not reuse complete typed inputs and architectural writeback", memory, selector)
+						}
+						standalone := before.clone()
+						if accepted, _ := x86ResultFloatCompareStep(ins, &standalone, nil, arch, false); accepted || !reflect.DeepEqual(standalone, before) {
+							t.Fatal("standalone observer borrowed raw or native continuation authority", memory, selector)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_legacy_float_compare_objects_test.go b/x86_raw_legacy_float_compare_objects_test.go
new file mode 100644
index 000000000..28da859d2
--- /dev/null
+++ b/x86_raw_legacy_float_compare_objects_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawLegacyFloatCompareObjectRow struct {
+	op, source, destination string
+	code                    []byte
+	selector                byte
+	register                bool
+}
+
+func x86RawLegacyFloatCompareObjectRows(arch string) []x86RawLegacyFloatCompareObjectRow {
+	var rows []x86RawLegacyFloatCompareObjectRow
+	for _, oracle := range x86RawLegacyFloatCompareOracles {
+		forms := []struct {
+			source, destination string
+			address             []byte
+			rex                 byte
+			register            bool
+		}{
+			{"X1", "X0", []byte{0xc1}, 0, true},
+			{"X0", "X0", []byte{0xc0}, 0, true},
+			{"(BX)", "X0", []byte{0x03}, 0, false},
+			{"-7(BX)(CX*4)", "X0", []byte{0x44, 0x8b, 0xf9}, 0, false},
+			{"128(BX)(CX*4)", "X0", []byte{0x84, 0x8b, 0x80, 0, 0, 0}, 0, false},
+		}
+		if arch == "amd64" {
+			forms = append(forms, struct {
+				source, destination string
+				address             []byte
+				rex                 byte
+				register            bool
+			}{"X15", "X14", []byte{0xf7}, 0x45, true})
+		}
+		for _, form := range forms {
+			// Immediate exhaustiveness belongs to the orthogonal 256-selector
+			// unit and original runtime, not another object Cartesian product.
+			for _, selector := range []byte{0, 128, 255} {
+				row := x86RawLegacyFloatCompareObjectRow{op: oracle.op, source: form.source,
+					destination: form.destination, selector: selector, register: form.register}
+				if oracle.prefix != 0 {
+					row.code = append(row.code, oracle.prefix)
+				}
+				if form.rex != 0 {
+					row.code = append(row.code, form.rex)
+				}
+				row.code = append(row.code, 0x0f, 0xc2)
+				row.code = append(row.code, form.address...)
+				row.code = append(row.code, selector)
+				rows = append(rows, row)
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawLegacyFloatCompareInitializedObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	x86RawLegacyFloatCompareOriginalProgramsUnchanged(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows, expected, move, word := x86RawLegacyFloatCompareObjectRows(arch), 72, "MOVQ", 8
+	if arch == "386" {
+		expected, move, word = 60, "MOVL", 4
+	}
+	if len(rows) != expected {
+		t.Fatal("complete independent legacy compare object directory changed", len(rows), expected)
+	}
+	for start := 0; start < len(rows); start += 36 {
+		end := start + 36
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%03d", start), func(t *testing.T) {
+			var named, raw, declarations strings.Builder
+			var names []string
+			for index, row := range rows[start:end] {
+				name := fmt.Sprintf("Compare%d", index)
+				names = append(names, name)
+				prefix := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s left+%d(FP),AX\n%s right+%d(FP),BX\nMOVL $2,CX\nMOVOU (AX),%s\n",
+					name, 3*word, move, move, word, move, 2*word, row.destination)
+				if row.register {
+					prefix += "MOVOU (BX)," + row.source + "\n"
+				}
+				suffix := "MOVOU " + row.destination + ",(DI)\nRET\n"
+				named.WriteString(prefix + fmt.Sprintf("%s %s,%s,$%d\n", row.op, row.source, row.destination, int8(row.selector)) + suffix)
+				raw.WriteString(prefix + x86RawDisplacementDirectives(row.code) + suffix)
+				fmt.Fprintf(&declarations, "func %s(out,left,right *byte)\n", name)
+			}
+			for _, spelling := range []struct{ name, source string }{{"named", named.String()}, {"raw", raw.String()}} {
+				t.Run(spelling.name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, triple, spelling.source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, spelling.source, declarations.String(), arch, triple, api)
+							if err != nil {
+								t.Fatal("complete initialized legacy compare source rejected", err)
+							}
+							for _, pipeline := range []struct{ name, text, level string }{
+								{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+								{"IR_O2_backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+							} {
+								t.Run(pipeline.name, func(t *testing.T) {
+									x86CompactExpandRequireAllDefinitions(t, pipeline.text, names)
+									for index, row := range rows[start:end] {
+										_, body, found := strings.Cut(pipeline.text, "define void @"+names[index]+"(")
+										body, _, ended := strings.Cut(body, "\n}")
+										original := fmt.Sprintf("asm sideeffect \"%s $$%d,", strings.ToLower(row.op), row.selector)
+										if !found || !ended || strings.Count(body, original) != 1 || !strings.Contains(body, "~{memory},~{fpsr}") {
+											t.Fatal("actual function lost its original opcode, full immediate or native effect", names[index], row.selector)
+										}
+									}
+									x86PackedStringCompileObject(t, llc, triple, pipeline.text, pipeline.level)
+								})
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawLegacyFloatingCompareInitializedLinuxAMD64Objects(t *testing.T) {
+	x86RawLegacyFloatCompareInitializedObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86RawLegacyFloatingCompareInitializedDarwinAMD64Objects(t *testing.T) {
+	x86RawLegacyFloatCompareInitializedObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86RawLegacyFloatingCompareInitializedWindowsAMD64Objects(t *testing.T) {
+	x86RawLegacyFloatCompareInitializedObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86RawLegacyFloatingCompareInitializedLinux386Objects(t *testing.T) {
+	x86RawLegacyFloatCompareInitializedObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86RawLegacyFloatingCompareInitializedWindows386Objects(t *testing.T) {
+	x86RawLegacyFloatCompareInitializedObjects(t, "386", "i686-pc-windows-msvc")
+}
diff --git a/x86_raw_legacy_float_compare_replay_test.go b/x86_raw_legacy_float_compare_replay_test.go
new file mode 100644
index 000000000..a59762c33
--- /dev/null
+++ b/x86_raw_legacy_float_compare_replay_test.go
@@ -0,0 +1,246 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86LegacyFloatReplaySource(arch string, row x86RawLegacyFloatCompareOracle, memory bool, selector byte, raw bool) (string, string) {
+	word, move, input := goWordSize(arch), "MOVQ", "X1"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	if memory {
+		input = "(BX)"
+	}
+	prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s out+0(FP),DI\n%s left+%d(FP),AX\n%s right+%d(FP),BX\nMOVOU (AX),X0\nMOVOU (BX),X1\n",
+		3*word, move, move, word, move, 2*word)
+	operation := fmt.Sprintf("%s %s,X0,$%d\n", row.op, input, int8(selector))
+	if raw {
+		operation = x86RawDisplacementDirectives(row.code(memory, selector))
+	}
+	return prefix + operation + "MOVOU X0,(DI)\nRET\n", "func Value(out,left,right *byte)"
+}
+
+func x86LegacyFloatReplayConsumer(t *testing.T, arch string) func(Func) error {
+	t.Helper()
+	source, declaration := x86LegacyFloatReplaySource(arch, x86RawLegacyFloatCompareOracles[0], false, 0, false)
+	return x86LegacyFloatReplayCheck(t, arch, source, declaration)
+}
+
+func x86LegacyFloatReplayCheck(t *testing.T, arch, source, declaration string) func(Func) error {
+	t.Helper()
+	pkg := mustGoPackage(t, "comparereplay", "package comparereplay\n"+declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	signatures, err := goSigsForAsmFile(pkg, mustParseX86RawReturn(t, source), resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal("actual original declaration/FP-layout prerequisite", err)
+	}
+	sig, found := signatures["Value"]
+	if !found {
+		t.Fatal("actual original compare declaration disappeared")
+	}
+	return func(function Func) error {
+		consumer := amd64Ctx{fpScalarSource: function, sig: sig, fpSourceSig: sig,
+			goarch: arch, targetTriple: x86AddressMemoryTargets(arch)[0]}
+		return consumer.checkLoweredScalarFPResultInitialization()
+	}
+}
+
+func x86LegacyFloatReplayOriginal(t *testing.T, arch, source string) (Func, int) {
+	t.Helper()
+	file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+	if err != nil {
+		t.Fatal("original complete compare decoding prerequisite", err)
+	}
+	function, ordinal := file.Funcs[0], -1
+	for index, ins := range function.Instrs {
+		if x86RawLegacyFloatCompareSource(ins, arch) {
+			if ordinal >= 0 {
+				t.Fatal("ambiguous original raw compare instruction")
+			}
+			ordinal = index
+		}
+	}
+	if ordinal < 0 || function.x86RawReplay == nil || function.x86RawReplay.validate(function, arch) != nil {
+		t.Fatal("complete original source lost its immutable compare replay")
+	}
+	return function, ordinal
+}
+
+func TestX86RawLegacyFloatingCompareReplayCompleteOriginalGoBytes(t *testing.T) {
+	x86RawLegacyFloatCompareOriginalProgramsUnchanged(t)
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			var expected []byte
+			for _, row := range x86RawLegacyFloatCompareOracles {
+				for _, memory := range []bool{false, true} {
+					input := "X1"
+					if memory {
+						input = "(BX)"
+					}
+					for selector := 0; selector < 256; selector++ {
+						fmt.Fprintf(&source, "%s %s,X0,$%d\n", row.op, input, int8(selector))
+						expected = append(expected, row.code(memory, byte(selector))...)
+					}
+				}
+			}
+			actual, pcs := x86NumericalBoundaryGoBytes(t, arch, source.String()+"RET")
+			expected = append(expected, 0xc3)
+			if len(pcs) != 2049 || !bytes.Equal(actual, expected) {
+				t.Fatal("actual Go bytes differ from the independent four-prefix/all256-selector register/memory table", len(pcs))
+			}
+		})
+	}
+}
+
+func TestX86RawLegacyFloatingCompareOriginOnlyDirectNamedControl(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				for _, memory := range []bool{false, true} {
+					for selector := 0; selector < 256; selector++ {
+						original := x86RawMoveObservedInstruction(t, arch, row.code(memory, byte(selector)))
+						if original.x86Encoded || original.x86SourceRaw == nil {
+							t.Fatal("legacy decoder generation prerequisite changed")
+						}
+						changed := cloneX86ReplayInstrs([]Instr{original})[0]
+						changed.x86SourceRaw = nil
+						if x86RawLegacyFloatCompareSource(changed, arch) || !x86ResultNamedPredicateInstruction(changed) {
+							t.Fatal("an erased raw origin is not a raw witness and can have the named instruction contract")
+						}
+						named := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s,X0,$%d", row.op, changed.Args[0], int8(selector)))
+						state, control := x86RawLegacyFloatCompareState(), x86RawLegacyFloatCompareState()
+						accepted, known := x86ResultFloatCompareStep(changed, &state, nil, arch, true)
+						valid, recognized := x86ResultFloatCompareStep(named, &control, nil, arch, true)
+						if !accepted || !known || !valid || !recognized || !reflect.DeepEqual(state, control) {
+							t.Fatal("direct origin-only mutation must not be mislabeled a missing-input rejection or forbid legal named instructions", memory, selector)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareOriginOnlyWholeReplayAllSelectors(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		check := x86LegacyFloatReplayConsumer(t, arch)
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			for _, memory := range []bool{false, true} {
+				for selector := 0; selector < 256; selector++ {
+					t.Run(fmt.Sprintf("%s/%s/memory=%t/selector=%03d", arch, row.op, memory, selector), func(t *testing.T) {
+						source, _ := x86LegacyFloatReplaySource(arch, row, memory, byte(selector), true)
+						function, ordinal := x86LegacyFloatReplayOriginal(t, arch, source)
+						if err := check(function); err != nil {
+							t.Fatal("valid initialized original source failed before any identity mutation", err)
+						}
+						namedSource, _ := x86LegacyFloatReplaySource(arch, row, memory, byte(selector), false)
+						named := mustParseX86RawReturn(t, namedSource).Funcs[0]
+						if named.x86RawReplay != nil || check(named) != nil {
+							t.Fatal("ordinary complete named source control must retain its original domain")
+						}
+						changed := function
+						changed.Instrs = cloneX86ReplayInstrs(function.Instrs)
+						changed.Instrs[ordinal].x86SourceRaw = nil // Do not also change generation.
+						if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual whole-Func consumer accepted an erased immutable original compare origin", err)
+						}
+						if function.x86RawReplay.validate(function, arch) != nil {
+							t.Fatal("mutating a clone corrupted its independently retained original source")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareOriginalReplayConsumerMutationBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		check := x86LegacyFloatReplayConsumer(t, arch)
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			for _, memory := range []bool{false, true} {
+				for _, selector := range []byte{0, 128, 255} {
+					source, _ := x86LegacyFloatReplaySource(arch, row, memory, selector, true)
+					function, ordinal := x86LegacyFloatReplayOriginal(t, arch, source)
+					for _, mutation := range []string{"none", "origin", "origin-and-selector", "origin-and-opcode", "origin-and-producer", "origin-and-spelling",
+						"missing-replay", "source-spelling", "original-bytes", "decoded-snapshot", "normalized-snapshot", "header", "generation", "snapshot", "address-width", "numerical-read"} {
+						t.Run(fmt.Sprintf("%s/%s/memory=%t/selector=%03d/%s", arch, row.op, memory, selector, mutation), func(t *testing.T) {
+							candidate := function
+							candidate.Instrs = cloneX86ReplayInstrs(function.Instrs)
+							ins := &candidate.Instrs[ordinal]
+							if mutation == "origin" || strings.HasPrefix(mutation, "origin-and-") {
+								ins.x86SourceRaw = nil
+							}
+							switch mutation {
+							case "origin-and-selector":
+								ins.Args[2].Imm = int64(int8(ins.Args[2].Imm + 1))
+							case "origin-and-opcode":
+								ins.Op = "CMPPS"
+								if row.op == "CMPPS" {
+									ins.Op = "CMPPD"
+								}
+							case "origin-and-producer":
+								candidate.Instrs[ordinal-1].Op = "VMOVDQU"
+							case "origin-and-spelling", "source-spelling":
+								ins.Raw += " changed"
+							case "missing-replay":
+								candidate.x86RawReplay = nil
+							case "original-bytes":
+								replay := *function.x86RawReplay
+								replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+								candidate.x86RawReplay = &replay
+							case "decoded-snapshot", "normalized-snapshot":
+								replay := *function.x86RawReplay
+								if mutation == "decoded-snapshot" {
+									replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+									replay.decoded[ordinal].x86SourceRaw = nil
+								} else {
+									replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+									replay.normalized[ordinal].x86SourceRaw = nil
+								}
+								candidate.x86RawReplay = &replay
+							case "header":
+								candidate.ArgSize += int64(goWordSize(arch))
+							case "generation":
+								ins.x86Encoded = true
+							case "snapshot":
+								ins.x86SourceRaw.legacyFloatCompare = x86RawLegacyFloatCompareIdentity{}
+							case "address-width":
+								ins.x86AddressBits = 16
+							case "numerical-read":
+								ins.x86NumericalRead = new(x86NumericalReadCertificate)
+							}
+							err := check(candidate)
+							if mutation == "none" && err != nil || mutation != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("actual original-source consumer lost its bounded complete replay contract", mutation, err)
+							}
+							if function.x86RawReplay.validate(function, arch) != nil {
+								t.Fatal("a private clone mutation changed the retained original source")
+							}
+						})
+					}
+					for _, spelling := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%s/memory=%t/selector=%03d/raw=%t/missing-input", arch, row.op, memory, selector, spelling), func(t *testing.T) {
+							original, _ := x86LegacyFloatReplaySource(arch, row, memory, selector, spelling)
+							missing := strings.Replace(original, "MOVOU (AX),X0\n", "", 1)
+							function := mustParseX86RawReturn(t, missing).Funcs[0]
+							if spelling {
+								function, _ = x86LegacyFloatReplayOriginal(t, arch, missing)
+							}
+							if err := check(function); !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("an original replay or named spelling manufactured missing input bytes", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_literal_result.go b/x86_raw_literal_result.go
new file mode 100644
index 000000000..6db94e35e
--- /dev/null
+++ b/x86_raw_literal_result.go
@@ -0,0 +1,209 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// A source shape alone supplies no input permission. The typed family, complete
+// source replay and independent raw-return/DATA consumer remain mandatory.
+func x86RawLiteralSourceShape(ins Instr, arch string) bool {
+	return arch == "amd64" && ins.x86Encoded && ins.x86RIPLiteral &&
+		ins.x86SourceRaw != nil && ins.x86RawNearReturn == nil && ins.x86AddressBits == 0 &&
+		!ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0
+}
+
+// Raw replay keeps decoder operands before the normalizer allocates a module
+// DATA symbol. Bind that single private relocation without rewriting the
+// immutable decoder checkpoint or accepting another changed source operand.
+func x86RawLiteralSourceIdentity(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	origin, read := ins.x86SourceRaw, ins.x86RIPMemoryRead
+	if origin.op != ins.Op || len(origin.args) != len(ins.Args) ||
+		origin.vectorBytes != ins.x86VectorBytes || origin.addressBits != ins.x86AddressBits {
+		return false
+	}
+	for index, operand := range origin.args {
+		if index == read.source {
+			pending := Operand{Kind: OpSym, Sym: "·__plan9asm_raw_literal_pending(SB)"}
+			if !reflect.DeepEqual(operand, pending) {
+				return false
+			}
+		} else if !reflect.DeepEqual(operand, ins.Args[index]) {
+			return false
+		}
+	}
+	return true
+}
+
+// RIP constants are a decoder role, never a named-immediate broadcast form.
+func x86RawBroadcastLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) {
+		return false
+	}
+	form, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false
+	}
+	if ins.Args[0].Kind == OpImm {
+		return ins.x86SourceRaw.op == ins.Op && reflect.DeepEqual(ins.x86SourceRaw.args, ins.Args) &&
+			(form.kind == x86BroadcastInteger || form.kind == x86BroadcastFloat)
+	}
+	return form.kind == x86BroadcastBlock && x86RawReturnDecodedReadIdentity(ins) &&
+		ins.x86RIPMemoryRead.source == 0 && ins.x86RIPMemoryRead.width == int64(form.sourceBytes)
+}
+
+func x86RawLogicalLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	form, known, err := x86PackedLogicalProperties(ins, arch)
+	return known && err == nil && !form.legacy && !form.mmx && form.memory >= 0 &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86RawByteShiftLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) ||
+		!x86RawPackedShiftEncodingSource(ins, arch) {
+		return false
+	}
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	return known && err == nil && form.countMode == x86PackedShiftBytes &&
+		!form.legacy && !form.mmx && form.memory == form.data &&
+		ins.x86RIPMemoryRead.source == form.data && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86RawIntegerCompareLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.legacy && !form.mmx && form.memory >= 0 &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86RawArithmeticLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	parsed, known, err := x86PackedArithmeticProperties(ins.Op, ins, arch, x86PackedArithmeticAdd|x86PackedArithmeticSubtract)
+	form := parsed.x86PackedBinaryForm
+	return known && err == nil && !form.legacy && !form.mmx && form.memory >= 0 &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86RawFloatCompareLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	form, known, err := x86FloatCompareProperties(ins, arch)
+	return known && err == nil && !form.legacy && form.memory >= 0 &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+// A scalar flag comparison consumes only the exact decoder-owned literal.
+// Its physical generation and scalar width do not grant a native pointer role.
+func x86RawCOMILiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceIdentity(ins, arch) {
+		return false
+	}
+	form, known, err := x86COMIProperties(ins, arch)
+	return known && err == nil && form.spec.vector && ins.Args[0].Kind == OpSym &&
+		ins.x86SourceRaw.comi.arch == arch && ins.x86SourceRaw.comi == x86COMIRawIdentity(ins, arch) &&
+		ins.x86RIPMemoryRead.source == 0 && ins.x86RIPMemoryRead.width == int64(form.spec.bits/8)
+}
+
+// Scalar SQRT and packed/scalar binary arithmetic share an exact decoded first
+// operand, not native-address authority. MIN/MAX keeps its distinct controls
+// and physical generation; FP16, packed SQRT and legacy remain separate roles.
+func x86RawBinaryFloatLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceIdentity(ins, arch) {
+		return false
+	}
+	f, known, err := x86SqrtProperties(ins, arch)
+	if known && (!f.scalar || f.bits != 32 && f.bits != 64) {
+		return false
+	}
+	if !known {
+		addsub, recognized, parseErr := x86FloatAddSubProperties(ins, arch)
+		f, known, err = addsub.x86FloatBinaryForm, recognized, parseErr
+	}
+	if !known {
+		muldiv, recognized, parseErr := x86FloatMulDivProperties(ins, arch)
+		f, known, err = muldiv.x86FloatBinaryForm, recognized, parseErr
+	}
+	if !known {
+		minmax, recognized, parseErr := x86FloatMinMaxProperties(ins, arch)
+		f, known, err = minmax.x86FloatBinaryForm, recognized, parseErr
+		if known && !x86RawFloatMinMaxEncodingSource(ins, arch) {
+			return false
+		}
+	}
+	return known && err == nil && !f.legacy && f.memory == f.first &&
+		ins.x86RIPMemoryRead.source == f.first && ins.x86RIPMemoryRead.width == int64(f.memoryBytes)
+}
+
+func x86RawResultLiteralForm(ins Instr, arch string) bool {
+	return x86RawVectorMoveLiteralSource(ins, arch) || x86RawIntegerMinMaxLiteralForm(ins, arch) ||
+		x86RawTernaryLogicLiteralForm(ins, arch) ||
+		x86RawBroadcastLiteralForm(ins, arch) || x86RawLogicalLiteralForm(ins, arch) ||
+		x86RawByteShiftLiteralForm(ins, arch) || x86RawIntegerCompareLiteralForm(ins, arch) ||
+		x86RawArithmeticLiteralForm(ins, arch) || x86RawFloatCompareLiteralForm(ins, arch) ||
+		x86RawBinaryFloatLiteralForm(ins, arch) || x86RawFMA3LiteralForm(ins, arch) ||
+		x86RawPackedAbsLiteralForm(ins, arch) || x86RawCOMILiteralForm(ins, arch) || x86RawRoundLiteralForm(ins, arch)
+}
+
+// This bounded source uses the ordinary typed family byte effects. It does
+// not join the conditional native-read route or waive raw RET's separately
+// checked frame, memory and continuation contracts. Other raw families retain
+// their own consumers. Declaration-only queries acquire no literal permission.
+func (c *amd64Ctx) checkRawLiteralResults() (bool, error) {
+	fn, arch := c.fpScalarSource, c.goarch
+	selected := false
+	for _, ins := range fn.Instrs {
+		selected = selected || x86RawResultLiteralForm(ins, arch)
+	}
+	if !selected {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, fmt.Errorf("%w: raw literal requires its complete source and independent return contract", ErrProbeNeedsContext)
+	}
+	if fn.FrameSize != 0 || len(fn.X86RawText) != 0 || fn.x86SourceStack != nil ||
+		fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil ||
+		fn.x86BoolCalls != nil || fn.x86RawReplay == nil {
+		return fail()
+	}
+	if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+		return true, err
+	}
+	hasReturn := false
+	for _, ins := range fn.Instrs {
+		if form := ins.x86RawNearReturn; form != nil {
+			if ins.Op != OpRET || !form.nativeWidth || form.cleanup != 0 {
+				return fail()
+			}
+			hasReturn = true
+		} else if !x86RawResultLiteralForm(ins, arch) && !x86ResultNamedPredicateInstruction(ins) {
+			return fail()
+		}
+	}
+	if !hasReturn {
+		return fail()
+	}
+	transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		state.loweredStaticReads = c.fpScalarData
+		defer func() { state.loweredStaticReads = nil }()
+		if accepted, known := x86ResultRawVectorMoveLiteralStep(ins, state, owned, resultOffset, arch); known {
+			return accepted
+		}
+		if x86RawBroadcastLiteralForm(ins, arch) {
+			accepted, _ := x86ResultBroadcastInputs(ins, state, owned, arch, false, true)
+			return accepted
+		}
+		return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch)
+	}
+	return true, checkX86ABI0ResultInitializationAtSource(fn, c.sig, arch, transfer, true)
+}
diff --git a/x86_raw_logical_result_test.go b/x86_raw_logical_result_test.go
new file mode 100644
index 000000000..72a48cbcf
--- /dev/null
+++ b/x86_raw_logical_result_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Go _yvandnpd/_yvaddsubpd/_yvblendmpd witnesses: twelve VEX
+// names, sixteen EVEX names, every vector width, mask role and memory tuple.
+// No production spec supplies this directory or its expected cardinality.
+func x86RawLogicalResultCases() []x86RawVectorLiteralCase {
+	var rows []x86RawVectorLiteralCase
+	for _, operation := range []struct {
+		opcode byte
+		stem   string
+	}{{0x54, "VAND"}, {0x55, "VANDN"}, {0x56, "VOR"}, {0x57, "VXOR"}} {
+		for pp, suffix := range []string{"PS", "PD"} {
+			for _, width := range []int{16, 32} {
+				for _, vex3 := range []bool{false, true} {
+					rows = append(rows, x86RawVectorLiteralCase{
+						name: fmt.Sprintf("%s%sVEX%d_%t", operation.stem, suffix, width, vex3),
+						code: x86RawFloatLogicalLiteral(operation.opcode, byte(pp), vex3, width),
+					})
+				}
+			}
+			for _, width := range []int{16, 32, 64} {
+				for _, mask := range []int{0, 3, 7} {
+					for _, broadcast := range []bool{false, true} {
+						rows = append(rows, x86RawVectorLiteralCase{
+							name: fmt.Sprintf("%s%sEVEX%d_%d_%t", operation.stem, suffix, width, mask, broadcast),
+							code: x86RawEVEXFloatLogicalLiteral(operation.opcode, byte(pp), width, mask, mask == 7, broadcast),
+							mask: mask,
+						})
+					}
+				}
+			}
+		}
+	}
+	for _, op := range []Op{"VPAND", "VPANDN", "VPOR", "VPXOR"} {
+		for _, width := range []int{16, 32} {
+			for _, vex3 := range []bool{false, true} {
+				code := x86RawPackedLogicalLiteral(op, false, width, 0, false, false)
+				if !vex3 {
+					code = append([]byte{0xc5, code[2] | 0x80}, code[3:]...)
+				}
+				rows = append(rows, x86RawVectorLiteralCase{
+					name: fmt.Sprintf("%sVEX%d_%t", op, width, vex3), code: code,
+				})
+			}
+		}
+	}
+	for _, op := range []Op{"VPANDD", "VPANDQ", "VPANDND", "VPANDNQ", "VPORD", "VPORQ", "VPXORD", "VPXORQ"} {
+		for _, width := range []int{16, 32, 64} {
+			for _, mask := range []int{0, 3, 7} {
+				for _, broadcast := range []bool{false, true} {
+					rows = append(rows, x86RawVectorLiteralCase{
+						name: fmt.Sprintf("%sEVEX%d_%d_%t", op, width, mask, broadcast),
+						code: x86RawPackedLogicalLiteral(op, true, width, mask, mask == 7, broadcast),
+						mask: mask,
+					})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86RawLogicalLiteralObjects(t *testing.T, triple string) {
+	t.Helper()
+	rows := x86RawLogicalResultCases()
+	if len(rows) != 336 {
+		t.Fatal("complete independent logical literal directory changed", len(rows))
+	}
+	x86RawVectorLiteralObjects(t, triple, rows)
+}
+
+func TestX86RawLogicalLiteralCompleteLinuxObjects(t *testing.T) {
+	x86RawLogicalLiteralObjects(t, "x86_64-unknown-linux-gnu")
+}
+
+func TestX86RawLogicalLiteralCompleteDarwinObjects(t *testing.T) {
+	x86RawLogicalLiteralObjects(t, "x86_64-apple-darwin")
+}
+
+func TestX86RawLogicalLiteralCompleteWindowsObjects(t *testing.T) {
+	x86RawLogicalLiteralObjects(t, "x86_64-pc-windows-msvc")
+}
+
+func TestX86RawLogicalLiteralKeepsIndependentInputsAndSource(t *testing.T) {
+	for _, row := range x86RawLogicalResultCases() {
+		source := x86RawVectorLiteralSource(row)
+		declaration := "func " + row.name + "()"
+		variants := []string{
+			strings.Replace(source, "$0-0", "$16-0", 1),
+			strings.Replace(source, "MOVL $5,AX", "MOVQ $0,SP\nMOVL $5,AX", 1),
+		}
+		if row.mask != 0 {
+			variants = append(variants, strings.NewReplacer("KMOVD AX,K3\n", "", "KMOVD AX,K7\n", "").Replace(source))
+		}
+		for _, changed := range variants {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("literal borrowed a missing mask or raw-return frame", row.name, api, err)
+				}
+			}
+		}
+		for _, change := range []string{"operand", "DATA"} {
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), "amd64")
+			if err != nil || len(file.Data) != 1 {
+				t.Fatal("original literal source lost its exact DATA", row.name, err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], FuncSig{Name: row.name, Ret: Void}, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("declaration-only query acquired lowering DATA", row.name, err)
+			}
+			if change == "DATA" {
+				file.Data[0].Payload[0] ^= 1
+			} else {
+				for index := range file.Funcs[0].Instrs {
+					instruction := &file.Funcs[0].Instrs[index]
+					if instruction.x86RIPLiteral {
+						instruction.Args[0].Sym += "changed"
+						break
+					}
+				}
+			}
+			options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu",
+				Sigs:       map[string]FuncSig{row.name: {Name: row.name, Ret: Void}},
+				ResolveSym: func(name string) string { return strings.TrimPrefix(name, "·") }}
+			if ir, err := Translate(file, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed source borrowed original literal identity", row.name, change, err)
+			}
+		}
+	}
+}
+
+func TestX86RawLogicalLiteralUsesExactTypedByteEffects(t *testing.T) {
+	for _, row := range x86RawLogicalResultCases() {
+		file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86RawVectorLiteralSource(row)), "amd64")
+		if err != nil {
+			t.Fatal(row.name, err)
+		}
+		for _, instruction := range file.Funcs[0].Instrs {
+			if !instruction.x86RIPLiteral {
+				continue
+			}
+			form, known, err := x86PackedLogicalProperties(instruction, "amd64")
+			if !known || err != nil || !x86RawLogicalLiteralForm(instruction, "amd64") ||
+				x86RawLogicalLiteralForm(instruction, "386") {
+				t.Fatal("literal lost its typed mode64 tuple", row.name, err)
+			}
+			address, valid := x86StaticSBReadAddress(form.source, "amd64")
+			if !valid {
+				t.Fatal("literal has no static DATA identity", row.name)
+			}
+			second, _ := amd64VectorRegisterIndex(instruction.Args[form.second].Reg, form.byteWidth)
+			destination, _ := amd64VectorRegisterIndex(instruction.Args[form.destination].Reg, form.byteWidth)
+			wantDestination := 0
+			if !strings.HasPrefix(row.name, "VP") {
+				wantDestination = 1
+				if strings.Contains(row.name, "EVEX") {
+					wantDestination = 2
+				}
+			}
+			if destination != wantDestination {
+				t.Fatal("independent bytes changed the physical destination", row.name, destination)
+			}
+			for missing := -1; missing < form.byteWidth; missing++ {
+				state := x86ResultState{flags: 0x3f,
+					loweredStaticReads: map[x86StaticSBAddress]int64{address: int64(form.memoryBytes)}}
+				state.masks[3], state.masks[7] = true, true
+				for index := range state.xmm {
+					state.writeVector(index, 64, ^uint64(0), false)
+				}
+				want := ^uint64(0)
+				if missing >= 0 {
+					want &^= uint64(1) << uint(missing)
+					state.writeVector(second, 64, want, false)
+				}
+				if !x86ScalarFPLogicalTransfer(instruction, form, &state, nil, "amd64") ||
+					state.vectorBytes(destination) != want || state.flags != 0x3f {
+					t.Fatal("literal invented a source byte or changed FLAGS", row.name, missing)
+				}
+				state.loweredStaticReads[address]--
+				if x86ScalarFPLogicalTransfer(instruction, form, &state, nil, "amd64") {
+					t.Fatal("literal accepted a shortened full/broadcast tuple", row.name)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_logical_scalar_result.go b/x86_raw_logical_scalar_result.go
new file mode 100644
index 000000000..7d391a7ba
--- /dev/null
+++ b/x86_raw_logical_scalar_result.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import "fmt"
+
+// A decoded native-width, zero-cleanup RET may compose with the existing
+// mode32 logical AX result. This lowering-only consumer checks the complete
+// original replay and a stack-unobserving register-only leaf first. It does
+// not give declaration queries, other raw instructions or memory a new role.
+func (c *amd64Ctx) checkRawLogicalScalarResult() (bool, error) {
+	fn, sig, arch := c.fpScalarSource, c.sig, c.goarch
+	selected := false
+	for _, ins := range fn.Instrs {
+		selected = selected || ins.x86RawNearReturn != nil
+	}
+	if !selected || !x86LogicalScalarResultNeedsProof(sig, arch) {
+		return false, nil
+	}
+	fail := func() (bool, error) {
+		return true, fmt.Errorf("%w: logical scalar raw return needs its complete register-only source and independent return contract", ErrProbeNeedsContext)
+	}
+	if fn.x86RawReplay == nil || fn.x86ContinuationFlow != nil ||
+		!x86RawReturnLeafStackUnobserved(fn) {
+		return fail()
+	}
+	if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+		return true, err
+	}
+	view := fn
+	view.Instrs = append([]Instr(nil), fn.Instrs...)
+	for index, ins := range fn.Instrs {
+		if form := ins.x86RawNearReturn; form != nil {
+			if ins.Op != OpRET || len(ins.Args) != 0 || !form.nativeWidth || form.cleanup != 0 ||
+				ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+				return fail()
+			}
+			// Local numerical dispatch only: neither sealed source snapshot
+			// is changed, and the independent native return guard still runs.
+			view.Instrs[index].x86Encoded = false
+			view.Instrs[index].x86SourceRaw = nil
+			view.Instrs[index].x86RawNearReturn = nil
+			continue
+		}
+		if !x86ResultNamedPredicateInstruction(ins) || isX86RawDirective(ins) {
+			return fail()
+		}
+		for _, operand := range ins.Args {
+			switch operand.Kind {
+			case OpMem, OpFP, OpFPAddr:
+				return fail()
+			case OpSym:
+				if ins.Op != OpTEXT && ins.Op != OpLABEL {
+					return fail()
+				}
+			}
+		}
+	}
+	transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+		return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+	}
+	return true, checkX86LogicalRegisterResultInitialization(view, sig, arch, transfer, false, false)
+}
diff --git a/x86_raw_logical_scalar_return_test.go b/x86_raw_logical_scalar_return_test.go
new file mode 100644
index 000000000..8810dd24e
--- /dev/null
+++ b/x86_raw_logical_scalar_return_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86Mode32LogicalScalarResultsComposeWithBoundZeroCleanupReturn(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, result := range []struct {
+			typ  LLVMType
+			move string
+		}{{I8, "MOVB $17,AX"}, {I16, "MOVW $4660,AX"}, {I32, "MOVL $2309737967,AX"}} {
+			for index, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+				t.Run(fmt.Sprintf("%s/%s/%d", target.triple, result.typ, index), func(t *testing.T) {
+					source := "TEXT value(SB),4,$0-0\n" + result.move + "\n" + encoding + "\nRET\n"
+					requireX86GoAssemblerResult(t, target.arch, source, true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					sig := FuncSig{Name: "value", Ret: result.typ}
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone declaration query borrowed a raw return contract", err)
+					}
+					for _, api := range []string{"text", "module"} {
+						t.Run(api, func(t *testing.T) {
+							options := Options{Goarch: target.arch, TargetTriple: target.triple,
+								Sigs: map[string]FuncSig{"value": sig}}
+							var ir string
+							if api == "text" {
+								ir, err = Translate(file, options)
+							} else {
+								context := llvm.NewContext()
+								defer context.Dispose()
+								module, moduleErr := TranslateModuleInContext(context, file, options)
+								err = moduleErr
+								if !module.IsNil() {
+									defer module.Dispose()
+									ir = module.String()
+								}
+							}
+							if err != nil || ir == "" {
+								t.Fatal("complete original zero-cleanup leaf lost its logical AX result", err)
+							}
+							for _, optimized := range []bool{false, true} {
+								text := ir
+								if optimized {
+									text = x86DwordProductIROptimize(t, text)
+								}
+								compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "raw-logical-return.ll", "raw-logical-return.o", text)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Mode32RawLogicalReturnRetainsExactReplayAndSource(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\nMOVL $17,AX\nBYTE $0xc3\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err = NormalizeRawFileForTranslation(file, "386")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, mutate := range map[string]func(*Func){
+		"unchanged":            func(*Func) {},
+		"missing-replay":       func(fn *Func) { fn.x86RawReplay = nil },
+		"changed-move":         func(fn *Func) { fn.Instrs[1].Args[0].Imm++ },
+		"changed-raw-spelling": func(fn *Func) { fn.Instrs[2].Raw += " changed" },
+		"changed-return-width": func(fn *Func) { fn.Instrs[2].x86RawNearReturn.nativeWidth = false },
+		"changed-cleanup":      func(fn *Func) { fn.Instrs[2].x86RawNearReturn.cleanup = 4 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+			mutate(&fn)
+			before := cloneX86ReplayInstrs(fn.Instrs)
+			context := amd64Ctx{goarch: "386", fpScalarSource: fn, sig: FuncSig{Name: "value", Ret: I32}}
+			selected, err := context.checkRawLogicalScalarResult()
+			if !selected || (name == "unchanged" && err != nil) ||
+				(name != "unchanged" && !errors.Is(err, ErrProbeNeedsContext)) {
+				t.Fatal("raw return acquired a changed or incomplete source role", selected, err)
+			}
+			if !reflect.DeepEqual(before, fn.Instrs) {
+				t.Fatal("logical result consumer edited the sealed original source")
+			}
+		})
+	}
+}
+
+func TestX86Mode32RawLogicalReturnsCannotSupplyMissingBytesOrPhysicalEntry(t *testing.T) {
+	for _, source := range []string{
+		"TEXT value(SB),4,$0-0\nBYTE $0xc3\nRET\n",
+		"TEXT value(SB),4,$0-0\nMOVB $17,AX\nBYTE $0xc3\nRET\n",
+		"TEXT value(SB),4,$0-0\nMOVL SP,BX\nMOVL $17,AX\nBYTE $0xc3\nRET\n",
+		"TEXT value(SB),4,$8-0\nMOVL $17,AX\nBYTE $0xc3\nRET\n",
+		"TEXT value(SB),4,$0-0\nMOVL $17,AX\nBYTE $0xc2\nWORD $4\nRET\n",
+	} {
+		requireX86GoAssemblerResult(t, "386", source, true)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ir, err := Translate(file, Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu",
+			Sigs: map[string]FuncSig{"value": {Name: "value", Ret: I32}}})
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("raw RET supplied missing data, stack or entry authority", strings.ReplaceAll(source, "\n", ";"), err)
+		}
+	}
+}
diff --git a/x86_raw_mask_compare_boundaries_test.go b/x86_raw_mask_compare_boundaries_test.go
new file mode 100644
index 000000000..48cc94fe2
--- /dev/null
+++ b/x86_raw_mask_compare_boundaries_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawMaskCompareMissingInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, name := range []string{"VPCMPB", "VPCMPW", "VPCMPD", "VPCMPQ", "VPCMPUB", "VPCMPUW", "VPCMPUD", "VPCMPUQ"} {
+			for _, operand := range []string{"X3", "(SI)"} {
+				bytes := x86RawNumericalInstruction(t, "amd64", name+" $6,"+operand+",X4,K1,K2")
+				source := "TEXT ·Value(SB),4,$0\n" + bytes + "RET\n"
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw compare acquired missing data/mask/native address through a dead result", target, name, operand, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawMaskCompareSelectorAndNativeAuthorityStayBound(t *testing.T) {
+	bytes := x86RawNumericalInstruction(t, "amd64", "VPCMPUD.BCST $6,(SI),X4,K1,K2")
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+bytes+"RET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err = normalizeX86RawFile(file, arch)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionEither}
+		state.pointerGP[6], state.masks[1] = true, true
+		state.writeVector(4, 64, ^uint64(0), false)
+		before := state.clone()
+		if accepted, known := x86ResultVectorCompareStepWithRead(ins, &state, nil, arch, false); !known || accepted || !reflect.DeepEqual(state, before) {
+			t.Fatal("standalone compare query borrowed the paired native read", arch)
+		}
+		want := before.clone()
+		want.masks[2] = true
+		if accepted, known := x86LoweredImmediatePackedCompareStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, want) {
+			t.Fatal("paired raw compare changed independent flags/pointer/vector facts", arch)
+		}
+		for _, mutate := range []func(*Instr){
+			func(ins *Instr) { ins.Args[0].Imm = 7 },
+			func(ins *Instr) { ins.Args[1].Mem.Base = DI },
+			func(ins *Instr) { ins.Op = "VPCMPD.BCST" },
+			func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+		} {
+			changed := ins
+			changed.Args = append([]Operand(nil), ins.Args...)
+			mutate(&changed)
+			state = before.clone()
+			if accepted, known := x86LoweredImmediatePackedCompareStep(changed, &state, nil, arch); !known || accepted || !reflect.DeepEqual(state, before) {
+				t.Fatal("changed raw selector/operand/encoding acquired a numerical continuation", arch, changed.Raw)
+			}
+		}
+	}
+}
diff --git a/x86_raw_mask_compare_input_test.go b/x86_raw_mask_compare_input_test.go
new file mode 100644
index 000000000..000648325
--- /dev/null
+++ b/x86_raw_mask_compare_input_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawMaskCompareCompleteInputObjects(t *testing.T, bank string) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, name := range []string{"VPCMPB", "VPCMPW", "VPCMPD", "VPCMPQ", "VPCMPUB", "VPCMPUW", "VPCMPUD", "VPCMPUQ"} {
+				for _, masked := range []bool{false, true} {
+					inputs := []string{bank + "3", "(AX)"}
+					if strings.HasSuffix(name, "D") || strings.HasSuffix(name, "Q") {
+						inputs = append(inputs, "broadcast")
+					}
+					for _, input := range inputs {
+						op, mask, operand := name, "", input
+						if input == "broadcast" {
+							op, operand = op+".BCST", "(AX)"
+						}
+						if masked {
+							mask = "K1,"
+						}
+						row := op + " $6," + operand + "," + bank + "4," + mask + "K2"
+						// The original Go encoder supplies every byte. Low-register
+						// physical mode32 rows are not its named arity limit.
+						bytes := x86RawNumericalInstruction(t, "amd64", row)
+						function := fmt.Sprint("RawCompare", count)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n"+
+							"MOV%s a+%d(FP),AX\nMOV%s b+%d(FP),BX\n"+
+							"VMOVUPS (AX),Z3\nVMOVUPS (BX),Z4\nMOVL $-1431655766,CX\nKMOVD CX,K1\n"+
+							"PUSH%s $0\nPOPF%s\n%s\nKMOVQ K2,(DI)\nPUSHF%s\nPOP%s CX\nMOV%s CX,64(DI)\nRET\n",
+							function, 3*word, suffix, suffix, word, suffix, 2*word, suffix, suffix, bytes, suffix, suffix, suffix)
+						fmt.Fprintf(&declarations, "func %s(out *[80]byte,a,b *[64]byte)\n", function)
+						count++
+					}
+				}
+			}
+			if count != 40 {
+				t.Fatal("complete raw compare input/broadcast/mask denominator changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86RawMaskCompareCompleteXInputObjects(t *testing.T) {
+	x86RawMaskCompareCompleteInputObjects(t, "X")
+}
+func TestX86RawMaskCompareCompleteYInputObjects(t *testing.T) {
+	x86RawMaskCompareCompleteInputObjects(t, "Y")
+}
+func TestX86RawMaskCompareCompleteZInputObjects(t *testing.T) {
+	x86RawMaskCompareCompleteInputObjects(t, "Z")
+}
diff --git a/x86_raw_move_literal_inputs_test.go b/x86_raw_move_literal_inputs_test.go
new file mode 100644
index 000000000..77e0ee5a8
--- /dev/null
+++ b/x86_raw_move_literal_inputs_test.go
@@ -0,0 +1,162 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RawMoveLiteralInputCases() []x86RawMoveOriginCase {
+	var rows []x86RawMoveOriginCase
+	for _, row := range x86RawMoveOriginCases() {
+		if row.role != "load" {
+			continue
+		}
+		aligned := false
+		for _, spec := range x86PackedMoveResultOracle {
+			aligned = aligned || spec.aligned && strings.HasPrefix(row.row, spec.name+" ") ||
+				spec.aligned && strings.HasPrefix(row.row, spec.name+".")
+		}
+		if !aligned {
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86RawMoveLiteralInputBytes(t *testing.T, rows []x86RawMoveOriginCase) ([][]byte, [][]byte) {
+	t.Helper()
+	observed := x86RawMoveOriginGoBytes(t, "amd64", rows)
+	code, payloads := make([][]byte, len(rows)), make([][]byte, len(rows))
+	for index, row := range rows {
+		if len(observed[index]) < 4 || observed[index][len(observed[index])-1] != 0x13 {
+			t.Fatal("independent Go (BX)-to-vector2 ModRM changed", row.row, observed[index])
+		}
+		width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+		if row.scalar {
+			width = 4
+			if strings.HasPrefix(row.row, "VMOVSD") {
+				width = 8
+			}
+		}
+		payload := make([]byte, width)
+		for i := range payload {
+			payload[i] = byte(i*37 + 19)
+		}
+		code[index] = append([]byte(nil), observed[index]...)
+		code[index][len(code[index])-1] = 0x15 // RIP+disp32, vector2 unchanged.
+		code[index] = append(code[index], 1, 0, 0, 0, 0xc3)
+		code[index] = append(code[index], payload...)
+		payloads[index] = payload
+	}
+	return code, payloads
+}
+
+// These are fully initialized original source-local reads, not unbound format
+// fixtures. Existing raw RET and DATA checks must remain effective; adding a
+// mandatory numerical obligation cannot reject their valid unmasked instances.
+func TestX86RawMoveInitializedLiteralInputsAndReturnStillWork(t *testing.T) {
+	rows := x86RawMoveLiteralInputCases()
+	if len(rows) != 62 {
+		t.Fatal("complete unaligned packed/scalar literal directory changed", len(rows))
+	}
+	code, payloads := x86RawMoveLiteralInputBytes(t, rows)
+	var source, declarations strings.Builder
+	for index := range rows {
+		fmt.Fprintf(&declarations, "func Literal%d(mask uint64)\n", index)
+		fmt.Fprintf(&source, "TEXT ·Literal%d(SB),4,$0-8\nKMOVD mask+0(FP),K1\nVPXORQ Z2,Z2,Z2\n", index)
+		for _, value := range code[index] {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+	}
+	file, err := Parse(ArchAMD64, source.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	normalized, err := normalizeX86RawFile(file, "amd64")
+	if err != nil || len(normalized.Data) != len(rows) {
+		t.Fatal("initialized literal source lost its complete data directory", err)
+	}
+	for index, data := range normalized.Data {
+		if data.Width != int64(len(payloads[index])) || !bytes.Equal(data.Payload, payloads[index]) {
+			t.Fatal("literal capture changed the exact original source tuple", rows[index].row, data)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("valid initialized raw literal/RET regressed under the mandatory move proof", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "move-literal.ll", "move-literal.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawMoveLiteralInputsDoNotGrantMasksMergeOrReturnRoles(t *testing.T) {
+	rows := x86RawMoveLiteralInputCases()
+	code, payloads := x86RawMoveLiteralInputBytes(t, rows)
+	for index, row := range rows {
+		if row.masking == "plain" {
+			continue
+		}
+		for _, control := range []string{"mask", "merge", "raw return width", "raw return cleanup", "frame"} {
+			if control == "merge" && row.masking != "merge" {
+				continue
+			}
+			t.Run(row.row+"/"+control, func(t *testing.T) {
+				var source strings.Builder
+				frame := 0
+				if control == "frame" {
+					frame = 16
+				}
+				fmt.Fprintf(&source, "TEXT ·Literal(SB),4,$%d-8\n", frame)
+				if control != "mask" {
+					source.WriteString("KMOVD mask+0(FP),K1\n")
+				}
+				if control != "merge" {
+					source.WriteString("VPXORQ Z2,Z2,Z2\n")
+				}
+				original := append([]byte(nil), code[index]...)
+				if strings.HasPrefix(control, "raw return") {
+					// The original source has one instruction then C3 and the
+					// exact pool. Keep that pool's target and complete tuple.
+					ret := len(original) - len(payloads[index]) - 1
+					if ret < 5 || original[ret] != 0xc3 {
+						t.Fatal("independent literal return boundary missing")
+					}
+					replacement := []byte{0x66, 0xc3}
+					if control == "raw return cleanup" {
+						replacement = []byte{0xc2, 8, 0}
+					}
+					original[ret-4] = byte(len(replacement))
+					original = append(append(append([]byte(nil), original[:ret]...), replacement...), original[ret+1:]...)
+				}
+				for _, value := range original {
+					fmt.Fprintf(&source, "BYTE $%d\n", value)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Literal(mask uint64)", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("literal DATA invented an input or native return/frame role", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_move_origin_test.go b/x86_raw_move_origin_test.go
new file mode 100644
index 000000000..12df6ca6d
--- /dev/null
+++ b/x86_raw_move_origin_test.go
@@ -0,0 +1,340 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawMoveOriginCase struct {
+	row, bank, role, masking string
+	scalar                   bool
+}
+
+// Reuse the independent Go-table directory, not the production move registry.
+// Every source/destination width, memory direction and legal mask/zero role
+// appears here; architectural .Z memory-store faults remain separate controls.
+func x86RawMoveOriginCases() []x86RawMoveOriginCase {
+	var cases []x86RawMoveOriginCase
+	add := func(name, bank string, scalar, vexOnly bool) {
+		for _, role := range []string{"register", "load", "store"} {
+			for _, masking := range []string{"plain", "merge", "zero"} {
+				if vexOnly && masking != "plain" || role == "store" && masking == "zero" {
+					continue
+				}
+				op, mask := name, ""
+				if masking != "plain" {
+					mask = "K1,"
+				}
+				if masking == "zero" {
+					op += ".Z"
+				}
+				operands := bank + "0," + mask + bank + "2"
+				if scalar {
+					operands = "X0,X1," + mask + "X2"
+				}
+				if role == "load" {
+					operands = "(BX)," + mask + bank + "2"
+				} else if role == "store" {
+					operands = bank + "2," + mask + "(DI)"
+				}
+				cases = append(cases, x86RawMoveOriginCase{
+					row: op + " " + operands, bank: bank, role: role, masking: masking, scalar: scalar,
+				})
+			}
+		}
+	}
+	for _, row := range x86PackedMoveResultOracle {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if row.vexOnly && bank == "Z" {
+				continue
+			}
+			add(row.name, bank, false, row.vexOnly)
+		}
+	}
+	add("VMOVSS", "X", true, false)
+	add("VMOVSD", "X", true, false)
+	return cases
+}
+
+// Actual Go listing PCs delimit the observed bytes without consulting the
+// translator decoder. Mode32's physical four-operand scalar mask form has no
+// named frontend row; observe its low-bank encoding in amd64, then retain it
+// verbatim in the separately assembled original mode32 BYTE program.
+func x86RawMoveOriginGoBytes(t *testing.T, arch string, rows []x86RawMoveOriginCase) [][]byte {
+	t.Helper()
+	result := make([][]byte, len(rows))
+	for _, physical := range []bool{false, true} {
+		var source strings.Builder
+		var indexes []int
+		for index, row := range rows {
+			mode32Physical := arch == "386" && row.scalar && row.role == "register" && row.masking != "plain"
+			if mode32Physical != physical {
+				continue
+			}
+			source.WriteString(row.row + "\n")
+			indexes = append(indexes, index)
+		}
+		if len(indexes) == 0 {
+			continue
+		}
+		encoder := arch
+		if physical {
+			encoder = "amd64"
+		}
+		code, pcs := x86NumericalBoundaryGoBytes(t, encoder, source.String()+"RET")
+		if len(pcs) != len(indexes)+1 || code[len(code)-1] != 0xc3 {
+			t.Fatal("incomplete actual Go move byte boundaries", encoder, len(pcs), len(indexes))
+		}
+		for position, index := range indexes {
+			result[index] = append([]byte(nil), code[pcs[position]:pcs[position+1]]...)
+		}
+	}
+	return result
+}
+
+func x86RawMoveOriginSource(rows []x86RawMoveOriginCase, code [][]byte, arch string) (string, string) {
+	word, pointerMove := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		pointerMove = "MOVL"
+	}
+	var source, declarations strings.Builder
+	for index := range rows {
+		fmt.Fprintf(&declarations, "func Move%d(input,old,out *[128]byte,mask uint64)\n", index)
+		fmt.Fprintf(&source, "TEXT ·Move%d(SB),4,$0-%d\n%s input+0(FP),BX\n%s old+%d(FP),SI\n%s out+%d(FP),DI\nKMOVD mask+%d(FP),K1\n",
+			index, 3*word+8, pointerMove, pointerMove, word, pointerMove, 2*word, 3*word)
+		source.WriteString("VMOVDQU64 (BX),Z0\nVMOVDQU64 (SI),Z1\nVMOVDQU64 (SI),Z2\n")
+		for _, value := range code[index] {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+		source.WriteString("VMOVDQU64 Z2,64(DI)\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+const x86RawMoveOriginBatchSize = 48
+
+func TestX86RawMoveCompleteIndependentBatchDirectory(t *testing.T) {
+	rows := x86RawMoveOriginCases()
+	if len(rows) != 268 {
+		t.Fatal("complete packed12/scalar2 move role/mask/width directory changed", len(rows))
+	}
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		if seen[row.row] {
+			t.Fatal("duplicate independent move witness", row.row)
+		}
+		seen[row.row] = true
+	}
+	if (len(rows)+x86RawMoveOriginBatchSize-1)/x86RawMoveOriginBatchSize != 6 {
+		t.Fatal("incomplete or unbounded raw move object partition")
+	}
+}
+
+func TestX86RawMoveInitializedFiveTargetsBatch00(t *testing.T) { x86RawMoveOriginObjectBatch(t, 0) }
+func TestX86RawMoveInitializedFiveTargetsBatch01(t *testing.T) { x86RawMoveOriginObjectBatch(t, 1) }
+func TestX86RawMoveInitializedFiveTargetsBatch02(t *testing.T) { x86RawMoveOriginObjectBatch(t, 2) }
+func TestX86RawMoveInitializedFiveTargetsBatch03(t *testing.T) { x86RawMoveOriginObjectBatch(t, 3) }
+func TestX86RawMoveInitializedFiveTargetsBatch04(t *testing.T) { x86RawMoveOriginObjectBatch(t, 4) }
+func TestX86RawMoveInitializedFiveTargetsBatch05(t *testing.T) { x86RawMoveOriginObjectBatch(t, 5) }
+
+func x86RawMoveOriginObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	rows := x86RawMoveOriginCases()
+	first, last := batch*x86RawMoveOriginBatchSize, (batch+1)*x86RawMoveOriginBatchSize
+	if first < 0 || first >= len(rows) {
+		t.Fatal("invalid raw move batch", batch)
+	}
+	if last > len(rows) {
+		last = len(rows)
+	}
+	rows = rows[first:last]
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			code := x86RawMoveOriginGoBytes(t, arch, rows)
+			source, declarations := x86RawMoveOriginSource(rows, code, arch)
+			for _, target := range x86RawReturnTargets {
+				if target.arch != arch {
+					continue
+				}
+				t.Run(target.triple, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("initialized original move bytes could not compose with native inputs/output", err)
+							}
+							for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								compileLLVMToObject(t, llc, target.triple, "raw-move.ll", "raw-move.o", body)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarMoveNativeDeadAccessRetainsExactVolatileWidth(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, pointerMove, triple := goWordSize(arch), "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			pointerMove, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct {
+			name string
+			bits int
+		}{{"VMOVSS", 32}, {"VMOVSD", 64}} {
+			for _, store := range []bool{false, true} {
+				for _, masked := range []bool{false, true} {
+					mask, operation := "", row.name
+					if masked {
+						mask = "K1,"
+						if !store {
+							operation += ".Z"
+						}
+					}
+					operands := "(BX)," + mask + "X2"
+					if store {
+						operands = "X2," + mask + "(BX)"
+					}
+					instruction := operation + " " + operands
+					for _, raw := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%s/store=%t/masked=%t/raw=%t", arch, row.name, store, masked, raw), func(t *testing.T) {
+							var source strings.Builder
+							fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),BX\nKMOVD mask+%d(FP),K1\nVPXORQ Z2,Z2,Z2\n", word+8, pointerMove, word)
+							emitX86GoEncodedTestInstructionForArch(t, &source, instruction, raw, arch)
+							source.WriteString("RET\n")
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Value(p *byte,mask uint64)", arch, triple, "Go")
+							if err != nil {
+								t.Fatal("initialized scalar native access lost its source role", err)
+							}
+							access := "load"
+							if store {
+								access = "store"
+							}
+							for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								if !strings.Contains(body, fmt.Sprintf("%s volatile i%d", access, row.bits)) ||
+									!strings.Contains(body, "align 1") || masked && !strings.Contains(body, "br i1") {
+									t.Fatal("dead scalar access vanished, widened, asserted alignment or lost active-mask guard", instruction, body)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawMoveActualGoByteCaptureDoesNotChangeOriginalRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86RawMoveOriginCases()
+		code := x86RawMoveOriginGoBytes(t, arch, rows)
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				original := append([]byte(nil), code[index]...)
+				file, err := Parse(ArchAMD64, "TEXT ·Raw(SB),4,$0-0\n"+row.row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				var raw strings.Builder
+				raw.WriteString("TEXT ·Raw(SB),4,$0-0\n")
+				for _, value := range original {
+					fmt.Fprintf(&raw, "BYTE $%d\n", value)
+				}
+				raw.WriteString("RET\n")
+				decoded, err := Parse(ArchAMD64, raw.String())
+				if err == nil {
+					decoded, err = normalizeX86RawFile(decoded, arch)
+				}
+				if err != nil || len(decoded.Funcs[0].Instrs) != 3 {
+					t.Fatal("actual original move instruction failed physical normalization", err)
+				}
+				got, want := decoded.Funcs[0].Instrs[1], file.Funcs[0].Instrs[1]
+				if got.Op != want.Op || !x86RawOperandsMatchGoSource(got.Args, want.Args) ||
+					got.x86SourceRaw == nil || !bytes.Equal(code[index], original) {
+					t.Fatal("captured move bytes changed operation, operands or original identity", got, want)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawMoveVoidCannotBorrowInputsMasksOrNativeAddresses(t *testing.T) {
+	rows := x86RawMoveOriginCases()
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, triple := goWordSize(arch), "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		code := x86RawMoveOriginGoBytes(t, arch, rows)
+		for index, row := range rows {
+			if row.bank != "X" {
+				continue // Width completeness belongs to the partitioned object matrix.
+			}
+			var controls []string
+			if row.role == "load" && row.masking == "plain" {
+				controls = []string{"unknown address", "numeric address", "lost pointer"}
+			} else if row.role == "load" && row.masking == "zero" {
+				controls = []string{"unknown mask"}
+			} else if row.role == "load" && row.masking == "merge" {
+				controls = []string{"unknown merge"}
+			} else if row.role == "store" && row.masking == "plain" {
+				controls = []string{"unknown stored bytes"}
+			}
+			for _, control := range controls {
+				for _, unused := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/unused=%t", arch, row.row, control, unused), func(t *testing.T) {
+						declaration, extent := "func Value(p *byte)", word
+						if unused {
+							declaration, extent = "func Value(p *byte,unused bool)", word+1
+						}
+						var source strings.Builder
+						fmt.Fprintf(&source, "TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\n", extent, move)
+						if control != "unknown address" && control != "numeric address" {
+							fmt.Fprintf(&source, "%s p+0(FP),BX\n", move)
+						}
+						if control == "numeric address" || control == "lost pointer" {
+							source.WriteString("MOVL $1,BX\n")
+						}
+						if control != "unknown mask" {
+							source.WriteString("MOVL $5,CX\nKMOVD CX,K1\n")
+						}
+						source.WriteString("VPXORQ Z0,Z0,Z0\nVPXORQ Z1,Z1,Z1\n")
+						if control != "unknown merge" && control != "unknown stored bytes" {
+							source.WriteString("VPXORQ Z2,Z2,Z2\n")
+						}
+						for _, value := range code[index] {
+							fmt.Fprintf(&source, "BYTE $%d\n", value)
+						}
+						source.WriteString("VMOVDQU64 Z2,(DI)\nRET\n")
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration, arch, triple, api)
+							if row.scalar && row.role == "load" && (control == "numeric address" || control == "lost pointer") {
+								width := 4
+								if strings.HasPrefix(row.row, "VMOVSD ") {
+									width = 8
+								}
+								if err != nil || x86NumericNativeVolatileReadBytes(t, ir) != width {
+									t.Fatal("raw scalar NUM load lost its exact paired read", api, err)
+								}
+								x86RequireNumericNativeSourceContext(t, source.String(), declaration, arch)
+								x86NumericNativeAddressObject(t, ir, triple)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("raw move borrowed missing numerical/mask/address inputs for Void", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_raw_move_state_test.go b/x86_raw_move_state_test.go
new file mode 100644
index 000000000..f96f4a059
--- /dev/null
+++ b/x86_raw_move_state_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86RawMoveObservedInstruction(t *testing.T, arch string, code []byte) Instr {
+	t.Helper()
+	var source strings.Builder
+	source.WriteString("TEXT ·Move(SB),4,$0-0\n")
+	for _, value := range code {
+		fmt.Fprintf(&source, "BYTE $%d\n", value)
+	}
+	source.WriteString("RET\n")
+	file, err := Parse(ArchAMD64, source.String())
+	if err == nil {
+		file, err = normalizeX86RawFile(file, arch)
+	}
+	if err != nil || len(file.Funcs[0].Instrs) != 3 {
+		t.Fatal("actual raw move lost its single original instruction", err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func x86RawMoveInitializedState() x86ResultState {
+	state := x86ResultState{
+		flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+		fp: []bool{true, false}, auto: []bool{false, true},
+	}
+	for index := range state.gp {
+		state.gp[index], state.canonicalGP[index] = 0xff, 0xa5
+	}
+	state.pointerGP[3], state.pointerGP[7] = true, true
+	state.callerAddressGP[3], state.callerAddressGP[7] = true, true
+	for index := range state.masks {
+		state.masks[index] = true
+	}
+	for index := 0; index < 3; index++ {
+		state.xmm[index], state.vectorUpper[index] = 0xffff, ^uint64(0xffff)
+	}
+	return state
+}
+
+func TestX86RawMoveEveryByteAndIndependentState(t *testing.T) {
+	rows := x86RawMoveOriginCases()
+	for _, arch := range []string{"amd64", "386"} {
+		code := x86RawMoveOriginGoBytes(t, arch, rows)
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, code[index])
+				width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+				if row.scalar {
+					width = 4
+					if strings.HasPrefix(row.row, "VMOVSD") {
+						width = 8
+					}
+				}
+				for source := 0; source < 3; source++ {
+					for missing := -1; missing < 64; missing++ {
+						state := x86RawMoveInitializedState()
+						if missing >= 0 {
+							if missing < 16 {
+								state.xmm[source] &^= uint16(1) << uint(missing)
+							} else {
+								state.vectorUpper[source] &^= uint64(1) << uint(missing)
+							}
+						}
+						before, expected := state.clone(), state.clone()
+						accepted := true
+						known := ^uint64(0)
+						if row.role == "store" {
+							accepted = source != 2 || missing < 0 || missing >= width
+						} else if row.scalar {
+							if row.role == "register" && source == 0 && missing >= 0 && missing < width ||
+								row.masking == "merge" && source == 2 && missing >= 0 && missing < width {
+								accepted = false
+							}
+							if row.role == "register" && source == 1 && missing >= width && missing < 16 {
+								known &^= uint64(1) << uint(missing)
+							}
+						} else if missing >= 0 && missing < width &&
+							(row.role == "register" && source == 0 || row.masking == "merge" && source == 2) {
+							known &^= uint64(1) << uint(missing)
+						}
+						if accepted && row.role != "store" {
+							expected.xmm[2], expected.vectorUpper[2] = uint16(known), known&^0xffff
+						}
+						got, recognized := x86LoweredRawVectorMoveStep(ins, &state, nil, 0, arch)
+						if !recognized || got != accepted ||
+							accepted && !reflect.DeepEqual(state, expected) || !accepted && !reflect.DeepEqual(state, before) {
+							t.Fatal("raw move invented a byte, changed independent state or partially committed a rejection", source, missing, got, accepted)
+						}
+					}
+				}
+				for _, control := range []string{"mask", "address"} {
+					if control == "mask" && row.masking == "plain" || control == "address" && row.role == "register" {
+						continue
+					}
+					state := x86RawMoveInitializedState()
+					if control == "mask" {
+						state.masks[1] = false
+					} else if row.role == "load" {
+						state.pointerGP[3] = false
+					} else {
+						state.pointerGP[7] = false
+					}
+					before := state.clone()
+					accepted, recognized := x86LoweredRawVectorMoveStep(ins, &state, nil, 0, arch)
+					numericalRead := control == "address" && row.scalar && row.role == "load"
+					if !recognized || accepted != numericalRead || !reflect.DeepEqual(state, before) {
+						t.Fatal("raw move changed independent address/mask state", control)
+					}
+					if numericalRead {
+						base := 3
+						if row.role == "store" {
+							base = 7
+						}
+						for _, available := range []uint8{0, 1} {
+							partial := before.clone()
+							partial.gp[base] = available
+							unchanged := partial.clone()
+							if accepted, _ := x86LoweredRawVectorMoveStep(ins, &partial, nil, 0, arch); accepted || !reflect.DeepEqual(partial, unchanged) {
+								t.Fatal("raw move acquired unknown or partial address bytes", available)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawMoveEditedOriginRejectsAtomically(t *testing.T) {
+	rows := x86RawMoveOriginCases()
+	for _, arch := range []string{"amd64", "386"} {
+		code := x86RawMoveOriginGoBytes(t, arch, rows)
+		for index, row := range rows {
+			t.Run(arch+"/"+row.row, func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, code[index])
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"opcode", func(ins *Instr) {
+						name, suffix, dotted := strings.Cut(string(ins.Op), ".")
+						if row.scalar {
+							name = map[string]string{"VMOVSS": "VMOVSD", "VMOVSD": "VMOVSS"}[name]
+						} else if name == "VMOVDQA" || name == "VMOVDQU" {
+							name = map[string]string{"VMOVDQA": "VMOVDQU", "VMOVDQU": "VMOVDQA"}[name]
+						} else if name == "VMOVUPS" {
+							name = "VMOVUPD"
+						} else {
+							name = "VMOVUPS"
+						}
+						if dotted {
+							name += "." + suffix
+						}
+						ins.Op = Op(name)
+					}},
+					{"operand", func(ins *Instr) {
+						last := &ins.Args[len(ins.Args)-1]
+						if last.Kind == OpMem {
+							last.Mem.Off++
+						} else {
+							last.Reg = Reg(row.bank + "3")
+						}
+					}},
+					{"source opcode", func(ins *Instr) { ins.x86SourceRaw.op = "MOVL" }},
+					{"source operand", func(ins *Instr) { ins.x86SourceRaw.args[0] = Operand{Kind: OpReg, Reg: "X4"} }},
+					{"vector width", func(ins *Instr) { ins.x86VectorBytes += 16 }},
+					{"source width", func(ins *Instr) { ins.x86SourceRaw.vectorBytes += 16 }},
+					{"address width", func(ins *Instr) { ins.x86AddressBits = 16 }},
+					{"address override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+					{"raw return", func(ins *Instr) { ins.x86RawNearReturn = new(x86RawNearReturnForm) }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					control.edit(&changed)
+					state := x86RawMoveInitializedState()
+					before := state.clone()
+					if accepted, _ := x86LoweredRawVectorMoveStep(changed, &state, nil, 0, arch); accepted || x86RawVectorMoveSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited original move borrowed a paired continuation or changed state", control.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_nop_source_state_test.go b/x86_raw_nop_source_state_test.go
new file mode 100644
index 000000000..0b2aed844
--- /dev/null
+++ b/x86_raw_nop_source_state_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func x86RawNOPSourceStateInstruction(t *testing.T, arch string, code []byte) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\n"+x86RawDisplacementDirectives(code)+"RET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, ins := range fn.Instrs {
+		if ins.x86SourceRaw != nil {
+			return ins
+		}
+	}
+	t.Fatal("missing actual original/normalized raw handoff")
+	return Instr{}
+}
+
+func TestX86RawNOPCompleteSourceStateRetention(t *testing.T) {
+	for _, mode := range []int{32, 64} {
+		arch := "amd64"
+		if mode == 32 {
+			arch = "386"
+		}
+		for _, code := range x86RawNOPWitnesses(mode) {
+			t.Run(fmt.Sprintf("mode%d/%x", mode, code), func(t *testing.T) {
+				ins := x86RawNOPSourceStateInstruction(t, arch, code)
+				for _, direction := range []x86ResultDirection{0, 1, 2, 3} {
+					if got := x86ResultDirectionAfter(ins, direction); got != direction {
+						t.Fatal("inert raw NOP lost or invented DF", direction, got)
+					}
+				}
+				for _, count := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+					if got := x86ResultStringCountAfter(ins, count, count, arch); got != count {
+						t.Fatal("inert raw NOP lost or invented the unchanged CX fact", count, got)
+					}
+				}
+				for _, predicate := range []x86ResultPredicate{{}, {kind: x86ResultNonzeroComparisonBytes, register: 3, width: 32}} {
+					if got := x86ResultPredicateAfter(ins, predicate, arch); got != predicate {
+						t.Fatal("inert raw NOP changed an existing relation", predicate, got)
+					}
+				}
+				for _, before := range [][16]bool{{}, {3: true, 7: true}} {
+					if got := x86ResultCallerAddressesAfter(ins, before, nil, arch); got != before {
+						t.Fatal("inert raw NOP lost or invented an existing GP identity", before, got)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawNOPPrivateStackAndIDRetention(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		width := "Q"
+		if arch == "386" {
+			width = "L"
+		}
+		for _, live := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/live=%t", arch, live), func(t *testing.T) {
+				body := x86RawDisplacementDirectives([]byte{0x0f, 0x1f, 0xc0})
+				if live {
+					body = "PUSH" + width + " $7\n" + body + "POP" + width + " AX\n"
+				}
+				file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\n"+body+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, initialized := range []bool{false, true} {
+					state := x86ResultState{valueStack: &x86ResultValueStack{id: initialized}}
+					if initialized {
+						state.direction, state.flags = x86ResultDirectionEither, x86ByteFlagsAll
+					}
+					err = checkX86ResultSourceFlow(fn, state, nil, 0, arch,
+						func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+							return x86ResultTransfer(ins, state, owned, offset, arch)
+						}, func(after x86ResultState, _ int) error {
+							if after.valueStack.id != initialized || after.direction != state.direction || after.flags != state.flags {
+								return fmt.Errorf("inert padding changed private status: before=%+v after=%+v", state, after)
+							}
+							return nil
+						})
+					if err != nil {
+						t.Fatal("sealed padding changed independent private numerical transport", initialized, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawNOPStateRetentionRequiresExactHandoff(t *testing.T) {
+	original := x86RawNOPSourceStateInstruction(t, "amd64", []byte{0x0f, 0x1f, 0xc0})
+	for _, mutation := range []string{
+		"original opcode", "original operands", "normalized opcode", "normalized operands",
+		"encoded", "raw return", "address size", "unbound address", "segment",
+	} {
+		t.Run(mutation, func(t *testing.T) {
+			ins := original
+			origin := *ins.x86SourceRaw
+			ins.x86SourceRaw = &origin
+			switch mutation {
+			case "original opcode":
+				origin.op = "PAUSE"
+			case "original operands":
+				origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "normalized opcode":
+				ins.Op = "PAUSE"
+			case "normalized operands":
+				ins.Args = []Operand{{Kind: OpReg, Reg: AX}}
+			case "encoded":
+				ins.x86Encoded = true
+			case "raw return":
+				ins.x86RawNearReturn = new(x86RawNearReturnForm)
+			case "address size":
+				ins.x86AddressBits = 32
+			case "unbound address":
+				ins.x86UnboundAddressOverride = true
+			case "segment":
+				ins.x86SegmentPrefix = 0x64
+			}
+			if got := x86ResultDirectionAfter(ins, x86ResultDirectionForward); got != x86ResultDirectionUnknown {
+				t.Fatal("changed physical effect retained DF", got)
+			}
+			if got := x86ResultStringCountAfter(ins, x86StringCountZero, x86StringCountZero, "amd64"); got != x86StringCountUnknown {
+				t.Fatal("changed physical effect retained a CX fact", got)
+			}
+			predicate := x86ResultPredicate{kind: x86ResultNonzeroComparisonBytes, register: 3, width: 32}
+			if got := x86ResultPredicateAfter(ins, predicate, "amd64"); got != (x86ResultPredicate{}) {
+				t.Fatal("changed physical effect retained a relation", got)
+			}
+			if got := x86ResultCallerAddressesAfter(ins, [16]bool{3: true}, nil, "amd64"); got != ([16]bool{}) {
+				t.Fatal("changed physical effect retained GP identities", got)
+			}
+			state := x86ResultState{valueStack: &x86ResultValueStack{bytes: make([]uint8, 8)}}
+			if x86ResultValueStackContinuation(ins, &state, "amd64") {
+				t.Fatal("changed physical effect entered live private storage")
+			}
+		})
+	}
+}
+
+func TestX86RawNOPOriginalStatusSourceObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86OrderingHintTargets {
+		bits := 64
+		if target.arch == "386" {
+			bits = 32
+		}
+		declarations, source, _, _ := x86RawNOPRuntimeFixture(bits)
+		t.Run(target.triple, func(t *testing.T) {
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source, declarations, target.arch, target.triple)
+				if err != nil {
+					t.Fatal("unchanged raw-NOP GP/FLAGS/MXCSR/canary source", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	t.Log("unchanged original state fixture: Go and LLVM objects, not native x86 execution")
+}
diff --git a/x86_raw_operand_free_source.go b/x86_raw_operand_free_source.go
new file mode 100644
index 000000000..57aeca214
--- /dev/null
+++ b/x86_raw_operand_free_source.go
@@ -0,0 +1,11 @@
+package plan9asm
+
+// A family must independently validate its complete zero-operand grammar.
+// This identity check alone establishes neither an effect nor an input role.
+func x86RawOperandFreeSource(ins Instr) bool {
+	origin := ins.x86SourceRaw
+	return len(ins.Args) == 0 && origin != nil && origin.op == ins.Op && len(origin.args) == 0 &&
+		origin.vectorBytes == ins.x86VectorBytes && ins.x86RawNearReturn == nil &&
+		ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0 &&
+		!ins.x86RIPLiteral && ins.x86NumericalRead == nil
+}
diff --git a/x86_raw_original_address_mode_test.go b/x86_raw_original_address_mode_test.go
new file mode 100644
index 000000000..d8f14afd8
--- /dev/null
+++ b/x86_raw_original_address_mode_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import "testing"
+
+func TestX86RawNumericalOriginRequiresOriginalAddressMode(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, line := range []string{
+			"MOVBEW (AX),BX", "ANDNL AX,BX,CX", "PDEPL AX,BX,CX", "PEXTL AX,BX,CX",
+			"VADDPD X0,X1,X2", "VPSHUFB X0,X1,X2", "CMOVLLE AX,BX",
+		} {
+			t.Run(arch+"/"+line, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+
+					x86RawNumericalInstruction(t, arch, line)+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if !x86RawOrdinaryVectorSource(ins, arch) {
+					t.Fatal("original default-mode numerical source rejected", ins)
+				}
+				origin := *ins.x86SourceRaw
+				origin.addressBits = 16
+				ins.x86SourceRaw = &origin
+				if x86RawOrdinaryVectorSource(ins, arch) {
+					t.Fatal("rewritten original address mode borrowed a numerical continuation")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_packed_move_generation_identity_test.go b/x86_raw_packed_move_generation_identity_test.go
new file mode 100644
index 000000000..fd681c832
--- /dev/null
+++ b/x86_raw_packed_move_generation_identity_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawPackedMovePhysicalGenerationSealRejectsAtomically(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86PackedMovePhysicalCases() {
+			t.Run(fmt.Sprintf("%s/%s/%s/%s/EVEX%t", arch, row.name, row.bank, row.role, row.evex), func(t *testing.T) {
+				original := x86RawMoveObservedInstruction(t, arch, row.code)
+				state := x86RawMoveInitializedState()
+				state.pointerGP[6] = true // The actual SI address, not an inferred pointee.
+				before := state.clone()
+				if accepted, known := x86LoweredRawVectorMoveStep(original, &state, nil, 0, arch); !known || !accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("complete original move lost its existing paired effect or changed independent state")
+				}
+				for _, control := range []struct {
+					name string
+					edit func(*Instr)
+				}{
+					{"absent snapshot", func(ins *Instr) { ins.x86SourceRaw.packedMove = x86RawPackedMoveIdentity{} }},
+					{"foreign snapshot", func(ins *Instr) {
+						ins.x86SourceRaw.packedMove.arch = map[string]string{"386": "amd64", "amd64": "386"}[arch]
+					}},
+					{"physical generation", func(ins *Instr) { ins.x86PackedVectorMoveEVEX = !ins.x86PackedVectorMoveEVEX }},
+					{"physical grammar", func(ins *Instr) { ins.x86Encoded = !ins.x86Encoded }},
+					{"snapshot generation", func(ins *Instr) { ins.x86SourceRaw.packedMove.evex = !ins.x86SourceRaw.packedMove.evex }},
+					{"snapshot grammar", func(ins *Instr) { ins.x86SourceRaw.packedMove.encoded = !ins.x86SourceRaw.packedMove.encoded }},
+				} {
+					changed := cloneX86ReplayInstrs([]Instr{original})[0]
+					control.edit(&changed)
+					state = before.clone()
+					if accepted, _ := x86LoweredRawVectorMoveStep(changed, &state, nil, 0, arch); accepted ||
+						x86RawVectorMoveSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("edited physical identity borrowed or partially committed a move effect", control.name)
+					}
+					if !x86RawVectorMoveSource(original, arch) {
+						t.Fatal("editing a replay clone mutated the original generation snapshot", control.name)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawPackedMovePhysicalGenerationCannotBroadenVEXOnlyMembers(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"VMOVDQA", "VMOVDQU"} {
+			for _, bank := range []string{"X", "Y"} {
+				t.Run(arch+"/"+name+"/"+bank, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT f(SB),4,$0-0\n%s %s0,%s2\nRET\n", name, bank, bank))
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					if _, known, err := amd64PackedVectorMoveProperties(ins, arch); !known || err != nil {
+						t.Fatal("the complete original VEX-only member lost its grammar", err)
+					}
+					ins.x86PackedVectorMoveEVEX = true
+					if _, known, err := amd64PackedVectorMoveProperties(ins, arch); !known || err == nil {
+						t.Fatal("physical generation metadata invented an EVEX spelling for a VEX-only member")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_packed_move_generation_test.go b/x86_raw_packed_move_generation_test.go
new file mode 100644
index 000000000..a41aedbce
--- /dev/null
+++ b/x86_raw_packed_move_generation_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+type x86PackedMovePhysicalCase struct {
+	name, bank, role string
+	evex, aligned    bool
+	code             []byte
+}
+
+// Independent literal bytes from Go 1.27's complete _yvmovapd rows and
+// AVMOVAPS/APD/UPS/UPD opcode entries. Named low-bank unmasked X/Y sources
+// select VEX, so they alone cannot witness the equally valid EVEX encodings.
+func x86PackedMovePhysicalCases() []x86PackedMovePhysicalCase {
+	var rows []x86PackedMovePhysicalCase
+	for _, name := range []string{"VMOVAPS", "VMOVAPD", "VMOVUPS", "VMOVUPD"} {
+		aligned, pp, opcode := strings.HasPrefix(name, "VMOVA"), byte(0), byte(0x10)
+		if aligned {
+			opcode = 0x28
+		}
+		if strings.HasSuffix(name, "PD") {
+			pp = 1
+		}
+		for _, evex := range []bool{false, true} {
+			for length, bank := range []string{"X", "Y", "Z"} {
+				if !evex && length == 2 {
+					continue
+				}
+				for _, role := range []string{"load", "store", "register-load", "register-store"} {
+					operation, modrm := opcode, byte(0x16) // (SI) and vector2.
+					if strings.HasSuffix(role, "store") {
+						operation++
+					}
+					if strings.HasPrefix(role, "register") {
+						modrm = 0xd1 // vector1 and vector2; retain both opcode directions.
+					}
+					code := []byte{0xc4, 0xe1, 0x78 | pp | byte(length)<<2, operation, modrm}
+					if evex {
+						p1 := byte(0x7c) | pp
+						if pp == 1 {
+							p1 |= 0x80
+						}
+						code = []byte{0x62, 0xf1, p1, 0x08 | byte(length)<<5, operation, modrm}
+					}
+					rows = append(rows, x86PackedMovePhysicalCase{name, bank, role, evex, aligned, code})
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86RawPackedMovePhysicalGenerationAndRequiredFeatures(t *testing.T) {
+	rows := x86PackedMovePhysicalCases()
+	if len(rows) != 80 {
+		t.Fatal("complete low-bank VEX/EVEX physical directory changed", len(rows))
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range rows {
+			t.Run(fmt.Sprintf("%s/%s/%s/%s/EVEX%t", arch, row.name, row.bank, row.role, row.evex), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code)
+				form, known, err := amd64PackedVectorMoveProperties(ins, arch)
+				if !known || err != nil || ins.Op != Op(row.name) || !x86RawVectorMoveSource(ins, arch) {
+					t.Fatal("valid original physical move lost its exact existing typed family", ins.Raw, err)
+				}
+				if form.nativeEVEX(ins) != row.evex {
+					t.Error("original low-bank physical generation was inferred from operands instead of retained from bytes")
+				}
+				if !row.aligned || strings.HasPrefix(row.role, "register") {
+					return // Only the existing aligned native-memory bridge needs these carriers.
+				}
+				features := "," + inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{ins}}) + ","
+				if got := strings.Contains(features, ",+avx512f,"); got != row.evex {
+					t.Error("isolated native memory has the wrong AVX512F requirement", features)
+				}
+				if got := strings.Contains(features, ",+avx512vl,"); got != (row.evex && row.bank != "Z") {
+					t.Error("isolated native memory has the wrong AVX512VL requirement", features)
+				}
+				if !row.evex && !strings.Contains(features, ",+avx,") {
+					t.Error("the original VEX control lost its AVX requirement", features)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawPackedMovePhysicalBytesIndependentLLVM22(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	var input strings.Builder
+	for _, row := range x86PackedMovePhysicalCases() {
+		for _, value := range row.code {
+			fmt.Fprintf(&input, "0x%02x ", value)
+		}
+		input.WriteByte('\n')
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "x86_64-unknown-linux-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple,
+				"--mattr=+avx,+avx512f,+avx512vl")
+			command.Stdin = strings.NewReader(input.String())
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+				t.Fatalf("independent complete physical-byte decoding failed: %v\n%s", err, output)
+			}
+			for _, name := range []string{"vmovaps", "vmovapd", "vmovups", "vmovupd"} {
+				if count := len(regexp.MustCompile(`\b`+name+`[ \t]+`).FindAll(output, -1)); count != 20 {
+					t.Fatalf("independent LLVM22 decoding lost %s physical forms: %d\n%s", name, count, output)
+				}
+			}
+		})
+	}
+}
+
+func x86RawPackedMoveAlignedPhysicalSource(arch string, initialized bool) (string, string) {
+	word, pointerMove := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		pointerMove = "MOVL"
+	}
+	var source, declarations strings.Builder
+	index := 0
+	for _, row := range x86PackedMovePhysicalCases() {
+		if !row.aligned || row.bank == "Z" || strings.HasPrefix(row.role, "register") {
+			continue
+		}
+		fmt.Fprintf(&declarations, "func Physical%d(p *[128]byte)\n", index)
+		fmt.Fprintf(&source, "TEXT ·Physical%d(SB),4,$0-%d\n", index, word)
+		if initialized {
+			fmt.Fprintf(&source, "%s p+0(FP),SI\nVPXOR X2,X2,X2\n", pointerMove)
+		}
+		for _, value := range row.code {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+		source.WriteString("RET\n")
+		index++
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86RawPackedMoveLowBankEVEXAlignedFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86RawPackedMoveAlignedPhysicalSource(target.arch, true)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("valid initialized original physical move was not translated", err)
+					}
+					for _, name := range []string{"vmovaps", "vmovapd"} {
+						if strings.Count(ir, "{evex} "+name+" ") != 4 || strings.Count(ir, `asm sideeffect "`+name+` `) != 4 {
+							t.Fatal("original low-bank native EVEX/VEX opcode generation changed", name)
+						}
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "physical-move.ll", "physical-move.o", body)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawPackedMovePhysicalGenerationDoesNotGrantEntryInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86RawPackedMoveAlignedPhysicalSource(target.arch, false)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("physical encoding or CPU features invented native entry inputs", api, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_packed_move_identity.go b/x86_raw_packed_move_identity.go
new file mode 100644
index 000000000..128ed7bd0
--- /dev/null
+++ b/x86_raw_packed_move_identity.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+// Physical generation is part of the original raw identity, not an operand
+// inference or a numerical permission. arch distinguishes an absent snapshot
+// from a genuine VEX source whose EVEX flag is false.
+type x86RawPackedMoveIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86PackedMoveRawIdentity(ins Instr, arch string) x86RawPackedMoveIdentity {
+	if _, known, err := amd64PackedVectorMoveProperties(ins, arch); !known || err != nil {
+		return x86RawPackedMoveIdentity{}
+	}
+	return x86RawPackedMoveIdentity{arch, ins.x86Encoded, ins.x86PackedVectorMoveEVEX}
+}
+
+func x86RawPackedMoveEncodingSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	return origin != nil && origin.packedMove.arch == arch &&
+		origin.packedMove == x86PackedMoveRawIdentity(ins, arch)
+}
diff --git a/x86_raw_qq_to_float_fixture_contract_test.go b/x86_raw_qq_to_float_fixture_contract_test.go
new file mode 100644
index 000000000..cf5f64c1a
--- /dev/null
+++ b/x86_raw_qq_to_float_fixture_contract_test.go
@@ -0,0 +1,192 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86RawQQToFloatFixturePrior(t *testing.T, arch string) (string, []byte, int) {
+	t.Helper()
+	wantSource, wantCode, count := "2d0155befdd249df921df14f13a5be911e7f751dcc2835cb863731b711e15b3d",
+		"d755acf6443648ef0cef5b99169df9b14649e5291ec25dfe6f690e7e8a1c4ad1", 76
+	if arch == "386" {
+		wantSource, wantCode, count = "cc6ced228c80f60bb4e83952a205844cbc1accb590cb54c6c756209cbb84af08",
+			"affd0b32e9ed38660b94b8f6f8591c1867d9c5030e5e11f061187c412a664d55", 36
+	}
+	source := x86RawQQToFloatOriginalSource(arch)
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(source))) != wantSource {
+		t.Fatal("the original uninitialized QQ-to-float source was changed", arch)
+	}
+	var code []byte
+	for _, line := range strings.Split(source, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) == 2 && fields[0] == "BYTE" {
+			value, err := strconv.ParseUint(strings.TrimPrefix(fields[1], "$"), 0, 8)
+			if err != nil {
+				t.Fatal("original BYTE inventory", err)
+			}
+			code = append(code, byte(value))
+		}
+	}
+	code = append(code, 0xc3) // Original textual RET, not a native-entry permission.
+	if fmt.Sprintf("%x", sha256.Sum256(code)) != wantCode {
+		t.Fatal("original raw physical encoding payload was shortened or replaced", arch)
+	}
+	file := mustParseX86RawReturn(t, source)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil || len(normalized.Funcs) != 1 || len(normalized.Funcs[0].Instrs) != count+2 {
+		t.Fatal("original whole QQ-to-float instruction denominator changed", arch, err)
+	}
+	seen := make(map[string]int)
+	for _, instruction := range normalized.Funcs[0].Instrs[1 : count+1] {
+		name, _, _ := strings.Cut(string(instruction.Op), ".")
+		seen[name]++
+	}
+	psXY, psZ, pd := 5, 9, 19
+	if arch == "386" {
+		psXY, psZ, pd = 3, 3, 9
+	}
+	want := map[string]int{
+		"VCVTQQ2PSX": psXY, "VCVTUQQ2PSX": psXY,
+		"VCVTQQ2PSY": psXY, "VCVTUQQ2PSY": psXY,
+		"VCVTQQ2PS": psZ, "VCVTUQQ2PS": psZ,
+		"VCVTQQ2PD": pd, "VCVTUQQ2PD": pd,
+	}
+	if len(seen) != len(want) {
+		t.Fatal("original four semantic families lost one of their eight Go spellings", seen)
+	}
+	for name, expected := range want {
+		if seen[name] != expected {
+			t.Fatal("original source lost a width/register/memory/broadcast/mask/ER witness", arch, name, seen[name], expected)
+		}
+	}
+	return source, code, count
+}
+
+func x86RawQQToFloatInitializedFixture(t *testing.T, arch string) (string, string, int) {
+	t.Helper()
+	original, _, count := x86RawQQToFloatFixturePrior(t, arch)
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	const oldHeader = "TEXT rawQQToFloat(SB),$0-0\n"
+	header := fmt.Sprintf("TEXT ·rawQQToFloat(SB),4,$0-%d\n%s p+0(FP),AX\n", word, move) +
+		"MOVL $1,CX\nKMOVD CX,K4\nKMOVD CX,K7\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n"
+	// Only a separate typed entry/prefix is added. Every original BYTE and the
+	// original final RET remain in their original order, including dead effects.
+	return header + strings.TrimPrefix(original, oldHeader), "func rawQQToFloat(p *byte)", count
+}
+
+func TestX86RawQQToFloatOriginalFixtureInputContract(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, payload, count := x86RawQQToFloatFixturePrior(t, arch)
+			actual := x86PackedShiftActualGoBytes(t, arch, source)
+			// Go may add a stack-check prologue/tail to the unchanged 386
+			// TEXT. Keep that complete object; require the entire original
+			// physical instruction payload once, not a truncated prefix.
+			if bytes.Count(actual, payload) != 1 {
+				t.Fatal("actual Go object lost the complete original raw payload/RET", arch)
+			}
+			t.Logf("original rows=%d sourceSHA256=%x actualWholeGoCodeSHA256=%x", count,
+				sha256.Sum256([]byte(source)), sha256.Sum256(actual))
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func rawQQToFloat()", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("the unchanged format-only Void fixture invented missing inputs", api, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawQQToFloatInitializedSourceAndMissingInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			source, declaration, count := x86RawQQToFloatInitializedFixture(t, arch)
+			triple, move := "x86_64-unknown-linux-gnu", "MOVQ"
+			if arch == "386" {
+				triple, move = "i386-unknown-linux-gnu", "MOVL"
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			missing := []struct{ name, remove string }{
+				{"source-vector", "VPXORD Z1,Z1,Z1\n"},
+				{"incoming-pointer", move + " p+0(FP),AX\n"},
+			}
+			if arch == "amd64" {
+				missing = append(missing, struct{ name, remove string }{"mask-K7", "KMOVD CX,K7\n"},
+					struct{ name, remove string }{"rounding-mask-K4", "KMOVD CX,K4\n"})
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if err != nil || strings.Count(ir, "asm sideeffect") != count {
+						t.Fatal("the same complete raw body lost initialized inputs or native MXCSR/access effects", api, err)
+					}
+					for _, control := range missing {
+						t.Run(control.name, func(t *testing.T) {
+							changed := strings.Replace(source, control.remove, "", 1)
+							if changed == source {
+								t.Fatal("missing-input control did not remove its real producer")
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("Void raw conversion borrowed an absent actual input", control.name, api, err)
+							}
+						})
+					}
+					ir, err = x86ScalarFPBitViewAPI(t, source, "func rawQQToFloat(p uintptr)", arch, triple, api)
+					if err != nil || strings.Count(ir, "asm sideeffect") != count {
+						t.Fatal("a full NUM address lost its original raw native accesses", api, err)
+					}
+					x86RequireNumericNativeSourceContext(t, source, "func rawQQToFloat(p uintptr)", arch)
+					x86NumericNativeAddressObject(t, ir, triple)
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawQQToFloatInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declaration, count := x86RawQQToFloatInitializedFixture(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized QQ-to-float public program", err)
+					}
+					optimized := x86DwordProductIROptimize(t, ir)
+					for _, pipeline := range []struct{ name, ir, backend string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"}, {"IR_O2_backend_O2", optimized, "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							if strings.Count(pipeline.ir, "asm sideeffect") != count {
+								t.Fatal("optimization removed an original opcode/access/exception effect")
+							}
+							x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.backend)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_raw_replay.go b/x86_raw_replay.go
new file mode 100644
index 000000000..e36679eba
--- /dev/null
+++ b/x86_raw_replay.go
@@ -0,0 +1,169 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// x86RawReplaySource retains the exact raw TEXT spelling and the two
+// normalization checkpoints needed by the logical AUTO observer. It is
+// deliberately private: JSON/source reconstruction cannot manufacture this
+// identity or any machine-state permission.
+type x86RawReplaySource struct {
+	source     string
+	goarch     string
+	sym        string
+	frame      int64
+	args       int64
+	original   []Instr
+	decoded    []Instr
+	normalized []Instr
+}
+
+func x86HasRawReplayDirectives(fn Func) bool {
+	for _, ins := range fn.Instrs {
+		if isX86RawDirective(ins) {
+			return true
+		}
+	}
+	return false
+}
+
+func x86RawReplaySourceText(fn Func) (string, bool) {
+	if len(fn.Instrs) == 0 {
+		return "", false
+	}
+	var source strings.Builder
+	for _, ins := range fn.Instrs {
+		if ins.Raw == "" || len(ins.Raw) > (1<<20)-source.Len()-1 {
+			return "", false
+		}
+		source.WriteString(ins.Raw)
+		source.WriteByte('\n')
+	}
+	return source.String(), true
+}
+
+func newX86RawReplaySource(original, decoded Func, goarch string) *x86RawReplaySource {
+	if !x86HasRawReplayDirectives(original) {
+		return nil
+	}
+	source, ok := x86RawReplaySourceText(original)
+	if !ok {
+		return nil
+	}
+	return &x86RawReplaySource{
+		source:   source,
+		goarch:   goarch,
+		sym:      original.Sym,
+		frame:    original.FrameSize,
+		args:     original.ArgSize,
+		original: cloneX86ReplayInstrs(original.Instrs),
+		decoded:  cloneX86ReplayInstrs(decoded.Instrs),
+	}
+}
+
+func (replay *x86RawReplaySource) withNormalized(fn Func) *x86RawReplaySource {
+	if replay == nil {
+		return nil
+	}
+	copy := *replay
+	copy.normalized = cloneX86ReplayInstrs(fn.Instrs)
+	return &copy
+}
+
+func cloneX86ReplayInstrs(input []Instr) []Instr {
+	if input == nil {
+		return nil
+	}
+	output := make([]Instr, len(input))
+	for index, instruction := range input {
+		output[index] = instruction
+		output[index].Args = append([]Operand(nil), instruction.Args...)
+		if instruction.x86SourceRaw != nil {
+			copy := *instruction.x86SourceRaw
+			copy.args = append([]Operand(nil), instruction.x86SourceRaw.args...)
+			output[index].x86SourceRaw = &copy
+		}
+		if instruction.x86RawNearReturn != nil {
+			copy := *instruction.x86RawNearReturn
+			output[index].x86RawNearReturn = &copy
+		}
+		output[index].x86SourceStackFP = cloneX86ReplayInt64Map(instruction.x86SourceStackFP)
+		output[index].x86CallerMemory = cloneX86ReplayCallerMemory(instruction.x86CallerMemory)
+		output[index].x86FixedLocalMemory = cloneX86ReplayFixedLocalMemory(instruction.x86FixedLocalMemory)
+		output[index].x86RIPLiteralData = append([]byte(nil), instruction.x86RIPLiteralData...)
+		output[index].x86RIPAddressData = append([]byte(nil), instruction.x86RIPAddressData...)
+		output[index].x86RIPMemoryRead = instruction.x86RIPMemoryRead
+		output[index].x86RIPMemoryRead.args = append([]Operand(nil), instruction.x86RIPMemoryRead.args...)
+	}
+	return output
+}
+
+func cloneX86ReplayInt64Map(input map[int]int64) map[int]int64 {
+	if input == nil {
+		return nil
+	}
+	output := make(map[int]int64, len(input))
+	for key, value := range input {
+		output[key] = value
+	}
+	return output
+}
+
+func cloneX86ReplayCallerMemory(input map[int]x86CallerMemoryAccess) map[int]x86CallerMemoryAccess {
+	if input == nil {
+		return nil
+	}
+	output := make(map[int]x86CallerMemoryAccess, len(input))
+	for key, value := range input {
+		value.args = append([]Operand(nil), value.args...)
+		output[key] = value
+	}
+	return output
+}
+
+func cloneX86ReplayFixedLocalMemory(input map[int]x86FixedLocalAccess) map[int]x86FixedLocalAccess {
+	if input == nil {
+		return nil
+	}
+	output := make(map[int]x86FixedLocalAccess, len(input))
+	for key, value := range input {
+		value.iterationOffsets = append([][8]int64(nil), value.iterationOffsets...)
+		output[key] = value
+	}
+	return output
+}
+
+// Repeated normalization may preserve a sealed checkpoint, never replace it
+// with edited instructions. Full source replay remains the consumer's check.
+func (replay *x86RawReplaySource) validateNormalized(fn Func, arch string) error {
+	if replay == nil || x86SourceStackScalarArch(replay.goarch) != x86SourceStackScalarArch(arch) ||
+		fn.Sym != replay.sym || fn.FrameSize != replay.frame || fn.ArgSize != replay.args || len(replay.normalized) == 0 {
+		return fmt.Errorf("%w: result initialization AUTO: original raw source identity changed", ErrProbeNeedsContext)
+	}
+	if !reflect.DeepEqual(fn.Instrs, replay.normalized) {
+		return fmt.Errorf("%w: result initialization AUTO: normalized raw source identity changed", ErrProbeNeedsContext)
+	}
+	return nil
+}
+
+func (replay *x86RawReplaySource) validate(fn Func, arch string) error {
+	if err := replay.validateNormalized(fn, arch); err != nil {
+		return err
+	}
+	parsed, err := Parse(ArchAMD64, replay.source)
+	if err != nil || parsed == nil || len(parsed.Funcs) != 1 || len(parsed.UnlinkedPrelude) != 0 || len(parsed.Data) != 0 || len(parsed.Globl) != 0 {
+		return fmt.Errorf("%w: result initialization AUTO: original raw source cannot be replayed", ErrProbeNeedsContext)
+	}
+	original := parsed.Funcs[0]
+	if original.Sym != replay.sym || original.FrameSize != replay.frame || original.ArgSize != replay.args || !reflect.DeepEqual(original.Instrs, replay.original) {
+		return fmt.Errorf("%w: result initialization AUTO: original raw source identity changed", ErrProbeNeedsContext)
+	}
+	decoded, err := decodeX86RawDirectives(original, arch)
+	if err != nil || !reflect.DeepEqual(decoded.Instrs, replay.decoded) {
+		return fmt.Errorf("%w: result initialization AUTO: normalized raw source identity changed", ErrProbeNeedsContext)
+	}
+	return nil
+}
diff --git a/x86_raw_return_alias_audit_test.go b/x86_raw_return_alias_audit_test.go
new file mode 100644
index 000000000..c3f955166
--- /dev/null
+++ b/x86_raw_return_alias_audit_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86RawReturnStackAddressAndRegisterViewsNeedContext(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		instructions := []string{
+			move + " $0(SP),AX", move + " $8(BP),AX",
+			move + " $0(SP)(CX*1),AX", move + " $8(AX)(BP*1),AX",
+		}
+		if arch == "amd64" {
+			instructions = append(instructions, "MOVB $0,BPB", "MOVB BPB,AL")
+		}
+		for _, instruction := range instructions {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT probe(SB),4,$0-0\n" + instruction + "\nBYTE $0xc3\nRET\n"
+				requireX86GoAssemblerResult(t, arch, source, true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				opt := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"probe": {Name: "probe", Ret: Void}}}
+				for _, api := range []string{"text", "module", "owned-module", "annotated"} {
+					var callErr error
+					switch api {
+					case "text":
+						_, callErr = Translate(file, opt)
+					case "module":
+						module, err := TranslateModule(file, opt)
+						if err == nil {
+							module.Dispose()
+						}
+						callErr = err
+					default:
+						ctx := llvm.NewContext()
+						options := opt
+						options.AnnotateSource = api == "annotated"
+						module, err := TranslateModuleInContext(ctx, file, options)
+						if err == nil {
+							module.Dispose()
+						}
+						ctx.Dispose()
+						callErr = err
+					}
+					if !errors.Is(callErr, ErrProbeNeedsContext) {
+						t.Errorf("%s actual Go-accepted source stack/view observation bypassed raw-return contract: %v", api, callErr)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawReturnNonStackAddressLeafRemainsSupported(t *testing.T) {
+	source := "TEXT probe(SB),4,$0-0\nMOVQ $8(AX)(CX*1),BX\nBYTE $0xc3\nRET\n"
+	requireX86GoAssemblerResult(t, "amd64", source, true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc not found")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: triple, Sigs: map[string]FuncSig{"probe": {Name: "probe", Ret: Void}}})
+		if err != nil {
+			t.Fatal("unrelated register-relative address became a failure:", err)
+		}
+		compileLLVMToObject(t, llc, triple, "non-stack.ll", "non-stack.o", ir)
+	}
+}
diff --git a/x86_raw_return_mask_input.go b/x86_raw_return_mask_input.go
new file mode 100644
index 000000000..c2a367162
--- /dev/null
+++ b/x86_raw_return_mask_input.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import "math"
+
+// KMOV's logical FP reader gathers exactly its B/W/D/Q bytes, including
+// interior and cross-field numeric parameter views. Their separately allocated
+// storage cannot overlap the native return PC. This is only that memory-safety
+// role: mask definedness, result reads and source initialization still belong
+// to the complete numerical consumer. Stores and native pointers gain nothing.
+func x86RawReturnMaskParameterReadBound(ins Instr, operand int, sig FuncSig, arch string) bool {
+	if arch != "amd64" && arch != "386" || operand != 0 ||
+		!x86ResultNamedPredicateInstruction(ins) || !amd64MaskMoveOperandsValid(ins, arch) ||
+		ins.Args[0].Kind != OpFP || !amd64IsKOperand(ins.Args[1]) ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.WASMContext != "" || len(sig.Frame.Params) == 0 {
+		return false
+	}
+	width := int64(amd64MaskMoveSpecs[ins.Op] / 8)
+	offset := ins.Args[0].FPOffset
+	if offset < 0 || width <= 0 || offset > math.MaxInt64-width {
+		return false
+	}
+	// Reuse the existing full signature/field/extent/overlap validation once.
+	// A touched prefix alone must not conceal a malformed unrelated slot.
+	first := sig.Frame.Params[0]
+	if !x86RawReturnFPBound(first.Offset, x86RawReturnSlotBytes(first.Type, arch), sig, arch) {
+		return false
+	}
+	for current := offset; current < offset+width; current++ {
+		matches := 0
+		for _, slot := range sig.Frame.Params {
+			if current < slot.Offset || current >= slot.Offset+x86RawReturnSlotBytes(slot.Type, arch) {
+				continue
+			}
+			switch slot.Type {
+			case I8, I16, I32, I64, LLVMType("float"), LLVMType("double"):
+				matches++
+			default:
+				return false // Pointer/bool bytes are not this numerical input role.
+			}
+		}
+		if matches != 1 {
+			return false // Neither padding, a result nor an absent parameter is backing.
+		}
+	}
+	return true
+}
diff --git a/x86_raw_return_mask_input_test.go b/x86_raw_return_mask_input_test.go
new file mode 100644
index 000000000..da7dd6219
--- /dev/null
+++ b/x86_raw_return_mask_input_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+// This observer checks only the existing return-PC memory-disjointness role.
+// It supplies neither mask initialization nor permission to access a native
+// pointer. The initialized literal programs exercise the independent consumer.
+func x86RawReturnMaskInputFixture(t *testing.T, arch, instruction string, sig FuncSig) (*File, Options) {
+	t.Helper()
+	source := "TEXT Bound(SB),4,$0-32\n" + instruction + "\nBYTE $0xc3\n"
+	file, err := Parse(ArchAMD64, source)
+	if err == nil {
+		// Exercise the exact memory consumer, not an earlier normalization
+		// rejection for the deliberately unbound native-pointer controls.
+		file.Funcs[0], err = decodeX86RawDirectives(file.Funcs[0], arch)
+	}
+	if err != nil {
+		t.Fatal("original mask input and canonical raw RET lost their source", err)
+	}
+	sig.Name = "Bound"
+	return file, Options{Goarch: arch, Sigs: map[string]FuncSig{"Bound": sig}}
+}
+
+func x86RawReturnMaskNumericParameters() FuncSig {
+	return FuncSig{Args: []LLVMType{I64, I64}, Ret: Void, Frame: FrameLayout{Params: []FrameSlot{
+		{Offset: 0, Type: I64, Index: 0, Field: -1},
+		{Offset: 8, Type: I64, Index: 1, Field: -1},
+	}}}
+}
+
+func TestX86RawReturnMaskParameterReadsUseExactCompleteNumericBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86MaskMoveFPOracle[:4] {
+			for offset := 0; offset <= 16-row.bits/8; offset++ {
+				t.Run(fmt.Sprintf("%s/%s/+%d", target.triple, row.op, offset), func(t *testing.T) {
+					instruction := fmt.Sprintf("%s mask+%d(FP),K1", row.op, offset)
+					file, options := x86RawReturnMaskInputFixture(t, target.arch, instruction, x86RawReturnMaskNumericParameters())
+					if !x86RawReturnMemoryBound(file.Funcs[0], file, options, true) {
+						t.Fatal("an exact existing typed numeric parameter read lost the bounded raw-return role")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawReturnMaskParameterReadsRequireEveryOriginalByte(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86MaskMoveFPOracle[:4] {
+			for missing := -1; missing < row.bits/8; missing++ {
+				t.Run(fmt.Sprintf("%s/%s/missing%d", target.triple, row.op, missing), func(t *testing.T) {
+					sig := FuncSig{Ret: Void}
+					for offset := 0; offset < row.bits/8; offset++ {
+						sig.Args = append(sig.Args, I8)
+						if offset != missing {
+							sig.Frame.Params = append(sig.Frame.Params, FrameSlot{Offset: int64(offset), Type: I8, Index: offset, Field: -1})
+						}
+					}
+					file, options := x86RawReturnMaskInputFixture(t, target.arch, row.op+" mask+0(FP),K1", sig)
+					if got := x86RawReturnMemoryBound(file.Funcs[0], file, options, true); got != (missing == -1) {
+						t.Fatal("padding or a missing parameter byte acquired return-PC separation", got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawReturnMaskParameterReadsDoNotGrantOtherStorageRoles(t *testing.T) {
+	controls := []string{
+		"pointer", "bool", "missing signature", "wrong signature", "unbound index", "overlap", "negative slot", "overflow slot",
+		"before frame", "past frame", "numeric result", "mask store", "wrong destination", "native pointer", "raw origin",
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86MaskMoveFPOracle[:4] {
+			for _, control := range controls {
+				t.Run(target.triple+"/"+row.op+"/"+control, func(t *testing.T) {
+					sig := x86RawReturnMaskNumericParameters()
+					instruction := row.op + " mask+0(FP),K1"
+					switch control {
+					case "pointer", "bool":
+						typ := Ptr
+						if control == "bool" {
+							typ = I1
+						}
+						sig.Args[0], sig.Frame.Params[0].Type = typ, typ
+					case "missing signature":
+						sig.Args = nil
+					case "wrong signature":
+						sig.Args[0] = I32
+					case "unbound index":
+						sig.Frame.Params[0].Index = 2
+					case "overlap":
+						sig.Frame.Params[1].Offset = 4
+					case "negative slot":
+						sig.Frame.Params[1].Offset = -1
+					case "overflow slot":
+						sig.Frame.Params[1].Offset = math.MaxInt64 - 1
+					case "past frame":
+						instruction = row.op + " mask+16(FP),K1"
+					case "numeric result":
+						sig = FuncSig{Ret: I64, Frame: FrameLayout{Results: []FrameSlot{{Type: I64, Index: 0, Field: -1}}}}
+					case "mask store":
+						instruction = row.op + " K1,mask+0(FP)"
+					case "wrong destination":
+						instruction = row.op + " mask+0(FP),AX"
+					case "native pointer":
+						instruction = row.op + " (AX),K1"
+					}
+					file, options := x86RawReturnMaskInputFixture(t, target.arch, instruction, sig)
+					if control == "before frame" {
+						file.Funcs[0].Instrs[1].Args[0].FPOffset = -1
+					}
+					if control == "raw origin" {
+						file.Funcs[0].Instrs[1].x86Encoded = true
+					}
+					if x86RawReturnMemoryBound(file.Funcs[0], file, options, true) {
+						t.Fatal("a bounded mask parameter read granted another storage or source role")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_round_literal_inputs_test.go b/x86_raw_round_literal_inputs_test.go
new file mode 100644
index 000000000..e1f0e1704
--- /dev/null
+++ b/x86_raw_round_literal_inputs_test.go
@@ -0,0 +1,178 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Keep the original complete module's four BYTE streams, raw RETs and literal
+// tails. Its scalar upper-copy inputs are unbound; that must not hide packed
+// source-local literal regressions, which are tested independently below.
+func x86RawRoundOriginalModuleObjects(t *testing.T, file *File, source, triple string, signatures map[string]FuncSig) string {
+	t.Helper()
+	if len(file.Funcs) != 4 || len(signatures) != 4 {
+		t.Fatal("original raw ROUND module changed")
+	}
+	var declarations strings.Builder
+	for _, function := range file.Funcs {
+		if signature, found := signatures[function.Sym]; !found || signature.Ret != Void {
+			t.Fatal("original raw ROUND signature changed", function.Sym)
+		}
+		fmt.Fprintf(&declarations, "func %s()\n", function.Sym)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("whole raw ROUND module borrowed its bare scalar upper input", api, err)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for index, function := range file.Funcs {
+		var one strings.Builder
+		for _, instruction := range function.Instrs {
+			one.WriteString(instruction.Raw + "\n")
+		}
+		name := function.Sym
+		x86LEAActualTargetGoObject(t, "amd64", triple, one.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("original-%d/%s", index, api), func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, one.String(), "func "+name+"()", "amd64", triple, api)
+				if index >= 2 {
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("bare raw scalar ROUND invented its upper-copy bytes", err)
+					}
+					return
+				}
+				if err != nil {
+					t.Fatal("self-contained packed RIP literal must retain public translation", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		}
+	}
+	return x86UnboundVoidRawScalarFormatObject(t, source, "amd64", triple)
+}
+
+func TestX86RoundInitializedRawLiteralAndNamedCounterparts(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		for _, kind := range []string{"raw-initialized", "named-initialized"} {
+			t.Run(triple+"/"+kind, func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index, op := range []string{"VROUNDPS", "VROUNDPD", "VROUNDSS", "VROUNDSD"} {
+					name := fmt.Sprint("InitializedRawRound", index)
+					if kind == "raw-initialized" {
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\nVPXOR Y0,Y0,Y0\n", name)
+						for _, value := range x86RawVEXRoundConstant(byte(0x08+index), index < 2) {
+							fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+						}
+						fmt.Fprintf(&declarations, "func %s()\n", name)
+					} else {
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),DX\nMOVQ a+8(FP),AX\n", name)
+						if index < 2 {
+							fmt.Fprintf(&source, "%s $9,(AX),Y2\n", op)
+						} else {
+							source.WriteString("MOVQ upper+16(FP),BX\nVMOVUPS (BX),X0\n")
+							fmt.Fprintf(&source, "%s $9,(AX),X0,X2\n", op)
+						}
+						source.WriteString("VMOVUPS Z2,(DX)\nRET\n")
+						fmt.Fprintf(&declarations, "func %s(out *[64]byte,a *[32]byte,upper *[16]byte)\n", name)
+					}
+				}
+				x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+						if err != nil {
+							t.Fatal("complete initialized ROUND literal/named counterpart rejected", kind, err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, ir, level)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86RawRoundLiteralRetainsSourceDataAndReturnBoundaries(t *testing.T) {
+	for index, op := range []string{"VROUNDPS", "VROUNDPD", "VROUNDSS", "VROUNDSD"} {
+		t.Run(op, func(t *testing.T) {
+			var source strings.Builder
+			source.WriteString("TEXT RawRoundBound(SB),4,$0-0\nVPXOR Y0,Y0,Y0\n")
+			for _, value := range x86RawVEXRoundConstant(byte(0x08+index), index < 2) {
+				fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+			}
+			for _, change := range []string{"DATA", "immediate", "raw-origin", "read-width", "frame", "unbound-upper"} {
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized, err := normalizeX86RawFile(file, "amd64")
+				if err != nil || len(normalized.Data) != 1 {
+					t.Fatal("original literal lost its bound source DATA", err)
+				}
+				var raw *Instr
+				for ordinal := range normalized.Funcs[0].Instrs {
+					if normalized.Funcs[0].Instrs[ordinal].Op == Op(op) {
+						raw = &normalized.Funcs[0].Instrs[ordinal]
+					}
+				}
+				if raw == nil {
+					t.Fatal("original raw ROUND disappeared")
+				}
+				switch change {
+				case "DATA":
+					normalized.Data[0].Payload[0] ^= 1
+				case "immediate":
+					raw.Args[0].Imm ^= 1
+				case "raw-origin":
+					raw.x86SourceRaw = nil
+				case "read-width":
+					raw.x86RIPMemoryRead.width++
+				case "frame":
+					normalized.Funcs[0].FrameSize = 16
+				case "unbound-upper":
+					if index < 2 {
+						return
+					} // These packed forms have no upper input.
+					// A changed scalar upper source must not inherit the original
+					// decoded identity, even when its memory literal is unchanged.
+					raw.Args[2].Reg = "X1"
+				}
+				for _, api := range []string{"text", "module"} {
+					options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"RawRoundBound": {Name: "RawRoundBound", Ret: Void}}}
+					var ir string
+					var err error
+					if api == "text" {
+						ir, err = Translate(normalized, options)
+					} else {
+						context := llvm.NewContext()
+						module, moduleErr := TranslateModuleInContext(context, normalized, options)
+						err = moduleErr
+						if !module.IsNil() {
+							ir = module.String()
+							module.Dispose()
+						}
+						context.Dispose()
+					}
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("edited literal/source/return borrowed raw ROUND authority", change, api, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_scalar_count_portable_test.go b/x86_raw_scalar_count_portable_test.go
new file mode 100644
index 000000000..68d5ec11f
--- /dev/null
+++ b/x86_raw_scalar_count_portable_test.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+// Execute the exact original raw-count source on the actual host. Numerical
+// values, partial-register preservation, CF/ZF and memory canaries are distinct
+// from required native x86 original-opcode and ISA-feature execution.
+func TestX86RawScalarCountOriginalPortableExecution(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	const main = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void rawbitcountsemantics(uint8_t*);
+int main(void) {
+    uint8_t storage[74];
+    memset(storage,0xc3,sizeof(storage));
+    uint8_t *out=storage+1;
+    rawbitcountsemantics(out);
+    const struct { unsigned offset; uint64_t want; } values[]={
+        {0,UINT64_C(0x12340010)},{16,0},{32,64},{48,0x100},{56,55}
+    };
+    for (unsigned row=0;row<sizeof(values)/sizeof(values[0]);row++) {
+        uint64_t got;
+        memcpy(&got,out+values[row].offset,8);
+        if (got!=values[row].want) {
+            fprintf(stderr,"raw count offset=%u got=%llx want=%llx\n",values[row].offset,
+                    (unsigned long long)got,(unsigned long long)values[row].want);
+            return 1;
+        }
+    }
+    const unsigned flags[]={8,9,24,25,40,41,64,65};
+    const uint8_t wantFlags[]={1,0,0,1,1,0,0,0};
+    for (unsigned row=0;row<sizeof(flags)/sizeof(flags[0]);row++) {
+        if (out[flags[row]]!=wantFlags[row]) {
+            fprintf(stderr,"raw count flags offset=%u\n",flags[row]);
+            return 1;
+        }
+    }
+    for (unsigned byte=0;byte<72;byte++) {
+        int written=byte<10 || (byte>=16 && byte<26) || (byte>=32 && byte<42) ||
+                    (byte>=48 && byte<66);
+        if (!written && out[byte]!=0xc3) return 1;
+    }
+    if (storage[0]!=0xc3 || storage[73]!=0xc3) return 1;
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, x86RawCountOriginalRuntimeSource,
+				"func rawbitcountsemantics(out *[72]byte)", "amd64", triple, api)
+			if err != nil {
+				t.Fatal("original raw count source lost its native output continuation", err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("raw-count-%s-ir%d-%s", api, index, level[1:]), triple, text, main, nil)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_scalar_original_fixture_test.go b/x86_raw_scalar_original_fixture_test.go
new file mode 100644
index 000000000..5ccc84e80
--- /dev/null
+++ b/x86_raw_scalar_original_fixture_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import "testing"
+
+const x86RawCountOriginalRuntimeSource = `
+TEXT rawbitcountsemantics(SB),NOSPLIT,$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0x12340000, AX
+	BYTE $0x66; BYTE $0xf3; BYTE $0x0f; BYTE $0xbc; BYTE $0xc0 // TZCNTW AX, AX
+	MOVQ AX, 0(DI)
+	SETCS 8(DI)
+	SETEQ 9(DI)
+	MOVQ $0x1122334480000000, AX
+	BYTE $0xf3; BYTE $0x0f; BYTE $0xbd; BYTE $0xc0 // LZCNTL AX, AX
+	MOVQ AX, 16(DI)
+	SETCS 24(DI)
+	SETEQ 25(DI)
+	MOVQ $0, AX
+	BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xbc; BYTE $0xc0 // TZCNTQ AX, AX
+	MOVQ AX, 32(DI)
+	SETCS 40(DI)
+	SETEQ 41(DI)
+	MOVQ $0x100, 48(DI)
+	BYTE $0xf3; BYTE $0x48; BYTE $0x0f; BYTE $0xbd; BYTE $0x4f; BYTE $0x30 // LZCNTQ 48(DI), CX
+	MOVQ CX, 56(DI)
+	SETCS 64(DI)
+	SETEQ 65(DI)
+	RET
+`
+
+const x86RawMoveMaskOriginalRuntimeSource = `TEXT rawmovemasksemantics(SB),4,$0-16
+	MOVQ input+0(FP), DI
+	MOVQ out+8(FP), SI
+	VMOVDQU (DI), Y1
+	BYTE $0xc5; BYTE $0xfd; BYTE $0xd7; BYTE $0xc1
+	MOVL AX, 0(SI)
+	BYTE $0xc5; BYTE $0xf8; BYTE $0x50; BYTE $0xc1
+	MOVL AX, 4(SI)
+	BYTE $0xc5; BYTE $0xfd; BYTE $0x50; BYTE $0xc1
+	MOVL AX, 8(SI)
+	RET
+`
+
+func TestX86RawScalarOriginalVoidNativeObjects(t *testing.T) {
+	for _, fixture := range []struct{ name, source, declaration string }{
+		{"count", x86RawCountOriginalRuntimeSource, "func rawbitcountsemantics(out *[72]byte)"},
+		{"move-mask", x86RawMoveMaskOriginalRuntimeSource, "func rawmovemasksemantics(input *[32]byte,out *[12]byte)"},
+	} {
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(fixture.name+"/"+triple, func(t *testing.T) {
+				x86RawNumericalFamilyObjects(t, fixture.source, fixture.declaration, "amd64", triple)
+			})
+		}
+	}
+}
diff --git a/x86_raw_source_operand_test.go b/x86_raw_source_operand_test.go
new file mode 100644
index 000000000..c7d5f1a32
--- /dev/null
+++ b/x86_raw_source_operand_test.go
@@ -0,0 +1,86 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// The absent SIB index leaves its encoded scale inactive. x86asm retains
+// 1/2/4/8 even then, whereas Go source has no multiplier and the parser keeps
+// zero. Compare only this source/physical representation difference on copies;
+// every active index and all other operand fields remain exact. Independent
+// original-byte tests must still check the decoder's physical scale itself.
+// This is a test oracle, never a source normalization or memory certificate.
+func x86RawOperandsMatchGoSource(decoded, source []Operand) bool {
+	if len(decoded) != len(source) {
+		return false
+	}
+	copyDecoded := append([]Operand(nil), decoded...)
+	for i := range copyDecoded {
+		actual, expected := &copyDecoded[i], source[i]
+		if actual.Kind != OpMem || expected.Kind != OpMem || actual.Mem.Index != "" ||
+			expected.Mem.Index != "" || expected.Mem.Scale != 0 {
+			continue
+		}
+		switch actual.Mem.Scale {
+		case 0, 1, 2, 4, 8:
+			actual.Mem.Scale = 0
+		default:
+			return false
+		}
+	}
+	return reflect.DeepEqual(copyDecoded, source)
+}
+
+func TestX86RawSourceOperandComparison(t *testing.T) {
+	source := []Operand{{Kind: OpMem, Mem: MemRef{Base: SP, Off: 8192}}, {Kind: OpReg, Reg: "X0"}}
+	before := fmt.Sprintf("%#v", source)
+	for _, scale := range []int64{0, 1, 2, 4, 8} {
+		decoded := append([]Operand(nil), source...)
+		decoded[0].Mem.Scale = scale
+		physical := fmt.Sprintf("%#v", decoded)
+		if !x86RawOperandsMatchGoSource(decoded, source) || physical != fmt.Sprintf("%#v", decoded) {
+			t.Errorf("inactive scale %d comparison failed or changed physical fields: decoded=%#v source=%#v", scale, decoded, source)
+		}
+	}
+	mutations := []struct {
+		name string
+		edit func(*Operand)
+	}{
+		{"invalid scale", func(a *Operand) { a.Mem.Scale = 3 }},
+		{"base", func(a *Operand) { a.Mem.Base = BP }},
+		{"index", func(a *Operand) { a.Mem.Index = CX }},
+		{"offset", func(a *Operand) { a.Mem.Off++ }},
+		{"segment", func(a *Operand) { a.Mem.Segment = FS }},
+		{"symbol", func(a *Operand) { a.Mem.Sym = "slot" }},
+		{"unresolved offset", func(a *Operand) { a.Mem.OffRaw = "unknown" }},
+		{"index extension", func(a *Operand) { a.Mem.IndexExt = ExtendUXTW }},
+		{"operand role", func(a *Operand) { a.Kind = OpFP }},
+		{"unrelated field", func(a *Operand) { a.Imm = 1 }},
+	}
+	for _, mutation := range mutations {
+		t.Run(mutation.name, func(t *testing.T) {
+			decoded := append([]Operand(nil), source...)
+			mutation.edit(&decoded[0])
+			if x86RawOperandsMatchGoSource(decoded, source) {
+				t.Fatalf("ignored a real operand difference: %#v", decoded)
+			}
+		})
+	}
+	indexed := append([]Operand(nil), source...)
+	indexed[0].Mem.Index, indexed[0].Mem.Scale = CX, 4
+	for _, scale := range []int64{0, 1, 2, 3, 8} {
+		decoded := append([]Operand(nil), indexed...)
+		decoded[0].Mem.Scale = scale
+		if x86RawOperandsMatchGoSource(decoded, indexed) {
+			t.Fatalf("ignored active index scale %d", scale)
+		}
+	}
+	if !x86RawOperandsMatchGoSource(indexed, indexed) || before != fmt.Sprintf("%#v", source) {
+		t.Fatal("comparison lost exact indexed equality or mutated its source")
+	}
+	if x86RawOperandsMatchGoSource(source[:1], source) || x86RawOperandsMatchGoSource(source, source[:1]) {
+		t.Fatal("comparison ignored a missing/extra operand")
+	}
+}
diff --git a/x86_raw_static_register_result_test.go b/x86_raw_static_register_result_test.go
new file mode 100644
index 000000000..f0b1f0fdb
--- /dev/null
+++ b/x86_raw_static_register_result_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86DirectStaticRegisterResultRejectsForeignSignatureRoles(t *testing.T) {
+	file := mustParseX86RawReturn(t, "TEXT Raw(SB),4,$0-0\nMOVQ saved(SB),AX\nRET\n")
+	for _, typ := range []LLVMType{Void, I1, Ptr, "float", "double", "i128", "{i32,i32}"} {
+		t.Run(string(typ), func(t *testing.T) {
+			if x86DirectStaticRegisterResultCandidate(file.Funcs[0], FuncSig{Name: "Raw", Ret: typ}, "amd64") {
+				t.Fatal("a foreign scalar role borrowed the integer AX result observer")
+			}
+		})
+	}
+}
+
+func TestX86RawStaticRegisterReturnCompleteMoveWidths(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			op, register string
+			typ          LLVMType
+		}{{"MOVB", "AL", I8}, {"MOVW", "AX", I16}, {"MOVL", "AX", I32}, {"MOVQ", "AX", I64}} {
+			if row.typ == I64 && target.arch == "386" {
+				continue // This direct scalar role has no physical mode32 qword GP transport.
+			}
+			for _, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+				t.Run(target.triple+"/"+row.op+"/"+encoding, func(t *testing.T) {
+					source := fmt.Sprintf("GLOBL saved<>(SB),8,$32\nTEXT Raw(SB),4,$0-0\n%s $17,%s\n%s %s,saved<>+4(SB)\n%s saved<>+4(SB),%s\n%s\nRET\n",
+						row.op, row.register, row.op, row.register, row.op, row.register, encoding)
+					requireX86GoAssemblerResult(t, target.arch, source, true)
+					options := Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Ret: row.typ}}}
+					x86RawReturnPointerAPIs(t, source, options, false)
+					if err := CheckX86ABI0ResultInitialization(mustParseX86RawReturn(t, source).Funcs[0], options.Sigs["Raw"], target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("the standalone ABI0 query borrowed direct-register lowering", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// Execute the portable integer/static LLVM lowering on the actual host.
+// This is not an original-Go ABI or physical raw-RET execution certificate.
+func TestX86DirectStaticRegisterResultHostRuntime(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	var source, reference strings.Builder
+	options := Options{Goarch: "amd64", TargetTriple: testTargetTriple(runtime.GOOS, runtime.GOARCH), Sigs: make(map[string]FuncSig)}
+	reference.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	var checks strings.Builder
+	for _, row := range []struct {
+		op, register, cType string
+		typ                 LLVMType
+	}{{"MOVB", "AL", "uint8_t", I8}, {"MOVW", "AX", "uint16_t", I16}, {"MOVL", "AX", "uint32_t", I32}, {"MOVQ", "AX", "uint64_t", I64}} {
+		for index, encoding := range []string{"BYTE $0xc3", "BYTE $0xc2\nWORD $0"} {
+			name := fmt.Sprintf("Result%s%d", row.op, index)
+			// The original compile-only counterexamples use RODATA (8).
+			// This explicit executable counterpart needs writable NOPTR (16).
+			fmt.Fprintf(&source, "GLOBL %sData<>(SB),16,$32\nTEXT %s(SB),4,$0-0\n%s $17,%s\n%s %s,%sData<>+4(SB)\n%s %sData<>+4(SB),%s\n%s\nRET\n",
+				name, name, row.op, row.register, row.op, row.register, name, row.op, name, row.register, encoding)
+			options.Sigs[name] = FuncSig{Name: name, Ret: row.typ}
+			fmt.Fprintf(&reference, "extern %s %s(void);\n", row.cType, name)
+			fmt.Fprintf(&checks, "if(%s()!=17){fprintf(stderr,\"%s incorrect\\n\");return 1;}\n", name, name)
+		}
+	}
+	reference.WriteString("int main(void){\n" + checks.String() + "return 0;\n}\n")
+	file := mustParseX86RawReturn(t, source.String())
+	for _, api := range []string{"text", "module", "owned-module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86X87UnboundOriginalAPI(t, file, options, api)
+			if err != nil || ir == "" {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				objectIR := ir
+				if optimized {
+					objectIR = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "direct-static", options.TargetTriple, objectIR, reference.String(), nil, level)
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawStaticRegisterReturnDoesNotInventSourceBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			op, register string
+			typ          LLVMType
+		}{{"MOVB", "AL", I8}, {"MOVW", "AX", I16}, {"MOVL", "AX", I32}, {"MOVQ", "AX", I64}} {
+			if row.typ == I64 && target.arch == "386" {
+				continue
+			}
+			body := fmt.Sprintf("%s $17,%s\n%s %s,saved<>+4(SB)\n%s saved<>+4(SB),%s\n",
+				row.op, row.register, row.op, row.register, row.op, row.register)
+			for _, mutation := range []struct{ name, body string }{
+				{"unknown-store-input", strings.Replace(body, row.op+" $17,"+row.register, "NOP", 1)},
+				{"unbound-static-read", strings.Replace(body, "saved<>+4(SB),"+row.register, "external+4(SB),"+row.register, 1)},
+				{"outside-static-extent", strings.Replace(body, "saved<>+4(SB),"+row.register, "saved<>+32(SB),"+row.register, 1)},
+				{"unknown-final-result", body + "MOVL DX,AX\n"},
+			} {
+				t.Run(target.triple+"/"+row.op+"/"+mutation.name, func(t *testing.T) {
+					source := "GLOBL saved<>(SB),8,$32\nTEXT Raw(SB),4,$0-0\n" + mutation.body + "BYTE $0xc3\nRET\n"
+					requireX86GoAssemblerResult(t, target.arch, source, true)
+					options := Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"Raw": {Name: "Raw", Ret: row.typ}}}
+					x86RawReturnPointerAPIs(t, source, options, true)
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_static_replay_test.go b/x86_raw_static_replay_test.go
new file mode 100644
index 000000000..7f982bb3e
--- /dev/null
+++ b/x86_raw_static_replay_test.go
@@ -0,0 +1,198 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86RawStaticReplayScalar(width int, addressTaken bool) []byte {
+	read := []byte{0x8b, 0x05, 1, 0, 0, 0}
+	if width == 8 {
+		read = append([]byte{0x48}, read...)
+	}
+	var code []byte
+	if addressTaken {
+		// LEAQ pool,BX, retaining the same pool as the following scalar read.
+		code = append(code, 0x48, 0x8d, 0x1d, byte(len(read)+1), 0, 0, 0)
+	}
+	code = append(code, read...)
+	code = append(code, 0xc3)
+	for index := 0; index < width; index++ {
+		code = append(code, byte(index*17+1))
+	}
+	return code
+}
+
+func TestX86RawStaticReplayCapturesDecoderBeforeSymbolRebinding(t *testing.T) {
+	cases := []struct {
+		name string
+		code []byte
+	}{
+		{"scalar32", x86RawStaticReplayScalar(4, false)},
+		{"scalar64", x86RawStaticReplayScalar(8, false)},
+		{"address32", x86RawStaticReplayScalar(4, true)},
+		{"address64", x86RawStaticReplayScalar(8, true)},
+		{"legacy-vector", x86RawLegacyPackedMoveConstant(0xf3, 0x6f)},
+		{"vex-vector", x86RawPackedMoveLiteral(false, 32)},
+		{"evex-vector", x86RawPackedMoveLiteral(true, 64)},
+		{"nonfirst-source", x86RawCLMULLiteral("legacy", 16)},
+	}
+	for _, row := range cases {
+		t.Run(row.name, func(t *testing.T) {
+			original := mustParseX86RawReturn(t, x86StaticReturnSource("Bound", row.code))
+			decoded, err := decodeX86RawDirectives(original.Funcs[0], "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			prepared, err := NormalizeRawFileForTranslation(original, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := prepared.Funcs[0]
+			replay := fn.x86RawReplay
+			if replay == nil || len(prepared.Data) != 1 {
+				t.Fatal("complete raw source or its one materialized pool was lost")
+			}
+			if !reflect.DeepEqual(replay.decoded, decoded.Instrs) {
+				t.Error("decoder checkpoint already contains file-local symbol rebinding")
+			}
+			if !reflect.DeepEqual(replay.normalized, fn.Instrs) {
+				t.Error("final checkpoint lost the complete materialized source")
+			}
+			if err := replay.validate(fn, "amd64"); err != nil {
+				t.Error("authentic decoder and final source do not replay", err)
+			}
+			for name, mutate := range map[string]func(*Func){
+				"symbol": func(fn *Func) { fn.Sym += "Changed" },
+				"frame":  func(fn *Func) { fn.FrameSize = 8 },
+				"args":   func(fn *Func) { fn.ArgSize = 8 },
+				"opcode": func(fn *Func) { fn.Instrs[1].Op = "NOP" },
+				"raw":    func(fn *Func) { fn.Instrs[1].Raw += " changed" },
+				"operand": func(fn *Func) {
+					fn.Instrs[1].Args[0] = Operand{Kind: OpReg, Reg: AX}
+				},
+			} {
+				changed := fn
+				changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+				mutate(&changed)
+				if !errors.Is(replay.validate(changed, "amd64"), ErrProbeNeedsContext) {
+					t.Error("rebound decoder snapshot authorized a changed source", name)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RawStaticReplayScalarResultsThreeAPIs(t *testing.T) {
+	for _, width := range []int{4, 8} {
+		for _, addressTaken := range []bool{false, true} {
+			source := x86StaticReturnSource("Bound", x86RawStaticReplayScalar(width, addressTaken))
+			requireX86GoAssemblerResult(t, "amd64", source, true)
+			for _, target := range x86RawReturnTargets {
+				if target.arch != "amd64" {
+					continue // These physical encodings use 64-bit RIP addressing.
+				}
+				t.Run(fmt.Sprintf("%s/width%d/address%t", target.triple, width, addressTaken), func(t *testing.T) {
+					typ := I32
+					if width == 8 {
+						typ = I64
+					}
+					options := Options{Goarch: "amd64", TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"Bound": {Name: "Bound", Ret: typ}}}
+					for _, prepared := range []bool{false, true} {
+						file := mustParseX86RawReturn(t, source)
+						if prepared {
+							var err error
+							file, err = NormalizeRawFileForTranslation(file, "amd64")
+							if err != nil {
+								t.Fatal(err)
+							}
+						}
+						for _, api := range []string{"text", "module", "owned-module"} {
+							ir, err := x86X87UnboundOriginalAPI(t, file, options, api)
+							if err != nil || ir == "" {
+								t.Error("complete raw scalar result was rejected", prepared, api, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+// Execute the lowered scalar/data semantics on the actual host. The unchanged
+// native cross-runtime owner separately executes the original Go instructions.
+func TestX86RawStaticReplayPortableValuesAndMutablePool(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	var source, declarations, checks strings.Builder
+	declarations.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	options := Options{Goarch: "amd64", TargetTriple: testTargetTriple(runtime.GOOS, runtime.GOARCH),
+		Sigs: make(map[string]FuncSig), ResolveSym: func(symbol string) string {
+			if strings.HasPrefix(symbol, "·__plan9asm_raw_address_") {
+				return "MutablePool"
+			}
+			return symbol
+		}}
+	values := []uint64{0, 1, 0x80000001, 0xffffffff, 0x89abcdef01234567, 0xfedcba9876543210}
+	for _, width := range []int{4, 8} {
+		for index, value := range values {
+			name := fmt.Sprintf("Scalar%d_%d", width, index)
+			code := x86RawStaticReplayScalar(width, false)
+			typ, cType := I32, "uint32_t"
+			if width == 4 {
+				value = uint64(uint32(value))
+				binary.LittleEndian.PutUint32(code[len(code)-width:], uint32(value))
+			} else {
+				typ, cType = I64, "uint64_t"
+				binary.LittleEndian.PutUint64(code[len(code)-width:], value)
+			}
+			source.WriteString(x86StaticReturnSource(name, code))
+			options.Sigs[name] = FuncSig{Name: name, Ret: typ}
+			fmt.Fprintf(&declarations, "extern %s %s(void);\n", cType, name)
+			fmt.Fprintf(&checks, "if(%s()!=0x%xULL){fprintf(stderr,\"%s wrong\\n\");return 1;}\n",
+				name, value, name)
+		}
+	}
+	mutable := x86RawStaticReplayScalar(8, true)
+	binary.LittleEndian.PutUint64(mutable[len(mutable)-8:], 0x89abcdef01234567)
+	source.WriteString(x86StaticReturnSource("Mutable", mutable))
+	options.Sigs["Mutable"] = FuncSig{Name: "Mutable", Ret: I64}
+	declarations.WriteString("extern uint64_t Mutable(void);\nextern uint64_t MutablePool[];\n")
+	checks.WriteString("if(Mutable()!=0x89abcdef01234567ULL){fprintf(stderr,\"initial pool wrong\\n\");return 1;}\n")
+	checks.WriteString("MutablePool[0]=0xfedcba9876543210ULL;\n")
+	checks.WriteString("if(Mutable()!=0xfedcba9876543210ULL){fprintf(stderr,\"changed pool folded\\n\");return 1;}\n")
+	if len(options.Sigs) != 13 {
+		t.Fatal("complete scalar value and mutable-pool denominator changed")
+	}
+	reference := declarations.String() + "int main(void){\n" + checks.String() + "return 0;}\n"
+	file := mustParseX86RawReturn(t, source.String())
+	for _, api := range []string{"text", "module", "owned-module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86X87UnboundOriginalAPI(t, file, options, api)
+			if err != nil || ir == "" {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang},
+							"raw-static-replay", options.TargetTriple, input, reference, nil, level)
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_raw_vector_literal_test.go b/x86_raw_vector_literal_test.go
new file mode 100644
index 000000000..9742329e8
--- /dev/null
+++ b/x86_raw_vector_literal_test.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86RawVectorLiteralCase struct {
+	name string
+	code []byte
+	mask int
+}
+
+func x86RawVectorLiteralSource(row x86RawVectorLiteralCase) string {
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", row.name)
+	source.WriteString("MOVL $5,AX\nKMOVD AX,K3\nKMOVD AX,K7\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n")
+	for _, value := range row.code {
+		fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+	}
+	return source.String()
+}
+
+func x86RawVectorLiteralObjects(t *testing.T, triple string, rows []x86RawVectorLiteralCase) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for start := 0; start < len(rows); start += 64 {
+		end := start + 64
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("batch-%d", start/64), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for _, row := range rows[start:end] {
+				source.WriteString(x86RawVectorLiteralSource(row))
+				fmt.Fprintf(&declarations, "func %s()\n", row.name)
+			}
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("exact vector literal/mask/source bytes lost", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_raw_vector_move_format_test.go b/x86_raw_vector_move_format_test.go
new file mode 100644
index 000000000..f7d1b04af
--- /dev/null
+++ b/x86_raw_vector_move_format_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Preserve complete original Go objects and their missing-input public Context
+// before compiling a private format unit. This proves formats, never initialized
+// numerical inputs, native entry, memory availability or executed semantics.
+func x86UnboundVoidVectorMoveFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	file, _ := x86UnboundVoidFormatSources(t, source, arch, triple)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("complete original move format lost its decoded bytes", err)
+	}
+	// Preserve the complete original source above, but compile every format in
+	// its own visible function below. A .Z memory store is terminal #UD and
+	// must neither swallow later rows nor be replaced by an ordinary store.
+	units := *normalized
+	units.Funcs = nil
+	signatures := make(map[string]FuncSig)
+	rows := 0
+	for _, function := range normalized.Funcs {
+		last := len(function.Instrs) - 1
+		if last < 2 || function.Instrs[0].Op != OpTEXT || !x86InstructionFormatTerminal(function.Instrs[last]) {
+			t.Fatal("original move formats lost their complete TEXT/return/fault envelope")
+		}
+		for _, instruction := range function.Instrs[1:last] {
+			name := fmt.Sprintf("MoveFormatRow%d", rows)
+			unit := function
+			unit.Sym = name
+			unit.Instrs = []Instr{function.Instrs[0], instruction, function.Instrs[last]}
+			units.Funcs = append(units.Funcs, unit)
+			signatures[name] = FuncSig{Name: name, Ret: Void}
+			rows++
+		}
+	}
+	ir := x86SingleInstructionFormatObjectUnits(t, &units, signatures, arch, triple,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			if known, terminated, err := c.lowerPackedVectorMove(instruction.Op, instruction); known {
+				return known, terminated, err
+			}
+			return c.lowerVectorScalarMove(instruction.Op, instruction)
+		})
+	if rows == 0 || strings.Count(ir, "define void @InstructionFormat") != rows {
+		t.Fatal("a complete original move row lost its visible backend function", rows)
+	}
+	t.Logf("%d original move formats each retain an externally visible LLVM object unit; no initialized/native execution claim", rows)
+	return ir
+}
+
+func x86UnboundVoidRawVectorMoveProbeObject(t *testing.T, file *File, arch, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	for _, function := range file.Funcs {
+		text, valid := x86RawReplaySourceText(function)
+		if !valid {
+			t.Fatal("move format probe lost its complete source")
+		}
+		source.WriteString(text)
+	}
+	return x86UnboundVoidVectorMoveFormatObject(t, source.String(), arch, triple)
+}
diff --git a/x86_raw_vector_move_terminal_test.go b/x86_raw_vector_move_terminal_test.go
new file mode 100644
index 000000000..ac1d6e516
--- /dev/null
+++ b/x86_raw_vector_move_terminal_test.go
@@ -0,0 +1,101 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawVectorMoveFormatProbeRetainsTerminalFault(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const source = "TEXT moveprobe(SB),4,$0-0\nVMOVSS (AX),X0\nVMOVSD X1,(BX)\nVMOVUPS (AX),Y2\nVMOVDQU32 Y3,(BX)\nRET\n"
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			code := assembleX87ControlBytes(t, target.arch, source)
+			original := append([]byte(nil), code...)
+			// Preserve the original complete RET program and all public
+			// Context observations before the private fault-ended transport.
+			raw := "TEXT moveprobe(SB),4,$0-0\n" + x86DwordProductDirectives(code)
+			x86UnboundVoidFormatSources(t, raw, target.arch, target.triple)
+			probe := x86RawUnprovedReturnFormProbeFile(t, target.arch, "moveprobe", code)
+			if !bytes.Equal(code, original) {
+				t.Fatal("private transport changed the independent original Go bytes")
+			}
+			normalized, err := normalizeX86RawFile(probe, target.arch)
+			if err != nil || len(normalized.Funcs) != 1 {
+				t.Fatal("private transport lost its decoded function", err)
+			}
+			instructions := normalized.Funcs[0].Instrs
+			if len(instructions) != 6 || (instructions[5].Op != "UD2" && instructions[5].Op != "UNDEF") ||
+				len(instructions[5].Args) != 0 {
+				t.Fatal("private transport lost its complete body and terminal #UD")
+			}
+			named, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, instruction := range instructions[1:5] {
+				want := named.Funcs[0].Instrs[index+1]
+				if instruction.Op != want.Op || !reflect.DeepEqual(instruction.Args, want.Args) {
+					t.Fatal("terminal transport changed an original move operand", index)
+				}
+			}
+			ir := x86UnboundVoidRawVectorMoveProbeObject(t, probe, target.arch, target.triple)
+			for index := 0; index < 4; index++ {
+				body := x86StringMemoryFunction(t, ir, fmt.Sprintf("InstructionFormat%d", index))
+				if strings.Count(body, `asm sideeffect "ud2"`) != 1 || !strings.Contains(body, "unreachable") ||
+					strings.Contains(body, "ret void") {
+					t.Fatal("private move format acquired a return or lost its terminal fault", index)
+				}
+			}
+			for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				x86PackedStringCompileObject(t, llc, target.triple, input, "-O0")
+			}
+		})
+	}
+}
+
+func TestX86VectorMoveFaultRowsKeepLaterFormatsVisible(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	const rows = "VMOVSS (AX),X0\nVMOVSD X1,(BX)\nVMOVUPS (AX),Y2\nVMOVDQU32.Z X3,K1,(BX)\nVMOVAPD (AX),X4\nVMOVDQU32 X5,(BX)\n"
+	for _, target := range x86RawReturnTargets {
+		for _, fault := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/fault=%t", target.triple, fault), func(t *testing.T) {
+				terminal := "RET\n"
+				if fault {
+					terminal = "BYTE $0x0f\nBYTE $0x0b\n"
+				}
+				source := "TEXT moverows(SB),4,$0-0\n" + rows + terminal
+				// The shared helper first authenticates the complete Go object
+				// and all public Context observations, not a cut-down row.
+				ir := x86UnboundVoidVectorMoveFormatObject(t, source, target.arch, target.triple)
+				if strings.Count(ir, "define void @InstructionFormat") != 6 {
+					t.Fatal("an architectural fault swallowed a later format row")
+				}
+				for index := 0; index < 6; index++ {
+					body := x86StringMemoryFunction(t, ir, fmt.Sprintf("InstructionFormat%d", index))
+					wantFault := fault || index == 3
+					if wantFault {
+						if strings.Count(body, `asm sideeffect "ud2"`) != 1 || !strings.Contains(body, "unreachable") ||
+							strings.Contains(body, "ret void") {
+							t.Fatal("format row lost its single terminal fault", index)
+						}
+					} else if !strings.Contains(body, "ret void") || strings.Contains(body, `asm sideeffect "ud2"`) {
+						t.Fatal("ordinary original format row changed its return", index)
+					}
+				}
+				for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					x86PackedStringCompileObject(t, llc, target.triple, input, "-O0")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_raw_vmovw_result_test.go b/x86_raw_vmovw_result_test.go
new file mode 100644
index 000000000..5824c54ed
--- /dev/null
+++ b/x86_raw_vmovw_result_test.go
@@ -0,0 +1,208 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Intel AVX512-FP16 section 5.61: both W values, two directions and
+// register/m16 forms. GP destinations zero-extend; X writes clear wider aliases.
+// https://cdrdv2-public.intel.com/678970/intel-avx512-fp16.pdf
+func x86RawVMOVWResultFixture(name, arch string, load, wide, memory bool) (string, string) {
+	move, word, result := "MOVQ", 8, 16
+	if arch == "386" {
+		move, word, result = "MOVL", 4, 8
+	}
+	general := 1 // CX is numerical, not the incoming pointer in AX.
+	if memory {
+		general = 0
+	}
+	source := fmt.Sprintf("TEXT %s(SB),4,$0-%d\n"+
+		"%s p+0(FP),AX\nMOVL value+%d(FP),CX\nMOVL CX,X1\n",
+		name, result+4, move, word)
+	source += x86RawDisplacementDirectives(rawVMOVW(load, wide, 1, general, memory))
+	if load || memory {
+		source += "MOVL X1,BX\n"
+	} else {
+		source += "MOVL CX,BX\n"
+	}
+	source += fmt.Sprintf("MOVL BX,ret+%d(FP)\nRET\n", result)
+	return source, fmt.Sprintf("func %s(p *byte,value uint32) uint32\n", name)
+}
+
+func TestX86RawVMOVWExactOriginAndNumericalState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, load := range []bool{false, true} {
+			for _, memory := range []bool{false, true} {
+				for _, wide := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/load=%t/memory=%t/wide=%t", arch, load, memory, wide), func(t *testing.T) {
+						general := 1
+						if memory {
+							general = 0
+						}
+						file := mustParseX86RawReturn(t, "TEXT Value(SB),4,$0-0\n"+
+							x86RawDisplacementDirectives(rawVMOVW(load, wide, 1, general, memory))+"RET\n")
+						file, err := normalizeX86RawFile(file, arch)
+						if err != nil {
+							t.Fatal(err)
+						}
+						ins := file.Funcs[0].Instrs[1]
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.pointerGP[0], state.gp[1], state.gp[2] = true, 3, 0x55
+						state.writeVector(1, 64, 0xabcdef0123450003, false)
+						before := state.clone()
+						accepted, known := x86LoweredRawVMOVWResultStep(ins, &state, nil, 0, arch)
+						want := before.clone()
+						if load {
+							want.writeVector(1, 64, ^uint64(0), false)
+						} else if !memory {
+							want.gp[1] = 0xff
+						}
+						if !accepted || !known || !reflect.DeepEqual(state, want) {
+							t.Fatal("VMOVW lost low two bytes, upper zeroing or unrelated state")
+						}
+						if !load || !memory {
+							for missing := uint(0); missing < 2; missing++ {
+								partial := before.clone()
+								if !load {
+									partial.writeVector(1, 64, partial.vectorBytes(1)&^(1<<missing), false)
+								} else {
+									partial.gp[1] &^= 1 << missing
+								}
+								original := partial.clone()
+								accepted, known := x86LoweredRawVMOVWResultStep(ins, &partial, nil, 0, arch)
+								if accepted || !known || !reflect.DeepEqual(partial, original) {
+									t.Fatal("VMOVW invented a missing low byte", missing)
+								}
+							}
+						}
+						for _, mutation := range []string{"encoding", "origin", "opcode", "operand", "address", "segment", "return", "literal"} {
+							changed, rejected := ins, before.clone()
+							switch mutation {
+							case "encoding":
+								changed.x86Encoded = false
+							case "origin":
+								changed.x86SourceRaw = nil
+							case "opcode":
+								changed.x86SourceRaw = &x86SourceRawInstruction{op: "VMOVD", args: ins.Args}
+							case "operand":
+								changed.Args = append([]Operand(nil), ins.Args...)
+								changed.Args[0] = Operand{Kind: OpReg, Reg: "X2"}
+							case "address":
+								changed.x86AddressBits = 32
+							case "segment":
+								changed.x86SegmentPrefix = 0x64
+							case "return":
+								changed.x86RawNearReturn = new(x86RawNearReturnForm)
+							case "literal":
+								changed.x86RIPLiteral = true
+							}
+							accepted, known := x86LoweredRawVMOVWResultStep(changed, &rejected, nil, 0, arch)
+							if accepted || !known || !reflect.DeepEqual(rejected, before) {
+								t.Fatal("changed raw origin acquired numerical effects", mutation)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawVMOVWInitializedResultsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, load := range []bool{false, true} {
+				for _, wide := range []bool{false, true} {
+					for _, memory := range []bool{false, true} {
+						asm, declaration := x86RawVMOVWResultFixture(
+							fmt.Sprintf("Value%d", count), target.arch, load, wide, memory)
+						source.WriteString(asm)
+						declarations.WriteString(declaration)
+						count++
+					}
+				}
+			}
+			if count != 8 {
+				t.Fatal("incomplete raw VMOVW format inventory", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized raw GP/X/m16 result sequence", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RawVMOVWRequiresInputsWithoutResults(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, load := range []bool{false, true} {
+			for _, wide := range []bool{false, true} {
+				for _, memory := range []bool{false, true} {
+					name := fmt.Sprintf("%s/load=%t/wide=%t/memory=%t", target.triple, load, wide, memory)
+					t.Run(name, func(t *testing.T) {
+						source := "TEXT Value(SB),4,$0-0\n" +
+							x86RawDisplacementDirectives(rawVMOVW(load, wide, 1, 0, memory)) + "RET\n"
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("raw VMOVW borrowed implementation zeros or unknown addresses", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawVMOVWRetainsPointerAndValueBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, load := range []bool{false, true} {
+			source, declaration := x86RawVMOVWResultFixture("Value", target.arch, load, false, true)
+			move := "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			for name, bad := range map[string]string{
+				"unknown pointer": strings.Replace(source, move+" p+0(FP),AX", "", 1),
+				"numeric pointer": strings.Replace(source, move+" p+0(FP),AX", "MOVL $4096,AX", 1),
+			} {
+				t.Run(fmt.Sprintf("%s/load=%t/%s", target.triple, load, name), func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, bad, declaration, target.arch, target.triple, api)
+						if load && name == "numeric pointer" {
+							if err != nil || strings.Count(ir, "load volatile i16,") != 1 {
+								t.Fatal("VMOVW numeric source lost its exact word read", api, err)
+							}
+							x86RequireNumericNativeSourceContext(t, bad, declaration, target.arch)
+							x86NumericNativeAddressObject(t, ir, target.triple)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw VMOVW invented incoming pointer identity", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_raw_zero_extend_identity_test.go b/x86_raw_zero_extend_identity_test.go
new file mode 100644
index 000000000..ddfc43aa7
--- /dev/null
+++ b/x86_raw_zero_extend_identity_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86RawZeroExtendSourceIdentityAndPreservedDomains(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for opcode := byte(0x30); opcode <= 0x35; opcode++ {
+			decoded, err := decodeX86RawDirectives(rawX86Function([]byte{0xc4, 0xe2, 0x79, opcode, 0x08}), arch)
+			if err != nil || len(decoded.Instrs) != 1 {
+				t.Fatal("independent complete widening row did not decode", err)
+			}
+			original := decoded.Instrs[0]
+			if !x86RawZeroExtendSource(original, arch) {
+				t.Fatal("original typed/raw widening identity disappeared")
+			}
+			t.Run(fmt.Sprintf("%s/%x/domains", arch, opcode), func(t *testing.T) {
+				var addresses [16]bool
+				addresses[0], addresses[7] = true, true
+				if x86ResultDirectionAfterSource(original, x86ResultDirectionBackward, arch) != x86ResultDirectionBackward ||
+					!x86ResultPreservesPrivateStorage(original, arch) ||
+					x86ResultCallerAddressesAfter(original, addresses, nil, arch) != addresses {
+					t.Fatal("bound widening revoked an independent DF/private-storage/GP-address fact")
+				}
+			})
+			for _, mutation := range []string{"origin", "mode", "encoded", "opcode", "operand", "vector width", "address size"} {
+				t.Run(fmt.Sprintf("%s/%x/%s", arch, opcode, mutation), func(t *testing.T) {
+					changed, mode := original, arch
+					changed.Args = append([]Operand(nil), original.Args...)
+					switch mutation {
+					case "origin":
+						changed.x86SourceRaw = nil
+					case "mode":
+						mode = map[string]string{"386": "amd64", "amd64": "386"}[arch]
+					case "encoded":
+						changed.x86Encoded = !changed.x86Encoded
+					case "opcode":
+						changed.Op = "VPMOVZXWQ"
+						if changed.Op == original.Op {
+							changed.Op = "VPMOVZXBD"
+						}
+					case "operand":
+						changed.Args[0].Mem.Base = DX
+					case "vector width":
+						changed.x86VectorBytes ^= 16
+					case "address size":
+						changed.x86AddressBits = 16
+					}
+					if x86RawZeroExtendSource(changed, mode) {
+						t.Fatal("mutated instruction acquired another raw producer's identity")
+					}
+					if mutation == "origin" {
+						// A VEX origin-only mutation can look exactly like a
+						// genuine named instruction. The immutable whole-source
+						// replay below, not a standalone step, must reject it.
+						return
+					}
+					state := x86FMA3ResultInputState()
+					before := state.clone()
+					if accepted, _ := x86ResultPackedZeroExtendStep(changed, &state, nil, mode, true); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("unbound physical widening changed numerical state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawZeroExtendWholeProducerAndStandaloneBoundaries(t *testing.T) {
+	const body = "MOVQ p+0(FP),AX\nVZEROALL\nBYTE $0xc4; BYTE $0xe2; BYTE $0x79; BYTE $0x31; BYTE $0x08\nPEXTRD $0,X1,AX\nMOVL AX,ret0+8(FP)\nRET"
+	_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(p *[32]byte) uint32", body)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	file, err := normalizeX86RawFile(file, "amd64")
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("complete initialized widening producer did not normalize", err)
+	}
+	for _, mutation := range []string{"original", "origin only", "producer", "replay"} {
+		t.Run(mutation, func(t *testing.T) {
+			function := file.Funcs[0]
+			function.Instrs = append([]Instr(nil), function.Instrs...)
+			switch mutation {
+			case "origin only":
+				for index := range function.Instrs {
+					if function.Instrs[index].Op == "VPMOVZXBD" {
+						function.Instrs[index].x86SourceRaw = nil
+						function.Instrs[index].x86Encoded = false
+					}
+				}
+			case "producer":
+				function.Instrs[2].Op = "VZEROUPPER"
+			case "replay":
+				function.x86RawReplay = nil
+			}
+			ctx := amd64Ctx{fpScalarSource: function, fpSourceSig: sig, sig: sig,
+				goarch: "amd64", targetTriple: "x86_64-unknown-linux-gnu"}
+			err := ctx.checkLoweredScalarFPResultInitialization()
+			if mutation == "original" {
+				if err != nil {
+					t.Fatal("complete original source lost its paired widening consumer", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed whole producer inherited the original source proof", err)
+			}
+			if err := checkX86ScalarFPResultInitialization(function, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone declaration query acquired paired native memory", err)
+			}
+		})
+	}
+}
diff --git a/x86_raw_zero_extend_source.go b/x86_raw_zero_extend_source.go
new file mode 100644
index 000000000..a614b7dd7
--- /dev/null
+++ b/x86_raw_zero_extend_source.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+type x86RawZeroExtendIdentity struct {
+	arch    string
+	encoded bool
+}
+
+func x86ZeroExtendRawIdentity(ins Instr, arch string) x86RawZeroExtendIdentity {
+	form, known, err := x86PackedZeroExtendProperties(ins, arch)
+	if !known || err != nil || !form.spec.vector {
+		return x86RawZeroExtendIdentity{}
+	}
+	return x86RawZeroExtendIdentity{arch, ins.x86Encoded}
+}
+
+// Both physical generations have the same shrinking tuple and upper-zero
+// effect. The complete raw producer retains their original bytes; this check
+// binds the existing typed grammar, architecture and every original operand.
+// It grants no caller, standalone-query, literal or physical-entry authority.
+func x86RawZeroExtendSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedZeroExtendProperties(ins, arch)
+	return known && err == nil && form.spec.vector && ins.x86SourceRaw != nil &&
+		ins.x86SourceRaw.zeroExtend.arch == arch &&
+		ins.x86SourceRaw.zeroExtend == x86ZeroExtendRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86ZeroExtendRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay != nil {
+		for _, ins := range fn.x86RawReplay.decoded {
+			if form, known, _ := x86PackedZeroExtendProperties(ins, arch); known && form.spec.vector {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/x86_reciprocal14_native_c_unix_test.go b/x86_reciprocal14_native_c_unix_test.go
new file mode 100644
index 000000000..2452991fa
--- /dev/null
+++ b/x86_reciprocal14_native_c_unix_test.go
@@ -0,0 +1,96 @@
+//go:build darwin || (linux && amd64)
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"debug/elf"
+	"debug/macho"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// These hosts have a real matching x86 C SDK/sysroot. Only compilation/linking
+// occurs: even a host without AVX512 must validate the C oracle and .byte/AX
+// constraints. Default Windows/ARM Linux source/object owners remain separate.
+func TestX86Reciprocal14NativeCFixturesCompileLinkOnly(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 compiler/backend required for C fixture qualification")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	compiler := []string{clang, "-target", triple}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(ctx, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal("actual macOS SDK required for compile-only x86 fixture", err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: triple, compiler: compiler}
+	qualify := func(t *testing.T, source, declarations, mainC string) {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+		if err != nil {
+			t.Fatal("C fixture's actual translated callback source rejected", err)
+		}
+		path := execution.compileLLVM(t, "rcp14-c-fixture", ir, mainC, "-O2")
+		if runtime.GOOS == "darwin" {
+			file, err := macho.Open(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer file.Close()
+			if file.Cpu != macho.CpuAmd64 {
+				t.Fatal("compile-only fixture has foreign architecture", file.Cpu)
+			}
+		} else {
+			file, err := elf.Open(path)
+			if err != nil {
+				t.Fatal(err)
+			}
+			defer file.Close()
+			if file.Machine != elf.EM_X86_64 {
+				t.Fatal("compile-only fixture has foreign architecture", file.Machine)
+			}
+		}
+		payload, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("actual C fixture compiled+linked target=%s executableSHA=%x; NOT executed", triple, sha256.Sum256(payload))
+	}
+	for _, profile := range []int{5, 6} {
+		var rows []x86Reciprocal14NativeRow
+		for _, row := range x86Reciprocal14NativeRows() {
+			if row.id < 132 && row.source != 0 && row.profile() == profile {
+				rows = append(rows, row)
+			}
+		}
+		for start := 0; start < len(rows); start += 32 {
+			end := start + 32
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("fault/profile%d/batch%d", profile, start/32), func(t *testing.T) {
+				source, declarations, fixture := x86Reciprocal14NativeFaultProgram(t, rows[start:end], profile)
+				qualify(t, source, declarations, fixture)
+			})
+		}
+	}
+	t.Run("values", func(t *testing.T) {
+		rows := x86Reciprocal14NativeRows()[:8]
+		source, declarations, prototypes := x86Reciprocal14NativeSource(rows, false)
+		fixture := strings.NewReplacer("@PROTOTYPES@", prototypes, "@ROWS@", x86Reciprocal14NativeMetadata(rows, false),
+			"@TRACE@", strconv.Quote(filepath.Join(t.TempDir(), "unexecuted.trace")), "@COUNT@", "1").Replace(x86Reciprocal14NativeValuesC)
+		qualify(t, source, declarations, fixture)
+	})
+}
diff --git a/x86_reciprocal14_native_linux_amd64_test.go b/x86_reciprocal14_native_linux_amd64_test.go
new file mode 100644
index 000000000..f128b1512
--- /dev/null
+++ b/x86_reciprocal14_native_linux_amd64_test.go
@@ -0,0 +1,19 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+// Explicit qualification only: default CI does not discover these owners.
+// Supplying the tag requires real hardware and never turns missing ISA into PASS.
+func TestX86Reciprocal14NativeFAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86RunReciprocal14Native(t, 5)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestX86Reciprocal14NativeVLAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	x86RunReciprocal14Native(t, 6)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_reciprocal14_native_oracle_test.go b/x86_reciprocal14_native_oracle_test.go
new file mode 100644
index 000000000..d5810d6a5
--- /dev/null
+++ b/x86_reciprocal14_native_oracle_test.go
@@ -0,0 +1,224 @@
+package plan9asm
+
+// Original Go executes the same initialized source later sent to each public
+// API. Its processor's approximation bits are the reference; independent
+// projections, Intel special cases/error bound and MXCSR invariants still
+// validate that reference. There is no exact-division replacement oracle.
+const x86Reciprocal14NativeOriginalGo = `package oracle
+import (
+    "bytes"
+    "encoding/binary"
+    "math"
+    "os"
+    "runtime"
+    "testing"
+)
+type kernel struct {
+    id,member,bits,width,source,mode,low,upper,dynamic int
+    run func(*[160]byte,*[64]byte,*[64]byte,*[64]byte,uint64,uint32,uint32)
+}
+type sample struct {row,pattern int; mask uint64; first,second uint32}
+var kernels=[]kernel{@ROWS@}
+var cases=[]sample{@CASES@}
+var patterns32=[]uint64{
+    0,0x80000000,0x7f800000,0xff800000,1,0x80000001,0x007fffff,0x807fffff,
+    0x00800000,0x80800000,0x3f800000,0xbf800000,0x40800000,0xc0800000,
+    0x3f123456,0xbf123456,0x7f7fffff,0xff7fffff,0x7e800000,0xfe800000,
+    0x7fc12345,0xffc12345,0x7f812345,0xff812345,
+}
+var patterns64=[]uint64{
+    0,0x8000000000000000,0x7ff0000000000000,0xfff0000000000000,1,0x8000000000000001,
+    0x000fffffffffffff,0x800fffffffffffff,0x0010000000000000,0x8010000000000000,
+    0x3ff0000000000000,0xbff0000000000000,0x4010000000000000,0xc010000000000000,
+    0x3fe2468ace13579b,0xbfe2468ace13579b,0x7fefffffffffffff,0xffefffffffffffff,
+    0x7fd0000000000000,0xffd0000000000000,0x7ff8123456789abc,0xfff8123456789abc,
+    0x7ff0123456789abc,0xfff0123456789abc,
+}
+func put(p []byte,bits int,value uint64) {
+    if bits==32 {binary.LittleEndian.PutUint32(p,uint32(value))} else {binary.LittleEndian.PutUint64(p,value)}
+}
+func get(p []byte,bits int) uint64 {
+    if bits==32 {return uint64(binary.LittleEndian.Uint32(p))};return binary.LittleEndian.Uint64(p)
+}
+func buffers(k kernel,s int) (input,upper,old [64]byte) {
+    for i:=range input {input[i]=byte(i*19+s*31+0xa5);upper[i]=byte(i*43+s*13+0x5a);old[i]=byte(i*53+s*17+0x69)}
+    patterns:=patterns32;if k.bits==64 {patterns=patterns64}
+    for lane:=0;lane<64/(k.bits/8);lane++ {put(input[lane*(k.bits/8):],k.bits,patterns[(s+lane)%24])}
+    return
+}
+func valid(k kernel,input,output uint64,csr uint32) bool {
+    fraction,exponent:=23,8
+    if k.bits==64 {fraction,exponent=52,11}
+    sign:=uint64(1)<<uint(k.bits-1)
+    infinity:=(uint64(1)<<uint(exponent)-1)<<uint(fraction)
+    magnitude:=input&^sign
+    if magnitude&infinity==0 && csr&0x40!=0 {input&=sign;magnitude=0}
+    if magnitude>infinity {return output&infinity==infinity && output&(uint64(1)<<uint(fraction-1))!=0}
+    if magnitude==0 {return output==input&sign|infinity}
+    rsqrt:=k.member>=4
+    if rsqrt && input&sign!=0 {return output==sign|infinity|uint64(1)<<uint(fraction-1)}
+    if magnitude==infinity {return output==input&sign}
+    x,y:=math.Float64frombits(input),math.Float64frombits(output)
+    smallest,largest:=math.SmallestNonzeroFloat64,math.MaxFloat64
+    if k.bits==32 {x,y=float64(math.Float32frombits(uint32(input))),float64(math.Float32frombits(uint32(output)));smallest,largest=math.SmallestNonzeroFloat32,math.MaxFloat32}
+    expected:=1/x;if rsqrt {expected=1/math.Sqrt(x)}
+    if math.IsInf(expected,0) || math.Abs(expected)>largest {return output&^sign==infinity}
+    if !rsqrt && csr&0x8000!=0 && math.Abs(expected)<smallest*float64(uint64(1)<<uint(fraction)) {return output==input&sign}
+    if output&infinity==0 && magnitude&infinity==0 && expected==0 {return output==input&sign}
+    return !math.IsNaN(y) && math.Abs((y-expected)/expected)<1.0/16384
+}
+func check(t *testing.T,k kernel,c sample,input,upper,old [64]byte,out [160]byte,ambient uint32) {
+    t.Helper()
+    registers:=[3][64]byte{input,upper,old}
+    if k.source==0 {registers[k.low-16]=input}
+    scalar:=k.member%4>=2
+    for half:=0;half<=k.dynamic;half++ {
+        csr:=c.first;if half==1 {csr=c.second}
+        value:=out[half*64:(half+1)*64]
+        lanes:=k.width*8/k.bits;if scalar {lanes=1}
+        for lane:=0;lane<lanes;lane++ {
+            offset:=lane*k.bits/8
+            active:=k.mode==0 || c.mask&(uint64(1)<<uint(lane))!=0
+            if active {
+                source:=offset;if k.source==2 || scalar {source=0}
+                if !valid(k,get(input[source:],k.bits),get(value[offset:],k.bits),csr) {t.Fatalf("native estimate outside specification row=%d lane=%d sample=%d csr=%x input=%x output=%x",k.id,lane,c.pattern,csr,get(input[source:],k.bits),get(value[offset:],k.bits))}
+            } else {
+                expected:=uint64(0);if k.mode==1 {expected=get(registers[2][offset:],k.bits)}
+                if get(value[offset:],k.bits)!=expected {t.Fatal("native mask projection",k.id,lane)}
+            }
+        }
+        end:=k.width
+        if scalar {
+            end=16
+            if !bytes.Equal(value[k.bits/8:16],registers[k.upper-16][k.bits/8:16]) {t.Fatal("native scalar upper copy",k.id)}
+        }
+        for _,b:=range value[end:] {if b!=0 {t.Fatal("native wider alias was not zero",k.id)}}
+    }
+    if binary.LittleEndian.Uint32(out[128:])!=ambient || binary.LittleEndian.Uint32(out[132:])!=0xc95 || binary.LittleEndian.Uint32(out[136:])!=c.first {t.Fatal("native first FLAGS/MXCSR",k.id)}
+    if k.dynamic!=0 {
+        if binary.LittleEndian.Uint32(out[140:])!=c.second || binary.LittleEndian.Uint32(out[144:])!=0xc95 {t.Fatal("native second FLAGS/MXCSR",k.id)}
+    } else {
+        for _,b:=range out[64:128] {if b!=0xc3 {t.Fatal("native output canary",k.id)}}
+        for _,b:=range out[140:148] {if b!=0xc3 {t.Fatal("native control canary",k.id)}}
+    }
+    for _,b:=range out[148:] {if b!=0xc3 {t.Fatal("native tail canary",k.id)}}
+}
+func TestOriginal(t *testing.T) {
+    runtime.LockOSThread();defer runtime.UnlockOSThread()
+    saved:=MXCSR(0x1f80);defer MXCSR(saved)
+    byID:=map[int]kernel{};for _,k:=range kernels {if _,exists:=byID[k.id];exists {t.Fatal("duplicate row")};byID[k.id]=k}
+    trace:=[]byte("R14TRACE")
+    append32:=func(x uint32) {var b [4]byte;binary.LittleEndian.PutUint32(b[:],x);trace=append(trace,b[:]...)}
+    append32(1);append32(uint32(len(cases)))
+    rounding:=map[[4]uint64][64]byte{}
+    for index,c:=range cases {
+        k,exists:=byID[c.row];if !exists {t.Fatal("foreign case row")}
+        input,upper,old:=buffers(k,c.pattern)
+        beforeInput,beforeUpper,beforeOld:=input,upper,old
+        var out [160]byte;for i:=range out {out[i]=0xc3}
+        ambient:=uint32(0x1f80);if index%2!=0 {ambient=0x3f80}
+        MXCSR(ambient);k.run(&out,&input,&upper,&old,c.mask,c.first,c.second)
+        if after:=MXCSR(0x1f80);after!=ambient {t.Fatal("ambient MXCSR not restored",after,ambient)}
+        if input!=beforeInput || upper!=beforeUpper || old!=beforeOld {t.Fatal("source canary changed")}
+        check(t,k,c,input,upper,old,out,ambient)
+        key:=[4]uint64{uint64(k.id),uint64(c.pattern),c.mask,uint64(c.first&0x8040)}
+        var first [64]byte;copy(first[:],out[:64])
+        if previous,seen:=rounding[key];seen && previous!=first {t.Fatal("native estimate changed with RC/status/exception masks",key)}
+        rounding[key]=first
+        append32(uint32(c.row));append32(uint32(c.pattern))
+        append32(uint32(c.mask));append32(uint32(c.mask>>32));append32(c.first);append32(c.second)
+        trace=append(trace,out[:]...)
+    }
+    if err:=os.WriteFile(@TRACE@,trace,0600);err!=nil {t.Fatal(err)}
+    t.Logf("actual original Go RCP14 rows=%d cases=%d complete bits/aliases/FLAGS/MXCSR/canaries",len(kernels),len(cases))
+}
+`
+
+// The original-Go trace is read-only and identity checked before and after
+// every candidate. This C fixture uses the existing compile/run process owner.
+const x86Reciprocal14NativeValuesC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+@PROTOTYPES@
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t,uint32_t,uint32_t);
+static const struct {unsigned id;Kernel run;unsigned bits;} rows[]={@ROWS@};
+static const uint64_t patterns[2][24]={
+ {0,0x80000000,0x7f800000,0xff800000,1,0x80000001,0x007fffff,0x807fffff,
+  0x00800000,0x80800000,0x3f800000,0xbf800000,0x40800000,0xc0800000,
+  0x3f123456,0xbf123456,0x7f7fffff,0xff7fffff,0x7e800000,0xfe800000,
+  0x7fc12345,0xffc12345,0x7f812345,0xff812345},
+ {0,UINT64_C(0x8000000000000000),UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000),1,UINT64_C(0x8000000000000001),
+  UINT64_C(0x000fffffffffffff),UINT64_C(0x800fffffffffffff),UINT64_C(0x0010000000000000),UINT64_C(0x8010000000000000),
+  UINT64_C(0x3ff0000000000000),UINT64_C(0xbff0000000000000),UINT64_C(0x4010000000000000),UINT64_C(0xc010000000000000),
+  UINT64_C(0x3fe2468ace13579b),UINT64_C(0xbfe2468ace13579b),UINT64_C(0x7fefffffffffffff),UINT64_C(0xffefffffffffffff),
+  UINT64_C(0x7fd0000000000000),UINT64_C(0xffd0000000000000),UINT64_C(0x7ff8123456789abc),UINT64_C(0xfff8123456789abc),
+  UINT64_C(0x7ff0123456789abc),UINT64_C(0xfff0123456789abc)}
+};
+static uint32_t u32(const uint8_t *p) {return (uint32_t)p[0]|(uint32_t)p[1]<<8|(uint32_t)p[2]<<16|(uint32_t)p[3]<<24;}
+static uint64_t u64(const uint8_t *p) {return u32(p)|(uint64_t)u32(p+4)<<32;}
+int main(void) {
+    FILE *f=fopen(@TRACE@,"rb");uint8_t header[16];
+    if (!f || fread(header,1,16,f)!=16 || memcmp(header,"R14TRACE",8) || u32(header+8)!=1 || u32(header+12)!=@COUNT@) return 1;
+    for (unsigned caseID=0;caseID<@COUNT@;caseID++) {
+        uint8_t record[184],input[64],upper[64],old[64],out[160];
+        if (fread(record,1,sizeof(record),f)!=sizeof(record)) return 2;
+        unsigned id=u32(record),sample=u32(record+4),index=0;
+        while(index<sizeof(rows)/sizeof(rows[0]) && rows[index].id!=id) index++;
+        if (index==sizeof(rows)/sizeof(rows[0]) || sample>=24) return 3;
+        if (rows[index].bits!=32 && rows[index].bits!=64) return 4;
+        unsigned precision=rows[index].bits==64,bytes=precision?8:4;
+        for(unsigned i=0;i<64;i++) {input[i]=(uint8_t)(i*19+sample*31+0xa5);upper[i]=(uint8_t)(i*43+sample*13+0x5a);old[i]=(uint8_t)(i*53+sample*17+0x69);}
+        for(unsigned lane=0;lane<64/bytes;lane++) {uint64_t value=patterns[precision][(sample+lane)%24];memcpy(input+lane*bytes,&value,bytes);}
+        uint8_t beforeInput[64],beforeUpper[64],beforeOld[64];
+        memcpy(beforeInput,input,64);memcpy(beforeUpper,upper,64);memcpy(beforeOld,old,64);memset(out,0xc3,160);
+        unsigned ambient=caseID%2?0x3f80:0x1f80;__asm__ volatile("ldmxcsr %0"::"m"(ambient):"memory");
+        rows[index].run(out,input,upper,old,u64(record+8),u32(record+16),u32(record+20));
+        unsigned after;__asm__ volatile("stmxcsr %0":"=m"(after));
+        if (memcmp(out,record+24,160) || memcmp(input,beforeInput,64) || memcmp(upper,beforeUpper,64) || memcmp(old,beforeOld,64)) {
+            fprintf(stderr,"RCP14 original-Go bit mismatch case=%u row=%u sample=%u\n",caseID,id,sample);
+            return 5;
+        }
+        if (after!=ambient) return 7;
+    }
+    if (fgetc(f)!=EOF || ferror(f) || fclose(f)) return 6;
+    printf("RCP14 native original-Go bits cases=%u failures=0\n",(unsigned)@COUNT@);
+    return 0;
+}
+`
+
+const x86Reciprocal14NativeFaultsC = `
+typedef void (*Kernel)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t,uint32_t,uint32_t);
+static const struct {unsigned id;Kernel run;unsigned extent,lane,lanes,mode;} rows[]={@ROWS@};
+__attribute__((target("@FEATURES@")))
+static void original(unsigned row,const uint8_t *input,unsigned mask) {
+    switch(row) {@ORIGINAL@ default:exit(86);}
+}
+int main(int argc,char **argv) {
+    unsigned row,probe,native;char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&row,&tail)!=1 || sscanf(argv[2],"%u%c",&probe,&tail)!=1 ||
+            sscanf(argv[3],"%u%c",&native,&tail)!=1 || row>=sizeof(rows)/sizeof(rows[0]) || probe>=10 || native>1) return 80;
+    if (memory_fault_setup(0)) return 81;
+    unsigned extent=rows[row].extent,lane=rows[row].lane,lanes=rows[row].lanes;
+    const uint8_t *input=NULL;uint64_t mask=0;
+    switch(probe) {
+    case 0:break;
+    case 1:mask=UINT64_C(1)<<lanes;break;
+    case 2:mask=1;break;
+    case 3:input=guard+page-extent;mask=0xffff;break;
+    case 4:input=guard+page-extent+1;mask=0xffff;break;
+    case 5:input=guard+page-lane;mask=1;break;
+    case 6:input=guard+page-lane+1;mask=1;break;
+    case 7:mask=UINT64_C(1)<<(lanes-1);break;
+    case 8:input=guard+1;mask=0xffff;break;
+    case 9:input=guard+page-extent;mask=0xffff;if(mprotect(guard,page,PROT_READ)) return 82;break;
+    }
+    uint8_t out[160],upper[64]={0},old[64]={0};memset(out,0xc3,sizeof(out));
+    printf("memory enter %u %u %u\n",row,probe,native);
+    if (fflush(stdout)) return 83;
+    if (native) original(rows[row].id,input,(unsigned)mask);
+    else rows[row].run(out,input,upper,old,mask,0x1f80,0x1f80);
+    if (free_guard()) return 84;
+    puts("memory complete");return fflush(stdout)?85:0;
+}
+`
diff --git a/x86_reciprocal14_native_policy_test.go b/x86_reciprocal14_native_policy_test.go
new file mode 100644
index 000000000..649de2a6f
--- /dev/null
+++ b/x86_reciprocal14_native_policy_test.go
@@ -0,0 +1,409 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"go/format"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86Reciprocal14NativeFiniteRowsAndFactoredCases(t *testing.T) {
+	rows := x86Reciprocal14NativeRows()
+	if len(rows) != 236 {
+		t.Fatal("132 canonical + 96 alias + 8 dynamic rows changed", len(rows))
+	}
+	var members [8]int
+	profiles := make(map[int]int)
+	seen := make(map[string]bool)
+	for index, row := range rows {
+		key := fmt.Sprint(row.member, "/", row.width, "/", row.source, "/", row.mode, "/", row.low, "/", row.upper, "/", row.dynamic)
+		if row.id != index || seen[key] {
+			t.Fatal("duplicate or unstable row identity", row)
+		}
+		seen[key] = true
+		members[row.member]++
+		profiles[row.profile()]++
+		if index < 132 && (row.low != 16 || row.upper != 17 || row.dynamic) {
+			t.Fatal("canonical row replaced by alias", row)
+		}
+	}
+	if profiles[5] != 140 || profiles[6] != 96 || len(profiles) != 2 {
+		t.Fatal("F / FVL profile denominator", profiles)
+	}
+	if members != [8]int{37, 37, 22, 22, 37, 37, 22, 22} {
+		t.Fatal("missing complete eight-member shape", members)
+	}
+	for _, profile := range []int{5, 6} {
+		var selected []x86Reciprocal14NativeRow
+		for _, row := range rows {
+			if row.profile() == profile {
+				selected = append(selected, row)
+			}
+		}
+		cases := x86Reciprocal14NativeCases(selected)
+		if len(cases) < 2000 || len(cases) > 18000 {
+			t.Fatal("factored cases unexpectedly Cartesian or empty", profile, len(cases))
+		}
+		source, declarations, _ := x86Reciprocal14NativeSource(selected, false)
+		for _, forbidden := range []string{"KMOVQ", "VMOVUPS (AX),X", "VMOVUPS (BX),X", "VMOVUPS (CX),X", "KeepFunc", "Crop"} {
+			if strings.Contains(source, forbidden) {
+				t.Fatal("native source lost minimum profile or full-source boundary", forbidden)
+			}
+		}
+		if strings.Count(source, "TEXT ·") != len(selected) || strings.Count(declarations, "func ") != len(selected) ||
+			strings.Count(source, "LDMXCSR 128(DI)") != len(selected) {
+			t.Fatal("incomplete initialized native program")
+		}
+	}
+}
+
+func TestX86Reciprocal14NativeTraceRejectsForeignAndIncompleteRecords(t *testing.T) {
+	cases := []x86Reciprocal14NativeCase{{3, 6, 0x1234, 0x1f80, 0x1fc0}, {7, 16, 0xffff, 0x1f80, 0x9f80}}
+	data := make([]byte, 16+184*len(cases))
+	copy(data, "R14TRACE")
+	binary.LittleEndian.PutUint32(data[8:], 1)
+	binary.LittleEndian.PutUint32(data[12:], uint32(len(cases)))
+	for index, c := range cases {
+		r := data[16+184*index:]
+		binary.LittleEndian.PutUint32(r, uint32(c.row))
+		binary.LittleEndian.PutUint32(r[4:], uint32(c.sample))
+		binary.LittleEndian.PutUint64(r[8:], c.mask)
+		binary.LittleEndian.PutUint32(r[16:], c.first)
+		binary.LittleEndian.PutUint32(r[20:], c.second)
+	}
+	if err := x86Reciprocal14NativeTrace(data, cases); err != nil {
+		t.Fatal(err)
+	}
+	for _, length := range []int{0, 7, 15, len(data) - 1, len(data) + 1} {
+		changed := append(append([]byte(nil), data...), 0)
+		if err := x86Reciprocal14NativeTrace(changed[:length], cases); err == nil {
+			t.Fatal("incomplete trace accepted", length)
+		}
+	}
+	for _, offset := range []int{0, 8, 12, 16, 20, 24, 28, 32, 36, 200} {
+		changed := append([]byte(nil), data...)
+		changed[offset] ^= 1
+		if err := x86Reciprocal14NativeTrace(changed, cases); err == nil {
+			t.Fatal("foreign trace identity accepted", offset)
+		}
+	}
+	duplicate := append([]byte(nil), data...)
+	copy(duplicate[200:], duplicate[16:200])
+	if err := x86Reciprocal14NativeTrace(duplicate, cases); err == nil {
+		t.Fatal("duplicate trace record replaced an actual case")
+	}
+}
+
+func TestX86Reciprocal14NativeGoListingBoundaryControls(t *testing.T) {
+	original := "literal.R140 STEXT nosplit asm size=1 args=0x0 locals=0x0\n" +
+		"  0x0000 00000 (fixture.s:2) RET\n" + fmt.Sprintf("  0x0000%-48s  .\n", " c3")
+	mutations := map[string][2]string{
+		"foreign package":  {"literal.R140", "foreign.R140"},
+		"wrong TEXT":       {"STEXT ", "SRODATA "},
+		"wrong PC":         {"0x0000 00000", "0x0001 00001"},
+		"wrong decimal PC": {"0x0000 00000", "0x0000 00001"},
+		"wrong source row": {"fixture.s:2", "fixture.s:3"},
+		"truncated extent": {"size=1", "size=2"},
+	}
+	inspect := func(owner string, line int, code []byte) {
+		if owner != "R140" || line != 2 || !bytes.Equal(code, []byte{0xc3}) {
+			t.Fatal("foreign original source instruction", owner, line, code)
+		}
+	}
+	rows := []x86Reciprocal14NativeRow{{id: 0, width: 64, low: 16, upper: 17}}
+	if fixture := os.Getenv("PLAN9ASM_RECIPROCAL14_LISTING_FIXTURE"); fixture != "" {
+		mutation, exists := mutations[fixture]
+		if !exists {
+			t.Fatal("unknown boundary-control fixture")
+		}
+		listing := strings.Replace(original, mutation[0], mutation[1], 1)
+		x86Reciprocal14NativeGoBytesIR(t, listing, rows, inspect)
+		return // Accepted corruption is a successful child, rejected by parent.
+	}
+	for _, prefix := range []string{"literal.", `"".`} {
+		x86Reciprocal14NativeGoBytesIR(t, strings.Replace(original, "literal.", prefix, 1), rows, inspect)
+	}
+	for name := range mutations {
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := exec.CommandContext(ctx, os.Args[0], "-test.run=^TestX86Reciprocal14NativeGoListingBoundaryControls$", "-test.count=1")
+		command.Env = append(os.Environ(), "PLAN9ASM_RECIPROCAL14_LISTING_FIXTURE="+name)
+		output, err := runtimeOracleCombinedOutput(ctx, command)
+		cancel()
+		var status *exec.ExitError
+		if !errors.As(err, &status) || status != err || status.ExitCode() != 1 ||
+			!strings.Contains(string(output), "--- FAIL: TestX86Reciprocal14NativeGoListingBoundaryControls") ||
+			!strings.Contains(string(output), "original") {
+			t.Fatalf("corrupt Go listing was accepted or failed without its source-bound rejection: %s: %v\n%s", name, err, output)
+		}
+	}
+	t.Logf("two actual producer prefixes accepted; %d foreign package/TEXT/PC/source/extent controls rejected", len(mutations))
+}
+
+func TestX86Reciprocal14NativeExplicitOwnerPolicy(t *testing.T) {
+	data, err := os.ReadFile("x86_reciprocal14_native_linux_amd64_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.HasPrefix(data, []byte("//go:build linux && amd64 && plan9asm_native_avx512\n")) ||
+		strings.Count(string(data), "func TestX86Reciprocal14Native") != 2 ||
+		strings.Contains(string(data), "TestCrossLinuxRuntimeMatrix") || strings.Contains(string(data), ".Skip") {
+		t.Fatal("native execution owners escaped explicit hardware qualification")
+	}
+	_, file, _ := x86OriginalFloatingPolicyFile(t, "x86_reciprocal14_native_runtime_test.go")
+	owner := x86OriginalFloatingPolicyFunction(t, file, "x86RunReciprocal14Native")
+	var calls bytes.Buffer
+	if err := format.Node(&calls, token.NewFileSet(), owner); err != nil {
+		t.Fatal(err)
+	}
+	for _, required := range []string{"x86RunOriginalGoNativeSource", "x86NativeFixtureASMDecl", "x86ScalarFPBitViewAPI", "x86OriginalFloatingRuntimeRequireCPU", "x86DwordProductIROptimize", "x86Reciprocal14NativeTrace", "os.Chmod"} {
+		if !strings.Contains(calls.String(), required) {
+			t.Fatal("native owner lost an independent stage", required)
+		}
+	}
+}
+
+func TestX86Reciprocal14NativeOriginalGoProgramCompiles(t *testing.T) {
+	var rows []x86Reciprocal14NativeRow
+	for _, row := range x86Reciprocal14NativeRows() {
+		if row.dynamic || row.source == 0 && row.mode == 0 && row.low == 16 && row.upper == 17 &&
+			(row.width == 64 || x86Reciprocal14TestMembers[row.member].scalar) {
+			rows = append(rows, row)
+		}
+	}
+	source, declarations, _ := x86Reciprocal14NativeSource(rows, false)
+	x86NativeFixtureASMDecl(t, "amd64", declarations, source, "")
+	var cases strings.Builder
+	for _, row := range rows {
+		fmt.Fprintf(&cases, "{%d,6,65535,8064,8128},\n", row.id)
+	}
+	directory := t.TempDir()
+	original := strings.NewReplacer("@ROWS@", x86Reciprocal14NativeMetadata(rows, true),
+		"@CASES@", cases.String(), "@TRACE@", strconv.Quote(filepath.Join(directory, "unexecuted.trace"))).Replace(x86Reciprocal14NativeOriginalGo)
+	for name, data := range map[string]string{
+		"go.mod":        "module oracle\n\ngo 1.20\n",
+		"value.go":      "package oracle\n" + declarations + "func MXCSR(value uint32) uint32\n",
+		"value_amd64.s": source + x86OriginalNativeMXCSRSource("amd64"),
+		"value_test.go": original,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), []byte(data), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	driver, _ := x86LEAActualSDKDriver(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "test", "-p=1", "-c", "-o", filepath.Join(directory, "original.test"), ".")
+	command.Dir, command.Env = directory, x86OriginalGoNativeEnvironment("amd64", os.Environ())
+	if output, err := runtimeOracleCombinedOutput(ctx, command); err != nil {
+		t.Fatalf("actual original-Go trace program did not compile (not executed): %v\n%s", err, output)
+	}
+	if _, err := os.Stat(filepath.Join(directory, "unexecuted.trace")); !os.IsNotExist(err) {
+		t.Fatal("object-only fixture unexpectedly executed", err)
+	}
+}
+
+func TestX86Reciprocal14NativeSourceThreeAPIsActualProfileObjects(t *testing.T) {
+	for _, profile := range []int{5, 6} {
+		var rows []x86Reciprocal14NativeRow
+		for _, row := range x86Reciprocal14NativeRows() {
+			if row.profile() == profile {
+				rows = append(rows, row)
+			}
+		}
+		name := map[int]string{5: "estimate14-F", 6: "estimate14-FVL"}[profile]
+		for start := 0; start < len(rows); start += 32 {
+			end := start + 32
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("profile%d/batch%d", profile, start/32), func(t *testing.T) {
+				batch := rows[start:end]
+				source, declarations, _ := x86Reciprocal14NativeSource(batch, false)
+				listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86NativeFixtureASMDecl(t, "amd64", declarations, source, "")
+				// Disassemble exact original Go text bytes, including its transport.
+				// This is object inspection, not raw-source translator permission.
+				original := x86Reciprocal14NativeGoBytesIR(t, listing, batch)
+				x86OriginalFloatingOpcodeListing(t, name, "x86_64-unknown-linux-gnu", "-O0", original, true, 0)
+				masked := false
+				for _, row := range batch {
+					masked = masked || row.mode != 0
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil {
+							t.Fatal("full initialized native source rejected", err)
+						}
+						x86OriginalFloatingRuntimeObjectPipelines(t, name, "x86_64-unknown-linux-gnu", ir, masked, 0)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86Reciprocal14NativeDeadSourceOriginalBytesAndThreeAPIs(t *testing.T) {
+	for _, profile := range []int{5, 6} {
+		var rows []x86Reciprocal14NativeRow
+		for _, row := range x86Reciprocal14NativeRows() {
+			if row.id < 132 && row.source != 0 && row.profile() == profile {
+				rows = append(rows, row)
+			}
+		}
+		for start := 0; start < len(rows); start += 32 {
+			end := start + 32
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("profile%d/batch%d", profile, start/32), func(t *testing.T) {
+				source, declarations, fixture := x86Reciprocal14NativeFaultProgram(t, rows[start:end], profile)
+				if strings.Count(fixture, ".byte ") != end-start || strings.Contains(fixture, "vrcp14") || strings.Contains(fixture, "vrsqrt14") {
+					t.Fatal("fault reference must use complete actual Go bytes, not reconstructed mnemonics")
+				}
+				if root := os.Getenv("PLAN9ASM_RUNTIME_ARTIFACT_DIR"); root != "" {
+					path := filepath.Join(root, t.Name(), "fault.c")
+					if err := os.MkdirAll(filepath.Dir(path), 0700); err != nil {
+						t.Fatal(err)
+					}
+					if err := os.WriteFile(path, []byte(fixture), 0600); err != nil {
+						t.Fatal(err)
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil {
+							t.Fatal("dead native memory source rejected", err)
+						}
+						x86OriginalFloatingRuntimeObjectPipelines(t, map[int]string{5: "estimate14-F", 6: "estimate14-FVL"}[profile],
+							"x86_64-unknown-linux-gnu", ir, true, 0)
+					})
+				}
+			})
+		}
+	}
+}
+
+// The existing Go byte-column parser owns byte extraction. No instruction is
+// decoded, shortened or given numerical/address permission here; LLVM objdump
+// independently disassembles every copied byte for the finite ISA-profile audit.
+func x86Reciprocal14NativeGoBytesIR(t *testing.T, listing string, rows []x86Reciprocal14NativeRow,
+	inspect ...func(string, int, []byte)) string {
+	t.Helper()
+	var ir strings.Builder
+	ir.WriteString("target triple = \"x86_64-unknown-linux-gnu\"\n")
+	seen, owner, size, expected := make(map[string]bool), "", 0, 0
+	last := byte(0)
+	var body []byte
+	var instructions [][2]int
+	wanted := make(map[string]bool)
+	for _, row := range rows {
+		wanted[row.name()] = true
+	}
+	finish := func() {
+		if owner == "" {
+			return
+		}
+		if owner != "" && (size == 0 || size != expected || last != 0xc3) {
+			t.Fatal("original Go TEXT has no complete RET/size byte boundary", owner, size, expected)
+		}
+		for index, instruction := range instructions {
+			end := len(body)
+			if index+1 < len(instructions) {
+				end = instructions[index+1][0]
+			}
+			if instruction[0] < 0 || instruction[0] >= end || end > len(body) {
+				t.Fatal("original Go instruction has incomplete PC boundaries", owner, instruction, end)
+			}
+			for _, observer := range inspect {
+				observer(owner, instruction[1], append([]byte(nil), body[instruction[0]:end]...))
+			}
+		}
+	}
+	for _, line := range strings.Split(listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) > 1 && (fields[1] == "STEXT" || fields[1] == "STEXTFIPS") {
+			finish()
+			// Match the existing official-row binder: historical Go emits
+			// an empty package even with -p. No foreign package is accepted.
+			owner = strings.TrimPrefix(fields[0], "literal.")
+			if owner == fields[0] {
+				owner = strings.TrimPrefix(fields[0], `"".`)
+			}
+			if owner == fields[0] {
+				t.Fatal("foreign original Go package", fields[0])
+			}
+			size, expected = 0, 0
+			body, instructions = nil, nil
+			for _, field := range fields {
+				if strings.HasPrefix(field, "size=") {
+					n, err := strconv.Atoi(strings.TrimPrefix(field, "size="))
+					if err != nil || n <= 0 {
+						t.Fatal("invalid original Go TEXT extent", line)
+					}
+					expected = n
+				}
+			}
+			if !wanted[owner] || seen[owner] {
+				t.Fatal("foreign or duplicate original Go TEXT", owner)
+			}
+			seen[owner] = true
+			fmt.Fprintf(&ir, "module asm \".globl OriginalGo%d\"\nmodule asm \"OriginalGo%d:\"\n", len(seen), len(seen))
+			continue
+		}
+		if len(fields) >= 2 && strings.HasPrefix(fields[1], "S") && !strings.HasPrefix(fields[0], "0x") {
+			finish()
+			owner = ""
+		}
+		if owner == "" {
+			continue
+		}
+		if match := x86OfficialPackedListingInstruction.FindStringSubmatch(line); match != nil &&
+			match[4] != "TEXT" && match[4] != "PCDATA" && match[4] != "FUNCDATA" {
+			pc, pcErr := strconv.ParseUint(match[1], 16, 32)
+			decimal, decimalErr := strconv.ParseUint(match[2], 10, 32)
+			line, lineErr := strconv.Atoi(match[3])
+			if pcErr != nil || decimalErr != nil || lineErr != nil || pc != decimal ||
+				len(instructions) != 0 && int(pc) <= instructions[len(instructions)-1][0] {
+				t.Fatal("invalid original Go instruction position", match)
+			}
+			instructions = append(instructions, [2]int{int(pc), line})
+		}
+		code := x86InsertExtractListedBytes(line)
+		if len(code) == 0 {
+			continue
+		}
+		pc, err := strconv.ParseUint(strings.TrimPrefix(fields[0], "0x"), 16, 32)
+		if owner == "" || err != nil || int(pc) != size {
+			t.Fatal("noncontiguous original Go byte ownership", line)
+		}
+		ir.WriteString("module asm \".byte ")
+		for index, b := range code {
+			if index != 0 {
+				ir.WriteByte(',')
+			}
+			fmt.Fprintf(&ir, "0x%02x", b)
+		}
+		ir.WriteString("\"\n")
+		size += len(code)
+		body = append(body, code...)
+		last = code[len(code)-1]
+	}
+	finish()
+	if len(seen) != len(rows) {
+		t.Fatal("original Go byte directory incomplete", len(seen), len(rows))
+	}
+	return ir.String()
+}
diff --git a/x86_reciprocal14_native_runtime_test.go b/x86_reciprocal14_native_runtime_test.go
new file mode 100644
index 000000000..b3d770e24
--- /dev/null
+++ b/x86_reciprocal14_native_runtime_test.go
@@ -0,0 +1,454 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// The finite execution directory is independent of the production grammar.
+// Canonical shapes come first; aliases and dynamic-environment controls do not
+// change the official 132-shape denominator.
+type x86Reciprocal14NativeRow struct {
+	id, member, width, source, mode, low, upper int
+	dynamic                                     bool
+}
+
+func x86Reciprocal14NativeRows() []x86Reciprocal14NativeRow {
+	var rows []x86Reciprocal14NativeRow
+	for member, op := range x86Reciprocal14TestMembers {
+		for _, width := range []int{16, 32, 64} {
+			if op.scalar && width != 16 {
+				continue
+			}
+			for source := 0; source < 3; source++ {
+				if op.scalar && source == 2 {
+					continue
+				}
+				for mode := 0; mode < 3; mode++ {
+					rows = append(rows, x86Reciprocal14NativeRow{
+						member: member, width: width, source: source,
+						mode: mode, low: 16, upper: 17,
+					})
+				}
+			}
+		}
+	}
+	canonical := append([]x86Reciprocal14NativeRow(nil), rows...)
+	for _, row := range canonical {
+		if row.source == 0 {
+			aliases := [][2]int{{18, 17}}
+			if x86Reciprocal14TestMembers[row.member].scalar {
+				aliases = [][2]int{{18, 17}, {16, 18}, {17, 17}, {18, 18}}
+			}
+			for _, alias := range aliases {
+				copy := row
+				copy.low, copy.upper = alias[0], alias[1]
+				rows = append(rows, copy)
+			}
+		} else if x86Reciprocal14TestMembers[row.member].scalar {
+			row.upper = 18
+			rows = append(rows, row)
+		}
+	}
+	for member, op := range x86Reciprocal14TestMembers {
+		width := 64
+		if op.scalar {
+			width = 16
+		}
+		rows = append(rows, x86Reciprocal14NativeRow{
+			member: member, width: width, low: 16, upper: 17, dynamic: true,
+		})
+	}
+	for index := range rows {
+		rows[index].id = index
+	}
+	return rows
+}
+
+func (row x86Reciprocal14NativeRow) profile() int {
+	if !x86Reciprocal14TestMembers[row.member].scalar && row.width != 64 {
+		return 6
+	}
+	return 5
+}
+
+func (row x86Reciprocal14NativeRow) name() string { return fmt.Sprintf("R14%d", row.id) }
+
+func (row x86Reciprocal14NativeRow) instruction() string {
+	member := x86Reciprocal14TestMembers[row.member]
+	op, input := member.op, "(AX)"
+	bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[row.width]
+	if row.source == 0 {
+		input = fmt.Sprintf("%s%d", bank, row.low)
+	} else if row.source == 2 {
+		op += ".BCST"
+	}
+	if row.mode == 2 {
+		op += ".Z"
+	}
+	operands := input + ","
+	if member.scalar {
+		operands += fmt.Sprintf("X%d,", row.upper)
+	}
+	if row.mode != 0 {
+		operands += "K1,"
+	}
+	return op + " " + operands + bank + "18"
+}
+
+func x86Reciprocal14NativeSource(rows []x86Reciprocal14NativeRow, dead bool) (string, string, string) {
+	var source, declarations, prototypes strings.Builder
+	for _, row := range rows {
+		name := row.name()
+		fmt.Fprintf(&declarations, "func %s(out *[160]byte,input,upper,old *[64]byte,mask uint64,first,second uint32)\n", name)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint64_t,uint32_t,uint32_t);\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-48\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),AX\n"+
+			"MOVQ upper+16(FP),BX\nMOVQ old+24(FP),CX\nVMOVUPS (BX),Z17\nVMOVUPS (CX),Z18\n", name)
+		if row.source == 0 {
+			fmt.Fprintf(&source, "VMOVUPS (AX),Z%d\n", row.low)
+		}
+		// Z-width moves and KMOVW are deliberate: original Go execution must
+		// not acquire narrow-VL or KMOVQ/BW requirements from its transport.
+		source.WriteString("MOVQ mask+32(FP),DX\nKMOVW DX,K1\nSTMXCSR 128(DI)\nLDMXCSR first+40(FP)\n" +
+			"MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\nSTD\n")
+		source.WriteString(row.instruction() + "\nPUSHFQ\nPOPQ DX\nANDL $0xcd5,DX\nCLD\nMOVL DX,132(DI)\nSTMXCSR 136(DI)\n")
+		if !dead {
+			source.WriteString("VMOVUPS Z18,(DI)\n")
+		}
+		if row.dynamic {
+			// Reloading inputs would hide same-input CSE across LDMXCSR.
+			source.WriteString("LDMXCSR second+44(FP)\nMOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\nSTD\n" +
+				row.instruction() + "\nPUSHFQ\nPOPQ DX\nANDL $0xcd5,DX\nCLD\n" +
+				"MOVL DX,144(DI)\nSTMXCSR 140(DI)\nVMOVUPS Z18,64(DI)\n")
+		}
+		source.WriteString("LDMXCSR 128(DI)\nVZEROUPPER\nRET\n")
+	}
+	return source.String(), declarations.String(), prototypes.String()
+}
+
+type x86Reciprocal14NativeCase struct {
+	row, sample   int
+	mask          uint64
+	first, second uint32
+}
+
+func x86Reciprocal14NativeCases(rows []x86Reciprocal14NativeRow) []x86Reciprocal14NativeCase {
+	var cases []x86Reciprocal14NativeCase
+	environments := make(map[int]bool)
+	for _, row := range rows {
+		member := x86Reciprocal14TestMembers[row.member]
+		lanes := row.width * 8 / member.bits
+		if member.scalar {
+			lanes = 1
+		}
+		if row.dynamic {
+			cases = append(cases, x86Reciprocal14NativeCase{row.id, 6, 0xffff, 0x1f80, 0x1fc0})
+			if row.member < 4 {
+				cases = append(cases, x86Reciprocal14NativeCase{row.id, 16, 0xffff, 0x1f80, 0x9f80})
+			}
+			continue
+		}
+		for _, sample := range []int{0, 6, 10, 22} {
+			for _, mask := range []uint64{0, 0xffff, 0x5555, 1, 1 << (lanes - 1), 1 << lanes} {
+				cases = append(cases, x86Reciprocal14NativeCase{row.id, sample, mask, 0x1f80, 0x1f80})
+			}
+		}
+		if row.source != 0 || row.mode != 0 || row.low != 16 || row.upper != 17 ||
+			!member.scalar && row.width == 32 || environments[row.member] {
+			continue
+		}
+		environments[row.member] = true
+		for sample := 0; sample < 24; sample++ {
+			for control := uint32(0); control < 64; control++ {
+				csr := (control&3)<<13 | (control&4)<<4 | (control&8)<<12
+				if control&16 != 0 {
+					csr |= 0x3f
+				}
+				if control&32 != 0 {
+					csr |= 0x1f80
+				}
+				cases = append(cases, x86Reciprocal14NativeCase{row.id, sample, 0xffff, csr, csr})
+			}
+		}
+	}
+	return cases
+}
+
+func x86Reciprocal14NativeTrace(data []byte, cases []x86Reciprocal14NativeCase) error {
+	const header, record = 16, 184
+	if len(data) != header+record*len(cases) || len(data) < header || !bytes.Equal(data[:8], []byte("R14TRACE")) {
+		return fmt.Errorf("incomplete or foreign original-Go trace")
+	}
+	if binary.LittleEndian.Uint32(data[8:]) != 1 || int(binary.LittleEndian.Uint32(data[12:])) != len(cases) {
+		return fmt.Errorf("original-Go trace protocol/count differs")
+	}
+	for index, c := range cases {
+		r := data[header+index*record : header+(index+1)*record]
+		if int(binary.LittleEndian.Uint32(r)) != c.row || int(binary.LittleEndian.Uint32(r[4:])) != c.sample ||
+			binary.LittleEndian.Uint64(r[8:]) != c.mask || binary.LittleEndian.Uint32(r[16:]) != c.first ||
+			binary.LittleEndian.Uint32(r[20:]) != c.second {
+			return fmt.Errorf("original-Go trace case %d has foreign identity/order", index)
+		}
+	}
+	return nil
+}
+
+func x86Reciprocal14NativeMetadata(rows []x86Reciprocal14NativeRow, goSyntax bool) string {
+	var b strings.Builder
+	for _, row := range rows {
+		member := x86Reciprocal14TestMembers[row.member]
+		dynamic := 0
+		if row.dynamic {
+			dynamic = 1
+		}
+		if goSyntax {
+			fmt.Fprintf(&b, "{%d,%d,%d,%d,%d,%d,%d,%d,%d,%s},\n", row.id, row.member, member.bits,
+				row.width, row.source, row.mode, row.low, row.upper, dynamic, row.name())
+		} else {
+			fmt.Fprintf(&b, "{%d,%s,%d},\n", row.id, row.name(), member.bits)
+		}
+	}
+	return b.String()
+}
+
+// This is the one existing native process/LLVM driver, not a new runner.
+// Only explicitly tagged roots call it; default owners below validate source,
+// trace controls and actual objects without claiming native execution.
+func x86RunReciprocal14Native(t *testing.T, profile int) {
+	t.Helper()
+	if runtime.GOOS != "linux" || runtime.GOARCH != "amd64" || profile != 5 && profile != 6 {
+		t.Fatal("RCP14 native qualification requires direct Linux/AMD64 and its exact profile")
+	}
+	if os.Getenv("PLAN9ASM_AVX512_RUNTIME") == "auto" {
+		t.Fatal("explicit RCP14 native qualification is required; auto cannot skip hardware acceptance")
+	}
+	execution := x86FloatCompareExecutionTools(t)
+	if execution.triple != "x86_64-unknown-linux-gnu" || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("RCP14 native qualification cannot use foreign or emulated execution")
+	}
+	x86FloatCompareVerifyArguments(t, execution)
+	preflight := map[int]string{5: "estimate14-F", 6: "estimate14-FVL"}[profile]
+	x86OriginalFloatingRuntimeRequireCPU(t, preflight, execution.compiler[0], execution.triple, nil)
+	var selected []x86Reciprocal14NativeRow
+	for _, row := range x86Reciprocal14NativeRows() {
+		if row.profile() == profile {
+			selected = append(selected, row)
+		}
+	}
+	for start := 0; start < len(selected); start += 32 {
+		end := start + 32
+		if end > len(selected) {
+			end = len(selected)
+		}
+		rows := selected[start:end]
+		t.Run(fmt.Sprintf("batch%d", start/32), func(t *testing.T) {
+			source, declarations, prototypes := x86Reciprocal14NativeSource(rows, false)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			x86NativeFixtureASMDecl(t, "amd64", declarations, source, "")
+			cases := x86Reciprocal14NativeCases(rows)
+			trace := filepath.Join(t.TempDir(), "original.trace")
+			var caseSource strings.Builder
+			for _, c := range cases {
+				fmt.Fprintf(&caseSource, "{%d,%d,%d,%d,%d},\n", c.row, c.sample, c.mask, c.first, c.second)
+			}
+			original := strings.NewReplacer("@ROWS@", x86Reciprocal14NativeMetadata(rows, true),
+				"@CASES@", caseSource.String(), "@TRACE@", strconv.Quote(trace)).Replace(x86Reciprocal14NativeOriginalGo)
+			t.Run("OriginalGo", func(t *testing.T) {
+				x86RunOriginalGoNativeSource(t, execution, "amd64", "package oracle\n"+declarations+
+					"func MXCSR(value uint32) uint32\n", source+x86OriginalNativeMXCSRSource("amd64"), original)
+			})
+			data, err := os.ReadFile(trace)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := x86Reciprocal14NativeTrace(data, cases); err != nil {
+				t.Fatal(err)
+			}
+			if err := os.Chmod(trace, 0400); err != nil {
+				t.Fatal(err)
+			}
+			identity := sha256.Sum256(data)
+			t.Logf("actual original-Go RCP14 sourceSHA=%x traceSHA=%x rows=%d cases=%d profile=%d",
+				sha256.Sum256([]byte(source)), identity, len(rows), len(cases), profile)
+			mainC := strings.NewReplacer("@PROTOTYPES@", prototypes, "@ROWS@", x86Reciprocal14NativeMetadata(rows, false),
+				"@TRACE@", strconv.Quote(trace), "@COUNT@", strconv.Itoa(len(cases))).Replace(x86Reciprocal14NativeValuesC)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal("complete original native source rejected", err)
+					}
+					for _, pipeline := range []struct{ name, body, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2/backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							executable := x86Reciprocal14NativeObject(t, execution, profile, "rcp14-native-values",
+								source, declarations, pipeline.body, mainC, pipeline.level)
+							output := execution.run(t, executable)
+							if string(output) != fmt.Sprintf("RCP14 native original-Go bits cases=%d failures=0\n", len(cases)) {
+								t.Fatal("native original-Go bit comparison lacks its complete terminal", string(output))
+							}
+							current, err := os.ReadFile(trace)
+							if err != nil || sha256.Sum256(current) != identity {
+								t.Fatal("original trace changed", err)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+	x86Reciprocal14NativeFaults(t, execution, profile)
+}
+
+func x86Reciprocal14NativeFaults(t *testing.T, execution x86FloatCompareExecution, profile int) {
+	t.Helper()
+	var rows []x86Reciprocal14NativeRow
+	for _, row := range x86Reciprocal14NativeRows() {
+		if row.id < 132 && row.source != 0 && row.profile() == profile {
+			rows = append(rows, row)
+		}
+	}
+	for start := 0; start < len(rows); start += 32 {
+		end := start + 32
+		if end > len(rows) {
+			end = len(rows)
+		}
+		batch := rows[start:end]
+		t.Run(fmt.Sprintf("faultBatch%d", start/32), func(t *testing.T) {
+			source, declarations, mainC := x86Reciprocal14NativeFaultProgram(t, batch, profile)
+			original := make(map[[2]int]string)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+					if err != nil {
+						t.Fatal("dead native RCP14 fault source rejected", err)
+					}
+					for _, pipeline := range []struct{ name, body, level string }{
+						{"backend_O0", ir, "-O0"}, {"backend_O2", ir, "-O2"},
+						{"IR_O2/backend_O2", x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							executable := x86Reciprocal14NativeObject(t, execution, profile, "rcp14-native-faults",
+								source, declarations, pipeline.body, mainC, pipeline.level)
+							for rowIndex, row := range batch {
+								for probe := 0; probe < 10; probe++ {
+									key := [2]int{rowIndex, probe}
+									want, seen := original[key]
+									if !seen {
+										want = x86ObserveMemoryFault(t, execution, executable, rowIndex, probe, 1)
+										original[key] = want
+									}
+									member := x86Reciprocal14TestMembers[row.member]
+									fullSpan := !member.scalar && row.source != 2 && row.width > member.bits/8
+									fault := probe == 2 || probe == 4 || probe == 6 || probe == 7 ||
+										row.mode == 0 && (probe < 2 || probe == 5 && fullSpan)
+									if fault && want != "segv" && want != "bus" || !fault && want != "return" {
+										t.Fatal("original RCP14 fault semantics differ", row.id, probe, want)
+									}
+									if got := x86ObserveMemoryFault(t, execution, executable, rowIndex, probe, 0); got != want {
+										t.Fatal("RCP14 dead native memory fault mismatch", row.id, probe, got, want)
+									}
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86Reciprocal14NativeFaultProgram(t *testing.T, batch []x86Reciprocal14NativeRow, profile int) (string, string, string) {
+	t.Helper()
+	source, declarations, prototypes := x86Reciprocal14NativeSource(batch, true)
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	x86NativeFixtureASMDecl(t, "amd64", declarations, source, "")
+	listing, err := x86ScalarLiteralGoListing(t, "amd64", source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	operationLines := make(map[int]x86Reciprocal14NativeRow)
+	for _, row := range batch {
+		found := 0
+		for line, instruction := range strings.Split(source, "\n") {
+			if instruction == row.instruction() {
+				operationLines[line+1] = row
+				found++
+			}
+		}
+		if found != 1 {
+			t.Fatal("original fault instruction lost unique source ownership", row.id, found)
+		}
+	}
+	originalBytes := make(map[int][]byte)
+	x86Reciprocal14NativeGoBytesIR(t, listing, batch, func(owner string, line int, code []byte) {
+		if row, exists := operationLines[line]; exists {
+			if owner != row.name() || len(originalBytes[row.id]) != 0 {
+				t.Fatal("original fault bytes have foreign/duplicate owner", owner, line)
+			}
+			originalBytes[row.id] = code
+		}
+	})
+	var directory, nativeAsm strings.Builder
+	for _, row := range batch {
+		member := x86Reciprocal14TestMembers[row.member]
+		lane, lanes, extent := member.bits/8, row.width*8/member.bits, row.width
+		if member.scalar {
+			lanes, extent = 1, lane
+		}
+		if row.source == 2 {
+			extent = lane
+		}
+		fmt.Fprintf(&directory, "{%d,%s,%d,%d,%d,%d},\n", row.id, row.name(), extent, lane, lanes, row.mode)
+		code := originalBytes[row.id]
+		if len(code) == 0 {
+			t.Fatal("actual original Go fault bytes absent", row.id)
+		}
+		var encoded strings.Builder
+		for index, b := range code {
+			if index != 0 {
+				encoded.WriteByte(',')
+			}
+			fmt.Fprintf(&encoded, "0x%02x", b)
+		}
+		asm := "kmovw %1,%%k1; vpxord %%zmm17,%%zmm17,%%zmm17; vpxord %%zmm18,%%zmm18,%%zmm18; .byte " + encoded.String()
+		// Go's selected original r/m operand is exactly (AX). The
+		// fixed a constraint supplies that machine address; it grants
+		// no new numerical pointer/array capability to translation.
+		fmt.Fprintf(&nativeAsm, "case %d: __asm__ volatile(%s::\"a\"(input),\"r\"(mask):\"zmm17\",\"zmm18\",\"k1\",\"memory\");break;\n", row.id, strconv.Quote(asm))
+	}
+	features := "avx512f"
+	if profile == 6 {
+		features += ",avx512vl"
+	}
+	mainC := x86MemoryFaultSupportC + prototypes + strings.NewReplacer("@ROWS@", directory.String(),
+		"@ORIGINAL@", nativeAsm.String(), "@FEATURES@", features).Replace(x86Reciprocal14NativeFaultsC)
+	return source, declarations, mainC
+}
+
+func x86Reciprocal14NativeObject(t *testing.T, execution x86FloatCompareExecution, profile int,
+	name, source, declarations, ir, mainC, level string) string {
+	t.Helper()
+	executable := execution.compileLLVM(t, name, ir, mainC, level)
+	object := filepath.Join(filepath.Dir(executable), name+".o")
+	objdump := findLLVM22Tool("llvm-objdump")
+	if objdump == "" {
+		t.Fatal("LLVM22 llvm-objdump required for actual native ISA acceptance")
+	}
+	listing := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "-d", object))
+	x86OriginalFloatingAuditListing(t, map[int]string{5: "estimate14-F", 6: "estimate14-FVL"}[profile],
+		execution.triple, level, strings.ToLower(string(listing)), false, 0)
+	x86Reciprocal14RetainObject(t, source, declarations, ir, object, listing)
+	return executable
+}
diff --git a/x86_reciprocal14_official_addresses_test.go b/x86_reciprocal14_official_addresses_test.go
new file mode 100644
index 000000000..d42a33a1d
--- /dev/null
+++ b/x86_reciprocal14_official_addresses_test.go
@@ -0,0 +1,336 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Keep the actual SDK source operands, including SP, repeated base/index,
+// negative displacements and non-K1 masks. Canonical row witnesses do not
+// establish initialized entry or memory authority for these original operands.
+func x86Reciprocal14OfficialOriginalInstructions(t *testing.T) []string {
+	t.Helper()
+	path := filepath.Join(runtime.GOROOT(), "src", "cmd", "asm", "internal", "asm", "testdata", "avx512enc", "avx512f.s")
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	members := make(map[string]bool)
+	for _, member := range x86Reciprocal14TestMembers {
+		members[member.op] = true
+	}
+	var instructions []string
+	for _, line := range strings.Split(string(data), "\n") {
+		line, _, _ = strings.Cut(line, "//")
+		line = strings.TrimSpace(line)
+		fields := strings.Fields(line)
+		if len(fields) != 0 && members[fields[0]] {
+			instructions = append(instructions, line)
+		}
+	}
+	if len(instructions) != 68 {
+		t.Fatal("complete original reciprocal14 SDK source denominator changed", len(instructions))
+	}
+	return instructions
+}
+
+func TestX86Reciprocal14OriginalEncodingWholeBoundaries(t *testing.T) {
+	legacy, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86Reciprocal14Rows(legacy, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	count := 0
+	for _, row := range rows {
+		for _, witness := range row.Witnesses {
+			count++
+			t.Run(fmt.Sprint(count), func(t *testing.T) {
+				if length, err := x86NumericalVectorBoundary(witness.Encoding, 64); err != nil || length != len(witness.Encoding) {
+					t.Fatalf("original %s boundary %x: length=%d err=%v", witness.Instruction, witness.Encoding, length, err)
+				}
+				for _, mutation := range []string{"truncated", "fixed bit", "zero without mask", "reserved source"} {
+					changed := append([]byte(nil), witness.Encoding...)
+					switch mutation {
+					case "truncated":
+						changed = changed[:len(changed)-1]
+					case "fixed bit":
+						changed[2] &^= 4
+					case "zero without mask":
+						changed[3] = changed[3]&^7 | 0x80
+					case "reserved source":
+						if strings.HasSuffix(row.Opcode, "SS") || strings.HasSuffix(row.Opcode, "SD") {
+							changed[3] |= 0x10 // Scalar encodings have no broadcast/rounding field.
+						} else {
+							changed[2] &^= 8 // Unary packed encodings reserve vvvv and V'.
+						}
+					}
+					if _, err := x86NumericalVectorBoundary(changed, 64); err == nil {
+						t.Fatal("changed bytes borrowed complete original boundary", mutation, witness.Instruction)
+					}
+				}
+			})
+		}
+	}
+	if len(rows) != 32 || count != 132 {
+		t.Fatal("complete reciprocal14 row/boundary denominator changed", len(rows), count)
+	}
+}
+
+func x86Reciprocal14OriginalRegisterInputs(t *testing.T, instruction string, privateFrame bool) (Instr, string) {
+	t.Helper()
+	ins := x86ScalarLaneInstruction(t, instruction)
+	vectors, masks := make(map[int]bool), make(map[string]bool)
+	for _, arg := range ins.Args {
+		if arg.Kind != OpReg {
+			continue
+		}
+		if amd64IsKOperand(arg) {
+			masks[string(arg.Reg)] = true
+			continue
+		}
+		if index, valid := amd64VectorRegisterIndex(arg.Reg, amd64VectorByteWidth(arg.Reg)); valid {
+			vectors[index] = true
+		}
+	}
+	var indices []int
+	for index := range vectors {
+		indices = append(indices, index)
+	}
+	sort.Ints(indices)
+	var source strings.Builder
+	for _, index := range indices {
+		if privateFrame {
+			fmt.Fprintf(&source, "VMOVUPS 0(SP),Z%d\n", index)
+		} else {
+			fmt.Fprintf(&source, "VPXORD Z%d,Z%d,Z%d\n", index, index, index)
+		}
+	}
+	var maskNames []string
+	for mask := range masks {
+		maskNames = append(maskNames, mask)
+	}
+	sort.Strings(maskNames)
+	for _, mask := range maskNames {
+		fmt.Fprintf(&source, "MOVQ $65535,AX\nKMOVQ AX,%s\n", mask)
+	}
+	return ins, source.String()
+}
+
+func x86Reciprocal14OriginalCallerSource(t *testing.T, instruction string) (string, string) {
+	t.Helper()
+	ins, setup := x86Reciprocal14OriginalRegisterInputs(t, instruction, false)
+	var body strings.Builder
+	body.WriteString(setup)
+	if first := ins.Args[0]; first.Kind == OpMem {
+		fmt.Fprintf(&body, "MOVQ input+8(FP),%s\nLEAQ 128(%s),%s\n", first.Mem.Base, first.Mem.Base, first.Mem.Base)
+		if first.Mem.Index != "" && first.Mem.Index != first.Mem.Base {
+			fmt.Fprintf(&body, "MOVQ $0,%s\n", first.Mem.Index)
+		}
+	}
+	body.WriteString(instruction + "\n")
+	destination := ins.Args[len(ins.Args)-1].Reg
+	fmt.Fprintf(&body, "MOVQ out+0(FP),DI\nVMOVUPS %s,(DI)\nRET\n", destination)
+	return "TEXT ·Original(SB),4,$0-16\n" + body.String(), "func Original(out,input *[512]byte)\n"
+}
+
+func TestX86Reciprocal14OriginalGPAndRegisterOperandsThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	count := 0
+	for index, instruction := range x86Reciprocal14OfficialOriginalInstructions(t) {
+		ins := x86ScalarLaneInstruction(t, instruction)
+		if ins.Args[0].Kind == OpMem && (ins.Args[0].Mem.Base == SP || ins.Args[0].Mem.Base == BP) {
+			continue // The captured private-frame owner below owns SP and BP.
+		}
+		if first := ins.Args[0]; first.Kind == OpMem && first.Mem.Index == first.Mem.Base {
+			continue // The independent pending-address boundary below owns both originals.
+		}
+		count++
+		t.Run(fmt.Sprintf("source%02d", index), func(t *testing.T) {
+			source, declaration := x86Reciprocal14OriginalCallerSource(t, instruction)
+			t.Logf("original=%q initializedSource=%q declaration=%q", instruction, source, declaration)
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil {
+						t.Fatalf("initialized original operand source %q: %v", instruction, err)
+					}
+					x86ResultInitializationObject(t, llc, "x86_64-unknown-linux-gnu", ir, api)
+				})
+			}
+		})
+	}
+	if count != 60 {
+		t.Fatal("original GP/register source denominator changed", count)
+	}
+}
+
+func TestX86Reciprocal14OriginalRepeatedPointerIndexRemainsContext(t *testing.T) {
+	count := 0
+	for _, instruction := range x86Reciprocal14OfficialOriginalInstructions(t) {
+		ins := x86ScalarLaneInstruction(t, instruction)
+		first := ins.Args[0]
+		if first.Kind != OpMem || first.Mem.Index == "" || first.Mem.Index != first.Mem.Base {
+			continue
+		}
+		count++
+		t.Run(fmt.Sprint(count), func(t *testing.T) {
+			source, declaration := x86Reciprocal14OriginalCallerSource(t, instruction)
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			// An initialized opaque pointer is not a NUM index or a proof that
+			// 3*pointer+99 belongs to its input array. Keep both exact originals
+			// pending a separate paired-native machine-address contract.
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "result initialization") {
+					t.Fatal("repeated opaque pointer index acquired an unproved native address", instruction, api, err)
+				}
+			}
+			t.Logf("PENDING_NATIVE_ADDRESS original=%q source=%q; no positive LLVM object or runtime claim", instruction, source)
+		})
+	}
+	if count != 2 {
+		t.Fatal("exact repeated-pointer address boundary denominator changed", count)
+	}
+}
+
+func TestX86Reciprocal14OriginalSPAndBPHaveCapturedInitializedFrame(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	count := 0
+	for _, instruction := range x86Reciprocal14OfficialOriginalInstructions(t) {
+		ins, setup := x86Reciprocal14OriginalRegisterInputs(t, instruction, true)
+		if ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != SP && ins.Args[0].Mem.Base != BP {
+			continue
+		}
+		count++
+		t.Run(fmt.Sprint(count), func(t *testing.T) {
+			var stores strings.Builder
+			for offset := 0; offset < 80; offset += 8 {
+				fmt.Fprintf(&stores, "MOVQ $0,%d(SP)\n", offset)
+			}
+			if ins.Args[0].Mem.Base == BP {
+				stores.WriteString("MOVQ SP,BP\nADDQ $48,BP\nMOVQ $0,SI\n")
+			}
+			pkg, request, _, options := fixedLocalFrameFixture(t, stores.String()+setup+instruction)
+			original, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+			if err != nil {
+				t.Fatal(err)
+			}
+			t.Logf("original=%q initializedCapturedSource=%q", instruction, original)
+			fixedLocalFreshAPIs(t, pkg, request, options, []string{"Translate", "Module", "GoModule"}, func(t *testing.T, ir string, err error) {
+				if err != nil {
+					t.Fatalf("original SP operand %q lost captured initialized frame: %v", instruction, err)
+				}
+				x86ResultInitializationObject(t, llc, options.TargetTriple, ir, "frame")
+			})
+		})
+	}
+	if count != 6 {
+		t.Fatal("original physical-SP source denominator changed", count)
+	}
+}
+
+func TestX86Reciprocal14FixedLocalTypedRolesRetainAllInputsAndStorage(t *testing.T) {
+	const frameBytes, vectorSeed = 320, 128
+	var original strings.Builder
+	for index, member := range x86Reciprocal14TestMembers {
+		bank := "Z"
+		if member.scalar {
+			bank = "X"
+		}
+		instruction := x86Reciprocal14TestInstruction(member.op, "16(SP)", bank, "merge", member.scalar)
+		_, setup := x86Reciprocal14OriginalRegisterInputs(t, instruction, true)
+		var stores strings.Builder
+		for offset := 0; offset < 80; offset += 8 {
+			fmt.Fprintf(&stores, "MOVQ $0,%d(SP)\n", offset)
+		}
+		// Keep vector seeds independent of the numerical source tuple. Removing
+		// a source byte must fail at RCP14, not at an earlier initializer load.
+		for offset := vectorSeed; offset < vectorSeed+64; offset += 8 {
+			fmt.Fprintf(&stores, "MOVQ $0,%d(SP)\n", offset)
+		}
+		setup = strings.ReplaceAll(setup, "VMOVUPS 0(SP),", fmt.Sprintf("VMOVUPS %d(SP),", vectorSeed))
+		source, signature, _ := x86PrivateAlignedFrameAuditFixture(t, stores.String()+setup+instruction)
+		source = strings.Replace(source, "$160-40", fmt.Sprintf("$%d-40", frameBytes), 1)
+		original.WriteString(strings.Replace(source, "·Value", fmt.Sprintf("·Value%d", index), 1))
+		for _, mutation := range []string{"complete", "mask", "old destination", "upper source", "memory byte", "outside frame", "raw"} {
+			if mutation == "upper source" && !member.scalar {
+				continue
+			}
+			t.Run(member.op+"/"+mutation, func(t *testing.T) {
+				candidate := source
+				switch mutation {
+				case "mask":
+					candidate = strings.Replace(candidate, "KMOVQ AX,K1\n", "", 1)
+				case "old destination":
+					candidate = strings.Replace(candidate, fmt.Sprintf("VMOVUPS %d(SP),Z18\n", vectorSeed), "", 1)
+				case "upper source":
+					candidate = strings.Replace(candidate, fmt.Sprintf("VMOVUPS %d(SP),Z17\n", vectorSeed), "", 1)
+				case "memory byte":
+					candidate = strings.Replace(candidate, "MOVQ AX,16(SP)\n", "", 1)
+					candidate = strings.Replace(candidate, "MOVQ $0,16(SP)\n", "", 1)
+				case "outside frame":
+					outside := strings.Replace(instruction, "16(SP)", fmt.Sprintf("%d(SP)", frameBytes+16), 1)
+					candidate = strings.Replace(candidate, instruction, outside, 1)
+				}
+				if mutation != "complete" && mutation != "raw" && candidate == source {
+					t.Fatal("negative source did not change", mutation)
+				}
+				file, err := Parse(ArchAMD64, candidate)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if mutation == "raw" {
+					for index := range file.Funcs[0].Instrs {
+						if string(file.Funcs[0].Instrs[index].Op) == member.op {
+							file.Funcs[0].Instrs[index].x86Encoded = true
+						}
+					}
+				}
+				_, err = proveX86FixedLocal(file.Funcs[0], signature)
+				if mutation == "complete" {
+					if err != nil {
+						t.Fatal("complete typed reciprocal14 frame rejected", err)
+					}
+				} else if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("missing input or foreign memory role obtained a private certificate", mutation, err)
+				}
+				if mutation == "memory byte" && !strings.Contains(err.Error(), "undefined or relocated private bytes") {
+					t.Fatal("isolated source byte did not reach the numerical memory read guard", err)
+				}
+				if mutation == "outside frame" && !strings.Contains(err.Error(), "access crosses storage") {
+					t.Fatal("outside-frame source did not reach the actual storage bound", err)
+				}
+			})
+		}
+	}
+	requireX86GoAssemblerResult(t, "amd64", original.String(), true)
+	for _, member := range x86FloatingHelperOracleMembers() {
+		ins := x86ScalarLaneInstruction(t, x86FloatingHelperOracleInstruction(member, false))
+		effect, known, err := x86TypedFloatingHelperByteEffect(ins.Op, ins, "amd64")
+		if !known || err != nil || effect.vector.memoryAlignment != 0 {
+			t.Fatal("reciprocal14 metadata widened another native helper's private storage role", member.name, err)
+		}
+	}
+}
diff --git a/x86_reciprocal14_typed_family_test.go b/x86_reciprocal14_typed_family_test.go
new file mode 100644
index 000000000..8541cfb5d
--- /dev/null
+++ b/x86_reciprocal14_typed_family_test.go
@@ -0,0 +1,334 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var x86Reciprocal14TestMembers = []struct {
+	op     string
+	bits   int
+	scalar bool
+}{
+	{"VRCP14PS", 32, false}, {"VRCP14PD", 64, false},
+	{"VRCP14SS", 32, true}, {"VRCP14SD", 64, true},
+	{"VRSQRT14PS", 32, false}, {"VRSQRT14PD", 64, false},
+	{"VRSQRT14SS", 32, true}, {"VRSQRT14SD", 64, true},
+}
+
+func TestX86OfficialReciprocal14RowsInitializedThreeAPIsObjects(t *testing.T) {
+	x86OfficialPackedRowsObjects(t, goasmrules.X86Reciprocal14Rows, 32, 132, 0)
+}
+
+func TestX86Reciprocal14FeatureProjection(t *testing.T) {
+	for _, member := range x86Reciprocal14TestMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if member.scalar && bank != "X" {
+				continue
+			}
+			instruction := x86Reciprocal14TestInstruction(member.op, bank+"16", bank, "plain", member.scalar)
+			ins := x86ScalarLaneInstruction(t, instruction)
+			features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", Func{Instrs: []Instr{ins}})
+			if !strings.Contains(features, "+avx512f") || strings.Contains(features, "+avx512vl") != (!member.scalar && bank != "Z") {
+				t.Errorf("feature projection does not follow the complete source shape: %s: %s", instruction, features)
+			}
+		}
+	}
+}
+
+func x86Reciprocal14TestInstruction(op, source, bank, mode string, scalar bool) string {
+	operands := source + ","
+	if scalar {
+		operands += "X17,"
+	}
+	if mode != "plain" {
+		operands += "K1,"
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	return op + " " + operands + bank + "18"
+}
+
+func TestX86Reciprocal14TypedCompleteFamilyRoles(t *testing.T) {
+	for _, member := range x86Reciprocal14TestMembers {
+		banks := []string{"X", "Y", "Z"}
+		if member.scalar {
+			banks = banks[:1]
+		}
+		for _, bank := range banks {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				for _, memory := range []bool{false, true} {
+					source := bank + "16"
+					if memory {
+						source = "(AX)"
+					}
+					instruction := x86Reciprocal14TestInstruction(member.op, source, bank, mode, member.scalar)
+					t.Run(instruction, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, instruction)
+						effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+						if !known || err != nil || !effect.requiresResultProof || effect.vector.upperWrite != x86TypedVectorUpperZero ||
+							effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+							t.Fatal("complete reciprocal14 has no precise typed owner", known, err, effect)
+						}
+						width := int64(map[string]int{"X": 16, "Y": 32, "Z": 64}[bank])
+						for _, operand := range effect.operands {
+							switch operand.index {
+							case 0:
+								if member.scalar {
+									width = int64(member.bits / 8)
+								}
+								if !operand.read || operand.write || operand.width != width {
+									t.Fatal("reciprocal14 numerical source width changed", operand)
+								}
+							case len(ins.Args) - 1:
+								if !operand.write || operand.read != (mode == "merge") || member.scalar && operand.read &&
+									operand.requiredBytes != x86CallerVectorByteMask(int64(member.bits/8)) {
+									t.Fatal("old destination is not exactly the merging result bytes", operand)
+								}
+							case 1:
+								if member.scalar && (!operand.read || operand.write || operand.width != 16 ||
+									operand.requiredBytes != 0xffff&^x86CallerVectorByteMask(int64(member.bits/8))) {
+									t.Fatal("scalar passthrough acquired an unused low input", operand)
+								}
+							}
+						}
+						if len(effect.operands) != len(ins.Args) {
+							t.Fatal("reciprocal14 lost an explicit source/result/mask role", effect)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86Reciprocal14InitializedAndMissingInputsThreeAPIs(t *testing.T) {
+	for index, member := range x86Reciprocal14TestMembers {
+		for _, memory := range []bool{false, true} {
+			sourceOperand := "X16"
+			if memory {
+				sourceOperand = "(AX)"
+			}
+			instruction := x86Reciprocal14TestInstruction(member.op, sourceOperand, "X", "zero", member.scalar)
+			source, declaration := x86PackedAbsSignInitializedInstruction(index, instruction, "amd64", [3]int{16, 17, 18})
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(instruction+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized reciprocal14 program was rejected", err)
+					}
+					withoutOld := strings.Replace(source, "VMOVDQU64 (CX),Z18\n", "", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, withoutOld, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+						t.Fatal("zeroing operation borrowed an old destination", err)
+					}
+					missing := []string{"KMOVQ mask+32(FP),K1\n"}
+					if !memory {
+						missing = append(missing, "VMOVDQU64 (AX),Z16\n")
+					}
+					if member.scalar {
+						missing = append(missing, "VMOVDQU64 (BX),Z17\n")
+					}
+					for _, input := range missing {
+						negative := strings.Replace(source, input, "", 1)
+						if negative == source {
+							t.Fatal("undefined-input control did not remove its source", input)
+						}
+						ir, err = x86ScalarFPBitViewAPI(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if !strings.HasPrefix(input, "KMOV") {
+							x86VectorScratchCodegenControl(t, negative, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("reciprocal14 borrowed an absent numerical/upper/mask input", input, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Reciprocal14ScalarUpperDoesNotReadLowPassthrough(t *testing.T) {
+	for index, member := range x86Reciprocal14TestMembers {
+		if !member.scalar {
+			continue
+		}
+		instruction := member.op + " X16,X1,X18"
+		source, declaration := x86PackedAbsSignInitializedInstruction(index, instruction, "amd64", [3]int{16, 17, 18})
+		upper := "MOVQ $123,R8\nPINSRQ $1,R8,X1\n"
+		if member.bits == 32 {
+			upper = "MOVL $123,R8\nPINSRD $1,R8,X1\nPINSRD $2,R8,X1\nPINSRD $3,R8,X1\n"
+		}
+		source = strings.Replace(source, "VMOVDQU64 (BX),Z17\n", upper, 1)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(member.op+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil || ir == "" {
+					t.Fatal("unused low passthrough was required as a numerical input", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86Reciprocal14DynamicMXCSRActualOptimizedObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	var source, declarations strings.Builder
+	for index, member := range x86Reciprocal14TestMembers {
+		name := fmt.Sprint("Environment", index)
+		fmt.Fprintf(&declarations, "func %s(out *[32]byte,input,upper *[16]byte,first,second *uint32)\n", name)
+		instruction := x86Reciprocal14TestInstruction(member.op, "X16", "X", "plain", member.scalar)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),AX\n"+
+			"MOVQ upper+16(FP),BX\nMOVQ first+24(FP),CX\nMOVQ second+32(FP),DX\n"+
+			"VMOVUPS (AX),X16\nVMOVUPS (BX),X17\nLDMXCSR (CX)\n%s\nVMOVUPS X18,(DI)\n"+
+			"LDMXCSR (DX)\n%s\nVMOVUPS X18,16(DI)\nRET\n", name, instruction, instruction)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", "Go")
+	if err != nil {
+		t.Fatal("initialized dynamic MXCSR source rejected", err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			body, level := ir, "-O0"
+			if optimized {
+				body, level = x86DwordProductIROptimize(t, ir), "-O2"
+			}
+			directory := t.TempDir()
+			input, object := filepath.Join(directory, "environment.ll"), filepath.Join(directory, "environment.o")
+			if err := os.WriteFile(input, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=x86_64-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+			listing := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "--disassemble", object))
+			x86Reciprocal14RetainObject(t, source.String(), declarations.String(), body, object, listing)
+			for _, member := range x86Reciprocal14TestMembers {
+				count := len(regexp.MustCompile(`\b`+strings.ToLower(member.op)+`\b`).FindAll(listing, -1))
+				if count != 2 {
+					t.Errorf("two equal register inputs with distinct MXCSR environments became %d %s instructions in actual object:\n%s", count, member.op, listing)
+				}
+			}
+			sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <([^>]+)>:\n`).FindAllSubmatchIndex(listing, -1)
+			seen := map[string]bool{}
+			for sectionIndex, section := range sections {
+				name := string(listing[section[2]:section[3]])
+				for index, member := range x86Reciprocal14TestMembers {
+					if name != fmt.Sprint("Environment", index) {
+						continue
+					}
+					end := len(listing)
+					if sectionIndex+1 < len(sections) {
+						end = sections[sectionIndex+1][0]
+					}
+					op := strings.ToLower(member.op)
+					sequence := regexp.MustCompile(`\b(ldmxcsr|`+op+`)\b`).FindAllString(string(listing[section[1]:end]), -1)
+					if strings.Join(sequence, ",") != "ldmxcsr,"+op+",ldmxcsr,"+op {
+						t.Errorf("dynamic environment order changed in %s: %v", name, sequence)
+					}
+					seen[name] = true
+				}
+			}
+			if len(seen) != len(x86Reciprocal14TestMembers) {
+				t.Fatal("dynamic environment object lost a function", seen)
+			}
+		})
+	}
+}
+
+func TestX86Reciprocal14BackendBoundaryThreeAPIs(t *testing.T) {
+	for index, member := range x86Reciprocal14TestMembers {
+		instruction := x86Reciprocal14TestInstruction(member.op, "X16", "X", "plain", member.scalar)
+		source, declaration := x86PackedAbsSignInitializedInstruction(index, instruction, "amd64", [3]int{16, 17, 18})
+		for _, triple := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-wasi", "unknown-unknown-wasm32", "i386-unknown-linux-gnu"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(member.op+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native reciprocal14 escaped its matching backend", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86Reciprocal14MaskedDeadMemoryActualOptimizedObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	var source, declarations strings.Builder
+	for index, member := range x86Reciprocal14TestMembers {
+		for modeIndex, mode := range []string{"merge", "zero"} {
+			instruction := x86Reciprocal14TestInstruction(member.op, "(AX)", "X", mode, member.scalar)
+			body, declaration := x86PackedAbsSignInitializedInstruction(index*2+modeIndex, instruction, "amd64", [3]int{16, 17, 18})
+			// The memory source must be read only by the instruction under test;
+			// a separate register initializer would conceal its lost access.
+			body = strings.Replace(body, "VMOVDQU64 (AX),Z16\n", "", 1)
+			body = strings.Replace(body, "VMOVDQU64 Z18,(DI)\nSETCS 64(DI)\n", "", 1)
+			source.WriteString(body)
+			declarations.WriteString(declaration)
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", "x86_64-unknown-linux-gnu", "Go")
+	if err != nil {
+		t.Fatal("initialized dead masked-memory program rejected", err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			body, level := ir, "-O0"
+			if optimized {
+				body, level = x86DwordProductIROptimize(t, ir), "-O2"
+			}
+			directory := t.TempDir()
+			input, object := filepath.Join(directory, "dead-memory.ll"), filepath.Join(directory, "dead-memory.o")
+			if err := os.WriteFile(input, []byte(body), 0600); err != nil {
+				t.Fatal(err)
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(llc, level, "-mtriple=x86_64-unknown-linux-gnu", "-filetype=obj", input, "-o", object))
+			listing := x86FloatCompareCaptureCommand(t, exec.Command(objdump, "--disassemble", object))
+			x86Reciprocal14RetainObject(t, source.String(), declarations.String(), body, object, listing)
+			for _, member := range x86Reciprocal14TestMembers {
+				count := len(regexp.MustCompile(`\b`+strings.ToLower(member.op)+`\b[^\n]*\(`).FindAll(listing, -1))
+				if count != 2 {
+					t.Errorf("dead results retained %d of two masked native-memory %s operations in actual object:\n%s", count, member.op, listing)
+				}
+			}
+		})
+	}
+}
+
+func x86Reciprocal14RetainObject(t *testing.T, source, declaration, ir, object string, listing []byte) {
+	t.Helper()
+	root := os.Getenv("PLAN9ASM_RUNTIME_ARTIFACT_DIR")
+	if root == "" {
+		return
+	}
+	directory := filepath.Join(root, t.Name())
+	if err := os.MkdirAll(directory, 0700); err != nil {
+		t.Fatal(err)
+	}
+	bytes, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, data := range map[string][]byte{
+		"source.s": []byte(source), "declarations.go": []byte(declaration),
+		"module.ll": []byte(ir), "module.o": bytes, "module.disassembly": listing,
+	} {
+		if err := os.WriteFile(filepath.Join(directory, name), data, 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/x86_reciprocal_sib_oracle_test.go b/x86_reciprocal_sib_oracle_test.go
new file mode 100644
index 000000000..99e80a240
--- /dev/null
+++ b/x86_reciprocal_sib_oracle_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+)
+
+func x86ReciprocalSIBBoundSource(source []byte) bool {
+	switch string(source) {
+	case "TEXT f(SB),4,$0-0\nVRCPSS 16(R9)(CX*2),X1,X2\nRET\n",
+		"TEXT f(SB),4,$0-0\nVRSQRTSS 16(R9)(CX*2),X1,X2\nRET\n":
+		return true
+	}
+	return false
+}
+
+func (schema x86SegmentMOVEncoderSchema) reciprocalSIBDiagnostic() (string, bool) {
+	index, hasIndex := schema.registers["REG_CX"]
+	base, hasBase := schema.registers["REG_R9"]
+	if !hasIndex || !hasBase || index <= 0 || base <= 0 || index == base {
+		return "", false
+	}
+	if schema.namedDiagnostic {
+		return "asm: asmidx: bad address 2/CX/R9\nasm: assembly failed\n", true
+	}
+	return fmt.Sprintf("asm: asmidx: bad address 2/%d/%d\nasm: assembly failed\n", index, base), true
+}
+
+// This observes only these two complete source rejections. It neither relaxes
+// the generic positionless diagnostic reader nor grants physical permission
+// to another extended mode32 address or to the retained unbound observations.
+func (schema x86SegmentMOVEncoderSchema) acceptsReciprocalSIBDiagnostic(filename, wantFilename string,
+	source, wantSource []byte, arch, diagnostic string) bool {
+	if filename != wantFilename || !filepath.IsAbs(filename) || arch != "386" ||
+		!bytes.Equal(source, wantSource) || !x86ReciprocalSIBBoundSource(source) {
+		return false
+	}
+	current, regular := goAssemblerOracleFixture(filename)
+	if !regular || !bytes.Equal(current, source) {
+		return false
+	}
+	expected, known := schema.reciprocalSIBDiagnostic()
+	return known && diagnostic == expected
+}
+
+func x86ReciprocalSIBOriginalGoRejection(t *testing.T, arch, source string) {
+	t.Helper()
+	if arch != "386" || !x86ReciprocalSIBBoundSource([]byte(source)) {
+		t.Fatalf("unbound reciprocal SIB rejection fixture: %s / %q", arch, source)
+	}
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	expected, known := producer.schema.reciprocalSIBDiagnostic()
+	if !known {
+		t.Fatal("actual selected producer lacks the complete CX/R9 register tuple")
+	}
+	driver, _ := x86LEAActualSDKDriver(t)
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "forms.s"), filepath.Join(dir, "forms.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	before, regular := goAssemblerOracleFixture(input)
+	if !regular || !bytes.Equal(before, []byte(source)) {
+		t.Fatal("original reciprocal source is not the complete regular fixture")
+	}
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	include := filepath.Join(runtime.GOROOT(), "pkg", "include")
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-I", include,
+		"-p", "example.com/forms", "-o", object, input)
+	command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch)
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := x86UnnamedAsmidxOutcome(output, err, ctx.Err(), expected); failure != nil {
+		t.Fatalf("exact reciprocal source rejection lost its tuple/exit/lifecycle: %v\n%s", failure, output)
+	}
+	if !producer.schema.acceptsReciprocalSIBDiagnostic(input, input, before, []byte(source), arch, string(output)) {
+		t.Fatal("actual reciprocal rejection lost its original source/selected producer identity")
+	}
+	t.Logf("ORIGINAL_RECIPROCAL_SIB_REJECTION arch=%s sourceSHA=%x outputSHA=%x output=%q",
+		arch, sha256.Sum256(before), sha256.Sum256(output), output)
+}
diff --git a/x86_reciprocal_sib_profile_test.go b/x86_reciprocal_sib_profile_test.go
new file mode 100644
index 000000000..aaf36064a
--- /dev/null
+++ b/x86_reciprocal_sib_profile_test.go
@@ -0,0 +1,232 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// The selected encoder already observes the complete SDK producer schema,
+// register enum and actual tools. This missing scoped consumer must bind the
+// original source/file as well, without weakening the ordinary diagnostic API.
+type x86ReciprocalSIBDiagnosticConsumer interface {
+	acceptsReciprocalSIBDiagnostic(string, string, []byte, []byte, string, string) bool
+}
+
+func x86ReciprocalSIBSource(op string) []byte {
+	return []byte("TEXT f(SB),4,$0-0\n" + op + " 16(R9)(CX*2),X1,X2\nRET\n")
+}
+
+func x86ReciprocalSIBExpectedDiagnostic(t *testing.T, schema x86SegmentMOVEncoderSchema) string {
+	t.Helper()
+	index, hasIndex := schema.registers["REG_CX"]
+	base, hasBase := schema.registers["REG_R9"]
+	if !hasIndex || !hasBase || index == base {
+		t.Fatal("actual selected register enum lost its distinct CX/R9 identities")
+	}
+	if schema.namedDiagnostic {
+		return "asm: asmidx: bad address 2/CX/R9\nasm: assembly failed\n"
+	}
+	return fmt.Sprintf("asm: asmidx: bad address 2/%d/%d\nasm: assembly failed\n", index, base)
+}
+
+func TestX86ReciprocalSIBDiagnosticBindsActualSelectedProducer(t *testing.T) {
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	consumer, present := any(producer.schema).(x86ReciprocalSIBDiagnosticConsumer)
+	if !present {
+		t.Fatal("missing selected-SDK reciprocal SIB diagnostic consumer")
+	}
+	for _, op := range []string{"VRCPSS", "VRSQRTSS"} {
+		t.Run(op, func(t *testing.T) {
+			source := x86ReciprocalSIBSource(op)
+			filename := filepath.Join(t.TempDir(), "bound.s")
+			if err := os.WriteFile(filename, source, 0600); err != nil {
+				t.Fatal(err)
+			}
+			expected := x86ReciprocalSIBExpectedDiagnostic(t, producer.schema)
+			if !consumer.acceptsReciprocalSIBDiagnostic(filename, filename, source, source, "386", expected) {
+				t.Fatal("exact source/selected-register diagnostic failed")
+			}
+			for _, mutation := range []string{"filename", "source", "expected-source", "opcode", "mode",
+				"scale", "arbitrary-registers", "swapped-registers", "writer", "missing", "footer-only", "duplicate", "extra"} {
+				t.Run(mutation, func(t *testing.T) {
+					actualFile, actual, want, arch, diagnostic := filename, source, source, "386", expected
+					switch mutation {
+					case "filename":
+						actualFile += ".foreign"
+					case "source":
+						actual = bytes.Replace(source, []byte("16(R9)"), []byte("17(R9)"), 1)
+					case "expected-source":
+						want = bytes.Replace(source, []byte(op), []byte("VADDSS"), 1)
+					case "opcode":
+						actual = bytes.Replace(source, []byte(op), []byte("VADDSS"), 1)
+						want = actual
+					case "mode":
+						arch = "amd64"
+					case "scale":
+						diagnostic = strings.Replace(expected, "address 2/", "address 3/", 1)
+					case "arbitrary-registers":
+						diagnostic = "asm: asmidx: bad address 2/12345/67890\nasm: assembly failed\n"
+					case "swapped-registers":
+						diagnostic = fmt.Sprintf("asm: asmidx: bad address 2/%d/%d\nasm: assembly failed\n",
+							producer.schema.registers["REG_R9"], producer.schema.registers["REG_CX"])
+					case "writer":
+						diagnostic = fmt.Sprintf("asm: asmidx: bad address 2/%d/%d\nasm: assembly failed\n",
+							producer.schema.registers["REG_CX"], producer.schema.registers["REG_R9"])
+						if !producer.schema.namedDiagnostic {
+							diagnostic = "asm: asmidx: bad address 2/CX/R9\nasm: assembly failed\n"
+						}
+					case "missing":
+						diagnostic = ""
+					case "footer-only":
+						diagnostic = "asm: assembly failed\n"
+					case "duplicate":
+						diagnostic += expected
+					case "extra":
+						diagnostic += "unobserved extra output\n"
+					}
+					if consumer.acceptsReciprocalSIBDiagnostic(actualFile, filename, actual, want, arch, diagnostic) {
+						t.Fatal("foreign source/producer/tuple acquired a source rejection", mutation)
+					}
+				})
+			}
+		})
+	}
+	changed := make(map[string][]byte)
+	for name, data := range producer.sources {
+		changed[name] = append([]byte(nil), data...)
+	}
+	name := x86SegmentMOVProducerSources[0]
+	changed[name] = bytes.Replace(changed[name], []byte("asmidx: bad address"), []byte("asmidx: foreign address"), 1)
+	if bytes.Equal(changed[name], producer.sources[name]) {
+		t.Fatal("foreign SDK producer control did not mutate its actual source")
+	}
+	if _, err := x86SegmentMOVInspectProducer(changed); err == nil {
+		t.Fatal("foreign SDK diagnostic implementation acquired the selected producer profile")
+	}
+}
+
+func TestX86ReciprocalSIBOriginalGoRejectionAndOwnedExit(t *testing.T) {
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	driver, _ := x86LEAActualSDKDriver(t)
+	for _, op := range []string{"VRCPSS", "VRSQRTSS"} {
+		t.Run(op, func(t *testing.T) {
+			source := x86ReciprocalSIBSource(op)
+			dir := t.TempDir()
+			filename, object := filepath.Join(dir, "bound.s"), filepath.Join(dir, "bound.o")
+			if err := os.WriteFile(filename, source, 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancelStage := runtimeOracleStageContext(t)
+			defer cancelStage()
+			ctx, cancel := context.WithTimeout(stage, time.Minute)
+			defer cancel()
+			command := exec.CommandContext(ctx, driver, "tool", "asm", "-p", "example.com/forms", "-o", object, filename)
+			command.Env = append(os.Environ(), "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH=386")
+			output, processErr := runtimeOracleCombinedOutput(ctx, command)
+			expected := x86ReciprocalSIBExpectedDiagnostic(t, producer.schema)
+			if err := x86UnnamedAsmidxOutcome(output, processErr, ctx.Err(), expected); err != nil {
+				t.Fatal("actual selected Go/complete source/exit prior", err)
+			}
+			for _, failure := range []error{nil, errors.New("launch failure"), errors.Join(processErr, errors.New("cleanup failure"))} {
+				if x86UnnamedAsmidxOutcome(output, failure, nil, expected) == nil {
+					t.Fatal("non-owned process outcome became a Go source rejection")
+				}
+			}
+			if x86UnnamedAsmidxOutcome(output, processErr, context.DeadlineExceeded, expected) == nil {
+				t.Fatal("expired command became a Go source rejection")
+			}
+			if current, err := os.ReadFile(filename); err != nil || !bytes.Equal(current, source) {
+				t.Fatal("actual command lost its original source identity", err)
+			}
+			consumer, present := any(producer.schema).(x86ReciprocalSIBDiagnosticConsumer)
+			if !present || !consumer.acceptsReciprocalSIBDiagnostic(filename, filename, source, source, "386", string(output)) {
+				t.Fatal("real Go refusal has no exact selected-source consumer")
+			}
+		})
+	}
+}
+
+func x86ReciprocalSIBOriginalOwnerWiring(source []byte) error {
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, "owner.go", source, 0)
+	if err != nil {
+		return err
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "TestX86ScalarReciprocalMode32FrontendAddressHasNoPhysicalPermission" {
+			continue
+		}
+		var output bytes.Buffer
+		if err := format.Node(&output, set, function.Body); err != nil {
+			return err
+		}
+		text := output.String()
+		for _, required := range []string{
+			`[]string{"VRCPSS", "VRSQRTSS"}`,
+			`[]string{"R8", "R9", "R10", "R11", "R13", "R14", "R15"}`,
+			`goAssemblerOracleOutput(t, "386", source, "", true)`,
+			`[]string{"16(AX)(R9*2)", "16(R9)(CX*2)", "16(R12)"}`,
+			`x86ReciprocalSIBOriginalGoRejection(t, "386", "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n")`,
+			`unbound diagnostic, no source-rejection claim`,
+			`not the non-SIB frontend compatibility class`,
+		} {
+			if strings.Count(text, required) != 1 {
+				return fmt.Errorf("missing unique original reciprocal source/observation scope: %s", required)
+			}
+		}
+		return nil
+	}
+	return fmt.Errorf("missing original complete reciprocal mode32 owner")
+}
+
+func TestX86ReciprocalSIBOriginalOwnerUsesSelectedDiagnostic(t *testing.T) {
+	source, err := os.ReadFile("x86_scalar_reciprocal_mode32_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	old := `goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n", "", false)`
+	bound := `x86ReciprocalSIBOriginalGoRejection(t, "386", "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n")`
+	unwired := string(source)
+	oldCount, boundCount := strings.Count(unwired, old), strings.Count(unwired, bound)
+	if oldCount+boundCount != 1 {
+		t.Fatal("original owner has an unknown, duplicated or missing diagnostic route")
+	}
+	if boundCount == 1 {
+		unwired = strings.Replace(unwired, bound, old, 1)
+	}
+	if strings.Count(unwired, old) != 1 || strings.Count(unwired, bound) != 0 {
+		t.Fatal("independent unwired baseline lost its exact original source route")
+	}
+	complete := strings.Replace(unwired, old, bound, 1)
+	if complete == unwired || x86ReciprocalSIBOriginalOwnerWiring([]byte(complete)) != nil {
+		t.Fatal("independent complete source/diagnostic routing control")
+	}
+	for _, change := range [][2]string{
+		{bound, old}, {bound, `x86ReciprocalSIBOriginalGoRejection(t, "amd64", "foreign")`},
+		{`goAssemblerOracleOutput(t, "386", source, "", true)`, "NOP()"},
+		{`"R8", "R9", "R10", "R11", "R13", "R14", "R15"`, `"R8", "R9"`},
+		{`"16(AX)(R9*2)", "16(R9)(CX*2)", "16(R12)"`, `"16(R9)(CX*2)"`},
+		{`unbound diagnostic, no source-rejection claim`, `accepted rejection`},
+	} {
+		changed := strings.Replace(complete, change[0], change[1], 1)
+		if changed == complete || x86ReciprocalSIBOriginalOwnerWiring([]byte(changed)) == nil {
+			t.Fatal("reduced or unbound original fixture passed routing policy", change)
+		}
+	}
+	if err := x86ReciprocalSIBOriginalOwnerWiring(source); err != nil {
+		t.Fatal("actual owner still uses an unobserved generic positionless diagnostic", err)
+	}
+}
diff --git a/x86_register_producer_replay_test.go b/x86_register_producer_replay_test.go
new file mode 100644
index 000000000..49efff55c
--- /dev/null
+++ b/x86_register_producer_replay_test.go
@@ -0,0 +1,163 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86RegisterReplayConsumers(t *testing.T, arch, source string) (func(Func) error, func(Func) error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "registerreplay", "package registerreplay\nfunc Value() uint32")
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	signatures, err := goSigsForAsmFile(pkg, mustParseX86RawReturn(t, source), resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal("actual zero-argument numeric result declaration prerequisite", err)
+	}
+	sig, found := signatures["Value"]
+	if !found || len(sig.Frame.Params) != 0 || sig.Ret != I32 {
+		t.Fatal("register-only fixture acquired caller inputs or a different result role")
+	}
+	strict := func(function Func) error {
+		if x86StaticIntegerResultSourceCandidate(function, sig, arch) || function.x86SourceStack != nil ||
+			function.x86FixedLocal != nil || len(function.X86RawText) != 0 {
+			t.Fatal("register-only fixture accidentally selected another static/native/frame owner")
+		}
+		return checkX86ScalarFPResultInitialization(function, sig, arch)
+	}
+	lowered := func(function Func) error {
+		consumer := amd64Ctx{fpScalarSource: function, sig: sig, fpSourceSig: sig,
+			goarch: arch, targetTriple: x86AddressMemoryTargets(arch)[0]}
+		return consumer.checkLoweredScalarFPResultInitialization()
+	}
+	return strict, lowered
+}
+
+func x86RegisterFloatReplaySource(row x86RawLegacyFloatCompareOracle, selector byte, producer string, raw bool) string {
+	initialization := "PXOR X0,X0\nPXOR X1,X1\n"
+	if producer == "immediate" {
+		initialization = "MOVL $0x3f800000,AX\nMOVL AX,X0\nMOVL $0x40000000,CX\nMOVL CX,X1\n"
+	}
+	operation := fmt.Sprintf("%s X1,X0,$%d\n", row.op, int8(selector))
+	if raw {
+		operation = x86RawDisplacementDirectives(row.code(false, selector))
+	}
+	return "TEXT ·Value(SB),4,$0-4\n" + initialization + operation + "MOVL X0,ret+0(FP)\nRET\n"
+}
+
+// Unlike the native-pointer matrix, every input here comes from PXOR or an
+// actual immediate GP→X transfer. Assert that the strict numeric observer
+// succeeds, so a passing test cannot merely exercise the old fallback gate.
+func TestX86RawLegacyFloatingCompareRegisterOnlyFastReplayAllSelectors(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		first := x86RegisterFloatReplaySource(x86RawLegacyFloatCompareOracles[0], 0, "xor", false)
+		strict, check := x86RegisterReplayConsumers(t, arch, first)
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			for _, producer := range []string{"xor", "immediate"} {
+				for selector := 0; selector < 256; selector++ {
+					t.Run(fmt.Sprintf("%s/%s/%s/selector=%03d", arch, row.op, producer, selector), func(t *testing.T) {
+						source := x86RegisterFloatReplaySource(row, byte(selector), producer, true)
+						original, ordinal := x86LegacyFloatReplayOriginal(t, arch, source)
+						if err := check(original); err != nil {
+							t.Fatal("fully initialized original register producer rejected before any mutation", err)
+						}
+						named := mustParseX86RawReturn(t, x86RegisterFloatReplaySource(row, byte(selector), producer, false)).Funcs[0]
+						if strict(named) != nil || check(named) != nil || named.x86RawReplay != nil {
+							t.Fatal("genuine named register-only source lost its unchanged strict input domain")
+						}
+						changed := original
+						changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+						changed.Instrs[ordinal].x86SourceRaw = nil
+						if err := strict(changed); err != nil {
+							t.Fatal("fixture did not reach the strict-success shortcut under review", err)
+						}
+						if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("strict numeric success bypassed immutable original compare replay", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86RawLegacyFloatingCompareRegisterOnlyGoObjectsAndInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		first := x86RegisterFloatReplaySource(x86RawLegacyFloatCompareOracles[0], 0, "xor", false)
+		_, check := x86RegisterReplayConsumers(t, arch, first)
+		var object strings.Builder
+		ordinal := 0
+		for _, row := range x86RawLegacyFloatCompareOracles {
+			for _, producer := range []string{"xor", "immediate"} {
+				for _, raw := range []bool{false, true} {
+					source := x86RegisterFloatReplaySource(row, 255, producer, raw)
+					fmt.Fprintf(&object, "%s", strings.Replace(source, "·Value", fmt.Sprint("·Register", ordinal), 1))
+					ordinal++
+					t.Run(fmt.Sprintf("%s/%s/%s/raw=%t", arch, row.op, producer, raw), func(t *testing.T) {
+						producerLine := "PXOR X0,X0\n"
+						if producer == "immediate" {
+							producerLine = "MOVL $0x3f800000,AX\n"
+						}
+						missing := strings.Replace(source, producerLine, "", 1)
+						function := mustParseX86RawReturn(t, missing).Funcs[0]
+						if raw {
+							function, _ = x86LegacyFloatReplayOriginal(t, arch, missing)
+						}
+						if err := check(function); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("replay or a strict-success shortcut manufactured missing GP/vector input bytes", err)
+						}
+					})
+				}
+			}
+		}
+		x86LEAActualTargetGoObject(t, arch, x86AddressMemoryTargets(arch)[0], object.String())
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceRegisterOnlyFastReplay(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		first := "TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nMOVL AX,ret+0(FP)\nRET\n"
+		strict, check := x86RegisterReplayConsumers(t, arch, first)
+		for _, operation := range []struct {
+			name string
+			code []byte
+		}{
+			{"SHLL $1,AX", []byte{0xd1, 0xe0}}, {"SHRL $1,AX", []byte{0xd1, 0xe8}},
+			{"SARL $1,AX", []byte{0xd1, 0xf8}}, {"ROLL $1,AX", []byte{0xd1, 0xc0}},
+			{"RORL $1,AX", []byte{0xd1, 0xc8}}, {"RCLL $1,AX", []byte{0xd1, 0xd0}},
+			{"RCRL $1,AX", []byte{0xd1, 0xd8}},
+		} {
+			t.Run(arch+"/"+operation.name, func(t *testing.T) {
+				prefix := "TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nSTC\n"
+				suffix := "MOVL AX,ret+0(FP)\nRET\n"
+				named := mustParseX86RawReturn(t, prefix+operation.name+"\n"+suffix).Funcs[0]
+				if strict(named) != nil || check(named) != nil {
+					t.Fatal("initialized strict named scalar producer control rejected")
+				}
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, prefix+x86RawDisplacementDirectives(operation.code)+suffix), arch)
+				if err != nil {
+					t.Fatal("original scalar opcode decoding prerequisite", err)
+				}
+				original, ordinal := file.Funcs[0], -1
+				for index, ins := range original.Instrs {
+					if x86RawLegacyScalarShiftSource(ins, arch) {
+						ordinal = index
+					}
+				}
+				if ordinal < 0 || original.x86RawReplay == nil || check(original) != nil {
+					t.Fatal("initialized original scalar producer lost its complete replay")
+				}
+				changed := original
+				changed.Instrs = cloneX86ReplayInstrs(original.Instrs)
+				changed.Instrs[ordinal].x86SourceRaw = nil
+				if err := strict(changed); err != nil {
+					t.Fatal("scalar fixture did not reach strict numeric success", err)
+				}
+				if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("strict scalar result bypassed immutable original producer replay", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_repeat_empty_guard_test.go b/x86_repeat_empty_guard_test.go
new file mode 100644
index 000000000..372d515a9
--- /dev/null
+++ b/x86_repeat_empty_guard_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+const repeatEmptyGuardDeclaration = "func view(p,q *byte,n,needle uintptr) uintptr"
+
+func repeatEmptyGuardPrefix(arch, opcode, prefix, direction string) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	body := fmt.Sprintf("%s p+0(FP),SI\n%s q+%d(FP),DI\n%s DI,BX\n%s n+%d(FP),CX\n%s needle+%d(FP),AX\n%s\n%s\n%s\n",
+		move, move, word, move, move, 2*word, move, 3*word, direction, prefix, opcode)
+	if direction == "STD" {
+		// Restore Go's direction convention without defining status FLAGS.
+		body += "CLD\n"
+	}
+	return body
+}
+
+func repeatEmptyGuardBody(arch, opcode, prefix, direction, branch string) string {
+	move, sub := "MOVQ", "SUBQ"
+	if arch == "386" {
+		move, sub = "MOVL", "SUBL"
+	}
+	// The source does not initialize ZF. A nonempty repeated comparison defines
+	// it. On the empty path DI is exactly its saved BX, so either Jcc outcome
+	// returns the same -1. Same pointer origin alone would not prove that fact.
+	return repeatEmptyGuardPrefix(arch, opcode, prefix, direction) + branch + " matched\n" +
+		move + " $-1,ret+RESULT(FP)\nRET\nmatched:\n" + sub + " BX,DI\n" +
+		sub + " $1,DI\n" + move + " DI,ret+RESULT(FP)"
+}
+
+func repeatEmptyGuardCompleteSource(t *testing.T, arch string, priorFlags bool) (string, string, int) {
+	t.Helper()
+	widths := "BWLQ"
+	if arch == "386" {
+		widths = "BWL"
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, stem := range []string{"SCAS", "CMPS"} {
+		for _, width := range widths {
+			for _, prefix := range []string{"REP", "REPN"} {
+				for _, direction := range []string{"CLD", "STD"} {
+					for _, branch := range []string{"JE", "JZ", "JNE", "JNZ"} {
+						body := repeatEmptyGuardBody(arch, stem+string(width), prefix, direction, branch)
+						if priorFlags {
+							// Independent old-contract control: this actual comparison
+							// supplies all six entry status flags even at zero count.
+							body = strings.Replace(body, prefix+"\n", "CMPL AX,AX\n"+prefix+"\n", 1)
+						}
+						name := fmt.Sprintf("RepeatEmpty%d", count)
+						assembly := x86ResultGPSIMDAdmissionSource(t, arch, repeatEmptyGuardDeclaration, body)
+						source.WriteString(strings.Replace(assembly, "·view(SB)", "·"+name+"(SB)", 1))
+						declarations.WriteString(strings.Replace(repeatEmptyGuardDeclaration, "view(", name+"(", 1) + "\n")
+						count++
+					}
+				}
+			}
+		}
+	}
+	want := 128
+	if arch == "386" {
+		want = 96
+	}
+	if count != want || strings.Count(source.String(), "TEXT ") != want || strings.Count(declarations.String(), "func ") != want {
+		t.Fatal("complete independent repeated comparison/branch directory changed", arch, count, want)
+	}
+	return source.String(), declarations.String(), count
+}
+
+func repeatEmptyGuardFamily(t *testing.T, priorFlags bool) {
+	t.Helper()
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, count := repeatEmptyGuardCompleteSource(t, arch, priorFlags)
+		// One complete original-Go assembler command per architecture, not a
+		// process per form. This is encoding evidence, not native execution.
+		goAssemblerOracleOutput(t, arch, source, "", true)
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("%d complete repeat/empty-path functions rejected: priorFLAGS=%t output=%t err=%v", count, priorFlags, ir != "", err)
+				}
+				for index := 0; index < count; index++ {
+					name := fmt.Sprintf("@RepeatEmpty%d(", index)
+					if !strings.Contains(ir, name) {
+						t.Fatal("complete original family lost a callable entry", name)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RepeatEmptyGuardCompleteScalarFamily(t *testing.T) {
+	repeatEmptyGuardFamily(t, false)
+}
+
+func TestX86RepeatEmptyGuardPriorFlagsControl(t *testing.T) {
+	repeatEmptyGuardFamily(t, true)
+}
+
+func TestX86RepeatEmptyGuardOriginalSDKIndexByte386WholeSource(t *testing.T) {
+	directory := filepath.Join(testGOROOT(t), "src", "internal", "bytealg")
+	input := filepath.Join(directory, "indexbyte_386.s")
+	source, err := os.ReadFile(input)
+	if err != nil {
+		t.Fatal("selected SDK complete 386 IndexByte source is required", err)
+	}
+	declarations, err := os.ReadFile(filepath.Join(directory, "indexbyte_native.go"))
+	if err != nil {
+		t.Fatal("selected SDK actual IndexByte declarations are required", err)
+	}
+	pkg := importedGlobalPackage(t, "internal/bytealg", "386", []string{string(declarations)}, nil)
+	if strings.Count(string(source), "TEXT ") != 2 || strings.Count(string(source), "JZ 3(PC)") != 2 ||
+		strings.Count(string(source), "REPN; SCASB") != 2 {
+		t.Fatal("the complete original two-entry 386 counterexample changed")
+	}
+	for _, target := range []struct{ goos, triple string }{
+		{"linux", "i386-unknown-linux-gnu"}, {"windows", "i686-pc-windows-msvc"},
+	} {
+		for _, api := range []string{"public", "owned-context"} {
+			t.Run(target.goos+"/"+api, func(t *testing.T) {
+				// Pass the unchanged complete source, real declarations and target.
+				// No KeepFunc, invented FP/signature, FLAGS seed or native ABI flag.
+				ir, err := importedGlobalReadRequest(t, pkg, source, "386", target.triple, api, false, func(options *GoModuleOptions) {
+					options.GOOS, options.FileName = target.goos, input
+				})
+				if err != nil || ir == "" {
+					t.Fatalf("complete original SDK IndexByte/IndexByteString rejected: output=%t err=%v", ir != "", err)
+				}
+				for _, name := range []string{"IndexByte", "IndexByteString"} {
+					if !strings.Contains(ir, "internal/bytealg."+name) {
+						t.Fatal("complete original source lost its public entry", name)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86RepeatEmptyGuardCannotInventFlagsOrSuppressEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, lea := 8, "MOVQ", "LEAQ"
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, lea, triple = 4, "MOVL", "LEAL", "i386-unknown-linux-gnu"
+		}
+		for _, stem := range []string{"SCAS", "CMPS"} {
+			for _, prefix := range []string{"REP", "REPN"} {
+				complete := repeatEmptyGuardBody(arch, stem+"B", prefix, "CLD", "JZ")
+				for _, mutation := range []string{
+					"different-empty-results", "one-arm-native-store", "nonzero-saved-offset", "different-pointer-origin",
+					"partial-counter", "missing-direction", "missing-accumulator", "skipped-prefix", "missing-result",
+					"unrelated-unknown-Jcc", "direct-status-result",
+				} {
+					if mutation == "missing-accumulator" && stem == "CMPS" {
+						continue // CMPS has two memory inputs, not an AX input.
+					}
+					body := complete
+					switch mutation {
+					case "different-empty-results":
+						body = strings.Replace(body, move+" $-1,ret+RESULT(FP)", move+" $0,ret+RESULT(FP)", 1)
+					case "one-arm-native-store":
+						body = strings.Replace(body, "matched:\n", "matched:\nMOVB $1,(BX)\n", 1)
+					case "nonzero-saved-offset":
+						body = strings.Replace(body, move+" DI,BX\n", move+" DI,BX\n"+lea+" 1(DI),DI\n", 1)
+					case "different-pointer-origin":
+						body = strings.Replace(body, move+" DI,BX\n", move+" SI,BX\n", 1)
+					case "partial-counter":
+						body = strings.Replace(body, fmt.Sprintf("%s n+%d(FP),CX", move, 2*word), fmt.Sprintf("MOVW n+%d(FP),CX", 2*word), 1)
+					case "missing-direction":
+						body = strings.Replace(body, "CLD\n", "", 1)
+					case "missing-accumulator":
+						body = strings.Replace(body, fmt.Sprintf("%s needle+%d(FP),AX\n", move, 3*word), "", 1)
+					case "skipped-prefix":
+						body = strings.Replace(body, prefix+"\n"+stem+"B", "CMPL AX,AX\nJE body\n"+prefix+"\nbody:\n"+stem+"B", 1)
+					case "missing-result":
+						body = strings.Replace(body, move+" DI,ret+RESULT(FP)", "NOP", 1)
+					case "unrelated-unknown-Jcc":
+						body = strings.Replace(body, prefix+"\n"+stem+"B\n", "", 1)
+					case "direct-status-result":
+						body = repeatEmptyGuardPrefix(arch, stem+"B", prefix, "CLD") + "MOVL $0,DX\nSETEQ DL\n" + move + " DX,ret+RESULT(FP)"
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(arch+"/"+stem+"/"+prefix+"/"+mutation+"/"+api, func(t *testing.T) {
+							source := x86ResultGPSIMDAdmissionSource(t, arch, repeatEmptyGuardDeclaration, body)
+							ir, err := x86ScalarFPBitViewAPI(t, source, repeatEmptyGuardDeclaration, arch, triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("empty-repeat guard manufactured a FLAGS/result/alias/memory fact: output=%t err=%v", ir != "", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_repeat_empty_native_linux_amd64_test.go b/x86_repeat_empty_native_linux_amd64_test.go
new file mode 100644
index 000000000..78bb777c4
--- /dev/null
+++ b/x86_repeat_empty_native_linux_amd64_test.go
@@ -0,0 +1,35 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86RepeatEmptyGuardNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native repeated comparison requires LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	repeatEmptyExecuteOriginal(t, "amd64", execution)
+	repeatEmptyExecuteLLVM(t, "amd64", execution)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86RepeatEmptyGuardNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("native 386 repeated comparison requires LLVM22/i686 compiler", err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie"}}
+	repeatEmptyExecuteOriginal(t, "386", execution)
+	repeatEmptyExecuteLLVM(t, "386", execution)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_repeat_empty_runtime_test.go b/x86_repeat_empty_runtime_test.go
new file mode 100644
index 000000000..29ddd2d60
--- /dev/null
+++ b/x86_repeat_empty_runtime_test.go
@@ -0,0 +1,297 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type repeatEmptyRuntimeRow struct {
+	name                                    string
+	width, cmps, backward, repeatEQ, jumpEQ int
+}
+
+func repeatEmptyRuntimeRows(t *testing.T, arch string) []repeatEmptyRuntimeRow {
+	t.Helper()
+	widths := []int{1, 2, 4, 8}
+	if arch == "386" {
+		widths = widths[:3]
+	}
+	var rows []repeatEmptyRuntimeRow
+	for cmps := 0; cmps < 2; cmps++ {
+		for _, width := range widths {
+			for _, repeatEQ := range []int{1, 0} { // Original source order: REP, REPN.
+				for backward := 0; backward < 2; backward++ {
+					for _, jumpEQ := range []int{1, 1, 0, 0} { // JE/JZ/JNE/JNZ.
+						rows = append(rows, repeatEmptyRuntimeRow{
+							fmt.Sprint("RepeatEmpty", len(rows)), width, cmps, backward, repeatEQ, jumpEQ})
+					}
+				}
+			}
+		}
+	}
+	_, _, count := repeatEmptyGuardCompleteSource(t, arch, false)
+	if len(rows) != count {
+		t.Fatal("independent executed form directory disagrees with whole source", len(rows), count)
+	}
+	return rows
+}
+
+func repeatEmptyRuntimeC(t *testing.T, arch string) string {
+	t.Helper()
+	var prototypes, rows strings.Builder
+	for _, row := range repeatEmptyRuntimeRows(t, arch) {
+		fmt.Fprintf(&prototypes, "extern uintptr_t %s(const uint8_t*,const uint8_t*,uintptr_t,uintptr_t);\n", row.name)
+		fmt.Fprintf(&rows, "    {%s,%d,%d,%d,%d,%d},\n", row.name, row.width, row.cmps, row.backward, row.repeatEQ, row.jumpEQ)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + prototypes.String() + `
+struct row {
+    uintptr_t (*run)(const uint8_t*,const uint8_t*,uintptr_t,uintptr_t);
+    unsigned width,cmps,backward,repeat_eq,jump_eq;
+};
+static const struct row rows[] = {
+` + rows.String() + `};
+static uint64_t load(const uint8_t *p,unsigned width) {
+    uint64_t v=0;
+    for(unsigned b=0;b<width;b++) v|=(uint64_t)p[b]<<(8*b);
+    return v;
+}
+static uintptr_t expected(struct row row,const uint8_t *p,const uint8_t *q,
+        uintptr_t n,uintptr_t needle) {
+    if(n==0) return UINTPTR_MAX; /* No pointer arithmetic/access for NULL. */
+    uintptr_t done=0;
+    unsigned equal=0;
+    while(done<n) {
+        intptr_t delta=(row.backward?-1:1)*(intptr_t)(done*row.width);
+        uint64_t a=row.cmps?load(p+delta,row.width):needle;
+        if(row.width<8) a&=(UINT64_C(1)<<(8*row.width))-1;
+        equal=a==load(q+delta,row.width);
+        done++;
+        if(equal!=row.repeat_eq) break;
+    }
+    if(equal!=row.jump_eq) return UINTPTR_MAX;
+    uintptr_t distance=done*row.width;
+    return (row.backward?(uintptr_t)0-distance:distance)-1;
+}
+int main(void) {
+    const uintptr_t counts[]={0,1,2,4,8};
+    const unsigned offsets[]={0,1,7};
+    unsigned checks=0;
+    for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++)
+    for(unsigned pattern=0;pattern<4;pattern++)
+    for(unsigned off=0;off<3;off++)
+    for(unsigned c=0;c<5;c++) {
+        uint8_t p[256],q[256],p_before[256],q_before[256];
+        for(unsigned i=0;i<256;i++) {
+            p[i]=q[i]=pattern<2?0:(pattern==2?0x5a:(uint8_t)(i*37+11));
+        }
+        if(pattern>=2) p[128]^=0xa5;
+        memcpy(p_before,p,256); memcpy(q_before,q,256);
+        unsigned start=(rows[r].backward?128:16)+offsets[off];
+        uintptr_t n=counts[c];
+        const uint8_t *left=n?p+start:NULL,*right=n?q+start:NULL;
+        uintptr_t needle=pattern==1?1:(uintptr_t)load(q+start,rows[r].width);
+        uintptr_t want=expected(rows[r],left,right,n,needle);
+        uintptr_t got=rows[r].run(left,right,n,needle);
+        if(got!=want||memcmp(p,p_before,256)||memcmp(q,q_before,256)) {
+            fprintf(stderr,"row=%u pattern=%u offset=%u n=%llu got=%llx want=%llx\n",
+                r,pattern,offsets[off],(unsigned long long)n,
+                (unsigned long long)got,(unsigned long long)want);
+            return 1;
+        }
+        checks++;
+    }
+    printf("repeat-empty LLVM checks=%u\n",checks);
+    return 0;
+}
+`
+}
+
+func TestX86RepeatEmptyGuardCompleteLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _ := repeatEmptyGuardCompleteSource(t, target.arch, false)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "repeat-empty.ll", "repeat-empty.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86RepeatEmptyGuardPortableLLVM22Objects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, count := repeatEmptyGuardCompleteSource(t, arch, false)
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "armv7-unknown-linux-gnueabihf", "wasm32-unknown-unknown"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+triple+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete source lost portable numerical translation", err)
+					}
+					if strings.Contains(ir, "asm sideeffect") {
+						t.Fatal("portable strings retained an x86-only direction instruction")
+					}
+					for index := 0; index < count; index++ {
+						body := x86StringMemoryFunction(t, ir, fmt.Sprint("RepeatEmpty", index))
+						for _, flag := range []string{"z", "slt", "cf", "pf", "af", "of"} {
+							// These implementation defaults prevent LLVM poison/undef;
+							// they are never entry FLAGS facts in the source proof.
+							if !strings.Contains(body, "store i1 false, ptr %flags_"+flag) {
+								t.Fatal("old status value has no concrete initialization", index, flag)
+							}
+						}
+					}
+					compileLLVMToObject(t, llc, triple, "portable-repeat.ll", "portable-repeat.o", ir)
+				})
+			}
+		}
+	}
+}
+
+func repeatEmptyExecuteLLVM(t *testing.T, arch string, execution x86FloatCompareExecution) {
+	t.Helper()
+	source, declarations, count := repeatEmptyGuardCompleteSource(t, arch, false)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, ir)
+					}
+					output := execution.compileAndRunLLVM(t, "repeat-empty", input, repeatEmptyRuntimeC(t, arch), level)
+					want := fmt.Sprintf("repeat-empty LLVM checks=%d", count*4*3*5)
+					if strings.TrimSpace(string(output)) != want {
+						t.Fatalf("incomplete portable independent numerical oracle: %q", output)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86RepeatEmptyGuardPortableNumericalExecution(t *testing.T) {
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	repeatEmptyExecuteLLVM(t, arch, x86ScalarCountHostExecution(t))
+	t.Log("actual-host LLVM comparison/cursor values, zero-count NULL, unaligned B/W/L/Q and both directions; not original x86 execution")
+}
+
+func repeatEmptyExecuteOriginal(t *testing.T, arch string, execution x86FloatCompareExecution) {
+	t.Helper()
+	source, declarations, _ := repeatEmptyGuardCompleteSource(t, arch, false)
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var assembly, entries, callers strings.Builder
+	assembly.WriteString(source)
+	entries.WriteString("package oracle\n" + declarations)
+	for index, row := range repeatEmptyRuntimeRows(t, arch) {
+		for zf := 0; zf < 2; zf++ {
+			name := fmt.Sprintf("Observe%dZF%d", index, zf)
+			fmt.Fprintf(&entries, "func %s(p,q *byte,n,needle uintptr) uintptr\n", name)
+			fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$%d-%d\n", name, 5*word, 5*word)
+			for argument, parameter := range []string{"p", "q", "n", "needle"} {
+				fmt.Fprintf(&assembly, "%s %s+%d(FP),AX\n%s AX,%d(SP)\n", move, parameter, argument*word, move, argument*word)
+			}
+			// Set both actual incoming ZF states immediately before CALL. No
+			// test initialization is added to the independently translated body.
+			fmt.Fprintf(&assembly, "MOVL $0,AX\nCMPL AX,$%d\nCALL ·%s(SB)\n", 1-zf, row.name)
+			fmt.Fprintf(&assembly, "%s %d(SP),AX\n%s AX,ret+%d(FP)\nRET\n", move, 4*word, move, 4*word)
+			fmt.Fprintf(&callers, "    {%s,%d,%d,%d,%d,%d},\n", name, row.width, row.cmps, row.backward, row.repeatEQ, row.jumpEQ)
+		}
+	}
+	oracle := `package oracle
+import (
+    "testing"
+    "unsafe"
+)
+type row struct {
+    run func(*byte,*byte,uintptr,uintptr) uintptr
+    width,cmps,backward,repeatEQ,jumpEQ int
+}
+var rows=[]row{
+` + callers.String() + `}
+func load(p *byte,width int) uint64 {
+    var value uint64
+    for b:=0;b<width;b++ { value|=uint64(*(*byte)(unsafe.Add(unsafe.Pointer(p),b)))<<uint(8*b) }
+    return value
+}
+func expected(r row,p,q *byte,n,needle uintptr) uintptr {
+    if n==0 { return ^uintptr(0) }
+    var done uintptr
+    equal:=0
+    for done<n {
+        delta:=int(done)*r.width
+        if r.backward!=0 { delta=-delta }
+        a:=uint64(needle)
+        if r.cmps!=0 { a=load((*byte)(unsafe.Add(unsafe.Pointer(p),delta)),r.width) }
+        if r.width<8 { a&=(uint64(1)<<uint(8*r.width))-1 }
+        equal=0
+        if a==load((*byte)(unsafe.Add(unsafe.Pointer(q),delta)),r.width) { equal=1 }
+        done++
+        if equal!=r.repeatEQ { break }
+    }
+    if equal!=r.jumpEQ { return ^uintptr(0) }
+    distance:=uintptr(done)*uintptr(r.width)
+    if r.backward!=0 { distance=0-distance }
+    return distance-1
+}
+func TestOriginal(t *testing.T) {
+    checks:=0
+    for index,r:=range rows {
+    for pattern:=0;pattern<4;pattern++ {
+    for _,offset:=range []int{0,1,7} {
+    for _,n:=range []uintptr{0,1,2,4,8} {
+        var p,q [256]byte
+        for i:=range p {
+            if pattern==2 { p[i]=0x5a }
+            if pattern==3 { p[i]=byte(i*37+11) }
+            q[i]=p[i]
+        }
+        if pattern>=2 { p[128]^=0xa5 }
+        beforeP,beforeQ:=p,q
+        start:=16+offset
+        if r.backward!=0 { start=128+offset }
+        left,right:=&p[start],&q[start]
+        if n==0 { left,right=nil,nil }
+        needle:=uintptr(load(&q[start],r.width))
+        if pattern==1 { needle=1 }
+        want:=expected(r,left,right,n,needle)
+        got:=r.run(left,right,n,needle)
+        if got!=want||p!=beforeP||q!=beforeQ {
+            t.Fatalf("row=%d pattern=%d offset=%d n=%d got=%x want=%x",index,pattern,offset,n,got,want)
+        }
+        checks++
+    }}}}
+    if checks!=len(rows)*4*3*5 { t.Fatal("incomplete actual original-Go directory",checks) }
+    t.Logf("repeat-empty original checks=%d; both incoming ZF states, complete unchanged bodies",checks)
+}
+`
+	x86RunOriginalGoNativeSource(t, execution, arch, entries.String(), assembly.String(), oracle)
+}
diff --git a/x86_result_accumulator_sign_extend.go b/x86_result_accumulator_sign_extend.go
new file mode 100644
index 000000000..a0d1acfa8
--- /dev/null
+++ b/x86_result_accumulator_sign_extend.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+func x86RawAccumulatorSignExtendSource(ins Instr, arch string) bool {
+	_, known, err := x86AccumulatorSignExtendProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOperandFreeSource(ins)
+}
+
+// Only the exact decoded implicit GP instruction shares the named byte effect.
+// This creates neither a raw entry nor a caller, frame or declaration-query role.
+func x86LoweredAccumulatorSignExtendResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	_, known, _ := x86AccumulatorSignExtendProperties(ins.Op, ins, arch)
+	if !known || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if !x86RawAccumulatorSignExtendSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_addsub_round.go b/x86_result_addsub_round.go
new file mode 100644
index 000000000..549662fc8
--- /dev/null
+++ b/x86_result_addsub_round.go
@@ -0,0 +1,79 @@
+package plan9asm
+
+// These byte transfers reuse the same grammar as lowering. Native reads are
+// conditional numerical availability only: they grant no source, pointer,
+// alignment, initialized pointee, extent or later-read fact. A native=true
+// caller must pair the instruction with an observable architectural read.
+func x86ResultAlternatingFloatStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86AlternatingFloatProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(local) {
+		if !native || !x86RawAlternatingFloatSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	read := native && (!form.legacy || form.memory >= 0 &&
+		x86LegacyAlternatingRoundMemorySource(local, local.Args[form.first], arch))
+	return x86ScalarFPFloatBinaryTransferWithRead(local, form, state, owned, arch, read), true
+}
+
+func x86RawAlternatingFloatSource(ins Instr, arch string) bool {
+	form, known, err := x86AlternatingFloatProperties(ins, arch)
+	return known && err == nil && !form.legacy && x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
+
+// Only the existing source-local decoder, immutable source replay, DATA
+// binding and independent raw-return owner can supply this literal role.
+// It is not ordinary raw, incoming-pointer or later-read authority.
+func x86RawRoundLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceIdentity(ins, arch) {
+		return false
+	}
+	form, known, err := x86RoundProperties(ins, arch)
+	return known && err == nil && form.spec.vector && form.memory &&
+		ins.x86RIPMemoryRead.source == 1 && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86ResultRoundStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86RoundProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	literal := x86RawRoundLiteralForm(ins, arch)
+	if !x86ResultNamedPredicateInstruction(ins) && !literal || !x86ResultRead(ins.Args[0], 1, state, owned, arch) {
+		return false, true
+	}
+	low := x86CallerVectorByteMask(int64(form.memoryBytes))
+	if form.memory {
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, native && (form.spec.vector || x86LegacyAlternatingRoundMemorySource(ins, form.source, arch))) {
+			return false, true
+		}
+	} else {
+		source, valid := amd64VectorRegisterIndex(form.source.Reg, form.byteWidth)
+		if !valid || arch == "386" && source >= 8 || state.vectorBytes(source)&low != low {
+			return false, true
+		}
+	}
+	destination, valid := amd64VectorRegisterIndex(form.destination.Reg, form.byteWidth)
+	if !valid || arch == "386" && destination >= 8 {
+		return false, true
+	}
+	defined := low
+	if form.spec.scalar {
+		upper, valid := amd64ParseXReg(form.upper.Reg)
+		if !valid || arch == "386" && upper >= 8 {
+			return false, true
+		}
+		upperRequired := uint64(0xffff) &^ low
+		if literal && state.vectorBytes(upper)&upperRequired != upperRequired {
+			return false, true
+		}
+		defined |= state.vectorBytes(upper) & upperRequired
+	}
+	state.writeVector(destination, form.byteWidth, defined, !form.spec.vector)
+	return true, true // All unrelated vector/GP/FLAGS/mask/storage facts survive.
+}
diff --git a/x86_result_aes_native.go b/x86_result_aes_native.go
new file mode 100644
index 000000000..ad73fee86
--- /dev/null
+++ b/x86_result_aes_native.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+func x86RawAESSource(ins Instr, arch string) bool {
+	form, known, err := x86AESProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSourceAt(ins, arch, form.source)
+}
+
+// The complete AES grammar and byte dependencies are shared, not re-listed.
+// The paired lowerer retains the original legacy m128 opcode/alignment fault,
+// or the vector form's complete volatile read. Neither grants native backing.
+func x86LoweredAESResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	_, known, err := x86AESProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawAESSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultAESStepWithRead(ins, state, owned, arch, true)
+}
diff --git a/x86_result_auto.go b/x86_result_auto.go
new file mode 100644
index 000000000..9433c433d
--- /dev/null
+++ b/x86_result_auto.go
@@ -0,0 +1,125 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+)
+
+var x86ResultAUTOLiteral = regexp.MustCompile(`^(.+)\(\s*SP\s*\)$`)
+
+// This replays the original source spelling before observing logical AUTO
+// bytes. Its extent is not an allocator size, physical SP, native backing,
+// alignment, caller region or address-lifetime certificate.
+func x86ResultAUTOExtent(fn Func, arch string) (int, error) {
+	return x86ResultAUTOExtentWithPrivateStack(fn, arch, false)
+}
+
+func x86ResultAUTOExtentWithPrivateStack(fn Func, arch string, privateStack bool) (int, error) {
+	needed := false
+	for _, ins := range fn.Instrs {
+		if _, _, private := x86ResultPrivateStackXORForm(ins, arch); privateStack && private {
+			continue // Only the separately bound, reaching private stack owns this access.
+		}
+		for _, arg := range ins.Args {
+			if _, outgoing := x86ABI0BoolOutgoingOffset(arg, fn.x86BoolCalls); outgoing {
+				continue
+			}
+			if _, static := x86SBMemoryAddressRole(arg, arch); static {
+				continue // A 386 named Reg annotation is not a logical AUTO base.
+			}
+			needed = needed || arg.Kind == OpMem && arg.Mem.Base == SP
+		}
+	}
+	if !needed {
+		return 0, nil
+	}
+	fail := func(reason string) (int, error) {
+		return 0, fmt.Errorf("%w: result initialization AUTO: %s", ErrProbeNeedsContext, reason)
+	}
+	if fn.x86RawReplay != nil {
+		if err := fn.x86RawReplay.validate(fn, arch); err != nil {
+			return 0, err
+		}
+	}
+	if fn.FrameSize <= 0 || fn.FrameSize > 4096 || len(fn.Instrs) == 0 || len(fn.Instrs) > 8192 || fn.Instrs[0].Op != OpTEXT {
+		return fail("requires complete bounded positive original TEXT")
+	}
+	if fn.x86RawReplay == nil {
+		var source strings.Builder
+		for _, ins := range fn.Instrs {
+			if ins.Raw == "" || len(ins.Raw) > (1<<20)-source.Len()-1 {
+				return fail("missing or oversized original literal")
+			}
+			source.WriteString(ins.Raw)
+			source.WriteByte('\n')
+		}
+		parsed, err := Parse(ArchAMD64, source.String())
+		if err != nil || len(parsed.Funcs) != 1 || len(parsed.UnlinkedPrelude) != 0 || len(parsed.Data) != 0 || len(parsed.Globl) != 0 {
+			return fail("original source cannot be replayed as one unchanged function")
+		}
+		original := parsed.Funcs[0]
+		instructions, err := x86ResultAUTOReplayInstructions(fn, arch)
+		if err != nil {
+			return 0, err
+		}
+		if original.Sym != fn.Sym || original.FrameSize != fn.FrameSize || original.ArgSize != fn.ArgSize ||
+			!reflect.DeepEqual(original.Instrs, instructions) {
+			return fail("TEXT, operands or source roles changed after parsing")
+		}
+	}
+	for _, ins := range fn.Instrs {
+		if _, _, private := x86ResultPrivateStackXORForm(ins, arch); privateStack && private {
+			continue
+		}
+		for index, arg := range ins.Args {
+			if _, outgoing := x86ABI0BoolOutgoingOffset(arg, fn.x86BoolCalls); outgoing {
+				continue
+			}
+			if _, static := x86SBMemoryAddressRole(arg, arch); static {
+				continue
+			}
+			if arg.Kind != OpMem || arg.Mem.Base != SP {
+				continue
+			}
+			fields := strings.Fields(ins.Raw)
+			if len(fields) < 2 {
+				return fail("AUTO operand lacks its original instruction")
+			}
+			operands := splitTopLevelCSV(strings.TrimSpace(ins.Raw[len(fields[0]):]))
+			if len(operands) != len(ins.Args) {
+				return fail("AUTO operand ordinal changed")
+			}
+			literal := x86ResultAUTOLiteral.FindStringSubmatch(operands[index])
+			if literal == nil {
+				return fail("physical or indexed SP is not logical AUTO")
+			}
+			offset, named := parseNamedStackConstantOffset(literal[1])
+			if !named || offset != arg.Mem.Off || arg.Mem.Sym != "" || arg.Mem.OffRaw != "" ||
+				arg.Mem.Index != "" || arg.Mem.IndexExt != "" || arg.Mem.Segment != "" || arg.Mem.Scale != 0 {
+				return fail("AUTO role, offset or address is not closed")
+			}
+			// Reuse the native-width observer's complete typed row. This local
+			// width projection is never passed to a translator or source loader;
+			// the actual original AUTO role and source remain unchanged above.
+			observation := ins
+			observation.Args = append([]Operand(nil), ins.Args...)
+			observation.Args[index] = Operand{Kind: OpFP}
+			width, _, known := X86FPAccessBytes(observation, index, arch)
+			if !known || width <= 0 || width > fn.FrameSize || offset < -fn.FrameSize || offset > -width {
+				return fail("unknown native width or access outside logical AUTO extent")
+			}
+		}
+	}
+	return int(fn.FrameSize), nil
+}
+
+func x86ResultAUTOOffset(arg Operand, width int64, extent int) (int, bool) {
+	if extent <= 0 || arg.Kind != OpMem || arg.Mem.Base != SP || arg.Mem.Sym != "" || arg.Mem.OffRaw != "" ||
+		arg.Mem.Index != "" || arg.Mem.IndexExt != "" || arg.Mem.Segment != "" || arg.Mem.Scale != 0 ||
+		width <= 0 || width > int64(extent) || arg.Mem.Off < -int64(extent) || arg.Mem.Off > -width {
+		return 0, false
+	}
+	return extent + int(arg.Mem.Off), true
+}
diff --git a/x86_result_auto_numerical.go b/x86_result_auto_numerical.go
new file mode 100644
index 000000000..2a6c38f6d
--- /dev/null
+++ b/x86_result_auto_numerical.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import "reflect"
+
+// A live numerical certificate is metadata on its exact original instruction,
+// not a change to Go's AUTO spelling. Only that authenticated metadata may be
+// projected away for source replay; raw/native/literal roles remain unchanged.
+// This observation creates neither numerical bytes nor a physical frame.
+func x86ResultAUTOReplayInstructions(fn Func, arch string) ([]Instr, error) {
+	var binding *GoX86NumericalReadBinding
+	for _, ins := range fn.Instrs {
+		if cert := ins.x86NumericalRead; cert != nil {
+			if cert.binding == nil || binding != nil && binding != cert.binding {
+				return nil, numericalSBContext("AUTO replay has missing or mixed original numerical bindings")
+			}
+			binding = cert.binding
+		}
+	}
+	if binding == nil {
+		return fn.Instrs, nil // Retain the exact ordinary source comparison.
+	}
+	if err := binding.verify(); err != nil {
+		return nil, err
+	}
+	if arch != binding.options.Goarch || binding.source.file == nil {
+		return nil, numericalSBContext("AUTO replay differs from the live numerical source mode")
+	}
+	instructions := append([]Instr(nil), fn.Instrs...)
+	for ordinal, ins := range instructions {
+		if ins.x86NumericalRead == nil {
+			continue
+		}
+		read, _, valid := numericalCertifiedRead(ins, arch)
+		ins.x86NumericalRead = nil
+		if !valid || read.Instruction != ordinal || read.Function != binding.symbols[fn.Sym] ||
+			!reflect.DeepEqual(ins, read.Original) {
+			return nil, numericalSBContext("AUTO replay changed the actual original numerical instruction/ordinal")
+		}
+		instructions[ordinal] = ins
+	}
+	matches := 0
+	for _, original := range binding.source.file.Funcs {
+		if original.Sym != fn.Sym {
+			continue
+		}
+		if original.FrameSize != fn.FrameSize || original.ArgSize != fn.ArgSize ||
+			!reflect.DeepEqual(original.Instrs, instructions) {
+			return nil, numericalSBContext("AUTO replay changed the complete actual numerical source TEXT")
+		}
+		matches++
+	}
+	if matches != 1 {
+		return nil, numericalSBContext("AUTO replay has no unique actual numerical source TEXT")
+	}
+	return instructions, nil
+}
diff --git a/x86_result_auto_numerical_join_go127_test.go b/x86_result_auto_numerical_join_go127_test.go
new file mode 100644
index 000000000..41c8f2d0a
--- /dev/null
+++ b/x86_result_auto_numerical_join_go127_test.go
@@ -0,0 +1,147 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestGoX86ResultAUTOCompleteActualFixedLocalNumericalJoinOriginalSourceShape(t *testing.T) {
+	numericalResultAUTOCompleteActualFixedLocalJoin(t, "original-source-shape")
+}
+
+func TestGoX86ResultAUTOCompleteActualFixedLocalNumericalJoinText(t *testing.T) {
+	numericalResultAUTOCompleteActualFixedLocalJoin(t, "text")
+}
+
+func TestGoX86ResultAUTOCompleteActualFixedLocalNumericalJoinContext(t *testing.T) {
+	numericalResultAUTOCompleteActualFixedLocalJoin(t, "context")
+}
+
+func TestGoX86ResultAUTOCompleteActualFixedLocalNumericalJoinGoModule(t *testing.T) {
+	numericalResultAUTOCompleteActualFixedLocalJoin(t, "go-module")
+}
+
+// Each public owner invokes the complete fresh producer once, with its own
+// original deadline and lifecycle. Keep this fixture shared, not its owner.
+func numericalResultAUTOCompleteActualFixedLocalJoin(t *testing.T, api string) {
+	t.Helper()
+	_, pkg, file, bound, source, frame := numericalLocalJoinedFactory(t)
+	before, err := x86CallerSourceFingerprint(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if api == "original-source-shape" {
+		frozen, options, err := freezeNumericalReadInputs(file, bound)
+		if err != nil {
+			t.Fatal("complete original numerical source precondition", err)
+		}
+		bindings, err := verifyX86FixedLocalBindings(frozen, options)
+		if err != nil {
+			t.Fatal("complete actual independent fixed-local precondition", err)
+		}
+		frozen, err = freezeX86FixedLocalFile(frozen, bindings)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := joinNumericalReadCertificates(frozen, options); err != nil {
+			t.Fatal("actual reparse/original-node join precondition", err)
+		}
+		certificates := 0
+		for _, fn := range frozen.Funcs {
+			for _, ins := range fn.Instrs {
+				if ins.x86NumericalRead != nil {
+					certificates++
+				}
+			}
+			instructions, err := x86ResultAUTOReplayInstructions(fn, options.Goarch)
+			if err != nil || !reflect.DeepEqual(instructions, file.Funcs[0].Instrs) {
+				t.Fatal("actual NUM metadata changed complete original source identity", err)
+			}
+			if _, err := x86ResultAUTOExtent(fn, options.Goarch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("authenticated NUM metadata granted physical SP logical AUTO storage", err)
+			}
+		}
+		if certificates == 0 {
+			t.Fatal("fixture lost its actual numerical source node")
+		}
+	} else {
+		ir := numericalFamilyTranslate(t, api, pkg, file, bound)
+		if ir == "" || !strings.Contains(ir, "fixed_local_native") || !strings.Contains(ir, "load volatile") {
+			t.Fatal("complete actual joined consumer lost independent local/NUM roles")
+		}
+	}
+	if err := source.Verify(bound.NumericalReads.context); err != nil {
+		t.Fatal("original source/storage owner changed", err)
+	}
+	if err := frame.Verify(bound.NumericalReads.context); err != nil {
+		t.Fatal("original frame owner changed", err)
+	}
+	if after, err := x86CallerSourceFingerprint(file); err != nil || after != before {
+		t.Fatal("private joined consumers mutated original whole source")
+	}
+}
+
+func TestGoX86ResultAUTONumericalReplayExactOriginalNodeGuards(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			_, file, _, create := numericalConsumerFactory(t, arch)
+			source, options := create(t)
+			frozen, bound, err := freezeNumericalReadInputs(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn := frozen.Funcs[0]
+			instructions, err := x86ResultAUTOReplayInstructions(fn, arch)
+			if err != nil || !reflect.DeepEqual(instructions, file.Funcs[0].Instrs) {
+				t.Fatal("complete actual source/mode/ordinal replay precondition", err)
+			}
+			ordinal := -1
+			for index, ins := range fn.Instrs {
+				if ins.x86NumericalRead != nil {
+					ordinal = index
+					break
+				}
+			}
+			if ordinal <= 0 {
+				t.Fatal("actual fixture lost original numerical ordinal")
+			}
+			for name, mutate := range map[string]func(*Func){
+				"missing binding":     func(fn *Func) { fn.Instrs[ordinal].x86NumericalRead = &x86NumericalReadCertificate{} },
+				"unknown instruction": func(fn *Func) { fn.Instrs[ordinal].Op = "UNKNOWN" },
+				"original literal":    func(fn *Func) { fn.Instrs[ordinal].Raw += " " },
+				"different ordinal":   func(fn *Func) { fn.Instrs[ordinal-1], fn.Instrs[ordinal] = fn.Instrs[ordinal], fn.Instrs[ordinal-1] },
+				"different function":  func(fn *Func) { fn.Sym = "·Other" },
+				"coherent different TEXT frame": func(fn *Func) {
+					fn.FrameSize = 8
+					fn.Instrs[0].Raw = strings.Replace(fn.Instrs[0].Raw, "$0-", "$8-", 1)
+				},
+				"coherent different tail": func(fn *Func) { fn.Instrs[len(fn.Instrs)-1] = Instr{Op: "NOP", Raw: "NOP"} },
+				"decoded instruction":     func(fn *Func) { fn.Instrs[ordinal].x86Encoded = true },
+				"SDK literal metadata":    func(fn *Func) { fn.Instrs[ordinal].x86SDKLiteral = &x86SDKLiteralCertificate{} },
+				"unrelated private role":  func(fn *Func) { fn.Instrs[0].x86SourceStackFP = map[int]int64{0: 0} },
+			} {
+				t.Run(name, func(t *testing.T) {
+					copy := fn
+					copy.Instrs = append([]Instr(nil), fn.Instrs...)
+					mutate(&copy)
+					if _, err := x86ResultAUTOReplayInstructions(copy, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("changed original function/instruction/source role was projected away", err)
+					}
+				})
+			}
+			if err := source.Verify(bound.NumericalReads.context); err != nil {
+				t.Fatal("source mutations in independent copies changed the original owner", err)
+			}
+			if err := source.Close(); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := x86ResultAUTOReplayInstructions(fn, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("closed original source retained authenticated metadata projection", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_auto_numerical_ownership_test.go b/x86_result_auto_numerical_ownership_test.go
new file mode 100644
index 000000000..6412401c0
--- /dev/null
+++ b/x86_result_auto_numerical_ownership_test.go
@@ -0,0 +1,194 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const numericalJoinOwnerPrefix = "TestGoX86ResultAUTOCompleteActualFixedLocalNumericalJoin"
+const numericalJoinOwnerHelper = "numericalResultAUTOCompleteActualFixedLocalJoin"
+
+func numericalJoinOwners(source []byte) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "owners.go", source, 0)
+	if err != nil {
+		return err
+	}
+	owners := map[string]string{
+		numericalJoinOwnerPrefix + "OriginalSourceShape": "original-source-shape",
+		numericalJoinOwnerPrefix + "Text":                "text",
+		numericalJoinOwnerPrefix + "Context":             "context",
+		numericalJoinOwnerPrefix + "GoModule":            "go-module",
+	}
+	seen := make(map[string]bool)
+	var helper *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		if fn.Name.Name == numericalJoinOwnerHelper {
+			if helper != nil {
+				return fmt.Errorf("duplicate complete fixture helper")
+			}
+			helper = fn
+		}
+		if !strings.HasPrefix(fn.Name.Name, numericalJoinOwnerPrefix) {
+			continue
+		}
+		axis, required := owners[fn.Name.Name]
+		if !required || seen[fn.Name.Name] || fn.Body == nil || len(fn.Body.List) != 1 {
+			return fmt.Errorf("missing/duplicate/aggregated numerical owner: %s", fn.Name.Name)
+		}
+		expression, ok := fn.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			return fmt.Errorf("conditional or shared numerical owner: %s", fn.Name.Name)
+		}
+		call, ok := expression.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 2 {
+			return fmt.Errorf("complete fixture call missing: %s", fn.Name.Name)
+		}
+		name, named := call.Fun.(*ast.Ident)
+		literal, literalOK := call.Args[1].(*ast.BasicLit)
+		parameter, parameterOK := call.Args[0].(*ast.Ident)
+		if !named || name.Name != numericalJoinOwnerHelper || !literalOK || literal.Value != strconv.Quote(axis) ||
+			!parameterOK || parameter.Name != "t" {
+			return fmt.Errorf("numerical owner changed its complete exact axis: %s", fn.Name.Name)
+		}
+		seen[fn.Name.Name] = true
+	}
+	if len(seen) != len(owners) || helper == nil || helper.Body == nil {
+		return fmt.Errorf("independent numerical deadline owners/helper missing")
+	}
+	factories, fingerprints, sourceGuards, frameGuards, translations := 0, []token.Pos{}, []token.Pos{}, []token.Pos{}, []token.Pos{}
+	var factory *ast.CallExpr
+	var forbidden string
+	ast.Inspect(helper.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if name, ok := call.Fun.(*ast.Ident); ok {
+			switch name.Name {
+			case "numericalLocalJoinedFactory":
+				factories++
+				factory = call
+			case "x86CallerSourceFingerprint":
+				fingerprints = append(fingerprints, call.Pos())
+			case "numericalFamilyTranslate":
+				translations = append(translations, call.Pos())
+			}
+		}
+		if selector, ok := call.Fun.(*ast.SelectorExpr); ok {
+			if strings.HasPrefix(selector.Sel.Name, "Skip") || selector.Sel.Name == "Run" {
+				forbidden = selector.Sel.Name
+			}
+			if receiver, ok := selector.X.(*ast.Ident); ok && selector.Sel.Name == "Verify" {
+				if receiver.Name == "source" {
+					sourceGuards = append(sourceGuards, call.Pos())
+				}
+				if receiver.Name == "frame" {
+					frameGuards = append(frameGuards, call.Pos())
+				}
+			}
+		}
+		return true
+	})
+	if forbidden != "" || factories != 1 || len(fingerprints) != 2 || len(sourceGuards) != 1 || len(frameGuards) != 1 || len(translations) != 1 {
+		return fmt.Errorf("complete fresh producer/original-source/final-owner guards changed")
+	}
+	direct := false
+	for _, statement := range helper.Body.List {
+		if assignment, ok := statement.(*ast.AssignStmt); ok && len(assignment.Rhs) == 1 && assignment.Rhs[0] == factory {
+			direct = true
+		}
+	}
+	if !direct || fingerprints[0] <= factory.Pos() || fingerprints[0] >= translations[0] ||
+		sourceGuards[0] <= translations[0] || frameGuards[0] <= translations[0] ||
+		fingerprints[1] <= sourceGuards[0] || fingerprints[1] <= frameGuards[0] {
+		return fmt.Errorf("fresh producer or final guards moved into a shared/partial lifecycle")
+	}
+	return nil
+}
+
+func TestX86ResultAUTONumericalJoinHasIndependentCompleteOwners(t *testing.T) {
+	source, err := os.ReadFile("x86_result_auto_numerical_join_go127_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := numericalJoinOwners(source); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86ResultAUTONumericalJoinOwnerPolicyRejectsMissingOrSharedAxes(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("package model\n")
+	for suffix, axis := range map[string]string{"OriginalSourceShape": "original-source-shape", "Text": "text", "Context": "context", "GoModule": "go-module"} {
+		fmt.Fprintf(&source, "func %s%s(t *testing.T) { %s(t,%q) }\n", numericalJoinOwnerPrefix, suffix, numericalJoinOwnerHelper, axis)
+	}
+	source.WriteString("func " + numericalJoinOwnerHelper + `(t *testing.T, api string) {
+_,pkg,file,bound,source,frame := numericalLocalJoinedFactory(t)
+x86CallerSourceFingerprint(file)
+numericalFamilyTranslate(t,api,pkg,file,bound)
+source.Verify(bound.context)
+frame.Verify(bound.context)
+x86CallerSourceFingerprint(file)
+}
+`)
+	model := source.String()
+	if err := numericalJoinOwners([]byte(model)); err != nil {
+		t.Fatal("valid ownership-only AST model", err)
+	}
+	for name, mutate := range map[string]func(string) string{
+		"missing owner": func(s string) string { return strings.Replace(s, numericalJoinOwnerPrefix+"Text", "NotAnOwner", 1) },
+		"duplicate owner": func(s string) string {
+			return s + "func " + numericalJoinOwnerPrefix + "Text(t *testing.T) { " + numericalJoinOwnerHelper + "(t,\"text\") }"
+		},
+		"wrong axis": func(s string) string { return strings.Replace(s, `"go-module"`, `"context"`, 1) },
+		"root shared loop": func(s string) string {
+			return strings.Replace(s, numericalJoinOwnerHelper+`(t,"text")`, "for _,api:=range axes { "+numericalJoinOwnerHelper+"(t,api) }", 1)
+		},
+		"shared subtest": func(s string) string {
+			return strings.Replace(s, numericalJoinOwnerHelper+`(t,"text")`, `t.Run("text",func(t *testing.T){ `+numericalJoinOwnerHelper+`(t,"text") })`, 1)
+		},
+		"missing fresh factory": func(s string) string {
+			return strings.Replace(s, "numericalLocalJoinedFactory(t)", "cachedFactory(t)", 1)
+		},
+		"factory inside loop": func(s string) string {
+			return strings.Replace(s, "_,pkg,file,bound,source,frame := numericalLocalJoinedFactory(t)", "for range axes { _,pkg,file,bound,source,frame := numericalLocalJoinedFactory(t) }", 1)
+		},
+		"duplicate fresh factory": func(s string) string {
+			return strings.Replace(s, "numericalLocalJoinedFactory(t)", "numericalLocalJoinedFactory(t); numericalLocalJoinedFactory(t)", 1)
+		},
+		"missing source guard": func(s string) string {
+			return strings.Replace(s, "source.Verify(bound.context)", "source.Unchecked(bound.context)", 1)
+		},
+		"missing frame guard": func(s string) string {
+			return strings.Replace(s, "frame.Verify(bound.context)", "frame.Unchecked(bound.context)", 1)
+		},
+		"missing source fingerprint": func(s string) string {
+			return strings.Replace(s, "x86CallerSourceFingerprint(file)", "unverifiedFingerprint(file)", 1)
+		},
+		"early final guards": func(s string) string {
+			return strings.Replace(s, "numericalFamilyTranslate(t,api,pkg,file,bound)\nsource.Verify(bound.context)\nframe.Verify(bound.context)", "source.Verify(bound.context)\nframe.Verify(bound.context)\nnumericalFamilyTranslate(t,api,pkg,file,bound)", 1)
+		},
+		"final fingerprint before source guard": func(s string) string {
+			return strings.Replace(s, "source.Verify(bound.context)\nframe.Verify(bound.context)\nx86CallerSourceFingerprint(file)", "frame.Verify(bound.context)\nx86CallerSourceFingerprint(file)\nsource.Verify(bound.context)", 1)
+		},
+		"skip": func(s string) string {
+			return strings.Replace(s, "source.Verify(bound.context)", "t.Skip(\"missing tools\")", 1)
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			if err := numericalJoinOwners([]byte(mutate(model))); err == nil {
+				t.Fatal("incomplete/shared deadline owner passed")
+			}
+		})
+	}
+}
diff --git a/x86_result_auto_numerical_test.go b/x86_result_auto_numerical_test.go
new file mode 100644
index 000000000..3437a35f4
--- /dev/null
+++ b/x86_result_auto_numerical_test.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestX86ResultAUTOReplayDoesNotWashUnboundSourceRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$32-4\nMOVL $1,spill-8(SP)\nMOVL spill-8(SP),AX\nMOVL AX,ret+0(FP)\nRET")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if extent, err := x86ResultAUTOExtent(file.Funcs[0], arch); err != nil || extent != 32 {
+			t.Fatal("unchanged logical source precondition", extent, err)
+		}
+		for name, mutate := range map[string]func(*Instr){
+			"missing binding": func(ins *Instr) { ins.x86NumericalRead = &x86NumericalReadCertificate{} },
+			"empty binding": func(ins *Instr) {
+				ins.x86NumericalRead = &x86NumericalReadCertificate{binding: &GoX86NumericalReadBinding{}}
+			},
+			"copied nonfactory token": func(ins *Instr) {
+				ins.x86NumericalRead = &x86NumericalReadCertificate{binding: &GoX86NumericalReadBinding{source: &GoX86NumericalReadSource{}}}
+			},
+			"physical encoding": func(ins *Instr) { ins.x86Encoded = true },
+			"source stack role": func(ins *Instr) { ins.x86SourceStackFP = map[int]int64{0: 0} },
+			"SDK literal role":  func(ins *Instr) { ins.x86SDKLiteral = &x86SDKLiteralCertificate{} },
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				fn := file.Funcs[0]
+				fn.Instrs = append([]Instr(nil), fn.Instrs...)
+				mutate(&fn.Instrs[1])
+				before := fn.Instrs[1]
+				if _, err := x86ResultAUTOExtent(fn, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unbound metadata was silently discarded during source replay", err)
+				}
+				if !reflect.DeepEqual(before, fn.Instrs[1]) {
+					t.Fatal("source role observer mutated the original instruction")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_auto_runtime_test.go b/x86_result_auto_runtime_test.go
new file mode 100644
index 000000000..781d8536c
--- /dev/null
+++ b/x86_result_auto_runtime_test.go
@@ -0,0 +1,122 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86LogicalAUTOInitializedBytesAndCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, goTest, reference strings.Builder
+	declarations.WriteString("package autoscalar\n")
+	goTest.WriteString(`package autoscalar
+import("testing";"math")
+func TestOriginal(t *testing.T) {
+ for sample:=uint64(0);sample<257;sample++ {
+  x:=sample*0x9e3779b97f4a7c15
+`)
+	reference.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	for _, row := range []struct {
+		name, move string
+		width      int
+	}{
+		{"Byte", "MOVB", 1}, {"Word", "MOVW", 2}, {"Long", "MOVL", 4}, {"Quad", "MOVQ", 8},
+	} {
+		fmt.Fprintf(&declarations, "func %s(x uint64) uint64\n", row.name)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$32-16\nXORQ AX,AX\n%s x+0(FP),AX\n%s AX,first-16(SP)\nXORQ AX,AX\n%s second-16(SP),AX\nMOVQ AX,ret0+8(FP)\nRET\n",
+			row.name, row.move, row.move, row.move)
+		mask := ^uint64(0)
+		if row.width < 8 {
+			mask = uint64(1)<<(8*row.width) - 1
+		}
+		fmt.Fprintf(&goTest, "if got:=%s(x);got!=x&0x%x {t.Fatalf(\"%s sample%%d got%%x want%%x\",sample,got,x&0x%x)}\n", row.name, mask, row.name, mask)
+		fmt.Fprintf(&reference, "extern uint64_t %s(uint64_t);\n", row.name)
+	}
+	for _, row := range []struct {
+		name, typ, move string
+		args            int
+	}{
+		{"Single", "float32", "MOVSS", 12}, {"Double", "float64", "MOVSD", 16},
+	} {
+		fmt.Fprintf(&declarations, "func %s(x %s) %s\n", row.name, row.typ, row.typ)
+		fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$32-%d\n%s x+0(FP),X0\n%s X0,first-16(SP)\n%s second-16(SP),X1\n%s X1,ret0+8(FP)\nRET\n",
+			row.name, row.args, row.move, row.move, row.move, row.move)
+		if row.typ == "float32" {
+			goTest.WriteString("if got:=math.Float32bits(Single(math.Float32frombits(uint32(x))));got!=uint32(x) {t.Fatalf(\"single sample%d got%x want%x\",sample,got,uint32(x))}\n")
+			reference.WriteString("extern float Single(float);\n")
+		} else {
+			goTest.WriteString("if got:=math.Float64bits(Double(math.Float64frombits(x)));got!=x {t.Fatalf(\"double sample%d got%x want%x\",sample,got,x)}\n")
+			reference.WriteString("extern double Double(double);\n")
+		}
+	}
+	goTest.WriteString("}\n}\n")
+	dir := t.TempDir()
+	for name, source := range map[string]string{
+		"go.mod": "module autoscalar\n\ngo 1.20\n", "auto.go": declarations.String(),
+		"auto_amd64.s": assembly.String(), "auto_test.go": goTest.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("original Go AUTO numerical oracle has no successful terminal: %s", output)
+	}
+	reference.WriteString(`int main(void) {
+ for(uint64_t sample=0;sample<257;sample++) {
+  uint64_t x=sample*UINT64_C(0x9e3779b97f4a7c15);
+  struct {uint64_t left,values[6],right;} out;
+  memset(&out,0xc3,sizeof(out));
+  out.values[0]=Byte(x);out.values[1]=Word(x);out.values[2]=Long(x);out.values[3]=Quad(x);
+  uint32_t small=(uint32_t)x,smallOut;float f;double d;uint64_t largeOut;
+  memcpy(&f,&small,4);f=Single(f);memcpy(&smallOut,&f,4);out.values[4]=smallOut;
+  memcpy(&d,&x,8);d=Double(d);memcpy(&largeOut,&d,8);out.values[5]=largeOut;
+  const uint64_t want[]={x&255,x&65535,x&UINT64_C(0xffffffff),x,(uint32_t)x,x};
+  if(out.left!=UINT64_C(0xc3c3c3c3c3c3c3c3)||out.right!=UINT64_C(0xc3c3c3c3c3c3c3c3)||memcmp(out.values,want,sizeof(want))) {
+   fprintf(stderr,"AUTO sample%llu byte/alias/canary mismatch\n",(unsigned long long)sample);return 1;
+  }
+ }
+ return 0;
+}
+`)
+	pkg := mustGoPackage(t, "example.invalid/autoscalar", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "logical-auto", ir, reference.String(), level)
+		})
+	}
+	t.Log("original Go 6 initialized AUTO kernels × 257 inputs; LLVM O0/O2 exact scalar bits and full output canaries; no native frame permission produced")
+}
diff --git a/x86_result_auto_test.go b/x86_result_auto_test.go
new file mode 100644
index 000000000..6cf4ec37f
--- /dev/null
+++ b/x86_result_auto_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This fixture establishes only original Go AUTO byte behavior. It does not
+// bind a native frame, caller memory, address lifetime or a translation right.
+func x86ResultAUTOFixture(t *testing.T, arch, declaration string, frame int, body string) (*File, FuncSig, string) {
+	t.Helper()
+	_, _, sig, source := x86ResultInitializationFixture(t, arch, declaration, body)
+	source = strings.Replace(source, ",$0-", fmt.Sprintf(",$%d-", frame), 1)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	goAssemblerOracleOutput(t, arch, source, "", true)
+	return file, sig, source
+}
+
+func TestX86ABI0ResultInitializationNamedAUTONumericByteDomain(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := []struct{ typ, move, register string }{
+			{"uint8", "MOVB", "AX"}, {"uint16", "MOVW", "AX"}, {"uint32", "MOVL", "AX"},
+			{"float32", "MOVSS", "X0"}, {"float64", "MOVSD", "X0"},
+		}
+		if arch == "amd64" {
+			rows = append(rows, struct{ typ, move, register string }{"uint64", "MOVQ", "R14"})
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.move, func(t *testing.T) {
+				_, _, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(x "+row.typ+") "+row.typ, "RET")
+				body := fmt.Sprintf("%s x+0(FP),%s\n%s %s,spill-16(SP)\n%s spill-16(SP),%s\n%s %s,ret0+%d(FP)\nRET",
+					row.move, row.register, row.move, row.register, row.move, row.register, row.move, row.register, sig.Frame.Results[0].Offset)
+				file, signature, source := x86ResultAUTOFixture(t, arch, "func Value(x "+row.typ+") "+row.typ, 32, body)
+				before := fmt.Sprintf("%#v %#v", file, signature)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signature, arch); err != nil {
+					t.Fatalf("actual initialized logical AUTO bytes remain unmodeled: %v\n%s", err, source)
+				}
+				if after := fmt.Sprintf("%#v %#v", file, signature); after != before {
+					t.Fatal("observer changed actual source or typed layout")
+				}
+			})
+		}
+	}
+	for name, body := range map[string]string{
+		"overlapping names are physical bytes": "MOVL $7,first-16(SP)\nMOVL $9,second-12(SP)\nMOVQ third-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"all branch stores":                    "MOVL $1,AX\nCMPL AX,$0\nJE other\nMOVQ $7,a-16(SP)\nJMP end\nother:\nMOVQ $9,b-16(SP)\nend:\nMOVQ c-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"initialized scalar loop":              "MOVL $3,count-8(SP)\nMOVQ $7,value-16(SP)\nloop:\nMOVL count-8(SP),AX\nSUBL $1,AX\nMOVL AX,count-8(SP)\nCMPL AX,$0\nJNE loop\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"byte SET into AUTO":                   "MOVQ $0,value-16(SP)\nMOVL $7,AX\nCMPL AX,$0\nSETNE value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, sig, source := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatalf("actual defined byte/CFG AUTO input remains unmodeled: %v\n%s", err, source)
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultInitializationAUTOUnknownAndEscapeStayContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"entry not initialized":       "MOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"missing upper AUTO bytes":    "MOVL $1,value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"missing GP byte stored":      "MOVB $1,AX\nMOVQ AX,value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"join missing initialization": "MOVL $1,AX\nCMPL AX,$0\nJE end\nMOVQ $7,value-16(SP)\nend:\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"loop no entry definition":    "MOVL $1,AX\nJMP condition\nbody:\nMOVQ $1,value-16(SP)\ncondition:\nCMPL AX,$0\nJNE body\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"AUTO positive offset":        "MOVQ $1,value+0(SP)\nMOVQ value+0(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"past frame start":            "MOVQ $1,value-40(SP)\nMOVQ value-40(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"cross frame end":             "MOVQ $1,value-4(SP)\nMOVQ value-4(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"physical SP not AUTO":        "MOVQ $1,-16(SP)\nMOVQ -16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"address materialization":     "MOVQ $1,value-16(SP)\nLEAQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"SP copied":                   "MOVQ SP,AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"SP adjusted":                 "ADDQ $8,SP\nMOVQ $1,value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"unknown native load":         "MOVQ $1,value-16(SP)\nMOVQ (R8),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"calling frame":               "MOVQ $1,value-16(SP)\nCALL ·Other(SB)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"raw instruction":             "MOVQ $1,value-16(SP)\nBYTE $0x90\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"dead unknown effect":         "MOVQ $1,value-16(SP)\nJMP end\nMOVQ (R8),AX\nend:\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("unknown bytes/address/call/extent were washed into result initialization: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultInitializationAUTOLiteralRoleCannotBeInvented(t *testing.T) {
+	file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32,
+		"MOVQ $1,value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET")
+	for name, mutate := range map[string]func(*Func){
+		"different parsed offset": func(fn *Func) { fn.Instrs[1].Args[1].Mem.Off = -24 },
+		"different original role": func(fn *Func) { fn.Instrs[1].Raw = "MOVQ $1,-16(SP)" },
+		"empty original literal":  func(fn *Func) { fn.Instrs[1].Raw = "" },
+		"different TEXT frame":    func(fn *Func) { fn.FrameSize = 64 },
+		"no AUTO extent":          func(fn *Func) { fn.FrameSize = 0 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			for index := range fn.Instrs {
+				fn.Instrs[index].Args = append([]Operand(nil), fn.Instrs[index].Args...)
+			}
+			mutate(&fn)
+			before := fmt.Sprintf("%#v %#v", fn, sig)
+			if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("changed AUTO source identity obtained byte knowledge: %v", err)
+			}
+			if !reflect.DeepEqual(before, fmt.Sprintf("%#v %#v", fn, sig)) {
+				t.Fatal("observer modified identity to manufacture AUTO source")
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultInitializationAUTOScalarVectorAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, move := range []string{"MOVSS", "MOVSD"} {
+			t.Run(arch+"/"+move, func(t *testing.T) {
+				// A legacy scalar memory load clears the other X bytes. A
+				// register copy, however, does not initialize those bytes.
+				body := "MOVL $7,value-16(SP)\n"
+				if move == "MOVSD" {
+					body += "MOVL $9,value-12(SP)\n"
+				}
+				body += move + " value-16(SP),X1\nMOVSD X1,ret0+0(FP)\nRET"
+				file, sig, _ := x86ResultAUTOFixture(t, arch, "func Value() float64", 32, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("actual scalar memory load's upper zeros were lost: %v", err)
+				}
+				if move == "MOVSS" {
+					body = strings.Replace(body, "MOVSD X1,ret0", "MOVSS X1,X0\nMOVSD X0,ret0", 1)
+					file, sig, _ = x86ResultAUTOFixture(t, arch, "func Value() float64", 32, body)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("register merge invented unknown upper bytes: %v", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultInitializationAUTOSourceAndSharedBudget(t *testing.T) {
+	for _, spelling := range []string{"spill-0x10(SP)", "spill-(8+8)(SP)", "spill-16( SP )"} {
+		t.Run(spelling, func(t *testing.T) {
+			body := "MOVQ $7," + spelling + "\nMOVQ " + spelling + ",AX\nMOVQ AX,ret0+0(FP)\nRET"
+			file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatalf("actual evaluable named AUTO spelling was lost: %v", err)
+			}
+		})
+	}
+	for name, frame := range map[string]int{"complete combined byte budget": 4096, "frame extent bounded": 4104} {
+		t.Run(name, func(t *testing.T) {
+			body := "MOVQ $7,value-16(SP)\n" + strings.Repeat("NOP\n", 2100) + "MOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET"
+			file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", frame, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("oversized logical domain obtained initialization: %v", err)
+			}
+		})
+	}
+	file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32,
+		"MOVQ $7,value-16(SP)\nMOVQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET")
+	// Explicit source mutations, not claimed actual assembler diagnostics.
+	for name, mutate := range map[string]func(*Func){
+		"extra TEXT":                 func(fn *Func) { fn.Instrs[1].Raw = "TEXT ·Other(SB),4,$32-8\nMOVQ $7,value-16(SP)" },
+		"unknown operand extent":     func(fn *Func) { fn.Instrs[1].Args[1].Mem.OffRaw = "unknown" },
+		"different symbol":           func(fn *Func) { fn.Sym = "·Other" },
+		"oversized original literal": func(fn *Func) { fn.Instrs[1].Raw = strings.Repeat(" ", 1<<20) + fn.Instrs[1].Raw },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			for index := range fn.Instrs {
+				fn.Instrs[index].Args = append([]Operand(nil), fn.Instrs[index].Args...)
+			}
+			mutate(&fn)
+			if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("invented source/budget obtained byte initialization: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultInitializationAUTOExistingTranslationContracts(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		for _, row := range []struct{ typ, move, register string }{
+			{"uint8", "MOVB", "AX"}, {"uint16", "MOVW", "AX"}, {"uint32", "MOVL", "AX"},
+			{"float32", "MOVSS", "X0"}, {"float64", "MOVSD", "X0"},
+		} {
+			t.Run(target.triple+"/"+row.move, func(t *testing.T) {
+				pkg, _, sig, _ := x86ResultInitializationFixture(t, target.arch, "func Value(x "+row.typ+") "+row.typ, "RET")
+				body := fmt.Sprintf("%s x+0(FP),%s\n%s %s,spill-16(SP)\n%s spill-16(SP),%s\n%s %s,ret0+%d(FP)\nRET",
+					row.move, row.register, row.move, row.register, row.move, row.register, row.move, row.register, sig.Frame.Results[0].Offset)
+				file, sig, source := x86ResultAUTOFixture(t, target.arch, "func Value(x "+row.typ+") "+row.typ, 32, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+					ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+				text, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, text, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch,
+					TargetTriple: target.triple, ResolveSym: options.ResolveSym})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+			})
+		}
+	}
+}
diff --git a/x86_result_bitcount_test.go b/x86_result_bitcount_test.go
new file mode 100644
index 000000000..362b77213
--- /dev/null
+++ b/x86_result_bitcount_test.go
@@ -0,0 +1,90 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ABI0ResultBitCountCompleteByteEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move := 8, "uint64", "MOVQ"
+		if arch == "386" {
+			word, typ, move = 4, "uint32", "MOVL"
+		}
+		for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			for _, suffix := range []string{"W", "L", "Q"} {
+				for _, input := range []string{"AX", "x+0(FP)", "local-16(SP)"} {
+					op := family + suffix
+					t.Run(arch+"/"+op+"/"+input, func(t *testing.T) {
+						body := fmt.Sprintf("%s x+0(FP),AX\n%s $0,BX\n%s AX,local-16(SP)\n%s %s,BX\n%s BX,ret0+%d(FP)\nRET",
+							move, move, move, op, input, move, word)
+						_, _, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x "+typ+") "+typ, body)
+						source = strings.Replace(source, ",$0-", ",$32-", 1)
+						rejected := arch == "386" && suffix == "Q"
+						goAssemblerOracleOutput(t, arch, source, "", !rejected)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil {
+							t.Fatal(err)
+						}
+						err = CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+						if rejected {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("mode32 acquired Q-width result bytes: %v", err)
+							}
+						} else if err != nil {
+							t.Fatalf("Go-accepted bit count has no numerical byte effect: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultBitCountFlagsAndUnknownBytes(t *testing.T) {
+	for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+		t.Run(family+"/opaque-pointer-is-not-numerical", func(t *testing.T) {
+			body := "MOVQ x+0(FP),AX\n" + family + "Q AX,BX\nMOVQ BX,ret0+8(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x *byte) uint64", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("opaque pointer became countable numerical bytes: %v", err)
+			}
+		})
+		for _, condition := range []string{"CC", "CS", "EQ", "NE", "HI", "LS", "GE", "LT", "GT", "LE", "MI", "PL", "OC", "OS", "PC", "PS"} {
+			t.Run(family+"/"+condition, func(t *testing.T) {
+				body := "MOVL $3,AX\nCMPL AX,$0\n" + family + "L AX,BX\nSET" + condition + " ret0+0(FP)\nRET"
+				_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint8", body)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+				defined := family == "POPCNT" || condition == "CC" || condition == "CS" ||
+					condition == "EQ" || condition == "NE" || condition == "HI" || condition == "LS"
+				if defined && err != nil || !defined && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("wrong count FLAGS knowledge: defined=%t error=%v", defined, err)
+				}
+			})
+		}
+		for name, body := range map[string]string{
+			"unknown source":       family + "Q AX,BX",
+			"partial source":       "MOVB $1,AX\n" + family + "Q AX,BX",
+			"word preserves upper": "MOVL $1,AX\n" + family + "W AX,BX",
+			"unbound native read":  "MOVQ $0,AX\n" + family + "Q (AX),BX",
+			"unknown AUTO":         "MOVB $1,local-16(SP)\n" + family + "Q local-16(SP),BX",
+		} {
+			t.Run(family+"/"+name, func(t *testing.T) {
+				_, _, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", body+"\nMOVQ BX,ret0+0(FP)\nRET")
+				source = strings.Replace(source, ",$0-", ",$32-", 1)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("bit count invented source, memory or upper result bytes: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_bitscan.go b/x86_result_bitscan.go
new file mode 100644
index 000000000..cc2821b5d
--- /dev/null
+++ b/x86_result_bitscan.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+// A pending scan result is tied to its immediately following ZF branch.
+// It is not a known value, nonzero-input claim, pointer or memory permission.
+// The zero edge retains exactly its prior numerical byte knowledge; only the
+// nonzero edge independently defines the written destination. Older dword
+// zero-input opcodes may clear the upper half instead of preserving it: a
+// previously known byte stays known in either case, but an unknown one does
+// not become known without that nonzero edge. No CPU generation is guessed.
+type x86ResultBitScanPending struct {
+	register uint8
+	mask     uint8 // Zero means there is no pending definition.
+}
+
+func x86ResultBitScanStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultBitScanStepWithRead(ins, state, owned, arch, false)
+}
+
+// Only the paired exact-width volatile emitter may supply numerical source
+// bytes after its read. Standalone queries, source permissions and the
+// zero-input prior destination retain their independent requirements.
+func x86ResultBitScanStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	spec, known, err := x86ScalarBitScanProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false, true // Named effects never inherit a raw/native source role.
+	}
+	width := int64(spec.bits / 8)
+	index, mask, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+	if !valid || !x86ResultReadWithNativeContinuation(ins, ins.Args[0], width, state, owned, arch, native) {
+		return false, true
+	}
+	if width == 4 && arch == "amd64" {
+		mask = 0xff // The valid dword result also clears the upper dword.
+	}
+	// Every affected byte is either its prior numerical value on zero input
+	// (or known zero for the historical dword upper-half behavior) or a defined
+	// scan result on nonzero input. Preserve knowledge, never invent a value.
+	state.canonicalGP[index] &^= mask
+	state.pointerGP[index], state.callerAddressGP[index] = false, false
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	state.flags = x86ByteFlagZF // Other flags have no portable cross-CPU definition.
+	state.bitScanPending = x86ResultBitScanPending{register: uint8(index), mask: mask}
+	nonzero := false
+	if ins.Args[0].Kind == OpReg && state.predicate.kind == x86ResultNonzeroMaskGP && int(state.predicate.width) <= spec.bits {
+		source, _, valid := x86ResultGP(ins.Args[0].Reg, width, arch)
+		nonzero = valid && uint8(source) == state.predicate.register
+	}
+	if state.shapeOnly || nonzero {
+		state.gp[index] |= mask // Shape validation is never a reaching-state proof.
+	}
+	if nonzero {
+		state.bitScanPending = x86ResultBitScanPending{}
+	}
+	return true, true
+}
+
+func x86ResultBitScanEdge(state x86ResultState, ins Instr, edge int) x86ResultState {
+	if !isAMD64ConditionalBranch(ins.Op) {
+		return state
+	}
+	pending := state.bitScanPending
+	state.bitScanPending = x86ResultBitScanPending{}
+	if pending.mask == 0 {
+		return state
+	}
+	nonzero := false
+	switch ins.Op {
+	case "JE", "JEQ", "JZ":
+		nonzero = edge == 0 // CFG edges retain fallthrough before taken.
+	case "JNE", "JNZ":
+		nonzero = edge == 1
+	}
+	if nonzero {
+		state.gp[pending.register] |= pending.mask
+	}
+	return state
+}
diff --git a/x86_result_bitscan_test.go b/x86_result_bitscan_test.go
new file mode 100644
index 000000000..d9946677d
--- /dev/null
+++ b/x86_result_bitscan_test.go
@@ -0,0 +1,219 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarBitScanCompleteOfficialRowsAndOperandGrammar(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := []string{
+		"{ABSFL, yml_rl, Pm, opBytes{0xbc}}", "{ABSFQ, yml_rl, Pw, opBytes{0x0f, 0xbc}}",
+		"{ABSFW, yml_rl, Pq, opBytes{0xbc}}", "{ABSRL, yml_rl, Pm, opBytes{0xbd}}",
+		"{ABSRQ, yml_rl, Pw, opBytes{0x0f, 0xbd}}", "{ABSRW, yml_rl, Pq, opBytes{0xbd}}",
+		"var yml_rl = []ytab{\n\t{Zm_r, 1, argList{Yml, Yrl}},\n}",
+	}
+	if len(x86ScalarBitScanSpecs) != len(rows)-1 {
+		t.Fatal("incomplete scalar scan family")
+	}
+	for _, row := range rows {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("complete original Go bit-scan encoding row changed", row)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			for _, operands := range []struct {
+				text  string
+				valid bool
+			}{
+				{"AX,BX", true}, {"x+0(FP),BX", true}, {"4(AX)(CX*2),BX", true}, {"table(SB),BX", true},
+				{"AL,BX", false}, {"X0,BX", false}, {"$3,BX", false}, {"$table(SB),BX", false},
+				{"AX,AH", false}, {"AX,X0", false}, {"AX,4(BX)", false}, {"AX", false}, {"AX,BX,CX", false},
+			} {
+				t.Run(arch+"/"+op+"/"+operands.text, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+" "+operands.text)
+					_, known, err := x86ScalarBitScanProperties(ins.Op, ins, arch)
+					want := operands.valid && !(arch == "386" && strings.HasSuffix(op, "Q"))
+					if !known || (err == nil) != want {
+						t.Fatal("scan grammar disagrees with complete Yml/Yrl rows", known, err, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultBitScanZeroBranchDefinesOnlyNonzeroEdge(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, family := range []string{"BSF", "BSR"} {
+			for _, width := range []struct{ suffix, typ, move string }{
+				{"W", "uint16", "MOVW"}, {"L", "uint32", "MOVL"}, {"Q", "uint64", "MOVQ"},
+			} {
+				if arch == "386" && width.suffix == "Q" {
+					continue // The official mode32 Q row is independently rejected.
+				}
+				for _, branch := range []string{"JE", "JEQ", "JZ", "JNE", "JNZ"} {
+					t.Run(arch+"/"+family+width.suffix+"/"+branch, func(t *testing.T) {
+						word := 8
+						if arch == "386" {
+							word = 4
+						}
+						prefix := fmt.Sprintf("%s x+0(FP),AX\n%s AX,BX\n", width.move, family+width.suffix)
+						good := fmt.Sprintf("%s BX,ret+%d(FP)\nRET\n", width.move, word)
+						zero := fmt.Sprintf("%s $0,ret+%d(FP)\nRET\n", width.move, word)
+						body := prefix + branch + " zero\n" + good + "zero:\n" + zero
+						if branch == "JNE" || branch == "JNZ" {
+							body = prefix + branch + " nonzero\n" + zero + "nonzero:\n" + good
+						}
+						_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(x "+width.typ+") "+width.typ, body)
+						if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+							t.Fatal("complete zero-guarded scan rejected", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultBitScanUndefinedValuesAndFlagsRemainContext(t *testing.T) {
+	for _, family := range []string{"BSF", "BSR"} {
+		for name, body := range map[string]string{
+			"unguarded":                    "MOVL x+0(FP),AX\nSCAN AX,BX\nMOVL BX,ret+8(FP)\nRET",
+			"zero edge observed":           "MOVL x+0(FP),AX\nSCAN AX,BX\nJNZ nonzero\nMOVL BX,ret+8(FP)\nRET\nnonzero:\nMOVL $0,ret+8(FP)\nRET",
+			"defined flags are not values": "MOVL x+0(FP),AX\nSCAN AX,BX\nSETEQ CL\nMOVL BX,ret+8(FP)\nRET",
+			"flags replaced":               "MOVL x+0(FP),AX\nSCAN AX,BX\nCMPL AX,$0\nJZ zero\nMOVL BX,ret+8(FP)\nRET\nzero:\nMOVL $0,ret+8(FP)\nRET",
+			"undefined carry":              "MOVL x+0(FP),AX\nSCAN AX,BX\nJCS zero\nMOVL $0,ret+8(FP)\nRET\nzero:\nMOVL $0,ret+8(FP)\nRET",
+			"unknown source":               "SCAN AX,BX\nJZ zero\nMOVL BX,ret+8(FP)\nRET\nzero:\nMOVL $0,ret+8(FP)\nRET",
+		} {
+			t.Run(family+"/"+name, func(t *testing.T) {
+				body = strings.ReplaceAll(body, "SCAN", family+"L")
+				_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(x uint32) uint32", body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("undefined scan acquired a result/FLAGS proof", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultBitScanGuardedByteAliasesAndCFGJoins(t *testing.T) {
+	for _, family := range []string{"BSF", "BSR"} {
+		for name, fixture := range map[string]struct {
+			body string
+			pass bool
+		}{
+			"word preserves defined upper bytes":        {"MOVQ $0,BX\nSCANW AX,BX\nJZ zero\nMOVQ BX,ret+8(FP)\nRET\nzero:\nMOVQ $0,ret+8(FP)\nRET", true},
+			"word cannot define unknown upper bytes":    {"SCANW AX,BX\nJZ zero\nMOVQ BX,ret+8(FP)\nRET\nzero:\nMOVQ $0,ret+8(FP)\nRET", false},
+			"dword clears upper on nonzero edge":        {"SCANL AX,BX\nJZ zero\nMOVQ BX,ret+8(FP)\nRET\nzero:\nMOVQ $0,ret+8(FP)\nRET", true},
+			"source destination alias":                  {"SCANQ AX,AX\nJZ zero\nMOVQ AX,ret+8(FP)\nRET\nzero:\nMOVQ $0,ret+8(FP)\nRET", true},
+			"both edges cannot merge scan result":       {"SCANQ AX,BX\nJZ joined\njoined:\nMOVQ BX,ret+8(FP)\nRET", false},
+			"zero result replaced before joining":       {"SCANQ AX,BX\nJNZ joined\nMOVQ $0,BX\njoined:\nMOVQ BX,ret+8(FP)\nRET", true},
+			"guard does not initialize other registers": {"SCANQ AX,BX\nJZ zero\nMOVQ CX,ret+8(FP)\nRET\nzero:\nMOVQ $0,ret+8(FP)\nRET", false},
+		} {
+			t.Run(family+"/"+name, func(t *testing.T) {
+				body := "MOVQ x+0(FP),AX\n" + strings.ReplaceAll(fixture.body, "SCAN", family)
+				_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint64", body)
+				err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+				if fixture.pass && err != nil || !fixture.pass && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("scan acquired wrong byte/CFG definition", fixture.pass, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanWholeSourceThreeAPIAdmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			for _, guarded := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/guarded%t", arch, op, guarded), func(t *testing.T) {
+					move, typ := "MOVQ", "uint64"
+					if arch == "386" {
+						move, typ = "MOVL", "uint32"
+					}
+					declaration := "func view(x " + typ + ") " + typ + "\n"
+					body := move + " x+0(FP),AX\n" + move + " $0,BX\n" + op + " AX,BX\n"
+					if guarded {
+						body += "JZ zero\n" + move + " BX,ret+RESULT(FP)\nRET\nzero:\n" + move + " $0,ret+RESULT(FP)"
+					} else {
+						body += move + " BX,ret+RESULT(FP)"
+					}
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					// This original source initializes the prior destination.
+					// Zero input therefore retains numerical bytes, even without
+					// the guard. Keep the source unchanged as a positive control.
+					x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, true)
+					unknown := strings.Replace(source, move+" $0,BX\n", "", 1)
+					t.Run("unknown-prior", func(t *testing.T) {
+						// Even the nonzero W edge cannot initialize a full
+						// word result's previously unknown upper bytes.
+						x86ResultGPSIMDAdmissionAPIs(t, arch, unknown, declaration, guarded && !strings.HasSuffix(op, "W"))
+					})
+				})
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultBitScanPendingStateCannotLeakAuthority(t *testing.T) {
+	base := x86ScalarLaneInstruction(t, "BSFL AX,BX")
+	for name, mutate := range map[string]func(*Instr){
+		"encoded":          func(ins *Instr) { ins.x86Encoded = true },
+		"address width":    func(ins *Instr) { ins.x86AddressBits = 32 },
+		"unbound override": func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+		"segment":          func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			ins := base
+			mutate(&ins)
+			state := x86ResultState{}
+			state.gp[0] = 0xff
+			if accepted, known := x86ResultBitScanStep(ins, &state, nil, "amd64"); accepted || !known || state.bitScanPending.mask != 0 {
+				t.Fatal("named scan borrowed a native/raw role", accepted, known, state)
+			}
+		})
+	}
+	initial := x86ResultState{bitScanPending: x86ResultBitScanPending{register: 3, mask: 0xff}}
+	for _, change := range []x86ResultBitScanPending{{}, {register: 1, mask: 0xff}, {register: 3, mask: 3}} {
+		other := initial.clone()
+		other.bitScanPending = change
+		if initial.intersect(other).bitScanPending.mask != 0 {
+			t.Fatal("different pending scan facts survived CFG intersection")
+		}
+	}
+	branch := x86ScalarLaneInstruction(t, "JNZ good")
+	nonzero := x86ResultBitScanEdge(initial, branch, 1)
+	zero := x86ResultBitScanEdge(initial, branch, 0)
+	if nonzero.gp[3] != 0xff || zero.gp[3] != 0 || nonzero.bitScanPending.mask != 0 || zero.bitScanPending.mask != 0 || initial.gp[3] != 0 {
+		t.Fatal("edge refinement contaminated sibling or predecessor state")
+	}
+}
+
+func TestX86ABI0ResultBitScanPortableStatusFlagConsumers(t *testing.T) {
+	for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+		for _, condition := range []string{"CC", "CS", "EQ", "NE", "HI", "LS", "GE", "LT", "GT", "LE", "MI", "PL", "OC", "OS", "PC", "PS"} {
+			t.Run(op+"/"+condition, func(t *testing.T) {
+				body := "MOVQ x+0(FP),AX\n" + op + " AX,BX\nSET" + condition + " ret+8(FP)\nRET"
+				_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint8", body)
+				err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+				pass := condition == "EQ" || condition == "NE"
+				if pass && err != nil || !pass && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("scan borrowed nonportable status flags", pass, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_bitscan_zero_test.go b/x86_result_bitscan_zero_test.go
new file mode 100644
index 000000000..645af808d
--- /dev/null
+++ b/x86_result_bitscan_zero_test.go
@@ -0,0 +1,263 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarBitScanNativeHelperShapesAndTargetBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, typ, word, triple := "MOVQ", "uint64", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, typ, word, triple = "MOVL", "uint32", 4, "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				declaration := "func view(x,prior " + typ + ") " + typ + "\n"
+				body := fmt.Sprintf("%s x+0(FP),AX\n%s prior+%d(FP),BX\n%s AX,BX\n%s BX,ret+RESULT(FP)", move, move, word, op, move)
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						for _, required := range []string{"noinline noredzone", "asm sideeffect", strings.ToLower(op) + " ${3:", "=r,=r,0,r,r,~{memory}", "and i" + fmt.Sprint(word*8) + " %status, 2261"} {
+							if !strings.Contains(ir, required) {
+								t.Fatal("complete native prior/status bridge missing", required)
+							}
+						}
+						if strings.Contains(ir, " = call i32 @llvm.cttz.") || strings.Contains(ir, " = call i64 @llvm.cttz.") || strings.Contains(ir, " = call i32 @llvm.ctlz.") || strings.Contains(ir, " = call i64 @llvm.ctlz.") {
+							t.Fatal("scan still invents a software zero-input destination")
+						}
+						for _, target := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+							bad, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, target, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || bad != "" {
+								t.Fatal("native scan guessed an absent/mismatched target", target, err)
+							}
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanNarrowRegisterAliasRetainsUnknownUpperBytes(t *testing.T) {
+	for _, family := range []string{"BSF", "BSR"} {
+		for _, row := range []struct {
+			suffix, argument, result string
+			pass                     bool
+		}{
+			{"W", "uint16", "uint16", true},
+			{"W", "uint16", "uint32", false},
+			{"W", "uint16", "uint64", false},
+			{"L", "uint32", "uint32", true},
+			{"L", "uint32", "uint64", false},
+			{"Q", "uint64", "uint64", true},
+		} {
+			t.Run(family+row.suffix+"/"+row.result, func(t *testing.T) {
+				declaration := fmt.Sprintf("func view(x %s) %s\n", row.argument, row.result)
+				// This existing logical register-entry role defines only the
+				// declared AX bytes. It supplies no physical Go caller/frame.
+				source := "TEXT ·view<ABIInternal>(SB),4,$0-0\n" + family + row.suffix + " AX,AX\nRET\n"
+				x86ResultGPSIMDAdmissionAPIs(t, "amd64", source, declaration, row.pass)
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanNamespaceAndMissingCompilerBridge(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·scan(SB),4,$0-0\nBSFW AX,BX\nBSRL AX,BX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	if got := x86BitScanNamespace(file, "amd64", resolve, map[string]FuncSig{"reserved": {Name: "__plan9asm_bitscan_0_amd64_bsfw"}}); got != "__plan9asm_bitscan_1_" {
+		t.Fatal("compiler helper collided with a final LLVM name", got)
+	}
+	for _, target := range []string{"", "aarch64-unknown-linux-gnu", "x86_64-unknown-linux-gnu"} {
+		for _, namespace := range []string{"", "__bound_"} {
+			if target == "x86_64-unknown-linux-gnu" && namespace != "" {
+				continue // Its complete emitted helper is tested through all APIs.
+			}
+			var output strings.Builder
+			ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, resolve, nil, "amd64", target, false)
+			ctx.bitScanNS = namespace
+			if accepted, _, err := ctx.lowerScalarBitScan("BSFW", x86ScalarLaneInstruction(t, "BSFW AX,BX")); !accepted || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("missing bridge/target was inferred from an unowned context", target, namespace, err)
+			}
+		}
+	}
+}
+
+func TestX86ResultBitScanZeroPreservesOnlyPriorNumericalBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue // The complete Go grammar has no mode32 qword row.
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" AX,BX")
+				spec := x86ScalarBitScanSpecs[Op(op)]
+				_, written, _ := x86ResultGP(BX, int64(spec.bits/8), arch)
+				if spec.bits == 32 && arch == "amd64" {
+					written = 0xff
+				}
+				for prior := 0; prior < 256; prior++ {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[3] = 0xff, uint8(prior)
+					state.canonicalGP[3] = 0xff
+					state.pointerGP[3], state.callerAddressGP[3] = true, true
+					state.resultAddressGP[3] = x86ResultSlotAddress{start: 8, end: 16, valid: true}
+					accepted, known := x86ResultBitScanStep(ins, &state, nil, arch)
+					if !accepted || !known || state.gp[3] != uint8(prior) {
+						t.Fatalf("zero input must retain exactly prior byte knowledge, not fabricate an output: prior=%02x state=%02x", prior, state.gp[3])
+					}
+					if state.canonicalGP[3] != 0xff&^written || state.pointerGP[3] || state.callerAddressGP[3] || state.resultAddressGP[3].valid || state.flags != x86ByteFlagZF {
+						t.Fatal("a numerical scan retained pointer/canonical/address or nonportable status authority", state)
+					}
+					branch := x86ScalarLaneInstruction(t, "JNZ good")
+					zero, nonzero := x86ResultBitScanEdge(state, branch, 0), x86ResultBitScanEdge(state, branch, 1)
+					if zero.gp[3] != uint8(prior) || nonzero.gp[3] != uint8(prior)|written || state.gp[3] != uint8(prior) {
+						t.Fatal("scan edge facts contaminated prior/zero/nonzero byte states")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanInitializedPriorThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, typ, word := "MOVQ", "uint64", 8
+		if arch == "386" {
+			move, typ, word = "MOVL", "uint32", 4
+		}
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				declaration := "func view(x,prior " + typ + ") " + typ + "\n"
+				body := fmt.Sprintf("%s x+0(FP),AX\n%s prior+%d(FP),BX\n%s AX,BX\n%s BX,ret+RESULT(FP)", move, move, word, op, move)
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, true)
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanUnknownPriorStillNeedsZeroEdgeContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, typ := "MOVQ", "uint64"
+		if arch == "386" {
+			move, typ = "MOVL", "uint32"
+		}
+		for _, op := range []string{"BSFW", "BSFL", "BSFQ", "BSRW", "BSRL", "BSRQ"} {
+			if arch == "386" && strings.HasSuffix(op, "Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				declaration := "func view(x " + typ + ") " + typ + "\n"
+				body := move + " x+0(FP),AX\n" + op + " AX,BX\n" + move + " BX,ret+RESULT(FP)"
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, false)
+			})
+		}
+	}
+}
+
+func TestX86ScalarBitScanOriginalGoHexWordOpsFunctionThreeAPIs(t *testing.T) {
+	assembly, err := os.ReadFile(filepath.Join("testdata", "conformance", "amd64", "conformance_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	goSource, err := os.ReadFile(filepath.Join("testdata", "conformance", "amd64", "conformance.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// This is the complete unchanged original function, not a claim that the
+	// entire conformance file or its native/runtime axes have been executed.
+	source, err := x86OriginalHexWordOpsSource(assembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	fset := token.NewFileSet()
+	parsed, err := parser.ParseFile(fset, "conformance.go", goSource, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration, matches := "", 0
+	for _, node := range parsed.Decls {
+		fn, ok := node.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != "goHexWordOps" || fn.Body != nil {
+			continue
+		}
+		declaration = string(goSource[fset.Position(fn.Pos()).Offset:fset.Position(fn.End()).Offset]) + "\n"
+		matches++
+	}
+	if matches != 1 {
+		t.Fatal("original typed declaration is missing or ambiguous", matches)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("unchanged original goHexWordOps was rejected", err)
+			}
+		})
+	}
+}
+
+func x86OriginalHexWordOpsSource(assembly []byte) (string, error) {
+	text := string(assembly)
+	start := strings.Index(text, "TEXT ·goHexWordOps(SB)")
+	if start < 0 {
+		return "", fmt.Errorf("original conformance member disappeared")
+	}
+	end := strings.Index(text[start+1:], "\nTEXT ")
+	if end < 0 {
+		return "", fmt.Errorf("complete original function boundary disappeared")
+	}
+	source := text[start : start+1+end]
+	// Check only a policy copy; return the complete original bytes unchanged
+	// for every actual translation API, including CRLF checkouts.
+	policySource := string(normalizeNativeOwnerPolicySource([]byte(source)))
+	if !strings.Contains(policySource, "MOVQ $0, AX\n\tBSFW DX, AX") {
+		return "", fmt.Errorf("original non-guarded initialized-destination counterexample changed")
+	}
+	return source, nil
+}
+
+func TestX86ScalarBitScanOriginalGoHexWordOpsSourceLineEndings(t *testing.T) {
+	const original = "TEXT ·goHexWordOps(SB), NOSPLIT, $0-16\n\tMOVQ $0, AX\n\tBSFW DX, AX\n\tRET\nTEXT ·next(SB), NOSPLIT, $0\n\tRET\n"
+	for _, newline := range []string{"\n", "\r\n"} {
+		name := "LF"
+		if newline == "\r\n" {
+			name = "CRLF"
+		}
+		t.Run(name, func(t *testing.T) {
+			assembly := strings.ReplaceAll(original, "\n", newline)
+			source, err := x86OriginalHexWordOpsSource([]byte(assembly))
+			boundary := strings.Index(assembly, "\nTEXT ·next(SB)")
+			if err != nil || source != assembly[:boundary] {
+				t.Fatal("Go-equivalent checkout changed original source selection or bytes", err)
+			}
+			changed := strings.Replace(assembly, "MOVQ $0, AX", "MOVQ $1, AX", 1)
+			if _, err := x86OriginalHexWordOpsSource([]byte(changed)); err == nil {
+				t.Fatal("changed original zero-input counterexample was accepted")
+			}
+		})
+	}
+}
diff --git a/x86_result_bittest_fp_shadow.go b/x86_result_bittest_fp_shadow.go
new file mode 100644
index 000000000..4f6fcce25
--- /dev/null
+++ b/x86_result_bittest_fp_shadow.go
@@ -0,0 +1,25 @@
+package plan9asm
+
+// The existing BIT emitter reads and, for BTC/BTR/BTS, updates these exact
+// logical shadow bytes. Only immediate indexes have a fixed FP envelope.
+// Reuse its complete span and numerical effects, not native caller storage.
+func (c *amd64Ctx) scalarBitTestFPShadowTransfer(ins Instr, state *x86ResultState,
+	owned []bool, arch string) (bool, bool) {
+	form, known, err := x86BitTestProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.destination.Kind != OpFP || form.index.Kind != OpImm {
+		return false, false
+	}
+	if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false, true
+	}
+	if _, err := c.bitTestFPSpan(form.destination.FPOffset, form.bits/8); err != nil {
+		return false, true
+	}
+	next := state.clone()
+	if !x86ResultTransfer(ins, &next, owned, 0, arch) {
+		return false, true
+	}
+	*state = next
+	return true, true
+}
diff --git a/x86_result_blend_minpos.go b/x86_result_blend_minpos.go
new file mode 100644
index 000000000..1bec06e10
--- /dev/null
+++ b/x86_result_blend_minpos.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+// Numerical byte dependencies do not authenticate raw origin or native
+// storage. Only the lowering continuation can consume the exact paired read.
+func x86ResultBlendMinposStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86BlendMinposProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(local) {
+		if !native || !x86RawBlendMinposSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	var source uint64
+	if form.memory {
+		if !x86ResultReadWithNativeContinuation(local, ins.Args[form.source], int64(form.byteWidth), state, owned, arch, native) {
+			return false, true
+		}
+		source = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.source].Reg, form.byteWidth)
+		source = state.vectorBytes(index)
+	}
+	var initialized uint64
+	if form.minimum {
+		initialized = 0xfff8 // The instruction clears bits 127:19, independently of its input values.
+		if source&0xffff == 0xffff {
+			initialized |= 7
+		}
+	} else {
+		maskIndex, _ := amd64VectorRegisterIndex(ins.Args[form.mask].Reg, form.byteWidth)
+		baseIndex, _ := amd64VectorRegisterIndex(ins.Args[form.base].Reg, form.byteWidth)
+		mask, base := state.vectorBytes(maskIndex), state.vectorBytes(baseIndex)
+		laneBytes := form.laneBits / 8
+		for at := 0; at < form.byteWidth; at++ {
+			flag := uint((at/laneBytes+1)*laneBytes - 1)
+			bit := uint64(1) << uint(at)
+			if mask&(uint64(1)<<flag) != 0 && source&bit != 0 && base&bit != 0 {
+				initialized |= bit
+			}
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, initialized, form.legacy)
+	return true, true
+}
+
+func x86RawBlendMinposSource(ins Instr, arch string) bool {
+	form, known, err := x86BlendMinposProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSourceAt(ins, arch, form.source)
+}
diff --git a/x86_result_block_native_read_runtime_unix_test.go b/x86_result_block_native_read_runtime_unix_test.go
new file mode 100644
index 000000000..199c02056
--- /dev/null
+++ b/x86_result_block_native_read_runtime_unix_test.go
@@ -0,0 +1,125 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This portable test executes the complete result-analysis path. It checks
+// continuation bytes and E6NF full-tuple faults, not native AVX512 execution.
+func TestCrossLinuxRuntimeMatrixX86BlockInsertResultFullTupleFaults(t *testing.T) {
+	llc, clang, triple, prefix := x86FloatAddSubRuntimeTools(t)
+	var source, declarations, prototypes, cases strings.Builder
+	count := 0
+	for _, chunk := range []int{16, 32} {
+		for mode := 0; mode < 3; mode++ {
+			for _, dead := range []bool{false, true} {
+				op, mask := "VINSERTF32X4", ""
+				if chunk == 32 {
+					op = "VINSERTI64X4"
+				}
+				if mode != 0 {
+					mask = "K1,"
+				}
+				if mode == 2 {
+					op += ".Z"
+				}
+				tail, discarded := "", 0
+				if dead {
+					tail, discarded = "VPXORQ Z2,Z2,Z2\n", 1
+				}
+				name := fmt.Sprintf("insert_result%d", count)
+				fmt.Fprintf(&declarations, "func %s(p *[32]byte, mask uint32) uint32\n", name)
+				fmt.Fprintf(&source, `TEXT ·%s(SB),4,$0-20
+MOVQ p+0(FP),AX
+MOVL mask+8(FP),CX
+KMOVW CX,K1
+VPXORQ Z1,Z1,Z1
+VPXORQ Z2,Z2,Z2
+MOVL $0x12345678,DX
+PINSRD $0,DX,X2
+%s $0,(AX),Z1,%sZ2
+%sPEXTRD $0,X2,AX
+MOVL AX,ret+16(FP)
+RET
+`, name, op, mask, tail)
+				fmt.Fprintf(&prototypes, "extern uint32_t %s(const uint8_t*,uint32_t);\n", name)
+				fmt.Fprintf(&cases, "{%s,%d,%d,%d},\n", name, chunk, mode, discarded)
+				count++
+			}
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+struct test {uint32_t (*run)(const uint8_t*,uint32_t); unsigned width,mode,dead;};
+` + prototypes.String() + "static const struct test cases[]={\n" + cases.String() + `};
+static int fault(const struct test *test,const uint8_t *p,uint32_t mask) {
+    pid_t child=fork();
+    if(child<0) return -1;
+    if(child==0) {
+        struct rlimit no_core={0,0};
+        if(setrlimit(RLIMIT_CORE,&no_core)) _exit(120);
+        volatile uint32_t value=test->run(p,mask);
+        (void)value;
+        _exit(0);
+    }
+    int status=0;
+    if(waitpid(child,&status,0)!=child) return -2;
+    if(WIFEXITED(status) && WEXITSTATUS(status)==0) return 0;
+    if(WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) return 1;
+    return -3;
+}
+int main(void) {
+    long page=sysconf(_SC_PAGESIZE);
+    if(page<128) return 1;
+    uint8_t *region=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+    if(region==MAP_FAILED || mprotect(region+page,page,PROT_NONE)) return 2;
+    memset(region,0x57,page);
+    uint32_t masks[]={0,1,UINT32_C(0x80000000),UINT32_MAX};
+    for(unsigned i=0;i<sizeof(cases)/sizeof(cases[0]);i++) {
+        const struct test *test=cases+i;
+        unsigned extents[]={0,test->width/2,test->width-1,test->width};
+        for(unsigned m=0;m<4;m++) {
+            uint32_t want=UINT32_C(0x57575757);
+            if(test->mode && !(masks[m]&1)) want=test->mode==1?UINT32_C(0x12345678):0;
+            if(test->dead) want=0;
+            if(test->run(region+1,masks[m])!=want) return 3;
+            /* E6NF still accesses every source byte with a zero mask, an
+               ignored high mask bit or an independently replaced result. */
+            if(fault(test,0,masks[m])!=1) return 4;
+            for(unsigned e=0;e<4;e++) {
+                int got=fault(test,region+page-extents[e],masks[m]);
+                if(got!=(extents[e]<test->width)) {
+                    fprintf(stderr,"case=%u mask=%x extent=%u result=%d\n",i,masks[m],extents[e],got);
+                    return 5;
+                }
+            }
+        }
+    }
+    return munmap(region,2*page)!=0;
+}
+`
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			compileAndRunRuntimeTestForTarget(t, llc, clang, "insert-result-faults", triple, text, driver, prefix)
+		})
+	}
+}
diff --git a/x86_result_block_native_read_test.go b/x86_result_block_native_read_test.go
new file mode 100644
index 000000000..883a92618
--- /dev/null
+++ b/x86_result_block_native_read_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultBlockNativeInsertReadCompleteSourceForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	count := 0
+	for _, row := range x86InsertExtractFormats() {
+		if !strings.HasPrefix(row, "VINSERT") || strings.HasSuffix(strings.Fields(row)[0], "PS") || !strings.Contains(row, "(BX)") {
+			continue
+		}
+		ins := x86ScalarLaneInstruction(t, row)
+		destination := ins.Args[len(ins.Args)-1].Reg
+		fmt.Fprintf(&declarations, "func load%d(p *[32]byte, mask uint32) uint32\n", count)
+		fmt.Fprintf(&source, `TEXT ·load%d(SB),4,$0-20
+MOVQ p+0(FP),AX
+MOVL mask+8(FP),CX
+KMOVW CX,K1
+VPXORQ Z1,Z1,Z1
+VPXORQ Z2,Z2,Z2
+%s
+PEXTRD $0,X%s,AX
+MOVL AX,ret+16(FP)
+RET
+`, count, strings.Replace(row, "(BX)", "(AX)", 1), string(destination)[1:])
+		// These source rows have four/five operands; mode32's rejection is
+		// an independent Go frontend axis, not an omitted object target.
+		goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+		count++
+	}
+	if count == 0 {
+		t.Fatal("missing independent memory-insertion formats")
+	}
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				if strings.Count(ir, "load volatile <") < count {
+					t.Fatal("conditional byte availability lost its paired native tuple read", api)
+				}
+				compileLLVMToObject(t, llc, triple, "native-insert.ll", "native-insert.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86ResultBlockNativeInsertReadDoesNotGrantOtherAuthority(t *testing.T) {
+	for _, row := range []string{
+		"VINSERTF32X4 $1,(AX),Z1,Z2",
+		"VINSERTI64X4.Z $1,(AX),Z1,K1,Z2",
+	} {
+		body := "MOVQ p+0(FP),AX\nVPXORQ Z1,Z1,Z1\nMOVL $0,CX\nKMOVW CX,K1\n" + row +
+			"\nPEXTRD $0,X2,AX\nMOVL AX,ret0+8(FP)\nRET"
+		_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[32]byte) uint32", body)
+		for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+			if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone observer acquired a native-memory certificate", row, err)
+			}
+		}
+		for _, bad := range []string{
+			strings.Replace(body, "(AX)", "(DX)", 1),
+			strings.Replace(body, "(AX)", "(AX)(DX*1)", 1),
+			strings.Replace(body, "MOVQ p+0(FP),AX", "MOVQ $1,AX", 1),
+			strings.Replace(body, "KMOVW CX,K1", "NOP", 1),
+		} {
+			if !strings.Contains(row, "K1") && strings.Contains(bad, "NOP") {
+				continue
+			}
+			source := "TEXT ·Value(SB),4,$0-12\n" + bad + "\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[32]byte) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("unknown native address/index/mask was laundered", row, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultBlockNativeInsertReadRawOriginStaysStrict(t *testing.T) {
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p *[32]byte) uint32",
+		"MOVQ p+0(FP),AX\nVPXORQ Z1,Z1,Z1\nVINSERTF32X4 $0,(AX),Z1,Z2\nPEXTRD $0,X2,CX\nMOVL CX,ret0+8(FP)\nRET")
+	for _, mutation := range []string{"decoded", "address size", "unknown address size", "raw TEXT", "source stack", "fixed local"} {
+		t.Run(mutation, func(t *testing.T) {
+			fn := file.Funcs[0]
+			fn.Instrs = append([]Instr(nil), fn.Instrs...)
+			switch mutation {
+			case "decoded":
+				fn.Instrs[3].x86Encoded = true
+			case "address size":
+				fn.Instrs[3].x86AddressBits = 32
+			case "unknown address size":
+				fn.Instrs[3].x86UnboundAddressOverride = true
+			case "raw TEXT":
+				fn.X86RawText = []byte{0xc3}
+			case "source stack":
+				fn.x86SourceStack = new(x86SourceStackProof)
+			case "fixed local":
+				fn.x86FixedLocal = new(x86FixedLocalProof)
+			}
+			context := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: "amd64"}
+			if err := context.checkLoweredScalarFPResultInitialization(); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("raw entry acquired the ordinary paired native read", mutation, err)
+			}
+		})
+	}
+}
diff --git a/x86_result_block_native_store_test.go b/x86_result_block_native_store_test.go
new file mode 100644
index 000000000..dc0c6ee4e
--- /dev/null
+++ b/x86_result_block_native_store_test.go
@@ -0,0 +1,212 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86BlockNativeStoreRows(arch string) []string {
+	var rows []string
+	for _, row := range x86InsertExtractFormats() {
+		if !strings.HasPrefix(row, "VEXTRACT") || strings.HasPrefix(row, "VEXTRACTPS ") ||
+			!strings.HasSuffix(row, "(BX)") || arch == "386" && strings.Contains(row, "K1") {
+			continue
+		}
+		rows = append(rows, row)
+	}
+	return rows
+}
+
+func TestX86BlockExtractStoreEmitterKeepsExactAccess(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86BlockNativeStoreRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before := output.Len()
+				known, _, err := ctx.lowerInsertExtractFamily(ins.Op, ins)
+				if !known || err != nil {
+					t.Fatal("complete extraction row rejected by its emitter", err)
+				}
+				text := output.String()[before:]
+				if strings.Contains(row, "K1") {
+					if !strings.Contains(text, "call void asm sideeffect") || !strings.Contains(text, "; vextract") {
+						t.Fatal("masked extraction lost its write-only native opcode")
+					}
+				} else {
+					chunk, _, _ := x86InsertExtractMaskedMemoryShape(row)
+					if strings.Count(text, fmt.Sprintf("store volatile <%d x i8>", chunk)) != 1 {
+						t.Fatal("unmasked extraction lost its exact observable native store")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86BlockExtractNativeStoreContinuation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86BlockNativeStoreRows(arch)
+		if len(rows) != map[string]int{"amd64": 26, "386": 14}[arch] {
+			t.Fatal("incomplete independent block-store forms", arch, len(rows))
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86InsertExtractProperties(ins, arch)
+				if !known || err != nil || !form.memoryWrite || form.spec.scalar {
+					t.Fatal("complete block-store grammar changed", err)
+				}
+				chunk, width, _ := x86InsertExtractMaskedMemoryShape(row)
+				offset := (255 % (width / chunk)) * chunk
+				selected := (uint64(1)<<uint(chunk) - 1) << uint(offset)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.pointerGP[3], state.masks[1] = true, true
+				state.writeVector(1, 64, selected, false)
+				before := state.clone()
+				if !x86ResultBlockTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, before) {
+					t.Fatal("paired block store rejected exact selected bytes or changed numerical facts")
+				}
+				if x86ResultBlockTransfer(ins, form, &state, nil, 0, arch) {
+					t.Fatal("standalone query acquired native write authority")
+				}
+				indexed := ins
+				indexed.Args = append([]Operand(nil), ins.Args...)
+				indexed.Args[form.destination].Mem.Index = CX
+				indexed.Args[form.destination].Mem.Scale = 4
+				indexed.Args[form.destination].Mem.Off = 3
+				state = before.clone()
+				wordMask := uint8(1)<<uint(x86ResultPointerWord(arch)) - 1
+				state.gp[1] = wordMask
+				indexedBefore := state.clone()
+				if !x86ResultBlockTransferWithNativeMemory(indexed, form, &state, nil, 0, arch, true) ||
+					!reflect.DeepEqual(state, indexedBefore) {
+					t.Fatal("complete numerical index lost the exact native store")
+				}
+				state.gp[1] = wordMask >> 1
+				indexedBefore = state.clone()
+				if x86ResultBlockTransferWithNativeMemory(indexed, form, &state, nil, 0, arch, true) ||
+					!reflect.DeepEqual(state, indexedBefore) {
+					t.Fatal("partial index supplied a native write address")
+				}
+				for _, mutation := range []string{"physical", "address-size", "segment"} {
+					changed := ins
+					switch mutation {
+					case "physical":
+						changed.x86Encoded = true
+					case "address-size":
+						changed.x86AddressBits = 32
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					}
+					state = before.clone()
+					if x86ResultBlockTransferWithNativeMemory(changed, form, &state, nil, 0, arch, true) ||
+						!reflect.DeepEqual(state, before) {
+						t.Fatal("named block store supplied a physical entry or access", mutation)
+					}
+				}
+				for missing := -2; missing < chunk; missing++ {
+					state = before.clone()
+					switch missing {
+					case -2:
+						state.pointerGP[3] = false
+					case -1:
+						if form.mask < 0 {
+							continue
+						}
+						state.masks[1] = false
+					default:
+						state.writeVector(1, 64, selected&^(uint64(1)<<uint(offset+missing)), false)
+					}
+					original := state.clone()
+					if x86ResultBlockTransferWithNativeMemory(ins, form, &state, nil, 0, arch, true) || !reflect.DeepEqual(state, original) {
+						t.Fatal("missing address, mask or selected byte was fabricated", missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86BlockExtractNativeStoreVoidRequiresInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word, triple := "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86BlockNativeStoreRows(arch) {
+			for _, unused := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/unused-bool=%t", arch, row, unused), func(t *testing.T) {
+					declaration, extent := "func Value(p *byte)", word
+					if unused {
+						declaration, extent = "func Value(p *byte,unused bool)", word+1
+					}
+					mask := ""
+					if strings.Contains(row, "K1") {
+						mask = "MOVL $1,AX\nKMOVW AX,K1\n"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),BX\n%s%s\nRET\n", extent, move, mask, row)
+					x86LEAActualTargetGoObject(t, arch, triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if arch == "amd64" {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool supplied unknown block bytes", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BlockExtractNativeStoresFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			move, word := "MOVQ", 8
+			if target.arch == "386" {
+				move, word = "MOVL", 4
+			}
+			var source, declarations strings.Builder
+			masked, plain := 0, 0
+			for index, row := range x86BlockNativeStoreRows(target.arch) {
+				name := fmt.Sprint("Copy", index)
+				fmt.Fprintf(&declarations, "func %s(out, input *byte, mask uint32)\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),BX\n%s input+%d(FP),DX\nMOVL mask+%d(FP),AX\nKMOVW AX,K1\nVMOVUPS (DX),Z1\n%s\n%s\nRET\n",
+					name, 2*word+4, move, move, word, 2*word, row, row)
+				if strings.Contains(row, "K1") {
+					masked++
+				} else {
+					plain++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original native block stores rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "store volatile <") != 2*plain ||
+							strings.Count(text, "; vextract") != 2*masked {
+							t.Fatal("overwritten block stores lost exact native effects", plain, masked)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_block_transfer.go b/x86_result_block_transfer.go
new file mode 100644
index 000000000..0c556b920
--- /dev/null
+++ b/x86_result_block_transfer.go
@@ -0,0 +1,97 @@
+package plan9asm
+
+// A block transfer selects a 128/256-bit chunk. Unknown bytes elsewhere in
+// the source are not dependencies; masked merge bytes retain both possibilities.
+// This numerical effect never creates native memory or initialized pointers.
+func x86ResultBlockTransfer(ins Instr, form x86InsertExtractForm, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) bool {
+	return x86ResultBlockTransferWithNativeMemory(ins, form, state, owned, resultOffset, arch, false)
+}
+
+// This private counterpart consumes the paired exact volatile tuple access or
+// original E6NF masked-store opcode. Continuation supplies numerical bytes for
+// reads only; stores establish no memory facts or raw/caller permission.
+func x86LoweredBlockNativeMemory(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, recognized, err := x86InsertExtractProperties(ins, arch)
+	if !recognized || err != nil || form.undefinedOpcode() || form.spec.scalar || form.memory < 0 {
+		return false, false
+	}
+	memory := ins.Args[form.memory]
+	if memory.Kind != OpMem || memory.Mem.Sym != "" || !x86OrdinaryNativeMemoryOperand(memory, arch) {
+		return false, false
+	}
+	address := x86ResultIncomingPointerReadAddressIdentity(memory, state, arch)
+	if form.memoryWrite {
+		address = x86ResultIncomingPointerAddressIdentity(memory, state, arch)
+	}
+	if !address {
+		return false, true
+	}
+	return x86ResultBlockTransferWithNativeMemory(ins, form, state, owned, resultOffset, arch, true), true
+}
+
+func x86ResultBlockTransferWithNativeMemory(ins Instr, form x86InsertExtractForm, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string, nativeMemory bool) bool {
+	if form.undefinedOpcode() || form.spec.scalar || form.memory >= 0 && (ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride) {
+		return false
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false
+		}
+	}
+	chunk := x86CallerVectorByteMask(int64(form.spec.chunk))
+	source := chunk
+	if form.spec.insert && form.memory >= 0 {
+		// E6NF reads its entire native tuple even for a zero mask, an
+		// unobserved chunk or an independently initialized return value.
+		if !nativeMemory && !x86ResultRead(ins.Args[form.memory], int64(form.spec.chunk), state, owned, arch) {
+			return false
+		}
+	} else {
+		operand := ins.Args[form.source]
+		index, valid := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+		if !valid {
+			return false
+		}
+		source = state.vectorBytes(index)
+	}
+	inputBytes, baseBytes := form.blockInputBytes()
+	known := source & inputBytes
+	if form.spec.insert {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.base].Reg, form.width)
+		known = state.vectorBytes(index)&baseBytes | known<<uint(form.offset)
+	} else {
+		known >>= uint(form.offset)
+	}
+	destination := ins.Args[form.destination]
+	if form.memoryWrite {
+		if known&chunk != chunk {
+			return false
+		}
+		if nativeMemory && x86ResultNamedPredicateInstruction(ins) && ins.x86NumericalRead == nil &&
+			x86OrdinaryNativeMemoryOperand(destination, arch) &&
+			x86ResultIncomingPointerAddressIdentity(destination, state, arch) {
+			return true // A native masked store neither reads nor initializes inactive bytes.
+		}
+		if form.mask >= 0 {
+			// A defined mask need not write any byte. The destination must
+			// already be numerical on every inactive-store path. Its read
+			// authority still cannot expand the separate write envelope.
+			if !x86ResultRead(destination, int64(form.output), state, owned, arch) {
+				return false
+			}
+		}
+		return x86ResultStore(destination, int64(form.output), state, owned, resultOffset, arch)
+	}
+	index, valid := amd64VectorRegisterIndex(destination.Reg, form.output)
+	if !valid {
+		return false
+	}
+	if form.mask >= 0 && !form.zeroing {
+		known &= state.vectorBytes(index)
+	}
+	state.writeVector(index, form.output, known, false)
+	return true
+}
diff --git a/x86_result_block_transfer_test.go b/x86_result_block_transfer_test.go
new file mode 100644
index 000000000..afa6f6733
--- /dev/null
+++ b/x86_result_block_transfer_test.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultBlockTransferAliasedOperands(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		if strings.HasSuffix(strings.Fields(row)[0], "PS") || strings.Contains(row, "(BX)") {
+			continue
+		}
+		// The five equality partitions of source/base/destination. Extraction
+		// has no base; retaining the partitions also checks an unrelated bank.
+		for _, aliases := range [][3]int{{0, 1, 2}, {0, 0, 2}, {0, 1, 0}, {0, 1, 1}, {0, 0, 0}} {
+			for _, immediate := range []int{0, 1, 2, 255} {
+				ins := x86ScalarLaneInstruction(t, strings.Replace(row, "$255", fmt.Sprintf("$%d", immediate), 1))
+				for index := range ins.Args {
+					arg := &ins.Args[index]
+					if arg.Kind == OpReg && amd64VectorByteWidth(arg.Reg) != 0 {
+						bank, valid := amd64VectorRegisterIndex(arg.Reg, amd64VectorByteWidth(arg.Reg))
+						if !valid || bank >= len(aliases) {
+							t.Fatal("unexpected independent format bank", row)
+						}
+						arg.Reg = Reg(fmt.Sprintf("%s%d", string(arg.Reg)[:1], aliases[bank]))
+					}
+				}
+				form, known, err := x86InsertExtractProperties(ins, "amd64")
+				if !known || err != nil {
+					t.Fatal(row, aliases, err)
+				}
+				state := x86ResultState{masks: [8]bool{1: true}, flags: x86ByteFlagsAll}
+				for index, bytes := range []uint64{0xa5a5f0f00f0f5a5a, 0x123456789abcdef0, 0xfedcba9876543210} {
+					state.writeVector(index, 64, bytes, false)
+				}
+				before := state.clone()
+				destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.output)
+				want := x86ResultBlockTransferReference(ins, form, before, immediate)
+				if !x86ResultBlockTransfer(ins, form, &state, nil, 0, "amd64") || state.vectorBytes(destination) != want {
+					t.Fatalf("%s aliases%v imm%d: %016x want %016x", row, aliases, immediate, state.vectorBytes(destination), want)
+				}
+				for index := range state.xmm {
+					if index != destination && state.vectorBytes(index) != before.vectorBytes(index) {
+						t.Fatal("aliased transfer modified an unrelated bank", row, index)
+					}
+				}
+				if state.flags != before.flags {
+					t.Fatal("aliased transfer modified flags", row)
+				}
+			}
+		}
+	}
+}
+
+func x86ResultBlockTransferReference(ins Instr, form x86InsertExtractForm, before x86ResultState, immediate int) uint64 {
+	source, _ := amd64VectorRegisterIndex(ins.Args[form.source].Reg, amd64VectorByteWidth(ins.Args[form.source].Reg))
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.output)
+	base := -1
+	if form.spec.insert {
+		base, _ = amd64VectorRegisterIndex(ins.Args[form.base].Reg, form.width)
+	}
+	selected := immediate % (form.width / form.spec.chunk) * form.spec.chunk
+	var want uint64
+	for output := 0; output < 64; output++ {
+		defined := true
+		if output < form.output {
+			from, at := source, selected+output
+			if form.spec.insert {
+				from, at = base, output
+				if output >= selected && output < selected+form.spec.chunk {
+					from, at = source, output-selected
+				}
+			}
+			defined = before.vectorBytes(from)>>uint(at)&1 != 0
+			if form.mask >= 0 && !form.zeroing {
+				defined = defined && before.vectorBytes(destination)>>uint(output)&1 != 0
+			}
+		}
+		if defined {
+			want |= uint64(1) << uint(output)
+		}
+	}
+	return want
+}
+
+func TestX86ResultBlockTransferWholeCFGSelection(t *testing.T) {
+	for _, otherBranch := range []string{"VZEROUPPER", "NOP"} {
+		for _, selection := range []int{0, 1, 2, 3} {
+			source := fmt.Sprintf(`TEXT ·view(SB),4,$0-12
+MOVL a+0(FP),AX
+MOVL AX,X0
+CMPL AX,$0
+JE other
+VZEROUPPER
+JMP joined
+other:
+%s
+joined:
+VEXTRACTF32X4 $%d,Z0,X1
+PEXTRD $0,X1,AX
+MOVL AX,ret+8(FP)
+RET
+`, otherBranch, selection)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				accepted := otherBranch == "VZEROUPPER" || selection == 0
+				if accepted && err != nil {
+					// Unknown unselected source bytes are not dependencies.
+					t.Fatal("selected initialized chunk lost", api, otherBranch, selection, err)
+				}
+				if !accepted {
+					x86VectorScratchCodegenControl(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+				} else if !accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("one predecessor or shape state defined the selected chunk", api, otherBranch, selection, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultBlockTransferCompleteTypedForms(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		if strings.HasSuffix(strings.Fields(row)[0], "PS") {
+			continue // The four scalar forms have their own byte-lane suite.
+		}
+		t.Run(row, func(t *testing.T) {
+			goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+			// FP here is an explicitly supplied numerical state, not native
+			// backing for a real masked store or permission to skip its emitter.
+			ins := x86ScalarLaneInstruction(t, strings.ReplaceAll(row, "(BX)", "a+0(FP)"))
+			state := x86ResultState{fp: make([]bool, 64), flags: x86ByteFlagsAll}
+			owned := make([]bool, 64)
+			for index := range owned {
+				owned[index], state.fp[index] = true, true
+			}
+			for register := range state.xmm {
+				state.writeVector(register, 64, ^uint64(0), false)
+			}
+			for mask := range state.masks {
+				state.masks[mask] = true
+			}
+			if !x86ScalarFPResultTransfer(ins, &state, owned, 0, "amd64") {
+				t.Fatal("complete typed block format has no composable numerical effect")
+			}
+			if state.flags != x86ByteFlagsAll {
+				t.Fatal("block transfer modified flags")
+			}
+		})
+	}
+}
+
+func TestX86ResultBlockTransferEveryImmediateByteAndMerge(t *testing.T) {
+	for _, row := range x86InsertExtractFormats() {
+		if strings.HasSuffix(strings.Fields(row)[0], "PS") || strings.Contains(row, "(BX)") {
+			continue
+		}
+		for immediate := 0; immediate < 256; immediate++ {
+			ins := x86ScalarLaneInstruction(t, strings.Replace(row, "$255", fmt.Sprintf("$%d", immediate), 1))
+			form, known, err := x86InsertExtractProperties(ins, "amd64")
+			if !known || err != nil {
+				t.Fatal(row, err)
+			}
+			source, _ := amd64VectorRegisterIndex(ins.Args[form.source].Reg, amd64VectorByteWidth(ins.Args[form.source].Reg))
+			destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.output)
+			base := -1
+			if form.spec.insert {
+				base, _ = amd64VectorRegisterIndex(ins.Args[form.base].Reg, form.width)
+			}
+			for input := 0; input < 3; input++ {
+				register := []int{source, base, destination}[input]
+				if register < 0 {
+					continue
+				}
+				for missing := 0; missing < 64; missing++ {
+					state := x86ResultState{masks: [8]bool{1: true}}
+					for index := 0; index < 3; index++ {
+						state.writeVector(index, 64, ^uint64(0), false)
+					}
+					state.writeVector(register, 64, ^(uint64(1) << uint(missing)), false)
+					before := state.clone()
+					want := x86ResultBlockTransferReference(ins, form, before, immediate)
+					if !x86ResultBlockTransfer(ins, form, &state, nil, 0, "amd64") || state.vectorBytes(destination) != want {
+						t.Fatalf("%s imm%d input%d byte%d: %016x want%016x", row, immediate, input, missing, state.vectorBytes(destination), want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultBlockTransferMemoryAndMaskRemainBound(t *testing.T) {
+	for _, chunk := range []int{16, 32} {
+		suffix := map[int]string{16: "32X4", 32: "32X8"}[chunk]
+		for _, insertion := range []bool{false, true} {
+			row := "VINSERTF" + suffix + ".Z $0,a+0(FP),Z1,K1,Z2"
+			if !insertion {
+				row = "VEXTRACTF" + suffix + " $0,Z1,K1,a+0(FP)"
+			}
+			ins := x86ScalarLaneInstruction(t, row)
+			for missing := -1; missing < 64; missing++ {
+				for _, mask := range []bool{false, true} {
+					state := x86ResultState{fp: make([]bool, 64), masks: [8]bool{1: mask}}
+					state.writeVector(1, 64, ^uint64(0), false)
+					owned := make([]bool, 64)
+					for index := range owned {
+						owned[index], state.fp[index] = true, index != missing
+					}
+					accepted := x86ResultTransfer(ins, &state, owned, 0, "amd64")
+					if accepted != (mask && (missing < 0 || missing >= chunk)) {
+						t.Fatal("mask/read/write erased a missing tuple byte", row, mask, missing)
+					}
+				}
+			}
+		}
+	}
+	for _, row := range []string{"VINSERTF32X4 $0,(AX),Z1,Z2", "VEXTRACTF32X8 $0,Z1,(AX)"} {
+		state := x86ResultState{pointerGP: [16]bool{true}}
+		state.writeVector(1, 64, ^uint64(0), false)
+		if x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") {
+			t.Fatal("numerical transfer created a native read/write certificate", row)
+		}
+	}
+}
+
+func TestX86ResultBlockTransferMaskedStoreCannotBorrowReadAuthority(t *testing.T) {
+	for _, chunk := range []int{16, 32} {
+		for _, destination := range []string{"·data(SB)", "input+0(FP)", "result+32(FP)"} {
+			for _, masked := range []bool{false, true} {
+				mask := ""
+				if masked {
+					mask = "K1,"
+				}
+				row := fmt.Sprintf("VEXTRACTF32X%d $0,Z1,%s%s", chunk/4, mask, destination)
+				ins := x86ScalarLaneInstruction(t, row)
+				state := x86ResultState{fp: make([]bool, 64), masks: [8]bool{1: true}}
+				state.writeVector(1, 64, ^uint64(0), false)
+				owned := make([]bool, 64)
+				for index := range owned {
+					owned[index], state.fp[index] = true, true
+				}
+				operand := ins.Args[len(ins.Args)-1]
+				if address, valid := x86StaticSBReadAddress(operand, "amd64"); valid {
+					state.loweredStaticReads = map[x86StaticSBAddress]int64{address: int64(chunk)}
+				}
+				if !x86ResultRead(operand, int64(chunk), &state, owned, "amd64") {
+					t.Fatal("fixture must supply complete numerical read authority", row)
+				}
+				accepted := x86ResultTransfer(ins, &state, owned, 32, "amd64")
+				if accepted != (destination == "result+32(FP)") {
+					t.Fatal("read authority changed the native or FP write envelope", row, accepted)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultBlockTransferFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86InsertExtractFormats() {
+				if strings.HasSuffix(strings.Fields(row)[0], "PS") || strings.Contains(row, "(BX)") {
+					continue
+				}
+				if target.arch == "386" && (strings.HasPrefix(row, "VINSERT") || strings.Contains(row, "K1")) {
+					continue // Go mode32 rejects four/five-operand named source.
+				}
+				ins := x86ScalarLaneInstruction(t, row)
+				destination := ins.Args[len(ins.Args)-1].Reg
+				fmt.Fprintf(&declarations, "func block%d() uint32\n", count)
+				fmt.Fprintf(&source, "TEXT ·block%d(SB),4,$0-4\nVPXORQ Z0,Z0,Z0\nVPXORQ Z1,Z1,Z1\nVPXORQ Z2,Z2,Z2\nMOVL $7,AX\nKMOVW AX,K1\n%s\nPEXTRD $0,X%s,AX\nMOVL AX,ret+0(FP)\nRET\n", count, row, string(destination)[1:])
+				count++
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "block-results.ll", "block-results.o", ir)
+			}
+		})
+	}
+}
diff --git a/x86_result_bmi2_shift.go b/x86_result_bmi2_shift.go
new file mode 100644
index 000000000..43f93ec9e
--- /dev/null
+++ b/x86_result_bmi2_shift.go
@@ -0,0 +1,38 @@
+package plan9asm
+
+import "reflect"
+
+func x86RawBMI2ShiftSource(ins Instr, arch string) bool {
+	form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && form.bmi2 && origin != nil && origin.op == ins.Op &&
+		reflect.DeepEqual(origin.args, ins.Args) && origin.vectorBytes == ins.x86VectorBytes &&
+		ins.x86RawNearReturn == nil && ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride &&
+		ins.x86SegmentPrefix == 0 && !ins.x86RIPLiteral && ins.x86NumericalRead == nil
+}
+
+// Exact original operands permit only this paired numerical transfer. Native
+// reads still need the same incoming address and exact volatile emitter; raw
+// entry, frame, backing and standalone declaration queries gain no permission.
+func x86LoweredBMI2ShiftResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, _ := x86ScalarShiftProperties(ins.Op, ins, arch)
+	if !known || !form.bmi2 || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if !x86RawBMI2ShiftSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	if accepted, known := x86LoweredScalarShiftMemory(local, state, owned, resultOffset, arch); known {
+		return accepted, true
+	}
+	next := state.clone()
+	if x86ResultTransfer(local, &next, owned, resultOffset, arch) {
+		*state = next
+		return true, true
+	}
+	// The existing nontrapping GP domain may retain a dead unknown result.
+	// It never initializes that result or grants a subsequent observable use.
+	return x86LoweredPureGPUnknownTransfer(local, state, arch), true
+}
diff --git a/x86_result_bmi2_shift_runtime_test.go b/x86_result_bmi2_shift_runtime_test.go
new file mode 100644
index 000000000..86070030b
--- /dev/null
+++ b/x86_result_bmi2_shift_runtime_test.go
@@ -0,0 +1,111 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Execute the unchanged 72-function numerical/FLAGS/unaligned-memory fixture
+// on the actual host. This is separate from native original-opcode execution.
+func TestX86BMI2ShiftOriginalFixturePortableExecution(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	source, _, declarations, checks := x86BMI2ShiftRuntimeFixture(t)
+	var goDeclarations strings.Builder
+	for index := 0; index < 72; index++ {
+		fmt.Fprintf(&goDeclarations, "func bmi2shift%d(count uint64,source,out *byte)\n", index)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, goDeclarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("original complete BMI2 source lost its native-read continuation", err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("bmi2-original-%s-ir%d-%s", api, index, level[1:]),
+						triple, text, x86BMI2ShiftRuntimeDriver(declarations, checks), nil)
+				}
+			}
+		})
+	}
+}
+
+func TestX86RORXPortableBoundaryValues(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, bits := range []int{32, 64} {
+		op := "RORXL"
+		if bits == 64 {
+			op = "RORXQ"
+		}
+		for _, immediate := range []int{0, 1, 7, 31, 32, 63, 64, 127, 128, 255} {
+			for _, raw := range []bool{false, true} {
+				name := fmt.Sprintf("Rotate%d", count)
+				line := fmt.Sprintf("%s $%d,AX,AX", op, immediate)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ value+0(FP),AX\n", name)
+				emitX86GoEncodedTestInstruction(t, &source, line, raw)
+				source.WriteString("MOVQ AX,ret+8(FP)\nRET\n")
+				fmt.Fprintf(&declarations, "func %s(value uint64) uint64\n", name)
+				fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t);\n", name)
+				fmt.Fprintf(&rows, "{%s,%d,%d},\n", name, bits, immediate)
+				count++
+			}
+		}
+	}
+	if count != 40 {
+		t.Fatal("complete named/raw width and boundary-count denominator changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	main := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static const struct { uint64_t (*run)(uint64_t); unsigned bits, count; } cases[] = {
+` + rows.String() + `};
+int main(void) {
+    for (unsigned row=0; row<sizeof(cases)/sizeof(cases[0]); row++) {
+        uint64_t mask=cases[row].bits==64 ? UINT64_MAX : UINT32_MAX;
+        unsigned n=cases[row].count & (cases[row].bits-1);
+        for (unsigned bit=0; bit<64; bit++) {
+            for (unsigned inverted=0; inverted<2; inverted++) {
+                uint64_t value=UINT64_C(1)<<bit;
+                if (inverted) value=~value;
+                uint64_t low=value&mask, want=low;
+                if (n) want=((low>>n)|(low<<(cases[row].bits-n)))&mask;
+                uint64_t got=cases[row].run(value);
+                if (got!=want) {
+                    fprintf(stderr,"RORX row=%u bit=%u inverted=%u got=%llx want=%llx\n",
+                            row,bit,inverted,(unsigned long long)got,(unsigned long long)want);
+                    return 1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("rorx-%s-ir%d-%s", api, index, level[1:]), triple, text, main, nil)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_bmi2_shift_test.go b/x86_result_bmi2_shift_test.go
new file mode 100644
index 000000000..772b6e439
--- /dev/null
+++ b/x86_result_bmi2_shift_test.go
@@ -0,0 +1,319 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+var x86BMI2ResultNames = []string{
+	"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ", "RORXL", "RORXQ",
+}
+
+func TestX86BMI2ResultCompleteIndependentEncoderAttributes(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range x86BMI2ResultNames {
+		prefix, table, zcase, opcode := "vexF3", "_ybextrl", "Zvex_v_rm_r", "0xF7"
+		classes, advance := []string{"Yrl", "Yml", "Yrl"}, 2
+		if strings.HasPrefix(name, "SHLX") {
+			prefix = "vex66"
+		} else if strings.HasPrefix(name, "SHRX") {
+			prefix = "vexF2"
+		} else if strings.HasPrefix(name, "RORX") {
+			prefix, table, zcase, opcode = "vexF2", "_yrorxl", "Zvex_i_rm_r", "0xF0"
+			classes, advance = []string{"Yu8", "Yml", "Yrl"}, 0
+		}
+		mapName, wide := "vex0F38", 0
+		if opcode == "0xF0" {
+			mapName = "vex0F3A"
+		}
+		if strings.HasSuffix(name, "Q") {
+			wide = 1
+		}
+		first := goasmrules.X86AVXRule{
+			Opcode: name, Ytab: table, Prefix: "Pavx", Classes: classes,
+			ZCase: zcase, ZOffset: advance,
+			OpBytes: []string{fmt.Sprintf("avxEscape | vex128 | %s | %s | vexW%d", prefix, mapName, wide), opcode},
+		}
+		expected := []goasmrules.X86AVXRule{first}
+		if advance == 0 {
+			second := first
+			second.Classes = []string{"Yi8", "Yml", "Yrl"}
+			second.RowIndex, second.ZOffset = 1, 2
+			expected = append(expected, second)
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == name {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatal("complete independent BMI2 encoding rows changed", name, actual, expected)
+		}
+	}
+}
+
+func x86BMI2ResultInstruction(t *testing.T, arch, op, input string, raw bool) string {
+	t.Helper()
+	count := "CX"
+	if strings.HasPrefix(op, "RORX") {
+		count = "$7"
+	}
+	instruction := op + " " + count + "," + input + ",AX"
+	if !raw {
+		return instruction
+	}
+	code := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+	return x86DwordProductDirectives(code[:len(code)-1])
+}
+
+func TestX86BMI2ResultDeadAndObservableUnknownInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86BMI2ResultNames {
+			for _, raw := range []bool{false, true} {
+				for _, unusedBool := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/bool=%t", target.triple, op, raw, unusedBool), func(t *testing.T) {
+						extent, declaration := 0, "func Value()"
+						if unusedBool {
+							extent, declaration = 1, "func Value(unused bool)"
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nRET\n", extent,
+							x86BMI2ResultInstruction(t, target.arch, op, "BX", raw))
+						word, move := 8, "MOVQ"
+						if target.arch == "386" {
+							word, move = 4, "MOVL"
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+								t.Fatal("dead nontrapping GP value must remain unknown, not prevent an independent return", api, err)
+							}
+							// Observing that same low result must fail. No private
+							// implementation zeros or dead-value rule supply its bytes.
+							observed := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n%s AX,ret+%d(FP)\nRET\n",
+								extent+word, x86BMI2ResultInstruction(t, target.arch, op, "BX", raw), move, extent)
+							if unusedBool {
+								// uintptr results use the compiler's actual word alignment.
+								observed = fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n%s AX,ret+%d(FP)\nRET\n",
+									2*word, x86BMI2ResultInstruction(t, target.arch, op, "BX", raw), move, word)
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, observed, declaration+" uintptr", target.arch, target.triple, api)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown BMI2 result borrowed implementation zeros", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86BMI2ResultVoidRoutesCompleteInputProof(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BMI2ResultNames {
+			source := "TEXT Value(SB),4,$0-0\n" + x86BMI2ResultInstruction(t, arch, op, "BX", false) + "\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, sig := file.Funcs[0], FuncSig{Name: "Value", Ret: Void}
+			if !x86TypedFPResultNeedsProof(fn, sig, arch) {
+				t.Fatal("dead named shift lost its mandatory source proof", arch, op)
+			}
+			ctx := &amd64Ctx{fpScalarSource: fn, sig: sig, goarch: arch}
+			if err := checkX86ScalarFPResultInitialization(fn, sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("strict result observer invented missing input", arch, op, err)
+			}
+			if err := ctx.validateScalarFPSourceViews(); err != nil {
+				t.Fatal("whole lowering proof lost the bounded dead-unknown GP contract", arch, op, err)
+			}
+		}
+	}
+}
+
+func TestX86BMI2ResultInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range x86BMI2ResultNames {
+				for _, memory := range []bool{false, true} {
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("Value%d", count)
+						input, argument := "BX", "uintptr"
+						if memory {
+							input, argument = "(BX)", "*[8]byte"
+						}
+						fmt.Fprintf(&declarations, "func %s(value %s,count uintptr) uintptr\n", name, argument)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s value+0(FP),BX\n%s count+%d(FP),CX\n%s\n%s AX,ret+%d(FP)\nRET\n",
+							name, 3*word, move, move, word, x86BMI2ResultInstruction(t, target.arch, op, input, raw), move, 2*word)
+						count++
+					}
+				}
+			}
+			if count != 32 {
+				t.Fatal("complete register/memory and named/raw denominator changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete BMI2 source lost its numerical/native continuation", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86BMI2ResultRawOriginCannotBeRebound(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BMI2ResultNames {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+
+				x86BMI2ResultInstruction(t, arch, op, "BX", true)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawBMI2ShiftSource(ins, arch) {
+				t.Fatal("original shift/rotate lost its complete source binding", arch, op)
+			}
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"opcode", func(ins *Instr) {
+					ins.Op = "SHLXL"
+					if strings.HasPrefix(op, "SHLX") {
+						ins.Op = "SARXL"
+					} else if strings.HasPrefix(op, "RORX") {
+						ins.Op = "RORXQ"
+						if ins.x86SourceRaw.op == "RORXQ" {
+							ins.Op = "RORXL"
+						}
+					}
+				}},
+				{"operand", func(ins *Instr) { ins.Args[1].Reg = DX }},
+				{"source-operand", func(ins *Instr) { ins.x86SourceRaw.args[1].Reg = DX }},
+				{"vector", func(ins *Instr) { ins.x86VectorBytes = 16 }},
+				{"address", func(ins *Instr) { ins.x86AddressBits = 32 }},
+				{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+				{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+			} {
+				t.Run(arch+"/"+op+"/"+control.name, func(t *testing.T) {
+					changed := ins
+					changed.Args = append([]Operand(nil), ins.Args...)
+					origin := *ins.x86SourceRaw
+					origin.args = append([]Operand(nil), origin.args...)
+					changed.x86SourceRaw = &origin
+					control.change(&changed)
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					for i := range state.gp {
+						state.gp[i] = 0xff
+					}
+					before := state.clone()
+					accepted, known := x86LoweredBMI2ShiftResultStep(changed, &state, nil, 0, arch)
+					if accepted || known != (control.name != "origin") ||
+						x86RawBMI2ShiftSource(changed, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("changed source acquired raw shift/rotate authority", accepted, known)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86BMI2ResultEveryInputByteBeforeAliasedWrite(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BMI2ResultNames {
+			for _, raw := range []bool{false, true} {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+
+					x86BMI2ResultInstruction(t, arch, op, "AX", raw)+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				width := 4
+				if arch == "amd64" && strings.HasSuffix(op, "Q") {
+					width = 8
+				}
+				for missing := -2; missing < width; missing++ {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/missing=%d", arch, op, raw, missing), func(t *testing.T) {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0] = (1 << uint(width)) - 1
+						state.gp[1] = 1 // Only the count's low byte is consumed.
+						if missing >= 0 {
+							state.gp[0] &^= 1 << uint(missing)
+						} else if missing == -1 {
+							state.gp[1] = 0
+							if strings.HasPrefix(op, "RORX") {
+								return // Immediate rotates have no register-count input.
+							}
+						}
+						before := state.clone()
+						accepted := false
+						if raw {
+							var known bool
+							accepted, known = x86LoweredBMI2ShiftResultStep(ins, &state, nil, 0, arch)
+							if !known {
+								t.Fatal("exact raw input not owned by its paired transfer")
+							}
+						} else {
+							accepted = x86ResultTransfer(ins, &state, nil, 0, arch)
+						}
+						if raw && missing != -2 {
+							// The lowering-only nontrapping continuation retains an
+							// unknown output, just like its named counterpart. It must
+							// never invent bytes from the aliased old destination.
+							before.gp[0] = 0
+							if width == 4 {
+								before.gp[0] = 0xf0
+							}
+							if !accepted || !reflect.DeepEqual(state, before) {
+								t.Fatal("paired dead-unknown output acquired numerical bytes or changed unrelated state")
+							}
+							return
+						}
+						if accepted != (missing == -2) || !accepted && !reflect.DeepEqual(state, before) {
+							t.Fatal("aliased destination hid missing data/count or mutated rejected state", accepted)
+						}
+						if accepted && (state.gp[0] != 0xff || state.flags != x86ByteFlagsAll) {
+							t.Fatal("BMI2 failed zero extension or FLAGS preservation", state.gp[0], state.flags)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_bp_atomic_sdk_go127_test.go b/x86_result_bp_atomic_sdk_go127_test.go
new file mode 100644
index 000000000..a40e20e6a
--- /dev/null
+++ b/x86_result_bp_atomic_sdk_go127_test.go
@@ -0,0 +1,84 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86ResultMode32BPActualAtomicWholeSourceRemainsContext(t *testing.T) {
+	proof, request := sdkASMDataRequest(t, "386", "internal/runtime/atomic")
+	source, err := captureGoX86SDKASMDataSourceRole(proof, request, sdkASMDataOriginalSourceRole)
+	if err != nil {
+		t.Fatal("actual complete original atomic source observation", err)
+	}
+	defer source.Close()
+	sdkASMDataDiagnosticRetainNamed(t, "-bp-complete-original", source)
+	if len(source.observation.CPP) != 1 || len(source.observation.Objects.Sources) != 1 ||
+		len(source.observation.Objects.Sources[0].Original.Texts) != 42 ||
+		strings.Count(string(source.observation.ObjectInputs.Sources[0].Original), "\nTEXT ") != 42 {
+		t.Fatal("the actual discovering file was cropped")
+	}
+	pkg, err := source.typedPackage("go1.27")
+	if err != nil || len(pkg.SourceSelection.Assembly) != 1 {
+		t.Fatal("actual selected typed source inventory differs", err)
+	}
+	var file *File
+	for _, selected := range pkg.SourceSelection.Assembly {
+		file = selected
+	}
+	if file == nil || len(file.Funcs) != 42 {
+		t.Fatal("complete selected source TEXT inventory differs")
+	}
+	resolve := testResolveSym(pkg.Path)
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := source.Verify(proof); err != nil {
+		t.Fatal(err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			published := false
+			var failure error
+			options := Options{Goarch: "386", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+			switch api {
+			case "text":
+				var ir string
+				ir, failure = Translate(file, options)
+				published = ir != ""
+			case "module":
+				var module llvm.Module
+				module, failure = TranslateModuleInContext(ctx, file, options)
+				published = !module.IsNil()
+				if published {
+					defer module.Dispose()
+				}
+			case "Go":
+				module, err := translateGoModuleInContext(ctx, pkg, []byte(source.observation.CPP[0].Output), GoModuleOptions{
+					GOARCH: "386", GOOS: "linux", TargetTriple: "i386-unknown-linux-gnu", ResolveSym: resolve,
+				})
+				failure = err
+				published = module != nil
+				if module != nil && !module.Module.IsNil() {
+					defer module.Module.Dispose()
+				}
+			}
+			if published || !errors.Is(failure, ErrProbeNeedsContext) ||
+				!strings.Contains(failure.Error(), "tail callee needs its independent CALL contract") {
+				t.Fatal("ordinary BP acquired terminal/native source authority", published, failure)
+			}
+			t.Log("complete original42TEXT source still Context, not a file/object/runtime pass:", failure)
+		})
+	}
+	if err := source.Verify(proof); err != nil {
+		t.Fatal("complete source selection/compiler inputs changed during the API replay", err)
+	}
+}
diff --git a/x86_result_bp_mode_objects_test.go b/x86_result_bp_mode_objects_test.go
new file mode 100644
index 000000000..7a6927062
--- /dev/null
+++ b/x86_result_bp_mode_objects_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultMode32BPOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	var source, declarations strings.Builder
+	for index, operation := range []string{
+		"NOP", "ADDL $9,BP", "XORL BP,BP", "MOVW $7,BP",
+		"MOVL $9,DI\nXCHGB BP,DI", "MOVL $9,DI\nXCHGW BP,DI", "MOVL $9,DI\nXCHGL BP,DI",
+		"LEAW 3(BP)(BP*2),BP", "LEAL 3(BP)(BP*2),BP", "CMPL BP,$0\nSETEQ BP\nMOVBLZX BP,BP",
+	} {
+		name := fmt.Sprintf("BPScalar%d", index)
+		fmt.Fprintf(&declarations, "func %s(n uint32) uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVL n+0(FP),BP\n%s\nMOVL BP,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+4(FP)\nRET\n", name, operation)
+	}
+	for _, width := range []string{"B", "W", "L"} {
+		name := "BPPointerTest" + width
+		fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVL p+0(FP),BP\nTEST%s $7,BP\nSETEQ AX\nMOVBLZX AX,AX\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+4(FP)\nRET\n", name, width)
+	}
+	for index, op := range []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"} {
+		name := fmt.Sprintf("BPCAS%d", index)
+		fmt.Fprintf(&declarations, "func %s(p *uint64,a,b,c,d uint32) uint32\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVL p+0(FP),BP\nMOVL a+4(FP),AX\nMOVL b+8(FP),DX\nMOVL c+12(FP),BX\nMOVL d+16(FP),CX\nLOCK\n%s ", name, op)
+		if op != "CMPXCHG8B" {
+			source.WriteString("CX,")
+		}
+		source.WriteString("(BP)\nSETEQ AX\nMOVBLZX AX,AX\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+20(FP)\nRET\n")
+	}
+	declarations.WriteString("func BPLogicalResult(n uint32) uint32\n")
+	source.WriteString("TEXT ·BPLogicalResult(SB),4,$0-8\nLEAL ret+4(FP),BP\nMOVL n+0(FP),SI\nMOVL SI,(BP)\nRET\n")
+	if strings.Count(source.String(), "TEXT ") != 18 {
+		t.Fatal("complete mode32 BP fixture inventory changed")
+	}
+	// Both affected targets retain original stock-Go objects and all three
+	// translation APIs. IR-prepass and backend optimization are separate axes;
+	// neither compilation nor this logical transport fixture executes native Go.
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "386", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original mode32 BP class did not translate", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, backend := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR-O2-%t/backend%s", optimized, backend), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, triple, input, backend)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_bp_mode_test.go b/x86_result_bp_mode_test.go
new file mode 100644
index 000000000..99fc753ff
--- /dev/null
+++ b/x86_result_bp_mode_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultMode32BPDefinedBytesAndCompleteCFG(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		pass       bool
+	}{
+		{"full-input", "MOVL n+0(FP),BP", true},
+		{"constant", "MOVL $7,BP", true},
+		{"arithmetic", "MOVL n+0(FP),BP\nADDL $9,BP", true},
+		{"self-XOR", "XORL BP,BP", true},
+		{"byte-exchange", "MOVL n+0(FP),BP\nMOVL $9,DI\nXCHGB BP,DI", true},
+		{"word-exchange", "MOVL n+0(FP),BP\nMOVL $9,DI\nXCHGW BP,DI", true},
+		{"dword-exchange", "MOVL n+0(FP),BP\nMOVL $9,DI\nXCHGL BP,DI", true},
+		{"byte-SETcc", "CMPL n+0(FP),$0\nSETEQ BP\nMOVBLZX BP,BP", true},
+		{"numerical-LEA", "MOVL n+0(FP),BP\nLEAL 3(BP)(BP*2),BP", true},
+		{"word-preserves-defined-high", "MOVL n+0(FP),BP\nMOVW $7,BP", true},
+		{"both-branches", "CMPL n+0(FP),$0\nJE other\nMOVL $7,BP\nJMP joined\nother:\nMOVL $9,BP\njoined:", true},
+		{"unknown-entry", "NOP", false},
+		{"partial-word", "MOVW $7,BP", false},
+		{"partial-byte", "MOVB $7,BP", false},
+		{"unknown-overwrite", "MOVL n+0(FP),BP\nMOVL CX,BP", false},
+		{"one-branch", "CMPL n+0(FP),$0\nJE joined\nMOVL $7,BP\njoined:", false},
+		{"unknown-LEA-input", "LEAL 3(BP),BP", false},
+		{"returning-CALL", "MOVL n+0(FP),BP\nCALL ·other(SB)", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			body := row.body + "\nMOVL BP,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+4(FP)\nRET"
+			_, file, sig, _ := x86ResultInitializationFixture(t, "386", "func Value(n uint32) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				err := check(file.Funcs[0], sig, "386")
+				if row.pass && err != nil || !row.pass && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("mode32 BP defined-byte proof differs", row.pass, err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					source := "TEXT ·view(SB),4,$0-8\n" + body + "\n"
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(n uint32) uint32\nfunc other()\n", "386", "i386-unknown-linux-gnu", api)
+					if row.pass && (err != nil || ir == "") || !row.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("mode32 BP source/result publication differs", row.pass, err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ResultMode32BPOpaquePointerPredicateAndCAS(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		pass       bool
+	}{
+		{"pointer-TEST", "MOVL p+0(FP),BP\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", true},
+		{"copied-pointer-TEST", "MOVL p+0(FP),SI\nMOVL SI,BP\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", true},
+		{"unknown-BP", "TESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"partial-pointer", "MOVW p+0(FP),BP\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"pointer-not-numeric", "MOVL p+0(FP),BP\nMOVL BP,AX", false},
+		{"partial-pointer-overwrite", "MOVL p+0(FP),BP\nMOVW $7,BP\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"unknown-FLAGS", "MOVL p+0(FP),BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"both-pointer-branches", "MOVL p+0(FP),SI\nTESTL $1,SI\nJE other\nMOVL SI,BP\nJMP joined\nother:\nMOVL p+0(FP),BP\njoined:\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", true},
+		{"missing-pointer-branch", "MOVL p+0(FP),SI\nTESTL $1,SI\nJE joined\nMOVL SI,BP\njoined:\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"numeric-pointer-join", "MOVL p+0(FP),SI\nTESTL $1,SI\nJE other\nMOVL SI,BP\nJMP joined\nother:\nMOVL $7,BP\njoined:\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+		{"returning-pointer-CALL", "MOVL p+0(FP),BP\nCALL ·other(SB)\nTESTL $7,BP\nSETEQ AX\nMOVBLZX AX,AX", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			body := row.body + "\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+4(FP)\nRET"
+			_, file, sig, _ := x86ResultInitializationFixture(t, "386", "func Value(p *byte) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				err := check(file.Funcs[0], sig, "386")
+				if row.pass && err != nil || !row.pass && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("mode32 BP pointer and NUM domains conflated", row.pass, err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-8\n"+body+"\n", "func view(p *byte) uint32\nfunc other()\n", "386", "i386-unknown-linux-gnu", api)
+					if row.pass && (err != nil || ir == "") || !row.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("mode32 BP predicate publication differs", row.pass, err)
+					}
+				})
+			}
+		})
+	}
+	for _, name := range []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"} {
+		for _, row := range []struct{ name, pointer string }{
+			{"incoming", "MOVL p+0(FP),BP"}, {"unknown", "NOP"}, {"numeric", "MOVL $7,BP"}, {"partial", "MOVW p+0(FP),BP"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(name+"/"+row.name+"/"+api, func(t *testing.T) {
+					body := row.pointer + "\nMOVL a+4(FP),AX\nMOVL b+8(FP),DX\nMOVL c+12(FP),BX\nMOVL d+16(FP),CX\nLOCK\n"
+					if name == "CMPXCHG8B" {
+						body += name + " (BP)"
+					} else {
+						body += name + " CX,(BP)"
+					}
+					body += "\nSETEQ AX\nMOVBLZX AX,AX\nMOVL AX,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+20(FP)\nRET\n"
+					_, file, sig, _ := x86ResultInitializationFixture(t, "386", "func Value(p *uint64,a,b,c,d uint32) uint32", body)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("ordinary BP classification gave a standalone query native CAS authority", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-24\n"+body,
+						"func view(p *uint64,a,b,c,d uint32) uint32\n", "386", "i386-unknown-linux-gnu", api)
+					pass := row.name == "incoming"
+					if pass && (err != nil || ir == "") || !pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("mode32 BP CAS acquired address/NUM authority", pass, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultModeAwareBPAndSPRemainDistinct(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, reg := range []string{"SP", "BP"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+reg+"/"+api, func(t *testing.T) {
+					word, move, triple := 4, "MOVL", "i386-unknown-linux-gnu"
+					if arch == "amd64" {
+						word, move, triple = 8, "MOVQ", "x86_64-unknown-linux-gnu"
+					}
+					body := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s n+0(FP),%s\nMOVL %s,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET\n", word+4, move, reg, reg, word)
+					ir, err := x86ScalarFPBitViewAPI(t, body, fmt.Sprintf("func view(n uint%d) uint32\n", word*8), arch, triple, api)
+					pass := arch == "386" && reg == "BP"
+					if pass && (err != nil || ir == "") || !pass && (err == nil || ir != "") {
+						t.Fatal("ordinary mode32 BP changed a stack/frame contract", pass, err)
+					}
+					if pass && !strings.Contains(ir, "%reg_BP") {
+						t.Fatal("mode32 BP source lost its independent value slot")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_bswap_native_driver_test.go b/x86_result_bswap_native_driver_test.go
new file mode 100644
index 000000000..10192483d
--- /dev/null
+++ b/x86_result_bswap_native_driver_test.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86ByteSwapExecuteOriginalAndLLVM(t *testing.T, arch string, execution x86FloatCompareExecution) {
+	t.Helper()
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	if execution.triple != triple || len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("native BSWAP owner requires exact direct Linux execution")
+	}
+	source, declarations, rows := x86ByteSwapNativeRows(t, arch)
+	var adapters strings.Builder
+	for index, row := range rows {
+		kernel := x86ByteSwapNativeKernel(row)
+		code := x86OrderingHintGoBytes(t, arch, kernel)
+		var raw strings.Builder
+		raw.WriteString("TEXT kernel(SB),4,$0-0\n")
+		for _, value := range code {
+			fmt.Fprintf(&raw, "BYTE $%d\n", value)
+		}
+		if actual := x86OrderingHintGoBytes(t, arch, raw.String()); !bytes.Equal(actual, code) {
+			t.Fatal("actual named/raw original-Go opcode kernel differs")
+		}
+		adapter, err := x86ByteSwapNativeAdapter(arch, row, index, code)
+		if err != nil {
+			t.Fatal(err)
+		}
+		adapters.WriteString(adapter)
+	}
+	driver := x86ByteSwapNativeDriver(t, arch, rows, adapters.String())
+	want := fmt.Sprintf("BSWAP original-Go opcode bytes and complete LLVM fixture: %d checks, six FLAGS/DF and stack canaries\n", len(rows)*len(x86ByteSwapNativeValues)*128)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete BSWAP numerical fixture failed", err)
+			}
+			for _, optimizeIR := range []bool{false, true} {
+				input := ir
+				if optimizeIR {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimizeIR, level), func(t *testing.T) {
+						executable := execution.compileLLVM(t, "bswap", input, driver, level)
+						var output []byte
+						if arch == "386" {
+							sealed, err := x87IA32StaticExecutable(executable)
+							if err != nil {
+								t.Fatal(err)
+							}
+							output = x87IA32RunDirect(t, sealed, nil, os.Environ())
+						} else {
+							output = execution.run(t, executable)
+						}
+						if string(output) != want {
+							t.Fatalf("native original opcode/LLVM/reference result/status/canary disagreement: %s", output)
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+// Compile the actual generated C/assembly driver for both target ISAs without
+// executing either. Minimal freestanding declarations replace only its two
+// libc includes; this is syntax/ABI-object evidence, not a native SDK or run.
+func TestX86ByteSwapNativeAdapterBothISAsCompileWithLLVM22(t *testing.T) {
+	clang := findLLVM22Tool("clang")
+	if clang == "" {
+		t.Fatal("BSWAP native-driver objects require LLVM22 clang")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			_, _, rows := x86ByteSwapNativeRows(t, arch)
+			var adapters strings.Builder
+			for index, row := range rows {
+				code := x86OrderingHintGoBytes(t, arch, x86ByteSwapNativeKernel(row))
+				adapter, err := x86ByteSwapNativeAdapter(arch, row, index, code)
+				if err != nil {
+					t.Fatal(err)
+				}
+				adapters.WriteString(adapter)
+			}
+			driver := x86ByteSwapNativeDriver(t, arch, rows, adapters.String())
+			const includes = "#include <stdint.h>\n#include <stdio.h>\n"
+			if !strings.HasPrefix(driver, includes) || strings.Count(driver, includes) != 1 {
+				t.Fatal("complete native-driver include projection changed")
+			}
+			driver = `typedef __UINT8_TYPE__ uint8_t;
+typedef __UINT32_TYPE__ uint32_t;
+typedef __UINT64_TYPE__ uint64_t;
+typedef __UINTPTR_TYPE__ uintptr_t;
+#define UINT64_C(x) x##ULL
+#define NULL ((void*)0)
+struct FILE;
+extern struct FILE *stderr;
+extern int printf(const char*,...);
+extern int fprintf(struct FILE*,const char*,...);
+` + strings.TrimPrefix(driver, includes)
+			dir := t.TempDir()
+			input, output := filepath.Join(dir, "driver.c"), filepath.Join(dir, "driver.o")
+			if err := os.WriteFile(input, []byte(driver), 0600); err != nil {
+				t.Fatal(err)
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			if arch == "386" {
+				triple = "i386-unknown-linux-gnu"
+			}
+			x86FloatCompareCaptureCommand(t, exec.Command(clang, "--no-default-config", "-target", triple,
+				"-ffreestanding", "-nostdinc", "-fno-pie", "-O2", "-c", input, "-o", output))
+			if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+				t.Fatal("complete native-driver target object missing", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_bswap_native_fixture_test.go b/x86_result_bswap_native_fixture_test.go
new file mode 100644
index 000000000..c4d322646
--- /dev/null
+++ b/x86_result_bswap_native_fixture_test.go
@@ -0,0 +1,319 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ByteSwapNativeRow struct {
+	name, op, register string
+	role               int // Complete translated value, sparse byte, or saved FLAGS.
+}
+
+var x86ByteSwapNativeValues = []uint64{
+	0, 1, 128, 255, 256, 65536, 0x1000000, 0x100000000,
+	0x10000000000, 0x1000000000000, 0x100000000000000,
+	0x8000000000000000, 0x1122334455667788, 0xffffffff,
+	0xffffffff00000000, ^uint64(0),
+}
+
+func x86ByteSwapNativeRows(t *testing.T, arch string) (string, string, []x86ByteSwapNativeRow) {
+	t.Helper()
+	source, declarations := x86ByteSwapObjectFixture(t, arch)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var rows []x86ByteSwapNativeRow
+	for _, fn := range file.Funcs {
+		row := x86ByteSwapNativeRow{name: strings.TrimPrefix(fn.Sym, "·")}
+		count := 0
+		for _, ins := range fn.Instrs {
+			if _, known := x86ByteSwapSpecs[ins.Op]; !known {
+				continue
+			}
+			if _, _, err := x86ByteSwapProperties(ins.Op, ins, arch); err != nil {
+				t.Fatal(err)
+			}
+			if count != 0 && (row.op != string(ins.Op) || row.register != string(ins.Args[0].Reg)) {
+				t.Fatal("complete native fixture changed its byte-permutation sequence")
+			}
+			row.op, row.register = string(ins.Op), string(ins.Args[0].Reg)
+			count++
+		}
+		if strings.HasPrefix(row.name, "Sparse") {
+			row.role = 1
+		} else if strings.HasPrefix(row.name, "Status") {
+			row.role = 2
+		}
+		if count != 1+row.role%2 {
+			t.Fatal("complete original/translated native fixture lost an instruction", row)
+		}
+		rows = append(rows, row)
+	}
+	return source, declarations, rows
+}
+
+func x86ByteSwapNativeKernel(row x86ByteSwapNativeRow) string {
+	count := 1 + row.role%2
+	return "TEXT kernel(SB),4,$0-0\n" + strings.Repeat(row.op+" "+row.register+"\n", count) + "RET\n"
+}
+
+// This test-only encoder expectation checks the complete standalone Go kernel,
+// including RET. It is not a source admission or an executable-entry capability.
+func x86ByteSwapNativeKernelBytes(row x86ByteSwapNativeRow) []byte {
+	registers := strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+	index := -1
+	for i, register := range registers {
+		if register == row.register {
+			index = i
+		}
+	}
+	if index < 0 || row.op != "BSWAPL" && row.op != "BSWAPQ" {
+		return nil
+	}
+	var instruction []byte
+	if row.op == "BSWAPQ" {
+		instruction = append(instruction, 0x48|byte(index/8))
+	} else if index >= 8 {
+		instruction = append(instruction, 0x41)
+	}
+	instruction = append(instruction, 0x0f, 0xc8+byte(index%8))
+	code := bytes.Repeat(instruction, 1+row.role%2)
+	return append(code, 0xc3)
+}
+
+// The explicit Linux C adapter supplies only a numerical register and safe
+// status seed to the complete original Go opcode kernel. It is NOT native Go
+// ABI0 execution. All callee-saved registers and the real stack are restored;
+// DF is observed before being cleared for the C ABI. No translator role follows.
+func x86ByteSwapNativeAdapter(arch string, row x86ByteSwapNativeRow, index int, code []byte) (string, error) {
+	registers := map[string]string{"AX": "ax", "CX": "cx", "DX": "dx", "BX": "bx", "BP": "bp", "SI": "si", "DI": "di"}
+	for i := 8; i < 16; i++ {
+		registers[fmt.Sprintf("R%d", i)] = fmt.Sprintf("r%d", i)
+	}
+	destination, valid := registers[row.register]
+	if !valid || row.register == "BP" && arch != "386" || row.role < 0 || row.role > 2 ||
+		arch != "amd64" && arch != "386" || arch == "386" && (row.op == "BSWAPQ" || strings.HasPrefix(row.register, "R")) ||
+		!bytes.Equal(code, x86ByteSwapNativeKernelBytes(row)) {
+		return "", fmt.Errorf("unbound original BSWAP kernel/bank/mode")
+	}
+	word, suffix, sp, accumulator, pointer, temporary := 8, "q", "%rsp", "%rax", "%rdx", "%r11"
+	saved := []string{"%rbx", "%rbp", "%r12", "%r13", "%r14", "%r15"}
+	if arch == "386" {
+		word, suffix, sp, accumulator, pointer, temporary = 4, "l", "%esp", "%eax", "%edx", "%ecx"
+		saved = []string{"%ebx", "%ebp", "%esi", "%edi"}
+		destination = "%e" + destination
+	} else if strings.HasPrefix(destination, "r") {
+		destination = "%" + destination
+	} else {
+		destination = "%r" + destination
+	}
+	var assembly strings.Builder
+	fmt.Fprintf(&assembly, ".text\nBSwapOriginalBody%d:\n.byte ", index)
+	for i, value := range code {
+		if i != 0 {
+			assembly.WriteByte(',')
+		}
+		fmt.Fprintf(&assembly, "0x%02x", value)
+	}
+	fmt.Fprintf(&assembly, "\n.globl BSwapOriginal%d\nBSwapOriginal%d:\n", index, index)
+	for _, register := range saved {
+		fmt.Fprintf(&assembly, "push%s %s\n", suffix, register)
+	}
+	fmt.Fprintf(&assembly, "sub%s $%d,%s\n", suffix, 7*word, sp)
+	if arch == "amd64" {
+		fmt.Fprintf(&assembly, "movq %%rdi,%d(%s)\nmovq %%rsi,%d(%s)\nmovq %%rdx,%d(%s)\n", word, sp, 2*word, sp, 3*word, sp)
+	} else {
+		for argument := 0; argument < 3; argument++ {
+			fmt.Fprintf(&assembly, "movl %d(%s),%%ecx\nmovl %%ecx,%d(%s)\n", (12+argument)*word, sp, (1+argument)*word, sp)
+		}
+	}
+	for i, slot := range []int{0, 4, 5, 6} {
+		move := "movl"
+		constant := []uint64{0x5a5a5a5a, 0x6b6b6b6b, 0x13579bdf, 0x2468ace}[i]
+		if arch == "amd64" {
+			move, constant = "movabsq", constant|constant<<32
+		}
+		fmt.Fprintf(&assembly, "%s $0x%x,%s\nmov%s %s,%d(%s)\n", move, constant, temporary, suffix, temporary, slot*word, sp)
+	}
+	fmt.Fprintf(&assembly, "mov%s %d(%s),%s\npush%s %d(%s)\npopf%s\ncall BSwapOriginalBody%d\n", suffix, word, sp, destination, suffix, 2*word, sp, suffix, index)
+	// Capture the destination before using any scratch register. PUSH/MOV/POP
+	// do not disturb status; the complete original kernel also includes RET.
+	fmt.Fprintf(&assembly, "push%s %s\npushf%s\npop%s %s\nmov%s %d(%s),%s\nmov%s %s,0(%s)\npop%s %s\ncld\n", suffix, destination, suffix, suffix, accumulator, suffix, 4*word, sp, pointer, suffix, accumulator, pointer, suffix, accumulator)
+	for i, slot := range []int{0, 4, 5, 6} {
+		fmt.Fprintf(&assembly, "mov%s %d(%s),%s\nmov%s %s,%d(%s)\n", suffix, slot*word, sp, temporary, suffix, temporary, (i+1)*word, pointer)
+	}
+	fmt.Fprintf(&assembly, "add%s $%d,%s\n", suffix, 7*word, sp)
+	for i := len(saved) - 1; i >= 0; i-- {
+		fmt.Fprintf(&assembly, "pop%s %s\n", suffix, saved[i])
+	}
+	assembly.WriteString("ret\n")
+	return fmt.Sprintf("__asm__(%q);\nextern word BSwapOriginal%d(word,word,word*);\n", assembly.String(), index), nil
+}
+
+func x86ByteSwapNativeDriver(t *testing.T, arch string, rows []x86ByteSwapNativeRow, adapters string) string {
+	t.Helper()
+	typ, stack := "uint64_t", "movq %%rsp,%0"
+	if arch == "386" {
+		typ, stack = "uint32_t", "movl %%esp,%0"
+	}
+	var declarations, registrations, values strings.Builder
+	for index, row := range rows {
+		functions := [3]string{"NULL", "NULL", "NULL"}
+		functions[row.role] = row.name
+		declaration := "extern word %s(word);\n"
+		if row.role == 1 {
+			declaration = "extern uint8_t %s(uint8_t);\n"
+		} else if row.role == 2 {
+			declaration = "extern word %s(word,word);\n"
+		}
+		fmt.Fprintf(&declarations, declaration, row.name)
+		width := 4
+		if row.op == "BSWAPQ" {
+			width = 8
+		}
+		fmt.Fprintf(&registrations, "{BSwapOriginal%d,%s,%s,%s,%d,%d},\n", index, functions[0], functions[1], functions[2], width, row.role)
+	}
+	for _, value := range x86ByteSwapNativeValues {
+		fmt.Fprintf(&values, "UINT64_C(0x%x),", value)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+typedef ` + typ + ` word;
+` + adapters + declarations.String() + `
+static const struct {
+    word (*original)(word,word,word*);
+    word (*value)(word);
+    uint8_t (*sparse)(uint8_t);
+    word (*status)(word,word);
+    unsigned bytes,role;
+} rows[]={
+` + registrations.String() + `};
+static __attribute__((always_inline)) inline uintptr_t stack_pointer(void) {
+    uintptr_t value;
+    __asm__ volatile("` + stack + `" : "=r"(value) : : "memory");
+    return value;
+}
+static word reverse_bytes(word value,unsigned bytes) {
+    volatile uint8_t input[8],output[8];
+    for(unsigned byte=0;byte<bytes;byte++)input[byte]=(uint8_t)(value>>(8*byte));
+    for(unsigned byte=0;byte<bytes;byte++)output[byte]=input[bytes-1-byte];
+    word result=0;
+    for(unsigned byte=0;byte<bytes;byte++)result|=(word)output[byte]<<(8*byte);
+    return result;
+}
+int main(void) {
+    const uint64_t values[]={` + values.String() + `};
+    unsigned checks=0;
+    for(unsigned value=0;value<sizeof(values)/sizeof(values[0]);value++)
+        for(unsigned status=0;status<128;status++) {
+            word seed=2;
+            const unsigned positions[]={0,2,4,6,7,11,10};
+            for(unsigned bit=0;bit<7;bit++)seed|=(word)(status>>bit&1)<<positions[bit];
+            for(unsigned row=0;row<sizeof(rows)/sizeof(rows[0]);row++) {
+                const word input=(word)values[value],left=(word)0x31415926,right=(word)0x27182818;
+                word observed[]={left,0,0,0,0,0,right};
+                const uintptr_t before=stack_pointer();
+                word raw=rows[row].original(input,seed,observed+1);
+                if(stack_pointer()!=before||observed[0]!=left||observed[6]!=right)return 1;
+                const word mask=(word)0x8d5|1024;
+                if((observed[1]&mask)!=(seed&mask))return 2;
+                const uint32_t canaries[]={0x5a5a5a5a,0x6b6b6b6b,0x13579bdf,0x2468ace};
+                for(unsigned i=0;i<4;i++) {
+                    uint64_t want=canaries[i];
+                    if(sizeof(word)==8)want|=want<<32;
+                    if(observed[i+2]!=(word)want)return 3;
+                }
+                word expected=reverse_bytes(input,rows[row].bytes);
+                if(rows[row].role==1)expected=reverse_bytes(expected,rows[row].bytes);
+                if(raw!=expected)return 4;
+                word actual=rows[row].role==0?rows[row].value(input):
+                    rows[row].role==1?rows[row].sparse((uint8_t)input):rows[row].status(input,seed);
+                word want=rows[row].role==1?(uint8_t)input:expected;
+                if(rows[row].role==2){actual&=mask;want=seed&mask;}
+                if(stack_pointer()!=before||actual!=want) {
+                    fprintf(stderr,"row=%u value=%llx status=%x raw=%llx LLVM=%llx want=%llx\n",
+                        row,(unsigned long long)input,status,(unsigned long long)raw,
+                        (unsigned long long)actual,(unsigned long long)want);
+                    return 5;
+                }
+                checks++;
+            }
+        }
+    printf("BSWAP original-Go opcode bytes and complete LLVM fixture: %u checks, six FLAGS/DF and stack canaries\n",checks);
+    return 0;
+}
+`
+}
+
+func TestX86ByteSwapNativeFixtureKeepsCompleteSourceAndBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source, declarations, rows := x86ByteSwapNativeRows(t, arch)
+		want := 32
+		if arch == "386" {
+			want = 9
+		}
+		if len(rows) != want || len(x86ByteSwapNativeValues) != 16 {
+			t.Fatal("complete native fixture denominator changed")
+		}
+		var adapters strings.Builder
+		for index, row := range rows {
+			code := x86ByteSwapNativeKernelBytes(row)
+			adapter, err := x86ByteSwapNativeAdapter(arch, row, index, code)
+			if err != nil || !strings.Contains(adapter, "\\ncld\\n") || strings.Contains(adapter, "blockaddress") {
+				t.Fatal("test-only adapter lost its restore boundary", err)
+			}
+			adapters.WriteString(adapter)
+			if got, err := x86ByteSwapNativeAdapter(arch, row, index, code[:len(code)-1]); err == nil || got != "" {
+				t.Fatal("incomplete original Go kernel accepted")
+			}
+		}
+		for _, register := range []string{"SP", "R16"} {
+			row := x86ByteSwapNativeRow{op: "BSWAPL", register: register}
+			if got, err := x86ByteSwapNativeAdapter(arch, row, 0, x86ByteSwapNativeKernelBytes(row)); err == nil || got != "" {
+				t.Fatal("test adapter borrowed a physical stack/unknown bank", register)
+			}
+		}
+		driver := x86ByteSwapNativeDriver(t, arch, rows, adapters.String())
+		if strings.Count(driver, "extern word BSwapOriginal") != want ||
+			!strings.Contains(driver, "status<128") || !strings.Contains(driver, "stack_pointer()!=before") {
+			t.Fatal("native six-status/DF/original/canary axes incomplete")
+		}
+		// All three ordinary consumers still receive the complete original
+		// fixture, not the standalone opcode adapter or a cropped function.
+		x86ResultGPSIMDAdmissionAPIs(t, arch, source, declarations, true)
+	}
+}
+
+func TestX86ByteSwapNativeOpcodeObserverDoesNotAuthorizeRawSource(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		source, declarations := x86ByteSwapObjectFixture(t, target.arch)
+		var raw strings.Builder
+		for _, line := range strings.Split(source, "\n") {
+			fields := strings.Fields(line)
+			if len(fields) == 2 && (fields[0] == "BSWAPL" || fields[0] == "BSWAPQ") {
+				code := x86ByteSwapNativeKernelBytes(x86ByteSwapNativeRow{op: fields[0], register: fields[1]})
+				for _, value := range code[:len(code)-1] {
+					fmt.Fprintf(&raw, "BYTE $%d\n", value)
+				}
+			} else {
+				fmt.Fprintln(&raw, line)
+			}
+		}
+		if strings.Count(raw.String(), "TEXT ·") != strings.Count(source, "TEXT ·") {
+			t.Fatal("raw observer negative cropped the complete fixture")
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, raw.String(), declarations, target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("test-only original opcode observer granted physical raw result authority", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_bswap_native_linux_amd64_test.go b/x86_result_bswap_native_linux_amd64_test.go
new file mode 100644
index 000000000..de2f27055
--- /dev/null
+++ b/x86_result_bswap_native_linux_amd64_test.go
@@ -0,0 +1,34 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+// Required Linux native owner: both ISA children execute. Other hosts do not
+// certify this owner, and missing tools on its actual host are fatal.
+func TestCrossLinuxRuntimeMatrixX86ByteSwapOriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native BSWAP owner requires LLVM22 llc/clang")
+	}
+	compiler386, err := exec.LookPath("i686-linux-gnu-gcc")
+	if err != nil {
+		t.Fatal("native BSWAP owner requires i686-linux-gnu-gcc", err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+				compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+			if arch == "386" {
+				execution.triple = "i386-unknown-linux-gnu"
+				execution.compiler = []string{compiler386, "-static", "-no-pie", "-maccumulate-outgoing-args"}
+			}
+			x86ByteSwapExecuteOriginalAndLLVM(t, arch, execution)
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_result_bswap_objects_test.go b/x86_result_bswap_objects_test.go
new file mode 100644
index 000000000..16282c4d8
--- /dev/null
+++ b/x86_result_bswap_objects_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteSwapOriginalGoCompleteGrammarAndBytes(t *testing.T) {
+	registers := strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+			t.Run(arch+"/"+op+"/Go-g-register-alias", func(t *testing.T) {
+				source := "TEXT swap(SB),4,$0-0\n" + op + " g\nRET\n"
+				if arch == "386" {
+					goAssemblerOracleOutput(t, arch, source, "", false)
+					return
+				}
+				code := x86OrderingHintGoBytes(t, arch, source)
+				physical := x86OrderingHintGoBytes(t, arch, strings.ReplaceAll(source, " g\n", " R14\n"))
+				if !bytes.Equal(code, physical) {
+					t.Fatal("official source g alias did not retain its exact R14 encoding")
+				}
+			})
+			for index, register := range registers {
+				t.Run(arch+"/"+op+"/"+register, func(t *testing.T) {
+					source := "TEXT swap(SB),4,$0-0\n" + op + " " + register + "\nRET\n"
+					if arch == "386" && (op == "BSWAPQ" || index >= 8) {
+						goAssemblerOracleOutput(t, arch, source, "", false)
+						return
+					}
+					code := x86OrderingHintGoBytes(t, arch, source)
+					var want []byte
+					if op == "BSWAPQ" {
+						want = append(want, 0x48|byte(index/8))
+					} else if index >= 8 {
+						want = append(want, 0x41)
+					}
+					want = append(want, 0x0f, 0xc8+byte(index%8), 0xc3)
+					if !bytes.Equal(code, want) {
+						t.Fatalf("complete original Go BSWAP bytes=%x, independent encoding=%x", code, want)
+					}
+				})
+			}
+			for _, operand := range []string{"AL", "AH", "X0", "M0", "K1", "FS", "TLS", "R16", "$1", "(AX)", "ret+0(FP)", "table(SB)", "AX,BX", ""} {
+				t.Run(arch+"/"+op+"/reject/"+operand, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT swap(SB),4,$0-0\n"+op+" "+operand+"\nRET\n", "", false)
+				})
+			}
+			for _, suffix := range []string{".Z", ".SAE"} {
+				t.Run(arch+"/"+op+"/reject-suffix/"+suffix, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT swap(SB),4,$0-0\n"+op+suffix+" AX\nRET\n", "", false)
+				})
+			}
+		}
+		for _, op := range []string{"BSWAPB", "BSWAPW"} {
+			t.Run(arch+"/reject-name/"+op, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT swap(SB),4,$0-0\n"+op+" AX\nRET\n", "", false)
+			})
+		}
+	}
+}
+
+// The complete ordinary numerical cohort excludes physical SP/AMD64 BP, whose
+// original Go encodings are observed above without inventing their entry role.
+// L on amd64 returns the full64-bit word, independently observing zero extension.
+func x86ByteSwapObjectFixture(t *testing.T, arch string) (string, string) {
+	t.Helper()
+	word, typ, move, push, pop := 8, "uint64", "MOVQ", "PUSHQ", "POPQ"
+	registers := strings.Fields("AX CX DX BX SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+	ops := []string{"BSWAPL", "BSWAPQ"}
+	if arch == "386" {
+		word, typ, move, push, pop = 4, "uint32", "MOVL", "PUSHL", "POPL"
+		registers, ops = strings.Fields("AX CX DX BX BP SI DI"), []string{"BSWAPL"}
+	}
+	var source, declarations strings.Builder
+	for _, op := range ops {
+		for _, register := range registers {
+			name := op + "_" + register
+			fmt.Fprintf(&declarations, "func %s(x %s) %s\n", name, typ, typ)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),%s\n%s %s\n%s %s,ret+%d(FP)\nRET\n", name, 2*word, move, register, op, register, move, register, word)
+		}
+		fmt.Fprintf(&declarations, "func Sparse%s(x byte) byte\n", op)
+		fmt.Fprintf(&source, "TEXT ·Sparse%s(SB),4,$0-%d\nMOVB x+0(FP),AX\n%s AX\n%s AX\nMOVB AX,ret+%d(FP)\nRET\n", op, word+1, op, op, word)
+		fmt.Fprintf(&declarations, "func Status%s(x,seed %s) %s\n", op, typ, typ)
+		fmt.Fprintf(&source, "TEXT ·Status%s(SB),4,$0-%d\n%s x+0(FP),BX\n%s seed+%d(FP)\nPOPF%s\n%s BX\nPUSHF%s\n%s AX\nCLD\n%s AX,ret+%d(FP)\nRET\n", op, 3*word, move, push, word, move[3:], op, move[3:], pop, move, 2*word)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ByteSwapObjectFixtureCompleteNumericalRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		source, declarations := x86ByteSwapObjectFixture(t, arch)
+		count := 32
+		if arch == "386" {
+			count = 9
+		}
+		if strings.Count(source, "TEXT ·") != count || strings.Count(declarations, "func ") != count {
+			t.Fatal("complete numerical bank/partial/FLAGS fixture inventory changed")
+		}
+		x86ResultGPSIMDAdmissionAPIs(t, arch, source, declarations, true)
+	}
+}
+
+func TestX86ByteSwapOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("BSWAP complete objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86ByteSwapObjectFixture(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete BSWAP source failed", err)
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input := ir
+						if optimizeIR {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimizeIR, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_bswap_test.go b/x86_result_bswap_test.go
new file mode 100644
index 000000000..37c618d02
--- /dev/null
+++ b/x86_result_bswap_test.go
@@ -0,0 +1,573 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"math/bits"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ByteSwapCompleteOfficialGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	if !strings.Contains(table, "var ybswap = []ytab{\n\t{Z_rp, 2, argList{Yrl}},\n}") {
+		t.Fatal("complete official Go BSWAP classes/zcase/zoffset changed")
+	}
+	rows := regexp.MustCompile(`\{A(BSWAP\w+), (\w+), (\w+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(table, -1)
+	if len(rows) != 2 || len(x86ByteSwapSpecs) != 2 {
+		t.Fatal("complete BSWAP family changed", rows)
+	}
+	for _, row := range rows {
+		prefix := map[string]string{"BSWAPL": "Px", "BSWAPQ": "Pw"}[row[1]]
+		if prefix == "" || row[2] != "ybswap" || row[3] != prefix || row[4] != "0x0f, 0xc8" {
+			t.Fatal("complete BSWAP opcode/operand-size attributes changed", row)
+		}
+	}
+}
+
+func TestX86ByteSwapCompleteGrammarAndDescriptor(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []Op{"BSWAPL", "BSWAPQ"} {
+			for _, register := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH X0 Y0 Z0 K1 M0 FS TLS R16") {
+				t.Run(arch+"/"+string(op)+"/"+register, func(t *testing.T) {
+					ins := Instr{Op: op, Args: []Operand{{Kind: OpReg, Reg: Reg(register)}}, Raw: string(op) + " " + register}
+					before := ins
+					before.Args = append([]Operand(nil), ins.Args...)
+					valid := strings.Contains(" AX CX DX BX SP BP SI DI ", " "+register+" ") ||
+						arch == "amd64" && strings.Contains(" R8 R9 R10 R11 R12 R13 R14 R15 ", " "+register+" ")
+					valid = valid && !(arch == "386" && op == "BSWAPQ")
+					effect, known, err := x86TypedInstructionByteEffect(op, ins, arch)
+					if !known || (err == nil) != valid {
+						t.Fatal("Go grammar bank/mode mismatch", known, err, valid)
+					}
+					if !reflect.DeepEqual(before, ins) {
+						t.Fatal("descriptor rewrote original instruction")
+					}
+					if valid {
+						width := int64(4)
+						if op == "BSWAPQ" {
+							width = 8
+						}
+						want := x86TypedByteEffect{operands: []x86TypedByteOperand{{index: 0, operand: ins.Args[0], width: width, read: true, write: true}}}
+						if !reflect.DeepEqual(effect, want) {
+							t.Fatal("BSWAP gained flags/memory/other operand effects", effect)
+						}
+					}
+				})
+			}
+			for _, args := range [][]Operand{nil, {{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: BX}},
+				{{Kind: OpImm, Imm: 7}}, {{Kind: OpFP, FPName: "ret", FPOffset: 0}},
+				{{Kind: OpMem, Mem: MemRef{Base: AX}}}, {{Kind: OpSym, Sym: "table(SB)"}}} {
+				if _, known, err := x86ByteSwapProperties(op, Instr{Op: op, Args: args}, arch); !known || err == nil {
+					t.Fatal("unregistered BSWAP operand form accepted", arch, op, args)
+				}
+			}
+		}
+	}
+	for _, op := range []Op{"BSWAPL.Z", "BSWAPQ.SAE"} {
+		if _, known, err := x86ByteSwapProperties(op, Instr{Op: op, Args: []Operand{{Kind: OpReg, Reg: AX}}}, "amd64"); !known || err == nil {
+			t.Fatal("unregistered suffix accepted", op)
+		}
+	}
+	for _, op := range []Op{"BSWAP", "BSWAPB", "BSWAPW", "BSWAPX"} {
+		if _, known, err := x86ByteSwapProperties(op, Instr{Op: op}, "amd64"); known || err != nil {
+			t.Fatal("unregistered family name borrowed BSWAP", op)
+		}
+	}
+	for _, arch := range []string{"arm", "arm64", "wasm", ""} {
+		if _, known, err := x86ByteSwapProperties("BSWAPL", Instr{Args: []Operand{{Kind: OpReg, Reg: AX}}}, arch); !known || err == nil {
+			t.Fatal("unbound/non-x86 mode acquired BSWAP", arch)
+		}
+	}
+	if _, _, err := x86ByteSwapProperties("BSWAPL", Instr{Op: "BSWAPQ", Args: []Operand{{Kind: OpReg, Reg: AX}}}, "amd64"); err == nil {
+		t.Fatal("dispatch/source opcode mismatch accepted")
+	}
+}
+
+func TestX86ResultByteSwapEveryByteMaskAndIndependentFlags(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []Op{"BSWAPL", "BSWAPQ"} {
+			if arch == "386" && op == "BSWAPQ" {
+				continue // Independently rejected syntax row, not a skipped execution.
+			}
+			for _, register := range strings.Fields("AX CX DX BX SI DI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+				if arch == "386" && strings.HasPrefix(register, "R") {
+					continue
+				}
+				if arch == "amd64" && register == "BP" {
+					continue // Its independent physical frame role stays unbound.
+				}
+				t.Run(arch+"/"+string(op)+"/"+register, func(t *testing.T) {
+					width := int64(4)
+					if op == "BSWAPQ" {
+						width = 8
+					}
+					root, _, valid := x86ResultGP(Reg(register), width, arch)
+					if !valid {
+						t.Fatal("ordinary typed bank unexpectedly unbound")
+					}
+					ins := Instr{Op: op, Args: []Operand{{Kind: OpReg, Reg: Reg(register)}}}
+					for mask := 0; mask < 256; mask++ {
+						state := x86ResultState{flags: uint8(mask) & x86ByteFlagsAll, direction: x86ResultDirection(mask % 4)}
+						state.gp[root] = uint8(mask)
+						state.pointerGP[root] = true
+						before := state.clone()
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("pure byte permutation rejected", mask)
+						}
+						want := bits.Reverse8(uint8(mask))
+						if width == 4 {
+							want = bits.Reverse8(uint8(mask)&15)>>4 | 0xf0
+						}
+						before.gp[root], before.pointerGP[root] = want, false
+						if !reflect.DeepEqual(before, state) {
+							t.Fatal("byte dependency/zero-extension/unchanged state mismatch", mask, want, state)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapCanonicalAndAddressDomains(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		op, width := Op("BSWAPQ"), int64(8)
+		if arch == "386" {
+			op, width = "BSWAPL", 4
+		}
+		ins := Instr{Op: op, Args: []Operand{{Kind: OpReg, Reg: CX}}}
+		before := [16]bool{true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true}
+		after := x86ResultCallerAddressesAfter(ins, before, nil, arch)
+		before[1] = false
+		if after != before {
+			t.Fatal("BSWAP preserved rewritten caller address or revoked unrelated GP", arch, after)
+		}
+		for mask := 0; mask < 256; mask++ {
+			var canonical [16]uint8
+			canonical[1], canonical[3] = uint8(mask), 0xa5
+			got := x86RegisterCanonicalBytesAfter(ins, canonical, arch)
+			want := bits.Reverse8(uint8(mask))
+			if width == 4 {
+				want = bits.Reverse8(uint8(mask)&15)>>4 | uint8(mask)&0xf0
+			}
+			canonical[1] = want
+			if got != canonical {
+				t.Fatal("canonical bytes did not follow their actual permutation", arch, mask, got, canonical)
+			}
+		}
+	}
+}
+
+func TestX86ByteSwapLowererUsesCompleteGrammarWithoutStatusWrites(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []Op{"BSWAPL", "BSWAPQ"} {
+			for _, reg := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH X0 K1") {
+				ins := Instr{Op: op, Args: []Operand{{Kind: OpReg, Reg: Reg(reg)}}}
+				c, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				c.goarch = arch
+				start := output.Len()
+				_, _, grammarError := x86ByteSwapProperties(op, ins, arch)
+				handled, terminal, err := c.lowerArith(op, ins)
+				if grammarError == nil && arch == "386" && reg == "SP" {
+					if !handled || terminal || err == nil || !strings.Contains(err.Error(), "386 direct SP write is unsupported") {
+						t.Fatal("valid Go SP syntax bypassed its independent stack-write contract", err)
+					}
+					continue
+				}
+				if !handled || terminal || (err == nil) != (grammarError == nil) {
+					t.Fatal("lowerer diverged from shared complete grammar", arch, op, reg, handled, terminal, err)
+				}
+				added := output.String()[start:]
+				if err != nil {
+					if added != "" {
+						t.Fatal("invalid BSWAP emitted partial IR", added)
+					}
+					continue
+				}
+				bits := 32
+				if op == "BSWAPQ" {
+					bits = 64
+				}
+				if !strings.Contains(added, fmt.Sprintf("call i%d @llvm.bswap.i%d", bits, bits)) || strings.Contains(added, "store i1") {
+					t.Fatal("wrong byte-swap width or status/DF write", added)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapCompleteThreeAPITypedBanks(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+			if target.arch == "386" && op == "BSWAPQ" {
+				continue
+			}
+			for _, reg := range strings.Fields("AX CX DX BX SI DI BP R8 R9 R10 R11 R12 R13 R14 R15") {
+				if target.arch == "386" && strings.HasPrefix(reg, "R") {
+					continue
+				}
+				if target.arch == "amd64" && reg == "BP" {
+					continue
+				}
+				move, typ := "MOVL", "uint32"
+				if op == "BSWAPQ" {
+					move, typ = "MOVQ", "uint64"
+				}
+				_, _, _, source := x86ResultInitializationFixture(t, target.arch, "func Value(x "+typ+") "+typ,
+					fmt.Sprintf("%s x+0(FP),%s\n%s %s\n%s %s,ret0+%d(FP)\nRET", move, reg, op, reg, move, reg, goWordSize(target.arch)))
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+reg+"/"+api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value(x "+typ+") "+typ+"\n", target.arch, target.triple)
+						if err != nil || ir == "" {
+							t.Fatal("actual initialized ABI0 result lost its BSWAP bytes", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapPhysicalStackAndFrameStayIndependent(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, register := range []Reg{SP, BP} {
+			if arch == "386" && register == BP {
+				continue // Positive source-defined BP is in the complete bank roots.
+			}
+			op, move, typ, word := "BSWAPQ", "MOVQ", "uint64", 8
+			if arch == "386" {
+				op, move, typ, word = "BSWAPL", "MOVL", "uint32", 4
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+string(register)+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s $7,%s\n%s %s\n%s %s,ret0+0(FP)\nRET\n", word, move, register, op, register, move, register)
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() "+typ+"\n", arch, testTargetTriple("linux", arch))
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("numerical byte swap acquired a physical SP/AMD64 BP contract", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapCanonicalBoolAndRawSeparation(t *testing.T) {
+	for _, value := range []uint32{0, 0x01000000, 0x02000000, 0xff000000} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("386/%x/%s", value, api), func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nMOVL $%d,AX\nBSWAPL AX\nMOVB AX,ret0+0(FP)\nRET\n", value)
+				ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() bool\n", "386", "i386-unknown-linux-gnu")
+				if value <= 0x01000000 {
+					if err != nil || ir == "" {
+						t.Fatal("permuted actual canonical byte rejected", err)
+					}
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("numerical definedness became canonical bool", err)
+				}
+			})
+		}
+	}
+	for _, mutate := range []func(*Instr){
+		func(ins *Instr) { ins.x86Encoded = true },
+		func(ins *Instr) { ins.x86AddressBits = 32 },
+		func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+		func(ins *Instr) { ins.x86SegmentPrefix = 1 },
+	} {
+		ins := Instr{Op: "BSWAPL", Args: []Operand{{Kind: OpReg, Reg: AX}}}
+		mutate(&ins)
+		state := x86ResultState{}
+		state.gp[0] = 255
+		before := state.clone()
+		if x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(before, state) {
+			t.Fatal("physical/raw role borrowed ordinary BSWAP byte proof", ins)
+		}
+	}
+}
+
+func TestX86ResultByteSwapCFGPartialAndOpaqueBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		op, move, typ, word := "BSWAPQ", "MOVQ", "uint64", 8
+		if arch == "386" {
+			op, move, typ, word = "BSWAPL", "MOVL", "uint32", 4
+		}
+		for _, row := range []struct {
+			name, declaration, body string
+			accept                  bool
+		}{
+			{"partial double permutation", "func Value() uint8", "MOVB $7,AX\n" + op + " AX\n" + op + " AX\nMOVB AX,ret0+0(FP)", true},
+			{"partial byte moves away", "func Value() uint8", "MOVB $7,AX\n" + op + " AX\nMOVB AX,ret0+0(FP)", false},
+			{"partial full result", "func Value() " + typ, "MOVB $7,AX\n" + op + " AX\n" + move + " AX,ret0+0(FP)", false},
+			{"both CFG paths initialize", "func Value(x " + typ + ") " + typ, move + " x+0(FP),BX\nCMP" + string(move[len(move)-1]) + " BX,$0\nJE other\n" + move + " $7,AX\nJMP joined\nother:\n" + move + " $9,AX\njoined:\n" + op + " AX\n" + move + fmt.Sprintf(" AX,ret0+%d(FP)", word), true},
+			{"unknown CFG path", "func Value(x " + typ + ") " + typ, move + " x+0(FP),BX\nCMP" + string(move[len(move)-1]) + " BX,$0\nJE joined\n" + move + " $7,AX\njoined:\n" + op + " AX\n" + move + fmt.Sprintf(" AX,ret0+%d(FP)", word), false},
+			{"pointer double permutation not numeric", "func Value(p *byte) " + typ, move + " p+0(FP),AX\n" + op + " AX\n" + op + " AX\n" + move + fmt.Sprintf(" AX,ret0+%d(FP)", word), false},
+			{"unknown flags remain unknown", "func Value() uint8", move + " $7,AX\n" + op + " AX\nSETEQ ret0+0(FP)", false},
+			{"known flags unchanged", "func Value() uint8", move + " $7,AX\nCMP" + string(move[len(move)-1]) + " AX,$0\n" + op + " AX\nSETEQ ret0+0(FP)", true},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, row.declaration, row.body+"\nRET")
+				err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+				if row.accept && err != nil || !row.accept && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("full CFG byte/opaque/flags boundary differs", row.accept, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultByteSwapWholeSource(t *testing.T) {
+	for _, row := range []struct{ arch, op, move, typ string }{
+		{"amd64", "BSWAPQ", "MOVQ", "uint64"},
+		{"amd64", "BSWAPL", "MOVL", "uint32"},
+		{"386", "BSWAPL", "MOVL", "uint32"},
+	} {
+		t.Run(row.arch+"/"+row.op, func(t *testing.T) {
+			body := fmt.Sprintf("%s x+0(FP),AX\n%s AX\n%s AX,ret0+%d(FP)\nRET", row.move, row.op, row.move, goWordSize(row.arch))
+			_, file, sig, _ := x86ResultInitializationFixture(t, row.arch, "func Value(x "+row.typ+") "+row.typ, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, row.arch); err != nil {
+				t.Fatal("initialized numerical BSWAP lost its complete result:", err)
+			}
+		})
+	}
+}
+
+func TestX86ResultByteSwapUnknownPublicResult(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				op, move, typ, bytes := "BSWAPQ", "MOVQ", "uint64", 8
+				if target.arch == "386" {
+					op, move, typ, bytes = "BSWAPL", "MOVL", "uint32", 4
+				}
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s AX\n%s AX,ret0+0(FP)\nRET\n", bytes, op, move)
+				ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() "+typ+"\n", target.arch, target.triple)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("unknown BSWAP bytes became a declared result: output=%t error=%v", ir != "", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultByteSwapLogicalBoolRequiresIndependentRole(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("canonical BSWAP objects require LLVM22 llc")
+	}
+	for _, target := range x86OrderingHintTargets {
+		for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+			if target.arch == "386" && op == "BSWAPQ" {
+				continue
+			}
+			for _, row := range []struct {
+				name, initialize string
+				accept           bool
+			}{
+				{"unknown", "", false},
+				{"noncanonical", "MOVL $0x02000000,AX\n", false},
+				{"canonical zero", "MOVL $0,AX\n", true},
+				{"canonical one", "MOVL $0x01000000,AX\n", true},
+			} {
+				initialize := row.initialize
+				if op == "BSWAPQ" {
+					switch row.name {
+					case "noncanonical":
+						initialize = "MOVQ $0x0200000000000000,AX\n"
+					case "canonical one":
+						initialize = "MOVQ $0x0100000000000000,AX\n"
+					}
+				}
+				source := "TEXT ·Value(SB),4,$0-1\n" + initialize + op + " AX\nMOVB AX,ret0+0(FP)\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+row.name+"/"+api, func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() bool\n", target.arch, target.triple)
+						if !row.accept {
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("undefined/noncanonical BSWAP bytes became a logical bool: output=%t error=%v", ir != "", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("canonical byte permutation lost its ordinary ABI0 bool role", err)
+						}
+						for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					})
+				}
+			}
+		}
+		for _, value := range []int{0, 1} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/unchanged-bool/%d/%s", target.triple, value, api), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-1\nMOVB $%d,ret0+0(FP)\nRET\n", value)
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() bool\n", target.arch, target.triple)
+					if err != nil || ir == "" {
+						t.Fatal("BSWAP admission stole an unchanged independent bool body", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapUnknownNonIntegerResults(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, row := range []struct {
+			typ, move string
+			width     int
+		}{
+			{"float32", "MOVL", 4}, {"float64", "MOVQ", 8}, {"*byte", "MOVQ", 8},
+		} {
+			op := "BSWAPQ"
+			if target.arch == "386" {
+				op = "BSWAPL"
+				if row.typ == "*byte" {
+					row.move, row.width = "MOVL", 4
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.typ+"/"+api, func(t *testing.T) {
+					store := row.move + " AX,ret0+0(FP)\n"
+					if target.arch == "386" && row.typ == "float64" {
+						store = "MOVL AX,ret0+0(FP)\nMOVL AX,ret0+4(FP)\n"
+					}
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s AX\n%sRET\n", row.width, op, store)
+					ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() "+row.typ+"\n", target.arch, target.triple)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unknown BSWAP bits escaped through a noninteger result: output=%t error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapExistingRegisterBoolRole(t *testing.T) {
+	for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+		for _, value := range []uint64{0, 1, 2, 255} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", op, value, api), func(t *testing.T) {
+					initialize := fmt.Sprintf("MOVL $%d,AX", value<<24)
+					if op == "BSWAPQ" {
+						initialize = fmt.Sprintf("MOVQ $%d,AX", value<<56)
+					}
+					source := amd64RegisterBoolSource(initialize + "\n" + op + " AX")
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a,b uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+					if value <= 1 {
+						if err != nil || ir == "" {
+							t.Fatal("existing actual register canonical role lost its BSWAP byte", err)
+						}
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("defined numerical byte became register canonical bool", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapActualGoRegisterAliasKeepsSourceAndUnknownEntry(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		if target.arch != "amd64" {
+			continue // Go registers g only on amd64; the actual assembler rejects386 above.
+		}
+		for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+			for _, initialized := range []bool{false, true} {
+				body := op + " g\nMOVQ g,ret0+0(FP)\nRET\n"
+				if initialized {
+					body = "MOVQ $0x1122334455667788,g\n" + body
+				}
+				source := "TEXT ·Value(SB),4,$0-8\n" + body
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				found := false
+				for _, ins := range file.Funcs[0].Instrs {
+					if ins.Op == Op(op) {
+						found = len(ins.Args) == 1 && ins.Args[0].Kind == OpReg && ins.Args[0].Reg == "R14" && ins.Raw == op+" g"
+					}
+				}
+				if !found {
+					t.Fatal("actual parsed alias lost original Op/Raw or normalized physical operand")
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/initialized=%t/%s", target.triple, op, initialized, api), func(t *testing.T) {
+						ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\nfunc Value() uint64\n", target.arch, target.triple)
+						if initialized {
+							if err != nil || ir == "" {
+								t.Fatal("source-defined ordinary numerical R14 alias lost its bytes", err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("g spelling supplied an invented thread/register entry value", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultByteSwapMixedBoolResultNeedsIndependentCanonicalRole(t *testing.T) {
+	for _, target := range x86OrderingHintTargets {
+		for _, op := range []string{"BSWAPL", "BSWAPQ"} {
+			if target.arch == "386" && op == "BSWAPQ" {
+				continue
+			}
+			for _, other := range []string{"uint8", "uint16", "uint32", "uint64", "float32", "float64"} {
+				for _, boolFirst := range []bool{false, true} {
+					results := other + ",bool"
+					if boolFirst {
+						results = "bool," + other
+					}
+					declaration := "func Value() (" + results + ")"
+					_, _, sig, _ := x86ResultInitializationFixture(t, target.arch, declaration, "RET")
+					var body strings.Builder
+					initialize := "MOVL $0x02000000,AX\n"
+					if op == "BSWAPQ" {
+						initialize = "MOVQ $0x0200000000000000,AX\n"
+					}
+					body.WriteString(initialize + op + " AX\n")
+					for index, slot := range sig.Frame.Results {
+						if slot.Type == I1 {
+							fmt.Fprintf(&body, "MOVB AX,ret%d+%d(FP)\n", index, slot.Offset)
+							continue
+						}
+						width := x86FrameScalarBytes(slot.Type, target.arch)
+						if width == 8 && target.arch == "386" {
+							fmt.Fprintf(&body, "MOVL $0,ret%d+%d(FP)\nMOVL $0,ret%d+%d(FP)\n", index, slot.Offset, index, slot.Offset+4)
+						} else {
+							move := map[int64]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+							if move == "" {
+								t.Fatal("mixed result fixture lost its actual scalar field")
+							}
+							fmt.Fprintf(&body, "%s $0,ret%d+%d(FP)\n", move, index, slot.Offset)
+						}
+					}
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body.String()+"RET")
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+op+"/"+results+"/"+api, func(t *testing.T) {
+							ir, err := x86OrderingHintTranslateAPI(t, api, source, "package ordering\n"+declaration+"\n", target.arch, target.triple)
+							if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("initialized mixed result byte became canonical bool: output=%t error=%v", ir != "", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_budget_payload_test.go b/x86_result_budget_payload_test.go
new file mode 100644
index 000000000..66b702207
--- /dev/null
+++ b/x86_result_budget_payload_test.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+// Independent logical byte-work oracle, not sizeof or a production charge.
+// All CFG states carry these domains even when a particular source does not
+// use MMX or K. FP/AUTO, canonical FP and optional aliases/stacks are additional.
+const x86IndependentResultBasePayload = 16 + // GP initialized-byte masks
+	16 + // Canonical GP masks
+	256 + // All 32 physical Z-register byte-definedness masks
+	8 + // Separate native MMX initialized-byte masks
+	8 + // K initializedness
+	1 + // Integer status FLAGS
+	16 + // Opaque pointer identities
+	16 + // Caller-address initializedness
+	32 + // Actual caller-origin IDs
+	1 + // Source shape discriminator
+	2 + // Pending scan fact
+	3 + // Predicate fact
+	1 + // Direction flag
+	1 + // Native string counter
+	2 + // Adjacent LEA register identity and byte mask, not pointer or NUM facts
+	12 // Adjacent shift: eight input-byte mask bytes and four typed byte fields
diff --git a/x86_result_byte_envelope_test.go b/x86_result_byte_envelope_test.go
new file mode 100644
index 000000000..6b867bf97
--- /dev/null
+++ b/x86_result_byte_envelope_test.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ABI0ResultInitializationCompleteStateByteEnvelope(t *testing.T) {
+	// 1944 FP bytes + 16 AUTO bytes + (16 GP + 16 canonical GP + 256 Z +
+	// 8 native MMX + 8 K + 1 flags + 16 pointer + 16 caller-address identities + 32 origin
+	// IDs + 2 scan-pending + 3 predicate + 1 DF + 1 string counter +
+	// 1 shape discriminator + 2 adjacent LEA + 12 adjacent shift observation bytes) is the logical payload
+	// bytes. Every vector bank now tracks all 64 byte-definedness bits; the
+	// redundant representation of its low-X bits is not another logical value.
+	// A linear CFG pays its source scan and
+	// eight conservative copy/join units for each visited instruction. This
+	// tests the logical work envelope, not Go's actual heap allocation size.
+	const payloadBytes = 1944 + 16 + x86IndependentResultBasePayload
+	const workLimit = 64 << 20
+	const lastLinear = workLimit / (9 * payloadBytes)
+	const lastSource = workLimit / (8 * payloadBytes)
+	for _, count := range []int{lastLinear, lastLinear + 1, 3609, lastSource, lastSource + 1} {
+		for _, target := range x86RawReturnTargets {
+			t.Run(fmt.Sprintf("%d/%s", count, target.triple), func(t *testing.T) {
+				body := "MOVL $1,AX\nMOVL AX,spill-4(SP)\n" +
+					"MOVL AX,ret0+1936(FP)\nMOVL AX,ret0+1940(FP)\n" +
+					strings.Repeat("NOP\n", count-5) + "RET"
+				_, _, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x [1936]byte) uint64", body)
+				source = strings.Replace(source, ",$0-", ",$16-", 1)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				t.Logf("actual complete-envelope source object: %+v", receipt)
+				if sig.Frame.Results[0].Offset != 1936 || file.Funcs[0].ArgSize != 1944 || len(file.Funcs[0].Instrs) != count+1 {
+					t.Fatal("actual typed source dimensions changed")
+				}
+				for _, query := range []struct {
+					name string
+					run  func(Func, FuncSig, string) error
+				}{
+					{"public", CheckX86ABI0ResultInitialization},
+					{"private-scalar-views", checkX86ScalarFPResultInitialization},
+				} {
+					err := query.run(file.Funcs[0], sig, target.arch)
+					if count == lastLinear {
+						if err != nil {
+							t.Errorf("%s rejected a bounded complete payload: %v", query.name, err)
+						}
+					} else {
+						phase := "must-defined"
+						if count > lastSource {
+							phase = "source-CFG"
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), phase+" byte budget exhausted") {
+							t.Errorf("%s undercounted the complete numerical/pointer state at %s: %v", query.name, phase, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_caller_address.go b/x86_result_caller_address.go
new file mode 100644
index 000000000..e389f687b
--- /dev/null
+++ b/x86_result_caller_address.go
@@ -0,0 +1,382 @@
+package plan9asm
+
+// TEST and CMP's register/immediate read-only rows observe actual incoming
+// caller addresses. CMP requires caller provenance for every register operand;
+// a numerical register is not a second address participant. The same physical
+// typed byte view and original immediate
+// encoding are used by lowering. This does not initialize GP bytes, prove a
+// pointee, or authorize a numerical/address result, store or native entry.
+func x86ResultCallerAddressTest(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, false
+	}
+	address, valid := false, true
+	for _, operand := range form.args {
+		if operand.Kind == OpReg {
+			root, _, physical := x86ResultGP(operand.Reg, int64(form.bits/8), arch)
+			// Source-wide shape validation sees all registered numerical
+			// registers together. It supplies no reaching caller provenance;
+			// the same operands must pass this gate again with shapeOnly=false.
+			if physical && (state.callerAddressGP[root] || !form.test && state.shapeOnly) {
+				address = true
+				continue
+			}
+		}
+		if form.test {
+			valid = valid && (operand.Kind == OpReg || operand.Kind == OpImm) &&
+				x86ResultRead(operand, int64(form.bits/8), state, owned, arch)
+		} else {
+			valid = valid && operand.Kind == OpImm && x86ResultRead(operand, int64(form.bits/8), state, owned, arch)
+		}
+	}
+	if !address {
+		return false, false
+	}
+	if !valid || ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false, true
+	}
+	state.flags = x86ByteFlagsAll
+	if form.test {
+		state.flags &^= x86ByteFlagAF
+	}
+	return true, true
+}
+
+// A source-bound string instruction or LOCK prefix has already passed its
+// complete paired transfer. Intersect with the prior must-domain: an untouched
+// register may retain its identity, but this post-consumer cannot introduce
+// one. Standalone LOCK still has no accepted numerical transfer or GP effect.
+func x86ResultCallerAddressesAfterTransfer(ins Instr, before, transferred [16]bool,
+	entryFP map[int64]bool, arch string) [16]bool {
+	_, stringMemory, err := x86StringInstructionProperties(ins, arch)
+	boundPrefix := ins.Op == "LOCK" && len(ins.Args) == 0
+	if (boundPrefix || stringMemory && err == nil) && x86ResultNamedPredicateInstruction(ins) {
+		for index := range before {
+			before[index] = before[index] && transferred[index]
+		}
+		return before
+	}
+	return x86ResultCallerAddressesAfter(ins, before, entryFP, arch)
+}
+
+// This post-transfer must-domain runs through the shared complete source CFG,
+// including dead effects and joins. A partial/full GP overwrite revokes its
+// old provenance independently of initialized bytes or opaque pointerGP.
+// Unknown effects conservatively revoke all caller addresses, never seed one.
+func x86ResultCallerAddressesAfter(ins Instr, before [16]bool, entryFP map[int64]bool, arch string) [16]bool {
+	if x86RawScalarFloatIntegerSource(ins, arch) {
+		form, _, _ := x86ScalarFloatIntegerProperties(ins, arch)
+		if destination, _, valid := x86ResultGP(ins.Args[1].Reg, int64(form.outputBits/8), arch); valid {
+			before[destination] = false
+		}
+		return before // Only the native GP result loses its old caller-address identity.
+	}
+	if x86RawCOMISource(ins, arch) {
+		return before // The exact scalar comparison has no GP output or new address role.
+	}
+	if x86RawMULXSource(ins, arch) {
+		form, _, _ := x86MULXProperties(ins.Op, ins, arch)
+		for _, output := range []Operand{form.low, form.high} {
+			if index, _, valid := x86ResultGP(output.Reg, int64(form.bits/8), arch); valid {
+				before[index] = false
+			}
+		}
+		return before // Retain unrelated identities, never a pointer from either product.
+	}
+	if x86RawZeroExtendSource(ins, arch) {
+		return before // Preserve existing GP identities without creating one.
+	}
+	if x86RawImmediateBlendSource(ins, arch) {
+		return before // Exact vector selection has no GP output or new caller-address role.
+	}
+	if x86RawPermute128Source(ins, arch) {
+		return before // Retain existing identities without creating a GP/pointee fact.
+	}
+	if x86RawScalarPrecisionSource(ins, arch) || x86RawPackedPrecisionSource(ins, arch) {
+		return before // The exact conversion writes X/MXCSR, never a new GP identity.
+	}
+	if x86RawExplicitMaskMoveSource(ins, arch) {
+		return before // Existing GP identities survive; no new address is created.
+	}
+	if x86RawUnalignedLoadSource(ins, arch) {
+		return before
+	}
+	if x86RawIntegerMinMaxSource(ins, arch) {
+		return before // Preserves existing identities, never creates a GP address.
+	}
+	if x86RawTernaryLogicSource(ins, arch) {
+		return before // Exact vector/mask inputs and writes have no GP destination.
+	}
+	if x86RawLegacyFloatCompareSource(ins, arch) {
+		return before // Exact legacy comparisons write X, not an existing GP identity.
+	}
+	if x86FloatMinMaxPreservesSourceState(ins, arch) {
+		return before // No GP destination; this creates no address or backing fact.
+	}
+	if x86PreservesNumericalSourceState(ins) {
+		return before
+	}
+	if x86WaitPackagePreservesStorage(ins) {
+		return before // No GP overwrite; this supplies no new address or memory fact.
+	}
+	if _, valid := x86EnqueueSourceForm(ins, arch); valid {
+		return before // Both GP addresses are read-only; submission supplies no memory fact.
+	}
+	if x86MaskLogicalPreservesStorage(ins) {
+		return before // Exact named/raw K-only forms never overwrite a GP identity.
+	}
+	if x86RawPackedConversionSource(ins, arch) || x86RawPackedReductionSource(ins, arch) {
+		return before // Exact physical conversions write no GP or caller-address identity.
+	}
+	if x86RawPackedDotSource(ins, arch) {
+		return before // Preserve only existing identities; no dot-product GP output exists.
+	}
+	if effect, known, err := x86TypedRegisterQueryByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, output := range effect.operands {
+			if index, _, valid := x86ResultGP(output.operand.Reg, output.width, arch); valid && output.write {
+				before[index] = false
+			}
+		}
+		return before // Exact query GP footprint; FLAGS stay in the independent descriptor.
+	}
+	if ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil ||
+		ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return [16]bool{}
+	}
+	ins = x86SourceMoveInstruction(ins, arch) // Original source/certificates stay unchanged.
+	if _, known, err := x86DuplicateMoveProperties(ins.Op, ins, arch); known && err == nil {
+		return before // A validated vector-only write preserves, but never creates, a GP identity.
+	}
+	if _, known, err := x86InLanePermuteProperties(ins.Op, ins, arch); known && err == nil {
+		return before // Named vector selection has no GP output or new address authority.
+	}
+	if _, known, err := x86MXCSRProperties(ins, arch); known && err == nil {
+		return before // All four original m32 opcodes preserve GP identities.
+	}
+	if form, known, err := x86X87WordProperties(ins, arch); known {
+		if err != nil {
+			return [16]bool{}
+		}
+		if form.kind == x86X87StoreStatus && form.operand.Kind == OpReg {
+			if index, _, valid := x86ResultGP(form.operand.Reg, 2, arch); valid {
+				before[index] = false
+			}
+		}
+		return before // Only FSTSW AX writes a GP; no unrelated identity changes.
+	}
+	if _, known, err := x86X87ValueProperties(ins, arch); known {
+		if err != nil {
+			return [16]bool{}
+		}
+		return before // Typed x87 value forms write no unrelated GP identity.
+	}
+	if form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch); known && err == nil {
+		// The paired typed emitter uses the effective REX byte register,
+		// which may be SI/DI rather than the textual DH/BH. This is only
+		// its write footprint, not permission to read the native source.
+		if destination, _, valid := x86ResultGP(form.destination, form.bytes, arch); valid {
+			before[destination] = false
+		}
+		return before
+	}
+	if (ins.Op == "REP" || ins.Op == "REPN") && len(ins.Args) == 0 {
+		return before // Only an independently accepted source-bound prefix reaches this post-consumer.
+	}
+	if form, known, err := x86StringInstructionProperties(ins, arch); known && err == nil {
+		before[1] = false // A possibly repeated native CX write.
+		if form.kind != "lods" {
+			before[7] = false
+		}
+		if form.kind == "cmps" || form.kind == "movs" || form.kind == "lods" {
+			before[6] = false
+		}
+		if form.kind == "lods" {
+			before[0] = false
+		}
+		return before // No implicit GP writes outside this typed footprint.
+	}
+	if destination, _, _, known := x86LogicalFPLEAWriteShape(ins, arch); known {
+		before[destination] = false
+		return before // Pure address calculation writes no unrelated GP or FLAGS.
+	}
+	if destination, _, _, _, known := x86SBLEAWriteShape(ins, arch); known {
+		before[destination] = false
+		return before // Only this validated destination loses its old address identity.
+	}
+	if _, known, err := x86SignedIntegerFloatProperties(ins, arch); known && err == nil {
+		return before // Signed conversion writes only its typed scalar/vector view.
+	}
+	if _, known, err := x86DirectionControlProperties(ins.Op, ins, arch); known && err == nil {
+		return before // Only DF changes; no GP, pointer or six-status writes.
+	}
+	if _, known := x86CallerPointerAdvanceProperties(ins, arch); known {
+		return before // Only a separately accepted full-word affine transfer preserves it.
+	}
+	if spec, known, err := amd64PackedStringCompareProperties(ins.Op, ins, arch); known && err == nil {
+		output, width, _ := spec.resultEffect()
+		if !spec.maskResult {
+			if index, _, valid := x86ResultGP(output, int64(width), arch); valid {
+				before[index] = false
+			}
+		}
+		return before // Neither the X0 result nor FLAGS write any other GP.
+	}
+	word := x86ResultPointerWord(arch)
+	if form, width, known, err := x86SwapProperties(ins, arch); known {
+		if err != nil {
+			return [16]bool{}
+		}
+		if form.nop {
+			return before
+		}
+		first, _, valid := x86ResultGP(form.register.Reg, width, arch)
+		if !valid {
+			return [16]bool{}
+		}
+		if form.other.Kind == OpReg {
+			last, _, valid := x86ResultGP(form.other.Reg, width, arch)
+			if !valid {
+				return [16]bool{}
+			}
+			if width == word {
+				before[first], before[last] = before[last], before[first]
+				return before
+			}
+			before[last] = false
+		}
+		before[first] = false
+		return before // A partial or memory overwrite never imports a caller identity.
+	}
+	move, lea, add, sub := Op("MOVQ"), Op("LEAQ"), Op("ADDQ"), Op("SUBQ")
+	if arch == "386" {
+		move, lea, add, sub = "MOVL", "LEAL", "ADDL", "SUBL"
+	}
+	if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+		destination, _, valid := x86ResultGP(ins.Args[1].Reg, word, arch)
+		if valid {
+			first := ins.Args[0]
+			switch ins.Op {
+			case move:
+				before[destination] = x86ResultPointerOperand(first, before, entryFP, arch)
+				return before
+			case lea:
+				base, _, valid := x86ResultGP(first.Mem.Base, word, arch)
+				before[destination] = first.Kind == OpMem && first.Mem.Sym == "" && valid && before[base]
+				return before // Numerical index/complete address checked by the original transfer.
+			case add, sub:
+				if ins.Op == add && !before[destination] {
+					before[destination] = x86ResultPointerOperand(first, before, entryFP, arch)
+				}
+				if ins.Op == sub && first.Kind == OpFP && entryFP[first.FPOffset] {
+					before[destination] = false // Canceling an actual input pointer consumes its address role.
+				}
+				if ins.Op == sub && first.Kind == OpReg {
+					if source, _, valid := x86ResultGP(first.Reg, word, arch); valid && before[source] {
+						before[destination] = false // A proved same-origin difference is numerical.
+					}
+				}
+				return before // Only the separately validated full-word address transform preserves it.
+			}
+		}
+	}
+	kill := func(operand Operand, width int64) {
+		if operand.Kind == OpReg {
+			if root, _, valid := x86ResultGP(operand.Reg, width, arch); valid {
+				before[root] = false
+			}
+		}
+	}
+	if form, known, err := x86StackWidthProperties(ins, arch); known {
+		if err != nil {
+			return [16]bool{}
+		}
+		if form.mode == amd64StackPopValue {
+			kill(ins.Args[0], int64(form.bits/8))
+		}
+		// This post-transfer observes only the GP write footprint. PUSH and
+		// FLAGS transport do not overwrite unrelated GP identities; POP's
+		// explicit destination does. The independent private-stack proof must
+		// still close every input, depth, memory and FLAGS effect first.
+		return before
+	}
+	if form, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch); known && err == nil {
+		for _, output := range x86ImplicitDivideWrites(form) {
+			kill(output.operand, output.width)
+		}
+		return before // A native continuation changes only the implicit GP output footprint.
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if operand.write {
+				kill(operand.operand, operand.width)
+			}
+		}
+		return before
+	}
+	if form, known, err := x86MoveMaskProperties(ins.Op, ins, arch); known {
+		if err != nil || form.byteWidth == 8 {
+			return [16]bool{} // Unbound physical MMX is not a caller effect.
+		}
+		index, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.byteWidth)
+		destination, _, physical := x86ResultGP(ins.Args[1].Reg, 4, arch)
+		if !valid || arch == "386" && index >= 8 || !physical {
+			return [16]bool{}
+		}
+		before[destination] = false // Complete typed r32 output, no other GP writes.
+		return before
+	}
+	if _, known, err := x86BroadcastProperties(ins.Op, ins, arch); known && err == nil {
+		return before // Scalar/block/mask inputs never give this vector output a GP write.
+	}
+	if _, known, err := x86VectorTestProperties(ins.Op, ins, arch); known && err == nil {
+		return before // Only FLAGS change; source/memory definedness is checked independently.
+	}
+	if form, known, err := x86ScalarBitScanProperties(ins.Op, ins, arch); known && err == nil {
+		kill(ins.Args[1], int64(form.bits/8))
+		return before // Conditional numerical definedness does not widen the write footprint.
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil {
+		kill(form.destination, 1)
+		return before
+	}
+	if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil {
+		return before
+	}
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 && len(ins.Args) == 2 {
+		kill(ins.Args[1], width)
+		return before
+	}
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known && err == nil && !form.mmx {
+		if !form.destinationX {
+			kill(ins.Args[1], int64(form.bits/8))
+		}
+		return before
+	}
+	if form, known, err := x86ScalarLaneProperties(ins, arch); known && err == nil {
+		if !form.insert {
+			kill(Operand{Kind: OpReg, Reg: form.transferReg}, int64(form.gpBits/8))
+		}
+		return before
+	}
+	if x86CallerVectorMoveKnown(ins) {
+		for _, operand := range ins.Args {
+			if operand.Kind == OpReg {
+				_, vector := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+				_, mask := amd64ParseKReg(operand.Reg)
+				if !vector && !mask {
+					return [16]bool{} // GP/alias/native banks need their own exact effect.
+				}
+			}
+		}
+		return before // Complete shared typed vector-only form, no GP output.
+	}
+	if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) || ins.Op == OpTEXT || ins.Op == OpLABEL || ins.Op == "NOP" {
+		return before
+	}
+	if _, known, err := x86DirectiveProperties(ins); known && err == nil {
+		return before
+	}
+	return [16]bool{}
+}
diff --git a/x86_result_caller_address_broadcast_test.go b/x86_result_caller_address_broadcast_test.go
new file mode 100644
index 000000000..46d5034f0
--- /dev/null
+++ b/x86_result_caller_address_broadcast_test.go
@@ -0,0 +1,115 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86CallerAddressBroadcastCompleteGPUnwrittenAndResultAnchors(t *testing.T) {
+	rows := x86BroadcastMemoryRows()
+	for _, spec := range x86BroadcastTestDirectory {
+		for _, bank := range spec.destinations {
+			if spec.source == "K" {
+				rows = append(rows, fmt.Sprintf("%s K1,%c2", spec.name, bank))
+			}
+			for _, source := range spec.source {
+				if source == 'X' {
+					rows = append(rows, fmt.Sprintf("%s X1,%c2", spec.name, bank))
+				} else if source == 'G' {
+					rows = append(rows, fmt.Sprintf("%s AX,%c2", spec.name, bank))
+				}
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range rows {
+			ins := x86YMMReadSource(t, row)
+			before := [16]bool{true, true, true, true, false, false, true, true}
+			if after := x86ResultCallerAddressesAfter(ins, before, nil, arch); after != before {
+				t.Errorf("%s %s: a vector-only output erased caller GP identities", arch, row)
+			}
+			anchor := x86ResultSlotAddress{start: 8, end: 16, offset: 8, valid: true}
+			state := x86ResultState{}
+			state.resultAddressGP[6] = anchor
+			x86ResultSlotRevokeOverwrites(ins, &state, state.resultAddressGP, arch)
+			if state.resultAddressGP[6] != anchor {
+				t.Errorf("%s %s: an unwritten logical result anchor was revoked", arch, row)
+			}
+		}
+	}
+}
+
+func TestX86CallerAddressBitScanRevokesOnlyActualDestination(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, direction := range []string{"F", "R"} {
+			widths := []string{"W", "L"}
+			if arch == "amd64" {
+				widths = append(widths, "Q")
+			}
+			for _, width := range widths {
+				ins := x86YMMReadSource(t, "BS"+direction+width+" DX,CX")
+				before := [16]bool{true, true, true, true, false, false, true, true}
+				want := before
+				want[1] = false
+				if after := x86ResultCallerAddressesAfter(ins, before, nil, arch); after != want {
+					t.Errorf("%s %s: conditional numerical result widened its GP-write footprint", arch, ins.Raw)
+				}
+			}
+		}
+	}
+}
+
+func TestX86CallerAddressVectorTestsHaveNoGPWrites(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"PTEST", "VPTEST", "VTESTPS", "VTESTPD"} {
+			banks := []string{"X"}
+			if op != "PTEST" {
+				banks = append(banks, "Y")
+			}
+			for _, bank := range banks {
+				for _, source := range []string{bank + "1", "(AX)", "feature+7(SB)"} {
+					ins := x86YMMReadSource(t, fmt.Sprintf("%s %s,%s2", op, source, bank))
+					before := [16]bool{true, true, true, true, false, false, true, true}
+					if after := x86ResultCallerAddressesAfter(ins, before, nil, arch); after != before {
+						t.Errorf("%s %s: read-only vector test erased unrelated GP addresses", arch, ins.Raw)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86CallerAddressRegisteredFootprintsCannotWashUnknownRoles(t *testing.T) {
+	before := [16]bool{true, true, true, true, false, false, true, true}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{
+			"VPBROADCASTB X1,X2", "VPMOVMSKB X1,DX", "VPTEST X1,X2", "BSFL DX,CX",
+		} {
+			for _, role := range []string{"raw", "decoded", "address override", "unbound address", "segment"} {
+				t.Run(arch+"/"+row+"/"+role, func(t *testing.T) {
+					ins := x86YMMReadSource(t, row)
+					switch role {
+					case "raw":
+						ins.x86SourceRaw = &x86SourceRawInstruction{}
+					case "decoded":
+						ins.x86Encoded = true
+					case "address override":
+						ins.x86AddressBits = 32
+					case "unbound address":
+						ins.x86UnboundAddressOverride = true
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					}
+					if after := x86ResultCallerAddressesAfter(ins, before, nil, arch); after != [16]bool{} {
+						t.Fatal("registered source spelling washed an unbound physical role", after)
+					}
+				})
+			}
+		}
+		for _, row := range []string{"VPBROADCASTB.Z X1,X2", "VPBROADCASTB X1,K0,X2", "BSFL X1,CX", "PTEST X1,Y2", "VPMOVMSKB M1,DX", "UNKNOWN X1,X2"} {
+			if after := x86ResultCallerAddressesAfter(x86YMMReadSource(t, row), before, nil, arch); after != [16]bool{} {
+				t.Fatal("unknown/malformed instruction preserved caller provenance", arch, row, after)
+			}
+		}
+	}
+}
diff --git a/x86_result_caller_address_go127_test.go b/x86_result_caller_address_go127_test.go
new file mode 100644
index 000000000..3e5c314f6
--- /dev/null
+++ b/x86_result_caller_address_go127_test.go
@@ -0,0 +1,94 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoX86SDKCallerAddressOriginalCompleteMaps(t *testing.T) {
+	for _, target := range []string{"linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) { goX86SDKCallerAddressOriginalCompleteMaps(t, target) })
+	}
+}
+
+func goX86SDKCallerAddressOriginalCompleteMaps(t *testing.T, target string) {
+	source, err := numericalSDKMapsReadCapture(t, target, "memhash_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ctx := source.sdk.originalContext
+	minimum, err := CaptureGoX86SDKLiteralAlignment(ctx, source.literals.owner)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { minimum.Close() })
+	pkg, file, options := numericalSDKLiteralPackage(t, source.literals.source, source.request.AssemblyFile)
+	bound, err := source.BindNumericalReadsWithLiteralAlignment(ctx, pkg, file, options, minimum)
+	if err != nil {
+		t.Fatal(err)
+	}
+	frozen, frozenOptions, err := freezeNumericalReadInputs(file, bound)
+	if err != nil || len(frozen.Funcs) != len(file.Funcs) || len(frozen.Data) != len(file.Data) || len(frozen.Globl) != len(file.Globl) {
+		t.Fatal("complete original source inventory differs", err)
+	}
+	for _, fn := range frozen.Funcs {
+		name := frozenOptions.ResolveSym(fn.Sym)
+		if name != pkg.Path+".memHashAES" {
+			continue
+		}
+		sig := frozenOptions.Sigs[name]
+		t.Logf("actual original entry %q arguments=%+v frame=%+v", fn.Sym, sig.Args, sig.Frame)
+		before := [16]bool{true}
+		for ordinal, ins := range fn.Instrs {
+			if ins.Op == "TESTW" {
+				break
+			}
+			after := x86ResultCallerAddressesAfter(ins, before, nil, "amd64")
+			if before[0] && !after[0] {
+				t.Fatalf("actual GP-unwritten entry prefix lost caller AX at ordinal %d: %s", ordinal, ins.Raw)
+			}
+			before = after
+		}
+	}
+	for _, api := range []string{"text", "context", "go-module"} {
+		t.Run(api, func(t *testing.T) {
+			ir := numericalFamilyTranslate(t, api, pkg, file, bound)
+			if strings.Count(ir, "define ") != len(file.Funcs) || !strings.Contains(ir, "external global [128 x i8]") || strings.Contains(ir, "constant [128") {
+				t.Fatal("complete original functions or mutable runtime AES global lost")
+			}
+			for _, read := range source.reads {
+				if read.original.Op != "PXOR" {
+					t.Fatal("actual selected SDK mutable read family changed", read.original.Op)
+				}
+			}
+			if strings.Count(ir, "pxor ($2), $0") != len(source.reads) {
+				t.Fatal("genuine original mutable AES/native-read inventory differs", len(source.reads))
+			}
+			func() {
+				context := llvm.NewContext()
+				defer context.Dispose()
+				module, err := parseIRModuleInContext(context, ir)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, global := range file.Globl {
+					definition := module.NamedGlobal(bound.ResolveSym(global.Sym))
+					floor := bound.NumericalReads.literalMinimum.Minima[global.Sym]
+					if definition.IsNil() || definition.IsDeclaration() || !definition.IsGlobalConstant() || floor == 0 ||
+						definition.Alignment() != int(goAssemblyDataAlignment(ArchAMD64, global.Size)) || definition.Alignment() < int(floor) {
+						t.Fatal("emitted original literal definition differs from authenticated minimum/Go size rule", global.Sym, floor)
+					}
+				}
+			}()
+			numericalLLVM22Axes(t, ir, options.TargetTriple, nil)
+		})
+	}
+	t.Log("complete original two TEXT/all DATA, exact mutable external AES/global join, authenticated minimum vs actual emitted alignment; logical objects only, not SDK-native caller/execution or frontend benchmark completion")
+}
diff --git a/x86_result_caller_address_movemask_test.go b/x86_result_caller_address_movemask_test.go
new file mode 100644
index 000000000..b65cf9548
--- /dev/null
+++ b/x86_result_caller_address_movemask_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86CallerAddressMoveMaskPreservesEveryUnwrittenGP(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+			banks := []string{"X"}
+			if op[0] == 'V' {
+				banks = append(banks, "Y")
+			}
+			limit := 8
+			if arch == "amd64" {
+				limit = 16
+			}
+			for _, bank := range banks {
+				for destination := 0; destination < limit; destination++ {
+					if destination == 4 || destination == 5 {
+						continue
+					}
+					register := []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"}[destination]
+					file, err := Parse(ArchAMD64, fmt.Sprintf("TEXT ·effect(SB),4,$0-0\n%s %s1,%s\nRET\n", op, bank, register))
+					if err != nil {
+						t.Fatal(err)
+					}
+					var before [16]bool
+					for index := 0; index < limit; index++ {
+						before[index] = index != 4 && index != 5
+					}
+					want := before
+					want[destination] = false
+					if after := x86ResultCallerAddressesAfter(file.Funcs[0].Instrs[1], before, nil, arch); after != want {
+						t.Errorf("%s %s/%s writes only %s; unrelated caller addresses lost", arch, op, bank, register)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86CallerAddressMoveMaskCompleteThreeAPIs(t *testing.T) {
+	for _, op := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+		for _, target := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				body := "MOVQ AX,SI\nPXOR X0,X0\n" + op + " X0,DX\nCMPQ AX,SI\nSETEQ AX"
+				if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p *byte) bool\n", "amd64", target, api); err != nil {
+					t.Errorf("%s/%s/%s: exact source mask output erased unrelated caller identity: %v", op, target, api, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_caller_address_runtime_test.go b/x86_result_caller_address_runtime_test.go
new file mode 100644
index 000000000..8b7323c11
--- /dev/null
+++ b/x86_result_caller_address_runtime_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86CallerAddressRuntimeRow struct {
+	body, address, test string
+	bits, condition     int
+}
+
+func x86CallerAddressRuntimeRows() []x86CallerAddressRuntimeRow {
+	var rows []x86CallerAddressRuntimeRow
+	for _, width := range []struct {
+		name string
+		bits int
+	}{{"B", 8}, {"W", 16}, {"L", 32}, {"Q", 64}} {
+		for condition, op := range amd64RegisterBoolConditions {
+			rows = append(rows, x86CallerAddressRuntimeRow{
+				body:    "MOVQ AX,DX\nLEAQ 16(DX),AX\nTEST" + width.name + " BX,AX\n" + op + " AX",
+				address: "a+16", test: "v&b", bits: width.bits, condition: condition,
+			})
+		}
+	}
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		rows = append(rows, x86CallerAddressRuntimeRow{
+			body:    alias + " AX,AX\nADDQ $16,AX\nTESTW $0xff0,AX\nJE yes\nMOVB $0,AX\nJMP done\nyes:\nMOVB $1,AX\ndone:",
+			address: "a+16", test: "v&UINT64_C(0xff0)", bits: 16, condition: 2,
+		})
+	}
+	return append(rows,
+		x86CallerAddressRuntimeRow{"TESTB BH,AH\nSETEQ AX", "a", "(v>>8)&(b>>8)", 8, 2},
+		x86CallerAddressRuntimeRow{"LEAQ (AX)(BX*8),AX\nTESTQ $-1,AX\nSETMI AX", "a+8*b", "v", 64, 9},
+		x86CallerAddressRuntimeRow{"SUBQ $16,AX\nTESTQ BX,AX\nSETEQ AX", "a-16", "v&b", 64, 2},
+		x86CallerAddressRuntimeRow{"ADDQ BX,AX\nTESTQ $-1,AX\nSETMI AX", "a+b", "v", 64, 9},
+	)
+}
+
+func TestX86ResultCallerAddressThreeTargetOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	for index, row := range x86CallerAddressRuntimeRows() {
+		name := fmt.Sprintf("Address%d", index)
+		source.WriteString(strings.ReplaceAll(x86CallerAddressRegisterSource(row.body), "·view", "·"+name))
+		fmt.Fprintf(&declarations, "func %s(p *byte,n uint64) bool\n", name)
+	}
+	requireAMD64RegisterResultGoObject(t, source.String())
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal(triple, api, err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				x86ResultInitializationObject(t, llc, triple, input, "caller-address")
+			}
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixX86CallerAddressInstructionBytesAndLLVM(t *testing.T) {
+	x86CallerAddressRuntime(t, x86CallerAddressRuntimeRows())
+}
+
+func x86CallerAddressRuntime(t *testing.T, rows []x86CallerAddressRuntimeRow) {
+	t.Helper()
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	var source, declarations, originals, wrappers, prototypes, checks strings.Builder
+	for index, row := range rows {
+		name := fmt.Sprintf("Address%d", index)
+		original := strings.ReplaceAll(x86CallerAddressRegisterSource(row.body), "·view", "·"+name)
+		source.WriteString(original)
+		fmt.Fprintf(&declarations, "func %s(p *byte,n uint64) bool\n", name)
+		// Reuse the independently declared original-byte AX/BX adapter and
+		// raw-u64/stack/GP canaries, not an SDK/native Go caller certificate.
+		originals.WriteString(amd64RegisterBoolOriginalAdapter(t, execution.triple, index, original))
+		fmt.Fprintf(&wrappers, "\ndefine i32 @Probe%d(ptr %%p,i64 %%n) {\n %%v=call i1 @%s(ptr %%p,i64 %%n)\n %%r=zext i1 %%v to i32\n ret i32 %%r\n}\n", index, name)
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(void*,uint64_t);\n", index)
+		fmt.Fprintf(&checks, "{uint64_t v=%s,r=%s,observed[7]={0},raw=Original%d(a,b,observed);unsigned wanted=predicate(r,%d,%d);uint32_t got=Probe%d(p,b);\n"+
+			"if(raw!=((v&~UINT64_C(255))|wanted)||(raw&255)>1||got!=wanted||!canaries(observed)){fprintf(stderr,\"row=%d offset=%%u mask=%%llx raw=%%llx LLVM=%%u expected=%%u\\n\",offset,(unsigned long long)b,(unsigned long long)raw,got,wanted);return 1;}}\n", row.address, row.test, index, row.bits, row.condition, index, index)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + originals.String() + prototypes.String() + `
+static int canaries(const uint64_t *p) {
+    return p[0]==UINT64_C(0x5a5a5a5a5a5a5a5a)&&p[1]==p[0]&&
+        p[2]==UINT64_C(0x6b6b6b6b6b6b6b6b)&&p[3]==p[2]&&
+        p[4]==UINT64_C(0x123456789abcdef0)&&p[5]==UINT64_C(0xfedcba9876543210)&&p[6]==UINT64_C(0x876543210fedcba9);
+}
+static unsigned predicate(uint64_t r,unsigned bits,unsigned condition) {
+    if(bits<64)r&=(UINT64_C(1)<<bits)-1;
+    unsigned zf=r==0,sf=(r>>(bits-1))&1;
+    uint8_t parity=r;parity^=parity>>4;parity^=parity>>2;parity^=parity>>1;
+    unsigned pf=(parity&1)==0;
+    /* TEST fixes CF/OF to zero, defines Z/S/P, and leaves AF undefined. */
+    unsigned want[]={1,0,zf,!sf,!zf&&!sf,!zf,zf||sf,zf,sf,sf,!zf,1,0,!pf,!sf,pf};
+    return want[condition];
+}
+int main(void) {
+    unsigned char arena[8192+32];
+    for(unsigned i=0;i<sizeof arena;i++)arena[i]=(unsigned char)(i*37+11);
+    const uint64_t masks[]={0,1,15,UINT64_C(0xff0),UINT64_C(0x8000),UINT64_C(0x80000000),UINT64_C(0x8000000000000000),UINT64_MAX};
+    for(unsigned offset=0;offset<4096;offset+=17)for(unsigned sample=0;sample<8;sample++){
+        void *p=&arena[offset];uint64_t a=(uintptr_t)p,b=masks[sample];
+` + checks.String() + `
+    }
+    for(unsigned i=0;i<sizeof arena;i++)if(arena[i]!=(unsigned char)(i*37+11))return 2;
+    puts("actual same caller pointer; complete original encoder bytes and LLVM TEST/address predicates; raw upper bytes, stack/GP and whole arena canaries; explicit i1-to-i32 only");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, optimized := range []bool{false, true} {
+			input, level := ir+wrappers.String(), "-O0"
+			if optimized {
+				input, level = x86MulDivRoundOptimize(t, input), "-O2"
+			}
+			t.Logf("%s/%s: %s", api, level, execution.compileAndRunLLVM(t, "caller-address", input, driver, level))
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixGoX86CallerAddressABI0Representation(t *testing.T) {
+	execution := x86FloatCompareRuntimeTools(t, x86FloatCompareSSE)
+	assembly := `TEXT ·Address(SB),4,$0-20
+MOVQ p+0(FP),AX
+ADDQ $16,AX
+TESTW $0xff0,AX
+SETEQ DX
+MOVBLZX DX,DX
+MOVL DX,ret+16(FP)
+RET
+TEXT ·Observe(SB),4,$32-40
+MOVQ p+0(FP),AX
+MOVQ AX,0(SP)
+MOVQ n+8(FP),AX
+MOVQ AX,8(SP)
+MOVQ $0x5a5a5a5a5a5a5a5a,AX
+MOVQ AX,16(SP)
+MOVQ $0x6b6b6b6b6b6b6b6b,AX
+MOVQ AX,24(SP)
+CALL ·Address(SB)
+MOVQ 16(SP),AX
+MOVQ AX,raw+16(FP)
+MOVQ 24(SP),AX
+MOVQ AX,adjacent+24(FP)
+MOVQ 0(SP),AX
+MOVQ AX,input+32(FP)
+RET
+`
+	declarations := "func Address(p *byte,n uintptr) uint32\nfunc Observe(p *byte,n uintptr)(raw,adjacent,input uintptr)\n"
+	oracle := `package framefixture
+import("testing";"unsafe")
+func TestOriginal(t *testing.T){
+    var arena [8192]byte;for i:=range arena{arena[i]=byte(i*37+11)}
+    seen:=uint8(0)
+    for offset:=0;offset<4096;offset++{
+        p:=&arena[offset];address:=uintptr(unsafe.Pointer(p));want:=uintptr(0)
+        if (address+16)&0xff0==0{want=1};seen|=1<<want
+        if Address(p,0)!=uint32(want){t.Fatalf("actual ABI0 pointer caller offset %d",offset)}
+        raw,adjacent,input:=Observe(p,0)
+        if raw!=0x5a5a5a5a00000000|want||adjacent!=0x6b6b6b6b6b6b6b6b||input!=address{t.Fatalf("raw result/stack/input canaries offset %d: %x %x %x",offset,raw,adjacent,input)}
+    }
+    if seen!=3{t.Fatal("page predicate lacks both real-address outcomes")}
+    for i,value:=range arena{if value!=byte(i*37+11){t.Fatal("address-only source changed caller memory")}}
+}
+`
+	fixedLocalPackedRunOriginal(t, execution, assembly, declarations, oracle, true)
+}
diff --git a/x86_result_caller_address_test.go b/x86_result_caller_address_test.go
new file mode 100644
index 000000000..63ccddfde
--- /dev/null
+++ b/x86_result_caller_address_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86CallerAddressRegisterSource(body string) string {
+	return "TEXT ·view<ABIInternal>(SB),4,$0-17\n" + body + "\nRET\n"
+}
+
+func TestX86ResultCallerAddressPredicateActualTypedEntry(t *testing.T) {
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, move := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+			body := move + " AX,DX\nLEAQ 16(DX),AX\nTEST" + width + " $0x70,AX\nSETEQ AX"
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p *byte,n uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+					t.Errorf("%s/%s/%s actual typed caller address predicate: %v", width, move, api, err)
+				}
+			}
+		}
+	}
+	for _, body := range []string{
+		"TESTB $0xf0,AH\nSETEQ AX",
+		"MOVOU (AX),X0\nTESTW $0xff0,AX\nSETEQ AX",
+		"TESTW $0xff0,AX\nMOVOU (AX),X0\nSETEQ AX",
+		"MOVQ AX,AX\nTESTW $0xff0,AX\nSETEQ AX",
+		"MOVD AX,AX\nTESTW $0xff0,AX\nSETEQ AX",
+		"MOVDQ2Q AX,AX\nTESTW $0xff0,AX\nSETEQ AX",
+		"ADDQ $16,AX\nTESTW $0xff0,AX\nJE yes\nMOVB $0,AX\nJMP done\nyes:\nMOVB $1,AX\ndone:",
+		"MOVQ AX,DX\nSUBQ $16,DX\nTESTQ BX,DX\nSETNE AX",
+		"LEAQ (AX)(BX*8),DX\nTESTB DX,DX\nSETPS AX",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p *byte,n uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Errorf("%s complete MOV/LEA/TEST/branch source: %v", api, err)
+			}
+		}
+	}
+}
+
+func TestX86ResultCallerAddressDomainIsNotOpaquePointerOrNumericalBytes(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·view(SB),4,$0-0\nTESTW $0xff0,AX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := file.Funcs[0].Instrs[1]
+	state := x86ResultState{}
+	state.pointerGP[0] = true // An SDK literal/OR opaque carrier alone has no caller role.
+	if accepted, _ := x86ResultCallerAddressTest(ins, &state, nil, "amd64"); accepted || state.flags != 0 {
+		t.Fatal("opaque pointerGP supplied actual caller address bits")
+	}
+	state.callerAddressGP[0] = true
+	state.pointerGP[0] = false
+	if accepted, known := x86ResultCallerAddressTest(ins, &state, nil, "amd64"); !accepted || !known || state.gp[0] != 0 || state.flags&x86ByteFlagAF != 0 {
+		t.Fatal("actual caller address observation manufactured GP bytes or AF", state)
+	}
+	if state.pointerGP[0] || x86ResultIncomingPointerAddressIdentity(Operand{Kind: OpMem, Mem: MemRef{Base: AX}}, &state, "amd64") {
+		t.Fatal("address-bit observation created a native read identity")
+	}
+	state.pointerGP[0] = true
+	other := state
+	other.callerAddressGP[0] = false
+	if merged := state.intersect(other); merged.callerAddressGP[0] || !merged.pointerGP[0] {
+		t.Fatal("caller address and opaque pointer must-domains were conflated", merged)
+	}
+}
+
+func TestX86ResultCallerAddressAllTypedFlagConsumersAndKills(t *testing.T) {
+	check := func(body string) {
+		t.Helper()
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p *byte,n uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Error(api, body, err)
+			}
+		}
+	}
+	for _, op := range []string{"JCC", "JCS", "JO", "JNO", "JE", "JNE", "JS", "JNS", "JP", "JNP", "JGE", "JL", "JG", "JLE", "JHI", "JLS"} {
+		check("TESTQ BX,AX\n" + op + " yes\nMOVB $0,AX\nJMP done\nyes:\nMOVB $1,AX\ndone:")
+	}
+	for op := range x86ConditionalMoveSpecs {
+		check("TESTQ BX,AX\nMOVQ $1,CX\nMOVQ $0,DX\n" + string(op) + " CX,DX\nMOVQ DX,AX")
+	}
+	for _, body := range []string{"MOVB $1,AX", "MOVW $1,AX", "MOVL $1,AX", "MOVQ $1,AX", "MOVBQZX CX,AX", "PEXTRB $0,X0,M0", "PEXTRD $0,X0,M0", "PEXTRQ $0,X0,M0", "PEXTRW $0,X0,M0", "PEXTRW $0,X0,AX", "MOVQ X0,AX", "RDTSC", "LAHF"} {
+		file, err := Parse(ArchAMD64, "TEXT ·effect(SB),4,$0-0\n"+body+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if after := x86ResultCallerAddressesAfter(file.Funcs[0].Instrs[1], [16]bool{true}, nil, "amd64"); after[0] {
+			t.Error("typed partial/full/implicit GP output kept stale caller address provenance", body)
+		}
+	}
+}
+
+func TestX86ResultCallerAddressSurvivesTypedUnwrittenGP(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·independent(SB),4,$0-0\nMOVQ BX,X0\nPINSRW $4,CX,X0\nPSHUFHW $0,X0,X0\nMOVO X0,X1\nPXOR ·independent(SB),X0\nAESENC X0,X0\nCMPQ CX,$16\nSAHF\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := [16]bool{true}
+	for _, ins := range file.Funcs[0].Instrs[1 : len(file.Funcs[0].Instrs)-1] {
+		if after := x86ResultCallerAddressesAfter(ins, before, nil, "amd64"); after != before {
+			t.Errorf("complete typed GP-unwritten shape unnecessarily lost a caller address: %s", ins.Raw)
+		}
+	}
+	// This private effect query grants no numerical source/load permission:
+	// original source/result transfer must already have accepted the effect.
+}
+
+func TestX86ResultCallerAddressPredicateCannotGrantAnotherContract(t *testing.T) {
+	for name, body := range map[string]string{
+		"partial-word":              "MOVW AX,DX\nTESTW $0xff0,DX\nSETEQ AX",
+		"partial-byte":              "MOVB AX,DX\nTESTB $0x70,DX\nSETEQ AX",
+		"partial-pointer-write":     "MOVW $0,AX\nTESTQ $0xff0,AX\nSETEQ AX",
+		"pointer-as-numeric-result": "TESTW $0xff0,AX",
+		"pointer-vector-escape":     "MOVQ AX,X0\nTESTW $0xff0,AX\nSETEQ AX",
+		"unknown-memory":            "TESTW $0xff0,(DX)\nSETEQ AX",
+		"unknown-index":             "LEAQ (AX)(DX*8),AX\nTESTW $0xff0,AX\nSETEQ AX",
+		"unknown-callee":            "CALL external(SB)\nTESTW $0xff0,AX\nSETEQ AX",
+		"unbound-flags":             "SETEQ AX",
+		"unknown-AF":                "TESTW $0xff0,AX\nLAHF\nMOVB AH,AX",
+		"stale-after-SET":           "TESTW $0xff0,AX\nSETEQ AX\nTESTQ $0xff0,AX\nSETEQ AX",
+		"mixed-origin":              "TESTQ BX,BX\nJE preserve\nMOVQ $7,AX\npreserve:\nTESTW $0xff0,AX\nSETEQ AX",
+		"raw":                       "BYTE $0x90\nTESTW $0xff0,AX\nSETEQ AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p *byte,n uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("%s caller address observation granted another contract: %v", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultCallerAddressPredicateTypedFPImport(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := x86ResultPointerWord(arch), "MOVQ"
+		widths := []string{"B", "W", "L", "Q"}
+		if arch == "386" {
+			move, widths = "MOVL", widths[:3]
+		}
+		for _, width := range widths {
+			body := fmt.Sprintf("%s x+0(FP),AX\nTEST%s $0x70,AX\nSETEQ DX\nMOVBLZX DX,DX\nMOVL DX,ret0+%d(FP)\nRET", move, width, word)
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x *byte) uint32", body)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, arch); err != nil {
+					t.Errorf("%s TEST%s typed caller FP import: %v", arch, width, err)
+				}
+			}
+			bad := strings.Replace(source, move+" x+0(FP),AX", "MOVB x+0(FP),AX", 1)
+			changed, err := Parse(Arch(arch), bad)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(changed.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("partial pointer FP bytes became an actual address", err)
+			}
+		}
+	}
+}
diff --git a/x86_result_caller_compare_objects_test.go b/x86_result_caller_compare_objects_test.go
new file mode 100644
index 000000000..190933f15
--- /dev/null
+++ b/x86_result_caller_compare_objects_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86CallerCompareRow struct {
+	body, left, right, rawBase string
+	bits, condition            int
+}
+
+func x86CallerCompareRows() []x86CallerCompareRow {
+	var rows []x86CallerCompareRow
+	for _, width := range []struct {
+		name string
+		bits int
+	}{{"B", 8}, {"W", 16}, {"L", 32}, {"Q", 64}} {
+		for condition, op := range amd64RegisterBoolConditions {
+			rows = append(rows, x86CallerCompareRow{"CMP" + width.name + " AX,BX\n" + op + " AX", "a", "b", "a", width.bits, condition})
+		}
+		for _, immediate := range []string{"0", "1", "127", "128", "255", "256", "-128", "-129", "32768", "65535", "2147483647", "2147483648", "4294967295", "-2147483648"} {
+			rows = append(rows, x86CallerCompareRow{"CMP" + width.name + " AX,$" + immediate + "\nSETCS AX", "a", immediate, "a", width.bits, 1})
+		}
+	}
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		rows = append(rows, x86CallerCompareRow{alias + " AX,DX\nLEAQ 16(DX),AX\nCMPQ AX,BX\nSETHI AX", "a+16", "b", "a+16", 64, 5})
+	}
+	return append(rows,
+		x86CallerCompareRow{"CMPB AH,BH\nSETCS AX", "a>>8", "b>>8", "a", 8, 1},
+		x86CallerCompareRow{"MOVQ AX,DI\nMOVQ BX,R8\nCMPB BH,R8B\nSETEQ AX", "a", "b", "a", 8, 2},
+		x86CallerCompareRow{"MOVQ AX,DX\nCMPQ DX,AX\nSETEQ AX", "a", "a", "a", 64, 2},
+	)
+}
+
+func x86CallerCompareSources() (string, string) {
+	var source, declarations strings.Builder
+	for index, row := range x86CallerCompareRows() {
+		name := fmt.Sprintf("Compare%d", index)
+		source.WriteString(strings.ReplaceAll(x86CallerAddressRegisterSource(row.body), "·view", "·"+name))
+		fmt.Fprintf(&declarations, "func %s(p,q *byte) bool\n", name)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86CallerAddressCMPThreeTargetOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source, declarations := x86CallerCompareSources()
+	requireAMD64RegisterResultGoObject(t, source)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(triple, api, err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				x86ResultInitializationObject(t, llc, triple, input, "caller-address-compare")
+			}
+		}
+	}
+}
diff --git a/x86_result_caller_compare_runtime_linux_amd64_test.go b/x86_result_caller_compare_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..45344f187
--- /dev/null
+++ b/x86_result_caller_compare_runtime_linux_amd64_test.go
@@ -0,0 +1,111 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Linux AMD64 owns both required actual execution axes. Other hosts retain
+// source/encoder/object coverage, not a fabricated runtime pass or tool skip.
+func x86CallerCompareNativeTools(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 native Linux AMD64 tools required")
+	}
+	return x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+}
+
+func TestCrossLinuxRuntimeMatrixX86CallerAddressCMPInstructionBytesAndLLVM(t *testing.T) {
+	execution := x86CallerCompareNativeTools(t)
+	source, declarations := x86CallerCompareSources()
+	var originals, wrappers, prototypes, checks strings.Builder
+	for index, row := range x86CallerCompareRows() {
+		name := fmt.Sprintf("Compare%d", index)
+		original := strings.ReplaceAll(x86CallerAddressRegisterSource(row.body), "·view", "·"+name)
+		originals.WriteString(amd64RegisterBoolOriginalAdapter(t, execution.triple, index, original))
+		fmt.Fprintf(&wrappers, "\ndefine i32 @Probe%d(ptr %%p,ptr %%q) {\n %%v=call i1 @%s(ptr %%p,ptr %%q)\n %%r=zext i1 %%v to i32\n ret i32 %%r\n}\n", index, name)
+		fmt.Fprintf(&prototypes, "extern uint32_t Probe%d(void*,void*);\n", index)
+		right := row.right
+		if row.bits == 64 && right != "a" && right != "b" && right != "b>>8" {
+			right = "(uint64_t)(int64_t)(int32_t)(uint32_t)(" + right + ")"
+		}
+		fmt.Fprintf(&checks, "{uint64_t observed[7]={0},raw=Original%d(a,b,observed);unsigned want=predicate(%s,%s,%d,%d);uint32_t got=Probe%d(p,q);\n"+
+			"if(raw!=(((%s)&~UINT64_C(255))|want)||(raw&255)>1||got!=want||!canaries(observed)){fprintf(stderr,\"row=%d offset=%%u other=%%u raw=%%llx LLVM=%%u expected=%%u\\n\",offset,other,(unsigned long long)raw,got,want);return 1;}}\n",
+			index, row.left, right, row.bits, row.condition, index, row.rawBase, index)
+	}
+	driver := `#include <stdint.h>
+#include <stdio.h>
+` + originals.String() + prototypes.String() + `
+static int canaries(const uint64_t *p) {
+    return p[0]==UINT64_C(0x5a5a5a5a5a5a5a5a)&&p[1]==p[0]&&
+        p[2]==UINT64_C(0x6b6b6b6b6b6b6b6b)&&p[3]==p[2]&&
+        p[4]==UINT64_C(0x123456789abcdef0)&&p[5]==UINT64_C(0xfedcba9876543210)&&p[6]==UINT64_C(0x876543210fedcba9);
+}
+static unsigned predicate(uint64_t a,uint64_t b,unsigned bits,unsigned condition) {
+    uint64_t mask=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1;
+    a&=mask;b&=mask;uint64_t r=(a-b)&mask;
+    unsigned cf=a<b,zf=r==0,sf=(r>>(bits-1))&1,of=(((a^b)&(a^r))>>(bits-1))&1;
+    uint8_t parity=r;parity^=parity>>4;parity^=parity>>2;parity^=parity>>1;
+    unsigned pf=(parity&1)==0;
+    unsigned want[]={!cf,cf,zf,sf==of,!zf&&sf==of,!cf&&!zf,zf||sf!=of,cf||zf,sf!=of,sf,!zf,!of,of,!pf,!sf,pf};
+    return want[condition];
+}
+int main(void) {
+    unsigned char arena[8192+32];
+    for(unsigned i=0;i<sizeof arena;i++)arena[i]=(unsigned char)(i*37+11);
+    const unsigned deltas[]={0,1,127,128,255,256,4095,8191};
+    for(unsigned offset=0;offset<4096;offset+=17)for(unsigned sample=0;sample<8;sample++){
+        unsigned other=(offset+deltas[sample])&8191;
+        void *p=&arena[offset],*q=&arena[other];uint64_t a=(uintptr_t)p,b=(uintptr_t)q;
+` + checks.String() + `
+    }
+    for(unsigned i=0;i<sizeof arena;i++)if(arena[i]!=(unsigned char)(i*37+11))return 2;
+    puts("actual caller pointers; complete original Go CMP bytes vs LLVM three APIs/O0/O2; physical aliases/immediates/all SETcc; raw upper-byte, stack/GP and arena canaries");
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal(api, err)
+		}
+		for _, optimized := range []bool{false, true} {
+			input, level := ir+wrappers.String(), "-O0"
+			if optimized {
+				input, level = x86MulDivRoundOptimize(t, input), "-O2"
+			}
+			t.Log(api, level, execution.compileAndRunLLVM(t, "caller-address-cmp", input, driver, level))
+		}
+	}
+}
+
+func TestCrossLinuxRuntimeMatrixGoX86CallerAddressCMPABI0Representation(t *testing.T) {
+	execution := x86CallerCompareNativeTools(t)
+	var assembly, declarations, checks strings.Builder
+	for _, width := range []struct {
+		name string
+		bits int
+	}{{"B", 8}, {"W", 16}, {"L", 32}, {"Q", 64}} {
+		fmt.Fprintf(&assembly, "TEXT ·Compare%s(SB),4,$0-17\nMOVQ p+0(FP),AX\nMOVQ q+8(FP),BX\nCMP%s AX,BX\nSETEQ DX\nMOVB DX,ret+16(FP)\nRET\n", width.name, width.name)
+		fmt.Fprintf(&assembly, "TEXT ·Observe%s(SB),4,$32-48\nMOVQ p+0(FP),AX\nMOVQ AX,0(SP)\nMOVQ q+8(FP),AX\nMOVQ AX,8(SP)\nMOVQ $0x5a5a5a5a5a5a5a5a,AX\nMOVQ AX,16(SP)\nMOVQ $0x6b6b6b6b6b6b6b6b,AX\nMOVQ AX,24(SP)\nCALL ·Compare%s(SB)\nMOVQ 16(SP),AX\nMOVQ AX,raw+16(FP)\nMOVQ 24(SP),AX\nMOVQ AX,adjacent+24(FP)\nMOVQ 0(SP),AX\nMOVQ AX,inputP+32(FP)\nMOVQ 8(SP),AX\nMOVQ AX,inputQ+40(FP)\nRET\n", width.name, width.name)
+		fmt.Fprintf(&declarations, "func Compare%s(p,q *byte) bool\nfunc Observe%s(p,q *byte)(raw,adjacent,inputP,inputQ uintptr)\n", width.name, width.name)
+		fmt.Fprintf(&checks, "{bits:=uint(%d);mask:=uint64(^uint64(0));if bits<64{mask=uint64(1)<<bits-1};want:=uintptr(0);if uint64(a)&mask==uint64(b)&mask{want=1};if Compare%s(p,q)!=(want==1){t.Fatal(\"actual Go ABI0 CMP %s\",offset,other)};raw,adjacent,inputP,inputQ:=Observe%s(p,q);if raw!=0x5a5a5a5a5a5a5a00|want||adjacent!=0x6b6b6b6b6b6b6b6b||inputP!=a||inputQ!=b{t.Fatalf(\"%s raw bool byte/stack/input canaries: %%x %%x %%x %%x\",raw,adjacent,inputP,inputQ)}}\n", width.bits, width.name, width.name, width.name, width.name)
+	}
+	oracle := `package framefixture
+import("testing";"unsafe")
+func TestOriginal(t *testing.T){
+    var arena [8192]byte;for i:=range arena{arena[i]=byte(i*37+11)}
+    for offset:=0;offset<4096;offset+=17{for _,delta:=range []int{0,1,127,128,255,256,4095,8191}{
+        other:=(offset+delta)&8191;p,q:=&arena[offset],&arena[other];a,b:=uintptr(unsafe.Pointer(p)),uintptr(unsafe.Pointer(q))
+` + checks.String() + `
+    }}
+    for i,value:=range arena{if value!=byte(i*37+11){t.Fatal("address-only CMP source changed caller memory")}}
+}
+`
+	fixedLocalPackedRunOriginal(t, execution, assembly.String(), declarations.String(), oracle, true)
+}
diff --git a/x86_result_caller_compare_test.go b/x86_result_caller_compare_test.go
new file mode 100644
index 000000000..2b4aab7e9
--- /dev/null
+++ b/x86_result_caller_compare_test.go
@@ -0,0 +1,168 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86CallerAddressCMPCompleteTypedParticipants(t *testing.T) {
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+			for _, operands := range []string{"AX,BX", "DX,AX", "DX,$0xf8"} {
+				body := alias + " AX,DX\nCMP" + width + " " + operands + "\nSETEQ AX"
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p,q *byte) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+						t.Errorf("%s/%s/%s/%s: actual caller CMP rejected: %v", width, alias, operands, api, err)
+					}
+				}
+			}
+		}
+	}
+	for _, body := range []string{
+		"CMPB AH,BH\nSETCS AX",
+		"MOVQ AX,DI\nMOVQ BX,R8\nCMPB BH,R8\nSETEQ AX", // REX BH is physical DI low byte.
+		"MOVQ AX,DX\nLEAQ 16(DX),DX\nCMPQ DX,BX\nSETGT AX",
+		"CMPQ AX,BX\nJE other\nMOVQ AX,DX\nJMP joined\nother:\nMOVQ BX,DX\njoined:\nCMPB DX,$0xf8\nSETHI AX",
+		"MOVQ AX,DX\nagain:\nCMPQ DX,BX\nJE done\nMOVQ BX,DX\nJMP again\ndone:\nSETEQ AX",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p,q *byte) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Error(api, body, err)
+			}
+		}
+	}
+}
+
+func TestX86CallerAddressCMPOnlyDefinesOriginalFlags(t *testing.T) {
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		file, err := Parse(ArchAMD64, "TEXT ·view(SB),4,$0-0\nCMP"+width+" AX,BX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		state := x86ResultState{}
+		state.callerAddressGP[0], state.callerAddressGP[3] = true, true
+		before := state
+		accepted, known := x86ResultCallerAddressTest(file.Funcs[0].Instrs[1], &state, nil, "amd64")
+		defined := state.flags
+		state.flags = before.flags
+		if !accepted || !known || defined != x86ByteFlagsAll || !reflect.DeepEqual(before, state) {
+			t.Fatal("CMP address predicate changed a non-FLAGS must-domain", width, accepted, known, state)
+		}
+	}
+}
+
+func TestX86CallerAddressCMPCompleteExistingFlagConsumers(t *testing.T) {
+	check := func(body string) {
+		t.Helper()
+		for _, api := range []string{"text", "module", "Go"} {
+			if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p,q *byte) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+				t.Error(api, body, err)
+			}
+		}
+	}
+	for _, op := range amd64RegisterBoolConditions {
+		check("CMPQ AX,BX\n" + op + " AX")
+	}
+	for op := range x86ConditionalMoveSpecs {
+		check("CMPQ AX,BX\nMOVQ $1,CX\nMOVQ $0,DX\n" + string(op) + " CX,DX\nMOVQ DX,AX")
+	}
+	for _, op := range []string{"JCC", "JCS", "JO", "JNO", "JE", "JNE", "JS", "JNS", "JP", "JNP", "JGE", "JL", "JG", "JLE", "JHI", "JLS"} {
+		check("CMPQ AX,BX\n" + op + " yes\nMOVB $0,AX\nJMP done\nyes:\nMOVB $1,AX\ndone:")
+	}
+	check("CMPQ AX,BX\nLAHF\nSETEQ AX") // AH is now a modeled numerical output, not a caller address.
+}
+
+func TestX86CallerAddressCMPCompleteGoRegisterViews(t *testing.T) {
+	wordRegisters := strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15")
+	byteRegisters := append(append([]string(nil), wordRegisters...), strings.Fields("AL AH BL BH CL CH DL DH BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B")...)
+	for _, width := range []string{"B", "W", "L", "Q"} {
+		registers := wordRegisters
+		if width == "B" {
+			registers = byteRegisters
+		}
+		for _, name := range registers {
+			t.Run(width+"/"+name, func(t *testing.T) {
+				root, valid := amd64FullRegBase(Reg(name))
+				if !valid {
+					t.Fatal("registered Go view lost its physical bank", name)
+				}
+				body := "CMP" + width + " " + name + ",AX\nSETEQ AX"
+				ordinary := root != SP && root != BP
+				if ordinary {
+					body = "MOVQ BX," + string(root) + "\n" + body
+				}
+				source := x86CallerAddressRegisterSource(body)
+				requireAMD64RegisterResultGoObject(t, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					_, err := x86ScalarFPBitViewAPI(t, source, "func view(p,q *byte) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+					if ordinary && err != nil || !ordinary && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Error(api, "registered address view vs native SP/BP role differs", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86CallerAddressCMPRejectsOtherParticipantsAndContracts(t *testing.T) {
+	for name, body := range map[string]string{
+		"unknown DX": "CMPQ AX,DX\nSETEQ AX", "native g": "CMPQ AX,R14\nSETEQ AX",
+		"numeric register":    "MOVQ $1,DX\nCMPQ AX,DX\nSETEQ AX",
+		"partial copy":        "MOVW AX,DX\nCMPW AX,DX\nSETEQ AX",
+		"partial overwrite":   "MOVQ BX,DX\nMOVB $1,DX\nCMPB AX,DX\nSETEQ AX",
+		"one lost join":       "CMPQ AX,BX\nJE other\nMOVQ AX,DX\nJMP joined\nother:\nMOVW BX,DX\njoined:\nCMPB DX,AX\nSETEQ AX",
+		"wrong REX high byte": "MOVQ BX,R8\nCMPB AH,R8\nSETEQ AX",
+		"immediate direction": "CMPQ $1,AX\nSETEQ AX",
+		"pointer vector":      "CMPQ AX,BX\nMOVQ AX,X0\nSETEQ AX",
+		"pointer result":      "CMPQ AX,BX", "noncanonical result": "CMPQ AX,BX\nMOVB $2,AX",
+		"memory participant":                  "CMPQ AX,(BX)\nSETEQ AX",
+		"unknown call":                        "CMPQ AX,BX\nCALL external(SB)\nSETEQ AX",
+		"raw entry":                           "BYTE $0x90\nCMPQ AX,BX\nSETEQ AX",
+		"AH overwrite revokes caller address": "CMPQ AX,BX\nLAHF\nCMPQ AX,BX\nSETEQ AX",
+	} {
+		t.Run(name, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				if _, err := x86ScalarFPBitViewAPI(t, x86CallerAddressRegisterSource(body), "func view(p,q *byte) bool\n", "amd64", "x86_64-unknown-linux-gnu", api); err == nil {
+					t.Error(api, "CMP predicate granted another source/entry/result role")
+				}
+			}
+		})
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·view(SB),4,$0-0\nCMPQ AX,BX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	state := x86ResultState{}
+	state.callerAddressGP[0], state.pointerGP[3] = true, true // Literal/closure/native identity is not caller provenance.
+	if accepted, _ := x86ResultCallerAddressTest(file.Funcs[0].Instrs[1], &state, nil, "amd64"); accepted || state.flags != 0 {
+		t.Fatal("opaque non-caller participant acquired physical address comparison")
+	}
+}
+
+func TestX86CallerAddressCMPActualABI0Imports(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := x86ResultPointerWord(arch), "MOVQ"
+		widths := []string{"B", "W", "L", "Q"}
+		if arch == "386" {
+			move, widths = "MOVL", widths[:3]
+		}
+		for _, width := range widths {
+			body := fmt.Sprintf("%s x+0(FP),AX\n%s y+%d(FP),BX\nCMP%s AX,BX\nSETEQ DX\nMOVBLZX DX,DX\nMOVL DX,ret0+%d(FP)\nRET", move, move, word, width, 2*word)
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x,y *byte) uint32", body)
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+				t.Error(arch, width, err)
+			}
+			changed, err := Parse(Arch(arch), strings.Replace(source, move+" y+", "MOVB y+", 1))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(changed.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("partial caller pointer field acquired a CMP participant", err)
+			}
+		}
+	}
+}
diff --git a/x86_result_caller_origin.go b/x86_result_caller_origin.go
new file mode 100644
index 000000000..33c90a5d0
--- /dev/null
+++ b/x86_result_caller_origin.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+// A nonzero ID names one actual immutable typed-entry pointer slot. It carries
+// no numerical bytes, extent, alignment, alias or pointee permission. Derived
+// addresses retain that ID only after the existing complete transfer accepts
+// their full-word operation and every numerical affine input.
+func x86ResultCallerOriginsAfter(original Instr, before [16]uint16, after [16]bool,
+	entryFP map[int64]bool, arch string) [16]uint16 {
+	if len(entryFP) == 0 {
+		return [16]uint16{} // A numerical-only entry cannot produce this domain.
+	}
+	next := before
+	for index, address := range after {
+		if !address {
+			next[index] = 0
+		}
+	}
+	ins := x86SourceMoveInstruction(original, arch)
+	if !x86ResultNamedPredicateInstruction(ins) || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		return next
+	}
+	word := x86ResultPointerWord(arch)
+	if form, width, known, err := x86SwapProperties(ins, arch); known && err == nil &&
+		width == word && form.other.Kind == OpReg {
+		first, _, _ := x86ResultGP(form.register.Reg, width, arch)
+		last, _, _ := x86ResultGP(form.other.Reg, width, arch)
+		if after[first] {
+			next[first] = before[last]
+		}
+		if after[last] {
+			next[last] = before[first]
+		}
+		return next
+	}
+	destination, _, valid := x86ResultGP(ins.Args[1].Reg, word, arch)
+	if !valid || !after[destination] {
+		return next
+	}
+	move, lea, add := Op("MOVQ"), Op("LEAQ"), Op("ADDQ")
+	if arch == "386" {
+		move, lea, add = "MOVL", "LEAL", "ADDL"
+	}
+	first := ins.Args[0]
+	switch ins.Op {
+	case move, add:
+		if ins.Op == add && before[destination] != 0 {
+			return next // The ordinary pointer-destination order retains its origin.
+		}
+		next[destination] = 0
+		if first.Kind == OpFP && first.FPOffset >= 0 && first.FPOffset < 4096 && entryFP[first.FPOffset] {
+			next[destination] = uint16(first.FPOffset + 1)
+		} else if first.Kind == OpReg {
+			if source, _, valid := x86ResultGP(first.Reg, word, arch); valid {
+				next[destination] = before[source]
+			}
+		}
+	case lea:
+		next[destination] = 0
+		if first.Kind == OpMem && first.Mem.Sym == "" {
+			if source, _, valid := x86ResultGP(first.Mem.Base, word, arch); valid {
+				next[destination] = before[source]
+			}
+		}
+	}
+	return next
+}
+
+// Subtracting two full-word affine addresses from the same actual entry
+// cancels their common opaque base. No unrelated address or transformed pointer
+// bits become numerical. The normal lowerer retains the original subtraction,
+// including all of its status flags; source instructions are never rewritten.
+func x86ResultCallerAddressDifferenceStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	op := Op("SUBQ")
+	if arch == "386" {
+		op = "SUBL"
+	}
+	if ins.Op != op || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg ||
+		state.shapeOnly && ins.Args[0].Kind != OpFP {
+		return false, false
+	}
+	word := x86ResultPointerWord(arch)
+	destination, _, last := x86ResultGP(ins.Args[1].Reg, word, arch)
+	if !last || !state.shapeOnly && !state.callerAddressGP[destination] {
+		return false, false
+	}
+	var origin uint16
+	switch source := ins.Args[0]; source.Kind {
+	case OpReg:
+		index, _, valid := x86ResultGP(source.Reg, word, arch)
+		if !valid || !state.callerAddressGP[index] {
+			return false, false
+		}
+		origin = state.callerAddressOrigin[index]
+	case OpFP:
+		// Entry parameter slots are immutable in this proof. Only the exact
+		// typed pointer field can cancel its own derived address; adjacent
+		// numeric fields and partial pointer reads cannot borrow that origin.
+		if source.FPOffset >= 0 && source.FPOffset < 4096 && state.callerAddressFP[source.FPOffset] {
+			origin = uint16(source.FPOffset + 1)
+		}
+	default:
+		return false, false
+	}
+	effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+	if !x86ResultNamedPredicateInstruction(ins) || !known || err != nil || effect.dynamicMemory ||
+		origin == 0 || !state.shapeOnly && origin != state.callerAddressOrigin[destination] {
+		return false, true
+	}
+	// The source-wide shape pass checks the exact typed FP field and grammar,
+	// not an origin match. Its state never reaches a CFG edge; every actual
+	// reaching transfer must independently prove the destination's origin.
+	state.gp[destination] = 0xff
+	state.canonicalGP[destination] = 0
+	state.pointerGP[destination], state.callerAddressGP[destination] = false, false
+	state.callerAddressOrigin[destination] = 0
+	state.resultAddressGP[destination] = x86ResultSlotAddress{}
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true
+}
+
+// This is only a cost predicate for requiring the existing complete cached
+// source proof. A pointer declaration or a SUB spelling grants no origin or
+// numerical result. The proof independently checks every actual source path.
+func x86ResultCallerAddressDifferenceNeedsProof(ins Instr, sig FuncSig, arch string) bool {
+	op := Op("SUBQ")
+	if arch == "386" {
+		op = "SUBL"
+	}
+	if ins.Op != op || !x86ResultNamedPredicateInstruction(ins) || len(ins.Args) != 2 ||
+		(ins.Args[0].Kind != OpReg && ins.Args[0].Kind != OpFP) || ins.Args[1].Kind != OpReg {
+		return false
+	}
+	if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err != nil {
+		return false
+	}
+	for _, slot := range sig.Frame.Params {
+		if slot.Type == Ptr && (ins.Args[0].Kind == OpReg || ins.Args[0].FPOffset == slot.Offset) {
+			return true
+		}
+	}
+	return false
+}
diff --git a/x86_result_caller_origin_fp_test.go b/x86_result_caller_origin_fp_test.go
new file mode 100644
index 000000000..206ebc7f1
--- /dev/null
+++ b/x86_result_caller_origin_fp_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultCallerAddressDifferenceOriginalFPSources(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, typ, move, lea, sub := 8, "uint64", "MOVQ", "LEAQ", "SUBQ"
+		if target.arch == "386" {
+			word, typ, move, lea, sub = 4, "uint32", "MOVL", "LEAL", "SUBL"
+		}
+		for _, offset := range []int{0, word} {
+			t.Run(fmt.Sprintf("%s/slot%d", target.triple, offset), func(t *testing.T) {
+				pointer, declaration := "p", "func Value(p,q *byte,n "+typ+") "+typ
+				if offset != 0 {
+					pointer = "q"
+				}
+				body := fmt.Sprintf("%s %s+%d(FP),SI\n%s n+%d(FP),AX\n%s -16(SI)(AX*1),DI\n%s %s+%d(FP),DI\n%s DI,ret+%d(FP)\nRET",
+					move, pointer, offset, move, 2*word, lea, sub, pointer, offset, move, 3*word)
+				_, file, sig, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, ins := range file.Funcs[0].Instrs {
+					if ins.Op == Op(sub) && !x86ResultCallerAddressDifferenceNeedsProof(ins, sig, target.arch) {
+						t.Fatal("direct FP pointer subtraction bypasses the whole-source obligation")
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("same typed origin did not cancel its original FP operand", err)
+						}
+						llc := findLLVM22Tool("llc")
+						if llc == "" {
+							t.Fatal("LLVM22 llc required")
+						}
+						compileLLVMToObject(t, llc, target.triple, "pointer-difference.ll", "pointer-difference.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCallerAddressDifferenceFPBoundary(t *testing.T) {
+	for name, body := range map[string]string{
+		"different pointer":       "SUBQ q+8(FP),SI",
+		"numerical field":         "SUBQ n+16(FP),SI",
+		"partial pointer field":   "SUBQ p+1(FP),SI",
+		"unbound field":           "SUBQ absent+32(FP),SI",
+		"partial destination":     "MOVB $0,SI\nSUBQ p+0(FP),SI",
+		"result is not a pointer": "SUBQ p+0(FP),SI\nMOVQ (SI),SI",
+		"origin is consumed":      "SUBQ p+0(FP),SI\nSUBQ p+0(FP),SI",
+	} {
+		t.Run(name, func(t *testing.T) {
+			declaration := "func Value(p,q *byte,n uint64) uint64"
+			body = "MOVQ p+0(FP),SI\nLEAQ 8(SI),SI\n" + body + "\nMOVQ SI,ret+24(FP)\nRET"
+			_, _, _, source := x86ResultInitializationFixture(t, "amd64", declaration, body)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+				if name == "result is not a pointer" {
+					if err != nil || strings.Count(ir, "load volatile i64,") != 1 {
+						t.Fatal("defined numerical difference lost its paired qword read", err)
+					}
+					x86RequireNumericNativeSourceContext(t, source, declaration, "amd64")
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+				} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("FP subtraction borrowed an unrelated value or memory role", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultCallerAddressDifferenceFPPortableExecution(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	declaration := "func Value(p *byte,n uint64) uint64"
+	body := "MOVQ p+0(FP),SI\nMOVQ n+8(FP),AX\nLEAQ -16(SI)(AX*1),SI\nSUBQ p+0(FP),SI\nMOVQ SI,ret+16(FP)\nRET"
+	_, _, _, source := x86ResultInitializationFixture(t, "amd64", declaration, body)
+	const driver = `#include <stdint.h>
+extern uint64_t Value(uint8_t*, uint64_t);
+int main(void) {
+    uint8_t storage[64] = {0};
+    const uint64_t offsets[] = {0, 1, 15, 16, 17, 31, 48, UINT64_MAX};
+    for (unsigned i = 0; i < sizeof(offsets)/sizeof(offsets[0]); ++i) {
+        if (Value(storage, offsets[i]) != offsets[i]-16) return 1;
+    }
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				execution.compileAndRunLLVM(t, "pointer-difference", input, driver, "-O2")
+			}
+		})
+	}
+}
diff --git a/x86_result_caller_origin_test.go b/x86_result_caller_origin_test.go
new file mode 100644
index 000000000..1c5d9c7c3
--- /dev/null
+++ b/x86_result_caller_origin_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultCallerAddressDifferenceCancelsSameTypedOrigin(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move, lea, add, sub := 8, "uint64", "MOVQ", "LEAQ", "ADDQ", "SUBQ"
+		if arch == "386" {
+			word, typ, move, lea, add, sub = 4, "uint32", "MOVL", "LEAL", "ADDL", "SUBL"
+		}
+		for name, middle := range map[string]string{
+			"copy":                     move + " SI,DI",
+			"constant affine":          lea + " 17(SI),DI",
+			"numerical affine":         lea + " -16(SI)(AX*1),DI",
+			"numerical delta":          move + " SI,DI\n" + add + " AX,DI",
+			"numerical negative delta": move + " SI,DI\n" + sub + " AX,DI",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				body := fmt.Sprintf("%s p+0(FP),SI\n%s n+%d(FP),AX\n%s\n%s SI,DI\n%s DI,ret+%d(FP)\nRET", move, move, word, middle, sub, move, 2*word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p *byte,n "+typ+") "+typ, body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); err != nil {
+						t.Fatal("same actual input origin did not cancel", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCallerAddressDifferenceUnknownOrMixedOriginsRemainContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move, sub := 8, "uint64", "MOVQ", "SUBQ"
+		if arch == "386" {
+			word, typ, move, sub = 4, "uint32", "MOVL", "SUBL"
+		}
+		for name, middle := range map[string]string{
+			"different typed pointer field":               fmt.Sprintf("%s q+%d(FP),DI", move, word),
+			"literal pointer bits":                        move + " $8,DI",
+			"partial overwrite":                           move + " SI,DI\nMOVB $0,DI",
+			"same origin only on one edge":                move + " SI,DI\nCMP" + strings.TrimPrefix(move, "MOV") + " AX,$0\nJZ joined\n" + fmt.Sprintf("%s q+%d(FP),DI\njoined:", move, word),
+			"vector transport is not an address identity": move + " SI,DI\nMOVL DI,X0\nMOVL X0,DI",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				body := fmt.Sprintf("%s p+0(FP),SI\n%s n+%d(FP),AX\n%s\n%s SI,DI\n%s DI,ret+%d(FP)\nRET", move, move, 2*word, middle, sub, move, 3*word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(p,q *byte,n "+typ+") "+typ, body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("pointer bits acquired numerical subtraction", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCallerAddressDifferenceThreeAPIWholeSourceAdmission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move, lea, sub, triple := 8, "uint64", "MOVQ", "LEAQ", "SUBQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, typ, move, lea, sub, triple = 4, "uint32", "MOVL", "LEAL", "SUBL", "i386-unknown-linux-gnu"
+		}
+		declaration := "func Value(p,q *byte,n " + typ + ") " + typ + "\n"
+		for _, sameOrigin := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/same%t", arch, sameOrigin), func(t *testing.T) {
+				middle := fmt.Sprintf("%s q+%d(FP),DI", move, word)
+				if sameOrigin {
+					middle = lea + " -16(SI)(AX*1),DI"
+				}
+				body := fmt.Sprintf("%s p+0(FP),SI\n%s n+%d(FP),AX\n%s\n%s SI,DI\n%s DI,ret+%d(FP)\nRET", move, move, 2*word, middle, sub, move, 3*word)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, strings.TrimSpace(declaration), body)
+				for _, ins := range file.Funcs[0].Instrs {
+					if ins.Op == Op(sub) && !x86ResultCallerAddressDifferenceNeedsProof(ins, sig, arch) {
+						t.Fatal("actual pointer result bypassed the complete-source cost predicate")
+					}
+				}
+				ctx := newX86Ctx(new(strings.Builder), file.Funcs[0], sig,
+					func(symbol string) string { return strings.TrimPrefix(symbol, "·") }, nil, arch, triple, false)
+				proofErr := ctx.checkLoweredScalarFPResultInitialization()
+				if sameOrigin && proofErr != nil || !sameOrigin && !errors.Is(proofErr, ErrProbeNeedsContext) {
+					t.Fatal("paired source proof disagrees with the actual input origins", sameOrigin, proofErr)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if sameOrigin {
+							if err != nil || ir == "" {
+								t.Fatal("same-origin numerical difference rejected", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("unrelated pointer fields bypassed complete result proof", len(ir), err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCallerAddressDifferenceCFGAndRevocation(t *testing.T) {
+	for _, fixture := range []struct {
+		name, body string
+		pass       bool
+	}{
+		{"same origin different offsets", "CMPQ AX,$0\nJZ alternate\nLEAQ 8(SI),DI\nJMP joined\nalternate:\nLEAQ 16(SI),DI\njoined:", true},
+		{"different origin join", "CMPQ AX,$0\nJZ alternate\nLEAQ 8(SI),DI\nJMP joined\nalternate:\nMOVQ q+8(FP),DI\njoined:", false},
+		{"loop preserves only original input", "MOVQ SI,DI\nloop:\nADDQ $1,DI\nSUBQ $1,AX\nJNZ loop", true},
+		{"loop imports another input", "MOVQ SI,DI\nloop:\nMOVQ q+8(FP),DI\nSUBQ $1,AX\nJNZ loop", false},
+		{"partial source overwrite", "MOVQ SI,DI\nMOVB $0,SI", false},
+		{"difference is not an address", "MOVQ SI,DI\nSUBQ SI,DI\nLEAQ 8(DI),DI", false},
+	} {
+		t.Run(fixture.name, func(t *testing.T) {
+			body := "MOVQ p+0(FP),SI\nMOVQ n+16(FP),AX\n" + fixture.body + "\nSUBQ SI,DI\nMOVQ DI,ret+24(FP)\nRET"
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(p,q *byte,n uint64) uint64", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				err := check(file.Funcs[0], sig, "amd64")
+				if fixture.pass && err != nil || !fixture.pass && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("CFG retained a stale or foreign input origin", fixture.pass, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultCallerAddressOriginIsBoundedIndependentMustState(t *testing.T) {
+	state := x86ResultState{}
+	state.callerAddressGP[3], state.callerAddressGP[6] = true, true
+	state.callerAddressOrigin[3], state.callerAddressOrigin[6] = 1, 1
+	other := state.clone()
+	other.callerAddressOrigin[3] = 9
+	if state.callerAddressOrigin[3] != 1 || state.intersect(other).callerAddressOrigin[3] != 0 || state.intersect(state).callerAddressOrigin[3] != 1 {
+		t.Fatal("origin clone or must-intersection aliases another state")
+	}
+	other = state.clone()
+	other.callerAddressGP[3] = false
+	if state.intersect(other).callerAddressOrigin[3] != 0 {
+		t.Fatal("origin survived loss of independently proved address role")
+	}
+	if size := len(state.callerAddressOrigin) * 2; size != 32 {
+		t.Fatal("unbounded or changed origin state payload", size)
+	}
+	ins := x86ScalarLaneInstruction(t, "SUBQ SI,BX")
+	for name, mutate := range map[string]func(*Instr, *x86ResultState){
+		"different origin": func(_ *Instr, s *x86ResultState) { s.callerAddressOrigin[3] = 9 },
+		"missing origin":   func(_ *Instr, s *x86ResultState) { s.callerAddressOrigin[3] = 0 },
+		"encoded effect":   func(i *Instr, _ *x86ResultState) { i.x86Encoded = true },
+		"address override": func(i *Instr, _ *x86ResultState) { i.x86AddressBits = 32 },
+		"segment":          func(i *Instr, _ *x86ResultState) { i.x86SegmentPrefix = 0x64 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			local, next := ins, state.clone()
+			mutate(&local, &next)
+			before := next.clone()
+			accepted, known := x86ResultCallerAddressDifferenceStep(local, &next, "amd64")
+			if accepted || !known || next.callerAddressOrigin != before.callerAddressOrigin || next.gp != before.gp {
+				t.Fatal("rejected origin effect leaked a numerical definition", accepted, known)
+			}
+		})
+	}
+	importPointer := x86ScalarLaneInstruction(t, "MOVQ p+0(FP),SI")
+	var addresses [16]bool
+	addresses[6] = true
+	if ids := x86ResultCallerOriginsAfter(importPointer, [16]uint16{}, addresses, map[int64]bool{0: true}, "amd64"); ids[6] != 1 {
+		t.Fatal("actual zero-offset pointer slot collided with absent origin")
+	}
+	if ids := x86ResultCallerOriginsAfter(importPointer, state.callerAddressOrigin, addresses, nil, "amd64"); ids != [16]uint16{} {
+		t.Fatal("a numerical-only entry invented an actual pointer origin")
+	}
+}
diff --git a/x86_result_carry_control_test.go b/x86_result_carry_control_test.go
new file mode 100644
index 000000000..33d75d3ff
--- /dev/null
+++ b/x86_result_carry_control_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86CarryControlNumericalAvailability(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"CLC", "STC", "CMC"} {
+			for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagsAll &^ x86ByteFlagCF, x86ByteFlagsAll} {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, op, flags), func(t *testing.T) {
+					state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+					state.gp[0] = 0x55
+					before := state.clone()
+					accepted := x86ResultTransfer(x86ScalarLaneInstruction(t, op), &state, nil, 0, arch)
+					if op == "CMC" && flags&x86ByteFlagCF == 0 {
+						if accepted || !reflect.DeepEqual(state, before) {
+							t.Fatal("CMC invented incoming CF or mutated a rejected state")
+						}
+						return
+					}
+					before.flags |= x86ByteFlagCF
+					if !accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("carry control lacks exact CF-only effect", accepted)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86CarryControlLogicalFPResultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		resultOffset := 8
+		if target.arch == "386" {
+			resultOffset = 4
+		}
+		for _, row := range []struct{ name, flags string }{
+			{"clear", "CLC"}, {"set", "STC"}, {"complement", "CLC\nCMC"}, {"unknown", "CMC"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVL x+0(FP),AX\n%s"+
+						"\nMOVL $3,BX\nCMOVLCC BX,AX\nMOVL AX,ret+%d(FP)\nRET\n", resultOffset+4, row.flags, resultOffset)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x float32) uint32", target.arch, target.triple, api)
+					if row.name == "unknown" {
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unknown CF was consumed as an initialized predicate", err)
+						}
+						return
+					}
+					if err != nil || ir == "" {
+						t.Fatal("exact logical FP input and carry control rejected", err)
+					}
+					want := uint64(3)
+					if row.name == "set" || row.name == "complement" {
+						want = 0
+					}
+					probe := "\ndefine i32 @Probe() {\n %r = call i32 @Value(float 0.0)\n ret i32 %r\n}\n"
+					x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{want})
+				})
+			}
+		}
+	}
+}
+
+// The native runtime fixture must use actual scalar result metadata rather
+// than the zero-value aggregate-field index. This all-host translation owner
+// keeps that layout and the complete exchange family testable without x86
+// execution on the development machine.
+func TestX86ExchangeScalarResultPhysicalLayout(t *testing.T) {
+	for _, family := range []string{"XADD", "XCHG", "REVERSE"} {
+		for _, width := range "BWLQ" {
+			t.Run(fmt.Sprintf("%s/%c", family, width), func(t *testing.T) {
+				reg := "AX"
+				if width == 'B' {
+					reg = "AL"
+				}
+				instruction := fmt.Sprintf("%s%c %s,1(BX)", family, width, reg)
+				if family == "REVERSE" {
+					instruction = fmt.Sprintf("XCHG%c 1(BX),%s", width, reg)
+				}
+				source := "TEXT Value(SB),$0-24\nMOVQ p+0(FP),BX\nMOVQ v+8(FP),AX\n" +
+					instruction + "\nMOVQ AX,ret+16(FP)\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Name: "Value", Args: []LLVMType{Ptr, I64}, Ret: I64, Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 8, Type: I64, Index: 1, Field: -1}},
+					Results: []FrameSlot{{Offset: 16, Type: I64, Index: 0, Field: -1}},
+				}}
+				ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", Sigs: map[string]FuncSig{"Value": sig}})
+				if err != nil || ir == "" {
+					t.Fatal("complete exchange scalar result fixture rejected", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_clmul_native.go b/x86_result_clmul_native.go
new file mode 100644
index 000000000..2438c7242
--- /dev/null
+++ b/x86_result_clmul_native.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+// Immediate selector and both data inputs retain one original identity. A
+// numerical lane selector is not a memory footprint or native-entry proof.
+func x86RawCLMULSource(ins Instr, arch string) bool {
+	f, known, err := x86CLMULProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSourceAt(ins, arch, f.source)
+}
+
+// The existing emitter preserves the complete native legacy m128 opcode and
+// its alignment/fault effects, or the full volatile vector tuple without fault
+// suppression. This conditional result grants no backing or reusable read fact;
+// unknown selected register qwords still propagate unknown numerical outputs.
+func x86LoweredCLMULStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	f, known, err := x86CLMULProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawCLMULSource(ins, arch) {
+			return false, true
+		}
+		// Physical mode32 has four operands even though its named frontend
+		// does not. Retain that captured form rather than reparsing locally.
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	return x86ResultCLMULTransfer(local, f, state, owned, arch, true)
+}
diff --git a/x86_result_cmov_native.go b/x86_result_cmov_native.go
new file mode 100644
index 000000000..a4e5d3322
--- /dev/null
+++ b/x86_result_cmov_native.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+// The existing complete CMOV grammar supplies widths and exact predicate
+// dependencies. Its paired lowerer always emits the full volatile read,
+// including false predicates and dead outputs. Continuing past that access
+// produces NUM, not backing, bounds, pointer or native-entry authority.
+func x86RawCMOVSource(ins Instr, arch string) bool {
+	_, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86LoweredCMOVResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ConditionalMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	named := x86ResultNamedPredicateInstruction(ins)
+	if named && form.source.Kind != OpMem {
+		return false, false // The existing strict transfer owns named register data.
+	}
+	if !named {
+		if !x86RawCMOVSource(ins, arch) {
+			return false, true
+		}
+		// Project only this authenticated operation, never its original file
+		// or caller/source-stack metadata. Raw entry and memory stay separate.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if form.source.Kind != OpReg && (form.source.Kind != OpMem || form.source.Mem.Sym != "" ||
+		!x86OrdinaryNativeMemoryOperand(form.source, arch)) {
+		return false, false // Logical fields and independently bound sources keep their own consumers.
+	}
+	width := int64(form.bits / 8)
+	required := x86ByteConditionFlags(form.condition)
+	destination, _, valid := x86ResultGP(form.destination.Reg, width, arch)
+	if !valid || state.pointerGP[destination] || !x86ResultNamedPredicateInstruction(ins) ||
+		required == 0 || state.flags&required != required ||
+		!x86ResultRead(form.destination, width, state, owned, arch) ||
+		!x86ResultReadWithNativeContinuation(ins, form.source, width, state, owned, arch, true) {
+		return false, true
+	}
+	if form.source.Kind == OpReg {
+		source, _, valid := x86ResultGP(form.source.Reg, width, arch)
+		if !valid || state.pointerGP[source] {
+			return false, true
+		}
+	}
+	return x86ResultStore(form.destination, width, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_cmov_native_test.go b/x86_result_cmov_native_test.go
new file mode 100644
index 000000000..d49b928ef
--- /dev/null
+++ b/x86_result_cmov_native_test.go
@@ -0,0 +1,179 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86CMOVNativeExactByteFlagsAndSourceState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range x86CMOVOracleNames(arch) {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, name+" -1(SI)(BX*2),AX")
+				width := map[byte]int64{'W': 2, 'L': 4, 'Q': 8}[name[4]]
+				required := uint8(0)
+				for _, row := range x86CMOVOracleConditions {
+					if name[5:] == row.name {
+						required = row.flags
+					}
+				}
+				if required == 0 {
+					t.Fatal("independent condition inventory lost a predicate")
+				}
+				seed := func() x86ResultState {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[3], state.pointerGP[6] = 0xff, 0xff, true
+					return state
+				}
+				check := func(changed Instr, state x86ResultState, want bool) {
+					t.Helper()
+					before := state.clone()
+					accepted, known := x86LoweredCMOVResultStep(changed, &state, nil, 0, arch)
+					if accepted != want || !known || !reflect.DeepEqual(state, before) {
+						t.Fatal("native CMOV changed an unrelated byte, FLAGS, address or failed state", accepted, want, known)
+					}
+					if x86ResultTransfer(changed, &before, nil, 0, arch) {
+						t.Fatal("standalone result observer borrowed a paired native read")
+					}
+				}
+				for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+					state := seed()
+					state.flags = flags
+					check(ins, state, flags&required == required)
+				}
+				for missing := int64(0); missing < 8; missing++ {
+					state := seed()
+					state.gp[0] &^= 1 << uint(missing)
+					// A successful L write independently clears the upper half.
+					if width == 4 && missing >= 4 {
+						if accepted, known := x86LoweredCMOVResultStep(ins, &state, nil, 0, arch); !known || !accepted || state.gp[0] != 0xff {
+							t.Fatal("dword CMOV failed to zero-extend even on a false predicate")
+						}
+						continue
+					}
+					check(ins, state, missing >= width)
+				}
+				for _, origin := range []string{"raw", "decoded", "raw-return", "address-size", "unbound-address", "segment", "pointer-destination"} {
+					changed, state := ins, seed()
+					switch origin {
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "decoded":
+						changed.x86Encoded = true
+					case "raw-return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address-size":
+						changed.x86AddressBits = 32
+					case "unbound-address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "pointer-destination":
+						state.pointerGP[0] = true
+					}
+					check(changed, state, false)
+				}
+			})
+		}
+	}
+}
+
+// The original initialized CMOV producer is shared with official byte rows.
+// A different destination only selects a nonaliasing FLAGS observation scratch;
+// it grants no predicate, pointer or source-memory permission.
+func x86ConditionalMoveInitializedFunction(name, operation, destination, arch string) (string, string) {
+	word, suffix := goWordSize(arch), "Q"
+	if word == 4 {
+		suffix = "L"
+	}
+	scratch := "BX"
+	if destination == scratch {
+		scratch = "DX"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\nMOV%s p+0(FP),SI\n"+
+		"MOV%s old+%d(FP),%s\nMOV%s out+%d(FP),DI\nMOV%s $11,CX\nPUSH%s flags+%d(FP)\nPOPF%s\n%s\n"+
+		"PUSHF%s\nPOP%s %s\nMOV%s %s,(DI)\nMOV%s %s,ret+%d(FP)\nRET\n", name, 5*word, suffix,
+		suffix, word, destination, suffix, 3*word, suffix, suffix, 2*word, suffix, operation, suffix, suffix, scratch, suffix, scratch, suffix, destination, 4*word)
+	declaration := fmt.Sprintf("func %s(p *byte,old,flags uintptr,out *uintptr) uintptr\n", name)
+	return source, declaration
+}
+
+func TestX86CMOVNativeCompleteFamilyFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word := goWordSize(target.arch)
+			for _, raw := range []bool{false, true} {
+				var source, declarations strings.Builder
+				count := 0
+				for _, name := range x86CMOVOracleNames(target.arch) {
+					for _, operand := range []string{"(SI)", "CX"} {
+						operation := name + " " + operand + ",AX"
+						if raw {
+							operation = x86RawNumericalInstruction(t, target.arch, operation)
+						}
+						function := fmt.Sprint("ConditionalRead", count)
+						body, declaration := x86ConditionalMoveInitializedFunction(function, operation, "AX", target.arch)
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+						count++
+					}
+				}
+				want := 96
+				if word == 4 {
+					want = 64
+				}
+				if count != want {
+					t.Fatal("complete conditional register/memory data inventory changed", count)
+				}
+				x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+			}
+		})
+	}
+}
+
+func TestX86CMOVNativeCannotInventPotentialInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix := goWordSize(target.arch), "Q"
+		if word == 4 {
+			suffix = "L"
+		}
+		for _, name := range x86CMOVOracleNames(target.arch) {
+			for _, role := range []string{"unknown-pointer", "numerical-pointer", "unknown-old", "unknown-flags", "unknown-index"} {
+				setup := fmt.Sprintf("MOV%s p+0(FP),SI\nMOV%s old+%d(FP),AX\n"+
+					"PUSH%s flags+%d(FP)\nPOPF%s\n", suffix, suffix, word, suffix, 2*word, suffix)
+				memory := "(SI)"
+				switch role {
+				case "unknown-pointer":
+					setup = strings.Replace(setup, fmt.Sprintf("MOV%s p+0(FP),SI\n", suffix), "", 1)
+				case "numerical-pointer":
+					setup = strings.Replace(setup, "p+0(FP)", fmt.Sprintf("old+%d(FP)", word), 1)
+				case "unknown-old":
+					setup = strings.Replace(setup, fmt.Sprintf("MOV%s old+%d(FP),AX\n", suffix, word), "", 1)
+				case "unknown-flags":
+					setup = strings.Replace(setup, fmt.Sprintf("PUSH%s flags+%d(FP)\nPOPF%s\n", suffix, 2*word, suffix), "", 1)
+				case "unknown-index":
+					memory = "(SI)(BX*2)"
+				}
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s %s,AX\nRET\n", 3*word, setup, name, memory)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,old,flags uintptr)", target.arch, target.triple, api)
+					if role == "numerical-pointer" {
+						x86RequireNumericNativeSourceContext(t, source, "func Value(p *byte,old,flags uintptr)", target.arch)
+						goAssemblerOracleOutput(t, target.arch, source, "", true)
+						width := map[byte]int{'W': 2, 'L': 4, 'Q': 8}[name[4]]
+						if err != nil || !strings.Contains(ir, fmt.Sprintf("load volatile <%d x i8>", width)) ||
+							!strings.Contains(ir, "asm sideeffect \"\", \"r\"") {
+							t.Fatal("numerical address lost CMOV's unconditional exact-width read", name, target.triple, api, err)
+						}
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native CMOV invented a potential input, including for Void", name, role, target.triple, api, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_commuted_pointer_add_runtime_linux_amd64_test.go b/x86_result_commuted_pointer_add_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..b45d54cd6
--- /dev/null
+++ b/x86_result_commuted_pointer_add_runtime_linux_amd64_test.go
@@ -0,0 +1,13 @@
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86IncomingPointerCommutedAdd(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	// Reuse the original Go instruction-byte adapter and independent C pointer
+	// arithmetic oracle, including wrapped offsets and register/arena canaries.
+	x86CallerAddressRuntime(t, []x86CallerAddressRuntimeRow{
+		{"ADDQ AX,BX\nMOVQ BX,AX\nTESTQ $-1,AX\nSETMI AX", "a+b", "v", 64, 9},
+		{"ADDQ AX,BX\nMOVQ BX,AX\nTESTQ $-1,AX\nSETEQ AX", "a+b", "v", 64, 2},
+	})
+}
diff --git a/x86_result_commuted_pointer_add_test.go b/x86_result_commuted_pointer_add_test.go
new file mode 100644
index 000000000..9e55753aa
--- /dev/null
+++ b/x86_result_commuted_pointer_add_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86CommutedPointerAddRegisters(arch string) []Reg {
+	registers := []Reg{AX, CX, DX, BX, SI, DI}
+	if arch == "386" {
+		return append(registers, BP)
+	}
+	return append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+}
+
+func TestX86IncomingPointerCommutedAddRegistersAndRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, suffix := x86ResultPointerWord(arch), "Q"
+		if arch == "386" {
+			suffix = "L"
+		}
+		var original strings.Builder
+		for _, source := range x86CommutedPointerAddRegisters(arch) {
+			for _, destination := range x86CommutedPointerAddRegisters(arch) {
+				fmt.Fprintf(&original, "ADD%s %s,%s\n", suffix, source, destination)
+			}
+		}
+		requireX86GoAssemblerResult(t, arch, "TEXT ·Value(SB),4,$0-0\n"+original.String()+"RET\n", true)
+		for _, source := range x86CommutedPointerAddRegisters(arch) {
+			for _, destination := range x86CommutedPointerAddRegisters(arch) {
+				if source == destination {
+					continue // A pointer cannot simultaneously supply the NUM operand.
+				}
+				for _, commuted := range []bool{false, true} {
+					for _, caller := range []bool{false, true} {
+						name := fmt.Sprintf("%s/%s-%s/commuted%t/caller%t", arch, source, destination, commuted, caller)
+						t.Run(name, func(t *testing.T) {
+							ins := x86ScalarLaneInstruction(t, "ADD"+suffix+" "+string(source)+","+string(destination))
+							first, _, _ := x86ResultGP(source, word, arch)
+							last, mask, _ := x86ResultGP(destination, word, arch)
+							pointer, number := last, first
+							if commuted {
+								pointer, number = first, last
+							}
+							state := x86ResultState{direction: x86ResultDirectionBackward}
+							state.gp[number] = mask
+							state.canonicalGP[number] = 1
+							state.pointerGP[pointer], state.callerAddressGP[pointer] = true, caller
+							if caller {
+								state.callerAddressOrigin[pointer] = 1
+							}
+							before, want := state.clone(), state.clone()
+							want.pointerGP[last], want.gp[last] = true, 0
+							want.canonicalGP[last] = 0
+							want.callerAddressGP[last], want.callerAddressOrigin[last] = caller, want.callerAddressOrigin[pointer]
+							want.flags = x86ByteFlagsAll
+							if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+								t.Fatal("full-word pointer/NUM addition rejected", ins.Raw)
+							}
+							state.callerAddressGP = x86ResultCallerAddressesAfterTransfer(ins, before.callerAddressGP, state.callerAddressGP, nil, arch)
+							state.callerAddressOrigin = x86ResultCallerOriginsAfter(ins, before.callerAddressOrigin, state.callerAddressGP, map[int64]bool{0: true}, arch)
+							if !reflect.DeepEqual(state, want) {
+								t.Fatal("addition changed NUM, source, caller origin, flags or DF outside its typed footprint", state, want)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86CommutedPointerAddBodies(arch string) []struct{ name, body string } {
+	word, suffix := x86ResultPointerWord(arch), "Q"
+	if arch == "386" {
+		suffix = "L"
+	}
+	load := fmt.Sprintf("MOV%s p+0(FP),SI\nMOV%s n+%d(FP),DX\n", suffix, suffix, word)
+	rows := []struct{ name, body string }{
+		{"commuted register", load + "ADD" + suffix + " SI,DX\n"},
+		{"commuted parameter", fmt.Sprintf("MOV%s n+%d(FP),DX\nADD%s p+0(FP),DX\n", suffix, word, suffix)},
+		{"ordinary register", load + "ADD" + suffix + " DX,SI\nMOV" + suffix + " SI,DX\n"},
+		{"ordinary parameter", "MOV" + suffix + " p+0(FP),DX\n" + fmt.Sprintf("ADD%s n+%d(FP),DX\n", suffix, word)},
+		{"same origin join", load + "CMP" + suffix + " DX,$0\nJE alternate\nADD" + suffix + " SI,DX\nJMP joined\nalternate:\nLEA" + suffix + " (SI)(DX*1),DX\njoined:\n"},
+	}
+	for index := range rows {
+		rows[index].body += fmt.Sprintf("SUB%s p+0(FP),DX\nMOV%s DX,ret+%d(FP)\nRET", suffix, suffix, 2*word)
+	}
+	return rows
+}
+
+func TestX86IncomingPointerCommutedAddWholeSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86CommutedPointerAddBodies(arch) {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p *byte,n uintptr) uintptr", row.body)
+				requireX86GoAssemblerResult(t, arch, source, true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); err != nil {
+						t.Fatal("complete same-origin commuted address did not cancel", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86IncomingPointerCommutedAddFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			assembly, declarations := x86CommutedPointerAddProgram(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != 5 {
+						t.Fatal("complete original pointer-add inventory rejected", err)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O0")
+					x86PackedStringCompileObject(t, llc, target.triple, x86MulDivRoundOptimize(t, ir), "-O2")
+				})
+			}
+		})
+	}
+}
+
+func x86CommutedPointerAddProgram(t *testing.T, arch string) (string, string) {
+	t.Helper()
+	var assembly, declarations strings.Builder
+	for index, row := range x86CommutedPointerAddBodies(arch) {
+		_, _, _, source := x86ResultInitializationFixture(t, arch, "func Value(p *byte,n uintptr) uintptr", row.body)
+		name := fmt.Sprintf("Value%d", index)
+		assembly.WriteString(strings.Replace(source, "·Value", "·"+name, 1))
+		fmt.Fprintf(&declarations, "func %s(p *byte,n uintptr) uintptr\n", name)
+	}
+	return assembly.String(), declarations.String()
+}
+
+func TestX86IncomingPointerCommutedAddPortableExecution(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	assembly, declarations := x86CommutedPointerAddProgram(t, "amd64")
+	const driver = `#include <stdint.h>
+extern uint64_t Value0(uint8_t*, uint64_t), Value1(uint8_t*, uint64_t);
+extern uint64_t Value2(uint8_t*, uint64_t), Value3(uint8_t*, uint64_t);
+extern uint64_t Value4(uint8_t*, uint64_t);
+int main(void) {
+    uint8_t storage[64] = {0};
+    uint64_t (*functions[])(uint8_t*, uint64_t) = {Value0, Value1, Value2, Value3, Value4};
+    const uint64_t offsets[] = {0, 1, 63, 64, 65, UINT64_MAX, UINT64_C(1)<<63};
+    for (unsigned fn=0; fn<5; fn++)
+        for (unsigned sample=0; sample<7; sample++)
+            if (functions[fn](storage, offsets[sample]) != offsets[sample]) return 1;
+    for (unsigned i=0; i<sizeof storage; i++) if (storage[i]) return 2;
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, declarations, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			execution.compileAndRunLLVM(t, "commuted-pointer-add", ir, driver, "-O0")
+			execution.compileAndRunLLVM(t, "commuted-pointer-add", x86MulDivRoundOptimize(t, ir), driver, "-O2")
+		})
+	}
+}
+
+func TestX86IncomingPointerCommutedAddBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, suffix := x86ResultPointerWord(arch), "uint64", "Q"
+		if arch == "386" {
+			typ, suffix = "uint32", "L"
+		}
+		for _, row := range []struct{ name, body string }{
+			{"two pointers", "MOV" + suffix + " SI,DX\nADD" + suffix + " SI,DX\n"},
+			{"same pointer alias", "ADD" + suffix + " SI,SI\n"},
+			{"partial add", "ADDW SI,DX\n"},
+			{"reversed subtract", "SUB" + suffix + " SI,DX\n"},
+			{"unknown offset", "ADD" + suffix + " SI,CX\n"},
+			{"pointer as NUM", "ADD" + suffix + " SI,DX\nMOV" + suffix + " DX,ret+RESULT(FP)\nRET\n"},
+			{"unproved pointee", "ADD" + suffix + " SI,DX\nMOVL (DX),AX\n"},
+			{"partial pointer overwrite", "MOVW $0,SI\nADD" + suffix + " SI,DX\n"},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				body := fmt.Sprintf("MOV%s p+0(FP),SI\nMOV%s n+%d(FP),DX\n", suffix, suffix, word) + row.body
+				body += fmt.Sprintf("MOV%s $0,ret+%d(FP)\nRET", suffix, 2*word)
+				body = strings.ReplaceAll(body, "RESULT", fmt.Sprint(2*word))
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p *byte,n "+typ+") "+typ, body)
+				requireX86GoAssemblerResult(t, arch, source, true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("commuted addition granted another pointer or NUM contract", err)
+				}
+			})
+		}
+		for missing := int64(0); missing < word; missing++ {
+			t.Run(fmt.Sprintf("%s/missing-offset-byte-%d", arch, missing), func(t *testing.T) {
+				state := x86ResultState{pointerGP: [16]bool{6: true}, callerAddressGP: [16]bool{6: true}}
+				state.gp[2] = uint8((1<<uint(word))-1) &^ (1 << uint(missing))
+				before := state.clone()
+				ins := x86ScalarLaneInstruction(t, "ADD"+suffix+" SI,DX")
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(before, state) {
+					t.Fatal("missing NUM input published an address or flags")
+				}
+			})
+		}
+		for _, row := range []struct {
+			name   string
+			mutate func(*Instr)
+		}{
+			{"encoded", func(ins *Instr) { ins.x86Encoded = true }},
+			{"address override", func(ins *Instr) { ins.x86AddressBits = 32 }},
+			{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				state := x86ResultState{pointerGP: [16]bool{6: true}, callerAddressGP: [16]bool{6: true}, gp: [16]uint8{2: 0xff}}
+				before := state.clone()
+				ins := x86ScalarLaneInstruction(t, "ADD"+suffix+" SI,DX")
+				row.mutate(&ins)
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(before, state) {
+					t.Fatal("named address addition borrowed an independent encoding contract")
+				}
+			})
+		}
+		t.Run(arch+"/different typed origin join", func(t *testing.T) {
+			body := fmt.Sprintf("MOV%s p+0(FP),SI\nMOV%s n+%d(FP),DX\nCMP%s DX,$0\nJE alternate\n"+
+				"ADD%s SI,DX\nJMP joined\nalternate:\nADD%s q+%d(FP),DX\njoined:\n"+
+				"SUB%s p+0(FP),DX\nMOV%s DX,ret+%d(FP)\nRET", suffix, suffix, 2*word, suffix,
+				suffix, suffix, word, suffix, suffix, 3*word)
+			_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p,q *byte,n "+typ+") "+typ, body)
+			requireX86GoAssemblerResult(t, arch, source, true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("different commuted pointer origins survived a must-join", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_commuted_pointer_read_objects_test.go b/x86_result_commuted_pointer_read_objects_test.go
new file mode 100644
index 000000000..e7c7ad22c
--- /dev/null
+++ b/x86_result_commuted_pointer_read_objects_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These literal ModRM/SIB observations are independent of the address-role
+// parser. They establish original Go encodings, not pointer bounds or execution.
+func TestX86IncomingPointerCommutedReadOriginalGoBytes(t *testing.T) {
+	for _, row := range []struct {
+		arch, instruction string
+		want              []byte
+	}{
+		{"amd64", "MOVB -8(BX)(AX*1),CX", []byte{0x8a, 0x4c, 0x03, 0xf8, 0xc3}},
+		{"amd64", "MOVB -8(AX)(BX*1),CX", []byte{0x8a, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVW -8(BX)(AX*1),CX", []byte{0x66, 0x8b, 0x4c, 0x03, 0xf8, 0xc3}},
+		{"amd64", "MOVW -8(AX)(BX*1),CX", []byte{0x66, 0x8b, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVL -8(BX)(AX*1),CX", []byte{0x8b, 0x4c, 0x03, 0xf8, 0xc3}},
+		{"amd64", "MOVL -8(AX)(BX*1),CX", []byte{0x8b, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVQ -8(BX)(AX*1),CX", []byte{0x48, 0x8b, 0x4c, 0x03, 0xf8, 0xc3}},
+		{"amd64", "MOVQ -8(AX)(BX*1),CX", []byte{0x48, 0x8b, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVL -8(AX)(BX*1),AX", []byte{0x8b, 0x44, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVL -8(AX)(BX*1),BX", []byte{0x8b, 0x5c, 0x18, 0xf8, 0xc3}},
+		{"amd64", "MOVD -8(AX)(BX*1),BX", []byte{0x48, 0x8b, 0x5c, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVB -8(AX)(BX*1),CX", []byte{0x8a, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVW -8(AX)(BX*1),CX", []byte{0x66, 0x8b, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVL -8(AX)(BX*1),CX", []byte{0x8b, 0x4c, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVL -8(BX)(AX*1),CX", []byte{0x8b, 0x4c, 0x03, 0xf8, 0xc3}},
+		{"386", "MOVL -8(AX)(BX*1),AX", []byte{0x8b, 0x44, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVL -8(AX)(BX*1),BX", []byte{0x8b, 0x5c, 0x18, 0xf8, 0xc3}},
+		{"386", "MOVL -8(AX)(BP*1),CX", []byte{0x8b, 0x4c, 0x28, 0xf8, 0xc3}},
+	} {
+		t.Run(row.arch+"/"+row.instruction, func(t *testing.T) {
+			source := "TEXT original(SB),4,$0-0\n" + row.instruction + "\nRET\n"
+			if actual := x86OrderingHintGoBytes(t, row.arch, source); !bytes.Equal(actual, row.want) {
+				t.Fatalf("original Go bytes = %x, independent SIB/alias bytes = %x", actual, row.want)
+			}
+		})
+	}
+	t.Run("386/Go-invalid-GP-qword", func(t *testing.T) {
+		// The memory-to-X m64 row is independent; this is the GP-only row
+		// that Go restricts to mode64, not another admitted mode32 format.
+		requireLEANativeGoObject(t, "386", "TEXT invalid(SB),4,$0-0\nMOVQ -8(AX)(BX*1),CX\nRET\n", false)
+	})
+}
+
+func TestX86IncomingPointerCommutedReadFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, nativeMove := goWordSize(target.arch), "MOVQ"
+			if target.arch == "386" {
+				nativeMove = "MOVL"
+			}
+			// Complete this bounded read/alias matrix once per target. The
+			// independent byte oracle above does not derive its expected bytes
+			// from these rows, nor from the production address parser.
+			type moveRow struct {
+				op, store, result string
+				width             int
+			}
+			rows := []moveRow{
+				{"MOVB", "MOVB", "uint8", 1},
+				{"MOVW", "MOVW", "uint16", 2},
+				{"MOVL", "MOVL", "uint32", 4},
+			}
+			if target.arch == "amd64" {
+				rows = append(rows,
+					moveRow{"MOVQ", "MOVQ", "uint64", 8},
+					moveRow{"MOVD", "MOVQ", "uint64", 8},
+				)
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range rows {
+				for order, address := range []string{"-8(BX)(AX*1)", "-8(AX)(BX*1)"} {
+					for _, destination := range []string{"AX", "BX", "CX"} {
+						name := fmt.Sprintf("Read%sOrder%dTo%s", row.op, order, destination)
+						fmt.Fprintf(&declarations, "func %s(p *byte,n uintptr) %s\n", name, row.result)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),BX\n%s n+%d(FP),AX\n%s %s,%s\n%s %s,ret+%d(FP)\nRET\n",
+							name, 2*word+row.width, nativeMove, nativeMove, word,
+							row.op, address, destination, row.store, destination, 2*word)
+						count++
+					}
+				}
+			}
+			want := 30
+			if target.arch == "386" {
+				want = 18
+			}
+			if count != want || strings.Count(source.String(), "TEXT ") != want {
+				t.Fatal("complete original source/alias denominator changed", count, want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != want {
+						t.Fatal("complete declared read/alias source failed", err)
+					}
+					for _, row := range rows {
+						reads := 6
+						if row.width == 8 {
+							reads = 12 // MOVQ and its complete original MOVD alias.
+						}
+						if strings.Count(ir, fmt.Sprintf("load volatile i%d,", 8*row.width)) != reads {
+							t.Fatal("native read lost exact width/volatile semantics", row.op)
+						}
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input, label := ir, "IR-original"
+						if optimizeIR {
+							input, label = x86MulDivRoundOptimize(t, ir), "IR-O2"
+						}
+						for _, backend := range []string{"-O0", "-O2"} {
+							t.Run(label+"/backend"+backend, func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, backend)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_commuted_pointer_read_test.go b/x86_result_commuted_pointer_read_test.go
new file mode 100644
index 000000000..278974d2d
--- /dev/null
+++ b/x86_result_commuted_pointer_read_test.go
@@ -0,0 +1,159 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86IncomingPointerCommutedReadThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		entry := fmt.Sprintf("%s p+0(FP),BX\n%s n+%d(FP),AX\n", move, move, word)
+		type addressCase struct {
+			name, setup, address string
+			accept               bool
+		}
+		rows := []addressCase{
+			{"pointer-base", entry, "-8(BX)(AX*1)", true},
+			{"pointer-base-scaled-number", entry, "-8(BX)(AX*4)", true},
+			{"pointer-index", entry, "-8(AX)(BX*1)", true},
+			{"pointer-index-result-alias", entry, "-8(AX)(BX*1)", true},
+			{"unknown-number", move + " p+0(FP),BX\n", "-8(AX)(BX*1)", false},
+			{"unknown-pointer", fmt.Sprintf("%s n+%d(FP),AX\n", move, word), "-8(AX)(BX*1)", false},
+			{"two-pointers", entry + move + " BX,AX\n", "-8(AX)(BX*1)", false},
+			{"two-numbers", entry + move + " $64,BX\n", "-8(AX)(BX*1)", true},
+			{"scaled-pointer-two", entry, "-8(AX)(BX*2)", false},
+			{"scaled-pointer-four", entry, "-8(AX)(BX*4)", false},
+			{"scaled-pointer-eight", entry, "-8(AX)(BX*8)", false},
+			{"partial-pointer", entry + "MOVB $0,BX\n", "-8(AX)(BX*1)", false},
+			{"same-pointer-twice", entry, "-8(BX)(BX*1)", false},
+			{"loaded-number-is-not-pointer", entry + "MOVL -8(AX)(BX*1),BX\n", "(BX)", true},
+			{"mixed-pointer-number-join", entry + "CMPL AX,$0\nJE joined\nMOVL $64,BX\njoined:\n", "-8(AX)(BX*1)", false},
+			{"unbound-frame-index", entry, "-8(AX)(SP*1)", false},
+		}
+		if target.arch == "amd64" {
+			rows = append(rows, addressCase{"unbound-frame-base", entry, "-8(BP)(BX*1)", false})
+		} else {
+			rows = append(rows, addressCase{"ordinary-mode32-BP-index", entry + "MOVL BX,BP\n", "-8(AX)(BP*1)", true})
+		}
+		for _, row := range rows {
+			destination := "CX"
+			if row.name == "pointer-index-result-alias" {
+				destination = "BX"
+			}
+			body := row.setup + "MOVL " + row.address + "," + destination + "\n" +
+				fmt.Sprintf("MOVL %s,ret+%d(FP)\nRET", destination, 2*word)
+			declaration := "func Value(p *uint32,n uintptr) uint32"
+			_, file, sig, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+			// Neither address order supplies a standalone memory/result query
+			// with the paired original volatile-load continuation.
+			for _, query := range []func(Func, FuncSig, string) error{
+				CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+			} {
+				if err := query(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("address spelling manufactured a standalone native read", row.name, err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if row.accept {
+						if err != nil || !strings.Contains(ir, "load volatile i32,") {
+							t.Fatal("typed pointer/NUM address lost its exact paired read", err)
+						}
+					} else if err == nil || ir != "" {
+						t.Fatalf("unbound/scaled/nonnumeric address accepted: output=%t error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86IncomingPointerCommutedReadRolesAndOriginalIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := x86ResultPointerWord(arch)
+		base, numericMask, _ := x86ResultGP(AX, word, arch)
+		pointer, _, _ := x86ResultGP(BX, word, arch)
+		for _, row := range []struct {
+			name, address                                string
+			basePointer, indexPointer, baseNUM, indexNUM bool
+			accept                                       bool
+		}{
+			{"original-order", "-8(AX)(BX*4)", true, false, false, true, true},
+			{"commuted-order", "-8(AX)(BX*1)", false, true, true, false, true},
+			{"unknown-base", "-8(AX)(BX*1)", false, true, false, false, false},
+			{"unknown-index", "-8(AX)(BX*1)", false, false, true, false, false},
+			{"two-pointers", "-8(AX)(BX*1)", true, true, false, false, false},
+			{"two-numbers", "-8(AX)(BX*1)", false, false, true, true, true},
+			{"scaled-pointer", "-8(AX)(BX*2)", false, true, true, false, false},
+			{"same-pointer", "-8(BX)(BX*1)", false, true, true, false, false},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+				state.pointerGP[base], state.pointerGP[pointer] = row.basePointer, row.indexPointer
+				if row.baseNUM {
+					state.gp[base] = numericMask
+				}
+				if row.indexNUM {
+					state.gp[pointer] = numericMask
+				}
+				ins := x86ScalarLaneInstruction(t, "MOVL "+row.address+",CX")
+				before := state.clone()
+				if row.name == "commuted-order" {
+					if x86ResultIncomingPointerAddressIdentity(ins.Args[0], &state, arch) {
+						t.Fatal("paired read widened the independent store/RMW address role")
+					}
+					lea := "LEAQ"
+					if arch == "386" {
+						lea = "LEAL"
+					}
+					address := x86ScalarLaneInstruction(t, lea+" "+row.address+",CX")
+					if accepted, _ := x86ResultIncomingPointerTransfer(address, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("paired read created an independent commuted LEA pointer")
+					}
+				}
+				if accepted, known := x86LoweredScalarNativeLoad(ins, &state, nil, 0, arch); !known || accepted != row.accept {
+					t.Fatal("paired load disagrees with the independent address roles", accepted, known)
+				}
+				if !row.accept && !reflect.DeepEqual(state, before) {
+					t.Fatal("rejected address changed result state")
+				}
+				if state.flags != before.flags || state.direction != before.direction {
+					t.Fatal("address permutation changed FLAGS/DF")
+				}
+			})
+		}
+		for _, origin := range []string{"decoded", "raw", "raw-return", "address-size", "unbound-address", "segment"} {
+			t.Run(arch+"/"+origin, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "MOVL -8(AX)(BX*1),CX")
+				switch origin {
+				case "decoded":
+					ins.x86Encoded = true
+				case "raw":
+					ins.x86SourceRaw = new(x86SourceRawInstruction)
+				case "raw-return":
+					ins.x86RawNearReturn = new(x86RawNearReturnForm)
+				case "address-size":
+					ins.x86AddressBits = 32
+				case "unbound-address":
+					ins.x86UnboundAddressOverride = true
+				case "segment":
+					ins.x86SegmentPrefix = 0x64
+				}
+				state := x86ResultState{}
+				state.gp[base], state.pointerGP[pointer] = numericMask, true
+				before := state.clone()
+				if accepted, _ := x86LoweredScalarNativeLoad(ins, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("commuted operand borrowed an unbound physical-source role")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_compact_expand.go b/x86_result_compact_expand.go
new file mode 100644
index 000000000..bec8b9d64
--- /dev/null
+++ b/x86_result_compact_expand.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+func x86RawCompactSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedCompactProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86RawOrdinaryVectorSource(ins, arch) {
+		return false
+	}
+	// Compression's memory is its destination, not the first data operand.
+	// Check that role as well: exact bytes grant neither RIP/static backing
+	// nor a segment, frame or nondefault-address continuation.
+	return form.memory < 0 || x86RawOrdinaryVectorSourceAt(ins, arch, form.memory)
+}
+
+// Unknown mask values can select any source lane and any merge byte. Require
+// the complete source and, for merging, the complete old destination. A mask's
+// definedness is not a constant-value or memory-access certificate.
+func x86ResultCompactExpandStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	return x86ResultCompactExpandMemoryStep(ins, state, owned, resultOffset, arch, false)
+}
+
+func x86ResultCompactExpandMemoryStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, pairedNative bool) (bool, bool) {
+	form, known, err := x86PackedCompactProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || form.undefinedOpcode() {
+		return false, true
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !pairedNative || !x86RawCompactSource(ins, arch) {
+			return false, true
+		}
+		// Consume only this instruction's exact original identity. Preserve
+		// the validated physical form; no standalone query gains this view.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	required := x86CallerVectorByteMask(int64(form.byteWidth))
+	for index, operand := range ins.Args {
+		if operand.Kind != OpReg || index == form.mask {
+			continue
+		}
+		register, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		if !valid || arch == "386" && register >= 8 {
+			return false, true // Accepted high-bank syntax is not a physical mode32 value input.
+		}
+		if index == 0 || form.mask >= 0 && !form.zeroing {
+			if state.vectorBytes(register)&required != required {
+				return false, true
+			}
+		}
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	if form.memory >= 0 {
+		memory := ins.Args[form.memory]
+		native := pairedNative && x86OrdinaryNativeMemoryOperand(memory, arch) &&
+			x86ResultIncomingPointerAddressIdentity(memory, state, arch)
+		// Logical FP/AUTO bytes and bound DATA reads are not native backing
+		// or permission to dereference an incoming pointer.
+		if !native && (form.expand || form.mask >= 0) && !x86ResultRead(memory, int64(form.byteWidth), state, owned, arch) {
+			return false, true
+		}
+		if !form.expand {
+			if native {
+				return true, true // Only the emitted compact prefix changes; no reusable memory facts.
+			}
+			return x86ResultStore(memory, int64(form.byteWidth), state, owned, resultOffset, arch), true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, required, false)
+	return true, true // EVEX clears wider aliases; FLAGS, DF and K are unchanged.
+}
diff --git a/x86_result_compact_expand_test.go b/x86_result_compact_expand_test.go
new file mode 100644
index 000000000..e2a0b6e1b
--- /dev/null
+++ b/x86_result_compact_expand_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// Independent of the production maps: six compress and six inverse-expand
+// opcodes, including floating spellings whose lanes are transported as bits.
+var x86CompactExpandResultMembers = []string{
+	"VCOMPRESSPS", "VCOMPRESSPD", "VPCOMPRESSB", "VPCOMPRESSW", "VPCOMPRESSD", "VPCOMPRESSQ",
+	"VEXPANDPS", "VEXPANDPD", "VPEXPANDB", "VPEXPANDW", "VPEXPANDD", "VPEXPANDQ",
+}
+
+func x86CompactExpandResultInstruction(op, bank, mode string) string {
+	if mode == "unmasked" {
+		return fmt.Sprintf("%s %s0,%s1", op, bank, bank)
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	return fmt.Sprintf("%s %s0,K1,%s1", op, bank, bank)
+}
+
+func TestX86PackedCompactExpandRegisterAvailability(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86CompactExpandResultMembers {
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					t.Run(arch+"/"+op+"/"+width.bank+"/"+mode, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, x86CompactExpandResultInstruction(op, width.bank, mode))
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+						state.writeVector(0, 64, ^uint64(0), false)
+						if mode == "merge" {
+							state.writeVector(1, 64, ^uint64(0), false)
+						}
+						state.masks[1] = mode != "unmasked"
+						before := state.clone()
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("complete Go register compaction/expansion lacks a numerical effect", ins.Raw)
+						}
+						before.writeVector(1, width.bytes, x86CallerVectorByteMask(int64(width.bytes)), false)
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("vector result failed to clear wider aliases or changed mask/FLAGS/DF", ins.Raw)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedCompactExpandMissingInputsRemainUnknown(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86CompactExpandResultMembers {
+			for _, width := range []struct {
+				bank  string
+				bytes int
+			}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+				t.Run(arch+"/"+op+"/"+width.bank, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, x86CompactExpandResultInstruction(op, width.bank, "merge"))
+					for _, unknown := range []string{"source", "mask", "merge"} {
+						for missing := 0; missing < width.bytes; missing++ {
+							state := x86ResultState{masks: [8]bool{1: unknown != "mask"}}
+							for index := 0; index < 2; index++ {
+								bits := ^uint64(0)
+								if index == 0 && unknown == "source" || index == 1 && unknown == "merge" {
+									bits &^= uint64(1) << uint(missing)
+								}
+								state.writeVector(index, 64, bits, false)
+							}
+							before := state.clone()
+							if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+								t.Fatalf("unknown %s/%d became a vector value", unknown, missing)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedCompactExpandResultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86CompactExpandResultMembers {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, mode := range []string{"unmasked", "merge", "zero"} {
+					row := x86CompactExpandResultInstruction(op, bank, mode)
+					source := "TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nKMOVD AX,K1\n" +
+						"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" + row +
+						"\nPEXTRD $0,X1,AX\nMOVL AX,ret+0(FP)\nRET\n"
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+op+"/"+bank+"/"+mode+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete initialized register form rejected", err)
+							}
+							if !x86CompactExpandZeroReturn(t, ir) {
+								t.Fatal("complete constant compact/expand fixture does not return zero")
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedCompactExpandCannotBypassWholeSourceProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range x86CompactExpandResultMembers {
+			for _, unknown := range []string{"source", "mask", "result"} {
+				setup := "VPXORD Z1,Z1,Z1\n"
+				if unknown != "source" {
+					setup += "VPXORD Z0,Z0,Z0\n"
+				}
+				if unknown != "mask" {
+					setup += "MOVL $7,AX\nKMOVD AX,K1\n"
+				}
+				source := "TEXT ·Value(SB),4,$0-0\n" + setup + op + " Z0,K1,Z1\nRET\n"
+				decl := "func Value()"
+				if unknown == "result" {
+					source = "TEXT ·Value(SB),4,$0-4\n" + setup + op + " Z0,K1,Z1\nRET\n"
+					decl = "func Value() uint32"
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+unknown+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, decl, target.arch, target.triple, api)
+						if err == nil || ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unknown input/result bypassed complete numerical proof", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_compare_exchange.go b/x86_result_compare_exchange.go
new file mode 100644
index 000000000..9d2d79ba2
--- /dev/null
+++ b/x86_result_compare_exchange.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import "reflect"
+
+// These are source ordinals of complete, same-block prefix/body pairs. This
+// is not an inert LOCK effect or a memory capability. The following opcode
+// still needs its own independent reaching input/result transfer.
+func x86ResultSourceLockPrefixes(fn Func, arch string) map[int]Instr {
+	bound := make(map[int]Instr)
+	if fn.x86DirectTailRoot != nil {
+		return bound // A one-node continuation block cannot borrow source adjacency.
+	}
+	var ordinals []int
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op != OpLABEL {
+			ordinals = append(ordinals, ordinal)
+		}
+	}
+	context := amd64Ctx{goarch: arch, blocks: amd64SplitBlocks(fn)}
+	at := 0
+	for bi, block := range context.blocks {
+		for ii, ins := range block.instrs {
+			if at >= len(ordinals) || !reflect.DeepEqual(ins, fn.Instrs[ordinals[at]]) {
+				return nil
+			}
+			if ins.Op == "LOCK" && x86ResultNamedPredicateInstruction(ins) && ii+1 < len(block.instrs) &&
+				x86ResultNamedPredicateInstruction(block.instrs[ii+1]) && context.namedLockPrefixBinding(bi, ii, ins) == nil {
+				bound[ordinals[at]] = ins
+			}
+			at++
+		}
+	}
+	if at != len(ordinals) {
+		return nil
+	}
+	return bound
+}
+
+func x86CompareExchangeResultOutputs(form x86CompareExchangeForm) (int64, []Reg) {
+	width, outputs := int64(form.spec.bits/8), []Reg{AX}
+	if form.spec.pair {
+		return width / 2, append(outputs, DX)
+	}
+	if form.destination.Kind == OpReg {
+		outputs = append(outputs, form.destination.Reg)
+	}
+	return width, outputs
+}
+
+// This is only the numerical continuation of the already paired native CAS
+// emitter. It supplies neither a readable pointee nor reusable write/extent,
+// native-entry, alignment, frame or caller permission. The original complete
+// sideeffect opcode still performs its read/write cycle, faults and ordering.
+func x86LoweredCompareExchangeResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86LoweredCompareExchangeResultStepWithAddressBits(ins, state, owned, arch, false)
+}
+
+// The existing closed-leaf address-bit scope permits one complete actual
+// caller word as a CAS value, never as NUM or a new memory/GC certificate.
+func x86LoweredCompareExchangeResultStepWithAddressBits(ins Instr, state *x86ResultState, owned []bool,
+	arch string, addressBits bool) (bool, bool) {
+	form, known, err := x86CompareExchangeProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	width, outputs := x86CompareExchangeResultOutputs(form)
+	read := func(operand Operand) (numeric, valid bool) {
+		if x86ResultRead(operand, width, state, owned, arch) {
+			return true, true
+		}
+		if !addressBits || width != x86ResultPointerWord(arch) || operand.Kind != OpReg ||
+			x86LogicalSourceFrameRegister(operand.Reg, arch) {
+			return false, false
+		}
+		root, _, valid := x86ResultGP(operand.Reg, width, arch)
+		return false, valid && state.pointerGP[root] && state.callerAddressGP[root]
+	}
+	inputs := []Operand{form.source, {Kind: OpReg, Reg: AX}}
+	if form.spec.pair {
+		inputs = []Operand{{Kind: OpReg, Reg: AX}, {Kind: OpReg, Reg: DX}, {Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: CX}}
+	}
+	for _, operand := range inputs {
+		if _, valid := read(operand); !valid {
+			return false, true
+		}
+	}
+	var numericOutputs [2]bool
+	for index, reg := range outputs {
+		numericOutputs[index] = x86ResultRead(Operand{Kind: OpReg, Reg: reg}, width, state, owned, arch)
+	}
+	if form.destination.Kind == OpReg {
+		destinationNumeric, valid := read(form.destination)
+		if !valid {
+			return false, true
+		}
+		sourceNumeric, _ := read(form.source)
+		numericOutputs[0] = numericOutputs[0] && destinationNumeric
+		numericOutputs[1] = sourceNumeric && destinationNumeric
+	} else {
+		address := x86ResultIncomingPointerAddressIdentity(form.destination, state, arch)
+		if !form.spec.pair {
+			address = x86ResultNativeRMWAddress(ins, form.destination, state, owned, arch)
+		}
+		if !address {
+			return false, true // No SB, FP/AUTO or numerical base is inferred.
+		}
+	}
+	for index, reg := range outputs {
+		root, mask, valid := x86ResultGP(reg, width, arch)
+		if !valid {
+			return false, true
+		}
+		// The accumulator write is conditional. In particular, a successful
+		// dword CAS preserves its old high half; no unconditional zero extension.
+		// A successful CAS may retain the opaque expected value. A register
+		// destination may instead receive opaque desired bits. Only bytes
+		// numerical on both outcomes remain NUM; neither outcome grants a
+		// pointer identity for unknown native contents or selected values.
+		if numericOutputs[index] {
+			state.gp[root] |= mask
+		} else {
+			state.gp[root] &^= mask
+		}
+		state.pointerGP[root] = false
+	}
+	if form.spec.pair {
+		state.flags |= x86ByteFlagZF // 8B/16B leave the other status flags unchanged.
+	} else {
+		state.flags = x86ByteFlagsAll
+	}
+	return true, true
+}
diff --git a/x86_result_compare_exchange_objects_test.go b/x86_result_compare_exchange_objects_test.go
new file mode 100644
index 000000000..1c0c47583
--- /dev/null
+++ b/x86_result_compare_exchange_objects_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86CompareExchangeResultFullFamilyOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("the complete CAS result family requires LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			ops := []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"}
+			if target.arch == "amd64" {
+				ops = append(ops, "CMPXCHGQ", "CMPXCHG16B")
+			}
+			var source, declarations strings.Builder
+			for _, op := range ops {
+				for _, shape := range []string{"plain-memory", "LOCK-memory", "register"} {
+					if shape == "register" && (op == "CMPXCHG8B" || op == "CMPXCHG16B") {
+						continue // The original Go pair register rows encode #UD.
+					}
+					body, declaration := x86ResultCompareExchangeFixture(target.arch, op, shape == "LOCK-memory", shape == "register")
+					name := strings.ReplaceAll(op+"_"+shape, "-", "_")
+					source.WriteString(strings.Replace(body, "·cas(SB)", "·"+name+"(SB)", 1))
+					declarations.WriteString(strings.Replace(declaration, "func cas(", "func "+name+"(", 1) + "\n")
+				}
+			}
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("ORIGINAL_CAS_RESULT_OBJECT: %+v", receipt)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("the complete original CAS family lost its result proof", err)
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input := ir
+						if optimizeIR {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimizeIR, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86CompareExchangeResultOriginalGoBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ name, from, to string }{
+			{"label-before-body", "LOCK\n", "LOCK\nbody:\n"},
+			{"jump-into-body", "LOCK\n", "JMP 2(PC)\nLOCK\n"},
+			{"conditional-entry", "LOCK\n", "CMPL AX,$0\nJEQ 2(PC)\nLOCK\n"},
+			{"detached-prefix", "LOCK\n", "LOCK\nNOP\n"},
+			{"undefined-effect", "SETEQ ret+", "FSIN\nSETEQ ret+"},
+		} {
+			t.Run(arch+"/Go-accepted-Context/"+row.name, func(t *testing.T) {
+				source, declaration := x86ResultCompareExchangeFixture(arch, "CMPXCHGL", true, false)
+				source = strings.Replace(source, row.from, row.to, 1)
+				requireLEANativeGoObject(t, arch, source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, testTargetTriple("linux", arch), api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Go-valid source acquired an unbound prefix or effect", api, err)
+					}
+				}
+			})
+		}
+		t.Run(arch+"/Go-rejected/operand-prefix", func(t *testing.T) {
+			source, _ := x86ResultCompareExchangeFixture(arch, "CMPXCHGL", true, false)
+			requireLEANativeGoObject(t, arch, strings.Replace(source, "LOCK\n", "LOCK AX\n", 1), false)
+		})
+	}
+}
diff --git a/x86_result_compare_exchange_pointer_test.go b/x86_result_compare_exchange_pointer_test.go
new file mode 100644
index 000000000..cb89782d7
--- /dev/null
+++ b/x86_result_compare_exchange_pointer_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86PointerCompareExchangeFixture(arch, op, shape string) (string, string) {
+	source, declaration := x86ResultCompareExchangeFixture(arch, op, shape == "locked", shape == "register")
+	word, typ := "Q", "uint64"
+	if arch == "386" {
+		word, typ = "L", "uint32"
+	}
+	// A pointer word is not a numerical SIMD input. The independent pointer
+	// fixture never borrows the existing numeric fixture's vector round trip.
+	source = strings.Replace(source, "MOV"+word+" AX,X0\nMOV"+word+" X0,AX\n", "", 1)
+	declaration = strings.Replace(declaration, "a,d,b,c "+typ, "a,d,b,c *byte", 1)
+	return source, strings.Replace(declaration, ") uint8", ") bool", 1)
+}
+
+func TestX86CompareExchangeCallerPointerWordObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			ops := []string{"CMPXCHGQ", "CMPXCHG16B"}
+			if target.arch == "386" {
+				ops = []string{"CMPXCHGL", "CMPXCHG8B"}
+			}
+			var source, declarations strings.Builder
+			for _, op := range ops {
+				for _, shape := range []string{"memory", "locked", "register"} {
+					if shape == "register" && strings.HasSuffix(op, "B") {
+						continue // Original pair-register encodings are #UD.
+					}
+					body, declaration := x86PointerCompareExchangeFixture(target.arch, op, shape)
+					name := "Pointer" + op + shape
+					source.WriteString(strings.Replace(body, "·cas(SB)", "·"+name+"(SB)", 1))
+					declarations.WriteString(strings.Replace(declaration, "func cas(", "func "+name+"(", 1) + "\n")
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete caller pointer words rejected by native CAS continuation", api, err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86CompareExchangePointerInputBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		op, move, word := "CMPXCHGQ", "MOVQ", 8
+		if target.arch == "386" {
+			op, move, word = "CMPXCHGL", "MOVL", 4
+		}
+		for _, row := range []struct{ name, from, to string }{
+			{"missing-source", fmt.Sprintf("%s c+%d(FP),CX\n", move, 4*word), ""},
+			{"partial-source", fmt.Sprintf("%s c+%d(FP),CX", move, 4*word), fmt.Sprintf("MOVW c+%d(FP),CX", 4*word)},
+			{"missing-expected", fmt.Sprintf("%s a+%d(FP),AX\n", move, word), ""},
+			{"not-an-address", move + " p+0(FP),SI", move + " $0,SI"},
+			{"unbound-frame", "$0-", "$8-"},
+			{"raw-source", "LOCK\n", "BYTE $0x90\nLOCK\n"},
+			{"pointer-not-numeric", "SETEQ ret+", "MOVB CX,ret+"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source, declarations := x86PointerCompareExchangeFixture(target.arch, op, "locked")
+					if !strings.Contains(source, row.from) {
+						t.Fatal("negative mutation lost its complete source operand", row.name)
+					}
+					source = strings.Replace(source, row.from, row.to, 1)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("incomplete pointer/source role gained CAS transport", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// A register CAS has no native memory access. This host-width LLVM oracle
+// checks actual pointer values, not C _Bool attributes or native Go ABI entry.
+func TestX86CompareExchangePointerRegisterPortable(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	const assembly = "TEXT ·Value(SB),4,$0-25\nMOVQ a+0(FP),AX\nMOVQ b+8(FP),BX\nMOVQ c+16(FP),CX\nCMPXCHGQ CX,BX\nSETEQ ret+24(FP)\nRET\n"
+	const shim = `
+define i32 @Probe(ptr %a,ptr %b,ptr %c) {
+ %result = call i1 @Value(ptr %a,ptr %b,ptr %c)
+ %output = zext i1 %result to i32
+ ret i32 %output
+}
+`
+	const driver = `extern int Probe(void*,void*,void*);
+int main(void) {
+ char values[3];
+ for (unsigned a=0;a<3;a++)
+  for (unsigned b=0;b<3;b++)
+   for (unsigned c=0;c<3;c++)
+    if (Probe(values+a,values+b,values+c)!=(a==b)) return 1;
+ return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly, "func Value(a,b,c *byte) bool", "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir += shim
+			for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "pointer-cas", triple, input, driver, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86CompareExchangePointerDoesNotAcquireNUM(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		op, word := "CMPXCHGQ", int64(8)
+		if arch == "386" {
+			op, word = "CMPXCHGL", 4
+		}
+		ins := x86ScalarLaneInstruction(t, op+" CX,(SI)")
+		state := x86ResultState{}
+		state.pointerGP[6], state.pointerGP[0], state.pointerGP[1] = true, true, true
+		state.callerAddressGP[0], state.callerAddressGP[1] = true, true
+		before := state.clone()
+		if accepted, known := x86LoweredCompareExchangeResultStep(ins, &state, nil, arch); accepted || !known || !reflect.DeepEqual(state, before) {
+			t.Fatal("unscoped numerical observer consumed opaque pointer words", word, accepted, known)
+		}
+	}
+}
+
+func TestX86CompareExchangePointerConditionalWordFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			op    string
+			width int64
+			pair  bool
+		}{
+			{"CMPXCHGB", 1, false}, {"CMPXCHGW", 2, false},
+			{"CMPXCHGL", 4, false}, {"CMPXCHGQ", 8, false},
+			{"CMPXCHG8B", 4, true}, {"CMPXCHG16B", 8, true},
+		} {
+			if arch == "386" && row.width == 8 {
+				continue // The original Go grammar rejects these two forms.
+			}
+			for _, register := range []bool{false, true} {
+				if row.pair && register {
+					continue // Original pair-register encodings are #UD.
+				}
+				body := row.op + " CX,(SI)"
+				inputs := []int{0, 1}
+				if row.pair {
+					body, inputs = row.op+" (SI)", []int{0, 2, 3, 1}
+				} else if register {
+					body, inputs = row.op+" CX,BX", append(inputs, 3)
+				}
+				for _, opaque := range inputs {
+					t.Run(fmt.Sprintf("%s/%s/register=%t/opaque=%d", arch, row.op, register, opaque), func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, body)
+						mask := uint8((uint16(1) << uint(row.width)) - 1)
+						state := x86ResultState{}
+						for _, root := range []int{0, 1, 2, 3} {
+							state.gp[root] = mask
+						}
+						state.pointerGP[6] = true
+						state.gp[opaque] = 0
+						state.pointerGP[opaque], state.callerAddressGP[opaque] = true, true
+						before := state.clone()
+						accepted, known := x86LoweredCompareExchangeResultStepWithAddressBits(ins, &state, nil, arch, true)
+						if row.width != x86ResultPointerWord(arch) {
+							if accepted || !known || !reflect.DeepEqual(state, before) {
+								t.Fatal("partial pointer bits gained an input or changed state")
+							}
+							return
+						}
+						if !accepted || !known {
+							t.Fatal("complete independently scoped caller word rejected")
+						}
+						outputs := []int{0}
+						if row.pair {
+							outputs = append(outputs, 2)
+						} else if register {
+							outputs = append(outputs, 3)
+						}
+						for _, root := range outputs {
+							numeric := root != opaque
+							if register {
+								numeric = opaque != 3 && (root == 0 && opaque != 0 || root == 3 && opaque != 1)
+							}
+							want := uint8(0)
+							if numeric {
+								want = mask
+							}
+							if state.gp[root] != want || state.pointerGP[root] {
+								t.Fatal("conditional CAS invented NUM or pointer identity", root, state.gp[root], want)
+							}
+						}
+						before.callerAddressGP[opaque] = false
+						withoutCaller := before.clone()
+						if accepted, known := x86LoweredCompareExchangeResultStepWithAddressBits(ins, &withoutCaller, nil, arch, true); accepted || !known || !reflect.DeepEqual(withoutCaller, before) {
+							t.Fatal("opaque identity alone supplied actual caller-word bits")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86CompareExchangeBoundPrefixKeepsOnlyPriorCallerWords(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		prefix := x86ScalarLaneInstruction(t, "LOCK")
+		before, transferred := [16]bool{true, false, true}, [16]bool{true, true, false}
+		if got := x86ResultCallerAddressesAfterTransfer(prefix, before, transferred, nil, arch); got != ([16]bool{true}) {
+			t.Fatal("paired prefix invented or revived a caller word", got)
+		}
+		if got := x86ResultCallerAddressesAfter(prefix, before, nil, arch); got != ([16]bool{}) {
+			t.Fatal("standalone overwrite query borrowed a bound source prefix", got)
+		}
+	}
+}
diff --git a/x86_result_compare_exchange_test.go b/x86_result_compare_exchange_test.go
new file mode 100644
index 000000000..345df832f
--- /dev/null
+++ b/x86_result_compare_exchange_test.go
@@ -0,0 +1,342 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultNamedLockCompleteSourceGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows, want := x86NamedLockOracleForms(arch), 67
+		if arch == "386" {
+			want = 49
+		}
+		if len(rows) != want {
+			t.Fatal("complete independent LOCK family changed", arch, len(rows))
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				source := x86NamedLockOracleSource(arch, "CMPL AX,AX\nLOCK\n"+row.text)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				before := x86DirectTailSnapshot(file)
+				bound := x86ResultSourceLockPrefixes(fn, arch)
+				if len(bound) != 1 {
+					t.Fatal("same-block legal complete RMW lost its prefix association", row.text)
+				}
+				for ordinal, prefix := range bound {
+					if prefix.Op != "LOCK" || !reflect.DeepEqual(fn.Instrs[ordinal], prefix) {
+						t.Fatal("prefix did not retain its complete original source ordinal")
+					}
+					state := x86ResultState{}
+					if x86ResultTransfer(prefix, &state, nil, 0, arch) {
+						t.Fatal("standalone LOCK acquired a generic inert numerical effect")
+					}
+					if accepted, known := x86LoweredCompareExchangeResultStep(prefix, &state, nil, arch); accepted || known {
+						t.Fatal("an isolated typed opcode query borrowed source adjacency")
+					}
+				}
+				if !reflect.DeepEqual(before, file) {
+					t.Fatal("source binding modified the original instruction tuple")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCompareExchangePrefixAndAuthorityBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, width, triple := "Q", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, width, triple = "L", 4, "i386-unknown-linux-gnu"
+		}
+		for _, row := range []struct{ name, from, to string }{
+			{"missing-result", fmt.Sprintf("SETEQ ret+%d(FP)\n", width*5), ""},
+			{"missing-CX", fmt.Sprintf("MOV%s c+%d(FP),CX\n", word, width*4), ""},
+			{"unknown-address", "MOV" + word + " p+0(FP),SI", "MOV" + word + " $0,SI"},
+			{"numerical-address", "MOV" + word + " p+0(FP),SI", fmt.Sprintf("MOV%s a+%d(FP),SI", word, width)},
+			{"unknown-index", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,(SI)(DI*4)"},
+			{"unbound-SB", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,missing(SB)"},
+			{"unbound-FP", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,p+0(FP)"},
+			{"physical-SP", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,(SP)"},
+			{"physical-BP", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,(BP)"},
+			{"prefix-operands", "LOCK\n", "LOCK AX\n"},
+			{"double-prefix", "LOCK\n", "LOCK\nLOCK\n"},
+			{"detached-prefix", "LOCK\nCMPXCHGL CX,(SI)", "LOCK\nNOP\nCMPXCHGL CX,(SI)"},
+			{"trailing-prefix", "LOCK\nCMPXCHGL CX,(SI)", "CMPXCHGL CX,(SI)\nLOCK"},
+			{"label-between", "LOCK\nCMPXCHGL CX,(SI)", "LOCK\nmiddle:\nCMPXCHGL CX,(SI)"},
+			{"jump-into-body", "LOCK\nCMPXCHGL CX,(SI)", "JMP 2(PC)\nLOCK\nCMPXCHGL CX,(SI)"},
+			{"jump-target-body", "LOCK\nCMPXCHGL CX,(SI)", "CMPL AX,AX\nJEQ 2(PC)\nLOCK\nCMPXCHGL CX,(SI)"},
+			{"locked-register", "CMPXCHGL CX,(SI)", "CMPXCHGL CX,BX"},
+			{"non-RMW-prefix-target", "CMPXCHGL CX,(SI)", "MOVL (SI),CX"},
+			{"REP-is-not-LOCK", "LOCK\n", "REP\n"},
+			{"REPN-is-not-LOCK", "LOCK\n", "REPN\n"},
+			{"undefined-vector-result", "SETEQ ret+", "AESENC X1,X0\nMOV" + word + " X0,AX\nCMPL AX,$0\nSETEQ ret+"},
+			{"unknown-effect", "SETEQ ret+", "FSIN\nSETEQ ret+"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					source, declaration := x86ResultCompareExchangeFixture(arch, "CMPXCHGL", true, false)
+					if !strings.Contains(source, row.from) {
+						t.Fatal("negative did not match the complete source", row.name)
+					}
+					source = strings.Replace(source, row.from, row.to, 1)
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+					if arch == "amd64" && row.name == "undefined-vector-result" {
+						x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+					} else if err == nil || ir != "" {
+						t.Fatal("unproved prefix/result/native role was published", row.name, err)
+					}
+				})
+			}
+		}
+		for _, vector := range []string{"X0", "X1"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/unused-AES-input-"+vector+"/"+api, func(t *testing.T) {
+					source, declaration := x86ResultCompareExchangeFixture(arch, "CMPXCHGL", true, false)
+					source = strings.Replace(source, "SETEQ ret+", "AESENC "+vector+",X0\nSETEQ ret+", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+						t.Fatal("an unused numerical AES output changed the independent CAS predicate", err)
+					}
+				})
+			}
+		}
+		for _, pair := range []string{"CMPXCHG8B", "CMPXCHG16B"} {
+			if arch == "386" && pair == "CMPXCHG16B" {
+				continue // The complete Go grammar rejects this mode, not a missing effect.
+			}
+			for _, implicit := range []string{"AX", "DX", "BX", "CX"} {
+				t.Run(arch+"/"+pair+"/missing-"+implicit, func(t *testing.T) {
+					source, declaration := x86ResultCompareExchangeFixture(arch, pair, true, false)
+					lines := strings.Split(source, "\n")
+					for index, line := range lines {
+						if strings.HasSuffix(line, ","+implicit) && strings.Contains(line, "(FP)") {
+							lines[index] = ""
+						}
+					}
+					if ir, err := x86ScalarFPBitViewAPI(t, strings.Join(lines, "\n"), declaration, arch, triple, "text"); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("missing implicit pair input acquired bytes", implicit, err)
+					}
+				})
+			}
+			t.Run(arch+"/"+pair+"/uninitialized-CF", func(t *testing.T) {
+				source, declaration := x86ResultCompareExchangeFixture(arch, pair, true, false)
+				source = strings.Replace(source, "SETEQ ret+", "SETCS ret+", 1)
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, "text"); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("pair CAS invented non-ZF status bytes", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCompareExchangeAlternateRMWUsesIndependentEffect(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		source, declaration := x86ResultCompareExchangeFixture(arch, "CMPXCHGL", true, false)
+		source = strings.Replace(source, "CMPXCHGL CX,(SI)", "XADDL CX,(SI)", 1)
+		requireX86GoAssemblerResult(t, arch, source, true)
+		instruction := x86ScalarLaneInstruction(t, "XADDL CX,(SI)")
+		state := x86ResultState{}
+		if accepted, known := x86LoweredCompareExchangeResultStep(instruction, &state, nil, arch); accepted || known {
+			t.Fatal("XADD acquired the unrelated CAS effect")
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+					t.Fatal("the independently modeled complete XADD source was rejected", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultNamedLockSourceBlockBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, body := range []string{
+			"LOCK", "LOCK AX\nCMPXCHGL CX,(SI)",
+			"LOCK\nLOCK\nCMPXCHGL CX,(SI)",
+			"LOCK\nNOP\nCMPXCHGL CX,(SI)",
+			"LOCK\nbody:\nCMPXCHGL CX,(SI)",
+			"JMP 2(PC)\nLOCK\nCMPXCHGL CX,(SI)",
+			"CMPL AX,AX\nJEQ 2(PC)\nLOCK\nCMPXCHGL CX,(SI)",
+		} {
+			t.Run(arch+"/"+body, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, x86NamedLockOracleSource(arch, body))
+				if err != nil {
+					t.Fatal("boundary must reach the original source/CFG observer", err)
+				}
+				prefixes := x86ResultSourceLockPrefixes(file.Funcs[0], arch)
+				for ordinal, ins := range file.Funcs[0].Instrs {
+					if ins.Op == "LOCK" {
+						if _, bound := prefixes[ordinal]; bound {
+							t.Fatal("the first split, malformed or independently entered prefix acquired a body", prefixes)
+						}
+						break
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultCompareExchangeConditionalBytesAndFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			op    string
+			bytes int64
+			pair  bool
+		}{
+			{"CMPXCHGB", 1, false}, {"CMPXCHGW", 2, false},
+			{"CMPXCHGL", 4, false}, {"CMPXCHGQ", 8, false},
+			{"CMPXCHG8B", 4, true}, {"CMPXCHG16B", 8, true},
+		} {
+			if arch == "386" && row.bytes == 8 {
+				continue // These complete Go forms are unavailable in this mode.
+			}
+			for _, register := range []bool{false, true} {
+				if register && row.pair {
+					continue // Pair register encodings are #UD, not numerical CAS.
+				}
+				t.Run(fmt.Sprintf("%s/%s/register=%t", arch, row.op, register), func(t *testing.T) {
+					source, _ := x86ResultCompareExchangeFixture(arch, row.op, false, register)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var ins Instr
+					for _, candidate := range file.Funcs[0].Instrs {
+						if string(candidate.Op) == row.op {
+							ins = candidate
+						}
+					}
+					mask := uint8((uint16(1) << uint(row.bytes)) - 1)
+					initial := x86ResultState{fp: make([]bool, 16), auto: make([]bool, 16)}
+					initial.pointerGP[6] = true // Only the actual opaque SI identity.
+					for _, index := range []int{0, 1, 2, 3} {
+						initial.gp[index] = mask
+					}
+					for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+						state := initial.clone()
+						state.flags = flags
+						want := state.clone()
+						want.flags = x86ByteFlagsAll
+						if row.pair {
+							want.flags = flags | x86ByteFlagZF
+						}
+						if accepted, known := x86LoweredCompareExchangeResultStep(ins, &state, nil, arch); !accepted || !known || !reflect.DeepEqual(state, want) {
+							t.Fatal("conditional accumulator/high-half, non-ZF or disjoint authority changed", flags, state, want)
+						}
+					}
+					inputs := []int{0, 1}
+					if register || row.pair {
+						inputs = append(inputs, 3)
+					}
+					if row.pair {
+						inputs = append(inputs, 2)
+					}
+					for _, input := range inputs {
+						for missing := int64(0); missing < row.bytes; missing++ {
+							state := initial.clone()
+							state.gp[input] &^= 1 << uint(missing)
+							before := state.clone()
+							if accepted, known := x86LoweredCompareExchangeResultStep(ins, &state, nil, arch); accepted || !known || !reflect.DeepEqual(state, before) {
+								t.Fatal("unknown/partial actual input gained conditional result bytes", input, missing)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86ResultCompareExchangeFixture(arch, op string, locked, register bool) (string, string) {
+	word, width, typ := "Q", 8, "uint64"
+	if arch == "386" {
+		word, width, typ = "L", 4, "uint32"
+	}
+	body := op + " CX,(SI)"
+	if strings.HasSuffix(op, "B") && op != "CMPXCHG8B" && op != "CMPXCHG16B" {
+		body = op + " CL,(SI)"
+	}
+	if op == "CMPXCHG8B" || op == "CMPXCHG16B" {
+		body = op + " (SI)"
+	}
+	if register {
+		body = strings.ReplaceAll(body, "(SI)", "BX")
+	}
+	if locked {
+		body = "LOCK\n" + body
+	}
+	source := fmt.Sprintf("TEXT ·cas(SB),4,$0-%d\nMOV%s p+0(FP),SI\n"+
+		"MOV%s a+%d(FP),AX\nMOV%s d+%d(FP),DX\nMOV%s b+%d(FP),BX\nMOV%s c+%d(FP),CX\n"+
+		"MOV%s AX,X0\nMOV%s X0,AX\n%s\nSETEQ ret+%d(FP)\nRET\n",
+		width*5+1, word, word, width, word, width*2, word, width*3, word, width*4, word, word, body, width*5)
+	declaration := "func cas(p *byte, a,d,b,c " + typ + ") uint8"
+	return source, declaration
+}
+
+func TestX86ResultCompareExchangeCompleteSourceFamily(t *testing.T) {
+	for _, target := range []struct{ arch, triple string }{
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+	} {
+		ops := []string{"CMPXCHGB", "CMPXCHGW", "CMPXCHGL", "CMPXCHG8B"}
+		if target.arch == "amd64" {
+			ops = append(ops, "CMPXCHGQ", "CMPXCHG16B")
+		}
+		for _, op := range ops {
+			for _, shape := range []string{"plain-memory", "LOCK-memory", "register"} {
+				if shape == "register" && (op == "CMPXCHG8B" || op == "CMPXCHG16B") {
+					continue // Both Go pair register rows encode #UD, not a numerical CAS.
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+shape+"/"+api, func(t *testing.T) {
+						source, declaration := x86ResultCompareExchangeFixture(target.arch, op, shape == "LOCK-memory", shape == "register")
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						if shape != "register" && (!strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, "=*m") || !strings.Contains(ir, "~{memory}")) {
+							t.Fatal("paired native read/write/fault/ordering effect was removed")
+						}
+						if shape == "LOCK-memory" && !strings.Contains(ir, "asm sideeffect \"lock; cmpxchg") {
+							t.Fatal("source-bound LOCK was removed from the original native operation")
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultCompareExchangeOrdinaryABI0Source(t *testing.T) {
+	const source = `TEXT ·Cas(SB),4,$0-13
+MOVL ptr+0(FP),BX
+MOVL old+4(FP),AX
+MOVL new+8(FP),CX
+LOCK
+CMPXCHGL CX,0(BX)
+SETEQ ret+12(FP)
+RET
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			_, err := x86ScalarFPBitViewAPI(t, source,
+				"func Cas(ptr *int32, old, new int32) bool", "386", "i386-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
diff --git a/x86_result_cpu_query.go b/x86_result_cpu_query.go
new file mode 100644
index 000000000..3d508b659
--- /dev/null
+++ b/x86_result_cpu_query.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+// Only the two architectural maximum-leaf selectors have an unconditional
+// EAX-only dependency. This must-fact supplies no numerical bytes or address
+// role. Unknown selectors, including unsupported leaves that may alias a
+// structured leaf, still consume ECX. Every CFG predecessor must agree.
+func x86ResultCPUIDRootLeafAfter(ins Instr, before bool, arch string) bool {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false
+	}
+	ins = x86SourceMoveInstruction(ins, arch)
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 && len(ins.Args) == 2 {
+		destination := ins.Args[1]
+		if destination.Kind != OpReg {
+			return before
+		}
+		index, _, valid := x86ResultGP(destination.Reg, width, arch)
+		if !valid || index != 0 {
+			return valid && before
+		}
+		source := ins.Args[0]
+		return width >= 4 && source.Kind == OpImm && source.ImmRaw == "" && !source.ImmIsFloat &&
+			(uint32(source.Imm) == 0 || uint32(source.Imm) == 0x80000000)
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil &&
+		form.spec.bits >= 32 && form.destination.Kind == OpReg && x86ScalarXORZeroRegister(form, int64(form.spec.bits/8)) {
+		index, _, valid := x86ResultGP(form.destination.Reg, int64(form.spec.bits/8), arch)
+		if valid && index == 0 {
+			return true
+		}
+	}
+	if !before {
+		return false
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+		if err != nil {
+			return false
+		}
+		for _, operand := range effect.operands {
+			if operand.write && operand.operand.Kind == OpReg {
+				index, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+				if !valid || index == 0 {
+					return false
+				}
+			}
+		}
+		return true
+	}
+	if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil {
+		return true
+	}
+	return ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) || ins.Op == "NOP"
+}
diff --git a/x86_result_data_address.go b/x86_result_data_address.go
new file mode 100644
index 000000000..15d2a0307
--- /dev/null
+++ b/x86_result_data_address.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import "strings"
+
+// This directory is private to the actual emitted module. It describes a
+// complete address value, not arbitrary relocation bytes, an incoming Go
+// pointer or a code address. numericLiterals supplies extents to the separate
+// whole-source indexed-read proof; the address value itself grants no read.
+type x86StaticAddressValues struct {
+	objects         map[string]bool
+	writable        map[string]bool
+	cells           map[x86StaticSBAddress]bool
+	numericLiterals map[string]int64 // Raw private names of complete emitted readonly numeric objects.
+}
+
+func x86LoweredStaticAddressValues(file *File, resolve func(string) string, sigs map[string]FuncSig, arch string) *x86StaticAddressValues {
+	if file == nil || file.Arch != ArchAMD64 || resolve == nil ||
+		arch != "386" && arch != "amd64" || len(file.Data)+len(file.Globl) == 0 {
+		return nil
+	}
+	type object struct {
+		raw                 string
+		size, end           int64
+		invalid             bool
+		readOnly            bool
+		definitions         int
+		relocated, badFlags bool
+	}
+	objects := make(map[string]object)
+	bind := func(raw string) (string, object) {
+		name := resolveAssemblyDataSymbol(raw, resolve)
+		current := objects[name]
+		if current.raw != "" && current.raw != raw {
+			current.invalid = true // Coalesced definitions do not prove one object.
+		}
+		current.raw = raw
+		return name, current
+	}
+	for _, global := range file.Globl {
+		name, current := bind(global.Sym)
+		readOnly, err := globlReadOnly(global.Flags)
+		current.definitions++
+		current.badFlags = current.badFlags || err != nil
+		current.readOnly = current.readOnly || readOnly || err != nil
+		current.invalid = current.invalid || global.SizeRaw != "" || global.Size < 0 || global.Size > maxDataGlobalSize
+		if global.Size > current.size {
+			current.size = global.Size
+		}
+		objects[name] = current
+	}
+	for _, datum := range file.Data {
+		name, current := bind(datum.Sym)
+		end, err := dataStmtEnd(datum)
+		current.invalid = current.invalid || err != nil || datum.Off < current.end
+		current.relocated = current.relocated || datum.Addr != ""
+		current.end = end
+		if end > current.size {
+			current.size = end
+		}
+		objects[name] = current
+	}
+	code := make(map[string]bool)
+	for _, function := range file.Funcs {
+		if len(function.x86ContinuationAddresses) != 0 {
+			return nil // Prepared per-entry code identities retain their separate whole-source consumer.
+		}
+		code[resolve(function.Sym)] = true
+		code[resolveAssemblyDataSymbol(function.Sym, resolve)] = true
+	}
+	for name, signature := range sigs {
+		code[name], code[funcSigSymbol(name, signature)] = true, true
+	}
+	if graph := file.x86ContinuationGraph; graph != nil {
+		for symbol := range graph.addresses {
+			code[resolve(symbol)] = true
+			code[resolveAssemblyDataSymbol(symbol, resolve)] = true
+		}
+		for symbol := range graph.tables {
+			code[resolveAssemblyDataSymbol(symbol, resolve)] = true
+		}
+	}
+	values := &x86StaticAddressValues{
+		objects: make(map[string]bool), writable: make(map[string]bool),
+		cells: make(map[x86StaticSBAddress]bool), numericLiterals: make(map[string]int64),
+	}
+	for name, current := range objects {
+		if !current.invalid && !code[name] && current.size > 0 && current.size <= maxDataGlobalSize {
+			values.objects[name] = true
+			values.writable[name] = !current.readOnly
+			if current.readOnly && current.definitions == 1 && !current.badFlags && !current.relocated &&
+				strings.HasSuffix(current.raw, "<>") {
+				values.numericLiterals[current.raw] = current.size
+			}
+		}
+	}
+	word := x86ResultPointerWord(arch)
+	for _, datum := range file.Data {
+		if datum.Addr == "" || datum.Width != word || datum.Payload != nil || datum.Value != 0 {
+			continue
+		}
+		base, _, err := dataAddress(datum)
+		if err != nil {
+			continue
+		}
+		holder := resolveAssemblyDataSymbol(datum.Sym, resolve)
+		target := resolveAssemblyDataSymbol(base, resolve)
+		if values.objects[holder] && values.objects[target] && !code[resolve(base)] {
+			values.cells[x86StaticSBAddress{holder, datum.Off}] = true
+		}
+	}
+	return values
+}
+
+// Reuse the existing MOVQ source aliases and SB grammar. The only new value
+// role is one complete native word; indexed reads and physical frame writes
+// retain their independent contracts. Address annotations follow the same
+// non-shared Go386 TYPE_ADDR rule as the existing paired emitter.
+func x86StaticAddressValueMove(ins Instr, arch string) (x86StaticSBAddress, bool, int, bool) {
+	ins = x86SourceMoveInstruction(ins, arch)
+	word := x86ResultPointerWord(arch)
+	if !x86ResultNamedPredicateInstruction(ins) || arch != "386" && arch != "amd64" ||
+		x86RawReturnScalarMoveBytes(ins.Op) != word || len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		return x86StaticSBAddress{}, false, 0, false
+	}
+	index, _, valid := x86ResultGP(ins.Args[1].Reg, word, arch)
+	if !valid {
+		return x86StaticSBAddress{}, false, 0, false
+	}
+	address, immediate, valid := x86StaticAddressValueSource(ins.Args[0], arch)
+	return address, immediate, index, valid
+}
+
+// MOV and the non-shared mode32 Yi32 arithmetic rows share address spelling,
+// including ignored source annotations. This never dereferences the address.
+func x86StaticAddressValueSource(source Operand, arch string) (x86StaticSBAddress, bool, bool) {
+	immediate := false
+	if source.Kind == OpSym && strings.HasPrefix(strings.TrimSpace(source.Sym), "$") {
+		immediate = true
+		source.Sym = strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(source.Sym), "$"))
+		if memory, matched, err := parseX86SymbolIndexedMemory(source.Sym); matched {
+			if err != nil {
+				return x86StaticSBAddress{}, false, false
+			}
+			if arch == "386" {
+				for _, register := range []Reg{memory.Base, memory.Index} {
+					if register != "" && !x86SymbolGoRegisterName(string(register)) {
+						return x86StaticSBAddress{}, false, false
+					}
+				}
+				if memory.IndexExt != "" || memory.Index == "CS" || memory.Index == "DS" || memory.Index == "ES" || memory.Index == FS || memory.Index == GS {
+					return x86StaticSBAddress{}, false, false
+				}
+				memory.Base, memory.Index, memory.Scale = "", "", 0
+			}
+			source = Operand{Kind: OpMem, Mem: memory}
+		}
+	}
+	address, valid := x86StaticSBSourceAddress(source, arch)
+	return address, immediate, valid && (immediate || address.offset >= 0)
+}
+
+func (c *amd64Ctx) scalarStaticAddressValueTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	values := c.fpStaticAddressValues
+	if values == nil {
+		return false, false
+	}
+	address, immediate, index, valid := x86StaticAddressValueMove(ins, arch)
+	if !valid {
+		return false, false
+	}
+	address.symbol = resolveAssemblyDataSymbol(address.symbol, c.resolve)
+	if immediate && !values.objects[address.symbol] || !immediate && !values.cells[address] {
+		return false, false
+	}
+	word := x86ResultPointerWord(arch)
+	if !x86ResultStore(ins.Args[1], word, state, owned, 0, arch) {
+		return false, true
+	}
+	state.canonicalGP[index] = 0
+	if word == 4 {
+		state.canonicalGP[index] = 0xf0
+	}
+	state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = false, false, 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	if state.boolFrameGP != nil {
+		state.boolFrameGP[index] = x86ResultSlotAddress{}
+	}
+	return true, true // Actual relocation emission/load is unchanged; FLAGS/DF are untouched.
+}
diff --git a/x86_result_data_address_objects_test.go b/x86_result_data_address_objects_test.go
new file mode 100644
index 000000000..e635fbd6e
--- /dev/null
+++ b/x86_result_data_address_objects_test.go
@@ -0,0 +1,107 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86StaticAddressValueCompleteMoveFormsAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range dataRelocationTargets {
+		if target.arch != ArchAMD64 {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			moves := []string{"MOVQ", "MOVD", "MOVDQ2Q"}
+			operands := []string{"box<>+8(SB)", "$bytes<>+3(SB)", "$bytes<>-1(SB)", "$bytes<>+17(SB)"}
+			if target.goarch == "386" {
+				word, move, moves = 4, "MOVL", []string{"MOVL"}
+				operands = append(operands, "box<>+8(SB)(SP)", "$bytes<>+3(SB)(AX)(CX*2)")
+			}
+			var source, declarations strings.Builder
+			fmt.Fprintf(&source, "DATA bytes<>(SB)/8,$0x1122334455667788\nGLOBL bytes<>(SB),16,$16\n"+
+				"DATA box<>+8(SB)/%d,$bytes<>+3(SB)\nGLOBL box<>(SB),16,$24\n", word)
+			for _, opcode := range moves {
+				for index, operand := range operands {
+					name := fmt.Sprintf("Value%s%d", opcode, index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s %s,AX\n%s AX,ret+0(FP)\nRET\n", name, word, opcode, operand, move)
+					fmt.Fprintf(&declarations, "func %s() uintptr\n", name)
+				}
+			}
+			dataRelocationGoObject(t, source.String(), target.goos, target.goarch, true)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.goarch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("complete native-word address forms: %s: %v", api, err)
+				}
+				for _, irLevel := range []string{"0", "2"} {
+					objectIR := ir
+					if irLevel == "2" {
+						objectIR = x86DwordProductIROptimize(t, ir)
+					}
+					for _, backendLevel := range []string{"0", "2"} {
+						t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, objectIR, "-O"+backendLevel)
+						})
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86StaticAddressValueDoesNotAuthorizeNativeDereference(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, form := range []string{"load", "address"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+form+"/"+api, func(t *testing.T) {
+					source := x86RelocationResultSource(target.arch, form)
+					source = strings.Replace(source, move+" AX,ret+0(FP)", "MOVB (AX),CX\n"+move+" AX,ret+0(FP)", 1)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					pkg := mustGoPackage(t, "address", "package address\nfunc Value() uintptr")
+					sigs, err := goSigsForAsmFile(pkg, file, func(name string) string {
+						return strings.TrimPrefix(name, "·")
+					}, target.arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sigs["Value"], target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("DATA identity authorized an unpaired native read", err)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", target.arch, target.triple, api)
+					if form == "load" {
+						// Loading a logical DATA relocation retains its independent
+						// source boundary; it is not a numerical native-load input.
+						if err == nil || ir != "" {
+							t.Fatal("logical relocation acquired a native-memory role", err)
+						}
+						return
+					}
+					if err != nil || !strings.Contains(ir, "load volatile i8,") {
+						t.Fatal("initialized address lost its paired native read", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_data_address_test.go b/x86_result_data_address_test.go
new file mode 100644
index 000000000..c2a209180
--- /dev/null
+++ b/x86_result_data_address_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86StaticAddressValueDirectoryRejectsAliasesAndCode(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, mutation := range []string{
+			"external target", "code target", "signature target", "signature alias",
+			"coalesced holder", "coalesced target", "unresolved extent", "oversize target",
+			"overlap holder", "code carrier", "block address", "prepared code address",
+			"wrong relocation width", "mixed relocation", "missing target",
+		} {
+			t.Run(arch+"/"+mutation, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, x86RelocationResultSource(arch, "load"))
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(symbol string) string {
+					return strings.TrimPrefix(strings.TrimPrefix(symbol, "·"), "alias-")
+				}
+				key := x86StaticSBAddress{"box<>", 8}
+				if values := x86LoweredStaticAddressValues(file, resolve, nil, arch); values == nil || !values.cells[key] {
+					t.Fatal("complete original relocation is missing")
+				}
+				var sigs map[string]FuncSig
+				switch mutation {
+				case "external target":
+					file.Data[1].Addr = "external(SB)"
+				case "code target":
+					file.Funcs = append(file.Funcs, Func{Sym: "bytes<>"})
+				case "signature target":
+					sigs = map[string]FuncSig{"bytes<>": {Ret: Void}}
+				case "signature alias":
+					sigs = map[string]FuncSig{"other": {Ret: Void, Name: "bytes<>"}}
+				case "coalesced holder":
+					file.Globl = append(file.Globl, GloblStmt{Sym: "alias-box<>", Size: 24})
+				case "coalesced target":
+					file.Globl = append(file.Globl, GloblStmt{Sym: "alias-bytes<>", Size: 16})
+				case "unresolved extent":
+					file.Globl[0].SizeRaw = "missing"
+				case "oversize target":
+					file.Globl[0].Size = maxDataGlobalSize + 1
+				case "overlap holder":
+					file.Data = append(file.Data, DataStmt{Sym: "box<>", Off: 8, Width: 1, Value: 1})
+				case "code carrier":
+					file.x86ContinuationGraph = &x86ContinuationGraph{tables: map[string]x86ContinuationTable{"box<>": {}}}
+				case "block address":
+					file.x86ContinuationGraph = &x86ContinuationGraph{addresses: map[string]x86Continuation{"bytes<>": {root: "Value", label: "inner"}}}
+				case "prepared code address":
+					file.Funcs[0].x86ContinuationAddresses = map[string]x86Continuation{"bytes<>": {root: "Value", label: "inner"}}
+				case "wrong relocation width":
+					file.Data[1].Width /= 2
+				case "mixed relocation":
+					file.Data[1].Value = 1
+				case "missing target":
+					file.Data, file.Globl = file.Data[1:], file.Globl[1:]
+				}
+				if values := x86LoweredStaticAddressValues(file, resolve, sigs, arch); values != nil && values.cells[key] {
+					t.Fatal("unclosed object or code identity supplied a numerical DATA address", mutation)
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticAddressValueWritesOnlyNumericalDestination(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, form := range []string{"load", "address"} {
+			for _, prior := range []uint8{0, 0x55, 0xff} {
+				t.Run(fmt.Sprintf("%s/%s/%x", arch, form, prior), func(t *testing.T) {
+					file, err := Parse(ArchAMD64, x86RelocationResultSource(arch, form))
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+					context := &amd64Ctx{resolve: resolve, fpStaticAddressValues: x86LoweredStaticAddressValues(file, resolve, nil, arch)}
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.gp[0], state.gp[2], state.canonicalGP[0] = prior, 0x55, 0xff
+					state.pointerGP[0], state.pointerGP[2] = true, true
+					state.callerAddressGP[0], state.callerAddressGP[2] = true, true
+					state.callerAddressOrigin[0], state.callerAddressOrigin[2] = 8, 9
+					state.resultAddressGP[0] = x86ResultSlotAddress{start: 0, end: 8, valid: true}
+					expected := state.clone()
+					expected.gp[0], expected.canonicalGP[0] = 0xff, 0
+					if arch == "386" {
+						expected.canonicalGP[0] = 0xf0
+					}
+					expected.pointerGP[0], expected.callerAddressGP[0], expected.callerAddressOrigin[0] = false, false, 0
+					expected.resultAddressGP[0] = x86ResultSlotAddress{}
+					var move Instr
+					for _, ins := range file.Funcs[0].Instrs {
+						if len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+							move = ins
+							break
+						}
+					}
+					accepted, known := context.scalarStaticAddressValueTransfer(move, &state, nil, arch)
+					if !accepted || !known || !reflect.DeepEqual(state, expected) {
+						t.Fatalf("address value changed another state domain: accepted=%t known=%t", accepted, known)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86StaticAddressValuesCannotSupplyDeclarationOnlyProof(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, form := range []string{"load", "address"} {
+			t.Run(arch+"/"+form, func(t *testing.T) {
+				_, _, signature, _ := x86ResultInitializationFixture(t, arch, "func Value() uintptr", "RET")
+				file, err := Parse(ArchAMD64, x86RelocationResultSource(arch, form))
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], signature, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone declaration query acquired an emitted module", err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_data_relocation_test.go b/x86_result_data_relocation_test.go
new file mode 100644
index 000000000..28ac6f7c4
--- /dev/null
+++ b/x86_result_data_relocation_test.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A complete, same-module DATA address value is distinct from an unknown
+// incoming pointer or arbitrary bytes read through one. These tests require
+// returning the actual relocated bits, not granting a dereference capability.
+func x86RelocationResultSource(arch, form string) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	value := "box<>+8(SB)"
+	if form == "address" {
+		value = "$bytes<>+3(SB)"
+	}
+	return fmt.Sprintf("DATA bytes<>(SB)/8,$0x1122334455667788\nGLOBL bytes<>(SB),16,$16\n"+
+		"DATA box<>+8(SB)/%d,$bytes<>+3(SB)\nGLOBL box<>(SB),16,$24\n"+
+		"TEXT ·Value(SB),4,$0-%d\n%s %s,AX\n%s AX,ret+0(FP)\nRET\n",
+		word, word, move, value, move)
+}
+
+func TestX86SameModuleRelocationValueOriginalGoObjects(t *testing.T) {
+	for _, target := range dataRelocationTargets {
+		if target.arch != ArchAMD64 {
+			continue
+		}
+		for _, form := range []string{"load", "address"} {
+			t.Run(target.triple+"/"+form, func(t *testing.T) {
+				dataRelocationGoObject(t, x86RelocationResultSource(target.goarch, form), target.goos, target.goarch, true)
+			})
+		}
+	}
+}
+
+func TestX86SameModuleRelocationValuesThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, form := range []string{"load", "address"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+form+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, x86RelocationResultSource(target.arch, form),
+						"func Value() uintptr", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete DATA relocation cannot publish its address value", err)
+					}
+					if !strings.Contains(ir, "ptrtoint") {
+						t.Fatal("relocation lost its native address-valued initializer")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RelocationValueDoesNotGrantIncomingPointerOrPartialBytes(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, role := range []string{"incoming-pointer", "partial-address", "shifted-cell", "unknown-source"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+role+"/"+api, func(t *testing.T) {
+					source := x86RelocationResultSource(target.arch, "load")
+					declaration := "func Value() uintptr"
+					switch role {
+					case "incoming-pointer":
+						source = fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s AX,ret+%d(FP)\nRET\n", 2*word, move, move, word)
+						declaration = "func Value(p *byte) uintptr"
+					case "partial-address":
+						source = strings.Replace(source, move+" box<>+8(SB),AX", "MOVB box<>+8(SB),AX", 1)
+					case "shifted-cell":
+						source = strings.Replace(source, move+" box<>+8(SB),AX", move+" box<>+9(SB),AX", 1)
+					case "unknown-source":
+						source = strings.Replace(source, move+" box<>+8(SB),AX", move+" unknown+8(SB),AX", 1)
+					}
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err == nil || ir != "" {
+						t.Fatal("literal address value manufactured broader numerical inputs", role, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86StaticAddressValuesRequireWholeResultProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, form := range []string{"load", "address"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+form+"/"+api, func(t *testing.T) {
+					source := x86RelocationResultSource(target.arch, form)
+					source = strings.Replace(source, move+" AX,ret+0(FP)\n", "", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", target.arch, target.triple, api); err == nil || ir != "" {
+						t.Fatal("missing result acquired an initialized implementation alloca", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_dead_source.go b/x86_result_dead_source.go
new file mode 100644
index 000000000..b3b91f5e6
--- /dev/null
+++ b/x86_result_dead_source.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// Shape-only validation may assume register classes, never an external native
+// address or a read mask. These operands retain their source-input obligations
+// even when a constant selector, zero mask or unreachable result discards data.
+// Logical FP/AUTO and independently bound SB/DATA keep their separate owners.
+func x86ResultDeadExternalInputs(ins Instr, arch string) bool {
+	externalMemory := func(operand Operand) bool {
+		if operand.Kind != OpMem || operand.Mem.Sym != "" || x86LogicalSourceFrameRegister(operand.Mem.Base, arch) {
+			return false
+		}
+		_, _, base := x86ResultGP(operand.Mem.Base, x86ResultPointerWord(arch), arch)
+		_, _, index := x86ResultGP(operand.Mem.Index, x86ResultPointerWord(arch), arch)
+		return base || index
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if (operand.read || operand.write) && externalMemory(operand.operand) {
+				return true
+			}
+			if _, mask := amd64ParseKReg(operand.operand.Reg); operand.read && mask {
+				return true
+			}
+		}
+		// Typed address calculations may spell OpMem in the source while
+		// describing only GP inputs. Syntax alone must not invent a read.
+		return false
+	}
+	for _, operand := range ins.Args {
+		if externalMemory(operand) {
+			return true
+		}
+	}
+	// Families without a byte descriptor still expose their explicit K input
+	// before the final output. A final write-only K result is not an input.
+	for index, operand := range ins.Args {
+		if index == len(ins.Args)-1 {
+			break
+		}
+		if _, mask := amd64ParseKReg(operand.Reg); operand.Kind == OpReg && mask {
+			return true
+		}
+	}
+	return false
+}
+
+// This is a separate source-closure proof, never an executable CFG edge or an
+// entry/backing permission. Reachable states and result checks remain unchanged.
+// A dead region starts with the real poststate of its preceding verified source
+// terminator. Its local CFG also checks source fallthrough after dead JMP/RET,
+// so disconnected fragments cannot hide unknown external inputs. No dead state
+// may flow back into a reachable block or borrow a later reachable producer.
+func x86ResultCheckDeadExternalInputs(fn Func, instructions []Instr, ordinals []int, edges [][]int,
+	reached map[int]x86ResultState, owned []bool, resultOffset int64, arch string,
+	transfer x86ResultSourceTransfer, visits, work *int, byteState int) error {
+	var targets []int
+	for pc, ins := range instructions {
+		if _, live := reached[pc]; !live && x86ResultDeadExternalInputs(ins, arch) {
+			targets = append(targets, pc)
+		}
+	}
+	if len(targets) == 0 {
+		return nil // Pure dead register arithmetic retains its existing domain.
+	}
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: result initialization: dead external source %s", ErrProbeNeedsContext, reason)
+	}
+	if fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil {
+		return fail("requires its own source-graph entry, not a neighboring function's state")
+	}
+	reserve := func(bytes int, visit bool) error {
+		*work += bytes
+		if visit {
+			*visits = *visits + 1
+		}
+		if budget := fn.x86ResultFlowBudget; budget != nil {
+			budget.bytes += bytes
+			if visit {
+				budget.visits++
+			}
+			if budget.bytes > 64<<20 || budget.visits > 16384 {
+				return fail("exhausted the combined source-graph work budget")
+			}
+		}
+		if *work > 64<<20 || *visits > 16384 {
+			return fail("exhausted the combined function work budget")
+		}
+		return nil
+	}
+	// One bounded graph/queue observation, shared by all dead components.
+	if err := reserve(64*len(instructions), false); err != nil {
+		return err
+	}
+	successors := func(pc int, observe func(int, int)) {
+		hasNext := false
+		for edge, target := range edges[pc] {
+			hasNext = hasNext || target == pc+1
+			if _, live := reached[target]; !live {
+				observe(edge, target)
+			}
+		}
+		if target := pc + 1; !hasNext && target < len(instructions) {
+			if _, live := reached[target]; !live {
+				observe(len(edges[pc]), target)
+			}
+		}
+	}
+	reverse := make([][]int, len(instructions))
+	for pc := range instructions {
+		if _, live := reached[pc]; !live {
+			successors(pc, func(_ int, target int) { reverse[target] = append(reverse[target], pc) })
+		}
+	}
+	needed := make([]bool, len(instructions))
+	for _, target := range targets {
+		needed[target] = true
+	}
+	for cursor := 0; cursor < len(targets); cursor++ {
+		for _, previous := range reverse[targets[cursor]] {
+			if !needed[previous] {
+				needed[previous] = true
+				targets = append(targets, previous)
+			}
+		}
+	}
+	states := make(map[int]x86ResultState)
+	var queue []int
+	join := func(pc int, next x86ResultState) {
+		if previous, exists := states[pc]; exists {
+			merged := previous.intersect(next)
+			if reflect.DeepEqual(previous, merged) {
+				return
+			}
+			states[pc] = merged
+		} else {
+			states[pc] = next.clone()
+		}
+		queue = append(queue, pc)
+	}
+	for pc := range instructions {
+		if !needed[pc] || pc == 0 {
+			continue
+		}
+		if before, live := reached[pc-1]; live {
+			if err := reserve(8*byteState, true); err != nil {
+				return err
+			}
+			post := before.clone()
+			if instructions[pc-1].Op != OpRET && !transfer(ordinals[pc-1], instructions[pc-1], &post, owned, resultOffset, arch) {
+				return fail("lost its previously verified predecessor")
+			}
+			join(pc, post)
+		}
+	}
+	for cursor := 0; cursor < len(queue); cursor++ {
+		if err := reserve(8*byteState, true); err != nil {
+			return err
+		}
+		pc := queue[cursor]
+		state := states[pc].clone()
+		ins := instructions[pc]
+		if ins.Op != OpRET && !transfer(ordinals[pc], ins, &state, owned, resultOffset, arch) {
+			return fail(fmt.Sprintf("has undefined context at instruction %d: %s", pc, ins.Raw))
+		}
+		successors(pc, func(edge, target int) {
+			if needed[target] {
+				join(target, x86ResultPredicateEdge(state, ins, edge))
+			}
+		})
+	}
+	for _, target := range targets {
+		if _, closed := states[target]; !closed {
+			return fail("has no source-bound component entry")
+		}
+	}
+	return nil
+}
diff --git a/x86_result_direction.go b/x86_result_direction.go
new file mode 100644
index 000000000..9437d4ff4
--- /dev/null
+++ b/x86_result_direction.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+// Must-defined DF with an independent value domain. A mixed forward/backward
+// join is defined but not a chosen direction. Unknown entry DF stays unknown;
+// no ABI, declaration or initialized six-status mask seeds it.
+type x86ResultDirection uint8
+
+const (
+	x86ResultDirectionUnknown  x86ResultDirection = 0
+	x86ResultDirectionForward  x86ResultDirection = 1
+	x86ResultDirectionBackward x86ResultDirection = 2
+	x86ResultDirectionEither   x86ResultDirection = 3
+)
+
+func (direction x86ResultDirection) intersect(other x86ResultDirection) x86ResultDirection {
+	if direction == x86ResultDirectionUnknown || other == x86ResultDirectionUnknown {
+		return x86ResultDirectionUnknown
+	}
+	return direction | other
+}
+
+func x86ResultDirectionStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	spec, known, err := x86DirectionControlProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	state.direction = x86ResultDirectionForward
+	if spec.backward {
+		state.direction = x86ResultDirectionBackward
+	}
+	return true, true
+}
+
+// Applied after every independently accepted source transfer, including
+// private CALL/stack roles. This never authorizes those operations. Unknown
+// physical effects and callee/FLAGS restoration cannot retain a prior DF fact.
+func x86ResultDirectionAfter(ins Instr, direction x86ResultDirection) x86ResultDirection {
+	if x86MaskLogicalPreservesStorage(ins) || x86EnqueuePreservesStorage(ins) {
+		return direction
+	}
+	if x86RegisterQueryPreservesSourceState(ins) || x86WaitPackagePreservesStorage(ins) || x86PreservesNumericalSourceState(ins) {
+		return direction
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.Op == OpCALL {
+		return x86ResultDirectionUnknown
+	}
+	if spec, known := amd64StackWidthSpecs[ins.Op]; known && spec.mode == amd64StackPopFlags {
+		return x86ResultDirectionUnknown
+	}
+	if spec, known := amd64FarReturnSpecs[ins.Op]; known && spec.kind == amd64InterruptReturn {
+		return x86ResultDirectionUnknown
+	}
+	return direction
+}
+
+// Only the paired source-flow consumer has a target mode and authenticated
+// raw product. Preserve an existing DF fact without making that data-changing
+// operation inert or extending the standalone observer's raw-source boundary.
+func x86ResultDirectionAfterSource(ins Instr, direction x86ResultDirection, arch string) x86ResultDirection {
+	if x86RawCOMISource(ins, arch) {
+		return direction // Six scalar status writes do not change the independent DF control.
+	}
+	if x86RawMULXSource(ins, arch) {
+		return direction // The exact integer product does not write DF.
+	}
+	if x86RawZeroExtendSource(ins, arch) {
+		return direction // Exact widening writes no independent DF control.
+	}
+	if x86RawPermute128Source(ins, arch) {
+		return direction // Exact vector selection does not write the independent DF domain.
+	}
+	if x86FMA3PreservesPrivateSourceState(ins, arch) {
+		return direction // The original floating operation does not write DF.
+	}
+	if x86RawBlendMinposSource(ins, arch) {
+		return direction // The exact data selection/reduction has no FLAGS/DF write.
+	}
+	if x86RawImmediateBlendSource(ins, arch) {
+		return direction // Exact immediate selection does not write the independent DF domain.
+	}
+	if x86RawScalarPrecisionSource(ins, arch) || x86RawScalarFloatIntegerSource(ins, arch) ||
+		x86RawPackedPrecisionSource(ins, arch) || x86RawNamedHalfSource(ins, arch) {
+		return direction // Native MXCSR effects do not alter the independent DF control.
+	}
+	if x86RawExplicitMaskMoveSource(ins, arch) {
+		return direction // The exact masked move has no FLAGS/DF write.
+	}
+	if x86RawPackedDotSource(ins, arch) {
+		return direction // The exact integer dot operation does not write DF.
+	}
+	if x86RawUnalignedLoadSource(ins, arch) {
+		return direction
+	}
+	if x86RawIntegerMinMaxSource(ins, arch) {
+		return direction // The exact vector operation has no DF effect.
+	}
+	if x86RawTernaryLogicSource(ins, arch) {
+		return direction // The data-changing Boolean operation leaves the existing DF unchanged.
+	}
+	if x86RawLegacyFloatCompareSource(ins, arch) {
+		return direction // MXCSR effects do not write the independent DF control.
+	}
+	if x86FloatMinMaxPreservesSourceState(ins, arch) {
+		return direction // Native MXCSR effects do not change the independent DF input.
+	}
+	if x86RawPackedConversionSource(ins, arch) || x86RawPackedReductionSource(ins, arch) || x86RawDwordProductResultSource(ins, arch) || x86RawCMOVSource(ins, arch) ||
+		x86RawAESSource(ins, arch) || x86RawSHASource(ins, arch) || x86RawVectorTestSource(ins, arch) || x86RawIFMASource(ins, arch) ||
+		x86RawQwordLookupSource(ins, arch) || x86RawPackedIntegerCompareSource(ins, arch) ||
+		x86RawImmediatePackedCompareSource(ins, arch) || x86RawBroadcastSource(ins, arch) || x86RawCLMULSource(ins, arch) {
+		return direction
+	}
+	return x86ResultDirectionAfter(ins, direction)
+}
diff --git a/x86_result_dword_product.go b/x86_result_dword_product.go
new file mode 100644
index 000000000..0e93e9dfd
--- /dev/null
+++ b/x86_result_dword_product.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+func x86RawDwordProductResultSource(ins Instr, arch string) bool {
+	form, known, err := x86DwordProductProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.legacy && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// The decoder's exact original opcode and operands permit only this paired
+// numerical continuation. Declaration queries and raw entries gain nothing.
+func x86LoweredDwordProductResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86DwordProductProperties(ins.Op, ins, arch)
+	if !known || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if err != nil || !x86RawDwordProductResultSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultFixedVectorInputsWithRead(local, form.x86PackedBinaryForm, false, state, owned, arch, true), true
+}
diff --git a/x86_result_dword_product_test.go b/x86_result_dword_product_test.go
new file mode 100644
index 000000000..cd71f4c4d
--- /dev/null
+++ b/x86_result_dword_product_test.go
@@ -0,0 +1,201 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// The original format probes declare a frame but never initialize vector or
+// address inputs. Keep all three public Context checks and original emitter
+// objects; the separate initialized matrices below own public object success.
+func x86DwordProductOriginalFormatObject(t *testing.T, source, declarations, arch, triple string, frame int64) string {
+	t.Helper()
+	_, declarations, found := strings.Cut(declarations, "\n")
+	if !found {
+		t.Fatal("original format declarations lost their package header")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("original formats invented vector, mask or native address inputs", api, err)
+		}
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "formatprobe", "package formatprobe\n"+declarations)
+	signatures := make(map[string]FuncSig)
+	for _, function := range file.Funcs {
+		name := strings.TrimPrefix(function.Sym, "·")
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		signatures[name] = sig
+	}
+	file, err = normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, frame,
+		func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+			return c.lowerDwordToQwordMultiply(ins.Op, ins)
+		})
+}
+
+// These four names and the complete encoder rows are independently checked in
+// TestX86DwordProductCompleteIndependentEncoderRows. Reuse the common native
+// input matrix, not the implementation's registry.
+func x86DwordProductResultRows(arch string) []struct{ op, bank, mode string } {
+	return x86FixedBinaryValueRows(arch, []string{"PMULDQ", "PMULULQ", "VPMULDQ", "VPMULUDQ"})
+}
+
+func TestX86DwordProductPairedNativeReadCompleteFamily(t *testing.T) {
+	x86FixedBinaryCompleteFamilyObjects(t, x86DwordProductResultRows, 20, 8)
+}
+
+func TestX86DwordProductPairedNativeReadCannotBorrowInputs(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, x86DwordProductResultRows)
+}
+
+func TestX86DwordProductVoidCannotInventRegisterInputs(t *testing.T) {
+	x86FixedBinaryVoidInputBoundaries(t, x86DwordProductResultRows)
+}
+
+func TestX86DwordProductRawPairedNativeObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, row := range x86FixedBinaryValueRows("amd64", []string{
+				"VPMULDQ", "VPMULUDQ", "VPMULDQ.BCST", "VPMULUDQ.BCST",
+			}) {
+				body, declaration := x86FixedBinaryValueFixture(target.arch, row.op, row.bank, row.mode, false)
+				file, err := Parse(ArchAMD64, body)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var instruction string
+				for _, ins := range file.Funcs[0].Instrs {
+					if strings.HasPrefix(string(ins.Op), "VPMULDQ") || strings.HasPrefix(string(ins.Op), "VPMULUDQ") {
+						instruction = ins.Raw
+					}
+				}
+				if instruction == "" {
+					t.Fatal("independent source lost its arithmetic instruction")
+				}
+				code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+				body = strings.Replace(body, instruction, x86DwordProductDirectives(code[:len(code)-1]), 1)
+				name := fmt.Sprintf("ProductRaw%d", count)
+				source.WriteString(strings.ReplaceAll(body, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+				count++
+			}
+			if count != 36 {
+				t.Fatal("complete raw full/broadcast/mask denominator changed", count)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("exact raw input source lost its paired native continuation", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86DwordProductRawVoidCannotInventInputs(t *testing.T) {
+	for _, row := range x86FixedBinaryValueRows("386", []string{"VPMULDQ", "VPMULUDQ"}) {
+		instruction := fmt.Sprintf("%s %s0,%s1,%s2", row.op, row.bank, row.bank, row.bank)
+		code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+		source := "TEXT ·Value(SB),4,$0-0\n" + x86DwordProductDirectives(code[:len(code)-1]) + "RET\n"
+		for _, target := range x86RawReturnTargets {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("raw Void opcode borrowed zeroed implementation registers", instruction, target.triple, api, err)
+				}
+			}
+		}
+	}
+}
+
+func TestX86DwordProductRawSourceCannotBeRebound(t *testing.T) {
+	for _, name := range []string{"VPMULDQ", "VPMULUDQ"} {
+		for _, instruction := range []string{
+			name + " X0,X1,X2", name + " Y0,Y1,Y2", name + " Z0,Z1,K1,Z2",
+			name + ".BCST.Z 8(AX),Y1,K1,Y2",
+		} {
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86DwordProductDirectives(code[:len(code)-1])+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, arch := range []string{"386", "amd64"} {
+				normalized, err := normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := normalized.Funcs[0].Instrs[1]
+				if !x86RawDwordProductResultSource(ins, arch) {
+					t.Fatal("fresh original physical source was not bound", instruction, arch)
+				}
+				if !x86ResultPreservesPrivateStorage(ins, arch) || x86PreservesNumericalSourceState(ins) {
+					t.Fatal("product private-control preservation was confused with inert numerical state")
+				}
+				for _, direction := range []x86ResultDirection{x86ResultDirectionUnknown,
+					x86ResultDirectionForward, x86ResultDirectionBackward, x86ResultDirectionEither} {
+					if x86ResultDirectionAfterSource(ins, direction, arch) != direction ||
+						x86ResultDirectionAfter(ins, direction) != x86ResultDirectionUnknown {
+						t.Fatal("paired product invented DF or granted a standalone raw-source fact")
+					}
+				}
+				state := x86ResultState{valueStack: &x86ResultValueStack{bytes: []uint8{255, 255}, id: true}}
+				if !x86ResultValueStackContinuation(ins, &state, arch) {
+					t.Fatal("exact product revoked independent live private storage")
+				}
+				for label, change := range map[string]func(*Instr){
+					"absent-origin": func(ins *Instr) { ins.x86SourceRaw = nil },
+					"opcode": func(ins *Instr) {
+						ins.Op = Op(strings.Replace(string(ins.Op), name, map[string]string{"VPMULDQ": "VPMULUDQ", "VPMULUDQ": "VPMULDQ"}[name], 1))
+					},
+					"destination": func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = "X3" },
+					"address":     func(ins *Instr) { ins.x86AddressBits = 32 },
+					"segment":     func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+					"literal":     func(ins *Instr) { ins.x86RIPLiteral = true },
+				} {
+					t.Run(arch+"/"+instruction+"/"+label, func(t *testing.T) {
+						changed := ins
+						changed.Args = append([]Operand(nil), ins.Args...)
+						change(&changed)
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						before := state.clone()
+						accepted, known := x86LoweredDwordProductResultStep(changed, &state, nil, arch)
+						if accepted || !known || x86RawDwordProductResultSource(changed, arch) || !reflect.DeepEqual(before, state) {
+							t.Fatal("changed raw source borrowed a paired numerical continuation", accepted, known)
+						}
+						if x86ResultPreservesPrivateStorage(changed, arch) ||
+							x86ResultDirectionAfterSource(changed, x86ResultDirectionEither, arch) != x86ResultDirectionUnknown {
+							t.Fatal("changed raw source borrowed private storage or DF preservation")
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_exchange_memory.go b/x86_result_exchange_memory.go
new file mode 100644
index 000000000..51d6a0cf4
--- /dev/null
+++ b/x86_result_exchange_memory.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import "strings"
+
+// This is the numerical continuation of the already paired, complete native
+// XADD/XCHG sideeffect opcode. The read/write cycle retains native faults and
+// ordering. It grants no reusable pointee, write envelope, alignment, frame,
+// caller, raw-entry or declaration-query permission.
+func x86LoweredExchangeResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86LoweredExchangeResultStepWithAddressBits(ins, state, owned, arch, false)
+}
+
+func x86LoweredExchangeResultStepWithAddressBits(ins Instr, state *x86ResultState, owned []bool, arch string, addressBits bool) (bool, bool) {
+	name := Op(strings.ToUpper(string(ins.Op)))
+	spec, known := amd64ExchangeSpecs[name]
+	if !known {
+		return false, false
+	}
+	form, err := parseAMD64ExchangeForm(arch, name, spec, ins)
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if form.other.Kind == OpReg && spec.kind == amd64ExchangeSwap {
+		return false, false // Keep the independent register/opaque/NOP consumer.
+	}
+	width := int64(spec.bits / 8)
+	numeric := x86ResultRead(form.register, width, state, owned, arch)
+	if !numeric {
+		root, _, valid := x86ResultGP(form.register.Reg, width, arch)
+		if !addressBits || spec.kind != amd64ExchangeSwap || form.other.Kind != OpMem ||
+			width != x86ResultPointerWord(arch) || !valid || x86LogicalSourceFrameRegister(form.register.Reg, arch) ||
+			!state.pointerGP[root] || !state.callerAddressGP[root] {
+			return false, true
+		}
+	}
+	outputs := []Operand{form.register}
+	if form.other.Kind == OpReg {
+		if !x86ResultRead(form.other, width, state, owned, arch) {
+			return false, true
+		}
+		outputs = append(outputs, form.other)
+	} else if !x86ResultNativeRMWAddress(ins, form.other, state, owned, arch) {
+		return false, true // No FP/AUTO, SB or numerical base witness.
+	}
+	if !x86ResultExchangeWriteback(spec, outputs, state, owned, arch) {
+		return false, true
+	}
+	if !numeric {
+		for _, operand := range outputs {
+			index, mask, _ := x86ResultGP(operand.Reg, width, arch)
+			// The complete caller word may be copied as opaque data. Its
+			// unknown native replacement supplies neither NUM nor a pointer.
+			state.gp[index] &^= mask
+		}
+	}
+	return true, true // XCHG preserves arithmetic FLAGS; both preserve DF.
+}
+
+// Each paired consumer checks its actual inputs/storage before this shared
+// numerical output step. Validate every destination before any aliased write.
+func x86ResultExchangeWriteback(spec amd64ExchangeSpec, outputs []Operand, state *x86ResultState, owned []bool, arch string) bool {
+	width := int64(spec.bits / 8)
+	for _, operand := range outputs {
+		if _, _, valid := x86ResultGP(operand.Reg, width, arch); operand.Kind != OpReg || !valid {
+			return false
+		}
+	}
+	for _, operand := range outputs {
+		index, mask, _ := x86ResultGP(operand.Reg, width, arch)
+		x86ResultStore(operand, width, state, owned, 0, arch)
+		state.canonicalGP[index] &^= mask
+		state.callerAddressGP[index] = false
+		state.callerAddressOrigin[index] = 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	if spec.kind == amd64ExchangeAdd {
+		state.flags = x86ByteFlagsAll
+	}
+	return true
+}
diff --git a/x86_result_explicit_mask_move.go b/x86_result_explicit_mask_move.go
new file mode 100644
index 000000000..17ab660f8
--- /dev/null
+++ b/x86_result_explicit_mask_move.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+// An absent snapshot is not evidence of the decoder's actual VEX mode.
+type x86RawExplicitMaskMoveIdentity struct {
+	arch    string
+	encoded bool
+}
+
+func x86ExplicitMaskMoveRawIdentity(ins Instr, arch string) x86RawExplicitMaskMoveIdentity {
+	if _, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, arch); !known || err != nil || !ins.x86Encoded {
+		return x86RawExplicitMaskMoveIdentity{}
+	}
+	return x86RawExplicitMaskMoveIdentity{arch, true}
+}
+
+func x86RawExplicitMaskMoveSource(ins Instr, arch string) bool {
+	f, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, arch)
+	return known && err == nil && ins.x86SourceRaw != nil &&
+		ins.x86SourceRaw.explicitMaskMove.arch == arch &&
+		ins.x86SourceRaw.explicitMaskMove == x86ExplicitMaskMoveRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, f.memory) && x86Mode32VectorRegisterContext(ins, arch) == nil
+}
+
+func x86ExplicitMaskMoveRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay == nil {
+		return false
+	}
+	for _, ins := range fn.x86RawReplay.decoded {
+		if _, known, _ := x86ExplicitMaskMoveProperties(ins.Op, ins, arch); known {
+			return true
+		}
+	}
+	return false
+}
+
+// Continued execution of the exact paired operation supplies active loaded
+// lanes; inactive lanes are zero. This grants no backing, bounds, future-read
+// fact or entry permission. Stores change no numerical memory facts.
+func x86ResultExplicitMaskMoveStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, native bool) (bool, bool) {
+	f, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil || x86Mode32VectorRegisterContext(ins, arch) != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawExplicitMaskMoveSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil // This exact paired effect only.
+	}
+	mask, _ := amd64VectorRegisterIndex(ins.Args[1].Reg, f.byteWidth)
+	if required := f.signByteInputs(); state.vectorBytes(mask)&required != required {
+		return false, true
+	}
+	width := int64(f.byteWidth)
+	memory := ins.Args[f.memory]
+	if !f.load && (memory.Kind == OpFP && memory.FPOffset < resultOffset || memory.Kind == OpSym ||
+		memory.Kind == OpMem && memory.Mem.Sym != "") {
+		return false, true // Readable parameter/static bytes are not a writable result/backing role.
+	}
+	if !f.load && !x86ResultPackedVectorRead(ins.Args[0], width, state, owned, arch) {
+		return false, true
+	}
+	if native && ins.x86NumericalRead == nil && x86OrdinaryNativeMemoryOperand(memory, arch) {
+		address := x86ResultIncomingPointerAddressIdentity(memory, state, arch)
+		if f.load {
+			address = x86ResultIncomingPointerReadAddressIdentity(memory, state, arch)
+		}
+		if !address {
+			return false, true
+		}
+	} else if !x86ResultRead(memory, width, state, owned, arch) {
+		// A logical masked store cannot initialize an unknown old byte: an
+		// inactive lane preserves it. A full prior NUM tuple stays NUM.
+		return false, true
+	}
+	if f.load {
+		destination, _ := amd64VectorRegisterIndex(ins.Args[2].Reg, f.byteWidth)
+		state.writeVector(destination, f.byteWidth, x86CallerVectorByteMask(width), false)
+	}
+	return true, true // FLAGS, DF, GP, mask and all memory facts are unchanged.
+}
+
+func x86CallerExplicitMaskMoveStep(ins *Instr, f x86ExplicitMaskMoveForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	mask := x86CallerVectorRoot(ins.Args[1].Reg)
+	if required := f.signByteInputs(); state.vectors[mask]&required != required {
+		return false
+	}
+	if !f.load {
+		data := x86CallerVectorRoot(ins.Args[0].Reg)
+		required := x86CallerVectorByteMask(int64(f.byteWidth))
+		if state.vectors[data]&required != required {
+			return false
+		}
+	}
+	if !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.byteWidth), !f.load) {
+		return false // The possible full tuple keeps independent caller bounds.
+	}
+	if f.load {
+		state.vectors[x86CallerVectorRoot(ins.Args[2].Reg)] = ^uint64(0)
+	}
+	return true
+}
diff --git a/x86_result_fixed_lane_value_test.go b/x86_result_fixed_lane_value_test.go
new file mode 100644
index 000000000..f75c57dfa
--- /dev/null
+++ b/x86_result_fixed_lane_value_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent Go optab/attribute inventory, never the production registry.
+type x86FixedLaneValueOracle struct {
+	name                        string
+	immediate, unary, broadcast bool
+}
+
+var x86GFNIResultOracle = []x86FixedLaneValueOracle{
+	{"VGF2P8MULB", false, false, false},
+	{"VGF2P8AFFINEQB", true, false, true},
+	{"VGF2P8AFFINEINVQB", true, false, true},
+}
+
+var x86BitCountResultOracle = []x86FixedLaneValueOracle{
+	{"VPOPCNTB", false, true, false}, {"VPOPCNTW", false, true, false},
+	{"VPOPCNTD", false, true, true}, {"VPOPCNTQ", false, true, true},
+	{"VPLZCNTD", false, true, true}, {"VPLZCNTQ", false, true, true},
+}
+
+func x86FixedLaneValueResultFixture(member x86FixedLaneValueOracle, bank, mode, input string, immediate int) string {
+	op, mask, second, control := member.name, "", bank+"1,", ""
+	if input == "broadcast" {
+		op, input = op+".BCST", "table<>(SB)"
+	}
+	if mode != "plain" {
+		mask = "K1,"
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	if member.unary {
+		second = ""
+	}
+	if member.immediate {
+		control = fmt.Sprintf("$%d,", immediate)
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nKMOVD AX,K1\n"+
+		"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nVPXORD Z3,Z3,Z3\n"+
+		"%s %s%s,%s%s%s2\nVPCOMPRESSQ Z2,K1,Z3\nPEXTRD $0,X3,AX\nMOVL AX,ret+0(FP)\nRET\n",
+		op, control, input, second, mask, bank)
+}
+
+func x86FixedLaneValueResultMatrix(t *testing.T, members []x86FixedLaneValueOracle, amd64Count, mode32Count int) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			source.WriteString("GLOBL table<>(SB),8,$64\n")
+			var names []string
+			for _, member := range members {
+				if target.arch == "386" && member.immediate {
+					continue // Named affine instructions require at least four operands.
+				}
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if target.arch == "386" && !member.unary && mode != "plain" {
+							continue
+						}
+						inputs := []string{bank + "0", "table<>(SB)"}
+						if member.broadcast {
+							inputs = append(inputs, "broadcast")
+						}
+						controls := []int{0}
+						if member.immediate {
+							controls = append(controls, 255)
+						}
+						for _, input := range inputs {
+							for _, immediate := range controls {
+								body := x86FixedLaneValueResultFixture(member, bank, mode, input, immediate)
+								name := fmt.Sprintf("Value%d", len(names))
+								names = append(names, name)
+								source.WriteString(strings.ReplaceAll(body, "Value", name))
+								declarations.WriteString("func " + name + "() uint32\n")
+							}
+						}
+					}
+				}
+			}
+			want := amd64Count
+			if target.arch == "386" {
+				want = mode32Count
+			}
+			if len(names) != want {
+				t.Fatal("independent value-family denominator changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized complete fixed-lane family rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+				})
+			}
+		})
+	}
+}
+
+func TestX86GFNIInitializedResultWholeFamily(t *testing.T) {
+	x86FixedLaneValueResultMatrix(t, x86GFNIResultOracle, 126, 6)
+}
+
+func TestX86PackedBitCountInitializedResultWholeFamily(t *testing.T) {
+	x86FixedLaneValueResultMatrix(t, x86BitCountResultOracle, 144, 144)
+}
+
+func TestX86FixedLaneValueResultInputsStayIndependent(t *testing.T) {
+	members := append(append([]x86FixedLaneValueOracle(nil), x86GFNIResultOracle...), x86BitCountResultOracle...)
+	for _, member := range members {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				source := x86FixedLaneValueResultFixture(member, bank, mode, bank+"0", 255)
+				missing := []string{"Z0", "result"}
+				if !member.unary {
+					missing = append(missing, "Z1")
+				}
+				if mode != "plain" {
+					missing = append(missing, "mask")
+				}
+				if mode == "merge" {
+					missing = append(missing, "Z2")
+				}
+				for _, omit := range missing {
+					body := strings.Replace(source, fmt.Sprintf("VPXORD %s,%s,%s", omit, omit, omit), "NOP", 1)
+					if omit == "result" {
+						body = strings.Replace(source, "MOVL AX,ret+0(FP)", "NOP", 1)
+					} else if omit == "mask" {
+						body = strings.Replace(source, "KMOVD AX,K1", "NOP", 1)
+					}
+					t.Run(member.name+"/"+bank+"/"+mode+"/"+omit, func(t *testing.T) {
+						goAssemblerOracleOutput(t, "amd64", body, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, body, "func Value() uint32", "amd64", "x86_64-unknown-linux-gnu", api)
+							if omit == "Z0" || omit == "Z1" || omit == "Z2" {
+								x86VectorScratchCodegenControl(t, body, "func Value() uint32", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+							} else if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("value family acquired an unknown input/result", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_flags_correlation.go b/x86_result_flags_correlation.go
new file mode 100644
index 000000000..adbe09131
--- /dev/null
+++ b/x86_result_flags_correlation.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// Zero is a defined bit, 1..32 identify an unknown entry FLAGS bit, and 255
+// is an untracked expression. XOR by a defined value preserves dependency;
+// XOR of identical tracked dependencies cancels it. No numerical value is
+// inferred, and two untracked expressions can never cancel each other.
+const x86FlagsUntracked = uint8(255)
+
+type x86ResultFlagsCorrelation struct {
+	flags  [32]uint8
+	bytes  [][8]uint8 // Same descending-byte order as the private value stack.
+	popped [32]uint8  // Only the immediately following instruction may consume it.
+}
+
+func x86FlagsXOROrigin(left, right uint8) uint8 {
+	if left == 0 {
+		return right
+	}
+	if right == 0 {
+		return left
+	}
+	if left == right && left != x86FlagsUntracked {
+		return 0
+	}
+	return x86FlagsUntracked
+}
+
+func x86ResultPrivateStackXORForm(ins Instr, arch string) (x86LockScalarRMWForm, int, bool) {
+	if arch != "386" || !x86ResultNamedPredicateInstruction(ins) {
+		return x86LockScalarRMWForm{}, 0, false
+	}
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.spec.stem != "XOR" {
+		return form, 0, false
+	}
+	for index, arg := range []Operand{form.source, form.destination} {
+		if arg.Kind != OpMem || arg.Mem.Base != SP {
+			continue
+		}
+		m := arg.Mem
+		if m.Sym != "" || m.OffRaw != "" || m.Index != "" || m.IndexExt != "" ||
+			m.Scale != 0 || m.Segment != "" || m.Off < 0 || m.Off > int64(x86ResultValueStackLimit(arch)) {
+			return form, 0, false
+		}
+		// Parsing intentionally erases AUTO names. Do not mistake saved+0(SP)
+		// for an offset within the private PUSH storage.
+		fields := strings.Fields(ins.Raw)
+		if len(fields) < 2 {
+			return form, 0, false
+		}
+		args := splitTopLevelCSV(strings.TrimSpace(ins.Raw[len(fields[0]):]))
+		if len(args) != 2 {
+			return form, 0, false
+		}
+		if strings.TrimSpace(args[index]) == "(SP)" {
+			return form, index, m.Off == 0
+		}
+		literal := x86ResultAUTOLiteral.FindStringSubmatch(args[index])
+		if literal == nil {
+			return form, 0, false
+		}
+		offset, err := strconv.ParseInt(strings.TrimSpace(literal[1]), 0, 64)
+		return form, index, err == nil && offset == m.Off
+	}
+	return form, 0, false
+}
+
+// Called only by the paired lowerer. Source replay and the shared CFG bind
+// the actual PUSH-owned byte storage; a declaration-only query gains nothing.
+func x86ResultPrivateFlagsSource(fn Func, arch string) (*x86ResultValueStack, error) {
+	if arch != "386" {
+		return nil, nil
+	}
+	needed := false
+	for _, ins := range fn.Instrs {
+		_, _, valid := x86ResultPrivateStackXORForm(ins, arch)
+		needed = needed || valid
+	}
+	if !needed {
+		return nil, nil
+	}
+	fail := func() (*x86ResultValueStack, error) {
+		return nil, fmt.Errorf("%w: private FLAGS correlation requires unchanged ordinary mode32 source", ErrProbeNeedsContext)
+	}
+	if len(fn.Instrs) == 0 || len(fn.Instrs) > 4096 || fn.Instrs[0].Op != OpTEXT ||
+		strings.Contains(fn.Sym, "<") || len(fn.X86RawText) != 0 || fn.x86RawReplay != nil ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86DirectTailRoot != nil ||
+		fn.x86ContinuationFlow != nil || fn.x86BoolCalls != nil {
+		return fail()
+	}
+	var source strings.Builder
+	for _, ins := range fn.Instrs {
+		if !x86ResultNamedPredicateInstruction(ins) || ins.Raw == "" || len(ins.Raw) > (1<<20)-source.Len()-1 {
+			return fail()
+		}
+		source.WriteString(ins.Raw)
+		source.WriteByte('\n')
+	}
+	parsed, err := Parse(ArchAMD64, source.String())
+	if err != nil || len(parsed.Funcs) != 1 || len(parsed.UnlinkedPrelude) != 0 || len(parsed.Data) != 0 || len(parsed.Globl) != 0 {
+		return fail()
+	}
+	original := parsed.Funcs[0]
+	instructions, err := x86ResultAUTOReplayInstructions(fn, arch)
+	if err != nil || original.Sym != fn.Sym || original.FrameSize != fn.FrameSize || original.ArgSize != fn.ArgSize ||
+		!reflect.DeepEqual(original.Instrs, instructions) {
+		return fail()
+	}
+	correlation := new(x86ResultFlagsCorrelation)
+	for bit := range correlation.flags {
+		correlation.flags[bit] = uint8(bit + 1)
+	}
+	return &x86ResultValueStack{correlation: correlation}, nil
+}
+
+func x86ResultFlagsStackPush(stack *x86ResultValueStack, known uint64, storage int, flags bool) {
+	if stack.correlation == nil {
+		return
+	}
+	for index := storage - 1; index >= 0; index-- {
+		var origins [8]uint8
+		for bit := range origins {
+			position := index*8 + bit
+			if known&(uint64(1)<<uint(position)) == 0 {
+				origins[bit] = x86FlagsUntracked
+				if flags && position < 32 {
+					origins[bit] = stack.correlation.flags[position]
+				}
+			}
+		}
+		stack.correlation.bytes = append(stack.correlation.bytes, origins)
+	}
+}
+
+func x86ResultFlagsStackPop(stack *x86ResultValueStack, storage int) [32]uint8 {
+	var origins [32]uint8
+	if stack.correlation == nil {
+		return origins
+	}
+	for bit := range origins {
+		origins[bit] = x86FlagsUntracked
+	}
+	bytes := stack.correlation.bytes
+	for index := 0; index < storage; index++ {
+		copy(origins[index*8:], bytes[len(bytes)-1-index][:])
+	}
+	stack.correlation.bytes = bytes[:len(bytes)-storage]
+	return origins
+}
+
+func x86ResultPrivateStackXORStep(ins Instr, popped x86ResultGPBits, poppedOrigins [32]uint8,
+	state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, memory, known := x86ResultPrivateStackXORForm(ins, arch)
+	if !known {
+		return false, false
+	}
+	stack := state.valueStack
+	if stack == nil || stack.correlation == nil || stack.invalid {
+		return false, true
+	}
+	width := form.spec.bits / 8
+	args := [2]Operand{form.source, form.destination}
+	offset := int(args[memory].Mem.Off)
+	if !state.shapeOnly && (offset+width > len(stack.bytes) || len(stack.correlation.bytes) != len(stack.bytes)) {
+		return false, true
+	}
+	var inputs [2][32]uint8
+	for index, arg := range args {
+		if state.shapeOnly || arg.Kind == OpImm {
+			continue
+		}
+		for bit := 0; bit < width*8; bit++ {
+			if index == memory {
+				inputs[index][bit] = stack.correlation.bytes[len(stack.bytes)-1-offset-bit/8][bit%8]
+				continue
+			}
+			root, mask, valid := x86ResultGP(arg.Reg, int64(width), arch)
+			if arg.Kind != OpReg || !valid || x86LogicalSourceFrameRegister(arg.Reg, arch) {
+				return false, true
+			}
+			shift := 0
+			if width == 1 && mask == 2 {
+				shift = 8
+			}
+			if state.gp[root]&(1<<uint((bit+shift)/8)) == 0 {
+				inputs[index][bit] = x86FlagsUntracked
+				if popped.valid && popped.fromStack && popped.register == root {
+					inputs[index][bit] = poppedOrigins[bit+shift]
+				}
+			}
+		}
+	}
+	allKnown := true
+	if memory == 1 && !state.shapeOnly {
+		stack.revokePointerCells(len(stack.bytes)-offset-width, len(stack.bytes)-offset,
+			int(x86ResultPointerWord(arch)))
+	}
+	for b := 0; b < width; b++ {
+		var origins [8]uint8
+		var bits uint8
+		for bit := range origins {
+			origins[bit] = x86FlagsXOROrigin(inputs[0][b*8+bit], inputs[1][b*8+bit])
+			if origins[bit] == 0 {
+				bits |= 1 << uint(bit)
+			}
+		}
+		allKnown = allKnown && bits == 255
+		if memory == 1 && !state.shapeOnly {
+			position := len(stack.bytes) - 1 - offset - b
+			stack.correlation.bytes[position] = origins
+			stack.bytes[position] = bits
+			if stack.refinable != nil {
+				stack.refinable[position] &= bits
+			}
+		}
+	}
+	if memory == 0 {
+		// A numeric GP consumer may observe only a fully canceled value.
+		// Unknown copies stay confined to the private storage transport.
+		if !allKnown || !x86ResultStore(form.destination, int64(width), state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	state.flags = x86ByteFlagCF | x86ByteFlagOF
+	if allKnown {
+		state.flags |= x86ByteFlagPF | x86ByteFlagZF | x86ByteFlagSF
+	}
+	return true, true
+}
+
+func x86ResultFlagsCorrelationAfter(ins Instr, state *x86ResultState, arch string) {
+	if state.valueStack == nil || state.valueStack.correlation == nil || state.shapeOnly {
+		return
+	}
+	if _, stack, _ := x86StackWidthProperties(ins, arch); stack {
+		return // The checked byte copy already retained the exact relation.
+	}
+	writes := uint8(x86ByteFlagsAll)
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		writes = effect.flagsDefined | effect.flagsKilled
+	} else if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) || ins.Op == "NOP" || x86RawReturnScalarMoveBytes(ins.Op) != 0 {
+		writes = 0
+	}
+	for index, bit := range []int{0, 2, 4, 6, 7, 11} {
+		if state.flags&(1<<uint(index)) != 0 {
+			state.valueStack.correlation.flags[bit] = 0
+		} else if writes&(1<<uint(index)) != 0 {
+			state.valueStack.correlation.flags[bit] = x86FlagsUntracked
+		}
+	}
+	correlation := state.valueStack.correlation
+	if state.direction != x86ResultDirectionUnknown {
+		correlation.flags[10] = 0
+	} else if correlation.flags[10] == 0 || ins.Op == OpCALL {
+		correlation.flags[10] = x86FlagsUntracked
+	}
+	if state.valueStack.id {
+		correlation.flags[21] = 0
+	} else if correlation.flags[21] == 0 || ins.Op == OpCALL {
+		correlation.flags[21] = x86FlagsUntracked
+	}
+}
+
+func x86ResultIntersectFlagsCorrelation(left, right *x86ResultValueStack) {
+	if left.correlation == nil {
+		return
+	}
+	if left.invalid || right == nil || right.correlation == nil ||
+		len(left.correlation.bytes) != len(right.correlation.bytes) {
+		left.correlation = nil
+		return
+	}
+	merge := func(left, right []uint8) {
+		for index := range left {
+			if left[index] != right[index] {
+				left[index] = x86FlagsUntracked
+			}
+		}
+	}
+	merge(left.correlation.flags[:], right.correlation.flags[:])
+	merge(left.correlation.popped[:], right.correlation.popped[:])
+	for index := range left.correlation.bytes {
+		merge(left.correlation.bytes[index][:], right.correlation.bytes[index][:])
+	}
+}
diff --git a/x86_result_float_compare.go b/x86_result_float_compare.go
new file mode 100644
index 000000000..644760405
--- /dev/null
+++ b/x86_result_float_compare.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+// The paired native comparison keeps the full immediate, MXCSR, mask and
+// fault behavior. Its continued execution defines numerical result bytes;
+// it supplies no caller/frame backing, pointer extent or raw-entry authority.
+func x86ResultFloatCompareStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86FloatCompareProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) && !x86RawFloatCompareLiteralForm(ins, arch) {
+		if !nativeRead || !x86RawLegacyFloatCompareSource(ins, arch) {
+			return false, true
+		}
+		// Only this paired numerical transfer consumes a named local view.
+		// The emitter and immutable replay retain every original selector and
+		// operand, and neither raw entry nor independent DATA authority follows.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if form.mask >= 0 {
+		mask, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	}
+	required := x86CallerVectorByteMask(int64(form.inputByteWidth()))
+	for _, ordinal := range []int{form.first, form.second} {
+		operand := ins.Args[ordinal]
+		if ordinal == form.memory {
+			if operand.Kind == OpFP && !form.scalar ||
+				!x86ResultReadWithNativeContinuation(ins, operand, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+				return false, true
+			}
+			continue
+		}
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		if !valid || state.vectorBytes(index)&required != required {
+			return false, true
+		}
+	}
+	if form.maskResult {
+		index, valid := amd64ParseKReg(ins.Args[form.destination].Reg)
+		if !valid {
+			return false, true
+		}
+		state.masks[index] = true
+		return true, true // A K destination is not an old merge input.
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	defined := form.resultDefinedBytes(state.vectorBytes(second), state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true // Arithmetic FLAGS/DF are preserved; MXCSR stays native.
+}
diff --git a/x86_result_float_minmax.go b/x86_result_float_minmax.go
new file mode 100644
index 000000000..672108ff1
--- /dev/null
+++ b/x86_result_float_minmax.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import "reflect"
+
+// An absent snapshot is not evidence for a legacy or VEX encoding. The decoder
+// records the actual generation before any numerical or literal projection.
+type x86RawFloatMinMaxIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86FloatMinMaxRawIdentity(ins Instr, arch string) x86RawFloatMinMaxIdentity {
+	if _, known, err := x86FloatMinMaxProperties(ins, arch); !known || err != nil {
+		return x86RawFloatMinMaxIdentity{}
+	}
+	return x86RawFloatMinMaxIdentity{arch, ins.x86Encoded, ins.x86FloatMinMaxEVEX}
+}
+
+func x86RawFloatMinMaxEncodingSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	return origin != nil && origin.floatMinMax.arch == arch &&
+		origin.floatMinMax == x86FloatMinMaxRawIdentity(ins, arch) &&
+		origin.op == ins.Op && (reflect.DeepEqual(origin.args, ins.Args) || x86RawLiteralSourceIdentity(ins, arch)) &&
+		origin.vectorBytes == ins.x86VectorBytes && origin.addressBits == ins.x86AddressBits
+}
+
+func x86RawFloatMinMaxSource(ins Instr, arch string) bool {
+	return x86RawFloatMinMaxEncodingSource(ins, arch) && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86FloatMinMaxPreservesSourceState(ins Instr, arch string) bool {
+	return x86RawFloatMinMaxSource(ins, arch) ||
+		x86RawFloatMinMaxEncodingSource(ins, arch) && x86RawBinaryFloatLiteralForm(ins, arch)
+}
+
+// Consult the sealed decoded inventory, not a mutable current origin pointer.
+// Removing an origin must not turn a physical instruction into a named one.
+func x86FloatMinMaxRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay == nil {
+		return false
+	}
+	for _, ins := range fn.x86RawReplay.decoded {
+		if _, known, _ := x86FloatMinMaxProperties(ins, arch); known {
+			return true
+		}
+	}
+	return false
+}
+
+func x86ResultFloatMinMaxStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	f, known, err := x86FloatMinMaxProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) && !x86RawBinaryFloatLiteralForm(ins, arch) {
+		if !nativeRead || !x86RawFloatMinMaxSource(ins, arch) {
+			return false, true
+		}
+		// Only the exact paired native opcode consumes this local read view.
+		// Complete source replay is checked once by the lowering owner.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ScalarFPFloatBinaryTransferWithRead(ins, f.x86FloatBinaryForm, state, owned, arch, nativeRead), true
+}
diff --git a/x86_result_floating_helper.go b/x86_result_floating_helper.go
new file mode 100644
index 000000000..648cd800d
--- /dev/null
+++ b/x86_result_floating_helper.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+// This transfer is paired with the complete native helper instruction. It
+// preserves MXCSR/fault behavior in lowering and proves numerical bytes only;
+// no pointee validity, caller extent, physical entry or storage owner follows.
+func x86ResultFloatingHelperStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86FloatingHelperProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if form.mask >= 0 {
+		mask, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	}
+	required := x86CallerVectorByteMask(int64(form.activeBytes()))
+	first := ins.Args[form.first]
+	if form.memory >= 0 {
+		if !form.spec.scalar && first.Kind == OpFP ||
+			!x86ResultReadWithNativeContinuation(ins, first, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else {
+		source, valid := amd64VectorRegisterIndex(first.Reg, form.byteWidth)
+		if !valid || state.vectorBytes(source)&required != required {
+			return false, true
+		}
+	}
+	upper := uint64(0)
+	if form.second >= 0 {
+		second, valid := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+		if !valid {
+			return false, true
+		}
+		upper = state.vectorBytes(second)
+		if form.spec.second && upper&required != required {
+			return false, true
+		}
+	}
+	if form.spec.maskResult {
+		destination, valid := amd64ParseKReg(ins.Args[form.destination].Reg)
+		if !valid {
+			return false, true
+		}
+		state.masks[destination] = true
+		return true, true // K destinations are write-only, never merge inputs.
+	}
+	destination, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if !valid || (form.spec.readDestination || form.mask >= 0 && !form.properties.zeroing) &&
+		state.vectorBytes(destination)&required != required {
+		return false, true
+	}
+	defined := ^uint64(0)
+	if form.spec.scalar {
+		defined = ^uint64(0xffff) | required | upper&(0xffff&^required)
+	}
+	state.writeVector(destination, form.byteWidth, defined, false)
+	return true, true // GP, FLAGS, DF/ID, masks and independent storage survive.
+}
diff --git a/x86_result_fma3.go b/x86_result_fma3.go
new file mode 100644
index 000000000..f6d3832c7
--- /dev/null
+++ b/x86_result_fma3.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+// Ordinary named FMA3 consumes three numerical sources in every order. Its
+// destructive destination remains an arithmetic input even with zero masking.
+// The existing raw-only FP16 consumer owns a separate exact-source contract.
+func x86ResultFMA3Step(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := amd64FMA3Properties(ins, arch)
+	if !known || form.spec.rawOnly {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	literal := x86RawFMA3LiteralForm(ins, arch)
+	if !literal && (!x86ResultNamedPredicateInstruction(ins) || ins.x86FMA3Encoding != x86RawFMA3Absent) {
+		if !nativeRead || !x86RawFMA3Source(ins, arch) {
+			return false, true
+		}
+		// Project only this paired access. Keep the complete physical form so
+		// mode32 masks do not get reparsed through Go's named arity limit.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultFMA3Inputs(ins, form, state, owned, arch, nativeRead), true
+}
+
+func x86ResultFMA3Inputs(ins Instr, form amd64FMA3Form, state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false
+		}
+	}
+	active := form.byteWidth
+	if form.spec.scalar {
+		active = form.spec.laneBits / 8
+	}
+	required := x86CallerVectorByteMask(int64(active))
+	for _, index := range []int{0, 1, form.destination} {
+		if index == form.memory {
+			if !x86ResultReadWithNativeContinuation(ins, ins.Args[index], int64(form.memoryBytes), state, owned, arch, nativeRead) {
+				return false
+			}
+			continue
+		}
+		register, _ := amd64VectorRegisterIndex(ins.Args[index].Reg, form.byteWidth)
+		if state.vectorBytes(register)&required != required {
+			return false
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	knownBytes := ^uint64(0)
+	if form.spec.scalar {
+		// Unlike scalar binary arithmetic, FMA's upper-X passthrough comes
+		// from the old destructive destination, not either explicit source.
+		knownBytes = required | state.vectorBytes(destination)&(0xffff&^required)
+	}
+	state.writeVector(destination, form.byteWidth, knownBytes, false)
+	return true
+}
diff --git a/x86_result_four_source.go b/x86_result_four_source.go
new file mode 100644
index 000000000..339c820d3
--- /dev/null
+++ b/x86_result_four_source.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+// Numerical availability only: the paired whole original opcode owns the
+// ambient FP state, precise fault and complete m128 access obligations. No
+// backing, caller, frame, native-entry or subsequent-read authority follows.
+func x86ResultFourSourceStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86FourSourceProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || form.memory.Kind == OpFP {
+		return false, true
+	}
+	if form.maskIndex >= 0 {
+		mask, valid := amd64ParseKReg(ins.Args[form.maskIndex].Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	}
+	if !x86ResultReadWithNativeContinuation(ins, form.memory, 16, state, owned, arch, native) {
+		return false, true
+	}
+	required := x86CallerVectorByteMask(form.inputBytes())
+	for position := 0; position < 4; position++ {
+		if state.vectorBytes(form.sourceBase+position)&required != required {
+			return false, true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(form.destination.Reg, form.byteWidth())
+	old := state.vectorBytes(destination)
+	if old&required != required {
+		return false, true // .Z still reads the old accumulator in active lanes.
+	}
+	defined := required
+	if form.spec.scalar {
+		defined |= old & (0xffff &^ required)
+	}
+	state.writeVector(destination, form.byteWidth(), defined, false)
+	return true, true // Other vectors, GP, FLAGS, DF/ID and K state are unchanged.
+}
diff --git a/x86_result_fp16_binary.go b/x86_result_fp16_binary.go
new file mode 100644
index 000000000..95180fe07
--- /dev/null
+++ b/x86_result_fp16_binary.go
@@ -0,0 +1,14 @@
+package plan9asm
+
+func x86RawFP16BinarySourceForm(ins Instr, arch string) (x86FP16BinaryForm, bool) {
+	f, known, err := x86FP16BinaryProperties(ins, arch)
+	return f, known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86LoweredFP16BinaryStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	f, known, err := x86FP16BinaryProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ScalarFPFloatBinaryTransferWithRead(ins, f.x86FloatBinaryForm, state, owned, arch, true), true
+}
diff --git a/x86_result_fp16_conversion.go b/x86_result_fp16_conversion.go
new file mode 100644
index 000000000..5c7ed0e25
--- /dev/null
+++ b/x86_result_fp16_conversion.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import "reflect"
+
+func x86RawFP16ConversionSourceForm(ins Instr, arch string) (x86FP16ConversionForm, bool) {
+	f, known, err := x86FP16ConversionProperties(ins, arch)
+	return f, known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// A typed family must validate the opcode and operands before using this
+// original-source identity check. It grants no standalone or native entry role.
+func x86RawOrdinaryVectorSource(ins Instr, arch string) bool {
+	return x86RawOrdinaryVectorSourceAt(ins, arch, 0)
+}
+
+// Validate the complete original identity before selecting the typed data
+// operand. An immediate-first family must not rewrite operands to borrow the
+// first-data grammar, or leave its selector outside the original identity.
+func x86RawOrdinaryVectorSourceAt(ins Instr, arch string, sourceIndex int) bool {
+	if sourceIndex < 0 || sourceIndex >= len(ins.Args) || ins.x86SourceRaw == nil ||
+		ins.x86SourceRaw.op != ins.Op || !reflect.DeepEqual(ins.x86SourceRaw.args, ins.Args) ||
+		ins.x86SourceRaw.vectorBytes != ins.x86VectorBytes ||
+		ins.x86SourceRaw.addressBits != ins.x86AddressBits ||
+		ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride ||
+		ins.x86SegmentPrefix != 0 || ins.x86RIPLiteral || ins.x86NumericalRead != nil {
+		return false
+	}
+	source := ins.Args[sourceIndex]
+	return source.Kind == OpReg || source.Kind == OpMem && source.Mem.Sym == "" &&
+		source.Mem.Segment == "" && x86OrdinaryNativeMemoryOperand(source, arch)
+}
+
+// Numerical bytes are conditional on the exact paired conversion/access.
+// They provide neither MXCSR facts nor backing, bounds, entry or caller roles.
+func x86LoweredFP16ConversionStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	_, known, _ := x86FP16ConversionProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	f, valid := x86RawFP16ConversionSourceForm(ins, arch)
+	if !valid {
+		return false, true
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	input := x86CallerVectorByteMask(int64(f.inputBytes))
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		index, _ := amd64VectorRegisterIndex(source.Reg, f.sourceBytes)
+		if state.vectorBytes(index)&input != input {
+			return false, true
+		}
+	} else {
+		local := ins
+		local.x86Encoded, local.x86SourceRaw = false, nil
+		if !x86ResultReadWithNativeContinuation(local, source, int64(f.memoryBytes), state, owned, arch, true) {
+			return false, true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	output := x86CallerVectorByteMask(int64(f.outputBytes))
+	if f.mask >= 0 && !f.controls.zeroing && state.vectorBytes(destination)&output != output {
+		return false, true
+	}
+	value := x86CallerVectorByteMask(int64(f.byteWidth))
+	if f.upper >= 0 {
+		upper, _ := amd64VectorRegisterIndex(ins.Args[f.upper].Reg, 16)
+		value = output | state.vectorBytes(upper)&(0xffff&^output)
+	}
+	state.writeVector(destination, f.byteWidth, value, false)
+	return true, true
+}
diff --git a/x86_result_fp16_fma.go b/x86_result_fp16_fma.go
new file mode 100644
index 000000000..e2c130f6f
--- /dev/null
+++ b/x86_result_fp16_fma.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+func x86RawFP16FMASourceForm(ins Instr, arch string) (amd64FMA3Form, bool) {
+	f, known, err := amd64FMA3Properties(ins, arch)
+	return f, known && err == nil && f.spec.rawOnly && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Only the paired lowerer may consume this conditional native result. Exact
+// original source and all three numerical inputs remain required; this grants
+// neither caller/backing authority nor a reusable memory or MXCSR fact.
+func x86LoweredFP16FMAStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	f, known, _ := amd64FMA3Properties(ins, arch)
+	if !known || !f.spec.rawOnly {
+		return false, false
+	}
+	if _, valid := x86RawFP16FMASourceForm(ins, arch); !valid {
+		return false, true
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	width := f.byteWidth
+	if f.spec.scalar {
+		width = f.spec.laneBits / 8
+	}
+	required := x86CallerVectorByteMask(int64(width))
+	for _, index := range []int{0, 1, f.destination} {
+		if index == f.memory {
+			local := ins
+			local.x86Encoded, local.x86SourceRaw = false, nil
+			if !x86ResultReadWithNativeContinuation(local, ins.Args[index], int64(f.memoryBytes), state, owned, arch, true) {
+				return false, true
+			}
+			continue
+		}
+		reg, _ := amd64VectorRegisterIndex(ins.Args[index].Reg, f.byteWidth)
+		if state.vectorBytes(reg)&required != required {
+			return false, true
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	value := ^uint64(0)
+	if f.spec.scalar {
+		value = required | state.vectorBytes(destination)&(0xffff&^required)
+	}
+	state.writeVector(destination, f.byteWidth, value, false)
+	return true, true
+}
diff --git a/x86_result_fp_address_effect.go b/x86_result_fp_address_effect.go
new file mode 100644
index 000000000..c09d7b154
--- /dev/null
+++ b/x86_result_fp_address_effect.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+// This is only the validated named FP-address write shape. The private
+// observer separately needs mapped typed storage; the post-consumer uses the
+// same shape only to revoke the exact destination's old identities.
+func x86LogicalFPLEAWriteShape(ins Instr, arch string) (int, uint8, int64, bool) {
+	if len(ins.Args) == 2 && ins.Args[0].Kind == OpFPAddr {
+		view, known, err := x86NamedFrameMoveAddressInstruction(ins, arch)
+		if !known || err != nil {
+			return 0, 0, 0, false
+		}
+		ins = view
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || len(ins.Args) != 2 ||
+		ins.Args[0].Kind != OpFP || ins.Args[0].Mem != (MemRef{}) {
+		return 0, 0, 0, false
+	}
+	width, err := x86LEAOperandWidth(ins, arch)
+	if err != nil || arch != "amd64" && arch != "386" {
+		return 0, 0, 0, false
+	}
+	index, mask, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+	return index, mask, width, valid && (arch != "amd64" || index != 14)
+}
+
+// Taking an address reads no data from that slot. This private fallback
+// retains only unknown address bytes, not numerical values, a reusable alias
+// or native backing. Full-word result/readonly-I1 producers run first.
+func x86ResultUnusedFPAddressStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	index, mask, width, known := x86LogicalFPLEAWriteShape(ins, arch)
+	if !known {
+		return false, false
+	}
+	offset := ins.Args[0].FPOffset
+	if state == nil || offset < 0 || offset >= int64(len(owned)) || !owned[offset] || offset >= int64(len(state.fp)) {
+		return false, true
+	}
+	if offset >= resultOffset {
+		matches := 0
+		for _, slot := range state.resultAddressSlots {
+			if slot.valid && slot.start >= resultOffset && slot.end > slot.start &&
+				slot.end <= int64(len(owned)) && offset >= slot.start && offset < slot.end {
+				for position := slot.start; position < slot.end; position++ {
+					if !owned[position] {
+						return false, true
+					}
+				}
+				matches++
+			}
+		}
+		if matches != 1 {
+			return false, true // No ordinary result-storage producer or unique field.
+		}
+	} else {
+		if !state.fp[offset] {
+			return false, true // Unmapped/pointer parameter bytes are not numerical storage.
+		}
+		for start := range state.pointerFP {
+			if offset >= start && offset < start+x86ResultPointerWord(arch) {
+				return false, true
+			}
+		}
+	}
+	state.gp[index] &^= mask
+	state.canonicalGP[index] &^= mask
+	if width == 4 {
+		state.gp[index] |= 0xf0 // Architectural upper32 zero, not initialized address bits.
+		state.canonicalGP[index] |= 0xf0
+	}
+	state.pointerGP[index], state.callerAddressGP[index] = false, false
+	state.callerAddressOrigin[index] = 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	state.predicate = x86ResultPredicate{}
+	return true, true
+}
diff --git a/x86_result_fp_address_effect_test.go b/x86_result_fp_address_effect_test.go
new file mode 100644
index 000000000..d3fc390a9
--- /dev/null
+++ b/x86_result_fp_address_effect_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86LEAFPInitializedResultOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			widths, result := []string{"W", "L"}, 4
+			if target.arch == "amd64" {
+				widths, result = append(widths, "Q"), 8
+			}
+			var source, declarations strings.Builder
+			for _, width := range widths {
+				for _, interior := range []int{0, 1} {
+					name := fmt.Sprintf("address%s%d", width, interior)
+					body := fmt.Sprintf("MOVL $7,ret+RESULT(FP)\nLEA%s ret+%d(FP),AX", width, result+interior)
+					original := x86ResultGPSIMDAdmissionSource(t, target.arch, "func view(x uint32) uint32", body)
+					source.WriteString(strings.Replace(original, "·view(SB)", "·"+name+"(SB)", 1))
+					fmt.Fprintf(&declarations, "func %s(x uint32) uint32\n", name)
+				}
+			}
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("complete initialized I32 source: TEXTs=%d source=%x object=%x SDK=%s",
+				len(widths)*2, receipt.Source, receipt.Object, receipt.GoVersion)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("complete typed source %s: %v", api, err)
+				}
+				for _, irLevel := range []string{"0", "2"} {
+					objectIR := ir
+					if irLevel == "2" {
+						objectIR = x86DwordProductIROptimize(t, ir)
+					}
+					for _, backendLevel := range []string{"0", "2"} {
+						t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, objectIR, "-O"+backendLevel)
+						})
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86LEAFPInitializedResultCompleteThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W", "L"}
+		if target.arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, interior := range []int{0, 1} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%d/%s", target.triple, width, interior, api), func(t *testing.T) {
+						declaration := "func view(x uint32) uint32"
+						result := 8
+						if target.arch == "386" {
+							result = 4
+						}
+						body := fmt.Sprintf("MOVL $7,ret+RESULT(FP)\nLEA%s ret+%d(FP),AX", width, result+interior)
+						source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+							t.Fatalf("known initialized I32 result cannot discard a legal storage-address value: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LEAFPAddressesNeverInitializeDeclaredResult(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W", "L"}
+		if target.arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, offset := range []int{8, 9} {
+				t.Run(fmt.Sprintf("%s/%s/%d", target.triple, width, offset), func(t *testing.T) {
+					// Preserve the original CI counterexample and its declared
+					// logical storage. Taking an address writes no result byte.
+					source := fmt.Sprintf("TEXT Address(SB),4,$0-16\nLEA%s r+%d(FP),AX\nRET\n", width, offset)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					options := Options{Goarch: target.arch, TargetTriple: target.triple,
+						Sigs: map[string]FuncSig{"Address": {
+							Name: "Address", Args: []LLVMType{I32}, Ret: I32,
+							Frame: FrameLayout{
+								Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+								Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1, Name: "r"}},
+							},
+						}},
+					}
+					if ir, err := Translate(file, options); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("unchanged missing result acquired initialization: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NarrowResultFPAddressPreservesUnknownBytesAndRevokesIdentities(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := []string{"W"}
+		if arch == "amd64" {
+			widths = append(widths, "L")
+		}
+		for _, width := range widths {
+			for _, prior := range []uint8{0, 0x55, 0xff} {
+				t.Run(fmt.Sprintf("%s/%s/%x", arch, width, prior), func(t *testing.T) {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.fp = make([]bool, 12)
+					owned := make([]bool, 12)
+					for offset := 8; offset < 12; offset++ {
+						owned[offset] = true
+					}
+					state.resultAddressSlots = []x86ResultSlotAddress{{start: 8, end: 12, offset: 8, valid: true}}
+					state.resultAddressGP[0], state.resultAddressGP[3] = state.resultAddressSlots[0], state.resultAddressSlots[0]
+					state.gp[0], state.canonicalGP[0] = prior, 0xff
+					state.pointerGP[0], state.callerAddressGP[0], state.callerAddressGP[3] = true, true, true
+					state.callerAddressOrigin[0], state.callerAddressOrigin[3] = 1, 2
+					state.predicate = x86ResultPredicate{kind: x86ResultNonzeroMaskGP, register: 0, width: 32}
+					before := state.clone()
+					ins := x86ScalarLaneInstruction(t, "LEA"+width+" ret+9(FP),AX")
+					if accepted, known := x86ResultUnusedFPAddressStep(ins, &state, owned, 8, arch); !accepted || !known {
+						t.Fatal("bound narrowed address cannot be retained as unknown bytes")
+					}
+					wantKnown, wantCanonical := prior&^uint8(3), uint8(0xfc)
+					if width == "L" {
+						wantKnown, wantCanonical = 0xf0, 0xf0 // Architectural upper32 zero, not guessed address bits.
+					}
+					if state.gp[0] != wantKnown || state.canonicalGP[0] != wantCanonical || state.pointerGP[0] ||
+						state.callerAddressGP[0] || state.callerAddressOrigin[0] != 0 || state.resultAddressGP[0].valid ||
+						state.predicate != (x86ResultPredicate{}) || state.flags != before.flags || state.direction != before.direction {
+						t.Fatal("narrowed address invented bytes or retained aliases/provenance/canonical facts")
+					}
+					// Exercise the real post-transfer consumer too. Its source view
+					// must revoke this destination, not unrelated live identities.
+					after := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch)
+					if after[0] || !after[3] || !reflect.DeepEqual(state.resultAddressGP[3], before.resultAddressGP[3]) {
+						t.Fatal("validated FP LEA revoked unrelated caller/result storage")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NarrowFPAddressLiveUsesAndEscapesRemainContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W"}
+		if target.arch == "amd64" {
+			widths = append(widths, "L")
+		}
+		for _, width := range widths {
+			for _, test := range []struct{ name, use string }{
+				{"NUM result", "MOVL AX,ret+RESULT(FP)"},
+				{"compare", "TESTW AX,AX\nMOVL $0,CX\nSETEQ CL\nMOVL CX,ret+RESULT(FP)"},
+				{"native load", "MOVB (AX),CL"},
+				{"native store", "MOVB $1,(AX)"},
+				{"input escape", "MOVL AX,x+0(FP)"},
+				{"vector result", "MOVL AX,X0\nPEXTRD $0,X0,ret+RESULT(FP)"},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+width+"/"+test.name+"/"+api, func(t *testing.T) {
+						declaration := "func view(x uint32) uint32"
+						body := "MOVL $7,ret+RESULT(FP)\nLEA" + width + " ret+RESULT(FP),AX\n" + test.use
+						source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("unused address knowledge escaped into observable data/memory: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86UnusedFPAddressPrivateMappedStorageOnly(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := []string{"W", "L"}
+		if arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			t.Run(arch+"/"+width, func(t *testing.T) {
+				declaration := "func view(x uint8) uint32"
+				// A one-byte field has a real address even for a qword LEA:
+				// address width is not a read of eight bytes of its pointee.
+				body := "MOVL $7,ret+RESULT(FP)\nLEA" + width + " x+0(FP),AX"
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sigs, err := goSigsForAsmFile(pkg, file, func(string) string { return "view" }, arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := sigs["view"]
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("public declaration query acquired private storage-address role", err)
+				}
+				ctx, _ := newAMD64CtxWithFuncForTest(t, file.Funcs[0], sig, nil)
+				ctx.goarch = arch
+				if err := ctx.checkLoweredScalarFPResultInitialization(); err != nil {
+					t.Fatal("complete private proof cannot discard an actual one-byte field address", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnusedFPAddressRejectsUnboundAndNonordinaryRoles(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func(*Instr, *x86ResultState, []bool)
+	}{
+		{"unmapped", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[0].FPOffset = 4 }},
+		{"end", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[0].FPOffset = 12 }},
+		{"negative", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[0].FPOffset = -1 }},
+		{"missing producer", func(_ *Instr, state *x86ResultState, _ []bool) { state.resultAddressSlots = nil }},
+		{"duplicate producer", func(_ *Instr, state *x86ResultState, _ []bool) {
+			state.resultAddressSlots = append(state.resultAddressSlots, state.resultAddressSlots[0])
+		}},
+		{"hole", func(_ *Instr, _ *x86ResultState, owned []bool) { owned[10] = false }},
+		{"raw", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.x86Encoded = true }},
+		{"address-size", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.x86AddressBits = 32 }},
+		{"segment", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.x86SegmentPrefix = 0x64 }},
+		{"indexed", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[0].Mem.Index = SI }},
+		{"SP", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[1].Reg = SP }},
+		{"g", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[1].Reg = "R14" }},
+		{"TYPE_ADDR", func(ins *Instr, _ *x86ResultState, _ []bool) { ins.Args[0].Kind = OpImm }},
+		{"pointer parameter", func(ins *Instr, state *x86ResultState, owned []bool) {
+			ins.Args[0].FPOffset = 1
+			state.pointerFP = map[int64]bool{0: true}
+			for offset := 0; offset < 8; offset++ {
+				owned[offset], state.fp[offset] = true, true
+			}
+		}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			state := x86ResultState{fp: make([]bool, 12), flags: x86ByteFlagsAll}
+			state.resultAddressSlots = []x86ResultSlotAddress{{start: 8, end: 12, valid: true}}
+			state.gp[0], state.pointerGP[0] = 0xff, true
+			owned := make([]bool, 12)
+			for offset := 8; offset < 12; offset++ {
+				owned[offset] = true
+			}
+			ins := x86ScalarLaneInstruction(t, "LEAW ret+9(FP),AX")
+			test.edit(&ins, &state, owned)
+			before := state.clone()
+			if accepted, _ := x86ResultUnusedFPAddressStep(ins, &state, owned, 8, "amd64"); accepted || !reflect.DeepEqual(before, state) {
+				t.Fatal("failed storage/shape contract published byte or identity facts")
+			}
+		})
+	}
+}
diff --git a/x86_result_fp_trap_shadow.go b/x86_result_fp_trap_shadow.go
new file mode 100644
index 000000000..d39f5af9c
--- /dev/null
+++ b/x86_result_fp_trap_shadow.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import "strings"
+
+// This is a private logical-storage consumer, not a native frame/return ABI.
+// Its complete proof must finish at exact traps on every reachable path before
+// the byte adapter may update a numeric parameter shadow. Existing bound entry
+// contracts and pointer/canonical-bool storage remain independent.
+func x86TrapOnlyLogicalFPSourceRole(fn Func, sig FuncSig, arch string) bool {
+	if arch != "amd64" && arch != "386" || fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil ||
+		sig.WASMContext != "" || sig.WASMNative || sig.amd64GoArguments != nil || sig.x86FixedLocal != nil ||
+		sig.x86CallerRegions != nil || sig.x86BorrowedBoolTail || len(fn.X86RawText) != 0 ||
+		fn.x86SourceStack != nil || fn.x86FixedLocal != nil || fn.x86RawReplay != nil ||
+		fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil || len(fn.x86ContinuationAddresses) != 0 ||
+		len(fn.x86IndirectLabels) != 0 || fn.x86BoolCalls != nil || fn.x86BoolReadonlyInputs {
+		return false
+	}
+	for _, typ := range append(append([]LLVMType(nil), sig.Args...), sig.Ret) {
+		switch typ {
+		case I8, I16, I32, I64, LLVMType("float"), LLVMType("double"), Void:
+		default:
+			return false
+		}
+	}
+	trap := false
+	for _, ins := range fn.Instrs {
+		if ins.Op == OpCALL || isX86RawDirective(ins) || ins.x86Encoded || ins.x86SourceRaw != nil ||
+			ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+			return false
+		}
+		if _, stack, _ := x86StackWidthProperties(ins, arch); stack {
+			return false // This new role does not supplement independent stack storage.
+		}
+		if _, known, err := x86UndefinedTrapProperties(ins.Op, ins, arch); known {
+			if err != nil {
+				return false
+			}
+			// A terminal encoding does not access its written memory operand.
+			// Earlier ordinary instructions retain their independent checks.
+			trap = true
+			continue
+		}
+		for _, operand := range ins.Args {
+			if operand.Kind == OpMem || operand.Kind == OpFPAddr {
+				return false
+			}
+		}
+	}
+	return trap
+}
+
+func (c *amd64Ctx) checkTrapOnlyLogicalFPResultInitialization() error {
+	transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+		if _, known, err := x86UndefinedTrapProperties(ins.Op, ins, arch); known {
+			return err == nil
+		}
+		width := x86IntegerFPMoveWidth(ins, arch)
+		if width != 0 && len(ins.Args) == 2 && ins.Args[1].Kind == OpFP {
+			if _, err := c.bitTestFPSpan(ins.Args[1].FPOffset, int(width)); err != nil {
+				return false
+			}
+			// Only the logical shadow boundary changes. All source byte/flag
+			// requirements still come from the same ordinary typed transfer.
+			return x86ScalarFPResultTransfer(ins, state, owned, 0, arch)
+		}
+		return x86ScalarFPResultTransfer(ins, state, owned, offset, arch)
+	}
+	return checkX86ABI0ResultInitializationWithTrapOnly(c.fpScalarSource, c.sig, c.goarch, transfer, true, true, false)
+}
+
+// Reverse closure requires every successor to terminate, not merely one path
+// to a trap. A reachable cyclic SCC never closes, even beside a trapping path.
+func x86ResultAllPathsTerminateInTrap(instructions []Instr, edges [][]int, states map[int]x86ResultState, arch string) bool {
+	closed, pending, previous := make([]bool, len(instructions)), make([]int, len(instructions)), make([][]int, len(instructions))
+	var queue []int
+	for pc := range states {
+		_, trap, err := x86UndefinedTrapProperties(instructions[pc].Op, instructions[pc], arch)
+		if trap && err == nil {
+			closed[pc] = true
+			queue = append(queue, pc)
+			continue
+		}
+		pending[pc] = len(edges[pc])
+		for _, target := range edges[pc] {
+			previous[target] = append(previous[target], pc)
+		}
+	}
+	for len(queue) != 0 {
+		pc := queue[0]
+		queue = queue[1:]
+		for _, predecessor := range previous[pc] {
+			pending[predecessor]--
+			if !closed[predecessor] && pending[predecessor] == 0 {
+				closed[predecessor] = true
+				queue = append(queue, predecessor)
+			}
+		}
+	}
+	for pc := range states {
+		if !closed[pc] {
+			return false
+		}
+	}
+	return len(states) != 0
+}
diff --git a/x86_result_gp_bits_budget_test.go b/x86_result_gp_bits_budget_test.go
new file mode 100644
index 000000000..cbceb6838
--- /dev/null
+++ b/x86_result_gp_bits_budget_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86ResultGPBitsBudgetTracksFunctionDomains(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, stackBytes := "L", 252+14+32
+		if arch == "amd64" {
+			word, stackBytes = "Q", 504+14+64+8
+		}
+		stack := "PUSH" + word + " $1\nPOP" + word + " AX\n"
+		mask := "VZEROALL\nPMOVMSKB X0,AX\n"
+		for _, row := range []struct {
+			name, body string
+			additional int
+		}{
+			{"ordinary", "MOVL $1,AX\n", 0},
+			{"movemask", mask, 11},
+			{"stack", stack, stackBytes},
+			{"both", mask + stack, stackBytes + 1},
+			{"lowercase-movemask", mask, 11},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+row.body+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				if row.name == "lowercase-movemask" {
+					fn.Instrs[2].Op = Op(strings.ToLower(string(fn.Instrs[2].Op)))
+				}
+				budget := new(x86ResultFlowBudget)
+				fn.x86ResultFlowBudget = budget
+				transfer := func(_ int, ins Instr, state *x86ResultState, owned []bool, offset int64, arch string) bool {
+					return x86ResultTransfer(ins, state, owned, offset, arch)
+				}
+				returned := false
+				err = checkX86ResultSourceFlow(fn, x86ResultState{}, nil, 0, arch, transfer, func(state x86ResultState, _ int) error {
+					returned = state.gp[0]&15 == 15
+					return nil
+				})
+				count := len(fn.Instrs) - 1
+				want := 9 * count * (x86IndependentResultBasePayload + row.additional)
+				if err != nil || !returned || budget.visits != count || budget.bytes != want {
+					t.Fatal("function domains changed exact source/visit work", budget, want, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_gp_simd.go b/x86_result_gp_simd.go
new file mode 100644
index 000000000..709efac32
--- /dev/null
+++ b/x86_result_gp_simd.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import "strings"
+
+// Both result observers consume the same typed numerical transfer. The public
+// observer enters only for register/register operands; the private observer
+// retains its existing logical-memory roles. Neither acquires native backing,
+// caller permission or numerical pointer bytes.
+func x86ResultGPSIMDTransfer(ins Instr, form x86GPSIMDTransferForm, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) bool {
+	return x86ResultGPSIMDTransferWithNativeMemory(ins, form, state, owned, resultOffset, arch, false)
+}
+
+func x86ResultGPSIMDTransferWithNativeMemory(ins Instr, form x86GPSIMDTransferForm, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string, nativeMemory bool) bool {
+	if form.mmx || form.spec.rawOnly {
+		return false
+	}
+	width := int64(form.bits / 8)
+	lowMask := uint16(1)<<uint(width) - 1
+	var known uint16
+	if form.sourceX {
+		index, valid := amd64ParseXReg(ins.Args[0].Reg)
+		if !valid {
+			return false
+		}
+		known = state.xmm[index] & lowMask
+	} else if ins.Args[0].Kind == OpReg {
+		index, mask, valid := x86ResultGP(ins.Args[0].Reg, width, arch)
+		if !valid || !state.shapeOnly && (state.pointerGP[index] || state.callerAddressGP[index]) {
+			return false // Opaque addresses are not numerical GP inputs.
+		}
+		known = uint16(state.gp[index] & mask)
+	} else if !x86ResultReadWithNativeContinuation(ins, ins.Args[0], width, state, owned, arch, nativeMemory) {
+		return false
+	} else {
+		known = lowMask // Memory still needs its complete independent read role.
+	}
+	if form.destinationX {
+		index, valid := amd64ParseXReg(ins.Args[1].Reg)
+		if !valid {
+			return false
+		}
+		state.writeVector(index, 16,
+			form.definedVectorBytes(uint64(known), state.vectorBytes(index)), form.spec.legacy)
+		return true
+	}
+	if ins.Args[1].Kind == OpReg {
+		index, _, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+		if !valid {
+			return false
+		}
+		// The active GP bytes replace old facts, even when unknown. A dword
+		// write clears AMD64's upper dword; mode32 has no qword GP read role.
+		state.gp[index] = uint8(known) | ^uint8(lowMask)
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		state.canonicalGP[index] = 0 // Numerical dependencies do not prove 0/1.
+		return true
+	}
+	if known != lowMask {
+		return false // A stored unknown byte cannot initialize FP/AUTO/SB data.
+	}
+	if nativeMemory && form.memoryWrite && x86ResultNamedPredicateInstruction(ins) &&
+		ins.x86NumericalRead == nil && x86OrdinaryNativeMemoryOperand(ins.Args[1], arch) &&
+		x86ResultIncomingPointerAddressIdentity(ins.Args[1], state, arch) {
+		return true // The paired exact volatile store creates no reusable memory facts.
+	}
+	if form.memoryWrite && ins.Args[1].Kind == OpSym {
+		// Only the existing private memory consumer enters this branch.
+		// An ordinary SB store defines no FP result bytes and supplies no
+		// address or extent certificate.
+		symbol := strings.TrimSpace(ins.Args[1].Sym)
+		base, _, valid := parseSBRef(symbol)
+		return valid && strings.HasSuffix(symbol, "(SB)") &&
+			strings.IndexAny(base, "$+(),[] \t") < 0
+	}
+	return x86ResultStore(ins.Args[1], width, state, owned, resultOffset, arch)
+}
diff --git a/x86_result_gp_simd_admission_test.go b/x86_result_gp_simd_admission_test.go
new file mode 100644
index 000000000..9c4acb570
--- /dev/null
+++ b/x86_result_gp_simd_admission_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// This is the original no-probe failure, not the separately observed PEXTRD
+// route. Both byte observers already reject the result; ordinary admission
+// must not forget to invoke that whole-function proof.
+func TestX86ResultGPSIMDPlainUnknownReturnNeedsWholeFunctionProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word, triple := "MOVD", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		declaration := "func view(c byte) uint32\n"
+		source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVB c+0(FP),AX\n%s AX,X0\nMOVL $0,BX\nMOVL X0,BX\nMOVL BX,ret+%d(FP)\nRET\n", word+4, move, word)
+		pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+		sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+			if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("leaf incorrectly initialized unknown result bytes", err)
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("plain GP/X bypassed complete result proof: IR bytes=%d error=%v", len(ir), err)
+				}
+			})
+		}
+	}
+}
+
+func x86ResultGPSIMDAdmissionSource(t *testing.T, arch, declaration, body string) string {
+	t.Helper()
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+	sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil || len(sig.Frame.Results) != 1 {
+		t.Fatal("actual scalar result layout is unavailable", err)
+	}
+	slot := sig.Frame.Results[0]
+	body = strings.ReplaceAll(body, "RESULT", fmt.Sprint(slot.Offset))
+	return fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s\nRET\n", slot.Offset+x86FrameScalarBytes(slot.Type, arch), body)
+}
+
+func x86ResultGPSIMDAdmissionAPIs(t *testing.T, arch, source, declaration string, pass bool) {
+	t.Helper()
+	triple := "x86_64-unknown-linux-gnu"
+	if arch == "386" {
+		triple = "i386-unknown-linux-gnu"
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+			if pass {
+				if err != nil || ir == "" {
+					t.Fatal("complete numerical result rejected", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatalf("uninitialized result admitted: IR bytes=%d error=%v", len(ir), err)
+			}
+		})
+	}
+}
+
+func TestX86ResultGPSIMDAdmissionScalarReturnFamilyThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			if arch == "386" && (op == "MOVQ" || op == "MOVD" || op == "MOVDQ2Q") {
+				continue // The complete Go grammar has no such GP mode32 row.
+			}
+			for _, result := range []struct{ typ, store string }{
+				{"uint8", "MOVB"}, {"uint16", "MOVW"}, {"uint32", "MOVL"}, {"uint64", "MOVQ"},
+			} {
+				for _, input := range []struct{ name, body string }{
+					{"complete", "MOVL $0x11223344,AX\n"},
+					{"low byte only", "MOVB c+0(FP),AX\n"},
+					{"unknown", ""},
+				} {
+					t.Run(arch+"/"+op+"/"+result.typ+"/"+input.name, func(t *testing.T) {
+						declaration := "func view(c byte) " + result.typ + "\n"
+						finish := result.store + " BX,ret+RESULT(FP)"
+						if arch == "386" && result.typ == "uint64" {
+							// There is no qword GP in mode32. The original X low
+							// qword is the same typed full-width numerical value.
+							finish = "MOVQ X0,ret+RESULT(FP)"
+						}
+						body := input.body + op + " AX,X0\n" + op + " X0,BX\n" + finish
+						source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+						pass := input.name == "complete" || input.name == "low byte only" && result.typ == "uint8"
+						x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, pass)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultGPSIMDAdmissionCompleteOfficialRegisterRows(t *testing.T) {
+	rows := x86OfficialGPSIMDTransferRows(t)
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q"} {
+		rows = append(rows, op+" AX,X0", op+" X0,AX")
+		if op != "MOVL" {
+			rows = append(rows, op+" X0,X1")
+		}
+	}
+	if len(rows) != 23 {
+		t.Fatal("complete official register-row denominator changed", len(rows))
+	}
+	for _, row := range rows {
+		for _, complete := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/complete%t", row, complete), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86GPSIMDTransferProperties(ins, "amd64")
+				if !known || err != nil {
+					t.Fatal("original typed row is unavailable", known, err)
+				}
+				body := "MOVB c+0(FP),AX\n"
+				if complete {
+					body = "MOVL $0x11223344,AX\n"
+				}
+				if form.sourceX {
+					seed := "MOVL"
+					if index, _ := amd64ParseXReg(ins.Args[0].Reg); index >= 16 {
+						seed = "VMOVD"
+					}
+					body += seed + " AX," + string(ins.Args[0].Reg) + "\n"
+				}
+				body += row + "\n"
+				destination := ins.Args[1].Reg
+				if form.destinationX {
+					sink := "MOVL"
+					if index, _ := amd64ParseXReg(destination); index >= 16 {
+						sink = "VMOVD"
+					}
+					body += sink + " " + string(destination) + ",BX\n"
+					destination = BX
+				}
+				body += "MOVL " + string(destination) + ",ret+RESULT(FP)"
+				declaration := "func view(c byte) uint32\n"
+				source := x86ResultGPSIMDAdmissionSource(t, "amd64", declaration, body)
+				x86ResultGPSIMDAdmissionAPIs(t, "amd64", source, declaration, complete)
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDAdmissionOrdinaryRolesAndCachedProof(t *testing.T) {
+	for _, test := range []struct {
+		name, row, typ string
+		change         func(*Instr)
+		proof          bool
+	}{
+		{"ordinary GP to X", "MOVL AX,X0", "uint32", nil, true},
+		{"ordinary X to GP", "MOVQ X0,AX", "uint32", nil, true},
+		{"ordinary X to X", "MOVD X0,X1", "uint32", nil, true},
+		// MMX has its own mandatory whole-source obligation. It must reject
+		// this uninitialized, unclosed source rather than bypass preflight.
+		{"physical MMX", "MOVQ X0,M0", "uint32", nil, true},
+		{"decoder origin", "VMOVD AX,X0", "uint32", func(ins *Instr) { ins.x86Encoded = true }, false},
+		{"raw source origin", "MOVL AX,X0", "uint32", func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{} }, false},
+		{"raw only", "VMOVW AX,X0", "uint32", func(ins *Instr) { ins.x86Encoded = true }, false},
+		// Bool has its independent mandatory canonical-byte proof even when
+		// no instruction happens to trigger the ordinary integer result route.
+		{"bool canonical proof", "MOVL AX,X0", "bool", nil, true},
+		{"floating is separate", "MOVL AX,X0", "float32", nil, false},
+		{"pointer is separate", "MOVL AX,X0", "*byte", nil, false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			declaration := "func view() " + test.typ + "\n"
+			pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+			if err != nil {
+				t.Fatal(err)
+			}
+			source := x86ResultGPSIMDAdmissionSource(t, "amd64", declaration, test.row)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if test.change != nil {
+				test.change(&file.Funcs[0].Instrs[1])
+			}
+			original := fmt.Sprintf("%#v", file)
+			consumer := &amd64Ctx{fpScalarSource: file.Funcs[0], sig: sig, fpResults: sig.Frame.Results, goarch: "amd64"}
+			first := consumer.validateScalarFPSourceViews()
+			second := consumer.validateScalarFPSourceViews()
+			if test.proof {
+				if !consumer.fpScalarChecked || !errors.Is(first, ErrProbeNeedsContext) || first != second {
+					t.Fatal("ordinary numerical result omitted or repeated its cached whole proof", first, second)
+				}
+			} else if consumer.fpScalarChecked || first != nil || second != nil {
+				t.Fatal("new ordinary trigger borrowed a disjoint result or native role", first, second)
+			}
+			if fmt.Sprintf("%#v", file) != original {
+				t.Fatal("preflight mutated original source")
+			}
+		})
+	}
+}
+
+func TestX86ResultGPSIMDAdmissionWholeSourcePathsWithoutProbe(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, test := range []struct {
+			name, body string
+			pass       bool
+		}{
+			{"one unknown branch", "MOVB c+0(FP),AX\nCMPB AX,$0\nJE joined\nMOVL $42,AX\njoined:\nMOVL AX,X0\nMOVL X0,BX\nMOVL BX,ret+RESULT(FP)", false},
+			{"all branches define", "MOVB c+0(FP),AX\nCMPB AX,$0\nJE other\nMOVL $42,AX\nJMP joined\nother:\nMOVL $43,AX\njoined:\nMOVL AX,X0\nMOVL X0,BX\nMOVL BX,ret+RESULT(FP)", true},
+			{"undefined result read", "MOVL ret+RESULT(FP),AX\nMOVL AX,X0\nMOVL X0,BX\nMOVL BX,ret+RESULT(FP)", false},
+			{"unknown transfer subsequently cleared", "MOVL AX,X0\nPXOR X0,X0\nMOVL X0,BX\nMOVL BX,ret+RESULT(FP)", true},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				declaration := "func view(c byte) uint32\n"
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, test.body)
+				x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, test.pass)
+			})
+		}
+	}
+}
diff --git a/x86_result_gp_simd_execution_driver_test.go b/x86_result_gp_simd_execution_driver_test.go
new file mode 100644
index 000000000..2ce74beec
--- /dev/null
+++ b/x86_result_gp_simd_execution_driver_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func x86GPSIMDSparseOriginalDriver(fixture x86GPSIMDSparseExecutionFixture) string {
+	var rows, seeds strings.Builder
+	for _, row := range fixture.rows {
+		fmt.Fprintf(&rows, "{%q,Seed%s,%d},\n", row.name, row.name, row.kind)
+	}
+	for _, seed := range x86GPSIMDSparseRuntimeSeeds {
+		fmt.Fprintf(&seeds, "0x%x,", seed)
+	}
+	return `package main
+import "fmt"
+` + fixture.declarations + fixture.wrapperDeclarations + `
+//go:noinline
+func snapshot(p *[4]uint64) [4]uint64 {return *p}
+func main() {
+ rows:=[]struct{name string;call func(byte,uint64)(uint32,uint32);kind int}{
+` + rows.String() + `}
+ seeds:=[]uint64{` + seeds.String() + `}
+ canaries:=[4]uint64{0x1122334455667788,0x8877665544332211,0xfedcba9876543210,0x123456789abcdef0}
+ before:=snapshot(&canaries)
+ hash:=uint64(1469598103934665603)
+ positive,unknown,guards:=0,0,0
+ for value:=0;value<256;value++ {for _,seed:=range seeds {for _,row:=range rows {
+  c:=byte(value)
+  got,guard:=row.call(c,seed)
+  want,wantGuard:=uint32(c),uint32(0xa7a7a7a7)
+  if row.kind==0 {want*=0x01010101}
+  if row.kind==1 {wantGuard=0xa7a7a700|uint32(c)}
+  if row.kind==3 {want=uint32(seed)&0xffffff00|uint32(c);unknown++}else{
+   hash^=uint64(got);hash*=1099511628211;positive++
+  }
+  if got!=want||guard!=wantGuard||snapshot(&canaries)!=before {
+   panic(fmt.Sprintf("%s c=%d seed=%x got=%x want=%x guard=%x wantGuard=%x",row.name,c,seed,got,want,guard,wantGuard))
+  }
+  guards++
+ }}}
+ fmt.Printf("GP/X positive checks=%d hash=%016x\n",positive,hash)
+ fmt.Printf("original unknown overwrite=%d outgoing/caller guards=%d\n",unknown,guards)
+}
+`
+}
+
+func x86GPSIMDSparseLLVMDriver(fixture x86GPSIMDSparseExecutionFixture) string {
+	var rows, declarations, seeds strings.Builder
+	for _, row := range fixture.rows {
+		if row.kind == 3 {
+			continue // No LLVM exists for the independent original unknown file.
+		}
+		typ := "uint32_t"
+		if row.kind == 1 {
+			typ = "uint8_t"
+		}
+		fmt.Fprintf(&declarations, "extern %s %s(uint8_t);\n", typ, row.name)
+		fmt.Fprintf(&rows, `{
+ uint32_t got=%s(c),want=c;
+ if(%d==0) want*=UINT32_C(0x01010101);
+ if(got!=want||canaries[0]!=left||canaries[1]!=right){
+  fprintf(stderr,"%s c=%%u seed=%%llx got=%%x want=%%x canary failure\n",c,(unsigned long long)seeds[s],got,want);return 1;
+ }
+ hash^=got;hash*=UINT64_C(1099511628211);calls++;
+}
+`, row.name, row.kind, row.name)
+	}
+	for _, seed := range x86GPSIMDSparseRuntimeSeeds {
+		fmt.Fprintf(&seeds, "UINT64_C(0x%x),", seed)
+	}
+	return `#include <stdint.h>
+#include <stdio.h>
+` + declarations.String() + `
+int main(void) {
+ const uint64_t seeds[]={` + seeds.String() + `};
+ uint64_t hash=UINT64_C(1469598103934665603);
+ unsigned calls=0;
+ for(unsigned value=0;value<256;value++)for(unsigned s=0;s<sizeof(seeds)/sizeof(seeds[0]);s++){
+  uint8_t c=(uint8_t)value;
+  uint64_t left=seeds[s]^UINT64_C(0x1122334455667788),right=seeds[s]^UINT64_C(0x8877665544332211);
+  volatile uint64_t canaries[]={left,right};
+` + rows.String() + `
+ }
+ printf("GP/X positive checks=%u hash=%016llx\n",calls,(unsigned long long)hash);
+ printf("LLVM caller guards=%u\n",calls);
+ return 0;
+}
+`
+}
+
+// Both native owners and an explicitly named execution-prefix diagnostic can
+// share this oracle. The caller alone establishes which execution role it owns.
+func x86GPSIMDSparseExecuteOriginalAndLLVM(t *testing.T, arch string, execution x86FloatCompareExecution) {
+	t.Helper()
+	op := "MOVD"
+	if arch == "386" {
+		op = "MOVL"
+	}
+	fixture := x86GPSIMDSparseExecutionFixtureFor(t, arch, []string{op})
+	dir := t.TempDir()
+	sources := map[string]string{
+		"go.mod":                  "module sparsegpsimd\n\ngo 1.20\n",
+		"main.go":                 x86GPSIMDSparseOriginalDriver(fixture),
+		"positive_" + arch + ".s": fixture.positive,
+		"negative_" + arch + ".s": fixture.negative,
+		"callers_" + arch + ".s":  fixture.wrappers,
+	}
+	for name, source := range sources {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	original := filepath.Join(dir, "original")
+	goDriver, driverHash := x86LEAActualSDKDriver(t)
+	command := exec.Command(goDriver, "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOFLAGS=", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	verifyOriginal := func() {
+		for name, source := range sources {
+			actual, err := os.ReadFile(filepath.Join(dir, name))
+			if err != nil || string(actual) != source {
+				t.Fatal("complete original source changed", name, err)
+			}
+		}
+		if actualDriver, actualHash := x86LEAActualSDKDriver(t); actualDriver != goDriver || actualHash != driverHash {
+			t.Fatal("original source driver changed")
+		}
+	}
+	verifyOriginal()
+	t.Logf("original driver SHA256=%x positive=%x negative=%x callers=%x", driverHash,
+		sha256.Sum256([]byte(fixture.positive)), sha256.Sum256([]byte(fixture.negative)), sha256.Sum256([]byte(fixture.wrappers)))
+	want := x86GPSIMDSparseExecutionExpected(fixture)
+	run := func(executable string) []byte {
+		if arch != "386" {
+			return execution.run(t, executable)
+		}
+		sealed, err := x87IA32StaticExecutable(executable)
+		if err != nil {
+			t.Fatal("actual i386 source needs its complete static ELF", err)
+		}
+		if len(execution.prefix) == 0 {
+			return x87IA32RunDirect(t, sealed, nil, os.Environ())
+		}
+		// An explicitly separate prefix diagnostic may execute the same
+		// sealed ELF, but it is not the required native owner above.
+		if err := sealed.verify(); err != nil {
+			t.Fatal(err)
+		}
+		output := execution.run(t, executable)
+		if err := sealed.verify(); err != nil {
+			t.Fatal(err)
+		}
+		return output
+	}
+	originalOutput := run(original)
+	originalWant := want + "original unknown overwrite=1280 outgoing/caller guards=5120\n"
+	if string(originalOutput) != originalWant {
+		t.Fatalf("complete original Go high-byte/slot observation: got=%q want=%q", originalOutput, originalWant)
+	}
+	t.Logf("arch=%s original Go: %s", arch, strings.TrimSpace(string(originalOutput)))
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			badIR, err := x86ScalarFPBitViewAPI(t, fixture.negative, fixture.declarations, arch, execution.triple, api)
+			if !errors.Is(err, ErrProbeNeedsContext) || badIR != "" {
+				t.Fatal("actual original unknown-overwrite source gained a translated return", err)
+			}
+			ir, err := x86ScalarFPBitViewAPI(t, fixture.positive, fixture.declarations, arch, execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete sparse source failed to translate", err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(level, func(t *testing.T) {
+					input := ir
+					if level == "-O2" {
+						input = x86MulDivRoundOptimize(t, input)
+					}
+					executable := execution.compileLLVM(t, "sparse-gp-x", input, x86GPSIMDSparseLLVMDriver(fixture), level)
+					output := run(executable)
+					if string(output) != want+"LLVM caller guards=3840\n" {
+						t.Fatal("LLVM byte/result/canary oracle differs from original Go:", string(output))
+					}
+					t.Logf("arch=%s original/LLVM common: %s", arch, strings.TrimSpace(want))
+				})
+			}
+		})
+	}
+	verifyOriginal()
+}
diff --git a/x86_result_gp_simd_execution_fixture_test.go b/x86_result_gp_simd_execution_fixture_test.go
new file mode 100644
index 000000000..1a5347868
--- /dev/null
+++ b/x86_result_gp_simd_execution_fixture_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+type x86GPSIMDSparseExecutionRow struct {
+	name, declaration string
+	kind              int
+}
+
+type x86GPSIMDSparseExecutionFixture struct {
+	positive, negative, declarations, wrappers, wrapperDeclarations string
+	rows                                                            []x86GPSIMDSparseExecutionRow
+}
+
+// The same complete positive and negative source files feed both original Go
+// and LLVM. Separate original-only callers seed the otherwise unknown incoming
+// AX bytes and observe outgoing-slot canaries; they grant no translation role.
+func x86GPSIMDSparseExecutionFixtureFor(t *testing.T, arch string, ops []string) x86GPSIMDSparseExecutionFixture {
+	t.Helper()
+	fixture := x86GPSIMDSparseExecutionFixture{wrappers: "#include \"funcdata.h\"\n"}
+	for _, op := range ops {
+		for kind, prefix := range []string{"Broadcast", "Copy", "Whole", "Bad"} {
+			name, result := prefix+op, "uint32"
+			input := "MOVB c+0(FP),AX\n"
+			if kind == 1 {
+				result = "byte"
+			} else if kind == 2 {
+				input = "MOVBLZX c+0(FP),AX\n"
+			}
+			body := input + op + " AX,X0\n"
+			if kind == 0 {
+				body += "PUNPCKLBW X0,X0\nPUNPCKLBW X0,X0\nPSHUFL $0,X0,X0\nMOVL X0,BX\n"
+			} else {
+				if kind == 3 {
+					body += "MOVL $0,BX\n"
+				}
+				body += op + " X0,BX\n"
+			}
+			store := "MOVL"
+			if kind == 1 {
+				store = "MOVB"
+			}
+			body += store + " BX,ret+RESULT(FP)"
+			declaration := fmt.Sprintf("func %s(c byte) %s\n", name, result)
+			source := x86ResultGPSIMDAdmissionSource(t, arch, "func view(c byte) "+result+"\n", body)
+			source = strings.Replace(source, "·view", "·"+name, 1)
+			if kind == 3 {
+				fixture.negative += source
+			} else {
+				fixture.positive += source
+			}
+			fixture.declarations += declaration
+			fixture.rows = append(fixture.rows, x86GPSIMDSparseExecutionRow{name, declaration, kind})
+			wrapperDeclaration := fmt.Sprintf("func Seed%s(c byte,seed uint64)(value uint32,guard uint32)\n", name)
+			pkg := mustGoPackage(t, "sparse", "package sparse\n"+wrapperDeclaration)
+			sig, err := DeriveGoFuncABI0Signature("Seed"+name, pkg.Types.Scope().Lookup("Seed"+name).(*types.Func), arch, types.SizesFor("gc", arch))
+			if err != nil || len(sig.Frame.Params) != 2 || len(sig.Frame.Results) != 2 {
+				t.Fatal("original caller must have its actual typed ABI0 layout", err)
+			}
+			word, seedMove := int64(8), "MOVQ"
+			if arch == "386" {
+				word, seedMove = 4, "MOVL"
+			}
+			if sig.Frame.Params[0].Offset != 0 || sig.Frame.Params[1].Offset != word ||
+				sig.Frame.Results[0].Offset != word+8 || sig.Frame.Results[1].Offset != word+12 {
+				t.Fatalf("original caller layout changed: %#v", sig.Frame)
+			}
+			load, guard := "MOVL", word+4
+			if kind == 1 {
+				load, guard = "MOVBLZX", word // Preserve the three bytes after the byte result.
+			}
+			fixture.wrapperDeclarations += wrapperDeclaration
+			fixture.wrappers += fmt.Sprintf(`TEXT ·Seed%s(SB),4,$16-%d
+NO_LOCAL_POINTERS
+MOVL $0xa7a7a7a7,0(SP)
+MOVL $0xa7a7a7a7,4(SP)
+MOVL $0xa7a7a7a7,8(SP)
+MOVL $0xa7a7a7a7,12(SP)
+MOVB c+0(FP),CX
+MOVB CX,0(SP)
+%s seed+%d(FP),AX
+CALL ·%s(SB)
+%s %d(SP),BX
+MOVL %d(SP),DX
+MOVL BX,value+%d(FP)
+MOVL DX,guard+%d(FP)
+RET
+`, name, word+16, seedMove, word, name, load, word, guard, word+8, word+12)
+		}
+	}
+	return fixture
+}
+
+var x86GPSIMDSparseRuntimeSeeds = []uint64{
+	0, ^uint64(0), 0x1122334455667788, 0x8877665544332211, 0x8000000000000000,
+}
+
+func x86GPSIMDSparseExecutionExpected(fixture x86GPSIMDSparseExecutionFixture) string {
+	hash, calls := uint64(1469598103934665603), 0
+	for value := 0; value < 256; value++ {
+		for range x86GPSIMDSparseRuntimeSeeds {
+			for _, row := range fixture.rows {
+				if row.kind == 3 {
+					continue
+				}
+				result := uint32(value)
+				if row.kind == 0 {
+					result *= 0x01010101
+				}
+				hash = (hash ^ uint64(result)) * 1099511628211
+				calls++
+			}
+		}
+	}
+	return fmt.Sprintf("GP/X positive checks=%d hash=%016x\n", calls, hash)
+}
+
+func TestX86ResultGPSIMDSparseExecutionFixturesRetainUnknownBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		op := "MOVD"
+		if arch == "386" {
+			op = "MOVL"
+		}
+		fixture := x86GPSIMDSparseExecutionFixtureFor(t, arch, []string{op})
+		if strings.Contains(fixture.positive, "PEXTR") || strings.Contains(fixture.positive, "MOVL $0,AX") ||
+			strings.Count(fixture.positive, "PUNPCKLBW X0,X0") != 2 || strings.Count(fixture.positive, "PSHUFL $0,X0,X0") != 1 {
+			t.Fatal("fixture hid the sparse transfer behind a probe or fake zero")
+		}
+		if len(fixture.rows) != 4 || strings.Count(fixture.wrappers, "CALL ·") != 4 ||
+			len(x86GPSIMDSparseRuntimeSeeds) != 5 || x86GPSIMDSparseRuntimeSeeds[2]&0xffffff00 == 0 {
+			t.Fatal("original incoming-byte trap or complete caller inventory missing")
+		}
+		pkg := mustGoPackage(t, "sparse", "package sparse\n"+fixture.declarations)
+		for _, test := range []struct {
+			source string
+			pass   bool
+		}{{fixture.positive, true}, {fixture.negative, false}} {
+			file, err := Parse(ArchAMD64, test.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(fn, sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("original fixture changed the unknown-byte boundary", test.pass, err)
+					}
+				}
+			}
+		}
+		t.Log(arch, strings.TrimSpace(x86GPSIMDSparseExecutionExpected(fixture)))
+	}
+}
diff --git a/x86_result_gp_simd_execution_linux_amd64_test.go b/x86_result_gp_simd_execution_linux_amd64_test.go
new file mode 100644
index 000000000..a97b85b0e
--- /dev/null
+++ b/x86_result_gp_simd_execution_linux_amd64_test.go
@@ -0,0 +1,35 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+// These are required actual native Linux counterparts. Neither Rosetta nor a
+// QEMU/binfmt route is allowed to count as execution of these owners.
+func TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNativeAMD64OriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("native sparse-byte owner requires LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	x86GPSIMDSparseExecuteOriginalAndLLVM(t, "amd64", execution)
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNative386OriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatal("native 386 sparse-byte owner requires LLVM22/i686 compiler", err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie"}}
+	x86GPSIMDSparseExecuteOriginalAndLLVM(t, "386", execution)
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_result_gp_simd_execution_objects_test.go b/x86_result_gp_simd_execution_objects_test.go
new file mode 100644
index 000000000..7ec1adc54
--- /dev/null
+++ b/x86_result_gp_simd_execution_objects_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86ResultGPSIMDSparseOriginalGoAndLLVMFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("five-target GP/X source/object counterpart requires LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			ops := []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"}
+			if target.arch == "386" {
+				ops = []string{"MOVL", "VMOVD", "VMOVQ"}
+			}
+			fixture := x86GPSIMDSparseExecutionFixtureFor(t, target.arch, ops)
+			positive := x86LEAActualTargetGoObject(t, target.arch, target.triple, fixture.positive)
+			negative := x86LEAActualTargetGoObject(t, target.arch, target.triple, fixture.negative)
+			if positive.Source == negative.Source || positive.Object == negative.Object {
+				t.Fatal("independent positive/unknown files borrowed one original object")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, fixture.positive, fixture.declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete byte/GP-X source lost its original target", err)
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input := ir
+						if optimizeIR {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimizeIR, level), func(t *testing.T) {
+								// The existing owned object driver checks the actual
+								// command and a nonempty regular target artifact.
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+					badIR, err := x86ScalarFPBitViewAPI(t, fixture.negative, fixture.declarations, target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || badIR != "" {
+						t.Fatal("complete original unknown-return file published LLVM", err)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_gp_simd_execution_policy_test.go b/x86_result_gp_simd_execution_policy_test.go
new file mode 100644
index 000000000..6bfdfdbed
--- /dev/null
+++ b/x86_result_gp_simd_execution_policy_test.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultGPSIMDSparseRuntimeNativeOwnerCannotEmulateOrSkip(t *testing.T) {
+	const path = "x86_result_gp_simd_execution_linux_amd64_test.go"
+	source, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	source = normalizeNativeOwnerPolicySource(source)
+	if !strings.HasPrefix(string(source), "//go:build linux && amd64\n") {
+		t.Fatal("both required runtime counterparts lost their actual native owner")
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, source, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	roots := map[string]string{
+		"TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNativeAMD64OriginalGoAndLLVM": "amd64",
+		"TestCrossLinuxRuntimeMatrixX86GPSIMDSparseNative386OriginalGoAndLLVM":   "386",
+	}
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok {
+			continue
+		}
+		arch, required := roots[fn.Name.Name]
+		if !required {
+			continue
+		}
+		gates, executions := 0, 0
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			switch value := node.(type) {
+			case *ast.CallExpr:
+				if name, ok := value.Fun.(*ast.Ident); ok {
+					if name.Name == "x87IA32RequireNativeHost" {
+						gates++
+					}
+					if name.Name == "x86GPSIMDSparseExecuteOriginalAndLLVM" {
+						executions++
+						if len(value.Args) != 3 {
+							t.Fatal("runtime oracle lost its complete explicit architecture")
+						}
+						literal, ok := value.Args[1].(*ast.BasicLit)
+						if !ok || literal.Value != strconv.Quote(arch) {
+							t.Fatal("native owner selected another source architecture")
+						}
+					}
+				}
+				if name, ok := value.Fun.(*ast.SelectorExpr); ok && strings.HasPrefix(name.Sel.Name, "Skip") {
+					t.Fatal("missing native tools or a failed owner cannot skip")
+				}
+			case *ast.KeyValueExpr:
+				if name, ok := value.Key.(*ast.Ident); ok && (name.Name == "prefix" || name.Name == "preserveArgv0") {
+					t.Fatal("native owner inserted a guest/emulator transport")
+				}
+			case *ast.BasicLit:
+				if value.Kind == token.STRING {
+					literal, err := strconv.Unquote(value.Value)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if strings.Contains(literal, "qemu") || literal == "-exec" {
+						t.Fatal("native owner inserted an execution fallback")
+					}
+				}
+			}
+			return true
+		})
+		if gates != 2 || executions != 1 {
+			t.Fatal("required before/after native observation or whole-source execution missing", fn.Name.Name, gates, executions)
+		}
+		delete(roots, fn.Name.Name)
+	}
+	if len(roots) != 0 {
+		t.Fatal("native runtime denominator is incomplete", roots)
+	}
+}
diff --git a/x86_result_gp_simd_sparse_test.go b/x86_result_gp_simd_sparse_test.go
new file mode 100644
index 000000000..f43265660
--- /dev/null
+++ b/x86_result_gp_simd_sparse_test.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultGPSIMDSparseByteBroadcastThreeAPIs(t *testing.T) {
+	for _, target := range []struct{ arch, triple, move string }{
+		{"amd64", "x86_64-unknown-linux-gnu", "MOVD"},
+		{"386", "i386-unknown-linux-gnu", "MOVL"},
+	} {
+		t.Run(target.arch, func(t *testing.T) {
+			declaration := "func view(c byte) uint32\n"
+			pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), target.arch, types.SizesFor("gc", target.arch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			result := int64(8)
+			if target.arch == "386" {
+				result = 4
+			}
+			if len(sig.Frame.Params) != 1 || sig.Frame.Params[0].Offset != 0 || sig.Frame.Params[0].Type != I8 ||
+				len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != result || sig.Frame.Results[0].Type != I32 {
+				t.Fatalf("fixture disagrees with actual typed ABI0 layout: %#v", sig.Frame)
+			}
+			source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVB c+0(FP),AX\n%s AX,X0\nPUNPCKLBW X0,X0\nPUNPCKLBW X0,X0\nPSHUFL $0,X0,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET\n", result+4, target.move, result)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+						t.Fatalf("known byte broadcast requires unused unknown GP bytes: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ResultGPSIMDSparseKnownByteMasksAndAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			qword := op == "MOVQ" || op == "MOVD" || op == "MOVDQ2Q" || op == "VMOVQ"
+			for _, direction := range []string{"gp-to-x", "x-to-gp", "x-to-x", "self"} {
+				gp := direction == "gp-to-x" || direction == "x-to-gp"
+				if !qword && !gp || arch == "386" && gp && qword && !strings.HasPrefix(op, "V") {
+					continue // Not part of the typed Go GP/X register grammar.
+				}
+				width, row := 4, op+" AX,X1"
+				if qword && !(arch == "386" && gp) {
+					width = 8
+				}
+				switch direction {
+				case "x-to-gp":
+					row = op + " X0,BX"
+				case "x-to-x":
+					row = op + " X0,X1"
+				case "self":
+					row = op + " X0,X0"
+				}
+				t.Run(arch+"/"+row, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row)
+					original := fmt.Sprintf("%#v", ins)
+					for seed := 0; seed < 256; seed++ {
+						initial := x86ResultState{flags: x86ByteFlagsAll}
+						initial.gp[0], initial.gp[3] = uint8(seed), 0xff
+						initial.pointerGP[3], initial.callerAddressGP[3], initial.canonicalGP[3] = true, true, 0xff
+						initial.xmm[0], initial.xmm[1] = 0x9b00|uint16(seed), 0x7531
+						initial.vectorUpper[0], initial.vectorUpper[1] = 0x5837bba945de0000, 0x7346edab91250000
+						initial.masks[1] = true
+						want := initial.clone()
+						// Independent per-byte oracle: source bytes below the width
+						// retain exactly their original knowledge. Only the bytes
+						// outside the transfer width are cleared by the instruction.
+						var vector uint16
+						var gpBytes uint8
+						for index := 0; index < 16; index++ {
+							if index >= width || seed&(1<<uint(index)) != 0 {
+								vector |= 1 << uint(index)
+								if index < 8 {
+									gpBytes |= 1 << uint(index)
+								}
+							}
+						}
+						if direction == "x-to-gp" {
+							want.gp[3] = gpBytes
+							want.pointerGP[3], want.callerAddressGP[3], want.canonicalGP[3] = false, false, 0
+						} else {
+							destination := 1
+							if direction == "self" {
+								destination = 0
+							}
+							want.xmm[destination] = vector
+							if strings.HasPrefix(op, "V") {
+								want.vectorUpper[destination] = ^uint64(0xffff)
+							}
+						}
+						for _, consumer := range x86ResultGPSIMDConsumers {
+							state := initial.clone()
+							if !consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+								t.Fatalf("%s seed=%02x: got=%#v want=%#v", consumer.name, seed, state, want)
+							}
+						}
+						if fmt.Sprintf("%#v", ins) != original {
+							t.Fatal("numerical propagation changed original source metadata")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultGPSIMDSparseGoAliasesFiveTargets(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			if target.arch == "386" && (op == "MOVQ" || op == "MOVD" || op == "MOVDQ2Q") {
+				continue // Those GP/X qword aliases have no mode32 Go row.
+			}
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				result := 8
+				if target.arch == "386" {
+					result = 4
+				}
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVB c+0(FP),AX\n%s AX,X0\nPUNPCKLBW X0,X0\nPUNPCKLBW X0,X0\nPSHUFL $0,X0,X0\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET\n", result+4, op, result)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func view(c byte) uint32\n", target.arch, target.triple, api); err != nil || ir == "" {
+							t.Fatal("typed alias lost sparse numerical dependencies", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDSparseUnknownResultBytesThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, pointerMove, word, triple := "MOVD", "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, pointerMove, word, triple = "MOVL", "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		prefix := "MOVB c+0(FP),AX\n" + move + " AX,X0\n"
+		broadcast := "PUNPCKLBW X0,X0\nPUNPCKLBW X0,X0\nPSHUFL $0,X0,X0\n"
+		finish := fmt.Sprintf("MOVL BX,ret+%d(FP)\nRET\n", word)
+		for _, test := range []struct {
+			name, body string
+			pass       bool
+		}{
+			{"whole unknown dword", prefix + "PEXTRD $0,X0,BX\n" + finish, false},
+			{"one interleave is insufficient", prefix + "PUNPCKLBW X0,X0\nPEXTRD $0,X0,BX\n" + finish, false},
+			{"selector needs next unknown byte", prefix + "PUNPCKLBW X0,X0\nPUNPCKLBW X0,X0\nPSHUFL $0x55,X0,X0\nPEXTRD $0,X0,BX\n" + finish, false},
+			{"unknown GP overwrites broadcast", prefix + broadcast + move + " CX,X0\nPEXTRD $0,X0,BX\n" + finish, false},
+			// The existing lane probe activates the whole-function result
+			// observer. This tests its transfer, not a new admission hook.
+			{"unknown X overwrites GP", prefix + "PEXTRD $3,X0,DX\nMOVL $0,BX\nMOVL X0,BX\n" + finish, false},
+			{"one path overwrites known input", prefix + "CMPB AX,$0\nJE done\n" + move + " CX,X0\ndone:\n" + broadcast + "PEXTRD $0,X0,BX\n" + finish, false},
+			{"known X old value is discarded", "PXOR X0,X0\n" + move + " AX,X0\nPEXTRD $0,X0,BX\n" + finish, false},
+			{"guaranteed cleared X bytes", prefix + "PEXTRD $3,X0,BX\n" + finish, true},
+			{"unknown numeric GP is discarded", move + " AX,X0\nPEXTRD $3,X0,BX\n" + finish, true},
+			{"opaque pointer is not numeric", fmt.Sprintf("%s p+0(FP),AX\n%s AX,X0\nPEXTRD $3,X0,BX\n", pointerMove, move) + finish, false},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				declaration := "func view(c byte) uint32\n"
+				if test.name == "opaque pointer is not numeric" {
+					declaration = "func view(p *byte) uint32\n"
+				}
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s", word+4, test.body)
+				pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+				sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("whole-function byte observer disagrees: pass=%t error=%v", test.pass, err)
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if test.pass {
+							if err != nil || ir == "" {
+								t.Fatal("discarded unknown numerical bytes became dependencies", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("unknown bytes or opaque identity supplied result authority: ir=%q err=%v", ir, err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDSparseRejectsUnboundSourceRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, test := range []struct {
+			name, row       string
+			pointer, caller bool
+		}{
+			{"opaque pointer", "MOVL AX,X1", true, false},
+			{"caller address", "MOVL AX,X1", false, true},
+			{"stack pointer", "MOVL SP,X1", false, false},
+			{"frame pointer", "MOVL BP,X1", false, false},
+			{"physical MMX", "MOVQ X0,M0", false, false},
+			{"unknown FP store", "MOVL X0,ret+4(FP)", false, false},
+			{"unknown SB store", "MOVL X0,table(SB)", false, false},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, test.row)
+				initial := x86ResultState{fp: make([]bool, 8), flags: x86ByteFlagsAll}
+				initial.gp[0], initial.xmm[1], initial.canonicalGP[0] = 0xff, 0xffff, 0xff
+				initial.pointerGP[0], initial.callerAddressGP[0] = test.pointer, test.caller
+				owned := make([]bool, 8)
+				for index := range owned {
+					owned[index] = true
+				}
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := initial.clone()
+					accepted := consumer.step(ins, &state, owned, 4, arch)
+					if arch == "386" && test.row == "MOVL BP,X1" {
+						// The ordinary register exists, but its low input bytes
+						// are unknown. Only X's architectural high zeros follow.
+						want := initial.clone()
+						want.xmm[1] = 0xfff0
+						if !accepted || !reflect.DeepEqual(state, want) {
+							t.Fatal("unknown mode32 BP acquired numerical low bytes", consumer.name, state)
+						}
+						continue
+					}
+					if accepted || !reflect.DeepEqual(state, initial) {
+						t.Fatalf("%s changed an unbound source role: got=%#v want=%#v", consumer.name, state, initial)
+					}
+				}
+			})
+		}
+		for missing := 0; missing < 8; missing++ {
+			t.Run(fmt.Sprintf("%s/full-memory-byte%d", arch, missing), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "MOVQ c+0(FP),X1")
+				state := x86ResultState{fp: make([]bool, 8)}
+				owned := make([]bool, 8)
+				for index := range owned {
+					owned[index], state.fp[index] = true, index != missing
+				}
+				before := state.clone()
+				if x86ScalarFPResultTransfer(ins, &state, owned, 8, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("sparse register rule reduced the complete memory read extent")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDSparseXToGPByteResultThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word, triple := "MOVD", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			if arch == "386" && (op == "MOVQ" || op == "MOVD" || op == "MOVDQ2Q") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				// Unknown X bytes are transported to GP unchanged. Only the
+				// known low byte becomes the result. The independent extraction
+				// of guaranteed-zero bytes activates the existing lane observer.
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVB c+0(FP),AX\n%s AX,X0\nPEXTRD $3,X0,DX\n%s X0,BX\nMOVB BX,ret+%d(FP)\nRET\n", word+1, move, op, word)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func view(c byte) byte\n", arch, triple, api); err != nil || ir == "" {
+							t.Fatal("discarded X-to-GP bytes became low-byte dependencies", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDSparseOfficialRegisterFormats(t *testing.T) {
+	rows := x86OfficialGPSIMDTransferRows(t)
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q"} {
+		rows = append(rows, op+" AX,X0", op+" X0,AX")
+		if op != "MOVL" {
+			rows = append(rows, op+" X0,X1")
+		}
+	}
+	if len(rows) != 23 {
+		t.Fatalf("complete GP/X register projection changed: %d, want 23", len(rows))
+	}
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row)
+			form, known, err := x86GPSIMDTransferProperties(ins, "amd64")
+			if !known || err != nil || form.memory != -1 || form.mmx {
+				t.Fatal("original table's numerical register role lost", known, err)
+			}
+			width := 8
+			if ins.Op == "MOVL" || ins.Op == "VMOVD" {
+				width = 4
+			}
+			if form.bits != 8*width {
+				t.Fatal("Go's typed source width changed", form.bits, width)
+			}
+			initial := x86ResultState{flags: x86ByteFlagsAll}
+			for index := range initial.gp {
+				initial.gp[index] = 0x05
+			}
+			for index := range initial.xmm {
+				initial.xmm[index], initial.vectorUpper[index] = 0xff05, 0x497eb58a129c0000
+			}
+			want := initial.clone()
+			var byteMask uint16
+			for index := 0; index < 16; index++ {
+				if index >= width || 0x05&(1<<uint(index)) != 0 {
+					byteMask |= 1 << uint(index)
+				}
+			}
+			if form.destinationX {
+				index, _ := amd64ParseXReg(ins.Args[1].Reg)
+				want.xmm[index] = byteMask
+				if strings.HasPrefix(string(ins.Op), "V") {
+					want.vectorUpper[index] = ^uint64(0xffff)
+				}
+			} else {
+				index, _, valid := x86ResultGP(ins.Args[1].Reg, int64(width), "amd64")
+				if !valid {
+					t.Fatal("official GP destination lost")
+				}
+				want.gp[index] = uint8(byteMask)
+			}
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := initial.clone()
+				if !consumer.step(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, want) {
+					t.Fatalf("%s omitted a complete original register row: got=%#v want=%#v", consumer.name, state, want)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_gp_simd_test.go b/x86_result_gp_simd_test.go
new file mode 100644
index 000000000..e89a39c14
--- /dev/null
+++ b/x86_result_gp_simd_test.go
@@ -0,0 +1,312 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86ResultGPSIMDConsumers = []struct {
+	name string
+	step func(Instr, *x86ResultState, []bool, int64, string) bool
+}{
+	{"public", x86ResultTransfer},
+	{"private", x86ScalarFPResultTransfer},
+}
+
+// Enumerate independent register axes, not the implementation's spec map.
+// SP and AMD64 BP retain their separate frame roles. Mode32 BP is an
+// ordinary GP; numerical availability still requires actual defined bytes.
+func x86ResultGPSIMDRegisterRows(arch string) []string {
+	gps := []string{"AX", "CX", "DX", "BX", "SI", "DI"}
+	if arch == "amd64" {
+		gps = append(gps, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	} else {
+		gps = append(gps, "BP")
+	}
+	var rows []string
+	seen := make(map[string]bool)
+	add := func(op, source, destination string) {
+		row := op + " " + source + "," + destination
+		if !seen[row] {
+			rows = append(rows, row)
+			seen[row] = true
+		}
+	}
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+		legacy := !strings.HasPrefix(op, "V")
+		gpLegal := arch != "386" || !legacy || op == "MOVL"
+		if gpLegal {
+			for _, gp := range gps {
+				add(op, gp, "X0")
+				add(op, "X0", gp)
+			}
+		}
+		limit := 8
+		if arch == "amd64" {
+			limit = 16
+			if !legacy {
+				limit = 32
+			}
+		}
+		for index := 0; index < limit; index++ {
+			x := fmt.Sprint("X", index)
+			if gpLegal {
+				add(op, "AX", x)
+				add(op, x, "AX")
+			}
+			if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+				add(op, x, x)
+				add(op, x, fmt.Sprint("X", (index+1)%limit))
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86ResultGPSIMDRegisterCompleteGoAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86ResultGPSIMDRegisterRows(arch)
+		goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", "", true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row)
+				before := fmt.Sprintf("%#v", ins)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					for index := range state.gp {
+						state.gp[index] = 0xff
+					}
+					for index := range state.xmm {
+						state.xmm[index] = 0xffff
+					}
+					if !consumer.step(ins, &state, nil, 0, arch) {
+						t.Errorf("%s omitted a Go-accepted numerical register effect", consumer.name)
+					}
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("result observer mutated original source metadata")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDRegisterIndependentEncoderRows(t *testing.T) {
+	// This existing independent oracle pins all 12 AVX rows: full prefix,
+	// zcase, row offset/advance, complete opcode bytes, W and tuple attributes.
+	rows := x86OfficialGPSIMDTransferRows(t)
+	for _, op := range []string{"MOVL", "MOVQ", "MOVD"} {
+		rows = append(rows, op+" AX,X0", op+" X0,AX")
+		if op != "MOVL" {
+			rows = append(rows, op+" X0,X1")
+		}
+	}
+	if len(rows) != 20 {
+		t.Fatalf("independent encoder witness denominator: %d, want 20", len(rows))
+	}
+	goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", "", true)
+	for _, row := range rows {
+		t.Run(row, func(t *testing.T) {
+			ins := x86YMMReadSource(t, row)
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{}
+				state.gp[0], state.xmm[0], state.xmm[17] = 0xff, 0xffff, 0xffff
+				if !consumer.step(ins, &state, nil, 0, "amd64") {
+					t.Errorf("%s lacks independent original-row effect", consumer.name)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultGPSIMDRegisterEveryInputByteAndOverwrite(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "MOVDQ2Q", "VMOVD", "VMOVQ"} {
+			qword := op == "MOVQ" || op == "MOVD" || op == "MOVDQ2Q" || op == "VMOVQ"
+			for _, direction := range []string{"gp-to-x", "x-to-gp", "x-to-x", "self"} {
+				gp := direction == "gp-to-x" || direction == "x-to-gp"
+				if !qword && !gp || arch == "386" && gp && qword && !strings.HasPrefix(op, "V") {
+					continue
+				}
+				width, row := 4, op+" AX,X1"
+				if qword {
+					width = 8
+				}
+				if arch == "386" && gp {
+					width = 4 // VEX.W is ignored for mode32 GP operands only.
+				}
+				switch direction {
+				case "x-to-gp":
+					row = op + " X0,BX"
+				case "x-to-x":
+					row = op + " X0,X1"
+				case "self":
+					row = op + " X0,X0"
+				}
+				t.Run(arch+"/"+op+"/"+direction, func(t *testing.T) {
+					ins := x86YMMReadSource(t, row)
+					for missing := -1; missing < 16; missing++ {
+						initial := x86ResultState{flags: x86ByteFlagsAll}
+						initial.gp[0], initial.xmm[0], initial.xmm[1] = 0xff, 0xffff, 0x5151
+						initial.pointerGP[3], initial.callerAddressGP[3] = true, true
+						initial.canonicalGP[3] = 0xff
+						if missing >= 0 {
+							if direction == "gp-to-x" {
+								initial.gp[0] &^= uint8(1) << uint(missing)
+							} else {
+								initial.xmm[0] &^= uint16(1) << uint(missing)
+							}
+						}
+						want := initial.clone()
+						mask := uint16(1)<<uint(width) - 1
+						known := initial.xmm[0] & mask
+						if direction == "gp-to-x" {
+							known = uint16(initial.gp[0]) & mask
+						}
+						switch direction {
+						case "gp-to-x", "x-to-x":
+							want.xmm[1] = known | 0xffff&^mask
+							if strings.HasPrefix(op, "V") {
+								want.vectorUpper[1] = ^uint64(0xffff)
+							}
+						case "self":
+							want.xmm[0] = known | 0xffff&^mask
+							if strings.HasPrefix(op, "V") {
+								want.vectorUpper[0] = ^uint64(0xffff)
+							}
+						case "x-to-gp":
+							want.gp[3] = uint8(known) | ^uint8(mask)
+							want.pointerGP[3], want.callerAddressGP[3], want.canonicalGP[3] = false, false, 0
+						}
+						for _, consumer := range x86ResultGPSIMDConsumers {
+							state := initial.clone()
+							if got := consumer.step(ins, &state, nil, 0, arch); !got || !reflect.DeepEqual(state, want) {
+								t.Fatalf("%s missing byte %d: accepted=%t, state=%#v want=%#v", consumer.name, missing, got, state, want)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultGPSIMDRegisterAllPathsAndAuthorityBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word := "MOVQ", 8
+		if arch == "386" {
+			move, word = "MOVL", 4
+		}
+		finish := fmt.Sprintf("PEXTRD $0,X0,BX\nMOVL BX,ret0+%d(FP)\nRET", word)
+		for name, test := range map[string]struct {
+			body string
+			pass bool
+		}{
+			"defined input":                  {"MOVL n+0(FP),AX\nMOVL AX,X0\n" + finish, true},
+			"both branches":                  {"MOVL n+0(FP),AX\nCMPL AX,$0\nJE other\nMOVL AX,X0\nJMP done\nother:\nVMOVD AX,X0\ndone:\n" + finish, true},
+			"unknown GP":                     {"MOVL AX,X0\n" + finish, false},
+			"partial GP":                     {"MOVW $7,AX\nMOVL AX,X0\n" + finish, false},
+			"one branch only":                {"MOVL n+0(FP),AX\nCMPL AX,$0\nJE done\nMOVL AX,X0\ndone:\n" + finish, false},
+			"unknown branch overwrite":       {"MOVL n+0(FP),AX\nMOVL AX,X0\nCMPL AX,$0\nJE done\nMOVL CX,X0\ndone:\n" + finish, false},
+			"pointee is not numeric":         {move + " p+0(FP),AX\nMOVL (AX),CX\nMOVL CX,X0\n" + finish, false},
+			"opaque identity is not numeric": {move + " p+0(FP),AX\nMOVL AX,X0\n" + finish, false},
+			"opaque VEX identity":            {move + " p+0(FP),AX\nVMOVQ AX,X0\n" + finish, false},
+			"SP role":                        {"MOVL SP,X0\n" + finish, false},
+			"BP role":                        {"MOVL BP,X0\n" + finish, false},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				declaration := "func Value(n uint32) uint32"
+				if strings.HasPrefix(name, "opaque") || strings.HasPrefix(name, "pointee") {
+					declaration = "func Value(p *byte) uint32"
+				}
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, test.body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("all-path numerical proof changed authority: pass=%t error=%v", test.pass, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+// Retain the original failing public-consumer sequence, including the opaque
+// MOVD import, rather than substituting PINSRD for its GP-to-X MOVL effect.
+func TestX86ResultGPSIMDRegisterOriginalOpaqueAliasWitness(t *testing.T) {
+	for _, register := range []string{"AX", "CX", "DX", "BX", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		t.Run(register, func(t *testing.T) {
+			body := fmt.Sprintf("MOVD x+0(FP),%s\nMOVD %s,SI\nMOVL $42,DX\nMOVL DX,X0\nPEXTRD $0,X0,BX\nMOVL BX,ret0+8(FP)\nRET", register, register)
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x *byte) uint32", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, "amd64"); err != nil {
+					t.Fatal("original GP/X witness still lacks complete numerical result effect", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultGPSIMDRegisterDoesNotAdoptPrivateMemoryRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := x86ResultPointerWord(arch)
+		for name, body := range map[string]string{
+			"logical FP load": fmt.Sprintf("MOVL x+0(FP),X0\nPEXTRD $0,X0,AX\nMOVL AX,ret0+%d(FP)\nRET", word),
+			"static SB store": fmt.Sprintf("MOVL x+0(FP),AX\nMOVL AX,X0\nMOVL X0,table(SB)\nMOVL AX,ret0+%d(FP)\nRET", word),
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x uint32) uint32", body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("public register consumer acquired a private memory role", err)
+				}
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal("existing private memory effect changed", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultGPSIMDRegisterThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"MOVL", "MOVQ", "MOVD", "VMOVD", "VMOVQ"} {
+			if target.arch == "386" && (op == "MOVQ" || op == "MOVD") {
+				continue // Those GP/X forms are rejected by Go, not a skipped test.
+			}
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				word, move, typ := 8, "MOVL", "uint32"
+				if target.arch == "386" {
+					word = 4
+				} else if op == "MOVQ" || op == "MOVD" || op == "VMOVQ" {
+					move, typ = "MOVQ", "uint64"
+				}
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s x+0(FP),AX\n%s AX,X0\nMOVQ X0,X1\n%s X1,BX\n%s BX,ret+%d(FP)\nRET\n", 2*word, move, op, op, move, word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, target.arch, "func Value(x "+typ+") "+typ,
+					fmt.Sprintf("%s x+0(FP),AX\n%s AX,X0\nMOVQ X0,X1\n%s X1,BX\n%s BX,ret0+%d(FP)\nRET", move, op, op, move, word))
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(x "+typ+") "+typ+"\n", target.arch, target.triple, api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "result-gp-x.ll", "result-gp-x.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_ifma.go b/x86_result_ifma.go
new file mode 100644
index 000000000..d2e6c0aa8
--- /dev/null
+++ b/x86_result_ifma.go
@@ -0,0 +1,71 @@
+package plan9asm
+
+func x86RawIFMASource(ins Instr, arch string) bool {
+	_, known, err := x86IFMAProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86ResultIFMAStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86IFMAProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	return x86IFMAResultTransfer(ins, form, state, owned, arch, false), true
+}
+
+func x86LoweredIFMAStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86IFMAProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawIFMASource(ins, arch) {
+			return false, true
+		}
+		// Keep the independently validated physical form. Clearing local
+		// provenance must not reparse it under a named mode32 operand cap.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86IFMAResultTransfer(ins, form, state, owned, arch, true), true
+}
+
+func x86IFMAResultTransfer(ins Instr, form x86IFMAForm, state *x86ResultState, owned []bool, arch string, native bool) bool {
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false
+		}
+	}
+	first := ins.Args[form.first]
+	var input uint64
+	if first.Kind == OpReg {
+		index, _ := amd64VectorRegisterIndex(first.Reg, form.byteWidth)
+		input = state.vectorBytes(index)
+	} else {
+		if !x86ResultReadWithNativeContinuation(ins, first, int64(form.memoryBytes), state, owned, arch, native) {
+			return false
+		}
+		input = ^uint64(0) // Conditional numerical bytes, never a reusable backing fact.
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	other, old := state.vectorBytes(second), state.vectorBytes(destination)
+	var defined uint64
+	for offset := 0; offset < form.byteWidth; offset += 8 {
+		// Bits 51:0 require seven source bytes, not irrelevant byte7. The
+		// complete eight-byte accumulator is data even with EVEX.z.
+		firstMask := uint64(0x7f) << uint(offset)
+		if form.broadcast {
+			firstMask = 0x7f
+		}
+		otherMask, output := uint64(0x7f)<<uint(offset), uint64(0xff)<<uint(offset)
+		if input&firstMask == firstMask && other&otherMask == otherMask && old&output == output {
+			defined |= output
+		}
+	}
+	state.writeVector(destination, form.byteWidth, defined, false)
+	return true // Unknown register results remain unknown; FLAGS and pointer roles are unchanged.
+}
diff --git a/x86_result_immediate_blend.go b/x86_result_immediate_blend.go
new file mode 100644
index 000000000..f43233624
--- /dev/null
+++ b/x86_result_immediate_blend.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+// Byte selection does not initialize the unselected register bytes or create
+// a pointer. Native memory still reads the complete tuple even at imm8=0.
+func x86ResultImmediateBlendStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86ImmediateBlendProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(local) {
+		if !native || !x86RawImmediateBlendSource(ins, arch) {
+			return false, true
+		}
+		// Preserve the already validated physical form. Reparsing this
+		// projection would incorrectly apply Go386's named operand limit.
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	var first uint64
+	if f.memory {
+		if !x86ResultReadWithNativeContinuation(local, ins.Args[f.source], int64(f.byteWidth), state, owned, arch, native) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(f.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[f.source].Reg, f.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	baseIndex, _ := amd64VectorRegisterIndex(ins.Args[f.base].Reg, f.byteWidth)
+	base := state.vectorBytes(baseIndex)
+	var defined uint64
+	for output := 0; output < f.byteWidth; output++ {
+		source := base
+		if f.selectsFirst(output) {
+			source = first
+		}
+		defined |= (source >> uint(output) & 1) << uint(output)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	state.writeVector(destination, f.byteWidth, defined, f.legacy)
+	return true, true
+}
+
+func x86RawImmediateBlendSource(ins Instr, arch string) bool {
+	f, known, err := x86ImmediateBlendProperties(ins.Op, ins, arch)
+	return known && err == nil && ins.x86Encoded != f.legacy &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, f.source)
+}
diff --git a/x86_result_immediate_compare_test.go b/x86_result_immediate_compare_test.go
new file mode 100644
index 000000000..d0e7a06d9
--- /dev/null
+++ b/x86_result_immediate_compare_test.go
@@ -0,0 +1,233 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This inventory follows all eight Go _yvpcmpb members independently of the
+// implementation's lowering table. Every member has X/Y/Z and an optional
+// K1-K7 input mask; its result is K0-K7, never a vector merge destination.
+var x86ImmediateCompareResultMembers = []string{
+	"VPCMPB", "VPCMPW", "VPCMPD", "VPCMPQ",
+	"VPCMPUB", "VPCMPUW", "VPCMPUD", "VPCMPUQ",
+}
+
+func TestX86ImmediatePackedCompareMaskAvailability(t *testing.T) {
+	for _, op := range x86ImmediateCompareResultMembers {
+		for _, vector := range []struct {
+			bank  string
+			bytes int
+		}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+			for _, masked := range []bool{false, true} {
+				name := fmt.Sprintf("%s/%s/masked-%t", op, vector.bank, masked)
+				t.Run(name, func(t *testing.T) {
+					mask := ""
+					if masked {
+						mask = "K2,"
+					}
+					row := fmt.Sprintf("%s $4,%s0,%s1,%sK2", op, vector.bank, vector.bank, mask)
+					ins := x86ScalarLaneInstruction(t, row)
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.writeVector(0, 64, ^uint64(0), false)
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.masks[2] = masked
+					before := state.clone()
+					if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatal("complete Go immediate comparison has no numerical mask-result effect", row)
+					}
+					before.masks[2] = true
+					if !reflect.DeepEqual(state, before) {
+						t.Fatal("mask comparison changed vectors, FLAGS, DF or unrelated state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ImmediatePackedCompareMissingBytesRemainUnknown(t *testing.T) {
+	for _, op := range x86ImmediateCompareResultMembers {
+		for _, vector := range []struct {
+			bank  string
+			bytes int
+		}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+			t.Run(op+"/"+vector.bank, func(t *testing.T) {
+				for _, predicate := range []int{3, 4, 7} {
+					row := fmt.Sprintf("%s $%d,%s0,%s1,K1,K2", op, predicate, vector.bank, vector.bank)
+					ins := x86ScalarLaneInstruction(t, row)
+					for _, maskKnown := range []bool{false, true} {
+						for input := 0; input < 2; input++ {
+							for missing := 0; missing < vector.bytes; missing++ {
+								state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: maskKnown}}
+								state.writeVector(0, 64, ^uint64(0), false)
+								state.writeVector(1, 64, ^uint64(0), false)
+								state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+								before := state.clone()
+								if x86ResultTransfer(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+									t.Fatalf("undefined comparison became numerical: %s mask=%t input=%d missing=%d", row, maskKnown, input, missing)
+								}
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImmediatePackedCompareResultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Go's mode32 frontend rejects these four/five-operand rows.
+		}
+		for _, op := range x86ImmediateCompareResultMembers {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				body := fmt.Sprintf("MOVQ x+0(FP),AX\nMOVQ AX,X0\nVPBROADCASTQ X0,Z0\n"+
+					"VPXORD Z1,Z1,Z1\n%s $4,%s1,%s0,K2\nKMOVQ K2,AX\nMOVQ AX,ret+8(FP)\nRET\n", op, bank, bank)
+				source := "TEXT ·Value(SB),4,$0-16\n" + body
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+bank+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x uint64) uint64", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("initialized immediate compare cannot publish its mask result", err)
+						}
+						bits := 8
+						switch op {
+						case "VPCMPW", "VPCMPUW":
+							bits = 16
+						case "VPCMPD", "VPCMPUD":
+							bits = 32
+						case "VPCMPQ", "VPCMPUQ":
+							bits = 64
+						}
+						lanes := map[string]int{"X": 128, "Y": 256, "Z": 512}[bank] / bits
+						for _, input := range []struct {
+							literal string
+							want    uint64
+						}{{"0", 0}, {"-1", ^uint64(0) >> uint(64-lanes)}} {
+							probe := fmt.Sprintf("\ndefine i64 @Probe() {\n %%r = call i64 @Value(i64 %s)\n ret i64 %%r\n}\n", input.literal)
+							x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{input.want})
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImmediatePackedCompareDeadMemoryRemainsObservable(t *testing.T) {
+	for _, op := range x86ImmediateCompareResultMembers {
+		bits := 8
+		switch op {
+		case "VPCMPW", "VPCMPUW":
+			bits = 16
+		case "VPCMPD", "VPCMPUD":
+			bits = 32
+		case "VPCMPQ", "VPCMPUQ":
+			bits = 64
+		}
+		for _, vector := range []struct {
+			bank  string
+			bytes int
+		}{{"X", 16}, {"Y", 32}, {"Z", 64}} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && bits < 32 {
+					continue // No Go broadcast row for B/W, signed or unsigned.
+				}
+				for _, mask := range []string{"none", "zero", "all"} {
+					name := fmt.Sprintf("%s/%s/broadcast-%t/%s", op, vector.bank, broadcast, mask)
+					t.Run(name, func(t *testing.T) {
+						suffix, inputMask, setup := "", "", ""
+						if broadcast {
+							suffix = ".BCST"
+						}
+						if mask != "none" {
+							value := "0"
+							if mask == "all" {
+								value = "-1"
+							}
+							setup = "MOVQ $" + value + ",CX\nKMOVQ CX,K1\n"
+							inputMask = "K1,"
+						}
+						// Predicate 3 is always false, and K2 is dead. Its active
+						// native memory access must nevertheless remain observable.
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),AX\nVPXORD Z0,Z0,Z0\n%s%s%s $3,(AX),%s0,%sK2\nRET\n",
+							setup, op, suffix, vector.bank, inputMask)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte)", "amd64", "x86_64-unknown-linux-gnu", "text")
+						if err != nil {
+							t.Fatal("valid native-memory comparison did not translate", err)
+						}
+						optimized := x86MulDivRoundOptimize(t, ir)
+						if mask == "zero" {
+							if strings.Contains(optimized, "load volatile") {
+								t.Fatal("fully inactive comparison still accesses native memory")
+							}
+							return
+						}
+						bytes := vector.bytes
+						if broadcast {
+							bytes = bits / 8
+						}
+						for _, input := range []string{ir, optimized} {
+							// An unmasked tuple may use one vector read; masked
+							// active lanes may use separate scalar volatile reads.
+							if got := x86ImmediateCompareVolatileReadBytes(input); got != bytes {
+								t.Fatal("dead comparison lost its exact active native tuple", got, bytes)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86ImmediateCompareVolatileReadBytes(ir string) int {
+	pattern := regexp.MustCompile(`load volatile (?:i([0-9]+)|<([0-9]+) x i([0-9]+)>),[^\r\n]*, align 1(?:[^0-9]|$)`)
+	bytes := 0
+	for _, match := range pattern.FindAllStringSubmatch(ir, -1) {
+		bits, _ := strconv.Atoi(match[1])
+		if match[2] != "" {
+			lanes, _ := strconv.Atoi(match[2])
+			width, _ := strconv.Atoi(match[3])
+			bits = lanes * width
+		}
+		bytes += bits / 8
+	}
+	return bytes
+}
+
+func TestX86ImmediatePackedCompareCannotBypassWholeSourceProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		for _, row := range []struct {
+			name, body string
+		}{
+			{"undefined-vector", "PXOR X2,X2\nVPCMPUQ $4,Z1,Z0,K2\nMOVSD X2,ret+0(FP)\nRET\n"},
+			{"undefined-mask", "VPXORD Z0,Z0,Z0\nPXOR X2,X2\nVPCMPUQ $4,Z0,Z0,K1,K2\nMOVSD X2,ret+0(FP)\nRET\n"},
+			{"missing-result", "VPXORD Z0,Z0,Z0\nVPCMPUQ $4,Z0,Z0,K2\nRET\n"},
+		} {
+			source := "TEXT ·Value(SB),4,$0-8\n" + row.body
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() float64", target.arch, target.triple, api)
+					if row.name == "undefined-vector" {
+						x86VectorScratchCodegenControl(t, source, "func Value() float64", target.arch, target.triple, ir, err)
+						return
+					}
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("floating storage bypassed the numerical family obligation: output=%t, error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_implicit_multiply_test.go b/x86_result_implicit_multiply_test.go
new file mode 100644
index 000000000..bf1d7facd
--- /dev/null
+++ b/x86_result_implicit_multiply_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86ImplicitMultiplyCase struct {
+	x86ScalarFPTupleSpanCase
+	op    string
+	width int
+}
+
+func x86ImplicitMultiplyCases(arch string) []x86ImplicitMultiplyCase {
+	var cases []x86ImplicitMultiplyCase
+	for _, stem := range []string{"MUL", "IMUL"} {
+		for _, width := range []int{1, 2, 4, 8} {
+			if arch == "386" && width == 8 {
+				continue // No Go mode32 Q encoding, not a skipped target.
+			}
+			suffix := map[int]string{1: "B", 2: "W", 4: "L", 8: "Q"}[width]
+			move, input, result, declaration := "MOV"+suffix, "7", 2*width, fmt.Sprintf("func Value() (uint%d,uint%d)", width*8, width*8)
+			want := []uint64{21, 0}
+			if stem == "IMUL" {
+				input = "-2"
+				mask := ^uint64(0)
+				if width != 8 {
+					mask = (uint64(1) << uint(width*8)) - 1
+				}
+				want = []uint64{mask - 5, mask}
+			}
+			stores := fmt.Sprintf("%s AX,ret+0(FP)\n%s DX,ret+%d(FP)\n", move, move, width)
+			if width == 1 {
+				declaration, result, stores = "func Value() uint16", 2, "MOVW AX,ret+0(FP)\n"
+				want = []uint64{21}
+				if stem == "IMUL" {
+					want = []uint64{0xfffa}
+				}
+			}
+			op := stem + suffix
+			body := fmt.Sprintf("%s $%s,AX\n%s $3,BX\n%s BX\n%sRET\n", move, input, move, op, stores)
+			cases = append(cases, x86ImplicitMultiplyCase{x86ScalarFPTupleSpanCase{
+				name: op, declaration: declaration,
+				source: fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", result, body), want: want,
+			}, op, width})
+		}
+	}
+	return cases
+}
+
+func TestX86ImplicitMultiplyWholeSourceThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ImplicitMultiplyCases(target.arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				for _, missing := range []string{"", "accumulator", "source"} {
+					t.Run(target.triple+"/"+row.op+"/"+api+"/missing="+missing, func(t *testing.T) {
+						source := row.source
+						if missing != "" {
+							lines := strings.Split(source, "\n")
+							index := 1
+							if missing == "source" {
+								index = 2
+							}
+							lines[index] = "NOP"
+							source = strings.Join(lines, "\n")
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+						if missing != "" {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("implicit operand was invented: output=%t error=%v", ir != "", err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("complete implicit product rejected", err)
+						}
+						x86ScalarFPTupleSpanConstantResult(t, ir, row.want)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyMissingFPResultsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, stem := range []string{"MUL", "IMUL"} {
+			for _, tuple := range []bool{false, true} {
+				declaration, bytes := "func Value() uint32", 4
+				if tuple {
+					declaration, bytes = "func Value() (uint32,uint32)", 8
+				}
+				for _, initialized := range []bool{false, true} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/%s/tuple=%t/initialized=%t/%s", target.triple, stem, tuple, initialized, api), func(t *testing.T) {
+							body := stem + "L BX\nRET\n"
+							if initialized {
+								body = "MOVL $2,AX\nMOVL $3,BX\n" + body
+							}
+							source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", bytes, body)
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if tuple && initialized {
+								// No result byte was written. Codegen does not turn
+								// incidental register returns into a source proof.
+								x86PartialTupleCodegenControl(t, source, declaration, target.arch, target.triple, ir, err)
+								return
+							}
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatalf("unwritten declared result escaped whole-source proof: output=%t error=%v", ir != "", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyNUMBytesAndStatus(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ImplicitMultiplyCases(arch) {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.op+" BX")
+				width := int64(row.width)
+				input := uint8((uint16(1) << uint(width)) - 1)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				ax, _, _ := x86ResultGP(AX, width, arch)
+				bx, _, _ := x86ResultGP(BX, width, arch)
+				dx, _, _ := x86ResultGP(DX, width, arch)
+				state.gp[ax], state.gp[bx], state.gp[dx] = input, input, 0x80
+				before := state.clone()
+				if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("missing implicit numerical effect")
+				}
+				wantAX, wantDX := input, input|0x80
+				if width == 1 {
+					wantAX, wantDX = 3, before.gp[dx] // B writes AX16, never DX.
+				} else if width == 4 {
+					wantAX, wantDX = 0xff, 0xff // Dword writes clear both upper32 halves.
+				}
+				if state.gp[ax] != wantAX || state.gp[dx] != wantDX || state.flags != x86ByteFlagCF|x86ByteFlagOF || state.direction != before.direction {
+					t.Fatal("incorrect implicit widths or undefined status retained", state.gp, state.flags)
+				}
+				var addresses [16]bool
+				var canonical [16]uint8
+				for index := range addresses {
+					addresses[index], canonical[index] = true, 255
+				}
+				after := x86ResultCallerAddressesAfter(ins, addresses, nil, arch)
+				addresses[ax] = false
+				if width != 1 {
+					addresses[dx] = false
+				}
+				if after != addresses {
+					t.Fatal("implicit output retained/revoked wrong opaque address", after)
+				}
+				boolean := x86RegisterCanonicalBytesAfter(ins, canonical, arch)
+				mask := input
+				if width == 1 {
+					mask = 3
+				}
+				canonical[ax] &^= mask
+				if width != 1 {
+					canonical[dx] &^= mask
+				}
+				if width == 4 && arch == "amd64" {
+					canonical[ax] |= 240
+					canonical[dx] |= 240
+				}
+				if boolean != canonical {
+					t.Fatal("product bytes borrowed canonical inputs", boolean)
+				}
+				unknown := before.clone()
+				unknown.gp[ax] = 0
+				original := unknown.clone()
+				if x86ScalarFPResultTransfer(ins, &unknown, nil, 0, arch) || !reflect.DeepEqual(unknown, original) {
+					t.Fatal("unknown accumulator acquired initialized bytes")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ImplicitMultiplyDoesNotRegisterRawEntryOrDivide(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ImplicitMultiplyCases(arch) {
+			ins := x86YMMReadSource(t, row.op+" BX")
+			if _, known, _ := x86TypedGPByteEffect(ins.Op, ins, arch); known || x86SourceStackInstructionKnown(ins, "MOVQ", "Q", arch) {
+				t.Fatal("NUM-only effect widened an independent raw/source-stack registry", arch, row.op)
+			}
+			ins.x86Encoded = true
+			if _, known, _ := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+				t.Fatal("named implicit product supplied a physical instruction effect")
+			}
+		}
+		for _, row := range []string{"DIVB BX", "DIVW BX", "DIVL BX", "DIVQ BX", "IDIVB BX", "IDIVW BX", "IDIVL BX", "IDIVQ BX"} {
+			ins := x86YMMReadSource(t, row)
+			if _, known, _ := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+				t.Fatal("implicit multiply granted division/poison authority", arch, row)
+			}
+		}
+	}
+}
+
+type x86ImplicitMultiplyFPCase struct {
+	name, params, arguments, source string
+	paramBytes, width               int
+	want                            uint64
+}
+
+func x86ImplicitMultiplyFPCases(arch string) []x86ImplicitMultiplyFPCase {
+	rows := []x86ImplicitMultiplyFPCase{
+		{"natural-byte", "a uint8", "i8 3", "a+0(FP)", 1, 1, 6},
+		{"natural-word", "a uint16", "i16 3", "a+0(FP)", 2, 2, 6},
+		{"natural-long", "a uint32", "i32 3", "a+0(FP)", 4, 4, 6},
+		{"partial-byte", "a uint64", "i64 134678021", "a+0(FP)", 8, 1, 10},
+		{"partial-word", "a uint64", "i64 134678021", "a+0(FP)", 8, 2, 0x0c0a},
+		{"partial-long", "a uint64", "i64 134678021", "a+0(FP)", 8, 4, 0x100e0c0a},
+		{"interior-byte", "a uint64", "i64 134678021", "a+1(FP)", 8, 1, 12},
+		{"interior-word", "a uint64", "i64 134678021", "a+1(FP)", 8, 2, 0x0e0c},
+		{"interior-long", "a uint64", "i64 578437695752307201", "a+1(FP)", 8, 4, 0x0a080604},
+		{"cross-word", "a,b uint8", "i8 3,i8 4", "a+0(FP)", 2, 2, 0x0806},
+		{"cross-long", "a,b uint16", "i16 513,i16 1027", "a+0(FP)", 4, 4, 0x08060402},
+		{"natural-float-bits", "a float32", "float 1.000000e+00", "a+0(FP)", 4, 4, 0x7f000000},
+	}
+	if arch == "amd64" {
+		rows = append(rows,
+			x86ImplicitMultiplyFPCase{"natural-quad", "a uint64", "i64 3", "a+0(FP)", 8, 8, 6},
+			x86ImplicitMultiplyFPCase{"interior-quad", "a,b uint64", "i64 578437695752307201,i64 16", "a+1(FP)", 16, 8, 0x20100e0c0a080604},
+			x86ImplicitMultiplyFPCase{"cross-quad", "a,b uint32", "i32 67305985,i32 134678021", "a+0(FP)", 8, 8, 0x100e0c0a08060402},
+			x86ImplicitMultiplyFPCase{"natural-double-bits", "a float64", "double 1.000000e+00", "a+0(FP)", 8, 8, 0x7fe0000000000000},
+		)
+	}
+	return rows
+}
+
+func x86ImplicitMultiplyFPFixture(row x86ImplicitMultiplyFPCase, stem, arch string) (string, string) {
+	word, move, resultType := 8, "MOVQ", "uint64"
+	if arch == "386" {
+		word, move, resultType = 4, "MOVL", "uint32"
+	}
+	result := (row.paramBytes + word - 1) & -word
+	suffix := map[int]string{1: "B", 2: "W", 4: "L", 8: "Q"}[row.width]
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVL $2,AX\n%s%s %s\n", result+word, stem, suffix, row.source)
+	if row.width <= 2 {
+		source += "MOVWLZX AX,AX\n" // B observes AX16; W also clears the old upper bytes.
+	}
+	source += fmt.Sprintf("%s AX,ret+%d(FP)\nRET\n", move, result)
+	return source, "func Value(" + row.params + ") " + resultType
+}
+
+func TestX86ImplicitMultiplyFPSourceBytesThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ImplicitMultiplyFPCases(target.arch) {
+			for _, stem := range []string{"MUL", "IMUL"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+stem+"/"+row.name+"/"+api, func(t *testing.T) {
+						source, declaration := x86ImplicitMultiplyFPFixture(row, stem, target.arch)
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("complete typed FP source rejected", err)
+						}
+						typ := fmt.Sprintf("i%d", goWordSize(target.arch)*8)
+						probe := fmt.Sprintf("define %s @Probe() {\n %%r = call %s @Value(%s)\n ret %s %%r\n}\n", typ, typ, row.arguments, typ)
+						x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{row.want})
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_indexed_permute_test.go b/x86_result_indexed_permute_test.go
new file mode 100644
index 000000000..969385d0f
--- /dev/null
+++ b/x86_result_indexed_permute_test.go
@@ -0,0 +1,156 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86IndexedPermuteResultNames = []string{
+	"VPERMB", "VPERMW", "VPERMI2B", "VPERMI2W", "VPERMI2D", "VPERMI2Q", "VPERMI2PS", "VPERMI2PD",
+	"VPERMT2B", "VPERMT2W", "VPERMT2D", "VPERMT2Q", "VPERMT2PS", "VPERMT2PD",
+}
+
+func TestX86IndexedPermuteResultRequiresCompleteTablesIndicesAndMerge(t *testing.T) {
+	for _, op := range x86IndexedPermuteResultNames {
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << axis
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				t.Run(op+"/"+bank+"/"+mode, func(t *testing.T) {
+					mask, suffix := "", ""
+					if mode != "plain" {
+						mask = "K1,"
+					}
+					if mode == "zero" {
+						suffix = ".Z"
+					}
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s%s %s0,%s1,%s%s2", op, suffix, bank, bank, mask, bank))
+					inputs := 2
+					if strings.HasPrefix(op, "VPERMI2") || strings.HasPrefix(op, "VPERMT2") || mode == "merge" {
+						inputs = 3
+					}
+					for input := 0; input < inputs; input++ {
+						for missing := -1; missing < width; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: true}}
+							for reg := 0; reg < 3; reg++ {
+								bits := ^uint64(0)
+								if reg == input && missing >= 0 {
+									bits &^= uint64(1) << uint(missing)
+								}
+								state.writeVector(reg, 64, bits, false)
+							}
+							before := state.clone()
+							accepted, known := x86ResultIndexedPermuteStep(ins, &state, nil, "amd64")
+							if !known || accepted != (missing < 0) {
+								t.Fatal("table/index/merge byte dependency lost", input, missing, accepted, known)
+							}
+							if missing >= 0 && !reflect.DeepEqual(state, before) {
+								t.Fatal("failed dependency changed source facts")
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86IndexedPermuteResultFixture(op, bank, mode, source string) string {
+	mask := ""
+	if mode != "plain" {
+		mask = "K1,"
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nKMOVD AX,K1\n"+
+		"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\nVPXORD Z3,Z3,Z3\n"+
+		"%s %s,%s1,%s%s2\nVPCOMPRESSQ Z2,K1,Z3\nPEXTRD $0,X3,AX\nMOVL AX,ret+0(FP)\nRET\n",
+		op, source, bank, mask, bank)
+}
+
+func TestX86IndexedPermuteInitializedResultWholeFamily(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			source.WriteString("GLOBL table<>(SB),8,$64\n")
+			var names []string
+			for _, op := range x86IndexedPermuteResultNames {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if target.arch == "386" && mode != "plain" {
+							continue // Four named operands exceed cmd/asm's 386 frontend.
+						}
+						inputs := []string{bank + "0", "table<>(SB)"}
+						broadcast := !strings.HasSuffix(op, "B") && !strings.HasSuffix(op, "W")
+						if broadcast {
+							inputs = append(inputs, "broadcast")
+						}
+						for _, input := range inputs {
+							member := op
+							if input == "broadcast" {
+								member, input = op+".BCST", "table<>(SB)"
+							}
+							body := x86IndexedPermuteResultFixture(member, bank, mode, input)
+							name := fmt.Sprintf("Value%d", len(names))
+							names = append(names, name)
+							source.WriteString(strings.ReplaceAll(body, "Value", name))
+							declarations.WriteString("func " + name + "() uint32\n")
+						}
+					}
+				}
+			}
+			want := 324
+			if target.arch == "386" {
+				want = 108
+			}
+			if len(names) != want {
+				t.Fatal("independent whole-family result inventory changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized indexed-permute family rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+				})
+			}
+		})
+	}
+}
+
+func TestX86IndexedPermuteResultInputsStayIndependent(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86IndexedPermuteResultNames {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, missing := range []string{"Z0", "Z1", "result"} {
+					source := x86IndexedPermuteResultFixture(op, bank, "plain", bank+"0")
+					if missing == "result" {
+						source = strings.Replace(source, "MOVL AX,ret+0(FP)", "NOP", 1)
+					} else {
+						source = strings.Replace(source, fmt.Sprintf("VPXORD %s,%s,%s", missing, missing, missing), "NOP", 1)
+					}
+					t.Run(arch+"/"+op+"/"+bank+"/"+missing, func(t *testing.T) {
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", arch, triple, api)
+							if arch == "amd64" && missing != "result" {
+								x86VectorScratchCodegenControl(t, source, "func Value() uint32", arch, triple, ir, err)
+							} else if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("indexed-permute acquired an unknown input/result", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_initialization.go b/x86_result_initialization.go
new file mode 100644
index 000000000..cb38231f8
--- /dev/null
+++ b/x86_result_initialization.go
@@ -0,0 +1,1450 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// Returned only after all source effects and every reachable return contract
+// have passed. An exact error type keeps a wrapped or joined input/storage
+// failure from masquerading as an incomplete numerical result.
+type x86IncompleteResultError struct{ error }
+
+func (err *x86IncompleteResultError) Unwrap() error {
+	return err.error
+}
+
+// CheckX86ABI0ResultInitialization checks only byte initialization of one or
+// more scalar ABI0 result fields. It supplies no source authentication, native
+// frame, caller-memory, return-continuation or translation permission. The
+// caller must derive sig from the actual selected Go declaration and bind the
+// complete original CPP source independently. Unknown effects fail closed.
+func CheckX86ABI0ResultInitialization(fn Func, sig FuncSig, goarch string) error {
+	return checkX86ABI0ResultInitialization(fn, sig, goarch, x86ResultTransfer, false)
+}
+
+func checkX86ABI0ResultInitialization(fn Func, sig FuncSig, goarch string,
+	transfer func(Instr, *x86ResultState, []bool, int64, string) bool, scalarViews bool) error {
+	return checkX86ABI0ResultInitializationAtSource(fn, sig, goarch,
+		func(_ int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			return transfer(ins, state, owned, resultOffset, arch)
+		}, scalarViews)
+}
+
+// The source ordinal is retained across TEXT/label removal. It does not itself
+// authorize an effect; a private observer may join it to an exact source fact.
+func checkX86ABI0ResultInitializationAtSource(fn Func, sig FuncSig, goarch string,
+	transfer func(int, Instr, *x86ResultState, []bool, int64, string) bool, scalarViews bool) error {
+	return checkX86ABI0ResultInitializationWithTrapOnly(fn, sig, goarch, transfer, scalarViews, false, false)
+}
+
+func checkX86ABI0ResultInitializationWithTrapOnly(fn Func, sig FuncSig, goarch string,
+	transfer x86ResultSourceTransfer, scalarViews, trapOnly, privateStack bool) error {
+	return checkX86ABI0ResultInitializationWithVectorEntry(fn, sig, goarch, transfer,
+		scalarViews, trapOnly, privateStack, nil)
+}
+
+// Only the paired lowering path supplies its exact planned allocation widths.
+// The public/source-only callers retain the empty entry map. Numerical vector
+// initialization changes no GP, pointer, canonical, stack or logical FP state.
+func checkX86ABI0ResultInitializationWithVectorEntry(fn Func, sig FuncSig, goarch string,
+	transfer x86ResultSourceTransfer, scalarViews, trapOnly, privateStack bool, vectors map[int]int) error {
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: result initialization: %s", ErrProbeNeedsContext, reason)
+	}
+	privateVoid := scalarViews && sig.Ret == Void && len(sig.Frame.Results) == 0
+	canonicalBool := scalarViews && x86ABI0BoolResultNeedsProof(sig, goarch)
+	if canonicalBool && !x86ABI0LogicalBoolFrameRole(fn, sig, goarch) {
+		return fail("bool byte requires its complete ordinary bounded logical ABI0 role")
+	}
+	mixedBool := scalarViews && x86MixedBoolResultNeedsCanonicalRole(sig, sig.Frame.Results)
+	if mixedBool && !x86OrdinaryMixedBoolResultRole(fn, sig, goarch) {
+		return fail("mixed bool requires its complete ordinary bounded logical ABI0 role")
+	}
+	// Go's file-local <> marker keeps ABI0; explicit entry selectors do not
+	// inherit this ordinary scalar-frame observation from their spelling.
+	if goarch != "amd64" && goarch != "386" || strings.Contains(strings.TrimSuffix(fn.Sym, "<>"), "<") ||
+		len(sig.ArgRegs) != 0 || sig.ARMEntry != nil || sig.WASMContext != "" ||
+		len(sig.Frame.Results) == 0 && !privateVoid {
+		return fail("requires an ordinary x86 scalar ABI0 declaration")
+	}
+	resultOffset := int64(0)
+	resultTypes := []LLVMType{sig.Ret}
+	if !privateVoid {
+		resultOffset = sig.Frame.Results[0].Offset
+	}
+	if len(sig.Frame.Results) > 1 {
+		var valid bool
+		resultTypes, valid = parseLiteralStructFields(sig.Ret)
+		if !valid || len(resultTypes) != len(sig.Frame.Results) {
+			return fail("result fields disagree with the return type")
+		}
+	}
+	frame := 0
+	for index, slot := range sig.Frame.Results {
+		width := x86ResultScalarBytes(slot.Type, goarch)
+		if width == 0 || slot.Type != resultTypes[index] || slot.Index != index || slot.Field != -1 || len(slot.Fields) != 0 ||
+			slot.Offset < 0 || slot.Offset > 4096-width || slot.Offset < resultOffset {
+			return fail("result layout is not bounded scalar fields")
+		}
+		if end := int(slot.Offset + width); end > frame {
+			frame = end
+		}
+	}
+	if privateVoid {
+		// A private scalar-view query can check inputs and effects without a
+		// result. Its entire logical extent comes from the typed parameters;
+		// placing the write boundary at the end permits no incoming FP store.
+		for _, slot := range sig.Frame.Params {
+			width := x86FrameScalarBytes(slot.Type, goarch)
+			if width == 0 || slot.Offset < 0 || slot.Offset > 4096-width {
+				return fail("void parameter layout is not bounded scalar fields")
+			}
+			if end := int(slot.Offset + width); end > frame {
+				frame = end
+			}
+		}
+		resultOffset = int64(frame)
+	}
+	initial := x86ResultState{fp: make([]bool, frame), pointerFP: make(map[int64]bool)}
+	for index, width := range vectors {
+		if index < 0 || index >= len(initial.xmm) || width != 16 && width != 32 && width != 64 {
+			return fail("invalid lowering vector allocation width")
+		}
+		initial.writeVector(index, width, x86CallerVectorByteMask(int64(width)), true)
+	}
+	if scalarViews && x86X87ValueFlowNeeded(fn) {
+		initial.x87 = new(x86ResultX87State)
+		if x86X87WordStateNeeded(fn) {
+			initial.x87.word = &x86ResultX87WordState{layout: &x86X87WordLayout{parameters: make(map[int64]bool)}}
+		}
+	}
+	if scalarViews && fn.x86ContinuationFlow != nil {
+		view := fn.x86ContinuationFlow
+		if !view.bind(fn, sig, goarch) {
+			return fail("coalesced source/declaration identity changed")
+		}
+		initial.continuation = &x86ContinuationResultState{flow: view, tablesValid: true,
+			written: make([]bool, view.graph.cells)}
+	}
+	if canonicalBool || mixedBool {
+		initial.canonicalFP = make([]bool, frame)
+	}
+	if mixedBool {
+		transfer = x86MixedBoolCanonicalTransfer(transfer)
+	}
+	if canonicalBool {
+		initial.boolFrameSlots = append(append([]FrameSlot(nil), sig.Frame.Params...), sig.Frame.Results...)
+		initial.boolCalls = fn.x86BoolCalls
+		initial.boolReadonlyInputs = fn.x86BoolReadonlyInputs
+		if initial.boolCalls != nil && len(initial.boolCalls.bytes) != 0 {
+			initial.boolOutgoing = make([]bool, x86ResultPointerWord(goarch)+1)
+			initial.boolOutgoingCanonical = make([]bool, x86ResultPointerWord(goarch)+1)
+		}
+		if x86ABI0BoolFrameAliasNeeded(fn, goarch) {
+			initial.boolFrameGP = new([16]x86ResultSlotAddress)
+		}
+		transfer = x86ABI0CanonicalBoolTransfer(transfer)
+	}
+	ordinaryResultAddress := scalarViews && x86OrdinaryResultAddressRole(fn, sig, goarch)
+	if scalarViews && (fn.x86DirectTailRoot != nil || ordinaryResultAddress) {
+		for _, slot := range sig.Frame.Results {
+			if x86IntegerResultSlot(slot) || ordinaryResultAddress && x86OrdinaryNumericAddressSlot(slot) {
+				initial.resultAddressSlots = append(initial.resultAddressSlots, x86ResultSlotAddress{
+					start: slot.Offset, end: slot.Offset + x86ResultScalarBytes(slot.Type, goarch), valid: true})
+			}
+		}
+		if region, valid := x86DirectTailResultRegion(fn, sig, goarch); valid {
+			initial.resultAddressSlots = []x86ResultSlotAddress{region}
+		}
+	}
+	// TEXT may include ABI0 allocation padding beyond the declared logical end.
+	// It cannot add owned/initialized bytes or extend an AMD64 field allocation.
+	if scalarViews && x86OrdinaryParameterAddressRole(fn, sig, goarch) &&
+		fn.ArgSize >= int64(frame) && fn.ArgSize <= 4096 {
+		initial.logicalFrameParameters = true
+		if goarch == "386" {
+			initial.resultAddressSlots = []x86ResultSlotAddress{{start: 0, end: int64(frame), valid: true}}
+		} else {
+			for _, slot := range sig.Frame.Params {
+				initial.resultAddressSlots = append(initial.resultAddressSlots, x86ResultSlotAddress{
+					start: slot.Offset, end: slot.Offset + x86FrameScalarBytes(slot.Type, goarch), valid: true})
+			}
+		}
+	}
+	initial.callerAddressFP = initial.pointerFP // Immutable actual typed entry layout.
+	if privateStack {
+		stack, err := x86ResultPrivateFlagsSource(fn, goarch)
+		if err != nil {
+			return err
+		}
+		initial.valueStack = stack
+	}
+	autoExtent, scopedControl := 0, false
+	if scalarViews {
+		autoExtent, scopedControl = x86X87ScopedControlScratchExtent(fn, goarch)
+	}
+	if !scopedControl {
+		var autoErr error
+		autoExtent, autoErr = x86ResultAUTOExtentWithPrivateStack(fn, goarch, initial.valueStack != nil)
+		if autoErr != nil {
+			return autoErr
+		}
+	}
+	initial.auto = make([]bool, autoExtent)
+	owned := make([]bool, frame)
+	for _, slot := range sig.Frame.Results {
+		for offset := slot.Offset; offset < slot.Offset+x86ResultScalarBytes(slot.Type, goarch); offset++ {
+			if owned[offset] {
+				return fail("overlapping result fields")
+			}
+			owned[offset] = true
+		}
+	}
+	parameterRoles := make(map[string]bool)
+	for _, slot := range sig.Frame.Params {
+		// Actual gc layout includes pointer storage even when no numeric
+		// instruction consumes it. Occupancy prevents overlap, but pointer
+		// bytes are deliberately not a numerical input or pointee witness.
+		bytes := x86FrameScalarBytes(slot.Type, goarch)
+		if bytes == 0 || slot.Offset < 0 || slot.Offset > int64(frame)-bytes || slot.Offset+bytes > resultOffset {
+			return fail("parameter bytes or result boundary are not closed")
+		}
+		role, valid := x86ResultParameterRole(sig.Args, slot)
+		if !valid || parameterRoles[role] {
+			return fail("parameter leaf type/index disagrees with its actual argument")
+		}
+		parameterRoles[role] = true
+		if initial.x87 != nil && initial.x87.word != nil && slot.Type == I16 {
+			initial.x87.word.layout.parameters[slot.Offset] = true
+		}
+		for offset := int(slot.Offset); offset < int(slot.Offset+bytes); offset++ {
+			if owned[offset] {
+				return fail("overlapping typed frame slots")
+			}
+			owned[offset], initial.fp[offset] = true, slot.Type != Ptr
+			if (canonicalBool || mixedBool) && slot.Type == I1 {
+				initial.canonicalFP[offset] = true // The logical entry is actual I1, not an arbitrary NUM byte.
+			}
+		}
+		if slot.Type == Ptr {
+			// Both observers may transport an incoming opaque identity while
+			// proving an independent numerical result. Neither marks these
+			// bytes numerical or infers initialized pointee/native storage.
+			initial.pointerFP[slot.Offset] = true
+		}
+	}
+	// Go's omitted suffix is unknown, not an explicit zero-sized argument
+	// frame. The independently checked declaration above still bounds inputs.
+	if (fn.ArgSize != 0 || privateVoid && !x86TEXTArgumentsUnspecified(fn)) &&
+		(fn.ArgSize < int64(frame) || fn.ArgSize > 4096) {
+		return fail("TEXT argument extent disagrees with the typed result")
+	}
+	var incomplete *x86IncompleteResultError
+	err := checkX86ResultSourceFlowWithTrapOnly(fn, initial, owned, resultOffset, goarch, transfer,
+		func(state x86ResultState, pc int) error {
+			if state.x87 != nil && (state.x87.invalid || state.x87.depth != 0) {
+				return fail("logical x87 value stack is not balanced at RET")
+			}
+			if trapOnly {
+				return fail("trap-only logical shadow reaches an ordinary RET")
+			}
+			if state.continuation != nil && !state.continuation.checkReturn() {
+				return fail("initializer does not write every code-table cell on every RET")
+			}
+			if canonicalBool || mixedBool {
+				for _, slot := range sig.Frame.Results {
+					if slot.Type == I1 && !state.canonicalFP[slot.Offset] {
+						return fail(fmt.Sprintf("bool result byte %d is not canonical zero/one on every path to RET %d", slot.Offset, pc))
+					}
+				}
+			}
+			for offset := int(resultOffset); offset < frame; offset++ {
+				if owned[offset] && !state.fp[offset] && incomplete == nil {
+					incomplete = &x86IncompleteResultError{fail(fmt.Sprintf("result byte %d is not written on every path to RET %d", offset, pc))}
+				}
+			}
+			return nil
+		}, trapOnly)
+	if err != nil {
+		return err
+	}
+	if incomplete != nil {
+		return incomplete
+	}
+	return nil
+}
+
+type x86ResultSourceTransfer func(int, Instr, *x86ResultState, []bool, int64, string) bool
+
+type x86ResultFlowBudget struct {
+	visits, bytes int
+}
+
+// The ABI owns entry bytes and the required return bytes. Instruction effects,
+// dead-source validation, joins and fixed-point budgets are shared, so a new
+// entry role cannot weaken the existing ABI0 result proof.
+func checkX86ResultSourceFlow(fn Func, initial x86ResultState, owned []bool, resultOffset int64, goarch string,
+	transfer x86ResultSourceTransfer, checkReturn func(x86ResultState, int) error) error {
+	return checkX86ResultSourceFlowWithTrapOnly(fn, initial, owned, resultOffset, goarch, transfer, checkReturn, false)
+}
+
+func checkX86ResultSourceFlowWithTrapOnly(fn Func, initial x86ResultState, owned []bool, resultOffset int64, goarch string,
+	transfer x86ResultSourceTransfer, checkReturn func(x86ResultState, int) error, trapOnly bool) error {
+	originalTransfer := transfer
+	trackCPUIDLeaf := false
+	var repeatEmptyBranch func(int, Instr, *x86ResultState) bool
+	transfer = func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+		if !x86ResultValueStackContinuation(ins, state, arch) {
+			return false
+		}
+		popped := state.gpBits
+		state.gpBits = x86ResultGPBits{}
+		var poppedOrigins [32]uint8
+		if state.valueStack != nil {
+			if correlation := state.valueStack.correlation; correlation != nil {
+				poppedOrigins = correlation.popped
+				correlation.popped = [32]uint8{}
+			}
+		}
+		spec, stack, _ := x86StackWidthProperties(ins, arch)
+		popFlags := stack && spec.mode == amd64StackPopFlags
+		if popFlags {
+			// An independently accepted restore supplies no saved DF fact.
+			// The actual checked private-stack transfer may establish a new
+			// fact below, but must not inherit the pre-restore direction.
+			state.direction = x86ResultDirectionUnknown
+		}
+		if !isAMD64ConditionalBranch(ins.Op) {
+			state.bitScanPending = x86ResultBitScanPending{}
+		}
+		before := state.callerAddressGP
+		origins := state.callerAddressOrigin
+		predicate := state.predicate
+		stringCount := state.stringCount
+		cpuidRootLeaf := state.cpuidRootLeaf
+		ordinaryStep := false
+		defer func() {
+			if !ordinaryStep {
+				state.shiftBits = x86ResultShiftBits{} // A private-stack/control transfer cannot preserve adjacency.
+			}
+		}()
+		handled := false
+		if state.continuation != nil {
+			accepted, known := x86ContinuationResultStep(ordinal, ins, state, owned, arch)
+			if known {
+				if !accepted {
+					return false
+				}
+				handled = true
+			} else {
+				if !x86ContinuationOrdinaryUses(ins, state, arch) {
+					return false
+				}
+				defer x86ContinuationRevokeOverwrites(ins, state, arch)
+			}
+		}
+		ordinary := func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+			ordinaryStep = true
+			if repeatEmptyBranch != nil && repeatEmptyBranch(ordinal, ins, state) {
+				return true // Same empty result on both edges, never invented FLAGS.
+			}
+			return originalTransfer(ordinal, ins, state, owned, resultOffset, arch)
+		}
+		step := ordinary
+		if state.valueStack != nil && state.valueStack.correlation != nil {
+			step = func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				if accepted, known := x86ResultPrivateStackXORStep(ins, popped, poppedOrigins, state, owned, resultOffset, arch); known {
+					return accepted
+				}
+				return ordinary(ordinal, ins, state, owned, resultOffset, arch)
+			}
+		}
+		if popped.valid {
+			previous := step
+			step = func(ordinal int, ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+				if accepted, known := x86ResultGPBitsMaskStep(ins, popped, state, owned, resultOffset, arch); known {
+					return accepted
+				}
+				return previous(ordinal, ins, state, owned, resultOffset, arch)
+			}
+		}
+		if !handled && !x86DirectTailResultAddressTransfer(ins, state, owned, resultOffset, arch, step, ordinal) {
+			return false
+		}
+		x86ResultX87After(ins, state, arch)
+		if state.valueStack != nil && !x86ResultPreservesPrivateStorage(ins, arch) {
+			state.valueStack.id = false
+		}
+		state.callerAddressGP = x86ResultCallerAddressesAfterTransfer(ins, before, state.callerAddressGP, state.callerAddressFP, arch)
+		state.callerAddressOrigin = x86ResultCallerOriginsAfter(ins, origins, state.callerAddressGP, state.callerAddressFP, arch)
+		state.predicate = x86ResultPredicateAfter(ins, predicate, arch)
+		state.stringCount = x86ResultStringCountAfter(ins, stringCount, state.stringCount, arch)
+		if trackCPUIDLeaf {
+			state.cpuidRootLeaf = x86ResultCPUIDRootLeafAfter(ins, cpuidRootLeaf, arch)
+		}
+		if !popFlags {
+			state.direction = x86ResultDirectionAfterSource(ins, state.direction, arch)
+		}
+		x86ResultFlagsCorrelationAfter(ins, state, arch)
+		return true
+	}
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: result initialization: %s", ErrProbeNeedsContext, reason)
+	}
+	labels := make(map[string]int)
+	var instructions []Instr
+	var ordinals []int
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op == OpTEXT {
+			continue
+		}
+		if ins.Op == OpLABEL {
+			if len(ins.Args) != 1 || ins.Args[0].Kind != OpLabel {
+				return fail("malformed label")
+			}
+			if _, duplicate := labels[ins.Args[0].Sym]; duplicate {
+				return fail("duplicate label")
+			}
+			labels[ins.Args[0].Sym] = len(instructions)
+			continue
+		}
+		instructions = append(instructions, ins)
+		ordinals = append(ordinals, ordinal)
+	}
+	if fn.x86DirectTailRoot != nil {
+		instructions = fn.x86DirectTailRoot.instructions
+		ordinals = fn.x86DirectTailRoot.ordinals
+	}
+	if fn.x86ContinuationFlow != nil {
+		instructions = fn.x86ContinuationFlow.instructions
+		ordinals = fn.x86ContinuationFlow.ordinals
+	}
+	if len(instructions) == 0 || len(instructions) > 4096 {
+		return fail("missing or oversized source CFG")
+	}
+	// Discover private value-stack effects in the same complete, already
+	// selected CFG used below, including source-bound private helpers.
+	flagProjection := false
+	trackMoveMask := false
+	for _, ins := range instructions {
+		trackCPUIDLeaf = trackCPUIDLeaf || strings.EqualFold(string(ins.Op), string(OpCPUID))
+		_, moveMask := amd64MoveMaskSpecs[Op(strings.ToUpper(string(ins.Op)))]
+		trackMoveMask = trackMoveMask || moveMask
+		if spec, known, _ := x86StackWidthProperties(ins, goarch); known {
+			if initial.valueStack == nil {
+				initial.valueStack = new(x86ResultValueStack)
+			}
+			flagProjection = flagProjection || spec.mode == amd64StackPushFlags
+		}
+	}
+	// One logical byte-work envelope includes FP/AUTO, numerical GP/Z/K,
+	// canonical FP/GP bytes, status/DF, opaque GP and caller-address identities, and the source-shape discriminator. It is
+	// not a bound on Go's heap/struct overhead. pointerFP is immutable shared
+	// layout metadata, not a state payload copied at each CFG successor.
+	// AUTO states do not obtain an independent frame or iteration budget.
+	byteState := len(initial.fp) + len(initial.canonicalFP) + len(initial.auto) +
+		len(initial.boolOutgoing) + len(initial.boolOutgoingCanonical) + len(initial.gp) + len(initial.canonicalGP) +
+		8*len(initial.xmm) + len(initial.nativeMMX) + len(initial.masks) + 1 + len(initial.pointerGP) + len(initial.callerAddressGP) +
+		2*len(initial.callerAddressOrigin) + 1 + 2 + 3 + 1 + 1 // Native string counter must-fact.
+	byteState += 2 // One adjacent LEA register/byte-mask observation, never pointer/NUM bytes.
+	if trackCPUIDLeaf {
+		byteState++ // CPUID's EAX-only maximum-leaf must-fact.
+	}
+	byteState += 12 // One adjacent shift's input-byte bits and four typed byte fields.
+	if trackMoveMask {
+		byteState += 11 // Shared adjacent GP bits, register, valid and stack-origin tag.
+	} else if initial.valueStack != nil {
+		byteState += 10 // POP-only origin is implicit, retaining its original logical payload.
+	}
+	if len(initial.resultAddressSlots) != 0 {
+		byteState += len(initial.resultAddressGP)*25 + 2
+	}
+	if initial.boolFrameGP != nil {
+		byteState += len(initial.boolFrameGP) * 25
+	}
+	if initial.valueStack != nil {
+		// Bit masks, two-byte depth, invalid join and ID. The adjacent GP-bit
+		// observation above is shared with the other typed register producers.
+		byteState += x86ResultValueStackLimit(goarch) + 4
+		// Pointer cell endpoints use complete bitmap words spanning the
+		// bounded byte domain: 64 logical bytes on AMD64, 32 on mode32.
+		byteState += ((x86ResultValueStackLimit(goarch) + 63) / 64) * 8
+		if goarch == "amd64" {
+			byteState += 8 // Existing W/Q source-cell identity; unused in mode32.
+		}
+		if flagProjection {
+			byteState += x86ResultValueStackLimit(goarch) // Exact source-position refinement masks.
+		}
+		if initial.valueStack.correlation != nil {
+			byteState += 8*x86ResultValueStackLimit(goarch) + 64
+		}
+	}
+	if initial.continuation != nil {
+		byteState += 16*48 + len(initial.continuation.written) + 2
+	}
+	if initial.x87 != nil {
+		byteState += 1 + 1 + 1 + 2 + 2*len(initial.x87.gp) // slots, depth, invalid, status, captured bits.
+		byteState += len(initial.x87.integer)              // Source signed bounds, not numerical representation.
+		if initial.x87.word != nil {
+			byteState += 2 // Control knownness only; actual parameter layout is immutable metadata.
+		}
+	}
+	const byteWorkLimit = 64 << 20
+	byteWork := len(instructions) * byteState
+	if trapOnly {
+		byteWork += len(instructions) * 16 // One bounded reverse-CFG termination check, not a per-state payload.
+	}
+	boundedWork := len(initial.auto) != 0 || len(initial.canonicalFP) != 0 ||
+		len(initial.resultAddressSlots) != 0 || fn.x86DirectTailRoot != nil || initial.valueStack != nil ||
+		initial.continuation != nil || initial.x87 != nil || trapOnly
+	if boundedWork && byteWork > byteWorkLimit/8 {
+		return fail("combined FP/AUTO source-CFG byte budget exhausted")
+	}
+	if budget := fn.x86ResultFlowBudget; budget != nil {
+		budget.bytes += byteWork
+		if budget.bytes > byteWorkLimit/8 {
+			return fail("combined source-graph byte budget exhausted")
+		}
+	}
+	// Validate effects and all static successors source-wide. Definedness is
+	// proved below only for reachable paths; dead instructions must not hide
+	// unknown effects, malformed branches or external entry requirements.
+	top := initial.clone()
+	top.shapeOnly = true
+	for offset := range top.fp {
+		top.fp[offset] = initial.fp[offset] || owned[offset] && int64(offset) >= resultOffset
+	}
+	for offset := range top.auto {
+		top.auto[offset] = true
+	}
+	for offset := range top.boolOutgoing {
+		top.boolOutgoing[offset], top.boolOutgoingCanonical[offset] = true, true
+	}
+	for index := range top.gp {
+		top.gp[index] = 0xff
+	}
+	for index := range top.xmm {
+		top.xmm[index] = 0xffff
+		top.vectorUpper[index] = ^uint64(0xffff)
+	}
+	for index := range top.masks {
+		top.masks[index] = true
+	}
+	top.flags = x86ByteFlagsAll
+	edges := make([][]int, len(instructions))
+	terminals := make([]bool, len(instructions))
+	hasRepeat := false
+	for pc, ins := range instructions {
+		hasRepeat = hasRepeat || ins.Op == "REP" || ins.Op == "REPN"
+		control := fn.x86DirectTailRoot.privateCallTransition(pc)
+		if ins.Op == OpRET && !control {
+			if len(ins.Args) != 0 {
+				return fail("nonordinary return")
+			}
+			continue
+		}
+		if _, terminal, err := x86UndefinedTrapProperties(ins.Op, ins, goarch); !control && terminal && err == nil {
+			terminals[pc] = true
+			continue // A complete architectural trap has no input effects or normal successor.
+		}
+		shape := top.clone()
+		if !control && !transfer(ordinals[pc], ins, &shape, owned, resultOffset, goarch) {
+			return fail(fmt.Sprintf("unclosed source effect at instruction %d: %s", pc, ins.Raw))
+		}
+		next := []int{pc + 1}
+		if fn.x86DirectTailRoot != nil {
+			next = fn.x86DirectTailRoot.edges[pc]
+		} else if fn.x86ContinuationFlow != nil {
+			next = fn.x86ContinuationFlow.edges[pc]
+		} else if ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) {
+			args := x86DirectTailBranchArgs(ins)
+			if len(args) != 1 {
+				return fail("unbound branch operands")
+			}
+			arg := args[0]
+			label := arg.Sym
+			if arg.Kind == OpIdent {
+				label = arg.Ident
+			}
+			target, found := labels[label]
+			if arg.Kind == OpMem {
+				// Named Go n(PC) counts source instructions, just as the
+				// emitter's flat block positions do. No raw/indirect address
+				// or external target may acquire this ordinary CFG edge.
+				memory := arg.Mem
+				found = x86ResultNamedPredicateInstruction(ins) &&
+					reflect.DeepEqual(memory, MemRef{Base: "PC", Off: memory.Off}) &&
+					memory.Off >= -int64(pc) && memory.Off < int64(len(instructions)-pc)
+				if found {
+					target = pc + int(memory.Off)
+				}
+			} else {
+				found = found && (arg.Kind == OpLabel || arg.Kind == OpIdent)
+			}
+			if !found {
+				return fail("indirect, external or unresolved branch")
+			}
+			if ins.Op == OpJMP {
+				next = []int{target}
+			} else {
+				next = append(next, target)
+			}
+		}
+		for _, target := range next {
+			if target < 0 || target >= len(instructions) {
+				return fail("source falls outside its continuation")
+			}
+		}
+		edges[pc] = next
+	}
+	states := map[int]x86ResultState{0: initial}
+	queue := []int{0}
+	returned := false
+	trapped := false
+	visits, sourceWork := 0, byteWork
+	repeatEmptyUsed := false
+	if hasRepeat && fn.x86DirectTailRoot == nil && fn.x86ContinuationFlow == nil {
+		positions, previous := make(map[int]int), make([]int, len(instructions))
+		for pc, ordinal := range ordinals {
+			positions[ordinal], previous[pc] = pc, -1
+		}
+		for from, successors := range edges {
+			for _, to := range successors {
+				if previous[to] == -1 {
+					previous[to] = from
+				} else if previous[to] != from {
+					previous[to] = -2
+				}
+			}
+		}
+		repeatEmptyBranch = func(ordinal int, ins Instr, state *x86ResultState) bool {
+			required := x86ByteBranchFlags(ins.Op)
+			if required == 0 || state.flags&required == required || state.shapeOnly ||
+				state.valueStack != nil || state.x87 != nil || !isAMD64ConditionalBranch(ins.Op) {
+				return false
+			}
+			pc, found := positions[ordinal]
+			if !found {
+				return false
+			}
+			accepted, steps := x86ResultRepeatEmptyBranch(instructions, edges, previous, pc, owned, resultOffset, goarch)
+			visits, sourceWork = visits+steps, sourceWork+steps*byteState
+			if budget := fn.x86ResultFlowBudget; budget != nil {
+				budget.visits, budget.bytes = budget.visits+steps, budget.bytes+steps*byteState
+				accepted = accepted && budget.visits < 16384 && budget.bytes <= byteWorkLimit
+			}
+			accepted = accepted && visits < 16384 && sourceWork <= byteWorkLimit
+			repeatEmptyUsed = repeatEmptyUsed || accepted
+			return accepted
+		}
+	}
+	for ; len(queue) != 0; visits++ {
+		if visits >= 16384 {
+			return fail("must-defined fixed-point budget exhausted")
+		}
+		if budget := fn.x86ResultFlowBudget; budget != nil {
+			budget.visits++
+			budget.bytes += 8 * byteState
+			if budget.visits > 16384 || budget.bytes > byteWorkLimit {
+				return fail("combined source-graph must-defined budget exhausted")
+			}
+		}
+		// A later dead-external-input proof shares this function's actual
+		// visits and byte work, including normally unbounded scalar views.
+		sourceWork += 8 * byteState
+		if repeatEmptyUsed && sourceWork > byteWorkLimit {
+			return fail("empty-repeat source-CFG byte budget exhausted")
+		}
+		if boundedWork {
+			byteWork += 8 * byteState // conservative bound for copies and joins
+			if byteWork > byteWorkLimit {
+				return fail("combined FP/AUTO must-defined byte budget exhausted")
+			}
+		}
+		pc := queue[0]
+		queue = queue[1:]
+		state := states[pc].clone()
+		ins := instructions[pc]
+		if fn.x86DirectTailRoot != nil && fn.x86DirectTailRoot.externalTails[pc] {
+			if state.valueStack != nil && (state.valueStack.invalid || len(state.valueStack.bytes) != 0) {
+				return fail("external terminal cannot consume the private value stack")
+			}
+			if state.resultAddressWritten {
+				return fail("external terminal could observe a prior logical result write")
+			}
+			returned = true
+			continue // Exact independent callee return, no invented root FP bytes.
+		}
+		control := fn.x86DirectTailRoot.privateCallTransition(pc)
+		if ins.Op == OpRET && !control {
+			if len(ins.Args) != 0 {
+				return fail("nonordinary return")
+			}
+			returned = true
+			continue // Check results after the complete fixed point, never early.
+		}
+		if terminals[pc] {
+			trapped = true
+			continue // Earlier reachable instructions have already consumed their original state.
+		}
+		if control {
+			// Real registers/FLAGS flow through the original helper body. These
+			// source-adjacency observations cannot cross CALL or its private RET.
+			state.shiftBits = x86ResultShiftBits{}
+			state.bitScanPending = x86ResultBitScanPending{}
+			state.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+		} else if !transfer(ordinals[pc], ins, &state, owned, resultOffset, goarch) {
+			return fail(fmt.Sprintf("unknown effect or undefined input at instruction %d: %s", pc, ins.Raw))
+		}
+		for edge, target := range edges[pc] {
+			nextState := x86ResultPredicateEdge(state, ins, edge)
+			if previous, visited := states[target]; visited {
+				merged := previous.intersect(nextState)
+				if reflect.DeepEqual(previous, merged) {
+					continue
+				}
+				states[target] = merged
+			} else {
+				states[target] = nextState.clone()
+			}
+			queue = append(queue, target)
+		}
+	}
+	if err := x86ResultCheckDeadExternalInputs(fn, instructions, ordinals, edges, states,
+		owned, resultOffset, goarch, transfer, &visits, &sourceWork, byteState); err != nil {
+		return err
+	}
+	if trapOnly && !x86ResultAllPathsTerminateInTrap(instructions, edges, states, goarch) {
+		return fail("trap-only logical shadow has a reachable non-trap continuation or cycle")
+	}
+	if !returned && !trapped {
+		return fail("no ordinary reachable RET")
+	}
+	for pc, state := range states {
+		if instructions[pc].Op != OpRET || fn.x86DirectTailRoot.privateCallTransition(pc) {
+			continue
+		}
+		if state.valueStack != nil && (state.valueStack.invalid || len(state.valueStack.bytes) != 0) {
+			return fail("private value stack is not balanced at RET")
+		}
+		if err := checkReturn(state, pc); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func x86ResultScalarBytes(typ LLVMType, arch string) int64 {
+	if typ == Ptr {
+		return 0 // Initialized pointer bits do not close a Go result/GC contract.
+	}
+	return x86FrameScalarBytes(typ, arch)
+}
+
+type x86ResultState struct {
+	fp   []bool
+	auto []bool
+	gp   [16]uint8
+	// Canonical FP is allocated only for the independent bounded ABI0 bool
+	// role. It neither replaces numerical initialization nor extends FP slots.
+	canonicalFP                         []bool
+	boolFrameSlots                      []FrameSlot               // Immutable declared logical fields, not native backing.
+	boolFrameGP                         *[16]x86ResultSlotAddress // Separate alias domain; never resultAddressGP/caller/native.
+	boolCalls                           *x86ABI0BoolCallPlan      // Immutable original call-site/declaration observations.
+	boolOutgoing, boolOutgoingCanonical []bool
+	boolReadonlyInputs                  bool // Only the independent readonly callee proof.
+	// Used by the independent register/ABI0 bool-result contracts.
+	// A set bit means that physical byte is exactly 0/1, not merely initialized.
+	canonicalGP   [16]uint8
+	cpuidRootLeaf bool
+	xmm           [32]uint16 // high banks are consumed only by validated mode-bound forms
+	nativeMMX     [8]uint8   // Only a source-bound actual native region may transfer this bank.
+	// The disjoint upper 48 byte bits share the same physical X/Y/Z bank.
+	// Existing low-X effects preserve these bits unless their typed encoding
+	// explicitly clears the upper aliases.
+	vectorUpper          [32]uint64
+	masks                [8]bool // used only by the private scalar bit-view transfer
+	flags                uint8
+	direction            x86ResultDirection          // DF only; no numerical/status/pointer permission.
+	stringCount          x86ResultStringCount        // Full native CX zero/nonzero; never NUM or a memory role.
+	valueStack           *x86ResultValueStack        // Private numerical storage; never physical SP or an entry slot.
+	x87                  *x86ResultX87State          // Private logical availability; never hardware entry/control state.
+	continuation         *x86ContinuationResultState // Separate opaque control/table identities, never NUM/native storage.
+	bitScanPending       x86ResultBitScanPending
+	gpBits               x86ResultGPBits
+	predicate            x86ResultPredicate
+	nativeLEAAddressBits x86NativeLEAAddressBits
+	shiftBits            x86ResultShiftBits
+
+	// Incoming pointer identities are not numerical register bytes. This is
+	// only an initialization observation, never a pointee/backing permission.
+	pointerFP map[int64]bool // immutable after deriving the actual ABI0 layout
+	pointerGP [16]bool
+	// A separate actual typed-entry address-bit domain. SDK literal/OR
+	// carriers never seed it; no numerical GP or memory facts follow.
+	callerAddressFP        map[int64]bool // immutable shared entry layout
+	callerAddressGP        [16]bool
+	callerAddressOrigin    [16]uint16
+	resultAddressSlots     []x86ResultSlotAddress // Immutable root-local scalar layout.
+	resultAddressGP        [16]x86ResultSlotAddress
+	resultAddressWritten   bool // May-write join, not an initialized-result fact.
+	logicalFrameParameters bool // Immutable private numeric parameter-copy role; never caller storage.
+	shapeOnly              bool // source-wide effect validation, never a reaching state
+
+	// Temporary numerical inputs for one guarded transfer. The consumer
+	// independently binds the actual DATA; these facts cannot establish a
+	// caller, raw-return, pointer or declaration-only query permission.
+	// Clear them before any state escapes into the CFG.
+	loweredStaticReads   map[x86StaticSBAddress]int64
+	goReadOnlyRead       *goReadOnlyRead
+	literalMemoryOperand *Operand
+	literalMemoryBytes   int64
+}
+
+func (state x86ResultState) clone() x86ResultState {
+	state.fp = append([]bool(nil), state.fp...)
+	state.canonicalFP = append([]bool(nil), state.canonicalFP...)
+	state.boolOutgoing = append([]bool(nil), state.boolOutgoing...)
+	state.boolOutgoingCanonical = append([]bool(nil), state.boolOutgoingCanonical...)
+	if state.boolFrameGP != nil {
+		aliases := *state.boolFrameGP
+		state.boolFrameGP = &aliases
+	}
+	state.auto = append([]bool(nil), state.auto...)
+	if state.x87 != nil {
+		copy := *state.x87
+		state.x87 = &copy
+		if state.x87.word != nil {
+			word := *state.x87.word
+			state.x87.word = &word
+		}
+	}
+	if state.valueStack != nil {
+		stack := *state.valueStack
+		stack.bytes = append([]uint8(nil), stack.bytes...)
+		stack.refinable = append([]uint8(nil), stack.refinable...)
+		if stack.correlation != nil {
+			copy := *stack.correlation
+			copy.bytes = append([][8]uint8(nil), copy.bytes...)
+			stack.correlation = &copy
+		}
+		state.valueStack = &stack
+	}
+	if state.continuation != nil {
+		copy := *state.continuation
+		copy.written = append([]bool(nil), copy.written...)
+		state.continuation = &copy
+	}
+	state.loweredStaticReads = nil
+	state.goReadOnlyRead = nil
+	state.literalMemoryOperand, state.literalMemoryBytes = nil, 0
+	return state
+}
+
+func (state x86ResultState) intersect(other x86ResultState) x86ResultState {
+	merged := state.clone()
+	if !merged.gpBits.valid || !other.gpBits.valid || merged.gpBits.register != other.gpBits.register ||
+		merged.gpBits.fromStack != other.gpBits.fromStack {
+		merged.gpBits = x86ResultGPBits{}
+	} else {
+		merged.gpBits.bits &= other.gpBits.bits
+	}
+	if merged.shiftBits != other.shiftBits {
+		merged.shiftBits = x86ResultShiftBits{}
+	}
+	if merged.x87 == nil && other.x87 != nil {
+		merged.x87 = &x86ResultX87State{invalid: true}
+	} else if merged.x87 != nil {
+		if other.x87 == nil || merged.x87.invalid || other.x87.invalid || merged.x87.depth != other.x87.depth {
+			// An unknown value-stack shape revokes hardware facts, not the
+			// same immutable ABI layout independently present on both edges.
+			sharedLayout := other.x87 != nil && merged.x87.word != nil && other.x87.word != nil &&
+				merged.x87.word.layout != nil && merged.x87.word.layout == other.x87.word.layout
+			merged.x87.revoke()
+			if !sharedLayout {
+				merged.x87.word = nil
+			}
+		} else {
+			merged.x87.slots &= other.x87.slots
+			merged.x87.status &= other.x87.status
+			for index := range merged.x87.integer {
+				if merged.x87.slots&(1<<uint(index)) == 0 || merged.x87.integer[index] == 0 || other.x87.integer[index] == 0 {
+					merged.x87.integer[index] = 0
+				} else if other.x87.integer[index] > merged.x87.integer[index] {
+					merged.x87.integer[index] = other.x87.integer[index]
+				}
+			}
+			for index := range merged.x87.gp {
+				merged.x87.gp[index] &= other.x87.gp[index]
+			}
+			if merged.x87.word != nil && other.x87.word != nil && merged.x87.word.layout == other.x87.word.layout {
+				merged.x87.word.control &= other.x87.word.control
+			} else if merged.x87.word != nil || other.x87.word != nil {
+				*merged.x87 = x86ResultX87State{invalid: true}
+			}
+		}
+	}
+	if merged.continuation == nil && other.continuation != nil {
+		copy := other.clone()
+		merged.continuation = copy.continuation
+		merged.continuation.invalid = true
+	}
+	if merged.continuation != nil && (other.continuation == nil || merged.continuation.flow != other.continuation.flow ||
+		len(merged.continuation.written) != len(other.continuation.written) || merged.continuation.invalid || other.continuation.invalid) {
+		merged.continuation.invalid = true
+		merged.continuation.gp = [16]x86ContinuationAddress{}
+		merged.continuation.tablesValid = false
+		for index := range merged.continuation.written {
+			merged.continuation.written[index] = false
+		}
+	} else if merged.continuation != nil {
+		for index := range merged.continuation.gp {
+			left, right := merged.continuation.gp[index], other.continuation.gp[index]
+			if left != right {
+				if left.kind == 2 && right.kind == 2 && left.root != "" && left.root == right.root {
+					// Every finite helper successor is already part of this root's
+					// authenticated CFG. Preserve only that shared opaque role.
+					merged.continuation.gp[index] = x86ContinuationAddress{kind: 2, root: left.root}
+				} else {
+					merged.continuation.gp[index] = x86ContinuationAddress{}
+				}
+			}
+		}
+		for index := range merged.continuation.written {
+			merged.continuation.written[index] = merged.continuation.written[index] && other.continuation.written[index]
+		}
+		merged.continuation.tablesValid = merged.continuation.tablesValid && other.continuation.tablesValid
+	}
+	for index := range merged.boolOutgoing {
+		merged.boolOutgoing[index] = index < len(other.boolOutgoing) && merged.boolOutgoing[index] && other.boolOutgoing[index]
+		merged.boolOutgoingCanonical[index] = index < len(other.boolOutgoingCanonical) && merged.boolOutgoingCanonical[index] && other.boolOutgoingCanonical[index]
+	}
+	for index := range merged.fp {
+		merged.fp[index] = merged.fp[index] && other.fp[index]
+	}
+	for index := range merged.canonicalFP {
+		merged.canonicalFP[index] = index < len(other.canonicalFP) && merged.canonicalFP[index] && other.canonicalFP[index]
+	}
+	if merged.boolFrameGP != nil {
+		for index := range merged.boolFrameGP {
+			if other.boolFrameGP == nil || merged.boolFrameGP[index] != other.boolFrameGP[index] {
+				merged.boolFrameGP[index] = x86ResultSlotAddress{}
+			}
+		}
+	}
+	for index := range merged.auto {
+		merged.auto[index] = merged.auto[index] && other.auto[index]
+	}
+	for index := range merged.gp {
+		merged.gp[index] &= other.gp[index]
+		merged.canonicalGP[index] &= other.canonicalGP[index]
+		merged.pointerGP[index] = merged.pointerGP[index] && other.pointerGP[index]
+		merged.callerAddressGP[index] = merged.callerAddressGP[index] && other.callerAddressGP[index]
+		if merged.callerAddressOrigin[index] != other.callerAddressOrigin[index] || !merged.callerAddressGP[index] {
+			merged.callerAddressOrigin[index] = 0
+		}
+		if merged.resultAddressGP[index] != other.resultAddressGP[index] {
+			merged.resultAddressGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	for index := range merged.xmm {
+		merged.xmm[index] &= other.xmm[index]
+		merged.vectorUpper[index] &= other.vectorUpper[index]
+	}
+	for index := range merged.nativeMMX {
+		merged.nativeMMX[index] &= other.nativeMMX[index]
+	}
+	for index := range merged.masks {
+		merged.masks[index] = merged.masks[index] && other.masks[index]
+	}
+	merged.flags &= other.flags
+	merged.cpuidRootLeaf = merged.cpuidRootLeaf && other.cpuidRootLeaf
+	merged.direction = state.direction.intersect(other.direction)
+	if merged.stringCount != other.stringCount {
+		merged.stringCount = x86StringCountUnknown
+	}
+	if merged.valueStack != nil {
+		if other.valueStack == nil || merged.valueStack.invalid || other.valueStack.invalid ||
+			len(merged.valueStack.bytes) != len(other.valueStack.bytes) ||
+			merged.valueStack.wordCells != other.valueStack.wordCells {
+			merged.valueStack.bytes, merged.valueStack.invalid = nil, true
+			merged.valueStack.refinable = nil
+			merged.valueStack.wordCells = 0
+			merged.valueStack.pointerCells = [8]uint64{}
+		} else {
+			for index := range merged.valueStack.pointerCells {
+				merged.valueStack.pointerCells[index] &= other.valueStack.pointerCells[index]
+			}
+			if merged.valueStack.refinable != nil || other.valueStack.refinable != nil {
+				left, right := merged.valueStack.refinable, other.valueStack.refinable
+				if left == nil {
+					left = merged.valueStack.bytes
+				}
+				if right == nil {
+					right = other.valueStack.bytes
+				}
+				merged.valueStack.refinable = make([]uint8, len(merged.valueStack.bytes))
+				for index := range merged.valueStack.refinable {
+					merged.valueStack.refinable[index] = left[index] & right[index]
+				}
+			}
+			for index := range merged.valueStack.bytes {
+				merged.valueStack.bytes[index] &= other.valueStack.bytes[index]
+			}
+			merged.valueStack.id = merged.valueStack.id && other.valueStack.id
+		}
+		x86ResultIntersectFlagsCorrelation(merged.valueStack, other.valueStack)
+	}
+	if merged.gpBits.fromStack && (merged.valueStack == nil || merged.valueStack.invalid) {
+		merged.gpBits = x86ResultGPBits{}
+	}
+	if merged.bitScanPending != other.bitScanPending {
+		merged.bitScanPending = x86ResultBitScanPending{}
+	}
+	if merged.predicate != other.predicate {
+		merged.predicate = x86ResultPredicate{}
+	}
+	if merged.nativeLEAAddressBits != other.nativeLEAAddressBits {
+		merged.nativeLEAAddressBits = x86NativeLEAAddressBits{}
+	}
+	merged.resultAddressWritten = state.resultAddressWritten || other.resultAddressWritten
+	return merged
+}
+
+// A logical source view never imports a physical stack/frame role. BP is an
+// ordinary GP in mode32; explicit native-frame bindings remain separate.
+func x86LogicalSourceFrameRegister(reg Reg, arch string) bool {
+	return reg == SP || reg == BP && arch != "386"
+}
+
+func x86ResultGP(reg Reg, width int64, arch string) (int, uint8, bool) {
+	root, valid := x86CallerGP(reg)
+	// This observer admits only ABI0. Its R14 entry bytes are undefined,
+	// unlike ABIInternal's opaque g identity; only explicit source writes can
+	// initialize them. No caller/source-stack/native permissions are changed.
+	// BP is an ordinary caller-clobbered GP in mode32. Its entry bytes are
+	// still unknown; only the existing typed writes can define NUM or opaque
+	// pointer facts. Physical source-stack/fixed-local roles remain separate.
+	if !valid || x86LogicalSourceFrameRegister(root, arch) || width == 8 && arch == "386" {
+		return 0, 0, false
+	}
+	if width != 1 && root != reg || width == 1 && !isGoYmbRegisterForArch(reg, arch) {
+		return 0, 0, false
+	}
+	for index, candidate := range []Reg{AX, CX, DX, BX, SP, BP, SI, DI, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		if root == candidate && (arch != "386" || index < 8) {
+			mask := x86CallerByteMask(reg, width)
+			return index, mask, mask != 0
+		}
+	}
+	return 0, 0, false
+}
+
+func x86ResultRead(arg Operand, width int64, state *x86ResultState, owned []bool, arch string) bool {
+	if state.literalMemoryOperand != nil && width > 0 && width <= state.literalMemoryBytes && reflect.DeepEqual(arg, *state.literalMemoryOperand) {
+		return true
+	}
+	if address, valid := x86StaticSBReadAddress(arg, arch); valid {
+		return width > 0 && state.loweredStaticReads[address] >= width || state.goReadOnlyRead.allows(arg, width)
+	}
+	switch arg.Kind {
+	case OpImm:
+		return arg.ImmRaw == "" && !arg.ImmIsFloat
+	case OpReg:
+		if width == 16 {
+			index, valid := amd64ParseXReg(arg.Reg)
+			return valid && index < 16 && (arch != "386" || index < 8) && state.xmm[index] == 0xffff
+		}
+		index, mask, valid := x86ResultGP(arg.Reg, width, arch)
+		return valid && state.gp[index]&mask == mask
+	case OpFP:
+		if arg.FPOffset < 0 || width > int64(len(owned)) || arg.FPOffset > int64(len(owned))-width {
+			return false
+		}
+		for offset := arg.FPOffset; offset < arg.FPOffset+width; offset++ {
+			if !owned[offset] || !state.fp[offset] {
+				return false
+			}
+		}
+		return true
+	case OpMem:
+		offset, valid := x86ResultAUTOOffset(arg, width, len(state.auto))
+		if !valid {
+			return false // An initialized pointer does not initialize its pointee.
+		}
+		for index := offset; index < offset+int(width); index++ {
+			if !state.auto[index] {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+func x86ResultStore(arg Operand, width int64, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+	if arg.Kind == OpMem {
+		offset, valid := x86ResultAUTOOffset(arg, width, len(state.auto))
+		if !valid {
+			return false
+		}
+		for index := offset; index < offset+int(width); index++ {
+			state.auto[index] = true
+		}
+		return true
+	}
+	if arg.Kind == OpReg {
+		if width == 16 {
+			index, valid := amd64ParseXReg(arg.Reg)
+			if !valid || index >= 16 || arch == "386" && index >= 8 {
+				return false
+			}
+			state.xmm[index] = 0xffff
+			return true
+		}
+		index, mask, valid := x86ResultGP(arg.Reg, width, arch)
+		if valid {
+			state.pointerGP[index] = false
+			state.gp[index] |= mask
+			if width == 4 || width == 8 {
+				state.gp[index] = 0xff
+			}
+		}
+		return valid
+	}
+	if arg.Kind != OpFP || arg.FPOffset < resultOffset || width > int64(len(owned)) || arg.FPOffset > int64(len(owned))-width {
+		return false
+	}
+	for offset := arg.FPOffset; offset < arg.FPOffset+width; offset++ {
+		if !owned[offset] {
+			return false
+		}
+	}
+	for offset := arg.FPOffset; offset < arg.FPOffset+width; offset++ {
+		state.fp[offset] = true
+	}
+	return true
+}
+
+func x86ResultTransfer(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) bool {
+	if accepted, known := x86ResultAlternatingFloatStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultRoundStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultVSIBStep(ins, state, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultImplicitMaskMoveStep(ins, state, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultImmediateBlendStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultNamedHalfStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedPrecisionStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultBlendMinposStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultXLATStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultFourSourceStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultFMA3Step(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultScalarPrecisionStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedAbsSignStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultScalarReciprocalStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedReciprocalStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultUnalignedLoadStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultMoveHalfStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedReductionStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultDuplicateMoveStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSegmentQueryStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultIntegerMinMaxStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultMaskBlendStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultFloatingHelperStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedAlignStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSqrtStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSADStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultScalarBitFieldStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedNarrowStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSingleSourceNarrowStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSignedPackedFloatStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedWordMultiplyStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedAverageStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedBitCountStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultGFNIStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultIndexedPermuteStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultIFMAStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedDotStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPermute128Step(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultElementPermuteStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultQwordLookupStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if form, oldInput, known, err := x86FixedVectorValueProperties(ins, arch); known {
+		return err == nil && x86ResultFixedVectorInputs(ins, form, oldInput, state, owned, arch)
+	}
+	if accepted, known := x86ResultCompactExpandStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultByteSwapStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultValueStackStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSignedIntegerFloatStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultUnsignedIntegerFloatStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedStringStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultDirectionStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultVectorTestStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultBitScanStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultNumericalReadStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedZeroExtendStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedSignExtendStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultVectorArithmeticStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultByteShuffleStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedUnpackStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultImmediateShuffleStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedFloatShuffleStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedLowMultiplyStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultMoveMaskStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedConversionStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultCOMIStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultScalarFloatIntegerStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if _, known, err := x86DirectiveProperties(ins); known {
+		return err == nil // Numerical only; never native layout/caller authority.
+	}
+	if accepted, known := x86ResultTernaryLogicStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultVectorCompareStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPackedTestMaskStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if form, known, err := x86VectorZeroProperties(ins, arch); known {
+		if err != nil {
+			return false
+		}
+		zeroed := ^x86CallerVectorByteMask(int64(form.spec.firstByte))
+		for register := 0; register < form.registers; register++ {
+			state.writeVector(register, 64, state.vectorBytes(register)|zeroed, false)
+		}
+		return true
+	}
+	if accepted, known := x86ResultPackedShiftStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultCLMULStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultBroadcastStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultSwapStep(ins, state, arch); known {
+		return accepted
+	}
+	// Share validated source move effects through a local value. The original
+	// operand direction, mode and native certificates remain independently
+	// checked; no source spelling acquires the other move's operand grammar.
+	ins = x86SourceMoveInstruction(ins, arch)
+	if form, known, err := x86GPSIMDTransferProperties(ins, arch); known &&
+		len(ins.Args) == 2 && ins.Args[0].Kind == OpReg && ins.Args[1].Kind == OpReg {
+		// Share numerical register effects, not the private observer's
+		// separate FP/AUTO/SB memory roles or any native/caller permission.
+		return err == nil && x86ResultGPSIMDTransfer(ins, form, state, owned, resultOffset, arch)
+	}
+	if accepted, recognized := x86ResultScalarLaneStep(ins, state, owned, resultOffset, arch); recognized {
+		return accepted
+	}
+	if accepted, known := x86ResultSHAStep(ins, state, owned, arch, false); known {
+		return accepted
+	}
+	if accepted, known := x86ResultAESStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultCallerAddressTest(ins, state, owned, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultCallerAddressDifferenceStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultPointerResidueStep(ins, state, owned, resultOffset, arch); known {
+		return accepted
+	}
+	if accepted, known := x86ResultCallerPointerAdvanceStep(ins, state, arch); known {
+		return accepted
+	}
+	if accepted, recognized := x86ResultIncomingPointerTransfer(ins, state, owned, arch); recognized {
+		return accepted
+	}
+	if ins.Op == OpJMP {
+		return true // The CFG checks its complete target independently.
+	}
+	if accepted, known := x86ResultCounterControlStep(ins, state, owned, arch); known {
+		return accepted
+	}
+	if isAMD64ConditionalBranch(ins.Op) {
+		required := x86ByteBranchFlags(ins.Op)
+		return required != 0 && state.flags&required == required
+	}
+	if ins.Op == "NOP" {
+		return len(ins.Args) == 0
+	}
+	if form, recognized, err := x86ConditionalSetProperties(ins.Op, ins, arch); recognized {
+		required := x86ByteConditionFlags(form.condition)
+		return err == nil && required != 0 && state.flags&required == required && x86ResultStore(form.destination, 1, state, owned, resultOffset, arch)
+	}
+	if effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); recognized {
+		if err != nil || effect.dynamicMemory || state.flags&effect.flagsRead != effect.flagsRead {
+			return false
+		}
+		// Read all ordered inputs before any overwrite. A three-operand
+		// multiply does not read its old result, unlike two-operand IMUL.
+		for _, operand := range effect.operands {
+			ignoredSubleaf := state.cpuidRootLeaf && strings.EqualFold(string(ins.Op), string(OpCPUID)) &&
+				operand.operand.Kind == OpReg && operand.operand.Reg == CX
+			if operand.read && !ignoredSubleaf && !x86ResultRead(operand.operand, operand.width, state, owned, arch) {
+				return false
+			}
+		}
+		for _, operand := range effect.operands {
+			if operand.write && !x86ResultStore(operand.operand, operand.width, state, owned, resultOffset, arch) {
+				return false
+			}
+		}
+		state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+		return true
+	}
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 {
+		return !(width == 8 && arch == "386") && len(ins.Args) == 2 && !(ins.Args[0].Kind == OpFP && ins.Args[1].Kind == OpFP) &&
+			x86ResultRead(ins.Args[0], width, state, owned, arch) &&
+			x86ResultStore(ins.Args[1], width, state, owned, resultOffset, arch)
+	}
+	if accepted, known := x86ResultLegacyScalarMoveStep(ins, state, owned, resultOffset, arch, false); known {
+		return accepted
+	}
+	// Registered scalar RMW instructions are handled by the typed effect above.
+	// Comparisons share the emitter's complete grammar and physical byte views.
+	comparison, recognized, err := x86ScalarCompareProperties(ins.Op, ins, arch)
+	if !recognized || err != nil {
+		return false
+	}
+	width := int64(comparison.bits / 8)
+	if !x86ResultRead(comparison.args[0], width, state, owned, arch) || !x86ResultRead(comparison.args[1], width, state, owned, arch) {
+		return false
+	}
+	state.flags = x86ByteFlagsAll
+	if comparison.test {
+		state.flags &^= x86ByteFlagAF // The architecture leaves AF undefined.
+	}
+	return true
+}
diff --git a/x86_result_initialization_test.go b/x86_result_initialization_test.go
new file mode 100644
index 000000000..dbe8a1c5b
--- /dev/null
+++ b/x86_result_initialization_test.go
@@ -0,0 +1,200 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86ResultInitializationFixture(t *testing.T, arch, declaration, body string) (GoPackage, *File, FuncSig, string) {
+	t.Helper()
+	pkg := mustGoPackage(t, "example.invalid/resultinit", "package resultinit\n"+declaration+"\n")
+	sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var args int64
+	for _, slot := range sig.Frame.Results {
+		if end := slot.Offset + x86FrameScalarBytes(slot.Type, arch); end > args {
+			args = end
+		}
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n", args, body)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return pkg, file, sig, source
+}
+
+func TestX86ABI0ResultInitializationOriginalGoAndFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		for _, kind := range []struct{ typ, move, register string }{
+			{"uint8", "MOVB", "AX"}, {"uint16", "MOVW", "AX"}, {"uint32", "MOVL", "AX"},
+			{"float32", "MOVSS", "X0"}, {"float64", "MOVSD", "X0"},
+		} {
+			t.Run(target.triple+"/"+kind.typ, func(t *testing.T) {
+				word := 8
+				if target.arch == "386" {
+					word = 4
+				}
+				result := word
+				if kind.typ == "float64" {
+					result = 8
+				}
+				body := fmt.Sprintf("%s x+0(FP),%s\n%s %s,ret0+%d(FP)\nRET", kind.move, kind.register, kind.move, kind.register, result)
+				pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x "+kind.typ+") "+kind.typ, body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+					ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+				text, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, text, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple,
+					ResolveSym: options.ResolveSym})
+				if translated != nil && !translated.Module.IsNil() {
+					defer translated.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+			})
+		}
+	}
+}
+
+func x86ResultInitializationObject(t *testing.T, llc, triple, ir, name string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, name+".ll"), filepath.Join(dir, name+".o")
+	if err := os.WriteFile(input, []byte(ir), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	data, err := runtimeOracleCombinedOutput(ctx, exec.CommandContext(ctx, llc, "-O0", "-mtriple="+triple, "-filetype=obj", input, "-o", output))
+	if err != nil {
+		t.Fatalf("LLVM22 result alias object failed: %v\n%s", err, data)
+	}
+	if info, err := os.Stat(output); err != nil || info.Size() == 0 {
+		t.Fatalf("LLVM22 result alias object absent: %v", err)
+	}
+}
+
+func TestX86ABI0ResultInitializationAllPathAndByteBoundaries(t *testing.T) {
+	for name, body := range map[string]string{
+		"split stores":                  "MOVL $1,ret0+0(FP)\nMOVL $2,ret0+4(FP)\nRET",
+		"all branches":                  "MOVL $1,AX\nCMPL AX,$0\nJE other\nMOVQ $1,ret0+0(FP)\nJMP end\nother:\nMOVQ $2,ret0+0(FP)\nend:\nRET",
+		"loop initialized before entry": "MOVQ $1,ret0+0(FP)\nMOVL $3,AX\nloop:\nSUBL $1,AX\nCMPL AX,$0\nJNE loop\nRET",
+		"L zero extends GP":             "MOVL $1,AX\nMOVQ AX,ret0+0(FP)\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+	for missing := 0; missing < 8; missing++ {
+		var body strings.Builder
+		for offset := 0; offset < 8; offset++ {
+			if offset != missing {
+				fmt.Fprintf(&body, "MOVB $1,ret0+%d(FP)\n", offset)
+			}
+		}
+		body.WriteString("RET")
+		_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", body.String())
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err == nil {
+			t.Fatalf("missing result byte %d was accepted", missing)
+		}
+	}
+	for name, body := range map[string]string{
+		"bare": "RET", "read result first": "MOVQ ret0+0(FP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"late unknown overwrite": "MOVQ $1,ret0+0(FP)\nMOVQ AX,ret0+0(FP)\nRET",
+		"partial GP":             "MOVB $1,AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"partial W GP":           "MOVW $1,AX\nMOVQ AX,ret0+0(FP)\nRET",
+		"join revocation":        "MOVL $1,AX\nCMPL AX,$0\nJE other\nMOVQ $1,ret0+0(FP)\nJMP end\nother:\nNOP\nend:\nRET",
+		"loop entry missing":     "MOVL $1,AX\nJMP condition\nbody:\nMOVQ $1,ret0+0(FP)\ncondition:\nCMPL AX,$0\nJNE body\nRET",
+		"call":                   "MOVQ $1,ret0+0(FP)\nCALL ·other(SB)\nRET",
+		"physical store":         "MOVQ $1,ret0+0(FP)\nMOVQ $2,(AX)\nRET",
+		"escape":                 "LEAQ ret0+0(FP),AX\nMOVQ $1,ret0+0(FP)\nRET",
+		"raw":                    "MOVQ $1,ret0+0(FP)\nBYTE $0x90\nRET",
+		"dead unknown call":      "MOVQ $1,ret0+0(FP)\nJMP end\nCALL ·other(SB)\nend:\nRET",
+		"dead unresolved branch": "MOVQ $1,ret0+0(FP)\nJMP end\nJMP nowhere\nend:\nRET",
+		"dead physical escape":   "MOVQ $1,ret0+0(FP)\nJMP end\nLEAQ ret0+0(FP),AX\nend:\nRET",
+		"tail":                   "MOVQ $1,ret0+0(FP)\nJMP ·other(SB)",
+		"wrong offset":           "MOVQ $1,ret0+1(FP)\nRET",
+		"unknown flags":          "JE end\nMOVQ $1,ret0+0(FP)\nend:\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err == nil {
+				t.Fatal("unknown/partial/mixed CFG result acquired initialization")
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultInitializationImmutableInputsAndUnsupportedRoles(t *testing.T) {
+	_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value() uint64", "MOVQ $1,ret0+0(FP)\nRET")
+	before := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+		t.Fatal(err)
+	}
+	if after := fmt.Sprintf("%#v %#v", file.Funcs[0], sig); after != before {
+		t.Fatal("result checker changed its original source or signature")
+	}
+	for name, mutate := range map[string]func(*Func, *FuncSig){
+		"ABIInternal":       func(f *Func, _ *FuncSig) { f.Sym += "<ABIInternal>" },
+		"incoming register": func(_ *Func, s *FuncSig) { s.ArgRegs = []Reg{AX} },
+		"pointer result":    func(_ *Func, s *FuncSig) { s.Ret, s.Frame.Results[0].Type = Ptr, Ptr },
+		"changed layout":    func(_ *Func, s *FuncSig) { s.Frame.Results[0].Offset = 1 },
+		"changed width":     func(_ *Func, s *FuncSig) { s.Ret, s.Frame.Results[0].Type = I32, I32 },
+		"aggregate field":   func(_ *Func, s *FuncSig) { s.Frame.Results[0].Fields = []int{0} },
+		"oversized result":  func(_ *Func, s *FuncSig) { s.Frame.Results[0].Offset = 4096 },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn, changed := file.Funcs[0], sig
+			changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+			mutate(&fn, &changed)
+			if err := CheckX86ABI0ResultInitialization(fn, changed, "amd64"); err == nil {
+				t.Fatal("changed role/layout acquired the original result proof")
+			}
+		})
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "386"); err == nil {
+		t.Fatal("mode32 MOVQ acquired a native-width write certificate")
+	}
+	if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "arm64"); err == nil {
+		t.Fatal("another architecture acquired x86 byte effects")
+	}
+}
diff --git a/x86_result_initialization_tuple_test.go b/x86_result_initialization_tuple_test.go
new file mode 100644
index 000000000..e10db50ce
--- /dev/null
+++ b/x86_result_initialization_tuple_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent gc scalar sizes/alignment, not the proof's layout helpers.
+// A zero width denotes a machine word on the selected target.
+var x86ResultTupleKinds = []struct {
+	name  string
+	width int
+	move  string
+}{
+	{"bool", 1, "MOVB"},
+	{"int8", 1, "MOVB"}, {"uint8", 1, "MOVB"},
+	{"int16", 2, "MOVW"}, {"uint16", 2, "MOVW"},
+	{"int32", 4, "MOVL"}, {"uint32", 4, "MOVL"},
+	{"int64", 8, "MOVQ"}, {"uint64", 8, "MOVQ"},
+	{"int", 0, ""}, {"uint", 0, ""}, {"uintptr", 0, ""},
+	{"float32", 4, "MOVSS"}, {"float64", 8, "MOVSD"},
+}
+
+func x86ResultTupleFixture(t *testing.T, arch string, kinds []int) (*File, FuncSig, string, string) {
+	t.Helper()
+	word := 8
+	if arch == "386" {
+		word = 4
+	}
+	var params, results []string
+	var offsets []int
+	position := 0
+	for _, index := range append(append([]int(nil), kinds...), kinds...) {
+		if len(offsets) == len(kinds) {
+			position = (position + word - 1) & -word
+		}
+		width := x86ResultTupleKinds[index].width
+		if width == 0 {
+			width = word
+		}
+		align := width
+		if align > word {
+			align = word
+		}
+		position = (position + align - 1) & -align
+		offsets = append(offsets, position)
+		position += width
+	}
+	var body strings.Builder
+	for i, index := range kinds {
+		kind := x86ResultTupleKinds[index]
+		params = append(params, fmt.Sprintf("x%d %s", i, kind.name))
+		results = append(results, kind.name)
+		op, reg := kind.move, "AX"
+		if kind.width == 0 {
+			op = "MOVQ"
+			if word == 4 {
+				op = "MOVL"
+			}
+		}
+		if strings.HasPrefix(kind.name, "float") {
+			reg = "X0"
+		}
+		parts, step := 1, 0
+		if arch == "386" && op == "MOVQ" {
+			op, parts, step = "MOVL", 2, 4
+		}
+		for part := 0; part < parts; part++ {
+			fmt.Fprintf(&body, "%s x%d+%d(FP),%s\n%s %s,ret+%d(FP)\n",
+				op, i, offsets[i]+part*step, reg, op, reg, offsets[len(kinds)+i]+part*step)
+		}
+	}
+	body.WriteString("RET")
+	declaration := "func Value(" + strings.Join(params, ",") + ") (" + strings.Join(results, ",") + ")"
+	_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, body.String())
+	if len(sig.Frame.Params) != len(kinds) || len(sig.Frame.Results) != len(kinds) || file.Funcs[0].ArgSize != int64(position) {
+		t.Fatal("typed declaration disagrees with independent scalar layout", sig, position)
+	}
+	for i := range kinds {
+		if sig.Frame.Params[i].Offset != int64(offsets[i]) || sig.Frame.Results[i].Offset != int64(offsets[len(kinds)+i]) {
+			t.Fatal("typed offsets disagree with independent scalar layout", i, offsets, sig)
+		}
+	}
+	return file, sig, source, declaration
+}
+
+func TestX86ABI0ResultTupleScalarTypesAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var all []int
+			var selections [][]int
+			for i := range x86ResultTupleKinds {
+				all = append(all, i)
+				selections = append(selections, []int{i, (i + 1) % len(x86ResultTupleKinds)})
+			}
+			selections = append(selections, all)
+			for i, kinds := range selections {
+				file, sig, asm, decl := x86ResultTupleFixture(t, target.arch, kinds)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatalf("scalar tuple %v: %v", kinds, err)
+				}
+				name := fmt.Sprintf("Tuple%d", i)
+				source.WriteString(strings.ReplaceAll(asm, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(decl, "Value", name) + "\n")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, optimized := range []bool{false, true} {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, ir)
+					}
+					compileLLVMToObject(t, llc, target.triple, "tuple.ll", "tuple.o", text)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultTupleEveryByteAndPath(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			const declaration = "func Value() (uint8, uint32, uint16)"
+			// Padding [1,4) is not a result. Every byte of all three actual
+			// fields is required, including bytes after the first result.
+			owned := []int{0, 4, 5, 6, 7, 8, 9}
+			for missing := -1; missing < len(owned); missing++ {
+				var body strings.Builder
+				for i, offset := range owned {
+					if i != missing {
+						fmt.Fprintf(&body, "MOVB $1,ret+%d(FP)\n", offset)
+					}
+				}
+				body.WriteString("RET")
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, body.String())
+				err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+				if missing < 0 && err != nil || missing >= 0 && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("missing byte index %d: %v", missing, err)
+				}
+			}
+			const stores = "MOVL $1,ret+0(FP)\nMOVL $2,ret+4(FP)\n"
+			for name, body := range map[string]string{
+				"two returns":         "MOVL $1,AX\nCMPL AX,$0\nJE other\n" + stores + "RET\nother:\n" + stores + "RET",
+				"joined returns":      "MOVL $1,AX\nCMPL AX,$0\nJE other\n" + stores + "JMP end\nother:\n" + stores + "end:\nRET",
+				"initialized loop":    stores + "MOVL $3,AX\nloop:\nSUBL $1,AX\nJNE loop\nRET",
+				"read written second": stores + "MOVL ret+4(FP),AX\nMOVL AX,ret+0(FP)\nRET",
+			} {
+				t.Run(name, func(t *testing.T) {
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() (uint32, uint32)", body)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+			for name, body := range map[string]string{
+				"missing first":            "MOVL $2,ret+4(FP)\nRET",
+				"missing second":           "MOVL $1,ret+0(FP)\nRET",
+				"join revocation":          "MOVL $1,AX\nCMPL AX,$0\nJE other\n" + stores + "JMP end\nother:\nMOVL $1,ret+0(FP)\nend:\nRET",
+				"read second before write": "MOVL ret+4(FP),AX\n" + stores + "RET",
+				"late unknown overwrite":   stores + "MOVL CX,ret+4(FP)\nRET",
+				"unknown flags":            "JE end\n" + stores + "end:\nRET",
+				"call":                     stores + "CALL ·other(SB)\nRET",
+				"dead call":                stores + "JMP end\nCALL ·other(SB)\nend:\nRET",
+				"native read":              stores + "MOVL (AX),CX\nRET",
+				"native write":             stores + "MOVL $1,(AX)\nRET",
+				"raw":                      stores + "BYTE $0x90\nRET",
+				"tail":                     stores + "JMP ·other(SB)",
+				"source padding":           "MOVB $1,ret+0(FP)\nMOVL $2,ret+1(FP)\nMOVL $3,ret+4(FP)\nMOVW $4,ret+8(FP)\nRET",
+			} {
+				t.Run(name, func(t *testing.T) {
+					decl := "func Value() (uint32, uint32)"
+					if name == "source padding" {
+						decl = declaration
+					}
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, decl, body)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("unproved tuple acquired initialized results: %v", err)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultTupleFlattenedNumericalAggregates(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for i, row := range []struct{ declaration, body string }{
+				{"func Value() (uint32, [2]uint32)", "MOVL $1,ret+0(FP)\nMOVL $2,ret+4(FP)\nMOVL $3,ret+8(FP)\nRET"},
+				{"func Value() (uint32, struct { A uint8; B uint32 })", "MOVL $1,ret+0(FP)\nMOVB $2,ret+4(FP)\nMOVL $3,ret+8(FP)\nRET"},
+			} {
+				_, file, sig, asm := x86ResultInitializationFixture(t, target.arch, row.declaration, row.body)
+				// DeriveGoFuncABI0Signature already flattens numerical results.
+				// Check all three scalar fields, not just the two Go results.
+				if len(sig.Frame.Results) != 3 {
+					t.Fatal("missing flattened numerical result fields", sig)
+				}
+				for index, field := range sig.Frame.Results {
+					if field.Offset != int64(index*4) || field.Index != index || field.Field != -1 || len(field.Fields) != 0 {
+						t.Fatal("unexpected flattened result layout", sig)
+					}
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				name := fmt.Sprintf("Aggregate%d", i)
+				source.WriteString(strings.ReplaceAll(asm, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(row.declaration, "Value", name) + "\n")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "tuple-aggregate.ll", "tuple-aggregate.o", ir)
+				compileLLVMToObject(t, llc, target.triple, "tuple-aggregate-opt.ll", "tuple-aggregate-opt.o", x86MulDivRoundOptimize(t, ir))
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultTupleLayoutAndAuthorityBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		file, sig, _, _ := x86ResultTupleFixture(t, arch, []int{6, 6})
+		before := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+			t.Fatal(err)
+		}
+		if after := fmt.Sprintf("%#v %#v", file.Funcs[0], sig); before != after {
+			t.Fatal("tuple proof mutated original source or signature")
+		}
+		for name, mutate := range map[string]func(*Func, *FuncSig){
+			"tuple arity": func(_ *Func, s *FuncSig) { s.Ret = "{ i32, i32, i32 }" },
+			"tuple type":  func(_ *Func, s *FuncSig) { s.Ret = "{ i32, float }" },
+			"scalar type": func(_ *Func, s *FuncSig) { s.Ret = I64 },
+			"index":       func(_ *Func, s *FuncSig) { s.Frame.Results[1].Index = 0 },
+			"overlap":     func(_ *Func, s *FuncSig) { s.Frame.Results[1].Offset = s.Frame.Results[0].Offset },
+			"reordered": func(_ *Func, s *FuncSig) {
+				s.Frame.Results[0].Offset, s.Frame.Results[1].Offset = s.Frame.Results[1].Offset, s.Frame.Results[0].Offset
+			},
+			"aggregate field":    func(_ *Func, s *FuncSig) { s.Frame.Results[1].Field = 0 },
+			"nested aggregate":   func(_ *Func, s *FuncSig) { s.Frame.Results[1].Fields = []int{0} },
+			"parameter overlap":  func(_ *Func, s *FuncSig) { s.Frame.Params[1].Offset = s.Frame.Results[0].Offset },
+			"unbounded result":   func(_ *Func, s *FuncSig) { s.Frame.Results[1].Offset = 4096 },
+			"short TEXT":         func(f *Func, _ *FuncSig) { f.ArgSize-- },
+			"pointer result":     func(_ *Func, s *FuncSig) { s.Ret, s.Frame.Results[1].Type = "{ i32, ptr }", Ptr },
+			"ABIInternal":        func(f *Func, _ *FuncSig) { f.Sym += "<ABIInternal>" },
+			"incoming registers": func(_ *Func, s *FuncSig) { s.ArgRegs = []Reg{AX} },
+			"void":               func(_ *Func, s *FuncSig) { s.Ret, s.Frame.Results = Void, nil },
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				fn, changed := file.Funcs[0], sig
+				changed.Frame.Results = append([]FrameSlot(nil), sig.Frame.Results...)
+				changed.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+				mutate(&fn, &changed)
+				if reflect.DeepEqual(sig, changed) && reflect.DeepEqual(fn, file.Funcs[0]) {
+					t.Fatal("mutation did not change the fixture")
+				}
+				if err := CheckX86ABI0ResultInitialization(fn, changed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("changed authority acquired tuple proof: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_integer_minmax.go b/x86_result_integer_minmax.go
new file mode 100644
index 000000000..2ac19bc64
--- /dev/null
+++ b/x86_result_integer_minmax.go
@@ -0,0 +1,44 @@
+package plan9asm
+
+func x86RawIntegerMinMaxSource(ins Instr, arch string) bool {
+	form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.legacy && ins.x86Encoded && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// A decoder-local constant keeps its existing exact DATA/return consumer.
+// This shape supplies no missing input, standalone or native-address role.
+func x86RawIntegerMinMaxLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.legacy && form.memory == form.first &&
+		ins.x86RIPMemoryRead.source == form.first && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+func x86ResultIntegerMinMaxStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86IntegerMinMaxProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		literal := state.loweredStaticReads != nil && x86RawIntegerMinMaxLiteralForm(ins, arch)
+		if !literal && (!native || !x86RawIntegerMinMaxSource(ins, arch)) {
+			return false, true
+		}
+		// Preserve the already-validated physical form. This local numerical
+		// projection does not reparse mode32 bytes as named source operands.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if form.legacy && form.memory >= 0 {
+		source := ins.Args[form.memory]
+		if source.Kind == OpFP || source.Kind == OpMem && !x86OrdinaryNativeMemoryOperand(source, arch) {
+			return false, true // Virtual bytes cannot supply original aligned m128 backing.
+		}
+		if native && !x86ResultPackedVectorRead(ins.Args[form.second], 16, state, owned, arch) {
+			return false, true // A dead original RMW still consumes its old destination.
+		}
+	}
+	return x86ResultPackedLaneArithmeticStepWithRead(ins, form.x86PackedBinaryForm,
+		form.spec.laneBits, state, owned, arch, native), true
+}
diff --git a/x86_result_legacy_integer_arithmetic_test.go b/x86_result_legacy_integer_arithmetic_test.go
new file mode 100644
index 000000000..48f35da9f
--- /dev/null
+++ b/x86_result_legacy_integer_arithmetic_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is the complete legacy Go add/subtract surface, not its V-prefixed
+// forms. PADDD is the assembler's explicit PADDL alias. PADDQ and every PSUB
+// use yxm; only the other PADD rows use ymm and Py1's mode64-only MMX axis.
+var x86LegacyIntegerArithmeticTestNames = []string{
+	"PADDB", "PADDW", "PADDL", "PADDD", "PADDQ",
+	"PADDSB", "PADDSW", "PADDUSB", "PADDUSW",
+	"PSUBB", "PSUBW", "PSUBL", "PSUBQ",
+	"PSUBSB", "PSUBSW", "PSUBUSB", "PSUBUSW",
+}
+
+func TestX86ABI0ResultLegacyIntegerArithmeticCompleteBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			for _, form := range []string{"register", "alias", "FP", "AUTO"} {
+				t.Run(arch+"/"+op+"/"+form, func(t *testing.T) {
+					body := "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\n"
+					for offset := -32; offset < -16; offset += 4 {
+						body += fmt.Sprintf("MOVL $%d,value%d(SP)\n", offset*71, offset)
+					}
+					source := "X1"
+					switch form {
+					case "alias":
+						source = "X0"
+					case "FP":
+						source = "a+0(FP)"
+					case "AUTO":
+						source = "value-32(SP)"
+					}
+					body += op + " " + source + ",X0\nMOVSD X0,ret0+32(FP)\nRET"
+					file, sig, assembly := x86ResultAUTOFixture(t, arch, "func Value(a,b,c,d uint64) uint64", 64, body)
+					goAssemblerOracleOutput(t, arch, assembly, "", true)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+						t.Fatalf("accepted complete legacy arithmetic lacks byte effects: %v\n%s", err, assembly)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyIntegerArithmeticCompleteOriginalGoRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			forms := []string{"X0,X7", "X0,X0", "(AX),X1", "8(AX)(CX*4),X1", "a+0(FP),X1", "value-32(SP),X1", "·data(SB),X1", "(FS),X1", "(GS),X1"}
+			if arch == "amd64" {
+				forms = append(forms, "X15,X0", "X0,X15")
+				if strings.HasPrefix(op, "PADD") && op != "PADDQ" {
+					forms = append(forms, "M0,M7", "(AX),M7", "a+0(FP),M7", "value-32(SP),M7", "·data(SB),M7")
+					for _, reg := range []string{"AX", "CX", "DX", "BX", "SP", "BP", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+						forms = append(forms, reg+",M7")
+					}
+				}
+			}
+			for _, operands := range forms {
+				t.Run(arch+"/accept/"+op+" "+operands, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$64-64\n"+op+" "+operands+"\nRET\n", "", true)
+				})
+			}
+			for _, operands := range []string{"$1,X0", "X0,(AX)", "X0,Y1", "Y0,Y1", "Z0,Z1", "X16,X0", "(AX),(BX)", "X0,K1,X1", "X0,M1", "M0,X1"} {
+				t.Run(arch+"/reject/"+op+" "+operands, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$0-0\n"+op+" "+operands+"\nRET\n", "", false)
+				})
+			}
+			if arch == "386" || op == "PADDQ" || strings.HasPrefix(op, "PSUB") {
+				t.Run(arch+"/reject/"+op+" M0,M1", func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$0-0\n"+op+" M0,M1\nRET\n", "", false)
+				})
+			}
+		}
+	}
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{(APADD\w+|APSUB\w+), (ymm|yxm),`).FindAllStringSubmatch(string(data), -1)
+	var inventory []string
+	for _, row := range rows {
+		inventory = append(inventory, row[1]+":"+row[2])
+	}
+	if got := strings.Join(inventory, ","); got != "APADDB:ymm,APADDL:ymm,APADDQ:yxm,APADDSB:ymm,APADDSW:ymm,APADDUSB:ymm,APADDUSW:ymm,APADDW:ymm,APSUBB:yxm,APSUBL:yxm,APSUBQ:yxm,APSUBSB:yxm,APSUBSW:yxm,APSUBUSB:yxm,APSUBUSW:yxm,APSUBW:yxm" {
+		t.Fatal("complete SDK legacy add/sub table changed", got)
+	}
+	for table, expected := range map[string]string{
+		"ymm": "Zm_r_xm:1:Ymm, Ymr;Zm_r_xm:2:Yxm, Yxr",
+		"yxm": "Zm_r_xm:1:Yxm, Yxr",
+	} {
+		body := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(data))
+		if len(body) != 2 {
+			t.Fatal("missing complete SDK operand table", table)
+		}
+		var actual []string
+		for _, row := range regexp.MustCompile(`\{(\w+), (\d+), argList\{([^}]+)\}\}`).FindAllStringSubmatch(body[1], -1) {
+			actual = append(actual, row[1]+":"+row[2]+":"+row[3])
+		}
+		if strings.Join(actual, ";") != expected {
+			t.Fatal("complete SDK operand rows changed", table, actual)
+		}
+	}
+	for _, class := range []string{"Yax", "Ycx", "Yrx", "Yrl", "Yrl32", "Ym", "Ymr"} {
+		if !strings.Contains(string(data), "ycover["+class+"*Ymax+Ymm] = 1") {
+			t.Fatal("Go physical MMX compatibility class changed", class)
+		}
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "asm", "internal", "arch", "arch.go"))
+	if err != nil || !strings.Contains(string(aliases), `instructions["PADDD"] = x86.APADDL`) {
+		t.Fatal("actual Go PADDD alias changed", err)
+	}
+}
diff --git a/x86_result_legacy_integer_native_read.go b/x86_result_legacy_integer_native_read.go
new file mode 100644
index 000000000..53655a230
--- /dev/null
+++ b/x86_result_legacy_integer_native_read.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+// Only the paired lowering observer may use this conditional result rule.
+// The complete legacy add/subtract form selects an original sideeffect m128
+// opcode, preserving its alignment and dead-fault effects. Continued execution
+// produces numerical result bytes; it proves no pointer extent or alignment.
+func x86ResultLegacyIntegerNativeReadStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, registered, err := x86LegacyIntegerArithmeticProperties(ins.Op, ins, arch)
+	if !registered || err != nil {
+		return false, registered
+	}
+	if form.mmx || !form.legacy || form.byteWidth != 16 || form.memory != 0 || form.source.Kind != OpMem || form.source.Mem.Sym != "" {
+		return false, false // Existing register, static and virtual roles stay separate.
+	}
+	if !x86OrdinaryNativeMemoryOperand(form.source, arch) || ins.x86NumericalRead != nil ||
+		ins.x86Encoded || ins.x86SourceRaw != nil || ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+		return false, true
+	}
+	if !x86ResultRead(form.destination, 16, state, owned, arch) ||
+		!x86ResultReadWithNativeContinuation(ins, form.source, 16, state, owned, arch, true) {
+		return false, true
+	}
+	// The shared legacy byte store preserves higher physical vector bytes;
+	// neither input is read after this write. These opcodes leave FLAGS intact.
+	return x86ResultStore(form.destination, 16, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_legacy_integer_native_read_test.go b/x86_result_legacy_integer_native_read_test.go
new file mode 100644
index 000000000..5c85a66b2
--- /dev/null
+++ b/x86_result_legacy_integer_native_read_test.go
@@ -0,0 +1,211 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86LegacyIntegerNativeResultSource(arch, op, address string, dead bool) (string, string) {
+	move, result, args, offset := "MOVQ", "uint64", 16, 8
+	if arch == "386" {
+		move, result, args, offset = "MOVL", "uint32", 8, 4
+	}
+	final := move + " X0,AX"
+	if dead {
+		final = move + " $7,AX"
+	}
+	body := fmt.Sprintf("TEXT ·Value(SB),4,$16-%d\n%s p+0(FP),AX\nMOVL $2,CX\nPXOR X0,X0\n%s %s,X0\n%s\n%s AX,ret+%d(FP)\nRET\n",
+		args, move, op, address, final, move, offset)
+	return body, "func Value(p *[16]byte) " + result + "\n"
+}
+
+func TestX86LoweredLegacyIntegerNativeReadCompleteThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			for _, address := range []string{"(AX)", "8(AX)(CX*4)"} {
+				for _, dead := range []bool{false, true} {
+					source, declaration := x86LegacyIntegerNativeResultSource(arch, op, address, dead)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/%s/%s/dead%t/%s", arch, op, address, dead, api), func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if err != nil {
+								t.Fatal("original native full-tuple legacy arithmetic did not supply continued result bytes", err)
+							}
+							mnemonic := strings.ToLower(op)
+							if op == "PADDL" || op == "PADDD" {
+								mnemonic = "paddd"
+							} else if op == "PSUBL" {
+								mnemonic = "psubd"
+							}
+							if !strings.Contains(ir, "asm sideeffect \""+mnemonic+" ($2), $0\"") || !strings.Contains(ir, "=x,0,r,~{memory}") ||
+								strings.Contains(ir, "fixed_local_native") {
+								t.Fatal("fault/alignment/full m128 read changed or borrowed local backing", ir)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86LoweredLegacyIntegerNativeReadDoesNotAuthenticateDeclarationQuery(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			source, declaration := x86LegacyIntegerNativeResultSource(arch, op, "(AX)", false)
+			pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			sigs, err := goSigsForAsmFile(pkg, file, func(symbol string) string { return strings.TrimPrefix(symbol, "·") }, arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sigs["Value"], arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("declaration-only observer borrowed paired native continued execution", arch, op, err)
+			}
+		}
+	}
+}
+
+func TestX86LoweredLegacyIntegerNativeReadRequiresWholeInputsAndKeepsState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			ins := x86PureGPUnknownInstruction(t, op+" 8(AX)(CX*4),X0")
+			makeState := func() x86ResultState {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.pointerGP[0], state.gp[1], state.xmm[0] = true, 0xff, 0xffff
+				state.xmm[1], state.vectorUpper[0] = 0x2579, 0xfedcba9876540000
+				return state
+			}
+			for missing := 0; missing < 16; missing++ {
+				state := makeState()
+				state.xmm[0] &^= uint16(1) << uint(missing)
+				before := state.clone()
+				if accepted, known := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, arch); accepted || !known || !reflect.DeepEqual(before, state) {
+					t.Fatal("native source initialized an unknown old destination byte", arch, op, missing, accepted, known)
+				}
+			}
+			for _, kind := range []string{"unknown pointer", "unknown index", "partial index", "numerical base"} {
+				state := makeState()
+				switch kind {
+				case "unknown pointer":
+					state.pointerGP[0] = false
+				case "unknown index":
+					state.gp[1] = 0
+				case "partial index":
+					state.gp[1] = 3
+				case "numerical base":
+					state.pointerGP[0], state.gp[0] = false, 0xff
+				}
+				// A fully initialized machine address is enough for this exact
+				// native access. It still creates no incoming pointer identity.
+				want := kind == "numerical base"
+				if accepted, known := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, arch); accepted != want || !known {
+					t.Fatal("native source borrowed an unproved address", arch, op, kind, accepted, known)
+				}
+			}
+			for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+				state := makeState()
+				state.flags = flags
+				before := state.clone()
+				if accepted, known := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, arch); !accepted || !known || !reflect.DeepEqual(before, state) {
+					t.Fatal("paired full-tuple arithmetic changed unrelated bytes, pointer facts or FLAGS", arch, op, flags, accepted, known)
+				}
+			}
+		}
+	}
+}
+
+func TestX86LoweredLegacyIntegerNativeReadCannotBorrowOtherRoles(t *testing.T) {
+	for _, op := range x86LegacyIntegerArithmeticTestNames {
+		for _, address := range []string{"X1", "a+0(FP)", "value-32(SP)", "·data(SB)", "(SP)", "(BP)", "(FS)", "(GS)"} {
+			ins := x86PureGPUnknownInstruction(t, op+" "+address+",X0")
+			state := x86ResultState{shapeOnly: true, flags: x86ByteFlagsAll}
+			state.xmm[0], state.xmm[1] = 0xffff, 0xffff
+			if accepted, _ := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, "amd64"); accepted {
+				t.Fatal("native conditional source reader borrowed a different operand role", op, address)
+			}
+		}
+		for name, change := range map[string]func(*Instr){
+			"physical":              func(i *Instr) { i.x86Encoded = true },
+			"raw source":            func(i *Instr) { i.x86SourceRaw = &x86SourceRawInstruction{} },
+			"address size":          func(i *Instr) { i.x86AddressBits = 32 },
+			"unbound address size":  func(i *Instr) { i.x86UnboundAddressOverride = true },
+			"segment":               func(i *Instr) { i.x86SegmentPrefix = 0x64 },
+			"numerical certificate": func(i *Instr) { i.x86NumericalRead = &x86NumericalReadCertificate{} },
+		} {
+			ins := x86PureGPUnknownInstruction(t, op+" (AX),X0")
+			change(&ins)
+			state := x86ResultState{shapeOnly: true}
+			state.xmm[0] = 0xffff
+			if accepted, _ := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, "amd64"); accepted {
+				t.Fatal("native conditional source reader borrowed an independent physical/certificate role", op, name)
+			}
+		}
+	}
+	for _, instruction := range []string{"PADDB (AX),M0", "VPADDD (AX),X0,X1", "VPSUBD (AX),Y0,Y1"} {
+		ins := x86PureGPUnknownInstruction(t, instruction)
+		state := x86ResultState{shapeOnly: true}
+		if accepted, _ := x86ResultLegacyIntegerNativeReadStep(ins, &state, nil, 0, "amd64"); accepted {
+			t.Fatal("MMX or VEX tuple borrowed the legacy m128 result rule", instruction)
+		}
+	}
+}
+
+func TestX86LoweredLegacyIntegerNativeReadFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc not found")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			for index, op := range x86LegacyIntegerArithmeticTestNames {
+				name := fmt.Sprintf("LegacyNative%d", index)
+				source, declaration := x86LegacyIntegerNativeResultSource(target.arch, op, "(AX)", false)
+				assembly.WriteString(strings.ReplaceAll(source, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Value", name))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete original legacy native family", api, err)
+				}
+				if strings.Count(ir, "define ") != 17 || strings.Count(ir, "asm sideeffect ") != 17 {
+					t.Fatal("complete family/source or original native opcode denominator changed", api)
+				}
+				for _, optimized := range []bool{false, true} {
+					input := ir
+					if optimized {
+						input = x86UndefinedTrapOptimizedIR(t, input)
+					}
+					compileLLVMToObject(t, llc, target.triple, "legacy-native.ll", "legacy-native.o", input)
+				}
+			}
+		})
+	}
+}
+
+func TestX86LegacyIntegerNativeMemoryCompleteFeatureInference(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86LegacyIntegerArithmeticTestNames {
+			for _, address := range []string{"(AX)", "8(AX)(CX*4)", "·constant(SB)"} {
+				instruction := x86PureGPUnknownInstruction(t, op+" "+address+",X0")
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}})
+				if !strings.Contains(features, "+sse2") {
+					t.Fatalf("complete legacy m128 instruction requires XMM registers: %s/%s/%s: %q", arch, op, address, features)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_legacy_packed_move_test.go b/x86_result_legacy_packed_move_test.go
new file mode 100644
index 000000000..748dbc5b6
--- /dev/null
+++ b/x86_result_legacy_packed_move_test.go
@@ -0,0 +1,146 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This directory is the complete whole-128-bit legacy subset of yxmov,
+// including MOVOA. The same ytab also serves distinct scalar/half moves; the
+// table inventory below retains those names without borrowing their effects.
+var x86LegacyPackedMoveTestNames = []string{"MOVOU", "MOVOA", "MOVO", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD"}
+
+func TestX86ABI0ResultLegacyPackedMoveCompleteDeclaredBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyPackedMoveTestNames {
+			for _, form := range []string{"register", "alias", "FP", "AUTO load", "AUTO store"} {
+				t.Run(arch+"/"+op+"/"+form, func(t *testing.T) {
+					body := "MOVSD a+0(FP),X0\nMOVSD c+16(FP),X1\n"
+					for offset := -32; offset < -16; offset += 4 {
+						body += fmt.Sprintf("MOVL $%d,value%d(SP)\n", offset*71, offset)
+					}
+					switch form {
+					case "register":
+						body += op + " X1,X0\n"
+					case "alias":
+						body += op + " X0,X0\n"
+					case "FP":
+						body += op + " a+0(FP),X0\n"
+					case "AUTO load":
+						body += op + " value-32(SP),X0\n"
+					case "AUTO store":
+						body += op + " X0,value-32(SP)\nMOVSD value-32(SP),X0\n"
+					}
+					body += "MOVSD X0,ret0+32(FP)\nRET"
+					file, sig, source := x86ResultAUTOFixture(t, arch, "func Value(a,b,c,d uint64) uint64", 64, body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+						t.Fatalf("complete Go legacy-move effect is missing: %v\n%s", err, source)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LegacyPackedMoveCompleteActualGoRows(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyPackedMoveTestNames {
+			for _, operands := range []string{
+				"X0,X1", "(AX),X1", "8(AX)(CX*4),X1", "a+0(FP),X1", "value-32(SP),X1", "·data(SB),X1",
+				"X0,(AX)", "X0,8(AX)(CX*4)", "X0,a+0(FP)", "X0,value-32(SP)", "X0,·data(SB)",
+			} {
+				instruction := op + " " + operands
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$64-64\n"+instruction+"\nRET\n", "", true)
+				})
+			}
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range x86LegacyPackedMoveTestNames {
+			for _, operands := range []string{"M0,M1", "AX,X0", "X0,AX", "$1,X0", "Y0,Y1", "Z0,Z1", "X16,X0", "(AX),(BX)", "X0,K1,X1"} {
+				t.Run(arch+"/reject/"+op+" "+operands, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, "TEXT ·Value(SB),4,$0-0\n"+op+" "+operands+"\nRET\n", "", false)
+				})
+			}
+		}
+	}
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows := regexp.MustCompile(`\{(AMOV\w+), yxmov,`).FindAllStringSubmatch(string(data), -1)
+	var names []string
+	for _, row := range rows {
+		names = append(names, row[1])
+	}
+	if strings.Join(names, ",") != "AMOVAPD,AMOVAPS,AMOVO,AMOVOU,AMOVHPD,AMOVHPS,AMOVLPD,AMOVLPS,AMOVSD,AMOVSS,AMOVUPD,AMOVUPS" {
+		t.Fatalf("complete current SDK yxmov rows changed: %v", names)
+	}
+	for _, row := range []string{"{Zm_r_xm, 1, argList{Yxm, Yxr}}", "{Zr_m_xm, 1, argList{Yxr, Yxm}}"} {
+		if !strings.Contains(string(data), row) {
+			t.Fatal("actual Go legacy packed-move operand row disappeared", row)
+		}
+	}
+	aliases, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "asm", "internal", "arch", "arch.go"))
+	if err != nil || !strings.Contains(string(aliases), `instructions["MOVOA"] = x86.AMOVO`) {
+		t.Fatalf("actual Go MOVOA alias changed: %v", err)
+	}
+}
+
+func TestX86ABI0ResultLegacyPackedMoveDoesNotBorrowPermission(t *testing.T) {
+	for _, op := range x86LegacyPackedMoveTestNames {
+		for name, body := range map[string]string{
+			"unknown vector":       op + " X1,X0\nMOVSD X0,ret0+0(FP)\nRET",
+			"unknown upper vector": "MOVSS X1,X0\n" + op + " X0,value-32(SP)\nMOVSD value-32(SP),X0\nMOVSD X0,ret0+0(FP)\nRET",
+			"unknown AUTO":         "MOVL $1,value-32(SP)\n" + op + " value-32(SP),X0\nMOVSD X0,ret0+0(FP)\nRET",
+			"native pointer":       op + " (AX),X0\nMOVSD X0,ret0+0(FP)\nRET",
+			"native store":         "MOVSD $1.0,X0\n" + op + " X0,(AX)\nMOVSD X0,ret0+0(FP)\nRET",
+			"FP gap":               op + " a+0(FP),X0\nMOVSD X0,ret0+8(FP)\nRET",
+			"result overstore":     "MOVSD $1.0,X0\n" + op + " X0,ret0+0(FP)\nRET",
+			"AUTO extent":          "MOVSD $1.0,X0\n" + op + " X0,value-8(SP)\nMOVSD X0,ret0+0(FP)\nRET",
+		} {
+			t.Run(op+"/"+name, func(t *testing.T) {
+				decl := "func Value() uint64"
+				if name == "FP gap" {
+					decl = "func Value(a uint32) uint64"
+				}
+				file, sig, _ := x86ResultAUTOFixture(t, "amd64", decl, 64, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("legacy move borrowed unknown bytes/backing: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultLegacyPackedMovePartialBytesAndJoinedPaths(t *testing.T) {
+	for _, op := range x86LegacyPackedMoveTestNames {
+		ins := Instr{Op: Op(op), Args: []Operand{{Kind: OpReg, Reg: "X1"}, {Kind: OpReg, Reg: "X0"}}}
+		for missing := 0; missing < 16; missing++ {
+			t.Run(fmt.Sprintf("%s/missing%d", op, missing), func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.xmm[1] = 0xffff &^ (uint16(1) << uint(missing))
+				if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+					t.Fatal("one missing source byte was fabricated by an old destination")
+				}
+				state.xmm[1] = 0xffff
+				if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || state.xmm[0] != 0xffff || state.flags != x86ByteFlagsAll {
+					t.Fatal("full overwrite read the old destination or changed flags")
+				}
+			})
+		}
+		body := "MOVSS a+0(FP),X1\nMOVL $1,AX\nCMPL AX,$0\nJE partial\n" + op + " X1,X0\nJMP joined\npartial:\nMOVSS X1,X0\njoined:\n" + op + " X0,value-32(SP)\nMOVSD value-32(SP),X0\nMOVSD X0,ret0+8(FP)\nRET"
+		file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value(a uint32) uint64", 64, body)
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("mixed full/partial vector paths became initialized", op, err)
+		}
+	}
+}
diff --git a/x86_result_local_symbol_test.go b/x86_result_local_symbol_test.go
new file mode 100644
index 000000000..0920e0f58
--- /dev/null
+++ b/x86_result_local_symbol_test.go
@@ -0,0 +1,99 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Go's symRefAttrs assigns ABI0 to both plain and file-local (<>) symbols.
+// Scope is not a register-entry contract or permission to access other bytes.
+func TestX86ABI0LocalSymbolScalarResultsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []struct{ name, move string }{
+			{"uint8", "MOVB"}, {"uint16", "MOVW"}, {"uint32", "MOVL"}, {"uint64", "MOVQ"},
+		} {
+			t.Run(target.triple+"/"+kind.name, func(t *testing.T) {
+				word, move := 8, kind.move
+				if target.arch == "386" {
+					word = 4
+					if kind.name == "uint64" {
+						// The Go mode32 frontend has no 64-bit GP transfer.
+						move = "MOVSD"
+						word = 8
+					}
+				}
+				register := "AX"
+				if move == "MOVSD" {
+					register = "X0"
+				}
+				body := fmt.Sprintf("%s x+0(FP),%s\n%s %s,ret0+%d(FP)\nRET", move, register, move, register, word)
+				pkg, _, signature, ordinary := x86ResultInitializationFixture(t, target.arch,
+					"func Value(x "+kind.name+") "+kind.name, body)
+				source := strings.Replace(ordinary, "·Value(SB)", "·Value<>(SB)", 1)
+				file := mustParseX86RawReturn(t, source)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signature, target.arch); err != nil {
+					t.Fatal("file-local scope changed the scalar result contract", err)
+				}
+				resolve := func(symbol string) string {
+					return strings.ReplaceAll(strings.TrimPrefix(symbol, "·"), "<>", "$local")
+				}
+				signature.Name = "Value$local"
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+					Sigs: map[string]FuncSig{signature.Name: signature}}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ctx := llvm.NewContext()
+						defer ctx.Dispose()
+						var ir string
+						var err error
+						switch api {
+						case "text":
+							ir, err = Translate(file, options)
+						case "module":
+							module, failure := TranslateModuleInContext(ctx, file, options)
+							err = failure
+							if !module.IsNil() {
+								defer module.Dispose()
+								ir = module.String()
+							}
+						case "Go":
+							module, failure := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+								GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+								ManualSig: func(name string) (FuncSig, bool) { return signature, name == signature.Name },
+							})
+							err = failure
+							if module != nil && !module.Module.IsNil() {
+								defer module.Module.Dispose()
+								ir = module.Module.String()
+							}
+						}
+						if err != nil || ir == "" {
+							t.Fatal("typed local scalar source rejected", err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					})
+				}
+				for _, suffix := range []string{"<ABIInternal>", "<ABI0>", "<><>", "<><ABIInternal>"} {
+					changed := file.Funcs[0]
+					changed.Sym = "·Value" + suffix
+					if err := CheckX86ABI0ResultInitialization(changed, signature, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("local scope supplied a different entry or malformed symbol role", suffix, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_mask_arithmetic_test.go b/x86_result_mask_arithmetic_test.go
new file mode 100644
index 000000000..d096f8a5c
--- /dev/null
+++ b/x86_result_mask_arithmetic_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent of the implementation maps: the complete Go KADD/KSHIFT and
+// KUNPCK families have 15 names and two operand rows (_ykaddb/_ykshiftlb).
+var x86MaskNumericalOracle = []struct {
+	op    string
+	bits  int
+	shift bool
+}{
+	{"KADDB", 8, false}, {"KADDW", 16, false},
+	{"KADDD", 32, false}, {"KADDQ", 64, false},
+	{"KSHIFTLB", 8, true}, {"KSHIFTLW", 16, true},
+	{"KSHIFTLD", 32, true}, {"KSHIFTLQ", 64, true},
+	{"KSHIFTRB", 8, true}, {"KSHIFTRW", 16, true},
+	{"KSHIFTRD", 32, true}, {"KSHIFTRQ", 64, true},
+	{"KUNPCKBW", 8, false}, {"KUNPCKWD", 16, false}, {"KUNPCKDQ", 32, false},
+}
+
+func TestX86MaskArithmeticCompletePortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	var source, declarations, prototypes, checks strings.Builder
+	count := 0
+	for _, row := range x86MaskNumericalOracle {
+		counts := []int{0}
+		operation := 0
+		if row.shift {
+			counts = []int{0, row.bits - 1, row.bits, 255}
+			operation = 1
+			if strings.HasPrefix(row.op, "KSHIFTR") {
+				operation = 2
+			}
+		} else if strings.HasPrefix(row.op, "KUNPCK") {
+			operation = 3
+		}
+		for _, shift := range counts {
+			name := fmt.Sprintf("MaskValue%d", count)
+			count++
+			first := "K0"
+			if row.shift {
+				first = fmt.Sprintf("$%d", shift)
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nKMOVQ a+0(FP),K0\nKMOVQ b+8(FP),K7\n"+
+				"%s %s,K7,K3\nKMOVQ K3,ret+16(FP)\nRET\n", name, row.op, first)
+			fmt.Fprintf(&declarations, "func %s(a,b uint64) uint64\n", name)
+			fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t,uint64_t);\n", name)
+			fmt.Fprintf(&checks, "if(check(%s,\"%s\",%d,%d,%d)) return 1;\n", name, name, operation, row.bits, shift)
+		}
+	}
+	if count != 39 {
+		t.Fatal("complete runtime family/count denominator changed", count)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static int check(uint64_t (*fn)(uint64_t,uint64_t),const char *name,unsigned op,unsigned bits,unsigned count) {
+ const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x89abcdef01234567),UINT64_C(0x8000000000000000),UINT64_C(0x55555555aaaaaaaa)};
+ uint64_t mask=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1;
+ for(unsigned a=0;a<6;a++) for(unsigned b=0;b<6;b++) {
+  uint64_t x=values[a]&mask,y=values[b]&mask,expected=0;
+  if(op==0) expected=(x+y)&mask;
+  if(op==1 && count<bits) expected=(y<<count)&mask;
+  if(op==2 && count<bits) expected=y>>count;
+  if(op==3) expected=x|(y<<bits);
+  uint64_t actual=fn(values[a],values[b]);
+  if(actual!=expected) {
+   fprintf(stderr,"%s a=%llx b=%llx got=%llx want=%llx\n",name,
+    (unsigned long long)values[a],(unsigned long long)values[b],(unsigned long long)actual,(unsigned long long)expected);
+   return 1;
+  }
+ }
+ return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete initialized mask-value runtime rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "mask-values", triple, text, oracle, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskArithmeticNumericalInputsAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86MaskNumericalOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				for destination := 0; destination < 8; destination++ {
+					for seed := 0; seed < 256; seed++ {
+						first := "K0"
+						if row.shift {
+							first = "$255"
+						}
+						ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s %s,K7,K%d", row.op, first, destination))
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.pointerGP[0] = 0x93, true
+						for mask := range state.masks {
+							state.masks[mask] = seed&(1<<mask) != 0
+						}
+						before := state.clone()
+						want := state.masks[7] && (row.shift || state.masks[0])
+						if accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch); accepted != want {
+							t.Fatalf("missing or invented input: destination=%d seed=%x accepted=%v want=%v", destination, seed, accepted, want)
+						}
+						if want {
+							before.masks[destination] = true
+						}
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("mask result changed GP, FLAGS, memory or an unrelated mask")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskArithmeticRejectsNonIntegerImmediateConsumers(t *testing.T) {
+	for _, row := range x86MaskNumericalOracle {
+		if !row.shift {
+			continue
+		}
+		for _, value := range []string{"$0.0", "$1.0", "$UNRESOLVED", "$-1", "$256"} {
+			t.Run(row.op+"/"+value, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" "+value+",K1,K2")
+				for _, arch := range []string{"386", "amd64"} {
+					control := x86ScalarLaneInstruction(t, row.op+" $1,K1,K2")
+					consumer, _ := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{control}}, FuncSig{Ret: Void}, nil)
+					consumer.goarch = arch
+					if err := consumer.lowerMaskArithmetic(control.Op, control); err != nil {
+						t.Fatal("valid immediate control did not reach the lowerer", err)
+					}
+					if err := consumer.lowerMaskArithmetic(ins.Op, ins); err == nil {
+						t.Fatal("lowerer accepted a non-Yu8 immediate", arch, value)
+					}
+					state := x86ResultState{}
+					state.masks[1] = true
+					before := state.clone()
+					if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(before, state) {
+						t.Fatal("invalid immediate acquired numerical authority", arch, value)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskArithmeticVoidCannotInventInputs(t *testing.T) {
+	for _, row := range x86MaskNumericalOracle {
+		t.Run(row.op, func(t *testing.T) {
+			first := "K0"
+			if row.shift {
+				first = "$255"
+			}
+			source := "TEXT ·Value(SB),4,$0-0\n" + row.op + " " + first + ",K7,K3\nRET\n"
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, arch := range []string{"386", "amd64"} {
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unknown mask input borrowed implementation zeros", arch, api, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskArithmeticCompleteResultFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			var names []string
+			for _, row := range x86MaskNumericalOracle {
+				counts := []int{0}
+				if row.shift {
+					counts = []int{0, row.bits - 1, row.bits, 255}
+				}
+				for _, count := range counts {
+					name := fmt.Sprintf("MaskResult%d", len(names))
+					names = append(names, name)
+					first := "K0"
+					if row.shift {
+						first = fmt.Sprintf("$%d", count)
+					}
+					fmt.Fprintf(&declarations, "func %s(a,b uintptr) uintptr\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s a+0(FP),AX\nKMOVD AX,K0\n"+
+						"%s b+%d(FP),AX\nKMOVD AX,K7\n%s %s,K7,K3\nKMOVD K3,BX\n%s BX,ret+%d(FP)\nRET\n",
+						name, 3*word, move, move, word, row.op, first, move, 2*word)
+				}
+			}
+			if len(names) != 39 {
+				t.Fatal("complete operation/count denominator changed", len(names))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete initialized mask result rejected", api, err)
+				}
+				x86CompactExpandRequireAllDefinitions(t, ir, names)
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_mask_blend.go b/x86_result_mask_blend.go
new file mode 100644
index 000000000..efeb85f6e
--- /dev/null
+++ b/x86_result_mask_blend.go
@@ -0,0 +1,40 @@
+package plan9asm
+
+// A paired E4 load either supplies the selected native bytes or faults. Its
+// mask suppresses only inactive lanes; this never creates native address,
+// FP/AUTO, raw-entry or caller storage permissions.
+func x86ResultMaskBlendStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86MaskBlendProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if form.mask >= 0 {
+		mask, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	}
+	width := int64(form.byteWidth)
+	firstWidth := width
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	first := ins.Args[form.first]
+	firstKnown := x86ResultPackedVectorRead(first, firstWidth, state, owned, arch)
+	if !firstKnown && nativeRead && first.Kind != OpReg {
+		firstKnown = x86ResultReadWithNativeContinuation(ins, first, firstWidth, state, owned, arch, true)
+	}
+	if !firstKnown || form.mask >= 0 && !form.zeroing &&
+		!x86ResultPackedVectorRead(ins.Args[form.second], width, state, owned, arch) {
+		return false, true
+	}
+	destination, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if !valid {
+		return false, true
+	}
+	state.writeVector(destination, form.byteWidth, ^uint64(0), false)
+	return true, true
+}
diff --git a/x86_result_mask_logical_raw_test.go b/x86_result_mask_logical_raw_test.go
new file mode 100644
index 000000000..e31ee143e
--- /dev/null
+++ b/x86_result_mask_logical_raw_test.go
@@ -0,0 +1,142 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86MaskLogicalRawOperation(t *testing.T, op string) string {
+	t.Helper()
+	for _, row := range x86RawKLogicalRows() {
+		if string(row.name) != op {
+			continue
+		}
+		destination := 3
+		if strings.Contains(op, "TEST") {
+			destination = 7
+		}
+		var source strings.Builder
+		for _, value := range encodeX86RawKLogical(row, 0, 7, destination) {
+			fmt.Fprintf(&source, "BYTE $%#02x\n", value)
+		}
+		return source.String()
+	}
+	t.Fatal("raw oracle has no complete mask encoding", op)
+	return ""
+}
+
+func x86MaskLogicalRawFixture(t *testing.T, source string) string {
+	t.Helper()
+	for _, row := range x86MaskLogicalOracle() {
+		instruction := row.op + " " + row.operands + "\n"
+		if strings.Count(source, instruction) != 1 {
+			t.Fatal("raw fixture lost exact original operation", row.op)
+		}
+		source = strings.Replace(source, instruction, x86MaskLogicalRawOperation(t, row.op), 1)
+	}
+	return source
+}
+
+func TestX86MaskLogicalRawUnknownVoidInputs(t *testing.T) {
+	for _, row := range x86MaskLogicalOracle() {
+		t.Run(row.op, func(t *testing.T) {
+			source := "TEXT ·Value(SB),4,$0\n" + x86MaskLogicalRawOperation(t, row.op) + "RET\n"
+			for _, target := range x86RawReturnTargets {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("raw source invented incoming mask values", target.triple, api, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskLogicalRawCannotBorrowOtherSourceRoles(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0\n"+x86MaskLogicalRawOperation(t, "KANDW")+"RET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err = normalizeX86RawFile(file, "amd64")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var original Instr
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == "KANDW" {
+			original = ins
+		}
+	}
+	if original.x86SourceRaw == nil {
+		t.Fatal("actual raw decoder did not retain the source")
+	}
+	for _, mutate := range []struct {
+		name  string
+		apply func(*Instr)
+	}{
+		{"opcode", func(ins *Instr) { ins.Op = "KORW" }},
+		{"operand", func(ins *Instr) { ins.Args[0].Reg = "K2" }},
+		{"physical", func(ins *Instr) { ins.x86Encoded = true }},
+		{"address-size", func(ins *Instr) { ins.x86AddressBits = 32 }},
+		{"unbound-address", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+		{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+	} {
+		t.Run(mutate.name, func(t *testing.T) {
+			state := x86ResultState{flags: x86ByteFlagAF}
+			state.masks[0], state.masks[7] = true, true
+			control := state.clone()
+			if !x86ScalarFPResultTransfer(original, &control, nil, 0, "amd64") {
+				t.Fatal("actual decoded register-only control rejected")
+			}
+			changed := original
+			changed.Args = append([]Operand(nil), original.Args...)
+			mutate.apply(&changed)
+			before := state.clone()
+			if x86ScalarFPResultTransfer(changed, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+				t.Fatal("changed or foreign raw role acquired mask numerical state")
+			}
+		})
+	}
+}
+
+func TestX86MaskLogicalRawPrivateStateFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word := "Q"
+			if target.arch == "386" {
+				word = "L"
+			}
+			var source, declarations strings.Builder
+			for _, row := range x86MaskLogicalOracle() {
+				fmt.Fprintf(&declarations, "func %s(a,b uint64) uint32\n", row.op)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-20\nKMOVQ a+0(FP),K0\nKMOVQ b+8(FP),K7\n", row.op)
+				// Seed status, DF and ID independently, and keep a live private
+				// stack value across the raw operation. No source SP is exposed.
+				fmt.Fprintf(&source, "PUSH%s $0x200cd7\nPOPF%s\nPUSH%s $42\n", word, word, word)
+				source.WriteString(x86MaskLogicalRawOperation(t, row.op))
+				fmt.Fprintf(&source, "POP%s CX\nPUSHF%s\nPOP%s AX\nMOVL AX,ret+16(FP)\nRET\n", word, word, word)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("raw mask operation lost independent DF/ID or private storage", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_mask_logical_test.go b/x86_result_mask_logical_test.go
new file mode 100644
index 000000000..6d49f3df1
--- /dev/null
+++ b/x86_result_mask_logical_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent source inventory: five binary, one unary and two FLAGS families,
+// each with B/W/D/Q widths. Go's rows are _ykaddb and _yknotb respectively.
+func x86MaskLogicalOracle() []struct{ op, operands string } {
+	var rows []struct{ op, operands string }
+	for _, stem := range []string{"KAND", "KANDN", "KOR", "KXNOR", "KXOR", "KNOT", "KTEST", "KORTEST"} {
+		operands := "K0,K7,K3"
+		if stem == "KNOT" {
+			operands = "K0,K3"
+		} else if stem == "KTEST" || stem == "KORTEST" {
+			operands = "K0,K7"
+		}
+		for _, suffix := range []string{"B", "W", "D", "Q"} {
+			rows = append(rows, struct{ op, operands string }{stem + suffix, operands})
+		}
+	}
+	return rows
+}
+
+func TestX86MaskLogicalCompleteInputAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86MaskLogicalOracle() {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.op+" "+row.operands)
+				for seed := 0; seed < 256; seed++ {
+					state := x86ResultState{flags: x86ByteFlagCF}
+					state.gp[1], state.pointerGP[2], state.callerAddressGP[2] = 0x53, true, true
+					state.xmm[3] = 0x1234
+					for index := range state.masks {
+						state.masks[index] = seed&(1<<index) != 0
+					}
+					before := state.clone()
+					want := state.masks[0] && (strings.HasPrefix(row.op, "KNOT") || state.masks[7])
+					accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+					if accepted != want {
+						t.Fatalf("seed=%02x accepted=%v want=%v", seed, accepted, want)
+					}
+					if want {
+						if strings.Contains(row.op, "TEST") {
+							before.flags = x86ByteFlagsAll
+						} else {
+							before.masks[3] = true
+						}
+					}
+					if !reflect.DeepEqual(state, before) {
+						t.Fatal("mask operation changed unrelated state or partially accepted missing inputs")
+					}
+					if accepted && x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch) != before.callerAddressGP {
+						t.Fatal("mask-only operation revoked unrelated GP address identities")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MaskLogicalUnknownVoidInputs(t *testing.T) {
+	for _, row := range x86MaskLogicalOracle() {
+		t.Run(row.op, func(t *testing.T) {
+			for _, arch := range []string{"amd64", "386"} {
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				source := "TEXT ·Value(SB),4,$0\n" + row.op + " " + row.operands + "\nRET\n"
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead output or unused bool invented source mask values", arch, declaration, api, err)
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskLogicalSameSourceConstants(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, stem := range []string{"KXOR", "KXNOR", "KANDN"} {
+			for _, suffix := range []string{"B", "W", "D", "Q"} {
+				for source := 0; source < 8; source++ {
+					for destination := 0; destination < 8; destination++ {
+						ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s%s K%d,K%d,K%d", stem, suffix, source, source, destination))
+						state := x86ResultState{flags: x86ByteFlagAF}
+						want := state.clone()
+						want.masks[destination] = true
+						if !x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+							t.Fatal("same-source constant required an irrelevant input or changed FLAGS", arch, ins.Raw)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86MaskLogicalCompleteFixture(arch string) (string, string) {
+	var source, declarations strings.Builder
+	for _, row := range x86MaskLogicalOracle() {
+		fmt.Fprintf(&declarations, "func %s(a,b uint64) uint64\n", row.op)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nKMOVQ a+0(FP),K0\nKMOVQ b+8(FP),K7\n%s %s\n",
+			row.op, row.op, row.operands)
+		if strings.Contains(row.op, "TEST") {
+			word := "Q"
+			if arch == "386" {
+				word = "L"
+			}
+			fmt.Fprintf(&source, "PUSHF%s\nPOP%s AX\nAND%s $0x8d5,AX\nMOV%s AX,ret+16(FP)\n", word, word, word, word)
+			if arch == "386" {
+				source.WriteString("MOVL $0,ret+20(FP)\n")
+			}
+		} else {
+			source.WriteString("KMOVQ K3,ret+16(FP)\n")
+		}
+		source.WriteString("RET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86MaskLogicalInitializedFiveTargetObjects(t *testing.T) {
+	x86MaskLogicalFiveTargetObjects(t, false)
+}
+
+func TestX86MaskLogicalRawInitializedFiveTargetObjects(t *testing.T) {
+	x86MaskLogicalFiveTargetObjects(t, true)
+}
+
+func x86MaskLogicalFiveTargetObjects(t *testing.T, raw bool) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86MaskLogicalCompleteFixture(target.arch)
+			if raw {
+				source = x86MaskLogicalRawFixture(t, source)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete initialized mask family rejected", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskLogicalPortableValuesAndFlags(t *testing.T) {
+	x86MaskLogicalPortableValuesAndFlags(t, false)
+}
+
+func TestX86MaskLogicalRawPortableValuesAndFlags(t *testing.T) {
+	x86MaskLogicalPortableValuesAndFlags(t, true)
+}
+
+func x86MaskLogicalPortableValuesAndFlags(t *testing.T, raw bool) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM 22 llc/clang required")
+	}
+	source, declarations := x86MaskLogicalCompleteFixture("amd64")
+	if raw {
+		source = x86MaskLogicalRawFixture(t, source)
+	}
+	var prototypes, checks strings.Builder
+	for index, row := range x86MaskLogicalOracle() {
+		bits := []int{8, 16, 32, 64}[index%4]
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t,uint64_t);\n", row.op)
+		fmt.Fprintf(&checks, "if (check(%s,\"%s\",%d,%d)) return 1;\n", row.op, row.op, index/4, bits)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static int check(uint64_t (*fn)(uint64_t,uint64_t), const char *name, unsigned op, unsigned bits) {
+    const uint64_t values[] = {0, 1, UINT64_MAX, UINT64_C(0x89abcdef01234567),
+        UINT64_C(0x8000000000000000), UINT64_C(0x55555555aaaaaaaa)};
+    uint64_t mask = bits == 64 ? UINT64_MAX : (UINT64_C(1) << bits) - 1;
+    for (unsigned i = 0; i < 6; i++) {
+        for (unsigned j = 0; j < 6; j++) {
+            uint64_t a = values[i] & mask, b = values[j] & mask, expected = 0;
+            switch (op) {
+            case 0: expected = a & b; break;
+            case 1: expected = a & ~b; break;
+            case 2: expected = a | b; break;
+            case 3: expected = ~(a ^ b) & mask; break;
+            case 4: expected = a ^ b; break;
+            case 5: expected = ~a & mask; break;
+            case 6: expected = ((a & b) == 0 ? 64 : 0) | ((a & ~b) == 0 ? 1 : 0); break;
+            case 7: expected = ((a | b) == 0 ? 64 : 0) | ((a | b) == mask ? 1 : 0); break;
+            }
+            uint64_t actual = fn(values[i], values[j]);
+            if (actual != expected) {
+                fprintf(stderr, "%s a=%llx b=%llx got=%llx want=%llx\n", name,
+                    (unsigned long long)values[i], (unsigned long long)values[j],
+                    (unsigned long long)actual, (unsigned long long)expected);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal("complete mask value/status program rejected", api, err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "mask-logical", triple, text, oracle, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_mask_move.go b/x86_result_mask_move.go
new file mode 100644
index 000000000..7764b2e82
--- /dev/null
+++ b/x86_result_mask_move.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+func x86RawMaskMoveSource(ins Instr, arch string) bool {
+	_, known, err := x86TypedMaskMoveByteEffect(ins.Op, ins, arch)
+	if !known || err != nil || ins.x86Encoded || !x86RawOrdinaryVectorSource(ins, arch) {
+		return false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg && !x86RegisterAddressedNativeMemoryOperand(operand, arch) {
+			return false // Decoded native operands cannot borrow FP, SB, literal or frame roles.
+		}
+	}
+	return true
+}
+
+// Native continuation belongs only to lowering paired with the exact volatile
+// access. Standalone declaration, caller and frame observers retain their own
+// storage contracts; an incoming pointer never asserts backing or bounds.
+func x86MaskMoveResultStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string, native bool) (bool, bool) {
+	form, known, err := x86MaskMoveProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, false
+	}
+	width := int64(form.bits / 8)
+	first, last := ins.Args[0], ins.Args[1]
+	// Whole-source replay is checked before the paired lowering consumer.
+	// Exact raw identity shares only the named emitter's volatile access;
+	// original source/provenance and all numerical inputs remain unchanged.
+	pairedNative := native && ins.x86NumericalRead == nil &&
+		(x86ResultNamedPredicateInstruction(ins) || x86RawMaskMoveSource(ins, arch))
+	if form.source == x86MaskMoveK {
+		index, _ := amd64ParseKReg(first.Reg)
+		if !state.masks[index] {
+			return false, true
+		}
+	} else if !x86ResultRead(first, width, state, owned, arch) {
+		if !pairedNative || !x86RegisterAddressedNativeMemoryOperand(first, arch) ||
+			!x86ResultIncomingPointerReadAddressIdentity(first, state, arch) {
+			return false, true
+		}
+	}
+	if form.destination == x86MaskMoveK {
+		index, _ := amd64ParseKReg(last.Reg)
+		state.masks[index] = true
+		return true, true
+	}
+	if pairedNative &&
+		x86OrdinaryNativeMemoryOperand(last, arch) && x86ResultIncomingPointerAddressIdentity(last, state, arch) {
+		return true, true // Native stores establish no reusable memory facts.
+	}
+	if last.Kind == OpReg {
+		// KMOV's GP encoding zero-extends B/W/D, unlike partial MOVB/W.
+		word := x86ResultPointerWord(arch)
+		if width < word {
+			width = word
+		}
+	}
+	return x86ResultStore(last, width, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_mask_move_fp_test.go b/x86_result_mask_move_fp_test.go
new file mode 100644
index 000000000..086f9c796
--- /dev/null
+++ b/x86_result_mask_move_fp_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+var x86MaskMoveFPOracle = []struct {
+	op          string
+	bits, input int
+}{
+	{"KMOVB", 8, 0}, {"KMOVW", 16, 0}, {"KMOVD", 32, 0}, {"KMOVQ", 64, 0},
+	{"KMOVB", 8, 3}, {"KMOVW", 16, 3}, {"KMOVD", 32, 2},
+}
+
+func x86MaskMoveFPFixture() (string, string, []string) {
+	var source, declarations strings.Builder
+	var names []string
+	for index, row := range x86MaskMoveFPOracle {
+		name := fmt.Sprintf("MaskFP%d", index)
+		names = append(names, name)
+		fmt.Fprintf(&declarations, "func %s(a,b uint32) uint64\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\n"+
+			"MOVL $0x11223344,AX\nMOVL AX,ret+8(FP)\n"+
+			"MOVL $0x55667788,AX\nMOVL AX,ret+12(FP)\n"+
+			"%s a+%d(FP),K1\n%s K1,ret+8(FP)\nRET\n", name, row.op, row.input, row.op)
+	}
+	return source.String(), declarations.String(), names
+}
+
+func TestX86MaskMoveLogicalFPExactReadAndWriteWidths(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	source, declarations, names := x86MaskMoveFPFixture()
+	if len(names) != 7 {
+		t.Fatal("complete FP width/cross-field denominator changed", len(names))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete logical mask movement rejected", api, err)
+				}
+				x86CompactExpandRequireAllDefinitions(t, ir, names)
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86MaskMoveLogicalFPExactBytesPortableRuntime(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	source, declarations, names := x86MaskMoveFPFixture()
+	var prototypes, checks strings.Builder
+	for index, name := range names {
+		row := x86MaskMoveFPOracle[index]
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(uint32_t,uint32_t);\n", name)
+		fmt.Fprintf(&checks, "if(check(%s,\"%s\",%d,%d)) return 1;\n", name, name, row.bits, row.input)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static int check(uint64_t (*fn)(uint32_t,uint32_t),const char *name,unsigned bits,unsigned offset) {
+    const uint32_t values[]={0,1,UINT32_MAX,UINT32_C(0x89abcdef),UINT32_C(0x12345678)};
+    uint64_t mask=bits==64 ? UINT64_MAX : (UINT64_C(1)<<bits)-1;
+    for(unsigned a=0;a<5;a++) for(unsigned b=0;b<5;b++) {
+        uint64_t source=(uint64_t)values[a]|((uint64_t)values[b]<<32);
+        uint64_t expected=(UINT64_C(0x5566778811223344)&~mask)|((source>>(8*offset))&mask);
+        uint64_t actual=fn(values[a],values[b]);
+        if(actual!=expected) {
+            fprintf(stderr,"%s a=%x b=%x actual=%llx expected=%llx\n",name,values[a],values[b],
+                    (unsigned long long)actual,(unsigned long long)expected);
+            return 1;
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks.String() + "return 0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete logical FP mask source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "mask-fp", triple, text, oracle, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86NumericalEffectConsumesOnlyCheckedCallerContinuation(t *testing.T) {
+	_, _, options, source := x86PrivateReadObserverFixture(t)
+	signature := options.Sigs["caller.kernel"]
+	for _, mutation := range []string{"complete", "inferred-features", "foreign-features", "unbound-features", "changed-declaration", "missing-declaration-caller", "missing-caller", "changed-signature", "changed-source", "different-stack", "different-arch"} {
+		t.Run(mutation, func(t *testing.T) {
+			consumer, _ := newAMD64CtxWithFuncForTest(t, source, signature, nil)
+			switch mutation {
+			case "inferred-features":
+				consumer.fpFeatureAttrs, consumer.sig.Attrs = "#17", "#17"
+			case "foreign-features":
+				consumer.fpFeatureAttrs, consumer.sig.Attrs = "#17", "#18"
+			case "unbound-features":
+				consumer.sig.Attrs = "#17"
+			case "changed-declaration":
+				consumer.fpSourceSig.Name += ".foreign"
+			case "missing-declaration-caller":
+				consumer.fpSourceSig.x86CallerRegions = nil
+			case "missing-caller":
+				consumer.sig.x86CallerRegions = nil
+			case "changed-signature":
+				consumer.sig.Name += ".foreign"
+			case "changed-source":
+				consumer.fpScalarSource.Instrs = append(append([]Instr(nil), source.Instrs...), Instr{Op: "NOP"})
+			case "different-stack":
+				copy := *consumer.sourceStack
+				consumer.sourceStack = &copy
+			case "different-arch":
+				consumer.goarch = "386"
+			}
+			err := consumer.integerEffectResultInitialized("mask movement")
+			if mutation == "complete" || mutation == "inferred-features" {
+				if err != nil || consumer.fpScalarChecked {
+					t.Fatal("complete caller proof was lost or impersonated a logical FP proof", err)
+				}
+			} else if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("edited or missing complete caller proof became numerical authority", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_mask_move_width_test.go b/x86_result_mask_move_width_test.go
new file mode 100644
index 000000000..b5d743ebc
--- /dev/null
+++ b/x86_result_mask_move_width_test.go
@@ -0,0 +1,137 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent data widths: a K-to-GP transfer also defines the architectural
+// zero remainder, unlike a partial ordinary MOVB/MOVW register write.
+var x86ResultMaskMoveWidthOracle = []struct {
+	op   string
+	bits int
+}{
+	{"KMOVB", 8}, {"KMOVW", 16}, {"KMOVD", 32}, {"KMOVQ", 64},
+}
+
+func TestX86MaskMoveGPResultFullWordDefinedness(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			for mask := 0; mask < 8; mask++ {
+				t.Run(fmt.Sprintf("%s/%s/K%d", arch, row.op, mask), func(t *testing.T) {
+					instruction := x86ScalarLaneInstruction(t, fmt.Sprintf("%s K%d,BX", row.op, mask))
+					for seed := 0; seed < 256; seed++ {
+						for _, initialized := range []bool{false, true} {
+							state := x86ResultState{flags: x86ByteFlagsAll}
+							state.masks[mask] = initialized
+							state.gp[3], state.pointerGP[3] = uint8(seed), true
+							before := state.clone()
+							accepted := x86ScalarFPResultTransfer(instruction, &state, nil, 0, arch)
+							want := initialized
+							if accepted != want {
+								t.Fatal("mask move acquired a missing input or physical width", seed, initialized, accepted, want)
+							}
+							if !want {
+								if !reflect.DeepEqual(state, before) {
+									t.Fatal("rejected mask transfer changed numerical state")
+								}
+								continue
+							}
+							before.gp[3], before.pointerGP[3] = 0xff, false
+							if !reflect.DeepEqual(state, before) {
+								t.Fatal("GP zero extension lost complete numerical bytes or changed unrelated state", seed, state.gp[3])
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86ResultMaskMoveWidthFixture(arch string) (string, string, []string) {
+	word, move, count := 8, "MOVQ", "POPCNTQ"
+	registers := []string{"AX", "BX", "CX", "DX", "SI", "DI", "R8", "R15"}
+	if arch == "386" {
+		word, move, count = 4, "MOVL", "POPCNTL"
+		registers = registers[:6]
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for _, row := range x86ResultMaskMoveWidthOracle {
+		for _, destination := range registers {
+			for _, mask := range []string{"K0", "K7"} {
+				input := "DX"
+				if destination == input {
+					input = "AX"
+				}
+				name := fmt.Sprintf("Mask%d", len(names))
+				names = append(names, name)
+				fmt.Fprintf(&declarations, "func %s(x uintptr) uintptr\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),%s\n"+
+					"KMOVD %s,K1\nVPXORD Z0,Z0,Z0\nVPXORD Z7,Z7,Z7\nVPCOMPRESSQ Z0,K1,Z7\n"+
+					"%s %s,%s\n%s %s,%s\n%s %s,%s\n%s %s,ret+%d(FP)\nRET\n",
+					name, 2*word, move, input, input, row.op, input, mask, row.op, mask, destination,
+					count, destination, destination, move, destination, word)
+			}
+		}
+	}
+	return source.String(), declarations.String(), names
+}
+
+func TestX86MaskMoveGPResultFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86ResultMaskMoveWidthFixture(target.arch)
+			want := 64
+			if target.arch == "386" {
+				want = 48
+			}
+			if len(names) != want {
+				t.Fatal("complete mask/width/register denominator changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete mask-to-GP count sequence rejected", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86MaskMoveGPResultCannotInventInputOrBoolCanonicality(t *testing.T) {
+	for _, row := range x86ResultMaskMoveWidthOracle {
+		for name, body := range map[string]string{
+			"unknown-mask": row.op + " K1,BX\nMOVB BX,ret+8(FP)\nRET\n",
+			"not-bool": "MOVQ x+0(FP),AX\nKMOVQ AX,K1\nMOVL $1,BX\n" +
+				row.op + " K1,BX\nMOVB BX,ret+8(FP)\nRET\n",
+		} {
+			t.Run(row.op+"/"+name, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-9\n" + body
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(x uint64) bool", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("mask transfer invented numerical input or a canonical bool", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_mask_native_test.go b/x86_result_mask_native_test.go
new file mode 100644
index 000000000..8ead37411
--- /dev/null
+++ b/x86_result_mask_native_test.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MaskNativeEmitterPreservesExactVolatileWidths(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			for _, text := range []string{row.op + " 3(AX)(CX*2),K1", row.op + " K1,3(AX)(CX*2)"} {
+				t.Run(arch+"/"+text, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, text)
+					consumer, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+					consumer.goarch = arch
+					// Emitter unit only: entry register values here are not a
+					// source proof, native backing or executable input.
+					if err := consumer.lowerMaskMove(ins.Op, ins); err != nil {
+						t.Fatal(err)
+					}
+					operation := "load"
+					if ins.Args[0].Kind == OpReg {
+						operation = "store"
+					}
+					if strings.Count(output.String(), fmt.Sprintf("%s volatile i%d", operation, row.bits)) != 1 ||
+						!strings.Contains(output.String(), "align 1") {
+						t.Fatal("native mask effect lost its exact width, fault or unaligned role", output.String())
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86MaskNativeFixture(arch, op string, dead bool) (string, string) {
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	result := "KMOVD K1,BX\n"
+	if dead {
+		result = "MOVL $7,BX\n"
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,CX\n"+
+		"%s 3(AX)(CX*2),K1\n%s K1,3(AX)(CX*2)\n%sMOVL BX,ret+%d(FP)\nRET\n",
+		word+4, move, op, op, result, word)
+	return source, "func Value(p *[16]byte) uint32"
+}
+
+func TestX86MaskNativeCompleteFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			for _, dead := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/dead%t", target.triple, row.op, dead), func(t *testing.T) {
+					source, declaration := x86MaskNativeFixture(target.arch, row.op, dead)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("paired native mask movement rejected", api, err)
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							if strings.Count(text, fmt.Sprintf("load volatile i%d,", row.bits)) != 1 ||
+								strings.Count(text, fmt.Sprintf("store volatile i%d ", row.bits)) != 1 {
+								t.Fatal("live/dead optimized source lost a native read or write", api, text)
+							}
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, target.triple, text, level)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86MaskNativeCannotSupplyDeclarationOrMissingInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ResultMaskMoveWidthOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				source, declaration := x86MaskNativeFixture(arch, row.op, false)
+				body := strings.SplitN(strings.TrimSuffix(source, "RET\n"), "\n", 2)[1]
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, body)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone declaration borrowed native execution", err)
+					}
+				}
+				for name, changed := range map[string]string{
+					"unknown-base":  strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+					"numeric-base":  strings.Replace(source, "MOVL $1,CX", "MOVL $42,AX\nMOVL $1,CX", 1),
+					"unknown-index": strings.Replace(source, "MOVL $1,CX\n", "", 1),
+					"unknown-mask":  strings.Replace(source, row.op+" 3(AX)(CX*2),K1\n", "", 1),
+				} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("native mask movement invented missing facts", name, api, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_move_half.go b/x86_result_move_half.go
new file mode 100644
index 000000000..edf3572da
--- /dev/null
+++ b/x86_result_move_half.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+// Byte selectors do not initialize an unknown copied half. The native m64
+// access is mandatory independently of any selected output, including Void.
+func x86ResultMoveHalfStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, native bool) (bool, bool) {
+	form, known, err := x86MoveHalfProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.undocumentedPDRegister {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawMoveHalfSource(ins, arch) {
+			return false, true
+		}
+		// Only this exact sealed source may share the paired projection.
+		// Register-only aliases supply no native address, caller or entry fact.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	source := uint64(0xff)
+	if form.memory >= 0 && !form.store {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[form.source], 8, state, owned, arch, native) {
+			return false, true
+		}
+	} else {
+		index, _ := amd64ParseXReg(ins.Args[form.source].Reg)
+		source = state.vectorBytes(index) >> uint(form.sourceLane*8) & 0xff
+	}
+	if form.store {
+		if source != 0xff {
+			return false, true
+		}
+		destination := ins.Args[form.destination]
+		if x86ResultScalarLaneNativeStore(ins, destination, state, arch, native) {
+			return true, true // The access creates no later-read or storage fact.
+		}
+		return x86ResultStore(destination, 8, state, owned, resultOffset, arch), true
+	}
+	base, _ := amd64ParseXReg(ins.Args[form.base].Reg)
+	destination, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+	lane := uint(form.outputLane * 8)
+	mask := uint64(0xff) << lane
+	defined := state.vectorBytes(base)&0xffff&^mask | source<<lane
+	state.writeVector(destination, 16, defined, !form.spec.vector)
+	return true, true // FLAGS, DF, masks, pointers and unrelated storage survive.
+}
+
+func x86RawMoveHalfSource(ins Instr, arch string) bool {
+	form, known, err := x86MoveHalfProperties(ins.Op, ins, arch)
+	return known && err == nil && (form.spec.vector || form.spec.registerOnly) && x86RawOrdinaryVectorSource(ins, arch)
+}
diff --git a/x86_result_movemask.go b/x86_result_movemask.go
new file mode 100644
index 000000000..6f9f91879
--- /dev/null
+++ b/x86_result_movemask.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+// Every output bit depends only on its source sign byte; high bits are zero.
+// Whole numerical GP bytes and one adjacent bit observation remain distinct.
+// FLAGS/vector aliases, physical MMX and raw/mode32 source roles are unchanged.
+func x86ResultMoveMaskStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86MoveMaskProperties(ins.Op, ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || form.byteWidth == 8 {
+		return false, true
+	}
+	index, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.byteWidth)
+	if !valid || arch == "386" && index >= 8 {
+		return false, true
+	}
+	source := state.vectorBytes(index)
+	named := x86ResultNamedPredicateInstruction(ins)
+	if !named && source&x86CallerVectorByteMask(int64(form.byteWidth)) != x86CallerVectorByteMask(int64(form.byteWidth)) {
+		return false, true // Partial named facts cannot establish a raw source role.
+	}
+	destination, _, valid := x86ResultGP(ins.Args[1].Reg, 4, arch)
+	if !valid {
+		return false, true
+	}
+	laneBytes := 1
+	if form.floatingLaneBits != 0 {
+		laneBytes = form.floatingLaneBits / 8
+	}
+	bits := ^uint64(0)
+	for lane := 0; lane < form.byteWidth/laneBytes; lane++ {
+		if source&(uint64(1)<<uint(lane*laneBytes+laneBytes-1)) == 0 {
+			bits &^= uint64(1) << uint(lane)
+		}
+	}
+	var bytes uint8
+	for at := 0; at < 8; at++ {
+		if byte(bits>>uint(8*at)) == 255 {
+			bytes |= 1 << uint(at)
+		}
+	}
+	if !x86ResultStore(ins.Args[1], 4, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.gp[destination] = bytes
+	if named && bits != ^uint64(0) {
+		state.gpBits = x86ResultGPBits{bits: bits, register: destination, valid: true}
+	}
+	return true, true
+}
diff --git a/x86_result_movemask_test.go b/x86_result_movemask_test.go
new file mode 100644
index 000000000..5b542f96b
--- /dev/null
+++ b/x86_result_movemask_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+var x86ResultMoveMaskForms = []string{
+	"PMOVMSKB X0,AX", "MOVMSKPS X0,AX", "MOVMSKPD X0,AX",
+	"VPMOVMSKB X0,AX", "VPMOVMSKB Y0,AX",
+	"VMOVMSKPS X0,AX", "VMOVMSKPS Y0,AX",
+	"VMOVMSKPD X0,AX", "VMOVMSKPD Y0,AX",
+}
+
+func TestX86ResultMoveMaskEveryByteAndPreservedState(t *testing.T) {
+	for _, line := range x86ResultMoveMaskForms {
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+line+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		instruction := file.Funcs[0].Instrs[1]
+		width := 16
+		if strings.Contains(line, " Y") {
+			width = 32
+		}
+		laneBytes := 1
+		if strings.Contains(line, "MSKPS") {
+			laneBytes = 4
+		} else if strings.Contains(line, "MSKPD") {
+			laneBytes = 8
+		}
+		for missing := -1; missing < width; missing++ {
+			state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagOF}
+			state.xmm[0], state.vectorUpper[0] = 0xffff, ^uint64(0xffff)
+			if missing >= 0 && missing < 16 {
+				state.xmm[0] &^= 1 << uint(missing)
+			} else if missing >= 16 {
+				state.vectorUpper[0] &^= 1 << uint(missing)
+			}
+			before := state
+			accepted, known := x86ResultMoveMaskStep(instruction, &state, nil, 0, "amd64")
+			if !known || !accepted {
+				t.Fatalf("%s missing byte=%d: accepted=%t known=%t", line, missing, accepted, known)
+			}
+			want := before
+			want.gp[0] = 0xff
+			if missing >= 0 && missing%laneBytes == laneBytes-1 {
+				// An unavailable sign bit makes only its output bit unknown.
+				// This does not make the containing GP byte numerical; only an
+				// adjacent consumer may independently mask away that bit.
+				bit := uint(missing / laneBytes)
+				want.gp[0] &^= 1 << (bit / 8)
+				want.gpBits = x86ResultGPBits{bits: ^(uint64(1) << bit), register: 0, valid: true}
+			}
+			if !reflect.DeepEqual(state, want) {
+				t.Fatalf("%s changed vector/FLAGS/other GP state at missing byte=%d", line, missing)
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultMoveMaskWholeFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		typ, move := "uint64", "MOVQ"
+		if arch == "386" {
+			typ, move = "uint32", "MOVL"
+		}
+		for _, instruction := range x86ResultMoveMaskForms {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				body := "VZEROALL\n" + instruction + "\n" + move + " AX,ret0+0(FP)\nRET"
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() "+typ, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("source-defined mask must define its zero-extended GP result: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultMoveMaskUnknownBytesAndFlags(t *testing.T) {
+	for _, instruction := range x86ResultMoveMaskForms {
+		for _, prefix := range []string{"", "MOVB $1,AX\nPINSRB $0,AX,X0\n"} {
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint64",
+				prefix+instruction+"\nMOVQ AX,ret0+0(FP)\nRET")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("unknown vector bytes became mask bits: %s %s: %v", prefix, instruction, err)
+			}
+		}
+		for _, defined := range []bool{false, true} {
+			prefix := "VZEROALL\n"
+			if defined {
+				prefix += "MOVL $1,BX\nCMPL BX,$0\n"
+			}
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint8",
+				prefix+instruction+"\nSETEQ ret0+0(FP)\nRET")
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+			if defined && err != nil || !defined && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Errorf("mask changed FLAGS definedness=%t: %s: %v", defined, instruction, err)
+			}
+		}
+	}
+	for _, sourceRegister := range []string{"X8", "Y8", "M0"} {
+		op := "VPMOVMSKB"
+		if sourceRegister == "M0" {
+			op = "PMOVMSKB"
+		}
+		body := fmt.Sprintf("%s %s,AX\nMOVL AX,ret0+0(FP)\nRET", op, sourceRegister)
+		_, file, sig, source := x86ResultInitializationFixture(t, "386", "func Value() uint32", body)
+		goAssemblerOracleOutput(t, "386", source, "", true)
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Errorf("mask acquired an unbound physical source role: %s: %v", sourceRegister, err)
+		}
+	}
+}
diff --git a/x86_result_movnti.go b/x86_result_movnti.go
new file mode 100644
index 000000000..7ea13a262
--- /dev/null
+++ b/x86_result_movnti.go
@@ -0,0 +1,23 @@
+package plan9asm
+
+// This is a lowering-only continuation for the original side-effecting MOVNTI
+// opcode. It supplies no numerical bytes, pointer backing, later memory facts,
+// frame permission or caller contract. Void/dead stores owe the same inputs.
+func x86LoweredMOVNTIResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86MOVNTIProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, true
+	}
+	if form.trap {
+		return true, true // The independently registered #UD closes control flow.
+	}
+	if x86LogicalSourceFrameRegister(form.source.Reg, arch) ||
+		!x86RegisterAddressedNativeMemoryOperand(form.destination, arch) ||
+		!x86ResultIncomingPointerAddressIdentity(form.destination, state, arch) {
+		return false, true
+	}
+	return x86ResultRead(form.source, int64(form.bits/8), state, owned, arch), true
+}
diff --git a/x86_result_movnti_test.go b/x86_result_movnti_test.go
new file mode 100644
index 000000000..9376b71c3
--- /dev/null
+++ b/x86_result_movnti_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86MOVNTIPairedStoreReadsEveryByteAndPreservesState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			name  string
+			width int64
+		}{{"MOVNTIL", 4}, {"MOVNTIQ", 8}} {
+			if arch == "386" && row.width == 8 {
+				continue
+			}
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row.name+" AX,-1(DX)(CX*2)")
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+					valueStack: &x86ResultValueStack{bytes: []uint8{255, 255, 255, 255, 255, 255, 255, 255}, id: true}}
+				value, _, _ := x86ResultGP(AX, row.width, arch)
+				base, _, _ := x86ResultGP(DX, x86ResultPointerWord(arch), arch)
+				index, _, _ := x86ResultGP(CX, x86ResultPointerWord(arch), arch)
+				state.gp[value], state.gp[index], state.pointerGP[base] = 0xff, 0xff, true
+				state.fp, state.auto = []bool{true, false}, []bool{false, true}
+				before := state.clone()
+				if accepted, known := x86LoweredMOVNTIResultStep(ins, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, before) {
+					t.Fatal("MOVNTI created bytes, memory, pointers or FLAGS facts")
+				}
+				for missing := int64(0); missing < row.width; missing++ {
+					current := before.clone()
+					current.gp[value] &^= 1 << uint(missing)
+					initial := current.clone()
+					if accepted, known := x86LoweredMOVNTIResultStep(ins, &current, nil, arch); !known || accepted || !reflect.DeepEqual(current, initial) {
+						t.Fatal("MOVNTI consumed a missing source byte", missing)
+					}
+				}
+				for _, change := range []string{"pointer", "numeric base", "index", "pointer data", "raw", "encoded", "address size", "address override", "segment prefix"} {
+					t.Run(change, func(t *testing.T) {
+						changed, current := ins, before.clone()
+						switch change {
+						case "pointer", "numeric base":
+							current.pointerGP[base] = false
+							if change == "numeric base" {
+								current.gp[base] = 0xff
+							}
+						case "index":
+							current.gp[index] = 0
+						case "pointer data":
+							current.gp[value], current.pointerGP[value] = 0, true
+						case "raw":
+							changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+						case "encoded":
+							changed.x86Encoded = true
+						case "address size":
+							changed.x86AddressBits = 16
+						case "address override":
+							changed.x86UnboundAddressOverride = true
+						case "segment prefix":
+							changed.x86SegmentPrefix = 0x64
+						}
+						initial := current.clone()
+						if accepted, known := x86LoweredMOVNTIResultStep(changed, &current, nil, arch); !known || accepted || !reflect.DeepEqual(current, initial) {
+							t.Fatal("MOVNTI borrowed unrelated source or memory authority", fmt.Sprint(change))
+						}
+					})
+				}
+				if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) {
+					t.Fatal("standalone result query borrowed the paired native store")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_mxcsr_conversion_objects_test.go b/x86_result_mxcsr_conversion_objects_test.go
new file mode 100644
index 000000000..8d8c53194
--- /dev/null
+++ b/x86_result_mxcsr_conversion_objects_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+func x86MXCSRConversionCompleteObjectFixture(t *testing.T, arch string) (string, string, int) {
+	t.Helper()
+	var declarations, source strings.Builder
+	count := 0
+	if arch == "amd64" {
+		// Retain the CI counterexample's complete eight original functions.
+		goSource, asmSource, _ := x86SignedIntegerFloatFPFixture(t)
+		declarations.WriteString(goSource)
+		source.WriteString(asmSource)
+		count = 8
+	} else {
+		declarations.WriteString("package oracle\n")
+		for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+			name := strings.ToLower(op)
+			declaration := fmt.Sprintf("func %s(a,b,c,d,e,f,g,h byte,csr uint32)(value uint64,flags uint32)\n", name)
+			declarations.WriteString(declaration)
+			pkg := mustGoPackage(t, "oracle", "package oracle\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+			if err != nil || len(sig.Frame.Params) != 9 || len(sig.Frame.Results) != 2 {
+				t.Fatal("complete actual mode32 conversion declaration changed", err)
+			}
+			value, flags := sig.Frame.Results[0].Offset, sig.Frame.Results[1].Offset
+			args, destination := "a+0(FP),X0", "X0"
+			if strings.HasPrefix(op, "V") {
+				args, destination = "a+0(FP),X0,X1", "X1"
+			}
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$8-%d\nSTMXCSR saved-4(SP)\nLDMXCSR csr+8(FP)\n%s %s\n", name, flags+4, op, args)
+			if strings.Contains(op, "SS") {
+				fmt.Fprintf(&source, "MOVL %s,AX\nMOVL AX,value+%d(FP)\nMOVL $0,value+%d(FP)\n", destination, value, value+4)
+			} else {
+				fmt.Fprintf(&source, "MOVQ %s,value+%d(FP)\n", destination, value)
+			}
+			fmt.Fprintf(&source, "STMXCSR flags+%d(FP)\nLDMXCSR saved-4(SP)\nRET\n", flags)
+			count++
+		}
+	}
+	for _, load := range []string{"LDMXCSR", "VLDMXCSR"} {
+		for _, store := range []string{"STMXCSR", "VSTMXCSR"} {
+			name := strings.ToLower(load + store)
+			declaration := fmt.Sprintf("func %s(input uint32) uint32\n", name)
+			declarations.WriteString(declaration)
+			pkg := mustGoPackage(t, "oracle", "package oracle\n"+declaration)
+			sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), arch, types.SizesFor("gc", arch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			result := sig.Frame.Results[0].Offset
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$8-%d\n%s saved-4(SP)\n%s input+0(FP)\n%s ret+%d(FP)\n%s saved-4(SP)\nRET\n", name, result+4, store, load, store, result, load)
+			count++
+		}
+	}
+	return declarations.String(), source.String(), count
+}
+
+func TestX86MXCSRConversionCompleteFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete MXCSR/conversion objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			declarations, source, count := x86MXCSRConversionCompleteObjectFixture(t, target.arch)
+			wantCount := 12
+			if target.arch == "386" {
+				wantCount = 10
+			}
+			if strings.Count(source, "TEXT ·") != count || count != wantCount {
+				t.Fatal("complete mode-selected conversion/MXCSR source inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			pkg := mustGoPackage(t, "oracle", declarations)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != count {
+						t.Fatal("complete original conversion/AUTO source failed", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_mxcsr_conversion_test.go b/x86_result_mxcsr_conversion_test.go
new file mode 100644
index 000000000..0e900a218
--- /dev/null
+++ b/x86_result_mxcsr_conversion_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86MXCSRFullMemoryWidthAndOperandGrammar(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" value+0(FP)")
+				width, write, known := X86FPAccessBytes(ins, 0, arch)
+				if !known || width != 4 || write != strings.Contains(op, "STMXCSR") {
+					t.Fatal("complete MXCSR row lost its exact m32 read/write role", width, write, known)
+				}
+				for _, row := range []string{op + ".Z value+0(FP)", op + " value+0(FP),X0", op + " X0", op + " $7"} {
+					bad := x86ScalarLaneInstruction(t, row)
+					if width, _, known := X86FPAccessBytes(bad, 0, arch); known || width != 0 {
+						t.Fatal("invalid MXCSR source acquired a memory width", row, width)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SignedIntegerFloatResultPreservesSparseMergeBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+			if arch == "386" && strings.HasPrefix(op, "CVTSQ") {
+				continue
+			}
+			registerRows := []string{"AX,X0", "AX,X1"}
+			if strings.HasPrefix(op, "V") {
+				registerRows = []string{"AX,X0,X1", "AX,X1,X1", "CX,X7,X6"}
+				if arch == "amd64" {
+					registerRows = append(registerRows, "R15,X31,X30", "R15,X31,X31")
+				}
+			} else if arch == "amd64" {
+				registerRows = append(registerRows, "R15,X15")
+			} else {
+				registerRows = append(registerRows, "CX,X7")
+			}
+			for _, registers := range registerRows {
+				t.Run(arch+"/"+op+"/"+registers, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+" "+registers)
+					form, known, err := x86SignedIntegerFloatProperties(ins, arch)
+					if !known || err != nil {
+						t.Fatal(err)
+					}
+					for missing := -1; missing < form.sourceBits/8; missing++ {
+						state := x86ResultState{flags: x86ByteFlagCF, direction: x86ResultDirectionBackward}
+						source, _, _ := x86ResultGP(ins.Args[0].Reg, int64(form.sourceBits/8), arch)
+						state.gp[source] = 0xff
+						state.xmm[0], state.xmm[1] = 0xa531, 0x71c2
+						state.vectorUpper[1] = 0x123456780000
+						state.callerAddressGP[7], state.callerAddressOrigin[7] = true, 1
+						if missing >= 0 {
+							state.gp[source] &^= 1 << uint(missing)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != (missing < 0) {
+							t.Fatal("signed conversion ignored an input byte or required unwritten merge bytes", missing, accepted)
+						}
+						if !accepted {
+							if !reflect.DeepEqual(before, state) {
+								t.Fatal("rejected signed input mutated numerical state")
+							}
+							continue
+						}
+						upper, _ := amd64ParseXReg(ins.Args[form.upper].Reg)
+						destination, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+						low := x86CallerVectorByteMask(int64(form.spec.resultBits / 8))
+						want := low | before.vectorBytes(upper)&(0xffff&^low)
+						if form.spec.legacy {
+							want |= before.vectorUpper[destination]
+						} else {
+							want |= ^uint64(0xffff)
+						}
+						if state.vectorBytes(destination) != want || state.gp != before.gp || state.pointerGP != before.pointerGP ||
+							state.flags != before.flags || state.direction != before.direction {
+							t.Fatal("legacy/VEX merge, alias or nonvector state footprint changed", state.vectorBytes(destination), want)
+						}
+						if after := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, arch); after != before.callerAddressGP {
+							t.Fatal("signed conversion invented a GP overwrite")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SignedIntegerFloatUnknownUpperResultThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CVTSL2SS", "VCVTSI2SSL", "VCVTSI2SSQ"} {
+			for _, known := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/upperKnown=%t", arch, op, known), func(t *testing.T) {
+					declaration := "func view(input int32) uint64\n"
+					args, destination := "AX,X0", "X0"
+					if strings.HasPrefix(op, "V") {
+						args, destination = "AX,X0,X1", "X1"
+					}
+					body := "MOVL input+0(FP),AX\n"
+					if known {
+						body += "PXOR X0,X0\n"
+					}
+					body += op + " " + args + "\nMOVQ " + destination + ",ret+RESULT(FP)"
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					if arch == "amd64" && !known {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, "x86_64-unknown-linux-gnu", api)
+								x86VectorScratchCodegenControl(t, source, declaration, arch, "x86_64-unknown-linux-gnu", ir, err)
+							})
+						}
+					} else {
+						x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, known)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SignedIntegerFloatPlainMXCSRReturnRequiresWholeSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+			if arch == "386" && strings.HasPrefix(op, "CVTSQ") {
+				continue
+			}
+			for _, known := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/inputKnown=%t", arch, op, known), func(t *testing.T) {
+					args := "AX,X0"
+					if strings.HasPrefix(op, "V") {
+						args += ",X1"
+					}
+					body := ""
+					if known {
+						move := "MOVL"
+						if arch == "amd64" && strings.Contains(op, "Q") {
+							move = "MOVQ"
+						}
+						body = move + " $7,AX\n"
+					}
+					// Conversion's observable MXCSR result has no extra GP/X move
+					// that could accidentally activate the cached source proof.
+					body += op + " " + args + "\nSTMXCSR ret+RESULT(FP)"
+					declaration := "func view() uint32\n"
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, known)
+				})
+			}
+		}
+	}
+}
+
+func TestX86MXCSRPlainAUTOReturnNeedsReachingBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, load := range []string{"LDMXCSR", "VLDMXCSR"} {
+			for _, store := range []string{"STMXCSR", "VSTMXCSR"} {
+				for _, known := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%s/known=%t", arch, load, store, known), func(t *testing.T) {
+						body := ""
+						if known {
+							body = "MOVL $0x1f80,saved-4(SP)\n"
+						}
+						body += load + " saved-4(SP)\n" + store + " ret+RESULT(FP)"
+						declaration := "func view() uint32\n"
+						source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+						source = strings.Replace(source, ",$0-", ",$8-", 1)
+						x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, known)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86SignedIntegerFloatPairedNativeReadRetainsExactDeadWidth(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"CVTSL2SS", "CVTSL2SD", "CVTSQ2SS", "CVTSQ2SD", "VCVTSI2SSL", "VCVTSI2SDL", "VCVTSI2SSQ", "VCVTSI2SDQ"} {
+			if arch == "386" && strings.HasPrefix(op, "CVTSQ") {
+				continue
+			}
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				args := "1(DI),X0"
+				if strings.HasPrefix(op, "V") {
+					args += ",X1"
+				}
+				declaration := "func view(p *byte) uint32\n"
+				// Even dead scalar outputs retain source faults and MXCSR effects.
+				body := move + " p+0(FP),DI\n" + op + " " + args + "\nMOVL $7,AX\nMOVL AX,ret+RESULT(FP)"
+				source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+				form, _, _ := x86SignedIntegerFloatProperties(x86ScalarLaneInstruction(t, op+" "+args), arch)
+				pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sigs["view"], arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone result query borrowed the paired read's memory bytes", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, arch, triple, api)
+						load := fmt.Sprintf("load volatile i%d", form.sourceBits)
+						if err != nil || strings.Count(ir, load) != 1 || strings.Contains(ir, "dereferenceable") {
+							t.Fatal("complete paired signed source read lost its native width", err)
+						}
+						if optimized := x86UndefinedTrapOptimizedIR(t, ir); strings.Count(optimized, load) != 1 {
+							t.Fatal("O2 erased a dead signed source read and its possible fault")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86MXCSRAUTOExtentKeepsCompleteSourceAndBounds(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"LDMXCSR", "VLDMXCSR", "STMXCSR", "VSTMXCSR"} {
+			for _, offset := range []int{-12, -8, -4, -3, 0} {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, op, offset), func(t *testing.T) {
+					source := fmt.Sprintf("TEXT value(SB),4,$8-0\n%s saved%+d(SP)\nRET\n", op, offset)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					extent, err := x86ResultAUTOExtent(file.Funcs[0], arch)
+					if offset == -8 || offset == -4 {
+						if err != nil || extent != 8 {
+							t.Fatal("actual bounded MXCSR AUTO width remains unknown", extent, err)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || extent != 0 {
+						t.Fatal("MXCSR native extent crossed the original AUTO frame", extent, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SignedIntegerFloatOriginalFPFixtureWholeThreeAPIs(t *testing.T) {
+	declarations, source, _ := x86SignedIntegerFloatFPFixture(t)
+	pkg := mustGoPackage(t, "oracle", declarations)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 8 {
+		t.Fatal("complete original signed-conversion fixture changed", err)
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || strings.Count(ir, "define ") != 8 {
+				t.Fatal("unchanged complete original FP/MXCSR fixture rejected", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_named_half.go b/x86_result_named_half.go
new file mode 100644
index 000000000..00453cc4d
--- /dev/null
+++ b/x86_result_named_half.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+// Physical generation, grammar and mode are distinct observations. Absence
+// cannot assert F16C/VEX, and ordinary named conversions are not raw FP16.
+type x86RawNamedHalfIdentity struct {
+	arch     string
+	encoding x86RawNamedHalfEncoding
+	encoded  bool
+}
+
+func x86NamedHalfRawIdentity(ins Instr, arch string) x86RawNamedHalfIdentity {
+	_, known, err := x86NamedHalfProperties(ins.Op, ins, arch)
+	if !known || err != nil || ins.x86Encoded ||
+		ins.x86NamedHalfEncoding != x86RawNamedHalfVEX && ins.x86NamedHalfEncoding != x86RawNamedHalfEVEX {
+		return x86RawNamedHalfIdentity{}
+	}
+	return x86RawNamedHalfIdentity{arch, ins.x86NamedHalfEncoding, ins.x86Encoded}
+}
+
+func x86RawNamedHalfSource(ins Instr, arch string) bool {
+	f, known, err := x86NamedHalfProperties(ins.Op, ins, arch)
+	identity := x86NamedHalfRawIdentity(ins, arch)
+	if !known || err != nil || identity.encoding == x86RawNamedHalfAbsent || ins.x86SourceRaw == nil ||
+		ins.x86SourceRaw.namedHalf != identity || !x86RawOrdinaryVectorSourceAt(ins, arch, f.source) {
+		return false
+	}
+	return f.memory != f.destination || x86RawOrdinaryVectorSourceAt(ins, arch, f.destination)
+}
+
+func x86NamedHalfRawReplayRequired(fn Func, arch string) bool {
+	hasProducer := func(instructions []Instr) bool {
+		for _, ins := range instructions {
+			if _, known, _ := x86NamedHalfProperties(ins.Op, ins, arch); known &&
+				(ins.x86SourceRaw != nil || ins.x86NamedHalfEncoding != x86RawNamedHalfAbsent) {
+				return true
+			}
+		}
+		return false
+	}
+	return hasProducer(fn.Instrs) || fn.x86RawReplay != nil && hasProducer(fn.x86RawReplay.decoded)
+}
+
+// Only this family selects the shared input/carrier axes. A paired native
+// write changes no logical pointee, later read, frame, caller or entry fact.
+func x86ResultNamedHalfStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86NamedHalfProperties(ins.Op, ins, arch)
+	if !known || err != nil || f.undefinedOpcode() {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawNamedHalfSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	local := ins
+	local.Args = ins.Args[f.source:]
+	if f.memory != f.destination {
+		return x86ResultPackedConversionInputs(local, f.conversion, state, owned, arch, native), true
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	index, _ := amd64VectorRegisterIndex(ins.Args[f.source].Reg, f.sourceBytes)
+	input := x86CallerVectorByteMask(int64(f.inputBytes))
+	if state.vectorBytes(index)&input != input {
+		return false, true
+	}
+	destination := ins.Args[f.destination]
+	return native && x86OrdinaryNativeMemoryOperand(destination, arch) &&
+		x86ResultIncomingPointerAddressIdentity(destination, state, arch), true
+}
diff --git a/x86_result_native_bittest.go b/x86_result_native_bittest.go
new file mode 100644
index 000000000..8f75c2ae1
--- /dev/null
+++ b/x86_result_native_bittest.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+// Conditional continuation of the complete native BIT emitter. The exact
+// volatile word read/write and signed dynamic bit-string addressing remain
+// observable. This supplies CF, not reusable memory or address authority.
+func x86LoweredNativeBitTest(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86BitTestProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.destination.Kind != OpMem {
+		return false, false
+	}
+	if !x86ResultNamedPredicateInstruction(ins) ||
+		!x86ResultNativeRMWAddress(ins, form.destination, state, owned, arch) ||
+		!x86ResultRead(form.index, int64(form.bits/8), state, owned, arch) {
+		return false, true
+	}
+	effect, _, _ := x86TypedBitTestByteEffect(ins.Op, ins, arch)
+	state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+	return true, true // No GP, vector, DF or logical storage changes.
+}
+
+// Only the paired scalar/bit-string emitter consumes this address. FS/GS
+// contributes its actual hardware base, never an AS0 pointer or storage fact.
+// A named GP offset still needs full numerical bytes; ordinary RMW addresses
+// keep their stricter incoming-pointer-base rule and cannot commute operands.
+func x86ResultNativeRMWAddress(ins Instr, address Operand, state *x86ResultState, owned []bool, arch string) bool {
+	if accepted, segment := x86ResultNativeSegmentAddress(ins, address, state, owned, arch); segment {
+		return accepted
+	}
+	return x86ResultIncomingPointerAddressIdentity(address, state, arch)
+}
+
+// Named hardware segments supply an actual base independently of numerical
+// GP address roles. Only an explicit offset consumes NUM; no storage follows.
+func x86ResultNativeSegmentAddress(ins Instr, address Operand, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	projected, segment, err := x86NamedSegmentMemorySource(ins, address, arch)
+	if !segment {
+		return false, false
+	}
+	if err != nil || !x86OrdinaryNativeMemoryOperand(projected, arch) {
+		return false, true
+	}
+	base := projected.Mem.Base
+	if base == "" {
+		return true, true
+	}
+	word := x86ResultPointerWord(arch)
+	index, _, valid := x86ResultGP(base, word, arch)
+	return valid && (state.shapeOnly || !state.pointerGP[index]) &&
+		x86ResultRead(Operand{Kind: OpReg, Reg: base}, word, state, owned, arch), true
+}
diff --git a/x86_result_native_lea_bits.go b/x86_result_native_lea_bits.go
new file mode 100644
index 000000000..756795354
--- /dev/null
+++ b/x86_result_native_lea_bits.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+// A single adjacent native store may observe these address-derived bytes.
+// They are not numerical inputs, canonical bools, pointers or backing facts.
+// Every other successful effect revokes this short-lived observation.
+type x86NativeLEAAddressBits struct {
+	register uint8
+	bytes    uint8
+}
+
+func x86ResultNativeLEAAddressBitsStep(ins Instr, state *x86ResultState, owned []bool,
+	arch string, leaf bool) (bool, bool) {
+	effect, known, err := x86TypedLEAByteEffect(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, false // Existing physical, stack and malformed-source consumers remain separate.
+	}
+	output := effect.operands[len(effect.operands)-1]
+	if output.width >= x86ResultPointerWord(arch) {
+		return false, false // Preserve the existing full-word incoming-pointer continuation.
+	}
+	address := false
+	for _, operand := range effect.operands {
+		if !operand.read {
+			continue
+		}
+		register, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch)
+		if valid && state.callerAddressGP[register] {
+			address = true
+		} else if !x86ResultRead(operand.operand, operand.width, state, owned, arch) {
+			return false, true
+		}
+	}
+	if !address {
+		return false, false // Do not intercept the complete existing pure-numerical LEA rule.
+	}
+	if !leaf || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	register, mask, valid := x86ResultGP(output.operand.Reg, output.width, arch)
+	if !valid {
+		return false, true
+	}
+	observed := mask
+	if output.width == 2 && state.callerAddressGP[register] {
+		// LEAW leaves the old destination's high bytes unchanged. An
+		// actual caller-address identity already supplies their observable
+		// representation, not NUM or a new pointer. Retain those bytes only
+		// in this same adjacent-store carrier; LEAL instead zeroes upper32.
+		observed = x86CallerByteMask(output.operand.Reg, x86ResultPointerWord(arch))
+	}
+	state.gp[register] &^= mask
+	state.canonicalGP[register] &^= mask
+	state.pointerGP[register] = false
+	if output.width == 4 {
+		// The architectural upper32 zero is numerical; the low address
+		// bytes remain in the disjoint one-store observation domain.
+		state.gp[register] = 0xf0
+		state.canonicalGP[register] |= 0xf0
+	}
+	state.nativeLEAAddressBits = x86NativeLEAAddressBits{uint8(register), observed}
+	return true, true
+}
diff --git a/x86_result_native_numeric_address.go b/x86_result_native_numeric_address.go
new file mode 100644
index 000000000..97c594bfd
--- /dev/null
+++ b/x86_result_native_numeric_address.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+// Only an already selected native emitter may consume these numerical address
+// bits. A successful volatile access initializes its result, not its pointee,
+// and creates no logical pointer, extent, caller or reusable storage fact.
+func x86ResultNativeNumericAddress(arg Operand, state *x86ResultState, arch string) bool {
+	if arg.Kind != OpMem || arg.Mem.Sym != "" || arg.Mem.OffRaw != "" ||
+		arg.Mem.Segment != "" || arg.Mem.IndexExt != "" ||
+		!x86OrdinaryNativeMemoryOperand(arg, arch) {
+		return false
+	}
+	word := x86ResultPointerWord(arch)
+	base, mask, valid := x86ResultGP(arg.Mem.Base, word, arch)
+	if !valid || state.gp[base]&mask != mask {
+		return false
+	}
+	if arg.Mem.Index == "" {
+		return true
+	}
+	index, mask, valid := x86ResultGP(arg.Mem.Index, word, arch)
+	return valid && state.gp[index]&mask == mask
+}
diff --git a/x86_result_native_pointer.go b/x86_result_native_pointer.go
new file mode 100644
index 000000000..564ce720e
--- /dev/null
+++ b/x86_result_native_pointer.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+// This domain observes only opaque incoming pointer identities. Copying or
+// computing an address does not initialize any numerical bytes or its pointee:
+// all native reads remain unproved without an independent caller-memory fact.
+// It grants no bounds, noalias, escape, lifetime, frame or translator permission.
+
+func x86ResultPointerWord(arch string) int64 {
+	if arch == "386" {
+		return 4
+	}
+	return 8
+}
+
+// Select an existing whole-word role, never numerical address bits or memory
+// contents. The caller supplies its own independent pointer/provenance domain.
+func x86ResultPointerOperand(arg Operand, gp [16]bool, fp map[int64]bool, arch string) bool {
+	if arg.Kind == OpFP {
+		return fp[arg.FPOffset]
+	}
+	index, _, valid := x86ResultGP(arg.Reg, x86ResultPointerWord(arch), arch)
+	return arg.Kind == OpReg && valid && gp[index]
+}
+
+func x86ResultIncomingPointerAddressIdentity(arg Operand, state *x86ResultState, arch string) bool {
+	return x86ResultIncomingPointerAddress(arg, state, arch, false)
+}
+
+// Only an existing paired native read may commute a numerical base with an
+// unscaled pointer index. Stores, RMW, caller certificates and LEA keep the
+// original base-pointer entry above; this grants no reusable address fact.
+func x86ResultIncomingPointerReadAddressIdentity(arg Operand, state *x86ResultState, arch string) bool {
+	return x86ResultIncomingPointerAddress(arg, state, arch, true)
+}
+
+func x86ResultIncomingPointerAddress(arg Operand, state *x86ResultState, arch string, commutedRead bool) bool {
+	if arg.Kind != OpMem {
+		return false
+	}
+	memory := arg.Mem
+	if memory.Sym != "" || memory.OffRaw != "" || memory.Segment != "" || memory.IndexExt != "" ||
+		memory.Off < -1<<31 || memory.Off > 1<<31-1 {
+		return false
+	}
+	word := x86ResultPointerWord(arch)
+	base, baseMask, valid := x86ResultGP(memory.Base, word, arch)
+	if !valid {
+		return false
+	}
+	if memory.Index == "" {
+		return memory.Scale == 0 && (state.shapeOnly || state.pointerGP[base])
+	}
+	if memory.Scale != 1 && memory.Scale != 2 && memory.Scale != 4 && memory.Scale != 8 {
+		return false
+	}
+	index, mask, valid := x86ResultGP(memory.Index, word, arch)
+	if !valid {
+		return false
+	}
+	if (state.shapeOnly || state.pointerGP[base]) && state.gp[index]&mask == mask {
+		return true // Preserve the existing pointer-base/numerical-index role.
+	}
+	return commutedRead && !state.shapeOnly && memory.Scale == 1 &&
+		!state.pointerGP[base] && state.gp[base]&baseMask == baseMask && state.pointerGP[index]
+}
+
+func x86ResultIncomingPointerTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	word := x86ResultPointerWord(arch)
+	move, lea, add, sub := Op("MOVQ"), Op("LEAQ"), Op("ADDQ"), Op("SUBQ")
+	if arch == "386" {
+		move, lea, add, sub = "MOVL", "LEAL", "ADDL", "SUBL"
+	}
+	if len(ins.Args) != 2 {
+		return false, false
+	}
+	first, last := ins.Args[0], ins.Args[1]
+	writePointer := func() bool {
+		if last.Kind != OpReg {
+			return false
+		}
+		index, _, valid := x86ResultGP(last.Reg, word, arch)
+		if valid {
+			state.pointerGP[index], state.gp[index] = true, 0
+			state.canonicalGP[index] = 0
+		}
+		return valid
+	}
+	if ins.Op == move {
+		if first.Kind == OpFP && state.pointerFP[first.FPOffset] {
+			return writePointer(), true
+		}
+		// The source-wide top state represents numerical and pointer inputs
+		// together; a reaching state never carries that union as authority.
+		if first.Kind == OpReg && !state.shapeOnly {
+			index, _, valid := x86ResultGP(first.Reg, word, arch)
+			if valid && state.pointerGP[index] {
+				return writePointer(), true
+			}
+		}
+	}
+	if ins.Op == lea && first.Kind == OpMem {
+		base, _, valid := x86ResultGP(first.Mem.Base, word, arch)
+		if valid && (state.shapeOnly || state.pointerGP[base]) {
+			address := x86ResultIncomingPointerAddressIdentity(first, state, arch)
+			if state.shapeOnly && !address {
+				// The source-wide top also represents numerical inputs. A
+				// legal NUM-only LEA can have a displacement outside this
+				// pointer role (386 uint32, for example). Defer to its typed
+				// grammar; reaching pointer identities keep the strict rule.
+				return false, false
+			}
+			return address && writePointer(), true
+		}
+		// No typed pointer base: let the independent numerical LEA effect
+		// prove every actual register input instead of treating it as a pointer.
+		return false, false
+	}
+	if (ins.Op == add || ins.Op == sub) && last.Kind == OpReg {
+		index, _, valid := x86ResultGP(last.Reg, word, arch)
+		if !valid {
+			return false, false
+		}
+		commuted := !state.pointerGP[index] && ins.Op == add &&
+			x86ResultPointerOperand(first, state.pointerGP, state.pointerFP, arch)
+		// The shape pass must recognize a declared pointer FP source too.
+		// Its top state supplies no reaching identity or numerical permission.
+		if !commuted && (!state.pointerGP[index] || state.shapeOnly) {
+			return false, false
+		}
+		number := first
+		if commuted {
+			if !x86ResultNamedPredicateInstruction(ins) {
+				return false, true
+			}
+			number = last // ADD alone may exchange its pointer and NUM inputs.
+		}
+		effect, recognized, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+		if !recognized || err != nil || effect.dynamicMemory ||
+			!x86ResultRead(number, word, state, owned, arch) {
+			return false, true
+		}
+		if commuted {
+			writePointer() // Revoke the old NUM/canonical result, not the source role.
+		}
+		state.flags = state.flags&^effect.flagsKilled | effect.flagsDefined
+		return true, true
+	}
+	return false, false
+}
diff --git a/x86_result_native_pointer_alias_test.go b/x86_result_native_pointer_alias_test.go
new file mode 100644
index 000000000..15e6b0a49
--- /dev/null
+++ b/x86_result_native_pointer_alias_test.go
@@ -0,0 +1,355 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+	"golang.org/x/arch/x86/x86asm"
+)
+
+type x86ResultAliasObject struct {
+	source, listing string
+	symbolPrefix    string
+	code            map[string][]byte
+}
+
+// This observes complete stock-Go objects only. Neither function is executed:
+// the caller deliberately supplies a pointer to storage it has not initialized.
+func x86ResultAliasGoObject(t *testing.T, arch, triple, source string) x86ResultAliasObject {
+	t.Helper()
+	goos := "linux"
+	if strings.Contains(triple, "apple") {
+		goos = "darwin"
+	} else if strings.Contains(triple, "windows") {
+		goos = "windows"
+	}
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "alias.s"), filepath.Join(dir, "alias.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-S", "-p", "pointeralias", "-o", object, input)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH="+arch, "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil {
+		t.Fatalf("original pointer-alias Go object: %v\n%s", err, output)
+	}
+	receipt := x86LEAReadObjectReceipt(t, arch, goos, source, input, driver, driverHash, object)
+	data, err := os.ReadFile(object)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("ORIGINAL_POINTER_ALIAS_OBJECT: receipt=%+v source=%q listing=%q object=%x", receipt, source, output, data)
+	result := x86ResultAliasObject{source: source, listing: string(output), code: make(map[string][]byte)}
+	name, size := "", 0
+	finish := func() {
+		if name != "" && len(result.code[name]) != size {
+			t.Fatalf("complete original %s size=%d bytes=%d", name, size, len(result.code[name]))
+		}
+	}
+	for _, line := range strings.Split(result.listing, "\n") {
+		fields := strings.Fields(line)
+		if len(fields) > 1 && fields[1] == "SSEHUNWINDINFO" {
+			finish()
+			if goos != "windows" || arch != "amd64" || !strings.HasPrefix(fields[0], "go:sehuw.") {
+				t.Fatal("unexpected original auxiliary data", line)
+			}
+			// Stock Windows unwind bytes are retained in the complete object
+			// and raw listing, never mistaken for either function's code.
+			name, size = "", 0
+			continue
+		}
+		if len(fields) > 1 && fields[1] == "STEXT" {
+			finish()
+			name = strings.TrimPrefix(fields[0], "pointeralias.")
+			if name == fields[0] {
+				// The old SDK's lex.Make rewrites local · to the literal
+				// "" placeholder. The current parser substitutes ctxt.Pkgpath.
+				name = strings.TrimPrefix(fields[0], `"".`)
+			}
+			if name != "Caller" && name != "Value" {
+				t.Fatalf("unexpected original TEXT: %s", line)
+			}
+			prefix := strings.TrimSuffix(fields[0], name)
+			if result.symbolPrefix != "" && result.symbolPrefix != prefix {
+				t.Fatal("original Caller and Value have different local namespaces")
+			}
+			result.symbolPrefix = prefix
+			if _, duplicate := result.code[name]; duplicate {
+				t.Fatal("duplicate original TEXT", name)
+			}
+			result.code[name] = nil
+			size = -1
+			for _, field := range fields[2:] {
+				if strings.HasPrefix(field, "size=") {
+					size, err = strconv.Atoi(strings.TrimPrefix(field, "size="))
+					if err != nil || size <= 0 {
+						t.Fatal("invalid original TEXT size", line)
+					}
+				}
+			}
+			continue
+		}
+		if name == "" || len(fields) < 2 || !strings.HasPrefix(fields[0], "0x") || len(fields[1]) != 2 {
+			continue
+		}
+		offset, err := strconv.ParseInt(fields[0][2:], 16, 32)
+		if err != nil || offset != int64(len(result.code[name])) {
+			t.Fatal("noncontiguous original code bytes", line)
+		}
+		// obj.printSym emits exactly sixteen hex columns per line, except
+		// the final partial line; its ASCII suffix can itself be two letters.
+		count := size - len(result.code[name])
+		if count > 16 {
+			count = 16
+		}
+		if count <= 0 || len(fields) < count+1 {
+			t.Fatal("original byte row exceeds or truncates declared TEXT", line)
+		}
+		for _, field := range fields[1 : count+1] {
+			if len(field) != 2 {
+				t.Fatal("invalid original byte column", line)
+			}
+			value, err := strconv.ParseUint(field, 16, 8)
+			if err != nil {
+				t.Fatal("invalid original byte", line)
+			}
+			result.code[name] = append(result.code[name], byte(value))
+		}
+	}
+	finish()
+	if len(result.code) != 2 {
+		t.Fatal("original object must contain both actual ABI0 functions")
+	}
+	return result
+}
+
+func x86ResultAliasDecode(t *testing.T, code []byte, arch string) []x86asm.Inst {
+	t.Helper()
+	mode := 64
+	if arch == "386" {
+		mode = 32
+	}
+	var decoded []x86asm.Inst
+	for offset := 0; offset < len(code); {
+		instruction, err := x86asm.Decode(code[offset:], mode)
+		if err != nil || instruction.Len <= 0 || instruction.Op == 0 {
+			t.Fatalf("original instruction at %d: %+v %v", offset, instruction, err)
+		}
+		decoded = append(decoded, instruction)
+		offset += instruction.Len
+	}
+	return decoded
+}
+
+// Derive the entry-relative cell from this SDK's real prologue and native
+// memory operand. PUSH-BP and spill-BP producers are distinct observations.
+func x86ResultAliasEntryCell(t *testing.T, object x86ResultAliasObject, arch, kind string) int64 {
+	t.Helper()
+	sp, bp, ax, word := x86asm.RSP, x86asm.RBP, x86asm.RAX, int64(8)
+	if arch == "386" {
+		sp, bp, ax, word = x86asm.ESP, x86asm.EBP, x86asm.EAX, 4
+	}
+	delta, pointerSeen, cellSeen := int64(0), false, false
+	var prologueWrites []int64
+	cell := int64(0)
+	for _, ins := range x86ResultAliasDecode(t, object.code["Value"], arch) {
+		if !pointerSeen {
+			if memory, ok := ins.Args[1].(x86asm.Mem); ins.Op == x86asm.MOV && ins.Args[0] == ax && ok && memory.Base == sp {
+				if delta+memory.Disp != word || memory.Index != 0 {
+					t.Fatalf("original incoming ABI0 slot disagrees with declaration: delta=%d %+v", delta, ins)
+				}
+				pointerSeen = true
+				continue
+			}
+			switch ins.Op {
+			case x86asm.PUSH:
+				if ins.Args[0] != bp {
+					t.Fatal("unknown original prologue PUSH", ins)
+				}
+				delta -= word
+				prologueWrites = append(prologueWrites, delta)
+			case x86asm.SUB:
+				immediate, ok := ins.Args[1].(x86asm.Imm)
+				if ins.Args[0] != sp || !ok || immediate <= 0 || immediate > 4096 {
+					t.Fatal("unknown original prologue SUB", ins)
+				}
+				delta -= int64(immediate)
+			case x86asm.MOV, x86asm.LEA:
+				memory, memoryDestination := ins.Args[0].(x86asm.Mem)
+				if ins.Args[0] != bp && !(ins.Op == x86asm.MOV && memoryDestination && memory.Base == sp && ins.Args[1] == bp) {
+					t.Fatal("unknown original BP producer", ins)
+				}
+				if memoryDestination {
+					prologueWrites = append(prologueWrites, delta+memory.Disp)
+				}
+			default:
+				t.Fatal("unknown original prologue", ins)
+			}
+			continue
+		}
+		memory, memorySource := ins.Args[1].(x86asm.Mem)
+		if kind == "AUTO" && ins.Op == x86asm.MOV && ins.Args[0] == x86asm.ECX && memorySource && memory.Base == sp {
+			cell, cellSeen = delta+memory.Disp, true
+			break // Before this dead layout observer, no original SP effect exists.
+		}
+		memory, memoryDestination := ins.Args[0].(x86asm.Mem)
+		if kind == "result" && ins.Op == x86asm.MOV && memoryDestination && memory.Base == sp && ins.Args[1] == x86asm.EBX {
+			cell, cellSeen = delta+memory.Disp, true
+			break // Frame-zero result source has no intervening SP effect.
+		}
+	}
+	if !pointerSeen || !cellSeen {
+		t.Fatalf("missing original %s ABI0 address observation", kind)
+	}
+	for _, offset := range prologueWrites {
+		if cell < offset+word && offset < cell+4 {
+			t.Fatal("native alias cell was initialized by an automatic BP save", cell, offset)
+		}
+	}
+	return cell
+}
+
+func x86ResultNativeAliasFixture(t *testing.T, arch, triple, kind string) (GoPackage, *File, FuncSig, string) {
+	t.Helper()
+	word, move, lea, frame := int64(8), "MOVQ", "LEAQ", int64(0)
+	if arch == "386" {
+		word, move, lea = 4, "MOVL", "LEAL"
+	}
+	declarations := "package pointeralias\nfunc Caller() uint32\nfunc Value(x *uint32) uint32\n"
+	pkg := mustGoPackage(t, "pointeralias", declarations)
+	sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil || sig.Frame.Results[0].Offset != word {
+		t.Fatalf("actual typed ABI0 declaration: %+v %v", sig, err)
+	}
+	body := move + " x+0(FP),AX\n"
+	if kind == "AUTO" {
+		frame = 16
+		// Dead source binds the actual named AUTO displacement in the very same
+		// object. It does not initialize the local or execute on the read path.
+		body += "JMP read\nlocalLayout:\nMOVL cell-8(SP),CX\nRET\nread:\n"
+	}
+	body += fmt.Sprintf("MOVL (AX),BX\nMOVL BX,ret0+%d(FP)\nRET\n", word)
+	value := fmt.Sprintf("TEXT ·Value(SB),4,$%d-%d\n%s", frame, word+4, body)
+	caller := func(offset int64) string {
+		return fmt.Sprintf("TEXT ·Caller(SB),4,$16-4\n%s %d(SP),AX\n%s AX,0(SP)\nCALL ·Value(SB)\nMOVL %d(SP),AX\nMOVL AX,ret0+0(FP)\nRET\n", lea, offset, move, word)
+	}
+	probe := x86ResultAliasGoObject(t, arch, triple, caller(0)+value)
+	cell := x86ResultAliasEntryCell(t, probe, arch, kind)
+	if kind == "result" && cell != word+sig.Frame.Results[0].Offset {
+		t.Fatal("original result displacement differs from actual typed slot", cell)
+	}
+	if kind == "AUTO" && (cell >= 0 || cell < -4096) {
+		t.Fatal("original local is not inside a bounded callee-private frame", cell)
+	}
+	// CALL pushes one native return word. The relative address comes from
+	// actual code, not from TEXT autosize or a presumed SDK prologue.
+	aliasOffset := cell - word
+	source := caller(aliasOffset) + value
+	actual := x86ResultAliasGoObject(t, arch, triple, source)
+	if !bytes.Equal(probe.code["Value"], actual.code["Value"]) || x86ResultAliasEntryCell(t, actual, arch, kind) != cell {
+		t.Fatal("rebuilt complete object changed the original callee layout")
+	}
+	leaSeen, pointerStored, callSeen := false, false, false
+	for _, instruction := range x86ResultAliasDecode(t, actual.code["Caller"], arch) {
+		if memory, ok := instruction.Args[1].(x86asm.Mem); instruction.Op == x86asm.LEA && ok &&
+			(memory.Base == x86asm.RSP || memory.Base == x86asm.ESP) && (instruction.Args[0] == x86asm.RAX || instruction.Args[0] == x86asm.EAX) {
+			if leaSeen || memory.Disp != aliasOffset || memory.Index != 0 {
+				t.Fatal("original caller pointer differs from observed callee cell", instruction)
+			}
+			leaSeen = true
+		}
+		if memory, ok := instruction.Args[0].(x86asm.Mem); instruction.Op == x86asm.MOV && ok &&
+			(memory.Base == x86asm.RSP || memory.Base == x86asm.ESP) && (instruction.Args[1] == x86asm.RAX || instruction.Args[1] == x86asm.EAX) && !callSeen {
+			if !leaSeen || pointerStored || memory.Disp != 0 || memory.Index != 0 {
+				t.Fatal("original outgoing pointer slot is not exactly ABI0 slot zero", instruction)
+			}
+			pointerStored = true
+		}
+		if instruction.Op == x86asm.CALL {
+			if callSeen || !leaSeen || !pointerStored {
+				t.Fatal("original caller has an unbound CALL")
+			}
+			callSeen = true
+		}
+	}
+	// Both actual objabi tables assign R_CALL=7; old listings print its
+	// number while current listings print the name. No other role is allowed.
+	relocation := regexp.MustCompile(`(?m)^\s*rel [0-9]+\+4 t=(?:7|R_CALL) ` + regexp.QuoteMeta(actual.symbolPrefix+"Value") + `\+0\s*$`)
+	if !leaSeen || !callSeen || len(relocation.FindAllString(actual.listing, -1)) != 1 {
+		t.Fatalf("complete caller lacks one original relocated Value CALL:\n%s", actual.listing)
+	}
+	t.Logf("ORIGINAL_POINTER_ALIAS_LAYOUT: kind=%s target=%s cell-entry=%d caller-SP=%d call-word=%d source=%x value-code=%x; compile-only, never executed", kind, triple, cell, aliasOffset, word, sha256.Sum256([]byte(source)), actual.code["Value"])
+	file, err := Parse(ArchAMD64, value)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatalf("unchanged original callee parse: %v", err)
+	}
+	return pkg, file, sig, value
+}
+
+func TestX86ABI0ResultNativeAliasOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []string{"result", "AUTO"} {
+			t.Run(target.triple+"/"+kind, func(t *testing.T) {
+				pkg, file, sig, source := x86ResultNativeAliasFixture(t, target.arch, target.triple, kind)
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				options := Options{Goarch: target.arch, TargetTriple: target.triple, ResolveSym: resolve, Sigs: map[string]FuncSig{"Value": sig}}
+				text, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, text, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				typed, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve})
+				if typed != nil && !typed.Module.IsNil() {
+					defer typed.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, typed.Module.String(), "typed-go")
+				t.Log("THREE_API_CALLEE_OBJECTS: compile-only; original assembly Caller is not translated or executed, no initialized-pointee/runtime claim")
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultNativeAliasesCannotProveInitialization(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, kind := range []string{"result", "AUTO"} {
+			t.Run(target.triple+"/"+kind, func(t *testing.T) {
+				_, file, sig, _ := x86ResultNativeAliasFixture(t, target.arch, target.triple, kind)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("uninitialized original native %s alias acquired public numerical/result-byte initialization: %v", kind, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_native_pointer_objects_test.go b/x86_result_native_pointer_objects_test.go
new file mode 100644
index 000000000..2a7e9f877
--- /dev/null
+++ b/x86_result_native_pointer_objects_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These functions return a literal; their opaque addresses are never read or
+// written. Object acceptance must not silently replace initialization proofs.
+func TestX86ABI0ResultIncomingPointerIdentityFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word := 8
+		if target.arch == "386" {
+			word = 4
+		}
+		for name, body := range x86ResultIncomingPointerIdentityBodies(target.arch) {
+			t.Run(target.triple+"/"+name, func(t *testing.T) {
+				body += fmt.Sprintf("MOVL $42,ret0+%d(FP)\nRET", word)
+				pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch,
+					"func Value(x *[8]uint32) uint32", body)
+				receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				t.Logf("ORIGINAL_POINTER_IDENTITY_OBJECT: %+v", receipt)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				options := Options{Goarch: target.arch, TargetTriple: target.triple,
+					ResolveSym: resolve, Sigs: map[string]FuncSig{"Value": sig}}
+				text, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, text, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				typed, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+				})
+				if typed != nil && !typed.Module.IsNil() {
+					defer typed.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, typed.Module.String(), "typed-go")
+			})
+		}
+	}
+}
diff --git a/x86_result_native_pointer_roles_test.go b/x86_result_native_pointer_roles_test.go
new file mode 100644
index 000000000..bcb29359e
--- /dev/null
+++ b/x86_result_native_pointer_roles_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86ResultIncomingPointerIdentityBodies(arch string) map[string]string {
+	move, add, lea := "MOVQ", "ADDQ", "LEAQ"
+	if arch == "386" {
+		move, add, lea = "MOVL", "ADDL", "LEAL"
+	}
+	load := move + " x+0(FP),AX\n"
+	return map[string]string{
+		"copy":          load + move + " AX,CX\n",
+		"offset":        load + add + " $4,AX\n",
+		"index":         load + "MOVL $2,CX\n" + lea + " 8(AX)(CX*4),DX\n",
+		"lea":           load + "MOVL $1,CX\n" + lea + " 4(AX)(CX*2),DX\n",
+		"both branches": load + "MOVL $0,DX\nCMPL DX,$0\nJE other\n" + move + " AX,CX\nJMP end\nother:\n" + move + " AX,CX\nend:\nNOP\n",
+	}
+}
+
+func TestX86ABI0ResultInitializationIncomingPointerRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := int64(8)
+		move, lea := "MOVQ", "LEAQ"
+		if arch == "386" {
+			word = 4
+			move, lea = "MOVL", "LEAL"
+		}
+		load := move + " x+0(FP),AX\n"
+		finish := fmt.Sprintf("MOVL $42,ret0+%d(FP)\nRET", word)
+		for name, body := range x86ResultIncomingPointerIdentityBodies(arch) {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x *[8]uint32) uint32", body+finish)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				original := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal(err)
+				}
+				if original != fmt.Sprintf("%#v %#v", file.Funcs[0], sig) {
+					t.Fatal("initialization observation changed original source/signature")
+				}
+			})
+		}
+		for name, body := range map[string]string{
+			"declared pointer read": load + "MOVL (AX),BX\n",
+			"unknown base":          "MOVL (AX),BX\n",
+			"unknown index":         load + "MOVL (AX)(CX*4),BX\n",
+			"partial pointer":       load + "MOVB $1,AX\nMOVL (AX),BX\n",
+			"numerical overwrite":   load + "MOVL $1,AX\nMOVL (AX),BX\n",
+			"numeric address":       move + " $1,AX\nMOVL (AX),BX\n",
+			"pointer as number":     load + "MOVL AX,BX\n",
+			"missing branch origin": load + "MOVL $0,DX\nCMPL DX,$0\nJE other\n" + move + " AX,CX\nJMP end\nother:\nNOP\nend:\nMOVL (CX),BX\n",
+			"mixed branch origin":   load + "MOVL $0,DX\nCMPL DX,$0\nJE other\n" + move + " AX,CX\nJMP end\nother:\nMOVL $1,CX\nend:\nMOVL (CX),BX\n",
+			"physical write":        load + "MOVL $1,(AX)\nMOVL (AX),BX\n",
+			"call":                  load + "CALL ·Other(SB)\nMOVL (AX),BX\n",
+			"symbol address":        "MOVL global(SB),BX\n",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x *uint32) uint32", body+fmt.Sprintf("MOVL BX,ret0+%d(FP)\nRET", word))
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err == nil {
+					t.Fatal("unclosed native role acquired a result initialization observation")
+				}
+			})
+		}
+		_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(x *uint32) uint32", load+lea+" (AX),DX\n"+finish)
+		changed := sig
+		changed.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+		changed.Frame.Params[0].Type = I64
+		if arch == "386" {
+			changed.Frame.Params[0].Type = I32
+		}
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], changed, arch); err == nil {
+			t.Fatal("numeric parameter inherited the original incoming pointer origin")
+		}
+		if reflect.DeepEqual(sig, changed) {
+			t.Fatal("signature role negative did not change its actual input")
+		}
+	}
+}
diff --git a/x86_result_native_pointer_test.go b/x86_result_native_pointer_test.go
new file mode 100644
index 000000000..055a35dbb
--- /dev/null
+++ b/x86_result_native_pointer_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86ABI0ResultInitializationDeclaredPointerReadsRemainUnproved(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, fixture := range []struct {
+			name, declaration, load, store string
+		}{
+			{"integer", "func Value(x *uint32) uint32", "MOVL (AX),BX", "MOVL BX"},
+			{"floating", "func Value(x *float32) float32", "MOVSS (AX),X0", "MOVSS X0"},
+		} {
+			t.Run(target.triple+"/"+fixture.name, func(t *testing.T) {
+				word, pointerMove := 8, "MOVQ"
+				if target.arch == "386" {
+					word, pointerMove = 4, "MOVL"
+				}
+				body := fmt.Sprintf("MOVL $0,ret0+%d(FP)\n%s x+0(FP),AX\n%s\n%s,ret0+%d(FP)\nRET",
+					word, pointerMove, fixture.load, fixture.store, word)
+				pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, fixture.declaration, body)
+				receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				t.Logf("ORIGINAL_DECLARED_POINTER_OBJECT: %+v", receipt)
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				options := Options{Goarch: target.arch, TargetTriple: target.triple,
+					ResolveSym: resolve, Sigs: map[string]FuncSig{"Value": sig}}
+				text, err := Translate(file, options)
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, text, "text")
+				ctx := llvm.NewContext()
+				defer ctx.Dispose()
+				module, err := TranslateModuleInContext(ctx, file, options)
+				if !module.IsNil() {
+					defer module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+				typed, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+					GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: resolve,
+				})
+				if typed != nil && !typed.Module.IsNil() {
+					defer typed.Module.Dispose()
+				}
+				if err != nil {
+					t.Fatal(err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, typed.Module.String(), "typed-go")
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("original and LLVM objects do not prove initialized pointee bytes: %v", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_numerical_lea_objects_test.go b/x86_result_numerical_lea_objects_test.go
new file mode 100644
index 000000000..237d8cd09
--- /dev/null
+++ b/x86_result_numerical_lea_objects_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86NumericalLEARow struct {
+	width, address, destination, effective string
+}
+
+// Independent effective-address axes, not inferred from the typed effect or
+// generated LLVM. Destination aliases expose read-before-write and W/L writes.
+func x86NumericalLEARows(arch string) []x86NumericalLEARow {
+	var rows []x86NumericalLEARow
+	addresses := []struct{ source, effective string }{
+		{"(AX)", "a"}, {"-129(AX)", "a-129"}, {"127(AX)", "a+127"}, {"128(AX)", "a+128"},
+		{"2147483647(AX)", "a+2147483647"}, {"-2147483648(AX)", "a-2147483648"},
+		{"17(AX)(BX*1)", "a+b+17"}, {"17(AX)(BX*2)", "a+2*b+17"},
+		{"17(AX)(BX*4)", "a+4*b+17"}, {"17(AX)(BX*8)", "a+8*b+17"},
+		{"0(BX*1)", "b"}, {"-7(BX*2)", "2*b-7"}, {"128(BX*4)", "4*b+128"}, {"0(BX*8)", "8*b"},
+		{"17", "UINT64_C(17)"}, {"-7", "UINT64_MAX-6"}, {"(1<<7)", "UINT64_C(128)"},
+	}
+	for _, width := range x86NumericalLEAWidths(arch) {
+		for _, address := range addresses {
+			for _, destination := range []string{"AX", "BX", "CX"} {
+				rows = append(rows, x86NumericalLEARow{width, address.source, destination, address.effective})
+			}
+		}
+		if width == "L" && arch == "amd64" {
+			rows = append(rows, x86NumericalLEARow{width, "0x100000002(AX)(BX*8)", "AX", "a+8*b+2"})
+		}
+		if arch == "386" {
+			rows = append(rows, x86NumericalLEARow{width, "0xffffffff(AX)", "AX", "a+UINT32_MAX"})
+		}
+	}
+	return rows
+}
+
+func (row x86NumericalLEARow) body(arch string, numericalResult bool) string {
+	move, seed := "MOVQ", "0x1122334455667788"
+	if arch == "386" {
+		move, seed = "MOVL", "0x55667788"
+	}
+	body := move + " $" + seed + ",CX\nCMP" + move[3:] + " AX,BX\nLEA" + row.width + " " + row.address + "," + row.destination + "\n"
+	if numericalResult {
+		// This scalar bit view makes both ABI0 and register result consumers
+		// check the complete original typed NUM-only source, not a final move.
+		return body + move + " " + row.destination + ",X0\n" + move + " X0,AX\n"
+	}
+	return body
+}
+
+func x86NumericalLEASources(arch string, rows []x86NumericalLEARow, register bool) (string, string) {
+	var source, declarations strings.Builder
+	word, move, typ := 8, "MOVQ", "uint64"
+	if arch == "386" {
+		word, move, typ = 4, "MOVL", "uint32"
+	}
+	for index, row := range rows {
+		name := fmt.Sprintf("NumericalLEA%d", index)
+		fmt.Fprintf(&declarations, "func %s(x,y %s) %s\n", name, typ, typ)
+		if register {
+			fmt.Fprintf(&source, "TEXT ·%s<ABIInternal>(SB),4,$0-0\n%sRET\n", name, row.body(arch, true))
+		} else {
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s y+%d(FP),BX\n%s%s AX,ret+%d(FP)\nRET\n",
+				name, 3*word, move, move, word, row.body(arch, true), move, 2*word)
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ResultNumericalLEAThreeAPIFiveTargetOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		rows := x86NumericalLEARows(target.arch)
+		for start := 0; start < len(rows); start += 64 {
+			end := start + 64
+			if end > len(rows) {
+				end = len(rows)
+			}
+			t.Run(fmt.Sprintf("%s/%d-%d", target.triple, start, end), func(t *testing.T) {
+				source, declarations := x86NumericalLEASources(target.arch, rows[start:end], false)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(target.triple, api, err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						x86ResultInitializationObject(t, llc, target.triple, input, "numerical-lea")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_numerical_lea_runtime_linux_amd64_test.go b/x86_result_numerical_lea_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..adf4d76b5
--- /dev/null
+++ b/x86_result_numerical_lea_runtime_linux_amd64_test.go
@@ -0,0 +1,127 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// These original complete Go bytes run through an explicit AX/BX C adapter,
+// not an authenticated SDK entry or a native Go caller. Capture RFLAGS before
+// the adapter's cleanup changes it; keep its original stack/GP canaries.
+func x86NumericalLEAOriginalAdapter(t *testing.T, index int, source string) string {
+	t.Helper()
+	adapter := amd64RegisterBoolOriginalAdapter(t, "x86_64-unknown-linux-gnu", index, source)
+	first, rest, found := strings.Cut(adapter, "\n")
+	if !found || !strings.HasPrefix(first, "__asm__(") || !strings.HasSuffix(first, ");") {
+		t.Fatal("original adapter must retain its exact assembly writer")
+	}
+	assembly, err := strconv.Unquote(strings.TrimSuffix(strings.TrimPrefix(first, "__asm__("), ");"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	call := fmt.Sprintf("callq OriginalBody%d\n", index)
+	observation := "movq %r15,48(%r12)\n"
+	if strings.Count(assembly, call) != 1 || strings.Count(assembly, observation) != 1 {
+		t.Fatal("original adapter lost its unique call/observation boundary")
+	}
+	assembly = strings.Replace(assembly, call, call+"pushfq\npopq %r11\n", 1)
+	assembly = strings.Replace(assembly, observation, observation+"movq %r11,56(%r12)\n", 1)
+	return fmt.Sprintf("__asm__(%q);\n%s", assembly, rest)
+}
+
+func TestCrossLinuxRuntimeMatrixX86NumericalLEAOriginalBytesAndLLVM(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("required native Linux AMD64 LEA owner needs LLVM22 llc/clang")
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+		compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+	rows := x86NumericalLEARows("amd64")
+	for start := 0; start < len(rows); start += 32 {
+		end := start + 32
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprintf("%d-%d", start, end), func(t *testing.T) {
+			batch := rows[start:end]
+			source, declarations := x86NumericalLEASources("amd64", batch, true)
+			var originals, prototypes, checks, status, statusDeclarations strings.Builder
+			for index, row := range batch {
+				original := fmt.Sprintf("TEXT ·NumericalLEA%d<ABIInternal>(SB),4,$0-0\n%sRET\n", index, row.body("amd64", true))
+				originals.WriteString(x86NumericalLEAOriginalAdapter(t, index, original))
+				fmt.Fprintf(&prototypes, "extern uint64_t NumericalLEA%d(uint64_t,uint64_t);\nextern uint64_t Status%d(uint64_t,uint64_t);\n", index, index)
+				// LAHF is a pre-existing scalar lowering diagnostic, not a new
+				// must-defined/canonical permission. The paired numerical result
+				// above independently requires the complete typed LEA proof.
+				fmt.Fprintf(&status, "TEXT ·Status%d<ABIInternal>(SB),4,$0-0\n%sSETOS DL\nLAHF\nMOVBLZX AH,AX\nMOVBLZX DL,DX\nSHLQ $8,DX\nORQ DX,AX\nRET\n", index, row.body("amd64", false))
+				fmt.Fprintf(&statusDeclarations, "func Status%d(x,y uint64) uint64\n", index)
+				initial := "UINT64_C(0x1122334455667788)"
+				if row.destination == "AX" {
+					initial = "a"
+				} else if row.destination == "BX" {
+					initial = "b"
+				}
+				result := row.effective
+				if row.width == "W" {
+					result = "((" + initial + ")&~UINT64_C(65535))|(uint16_t)(" + result + ")"
+				} else if row.width == "L" {
+					result = "(uint32_t)(" + result + ")"
+				}
+				fmt.Fprintf(&checks, `{
+    uint64_t observed[8]={0},raw=Original%d(a,b,observed),want=%s;
+    uint64_t got=NumericalLEA%d(a,b),bits=flags(a,b),packed=(bits&255)|2|((bits>>11&1)<<8);
+    uint64_t llvmFlags=Status%d(a,b);
+    if(raw!=want||got!=want||(observed[7]&0x8d5)!=bits||llvmFlags!=packed||!canaries(observed)){
+        fprintf(stderr,"row=%d a=%%llx b=%%llx raw=%%llx LLVM=%%llx want=%%llx nativeFlags=%%llx LLVMflags=%%llx expectedFlags=%%llx\n",
+            (unsigned long long)a,(unsigned long long)b,(unsigned long long)raw,(unsigned long long)got,
+            (unsigned long long)want,(unsigned long long)(observed[7]&0x8d5),(unsigned long long)llvmFlags,(unsigned long long)bits);
+        return 1;
+    }
+}
+`, index, result, index, index, start+index)
+			}
+			driver := `#include <stdint.h>
+#include <stdio.h>
+` + originals.String() + prototypes.String() + `
+static int canaries(const uint64_t *p){
+    return p[0]==UINT64_C(0x5a5a5a5a5a5a5a5a)&&p[1]==p[0]&&
+        p[2]==UINT64_C(0x6b6b6b6b6b6b6b6b)&&p[3]==p[2]&&
+        p[4]==UINT64_C(0x123456789abcdef0)&&p[5]==UINT64_C(0xfedcba9876543210)&&p[6]==UINT64_C(0x876543210fedcba9);
+}
+static uint64_t flags(uint64_t a,uint64_t b){
+    uint64_t r=a-b;unsigned parity=(uint8_t)r;
+    parity^=parity>>4;parity^=parity>>2;parity^=parity>>1;
+    return (a<b)|((uint64_t)((parity&1)==0)<<2)|(((a^b^r)>>4&1)<<4)|
+        ((uint64_t)(r==0)<<6)|((r>>63)<<7)|((((a^b)&(a^r))>>63)<<11);
+}
+int main(void){
+    const uint64_t values[]={0,1,63,64,65,65535,65536,UINT64_C(2147483647),UINT64_C(2147483648),
+        UINT64_C(4294967295),UINT64_C(4294967296),UINT64_C(1)<<63,UINT64_C(0x1122334455667788),UINT64_MAX};
+    for(unsigned i=0;i<sizeof(values)/sizeof(values[0]);i++)for(unsigned j=0;j<sizeof(values)/sizeof(values[0]);j++){
+        uint64_t a=values[i],b=values[j];
+` + checks.String() + `
+    }
+    puts("complete original Go numerical LEA bytes vs LLVM; W/L/Q, all effective-address axes, aliases, all six unchanged FLAGS and stack/GP canaries");
+    return 0;
+}
+`
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source+status.String(), declarations+statusDeclarations.String(), "amd64", execution.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				for _, optimized := range []bool{false, true} {
+					input, level := ir, "-O0"
+					if optimized {
+						input, level = x86MulDivRoundOptimize(t, input), "-O2"
+					}
+					t.Log(api, level, execution.compileAndRunLLVM(t, "numerical-lea", input, driver, level))
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_numerical_lea_test.go b/x86_result_numerical_lea_test.go
new file mode 100644
index 000000000..2172e6b76
--- /dev/null
+++ b/x86_result_numerical_lea_test.go
@@ -0,0 +1,375 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultNumericalLEAIndexOnlyThreeAPIs(t *testing.T) {
+	const source = "TEXT ·view<ABIInternal>(SB),4,$0-0\nLEAQ 0(BX*8),CX\nCMPQ CX,$0\nSETEQ AX\nRET\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			_, err := x86ScalarFPBitViewAPI(t, source, "func view(x,y uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil {
+				t.Fatal("initialized NUM-only index LEA rejected:", err)
+			}
+		})
+	}
+}
+
+func x86NumericalLEAWidths(arch string) []string {
+	if arch == "386" {
+		return []string{"W", "L"}
+	}
+	return []string{"W", "L", "Q"}
+}
+
+func x86NumericalLEAAddresses() []string {
+	return []string{"(AX)", "-129(AX)", "127(AX)", "128(AX)", "2147483647(AX)", "-2147483648(AX)",
+		"17(AX)(BX*1)", "17(AX)(BX*2)", "17(AX)(BX*4)", "17(AX)(BX*8)",
+		"0(BX*1)", "-7(BX*2)", "128(BX*4)", "0(BX*8)", "17", "-7", "(1<<7)"}
+}
+
+func TestX86ResultNumericalLEACompleteIndependentGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	if !regexp.MustCompile(`(?s)var ym_rl = \[\]ytab\{\s*\{Zm_r, 1, argList\{Ym, Yrl\}\},\s*\}`).MatchString(table) {
+		t.Fatal("complete Go LEA zcase/zoffset/classes changed")
+	}
+	rows := regexp.MustCompile(`\{A(LEA[WLQ]), ([^,]+), ([^,]+), opBytes\{([^}]+)\}\}`).FindAllStringSubmatch(table, -1)
+	if len(rows) != 3 {
+		t.Fatal("complete Go LEA family changed", len(rows))
+	}
+	for _, row := range rows {
+		prefix := map[string]string{"LEAW": "Pe", "LEAL": "Px", "LEAQ": "Pw"}[row[1]]
+		if row[2] != "ym_rl" || row[3] != prefix || row[4] != "0x8d" {
+			t.Fatal("complete Go LEA attributes changed", row)
+		}
+	}
+}
+
+func TestX86ResultNumericalLEACompleteGoShapesAndEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range x86NumericalLEAWidths(arch) {
+			for _, address := range x86NumericalLEAAddresses() {
+				t.Run(arch+"/"+width+"/"+address, func(t *testing.T) {
+					body := "LEA" + width + " " + address + ",CX"
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", true)
+					ins := x86PureGPUnknownInstruction(t, body)
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || effect.dynamicMemory || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+						t.Fatal("numerical LEA byte effect/unchanged FLAGS missing", known, err, effect)
+					}
+					last := effect.operands[len(effect.operands)-1]
+					if !last.write || last.read || !reflect.DeepEqual(last.operand, Operand{Kind: OpReg, Reg: CX}) || last.width != x86LEAWidth(ins.Op, arch) {
+						t.Fatal("LEA reads old destination or writes wrong bytes", last)
+					}
+					for _, input := range effect.operands[:len(effect.operands)-1] {
+						if !input.read || input.write || input.operand.Kind != OpReg || input.width != last.width {
+							t.Fatal("LEA effective address is not a numerical register dependency", input)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultNumericalLEADefinedBytesFlagsAndAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range x86NumericalLEAWidths(arch) {
+			for _, destination := range []string{"AX", "BX", "CX"} {
+				ins := x86PureGPUnknownInstruction(t, "LEA"+width+" -7(AX)(BX*8),"+destination)
+				for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagAF | x86ByteFlagPF, x86ByteFlagsAll} {
+					state := x86ResultState{flags: flags}
+					state.gp[0], state.gp[3] = 0xff, 0xff
+					before := state.clone()
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) || state.flags != flags {
+						t.Fatal("initialized LEA or preserved FLAGS rejected", arch, width, destination, state.flags)
+					}
+					root, mask, _ := x86ResultGP(Reg(destination), x86LEAWidth(ins.Op, arch), arch)
+					if width == "L" || width == "Q" {
+						mask = 0xff
+					}
+					before.gp[root] |= mask
+					if !reflect.DeepEqual(before, state) {
+						t.Fatal("LEA gained a non-numerical fact", arch, width, destination, state)
+					}
+				}
+			}
+		}
+		word, move, typ := x86ResultPointerWord(arch), "MOVQ", "uint64"
+		if arch == "386" {
+			move, typ = "MOVL", "uint32"
+		}
+		for _, test := range []struct {
+			name, body string
+			accept     bool
+		}{
+			{"W low inputs", "MOVW $7,AX\nMOVW $9,BX\nLEAW -7(AX)(BX*8),CX\nMOVW CX,DX", true},
+			{"W unknown upper", "MOVW $7,AX\nLEAW 0(AX*8),CX\n" + move + " CX,DX", false},
+			{"L missing input", "MOVW $7,BX\nLEAL 0(BX*8),CX\nMOVL CX,DX", false},
+			{"L clears old pointer", move + " p+0(FP),CX\nMOVL $7,BX\nLEAL 0(BX*8),CX\n" + move + " CX,DX", true},
+			{"W old pointer remainder", move + " p+0(FP),CX\nMOVL $7,BX\nLEAW 0(BX*8),CX\n" + move + " CX,DX", false},
+			{"unknown index", "LEAL 0(BX*8),CX\nMOVL CX,DX", false},
+			{"unknown base", "MOVL $7,BX\nLEAL 0(AX)(BX*8),CX\nMOVL CX,DX", false},
+			{"pointer index", move + " p+0(FP),BX\nLEAL 0(BX*8),CX\nMOVL CX,DX", false},
+			{"pointer base as data", move + " p+0(FP),BX\nLEAL 0(BX),CX\nMOVL CX,DX", false},
+		} {
+			t.Run(arch+"/"+test.name, func(t *testing.T) {
+				body := test.body + fmt.Sprintf("\nMOVW DX,ret0+%d(FP)\nRET", word)
+				if strings.Contains(test.name, "unknown upper") || strings.Contains(test.name, "pointer remainder") {
+					body = test.body + fmt.Sprintf("\n%s DX,ret0+%d(FP)\nRET", move, word)
+				}
+				result := "uint16"
+				if strings.Contains(test.name, "unknown upper") || strings.Contains(test.name, "pointer remainder") {
+					result = typ
+				}
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p *byte) "+result, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.accept && err != nil || !test.accept && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("NUM-only/opaque/partial-byte boundary differs", test.accept, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultNumericalLEACanonicalBoolAndCompleteCFG(t *testing.T) {
+	for _, test := range []struct {
+		name, body string
+		accept     bool
+	}{
+		{"canonical untouched", "MOVB $1,AX\nLEAQ 0(BX*8),CX", true},
+		{"flags preserved", "CMPQ AX,BX\nLEAQ 0(BX*8),CX\nSETEQ AX", true},
+		{"canonical overwritten W", "MOVB $1,AX\nLEAW 0(BX*8),AX", false},
+		{"canonical overwritten L", "MOVB $1,AX\nLEAL 0(BX*8),AX", false},
+		{"canonical overwritten Q", "MOVB $1,AX\nLEAQ 0(BX*8),AX", false},
+		{"unknown dead LEA", "LEAQ 0(DX*8),CX\nMOVB $1,AX", false},
+		{"unknown joined input", "CMPQ AX,BX\nJE one\nMOVQ $7,DX\nJMP joined\none:\nMOVW $7,DX\njoined:\nLEAQ 0(DX*8),CX\nSETEQ AX", false},
+		{"complete joined input", "CMPQ AX,BX\nJE one\nMOVQ $7,DX\nJMP joined\none:\nMOVQ BX,DX\njoined:\nLEAQ 0(DX*8),CX\nSETEQ AX", true},
+		{"no implicit FLAGS", "LEAQ 0(BX*8),CX\nSETEQ AX", false},
+		{"no native memory", "LEAQ 0(BX*8),CX\nMOVQ (CX),DX\nCMPQ DX,$0\nSETEQ AX", true},
+		{"no g fact", "LEAQ 0(R14*8),CX\nCMPQ CX,$0\nSETEQ AX", false},
+		{"no physical SP fact", "LEAQ 0(SP),CX\nMOVB $1,AX", false},
+		{"no physical BP fact", "LEAQ 0(BP),CX\nMOVB $1,AX", false},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			source := "TEXT ·view<ABIInternal>(SB),4,$0-0\n" + test.body + "\nRET\n"
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view(x,y uint64) bool\n", "amd64", "x86_64-unknown-linux-gnu", api)
+				if test.accept && err != nil || !test.accept && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal(api, test.accept, err)
+				}
+				if test.name == "no native memory" {
+					if strings.Count(ir, "load volatile i64,") != 1 {
+						t.Fatal("complete LEA NUM address lost its native read")
+					}
+					x86RequireNumericNativeSourceContext(t, source, "func view(x,y uint64) bool", "amd64")
+					x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultNumericalLEACompletePhysicalRegisterBank(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		registers := strings.Fields("AX CX DX BX SP BP SI DI")
+		if arch == "amd64" {
+			registers = append(registers, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15")...)
+		}
+		for _, width := range x86NumericalLEAWidths(arch) {
+			for _, register := range registers {
+				for _, body := range []string{
+					"LEA" + width + " 7(" + register + "),CX",
+					"LEA" + width + " 7(" + register + "*8),CX",
+					"LEA" + width + " 7(AX)(BX*8)," + register,
+				} {
+					if register == "SP" && strings.Contains(body, "SP*8") {
+						goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+						continue
+					}
+					goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", true)
+					ins := x86PureGPUnknownInstruction(t, body)
+					_, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					ordinary := register != "SP" && (register != "BP" || arch == "386")
+					if ordinary && (!known || err != nil) || !ordinary && (known || err != nil) {
+						t.Fatal("registered bank vs physical stack-role boundary", arch, body, known, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultNumericalLEARejectsOtherRolesAndUnknownInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range x86NumericalLEAWidths(arch) {
+			for _, source := range []string{"slot+0(FP)", "tmp-8(SP)", "table(SB)", "0(FS)", "0(GS)", "0(TLS)", "1(PC)", "CONST(AX)"} {
+				ins := x86PureGPUnknownInstruction(t, "LEA"+width+" "+source+",CX")
+				if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); source == "tmp-8(SP)" {
+					if known || err != nil {
+						t.Fatal("named NUM registration intercepted a specialized stack role", arch, known, err)
+					}
+				} else if !known || err == nil {
+					t.Fatal("LEA granted another address/storage domain", arch, source, known, err)
+				}
+				if _, _, known := X86FPAccessBytes(ins, 0, arch); known {
+					t.Fatal("LEA acquired an FP memory access width", arch, source)
+				}
+			}
+			for _, args := range []string{"$1,CX", "AX,CX", "(AX),AL", "(AX),AH", "(AX),X0", "(AX),M0", "(AX),TLS", "(AX),(BX)", "(AX)", "(AX),BX,CX", "(AX)(BX*3),CX"} {
+				body := "LEA" + width + " " + args
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n", "", false)
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+body+"\nRET\n")
+				if err != nil {
+					continue // Actual source rejected by both parsers, not a pass.
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err == nil {
+					t.Fatal("Go-rejected LEA row admitted", arch, body, known, err)
+				}
+			}
+			// asmidx emits no source position. Reuse its exact tuple-bound
+			// observer, never widen the generic actual-Go rejection oracle.
+			unscaled := "LEA" + width + " 0(AX)(CX),DX"
+			x86UnnamedScale0OriginalGoRejection(t, arch, "TEXT addr(SB),4,$0-0\n"+unscaled+"\nRET\n")
+			ins := x86PureGPUnknownInstruction(t, unscaled)
+			if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err == nil {
+				t.Fatal("unencodable missing scale became numerical LEA", known, err)
+			}
+		}
+	}
+	ins := x86PureGPUnknownInstruction(t, "LEAQ 0(BX*8),CX")
+	for _, change := range []func(*Instr){
+		func(i *Instr) { i.x86Encoded = true },
+		func(i *Instr) { i.x86AddressBits = 32 },
+		func(i *Instr) { i.x86UnboundAddressOverride = true },
+		func(i *Instr) { i.x86SegmentPrefix = 0x64 },
+		func(i *Instr) { i.x86RawNearReturn = &x86RawNearReturnForm{} },
+	} {
+		changed := ins
+		change(&changed)
+		if _, known, err := x86TypedInstructionByteEffect(changed.Op, changed, "amd64"); known || err != nil {
+			t.Fatal("named NUM LEA intercepted a physical/source override", known, err)
+		}
+		bare := x86PureGPUnknownInstruction(t, "LEAQ 17,CX")
+		change(&bare)
+		if !reflect.DeepEqual(x86LEASourceInstruction(bare), bare) {
+			t.Fatal("bare source displacement laundered a physical/source override")
+		}
+	}
+	for _, op := range []Op{"LEAQ.Z", "LEAQ.SAE"} {
+		changed := ins
+		changed.Op = op
+		if _, known, err := x86TypedInstructionByteEffect(op, changed, "amd64"); !known || err == nil {
+			t.Fatal("LEA acquired a suffix", known, err)
+		}
+	}
+	state := x86ResultState{}
+	state.pointerGP[3], state.callerAddressGP[3] = true, true
+	if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+		t.Fatal("opaque/caller address index became numerical bytes")
+	}
+	for _, source := range []string{"LEAQ 0(DX*8),CX", "LEAW 0(AX),CX"} {
+		unknown := x86PureGPUnknownInstruction(t, source)
+		if x86LoweredPureGPUnknownTransfer(unknown, &state, "amd64") {
+			t.Fatal("unknown-value fallback acquired LEA/address authority")
+		}
+	}
+}
+
+func TestX86ResultNumericalLEAOriginalIdentityAndPointerRuleIndependent(t *testing.T) {
+	for _, source := range []string{"LEAQ 17,CX", "LEAL (1<<7),CX", "LEAQ (AX)(BX*8),CX"} {
+		ins := x86PureGPUnknownInstruction(t, source)
+		before := fmt.Sprintf("%#v", ins)
+		state := x86ResultState{}
+		state.gp[0], state.gp[3] = 0xff, 0xff
+		if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || before != fmt.Sprintf("%#v", ins) {
+			t.Fatal("LEA effect changed original source/operand identity", source)
+		}
+	}
+	ins := x86PureGPUnknownInstruction(t, "LEAQ 7(AX)(BX*8),CX")
+	state := x86ResultState{}
+	state.pointerGP[0], state.callerAddressGP[0], state.gp[3] = true, true, 0xff
+	if !x86ResultTransfer(ins, &state, nil, 0, "amd64") || !state.pointerGP[1] || state.gp[1] != 0 {
+		t.Fatal("separate caller address LEA became numerical or was disabled")
+	}
+	state = x86ResultState{}
+	state.pointerGP[3], state.gp[0] = true, 0xff
+	if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+		t.Fatal("numerical base and opaque pointer index became a valid address")
+	}
+}
+
+func TestX86ResultNumericalLEASharedCarryAndCanonicalConsumers(t *testing.T) {
+	for _, op := range []string{"LEAW", "LEAL", "LEAQ"} {
+		ins := x86PureGPUnknownInstruction(t, op+" -7(BX*8),CX")
+		ctx := &amd64Ctx{goarch: "amd64"}
+		carry := x86LockCarryState{carry: true}
+		carry.gp[3] = 0xff
+		next := ctx.lockCarryTransfer(ins, carry)
+		if !next.carry || next.stackUnbound || next.gp[1] == 0 {
+			t.Fatal("LEA lost known carry or numerical output", op, next)
+		}
+		carry.gp[3] = 0
+		next = ctx.lockCarryTransfer(ins, carry)
+		if !next.carry || next.gp[1]&15 != 0 {
+			t.Fatal("LEA invented known numerical low bytes or changed carry", op, next)
+		}
+		canonical := [16]uint8{255, 255, 255, 255}
+		nextCanonical := x86RegisterCanonicalBytesAfter(ins, canonical, "amd64")
+		written := uint8(3)
+		if op == "LEAL" {
+			written = 15
+		} else if op == "LEAQ" {
+			written = 255
+		}
+		canonical[1] &^= written
+		if !reflect.DeepEqual(nextCanonical, canonical) {
+			t.Fatal("LEA canonicality did not kill exactly its computed bytes", op, nextCanonical, canonical)
+		}
+	}
+}
+
+func TestX86ResultNumericalLEAExistingStackFlagsConsumer(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, suffix := int64(8), Op("MOVQ"), "Q"
+		if arch == "386" {
+			word, move, suffix = 4, "MOVL", "L"
+		}
+		ins := x86PureGPUnknownInstruction(t, fmt.Sprintf("LEA%s -%d(BP),SP", suffix, 2*word))
+		state := x86SourceStackState{callers: map[Reg]x86CallerPointerValue{}, known: map[Reg]uint8{}}
+		state.bp = x86SourceStackAddress{offset: 0}
+		x86SourceStackSetNumericFlags(&state, x86ByteFlagsAll)
+		// These are the existing consumers in their actual order. The exact
+		// stack address is proved first, not by the numerical descriptor.
+		if !x86SourceStackAddressStep(&ins, &state, move, suffix, word) || state.sp != -2*word {
+			t.Fatal("independent existing stack-address role was not exercised", arch)
+		}
+		if _, valid := x86CallerScalarStep(&ins, &state, &x86GoCallerRegionProof{}); !valid {
+			t.Fatal("preceding stack proof lost its caller transfer", arch)
+		}
+		if !x86SourceStackFlagsStepForArch(ins, &state, arch) || x86SourceStackNumericFlagMask(&state) != x86ByteFlagsAll {
+			t.Fatal("named numerical registration stole exact stack FLAGS delegation", arch)
+		}
+		numbers := x86ResultState{}
+		if x86ResultTransfer(ins, &numbers, nil, 0, arch) {
+			t.Fatal("specialized stack delegation became an unbound numerical fact", arch)
+		}
+	}
+}
diff --git a/x86_result_numerical_lea_unsigned_test.go b/x86_result_numerical_lea_unsigned_test.go
new file mode 100644
index 000000000..79a189aa5
--- /dev/null
+++ b/x86_result_numerical_lea_unsigned_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+// Independent source integers at both signed boundaries. In 386 asm6.go's
+// asmandsz accepts signed32 or uint32, then encodes int32: the complete named
+// W/L grammar is unchanged, and no original source operand is rewritten.
+func x86Mode32LEADisplacements() []int64 {
+	return []int64{-2147483648, -1, 2147483647, 2147483648, 2147483649, 4294967295}
+}
+
+func TestX86ResultNumericalLEAMode32UnsignedShapeAndReachingDomains(t *testing.T) {
+	for _, width := range []string{"W", "L"} {
+		for _, displacement := range x86Mode32LEADisplacements() {
+			for _, destination := range []string{"AX", "BX", "CX"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", width, displacement, destination), func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, fmt.Sprintf("LEA%s %d(AX)(BX*8),%s", width, displacement, destination))
+					original := ins
+					for _, shape := range []bool{false, true} {
+						state := x86ResultState{shapeOnly: shape, flags: x86ByteFlagsAll}
+						state.gp[0], state.gp[3], state.gp[1] = 0xff, 0xff, 0xff
+						if !x86ResultTransfer(ins, &state, nil, 0, "386") || state.flags != x86ByteFlagsAll {
+							t.Fatal("legal NUM-only LEA was stolen by the pointer source-shape branch", shape, state)
+						}
+						if !shape && (state.pointerGP[0] || state.pointerGP[1] || state.pointerGP[3]) {
+							t.Fatal("numerical LEA created reaching pointer authority")
+						}
+					}
+					for _, kind := range []string{"unknown base", "unknown index", "actual pointer"} {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.gp[3] = 0xff, 0xff
+						switch kind {
+						case "unknown base":
+							state.gp[0] = 0
+						case "unknown index":
+							state.gp[3] = 0
+						case "actual pointer":
+							state.gp[0], state.pointerGP[0] = 0, true
+						}
+						if kind == "actual pointer" && width == "L" && displacement <= 2147483647 {
+							continue // Existing opaque pointer arithmetic has its own role.
+						}
+						if x86ResultTransfer(ins, &state, nil, 0, "386") {
+							t.Fatal("shape fallback granted unknown bytes or widened actual pointer arithmetic", kind, state)
+						}
+					}
+					if !reflect.DeepEqual(ins, original) {
+						t.Fatal("source opcode/operand/Raw identity was normalized in place")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultNumericalLEAMode32UnsignedWholeThreeAPIs(t *testing.T) {
+	for _, width := range []string{"W", "L"} {
+		for _, displacement := range x86Mode32LEADisplacements() {
+			row := x86NumericalLEARow{width: width, address: fmt.Sprintf("%d(AX)(BX*8)", displacement), destination: "AX"}
+			source, declarations := x86NumericalLEASources("386", []x86NumericalLEARow{row}, false)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%d/%s", width, displacement, api), func(t *testing.T) {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", "i386-unknown-linux-gnu", api); err != nil {
+						t.Fatal("legal initialized uint32 address expression failed whole-source proof", err)
+					}
+				})
+			}
+		}
+	}
+	for _, body := range []string{
+		"LEAL 0xffffffff(AX),AX\nMOVL AX,X0\nMOVL X0,AX\nMOVL AX,ret+4(FP)",
+		"MOVL p+0(FP),AX\nLEAL 0xffffffff(AX),AX\nMOVL AX,X0\nMOVL X0,AX\nMOVL AX,ret+4(FP)",
+		"MOVW $7,AX\nLEAL 0xffffffff(AX),AX\nMOVL AX,X0\nMOVL X0,AX\nMOVL AX,ret+4(FP)",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			_, err := x86ScalarFPBitViewAPI(t, "TEXT ·view(SB),4,$0-8\n"+body+"\nRET\n", "func view(p *byte) uint32\n", "386", "i386-unknown-linux-gnu", api)
+			if !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("unknown/partial/pointer input acquired NUM result bytes", api, body, err)
+			}
+		}
+	}
+}
+
+func TestX86ResultNumericalLEAMode32UnsignedCannotBorrowPhysicalAddressRoles(t *testing.T) {
+	for _, width := range []string{"W", "L"} {
+		for _, displacement := range []int64{-2147483649, 4294967296} {
+			ins := x86PureGPUnknownInstruction(t, fmt.Sprintf("LEA%s %d(AX),CX", width, displacement))
+			state := x86ResultState{shapeOnly: true, flags: x86ByteFlagsAll}
+			state.gp[0] = 0xff
+			if x86ResultTransfer(ins, &state, nil, 0, "386") {
+				t.Fatal("NUM source-shape fallback widened Go's encoded displacement range", width, displacement)
+			}
+		}
+		for name, change := range map[string]func(*Instr){
+			"physical decoder":      func(i *Instr) { i.x86Encoded = true },
+			"explicit address size": func(i *Instr) { i.x86AddressBits = 16 },
+			"unbound address size":  func(i *Instr) { i.x86UnboundAddressOverride = true },
+			"segment":               func(i *Instr) { i.x86SegmentPrefix = 0x64 },
+			"raw source":            func(i *Instr) { i.x86SourceRaw = &x86SourceRawInstruction{} },
+		} {
+			t.Run(width+"/"+name, func(t *testing.T) {
+				ins := x86PureGPUnknownInstruction(t, "LEA"+width+" 0xffffffff(AX),CX")
+				change(&ins)
+				if _, registered, err := x86TypedLEAByteEffect(ins.Op, ins, "386"); registered || err != nil {
+					t.Fatal("physical/address-size role borrowed a named NUM source registration", registered, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultNumericalLEAMode32UnsignedOriginalEncoding(t *testing.T) {
+	for _, width := range []string{"W", "L"} {
+		for _, displacement := range x86Mode32LEADisplacements() {
+			t.Run(fmt.Sprintf("%s/%d", width, displacement), func(t *testing.T) {
+				original := fmt.Sprintf("TEXT encoded(SB),4,$0-0\nLEA%s %d(AX),AX\nRET\n", width, displacement)
+				actual := x86MinimumPositionOriginalGoBytes(t, "386", original)
+				var want []byte
+				if width == "W" {
+					want = append(want, 0x66)
+				}
+				offset := int32(displacement)
+				if offset >= -128 && offset <= 127 {
+					want = append(want, 0x8d, 0x40, byte(offset))
+				} else {
+					want = append(want, 0x8d, 0x80)
+					var encoded [4]byte
+					binary.LittleEndian.PutUint32(encoded[:], uint32(offset))
+					want = append(want, encoded[:]...)
+				}
+				want = append(want, 0xc3)
+				if !bytes.Equal(actual, want) {
+					t.Fatalf("actual original Go mode32 encoded displacement differs: %x, want %x", actual, want)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_occupied_set_test.go b/x86_result_occupied_set_test.go
new file mode 100644
index 000000000..b12e85f4b
--- /dev/null
+++ b/x86_result_occupied_set_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ABI0ResultInitializationOccupiedPointerComponents(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := 8
+		move := "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range []struct {
+			name, declaration string
+			input, result     int
+		}{
+			{"unused direct pointer", "func Value(x *uint32) uint32", -1, word},
+			{"slice length", "func Value(x []uint32) uint32", word, 3 * word},
+			{"slice capacity", "func Value(x []uint32) uint32", 2 * word, 3 * word},
+			{"string length", "func Value(x string) uint32", word, 2 * word},
+			{"struct numeric field", "type S struct { P *uint32; N uintptr }; func Value(x S) uint32", word, 2 * word},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				body := "MOVL $7,AX"
+				if row.input >= 0 {
+					body = fmt.Sprintf("%s x+%d(FP),AX", move, row.input)
+				}
+				body += fmt.Sprintf("\nMOVL AX,ret0+%d(FP)\nRET", row.result)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, row.declaration, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("unused pointer storage must not invent or prevent a numeric input: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultInitializationConditionalSetCompleteFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := 8
+		if arch == "386" {
+			word = 4
+		}
+		for _, condition := range strings.Fields("CC CS EQ GE GT HI LE LS LT MI NE OC OS PC PL PS") {
+			for _, destination := range []string{"AX", "AH", fmt.Sprintf("ret0+%d(FP)", word)} {
+				t.Run(arch+"/"+condition+"/"+destination, func(t *testing.T) {
+					body := fmt.Sprintf("MOVB x+0(FP),BX\nCMPB BX,$0\nSET%s %s", condition, destination)
+					if destination == "AX" || destination == "AH" {
+						body += fmt.Sprintf("\nMOVB %s,ret0+%d(FP)", destination, word)
+					}
+					body += "\nRET"
+					_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x uint8) uint8", body)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+						t.Fatalf("complete source-defined SETcc byte did not discharge its exact result: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_owned_indexed_vector.go b/x86_result_owned_indexed_vector.go
new file mode 100644
index 000000000..dc581e104
--- /dev/null
+++ b/x86_result_owned_indexed_vector.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import "reflect"
+
+// Only these complete typed read families consume an owned indexed table.
+// This selects the actual operand and access width, not a caller/pointer role.
+func x86OwnedIndexedVectorRead(ins Instr, arch string) (int, int64, bool) {
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil || ins.x86SDKLiteral != nil {
+		return 0, 0, false
+	}
+	if form, known, err := x86PackedLogicalProperties(ins, arch); known {
+		return form.memory, int64(form.memoryBytes), err == nil && !form.mmx && form.memory >= 0
+	}
+	if form, known, err := x86ByteShuffleProperties(ins.Op, ins, arch); known {
+		return form.memory, int64(form.memoryBytes), err == nil && form.memory >= 0
+	}
+	if form, known, err := x86LegacyIntegerArithmeticProperties(ins.Op, ins, arch); known {
+		return form.memory, int64(form.memoryBytes), err == nil && !form.mmx && form.memory >= 0
+	}
+	if form, known, err := x86PackedLowMultiplyProperties(ins.Op, ins, arch); known {
+		return form.memory, int64(form.memoryBytes), err == nil && form.legacy && form.memory >= 0
+	}
+	if form, known, err := x86PackedWordMultiplyProperties(ins.Op, ins, arch); known {
+		return form.memory, int64(form.memoryBytes), err == nil && form.legacy && !form.mmx &&
+			form.spec.mode == amd64PackedWordMultiplyLow && form.memory >= 0
+	}
+	return 0, 0, false
+}
+
+func (c *amd64Ctx) ownedIndexedVectorReads(fn Func, sig FuncSig, arch string) map[int]x86SDKLiteralAccess {
+	if c.fpStaticAddressValues == nil || len(c.fpStaticAddressValues.numericLiterals) == 0 {
+		return nil
+	}
+	literals := c.fpStaticAddressValues.numericLiterals
+	address, memory, direct := false, false, false
+	for _, ins := range fn.Instrs {
+		operand, _, vector := x86OwnedIndexedVectorRead(ins, arch)
+		memory = memory || vector && ins.Args[operand].Kind == OpMem
+		for index := range ins.Args {
+			form, valid := x86SDKLiteralOperandProperties(ins, index, arch)
+			address = address || valid && form.address && literals[form.symbol] > 0
+			// Mode32 may name the table directly instead of materializing a
+			// GP base. This selects a proof candidate, not an index or extent.
+			direct = direct || vector && index == operand && valid && !form.address &&
+				form.memory.Index != "" && literals[form.symbol] > 0
+		}
+	}
+	if !memory || !address && !direct {
+		return nil // No new proof or restriction for unrelated source domains.
+	}
+	// The existing pure CFG/range algorithm takes ordinary source, signature
+	// and actual numeric extents. Its result is not an SDK observation/token.
+	// Failure grants nothing; the original complete result proof still runs.
+	facts, err := proveX86SDKLiteralAccesses(fn, sig, arch, literals)
+	if err != nil {
+		return nil
+	}
+	reads := make(map[int]x86SDKLiteralAccess)
+	for _, fact := range facts {
+		operand, width, valid := x86OwnedIndexedVectorRead(fact.Original, arch)
+		if valid && !fact.Address && fact.LowBits == nil && fact.Operand == operand && fact.Width == width {
+			reads[fact.Instruction] = fact
+		}
+	}
+	return reads
+}
+
+func x86OwnedIndexedVectorReadAt(reads map[int]x86SDKLiteralAccess, ordinal int, ins Instr) (Operand, int64, bool) {
+	fact, present := reads[ordinal]
+	if !present || fact.Operand < 0 || fact.Operand >= len(ins.Args) ||
+		!reflect.DeepEqual(ins, fact.Original) {
+		return Operand{}, 0, false
+	}
+	return ins.Args[fact.Operand], fact.Width, true
+}
diff --git a/x86_result_packed_abs_sign.go b/x86_result_packed_abs_sign.go
new file mode 100644
index 000000000..35198c7f3
--- /dev/null
+++ b/x86_result_packed_abs_sign.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+// ABS and SIGN are nontrapping integer operations: unknown dead register
+// data may remain unknown. Native addresses and K inputs are still required,
+// even for Void or an unused result; this grants no backing or entry facts.
+func x86ResultPackedAbsSignStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedAbsSignProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) && !x86RawPackedAbsLiteralForm(ins, arch) {
+		return false, true
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	var first uint64
+	if form.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[form.first], int64(form.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, form.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	second := ^uint64(0)
+	if form.spec.sign {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+		second = state.vectorBytes(index)
+	}
+	var initialized uint64
+	laneBytes := form.spec.laneBits / 8
+	for at := 0; at < form.byteWidth; at += laneBytes {
+		lane := x86CallerVectorByteMask(int64(laneBytes)) << uint(at)
+		if first&lane == lane && second&lane == lane {
+			initialized |= lane
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if form.mask >= 0 && !form.zeroing {
+		initialized &= state.vectorBytes(destination)
+	}
+	state.writeVector(destination, form.byteWidth, initialized, form.legacy)
+	return true, true
+}
diff --git a/x86_result_packed_align.go b/x86_result_packed_align.go
new file mode 100644
index 000000000..9fa46457b
--- /dev/null
+++ b/x86_result_packed_align.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+// The result proof propagates selected-byte knowledge, never treats unknown
+// register input as zero. Native accesses and masks remain mandatory even
+// when the numerical result is dead or a large byte selector returns zero.
+func x86ResultPackedAlignStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedAlignProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	var first uint64
+	if form.memory >= 0 {
+		source := ins.Args[form.first]
+		if form.legacy && source.Kind == OpFP ||
+			!x86ResultReadWithNativeContinuation(ins, source, int64(form.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, form.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	defined := form.definedBytes(first, state.vectorBytes(second), state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true
+}
+
+func x86CallerPackedAlignStep(ins *Instr, form x86PackedAlignForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	first := uint64(0)
+	if form.memory >= 0 {
+		// An ordinary caller slice supplies no legacy m128 alignment witness.
+		if form.legacy || !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+		first = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)]
+	}
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	old := state.vectors[destination]
+	known := form.definedBytes(first, state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)], old)
+	upper := ^x86CallerVectorByteMask(int64(form.byteWidth))
+	if form.legacy {
+		upper &= old
+	}
+	state.vectors[destination] = upper | known
+	return true
+}
diff --git a/x86_result_packed_conversion_raw.go b/x86_result_packed_conversion_raw.go
new file mode 100644
index 000000000..0429ce503
--- /dev/null
+++ b/x86_result_packed_conversion_raw.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+// This value snapshot is copied with its sealed raw origin, including immutable
+// whole-source replay clones. No default false value identifies a conversion:
+// arch is present only after its complete typed physical shape validates.
+type x86RawPackedConversionIdentity struct {
+	arch               string
+	encoded, evex, mmx bool
+}
+
+func x86PackedConversionRawIdentity(ins Instr, arch string) x86RawPackedConversionIdentity {
+	_, signed, signedErr := x86SignedPackedFloatProperties(ins, arch)
+	_, numeric, numericErr := x86PackedConversionProperties(ins, arch)
+	if !signed && !numeric || signed && signedErr != nil || numeric && numericErr != nil {
+		return x86RawPackedConversionIdentity{}
+	}
+	return x86RawPackedConversionIdentity{
+		arch: arch, encoded: ins.x86Encoded,
+		evex: ins.x86PackedNumericEVEX, mmx: ins.x86MMXSourceConversion,
+	}
+}
+
+func x86RawPackedConversionSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	if origin == nil || origin.packedConversion.arch != arch ||
+		origin.packedConversion != x86PackedConversionRawIdentity(ins, arch) ||
+		!x86RawOrdinaryVectorSource(ins, arch) {
+		return false
+	}
+	if form, known, err := x86SignedPackedFloatProperties(ins, arch); known {
+		return err == nil && !form.mmx
+	}
+	form, known, err := x86PackedConversionProperties(ins, arch)
+	return known && err == nil && !form.mmx
+}
+
+// Only an exact original physical conversion may project into its existing
+// numerical byte effect. The paired original native opcode retains MXCSR,
+// exceptions, complete memory accesses and all mask/merge obligations. This
+// projection creates no entry, caller, pointee, frame or reusable read fact.
+func x86LoweredPackedConversionResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	_, signed, _ := x86SignedPackedFloatProperties(ins, arch)
+	_, numeric, _ := x86PackedConversionProperties(ins, arch)
+	if !signed && !numeric || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if !x86RawPackedConversionSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	if signed {
+		return x86ResultSignedPackedFloatStep(local, state, owned, arch, true)
+	}
+	return x86ResultPackedConversionStepWithRead(local, state, owned, arch, true)
+}
diff --git a/x86_result_packed_dot.go b/x86_result_packed_dot.go
new file mode 100644
index 000000000..6aee60ef8
--- /dev/null
+++ b/x86_result_packed_dot.go
@@ -0,0 +1,109 @@
+package plan9asm
+
+// Zero is absent physical identity. Low-bank unmasked X/Y operands alone
+// cannot distinguish an AVX-VNNI opcode from the EVEX Go source spelling.
+type x86RawPackedDotEncoding uint8
+
+const (
+	x86RawPackedDotAbsent x86RawPackedDotEncoding = iota
+	x86RawPackedDotVEX
+	x86RawPackedDotEVEX
+)
+
+type x86RawPackedDotIdentity struct {
+	arch     string
+	encoding x86RawPackedDotEncoding
+	encoded  bool
+}
+
+func x86PackedDotRawIdentity(ins Instr, arch string) x86RawPackedDotIdentity {
+	if _, known, err := x86PackedDotProperties(ins.Op, ins, arch); !known || err != nil ||
+		ins.x86PackedDotEncoding != x86RawPackedDotVEX && ins.x86PackedDotEncoding != x86RawPackedDotEVEX {
+		return x86RawPackedDotIdentity{}
+	}
+	return x86RawPackedDotIdentity{arch, ins.x86PackedDotEncoding, ins.x86Encoded}
+}
+
+func x86RawPackedDotSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedDotProperties(ins.Op, ins, arch)
+	return known && err == nil && ins.x86SourceRaw != nil &&
+		ins.x86SourceRaw.packedDot.arch == arch &&
+		ins.x86SourceRaw.packedDot == x86PackedDotRawIdentity(ins, arch) &&
+		x86Mode32VectorRegisterContext(ins, arch) == nil &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
+
+// Select the restriction from the immutable decoded source before any strict
+// numerical success; deleting a mutable origin cannot invent a named source.
+func x86PackedDotRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay != nil {
+		for _, ins := range fn.x86RawReplay.decoded {
+			if _, known, _ := x86PackedDotProperties(ins.Op, ins, arch); known {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func x86ResultPackedDotStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedDotProperties(ins.Op, ins, arch)
+	if !known || err != nil || x86Mode32VectorRegisterContext(ins, arch) != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawPackedDotSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	} else if ins.x86PackedDotEncoding != x86RawPackedDotAbsent {
+		return false, true // A named source cannot invent a decoder generation.
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	var first uint64
+	if source := ins.Args[form.first]; source.Kind == OpReg {
+		index, _ := amd64VectorRegisterIndex(source.Reg, form.byteWidth)
+		first = state.vectorBytes(index)
+	} else {
+		if !x86ResultReadWithNativeContinuation(ins, source, int64(form.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+		first = ^uint64(0) // Conditional input bytes, never a later memory fact.
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if !form.inputsDefined(first, state.vectorBytes(second), state.vectorBytes(destination)) {
+		return false, true
+	}
+	state.writeVector(destination, form.byteWidth, x86CallerVectorByteMask(int64(form.byteWidth)), false)
+	return true, true // FLAGS, DF, masks, pointers and storage are unchanged.
+}
+
+func x86CallerPackedDotStep(ins *Instr, form x86PackedDotForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if !x86ResultNamedPredicateInstruction(*ins) {
+		return false // Raw source has no inherited caller capability.
+	}
+	if form.mask >= 0 && !state.masks[ins.Args[form.mask].Reg] {
+		return false
+	}
+	first := ^uint64(0)
+	if form.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, int64(form.memoryBytes), false) {
+			return false
+		}
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)]
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)]
+	destination := x86CallerVectorRoot(ins.Args[form.destination].Reg)
+	if !form.inputsDefined(first, second, state.vectors[destination]) {
+		return false
+	}
+	state.vectors[destination] = ^uint64(0)
+	return true
+}
diff --git a/x86_result_packed_float_shuffle.go b/x86_result_packed_float_shuffle.go
new file mode 100644
index 000000000..e813a4a69
--- /dev/null
+++ b/x86_result_packed_float_shuffle.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+// The standalone observer supplies no native input or raw producer permission.
+// The lowering-paired observer consumes the exact unconditional E4NF tuple;
+// continuing past the original access establishes no future memory validity.
+func x86ResultPackedFloatShuffleStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86PackedFloatShuffleProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	var first uint64
+	if f.memory >= 0 {
+		source := ins.Args[f.first]
+		if f.legacy && source.Kind == OpFP ||
+			!x86ResultReadWithNativeContinuation(ins, source, int64(f.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(f.memoryBytes))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[f.first].Reg, f.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[f.second].Reg, f.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	defined := f.definedBytes(first, state.vectorBytes(second), state.vectorBytes(destination))
+	if f.memory >= 0 && native && defined != x86CallerVectorByteMask(int64(f.byteWidth)) {
+		return false, true // Dead native reads cannot invent selected/merging input bytes.
+	}
+	state.writeVector(destination, f.byteWidth, defined, f.legacy)
+	return true, true
+}
+
+func x86CallerPackedFloatShuffleStep(ins *Instr, f x86PackedFloatShuffleForm, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if !x86ResultNamedPredicateInstruction(*ins) || f.mask >= 0 && !state.masks[ins.Args[f.mask].Reg] {
+		return false
+	}
+	var first uint64
+	if f.memory >= 0 {
+		// A caller slice has no legacy m128 alignment promise. A mask or
+		// selector never reduces the separately checked full native tuple.
+		if f.legacy || !x86CallerOrdinaryMemoryStep(ins, f.memory, state, proof, int64(f.memoryBytes), false) {
+			return false
+		}
+		first = x86CallerVectorByteMask(int64(f.memoryBytes))
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[f.first].Reg)]
+	}
+	destination := x86CallerVectorRoot(ins.Args[f.destination].Reg)
+	old := state.vectors[destination]
+	defined := f.definedBytes(first, state.vectors[x86CallerVectorRoot(ins.Args[f.second].Reg)], old)
+	upper := ^x86CallerVectorByteMask(int64(f.byteWidth))
+	if f.legacy {
+		upper &= old
+	}
+	state.vectors[destination] = upper | defined
+	return true
+}
diff --git a/x86_result_packed_logical_store.go b/x86_result_packed_logical_store.go
new file mode 100644
index 000000000..4d323d7ff
--- /dev/null
+++ b/x86_result_packed_logical_store.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+// Cost routing only. The complete source proof and the existing move grammar
+// still decide initialization, typed storage, masks and native alignment.
+func x86LogicalPackedFPStoreBytes(ins Instr, arch string) int64 {
+	if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known {
+		if err == nil && form.memoryWrite && ins.Args[form.destination].Kind == OpFP {
+			return int64(form.byteWidth)
+		}
+		return 0
+	}
+	if form, known, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch); known && err == nil &&
+		form.memoryWrite && form.destination.Kind == OpFP {
+		return 16
+	}
+	return 0
+}
+
+// The emitter already scatters these stores into private logical parameter and
+// result fields. Account for the same writes without treating a parameter copy
+// as caller storage. Every touched byte must be a unique numeric field, never a
+// pointer, bool, hole or TEXT allocation padding. Aligned forms stay separate.
+func (c *amd64Ctx) scalarPackedLogicalFPWriteTransfer(ins Instr, state *x86ResultState,
+	owned []bool, arch string) (bool, bool) {
+	width := x86LogicalPackedFPStoreBytes(ins, arch)
+	if width == 0 {
+		return false, false
+	}
+	offset := ins.Args[len(ins.Args)-1].FPOffset
+	if offset < 0 || offset > 4096-width {
+		return false, true
+	}
+	for position := int64(0); position < width; position += 8 {
+		if _, err := c.scalarFPSpan(offset+position, 64); err != nil {
+			return false, true
+		}
+	}
+	if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known {
+		return err == nil && x86ResultPackedVectorMoveTransfer(ins, form, state, owned, 0, arch, false), true
+	}
+	form, _, err := x86LegacyPackedMoveProperties(ins.Op, ins, arch)
+	return err == nil && !form.aligned && x86ResultTransfer(ins, state, owned, 0, arch), true
+}
diff --git a/x86_result_packed_narrow.go b/x86_result_packed_narrow.go
new file mode 100644
index 000000000..4715d1442
--- /dev/null
+++ b/x86_result_packed_narrow.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+// A partial numerical source defines only its independently computed output
+// elements. Memory always retains the complete E4NF/.nb source tuple, even
+// when a result is discarded or its output mask is zero.
+func x86ResultPackedNarrowStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86PackedNarrowProperties(ins, arch)
+	if !known || err != nil || form.mmx {
+		return false, known // Physical MMX/x87 remains an independent entry role.
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	var first uint64
+	if form.memory >= 0 {
+		// Logical FP/AUTO bytes cannot prove native legacy m128 alignment.
+		_, static := x86StaticSBReadAddress(form.source, arch)
+		if form.legacy && !static && !nativeRead {
+			return false, true
+		}
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, form.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	defined := x86PackedNarrowDefinedBytes(form, first, state.vectorBytes(second), state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true // No FLAGS/DF, mask or memory facts change.
+}
diff --git a/x86_result_packed_narrow_test.go b/x86_result_packed_narrow_test.go
new file mode 100644
index 000000000..da994ba24
--- /dev/null
+++ b/x86_result_packed_narrow_test.go
@@ -0,0 +1,147 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent ymm/yxm_q4 and _yvandnpd families, including each opcode's
+// separate N4 broadcast attribute. Neither inventory reads production specs.
+func x86NarrowValueRows(arch string) []struct{ op, bank, mode string } {
+	rows := x86FixedBinaryValueRows(arch, []string{
+		"PACKSSLW", "PACKSSWB", "PACKUSDW", "PACKUSWB",
+		"VPACKSSDW", "VPACKSSWB", "VPACKUSDW", "VPACKUSWB",
+	})
+	broadcast := x86FixedBinaryValueRows(arch, []string{"VPACKSSDW", "VPACKUSDW"})
+	for _, row := range broadcast {
+		row.op += ".BCST"
+		rows = append(rows, row)
+	}
+	return rows
+}
+
+func TestX86PackedNarrowValueCompleteFamilyFiveTargetsThreeAPIs(t *testing.T) {
+	for batch := 0; batch < 2; batch++ {
+		t.Run(fmt.Sprint(batch), func(t *testing.T) {
+			x86FixedBinaryCompleteFamilyObjects(t, func(arch string) []struct{ op, bank, mode string } {
+				rows := x86NarrowValueRows(arch)
+				want := 58
+				if arch == "386" {
+					want = 22
+				}
+				if len(rows) != want {
+					t.Fatal("complete independent narrow denominator changed", len(rows), want)
+				}
+				return rows[batch*want/2 : (batch+1)*want/2]
+			}, 29, 11)
+		})
+	}
+}
+
+// Discarded numerical bytes may stay unknown. An actual native address,
+// mask or result byte still cannot be borrowed from implementation slots.
+func TestX86PackedNarrowVoidCannotInventMaskOrMemoryInputs(t *testing.T) {
+	for _, row := range x86NarrowValueRows("amd64") {
+		source, declaration := x86FixedBinaryValueFixture("amd64", row.op, row.bank, row.mode, false)
+		variants := map[string]string{
+			"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+			"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+		}
+		if row.mode != "plain" {
+			variants["unknown-mask"] = strings.Replace(source, "KMOVQ CX,K1\n", "", 1)
+		}
+		for name, changed := range variants {
+			t.Run(row.op+"/"+row.bank+"/"+row.mode+"/"+name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+						t.Fatal("complete independent Void control rejected", api, err)
+					}
+					if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Error("Void narrow acquired a missing native address or mask", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86PackedNarrowNativeInputsStayIndependent(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, x86NarrowValueRows)
+}
+
+func TestX86PackedNarrowResultEveryOutputByteKeepsExactDependencies(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86NarrowValueRows(arch) {
+			if strings.Contains(row.op, ".") {
+				continue // Broadcast's complete memory tuple has its own matrix.
+			}
+			op, operands := row.op, "X0,X1"
+			legacy := !strings.HasPrefix(op, "V")
+			if !legacy {
+				operands = row.bank + "0," + row.bank + "1,"
+				if row.mode != "plain" {
+					operands += "K1,"
+				}
+				operands += row.bank + "2"
+				if row.mode == "zero" {
+					op += ".Z"
+				}
+			}
+			t.Run(arch+"/"+op+" "+operands, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" "+operands)
+				width, destination := amd64VectorByteWidth(Reg(row.bank+"0")), 2
+				if legacy {
+					destination = 1
+				}
+				inputBytes := 2
+				if strings.HasSuffix(row.op, "DW") || row.op == "PACKSSLW" {
+					inputBytes = 4
+				}
+				for _, first := range []uint64{0, 1, 3, 15, 0xffff, 0xff00ff00ff00ff00, ^uint64(0)} {
+					for _, second := range []uint64{0, 7, 0xffff, 0x5555555555555555, ^uint64(0)} {
+						old := uint64(0xaaaaaaaaaaaaaaaa)
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						for index, bits := range []uint64{first, second, old} {
+							state.xmm[index], state.vectorUpper[index] = uint16(bits), bits&^0xffff
+						}
+						state.masks[1] = true
+						if legacy {
+							old = second
+						}
+						// An output element depends on every byte of exactly one
+						// signed input element, independently in each 128-bit lane.
+						var want uint64
+						for output := 0; output < width; output += inputBytes / 2 {
+							chunk, local := output/16*16, output%16
+							input, source := chunk+(local%8)/(inputBytes/2)*inputBytes, second
+							if local >= 8 {
+								source = first
+							}
+							needed := uint64(1<<uint(inputBytes)-1) << uint(input)
+							if source&needed == needed {
+								want |= uint64(1<<uint(inputBytes/2)-1) << uint(output)
+							}
+						}
+						if row.mode == "merge" {
+							want &= old
+						}
+						active := x86CallerVectorByteMask(int64(width))
+						if legacy {
+							want |= old &^ active
+						} else {
+							want |= ^active
+						}
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("complete typed narrow has no result dependency consumer")
+						}
+						if got := state.vectorBytes(destination); got != want || state.flags != x86ByteFlagsAll {
+							t.Fatalf("first=%x second=%x got=%x want=%x flags=%x", first, second, got, want, state.flags)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_packed_precision.go b/x86_result_packed_precision.go
new file mode 100644
index 000000000..40f4982e8
--- /dev/null
+++ b/x86_result_packed_precision.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+type x86RawPackedPrecisionIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86PackedPrecisionRawIdentity(ins Instr, arch string) x86RawPackedPrecisionIdentity {
+	if _, known, err := x86PackedPrecisionProperties(ins.Op, ins, arch); !known || err != nil {
+		return x86RawPackedPrecisionIdentity{}
+	}
+	return x86RawPackedPrecisionIdentity{arch, ins.x86Encoded, ins.x86PackedPrecisionEVEX}
+}
+
+func x86RawPackedPrecisionSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	return origin != nil && ins.x86Encoded && origin.packedPrecision.arch == arch &&
+		origin.packedPrecision == x86PackedPrecisionRawIdentity(ins, arch) && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86PackedPrecisionRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay != nil {
+		for _, ins := range fn.x86RawReplay.decoded {
+			if _, known, _ := x86PackedPrecisionProperties(ins.Op, ins, arch); known {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// Both actual source bytes and possible old active output bytes precede the
+// single write. Upper carrier zeros do not read old bytes; CF/DF/ID, pointers
+// and storage remain independent. Raw continuation is paired and source-bound.
+func x86ResultPackedPrecisionStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedPrecisionProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawPackedPrecisionSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultPackedConversionInputs(ins, form, state, owned, arch, native), true
+}
diff --git a/x86_result_packed_reduction.go b/x86_result_packed_reduction.go
new file mode 100644
index 000000000..40956831c
--- /dev/null
+++ b/x86_result_packed_reduction.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+type x86RawPackedReductionIdentity struct {
+	arch    string
+	encoded bool
+}
+
+func x86PackedReductionRawIdentity(ins Instr, arch string) x86RawPackedReductionIdentity {
+	local := ins
+	// The sole caller that creates this snapshot has already decoded actual
+	// whole-source bytes. A raw physical dot can have four operands in mode32;
+	// this does not alter the separate named frontend's three-operand limit.
+	local.x86Encoded = true
+	if _, known, err := x86PackedReductionProperties(local, arch); !known || err != nil {
+		return x86RawPackedReductionIdentity{}
+	}
+	return x86RawPackedReductionIdentity{arch: arch, encoded: ins.x86Encoded}
+}
+
+// This consumes numerical bytes only. The paired whole opcode performs its
+// full native read and exceptions even for imm=0 or a dead/zeroed result.
+// It creates no pointer, backing, alignment, caller or later-read authority.
+func x86ResultPackedReductionStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86PackedReductionProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	return x86ResultPackedReductionInputs(ins, form, state, owned, arch, native), true
+}
+
+func x86ResultPackedReductionInputs(ins Instr, form x86PackedReductionForm, state *x86ResultState, owned []bool, arch string, native bool) bool {
+	required := form.inputBytes()
+	for _, index := range []int{form.first, form.second} {
+		operand := ins.Args[index]
+		if index == form.memory {
+			if form.legacy && operand.Kind == OpFP ||
+				!x86ResultReadWithNativeContinuation(ins, operand, int64(form.byteWidth), state, owned, arch, native) {
+				return false
+			}
+		} else {
+			register, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+			if !valid || state.vectorBytes(register)&required != required {
+				return false
+			}
+		}
+	}
+	destination, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if !valid {
+		return false
+	}
+	state.writeVector(destination, form.byteWidth, x86CallerVectorByteMask(int64(form.byteWidth)), form.legacy)
+	return true
+}
+
+func x86RawPackedReductionSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedReductionProperties(ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && origin != nil && origin.packedReduction.arch == arch &&
+		origin.packedReduction == x86PackedReductionRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
+
+func x86LoweredRawPackedReductionStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86PackedReductionProperties(ins, arch)
+	if !known || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if err != nil || !x86RawPackedReductionSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultPackedReductionInputs(local, form, state, owned, arch, true), true
+}
diff --git a/x86_result_packed_string.go b/x86_result_packed_string.go
new file mode 100644
index 000000000..526f9b66e
--- /dev/null
+++ b/x86_result_packed_string.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+// All eight string-compare names share the emitter's complete imm8/X/m128/X
+// grammar. Both X inputs are read before the implicit CX/X0 overwrite. Even
+// explicit zero lengths do not shrink the architectural 128-bit memory input.
+// This observer grants no pointee, alignment, caller or native-entry authority.
+func x86ResultPackedStringStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultPackedStringStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultPackedStringStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	spec, known, err := amd64PackedStringCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if spec.explicitLength && (!x86ResultRead(Operand{Kind: OpReg, Reg: AX}, 4, state, owned, arch) ||
+		!x86ResultRead(Operand{Kind: OpReg, Reg: DX}, 4, state, owned, arch)) {
+		return false, true
+	}
+	if !x86ResultRead(ins.Args[2], 16, state, owned, arch) ||
+		!x86ResultReadWithNativeContinuation(ins, ins.Args[1], 16, state, owned, arch, nativeRead) {
+		return false, true
+	}
+	output, width, zeroUpper := spec.resultEffect()
+	if spec.maskResult {
+		index, _ := amd64ParseXReg(output)
+		state.writeVector(index, width, 0xffff, !zeroUpper)
+	} else {
+		index, _, _ := x86ResultGP(output, int64(width), arch)
+		state.gp[index] = 0xff // Architectural r32 write zero-extends the GP alias.
+		state.canonicalGP[index] = 0
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		state.callerAddressOrigin[index] = 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	state.flags = x86ByteFlagsAll // CF/ZF/SF/OF defined, PF/AF zero; never DF.
+	state.bitScanPending = x86ResultBitScanPending{}
+	state.predicate = x86ResultPredicate{}
+	return true, true
+}
diff --git a/x86_result_packed_string_object_test.go b/x86_result_packed_string_object_test.go
new file mode 100644
index 000000000..fa17890f7
--- /dev/null
+++ b/x86_result_packed_string_object_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86PackedStringResultObjectFixture(arch string) (string, string) {
+	move, word := "MOVQ", 8
+	if arch == "386" {
+		move, word = "MOVL", 4
+	}
+	var source, declarations strings.Builder
+	for _, row := range go127PackedStringCompareSpecs() {
+		for _, role := range []string{"register", "native", "dead-native"} {
+			name := strings.ToLower(row.op) + strings.ReplaceAll(role, "-", "")
+			fmt.Fprintf(&declarations, "func %s(p *byte) uint32\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nPXOR X0,X0\nPXOR X1,X1\nMOVL $0,AX\nMOVL $0,DX\n", name, word+4)
+			operand := "X0"
+			if role != "register" {
+				fmt.Fprintf(&source, "%s p+0(FP),DI\n", move)
+				operand = "1(DI)"
+			}
+			fmt.Fprintf(&source, "%s $12,%s,X1\n", row.op, operand)
+			if role == "dead-native" {
+				source.WriteString("MOVL $7,AX\n")
+			} else if row.mask {
+				source.WriteString("MOVL X0,AX\n")
+			} else {
+				source.WriteString("MOVL CX,AX\n")
+			}
+			fmt.Fprintf(&source, "MOVL AX,ret+%d(FP)\nRET\n", word)
+		}
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86PackedStringNumericalCompleteFiveTargetGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete packed-string numerical objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86PackedStringResultObjectFixture(target.arch)
+			if strings.Count(source, "TEXT ·") != 24 {
+				t.Fatal("complete eight-name/three-role source inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "load volatile <16 x i8>") != 16 {
+						t.Fatal("complete original numerical/read inventory changed", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						if strings.Count(input, "load volatile <16 x i8>") != 16 {
+							t.Fatal("full native dead/zero-length source reads lost before objects")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) { x86PackedStringCompileObject(t, llc, target.triple, input, level) })
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_packed_string_sdk_go127_test.go b/x86_result_packed_string_sdk_go127_test.go
new file mode 100644
index 000000000..028119e59
--- /dev/null
+++ b/x86_result_packed_string_sdk_go127_test.go
@@ -0,0 +1,119 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"go/types"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestGoX86PackedStringOriginalSDKIndexCompleteSourceThreeAPIs(t *testing.T) {
+	goX86PackedStringOriginalSDKIndexComplete(t, false)
+}
+
+func TestGoX86PackedStringOriginalSDKIndexCompleteSourceLLVM22Objects(t *testing.T) {
+	goX86PackedStringOriginalSDKIndexComplete(t, true)
+}
+
+// Each root owns a fresh complete source/CPU producer and its original stage
+// deadline. Object work cannot consume the source-only owner's five minutes.
+func goX86PackedStringOriginalSDKIndexComplete(t *testing.T, objects bool) {
+	llc := ""
+	if objects {
+		llc = findLLVM22Tool("llc")
+		if llc == "" {
+			t.Fatal("LLVM 22 llc is required for complete original SDK objects")
+		}
+	}
+	ctx, request, metadata, _ := numericalSDKAssemblyFixture(t)
+	request.AssemblyFile = "index_amd64.s"
+	source, err := CaptureGoX86SDKNumericalReadSource(ctx, request)
+	if err != nil {
+		t.Fatal("actual complete SDK source/CPU/compiler precondition", err)
+	}
+	defer closeNumericalConsumerSource(t, source)
+	pkg, _, _ := numericalSDKOriginalTypedPackage(t, metadata, request.AssemblyFile)
+	sizes := types.SizesFor("gc", "amd64")
+	file := source.file
+	if len(file.Funcs) != 3 || len(file.Data) != 0 || len(file.Globl) != 0 {
+		t.Fatal("complete original three-TEXT member changed")
+	}
+	resolve := func(symbol string) string { return numericalNativeName(goTextSymbolForResolution(symbol), pkg.Path) }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", sizes, sizes, nil)
+	if err != nil {
+		t.Fatal("complete actual SDK declarations and private graph inventory", err)
+	}
+	options := Options{Goarch: "amd64", TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: resolve, Sigs: sigs}
+	bound, err := source.BindNumericalReads(ctx, pkg, file, options)
+	if err != nil {
+		t.Fatal("original CPU/read/source join", err)
+	}
+	original, err := os.ReadFile(filepath.Join(request.Directory, request.AssemblyFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	objectCount := 0
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			// Dispose every module/context before creating object artifacts.
+			// Both object axes consume this unchanged complete original IR.
+			ir, result := func() (string, error) {
+				if api == "text" {
+					return Translate(file, bound)
+				}
+				context := llvm.NewContext()
+				defer context.Dispose()
+				var module llvm.Module
+				var result error
+				if api == "module" {
+					module, result = TranslateModuleInContext(context, file, bound)
+				} else {
+					var translated *GoModuleTranslation
+					translated, result = translateGoModuleInContext(context, pkg, original, GoModuleOptions{GOOS: "linux", GOARCH: "amd64", TargetTriple: bound.TargetTriple,
+						FileName: request.AssemblyFile, ResolveSym: bound.ResolveSym, NumericalReads: bound.NumericalReads})
+					if translated != nil {
+						module = translated.Module
+					}
+				}
+				if !module.IsNil() {
+					defer module.Dispose()
+					return module.String(), result
+				}
+				return "", result
+			}()
+			if result != nil {
+				t.Fatal("complete unchanged original SDK source must translate successfully", result)
+			}
+			if ir == "" || strings.Count(ir, "load volatile <16 x i8>") < 2 {
+				t.Fatal("complete original full m128 reads missing")
+			}
+			t.Log("complete unchanged SDK numerical/IR source succeeded")
+			if objects {
+				for _, optimizeIR := range []bool{false, true} {
+					input, label := ir, "IR-original"
+					if optimizeIR {
+						input, label = x86MulDivRoundOptimize(t, ir), "IR-O2"
+					}
+					for _, backend := range []string{"-O0", "-O2"} {
+						t.Run(label+"/backend"+backend, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, bound.TargetTriple, input, backend)
+							objectCount++
+						})
+					}
+				}
+			}
+		})
+	}
+	if objects && objectCount != 12 {
+		t.Fatal("complete three-API/IR/backend object denominator changed", objectCount)
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("original complete source changed after all consumers", err)
+	}
+	t.Logf("complete unchanged SDK source: LLVM objects=%d; no native execution claim", objectCount)
+}
diff --git a/x86_result_packed_string_test.go b/x86_result_packed_string_test.go
new file mode 100644
index 000000000..3760714d8
--- /dev/null
+++ b/x86_result_packed_string_test.go
@@ -0,0 +1,303 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultPackedStringCompleteRegisterDependenciesAndEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range go127PackedStringCompareSpecs() {
+			for _, registers := range []string{"X0,X1", "X1,X0", "X0,X0", "X1,X1", "X7,X6"} {
+				t.Run(arch+"/"+row.op+"/"+registers, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, row.op+" $12,"+registers)
+					initial := x86ResultState{flags: x86ByteFlagCF, direction: x86ResultDirectionBackward}
+					for index := range initial.xmm {
+						initial.xmm[index] = 0xffff
+						initial.vectorUpper[index] = 0x123456780000
+					}
+					initial.gp[0], initial.gp[2] = 0x0f, 0x0f // Only the declared low32 length views.
+					initial.canonicalGP[1] = 0xff
+					initial.pointerGP[1], initial.callerAddressGP[1], initial.callerAddressOrigin[1] = true, true, 1
+					initial.resultAddressGP[1] = x86ResultSlotAddress{start: 8, end: 16, valid: true}
+					initial.predicate = x86ResultPredicate{kind: x86ResultNonzeroMaskGP, register: 1, width: 16}
+					for _, missing := range []struct {
+						role  string
+						count int
+					}{{"none", 1}, {"source", 16}, {"left", 16}, {"AX", 4}, {"DX", 4}} {
+						for byteIndex := 0; byteIndex < missing.count; byteIndex++ {
+							state := initial.clone()
+							if missing.role == "source" || missing.role == "left" {
+								arg := 1
+								if missing.role == "left" {
+									arg = 2
+								}
+								index, _ := amd64ParseXReg(ins.Args[arg].Reg)
+								state.xmm[index] &^= 1 << uint(byteIndex)
+							} else if missing.role == "AX" {
+								state.gp[0] &^= 1 << uint(byteIndex)
+							} else if missing.role == "DX" {
+								state.gp[2] &^= 1 << uint(byteIndex)
+							}
+							before := state.clone()
+							accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+							want := missing.role == "none" || !row.explicit && (missing.role == "AX" || missing.role == "DX")
+							if accepted != want {
+								t.Fatal("packed-string dependency was omitted or widened", missing.role, byteIndex, accepted, want)
+							}
+							if !want {
+								if !reflect.DeepEqual(before, state) {
+									t.Fatal("rejected input mutated output knowledge")
+								}
+								continue
+							}
+							if state.flags != x86ByteFlagsAll || state.direction != before.direction || state.predicate != (x86ResultPredicate{}) {
+								t.Fatal("status effects borrowed DF or retained a stale predicate")
+							}
+							if row.mask {
+								wantUpper := before.vectorUpper[0]
+								if row.vector {
+									wantUpper = ^uint64(0xffff)
+								}
+								if state.xmm[0] != 0xffff || state.vectorUpper[0] != wantUpper || state.gp != before.gp || state.pointerGP != before.pointerGP {
+									t.Fatal("X0 mask result lost its exact legacy/VEX alias footprint")
+								}
+							} else if state.gp[1] != 0xff || state.canonicalGP[1] != 0 || state.pointerGP[1] || state.callerAddressGP[1] || state.callerAddressOrigin[1] != 0 || state.resultAddressGP[1].valid || state.xmm != before.xmm || state.vectorUpper != before.vectorUpper {
+								t.Fatal("index output retained address/canonical authority or lost zero extension")
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedStringPlainIndexNoProbeRequiresWholeSource(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"PCMPESTRI", "PCMPISTRI", "VPCMPESTRI", "VPCMPISTRI"} {
+			for _, known := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/known=%t", arch, op, known), func(t *testing.T) {
+					declaration := "func view() uint32\n"
+					body := op + " $12,X0,X1\nMOVL CX,ret+RESULT(FP)"
+					if known {
+						body = "PXOR X0,X0\nPXOR X1,X1\nMOVL $3,AX\nMOVL $7,DX\n" + body
+					}
+					// No extra GP/X move or BSF probe can hide a missed cost gate.
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					if arch == "amd64" && !known && !strings.Contains(op, "ESTR") {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, "x86_64-unknown-linux-gnu", api)
+								x86VectorScratchCodegenControl(t, source, declaration, arch, "x86_64-unknown-linux-gnu", ir, err)
+							})
+						}
+					} else {
+						x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, known)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedStringWholeFamilyThreeAPIsStatusAndMask(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range go127PackedStringCompareSpecs() {
+			for _, missing := range []string{"none", "source", "left", "AX", "DX"} {
+				t.Run(arch+"/"+row.op+"/"+missing, func(t *testing.T) {
+					body := "PXOR X0,X0\nPXOR X1,X1\nMOVL $3,AX\nMOVL $7,DX\n"
+					if missing == "source" {
+						body = strings.Replace(body, "PXOR X0,X0\n", "", 1)
+					}
+					if missing == "left" {
+						body = strings.Replace(body, "PXOR X1,X1\n", "", 1)
+					}
+					if missing == "AX" {
+						body = strings.Replace(body, "MOVL $3,AX\n", "", 1)
+					}
+					if missing == "DX" {
+						body = strings.Replace(body, "MOVL $7,DX\n", "", 1)
+					}
+					body += row.op + " $12,X0,X1\n"
+					if row.mask {
+						body += "MOVL X0,AX\n"
+					} else {
+						body += "MOVL CX,AX\n"
+					}
+					// A complete six-status result must be preserved by DF setters.
+					body += "SETCS BL\nMOVBLZX BL,BX\nADDL BX,AX\nMOVL AX,ret+RESULT(FP)"
+					declaration := "func view() uint32\n"
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					if arch == "amd64" && (missing == "source" || missing == "left") {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, "x86_64-unknown-linux-gnu", api)
+								x86VectorScratchCodegenControl(t, source, declaration, arch, "x86_64-unknown-linux-gnu", ir, err)
+							})
+						}
+					} else {
+						x86ResultGPSIMDAdmissionAPIs(t, arch, source, declaration, missing == "none" || !row.explicit && (missing == "AX" || missing == "DX"))
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedStringPublicMemoryDoesNotAcquirePointeeBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range go127PackedStringCompareSpecs() {
+			state := x86ResultState{}
+			state.xmm[1], state.gp[0], state.gp[2], state.pointerGP[7] = 0xffff, 0x0f, 0x0f, true
+			ins := x86ScalarLaneInstruction(t, row.op+" $12,(DI),X1")
+			if x86ResultTransfer(ins, &state, nil, 0, arch) {
+				t.Fatal("descriptor gave an initialized pointer its full m128 input")
+			}
+		}
+	}
+}
+
+func TestX86PackedStringPairedNativeReadAndDeadOutputStayFullWidth(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, row := range go127PackedStringCompareSpecs() {
+			for _, dead := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/dead=%t", arch, row.op, dead), func(t *testing.T) {
+					declaration := "func view(p *byte) uint32\n"
+					body := move + " p+0(FP),DI\nPXOR X1,X1\nMOVL $0,AX\nMOVL $0,DX\n" + row.op + " $12,1(DI),X1\n"
+					if dead {
+						body += "MOVL $7,AX\n"
+					} else if row.mask {
+						body += "MOVL X0,AX\n"
+					} else {
+						body += "MOVL CX,AX\n"
+					}
+					body += "MOVL AX,ret+RESULT(FP)"
+					source := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					pkg := mustGoPackage(t, "bitview", "package bitview\n"+declaration)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+					sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+					if err != nil {
+						t.Fatal(err)
+					}
+					for _, query := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+						if err := query(file.Funcs[0], sigs["view"], arch); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("declaration alone supplied native pointee bytes", err)
+						}
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if err != nil || strings.Count(ir, "load volatile <16 x i8>") != 1 || !strings.Contains(ir, ", align 1") || strings.Contains(ir, "dereferenceable") {
+								t.Fatal("paired full unaligned m128 read was erased/shrunk or lent bounds", err)
+							}
+							optimized := x86UndefinedTrapOptimizedIR(t, ir)
+							if strings.Count(optimized, "load volatile <16 x i8>") != 1 {
+								t.Fatal("O2 discarded the original full read, including zero-length/dead-output cases")
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PackedStringStrictWidthsImmediateAndRawResultRoles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range go127PackedStringCompareSpecs() {
+			for _, operand := range []string{"$256,X0,X1", "$-129,X0,X1", "$0.0,X0,X1", "$1,Y0,X1", "$1,X0,Y1", "$1,M0,X1", "$1,X0,X16", "$1,X0,(DI)", "$1,X0,X1,X2"} {
+				ins := x86ScalarLaneInstruction(t, row.op+" "+operand)
+				state := x86ResultState{}
+				if accepted, known := x86ResultPackedStringStep(ins, &state, nil, arch); accepted || !known {
+					t.Fatal("malformed vector-width/immediate/result role passed", arch, row.op, operand)
+				}
+			}
+			for _, tail := range []string{"", ".Z"} {
+				for _, immediate := range []int{-128, -1, 0, 127, 255} {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s%s $%d,X0,X1", row.op, tail, immediate))
+					state := x86ResultState{}
+					state.xmm[0], state.xmm[1], state.gp[0], state.gp[2] = 0xffff, 0xffff, 0xf, 0xf
+					want := tail == "" && (row.vector || immediate >= 0)
+					if accepted, known := x86ResultPackedStringStep(ins, &state, nil, arch); !known || accepted != want {
+						t.Fatal("complete Yu8/Yi8 distinction changed", arch, row.op, immediate, tail)
+					}
+				}
+			}
+			for _, mutate := range []func(*Instr){
+				func(ins *Instr) { ins.x86Encoded = true },
+				func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{} },
+				func(ins *Instr) { ins.x86AddressBits = 32 },
+				func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+				func(ins *Instr) { ins.x86SegmentPrefix = 1 },
+			} {
+				ins := x86ScalarLaneInstruction(t, row.op+" $12,X0,X1")
+				mutate(&ins)
+				state := x86ResultState{}
+				state.xmm[0], state.xmm[1], state.gp[0], state.gp[2] = 0xffff, 0xffff, 0xf, 0xf
+				before := state.clone()
+				if accepted, known := x86ResultPackedStringStepWithRead(ins, &state, nil, arch, true); accepted || !known || !reflect.DeepEqual(before, state) {
+					t.Fatal("named transfer lent an encoded/source-entry role")
+				}
+			}
+		}
+	}
+}
+
+func TestX86PackedStringFullFPAndLoweredMemoryBytesRemainIndependent(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range go127PackedStringCompareSpecs() {
+			for _, extent := range []int{0, 1, 8, 15, 16} {
+				state := x86ResultState{fp: make([]bool, 16)}
+				owned := make([]bool, 16)
+				for index := range owned {
+					owned[index] = true
+					state.fp[index] = index < extent
+				}
+				state.xmm[1], state.gp[0], state.gp[2] = 0xffff, 0xf, 0xf
+				ins := x86ScalarLaneInstruction(t, row.op+" $12,input+0(FP),X1")
+				if accepted, known := x86ResultPackedStringStep(ins, &state, owned, arch); !known || accepted != (extent == 16) {
+					t.Fatal("m128 became a shortened independent FP read", arch, row.op, extent)
+				}
+			}
+			for _, pointer := range []bool{false, true} {
+				state := x86ResultState{}
+				state.xmm[1], state.gp[0], state.gp[2], state.pointerGP[7] = 0xffff, 0xf, 0xf, pointer
+				ins := x86ScalarLaneInstruction(t, row.op+" $12,(DI),X1")
+				before := state.clone()
+				if accepted, known := x86ResultPackedStringStepWithRead(ins, &state, nil, arch, true); !known || accepted != pointer {
+					t.Fatal("private paired read fabricated an unknown address", arch, row.op, pointer)
+				}
+				if !pointer && !reflect.DeepEqual(before, state) {
+					t.Fatal("failed native address attempt mutated knowledge")
+				}
+			}
+			for _, memory := range []string{"(SP)", "(BP)", "(DI)(SI*1)", "global(SB)"} {
+				state := x86ResultState{}
+				state.xmm[1], state.gp[0], state.gp[2], state.pointerGP[7] = 0xffff, 0xf, 0xf, true
+				ins := x86ScalarLaneInstruction(t, row.op+" $12,"+memory+",X1")
+				if accepted, known := x86ResultPackedStringStepWithRead(ins, &state, nil, arch, true); accepted || !known {
+					t.Fatal("private memory continuation lent stack/static/segment/uninitialized-index authority", arch, row.op, memory)
+				}
+			}
+			state := x86ResultState{}
+			state.xmm[1], state.gp[0], state.gp[2], state.pointerGP[7] = 0xffff, 0xf, 0xf, true
+			segmented := x86ScalarLaneInstruction(t, row.op+" $12,(DI),X1")
+			segmented.Args[1].Mem.Segment = "FS"
+			if accepted, known := x86ResultPackedStringStepWithRead(segmented, &state, nil, arch, true); accepted || !known {
+				t.Fatal("paired ordinary read borrowed a segment role")
+			}
+		}
+	}
+}
diff --git a/x86_result_parameter_roles.go b/x86_result_parameter_roles.go
new file mode 100644
index 000000000..3934e548b
--- /dev/null
+++ b/x86_result_parameter_roles.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// This checks only the consistency of the supplied parameter observation.
+// Scalar and officially flattened parts are direct arguments; an unflattened
+// part must project its exact scalar leaf through the actual aggregate path.
+// It authenticates no declaration, physical layout, caller or pointee.
+func x86ResultParameterRole(args []LLVMType, slot FrameSlot) (string, bool) {
+	if slot.Index < 0 || slot.Index >= len(args) {
+		return "", false
+	}
+	path := frameSlotFields(slot)
+	leaf := string(args[slot.Index])
+	for _, index := range path {
+		var valid bool
+		leaf, valid = x86ResultAggregateField(leaf, index)
+		if !valid {
+			return "", false
+		}
+	}
+	if LLVMType(leaf) != slot.Type {
+		return "", false
+	}
+	return fmt.Sprintf("%d/%v", slot.Index, path), true
+}
+
+// Go-derived LLVM aggregates are literal structs and arrays. Select only one
+// field, with no allocation proportional to an array's declared length. The
+// nested brace/bracket grammar matters: a comma inside a nested struct is not
+// a sibling field. Named, packed, vector and malformed types grant no leaf.
+func x86ResultAggregateField(typ string, index int) (string, bool) {
+	typ = strings.TrimSpace(typ)
+	if index < 0 || len(typ) < 2 {
+		return "", false
+	}
+	if typ[0] == '[' && typ[len(typ)-1] == ']' {
+		count, element, found := strings.Cut(strings.TrimSpace(typ[1:len(typ)-1]), " x ")
+		if !found || count == "" || strings.TrimSpace(element) == "" {
+			return "", false
+		}
+		for _, digit := range count {
+			if digit < '0' || digit > '9' {
+				return "", false
+			}
+		}
+		n, err := strconv.ParseUint(count, 10, 64)
+		if err != nil || uint64(index) >= n {
+			return "", false
+		}
+		return strings.TrimSpace(element), true
+	}
+	if typ[0] != '{' || typ[len(typ)-1] != '}' {
+		return "", false
+	}
+	inner := typ[1 : len(typ)-1]
+	var stack []byte
+	start, field := 0, 0
+	selected := ""
+	for offset := 0; offset <= len(inner); offset++ {
+		if offset == len(inner) || inner[offset] == ',' && len(stack) == 0 {
+			part := strings.TrimSpace(inner[start:offset])
+			if part == "" {
+				return "", false
+			}
+			if field == index {
+				selected = part
+			}
+			field++
+			start = offset + 1
+			continue
+		}
+		switch inner[offset] {
+		case '{', '[':
+			stack = append(stack, inner[offset])
+		case '}', ']':
+			if len(stack) == 0 || (inner[offset] == '}' && stack[len(stack)-1] != '{') ||
+				(inner[offset] == ']' && stack[len(stack)-1] != '[') {
+				return "", false
+			}
+			stack = stack[:len(stack)-1]
+		}
+	}
+	return selected, len(stack) == 0 && selected != ""
+}
diff --git a/x86_result_parameter_roles_test.go b/x86_result_parameter_roles_test.go
new file mode 100644
index 000000000..0679141ea
--- /dev/null
+++ b/x86_result_parameter_roles_test.go
@@ -0,0 +1,171 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"reflect"
+	"testing"
+)
+
+func x86ResultParameterRoleInstructions(t *testing.T, body string) []Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+body+"\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs
+}
+
+func TestX86ABI0ResultInitializationParameterLeafRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, typ := range []string{"uintptr", "bool", "float32", "float64", "complex64", "complex128",
+			"*uint32", "func()", "map[uint32]uint32", "chan uint32", "string", "[]uint32", "interface{}",
+			"struct{}", "[0]uintptr", "struct{ Z [0]uintptr; N uintptr }", "[2]uintptr",
+			"struct{ P *uint32; N uintptr }", "struct{ A [2]struct{ P *uint32; N uintptr }; S []uint32 }"} {
+			t.Run(arch+"/"+typ, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(x "+typ+") uint32", "RET")
+				file.Funcs[0].Instrs = x86ResultParameterRoleInstructions(t, fmt.Sprintf("MOVL $42,ret0+%d(FP)\nRET", sig.Frame.Results[0].Offset))
+				for _, query := range []struct {
+					name string
+					run  func(Func, FuncSig, string) error
+				}{
+					{"public", CheckX86ABI0ResultInitialization},
+					{"scalar view", checkX86ScalarFPResultInitialization},
+				} {
+					original := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+					if err := query.run(file.Funcs[0], sig, arch); err != nil {
+						t.Fatal(query.name, "actual scalar/aggregate leaf rejected:", err)
+					}
+					if original != fmt.Sprintf("%#v %#v", file.Funcs[0], sig) {
+						t.Fatal("parameter observation rewrote its source/signature")
+					}
+					for index := range sig.Frame.Params {
+						for _, mutation := range []string{"type", "negative index", "past index", "wrong field", "wrong nested field", "duplicate leaf"} {
+							changed := sig
+							changed.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+							changed.Frame.Params[index].Fields = append([]int(nil), sig.Frame.Params[index].Fields...)
+							slot := &changed.Frame.Params[index]
+							switch mutation {
+							case "type":
+								if slot.Type == Ptr {
+									slot.Type = I32
+								} else {
+									slot.Type = Ptr
+								}
+							case "negative index":
+								slot.Index = -1
+							case "past index":
+								slot.Index = len(sig.Args)
+							case "wrong field":
+								slot.Field, slot.Fields = 999, nil
+							case "wrong nested field":
+								slot.Fields = append(append([]int(nil), frameSlotFields(*slot)...), -1)
+							case "duplicate leaf":
+								copySlot := *slot
+								if len(sig.Frame.Params) > 1 {
+									other := (index + 1) % len(sig.Frame.Params)
+									copySlot.Offset = sig.Frame.Params[other].Offset
+									changed.Frame.Params[other] = copySlot
+								} else {
+									copySlot.Offset = sig.Frame.Results[0].Offset
+									changed.Frame.Params = append(changed.Frame.Params, copySlot)
+								}
+							}
+							if err := query.run(file.Funcs[0], changed, arch); err == nil {
+								t.Fatal(query.name, mutation, index, "contradictory parameter acquired entry facts")
+							}
+						}
+					}
+					// The official flattened form has one scalar argument per part,
+					// not one original aggregate argument per source parameter.
+					flat := sig
+					flat.Args = nil
+					flat.Frame.Params = append([]FrameSlot(nil), sig.Frame.Params...)
+					for index := range flat.Frame.Params {
+						slot := &flat.Frame.Params[index]
+						flat.Args = append(flat.Args, slot.Type)
+						slot.Index, slot.Field, slot.Fields = index, -1, nil
+					}
+					if err := query.run(file.Funcs[0], flat, arch); err != nil {
+						t.Fatal(query.name, "valid flattened parts rejected:", err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultInitializationActualNestedNumericalLEA(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		pkg, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(x struct{ A [2]struct{ P *uint32; N uintptr }; S []uint32 }) uint32", "RET")
+		move, lea := "MOVQ", "LEAQ"
+		if arch == "386" {
+			move, lea = "MOVL", "LEAL"
+		}
+		for _, slot := range sig.Frame.Params {
+			if slot.Type == Ptr {
+				continue
+			}
+			body := fmt.Sprintf("%s part+%d(FP),AX\n%s 0(AX*8),CX\nMOVL $42,ret0+%d(FP)\nRET", move, slot.Offset, lea, sig.Frame.Results[0].Offset)
+			file.Funcs[0].Instrs = x86ResultParameterRoleInstructions(t, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+				t.Fatal(arch, slot, err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+				t.Fatal(arch, slot, err)
+			}
+		}
+		actual := pkg.Types.Scope().Lookup("Value").(*types.Func).Type().(*types.Signature)
+		args, slots, _, err := goLLVMArgsAndFrameSlotsForTuple(actual.Params(), arch, types.SizesFor("gc", arch), types.SizesFor("gc", arch), 0, true)
+		if err != nil {
+			t.Fatal(err)
+		}
+		flat := sig
+		flat.Args, flat.Frame.Params = args, slots
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], flat, arch); err != nil {
+			t.Fatal(err)
+		}
+		if reflect.DeepEqual(flat, sig) {
+			t.Fatal("flattened producer control did not change argument roles")
+		}
+	}
+}
+
+func TestX86ResultParameterRoleExactAggregateGrammar(t *testing.T) {
+	for _, row := range []struct {
+		typ   LLVMType
+		path  []int
+		leaf  LLVMType
+		valid bool
+	}{
+		{I64, nil, I64, true},
+		{Ptr, nil, I64, false},
+		{"{ ptr, i64, i64 }", []int{1}, I64, true},
+		{"{ { ptr, i32 }, [2 x { ptr, i64 }] }", []int{1, 1, 1}, I64, true},
+		{"[18446744073709551615 x i64]", []int{3}, I64, true},
+		{"[18446744073709551616 x i64]", []int{3}, I64, false},
+		{"[0 x i64]", []int{0}, I64, false},
+		{"[2 x i64]", []int{2}, I64, false},
+		{"[2 x i64]", []int{-1}, I64, false},
+		{"{ ptr, i64 }", []int{1, 0}, I64, false},
+		{"{ ptr, i64 }", []int{2}, I64, false},
+		{"{ {ptr, i64], i64 }", []int{1}, I64, false},
+		{"{ [2 x i64, i64 }", []int{1}, I64, false},
+		{"{ ptr,, i64 }", []int{2}, I64, false},
+		{"%unbound", []int{0}, I64, false},
+		{"<{ ptr, i64 }>", []int{1}, I64, false},
+		{"<2 x i64>", []int{1}, I64, false},
+		{"[+2 x i64]", []int{1}, I64, false},
+	} {
+		slot := FrameSlot{Index: 0, Type: row.leaf, Field: -1, Fields: row.path}
+		if _, valid := x86ResultParameterRole([]LLVMType{row.typ}, slot); valid != row.valid {
+			t.Fatal(row, "leaf classification", valid)
+		}
+	}
+	// Fields is the existing authoritative nested path; Field is not a second
+	// extraction and may retain the compatibility producer's outer field.
+	slot := FrameSlot{Index: 0, Type: I64, Field: 99, Fields: []int{1, 0}}
+	if _, valid := x86ResultParameterRole([]LLVMType{"{ ptr, [2 x i64] }"}, slot); !valid {
+		t.Fatal("nested path override was changed")
+	}
+}
diff --git a/x86_result_permute128.go b/x86_result_permute128.go
new file mode 100644
index 000000000..10f65f621
--- /dev/null
+++ b/x86_result_permute128.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+type x86RawPermute128Identity struct {
+	arch    string
+	vex     bool
+	encoded bool
+}
+
+func x86Permute128RawIdentity(ins Instr, arch string) x86RawPermute128Identity {
+	if _, known, err := x86Permute128Properties(ins.Op, ins, arch); !known || err != nil ||
+		!ins.x86Permute128VEX || !ins.x86Encoded || ins.x86VectorBytes != 32 {
+		return x86RawPermute128Identity{}
+	}
+	return x86RawPermute128Identity{arch, true, true}
+}
+
+func x86RawPermute128Source(ins Instr, arch string) bool {
+	form, known, err := x86Permute128Properties(ins.Op, ins, arch)
+	return known && err == nil && ins.x86SourceRaw != nil &&
+		ins.x86SourceRaw.permute128.arch == arch &&
+		ins.x86SourceRaw.permute128 == x86Permute128RawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
+
+func x86Permute128RawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay != nil {
+		for _, ins := range fn.x86RawReplay.decoded {
+			if _, known, _ := x86Permute128Properties(ins.Op, ins, arch); known {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// A raw operand gets only a lowering-local projection after exact identity
+// checks. The form was captured before projection, so it cannot borrow Go's
+// named mode32 arity or authorize a standalone/frame/caller/native entry.
+func x86ResultPermute128Step(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86Permute128Properties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawPermute128Source(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	} else if ins.x86Permute128VEX {
+		return false, true // A named source cannot fabricate physical generation.
+	}
+	var first uint64
+	if form.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[form.first], 32, state, owned, arch, native) {
+			return false, true
+		}
+		first = 0xffffffff // No reusable memory or address fact follows.
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, 32)
+		first = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, 32)
+	if !form.inputsDefined(first, state.vectorBytes(second)) {
+		return false, true
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, 32)
+	state.writeVector(destination, 32, 0xffffffff, false)
+	return true, true
+}
+
+func x86CallerPermute128Step(ins *Instr, form x86Permute128Form, state *x86SourceStackState, proof *x86GoCallerRegionProof) bool {
+	if !x86ResultNamedPredicateInstruction(*ins) || ins.x86Permute128VEX {
+		return false
+	}
+	first := uint64(0xffffffff)
+	if form.memory >= 0 {
+		if !x86CallerOrdinaryMemoryStep(ins, form.memory, state, proof, 32, false) {
+			return false
+		}
+	} else {
+		first = state.vectors[x86CallerVectorRoot(ins.Args[form.first].Reg)]
+	}
+	second := state.vectors[x86CallerVectorRoot(ins.Args[form.second].Reg)]
+	if !form.inputsDefined(first, second) {
+		return false
+	}
+	state.vectors[x86CallerVectorRoot(ins.Args[form.destination].Reg)] = ^uint64(0)
+	return true
+}
diff --git a/x86_result_permute_inlane.go b/x86_result_permute_inlane.go
new file mode 100644
index 000000000..1b5904a1c
--- /dev/null
+++ b/x86_result_permute_inlane.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+// Only the lowering-paired E4NF read supplies conditional native bytes. Raw
+// boundaries, caller memory, SDK literals and native entry retain their owners.
+func x86ResultElementPermuteStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	f, known, err := x86ElementPermuteProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	var source uint64
+	if f.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[f.source], int64(f.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+		source = x86CallerVectorByteMask(int64(f.memoryBytes))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[f.source].Reg, f.byteWidth)
+		source = state.vectorBytes(index)
+	}
+	var defined uint64
+	if f.immediate {
+		for output := 0; output < f.byteWidth; output++ {
+			defined |= (source >> uint(f.sourceByte(output)) & 1) << uint(output)
+		}
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[f.data].Reg, f.byteWidth)
+		data, control := state.vectorBytes(index), source
+		dataWidth := f.byteWidth
+		if f.wholeVector {
+			data, control = source, data
+			if f.broadcast {
+				dataWidth = f.memoryBytes
+			}
+		}
+		dataMask := x86CallerVectorByteMask(int64(dataWidth))
+		if data&dataMask != dataMask {
+			return false, true // Even a dead variable permute consumes its numerical data input.
+		}
+		bytes := f.bits / 8
+		for lane := 0; lane < f.byteWidth/bytes; lane++ {
+			controlByte := lane * bytes
+			if f.broadcast && !f.wholeVector {
+				controlByte = 0
+			}
+			if control>>uint(controlByte)&1 == 0 {
+				return false, true // Only selector bits in the low control byte are read.
+			}
+		}
+		defined = x86CallerVectorByteMask(int64(f.byteWidth))
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	if f.mask >= 0 && !f.zeroing {
+		defined &= state.vectorBytes(destination)
+	}
+	state.writeVector(destination, f.byteWidth, defined, false)
+	return true, true // FLAGS, DF, GP identities, masks and independent storage survive.
+}
diff --git a/x86_result_pointer_advance.go b/x86_result_pointer_advance.go
new file mode 100644
index 000000000..292cf082c
--- /dev/null
+++ b/x86_result_pointer_advance.go
@@ -0,0 +1,31 @@
+package plan9asm
+
+// This is the existing complete unary grammar projected onto a native-word
+// affine address transform. Narrow writes and physical SP/amd64 BP retain
+// their independent roles. The shape alone never creates an address identity.
+func x86CallerPointerAdvanceProperties(ins Instr, arch string) (x86LockScalarRMWForm, bool) {
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) ||
+		form.spec.stem != "INC" && form.spec.stem != "DEC" ||
+		int64(form.spec.bits/8) != x86ResultPointerWord(arch) || form.destination.Kind != OpReg {
+		return form, false
+	}
+	_, _, valid := x86ResultGP(form.destination.Reg, int64(form.spec.bits/8), arch)
+	return form, valid
+}
+
+func x86ResultCallerPointerAdvanceStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	form, known := x86CallerPointerAdvanceProperties(ins, arch)
+	if !known || state.shapeOnly {
+		return false, false
+	}
+	index, _, _ := x86ResultGP(form.destination.Reg, int64(form.spec.bits/8), arch)
+	if !state.pointerGP[index] || !state.callerAddressGP[index] {
+		return false, false // An opaque literal carrier is not an actual caller address.
+	}
+	// INC/DEC does not consume CF to compute its address. Preserve exactly its
+	// prior defined/unknown status; every other status bit is defined, DF is
+	// unchanged, and no numerical bytes or new native memory identity appear.
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true
+}
diff --git a/x86_result_pointer_advance_test.go b/x86_result_pointer_advance_test.go
new file mode 100644
index 000000000..ae4e9a9be
--- /dev/null
+++ b/x86_result_pointer_advance_test.go
@@ -0,0 +1,98 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86IncomingPointerUnaryAdvanceWholeSourceThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move, suffix := goWordSize(target.arch), "MOVQ", "Q"
+		if target.arch == "386" {
+			move, suffix = "MOVL", "L"
+		}
+		for _, stem := range []string{"INC", "DEC"} {
+			for _, scenario := range []string{"projection", "native-read", "unknown", "unknown-CF", "partial", "result-address"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+stem+"/"+scenario+"/"+api, func(t *testing.T) {
+						body := move + " p+0(FP),AX\n"
+						if scenario == "unknown" {
+							body = ""
+						}
+						if scenario == "result-address" {
+							body = fmt.Sprintf("LEA%s ret+%d(FP),AX\n", suffix, word)
+						}
+						actualSuffix := suffix
+						if scenario == "partial" {
+							actualSuffix = "W"
+						}
+						body += stem + actualSuffix + " AX\n"
+						if scenario == "native-read" {
+							body += move + " AX,SI\nMOVL $0,AX\nCRC32B (SI),AX\n"
+						} else {
+							if scenario == "unknown-CF" {
+								body += "JCS unknown_cf\nunknown_cf:\n"
+							}
+							body += "AND" + suffix + " $7,AX\n"
+						}
+						body += fmt.Sprintf("MOVL AX,ret+%d(FP)\nRET\n", word)
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word+4, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte) uint32", target.arch, target.triple, api)
+						positive := scenario == "projection" || scenario == "native-read"
+						if positive && (err != nil || ir == "") {
+							t.Fatal("actual caller native-word unary advance lost its pointer", err)
+						}
+						if !positive && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+							t.Fatal("unary address advance borrowed unknown/partial bytes or incoming CF", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86IncomingPointerUnaryAdvanceRolesFlagsAndOrigins(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, suffix := x86ResultPointerWord(arch), "Q"
+		if arch == "386" {
+			suffix = "L"
+		}
+		for _, stem := range []string{"INC", "DEC"} {
+			for _, register := range []Reg{AX, CX, DX, BX, BP, SI, DI, "R8", "R15"} {
+				index, _, valid := x86ResultGP(register, word, arch)
+				if !valid {
+					continue
+				}
+				for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagsAll} {
+					for _, caller := range []bool{false, true} {
+						ins := x86ScalarLaneInstruction(t, stem+suffix+" "+string(register))
+						state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+						state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = true, caller, 1
+						accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != caller {
+							t.Fatal("unary advance conflated opaque and actual caller roles", arch, ins.Raw, caller, accepted)
+						}
+						if !caller {
+							continue
+						}
+						wantFlags := flags&x86ByteFlagCF | x86ByteFlagsAll&^x86ByteFlagCF
+						if state.flags != wantFlags || state.gp[index] != 0 || !state.pointerGP[index] || state.direction != x86ResultDirectionBackward {
+							t.Fatal("unary address advance changed CF/NUM/DF", arch, ins.Raw, state)
+						}
+						after := x86ResultCallerAddressesAfter(ins, state.callerAddressGP, nil, arch)
+						origin := x86ResultCallerOriginsAfter(ins, state.callerAddressOrigin, after, map[int64]bool{0: true}, arch)
+						if !after[index] || origin[index] != 1 {
+							t.Fatal("post-transfer lost actual pointer/origin after a checked affine advance", arch, ins.Raw)
+						}
+						var unknown [16]bool
+						if x86ResultCallerAddressesAfter(ins, unknown, nil, arch) != unknown {
+							t.Fatal("unary shape created caller address identity")
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_pointer_cells.go b/x86_result_pointer_cells.go
new file mode 100644
index 000000000..c8cc72d39
--- /dev/null
+++ b/x86_result_pointer_cells.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+// One bit at byte-end minus one means the preceding native word was pushed
+// from an already established opaque incoming pointer. It does not describe
+// numerical bits, a pointee or any caller/frame/entry capability. Byte ends
+// preserve mode32's genuinely mixed W/L positions without joining two halves.
+func (stack *x86ResultValueStack) pointerCell(end int) bool {
+	return end > 0 && end <= len(stack.bytes) &&
+		stack.pointerCells[(end-1)/64]&(uint64(1)<<uint((end-1)%64)) != 0
+}
+
+func (stack *x86ResultValueStack) markPointerCell(end int) {
+	stack.pointerCells[(end-1)/64] |= uint64(1) << uint((end-1)%64)
+}
+
+// A write or partial pop revokes every saved word whose byte span overlaps.
+// Removed bytes cannot retain a tag which a later narrow push could resurrect.
+func (stack *x86ResultValueStack) revokePointerCells(begin, end, word int) {
+	first := begin + 1
+	if first < word {
+		first = word
+	}
+	last := end + word - 1
+	if last > len(stack.bytes) {
+		last = len(stack.bytes)
+	}
+	for boundary := first; boundary <= last; boundary++ {
+		stack.pointerCells[(boundary-1)/64] &^= uint64(1) << uint((boundary-1)%64)
+	}
+}
+
+func (stack *x86ResultValueStack) pointerCellsBounded(arch string) bool {
+	word := int(x86ResultPointerWord(arch))
+	if stack.pointerCells[0]&((uint64(1)<<uint(word-1))-1) != 0 {
+		return false // No complete word ends before the first native word.
+	}
+	for index, bits := range stack.pointerCells {
+		remaining := len(stack.bytes) - index*64
+		if remaining <= 0 && bits != 0 || remaining > 0 && remaining < 64 && bits>>uint(remaining) != 0 {
+			return false
+		}
+		if arch == "amd64" && bits&^uint64(0x8080808080808080) != 0 {
+			return false // Existing AMD64 virtual cells each occupy eight bytes.
+		}
+	}
+	return true
+}
diff --git a/x86_result_pointer_residue.go b/x86_result_pointer_residue.go
new file mode 100644
index 000000000..420f5f719
--- /dev/null
+++ b/x86_result_pointer_residue.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+// A proper low-bit AND projection may observe an actual incoming caller
+// address, not an arbitrary opaque pointer carrier. Both independent reaching
+// identities must survive; neither a literal/OR carrier nor NUM bytes supply
+// them. This consumes the complete existing Go AND immediate/register grammar,
+// including encoded immediates and physical byte aliases. No source, native
+// entry, backing, extent, alignment or reusable address permission follows.
+func x86ResultPointerResidueStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if state.shapeOnly || !x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.spec.stem != "AND" || form.source.Kind != OpImm || form.destination.Kind != OpReg {
+		return false, false
+	}
+	width := int64(form.spec.bits / 8)
+	index, _, valid := x86ResultGP(form.destination.Reg, width, arch)
+	if !valid || !state.pointerGP[index] || !state.callerAddressGP[index] {
+		return false, false
+	}
+	mask, all := uint64(form.source.Imm), ^uint64(0)
+	if form.spec.bits < 64 {
+		all = uint64(1)<<uint(form.spec.bits) - 1
+	}
+	if form.source.Imm < 0 || mask >= all || mask&(mask+1) != 0 {
+		return false, false // Identity/sparse transforms retain their old opaque role.
+	}
+	if !x86ResultStore(form.destination, width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	// Partial writes define only their bytes; L clears the upper32. The old
+	// full-word pointer and all address aliases are revoked even for B/W.
+	state.callerAddressGP[index], state.pointerGP[index] = false, false
+	state.callerAddressOrigin[index] = 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	state.canonicalGP[index] = 0
+	state.predicate = x86ResultPredicate{}
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true
+}
diff --git a/x86_result_pointer_residue_test.go b/x86_result_pointer_residue_test.go
new file mode 100644
index 000000000..e9dd954b1
--- /dev/null
+++ b/x86_result_pointer_residue_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86IncomingPointerResidueMasksRolesAndByteAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []struct {
+			op    string
+			width int64
+		}{{"ANDB", 1}, {"ANDW", 2}, {"ANDL", 4}, {"ANDQ", 8}} {
+			if arch == "386" && row.width == 8 {
+				continue
+			}
+			for _, register := range strings.Fields("AX CX DX BX SP BP SI DI R8 R9 R10 R11 R12 R13 R14 R15 AL AH BL BH CL CH DL DH BPB SIB DIB R8B R9B R10B R11B R12B R13B R14B R15B") {
+				for _, mask := range []int64{0, 1, 3, 7, 5, -1, 0x107, 0x10007, 0x7fffffff, 0xffffffff} {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,%s", row.op, mask, register))
+					// Byte identity is the separately validated existing grammar;
+					// the expectation below independently selects role/mask bits.
+					form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+					if !known || err != nil {
+						continue
+					}
+					index, byteMask, valid := x86ResultGP(form.destination.Reg, row.width, arch)
+					if !valid {
+						continue // Physical SP/amd64 BP and mode32 high banks have no role.
+					}
+					for _, caller := range []bool{false, true} {
+						for _, pointer := range []bool{false, true} {
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+							state.pointerGP[index], state.callerAddressGP[index] = pointer, caller
+							before := state.clone()
+							encoded, all := int64(int32(mask)), uint64(0xffffffff)
+							if row.width == 1 {
+								encoded, all = int64(int8(mask)), 255
+							} else if row.width == 2 {
+								encoded, all = int64(int16(mask)), 65535
+							} else if row.width == 8 {
+								all = ^uint64(0)
+							}
+							lowMask := uint64(encoded)
+							positive := caller && pointer && encoded >= 0 && lowMask < all && lowMask&(lowMask+1) == 0
+							got := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch)
+							if got != positive {
+								t.Fatalf("%s %s %s mask=%d caller=%t pointer=%t: got=%t want=%t", arch, row.op, register, mask, caller, pointer, got, positive)
+							}
+							if positive {
+								before.gp[index] = byteMask
+								if row.width >= 4 {
+									before.gp[index] = 255
+								}
+								before.pointerGP[index], before.callerAddressGP[index] = false, false
+								before.flags = x86ByteFlagsAll &^ x86ByteFlagAF
+							}
+							if !reflect.DeepEqual(state, before) {
+								t.Fatal("projection changed unrelated bytes/flags/DF or retained address authority", arch, ins.Raw)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, origin := range []string{"named", "raw", "decoded", "address", "unbound-address", "segment"} {
+		ins := x86ScalarLaneInstruction(t, "ANDQ $7,AX")
+		switch origin {
+		case "raw":
+			ins.x86SourceRaw = new(x86SourceRawInstruction)
+		case "decoded":
+			ins.x86Encoded = true
+		case "address":
+			ins.x86AddressBits = 32
+		case "unbound-address":
+			ins.x86UnboundAddressOverride = true
+		case "segment":
+			ins.x86SegmentPrefix = 0x64
+		}
+		state := x86ResultState{flags: x86ByteFlagsAll}
+		for _, index := range []int{0, 3} {
+			state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = true, true, 42
+			state.canonicalGP[index] = 255
+			state.resultAddressGP[index] = x86ResultSlotAddress{start: 8, end: 12, offset: 8, valid: true}
+		}
+		state.predicate = x86ResultPredicate{kind: x86ResultNonzeroMaskGP, register: 0, width: 8}
+		before := state.clone()
+		accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64")
+		if accepted != (origin == "named") {
+			t.Fatal("residue borrowed another source role", origin, accepted)
+		}
+		if accepted {
+			before.gp[0], before.pointerGP[0], before.callerAddressGP[0] = 255, false, false
+			before.callerAddressOrigin[0], before.canonicalGP[0] = 0, 0
+			before.resultAddressGP[0], before.predicate = x86ResultSlotAddress{}, x86ResultPredicate{}
+			before.flags &^= x86ByteFlagAF
+		}
+		if !reflect.DeepEqual(state, before) {
+			t.Fatal("residue retained overwritten authority or changed another register", origin)
+		}
+	}
+}
+
+func TestX86IncomingPointerResidueWholeSourceThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, copy := goWordSize(target.arch), "MOVQ"
+		if target.arch == "386" {
+			copy = "MOVL"
+		}
+		for _, row := range []struct {
+			op, store, typ string
+			width          int
+		}{{"ANDB", "MOVB", "uint8", 1}, {"ANDW", "MOVW", "uint16", 2}, {"ANDL", "MOVL", "uint32", 4}, {"ANDQ", "MOVQ", "uint64", 8}} {
+			if target.arch == "386" && row.width == 8 {
+				continue // No Go Q instruction in this source mode.
+			}
+			for _, scenario := range []string{"actual-pointer", "copied-pointer", "unknown", "all-bits", "sparse-mask"} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.op+"/"+scenario+"/"+api, func(t *testing.T) {
+						body := ""
+						if scenario != "unknown" {
+							body = copy + " p+0(FP),AX\n"
+						}
+						if scenario == "copied-pointer" {
+							body += copy + " AX,BX\n"
+							body += copy + " BX,AX\n"
+						}
+						mask := "7"
+						if scenario == "all-bits" {
+							mask = "-1"
+						} else if scenario == "sparse-mask" {
+							mask = "5"
+						}
+						body += row.op + " $" + mask + ",AX\n" + fmt.Sprintf("%s AX,ret+%d(FP)\nRET\n", row.store, word)
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word+row.width, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte) "+row.typ, target.arch, target.triple, api)
+						positive := scenario == "actual-pointer" || scenario == "copied-pointer"
+						if positive && (err != nil || ir == "") {
+							t.Fatal("actual pointer low-bit projection did not produce a defined scalar", err)
+						}
+						if !positive && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+							t.Fatal("unregistered pointer representation became general NUM", scenario, err)
+						}
+					})
+				}
+			}
+		}
+		for _, row := range []struct{ name, params, body string }{
+			{"native-after-projection", "p *byte", copy + " p+0(FP),SI\nAND" + strings.TrimPrefix(copy, "MOV") + " $7,SI\nMOVL $0,AX\nCRC32B (SI),AX\n"},
+			{"numeric-native-address", "p uintptr", copy + " p+0(FP),SI\nAND" + strings.TrimPrefix(copy, "MOV") + " $7,SI\nMOVL $0,AX\nCRC32B (SI),AX\n"},
+			{"unknown-join", "p *byte", "MOVL $0,CX\nCMPL CX,$0\nJE unknown\n" + copy + " p+0(FP),AX\nJMP join\nunknown:\nNOP\njoin:\nAND" + strings.TrimPrefix(copy, "MOV") + " $7,AX\n"},
+			{"result-address", "p *byte", "LEA" + strings.TrimPrefix(copy, "MOV") + fmt.Sprintf(" ret+%d(FP),AX\n", word) + "AND" + strings.TrimPrefix(copy, "MOV") + " $7,AX\n"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOVL AX,ret+%d(FP)\nRET\n", word+4, row.body, word)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value("+row.params+") uint32", target.arch, target.triple, api)
+					if row.name == "native-after-projection" || row.name == "numeric-native-address" {
+						x86RequireNumericNativeSourceContext(t, source, "func Value("+row.params+") uint32", target.arch)
+						x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+						if err != nil || !strings.Contains(ir, "load volatile i8,") {
+							t.Fatal("defined numerical residue lost its exact native CRC byte read", err)
+						}
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("residue manufactured an address/unknown/padding authority", err)
+					}
+				})
+			}
+		}
+		for _, qType := range []string{"*byte", "uintptr"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/joined-"+qType+"/"+api, func(t *testing.T) {
+					body := fmt.Sprintf("MOVL flag+%d(FP),CX\nCMPL CX,$0\nJE second\n%s p+0(FP),AX\nJMP join\nsecond:\n%s q+%d(FP),AX\njoin:\nAND%s $7,AX\nMOVL AX,ret+%d(FP)\nRET\n", 2*word, copy, copy, word, strings.TrimPrefix(copy, "MOV"), 3*word)
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", 3*word+4, body)
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,q "+qType+",flag uint32) uint32", target.arch, target.triple, api)
+					if qType == "*byte" && (err != nil || ir == "") {
+						t.Fatal("two actual caller origins need no common-origin witness for a unary projection", err)
+					}
+					if qType != "*byte" && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("NUM/caller join supplied an actual pointer identity", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_popped_word.go b/x86_result_popped_word.go
new file mode 100644
index 000000000..36a2c4dc0
--- /dev/null
+++ b/x86_result_popped_word.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+// One adjacent consumer may project partially defined GP bits from a typed
+// producer. This replaces the POP-only observation, not a per-register bit
+// domain. Every intervening instruction consumes it, including branches.
+// Stack origins remain separate from numerical bit availability.
+type x86ResultGPBits struct {
+	bits      uint64
+	register  int
+	valid     bool
+	fromStack bool // Only a real POP can consume the private FLAGS-origin relation.
+}
+
+func x86ResultGPBitsMaskStep(ins Instr, pending x86ResultGPBits, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if !pending.valid || !x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	var source, destination Operand
+	var width int64
+	var killed, defined uint8
+	readOnly := false
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil &&
+		form.spec.stem == "AND" && form.source.Kind == OpImm && form.destination.Kind == OpReg {
+		source, destination, width = form.source, form.destination, int64(form.spec.bits/8)
+		killed, defined = form.spec.flagsKilled, form.spec.flagsDefined
+	} else if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil &&
+		form.test && form.args[0].Kind == OpImm && form.args[1].Kind == OpReg {
+		source, destination, width = form.args[0], form.args[1], int64(form.bits/8)
+		killed, defined, readOnly = x86ByteFlagsAll, x86ByteFlagsAll&^x86ByteFlagAF, true
+	} else {
+		return false, false
+	}
+	index, bytes, valid := x86ResultGP(destination.Reg, width, arch)
+	if !valid || index != pending.register || x86LogicalSourceFrameRegister(destination.Reg, arch) {
+		return false, false
+	}
+	shift := uint(0)
+	if width == 1 && bytes == 2 {
+		shift = 8 // AH/CH/DH/BH select the second physical byte.
+	}
+	mask := uint64(source.Imm)
+	if width < 8 {
+		mask &= uint64(1)<<uint(8*width) - 1
+	}
+	if mask&^(pending.bits>>shift) != 0 {
+		return false, true // Unselected unknown bits do not become numerical.
+	}
+	if !readOnly && !x86ResultStore(destination, width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^killed | defined
+	return true, true // TEST never writes the unobserved GP bits.
+}
diff --git a/x86_result_popped_word_test.go b/x86_result_popped_word_test.go
new file mode 100644
index 000000000..2f8dfadbc
--- /dev/null
+++ b/x86_result_popped_word_test.go
@@ -0,0 +1,161 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86NarrowPoppedWordCannotDefineUnwrittenHighBits(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, control := range []struct {
+			name, before string
+			pass         bool
+		}{
+			{"unknown-high", "", false},
+			{"narrow-high", "MOVW $0,AX\n", false},
+			{"known-high", move + " $0,AX\n", true},
+			{"zero-extended-high", "MOVL $0,AX\n", true},
+		} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOVL $1,DX\nCMPL DX,DX\nBTW $0,DX\nPUSHFW\nPOPW AX\nAND%s $65536,AX\n%s AX,ret+0(FP)\nRET\n", word, control.before, move[3:], move)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+control.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", target.arch, target.triple, api)
+					if control.pass && (err != nil || ir == "") || !control.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("narrow POP invented or revoked unwritten GP bits", control.pass, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86NativeBitTestExactStateAndIndependentAuthorities(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86BitTestOracleNames(arch) {
+			for _, index := range []string{"$-128", "$127", "CX"} {
+				ins := x86ScalarLaneInstruction(t, op+" "+index+",-1(DX)(BX*2)")
+				for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+					state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+					state.gp[1], state.gp[3], state.pointerGP[2] = 0xff, 0xff, true
+					want := state.clone()
+					want.flags = flags&x86ByteFlagZF | x86ByteFlagCF
+					if accepted, known := x86LoweredNativeBitTest(ins, &state, nil, arch); !accepted || !known || !reflect.DeepEqual(state, want) {
+						t.Fatal("native BIT invented memory/GP/flags facts", arch, ins, state, want)
+					}
+				}
+				for _, mutation := range []string{"unknown-base", "numerical-base", "unknown-index", "commuted-pointer", "physical", "address", "raw"} {
+					if index != "CX" && mutation == "unknown-index" {
+						continue
+					}
+					changed := ins
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[1], state.gp[3], state.pointerGP[2] = 0xff, 0xff, true
+					switch mutation {
+					case "unknown-base":
+						state.pointerGP[2] = false
+					case "numerical-base":
+						state.pointerGP[2], state.gp[2] = false, 0xff
+					case "unknown-index":
+						state.gp[1] = 0
+					case "commuted-pointer":
+						state.pointerGP[2], state.gp[2], state.pointerGP[3], state.gp[3] = false, 0xff, true, 0
+					case "physical":
+						changed.x86Encoded = true
+					case "address":
+						changed.x86AddressBits = 16
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					}
+					before := state.clone()
+					if accepted, _ := x86LoweredNativeBitTest(changed, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("native BIT accepted an unproved reaching role or changed rejected state", arch, op, index, mutation)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86PoppedFlagWordImmediateMaskThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			suffix, typ string
+			width       int
+		}{
+			{"W", "uint16", 2}, {"L", "uint32", 4}, {"Q", "uint64", 8},
+		} {
+			if target.arch == "amd64" && row.suffix == "L" || target.arch == "386" && row.suffix == "Q" {
+				continue // These stack-width spellings are Go-rejected in this mode.
+			}
+			for _, control := range []struct {
+				name, between string
+				mask          int
+				pass          bool
+			}{
+				{"CF-ZF", "", 65, true}, {"CF", "", 1, true}, {"ZF", "", 64, true}, {"zero", "", 0, true},
+				{"unknown-PF", "", 69, false}, {"unknown-DF", "", 1024, false}, {"unknown-OF", "", 2048, false},
+				{"overwritten", "MOV" + row.suffix + " BX,AX\n", 65, false},
+			} {
+				body := fmt.Sprintf("MOVL $1,DX\nCMPL DX,DX\nBTW $0,DX\nPUSHF%s\nPOP%s AX\n%sAND%s $%d,AX\nMOV%s AX,ret+0(FP)\nRET\n", row.suffix, row.suffix, control.between, row.suffix, control.mask, row.suffix)
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", row.width, body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.suffix+"/"+control.name+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() "+row.typ, target.arch, target.triple, api)
+						if control.pass && (err != nil || ir == "") || !control.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+							t.Fatal("captured status mask lost or invented defined bits", control.pass, err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86NativeBitTestCompleteReachingInputsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, op := range x86BitTestOracleNames(target.arch) {
+			for _, index := range []string{"$-128", "$127", "CX"} {
+				body := fmt.Sprintf("%s p+0(FP),DX\n%s index+%d(FP),CX\n%s %s,(DX)\nSETCS AL\nMOVB AL,ret+%d(FP)\nRET\n", move, move, word, op, index, word*2)
+				for _, control := range []struct {
+					name, body string
+					pass       bool
+				}{
+					{"complete", body, true},
+					{"unknown-base", "NOP\n" + body[len(move+" p+0(FP),DX\n"):], false},
+				} {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word*2+1, control.body)
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+op+"/"+index+"/"+control.name+"/"+api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *byte,index uintptr) uint8", target.arch, target.triple, api)
+							if control.pass && (err != nil || ir == "") || !control.pass && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+								t.Fatal("native BIT reaching input class mismatch", control.pass, err)
+							}
+							if control.pass {
+								llc := findLLVM22Tool("llc")
+								if llc == "" {
+									t.Fatal("LLVM22 llc required")
+								}
+								for _, level := range []string{"-O0", "-O2"} {
+									x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_predicate.go b/x86_result_predicate.go
new file mode 100644
index 000000000..9e9fd0850
--- /dev/null
+++ b/x86_result_predicate.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+type x86ResultPredicateKind uint8
+
+const (
+	x86ResultNoPredicate x86ResultPredicateKind = iota
+	x86ResultComparisonBytes
+	x86ResultTestComparisonBytes
+	x86ResultNonzeroComparisonBytes
+	x86ResultNonzeroMaskGP
+)
+
+// One bounded, ephemeral relation follows a complete typed comparison/test/
+// branch/movemask chain. It never asserts a value from numerical definedness.
+// Width identifies the exact vector view, or the potentially nonzero GP bits.
+// Unknown/intervening effects revoke it; joins retain only identical facts.
+type x86ResultPredicate struct {
+	kind     x86ResultPredicateKind
+	register uint8
+	width    uint8
+}
+
+func x86ResultNamedPredicateInstruction(ins Instr) bool {
+	return !ins.x86Encoded && ins.x86SourceRaw == nil && ins.x86RawNearReturn == nil &&
+		ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride && ins.x86SegmentPrefix == 0
+}
+
+// Called only after the independent complete byte/effect transfer succeeds.
+func x86ResultPredicateAfter(ins Instr, before x86ResultPredicate, arch string) x86ResultPredicate {
+	if x86PreservesNumericalSourceState(ins) {
+		return before
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86ResultPredicate{}
+	}
+	if known, err := x86SizedNOPProperties(ins, arch); known && err == nil {
+		return before // No input, write or FLAGS change revokes the existing relation.
+	}
+	if isAMD64ConditionalBranch(ins.Op) {
+		if spec, counter := x86CounterControlPropertiesForOpcode(ins.Op); counter && spec.decrement &&
+			before.kind == x86ResultNonzeroMaskGP && before.register == 1 {
+			return x86ResultPredicate{} // The old numerical CX relation does not survive a decrement.
+		}
+		return before // The CFG refines each successor independently.
+	}
+	if form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch); known && err == nil && !form.mmx && !form.maskResult {
+		index, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+		if valid {
+			return x86ResultPredicate{kind: x86ResultComparisonBytes, register: uint8(index), width: uint8(form.byteWidth)}
+		}
+	}
+	if form, known, err := x86VectorTestProperties(ins.Op, ins, arch); known && err == nil &&
+		before.kind == x86ResultComparisonBytes && ins.Args[0].Kind == OpReg && ins.Args[0].Reg == ins.Args[1].Reg {
+		index, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.byteWidth)
+		if valid && before.register == uint8(index) && before.width == uint8(form.byteWidth) {
+			before.kind = x86ResultTestComparisonBytes
+			return before // For all-00/FF bytes, sign tests also detect nonzero.
+		}
+	}
+	if form, known, err := x86MoveMaskProperties(ins.Op, ins, arch); known && err == nil &&
+		before.kind == x86ResultNonzeroComparisonBytes && before.width == uint8(form.byteWidth) {
+		source, valid := amd64VectorRegisterIndex(ins.Args[0].Reg, form.byteWidth)
+		destination, _, gp := x86ResultGP(ins.Args[1].Reg, 4, arch)
+		if valid && gp && before.register == uint8(source) {
+			bits := form.byteWidth
+			if form.floatingLaneBits != 0 {
+				bits /= form.floatingLaneBits / 8
+			}
+			return x86ResultPredicate{kind: x86ResultNonzeroMaskGP, register: uint8(destination), width: uint8(bits)}
+		}
+	}
+	return x86ResultPredicate{}
+}
+
+func x86ResultPredicateEdge(state x86ResultState, ins Instr, edge int) x86ResultState {
+	state = x86ResultBitScanEdge(state, ins, edge)
+	if _, counter := x86CounterControlPropertiesForOpcode(ins.Op); counter {
+		return state // Count branches do not establish the ordinary JE/JNE vector-mask relation.
+	}
+	if state.predicate.kind != x86ResultTestComparisonBytes || !isAMD64ConditionalBranch(ins.Op) {
+		return state
+	}
+	nonzero := (ins.Op == "JE" || ins.Op == "JEQ" || ins.Op == "JZ") && edge == 0 ||
+		(ins.Op == "JNE" || ins.Op == "JNZ") && edge == 1
+	if nonzero {
+		state.predicate.kind = x86ResultNonzeroComparisonBytes
+	} else {
+		state.predicate = x86ResultPredicate{}
+	}
+	return state
+}
+
+func x86ResultVectorTestStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultVectorTestStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultVectorTestStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86VectorTestProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	for role, operand := range ins.Args {
+		if operand.Kind != OpReg {
+			if !native || role != 0 || !x86ResultReadWithNativeContinuation(ins, operand,
+				int64(form.byteWidth), state, owned, arch, true) {
+				return false, true // Shape cannot supply native memory or alignment.
+			}
+			continue
+		}
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		mask := x86CallerVectorByteMask(int64(form.byteWidth))
+		if !valid || arch == "386" && index >= 8 || state.vectorBytes(index)&mask != mask {
+			return false, true
+		}
+	}
+	state.flags = x86ByteFlagsAll
+	return true, true
+}
diff --git a/x86_result_predicate_test.go b/x86_result_predicate_test.go
new file mode 100644
index 000000000..1d790e062
--- /dev/null
+++ b/x86_result_predicate_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ResultPredicateFixture(t *testing.T, compare, test, movemask, scan, between string) (Func, FuncSig, string) {
+	t.Helper()
+	ins := x86ScalarLaneInstruction(t, scan)
+	if len(ins.Args) != 2 || ins.Args[1].Kind != OpReg {
+		t.Fatal("predicate fixture needs its actual scan destination")
+	}
+	destination := string(ins.Args[1].Reg)
+	body := "MOVQ x+0(FP),AX\nMOVQ AX,X0\nVPBROADCASTQ X0,Y1\nVPBROADCASTQ X0,Y2\n" + compare + "\n" + test + "\nJZ zero\n" + between + movemask + "\n" + scan + "\nMOVL " + destination + ",ret+8(FP)\nRET\nzero:\nMOVL $0,ret+8(FP)\nRET"
+	_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x uint64) uint32", body)
+	return file.Funcs[0], sig, source
+}
+
+func TestX86ResultPredicateNonzeroComparisonMaskBitScan(t *testing.T) {
+	for _, compare := range []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"} {
+		for _, test := range []string{"VPTEST", "VTESTPS", "VTESTPD"} {
+			for _, mask := range []string{"VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+				t.Run(compare+"/"+test+"/"+mask, func(t *testing.T) {
+					fn, sig, _ := x86ResultPredicateFixture(t, compare+" Y1,Y2,Y3", test+" Y3,Y3", mask+" Y3,DX", "BSFL DX,DX", "")
+					if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+						t.Fatal("typed nonzero comparison mask rejected", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultPredicateNonzeroCannotBorrowOtherValueOrWidth(t *testing.T) {
+	for name, change := range map[string]struct{ compare, test, mask, scan, between string }{
+		"plain vector is not a comparison mask":     {"VMOVDQU Y1,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y3,DX", "BSFL DX,DX", ""},
+		"different tested vector":                   {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y2,Y2", "VPMOVMSKB Y3,DX", "BSFL DX,DX", ""},
+		"mixed test intersection":                   {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y2,Y3", "VPMOVMSKB Y3,DX", "BSFL DX,DX", ""},
+		"different movemask vector":                 {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y2,DX", "BSFL DX,DX", ""},
+		"narrowing discards only nonzero high half": {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB X3,DX", "BSFL DX,DX", ""},
+		"word scan discards nonzero mask high bits": {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y3,DX", "BSFW DX,DX", ""},
+		"vector replaced":                           {"VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y3,DX", "BSFL DX,DX", "VMOVDQU Y1,Y3\n"},
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn, sig, _ := x86ResultPredicateFixture(t, change.compare, change.test, change.mask, change.scan, change.between)
+			if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+				t.Fatal("the original initialized self-alias is a valid numerical control", err)
+			}
+			unknownScan := strings.Replace(change.scan, ",DX", ",BX", 1)
+			fn, sig, _ = x86ResultPredicateFixture(t, change.compare, change.test, change.mask, unknownScan, change.between)
+			if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("nonzero relationship laundered a different value", err)
+			}
+		})
+	}
+	for _, replacement := range []string{"JNZ zero", "JCS zero", "CMPL AX,$0\nJZ zero"} {
+		t.Run(fmt.Sprintf("replaced guard %s", replacement), func(t *testing.T) {
+			_, sig, source := x86ResultPredicateFixture(t, "VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y3,DX", "BSFL DX,DX", "")
+			changed := strings.Replace(source, "JZ zero", replacement, 1)
+			file, err := Parse(ArchAMD64, changed)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatal("original initialized self-alias ceased to be numerical", err)
+			}
+			unknown := strings.ReplaceAll(strings.Replace(changed, "BSFL DX,DX", "BSFL DX,BX", 1), "MOVL DX,ret", "MOVL BX,ret")
+			file, err = Parse(ArchAMD64, unknown)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("wrong/stale predicate authorized a nonzero mask", err)
+			}
+		})
+	}
+}
+
+func TestX86ResultPredicateBoundedStateAndRawRevocation(t *testing.T) {
+	base := x86ResultPredicate{kind: x86ResultNonzeroComparisonBytes, register: 3, width: 32}
+	ins := x86ScalarLaneInstruction(t, "VPMOVMSKB Y3,DX")
+	for _, kind := range []x86ResultPredicateKind{x86ResultNoPredicate, x86ResultComparisonBytes, x86ResultTestComparisonBytes, x86ResultNonzeroComparisonBytes, x86ResultNonzeroMaskGP} {
+		for _, width := range []uint8{16, 32, 64} {
+			for _, register := range []uint8{2, 3, 4} {
+				before := x86ResultPredicate{kind: kind, register: register, width: width}
+				next := x86ResultPredicateAfter(ins, before, "amd64")
+				want := kind == base.kind && width == base.width && register == base.register
+				if (next.kind == x86ResultNonzeroMaskGP) != want {
+					t.Fatal("predicate accepts a different domain/view/physical register", before, next)
+				}
+				left := x86ResultState{predicate: base}
+				right := x86ResultState{predicate: before}
+				if (left.intersect(right).predicate == base) != (base == before) {
+					t.Fatal("predicate intersection manufactured a relation", base, before)
+				}
+			}
+		}
+	}
+	for _, raw := range []bool{false, true} {
+		local := ins
+		local.x86Encoded = raw
+		next := x86ResultPredicateAfter(local, base, "amd64")
+		if raw && next.kind != x86ResultNoPredicate || !raw && next.kind != x86ResultNonzeroMaskGP {
+			t.Fatal("named predicate adopted encoded source authority", raw, next)
+		}
+	}
+	state := x86ResultState{predicate: x86ResultPredicate{kind: x86ResultTestComparisonBytes, register: 3, width: 32}}
+	branch := x86ScalarLaneInstruction(t, "JNZ matched")
+	zero := x86ResultPredicateEdge(state, branch, 0)
+	nonzero := x86ResultPredicateEdge(state, branch, 1)
+	if zero.predicate.kind != x86ResultNoPredicate || nonzero.predicate.kind != x86ResultNonzeroComparisonBytes || state.predicate.kind != x86ResultTestComparisonBytes {
+		t.Fatal("predicate edge mutated predecessor or sibling")
+	}
+}
+
+func TestX86ResultPredicateLegacyAndVEXCompleteComparisonFamilies(t *testing.T) {
+	for _, compare := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ", "PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ"} {
+		for _, test := range []string{"PTEST", "VPTEST", "VTESTPS", "VTESTPD"} {
+			for _, mask := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+				t.Run(compare+"/"+test+"/"+mask, func(t *testing.T) {
+					fn, sig, _ := x86ResultPredicateFixture(t, compare+" X1,X2", test+" X2,X2", mask+" X2,DX", "BSFW DX,DX", "")
+					if err := checkX86ScalarFPResultInitialization(fn, sig, "amd64"); err != nil {
+						t.Fatal("complete typed X comparison/test/mask rejected", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultPredicateWholeSourceThreeAPIsAndMode32(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, mutation := range []string{"none", "zero edge", "different vector", "GP replaced", "flags replaced"} {
+			t.Run(arch+"/"+mutation, func(t *testing.T) {
+				_, _, source := x86ResultPredicateFixture(t, "VPCMPEQB Y1,Y2,Y3", "VPTEST Y3,Y3", "VPMOVMSKB Y3,DX", "BSFL DX,BX", "")
+				declaration := "func Value(x uint64) uint32\n"
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					declaration, triple = "func Value(x uint32) uint32\n", "i386-unknown-linux-gnu"
+					source = strings.ReplaceAll(source, "MOVQ", "MOVL")
+					source = strings.ReplaceAll(source, "VPBROADCASTQ", "VPBROADCASTD")
+					source = strings.ReplaceAll(source, "ret+8(FP)", "ret+4(FP)")
+					source = strings.Replace(source, "$0-12", "$0-8", 1)
+				}
+				switch mutation {
+				case "zero edge":
+					source = strings.Replace(source, "JZ zero", "JNZ zero", 1)
+				case "different vector":
+					source = strings.Replace(source, "VPMOVMSKB Y3", "VPMOVMSKB Y2", 1)
+				case "GP replaced":
+					source = strings.Replace(source, "BSFL DX,BX", "MOVL $0,DX\nBSFL DX,BX", 1)
+				case "flags replaced":
+					source = strings.Replace(source, "JZ zero", "CMPL AX,$0\nJZ zero", 1)
+				}
+				// Preserve every original self-alias source as a separate
+				// positive. Its already initialized DX supplies numeric bytes
+				// even when the relationship does not prove a nonzero mask.
+				selfAlias := strings.ReplaceAll(strings.Replace(source, "BSFL DX,BX", "BSFL DX,DX", 1), "MOVL BX,ret", "MOVL DX,ret")
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						known, err := x86ScalarFPBitViewAPI(t, selfAlias, declaration, arch, triple, api)
+						if err != nil || known == "" {
+							t.Fatal("original initialized self-alias rejected", err)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if mutation == "none" {
+							if err != nil || ir == "" {
+								t.Fatal("original complete nonzero chain rejected", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("changed chain acquired original predicate", len(ir), err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_ps_logical_store.go b/x86_result_ps_logical_store.go
new file mode 100644
index 000000000..6f76c9985
--- /dev/null
+++ b/x86_result_ps_logical_store.go
@@ -0,0 +1,19 @@
+package plan9asm
+
+// EXTRACTPS already writes separate logical FP fields through
+// storeFPVectorBytes. Its lowering-only result observer must account for those
+// same writes, including parameter copies, without treating them as native
+// caller stores. The complete scalar span excludes pointers, bools and holes;
+// the shared lane effect still requires every selected source byte.
+func (c *amd64Ctx) scalarPSLogicalFPWriteTransfer(ins Instr, state *x86ResultState,
+	owned []bool, arch string) (bool, bool) {
+	form, known, err := x86InsertExtractProperties(ins, arch)
+	if !known || err != nil || !form.spec.scalar || form.spec.insert ||
+		form.memory < 0 || ins.Args[form.destination].Kind != OpFP {
+		return false, false
+	}
+	if _, err := c.scalarFPSpan(ins.Args[form.destination].FPOffset, 32); err != nil {
+		return false, true
+	}
+	return x86ResultScalarPSLaneStep(ins, form, state, owned, 0, arch, false), true
+}
diff --git a/x86_result_ps_logical_store_test.go b/x86_result_ps_logical_store_test.go
new file mode 100644
index 000000000..2cd58ca07
--- /dev/null
+++ b/x86_result_ps_logical_store_test.go
@@ -0,0 +1,158 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86PSLogicalParameterStoreCompleteByteEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		pkg := mustGoPackage(t, "pseffects", "package pseffects\nfunc view(x,y,z,w byte) uint32\n")
+		sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+		if err != nil {
+			t.Fatal(err)
+		}
+		context := amd64Ctx{sig: sig, fpResults: sig.Frame.Results, goarch: arch}
+		for _, op := range []string{"EXTRACTPS", "VEXTRACTPS"} {
+			first, last := 0, 3
+			if op == "VEXTRACTPS" {
+				first, last = -128, 255 // Complete signed/unsigned Go imm8 rows.
+			}
+			for immediate := first; immediate <= last; immediate++ {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, op, immediate), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,X0,x+0(FP)", op, immediate))
+					owned := []bool{true, true, true, true}
+					state := x86ResultState{fp: make([]bool, 4), flags: x86ByteFlagsAll}
+					selected := uint(immediate&3) * 4
+					state.xmm[0] = 0xf << selected
+					state.xmm[1], state.vectorUpper[0] = 0xabcd, ^uint64(0xffff)
+					want := state.clone()
+					for offset := range want.fp {
+						want.fp[offset] = true
+					}
+					if ok, known := context.scalarPSLogicalFPWriteTransfer(ins, &state, owned, arch); !known || !ok || !reflect.DeepEqual(state, want) {
+						t.Fatal("PS store lost exact source/field/FLAGS/alias effects", ok, known)
+					}
+					for byteIndex := uint(0); byteIndex < 4; byteIndex++ {
+						bad := state.clone()
+						bad.xmm[0] &^= 1 << (selected + byteIndex)
+						before := bad.clone()
+						if ok, known := context.scalarPSLogicalFPWriteTransfer(ins, &bad, owned, arch); !known || ok || !reflect.DeepEqual(bad, before) {
+							t.Fatal("PS store manufactured a missing selected byte", byteIndex)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PSLogicalParameterStoreThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, layout := range []struct {
+				name, params string
+				width        int
+			}{
+				{"bytes", "x,y,z,w byte", 4},
+				{"words", "x,y uint16", 4},
+				{"integer", "x uint32", 4},
+				{"float", "x float32", 4},
+				{"wide-integer", "x uint64", 8},
+				{"wide-float", "x float64", 8},
+			} {
+				word := goWordSize(target.arch)
+				result := (layout.width + word - 1) / word * word
+				for _, op := range []string{"EXTRACTPS", "VEXTRACTPS"} {
+					for lane := 0; lane < 4; lane++ {
+						name := fmt.Sprintf("view%d", count)
+						count++
+						fmt.Fprintf(&declarations, "func %s(%s) uint32\n", name, layout.params)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOVL $0x87654321,AX\nMOVL AX,X0\n%s $%d,X0,x+0(FP)\nMOVBLZX x+0(FP),AX\nMOVL AX,ret+%d(FP)\nRET\n", name, result+4, op, lane, result)
+					}
+				}
+			}
+			if got := strings.Count(declarations.String(), "func "); got != 48 {
+				t.Fatalf("incomplete PS source/layout/selector union: %d", got)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			pkg := mustGoPackage(t, "psfields", "package psfields\n"+declarations.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					if got := strings.Count(ir, "define i32 @"); got != 48 {
+						t.Fatalf("lost PS functions: %d", got)
+					}
+					for _, optimizeIR := range []bool{false, true} {
+						input := ir
+						if optimizeIR {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						compileLLVMToObject(t, findLLVM22Tool("llc"), target.triple, "ps-fields.ll", "ps-fields.o", input)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PSLogicalParameterStoreKeepsIndependentRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"EXTRACTPS", "VEXTRACTPS"} {
+			for _, row := range []struct {
+				name, declaration, setup, destination string
+			}{
+				{"unknown-source", "func view(x uint64) uint32", "", "x+0(FP)"},
+				{"missing-selected-byte", "func view(x uint64) uint32", "MOVL $1,AX\nPINSRB $0,AX,X0\n", "x+0(FP)"},
+				{"pointer", "func view(x *byte) uint32", "PXOR X0,X0\n", "x+0(FP)"},
+				{"bool", "func view(x bool,y,z,w byte) uint32", "PXOR X0,X0\n", "x+0(FP)"},
+				{"padding", "func view(x byte,y uint32) uint32", "PXOR X0,X0\n", "x+0(FP)"},
+			} {
+				t.Run(arch+"/"+op+"/"+row.name, func(t *testing.T) {
+					pkg := mustGoPackage(t, "psnegative", "package psnegative\n"+row.declaration+"\n")
+					sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+					if err != nil {
+						t.Fatal(err)
+					}
+					result := sig.Frame.Results[0].Offset
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s%s $0,X0,%s\nMOVL $1,ret+%d(FP)\nRET\n", result+4, row.setup, op, row.destination, result)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration+"\n", arch, testTargetTriple("linux", arch), api)
+						// The existing complete-span binder diagnoses an absent
+						// field before the result observer; this is still an error,
+						// not numerical initialization or storage permission.
+						if arch == "amd64" && (row.name == "unknown-source" || row.name == "missing-selected-byte") {
+							x86VectorScratchCodegenControl(t, source, row.declaration+"\n", arch, testTargetTriple("linux", arch), ir, err)
+						} else if err == nil || ir != "" || row.name != "padding" && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("%s unsupported storage/source acquired permission: %v, IR bytes %d", api, err, len(ir))
+						}
+					}
+				})
+			}
+			// Standalone declaration checks have no paired logical field writer.
+			source := "TEXT view(SB),4,$0-12\nPXOR X0,X0\n" + op + " $0,X0,x+0(FP)\nMOVL $1,ret+8(FP)\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "psdecl", "package psdecl\nfunc view(x uint64) uint32\n")
+			sig, err := DeriveGoFuncABI0Signature("view", pkg.Types.Scope().Lookup("view").(*types.Func), arch, types.SizesFor("gc", arch))
+			if err != nil {
+				t.Fatal(err)
+			}
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("declaration-only query borrowed paired PS writes: %v", err)
+			}
+		}
+	}
+}
diff --git a/x86_result_qword_lookup.go b/x86_result_qword_lookup.go
new file mode 100644
index 000000000..b92456689
--- /dev/null
+++ b/x86_result_qword_lookup.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+func x86RawQwordLookupSource(ins Instr, arch string) bool {
+	_, known, err := x86QwordLookupProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+func x86ResultQwordLookupStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86QwordLookupProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawOrdinaryVectorSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	first := ins.Args[form.first]
+	if form.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, first, int64(form.memoryBytes), state, owned, arch, native) {
+			return false, true
+		}
+	} else if !x86ResultPackedVectorRead(first, int64(form.byteWidth), state, owned, arch) {
+		return false, true
+	}
+	if !x86ResultPackedVectorRead(ins.Args[form.second], int64(form.byteWidth), state, owned, arch) {
+		return false, true
+	}
+	if form.spec.output == amd64QwordBitLookupMask {
+		destination, _ := amd64ParseKReg(ins.Args[form.destination].Reg)
+		state.masks[destination] = true
+	} else {
+		if form.mask >= 0 && !form.zeroing &&
+			!x86ResultPackedVectorRead(ins.Args[form.destination], int64(form.byteWidth), state, owned, arch) {
+			return false, true
+		}
+		destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+		state.writeVector(destination, form.byteWidth, x86CallerVectorByteMask(int64(form.byteWidth)), false)
+	}
+	return true, true // No FLAGS, pointer, backing or reusable memory fact follows.
+}
diff --git a/x86_result_r14_role_test.go b/x86_result_r14_role_test.go
new file mode 100644
index 000000000..5a5c637fc
--- /dev/null
+++ b/x86_result_r14_role_test.go
@@ -0,0 +1,37 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// ABIInternal requires the hidden g value in R14; ABI0 does not. This checks
+// byte-definedness only: it grants no native register entry, g, memory or
+// caller continuation permission, and every GP entry mask remains empty.
+func TestX86ABI0ResultInitializationR14ActualSourceRoles(t *testing.T) {
+	for _, row := range []struct{ typ, move, register string }{
+		{"uint8", "MOVB", "R14B"}, {"uint16", "MOVW", "R14"},
+		{"uint32", "MOVL", "R14"}, {"uint64", "MOVQ", "R14"},
+	} {
+		t.Run(row.move, func(t *testing.T) {
+			body := fmt.Sprintf("MOVQ $0x1122334455667788,R14\n%s %s,AX\n%s AX,ret0+0(FP)\nRET", row.move, row.register, row.move)
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() "+row.typ, body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); err != nil {
+				t.Fatalf("source-defined ABI0 scratch byte rejected as hidden g: %v", err)
+			}
+			unknown := fmt.Sprintf("%s %s,AX\n%s AX,ret0+0(FP)\nRET", row.move, row.register, row.move)
+			_, emptyFile, emptySig, emptySource := x86ResultInitializationFixture(t, "amd64", "func Value() "+row.typ, unknown)
+			goAssemblerOracleOutput(t, "amd64", emptySource, "", true)
+			if err := CheckX86ABI0ResultInitialization(emptyFile.Funcs[0], emptySig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("undefined ABI0 R14 acquired an entry value")
+			}
+			internal := file.Funcs[0]
+			internal.Sym += "<ABIInternal>"
+			if err := CheckX86ABI0ResultInitialization(internal, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ABIInternal was treated as ordinary numeric ABI0")
+			}
+		})
+	}
+}
diff --git a/x86_result_raw_broadcast.go b/x86_result_raw_broadcast.go
new file mode 100644
index 000000000..d4f85f242
--- /dev/null
+++ b/x86_result_raw_broadcast.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+// Scalar, block and K-data broadcasts share the complete typed grammar. This
+// checks original source identity, not numerical inputs or native backing;
+// RIP literals, logical fields and raw entry retain their separate consumers.
+func x86RawBroadcastSource(ins Instr, arch string) bool {
+	_, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Only the paired emitter's exact E6 accesses supply conditional native input.
+// Capture its complete physical form before projecting provenance locally:
+// numeric GP bits, actual K data, masks and old/source vector bytes remain
+// independent obligations, including dead outputs and mode32 GP-Q WIG forms.
+func x86LoweredRawBroadcastStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	f, known, err := x86BroadcastProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86RawBroadcastSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultBroadcastTransfer(local, f, state, owned, arch, true, false)
+}
diff --git a/x86_result_raw_comi.go b/x86_result_raw_comi.go
new file mode 100644
index 000000000..04ba52e11
--- /dev/null
+++ b/x86_result_raw_comi.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+// Zero is absent, not evidence for VEX. The complete decoder captures this
+// physical mode/generation before any lowering-local numerical projection.
+type x86RawCOMIIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86COMIRawIdentity(ins Instr, arch string) x86RawCOMIIdentity {
+	form, known, err := x86COMIProperties(ins, arch)
+	if !known || err != nil || !form.spec.vector {
+		return x86RawCOMIIdentity{}
+	}
+	return x86RawCOMIIdentity{arch, ins.x86Encoded, ins.x86ScalarFlagCompareEVEX}
+}
+
+func x86RawCOMISource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	identity := x86COMIRawIdentity(ins, arch)
+	return origin != nil && identity.arch != "" && origin.comi.arch == arch &&
+		origin.comi == identity && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Check immutable decoded inventory before named/strict success too. Erasing
+// an origin cannot launder a physical comparison into a genuine named source.
+// Replay is restriction-only: it supplies no numerical input or entry role.
+func x86COMIRawReplayRequired(fn Func, arch string) bool {
+	hasRaw := func(instructions []Instr) bool {
+		for _, instruction := range instructions {
+			form, known, _ := x86COMIProperties(instruction, arch)
+			if known && form.spec.vector && (instruction.x86SourceRaw != nil ||
+				instruction.x86Encoded || instruction.x86ScalarFlagCompareEVEX) {
+				return true
+			}
+		}
+		return false
+	}
+	return hasRaw(fn.Instrs) || fn.x86RawReplay != nil && hasRaw(fn.x86RawReplay.decoded)
+}
+
+// Only paired lowering projects an exact ordinary raw comparison onto the
+// existing complete scalar byte/FLAGS effect. RIP DATA, native entry, private
+// frames and reusable pointee facts retain their independent owners.
+func x86LoweredRawCOMIStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	form, known, err := x86COMIProperties(ins, arch)
+	if !known || !form.spec.vector {
+		return false, false
+	}
+	if err != nil || !x86RawCOMISource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultCOMIStepWithRead(local, state, owned, arch, true)
+}
diff --git a/x86_result_raw_fma3.go b/x86_result_raw_fma3.go
new file mode 100644
index 000000000..3fb192d71
--- /dev/null
+++ b/x86_result_raw_fma3.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import "reflect"
+
+// Physical generation is independent of the named spelling, encoded grammar
+// extensions and FP16's MAP6 owner. Zero cannot assert an original VEX form.
+type x86RawFMA3Encoding uint8
+
+const (
+	x86RawFMA3Absent x86RawFMA3Encoding = iota
+	x86RawFMA3VEX
+	x86RawFMA3EVEX
+)
+
+type x86RawFMA3Identity struct {
+	arch     string
+	encoding x86RawFMA3Encoding
+	encoded  bool
+}
+
+func x86FMA3RawIdentity(ins Instr, arch string) x86RawFMA3Identity {
+	form, known, err := amd64FMA3Properties(ins, arch)
+	if !known || err != nil || form.spec.rawOnly ||
+		ins.x86FMA3Encoding != x86RawFMA3VEX && ins.x86FMA3Encoding != x86RawFMA3EVEX {
+		return x86RawFMA3Identity{}
+	}
+	return x86RawFMA3Identity{arch, ins.x86FMA3Encoding, ins.x86Encoded}
+}
+
+func x86RawFMA3EncodingSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	identity := x86FMA3RawIdentity(ins, arch)
+	return origin != nil && identity.encoding != x86RawFMA3Absent && identity.arch == arch && origin.fma3 == identity &&
+		origin.op == ins.Op && origin.vectorBytes == ins.x86VectorBytes &&
+		origin.addressBits == ins.x86AddressBits &&
+		(reflect.DeepEqual(origin.args, ins.Args) || x86RawLiteralSourceIdentity(ins, arch))
+}
+
+func x86RawFMA3Source(ins Instr, arch string) bool {
+	return x86RawFMA3EncodingSource(ins, arch) && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// The DATA image and canonical raw RET keep their independent existing owner.
+// An exact FMA encoding cannot substitute an arbitrary symbolic native read.
+func x86RawFMA3LiteralForm(ins Instr, arch string) bool {
+	if !x86RawFMA3EncodingSource(ins, arch) || !x86RawLiteralSourceIdentity(ins, arch) {
+		return false
+	}
+	form, known, err := amd64FMA3Properties(ins, arch)
+	return known && err == nil && !form.spec.rawOnly && form.memory == 0 &&
+		ins.x86RIPMemoryRead.source == 0 && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
+
+// An authenticated FMA changes its vector destination and MXCSR, not DF, ID
+// or private FLAGS storage. Preserving those independent facts supplies no
+// arithmetic inputs, memory backing, entry authority or inert-data predicate.
+func x86FMA3PreservesPrivateSourceState(ins Instr, arch string) bool {
+	return x86RawFMA3Source(ins, arch) || x86RawFMA3LiteralForm(ins, arch)
+}
+
+// A restriction selected from immutable original instructions precedes strict
+// NUM success too. Removing a mutable origin cannot erase its replay duty.
+func x86FMA3RawReplayRequired(fn Func, arch string) bool {
+	hasProducer := func(instructions []Instr) bool {
+		for _, ins := range instructions {
+			form, known, _ := amd64FMA3Properties(ins, arch)
+			if known && !form.spec.rawOnly && (ins.x86SourceRaw != nil || ins.x86FMA3Encoding != x86RawFMA3Absent) {
+				return true
+			}
+		}
+		return false
+	}
+	return hasProducer(fn.Instrs) || fn.x86RawReplay != nil && hasProducer(fn.x86RawReplay.decoded)
+}
diff --git a/x86_result_raw_gp_simd.go b/x86_result_raw_gp_simd.go
new file mode 100644
index 000000000..b4d0a0fa2
--- /dev/null
+++ b/x86_result_raw_gp_simd.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import "reflect"
+
+// VMOVW is absent from Go's named table. Only its exact decoder-bound
+// register/m16 form may share the ordinary GP/X numerical transfer. This
+// observation grants no physical entry, raw return, frame or caller memory.
+func x86RawVMOVWResultForm(ins Instr, arch string) (x86GPSIMDTransferForm, bool) {
+	if ins.Op != "VMOVW" || !ins.x86Encoded || ins.x86SourceRaw == nil ||
+		ins.x86RawNearReturn != nil || ins.x86AddressBits != 0 ||
+		ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 ||
+		ins.x86RIPLiteral || ins.x86NumericalRead != nil ||
+		ins.x86SourceRaw.op != ins.Op || !reflect.DeepEqual(ins.x86SourceRaw.args, ins.Args) {
+		return x86GPSIMDTransferForm{}, false
+	}
+	form, known, err := x86GPSIMDTransferProperties(ins, arch)
+	if !known || err != nil || !form.spec.rawOnly || form.bits != 16 || form.mmx {
+		return form, false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg && (operand.Kind != OpMem ||
+			operand.Mem.Sym != "" || operand.Mem.Segment != "" || !x86OrdinaryNativeMemoryOperand(operand, arch)) {
+			return form, false
+		}
+	}
+	return form, true
+}
+
+// The paired lowerer retains exact volatile i16 accesses. Continuing past a
+// read supplies only those two numerical bytes; it does not assert validity,
+// alignment, extent, aliasing or a reusable memory fact. Unknown register
+// inputs remain required even when the instruction's result is dead.
+func x86LoweredRawVMOVWResultStep(ins Instr, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if ins.Op != "VMOVW" {
+		return false, false
+	}
+	form, valid := x86RawVMOVWResultForm(ins, arch)
+	if !valid {
+		return false, true
+	}
+	if form.sourceX {
+		index, _ := amd64ParseXReg(ins.Args[0].Reg)
+		if state.xmm[index]&3 != 3 {
+			return false, true
+		}
+	} else if ins.Args[0].Kind == OpReg && !x86ResultRead(ins.Args[0], 2, state, owned, arch) {
+		return false, true
+	}
+	// Project only this already-validated effect into the shared byte rule.
+	// The actual source, raw identity and lowerer's ISA attributes stay intact.
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	form.spec.rawOnly = false
+	return x86ResultGPSIMDTransferWithNativeMemory(local, form, state, owned, resultOffset, arch, true), true
+}
diff --git a/x86_result_raw_integer_compare.go b/x86_result_raw_integer_compare.go
new file mode 100644
index 000000000..2848d14d8
--- /dev/null
+++ b/x86_result_raw_integer_compare.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+// The complete legacy X/VEX X/Y/EVEX K-result grammar remains independent of
+// raw source authentication. Physical MMX/x87 regions, RIP literals, source
+// frames and entry permissions retain their existing separate consumers.
+func x86RawPackedIntegerCompareSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch)
+	return known && err == nil && !form.mmx && x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
+
+// Only the paired original opcode or exact volatile E4 accesses supply this
+// conditional numerical result. Preserve the captured physical form before
+// projecting provenance locally: mode32's real four-operand EVEX instruction
+// must not be reparsed under the different named-frontend arity limit.
+func x86LoweredPackedIntegerCompareStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86RawPackedIntegerCompareSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultVectorCompareTransfer(local, form, state, owned, arch, true)
+}
diff --git a/x86_result_raw_legacy_float_compare.go b/x86_result_raw_legacy_float_compare.go
new file mode 100644
index 000000000..f79717783
--- /dev/null
+++ b/x86_result_raw_legacy_float_compare.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+// Legacy compare opcodes have a different immediate position from VCMP and
+// different packed alignment/scalar passthrough effects. Bind their complete
+// decoded identity before reusing the existing numerical family. The original
+// native opcode, not a mathematical predicate projection, owns MXCSR and faults.
+type x86RawLegacyFloatCompareIdentity struct {
+	arch    string
+	encoded bool
+}
+
+func x86LegacyFloatCompareRawIdentity(ins Instr, arch string) x86RawLegacyFloatCompareIdentity {
+	form, known, err := x86FloatCompareProperties(ins, arch)
+	if !known || err != nil || !form.legacy {
+		return x86RawLegacyFloatCompareIdentity{}
+	}
+	return x86RawLegacyFloatCompareIdentity{arch: arch, encoded: ins.x86Encoded}
+}
+
+func x86RawLegacyFloatCompareSource(ins Instr, arch string) bool {
+	form, known, err := x86FloatCompareProperties(ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && form.legacy && origin != nil &&
+		origin.legacyFloatCompare.arch == arch &&
+		origin.legacyFloatCompare == x86LegacyFloatCompareRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, form.first)
+}
diff --git a/x86_result_raw_mask_compare.go b/x86_result_raw_mask_compare.go
new file mode 100644
index 000000000..128ee049a
--- /dev/null
+++ b/x86_result_raw_mask_compare.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+func x86RawImmediatePackedCompareSource(ins Instr, arch string) bool {
+	_, known, err := x86ImmediatePackedCompareProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSourceAt(ins, arch, 1)
+}
+
+func x86LoweredImmediatePackedCompareStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86ImmediatePackedCompareProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawImmediatePackedCompareSource(ins, arch) {
+			return false, true
+		}
+		// The complete original selector and every operand remain bound.
+		// Only this paired numerical transfer consumes a named local view.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultVectorCompareTransfer(ins, form.x86PackedIntegerCompareForm, state, owned, arch, true)
+}
diff --git a/x86_result_raw_packed_shift.go b/x86_result_raw_packed_shift.go
new file mode 100644
index 000000000..bed3a3d58
--- /dev/null
+++ b/x86_result_raw_packed_shift.go
@@ -0,0 +1,87 @@
+package plan9asm
+
+import "reflect"
+
+// Zero is absent physical identity, never an assertion that an instruction was
+// VEX. Low-bank unmasked X/Y operands do not distinguish VEX from EVEX.
+type x86RawPackedShiftEncoding uint8
+
+const (
+	x86RawPackedShiftAbsent x86RawPackedShiftEncoding = iota
+	x86RawPackedShiftVEX
+	x86RawPackedShiftEVEX
+)
+
+type x86RawPackedShiftIdentity struct {
+	arch     string
+	encoding x86RawPackedShiftEncoding
+	w        bool
+}
+
+func x86PackedShiftRawIdentity(ins Instr, arch string) x86RawPackedShiftIdentity {
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.legacy || !ins.x86Encoded ||
+		ins.x86PackedShiftEncoding != x86RawPackedShiftVEX && ins.x86PackedShiftEncoding != x86RawPackedShiftEVEX {
+		return x86RawPackedShiftIdentity{}
+	}
+	return x86RawPackedShiftIdentity{arch, ins.x86PackedShiftEncoding, ins.x86PackedShiftW}
+}
+
+func x86RawPackedShiftEncodingSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && !form.legacy && origin != nil && origin.packedShift.arch == arch &&
+		origin.packedShift == x86PackedShiftRawIdentity(ins, arch) && origin.op == ins.Op &&
+		origin.vectorBytes == ins.x86VectorBytes && origin.addressBits == ins.x86AddressBits &&
+		(reflect.DeepEqual(origin.args, ins.Args) || x86RawLiteralSourceIdentity(ins, arch))
+}
+
+func x86RawPackedShiftSource(ins Instr, arch string) bool {
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86RawPackedShiftEncodingSource(ins, arch) ||
+		x86Mode32VectorRegisterContext(ins, arch) != nil {
+		return false
+	}
+	// Immediate selectors retain their original position and byte. The selected
+	// operand checks ordinary native memory only; RIP/DATA and logical fields
+	// retain separate owners and cannot borrow this continuation.
+	source := form.data
+	if form.memory >= 0 {
+		source = form.memory
+	}
+	return x86RawOrdinaryVectorSourceAt(ins, arch, source)
+}
+
+// Select this restriction from the immutable decoded inventory, before strict
+// NUM success. Erasing a mutable origin must not turn raw bytes into a genuine
+// named instruction. No replay supplies any missing input or native entry.
+func x86PackedShiftRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay == nil {
+		return false
+	}
+	for _, ins := range fn.x86RawReplay.decoded {
+		if form, known, _ := x86PackedShiftProperties(ins.Op, ins, arch); known && !form.legacy {
+			return true
+		}
+	}
+	return false
+}
+
+// Only lowering's complete-source owner may project the exact decoded shift
+// onto the existing typed byte/count/mask effect. It creates neither reusable
+// memory facts nor caller, frame, raw-RET, physical-SP or entry permissions.
+func x86LoweredRawPackedShiftStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86PackedShiftProperties(ins.Op, ins, arch)
+	if !known || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if err != nil || !x86RawPackedShiftSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	local.x86PackedShiftEncoding, local.x86PackedShiftW = x86RawPackedShiftAbsent, false
+	// Keep the already-validated physical form: mode32 masks have four operands
+	// even though Go's genuine named mode32 frontend still has its old arity cap.
+	return x86ResultPackedShiftInputs(local, form, state, owned, arch, true), true
+}
diff --git a/x86_result_raw_scalar_float_integer.go b/x86_result_raw_scalar_float_integer.go
new file mode 100644
index 000000000..d4af5db30
--- /dev/null
+++ b/x86_result_raw_scalar_float_integer.go
@@ -0,0 +1,27 @@
+package plan9asm
+
+// A zero identity is absent, not an assertion of legacy/VEX generation.
+// The decoder captures physical mode and EVEX separately from a named form's
+// inferred ISA needs. This snapshot grants no numerical or native entry facts.
+type x86RawScalarFloatIntegerIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86ScalarFloatIntegerRawIdentity(ins Instr, arch string) x86RawScalarFloatIntegerIdentity {
+	form, known, err := x86ScalarFloatIntegerProperties(ins, arch)
+	if !known || err != nil || form.evex != ins.x86ScalarFloatIntegerEVEX {
+		return x86RawScalarFloatIntegerIdentity{}
+	}
+	return x86RawScalarFloatIntegerIdentity{arch, ins.x86Encoded, ins.x86ScalarFloatIntegerEVEX}
+}
+
+// Validate the complete current form against its immutable physical snapshot.
+// The whole-function replay separately authenticates all original producers;
+// neither identity supplies an absent pointer, index, vector or MXCSR input.
+func x86RawScalarFloatIntegerSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	identity := x86ScalarFloatIntegerRawIdentity(ins, arch)
+	return origin != nil && identity.arch == arch && origin.scalarFloatInteger == identity &&
+		x86RawOrdinaryVectorSource(ins, arch)
+}
diff --git a/x86_result_raw_scalar_observer.go b/x86_result_raw_scalar_observer.go
new file mode 100644
index 000000000..5d5483250
--- /dev/null
+++ b/x86_result_raw_scalar_observer.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+func x86RawScalarObserverSource(ins Instr, arch string) bool {
+	_, count, err := x86ScalarBitCountProperties(ins.Op, ins, arch)
+	if !count {
+		form, mask, maskErr := x86MoveMaskProperties(ins.Op, ins, arch)
+		if !mask || maskErr != nil || form.byteWidth == 8 {
+			return false // Physical MMX/x87 state retains its separate owner.
+		}
+	}
+	return err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Exact decoded source identity composes with the existing scalar-count or
+// move-mask effect. Only the paired native read may supply numerical bytes;
+// declaration, caller, physical entry and reusable-memory roles stay strict.
+func x86LoweredRawScalarObserverStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	_, count, _ := x86ScalarBitCountProperties(ins.Op, ins, arch)
+	var maskForm x86MoveMaskForm
+	if !count {
+		var mask bool
+		if maskForm, mask, _ = x86MoveMaskProperties(ins.Op, ins, arch); !mask {
+			return false, false
+		}
+	}
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if !x86RawScalarObserverSource(ins, arch) {
+		return false, true
+	}
+	if !count {
+		// Erasing the exact raw origin must not create the named-only
+		// adjacent partial-bit role. Retain the original complete input.
+		index, _ := amd64VectorRegisterIndex(ins.Args[0].Reg, maskForm.byteWidth)
+		required := x86CallerVectorByteMask(int64(maskForm.byteWidth))
+		if state.vectorBytes(index)&required != required {
+			return false, true
+		}
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	if count {
+		if accepted, known := x86LoweredScalarBitCountNativeRead(local, state, owned, resultOffset, arch); known {
+			return accepted, true
+		}
+	}
+	return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_raw_scalar_observer_test.go b/x86_result_raw_scalar_observer_test.go
new file mode 100644
index 000000000..873cd65db
--- /dev/null
+++ b/x86_result_raw_scalar_observer_test.go
@@ -0,0 +1,292 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86RawScalarObserverOriginsAndEveryInputByte(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var rows []string
+		for _, stem := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			widths := []string{"W", "L"}
+			if arch == "amd64" {
+				widths = append(widths, "Q")
+			}
+			for _, width := range widths {
+				rows = append(rows, stem+width+" AX,BX")
+			}
+		}
+		for _, op := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+			rows = append(rows, op+" X1,BX")
+			if strings.HasPrefix(op, "V") {
+				rows = append(rows, op+" Y1,BX")
+			}
+		}
+		for _, row := range rows {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawScalarObserverSource(ins, arch) {
+				t.Fatal("complete original count/mask source not recognized", row)
+			}
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.gp[0], state.gp[3] = 0xff, 0x80
+			state.writeVector(1, 64, ^uint64(0), false)
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+				{"opcode", func(ins *Instr) {
+					if strings.Contains(row, "CNT") {
+						ins.Op = "TZCNTL"
+						if ins.x86SourceRaw.op == "TZCNTL" {
+							ins.Op = "LZCNTL"
+						}
+					} else {
+						ins.Op = "VMOVMSKPS"
+						if ins.x86SourceRaw.op == "VMOVMSKPS" {
+							ins.Op = "VMOVMSKPD"
+						}
+					}
+				}},
+				{"operand", func(ins *Instr) { ins.Args[1].Reg = DX }},
+				{"source-operand", func(ins *Instr) { ins.x86SourceRaw.args[1].Reg = DX }},
+				{"vector", func(ins *Instr) { ins.x86VectorBytes = 64 }},
+				{"address", func(ins *Instr) { ins.x86AddressBits = 32 }},
+				{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+				{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+				{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+			} {
+				t.Run(arch+"/"+row+"/"+control.name, func(t *testing.T) {
+					changed, next := ins, state.clone()
+					changed.Args = append([]Operand(nil), ins.Args...)
+					origin := *ins.x86SourceRaw
+					origin.args = append([]Operand(nil), origin.args...)
+					changed.x86SourceRaw = &origin
+					control.change(&changed)
+					accepted, known := x86LoweredRawScalarObserverStep(changed, &next, nil, 0, arch)
+					if accepted || known != (control.name != "origin") || x86RawScalarObserverSource(changed, arch) || !reflect.DeepEqual(state, next) {
+						t.Fatal("changed source acquired a numerical/native role", accepted, known)
+					}
+				})
+			}
+			width := 16
+			mask := !strings.Contains(row, "CNT")
+			if mask {
+				if ins.Args[0].Reg == "Y1" {
+					width = 32
+				}
+			} else {
+				width = 4
+				if strings.HasSuffix(string(ins.Op), "W") {
+					width = 2
+				} else if strings.HasSuffix(string(ins.Op), "Q") {
+					width = 8
+				}
+			}
+			for missing := -1; missing < width; missing++ {
+				t.Run(fmt.Sprintf("%s/%s/missing=%d", arch, row, missing), func(t *testing.T) {
+					next := state.clone()
+					if missing >= 0 {
+						if mask {
+							next.writeVector(1, 64, ^uint64(0)&^(1<<uint(missing)), false)
+						} else {
+							next.gp[0] &^= 1 << uint(missing)
+						}
+					}
+					before := next.clone()
+					accepted, known := x86LoweredRawScalarObserverStep(ins, &next, nil, 0, arch)
+					if !known || accepted != (missing < 0) || !accepted && !reflect.DeepEqual(before, next) {
+						t.Fatal("raw projection invented an input byte or mutated failed state", accepted, known)
+					}
+					if accepted {
+						want := uint8(0xff)
+						if width == 2 {
+							want = 0x83
+						}
+						if next.gp[3] != want {
+							t.Fatal("wrong exact GP write/zero-extension", next.gp[3], want)
+						}
+						before.gp[3] = want
+						if !mask && !strings.HasPrefix(row, "POPCNT") {
+							before.flags = x86ByteFlagCF | x86ByteFlagZF
+						}
+						if !reflect.DeepEqual(before, next) {
+							t.Fatal("count/mask changed unrelated state or retained undefined FLAGS")
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RawScalarObserverDoesNotGrantMemoryOrMMXRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{"POPCNTW (DI),BX", "LZCNTL (DI),BX", "TZCNTL (DI),BX", "PMOVMSKB M1,BX"} {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.gp[7] = 0xff        // Complete numerical address bits, not a pointer/storage role.
+				state.nativeMMX[1] = 0xff // Bytes alone are not an x87/MMX owner.
+				before := state.clone()
+				accepted, known := x86LoweredRawScalarObserverStep(ins, &state, nil, 0, arch)
+				if strings.HasPrefix(row, "PMOVMSKB") {
+					if accepted || !known || !reflect.DeepEqual(before, state) || x86RawScalarObserverSource(ins, arch) {
+						t.Fatal("ordinary numerical source allowed physical MMX input", accepted, known)
+					}
+					return
+				}
+				// Only the paired volatile read supplies the result if it
+				// continues. No memory extent or reusable identity is created.
+				want := before.clone()
+				want.gp[3] = 0xff
+				if strings.HasPrefix(row, "POPCNTW") {
+					want.gp[3] = 3
+				} else {
+					want.flags = x86ByteFlagCF | x86ByteFlagZF
+				}
+				if !accepted || !known || !reflect.DeepEqual(want, state) {
+					t.Fatal("paired count read lost its exact result or created unrelated facts", accepted, known)
+				}
+				for _, address := range []string{"unknown", "partial"} {
+					t.Run(address, func(t *testing.T) {
+						next := before.clone()
+						next.gp[7] = 0
+						if address == "partial" {
+							word := uint(x86ResultPointerWord(arch))
+							next.gp[7] = uint8((uint16(1)<<word)-1) &^ (1 << (word - 1))
+						}
+						unchanged := next.clone()
+						accepted, known := x86LoweredRawScalarObserverStep(ins, &next, nil, 0, arch)
+						if accepted || !known || !reflect.DeepEqual(unchanged, next) {
+							t.Fatal("paired read invented missing address bits or changed rejected state", accepted, known)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func x86RawNumericalInstruction(t *testing.T, arch, instruction string) string {
+	t.Helper()
+	code := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+	if len(code) < 2 || code[len(code)-1] != 0xc3 {
+		t.Fatal("original numerical instruction lost its exact terminal near RET", instruction)
+	}
+	return x86DwordProductDirectives(code[:len(code)-1])
+}
+
+func TestX86RawScalarCountCompleteFamilyNativeObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			widths := []string{"W", "L", "Q"}
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+				widths = widths[:2] // Q has no Go mode32 encoder row.
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, stem := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+				for _, width := range widths {
+					for _, memory := range []bool{false, true} {
+						for _, raw := range []bool{false, true} {
+							name, input := fmt.Sprintf("Count%d", count), "AX"
+							if memory {
+								input = "(BX)"
+							}
+							line := stem + width + " " + input + ",CX"
+							if raw {
+								line = x86RawNumericalInstruction(t, target.arch, line)
+							}
+							fmt.Fprintf(&declarations, "func %s(value uintptr,input *[8]byte) uintptr\n", name)
+							fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s value+0(FP),AX\n%s input+%d(FP),BX\n%s $-1,CX\n%s\n%s CX,ret+%d(FP)\nRET\n",
+								name, 3*word, move, move, word, move, line, move, 2*word)
+							count++
+						}
+					}
+				}
+			}
+			if count != 12*len(widths) {
+				t.Fatal("incomplete scalar count matrix", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func TestX86RawMoveMaskCompleteFamilyNativeObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range []string{"PMOVMSKB", "MOVMSKPS", "MOVMSKPD", "VPMOVMSKB", "VMOVMSKPS", "VMOVMSKPD"} {
+				banks := []string{"X"}
+				if strings.HasPrefix(op, "V") {
+					banks = append(banks, "Y")
+				}
+				for _, bank := range banks {
+					for _, raw := range []bool{false, true} {
+						name := fmt.Sprintf("Mask%d", count)
+						line := op + " " + bank + "1,AX"
+						if raw {
+							line = x86RawNumericalInstruction(t, target.arch, line)
+						}
+						fmt.Fprintf(&declarations, "func %s(input *[32]byte) uintptr\n", name)
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),BX\nVMOVDQU (BX),Y1\n%s\n%s AX,ret+%d(FP)\nRET\n",
+							name, 2*word, move, line, move, word)
+						count++
+					}
+				}
+			}
+			if count != 18 {
+				t.Fatal("incomplete legacy/VEX X/Y move-mask matrix", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func x86RawNumericalFamilyObjects(t *testing.T, source, declarations, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, "#include \"textflag.h\"\n"+source)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+		if err != nil {
+			t.Fatal("complete raw numerical family lost its paired native inputs", api, err)
+		}
+		for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, text, level)
+			}
+		}
+	}
+}
diff --git a/x86_result_raw_vector_move.go b/x86_result_raw_vector_move.go
new file mode 100644
index 000000000..a995d2f0d
--- /dev/null
+++ b/x86_result_raw_vector_move.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import "strings"
+
+// This family-local identity check supplies no numerical bytes or memory
+// authority. Validate the complete typed form before consuming it as an effect.
+// Both memory directions are checked: a register source cannot hide a symbolic,
+// segmented, logical-frame or changed destination address.
+func x86RawVectorMoveOperandIdentity(ins Instr, arch string) bool {
+	if arch != "386" && arch != "amd64" || !x86RawOrdinaryVectorSource(ins, arch) {
+		return false
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind != OpReg && (operand.Kind != OpMem || operand.Mem.Sym != "" ||
+			operand.Mem.Segment != "" || !x86OrdinaryNativeMemoryOperand(operand, arch)) {
+			return false
+		}
+		if operand.Kind == OpReg && arch == "386" {
+			index, vector := amd64VectorRegisterIndex(operand.Reg, amd64VectorByteWidth(operand.Reg))
+			if vector && index >= 8 {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+// A low-bank physical EVEX scalar mask can have four operands in mode32 even
+// though Go's named frontend has a three-operand cap. This identifies only that
+// exact decoder source; the complete scalar grammar still validates every role.
+func x86RawScalarVectorMoveIdentity(ins Instr, arch string) bool {
+	name, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := amd64ScalarVectorMoveSpecs[Op(name)]
+	return known && !spec.legacy && !spec.rawOnly && (spec.bits == 32 || spec.bits == 64) &&
+		x86RawVectorMoveOperandIdentity(ins, arch)
+}
+
+func x86RawPackedVectorMoveSourceForm(ins Instr, arch string) (amd64PackedVectorMoveForm, bool) {
+	form, known, err := amd64PackedVectorMoveProperties(ins, arch)
+	return form, known && err == nil && !form.undefinedOpcode() &&
+		x86RawPackedMoveEncodingSource(ins, arch) && x86RawVectorMoveOperandIdentity(ins, arch)
+}
+
+func x86RawScalarVectorMoveSourceForm(ins Instr, arch string) (amd64ScalarVectorMoveForm, bool) {
+	form, known, err := amd64ScalarVectorMoveProperties(ins, arch)
+	return form, known && err == nil && !form.literal && x86RawScalarVectorMoveIdentity(ins, arch)
+}
+
+func x86RawVectorMoveSource(ins Instr, arch string) bool {
+	if _, valid := x86RawPackedVectorMoveSourceForm(ins, arch); valid {
+		return true
+	}
+	_, valid := x86RawScalarVectorMoveSourceForm(ins, arch)
+	return valid
+}
+
+// Source-local constants retain their existing bounded literal/replay/DATA and
+// raw-return consumer. This is not the ordinary native-read continuation above.
+// Aligned packed loads still need their independent original pool alignment;
+// a newly materialized DATA global must not invent that physical backing.
+func x86RawVectorMoveLiteralSource(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) ||
+		ins.x86RIPMemoryRead.source != 0 {
+		return false
+	}
+	if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known {
+		return err == nil && !form.spec.aligned && form.memory == 0 && x86RawPackedMoveEncodingSource(ins, arch) &&
+			ins.x86RIPMemoryRead.width == int64(form.byteWidth)
+	}
+	form, known, err := amd64ScalarVectorMoveProperties(ins, arch)
+	return known && err == nil && !form.spec.legacy && !form.spec.rawOnly && form.memory == 0 &&
+		ins.x86RIPMemoryRead.width == int64(form.spec.bits/8)
+}
+
+func x86ResultRawVectorMoveLiteralStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	if !x86RawVectorMoveLiteralSource(ins, arch) {
+		return false, false
+	}
+	if form, known, _ := amd64PackedVectorMoveProperties(ins, arch); known && form.mask >= 0 && !form.zeroing {
+		destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+		required := x86CallerVectorByteMask(int64(form.byteWidth))
+		if state.vectorBytes(destination)&required != required {
+			return false, true // A possible inactive lane still consumes its actual old byte, including Void.
+		}
+	}
+	return x86ScalarFPResultTransfer(ins, state, owned, resultOffset, arch), true
+}
+
+// Exact decoded moves compose only in the paired lowering observer. Retain the
+// captured physical form while projecting provenance locally; original source,
+// native entry, caller, FP/AUTO and standalone declaration roles are unchanged.
+func x86LoweredRawVectorMoveStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	if x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if _, known, _ := amd64PackedVectorMoveProperties(ins, arch); known {
+		form, valid := x86RawPackedVectorMoveSourceForm(ins, arch)
+		if !valid {
+			return false, true
+		}
+		if form.memory >= 0 {
+			memory := ins.Args[form.memory]
+			if form.memoryWrite {
+				if !x86ResultIncomingPointerAddressIdentity(memory, state, arch) {
+					return false, true
+				}
+			} else if !x86ResultIncomingPointerReadAddressIdentity(memory, state, arch) {
+				return false, true
+			}
+		}
+		local := ins
+		local.x86Encoded, local.x86SourceRaw = false, nil
+		return x86ResultPackedVectorMoveTransfer(local, form, state, owned, resultOffset, arch, true), true
+	}
+	form, known, _ := amd64ScalarVectorMoveProperties(ins, arch)
+	if !known || form.spec.legacy || form.spec.rawOnly {
+		return false, false
+	}
+	var valid bool
+	form, valid = x86RawScalarVectorMoveSourceForm(ins, arch)
+	if !valid {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ScalarVectorMoveResultTransfer(local, form, state, owned, resultOffset, arch, true), true
+}
+
+// Named scalar moves use this continuation only for their actual ordinary
+// native memory path. Virtual fields and native stores have distinct effects;
+// neither a load nor a defined mask supplies a future-read/backing certificate.
+func x86LoweredScalarVectorMoveMemoryStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := amd64ScalarVectorMoveProperties(ins, arch)
+	if !known || form.spec.legacy || form.spec.rawOnly || form.memory < 0 ||
+		!x86ScalarVectorMoveOrdinaryMemory(ins.Args[form.memory], form.spec.bits, arch) ||
+		!x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	return err == nil && x86ScalarVectorMoveResultTransfer(ins, form, state, owned, resultOffset, arch, true), true
+}
diff --git a/x86_result_repeat_empty.go b/x86_result_repeat_empty.go
new file mode 100644
index 000000000..c51572c7f
--- /dev/null
+++ b/x86_result_repeat_empty.go
@@ -0,0 +1,200 @@
+package plan9asm
+
+// This bounded projection observes only the zero-iteration case of an already
+// accepted original REP/REPN comparison. It does not define FLAGS or change an
+// executable edge. The ordinary transfer still checks every nonempty access,
+// operand and result; both empty-case successors must independently return the
+// same complete constant result without any observable memory/control effect.
+func x86ResultRepeatEmptyBranch(instructions []Instr, edges [][]int, previous []int,
+	pc int, owned []bool, resultOffset int64, arch string) (bool, int) {
+	const limit = 32
+	work := 0
+	stepBack := func(at int) int {
+		if at > 0 && previous[at] == at-1 && len(edges[at-1]) == 1 && edges[at-1][0] == at {
+			return at - 1
+		}
+		return -1
+	}
+	plain := func(ins Instr) bool { return x86ResultNamedPredicateInstruction(ins) }
+	harmless := func(ins Instr) bool {
+		return plain(ins) && len(ins.Args) == 0 && (ins.Op == "CLD" || ins.Op == "STD" || ins.Op == "NOP")
+	}
+	if pc < 0 || pc >= len(instructions) || !plain(instructions[pc]) ||
+		!isAMD64ConditionalBranch(instructions[pc].Op) || len(edges[pc]) != 2 {
+		return false, work
+	}
+	comparison := stepBack(pc)
+	for comparison >= 0 && harmless(instructions[comparison]) && work < limit {
+		work++
+		comparison = stepBack(comparison)
+	}
+	if comparison < 0 || work >= limit {
+		return false, work
+	}
+	form, known, err := x86StringInstructionProperties(instructions[comparison], arch)
+	prefix := stepBack(comparison)
+	if !known || err != nil || !plain(instructions[comparison]) ||
+		(form.kind != "scas" && form.kind != "cmps") || prefix < 0 ||
+		!plain(instructions[prefix]) || len(instructions[prefix].Args) != 0 ||
+		(instructions[prefix].Op != "REP" && instructions[prefix].Op != "REPN") {
+		return false, work
+	}
+	// Recover exact copies only in one short, straight-line predecessor region.
+	// Different loads/affine offsets never share an identity just because their
+	// caller-address origins happen to match. Every other write kills equality.
+	start := prefix
+	for count := 0; count < limit; count++ {
+		before := stepBack(start)
+		if before < 0 {
+			break
+		}
+		start = before
+	}
+	var identities [16]uint16
+	next := uint16(len(identities))
+	for index := range identities {
+		identities[index] = uint16(index + 1)
+	}
+	word := x86ResultPointerWord(arch)
+	move, subtract := Op("MOVQ"), Op("SUBQ")
+	if arch == "386" {
+		move, subtract = "MOVL", "SUBL"
+	}
+	for at := start; at < comparison; at++ {
+		work++
+		ins := x86SourceMoveInstruction(instructions[at], arch)
+		width := x86RawReturnScalarMoveBytes(ins.Op)
+		if plain(ins) && width != 0 && len(ins.Args) == 2 && ins.Args[1].Kind == OpReg {
+			destination, _, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+			if !valid {
+				return false, work
+			}
+			next++
+			identity := next
+			if width == word && ins.Args[0].Kind == OpReg {
+				if source, _, valid := x86ResultGP(ins.Args[0].Reg, word, arch); valid {
+					identity = identities[source]
+				}
+			}
+			identities[destination] = identity
+		} else if !harmless(ins) && ins.Op != "REP" && ins.Op != "REPN" {
+			for index := range identities {
+				next++
+				identities[index] = next
+			}
+		}
+	}
+	type value struct {
+		identity uint16
+		bits     uint64
+		known    bool
+	}
+	var initial [16]value
+	for index, identity := range identities {
+		initial[index] = value{identity: identity, known: true}
+	}
+	initial[1] = value{known: true} // Only this projection assumes native CX=0.
+	mask := ^uint64(0)
+	if arch == "386" {
+		mask = 1<<32 - 1
+	}
+	// There is no second CFG/fixed point here: each successor is a bounded,
+	// forward-only scalar continuation. The caller charges all steps to the
+	// existing shared source-flow work envelope; no mutable proof is cached.
+	observe := func(at int) ([]uint16, bool) {
+		registers := initial
+		result := make([]uint16, len(owned)) // 0 unknown; otherwise exact byte+1.
+		read := func(operand Operand) value {
+			if operand.Kind == OpImm && operand.ImmRaw == "" && !operand.ImmIsFloat {
+				return value{bits: uint64(operand.Imm) & mask, known: true}
+			}
+			if operand.Kind == OpReg {
+				if index, _, valid := x86ResultGP(operand.Reg, word, arch); valid {
+					return registers[index]
+				}
+			}
+			return value{}
+		}
+		for count := 0; count < limit && at >= 0 && at < len(instructions); count++ {
+			work++
+			ins := x86SourceMoveInstruction(instructions[at], arch)
+			if !plain(ins) {
+				return nil, false
+			}
+			if ins.Op == OpRET && len(ins.Args) == 0 {
+				for offset, required := range owned {
+					if int64(offset) >= resultOffset && required && result[offset] == 0 {
+						return nil, false
+					}
+				}
+				return result, true
+			}
+			if !(ins.Op == "NOP" && len(ins.Args) == 0) && ins.Op != OpJMP {
+				if (ins.Op != move && ins.Op != subtract) || len(ins.Args) != 2 {
+					return nil, false
+				}
+				// MOV uses the ordinary full-word move grammar already checked
+				// source-wide. Arithmetic also binds its typed effect here.
+				if ins.Op == subtract {
+					if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err != nil {
+						return nil, false
+					}
+				}
+				v, destination := read(ins.Args[0]), ins.Args[1]
+				if !v.known {
+					return nil, false
+				}
+				if destination.Kind == OpReg {
+					index, _, valid := x86ResultGP(destination.Reg, word, arch)
+					if !valid {
+						return nil, false
+					}
+					if ins.Op == subtract {
+						old := registers[index]
+						if !old.known || v.identity != 0 && old.identity != v.identity {
+							return nil, false
+						}
+						old.bits = (old.bits - v.bits) & mask
+						if v.identity != 0 {
+							old.identity = 0 // Exact same opaque value cancels.
+						}
+						v = old
+					}
+					registers[index] = v
+				} else if destination.Kind == OpFP && ins.Op == move && v.identity == 0 {
+					offset := destination.FPOffset
+					if offset < resultOffset || offset < 0 || offset > int64(len(owned))-word {
+						return nil, false
+					}
+					for byte := int64(0); byte < word; byte++ {
+						if !owned[offset+byte] {
+							return nil, false
+						}
+						result[offset+byte] = uint16(uint8(v.bits>>uint(8*byte))) + 1
+					}
+				} else {
+					return nil, false
+				}
+			}
+			if len(edges[at]) != 1 || edges[at][0] <= at {
+				return nil, false
+			}
+			at = edges[at][0]
+		}
+		return nil, false
+	}
+	left, valid := observe(edges[pc][0])
+	if !valid {
+		return false, work
+	}
+	right, valid := observe(edges[pc][1])
+	if !valid || len(left) != len(right) {
+		return false, work
+	}
+	for index := range left {
+		if left[index] != right[index] {
+			return false, work
+		}
+	}
+	return true, work
+}
diff --git a/x86_result_sad.go b/x86_result_sad.go
new file mode 100644
index 000000000..fb6394d18
--- /dev/null
+++ b/x86_result_sad.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+// SAD shares its ordered byte selectors with the caller model and lowerer.
+// Only selected register bytes contribute, but every memory form still reads
+// its complete native tuple, including a zero mask or unused result.
+func x86ResultSADStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86PackedSADProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	width := x86CallerVectorByteMask(int64(form.byteWidth))
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	if form.constantZero(ins) {
+		state.writeVector(destination, form.byteWidth, width, form.legacy)
+		return true, true
+	}
+	var requiredFirst, requiredSecond uint64
+	for output := 0; output < form.byteWidth; output += 2 {
+		first, second := form.wordInputs(output)
+		requiredFirst |= first
+		requiredSecond |= second
+	}
+	first := ins.Args[form.first]
+	if form.memory >= 0 {
+		// The legacy m128 opcode keeps its alignment and fault behavior.
+		// Logical FP/AUTO bytes alone cannot establish that native storage.
+		if _, static := x86StaticSBReadAddress(first, arch); form.legacy && !static &&
+			(!nativeRead || !x86OrdinaryNativeMemoryOperand(first, arch)) {
+			return false, true
+		}
+		if !x86ResultReadWithNativeContinuation(ins, first, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else {
+		index, _ := amd64VectorRegisterIndex(first.Reg, form.byteWidth)
+		if state.vectorBytes(index)&requiredFirst != requiredFirst {
+			return false, true
+		}
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	if state.vectorBytes(second)&requiredSecond != requiredSecond ||
+		form.mask >= 0 && !form.zeroing && state.vectorBytes(destination)&width != width {
+		return false, true
+	}
+	state.writeVector(destination, form.byteWidth, width, form.legacy)
+	return true, true // No GP, FLAGS, mask, DF, pointer or storage writes.
+}
diff --git a/x86_result_sad_test.go b/x86_result_sad_test.go
new file mode 100644
index 000000000..7f96aa1cf
--- /dev/null
+++ b/x86_result_sad_test.go
@@ -0,0 +1,278 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent Go inventory: legacy X, VPSADBW X/Y/Z, VMPSADBW X/Y,
+// and VDBPSADBW X/Y/Z with optional merge/zero masks. Go's mode32
+// frontend has no four/five-operand immediate vector spelling.
+func x86SADValueRows(arch string) []struct{ op, bank, mode string } {
+	var rows []struct{ op, bank, mode string }
+	for _, op := range []string{"PSADBW", "MPSADBW", "VPSADBW", "VMPSADBW", "VDBPSADBW"} {
+		if arch == "386" && (op == "VMPSADBW" || op == "VDBPSADBW") {
+			continue
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if !strings.HasPrefix(op, "V") && bank != "X" || op == "VMPSADBW" && bank == "Z" {
+				continue
+			}
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				if mode != "plain" && op != "VDBPSADBW" {
+					continue
+				}
+				rows = append(rows, struct{ op, bank, mode string }{op, bank, mode})
+			}
+		}
+	}
+	return rows
+}
+
+func x86SADValueInstruction(op, bank, mode, first string, control int) string {
+	name, args := op, first+","+bank+"1"
+	if strings.HasPrefix(op, "V") {
+		if mode != "plain" {
+			args += ",K1"
+		}
+		args += "," + bank + "2"
+	}
+	if mode == "zero" {
+		name += ".Z"
+	}
+	if op != "PSADBW" && op != "VPSADBW" {
+		args = fmt.Sprintf("$%d,", control) + args
+	}
+	return name + " " + args
+}
+
+func TestX86SADNumericalInputsAndAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86SADValueRows(arch) {
+			t.Run(arch+"/"+row.op+"/"+row.bank+"/"+row.mode, func(t *testing.T) {
+				width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+				for control := 0; control < 256; control++ {
+					ins := x86ScalarLaneInstruction(t, x86SADValueInstruction(row.op, row.bank, row.mode, row.bank+"0", control))
+					// Derive dependencies by perturbing a separate numerical oracle,
+					// never by reading the implementation's word-input masks.
+					var required [2]uint64
+					for input := 0; input < width; input++ {
+						for source := range required {
+							a, b := make([]byte, width), make([]byte, width)
+							if source == 0 {
+								a[input] = 1
+							} else {
+								b[input] = 1
+							}
+							for _, value := range x86SADReference(row.op, width, control, a, b) {
+								if value != 0 {
+									required[source] |= uint64(1) << uint(input)
+								}
+							}
+						}
+					}
+					for missing := -1; missing < 2*width; missing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[3], state.pointerGP[7], state.callerAddressGP[7] = 0x53, true, true
+						state.masks[1] = true
+						for index := 0; index < 3; index++ {
+							state.xmm[index], state.vectorUpper[index] = 0xffff, ^uint64(0xffff)
+						}
+						want := true
+						if missing >= 0 {
+							index, bit := missing/width, uint(missing%width)
+							bits := state.vectorBytes(index) &^ (uint64(1) << bit)
+							state.xmm[index], state.vectorUpper[index] = uint16(bits), bits&^0xffff
+							want = required[index]&(uint64(1)<<bit) == 0
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != want {
+							t.Fatalf("imm%d missing%d accepted=%t want=%t", control, missing, accepted, want)
+						}
+						if want {
+							destination := 2
+							if !strings.HasPrefix(row.op, "V") {
+								destination = 1
+							}
+							before.writeVector(destination, width, x86CallerVectorByteMask(int64(width)), !strings.HasPrefix(row.op, "V"))
+						}
+						if !reflect.DeepEqual(state, before) {
+							t.Fatal("SAD changed unrelated state or partially accepted missing inputs")
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SADUnknownVoidInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86SADValueRows(arch) {
+			instruction := x86SADValueInstruction(row.op, row.bank, row.mode, row.bank+"0", 37)
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				original := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+				x86LEAActualTargetGoObject(t, arch, triple, original)
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, original, declaration, arch, triple, api)
+						if arch == "amd64" && declaration == "func Value(unused bool)" && !strings.Contains(instruction, ",K") {
+							x86VectorScratchCodegenControl(t, original, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead SAD output invented input data", declaration, api, err)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SADSameSourceBlockConstants(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"PSADBW", "VPSADBW"} {
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if op == "PSADBW" && bank != "X" {
+					continue
+				}
+				for source := 0; source < 8; source++ {
+					for destination := 0; destination < 8; destination++ {
+						if op == "PSADBW" && source != destination {
+							continue
+						}
+						instruction := fmt.Sprintf("%s %s%d,%s%d", op, bank, source, bank, source)
+						if op == "VPSADBW" {
+							instruction += fmt.Sprintf(",%s%d", bank, destination)
+						}
+						state := x86ResultState{flags: x86ByteFlagAF}
+						before := state.clone()
+						width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+						before.writeVector(destination, width, x86CallerVectorByteMask(int64(width)), op == "PSADBW")
+						if !x86ResultTransfer(x86ScalarLaneInstruction(t, instruction), &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+							t.Fatal("same-byte absolute differences require no incoming values", arch, instruction)
+						}
+						ins := x86ScalarLaneInstruction(t, instruction)
+						form, _, err := x86PackedSADProperties(ins, arch)
+						caller := &x86SourceStackState{vectors: map[Reg]uint64{}}
+						if err != nil || !x86CallerSADStep(&ins, form, caller, nil) ||
+							caller.vectors[Reg(fmt.Sprintf("Z%d", destination))] != before.vectorBytes(destination) {
+							t.Fatal("caller and result disagree on the input-independent zero", arch, instruction, err)
+						}
+					}
+				}
+			}
+		}
+	}
+	for _, instruction := range []string{"MPSADBW $0,X0,X0", "VMPSADBW $0,Y0,Y0,Y1", "VDBPSADBW $0,Z0,Z0,Z1"} {
+		state := x86ResultState{}
+		if x86ResultTransfer(x86ScalarLaneInstruction(t, instruction), &state, nil, 0, "amd64") {
+			t.Fatal("sliding/shuffled SAD invented a same-source constant", instruction)
+		}
+	}
+}
+
+func TestX86SADInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := int(goWordSize(target.arch)), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			for _, instruction := range []string{"PSADBW X0,X0", "VPSADBW X0,X0,X0", "VPSADBW Y0,Y0,Y0", "VPSADBW Z0,Z0,Z0"} {
+				name := "constant" + strings.NewReplacer(" ", "", ",", "").Replace(instruction)
+				fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n%s\nPEXTRD $0,X0,AX\nMOVL AX,ret+0(FP)\nRET\n", name, instruction)
+			}
+			for _, row := range x86SADValueRows(target.arch) {
+				for _, memory := range []bool{false, true} {
+					name := fmt.Sprintf("%s%s%s%t", row.op, row.bank, row.mode, memory)
+					first := row.bank + "0"
+					if memory {
+						first = "3(AX)(DX*2)"
+					}
+					fmt.Fprintf(&declarations, "func %s(p *[128]byte,mask uintptr) uint32\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\nKMOVD CX,K1\n"+
+						"MOVL $1,DX\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\n",
+						name, 2*word+4, move, move, word, x86SADValueInstruction(row.op, row.bank, row.mode, first, 37))
+					destination := "X2"
+					if !strings.HasPrefix(row.op, "V") {
+						destination = "X1"
+					}
+					fmt.Fprintf(&source, "PEXTRD $0,%s,AX\nMOVL AX,ret+%d(FP)\nRET\n", destination, 2*word)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete SAD input lost its numerical continuation", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86SADNativeInputsStayIndependent(t *testing.T) {
+	for _, row := range x86SADValueRows("amd64") {
+		instruction := x86SADValueInstruction(row.op, row.bank, row.mode, "3(AX)(DX*2)", 37)
+		original := "TEXT ·Value(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ mask+8(FP),CX\nKMOVD CX,K1\n" +
+			"MOVL $1,DX\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n" + instruction + "\nRET\n"
+		declaration := "func Value(p *[128]byte,mask uintptr)"
+		variants := []struct{ name, source string }{
+			{"complete", original},
+			{"unknown-pointer", strings.Replace(original, "p+0(FP),AX", "p+0(FP),DI", 1)},
+			{"numeric-pointer", strings.Replace(original, "MOVQ p+0(FP),AX", "MOVQ $42,AX", 1)},
+			{"unknown-index", strings.Replace(original, "MOVL $1,DX\n", "", 1)},
+			{"unknown-second", strings.Replace(original, "VPXORD Z1,Z1,Z1\n", "", 1)},
+		}
+		if row.mode != "plain" {
+			variants = append(variants, struct{ name, source string }{"unknown-mask", strings.Replace(original, "KMOVD CX,K1\n", "", 1)})
+		}
+		if row.mode == "merge" {
+			variants = append(variants, struct{ name, source string }{"unknown-merge", strings.Replace(original, "VPXORD Z2,Z2,Z2\n", "", 1)})
+		}
+		for _, variant := range variants {
+			t.Run(row.op+"/"+row.bank+"/"+row.mode+"/"+variant.name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, variant.source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if variant.name == "complete" || variant.name == "numeric-pointer" {
+						if err != nil || ir == "" {
+							t.Fatal("complete native SAD inputs rejected", api, err)
+						}
+						if variant.name == "numeric-pointer" {
+							originalIR, originalErr := x86ScalarFPBitViewAPI(t, original, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+							if originalErr != nil {
+								t.Fatal(originalErr)
+							}
+							x86RequireSameNativeMemoryEffects(t, originalIR, ir)
+							x86RequireNumericNativeSourceContext(t, variant.source, declaration, "amd64")
+							x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+						}
+					} else if variant.name == "unknown-second" || variant.name == "unknown-merge" {
+						x86VectorScratchCodegenControl(t, variant.source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("SAD acquired unknown memory/vector/mask inputs", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_sb_address_effect.go b/x86_result_sb_address_effect.go
new file mode 100644
index 000000000..0ed0cd464
--- /dev/null
+++ b/x86_result_sb_address_effect.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import "strings"
+
+// This is the existing complete named LEA grammar restricted to an SB address.
+// It describes a GP write, not DATA contents, numerical address bits or backing.
+func x86SBLEAWriteShape(ins Instr, arch string) (int, uint8, int64, MemRef, bool) {
+	if !x86ResultNamedPredicateInstruction(ins) || arch != "386" && arch != "amd64" {
+		return 0, 0, 0, MemRef{}, false
+	}
+	width, err := x86LEAOperandWidth(ins, arch)
+	if err != nil {
+		return 0, 0, 0, MemRef{}, false
+	}
+	memory, valid := x86SBMemoryAddressRole(ins.Args[0], arch)
+	if !valid || memory.OffRaw != "" || memory.Segment != "" || memory.IndexExt != "" ||
+		memory.Index == "" && memory.Scale != 0 {
+		return 0, 0, 0, MemRef{}, false
+	}
+	symbol, _, valid := parseSBRef(memory.Sym)
+	if !valid || symbol == "" || strings.IndexAny(symbol, "$+(),[] \t") >= 0 {
+		return 0, 0, 0, MemRef{}, false
+	}
+	index, mask, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+	return index, mask, width, memory, valid && (arch != "amd64" || index != 14)
+}
+
+// The paired ordinary lowerer may discard an address value without claiming
+// any of its bits are NUM. W preserves prior upper bytes; L only defines the
+// architectural zero upper32; Q leaves all written bytes unknown. No read,
+// store, caller, raw-entry or logical-frame permission is established here.
+func x86ResultUnknownSBAddressStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	if address, immediate, _, known := x86StaticAddressValueMove(ins, arch); known && immediate {
+		// Go progedit turns native-word MOV $symbol into LEA. Project only
+		// that already validated address role; the original source is not
+		// rewritten and no external address bit becomes numerical knowledge.
+		ins.Args = append([]Operand(nil), ins.Args...)
+		ins.Args[0] = Operand{Kind: OpMem, Mem: MemRef{Sym: address.symbol + "(SB)", Off: address.offset}}
+		ins.Op = "LEAQ"
+		if arch == "386" {
+			ins.Op = "LEAL"
+		}
+	}
+	index, mask, width, memory, known := x86SBLEAWriteShape(ins, arch)
+	if !known {
+		return false, false
+	}
+	if state == nil {
+		return false, true
+	}
+	if memory.Index != "" {
+		source, _, valid := x86ResultGP(memory.Index, x86ResultPointerWord(arch), arch)
+		if !valid || state.pointerGP[source] || state.callerAddressGP[source] || state.resultAddressGP[source].valid ||
+			!x86ResultRead(Operand{Kind: OpReg, Reg: memory.Index}, x86ResultPointerWord(arch), state, nil, arch) {
+			return false, true
+		}
+	}
+	state.gp[index] &^= mask
+	state.canonicalGP[index] &^= mask
+	if width == 4 {
+		state.gp[index] |= 0xf0
+		state.canonicalGP[index] |= 0xf0
+	}
+	state.pointerGP[index], state.callerAddressGP[index] = false, false
+	state.callerAddressOrigin[index] = 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	state.predicate = x86ResultPredicate{}
+	return true, true
+}
diff --git a/x86_result_sb_address_effect_test.go b/x86_result_sb_address_effect_test.go
new file mode 100644
index 000000000..07d101bc3
--- /dev/null
+++ b/x86_result_sb_address_effect_test.go
@@ -0,0 +1,242 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86LEASBUnknownAddressSource(t *testing.T, arch, declaration, body string) string {
+	t.Helper()
+	return "DATA ·table<>+0(SB)/8,$7\nGLOBL ·table<>(SB),16,$16\n" +
+		x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+}
+
+func TestX86LEASBUnknownAddressCompleteThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W", "L"}
+		registers := []string{"AX", "CX", "DX", "BX", "SI", "DI", "BP"}
+		if target.arch == "amd64" {
+			widths = append(widths, "Q")
+			registers = []string{"AX", "CX", "DX", "BX", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R15"}
+		}
+		for _, width := range widths {
+			for _, register := range registers {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+width+"/"+register+"/"+api, func(t *testing.T) {
+						// Neither the address nor its uninitialized W remainder
+						// contributes data to this independently defined result.
+						body := fmt.Sprintf("MOVL $1,AX\nCMPL AX,$1\nLEA%s ·table<>-1(SB),%s\nSETEQ CL\nMOVL $7,ret+RESULT(FP)", width, register)
+						source := x86LEASBUnknownAddressSource(t, target.arch, "func view() uint32", body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatalf("discarded valid SB address blocked independent NUM result: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LEASBUnknownAddressDoesNotGrantFacts(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := []string{"W", "L"}
+		move := "MOVL"
+		if target.arch == "amd64" {
+			widths, move = append(widths, "Q"), "MOVQ"
+		}
+		for _, width := range widths {
+			for _, test := range []struct{ name, before, after string }{
+				{"NUM-result", "", "MOVL DX,ret+RESULT(FP)"},
+				{"NUM-compare", "", "TESTW DX,DX\nMOVL $0,CX\nSETEQ CL\nMOVL CX,ret+RESULT(FP)"},
+				{"native-read", move + " p+0(FP),DX\n", "MOVB (DX),CL"},
+				{"native-write", move + " p+0(FP),DX\n", "MOVB $1,(DX)"},
+				{"caller-address", move + " p+0(FP),DX\n", "CMPW DX,$0"},
+				{"old-result-address", "LEA" + strings.TrimPrefix(move, "MOV") + " ret+RESULT(FP),DX\n", "MOVL $7,(DX)"},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+width+"/"+test.name+"/"+api, func(t *testing.T) {
+						declaration := "func view(p *byte) uint32"
+						body := "MOVL $7,ret+RESULT(FP)\n" + test.before + "LEA" + width + " ·table<>(SB),DX\n" + test.after
+						source := x86LEASBUnknownAddressSource(t, target.arch, declaration, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("SB address created numerical/caller/result/native authority: IR=%d error=%v", len(ir), err)
+						}
+					})
+				}
+			}
+		}
+		for _, boundary := range []struct{ name, instruction string }{
+			{"SP-destination", "LEAL ·table<>(SB),SP"},
+			{"indexed-AUTO", "LEAL local+0(SP)(CX*1),DX"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/physical/"+boundary.name+"/"+api, func(t *testing.T) {
+					body := "MOVL $7,ret+RESULT(FP)\nMOVL $0,CX\n" + boundary.instruction
+					source := x86LEASBUnknownAddressSource(t, target.arch, "func view() uint32", body)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("physical source stack acquired backing: %v", err)
+					}
+				})
+			}
+		}
+		if target.arch == "amd64" {
+			for _, width := range widths {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/physical/BP-destination/"+width+"/"+api, func(t *testing.T) {
+						body := "LEA" + width + " ·table<>(SB),BP\nMOVL $7,ret+RESULT(FP)"
+						source := x86LEASBUnknownAddressSource(t, target.arch, "func view() uint32", body)
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("AMD64 physical frame destination acquired ordinary GP authority: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86LEASBUnknownAddressWriteEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := []string{"W", "L"}
+		if arch == "amd64" {
+			widths = append(widths, "Q")
+		}
+		for _, width := range widths {
+			for _, prior := range []uint8{0, 0x55, 0xff} {
+				t.Run(fmt.Sprintf("%s/%s/%x", arch, width, prior), func(t *testing.T) {
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagZF, direction: x86ResultDirectionBackward}
+					state.gp[2], state.canonicalGP[2] = prior, 0xff
+					state.pointerGP[2], state.pointerGP[3] = true, true
+					state.callerAddressGP[2], state.callerAddressGP[3] = true, true
+					state.callerAddressOrigin[2], state.callerAddressOrigin[3] = 8, 9
+					state.resultAddressGP[2] = x86ResultSlotAddress{start: 8, end: 12, valid: true}
+					state.resultAddressGP[3] = state.resultAddressGP[2]
+					state.predicate = x86ResultPredicate{kind: x86ResultNonzeroMaskGP, register: 2, width: 8}
+					before := state.clone()
+					ins := x86ScalarLaneInstruction(t, "LEA"+width+" ·table<>-1(SB),DX")
+					if accepted, known := x86ResultUnknownSBAddressStep(ins, &state, arch); !accepted || !known {
+						t.Fatal("complete SB address write was not retained as unknown")
+					}
+					mask, zeros := uint8(3), uint8(0)
+					if width == "L" {
+						mask, zeros = 0x0f, 0xf0
+					} else if width == "Q" {
+						mask = 0xff
+					}
+					before.gp[2], before.canonicalGP[2] = prior&^mask|zeros, 0xff&^mask|zeros
+					before.pointerGP[2], before.callerAddressGP[2], before.callerAddressOrigin[2] = false, false, 0
+					before.resultAddressGP[2], before.predicate = x86ResultSlotAddress{}, x86ResultPredicate{}
+					if !reflect.DeepEqual(state, before) {
+						t.Fatal("SB address changed unwritten bytes, FLAGS/DF, unrelated identities or created a fact")
+					}
+					callers := x86ResultCallerAddressesAfter(ins, [16]bool{2: true, 3: true}, nil, arch)
+					if callers != ([16]bool{3: true}) {
+						t.Fatal("post-consumer retained destination or revoked an unrelated caller identity", callers)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86LEASBUnknownAddressRejectsUnboundRoles(t *testing.T) {
+	for _, test := range []struct {
+		name string
+		edit func(*Instr)
+	}{
+		{"raw", func(ins *Instr) { ins.x86Encoded = true }},
+		{"address-size", func(ins *Instr) { ins.x86AddressBits = 32 }},
+		{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+		{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+		{"not-SB", func(ins *Instr) { ins.Args[0].Sym = "table" }},
+		{"unresolved", func(ins *Instr) { ins.Args[0].Sym = "table+MISSING(SB)" }},
+		{"SP", func(ins *Instr) { ins.Args[1].Reg = SP }},
+		{"BP", func(ins *Instr) { ins.Args[1].Reg = BP }},
+		{"g", func(ins *Instr) { ins.Args[1].Reg = "R14" }},
+		{"byte-alias", func(ins *Instr) { ins.Args[1].Reg = "DH" }},
+		{"high-bank", func(ins *Instr) { ins.Args[1].Reg = "R16" }},
+		{"FP-destination", func(ins *Instr) { ins.Args[1] = Operand{Kind: OpFP} }},
+		{"non-LEA", func(ins *Instr) { ins.Op = "MOVL" }},
+		{"extra-operand", func(ins *Instr) { ins.Args = append(ins.Args, Operand{Kind: OpReg, Reg: CX}) }},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, "LEAL ·table<>(SB),DX")
+			test.edit(&ins)
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+			state.gp[2], state.callerAddressGP[2], state.callerAddressGP[3] = 0xff, true, true
+			before := state.clone()
+			if accepted, _ := x86ResultUnknownSBAddressStep(ins, &state, "amd64"); accepted || !reflect.DeepEqual(state, before) {
+				t.Fatal("unbound role borrowed named SB address availability")
+			}
+			if ins.x86Encoded || ins.x86AddressBits != 0 || ins.x86UnboundAddressOverride || ins.x86SegmentPrefix != 0 {
+				if got := x86ResultCallerAddressesAfter(ins, before.callerAddressGP, nil, "amd64"); got != ([16]bool{}) {
+					t.Fatal("unbound physical role retained caller facts", got)
+				}
+			}
+		})
+	}
+	ins := x86ScalarLaneInstruction(t, "LEAL ·table<>(SB),DX")
+	if accepted, known := x86ResultUnknownSBAddressStep(ins, nil, "amd64"); accepted || !known {
+		t.Fatal("nil state acquired unknown-address availability")
+	}
+	ins.Op = "LEAQ"
+	if accepted, _ := x86ResultUnknownSBAddressStep(ins, &x86ResultState{}, "386"); accepted {
+		t.Fatal("mode32 acquired a qword GP write")
+	}
+}
+
+func TestX86LEASBUnknownAddressReachingIndexAndUnrelatedPointers(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths, move := []string{"W", "L"}, "MOVL"
+		if target.arch == "amd64" {
+			widths, move = append(widths, "Q"), "MOVQ"
+		}
+		for _, width := range widths {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+width+"/unrelated-pointer/"+api, func(t *testing.T) {
+					declaration := "func view(p *byte) uint32"
+					body := move + " p+0(FP),BX\nLEA" + width + " ·table<>(SB),DX\nMOVB (BX),CL\nMOVL $7,ret+RESULT(FP)"
+					source := x86LEASBUnknownAddressSource(t, target.arch, declaration, body)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+						t.Fatal("dead SB write revoked an unrelated reaching pointer", err)
+					}
+				})
+			}
+			if target.arch != "386" {
+				continue // Named AMD64 SB operands cannot have a SIB index.
+			}
+			for _, test := range []struct {
+				name, before string
+				accepted     bool
+			}{
+				{"complete", "MOVL $1,CX\n", true},
+				{"self-alias", "MOVL $1,DX\nMOVL DX,CX\n", true},
+				{"unknown", "", false},
+				{"partial", "MOVB $1,CX\n", false},
+				{"opaque-pointer", "MOVL p+0(FP),CX\n", false},
+				{"prior-SB-address", "LEAL ·table<>(SB),CX\n", false},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+width+"/index/"+test.name+"/"+api, func(t *testing.T) {
+						declaration := "func view(p *byte) uint32"
+						body := test.before + "LEA" + width + " ·table<>(SB)(BP)(CX*2),CX\nMOVL $7,ret+RESULT(FP)"
+						source := x86LEASBUnknownAddressSource(t, target.arch, declaration, body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if test.accepted {
+							if err != nil || ir == "" {
+								t.Fatal("complete reaching numerical index was not read before its overwrite", err)
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("unknown/partial/address index acquired NUM permission: %v", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_sb_address_objects_test.go b/x86_result_sb_address_objects_test.go
new file mode 100644
index 000000000..b8775f8fb
--- /dev/null
+++ b/x86_result_sb_address_objects_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86LEASBUnknownAddressOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			widths := []string{"W", "L"}
+			registers := []string{"AX", "CX", "DX", "BX", "SI", "DI", "BP"}
+			if target.arch == "amd64" {
+				widths = append(widths, "Q")
+				registers = []string{"AX", "CX", "DX", "BX", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R15"}
+			}
+			var source, declarations strings.Builder
+			source.WriteString("DATA ·table<>+0(SB)/8,$7\nGLOBL ·table<>(SB),16,$16\n")
+			for _, width := range widths {
+				for _, register := range registers {
+					name := "address" + width + register
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\nMOVL $1,AX\nCMPL AX,$1\nLEA%s ·table<>-1(SB),%s\nSETEQ CL\nMOVL $7,ret+0(FP)\nRET\n", name, width, register)
+					fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+				}
+			}
+			receipt := x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			t.Logf("complete W/L/Q SB address banks: TEXTs=%d source=%x object=%x SDK=%s", len(widths)*len(registers), receipt.Source, receipt.Object, receipt.GoVersion)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatalf("complete original SB source %s: %v", api, err)
+				}
+				for _, irLevel := range []string{"0", "2"} {
+					objectIR := ir
+					if irLevel == "2" {
+						objectIR = x86DwordProductIROptimize(t, ir)
+					}
+					for _, backendLevel := range []string{"0", "2"} {
+						t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, objectIR, "-O"+backendLevel)
+						})
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_scalar_import_runtime_test.go b/x86_result_scalar_import_runtime_test.go
new file mode 100644
index 000000000..2394e3ef5
--- /dev/null
+++ b/x86_result_scalar_import_runtime_test.go
@@ -0,0 +1,94 @@
+package plan9asm
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ABI0ScalarImportIndependentResult(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	const declaration = "func view(x uint32,p *byte) uint32\n"
+	const source = `TEXT ·view(SB),4,$0-20
+MOVL x+0(FP),X0
+MOVQ p+8(FP),SI
+MOVQ SI,DI
+MOVL $7,CX
+LEAQ 4(DI)(CX*2),BX
+PEXTRD $0,X0,AX
+MOVL AX,ret+16(FP)
+RET
+`
+	const originalTest = `package scalarimport
+import "testing"
+func TestOriginal(t *testing.T) {
+ for sample:=uint32(0);sample<257;sample++ {
+  x:=sample*0x9e3779b9
+  data:=[4]byte{0x19,0x28,0x37,0x46}
+  for _,p:=range []*byte{nil,&data[0],&data[3]} {
+   if got:=view(x,p);got!=x { t.Fatalf("sample%d got%x want%x",sample,got,x) }
+   if data!=[4]byte{0x19,0x28,0x37,0x46} { t.Fatal("opaque pointer transport touched input") }
+  }
+ }
+}
+`
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod":       "module scalarimport\n\ngo 1.20\n",
+		"view.go":      "package scalarimport\n" + declaration,
+		"view_amd64.s": source, "view_test.go": originalTest,
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", execution.triple, source)
+	binary := filepath.Join(dir, "original.test")
+	ctx, cancel := runtimeOracleStageContext(t)
+	command := exec.CommandContext(ctx, "go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	cancel()
+	if err != nil {
+		t.Fatalf("original first-party scalar-import object: %v\n%s", err, output)
+	}
+	if output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v"); !strings.Contains(string(output), "--- PASS: TestOriginal") {
+		t.Fatalf("original scalar-import runtime has no passing terminal: %s", output)
+	}
+	ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	const main = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint32_t view(uint32_t,void *);
+int main(void) {
+ for(uint32_t sample=0;sample<257;sample++) {
+  uint32_t x=sample*UINT32_C(0x9e3779b9);
+  uint8_t data[4]={0x19,0x28,0x37,0x46};
+  const uint8_t expected[4]={0x19,0x28,0x37,0x46};
+  void *p[3]={NULL,data,data+3};
+  for(int i=0;i<3;i++) {
+   volatile struct { uint32_t before,value,after; } result={0x11223344,view(x,p[i]),0x88776655};
+   if(result.value!=x||result.before!=0x11223344||result.after!=0x88776655||memcmp(data,expected,4)) {
+    fprintf(stderr,"sample%u pointer%d got%x want%x\n",sample,i,result.value,x);return 1;
+   }
+  }
+ }
+ puts("SCALAR_IMPORT_NUMERICAL_AND_INPUT_GUARDS_PASS");return 0;
+}
+`
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run("backend"+level, func(t *testing.T) {
+			output := execution.compileAndRunLLVM(t, "scalar-import", ir, main, level)
+			if !strings.Contains(string(output), "SCALAR_IMPORT_NUMERICAL_AND_INPUT_GUARDS_PASS") {
+				t.Fatalf("LLVM scalar-import runtime has no passing terminal: %s", output)
+			}
+		})
+	}
+	t.Log("257 numerical inputs ×3 opaque identities, original Go plus LLVM backend O0/O2; no pointee read or native Linux claim on Rosetta")
+}
diff --git a/x86_result_scalar_import_test.go b/x86_result_scalar_import_test.go
new file mode 100644
index 000000000..3d1cdf50d
--- /dev/null
+++ b/x86_result_scalar_import_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86ABI0ScalarImportOpaquePointerIndependentResult(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := x86ResultPointerWord(arch)
+		for name, body := range x86ResultIncomingPointerIdentityBodies(arch) {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				finish := fmt.Sprintf("MOVL $42,DX\nMOVL DX,X1\nPEXTRD $0,X1,BX\nMOVL BX,ret0+%d(FP)\nRET", word)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch,
+					"func Value(x *[8]uint32) uint32", body+finish)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				before := fmt.Sprintf("%#v %#v", file.Funcs[0], sig)
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("opaque pointer transport contaminated independent numerical result: %v", err)
+				}
+				if before != fmt.Sprintf("%#v %#v", file.Funcs[0], sig) {
+					t.Fatal("import observation changed original source or declaration")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ScalarImportGoMOVDWordAlias(t *testing.T) {
+	for _, register := range []string{"AX", "CX", "DX", "BX", "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15"} {
+		t.Run(register, func(t *testing.T) {
+			body := fmt.Sprintf("MOVD x+0(FP),%s\nMOVD %s,SI\nMOVL $42,DX\nPINSRD $0,DX,X0\nPEXTRD $0,X0,BX\nMOVL BX,ret0+8(FP)\nRET", register, register)
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value(x *byte) uint32", body)
+			// Stock cmd/asm aliases MOVD to AMOVQ. All supported GP imports
+			// must retain that exact word-width opaque role in both observers.
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, "amd64"); err != nil {
+					t.Fatalf("Go MOVD word alias lost complete opaque transfer: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ABI0ScalarImportSliceThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			// This independently derived gc declaration has the crc32 shape:
+			// an integer followed by slice data/len/cap and one scalar result.
+			// The pointer is transported, never dereferenced or used as bits.
+			moves := []string{move}
+			if target.arch == "amd64" {
+				moves = append(moves, "MOVD")
+			}
+			for _, pointerMove := range moves {
+				t.Run(pointerMove, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVL crc+0(FP),X0\n%s p+%d(FP),SI\n%s p_len+%d(FP),CX\n%s SI,DI\nPEXTRD $0,X0,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+						4*word+4, pointerMove, word, move, 2*word, pointerMove, 4*word)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source,
+								"func view(crc uint32,p []byte) uint32\n", target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatalf("declared scalar import with independent extracted result: %v", err)
+							}
+							compileLLVMToObject(t, llc, target.triple, "scalar-import.ll", "scalar-import.o", ir)
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ABI0ScalarImportDoesNotGrantNumericOrMemoryPermission(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := x86ResultPointerWord(arch)
+		move, lea := "MOVQ", "LEAQ"
+		if arch == "386" {
+			move, lea = "MOVL", "LEAL"
+		}
+		load := move + " x+0(FP),AX\n"
+		finish := fmt.Sprintf("MOVL $42,DX\nMOVL DX,X1\nPEXTRD $0,X1,BX\nMOVL BX,ret0+%d(FP)\nRET", word)
+		for name, body := range map[string]string{
+			"pointee":             load + "MOVL (AX),BX\n",
+			"pointee vector":      load + "MOVOU (AX),X0\n",
+			"pointer GP bits":     load + "MOVW AX,CX\n",
+			"pointer X bits":      load + move + " AX,X0\n",
+			"pointer FP bits":     "MOVL x+0(FP),X0\n",
+			"pointer lane":        load + "PINSRD $0,AX,X0\n",
+			"input store":         load + move + " AX,x+0(FP)\n",
+			"result identity":     load + fmt.Sprintf("MOVL AX,ret0+%d(FP)\n", word),
+			"unknown source":      move + " AX,CX\n",
+			"unknown LEA index":   load + lea + " (AX)(CX*4),DI\n",
+			"pointer LEA index":   load + lea + " (AX)(AX*4),DI\n",
+			"unknown GP result":   load + "PINSRD $0,CX,X0\n",
+			"unknown result lane": load + "MOVL $7,DX\nPINSRD $1,DX,X0\nPEXTRD $0,X0,BX\n",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x *uint32) uint32", body+finish)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("opaque import granted numerical/native authority: %v", err)
+				}
+			})
+		}
+	}
+	state := x86ResultState{pointerFP: map[int64]bool{0: true}, fp: make([]bool, 8)}
+	owned := []bool{true, true, true, true, true, true, true, true}
+	ins := x86YMMReadSource(t, "MOVQ x+0(FP),AX")
+	if !x86ScalarFPResultTransfer(ins, &state, owned, 8, "amd64") || !state.pointerGP[0] || state.gp[0] != 0 ||
+		!reflect.DeepEqual(state.fp, make([]bool, 8)) {
+		t.Fatal("opaque import initialized numerical pointer bytes")
+	}
+}
diff --git a/x86_result_scalar_precision.go b/x86_result_scalar_precision.go
new file mode 100644
index 000000000..7bdd3ad02
--- /dev/null
+++ b/x86_result_scalar_precision.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+// The complete physical mode and generation are captured at raw decoding.
+// Zero is absent, not an assertion of legacy/VEX or a reusable source proof.
+type x86RawScalarPrecisionIdentity struct {
+	arch          string
+	encoded, evex bool
+}
+
+func x86ScalarPrecisionRawIdentity(ins Instr, arch string) x86RawScalarPrecisionIdentity {
+	if _, known, err := x86ScalarPrecisionProperties(ins.Op, ins, arch); !known || err != nil {
+		return x86RawScalarPrecisionIdentity{}
+	}
+	return x86RawScalarPrecisionIdentity{arch, ins.x86Encoded, ins.x86ScalarPrecisionEVEX}
+}
+
+func x86RawScalarPrecisionSource(ins Instr, arch string) bool {
+	origin := ins.x86SourceRaw
+	return origin != nil && ins.x86Encoded && origin.scalarPrecision.arch == arch &&
+		origin.scalarPrecision == x86ScalarPrecisionRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Read the sealed decoded inventory before any named/strict fast path. Removing
+// both mutable origin fields cannot launder a physical conversion into named
+// source, or hide an edited producer elsewhere in its complete function.
+func x86ScalarPrecisionRawReplayRequired(fn Func, arch string) bool {
+	if fn.x86RawReplay == nil {
+		return false
+	}
+	for _, ins := range fn.x86RawReplay.decoded {
+		if _, known, _ := x86ScalarPrecisionProperties(ins.Op, ins, arch); known {
+			return true
+		}
+	}
+	return false
+}
+
+// Active floating input and possible merge bytes are mandatory, including
+// Void: implementation zeros cannot stand in for their native exceptions.
+// Independently copied upper bytes may stay unknown and supply no pointer,
+// backing, frame, caller or raw-entry fact.
+func x86ResultScalarPrecisionStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86ScalarPrecisionProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawScalarPrecisionSource(ins, arch) {
+			return false, true
+		}
+		// Only this bound source's original native opcode owns the conditional
+		// numerical read. No subsequent access gains a pointer/backing fact.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	input := int64(form.spec.inputBits / 8)
+	if form.memory >= 0 {
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[0], input, state, owned, arch, native) {
+			return false, true
+		}
+	} else {
+		source, _ := amd64ParseXReg(ins.Args[0].Reg)
+		required := x86CallerVectorByteMask(input)
+		if state.vectorBytes(source)&required != required {
+			return false, true
+		}
+	}
+	destination, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+	output := x86CallerVectorByteMask(int64(form.spec.outputBits / 8))
+	if form.mask >= 0 && !form.zeroing && state.vectorBytes(destination)&output != output {
+		return false, true
+	}
+	base, _ := amd64ParseXReg(ins.Args[form.second].Reg)
+	defined := output | state.vectorBytes(base)&(0xffff&^output)
+	state.writeVector(destination, 16, defined, form.legacy)
+	return true, true
+}
diff --git a/x86_result_scalar_reciprocal.go b/x86_result_scalar_reciprocal.go
new file mode 100644
index 000000000..b7fe75ab0
--- /dev/null
+++ b/x86_result_scalar_reciprocal.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+// A scalar estimate consumes only low32 and copies upper96 independently.
+// An unknown dead register value stays unknown; it is not a native pointer
+// obligation. Native m32 remains mandatory even when no output is observed.
+func x86ResultScalarReciprocalStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86ScalarReciprocalProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !native || !x86RawScalarReciprocalSource(ins, arch) {
+			return false, true
+		}
+		// Project only this exact sealed source into the paired native step.
+		// No caller, raw-entry, storage or later-read fact follows from it.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	source := ins.Args[0]
+	computed := uint64(0xf)
+	if source.Kind == OpReg {
+		index, _ := amd64ParseXReg(source.Reg)
+		if state.vectorBytes(index)&0xf != 0xf {
+			computed = 0
+		}
+	} else if !x86ResultReadWithNativeContinuation(ins, source, 4, state, owned, arch, native) {
+		return false, true
+	}
+	base, _ := amd64ParseXReg(ins.Args[form.base].Reg)
+	destination, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+	defined := state.vectorBytes(base)&0xfff0 | computed
+	state.writeVector(destination, 16, defined, !form.spec.vector)
+	return true, true // The opcode changes neither FLAGS, DF nor MXCSR.
+}
+
+func x86RawScalarReciprocalSource(ins Instr, arch string) bool {
+	_, known, err := x86ScalarReciprocalProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
diff --git a/x86_result_scalar_shift_choice.go b/x86_result_scalar_shift_choice.go
new file mode 100644
index 000000000..a2dcd94ac
--- /dev/null
+++ b/x86_result_scalar_shift_choice.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// The standalone steps cannot distinguish a legacy decoded instruction whose
+// origin was erased from an otherwise identical named instruction. These
+// producer families therefore check the immutable complete source once before
+// their paired proof. Inspect current and sealed decoded instructions so an
+// erased origin or edited opcode cannot erase that restriction. This is never
+// an input, caller, native-entry or memory-backing permission.
+func x86LoweredNumericalProducerReplay(fn Func, arch string) error {
+	hasProducer := func(instructions []Instr) bool {
+		for _, ins := range instructions {
+			if ins.x86SourceRaw == nil {
+				continue
+			}
+			if ins.x86SourceRaw.scalarSegmentLoad.arch != "" {
+				return true // A physical segment read cannot outlive its complete sealed source.
+			}
+			if _, known := amd64MaskMoveSpecs[ins.Op]; known {
+				return true // Exact raw KMOV access cannot survive erased or edited producer identity.
+			}
+			if form, known, _ := x86ScalarShiftProperties(ins.Op, ins, arch); known && !form.bmi2 {
+				return true
+			}
+			if form, known, _ := x86FloatCompareProperties(ins, arch); known && form.legacy {
+				return true
+			}
+			if _, known, _ := x86BlendMinposProperties(ins.Op, ins, arch); known {
+				return true
+			}
+			if _, known, _ := x86ImmediateBlendProperties(ins.Op, ins, arch); known {
+				return true
+			}
+			if form, known, _ := x86AlternatingFloatProperties(ins, arch); known && !form.legacy {
+				return true // Erased or edited raw arithmetic origins cannot skip whole-source replay.
+			}
+			if _, known, _ := x86MULXProperties(ins.Op, ins, arch); known {
+				return true
+			}
+			if _, known, _ := x86ElementPermuteProperties(ins.Op, ins, arch); known {
+				return true
+			}
+			if _, known, _ := x86PackedSignExtendProperties(ins, arch); known {
+				return true // Restrict erased raw origins; this does not grant a raw SX result role.
+			}
+			if _, known, _ := x86PackedFloatShuffleProperties(ins.Op, ins, arch); known {
+				return true
+			}
+			if _, known, _ := x86ScalarFloatIntegerProperties(ins, arch); known {
+				return true // Restrict erased raw origins before ordinary strict success.
+			}
+			if form, known, _ := x86IntegerMinMaxProperties(ins.Op, ins, arch); known && form.legacy {
+				return true
+			}
+		}
+		return false
+	}
+	replay := fn.x86RawReplay
+	if !x86FMA3RawReplayRequired(fn, arch) && !x86NamedHalfRawReplayRequired(fn, arch) &&
+		!hasProducer(fn.Instrs) && (replay == nil || !hasProducer(replay.decoded)) {
+		return nil // Ordinary named source keeps its existing input/unknown domain.
+	}
+	if replay == nil {
+		return fmt.Errorf("%w: lowering producer needs its original whole-source replay", ErrProbeNeedsContext)
+	}
+	return replay.validate(fn, arch)
+}
+
+func x86RawLegacyScalarShiftSource(ins Instr, arch string) bool {
+	form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && !form.bmi2 && origin != nil && origin.op == ins.Op &&
+		reflect.DeepEqual(origin.args, ins.Args) && origin.vectorBytes == ins.x86VectorBytes &&
+		ins.x86RawNearReturn == nil && ins.x86AddressBits == 0 && !ins.x86UnboundAddressOverride &&
+		ins.x86SegmentPrefix == 0 && !ins.x86RIPLiteral && ins.x86NumericalRead == nil
+}
+
+// The paired scalar emitter materializes only producer-specific ISA choices.
+// It grants neither public-query definedness nor native FLAGS, entry, caller,
+// frame or memory-backing authority. Native RMW retains its exact volatile load
+// and store, including zero count and otherwise unobservable chosen outputs.
+func x86LoweredScalarShiftChoiceStep(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch)
+	if !known || form.bmi2 {
+		return false, false
+	}
+	if err != nil {
+		return false, true
+	}
+	local := ins
+	if !x86ResultNamedPredicateInstruction(local) {
+		if !x86RawLegacyScalarShiftSource(ins, arch) {
+			return false, true
+		}
+		local.x86Encoded, local.x86SourceRaw = false, nil
+	}
+	next := state.clone()
+	next.loweredStaticReads = state.loweredStaticReads
+	if x86LoweredScalarShiftTransfer(local, form, &next, owned, resultOffset, arch) {
+		*state = next
+		return true, true
+	}
+	// Retain only the already closed nontrapping GP fallback. It does not
+	// materialize choices or initialize missing dependent bytes/FLAGS. Memory
+	// accesses and W-double forms outside that old domain cannot borrow it.
+	return x86LoweredPureGPUnknownTransfer(local, state, arch), true
+}
diff --git a/x86_result_segment_query.go b/x86_result_segment_query.go
new file mode 100644
index 000000000..ba5202d4e
--- /dev/null
+++ b/x86_result_segment_query.go
@@ -0,0 +1,57 @@
+package plan9asm
+
+// Numerical query results consume the shared selector and old-destination
+// grammar. Only the paired lowering reader may continue a native m16 access;
+// a declaration-only observer gains no pointer, storage or later-read fact.
+func x86ResultSegmentQueryStep(ins Instr, state *x86ResultState, owned []bool, arch string, native bool) (bool, bool) {
+	form, known, err := x86SegmentQueryProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	effect, _, _ := x86TypedSegmentQueryByteEffect(ins.Op, ins, arch)
+	for _, input := range effect.operands {
+		if input.operand.Kind == OpReg {
+			index, _, valid := x86ResultGP(input.operand.Reg, input.width, arch)
+			if !valid || state.pointerGP[index] {
+				return false, true
+			}
+		}
+		if !x86ResultReadWithNativeContinuation(ins, input.operand, input.width, state, owned, arch, native) {
+			return false, true
+		}
+	}
+	if form.spec.bits != 0 {
+		index, mask, valid := x86ResultGP(form.destination, int64(form.spec.bits/8), arch)
+		if !valid {
+			return false, true
+		}
+		// A failed query retains the old result. In particular a dword
+		// conditional write cannot manufacture unknown upper-byte knowledge
+		// through the ordinary unconditional MOVL zero-extension rule.
+		state.gp[index] |= mask
+		state.canonicalGP[index] &^= mask
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		state.callerAddressOrigin[index] = 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+	}
+	state.flags |= x86ByteFlagZF // All five other status flags, DF and ID are preserved.
+	return true, true
+}
+
+func x86SegmentQueryCanonicalBytesAfter(ins Instr, before [16]uint8, arch string) ([16]uint8, bool) {
+	form, known, err := x86SegmentQueryProperties(ins.Op, ins, arch)
+	if !known || err != nil || !x86ResultNamedPredicateInstruction(ins) {
+		return before, false
+	}
+	if form.spec.bits != 0 {
+		index, mask, valid := x86ResultGP(form.destination, int64(form.spec.bits/8), arch)
+		if !valid {
+			return [16]uint8{}, true
+		}
+		before[index] &^= mask // No new canonical high dword follows from a conditional write.
+	}
+	return before, true
+}
diff --git a/x86_result_self_compare.go b/x86_result_self_compare.go
new file mode 100644
index 000000000..238198dca
--- /dev/null
+++ b/x86_result_self_compare.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+// Integer CMP of exactly the same physical GP byte view is independent of
+// that input's value. Reuse the complete comparison grammar, including Go's
+// effective REX aliases; neither a mnemonic nor equal textual names suffice.
+// This defines status flags only, never numerical input bytes or memory roles.
+func x86TypedSelfCompareByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return x86TypedByteEffect{}, false, nil
+	}
+	form, known, err := x86ScalarCompareProperties(op, ins, arch)
+	if !known || err != nil || form.test || form.memory != -1 ||
+		form.args[0].Kind != OpReg || form.args[1].Kind != OpReg {
+		return x86TypedByteEffect{}, false, nil
+	}
+	width := int64(form.bits / 8)
+	left, leftMask, leftValid := x86ResultGP(form.args[0].Reg, width, arch)
+	right, rightMask, rightValid := x86ResultGP(form.args[1].Reg, width, arch)
+	if !leftValid || !rightValid || left != right || leftMask != rightMask {
+		return x86TypedByteEffect{}, false, nil
+	}
+	return x86TypedByteEffect{
+		flagsDefined: x86ByteFlagsAll, flagsKilled: x86ByteFlagsAll,
+		requiresResultProof: true,
+	}, true, nil
+}
diff --git a/x86_result_self_compare_test.go b/x86_result_self_compare_test.go
new file mode 100644
index 000000000..5210d4d94
--- /dev/null
+++ b/x86_result_self_compare_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86SelfCMPCompleteFlagsWithoutNumericalInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := "BWLQ"
+		if arch == "386" {
+			widths = "BWL"
+		}
+		for _, width := range widths {
+			registers := []string{"AX", "CX", "DX", "BX", "SI", "DI"}
+			if arch == "386" {
+				registers = append(registers, "BP")
+			} else {
+				registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+			}
+			if width == 'B' {
+				registers = []string{"AX", "CX", "DX", "BX", "AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH"}
+				if arch == "amd64" {
+					registers = append(registers, "SI", "DI", "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+				}
+			}
+			for _, register := range registers {
+				t.Run(fmt.Sprintf("%s/CMP%c/%s", arch, width, register), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("CMP%c %s,%s", width, register, register))
+					state := x86ResultState{direction: x86ResultDirectionBackward}
+					state.pointerGP[0], state.callerAddressGP[0], state.callerAddressOrigin[0] = true, true, 5
+					expected := state.clone()
+					expected.flags = x86ByteFlagsAll
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, expected) {
+						t.Fatal("self comparison needs no source value and must define only the six status flags")
+					}
+				})
+			}
+		}
+		for _, aliases := range [][2]string{{"AX", "AL"}, {"AL", "AX"}, {"CX", "CL"}, {"DX", "DL"}, {"BX", "BL"}} {
+			t.Run(arch+"/same-low-byte/"+aliases[0]+"/"+aliases[1], func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "CMPB "+aliases[0]+","+aliases[1])
+				state := x86ResultState{direction: x86ResultDirectionForward}
+				expected := state.clone()
+				expected.flags = x86ByteFlagsAll
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, expected) {
+					t.Fatal("equal physical byte aliases were treated as different values")
+				}
+			})
+		}
+		for _, source := range []string{"CMPB AX,AH", "CMPB AH,AX", "TESTB AX,AX", "CMPL (AX),AX"} {
+			t.Run(arch+"/distinct-read/"+source, func(t *testing.T) {
+				state := x86ResultState{}
+				if x86ResultTransfer(x86ScalarLaneInstruction(t, source), &state, nil, 0, arch) {
+					t.Fatal("different byte, TEST or native memory borrowed self-CMP's value-independent role")
+				}
+			})
+		}
+	}
+}
+
+func TestX86SelfCMPThreeAPIsKeepNumericalAndPhysicalBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		widths := "BWLQ"
+		if target.arch == "386" {
+			widths = "BWL"
+		}
+		for _, width := range widths {
+			rows := []struct {
+				name, body string
+				accepted   bool
+			}{
+				{"flags-only", fmt.Sprintf("CMP%c AX,AX\nMOVL $0,BX\nSETEQ BL\nMOVL BX,ret+RESULT(FP)", width), true},
+				{"not-NUM", fmt.Sprintf("CMP%c AX,AX\nMOVL AX,ret+RESULT(FP)", width), false},
+				{"different-inputs", fmt.Sprintf("CMP%c AX,BX\nMOVL $7,ret+RESULT(FP)", width), false},
+				// TEST always clears CF, but its ZF still depends on the input.
+				{"TEST-independent-flags", fmt.Sprintf("TEST%c AX,AX\nMOVL $0,BX\nSETCS BL\nMOVL BX,ret+RESULT(FP)", width), true},
+				{"TEST-reads-input", fmt.Sprintf("TEST%c AX,AX\nMOVL $0,BX\nSETEQ BL\nMOVL BX,ret+RESULT(FP)", width), false},
+				{"SP-still-physical", fmt.Sprintf("CMP%c SP,SP\nMOVL $7,ret+RESULT(FP)", width), false},
+			}
+			if target.arch == "amd64" {
+				rows = append(rows, struct {
+					name, body string
+					accepted   bool
+				}{"BP-still-physical", fmt.Sprintf("CMP%c BP,BP\nMOVL $7,ret+RESULT(FP)", width), false})
+			}
+			for _, row := range rows {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/CMP%c/%s/%s", target.triple, width, row.name, api), func(t *testing.T) {
+						source := x86ResultGPSIMDAdmissionSource(t, target.arch, "func view() uint32", row.body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32", target.arch, target.triple, api)
+						if row.accepted {
+							if err != nil || ir == "" {
+								t.Fatal("self-CMP status was not available", err)
+							}
+						} else if err == nil || ir != "" {
+							t.Fatal("self comparison granted an input value or a different operand role", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_set_input_obligation_test.go b/x86_result_set_input_obligation_test.go
new file mode 100644
index 000000000..cc76a0364
--- /dev/null
+++ b/x86_result_set_input_obligation_test.go
@@ -0,0 +1,62 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ConditionalSetVoidRequiresActualPredicateFlags(t *testing.T) {
+	// The independent complete yscond inventory also covers register writes:
+	// no result store or native destination is needed to consume FLAGS.
+	ops := strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS " +
+		"SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS")
+	if len(ops) != 16 {
+		t.Fatal("complete conditional byte family changed")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		var originals strings.Builder
+		for index, op := range ops {
+			fmt.Fprintf(&originals, "TEXT ·Original%d(SB),4,$0-0\n%s AH\nRET\n", index, op)
+		}
+		x86LEAActualTargetGoObject(t, arch, triple, originals.String())
+		for _, op := range ops {
+			for _, destination := range []string{"AX", "AH"} {
+				for _, role := range []string{"void", "unused-bool"} {
+					t.Run(arch+"/"+op+"/"+destination+"/"+role, func(t *testing.T) {
+						arguments, declaration := 0, "func Value()"
+						if role == "unused-bool" {
+							arguments, declaration = 1, "func Value(unused bool)"
+						}
+						prefix := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVL $1,AX\n", arguments)
+						ending := op + " " + destination + "\nRET\n"
+						for _, api := range []string{"text", "module", "Go"} {
+							if ir, err := x86ScalarFPBitViewAPI(t, prefix+"CMPL AX,$0\n"+ending,
+								declaration, arch, triple, api); err != nil || ir == "" {
+								t.Fatal("explicit complete predicate rejected", api, err)
+							}
+							if ir, err := x86ScalarFPBitViewAPI(t, prefix+ending,
+								declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("Void register SETcc borrowed initial implementation FLAGS", api, err)
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, prefix+"CLC\n"+ending,
+								declaration, arch, triple, api)
+							if op == "SETCC" || op == "SETCS" {
+								if err != nil || ir == "" {
+									t.Error("actual CF-only predicate rejected", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("CF-only producer supplied other predicate bits", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_set_native_test.go b/x86_result_set_native_test.go
new file mode 100644
index 000000000..5453e5470
--- /dev/null
+++ b/x86_result_set_native_test.go
@@ -0,0 +1,181 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent complete Go yscond name inventory, not the implementation map.
+var x86NativeSetOracle = strings.Fields("SETCC SETCS SETEQ SETGE SETGT SETHI SETLE SETLS SETLT SETMI SETNE SETOC SETOS SETPC SETPL SETPS")
+
+func TestX86NativeConditionalSetExactFlagsAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86NativeSetOracle {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				var required uint8
+				switch op {
+				case "SETCC", "SETCS":
+					required = x86ByteFlagCF
+				case "SETEQ", "SETNE":
+					required = x86ByteFlagZF
+				case "SETGE", "SETLT":
+					required = x86ByteFlagSF | x86ByteFlagOF
+				case "SETGT", "SETLE":
+					required = x86ByteFlagZF | x86ByteFlagSF | x86ByteFlagOF
+				case "SETHI", "SETLS":
+					required = x86ByteFlagCF | x86ByteFlagZF
+				case "SETMI", "SETPL":
+					required = x86ByteFlagSF
+				case "SETOC", "SETOS":
+					required = x86ByteFlagOF
+				case "SETPC", "SETPS":
+					required = x86ByteFlagPF
+				}
+				ins := x86ScalarLaneInstruction(t, op+" 3(AX)(CX*2)")
+				for flags := uint8(0); flags <= x86ByteFlagsAll; flags++ {
+					for _, pointer := range []bool{false, true} {
+						state := x86ResultState{flags: flags}
+						state.pointerGP[0], state.gp[1], state.masks[7] = pointer, 0xff, true
+						before := state.clone()
+						accepted, known := x86LoweredNativeConditionalSet(ins, &state, arch)
+						if !known || accepted != (pointer && flags&required == required) || !reflect.DeepEqual(state, before) {
+							t.Fatal("SETcc invented FLAGS/address or changed numerical state", flags, pointer, accepted, known)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86NativeSetFixture(arch string) (string, string, []string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for _, op := range x86NativeSetOracle {
+		name := "Native" + op
+		names = append(names, name)
+		fmt.Fprintf(&declarations, "func %s(p *[8]byte,x,y uint32)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL x+%d(FP),BX\n"+
+			"MOVL y+%d(FP),CX\nCMPL BX,CX\n%s 3(AX)\nRET\n", name, word+8, move, word, word+4, op)
+	}
+	return source.String(), declarations.String(), names
+}
+
+func TestX86NativeConditionalSetCompleteFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86NativeSetFixture(target.arch)
+			if len(names) != 16 {
+				t.Fatal("complete yscond denominator changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized native SETcc rejected", api, err)
+				}
+				x86CompactExpandRequireAllDefinitions(t, ir, names)
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if strings.Count(text, "store volatile i8 ") != len(names) {
+						t.Fatal("SETcc lost an observable exact-byte write", api)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86NativeConditionalSetCannotInventFlagsOrAddress(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, _ := x86NativeSetFixture(arch)
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for name, changed := range map[string]string{
+			"unknown-flags": strings.ReplaceAll(source, "CMPL BX,CX\n", ""),
+			"unknown-base":  strings.ReplaceAll(source, "p+0(FP),AX", "p+0(FP),DI"),
+			"numeric-base":  strings.ReplaceAll(source, "CMPL BX,CX", "MOVL $42,AX\nCMPL BX,CX"),
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native SETcc invented a source flag or pointer", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+// Complete original format-only SETcc fixtures have no initialized FLAGS or
+// native addresses. Public translation must reject that missing context.
+// This separately labeled emitter unit retains every original instruction and
+// its logical byte result; its objects are never an executable source proof.
+func x86ConditionalSetOriginalEmitterUnit(t *testing.T, file *File, arch, triple string) string {
+	t.Helper()
+	if len(file.Funcs) != 1 || len(file.Data) != 0 || len(file.Globl) != 0 {
+		t.Fatal("SETcc emitter unit requires one complete original TEXT")
+	}
+	fn := file.Funcs[0]
+	if fn.FrameSize != 0 || fn.ArgSize != 1 {
+		t.Fatal("SETcc emitter unit lost its original logical byte layout")
+	}
+	sig := FuncSig{Name: "SETEmitterOnly", Ret: I8,
+		Frame: FrameLayout{Results: []FrameSlot{{Offset: 0, Type: I8, Index: 0, Field: -1}}}}
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\n", triple)
+	emitAMD64Prelude(&ir, arch, file)
+	emitExternSBGlobals(&ir, file, func(name string) string { return name }, nil)
+	ir.WriteString("define i8 @SETEmitterOnly() {\n")
+	consumer := newX86Ctx(&ir, fn, sig, func(name string) string { return name }, nil, arch, triple, false)
+	if err := consumer.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	emitted, returns := 0, 0
+	for ordinal, instruction := range fn.Instrs {
+		switch instruction.Op {
+		case OpTEXT:
+			if ordinal != 0 {
+				t.Fatal("emitter unit lost original TEXT order")
+			}
+		case OpRET:
+			if ordinal != len(fn.Instrs)-1 || len(instruction.Args) != 0 {
+				t.Fatal("emitter unit cannot omit original continuations")
+			}
+			value, err := consumer.loadFPResult(sig.Frame.Results[0])
+			if err != nil {
+				t.Fatal(err)
+			}
+			fmt.Fprintf(&ir, "  ret i8 %s\n", value)
+			returns++
+		default:
+			known, terminated, err := consumer.lowerConditionalSet(instruction.Op, instruction)
+			if !known || terminated || err != nil {
+				t.Fatal("original SETcc row was not emitted", ordinal, instruction.Raw, err)
+			}
+			emitted++
+		}
+	}
+	if emitted != len(fn.Instrs)-2 || returns != 1 || consumer.fpScalarChecked {
+		t.Fatal("emitter unit dropped original source or borrowed a source proof")
+	}
+	ir.WriteString("}\n")
+	t.Logf("emitter-only LLVM object: all %d original SETcc rows; no public translation or execution claim", emitted)
+	return ir.String()
+}
diff --git a/x86_result_signed_integer_float.go b/x86_result_signed_integer_float.go
new file mode 100644
index 000000000..2a28ee227
--- /dev/null
+++ b/x86_result_signed_integer_float.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+// The complete signed conversion grammar supplies a defined low scalar from
+// every native integer source byte. Unwritten merge bytes keep their actual
+// sparse knowledge, not a guessed zero or a requirement to read the whole X.
+// Only the paired volatile native read may supply conditional numerical bytes;
+// the descriptor never grants pointee, caller, frame, alignment or entry roles.
+func x86ResultSignedIntegerFloatStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultSignedIntegerFloatStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultSignedIntegerFloatStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86SignedIntegerFloatProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	return x86ResultIntegerScalarFloatInputs(ins, form, state, owned, arch, nativeRead), true
+}
+
+func x86ResultIntegerScalarFloatInputs(ins Instr, form x86SignedIntegerFloatForm, state *x86ResultState, owned []bool, arch string, nativeRead bool) bool {
+	if !x86ResultNamedPredicateInstruction(ins) {
+		return false
+	}
+	width := int64(form.sourceBits / 8)
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		index, _, valid := x86ResultGP(source.Reg, width, arch)
+		if !valid || state.pointerGP[index] || state.callerAddressGP[index] {
+			return false
+		}
+	}
+	if !x86ResultReadWithNativeContinuation(ins, source, width, state, owned, arch, nativeRead) {
+		return false
+	}
+	upper, _ := amd64ParseXReg(ins.Args[form.upper].Reg)
+	destination, _ := amd64ParseXReg(ins.Args[form.destination].Reg)
+	low := x86CallerVectorByteMask(int64(form.spec.resultBits / 8))
+	merge := state.vectorBytes(upper) & (0xffff &^ low)
+	state.writeVector(destination, 16, low|merge, form.spec.legacy)
+	return true // Integer status and DF remain unchanged; MXCSR is native.
+}
diff --git a/x86_result_signed_packed_float.go b/x86_result_signed_packed_float.go
new file mode 100644
index 000000000..e6c6714c3
--- /dev/null
+++ b/x86_result_signed_packed_float.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+// Native conversion, rounding and exception behavior belong to the existing
+// original-opcode emitter. Numerical availability grants no MXCSR, alignment,
+// pointee, caller or physical-entry fact. Standalone queries have no native read.
+func x86ResultSignedPackedFloatStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86SignedPackedFloatProperties(ins, arch)
+	if !known || err != nil || form.mmx || !x86ResultNamedPredicateInstruction(ins) {
+		return false, known
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	source := ins.Args[0]
+	if source.Kind == OpReg {
+		index, valid := amd64VectorRegisterIndex(source.Reg, form.sourceBytes)
+		mask := x86CallerVectorByteMask(int64(form.inputBytes))
+		if !valid || state.vectorBytes(index)&mask != mask {
+			return false, true
+		}
+	} else if !x86ResultReadWithNativeContinuation(ins, source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+		return false, true
+	}
+	destination, valid := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	output := x86CallerVectorByteMask(int64(form.byteWidth))
+	if !valid || form.mask >= 0 && !form.zeroing && state.vectorBytes(destination)&output != output {
+		return false, true
+	}
+	state.writeVector(destination, form.byteWidth, output, form.spec.legacy)
+	return true, true // EFLAGS, DF, GP, logical memory and pointer identities stay unchanged.
+}
diff --git a/x86_result_slot_move_width_test.go b/x86_result_slot_move_width_test.go
new file mode 100644
index 000000000..715d3ed97
--- /dev/null
+++ b/x86_result_slot_move_width_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultSlotMoveWidthKeepsScalarMode32Boundary(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+			for _, operands := range []string{"AX,(DI)", "(DI),AX", "$17,(DI)"} {
+				t.Run(arch+"/"+op+"/"+operands, func(t *testing.T) {
+					original := x86YMMReadSource(t, op+" "+operands)
+					local := x86GoMOVQSourceInstruction(original)
+					want := int64(8)
+					if arch == "386" {
+						want = 0
+					}
+					if got := x86ResultSlotMoveBytes(local, arch); got != want {
+						t.Fatalf("scalar fallback width=%d want=%d; original %s", got, want, original.Raw)
+					}
+					if original.Op != Op(op) || original.Raw != op+" "+operands {
+						t.Fatal("descriptor rewrote original source identity")
+					}
+				})
+			}
+		}
+		for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q", "VMOVQ"} {
+			for _, operands := range []string{"X0,(DI)", "(DI),X0"} {
+				t.Run(arch+"/legal_X_m64/"+op+"/"+operands, func(t *testing.T) {
+					ins := x86GoMOVQSourceInstruction(x86YMMReadSource(t, op+" "+operands))
+					if got := x86ResultSlotMoveBytes(ins, arch); got != 8 {
+						t.Fatalf("actual legal X/m64 width=%d want8", got)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultSlotMoveWidthWholeProofAndThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, triple := "Q", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, triple = "L", "i386-unknown-linux-gnu"
+		}
+		for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+			for _, operation := range []struct{ name, body string }{
+				{"GP_store", "MOVWORD $17,AX\n " + op + " AX,(DI)"},
+				{"GP_load", "MOVL $17,(DI)\n MOVL $0,4(DI)\n " + op + " (DI),AX\n " + op + " AX,(DI)"},
+				{"immediate", op + " $17,(DI)"},
+			} {
+				t.Run(arch+"/"+op+"/"+operation.name, func(t *testing.T) {
+					body := "LEA" + word + " ret+0(FP),DI\n " + strings.ReplaceAll(operation.body, "WORD", word) + "\n RET"
+					_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint64", body)
+					accept := arch == "amd64"
+					if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); accept && err != nil || !accept && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("private proof accept=%t: %v", accept, err)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint64", arch, triple, api)
+							if accept && (err != nil || ir == "") || !accept && (err == nil || ir != "") {
+								t.Fatalf("complete ordinary I64 source %s accept=%t: %v", api, accept, err)
+							}
+							if !accept && !strings.Contains(err.Error(), "outside Go 1.27's MOVD/ymovq forms") {
+								t.Fatalf("bad mode32 GP-only source lost its explicit form rejection: %v", err)
+							}
+						})
+					}
+				})
+			}
+		}
+		for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q", "VMOVQ"} {
+			t.Run(arch+"/legal_X_m64/"+op, func(t *testing.T) {
+				body := fmt.Sprintf("LEA%s ret+0(FP),DI\n PXOR X0,X0\n %s X0,(DI)\n %s (DI),X1\n %s X1,(DI)\n RET", word, op, op, op)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() uint64", body)
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal(err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if _, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint64", arch, triple, api); err != nil {
+							t.Fatal(err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_sqrt.go b/x86_result_sqrt.go
new file mode 100644
index 000000000..b6fc2be13
--- /dev/null
+++ b/x86_result_sqrt.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+func x86RawFP16SqrtSource(ins Instr, arch string) bool {
+	f, known, err := x86SqrtProperties(ins, arch)
+	return known && err == nil && f.bits == 16 && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Sqrt computes only from its first operand. Scalar VEX/EVEX copies the
+// second operand's upper X bytes without requiring its unused low scalar.
+// Unknown copied bytes stay unknown; no pointer or storage facts are created.
+func x86ResultSqrtStep(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	f, known, err := x86SqrtProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if f.bits == 16 {
+		if !nativeRead || !x86RawFP16SqrtSource(ins, arch) {
+			return false, true
+		}
+		// The original identity above remains mandatory. This local projection
+		// lets the shared numerical read consume the paired native access only.
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	if f.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[f.mask].Reg)
+		if !state.masks[mask] {
+			return false, true
+		}
+	}
+	input := ^uint64(0)
+	if f.memory >= 0 {
+		if !f.scalar && ins.Args[0].Kind == OpFP {
+			return false, true // Packed original memory needs contiguous native backing.
+		}
+		if !x86ResultReadWithNativeContinuation(ins, ins.Args[0], int64(f.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+	} else {
+		source, _ := amd64VectorRegisterIndex(ins.Args[0].Reg, f.byteWidth)
+		input = state.vectorBytes(source)
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[f.destination].Reg, f.byteWidth)
+	old := state.vectorBytes(destination)
+	upper, _ := amd64VectorRegisterIndex(ins.Args[f.second].Reg, f.byteWidth)
+	value, valid := x86SqrtDefinedBytes(f, input, state.vectorBytes(upper), old)
+	if !valid {
+		return false, true
+	}
+	state.writeVector(destination, f.byteWidth, value, f.legacy)
+	return true, true
+}
diff --git a/x86_result_stack_flags_correlation_runtime_test.go b/x86_result_stack_flags_correlation_runtime_test.go
new file mode 100644
index 000000000..d32bc3819
--- /dev/null
+++ b/x86_result_stack_flags_correlation_runtime_test.go
@@ -0,0 +1,49 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86Mode32PrivateFlagsCancellationPortableValues(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	var checks strings.Builder
+	index := 0
+	for _, carrier := range []struct {
+		width, typ, ctyp string
+		bytes            int
+		masks            []uint32
+	}{
+		{"W", "uint16", "uint16_t", 2, []uint32{0, 1, 0x40, 0x400, 0x8d5}},
+		{"L", "uint32", "uint32_t", 4, []uint32{0, 1, 0x400, 0x200000, 0x200cd5}},
+	} {
+		for _, register := range []string{"AX", "BX", "CX", "DX", "BP", "SI", "DI"} {
+			for _, mask := range carrier.masks {
+				name := fmt.Sprintf("cancelFlags%d", index)
+				index++
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%sMOV%s %s,ret+0(FP)\nRET\n",
+					name, carrier.bytes, x86StackFlagsCorrelationBody(carrier.width, register, mask), carrier.width, register)
+				fmt.Fprintf(&declarations, "func %s() %s\n", name, carrier.typ)
+				fmt.Fprintf(&driver, "extern %s %s(void);\n", carrier.ctyp, name)
+				fmt.Fprintf(&checks, "if (%s()!=UINT32_C(%d)) {fprintf(stderr,\"%s\\n\"); return 1;}\n", name, mask, name)
+			}
+		}
+	}
+	fmt.Fprintf(&driver, "int main(void) {for(unsigned row=0;row<257;++row) {%s} return 0;}\n", checks.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "386", execution.triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete portable private FLAGS source", err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "private-flags-values", text, driver.String(), level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_stack_flags_correlation_test.go b/x86_result_stack_flags_correlation_test.go
new file mode 100644
index 000000000..9aa914e90
--- /dev/null
+++ b/x86_result_stack_flags_correlation_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// These are independent numerical programs, not replacements for the original
+// eighteen-TEXT Windows fixture. Two copies of the same FLAGS bits must cancel
+// after XOR even when their entry values are unknown. No unknown bit becomes
+// available to an unrelated read, branch, pointer or return.
+func x86StackFlagsCorrelationBody(width, register string, mask uint32) string {
+	return fmt.Sprintf("PUSHF%s\nPUSHF%s\nXOR%s $%d,0(SP)\nPOPF%s\n"+
+		"PUSHF%s\nPOP%s %s\nXOR%s 0(SP),%s\nPOPF%s\n",
+		width, width, width, mask, width, width, width, register, width, register, width)
+}
+
+func TestX86Mode32PrivateFlagsCopiesCancelUnknownInputs(t *testing.T) {
+	for _, row := range []struct {
+		width, typ string
+		bytes      int
+		masks      []uint32
+	}{
+		{"W", "uint16", 2, []uint32{0, 1, 0x40, 0x400, 0x8d5}},
+		{"L", "uint32", 4, []uint32{0, 1, 0x400, 0x200000, 0x200cd5}},
+	} {
+		for _, register := range []string{"AX", "BX", "CX", "DX", "BP", "SI", "DI"} {
+			for _, mask := range row.masks {
+				body := x86StackFlagsCorrelationBody(row.width, register, mask)
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOV%s %s,ret+0(FP)\nRET\n",
+					row.bytes, body, row.width, register)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%x/%s", row.width, register, mask, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() "+row.typ,
+							"386", "i386-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatal("balanced private FLAGS copies did not cancel their same unknown bits", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86Mode32PrivateFlagsSubwordCopiesCancel(t *testing.T) {
+	for _, carrier := range []struct {
+		width, typ string
+		bytes      int
+	}{
+		{"W", "uint16", 2}, {"L", "uint32", 4},
+	} {
+		for _, access := range []struct {
+			width string
+			bytes int
+		}{
+			{"B", 1}, {"W", 2}, {"L", 4},
+		} {
+			for offset := 0; offset+access.bytes <= carrier.bytes; offset++ {
+				mask := uint32(0x200cd5) >> uint(offset*8)
+				if access.bytes < 4 {
+					mask &= uint32(1)<<uint(access.bytes*8) - 1
+				}
+				body := x86StackFlagsCorrelationBody(carrier.width, "AX", 0)
+				body = strings.Replace(body, "XOR"+carrier.width+" $0,0(SP)",
+					fmt.Sprintf("XOR%s $%d,%d(SP)", access.width, mask, offset), 1)
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sMOV%s AX,ret+0(FP)\nRET\n",
+					carrier.bytes, body, carrier.width)
+				requireX86GoAssemblerResult(t, "386", source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%d/%s", carrier.width, access.width, offset, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() "+carrier.typ,
+							"386", "i386-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatal("bounded B/W/L XOR lost the copied FLAGS bit identities", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86Mode32PrivateFlagsCorrelationCannotInventValues(t *testing.T) {
+	const prefix = "TEXT ·Value(SB),4,$0-4\n"
+	const suffix = "MOVL AX,ret+0(FP)\nRET\n"
+	base := x86StackFlagsCorrelationBody("L", "AX", 0x200000)
+	for _, row := range []struct{ name, before, after string }{
+		{"uncancelled", "XORL 0(SP),AX\n", ""},
+		{"different-unknown", "XORL 0(SP),AX", "XORL BX,AX"},
+		{"unwritten-upper", "POPL AX", "POPW AX\nPOPW BX"},
+		{"outside-live-stack", "XORL 0(SP),AX", "XORL 4(SP),AX"},
+		{"partial-outside-live-stack", "XORL 0(SP),AX", "XORL 1(SP),AX"},
+		{"before-live-stack", "XORL 0(SP),AX", "XORL -4(SP),AX"},
+		{"indexed-stack", "XORL 0(SP),AX", "XORL 0(SP)(CX*1),AX"},
+		{"symbolic-stack", "XORL 0(SP),AX", "XORL saved+0(SP),AX"},
+		{"changed-stack-pointer", "XORL 0(SP),AX", "MOVL $0,SP\nXORL 0(SP),AX"},
+		{"unbalanced-return", "XORL 0(SP),AX\nPOPFL", "XORL 0(SP),AX"},
+	} {
+		if strings.Count(base, row.before) != 1 {
+			t.Fatal("independent mutation is not unique", row.name)
+		}
+		source := prefix + strings.Replace(base, row.before, row.after, 1) + suffix
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32",
+					"386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("private FLAGS identity invented a value or backing stack extent", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86Mode32PrivateFlagsCorrelationOriginalGoAndLLVMObjects(t *testing.T) {
+	var source, declarations strings.Builder
+	for _, row := range []struct {
+		width, typ string
+		bytes      int
+		mask       uint32
+	}{
+		{"W", "uint16", 2, 0xcd5},
+		{"L", "uint32", 4, 0x200cd5},
+	} {
+		for index, register := range []string{"AX", "BX", "CX", "DX", "BP", "SI", "DI"} {
+			name := fmt.Sprintf("flags%s%d", row.width, index)
+			fmt.Fprintf(&declarations, "func %s() %s\n", name, row.typ)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%sMOV%s %s,ret+0(FP)\nRET\n",
+				name, row.bytes, x86StackFlagsCorrelationBody(row.width, register, row.mask), row.width, register)
+		}
+	}
+	// Actual Go owns the independent W/L stack and yaddl operand grammar.
+	// The LLVM objects below retain the complete source, without seeding flags.
+	requireX86GoAssemblerResult(t, "386", source.String(), true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("private FLAGS objects require LLVM 22 llc")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "386", triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete original private FLAGS program", err)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, triple, ir, level)
+				}
+			})
+		}
+	}
+}
+
+func TestX86Mode32PrivateFlagsSourceAndQueryBoundaries(t *testing.T) {
+	source := "TEXT ·Value(SB),4,$0-4\n" + x86StackFlagsCorrelationBody("L", "AX", 0x200000) + "MOVL AX,ret+0(FP)\nRET\n"
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig := FuncSig{Name: "Value", Ret: I32, Frame: FrameLayout{
+		Results: []FrameSlot{{Type: I32, Index: 0, Field: -1}},
+	}}
+	if !errors.Is(CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "386"), ErrProbeNeedsContext) ||
+		!errors.Is(checkX86ScalarFPResultInitialization(file.Funcs[0], sig, "386"), ErrProbeNeedsContext) {
+		t.Fatal("standalone queries acquired private lowering storage")
+	}
+	for name, change := range map[string]func(*Func){
+		"operand": func(fn *Func) {
+			for index := range fn.Instrs {
+				if fn.Instrs[index].Op == "XORL" {
+					fn.Instrs[index].Args[1].Mem.Off = 1
+					return
+				}
+			}
+		},
+		"frame": func(fn *Func) { fn.FrameSize = 8 },
+		"literal": func(fn *Func) {
+			for index := range fn.Instrs {
+				if fn.Instrs[index].Op == "XORL" {
+					fn.Instrs[index].Raw = "XORL $1,0(SP)"
+					return
+				}
+			}
+		},
+		"raw": func(fn *Func) { fn.Instrs[1].x86Encoded = true },
+	} {
+		t.Run(name, func(t *testing.T) {
+			fn := x86DirectTailSnapshot(file).Funcs[0]
+			change(&fn)
+			if _, err := x86ResultPrivateFlagsSource(fn, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed original source retained private storage identity", err)
+			}
+		})
+	}
+}
+
+func TestX86Mode32PrivateFlagsCloneAndJoinIdentity(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+x86StackFlagsCorrelationBody("L", "AX", 1)+"RET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	stack, err := x86ResultPrivateFlagsSource(file.Funcs[0], "386")
+	if err != nil || stack == nil {
+		t.Fatal("independent private source", err)
+	}
+	left := x86ResultState{valueStack: stack}
+	push := x86ScalarLaneInstruction(t, "PUSHFL")
+	if !x86ResultTransfer(push, &left, nil, 0, "386") {
+		t.Fatal("private FLAGS copy")
+	}
+	before := left.clone()
+	right := left.clone()
+	right.valueStack.correlation.flags[0] = 255
+	right.valueStack.correlation.bytes[3][0] = 255
+	right.valueStack.correlation.popped[0] = 1
+	merged := left.intersect(right)
+	if !reflect.DeepEqual(before, left) || merged.valueStack.correlation == nil ||
+		merged.valueStack.correlation.flags[0] != 255 || merged.valueStack.correlation.bytes[3][0] != 255 ||
+		merged.valueStack.correlation.popped[0] != 255 {
+		t.Fatal("clone/join retained an unequal relation or mutated a predecessor")
+	}
+	if got := left.intersect(left); !reflect.DeepEqual(got, left) {
+		t.Fatal("identical CFG paths lost their original relation")
+	}
+}
+
+func TestX86Mode32PrivateFlagsXOROriginTruthTable(t *testing.T) {
+	for _, left := range []uint8{0, 1, 2, 3, 255} {
+		for _, right := range []uint8{0, 1, 2, 3, 255} {
+			// Enumerate independent input bits. Untracked left/right values
+			// deliberately use different variables even for the same tag.
+			first, constant := uint8(0), true
+			for input := uint8(0); input < 32; input++ {
+				value := func(origin uint8, untracked uint8) uint8 {
+					if origin == 0 {
+						return 0
+					}
+					if origin == 255 {
+						origin = untracked
+					}
+					return input >> (origin - 1) & 1
+				}
+				got := value(left, 4) ^ value(right, 5)
+				if input == 0 {
+					first = got
+				}
+				constant = constant && got == first
+			}
+			if (x86FlagsXOROrigin(left, right) == 0) != constant {
+				t.Fatal("XOR dependency disagrees with exhaustive independent bit assignments", left, right)
+			}
+		}
+	}
+}
+
+func TestX86Mode32PrivateFlagsCompleteXORRows(t *testing.T) {
+	for _, row := range []struct{ width, register string }{
+		{"B", "AL"}, {"B", "AH"}, {"W", "AX"}, {"L", "AX"},
+	} {
+		for _, address := range []string{"(SP)", "0(SP)", "0x0(SP)"} {
+			for _, modify := range []string{
+				"XOR" + row.width + " $1," + address,
+				"MOVL $1,AX\nXOR" + row.width + " " + row.register + "," + address,
+			} {
+				body := "PUSHFL\nPUSHFL\n" + modify + "\nPOPFL\nPUSHFL\nPOPL AX\nXORL " + address + ",AX\nPOPFL\n"
+				source := "TEXT ·Value(SB),4,$0-4\n" + body + "MOVL AX,ret+0(FP)\nRET\n"
+				requireX86GoAssemblerResult(t, "386", source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%s", row.width, row.register, modify, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", "386", "i386-unknown-linux-gnu", api)
+						if err != nil || ir == "" {
+							t.Fatal("complete typed XOR row lost its private storage dependency", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_state_domains_test.go b/x86_result_state_domains_test.go
new file mode 100644
index 000000000..9b122ca38
--- /dev/null
+++ b/x86_result_state_domains_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86ABI0ResultInitializationPrivateScalarPointerDomain(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := x86ResultPointerWord(arch)
+		finish := fmt.Sprintf("MOVL $42,ret0+%d(FP)\nRET", word)
+		for name, body := range x86ResultIncomingPointerIdentityBodies(arch) {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch,
+					"func Value(x *[8]uint32) uint32", body+finish)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("public opaque identity observation: %v", err)
+				}
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatalf("opaque transport does not consume numerical pointer bytes: %v", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ABI0ResultInitializationAllStateDomainJoins(t *testing.T) {
+	left := x86ResultState{}
+	right := x86ResultState{}
+	for index := range left.gp {
+		left.gp[index], right.gp[index] = 0xff, 0x0f
+		left.canonicalGP[index], right.canonicalGP[index] = 0x55, 0x33
+		left.pointerGP[index] = true
+		right.pointerGP[index] = index%2 == 0
+		left.callerAddressGP[index] = index%3 == 0
+		right.callerAddressGP[index] = index%2 == 0
+	}
+	for index := range left.xmm {
+		left.xmm[index], right.xmm[index] = 0xffff, 0x00ff
+	}
+	for index := range left.nativeMMX {
+		left.nativeMMX[index], right.nativeMMX[index] = 0xff, 0x55
+	}
+	for index := range left.masks {
+		left.masks[index] = true
+		right.masks[index] = index%2 == 0
+	}
+	merged := left.intersect(right)
+	for index := range merged.gp {
+		if merged.gp[index] != 0x0f || merged.canonicalGP[index] != 0x11 || merged.pointerGP[index] != (index%2 == 0) || merged.callerAddressGP[index] != (index%6 == 0) {
+			t.Errorf("GP/pointer join %d: %+v", index, merged)
+		}
+	}
+	for index := range merged.xmm {
+		if merged.xmm[index] != 0x00ff {
+			t.Errorf("X%d bypassed the must-defined join: %#x", index, merged.xmm[index])
+		}
+	}
+	for index := range merged.nativeMMX {
+		if merged.nativeMMX[index] != 0x55 {
+			t.Errorf("M%d bypassed the native-region must-defined join", index)
+		}
+	}
+	for index := range merged.masks {
+		if merged.masks[index] != (index%2 == 0) {
+			t.Errorf("K%d bypassed the must-defined join", index)
+		}
+	}
+}
diff --git a/x86_result_static_move.go b/x86_result_static_move.go
new file mode 100644
index 000000000..75e863f89
--- /dev/null
+++ b/x86_result_static_move.go
@@ -0,0 +1,51 @@
+package plan9asm
+
+// Symbol syntax and the shared GP MOV row are separate from storage authority.
+// Reuse the register/immediate grammar and its encoded-value normalization;
+// the temporary AX address validates only that row and never becomes a source
+// operand, initialized address, or permission in either returned form.
+func x86ScalarStaticStoreProperties(op Op, ins Instr, arch string) (x86ScalarNativeStoreForm, bool, error) {
+	if len(ins.Args) != 2 || ins.Args[0].Kind != OpReg && ins.Args[0].Kind != OpImm {
+		return x86ScalarNativeStoreForm{}, false, nil
+	}
+	if _, valid := x86StaticSBSourceAddress(ins.Args[1], arch); !valid {
+		return x86ScalarNativeStoreForm{}, false, nil
+	}
+	projected := ins
+	projected.Args = []Operand{ins.Args[0], {Kind: OpMem, Mem: MemRef{Base: AX}}}
+	form, known, err := x86ScalarNativeStoreProperties(op, projected, arch)
+	if known && err == nil {
+		form.destination = ins.Args[1]
+	}
+	return form, known, err
+}
+
+// Only the emitted module's complete numeric extent and actual writable
+// object supply this continuation. A source-level symbol, C declaration,
+// pointer value, raw instruction or standalone byte query supplies neither.
+// A store defines no register, caller byte, reusable address or memory fact.
+func (c *amd64Ctx) scalarStaticMoveTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86ScalarStaticStoreProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		state == nil || c.fpStaticAddressValues == nil || c.resolve == nil {
+		return false, true
+	}
+	address, valid := x86StaticSBReadAddress(form.destination, arch)
+	if !valid || c.fpScalarData[address] < form.bytes {
+		return false, true
+	}
+	name := resolveAssemblyDataSymbol(address.symbol, c.resolve)
+	if !c.fpStaticAddressValues.objects[name] || !c.fpStaticAddressValues.writable[name] {
+		return false, true // Numeric extent alone does not establish a writable backing object.
+	}
+	if form.source.Kind == OpReg {
+		index, _, valid := x86ResultGP(form.source.Reg, form.bytes, arch)
+		if !valid || state.pointerGP[index] {
+			return false, true
+		}
+	}
+	return x86ResultRead(form.source, form.bytes, state, owned, arch), true
+}
diff --git a/x86_result_static_rmw.go b/x86_result_static_rmw.go
new file mode 100644
index 000000000..302f401fb
--- /dev/null
+++ b/x86_result_static_rmw.go
@@ -0,0 +1,129 @@
+package plan9asm
+
+import "strings"
+
+// Only this module's actual writable numeric bytes supply the memory input
+// to the paired XADD/XCHG emitter. Symbol syntax, opaque pointer data and a
+// declaration alone cannot supply storage or numerical register outputs.
+func (c *amd64Ctx) scalarStaticExchangeTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	name := Op(strings.ToUpper(string(ins.Op)))
+	spec, known := amd64ExchangeSpecs[name]
+	if !known {
+		return false, false
+	}
+	symbolic := false
+	for _, operand := range ins.Args {
+		if operand.Kind == OpSym || operand.Kind == OpMem && operand.Mem.Sym != "" {
+			symbolic = true
+			break
+		}
+	}
+	if !symbolic {
+		return false, false // Cost query only; ordinary native/register forms keep their existing parser.
+	}
+	form, err := parseAMD64ExchangeForm(arch, name, spec, ins)
+	if err != nil {
+		return false, true
+	}
+	address, static := x86StaticSBReadAddress(form.other, arch)
+	if !static {
+		return false, false // The native pointer, register and physical frame routes keep their own inputs.
+	}
+	values := c.fpStaticAddressValues
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil ||
+		values == nil || state == nil || c.resolve == nil {
+		return false, true
+	}
+	width := int64(spec.bits / 8)
+	symbol := resolveAssemblyDataSymbol(address.symbol, c.resolve)
+	index, _, valid := x86ResultGP(form.register.Reg, width, arch)
+	if !values.objects[symbol] || !values.writable[symbol] || c.fpScalarData[address] < width ||
+		!valid || state.pointerGP[index] || !x86ResultRead(form.register, width, state, owned, arch) {
+		return false, true
+	}
+	return x86ResultExchangeWriteback(spec, []Operand{form.register}, state, owned, arch), true
+}
+
+// Consume only the actual emitted module's numeric storage and address values.
+// The complete shared scalar grammar owns widths, byte views and FLAGS effects;
+// the unchanged emitter owns paired volatile accesses. No external symbol or
+// declaration-only query gains storage, address or initialized-result facts.
+func (c *amd64Ctx) scalarStaticRMWTransfer(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil ||
+		!x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, false
+	}
+	if form.spec.bitString {
+		return c.scalarStaticBitStringTransfer(form, state, owned, arch)
+	}
+	destination, static := x86StaticSBReadAddress(form.destination, arch)
+	relocation := x86AbsoluteRelocationSource(form.source, arch, form.spec.bits)
+	if !static && (!relocation || form.destination.Kind != OpReg) {
+		return false, false
+	}
+	values := c.fpStaticAddressValues
+	if values == nil || state == nil {
+		return false, true
+	}
+	width := int64(form.spec.bits / 8)
+	if static {
+		name := resolveAssemblyDataSymbol(destination.symbol, c.resolve)
+		if !values.writable[name] || c.fpScalarData[destination] < width {
+			return false, true // A numeric extent alone is not writable storage.
+		}
+	} else if !x86ResultRead(form.destination, width, state, owned, arch) {
+		return false, true
+	}
+	if relocation {
+		address, immediate, valid := x86StaticAddressValueSource(form.source, arch)
+		if !valid || !immediate || !values.objects[resolveAssemblyDataSymbol(address.symbol, c.resolve)] {
+			return false, true
+		}
+	} else if !form.spec.unary && !x86ResultRead(form.source, width, state, owned, arch) {
+		return false, true
+	}
+	if (form.spec.stem == "ADC" || form.spec.stem == "SBB") && state.flags&x86ByteFlagCF == 0 {
+		return false, true
+	}
+	if !static {
+		index, _, valid := x86ResultGP(form.destination.Reg, width, arch)
+		if !valid || state.pointerGP[index] || !x86ResultStore(form.destination, width, state, owned, 0, arch) {
+			return false, true
+		}
+		// Relocation arithmetic is mode32/L only. Its full numerical result
+		// and architectural upper zeroes are not a canonical bool or pointer.
+		state.canonicalGP[index] = 0xf0
+		state.callerAddressGP[index], state.callerAddressOrigin[index] = false, 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true // No new memory-read capability or unrelated state escapes.
+}
+
+// Both native emitters retain the complete BTC/BTR/BTS memory effect: the LOCK
+// helper, or the ordinary emitter's volatile access and signed word selection.
+// The actual module owns this writable base word; this is not a bound on the
+// register-indexed access. If native execution continues, only its FLAGS result
+// becomes numerical. No dynamic extent or reusable memory fact is exported.
+func (c *amd64Ctx) scalarStaticBitStringTransfer(form x86LockScalarRMWForm, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	destination, static := x86StaticSBReadAddress(form.destination, arch)
+	if !static {
+		return false, false
+	}
+	values := c.fpStaticAddressValues
+	if values == nil || state == nil {
+		return false, true
+	}
+	name := resolveAssemblyDataSymbol(destination.symbol, c.resolve)
+	width := int64(form.spec.bits / 8)
+	if !values.objects[name] || !values.writable[name] || c.fpScalarData[destination] < width ||
+		!x86ResultRead(form.source, width, state, owned, arch) {
+		return false, true
+	}
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true
+}
diff --git a/x86_result_string_compare_caller_test.go b/x86_result_string_compare_caller_test.go
new file mode 100644
index 000000000..4e6f834f9
--- /dev/null
+++ b/x86_result_string_compare_caller_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86StringCompareWholeFlowPreservesExactCallerFootprint(t *testing.T) {
+	const declaration = "func view(p *byte,needle uintptr) uint32"
+	for _, target := range x86RawReturnTargets {
+		word, move, compare, widths := 8, "MOVQ", "CMPQ", "BWLQ"
+		if target.arch == "386" {
+			word, move, compare, widths = 4, "MOVL", "CMPL", "BWL"
+		}
+		for _, stem := range []string{"SCAS", "CMPS"} {
+			for _, width := range widths {
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					for _, zero := range []bool{true, false} {
+						if prefix == "" && !zero {
+							continue // Bare strings execute once, independently of CX.
+						}
+						registers := []string{"CX"}
+						if prefix != "" {
+							registers = []string{"DI", "SI"}
+						}
+						for _, register := range registers {
+							if !zero && stem == "SCAS" && register == "SI" {
+								continue // This separate input is not an updated SCAS index.
+							}
+							for _, api := range []string{"text", "module", "Go"} {
+								t.Run(fmt.Sprintf("%s/%s%c/%s/zero%t/%s/%s", target.triple, stem, width, prefix, zero, register, api), func(t *testing.T) {
+									body := fmt.Sprintf("%s p+0(FP),SI\n%s p+0(FP),DI\n%s needle+%d(FP),AX\n", move, move, move, word)
+									if prefix == "" {
+										body += move + " p+0(FP),CX\nCLD\n"
+									} else if zero {
+										body += "MOVL $0,CX\n" + prefix + "\n"
+									} else {
+										body += "MOVL $1,CX\nCLD\n" + prefix + "\n"
+									}
+									body += stem + string(width) + "\n" + compare + " " + register + ",$0\nMOVL $7,ret+RESULT(FP)"
+									source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+									ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+									if err != nil || ir == "" {
+										t.Fatal("comparison lost independently initialized entry-derived address bits", err)
+									}
+									// Keep the complete original comparison above. Observing
+									// its bits is not permission to access the changed cursor.
+									for _, access := range []struct{ name, instruction string }{
+										{"native-read", "MOVBLZX (" + register + "),DX"},
+										{"native-store", "MOVB $1,(" + register + ")"},
+									} {
+										t.Run(access.name, func(t *testing.T) {
+											changed := strings.Replace(body, compare+" "+register+",$0\n", access.instruction+"\n", 1)
+											changedSource := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, changed)
+											ir, err := x86ScalarFPBitViewAPI(t, changedSource, declaration, target.arch, target.triple, api)
+											if zero {
+												if err != nil || ir == "" {
+													t.Fatal("zero iterations revoked the actual unchanged pointer", err)
+												}
+											} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+												t.Fatal("cursor bits acquired a reusable native memory role", err)
+											}
+										})
+									}
+								})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_string_compare_effect_test.go b/x86_result_string_compare_effect_test.go
new file mode 100644
index 000000000..11d949d32
--- /dev/null
+++ b/x86_result_string_compare_effect_test.go
@@ -0,0 +1,222 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func x86StringCompareModelSite(t *testing.T, arch, opcode, prefix string) (*x86ResultStringMemoryPlan, int, Instr) {
+	t.Helper()
+	body := "TEXT compare(SB),4,$0-0\n"
+	if prefix != "" {
+		body += prefix + "\n"
+	}
+	file, err := Parse(ArchAMD64, body+opcode+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	plan, err := x86ResultStringMemorySourcePlan(file.Funcs[0], arch)
+	if err != nil || plan == nil || len(plan.bodies) != 1 {
+		t.Fatal("complete source model lost its typed compare", err)
+	}
+	for ordinal, site := range plan.bodies {
+		return plan, ordinal, site.instruction
+	}
+	t.Fatal("missing source comparison")
+	return nil, 0, Instr{}
+}
+
+func TestX86StringCompareTypedContinuationChangesOnlyActualOutputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := "BWLQ"
+		if arch == "386" {
+			widths = "BWL"
+		}
+		for _, stem := range []string{"SCAS", "CMPS"} {
+			for _, width := range widths {
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					for _, count := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+						for _, direction := range []x86ResultDirection{x86ResultDirectionForward, x86ResultDirectionBackward, x86ResultDirectionEither} {
+							t.Run(fmt.Sprintf("%s/%s%c/%s/%d/%d", arch, stem, width, prefix, count, direction), func(t *testing.T) {
+								plan, ordinal, ins := x86StringCompareModelSite(t, arch, stem+string(width), prefix)
+								state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagAF, direction: direction, stringCount: count}
+								state.gp[0], state.gp[1], state.gp[3] = 0xff, 0xff, 0x55
+								state.canonicalGP[0], state.canonicalGP[1], state.canonicalGP[3] = 0xa5, 0xff, 0x55
+								for _, index := range []int{3, 6, 7} {
+									state.pointerGP[index], state.callerAddressGP[index], state.callerAddressOrigin[index] = true, true, uint16(index+1)
+									state.resultAddressGP[index] = x86ResultSlotAddress{start: 4, end: 8, valid: true}
+								}
+								expected := state.clone()
+								if prefix == "" || count != x86StringCountZero {
+									indexes := []int{7}
+									if stem == "CMPS" {
+										indexes = append(indexes, 6)
+									}
+									for _, index := range indexes {
+										expected.gp[index], expected.canonicalGP[index] = 0, 0
+										expected.pointerGP[index] = false
+										expected.resultAddressGP[index] = x86ResultSlotAddress{}
+									}
+									if prefix == "" || count == x86StringCountNonzero {
+										expected.flags = x86ByteFlagsAll
+									}
+									if prefix != "" {
+										expected.stringCount, expected.canonicalGP[1] = x86StringCountUnknown, 0
+										if arch == "386" {
+											expected.canonicalGP[1] = 0xf0
+										}
+									}
+								}
+								if accepted, known := plan.transfer(ordinal, ins, &state, arch); !accepted || !known || !reflect.DeepEqual(state, expected) {
+									t.Fatal("conditional native comparison changed another byte, identity or FLAGS/DF domain", accepted, known)
+								}
+								// The shared post-consumer must retain exactly the paired
+								// transfer's surviving caller identities and origins.
+								before := [16]bool{3: true, 6: true, 7: true}
+								origins := [16]uint16{3: 4, 6: 7, 7: 8}
+								addresses := x86ResultCallerAddressesAfterTransfer(ins, before, state.callerAddressGP, nil, arch)
+								if addresses != expected.callerAddressGP {
+									t.Fatal("post-consumer changed the actual conditional caller footprint")
+								}
+								entry := map[int64]bool{0: true}
+								if got := x86ResultCallerOriginsAfter(ins, origins, addresses, entry, arch); got != expected.callerAddressOrigin {
+									t.Fatal("revoked caller origins did not match the final address domain")
+								}
+								transferred := state.callerAddressGP
+								transferred[0] = true
+								if got := x86ResultCallerAddressesAfterTransfer(ins, before, transferred, nil, arch); got[0] {
+									t.Fatal("post-consumer introduced an identity absent before the transfer")
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+		for _, row := range []struct {
+			name, source string
+			change       func(*Instr)
+		}{
+			{name: "operands", source: "SCASB AX"},
+			{name: "unrelated-string", source: "MOVSB"},
+			{name: "raw", source: "SCASB", change: func(ins *Instr) { ins.x86Encoded = true }},
+			{name: "address-override", source: "CMPSB", change: func(ins *Instr) { ins.x86AddressBits = 32 }},
+		} {
+			t.Run(arch+"/post-consumer/"+row.name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.source)
+				if row.change != nil {
+					row.change(&ins)
+				}
+				before := [16]bool{1: true, 3: true, 6: true, 7: true}
+				want := [16]bool{}
+				if row.name == "unrelated-string" {
+					// MOVS is now independently registered. This post-consumer
+					// intersects already accepted reaching facts, not permissions.
+					want = before
+				}
+				if got := x86ResultCallerAddressesAfterTransfer(ins, before, before, nil, arch); got != want {
+					t.Fatal("unbound source borrowed the paired string footprint")
+				}
+			})
+		}
+	}
+}
+
+func TestX86StringCompareCountFactsRevokeAndIntersect(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, xor := "MOVL", "XORL"
+		if arch == "amd64" {
+			move, xor = "MOVQ", "XORQ"
+		}
+		for _, row := range []struct {
+			source string
+			want   x86ResultStringCount
+		}{
+			{move + " $0,CX", x86StringCountZero},
+			{move + " $1,CX", x86StringCountNonzero},
+			{"MOVL $0,CX", x86StringCountZero},
+			{"MOVB $0,CL", x86StringCountUnknown},
+			{"MOVB $0,CH", x86StringCountUnknown},
+			{"MOVW $0,CX", x86StringCountUnknown},
+			{"MOVW AX,CX", x86StringCountUnknown},
+			{"MOVL AX,CX", x86StringCountUnknown},
+			{xor + " CX,CX", x86StringCountZero},
+			{"XORW CX,CX", x86StringCountUnknown},
+			{"INCL CX", x86StringCountUnknown},
+			{"POPL CX", x86StringCountUnknown},
+			{"CALL other(SB)", x86StringCountUnknown},
+			{"CMPL AX,AX", x86StringCountNonzero},
+			{"MOVL $8,BX", x86StringCountNonzero},
+			{"CLD", x86StringCountNonzero},
+			{"STD", x86StringCountNonzero},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.source)
+				if got := x86ResultStringCountAfter(ins, x86StringCountNonzero, x86StringCountNonzero, arch); got != row.want {
+					t.Fatal("counter fact was inferred from partial or overwritten bytes", got, row.want)
+				}
+				ins.x86Encoded = true
+				if got := x86ResultStringCountAfter(ins, x86StringCountZero, x86StringCountZero, arch); got != x86StringCountUnknown {
+					t.Fatal("raw source retained a counter value")
+				}
+			})
+		}
+	}
+	for _, left := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+		for _, right := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+			state := x86ResultState{stringCount: left}
+			copy := state.clone()
+			copy.stringCount = right
+			want := x86StringCountUnknown
+			if left == right {
+				want = left
+			}
+			if state.stringCount != left || state.intersect(copy).stringCount != want {
+				t.Fatal("counter join created a zero/nonzero value or clone mutated its parent")
+			}
+		}
+	}
+}
+
+func TestX86StringComparePlanBindsOriginalPrefixAndBody(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, shape := range []string{"adjacent", "fallthrough-label-chain", "branch-to-prefix", "pc-to-prefix",
+				"conditional-bypass", "unreachable-prefix", "backedge-to-body", "pc-bypass", "unknown-indirect"} {
+				t.Run(arch+"/"+prefix+"/"+shape, func(t *testing.T) {
+					source := "TEXT compare(SB),4,$0-0\n" + x86StringRepeatCFGBody("SCASB", prefix, shape) + "RET\n"
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					plan, err := x86ResultStringMemorySourcePlan(file.Funcs[0], arch)
+					positive := shape == "adjacent" || shape == "fallthrough-label-chain" || shape == "branch-to-prefix" || shape == "pc-to-prefix"
+					if !positive {
+						if err == nil {
+							t.Fatal("a branch borrowed its skipped source prefix")
+						}
+						return
+					}
+					if err != nil || plan == nil || len(plan.prefixes) != 1 || len(plan.bodies) != 1 {
+						t.Fatal("unique complete source binding was lost", err)
+					}
+					for ordinal, site := range plan.bodies {
+						state := x86ResultState{shapeOnly: true}
+						if accepted, known := plan.transfer(ordinal, site.instruction, &state, arch); !accepted || !known {
+							t.Fatal("bound shape was lost")
+						}
+						changed := site.instruction
+						changed.Raw += " changed"
+						if accepted, _ := plan.transfer(ordinal, changed, &state, arch); accepted {
+							t.Fatal("another original instruction borrowed the source ordinal")
+						}
+						if accepted, _ := plan.transfer(ordinal+1, site.instruction, &state, arch); accepted {
+							t.Fatal("comparison borrowed another source ordinal")
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_string_compare_objects_test.go b/x86_result_string_compare_objects_test.go
new file mode 100644
index 000000000..6944db3b2
--- /dev/null
+++ b/x86_result_string_compare_objects_test.go
@@ -0,0 +1,33 @@
+package plan9asm
+
+import "testing"
+
+func TestX86StringCompareFiveTargetThreeAPICompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86StringCompareCompleteSource(t, target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete original string-comparison source was rejected", err)
+				}
+				for _, irLevel := range []string{"0", "2"} {
+					input := ir
+					if irLevel == "2" {
+						input = x86DwordProductIROptimize(t, input)
+					}
+					for _, backendLevel := range []string{"0", "2"} {
+						t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, input, "-O"+backendLevel)
+						})
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_string_compare_test.go b/x86_result_string_compare_test.go
new file mode 100644
index 000000000..7959c27c9
--- /dev/null
+++ b/x86_result_string_compare_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86StringCompareResultBody(arch, opcode, prefix, direction string, flags bool) string {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	body := fmt.Sprintf("%s left+0(FP),SI\n%s right+%d(FP),DI\n%s n+%d(FP),CX\n%s needle+%d(FP),AX\n%s\n",
+		move, move, word, move, 2*word, move, 3*word, direction)
+	if prefix != "" {
+		body += prefix + "\n"
+	}
+	body += opcode + "\n"
+	if flags {
+		body += "MOVL $0,BX\nSETEQ BL\n" + move + " BX,ret+RESULT(FP)"
+	} else {
+		body += move + " CX,ret+RESULT(FP)"
+	}
+	return body
+}
+
+func x86StringCompareCompleteSource(t *testing.T, arch string) (string, string) {
+	t.Helper()
+	const declaration = "func view(left,right *byte,n,needle uintptr) uintptr"
+	var source, declarations strings.Builder
+	for _, stem := range []string{"SCAS", "CMPS"} {
+		widths := "BWLQ"
+		if arch == "386" {
+			widths = "BWL"
+		}
+		for _, width := range widths {
+			for index, prefix := range []string{"", "REP", "REPN"} {
+				for _, direction := range []string{"CLD", "STD"} {
+					body := x86StringCompareResultBody(arch, stem+string(width), prefix, direction, prefix == "")
+					text := x86ResultGPSIMDAdmissionSource(t, arch, declaration, body)
+					name := fmt.Sprintf("view%s%c%d%s", stem, width, index, direction)
+					source.WriteString(strings.Replace(text, "·view(SB)", "·"+name+"(SB)", 1))
+					declarations.WriteString(strings.Replace(declaration, "view(", name+"(", 1) + "\n")
+				}
+			}
+		}
+	}
+	want := 48
+	if arch == "386" {
+		want = 36
+	}
+	if strings.Count(source.String(), "TEXT ") != want || strings.Count(declarations.String(), "func ") != want {
+		t.Fatal("complete independent SCAS/CMPS source inventory changed")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86StringCompareCompleteGoObjects(t *testing.T) {
+	for _, target := range dataRelocationTargets {
+		if target.arch != ArchAMD64 {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			source, _ := x86StringCompareCompleteSource(t, target.goarch)
+			dataRelocationGoObject(t, source, target.goos, target.goarch, true)
+		})
+	}
+}
+
+func TestX86StringCompareConditionalFactsRequireWholeSource(t *testing.T) {
+	const declaration = "func view(left,right *byte,n,needle uintptr) uintptr"
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range []struct {
+			name string
+			edit func(string) string
+		}{
+			{"missing-result", func(body string) string { return strings.Replace(body, "CX,ret+RESULT(FP)", "CX,BX", 1) }},
+			{"missing-needle", func(body string) string {
+				return strings.Replace(body, fmt.Sprintf("%s needle+%d(FP),AX\n", move, 3*word), "", 1)
+			}},
+			{"not-a-pointer", func(body string) string {
+				return strings.Replace(body, fmt.Sprintf("%s right+%d(FP),DI", move, word), fmt.Sprintf("%s n+%d(FP),DI", move, 2*word), 1)
+			}},
+			{"partial-zero", func(string) string { return "MOVW $0,CX\nREP\nSCASB\n" + move + " $7,ret+RESULT(FP)" }},
+			{"overwritten-zero", func(string) string { return "MOVL $0,CX\nMOVB $1,CL\nREP\nSCASB\n" + move + " $7,ret+RESULT(FP)" }},
+			{"zero-cannot-define-ZF", func(string) string {
+				return "MOVL $0,CX\nREP\nSCASB\nMOVL $0,BX\nSETEQ BL\n" + move + " BX,ret+RESULT(FP)"
+			}},
+			{"zero-cannot-define-DF", func(body string) string {
+				return "MOVL $0,CX\nREP\nSCASB\n" + strings.Replace(body, "CLD\n", "", 1)
+			}},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					body := row.edit(x86StringCompareResultBody(target.arch, "SCASB", "REPN", "CLD", false))
+					source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err == nil || ir != "" {
+						t.Fatal("conditional continuation manufactured a missing input, result or status fact", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86StringCompareNumericalContinuationThreeAPIs(t *testing.T) {
+	const declaration = "func view(left,right *byte,n,needle uintptr) uintptr"
+	for _, target := range x86RawReturnTargets {
+		for _, stem := range []string{"SCAS", "CMPS"} {
+			widths := "BWLQ"
+			if target.arch == "386" {
+				widths = "BWL"
+			}
+			for _, width := range widths {
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					for _, direction := range []string{"CLD", "STD"} {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(fmt.Sprintf("%s/%s%c/%s/%s/%s", target.triple, stem, width, prefix, direction, api), func(t *testing.T) {
+								body := x86StringCompareResultBody(target.arch, stem+string(width), prefix, direction, prefix == "")
+								source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+								if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); err != nil || ir == "" {
+									t.Fatal("complete comparison/count result rejected", err)
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringCompareZeroCountPreservesOriginalFlags(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, flags := range []bool{false, true} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/flags%t/%s", target.triple, prefix, flags, api), func(t *testing.T) {
+						// With zero iterations neither a source pointer, an
+						// accumulator value nor incoming DF is observed.
+						body := "MOVL $0,CX\n"
+						if flags {
+							body += "CMPL AX,AX\n"
+						}
+						body += prefix + "\nSCASB\n"
+						if flags {
+							body += "MOVL $0,BX\nSETEQ BL\n" + move + " BX,ret+RESULT(FP)"
+						} else {
+							body += move + " CX,ret+RESULT(FP)"
+						}
+						source := x86ResultGPSIMDAdmissionSource(t, target.arch, "func view() uintptr", body)
+						if ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uintptr", target.arch, target.triple, api); err != nil || ir == "" {
+							t.Fatal("zero-count comparison changed FLAGS or observed an unused input", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringCompareCannotInventIncomingFlagsOrDirection(t *testing.T) {
+	const declaration = "func view(left,right *byte,n,needle uintptr) uintptr"
+	for _, target := range x86RawReturnTargets {
+		for _, role := range []string{"unknown DF", "unknown initial ZF", "partial counter", "skipped prefix"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+role+"/"+api, func(t *testing.T) {
+					body := x86StringCompareResultBody(target.arch, "SCASB", "REPN", "CLD", false)
+					switch role {
+					case "unknown DF":
+						body = strings.Replace(body, "CLD\n", "", 1)
+					case "unknown initial ZF":
+						body = x86StringCompareResultBody(target.arch, "SCASB", "REP", "CLD", true)
+					case "partial counter":
+						// A low16 zero is not a full native count of zero.
+						move := "MOVQ"
+						if target.arch == "386" {
+							move = "MOVL"
+						}
+						body = "MOVW $0,CX\nREPN\nSCASB\n" + move + " CX,ret+RESULT(FP)"
+					case "skipped prefix":
+						body = strings.Replace(body, "REPN\nSCASB", "CMPL AX,AX\nJE body\nREPN\nbody:\nSCASB", 1)
+					}
+					source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("comparison fabricated an unproved status, count, direction or prefix", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_result_string_load_store_test.go b/x86_result_string_load_store_test.go
new file mode 100644
index 000000000..1426facc5
--- /dev/null
+++ b/x86_result_string_load_store_test.go
@@ -0,0 +1,145 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent sibling inventory: MOVS/STOS/LODS share the existing twenty
+// Go ynone rows, but not the comparison family's FLAGS or conditional exit.
+func TestX86StringLoadStorePairedEffectsCompleteFamily(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := "BWLQ"
+		if arch == "386" {
+			widths = "BWL"
+		}
+		for _, stem := range []string{"MOVS", "STOS", "LODS"} {
+			for index, suffix := range widths {
+				width := []int{1, 2, 4, 8}[index]
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					for _, count := range []x86ResultStringCount{x86StringCountUnknown, x86StringCountZero, x86StringCountNonzero} {
+						for _, direction := range []x86ResultDirection{x86ResultDirectionForward, x86ResultDirectionBackward, x86ResultDirectionEither} {
+							t.Run(fmt.Sprintf("%s/%s%c/%s/count%d/DF%d", arch, stem, suffix, prefix, count, direction), func(t *testing.T) {
+								source := "TEXT strings(SB),4,$0-0\n"
+								if prefix != "" {
+									source += prefix + "\n"
+								}
+								file, err := Parse(ArchAMD64, source+stem+string(suffix)+"\nRET\n")
+								if err != nil {
+									t.Fatal(err)
+								}
+								plan, err := x86ResultStringMemorySourcePlan(file.Funcs[0], arch)
+								if err != nil || plan == nil || len(plan.bodies) != 1 {
+									t.Fatal("shared typed string grammar omitted the complete load/store sibling", err)
+								}
+								for ordinal, site := range plan.bodies {
+									state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagAF, direction: direction, stringCount: count}
+									state.gp[0], state.gp[1], state.gp[3] = 0xff, 0xff, 0x55
+									if stem == "LODS" {
+										state.gp[0] = 0xf0 // Unspecified accumulator low bytes stay unspecified on count0.
+									}
+									state.canonicalGP[0] = 0xa0
+									for _, register := range []int{6, 7} {
+										state.pointerGP[register], state.callerAddressGP[register] = true, true
+										state.callerAddressOrigin[register] = uint16(register + 1)
+									}
+									expected := state.clone()
+									if prefix == "" || count != x86StringCountZero {
+										indexes := []int{7}
+										if stem == "LODS" {
+											indexes = []int{6}
+											mask := uint8((uint16(1) << uint(width)) - 1)
+											if prefix == "" || count == x86StringCountNonzero {
+												expected.gp[0] |= mask
+											}
+											expected.canonicalGP[0] &^= mask
+											if width == 4 && (prefix == "" || count == x86StringCountNonzero) {
+												expected.gp[0] |= 0xf0
+												expected.canonicalGP[0] |= 0xf0
+											}
+										} else if stem == "MOVS" {
+											indexes = append(indexes, 6)
+										}
+										for _, register := range indexes {
+											expected.pointerGP[register] = false
+										}
+										if prefix != "" {
+											// Unlike SCAS/CMPS, every completed repeated transfer
+											// consumes the entire counter; no predicate exits early.
+											expected.gp[1], expected.canonicalGP[1] = 0xff, 0xff
+											expected.stringCount = x86StringCountZero
+										}
+									}
+									if accepted, known := plan.transfer(ordinal, site.instruction, &state, arch); !accepted || !known || !reflect.DeepEqual(state, expected) {
+										t.Fatal("native transfer lost conditional bytes, zero counter or independent FLAGS/DF", accepted, known)
+									}
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// Each operation owns at most 48 functions, below the existing 64-function
+// object batch bound. The independent effect matrix above owns sparse-byte,
+// count and direction semantics; these are actual initialized public entries.
+func TestX86StringLoadStoreInitializedFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move, widths := 8, "MOVQ", "BWLQ"
+		if target.arch == "386" {
+			word, move, widths = 4, "MOVL", "BWL"
+		}
+		for _, stem := range []string{"MOVS", "STOS", "LODS"} {
+			t.Run(target.triple+"/"+stem, func(t *testing.T) {
+				var source, declaration strings.Builder
+				count := 0
+				for _, suffix := range widths {
+					for _, prefix := range []string{"", "REP", "REPN"} {
+						for _, iterations := range []int{0, 3} {
+							for _, backward := range []bool{false, true} {
+								name := fmt.Sprintf("%s%c_%s_%d_%t", stem, suffix, prefix, iterations, backward)
+								fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s src+0(FP),SI\n%s dst+%d(FP),DI\n%s value+%d(FP),AX\n%s $%d,CX\n",
+									name, 4*word, move, move, word, move, 2*word, move, iterations)
+								if backward {
+									source.WriteString("STD\n")
+								} else {
+									source.WriteString("CLD\n")
+								}
+								if prefix != "" {
+									source.WriteString(prefix + "\n")
+								}
+								fmt.Fprintf(&source, "%s%c\nCLD\n%s AX,ret+%d(FP)\nRET\n", stem, suffix, move, 3*word)
+								fmt.Fprintf(&declaration, "func %s(src,dst *byte,value uintptr) uintptr\n", name)
+								count++
+							}
+						}
+					}
+				}
+				if count != len(widths)*12 || count > 64 {
+					t.Fatal("complete independent string object inventory changed", count)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declaration.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized string sibling lost its complete source proof", api, err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_string_memory.go b/x86_result_string_memory.go
new file mode 100644
index 000000000..cef4a209e
--- /dev/null
+++ b/x86_result_string_memory.go
@@ -0,0 +1,288 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// These are facts about the full native repeat counter, not numerical bytes
+// or an entry convention. Partial writes cannot establish either fact.
+type x86ResultStringCount uint8
+
+const (
+	x86StringCountUnknown x86ResultStringCount = iota
+	x86StringCountZero
+	x86StringCountNonzero
+)
+
+type x86ResultStringMemorySite struct {
+	instruction Instr
+	prefix      string
+}
+
+type x86ResultStringMemoryPlan struct {
+	prefixes map[int]Instr
+	bodies   map[int]x86ResultStringMemorySite
+}
+
+// Bind the complete original source before the result proof. The exact same
+// CFG verifier runs again at emission; a lexical prefix cannot stand in for
+// an incoming edge which bypasses its source node.
+func x86ResultStringMemorySourcePlan(fn Func, arch string) (*x86ResultStringMemoryPlan, error) {
+	hasStrings := false
+	for _, ins := range fn.Instrs {
+		if _, known, _ := x86StringInstructionProperties(ins, arch); known {
+			hasStrings = true
+			break
+		}
+	}
+	if !hasStrings {
+		return nil, nil
+	}
+	fail := func(reason string) error {
+		return fmt.Errorf("%w: string instruction needs its original source CFG: %s", ErrProbeNeedsContext, reason)
+	}
+	if fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil {
+		return nil, fail("another source-graph role cannot supply prefix ordinals")
+	}
+	context := amd64Ctx{goarch: arch, blocks: amd64SplitBlocks(fn), blockByIdx: make(map[int]int)}
+	base := 0
+	for index, block := range context.blocks {
+		context.blockBase = append(context.blockBase, base)
+		context.blockByIdx[base] = index
+		base += len(block.instrs)
+	}
+	pairs, err := context.stringRepeatSourceBindings()
+	if err != nil {
+		return nil, err
+	}
+	var ordinals []int
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op != OpLABEL {
+			ordinals = append(ordinals, ordinal)
+		}
+	}
+	positions := make([][]int, len(context.blocks))
+	plan := &x86ResultStringMemoryPlan{prefixes: make(map[int]Instr), bodies: make(map[int]x86ResultStringMemorySite)}
+	at := 0
+	for block, body := range context.blocks {
+		for _, ins := range body.instrs {
+			if at >= len(ordinals) || !reflect.DeepEqual(ins, fn.Instrs[ordinals[at]]) {
+				return nil, fail("split source changed an instruction identity")
+			}
+			ordinal := ordinals[at]
+			positions[block] = append(positions[block], ordinal)
+			if _, known, err := x86StringInstructionProperties(ins, arch); known {
+				if err != nil || !x86ResultNamedPredicateInstruction(ins) {
+					return nil, fail("unbound string instruction shape")
+				}
+				plan.bodies[ordinal] = x86ResultStringMemorySite{instruction: ins}
+			}
+			at++
+		}
+	}
+	if at != len(ordinals) {
+		return nil, fail("incomplete original instruction inventory")
+	}
+	for _, pair := range pairs {
+		prefixOrdinal := positions[pair.prefixBlock][pair.prefixInstruction]
+		bodyOrdinal := positions[pair.bodyBlock][pair.bodyInstruction]
+		if body, participant := plan.bodies[bodyOrdinal]; participant {
+			prefix := fn.Instrs[prefixOrdinal]
+			if !x86ResultNamedPredicateInstruction(prefix) {
+				return nil, fail("unbound repeat prefix")
+			}
+			body.prefix = strings.ToUpper(string(prefix.Op))
+			plan.prefixes[prefixOrdinal], plan.bodies[bodyOrdinal] = prefix, body
+		}
+	}
+	return plan, nil
+}
+
+// This is the numerical continuation of the existing exact volatile helper,
+// not a readable region, extent, pointer-to-number conversion or native-entry
+// capability. An unsuccessful native access still faults in the paired emitter.
+func (plan *x86ResultStringMemoryPlan) transfer(ordinal int, ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	if plan == nil {
+		return false, false
+	}
+	if prefix, bound := plan.prefixes[ordinal]; bound {
+		return state != nil && reflect.DeepEqual(prefix, ins), true
+	}
+	form, known, err := x86StringInstructionProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	site, bound := plan.bodies[ordinal]
+	if err != nil || state == nil || !bound || !reflect.DeepEqual(site.instruction, ins) || !x86ResultNamedPredicateInstruction(ins) {
+		return false, true
+	}
+	if state.shapeOnly {
+		return true, true // Complete shape only; never a reaching input fact.
+	}
+	repeat := site.prefix != ""
+	word := x86ResultPointerWord(arch)
+	if repeat {
+		if !x86ResultRead(Operand{Kind: OpReg, Reg: CX}, word, state, nil, arch) {
+			return false, true
+		}
+		if state.stringCount == x86StringCountZero {
+			return true, true // No read, index update, comparison or DF observation.
+		}
+	}
+	if state.direction == x86ResultDirectionUnknown {
+		return false, true
+	}
+	indexes := []Reg{DI}
+	if form.kind == "lods" {
+		indexes = []Reg{SI}
+	} else if form.kind == "cmps" || form.kind == "movs" {
+		indexes = append(indexes, SI)
+	} else if !x86ResultRead(Operand{Kind: OpReg, Reg: AX}, int64(form.width), state, nil, arch) {
+		return false, true
+	}
+	for _, index := range indexes {
+		if !x86ResultIncomingPointerReadAddressIdentity(Operand{Kind: OpMem, Mem: MemRef{Base: index}}, state, arch) {
+			return false, true
+		}
+	}
+	for _, register := range indexes {
+		index, _, _ := x86ResultGP(register, word, arch)
+		state.gp[index], state.canonicalGP[index] = 0, 0
+		// The cursor is no longer the original native-read base. Its full
+		// address bits remain initialized and derived from the same actual
+		// entry, without acquiring NUM bytes or reusable memory permission.
+		state.pointerGP[index] = false
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+	}
+	comparison := form.kind == "scas" || form.kind == "cmps"
+	if comparison && (!repeat || state.stringCount == x86StringCountNonzero) {
+		state.flags = x86ByteFlagsAll
+	} // Otherwise the possible zero path retains only the old six must-bits.
+	if form.kind == "lods" {
+		mask := uint8((uint16(1) << uint(form.width)) - 1)
+		state.canonicalGP[0] &^= mask
+		if !repeat || state.stringCount == x86StringCountNonzero {
+			state.gp[0] |= mask
+			if form.width == 4 {
+				state.gp[0] |= 0xf0
+				state.canonicalGP[0] |= 0xf0
+			}
+		}
+		// A possible zero path retains only old numerical byte knowledge.
+		// A possible read cannot retain any old AX address identity.
+		state.pointerGP[0], state.callerAddressGP[0], state.callerAddressOrigin[0] = false, false, 0
+		state.resultAddressGP[0] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[0] = x86ResultSlotAddress{}
+		}
+	}
+	if repeat {
+		if !x86ResultStore(Operand{Kind: OpReg, Reg: CX}, word, state, nil, 0, arch) {
+			return false, true
+		}
+		state.canonicalGP[1] = 0
+		if arch == "386" {
+			state.canonicalGP[1] = 0xf0
+		}
+		state.callerAddressGP[1], state.callerAddressOrigin[1] = false, 0
+		state.resultAddressGP[1] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[1] = x86ResultSlotAddress{}
+		}
+		state.stringCount = x86StringCountUnknown
+		if !comparison {
+			state.canonicalGP[1] = 0xff
+			state.stringCount = x86StringCountZero
+		}
+	}
+	return true, true
+}
+
+// Observe only independently accepted typed transfers. The single native
+// counter fact is revoked by any overlapping write, unknown effect or CALL;
+// clone/join and the existing shared work budget account for it separately.
+func x86ResultStringCountAfter(ins Instr, before, current x86ResultStringCount, arch string) x86ResultStringCount {
+	if x86PreservesNumericalSourceState(ins) {
+		return before
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.Op == OpCALL {
+		return x86StringCountUnknown
+	}
+	if _, known, err := x86StringInstructionProperties(ins, arch); known {
+		if err == nil {
+			return current
+		}
+		return x86StringCountUnknown
+	}
+	if (ins.Op == "REP" || ins.Op == "REPN") && len(ins.Args) == 0 {
+		return before // Only the independently bound source transfer accepts it.
+	}
+	ins = x86SourceMoveInstruction(ins, arch)
+	word := x86ResultPointerWord(arch)
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 && len(ins.Args) == 2 {
+		if ins.Args[1].Kind != OpReg {
+			return before
+		}
+		destination, _, valid := x86ResultGP(ins.Args[1].Reg, width, arch)
+		if !valid {
+			return x86StringCountUnknown
+		}
+		if destination != 1 {
+			return before
+		}
+		first := ins.Args[0]
+		if width >= word || arch == "amd64" && width == 4 {
+			if first.Kind == OpImm && first.ImmRaw == "" && !first.ImmIsFloat {
+				value := uint64(first.Imm)
+				if width == 4 {
+					value = uint64(uint32(value))
+				}
+				if value == 0 {
+					return x86StringCountZero
+				}
+				return x86StringCountNonzero
+			}
+		}
+		return x86StringCountUnknown
+	}
+	if form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch); known && err == nil {
+		width := int64(form.spec.bits / 8)
+		if form.destination.Kind == OpReg {
+			index, _, valid := x86ResultGP(form.destination.Reg, width, arch)
+			if valid && index == 1 && (width >= word || arch == "amd64" && width == 4) && x86ScalarXORZeroRegister(form, width) {
+				return x86StringCountZero
+			}
+		}
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+		if err != nil {
+			return x86StringCountUnknown
+		}
+		for _, operand := range effect.operands {
+			if operand.write && operand.operand.Kind == OpReg {
+				if index, _, valid := x86ResultGP(operand.operand.Reg, operand.width, arch); !valid || index == 1 {
+					return x86StringCountUnknown
+				}
+			}
+		}
+		return before
+	}
+	if _, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil {
+		return before
+	}
+	if _, known, err := x86DirectionControlProperties(ins.Op, ins, arch); known && err == nil {
+		return before
+	}
+	if _, known, err := x86DirectiveProperties(ins); known && err == nil {
+		return before
+	}
+	if ins.Op == OpTEXT || ins.Op == OpLABEL || ins.Op == OpJMP || isAMD64ConditionalBranch(ins.Op) || ins.Op == "NOP" {
+		return before
+	}
+	return x86StringCountUnknown
+}
diff --git a/x86_result_swap.go b/x86_result_swap.go
new file mode 100644
index 000000000..e65e72fe9
--- /dev/null
+++ b/x86_result_swap.go
@@ -0,0 +1,47 @@
+package plan9asm
+
+// x86ResultSwapStep shares the existing Go exchange grammar between result
+// observers, but admits only register/register byte effects. Memory exchanges
+// still need their independent FP, AUTO, native or caller authority.
+func x86ResultSwapStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	form, width, known, err := x86SwapProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || form.register.Kind != OpReg || form.other.Kind != OpReg {
+		return false, true
+	}
+	if form.nop {
+		return true, true // Preserve even undefined bytes and opaque identities.
+	}
+	first, firstMask, firstValid := x86ResultGP(form.register.Reg, width, arch)
+	last, lastMask, lastValid := x86ResultGP(form.other.Reg, width, arch)
+	if !firstValid || !lastValid {
+		return false, true
+	}
+	// Snapshot both required reads before either write. Opaque identities are
+	// transferable only at the complete pointer width, never as numeric bytes.
+	read := func(index int, mask uint8) (opaque, valid bool) {
+		if state.gp[index]&mask == mask {
+			return false, true
+		}
+		return true, width == x86ResultPointerWord(arch) && state.pointerGP[index]
+	}
+	firstOpaque, firstRead := read(first, firstMask)
+	lastOpaque, lastRead := read(last, lastMask)
+	if !firstRead || !lastRead {
+		return false, true
+	}
+	write := func(operand Operand, index int, opaque bool) {
+		if opaque {
+			state.pointerGP[index], state.gp[index] = true, 0
+		} else {
+			// The register views were validated above; retain the existing
+			// partial-write and genuine r32/r64 zero-extension byte effects.
+			x86ResultStore(operand, width, state, nil, 0, arch)
+		}
+	}
+	write(form.register, first, lastOpaque)
+	write(form.other, last, firstOpaque)
+	return true, true // XCHG preserves every flag and all other state domains.
+}
diff --git a/x86_result_swap_objects_test.go b/x86_result_swap_objects_test.go
new file mode 100644
index 000000000..25f777523
--- /dev/null
+++ b/x86_result_swap_objects_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86ResultSwapTranslateAPI(t *testing.T, api, source string, pkg GoPackage, arch, triple string) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	sig, err := DeriveGoFuncABI0Signature("Value", pkg.Types.Scope().Lookup("Value").(*types.Func), arch, types.SizesFor("gc", arch))
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"Value": sig},
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "module" {
+		module, err := TranslateModuleInContext(ctx, file, options)
+		if !module.IsNil() {
+			defer module.Dispose()
+		}
+		if err != nil {
+			return "", err
+		}
+		return module.String(), nil
+	}
+	if api != "Go" {
+		t.Fatal("unknown translation API", api)
+	}
+	result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		GOARCH: arch, TargetTriple: triple, ResolveSym: options.ResolveSym})
+	if result != nil && !result.Module.IsNil() {
+		defer result.Module.Dispose()
+	}
+	if err != nil {
+		return "", err
+	}
+	return result.Module.String(), nil
+}
+
+func TestX86ResultSwapThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			body := fmt.Sprintf("%s x+0(FP),AX\n%s y+%d(FP),BX\n", move, move, word) +
+				"XCHGB AH,AL\nXCHGB AL,AH\nXCHGB AX,BL\nXCHGW AX,BX\nXCHGW AX,AX\nXCHGL AX,BX\nXCHGL BX,BX\nXCHGL AX,AX\n"
+			if target.arch == "amd64" {
+				body += "MOVQ $42,R11\nMOVQ $43,R12\nXCHGB R11B,R12\nXCHGW R11,R12\nXCHGL R11,R12\nXCHGQ R11,R12\nXCHGQ AX,BX\nXCHGQ AX,AX\n"
+			}
+			body += fmt.Sprintf("%s AX,X0\nVPEXTRQ $0,X0,BX\n%s BX,ret0+%d(FP)\nRET", move, move, 2*word)
+			pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x,y "+typ+") "+typ, body)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, target.arch); err != nil {
+					t.Fatal("whole-source swap scalar result proof", err)
+				}
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ResultSwapTranslateAPI(t, api, source, pkg, target.arch, target.triple)
+					if err != nil {
+						t.Fatal(err)
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, "register-swap-"+api)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_result_swap_runtime_test.go b/x86_result_swap_runtime_test.go
new file mode 100644
index 000000000..35f0e7113
--- /dev/null
+++ b/x86_result_swap_runtime_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86SwapNumericalCase struct {
+	row, setup, capture      string
+	width, first, last, a, b int
+	nop                      bool
+}
+
+// Independent numerical directory. first/last select logical output words,
+// a/b select byte offsets. All payloads are snapshotted before either write.
+var x86SwapNumericalCases = []x86SwapNumericalCase{
+	{row: "XCHGB AH,AL", width: 1, a: 1},
+	{row: "XCHGB AL,AH", width: 1, b: 1},
+	{row: "XCHGB AL,BL", width: 1, last: 1},
+	{row: "XCHGB AX,BX", width: 1, last: 1},
+	{row: "XCHGB AX,AL", width: 1},
+	{row: "XCHGW AX,BX", width: 2, last: 1},
+	{row: "XCHGW AX,AX", width: 2, nop: true},
+	{row: "XCHGL AX,BX", width: 4, last: 1},
+	{row: "XCHGL BX,BX", width: 4, first: 1, last: 1},
+	{row: "XCHGL AX,AX", width: 4, nop: true},
+	{row: "XCHGQ AX,BX", width: 8, last: 1},
+	{row: "XCHGQ AX,AX", width: 8, nop: true},
+	{row: "XCHGB R11B,R12", setup: "MOVQ AX,R11\nMOVQ BX,R12\n", capture: "MOVQ R11,AX\nMOVQ R12,BX\n", width: 1, last: 1},
+	{row: "XCHGW R11,R12", setup: "MOVQ AX,R11\nMOVQ BX,R12\n", capture: "MOVQ R11,AX\nMOVQ R12,BX\n", width: 2, last: 1},
+	{row: "XCHGL R11,R12", setup: "MOVQ AX,R11\nMOVQ BX,R12\n", capture: "MOVQ R11,AX\nMOVQ R12,BX\n", width: 4, last: 1},
+	{row: "XCHGQ R11,R12", setup: "MOVQ AX,R11\nMOVQ BX,R12\n", capture: "MOVQ R11,AX\nMOVQ R12,BX\n", width: 8, last: 1},
+	{row: "XCHGB CL,CH", setup: "MOVQ AX,CX\nMOVQ BX,DX\n", capture: "MOVQ CX,AX\nMOVQ DX,BX\n", width: 1, b: 1},
+	{row: "XCHGB SIB,DIB", setup: "MOVQ AX,SI\nMOVQ BX,DI\n", capture: "MOVQ SI,AX\nMOVQ DI,BX\n", width: 1, last: 1},
+}
+
+func x86SwapNumericalSource() (declarations, assembly, names, metadata string) {
+	var decl, source, functions, rows strings.Builder
+	for index, test := range x86SwapNumericalCases {
+		name := fmt.Sprint("swap", index)
+		fmt.Fprintf(&decl, "func %s(out *[64]byte,x,y uint64)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-24\nMOVQ out+0(FP),R10\nMOVQ x+8(FP),AX\nMOVQ y+16(FP),BX\nSTMXCSR 24(R10)\nCMPQ AX,BX\n%s%s\n%s", name, test.setup, test.row, test.capture)
+		// A memory address through R10 requires REX, which would turn an AH
+		// spelling into SPL. Capture the actual high byte before that store.
+		source.WriteString("MOVQ AX,0(R10)\nMOVQ BX,8(R10)\nSETCS 16(R10)\nSETEQ 17(R10)\nSETMI 18(R10)\nSETOS 19(R10)\nLAHF\nMOVB AH,CL\nMOVB CL,20(R10)\nSTMXCSR 28(R10)\nRET\n")
+		fmt.Fprintf(&functions, "%s,", name)
+		fmt.Fprintf(&rows, "{%d,%d,%d,%d,%d,%t},\n", test.width, test.first, test.last, test.a, test.b, test.nop)
+	}
+	return decl.String(), source.String(), functions.String(), rows.String()
+}
+
+func TestX86ResultSwapOriginalGoNumericalCanariesAndFlags(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declaration, source, functions, metadata := x86SwapNumericalSource()
+	// The shared original-Go producer owns compiler/executable process groups.
+	// This helper executes first-party source only, not a discovered library.
+	driver := strings.ReplaceAll(x86SwapOriginalGoDriver, "FUNCTIONS", functions)
+	driver = strings.ReplaceAll(driver, "METADATA", metadata)
+	x86WordMultiplyRunOriginalGo(t, execution, "package wordmultiply\n"+declaration, source, driver)
+	t.Log("Original Go: 18 kernels ×49 inputs, complete output/input guards and flags/MXCSR. Rosetta is not native Linux.")
+}
+
+func TestX86ResultSwapLLVMNumericalCanariesAndFlags(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declaration, source, _, _ := x86SwapNumericalSource()
+	var prototypes, rows strings.Builder
+	for index, test := range x86SwapNumericalCases {
+		fmt.Fprintf(&prototypes, "extern void swap%d(uint8_t*,uint64_t,uint64_t);\n", index)
+		fmt.Fprintf(&rows, "{swap%d,%d,%d,%d,%d,%d,%d},\n", index, test.width, test.first, test.last, test.a, test.b, x86FloatAddSubBoolInt(test.nop))
+	}
+	main := strings.ReplaceAll(x86SwapLLVMDriver, "PROTOTYPES", prototypes.String())
+	main = strings.ReplaceAll(main, "ROWS", rows.String())
+	ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, optimized := range []bool{false, true} {
+		t.Run(fmt.Sprintf("IR_default_O2=%t", optimized), func(t *testing.T) {
+			text := ir
+			if optimized {
+				text = x86MulDivRoundOptimize(t, text)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run("backend"+level, func(t *testing.T) {
+					output := execution.compileAndRunLLVM(t, "register-swap", text, main, level)
+					if string(output) != "LLVM_SWAP_882_NUMERICAL_CANARY_FLAGS_MXCSR_PASS\n" {
+						t.Fatalf("complete numerical result missing: %s", output)
+					}
+				})
+			}
+		})
+	}
+	t.Log("18 kernels ×49 inputs, complete output/input guards and flags/MXCSR; IR default<O2> and backend O0/O2 are separate axes. Rosetta is not native Linux.")
+}
+
+const x86SwapOriginalGoDriver = `package wordmultiply
+import (
+ "encoding/binary"
+ "fmt"
+ "math/bits"
+ "testing"
+ "unsafe"
+)
+func TestOriginal(t *testing.T) {
+ functions:=[]func(*[64]byte,uint64,uint64){FUNCTIONS}
+ metadata:=[]struct {width,first,last,a,b int; nop bool}{METADATA}
+ samples:=[]uint64{0,1,0xffffffffffffffff,0x8000000000000000,0x0123456789abcdef,0xfedcba9876543210,0x8877665544332211}
+ observations:=0
+ for k,program:=range functions {
+  rule:=metadata[k]
+  for _,x:=range samples {
+   for _,y:=range samples {
+    var packet,want [80]byte
+    for i:=range packet {packet[i]=byte(i*37+91)}
+    want=packet
+    values:=[2]uint64{x,y}
+    mask:=uint64(^uint64(0))
+    if rule.width<8 {mask=(uint64(1)<<uint(rule.width*8))-1}
+    if !rule.nop {
+     a,b:=(values[rule.first]>>uint(rule.a*8))&mask,(values[rule.last]>>uint(rule.b*8))&mask
+     values[rule.first]=(values[rule.first]&^(mask<<uint(rule.a*8)))|(b<<uint(rule.a*8))
+     values[rule.last]=(values[rule.last]&^(mask<<uint(rule.b*8)))|(a<<uint(rule.b*8))
+     if rule.width==4 {values[rule.first]&=0xffffffff;values[rule.last]&=0xffffffff}
+    }
+    binary.LittleEndian.PutUint64(want[8:16],values[0])
+    binary.LittleEndian.PutUint64(want[16:24],values[1])
+    difference:=x-y
+    flag:=func(value bool)byte {if value{return 1};return 0}
+    cf,zf,sf,of,pf,af:=flag(x<y),flag(x==y),flag(difference>>63!=0),flag(((x^y)&(x^difference))>>63!=0),flag(bits.OnesCount8(byte(difference))%2==0),flag((x^y^difference)&16!=0)
+    want[24],want[25],want[26],want[27]=cf,zf,sf,of
+    want[28]=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7)
+    // Numerical first-party transport; not a caller-memory proof producer.
+    out:=(*[64]byte)(unsafe.Pointer(&packet[8]))
+    program(out,x,y)
+    before,after:=binary.LittleEndian.Uint32(packet[32:36]),binary.LittleEndian.Uint32(packet[36:40])
+    if before!=after {t.Fatalf("kernel%d changed MXCSR %x ->%x",k,before,after)}
+    copy(want[32:40],packet[32:40])
+    if packet!=want {t.Fatalf("kernel%d x%x y%x got%x want%x",k,x,y,packet,want)}
+    observations++
+   }
+  }
+ }
+ if observations!=882 {t.Fatalf("incomplete numerical denominator %d",observations)}
+ fmt.Println("ORIGINAL_SWAP_882_NUMERICAL_CANARY_FLAGS_MXCSR_PASS")
+}
+`
+
+const x86SwapLLVMDriver = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+typedef struct { void (*program)(uint8_t*,uint64_t,uint64_t); unsigned width,first,last,a,b,nop; } rule;
+static const rule rules[]={ROWS};
+int main(void) {
+ const uint64_t samples[]={0,1,UINT64_MAX,UINT64_C(0x8000000000000000),UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(0x8877665544332211)};
+ unsigned observations=0;
+ for(unsigned k=0;k<sizeof(rules)/sizeof(rules[0]);k++) {
+  const rule r=rules[k];
+  for(unsigned i=0;i<7;i++) for(unsigned j=0;j<7;j++) {
+   uint64_t x=samples[i],y=samples[j],values[2]={x,y};
+   uint8_t packet[80],want[80];
+   for(unsigned n=0;n<80;n++) packet[n]=(uint8_t)(n*37+91);
+   memcpy(want,packet,80);
+   uint64_t mask=r.width==8?UINT64_MAX:(UINT64_C(1)<<(r.width*8))-1;
+   if(!r.nop) {
+    const uint64_t a=(values[r.first]>>(r.a*8))&mask,b=(values[r.last]>>(r.b*8))&mask;
+    values[r.first]=(values[r.first]&~(mask<<(r.a*8)))|(b<<(r.a*8));
+    values[r.last]=(values[r.last]&~(mask<<(r.b*8)))|(a<<(r.b*8));
+    if(r.width==4) {values[r.first]&=UINT32_MAX;values[r.last]&=UINT32_MAX;}
+   }
+   memcpy(want+8,values,16);
+   uint64_t d=x-y;
+   uint8_t cf=x<y,zf=x==y,sf=d>>63,of=((x^y)&(x^d))>>63;
+   uint8_t pf=(__builtin_popcount((unsigned)(uint8_t)d)&1)==0,af=((x^y^d)&16)!=0;
+   want[24]=cf;want[25]=zf;want[26]=sf;want[27]=of;
+   want[28]=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7);
+   uint32_t csr0,csr1;
+   __asm__ volatile("stmxcsr %0":"=m"(csr0));
+   r.program(packet+8,x,y);
+   __asm__ volatile("stmxcsr %0":"=m"(csr1));
+   uint32_t before,after;
+   memcpy(&before,packet+32,4);memcpy(&after,packet+36,4);
+   if(before!=csr0||after!=csr0||csr1!=csr0) {fprintf(stderr,"kernel%u MXCSR changed\n",k);return 1;}
+   memcpy(want+32,packet+32,8);
+   if(memcmp(packet,want,80)) {
+    for(unsigned n=0;n<80;n++) if(packet[n]!=want[n]) fprintf(stderr,"kernel%u input%u,%u byte%u got%x want%x\n",k,i,j,n,packet[n],want[n]);
+    return 1;
+   }
+   observations++;
+  }
+ }
+ if(observations!=882) {fprintf(stderr,"incomplete denominator %u\n",observations);return 1;}
+ puts("LLVM_SWAP_882_NUMERICAL_CANARY_FLAGS_MXCSR_PASS");return 0;
+}
+`
diff --git a/x86_result_swap_test.go b/x86_result_swap_test.go
new file mode 100644
index 000000000..45d471046
--- /dev/null
+++ b/x86_result_swap_test.go
@@ -0,0 +1,402 @@
+package plan9asm
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultSwapCompleteOriginalEncoderDirectory(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{AXCHGB, yml_mb, Pb, opBytes{0x86, 0x86}}",
+		"{AXCHGW, yxchg, Pe, opBytes{0x90, 0x90, 0x87, 0x87}}",
+		"{AXCHGL, yxchg, Px, opBytes{0x90, 0x90, 0x87, 0x87}}",
+		"{AXCHGQ, yxchg, Pw, opBytes{0x90, 0x90, 0x87, 0x87}}",
+	} {
+		if !bytes.Contains(data, []byte(row)) {
+			t.Fatal("independent complete opcode registration changed", row)
+		}
+	}
+	for name, rows := range map[string]string{
+		"yml_mb": `{Zr_m,1,argList{Yrb,Ymb}},{Zm_r,1,argList{Ymb,Yrb}},`,
+		"yxchg":  `{Z_rp,1,argList{Yax,Yrl}},{Zrp_,1,argList{Yrl,Yax}},{Zr_m,1,argList{Yrl,Yml}},{Zm_r,1,argList{Yml,Yrl}},`,
+	} {
+		body := regexp.MustCompile(`(?s)var ` + name + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(body) != 2 || regexp.MustCompile(`\s+`).ReplaceAllString(string(body[1]), "") != rows {
+			t.Fatal("independent ordered encoder classes/offset advances changed", name)
+		}
+	}
+	if len(regexp.MustCompile(`\{AXCHG[BWLQ],`).FindAll(data, -1)) != 4 {
+		t.Fatal("original family acquired an unenumerated opcode")
+	}
+}
+
+func TestX86ResultSwapOriginalPhysicalByteWitnesses(t *testing.T) {
+	for _, row := range []struct {
+		arch, body string
+		code       []byte
+	}{
+		{"amd64", "XCHGB AH,AL", []byte{0x86, 0xe0}},
+		{"amd64", "XCHGB AL,AH", []byte{0x86, 0xc4}},
+		{"amd64", "XCHGB AH,R11", []byte{0x41, 0x86, 0xe3}},
+		{"amd64", "XCHGB R11,AH", []byte{0x44, 0x86, 0xdc}},
+		{"amd64", "XCHGB DH,R11", []byte{0x41, 0x86, 0xf3}},
+		{"amd64", "XCHGB CH,SI", []byte{0x40, 0x86, 0xee}},
+		{"amd64", "XCHGW AX,AX", []byte{0x66, 0x90}},
+		{"amd64", "XCHGL AX,AX", []byte{0x90}},
+		{"amd64", "XCHGQ AX,AX", []byte{0x48, 0x90}},
+		{"amd64", "XCHGL BX,BX", []byte{0x87, 0xdb}},
+		{"amd64", "XCHGL AX,BX", []byte{0x93}},
+		{"amd64", "XCHGL BX,AX", []byte{0x93}},
+		{"amd64", "XCHGQ AX,R11", []byte{0x49, 0x93}},
+		{"386", "XCHGB AH,AL", []byte{0x86, 0xe0}},
+		{"386", "XCHGB SI,DI", []byte{0x96, 0x87, 0xdf, 0x86, 0xc3, 0x87, 0xdf, 0x96}},
+		{"386", "XCHGL AX,AX", []byte{0x90}},
+	} {
+		t.Run(row.arch+"/"+row.body, func(t *testing.T) {
+			source := "TEXT ·Value(SB),4,$0-0\n" + row.body + "\nRET\n"
+			actual := x86OrderingHintGoBytes(t, row.arch, source)
+			want := append(append([]byte(nil), row.code...), 0xc3)
+			if !bytes.Equal(actual, want) {
+				t.Fatalf("actual whole Go instruction sequence=%x, want=%x", actual, want)
+			}
+			t.Logf("original Go complete bytes=%x (encoding, not a runtime or permission certificate)", actual)
+		})
+	}
+}
+
+func x86ResultSwapRegisterAxes(arch string) []string {
+	gp := []string{"AX", "CX", "DX", "BX", "SI", "DI"}
+	byteRegs := append(append([]string(nil), gp...), "AL", "CL", "DL", "BL", "AH", "CH", "DH", "BH")
+	widths := "BWL"
+	if arch == "amd64" {
+		widths += "Q"
+		byteRegs = append(byteRegs, "SIB", "DIB")
+		for index := 8; index < 16; index++ {
+			reg := fmt.Sprint("R", index)
+			gp = append(gp, reg)
+			byteRegs = append(byteRegs, reg, reg+"B")
+		}
+	}
+	var rows []string
+	for _, width := range widths {
+		registers := gp
+		if width == 'B' {
+			registers = byteRegs
+		}
+		for _, first := range registers {
+			for _, second := range registers {
+				rows = append(rows, fmt.Sprintf("XCHG%c %s,%s", width, first, second))
+			}
+		}
+	}
+	return rows
+}
+
+// This independent source-name classifier is used only to assert rejection of
+// Go-accepted REX reinterpretations. It is not the production grammar.
+func x86ResultSwapHighByteREX(row string) bool {
+	fields := strings.FieldsFunc(row, func(r rune) bool { return r == ' ' || r == ',' })
+	if fields[0] != "XCHGB" {
+		return false
+	}
+	high, rex := false, false
+	for _, reg := range fields[1:] {
+		high = high || reg == "AH" || reg == "CH" || reg == "DH" || reg == "BH"
+		rex = rex || reg == "SP" || reg == "BP" || reg == "SI" || reg == "DI" || reg == "BPB" || reg == "SIB" || reg == "DIB" || strings.HasPrefix(reg, "R")
+	}
+	return high && rex
+}
+
+func TestX86ResultSwapCompleteRegisterAxes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86ResultSwapRegisterAxes(arch)
+		goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", "", true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row)
+				before := fmt.Sprintf("%#v", ins)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: x86ByteFlagCF | x86ByteFlagAF | x86ByteFlagOF}
+					for index := range state.gp {
+						state.gp[index] = 0xff
+					}
+					state.xmm[0], state.masks[0] = 0x55aa, true
+					want := state.clone()
+					accepted := arch != "amd64" || !x86ResultSwapHighByteREX(row)
+					if got := consumer.step(ins, &state, nil, 0, arch); got != accepted || !reflect.DeepEqual(state, want) {
+						t.Errorf("%s initialized register swap: accepted=%t want=%t, state=%#v want=%#v", consumer.name, got, accepted, state, want)
+					}
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("observer changed original source metadata")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultSwapEveryInputByteAndAliasPreservation(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, test := range []struct {
+			row             string
+			first, second   int
+			firstMask, last uint8
+			width           int
+		}{
+			{"XCHGB AH,AL", 0, 0, 2, 1, 1},
+			{"XCHGB AL,AH", 0, 0, 1, 2, 1},
+			{"XCHGB AX,AL", 0, 0, 1, 1, 1},
+			{"XCHGB AL,BL", 0, 3, 1, 1, 1},
+			{"XCHGW AX,BX", 0, 3, 3, 3, 2},
+			{"XCHGL AX,BX", 0, 3, 15, 15, 4},
+			{"XCHGL BX,BX", 3, 3, 15, 15, 4},
+			{"XCHGQ AX,BX", 0, 3, 255, 255, 8},
+		} {
+			if arch == "386" && test.width == 8 {
+				continue // Go rejects this Q row; rejection is exercised below.
+			}
+			t.Run(arch+"/"+test.row, func(t *testing.T) {
+				ins := x86YMMReadSource(t, test.row)
+				for operand := 0; operand < 2; operand++ {
+					for missing := -1; missing < 8; missing++ {
+						initial := x86ResultState{flags: x86ByteFlagPF | x86ByteFlagSF}
+						initial.gp[test.first] = test.firstMask | 0x80
+						initial.gp[test.second] |= test.last | 0x80
+						index, mask := test.first, test.firstMask
+						if operand == 1 {
+							index, mask = test.second, test.last
+						}
+						if missing >= 0 {
+							initial.gp[index] &^= uint8(1) << uint(missing)
+						}
+						need := mask
+						if test.first == test.second {
+							need = test.firstMask | test.last
+						}
+						accepted := missing < 0 || need&(uint8(1)<<uint(missing)) == 0
+						want := initial.clone()
+						if accepted && test.width >= 4 {
+							want.gp[test.first], want.gp[test.second] = 0xff, 0xff
+						}
+						for _, consumer := range x86ResultGPSIMDConsumers {
+							state := initial.clone()
+							if got := consumer.step(ins, &state, nil, 0, arch); got != accepted || !reflect.DeepEqual(state, want) {
+								t.Fatalf("%s operand=%d missing=%d: accepted=%t want=%t, state=%#v want=%#v", consumer.name, operand, missing, got, accepted, state, want)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultSwapOpaqueIdentityIsNotNumeric(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			if arch == "386" && width == "Q" {
+				continue
+			}
+			for _, second := range []string{"numeric", "opaque", "unknown", "self"} {
+				t.Run(arch+"/"+width+"/"+second, func(t *testing.T) {
+					row := "XCHG" + width + " AX,BX"
+					initial := x86ResultState{flags: x86ByteFlagsAll}
+					initial.pointerGP[0] = true
+					if second == "numeric" {
+						initial.gp[3] = 0xff
+					} else if second == "opaque" {
+						initial.pointerGP[3] = true
+					} else if second == "self" {
+						row = "XCHG" + width + " AX,AX"
+					}
+					word := width == "Q" && arch == "amd64" || width == "L" && arch == "386"
+					accepted := second == "self" && width != "B" || word && second != "unknown"
+					want := initial.clone()
+					if accepted && second != "self" {
+						want.gp[0], want.gp[3] = initial.gp[3], initial.gp[0]
+						want.pointerGP[0], want.pointerGP[3] = initial.pointerGP[3], initial.pointerGP[0]
+					}
+					ins := x86YMMReadSource(t, row)
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						state := initial.clone()
+						if got := consumer.step(ins, &state, nil, 0, arch); got != accepted || !reflect.DeepEqual(state, want) {
+							t.Fatalf("%s opaque domain: accepted=%t want=%t, state=%#v want=%#v", consumer.name, got, accepted, state, want)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultSwapAccumulatorNOPDoesNotDefineBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			if arch == "386" && width == "Q" {
+				continue
+			}
+			for mask := 0; mask < 256; mask++ {
+				ins := x86YMMReadSource(t, "XCHG"+width+" AX,AX")
+				initial := x86ResultState{flags: uint8(mask) & x86ByteFlagsAll}
+				initial.gp[0] = uint8(mask)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := initial.clone()
+					if !consumer.step(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, initial) {
+						t.Fatalf("%s/%s/%s opcode90 manufactured defined bytes or changed flags at mask=%02x", arch, width, consumer.name, mask)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultSwapOriginalScalarLaneWitnessAndAllPaths(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, resultMove, typ := 8, "MOVQ", "uint64"
+		if arch == "386" {
+			word, resultMove, typ = 4, "MOVL", "uint32"
+		}
+		finish := fmt.Sprintf("MOVL $0,BX\nMOVL BX,X0\nPINSRW $0,AX,X0\nVPEXTRQ $0,X0,BX\n%s BX,ret0+%d(FP)\nRET", resultMove, word)
+		for name, test := range map[string]struct {
+			body string
+			pass bool
+		}{
+			"original AH AL":              {"MOVW x+0(FP),AX\nXCHGB AH,AL\n" + finish, true},
+			"simultaneous AL AH":          {"MOVW x+0(FP),AX\nXCHGB AL,AH\n" + finish, true},
+			"partial unknown AH":          {"MOVB x+0(FP),AL\nXCHGB AH,AL\n" + finish, false},
+			"unknown AL":                  {"MOVB $7,AH\nXCHGB AH,AL\n" + finish, false},
+			"NOP is not L zero extension": {"MOVW x+0(FP),AX\nXCHGL AX,AX\nMOVL AX,X0\n" + fmt.Sprintf("PEXTRD $0,X0,BX\n%s BX,ret0+%d(FP)\nRET", resultMove, word), false},
+			"flags survive every swap":    {"MOVW x+0(FP),AX\nCMPW AX,$0\nXCHGB AH,AL\nJE other\nXCHGW AX,AX\nJMP done\nother:\nXCHGB AH,AL\ndone:\n" + finish, true},
+			"one path unknown byte":       {"MOVB x+0(FP),AL\nCMPB AL,$0\nJE done\nMOVB $7,AH\ndone:\nXCHGB AH,AL\n" + finish, false},
+			"native memory not granted":   {"MOVW x+0(FP),AX\nXCHGW AX,(SI)\n" + finish, false},
+			"result RMW not granted":      {fmt.Sprintf("MOVW x+0(FP),AX\nXCHGW AX,ret0+%d(FP)\n", word) + finish, false},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x uint16) "+typ, test.body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("all-path scalar input/result obligation pass=%t error=%v", test.pass, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultSwapREXAliasesKeepContext(t *testing.T) {
+	for _, high := range []string{"AH", "CH", "DH", "BH"} {
+		for _, rex := range []string{"SI", "DIB", "R11", "R11B"} {
+			for _, reverse := range []bool{false, true} {
+				row := "XCHGB " + high + "," + rex
+				if reverse {
+					row = "XCHGB " + rex + "," + high
+				}
+				t.Run(row, func(t *testing.T) {
+					source := "TEXT ·Value(SB),4,$0-4\nMOVL $7,AX\nMOVL $9,BX\nMOVL $11,CX\nMOVL $13,DX\nMOVL $17,SI\nMOVL $19,DI\nMOVL $23,R11\n" + row + "\nMOVL AX,ret0+0(FP)\nRET\n"
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+					pkg := mustGoPackage(t, "example.invalid/resultinit", "package resultinit\nfunc Value() uint32\n")
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ResultSwapTranslateAPI(t, api, source, pkg, "amd64", "x86_64-unknown-linux-gnu")
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("%s gave a high-byte spelling a different physical REX view: %v", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultSwapOpaqueOriginalSourceAndResultBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, swap, typ, word := "MOVQ", "XCHGQ", "uint64", 8
+		if arch == "386" {
+			move, swap, typ, word = "MOVL", "XCHGL", "uint32", 4
+		}
+		prefix := fmt.Sprintf("%s p+0(FP),AX\n%s x+%d(FP),BX\n%s AX,BX\n", move, move, word, swap)
+		for name, test := range map[string]struct {
+			body string
+			pass bool
+		}{
+			"numeric snapshot reaches result": {prefix + fmt.Sprintf("%s AX,ret0+%d(FP)\nRET", move, 2*word), true},
+			"opaque snapshot is not numeric":  {prefix + fmt.Sprintf("%s BX,ret0+%d(FP)\nRET", move, 2*word), false},
+			"opaque snapshot has no pointee":  {prefix + fmt.Sprintf("MOVL (BX),AX\n%s AX,ret0+%d(FP)\nRET", move, 2*word), false},
+			"unknown second required read":    {fmt.Sprintf("%s p+0(FP),AX\nMOVW $7,BX\n%s AX,BX\n%s $42,ret0+%d(FP)\nRET", move, swap, move, 2*word), false},
+			"opaque survives encoded NOP":     {fmt.Sprintf("%s p+0(FP),AX\nXCHGL AX,AX\n%s $42,ret0+%d(FP)\nRET", move, move, 2*word), true},
+			"opaque NOP defines no numbers":   {fmt.Sprintf("%s p+0(FP),AX\nXCHGL AX,AX\n%s AX,ret0+%d(FP)\nRET", move, move, 2*word), false},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value(p *[8]uint32,x "+typ+") "+typ, test.body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("opaque identity/result separation pass=%t error=%v", test.pass, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultSwapRejectsNonRegisterAuthorityAndMalformedGrammar(t *testing.T) {
+	for _, test := range []struct {
+		arch, row string
+	}{
+		{"amd64", "XCHGB SP,AX"}, {"amd64", "XCHGB BPB,AL"},
+		{"386", "XCHGB BP,DI"}, {"amd64", "XCHGQ SP,AX"},
+		{"amd64", "XCHGQ BP,AX"}, {"386", "XCHGQ AX,BX"},
+		{"386", "XCHGL R8,AX"}, {"386", "XCHGB R8B,AL"},
+		{"amd64", "XCHGW $1,AX"}, {"amd64", "XCHGL AX,X0"},
+		{"amd64", "XCHGL.Z AX,BX"}, {"arm64", "XCHGL AX,BX"},
+		{"amd64", "XCHGW AX"}, {"amd64", "XCHGL AX,BX,CX"},
+		{"amd64", "XCHGB AH,(R11)"}, {"amd64", "XCHGB (R11),AH"},
+		{"amd64", "XCHGQ AX,(BX)"}, {"amd64", "XCHGQ (BX),AX"},
+		{"amd64", "XCHGW AX,value+0(FP)"}, {"amd64", "XCHGW AX,tmp+0(SP)"},
+		{"amd64", "XCHGW AX,value(SB)"}, {"amd64", "XCHGW AX,$value(SB)"},
+	} {
+		t.Run(test.arch+"/"+test.row, func(t *testing.T) {
+			ins := x86YMMReadSource(t, test.row)
+			initial := x86ResultState{flags: x86ByteFlagsAll, fp: []bool{true, true}, auto: []bool{true, true}}
+			for index := range initial.gp {
+				initial.gp[index], initial.pointerGP[index] = 0xff, true
+			}
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := initial.clone()
+				accepted := consumer.step(ins, &state, []bool{true, true}, 0, test.arch)
+				if test.arch == "386" && test.row == "XCHGB BP,DI" {
+					want := initial.clone()
+					want.pointerGP[5], want.pointerGP[7] = false, false
+					if !accepted || !reflect.DeepEqual(state, want) {
+						t.Fatal("ordinary mode32 byte exchange changed unrelated state", consumer.name, state)
+					}
+					continue
+				}
+				if accepted || !reflect.DeepEqual(state, initial) {
+					t.Fatalf("%s widened register or memory authority: %#v", consumer.name, state)
+				}
+			}
+		})
+	}
+	ins := x86YMMReadSource(t, "XCHGL AX,BX")
+	if _, err := parseAMD64ExchangeForm("amd64", "XCHGL", amd64ExchangeSpec{amd64ExchangeSwap, 16}, ins); err == nil {
+		t.Fatal("typed exchange accepted a contradictory width")
+	}
+	if _, err := parseAMD64ExchangeForm("amd64", "XCHGW", amd64ExchangeSpecs["XCHGW"], ins); err == nil {
+		t.Fatal("typed exchange accepted a contradictory source opcode")
+	}
+}
diff --git a/x86_result_ternary_raw.go b/x86_result_ternary_raw.go
new file mode 100644
index 000000000..e310d9140
--- /dev/null
+++ b/x86_result_ternary_raw.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+// The decoder records both the actual physical mode and the explicit encoded
+// marker. An absent zero snapshot cannot assert a named or raw generation.
+type x86RawTernaryLogicIdentity struct {
+	arch    string
+	encoded bool
+}
+
+func x86TernaryLogicRawIdentity(ins Instr, arch string) x86RawTernaryLogicIdentity {
+	form, known, err := x86TernaryLogicProperties(ins.Op, ins, arch)
+	if !known || err != nil || !ins.x86Encoded || ins.x86VectorBytes != form.byteWidth {
+		return x86RawTernaryLogicIdentity{}
+	}
+	return x86RawTernaryLogicIdentity{arch: arch, encoded: ins.x86Encoded}
+}
+
+func x86RawTernaryLogicSource(ins Instr, arch string) bool {
+	_, known, err := x86TernaryLogicProperties(ins.Op, ins, arch)
+	origin := ins.x86SourceRaw
+	return known && err == nil && origin != nil && origin.ternaryLogic.arch == arch &&
+		origin.ternaryLogic == x86TernaryLogicRawIdentity(ins, arch) &&
+		x86RawOrdinaryVectorSourceAt(ins, arch, 1)
+}
+
+// An independently bound DATA owner retains its existing literal consumer.
+// It is not an incoming pointer or an ordinary native source continuation.
+func x86RawTernaryLogicLiteralForm(ins Instr, arch string) bool {
+	if !x86RawLiteralSourceShape(ins, arch) || !x86RawReturnDecodedReadIdentity(ins) {
+		return false
+	}
+	form, known, err := x86TernaryLogicProperties(ins.Op, ins, arch)
+	return known && err == nil && form.memory == 1 &&
+		ins.x86RIPMemoryRead.source == 1 && ins.x86RIPMemoryRead.width == int64(form.memoryBytes)
+}
diff --git a/x86_result_typed_effects_runtime_test.go b/x86_result_typed_effects_runtime_test.go
new file mode 100644
index 000000000..660dccd13
--- /dev/null
+++ b/x86_result_typed_effects_runtime_test.go
@@ -0,0 +1,187 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/types"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ExplicitMultiplyDeclaredBytesAndFlags(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	var declarations, assembly, goTest, reference strings.Builder
+	declarations.WriteString("package explicitmul\n")
+	goTest.WriteString(`package explicitmul
+import "testing"
+
+func signed(value uint64,bits int) int64 {
+ if bits==16 { return int64(int16(value)) }
+ if bits==32 { return int64(int32(value)) }
+ return int64(value)
+}
+func expected(a,b uint64,bits int) (uint64,uint8) {
+ x,y:=signed(a,bits),signed(b,bits)
+ product:=uint64(x)*uint64(y)
+ flag:=uint8(0)
+ if bits<64 {
+  wide:=x*y
+  if signed(product,bits)!=wide { flag=3 }
+ } else if x!=0 {
+  low:=int64(product)
+  if x==-1&&y==(-1<<63)||low/x!=y { flag=3 }
+ }
+ if bits==16 { product=b&^uint64(65535)|uint64(uint16(product)) }
+ if bits==32 { product=uint64(uint32(product)) }
+ return product,flag
+}
+func TestOriginal(t *testing.T) {
+ for sample:=uint64(0);sample<257;sample++ {
+  x:=sample*0x9e3779b97f4a7c15
+  y:=sample*0xd1b54a32d192ed03^0xfaceb00c01234567
+`)
+	reference.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+static int64_t signed_bits(uint64_t value,int bits) {
+ if(bits==16) return (int16_t)value;
+ if(bits==32) return (int32_t)value;
+ return (int64_t)value;
+}
+static uint64_t expected(uint64_t a,uint64_t b,int bits,uint8_t *flags) {
+ __int128 wide=(__int128)signed_bits(a,bits)*signed_bits(b,bits);
+ uint64_t low=(uint64_t)wide;
+ *flags=signed_bits(low,bits)!=wide?3:0;
+ if(bits==16) low=(b&~UINT64_C(65535))|(uint16_t)low;
+ if(bits==32) low=(uint32_t)low;
+ return low;
+}
+`)
+	var checks strings.Builder
+	kinds := []string{"Reg", "Alias", "FP", "AUTO", "Imm8", "Imm32", "ThreeReg", "ThreeFP", "ThreeAUTO"}
+	immediates := make(map[string]x86IMULImmediateCase)
+	for _, literal := range x86IMULImmediateCases {
+		if literal.only386 {
+			continue // This numerical execution is AMD64; every 386 row has object/byte coverage.
+		}
+		for _, prefix := range []string{"TwoLiteral", "ThreeLiteral"} {
+			kind := prefix + literal.name
+			kinds = append(kinds, kind)
+			immediates[kind] = literal
+		}
+	}
+	for _, bits := range []int{16, 32, 64} {
+		suffix := map[int]string{16: "W", 32: "L", 64: "Q"}[bits]
+		for _, kind := range kinds {
+			name := fmt.Sprintf("Mul%d%s", bits, kind)
+			operation, a, b := "IMUL"+suffix+" AX,BX", "x", "y"
+			switch kind {
+			case "Reg":
+				// The register form is the initialized default above.
+			case "Alias":
+				operation, a = "IMUL"+suffix+" BX,BX", "y"
+			case "FP":
+				operation = "IMUL" + suffix + " x+0(FP),BX"
+			case "AUTO":
+				operation = "IMUL" + suffix + " value-16(SP),BX"
+			case "Imm8":
+				operation, a = "IMUL"+suffix+" $-7,BX", "uint64(0xfffffffffffffff9)"
+			case "Imm32":
+				operation, a = "IMUL"+suffix+" $2147483648,BX", "uint64(0xffffffff80000000)"
+			case "ThreeReg", "ThreeFP", "ThreeAUTO":
+				source := map[string]string{"ThreeReg": "AX", "ThreeFP": "x+0(FP)", "ThreeAUTO": "value-16(SP)"}[kind]
+				operation, a, b = "IMUL3"+suffix+" $65537,"+source+",BX", "uint64(65537)", "x"
+			default:
+				literal := immediates[kind]
+				// The independent mathematical references use the architectural
+				// signed immediate, not the production descriptor or formatter.
+				a = fmt.Sprintf("uint64(0x%x)", uint64(int64(int32(literal.value))))
+				operation = "IMUL" + suffix + " $" + literal.literal + ",BX"
+				if strings.HasPrefix(kind, "ThreeLiteral") {
+					operation, b = "IMUL3"+suffix+" $"+literal.literal+",AX,BX", "x"
+				}
+			}
+			// Word results preserve the old destination's high bytes, not the
+			// source's. Both references supply that independently below.
+			for _, flags := range []bool{false, true} {
+				function, typ, size := name, "uint64", 24
+				if flags {
+					function, typ, size = name+"Flags", "uint8", 17
+				}
+				fmt.Fprintf(&declarations, "func %s(x,y uint64) %s\n", function, typ)
+				fmt.Fprintf(&assembly, "TEXT ·%s(SB),4,$32-%d\nMOVQ x+0(FP),AX\nMOVQ y+8(FP),BX\nMOVQ AX,value-16(SP)\n%s\n", function, size, operation)
+				if flags {
+					assembly.WriteString("MOVL $0,DX\nSETCS DX\nSETOS AX\nMOVBLZX DX,DX\nMOVBLZX AX,AX\nADDL AX,AX\nORL AX,DX\nMOVB DX,ret0+16(FP)\nRET\n")
+				} else {
+					assembly.WriteString("MOVQ BX,ret0+16(FP)\nRET\n")
+				}
+			}
+			fmt.Fprintf(&goTest, "{ want,flags:=expected(%s,%s,%d);", a, b, bits)
+			if bits == 16 {
+				goTest.WriteString("want=y&^uint64(65535)|uint64(uint16(want));")
+			}
+			fmt.Fprintf(&goTest, "if got:=%s(x,y);got!=want { t.Fatalf(\"%s sample%%d got%%x want%%x\",sample,got,want) };if got:=%sFlags(x,y);got!=flags { t.Fatalf(\"%s flags sample%%d got%%x want%%x\",sample,got,flags) }}\n", name, name, name, name)
+			fmt.Fprintf(&reference, "extern uint64_t %s(uint64_t,uint64_t);\nextern uint8_t %sFlags(uint64_t,uint64_t);\n", name, name)
+			ca := strings.ReplaceAll(a, "uint64(", "UINT64_C(")
+			cb := strings.ReplaceAll(b, "uint64(", "UINT64_C(")
+			fmt.Fprintf(&checks, "{ uint8_t flags;uint64_t want=expected(%s,%s,%d,&flags);", ca, cb, bits)
+			if bits == 16 {
+				checks.WriteString("want=(y&~UINT64_C(65535))|(uint16_t)want;")
+			}
+			fmt.Fprintf(&checks, "struct {uint64_t before,value,after;} out={UINT64_C(0x1122334455667788),%s(x,y),UINT64_C(0x8877665544332211)};if(out.value!=want||%sFlags(x,y)!=flags||out.before!=UINT64_C(0x1122334455667788)||out.after!=UINT64_C(0x8877665544332211)) {fprintf(stderr,\"%s sample%%llu got%%llx want%%llx flags%%u\\n\",(unsigned long long)sample,(unsigned long long)out.value,(unsigned long long)want,flags);return 1;}}\n", name, name, name)
+		}
+	}
+	goTest.WriteString("}\n}\n")
+	reference.WriteString("int main(void) {for(uint64_t sample=0;sample<257;sample++){uint64_t x=sample*UINT64_C(0x9e3779b97f4a7c15),y=sample*UINT64_C(0xd1b54a32d192ed03)^UINT64_C(0xfaceb00c01234567);\n" + checks.String() + "}\nreturn 0;}\n")
+	dir := t.TempDir()
+	for name, contents := range map[string]string{
+		"go.mod": "module explicitmul\n\ngo 1.20\n", "mul.go": declarations.String(),
+		"mul_amd64.s": assembly.String(), "mul_test.go": goTest.String(),
+	} {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", assembly.String(), "", true)
+	binary := filepath.Join(dir, "original.test")
+	command := exec.Command("go", "test", "-p=2", "-vet=off", "-c", "-o", binary, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local", "GOARCH=amd64", "CGO_ENABLED=0", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	output := execution.run(t, binary, "-test.run=^TestOriginal$", "-test.count=1", "-test.v")
+	if !strings.Contains(string(output), "--- PASS: TestOriginal") || !strings.Contains(string(output), "PASS\n") {
+		t.Fatalf("original Go explicit multiplication has no successful terminal: %s", output)
+	}
+	pkg := mustGoPackage(t, "example.invalid/explicitmul", declarations.String())
+	file, err := Parse(ArchAMD64, assembly.String())
+	if err != nil {
+		t.Fatal(err)
+	}
+	sigs := make(map[string]FuncSig)
+	for _, fn := range file.Funcs {
+		name := strings.TrimPrefix(fn.Sym, "·")
+		sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func), "amd64", types.SizesFor("gc", "amd64"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); err != nil {
+			t.Fatal(err)
+		}
+		sigs[name] = sig
+	}
+	ir, err := Translate(file, Options{Goarch: "amd64", TargetTriple: execution.triple, Sigs: sigs,
+		ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, level := range []string{"-O0", "-O2"} {
+		t.Run(level, func(t *testing.T) {
+			execution.compileAndRunLLVM(t, "typed-multiply", ir, reference.String(), level)
+		})
+	}
+	if !t.Failed() {
+		t.Logf("original Go/LLVM %d initialized multiplication forms plus %d CF/OF kernels ×257 inputs; full word aliases, scalar results and canaries; no frame/caller/source permission", 3*len(kinds), 3*len(kinds))
+	}
+}
diff --git a/x86_result_typed_effects_test.go b/x86_result_typed_effects_test.go
new file mode 100644
index 000000000..40aa49138
--- /dev/null
+++ b/x86_result_typed_effects_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The directory below is independent of the production descriptor. These are
+// the complete named GP extension rows in the actual Go x86 encoder. The
+// observation establishes numerical byte knowledge only, never pointer/frame
+// permissions or an initialized ABI0 entry register.
+func TestX86ABI0ResultTypedExtensionsCompleteDeclaredBytes(t *testing.T) {
+	rows := []struct {
+		op        string
+		source    int
+		result    int
+		reject386 bool
+	}{
+		{"MOVBWSX", 1, 2, false}, {"MOVBWZX", 1, 2, false},
+		{"MOVBLSX", 1, 4, false}, {"MOVBLZX", 1, 4, false},
+		{"MOVBQSX", 1, 8, true}, {"MOVBQZX", 1, 8, true},
+		{"MOVWLSX", 2, 4, false}, {"MOVWLZX", 2, 4, false},
+		{"MOVWQSX", 2, 8, true}, {"MOVWQZX", 2, 8, true},
+		{"MOVLQSX", 4, 8, true}, {"MOVLQZX", 4, 8, false},
+		{"MOVSWW", 2, 2, false}, {"MOVZWW", 2, 2, false},
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move := 8, "uint64", "MOVQ"
+		if arch == "386" {
+			word, typ, move = 4, "uint32", "MOVL"
+		}
+		for _, row := range rows {
+			for _, input := range []string{"AX", "x+0(FP)", "value-16(SP)"} {
+				t.Run(arch+"/"+row.op+"/"+input, func(t *testing.T) {
+					body := fmt.Sprintf("%s x+0(FP),AX\n%s $0,BX\n%s AX,value-16(SP)\n%s %s,BX\n%s BX,ret0+%d(FP)\nRET",
+						move, move, move, row.op, input, move, word)
+					_, _, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x "+typ+") "+typ, body)
+					source = strings.Replace(source, ",$0-", ",$32-", 1)
+					goAssemblerOracleOutput(t, arch, source, "", !row.reject386 || arch != "386")
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					err = CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+					if arch == "386" && row.reject386 {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("Go-rejected mode acquired result knowledge: %v", err)
+						}
+						return
+					}
+					if err != nil {
+						t.Fatalf("Go-accepted extension numerical effect missing: %v\n%s", err, source)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultTypedExplicitMultiplyCompleteForms(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, move := 8, "uint64", "MOVQ"
+		if arch == "386" {
+			word, typ, move = 4, "uint32", "MOVL"
+		}
+		for _, suffix := range []string{"W", "L", "Q"} {
+			for _, form := range []string{
+				"IMUL%s AX,BX", "IMUL%s x+0(FP),BX", "IMUL%s value-16(SP),BX",
+				"IMUL%s $-7,BX", "IMUL%s $65537,BX",
+				"IMUL3%s $-7,AX,BX", "IMUL3%s $65537,x+0(FP),BX", "IMUL3%s $65537,value-16(SP),BX",
+			} {
+				instruction := fmt.Sprintf(form, suffix)
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					body := fmt.Sprintf("%s x+0(FP),AX\n%s $3,BX\n%s AX,value-16(SP)\n%s\n%s BX,ret0+%d(FP)\nRET",
+						move, move, move, instruction, move, word)
+					_, _, sig, source := x86ResultInitializationFixture(t, arch, "func Value(x "+typ+") "+typ, body)
+					source = strings.Replace(source, ",$0-", ",$32-", 1)
+					rejected := arch == "386" && suffix == "Q"
+					goAssemblerOracleOutput(t, arch, source, "", !rejected)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					err = CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+					if rejected {
+						if !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatalf("Go-rejected multiplication acquired knowledge: %v", err)
+						}
+						return
+					}
+					if err != nil {
+						t.Fatalf("Go-accepted explicit multiply effect missing: %v\n%s", err, source)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ABI0ResultTypedMultiplyOnlyDefinesCFAndOF(t *testing.T) {
+	for _, condition := range []string{"CC", "CS", "EQ", "NE", "GE", "LT", "GT", "LE", "HI", "LS", "MI", "PL", "OC", "OS", "PC", "PS"} {
+		t.Run(condition, func(t *testing.T) {
+			body := "MOVL $3,AX\nCMPL AX,$0\nIMUL3L $7,AX,AX\nSET" + condition + " ret0+0(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint8", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+			defined := condition == "CC" || condition == "CS" || condition == "OC" || condition == "OS"
+			if defined && err != nil {
+				t.Fatalf("defined multiply flags remain unknown: %v", err)
+			}
+			if !defined && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("multiply inherited undefined old comparison flags: %v", err)
+			}
+		})
+	}
+}
+
+func TestX86ABI0ResultTypedGPUnknownAliasAndAddressStayContext(t *testing.T) {
+	for name, body := range map[string]string{
+		"undefined extension source":           "MOVLQSX AX,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"partial extension source":             "MOVB $1,AX\nMOVWQSX AX,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"word destination keeps unknown upper": "MOVB $1,AX\nMOVBWSX AX,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"word high alias is SP":                "MOVW $1,AX\nMOVSWW AH,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"byte REX alias is SP":                 "MOVB $1,AH\nMOVBQSX AH,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"undefined explicit multiply input":    "MOVL $7,BX\nIMULL AX,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"three operand source still undefined": "IMUL3Q $7,AX,BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"native load has no region":            "MOVLQSX (AX),BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"unknown AUTO byte":                    "MOVB $1,value-16(SP)\nMOVWQSX value-16(SP),BX\nMOVQ BX,ret0+0(FP)\nRET",
+		"LEA is not numeric":                   "LEAQ value-16(SP),AX\nMOVQ AX,ret0+0(FP)\nRET",
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, sig, _ := x86ResultAUTOFixture(t, "amd64", "func Value() uint64", 32, body)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatalf("undefined/pointer/partial alias acquired numeric effect: %v", err)
+			}
+		})
+	}
+}
diff --git a/x86_result_unpack.go b/x86_result_unpack.go
new file mode 100644
index 000000000..ef66fb50e
--- /dev/null
+++ b/x86_result_unpack.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+// Interleave follows only the selected numerical bytes, including sparse
+// inputs whose unused bytes remain unknown. The complete native memory tuple
+// must be proved independently, even with an initialized or zeroing mask.
+func x86ResultPackedUnpackStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultPackedUnpackStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultPackedUnpackStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86PackedUnpackProperties(ins, arch)
+	if !known || err != nil || form.mmx {
+		return false, known // Physical MMX remains a separate state bank.
+	}
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	var first uint64
+	if form.memory >= 0 {
+		// Logical FP/AUTO bytes do not prove legacy m128's native alignment.
+		// A paired emitted static read retains its existing independent role.
+		if _, static := x86StaticSBReadAddress(form.source, arch); form.legacy && !static &&
+			(!nativeRead || !x86OrdinaryNativeMemoryOperand(form.source, arch)) {
+			return false, true
+		}
+		if !x86ResultReadWithNativeContinuation(ins, form.source, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+			return false, true
+		}
+		first = x86CallerVectorByteMask(int64(form.byteWidth))
+	} else {
+		index, _ := amd64VectorRegisterIndex(ins.Args[form.first].Reg, form.byteWidth)
+		first = state.vectorBytes(index)
+	}
+	second, _ := amd64VectorRegisterIndex(ins.Args[form.second].Reg, form.byteWidth)
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	defined := x86PackedUnpackDefinedBytes(form, first, state.vectorBytes(second), state.vectorBytes(destination))
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true
+}
diff --git a/x86_result_unpack_test.go b/x86_result_unpack_test.go
new file mode 100644
index 000000000..14bfa3905
--- /dev/null
+++ b/x86_result_unpack_test.go
@@ -0,0 +1,206 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// An independent byte-array oracle follows each 128-bit interleave lane.
+// It deliberately does not call the production dependency calculation.
+func x86ResultUnpackExpected(op string, width int, first, second uint64) uint64 {
+	bytes := x86UnpackTestLaneBytes(op)
+	high := strings.Contains(op, "UNPCKH")
+	var result uint64
+	for output := 0; output < width; output++ {
+		group := output / 16 * 16
+		lane := output % 16 / bytes
+		input := group + lane/2*bytes + output%bytes
+		if high {
+			input += 8
+		}
+		known := second
+		if lane%2 != 0 {
+			known = first
+		}
+		if known>>uint(input)&1 != 0 {
+			result |= uint64(1) << uint(output)
+		}
+	}
+	return result
+}
+
+func TestX86ResultPackedUnpackCompleteRegisterByteRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x86CallerUnpackOpcodes() {
+			vector := strings.HasPrefix(op, "V")
+			for _, bank := range []string{"X", "Y", "Z"} {
+				if !vector && bank != "X" {
+					continue
+				}
+				for _, mask := range []string{"", "K1", "K1.Z"} {
+					if mask != "" && (!vector || arch == "386") {
+						continue
+					}
+					name := op
+					row := op + " X0,X1"
+					if vector {
+						if mask == "K1.Z" {
+							name += ".Z"
+						}
+						args := []string{bank + "0", bank + "1"}
+						if mask != "" {
+							args = append(args, "K1")
+						}
+						args = append(args, bank+"2")
+						row = name + " " + strings.Join(args, ",")
+					}
+					t.Run(arch+"/"+row, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, row)
+						form, known, err := x86PackedUnpackProperties(ins, arch)
+						if !known || err != nil || form.mmx {
+							t.Fatal("official typed register row lost", known, err)
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.masks[1] = true
+						patterns := []uint64{0x915ac30ef047268b, 0xe315a49c7026b8fd, 0x693ca517f0d24b8e}
+						for i, bits := range patterns {
+							state.xmm[i], state.vectorUpper[i] = uint16(bits), bits&^0xffff
+						}
+						first, second := patterns[0], patterns[1]
+						destination := form.destination
+						index, _ := amd64VectorRegisterIndex(ins.Args[destination].Reg, form.byteWidth)
+						old := state.vectorBytes(index)
+						want := x86ResultUnpackExpected(op, form.byteWidth, first, second)
+						if mask == "K1" {
+							want &= old
+						}
+						active := x86CallerVectorByteMask(int64(form.byteWidth))
+						if form.legacy {
+							want |= old &^ active
+						} else {
+							want |= ^active
+						}
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("typed interleave has no numerical-byte transfer")
+						}
+						if got := state.vectorBytes(index); got != want || state.flags != x86ByteFlagsAll {
+							t.Fatalf("got=%016x want=%016x flags=%x", got, want, state.flags)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultPackedUnpackSparseByteBroadcast(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			state := x86ResultState{}
+			// Only byte zero of the incoming GP is numerical. Go's AMD64
+			// MOVD source alias is MOVQ, independently clearing X bytes8..15;
+			// the legal mode32 spelling is MOVL and clears X bytes4..15.
+			state.xmm[0] = 0xff01
+			if arch == "386" {
+				state.xmm[0] = 0xfff1
+			}
+			for _, row := range []string{"PUNPCKLBW X0,X0", "PUNPCKLBW X0,X0", "PSHUFL $0,X0,X0"} {
+				if !x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, arch) {
+					t.Fatal("sparse broadcast cannot compose", row)
+				}
+			}
+			if state.xmm[0] != 0xffff || state.vectorUpper[0] != 0 {
+				t.Fatalf("dead GP bytes became required, or wider aliases were invented: %04x/%016x", state.xmm[0], state.vectorUpper[0])
+			}
+		})
+	}
+}
+
+func TestX86ResultPackedUnpackMemoryRolesDoNotShrink(t *testing.T) {
+	for _, op := range x86CallerUnpackOpcodes() {
+		if !strings.HasPrefix(op, "V") {
+			continue
+		}
+		for _, broadcast := range []bool{false, true} {
+			if broadcast && x86UnpackTestLaneBytes(op) < 4 {
+				continue
+			}
+			name := op + ".Z"
+			if broadcast {
+				name = op + ".BCST.Z"
+			}
+			row := name + " a+0(FP),Z1,K1,Z2"
+			t.Run(row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				form, known, err := x86PackedUnpackProperties(ins, "amd64")
+				if !known || err != nil {
+					t.Fatal(known, err)
+				}
+				for missing := -1; missing < form.memoryBytes; missing++ {
+					state := x86ResultState{fp: make([]bool, form.memoryBytes)}
+					owned := make([]bool, form.memoryBytes)
+					state.masks[1], state.xmm[1], state.vectorUpper[1] = true, 0xffff, ^uint64(0xffff)
+					for i := range owned {
+						owned[i], state.fp[i] = true, i != missing
+					}
+					accepted := x86ResultTransfer(ins, &state, owned, int64(len(owned)), "amd64")
+					if accepted != (missing == -1) {
+						t.Fatalf("full E4NF extent %d, missing byte %d: accepted=%t", form.memoryBytes, missing, accepted)
+					}
+				}
+				// Initialized address bits and a mask do not prove pointee bytes.
+				native := x86ScalarLaneInstruction(t, strings.Replace(row, "a+0(FP)", "(AX)", 1))
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				state.gp[0], state.masks[1], state.xmm[1], state.vectorUpper[1] = 0xff, true, 0xffff, ^uint64(0xffff)
+				if x86ResultTransfer(native, &state, nil, 0, "amd64") {
+					t.Fatal("native memory acquired permission from initialized address or numerical mask")
+				}
+			})
+		}
+	}
+	for _, row := range []string{"PUNPCKLBW a+0(FP),X0", "PUNPCKHBW a+0(FP),X0", "PUNPCKLBW M0,M1"} {
+		t.Run(fmt.Sprintf("legacy/%s", row), func(t *testing.T) {
+			state := x86ResultState{fp: make([]bool, 16)}
+			owned := make([]bool, 16)
+			for i := range owned {
+				owned[i], state.fp[i] = true, true
+			}
+			state.xmm[0] = 0xffff
+			if x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, owned, 16, "amd64") {
+				t.Fatal("logical bytes invented legacy alignment or the disjoint physical MMX bank")
+			}
+		})
+	}
+}
+
+func TestX86ResultPackedUnpackRejectsUnboundOperandRoles(t *testing.T) {
+	for _, row := range []struct{ arch, source string }{
+		{"amd64", "VPUNPCKLBW.Z X0,X1,K1,X2"}, // Unknown mask is not an inactive-lane proof.
+		{"amd64", "PUNPCKLBW X0,X1,X2"},
+		{"amd64", "VPUNPCKLBW X0,Y1,Y2"},
+		{"amd64", "VPUNPCKLBW.BCST (AX),X1,X2"},
+		{"amd64", "VUNPCKLPD.Z X0,X1,X2"},
+		{"386", "VPUNPCKLBW X8,X1,X2"},
+		{"386", "VPUNPCKLBW X0,X1,K1,X2"},
+	} {
+		t.Run(row.arch+"/"+row.source, func(t *testing.T) {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			for i := range state.xmm {
+				state.xmm[i], state.vectorUpper[i] = 0xffff, ^uint64(0xffff)
+			}
+			before := state.clone()
+			if x86ResultTransfer(x86ScalarLaneInstruction(t, row.source), &state, nil, 0, row.arch) {
+				t.Fatal("initialized operands invented a missing mask, format or mode role")
+			}
+			for i := range state.xmm {
+				if state.vectorBytes(i) != before.vectorBytes(i) {
+					t.Fatal("failed form changed a physical register")
+				}
+			}
+			if state.flags != before.flags {
+				t.Fatal("failed form changed flags")
+			}
+		})
+	}
+}
diff --git a/x86_result_value_stack.go b/x86_result_value_stack.go
new file mode 100644
index 000000000..e0284ce7d
--- /dev/null
+++ b/x86_result_value_stack.go
@@ -0,0 +1,322 @@
+package plan9asm
+
+// Each bit records initialization of one bit in private numerical storage.
+// This retains independently unknown status bits through PUSHF/POPF without
+// turning an entire packed byte into a numerical or pointer witness.
+type x86ResultValueStack struct {
+	bytes   []uint8 // Low byte is at the end, matching a descending byte stack.
+	invalid bool
+	id      bool // ID is separate from the six arithmetic flags and DF.
+	// AMD64 has at most 63 private cells. A set bit marks a source W cell,
+	// not a Q cell; equal virtual depth does not imply equal native SP delta.
+	wordCells uint64
+	// Eight bounded bitmap words cover at most 504 private byte positions.
+	// Mode32 uses only the first four; unused positions must remain zero.
+	pointerCells [8]uint64
+	// Nil means the existing ordinary NUM bytes. FLAGS pushes additionally
+	// retain precisely which source bits the adjacent mask may refine. Keep
+	// those masks in stack-byte order through mixed widths, not GP positions.
+	refinable   []uint8
+	correlation *x86ResultFlagsCorrelation // Paired mode32 lowering only; no native stack permission.
+}
+
+func x86ResultValueStackLimit(arch string) int {
+	// AMD64 lowering reserves one of its 64 virtual slots for an unproved
+	// entry continuation. This observer never reads that slot. The 386 byte
+	// stack uses the same bounded number of native words.
+	return 63 * int(x86ResultPointerWord(arch))
+}
+
+// Private numerical storage and ID survive these independently accepted
+// transfers. This is not the stronger inert-source rule: a vector product
+// changes data registers, but neither accesses SP nor changes private FLAGS.
+// Exact decoder identity supplies no input, pointer or entry permission.
+func x86ResultPreservesPrivateStorage(ins Instr, arch string) bool {
+	if x86RawCOMISource(ins, arch) {
+		return true // Scalar status/MXCSR effects do not access private SP or ID.
+	}
+	if x86RawMULXSource(ins, arch) {
+		return true // Exact GP products do not access private SP or ID.
+	}
+	if x86RawZeroExtendSource(ins, arch) {
+		return true // Exact vector widening does not access private SP or ID.
+	}
+	if x86RawPermute128Source(ins, arch) {
+		return true // No private SP or ID effect follows from vector selection.
+	}
+	if x86RawBlendMinposSource(ins, arch) {
+		return true // Exact vector data effects do not access private SP or ID.
+	}
+	if x86RawImmediateBlendSource(ins, arch) {
+		return true // Exact vector selection does not access private SP or ID.
+	}
+	if x86FMA3PreservesPrivateSourceState(ins, arch) {
+		return true // Exact vector/MXCSR effects do not access private SP or ID.
+	}
+	if x86RawScalarPrecisionSource(ins, arch) || x86RawScalarFloatIntegerSource(ins, arch) ||
+		x86RawPackedPrecisionSource(ins, arch) || x86RawNamedHalfSource(ins, arch) {
+		return true // The exact X/MXCSR conversion does not access private SP or ID.
+	}
+	if x86RawExplicitMaskMoveSource(ins, arch) {
+		return true // Exact native vector/memory effects do not access private SP or ID.
+	}
+	if x86RawPackedDotSource(ins, arch) {
+		return true // Exact vector arithmetic does not access private SP or ID.
+	}
+	if x86RawUnalignedLoadSource(ins, arch) {
+		return true
+	}
+	if x86RawIntegerMinMaxSource(ins, arch) {
+		return true // Exact vector data effects do not access private SP or FLAGS.
+	}
+	if x86RawTernaryLogicSource(ins, arch) {
+		return true // Exact bitwise vector writes do not create or replace private storage.
+	}
+	if x86RawLegacyFloatCompareSource(ins, arch) {
+		return true // Numerical X writes do not access the private stack or ID.
+	}
+	if x86FloatMinMaxPreservesSourceState(ins, arch) {
+		return true // Exact floating vector writes do not access private storage or ID.
+	}
+	return ins.Op != OpCALL && (x86ResultNamedPredicateInstruction(ins) ||
+		x86RegisterQueryPreservesSourceState(ins) || x86WaitPackagePreservesStorage(ins) ||
+		x86PreservesNumericalSourceState(ins) || x86MaskLogicalPreservesStorage(ins) ||
+		x86EnqueuePreservesStorage(ins) || x86RawPackedConversionSource(ins, arch) || x86RawPackedReductionSource(ins, arch) || x86RawDwordProductResultSource(ins, arch) ||
+		x86RawCMOVSource(ins, arch) || x86RawAESSource(ins, arch) || x86RawSHASource(ins, arch) || x86RawVectorTestSource(ins, arch) ||
+		x86RawIFMASource(ins, arch) || x86RawQwordLookupSource(ins, arch) ||
+		x86RawPackedIntegerCompareSource(ins, arch) || x86RawImmediatePackedCompareSource(ins, arch) ||
+		x86RawBroadcastSource(ins, arch) || x86RawCLMULSource(ins, arch))
+}
+
+func x86ResultValueStackContinuation(ins Instr, state *x86ResultState, arch string) bool {
+	if state.valueStack == nil || state.shapeOnly || len(state.valueStack.bytes) == 0 && !state.valueStack.invalid {
+		return true
+	}
+	if state.valueStack.invalid || !x86ResultPreservesPrivateStorage(ins, arch) {
+		return false
+	}
+	// On 386 the private byte stack moves the simulated SP. An AUTO access
+	// cannot borrow the independent unchanged-SP local-byte proof while live.
+	if arch == "386" {
+		if _, _, private := x86ResultPrivateStackXORForm(ins, arch); private && state.valueStack.correlation != nil {
+			return true // The transfer still checks every byte against reaching private depth.
+		}
+		for _, arg := range ins.Args {
+			if arg.Kind == OpMem && x86LogicalSourceFrameRegister(arg.Mem.Base, arch) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func x86ResultValueStackStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	return x86ResultValueStackStepWithNativeStore(ins, state, owned, resultOffset, arch, false)
+}
+
+func x86ResultValueStackStepWithNativeStore(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string, nativeStore bool) (bool, bool) {
+	spec, known, err := x86StackWidthProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) || state.valueStack == nil || state.valueStack.invalid {
+		return false, true
+	}
+	width := int64(spec.bits / 8)
+	storage := int(width)
+	if arch == "amd64" {
+		storage = 8 // Existing virtual AMD64 slots zero-extend narrow pushes.
+	}
+	stack := state.valueStack
+	if spec.mode == amd64StackPopValue && ins.Args[0].Kind == OpReg && ins.Args[0].Reg == SP {
+		return false, true // Numerical storage cannot rebind the physical/private stack pointer.
+	}
+	if len(stack.bytes)%2 != 0 || len(stack.bytes) > x86ResultValueStackLimit(arch) ||
+		!stack.pointerCellsBounded(arch) ||
+		stack.refinable != nil && len(stack.refinable) != len(stack.bytes) ||
+		stack.correlation != nil && (arch != "386" || len(stack.correlation.bytes) != len(stack.bytes)) {
+		return false, true
+	}
+	if arch == "amd64" && (len(stack.bytes)%8 != 0 || stack.wordCells>>uint(len(stack.bytes)/8) != 0) {
+		return false, true
+	}
+	push := spec.mode == amd64StackPushValue || spec.mode == amd64StackPushFlags
+	if push {
+		bits := ^uint64(0)
+		pointer := false
+		if spec.mode == amd64StackPushValue {
+			arg := ins.Args[0]
+			if x86SegmentRegisterOperand(arg) {
+				return false, true
+			}
+			if arg.Kind == OpReg {
+				index, _, valid := x86ResultGP(arg.Reg, width, arch)
+				if !valid {
+					return false, true
+				}
+				pointer = width == x86ResultPointerWord(arch) && state.pointerGP[index]
+				// This is a bit-preserving private copy, not a numerical use.
+				// Retain only independently known bytes; narrow virtual slots
+				// zero-extend exactly as the paired existing emitter does.
+				bits = ^uint64(0) << uint(8*width)
+				for offset := int64(0); offset < width; offset++ {
+					if !pointer && state.gp[index]&(1<<uint(offset)) != 0 {
+						bits |= uint64(255) << uint(8*offset)
+					}
+				}
+			} else if x86AbsoluteRelocationSource(arg, arch, spec.bits) {
+				// Copy the actual relocation address as opaque bits. Its
+				// numerical value and every pointer/storage role remain unknown.
+				bits = ^uint64(0) << uint(8*width)
+			} else if !x86ResultRead(arg, width, state, owned, arch) {
+				return false, true
+			}
+		} else {
+			for index, physical := range []uint{0, 2, 4, 6, 7, 11} {
+				if state.flags&(1<<uint(index)) == 0 {
+					bits &^= 1 << physical
+				}
+			}
+			if state.direction == x86ResultDirectionUnknown {
+				bits &^= 1 << 10
+			}
+			if !stack.id && spec.bits > 16 {
+				bits &^= 1 << 21
+			}
+		}
+		if state.shapeOnly {
+			return true, true
+		}
+		if len(stack.bytes) > x86ResultValueStackLimit(arch)-storage {
+			return false, true
+		}
+		x86ResultFlagsStackPush(stack, bits, storage, spec.mode == amd64StackPushFlags)
+		if arch == "amd64" && width == 2 {
+			stack.wordCells |= uint64(1) << uint(len(stack.bytes)/8)
+		}
+		if spec.mode == amd64StackPushFlags && stack.refinable == nil {
+			stack.refinable = make([]uint8, len(stack.bytes))
+			copy(stack.refinable, stack.bytes)
+		}
+		for index := storage - 1; index >= 0; index-- {
+			initialized := uint8(bits >> uint(8*index))
+			if stack.refinable != nil {
+				eligible := initialized
+				if spec.mode == amd64StackPushFlags {
+					const modeledFlags = uint64(0x200cff)
+					eligible &= uint8(modeledFlags >> uint(8*index))
+				}
+				stack.refinable = append(stack.refinable, eligible)
+			}
+			stack.bytes = append(stack.bytes, initialized)
+		}
+		if pointer {
+			stack.markPointerCell(len(stack.bytes))
+		}
+		return true, true
+	}
+	bits := ^uint64(0)
+	pointer := false
+	refinable := bits
+	var origins [32]uint8
+	if !state.shapeOnly {
+		if len(stack.bytes) < storage {
+			return false, true
+		}
+		if arch == "amd64" {
+			cell := uint64(1) << uint(len(stack.bytes)/8-1)
+			if (stack.wordCells&cell != 0) != (width == 2) {
+				return false, true // Partial native pops need a separate byte-accurate emitter.
+			}
+			stack.wordCells &^= cell
+		}
+		pointer = width == x86ResultPointerWord(arch) && stack.pointerCell(len(stack.bytes))
+		stack.revokePointerCells(len(stack.bytes)-storage, len(stack.bytes), int(x86ResultPointerWord(arch)))
+		bits = 0
+		refinable = 0
+		for index := 0; index < storage; index++ {
+			position := len(stack.bytes) - 1 - index
+			bits |= uint64(stack.bytes[position]) << uint(8*index)
+			eligible := stack.bytes[position]
+			if stack.refinable != nil {
+				eligible &= stack.refinable[position]
+			}
+			refinable |= uint64(eligible) << uint(8*index)
+		}
+		origins = x86ResultFlagsStackPop(stack, storage)
+		if stack.refinable != nil {
+			stack.refinable = stack.refinable[:len(stack.bytes)-storage]
+			if len(stack.refinable) == 0 {
+				stack.refinable = nil
+			}
+		}
+		stack.bytes = stack.bytes[:len(stack.bytes)-storage]
+	}
+	if spec.mode == amd64StackPopFlags {
+		if stack.correlation != nil && !state.shapeOnly {
+			copy(stack.correlation.flags[:spec.bits], origins[:spec.bits])
+		}
+		state.flags = 0
+		for index, physical := range []uint{0, 2, 4, 6, 7, 11} {
+			if bits&(1<<physical) != 0 {
+				state.flags |= 1 << uint(index)
+			}
+		}
+		state.direction = x86ResultDirectionUnknown
+		if bits&(1<<10) != 0 {
+			state.direction = x86ResultDirectionEither
+		}
+		if spec.bits > 16 {
+			stack.id = bits&(1<<21) != 0
+		}
+		return true, true
+	}
+	arg := ins.Args[0]
+	if x86SegmentRegisterOperand(arg) {
+		return false, true
+	}
+	if arg.Kind == OpReg {
+		index, mask, valid := x86ResultGP(arg.Reg, width, arch)
+		if !valid {
+			return false, true
+		}
+		var initialized uint8
+		for b := int64(0); b < width; b++ {
+			if uint8(bits>>uint(8*b)) == 0xff {
+				initialized |= 1 << uint(b)
+			}
+		}
+		state.gp[index] = state.gp[index]&^mask | initialized
+		if width == 4 {
+			state.gp[index] |= 0xf0
+		}
+		state.pointerGP[index], state.callerAddressGP[index] = pointer, false
+		state.canonicalGP[index] &^= mask
+		// Preserve partial-bit knowledge for exactly the next instruction.
+		// Whole known bytes outside a narrow POP remain independently known.
+		known := uint64(0)
+		for b := int64(0); b < width; b++ {
+			known |= uint64(uint8(refinable>>uint(8*b))) << uint(8*b)
+		}
+		for b := width; b < 8; b++ {
+			if state.gp[index]&(1<<uint(b)) != 0 {
+				known |= uint64(0xff) << uint(8*b)
+			}
+		}
+		state.gpBits = x86ResultGPBits{bits: known, register: index, valid: true, fromStack: true}
+		if stack.correlation != nil {
+			stack.correlation.popped = origins
+		}
+		return true, true
+	}
+	for b := int64(0); b < width; b++ {
+		if uint8(bits>>uint(8*b)) != 0xff {
+			return false, true
+		}
+	}
+	if nativeStore && ins.x86NumericalRead == nil && x86OrdinaryNativeMemoryOperand(arg, arch) &&
+		x86ResultIncomingPointerAddressIdentity(arg, state, arch) {
+		return true, true // Only the existing private pop changes; no pointee or later-read fact.
+	}
+	return x86ResultStore(arg, width, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_value_stack_relocation_test.go b/x86_result_value_stack_relocation_test.go
new file mode 100644
index 000000000..342b7f312
--- /dev/null
+++ b/x86_result_value_stack_relocation_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestX86PrivateStackAbsoluteRelocationBitsStayOpaque(t *testing.T) {
+	state := x86ResultState{valueStack: new(x86ResultValueStack), flags: x86ByteFlagsAll,
+		direction: x86ResultDirectionBackward}
+	before := state.clone()
+	push := x86ScalarLaneInstruction(t, "PUSHL $·cell+8(SB)")
+	if !x86ResultTransfer(push, &state, nil, 0, "386") {
+		t.Fatal("complete Go absolute-relocation push lost its private copy role")
+	}
+	if len(state.valueStack.bytes) != 4 || !reflect.DeepEqual(state.valueStack.bytes, []uint8{0, 0, 0, 0}) {
+		t.Fatal("relocation address invented numerical byte values", state.valueStack.bytes)
+	}
+	if state.gp != before.gp || state.pointerGP != before.pointerGP || state.callerAddressGP != before.callerAddressGP ||
+		state.flags != before.flags || state.direction != before.direction {
+		t.Fatal("private address copy changed unrelated state or created pointer authority")
+	}
+	state.gp[0], state.canonicalGP[0], state.pointerGP[0] = 0xff, 0xff, true
+	pop := x86ScalarLaneInstruction(t, "POPL AX")
+	if !x86ResultTransfer(pop, &state, nil, 0, "386") || len(state.valueStack.bytes) != 0 {
+		t.Fatal("balanced opaque address pop was rejected")
+	}
+	if state.gp[0]&0xf != 0 || state.canonicalGP[0]&0xf != 0 || state.pointerGP[0] {
+		t.Fatal("opaque address pop revived numerical, canonical or pointer bytes")
+	}
+}
+
+func TestX86PrivateStackAbsoluteRelocationCannotSupplyValuesOrStorage(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"NUM-result", "func Value() uint32", "MOVL AX,ret+0(FP)"},
+		{"comparison", "func Value() uint32", "TESTL AX,AX\nMOVL $0,BX\nSETEQ BL\nMOVL BX,ret+0(FP)"},
+		{"native-load", "func Value() uint32", "MOVL (AX),BX\nMOVL BX,ret+0(FP)"},
+		{"native-store", "func Value()", "MOVL $7,(AX)"},
+		{"FLAGS", "func Value()", "PUSHL AX\nPOPFL\nSETCS BL"},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(row.name+"/"+api, func(t *testing.T) {
+				args := "0"
+				if row.name == "NUM-result" || row.name == "native-load" || row.name == "comparison" {
+					args = "4"
+				}
+				source := "TEXT ·Value(SB),4,$0-" + args + "\nPUSHL $·cell(SB)\nPOPL AX\n" + row.body + "\nRET\n"
+				ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, "386", "i386-unknown-linux-gnu", api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("a private relocation copy acquired unrelated data/address authority", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_value_stack_test.go b/x86_result_value_stack_test.go
new file mode 100644
index 000000000..19cdb85ee
--- /dev/null
+++ b/x86_result_value_stack_test.go
@@ -0,0 +1,189 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultValueStackFPStatusRoundTripThreeAPIs(t *testing.T) {
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		word, typ, bytes := "Q", "uint64", 8
+		if target.arch == "386" {
+			word, typ, bytes = "L", "uint32", 4
+		}
+		// The typed FP input seeds every modeled status, DF and ID bit. A
+		// numerical result observes the packed flags after a defined writer.
+		source := fmt.Sprintf("TEXT ·roundtrip(SB),4,$0-%d\nPUSH%s seed+0(FP)\nPOPF%s\nMOVL $1,AX\nPOPCNTL AX,BX\nPUSHF%s\nPOP%s CX\nMOV%s CX,ret+%d(FP)\nRET\n",
+			2*bytes, word, word, word, word, word, bytes)
+		declaration := fmt.Sprintf("func roundtrip(seed %s) %s\n", typ, typ)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				x86CPUQueryIRFromDeclaration(t, source, declaration, target.arch, target.triple, api)
+			})
+		}
+	}
+}
+
+func TestX86ResultValueStackPrivateWordTransport(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, bytes := "Q", I64, int64(8)
+		if arch == "386" {
+			word, typ, bytes = "L", I32, 4
+		}
+		source := fmt.Sprintf("TEXT value(SB),4,$0-%d\nPUSH%s value+0(FP)\nPOP%s AX\nMOV%s AX,ret+%d(FP)\nRET\n", 2*bytes, word, word, word, bytes)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		sig := FuncSig{Name: "value", Ret: typ, Args: []LLVMType{typ}, Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+			Results: []FrameSlot{{Offset: bytes, Type: typ, Index: 0, Field: -1}},
+		}}
+		t.Run(arch, func(t *testing.T) {
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86ResultValueStackCompleteWidthsAndBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, bytes := "Q", I64, int64(8)
+		if arch == "386" {
+			word, typ, bytes = "L", I32, 4
+		}
+		for _, row := range []struct {
+			name, body string
+			valid      bool
+		}{
+			{"word", "PUSHW value+0(FP)\nPOPW AX\nMOVW AX,ret+@N(FP)\nMOVW $0,ret+@N2(FP)", true},
+			{"flags-word", "PUSHW value+0(FP)\nPOPFW\nPUSHFW\nPOPW AX\nMOVW AX,ret+@N(FP)\nMOVW $0,ret+@N2(FP)", true},
+			{"immediate", "PUSH@W $7\nPOP@W AX\nMOV@W AX,ret+@N(FP)", true},
+			{"flags", "PUSH@W value+0(FP)\nPOPF@W\nPUSHF@W\nPOP@W AX\nMOV@W AX,ret+@N(FP)", true},
+			{"nested", "PUSH@W value+0(FP)\nPUSH@W $1\nPOP@W AX\nPOP@W DX\nMOV@W DX,ret+@N(FP)", true},
+			{"underflow", "POP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"unknown-input", "PUSH@W AX\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"unwritten-fp", "PUSH@W ret+@N(FP)\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"unknown-flags", "PUSHF@W\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"unknown-df", "MOVL $1,AX\nCMPL AX,AX\nPUSHFW\nPOPW AX\nMOVW AX,ret+@N(FP)\nMOVW $0,ret+@N2(FP)", false},
+			{"partial-input", "MOVB $1,AX\nPUSHW AX\nPOPW AX\nMOV@W AX,ret+@N(FP)", false},
+			{"unbalanced", "PUSH@W value+0(FP)\nMOV@W $1,ret+@N(FP)", false},
+			{"overflow", strings.Repeat("PUSH@W $1\n", 64) + strings.Repeat("POP@W AX\n", 64) + "MOV@W $1,ret+@N(FP)", false},
+			{"native-read", "PUSH@W (AX)\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"native-write", "PUSH@W $1\nPOP@W (AX)\nMOV@W $1,ret+@N(FP)", false},
+			{"stack-address", "PUSH@W SP\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+			{"segment", "PUSHW FS\nPOPW AX\nMOV@W AX,ret+@N(FP)", false},
+			{"input-write", "PUSH@W $1\nPOP@W value+0(FP)\nMOV@W $1,ret+@N(FP)", false},
+			{"width-mode", "PUSHL $1\nPOPQ AX\nMOV@W AX,ret+@N(FP)", false},
+			{"depth-join", "MOVL $1,AX\nCMPL AX,AX\nJE join\nPUSH@W $1\njoin:\nPOP@W AX\nMOV@W AX,ret+@N(FP)", false},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				body := strings.NewReplacer("@W", word, "@N2", fmt.Sprint(bytes+2), "@N", fmt.Sprint(bytes)).Replace(row.body)
+				if row.valid && strings.Contains(body, "MOVW $0,") && arch == "amd64" {
+					body += fmt.Sprintf("\nMOVL $0,ret+%d(FP)", bytes+4)
+				}
+				source := fmt.Sprintf("TEXT value(SB),4,$0-%d\n%s\nRET\n", 2*bytes, body)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Name: "value", Ret: typ, Args: []LLVMType{typ}, Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: bytes, Type: typ, Index: 0, Field: -1}},
+				}}
+				err = CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch)
+				if row.valid && err != nil || !row.valid && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("valid=%v: %v\n%s", row.valid, err, source)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultValueStackPackedBitDefinedness(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word := "Q"
+		if arch == "386" {
+			word = "L"
+		}
+		file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\nPUSHF"+word+"\nPOP"+word+" AX\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		for flags := uint8(0); flags < 64; flags++ {
+			for extra := 0; extra < 4; extra++ {
+				t.Run(fmt.Sprintf("%s/status=%02x/DF-ID=%d", arch, flags, extra), func(t *testing.T) {
+					state := x86ResultState{flags: flags, valueStack: &x86ResultValueStack{id: extra&2 != 0}}
+					if extra&1 != 0 {
+						state.direction = x86ResultDirectionEither
+					}
+					for _, ins := range file.Funcs[0].Instrs[1:3] {
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("packed partial bit transport failed", ins.Raw)
+						}
+					}
+					want := uint8(0xf8) // Constant bits, plus r32 zero-extension.
+					if flags&0x1f == 0x1f {
+						want |= 1 // CF/PF/AF/ZF/SF share packed byte zero.
+					}
+					if flags&0x20 != 0 && extra&1 != 0 {
+						want |= 2 // OF and the separate DF share byte one.
+					}
+					if extra&2 != 0 {
+						want |= 4 // ID alone affects byte two.
+					}
+					if state.gp[0] != want || state.flags != flags || len(state.valueStack.bytes) != 0 {
+						t.Fatalf("packed flags invented bytes: got=%02x want=%02x flags=%02x", state.gp[0], want, state.flags)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultValueStackOpaqueAndPhysicalBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, typ, bytes := "Q", I64, int64(8)
+		if arch == "386" {
+			word, typ, bytes = "L", I32, 4
+		}
+		source := fmt.Sprintf("TEXT f(SB),4,$0-%d\nPUSH%s x+0(FP)\nPOP%s AX\nMOV%s AX,ret+%d(FP)\nRET\n", 2*bytes, word, word, word, bytes)
+		for _, role := range []string{"pointer", "partial-fp", "encoded", "raw", "address-size", "segment-prefix"} {
+			t.Run(arch+"/"+role, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Name: "f", Ret: typ, Args: []LLVMType{typ}, Frame: FrameLayout{
+					Params:  []FrameSlot{{Offset: 0, Type: typ, Index: 0, Field: -1}},
+					Results: []FrameSlot{{Offset: bytes, Type: typ, Index: 0, Field: -1}},
+				}}
+				ins := &file.Funcs[0].Instrs[1]
+				switch role {
+				case "pointer":
+					sig.Args[0], sig.Frame.Params[0].Type = Ptr, Ptr
+				case "partial-fp":
+					sig.Args[0], sig.Frame.Params[0].Type = I8, I8
+				case "encoded":
+					ins.x86Encoded = true
+				case "raw":
+					ins.x86SourceRaw = &x86SourceRawInstruction{}
+				case "address-size":
+					ins.x86AddressBits = 32
+				case "segment-prefix":
+					ins.x86SegmentPrefix = 0x64
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("physical or unknown source acquired private numerical storage", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_value_stack_transport_test.go b/x86_result_value_stack_transport_test.go
new file mode 100644
index 000000000..0835305da
--- /dev/null
+++ b/x86_result_value_stack_transport_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ValueStackTransportProgram(arch string) (string, string, []string) {
+	word := "Q"
+	if arch == "386" {
+		word = "L"
+	}
+	registers := strings.Fields("AX BX CX DX SI DI")
+	if arch == "amd64" {
+		registers = append(registers, "R8", "R15")
+	} else {
+		registers = append(registers, "BP")
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for index, register := range registers {
+		name := fmt.Sprintf("OpaqueTransport%d", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\nPUSH%s %s\nMOVL $13,%s\nPOP%s %s\nMOVL $7,AX\nMOVL AX,ret+0(FP)\nRET\n",
+			name, word, register, register, word, register)
+		declarations.WriteString("func " + name + "() uint32\n")
+		names = append(names, name)
+	}
+	source.WriteString("TEXT ·PartialTransport(SB),4,$0-4\nMOVB $7,BL\nPUSH" + word + " BX\nPOP" + word + " AX\nMOVBLZX AL,AX\nMOVL AX,ret+0(FP)\nRET\n")
+	declarations.WriteString("func PartialTransport() uint32\n")
+	names = append(names, "PartialTransport")
+	return source.String(), declarations.String(), names
+}
+
+func TestX86ValueStackPureRegisterTransportKeepsExactAvailability(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86ValueStackTransportProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("pure saved/partial GP transport requires no unknown numerical observation", err)
+					}
+					x86CompactExpandRequireAllDefinitions(t, ir, names)
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ValueStackRegisterTransportCannotInventBitsOrPointerRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := "Q"
+		if target.arch == "386" {
+			word = "L"
+		}
+		for _, row := range []struct{ name, body string }{
+			{"unknown-byte", "PUSH" + word + " BX\nPOP" + word + " AX\nMOVBLZX AL,AX"},
+			{"unknown-other-byte", "MOVB $7,BL\nPUSH" + word + " BX\nPOP" + word + " AX\nMOVBLZX AH,AX"},
+			{"unknown-address", "PUSH" + word + " BX\nPOP" + word + " AX\nMOVL (AX),AX"},
+			{"unknown-stack-pointer", "PUSH" + word + " BX\nPOP" + word + " SP\nMOVL $7,AX"},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-4\n" + row.body + "\nMOVL AX,ret+0(FP)\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("private transport invented a byte, pointee or physical SP role", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ValueStackAMD64FrameRegisterNeedsItsSeparateRole(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Mode32 BP is an ordinary GP; the positive matrix covers it.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			for _, register := range []string{"SP", "BP"} {
+				source := "TEXT ·Value(SB),4,$0-4\nPUSHQ " + register + "\nPOPQ AX\nMOVL $7,AX\nMOVL AX,ret+0(FP)\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("private numerical copy acquired a physical stack/frame role", register, api, err)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_value_stack_width_identity_test.go b/x86_result_value_stack_width_identity_test.go
new file mode 100644
index 000000000..9a0684179
--- /dev/null
+++ b/x86_result_value_stack_width_identity_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// AMD64's private lowering currently uses one virtual cell per PUSH. Go's
+// actual W/Q operations move SP by two/eight bytes. A partial native pop must
+// not consume an entire private cell or invent zero bytes for a later wide pop.
+func TestX86ValueStackMixedNativeWidthsNeedByteAccurateStorage(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue
+		}
+		for _, row := range []struct {
+			name, body string
+		}{
+			{"wide-first", "PUSHQ value+0(FP)\nPOPW AX\nPUSHW $9\nPOPQ BX\nMOVQ BX,ret+8(FP)"},
+			{"narrow-first", "PUSHW $7\nPOPQ AX\nPUSHQ $9\nPOPW BX\nMOVQ $1,ret+8(FP)"},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-16\n" + row.body + "\nRET\n"
+				// Both sources balance their actual total SP delta. The first
+				// recombines bytes; the second can overwrite the entry word.
+				// Keep actual Go objects, but never execute the unsafe source.
+				for _, result := range []bool{false, true} {
+					text, declaration := source, "func Value(value uint64) uint64"
+					if !result {
+						text = strings.ReplaceAll(text, "$0-16", "$0-8")
+						text = strings.ReplaceAll(text, "MOVQ BX,ret+8(FP)\n", "")
+						text = strings.ReplaceAll(text, "MOVQ $1,ret+8(FP)\n", "")
+						declaration = "func Value(value uint64)"
+					}
+					x86LEAActualTargetGoObject(t, "amd64", target.triple, text)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, text, declaration, "amd64", target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Errorf("%s result=%v changed native byte-stack semantics into virtual-cell semantics: %v", api, result, err)
+						}
+					}
+				}
+			})
+		}
+		// Different widths may nest when each cell is consumed whole. This
+		// retains the original value without granting a physical SP alias.
+		t.Run(target.triple+"/nested-complete-cells", func(t *testing.T) {
+			const source = "TEXT ·Value(SB),4,$0-16\nPUSHQ value+0(FP)\nPUSHW $9\nPOPW AX\nPOPQ BX\nMOVQ BX,ret+8(FP)\nRET\n"
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source,
+					"func Value(value uint64) uint64", "amd64", target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete nested cells lost their independent numerical input", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ValueStackCellWidthsKeepCloneAndJoinIdentity(t *testing.T) {
+	for _, widths := range []struct{ left, right string }{
+		{"Q", "Q"}, {"W", "W"}, {"Q", "W"}, {"W", "Q"},
+	} {
+		for _, flags := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s-%s/flags=%v", widths.left, widths.right, flags), func(t *testing.T) {
+				makeState := func(width string) x86ResultState {
+					state := x86ResultState{valueStack: &x86ResultValueStack{id: true},
+						flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					text := "PUSH" + width + " $7"
+					if flags {
+						text = "PUSHF" + width
+					}
+					ins := x86ScalarLaneInstruction(t, text)
+					if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatal("independent complete immediate push rejected")
+					}
+					return state
+				}
+				left, right := makeState(widths.left), makeState(widths.right)
+				clone := left.clone()
+				pop := x86ScalarLaneInstruction(t, "POP"+widths.left+" AX")
+				if !x86ResultTransfer(pop, &clone, nil, 0, "amd64") || len(left.valueStack.bytes) != 8 {
+					t.Fatal("a cloned pop changed the original private cell")
+				}
+				replacement := "Q"
+				if widths.left == "Q" {
+					replacement = "W"
+				}
+				push := x86ScalarLaneInstruction(t, "PUSH"+replacement+" $9")
+				if !x86ResultTransfer(push, &clone, nil, 0, "amd64") {
+					t.Fatal("a consumed cell could not be independently reused")
+				}
+				original := left.clone()
+				if !x86ResultTransfer(pop, &original, nil, 0, "amd64") {
+					t.Fatal("a cloned cell replacement changed the original source width")
+				}
+				merged := left.intersect(right)
+				got := x86ResultTransfer(pop, &merged, nil, 0, "amd64")
+				if got != (widths.left == widths.right) {
+					t.Fatal("equal virtual depth erased a native cell-width distinction", widths, got)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_vector_arithmetic.go b/x86_result_vector_arithmetic.go
new file mode 100644
index 000000000..6f4e04ba3
--- /dev/null
+++ b/x86_result_vector_arithmetic.go
@@ -0,0 +1,26 @@
+package plan9asm
+
+// Numerical result effects consume the same forms as the lowerer. Legacy
+// arithmetic keeps its existing typed consumer; no caller or native-memory
+// permission follows from knowing the bytes of a vector arithmetic result.
+func x86ResultVectorArithmeticStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultVectorArithmeticStepWithRead(ins, state, owned, arch, false)
+}
+
+// Only the paired emitter may consume a continued native read. The complete
+// tuple, mask, lane dependencies and wider aliases keep their existing rules.
+func x86ResultVectorArithmeticStepWithRead(ins Instr, state *x86ResultState, owned []bool,
+	arch string, nativeRead bool) (bool, bool) {
+	parsed, known, err := x86PackedArithmeticProperties(ins.Op, ins, arch, x86PackedArithmeticAdd|x86PackedArithmeticSubtract)
+	if !known {
+		return false, false
+	}
+	form, bits := parsed.x86PackedBinaryForm, parsed.spec.laneBits
+	if err != nil {
+		return false, true
+	}
+	if form.legacy {
+		return false, false
+	}
+	return x86ResultPackedLaneArithmeticStepWithRead(ins, form, bits, state, owned, arch, nativeRead), true
+}
diff --git a/x86_result_vector_arithmetic_native_test.go b/x86_result_vector_arithmetic_native_test.go
new file mode 100644
index 000000000..89812282e
--- /dev/null
+++ b/x86_result_vector_arithmetic_native_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// The independent Go-table inventory already checks all sixteen operations,
+// every encoder row and its individual broadcast/zeroing attributes. Reuse
+// those names, not production-map keys, for the missing native continuation.
+func x86NativeVectorArithmeticRows(arch string, start, end int) []struct{ op, bank, mode string } {
+	var names, broadcasts []string
+	for _, member := range x86ResultVectorArithmeticNames[start:end] {
+		names = append(names, member.name)
+		if member.bits >= 32 {
+			broadcasts = append(broadcasts, member.name+".BCST")
+		}
+	}
+	rows := x86FixedBinaryValueRows(arch, names)
+	return append(rows, x86FixedBinaryValueRows(arch, broadcasts)...)
+}
+
+func TestX86VectorArithmeticPairedNativeReadCompleteFamily(t *testing.T) {
+	for batch, name := range []string{"add", "subtract"} {
+		t.Run(name, func(t *testing.T) {
+			x86FixedBinaryCompleteFamilyObjects(t, func(arch string) []struct{ op, bank, mode string } {
+				return x86NativeVectorArithmeticRows(arch, batch*8, (batch+1)*8)
+			}, 90, 30)
+		})
+	}
+}
+
+func TestX86VectorArithmeticPairedNativeReadCannotBorrowSourceFacts(t *testing.T) {
+	x86FixedBinaryNativeInputBoundaries(t, func(arch string) []struct{ op, bank, mode string } {
+		return x86NativeVectorArithmeticRows(arch, 0, 16)
+	})
+
+	// Keep the existing KMOV whole-source obligation even with an unused mask
+	// and no result. Its initialized mask cannot supply an incoming address.
+	for _, member := range x86ResultVectorArithmeticNames {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),AX\n"+
+				"MOVL $0,CX\nKMOVD CX,K1\nVPXORD Z1,Z1,Z1\n%s (AX),%s1,%s2\nRET\n", member.name, bank, bank)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)",
+					"amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+					t.Fatal("initialized Void native arithmetic rejected", member.name, bank, api, err)
+				}
+				for _, replacement := range []string{"MOVL $1,AX", "MOVQ p+0(FP),DI"} {
+					bad := strings.Replace(source, "MOVQ p+0(FP),AX", replacement, 1)
+					ir, err := x86ScalarFPBitViewAPI(t, bad, "func Value(p *[64]byte)",
+						"amd64", "x86_64-unknown-linux-gnu", api)
+					if replacement == "MOVL $1,AX" {
+						if err != nil || x86NumericNativeVolatileReadBytes(t, ir) != map[string]int{"X": 16, "Y": 32, "Z": 64}[bank] {
+							t.Fatal("Void arithmetic lost its initialized NUM native tuple", member.name, bank, api, err)
+						}
+						x86RequireNumericNativeSourceContext(t, bad, "func Value(p *[64]byte)", "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("Void native arithmetic invented address context", member.name, bank, replacement, api, err)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_vector_arithmetic_test.go b/x86_result_vector_arithmetic_test.go
new file mode 100644
index 000000000..29252f69e
--- /dev/null
+++ b/x86_result_vector_arithmetic_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent inventory from Go's complete AVPADD/AVPSUB encoder rows.
+// Do not derive the expected family or byte dependencies from production specs.
+var x86ResultVectorArithmeticNames = []struct {
+	name string
+	bits int
+}{
+	{"VPADDB", 8}, {"VPADDW", 16}, {"VPADDD", 32}, {"VPADDQ", 64},
+	{"VPADDSB", 8}, {"VPADDSW", 16}, {"VPADDUSB", 8}, {"VPADDUSW", 16},
+	{"VPSUBB", 8}, {"VPSUBW", 16}, {"VPSUBD", 32}, {"VPSUBQ", 64},
+	{"VPSUBSB", 8}, {"VPSUBSW", 16}, {"VPSUBUSB", 8}, {"VPSUBUSW", 16},
+}
+
+func TestX86VectorArithmeticIndependentResultConsumers(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, op := range x86ResultVectorArithmeticNames {
+				for _, bank := range []string{"X", "Y", "Z"} {
+					name := fmt.Sprintf("Arithmetic%d%s", index, bank)
+					fmt.Fprintf(&declarations, "func %s(a,b uint64) uint32\n", name)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-20\nVZEROALL\nMOVQ a+0(FP),X0\nMOVQ b+8(FP),X1\n", name)
+					fmt.Fprintf(&source, "%s %s0,%s1,%s1\nPEXTRD $0,X1,AX\nMOVL AX,ret+16(FP)\nRET\n", op.name, bank, bank, bank)
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatalf("%s complete vector arithmetic lacks result effects: %v", api, err)
+				}
+				x86ResultInitializationObject(t, llc, target.triple, ir, "vector-arithmetic-"+api)
+				x86ResultInitializationObject(t, llc, target.triple, x86MulDivRoundOptimize(t, ir), "vector-arithmetic-"+api+"-O2")
+			}
+		})
+	}
+}
+
+func TestX86VectorArithmeticSparseResultBytes(t *testing.T) {
+	for _, op := range x86ResultVectorArithmeticNames {
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for masking := 0; masking < 3; masking++ {
+				row := op.name
+				if masking == 2 {
+					row += ".Z"
+				}
+				row += " " + bank + "0," + bank + "1"
+				if masking != 0 {
+					row += ",K1"
+				}
+				row += "," + bank + "2"
+				ins := x86ScalarLaneInstruction(t, row)
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						initial := [3]uint64{^uint64(0), ^uint64(0), ^uint64(0)}
+						if missing >= 0 {
+							initial[input] &^= uint64(1) << uint(missing)
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						for index, value := range initial {
+							state.writeVector(index, 64, value, false)
+						}
+						state.masks[1] = true
+						if !x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+							t.Fatal("missing numerical byte consumer", row)
+						}
+						var want uint64
+						for output := 0; output < 64; output++ {
+							known := true
+							if output < width {
+								start := output / (op.bits / 8) * (op.bits / 8)
+								for source := start; source < start+op.bits/8; source++ {
+									known = known && initial[0]>>uint(source)&1 != 0 && initial[1]>>uint(source)&1 != 0
+								}
+								if masking == 1 {
+									known = known && initial[2]>>uint(output)&1 != 0
+								}
+							}
+							if known {
+								want |= uint64(1) << uint(output)
+							}
+						}
+						if state.vectorBytes(2) != want || state.flags != x86ByteFlagsAll ||
+							state.vectorBytes(0) != initial[0] || state.vectorBytes(1) != initial[1] {
+							t.Fatalf("%s input=%d missing=%d: got=%x want=%x", row, input, missing, state.vectorBytes(2), want)
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86VectorArithmeticResultMemoryAndMaskBoundaries(t *testing.T) {
+	for _, op := range x86ResultVectorArithmeticNames {
+		for _, width := range []int{16, 32, 64} {
+			bank := map[int]string{16: "X", 32: "Y", 64: "Z"}[width]
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && op.bits < 32 {
+					continue
+				}
+				row, bytes := op.name, width
+				if broadcast {
+					row, bytes = row+".BCST", op.bits/8
+				}
+				row += ".Z value+0(FP)," + bank + "1,K1," + bank + "2"
+				ins := x86ScalarLaneInstruction(t, row)
+				for missing := -1; missing < 64; missing++ {
+					for _, maskKnown := range []bool{false, true} {
+						state := x86ResultState{fp: make([]bool, 64)}
+						owned := make([]bool, 64)
+						for i := range owned {
+							owned[i], state.fp[i] = true, i != missing
+						}
+						state.writeVector(1, 64, ^uint64(0), false)
+						state.masks[1] = maskKnown
+						accepted := x86ResultTransfer(ins, &state, owned, 64, "amd64")
+						want := maskKnown && (missing < 0 || missing >= bytes)
+						if accepted != want || accepted && state.vectorBytes(2) != ^uint64(0) || len(ins.x86CallerMemory) != 0 {
+							t.Fatal("mask/tuple invented bytes or caller permission", row, missing, maskKnown, accepted)
+						}
+					}
+				}
+			}
+		}
+		for _, source := range []string{"(AX)", "·unknown(SB)", "value-1(FP)"} {
+			ins := x86ScalarLaneInstruction(t, op.name+" "+source+",X1,X2")
+			state := x86ResultState{}
+			state.xmm[1], state.pointerGP[0] = 0xffff, true
+			if x86ResultTransfer(ins, &state, nil, 0, "amd64") {
+				t.Fatal("unproved memory acquired numerical authority", op.name, source)
+			}
+		}
+	}
+}
+
+func TestX86VectorArithmeticSaturatingAddNativeReadEffects(t *testing.T) {
+	for _, op := range []string{"VPADDSB", "VPADDSW", "VPADDUSB", "VPADDUSW"} {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			row := op + ".Z (DX)," + bank + "0,K1," + bank + "1"
+			source := "TEXT ·view(SB),4,$0-16\nMOVQ p+0(FP),DX\nMOVQ mask+8(FP),AX\nKMOVQ AX,K1\nVZEROALL\n" + row + "\nRET\n"
+			t.Run(row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func view(p *[64]byte, mask uint64)\n", "amd64", "x86_64-unknown-linux-gnu", "Go")
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					if !strings.Contains(text, "load volatile") || !strings.Contains(text, "br i1") {
+						t.Fatal("dead masked arithmetic lost conditional native reads")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86VectorArithmeticSaturatingAddCompleteForms(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"VPADDSB", "VPADDSW", "VPADDUSB", "VPADDUSW"} {
+			t.Run(target.triple+"/"+op, func(t *testing.T) {
+				var source, declarations strings.Builder
+				count := 0
+				for _, bank := range []string{"X", "Y", "Z"} {
+					for _, input := range []string{bank + "0", "value+0(FP)", "(AX)", "8(AX)(CX*2)", "·data(SB)"} {
+						for masking := 0; masking < 3; masking++ {
+							if target.arch == "386" && masking != 0 {
+								continue
+							}
+							row := op
+							if masking == 2 {
+								row += ".Z"
+							}
+							row += " " + input + "," + bank + "1"
+							if masking != 0 {
+								row += ",K7"
+							}
+							row += "," + bank + "2"
+							fmt.Fprintf(&declarations, "func Saturating%d(value [64]byte)\n", count)
+							fmt.Fprintf(&source, "TEXT ·Saturating%d(SB),4,$0-64\n%s\nRET\n", count, row)
+							count++
+						}
+					}
+				}
+				if count > 64 || target.arch == "amd64" && count != 45 || target.arch == "386" && count != 15 {
+					t.Fatal("incomplete or oversized form batch", count)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				file := mustParseX86RawReturn(t, source.String())
+				pkg := mustGoPackage(t, "arithmeticformats", "package arithmeticformats\n"+declarations.String())
+				resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+				signatures, err := goSigsForAsmFile(pkg, file, resolve, target.arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// Every original form and Go object remains. These unbound
+				// functions lack vectors, masks and native addresses; syntax
+				// objects cannot grant their missing public ABI0 inputs.
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source.String(), pkg, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unbound saturating format invented source inputs", api, err)
+					}
+				}
+				ir := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_result_vector_compare.go b/x86_result_vector_compare.go
new file mode 100644
index 000000000..2803c74b9
--- /dev/null
+++ b/x86_result_vector_compare.go
@@ -0,0 +1,110 @@
+package plan9asm
+
+// Legacy/VEX comparisons write vector lanes; EVEX comparisons write K bits.
+// Their common operand grammar must not erase these different destination
+// roles. Complete numerical inputs confer no native/caller memory permission.
+func x86ResultVectorCompareStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	return x86ResultVectorCompareStepWithRead(ins, state, owned, arch, false)
+}
+
+func x86ResultVectorCompareStepWithRead(ins Instr, state *x86ResultState, owned []bool, arch string, nativeRead bool) (bool, bool) {
+	form, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch)
+	namedIntegerCompare := known
+	if !known {
+		immediate, recognized, immediateErr := x86ImmediatePackedCompareProperties(ins.Op, ins, arch)
+		form, known, err = immediate.x86PackedIntegerCompareForm, recognized, immediateErr
+	}
+	if !known {
+		return false, false
+	}
+	if err != nil || form.mmx {
+		return false, true
+	}
+	// Only the named lowering continuation may project complete result lanes.
+	// Raw encodings call the strict transfer below, even after their local
+	// provenance handoff; standalone queries and K results remain all-input.
+	if nativeRead && namedIntegerCompare && !form.maskResult && form.mask < 0 && x86ResultNamedPredicateInstruction(ins) {
+		return x86ResultNamedCompareLaneTransfer(ins, form, state, owned, arch)
+	}
+	return x86ResultVectorCompareTransfer(ins, form, state, owned, arch, nativeRead)
+}
+
+func x86ResultNamedCompareLaneTransfer(ins Instr, form x86PackedIntegerCompareForm,
+	state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	required := x86CallerVectorByteMask(int64(form.byteWidth))
+	defined := required
+	if !form.identicalVectorInputs(ins) {
+		for _, input := range []int{form.first, form.second} {
+			operand := ins.Args[input]
+			if input == form.first {
+				operand = form.source
+			}
+			if input == form.memory {
+				// Partial result knowledge never reduces the original memory
+				// access, including its extent and actual address obligations.
+				if !x86ResultReadWithNativeContinuation(ins, operand, int64(form.memoryBytes), state, owned, arch, true) {
+					return false, true
+				}
+				continue
+			}
+			index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+			if !valid {
+				return false, true
+			}
+			defined &= state.vectorBytes(index)
+		}
+	}
+	// Integer EQ/GT depends on every bit of its own lane, not other lanes.
+	// One unknown byte therefore invalidates that entire result lane only.
+	laneBytes := form.spec.laneBits / 8
+	for offset := 0; offset < form.byteWidth; offset += laneBytes {
+		lane := x86CallerVectorByteMask(int64(laneBytes)) << uint(offset)
+		if defined&lane != lane {
+			defined &^= lane
+		}
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, defined, form.legacy)
+	return true, true
+}
+
+// A validated physical form survives the lowering-local provenance handoff.
+// Do not reparse it under named mode32 operand limits after that handoff.
+func x86ResultVectorCompareTransfer(ins Instr, form x86PackedIntegerCompareForm, state *x86ResultState,
+	owned []bool, arch string, nativeRead bool) (bool, bool) {
+	if form.mask >= 0 {
+		index, valid := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !valid || !state.masks[index] {
+			return false, true
+		}
+	}
+	required := x86CallerVectorByteMask(int64(form.byteWidth))
+	for _, input := range []int{form.first, form.second} {
+		if form.identicalVectorInputs(ins) {
+			break // Same-view integer identities need no incoming numerical bytes.
+		}
+		operand := ins.Args[input]
+		if input == form.first {
+			operand = form.source
+		}
+		if input == form.memory {
+			if !x86ResultReadWithNativeContinuation(ins, operand, int64(form.memoryBytes), state, owned, arch, nativeRead) {
+				return false, true
+			}
+			continue
+		}
+		index, valid := amd64VectorRegisterIndex(operand.Reg, form.byteWidth)
+		if !valid || state.vectorBytes(index)&required != required {
+			return false, true
+		}
+	}
+	destination := ins.Args[form.destination].Reg
+	if form.maskResult {
+		index, _ := amd64ParseKReg(destination)
+		state.masks[index] = true
+	} else {
+		index, _ := amd64VectorRegisterIndex(destination, form.byteWidth)
+		state.writeVector(index, form.byteWidth, required, form.legacy)
+	}
+	return true, true
+}
diff --git a/x86_result_vector_compare_test.go b/x86_result_vector_compare_test.go
new file mode 100644
index 000000000..1d74c44a8
--- /dev/null
+++ b/x86_result_vector_compare_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ResultVectorCompareCompleteDestinationRoles(t *testing.T) {
+	for _, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ", "PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ"} {
+		vector := "V" + strings.ReplaceAll(op, "L", "D")
+		rows := []string{op + " X0,X2", vector + " X0,X1,X2", vector + " Y0,Y1,Y2"}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			rows = append(rows, fmt.Sprintf("%s %s0,%s1,K0", vector, bank, bank), fmt.Sprintf("%s %s0,%s1,K1,K0", vector, bank, bank))
+		}
+		for _, row := range rows {
+			t.Run(row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "amd64", "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", true)
+				state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: true}}
+				state.writeVector(0, 64, ^uint64(0), false)
+				state.writeVector(1, 64, ^uint64(0), false)
+				state.xmm[2] = 0xffff
+				state.vectorUpper[2] = 1 << 60
+				if !x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") {
+					t.Fatal("typed compare destination has no closed numerical effect")
+				}
+				want := uint64(0xffff | 1<<60)
+				if strings.HasSuffix(row, "K0") {
+					if !state.masks[0] {
+						t.Fatal("complete EVEX compare failed to define its K destination")
+					}
+				} else if strings.HasPrefix(row, "V") {
+					want = ^uint64(0)
+				}
+				if state.vectorBytes(2) != want || state.flags != x86ByteFlagsAll {
+					t.Fatal("packed compare changed the wrong vector aliases or flags")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultVectorCompareRequiresEveryReadByte(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+		for _, op := range []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ"} {
+			row := fmt.Sprintf("%s %s0,%s1,K1,K0", op, bank, bank)
+			for _, maskDefined := range []bool{false, true} {
+				for missing := -1; missing < 64; missing++ {
+					for input := 0; input < 2; input++ {
+						state := x86ResultState{masks: [8]bool{1: maskDefined}}
+						state.writeVector(0, 64, ^uint64(0), false)
+						state.writeVector(1, 64, ^uint64(0), false)
+						if missing >= 0 {
+							state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64")
+						want := maskDefined && (missing < 0 || missing >= width)
+						if accepted != want || accepted && !state.masks[0] || !accepted && !reflect.DeepEqual(before, state) {
+							t.Fatal("wide comparison laundered missing input or mask bytes", row, input, missing, maskDefined)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_result_vector_domain.go b/x86_result_vector_domain.go
new file mode 100644
index 000000000..5a28d6a41
--- /dev/null
+++ b/x86_result_vector_domain.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+// A numerical byte is known independently of its value. This domain models
+// every byte in each physical vector bank, not just an observed low-X result.
+// It grants no memory extent, alignment, initialized pointee or ABI permission.
+func (state *x86ResultState) vectorBytes(index int) uint64 {
+	return uint64(state.xmm[index]) | state.vectorUpper[index]
+}
+
+// Typed forms choose the active width and legacy versus VEX/EVEX write rule.
+// Legacy writes preserve inactive aliases; VEX/EVEX writes define them as zero.
+// known contains only numerical dependencies; memory effects stay independent.
+func (state *x86ResultState) writeVector(index, width int, known uint64, legacy bool) {
+	mask := x86CallerVectorByteMask(int64(width))
+	if legacy {
+		known = known&mask | state.vectorBytes(index)&^mask
+	} else {
+		known = known&mask | ^mask
+	}
+	state.xmm[index] = uint16(known)
+	state.vectorUpper[index] = known &^ 0xffff
+}
diff --git a/x86_result_vector_domain_test.go b/x86_result_vector_domain_test.go
new file mode 100644
index 000000000..f904fd639
--- /dev/null
+++ b/x86_result_vector_domain_test.go
@@ -0,0 +1,341 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These spellings are independent Go-table witnesses. The wide result domain
+// must compose with existing typed effects, not merely accept one zero idiom.
+func TestX86ResultVectorDomainWideComposition(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		for _, operation := range []string{
+			"VPANDQ %[1]s0,%[1]s1,%[1]s2",
+			"VPCLMULQDQ $17,%[1]s0,%[1]s1,%[1]s2",
+			"VPSRLQ $7,%[1]s0,%[1]s2",
+			"VAESENC %[1]s0,%[1]s1,%[1]s2",
+			"VADDPS %[1]s0,%[1]s1,%[1]s2",
+		} {
+			row := fmt.Sprintf(operation, bank)
+			t.Run(bank+"/"+row, func(t *testing.T) {
+				rows := []string{
+					fmt.Sprintf("VPXORQ %[1]s0,%[1]s0,%[1]s0", bank),
+					fmt.Sprintf("VPXORQ %[1]s1,%[1]s1,%[1]s1", bank), row,
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for _, current := range rows {
+					ins := x86ScalarLaneInstruction(t, current)
+					if !x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatalf("typed vector domain cannot compose %s", current)
+					}
+				}
+				if state.xmm[2] != 0xffff || state.flags != x86ByteFlagsAll {
+					t.Fatal("composed numerical result or flags lost")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResultVectorDomainWholeCFGDoesNotBorrowShapeState(t *testing.T) {
+	for _, otherBranch := range []string{"VZEROUPPER", "NOP"} {
+		source := `TEXT ·view(SB),4,$0-12
+MOVL a+0(FP),AX
+MOVL AX,X0
+CMPL AX,$0
+JE other
+VZEROUPPER
+JMP joined
+other:
+` + otherBranch + `
+joined:
+VADDPS Z0,Z0,Z1
+PEXTRD $0,X1,AX
+MOVL AX,ret+8(FP)
+RET
+`
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", api)
+			if otherBranch == "VZEROUPPER" && err != nil {
+				t.Fatal("both-path upper initialization lost", api, err)
+			}
+			if otherBranch == "NOP" {
+				x86VectorScratchCodegenControl(t, source, "func view(a uint32) uint32\n", "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			} else if otherBranch == "NOP" && !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("source-wide top or one predecessor defined the missing upper bytes", api, err)
+			}
+		}
+	}
+	const deadRead = `TEXT ·view(SB),4,$0-4
+JMP finish
+VPCLMULQDQ $0,(AX),Z0,Z1
+finish:
+MOVL $1,AX
+MOVL AX,X0
+PEXTRD $0,X0,AX
+MOVL AX,ret+0(FP)
+RET
+`
+	goAssemblerOracleOutput(t, "amd64", deadRead, "", true)
+	for _, api := range []string{"text", "module", "Go"} {
+		if _, err := x86ScalarFPBitViewAPI(t, deadRead, "func view() uint32\n", "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("dead wide native read bypassed source closure", api, err)
+		}
+	}
+}
+
+func TestX86ResultVectorDomainPhysicalAliasesAndJoins(t *testing.T) {
+	for register := 0; register < 32; register++ {
+		for width := 16; width <= 64; width *= 2 {
+			for missing := 0; missing < 64; missing++ {
+				for _, legacy := range []bool{false, true} {
+					if legacy && width != 16 {
+						continue
+					}
+					before := x86ResultState{flags: x86ByteFlagsAll}
+					before.xmm[register] = 0xa55a
+					before.vectorUpper[register] = 0xa55aa55aa55a0000
+					state := before.clone()
+					known := ^(uint64(1) << uint(missing))
+					state.writeVector(register, width, known, legacy)
+					var want uint64
+					for byteIndex := 0; byteIndex < 64; byteIndex++ {
+						defined := byteIndex != missing
+						if byteIndex >= width {
+							defined = !legacy || before.vectorBytes(register)>>uint(byteIndex)&1 != 0
+						}
+						if defined {
+							want |= uint64(1) << uint(byteIndex)
+						}
+					}
+					if state.vectorBytes(register) != want || state.vectorUpper[register]&0xffff != 0 {
+						t.Fatalf("bank%d width%d missing%d legacy%t: %016x want %016x", register, width, missing, legacy, state.vectorBytes(register), want)
+					}
+					joined := state.intersect(before)
+					if joined.vectorBytes(register) != want&before.vectorBytes(register) {
+						t.Fatal("CFG join promoted unknown upper bytes")
+					}
+					joined.writeVector(register, 64, 0, false)
+					if state.vectorBytes(register) != want || state.flags != before.flags {
+						t.Fatal("clone/join shares mutable physical vector state")
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultVectorDomainEveryExistingWriteEncoding(t *testing.T) {
+	// Every existing low-X writer must explicitly preserve or clear aliases.
+	// This list is independent of the implementation dispatch and registries.
+	for _, row := range []string{
+		"MOVL AX,X2", "VMOVD AX,X2", "MOVQ AX,X2", "VMOVQ AX,X2",
+		"MOVSS X0,X2", "MOVSD X0,X2", "VMOVSS X0,X1,X2", "VMOVSD X0,X1,X2",
+		"PINSRB $3,AX,X2", "VPINSRB $3,AX,X0,X2",
+		"INSERTPS $35,X0,X2", "VINSERTPS $35,X0,X1,X2",
+		"PXOR X0,X2", "VPXOR X0,X1,X2",
+		"PCLMULQDQ $17,X0,X2", "VPCLMULQDQ $17,X0,X1,X2",
+		"AESENC X0,X2", "VAESENC X0,X1,X2",
+		"PSRLQ $1,X2", "VPSRLQ $1,X0,X2",
+		"ADDSS X0,X2", "VADDSS X0,X1,X2", "MULPS X0,X2", "VMULPS X0,X1,X2",
+		"VPBROADCASTD X0,X2",
+	} {
+		t.Run(row, func(t *testing.T) {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			for index := range state.xmm {
+				state.xmm[index] = 0xffff
+				state.vectorUpper[index] = 0xa5a55a5aa5a50000
+			}
+			state.gp[0] = 0xff
+			before := state.clone()
+			if !x86ScalarFPResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") {
+				t.Fatal("existing typed writer lost its effect")
+			}
+			want := before.vectorUpper[2]
+			if strings.HasPrefix(row, "V") {
+				want = ^uint64(0xffff)
+			}
+			if state.vectorUpper[2] != want || state.xmm[2] != 0xffff || state.flags != before.flags {
+				t.Fatalf("write encoding lost alias semantics: %016x", state.vectorBytes(2))
+			}
+			for index := range state.xmm {
+				if index != 2 && state.vectorBytes(index) != before.vectorBytes(index) {
+					t.Fatal("unrelated vector bank changed", index)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ResultVectorDomainWideLogicalEveryByte(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		width := map[string]int{"X": 16, "Y": 32, "Z": 64}[bank]
+		for _, suffix := range []string{"", ".Z"} {
+			row := fmt.Sprintf("VPANDQ%s %s0,%s1,K1,%s2", suffix, bank, bank, bank)
+			ins := x86ScalarLaneInstruction(t, row)
+			for missing := 0; missing < 64; missing++ {
+				for input := 0; input < 3; input++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: true}}
+					for register := 0; register < 3; register++ {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					state.writeVector(input, 64, ^(uint64(1) << uint(missing)), false)
+					if !x86ScalarFPResultTransfer(ins, &state, nil, 0, "amd64") {
+						t.Fatal("legal partial input was not represented", row)
+					}
+					want := ^uint64(0)
+					if missing < width && (input < 2 || suffix == "") {
+						want &^= uint64(1) << uint(missing)
+					}
+					if state.vectorBytes(2) != want {
+						t.Fatalf("%s input%d missing%d: %016x want%016x", row, input, missing, state.vectorBytes(2), want)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86ResultVectorDomainDoesNotPromoteLowXToWide(t *testing.T) {
+	for _, row := range []string{"VPANDQ Z0,Z1,Z2", "VPCLMULQDQ $17,Z0,Z1,Z2", "VPSRLQ $1,Z0,Z2", "VAESENC Z0,Z1,Z2"} {
+		state := x86ResultState{xmm: [32]uint16{0: 0xffff, 1: 0xffff}}
+		if !x86ScalarFPResultTransfer(x86ScalarLaneInstruction(t, row), &state, nil, 0, "amd64") {
+			t.Fatal("valid effect must retain the unknown upper bytes", row)
+		}
+		if state.vectorUpper[2] != 0 || state.xmm[2] != 0xffff {
+			t.Fatal("a low-X witness falsely initialized a wider source", row)
+		}
+	}
+}
+
+func TestX86ResultVectorTransportNeverInitializesMissingUpperBytes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		resultOffset, triple := 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			resultOffset, triple = 4, "i386-unknown-linux-gnu"
+		}
+		for _, form := range []struct{ move, extract string }{
+			{"VMOVUPS Y0,Y1", "VEXTRACTF128 $1,Y1,X2"},
+			{"VMOVUPS Z0,Z1", "VEXTRACTF32X4 $1,Z1,X2"},
+		} {
+			for _, initialized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/%s/upper-initialized-%v", arch, form.move, initialized), func(t *testing.T) {
+					upper := "NOP"
+					if initialized {
+						upper = "VZEROUPPER"
+					}
+					source := fmt.Sprintf(`TEXT ·view(SB),4,$0-%d
+MOVL a+0(FP),AX
+MOVL AX,X0
+%s
+%s
+%s
+PEXTRD $0,X2,AX
+MOVL AX,ret+%d(FP)
+RET
+`, resultOffset+4, upper, form.move, form.extract, resultOffset)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view(a uint32) uint32\n", arch, triple, api)
+						if initialized && err != nil {
+							t.Errorf("%s lost independently initialized upper bytes: %v", api, err)
+						}
+						if arch == "amd64" && !initialized {
+							x86VectorScratchCodegenControl(t, source, "func view(a uint32) uint32\n", arch, triple, ir, err)
+						} else if !initialized && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Errorf("%s promoted unknown upper bytes through register transport: %v", api, err)
+						}
+						if initialized && err == nil {
+							compileLLVMToObject(t, llc, triple, "known-upper.ll", "known-upper.o", ir)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ResultVectorDomainFiveTargetThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, bank := range []string{"X", "Y", "Z"} {
+				for _, operation := range []string{
+					"VPANDQ %[1]s0,%[1]s1,%[1]s2", "VPCLMULQDQ $17,%[1]s0,%[1]s1,%[1]s2",
+					"VPSRLQ $7,%[1]s0,%[1]s2", "VAESENC %[1]s0,%[1]s1,%[1]s2",
+					"VADDPS %[1]s0,%[1]s1,%[1]s2", "VMULPD %[1]s0,%[1]s1,%[1]s2",
+				} {
+					if target.arch == "386" && strings.HasPrefix(operation, "VPCLMULQDQ") {
+						continue // Go mode32 does not parse the four-operand row.
+					}
+					fmt.Fprintf(&declarations, "func wide%d() uint32\n", count)
+					fmt.Fprintf(&source, "TEXT ·wide%d(SB),4,$0-4\nVPXORQ %s0,%s0,%s0\nVPXORQ %s1,%s1,%s1\n%s\nPEXTRD $0,X2,AX\nMOVL AX,ret+0(FP)\nRET\n",
+						count, bank, bank, bank, bank, bank, bank, fmt.Sprintf(operation, bank))
+					count++
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal(api, err)
+				}
+				compileLLVMToObject(t, llc, target.triple, "wide-results.ll", "wide-results.o", ir)
+			}
+		})
+	}
+}
+
+func TestX86ResultVectorDomainZeroRegisterBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range []string{"VZEROUPPER", "VZEROALL"} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for register := range state.xmm {
+					state.xmm[register] = 0x1234
+					state.vectorUpper[register] = 0x1234123412340000
+				}
+				if !x86ScalarFPResultTransfer(x86ScalarLaneInstruction(t, name), &state, nil, 0, arch) {
+					t.Fatal("complete zero-register family lacks result effects")
+				}
+				limit := 16
+				if arch == "386" {
+					limit = 8
+				}
+				for register := range state.xmm {
+					want := uint64(0x1234123412341234)
+					if register < limit {
+						want |= ^uint64(0xffff)
+						if name == "VZEROALL" {
+							want = ^uint64(0)
+						}
+					}
+					if state.vectorBytes(register) != want {
+						t.Fatal("zero-register encoding changed wrong bank/bytes", register)
+					}
+				}
+				if state.flags != x86ByteFlagsAll {
+					t.Fatal("vector zero modified flags")
+				}
+			})
+		}
+		for _, malformed := range []string{"VZEROUPPER X0", "VZEROALL.Z"} {
+			state := x86ResultState{}
+			if x86ScalarFPResultTransfer(x86ScalarLaneInstruction(t, malformed), &state, nil, 0, arch) {
+				t.Fatal("malformed zero form supplied defined bytes", malformed)
+			}
+		}
+	}
+}
diff --git a/x86_result_vector_inputs.go b/x86_result_vector_inputs.go
new file mode 100644
index 000000000..f2a47a997
--- /dev/null
+++ b/x86_result_vector_inputs.go
@@ -0,0 +1,116 @@
+package plan9asm
+
+// This common dependency consumer supplies numerical values only. Operation
+// specs independently identify whether old destination bytes are data inputs.
+func x86ResultFixedVectorInputs(ins Instr, form x86PackedBinaryForm, oldInput bool, state *x86ResultState, owned []bool, arch string) bool {
+	return x86ResultFixedVectorInputsWithRead(ins, form, oldInput, state, owned, arch, false)
+}
+
+func x86ResultFixedVectorInputsWithRead(ins Instr, form x86PackedBinaryForm, oldInput bool,
+	state *x86ResultState, owned []bool, arch string, native bool) bool {
+	if form.mmx || !x86ResultNamedPredicateInstruction(ins) || x86Mode32VectorRegisterContext(ins, arch) != nil {
+		return false
+	}
+	if form.mask >= 0 {
+		mask, _ := amd64ParseKReg(ins.Args[form.mask].Reg)
+		if !state.masks[mask] {
+			return false
+		}
+	}
+	width := int64(form.byteWidth)
+	firstWidth := width
+	if form.memory >= 0 {
+		firstWidth = int64(form.memoryBytes)
+	}
+	first := ins.Args[form.first]
+	firstKnown := x86ResultPackedVectorRead(first, firstWidth, state, owned, arch)
+	if !firstKnown && native && first.Kind != OpReg {
+		firstKnown = x86ResultReadWithNativeContinuation(ins, first, firstWidth, state, owned, arch, true)
+	}
+	if !firstKnown ||
+		form.second >= 0 && !x86ResultPackedVectorRead(ins.Args[form.second], width, state, owned, arch) {
+		return false
+	}
+	// An operation may read its old destination as data, independently of
+	// the optional masked merge. Neither dependency is supplied by .Z.
+	if (oldInput || form.mask >= 0 && !form.zeroing) &&
+		!x86ResultPackedVectorRead(ins.Args[form.destination], width, state, owned, arch) {
+		return false
+	}
+	destination, _ := amd64VectorRegisterIndex(ins.Args[form.destination].Reg, form.byteWidth)
+	state.writeVector(destination, form.byteWidth, x86CallerVectorByteMask(width), form.legacy)
+	return true // No FLAGS/DF/mask, memory or pointer facts change.
+}
+
+// Share only the complete family grammar and old-destination input role.
+// This description grants no numerical, memory, frame or declaration authority.
+func x86FixedVectorValueProperties(ins Instr, arch string) (x86PackedBinaryForm, bool, bool, error) {
+	if parsed, known, err := x86PackedPhysicalProperties(ins.Op, ins, arch, ""); known {
+		return parsed.x86PackedBinaryForm, false, known, err
+	}
+	return x86OtherFixedVectorValueProperties(ins, arch)
+}
+
+func x86OtherFixedVectorValueProperties(ins Instr, arch string) (x86PackedBinaryForm, bool, bool, error) {
+	if parsed, known, err := x86Shuffle128BitBlocksProperties(ins.Op, ins, arch); known {
+		return parsed.x86PackedBinaryForm, false, known, err
+	}
+	if parsed, known, err := x86PackedRotateProperties(ins.Op, ins, arch); known {
+		return parsed.x86PackedBinaryForm, false, known, err
+	}
+	if parsed, known, err := x86PackedConflictProperties(ins.Op, ins, arch); known {
+		return parsed.x86PackedBinaryForm, false, known, err
+	}
+	if parsed, known, err := x86FunnelShiftProperties(ins.Op, ins, arch); known {
+		return parsed.x86PackedBinaryForm, parsed.spec.variable, known, err
+	}
+	if form, known, err := x86IFMAProperties(ins.Op, ins, arch); known {
+		return form.x86PackedBinaryForm, true, true, err
+	}
+	if parsed, known, err := x86HorizontalIntegerProperties(ins, arch); known {
+		return x86PackedBinaryForm{
+			first: parsed.first, second: parsed.second, destination: parsed.destination,
+			memory: parsed.memory, memoryBytes: parsed.byteWidth, byteWidth: parsed.byteWidth,
+			mask: -1, legacy: !parsed.spec.vector, mmx: parsed.mmx,
+		}, false, true, err
+	}
+	if parsed, spec, recognized, parseErr := x86IndexedPermuteProperties(ins.Op, ins, arch); recognized {
+		return parsed, spec.mode != amd64IndexedPermuteSingle, recognized, parseErr
+	}
+	if parsed, recognized, parseErr := x86GFNIProperties(ins.Op, ins, arch); recognized {
+		return parsed.x86PackedBinaryForm, false, recognized, parseErr
+	}
+	if parsed, recognized, parseErr := x86PackedBitCountProperties(ins.Op, ins, arch); recognized {
+		return parsed.x86PackedBinaryForm, false, recognized, parseErr
+	}
+	return x86PackedBinaryForm{}, false, false, nil
+}
+
+// Only the paired exact-width native emitter consumes this conditional read.
+// Complete masks, second inputs and I2/T2/merge destination bytes stay required.
+func x86LoweredFixedVectorNativeRead(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	form, oldInput, known, err := x86FixedVectorValueProperties(ins, arch)
+	if !known {
+		if parsed, registered, parseErr := x86PackedLowMultiplyProperties(ins.Op, ins, arch); registered {
+			form, known, err = parsed.x86PackedBinaryForm, registered, parseErr
+		}
+	}
+	if !known || err != nil {
+		return false, known
+	}
+	if form.memory < 0 || ins.Args[form.memory].Kind != OpMem {
+		return false, false // Logical fields and bound DATA retain their existing consumers.
+	}
+	return x86ResultFixedVectorInputsWithRead(ins, form, oldInput, state, owned, arch, true), true
+}
+
+// This is only a numerical vector view. Keep the older scalar/legacy-X read
+// domain unchanged; neither native pointers nor wider logical storage follow.
+func x86ResultPackedVectorRead(operand Operand, width int64, state *x86ResultState, owned []bool, arch string) bool {
+	if operand.Kind != OpReg {
+		return x86ResultRead(operand, width, state, owned, arch)
+	}
+	index, valid := amd64VectorRegisterIndex(operand.Reg, int(width))
+	mask := x86CallerVectorByteMask(width)
+	return valid && (arch != "386" || index < 8) && mask != 0 && state.vectorBytes(index)&mask == mask
+}
diff --git a/x86_result_vector_test_native.go b/x86_result_vector_test_native.go
new file mode 100644
index 000000000..35f5ef123
--- /dev/null
+++ b/x86_result_vector_test_native.go
@@ -0,0 +1,22 @@
+package plan9asm
+
+func x86RawVectorTestSource(ins Instr, arch string) bool {
+	_, known, err := x86VectorTestProperties(ins.Op, ins, arch)
+	return known && err == nil && x86RawOrdinaryVectorSource(ins, arch)
+}
+
+// Exact raw identity grants a transfer-local view, not input bytes, native
+// backing, physical entry or a reusable declaration/query permission.
+func x86LoweredVectorTestResultStep(ins Instr, state *x86ResultState, owned []bool, arch string) (bool, bool) {
+	_, known, err := x86VectorTestProperties(ins.Op, ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) {
+		if !x86RawVectorTestSource(ins, arch) {
+			return false, true
+		}
+		ins.x86Encoded, ins.x86SourceRaw = false, nil
+	}
+	return x86ResultVectorTestStepWithRead(ins, state, owned, arch, true)
+}
diff --git a/x86_result_vector_zero.go b/x86_result_vector_zero.go
new file mode 100644
index 000000000..98519e32e
--- /dev/null
+++ b/x86_result_vector_zero.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+func x86RawVectorZeroSource(ins Instr, arch string) bool {
+	_, known, err := x86VectorZeroProperties(ins, arch)
+	return known && err == nil && x86RawOperandFreeSource(ins)
+}
+
+// Only the exact decoded implicit write shares the existing complete-bank
+// effect. Preserved low/high bytes stay unknown; no memory or entry role follows.
+func x86LoweredVectorZeroResultStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	_, known, _ := x86VectorZeroProperties(ins, arch)
+	if !known || x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	if !x86RawVectorZeroSource(ins, arch) {
+		return false, true
+	}
+	local := ins
+	local.x86Encoded, local.x86SourceRaw = false, nil
+	return x86ResultTransfer(local, state, owned, resultOffset, arch), true
+}
diff --git a/x86_result_vector_zero_test.go b/x86_result_vector_zero_test.go
new file mode 100644
index 000000000..ca18ba5c7
--- /dev/null
+++ b/x86_result_vector_zero_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VectorZeroRawPairedStateAndOrigin(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, code := range []string{
+			"WORD $0xf8c5\nBYTE $0x77", "WORD $0xfcc5\nBYTE $0x77",
+			"LONG $0x77f8e1c4", "LONG $0x77fce1c4",
+			"LONG $0x7778e1c4", "LONG $0x777ce1c4",
+		} {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+code+"\nRET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawVectorZeroSource(ins, arch) {
+				t.Fatal("original zero-operand encoding lost its source identity", arch, code)
+			}
+			t.Run(arch+"/"+code, func(t *testing.T) {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for register := 0; register < 32; register++ {
+					state.writeVector(register, 64, uint64(0x8123456789abcdef)>>uint(register%8), false)
+				}
+				before, want := state.clone(), state.clone()
+				last, first := 16, 16
+				if arch == "386" {
+					last = 8
+				}
+				if ins.Op == "VZEROALL" {
+					first = 0
+				}
+				for register := 0; register < last; register++ {
+					want.writeVector(register, 64, want.vectorBytes(register)|(^uint64(0)<<uint(first)), false)
+				}
+				accepted, known := x86LoweredVectorZeroResultStep(ins, &state, nil, 0, arch)
+				if !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("complete implicit bank/preserved unknown/FLAGS effect differs", accepted, known)
+				}
+				for _, control := range []struct {
+					name   string
+					change func(*Instr)
+				}{
+					{"origin", func(ins *Instr) { ins.x86SourceRaw = nil }},
+					{"opcode", func(ins *Instr) {
+						ins.Op = "VZEROALL"
+						if ins.x86SourceRaw.op == "VZEROALL" {
+							ins.Op = "VZEROUPPER"
+						}
+					}},
+					{"operand", func(ins *Instr) { ins.Args = []Operand{{Kind: OpReg, Reg: AX}} }},
+					{"source-operand", func(ins *Instr) { ins.x86SourceRaw.args = []Operand{{Kind: OpReg, Reg: AX}} }},
+					{"vector", func(ins *Instr) { ins.x86VectorBytes = 16 }},
+					{"address", func(ins *Instr) { ins.x86AddressBits = 32 }},
+					{"override", func(ins *Instr) { ins.x86UnboundAddressOverride = true }},
+					{"segment", func(ins *Instr) { ins.x86SegmentPrefix = 0x64 }},
+					{"literal", func(ins *Instr) { ins.x86RIPLiteral = true }},
+				} {
+					t.Run(control.name, func(t *testing.T) {
+						changed, state := ins, before.clone()
+						origin := *ins.x86SourceRaw
+						changed.x86SourceRaw = &origin
+						control.change(&changed)
+						accepted, known := x86LoweredVectorZeroResultStep(changed, &state, nil, 0, arch)
+						if accepted || known != (control.name != "origin") ||
+							x86RawVectorZeroSource(changed, arch) || !reflect.DeepEqual(state, before) {
+							t.Fatal("changed zero-operand source acquired a native continuation", accepted, known)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+// The complete original eight named/VEX2/VEX3/WIG source programs retain every
+// X/Y/Z bank and K/FLAGS canary. Actual native MXCSR checks remain separate.
+func TestX86VectorZeroOriginalWholeBankPortableExecution(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	source, _, prototypes, checks := x86VectorZeroRuntimeFixture(t)
+	var declarations strings.Builder
+	for index := 0; index < 8; index++ {
+		fmt.Fprintf(&declarations, "func vectorzero%d(out,in *byte,mask uint64)\n", index)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+	main := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes + `
+static int checkVectorZero(void (*program)(uint8_t*,const uint8_t*,uint64_t),
+                           const char *name,int clearLow) {
+    for (unsigned round=0; round<16; round++) {
+        uint8_t input[2050], original[2050], output[3596];
+        for (unsigned i=0; i<sizeof(input); i++) input[i]=(uint8_t)(i*73+round*19+1);
+        memcpy(original,input,sizeof(input));
+        memset(output,0xc3,sizeof(output));
+        uint64_t mask=UINT64_C(0x8123456789abcdef)^round;
+        program(output+1,input+1,mask);
+        uint64_t gotMask;
+        memcpy(&gotMask,output+3587,8);
+        if (output[0]!=0xc3 || output[3595]!=0xc3 || output[3585]!=1 ||
+            output[3586]!=0 || gotMask!=mask || memcmp(input,original,sizeof(input))) {
+            fprintf(stderr,"%s round=%u FLAGS/K/input/canary failure\n",name,round);
+            return 1;
+        }
+        const unsigned widths[]={16,32,64}, offsets[]={0,16,48};
+        for (unsigned reg=0; reg<32; reg++) {
+            for (unsigned view=0; view<3; view++) {
+                for (unsigned byte=0; byte<widths[view]; byte++) {
+                    uint8_t want=reg<16 && (clearLow || byte>=16) ? 0 : input[1+reg*64+byte];
+                    uint8_t got=output[1+reg*112+offsets[view]+byte];
+                    if (got!=want) {
+                        fprintf(stderr,"%s round=%u reg=%u view=%u byte=%u\n",
+                                name,round,reg,view,byte);
+                        return 1;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
+}
+int main(void) {
+` + checks + "return 0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("complete original vector-zero source lost its native-read continuation", err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("vector-zero-%s-ir%d-%s", api, index, level[1:]), triple, text, main, nil)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_result_vsib.go b/x86_result_vsib.go
new file mode 100644
index 000000000..87ff49e49
--- /dev/null
+++ b/x86_result_vsib.go
@@ -0,0 +1,58 @@
+package plan9asm
+
+// VSIB numerical continuation requires the actual index, mask and merge/data
+// inputs. A paired indexed access may supply active loaded bytes on normal
+// continuation; it creates no contiguous extent, frame or later-read fact.
+func x86ResultVSIBStep(ins Instr, state *x86ResultState, arch string, native bool) (bool, bool) {
+	form, known, err := x86VSIBProperties(ins, arch)
+	if !known || err != nil {
+		return false, known
+	}
+	if !x86ResultNamedPredicateInstruction(ins) || ins.x86NumericalRead != nil {
+		return false, true
+	}
+	if form.prefetch {
+		return true, true // The existing emitter elides this hint, with no data or state result.
+	}
+	index, valid := amd64VectorRegisterIndex(form.memory.Mem.Index, form.indexBytes)
+	indexRequired := x86CallerVectorByteMask(int64(form.indexBytes))
+	if !valid || state.vectorBytes(index)&indexRequired != indexRequired {
+		return false, true
+	}
+	data, valid := amd64VectorRegisterIndex(form.data.Reg, form.dataBytes)
+	required := x86CallerVectorByteMask(int64(form.dataBytes))
+	if !valid || arch == "386" && data >= 8 || state.vectorBytes(data)&required != required {
+		return false, true // Gather retains inactive merge lanes; scatter reads active data.
+	}
+	mask := 0
+	if form.evex {
+		mask, valid = amd64ParseKReg(form.mask.Reg)
+		if !valid || !state.masks[mask] {
+			return false, true
+		}
+	} else {
+		mask, valid = amd64VectorRegisterIndex(form.mask.Reg, form.dataBytes)
+		if !valid || arch == "386" && mask >= 8 || state.vectorBytes(mask)&required != required {
+			return false, true
+		}
+	}
+	if !native || !x86OrdinaryNativeMemoryOperand(form.memory, arch) {
+		return false, true
+	}
+	// Check the independent typed pointer base after consuming the numerical
+	// vector index. A vector index is not an ordinary GP or a contiguous tuple.
+	base := form.memory
+	base.Mem.Index, base.Mem.Scale = "", 0
+	if !x86ResultIncomingPointerAddressIdentity(base, state, arch) {
+		return false, true
+	}
+	if !form.scatter {
+		state.writeVector(data, form.dataBytes, required, false)
+	}
+	if form.evex {
+		state.masks[mask] = true // A normally completed gather/scatter clears its K mask.
+	} else {
+		state.writeVector(mask, form.dataBytes, required, false)
+	}
+	return true, true
+}
diff --git a/x86_result_x87_values.go b/x86_result_x87_values.go
new file mode 100644
index 000000000..197fb9d19
--- /dev/null
+++ b/x86_result_x87_values.go
@@ -0,0 +1,402 @@
+package plan9asm
+
+import "strings"
+
+// This is source-authored logical availability, not hardware Tag/TOP, a saved
+// environment, physical stack capacity or control/rounding authority. Entry
+// values/status start unknown regardless of the emitter's private zero slots.
+type x86ResultX87State struct {
+	slots   uint8
+	depth   uint8
+	invalid bool
+	status  uint16
+	gp      [16]uint16             // Captured known status bits, never whole NUM/canonical bytes.
+	word    *x86ResultX87WordState // Optional control knownness and immutable natural-word layout.
+	integer [8]uint8               // Source signed range in 2/4/8 bytes, not the emitter's representation.
+}
+
+const x86ResultX87StatusConditions uint16 = 0x4500 // C3, C2, C0 only.
+
+func (state *x86ResultX87State) revoke() {
+	word := state.word
+	*state = x86ResultX87State{invalid: true}
+	if word != nil {
+		// ABI layout is immutable source metadata, not an x87 hardware fact.
+		state.word = &x86ResultX87WordState{layout: word.layout}
+	}
+}
+
+func x86X87FlowInstructions(fn Func) []Instr {
+	if fn.x86DirectTailRoot != nil {
+		return fn.x86DirectTailRoot.instructions
+	} else if fn.x86ContinuationFlow != nil {
+		return fn.x86ContinuationFlow.instructions
+	}
+	return fn.Instrs
+}
+
+func x86X87ValueFlowNeeded(fn Func) bool {
+	for _, ins := range x86X87FlowInstructions(fn) {
+		name, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+		if name == "FLDENV" {
+			return true // Allocation only; the actual transfer still checks mode and source.
+		}
+		if _, known := x86X87ValueSpecForName(Op(name)); known {
+			return true
+		}
+		if _, known := x86X87WordSpecs[Op(name)]; known {
+			return true
+		}
+	}
+	return false
+}
+
+func (state *x86ResultX87State) read(operand Operand) bool {
+	index, valid := x87OperandReg(operand)
+	return valid && !state.invalid && index < int(state.depth) && state.slots&(1<<uint(index)) != 0
+}
+
+func (state *x86ResultX87State) write(operand Operand) bool {
+	index, valid := x87OperandReg(operand)
+	if !valid || state.invalid {
+		return false
+	}
+	state.slots |= 1 << uint(index)
+	state.integer[index] = 0
+	if state.depth <= uint8(index) {
+		state.depth = uint8(index + 1)
+	}
+	return true
+}
+
+func (state *x86ResultX87State) push() bool {
+	if state.invalid || state.depth >= 8 {
+		return false
+	}
+	state.slots = state.slots<<1 | 1
+	for index := len(state.integer) - 1; index > 0; index-- {
+		state.integer[index] = state.integer[index-1]
+	}
+	state.integer[0] = 0
+	state.depth++
+	return true
+}
+
+func (state *x86ResultX87State) pop(count uint8) bool {
+	if state.invalid || state.depth < count {
+		return false
+	}
+	for i := uint8(0); i < count; i++ {
+		if state.slots&1 == 0 {
+			return false
+		}
+		state.slots >>= 1
+		copy(state.integer[:], state.integer[1:])
+		state.integer[len(state.integer)-1] = 0
+		state.depth--
+	}
+	return true
+}
+
+func (state *x86ResultX87State) integerBytes(operand Operand) uint8 {
+	index, valid := x87OperandReg(operand)
+	if !valid || !state.read(operand) {
+		return 0
+	}
+	width := state.integer[index]
+	if width != 2 && width != 4 && width != 8 {
+		return 0
+	}
+	return width
+}
+
+// Only the private logical-FP observer installs this transfer. Existing
+// bounded FP/AUTO or exact observed static bytes supply memory; no conditional
+// native read or write follows from knowing an x87 instruction's width.
+func x86ResultX87ValueStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	return x86ResultX87ValueStepWithHardwareRounding(ins, state, owned, resultOffset, arch, false)
+}
+
+// The ordinary query has no ambient environment. Only the paired lowering
+// adapter may set hardwareRounding for an actually emitted native operation;
+// a default X87Mode value is not a source/control or native continuation fact.
+func x86ResultX87ValueStepWithHardwareRounding(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string, hardwareRounding bool) (bool, bool) {
+	return x86ResultX87ValueStepWithMemory(ins, state, owned, resultOffset, arch, hardwareRounding, false)
+}
+
+// nativeMemory is confined to the paired floating-move emitter. The shared
+// grammar, x87 depth and numerical inputs still own every ordinary effect.
+func x86ResultX87ValueStepWithMemory(ins Instr, state *x86ResultState, owned []bool,
+	resultOffset int64, arch string, hardwareRounding, nativeMemory bool) (bool, bool) {
+	if accepted, known := x86ResultX87WordStep(ins, state, owned, resultOffset, arch); known {
+		return accepted, true
+	}
+	form, known, err := x86X87ValueProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || form.unprovedEncoding || !x86ResultNamedPredicateInstruction(ins) || state.x87 == nil || state.x87.invalid {
+		return false, true
+	}
+	// A binary64/i64 value model cannot certify arbitrary packed BCD or
+	// extended80 values, faults and conversions. Keep all existing cell/control
+	// facts untouched while refusing the unproved numerical continuation.
+	if form.memoryBytes() == 10 {
+		return false, true
+	}
+	x87 := state.x87
+	nativeMemory = nativeMemory && form.spec.kind == x86X87FloatMove
+	hardwareRounding = hardwareRounding && (form.spec.kind == x86X87Round ||
+		form.spec.kind == x86X87IntegerMove && form.spec.width == 'V' && form.spec.pop == 1)
+	read := func(operand Operand) bool {
+		if isX87RegisterOperand(operand) {
+			return state.shapeOnly || x87.read(operand)
+		}
+		if operand.Kind == OpImm {
+			return true // The descriptor already validated the exact Go FLOAT rewrite.
+		}
+		return x86ResultRead(operand, form.memoryBytes(), state, owned, arch) ||
+			nativeMemory && x86RegisterAddressedNativeMemoryOperand(operand, arch) &&
+				x86ResultIncomingPointerReadAddressIdentity(operand, state, arch)
+	}
+	write := func(operand Operand) bool {
+		if isX87RegisterOperand(operand) {
+			return state.shapeOnly || x87.write(operand)
+		}
+		if form.spec.kind == x86X87IntegerMove {
+			return x86ResultX87NaturalWordStore(operand, form.memoryBytes(), state, owned, resultOffset, arch)
+		}
+		if nativeMemory && x86RegisterAddressedNativeMemoryOperand(operand, arch) {
+			return x86ResultIncomingPointerAddressIdentity(operand, state, arch)
+		}
+		return x86ResultStore(operand, form.memoryBytes(), state, owned, resultOffset, arch)
+	}
+	f0 := Operand{Kind: OpReg, Reg: "F0"}
+	controlKnown := x87.word != nil && x87.word.control == 0xffff
+	status := uint16(0)
+	switch form.spec.kind {
+	case x86X87ConditionalMove:
+		if !read(form.source) || !read(form.destination) ||
+			!state.shapeOnly && state.flags&form.spec.flags != form.spec.flags {
+			return false, true
+		}
+		first, last := x87.integerBytes(form.source), x87.integerBytes(form.destination)
+		if !write(form.destination) {
+			return false, true
+		}
+		if !state.shapeOnly && first != 0 && last != 0 {
+			if first > last {
+				last = first
+			}
+			x87.integer[0] = last // The selected value has either complete signed bound.
+		}
+	case x86X87FloatMove:
+		if !read(form.source) {
+			return false, true
+		}
+		integer := x87.integerBytes(form.source) // Capture before push or an aliased overwrite.
+		if form.push {
+			if !state.shapeOnly && !x87.push() {
+				return false, true
+			}
+			if !state.shapeOnly {
+				x87.integer[0] = integer
+			}
+		} else if !write(form.destination) {
+			return false, true
+		} else if !state.shapeOnly {
+			if index, register := x87OperandReg(form.destination); register {
+				x87.integer[index] = integer
+			}
+		}
+	case x86X87IntegerMove:
+		if !read(form.source) {
+			return false, true
+		}
+		if form.push {
+			if !state.shapeOnly {
+				if !x87.push() {
+					return false, true
+				}
+				x87.integer[0] = uint8(form.memoryBytes())
+			}
+		} else {
+			integer := x87.integerBytes(f0)
+			infallible := integer != 0 && int64(integer) <= form.memoryBytes()
+			if !state.shapeOnly && !infallible && !controlKnown && !hardwareRounding {
+				return false, true
+			}
+			if !write(form.destination) {
+				return false, true
+			}
+		}
+	case x86X87Constant:
+		if !state.shapeOnly && !x87.push() {
+			return false, true
+		}
+	case x86X87Unary:
+		if !read(f0) {
+			return false, true
+		}
+		if !state.shapeOnly {
+			x87.integer[0] = 0 // Even a sign change can leave the old signed range.
+		}
+	case x86X87Round:
+		if !read(f0) || !state.shapeOnly && !controlKnown && !hardwareRounding {
+			return false, true
+		}
+		// An already integral value retains its signed bound. Rounding an
+		// arbitrary float supplies no finite/signed-range or NUM entry fact.
+	case x86X87Exchange:
+		if !read(form.source) || !read(form.destination) {
+			return false, true
+		}
+		// Both exact cells were independently defined before either write.
+		if !state.shapeOnly {
+			first, _ := x87OperandReg(form.source)
+			last, _ := x87OperandReg(form.destination)
+			x87.integer[first], x87.integer[last] = x87.integer[last], x87.integer[first]
+		}
+	case x86X87Arithmetic:
+		if !read(form.source) || !read(form.destination) || !write(form.destination) {
+			return false, true
+		}
+	case x86X87Compare:
+		if !read(form.left) || !read(form.right) {
+			return false, true
+		}
+		if form.spec.directFlags {
+			state.flags = x86ByteFlagsAll // CF/PF/ZF computed; OF/SF/AF cleared.
+		} else {
+			status = x86ResultX87StatusConditions
+		}
+	case x86X87Test:
+		if !read(f0) {
+			return false, true
+		}
+		status = x86ResultX87StatusConditions
+	}
+	if !state.shapeOnly && !x87.pop(form.spec.pop) {
+		return false, true
+	}
+	// Never inherit stale C bits from a previous operation or private alloca.
+	// FSTSW captures the previous status before its documented undefined
+	// post-state; integer FLAGS and DF remain independent.
+	x87.status = status
+	return true, true
+}
+
+// A saved status may expose only independently defined bits. The complete
+// existing AND B/W/L/Q grammar provides its physical aliases, encoded mask and
+// FLAGS effects; unknown status bits selected by that mask remain Context.
+func x86ResultX87StatusProjection(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	if state.x87 == nil || state.x87.invalid || state.shapeOnly || !x86ResultNamedPredicateInstruction(ins) {
+		return false, false
+	}
+	form, known, err := x86LockScalarRMWProperties(ins.Op, ins, arch)
+	if !known || err != nil || form.spec.stem != "AND" || form.source.Kind != OpImm || form.destination.Kind != OpReg {
+		return false, false
+	}
+	width := int64(form.spec.bits / 8)
+	index, bytes, valid := x86ResultGP(form.destination.Reg, width, arch)
+	if !valid || state.x87.gp[index] == 0 {
+		return false, false
+	}
+	var initialized uint64
+	for b := uint(0); b < 8; b++ {
+		if state.gp[index]&(1<<b) != 0 {
+			initialized |= uint64(0xff) << (8 * b)
+		}
+	}
+	initialized |= uint64(state.x87.gp[index])
+	mask := uint64(form.source.Imm)
+	if width != 8 {
+		mask &= uint64(1)<<uint(8*width) - 1
+	}
+	if bytes == 2 && width == 1 {
+		mask <<= 8 // AH aliases the same captured AX word, not a second GP.
+	}
+	if initialized&mask != mask || !x86ResultStore(form.destination, width, state, owned, resultOffset, arch) {
+		return false, true
+	}
+	state.canonicalGP[index] &^= bytes
+	state.pointerGP[index], state.callerAddressGP[index] = false, false
+	state.callerAddressOrigin[index] = 0
+	state.resultAddressGP[index] = x86ResultSlotAddress{}
+	if state.boolFrameGP != nil {
+		state.boolFrameGP[index] = x86ResultSlotAddress{}
+	}
+	state.x87.gp[index] &^= x86X87CapturedByteMask(bytes)
+	state.flags = state.flags&^form.spec.flagsKilled | form.spec.flagsDefined
+	return true, true
+}
+
+func x86X87CapturedByteMask(bytes uint8) uint16 {
+	var mask uint16
+	if bytes&1 != 0 {
+		mask |= 0xff
+	}
+	if bytes&2 != 0 {
+		mask |= 0xff00
+	}
+	return mask
+}
+
+// Called after an ordinary transfer. Overwriting GP bytes revokes captured
+// status-bit knowledge even when numerical definedness remains unchanged.
+func x86ResultX87After(ins Instr, state *x86ResultState, arch string) {
+	if state.x87 == nil {
+		return
+	}
+	if ins.Op == OpCALL {
+		state.x87.revoke()
+		return // An independently accepted call supplies no empty-stack or captured GP fact.
+	}
+	if _, known, _ := x86X87WordProperties(ins, arch); known {
+		return // The shared typed word transfer applied every exact GP write.
+	}
+	if _, known, _ := x86X87ValueProperties(ins, arch); known {
+		return // The typed value transfer already applied its exact write/capture.
+	}
+	x86ResultX87CapturedAfter(ins, state, arch)
+}
+
+func x86ResultX87CapturedAfter(ins Instr, state *x86ResultState, arch string) {
+	if state.x87 == nil {
+		return
+	}
+	clear := func(operand Operand, width int64) {
+		if operand.Kind == OpReg {
+			if index, bytes, valid := x86ResultGP(operand.Reg, width, arch); valid {
+				state.x87.gp[index] &^= x86X87CapturedByteMask(bytes)
+			}
+		}
+	}
+	if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil {
+		for _, operand := range effect.operands {
+			if operand.write {
+				clear(operand.operand, operand.width)
+			}
+		}
+		return
+	}
+	if width := x86RawReturnScalarMoveBytes(ins.Op); width != 0 && len(ins.Args) == 2 {
+		clear(ins.Args[1], width)
+		return
+	}
+	if form, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil {
+		clear(form.destination, 1)
+		return
+	}
+	var captures [16]bool
+	for index, bits := range state.x87.gp {
+		captures[index] = bits != 0
+	}
+	after := x86ResultCallerAddressesAfter(ins, captures, nil, arch)
+	for index, live := range after {
+		if !live {
+			state.x87.gp[index] = 0
+		}
+	}
+}
diff --git a/x86_result_x87_words.go b/x86_result_x87_words.go
new file mode 100644
index 000000000..f35e91169
--- /dev/null
+++ b/x86_result_x87_words.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import "strings"
+
+// Only explicitly initialized control-word knownness is mutable state. The
+// parameter offsets are immutable actual typed-layout metadata, shared by all
+// CFG copies like pointerFP, not native backing or generic input-write rights.
+type x86ResultX87WordState struct {
+	control uint16
+	layout  *x86X87WordLayout
+}
+
+type x86X87WordLayout struct {
+	parameters map[int64]bool
+}
+
+func x86X87WordStateNeeded(fn Func) bool {
+	for _, ins := range x86X87FlowInstructions(fn) {
+		name, _, _ := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+		if name == "FLDENV" {
+			return true // Environment observation does not initialize the value stack.
+		}
+		if spec, known := x86X87ValueSpecs[Op(name)]; known &&
+			(spec.kind == x86X87IntegerMove || spec.kind == x86X87Round) {
+			return true // Explicit control knownness/layout, never a default CW.
+		}
+		if kind, known := x86X87WordSpecs[Op(name)]; known && kind != x86X87StoreStatus {
+			return true // No target permission follows from this allocation predicate.
+		}
+	}
+	return false
+}
+
+func x86ResultX87WordStep(ins Instr, state *x86ResultState, owned []bool, resultOffset int64, arch string) (bool, bool) {
+	form, known, err := x86X87WordProperties(ins, arch)
+	if !known {
+		return false, false
+	}
+	if err != nil || !x86ResultNamedPredicateInstruction(ins) || state.x87 == nil {
+		return false, true
+	}
+	x87 := state.x87
+	switch form.kind {
+	case x86X87Initialize:
+		if x87.word == nil {
+			return false, true
+		}
+		if !state.shapeOnly {
+			// Empty tags are not zero-valued F0..F7. Existing GP captures
+			// remain physically unchanged; no GP or integer FLAGS are written.
+			x87.slots, x87.depth, x87.invalid = 0, 0, false
+			x87.integer = [8]uint8{}
+			x87.status, x87.word.control = 0xffff, 0xffff
+		}
+		return true, true
+	case x86X87Clear:
+		if !state.shapeOnly {
+			// Only B/ES/SF and the exception bits become known zero.
+			// C3/TOP/C2/C1/C0 retain precisely their previous knownness.
+			x87.status = x87.status&0x7f00 | 0x80ff
+		}
+		return true, true
+	case x86X87LoadControl:
+		// This is the already implemented control-word write/read role, not
+		// an environment restore, stack/value producer or native memory read.
+		// Only two actual mapped FP/AUTO bytes may supply it; neither static
+		// bytes nor an incoming pointer acquire a new control-load permission.
+		mappedSource := form.operand.Kind == OpFP || form.operand.Kind == OpMem && form.operand.Mem.Base == SP
+		if x87.word == nil || !mappedSource ||
+			!x86ResultRead(form.operand, 2, state, owned, arch) {
+			return false, true
+		}
+		if !state.shapeOnly {
+			x87.word.control = 0xffff
+		}
+		return true, true
+	}
+	bits := x87.status
+	if form.kind == x86X87StoreControl {
+		bits = 0
+		if x87.word != nil {
+			bits = x87.word.control
+		}
+	}
+	if form.operand.Kind == OpReg {
+		index, mask, valid := x86ResultGP(form.operand.Reg, 2, arch)
+		if !valid {
+			return false, true
+		}
+		state.gp[index] &^= mask
+		if bits&0xff == 0xff {
+			state.gp[index] |= 1
+		}
+		if bits&0xff00 == 0xff00 {
+			state.gp[index] |= 2
+		}
+		state.canonicalGP[index] &^= mask // Defined bytes are not canonical values.
+		state.pointerGP[index], state.callerAddressGP[index] = false, false
+		state.callerAddressOrigin[index] = 0
+		state.resultAddressGP[index] = x86ResultSlotAddress{}
+		if state.boolFrameGP != nil {
+			state.boolFrameGP[index] = x86ResultSlotAddress{}
+		}
+		x87.gp[index] = bits
+	} else {
+		if !state.shapeOnly && bits != 0xffff {
+			return false, true
+		}
+		if !x86ResultX87NaturalWordStore(form.operand, 2, state, owned, resultOffset, arch) {
+			return false, true
+		}
+	}
+	// Preserve the existing conservative undefined post-condition-code policy.
+	// A second store cannot borrow stale full-status facts from its first read.
+	x87.status = 0
+	return true, true
+}
+
+// Reuse only the old exact natural I16 parameter shadow. A typed x87 integer
+// store does not make other parameter spans, pointers or caller memory writable.
+// Results and named AUTO keep the existing independently bounded byte writer.
+func x86ResultX87NaturalWordStore(operand Operand, width int64, state *x86ResultState,
+	owned []bool, resultOffset int64, arch string) bool {
+	if operand.Kind != OpFP || operand.FPOffset >= resultOffset {
+		return x86ResultStore(operand, width, state, owned, resultOffset, arch)
+	}
+	offset := operand.FPOffset
+	if width != 2 || state.x87 == nil || state.x87.word == nil || state.x87.word.layout == nil ||
+		!state.x87.word.layout.parameters[offset] || offset < 0 ||
+		offset > int64(len(owned))-2 || offset > int64(len(state.fp))-2 || !owned[offset] || !owned[offset+1] {
+		return false
+	}
+	state.fp[offset], state.fp[offset+1] = true, true
+	return true
+}
diff --git a/x86_round_fixture_classification_test.go b/x86_round_fixture_classification_test.go
new file mode 100644
index 000000000..a650dbd0b
--- /dev/null
+++ b/x86_round_fixture_classification_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// A real source refusal is neither an object success nor a native fault.
+// Keep all three public APIs negative without guessing the refusal's error class.
+func x86RoundRejectedGoSource(t *testing.T, source, declarations, arch, triple string) {
+	t.Helper()
+	goAssemblerOracleOutput(t, arch, "#include \"textflag.h\"\n"+source, "", false)
+	for _, api := range []string{"text", "module", "Go"} {
+		if ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api); ir != "" || err == nil {
+			t.Fatal("Go-refused ordinary ROUND source was accepted by public API", api, err)
+		}
+	}
+}
+
+// This retains the original mixed fixture exactly, observes every statement,
+// and emits only independently Go-selected statements in its ordinary object.
+func x86RoundOriginalSourceClassifiedObjects(t *testing.T, original, arch, triple string) string {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	x86RoundRejectedGoSource(t, original, "func roundforms()", arch, triple)
+	file, err := Parse(ArchAMD64, original)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var selected strings.Builder
+	selected.WriteString("TEXT roundforms(SB),NOSPLIT,$0-0\n")
+	accepted, refused, originalRows := 0, 0, 0
+	for _, ins := range file.Funcs[0].Instrs {
+		if ins.Op == OpTEXT || ins.Op == OpRET {
+			continue
+		}
+		originalRows++
+		scalarVEX := ins.Op == "VROUNDSS" || ins.Op == "VROUNDSD"
+		bad := scalarVEX && (arch == "386" || ins.Args[0].Imm < 0)
+		row := "TEXT roundoriginal(SB),NOSPLIT,$0-0\n" + ins.Raw + "\nRET\n"
+		t.Run(fmt.Sprint("original-", originalRows), func(t *testing.T) {
+			if bad {
+				x86RoundRejectedGoSource(t, row, "func roundoriginal()", arch, triple)
+			} else {
+				x86LEAActualTargetGoObject(t, arch, triple, "#include \"textflag.h\"\n"+row)
+			}
+		})
+		if bad {
+			refused++
+		} else {
+			accepted++
+			selected.WriteString(ins.Raw + "\n")
+		}
+		if scalarVEX && ins.Args[0].Imm < 0 {
+			// Yu8 cannot encode this original negative spelling. Keep its
+			// independent ordinary AMD64 counterpart instead of erasing it.
+			counterpart := strings.Replace(ins.Raw, "$-1", "$255", 1)
+			counterSource := "TEXT roundcounterpart(SB),NOSPLIT,$0-0\n" + counterpart + "\nRET\n"
+			if arch == "amd64" {
+				ir := x86UnboundVoidScalarFormatObject(t, counterSource, "roundcounterpart", arch, triple)
+				x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+			}
+		}
+		if arch == "386" && scalarVEX {
+			// Physical low-bank VEX bytes exist in mode32 even though the
+			// ordinary Go frontend rejects four operands. Obtain the bytes
+			// from real Go/AMD64 using Yu8, then keep raw mode32 separate.
+			physical := strings.Replace(ins.Raw, "$-1", "$255", 1)
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+physical+"\nRET\n")
+			if len(code) < 2 || code[len(code)-1] != 0xc3 {
+				t.Fatal("actual scalar ROUND lost its complete RET boundary")
+			}
+			raw := "TEXT roundphysical(SB),4,$0-0\n" + x86DwordProductDirectives(code[:len(code)-1]) + "\nRET\n"
+			ir := x86UnboundVoidRawScalarFormatObject(t, raw, arch, triple)
+			x86PackedStringCompileObject(t, llc, triple, ir, "-O0")
+		}
+	}
+	wantAccepted, wantRefused := 20, 2
+	if arch == "386" {
+		wantAccepted, wantRefused = 16, 6
+	}
+	if originalRows != 22 || accepted != wantAccepted || refused != wantRefused {
+		t.Fatal("original ROUND inventory changed", originalRows, accepted, refused)
+	}
+	selected.WriteString("RET\n")
+	t.Logf("original ROUND statements=%d ordinary-Go-selected=%d refused=%d; physical raw format objects are separate", originalRows, accepted, refused)
+	return x86UnboundVoidScalarFormatObject(t, selected.String(), "roundforms", arch, triple)
+}
diff --git a/x86_round_grammar_boundaries_test.go b/x86_round_grammar_boundaries_test.go
new file mode 100644
index 000000000..89b460e5f
--- /dev/null
+++ b/x86_round_grammar_boundaries_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86RoundGoImmediateAndModeBoundary(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"VROUNDSS", "VROUNDSD"} {
+			for _, immediate := range []int{-129, -128, -1, 0, 255, 256} {
+				for _, physical := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s/%d/encoded-%t", arch, op, immediate, physical), func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,X0,X1,X2", op, immediate))
+						ins.x86Encoded = physical
+						form, known, err := x86RoundProperties(ins, arch)
+						want := immediate >= 0 && immediate <= 255 && (arch != "386" || physical)
+						if !known || (err == nil) != want {
+							t.Fatal("scalar ROUND confused Go Yu8/front-end arity with normalized physical encoding", known, err, want)
+						}
+						if want && form.immediate != uint8(immediate) {
+							t.Fatal("ROUND immediate changed", form.immediate, immediate)
+						}
+					})
+				}
+			}
+		}
+		for _, op := range []string{"VROUNDPS", "VROUNDPD", "ROUNDPS", "ROUNDPD", "ROUNDSS", "ROUNDSD"} {
+			for _, immediate := range []int{-129, -128, -1, 0, 255, 256} {
+				t.Run(fmt.Sprintf("%s/%s/%d", arch, op, immediate), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, fmt.Sprintf("%s $%d,X0,X1", op, immediate))
+					_, known, err := x86RoundProperties(ins, arch)
+					low := 0
+					if op == "VROUNDPS" || op == "VROUNDPD" {
+						low = -128
+					}
+					want := immediate >= low && immediate <= 255
+					if !known || (err == nil) != want {
+						t.Fatal("packed VEX Yi8/Yu8 or legacy Yu8 boundary changed", known, err, want)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86RoundImmediateLiteralKinds(t *testing.T) {
+	for _, row := range []string{"VROUNDSS $0,X0,X1,X2", "VROUNDSD $0,X0,X1,X2", "VROUNDPS $0,X0,X1", "ROUNDSS $0,X0,X1"} {
+		for _, mutation := range []string{"floating", "unresolved", "non-immediate"} {
+			t.Run(row+"/"+mutation, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				switch mutation {
+				case "floating":
+					ins.Args[0].ImmIsFloat = true
+				case "unresolved":
+					ins.Args[0].ImmRaw = "$unresolved_round_control"
+				case "non-immediate":
+					ins.Args[0].Kind = OpReg
+					ins.Args[0].Reg = AX
+				}
+				if _, known, err := x86RoundProperties(ins, "amd64"); !known || err == nil {
+					t.Fatal("non-integer ROUND control silently became zero", mutation, known, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_round_raw_grammar_test.go b/x86_round_raw_grammar_test.go
new file mode 100644
index 000000000..d8ddcc444
--- /dev/null
+++ b/x86_round_raw_grammar_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86RoundNormalizedRawMode32GrammarDoesNotGrantNUM(t *testing.T) {
+	for _, instruction := range []string{"VROUNDSS $255,(AX),X1,X2", "VROUNDSD $255,X0,X1,X2"} {
+		t.Run(instruction, func(t *testing.T) {
+			code := x86OrderingHintGoBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+instruction+"\nRET\n")
+			if len(code) < 2 || code[len(code)-1] != 0xc3 {
+				t.Fatal("original Go ROUND lost its complete RET boundary")
+			}
+			source := "TEXT rawround(SB),4,$0-0\n" + x86DwordProductDirectives(code[:len(code)-1]) + "\nRET\n"
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized, err := normalizeX86RawFile(file, "386")
+			if err != nil || len(normalized.Funcs) != 1 || len(normalized.Funcs[0].Instrs) != 3 {
+				t.Fatal("actual original bytes did not retain one physical ROUND", err)
+			}
+			ins := normalized.Funcs[0].Instrs[1]
+			if ins.Op != x86ScalarLaneInstruction(t, instruction).Op || ins.x86Encoded || ins.x86SourceRaw == nil {
+				t.Fatal("decoder's original raw metadata contract changed", ins.Op, ins.x86Encoded, ins.x86SourceRaw)
+			}
+			if form, known, err := x86RoundProperties(ins, "386"); !known || err != nil || form.immediate != 255 || !form.spec.scalar {
+				t.Fatal("normalized physical mode32 ROUND was mistaken for an ordinary Go four-operand source", known, err)
+			}
+			for _, change := range []string{"original", "encoded-marker", "synthetic-raw-marker", "changed-source"} {
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				switch change {
+				case "encoded-marker":
+					changed.x86Encoded = true
+				case "synthetic-raw-marker":
+					changed.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: append([]Operand(nil), ins.Args...)}
+				case "changed-source":
+					changed.Args[1] = Operand{Kind: OpReg, Reg: "X3"}
+				}
+				if _, known, err := x86RoundProperties(changed, "386"); !known || err != nil {
+					t.Fatal("raw grammar boundary was replaced by NUM authority", change, known, err)
+				}
+				for _, native := range []bool{false, true} {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.pointerGP[0] = true
+					for register := 0; register < 4; register++ {
+						state.writeVector(register, 64, ^uint64(0), false)
+					}
+					before := state.clone()
+					if accepted, known := x86ResultRoundStep(changed, &state, nil, "386", native); !known || accepted || !reflect.DeepEqual(before, state) {
+						t.Fatal("raw or mutated raw ROUND borrowed native NUM/source permission", change, native)
+					}
+				}
+			}
+			ordinary := ins
+			ordinary.x86SourceRaw = nil
+			if _, known, err := x86RoundProperties(ordinary, "386"); !known || err == nil {
+				t.Fatal("removing raw provenance admitted ordinary mode32 four-operand source")
+			}
+		})
+	}
+}
diff --git a/x86_rtm_status_result_test.go b/x86_rtm_status_result_test.go
new file mode 100644
index 000000000..1c31ce3cb
--- /dev/null
+++ b/x86_rtm_status_result_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86RTMStatusQueryGoRowAndState(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{"var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}",
+		"{AXTEST, ynone, Px, opBytes{0x0f, 01, 0xd6}}"} {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("original Go RTM status-query row changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		source := "TEXT query(SB),4,$0-0\nXTEST\nRET\n"
+		if got := assembleX87ControlBytes(t, arch, source); !bytes.Equal(got, []byte{0x0f, 0x01, 0xd6, 0xc3}) {
+			t.Fatalf("Go XTEST identity changed: %x", got)
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", arch, raw), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "XTEST")
+				if raw {
+					ins.x86SourceRaw = &x86SourceRawInstruction{op: "XTEST"}
+				}
+				state := x86ResultState{direction: x86ResultDirectionBackward,
+					valueStack: &x86ResultValueStack{bytes: []uint8{1, 2}, id: true}}
+				state.gp[0], state.xmm[1], state.masks[2] = 0x81, 0x1234, true
+				state.callerAddressGP[7], state.pointerGP[7] = true, true
+				want := state.clone()
+				want.flags = x86ByteFlagsAll
+				if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+					t.Error("XTEST must define six status flags without borrowing or modifying any other state")
+				}
+				if !x86ResultValueStackContinuation(ins, &state, arch) ||
+					x86ResultDirectionAfter(ins, state.direction) != state.direction ||
+					x86ResultCallerAddressesAfter(ins, state.callerAddressGP, nil, arch) != state.callerAddressGP {
+					t.Error("status query destroyed private storage, DF or unrelated caller identity")
+				}
+			})
+		}
+	}
+}
+
+func TestX86RTMGrammarRejectsConstructedIdentityAndNonIntegerAbort(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, spelling := range []string{"XABORT $0.0", "XTEST"} {
+			t.Run(arch+"/"+spelling, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, spelling)
+				if ins.Op == "XABORT" {
+					requireX86GoAssemblerResult(t, arch, "TEXT bad(SB),4,$0-0\n"+spelling+"\nRET\n", false)
+				} else {
+					ins.Op = "XEND" // A dispatcher may not reinterpret a different original opcode.
+				}
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				before, temporary := output.String(), ctx.tmp
+				op := Op(strings.Fields(spelling)[0])
+				known, terminated, err := ctx.lowerRTM(0, 0, op, ins, nil)
+				if !known || terminated || err == nil || output.String() != before || ctx.tmp != temporary {
+					t.Fatal("malformed RTM source emitted an instruction", known, terminated, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86RTMStatusQueryRawCompositionKeepsBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		x86RegisterQueryRawCompositionRoles(t, arch, "XTEST", []byte{0x0f, 0x01, 0xd6}, "MOVL $1,AX\n")
+	}
+}
+
+func TestX86RTMAbortCompleteIntegerImmediateDomain(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var source strings.Builder
+	source.WriteString("TEXT ·Abort(SB),4,$0-0\n")
+	var bytesWant []byte
+	for immediate := 0; immediate < 256; immediate++ {
+		fmt.Fprintf(&source, "XABORT $%d\n", immediate)
+		bytesWant = append(bytesWant, 0xc6, 0xf8, byte(immediate))
+	}
+	source.WriteString("RET\n")
+	bytesWant = append(bytesWant, 0xc3)
+	for _, arch := range []string{"386", "amd64"} {
+		if got := assembleX87ControlBytes(t, arch, source.String()); !bytes.Equal(got, bytesWant) {
+			t.Fatalf("%s original Go abort immediate bytes differ", arch)
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), "func Abort()", target.arch, target.triple, api)
+				if err != nil || strings.Count(ir, "call void @llvm.x86.xabort(") != 256 {
+					t.Fatal("complete integer-domain source did not reach actual aborts", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86RTMStatusQueryThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, value, size := "L", "uint32", 4
+		if target.arch == "amd64" {
+			word, value, size = "Q", "uint64", 8
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				body := "XTEST\n"
+				if raw {
+					body = x86RawDisplacementDirectives([]byte{0x0f, 0x01, 0xd6})
+				}
+				source := fmt.Sprintf("TEXT ·Query(SB),4,$0-%d\nPUSH%s seed+0(FP)\nPOPF%s\n%sPUSHF%s\nPOP%s AX\nMOV%s AX,ret+%d(FP)\nRET\n",
+					2*size, word, word, body, word, word, word, size)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Query(seed "+value+") "+value, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Error("original complete status query rejected", api, err)
+						continue
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_runtime386_bounded_scratch_test.go b/x86_runtime386_bounded_scratch_test.go
new file mode 100644
index 000000000..2dedee43a
--- /dev/null
+++ b/x86_runtime386_bounded_scratch_test.go
@@ -0,0 +1,238 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// This is a distinct complete-source counterpart, not a replacement of the
+// original Windows runtime owner. Preserve all18 TEXTs, manual transport roles,
+// the existing BX-only correction and the C driver. No GoModule ABI is invented
+// for cas64's original SI/AX/DX/BX/CX register convention.
+var runtime386BoundedScratchPatches = [][2]string{
+	{"TEXT floorValue(SB),NOSPLIT,$0-16", "TEXT floorValue(SB),NOSPLIT,$4-16"},
+	{"\tFSTCW -2(SP)\n", "\tFSTCW savedCW-2(SP)\n"},
+	{"\tMOVW -2(SP), AX\n", "\tMOVW savedCW-2(SP), AX\n"},
+	{"\tMOVW AX, -4(SP)\n", "\tMOVW AX, roundCW-4(SP)\n"},
+	{"\tFLDCW -4(SP)\n", "\tFLDCW roundCW-4(SP)\n"},
+	{"\tFLDCW -2(SP)\n", "\tFLDCW savedCW-2(SP)\n"},
+	{"TEXT uint32ToFloat64(SB),NOSPLIT,$0-12", "TEXT uint32ToFloat64(SB),NOSPLIT,$8-12"},
+	{"\tMOVL AX, 0(SP)\n", "\tMOVL AX, integer-8(SP)\n"},
+	{"\tMOVL $0, 4(SP)\n", "\tMOVL $0, integer-4(SP)\n"},
+	{"\tFMOVV 0(SP), F0\n", "\tFMOVV integer-8(SP), F0\n"},
+}
+
+func runtime386ScratchReplace(t *testing.T, source, before, after string) string {
+	t.Helper()
+	if before == after || strings.Count(source, before) != 1 {
+		t.Fatalf("scratch producer is not unique: %q", before)
+	}
+	return strings.Replace(source, before, after, 1)
+}
+
+func runtime386BoundedScratchAssembly(t *testing.T) string {
+	t.Helper()
+	source := runtime386CoreCorrectedAssembly(t)
+	for _, patch := range runtime386BoundedScratchPatches {
+		source = runtime386ScratchReplace(t, source, patch[0], patch[1])
+	}
+	return source
+}
+
+func runtime386ScratchSourceBodies(t *testing.T, source string) []string {
+	t.Helper()
+	parts := strings.Split(source, "\nTEXT ")
+	if len(parts) != 19 || parts[0] != "" {
+		t.Fatal("complete original eighteen-TEXT source inventory changed")
+	}
+	for index := 1; index < len(parts); index++ {
+		parts[index] = "TEXT " + parts[index]
+	}
+	return parts[1:]
+}
+
+func TestRuntimeExec386CoreBoundedScratchKeepsCompleteSource(t *testing.T) {
+	for _, pin := range []struct{ name, source, digest string }{
+		{"original18", runtime386CoreAssembly, "8cfb20eb17f5105cb92fc184bffa1333007c80fcfe19865795ed15b0c6d1fbb2"},
+		{"BX-only18", runtime386CoreCorrectedAssembly(t), "27ba9d589e34fd6be7497b7ea180d498453f2fe9d7b6d1c2aa14ca4cafdeb331"},
+		{"original-C-driver", runtime386CoreCSource, "50eb6e546b44eff9347c96721d22f49eb70e0be57b2be06b75c2324cae12916a"},
+	} {
+		if got := fmt.Sprintf("%x", sha256.Sum256([]byte(pin.source))); got != pin.digest {
+			t.Fatal("original fixture bytes changed", pin.name, got)
+		}
+	}
+	// Pin the actual manual-options producer, including its ordinary target,
+	// modes, complete frame slots and custom-register signature. CRLF source
+	// normalization changes no Go token or raw literal value.
+	data, err := os.ReadFile("x86_runtime386_core_fixture_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := strings.ReplaceAll(string(data), "\r\n", "\n")
+	positions := token.NewFileSet()
+	parsed, err := parser.ParseFile(positions, "original-fixture.go", text, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	found := 0
+	for _, declaration := range parsed.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "runtime386CoreOptions" {
+			continue
+		}
+		found++
+		start, end := positions.Position(function.Pos()).Offset, positions.Position(function.End()).Offset
+		if got := fmt.Sprintf("%x", sha256.Sum256([]byte(text[start:end]))); got != "26215a784fbdd37a0375d0c39535bf48a9f79946388671669e975072545d4957" {
+			t.Fatal("original manual-options producer changed", got)
+		}
+	}
+	if found != 1 {
+		t.Fatal("original manual-options producer is not unique")
+	}
+	corrected, bounded := runtime386CoreCorrectedAssembly(t), runtime386BoundedScratchAssembly(t)
+	restored := bounded
+	for _, patch := range runtime386BoundedScratchPatches {
+		restored = runtime386ScratchReplace(t, restored, patch[1], patch[0])
+	}
+	if restored != corrected || strings.Count(bounded, "\tMOVBLZX BX,BX\n") != 1 {
+		t.Fatal("bounded counterpart changed more than the two scratch producers or lost the BX correction")
+	}
+	beforeBodies, afterBodies := runtime386ScratchSourceBodies(t, corrected), runtime386ScratchSourceBodies(t, bounded)
+	file, err := Parse(ArchAMD64, bounded)
+	if err != nil || len(file.Funcs) != 18 {
+		t.Fatal("complete bounded source lost an original TEXT", err)
+	}
+	options := runtime386CoreOptions()
+	if len(options.Sigs) != 18 || options.Goarch != "386" || options.TargetTriple != "i686-pc-windows-msvc" || options.X87Mode != X87Auto {
+		t.Fatal("bounded counterpart changed the original target/mode/signature inventory")
+	}
+	if !reflect.DeepEqual(options.Sigs["cas64"].ArgRegs, []Reg{SI, AX, DX, BX, CX}) || options.Sigs["cas64"].Ret != I1 {
+		t.Fatal("bounded scratch fabricated a Go ABI0 cas64 declaration")
+	}
+	for index, function := range file.Funcs {
+		t.Run(function.Sym, func(t *testing.T) {
+			if !strings.HasPrefix(afterBodies[index], "TEXT "+function.Sym+"(SB),") || options.Sigs[function.Sym].Name != function.Sym {
+				t.Fatal("original ordered TEXT/signature identity changed")
+			}
+			switch function.Sym {
+			case "floorValue":
+				if function.FrameSize != 4 || function.ArgSize != 16 || strings.Count(afterBodies[index], "savedCW-2(SP)") != 3 || strings.Count(afterBodies[index], "roundCW-4(SP)") != 2 {
+					t.Fatal("floor scratch does not have its exact two distinct bounded words")
+				}
+			case "uint32ToFloat64":
+				if function.FrameSize != 8 || function.ArgSize != 12 || !strings.Contains(afterBodies[index], "MOVL AX, integer-8(SP)\n\tMOVL $0, integer-4(SP)\n\tFMOVV integer-8(SP), F0") {
+					t.Fatal("unsigned conversion lost the complete eight-byte integer producer")
+				}
+			default:
+				if beforeBodies[index] != afterBodies[index] {
+					t.Fatal("another original TEXT changed", function.Sym)
+				}
+			}
+		})
+	}
+}
+
+func TestRuntimeExec386CoreBoundedScratchOriginalGoObjects(t *testing.T) {
+	for _, row := range []struct{ name, source string }{
+		{"original18", runtime386CoreAssembly},
+		{"BX-only18", runtime386CoreCorrectedAssembly(t)},
+		{"bounded-complete18", runtime386BoundedScratchAssembly(t)},
+	} {
+		t.Run(row.name, func(t *testing.T) { runtime386CoreGoObject(t, row.source) })
+	}
+	// These are complete actual Windows386 Go objects, not native execution,
+	// memory permission, or original-Go ABI0 validation of the C transport.
+}
+
+func TestRuntimeExec386CoreBoundedScratchCompleteTextModuleObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete bounded Windows386 objects require LLVM22 llc")
+	}
+	source := runtime386BoundedScratchAssembly(t)
+	functions, err := Parse(ArchAMD64, source)
+	if err != nil || len(functions.Funcs) != 18 {
+		t.Fatal("complete bounded source lost its full inventory", err)
+	}
+	for _, api := range []string{"text", "module"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := runtime386CoreTranslate(t, source, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete bounded source has an independent unclosed contract; backend axes not attempted", err)
+			}
+			for _, function := range functions.Funcs {
+				x86StringMemoryFunction(t, ir, function.Sym)
+			}
+			if !strings.Contains(ir, "target triple = \"i686-pc-windows-msvc\"") {
+				t.Fatal("complete bounded observation changed the original target")
+			}
+			for _, level := range []string{"0", "2"} {
+				input := ir
+				if level == "2" {
+					input = x86DwordProductIROptimize(t, input)
+				}
+				for _, backend := range []string{"0", "2"} {
+					t.Run("IR"+level+"/backend"+backend, func(t *testing.T) {
+						x86PackedStringCompileObject(t, llc, "i686-pc-windows-msvc", input, "-O"+backend)
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestRuntimeExec386CoreBoundedScratchSingleMutationBoundaries(t *testing.T) {
+	source := runtime386BoundedScratchAssembly(t)
+	mutations := []struct{ name, before, after string }{
+		{"floor-zero-frame", "TEXT floorValue(SB),NOSPLIT,$4-16", "TEXT floorValue(SB),NOSPLIT,$0-16"},
+		{"floor-physical-SP", "savedCW-2(SP)", "-2(SP)"},
+		{"floor-outside-frame", "roundCW-4(SP)", "roundCW-6(SP)"},
+		{"floor-missing-CW-write", "\tFSTCW savedCW-2(SP)\n", ""},
+		{"floor-partial-CW-write", "\tFSTCW savedCW-2(SP)\n", "\tMOVB $127,savedCW-2(SP)\n"},
+		{"floor-missing-round-CW-byte", "\tMOVW AX, roundCW-4(SP)\n", "\tMOVB AX, roundCW-4(SP)\n"},
+		{"floor-one-path-no-CW-write", "\tFSTCW savedCW-2(SP)\n", "\tMOVL value+0(FP),AX\n\tTESTL AX,AX\n\tJE noFloorCW\n\tFSTCW savedCW-2(SP)\nnoFloorCW:\n"},
+		{"integer-zero-frame", "TEXT uint32ToFloat64(SB),NOSPLIT,$8-12", "TEXT uint32ToFloat64(SB),NOSPLIT,$0-12"},
+		{"integer-physical-SP", "integer-8(SP)", "0(SP)"},
+		{"integer-outside-frame", "integer-8(SP)", "integer-12(SP)"},
+		{"integer-missing-low-write", "\tMOVL AX, integer-8(SP)\n", ""},
+		{"integer-missing-high-write", "\tMOVL $0, integer-4(SP)\n", ""},
+		{"integer-partial-high-write", "\tMOVL $0, integer-4(SP)\n", "\tMOVW $0, integer-4(SP)\n"},
+		{"integer-one-path-no-high-write", "\tMOVL $0, integer-4(SP)\n", "\tTESTL AX,AX\n\tJE noIntegerHigh\n\tMOVL $0, integer-4(SP)\nnoIntegerHigh:\n"},
+	}
+	for _, mutation := range mutations {
+		// Address-role mutations intentionally change every use of exactly one
+		// scratch cell; other mutations change one actual source instruction.
+		if !strings.Contains(source, mutation.before) {
+			t.Fatal("single-axis mutation no longer identifies its source", mutation.name)
+		}
+		changed := strings.ReplaceAll(source, mutation.before, mutation.after)
+		if mutation.name == "integer-physical-SP" {
+			changed = strings.ReplaceAll(changed, "integer-4(SP)", "4(SP)")
+		} else if mutation.name == "integer-outside-frame" {
+			changed = strings.ReplaceAll(changed, "integer-4(SP)", "integer-8(SP)")
+		}
+		if changed == source || len(runtime386ScratchSourceBodies(t, changed)) != 18 {
+			t.Fatal("single-axis mutation lost complete original source", mutation.name)
+		}
+		for _, api := range []string{"text", "module"} {
+			t.Run(mutation.name+"/"+api, func(t *testing.T) {
+				ir, err := runtime386CoreTranslate(t, changed, api)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("changed complete source bypassed scratch/input obligation: output=%t error=%v", ir != "", err)
+				}
+				t.Logf("actual first Context for %s (not a certificate for a later boundary): %v", mutation.name, err)
+			})
+		}
+	}
+	// This951 checkpoint has no new word/integer proof. Retain any real false
+	// pass or independent earlier Context; do not weaken these expectations or
+	// call an unrelated first rejection proof of a particular scratch boundary.
+}
diff --git a/x86_runtime386_core_fixture_test.go b/x86_runtime386_core_fixture_test.go
new file mode 100644
index 000000000..ddbbd2d15
--- /dev/null
+++ b/x86_runtime386_core_fixture_test.go
@@ -0,0 +1,326 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+// Shared verbatim source, manual transport signatures and native C driver.
+// Portable object observations do not turn this fixture into a Go ABI0 body.
+const runtime386CoreAssembly = `
+TEXT addCarry(SB),NOSPLIT,$0-12
+	MOVL a+0(FP), AX
+	MOVL b+4(FP), BX
+	CMPL AX, $0
+	ADCL BX, AX
+	MOVL AX, ret+8(FP)
+	RET
+
+TEXT cpuidProbe(SB),NOSPLIT,$0-0
+	PUSHFL
+	PUSHFL
+	XORL $0x200000, 0(SP)
+	POPFL
+	PUSHFL
+	POPL AX
+	XORL 0(SP), AX
+	POPFL
+	TESTL $0x200000, AX
+	JNE cpuidAvailable
+	MOVL $0, AX
+	RET
+cpuidAvailable:
+	MOVL $1, AX
+	RET
+
+TEXT frameAddress(SB),NOSPLIT,$0-12
+	LEAL a+0(FP), SI
+	MOVL $41, 4(SI)
+	MOVL b+4(FP), AX
+	MOVL AX, ret+8(FP)
+	RET
+
+TEXT copyForward(SB),NOSPLIT,$0-12
+	MOVL dst+0(FP), DI
+	MOVL src+4(FP), SI
+	MOVL n+8(FP), CX
+	CLD
+	REP; MOVSB
+	RET
+
+TEXT copyBackward(SB),NOSPLIT,$0-12
+	MOVL dst+0(FP), DI
+	MOVL src+4(FP), SI
+	MOVL n+8(FP), CX
+	ADDL CX, DI
+	ADDL CX, SI
+	DECL DI
+	DECL SI
+	STD
+	REP; MOVSB
+	CLD
+	RET
+
+TEXT copyBackwardRestoredDF(SB),NOSPLIT,$0-12
+	MOVL dst+0(FP), DI
+	MOVL src+4(FP), SI
+	MOVL n+8(FP), CX
+	ADDL CX, DI
+	ADDL CX, SI
+	DECL DI
+	DECL SI
+	STD
+	PUSHFL
+	CLD
+	POPFL
+	REP; MOVSB
+	CLD
+	RET
+
+TEXT fillWords(SB),NOSPLIT,$0-12
+	MOVL dst+0(FP), DI
+	MOVL value+4(FP), AX
+	MOVL n+8(FP), CX
+	CLD
+	REP; STOSL
+	RET
+
+TEXT findByte(SB),NOSPLIT,$0-16
+	MOVL data+0(FP), DI
+	MOVL n+4(FP), CX
+	MOVL value+8(FP), AX
+	CLD
+	REPN; SCASB
+	MOVL CX, ret+12(FP)
+	RET
+
+TEXT zeroLengthScanPreservesZF(SB),NOSPLIT,$0-8
+	MOVL data+0(FP), DI
+	MOVL $0, CX
+	CMPL AX, AX
+	REPN; SCASB
+	JNE zfLost
+	MOVL $1, AX
+	MOVL AX, ret+4(FP)
+	RET
+zfLost:
+	MOVL $0, AX
+	MOVL AX, ret+4(FP)
+	RET
+
+TEXT negateHasCarry(SB),NOSPLIT,$0-8
+	MOVL value+0(FP), AX
+	NEGL AX
+	SETCS BX
+	MOVL BX, ret+4(FP)
+	RET
+
+TEXT floorValue(SB),NOSPLIT,$0-16
+	FMOVD value+0(FP), F0
+	FSTCW -2(SP)
+	MOVW -2(SP), AX
+	ANDW $0xf3ff, AX
+	ORW $0x0400, AX
+	MOVW AX, -4(SP)
+	FLDCW -4(SP)
+	FRNDINT
+	FLDCW -2(SP)
+	FMOVDP F0, ret+8(FP)
+	RET
+
+TEXT uint32ToFloat64(SB),NOSPLIT,$0-12
+	MOVL value+0(FP), AX
+	MOVL AX, 0(SP)
+	MOVL $0, 4(SP)
+	FMOVV 0(SP), F0
+	FMOVDP F0, ret+4(FP)
+	RET
+
+TEXT cas64(SB),NOSPLIT,$0-0
+	LOCK
+	CMPXCHG8B (SI)
+	SETEQ AX
+	RET
+
+TEXT xadd32(SB),NOSPLIT,$0-12
+	MOVL ptr+0(FP), BX
+	MOVL delta+4(FP), AX
+	MOVL AX, CX
+	LOCK
+	XADDL AX, 0(BX)
+	ADDL CX, AX
+	MOVL AX, ret+8(FP)
+	RET
+
+TEXT identity64(SB),NOSPLIT,$0-16
+	MOVL value_lo+0(FP), AX
+	MOVL AX, ret_lo+8(FP)
+	MOVL value_hi+4(FP), AX
+	MOVL AX, ret_hi+12(FP)
+	RET
+
+TEXT identityFloat64(SB),NOSPLIT,$0-16
+	MOVL value_lo+0(FP), AX
+	MOVL AX, ret_lo+8(FP)
+	MOVL value_hi+4(FP), AX
+	MOVL AX, ret_hi+12(FP)
+	RET
+
+TEXT readFS(SB),NOSPLIT,$0-4
+	MOVL 0x18(FS), AX
+	MOVL AX, ret+0(FP)
+	RET
+
+TEXT roundNearest(SB),NOSPLIT,$0-16
+	FMOVD value+0(FP), F0
+	FRNDINT
+	FMOVDP F0, ret+8(FP)
+	RET
+`
+
+// Keep the original complete counterexample above. SETCS writes only BL;
+// explicitly extend that byte before the corrected runtime fixture returns
+// all of BX. No other TEXT, transport signature or native observation changes.
+func runtime386CoreCorrectedAssembly(t *testing.T) string {
+	t.Helper()
+	const before = "\tSETCS BX\n\tMOVL BX, ret+4(FP)"
+	const after = "\tSETCS BX\n\tMOVBLZX BX,BX\n\tMOVL BX, ret+4(FP)"
+	if strings.Count(runtime386CoreAssembly, before) != 1 {
+		t.Fatal("original carry-result path is not uniquely identified")
+	}
+	return strings.Replace(runtime386CoreAssembly, before, after, 1)
+}
+
+func runtime386CoreOptions() Options {
+	sig := FuncSig{
+		Name: "addCarry", Args: []LLVMType{I32, I32}, Ret: I32,
+		Frame: FrameLayout{
+			Params:  []FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+			Results: []FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}},
+		},
+	}
+	frameSig := func(name string, args []LLVMType, ret LLVMType, params, results []FrameSlot) FuncSig {
+		return FuncSig{
+			Name: name, Args: args, Ret: ret,
+			Frame: FrameLayout{Params: params, Results: results},
+		}
+	}
+	return Options{
+		TargetTriple: "i686-pc-windows-msvc",
+		Goarch:       "386",
+		Sigs: map[string]FuncSig{
+			"addCarry":   sig,
+			"cpuidProbe": {Name: "cpuidProbe", Ret: I32},
+			"frameAddress": frameSig("frameAddress", []LLVMType{I32, I32}, I32,
+				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}),
+			"copyForward": frameSig("copyForward", []LLVMType{Ptr, Ptr, I32}, Void,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
+			"copyBackward": frameSig("copyBackward", []LLVMType{Ptr, Ptr, I32}, Void,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
+			"copyBackwardRestoredDF": frameSig("copyBackwardRestoredDF", []LLVMType{Ptr, Ptr, I32}, Void,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: Ptr, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
+			"fillWords": frameSig("fillWords", []LLVMType{Ptr, I32, I32}, Void,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}}, nil),
+			"findByte": frameSig("findByte", []LLVMType{Ptr, I32, I32}, I32,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}, {Offset: 8, Type: I32, Index: 2, Field: -1}},
+				[]FrameSlot{{Offset: 12, Type: I32, Index: 0, Field: -1}}),
+			"zeroLengthScanPreservesZF": frameSig("zeroLengthScanPreservesZF", []LLVMType{Ptr}, I32,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}}),
+			"negateHasCarry": frameSig("negateHasCarry", []LLVMType{I32}, I32,
+				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 4, Type: I32, Index: 0, Field: -1}}),
+			"floorValue": frameSig("floorValue", []LLVMType{LLVMType("double")}, LLVMType("double"),
+				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
+			"uint32ToFloat64": frameSig("uint32ToFloat64", []LLVMType{I32}, LLVMType("double"),
+				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 4, Type: LLVMType("double"), Index: 0, Field: -1}}),
+			"cas64": {
+				Name: "cas64", Args: []LLVMType{Ptr, I32, I32, I32, I32}, Ret: I1,
+				ArgRegs: []Reg{SI, AX, DX, BX, CX},
+			},
+			"xadd32": frameSig("xadd32", []LLVMType{Ptr, I32}, I32,
+				[]FrameSlot{{Offset: 0, Type: Ptr, Index: 0, Field: -1}, {Offset: 4, Type: I32, Index: 1, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: I32, Index: 0, Field: -1}}),
+			"identity64": frameSig("identity64", []LLVMType{I64}, I64,
+				[]FrameSlot{{Offset: 0, Type: I64, Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: I64, Index: 0, Field: -1}}),
+			"identityFloat64": frameSig("identityFloat64", []LLVMType{LLVMType("double")}, LLVMType("double"),
+				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
+			"readFS": frameSig("readFS", nil, I32, nil,
+				[]FrameSlot{{Offset: 0, Type: I32, Index: 0, Field: -1}}),
+			"roundNearest": frameSig("roundNearest", []LLVMType{LLVMType("double")}, LLVMType("double"),
+				[]FrameSlot{{Offset: 0, Type: LLVMType("double"), Index: 0, Field: -1}},
+				[]FrameSlot{{Offset: 8, Type: LLVMType("double"), Index: 0, Field: -1}}),
+		},
+	}
+}
+
+const runtime386CoreCSource = `
+int _fltused;
+extern int addCarry(int, int);
+extern int cpuidProbe(void);
+extern int frameAddress(int, int);
+extern void copyForward(unsigned char *, const unsigned char *, unsigned int);
+extern void copyBackward(unsigned char *, const unsigned char *, unsigned int);
+extern void copyBackwardRestoredDF(unsigned char *, const unsigned char *, unsigned int);
+extern void fillWords(unsigned int *, unsigned int, unsigned int);
+extern unsigned int findByte(const unsigned char *, unsigned int, unsigned int);
+extern unsigned int zeroLengthScanPreservesZF(const unsigned char *);
+extern unsigned int negateHasCarry(unsigned int);
+extern double floorValue(double);
+extern double uint32ToFloat64(unsigned int);
+extern _Bool cas64(unsigned long long *, unsigned int, unsigned int, unsigned int, unsigned int);
+extern unsigned int xadd32(unsigned int *, unsigned int);
+extern unsigned long long identity64(unsigned long long);
+extern double identityFloat64(double);
+extern unsigned int readFS(void);
+extern double roundNearest(double);
+int main(void) {
+    unsigned int i;
+    const unsigned char source[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+    unsigned char copied[8] = {0};
+    unsigned char overlap[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+    unsigned char restoredOverlap[9] = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+    unsigned char forwardOverlap[5] = {1, 2, 3, 4, 5};
+    unsigned int words[4] = {0};
+    __declspec(align(8)) unsigned long long word = 0x1122334455667788ULL;
+    unsigned int atomicWord = 10;
+    if (addCarry(20, 22) != 42) return 11;
+    if (cpuidProbe() != 1) return 12;
+    if (frameAddress(20, 22) != 41) return 13;
+    copyForward(copied, source, 8);
+    for (i = 0; i < 8; i++) if (copied[i] != source[i]) return 14;
+    copyBackward(overlap + 1, overlap, 8);
+    for (i = 0; i < 8; i++) if (overlap[i + 1] != i) return 15;
+    copyBackwardRestoredDF(restoredOverlap + 1, restoredOverlap, 8);
+    for (i = 0; i < 8; i++) if (restoredOverlap[i + 1] != i) return 31;
+    fillWords(words, 0x89abcdefU, 4);
+    for (i = 0; i < 4; i++) if (words[i] != 0x89abcdefU) return 16;
+    if (findByte(source, 8, 4) != 4) return 17;
+    if (findByte(source, 8, 9) != 0) return 18;
+    if (zeroLengthScanPreservesZF(source) != 1) return 32;
+    if (negateHasCarry(0) != 0 || negateHasCarry(7) != 1) return 33;
+    if (floorValue(3.75) != 3.0 || floorValue(-3.25) != -4.0) return 19;
+    if (uint32ToFloat64(0xffffffffU) != 4294967295.0) return 20;
+    if (!cas64(&word, 0x55667788U, 0x11223344U, 0xaabbccddU, 0x99aabbccU)) return 21;
+    if (word != 0x99aabbccaabbccddULL) return 22;
+    if (cas64(&word, 0, 0, 1, 2) || word != 0x99aabbccaabbccddULL) return 23;
+    if (xadd32(&atomicWord, 5) != 15 || atomicWord != 15) return 24;
+    if (identity64(0x8877665544332211ULL) != 0x8877665544332211ULL) return 25;
+    if (identityFloat64(-123.75) != -123.75) return 26;
+    copyForward(forwardOverlap + 1, forwardOverlap, 4);
+    for (i = 0; i < 5; i++) if (forwardOverlap[i] != 1) return 27;
+    if (readFS() == 0) return 28;
+    if (roundNearest(2.5) != 2.0 || roundNearest(3.5) != 4.0 || roundNearest(-1.5) != -2.0) return 29;
+    {
+        union { double f; unsigned long long u; } rounded;
+        rounded.f = roundNearest(-0.5);
+        if (rounded.u != 0x8000000000000000ULL) return 30;
+    }
+    return 0;
+}
+`
diff --git a/x86_runtime386_core_objects_test.go b/x86_runtime386_core_objects_test.go
new file mode 100644
index 000000000..22688f8f9
--- /dev/null
+++ b/x86_runtime386_core_objects_test.go
@@ -0,0 +1,197 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func runtime386CoreGoObject(t *testing.T, body string) {
+	t.Helper()
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	include := filepath.Join(runtime.GOROOT(), "pkg", "include")
+	header := filepath.Join(include, "textflag.h")
+	before, err := os.ReadFile(header)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Only the actual selected SDK's header supplies the complete fixture's
+	// existing NOSPLIT spelling. The observed body is never cropped.
+	source := "#include \"textflag.h\"\n" + body
+	directory := t.TempDir()
+	input, object := filepath.Join(directory, "core.s"), filepath.Join(directory, "core.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-I", include, "-p", "runtimecore", "-o", object, input)
+	command.Env = append(os.Environ(), "GOOS=windows", "GOARCH=386", "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goAssemblerOracleOutcome(input, object, output, err, ctx.Err(), true, "386"); failure != nil {
+		t.Fatalf("complete Windows386 Go assembly: %v\n%s", failure, output)
+	}
+	if after, err := os.ReadFile(header); err != nil || !bytes.Equal(before, after) {
+		t.Fatal("selected SDK's original header changed during assembly", err)
+	}
+	x86LEAReadObjectReceipt(t, "386", "windows", source, input, driver, driverHash, object)
+}
+
+func runtime386CoreTranslate(t *testing.T, source, api string) (string, error) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	options := runtime386CoreOptions()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api != "module" {
+		t.Fatal("unknown portable 386 transport API", api)
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := TranslateModuleInContext(context, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		if err == nil {
+			return module.String(), nil
+		}
+	}
+	return "", err
+}
+
+// This portable owner observes all original source and manual transport
+// signatures. It does not execute the Windows C driver or invent a GoModule
+// ABI0 declaration for cas64's existing SI/AX/DX/BX/CX register convention.
+func TestRuntimeExec386CoreCompleteSourceGoAndLLVMObjects(t *testing.T) {
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(runtime386CoreAssembly))); got != "8cfb20eb17f5105cb92fc184bffa1333007c80fcfe19865795ed15b0c6d1fbb2" {
+		t.Fatal("original complete Windows386 source changed", got)
+	}
+	if got := fmt.Sprintf("%x", sha256.Sum256([]byte(runtime386CoreCSource))); got != "50eb6e546b44eff9347c96721d22f49eb70e0be57b2be06b75c2324cae12916a" {
+		t.Fatal("original Windows native C driver changed", got)
+	}
+	want := []string{"addCarry", "cpuidProbe", "frameAddress", "copyForward", "copyBackward", "copyBackwardRestoredDF",
+		"fillWords", "findByte", "zeroLengthScanPreservesZF", "negateHasCarry", "floorValue", "uint32ToFloat64",
+		"cas64", "xadd32", "identity64", "identityFloat64", "readFS", "roundNearest"}
+	file, err := Parse(ArchAMD64, runtime386CoreAssembly)
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := runtime386CoreOptions()
+	if len(file.Funcs) != 18 || len(options.Sigs) != 18 || options.Goarch != "386" || options.TargetTriple != "i686-pc-windows-msvc" {
+		t.Fatal("complete original source/signature/target inventory changed")
+	}
+	for index, function := range file.Funcs {
+		if function.Sym != want[index] || options.Sigs[function.Sym].Name != want[index] {
+			t.Fatal("original TEXT order or manual signature identity changed", function.Sym)
+		}
+	}
+	if !reflect.DeepEqual(options.Sigs["cas64"].ArgRegs, []Reg{SI, AX, DX, BX, CX}) || options.Sigs["cas64"].Ret != I1 {
+		t.Fatal("original custom-register cas64 transport was replaced by a fabricated Go ABI")
+	}
+	corrected := runtime386CoreCorrectedAssembly(t)
+	const insertion = "\tMOVBLZX BX,BX\n"
+	if strings.Count(corrected, insertion) != 1 || strings.Replace(corrected, insertion, "", 1) != runtime386CoreAssembly {
+		t.Fatal("corrected complete fixture differs by more than the one byte-extension instruction")
+	}
+	changed, err := Parse(ArchAMD64, corrected)
+	if err != nil || len(changed.Funcs) != len(file.Funcs) {
+		t.Fatal("corrected complete fixture lost an original TEXT", err)
+	}
+	for index, function := range changed.Funcs {
+		if function.Sym == "negateHasCarry" {
+			if len(function.Instrs) != len(file.Funcs[index].Instrs)+1 {
+				t.Fatal("corrected carry fixture changed another instruction")
+			}
+			found := -1
+			for ordinal, instruction := range function.Instrs {
+				if instruction.Op == "MOVBLZX" {
+					found = ordinal
+					if !reflect.DeepEqual(instruction.Args, []Operand{{Kind: OpReg, Reg: BX}, {Kind: OpReg, Reg: BX}}) {
+						t.Fatal("byte extension changed the original carry-result register")
+					}
+				}
+			}
+			if found <= 0 || function.Instrs[found-1].Op != "SETCS" {
+				t.Fatal("byte extension is not after the original carry-byte producer")
+			}
+			instructions := append([]Instr(nil), function.Instrs[:found]...)
+			function.Instrs = append(instructions, function.Instrs[found+1:]...)
+		}
+		if !reflect.DeepEqual(function, file.Funcs[index]) {
+			t.Fatal("corrected fixture changed an original TEXT, frame, operand or source effect", function.Sym)
+		}
+	}
+	if !t.Run("original-Go-windows386", func(t *testing.T) { runtime386CoreGoObject(t, runtime386CoreAssembly) }) {
+		return
+	}
+	for _, api := range []string{"text", "module"} {
+		t.Run("original-undefined-BX/"+api, func(t *testing.T) {
+			ir, err := runtime386CoreTranslate(t, runtime386CoreAssembly, api)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "negateHasCarry") ||
+				!strings.Contains(err.Error(), "instruction 3: MOVL BX, ret+4(FP)") {
+				t.Fatal("original undefined upper BX bytes acquired a complete numerical result", err)
+			}
+		})
+	}
+	if !t.Run("corrected-Go-windows386", func(t *testing.T) { runtime386CoreGoObject(t, corrected) }) {
+		return
+	}
+	for _, api := range []string{"text", "module"} {
+		t.Run("BX-only-unbounded-scratch/"+api, func(t *testing.T) {
+			ir, err := runtime386CoreTranslate(t, corrected, api)
+			// The complete save/change/restore scope in floorValue now has
+			// independent private-word proof. It supplies no incoming-SP
+			// backing to the next original uint32 conversion function.
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" || !strings.Contains(err.Error(), "uint32ToFloat64") ||
+				!strings.Contains(err.Error(), "requires complete bounded positive original TEXT") {
+				t.Fatal("BX correction manufactured a backing frame for the original physical SP scratch", err)
+			}
+		})
+	}
+	bounded := runtime386BoundedScratchAssembly(t)
+	if !t.Run("bounded-Go-windows386", func(t *testing.T) { runtime386CoreGoObject(t, bounded) }) {
+		return
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete original Windows386 objects require LLVM22 llc")
+	}
+	for _, api := range []string{"text", "module"} {
+		t.Run("bounded-complete18/"+api, func(t *testing.T) {
+			ir, err := runtime386CoreTranslate(t, bounded, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete corrected Windows386 source has an unclosed contract", err)
+			}
+			for _, name := range want {
+				x86StringMemoryFunction(t, ir, name)
+			}
+			if !strings.Contains(ir, "target triple = \"i686-pc-windows-msvc\"") {
+				t.Fatal("portable observation changed the original Windows386 target")
+			}
+			for _, level := range []string{"0", "2"} {
+				input := ir
+				if level == "2" {
+					input = x86DwordProductIROptimize(t, input)
+				}
+				for _, backend := range []string{"0", "2"} {
+					t.Run("IR"+level+"/backend"+backend, func(t *testing.T) {
+						x86PackedStringCompileObject(t, llc, options.TargetTriple, input, "-O"+backend)
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_sad_encoder_test.go b/x86_sad_encoder_test.go
new file mode 100644
index 000000000..1daf3977a
--- /dev/null
+++ b/x86_sad_encoder_test.go
@@ -0,0 +1,74 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86SADIndependentEncoderAttributes(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, op := range []string{"VPSADBW", "VMPSADBW", "VDBPSADBW"} {
+		var expected []goasmrules.X86AVXRule
+		var encoding []string
+		offset := 0
+		add := func(table, zcase string, advance int, classes string) {
+			expected = append(expected, goasmrules.X86AVXRule{
+				Opcode: op, Ytab: table, Prefix: "Pavx", Classes: strings.Split(classes, ","),
+				RowIndex: len(expected), ZCase: zcase, ZOffset: advance, EncodingOffset: offset,
+			})
+			offset += advance
+		}
+		for index, bank := range []string{"x", "y", "z"} {
+			width := 16 << uint(index)
+			if op != "VDBPSADBW" && index < 2 {
+				prefix := fmt.Sprintf("avxEscape | vex%d | vex66 | vex0F", 8*width)
+				if op == "VMPSADBW" {
+					add("_yvblendpd", "Zvex_i_rm_v_r", 2, "Yu8,Y"+bank+"m,Y"+bank+"r,Y"+bank+"r")
+					encoding = append(encoding, prefix+"3A | vexW0", "0x42")
+				} else {
+					add("_yvaesdec", "Zvex_rm_v_r", 2, "Y"+bank+"m,Y"+bank+"r,Y"+bank+"r")
+					encoding = append(encoding, prefix+" | vexW0", "0xF6")
+				}
+			}
+		}
+		if op != "VMPSADBW" {
+			for index, bank := range []string{"x", "y", "z"} {
+				width := 16 << uint(index)
+				classes := "Y" + bank + "mEvex,Y" + bank + "rEvex,Y" + bank + "rEvex"
+				if bank == "z" {
+					classes = "Yzm,Yzr,Yzr"
+				}
+				prefix := fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F", 8*width)
+				if op == "VPSADBW" {
+					add("_yvaesdec", "Zevex_rm_v_r", 3, classes)
+					encoding = append(encoding, prefix+" | evexW0", fmt.Sprintf("evexN%d", width), "0xF6")
+				} else {
+					add("_yvalignd", "Zevex_i_rm_v_r", 0, "Yu8,"+classes)
+					parts := strings.Split(classes, ",")
+					add("_yvalignd", "Zevex_i_rm_v_k_r", 3, "Yu8,"+strings.Join(parts[:2], ",")+",Yknot0,"+parts[2])
+					encoding = append(encoding, prefix+"3A | evexW0", fmt.Sprintf("evexN%d | evexZeroingEnabled", width), "0x42")
+				}
+			}
+		}
+		for index := range expected {
+			expected[index].OpBytes = encoding
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == op {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("%s complete original Go encoding rows changed:\ngot %+v\nwant %+v", op, actual, expected)
+		}
+	}
+}
diff --git a/x86_sad_raw_width_test.go b/x86_sad_raw_width_test.go
new file mode 100644
index 000000000..160090c2c
--- /dev/null
+++ b/x86_sad_raw_width_test.go
@@ -0,0 +1,70 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol. 2B PSADBW/MPSADBW: VEX VPSADBW/VMPSADBW and EVEX
+// VPSADBW are WIG. VDBPSADBW alone requires EVEX.W0. Go emits W0,
+// so the named encoder table cannot detect this physical-decoder boundary.
+// https://cdrdv2-public.intel.com/868141/253667-089-sdm-vol-2b.pdf
+func TestX86SADRawIgnoredWidthAndReservedWidth(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc required")
+	}
+	for _, encoded := range []Op{"VPSADBW", "VPSADBW.EVEX", "VMPSADBW", "VDBPSADBW"} {
+		for width := 0; width < 3; width++ {
+			if width == 2 && (encoded == "VPSADBW" || encoded == "VMPSADBW") {
+				continue
+			}
+			for _, memory := range []bool{false, true} {
+				for _, mode := range []int{32, 64} {
+					t.Run(fmt.Sprintf("%s/width%d/memory%t/mode%d", encoded, width, memory, mode), func(t *testing.T) {
+						original := encodeX86RawPackedSAD(encoded, width, 0, 1, 2, 0, false, memory)
+						changed := append([]byte(nil), original...)
+						changed[2] |= 0x80
+						control, length, known, err := decodedX86RawPackedSADInstruction(original, mode)
+						if !known || err != nil || length != len(original) {
+							t.Fatal("original W0 control failed", err)
+						}
+						actual, length, known, err := decodedX86RawPackedSADInstruction(changed, mode)
+						if encoded == "VDBPSADBW" {
+							if !known || err == nil {
+								t.Fatal("reserved VDBPSADBW W1 acquired semantics")
+							}
+							return
+						}
+						var input strings.Builder
+						for _, code := range [][]byte{original, changed} {
+							for _, value := range code {
+								fmt.Fprintf(&input, "0x%02x ", value)
+							}
+							input.WriteByte('\n')
+						}
+						triple := "x86_64-unknown-linux-gnu"
+						if mode == 32 {
+							triple = "i386-unknown-linux-gnu"
+						}
+						ctx, cancel := runtimeOracleStageContext(t)
+						defer cancel()
+						command := exec.CommandContext(ctx, mc, "-triple="+triple, "-disassemble", "-mattr=+avx2,+avx512f,+avx512bw,+avx512vl")
+						command.Stdin = strings.NewReader(input.String())
+						output, llvmErr := runtimeOracleCombinedOutput(ctx, command)
+						name := strings.ToLower(strings.TrimSuffix(string(encoded), ".EVEX"))
+						if llvmErr != nil || strings.Contains(string(output), "warning") || strings.Count(string(output), name) != 2 {
+							t.Fatalf("LLVM rejected the independent WIG pair: %v\n%s", llvmErr, output)
+						}
+						if !known || err != nil || length != len(changed) || actual.Op != control.Op || !reflect.DeepEqual(actual.Args, control.Args) {
+							t.Fatal("ignored W bit changed the complete physical SAD form", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_scalar_bitcount_format_unit_test.go b/x86_scalar_bitcount_format_unit_test.go
new file mode 100644
index 000000000..b08da3e82
--- /dev/null
+++ b/x86_scalar_bitcount_format_unit_test.go
@@ -0,0 +1,21 @@
+package plan9asm
+
+import "testing"
+
+// Original zero-argument format fixtures have no initialized entry registers
+// or bound native pointers. Retain every Go object, public Context boundary
+// and emitter-only LLVM format; initialized counterparts own public execution.
+func x86ScalarCountUnboundFormatObject(t *testing.T, source, name, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	return x86InstructionFormatObjectUnit(t, file, signatures, arch, triple, 0,
+		func(c *amd64Ctx, instruction Instr) (bool, bool, error) {
+			// This object-only emitter observes the original SP destination
+			// through its virtual register slot, not a native stack contract.
+			// All public APIs above must still reject the unchanged source.
+			c.allowSPWrite = arch == "386" && len(instruction.Args) == 2 &&
+				instruction.Args[1].Kind == OpReg && instruction.Args[1].Reg == SP
+			defer func() { c.allowSPWrite = false }()
+			return c.lowerScalarBitCount(instruction.Op, instruction)
+		})
+}
diff --git a/x86_scalar_bitcount_native_runtime_test.go b/x86_scalar_bitcount_native_runtime_test.go
new file mode 100644
index 000000000..b8e30021d
--- /dev/null
+++ b/x86_scalar_bitcount_native_runtime_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86ScalarCountHostExecution(t *testing.T) x86FloatCompareExecution {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	execution := x86FloatCompareExecution{llc: llc, triple: triple,
+		compiler: []string{clang, "-target", triple}}
+	if runtime.GOOS == "darwin" {
+		ctx, cancel := runtimeOracleStageContext(t)
+		command := runtimeOracleNativeCCommand(t, ctx, clang, "-target", triple)
+		cancel()
+		execution.compiler = command.Args
+	}
+	return execution
+}
+
+func TestX86ScalarBitCountNativeReadPortableValuesAndFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch, cWord, originalTriple := "amd64", "uint64_t", "x86_64-unknown-linux-gnu"
+	if strconv.IntSize == 32 {
+		arch, cWord, originalTriple = "386", "uint32_t", "i386-unknown-linux-gnu"
+	}
+	var assembly, declarations, prototypes, values, callbacks, faults strings.Builder
+	count := 0
+	for kind, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+		widths := []struct {
+			suffix string
+			bits   int
+		}{{"W", 16}, {"L", 32}}
+		if arch == "amd64" {
+			widths = append(widths, struct {
+				suffix string
+				bits   int
+			}{"Q", 64})
+		}
+		for _, width := range widths {
+			for _, dead := range []bool{false, true} {
+				name := fmt.Sprint("Count", count)
+				source, declaration := x86ScalarCountNativeFixture(arch, family+width.suffix, dead)
+				// Keep the indexed address for value observations. The same
+				// function receives a source five bytes before the guarded input.
+				assembly.WriteString(strings.ReplaceAll(source, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+				fmt.Fprintf(&prototypes, "extern %s %s(const uint8_t*);\n", cWord, name)
+				fmt.Fprintf(&values, "{%s,%d,%d,%t},\n", name, width.bits, kind, dead)
+				if dead {
+					fmt.Fprintf(&callbacks, "static int run%d(const uint8_t *p) {\n", count)
+					// Integer address arithmetic avoids constructing an
+					// out-of-object C pointer by subtracting from NULL.
+					fmt.Fprintf(&callbacks, "    return %s((const uint8_t*)((uintptr_t)p-5))==7 ? 0 : 91;\n}\n", name)
+					fmt.Fprintf(&faults, "{run%d,%d,%d},\n", count, width.bits/8, width.bits/8-1)
+				}
+				count++
+			}
+		}
+	}
+	want := 18
+	if arch == "386" {
+		want = 12
+	}
+	if count != want {
+		t.Fatal("incomplete live/dead scalar count directory", count, want)
+	}
+	x86LEAActualTargetGoObject(t, arch, originalTriple, assembly.String())
+	valueDriver := strings.ReplaceAll(x86ScalarCountNativeValueDriver, "COUNT_WORD", cWord)
+	valueDriver = strings.ReplaceAll(valueDriver, "PROTOTYPES", prototypes.String())
+	valueDriver = strings.ReplaceAll(valueDriver, "ROWS", values.String())
+	faultDriver := x86MemoryFaultDriver(prototypes.String()+callbacks.String(), faults.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), arch, execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, passes := range []string{"default", "O2"} {
+				text := ir
+				if passes == "O2" {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(passes+level, func(t *testing.T) {
+						execution.compileAndRunLLVM(t, "count-values", text, valueDriver, level)
+						executable := execution.compileLLVM(t, "count-faults", text, faultDriver, level)
+						x86CheckMemoryFaultMatrix(t, execution, executable, count/2)
+					})
+				}
+			}
+		})
+	}
+	t.Log("live/dead counts, exact W/L/Q native reads, immutable inputs and canaries; actual-host portable LLVM, not original x86 execution")
+}
+
+const x86ScalarCountNativeValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+PROTOTYPES
+struct kernel { COUNT_WORD (*run)(const uint8_t*); unsigned bits,kind; bool dead; };
+static const struct kernel kernels[] = { ROWS };
+
+static unsigned independent_count(uint64_t value, unsigned bits, unsigned kind) {
+    if (kind==0) {
+        unsigned count=0;
+        for (unsigned bit=0;bit<bits;++bit) count+=(unsigned)(value>>bit)&1;
+        return count;
+    }
+    for (unsigned count=0;count<bits;++count) {
+        unsigned bit=kind==1 ? bits-1-count : count;
+        if ((value>>bit)&1) return count;
+    }
+    return bits;
+}
+
+int main(void) {
+    for (unsigned k=0;k<sizeof(kernels)/sizeof(kernels[0]);++k) {
+        for (unsigned sample=0;sample<257;++sample) {
+            const struct kernel *kernel=&kernels[k];
+            uint64_t value=UINT64_C(0x9e3779b97f4a7c15)*sample;
+            if (sample<64) value=UINT64_C(1)<<sample;
+            if (sample==64) value=0;
+            if (sample==65) value=UINT64_MAX;
+            uint8_t input[64],before[64];
+            memset(input,0xa5,sizeof(input));
+            memcpy(input+5,&value,kernel->bits/8);
+            memcpy(before,input,sizeof(input));
+            COUNT_WORD expected=kernel->dead ? 7 : independent_count(value,kernel->bits,kernel->kind);
+            COUNT_WORD got=kernel->run(input);
+            if (got!=expected || memcmp(input,before,sizeof(input))) {
+                fprintf(stderr,"kernel=%u sample=%u bits=%u kind=%u got=%llu want=%llu\n",
+                    k,sample,kernel->bits,kernel->kind,(unsigned long long)got,(unsigned long long)expected);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_scalar_bitcount_native_test.go b/x86_scalar_bitcount_native_test.go
new file mode 100644
index 000000000..338cc7399
--- /dev/null
+++ b/x86_scalar_bitcount_native_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ScalarCountNativeFixture(arch, opcode string, dead bool) (string, string) {
+	word, move, typ := 8, "MOVQ", "uint64"
+	if arch == "386" {
+		word, move, typ = 4, "MOVL", "uint32"
+	}
+	body := fmt.Sprintf("%s p+0(FP),AX\nMOVL $1,DX\n%s $0,BX\n%s 3(AX)(DX*2),BX\n", move, move, opcode)
+	if dead {
+		body += "MOVL $7,BX\n"
+	}
+	body += fmt.Sprintf("%s BX,ret+%d(FP)\nRET\n", move, word)
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word*2, body),
+		"func Value(p *[64]byte) " + typ
+}
+
+func TestX86ScalarBitCountPairedNativeReadCompleteFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var assembly, declarations strings.Builder
+			var names []string
+			for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+				suffixes := []string{"W", "L"}
+				if target.arch == "amd64" {
+					suffixes = append(suffixes, "Q")
+				}
+				for _, suffix := range suffixes {
+					for _, dead := range []bool{false, true} {
+						source, declaration := x86ScalarCountNativeFixture(target.arch, family+suffix, dead)
+						name := fmt.Sprint("Count", len(names))
+						names = append(names, name)
+						assembly.WriteString(strings.ReplaceAll(source, "Value", name))
+						declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, assembly.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, assembly.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete scalar-count family lost its paired native input", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						if strings.Count(text, "load volatile") != len(names) {
+							t.Fatal("live or dead scalar count lost its exact observable source width")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarBitCountPairedNativeReadKeepsInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			suffixes := []string{"W", "L"}
+			if arch == "amd64" {
+				suffixes = append(suffixes, "Q")
+			}
+			for _, suffix := range suffixes {
+				op := family + suffix
+				t.Run(arch+"/"+op, func(t *testing.T) {
+					source, declaration := x86ScalarCountNativeFixture(arch, op, false)
+					body := source[strings.Index(source, "\n")+1:]
+					_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, body)
+					for _, check := range []func(Func, FuncSig, string) error{
+						CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+					} {
+						if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("standalone scalar-count query acquired native input", err)
+						}
+					}
+					for _, missing := range []string{move + " p+0(FP),AX\n", "MOVL $1,DX\n", move + " $0,BX\n"} {
+						changed := strings.Replace(source, missing, "", 1)
+						want := missing == move+" $0,BX\n" && suffix != "W"
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+							if want && (err != nil || ir == "") || !want && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+								t.Fatal("scalar count invented an address, index or untouched upper byte", missing, api, err)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitCountVoidCannotHideNativeInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move, triple := 8, "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, move, triple = 4, "MOVL", "i386-unknown-linux-gnu"
+		}
+		for _, family := range []string{"POPCNT", "LZCNT", "TZCNT"} {
+			suffixes := []string{"W", "L"}
+			if arch == "amd64" {
+				suffixes = append(suffixes, "Q")
+			}
+			for _, suffix := range suffixes {
+				for _, unusedBool := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/%s%s/bool-%t", arch, family, suffix, unusedBool), func(t *testing.T) {
+						source, _ := x86ScalarCountNativeFixture(arch, family+suffix, true)
+						body := source[strings.Index(source, "\n")+1:]
+						body = strings.Replace(body, fmt.Sprintf("%s BX,ret+%d(FP)\n", move, word), "", 1)
+						declaration := "func Value(p *[64]byte)"
+						arguments := word
+						if unusedBool {
+							declaration = "func Value(p *[64]byte,unused bool)"
+							arguments++
+						}
+						source = fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", arguments, body)
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+									t.Fatal("complete Void count lost its native continuation", api, err)
+								}
+								for _, input := range []struct{ name, line string }{
+									{"pointer", move + " p+0(FP),AX\n"}, {"index", "MOVL $1,DX\n"},
+								} {
+									t.Run(input.name, func(t *testing.T) {
+										changed := strings.Replace(source, input.line, "", 1)
+										if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+											t.Fatal("Void count invented a native pointer or index", api, err)
+										}
+									})
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_scalar_bitcount_original_program_test.go b/x86_scalar_bitcount_original_program_test.go
new file mode 100644
index 000000000..c67066c21
--- /dev/null
+++ b/x86_scalar_bitcount_original_program_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import "testing"
+
+func TestX86ScalarCountOriginalLZCNTProgramPortableAndObjects(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	source := x86LZCNTOriginalRuntimeSource
+	declaration := "func lzcntsemantics(out *[56]byte)"
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // The unchanged original source contains LZCNTQ.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", target.triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", target.triple, api)
+				if err != nil {
+					t.Fatal("complete original LZCNT runtime source", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, execution.llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("portable/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "original-lzcnt", text, x86LZCNTOriginalPortableDriver, level)
+				}
+			}
+		})
+	}
+	t.Log("unchanged original source: Go objects, three-target LLVM objects and actual-host portable values/FLAGS/canaries; not original x86 execution")
+}
+
+const x86LZCNTOriginalPortableDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void lzcntsemantics(uint8_t *);
+int main(void) {
+    uint8_t out[72], expected[72];
+    memset(out,0xa5,sizeof(out));
+    memcpy(expected,out,sizeof(out));
+    const uint64_t values[] = {UINT64_C(0xaabbccddeeff0010),0,1,63};
+    const unsigned offsets[] = {0,16,32,40};
+    for (unsigned i=0;i<4;++i) memcpy(expected+8+offsets[i],&values[i],8);
+    expected[8+8]=1; expected[8+9]=0;
+    expected[8+24]=0; expected[8+25]=1;
+    expected[8+48]=0; expected[8+49]=0;
+    lzcntsemantics(out+8);
+    for (unsigned i=0;i<sizeof(out);++i) {
+        if (out[i]!=expected[i]) {
+            fprintf(stderr,"original LZCNT byte=%u got=%x want=%x\n",i,out[i],expected[i]);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
diff --git a/x86_scalar_bitscan_native_read_test.go b/x86_scalar_bitscan_native_read_test.go
new file mode 100644
index 000000000..b4ebd10d8
--- /dev/null
+++ b/x86_scalar_bitscan_native_read_test.go
@@ -0,0 +1,223 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarBitScanNativeReadPreservesExactByteKnowledge(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, family := range []string{"BSF", "BSR"} {
+			for _, suffix := range []string{"W", "L", "Q"} {
+				if arch == "386" && suffix == "Q" {
+					continue
+				}
+				t.Run(arch+"/"+family+suffix, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, family+suffix+" 0(SI),BX")
+					seed := func(prior uint8) x86ResultState {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[3], state.pointerGP[6] = prior, true
+						return state
+					}
+					for prior := 0; prior < 256; prior++ {
+						state := seed(uint8(prior))
+						if accepted, known := x86ResultBitScanStepWithRead(ins, &state, nil, arch, true); !accepted || !known || state.gp[3] != uint8(prior) || state.flags != x86ByteFlagZF {
+							t.Fatal("native read invented zero-input destination or nonportable flags", prior, state)
+						}
+						if x86ResultRead(ins.Args[0], 1, &state, nil, arch) {
+							t.Fatal("paired input created reusable numerical memory")
+						}
+						state = seed(uint8(prior))
+						before := state.clone()
+						if accepted, known := x86ResultBitScanStep(ins, &state, nil, arch); accepted || !known || !reflect.DeepEqual(state, before) {
+							t.Fatal("standalone observer acquired a paired native read")
+						}
+					}
+					for _, change := range []string{"missing address", "raw", "encoded", "near return", "address size", "segment"} {
+						changed, state := ins, seed(0xff)
+						switch change {
+						case "missing address":
+							state.pointerGP[6] = false
+						case "raw":
+							changed.x86SourceRaw = new(x86SourceRawInstruction)
+						case "encoded":
+							changed.x86Encoded = true
+						case "near return":
+							changed.x86RawNearReturn = new(x86RawNearReturnForm)
+						case "address size":
+							changed.x86AddressBits = 32
+						case "segment":
+							changed.x86SegmentPrefix = 0x64
+						}
+						before := state.clone()
+						if accepted, known := x86ResultBitScanStepWithRead(changed, &state, nil, arch, true); accepted || !known || !reflect.DeepEqual(state, before) {
+							t.Fatal("unbound or another source role acquired a paired read", change)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitScanPairedNativeReadWholeFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for _, family := range []string{"BSF", "BSR"} {
+				for _, suffix := range []string{"W", "L", "Q"} {
+					if target.arch == "386" && suffix == "Q" {
+						continue
+					}
+					for _, dead := range []bool{false, true} {
+						name := fmt.Sprint("NativeScan", len(names))
+						names = append(names, name)
+						body, declaration := x86ScalarRMRegisterInitializedFunction(name, family+suffix+" 0(SI),BX", target.arch)
+						if dead {
+							move := "Q"
+							if target.arch == "386" {
+								move = "L"
+							}
+							body = strings.Replace(body, "\nMOV"+move+" BX,ret+", "\nMOVL $7,BX\nMOV"+move+" BX,ret+", 1)
+						}
+						source.WriteString(body)
+						declarations.WriteString(declaration)
+					}
+				}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete native scan family lost its source continuation", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86CompactExpandRequireAllDefinitions(t, text, names)
+						if strings.Count(text, "load volatile") != len(names) {
+							t.Fatal("live or dead scan lost its exact observable read width")
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+						for _, bits := range []int{16, 32, 64} {
+							if bits == 64 && target.arch == "386" {
+								continue
+							}
+							if !strings.Contains(text, fmt.Sprint("load volatile <", bits/8, " x i8>")) {
+								t.Fatal("source width was replaced by the GP carrier", bits)
+							}
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarBitScanPairedReadRetainsProofBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix := goWordSize(target.arch), "Q"
+		if word == 4 {
+			suffix = "L"
+		}
+		for _, family := range []string{"BSF", "BSR"} {
+			for _, width := range []string{"W", "L", "Q"} {
+				if target.arch == "386" && width == "Q" {
+					continue
+				}
+				t.Run(target.triple+"/"+family+width, func(t *testing.T) {
+					source, declaration := x86ScalarRMRegisterInitializedFunction("Value", family+width+" 0(SI),BX", target.arch)
+					body := source[strings.Index(source, "\n")+1:]
+					_, file, sig, _ := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("standalone query acquired a native read", err)
+					}
+					for _, removed := range []string{
+						"MOV" + suffix + " memory+0(FP),SI\n",
+						fmt.Sprintf("MOV%s old+%d(FP),BX\n", suffix, word),
+					} {
+						changed := strings.Replace(source, removed, "", 1)
+						if changed == source {
+							t.Fatal("missing-input control changed no original instruction")
+						}
+						for _, api := range []string{"text", "module", "Go"} {
+							if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("scan invented an address or zero-input prior result", api, removed, err)
+							}
+						}
+					}
+					for _, foreign := range []string{"", "aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, foreign, "module"); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("native scan acquired a foreign or missing backend", foreign, err)
+						}
+					}
+					instruction := family + width + " 0(SI),BX"
+					raw := x86RawNumericalInstruction(t, target.arch, instruction)
+					changed := strings.Replace(source, instruction, raw, 1)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("raw scan borrowed the named native continuation", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarBitScanVoidStillRequiresSourceInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, suffix, triple := goWordSize(arch), "Q", "x86_64-unknown-linux-gnu"
+		if word == 4 {
+			suffix, triple = "L", "i386-unknown-linux-gnu"
+		}
+		for _, family := range []string{"BSF", "BSR"} {
+			for _, width := range []string{"W", "L", "Q"} {
+				if arch == "386" && width == "Q" {
+					continue
+				}
+				for _, operand := range []string{"CX", "0(SI)"} {
+					for _, unused := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%s%s/%s/bool-%t", arch, family, width, operand, unused), func(t *testing.T) {
+							operation := family + width + " " + operand + ",BX"
+							source, _ := x86ScalarRMRegisterInitializedFunction("Value", operation, arch)
+							body := source[strings.Index(source, "\n")+1:]
+							body = strings.Replace(body, fmt.Sprintf("MOV%s BX,ret+%d(FP)\n", suffix, 3*word), "", 1)
+							declaration, size := "func Value(memory *[8]byte,old,input uintptr)", 3*word
+							if unused {
+								declaration = "func Value(memory *[8]byte,old,input uintptr,unused bool)"
+								size++
+							}
+							source = fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", size, body)
+							removed := fmt.Sprintf("MOV%s input+%d(FP),CX\nCMPL CX,CX\n", suffix, 2*word)
+							if operand == "0(SI)" {
+								removed = "MOV" + suffix + " memory+0(FP),SI\n"
+							}
+							changed := strings.Replace(source, removed, "", 1)
+							if changed == source {
+								t.Fatal("input control did not alter the original source")
+							}
+							for _, api := range []string{"text", "module", "Go"} {
+								if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); ir == "" || err != nil {
+									t.Fatal("complete Void scan lost its initialized inputs", api, err)
+								}
+								if ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("dead scan invented a numerical input or native address", api, err)
+								}
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_scalar_compare_input_boundary_test.go b/x86_scalar_compare_input_boundary_test.go
new file mode 100644
index 000000000..7c37c85cc
--- /dev/null
+++ b/x86_scalar_compare_input_boundary_test.go
@@ -0,0 +1,174 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarCompareMemoryRoutesExistingTypedProof(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operation := range x86ScalarCompareNames(arch) {
+			ins := x86PureGPUnknownInstruction(t, x86ScalarCompareInstruction(operation, "(SI)", "$0"))
+			for _, raw := range []bool{false, true} {
+				ins.x86Encoded = raw
+				if !x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, arch) {
+					t.Fatal("dead named/raw memory read bypassed the existing whole-input proof", arch, operation, raw)
+				}
+			}
+		}
+		for _, instruction := range []string{"CMPL AX,$128", "TESTL CX,BX", "LEAL (SI),BX"} {
+			ins := x86PureGPUnknownInstruction(t, instruction)
+			if x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, arch) {
+				t.Fatal("faulting-read routing absorbed nontrapping GP scratch or address calculation", arch, instruction)
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareRowsCannotSupplyNumericalInputs(t *testing.T) {
+	for _, item := range []struct{ operation, removed string }{
+		{"CMPL AX,$128", "MOVQ a+16(FP),AX\n"},
+		{"CMPL CX,BX", "MOVQ c+32(FP),CX\n"},
+		{"TESTL 0(SI),BX", "MOVQ memory+0(FP),SI\n"},
+	} {
+		source, declaration := x86ScalarCompareInitializedFunction("CompareMissing", item.operation, "amd64")
+		if strings.Count(source, item.removed) != 1 {
+			t.Fatal("negative failed to remove one original numerical/address source")
+		}
+		source = strings.Replace(source, item.removed, "", 1)
+		for _, api := range []string{"text", "module", "Go"} {
+			if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("source compare transport supplied missing numerical/address input", item.operation, api, err)
+			}
+		}
+	}
+	for _, operation := range []string{"CMPL 0(SI),$128", "TESTL 0(SI),BX"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			source := "TEXT ·CompareVoid(SB),4,$0-0\n" + operation + "\nRET\n"
+			if ir, err := x86ScalarFPBitViewAPI(t, source, "func CompareVoid()", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("dead Void hid an unknown faulting scalar memory read", operation, api, err)
+			}
+		}
+	}
+	for _, operation := range []string{"CMPL AX,$128", "TESTL CX,BX"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			source := "TEXT ·CompareBool(SB),4,$0-1\n" + operation + "\nSETEQ AL\nMOVB AL,ret+0(FP)\nRET\n"
+			if ir, err := x86ScalarFPBitViewAPI(t, source, "func CompareBool() bool", "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("observable comparison status manufactured an unknown numerical input", operation, api, err)
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareDeadScratchIsNotNumericalEvidence(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, operation := range []string{"CMPL AX,$128", "TESTL CX,BX"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			// Unknown scratch may flow through a nontrapping GP instruction
+			// when no result, memory address or control decision observes it.
+			// Object success here establishes no NUM bytes or status values.
+			source := "TEXT ·CompareDead(SB),4,$0-0\n" + operation + "\nRET\n"
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func CompareDead()", "amd64", "x86_64-unknown-linux-gnu", api)
+			if err != nil || ir == "" {
+				t.Fatal("ordinary nontrapping dead GP scratch lost its existing contract", operation, api, err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, "x86_64-unknown-linux-gnu", ir, level)
+			}
+		}
+	}
+}
+
+func TestX86ScalarCompareDeadMemoryKeepsExactVolatileRead(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "Q"
+		if word == 4 {
+			move = "L"
+		}
+		var source, declarations strings.Builder
+		for index, operation := range x86ScalarCompareNames(arch) {
+			for _, live := range []bool{false, true} {
+				name := fmt.Sprintf("CompareMemory%d_%t", index, live)
+				value, bytes := "$0", word
+				declaration := fmt.Sprintf("func %s(memory *[8]byte)\n", name)
+				seed, result := "", ""
+				if live {
+					value, bytes = "CX", 2*word+1
+					declaration = fmt.Sprintf("func %s(memory *[8]byte,value uintptr) bool\n", name)
+					seed = fmt.Sprintf("MOV%s value+%d(FP),CX\n", move, word)
+					result = fmt.Sprintf("SETEQ AL\nMOVB AL,ret+%d(FP)\n", 2*word)
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s memory+0(FP),AX\n%s%s\n%sRET\n",
+					name, bytes, move, seed, x86ScalarCompareInstruction(operation, "(AX)", value), result)
+				declarations.WriteString(declaration)
+			}
+		}
+		// Sixteen AMD64 / twelve I386 complete functions per assembler and
+		// compiler batch. Source syntax is independently checked with Go.
+		x86Legacy127OriginalListing(t, arch, source.String(), true)
+		for _, target := range x86Legacy127Targets(arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, target, api)
+				if err != nil || ir == "" {
+					t.Fatal("known-address comparison lost its original dead/live read", arch, target, api, err)
+				}
+				optimized := x86DwordProductIROptimize(t, ir)
+				for _, bits := range []int{8, 16, 32, 64} {
+					if arch == "386" && bits == 64 {
+						continue
+					}
+					read := fmt.Sprint("load volatile i", bits)
+					if strings.Count(ir, read) != 4 || !strings.Contains(optimized, read) {
+						t.Fatal("dead flags/test-zero erased or widened an exact faulting memory read", arch, bits, target, api)
+					}
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					x86PackedStringCompileObject(t, llc, target, ir, level)
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarComparePublicMemoryInputsWholeFamily(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "Q"
+		if word == 4 {
+			move = "L"
+		}
+		for _, operation := range x86ScalarCompareNames(arch) {
+			for _, kind := range []string{"unknown-address", "unknown-partner", "live-unknown-partner"} {
+				t.Run(arch+"/"+operation+"/"+kind, func(t *testing.T) {
+					bytes, seed, tail, address := 0, "", "", "(SI)"
+					declaration := "func CompareInput()"
+					if kind != "unknown-address" {
+						bytes, address = word, "(AX)"
+						seed = fmt.Sprintf("MOV%s memory+0(FP),AX\n", move)
+						declaration = "func CompareInput(memory *[8]byte)"
+					}
+					if kind == "live-unknown-partner" {
+						bytes = word + 1
+						tail = fmt.Sprintf("SETEQ AL\nMOVB AL,ret+%d(FP)\n", word)
+						declaration += " bool"
+					}
+					instruction := x86ScalarCompareInstruction(operation, address, "CX")
+					source := fmt.Sprintf("TEXT ·CompareInput(SB),4,$0-%d\n%s%s\n%sRET\n", bytes, seed, instruction, tail)
+					for _, api := range []string{"text", "module", "Go"} {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86Legacy127Targets(arch)[0], api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Errorf("%s missing address/NUM reached a public dead/live memory compare: %v", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_float_integer_native_read_test.go b/x86_scalar_float_integer_native_read_test.go
new file mode 100644
index 000000000..f6ee55274
--- /dev/null
+++ b/x86_scalar_float_integer_native_read_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// The independent namespace already checks all 32 original Go encoder rows.
+// These source-bound cases exercise their common m32/m64 native continuation,
+// not a declaration-only promise that an opaque pointer has initialized bytes.
+func x86ScalarIntegerNativeNames(arch string) []string {
+	var names []string
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		if arch == "386" && !strings.HasPrefix(name, "V") && strings.HasSuffix(name, "Q") {
+			continue
+		}
+		names = append(names, name)
+	}
+	return names
+}
+
+func x86ScalarIntegerNativeSource(arch, symbol, name, variant string, live bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	setup := fmt.Sprintf("%s p+0(FP),DI\n%s csr+%d(FP),SI\n", move, move, word)
+	operand := "(DI)"
+	switch variant {
+	case "index":
+		setup += "MOVL $0,CX\n"
+		operand = "(DI)(CX*1)"
+	case "missing-pointer":
+		setup = fmt.Sprintf("%s csr+%d(FP),SI\n", move, word)
+	case "numeric-pointer":
+		setup += move + " $4096,DI\n"
+	case "missing-index":
+		operand = "(DI)(CX*1)"
+	case "opaque-index":
+		setup += move + " p+0(FP),CX\n"
+		operand = "(DI)(CX*2)"
+	case "missing-vector":
+		operand = "X1"
+	case "initialized-vector":
+		setup += "PXOR X1,X1\n"
+		operand = "X1"
+	case "missing-mxcsr-pointer":
+		setup = move + " p+0(FP),DI\n"
+	}
+	frame, result, ret := 2*word, "", ""
+	if live {
+		frame += 4
+		result = fmt.Sprintf("MOVL AX,ret+%d(FP)\n", 2*word)
+		ret = " uint32"
+	} else {
+		result = "XORL AX,AX\n"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%sLDMXCSR (SI)\n%s %s,AX\n%sRET\n",
+		symbol, frame, setup, name, operand, result)
+	declaration := fmt.Sprintf("func %s(p *uint64,csr *uint32)%s\n", symbol, ret)
+	return source, declaration
+}
+
+func TestX86ScalarFloatIntegerPairedNativeReadCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			type function struct {
+				name  string
+				width int
+			}
+			var functions []function
+			for _, name := range x86ScalarIntegerNativeNames(target.arch) {
+				for _, live := range []bool{false, true} {
+					symbol := fmt.Sprintf("native%d", len(functions))
+					variant := ""
+					if live {
+						variant = "index"
+					}
+					body, decl := x86ScalarIntegerNativeSource(target.arch, symbol, name, variant, live)
+					source.WriteString(body)
+					declarations.WriteString(decl)
+					width := 4
+					if strings.Contains(name, "SD") {
+						width = 8
+					}
+					functions = append(functions, function{symbol, width})
+				}
+			}
+			// The entire original program is independently assembled first.
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized original native conversion did not close", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						for _, fn := range functions {
+							body := x86StringMemoryFunction(t, input, fn.name)
+							if strings.Count(body, "~{fpsr}") != 1 || !strings.Contains(body, "asm sideeffect") ||
+								!strings.Contains(body, "*m,~{memory},~{fpsr}") || !strings.Contains(body, fmt.Sprintf("elementtype([%d x i8])", fn.width)) ||
+								strings.Contains(body, "fptosi ") || strings.Contains(body, "fptoui ") {
+								t.Fatal("dead or live conversion lost its exact native read/MXCSR effect", fn.name, optimized, body)
+							}
+						}
+						compileLLVMToObject(t, llc, target.triple, "scalar-native-read.ll", "scalar-native-read.o", input)
+					}
+				})
+			}
+			t.Logf("%d complete initialized original functions; 3 APIs, original/O2 IR objects; not native execution", len(functions))
+		})
+	}
+}
+
+func TestX86ScalarFloatIntegerPairedReadRequiresIndependentInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		type sample struct {
+			name, variant, source, decl string
+			live                        bool
+		}
+		var samples []sample
+		var original strings.Builder
+		for _, name := range x86ScalarIntegerNativeNames(arch) {
+			for _, live := range []bool{false, true} {
+				for _, variant := range []string{"index", "initialized-vector", "missing-pointer", "numeric-pointer", "missing-index", "opaque-index", "missing-vector", "missing-mxcsr-pointer"} {
+					symbol := fmt.Sprintf("input%d", len(samples))
+					source, decl := x86ScalarIntegerNativeSource(arch, symbol, name, variant, live)
+					samples = append(samples, sample{name, variant, source, decl, live})
+					original.WriteString(source)
+				}
+			}
+		}
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		for _, item := range samples {
+			t.Run(fmt.Sprintf("%s/%s/%s/live=%t", arch, item.name, item.variant, item.live), func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, item.source, item.decl, arch, triple, api)
+						positive := item.variant == "index" || item.variant == "initialized-vector" || item.variant == "numeric-pointer"
+						if arch == "amd64" && item.variant == "missing-vector" {
+							x86VectorScratchCodegenControl(t, item.source, item.decl, arch, triple, ir, err)
+						} else if positive && err != nil || !positive && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("native input/pointer role mismatch", positive, err)
+						}
+						if item.variant == "numeric-pointer" {
+							x86RequireNumericNativeSourceContext(t, item.source, item.decl, arch)
+							width := 4
+							if strings.Contains(item.name, "SD") {
+								width = 8
+							}
+							// Go's SL/SQ aliases use hardware SI, and VEX/EVEX W
+							// does not select a 64-bit GP result in mode32.
+							mnemonic := strings.TrimSuffix(strings.TrimSuffix(item.name, "Q"), "L")
+							if !strings.HasPrefix(item.name, "V") {
+								mnemonic += "I"
+							}
+							suffix := "l"
+							if arch == "amd64" && strings.HasSuffix(item.name, "Q") {
+								suffix = "q"
+							}
+							mnemonic = strings.ToLower(mnemonic) + suffix
+							if !strings.Contains(ir, "asm sideeffect") || !strings.Contains(ir, mnemonic+" ") ||
+								!strings.Contains(ir, fmt.Sprintf("elementtype([%d x i8])", width)) ||
+								!strings.Contains(ir, "*m,~{memory},~{fpsr}") || strings.Count(ir, "~{fpsr}") != 1 {
+								t.Fatal("numerical address lost its original exact-width conversion/MXCSR effect", ir)
+							}
+							x86NumericNativeAddressObject(t, ir, triple)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerNativeEffectsDoNotGrantObserverBytes(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, name := range x86ScalarIntegerNativeNames(arch) {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, name+" (DI),AX")
+				effect, known, err := x86TypedScalarFloatIntegerByteEffect(ins.Op, ins, arch)
+				if err != nil || !known || !effect.requiresResultProof {
+					t.Error("native conversion must check original inputs even for Void", known, err)
+				}
+				state := &x86ResultState{flags: 0x3f}
+				state.pointerGP[7] = true
+				before := state.clone()
+				accepted, known := x86ResultScalarFloatIntegerStep(ins, state, nil, 0, arch)
+				if !known || accepted || !reflect.DeepEqual(*state, before) {
+					t.Fatal("strict observer borrowed a native read or mutated failed state", known, accepted)
+				}
+				ins = x86ScalarLaneInstruction(t, name+" X1,AX")
+				state.writeVector(1, 64, ^uint64(0), false)
+				before = state.clone()
+				accepted, known = x86ResultScalarFloatIntegerStep(ins, state, nil, 0, arch)
+				if !known || !accepted || state.flags != before.flags || state.vectorBytes(1) != before.vectorBytes(1) || state.pointerGP[7] != before.pointerGP[7] {
+					t.Fatal("conversion changed FLAGS, its source, or independent pointer identity", known, accepted)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerNativeContinuationRetainsMXCSRTarget(t *testing.T) {
+	var original strings.Builder
+	for index, name := range x86ScalarFloatIntegerOracleNames() {
+		source, _ := x86ScalarIntegerNativeSource("amd64", fmt.Sprintf("target%d", index), name, "", false)
+		original.WriteString(source)
+	}
+	goAssemblerOracleOutput(t, "amd64", original.String(), "", true)
+	for _, name := range x86ScalarFloatIntegerOracleNames() {
+		source, decl := x86ScalarIntegerNativeSource("amd64", "value", name, "", false)
+		for _, triple := range []string{"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown", "i386-unknown-linux-gnu"} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(name+"/"+triple+"/"+api, func(t *testing.T) {
+					if _, err := x86ScalarFPBitViewAPI(t, source, decl, "amd64", triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native continuation invented cross-target MXCSR semantics", err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_float_integer_original_format_test.go b/x86_scalar_float_integer_original_format_test.go
new file mode 100644
index 000000000..2119a09c8
--- /dev/null
+++ b/x86_scalar_float_integer_original_format_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Pair every original named encoder row with actual producers. An initialized
+// vector does not supply a physical SP/BP, segment, AUTO or FP pointer value;
+// those separate storage/entry roles remain explicit Context controls.
+func TestX86ScalarFloatIntegerOriginalRowsInitializedNamedCounterparts(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := 8, "MOVQ"
+			if target.arch == "386" {
+				word, move = 4, "MOVL"
+			}
+			type sample struct {
+				source, declaration string
+				context             bool
+			}
+			var samples []sample
+			var original strings.Builder
+			for index, row := range x86ScalarFloatIntegerFormRows(target.arch) {
+				ins := x86ScalarLaneInstruction(t, row)
+				_, known, err := x86ScalarFloatIntegerProperties(ins, target.arch)
+				if !known || err != nil && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("original named directory became malformed", row, err)
+				}
+				context := err != nil || x86LogicalSourceFrameRegister(ins.Args[1].Reg, target.arch)
+				setup := fmt.Sprintf("%s p+0(FP),BX\nMOVL $0,CX\n", move)
+				source := ins.Args[0]
+				if source.Kind == OpReg {
+					bank, _ := amd64ParseXReg(source.Reg)
+					if target.arch == "386" && bank >= 8 {
+						// Go accepts the original row, but this mode has no
+						// independent physical producer for its high bank.
+						// Initialize only an unrelated, legal low register.
+						context = true
+						setup += "PXOR X0,X0\n"
+					} else if bank >= 16 {
+						setup += fmt.Sprintf("VPXORD Z%d,Z%d,Z%d\n", bank, bank, bank)
+					} else {
+						setup += fmt.Sprintf("PXOR %s,%s\n", source.Reg, source.Reg)
+					}
+				} else if source.Kind != OpMem || source.Mem.Sym != "" || source.Mem.Base != BX {
+					context = true
+				}
+				name := fmt.Sprintf("originalrow%d", index)
+				body := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s%s\nRET\n", name, word, setup, row)
+				decl := fmt.Sprintf("func %s(p *byte)\n", name)
+				samples = append(samples, sample{body, decl, context})
+				original.WriteString(body)
+			}
+			goAssemblerOracleOutput(t, target.arch, original.String(), "", true)
+			var body, declarations strings.Builder
+			positive, contextual, batch, count := 0, 0, 0, 0
+			flush := func() {
+				if count == 0 {
+					return
+				}
+				t.Run(fmt.Sprintf("initialized-batch-%d", batch), func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							if _, err := x86ScalarFPBitViewAPI(t, body.String(), declarations.String(), target.arch, target.triple, api); err != nil {
+								t.Fatal("complete initialized original rows did not close", err)
+							}
+						})
+					}
+				})
+				body.Reset()
+				declarations.Reset()
+				batch++
+				count = 0
+			}
+			for index, item := range samples {
+				if item.context {
+					contextual++
+					t.Run(fmt.Sprintf("independent-storage-role-%d", index), func(t *testing.T) {
+						for _, api := range []string{"text", "module", "Go"} {
+							_, err := x86ScalarFPBitViewAPI(t, item.source, "var data [8]byte\n"+item.declaration, target.arch, target.triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("initialized source supplied a different native storage/entry role", api, err)
+							}
+						}
+					})
+					continue
+				}
+				positive++
+				body.WriteString(item.source)
+				declarations.WriteString(item.declaration)
+				count++
+				if count == 96 {
+					flush()
+				}
+			}
+			flush()
+			if positive+contextual != len(samples) {
+				t.Fatal("original named directory lost a row")
+			}
+			t.Logf("all %d original named rows: %d independently initialized, %d require a separate storage/physical-entry role; 3 public APIs; not native execution", len(samples), positive, contextual)
+		})
+	}
+}
diff --git a/x86_scalar_float_integer_raw_source_test.go b/x86_scalar_float_integer_raw_source_test.go
new file mode 100644
index 000000000..ac28e4f9d
--- /dev/null
+++ b/x86_scalar_float_integer_raw_source_test.go
@@ -0,0 +1,432 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"os/exec"
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+type x86ScalarIntegerRawRow struct {
+	name, operand string
+	code          []byte
+	evex, memory  bool
+}
+
+func x86ScalarIntegerRawRows(t *testing.T, arch string) []x86ScalarIntegerRawRow {
+	t.Helper()
+	var rows []x86ScalarIntegerRawRow
+	var original strings.Builder
+	for _, name := range x86ScalarIntegerNativeNames(arch) {
+		operands := []string{"X1", "(BX)"}
+		if name == "CVTSS2SL" || name == "VCVTSS2SI" || name == "VCVTSS2USIL" {
+			operands = append(operands, "(BX)(CX*1)")
+		}
+		for _, operand := range operands {
+			rows = append(rows, x86ScalarIntegerRawRow{name: name, operand: operand, memory: operand != "X1"})
+			original.WriteString(name + " " + operand + ",AX\n")
+		}
+		if strings.HasPrefix(name, "V") {
+			controls := []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}
+			if strings.Contains(name, "CVTT") {
+				controls = []string{"SAE"}
+			}
+			for _, control := range controls {
+				rows = append(rows, x86ScalarIntegerRawRow{name: name + "." + control, operand: "X1", evex: true})
+				original.WriteString(name + "." + control + " X1,AX\n")
+			}
+		}
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, arch, original.String()+"RET\n")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("actual Go scalar conversion directory lost complete original PCs/RET")
+	}
+	for index := range rows {
+		rows[index].code = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+		rows[index].evex = rows[index].code[0] == 0x62
+	}
+	// Independent low-bank EVEX literals overlap the Go encoder's VEX choice.
+	// They are not attributed to named Go output; llvm-mc checks them below.
+	for _, name := range x86ScalarIntegerNativeNames(arch) {
+		if !strings.HasPrefix(name, "V") || strings.Contains(name, "USI") {
+			continue
+		}
+		pp, opcode := byte(2), byte(0x2d)
+		if strings.Contains(name, "SD") {
+			pp = 3
+		}
+		if strings.Contains(name, "CVTT") {
+			opcode = 0x2c
+		}
+		p1 := byte(0x7c) | pp
+		if strings.HasSuffix(name, "Q") {
+			p1 |= 0x80
+		}
+		for _, memory := range []bool{false, true} {
+			operand, modrm := "X1", byte(0xc1)
+			if memory {
+				operand, modrm = "(BX)", 0x03
+			}
+			rows = append(rows, x86ScalarIntegerRawRow{name, operand, []byte{0x62, 0xf1, p1, 0x08, opcode, modrm}, true, memory})
+		}
+		if name == "VCVTSS2SI" {
+			rows = append(rows, x86ScalarIntegerRawRow{name, "(BX)(CX*1)", []byte{0x62, 0xf1, p1, 0x08, opcode, 0x04, 0x0b}, true, true})
+		}
+	}
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required for independent scalar conversion physical prior")
+	}
+	var physical strings.Builder
+	for _, row := range rows {
+		for _, b := range row.code {
+			fmt.Fprintf(&physical, "0x%02x ", b)
+		}
+		physical.WriteByte('\n')
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+x86AddressMemoryTargets(arch)[0], "--mattr=+avx,+avx512f,+avx512vl")
+	command.Stdin = strings.NewReader(physical.String())
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") || strings.Count(string(output), "2si")+strings.Count(string(output), "2usi") != len(rows) {
+		t.Fatalf("independent full scalar conversion physical prior: %v\n%s", err, output)
+	}
+	want := 108
+	if arch == "386" {
+		want = 100
+	}
+	if len(rows) != want {
+		t.Fatal("incomplete original scalar conversion generation/control directory", arch, len(rows), want)
+	}
+	return rows
+}
+
+func x86ScalarIntegerRawSource(arch, symbol string, row x86ScalarIntegerRawRow, variant string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	setup := fmt.Sprintf("%s p+0(FP),BX\n%s csr+%d(FP),SI\nLDMXCSR (SI)\nPXOR X0,X0\nPXOR X1,X1\n", move, move, word)
+	if strings.Contains(row.operand, "CX") {
+		setup += "MOVL $0,CX\n"
+	}
+	switch variant {
+	case "missing-pointer":
+		setup = strings.Replace(setup, move+" p+0(FP),BX\n", "", 1)
+	case "numeric-pointer":
+		setup += move + " $4096,BX\n"
+	case "missing-vector":
+		setup = strings.Replace(setup, "PXOR X1,X1\n", "", 1)
+	case "missing-mxcsr":
+		setup = strings.Replace(setup, fmt.Sprintf("%s csr+%d(FP),SI\n", move, word), "", 1)
+	case "missing-index":
+		setup = strings.Replace(setup, "MOVL $0,CX\n", "", 1)
+	case "opaque-index":
+		setup += move + " p+0(FP),CX\n"
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s%sMOVL AX,ret+%d(FP)\nRET\n",
+			symbol, 2*word+4, setup, x86RawDisplacementDirectives(row.code), 2*word),
+		fmt.Sprintf("func %s(p *uint64,csr *uint32) uint32\n", symbol)
+}
+
+func TestX86ScalarFloatIntegerInitializedRawCompleteFamilyObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rowsByArch := map[string][]x86ScalarIntegerRawRow{
+		"amd64": x86ScalarIntegerRawRows(t, "amd64"),
+		"386":   x86ScalarIntegerRawRows(t, "386"),
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := rowsByArch[target.arch]
+			for start := 0; start < len(rows); start += 96 {
+				t.Run(fmt.Sprintf("batch-%d", start/96), func(t *testing.T) {
+					var source, decl strings.Builder
+					for index := start; index < len(rows) && index < start+96; index++ {
+						body, declaration := x86ScalarIntegerRawSource(target.arch, fmt.Sprintf("raw%d", index), rows[index], "")
+						source.WriteString(body)
+						decl.WriteString(declaration)
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), decl.String(), target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("complete initialized original raw conversion lost its native continuation", err)
+							}
+							for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+								compileLLVMToObject(t, llc, target.triple, "raw-scalar-native.ll", "raw-scalar-native.o", input)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarFloatIntegerRawProducerIdentityAndMissingInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		triple := x86AddressMemoryTargets(arch)[0]
+		rows := x86ScalarIntegerRawRows(t, arch)
+		var original strings.Builder
+		for index, row := range rows {
+			source, _ := x86ScalarIntegerRawSource(arch, fmt.Sprintf("original%d", index), row, "")
+			original.WriteString(source)
+		}
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		for index, row := range rows {
+			t.Run(fmt.Sprintf("%s/row-%d", arch, index), func(t *testing.T) {
+				source, decl := x86ScalarIntegerRawSource(arch, "value", row, "")
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				fn := file.Funcs[0]
+				ordinal := len(fn.Instrs) - 3
+				instruction := fn.Instrs[ordinal]
+				expected := x86ScalarLaneInstruction(t, row.name+" "+row.operand+",AX")
+				if instruction.Op != expected.Op || !reflect.DeepEqual(instruction.Args, expected.Args) {
+					t.Fatal("original physical conversion lost its exact opcode/operands", instruction, expected)
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}})
+				if instruction.x86ScalarFloatIntegerEVEX != row.evex || strings.Contains(features, "+avx512f") != row.evex {
+					t.Error("isolated physical conversion lost its low-bank generation/ISA", row.name, row.evex, features)
+				}
+				pkg := mustGoPackage(t, "rawconversion", "package rawconversion\n"+decl)
+				sigs, err := goSigsForAsmFile(pkg, file, func(s string) string { return strings.TrimPrefix(s, "·") }, arch, nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				check := func(fn Func) error {
+					consumer := newX86Ctx(new(strings.Builder), fn, sigs["value"], nil, sigs, arch, triple, false)
+					return consumer.checkLoweredScalarFPResultInitialization()
+				}
+				t.Run("valid-original", func(t *testing.T) {
+					if err := check(fn); err != nil {
+						t.Fatal("initialized exact original producer rejected", err)
+					}
+				})
+				for _, mutation := range []struct {
+					name string
+					edit func(*Func)
+				}{
+					{"missing replay", func(f *Func) { f.x86RawReplay = nil }},
+					{"source spelling", func(f *Func) { f.Instrs[1].Raw += " " }},
+					{"replay arch", func(f *Func) {
+						copy := *f.x86RawReplay
+						copy.goarch = "arm64"
+						f.x86RawReplay = &copy
+					}},
+					{"origin only", func(f *Func) { f.Instrs[ordinal].x86SourceRaw = nil }},
+					{"origin and encoded", func(f *Func) { f.Instrs[ordinal].x86SourceRaw, f.Instrs[ordinal].x86Encoded = nil, false }},
+					{"generation", func(f *Func) {
+						f.Instrs[ordinal].x86ScalarFloatIntegerEVEX = !f.Instrs[ordinal].x86ScalarFloatIntegerEVEX
+					}},
+					{"operand", func(f *Func) { f.Instrs[ordinal].Args[0] = Operand{Kind: OpReg, Reg: "X0"} }},
+					{"address mode", func(f *Func) {
+						bits := 32
+						if f.Instrs[ordinal].x86AddressBits == bits {
+							bits = 64
+						}
+						f.Instrs[ordinal].x86AddressBits = bits
+					}},
+				} {
+					t.Run(mutation.name, func(t *testing.T) {
+						changed := fn
+						changed.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+						mutation.edit(&changed)
+						if reflect.DeepEqual(changed, fn) {
+							t.Fatal("identity negative did not change the original snapshot", mutation.name)
+						}
+						if err := check(changed); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("edited whole producer acquired raw conversion authority", err)
+						}
+					})
+				}
+				for _, variant := range []string{"missing-pointer", "numeric-pointer", "missing-vector", "missing-mxcsr", "missing-index", "opaque-index"} {
+					if row.memory && variant == "missing-vector" || !row.memory && (variant == "missing-pointer" || variant == "numeric-pointer") ||
+						(variant == "missing-index" || variant == "opaque-index") && !strings.Contains(row.operand, "CX") {
+						continue
+					}
+					t.Run(variant, func(t *testing.T) {
+						body, decl := x86ScalarIntegerRawSource(arch, "value", row, variant)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, body, decl, arch, triple, api)
+							if variant == "numeric-pointer" {
+								if err != nil || ir == "" {
+									t.Fatal("raw scalar conversion lost its full NUM native input", api, err)
+								}
+								pointerIR, err := x86ScalarFPBitViewAPI(t, source, decl, arch, triple, api)
+								if err != nil {
+									t.Fatal(err)
+								}
+								x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+								x86RequireNumericNativeSourceContext(t, body, decl, arch)
+								x86NumericNativeAddressObject(t, ir, triple)
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("raw conversion invented missing native/numerical input", api, variant, err)
+							}
+						}
+					})
+				}
+				for end := 1; end < len(row.code); end++ {
+					prefix := Func{}
+					for _, b := range row.code[:end] {
+						prefix.Instrs = append(prefix.Instrs, Instr{Op: OpBYTE, Args: []Operand{{Kind: OpImm, Imm: int64(b)}}})
+					}
+					decoded, err := decodeX86RawDirectives(prefix, arch)
+					if err == nil && len(decoded.Instrs) == 1 {
+						if _, known, err := x86ScalarFloatIntegerProperties(decoded.Instrs[0], arch); known && err == nil {
+							t.Fatal("truncated original conversion acquired a complete typed instruction", end)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerOriginalInitializedRawRuntimeObjects(t *testing.T) {
+	data, err := os.ReadFile("amd64_raw_scalar_float_to_int_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), "original.go", data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	constants := make(map[string]string)
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != "x86RawScalarFloatToIntegerNativeRuntime" {
+			continue
+		}
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || len(value.Values) != 1 || value.Names[0].Name != "source" && value.Names[0].Name != "mainC" {
+				return true
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("original initialized runtime lost its complete source/C literals")
+			}
+			constants[value.Names[0].Name], err = strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			return true
+		})
+	}
+	for name, want := range map[string]string{"source": "1e0a8f59c481dfe0a3df7a72eaa4171724cd987c7e16a43ad79fa5b7b0e9584b", "mainC": "2ed5aa1e438e280875379ed2e027c02fcc826ea2bde65e69939df42d60739b34"} {
+		if fmt.Sprintf("%x", sha256.Sum256([]byte(constants[name]))) != want {
+			t.Fatal("complete original initialized runtime ASM/C changed", name)
+		}
+	}
+	goAssemblerOracleOutput(t, "amd64", constants["source"], "", true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Original runtime's MOVQ/ABI0 contract is AMD64 only.
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, constants["source"], "func rawfloattointsemantics(input *float64,out *uint32)\n", "amd64", target.triple, api)
+				if err != nil {
+					t.Fatal("existing initialized raw runtime lost native continuation", err)
+				}
+				for _, input := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					compileLLVMToObject(t, llc, target.triple, "original-raw-scalar.ll", "original-raw-scalar.o", input)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarFloatIntegerRawSavedFlagsAndExactPostDomains(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, suffix := 8, "Q"
+		if arch == "386" {
+			word, suffix = 4, "L"
+		}
+		rows := x86ScalarIntegerRawRows(t, arch)
+		type sample struct{ source, declaration, control string }
+		var samples []sample
+		var original strings.Builder
+		for _, row := range rows {
+			if row.operand != "X1" || row.name != "CVTSS2SL" && row.name != "VCVTSS2SI" && row.name != "VCVTSS2USIL" {
+				continue
+			}
+			for _, control := range []string{"named", "raw", "missing-vector"} {
+				name := fmt.Sprintf("saved%d", len(samples))
+				body, decl := x86ScalarIntegerRawSource(arch, name, row, "")
+				code := x86RawDisplacementDirectives(row.code)
+				observed := "MOVL $3,DX\nCMPL DX,$3\nSTD\nPUSHF" + suffix + "\n" + code +
+					"POP" + suffix + " DX\nANDL $0xcd5,DX\nCLD\n"
+				body = strings.Replace(body, code, observed, 1)
+				body = strings.Replace(body, fmt.Sprintf("MOVL AX,ret+%d(FP)", 2*word), fmt.Sprintf("MOVL DX,ret+%d(FP)", 2*word), 1)
+				if control == "named" {
+					body = strings.Replace(body, code, row.name+" X1,AX\n", 1)
+				} else if control == "missing-vector" {
+					body = strings.Replace(body, "PXOR X1,X1\n", "", 1)
+				}
+				samples = append(samples, sample{body, decl, control})
+				original.WriteString(body)
+			}
+		}
+		goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		for index, item := range samples {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/saved-%d/%s", arch, index, api), func(t *testing.T) {
+					_, err := x86ScalarFPBitViewAPI(t, item.source, item.declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+					if item.control == "missing-vector" && !errors.Is(err, ErrProbeNeedsContext) || item.control != "missing-vector" && err != nil {
+						t.Fatal("saved FLAGS/DF changed or supplied a missing conversion input", item.control, err)
+					}
+				})
+			}
+		}
+		for index, row := range rows {
+			t.Run(fmt.Sprintf("%s/post-%d", arch, index), func(t *testing.T) {
+				ins := x86RawMoveObservedInstruction(t, arch, row.code)
+				for _, direction := range []x86ResultDirection{x86ResultDirectionUnknown, x86ResultDirectionForward, x86ResultDirectionBackward, x86ResultDirectionEither} {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: direction, valueStack: &x86ResultValueStack{id: true}}
+					state.writeVector(1, 64, ^uint64(0), false)
+					state.pointerGP[3], state.gp[1] = true, 0xff
+					state.callerAddressGP[0], state.callerAddressGP[3], state.callerAddressGP[7] = true, true, true
+					push := x86ScalarLaneInstruction(t, "PUSHF"+suffix)
+					if accepted, known := x86ResultValueStackStep(push, &state, nil, 0, arch); !known || !accepted {
+						t.Fatal("independent saved FLAGS prerequisite failed")
+					}
+					before := state.clone()
+					if !x86ResultValueStackContinuation(ins, &state, arch) || x86ResultDirectionAfterSource(ins, direction, arch) != direction || x86PreservesNumericalSourceState(ins) {
+						t.Error("raw conversion lost saved bytes/ID/DF or acquired an inert data role")
+					}
+					want := before.callerAddressGP
+					want[0] = false // Every independent physical row writes AX, not BX/DI.
+					got := x86ResultCallerAddressesAfterTransfer(ins, before.callerAddressGP, before.callerAddressGP, nil, arch)
+					if got != want {
+						t.Error("raw scalar output did not revoke exactly its GP caller-address destination", got, want)
+					}
+					accepted, known := x86ResultScalarFloatIntegerStepWithRead(ins, &state, nil, 0, arch, true)
+					if !known || !accepted || state.flags != before.flags || state.direction != before.direction || !reflect.DeepEqual(state.valueStack, before.valueStack) {
+						t.Error("raw conversion altered six status flags, DF, saved bytes or ID", known, accepted)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_fp_byte_controls_test.go b/x86_scalar_fp_byte_controls_test.go
new file mode 100644
index 000000000..8037c75d6
--- /dev/null
+++ b/x86_scalar_fp_byte_controls_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ScalarFPByteInputCase struct {
+	x86ScalarFPTupleSpanCase
+	probe string
+}
+
+func x86ScalarFPByteInputCases(arch string) []x86ScalarFPByteInputCase {
+	word, bits, move := 8, 64, "MOVQ"
+	if arch == "386" {
+		word, bits, move = 4, 32, "MOVL"
+	}
+	rows := []x86ScalarFPByteInputCase{
+		{x86ScalarFPTupleSpanCase{
+			name: "readonly-numeric-inputs", declaration: "func Value(a,b uint8) uint16",
+			source: fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVW a+0(FP),AX\nMOVW AX,ret+%d(FP)\nRET\n", word+2, word),
+			want:   []uint64{0x0403},
+		}, "define i16 @Probe() {\n %r = call i16 @Value(i8 3,i8 4)\n ret i16 %r\n}\n"},
+		{x86ScalarFPTupleSpanCase{
+			name: "readonly-canonical-byte", declaration: "func Value(a bool,b uint8) (bool,uint8,uint16)",
+			source: fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nMOVW a+0(FP),AX\nMOVW AX,ret+%d(FP)\nMOVW AX,ret+%d(FP)\nRET\n", word+4, word, word+2),
+			want:   []uint64{1, 2, 0x0201},
+		}, "define {i1,i8,i16} @Probe() {\n %r = call {i1,i8,i16} @Value(i1 true,i8 2)\n ret {i1,i8,i16} %r\n}\n"},
+	}
+	read, expected := "a+0(FP)", uint64(0x112233443f800000)
+	if arch == "386" {
+		read, expected = "a+1(FP)", 0x443f8000
+	}
+	rows = append(rows, x86ScalarFPByteInputCase{x86ScalarFPTupleSpanCase{
+		name: "floating-input-bits", declaration: fmt.Sprintf("func Value(a float32,b uint32) uint%d", bits),
+		source: fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s %s,AX\n%s AX,ret+8(FP)\nRET\n", 8+word, move, read, move),
+		want:   []uint64{expected},
+	}, fmt.Sprintf("define i%d @Probe() {\n %%r = call i%d @Value(float 1.000000e+00,i32 287454020)\n ret i%d %%r\n}\n", bits, bits, bits)})
+	body := "MOVQ $0x3ff0000000000000,AX\nMOVQ AX,ret+0(FP)\nMOVB $0x11,ret+1(FP)\nMOVQ ret+0(FP),AX\nMOVQ AX,ret+8(FP)\n"
+	if arch == "386" {
+		body = "MOVL $0,ret+0(FP)\nMOVL $0x3ff00000,ret+4(FP)\nMOVB $0x11,ret+1(FP)\nMOVL ret+0(FP),AX\nMOVL AX,ret+8(FP)\nMOVL ret+4(FP),DX\nMOVL DX,ret+12(FP)\n"
+	}
+	rows = append(rows, x86ScalarFPByteInputCase{x86ScalarFPTupleSpanCase{
+		name: "partial-floating32-result-bits", declaration: "func Value() (float32,uint32)",
+		source: "TEXT ·Value(SB),4,$0-8\nMOVL $0x3f800000,ret+0(FP)\nMOVB $0x11,ret+1(FP)\nMOVL ret+0(FP),AX\nMOVL AX,ret+4(FP)\nRET\n",
+		want:   []uint64{0x3f801100, 0x3f801100},
+	}, "define {i32,i32} @Probe() {\n %r = call {float,i32} @Value()\n %f = extractvalue {float,i32} %r,0\n %b = bitcast float %f to i32\n %n = extractvalue {float,i32} %r,1\n %a = insertvalue {i32,i32} poison,i32 %b,0\n %v = insertvalue {i32,i32} %a,i32 %n,1\n ret {i32,i32} %v\n}\n"})
+	rows = append(rows, x86ScalarFPByteInputCase{x86ScalarFPTupleSpanCase{
+		name: "partial-floating-result-bits", declaration: "func Value() (float64,uint64)",
+		source: "TEXT ·Value(SB),4,$0-16\n" + body + "RET\n",
+		want:   []uint64{0x3ff0000000001100, 0x3ff0000000001100},
+	}, "define {i64,i64} @Probe() {\n %r = call {double,i64} @Value()\n %f = extractvalue {double,i64} %r,0\n %b = bitcast double %f to i64\n %n = extractvalue {double,i64} %r,1\n %a = insertvalue {i64,i64} poison,i64 %b,0\n %v = insertvalue {i64,i64} %a,i64 %n,1\n ret {i64,i64} %v\n}\n"})
+	return rows
+}
+
+func TestX86IntegerFPByteViewsReadonlyInputsAndFloatingBits(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ScalarFPByteInputCases(target.arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete typed bit transport rejected", err)
+					}
+					// A test-owned ordinary LLVM caller supplies independent input
+					// constants; it adds no source/native/entry permission to Value.
+					x86ScalarFPNamedConstantResult(t, ir+row.probe, "Probe", row.want)
+				})
+			}
+		}
+	}
+}
+
+var x86ScalarFPSparseCompleteCase = x86ScalarFPTupleSpanCase{
+	name: "complete-byte-writes", declaration: "func Value() (uint32,uint8)",
+	source: "TEXT ·Value(SB),4,$0-5\nMOVW $0x0201,ret+0(FP)\nMOVW $0x0403,ret+2(FP)\nMOVB ret+1(FP),AX\nMOVB AX,ret+4(FP)\nRET\n",
+	want:   []uint64{0x04030201, 2},
+}
+
+func TestX86IntegerFPByteViewsSparseMustInitialization(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, body string }{
+			{"only-low-byte", "MOVB $1,ret+0(FP)"},
+			{"only-high-word", "MOVW $1,ret+2(FP)"},
+			{"sparse-GP-source", "MOVB $1,AX\nMOVL AX,ret+0(FP)"},
+			{"undefined-interior-read", "MOVB ret+1(FP),AX\nMOVL AX,ret+0(FP)"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·Value(SB),4,$0-4\n"+row.body+"\nRET\n", "func Value() uint32", target.arch, target.triple, api)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("implementation zeroes initialized an unknown source byte: output=%t, error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/complete/"+api, func(t *testing.T) {
+				row := x86ScalarFPSparseCompleteCase
+				ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete independent partial writes rejected", err)
+				}
+				x86ScalarFPTupleSpanConstantResult(t, ir, row.want)
+			})
+		}
+	}
+}
+
+func TestX86IntegerFPByteViewsMOVQSourceAliases(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Mode32's legal X/m64 and rejected GP controls are separate.
+		}
+		for _, read := range []bool{false, true} {
+			for _, row := range x86ScalarFPTupleSpanCases(target.arch, read) {
+				if !strings.Contains(row.source, "MOVQ") {
+					continue
+				}
+				for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+alias+"/"+row.name+"/"+api, func(t *testing.T) {
+							source := strings.ReplaceAll(row.source, "MOVQ", alias)
+							ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("official source alias lost exact byte transport", err)
+							}
+							x86ScalarFPTupleSpanConstantResult(t, ir, row.want)
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86OrdinaryIntegerFPStoreWidthsRequireWholeSource(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := 8
+		if target.arch == "386" {
+			word = 4
+		}
+		for _, width := range []int{1, 2, 4, 8} {
+			move := map[int]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+			store := move + " AX,ret+0(FP)\n"
+			constant := move + " $9,AX\n" + store
+			partial := "MOVB $1,AH\n" + store
+			if width > 1 {
+				partial = "MOVB $1,AX\n" + store
+			}
+			result := (width + word - 1) & -word
+			input := fmt.Sprintf("%s x+0(FP),AX\n%s AX,ret+%d(FP)\n", move, move, result)
+			if width == 8 && target.arch == "386" {
+				store = "MOVL AX,ret+0(FP)\nMOVL $0,ret+4(FP)\n"
+				constant = "MOVL $9,AX\n" + store
+				partial = "MOVB $1,AX\n" + store
+				input = fmt.Sprintf("MOVL x+0(FP),AX\nMOVL AX,ret+%d(FP)\nMOVL x+4(FP),DX\nMOVL DX,ret+%d(FP)\n", result, result+4)
+			}
+			for _, row := range []struct {
+				name, body string
+				input, ok  bool
+			}{
+				{"undefined", store, false, false},
+				{"partial", partial, false, false},
+				{"constant", constant, false, true},
+				{"actual-numeric-input", input, true, true},
+			} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%d/%s/%s", target.triple, width, row.name, api), func(t *testing.T) {
+						declaration, extent := fmt.Sprintf("func Value() uint%d", 8*width), width
+						if row.input {
+							declaration, extent = fmt.Sprintf("func Value(x uint%d) uint%d", 8*width, 8*width), result+width
+						}
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%sRET\n", extent, row.body)
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if row.ok {
+							if err != nil || ir == "" {
+								t.Fatal("complete ordinary scalar source rejected", err)
+							}
+							if !row.input {
+								x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{9})
+							}
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("ordinary full-width store published unknown bytes: output=%t, error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_scalar_fp_byte_default_test.go b/x86_scalar_fp_byte_default_test.go
new file mode 100644
index 000000000..361d4fdab
--- /dev/null
+++ b/x86_scalar_fp_byte_default_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Only ArchAMD64's text/module Options have the documented historical amd64
+// default. The Go-aware API deliberately requires an explicit actual GOARCH.
+func x86IntegerFPDefaultAPI(t *testing.T, source, declaration, triple, api string) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "defaultfp", "package defaultfp\n"+declaration)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	context := llvm.NewContext()
+	defer context.Dispose()
+	if api == "Go-blank" {
+		module, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{TargetTriple: triple, ResolveSym: resolve})
+		if module != nil && !module.Module.IsNil() {
+			defer module.Module.Dispose()
+			return module.Module.String(), err
+		}
+		return "", err
+	}
+	if api != "module" {
+		t.Fatal("unknown default FP API", api)
+	}
+	module, err := TranslateModuleInContext(context, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func TestX86OrdinaryIntegerFPDefaultArchitectureCannotBypassProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Empty Options.Goarch is AMD64, never a mode32 inference.
+		}
+		for _, width := range []int{1, 2, 4, 8} {
+			move := map[int]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+			for _, known := range []bool{false, true} {
+				body := move + " AX,ret+0(FP)\nRET\n"
+				if known {
+					body = move + " $9,AX\n" + body
+				}
+				for _, api := range []string{"text", "module"} {
+					t.Run(fmt.Sprintf("%s/%d/known=%t/%s", target.triple, width, known, api), func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", width, body)
+						ir, err := x86IntegerFPDefaultAPI(t, source, fmt.Sprintf("func Value() uint%d", 8*width), target.triple, api)
+						if known {
+							if err != nil || ir == "" {
+								t.Fatal("documented AMD64 default rejected initialized result", err)
+							}
+							x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{9})
+						} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("default direct path bypassed whole-source initialization: output=%t, error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+		for _, api := range []string{"text", "module"} {
+			t.Run(target.triple+"/readonly-I1/"+api, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-9\nMOVB x+0(FP),AX\nMOVB AX,ret+8(FP)\nRET\n"
+				ir, err := x86IntegerFPDefaultAPI(t, source, "func Value(x bool) uint8", target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("default projection changed the independent logical I1 input route", err)
+				}
+				x86ScalarFPNamedConstantResult(t, ir+"define i8 @Probe() {\n %v = call i8 @Value(i1 true)\n ret i8 %v\n}\n", "Probe", []uint64{1})
+			})
+		}
+	}
+	t.Run("Go-blank-keeps-explicit-selection-boundary", func(t *testing.T) {
+		ir, err := x86IntegerFPDefaultAPI(t, "TEXT ·Value(SB),4,$0-4\nMOVL $9,ret+0(FP)\nRET\n", "func Value() uint32", "x86_64-unknown-linux-gnu", "Go-blank")
+		if err == nil || !strings.Contains(err.Error(), "empty GOARCH") || ir != "" {
+			t.Fatalf("blank Go selection acquired an implicit source/ABI role: output=%t, error=%v", ir != "", err)
+		}
+	})
+}
diff --git a/x86_scalar_fp_byte_objects_test.go b/x86_scalar_fp_byte_objects_test.go
new file mode 100644
index 000000000..1698d68e1
--- /dev/null
+++ b/x86_scalar_fp_byte_objects_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86ScalarFPByteCompleteFixture(arch string) (string, string, int) {
+	var rows []x86ScalarFPTupleSpanCase
+	for _, read := range []bool{false, true} {
+		for _, row := range x86ScalarFPTupleSpanCases(arch, read) {
+			rows = append(rows, row)
+			if arch == "amd64" && strings.Contains(row.source, "MOVQ") {
+				for _, alias := range []string{"MOVD", "MOVDQ2Q"} {
+					copy := row
+					copy.source = strings.ReplaceAll(row.source, "MOVQ", alias)
+					rows = append(rows, copy)
+				}
+			}
+		}
+	}
+	rows = append(rows, x86ScalarFPInteriorCases(arch)...)
+	for _, row := range x86ScalarFPByteInputCases(arch) {
+		rows = append(rows, row.x86ScalarFPTupleSpanCase)
+	}
+	rows = append(rows, x86ScalarFPSparseCompleteCase, x86ScalarFPTupleSpanCase{
+		declaration: "func Value() (uint8,uint8,uint8,uint8,bool)", source: x86IntegerFPByteStatusSource,
+	})
+	var declarations, source strings.Builder
+	declarations.WriteString("package bitspan\n")
+	for index, row := range rows {
+		name := fmt.Sprintf("Span%d", index)
+		declarations.WriteString(strings.ReplaceAll(row.declaration, "Value", name) + "\n")
+		source.WriteString(strings.ReplaceAll(row.source, "Value", name))
+	}
+	return declarations.String(), source.String(), len(rows)
+}
+
+func TestX86IntegerFPByteViewsFiveTargetOriginalAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete integer FP byte-view objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			declarations, source, count := x86ScalarFPByteCompleteFixture(target.arch)
+			wantCount := 89
+			if target.arch == "386" {
+				wantCount = 39
+			}
+			if count != wantCount || strings.Count(source, "TEXT ·") != count {
+				t.Fatalf("complete unfiltered byte-view source changed: got %d, want %d", count, wantCount)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			pkg := mustGoPackage(t, "bitspan", declarations)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewPackageAPI(t, source, pkg, target.arch, target.triple, api)
+					if err != nil || strings.Count(ir, "define ") != count {
+						t.Fatal("complete byte-view fixture failed", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_scalar_fp_byte_storage_roles_test.go b/x86_scalar_fp_byte_storage_roles_test.go
new file mode 100644
index 000000000..56ed2f497
--- /dev/null
+++ b/x86_scalar_fp_byte_storage_roles_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86OrdinaryIntegerFPStoreKeepsIndependentStorageConsumers(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, lea, stackWord := 8, "LEAQ", "Q"
+		if target.arch == "386" {
+			word, lea, stackWord = 4, "LEAL", "L"
+		}
+		for _, row := range []struct {
+			name, declaration, body string
+			extent                  int
+			accepted                bool
+		}{
+			{"direct-defined", "func Value() uint32", "MOVL $9,AX\nMOVL AX,ret+0(FP)", 4, true},
+			{"direct-unknown", "func Value() uint32", "MOVL AX,ret+0(FP)", 4, false},
+			{"existing-virtual-SP", "func Value() uint32", "MOVL $9,-4(SP)\nMOVL -4(SP),AX\nMOVL AX,ret+0(FP)", 4, true},
+			{"existing-implicit-stack", "func Value() uint32", fmt.Sprintf("MOVL $9,AX\nPUSH%s AX\nPOP%s AX\nMOVL AX,ret+0(FP)", stackWord, stackWord), 4, true},
+			// Mode32 owns one checked logical frame. AMD64's independent
+			// parameter allocations do not supply contiguous neighbor storage.
+			// Retain the original Go source/object, not an out-of-bounds
+			// private alloca write disguised as successful translation.
+			{"FP-neighbor-needs-contiguous-storage", "func Value(a,b uint32) uint32", lea + " a+0(FP),SI\nMOVL $41,4(SI)\nMOVL b+4(FP),AX\nMOVL AX,ret+8(FP)", 12, target.arch == "386"},
+			{"existing-FP-field-address", "func Value(a,b uint32) uint32", lea + " b+4(FP),SI\nMOVL $41,(SI)\nMOVL b+4(FP),AX\nMOVL AX,ret+8(FP)", 12, true},
+			{"existing-FP-input-shadow", "func Value(x uint32) uint32", fmt.Sprintf("MOVL $41,x+0(FP)\nMOVL x+0(FP),AX\nMOVL AX,ret+%d(FP)", word), word + 4, true},
+			{"partial-cannot-borrow-SP", "func Value() uint32", "MOVL $9,-4(SP)\nMOVB $1,ret+0(FP)", 4, false},
+			{"partial-cannot-borrow-implicit-stack", "func Value() uint32", fmt.Sprintf("MOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\nPUSH%s $0\nPOPF%s\nUMWAIT BX\nMOVB $1,ret+0(FP)", stackWord, stackWord), 4, false},
+			{"partial-cannot-borrow-FP-address", "func Value(x uint32) uint32", fmt.Sprintf("%s x+0(FP),SI\nMOVB $1,ret+%d(FP)", lea, word), word + 4, false},
+			{"interior-cannot-borrow-SP", "func Value() (uint32,uint8)", "MOVL $9,-4(SP)\nMOVL $0x04030201,ret+0(FP)\nMOVB ret+1(FP),AX\nMOVB AX,ret+4(FP)", 5, false},
+			{"cross-field-defined-FP-address", "func Value(x uint32) (uint16,uint16)", fmt.Sprintf("%s x+0(FP),SI\nMOVL $0x04030201,ret+%d(FP)", lea, word), word + 4, true},
+			{"cross-field-unknown-cannot-borrow-FP-address", "func Value(x uint32) (uint16,uint16)", fmt.Sprintf("%s x+0(FP),SI\nMOVL AX,ret+%d(FP)", lea, word), word + 4, false},
+		} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nRET\n", row.extent, row.body)
+			if row.name == "FP-neighbor-needs-contiguous-storage" || row.name == "existing-FP-field-address" {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+					if row.accepted {
+						if err != nil || ir == "" {
+							t.Fatal("existing logical storage consumer was replaced by another role", err)
+						}
+						if row.name == "direct-defined" {
+							x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{9})
+						} else if row.name == "existing-FP-field-address" {
+							const observe = `
+define i32 @ObserveField() {
+    %value = call i32 @Value(i32 11, i32 23)
+    ret i32 %value
+}
+`
+							// The optimizer must use the selected target's actual
+							// pointer layout, not its default host-sized pointer.
+							observed := x86LODSStateTargetLayout(t, ir+observe, target.triple, word)
+							x86ScalarFPNamedConstantResult(t, observed, "ObserveField", []uint64{41})
+						} else if row.name == "cross-field-defined-FP-address" {
+							// The existing checked unused-address effect grants no
+							// address bits, but does not invalidate unrelated data.
+							x86ScalarFPTupleSpanConstantResult(t, ir, []uint64{0x0201, 0x0403})
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatalf("new byte view borrowed an independent storage role: output=%t, error=%v", ir != "", err)
+					}
+				})
+			}
+		}
+		// Independent width/mode/segment witnesses for every value/FLAGS stack
+		// row. This tests cost separation only, not native segment permission.
+		for _, instruction := range []string{
+			"PUSHW AX", "POPW AX", "PUSHFW", "POPFW",
+			"PUSH" + stackWord + " AX", "POP" + stackWord + " AX", "PUSHF" + stackWord, "POPF" + stackWord,
+			"PUSHL FS", "POPL GS", "PUSHQ FS", "POPQ GS",
+		} {
+			t.Run(target.triple+"/typed-storage/"+instruction, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-4\n"+instruction+"\nMOVL $9,AX\nMOVL AX,ret+0(FP)\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				sig := FuncSig{Name: "Value", Ret: I32, Frame: FrameLayout{Results: []FrameSlot{{Type: I32, Field: -1}}}}
+				if x86OrdinaryIntegerFPStoreNeedsProof(file.Funcs[0], sig, target.arch) {
+					t.Fatal("complete typed stack row was stolen by direct GP/FP admission")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_fp_tuple_span_test.go b/x86_scalar_fp_tuple_span_test.go
new file mode 100644
index 000000000..7cd2a3455
--- /dev/null
+++ b/x86_scalar_fp_tuple_span_test.go
@@ -0,0 +1,267 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These byte tuples have no padding. Their independently specified little-
+// endian bytes describe physical FP storage, not a coercion to its first field.
+type x86ScalarFPTupleSpanCase struct {
+	name, source, declaration string
+	want                      []uint64
+}
+
+func x86ScalarFPTupleSpanCases(arch string, read bool) []x86ScalarFPTupleSpanCase {
+	widths := []int{2, 4}
+	if arch == "amd64" {
+		widths = append(widths, 8)
+	}
+	var cases []x86ScalarFPTupleSpanCase
+	for _, width := range widths {
+		for _, boolean := range []int{0, width - 1, -1} {
+			position := "numeric"
+			if boolean == 0 {
+				position = "bool-first"
+			} else if boolean == width-1 {
+				position = "bool-last"
+			}
+			var fields []string
+			var values []uint64
+			var packed uint64
+			for index := 0; index < width; index++ {
+				typ, value := "uint8", uint64(index+2)
+				if boolean == 0 {
+					value--
+				}
+				if index == boolean {
+					typ, value = "bool", 1
+				}
+				fields = append(fields, typ)
+				values = append(values, value)
+				packed |= value << uint(8*index)
+			}
+			move := map[int]string{2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+			var body strings.Builder
+			role, extent := "store", width
+			if read {
+				role, extent = "read", 2*width
+				for index, value := range values {
+					fmt.Fprintf(&body, "MOVB $%d,ret+%d(FP)\n", value, index)
+				}
+				fmt.Fprintf(&body, "%s ret+0(FP),AX\n%s AX,ret+%d(FP)\n", move, move, width)
+				fields = append(fields, fmt.Sprintf("uint%d", 8*width))
+				values = append(values, packed)
+			} else {
+				// Register transport keeps Q's full-width literal legal: x86 has
+				// no arbitrary imm64-to-memory encoding.
+				fmt.Fprintf(&body, "%s $0x%x,AX\n%s AX,ret+0(FP)\n", move, packed, move)
+			}
+			body.WriteString("RET\n")
+			cases = append(cases, x86ScalarFPTupleSpanCase{
+				name:        fmt.Sprintf("%s/%s/%s", role, move, position),
+				declaration: "func Value() (" + strings.Join(fields, ",") + ")",
+				source:      fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", extent, body.String()),
+				want:        values,
+			})
+			if read && boolean >= 0 {
+				// The Go bool return must be restored to one, but its earlier
+				// physical byte two must survive the wide numerical read.
+				physical := strings.Replace(body.String(), fmt.Sprintf("MOVB $1,ret+%d(FP)", boolean), fmt.Sprintf("MOVB $2,ret+%d(FP)", boolean), 1)
+				physical = strings.Replace(physical, "RET\n", fmt.Sprintf("MOVB $1,ret+%d(FP)\nRET\n", boolean), 1)
+				expected := append([]uint64(nil), values...)
+				expected[len(expected)-1] += uint64(1) << uint(8*boolean)
+				cases = append(cases, x86ScalarFPTupleSpanCase{
+					name:        fmt.Sprintf("%s/%s/%s-physical-two", role, move, position),
+					declaration: "func Value() (" + strings.Join(fields, ",") + ")",
+					source:      fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", extent, physical),
+					want:        expected,
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func x86ScalarFPTupleSpanConstantResult(t *testing.T, ir string, want []uint64) {
+	x86ScalarFPNamedConstantResult(t, ir, "Value", want)
+}
+
+func x86ScalarFPNamedConstantResult(t *testing.T, ir, name string, want []uint64) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	function := module.NamedFunction(name)
+	if function.IsNil() {
+		t.Fatal("missing exact translated entry", name)
+	}
+	returns := 0
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for instruction := block.FirstInstruction(); !instruction.IsNil(); instruction = llvm.NextInstruction(instruction) {
+			if instruction.IsAReturnInst().IsNil() {
+				continue
+			}
+			returns++
+			if instruction.OperandsCount() != 1 {
+				t.Fatalf("missing physical-byte tuple result: %s", function.String())
+			}
+			result := instruction.Operand(0)
+			if len(want) == 1 && !result.IsAConstantInt().IsNil() {
+				if result.ZExtValue() != want[0] {
+					t.Errorf("FP span scalar result: got %s, want %d; optimized actual fixture:\n%s", result.String(), want[0], function.String())
+				}
+				continue
+			}
+			if result.IsAConstantStruct().IsNil() || result.OperandsCount() != len(want) {
+				t.Fatalf("whole constant fixture did not produce an inspectable tuple: %s", function.String())
+			}
+			for index, expected := range want {
+				field := result.Operand(index)
+				if field.IsAConstantInt().IsNil() || field.ZExtValue() != expected {
+					t.Errorf("FP span lost field %d: got %s, want %d; optimized actual fixture:\n%s", index, field.String(), expected, function.String())
+				}
+			}
+		}
+	}
+	if returns != 1 {
+		t.Fatalf("constant fixture has %d returns, want one", returns)
+	}
+}
+
+func x86ScalarFPTupleSpanThreeAPIs(t *testing.T, read bool) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ScalarFPTupleSpanCases(target.arch, read) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("complete initialized physical FP span rejected: %v", err)
+					}
+					x86ScalarFPTupleSpanConstantResult(t, ir, row.want)
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPWideTupleStoresPreserveEveryField(t *testing.T) {
+	x86ScalarFPTupleSpanThreeAPIs(t, false)
+}
+
+func TestX86ScalarFPWideTupleReadsPreserveEveryField(t *testing.T) {
+	x86ScalarFPTupleSpanThreeAPIs(t, true)
+}
+
+func x86ScalarFPInteriorCases(arch string) []x86ScalarFPTupleSpanCase {
+	word, full, seed := 8, "MOVQ", uint64(0x0807060504030201)
+	if arch == "386" {
+		word, full, seed = 4, "MOVL", 0x04030201
+	}
+	var cases []x86ScalarFPTupleSpanCase
+	for _, width := range []int{1, 2, 4, 8} {
+		if width > word {
+			continue // No GP qword row exists in the mode32 Go table.
+		}
+		mask := ^uint64(0)
+		if width < 8 {
+			mask = uint64(1)<<uint(8*width) - 1
+		}
+		move := map[int]string{1: "MOVB", 2: "MOVW", 4: "MOVL", 8: "MOVQ"}[width]
+		for offset := 0; offset <= word-width; offset++ {
+			for _, read := range []bool{false, true} {
+				role, first, second := "write", seed, seed
+				body := fmt.Sprintf("%s $0x%x,AX\n%s AX,ret+0(FP)\n", full, seed, full)
+				if read {
+					role, second = "read", seed>>uint(8*offset)&mask
+					body += fmt.Sprintf("%s $0,AX\n%s ret+%d(FP),AX\n", full, move, offset)
+				} else {
+					part := uint64(0x1514131211100f0e) & mask
+					first = seed&^(mask<<uint(8*offset)) | part<<uint(8*offset)
+					second = first
+					body += fmt.Sprintf("%s $0x%x,BX\n%s BX,ret+%d(FP)\n%s ret+0(FP),AX\n", move, part, move, offset, full)
+				}
+				body += fmt.Sprintf("%s AX,ret+%d(FP)\nRET\n", full, word)
+				cases = append(cases, x86ScalarFPTupleSpanCase{
+					name:        fmt.Sprintf("%s/%s/offset-%d", role, move, offset),
+					declaration: fmt.Sprintf("func Value() (uint%d,uint%d)", 8*word, 8*word),
+					source:      fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", 2*word, body),
+					want:        []uint64{first, second},
+				})
+			}
+		}
+	}
+	return cases
+}
+
+func TestX86ScalarFPIntegerPartialAndInteriorBytesThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86ScalarFPInteriorCases(target.arch) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, row.source, row.declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatalf("complete initialized physical FP span rejected: %v", err)
+					}
+					x86ScalarFPTupleSpanConstantResult(t, ir, row.want)
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarFPWideTupleSpanOriginalGoAssembly(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			var source strings.Builder
+			for _, read := range []bool{false, true} {
+				for index, row := range x86ScalarFPTupleSpanCases(arch, read) {
+					name := fmt.Sprintf("Span%dRead%t", index, read)
+					source.WriteString(strings.ReplaceAll(row.source, "Value", name))
+				}
+			}
+			for index, row := range x86ScalarFPInteriorCases(arch) {
+				source.WriteString(strings.ReplaceAll(row.source, "Value", fmt.Sprintf("Interior%d", index)))
+			}
+			word := 8
+			if arch == "386" {
+				word = 4
+			}
+			for index, row := range x86IntegerFPByteRoleCases(word) {
+				fmt.Fprintf(&source, "TEXT ·Role%d(SB),4,$0-%d\n%s\n", index, row.args, row.body)
+			}
+			source.WriteString(strings.ReplaceAll(x86IntegerFPByteStatusSource, "Value", "Status"))
+			if arch == "386" {
+				for index, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+					fmt.Fprintf(&source, "TEXT ·Vector%d(SB),4,$0-8\nPXOR X0,X0\n%s X0,ret+0(FP)\n%s ret+0(FP),X1\n%s X1,ret+0(FP)\nRET\n", index, alias, alias, alias)
+				}
+			}
+			goAssemblerOracleOutput(t, arch, source.String(), "", true)
+		})
+	}
+	// These are Go-invalid GP rows, not another admitted mode32 format. Require
+	// the actual assembler's fixture-bound exit-1 diagnostic independently of
+	// the translator's conservative Context result and the valid X/m64 controls.
+	for _, alias := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		for _, row := range []struct{ name, body string }{{"store", alias + " AX,ret+0(FP)"}, {"load", alias + " ret+0(FP),AX"}} {
+			t.Run("386-GP-qword-rejected/"+alias+"/"+row.name, func(t *testing.T) {
+				goAssemblerOracleOutput(t, "386", "TEXT ·Invalid(SB),4,$0-8\n"+row.body+"\nRET\n", "", false)
+			})
+		}
+	}
+}
diff --git a/x86_scalar_move_alias_runtime_test.go b/x86_scalar_move_alias_runtime_test.go
new file mode 100644
index 000000000..e80fa0cc1
--- /dev/null
+++ b/x86_scalar_move_alias_runtime_test.go
@@ -0,0 +1,117 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// These integer-only programs run the translated IR on the actual host. Go
+// independently assembles both source modes; this is not native x86 execution.
+// Mode32 has no host-pointer argument, so a 64-bit host cannot mask a truncated
+// 386 native address. Its memory operations remain in the five-target owner.
+func TestX86ScalarMoveAliasesPortableValuesFlagsAndMemory(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			word, move, ctype, gotype := goWordSize(arch), "MOVQ", "uint64_t", "uint64"
+			if arch == "386" {
+				move, ctype, gotype = "MOVL", "uint32_t", "uint32"
+			}
+			var source, declarations, prototypes strings.Builder
+			for _, op := range []string{"MOVQL", "MOVLQZX"} {
+				name := "Alias" + op
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s seed+%d(FP),BX\n"+
+					"CMPL BX,$0\n%s AX,BX\nJNE done%s\nADDL $7,BX\ndone%s:\n%s BX,ret+%d(FP)\nRET\n",
+					name, 3*word, move, move, word, op, name, name, move, 2*word)
+				fmt.Fprintf(&declarations, "func %s(x,seed %s) %s\n", name, gotype, gotype)
+				fmt.Fprintf(&prototypes, "extern %s %s(%s,%s);\n", ctype, name, ctype, ctype)
+			}
+			if arch == "amd64" {
+				for _, op := range []string{"MOVQL", "MOVLQZX"} {
+					body, declaration := scalarMoveAliasFunction("Memory"+op, arch, op, true)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+				}
+			}
+			x86LEAActualTargetGoObject(t, arch, map[string]string{
+				"amd64": "x86_64-unknown-linux-gnu", "386": "i386-unknown-linux-gnu",
+			}[arch], source.String())
+			driver := scalarMoveAliasPortableOracle(ctype, prototypes.String(), arch == "amd64")
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized scalar alias executable rejected", err)
+					}
+					x86ConflictFunnelPortableRuntime(t, llc, clang, "scalar_move_alias", triple, ir, driver)
+				})
+			}
+		})
+	}
+}
+
+func scalarMoveAliasPortableOracle(ctype, prototypes string, memory bool) string {
+	driver := `
+#include <stdint.h>
+#include <string.h>
+` + prototypes + `
+static const uint64_t inputs[]={0,1,UINT64_C(0x80000000),UINT64_C(0xffffffff),
+    UINT64_C(0x1234567800000000),UINT64_C(0x1234567880000001),
+    UINT64_C(0xffffffff12345678),UINT64_MAX};
+static const uint64_t seeds[]={0,UINT64_MAX,UINT64_C(0x8765432100000000),
+    UINT64_C(0x76543210aabbccdd)};
+typedef ` + ctype + ` Word;
+static int registers(void) {
+    Word (*rows[])(Word,Word)={AliasMOVQL,AliasMOVLQZX};
+    unsigned observations=0;
+    for(unsigned repeat=0;repeat<16;repeat++) {
+        for(unsigned r=0;r<2;r++) {
+            for(unsigned v=0;v<8;v++) {
+                for(unsigned s=0;s<4;s++) {
+                    uint32_t low=(uint32_t)inputs[v];
+                    Word want=(uint32_t)(low+((uint32_t)seeds[s]==0?7u:0u));
+                    if(rows[r]((Word)inputs[v],(Word)seeds[s])!=want) return 1;
+                    observations++;
+                }
+            }
+        }
+    }
+    return observations==1024?0:2;
+}
+`
+	if memory {
+		driver += `
+extern uint64_t MemoryMOVQL(uint8_t *,uint64_t);
+extern uint64_t MemoryMOVLQZX(const uint8_t *);
+static int memory(void) {
+    unsigned stores=0,loads=0;
+    for(unsigned repeat=0;repeat<16;repeat++) {
+        for(unsigned v=0;v<8;v++) {
+            uint8_t actual[16],want[16],before[16];
+            for(unsigned b=0;b<16;b++) actual[b]=want[b]=(uint8_t)(0xa5+b*13+repeat);
+            for(unsigned b=0;b<4;b++) want[b+3]=(uint8_t)(inputs[v]>>(8*b));
+            if(MemoryMOVQL(actual+2,inputs[v])!=(uint32_t)inputs[v] ||
+               memcmp(actual,want,sizeof(actual))) return 3;
+            stores++;
+            for(unsigned b=0;b<16;b++) actual[b]=before[b]=(uint8_t)(v*37+b*19+repeat);
+            uint32_t expected=0;
+            for(unsigned b=0;b<4;b++) expected|=(uint32_t)before[b+3]<<(8*b);
+            if(MemoryMOVLQZX(actual+2)!=expected || memcmp(actual,before,sizeof(actual))) return 4;
+            loads++;
+        }
+    }
+    return stores==128&&loads==128?0:5;
+}
+int main(void) {return registers() || memory();}
+`
+	} else {
+		driver += "\nint main(void) {return registers();}\n"
+	}
+	return driver
+}
diff --git a/x86_scalar_move_alias_test.go b/x86_scalar_move_alias_test.go
new file mode 100644
index 000000000..ae798d777
--- /dev/null
+++ b/x86_scalar_move_alias_test.go
@@ -0,0 +1,352 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ScalarMoveAliasesOriginalGoTablesAndBytes(t *testing.T) {
+	catalog, err := goasmrules.LoadX86LegacyRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	seen := map[string]bool{}
+	for _, entry := range catalog.Optab {
+		if entry.Opcode != "MOVQL" && entry.Opcode != "MOVLQZX" {
+			continue
+		}
+		classes, code, table := "Yrl,Yml", "0x89", "yrl_ml"
+		if entry.Opcode == "MOVLQZX" {
+			classes, code, table = "Yml,Yrl", "0x8b", "yml_rl"
+		}
+		if seen[entry.Opcode] || entry.Kind != "encoding" || entry.Ytab != table || entry.Prefix != "Px" ||
+			len(entry.OpBytes) != 1 || entry.OpBytes[0] != code || entry.EscapeAdjustment != 0 ||
+			len(entry.Rows) != 1 || entry.Rows[0].RowIndex != 0 || entry.Rows[0].UnmatchedOffset != 0 ||
+			entry.Rows[0].ZCase != "Zr_m" && entry.Opcode == "MOVQL" ||
+			entry.Rows[0].ZCase != "Zm_r" && entry.Opcode == "MOVLQZX" ||
+			entry.Rows[0].ZOffset != 1 || strings.Join(entry.Rows[0].Classes, ",") != classes {
+			t.Fatal("complete scalar alias source table changed", entry)
+		}
+		seen[entry.Opcode] = true
+	}
+	if len(seen) != 2 {
+		t.Fatal("missing an original scalar move alias", seen)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		cases := []x86OfficialPackedCase{
+			{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVQL BX,CX", Encoding: []byte{0x89, 0xd9}}},
+			{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVQL CX,0(SI)", Encoding: []byte{0x89, 0x0e}}},
+			{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVLQZX BX,CX", Encoding: []byte{0x8b, 0xcb}}},
+			{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVLQZX 0(SI),CX", Encoding: []byte{0x8b, 0x0e}}},
+		}
+		if arch == "amd64" {
+			cases = append(cases,
+				x86OfficialPackedCase{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVQL R8,BX", Encoding: []byte{0x44, 0x89, 0xc3}}},
+				x86OfficialPackedCase{witness: goasmrules.X86PackedBinaryWitness{Instruction: "MOVLQZX R8,BX", Encoding: []byte{0x41, 0x8b, 0xd8}}})
+		}
+		var source strings.Builder
+		for i := range cases {
+			cases[i].symbol = fmt.Sprintf("ScalarAliasBytes%d", i)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-0\n", cases[i].symbol)
+			cases[i].line = strings.Count(source.String(), "\n") + 1
+			fmt.Fprintln(&source, cases[i].witness.Instruction)
+			source.WriteString("RET\n")
+		}
+		listing, err := x86ScalarLiteralGoListing(t, arch, source.String())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := x86OfficialPackedVerifyListing(listing, cases); err != nil {
+			t.Fatal("original alias direction, width or REX encoding changed", arch, err)
+		}
+	}
+}
+
+func TestX86ScalarMoveAliasesByteEffectsAndPreservedRoles(t *testing.T) {
+	for _, operation := range []string{"MOVQL R8,BX", "MOVQL AX,(R8)", "MOVLQZX R8,BX", "MOVLQZX (R8),BX"} {
+		instruction := x86ScalarLaneInstruction(t, operation)
+		if _, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, "386"); known && err == nil {
+			t.Error("386 scalar alias acquired an amd64 register/address bank", operation)
+		}
+		if after := x86ResultCallerAddressesAfter(instruction, [16]bool{true}, nil, "386"); after != [16]bool{} {
+			t.Error("invalid mode32 alias retained a caller-address fact", operation, after)
+		}
+		goAssemblerOracleOutput(t, "386", "TEXT mode(SB),4,$0-0\n"+operation+"\nRET\n", "", false)
+	}
+	for _, offset := range []string{"2147483648", "4294967295"} {
+		for _, operation := range []string{"MOVQL AX," + offset + "(SI)", "MOVLQZX " + offset + "(SI),BX"} {
+			instruction := x86ScalarLaneInstruction(t, operation)
+			if _, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, "386"); !known || err != nil {
+				t.Error("SCALAR_MOVE_ALIAS_UNSIGNED_OFFSET_GAP", operation, known, err)
+			}
+			goAssemblerOracleOutput(t, "386", "TEXT offset(SB),4,$0-0\n"+operation+"\nRET\n", "", true)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, operation := range []string{"MOVQL AX,BX", "MOVQL AX,0(SI)", "MOVLQZX AX,BX", "MOVLQZX 0(SI),BX"} {
+			instruction := x86ScalarLaneInstruction(t, operation)
+			effect, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, arch)
+			if !known || err != nil || len(effect.operands) != 2 || effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.dynamicMemory {
+				t.Error("SCALAR_MOVE_ALIAS_TYPED_EFFECT_GAP", arch, operation, effect, known, err)
+				continue
+			}
+			read, write := effect.operands[0], effect.operands[1]
+			if read.index != 0 || !read.read || read.write || read.width != 4 ||
+				write.index != 1 || !write.write || write.read ||
+				(write.width != 4 && !(arch == "amd64" && instruction.Args[1].Kind == OpReg && write.width == 8)) {
+				t.Error("scalar alias lost exact four-byte input/store or GP zero-extension footprint", arch, operation, effect)
+			}
+		}
+		for _, op := range []string{"MOVQL", "MOVLQZX"} {
+			t.Run(arch+"/"+op, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, op+" AX,BX")
+				canonical := x86ScalarLaneInstruction(t, "MOVL AX,BX")
+				original := fmt.Sprintf("%#v", instruction)
+				for mask := 0; mask < 256; mask++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.gp[0], state.gp[3], state.pointerGP[3] = uint8(mask), 0x80, true
+					want, got := state.clone(), state.clone()
+					accepted := x86ResultTransfer(canonical, &want, nil, 0, arch)
+					actual := x86ResultTransfer(instruction, &got, nil, 0, arch)
+					if actual != accepted || !reflect.DeepEqual(got, want) || accepted != (mask&15 == 15) {
+						t.Fatal("SCALAR_MOVE_ALIAS_BYTE_FLOW_GAP", op, arch, mask, actual, accepted, got, want)
+					}
+					if actual && (got.gp[3] != 0xff || got.pointerGP[3] || got.flags != state.flags || got.direction != state.direction) {
+						t.Fatal("scalar alias lost r32 zero extension or changed unrelated roles")
+					}
+				}
+				// A source-width operation must preserve the existing MOVL
+				// pointer-bit policy, including a complete mode32 word copy.
+				pointer := x86ResultState{flags: x86ByteFlagCF}
+				pointer.pointerGP[0] = true
+				want, got := pointer.clone(), pointer.clone()
+				accepted := x86ResultTransfer(canonical, &want, nil, 0, arch)
+				if actual := x86ResultTransfer(instruction, &got, nil, 0, arch); actual != accepted || !reflect.DeepEqual(got, want) {
+					t.Fatal("scalar alias invented NUM or lost the existing whole-word pointer role", arch, op, got, want)
+				}
+				addresses := [16]bool{}
+				addresses[2], addresses[3] = true, true
+				wantAddresses := x86ResultCallerAddressesAfter(canonical, addresses, nil, arch)
+				if gotAddresses := x86ResultCallerAddressesAfter(instruction, addresses, nil, arch); gotAddresses != wantAddresses {
+					t.Fatal("SCALAR_MOVE_ALIAS_ADDRESS_FOOTPRINT_GAP", arch, op, gotAddresses, wantAddresses)
+				}
+				if fmt.Sprintf("%#v", instruction) != original {
+					t.Fatal("alias effect changed original Op, Raw or operands")
+				}
+			})
+			if arch == "386" {
+				t.Run("386/native-pointer-copy/"+op, func(t *testing.T) {
+					// Px copies one complete 32-bit word on this mode. Preserve
+					// its actual pointer identity without turning its bits into NUM.
+					source := "TEXT ·Value(SB),4,$0-8\nMOVL p+0(FP),AX\n" + op + " AX,SI\nMOVL (SI),BX\nMOVL BX,ret+4(FP)\nRET\n"
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *uint32) uint32", arch, "i386-unknown-linux-gnu", api); err != nil || ir == "" {
+								t.Fatal("SCALAR_MOVE_ALIAS_WORD_POINTER_GAP", op, api, err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
+
+func scalarMoveAliasFunction(name, arch, op string, memory bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	if !memory {
+		return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s x+0(FP),AX\n%s AX,BX\n%s BX,ret+%d(FP)\nRET\n", name, 2*word, move, op, move, word),
+			fmt.Sprintf("func %s(x uintptr) uintptr\n", name)
+	}
+	if op == "MOVQL" {
+		return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\n%s x+%d(FP),AX\nMOVQL AX,1(SI)\nMOVL 1(SI),BX\n%s BX,ret+%d(FP)\nRET\n", name, 3*word, move, move, word, move, 2*word),
+			fmt.Sprintf("func %s(p *[8]byte,x uintptr) uintptr\n", name)
+	}
+	return fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),SI\nMOVLQZX 1(SI),BX\n%s BX,ret+%d(FP)\nRET\n", name, 2*word, move, move, word),
+		fmt.Sprintf("func %s(p *[8]byte) uintptr\n", name)
+}
+
+func TestX86ScalarMoveAliasesInitializedThreeAPIFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range []string{"MOVQL", "MOVLQZX"} {
+				for _, memory := range []bool{false, true} {
+					body, declaration := scalarMoveAliasFunction(fmt.Sprintf("ScalarAlias%d", count), target.arch, op, memory)
+					source.WriteString(body)
+					declarations.WriteString(declaration)
+					count++
+				}
+			}
+			if count != 4 {
+				t.Fatal("incomplete source/destination alias directions")
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("SCALAR_MOVE_ALIAS_INITIALIZED_GAP", err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run(level, func(t *testing.T) { x86PackedStringCompileObject(t, llc, target.triple, ir, level) })
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarMoveAliasesMissingInputAndFormatsRemainRejected(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		triple := x86Legacy127Targets(arch)[0]
+		for _, op := range []string{"MOVQL", "MOVLQZX"} {
+			for _, sample := range []struct{ name, body string }{
+				{"missing-source", op + " AX,BX"},
+				{"partial-source", "MOVB $1,AX\n" + op + " AX,BX"},
+			} {
+				t.Run(arch+"/"+op+"/"+sample.name, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n%s BX,ret+0(FP)\nRET\n", word, sample.body, move)
+					goAssemblerOracleOutput(t, arch, source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("alias syntax supplied missing numerical input", op, sample.name, api, err)
+						}
+					}
+				})
+			}
+		}
+		for _, operation := range []string{
+			"MOVQL $1,BX", "MOVQL (SI),BX", "MOVQL x+0(FP),BX", "MOVQL (SI),(DI)",
+			"MOVQL AL,BX", "MOVQL AH,BX", "MOVQL X0,BX", "MOVQL M0,BX", "MOVQL AX,X0", "MOVQL.Z AX,BX",
+			"MOVLQZX $1,BX", "MOVLQZX AX,(SI)", "MOVLQZX (SI),(DI)", "MOVLQZX AH,BX", "MOVLQZX M0,BX",
+		} {
+			t.Run(arch+"/invalid/"+operation, func(t *testing.T) {
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\n%s BX,ret+0(FP)\nRET\n", word, operation, move)
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uintptr", arch, triple, api); err == nil || ir != "" {
+						t.Fatal("alias widened beyond its original directional table", arch, operation, api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarMoveAliasesNativeAddressAndSourceIdentityBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move := goWordSize(arch), "MOVQ"
+		if arch == "386" {
+			move = "MOVL"
+		}
+		triple := x86Legacy127Targets(arch)[0]
+		for _, op := range []string{"MOVQL", "MOVLQZX"} {
+			source, declaration := scalarMoveAliasFunction("Value", arch, op, true)
+			pointerLoad := move + " p+0(FP),SI\n"
+			if strings.Count(source, pointerLoad) != 1 {
+				t.Fatal("native negative no longer removes exactly one pointer input")
+			}
+			for name, changed := range map[string]string{
+				"unknown-base":  strings.Replace(source, pointerLoad, "", 1),
+				"numeric-base":  strings.Replace(source, pointerLoad, "MOVL $42,SI\n", 1),
+				"pointer-index": strings.ReplaceAll(source, "1(SI)", "1(SI)(SI*1)"),
+			} {
+				t.Run(arch+"/"+op+"/"+name, func(t *testing.T) {
+					goAssemblerOracleOutput(t, arch, changed, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+						if name == "numeric-base" {
+							effect := "load volatile i32,"
+							if op == "MOVQL" {
+								effect = "store volatile i32 "
+							}
+							if err != nil || !strings.Contains(ir, effect) {
+								t.Fatal("NUM scalar alias lost its exact dword direction", op, api, err)
+							}
+							x86RequireNumericNativeSourceContext(t, changed, declaration, arch)
+							x86NumericNativeAddressObject(t, ir, triple)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar alias supplied native address authority", op, name, api, err)
+						}
+					}
+				})
+			}
+			for _, mutation := range []string{"decoded", "raw"} {
+				t.Run(arch+"/"+op+"/"+mutation, func(t *testing.T) {
+					body := fmt.Sprintf("%s x+0(FP),AX\nMOVL $7,DX\n%s AX,BX\n%s BX,ret+%d(FP)\nRET", move, op, move, word)
+					_, file, sig, original := x86ResultInitializationFixture(t, arch, "func Value(x uintptr) uintptr", body)
+					goAssemblerOracleOutput(t, arch, original, "", true)
+					changed := 0
+					for index := range file.Funcs[0].Instrs {
+						ins := &file.Funcs[0].Instrs[index]
+						if ins.Op != Op(op) {
+							continue
+						}
+						changed++
+						switch mutation {
+						case "decoded":
+							ins.x86Encoded = true
+						case "raw":
+							ins.x86SourceRaw = new(x86SourceRawInstruction)
+						}
+					}
+					if changed != 1 {
+						t.Fatal("source identity negative lost its single original operation")
+					}
+					options := Options{Goarch: arch, TargetTriple: triple, Sigs: map[string]FuncSig{"Value": sig},
+						ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+					ir, err := Translate(file, options)
+					if op == "MOVQL" {
+						if err == nil || ir != "" {
+							t.Fatal("new source alias authenticated an unbound physical producer", op, mutation, err)
+						}
+						return
+					}
+					// The existing extension consumer already admits pure NUM
+					// register effects with these markers. Preserve that allowance;
+					// a marker must still not authorize a new native memory read.
+					if err != nil || ir == "" {
+						t.Fatal("existing numerical raw extension regressed", mutation, err)
+					}
+					memoryBody := fmt.Sprintf("%s p+0(FP),AX\nMOVLQZX (AX),BX\n%s BX,ret+%d(FP)\nRET", move, move, word)
+					_, memoryFile, memorySig, memorySource := x86ResultInitializationFixture(t, arch, "func Value(p *uint32) uintptr", memoryBody)
+					goAssemblerOracleOutput(t, arch, memorySource, "", true)
+					for index := range memoryFile.Funcs[0].Instrs {
+						ins := &memoryFile.Funcs[0].Instrs[index]
+						if ins.Op == "MOVLQZX" {
+							ins.x86Encoded = mutation == "decoded"
+							if mutation == "raw" {
+								ins.x86SourceRaw = new(x86SourceRawInstruction)
+							}
+						}
+					}
+					options.Sigs = map[string]FuncSig{"Value": memorySig}
+					if ir, err := Translate(memoryFile, options); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("numerical raw extension acquired native read authority", mutation, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_precision_contract_test.go b/x86_scalar_precision_contract_test.go
new file mode 100644
index 000000000..eb79d54f7
--- /dev/null
+++ b/x86_scalar_precision_contract_test.go
@@ -0,0 +1,260 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent of production: legacy yxm and both complete _yvaddsd rows.
+// EVEX SS->SD has SAE only, whereas SD->SS has all four ER controls.
+type x86ScalarPrecisionOracleRow struct {
+	op, control, mode, source string
+	input, output             int
+	vector, high              bool
+}
+
+func x86ScalarPrecisionOracleRows(arch string) []x86ScalarPrecisionOracleRow {
+	var rows []x86ScalarPrecisionOracleRow
+	for _, scalar := range []struct {
+		op            string
+		input, output int
+	}{{"CVTSS2SD", 4, 8}, {"CVTSD2SS", 8, 4}} {
+		for _, source := range []string{"register", "native", "FP"} {
+			rows = append(rows, x86ScalarPrecisionOracleRow{op: scalar.op, input: scalar.input, output: scalar.output, source: source})
+		}
+		controls := []string{"", "SAE"}
+		if scalar.input == 8 {
+			controls = []string{"", "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}
+		}
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			if arch == "386" && mode != "plain" {
+				continue // Go's named frontend has no four-operand mode32 row.
+			}
+			for _, source := range []string{"register", "native", "FP"} {
+				for _, control := range controls {
+					if control != "" && source != "register" {
+						continue
+					}
+					rows = append(rows, x86ScalarPrecisionOracleRow{op: "V" + scalar.op, input: scalar.input,
+						output: scalar.output, source: source, control: control, mode: mode, vector: true})
+				}
+			}
+		}
+		if arch == "amd64" {
+			// A high upper/destination bank forces the otherwise overlapping
+			// unmasked EVEX row, including its independent m32/m64 tuple.
+			for _, source := range []string{"register", "native", "FP"} {
+				rows = append(rows, x86ScalarPrecisionOracleRow{op: "V" + scalar.op, input: scalar.input,
+					output: scalar.output, source: source, mode: "plain", vector: true, high: true})
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86ScalarPrecisionOracleRow) instruction() string {
+	scalar, upper, destination := row.registers()
+	op, source := row.op, fmt.Sprint("X", scalar)
+	if row.source == "native" {
+		source = "(AX)"
+	} else if row.source == "FP" {
+		source = "input+8(FP)"
+	}
+	if row.control != "" {
+		op += "." + row.control
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	if !row.vector {
+		return fmt.Sprintf("%s %s,X%d", op, source, destination)
+	}
+	mask := ""
+	if row.mode == "merge" || row.mode == "zero" {
+		mask = ",K1"
+	}
+	return fmt.Sprintf("%s %s,X%d%s,X%d", op, source, upper, mask, destination)
+}
+
+func (row x86ScalarPrecisionOracleRow) registers() (source, upper, destination int) {
+	if row.high {
+		return 16, 17, 18
+	}
+	if !row.vector {
+		return 0, 2, 2
+	}
+	return 0, 1, 2
+}
+
+func TestX86ScalarPrecisionCompleteTypedOperandAndControlMatrix(t *testing.T) {
+	x86ScalarPrecisionOriginalProgram(t)
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86ScalarPrecisionOracleRows(arch)
+		want := 45
+		if arch == "386" {
+			want = 17
+		}
+		if len(rows) != want {
+			t.Fatal("complete independent precision source/control directory changed", arch, len(rows), want)
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+					effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+					t.Fatal("complete precision conversion source/upper/K/destination effect missing", effect, known, err)
+				}
+				reads, writes := make(map[int]bool), make(map[int]bool)
+				for _, operand := range effect.operands {
+					width := int64(16)
+					if operand.index == 0 {
+						width = int64(row.input)
+					} else if operand.operand.Kind == OpReg && operand.operand.Reg == "K1" {
+						width = 8
+					}
+					if operand.index < 0 || operand.index >= len(ins.Args) || operand.width != width ||
+						!reflect.DeepEqual(operand.operand, ins.Args[operand.index]) {
+						t.Fatal("scalar input tuple, upper carrier or K width changed", operand)
+					}
+					reads[operand.index] = reads[operand.index] || operand.read
+					writes[operand.index] = writes[operand.index] || operand.write
+				}
+				last := len(ins.Args) - 1
+				for index := range ins.Args {
+					wantRead := index < last || !row.vector || row.mode == "merge"
+					if reads[index] != wantRead || writes[index] != (index == last) {
+						t.Fatal("conversion data, copied upper, merge or mask role was lost", index, reads, writes)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarPrecisionSelectedBytesOldUpperAndAliases(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarPrecisionOracleRows(arch) {
+			if row.source != "register" {
+				continue
+			}
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				for _, alias := range []string{"distinct", "source-destination", "upper-destination", "all"} {
+					ins := x86ScalarLaneInstruction(t, row.instruction())
+					source, base, destination := row.registers()
+					if alias == "source-destination" || alias == "all" {
+						source, ins.Args[0].Reg = destination, Reg(fmt.Sprint("X", destination))
+					}
+					if row.vector && (alias == "upper-destination" || alias == "all") {
+						base, ins.Args[1].Reg = destination, Reg(fmt.Sprint("X", destination))
+					}
+					start, _, _ := row.registers()
+					for register := start; register < start+3; register++ {
+						for missing := -1; missing < 64; missing++ {
+							state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward, masks: [8]bool{1: true}}
+							for index := start; index < start+3; index++ {
+								state.writeVector(index, 64, ^uint64(0), true)
+							}
+							state.pointerGP[5], state.callerAddressGP[6] = true, true
+							if missing >= 0 {
+								state.writeVector(register, 64, ^(uint64(1) << uint(missing)), true)
+							}
+							before, want := state.clone(), state.clone()
+							input := x86CallerVectorByteMask(int64(row.input))
+							output := x86CallerVectorByteMask(int64(row.output))
+							valid := state.vectorBytes(source)&input == input &&
+								(row.mode != "merge" || state.vectorBytes(destination)&output == output)
+							if valid {
+								defined := output | state.vectorBytes(base)&(0xffff&^output)
+								want.writeVector(destination, 16, defined, !row.vector)
+							}
+							if accepted := x86ResultTransfer(ins, &state, nil, 0, arch); accepted != valid || !reflect.DeepEqual(state, want) {
+								t.Fatal("precision conversion invented active FP/merge input, copied unknown upper bytes or changed unrelated state",
+									alias, register, missing, accepted, valid, before, state, want)
+							}
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarPrecisionLogicalScalarReadRequiresExactOwnedBytes(t *testing.T) {
+	for _, row := range x86ScalarPrecisionOracleRows("amd64") {
+		if row.source != "FP" {
+			continue
+		}
+		t.Run(row.instruction(), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.instruction())
+			_, upper, destination := row.registers()
+			for missing := -1; missing < row.input; missing++ {
+				for _, role := range []string{"defined", "owned"} {
+					owned := make([]bool, 16)
+					state := x86ResultState{fp: make([]bool, 16), masks: [8]bool{1: true}, flags: x86ByteFlagsAll}
+					state.writeVector(upper, 64, ^uint64(0), true)
+					state.writeVector(destination, 64, ^uint64(0), true)
+					for at := 8; at < 8+row.input; at++ {
+						owned[at], state.fp[at] = true, true
+					}
+					if missing >= 0 {
+						if role == "defined" {
+							state.fp[8+missing] = false
+						} else {
+							owned[8+missing] = false
+						}
+					}
+					before := state.clone()
+					if accepted := x86ResultTransfer(ins, &state, owned, 16, "amd64"); accepted != (missing < 0) ||
+						missing >= 0 && !reflect.DeepEqual(state, before) {
+						t.Fatal("scalar precision borrowed adjacent virtual bytes or missing owned input", role, missing, accepted)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarPrecisionNativeAndMaskInputsRemainMandatory(t *testing.T) {
+	for _, row := range x86ScalarPrecisionOracleRows("amd64") {
+		if row.source == "FP" || row.source != "native" && row.mode != "merge" && row.mode != "zero" {
+			continue
+		}
+		for _, unusedBool := range []bool{false, true} {
+			extent, declaration := 0, "func Missing()"
+			if unusedBool {
+				extent, declaration = 1, "func Missing(unused bool)"
+			}
+			source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s\nRET\n", extent, row.instruction())
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/unused=%t/%s", row.instruction(), unusedBool, api), func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Void/dead conversion invented active FP/native/K/merge input", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarPrecisionTypedGrammarRejectsNonGoForms(t *testing.T) {
+	for _, line := range []string{
+		"CVTSS2SD Y0,X1", "CVTSD2SS M0,X1", "CVTSS2SD X16,X1", "CVTSD2SS.Z X0,X1",
+		"VCVTSS2SD.RN_SAE X0,X1,X2", "VCVTSD2SS.SAE X0,X1,X2",
+		"VCVTSS2SD.SAE (AX),X1,X2", "VCVTSD2SS.RN_SAE (AX),X1,X2",
+		"VCVTSS2SD.Z X0,X1,X2", "VCVTSD2SS X0,X1,K0,X2",
+		"VCVTSS2SD.BCST (AX),X1,X2", "VCVTSD2SS Y0,X1,X2", "VCVTSS2SD X0,Y1,X2",
+		"VCVTSD2SS X0,X1,Z2", "VCVTSS2SD X0,X1", "VCVTSD2SS.RN_SAE.RD_SAE X0,X1,X2",
+	} {
+		t.Run(strings.ReplaceAll(line, " ", "_"), func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, line)
+			if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64"); !known || err == nil {
+				t.Fatal("known precision family lacks closed operands/control grammar", known, err)
+			}
+		})
+	}
+}
diff --git a/x86_scalar_precision_features_test.go b/x86_scalar_precision_features_test.go
new file mode 100644
index 000000000..4416e1e12
--- /dev/null
+++ b/x86_scalar_precision_features_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarPrecisionCompleteMinimalNativeFeatures(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarPrecisionOracleRows(arch) {
+			instruction := x86ScalarLaneInstruction(t, row.instruction())
+			want := "+sse2"
+			if row.vector {
+				want = "+avx"
+				if row.high || row.control != "" || row.mode == "merge" || row.mode == "zero" {
+					want = "+avx512f"
+				}
+			}
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}}); got != want {
+				t.Fatal("isolated named precision form lost its minimum native ISA", arch, row.instruction(), got, want)
+			}
+		}
+		for _, row := range x86ScalarPrecisionRawCases() {
+			if arch == "386" && (row.row.mode == "merge" || row.row.mode == "zero") {
+				continue // The physical decoder retains its separate current mode32 mask boundary.
+			}
+			file, err := normalizeX86RawFile(mustParseX86RawReturn(t,
+				"TEXT ·RawMinimum(SB),4,$0-0\n"+x86RawDisplacementDirectives(row.code)+"RET\n"), arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			want := map[string]string{"legacy": "+sse2", "VEX": "+avx", "EVEX": "+avx512f"}[row.generation]
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0]); got != want {
+				t.Fatal("low-bank physical precision generation lost its minimum native ISA", arch, row.generation, row.row.instruction(), got, want)
+			}
+		}
+		for _, source := range []string{
+			"CVTSS2SD", "CVTSD2SS Y0,X1", "VCVTSS2SD.SAE (AX),X1,X2",
+			"VCVTSD2SS.SAE X0,X1,X2", "VCVTSS2SD.Z X0,X1,X2",
+		} {
+			instruction := x86ScalarLaneInstruction(t, source)
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}}); got != "" {
+				t.Fatal("malformed scalar precision source acquired a native ISA profile", arch, source, got)
+			}
+		}
+	}
+}
+
+// Every function has just one conversion and its own inferred feature set.
+// Compiling them in one module cannot borrow an SSE/AVX/EVEX sibling's profile.
+// These original uninitialized Go/emitter objects remain public Context, not
+// initialized execution, caller memory or a native-entry certificate.
+func TestX86ScalarPrecisionIsolatedNativeProfileObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("isolated scalar precision native profiles require LLVM22")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		var source strings.Builder
+		for index, row := range x86ScalarPrecisionOracleRows(arch) {
+			if row.source == "FP" {
+				continue // The independent owned scalar-input matrix, not an unbound native format.
+			}
+			fmt.Fprintf(&source, "TEXT ·NamedMinimum%d(SB),4,$0-0\n%s\nRET\n", index, row.instruction())
+		}
+		for index, row := range x86ScalarPrecisionRawCases() {
+			if arch == "386" && (row.row.mode == "merge" || row.row.mode == "zero") {
+				continue
+			}
+			fmt.Fprintf(&source, "TEXT ·RawMinimum%d(SB),4,$0-0\n%sRET\n", index, x86RawDisplacementDirectives(row.code))
+		}
+		targets := []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"}
+		if arch == "386" {
+			targets = []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"}
+		}
+		for _, triple := range targets {
+			t.Run(arch+"/"+triple, func(t *testing.T) {
+				file, signatures := x86UnboundVoidFormatSources(t, source.String(), arch, triple)
+				normalized, err := normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ir := x86ScalarFormatObjectUnit(t, normalized, signatures, arch, triple, 0)
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					compileLLVMToObject(t, llc, triple, "precision-minimum.ll", "precision-minimum.o", text)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_precision_format_test.go b/x86_scalar_precision_format_test.go
new file mode 100644
index 000000000..101abc5c8
--- /dev/null
+++ b/x86_scalar_precision_format_test.go
@@ -0,0 +1,52 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+// Preserve the entire original Go object and three-API Context result. Only
+// physically bound rows enter this private, compile-only emitter carrier;
+// mode32 high banks are not initialized or remapped into AMD64 registers.
+// Public initialized objects have their own complete independent matrix.
+func x86ScalarPrecisionOriginalFormatObject(t *testing.T, source, name, arch, triple string, raw bool) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	if raw {
+		var err error
+		file, err = normalizeX86RawFile(file, arch)
+		if err != nil {
+			t.Fatal("complete original scalar precision bytes lost their decoder", err)
+		}
+	}
+	local := *file
+	local.Funcs = append([]Func(nil), file.Funcs...)
+	local.Funcs[0].Instrs = nil
+	contextRows, retained := 0, 0
+	for _, instruction := range file.Funcs[0].Instrs {
+		if _, known, err := x86ScalarPrecisionProperties(instruction.Op, instruction, arch); known {
+			if err != nil {
+				if arch != "386" || !errors.Is(err, ErrProbeNeedsContext) ||
+					x86Mode32VectorRegisterContext(instruction, arch) == nil {
+					t.Fatal("original precision format became malformed or lost a different source role", instruction.Raw, err)
+				}
+				contextRows++
+				continue
+			}
+			retained++
+		}
+		local.Funcs[0].Instrs = append(local.Funcs[0].Instrs, instruction)
+	}
+	expectedContext := 0
+	if arch == "386" {
+		expectedContext = 7
+		if raw {
+			expectedContext = 4
+		}
+	}
+	if contextRows != expectedContext || retained == 0 {
+		t.Fatal("original physical-bank Context partition changed", arch, raw, contextRows, expectedContext, retained)
+	}
+	t.Logf("complete original source/object preserved: %d rows remain physical-bank Context; %d direct-emitter rows are object-only", contextRows, retained)
+	return x86ScalarFormatObjectUnit(t, &local, signatures, arch, triple, 0)
+}
diff --git a/x86_scalar_precision_go127_test.go b/x86_scalar_precision_go127_test.go
new file mode 100644
index 000000000..746cd02e6
--- /dev/null
+++ b/x86_scalar_precision_go127_test.go
@@ -0,0 +1,69 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86ScalarPrecisionCompleteOfficialEncoderRows(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, expected := range []string{
+		"var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n}",
+		"{ACVTSD2SS, yxm, Pf2, opBytes{0x5a}}", "{ACVTSS2SD, yxm, Pf3, opBytes{0x5a}}",
+	} {
+		if !strings.Contains(string(legacy), expected) {
+			t.Fatal("complete legacy scalar precision grammar/prefix/opcode changed", expected)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VCVTSS2SD" && rule.Opcode != "VCVTSD2SS" {
+			continue
+		}
+		prefix, w, bytes, control := "F3", "W0", "N4", "Sae"
+		if rule.Opcode == "VCVTSD2SS" {
+			prefix, w, bytes, control = "F2", "W1", "N8", "Rounding"
+		}
+		attributes := []string{
+			"avxEscape | vex128 | vex" + prefix + " | vex0F | vexW0", "0x5A",
+			"avxEscape | evex128 | evex" + prefix + " | evex0F | evex" + w,
+			"evex" + bytes + " | evex" + control + "Enabled | evexZeroingEnabled", "0x5A",
+		}
+		classes := [][]string{{"Yxm", "Yxr", "Yxr"}, {"YxmEvex", "YxrEvex", "YxrEvex"}, {"YxmEvex", "YxrEvex", "Yknot0", "YxrEvex"}}
+		index := rule.RowIndex
+		if index < 0 || index > 2 {
+			t.Fatal("scalar precision acquired an unobserved encoder row", rule)
+		}
+		offset, zoffset, zcase := 0, 2, "Zvex_rm_v_r"
+		if index > 0 {
+			offset, zoffset, zcase = 2, 0, "Zevex_rm_v_r"
+			if index == 2 {
+				zoffset, zcase = 3, "Zevex_rm_v_k_r"
+			}
+		}
+		if rule.Ytab != "_yvaddsd" || rule.Prefix != "Pavx" || rule.EncodingOffset != offset ||
+			rule.ZOffset != zoffset || rule.ZCase != zcase || !reflect.DeepEqual(rule.Classes, classes[index]) ||
+			!reflect.DeepEqual(rule.OpBytes, attributes) {
+			t.Fatal("complete precision control, tuple, zeroing or operand row changed", rule, attributes)
+		}
+		counts[rule.Opcode]++
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VCVTSS2SD": 3, "VCVTSD2SS": 3}) {
+		t.Fatal("complete six AVX plus two legacy encoder row inventory changed", counts)
+	}
+}
diff --git a/x86_scalar_precision_mode32_test.go b/x86_scalar_precision_mode32_test.go
new file mode 100644
index 000000000..a889c828a
--- /dev/null
+++ b/x86_scalar_precision_mode32_test.go
@@ -0,0 +1,32 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+)
+
+func TestX86ScalarPrecisionMode32FrontendDoesNotGrantPhysicalInputs(t *testing.T) {
+	for _, op := range []string{"VCVTSS2SD", "VCVTSD2SS"} {
+		for _, operands := range []string{"X31,X30,X29", "16(R9),X1,X2"} {
+			t.Run(op+"/"+operands, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" "+operands)
+				goAssemblerOracleOutput(t, "386", "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n", "", true)
+				if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go's accepted spelling acquired a physical mode32 register/address or became rejected syntax", known, err)
+				}
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for index := range state.xmm {
+					state.writeVector(index, 64, ^uint64(0), true)
+				}
+				for index := range state.gp {
+					state.gp[index], state.pointerGP[index] = 0xff, true
+				}
+				before := state.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, "386") || !reflect.DeepEqual(state, before) {
+					t.Fatal("frontend spelling borrowed an AMD64 numerical/native input", state)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_precision_objects_tdd_test.go b/x86_scalar_precision_objects_tdd_test.go
new file mode 100644
index 000000000..00f6384a6
--- /dev/null
+++ b/x86_scalar_precision_objects_tdd_test.go
@@ -0,0 +1,324 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Replay the actual complete discovering runtime source. Neither its MOVSD/
+// MOVSS producers nor its rounding/mask operations, C oracle or inputs may
+// change merely to make the initialized program pass.
+func x86ScalarPrecisionOriginalProgram(t *testing.T) string {
+	t.Helper()
+	const path = "amd64_lower_vcvtss2sd_test.go"
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	set := token.NewFileSet()
+	file, err := parser.ParseFile(set, path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "qualifyAMD64ScalarPrecisionConvertRuntimeSemantics" {
+			continue
+		}
+		start, end := set.Position(function.Pos()).Offset, set.Position(function.End()).Offset
+		// Only this independently audited, execution-only preflight may be
+		// removed from the original driver fingerprint. The complete original
+		// ASM/C, samples and all other statements retain their old exact hash.
+		original := strings.Replace(string(data[start:end]),
+			"\tx86OriginalFloatingRuntimeRequireCPU(t, \"scalar-precision\", clang, triple, runPrefix)\n", "", 1)
+		original = strings.Replace(original, "func qualifyAMD64ScalarPrecisionConvertRuntimeSemantics(",
+			"func TestAMD64ScalarPrecisionConvertRuntimeSemantics(", 1)
+		if fmt.Sprintf("%x", sha256.Sum256([]byte(original))) != "9df4a3815affc1e690c09fb6db69dfbe20c2acedb32baa9e31210d4a00a977ee" {
+			t.Fatal("original precision conversion ASM/C, independent values or source inputs changed")
+		}
+		constants := make(map[string]string)
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			value, ok := node.(*ast.ValueSpec)
+			if !ok || len(value.Names) != 1 || len(value.Values) != 1 {
+				return true
+			}
+			name := value.Names[0].Name
+			if name != "source" && name != "mainC" {
+				return true
+			}
+			literal, ok := value.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING || constants[name] != "" {
+				t.Fatal("original complete runtime escaped its independent single literal", name)
+			}
+			constants[name], err = strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			return true
+		})
+		if len(constants) != 2 || constants["source"] == "" || constants["mainC"] == "" {
+			t.Fatal("complete original precision runtime or independent C oracle disappeared")
+		}
+		return constants["source"]
+	}
+	t.Fatal("original precision runtime root disappeared")
+	return ""
+}
+
+func x86ScalarPrecisionRequireNativeEffects(t *testing.T, ir string, functions map[string][]string) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	for name, operations := range functions {
+		function := module.NamedFunction(name)
+		if function.IsNil() || function.FirstBasicBlock().IsNil() {
+			t.Fatal("complete scalar precision source omitted an actual function body", name)
+		}
+		body := function.String()
+		for _, operation := range operations {
+			found := false
+			for _, line := range strings.Split(body, "\n") {
+				found = found || x86ScalarPrecisionNativeEffectLine(line, operation)
+			}
+			if !found {
+				t.Fatal("original conversion opcode/MXCSR/exception effect was replaced by unowned pure LLVM arithmetic", name, operation, body)
+			}
+		}
+	}
+}
+
+func x86ScalarPrecisionNativeEffectLine(line, operation string) bool {
+	if strings.ContainsAny(line, "\r\n") {
+		return false
+	}
+	_, rest, present := strings.Cut(line, "asm sideeffect \"")
+	if !present {
+		return false
+	}
+	assembly, rest, present := strings.Cut(rest, "\"")
+	if !present {
+		return false
+	}
+	// A mask's kmovw and the forced EVEX encoding belong to the same actual
+	// opcode call. Do not accept unrelated prefixes, comments or other calls.
+	if strings.HasPrefix(assembly, "kmovw ") {
+		_, assembly, present = strings.Cut(assembly, "; ")
+		if !present {
+			return false
+		}
+	}
+	assembly = strings.TrimPrefix(assembly, "{evex} ")
+	canonical := strings.HasPrefix(assembly, strings.ToLower(operation)+" ")
+	rest = strings.TrimSpace(rest)
+	if !strings.HasPrefix(rest, ", \"") {
+		return false
+	}
+	constraints, arguments, present := strings.Cut(rest[len(", \""):], "\"")
+	memory, status := false, false
+	for _, constraint := range strings.Split(constraints, ",") {
+		memory = memory || constraint == "~{memory}"
+		status = status || constraint == "~{fpsr}"
+	}
+	if !present || !memory || !status {
+		return false
+	}
+	if canonical {
+		return true
+	}
+	return x86PackedPrecisionNativeMemoryAlias(assembly, constraints, arguments, operation)
+}
+
+func TestX86ScalarPrecisionOpcodeReceiptBindsOneActualCall(t *testing.T) {
+	for _, prefix := range []string{"", "{evex} ", "kmovw ${4:k}, %k1; ", "kmovw ${4:k}, %k1; {evex} "} {
+		line := "  %x = call <4 x float> asm sideeffect \"" + prefix +
+			"vcvtss2sd $3, $2, $0\", \"=v,0,v,v,~{memory},~{fpsr}\"()"
+		if !x86ScalarPrecisionNativeEffectLine(line, "VCVTSS2SD") {
+			t.Fatal("receipt rejected actual same-call mask/EVEX prefixes", prefix)
+		}
+		for _, changed := range []string{
+			strings.Replace(line, "sideeffect", "", 1),
+			strings.Replace(line, "~{memory}", "~{cc}", 1),
+			strings.Replace(line, "~{fpsr}", "~{cc}", 1),
+			strings.Replace(line, "vcvtss2sd", "vcvtsd2ss", 1),
+			strings.Replace(line, "vcvtss2sd", "# vcvtss2sd", 1),
+			strings.Replace(line, "vcvtss2sd", "nop; vcvtss2sd", 1),
+		} {
+			if x86ScalarPrecisionNativeEffectLine(changed, "VCVTSS2SD") {
+				t.Fatal("receipt borrowed another instruction, comment, unowned status or memory effect", changed)
+			}
+		}
+	}
+}
+
+func TestX86ScalarPrecisionOriginalProgramThreeAPIObjectsAndNativeOpcode(t *testing.T) {
+	source := x86ScalarPrecisionOriginalProgram(t)
+	declaration := "func scalarPrecisionConvertSemantics(out *[112]byte,doubles *float64,floats *float32,upper,old *[16]byte,mask uint64)\n"
+	if _, err := parser.ParseFile(token.NewFileSet(), "api.go", "package bitview\n"+declaration, parser.AllErrors); err != nil {
+		t.Fatal("complete original declaration is not valid Go", err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original initialized scalar precision objects require LLVM22")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			// Supply the actual Go SDK's macro header, without modifying any
+			// original assembly body byte or substituting its instruction set.
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+					if err != nil {
+						t.Fatal("original complete initialized precision source remains unclosed", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, text, map[string][]string{
+							"scalarPrecisionConvertSemantics": {"VCVTSD2SS", "VCVTSS2SD"},
+						})
+						compileLLVMToObject(t, llc, triple, "original-scalar-precision.ll", "original-scalar-precision.o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86ScalarPrecisionInitializedProgram(index int, row x86ScalarPrecisionOracleRow) (string, string, string) {
+	name := fmt.Sprint("Precision", index)
+	scalar, _, destination := row.registers()
+	upper := scalar + 1 // Legacy's copied bytes come from old, not this independent input.
+	inputType, preparation := "uint64", ""
+	if row.source == "native" {
+		inputType, preparation = "*[8]byte", "MOVQ input+8(FP),AX\n"
+	} else if row.source == "register" {
+		move := "MOVSS"
+		if row.input == 8 {
+			move = "MOVSD"
+		}
+		if row.high {
+			move = "V" + move // Legacy scalar transport cannot address X16-X31.
+		}
+		preparation = fmt.Sprintf("%s input+8(FP),X%d\n", move, scalar)
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-40\nMOVQ out+0(FP),DI\nMOVQ upper+16(FP),BX\nMOVQ old+24(FP),CX\n"+
+		"VMOVDQU64 (BX),Z%d\nVMOVDQU64 (CX),Z%d\nKMOVQ mask+32(FP),K1\n%sSTC\n%s\n"+
+		"VMOVDQU64 Z%d,(DI)\nSETCS 64(DI)\nSTMXCSR 68(DI)\nRET\n", name, upper, destination, preparation, row.instruction(), destination)
+	declaration := fmt.Sprintf("func %s(out *[80]byte,input %s,upper,old *[64]byte,mask uint64)\n", name, inputType)
+	return source, declaration, name
+}
+
+func TestX86ScalarPrecisionCompleteInitializedMatrixThreeAPIObjects(t *testing.T) {
+	x86ScalarPrecisionOriginalProgram(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete initialized scalar precision objects require LLVM22")
+	}
+	rows := x86ScalarPrecisionOracleRows("amd64")
+	if len(rows) != 45 {
+		t.Fatal("complete precision input/control inventory changed", len(rows))
+	}
+	var source, declarations strings.Builder
+	functions := make(map[string][]string)
+	for index, row := range rows {
+		body, declaration, name := x86ScalarPrecisionInitializedProgram(index, row)
+		source.WriteString(body)
+		declarations.WriteString(declaration)
+		functions[name] = []string{row.op}
+	}
+	if _, err := parser.ParseFile(token.NewFileSet(), "api.go", "package bitview\n"+declarations.String(), parser.AllErrors); err != nil {
+		t.Fatal("complete precision declarations are not valid Go", err)
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("complete initialized scalar precision matrix remains unclosed", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, text, functions)
+						compileLLVMToObject(t, llc, triple, "complete-scalar-precision.ll", "complete-scalar-precision.o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ScalarPrecisionInitializedInputRevocationsAndZeroing(t *testing.T) {
+	type inputMutation struct {
+		name, remove string
+		valid        bool
+	}
+	for index, row := range x86ScalarPrecisionOracleRows("amd64") {
+		if row.source == "FP" || row.control != "" || row.high {
+			continue // Shared byte roles do not vary with an embedded control.
+		}
+		source, declaration, _ := x86ScalarPrecisionInitializedProgram(index, row)
+		input := "MOVQ input+8(FP),AX\n"
+		if row.source == "register" {
+			input = "MOVSS input+8(FP),X0\n"
+			if row.input == 8 {
+				input = "MOVSD input+8(FP),X0\n"
+			}
+		}
+		upper := "VMOVDQU64 (CX),Z2\n"
+		if row.vector {
+			upper = "VMOVDQU64 (BX),Z1\n"
+		}
+		mutations := []inputMutation{
+			{"active-input", input, false},
+			{"copied-upper", upper, false},
+			{"output-address", "MOVQ out+0(FP),DI\n", false},
+		}
+		if row.mode == "merge" || row.mode == "zero" {
+			mutations = append(mutations,
+				inputMutation{"mask", "KMOVQ mask+32(FP),K1\n", false},
+				inputMutation{"old-destination", "VMOVDQU64 (CX),Z2\n", row.mode == "zero"})
+		}
+		for _, mutation := range mutations {
+			if strings.Count(source, mutation.remove) != 1 {
+				t.Fatal("independent source mutation is not exact", row, mutation.name)
+			}
+			changed := strings.Replace(source, mutation.remove, "", 1)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(row.instruction()+"/"+mutation.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if mutation.valid {
+						if err != nil || ir == "" {
+							t.Fatal("write-only zero-masked destination acquired a false old-value dependency", err)
+						}
+						return
+					}
+					if mutation.name == "copied-upper" || mutation.name == "old-destination" || mutation.name == "active-input" && row.source == "register" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("complete initialized conversion borrowed a revoked active/upper/mask/old/native input", mutation.name, err)
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_precision_raw_identity_test.go b/x86_scalar_precision_raw_identity_test.go
new file mode 100644
index 000000000..ac99c419a
--- /dev/null
+++ b/x86_scalar_precision_raw_identity_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86ScalarPrecisionRawCase struct {
+	row        x86ScalarPrecisionOracleRow
+	code       []byte
+	generation string
+}
+
+func x86ScalarPrecisionRawCases() []x86ScalarPrecisionRawCase {
+	var cases []x86ScalarPrecisionRawCase
+	for _, spec := range rawScalarPrecisionConvertSpecs {
+		for _, generation := range []string{"legacy", "VEX", "EVEX"} {
+			for _, memory := range []bool{false, true} {
+				row := x86ScalarPrecisionOracleRow{op: string(spec.legacy), input: spec.inputBytes,
+					output: 12 - spec.inputBytes, source: "register"}
+				code := encodeX86RawLegacyScalarPrecisionConvert(spec, 0, 2)
+				if generation != "legacy" {
+					row.op, row.vector, row.mode = string(spec.vector), true, "plain"
+					code = encodeX86RawVEXScalarPrecisionConvert(spec, 0, 1, 2)
+				}
+				if generation == "EVEX" {
+					code = encodeX86RawEVEXScalarPrecisionConvert(spec, -1, 0, false, 0, 1, 2)
+				}
+				if memory {
+					row.source, code[len(code)-1] = "native", 0x10 // Exact (AX), not a fabricated FP backing.
+				}
+				cases = append(cases, x86ScalarPrecisionRawCase{row, code, generation})
+			}
+		}
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			controls := []int{-1, 0}
+			if spec.inputBytes == 8 {
+				controls = []int{-1, 0, 1, 2, 3}
+			}
+			for _, control := range controls {
+				for _, memory := range []bool{false, true} {
+					if mode == "plain" && control < 0 || memory && control >= 0 {
+						continue // Already listed, or absent from the physical ISA.
+					}
+					row := x86ScalarPrecisionOracleRow{op: string(spec.vector), input: spec.inputBytes,
+						output: 12 - spec.inputBytes, source: "register", vector: true, mode: mode}
+					mask := 0
+					if mode != "plain" {
+						mask = 1
+					}
+					if control >= 0 {
+						row.control = "SAE"
+						if spec.inputBytes == 8 {
+							row.control = []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"}[control]
+						}
+					}
+					code := encodeX86RawEVEXScalarPrecisionConvert(spec, control, mask, mode == "zero", 0, 1, 2)
+					if memory {
+						row.source, code[len(code)-1] = "native", 0x10
+					}
+					cases = append(cases, x86ScalarPrecisionRawCase{row, code, "EVEX"})
+				}
+			}
+		}
+	}
+	return cases
+}
+
+func x86ScalarPrecisionRawRegisterSource(name string, row x86ScalarPrecisionRawCase) string {
+	source := "TEXT ·" + name + "(SB),4,$0-0\nXORPS X0,X0\nXORPS X1,X1\nXORPS X2,X2\n"
+	if row.row.mode == "merge" || row.row.mode == "zero" {
+		source += "MOVL $1,AX\nKMOVD AX,K1\n"
+	}
+	return source + x86RawDisplacementDirectives(row.code) + "RET\n"
+}
+
+func TestX86ScalarPrecisionRawGenerationAndWholeSourceIdentity(t *testing.T) {
+	rows := x86ScalarPrecisionRawCases()
+	if len(rows) != 35 {
+		t.Fatal("complete independent low-bank physical precision directory changed", len(rows))
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for index, row := range rows {
+			if row.row.source != "register" || arch == "386" && (row.row.mode == "merge" || row.row.mode == "zero") {
+				continue // Native pointers and Go's mode32 mask cap are independent scopes.
+			}
+			name := fmt.Sprint("RawPrecision", index)
+			t.Run(arch+"/"+row.generation+"/"+row.row.instruction(), func(t *testing.T) {
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, x86ScalarPrecisionRawRegisterSource(name, row)), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				function := file.Funcs[0]
+				ordinal := len(function.Instrs) - 2
+				instruction := function.Instrs[ordinal]
+				check := func(function Func, targetArch string) error {
+					triple := "x86_64-unknown-linux-gnu"
+					if targetArch == "386" {
+						triple = "i386-unknown-linux-gnu"
+					}
+					consumer := newX86Ctx(new(strings.Builder), function, FuncSig{Name: name, Ret: Void}, nil, nil, targetArch, triple, false)
+					return consumer.checkLoweredScalarFPResultInitialization()
+				}
+				namedSource := strings.Replace(x86ScalarPrecisionRawRegisterSource(name, row),
+					x86RawDisplacementDirectives(row.code), row.row.instruction()+"\n", 1)
+				named := mustParseX86RawReturn(t, namedSource)
+				if named.Funcs[0].x86RawReplay != nil || check(named.Funcs[0], arch) != nil {
+					t.Fatal("physical-origin negative rejected the independently initialized named control")
+				}
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}})
+				if strings.Contains(features, "+avx512f") != (row.generation == "EVEX") {
+					t.Fatal("isolated native instruction lost its physical EVEX generation", row.generation, features)
+				}
+				if err := check(function, arch); err != nil {
+					t.Fatal("actual initialized whole-source raw conversion lost its paired native continuation", err)
+				}
+				for _, mutation := range []struct {
+					name string
+					edit func(*Func)
+				}{
+					{"missing replay", func(fn *Func) { fn.x86RawReplay = nil }},
+					{"producer changed", func(fn *Func) { fn.Instrs[1].Raw += " " }},
+					{"origin only", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw = nil }},
+					{"encoded only", func(fn *Func) { fn.Instrs[ordinal].x86Encoded = false }},
+					{"physical generation", func(fn *Func) {
+						fn.Instrs[ordinal].x86ScalarPrecisionEVEX = !fn.Instrs[ordinal].x86ScalarPrecisionEVEX
+					}},
+					{"snapshot generation", func(fn *Func) {
+						origin := fn.Instrs[ordinal].x86SourceRaw
+						origin.scalarPrecision.evex = !origin.scalarPrecision.evex
+					}},
+					{"snapshot mode", func(fn *Func) { fn.Instrs[ordinal].x86SourceRaw.scalarPrecision.arch = "arm64" }},
+					{"missing snapshot", func(fn *Func) {
+						fn.Instrs[ordinal].x86SourceRaw.scalarPrecision = x86RawScalarPrecisionIdentity{}
+					}},
+					{"named laundering", func(fn *Func) {
+						fn.Instrs[ordinal].x86Encoded, fn.Instrs[ordinal].x86SourceRaw = false, nil
+					}},
+					{"physical width", func(fn *Func) { fn.Instrs[ordinal].x86VectorBytes = 32 }},
+					{"physical address", func(fn *Func) { fn.Instrs[ordinal].x86AddressBits = 32 }},
+					{"operand", func(fn *Func) { fn.Instrs[ordinal].Args[0].Reg = "X3" }},
+				} {
+					changed := function
+					changed.Instrs = cloneX86ReplayInstrs(function.Instrs)
+					mutation.edit(&changed)
+					if err := check(changed, arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("mutable origin or changed complete source acquired raw native rights", mutation.name, err)
+					}
+				}
+				foreign := "386"
+				if arch == "386" {
+					foreign = "amd64"
+				}
+				if err := check(function, foreign); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("same low banks borrowed a different source architecture", err)
+				}
+				if err := function.x86RawReplay.validate(function, arch); err != nil {
+					t.Fatal("negative clone mutated original complete-source identity", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarPrecisionRawInitializedGenerationThreeAPIObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete raw scalar precision objects require LLVM22")
+	}
+	var source, declarations strings.Builder
+	functions, generations := make(map[string][]string), make(map[string]bool)
+	for index, row := range x86ScalarPrecisionRawCases() {
+		body, declaration, name := x86ScalarPrecisionInitializedProgram(index, row.row)
+		if strings.Count(body, row.row.instruction()+"\n") != 1 {
+			t.Fatal("raw encoding must replace exactly its independently typed original instruction", index)
+		}
+		source.WriteString(strings.Replace(body, row.row.instruction()+"\n", x86RawDisplacementDirectives(row.code), 1))
+		declarations.WriteString(declaration)
+		functions[name], generations[name] = []string{row.row.op}, row.generation == "EVEX"
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil {
+						t.Fatal("complete initialized physical conversion lost its actual native owner", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, text, functions)
+						context := llvm.NewContext()
+						module, err := parseIRModuleInContext(context, text)
+						if err != nil {
+							if !module.IsNil() {
+								module.Dispose()
+							}
+							context.Dispose()
+							t.Fatal(err)
+						}
+						for name, evex := range generations {
+							body := module.NamedFunction(name).String()
+							if strings.Contains(body, "{evex}") != evex {
+								module.Dispose()
+								context.Dispose()
+								t.Fatal("actual function replaced its original physical encoding generation", name, evex, body)
+							}
+						}
+						module.Dispose()
+						context.Dispose()
+						compileLLVMToObject(t, llc, triple, "raw-precision-generation.ll", "raw-precision-generation.o", text)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_scalar_precision_raw_inputs_test.go b/x86_scalar_precision_raw_inputs_test.go
new file mode 100644
index 000000000..7810d65f8
--- /dev/null
+++ b/x86_scalar_precision_raw_inputs_test.go
@@ -0,0 +1,72 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestX86ScalarPrecisionRawPairedInputsAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for index, row := range x86ScalarPrecisionRawCases() {
+			if arch == "386" && (row.row.mode == "merge" || row.row.mode == "zero") {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%d/%s", arch, index, row.row.instruction()), func(t *testing.T) {
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t,
+					"TEXT ·RawInputs(SB),4,$0-0\n"+x86RawDisplacementDirectives(row.code)+"RET\n"), arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				instruction := file.Funcs[0].Instrs[1]
+				if !x86RawScalarPrecisionSource(instruction, arch) {
+					t.Fatal("physical conversion lost its exact typed source identity")
+				}
+				for _, missing := range []string{"none", "input", "upper", "old", "mask", "pointer"} {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+						masks: [8]bool{1: true}}
+					for register := 0; register < 3; register++ {
+						state.writeVector(register, 64, ^uint64(0), true)
+					}
+					state.pointerGP[0], state.callerAddressGP[0] = true, true
+					source, upper, destination := row.row.registers()
+					valid := true
+					switch missing {
+					case "input":
+						state.writeVector(source, 64, ^x86CallerVectorByteMask(int64(row.row.input)), true)
+						valid = row.row.source == "native"
+					case "upper":
+						state.writeVector(upper, 64, x86CallerVectorByteMask(int64(row.row.output)), true)
+					case "old":
+						state.writeVector(destination, 64, ^x86CallerVectorByteMask(int64(row.row.output)), true)
+						valid = row.row.mode != "merge"
+					case "mask":
+						state.masks[1] = false
+						valid = row.row.mode != "merge" && row.row.mode != "zero"
+					case "pointer":
+						state.pointerGP[0] = false
+						valid = row.row.source != "native"
+					}
+					before, expected := state.clone(), state.clone()
+					if valid {
+						output := x86CallerVectorByteMask(int64(row.row.output))
+						expected.writeVector(destination, 16, output|state.vectorBytes(upper)&(0xffff&^output), !row.row.vector)
+					}
+					standalone := state.clone()
+					if accepted, known := x86ResultScalarPrecisionStep(instruction, &standalone, nil, arch, false); accepted || !known || !reflect.DeepEqual(standalone, before) {
+						t.Fatal("raw source identity granted standalone numerical authority", missing)
+					}
+					accepted, known := x86ResultScalarPrecisionStep(instruction, &state, nil, arch, true)
+					if !known || accepted != valid || !reflect.DeepEqual(state, expected) {
+						t.Fatal("paired raw conversion lost active/merge/K/native inputs or fabricated copied upper bytes", missing, accepted, valid)
+					}
+					if x86ResultCallerAddressesAfter(instruction, before.callerAddressGP, nil, arch) != before.callerAddressGP ||
+						x86ResultDirectionAfterSource(instruction, before.direction, arch) != before.direction ||
+						!x86ResultPreservesPrivateStorage(instruction, arch) {
+						t.Fatal("exact conversion discarded unrelated GP/DF/private state")
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_reciprocal_boundary_test.go b/x86_scalar_reciprocal_boundary_test.go
new file mode 100644
index 000000000..e50662402
--- /dev/null
+++ b/x86_scalar_reciprocal_boundary_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86ScalarReciprocalNativeAccessAndExactSourceIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarReciprocalOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				args := "(AX),X2"
+				if row.vector {
+					args = "(AX),X1,X2"
+				}
+				ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+				initial := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				initial.xmm[1], initial.xmm[2] = 0xffff, 0xffff
+				initial.pointerGP[0] = true
+				state := initial.clone()
+				if accepted, known := x86ResultScalarReciprocalStep(ins, &state, nil, arch, false); !known || accepted || !reflect.DeepEqual(state, initial) {
+					t.Fatal("native m32 was invented by the numerical domain", accepted, known, state)
+				}
+				if accepted, known := x86ResultScalarReciprocalStep(ins, &state, nil, arch, true); !known || !accepted {
+					t.Fatal("exact m32 native continuation was not available", accepted, known)
+				}
+				expected := initial.clone()
+				expected.xmm[2], expected.vectorUpper[2] = state.xmm[2], state.vectorUpper[2]
+				if !reflect.DeepEqual(state, expected) {
+					t.Fatal("scalar estimate supplied a storage, pointer, FLAGS or frame fact", state)
+				}
+				missing := initial.clone()
+				missing.pointerGP[0] = false
+				before := missing.clone()
+				if accepted, _ := x86ResultScalarReciprocalStep(ins, &missing, nil, arch, true); accepted || !reflect.DeepEqual(missing, before) {
+					t.Fatal("dead native input became optional", missing)
+				}
+
+				code := []byte{0xf3, 0x0f, row.opcode, 0x10}
+				if row.vector {
+					code = []byte{0xc4, 0xe1, 0x72, row.opcode, 0x10}
+				}
+				mode := 64
+				if arch == "386" {
+					mode = 32
+				}
+				raw, _, recognized, err := decodedX86RawScalarReciprocalInstruction(code, mode)
+				if !recognized || err != nil {
+					t.Fatal("complete raw scalar estimate row missing", err)
+				}
+				raw.x86Encoded = true
+				raw.x86SourceRaw = &x86SourceRawInstruction{
+					op: raw.Op, args: append([]Operand(nil), raw.Args...),
+				}
+				if !x86RawScalarReciprocalSource(raw, arch) {
+					t.Fatal("exact sealed source was not recognized")
+				}
+				state = initial.clone()
+				if accepted, known := x86ResultScalarReciprocalStep(raw, &state, nil, arch, true); !known || !accepted {
+					t.Fatal("sealed original m32 could not retain its native continuation")
+				}
+				for _, mutate := range []func(*Instr){
+					func(ins *Instr) { ins.x86SourceRaw = nil },
+					func(ins *Instr) { ins.x86VectorBytes = 32 },
+					func(ins *Instr) { ins.x86AddressBits = 32 },
+					func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+					func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+					func(ins *Instr) { ins.Args[0].Mem.Off = 4 },
+					func(ins *Instr) { ins.Args[len(ins.Args)-1].Reg = "X3" },
+				} {
+					changed := raw
+					changed.Args = append([]Operand(nil), raw.Args...)
+					mutate(&changed)
+					state = initial.clone()
+					if x86RawScalarReciprocalSource(changed, arch) {
+						t.Fatal("changed complete raw identity was authorized", changed)
+					}
+					if accepted, _ := x86ResultScalarReciprocalStep(changed, &state, nil, arch, true); accepted || !reflect.DeepEqual(state, initial) {
+						t.Fatal("changed source mutated state or borrowed native inputs", changed, state)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_reciprocal_effect_test.go b/x86_scalar_reciprocal_effect_test.go
new file mode 100644
index 000000000..9252e158a
--- /dev/null
+++ b/x86_scalar_reciprocal_effect_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent complete estimate family; RCP14/28 are different ISA classes.
+var x86ScalarReciprocalOracle = []struct {
+	op     string
+	opcode byte
+	vector bool
+}{
+	{"RCPSS", 0x53, false}, {"RSQRTSS", 0x52, false},
+	{"VRCPSS", 0x53, true}, {"VRSQRTSS", 0x52, true},
+}
+
+func TestX86ScalarReciprocalCompleteIndependentGoRowsAndTypedEffects(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(legacy), "var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}},\n}") {
+		t.Fatal("complete legacy reciprocal input grammar changed")
+	}
+	for _, row := range x86ScalarReciprocalOracle[:2] {
+		if want := fmt.Sprintf("{A%s, yxm, Pf3, opBytes{0x%02x}}", row.op, row.opcode); !strings.Contains(string(legacy), want) {
+			t.Fatal("independent legacy reciprocal opcode/prefix changed", want)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	for _, rule := range rules {
+		if rule.Opcode != "VRCPSS" && rule.Opcode != "VRSQRTSS" {
+			continue
+		}
+		counts[rule.Opcode]++
+		code := "0x53"
+		if rule.Opcode == "VRSQRTSS" {
+			code = "0x52"
+		}
+		if rule.RowIndex != 0 || rule.Ytab != "_yvrcpss" || rule.Prefix != "Pavx" ||
+			rule.ZCase != "Zvex_rm_v_r" || rule.ZOffset != 2 || rule.EncodingOffset != 0 ||
+			strings.Join(rule.Classes, ",") != "Yxm,Yxr,Yxr" ||
+			!reflect.DeepEqual(rule.OpBytes, []string{"avxEscape | vex128 | vexF3 | vex0F | vexW0", code}) {
+			t.Fatal("complete independent VEX reciprocal row changed", rule)
+		}
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VRCPSS": 1, "VRSQRTSS": 1}) {
+		t.Fatal("scalar reciprocal has no EVEX, mask or packed-width row", counts)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarReciprocalOracle {
+			for _, source := range []string{"X0", "value+0(FP)", "(AX)"} {
+				t.Run(arch+"/"+row.op+"/"+source, func(t *testing.T) {
+					args := source + ",X2"
+					if row.vector {
+						args = source + ",X1,X2"
+					}
+					ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || !effect.requiresResultProof || effect.dynamicMemory ||
+						effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 || len(effect.operands) != len(ins.Args) {
+						t.Fatal("complete scalar reciprocal typed source/upper/write effect missing", effect, known, err)
+					}
+					for index, operand := range effect.operands {
+						width := int64(16)
+						if index == 0 {
+							width = 4
+						}
+						if operand.index != index || !reflect.DeepEqual(operand.operand, ins.Args[index]) || operand.width != width ||
+							operand.read != (index < len(ins.Args)-1 || !row.vector) || operand.write != (index == len(ins.Args)-1) {
+							t.Fatal("scalar source width or independent upper-half role changed", operand)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarReciprocalSelectedBytesUpperAliasesAndUnrelatedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarReciprocalOracle {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				args, base := "X0,X2", 2
+				if row.vector {
+					args, base = "X0,X1,X2", 1
+				}
+				ins := x86ScalarLaneInstruction(t, row.op+" "+args)
+				for sourceMissing := -1; sourceMissing < 16; sourceMissing++ {
+					for upperMissing := -1; upperMissing < 16; upperMissing++ {
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.xmm[0], state.xmm[base], state.vectorUpper[2] = 0xffff, 0xffff, 0x55aa00ffff000000
+						state.pointerGP[7], state.masks[1] = true, true
+						if sourceMissing >= 0 {
+							state.xmm[0] &^= 1 << uint(sourceMissing)
+						}
+						if upperMissing >= 0 {
+							state.xmm[base] &^= 1 << uint(upperMissing)
+						}
+						before, want := state.clone(), state.clone()
+						computed := uint16(0xf)
+						if sourceMissing >= 0 && sourceMissing < 4 {
+							computed = 0 // Unknown scalar stays unknown, never an implementation zero.
+						}
+						want.xmm[2] = state.xmm[base]&0xfff0 | computed
+						if row.vector {
+							want.vectorUpper[2] = ^uint64(0xffff)
+						}
+						if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+							t.Fatal("scalar estimate invented numerical input/upper bytes or altered FLAGS/DF/storage", sourceMissing, upperMissing, before, state, want)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarReciprocalInitializedPublicInputsAndMXCSRSource(t *testing.T) {
+	for _, row := range x86ScalarReciprocalOracle {
+		for _, memory := range []bool{false, true} {
+			t.Run(fmt.Sprint(row.op, "/memory=", memory), func(t *testing.T) {
+				scalar, load := "(AX)", ""
+				if !memory {
+					scalar, load = "X0", "MOVSS (AX),X0\n"
+				}
+				args, destination := scalar+",X1", "X1"
+				if row.vector {
+					args, destination = scalar+",X1,X2", "X2"
+				}
+				source := "TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ p+8(FP),AX\nMOVQ upper+16(FP),BX\n" +
+					"MOVUPS (BX),X1\nSTC\n" + load + row.op + " " + args + "\nMOVUPS " + destination +
+					",(DI)\nSETCS 16(DI)\nSTMXCSR 20(DI)\nRET\n"
+				declaration := "func Value(out *[24]byte,p *uint32,upper *[16]byte)\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						if _, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil {
+							t.Fatal("valid complete scalar estimate source with observable MXCSR rejected", err)
+						}
+						missing := strings.Replace(source, "MOVQ p+8(FP),AX\n", "", 1)
+						if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar estimate supplied its own native input", err)
+						}
+						missing = strings.Replace(source, "MOVQ out+0(FP),DI\n", "", 1)
+						if _, err := x86ScalarFPBitViewAPI(t, missing, declaration, "amd64", "x86_64-unknown-linux-gnu", api); !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("scalar estimate supplied its own result/MXCSR destination", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_reciprocal_mode32_test.go b/x86_scalar_reciprocal_mode32_test.go
new file mode 100644
index 000000000..dc2c77a28
--- /dev/null
+++ b/x86_scalar_reciprocal_mode32_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86ScalarReciprocalMode32FrontendAddressHasNoPhysicalPermission(t *testing.T) {
+	for _, op := range []string{"VRCPSS", "VRSQRTSS"} {
+		for _, base := range []string{"R8", "R9", "R10", "R11", "R13", "R14", "R15"} {
+			memory := fmt.Sprintf("16(%s)", base)
+			t.Run(op+"/"+memory, func(t *testing.T) {
+				source := "TEXT f(SB),4,$0-0\n" + op + " " + memory + ",X1,X2\nRET\n"
+				goAssemblerOracleOutput(t, "386", source, "", true)
+				ins := x86ScalarLaneInstruction(t, op+" "+memory+",X1,X2")
+				if _, known, err := x86ScalarReciprocalProperties(ins.Op, ins, "386"); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("Go-accepted VEX address was misclassified as rejected syntax or granted a physical mode32 binding", known, err)
+				}
+				state := x86ResultState{}
+				state.xmm[1], state.xmm[2] = 0xffff, 0xffff
+				for index := range state.gp {
+					state.gp[index], state.pointerGP[index] = 0xff, true
+				}
+				if accepted, known := x86ResultScalarReciprocalStep(ins, &state, nil, "386", true); !known || accepted {
+					t.Fatal("frontend extended address acquired numerical or native permission", accepted, known)
+				}
+			})
+		}
+		for _, memory := range []string{"16(AX)(R9*2)", "16(R9)(CX*2)", "16(R12)"} {
+			t.Run(op+"/rejected-SIB/"+memory, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, op+" "+memory+",X1,X2")
+				if _, known, err := x86ScalarReciprocalProperties(ins.Op, ins, "386"); !known || err == nil || errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("simple VEX base compatibility was incorrectly extended to SIB syntax", known, err)
+				}
+				if memory == "16(R9)(CX*2)" {
+					x86ReciprocalSIBOriginalGoRejection(t, "386", "TEXT f(SB),4,$0-0\n"+ins.Raw+"\nRET\n")
+				} else if memory == "16(AX)(R9*2)" {
+					// Actual Go 1.27 emitted this positionless stderr in the
+					// original RED, but the independent diagnostic join did not
+					// bind it to the complete source. Retain the observation,
+					// not a fabricated source-rejection certificate.
+					t.Log("prior actual Go stderr: asm: asmidx: bad address 2/R9/AX; asm: assembly failed; unbound diagnostic, no source-rejection claim")
+				} else {
+					// Even without an explicit index, R12 requires SIB. Go's
+					// asmidx source rejects its extended mode32 base; do not
+					// invent a concrete tool diagnostic that was not observed.
+					t.Log("R12 uses the independently inspected asmidx SIB source route, not the non-SIB frontend compatibility class")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_reciprocal_native_driver_test.go b/x86_scalar_reciprocal_native_driver_test.go
new file mode 100644
index 000000000..293d661a6
--- /dev/null
+++ b/x86_scalar_reciprocal_native_driver_test.go
@@ -0,0 +1,225 @@
+package plan9asm
+
+// The C reference executes the actual scalar opcode, then separately checks
+// IEEE special classes and Intel's 1.5*2^-12 relative error bound. It is not a
+// packed estimate, exact division/sqrt implementation, or translator helper.
+const x86ScalarReciprocalNativeValuesC = `
+#include <float.h>
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <xmmintrin.h>
+%s
+struct kernel {
+    void (*run)(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint32_t);
+    int kind,source,base,dst;
+};
+static const struct kernel kernels[]={%s};
+static const uint32_t patterns[]={
+    0x00000000,0x80000000,0x7f800000,0xff800000,
+    0x00000001,0x80000001,0x007fffff,0x807fffff,
+    0x00800000,0x80800000,0x3f800000,0xbf800000,
+    0x40800000,0xc0800000,0x3f123456,0xbf123456,
+    0x7f7fffff,0xff7fffff,0x7e800000,0xfe800000,
+    0x7fc12345,0xffc12345,0x7f812345,0xff812345,
+};
+static uint32_t reference(unsigned kind,uint32_t bits) {
+    float source,result;
+    memcpy(&source,&bits,4);
+    switch (kind) {
+    case 0: __asm__ volatile("rcpss %%1,%%0":"=x"(result):"x"(source));break;
+    case 1: __asm__ volatile("rsqrtss %%1,%%0":"=x"(result):"x"(source));break;
+    case 2: __asm__ volatile("vrcpss %%1,%%1,%%0":"=x"(result):"x"(source));break;
+    default: __asm__ volatile("vrsqrtss %%1,%%1,%%0":"=x"(result):"x"(source));break;
+    }
+    memcpy(&bits,&result,4);
+    return bits;
+}
+static int valid_estimate(unsigned kind,uint32_t input,uint32_t output) {
+    uint32_t magnitude=input&0x7fffffff,sign=input&0x80000000;
+    unsigned exponent=magnitude>>23;
+    if (!exponent) return output==(sign|0x7f800000);
+    if (magnitude>0x7f800000) return (output&0x7fc00000)==0x7fc00000;
+    if ((kind&1) && sign) return output==0xffc00000;
+    if (magnitude==0x7f800000) return output==sign;
+    float source,result;
+    memcpy(&source,&input,4);memcpy(&result,&output,4);
+    double expected=(kind&1)?1.0/sqrt((double)source):1.0/(double)source;
+    const double bound=1.5/4096.0;
+    if (!(output&0x7fffffff))
+        return !(kind&1) && (output&0x80000000)==sign && fabs(expected)<=FLT_MIN/(1.0-bound);
+    if (!(output&0x7f800000) || (output&0x7f800000)==0x7f800000) return 0;
+    return fabs(((double)result-expected)/expected)<=bound;
+}
+int main(void) {
+    unsigned count=0,saved=_mm_getcsr();
+    _mm_setcsr(0x1f80);
+    for (unsigned row=0;row<sizeof(kernels)/sizeof(kernels[0]);row++) {
+        struct kernel k=kernels[row];
+        for (unsigned sample=0;sample<24;sample++) for (unsigned control=0;control<64;control++) {
+            uint8_t storage[64],upper[32],old[32],out[64],expected[64],registers[3][32];
+            uint8_t *input=storage+sample%%16;
+            for (unsigned i=0;i<sizeof(storage);i++) storage[i]=(uint8_t)(i*19+sample*31+0xa5);
+            for (unsigned i=0;i<32;i++) {
+                upper[i]=(uint8_t)(i*43+sample*13+0x5a);
+                old[i]=(uint8_t)(i*53+sample*17+0x69);
+            }
+            uint32_t bits=patterns[sample];memcpy(input,&bits,4);
+            uint8_t beforeStorage[64],beforeUpper[32],beforeOld[32];
+            memcpy(beforeStorage,storage,64);memcpy(beforeUpper,upper,32);memcpy(beforeOld,old,32);
+            memcpy(registers[0],input,32);memcpy(registers[1],upper,32);memcpy(registers[2],old,32);
+            if (k.source>=0) {
+                memcpy(registers[k.source],&bits,4);
+                memset(registers[k.source]+4,0,12); // Actual legacy MOVSS m32 setup.
+            }
+            memset(out,0xc3,64);memset(expected,0xc3,64);
+            memcpy(expected+8,registers[k.dst],32);
+            memcpy(expected+12,registers[k.base]+4,12);
+            if (k.kind>=2) memset(expected+24,0,16);
+            uint32_t scalar=reference(k.kind,bits),flags=0xc95,ambient=0x1f80;
+            memcpy(expected+8,&scalar,4);memcpy(expected+40,&ambient,4);memcpy(expected+44,&flags,4);
+            uint32_t profile=((control&3)<<13)|((control&4)<<4)|((control&8)<<12)|
+                ((control&16)?0x3f:0)|((control&32)?0x1f80:0);
+            memcpy(expected+48,&profile,4);
+            _mm_setcsr(ambient);
+            k.run(out,input,upper,old,profile);
+            unsigned after=_mm_getcsr();_mm_setcsr(ambient);
+            if (memcmp(out,expected,64) || after!=ambient || memcmp(storage,beforeStorage,64) ||
+                    memcmp(upper,beforeUpper,32) || memcmp(old,beforeOld,32) || !valid_estimate(k.kind,bits,scalar)) {
+                fprintf(stderr,"scalar estimate row=%%u sample=%%u control=%%u MXCSR=%%x expected=%%x scalar=%%x\n",
+                    row,sample,control,after,ambient,scalar);
+                for (unsigned i=0;i<64;i++) if (out[i]!=expected[i])
+                    fprintf(stderr,"byte %%u got %%02x want %%02x\n",i,out[i],expected[i]);
+                _mm_setcsr(saved);
+                return 1;
+            }
+            count++;
+        }
+    }
+    _mm_setcsr(saved);
+    printf("scalar estimates whole32/FLAGS/DF/MXCSR/canary outcomes %%u failures 0\n",count);
+    return 0;
+}
+`
+
+const x86ScalarReciprocalNativeOriginalGo = `package oracle
+import (
+    "encoding/binary"
+    "math"
+    "runtime"
+    "testing"
+    "unsafe"
+)
+type kernel struct {
+    run func(*[64]byte,*[32]byte,*[32]byte,*[32]byte,uint32)
+    kind,source,base,dst int
+}
+var kernels=[]kernel{%s}
+var references=[]func(uint32)uint32{Reference0,Reference1,Reference2,Reference3}
+func validEstimate(kind int,input,output uint32) bool {
+    sign,magnitude:=input&0x80000000,input&0x7fffffff
+    switch {
+    case magnitude<0x00800000:
+        return output==sign|0x7f800000
+    case magnitude>0x7f800000:
+        return output&0x7fc00000==0x7fc00000
+    case kind&1!=0 && sign!=0:
+        return output==0xffc00000
+    case magnitude==0x7f800000:
+        return output==sign
+    }
+    inputValue:=float64(math.Float32frombits(input))
+    expected:=1/inputValue
+    if kind&1!=0 {expected=1/math.Sqrt(inputValue)}
+    const bound=1.5/4096
+    if output&0x7fffffff==0 {
+        return kind&1==0 && output&0x80000000==sign && math.Abs(expected)<=0x1p-126/(1-bound)
+    }
+    if output&0x7f800000==0 || output&0x7f800000==0x7f800000 {return false}
+    return math.Abs((float64(math.Float32frombits(output))-expected)/expected)<=bound
+}
+func TestOriginal(t *testing.T) {
+    runtime.LockOSThread();defer runtime.UnlockOSThread()
+    saved:=MXCSR(0x1f80);defer MXCSR(saved)
+    patterns:=[]uint32{
+        0x00000000,0x80000000,0x7f800000,0xff800000,
+        0x00000001,0x80000001,0x007fffff,0x807fffff,
+        0x00800000,0x80800000,0x3f800000,0xbf800000,
+        0x40800000,0xc0800000,0x3f123456,0xbf123456,
+        0x7f7fffff,0xff7fffff,0x7e800000,0xfe800000,
+        0x7fc12345,0xffc12345,0x7f812345,0xff812345,
+    }
+    count:=0
+    for row,k:=range kernels {
+        for sample,bits:=range patterns {for control:=uint32(0);control<64;control++ {
+            var storage [64]byte
+            var upper,old [32]byte
+            for i:=range storage {storage[i]=byte(i*19+sample*31+0xa5)}
+            for i:=range upper {upper[i]=byte(i*43+sample*13+0x5a);old[i]=byte(i*53+sample*17+0x69)}
+            input:=(*[32]byte)(unsafe.Pointer(&storage[sample%%16]))
+            binary.LittleEndian.PutUint32(input[:],bits)
+            beforeStorage,beforeUpper,beforeOld:=storage,upper,old
+            registers:=[3][32]byte{*input,upper,old}
+            if k.source>=0 {
+                binary.LittleEndian.PutUint32(registers[k.source][:],bits)
+                for i:=4;i<16;i++ {registers[k.source][i]=0}
+            }
+            var out,expected [64]byte
+            for i:=range out {out[i],expected[i]=0xc3,0xc3}
+            copy(expected[8:40],registers[k.dst][:])
+            copy(expected[12:24],registers[k.base][4:16])
+            if k.kind>=2 {for i:=24;i<40;i++ {expected[i]=0}}
+            MXCSR(0x1f80)
+            scalar:=references[k.kind](bits)
+            binary.LittleEndian.PutUint32(expected[8:],scalar)
+            binary.LittleEndian.PutUint32(expected[40:],0x1f80)
+            binary.LittleEndian.PutUint32(expected[44:],0xc95)
+            profile:=(control&3)<<13|(control&4)<<4|(control&8)<<12
+            if control&16!=0 {profile|=0x3f}
+            if control&32!=0 {profile|=0x1f80}
+            binary.LittleEndian.PutUint32(expected[48:],profile)
+            MXCSR(0x1f80)
+            k.run(&out,input,&upper,&old,profile)
+            after:=MXCSR(0x1f80)
+            if out!=expected || after!=0x1f80 || storage!=beforeStorage || upper!=beforeUpper || old!=beforeOld ||
+                    !validEstimate(k.kind,bits,scalar) {
+                t.Fatalf("actual Go scalar row=%%d sample=%%d control=%%x got=%%x want=%%x MXCSR=%%x scalar=%%x",
+                    row,sample,control,out,expected,after,scalar)
+            }
+            count++
+        }}
+    }
+    if len(kernels)!=20 || count!=30720 {t.Fatal("incomplete original scalar basis",len(kernels),count)}
+    t.Logf("actual original Go scalar whole32/FLAGS/DF/MXCSR/canary outcomes %%d failures 0",count)
+}
+`
+
+const x86ScalarReciprocalNativeFaultsC = `
+static void (*const kernels[])(const uint8_t *)={Dead0,Dead1,Dead2,Dead3};
+int main(int argc,char **argv) {
+    unsigned row,probe,original;char tail;
+    if (argc!=4 || sscanf(argv[1],"%u%c",&row,&tail)!=1 ||
+            sscanf(argv[2],"%u%c",&probe,&tail)!=1 || sscanf(argv[3],"%u%c",&original,&tail)!=1 ||
+            row>=4 || probe>=5 || original>1) return 80;
+    if (memory_fault_setup(0)) return 81;
+    const uint8_t *input=NULL;
+    if (probe==1) input=guard+page-3;
+    else if (probe==2 || probe==3) input=guard+page-4;
+    else if (probe==4) input=guard+1;
+    if (probe==3 && mprotect(guard,page,PROT_READ)) return 82;
+    printf("memory enter %u %u %u\n",row,probe,original);
+    if (fflush(stdout)) return 83;
+    if (original) {
+        switch (row) {
+        case 0: __asm__ volatile("rcpss (%0),%%xmm0"::"r"(input):"xmm0","memory");break;
+        case 1: __asm__ volatile("rsqrtss (%0),%%xmm0"::"r"(input):"xmm0","memory");break;
+        case 2: __asm__ volatile("vrcpss (%0),%%xmm0,%%xmm0"::"r"(input):"xmm0","memory");break;
+        case 3: __asm__ volatile("vrsqrtss (%0),%%xmm0,%%xmm0"::"r"(input):"xmm0","memory");break;
+        }
+    } else kernels[row](input);
+    if (free_guard()) return 84;
+    puts("memory complete");
+    return fflush(stdout)?85:0;
+}
+`
diff --git a/x86_scalar_reciprocal_native_linux_amd64_test.go b/x86_scalar_reciprocal_native_linux_amd64_test.go
new file mode 100644
index 000000000..1f18368b4
--- /dev/null
+++ b/x86_scalar_reciprocal_native_linux_amd64_test.go
@@ -0,0 +1,28 @@
+package plan9asm
+
+import (
+	"os/exec"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNativeAMD64(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	execution.requireAVX(t)
+	x86RunScalarReciprocalNative(t, execution, "amd64")
+	x87IA32RequireNativeHost(t)
+}
+
+func TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNative386(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc := findLLVM22Tool("llc")
+	compiler, err := exec.LookPath("i686-linux-gnu-gcc")
+	if llc == "" || err != nil {
+		t.Fatalf("required native mode32 scalar estimate tools: LLVM22=%q compiler=%v", llc, err)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie", "-msse2"}}
+	execution.requireAVX(t)
+	x86RunScalarReciprocalNative(t, execution, "386")
+	x87IA32RequireNativeHost(t)
+}
diff --git a/x86_scalar_reciprocal_native_policy_test.go b/x86_scalar_reciprocal_native_policy_test.go
new file mode 100644
index 000000000..716b94a1b
--- /dev/null
+++ b/x86_scalar_reciprocal_native_policy_test.go
@@ -0,0 +1,75 @@
+package plan9asm
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"testing"
+)
+
+func TestX86ScalarReciprocalNativeCommandsRetainExactOwnedHelpers(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_scalar_reciprocal_native_runtime_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	required := map[string]int{
+		"goAssemblerOracleOutput": 1, "x86ScalarFPBitViewAPI": 1, "x86DwordProductIROptimize": 1,
+		"execution.compileLLVM": 2, "execution.run": 1, "x87IA32RunDirect": 1,
+		"x86NativeOracleIA32Executable": 2, "x86ObserveMemoryFault": 1, "x86RunOriginalGoNativeSource": 1,
+	}
+	if err := x86CheckHalfIndirectCommandOwner(file, "x86RunScalarReciprocalNative", required); err != nil {
+		t.Fatal(err)
+	}
+	for name := range required {
+		changed := make(map[string]int)
+		for name, count := range required {
+			changed[name] = count
+		}
+		changed[name]++
+		if err := x86CheckHalfIndirectCommandOwner(file, "x86RunScalarReciprocalNative", changed); err == nil {
+			t.Fatal("policy accepted a missing or duplicate bounded execution edge", name)
+		}
+	}
+
+	// Linux-only roots are parsed even on ARM64 developer hosts. In particular,
+	// a valid Go object or a cross-process emulator cannot replace actual native
+	// host bracketing and the AVX OS-state permission probe.
+	file, err = parser.ParseFile(token.NewFileSet(), "x86_scalar_reciprocal_native_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, suffix := range []string{"AMD64", "386"} {
+		root := "TestCrossLinuxRuntimeMatrixX86ScalarReciprocalOriginalGoAndNative" + suffix
+		var observed = make(map[string]int)
+		for _, declaration := range file.Decls {
+			function, ok := declaration.(*ast.FuncDecl)
+			if !ok || function.Name.Name != root {
+				continue
+			}
+			ast.Inspect(function.Body, func(node ast.Node) bool {
+				call, ok := node.(*ast.CallExpr)
+				if !ok {
+					return true
+				}
+				if name, ok := call.Fun.(*ast.Ident); ok {
+					observed[name.Name]++
+				} else if method, ok := call.Fun.(*ast.SelectorExpr); ok {
+					if receiver, ok := method.X.(*ast.Ident); ok {
+						observed[receiver.Name+"."+method.Sel.Name]++
+					}
+				}
+				return true
+			})
+		}
+		expected := map[string]int{"x87IA32RequireNativeHost": 2, "execution.requireAVX": 1, "x86RunScalarReciprocalNative": 1}
+		if suffix == "AMD64" {
+			expected["x86FloatCompareExecutionTools"] = 1
+		} else {
+			expected["findLLVM22Tool"], expected["exec.LookPath"], expected["t.Fatalf"] = 1, 1, 1
+		}
+		if !reflect.DeepEqual(observed, expected) {
+			t.Fatal("native owner lost exact host/tool/preflight/bounded driver edges", root, observed, expected)
+		}
+	}
+}
diff --git a/x86_scalar_reciprocal_native_runtime_test.go b/x86_scalar_reciprocal_native_runtime_test.go
new file mode 100644
index 000000000..9f21c43d4
--- /dev/null
+++ b/x86_scalar_reciprocal_native_runtime_test.go
@@ -0,0 +1,245 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/parser"
+	"go/token"
+	"os"
+	"strings"
+	"testing"
+)
+
+// This is an independent finite alias basis, not a list obtained from the
+// production grammar: five set partitions of three VEX operands, both memory
+// base/destination relations, and both legacy register relations plus m32.
+type x86ScalarReciprocalNativeRow struct {
+	name, op          string
+	source, base, dst int
+	kind              int
+	memory, vector    bool
+}
+
+func x86ScalarReciprocalNativeRows() []x86ScalarReciprocalNativeRow {
+	var rows []x86ScalarReciprocalNativeRow
+	for kind, op := range []string{"RCPSS", "RSQRTSS", "VRCPSS", "VRSQRTSS"} {
+		aliases := [][3]int{{0, 2, 2}, {2, 2, 2}, {-1, 2, 2}}
+		if kind >= 2 {
+			aliases = [][3]int{{0, 1, 2}, {2, 1, 2}, {0, 2, 2}, {1, 1, 2}, {2, 2, 2}, {-1, 1, 2}, {-1, 2, 2}}
+		}
+		for _, alias := range aliases {
+			rows = append(rows, x86ScalarReciprocalNativeRow{
+				name: fmt.Sprint("Estimate", len(rows)), op: op,
+				source: alias[0], base: alias[1], dst: alias[2],
+				kind: kind, memory: alias[0] < 0, vector: kind >= 2,
+			})
+		}
+	}
+	return rows
+}
+
+func x86ScalarReciprocalNativeAssembly(row x86ScalarReciprocalNativeRow, arch string, dead bool) string {
+	word, move, push, pop := 8, "MOVQ", "PUSHFQ", "POPQ"
+	if arch == "386" {
+		word, move, push, pop = 4, "MOVL", "PUSHFL", "POPL"
+	}
+	input := fmt.Sprintf("X%d", row.source)
+	if row.memory {
+		input = "(AX)"
+	}
+	operation := fmt.Sprintf("%s %s,X%d", row.op, input, row.dst)
+	if row.vector {
+		operation = fmt.Sprintf("%s %s,X%d,X%d", row.op, input, row.base, row.dst)
+	}
+	if dead {
+		return fmt.Sprintf("TEXT ·Dead%d(SB),4,$0-%d\n%s input+0(FP),AX\n%s\nRET\n", row.kind, word, move, operation)
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),AX\n%s upper+%d(FP),BX\n%s old+%d(FP),CX\n",
+		row.name, 4*word+4, move, move, word, move, 2*word, move, 3*word)
+	source.WriteString("VMOVUPS (AX),Y0\nVMOVUPS (BX),Y1\nVMOVUPS (CX),Y2\n")
+	if !row.memory {
+		fmt.Fprintf(&source, "MOVSS (AX),X%d\n", row.source)
+	}
+	// Set the complete requested environment only after preparing transport.
+	// The estimate must not signal or change any MXCSR bit, including unmasked
+	// SNaN/denormal inputs. Restore before returning to either C or Go.
+	fmt.Fprintf(&source, "STMXCSR 40(DI)\nLDMXCSR csr+%d(FP)\nMOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\nSTD\n%s\n", 4*word, operation)
+	fmt.Fprintf(&source, "%s\n%s DX\nANDL $0xcd5,DX\nCLD\nVMOVUPS Y%d,8(DI)\nMOVL DX,44(DI)\nSTMXCSR 48(DI)\nLDMXCSR 40(DI)\nVZEROUPPER\nRET\n", push, pop, row.dst)
+	return source.String()
+}
+
+func x86ScalarReciprocalNativeProgram(arch string) (source, declarations, prototypes, metadata string) {
+	var assembly, decl, c, rows strings.Builder
+	dead := make(map[int]bool)
+	for _, row := range x86ScalarReciprocalNativeRows() {
+		assembly.WriteString(x86ScalarReciprocalNativeAssembly(row, arch, false))
+		fmt.Fprintf(&decl, "func %s(out *[64]byte,input,upper,old *[32]byte,csr uint32)\n", row.name)
+		fmt.Fprintf(&c, "extern void %s(uint8_t *,const uint8_t *,const uint8_t *,const uint8_t *,uint32_t);\n", row.name)
+		fmt.Fprintf(&rows, "{%s,%d,%d,%d,%d},\n", row.name, row.kind, row.source, row.base, row.dst)
+		if row.memory && !dead[row.kind] {
+			dead[row.kind] = true
+			assembly.WriteString(x86ScalarReciprocalNativeAssembly(row, arch, true))
+			fmt.Fprintf(&decl, "func Dead%d(input *uint32)\n", row.kind)
+			fmt.Fprintf(&c, "extern void Dead%d(const uint8_t *);\n", row.kind)
+		}
+	}
+	return assembly.String(), decl.String(), c.String(), rows.String()
+}
+
+func x86ScalarReciprocalOriginalReferences(arch string) (string, string) {
+	var source, declarations strings.Builder
+	result := goWordSize(arch)
+	for kind, op := range []string{"RCPSS", "RSQRTSS", "VRCPSS", "VRSQRTSS"} {
+		fmt.Fprintf(&declarations, "func Reference%d(bits uint32) uint32\n", kind)
+		fmt.Fprintf(&source, "TEXT ·Reference%d(SB),4,$0-%d\nMOVSS bits+0(FP),X0\n%s X0,X0", kind, result+4, op)
+		if kind >= 2 {
+			source.WriteString(",X0")
+		}
+		fmt.Fprintf(&source, "\nMOVSS X0,ret+%d(FP)\nRET\n", result)
+	}
+	declarations.WriteString("func MXCSR(value uint32) uint32\n")
+	source.WriteString(x86OriginalNativeMXCSRSource(arch))
+	return source.String(), declarations.String()
+}
+
+func TestX86ScalarReciprocalNativeDirectoryAndOriginalGoSource(t *testing.T) {
+	rows := x86ScalarReciprocalNativeRows()
+	var kinds [4]int
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		if row.kind < 0 || row.kind >= len(kinds) || seen[row.name] || row.vector != (row.kind >= 2) || row.memory != (row.source < 0) {
+			t.Fatal("invalid independent native alias row", row)
+		}
+		seen[row.name] = true
+		kinds[row.kind]++
+	}
+	if len(rows) != 20 || kinds != [4]int{3, 3, 7, 7} {
+		t.Fatal("complete four-name native alias basis changed", len(rows), kinds)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		refs, refDecl := x86ScalarReciprocalOriginalReferences(arch)
+		source, declarations, _, metadata := x86ScalarReciprocalNativeProgram(arch)
+		if strings.Count(source, "TEXT ·Estimate") != 20 || strings.Count(source, "TEXT ·Dead") != 4 ||
+			strings.Contains(source+refs, "Z0") || strings.Contains(source+refs, "VMOVDQU64") {
+			t.Fatal("native source lost complete live/dead SSE/AVX-only inventory", arch)
+		}
+		for name, text := range map[string]string{
+			"value.go":      "package oracle\n" + declarations + refDecl,
+			"api.go":        "package bitview\n" + declarations,
+			"value_test.go": fmt.Sprintf(x86ScalarReciprocalNativeOriginalGo, metadata),
+		} {
+			file, err := parser.ParseFile(token.NewFileSet(), name, text, parser.AllErrors)
+			want := "oracle"
+			if name == "api.go" {
+				want = "bitview"
+			}
+			if err != nil || file.Name.Name != want {
+				t.Fatal("complete actual original Go source is not parseable", arch, name, err)
+			}
+			if name == "api.go" {
+				if _, err := parser.ParseFile(token.NewFileSet(), name, "package bitview\npackage oracle\n"+declarations, parser.AllErrors); err == nil {
+					t.Fatal("API source control accepted the old duplicate package clause")
+				}
+			}
+		}
+	}
+}
+
+// STD/CLD are deliberately retained: this root validates native x86 source,
+// not a portable replacement that silently drops the DF observation. The
+// independent typed family already has its separate five-target object gate.
+func TestX86ScalarReciprocalNativeSourcePhysicalX86Targets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if !strings.HasPrefix(target.triple, "x86_64-") && !strings.HasPrefix(target.triple, "i386-") {
+			continue
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _, _ := x86ScalarReciprocalNativeProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete initialized estimate/FLAGS/DF/MXCSR source rejected", err)
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, target.triple, "scalar-reciprocal-native.ll", "scalar-reciprocal-native.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+func x86RunScalarReciprocalNative(t *testing.T, execution x86FloatCompareExecution, arch string) {
+	t.Helper()
+	if len(execution.prefix) != 0 || arch != "amd64" && arch != "386" {
+		t.Fatal("estimate native qualification requires direct x86 host execution", arch, execution.prefix)
+	}
+	source, declarations, prototypes, metadata := x86ScalarReciprocalNativeProgram(arch)
+	goAssemblerOracleOutput(t, arch, source, "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, "Go")
+	if err != nil {
+		t.Fatal("complete native four-name estimate program rejected", err)
+	}
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			executable := execution.compileLLVM(t, "scalar-reciprocal-values", pipeline.ir,
+				fmt.Sprintf(x86ScalarReciprocalNativeValuesC, prototypes, metadata), pipeline.level)
+			var output []byte
+			if arch == "386" {
+				output = x87IA32RunDirect(t, x86NativeOracleIA32Executable(t, execution, executable), nil, os.Environ())
+			} else {
+				output = execution.run(t, executable)
+			}
+			if string(output) != "scalar estimates whole32/FLAGS/DF/MXCSR/canary outcomes 30720 failures 0\n" {
+				t.Fatal("independent native scalar estimate model mismatch", string(output))
+			}
+			faultExecutable := execution.compileLLVM(t, "scalar-reciprocal-faults", pipeline.ir,
+				x86MemoryFaultSupportC+prototypes+x86ScalarReciprocalNativeFaultsC, pipeline.level)
+			var ia32 *x87IA32Executable
+			if arch == "386" {
+				program := x86NativeOracleIA32Executable(t, execution, faultExecutable)
+				ia32 = &program
+			}
+			for row := 0; row < 4; row++ {
+				for probe := 0; probe < 5; probe++ {
+					observe := func(original int) string {
+						if ia32 != nil {
+							if err := ia32.verify(); err != nil {
+								t.Fatal(err)
+							}
+						}
+						result := x86ObserveMemoryFault(t, execution, faultExecutable, row, probe, original)
+						if ia32 != nil {
+							if err := ia32.verify(); err != nil {
+								t.Fatal(err)
+							}
+						}
+						return result
+					}
+					want := observe(1)
+					if probe < 2 && want != "segv" && want != "bus" || probe >= 2 && want != "return" {
+						t.Fatal("actual scalar opcode has unexpected exact m32 access", row, probe, want)
+					}
+					if got := observe(0); got != want {
+						t.Fatal("dead scalar estimate lost actual m32 fault", row, probe, got, want)
+					}
+				}
+			}
+			t.Logf("scalar estimates native arch=%s live=20 dead=4 whole32-outcomes=30720 fault-processes=40; SSE/AVX actual scalar opcodes, no AVX512/Z transport", arch)
+		})
+	}
+	t.Run("OriginalGo", func(t *testing.T) {
+		references, refDecl := x86ScalarReciprocalOriginalReferences(arch)
+		x86RunOriginalGoNativeSource(t, execution, arch, "package oracle\n"+declarations+refDecl, source+references,
+			fmt.Sprintf(x86ScalarReciprocalNativeOriginalGo, metadata))
+		t.Log("actual original Go scalar estimates: 20 aliases × 24 bit patterns × 64 MXCSR profiles = 30720 whole32/FLAGS/DF/MXCSR/canary outcomes; independent scalar references, no AVX512/Z execution claim")
+	})
+}
diff --git a/x86_scalar_reciprocal_owner_go127_test.go b/x86_scalar_reciprocal_owner_go127_test.go
new file mode 100644
index 000000000..0b254283c
--- /dev/null
+++ b/x86_scalar_reciprocal_owner_go127_test.go
@@ -0,0 +1,41 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarReciprocalExistingOwnersPrecedeNativeFamilies(t *testing.T) {
+	owners := x86CaptureNativeFamilyOwnerOracle(t)
+	for _, op := range []string{"MOVSS", "MOVSD", "RCPSS", "RSQRTSS", "VRCPSS", "VRSQRTSS"} {
+		for _, memory := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/memory=%t", op, memory), func(t *testing.T) {
+				text, declaration, target := x86ScalarReciprocalOwnerProgram(op, memory)
+				owners.checkProgram(t, text, declaration, target)
+			})
+		}
+	}
+}
+
+func x86ScalarReciprocalOwnerProgram(op string, memory bool) (source, declaration, target string) {
+	load, scalar := "MOVSS", "uint32"
+	if op == "MOVSD" {
+		load, scalar = "MOVSD", "uint64"
+	}
+	input, preload := "(AX)", ""
+	if !memory {
+		input, preload = "X0", load+" (AX),X0\n"
+	}
+	args, destination := input+",X1", "X1"
+	if strings.HasPrefix(op, "V") {
+		args, destination = input+",X1,X2", "X2"
+	}
+	target = op + " " + args
+	source = "TEXT ·Value(SB),4,$0-24\nMOVQ out+0(FP),DI\nMOVQ input+8(FP),AX\nMOVQ upper+16(FP),BX\n" +
+		"MOVUPS (BX),X1\nSTC\n" + preload + target + "\nMOVUPS " + destination + ",(DI)\nSETCS 16(DI)\nSTMXCSR 20(DI)\nRET\n"
+	declaration = fmt.Sprintf("func Value(out *[24]byte,input *%s,upper *[16]byte)\n", scalar)
+	return source, declaration, target
+}
diff --git a/x86_scalar_reciprocal_physical_test.go b/x86_scalar_reciprocal_physical_test.go
new file mode 100644
index 000000000..a5ccc7924
--- /dev/null
+++ b/x86_scalar_reciprocal_physical_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol.2B RCPSS/RSQRTSS: VEX.LIG.F3.0F.WIG. These
+// independent literal byte witnesses supplement Go's canonical W0/L0 rows.
+func TestX86ScalarReciprocalPhysicalWIGLIGSourceIdentity(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required")
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, row := range x86ScalarReciprocalOracle {
+			for _, memory := range []bool{false, true} {
+				for variant := 0; variant < 4; variant++ {
+					if !row.vector && variant != 0 {
+						continue
+					}
+					t.Run(fmt.Sprintf("%s/%s/memory=%t/WL=%d", arch, row.op, memory, variant), func(t *testing.T) {
+						modrm := byte(0xd0) // X0 -> X2, with independent VEX base X1.
+						if memory {
+							modrm = 0x10 // (AX), not a logical field or manufactured backing.
+						}
+						code := []byte{0xf3, 0x0f, row.opcode, modrm}
+						if row.vector {
+							control := byte(0x72)
+							if variant&1 != 0 {
+								control |= 0x80
+							}
+							if variant&2 != 0 {
+								control |= 4
+							}
+							code = []byte{0xc4, 0xe1, control, row.opcode, modrm}
+						}
+						var input, directives strings.Builder
+						for _, value := range code {
+							fmt.Fprintf(&input, "0x%02x ", value)
+							fmt.Fprintf(&directives, "BYTE $0x%02x\n", value)
+						}
+						ctx, cancel := runtimeOracleStageContext(t)
+						defer cancel()
+						command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+avx")
+						command.Stdin = strings.NewReader(input.String() + "\n")
+						output, err := runtimeOracleCombinedOutput(ctx, command)
+						if err != nil || strings.Contains(string(output), "warning:") || !strings.Contains(string(output), strings.ToLower(row.op)) {
+							t.Fatal("independent LLVM scalar estimate encoding observation failed", code, err, string(output))
+						}
+						original := "TEXT f(SB),4,$0-0\n" + directives.String() + "RET\n"
+						goAssemblerOracleOutput(t, arch, original, "", true)
+						parsed, err := Parse(ArchAMD64, original)
+						if err != nil {
+							t.Fatal(err)
+						}
+						normalized, err := normalizeX86RawFile(parsed, arch)
+						if err != nil {
+							t.Fatal("complete physical scalar reciprocal byte identity unrecognized", err)
+						}
+						matches := 0
+						for _, ins := range normalized.Funcs[0].Instrs {
+							if ins.Op == Op(row.op) {
+								matches++
+								if ins.x86SourceRaw == nil || ins.Args[0].Kind == OpMem != memory ||
+									ins.Args[len(ins.Args)-1].Reg != "X2" || row.vector && ins.Args[1].Reg != "X1" {
+									t.Fatal("WIG/LIG changed complete original source, upper input or physical destination", ins)
+								}
+							}
+						}
+						if matches != 1 {
+							t.Fatal("physical scalar estimate missing its exact single decoded source", matches)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_scalar_rmw_partial_bytes_test.go b/x86_scalar_rmw_partial_bytes_test.go
new file mode 100644
index 000000000..70d170c04
--- /dev/null
+++ b/x86_scalar_rmw_partial_bytes_test.go
@@ -0,0 +1,196 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarRMWPartialByteDependenciesCompleteFamily(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, width := range []struct {
+			suffix string
+			bytes  int
+		}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+			if arch == "386" && width.bytes == 8 {
+				continue
+			}
+			for _, stem := range strings.Fields("ADD ADC SUB SBB INC DEC NEG NOT AND OR XOR") {
+				unary := stem == "INC" || stem == "DEC" || stem == "NEG" || stem == "NOT"
+				for _, input := range []string{"destination", "source"} {
+					if unary && input == "source" {
+						continue
+					}
+					for missing := 0; missing < width.bytes; missing++ {
+						for _, carry := range []bool{false, true} {
+							name := fmt.Sprintf("%s/%s%s/%s/%d/CF=%t", arch, stem, width.suffix, input, missing, carry)
+							t.Run(name, func(t *testing.T) {
+								body := stem + width.suffix + " BX,DX"
+								if unary {
+									body = stem + width.suffix + " DX"
+								}
+								state := x86ResultState{flags: x86ByteFlagsAll}
+								if !carry {
+									state.flags &^= x86ByteFlagCF
+								}
+								state.gp[2], state.gp[3] = 0xff, 0xff
+								register := 2
+								if input == "source" {
+									register = 3
+								}
+								state.gp[register] &^= 1 << uint(missing)
+								before := state.gp
+								mask := uint8((uint16(1) << uint(width.bytes)) - 1)
+								known := mask & before[2]
+								if !unary {
+									known &= before[3]
+								}
+								if stem != "AND" && stem != "OR" && stem != "XOR" && stem != "NOT" {
+									// Carry/borrow can propagate only upward from a
+									// missing byte. Lower output bytes stay defined.
+									prefix := uint8(0)
+									for b := 0; b < width.bytes && known&(1<<uint(b)) != 0; b++ {
+										prefix |= 1 << uint(b)
+									}
+									known = prefix
+								}
+								if (stem == "ADC" || stem == "SBB") && !carry {
+									known = 0
+								}
+								want := before[2]&^mask | known
+								if width.bytes == 4 {
+									want |= 0xf0
+								}
+								if !x86LoweredPureGPUnknownTransfer(x86PureGPUnknownInstruction(t, body), &state, arch) || state.gp[2] != want {
+									t.Fatalf("partial-byte output lost exact data dependence: got=%x want=%x", state.gp[2], want)
+								}
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86ScalarPartialAddSource(arch string) string {
+	word, suffix := 8, "Q"
+	if arch == "386" {
+		word, suffix = 4, "L"
+	}
+	return fmt.Sprintf("TEXT ·PartialAdd(SB),4,$0-%d\nMOVB x+0(FP),AX\nADD%s $7,AX\nMOVB AX,ret+%d(FP)\nRET\n", word+1, suffix, word)
+}
+
+func TestX86ScalarPartialAddThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source := x86ScalarPartialAddSource(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func PartialAdd(x byte) byte", target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("unknown upper scratch bytes hid an independently defined low result", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarPartialRMWCannotSupplyUpperBytesOrWholeFlags(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix, typ := 8, "Q", "uint64"
+		if target.arch == "386" {
+			word, suffix, typ = 4, "L", "uint32"
+		}
+		prefix := "MOVB x+0(FP),AX\nADD" + suffix + " $7,AX\n"
+		rows := []struct {
+			name, declaration, body string
+			args                    int
+		}{
+			{"upper-result", "func Value(x byte) " + typ,
+				prefix + fmt.Sprintf("MOV%s AX,ret+%d(FP)", suffix, word), 2 * word},
+			{"wide-native-store", "func Value(p *uint64,x byte) byte",
+				fmt.Sprintf("MOV%s p+0(FP),DX\nMOVB x+%d(FP),AX\nADD%s $7,AX\nMOV%s AX,(DX)\nMOVB AX,ret+%d(FP)",
+					suffix, word, suffix, suffix, 2*word), 2*word + 1},
+		}
+		for _, condition := range []string{"EQ", "CS", "OS"} {
+			rows = append(rows, struct {
+				name, declaration, body string
+				args                    int
+			}{"unknown-" + condition, "func Value(x byte) byte",
+				prefix + fmt.Sprintf("SET%s BL\nMOVB BL,ret+%d(FP)", condition, word), word + 1})
+		}
+		for _, row := range rows {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nRET\n", row.args, row.body)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("known low bytes supplied unknown upper data or native-width FLAGS", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86ScalarPartialAddPortableAllByteValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	const driver = `#include <stdint.h>
+#include <stdio.h>
+extern uint32_t PartialAddByteOracle(uint32_t);
+int main(void) {
+    for (unsigned input=0;input<256;++input) {
+        unsigned got=PartialAddByteOracle(input);
+        if (got!=(uint8_t)(input+7)) {
+            fprintf(stderr,"partial add input=%u got=%u\n",input,got);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, arch := range []string{"386", "amd64"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, x86ScalarPartialAddSource(arch), "func PartialAdd(x byte) byte", arch, triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				// The translator exposes LLVM's i8 ABI, not C's stronger
+				// zeroext return convention on targets such as Darwin ARM64.
+				// Observe the original low byte through an explicit LLVM
+				// trunc/zext adapter; both sides of the C boundary use i32.
+				ir += `
+define i32 @PartialAddByteOracle(i32 %input) {
+    %byte = trunc i32 %input to i8
+    %value = call i8 @PartialAdd(i8 %byte)
+    %result = zext i8 %value to i32
+    ret i32 %result
+}
+`
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []int{0, 2} {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "partial-add-byte-values", triple, text, driver, nil, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_rmw_segment_test.go b/x86_scalar_rmw_segment_test.go
new file mode 100644
index 000000000..041a68ccf
--- /dev/null
+++ b/x86_scalar_rmw_segment_test.go
@@ -0,0 +1,96 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86SegmentRMWTestStep(ins Instr, state *x86ResultState, arch string) (bool, bool) {
+	if accepted, known := x86LoweredScalarMemoryRMW(ins, state, nil, arch); known {
+		return accepted, known
+	}
+	return x86LoweredNativeBitTest(ins, state, nil, arch)
+}
+
+func TestX86ScalarRMWCompleteNativeSegmentInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var original strings.Builder
+		count := 0
+		for _, row := range x86LockScalarOracleForms(arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				for _, address := range []string{"1(@)", "1(AX)(@*1)", "1(AX)(@*2)", "1(AX)(@*4)", "1(AX)(@*8)"} {
+					text := strings.Replace(row.text, "1(SI)", strings.ReplaceAll(address, "@", segment), 1)
+					fmt.Fprintf(&original, "TEXT ·segment%d(SB),4,$0-0\nLOCK\n%s\nRET\n", count, text)
+					count++
+					t.Run(arch+"/"+text, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, text)
+						before := ins
+						before.Args = append([]Operand(nil), ins.Args...)
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+						state.gp[0], state.gp[1] = 0xff, 0xff
+						state.pointerGP[2], state.callerAddressGP[2] = true, true
+						want := state.clone()
+						stem := row.op[:len(row.op)-1]
+						if stem == "AND" || stem == "OR" || stem == "XOR" {
+							want.flags &^= x86ByteFlagAF
+						} else if strings.HasPrefix(stem, "BT") {
+							want.flags = x86ByteFlagCF | x86ByteFlagZF
+						}
+						accepted, known := x86SegmentRMWTestStep(ins, &state, arch)
+						if !known || !accepted || !reflect.DeepEqual(state, want) || !reflect.DeepEqual(ins, before) {
+							t.Fatal("typed segment operation lost inputs or changed unrelated source/state", known, accepted)
+						}
+					})
+				}
+			}
+		}
+		want := 660
+		if arch == "amd64" {
+			want = 900
+		}
+		if count != want {
+			t.Fatal("incomplete independent scalar/bit-string segment family", count)
+		}
+		t.Run(arch+"/complete-original-Go", func(t *testing.T) {
+			goAssemblerOracleOutput(t, arch, original.String(), "", true)
+		})
+	}
+}
+
+func TestX86ScalarRMWSegmentCannotInventNumericalAddress(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ADCL", "BTCL"} {
+			for _, mutation := range []string{"unknown-base", "pointer-base", "unknown-data", "raw", "address-override", "physical-SP", "symbol", "unknown-offset"} {
+				t.Run(arch+"/"+op+"/"+mutation, func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+" CX,1(AX)(FS*4)")
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.gp[0], state.gp[1] = 0xff, 0xff
+					switch mutation {
+					case "unknown-base":
+						state.gp[0] = 0
+					case "pointer-base":
+						state.gp[0], state.pointerGP[0] = 0, true
+					case "unknown-data":
+						state.gp[1] = 0
+					case "raw":
+						ins.x86Encoded = true
+					case "address-override":
+						ins.x86AddressBits = 16
+					case "physical-SP":
+						ins.Args[1].Mem.Base = SP
+					case "symbol":
+						ins.Args[1].Mem.Sym = "external(SB)"
+					case "unknown-offset":
+						ins.Args[1].Mem.OffRaw = "missing"
+					}
+					before := state.clone()
+					if accepted, _ := x86SegmentRMWTestStep(ins, &state, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("segment continuation manufactured inputs or changed rejected state")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_shift_architectural_choice_test.go b/x86_scalar_shift_architectural_choice_test.go
new file mode 100644
index 000000000..0b043551a
--- /dev/null
+++ b/x86_scalar_shift_architectural_choice_test.go
@@ -0,0 +1,346 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86ShiftChoiceCase struct {
+	text        string
+	valueChoice bool
+	flagsChoice bool
+}
+
+// This independent finite basis complements the existing complete 148-row Go
+// encoder oracle. It spans every mnemonic, width and input role, both kinds of
+// architectural choice, high-byte preservation, native RMW and BMI2 sources.
+// Missing inputs are not architectural choices.
+func x86ShiftChoiceCases(arch string) []x86ShiftChoiceCase {
+	widths := []string{"B", "W", "L", "Q"}
+	if arch == "386" {
+		widths = widths[:3]
+	}
+	var rows []x86ShiftChoiceCase
+	for _, stem := range []string{"RCL", "RCR", "ROL", "ROR", "SAL", "SAR", "SHL", "SHR"} {
+		for _, width := range widths {
+			for _, operands := range []string{"CL,AX", "$2,AX", "CL,1(SI)"} {
+				rows = append(rows, x86ShiftChoiceCase{stem + width + " " + operands, false, true})
+			}
+			if width == "B" {
+				rows = append(rows, x86ShiftChoiceCase{stem + "B CL,AH", false, true})
+			}
+		}
+	}
+	for _, stem := range []string{"SHL", "SHR"} {
+		for _, width := range widths[1:] {
+			for _, operands := range []string{"CL,BX,AX", "$17,BX,AX", "CL,BX,1(SI)"} {
+				rows = append(rows, x86ShiftChoiceCase{stem + width + " " + operands, width == "W", true})
+			}
+			if width == "W" {
+				rows = append(rows,
+					x86ShiftChoiceCase{stem + "W $16,BX,AX", false, true},
+					x86ShiftChoiceCase{stem + "W CX,BX,AX", true, true})
+			}
+		}
+	}
+	for _, stem := range []string{"SARX", "SHLX", "SHRX", "RORX"} {
+		for _, width := range []string{"L", "Q"} {
+			count := "CX"
+			if stem == "RORX" {
+				count = "$2"
+			}
+			for _, source := range []string{"BX", "1(SI)"} {
+				rows = append(rows, x86ShiftChoiceCase{stem + width + " " + count + "," + source + ",AX", false, false})
+			}
+		}
+	}
+	return rows
+}
+
+func x86ShiftChoiceOriginalBytes(t *testing.T, arch string, rows []x86ShiftChoiceCase) [][]byte {
+	t.Helper()
+	var source strings.Builder
+	for _, row := range rows {
+		source.WriteString(row.text + "\n")
+	}
+	code, pcs := x86NumericalBoundaryGoBytes(t, arch, source.String()+"RET")
+	if len(pcs) != len(rows)+1 || len(code) == 0 || code[len(code)-1] != 0xc3 {
+		t.Fatal("incomplete original Go scalar opcode bytes or instruction boundaries")
+	}
+	result := make([][]byte, len(rows))
+	for index := range rows {
+		result[index] = append([]byte(nil), code[pcs[index]:pcs[index+1]]...)
+	}
+	return result
+}
+
+func x86ShiftChoiceSource(arch, instruction string, code []byte, control string, observeAll bool) (string, string) {
+	word, move := goWordSize(arch), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	frame := 5 * word
+	declaration := "func Choice(out *[48]byte,memory *[16]byte,x,y,count uintptr)\n"
+	if control == "unused bool" || strings.HasPrefix(control, "unused bool/") {
+		frame++
+		declaration = "func Choice(out *[48]byte,memory *[16]byte,x,y,count uintptr,unused bool)\n"
+		control = strings.TrimPrefix(strings.TrimPrefix(control, "unused bool"), "/")
+	}
+	var source strings.Builder
+	fmt.Fprintf(&source, "TEXT ·Choice(SB),4,$0-%d\n%s out+0(FP),DI\n", frame, move)
+	if control == "numeric address" {
+		source.WriteString("MOVL $1,SI\n")
+	} else if control != "missing address" {
+		fmt.Fprintf(&source, "%s memory+%d(FP),SI\n", move, word)
+	}
+	if control == "missing old high" {
+		fmt.Fprintf(&source, "MOVW x+%d(FP),AX\n", 2*word)
+	} else if control != "missing x" {
+		fmt.Fprintf(&source, "%s x+%d(FP),AX\n", move, 2*word)
+	}
+	if control != "missing y" {
+		fmt.Fprintf(&source, "%s y+%d(FP),BX\n", move, 3*word)
+	}
+	if control != "missing count" {
+		fmt.Fprintf(&source, "%s count+%d(FP),CX\n", move, 4*word)
+	}
+	// Seed independently of data/count under test. A missing AX/BX/CX must
+	// fail at its actual consumer, not accidentally at this FLAGS producer.
+	switch control {
+	case "missing flags", "missing carry":
+	case "foreign AF":
+		source.WriteString("MOVL $7,DX\nANDL $1,DX\n")
+	case "carry only":
+		source.WriteString("STC\n")
+	default:
+		source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n")
+	}
+	if code == nil {
+		source.WriteString(instruction + "\n")
+	} else {
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $%d\n", value)
+		}
+	}
+	fmt.Fprintf(&source, "%s AX,0(DI)\n", move)
+	if control != "missing carry" {
+		if control == "carry only" {
+			source.WriteString("SETEQ 32(DI)\n")
+		} else {
+			source.WriteString("SETCS 32(DI)\nSETOS 33(DI)\n")
+		}
+	}
+	if observeAll {
+		source.WriteString("SETEQ 34(DI)\nSETMI 35(DI)\nSETPS 36(DI)\nLAHF\nMOVB AH,37(DI)\n")
+	}
+	source.WriteString("RET\n")
+	return source.String(), declaration
+}
+
+func TestX86ScalarShiftArchitecturalChoiceIndependentDirectory(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86ShiftChoiceCases(arch)
+		want, flags := 142, 126
+		if arch == "386" {
+			want, flags = 112, 96
+		}
+		seen, valueChoices, flagChoices := make(map[string]bool), 0, 0
+		for _, row := range rows {
+			if seen[row.text] {
+				t.Fatal("duplicate independent architectural-outcome witness", arch, row.text)
+			}
+			seen[row.text] = true
+			if row.valueChoice {
+				valueChoices++
+			}
+			if row.flagsChoice {
+				flagChoices++
+			}
+		}
+		if len(rows) != want || valueChoices != 8 || flagChoices != flags {
+			t.Fatal("complete outcome/input-role basis changed", arch, len(rows), valueChoices, flagChoices)
+		}
+	}
+}
+
+func x86ShiftChoiceObjectBatch(t *testing.T, batch int) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for complete architectural-outcome objects")
+	}
+	type originals struct {
+		rows []x86ShiftChoiceCase
+		code [][]byte
+	}
+	cache := make(map[string]originals)
+	for _, target := range x86RawReturnTargets {
+		rows := x86ShiftChoiceCases(target.arch)
+		start, end := batch*32, (batch+1)*32
+		if start >= len(rows) {
+			continue // The independently pinned 386 basis has four batches, not five.
+		}
+		if end > len(rows) {
+			end = len(rows)
+		}
+		original, exists := cache[target.arch]
+		if !exists {
+			original.rows = rows[start:end]
+			original.code = x86ShiftChoiceOriginalBytes(t, target.arch, original.rows)
+			cache[target.arch] = original
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index, row := range original.rows {
+					var code []byte
+					if raw {
+						code = original.code[index]
+					}
+					body, declaration := x86ShiftChoiceSource(target.arch, row.text, code, "", true)
+					name := fmt.Sprint("Choice", start+index)
+					source.WriteString(strings.ReplaceAll(body, "Choice", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Choice", name))
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Error("actual initialized opcode inputs cannot observe conditional ISA choices as finite values", err)
+							return
+						}
+						for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							compileLLVMToObject(t, llc, target.triple, "scalar-choices.ll", "scalar-choices.o", body)
+						}
+						x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceObjectsBatch0(t *testing.T) {
+	x86ShiftChoiceObjectBatch(t, 0)
+}
+
+func TestX86ScalarShiftArchitecturalChoiceObjectsBatch1(t *testing.T) {
+	x86ShiftChoiceObjectBatch(t, 1)
+}
+
+func TestX86ScalarShiftArchitecturalChoiceObjectsBatch2(t *testing.T) {
+	x86ShiftChoiceObjectBatch(t, 2)
+}
+
+func TestX86ScalarShiftArchitecturalChoiceObjectsBatch3(t *testing.T) {
+	x86ShiftChoiceObjectBatch(t, 3)
+}
+
+func TestX86ScalarShiftArchitecturalChoiceObjectsBatch4(t *testing.T) {
+	x86ShiftChoiceObjectBatch(t, 4)
+}
+
+func TestX86ScalarShiftArchitecturalChoiceDefinedCountControls(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		widths := []string{"B", "W", "L", "Q"}
+		if arch == "386" {
+			widths = widths[:3]
+		}
+		var source, declarations strings.Builder
+		index := 0
+		for _, stem := range []string{"RCL", "RCR", "ROL", "ROR", "SAL", "SAR", "SHL", "SHR"} {
+			for _, width := range widths {
+				for _, count := range []string{"$0", "$1"} {
+					body, declaration := x86ShiftChoiceSource(arch, stem+width+" "+count+",AX", nil, "", false)
+					name := fmt.Sprint("Choice", index)
+					index++
+					source.WriteString(strings.ReplaceAll(body, "Choice", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Choice", name))
+				}
+			}
+		}
+		triple := x86AddressMemoryTargets(arch)[0]
+		x86LEAActualTargetGoObject(t, arch, triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api); err != nil || ir == "" {
+					t.Fatal("fully defined count0/count1 CF/OF control failed before any architectural choice", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceCannotRepairMissingFacts(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			instruction, control string
+			observeAll           bool
+		}{
+			{"SHLW CL,BX,AX", "missing x", false},
+			{"SHLW CL,BX,AX", "missing y", false},
+			{"SHLW CL,BX,AX", "missing count", false},
+			{"SHLW $17,BX,AX", "missing old high", false},
+			{"RCLB CL,AX", "missing carry", false},
+			{"SHLL $0,AX", "missing flags", false},
+			{"SHLL CL,AX", "missing flags", false},
+			{"RCLL $1,AX", "carry only", false},
+			{"SHLXL CX,BX,AX", "missing flags", false},
+			{"RORXL $2,BX,AX", "missing flags", false},
+			{"ROLW $0,AX", "foreign AF", true},
+			{"SHLW CL,BX,1(SI)", "missing address", false},
+			{"SHLW CL,BX,1(SI)", "numeric address", false},
+			{"SHLW CL,BX,AX", "unused bool/missing x", false},
+			{"SHLW CL,BX,AX", "unused bool/missing count", false},
+			{"RCLB CL,AX", "unused bool/missing carry", false},
+		} {
+			source, declaration := x86ShiftChoiceSource(arch, row.instruction, nil, row.control, row.observeAll)
+			triple := x86AddressMemoryTargets(arch)[0]
+			x86LEAActualTargetGoObject(t, arch, triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.instruction+"/"+row.control+"/"+api, func(t *testing.T) {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("ISA choice borrowed a missing input, retained flag/high byte or native address", err)
+					}
+				})
+			}
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/unusedBoolPositive/"+api, func(t *testing.T) {
+				source, declaration := x86ShiftChoiceSource(arch, "SHLW CL,BX,AX", nil, "unused bool", true)
+				triple := x86AddressMemoryTargets(arch)[0]
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); ir == "" || err != nil {
+					t.Fatal("valid initialized Void program with unused bool lost its independent scalar outcome", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceNeedsPairedMaterialization(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []string{"SHLW CL,BX,AX", "SHRW CX,BX,AX", "SHLW $17,BX,AX", "SHRW $-1,BX,AX"} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				instruction := x86ScalarLaneInstruction(t, row)
+				if _, known, err := x86TypedScalarShiftByteEffect(instruction.Op, instruction, arch); !known || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("a format/byte-effect query materialized an unspecified output without its paired emitter", known, err)
+				}
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					for register := range state.gp {
+						state.gp[register] = 0xff
+					}
+					before := state.clone()
+					if consumer.step(instruction, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("declaration-only consumer borrowed a paired architectural-choice role", consumer.name)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_shift_choice_conformance_test.go b/x86_scalar_shift_choice_conformance_test.go
new file mode 100644
index 000000000..9525b4e18
--- /dev/null
+++ b/x86_scalar_shift_choice_conformance_test.go
@@ -0,0 +1,193 @@
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86ShiftChoiceOriginalConformance(t *testing.T) string {
+	t.Helper()
+	source, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	start := strings.Index(string(source), "TEXT ·scalarShiftRotateSemantics(SB)")
+	if start < 0 {
+		t.Fatal("original initialized conformance source disappeared")
+	}
+	body := string(source[start:])
+	if next := strings.Index(body, "\nTEXT "); next >= 0 {
+		body = body[:next]
+	}
+	if strings.Count(body, "SHLW CL, AX, DX") != 1 || strings.Count(body, "SHRW CX, AX, DX") != 1 {
+		t.Fatal("original variable W double shifts were rewritten or removed")
+	}
+	return body
+}
+
+const x86ShiftChoiceConformanceDeclaration = "func scalarShiftRotateSemantics(out *[14]uint64,value,count uint64)\n"
+
+func TestX86ScalarShiftArchitecturalChoiceOriginalNumericalObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for unchanged numerical/FLAGS/MXCSR source")
+	}
+	for _, raw := range []bool{false, true} {
+		declaration, source, _, _ := x86ScalarShiftNumericalSource(t, raw)
+		kind := "named"
+		if raw {
+			kind = "raw"
+		}
+		for _, triple := range x86AddressMemoryTargets("amd64") {
+			t.Run(kind+"/"+triple, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+						if err != nil || ir == "" {
+							t.Error("unchanged original numerical source lost initialized count/data/FLAGS observations", err)
+							return
+						}
+						for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							compileLLVMToObject(t, llc, triple, "original-numerical-choice.ll", "original-numerical-choice.o", body)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceOriginalConformanceObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required for original initialized scalar conformance")
+	}
+	source := x86ShiftChoiceOriginalConformance(t)
+	for _, triple := range x86AddressMemoryTargets("amd64") {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, x86ShiftChoiceConformanceDeclaration, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Error("original fully initialized scalar program cannot observe defined/choice outcomes", err)
+						return
+					}
+					for _, body := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						compileLLVMToObject(t, llc, triple, "original-scalar-choice.ll", "original-scalar-choice.o", body)
+					}
+				})
+			}
+		})
+	}
+}
+
+// The original source is unchanged. This independent companion extends its
+// original legal-count vectors to all 256 counts without assigning a numerical
+// expectation to undefined low16 results. Untouched high bytes and every other
+// defined result remain mandatory, including count16's exact source value.
+const x86ShiftChoiceConformanceC = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void scalarShiftRotateSemantics(uint64_t*,uint64_t,uint64_t);
+static uint64_t lane(uint64_t value,unsigned bits,unsigned count,unsigned kind) {
+    uint64_t mask=bits==64?UINT64_MAX:(UINT64_C(1)<<bits)-1;
+    uint64_t sign=UINT64_C(1)<<(bits-1);
+    value&=mask;
+    if(kind<2) count%=bits;
+    for(unsigned i=0;i<count;i++) {
+        if(kind==0) value=((value<<1)|(value>>(bits-1)))&mask;
+        else if(kind==1) value=(value>>1)|((value&1)<<(bits-1));
+        else if(kind==2) value>>=1;
+        else if(kind==3) value=(value>>1)|(value&sign);
+        else value=(value<<1)&mask;
+    }
+    return value;
+}
+static uint64_t replace(uint64_t old,uint64_t value,unsigned bits) {
+    uint64_t mask=(UINT64_C(1)<<bits)-1;
+    return (old&~mask)|(value&mask);
+}
+static uint16_t double_word(uint16_t old,uint16_t source,unsigned count,int left) {
+    uint16_t value=old;
+    for(unsigned i=0;i<count;i++) {
+        if(left) value=(uint16_t)((value<<1)|((source>>(15-i))&1));
+        else value=(uint16_t)((value>>1)|(((source>>i)&1)<<15));
+    }
+    return value;
+}
+int main(void) {
+    const uint64_t values[]={0,1,UINT64_MAX,UINT64_C(0x8123456789abcdef),
+        UINT64_C(0x7fffffffffffffff),UINT64_C(0x8000000080000000),UINT64_C(0x1122334455667788)};
+    const uint64_t old=UINT64_C(0xfedcba9876543210);
+    unsigned observations=0;
+    for(unsigned sample=0;sample<7;sample++) for(unsigned count=0;count<256;count++) {
+        uint64_t value=values[sample],packet[18],want[18];
+        for(unsigned i=0;i<18;i++) packet[i]=UINT64_C(0xa5c391e7b6d8024f)^(UINT64_C(0x1020304050607)*i);
+        memcpy(want,packet,sizeof(want));
+        unsigned n=count&31;
+        uint64_t *out=want+2;
+        out[0]=replace(value,lane(value,8,n,0),8);
+        out[1]=replace(value,lane(value,8,n,1),8);
+        out[2]=replace(value,lane(value,8,n,3),8);
+        out[3]=replace(value,lane(value,8,n,2),8);
+        out[4]=replace(value,lane(value,16,n,0),16);
+        out[5]=replace(value,lane(value,16,n,3),16);
+        out[6]=lane(value,32,n,4);
+        out[7]=lane(value,64,count&63,1);
+        out[8]=out[3];
+        out[9]=out[4];
+        out[10]=old;
+        out[11]=old;
+        if(n<=16) {
+            out[10]=replace(old,double_word((uint16_t)old,(uint16_t)value,n,1),16);
+            out[11]=replace(old,double_word((uint16_t)old,(uint16_t)value,n,0),16);
+        }
+        out[12]=replace(value,lane(value,8,3,4),8);
+        out[13]=lane(value,32,3,3);
+        scalarShiftRotateSemantics(packet+2,value,count);
+        if(n>16) {
+            for(unsigned i=10;i<12;i++) {
+                out[i]=(out[i]&~UINT64_C(65535))|(packet[2+i]&65535);
+            }
+        }
+        if(memcmp(packet,want,sizeof(packet))) {
+            fprintf(stderr,"original scalar choice sample=%u count=%u\n",sample,count);
+            return 1;
+        }
+        observations++;
+    }
+    if(observations!=1792) return 2;
+    puts("ORIGINAL_SCALAR_DEFINED_AND_CHOICE_1792_VALUES_CANARIES_PASS");
+    return 0;
+}
+`
+
+func TestX86ScalarShiftArchitecturalChoiceOriginalConformancePortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required for full-count original scalar source")
+	}
+	source := x86ShiftChoiceOriginalConformance(t)
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", "#include \"textflag.h\"\n"+source)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, x86ShiftChoiceConformanceDeclaration, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("actual initialized original rejected before all-count finite-value execution", err)
+			}
+			for _, pipeline := range []struct {
+				input string
+				level int
+			}{{ir, 0}, {ir, 2}, {x86DwordProductIROptimize(t, ir), 2}} {
+				compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "original-scalar-outcomes", triple,
+					pipeline.input, x86ShiftChoiceConformanceC, nil, pipeline.level)
+			}
+		})
+	}
+	t.Log("original scalar source, 7 values x 256 counts x 3 APIs x 3 optimization paths; exact defined outputs, count16, preserved upper bytes and full canaries; undefined low16 has no guessed CPU value")
+}
diff --git a/x86_scalar_shift_choice_producer_test.go b/x86_scalar_shift_choice_producer_test.go
new file mode 100644
index 000000000..8869f87a4
--- /dev/null
+++ b/x86_scalar_shift_choice_producer_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftArchitecturalChoiceProducerFacts(t *testing.T) {
+	cf, pf, af, zf, sf, of := x86ByteFlagCF, x86ByteFlagPF, x86ByteFlagAF, x86ByteFlagZF, x86ByteFlagSF, x86ByteFlagOF
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			text                 string
+			old, finite, choices uint8
+			value                bool
+		}{
+			{"SHLW CL,BX,AX", x86ByteFlagsAll, 0, x86ByteFlagsAll, true},
+			{"SHRW $17,BX,AX", 0, x86ByteFlagsAll, x86ByteFlagsAll, true},
+			{"SHLW $16,BX,AX", 0, x86ByteFlagsAll, af | of, false},
+			{"SHLW $0,BX,AX", x86ByteFlagsAll, 0, 0, false},
+			{"SHLB CL,AH", x86ByteFlagsAll, 0, cf | af | of, false},
+			{"SARB CL,AH", x86ByteFlagsAll, 0, af | of, false},
+			{"SHLB $8,AH", 0, x86ByteFlagsAll, cf | af | of, false},
+			{"SHLL $1,AX", 0, x86ByteFlagsAll, af, false},
+			{"SHRL CL,AX", x86ByteFlagsAll, 0, af | of, false},
+			{"ROLW CL,AX", x86ByteFlagsAll, 0, of, false},
+			{"RORB $8,AX", pf | af | zf | sf, cf | of, of, false},
+			{"ROLW $1,AX", pf | af | zf | sf, cf | of, 0, false},
+			{"RCLB $9,AX", x86ByteFlagsAll, 0, 0, false},
+			{"RCRW $17,AX", x86ByteFlagsAll, 0, 0, false},
+			{"RCLB $10,AX", pf | af | zf | sf, cf | of, of, false},
+			{"RCRL CL,AX", x86ByteFlagsAll, 0, of, false},
+		} {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch)
+				if !known || err != nil {
+					t.Fatal("independent valid producer grammar", known, err)
+				}
+				outcome := form.outcome()
+				if outcome.flagsFromOld != row.old || outcome.flagsFinite != row.finite ||
+					outcome.flagsChoice != row.choices || outcome.valueChoice != row.value {
+					t.Fatal("opcode/count-specific outcome differs from independent ISA directory", outcome, row)
+				}
+				for initial := uint8(0); initial <= x86ByteFlagsAll; initial++ {
+					state := x86ResultState{flags: initial}
+					for register := range state.gp {
+						state.gp[register] = 0xff
+					}
+					before := state.clone()
+					accepted, recognized := x86LoweredScalarShiftChoiceStep(ins, &state, nil, 0, arch)
+					required := uint8(0)
+					if strings.HasPrefix(row.text, "RCLB $10") || strings.HasPrefix(row.text, "RCRL CL") {
+						required = cf
+					}
+					if !recognized || !accepted {
+						t.Fatal("closed register transfer must preserve its existing unknown-result fallback", initial)
+					}
+					if initial&required == required {
+						if state.flags != initial&row.old|row.finite {
+							t.Fatal("conditional/unchanged FLAGS became invented facts", initial, state.flags)
+						}
+					} else if state.gp[0] == before.gp[0] {
+						t.Fatal("missing carry input became a finite initialized numerical result")
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceRawOriginBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86ShiftChoiceCases(arch)
+		code := x86ShiftChoiceOriginalBytes(t, arch, rows)
+		for index, row := range rows {
+			if !row.flagsChoice {
+				continue // BMI2 has its independent complete source-binding owner.
+			}
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				decoded, err := decodeX86RawDirectives(rawX86Function(code[index]), arch)
+				if err != nil || len(decoded.Instrs) != 1 {
+					t.Fatal("complete original Go instruction could not be decoded", err)
+				}
+				ins := decoded.Instrs[0]
+				if !x86RawLegacyScalarShiftSource(ins, arch) {
+					t.Fatal("complete original raw scalar input lost exact source identity")
+				}
+				for _, mutation := range []string{"origin", "opcode", "operand", "source-operand", "vector", "address", "override", "segment", "literal", "return", "reader"} {
+					t.Run(mutation, func(t *testing.T) {
+						changed := x86ShiftChoiceMutatedOrigin(ins, mutation)
+						if x86RawLegacyScalarShiftSource(changed, arch) {
+							t.Fatal("changed source retained its exact raw identity")
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						for register := range state.gp {
+							state.gp[register] = 0xff
+						}
+						before := state.clone()
+						accepted, _ := x86LoweredScalarShiftChoiceStep(changed, &state, nil, 0, arch)
+						if mutation == "origin" {
+							// x86Encoded relaxes physical operand grammar; it is not
+							// a universal raw-origin bit. These legacy instructions
+							// have exactly named metadata after dropping origin. The
+							// complete immutable Func replay, tested independently,
+							// must detect that edit; a standalone step cannot.
+							named := Instr{Op: changed.Op, Args: append([]Operand(nil), changed.Args...), Raw: changed.Raw}
+							if ins.x86Encoded || !reflect.DeepEqual(changed, named) || !x86ResultNamedPredicateInstruction(changed) {
+								t.Fatal("origin deletion unexpectedly retained another physical restriction")
+							}
+							want := before.clone()
+							wantAccepted, _ := x86LoweredScalarShiftChoiceStep(named, &want, nil, 0, arch)
+							if accepted != wantAccepted || !reflect.DeepEqual(state, want) {
+								t.Fatal("indistinguishable named instructions acquired different numerical contracts")
+							}
+							return
+						}
+						if accepted || !reflect.DeepEqual(state, before) {
+							t.Fatal("foreign source role acquired finite scalar outcomes")
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func x86ShiftChoiceMutatedOrigin(ins Instr, mutation string) Instr {
+	changed := cloneX86ReplayInstrs([]Instr{ins})[0]
+	switch mutation {
+	case "origin":
+		changed.x86SourceRaw = nil
+	case "opcode":
+		changed.x86SourceRaw.op = "UNKNOWN"
+	case "operand":
+		changed.Args[0] = Operand{Kind: OpReg, Reg: DX}
+	case "source-operand":
+		changed.x86SourceRaw.args[0] = Operand{Kind: OpReg, Reg: DX}
+	case "vector":
+		changed.x86VectorBytes = 16
+	case "address":
+		changed.x86AddressBits = 32
+	case "override":
+		changed.x86UnboundAddressOverride = true
+	case "segment":
+		changed.x86SegmentPrefix = 0x64
+	case "literal":
+		changed.x86RIPLiteral = true
+	case "return":
+		changed.x86RawNearReturn = new(x86RawNearReturnForm)
+	case "reader":
+		changed.x86NumericalRead = &x86NumericalReadCertificate{}
+	}
+	return changed
+}
+
+func TestX86ScalarShiftArchitecturalChoiceProducerIRGuards(t *testing.T) {
+	for _, row := range []struct {
+		text        string
+		flag, value int
+	}{
+		{"SHLB CL,AH", 3, 0}, {"SARW CL,AX", 2, 0}, {"SHRL CL,AX", 2, 0},
+		{"RORQ CL,AX", 1, 0}, {"RCLW CL,AX", 1, 0},
+		{"SHLW CL,BX,AX", 6, 1}, {"SHRW $17,BX,AX", 6, 1},
+		{"SHLQ CL,BX,AX", 2, 0}, {"SHLXQ CX,BX,AX", 0, 0},
+	} {
+		t.Run(row.text, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row.text)
+			ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+			ctx.goarch = "amd64"
+			ctx.blocks = []amd64Block{{instrs: []Instr{ins}}}
+			if _, err := ctx.lowerInstr(0, 0, ins, nil, nil); err != nil {
+				t.Fatal("actual scalar producer emitter failed", err)
+			}
+			ir := output.String()
+			if strings.Count(ir, "freeze i1 poison") != row.flag || strings.Count(ir, "freeze i16 poison") != row.value ||
+				strings.Count(ir, " = freeze ") != row.flag+row.value {
+				t.Fatal("producer froze an input/old high byte, or lost a distinct output choice", fmt.Sprint(row), ir)
+			}
+			for _, line := range strings.Split(ir, "\n") {
+				if strings.Contains(line, " = freeze ") && !strings.HasSuffix(line, " poison") {
+					t.Fatal("an unavailable source value was frozen", line)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarShiftArchitecturalChoiceEveryInputByteBeforeAlias(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			text       string
+			inputs     [16]uint8
+			result     int
+			resultMask uint8
+		}{
+			{"SHLW CL,BX,AX", [16]uint8{0: 3, 1: 1, 3: 3}, 0, 3},
+			{"SHRW CX,AX,AX", [16]uint8{0: 3, 1: 1}, 0, 3},
+			{"SHLW CL,CX,CX", [16]uint8{1: 3}, 1, 3},
+			{"SHLW $17,BX,AX", [16]uint8{0: 3, 3: 3}, 0, 3},
+			{"SHLW $0,BX,AX", [16]uint8{0: 3}, 0, 3},
+			{"SHLB CL,AH", [16]uint8{0: 2, 1: 1}, 0, 2},
+			{"RCLW CL,AX", [16]uint8{0: 3, 1: 1}, 0, 3},
+			{"SHRL CX,AX", [16]uint8{0: 15, 1: 1}, 0, 255},
+		} {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				for register := 0; register < 16; register++ {
+					for missing := uint(0); missing < 8; missing++ {
+						state := x86ResultState{gp: row.inputs, flags: x86ByteFlagsAll}
+						state.gp[register] &^= 1 << missing
+						before := state.clone()
+						accepted, known := x86LoweredScalarShiftChoiceStep(ins, &state, nil, 0, arch)
+						valid := row.inputs[register]&(1<<missing) == 0
+						if !known || valid && (!accepted || state.gp[row.result]&row.resultMask != row.resultMask) ||
+							!valid && accepted && state.gp[row.result]&row.resultMask == row.resultMask ||
+							!accepted && !reflect.DeepEqual(before, state) {
+							t.Fatal("paired choice supplied a missing aliased byte or mutated a rejected state", register, missing, accepted)
+						}
+						if valid && row.resultMask != 255 && state.gp[row.result]&^row.resultMask != before.gp[row.result]&^row.resultMask {
+							t.Fatal("partial output choice invented unwritten high bytes")
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_shift_choice_replay_test.go b/x86_scalar_shift_choice_replay_test.go
new file mode 100644
index 000000000..a4cd49f49
--- /dev/null
+++ b/x86_scalar_shift_choice_replay_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftArchitecturalChoiceOriginalReplayMutationBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := x86ShiftChoiceCases(arch)
+		code := x86ShiftChoiceOriginalBytes(t, arch, rows)
+		first, declaration := x86ShiftChoiceSource(arch, rows[0].text, code[0], "", true)
+		pkg := mustGoPackage(t, "scalarreplay", "package scalarreplay\n"+declaration)
+		resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+		signatures, err := goSigsForAsmFile(pkg, mustParseX86RawReturn(t, first), resolve, arch, nil, nil, nil)
+		if err != nil {
+			t.Fatal("actual typed declaration/FP layout prerequisite", err)
+		}
+		sig, present := signatures["Choice"]
+		if !present {
+			t.Fatal("actual original function declaration disappeared")
+		}
+		check := func(function Func) error {
+			consumer := amd64Ctx{fpScalarSource: function, sig: sig, fpSourceSig: sig,
+				goarch: arch, targetTriple: x86AddressMemoryTargets(arch)[0]}
+			return consumer.checkLoweredScalarFPResultInitialization()
+		}
+		for index, row := range rows {
+			if !row.flagsChoice {
+				continue // BMI2 retains its separate complete continuation owner.
+			}
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				source, _ := x86ShiftChoiceSource(arch, row.text, code[index], "", true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil {
+					t.Fatal("original raw producer/whole-source replay prerequisite", err)
+				}
+				function := file.Funcs[0]
+				ordinal := -1
+				for at, instruction := range function.Instrs {
+					if x86RawLegacyScalarShiftSource(instruction, arch) {
+						if ordinal >= 0 {
+							t.Fatal("ambiguous original raw scalar producer")
+						}
+						ordinal = at
+					}
+				}
+				if ordinal < 0 || function.x86RawReplay == nil || function.x86RawReplay.validate(function, arch) != nil {
+					t.Fatal("original decoded producer lost its immutable whole-source replay")
+				}
+				for _, mutation := range []string{"none", "origin", "opcode", "operand", "source-operand", "vector", "address", "override", "segment", "literal", "return", "reader", "missing replay", "source spelling", "original bytes", "decoded snapshot"} {
+					t.Run(mutation, func(t *testing.T) {
+						candidate := function
+						candidate.Instrs = cloneX86ReplayInstrs(function.Instrs)
+						switch mutation {
+						case "missing replay":
+							candidate.x86RawReplay = nil
+						case "source spelling":
+							candidate.Instrs[ordinal].Raw += " changed"
+						case "original bytes":
+							replay := *function.x86RawReplay
+							replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+							candidate.x86RawReplay = &replay
+						case "decoded snapshot":
+							replay := *function.x86RawReplay
+							replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+							replay.decoded[ordinal].x86SourceRaw = nil
+							candidate.x86RawReplay = &replay
+						default:
+							candidate.Instrs[ordinal] = x86ShiftChoiceMutatedOrigin(candidate.Instrs[ordinal], mutation)
+						}
+						err := check(candidate)
+						if mutation == "none" && err != nil || mutation != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("actual paired consumer lost original source identity or rejected initialized bytes", mutation, err)
+						}
+						if function.x86RawReplay.validate(function, arch) != nil {
+							t.Fatal("a mutation changed the independently retained original replay")
+						}
+					})
+				}
+				for _, control := range []string{"named", "missing bytes"} {
+					t.Run(control, func(t *testing.T) {
+						input := ""
+						if control == "missing bytes" {
+							input = "missing x"
+						}
+						source, _ := x86ShiftChoiceSource(arch, row.text, nil, input, true)
+						named := mustParseX86RawReturn(t, source).Funcs[0]
+						if named.x86RawReplay != nil {
+							t.Fatal("ordinary named source unexpectedly carries raw replay")
+						}
+						err := check(named)
+						if control == "named" && err != nil || control == "missing bytes" && !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("named grammar or missing-input boundary changed", control, err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_shift_choice_stable_runtime_test.go b/x86_scalar_shift_choice_stable_runtime_test.go
new file mode 100644
index 000000000..b8757e133
--- /dev/null
+++ b/x86_scalar_shift_choice_stable_runtime_test.go
@@ -0,0 +1,114 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftArchitecturalChoiceStableRepeatedObservations(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required for repeated scalar output observations")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	rows := []x86ShiftChoiceCase{{text: "SHLW CL,BX,AX"}, {text: "SHRW CL,BX,AX"}}
+	code := x86ShiftChoiceOriginalBytes(t, "amd64", rows)
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprint("raw=", raw), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for index, row := range rows {
+				var original []byte
+				if raw {
+					original = code[index]
+				}
+				body, declaration := x86ShiftChoiceSource("amd64", row.text, original, "", true)
+				// Independent repeated consumers must see the same per-producer
+				// choices, including AF in both LAHF observations. No arithmetic
+				// or other FLAGS writer may intervene between these observations.
+				body = strings.TrimSuffix(body, "RET\n") + "SETCS 38(DI)\nSETOS 39(DI)\nSETEQ 40(DI)\nSETMI 41(DI)\nSETPS 42(DI)\nLAHF\nMOVB AH,43(DI)\nRET\n"
+				name := fmt.Sprint("StableShift", index)
+				source.WriteString(strings.ReplaceAll(body, "Choice", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Choice", name))
+			}
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("actual initialized scalar choices lost their repeated consumers", err)
+					}
+					for _, pipeline := range []struct {
+						input string
+						level int
+					}{{ir, 0}, {ir, 2}, {x86DwordProductIROptimize(t, ir), 2}} {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "scalar-stable-choices", triple,
+							pipeline.input, x86ShiftChoiceStableC, nil, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+	t.Log("two original W-double opcodes x 7 values x 256 counts x named/raw x 3 APIs x 3 optimization paths; exact defined results/FLAGS, preserved high bytes/canaries and same-producer repeated choices; portable integer LLVM, not native FLAGS execution")
+}
+
+const x86ShiftChoiceStableC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void StableShift0(uint8_t*,uint8_t*,uint64_t,uint64_t,uint64_t);
+extern void StableShift1(uint8_t*,uint8_t*,uint64_t,uint64_t,uint64_t);
+int main(void) {
+    void (*functions[])(uint8_t*,uint8_t*,uint64_t,uint64_t,uint64_t)={StableShift0,StableShift1};
+    const uint64_t samples[]={0,1,UINT64_MAX,UINT64_C(0x8000000080000000),
+        UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(0x8877665544332211)};
+    unsigned observations=0;
+    for(unsigned k=0;k<2;k++) for(unsigned n=0;n<256;n++) for(unsigned s=0;s<7;s++) {
+        uint8_t packet[80],want[80],memory[16],before[16];
+        for(unsigned i=0;i<80;i++) packet[i]=(uint8_t)(i*37+91);
+        for(unsigned i=0;i<16;i++) memory[i]=(uint8_t)(i*19+43);
+        memcpy(want,packet,80);memcpy(before,memory,16);
+        const uint64_t x=samples[s],y=samples[(s+3)%7];
+        unsigned count=n&31,cf=1,pf=1,af=1,zf=0,sf=1,of=1;
+        uint16_t value=(uint16_t)x,source=(uint16_t)y,old=value;
+        unsigned flagmask=0x8d5;
+        if(count>16) flagmask=0;
+        else if(count) {
+            for(unsigned i=0;i<count;i++) {
+                if(k==0) {cf=value>>15;value=(uint16_t)((value<<1)|((source>>(15-i))&1));}
+                else {cf=value&1;value=(uint16_t)((value>>1)|(((source>>i)&1)<<15));}
+            }
+            zf=value==0;sf=value>>15;pf=(__builtin_popcount((uint8_t)value)&1)==0;
+            flagmask&=~0x10u;
+            if(count==1) of=(old^value)>>15;else flagmask&=~0x800u;
+        }
+        functions[k](packet+8,memory,x,y,n|UINT64_C(0x1234567800000000));
+        uint64_t got;memcpy(&got,packet+8,8);
+        uint64_t expected=(x&~UINT64_C(0xffff))|(count>16?(got&0xffff):value);
+        memcpy(want+8,&expected,8);
+        const unsigned bits[]={1,0x800,0x40,0x80,4};
+        const unsigned flags[]={cf,of,zf,sf,pf};
+        for(unsigned i=0;i<5;i++) {
+            uint8_t actual=packet[40+i];
+            if(actual>1||actual!=packet[46+i]||((flagmask&bits[i])&&actual!=flags[i])) {
+                fprintf(stderr,"scalar stable FLAGS k%u count%u sample%u flag%u\n",k,n,s,i);return 1;
+            }
+            want[40+i]=want[46+i]=actual;
+        }
+        unsigned lahf=packet[45],lahfmask=2|(flagmask&0xd5);
+        unsigned expectedLahf=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7);
+        if(lahf!=packet[51]||(lahf&0x2a)!=2||(lahf&lahfmask)!=(expectedLahf&lahfmask)||
+            (lahf&1)!=packet[40]||((lahf>>2)&1)!=packet[44]||
+            ((lahf>>6)&1)!=packet[42]||((lahf>>7)&1)!=packet[43]) return 2;
+        want[45]=want[51]=(uint8_t)lahf;
+        if(memcmp(packet,want,80)||memcmp(memory,before,16)) {
+            fprintf(stderr,"scalar stable values/canaries k%u count%u sample%u\n",k,n,s);return 3;
+        }
+        observations++;
+    }
+    if(observations!=3584) return 4;
+    puts("SCALAR_SAME_PRODUCER_3584_DEFINED_AND_CHOICE_OBSERVATIONS_PASS");
+    return 0;
+}
+`
diff --git a/x86_scalar_shift_effect_test.go b/x86_scalar_shift_effect_test.go
new file mode 100644
index 000000000..3d27bfdf1
--- /dev/null
+++ b/x86_scalar_shift_effect_test.go
@@ -0,0 +1,419 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent directory: no production spec map supplies the denominator.
+var x86ScalarShiftTestStems = []string{"RCL", "RCR", "ROL", "ROR", "SAL", "SAR", "SHL", "SHR"}
+
+func x86ScalarShiftTestRows(arch string) []string {
+	regs := []string{"AX", "CX", "DX", "BX", "SI", "DI"}
+	widths := []string{"B", "W", "L"}
+	if arch == "amd64" {
+		regs = append(regs, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		widths = append(widths, "Q")
+	}
+	var rows []string
+	for _, stem := range x86ScalarShiftTestStems {
+		for _, width := range widths {
+			destinations := regs
+			if width == "B" {
+				destinations = []string{"AX", "AL", "AH", "BX", "BL", "BH", "CX", "CL", "CH", "DX", "DL", "DH"}
+				if arch == "386" {
+					destinations = append(destinations, "SI", "DI") // Go's bounded BX swap expansion.
+				}
+				if arch == "amd64" {
+					destinations = append(destinations, "SI", "SIB", "DI", "DIB", "R8", "R8B", "R15", "R15B")
+				}
+			}
+			for _, dst := range destinations {
+				for _, count := range []string{"$0", "$1", "$7", "$255", "CL", "CX"} {
+					rows = append(rows, stem+width+" "+count+","+dst)
+				}
+			}
+		}
+	}
+	for _, stem := range []string{"SHL", "SHR"} {
+		for _, width := range widths[1:] {
+			for _, count := range []string{"$0", "$1", "$16", "$-1", "CL", "CX"} {
+				for _, pair := range []string{"AX,BX", "AX,AX", "CX,CX", "AX,CX", "CX,AX"} {
+					rows = append(rows, stem+width+" "+count+","+pair)
+				}
+			}
+		}
+	}
+	for _, op := range []string{"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ", "RORXL", "RORXQ"} {
+		for _, dst := range regs {
+			if strings.HasPrefix(op, "RORX") {
+				for _, count := range []string{"$0", "$1", "$-128", "$255"} {
+					rows = append(rows, op+" "+count+","+dst+","+dst)
+				}
+			} else {
+				for _, pair := range []string{"AX,BX", "AX,AX", "BX,AX"} {
+					rows = append(rows, op+" "+pair+","+dst)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86ScalarShiftDefinedFlagAvailability(t *testing.T) {
+	cf, pf, af, zf, sf, of := x86ByteFlagCF, x86ByteFlagPF, x86ByteFlagAF, x86ByteFlagZF, x86ByteFlagSF, x86ByteFlagOF
+	for _, test := range []struct {
+		row                   string
+		read, defined, killed uint8
+	}{
+		{"SHRL $0,AX", 0, 0, 0}, {"SHRQ $64,AX", 0, 0, 0},
+		{"SHLB $1,AH", 0, cf | pf | zf | sf | of, x86ByteFlagsAll},
+		{"SHRW $16,AX", 0, pf | zf | sf, x86ByteFlagsAll},
+		{"SARB $31,AL", 0, cf | pf | zf | sf, x86ByteFlagsAll},
+		{"SHLQ CL,AX", 0, 0, af | of}, {"SHLW CX,AX", 0, 0, cf | af | of},
+		{"SARW CL,AX", 0, 0, af | of},
+		{"RORB $8,AL", 0, cf, of}, {"ROLW $1,AX", 0, cf | of, of},
+		{"RCLB $0,AL", 0, 0, 0}, {"RCLB $9,AL", 0, 0, of},
+		{"RCRW $17,AX", 0, 0, of}, {"RCLB $10,AL", cf, cf, of},
+		{"RCRQ $1,AX", cf, cf | of, of}, {"RCLL CX,AX", cf, 0, of},
+		{"SHLW $16,BX,AX", 0, cf | pf | zf | sf, x86ByteFlagsAll},
+		{"SHRL CX,BX,AX", 0, 0, af | of},
+		{"SHLXQ CX,BX,AX", 0, 0, 0}, {"RORXQ $255,BX,AX", 0, 0, 0},
+	} {
+		t.Run(test.row, func(t *testing.T) {
+			ins := x86YMMReadSource(t, test.row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if !known || err != nil || effect.flagsRead != test.read || effect.flagsDefined != test.defined || effect.flagsKilled != test.killed {
+				t.Fatalf("read/defined/killed=%x/%x/%x want%x/%x/%x known=%t err=%v", effect.flagsRead, effect.flagsDefined, effect.flagsKilled, test.read, test.defined, test.killed, known, err)
+			}
+			for _, initial := range []uint8{0, cf, pf | zf | sf, x86ByteFlagsAll} {
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: initial}
+					for index := range state.gp {
+						state.gp[index] = 0xff
+					}
+					before := state.clone()
+					valid := initial&test.read == test.read
+					if got := consumer.step(ins, &state, nil, 0, "amd64"); got != valid {
+						t.Fatalf("%s admitted unavailable input flags: %x", consumer.name, initial)
+					}
+					if valid && state.flags != initial&^test.killed|test.defined || !valid && !reflect.DeepEqual(state, before) {
+						t.Fatalf("%s changed defined/undefined flags or failed state", consumer.name)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarShiftIndependentPhysicalInputGuards(t *testing.T) {
+	for _, test := range []struct {
+		row    string
+		reads  [16]uint8
+		result int
+		width  uint8
+	}{
+		{row: "SHLB $0,AH", reads: [16]uint8{2}, width: 2},
+		{row: "SHLW CL,AX", reads: [16]uint8{3, 1}, width: 3},
+		{row: "SHRL CX,AX", reads: [16]uint8{15, 1}, width: 255},
+		{row: "SHRQ CL,R8", reads: [16]uint8{1: 1, 8: 255}, result: 8, width: 255},
+		{row: "SHLL $0,BX,AX", reads: [16]uint8{15}, width: 255},
+		{row: "SHLW $16,BX,AX", reads: [16]uint8{0: 3, 3: 3}, width: 3},
+		{row: "SHLXQ AX,BX,AX", reads: [16]uint8{0: 1, 3: 255}, width: 255},
+		{row: "RORXL $0,BX,AX", reads: [16]uint8{3: 15}, width: 255},
+	} {
+		t.Run(test.row, func(t *testing.T) {
+			ins := x86YMMReadSource(t, test.row)
+			for register := 0; register < 16; register++ {
+				for missing := 0; missing < 8; missing++ {
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp = test.reads
+						state.gp[register] &^= 1 << uint(missing)
+						before := state.clone()
+						valid := test.reads[register]&(1<<uint(missing)) == 0
+						if got := consumer.step(ins, &state, nil, 0, "amd64"); got != valid {
+							t.Fatalf("%s register%d missing%d accepted%t want%t", consumer.name, register, missing, got, valid)
+						}
+						if valid && state.gp[test.result]&test.width != test.width || !valid && !reflect.DeepEqual(state, before) {
+							t.Fatal("missing byte or alias extent was manufactured")
+						}
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarShiftGrammarAndMemoryAuthorityControls(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range []string{
+			"SHLB $-1,AX", "SHRW $256,AX", "SHLL AX,BX", "RCLQ $1,X0", "RORB $1,SPB",
+			"SHLW $128,AX,BX", "SHRW $-129,AX,BX", "SHLB $1,AX,BX", "SALW $1,AX,BX",
+			"RORXQ $256,AX,BX", "RORXL $-129,AX,BX", "SHLXQ $1,AX,BX", "SHRXL CL,AX,BX",
+			"SARXL AX,X0,BX", "SHLL.Z $1,AX",
+		} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n", "", false)
+				ins := x86YMMReadSource(t, row)
+				if _, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err == nil {
+					t.Fatal("typed grammar acquired Go-rejected form")
+				}
+			})
+		}
+		for _, row := range []string{"SHLL $1,AX", "SHLW CL,AX", "RORXL $1,AX,BX"} {
+			ins := x86YMMReadSource(t, row)
+			if ins.Args[0].Kind == OpImm {
+				for _, raw := range []bool{false, true} {
+					changed := ins
+					changed.Args = append([]Operand(nil), ins.Args...)
+					changed.Args[0].ImmRaw = "UNKNOWN"
+					if raw {
+						changed.Args[0].ImmRaw = ""
+						changed.Args[0].ImmIsFloat = true
+					}
+					if _, known, err := x86TypedInstructionByteEffect(changed.Op, changed, arch); !known || err == nil {
+						t.Fatal("unresolved or floating count promoted to integer")
+					}
+				}
+			}
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{flags: x86ByteFlagsAll, pointerGP: [16]bool{true}}
+				if consumer.step(ins, &state, nil, 0, arch) {
+					t.Fatal("opaque pointer bytes promoted to numerical shift data")
+				}
+			}
+		}
+		for _, row := range []string{"SHLL $1,(AX)", "SHRL CL,tmp-4(SP)", "ROLW $1,data(SB)", "SHRXL AX,(BX),CX"} {
+			ins := x86YMMReadSource(t, row)
+			if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); !known || err != nil || !effect.requiresResultProof {
+				t.Fatal("memory shape lost its mandatory numerical obligation", err)
+			}
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				if consumer.step(ins, &state, nil, 0, arch) {
+					t.Fatal("a memory byte shape supplied unproved storage")
+				}
+			}
+		}
+	}
+}
+
+func TestX86ScalarShiftIndependentCompleteGoEncoderRows(t *testing.T) {
+	compact := func(s string) string { return strings.Join(strings.Fields(s), "") }
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := compact(string(data))
+	rows := 0
+	for _, stem := range x86ScalarShiftTestStems {
+		digit := "0" + map[string]string{"ROL": "0", "ROR": "1", "RCL": "2", "RCR": "3", "SAL": "4", "SHL": "4", "SHR": "5", "SAR": "7"}[stem]
+		for _, width := range []string{"B", "W", "L", "Q"} {
+			tab, prefix, bytes := "yshl", map[string]string{"W": "Pe", "L": "Px", "Q": "Pw"}[width], "0xd1,"+digit+",0xc1,"+digit+",0xd3,"+digit+",0xd3,"+digit
+			if width == "B" {
+				tab, prefix, bytes = "yshb", "Pb", "0xd0,"+digit+",0xc0,"+digit+",0xd2,"+digit
+				rows += 3
+			} else {
+				rows += 4
+			}
+			want := "{A" + stem + width + "," + tab + "," + prefix + ",opBytes{" + bytes + "}}"
+			if !strings.Contains(text, want) {
+				t.Fatalf("missing complete prefix/opcode row %s", want)
+			}
+		}
+	}
+	for tab, want := range map[string]string{
+		"yshb": "{Zo_m,2,argList{Yi1,Ymb}},{Zibo_m,2,argList{Yu8,Ymb}},{Zo_m,2,argList{Ycx,Ymb}},",
+		"yshl": "{Zo_m,2,argList{Yi1,Yml}},{Zibo_m,2,argList{Yu8,Yml}},{Zo_m,2,argList{Ycl,Yml}},{Zo_m,2,argList{Ycx,Yml}},",
+	} {
+		capture := regexp.MustCompile(`(?s)var ` + tab + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(data))
+		if len(capture) != 2 || compact(capture[1]) != want {
+			t.Fatalf("complete %s zcase/advance/classes changed", tab)
+		}
+	}
+	for _, stem := range []string{"SHL", "SHR"} {
+		for _, width := range []string{"W", "L", "Q"} {
+			opcodes := map[string]string{"SHL": "0xa4,0xa5", "SHR": "0xac,0xad"}[stem]
+			prefix := map[string]string{"W": "Pe,", "L": "", "Q": "Pw,"}[width]
+			padding := ",0"
+			if width == "L" {
+				padding += ",0"
+			}
+			for _, count := range []string{"Yi8", "Ycl", "Ycx"} {
+				want := "{A" + stem + width + "," + count + ",Yrl,Yml,movDoubleShift,[4]uint8{" + prefix + opcodes + padding + "}}"
+				if !strings.Contains(text, want) {
+					t.Fatalf("missing full movtab row %s", want)
+				}
+				rows++
+			}
+		}
+	}
+	avx, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text = compact(string(avx))
+	for _, stem := range []string{"SARX", "SHLX", "SHRX", "RORX"} {
+		for _, width := range []string{"L", "Q"} {
+			tab, escape, opcode := "_ybextrl", "vex0F38", "0xF7"
+			if stem == "RORX" {
+				tab, escape, opcode = "_yrorxl", "vex0F3A", "0xF0"
+				rows += 2
+			} else {
+				rows++
+			}
+			prefix := map[string]string{"SARX": "vexF3", "SHLX": "vex66", "SHRX": "vexF2", "RORX": "vexF2"}[stem]
+			w := map[string]string{"L": "vexW0", "Q": "vexW1"}[width]
+			want := "{as:A" + stem + width + ",ytab:" + tab + ",prefix:Pavx,op:opBytes{avxEscape|vex128|" + prefix + "|" + escape + "|" + w + "," + opcode + ",}}"
+			if !strings.Contains(text, want) {
+				t.Fatal("missing complete AVX attributes/opbytes", want)
+			}
+		}
+	}
+	for tab, want := range map[string]string{
+		"_ybextrl": "{zcase:Zvex_v_rm_r,zoffset:2,args:argList{Yrl,Yml,Yrl}},",
+		"_yrorxl":  "{zcase:Zvex_i_rm_r,zoffset:0,args:argList{Yu8,Yml,Yrl}},{zcase:Zvex_i_rm_r,zoffset:2,args:argList{Yi8,Yml,Yrl}},",
+	} {
+		capture := regexp.MustCompile(`(?s)var ` + tab + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(avx))
+		if len(capture) != 2 || compact(capture[1]) != want {
+			t.Fatal("complete AVX zcase/advance/classes changed", tab)
+		}
+	}
+	if rows != 148 {
+		t.Fatalf("complete independent row denominator %d", rows)
+	}
+	t.Log("148 complete independent rows: 120 Group2, 18 double-shift, 10 BMI2; all attributes and opcode bytes")
+}
+
+func TestX86ScalarShiftCompleteRegisterEffects(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		rows := x86ScalarShiftTestRows(arch)
+		// Actual Go object producer is independent of the effect implementation.
+		goAssemblerOracleOutput(t, arch, "TEXT f(SB),4,$0-0\n"+strings.Join(rows, "\n")+"\nRET\n", "", true)
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86YMMReadSource(t, row)
+				before := fmt.Sprintf("%#v", ins)
+				undefined := (ins.Op == "SHLW" || ins.Op == "SHRW") && len(ins.Args) == 3 && (ins.Args[0].Kind == OpReg || ins.Args[0].Imm&31 > 16)
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					for index := range state.gp {
+						state.gp[index] = 0xff
+					}
+					if got := consumer.step(ins, &state, nil, 0, arch); got == undefined {
+						t.Errorf("%s: effect accepted=%t undefined=%t", consumer.name, got, undefined)
+					}
+				}
+				if before != fmt.Sprintf("%#v", ins) {
+					t.Fatal("observer rewrote original source/operand metadata")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftEveryRequiredInputByteAndAliasExtent(t *testing.T) {
+	for _, row := range []string{"SHLB $5,AH", "RORW $1,BX", "RCLL $0,AX", "SHRL CX,BX", "SHRQ CL,R8", "SHLL $1,AX,BX", "SHRW $16,AX,BX", "SHLXQ AX,BX,AX", "SARXQ AX,AX,AX", "RORXQ $255,AX,BX"} {
+		t.Run(row, func(t *testing.T) {
+			ins := x86YMMReadSource(t, row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if !known || err != nil {
+				t.Fatalf("missing typed effect: known=%t err=%v", known, err)
+			}
+			for _, operand := range effect.operands {
+				if !operand.read || operand.operand.Kind != OpReg {
+					continue
+				}
+				index, mask, valid := x86ResultGP(operand.operand.Reg, operand.width, "amd64")
+				if !valid {
+					t.Fatal("invalid expected register read")
+				}
+				for missing := 0; missing < 8; missing++ {
+					if mask&(1<<uint(missing)) == 0 {
+						continue
+					}
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						for i := range state.gp {
+							state.gp[i] = 0xff
+						}
+						state.gp[index] &^= 1 << uint(missing)
+						before := state.clone()
+						if consumer.step(ins, &state, nil, 0, "amd64") || !reflect.DeepEqual(state, before) {
+							t.Fatalf("%s acquired missing physical byte%d or changed failed state", consumer.name, missing)
+						}
+					}
+				}
+			}
+		})
+	}
+	for _, row := range []string{"SHLL $0,AX", "ROLL $32,AX", "RCRL $0,AX", "SHLL $0,BX,AX", "RORXL $0,AX,AX", "SHLXQ CX,AX,AX"} {
+		ins := x86YMMReadSource(t, row)
+		for _, consumer := range x86ResultGPSIMDConsumers {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.gp[0], state.gp[1] = 0x0f, 1
+			if strings.HasPrefix(row, "SHLXQ") {
+				state.gp[0] = 0xff
+			}
+			if !consumer.step(ins, &state, nil, 0, "amd64") || state.gp[0] != 0xff {
+				t.Fatalf("%s failed physical zero-count r32 upper overwrite / count low byte: %s %#v", consumer.name, row, state)
+			}
+		}
+	}
+}
+
+func TestX86ScalarShiftBothResultObserversAndAuthority(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		word, move, reg, extract := 8, "MOVQ", "R8", "VPEXTRQ"
+		if arch == "386" {
+			word, move, reg, extract = 4, "MOVL", "AX", "VPEXTRD"
+		}
+		finish := fmt.Sprintf("%s %s,X0\n%s $0,X0,BX\n%s BX,ret0+%d(FP)\nRET", move, reg, extract, move, word)
+		load := fmt.Sprintf("%s x+0(FP),%s\n", move, reg)
+		for name, test := range map[string]struct {
+			body string
+			pass bool
+		}{
+			"exact CI class":              {load + "SHR" + map[string]string{"amd64": "Q", "386": "L"}[arch] + " $5," + reg + "\n" + finish, true},
+			"both paths":                  {load + "CMPL " + reg + ",$0\nJE other\nSHRL $1," + reg + "\nJMP done\nother:\nROLL $1," + reg + "\ndone:\n" + finish, true},
+			"missing initial destination": {"SHRL $5," + reg + "\n" + finish, false},
+			"unknown count":               {load + "SHRL CL," + reg + "\n" + finish, false},
+			"partial count sufficient":    {load + "MOVB $7,CL\nSHRL CX," + reg + "\n" + finish, true},
+			"opaque input":                {fmt.Sprintf("%s p+0(FP),%s\nSHRL $5,%s\n", move, reg, reg) + finish, false},
+			"native memory":               {load + "SHRL $5,(AX)\n" + finish, false},
+			"SP numeric":                  {load + "SHRL $5,SP\n" + finish, false},
+			"SB memory":                   {load + "SHRL $5,data(SB)\n" + finish, false},
+			"undefined OF":                {load + "SHRL $2," + reg + "\nSETOS CL\n" + finish, false},
+			"defined OF":                  {load + "SHRL $1," + reg + "\nSETOS CL\n" + finish, true},
+			"unknown carry":               {load + "RCRL $1," + reg + "\n" + finish, false},
+			"zero carry not read":         {load + "RCRL $0," + reg + "\n" + finish, true},
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				declaration := "func Value(x uint64) uint64"
+				if arch == "386" {
+					declaration = "func Value(x uint32) uint32"
+				}
+				if name == "opaque input" {
+					declaration = strings.Replace(declaration, "x uint64", "p *byte", 1)
+					declaration = strings.Replace(declaration, "x uint32", "p *byte", 1)
+				}
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, declaration, test.body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					err := check(file.Funcs[0], sig, arch)
+					if test.pass && err != nil || !test.pass && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("pass=%t error=%v", test.pass, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_shift_forms.go b/x86_scalar_shift_forms.go
new file mode 100644
index 000000000..9b02ac11c
--- /dev/null
+++ b/x86_scalar_shift_forms.go
@@ -0,0 +1,170 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86ScalarShiftForm struct {
+	stem, name                    string
+	bits                          int
+	count, source, destination    Operand
+	sourceIndex, destinationIndex int
+	double, bmi2                  bool
+}
+
+// Match complete Go yshb/yshl, movDoubleShift, _ybextrl and _yrorxl
+// grammars. A shape is not numerical input, memory backing or entry authority.
+func x86ScalarShiftProperties(op Op, ins Instr, arch string) (x86ScalarShiftForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	base, _, dotted := strings.Cut(name, ".")
+	stem, bits, known := amd64ScalarShiftRotateProperties(base)
+	bmi2 := false
+	if !known {
+		if spec, present := amd64BMI2ShiftSpecs[Op(base)]; present {
+			stem, bits, known, bmi2 = base[:len(base)-1], spec.bits, true, true
+		}
+	}
+	if !known {
+		return x86ScalarShiftForm{}, false, nil
+	}
+	f := x86ScalarShiftForm{stem: stem, name: base, bits: bits, bmi2: bmi2, sourceIndex: -1, destinationIndex: 1}
+	fail := func(reason string) (x86ScalarShiftForm, bool, error) {
+		return f, true, fmt.Errorf("%s %s outside Go scalar shift/rotate grammar (%s): %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || dotted || ins.Op != "" && !strings.EqualFold(string(ins.Op), name) {
+		return fail("mode or opcode identity")
+	}
+	if arch == "386" && bits == 64 {
+		if !bmi2 {
+			return fail("legacy Q requires 64-bit mode")
+		}
+		f.bits = 32 // Go accepts VEX.W1 spellings; hardware ignores W in mode32.
+	}
+	if bmi2 || len(ins.Args) == 3 {
+		if len(ins.Args) != 3 || !bmi2 && (bits == 8 || stem != "SHL" && stem != "SHR") {
+			return fail("operand count or double-shift width")
+		}
+		f.double, f.sourceIndex, f.destinationIndex = !bmi2, 1, 2
+		f.source = ins.Args[1]
+		if f.source.Kind == OpReg {
+			if !isX86YrlRegisterForArch(f.source.Reg, arch) {
+				return fail("Yrl source")
+			}
+		} else if f.double || !isAMD64MemoryOperand(f.source) || !x86PackedShiftMemoryValid(f.source, arch) {
+			return fail("Yml source")
+		}
+	} else if len(ins.Args) != 2 {
+		return fail("operand count")
+	}
+	f.count, f.destination = ins.Args[0], ins.Args[f.destinationIndex]
+	if f.destination.Kind == OpReg {
+		valid := isX86YrlRegisterForArch(f.destination.Reg, arch)
+		if f.bits == 8 {
+			valid = isGoYmbRegisterForArch(f.destination.Reg, arch)
+		}
+		if !valid {
+			return fail("destination register class")
+		}
+	} else if bmi2 || !isAMD64MemoryOperand(f.destination) || !x86PackedShiftMemoryValid(f.destination, arch) {
+		return fail("destination memory class")
+	}
+	if bmi2 && stem != "RORX" {
+		if f.count.Kind != OpReg || !isX86YrlRegisterForArch(f.count.Reg, arch) {
+			return fail("Yrl register count")
+		}
+	} else if f.count.Kind == OpImm {
+		low, high := int64(0), int64(255)
+		if f.double {
+			low, high = -128, 127
+		} else if bmi2 { // _yrorxl has both Yu8 and Yi8 encoder rows.
+			low = -128
+		}
+		if f.count.ImmRaw != "" || f.count.ImmIsFloat || f.count.Imm < low || f.count.Imm > high {
+			return fail("resolved encoder imm8 count")
+		}
+	} else if bmi2 || f.count.Kind != OpReg || f.count.Reg != CL && f.count.Reg != CX {
+		return fail("CL/CX count")
+	}
+	return f, true, nil
+}
+
+func (f x86ScalarShiftForm) maskedCount() int64 {
+	mask := int64(31)
+	if f.bits == 64 {
+		mask = 63
+	}
+	return f.count.Imm & mask
+}
+
+func x86TypedScalarShiftByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	f, known, err := x86ScalarShiftProperties(op, ins, arch)
+	if !known || err != nil {
+		return x86TypedByteEffect{}, known, err
+	}
+	count, variable := f.maskedCount(), f.count.Kind == OpReg
+	if f.double && f.bits == 16 && (variable || count > 16) {
+		return x86TypedByteEffect{}, true, fmt.Errorf("%w: W double-shift has an unproved or undefined numerical count", ErrProbeNeedsContext)
+	}
+	effect := f.inputEffect()
+	if f.bmi2 || !variable && count == 0 {
+		return effect, true, nil // BMI2 never writes flags; Group2 count0 preserves.
+	}
+	rotate := f.stem == "RCL" || f.stem == "RCR" || f.stem == "ROL" || f.stem == "ROR"
+	carry := f.stem == "RCL" || f.stem == "RCR"
+	if rotate {
+		effect.flagsKilled = x86ByteFlagOF
+		if !variable {
+			if !carry || count%int64(f.bits+1) != 0 {
+				effect.flagsDefined = x86ByteFlagCF
+			}
+			if count == 1 {
+				effect.flagsDefined |= x86ByteFlagOF
+			}
+		}
+		return effect, true, nil
+	}
+	effect.flagsKilled = x86ByteFlagAF | x86ByteFlagOF
+	if variable {
+		// Count0 preserves unknown flags: no fresh definition is unconditional.
+		// B/W logical shifts also have a legal count where CF is undefined.
+		if f.bits < 32 && f.stem != "SAR" {
+			effect.flagsKilled |= x86ByteFlagCF
+		}
+	} else {
+		effect.flagsKilled = x86ByteFlagsAll
+		effect.flagsDefined = x86ByteFlagPF | x86ByteFlagZF | x86ByteFlagSF
+		if f.double || f.stem == "SAR" || count < int64(f.bits) {
+			effect.flagsDefined |= x86ByteFlagCF
+		}
+		if count == 1 {
+			effect.flagsDefined |= x86ByteFlagOF
+		}
+	}
+	return effect, true, nil
+}
+
+func (f x86ScalarShiftForm) inputEffect() x86TypedByteEffect {
+	count, variable := f.maskedCount(), f.count.Kind == OpReg
+	// A numerical byte effect is not memory authority. Logical FP/AUTO
+	// consumers still need initialized storage; native operands require the
+	// lowering-only continuation paired with their exact volatile access.
+	effect := x86TypedByteEffect{requiresResultProof: f.bmi2 || f.hasMemory()}
+	if variable {
+		// Both CX spelling and every BMI2 Yrl count consume only low CL bits.
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: 0, operand: f.count, width: 1, read: true})
+	}
+	width := int64(f.bits / 8)
+	if f.sourceIndex >= 0 {
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: f.sourceIndex, operand: f.source, width: width, read: f.bmi2 || variable || count != 0})
+	}
+	effect.operands = append(effect.operands, x86TypedByteOperand{index: f.destinationIndex, operand: f.destination, width: width, read: !f.bmi2, write: true})
+	if (f.stem == "RCL" || f.stem == "RCR") && (variable || count%int64(f.bits+1) != 0) {
+		effect.flagsRead = x86ByteFlagCF
+	}
+	return effect
+}
+
+func (f x86ScalarShiftForm) hasMemory() bool {
+	return f.destination.Kind != OpReg || f.sourceIndex >= 0 && f.source.Kind != OpReg
+}
diff --git a/x86_scalar_shift_memory_runtime_test.go b/x86_scalar_shift_memory_runtime_test.go
new file mode 100644
index 000000000..98f9e5f96
--- /dev/null
+++ b/x86_scalar_shift_memory_runtime_test.go
@@ -0,0 +1,318 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Independent runtime metadata follows the test's Go encoder rows, never the
+// production descriptor. This exact-result oracle excludes four W double
+// forms with unspecified low16 outcomes. Their whole-object/paired-access and
+// producer-consistency controls have independent architectural-choice owners.
+type x86ShiftMemoryRuntimeRow struct {
+	x86ShiftMemoryOracle
+	kind, count int
+	flags       uint64
+}
+
+func x86ShiftMemoryRuntimeRows(arch string) []x86ShiftMemoryRuntimeRow {
+	var rows []x86ShiftMemoryRuntimeRow
+	for _, row := range x86ScalarShiftMemoryRows(arch) {
+		if row.valueChoice {
+			continue
+		}
+		rows = append(rows, x86ShiftMemoryRuntimeMetadata(row))
+	}
+	return rows
+}
+
+// The independent runtime directory and official-row object producer share
+// observation metadata, never a production permission for undefined FLAGS.
+func x86ShiftMemoryRuntimeMetadata(row x86ShiftMemoryOracle) x86ShiftMemoryRuntimeRow {
+	op, operands, _ := strings.Cut(row.text, " ")
+	stem := op[:len(op)-1]
+	kind := -1
+	for i, name := range []string{"RCL", "RCR", "ROL", "ROR", "SAL", "SAR", "SHL", "SHR", "SHL", "SHR", "SARX", "SHLX", "SHRX", "RORX"} {
+		if name == stem && (i < 8) == (strings.Count(operands, ",") == 1) {
+			kind = i
+		}
+	}
+	count := -1
+	if first, _, _ := strings.Cut(operands, ","); strings.HasPrefix(first, "$") {
+		var err error
+		count, err = strconv.Atoi(first[1:])
+		if err != nil {
+			panic(err)
+		}
+		count &= 31
+		if row.bits == 64 {
+			original, _ := strconv.Atoi(first[1:])
+			count = original & 63
+		}
+	}
+	if kind < 0 {
+		panic("unregistered independent scalar-shift reference")
+	}
+	flags := uint64(0x8d5)
+	if kind < 10 && count != 0 {
+		if count != 1 {
+			flags &^= 0x800 // OF is undefined, not a value to compare.
+		}
+		if kind >= 4 {
+			flags &^= 0x10 // AF is undefined after nonzero shifts.
+			if row.bits < 32 && kind != 5 && count < 0 {
+				flags &^= 1 // B/W logical counts can make CF undefined.
+			}
+		}
+	}
+	if row.valueChoice {
+		// Some W double counts have no defined data/status expectation. Their
+		// existing paired lowering can choose a finite value, not known FLAGS.
+		flags = 0
+	}
+	return x86ShiftMemoryRuntimeRow{row, kind, count, flags}
+}
+
+func x86ShiftMemoryRuntimeFixture(arch string, rows []x86ShiftMemoryRuntimeRow) (string, string, string) {
+	word, move, suffix, cword := 8, "MOVQ", "Q", "uint64_t"
+	if arch == "386" {
+		word, move, suffix, cword = 4, "MOVL", "L", "uint32_t"
+	}
+	var source, declaration, prototypes, metadata strings.Builder
+	for i, row := range rows {
+		name := fmt.Sprint("MemoryShift", i)
+		fmt.Fprintf(&declaration, "func %s(p *[128]byte,out *[8]uint64,value,count,seed uintptr)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n", name, word*5)
+		fmt.Fprintf(&source, "%s p+0(FP),DI\n%s out+%d(FP),SI\n%s value+%d(FP),AX\n%s count+%d(FP),CX\n%s seed+%d(FP),DX\n",
+			move, move, word, move, word*2, move, word*3, move, word*4)
+		fmt.Fprintf(&source, "PUSH%s DX\nPOPF%s\n%s\nPUSHF%s\nPOP%s DX\nAND%s $%d,DX\n",
+			suffix, suffix, row.text, suffix, suffix, suffix, row.flags)
+		fmt.Fprintf(&source, "%s DX,0(SI)\n%s AX,8(SI)\n%s CX,16(SI)\nRET\n", move, move, move)
+		fmt.Fprintf(&prototypes, "extern void %s(uint8_t*,uint64_t*,word,word,word);\n", name)
+		fmt.Fprintf(&metadata, "{%s,%d,%d,%d,%d},\n", name, row.bits, row.kind, row.count, row.flags)
+	}
+	driver := strings.NewReplacer("@WORD@", cword, "@PROTOTYPES@", prototypes.String(),
+		"@ROWS@", metadata.String()).Replace(x86ShiftMemoryReferenceC)
+	return source.String(), declaration.String(), driver
+}
+
+func x86ShiftMemoryPortableRuntime(t *testing.T, api string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	arch, originalTriple, want := "amd64", "x86_64-unknown-linux-gnu", 144
+	if strconv.IntSize == 32 {
+		arch, originalTriple, want = "386", "i386-unknown-linux-gnu", 106
+	}
+	rows := x86ShiftMemoryRuntimeRows(arch)
+	if len(rows) != want {
+		t.Fatal("incomplete defined-count memory runtime denominator", len(rows), want)
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for first := 0; first < len(rows); first += 72 {
+		last := first + 72
+		if last > len(rows) {
+			last = len(rows)
+		}
+		t.Run(fmt.Sprint("batch-", first/72), func(t *testing.T) {
+			source, declaration, driver := x86ShiftMemoryRuntimeFixture(arch, rows[first:last])
+			x86LEAActualTargetGoObject(t, arch, originalTriple, source)
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete initialized memory runtime rejected", err)
+			}
+			for _, optimized := range []bool{false, true} {
+				text := ir
+				if optimized {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "scalar-shift-memory", triple,
+							text, driver, nil, level)
+					})
+				}
+			}
+		})
+	}
+	t.Logf("%d kernels: all imm8 runtime counts, both carry seeds, exact memory/GP bytes, defined FLAGS and canaries; portable LLVM, not native x86 execution", len(rows))
+}
+
+func TestX86ScalarShiftMemoryPortableTextRuntime(t *testing.T) {
+	x86ShiftMemoryPortableRuntime(t, "text")
+}
+
+func TestX86ScalarShiftMemoryPortableModuleRuntime(t *testing.T) {
+	x86ShiftMemoryPortableRuntime(t, "module")
+}
+
+func TestX86ScalarShiftMemoryPortableGoRuntime(t *testing.T) {
+	x86ShiftMemoryPortableRuntime(t, "Go")
+}
+
+// Repeated single-bit operations deliberately do not mirror LLVM's lowering.
+// Native access/fault behavior has its own original-Go execution oracle.
+const x86ShiftMemoryReferenceC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+typedef @WORD@ word;
+@PROTOTYPES@
+typedef struct {
+    void (*fn)(uint8_t*,uint64_t*,word,word,word);
+    unsigned bits, kind;
+    int count;
+    uint64_t flags;
+} Kernel;
+static const Kernel kernels[] = {@ROWS@};
+/* Original Go opcode definitions. */
+
+static uint64_t reference(Kernel k, uint64_t input, uint64_t source,
+        unsigned count, uint64_t seed, uint64_t *status) {
+    const uint64_t mask = k.bits == 64 ? UINT64_MAX : (UINT64_C(1)<<k.bits)-1;
+    uint64_t value = input & mask, old = value;
+    unsigned cf = seed&1, pf = (seed>>2)&1, af = (seed>>4)&1;
+    unsigned zf = (seed>>6)&1, sf = (seed>>7)&1, of = (seed>>11)&1;
+    count = (k.count >= 0 ? (unsigned)k.count : count) & (k.bits == 64 ? 63 : 31);
+    source &= mask;
+    unsigned effective = count;
+    if (k.kind < 2) effective %= k.bits+1;
+    if (k.kind == 2 || k.kind == 3) effective %= k.bits;
+    for (unsigned i = 0; i < effective; i++) {
+        unsigned next;
+        switch (k.kind) {
+        case 0:
+            next = value>>(k.bits-1);
+            value = ((value<<1)|cf)&mask;
+            cf = next;
+            break;
+        case 1:
+            next = value&1;
+            value = (value>>1)|((uint64_t)cf<<(k.bits-1));
+            cf = next;
+            break;
+        case 2:
+            cf = value>>(k.bits-1);
+            value = ((value<<1)|cf)&mask;
+            break;
+        case 3:
+            cf = value&1;
+            value = (value>>1)|((uint64_t)cf<<(k.bits-1));
+            break;
+        case 4: case 6: case 11:
+            cf = value>>(k.bits-1);
+            value = (value<<1)&mask;
+            break;
+        case 5: case 10:
+            cf = value&1;
+            value = (value>>1)|(value&(UINT64_C(1)<<(k.bits-1)));
+            break;
+        case 7: case 12:
+            cf = value&1;
+            value >>= 1;
+            break;
+        case 8:
+            cf = value>>(k.bits-1);
+            value = ((value<<1)|((source>>(k.bits-i-1))&1))&mask;
+            break;
+        case 9:
+            cf = value&1;
+            value = (value>>1)|(((source>>i)&1)<<(k.bits-1));
+            break;
+        case 13:
+            value = (value>>1)|((value&1)<<(k.bits-1));
+            break;
+        }
+    }
+    if (k.kind >= 10) {
+        *status = seed&k.flags;
+        return value;
+    }
+    if (count && k.kind < 4) {
+        if (k.kind == 2) cf = value&1;
+        if (k.kind == 3) cf = value>>(k.bits-1);
+        if (count == 1) {
+            of = k.kind == 0 || k.kind == 2 ? (value>>(k.bits-1))^cf :
+                ((value>>(k.bits-1))^(value>>(k.bits-2)))&1;
+        }
+    } else if (count) {
+        zf = value == 0;
+        sf = value>>(k.bits-1);
+        pf = (__builtin_popcount((uint8_t)value)&1) == 0;
+        if (count == 1) {
+            if (k.kind >= 8) of = (old^value)>>(k.bits-1);
+            else if (k.kind == 5) of = 0;
+            else if (k.kind == 7) of = old>>(k.bits-1);
+            else of = (value>>(k.bits-1))^cf;
+        }
+    }
+    *status = (cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7)|(of<<11))&k.flags;
+    return value;
+}
+
+int main(void) {
+    const uint64_t samples[] = {0,1,UINT64_MAX,UINT64_C(0x8000000080000000),
+        UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(0x8877665544332211)};
+    const uint64_t sentinel = UINT64_C(0xa7a7a7a7a7a7a7a7);
+    unsigned observations = 0;
+    for (unsigned kernel = 0; kernel < sizeof(kernels)/sizeof(kernels[0]); kernel++) {
+        const Kernel k = kernels[kernel];
+        for (unsigned n = 0; n < 256; n++) {
+            for (unsigned sample = 0; sample < 7; sample++) {
+                for (unsigned carry = 0; carry < 2; carry++) {
+                    unsigned offset = 32+(sample+n)%8;
+                    uint8_t memory[128], expected[128];
+                    uint64_t output[8], wanted[8];
+                    for (unsigned i = 0; i < 128; i++) memory[i] = i*37+91;
+                    for (unsigned b = 0; b < k.bits/8; b++) memory[offset+b] = samples[sample]>>(8*b);
+                    memcpy(expected,memory,sizeof(memory));
+                    for (unsigned i = 0; i < 8; i++) output[i] = wanted[i] = sentinel;
+                    word value = (word)samples[(sample+3)%7];
+                    word count = (word)(n|UINT64_C(0x1234567800000000));
+                    word seed = carry ? 0x8c7 : 0x12;
+                    uint64_t flags, result = reference(k,samples[sample],value,count,seed,&flags);
+                    uint64_t ax = value;
+                    if (k.kind >= 10) ax = result;
+                    else for (unsigned b = 0; b < k.bits/8; b++) expected[offset+b] = result>>(8*b);
+                    word status = (word)flags, resultWord = (word)ax;
+                    memcpy(wanted,&status,sizeof(word));
+                    memcpy(wanted+1,&resultWord,sizeof(word));
+                    memcpy(wanted+2,&count,sizeof(word));
+#ifdef ORIGINAL_NATIVE
+                    uint8_t originalMemory[128];
+                    uint64_t originalOutput[8];
+                    memcpy(originalMemory,memory,sizeof(memory));
+                    memcpy(originalOutput,output,sizeof(output));
+#endif
+                    k.fn(memory+offset-1,output,value,count,seed);
+                    if (memcmp(memory,expected,sizeof(memory)) || memcmp(output,wanted,sizeof(output))) {
+                        fprintf(stderr,"kernel%u bits%u kind%u count%u sample%u carry%u: memory/FLAGS/GP/canary mismatch\n",
+                            kernel,k.bits,k.kind,n,sample,carry);
+                        return 1;
+                    }
+#ifdef ORIGINAL_NATIVE
+                    originals[kernel](originalMemory+offset-1,originalOutput,value,count,seed);
+                    if (memcmp(originalMemory,expected,sizeof(memory)) || memcmp(originalOutput,wanted,sizeof(output))) {
+                        fprintf(stderr,"original kernel%u bits%u kind%u count%u sample%u carry%u mismatch\n",
+                            kernel,k.bits,k.kind,n,sample,carry);
+                        return 3;
+                    }
+#endif
+                    observations++;
+                }
+            }
+        }
+    }
+    if (observations != sizeof(kernels)/sizeof(kernels[0])*256*7*2) return 2;
+#ifdef ORIGINAL_NATIVE
+    if (check_faults()) return 4;
+#endif
+    printf("scalar shift memory observations %u\n",observations);
+    return 0;
+}
+`
diff --git a/x86_scalar_shift_memory_test.go b/x86_scalar_shift_memory_test.go
new file mode 100644
index 000000000..41f2dce5a
--- /dev/null
+++ b/x86_scalar_shift_memory_test.go
@@ -0,0 +1,320 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86ShiftMemoryOracle struct {
+	text        string
+	bits        int
+	readOnly    bool
+	valueChoice bool // W double shifts include ISA-unspecified low16 results.
+}
+
+// One memory witness per independently checked Go encoder row. This directory
+// does not use the production grammar or its numerical effect descriptor.
+func x86ScalarShiftMemoryRows(arch string) []x86ShiftMemoryOracle {
+	widths := []string{"B", "W", "L", "Q"}
+	if arch == "386" {
+		widths = widths[:3]
+	}
+	var rows []x86ShiftMemoryOracle
+	bits := map[string]int{"B": 8, "W": 16, "L": 32, "Q": 64}
+	for _, stem := range x86ScalarShiftTestStems {
+		for _, width := range widths {
+			counts := []string{"$1", "$0", "CX"}
+			if width != "B" {
+				counts = append(counts, "CL")
+			}
+			for _, count := range counts {
+				rows = append(rows, x86ShiftMemoryOracle{stem + width + " " + count + ",1(DI)", bits[width], false, false})
+			}
+		}
+	}
+	for _, stem := range []string{"SHL", "SHR"} {
+		for _, width := range widths[1:] {
+			for _, count := range []string{"$1", "CL", "CX"} {
+				rows = append(rows, x86ShiftMemoryOracle{stem + width + " " + count + ",AX,1(DI)",
+					bits[width], false, width == "W" && count != "$1"})
+			}
+		}
+	}
+	for _, stem := range []string{"SARX", "SHLX", "SHRX", "RORX"} {
+		for _, width := range []string{"L", "Q"} {
+			physical := bits[width]
+			if arch == "386" {
+				physical = 32 // VEX.W is ignored, including the memory width.
+			}
+			counts := []string{"CX"}
+			if stem == "RORX" {
+				counts = []string{"$255", "$-128"}
+			}
+			for _, count := range counts {
+				rows = append(rows, x86ShiftMemoryOracle{stem + width + " " + count + ",1(DI),AX", physical, true, false})
+			}
+		}
+	}
+	return rows
+}
+
+func x86ScalarShiftMemoryFixture(arch, instruction string, result bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	frame, tail := word*3, ""
+	declaration := "func Value(p *[32]byte,value,count uintptr)"
+	if result {
+		frame += 4
+		declaration += " uint32"
+		tail = fmt.Sprintf("MOVL AX,ret+%d(FP)\n", word*3)
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),DI\n%s value+%d(FP),AX\n%s count+%d(FP),CX\nCLC\n%s\n%sRET\n",
+		frame, move, move, word, move, word*2, instruction, tail), declaration
+}
+
+func TestX86ScalarShiftMemoryCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		rows := x86ScalarShiftMemoryRows(target.arch)
+		want := 148
+		if target.arch == "386" {
+			want = 110
+		}
+		if len(rows) != want {
+			t.Fatal("incomplete independent memory-form denominator", target.arch, len(rows), want)
+		}
+		for first := 0; first < len(rows); first += 80 {
+			last := first + 80
+			if last > len(rows) {
+				last = len(rows)
+			}
+			t.Run(fmt.Sprintf("%s/batch-%d", target.triple, first/80), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for index, row := range rows[first:last] {
+					assembly, declaration := x86ScalarShiftMemoryFixture(target.arch, row.text, true)
+					name := fmt.Sprint("Shift", first+index)
+					source.WriteString(strings.ReplaceAll(assembly, "Value", name))
+					declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Error("complete initialized memory family lacks its numerical continuation", api, err)
+						continue
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftMemoryEmitterRetainsExactAccess(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86ScalarShiftMemoryRows(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				ctx, output := newAMD64CtxWithFuncForTest(t, Func{Instrs: []Instr{ins}}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				ctx.blocks = []amd64Block{{instrs: []Instr{ins}}}
+				if _, err := ctx.lowerInstr(0, 0, ins, nil, nil); err != nil {
+					t.Fatal("valid format did not reach its actual emitter", err)
+				}
+				stores := 1
+				if row.readOnly {
+					stores = 0
+				}
+				ir := output.String()
+				if strings.Count(ir, fmt.Sprintf("load volatile i%d,", row.bits)) != 1 ||
+					strings.Count(ir, fmt.Sprintf("store volatile i%d ", row.bits)) != stores ||
+					strings.Contains(ir, "atomicrmw ") {
+					t.Error("memory shift lost an exact-width observable access, including count zero")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftMemoryVoidRequiresInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		for _, instruction := range []string{"SHLL CL,AX,1(DI)", "RCLL CX,1(DI)", "SARXL CX,1(DI),AX", "RORXL $0,1(DI),AX"} {
+			source, declaration := x86ScalarShiftMemoryFixture(arch, instruction, false)
+			variants := map[string]string{
+				"complete":          source,
+				"missing-address":   strings.Replace(source, move+" p+0(FP),DI\n", "", 1),
+				"numerical-address": strings.Replace(source, move+" p+0(FP),DI\n", "MOVL $1,DI\n", 1),
+			}
+			if !strings.HasPrefix(instruction, "RORX") {
+				variants["missing-count"] = strings.Replace(source, fmt.Sprintf("%s count+%d(FP),CX\n", move, word*2), "", 1)
+			}
+			if strings.HasPrefix(instruction, "SHLL") {
+				variants["missing-value"] = strings.Replace(source, fmt.Sprintf("%s value+%d(FP),AX\n", move, word), "", 1)
+			}
+			if strings.HasPrefix(instruction, "RCL") {
+				variants["missing-carry"] = strings.Replace(source, "CLC\n", "", 1)
+			}
+			for name, assembly := range variants {
+				t.Run(arch+"/"+instruction+"/"+name, func(t *testing.T) {
+					x86LEAActualTargetGoObject(t, arch, triple, assembly)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, assembly, declaration, arch, triple, api)
+						if name == "complete" || name == "numerical-address" && (strings.HasPrefix(instruction, "SARX") || strings.HasPrefix(instruction, "RORX")) {
+							if err != nil || ir == "" {
+								t.Error("initialized Void memory shift lost its paired effect", api, err)
+							}
+							if name == "numerical-address" {
+								if strings.Count(ir, "load volatile i32,") != 1 || strings.Contains(ir, "store volatile ") {
+									t.Fatal("BMI2 numerical source changed its read-only width")
+								}
+								x86RequireNumericNativeSourceContext(t, assembly, declaration, arch)
+								x86NumericNativeAddressObject(t, ir, triple)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("Void memory shift invented a missing numerical/address input", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86DoubleShiftOriginalConformanceObjects(t *testing.T) {
+	original, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, width := range []int{32, 64} {
+		name := fmt.Sprint("doubleShift", width)
+		start := strings.Index(string(original), "TEXT ·"+name+"(")
+		if start < 0 {
+			t.Fatal("original discovering function disappeared", name)
+		}
+		body := string(original[start:])
+		if next := strings.Index(body, "\nTEXT "); next >= 0 {
+			body = body[:next+1]
+		}
+		declaration := fmt.Sprintf("func %s(out *[8]uint%d, src, dst, amount uint%d)", name, width, width)
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(name+"/"+triple, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+body)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, body, declaration, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Error("unchanged discovering memory program failed", api, err)
+						continue
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarShiftMemoryContinuationBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarShiftMemoryRows(arch) {
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.text)
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				base, _, _ := x86ResultGP(DI, 4, arch)
+				value, _, _ := x86ResultGP(AX, 4, arch)
+				count, _, _ := x86ResultGP(CX, 4, arch)
+				state.pointerGP[base] = true
+				state.gp[value], state.gp[count] = 0xff, 0xff
+				for _, consumer := range x86ResultGPSIMDConsumers {
+					standalone := state.clone()
+					if consumer.step(ins, &standalone, nil, 0, arch) {
+						t.Fatal("standalone numerical observer borrowed a native continuation")
+					}
+				}
+				complete := state.clone()
+				accepted, known := x86LoweredScalarShiftMemory(ins, &complete, nil, 0, arch)
+				if !known || !accepted {
+					t.Fatal("paired initialized shift lost its finite ISA outcome", accepted, known)
+				}
+				if complete.gp != state.gp || complete.pointerGP != state.pointerGP {
+					t.Fatal("native shift created unrelated GP or pointer facts")
+				}
+				for _, mutation := range []string{"missing-address", "numerical-address", "pointer-count", "missing-count",
+					"encoded", "raw", "return", "address-size", "unbound-address", "segment"} {
+					changed, rejected := ins, state.clone()
+					switch mutation {
+					case "missing-address":
+						rejected.pointerGP[base] = false
+					case "numerical-address":
+						rejected.pointerGP[base], rejected.gp[base] = false, 0xff
+					case "pointer-count", "missing-count":
+						if ins.Args[0].Kind != OpReg {
+							continue
+						}
+						rejected.gp[count] = 0
+						rejected.pointerGP[count] = mutation == "pointer-count"
+					case "encoded":
+						changed.x86Encoded = true
+					case "raw":
+						changed.x86SourceRaw = new(x86SourceRawInstruction)
+					case "return":
+						changed.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "address-size":
+						changed.x86AddressBits = 32
+					case "unbound-address":
+						changed.x86UnboundAddressOverride = true
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					}
+					before := rejected.clone()
+					accepted, known := x86LoweredScalarShiftMemory(changed, &rejected, nil, 0, arch)
+					if mutation == "numerical-address" && row.readOnly {
+						if !accepted || !known || !reflect.DeepEqual(rejected, before) {
+							t.Fatal("BMI2 NUM source changed unrelated input/status roles")
+						}
+						source, declaration := x86ScalarShiftMemoryFixture(arch, row.text, true)
+						move := "MOVQ"
+						if arch == "386" {
+							move = "MOVL"
+						}
+						source = strings.Replace(source, move+" p+0(FP),DI", "MOVL $7,DI", 1)
+						triple := x86AddressMemoryTargets(arch)[0]
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+							if err != nil || strings.Count(ir, fmt.Sprintf("load volatile i%d,", row.bits)) != 1 {
+								t.Fatal("BMI2 lost its exact NUM-address source read", api, err)
+							}
+							x86RequireNumericNativeSourceContext(t, source, declaration, arch)
+							x86NumericNativeAddressObject(t, ir, triple)
+						}
+					} else if accepted || !reflect.DeepEqual(rejected, before) {
+						t.Fatal("missing source or foreign role acquired effects", mutation)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_scalar_shift_objects_test.go b/x86_scalar_shift_objects_test.go
new file mode 100644
index 000000000..7b490a350
--- /dev/null
+++ b/x86_scalar_shift_objects_test.go
@@ -0,0 +1,133 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarShiftOriginalPhysicalByteWitnesses(t *testing.T) {
+	for _, test := range []struct {
+		arch, row string
+		code      []byte
+	}{
+		{"amd64", "SHRQ $5,R8", []byte{0x49, 0xc1, 0xe8, 5}},
+		{"amd64", "SHLL $0,AX", []byte{0xc1, 0xe0, 0}},
+		{"amd64", "RCLL $0,AX", []byte{0xc1, 0xd0, 0}},
+		{"amd64", "SHLB $1,AH", []byte{0xd0, 0xe4}},
+		{"amd64", "SHLB CX,AH", []byte{0xd2, 0xe4}},
+		{"amd64", "SHLW $16,BX,AX", []byte{0x66, 0x0f, 0xa4, 0xd8, 16}},
+		{"amd64", "SHRW $16,BX,AX", []byte{0x66, 0x0f, 0xac, 0xd8, 16}},
+		{"386", "SHLL $0,AX", []byte{0xc1, 0xe0, 0}},
+		{"386", "SHLW CL,BX,AX", []byte{0x66, 0x0f, 0xa5, 0xd8}},
+	} {
+		t.Run(test.arch+"/"+test.row, func(t *testing.T) {
+			code := assembleX87ControlBytes(t, test.arch, "TEXT f(SB),4,$0-0\n"+test.row+"\nRET\n")
+			if !bytes.Equal(code, append(append([]byte(nil), test.code...), 0xc3)) {
+				t.Fatalf("actual Go bytes%x want%x", code, test.code)
+			}
+			decoded, err := decodeX86RawDirectives(rawX86Function(test.code), test.arch)
+			if err != nil || len(decoded.Instrs) != 1 {
+				t.Fatalf("actual source byte decoder %v %+v", err, decoded)
+			}
+			ins := decoded.Instrs[0]
+			// A CL count and a W double-shift variable count still have their
+			// numerical obligations; decoding does not grant initialized bytes.
+			undefined := test.arch == "386" && test.row == "SHLW CL,BX,AX"
+			for _, consumer := range x86ResultGPSIMDConsumers {
+				state := x86ResultState{flags: x86ByteFlagsAll}
+				for index := range state.gp {
+					state.gp[index] = 0xff
+				}
+				if got := consumer.step(ins, &state, nil, 0, test.arch); got == undefined {
+					t.Fatalf("%s physical source accepted%t undefined%t", consumer.name, got, undefined)
+				}
+			}
+		})
+	}
+}
+
+func TestX86ScalarShiftThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ, widths := 8, "MOVQ", "uint64", []string{"B", "W", "L", "Q"}
+			if target.arch == "386" {
+				word, move, typ, widths = 4, "MOVL", "uint32", widths[:3]
+			}
+			for _, raw := range []bool{false, true} {
+				t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+					var body strings.Builder
+					fmt.Fprintf(&body, "%s x+0(FP),AX\n%s y+%d(FP),BX\n%s count+%d(FP),CX\n", move, move, word, move, 2*word)
+					emit := func(row string) {
+						fmt.Fprintf(&body, "CMP%s AX,BX\n", map[string]string{"amd64": "Q", "386": "L"}[target.arch])
+						if !raw {
+							body.WriteString(row + "\n")
+							return
+						}
+						code := assembleX87ControlBytes(t, target.arch, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+						if len(code) == 0 || code[len(code)-1] != 0xc3 {
+							t.Fatal("original instruction object lacks RET")
+						}
+						for _, b := range code[:len(code)-1] {
+							fmt.Fprintf(&body, "BYTE $%#x\n", b)
+						}
+					}
+					for _, stem := range x86ScalarShiftTestStems {
+						for _, width := range widths {
+							for _, count := range []string{"$0", "$1", "$255", "CL", "CX"} {
+								emit(stem + width + " " + count + ",AX")
+							}
+							if width == "B" {
+								emit(stem + width + " $1,AH")
+							}
+						}
+					}
+					for _, stem := range []string{"SHL", "SHR"} {
+						for _, width := range widths[1:] {
+							counts := []string{"$0", "$1", "$16", "CL", "CX"}
+							if width == "W" {
+								counts = counts[:3]
+							}
+							for _, count := range counts {
+								emit(stem + width + " " + count + ",BX,AX")
+							}
+						}
+					}
+					for _, op := range []string{"SARXL", "SARXQ", "SHLXL", "SHLXQ", "SHRXL", "SHRXQ", "RORXL", "RORXQ"} {
+						if strings.HasPrefix(op, "RORX") {
+							emit(op + " $-128,BX,AX")
+						} else {
+							emit(op + " CX,BX,AX")
+						}
+					}
+					fmt.Fprintf(&body, "%s AX,X0\nVPEXTRQ $0,X0,BX\n%s BX,ret0+%d(FP)\nRET", move, move, 3*word)
+					pkg, file, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x,y,count "+typ+") "+typ, body.String())
+					goAssemblerOracleOutput(t, target.arch, source, "", true)
+					// Named source is checked directly. Raw APIs independently
+					// consume the complete original object bytes before checking.
+					if !raw {
+						for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+							if err := check(file.Funcs[0], sig, target.arch); err != nil {
+								t.Fatal(err)
+							}
+						}
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ResultSwapTranslateAPI(t, api, source, pkg, target.arch, target.triple)
+							if err != nil {
+								t.Fatal(err)
+							}
+							x86ResultInitializationObject(t, llc, target.triple, ir, "scalar-shift-"+api)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_scalar_shift_outcomes.go b/x86_scalar_shift_outcomes.go
new file mode 100644
index 000000000..dc5079165
--- /dev/null
+++ b/x86_scalar_shift_outcomes.go
@@ -0,0 +1,66 @@
+package plan9asm
+
+import "fmt"
+
+// This producer-specific descriptor distinguishes a finite architectural
+// choice from an unavailable source. It is consumed only by the paired
+// lowerer, after all actual data, count, carry and address inputs validate.
+// flagsChoice is descriptive, not permission derived from flagsKilled.
+type x86ScalarShiftOutcome struct {
+	flagsFromOld uint8
+	flagsFinite  uint8
+	flagsChoice  uint8
+	valueChoice  bool
+}
+
+func (f x86ScalarShiftForm) outcome() x86ScalarShiftOutcome {
+	out := x86ScalarShiftOutcome{flagsFromOld: x86ByteFlagsAll}
+	count, variable := f.maskedCount(), f.count.Kind == OpReg
+	if f.bmi2 || !variable && count == 0 {
+		return out
+	}
+	rotate := f.stem == "RCL" || f.stem == "RCR" || f.stem == "ROL" || f.stem == "ROR"
+	if rotate {
+		carry := f.stem == "RCL" || f.stem == "RCR"
+		if !variable && carry && count%int64(f.bits+1) == 0 {
+			return out // A zero-bit carry rotate retains every old flag.
+		}
+		if variable || count != 1 {
+			out.flagsChoice = x86ByteFlagOF
+		}
+		if !variable {
+			out.flagsFinite = x86ByteFlagCF | x86ByteFlagOF
+			out.flagsFromOld &^= out.flagsFinite
+		}
+		return out
+	}
+	out.flagsChoice = x86ByteFlagAF
+	if variable || count != 1 {
+		out.flagsChoice |= x86ByteFlagOF
+	}
+	if f.double && f.bits == 16 && (variable || count > 16) {
+		out.valueChoice, out.flagsChoice = true, x86ByteFlagsAll
+	} else if !f.double && f.bits < 32 && f.stem != "SAR" && (variable || count >= int64(f.bits)) {
+		out.flagsChoice |= x86ByteFlagCF
+	}
+	if !variable {
+		out.flagsFromOld, out.flagsFinite = 0, x86ByteFlagsAll
+	}
+	// A variable count can be zero. Even if every nonzero arm defines a
+	// finite flag, its zero-count arm still needs that actual old flag.
+	return out
+}
+
+func (out x86ScalarShiftOutcome) availableFlags(before uint8) uint8 {
+	return before&out.flagsFromOld | out.flagsFinite
+}
+
+// Freeze only a selected ISA-undefined output, once at its producer. The
+// guarded consumer retains its original zero/defined arms; no missing input,
+// unwritten byte, pointer, native flag or CFG-joined poison is frozen here.
+func (c *amd64Ctx) emitScalarShiftArchitecturalChoice(typ LLVMType, when, otherwise string) string {
+	choice, selected := c.newTmp(), c.newTmp()
+	fmt.Fprintf(c.b, "  %%%s = freeze %s poison\n", choice, typ)
+	fmt.Fprintf(c.b, "  %%%s = select i1 %s, %s %%%s, %s %s\n", selected, when, typ, choice, typ, otherwise)
+	return "%" + selected
+}
diff --git a/x86_scalar_shift_pointer_entry_shape_test.go b/x86_scalar_shift_pointer_entry_shape_test.go
new file mode 100644
index 000000000..74eb31a74
--- /dev/null
+++ b/x86_scalar_shift_pointer_entry_shape_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Keep the SDK's complete diff8 numerical tail, including its original scan,
+// shift, mask and result mapping. This is not a new caller/aggregate contract.
+const x86CompareDiff8ShiftTail = `BSWAPQ AX
+BSWAPQ CX
+XORQ AX,CX
+BSRQ CX,CX
+SHRQ CX,AX
+ANDQ $1,AX
+LEAQ -1(AX*2),AX
+RET
+`
+
+func x86CompareShiftRegisterSource(t *testing.T, declaration, body string) string {
+	t.Helper()
+	source := x86ResultGPSIMDAdmissionSource(t, "amd64", declaration, body)
+	return strings.Replace(source, "·view(SB)", "·view<ABIInternal>(SB)", 1)
+}
+
+func TestAMD64ScalarShiftPointerEntryOverwriteDoesNotPolluteSourceShape(t *testing.T) {
+	original, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "internal", "bytealg", "compare_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	canonical := func(source string) string {
+		var lines []string
+		for _, line := range strings.Split(source, "\n") {
+			line, _, _ = strings.Cut(line, "//")
+			if fields := strings.Fields(line); len(fields) != 0 {
+				lines = append(lines, strings.Join(fields, ""))
+			}
+		}
+		return strings.Join(lines, "\n")
+	}
+	if !strings.Contains(canonical(string(original)), canonical(x86CompareDiff8ShiftTail)) {
+		t.Fatal("the unchanged complete SDK diff8 shift/result sequence differs")
+	}
+
+	for _, row := range []struct{ name, declaration, body string }{
+		{"value-native-overwrite", "func view(data *uint64,count uint64) uint64\n",
+			"MOVQ (AX),AX\nMOVQ BX,CX\nSHRQ CX,AX"},
+		{"value-immediate-overwrite", "func view(data *uint64,count uint64) uint64\n",
+			"MOVQ $0x1122334455667788,AX\nMOVQ BX,CX\nSHRQ CX,AX"},
+		{"count-native-overwrite", "func view(value,unused uint64,count *uint64) uint64\n",
+			"MOVQ (CX),CX\nSHRQ CX,AX"},
+		{"diff8-native-overwrite", "func view(a,b *uint64) int64\n",
+			"MOVQ AX,SI\nMOVQ BX,DI\nMOVQ (SI),AX\nMOVQ (DI),CX\nCMPQ AX,CX\nJEQ same\n" +
+				x86CompareDiff8ShiftTail + "same:\nXORQ AX,AX"},
+		{"diff8-numerical-control", "func view(a,b uint64) int64\n",
+			"MOVQ BX,CX\nCMPQ AX,CX\nJEQ same\n" + x86CompareDiff8ShiftTail + "same:\nXORQ AX,AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := x86CompareShiftRegisterSource(t, row.declaration, row.body)
+			// The reaching source explicitly replaces the original opaque
+			// entry register. An independent source-shape check must not
+			// mistake that stale entry role for the instruction's live role.
+			x86ResultGPSIMDAdmissionAPIs(t, "amd64", source, row.declaration, true)
+		})
+	}
+}
+
+func TestAMD64ScalarShiftSourceShapeDoesNotSupplyReachingNUMOrFlags(t *testing.T) {
+	for _, row := range []struct{ name, declaration, body string }{
+		{"pointer-is-not-value", "func view(data *uint64,count uint64) uint64\n",
+			"MOVQ BX,CX\nSHRQ CX,AX"},
+		{"pointer-is-not-count", "func view(value,unused uint64,count *uint64) uint64\n",
+			"SHRQ CX,AX"},
+		{"partial-native-value", "func view(data *uint64,count uint64) uint64\n",
+			"MOVB (AX),AL\nMOVQ BX,CX\nSHRQ CX,AX"},
+		{"missing-count-byte", "func view(data *uint64,count uint64) uint64\n",
+			"MOVQ (AX),AX\nMOVB R12,CL\nSHRQ CX,AX"},
+		{"scan-does-not-define-carry", "func view(value,count uint64) uint64\n",
+			"MOVQ BX,CX\nBSRQ CX,CX\nRCRQ CX,AX"},
+		{"scan-carry-cannot-be-observed", "func view(value,count uint64) uint64\n",
+			"MOVQ BX,CX\nBSRQ CX,CX\nSETCS DL\nSHRQ CX,AX"},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			source := x86CompareShiftRegisterSource(t, row.declaration, row.body)
+			x86ResultGPSIMDAdmissionAPIs(t, "amd64", source, row.declaration, false)
+		})
+	}
+}
diff --git a/x86_scalar_shift_runtime_test.go b/x86_scalar_shift_runtime_test.go
new file mode 100644
index 000000000..cda2b34e0
--- /dev/null
+++ b/x86_scalar_shift_runtime_test.go
@@ -0,0 +1,221 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ScalarShiftNumericalRule struct {
+	row                                          string
+	bits, kind, destination, source, count, high int
+}
+
+func x86ScalarShiftNumericalRules() []x86ScalarShiftNumericalRule {
+	var rules []x86ScalarShiftNumericalRule
+	for kind, stem := range x86ScalarShiftTestStems {
+		for _, width := range []struct {
+			suffix string
+			bits   int
+		}{{"B", 8}, {"W", 16}, {"L", 32}, {"Q", 64}} {
+			for _, count := range []string{"CL", "CX"} {
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " " + count + ",AX", bits: width.bits, kind: kind, count: 2})
+			}
+			if width.bits == 8 {
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + "B CL,AH", bits: 8, kind: kind, count: 2, high: 1})
+			}
+			// Immediate zero is a distinct physical encoding and still writes
+			// r32's upper half, even though all flags remain unchanged.
+			rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " $0,AX", bits: width.bits, kind: kind, count: -1})
+		}
+	}
+	for _, width := range []struct {
+		suffix string
+		bits   int
+	}{{"W", 16}, {"L", 32}, {"Q", 64}} {
+		for kind, stem := range []string{"SHL", "SHR"} {
+			for _, count := range []string{"CL", "CX"} {
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " " + count + ",BX,AX", bits: width.bits, kind: 8 + kind, source: 1, count: 2})
+			}
+			rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " CL,AX,AX", bits: width.bits, kind: 8 + kind, count: 2})
+		}
+	}
+	for kind, stem := range []string{"SARX", "SHLX", "SHRX", "RORX"} {
+		for _, width := range []struct {
+			suffix string
+			bits   int
+		}{{"L", 32}, {"Q", 64}} {
+			if stem == "RORX" {
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " $1,BX,AX", bits: width.bits, kind: 10 + kind, source: 1, count: -2})
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " $0,AX,AX", bits: width.bits, kind: 10 + kind, count: -1})
+				continue
+			}
+			for _, axes := range []struct {
+				pair                       string
+				destination, source, count int
+			}{{"CX,BX,AX", 0, 1, 2}, {"AX,BX,AX", 0, 1, 0}, {"CX,CX,CX", 2, 2, 2}} {
+				rules = append(rules, x86ScalarShiftNumericalRule{row: stem + width.suffix + " " + axes.pair, bits: width.bits, kind: 10 + kind, destination: axes.destination, source: axes.source, count: axes.count})
+			}
+		}
+	}
+	return rules
+}
+
+func x86ScalarShiftNumericalSource(t *testing.T, raw bool) (string, string, string, string) {
+	t.Helper()
+	var decl, asm, names, metadata strings.Builder
+	for index, rule := range x86ScalarShiftNumericalRules() {
+		name := fmt.Sprint("shift", index)
+		fmt.Fprintf(&decl, "func %s(out *[64]byte,x,y,count uint64)\n", name)
+		fmt.Fprintf(&asm, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),R10\nMOVQ x+8(FP),AX\nMOVQ y+16(FP),BX\nMOVQ count+24(FP),CX\nSTMXCSR 32(R10)\nCMPQ AX,BX\n", name)
+		emitX86GoEncodedTestInstruction(t, &asm, rule.row, raw)
+		asm.WriteString("MOVQ AX,0(R10)\nMOVQ BX,8(R10)\nMOVQ CX,16(R10)\nSETCS 24(R10)\nSETEQ 25(R10)\nSETMI 26(R10)\nSETOS 27(R10)\nLAHF\nMOVB AH,DL\nMOVB DL,28(R10)\nSTMXCSR 36(R10)\nRET\n")
+		fmt.Fprintf(&names, "%s,", name)
+		fmt.Fprintf(&metadata, "{%d,%d,%d,%d,%d,%d},\n", rule.bits, rule.kind, rule.destination, rule.source, rule.count, rule.high)
+	}
+	return decl.String(), asm.String(), names.String(), metadata.String()
+}
+
+func TestX86ScalarShiftOriginalGoNumericalFlagsCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	declaration, source, names, metadata := x86ScalarShiftNumericalSource(t, false)
+	driver := strings.ReplaceAll(x86ScalarShiftOriginalGoDriver, "FUNCTIONS", names)
+	driver = strings.ReplaceAll(driver, "METADATA", metadata)
+	x86WordMultiplyRunOriginalGo(t, execution, "package wordmultiply\n"+declaration, source, driver)
+	t.Log("original Go physical legacy/BMI2 value, flags, full GP upper aliases, guards and MXCSR; undefined bits are not compared; Rosetta is not native Linux")
+}
+
+func TestX86ScalarShiftDoubleWordCount16LLVM(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, op := range []string{"SHLW", "SHRW"} {
+		t.Run(op, func(t *testing.T) {
+			source := "TEXT ·Word(SB),4,$0-24\nMOVQ out+0(FP),R10\nMOVQ x+8(FP),AX\nMOVQ y+16(FP),BX\n" + op + " $16,BX,AX\nMOVQ AX,0(R10)\nRET\n"
+			ir, err := x86ScalarFPBitViewAPI(t, source, "func Word(out *[64]byte,x,y uint64)", "amd64", execution.triple, "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			main := `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern void Word(uint8_t*,uint64_t,uint64_t);
+int main(void) {
+ uint8_t out[64]={0};
+ Word(out,UINT64_C(0x1122334455661234),UINT64_C(0x887766554433abcd));
+ uint64_t got; memcpy(&got,out,8);
+ if(got!=UINT64_C(0x112233445566abcd)) {fprintf(stderr,"defined count16: got%llx want112233445566abcd\n",(unsigned long long)got);return 1;}
+ puts("DOUBLE_WORD_DEFINED_COUNT16_PASS");return 0;
+}`
+			execution.compileAndRunLLVM(t, "defined-double-word", ir, main, "-O0")
+		})
+	}
+}
+
+func TestX86ScalarShiftLLVMNumericalFlagsCanaries(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	for _, raw := range []bool{false, true} {
+		t.Run(fmt.Sprintf("raw=%t", raw), func(t *testing.T) {
+			declaration, source, _, _ := x86ScalarShiftNumericalSource(t, raw)
+			var prototypes, rows strings.Builder
+			for index, rule := range x86ScalarShiftNumericalRules() {
+				fmt.Fprintf(&prototypes, "extern void shift%d(uint8_t*,uint64_t,uint64_t,uint64_t);\n", index)
+				fmt.Fprintf(&rows, "{shift%d,%d,%d,%d,%d,%d,%d},\n", index, rule.bits, rule.kind, rule.destination, rule.source, rule.count, rule.high)
+			}
+			main := strings.ReplaceAll(x86ScalarShiftLLVMDriver, "PROTOTYPES", prototypes.String())
+			main = strings.ReplaceAll(main, "ROWS", rows.String())
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, "Go")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("IR_default_O2=%t", optimized), func(t *testing.T) {
+					text := ir
+					if optimized {
+						text = x86MulDivRoundOptimize(t, text)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						t.Run("backend"+level, func(t *testing.T) {
+							output := execution.compileAndRunLLVM(t, "scalar-shift", text, main, level)
+							if !strings.Contains(string(output), "LLVM_SCALAR_SHIFT_NUMERICAL_FLAGS_GUARDS_MXCSR_PASS") {
+								t.Fatal(string(output))
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+const x86ScalarShiftOriginalGoDriver = `package wordmultiply
+import("encoding/binary";"fmt";"math/bits";"testing";"unsafe")
+func TestOriginal(t *testing.T) {
+ functions:=[]func(*[64]byte,uint64,uint64,uint64){FUNCTIONS}
+ rules:=[]struct{bits,kind,destination,source,count,high int}{METADATA}
+ samples:=[]uint64{0,1,^uint64(0),0x8000000080000000,0x0123456789abcdef,0xfedcba9876543210,0x8877665544332211}
+ observations:=0
+ for k,program:=range functions { r:=rules[k]
+  for n:=uint64(0);n<256;n++ { for s,x:=range samples {y:=samples[(s+3)%len(samples)];words:=[3]uint64{x,y,n|0x1234567800000000};d:=x-y
+   cf,zf,sf,of,pf,af:=x<y,x==y,d>>63!=0,((x^y)&(x^d))>>63!=0,bits.OnesCount8(byte(d))%2==0,(x^y^d)&16!=0
+   mask:=^uint64(0);if r.bits<64 {mask=(uint64(1)<<uint(r.bits))-1};v:=(words[r.destination]>>uint(r.high*8))&mask;src:=words[r.source]&mask
+   count:=uint64(0);if r.count>=0 {count=words[r.count]} else if r.count==-2 {count=1};count&=31;if r.bits==64 {if r.count>=0 {count=words[r.count]&63}}
+   flagmask:=byte(63);definedValue:=true;old:=v
+   if r.kind>=10 {v=src;if r.kind==13 {for i:=uint64(0);i<count;i++ {v=(v>>1)|((v&1)<<uint(r.bits-1))}} else {for i:=uint64(0);i<count;i++ {switch r.kind {case 10:v=(v>>1)|(v&(uint64(1)<<uint(r.bits-1)));case 11:v=(v<<1)&mask;case 12:v>>=1}}}
+   } else if r.kind>=8 {if count>uint64(r.bits) {definedValue=false;flagmask=0} else if count!=0 {for i:=uint64(0);i<count;i++ {if r.kind==8 {cf=v>>uint(r.bits-1)!=0;v=((v<<1)|((src>>uint(r.bits-int(i)-1))&1))&mask} else {cf=v&1!=0;v=(v>>1)|(((src>>i)&1)<<uint(r.bits-1))}};zf=v==0;sf=v>>uint(r.bits-1)!=0;pf=bits.OnesCount8(byte(v))%2==0;flagmask&^=4;if count==1 {of=(old^v)>>uint(r.bits-1)!=0} else {flagmask&^=32}}
+   } else if count!=0 {effective:=count;if r.kind<2&&(r.bits==8||r.bits==16) {effective%=uint64(r.bits+1)} else if r.kind==2||r.kind==3 {effective%=uint64(r.bits)}
+    for i:=uint64(0);i<effective;i++ {switch r.kind {case 0:next:=v>>uint(r.bits-1)!=0;v=(v<<1)&mask;if cf {v|=1};cf=next;case 1:next:=v&1!=0;v>>=1;if cf {v|=uint64(1)<<uint(r.bits-1)};cf=next;case 2:cf=v>>uint(r.bits-1)!=0;v=((v<<1)|bool64(cf))&mask;case 3:cf=v&1!=0;v=(v>>1)|(bool64(cf)<<uint(r.bits-1));case 4,6:cf=v>>uint(r.bits-1)!=0;v=(v<<1)&mask;case 5:cf=v&1!=0;v=(v>>1)|(v&(uint64(1)<<uint(r.bits-1)));case 7:cf=v&1!=0;v>>=1}}
+    if r.kind<4 {if r.kind==2 {cf=v&1!=0};if r.kind==3 {cf=v>>uint(r.bits-1)!=0};if count==1 {if r.kind==0||r.kind==2 {of=(v>>uint(r.bits-1)!=0)!=cf} else {of=((v>>uint(r.bits-1))^(v>>uint(r.bits-2)))&1!=0}} else {flagmask&^=32}
+    } else {zf=v==0;sf=v>>uint(r.bits-1)!=0;pf=bits.OnesCount8(byte(v))%2==0;flagmask&^=4;if (r.kind==4||r.kind==6||r.kind==7)&&count>=uint64(r.bits) {flagmask&^=1};if count==1 {switch r.kind {case 4,6:of=(v>>uint(r.bits-1)!=0)!=cf;case 5:of=false;case 7:of=old>>uint(r.bits-1)!=0}} else {flagmask&^=32}}
+   }
+   var packet,want [80]byte;for i:=range packet {packet[i]=byte(i*37+91)};want=packet
+   words[r.destination]=(words[r.destination]&^(mask<<uint(r.high*8)))|(v<<uint(r.high*8));if r.bits==32 {words[r.destination]&=0xffffffff}
+   for i,v:=range words {binary.LittleEndian.PutUint64(want[8+8*i:],v)}
+   values:=[]bool{cf,zf,sf,of};for i,v:=range values {want[32+i]=byte(bool64(v))};want[36]=2|byte(bool64(cf))|byte(bool64(pf)<<2)|byte(bool64(af)<<4)|byte(bool64(zf)<<6)|byte(bool64(sf)<<7)
+   program((*[64]byte)(unsafe.Pointer(&packet[8])),x,y,n|0x1234567800000000)
+   if !definedValue {for b:=0;b<r.bits/8;b++ {want[8+8*r.destination+r.high+b]=packet[8+8*r.destination+r.high+b]}}
+   for i,bit:=range []byte{1,8,16,32} {if flagmask&bit==0 {want[32+i]=packet[32+i]}}
+   lahfmask:=byte(2);for i,bit:=range []byte{1,2,4,8,16} {if flagmask&bit!=0 {lahfmask|=[]byte{1,4,16,64,128}[i]}};want[36]=(want[36]&lahfmask)|(packet[36]&^lahfmask)
+   before,after:=binary.LittleEndian.Uint32(packet[40:44]),binary.LittleEndian.Uint32(packet[44:48]);if before!=after {t.Fatal("MXCSR changed")};copy(want[40:48],packet[40:48])
+   if packet!=want {t.Fatalf("kernel%d %v sample%d count%d got%x want%x",k,r,s,n,packet,want)};observations++
+  }}
+ }
+ if observations!=len(functions)*256*7 {t.Fatal("incomplete numerical denominator")};fmt.Println("ORIGINAL_SCALAR_SHIFT_NUMERICAL_FLAGS_GUARDS_MXCSR_PASS",observations)
+}
+func bool64(v bool)uint64 {if v{return 1};return 0}
+`
+
+const x86ScalarShiftLLVMDriver = `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+PROTOTYPES
+typedef struct {void(*program)(uint8_t*,uint64_t,uint64_t,uint64_t);unsigned bits,kind,destination,source;int count;unsigned high;} rule;
+static const rule rules[]={ROWS};
+int main(void) {
+ const uint64_t samples[]={0,1,UINT64_MAX,UINT64_C(0x8000000080000000),UINT64_C(0x0123456789abcdef),UINT64_C(0xfedcba9876543210),UINT64_C(0x8877665544332211)};
+ unsigned observations=0;
+ for(unsigned k=0;k<sizeof(rules)/sizeof(rules[0]);k++) {const rule r=rules[k];
+  for(unsigned n=0;n<256;n++) for(unsigned s=0;s<7;s++) {uint64_t x=samples[s],y=samples[(s+3)%7],words[]={x,y,n|UINT64_C(0x1234567800000000)},d=x-y;
+   unsigned cf=x<y,zf=x==y,sf=d>>63,of=((x^y)&(x^d))>>63,pf=(__builtin_popcount((uint8_t)d)&1)==0,af=((x^y^d)&16)!=0;
+   uint64_t mask=r.bits==64?UINT64_MAX:(UINT64_C(1)<<r.bits)-1,v=(words[r.destination]>>(r.high*8))&mask,src=words[r.source]&mask,old=v;
+   unsigned count=r.count>=0?words[r.count]:r.count==-2?1:0;count&=r.bits==64?63:31;
+   unsigned flagmask=63,definedValue=1;
+   if(r.kind>=10) {v=src;for(unsigned i=0;i<count;i++) {switch(r.kind) {case 10:v=(v>>1)|(v&(UINT64_C(1)<<(r.bits-1)));break;case 11:v=(v<<1)&mask;break;case 12:v>>=1;break;case 13:v=(v>>1)|((v&1)<<(r.bits-1));break;}}
+   } else if(r.kind>=8) {if(count>r.bits) {definedValue=0;flagmask=0;} else if(count) {for(unsigned i=0;i<count;i++) {if(r.kind==8) {cf=v>>(r.bits-1);v=((v<<1)|((src>>(r.bits-i-1))&1))&mask;} else {cf=v&1;v=(v>>1)|(((src>>i)&1)<<(r.bits-1));}};zf=v==0;sf=v>>(r.bits-1);pf=(__builtin_popcount((uint8_t)v)&1)==0;flagmask&=~4;if(count==1) of=(old^v)>>(r.bits-1);else flagmask&=~32;}
+   } else if(count) {unsigned effective=count;if(r.kind<2&&(r.bits==8||r.bits==16)) effective%=r.bits+1;else if(r.kind==2||r.kind==3) effective%=r.bits;
+    for(unsigned i=0;i<effective;i++) {unsigned next;switch(r.kind) {case 0:next=v>>(r.bits-1);v=((v<<1)|cf)&mask;cf=next;break;case 1:next=v&1;v=(v>>1)|((uint64_t)cf<<(r.bits-1));cf=next;break;case 2:cf=v>>(r.bits-1);v=((v<<1)|cf)&mask;break;case 3:cf=v&1;v=(v>>1)|((uint64_t)cf<<(r.bits-1));break;case 4:case 6:cf=v>>(r.bits-1);v=(v<<1)&mask;break;case 5:cf=v&1;v=(v>>1)|(v&(UINT64_C(1)<<(r.bits-1)));break;case 7:cf=v&1;v>>=1;break;}}
+    if(r.kind<4) {if(r.kind==2) cf=v&1;if(r.kind==3) cf=v>>(r.bits-1);if(count==1) {if(r.kind==0||r.kind==2) of=(v>>(r.bits-1))^cf;else of=((v>>(r.bits-1))^(v>>(r.bits-2)))&1;} else flagmask&=~32;
+    } else {zf=v==0;sf=v>>(r.bits-1);pf=(__builtin_popcount((uint8_t)v)&1)==0;flagmask&=~4;if((r.kind==4||r.kind==6||r.kind==7)&&count>=r.bits) flagmask&=~1;if(count==1) {switch(r.kind) {case 4:case 6:of=(v>>(r.bits-1))^cf;break;case 5:of=0;break;case 7:of=old>>(r.bits-1);break;}} else flagmask&=~32;}
+   }
+   uint8_t packet[80],want[80];for(unsigned i=0;i<80;i++) packet[i]=(uint8_t)(i*37+91);memcpy(want,packet,80);
+   words[r.destination]=(words[r.destination]&~(mask<<(r.high*8)))|(v<<(r.high*8));if(r.bits==32) words[r.destination]&=UINT32_MAX;memcpy(want+8,words,24);
+   want[32]=cf;want[33]=zf;want[34]=sf;want[35]=of;want[36]=2|cf|(pf<<2)|(af<<4)|(zf<<6)|(sf<<7);
+   uint32_t csr0,csr1;__asm__ volatile("stmxcsr %0":"=m"(csr0));r.program(packet+8,x,y,n|UINT64_C(0x1234567800000000));__asm__ volatile("stmxcsr %0":"=m"(csr1));
+   if(!definedValue) for(unsigned b=0;b<r.bits/8;b++) want[8+8*r.destination+r.high+b]=packet[8+8*r.destination+r.high+b];
+   const unsigned bits[]={1,8,16,32};for(unsigned i=0;i<4;i++) if(!(flagmask&bits[i])) want[32+i]=packet[32+i];
+   const unsigned lahfbits[]={1,4,16,64,128};unsigned lahfmask=2;for(unsigned i=0;i<5;i++) if(flagmask&(1<<i)) lahfmask|=lahfbits[i];want[36]=(want[36]&lahfmask)|(packet[36]&~lahfmask);
+   uint32_t before,after;memcpy(&before,packet+40,4);memcpy(&after,packet+44,4);if(before!=csr0||after!=csr0||csr1!=csr0) {fprintf(stderr,"kernel%u MXCSR changed\n",k);return 1;}memcpy(want+40,packet+40,8);
+   if(memcmp(packet,want,80)) {for(unsigned i=0;i<80;i++) if(packet[i]!=want[i]) fprintf(stderr,"kernel%u kind%u bits%u count%u sample%u byte%u got%x want%x\n",k,r.kind,r.bits,n,s,i,packet[i],want[i]);return 1;}observations++;
+  }
+ }
+ if(observations!=sizeof(rules)/sizeof(rules[0])*256*7) return 1;puts("LLVM_SCALAR_SHIFT_NUMERICAL_FLAGS_GUARDS_MXCSR_PASS");return 0;
+}
+`
diff --git a/x86_scalar_sqrt_observable_read_test.go b/x86_scalar_sqrt_observable_read_test.go
new file mode 100644
index 000000000..1498e45c6
--- /dev/null
+++ b/x86_scalar_sqrt_observable_read_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86ScalarSqrtNativeReadSurvivesOptimization(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range []struct {
+			operation string
+			bits      int
+		}{
+			{"SQRTSS (AX),X1", 32},
+			{"SQRTSD (AX),X1", 64},
+			{"VSQRTSS (AX),X0,X1", 32},
+			{"VSQRTSD (AX),X0,X1", 64},
+		} {
+			for _, address := range []struct{ name, input string }{
+				{"null", "MOVL $0,AX"},
+				{"runtime", move + " p+0(FP),AX"},
+			} {
+				t.Run(target.triple+"/"+row.operation+"/"+address.name, func(t *testing.T) {
+					source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s\nPXOR X0,X0\nPXOR X1,X1\n%s\nRET\n",
+						word, address.input, row.operation)
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p uintptr)", target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete numerical source did not reach its native scalar opcode", err)
+							}
+							x86RequireNumericNativeSourceContext(t, source, "func Value(p uintptr)", target.arch)
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								body := x86StringMemoryFunction(t, text, "Value")
+								// Even a dead numerical result must retain the source
+								// access and fault, without a pointer-validity assumption.
+								if x86FMA3PortableVolatileBytes(t, body) != row.bits/8 ||
+									!strings.Contains(body, "asm sideeffect") || strings.Contains(body, "dereferenceable") {
+									t.Errorf("native m%d read/fault was lost or given invented backing:\n%s", row.bits, body)
+									continue
+								}
+								x86PackedStringCompileObject(t, llc, target.triple, text, "-O2")
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_scalar_xor_zero_effect_test.go b/x86_scalar_xor_zero_effect_test.go
new file mode 100644
index 000000000..86ae665f4
--- /dev/null
+++ b/x86_scalar_xor_zero_effect_test.go
@@ -0,0 +1,239 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/types"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This directory is independent of the production effect descriptor. Source
+// register spellings that select the same physical byte have the same zeroing
+// effect, but different bytes of one GP bank still require initialized input.
+func x86ScalarXORZeroOracleRows(arch string) []string {
+	registers := []string{"AX", "BX", "CX", "DX", "SI", "DI"}
+	widths := "BWL"
+	if arch == "amd64" {
+		registers = append(registers, "R8", "R9", "R14", "R15")
+		widths += "Q"
+	}
+	var rows []string
+	for _, width := range widths {
+		for _, register := range registers {
+			rows = append(rows, fmt.Sprintf("XOR%c %s,%s", width, register, register))
+		}
+	}
+	for _, pair := range [][2]string{
+		{"AL", "AL"}, {"AH", "AH"}, {"BL", "BL"}, {"BH", "BH"},
+		{"CL", "CL"}, {"CH", "CH"}, {"DL", "DL"}, {"DH", "DH"},
+		{"AX", "AL"}, {"AL", "AX"}, {"BX", "BL"}, {"BL", "BX"},
+		{"CX", "CL"}, {"CL", "CX"}, {"DX", "DL"}, {"DL", "DX"},
+	} {
+		rows = append(rows, "XORB "+pair[0]+","+pair[1])
+	}
+	return rows
+}
+
+func TestX86ScalarXORZeroCompleteGoRoles(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The carrier binds complete yxorb/yaddl ordered rows, opcode bytes,
+	// prefix, zcase and offsets, not only the four XOR mnemonic names.
+	if err := x86LockScalarEncoderCarrier(data); err != nil {
+		t.Fatal(err)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarXORZeroOracleRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\n" + row + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				original := append([]Operand(nil), ins.Args...)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if err != nil || !known || len(effect.operands) != 2 {
+					t.Fatal("actual Go XOR register row lacks its typed effect", err)
+				}
+				width := map[byte]int64{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[row[3]]
+				for index, operand := range effect.operands {
+					if operand.index != index || operand.width != width || operand.read || operand.write != (index == 1) {
+						t.Fatalf("self-XOR retained undefined input or changed its written bytes: %#v", effect)
+					}
+				}
+				if effect.flagsRead != 0 || effect.flagsDefined != x86ByteFlagsAll&^x86ByteFlagAF ||
+					effect.flagsKilled != x86ByteFlagAF || effect.dynamicMemory || !reflect.DeepEqual(ins.Args, original) {
+					t.Fatal("self-XOR inherited undefined AF, memory permission or altered source")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarXORZeroInitializesOnlyWrittenBytesAndCarry(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86ScalarXORZeroOracleRows(arch) {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				width := row[3]
+				typ := map[byte]string{'B': "uint8", 'W': "uint16", 'L': "uint32", 'Q': "uint64"}[width]
+				register := strings.Split(row[5:], ",")[1]
+				body := row + fmt.Sprintf("\nMOV%c %s,ret0+0(FP)\nRET", width, register)
+				_, file, sig, source := x86ResultInitializationFixture(t, arch, "func Value() "+typ, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal("actual self-XOR numerical result remains undefined", err)
+				}
+				ctx, _ := newAMD64CtxWithFuncForTest(t, Func{}, FuncSig{Ret: Void}, nil)
+				ctx.goarch = arch
+				state := ctx.lockCarryTransfer(file.Funcs[0].Instrs[1], x86LockCarryState{})
+				if !state.carry || state.stackUnbound || !ctx.lockCarryRead(file.Funcs[0].Instrs[1].Args[1],
+					map[byte]int64{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[width], state) {
+					t.Fatal("self-XOR lost its defined CF or exact numeric destination")
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarXORZeroDoesNotInventOtherBytesOrMemory(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for name, body := range map[string]string{
+			"different register":       "XORL AX,BX\nMOVL BX,ret0+0(FP)\nRET",
+			"different byte alias":     "XORB AH,AL\nMOVB AL,ret0+0(FP)\nRET",
+			"only low byte cleared":    "XORB AX,AX\nMOVL AX,ret0+0(FP)\nRET",
+			"only word cleared":        "XORW AX,AX\nMOVL AX,ret0+0(FP)\nRET",
+			"memory still read":        "XORL ret0+0(FP),AX\nMOVL AX,ret0+0(FP)\nRET",
+			"uninitialized AUTO input": "XORL $0,value-16(SP)\nMOVL value-16(SP),AX\nMOVL AX,ret0+0(FP)\nRET",
+			"AND is not a zero idiom":  "ANDL AX,AX\nMOVL AX,ret0+0(FP)\nRET",
+			"OR is not a zero idiom":   "ORL AX,AX\nMOVL AX,ret0+0(FP)\nRET",
+		} {
+			t.Run(arch+"/"+name, func(t *testing.T) {
+				typ := "uint32"
+				if name == "different byte alias" {
+					typ = "uint8"
+				}
+				file, sig, _ := x86ResultAUTOFixture(t, arch, "func Value() "+typ, 32, body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("self-XOR granted unrelated numerical or memory inputs", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86ScalarXORZeroRequiresCanonicalRegisterMetadata(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\nXORB AX,AL\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range []string{"extension", "shift", "immediate", "memory", "register-list"} {
+		t.Run(name, func(t *testing.T) {
+			ins := file.Funcs[0].Instrs[1]
+			ins.Args = append([]Operand(nil), ins.Args...)
+			for index := range ins.Args {
+				switch name {
+				case "extension":
+					ins.Args[index].Ext = "UXTW"
+				case "shift":
+					ins.Args[index].ShiftAmount = 1
+				case "immediate":
+					ins.Args[index].Imm = 1
+				case "memory":
+					ins.Args[index].Mem.Base = AX
+				case "register-list":
+					ins.Args[index].RegList = []Reg{AX}
+				}
+			}
+			// Consumer-input mutation only, not additional Go syntax.
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, "amd64")
+			if err != nil || !known || len(effect.operands) != 2 ||
+				!effect.operands[0].read || !effect.operands[1].read {
+				t.Fatal("uncanonical constructed register acquired input-independent zeroing", err)
+			}
+		})
+	}
+}
+
+func TestX86ScalarXORZeroThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			var declarations, source strings.Builder
+			declarations.WriteString("package xorzero\n")
+			for index, row := range x86ScalarXORZeroOracleRows(target.arch) {
+				name := fmt.Sprintf("Zero%03d", index)
+				width := row[3]
+				typ := map[byte]string{'B': "uint8", 'W': "uint16", 'L': "uint32", 'Q': "uint64"}[width]
+				bytes := map[byte]int{'B': 1, 'W': 2, 'L': 4, 'Q': 8}[width]
+				register := strings.Split(row[5:], ",")[1]
+				fmt.Fprintf(&declarations, "func %s() %s\n", name, typ)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s\nMOV%c %s,ret0+0(FP)\nRET\n",
+					name, bytes, row, width, register)
+			}
+			pkg := mustGoPackage(t, "example.invalid/xorzero", declarations.String())
+			file, err := Parse(ArchAMD64, source.String())
+			if err != nil {
+				t.Fatal(err)
+			}
+			goAssemblerOracleOutput(t, target.arch, source.String(), "", true)
+			sigs := make(map[string]FuncSig)
+			for _, fn := range file.Funcs {
+				name := strings.TrimPrefix(fn.Sym, "·")
+				sig, err := DeriveGoFuncABI0Signature(name, pkg.Types.Scope().Lookup(name).(*types.Func),
+					target.arch, types.SizesFor("gc", target.arch))
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := CheckX86ABI0ResultInitialization(fn, sig, target.arch); err != nil {
+					t.Fatal(err)
+				}
+				sigs[name] = sig
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: sigs,
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, ir, "text")
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(source.String()), GoModuleOptions{
+				GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+		})
+	}
+}
diff --git a/x86_sdk_crc32_profile_ownership_test.go b/x86_sdk_crc32_profile_ownership_test.go
new file mode 100644
index 000000000..672d49848
--- /dev/null
+++ b/x86_sdk_crc32_profile_ownership_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// This is scheduling policy, not source or compilation authority. Each owner
+// must still execute the unchanged complete-source helper and its live guards.
+func TestX86SDKCRC32ProfilesHaveIndependentCompleteOwners(t *testing.T) {
+	source, err := os.ReadFile("cmd/plan9asmll/x86_sdk_numerical_source_go127_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, owner := range x86SDKCRC32ProfileOwners() {
+		t.Run(owner.profile, func(t *testing.T) {
+			if err := x86SDKCRC32ProfileOwnerError(source, owner.name, owner.profile); err != nil {
+				t.Fatal(err)
+			}
+		})
+	}
+}
+
+func TestX86SDKCRC32ProfileOwnerPolicyRejectsSharedOrMissingProfiles(t *testing.T) {
+	const explicit = `func TestCompileOneX86SDKOriginalCRC32NumericalDataJoin(t *testing.T) {
+	t.Run("explicit", func(t *testing.T) {
+		compileX86SDKOriginalCRC32NumericalDataJoin(t, "explicit")
+	})
+}`
+	const defaults = `func TestCompileOneX86SDKOriginalCRC32NumericalDataJoinEffectiveDefaults(t *testing.T) {
+	t.Run("effective-defaults", func(t *testing.T) {
+		compileX86SDKOriginalCRC32NumericalDataJoin(t, "effective-defaults")
+	})
+}`
+	const prefix = "package main\nimport \"testing\"\n"
+	valid := prefix + explicit + "\n" + defaults
+	check := func(source string) error {
+		for _, owner := range x86SDKCRC32ProfileOwners() {
+			if err := x86SDKCRC32ProfileOwnerError([]byte(source), owner.name, owner.profile); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	t.Run("valid", func(t *testing.T) {
+		if err := check(valid); err != nil {
+			t.Fatal(err)
+		}
+	})
+	for _, row := range []struct{ name, source string }{
+		{"missing-explicit", prefix + defaults},
+		{"missing-defaults", prefix + explicit},
+		{"shared-loop", prefix + `func TestCompileOneX86SDKOriginalCRC32NumericalDataJoin(t *testing.T) {
+	for _, profile := range []string{"explicit", "effective-defaults"} {
+		t.Run(profile, func(t *testing.T) { compileX86SDKOriginalCRC32NumericalDataJoin(t, profile) })
+	}
+}` + "\n" + defaults},
+		{"wrong-profile", prefix + explicit + "\n" + strings.ReplaceAll(defaults, `"effective-defaults"`, `"explicit"`)},
+		{"extra-profile", prefix + strings.Replace(explicit, "\n}", `
+	t.Run("effective-defaults", func(t *testing.T) {
+		compileX86SDKOriginalCRC32NumericalDataJoin(t, "effective-defaults")
+	})
+}`, 1) + "\n" + defaults},
+		{"different-helper", strings.ReplaceAll(valid, "compileX86SDKOriginalCRC32NumericalDataJoin(t,", "compileUnrelatedSource(t,")},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			if err := check(row.source); err == nil {
+				t.Fatal("incomplete/shared profile ownership accepted")
+			}
+		})
+	}
+}
+
+func x86SDKCRC32ProfileOwners() []struct{ name, profile string } {
+	return []struct{ name, profile string }{
+		{"TestCompileOneX86SDKOriginalCRC32NumericalDataJoin", "explicit"},
+		{"TestCompileOneX86SDKOriginalCRC32NumericalDataJoinEffectiveDefaults", "effective-defaults"},
+	}
+}
+
+func x86SDKCRC32ProfileOwnerError(source []byte, name, profile string) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "crc32-source-owners.go", source, 0)
+	if err != nil {
+		return err
+	}
+	var owner *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if ok && function.Name.Name == name {
+			if owner != nil {
+				return fmt.Errorf("duplicate profile owner %s", name)
+			}
+			owner = function
+		}
+	}
+	if owner == nil || owner.Body == nil {
+		return fmt.Errorf("missing independent complete-source profile owner %s", name)
+	}
+	// One literal t.Run owns one profile. A loop over both profiles would still
+	// share go test's deadline even when it makes a fresh context per subtest.
+	if len(owner.Body.List) != 1 {
+		return fmt.Errorf("%s must own exactly one literal profile", name)
+	}
+	statement, ok := owner.Body.List[0].(*ast.ExprStmt)
+	if !ok {
+		return fmt.Errorf("%s cannot share a loop/branch profile lease", name)
+	}
+	run, ok := statement.X.(*ast.CallExpr)
+	if !ok || len(run.Args) != 2 {
+		return fmt.Errorf("%s must invoke one profile subtest", name)
+	}
+	method, ok := run.Fun.(*ast.SelectorExpr)
+	if !ok || method.Sel.Name != "Run" || !x86SDKCRC32OwnerIdent(method.X, "t") || !x86SDKCRC32OwnerString(run.Args[0], profile) {
+		return fmt.Errorf("%s does not own literal profile %s", name, profile)
+	}
+	callback, ok := run.Args[1].(*ast.FuncLit)
+	if !ok || callback.Body == nil || len(callback.Body.List) != 1 {
+		return fmt.Errorf("%s must run the complete-source helper once", name)
+	}
+	helperStatement, ok := callback.Body.List[0].(*ast.ExprStmt)
+	if !ok {
+		return fmt.Errorf("%s must delegate directly to the complete-source helper", name)
+	}
+	helper, ok := helperStatement.X.(*ast.CallExpr)
+	if !ok || !x86SDKCRC32OwnerIdent(helper.Fun, "compileX86SDKOriginalCRC32NumericalDataJoin") ||
+		len(helper.Args) != 2 || !x86SDKCRC32OwnerIdent(helper.Args[0], "t") || !x86SDKCRC32OwnerString(helper.Args[1], profile) {
+		return fmt.Errorf("%s changed or duplicated its complete-source profile", name)
+	}
+	return nil
+}
+
+func x86SDKCRC32OwnerIdent(expression ast.Expr, name string) bool {
+	identifier, ok := expression.(*ast.Ident)
+	return ok && identifier.Name == name
+}
+
+func x86SDKCRC32OwnerString(expression ast.Expr, value string) bool {
+	literal, ok := expression.(*ast.BasicLit)
+	if !ok || literal.Kind != token.STRING {
+		return false
+	}
+	actual, err := strconv.Unquote(literal.Value)
+	return err == nil && actual == value
+}
diff --git a/x86_sdk_original_inactive_capture_go127_test.go b/x86_sdk_original_inactive_capture_go127_test.go
new file mode 100644
index 000000000..800789ff7
--- /dev/null
+++ b/x86_sdk_original_inactive_capture_go127_test.go
@@ -0,0 +1,136 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+)
+
+// The original SDK helper deliberately fixes GOAMD64=v1 for its strict DATA
+// role. These separate fresh requests test the actual inactive field instead;
+// they retain the complete original source and never authorize its execution.
+func TestX86SDKOriginalSource386InactiveAMD64ProfileCompleteCapture(t *testing.T) {
+	for _, profile := range []struct {
+		name, value string
+		provided    bool
+	}{
+		{"unset", "", false},
+		{"empty", "", true},
+		{"v3", "v3", true},
+	} {
+		t.Run(profile.name, func(t *testing.T) {
+			ctx, request := sdkASMDataRequest(t, "386", "internal/runtime/atomic")
+			var environment []string
+			for _, pair := range request.Environment {
+				if !strings.HasPrefix(pair, "GOAMD64=") {
+					environment = append(environment, pair)
+				}
+			}
+			if profile.provided {
+				environment = append(environment, "GOAMD64="+profile.value)
+			}
+			request.Environment = environment
+			before := append([]string(nil), environment...)
+			actual, err := goasmcmd.Run(ctx, request.Directory, request.Environment, request.GoBinary,
+				"env", "-json", "GOOS", "GOARCH", "GOAMD64", "GO386")
+			var profileObservation map[string]string
+			if err != nil || json.Unmarshal(actual, &profileObservation) != nil {
+				t.Fatal("independent actual Go profile observation failed", err)
+			}
+			inactive, present := profileObservation["GOAMD64"]
+			if !present || inactive != profile.value || profileObservation["GO386"] != "sse2" ||
+				profileObservation["GOOS"] != "linux" || profileObservation["GOARCH"] != "386" {
+				t.Fatal("actual inactive/active architecture fields differ", profileObservation)
+			}
+			t.Logf("independent actual original386 profile before capture: %s", actual)
+			if public, err := CaptureGoX86SDKASMDataSource(ctx, request); public != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("inactive original-source profile leaked into strict DATA/NUM observation", err)
+			}
+			if frame, err := CaptureGoAMD64SDKFrameObservation(ctx, request); frame != nil || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("386 source-only profile acquired an AMD64 native-frame observation", err)
+			}
+			source, err := captureGoX86SDKASMDataSourceRole(ctx, request, sdkASMDataOriginalSourceRole)
+			if err != nil {
+				t.Fatal("complete actual original386 inactive-profile source capture", err)
+			}
+			t.Cleanup(func() {
+				if err := source.Close(); err != nil {
+					t.Error("close original source observation", err)
+				}
+			})
+			var observed map[string]string
+			rawEnvironment := append([]byte(nil), source.observation.RawEnvironment...)
+			if err := json.Unmarshal(rawEnvironment, &observed); err != nil {
+				t.Fatal("actual command environment is not complete JSON", err)
+			}
+			value, present := observed["GOAMD64"]
+			if !present || value != profile.value || observed["GO386"] != "sse2" ||
+				observed["GOOS"] != "linux" || observed["GOARCH"] != "386" ||
+				!reflect.DeepEqual(observed, source.guard.env) ||
+				!reflect.DeepEqual(before, request.Environment) || !reflect.DeepEqual(before, source.request.Environment) {
+				t.Fatal("capture changed an original observed/active profile or its request", observed)
+			}
+			if source.captureRole != sdkASMDataOriginalSourceRole || len(source.observation.Frames) != 0 ||
+				source.frameListingBytes != 0 || source.guard.ready || source.guard.sdkFrame != nil ||
+				len(source.guard.functions) != 0 || source.guard.numericalOrigin != nil {
+				t.Fatal("inactive-field observation acquired frame or numerical authority")
+			}
+			objects := source.observation.Objects
+			inputs := source.observation.ObjectInputs
+			if objects == nil || len(objects.Sources) != 1 || len(objects.Sources[0].Original.Texts) != 42 ||
+				len(objects.Sources[0].Expanded.Texts) != 42 || len(objects.Members) != 3 ||
+				len(objects.Sources[0].GeneratedFuncdata) != 1 || len(objects.Sources[0].GeneratedFuncdata[0].Owners) != 5 ||
+				len(objects.Sources[0].ExpandedLayouts) != 0 || len(inputs.Sources) != 1 || len(inputs.Archive) == 0 ||
+				len(source.observation.CPP) != 1 || len(source.observation.Positions) != 1 {
+				t.Fatal("inactive profile lost complete compiler/archive/42-TEXT/generated-source identity")
+			}
+			original := inputs.Sources[0]
+			if strings.Count(string(original.Original), "\nTEXT ") != 42 || len(original.OriginalObject) == 0 ||
+				len(original.ExpandedObject) == 0 || !bytes.Equal(original.Expanded, []byte(source.observation.CPP[0].Output)) {
+				t.Fatal("complete original/expanded assembly or native objects were cropped")
+			}
+			if images, err := gostaticstorage.ReadonlyLiteralDataInitializers(objects); images != nil || !errors.Is(err, gostaticstorage.ErrContext) {
+				t.Fatal("generated metadata became a readonly/numerical initializer owner", images, err)
+			}
+			pkg, err := source.typedPackage("go1.27")
+			if err != nil || len(pkg.SourceSelection.Assembly) != 1 {
+				t.Fatal("actual complete typed SDK selection differs", err)
+			}
+			for _, file := range pkg.SourceSelection.Assembly {
+				if len(file.Funcs) != 42 {
+					t.Fatal("actual selected source lost an original TEXT")
+				}
+			}
+			sdkASMDataRetain(t, source) // Optional owned artifact directory retains the full raw observation.
+			if err := source.Verify(ctx); err != nil || !bytes.Equal(rawEnvironment, source.observation.RawEnvironment) {
+				t.Fatal("complete live verification changed original observed bytes", err)
+			}
+			t.Logf("source-only42TEXT inactive GOAMD64=%q provided=%t activeGO386=sse2 rawenv=%s original=%x expanded=%x originalobject=%x expandedobject=%x",
+				value, profile.provided, rawEnvironment, sha256.Sum256(original.Original), sha256.Sum256(original.Expanded),
+				sha256.Sum256(original.OriginalObject), sha256.Sum256(original.ExpandedObject))
+			// An observed inactive field does not weaken the actual active profile
+			// or the permanent complete-source seal, even if bytes are restored.
+			for index, pair := range source.request.Environment {
+				if strings.HasPrefix(pair, "GO386=") {
+					source.request.Environment[index] = "GO386=softfloat"
+				}
+			}
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("changed active profile retained the source observation", err)
+			}
+			source.request.Environment = append([]string(nil), before...)
+			if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("restoring a changed active profile revived its observation", err)
+			}
+		})
+	}
+}
diff --git a/x86_sdk_original_observed_profile_test.go b/x86_sdk_original_observed_profile_test.go
new file mode 100644
index 000000000..a90a827c2
--- /dev/null
+++ b/x86_sdk_original_observed_profile_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/gotoolchain"
+)
+
+// These literal command-profile controls supply no source, compiler, object or
+// terminal authority. The live producer must still authenticate every input.
+func sdkOriginalObservedProfile(t *testing.T, role sdkASMDataCaptureRole, arch string) (*GoX86SDKASMDataSource, map[string]string, map[string]string) {
+	t.Helper()
+	directory := t.TempDir()
+	root := filepath.Join(directory, "sdk")
+	source := &GoX86SDKASMDataSource{captureRole: role, originalProfile: role != sdkASMDataStrictRole,
+		request: GoX86SDKASMDataCaptureRequest{Target: "linux/" + arch, GoBinary: filepath.Join(root, "bin", gotoolchain.HostExecutable("go"))}}
+	provided := map[string]string{"GOCACHE": filepath.Join(directory, "build"), "GOMODCACHE": filepath.Join(directory, "mod"),
+		"CGO_ENABLED": "0", "GOENV": "off", "GOWORK": "off", "GOTOOLCHAIN": "local"}
+	source.request.Environment = []string{"GOOS=linux", "GOARCH=" + arch, "GOFLAGS=", "GOEXPERIMENT="}
+	for key, value := range provided {
+		source.request.Environment = append(source.request.Environment, key+"="+value)
+	}
+	env := map[string]string{"GOROOT": root, "GOVERSION": "go1.27.2", "GOOS": "linux", "GOARCH": arch,
+		"GOAMD64": "v1", "GO386": "sse2", "GOFLAGS": "", "GOEXPERIMENT": "",
+		"GOCACHE": provided["GOCACHE"], "GOMODCACHE": provided["GOMODCACHE"], "CGO_ENABLED": "0",
+		"GOENV": "", "GOWORK": "off", "GOTOOLCHAIN": "local", "GOPROXY": "off"}
+	return source, provided, env
+}
+
+func sdkCheckOriginalObservedProfile(t *testing.T, source *GoX86SDKASMDataSource, provided, env map[string]string, accept bool) {
+	t.Helper()
+	raw, err := json.Marshal(env)
+	if err != nil {
+		t.Fatal(err)
+	}
+	before := append([]byte(nil), raw...)
+	requestBefore := append([]string(nil), source.request.Environment...)
+	providedBefore := make(map[string]string, len(provided))
+	for key, value := range provided {
+		providedBefore[key] = value
+	}
+	observed, err := source.validateObservedEnvironment(raw, provided)
+	if accept && (err != nil || !reflect.DeepEqual(observed, env)) {
+		t.Fatal("the actual selected architecture's profile was rejected or rewritten", observed, err)
+	}
+	if !accept && (!errors.Is(err, ErrProbeNeedsContext) || observed != nil) {
+		t.Fatal("another role or changed active profile acquired admission", observed, err)
+	}
+	if !bytes.Equal(raw, before) || !reflect.DeepEqual(provided, providedBefore) || !reflect.DeepEqual(source.request.Environment, requestBefore) {
+		t.Fatal("profile validation rewrote actual command metadata or supplied environment")
+	}
+}
+
+func TestX86SDKOriginalObservedInactiveCPUField(t *testing.T) {
+	for _, role := range []sdkASMDataCaptureRole{sdkASMDataStrictRole, sdkASMDataOriginalFrameRole, sdkASMDataOriginalSourceRole} {
+		for _, arch := range []string{"386", "amd64"} {
+			for _, inactive := range []string{"", "v1", "v2", "v3", "v4", "future-profile"} {
+				t.Run(profileRoleName(role)+"/"+arch+"/GOAMD64="+inactive, func(t *testing.T) {
+					source, provided, env := sdkOriginalObservedProfile(t, role, arch)
+					env["GOAMD64"] = inactive
+					if inactive != "" {
+						provided["GOAMD64"] = inactive
+						source.request.Environment = append(source.request.Environment, "GOAMD64="+inactive)
+					}
+					accept := inactive == "v1" || arch == "386" && role == sdkASMDataOriginalSourceRole
+					sdkCheckOriginalObservedProfile(t, source, provided, env, accept)
+				})
+			}
+		}
+	}
+}
+
+func profileRoleName(role sdkASMDataCaptureRole) string {
+	switch role {
+	case sdkASMDataStrictRole:
+		return "strict-DATA-NUM"
+	case sdkASMDataOriginalFrameRole:
+		return "original-frame"
+	default:
+		return "original-source"
+	}
+}
+
+func TestX86SDKOriginalObservedActiveAndCompleteProfileStillRequired(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for key, value := range map[string]string{"GOOS": "windows", "GOARCH": "arm64", "GOROOT": "other-sdk",
+			"GOVERSION": "go1.20.14", "GOFLAGS": "-overlay=changed", "GOEXPERIMENT": "changed",
+			"GOCACHE": "other-cache", "GOMODCACHE": "other-mod", "CGO_ENABLED": "1",
+			"GOENV": "other-config", "GOWORK": "other-work", "GOTOOLCHAIN": "auto"} {
+			t.Run(arch+"/"+key, func(t *testing.T) {
+				source, provided, env := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, arch)
+				if arch == "386" {
+					env["GOAMD64"] = ""
+				}
+				env[key] = value
+				sdkCheckOriginalObservedProfile(t, source, provided, env, false)
+			})
+		}
+	}
+	for _, active := range []string{"", "softfloat", "sse3", "changed"} {
+		t.Run("386/active-GO386="+active, func(t *testing.T) {
+			source, provided, env := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, "386")
+			env["GO386"] = active
+			sdkCheckOriginalObservedProfile(t, source, provided, env, false)
+		})
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch+"/missing-observed-GOAMD64", func(t *testing.T) {
+			source, provided, env := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, arch)
+			delete(env, "GOAMD64")
+			sdkCheckOriginalObservedProfile(t, source, provided, env, false)
+		})
+	}
+	for _, inactive := range []string{"", "sse2", "softfloat", "future-profile"} {
+		t.Run("amd64/inactive-GO386="+inactive, func(t *testing.T) {
+			source, provided, env := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, "amd64")
+			env["GO386"] = inactive
+			sdkCheckOriginalObservedProfile(t, source, provided, env, true)
+		})
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch+"/original-config-and-cgo-default", func(t *testing.T) {
+			source, provided, env := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, arch)
+			provided["GOENV"] = filepath.Join(t.TempDir(), "selected-config")
+			provided["CGO_ENABLED"] = "1"
+			env["GOENV"], env["CGO_ENABLED"] = provided["GOENV"], provided["CGO_ENABLED"]
+			for index, pair := range source.request.Environment {
+				key, _, _ := strings.Cut(pair, "=")
+				if value, present := provided[key]; present {
+					source.request.Environment[index] = key + "=" + value
+				}
+			}
+			if arch == "386" {
+				env["GOAMD64"] = ""
+				source.request.Environment = append(source.request.Environment, "GOAMD64=")
+			}
+			sdkCheckOriginalObservedProfile(t, source, provided, env, true)
+		})
+	}
+	for _, raw := range []string{"null", "[]", "{", `{"GOAMD64":1}`} {
+		t.Run("malformed-observation="+raw, func(t *testing.T) {
+			source, provided, _ := sdkOriginalObservedProfile(t, sdkASMDataOriginalSourceRole, "386")
+			if observed, err := source.validateObservedEnvironment([]byte(raw), provided); !errors.Is(err, ErrProbeNeedsContext) || observed != nil {
+				t.Fatal("malformed command metadata acquired profile admission", observed, err)
+			}
+		})
+	}
+}
diff --git a/x86_sdk_original_source_go127_test.go b/x86_sdk_original_source_go127_test.go
new file mode 100644
index 000000000..d61ba1144
--- /dev/null
+++ b/x86_sdk_original_source_go127_test.go
@@ -0,0 +1,154 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmcmd"
+	"github.com/xgo-dev/plan9asm/internal/gostaticstorage"
+	"github.com/xgo-dev/plan9asm/internal/sourcepath"
+)
+
+func TestX86SDKOriginalSource386HasNoFrameOrTerminalAuthority(t *testing.T) {
+	ctx, request := sdkASMDataRequest(t, "386", "internal/runtime/atomic")
+	config := filepath.Join(t.TempDir(), "actual-go-env")
+	if err := os.WriteFile(config, []byte("GOPROXY=https://original-source.invalid,direct\n"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	config, err := sourcepath.Resolve(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var environment []string
+	for _, value := range request.Environment {
+		if !strings.HasPrefix(value, "GOENV=") && !strings.HasPrefix(value, "GOPROXY=") {
+			environment = append(environment, value)
+		}
+	}
+	request.Environment = append(environment, "GOENV="+config)
+	if public, err := CaptureGoX86SDKASMDataSource(ctx, request); public != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("original profile leaked into the unchanged strict public DATA producer", err)
+	}
+	if frame, err := CaptureGoAMD64SDKFrameObservation(ctx, request); frame != nil || !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("386 source-only observation acquired an AMD64 native frame", err)
+	}
+	source, err := captureGoX86SDKASMDataSourceRole(ctx, request, sdkASMDataOriginalSourceRole)
+	if err != nil {
+		t.Fatal("complete actual original-profile386 source/header/compiler/ASM observation", err)
+	}
+	defer source.Close()
+	if source.guard.env["GOENV"] != config || source.guard.env["GOPROXY"] != "https://original-source.invalid,direct" ||
+		source.captureRole != sdkASMDataOriginalSourceRole || len(source.observation.Frames) != 0 || source.frameListingBytes != 0 ||
+		source.guard.ready || source.guard.sdkFrame != nil || len(source.guard.functions) != 0 || source.guard.numericalOrigin != nil {
+		t.Fatal("source observation changed the original profile or acquired frame/numerical authority")
+	}
+	if len(source.observation.Objects.Sources) != 1 || len(source.observation.Objects.Sources[0].GeneratedFuncdata) != 1 ||
+		len(source.observation.Objects.Sources[0].GeneratedFuncdata[0].Owners) != 5 || len(source.observation.Objects.Sources[0].ExpandedLayouts) != 0 {
+		t.Fatal("the complete generated metadata/source-owner inventory was omitted or became DATA")
+	}
+	if images, err := gostaticstorage.ReadonlyLiteralDataInitializers(source.observation.Objects); images != nil || !errors.Is(err, gostaticstorage.ErrContext) {
+		t.Fatal("actual generated metadata acquired literal/numerical backing", images, err)
+	}
+	if err := gostaticstorage.GeneratedFuncdataSources(source.guard.env["GOVERSION"], func(role string) ([]byte, error) {
+		data, err := source.guard.read(filepath.Join(source.guard.env["GOROOT"], filepath.FromSlash(role)))
+		if role == "pkg/include/funcdata.h" && len(data) != 0 {
+			data = append([]byte(nil), data...)
+			data[0] ^= 1
+		}
+		return data, err
+	}); !errors.Is(err, gostaticstorage.ErrContext) {
+		t.Fatal("changed actual metadata producer source retained its registered role", err)
+	}
+	x86SDKGeneratedMetadataAddressSyntax(t, source)
+	pkg, err := source.typedPackage("go1.27")
+	if err != nil {
+		t.Fatal("same sealed compiler selection did not reconstruct its complete typed source", err)
+	}
+	bodies, err := x86GoSinglePanicBodies(pkg)
+	if err != nil || len(bodies) != 1 || len(pkg.SourceSelection.Assembly) != 1 {
+		t.Fatal("actual complete selected Go body/ASM inventory differs", len(bodies), err)
+	}
+	for _, file := range pkg.SourceSelection.Assembly {
+		if len(file.Funcs) != 42 {
+			t.Fatal("the untouched actual assembly was cropped", len(file.Funcs))
+		}
+	}
+	if err := source.Verify(ctx); err != nil {
+		t.Fatal("actual complete source/selection/compiler object lost its identity", err)
+	}
+	source.captureRole = sdkASMDataOriginalFrameRole
+	if err := source.Verify(ctx); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("changed private role survived the complete observation seal", err)
+	}
+}
+
+// These fresh assembler observations classify syntax, not metadata authority.
+// In particular, rejection of quoted/base64 names is not the reason that the
+// independent source/object classifier denies address aliases.
+func x86SDKGeneratedMetadataAddressSyntax(t *testing.T, source *GoX86SDKASMDataSource) {
+	t.Helper()
+	whole := string(source.observation.ObjectInputs.Sources[0].Original)
+	if strings.Count(whole, "\nTEXT ") != 42 || !strings.Contains(whole, "\n\tRET") {
+		t.Fatal("the alias oracle requires the complete actual 42-TEXT source")
+	}
+	name := source.observation.Objects.Sources[0].GeneratedFuncdata[0].Definition.Name
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	if driver != source.request.GoBinary {
+		t.Fatal("the syntax oracle changed the selected original SDK")
+	}
+	for _, row := range []struct {
+		name, instruction string
+		accepted          bool
+	}{
+		{"complete-original", "", true},
+		{"reserved-address", "MOVL $no_pointers_stackmap(SB),AX", true},
+		{"generated-bare", "LEAL " + name + "(SB),AX", false},
+		{"generated-quoted", "MOVL $\"" + name + "\"(SB),AX", false},
+		{"generated-quoted-offset", "LEAL \"" + name + "\"+4(SB),AX", false},
+		{"generated-quoted-slash", "LEAL \"" + name + "/\"(SB),AX", false},
+	} {
+		t.Run("actual-Go-syntax/"+row.name, func(t *testing.T) {
+			if err := source.Verify(source.context); err != nil {
+				t.Fatal(err)
+			}
+			assembly := whole
+			if row.instruction != "" {
+				assembly = strings.Replace(assembly, "\n\tRET", "\n\t"+row.instruction+"\n\tRET", 1)
+			}
+			directory := t.TempDir()
+			input, object := filepath.Join(directory, "whole.s"), filepath.Join(directory, "whole.o")
+			if err := os.WriteFile(input, []byte(assembly), 0600); err != nil {
+				t.Fatal(err)
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			defer cancel()
+			args := append(source.asmArguments(source.guard.owned), "-o", object, input)
+			observed, err := goasmcmd.Observe(stage, source.request.Directory, source.request.Environment, driver, args...)
+			output := append(append([]byte(nil), observed.Stdout...), observed.Stderr...)
+			if failure := goAssemblerOracleOutcome(input, object, output, err, stage.Err(), row.accepted, "386"); failure != nil {
+				t.Fatalf("complete actual source syntax classification: %v\n%s", failure, output)
+			}
+			current, readErr := os.ReadFile(input)
+			tool, toolErr := os.ReadFile(driver)
+			if readErr != nil || toolErr != nil || !bytes.Equal(current, []byte(assembly)) || sha256.Sum256(tool) != driverHash ||
+				!observed.Waited || observed.ExitCode != 0 && observed.ExitCode != 1 {
+				t.Fatal("the actual source/tool/owned-command identity changed", readErr, toolErr)
+			}
+			t.Logf("complete 42-TEXT syntax observation: accepted=%t source=%x driver=%x exit=%d diagnostic=%q",
+				row.accepted, sha256.Sum256(current), driverHash, observed.ExitCode, output)
+			if row.accepted {
+				x86LEAReadObjectReceipt(t, "386", "linux", assembly, input, driver, driverHash, object)
+			}
+			if err := source.Verify(source.context); err != nil {
+				t.Fatal("the syntax observation changed the live source producer", err)
+			}
+		})
+	}
+}
diff --git a/x86_sdk_original_source_profile_test.go b/x86_sdk_original_source_profile_test.go
new file mode 100644
index 000000000..a70408d6a
--- /dev/null
+++ b/x86_sdk_original_source_profile_test.go
@@ -0,0 +1,42 @@
+package plan9asm
+
+import (
+	"errors"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86SDKOriginalSourceProfileDoesNotBorrowNativeFrame(t *testing.T) {
+	for _, target := range []string{"linux/386", "windows/386", "linux/amd64", "darwin/amd64", "windows/amd64"} {
+		t.Run(target, func(t *testing.T) {
+			goos, arch, _ := strings.Cut(target, "/")
+			request := GoX86SDKASMDataCaptureRequest{Target: target, Environment: []string{
+				"GOOS=" + goos, "GOARCH=" + arch, "GOFLAGS=", "GOTOOLCHAIN=local", "GOWORK=off",
+				"CGO_ENABLED=0", "GOENV=off", "GOEXPERIMENT=", "GOPACKAGESDRIVER=off",
+			}}
+			before := append([]string(nil), request.Environment...)
+			actual, err := sdkX86OriginalSourceEnvironment(request)
+			if err != nil || actual["GOARCH"] != arch || !reflect.DeepEqual(before, request.Environment) {
+				t.Fatal("source observation changed the actual producer profile", err)
+			}
+			_, err = sdkAMD64FrameEnvironment(request)
+			if arch == "386" && !errors.Is(err, ErrProbeNeedsContext) || arch == "amd64" && err != nil {
+				t.Fatal("source-only role changed the separate AMD64 frame target boundary", err)
+			}
+			for _, change := range []string{"GOFLAGS=-overlay=other", "GOARCH=arm64", "GOTOOLCHAIN=auto", "GOENV=relative", "GOEXPERIMENT=changed", "GOPACKAGESDRIVER=custom"} {
+				changed := request
+				changed.Environment = append([]string(nil), request.Environment...)
+				key, _, _ := strings.Cut(change, "=")
+				for index, value := range changed.Environment {
+					if strings.HasPrefix(value, key+"=") {
+						changed.Environment[index] = change
+					}
+				}
+				if _, err := sdkX86OriginalSourceEnvironment(changed); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("different compiler/profile acquired the original source role", change, err)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_segment_mov_caller_footprint_test.go b/x86_segment_mov_caller_footprint_test.go
new file mode 100644
index 000000000..e4e319a4e
--- /dev/null
+++ b/x86_segment_mov_caller_footprint_test.go
@@ -0,0 +1,54 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86SegmentMOVREXCallerFootprintUsesActualDestination(t *testing.T) {
+	addresses := []string{"-8(R8)", "-8(R8)(FS)", "-8(R8)(GS)"}
+	for _, scale := range []string{"1", "2", "4", "8"} {
+		addresses = append(addresses, "-8(R8)(CX*"+scale+")",
+			"-8(R8)(FS*"+scale+")", "-8(R8)(GS*"+scale+")")
+	}
+	if len(addresses) != 15 {
+		t.Fatal("complete independent ordinary/segment address footprint changed")
+	}
+	for _, address := range addresses {
+		for _, alias := range []Reg{DH, BH} {
+			t.Run(address+"/"+string(alias), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, "MOVB "+address+","+string(alias))
+				original := ins
+				original.Args = append([]Operand(nil), ins.Args...)
+				// The actual REX encoding reads DH/BH's ModRM register
+				// number as SI/DI's low byte, not as DX/BX's high byte.
+				root, destination := 6, SI
+				if alias == BH {
+					root, destination = 7, DI
+				}
+				form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, "amd64")
+				if !known || err != nil || form.destination != destination || form.bytes != 1 {
+					t.Fatal("typed native-load footprint differs from the actual REX byte row", form, known, err)
+				}
+				// This independent denial-only post-consumer runs after a
+				// separate transfer validated all reads. It cannot authorize
+				// the source address or retain the overwritten caller role.
+				before := [16]bool{2: true, 3: true, 6: true, 7: true}
+				origins := [16]uint16{2: 3, 3: 4, 6: 7, 7: 8}
+				want, wantOrigins := before, origins
+				want[root], wantOrigins[root] = false, 0
+				after := x86ResultCallerAddressesAfterTransfer(ins, before, before, nil, "amd64")
+				if after != want {
+					t.Fatal("caller post-consumer retained actual SI/DI or revoked unrelated textual DX/BX", after, want)
+				}
+				entry := map[int64]bool{2: true, 3: true, 6: true, 7: true}
+				if got := x86ResultCallerOriginsAfter(ins, origins, after, entry, "amd64"); got != wantOrigins {
+					t.Fatal("caller origin revocation disagrees with the actual written register", got, wantOrigins)
+				}
+				if !reflect.DeepEqual(ins, original) {
+					t.Fatal("post-consumer changed original source operands or Raw")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_segment_mov_encoding_test.go b/x86_segment_mov_encoding_test.go
new file mode 100644
index 000000000..415d42d98
--- /dev/null
+++ b/x86_segment_mov_encoding_test.go
@@ -0,0 +1,253 @@
+package plan9asm
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmoracle"
+)
+
+func x86SegmentMOVRegisters(arch string, width int) []Reg {
+	registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI}
+	if arch == "amd64" {
+		registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+	}
+	if width == 1 {
+		registers = append(registers, AL, CL, DL, BL, AH, CH, DH, BH)
+		if arch == "386" {
+			// Go synthesizes BP/SI/DI byte rows but rejects direct SP.
+			registers = append(append([]Reg{}, registers[:4]...), registers[5:]...)
+		} else {
+			registers = append(registers, BPB, SIB, DIB, R8B, R9B, R10B, R11B, R12B, R13B, R14B, R15B)
+		}
+	}
+	return registers
+}
+
+func TestX86SegmentMOVCompleteGoGrammarAndAliases(t *testing.T) {
+	// This existing independent oracle pins every row of all four actual
+	// ymov tables, including the distinct historical signed-imm32 table.
+	TestX86GPSIMDTransferCompleteLegacyOriginalTables(t)
+	x86OriginalMOVQAliases(t)
+	source, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, table := range []struct{ name, row string }{
+		{"ymovb", "{Zm_r,1,argList{Ymb,Yrb}}"},
+		{"ymovw", "{Zm_r,1,argList{Yml,Yrl}}"},
+		{"ymovl", "{Zm_r,1,argList{Yml,Yrl}}"},
+		{"ymovq", "{Zm_r,1,argList{Yml,Yrl}}"},
+	} {
+		definition := regexp.MustCompile(`(?s)var ` + table.name + ` = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(string(source))
+		if len(definition) != 2 {
+			t.Fatal("missing complete actual MOV table", table.name)
+		}
+		rows := regexp.MustCompile(`//[^\n]*`).ReplaceAllString(definition[1], "")
+		rows = strings.Join(strings.Fields(rows), "")
+		if strings.Count(rows, table.row) != 1 {
+			t.Fatal("actual native memory-to-GP row is missing or duplicated", table.name)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86SegmentMOVRows(arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				for _, address := range []string{"fixed", "fixed-zero", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"} {
+					_, memory := x86SegmentMOVAddress(arch, segment, address)
+					for _, destination := range x86SegmentMOVRegisters(arch, row.width) {
+						t.Run(fmt.Sprintf("%s/%s/%s/%s/%s", arch, row.op, segment, address, destination), func(t *testing.T) {
+							ins := x86ScalarLaneInstruction(t, row.op+" "+memory+","+string(destination))
+							original := ins
+							original.Args = append([]Operand(nil), ins.Args...)
+							wantSource := ins.Args[0]
+							if strings.HasPrefix(address, "segment-index-scale") {
+								wantSource.Mem.Segment, wantSource.Mem.Index, wantSource.Mem.Scale = Reg(segment), "", 0
+							}
+							form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch)
+							if !known || err != nil || form.bytes != int64(row.width) || form.destination != destination || !reflect.DeepEqual(form.source, wantSource) || !reflect.DeepEqual(ins, original) {
+								t.Fatal("complete typed segment MOV row/alias changed", form, known, err)
+							}
+						})
+					}
+				}
+				for _, mutation := range []string{"OffRaw", "IndexExt", "scale", "wide-offset", "unmodeled-CS-role", "illegal-source-GP-scaled-index"} {
+					name := "outside-modeled-source-role-" + mutation
+					if mutation == "unmodeled-CS-role" {
+						name = mutation // CS is valid Go syntax, outside this FS/GS role.
+					}
+					t.Run(arch+"/"+row.op+"/"+segment+"/"+name, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, row.op+" 24("+segment+"),DX")
+						switch mutation {
+						case "OffRaw":
+							ins.Args[0].Mem.OffRaw = "unresolved"
+						case "IndexExt":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.IndexExt, ins.Args[0].Mem.Scale = CX, "UXTW", 4
+						case "scale":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+						case "wide-offset":
+							ins.Args[0].Mem.Off = 1 << 32
+						case "unmodeled-CS-role":
+							ins.Args[0].Mem.Segment = "CS"
+						case "illegal-source-GP-scaled-index":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 4
+						}
+						if _, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, arch); known && err == nil {
+							if mutation == "unmodeled-CS-role" {
+								t.Fatal("FS/GS-only source projection borrowed an unmodeled Go segment role")
+							}
+							t.Fatal("typed segment source accepted a representation outside its modeled source role", mutation)
+						}
+					})
+				}
+			}
+		}
+	}
+	for _, alias := range []Reg{AH, CH, DH, BH} {
+		want := map[Reg]Reg{AH: SP, CH: BP, DH: SI, BH: DI}[alias]
+		ins := x86ScalarLaneInstruction(t, "MOVB -8(R8)(FS),"+string(alias))
+		form, known, err := x86ScalarNativeLoadProperties(ins.Op, ins, "amd64")
+		if !known || err != nil || form.destination != want {
+			t.Fatal("Go's actual REX byte-register number was not preserved", alias, form, err)
+		}
+	}
+}
+
+func TestX86SegmentMOVOriginalGoEncodingWitnesses(t *testing.T) {
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	if !producer.schema.indexPrefix386 {
+		t.Log("historical selected producer: 386 dynamic Index FS/GS emits no segment override; its object is not evidence of current segment-read execution equivalence")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, segment := range []string{"FS", "GS"} {
+			prefix := byte(0x64)
+			if segment == "GS" {
+				prefix = 0x65
+			}
+			for _, row := range x86SegmentMOVRows(arch) {
+				t.Run(arch+"/"+row.op+"/"+segment+"/fixed-bytes", func(t *testing.T) {
+					want := []byte{prefix}
+					if row.width == 2 {
+						want = append(want, 0x66)
+					} else if row.width == 8 {
+						want = append(want, 0x48)
+					}
+					opcode := byte(0x8b)
+					if row.width == 1 {
+						opcode = 0x8a
+					}
+					if arch == "386" {
+						want = append(want, opcode, 0x0d, 24, 0, 0, 0, 0xc3)
+					} else {
+						want = append(want, opcode, 0x0c, 0x25, 24, 0, 0, 0, 0xc3)
+					}
+					source := "TEXT original(SB),4,$0-0\n" + row.op + " 24(" + segment + "),CX\nRET\n"
+					if got := x86OrderingHintGoBytes(t, arch, source); !bytes.Equal(got, want) {
+						t.Fatalf("actual full original byte witness differs: %x != %x", got, want)
+					}
+				})
+			}
+			for _, witness := range []struct {
+				name, instruction string
+				bytes             []byte
+			}{
+				{"base", "MOVB -8(BX)(" + segment + "),CX", append(producer.schema.dynamicPrefix(arch, segment), 0x8a, 0x4b, 0xf8, 0xc3)},
+			} {
+				t.Run(arch+"/"+segment+"/"+witness.name+"-bytes", func(t *testing.T) {
+					got := x86OrderingHintGoBytes(t, arch, "TEXT original(SB),4,$0-0\n"+witness.instruction+"\nRET\n")
+					if !bytes.Equal(got, witness.bytes) {
+						t.Fatalf("actual complete dynamic-address bytes differ: %x != %x", got, witness.bytes)
+					}
+				})
+			}
+			for _, scale := range []string{"1", "2", "4", "8"} {
+				t.Run(arch+"/"+segment+"/segment-annotation-scale"+scale, func(t *testing.T) {
+					source := "TEXT original(SB),4,$0-0\nMOVL -8(BX)(" + segment + "*" + scale + "),DX\nRET\n"
+					want := append(producer.schema.dynamicPrefix(arch, segment), 0x8b, 0x53, 0xf8, 0xc3)
+					if got := x86OrderingHintGoBytes(t, arch, source); !bytes.Equal(got, want) {
+						t.Fatalf("segment annotation changed actual GP address/scale: %x != %x", got, want)
+					}
+				})
+			}
+			t.Run(arch+"/"+segment+"/illegal-GP-scaled-index-source", func(t *testing.T) {
+				x86SegmentMOVRejectScaledGPSource(t, arch, segment, producer.schema)
+			})
+			if arch == "amd64" {
+				for index, alias := range []Reg{AH, CH, DH, BH} {
+					t.Run(arch+"/"+segment+"/REX-"+string(alias), func(t *testing.T) {
+						source := "TEXT original(SB),4,$0-0\nMOVB -8(R8)(" + segment + ")," + string(alias) + "\nRET\n"
+						want := []byte{prefix, 0x41, 0x8a, byte(0x60 + 8*index), 0xf8, 0xc3}
+						if got := x86OrderingHintGoBytes(t, arch, source); !bytes.Equal(got, want) {
+							t.Fatalf("actual REX high-byte alias differs: %x != %x", got, want)
+						}
+					})
+				}
+			}
+		}
+		t.Run(arch+"/complete-register-address-banks", func(t *testing.T) {
+			var source strings.Builder
+			count := 0
+			for _, row := range x86SegmentMOVRows(arch) {
+				for _, segment := range []string{"FS", "GS"} {
+					for _, address := range []string{"fixed", "fixed-zero", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"} {
+						_, memory := x86SegmentMOVAddress(arch, segment, address)
+						for _, destination := range x86SegmentMOVRegisters(arch, row.width) {
+							fmt.Fprintf(&source, "TEXT original%d(SB),4,$0-0\n%s %s,%s\nRET\n", count, row.op, memory, destination)
+							count++
+						}
+					}
+				}
+			}
+			triple := "x86_64-unknown-linux-gnu"
+			want := 1610
+			if arch == "386" {
+				triple, want = "i386-unknown-linux-gnu", 434
+			}
+			if count != want || strings.Count(source.String(), "TEXT ") != want {
+				t.Fatal("independent complete grammar denominator changed", count, want)
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+		})
+	}
+	for _, op := range []string{"MOVQ", "MOVD", "MOVDQ2Q"} {
+		t.Run("386/no-GP-qword/"+op, func(t *testing.T) {
+			requireLEANativeGoObject(t, "386", "TEXT invalid(SB),4,$0-0\n"+op+" 24(FS),AX\nRET\n", false)
+		})
+	}
+}
+
+func x86SegmentMOVRejectScaledGPSource(t *testing.T, arch, segment string, schema x86SegmentMOVEncoderSchema) {
+	t.Helper()
+	// This is an exact actual-Go invalid address tuple, separately from a
+	// legal source's missing numerical/native permissions. The generic
+	// oracle intentionally does not whitelist positionless asmidx messages.
+	source := "TEXT invalid(SB),4,$0-0\nMOVL -8(" + segment + ")(CX*4),DX\nRET\n"
+	dir := t.TempDir()
+	input, object := filepath.Join(dir, "invalid.s"), filepath.Join(dir, "invalid.o")
+	if err := os.WriteFile(input, []byte(source), 0600); err != nil {
+		t.Fatal(err)
+	}
+	driver, _ := x86LEAActualSDKDriver(t)
+	stage, cancelStage := runtimeOracleStageContext(t)
+	defer cancelStage()
+	ctx, cancel := context.WithTimeout(stage, time.Minute)
+	defer cancel()
+	command := exec.CommandContext(ctx, driver, "tool", "asm", "-p", "segment", "-o", object, input)
+	command.Env = append(os.Environ(), "GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOTOOLCHAIN=local", "GOENV=off", "GOWORK=off")
+	output, err := runtimeOracleCombinedOutput(ctx, command)
+	if failure := goasmoracle.CheckOutcome(input, object, output, nil, err, ctx.Err(), false, 0, func(filename, diagnostic string) bool {
+		original, readErr := os.ReadFile(filename)
+		return readErr == nil && schema.acceptsScaledDiagnostic(filename, input, original, []byte(source), segment, diagnostic)
+	}); failure != nil {
+		t.Fatalf("exact invalid original Go address tuple lost its bound source diagnostic: %v\n%s", failure, output)
+	}
+}
diff --git a/x86_segment_mov_objects_test.go b/x86_segment_mov_objects_test.go
new file mode 100644
index 000000000..15120c665
--- /dev/null
+++ b/x86_segment_mov_objects_test.go
@@ -0,0 +1,149 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86SegmentMOVFunction struct {
+	name                string
+	width, addressSpace int
+}
+
+func x86SegmentMOVCompleteSource(t *testing.T, arch string) (string, string, []x86SegmentMOVFunction) {
+	t.Helper()
+	var source, declarations strings.Builder
+	var functions []x86SegmentMOVFunction
+	appendFunction := func(assembly, declaration string, width, space int) {
+		name := fmt.Sprintf("segment%d", len(functions))
+		if strings.Count(assembly, "·view(SB)") != 1 || strings.Count(declaration, "view(") != 1 {
+			t.Fatal("complete segment fixture lost its one source/type identity")
+		}
+		source.WriteString(strings.Replace(assembly, "·view(SB)", "·"+name+"(SB)", 1))
+		declarations.WriteString(strings.Replace(declaration, "view(", name+"(", 1) + "\n")
+		functions = append(functions, x86SegmentMOVFunction{name, width, space})
+	}
+	addresses := []string{"fixed", "fixed-zero", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"}
+	if arch == "386" {
+		addresses = append(addresses, "mode32-BP")
+	}
+	for _, row := range x86SegmentMOVRows(arch) {
+		for _, segment := range []string{"FS", "GS"} {
+			space := 257
+			if segment == "GS" {
+				space = 256
+			}
+			for _, address := range addresses {
+				for _, dead := range []bool{false, true} {
+					assembly, declaration := x86SegmentMOVFixture(t, arch, row, segment, address, dead)
+					appendFunction(assembly, declaration, row.width, space)
+				}
+			}
+			assembly, declaration := x86SegmentMOVVoidFixture(arch, row, segment)
+			appendFunction(assembly, declaration, row.width, space)
+			for _, address := range []string{"fixed", "base"} {
+				assembly, declaration := x86SegmentMOVVoidAddressFixture(arch, row, segment, address)
+				appendFunction(assembly, declaration, row.width, space)
+			}
+		}
+	}
+	if arch == "amd64" {
+		for _, segment := range []string{"FS", "GS"} {
+			space := 257
+			if segment == "GS" {
+				space = 256
+			}
+			for _, alias := range []string{"DH", "BH"} {
+				for _, dead := range []bool{false, true} {
+					assembly, declaration := x86SegmentMOVREXFixture(t, segment, alias, dead)
+					appendFunction(assembly, declaration, 1, space)
+				}
+			}
+		}
+	}
+	want := 212
+	if arch == "386" {
+		want = 114
+	}
+	if len(functions) != want || strings.Count(source.String(), "TEXT ") != want || strings.Count(declarations.String(), "func ") != want {
+		t.Fatal("independent complete segment source denominator changed", len(functions), want)
+	}
+	return source.String(), declarations.String(), functions
+}
+
+func x86SegmentMOVTargetCompleteObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	known := false
+	for _, target := range x86RawReturnTargets {
+		known = known || target.arch == arch && target.triple == triple
+	}
+	if !known {
+		t.Fatal("complete segment object owner requires a registered target", arch, triple)
+	}
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	if !producer.schema.indexPrefix386 {
+		t.Log("historical selected Go producer objects retain all original TEXTs, but its dynamic 386 FS/GS Index forms have no segment prefix; they do not certify equivalence to current named-source LLVM segment reads")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	t.Run(triple, func(t *testing.T) {
+		source, declarations, functions := x86SegmentMOVCompleteSource(t, arch)
+		x86LEAActualTargetGoObject(t, arch, triple, source)
+		names := make([]string, len(functions))
+		for index, function := range functions {
+			names[index] = function.name
+		}
+		axes := 0
+		for _, api := range []string{"text", "module", "Go"} {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete uncut segment MOV source was rejected", err)
+			}
+			for _, irLevel := range []string{"0", "2"} {
+				input := ir
+				if irLevel == "2" {
+					input = x86DwordProductIROptimize(t, input)
+				}
+				if strings.Count(input, "\ndefine ") != len(functions) {
+					t.Fatal("whole-file translation added or cropped a function", api, irLevel)
+				}
+				bodies := x86StringMemoryFunctions(t, input, names)
+				for _, function := range functions {
+					x86SegmentMOVReadBody(t, bodies[function.name], function.width, function.addressSpace)
+				}
+				for _, backendLevel := range []string{"0", "2"} {
+					axes++
+					t.Run(api+"/IR"+irLevel+"/backend"+backendLevel, func(t *testing.T) {
+						x86PackedStringCompileObject(t, llc, triple, input, "-O"+backendLevel)
+					})
+				}
+			}
+		}
+		if axes != 12 {
+			t.Fatal("complete three-API/IR/backend object denominator changed", axes)
+		}
+	})
+}
+
+func TestX86SegmentMOVLinux386CompleteObjects(t *testing.T) {
+	x86SegmentMOVTargetCompleteObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86SegmentMOVWindows386CompleteObjects(t *testing.T) {
+	x86SegmentMOVTargetCompleteObjects(t, "386", "i686-pc-windows-msvc")
+}
+
+func TestX86SegmentMOVDarwinAMD64CompleteObjects(t *testing.T) {
+	x86SegmentMOVTargetCompleteObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86SegmentMOVLinuxAMD64CompleteObjects(t *testing.T) {
+	x86SegmentMOVTargetCompleteObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86SegmentMOVWindowsAMD64CompleteObjects(t *testing.T) {
+	x86SegmentMOVTargetCompleteObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
diff --git a/x86_segment_mov_producer_test.go b/x86_segment_mov_producer_test.go
new file mode 100644
index 000000000..04e05572c
--- /dev/null
+++ b/x86_segment_mov_producer_test.go
@@ -0,0 +1,357 @@
+package plan9asm
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/constant"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This is a test-only observation of the selected assembler's source schema.
+// It never selects translator semantics or grants a source/native capability.
+type x86SegmentMOVEncoderSchema struct {
+	indexPrefix386  bool
+	namedDiagnostic bool
+	registers       map[string]int64
+}
+
+var x86SegmentMOVProducerSources = []string{
+	"src/cmd/internal/obj/x86/asm6.go",
+	"src/cmd/asm/internal/asm/parse.go",
+	"src/cmd/internal/obj/x86/a.out.go",
+	"src/cmd/internal/obj/util.go",
+}
+
+func x86SegmentMOVSourceFunction(source []byte, name string) ([]byte, error) {
+	fset := token.NewFileSet()
+	file, err := parser.ParseFile(fset, "selected.go", source, 0)
+	if err != nil {
+		return nil, err
+	}
+	var found *ast.FuncDecl
+	for _, declaration := range file.Decls {
+		if function, ok := declaration.(*ast.FuncDecl); ok && function.Name.Name == name {
+			if found != nil {
+				return nil, fmt.Errorf("duplicate selected function %s", name)
+			}
+			found = function
+		}
+	}
+	if found == nil || found.Body == nil {
+		return nil, fmt.Errorf("missing selected function %s", name)
+	}
+	return source[fset.Position(found.Pos()).Offset:fset.Position(found.End()).Offset], nil
+}
+
+func x86SegmentMOVInspectProducer(sources map[string][]byte) (x86SegmentMOVEncoderSchema, error) {
+	var result x86SegmentMOVEncoderSchema
+	// Complete AST-bounded functions pin the two independently inspected
+	// producer schemas. An unfamiliar producer fails observation, not skips.
+	profiles := []struct {
+		prefix, index, address, parse string
+		indexPrefix, named            bool
+	}{
+		// Observed Go1.20.14: I386 early return dominates the Index switch;
+		// asmidx writes the selected enum's numeric register identities.
+		{
+			"4b1d710df7230ccfb9abb463fa692b57a492fa44ddef3feda094eb963822dff1",
+			"3c08a9be657cff57a08638f4366576bdc6c7a951711855d417a70f36fe7db17d",
+			"2c2e8d87991ead9b37a043704619d0f862f0039644c9feb711e9cf22e5cb8f9d",
+			"e973c5bb650e3cecba96f4ac6934b17388cf4c64907d0006340be23e3e2e30f5",
+			false, false,
+		},
+		// Observed Go1.21.13/1.22.12/1.23.12: the I386 early return
+		// is gone, but asmidx retains numeric identities. asmandsz has
+		// the changed Windows TLS relocation condition.
+		{
+			"7359b12c59641f0ca2b3179bdd5c631dd91b721cf3b68d2a05ffd837992bb881",
+			"3c08a9be657cff57a08638f4366576bdc6c7a951711855d417a70f36fe7db17d",
+			"db9c3b90208841426493ed3e3f475000462e8a53a5e0d4e67a68e11f8c3c44c9",
+			"e973c5bb650e3cecba96f4ac6934b17388cf4c64907d0006340be23e3e2e30f5",
+			true, false,
+		},
+		// Observed Go1.24.13/1.25.14/1.26.9: named diagnostics and
+		// the current relocation writer, with the earlier parser body.
+		{
+			"7359b12c59641f0ca2b3179bdd5c631dd91b721cf3b68d2a05ffd837992bb881",
+			"aecd67962a374b23f9f57ed1dbfe281bd91e801118d9c3478fa54d150dd90f06",
+			"dca5b846b2f8e47be6c360076cbddc4d3a95a879a3e7cc90a581d34a10287a46",
+			"e973c5bb650e3cecba96f4ac6934b17388cf4c64907d0006340be23e3e2e30f5",
+			true, true,
+		},
+		// Observed Go1.27.2: explicit Index FS/GS reaches the prefix switch;
+		// asmidx writes register names. These hashes are not a build-version gate.
+		{
+			"7359b12c59641f0ca2b3179bdd5c631dd91b721cf3b68d2a05ffd837992bb881",
+			"aecd67962a374b23f9f57ed1dbfe281bd91e801118d9c3478fa54d150dd90f06",
+			"dca5b846b2f8e47be6c360076cbddc4d3a95a879a3e7cc90a581d34a10287a46",
+			"c15ef57b88cb006f21dd98b0b15b52a9082d899d9afdb075f454a02fdd8b516a",
+			true, true,
+		},
+	}
+	var hashes []string
+	for index, name := range []string{"prefixof", "asmidx", "asmandsz", "registerIndirect"} {
+		filename := x86SegmentMOVProducerSources[0]
+		if index == 3 {
+			filename = x86SegmentMOVProducerSources[1]
+		}
+		function, err := x86SegmentMOVSourceFunction(sources[filename], name)
+		if err != nil {
+			return result, err
+		}
+		hashes = append(hashes, fmt.Sprintf("%x", sha256.Sum256(function)))
+	}
+	matched := false
+	for _, profile := range profiles {
+		if strings.Join(hashes, "/") == strings.Join([]string{profile.prefix, profile.index, profile.address, profile.parse}, "/") {
+			result.indexPrefix386, result.namedDiagnostic, matched = profile.indexPrefix, profile.named, true
+		}
+	}
+	if !matched {
+		return result, fmt.Errorf("unobserved selected prefix/index/address/parser schema: %v", hashes)
+	}
+	registers, err := x86SegmentMOVProducerRegisters(sources[x86SegmentMOVProducerSources[2]], sources[x86SegmentMOVProducerSources[3]])
+	if err != nil {
+		return result, err
+	}
+	result.registers = registers
+	return result, nil
+}
+
+func x86SegmentMOVProducerRegisters(registerSource, objectSource []byte) (map[string]int64, error) {
+	objects, err := parser.ParseFile(token.NewFileSet(), "util.go", objectSource, 0)
+	if err != nil {
+		return nil, err
+	}
+	var base int64
+	found := false
+	for _, declaration := range objects.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST {
+			continue
+		}
+		for _, specification := range group.Specs {
+			value := specification.(*ast.ValueSpec)
+			if len(value.Names) != 1 || value.Names[0].Name != "RBaseAMD64" || len(value.Values) != 1 {
+				continue
+			}
+			expression, ok := value.Values[0].(*ast.BinaryExpr)
+			if !ok || expression.Op != token.MUL || found {
+				return nil, fmt.Errorf("unknown register base declaration")
+			}
+			left, leftOK := expression.X.(*ast.BasicLit)
+			right, rightOK := expression.Y.(*ast.BasicLit)
+			if !leftOK || !rightOK || left.Kind != token.INT || right.Kind != token.INT {
+				return nil, fmt.Errorf("unknown register base expression")
+			}
+			base, found = constant.Int64Val(constant.BinaryOp(constant.MakeFromLiteral(left.Value, token.INT, 0), token.MUL, constant.MakeFromLiteral(right.Value, token.INT, 0)))
+		}
+	}
+	if !found || base <= 0 || base > 1<<30 {
+		return nil, fmt.Errorf("missing bounded actual register base")
+	}
+	registers, err := parser.ParseFile(token.NewFileSet(), "a.out.go", registerSource, 0)
+	if err != nil {
+		return nil, err
+	}
+	for _, declaration := range registers.Decls {
+		group, ok := declaration.(*ast.GenDecl)
+		if !ok || group.Tok != token.CONST || len(group.Specs) == 0 {
+			continue
+		}
+		first := group.Specs[0].(*ast.ValueSpec)
+		if len(first.Names) != 1 || first.Names[0].Name != "REG_AL" || len(first.Values) != 1 {
+			continue
+		}
+		expression, ok := first.Values[0].(*ast.BinaryExpr)
+		if !ok || expression.Op != token.ADD {
+			return nil, fmt.Errorf("unknown register iota expression")
+		}
+		selector, leftOK := expression.X.(*ast.SelectorExpr)
+		iota, rightOK := expression.Y.(*ast.Ident)
+		if !leftOK || !rightOK || iota.Name != "iota" || selector.Sel.Name != "RBaseAMD64" {
+			return nil, fmt.Errorf("unknown actual register iota base")
+		}
+		object, ok := selector.X.(*ast.Ident)
+		if !ok || object.Name != "obj" {
+			return nil, fmt.Errorf("unknown actual register namespace")
+		}
+		result := make(map[string]int64)
+		for index, specification := range group.Specs {
+			value := specification.(*ast.ValueSpec)
+			if len(value.Names) != 1 || value.Type != nil || index != 0 && len(value.Values) != 0 {
+				return nil, fmt.Errorf("unknown register enum shape")
+			}
+			name := value.Names[0].Name
+			if _, duplicate := result[name]; duplicate {
+				return nil, fmt.Errorf("duplicate register constant")
+			}
+			result[name] = base + int64(index)
+			if name == "REG_GS" {
+				if result["REG_CX"] == 0 || result["REG_FS"] == 0 {
+					return nil, fmt.Errorf("incomplete actual register tuple")
+				}
+				return result, nil
+			}
+		}
+	}
+	return nil, fmt.Errorf("missing complete actual register enum")
+}
+
+type x86SegmentMOVSelectedEncoder struct {
+	schema  x86SegmentMOVEncoderSchema
+	sources map[string][]byte
+}
+
+func x86SegmentMOVObserveSelectedEncoder(t *testing.T) x86SegmentMOVSelectedEncoder {
+	t.Helper()
+	driver, _ := x86LEAActualSDKDriver(t)
+	tool := "asm"
+	if runtime.GOOS == "windows" {
+		tool += ".exe"
+	}
+	paths := []string{driver, filepath.Join(runtime.GOROOT(), "pkg/tool", runtime.GOOS+"_"+runtime.GOARCH, tool)}
+	for _, filename := range x86SegmentMOVProducerSources {
+		paths = append(paths, filepath.Join(runtime.GOROOT(), filepath.FromSlash(filename)))
+	}
+	sources := make(map[string][]byte)
+	for index, filename := range paths {
+		data, err := os.ReadFile(filename)
+		real, realErr := filepath.EvalSymlinks(filename)
+		if err != nil || realErr != nil {
+			t.Fatalf("selected producer observation missing %s: %v %v", filename, err, realErr)
+		}
+		if index >= 2 {
+			sources[x86SegmentMOVProducerSources[index-2]] = data
+		}
+		filename, real, want := filename, real, sha256.Sum256(data)
+		t.Cleanup(func() {
+			current, err := os.ReadFile(filename)
+			currentReal, realErr := filepath.EvalSymlinks(filename)
+			if err != nil || realErr != nil || currentReal != real || sha256.Sum256(current) != want {
+				t.Errorf("selected producer source/tool changed: %s", filename)
+			}
+		})
+		t.Logf("selected producer observation path=%s sha256=%x", filename, sha256.Sum256(data))
+	}
+	schema, err := x86SegmentMOVInspectProducer(sources)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual selected encoder schema: 386 Index segment prefix=%v, named asmidx diagnostic=%v; observation only, no source/native authority", schema.indexPrefix386, schema.namedDiagnostic)
+	return x86SegmentMOVSelectedEncoder{schema, sources}
+}
+
+func (schema x86SegmentMOVEncoderSchema) dynamicPrefix(arch, segment string) []byte {
+	if arch == "386" && !schema.indexPrefix386 {
+		return nil
+	}
+	if segment == "FS" {
+		return []byte{0x64}
+	}
+	return []byte{0x65}
+}
+
+func (schema x86SegmentMOVEncoderSchema) acceptsScaledDiagnostic(filename, wantFilename string, source, wantSource []byte, segment, diagnostic string) bool {
+	if filename != wantFilename || !bytes.Equal(source, wantSource) || segment != "FS" && segment != "GS" {
+		return false
+	}
+	index, hasIndex := schema.registers["REG_CX"]
+	base, hasBase := schema.registers["REG_"+segment]
+	if !hasIndex || !hasBase {
+		return false
+	}
+	want := fmt.Sprintf("asm: asmidx: bad address 4/%d/%d\nasm: assembly failed", index, base)
+	if schema.namedDiagnostic {
+		want = "asm: asmidx: bad address 4/CX/" + segment + "\nasm: assembly failed"
+	}
+	return strings.TrimSpace(strings.ReplaceAll(diagnostic, "\r\n", "\n")) == want
+}
+
+func TestX86SegmentMOVSelectedProducerSchemaRejectsUnknownAST(t *testing.T) {
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	t.Run("actual-complete-schema", func(t *testing.T) {
+		if _, err := x86SegmentMOVInspectProducer(producer.sources); err != nil {
+			t.Fatal(err)
+		}
+	})
+	for _, mutation := range []struct{ name, function, old, replacement string }{
+		{"prefix-effect", "prefixof", "return 0x64", "return 0x66"},
+		{"prefix-declaration", "prefixof", "func prefixof", "func otherPrefix"},
+		{"diagnostic-writer", "asmidx", "asmidx: bad address", "asmidx: unknown address"},
+		{"address-role", "asmandsz", "a.Index != REG_TLS", "a.Index != REG_FS"},
+		{"parser-identity", "registerIndirect", "a.Index = r1", "a.Index = r2"},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			filename := x86SegmentMOVProducerSources[0]
+			if mutation.function == "registerIndirect" {
+				filename = x86SegmentMOVProducerSources[1]
+			}
+			original, err := x86SegmentMOVSourceFunction(producer.sources[filename], mutation.function)
+			if err != nil || !bytes.Contains(original, []byte(mutation.old)) {
+				t.Fatal("mutation lost its exact actual function anchor", err)
+			}
+			changed := bytes.Replace(original, []byte(mutation.old), []byte(mutation.replacement), 1)
+			sources := make(map[string][]byte)
+			for name, source := range producer.sources {
+				sources[name] = append([]byte(nil), source...)
+			}
+			sources[filename] = bytes.Replace(sources[filename], original, changed, 1)
+			if _, err := x86SegmentMOVInspectProducer(sources); err == nil {
+				t.Fatal("unobserved actual producer AST borrowed a calibrated encoding/diagnostic")
+			}
+		})
+	}
+	for _, filename := range x86SegmentMOVProducerSources {
+		t.Run("missing-"+filepath.Base(filename), func(t *testing.T) {
+			sources := make(map[string][]byte)
+			for name, source := range producer.sources {
+				if name != filename {
+					sources[name] = source
+				}
+			}
+			if _, err := x86SegmentMOVInspectProducer(sources); err == nil {
+				t.Fatal("incomplete selected source inventory accepted")
+			}
+		})
+	}
+}
+
+func TestX86SegmentMOVSelectedProducerDiagnosticReaderExactIdentity(t *testing.T) {
+	producer := x86SegmentMOVObserveSelectedEncoder(t)
+	for _, segment := range []string{"FS", "GS"} {
+		source := []byte("TEXT invalid(SB),4,$0-0\nMOVL -8(" + segment + ")(CX*4),DX\nRET\n")
+		good := fmt.Sprintf("asm: asmidx: bad address 4/%d/%d\nasm: assembly failed", producer.schema.registers["REG_CX"], producer.schema.registers["REG_"+segment])
+		if producer.schema.namedDiagnostic {
+			good = "asm: asmidx: bad address 4/CX/" + segment + "\nasm: assembly failed"
+		}
+		for _, row := range []struct {
+			name, filename, text, diagnostic string
+			accepted                         bool
+		}{
+			{"exact", "bound.s", string(source), good, true},
+			{"CRLF", "bound.s", string(source), strings.ReplaceAll(good, "\n", "\r\n"), true},
+			{"foreign-file", "foreign.s", string(source), good, false},
+			{"changed-source", "bound.s", string(source) + "NOP\n", good, false},
+			{"arbitrary-numbers", "bound.s", string(source), "asm: asmidx: bad address 4/12345/67890\nasm: assembly failed", false},
+			{"swapped-registers", "bound.s", string(source), fmt.Sprintf("asm: asmidx: bad address 4/%d/%d\nasm: assembly failed", producer.schema.registers["REG_"+segment], producer.schema.registers["REG_CX"]), false},
+			{"wrong-scale", "bound.s", string(source), strings.Replace(good, "address 4/", "address 8/", 1), false},
+			{"extra-diagnostic", "bound.s", string(source), good + "\nother source failed", false},
+			{"missing-terminal", "bound.s", string(source), strings.Split(good, "\n")[0], false},
+		} {
+			t.Run(segment+"/"+row.name, func(t *testing.T) {
+				if got := producer.schema.acceptsScaledDiagnostic(row.filename, "bound.s", []byte(row.text), source, segment, row.diagnostic); got != row.accepted {
+					t.Fatal("diagnostic lost exact selected-source/writer/register identity", got, row.accepted)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_segment_mov_test.go b/x86_segment_mov_test.go
new file mode 100644
index 000000000..d9eb615a2
--- /dev/null
+++ b/x86_segment_mov_test.go
@@ -0,0 +1,434 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent source spellings and returned byte widths. Neither this test
+// inventory nor a segment name is an initialized-pointee or pointer witness.
+type x86SegmentMOVRow struct {
+	op, store, result string
+	width             int
+}
+
+func x86SegmentMOVRows(arch string) []x86SegmentMOVRow {
+	rows := []x86SegmentMOVRow{{"MOVB", "MOVB", "uint8", 1}, {"MOVW", "MOVW", "uint16", 2}, {"MOVL", "MOVL", "uint32", 4}}
+	if arch == "amd64" {
+		rows = append(rows, x86SegmentMOVRow{"MOVQ", "MOVQ", "uint64", 8},
+			x86SegmentMOVRow{"MOVD", "MOVQ", "uint64", 8}, x86SegmentMOVRow{"MOVDQ2Q", "MOVQ", "uint64", 8})
+	}
+	return rows
+}
+
+func x86SegmentMOVAddress(arch, segment, kind string) (string, string) {
+	move := "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	switch kind {
+	case "fixed":
+		return "", "24(" + segment + ")"
+	case "fixed-zero":
+		return "", "0(" + segment + ")"
+	case "base":
+		return move + " offset+0(FP),BX\n", "-8(BX)(" + segment + ")"
+	case "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8":
+		// The second register is the segment annotation, not a numerical
+		// scaled index. The actual Go encoder ignores its scale field.
+		scale := strings.TrimPrefix(kind, "segment-index-scale")
+		return move + " offset+0(FP),BX\n", "-8(BX)(" + segment + "*" + scale + ")"
+	case "mode32-BP":
+		return "MOVL offset+0(FP),BP\n", "-8(BP)(" + segment + ")"
+	default:
+		panic("unknown independent segment address fixture")
+	}
+}
+
+func x86SegmentMOVFixture(t *testing.T, arch string, row x86SegmentMOVRow, segment, address string, dead bool) (string, string) {
+	t.Helper()
+	setup, memory := x86SegmentMOVAddress(arch, segment, address)
+	body := setup + row.op + " " + memory + ",DX\n"
+	result := "DX"
+	if dead {
+		result = "$7"
+	}
+	body += row.store + " " + result + ",ret+RESULT(FP)"
+	declaration := "func view(offset uintptr) " + row.result
+	return x86ResultGPSIMDAdmissionSource(t, arch, declaration, body), declaration
+}
+
+func x86SegmentMOVReadIR(t *testing.T, ir string, width, addressSpace int) {
+	x86SegmentMOVNamedReadIR(t, ir, "view", width, addressSpace)
+}
+
+func x86SegmentMOVNamedReadIR(t *testing.T, ir, name string, width, addressSpace int) {
+	t.Helper()
+	x86SegmentMOVReadBody(t, x86StringMemoryFunction(t, ir, name), width, addressSpace)
+}
+
+func x86SegmentMOVReadBody(t *testing.T, body string, width, addressSpace int) {
+	t.Helper()
+	want := fmt.Sprintf("load volatile i%d, ptr addrspace(%d)", 8*width, addressSpace)
+	if strings.Count(body, want) != 1 || strings.Count(body, "load volatile ") != 1 {
+		t.Fatalf("exact segment read/width/volatility was changed, duplicated or discarded; want %q\n%s", want, body)
+	}
+	if strings.Contains(body, fmt.Sprintf("load i%d, ptr addrspace(%d)", 8*width, addressSpace)) {
+		t.Fatal("native segment read became an ordinary eliminable load", body)
+	}
+}
+
+func TestX86SegmentMOVNumericalContinuationThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		addresses := []string{"fixed", "fixed-zero", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"}
+		if target.arch == "386" {
+			addresses = append(addresses, "mode32-BP")
+		}
+		for _, row := range x86SegmentMOVRows(target.arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				space := 257
+				if segment == "GS" {
+					space = 256
+				}
+				for _, address := range addresses {
+					for _, dead := range []bool{false, true} {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(fmt.Sprintf("%s/%s/%s/%s/dead%t/%s", target.triple, row.op, segment, address, dead, api), func(t *testing.T) {
+								source, declaration := x86SegmentMOVFixture(t, target.arch, row, segment, address, dead)
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+								if err != nil || ir == "" {
+									t.Fatal("paired segment read lost its exact numerical continuation", err)
+								}
+								x86SegmentMOVReadIR(t, ir, row.width, space)
+								x86SegmentMOVReadIR(t, x86DwordProductIROptimize(t, ir), row.width, space)
+							})
+						}
+					}
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.op+"/"+segment+"/void-dead/"+api, func(t *testing.T) {
+						source, declaration := x86SegmentMOVVoidFixture(target.arch, row, segment)
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("void discarded result lost its observable hardware read", err)
+						}
+						x86SegmentMOVReadIR(t, ir, row.width, space)
+						x86SegmentMOVReadIR(t, x86DwordProductIROptimize(t, ir), row.width, space)
+					})
+				}
+				for _, address := range []string{"fixed", "base"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row.op+"/"+segment+"/void-address/"+address+"/"+api, func(t *testing.T) {
+							source, declaration := x86SegmentMOVVoidAddressFixture(target.arch, row, segment, address)
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("void native read rejected its actual hardware/NUM address", err)
+							}
+							x86SegmentMOVReadIR(t, ir, row.width, space)
+							x86SegmentMOVReadIR(t, x86DwordProductIROptimize(t, ir), row.width, space)
+						})
+					}
+				}
+			}
+		}
+		if target.arch == "amd64" {
+			for _, segment := range []string{"FS", "GS"} {
+				for _, alias := range []string{"DH", "BH"} {
+					for _, dead := range []bool{false, true} {
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(fmt.Sprintf("%s/REX/%s/%s/dead%t/%s", target.triple, segment, alias, dead, api), func(t *testing.T) {
+								source, declaration := x86SegmentMOVREXFixture(t, segment, alias, dead)
+								ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+								if err != nil || ir == "" {
+									t.Fatal("actual REX byte alias lost its numerical low byte", err)
+								}
+								space := 257
+								if segment == "GS" {
+									space = 256
+								}
+								x86SegmentMOVReadIR(t, ir, 1, space)
+								x86SegmentMOVReadIR(t, x86DwordProductIROptimize(t, ir), 1, space)
+							})
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+func x86SegmentMOVVoidFixture(arch string, row x86SegmentMOVRow, segment string) (string, string) {
+	// No GP initialization is needed for a hardware segment's fixed offset.
+	// Its zero displacement is not a pointer to address-space-zero null.
+	return "TEXT ·view(SB),4,$0-0\n" + row.op + " 0(" + segment + "),DX\nRET\n", "func view()"
+}
+
+func x86SegmentMOVVoidAddressFixture(arch string, row x86SegmentMOVRow, segment, address string) (string, string) {
+	setup, memory := x86SegmentMOVAddress(arch, segment, address)
+	frame, declaration := 0, "func view()"
+	if address == "base" {
+		frame, declaration = 8, "func view(offset uintptr)"
+		if arch == "386" {
+			frame = 4
+		}
+	}
+	return fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s%s %s,DX\nRET\n", frame, setup, row.op, memory), declaration
+}
+
+func x86SegmentMOVREXFixture(t *testing.T, segment, alias string, dead bool) (string, string) {
+	t.Helper()
+	actual := "SI"
+	if alias == "BH" {
+		actual = "DI"
+	} else if alias != "DH" {
+		t.Fatal("unexpected independent REX alias fixture", alias)
+	}
+	result := actual
+	if dead {
+		result = "$7"
+	}
+	declaration := "func view(offset uintptr) uint8"
+	body := "MOVQ offset+0(FP),R8\nMOVB -8(R8)(" + segment + ")," + alias + "\nMOVB " + result + ",ret+RESULT(FP)"
+	return x86ResultGPSIMDAdmissionSource(t, "amd64", declaration, body), declaration
+}
+
+func TestX86SegmentMOVCannotGrantIndependentAuthority(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86SegmentMOVRows(target.arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				load := row.op + " 24(" + segment + "),DX\n"
+				finish := row.store + " $7,ret+RESULT(FP)"
+				declaration := "func view(offset uintptr,p *byte) " + row.result
+				controls := []struct{ name, body, declaration string }{
+					{"missing-result", load, declaration},
+					{"unused-bool-parameter-missing-result", load, "func view(offset uintptr,unused bool) " + row.result},
+					{"other-storage-role-missing-result", load + "PXOR X0,X0", declaration},
+					{"unknown-offset", row.op + " -8(BX)(" + segment + "),DX\n" + finish, declaration},
+					{"partial-offset", "MOVW $8,BX\n" + row.op + " -8(BX)(" + segment + "),DX\n" + finish, declaration},
+					{"pointer-offset", fmt.Sprintf("%s p+%d(FP),BX\n", move, word) + row.op + " -8(BX)(" + segment + "),DX\n" + finish, declaration},
+					{"pointer-overwritten-offset", move + " offset+0(FP),BX\n" + fmt.Sprintf("%s p+%d(FP),BX\n", move, word) + row.op + " -8(BX)(" + segment + "),DX\n" + finish, declaration},
+					{"unknown-join", move + " offset+0(FP),AX\nCMPL AX,$0\nJE joined\n" + move + " offset+0(FP),BX\njoined:\n" + row.op + " -8(BX)(" + segment + "),DX\n" + finish, declaration},
+					{"TLS-pseudo-register", row.op + " 24(TLS),DX\n" + finish, declaration},
+					{"physical-SP-offset", row.op + " -8(SP)(" + segment + "),DX\n" + finish, declaration},
+					{"store-permission", load + "MOVL $7,AX\n" + row.store + " AX,24(" + segment + ")\n" + finish, declaration},
+					{"numerical-address-not-pointer", move + " offset+0(FP),DI\n" + load + row.store + " DX,(DI)\n" + finish, declaration},
+					{"loaded-value-not-pointer", "MOVL $0,DX\n" + load + "MOVB (DX),AX\n" + finish, declaration},
+					{"result-address-not-pointer", "MOVL $0,DX\n" + load + move + " DX,SI\nMOVB $7,(SI)\n" + finish, declaration},
+					{"noncanonical-bool", "MOVL $0,DX\n" + load + "MOVB DX,ret+RESULT(FP)", "func view(offset uintptr,p *byte) bool"},
+					{"pointer-result", "MOVL $0,DX\n" + load + move + " DX,ret+RESULT(FP)", "func view(offset uintptr,p *byte) *byte"},
+					{"unknown-FLAGS", load + "SETEQ AX\nMOVB AX,ret+RESULT(FP)", "func view(offset uintptr,p *byte) bool"},
+				}
+				if target.arch == "amd64" {
+					controls = append(controls, []struct{ name, body, declaration string }{
+						{"physical-BP-offset", row.op + " -8(BP)(" + segment + "),DX\n" + finish, declaration},
+						{"physical-BP-destination", row.op + " 24(" + segment + "),BP\n" + finish, declaration},
+						{"REX-SP-destination", "MOVQ offset+0(FP),R8\nMOVB -8(R8)(" + segment + "),AH\n" + finish, declaration},
+						{"REX-BP-destination", "MOVQ offset+0(FP),R8\nMOVB -8(R8)(" + segment + "),CH\n" + finish, declaration},
+					}...)
+				}
+				for _, control := range controls {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row.op+"/"+segment+"/"+control.name+"/"+api, func(t *testing.T) {
+							source := x86ResultGPSIMDAdmissionSource(t, target.arch, control.declaration, control.body)
+							ir, err := x86ScalarFPBitViewAPI(t, source, control.declaration, target.arch, target.triple, api)
+							if control.name == "numerical-address-not-pointer" || control.name == "loaded-value-not-pointer" || control.name == "result-address-not-pointer" {
+								space := 257
+								if segment == "GS" {
+									space = 256
+								}
+								if err != nil || strings.Count(ir, fmt.Sprintf("load volatile i%d, ptr addrspace(%d)", row.width*8, space)) != 1 {
+									t.Fatal("defined NUM continuation lost its exact segment read", err)
+								}
+								if control.name == "loaded-value-not-pointer" {
+									if strings.Count(ir, "load volatile ") != 2 || !strings.Contains(ir, "load volatile i8,") {
+										t.Fatal("segment value lost its independent paired byte read")
+									}
+								} else {
+									bits := row.width * 8
+									if control.name == "result-address-not-pointer" {
+										bits = 8
+									}
+									if strings.Count(ir, "store volatile ") != 1 || !strings.Contains(ir, fmt.Sprintf("store volatile i%d ", bits)) {
+										t.Fatal("segment NUM address lost its independent exact scalar store")
+									}
+								}
+								x86RequireNumericNativeSourceContext(t, source, control.declaration, target.arch)
+								x86NumericNativeAddressObject(t, ir, target.triple)
+							} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("paired segment load granted another input/result/store/native contract", err)
+							}
+						})
+					}
+				}
+				for _, control := range []struct{ name, setup string }{
+					{"unknown-base", ""},
+					{"partial-base", "MOVW $8,BX\n"},
+					{"pointer-base", fmt.Sprintf("%s p+%d(FP),BX\n", move, word)},
+					{"revoked-NUM-base", move + " offset+0(FP),BX\n" + fmt.Sprintf("%s p+%d(FP),BX\n", move, word)},
+				} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row.op+"/"+segment+"/void-address-denial/"+control.name+"/"+api, func(t *testing.T) {
+							source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s%s -8(BX)(%s),DX\nRET\n", 2*word, control.setup, row.op, segment)
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func view(offset uintptr,p *byte)", target.arch, target.triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("void discarded result bypassed its actual native address input", err)
+							}
+						})
+					}
+				}
+				// A real GP index after a segment-as-base is rejected by
+				// Go's encoder, independently of its initialized-byte role.
+				// Do not count these as valid-format permission rejections.
+				for _, format := range []struct{ name, setup string }{
+					{"unknown-index", ""},
+					{"partial-index", "MOVW $8,CX\n"},
+					{"full-index", move + " offset+0(FP),CX\n"},
+					{"pointer-index", fmt.Sprintf("%s p+%d(FP),CX\n", move, word)},
+				} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+row.op+"/"+segment+"/format-rejection/"+format.name+"/"+api, func(t *testing.T) {
+							body := format.setup + row.op + " -8(" + segment + ")(CX*4),DX\n" + finish
+							source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err == nil || ir != "" {
+								t.Fatal("actual-Go illegal segment/index format was published", err)
+							}
+						})
+					}
+				}
+				// Both standalone queries still lack the paired emitter, even
+				// for a complete fixed-displacement read and exact return width.
+				body := load + fmt.Sprintf("%s DX,ret0+0(FP)\nRET", row.store)
+				_, file, sig, _ := x86ResultInitializationFixture(t, target.arch, "func Value() "+row.result, body)
+				for _, query := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+					if err := query(file.Funcs[0], sig, target.arch); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("declaration-only query borrowed a segment hardware input", row.op, segment, err)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86SegmentMOVStateAndOriginalRoleBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86SegmentMOVRows(arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				for _, address := range []string{"fixed", "fixed-zero", "base", "segment-index-scale1", "segment-index-scale2", "segment-index-scale4", "segment-index-scale8"} {
+					t.Run(arch+"/"+row.op+"/"+segment+"/"+address, func(t *testing.T) {
+						_, memory := x86SegmentMOVAddress(arch, segment, address)
+						ins := x86ScalarLaneInstruction(t, row.op+" "+memory+",DX")
+						state := x86ResultState{flags: 0x15, direction: x86ResultDirectionBackward, fp: []bool{true}, auto: []bool{true}}
+						if address == "base" || strings.HasPrefix(address, "segment-index-scale") {
+							state.gp[3] = 0xff
+						}
+						state.pointerGP[7], state.callerAddressGP[7], state.callerAddressOrigin[7] = true, true, 9
+						state.pointerGP[2], state.callerAddressGP[2], state.callerAddressOrigin[2] = true, true, 3
+						expected := state.clone()
+						expected.pointerGP[2] = false
+						expected.gp[2] = uint8(1<<uint(row.width) - 1)
+						if row.width >= 4 {
+							expected.gp[2] = 0xff
+						}
+						if accepted, known := x86LoweredScalarNativeLoad(ins, &state, nil, 0, arch); !known || !accepted || !reflect.DeepEqual(state, expected) {
+							t.Fatal("segment continuation changed more than the exact numerical destination", accepted, known)
+						}
+						before, origins := state.callerAddressGP, state.callerAddressOrigin
+						state.callerAddressGP = x86ResultCallerAddressesAfterTransfer(ins, before, state.callerAddressGP, nil, arch)
+						state.callerAddressOrigin = x86ResultCallerOriginsAfter(ins, origins, state.callerAddressGP, map[int64]bool{8: true}, arch)
+						expected.callerAddressGP[2], expected.callerAddressOrigin[2] = false, 0
+						if !reflect.DeepEqual(state, expected) {
+							t.Fatal("shared post-consumer retained the overwritten identity or revoked an unrelated one")
+						}
+					})
+				}
+				origins := []string{"encoded", "source-raw", "raw-return", "address-size", "unbound-address", "raw-segment", "numerical-certificate", "unmodeled-CS-role", "unresolved-offset", "index-extension", "invalid-scale", "wide-displacement", "unknown-offset", "partial-offset", "pointer-offset", "illegal-source-GP-scaled-index", "unknown-index", "partial-index", "pointer-index", "SP-destination", "SP-base", "SP-index"}
+				if arch == "amd64" {
+					origins = append(origins, "BP-destination", "BP-base", "BP-index", "REX-SP-destination", "REX-BP-destination")
+				}
+				for _, origin := range origins {
+					t.Run(arch+"/"+row.op+"/"+segment+"/"+origin, func(t *testing.T) {
+						ins := x86ScalarLaneInstruction(t, row.op+" 24("+segment+"),DX")
+						state := x86ResultState{flags: 0x15, direction: x86ResultDirectionForward}
+						switch origin {
+						case "encoded":
+							ins.x86Encoded = true
+						case "source-raw":
+							ins.x86SourceRaw = new(x86SourceRawInstruction)
+						case "raw-return":
+							ins.x86RawNearReturn = new(x86RawNearReturnForm)
+						case "address-size":
+							ins.x86AddressBits = 32
+						case "unbound-address":
+							ins.x86UnboundAddressOverride = true
+						case "raw-segment":
+							ins.x86SegmentPrefix = 0x64
+						case "numerical-certificate":
+							ins.x86NumericalRead = new(x86NumericalReadCertificate)
+						case "unmodeled-CS-role":
+							ins.Args[0].Mem.Segment = "CS"
+						case "unresolved-offset":
+							ins.Args[0].Mem.OffRaw = "missing"
+						case "index-extension":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.IndexExt, ins.Args[0].Mem.Scale = CX, "UXTW", 4
+							state.gp[1] = 0xff
+						case "invalid-scale":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 3
+							state.gp[1] = 0xff
+						case "wide-displacement":
+							ins.Args[0].Mem.Off = 1 << 32
+						case "unknown-offset", "partial-offset", "pointer-offset":
+							ins.Args[0].Mem.Base = BX
+							if origin == "partial-offset" {
+								state.gp[3] = 3
+							} else if origin == "pointer-offset" {
+								state.pointerGP[3], state.callerAddressGP[3] = true, true
+							}
+						case "illegal-source-GP-scaled-index", "unknown-index", "partial-index", "pointer-index":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = CX, 4
+							if origin == "illegal-source-GP-scaled-index" {
+								state.gp[1] = 0xff
+							} else if origin == "partial-index" {
+								state.gp[1] = 3
+							} else if origin == "pointer-index" {
+								state.pointerGP[1], state.callerAddressGP[1] = true, true
+							}
+						case "SP-destination":
+							ins.Args[1].Reg = SP
+						case "BP-destination":
+							ins.Args[1].Reg = BP
+						case "SP-base", "BP-base":
+							ins.Args[0].Mem.Base = SP
+							if origin == "BP-base" {
+								ins.Args[0].Mem.Base = BP
+							}
+						case "SP-index", "BP-index":
+							ins.Args[0].Mem.Index, ins.Args[0].Mem.Scale = SP, 4
+							if origin == "BP-index" {
+								ins.Args[0].Mem.Index = BP
+							}
+						case "REX-SP-destination", "REX-BP-destination":
+							// Only the byte row has Go's high-byte/REX alias.
+							ins.Op, ins.Args[0].Mem.Base, ins.Args[1].Reg = "MOVB", "R8", AH
+							state.gp[8] = 0xff
+							if origin == "REX-BP-destination" {
+								ins.Args[1].Reg = CH
+							}
+						}
+						before := state.clone()
+						if accepted, _ := x86LoweredScalarNativeLoad(ins, &state, nil, 0, arch); accepted || !reflect.DeepEqual(state, before) {
+							t.Fatal("unbound physical/source role acquired numerical segment bytes", origin)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_segment_native_store_composition_test.go b/x86_segment_native_store_composition_test.go
new file mode 100644
index 000000000..75bee4622
--- /dev/null
+++ b/x86_segment_native_store_composition_test.go
@@ -0,0 +1,43 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86SegmentLoadAndNativeStoreHaveIndependentPairedEffects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86SegmentMOVRows(target.arch) {
+			for _, segment := range []string{"FS", "GS"} {
+				declaration := "func view(offset uintptr,p *byte) " + row.result
+				// Preserve the complete original former caller-write negative.
+				// Reading a native value does not grant a write: the separate
+				// paired GP store requires the actual incoming p identity.
+				body := fmt.Sprintf("%s p+%d(FP),DI\n%s 24(%s),DX\n%s DX,(DI)\n%s $7,ret+RESULT(FP)", move, word, row.op, segment, row.store, row.store)
+				source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration, body)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.op+"/"+segment+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" || !strings.Contains(ir, "load volatile ") || !strings.Contains(ir, "store volatile ") {
+							t.Fatal("composed segment load/native store lost a complete effect", err)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, level)
+						}
+						// Objects do not establish physical FS/GS runtime state.
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_segment_object_owners_test.go b/x86_segment_object_owners_test.go
new file mode 100644
index 000000000..4130b53b4
--- /dev/null
+++ b/x86_segment_object_owners_test.go
@@ -0,0 +1,119 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+var x86SegmentObjectOwners = map[string]string{
+	"TestX86SegmentMOVLinux386CompleteObjects":     "i386-unknown-linux-gnu",
+	"TestX86SegmentMOVWindows386CompleteObjects":   "i686-pc-windows-msvc",
+	"TestX86SegmentMOVDarwinAMD64CompleteObjects":  "x86_64-apple-darwin",
+	"TestX86SegmentMOVLinuxAMD64CompleteObjects":   "x86_64-unknown-linux-gnu",
+	"TestX86SegmentMOVWindowsAMD64CompleteObjects": "x86_64-pc-windows-msvc",
+}
+
+func x86SegmentObjectOwnerSourceError(source string) error {
+	file, err := parser.ParseFile(token.NewFileSet(), "objects_test.go", source, parser.AllErrors)
+	if err != nil {
+		return err
+	}
+	targets := make(map[string]string)
+	for _, target := range x86RawReturnTargets {
+		if targets[target.triple] != "" {
+			return fmt.Errorf("duplicate complete target %s", target.triple)
+		}
+		targets[target.triple] = target.arch
+	}
+	seen := make(map[string]bool)
+	for _, decl := range file.Decls {
+		fn, ok := decl.(*ast.FuncDecl)
+		if !ok || !strings.HasPrefix(fn.Name.Name, "TestX86SegmentMOV") ||
+			!strings.HasSuffix(fn.Name.Name, "CompleteObjects") {
+			continue
+		}
+		triple, expected := x86SegmentObjectOwners[fn.Name.Name]
+		if !expected || seen[triple] || fn.Body == nil || len(fn.Body.List) != 1 {
+			return fmt.Errorf("missing, duplicate or noncanonical complete owner %s", fn.Name.Name)
+		}
+		statement, ok := fn.Body.List[0].(*ast.ExprStmt)
+		if !ok {
+			return fmt.Errorf("owner %s does not execute its target", fn.Name.Name)
+		}
+		call, ok := statement.X.(*ast.CallExpr)
+		if !ok || len(call.Args) != 3 {
+			return fmt.Errorf("owner %s has no complete target call", fn.Name.Name)
+		}
+		helper, ok := call.Fun.(*ast.Ident)
+		if !ok || helper.Name != "x86SegmentMOVTargetCompleteObjects" {
+			return fmt.Errorf("owner %s substituted its executor", fn.Name.Name)
+		}
+		for index, expected := range []string{targets[triple], triple} {
+			literal, ok := call.Args[index+1].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				return fmt.Errorf("owner %s has no literal target", fn.Name.Name)
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil || expected == "" || value != expected {
+				return fmt.Errorf("owner %s changed target axis", fn.Name.Name)
+			}
+		}
+		seen[triple] = true
+	}
+	if len(seen) != len(targets) || len(seen) != len(x86SegmentObjectOwners) {
+		return fmt.Errorf("complete object owner union is %d, want all %d targets", len(seen), len(targets))
+	}
+	return nil
+}
+
+func TestX86SegmentMOVObjectOwnersCoverFullMatrix(t *testing.T) {
+	source, err := os.ReadFile("x86_segment_mov_objects_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := x86SegmentObjectOwnerSourceError(string(source)); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestX86SegmentMOVObjectOwnersRejectMissingOrCroppedTargets(t *testing.T) {
+	var source strings.Builder
+	source.WriteString("package plan9asm\n")
+	names := make([]string, 0, len(x86SegmentObjectOwners))
+	for name := range x86SegmentObjectOwners {
+		names = append(names, name)
+	}
+	sort.Strings(names)
+	for _, name := range names {
+		triple, arch := x86SegmentObjectOwners[name], "amd64"
+		if strings.HasPrefix(triple, "i") {
+			arch = "386"
+		}
+		fmt.Fprintf(&source, "func %s(t *testing.T) {\nx86SegmentMOVTargetCompleteObjects(t,%q,%q)\n}\n",
+			name, arch, triple)
+	}
+	base := source.String()
+	if err := x86SegmentObjectOwnerSourceError(base); err != nil {
+		t.Fatal("independent complete owner fixture rejected", err)
+	}
+	for name, changed := range map[string]string{
+		"missing":        strings.Replace(base, names[0], "TestMissingTarget", 1),
+		"duplicate":      base + strings.SplitN(base, "package plan9asm\n", 2)[1],
+		"architecture":   strings.Replace(base, `"amd64"`, `"386"`, 1),
+		"triple":         strings.Replace(base, `"x86_64-apple-darwin"`, `"x86_64-unknown-linux-gnu"`, 1),
+		"executor":       strings.Replace(base, "x86SegmentMOVTargetCompleteObjects(", "unrelatedExecutor(", 1),
+		"skip":           strings.Replace(base, "{\n", "{\nt.Skip(\"cropped\")\n", 1),
+		"partial-target": strings.Replace(base, `"i386-unknown-linux-gnu"`, `"i386-unknown-linux-gnu/text"`, 1),
+	} {
+		if changed == base || x86SegmentObjectOwnerSourceError(changed) == nil {
+			t.Error("object owner mechanism accepted mutation", name)
+		}
+	}
+}
diff --git a/x86_segment_physical_handoff_test.go b/x86_segment_physical_handoff_test.go
new file mode 100644
index 000000000..d298e2609
--- /dev/null
+++ b/x86_segment_physical_handoff_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86NamedSegmentMemoryDoesNotReinterpretPhysicalDecoder(t *testing.T) {
+	for _, prefix := range []byte{0x64, 0x65} {
+		for _, address := range [][]byte{{0x04, 0x25, 0x30, 0, 0, 0}, {0x40, 0x30}} {
+			source := "TEXT Physical(SB),4,$0-0\n"
+			for _, value := range append([]byte{prefix, 0x48, 0x8b}, address...) {
+				source += fmt.Sprintf("BYTE $%d\n", value)
+			}
+			file := mustParseX86RawReturn(t, source+"RET\n")
+			function, err := decodeX86RawDirectives(file.Funcs[0], "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			observed := false
+			for _, instruction := range function.Instrs {
+				if instruction.Op != OpMOVQ {
+					continue
+				}
+				observed = true
+				if _, named, err := x86NamedSegmentMemorySource(instruction, instruction.Args[0], "amd64"); named || err != nil {
+					t.Fatal("physical decoder operands were reinterpreted as named Go syntax", named, err)
+				}
+			}
+			if !observed {
+				t.Fatal("complete physical source lost its actual MOVQ")
+			}
+		}
+	}
+}
diff --git a/x86_segment_query_effect_test.go b/x86_segment_query_effect_test.go
new file mode 100644
index 000000000..6b8edc327
--- /dev/null
+++ b/x86_segment_query_effect_test.go
@@ -0,0 +1,176 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Independent of the implementation's family map. Go uses one complete
+// yml_rl row for LAR/LSL and one ydivl row for VERR/VERW. All selector reads
+// consume exactly 16 bits, regardless of the destination/register spelling.
+var x86SegmentQueryOracle = []struct {
+	op, table, prefix, opcode string
+	bytes                     int64
+}{
+	{"LARW", "yml_rl", "Pq", "0x02", 2},
+	{"LARL", "yml_rl", "Pm", "0x02", 4},
+	{"LARQ", "yml_rl", "Pw", "0x0f, 0x02", 8},
+	{"LSLW", "yml_rl", "Pq", "0x03", 2},
+	{"LSLL", "yml_rl", "Pm", "0x03", 4},
+	{"LSLQ", "yml_rl", "Pw", "0x0f, 0x03", 8},
+	{"VERR", "ydivl", "Pm", "0x00, 04", 0},
+	{"VERW", "ydivl", "Pm", "0x00, 05", 0},
+}
+
+func x86SegmentQueryOracleInstruction(t *testing.T, op string, destination bool) Instr {
+	t.Helper()
+	text := op + " AX"
+	if destination {
+		text += ",CX"
+	}
+	file, err := Parse(ArchAMD64, "TEXT value(SB),4,$0-0\n"+text+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86SegmentQueryCompleteGoRowsAndTypedEffects(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, grammar := range []string{
+		"var yml_rl = []ytab{\n\t{Zm_r, 1, argList{Yml, Yrl}},\n}",
+		"var ydivl = []ytab{\n\t{Zm_o, 2, argList{Yml}},\n}",
+	} {
+		if !strings.Contains(string(data), grammar) {
+			t.Fatal("complete original selector encoder row changed", grammar)
+		}
+	}
+	for _, row := range x86SegmentQueryOracle {
+		want := fmt.Sprintf("{A%s, %s, %s, opBytes{%s}}", row.op, row.table, row.prefix, row.opcode)
+		if !strings.Contains(string(data), want) {
+			t.Fatal("independent Go selector opcode attributes changed", want)
+		}
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86SegmentQueryOracleInstruction(t, row.op, row.bytes != 0)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if arch == "386" && row.bytes == 8 {
+					if !known || err == nil {
+						t.Fatal("Go-rejected mode32 qword acquired a numerical effect", known, err)
+					}
+					return
+				}
+				wantOperands := 1
+				if row.bytes != 0 {
+					wantOperands++
+				}
+				if !known || err != nil || len(effect.operands) != wantOperands ||
+					!effect.requiresResultProof || effect.dynamicMemory || effect.flagsRead != 0 ||
+					effect.flagsDefined != x86ByteFlagZF || effect.flagsKilled != 0 {
+					t.Fatal("missing complete selector/old-destination/ZF effect", effect, known, err)
+				}
+				selector := effect.operands[0]
+				if selector.index != 0 || selector.operand.Reg != AX || selector.width != 2 || !selector.read || selector.write {
+					t.Fatal("selector is not an exact read-only low word", selector)
+				}
+				if row.bytes != 0 {
+					destination := effect.operands[1]
+					if destination.index != 1 || destination.operand.Reg != CX || destination.width != row.bytes ||
+						!destination.read || !destination.write {
+						t.Fatal("failed query did not retain its complete old destination", destination)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SegmentQuerySelectorOldDestinationAndFlagsState(t *testing.T) {
+	// Intel SDM 093 Vol.2A LSL 3-575 explicitly preserves CF/OF/SF/AF/PF;
+	// Intel XED's four family records modify ZF only. The old STC/VERR/SETCS
+	// fixture is legitimate and must not be relabeled as undefined-FLAGS Context.
+	// https://cdrdv2.intel.com/v1/dl/getContent/671199
+	// https://github.com/intelxed/xed/blob/main/datafiles/xed-isa.txt
+	for _, row := range x86SegmentQueryOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			if arch == "386" && row.bytes == 8 {
+				continue // Independent Go mode rejection is checked above.
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86SegmentQueryOracleInstruction(t, row.op, row.bytes != 0)
+				oldMask := uint8(1<<uint(row.bytes) - 1)
+				for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagsAll &^ x86ByteFlagZF, x86ByteFlagsAll} {
+					state := x86ResultState{flags: flags}
+					state.gp[0], state.gp[1], state.gp[2] = 3, oldMask, 0x55
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) {
+						t.Fatal("complete low selector and old destination were rejected", flags)
+					}
+					if state.flags != flags|x86ByteFlagZF || state.gp[0] != 3 ||
+						state.gp[1] != oldMask || state.gp[2] != 0x55 {
+						t.Fatal("query invented FLAGS/input bytes or changed unrelated storage", state.flags, state.gp)
+					}
+				}
+				for missing := int64(0); missing < 2+row.bytes; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[1] = 3, oldMask
+					if missing < 2 {
+						state.gp[0] &^= 1 << uint(missing)
+					} else {
+						state.gp[1] &^= 1 << uint(missing-2)
+					}
+					if x86ResultTransfer(ins, &state, nil, 0, arch) {
+						t.Fatal("missing selector/failed-query merge byte was invented", missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SegmentQueryInitializedPublicAndMissingInputs(t *testing.T) {
+	for _, row := range x86SegmentQueryOracle {
+		for _, arch := range []string{"amd64", "386"} {
+			if arch == "386" && row.bytes == 8 {
+				continue
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+row.op+"/"+api, func(t *testing.T) {
+					move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+					if arch == "386" {
+						move, triple = "MOVL", "i386-unknown-linux-gnu"
+					}
+					query := row.op + " AX"
+					if row.bytes != 0 {
+						query += ",CX"
+					}
+					selector := "MOVW $0,AX\n"
+					old := move + " $0x12345678,CX\n"
+					body := "STC\n" + query + "\nSETEQ DL\nSETCS BL\nMOVBLZX DL,DX\n" +
+						"MOVBLZX BL,BX\nSHLL $1,BX\nORL BX,DX\nMOVL DX,ret+0(FP)\nRET\n"
+					source := "TEXT ·Value(SB),4,$0-4\n" + selector + old + body
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value() uint32", arch, triple, api); err != nil || ir == "" {
+						t.Fatal("initialized selector and preserved CF/ZF lost their public result", err)
+					}
+					for _, missing := range []string{selector, old} {
+						if missing == old && row.bytes == 0 {
+							continue // VERR/VERW do not have an old result register.
+						}
+						changed := strings.Replace(source, missing, "", 1)
+						ir, err := x86ScalarFPBitViewAPI(t, changed, "func Value() uint32", arch, triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("missing native query input borrowed an implementation slot", missing, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_segment_query_native_fixture_test.go b/x86_segment_query_native_fixture_test.go
new file mode 100644
index 000000000..b79448835
--- /dev/null
+++ b/x86_segment_query_native_fixture_test.go
@@ -0,0 +1,12 @@
+package plan9asm
+
+// Both the actual Go program and independent GNU opcode reference seed every
+// observed status bit. XOR would leave AF undefined before the complete LAHF
+// observation. MOV additionally makes the SUB input an explicit source fact;
+// no instruction-proof relaxation is needed to recognize a self-subtraction.
+func x86SegmentQueryNativeFlagSeed(overflow bool) (goSource, gnuSource string) {
+	if overflow {
+		return "MOVB $127,DL\nADDB $1,DL\nSTC\n", "movb $127,%%dl; addb $1,%%dl; stc; "
+	}
+	return "MOVL $0,DX\nSUBL DX,DX\nSTC\n", "movl $0,%%edx; subl %%edx,%%edx; stc; "
+}
diff --git a/x86_segment_query_original_source_test.go b/x86_segment_query_original_source_test.go
new file mode 100644
index 000000000..e3dd737fa
--- /dev/null
+++ b/x86_segment_query_original_source_test.go
@@ -0,0 +1,120 @@
+package plan9asm
+
+import (
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Parse the actual Linux-only driver on every development host. Building the
+// translator on ARM64 cannot otherwise catch a generated original Go file
+// missing its package clause. No subprocess or platform skip is involved.
+func TestX86SegmentQueryOriginalGoSourceIsCompleteAndParseable(t *testing.T) {
+	file, err := parser.ParseFile(token.NewFileSet(), "x86_segment_query_runtime_linux_amd64_test.go", nil, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var template, declarationFormat string
+	var originalCall *ast.CallExpr
+	formats, calls := 0, 0
+	ast.Inspect(file, func(node ast.Node) bool {
+		switch value := node.(type) {
+		case *ast.ValueSpec:
+			if len(value.Names) == 1 && value.Names[0].Name == "x86SegmentQueryOriginalGo" && len(value.Values) == 1 {
+				literal, ok := value.Values[0].(*ast.BasicLit)
+				if !ok || literal.Kind != token.STRING {
+					t.Fatal("original Go test body must retain its complete source literal")
+				}
+				template, err = strconv.Unquote(literal.Value)
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+		case *ast.CallExpr:
+			if name, ok := value.Fun.(*ast.Ident); ok && name.Name == "x86RunOriginalGoNativeSource" {
+				originalCall, calls = value, calls+1
+			}
+			selector, ok := value.Fun.(*ast.SelectorExpr)
+			if !ok || selector.Sel.Name != "Fprintf" || len(value.Args) < 2 {
+				return true
+			}
+			address, ok := value.Args[0].(*ast.UnaryExpr)
+			if !ok || address.Op != token.AND {
+				return true
+			}
+			name, ok := address.X.(*ast.Ident)
+			if !ok || name.Name != "declarations" {
+				return true
+			}
+			literal, ok := value.Args[1].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("original Go declaration builder lost its bounded format")
+			}
+			format, err := strconv.Unquote(literal.Value)
+			if err != nil || declarationFormat != "" && declarationFormat != format {
+				t.Fatal("original live/dead query signatures diverged", err)
+			}
+			declarationFormat, formats = format, formats+1
+		}
+		return true
+	})
+	if calls != 1 || formats != 2 || originalCall == nil || len(originalCall.Args) != 6 || template == "" ||
+		strings.Count(declarationFormat, "%s") != 1 {
+		t.Fatal("complete actual original Go call/declaration/test inventory changed", calls, formats)
+	}
+	var declarations, rows strings.Builder
+	for operation, row := range x86SegmentQueryOracle {
+		for role := 0; role < 3; role++ {
+			for seed := 0; seed < 2; seed++ {
+				name := fmt.Sprintf("Query%d_%d_%d", operation, role, seed)
+				fmt.Fprintf(&declarations, declarationFormat, name)
+				fmt.Fprintf(&rows, "{%s,%d,%d,%d,%d},\n", name, operation, role, seed, row.bytes)
+			}
+		}
+		fmt.Fprintf(&declarations, declarationFormat, fmt.Sprintf("QueryDead%d", operation))
+	}
+	var render func(ast.Expr) string
+	render = func(expression ast.Expr) string {
+		switch value := expression.(type) {
+		case *ast.BasicLit:
+			if value.Kind == token.STRING {
+				text, err := strconv.Unquote(value.Value)
+				if err == nil {
+					return text
+				}
+			}
+		case *ast.BinaryExpr:
+			if value.Op == token.ADD {
+				return render(value.X) + render(value.Y)
+			}
+		case *ast.CallExpr:
+			selector, ok := value.Fun.(*ast.SelectorExpr)
+			if ok && selector.Sel.Name == "String" && len(value.Args) == 0 {
+				if name, ok := selector.X.(*ast.Ident); ok && name.Name == "declarations" {
+					return declarations.String()
+				}
+			}
+		}
+		t.Fatal("original Go declaration source escaped its exact bounded builder")
+		return ""
+	}
+	program := render(originalCall.Args[3])
+	for name, source := range map[string]string{
+		"value.go": program, "value_test.go": fmt.Sprintf(template, rows.String()),
+	} {
+		parsed, err := parser.ParseFile(token.NewFileSet(), name, source, parser.AllErrors)
+		if err != nil || parsed == nil || parsed.Name.Name != "oracle" {
+			t.Fatal("actual complete original Go source is not a valid oracle package", name, err)
+		}
+		if _, err := parser.ParseFile(token.NewFileSet(), name, strings.TrimPrefix(source, "package oracle\n"), parser.AllErrors); err == nil {
+			t.Fatal("parser control failed to reject the old missing-package source", name)
+		}
+		if name == "value.go" && len(parsed.Decls) != 57 {
+			t.Fatal("original Go lost a live/dead/CS declaration", len(parsed.Decls))
+		}
+	}
+}
diff --git a/x86_segment_query_runtime_linux_amd64_test.go b/x86_segment_query_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..2a62cb804
--- /dev/null
+++ b/x86_segment_query_runtime_linux_amd64_test.go
@@ -0,0 +1,257 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86SegmentQueryOriginalFlagsAliasesAndFaults(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	execution := x86FloatCompareExecutionTools(t)
+	var source, declarations, prototypes, references, rows, goRows, deadRows strings.Builder
+	count, nativeReads := 0, 0
+	for operation, row := range x86SegmentQueryOracle {
+		for role, operand := range []string{"AX", "(SI)", "CX"} {
+			query := row.op + " " + operand
+			if row.bytes != 0 {
+				query += ",CX"
+			}
+			code := assembleX87ControlBytes(t, "amd64", "TEXT original(SB),4,$0-0\n"+query+"\nRET\n")
+			want := x86SegmentQueryOriginalOpcode(row.op, role)
+			if string(code) != string(append(want, 0xc3)) {
+				t.Fatal("complete original Go query opcode changed", row.op, role, code, want)
+			}
+			var literals []string
+			for _, value := range want {
+				literals = append(literals, fmt.Sprintf("0x%02x", value))
+			}
+			for seed := 0; seed < 2; seed++ {
+				name := fmt.Sprintf("Query%d_%d_%d", operation, role, seed)
+				prepare, cPrepare := x86SegmentQueryNativeFlagSeed(seed == 1)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ selector+8(FP),AX\n"+
+					"MOVQ old+16(FP),CX\nMOVQ p+24(FP),SI\n%s%s\nMOVQ CX,0(DI)\nMOVQ AX,10(DI)\n"+
+					"LAHF\nMOVB AH,8(DI)\nSETOS 9(DI)\nRET\n", name, prepare, query)
+				fmt.Fprintf(&declarations, "func %s(out *[18]byte,selector,old uint64,p *uint16)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,uint64_t,uint64_t,const uint16_t *);\n", name)
+				fmt.Fprintf(&references, `__attribute__((noinline)) static void original_%s(uint8_t *out,uint64_t selector,uint64_t old,const uint16_t *p) {
+  __asm__ volatile("%s.byte %s; movq %%%%rcx,0(%%%%rdi); movq %%%%rax,10(%%%%rdi); lahf; movb %%%%ah,8(%%%%rdi); seto 9(%%%%rdi)"
+    : "+a"(selector),"+c"(old) : "D"(out),"S"(p) : "rdx","cc","memory");
+}
+`, name, cPrepare, strings.Join(literals, ","))
+				fmt.Fprintf(&rows, "{%s,original_%s,%d,%d,%d,%d},\n", name, name, operation, role, seed, row.bytes)
+				fmt.Fprintf(&goRows, "{%s,%d,%d,%d,%d},\n", name, operation, role, seed, row.bytes)
+				count++
+				if role == 1 {
+					nativeReads++
+				}
+			}
+			if role != 1 {
+				continue
+			}
+			name := fmt.Sprintf("QueryDead%d", operation)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-32\nMOVQ out+0(FP),DI\nMOVQ selector+8(FP),AX\n"+
+				"MOVQ old+16(FP),CX\nMOVQ p+24(FP),SI\n%s\nRET\n", name, query)
+			fmt.Fprintf(&declarations, "func %s(out *[18]byte,selector,old uint64,p *uint16)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(uint8_t *,uint64_t,uint64_t,const uint16_t *);\n", name)
+			fmt.Fprintf(&references, `__attribute__((noinline)) static void original_%s(uint8_t *out,uint64_t selector,uint64_t old,const uint16_t *p) {
+  (void)out;
+  __asm__ volatile(".byte %s" : "+a"(selector),"+c"(old) : "S"(p) : "cc","memory");
+}
+`, name, strings.Join(literals, ","))
+			fmt.Fprintf(&deadRows, "{%s,original_%s},\n", name, name)
+			nativeReads++
+		}
+	}
+	if count != 48 || nativeReads != 24 {
+		t.Fatal("complete bounded query/native-read inventory changed", count, nativeReads)
+	}
+	goAssemblerOracleOutput(t, "amd64", source.String(), "", true)
+	ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, "Go")
+	if err != nil {
+		t.Fatal("complete original query program rejected", err)
+	}
+	driver := fmt.Sprintf(x86SegmentQueryNativeC, prototypes.String(), references.String(), rows.String(), deadRows.String())
+	for _, pipeline := range []struct{ name, level, ir string }{
+		{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir}, {"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+	} {
+		t.Run(pipeline.name, func(t *testing.T) {
+			queries := 0
+			for _, mnemonic := range []string{"lar", "lsl", "verr", "verw"} {
+				queries += strings.Count(pipeline.ir, `asm sideeffect "`+mnemonic)
+			}
+			if queries != 56 || strings.Count(pipeline.ir, "load volatile i16, ptr") != nativeReads {
+				t.Fatal("an observable/dead query lost its native opcode or exact m16 access", queries)
+			}
+			output := execution.compileAndRunLLVM(t, "segment-query-native", pipeline.ir, driver, pipeline.level)
+			if string(output) != "SEGMENT_QUERY_NATIVE_COMPLETE values=768 faults=160 failures=0\n" {
+				t.Fatal("missing complete independent original-opcode/native query terminal", string(output))
+			}
+			t.Log("48 original-Go opcode rows × 16 inputs; full GP aliases, six status flags, canaries; 160 live/dead m16 fault processes")
+		})
+	}
+	originalSource := source.String() + "TEXT ·OriginalCS(SB),4,$0-2\nMOVW CS,AX\nMOVW AX,ret0+0(FP)\nRET\n"
+	goAssemblerOracleOutput(t, "amd64", originalSource, "", true)
+	x86RunOriginalGoNativeSource(t, execution, "amd64", "package oracle\n"+declarations.String()+"func OriginalCS() uint16\n", originalSource,
+		fmt.Sprintf(x86SegmentQueryOriginalGo, goRows.String()))
+	x87IA32RequireNativeHost(t)
+}
+
+func x86SegmentQueryOriginalOpcode(op string, role int) []byte {
+	if op == "VERR" || op == "VERW" {
+		modrm := byte(0xe0)
+		if role == 1 {
+			modrm = 0x26
+		} else if role == 2 {
+			modrm = 0xe1
+		}
+		if op == "VERW" {
+			modrm += 8
+		}
+		return []byte{0x0f, 0x00, modrm}
+	}
+	var code []byte
+	if strings.HasSuffix(op, "W") {
+		code = append(code, 0x66)
+	} else if strings.HasSuffix(op, "Q") {
+		code = append(code, 0x48)
+	}
+	opcode, modrm := byte(2), byte(0xc8)
+	if strings.HasPrefix(op, "LSL") {
+		opcode = 3
+	}
+	if role == 1 {
+		modrm = 0x0e
+	} else if role == 2 {
+		modrm = 0xc9
+	}
+	return append(code, 0x0f, opcode, modrm)
+}
+
+const x86SegmentQueryNativeC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+%s
+%s
+typedef void (*Kernel)(uint8_t *,uint64_t,uint64_t,const uint16_t *);
+typedef struct {Kernel run,original;unsigned operation,role,seed,bytes;} Row;
+static const Row rows[]={
+%s
+};
+static const struct {Kernel run,original;} dead[]={
+%s
+};
+static uint64_t word(const uint8_t *p) {uint64_t v;memcpy(&v,p,8);return v;}
+static int fault(Kernel run,const uint16_t *p) {
+  pid_t child=fork();
+  if(child<0) return -1;
+  if(!child) {
+    struct rlimit limit={0,0};
+    if(setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+    uint8_t out[20];memset(out,0xa7,sizeof(out));
+    run(out+1,0,UINT64_C(0x123456789abcdef0),p);
+    _exit(out[0]==0xa7 && out[19]==0xa7 ? 0:2);
+  }
+  int status=0;
+  if(waitpid(child,&status,0)!=child) return -2;
+  if(WIFEXITED(status)) return WEXITSTATUS(status)?-3:0;
+  return WIFSIGNALED(status) && (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)?1:-4;
+}
+int main(void) {
+  uint16_t cs;__asm__ volatile("movw %%%%cs,%%0":"=r"(cs));
+  const uint64_t high[]={0,UINT64_C(0x123456789abc0000),UINT64_C(0xffffffffffff0000),UINT64_C(0x8000000000000000)};
+  const uint64_t oldValues[]={UINT64_C(0x123456789abcdef0),UINT64_C(0xfedcba9876543210)};
+  unsigned values=0,faults=0;
+  if(sizeof(rows)/sizeof(rows[0])!=48 || sizeof(dead)/sizeof(dead[0])!=8) return 1;
+  for(unsigned r=0;r<48;r++) for(unsigned s=0;s<2;s++) for(unsigned h=0;h<4;h++) for(unsigned o=0;o<2;o++) {
+    uint16_t selector=s?cs:0;
+    uint64_t input=high[h]|selector,old=oldValues[o];
+    if(rows[r].role==2) old=(old&~UINT64_C(65535))|selector;
+    uint8_t actual[20],original[20];memset(actual,0xa7,sizeof(actual));memset(original,0xa7,sizeof(original));
+    rows[r].original(original+1,input,old,&selector);
+    rows[r].run(actual+1,input,old,&selector);
+    uint64_t mask=rows[r].operation<3 && selector?~UINT64_C(0x000f0000):UINT64_MAX;
+    unsigned zf=s && rows[r].operation!=7;
+    unsigned lahf=(rows[r].seed?0x93:0x47)&~0x40u;
+    lahf|=zf<<6;
+    if(actual[0]!=0xa7 || actual[19]!=0xa7 || original[0]!=0xa7 || original[19]!=0xa7 ||
+       ((word(actual+1)^word(original+1))&mask) || word(actual+11)!=input || word(original+11)!=input ||
+       actual[9]!=lahf || original[9]!=lahf || actual[10]!=rows[r].seed || original[10]!=rows[r].seed) {
+      fprintf(stderr,"query row=%%u selector=%%x high=%%u old=%%u got=%%llx want=%%llx flags=%%x/%%x\n",
+        r,selector,h,o,(unsigned long long)word(actual+1),(unsigned long long)word(original+1),actual[9],original[9]);
+      return 1;
+    }
+    if((rows[r].operation>=6 && word(actual+1)!=old) ||
+       (!selector && ((word(actual+1)^old)&(rows[r].bytes==4?UINT64_C(0xffffffff):UINT64_MAX)))) return 1;
+    values++;
+  }
+  long page=sysconf(_SC_PAGESIZE);
+  if(page<64) return 1;
+  uint8_t *p=mmap(0,(size_t)page*2,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANONYMOUS,-1,0);
+  if(p==MAP_FAILED || mprotect(p+page,(size_t)page,PROT_NONE)) return 1;
+  memset(p,0,(size_t)page);
+  if(mprotect(p,(size_t)page,PROT_READ)) return 1;
+  const uint16_t *probes[]={0,(const uint16_t *)(p+page-2),(const uint16_t *)(p+page-1),
+    (const uint16_t *)(p+1),(const uint16_t *)p};
+  for(unsigned r=0;r<8;r++) for(unsigned probe=0;probe<5;probe++) for(unsigned live=0;live<2;live++) {
+    unsigned expected=probe==0 || probe==2;
+    Kernel actual=live?rows[r*6+2].run:dead[r].run;
+    Kernel original=live?rows[r*6+2].original:dead[r].original;
+    int before=fault(original,probes[probe]),after=fault(actual,probes[probe]);faults+=2;
+    if(before!=(int)expected || after!=before) {
+      fprintf(stderr,"query native fault operation=%%u probe=%%u live=%%u original=%%d translated=%%d\n",r,probe,live,before,after);
+      return 1;
+    }
+  }
+  if(values!=768 || faults!=160 || munmap(p,(size_t)page*2)) return 1;
+  puts("SEGMENT_QUERY_NATIVE_COMPLETE values=768 faults=160 failures=0");return 0;
+}
+`
+
+const x86SegmentQueryOriginalGo = `package oracle
+import("encoding/binary";"testing")
+type query struct {
+  run func(*[18]byte,uint64,uint64,*uint16)
+  operation,role,seed,bytes uint
+}
+var queries=[]query{
+%s
+}
+func TestOriginal(t *testing.T) {
+  cs:=OriginalCS()
+  high:=[]uint64{0,0x123456789abc0000,0xffffffffffff0000,0x8000000000000000}
+  oldValues:=[]uint64{0x123456789abcdef0,0xfedcba9876543210}
+  outcomes:=0
+  if len(queries)!=48 {t.Fatal("incomplete original Go query inventory")}
+  for row,q:=range queries {
+    for _,selector:=range []uint16{0,cs} {for _,upper:=range high {for _,old:=range oldValues {
+      if q.role==2 {old=old&^65535|uint64(selector)}
+      input:=upper|uint64(selector)
+      var out [20]byte
+      for i:=range out {out[i]=0xa7}
+      q.run((*[18]byte)(out[1:19]),input,old,&selector)
+      zf:=byte(0)
+      if selector!=0 && q.operation!=7 {zf=0x40}
+      lahf:=byte(0x47)
+      if q.seed!=0 {lahf=0x93}
+      result:=binary.LittleEndian.Uint64(out[1:9])
+      mask:=^uint64(0)
+      if q.bytes==4 {mask=0xffffffff}
+      if out[0]!=0xa7 || out[19]!=0xa7 || out[9]!=(lahf&^0x40|zf) || out[10]!=byte(q.seed) ||
+        binary.LittleEndian.Uint64(out[11:19])!=input || q.operation>=6 && result!=old ||
+        selector==0 && (result^old)&mask!=0 {
+        t.Fatal("actual original query value/flags/full-buffer mismatch",row,selector,upper,old,out)
+      }
+      outcomes++
+    }}}
+  }
+  if outcomes!=768 {t.Fatal("incomplete original Go query outcomes",outcomes)}
+  t.Log("768 actual original Go query whole-GP/FLAGS/canary outcomes")
+}
+`
diff --git a/x86_signed_packed_float_value_inputs_test.go b/x86_signed_packed_float_value_inputs_test.go
new file mode 100644
index 000000000..c2fc05e4c
--- /dev/null
+++ b/x86_signed_packed_float_value_inputs_test.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86SignedPackedValueRow struct {
+	op, bank, input, mask string
+}
+
+// Independent yxcvm2, _yvcvtdq2ps and _yvcvtdq2pd axes. MMX's physical
+// x87-state ownership remains a separate negative boundary, not a vector row.
+func x86SignedPackedValueRows() []x86SignedPackedValueRow {
+	var rows []x86SignedPackedValueRow
+	for _, op := range []string{"CVTPL2PS", "CVTPL2PD", "VCVTDQ2PS", "VCVTDQ2PD"} {
+		banks := []string{"X"}
+		modes := []string{"plain"}
+		if strings.HasPrefix(op, "V") {
+			banks = []string{"X", "Y", "Z"}
+			modes = []string{"plain", "merge", "zero"}
+		}
+		for _, bank := range banks {
+			inputBank := bank
+			if op == "VCVTDQ2PD" {
+				inputBank = "X"
+				if bank == "Z" {
+					inputBank = "Y"
+				}
+			}
+			for _, mode := range modes {
+				name, mask := op, ""
+				if mode != "plain" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					name += ".Z"
+				}
+				rows = append(rows, x86SignedPackedValueRow{name, bank, inputBank + "0", mask},
+					x86SignedPackedValueRow{name, bank, "3(AX)(DX*2)", mask})
+				if strings.HasPrefix(op, "V") {
+					broadcast := op + ".BCST"
+					if mode == "zero" {
+						broadcast += ".Z"
+					}
+					rows = append(rows, x86SignedPackedValueRow{broadcast, bank, "3(AX)(DX*2)", mask})
+				}
+			}
+		}
+	}
+	for _, rounding := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			row := x86SignedPackedValueRow{"VCVTDQ2PS." + rounding, "Z", "Z0", ""}
+			if mode != "plain" {
+				row.mask = "K1,"
+			}
+			if mode == "zero" {
+				row.op += ".Z"
+			}
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func TestX86SignedPackedFloatResultByteTransfers(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for index, row := range x86SignedPackedValueRows() {
+			if strings.Contains(row.input, "(") {
+				continue
+			}
+			t.Run(fmt.Sprintf("%s/%d", arch, index), func(t *testing.T) {
+				width := map[string]int{"X": 16, "Y": 32, "Z": 64}[row.bank]
+				inputBytes := width
+				if strings.Contains(row.op, "DQ2PD") || row.op == "CVTPL2PD" {
+					inputBytes /= 2
+				}
+				legacy := !strings.HasPrefix(row.op, "V")
+				instruction := x86ScalarLaneInstruction(t, row.op+" "+row.input+","+row.mask+row.bank+"1")
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.pointerGP[3], state.gp[2], state.masks[1] = true, 0xff, true
+				input := x86CallerVectorByteMask(int64(inputBytes))
+				state.writeVector(0, 64, input, true)
+				old := uint64(0xa5a55a5affff0000)
+				if row.mask != "" && !strings.HasSuffix(row.op, ".Z") {
+					old |= x86CallerVectorByteMask(int64(width))
+				}
+				state.writeVector(1, 64, old, true)
+				before, want := state.clone(), state.clone()
+				want.writeVector(1, width, x86CallerVectorByteMask(int64(width)), legacy)
+				if !x86ResultTransfer(instruction, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+					t.Fatal("signed conversion byte transfer lost exact input/output/upper aliases or changed unrelated state", instruction.Raw)
+				}
+				missing := before.clone()
+				missing.writeVector(0, 64, input&^(uint64(1)<<uint(inputBytes-1)), true)
+				unchanged := missing.clone()
+				if x86ResultTransfer(instruction, &missing, nil, 0, arch) || !reflect.DeepEqual(missing, unchanged) {
+					t.Fatal("signed conversion accepted a missing integer byte or mutated a rejected state")
+				}
+			})
+		}
+	}
+}
+
+func x86SignedPackedValueFixture(arch string, row x86SignedPackedValueRow, result bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	declaration, finish, extent := "func Value(p *byte,mask uintptr)", "", 2*word
+	if result {
+		declaration += " uint32"
+		extent += 4
+		finish = fmt.Sprintf("PEXTRD $0,X1,AX\nMOVL AX,ret+%d(FP)\n", 2*word)
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\nKMOVD CX,K1\n"+
+		"MOVL $1,DX\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nSTC\n%s %s,%s%s1\n%sRET\n",
+		extent, move, move, word, row.op, row.input, row.mask, row.bank, finish), declaration
+}
+
+func TestX86SignedPackedFloatInitializedValuesFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86SignedPackedValueRows()
+	if len(rows) != 70 {
+		t.Fatal("complete signed packed conversion denominator changed", len(rows))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			for start := 0; start < len(rows); start += 32 {
+				end := start + 32
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprintf("%d-%d", start, end), func(t *testing.T) {
+					var source, declarations strings.Builder
+					var names []string
+					for _, row := range rows[start:end] {
+						for _, result := range []bool{false, true} {
+							body, declaration := x86SignedPackedValueFixture(target.arch, row, result)
+							name := fmt.Sprintf("SignedPackedValue%d", len(names))
+							names = append(names, name)
+							source.WriteString(strings.ReplaceAll(body, "Value", name))
+							declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+						}
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("complete initialized signed packed conversion source rejected", err)
+							}
+							x86CompactExpandRequireAllDefinitions(t, ir, names)
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								for _, level := range []string{"-O0", "-O2"} {
+									x86PackedStringCompileObject(t, llc, target.triple, text, level)
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86SignedPackedFloatVoidCannotInventRegisterInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86SignedPackedValueRows() {
+			if row.mask != "" || strings.Contains(row.input, "(") || strings.Contains(row.op, ".") {
+				continue // Plain independent Void rows must not route via KMOV or a result store.
+			}
+			t.Run(target.triple+"/"+row.op+"/"+row.bank, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0-0\nVPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" +
+					row.op + " " + row.input + "," + row.bank + "1\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api); err != nil || ir == "" {
+						t.Fatal("initialized independent signed conversion rejected", api, err)
+					}
+					unknown := strings.Replace(source, "VPXORD Z0,Z0,Z0\n", "", 1)
+					if ir, err := x86ScalarFPBitViewAPI(t, unknown, "func Value()", target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Error("Void conversion borrowed unknown vector bytes", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SignedPackedFloatNativeInputsStayIndependent(t *testing.T) {
+	for index, row := range x86SignedPackedValueRows() {
+		if !strings.Contains(row.input, "(") {
+			continue
+		}
+		source, declaration := x86SignedPackedValueFixture("amd64", row, true)
+		pkg := mustGoPackage(t, "value", "package value\n"+declaration)
+		file := mustParseX86RawReturn(t, source)
+		signatures, err := goSigsForAsmFile(pkg, file, func(name string) string {
+			return strings.TrimPrefix(name, "·")
+		}, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signatures["Value"], "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("standalone signed conversion acquired native memory authority", err)
+		}
+		variants := map[string]string{
+			"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+			"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+			"numeric-pointer": strings.Replace(source, "MOVL $1,DX", "MOVL $42,AX\nMOVL $1,DX", 1),
+		}
+		if row.mask != "" {
+			variants["unknown-mask"] = strings.Replace(source, "KMOVD CX,K1\n", "", 1)
+			if !strings.HasSuffix(row.op, ".Z") {
+				variants["unknown-merge"] = strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+			}
+		}
+		for name, changed := range variants {
+			t.Run(fmt.Sprintf("%d/%s", index, name), func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if name == "numeric-pointer" {
+						if err != nil || ir == "" {
+							t.Fatal("signed conversion lost its full NUM native input", api, err)
+						}
+						pointerIR, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+						x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if name == "unknown-vector" || name == "unknown-merge" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("signed conversion borrowed native or vector inputs", api, err)
+					}
+				}
+			})
+		}
+		if row.mask != "" && strings.HasSuffix(row.op, ".Z") {
+			t.Run(fmt.Sprintf("%d/zeroing-needs-no-old-destination", index), func(t *testing.T) {
+				zero := strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+				for _, api := range []string{"text", "module", "Go"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, zero, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+						t.Fatal("zeroing conversion incorrectly demanded an old destination", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_single_source_narrowing_fault_unix_test.go b/x86_single_source_narrowing_fault_unix_test.go
new file mode 100644
index 000000000..aef19d9a1
--- /dev/null
+++ b/x86_single_source_narrowing_fault_unix_test.go
@@ -0,0 +1,60 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Reuse the existing element-granular protection oracle for stores. A zero
+// mask must not read old destination bytes; inactive output elements must not
+// be accessed. This executes portable IR, not original AVX512 instructions.
+func TestX86SingleSourceNarrowingMaskedStoreActiveLaneFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("masked narrowing stores require LLVM22 llc/clang")
+	}
+	var source, declarations, prototypes, metadata strings.Builder
+	count := 0
+	for _, op := range x86SingleSourceNarrowingTestNames() {
+		inputBits, outputBits := x86SingleSourceNarrowTestBits(op)
+		for index, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << index
+			lanes := width * 8 / inputBits
+			name := fmt.Sprintf("NarrowStore%d", count)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\n"+
+				"MOVQ mask+8(FP),CX\nKMOVQ CX,K1\nVPXORD Z0,Z0,Z0\n%s %s0,K1,(AX)\nRET\n", name, op, bank)
+			fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uint64)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint64_t);\n", name)
+			fmt.Fprintf(&metadata, "{%s,%d,%d,%d},\n", name, lanes*outputBits/8, outputBits/8, lanes)
+			count++
+		}
+	}
+	if count != 54 {
+		t.Fatal("masked store lost a family member or physical source width", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86E4DeadReadFaultOracle(prototypes.String(), metadata.String())
+	// The shared oracle's last check supplies a read-only page. Every active
+	// store must fault there, while its original read owners expect success.
+	// Keep those existing owners and their driver bytes completely unchanged.
+	readOnlyCheck := "if(fault(rows[r].run,p+page-rows[r].extent,UINT64_MAX)) return 1;"
+	if strings.Count(driver, readOnlyCheck) != 1 {
+		t.Fatal("shared protection oracle no longer exposes one read-only control")
+	}
+	driver = strings.Replace(driver, readOnlyCheck,
+		"if(fault(rows[r].run,p+page-rows[r].extent,UINT64_MAX)!=1) return 1;", 1)
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized masked-store source rejected before fault observation", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "narrow-masked-store", triple, ir, driver)
+		})
+	}
+}
diff --git a/x86_single_source_narrowing_semantics_test.go b/x86_single_source_narrowing_semantics_test.go
new file mode 100644
index 000000000..01429377e
--- /dev/null
+++ b/x86_single_source_narrowing_semantics_test.go
@@ -0,0 +1,234 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86SingleSourceNarrowingTestNames() []string {
+	return strings.Fields(`VPMOVDB VPMOVDW VPMOVQB VPMOVQD VPMOVQW VPMOVWB
+		VPMOVSDB VPMOVSDW VPMOVSQB VPMOVSQD VPMOVSQW VPMOVSWB
+		VPMOVUSDB VPMOVUSDW VPMOVUSQB VPMOVUSQD VPMOVUSQW VPMOVUSWB`)
+}
+
+// Intel SDM's unsigned-source narrowing is distinct from PACK's signed input
+// with unsigned output. Exercise the high bit without borrowing PACK's oracle.
+// These are portable translated semantics, not original AVX512 execution.
+func TestX86SingleSourceNarrowingUnsignedSourceBoundaries(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("unsigned-source narrowing requires LLVM22 llc/clang")
+	}
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, member := range []struct {
+		op                            string
+		inputBits, outputBits, domain int
+	}{
+		{"VPMOVUSWB", 16, 8, 2}, {"VPMOVUSDB", 32, 8, 2}, {"VPMOVUSQB", 64, 8, 2},
+		{"VPMOVUSDW", 32, 16, 2}, {"VPMOVUSQW", 64, 16, 2}, {"VPMOVUSQD", 64, 32, 2},
+		{"VPMOVSWB", 16, 8, 1}, {"VPMOVSDB", 32, 8, 1}, {"VPMOVSQB", 64, 8, 1},
+		{"VPMOVSDW", 32, 16, 1}, {"VPMOVSQW", 64, 16, 1}, {"VPMOVSQD", 64, 32, 1},
+		{"VPMOVWB", 16, 8, 0}, {"VPMOVDB", 32, 8, 0}, {"VPMOVQB", 64, 8, 0},
+		{"VPMOVDW", 32, 16, 0}, {"VPMOVQW", 64, 16, 0}, {"VPMOVQD", 64, 32, 0},
+	} {
+		for index, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << index
+			carrier := "X"
+			if width*member.outputBits/member.inputBits > 16 {
+				carrier = "Y"
+			}
+			for _, memory := range []bool{false, true} {
+				name := fmt.Sprintf("UnsignedNarrow%d", count)
+				operation := fmt.Sprintf("%s %s0,%s1\nVMOVUPS Z1,(DX)\n", member.op, bank, carrier)
+				memoryFlag := 0
+				if memory {
+					operation = fmt.Sprintf("MOVQ $0xaaaaaaaaaaaaaaaa,CX\nKMOVQ CX,K1\n%s %s0,K1,(DX)\n", member.op, bank)
+					memoryFlag = 1
+				}
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ input+0(FP),AX\nMOVQ out+8(FP),DX\n"+
+					"VMOVUPS (AX),Z0\nVMOVUPS (AX),Z1\n%sRET\n", name, operation)
+				fmt.Fprintf(&declarations, "func %s(input,out *[64]byte)\n", name)
+				fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*,uint8_t*);\n", name)
+				fmt.Fprintf(&rows, "{%s,\"%s\",%d,%d,%d,%d,%d},\n", name, member.op, width, member.inputBits, member.outputBits, member.domain, memoryFlag)
+				count++
+			}
+		}
+	}
+	if count != 108 {
+		t.Fatal("lost narrowing input domain, member or vector width", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n" + prototypes.String() + `
+typedef struct {
+ void(*run)(const uint8_t*,uint8_t*);
+ const char *op;
+ unsigned width,inbits,outbits,domain,memory;
+} Row;
+static const Row rows[]={
+` + rows.String() + `};
+int main(void) {
+ for(unsigned r=0;r<sizeof(rows)/sizeof(rows[0]);r++) {
+  const Row *p=rows+r;
+  uint64_t maximum=(UINT64_C(1)<<p->outbits)-1;
+  uint64_t source_max=UINT64_MAX>>(64-p->inbits),high=UINT64_C(1)<<(p->inbits-1);
+  uint64_t signed_max=maximum>>1,signed_min=source_max-signed_max;
+  const uint64_t edges[]={0,1,maximum-1,maximum,maximum+1,high,high+1,source_max-1,source_max,
+   signed_max-1,signed_max,signed_max+1,signed_min-1,signed_min,signed_min+1};
+  for(unsigned sample=0;sample<sizeof(edges)/sizeof(edges[0]);sample++) {
+   uint8_t input[64],saved[64],output[66],want[64]={0};
+   if(p->memory) memset(want,0xa7,sizeof(want));
+   for(unsigned lane=0;lane<64/(p->inbits/8);lane++) {
+    uint64_t value=edges[(sample+lane)%(sizeof(edges)/sizeof(edges[0]))];
+    for(unsigned b=0;b<p->inbits/8;b++) input[lane*(p->inbits/8)+b]=(uint8_t)(value>>(b*8));
+    if(lane<p->width/(p->inbits/8)&&(!p->memory||(lane&1))) {
+     uint64_t narrowed=value&maximum;
+     if(p->domain==2) narrowed=value>maximum?maximum:value;
+     if(p->domain==1) {
+      int64_t signed_value;
+      if(p->inbits==64) memcpy(&signed_value,&value,sizeof(value));
+      else signed_value=(int64_t)value-((value&high)?(INT64_C(1)<<p->inbits):0);
+      int64_t upper=(int64_t)signed_max,lower=-upper-1;
+      if(signed_value>upper) signed_value=upper;
+      if(signed_value<lower) signed_value=lower;
+      narrowed=(uint64_t)signed_value&maximum;
+     }
+     for(unsigned b=0;b<p->outbits/8;b++) want[lane*(p->outbits/8)+b]=(uint8_t)(narrowed>>(b*8));
+    }
+   }
+   memcpy(saved,input,64);
+   memset(output,0xa7,sizeof(output));
+   p->run(input,output+1);
+   if(memcmp(output+1,want,64)||memcmp(input,saved,64)||output[0]!=0xa7||output[65]!=0xa7) {
+    fprintf(stderr,"unsigned-source narrow op=%s width=%u sample=%u\n",p->op,p->width,sample);
+    return 1;
+   }
+  }
+ }
+ return 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized unsigned-source narrowing rejected before numerical comparison", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "unsigned-source-narrow", triple, ir, driver)
+		})
+	}
+}
+
+// Preserve all 54 Go-encoded memory.Z forms as terminal architectural traps.
+// LLVM22's avx512_trunc_common has rr/rrk/rrkz and mr/mrk, never mrkz;
+// this matches the existing whole-vector move/compact undefined-opcode owner.
+func TestX86SingleSourceNarrowingMemoryZeroingKeepsGoEncodingAndTerminalTrap(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for _, op := range x86SingleSourceNarrowingTestNames() {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			instruction := fmt.Sprintf("%s.Z %s0,K1,(AX)", op, bank)
+			code := x86PackedFirstGoInstructionBytes(t, "amd64", instruction)
+			if len(code) != 6 || code[0] != 0x62 || code[3]&0x80 == 0 || code[5]>>6 == 3 {
+				t.Fatalf("actual Go instruction lacks EVEX.z memory identity: %s %x", instruction, code)
+			}
+			t.Logf("actual Go memory.Z opcode=%s bytes=%x", instruction, code)
+			name := fmt.Sprintf("NarrowTrap%d", len(names))
+			source.WriteString(x86PackedZeroStoreInstruction("·"+name, instruction))
+			fmt.Fprintf(&declarations, "func %s()\n", name)
+			names = append(names, name)
+		}
+	}
+	if len(names) != 54 {
+		t.Fatal("a former Go-encoded shape disappeared", len(names))
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-apple-darwin"},
+		{"amd64", "x86_64-pc-windows-msvc"}, {"386", "i386-unknown-linux-gnu"},
+		{"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("Go-encoded trap failed before object verification", err)
+					}
+					for _, name := range names {
+						if _, err := x86OfficialMoveFaultBody(ir, name); err != nil {
+							t.Fatal("trap read a mask/vector/address or retained an ordinary continuation", err)
+						}
+					}
+					x86ResultInitializationObject(t, llc, target.triple, ir, api)
+				})
+			}
+		})
+	}
+}
+
+func TestX86SingleSourceNarrowingMergeUsesOnlyActiveOldBytes(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT partial(SB),4,$0-0\nVPMOVDB X0,K1,X1\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := file.Funcs[0].Instrs[0]
+	if ins.Op == OpTEXT {
+		ins = file.Funcs[0].Instrs[1]
+	}
+	effect, known, err := x86TypedSingleSourceNarrowByteEffect(ins.Op, ins, "amd64")
+	if !known || err != nil || !effect.operands[1].read || effect.operands[1].requiredBytes != 0xf || effect.operands[1].width != 16 {
+		t.Fatal("active result tuple was confused with the physical carrier", effect, err)
+	}
+	for _, change := range []string{"valid", "source missing", "old missing", "mask missing"} {
+		state := x86ResultState{}
+		state.xmm[0], state.xmm[1], state.masks[1] = 0xffff, 0xf, true
+		switch change {
+		case "source missing":
+			state.xmm[0] &^= 0x8000
+		case "old missing":
+			state.xmm[1] &^= 0x8
+		case "mask missing":
+			state.masks[1] = false
+		}
+		ok, known := x86ResultSingleSourceNarrowStep(ins, &state, nil, 0, "amd64", false)
+		if !known || ok != (change == "valid") || ok && state.vectorBytes(1) != ^uint64(0) {
+			t.Fatal("partial old bytes, input obligations or zero upper aliases changed", change, ok, state.vectorBytes(1))
+		}
+	}
+	const body = "TEXT ·PartialNarrow(SB),4,$0-24\nMOVQ input+0(FP),DI\nMOVQ old+8(FP),SI\nMOVQ out+16(FP),DX\n" +
+		"VMOVUPS (DI),Z0\nMOVSS (SI),X3\nMOVSS X3,X1\nMOVL $1,AX\nKMOVQ AX,K1\nVPMOVDB X0,K1,X1\nVMOVUPS Z1,(DX)\nRET\n"
+	const declaration = "func PartialNarrow(input,old,out *[64]byte)\n"
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, change := range []string{"valid", "source missing", "old missing"} {
+			source := body
+			if change == "source missing" {
+				source = strings.Replace(source, "VMOVUPS (DI),Z0", "MOVSS X3,X0", 1)
+			}
+			if change == "old missing" {
+				source = strings.Replace(source, "MOVSS X3,X1\n", "", 1)
+			}
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+			if change != "valid" {
+				x86VectorScratchCodegenControl(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+			} else if change == "valid" && err != nil || change != "valid" && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+				t.Fatal("public API changed partial-byte admission", api, change, err)
+			}
+			if change == "valid" {
+				llc := findLLVM22Tool("llc")
+				if llc == "" {
+					t.Fatal("LLVM22 llc required for initialized partial-carrier objects")
+				}
+				x86ResultInitializationObject(t, llc, "x86_64-unknown-linux-gnu", ir, api)
+			}
+		}
+	}
+}
diff --git a/x86_sized_nop_result_test.go b/x86_sized_nop_result_test.go
new file mode 100644
index 000000000..8928c8ddd
--- /dev/null
+++ b/x86_sized_nop_result_test.go
@@ -0,0 +1,121 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86SizedNOPCompleteGoRowsAndInertState(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	compact := strings.Join(strings.Fields(string(data)), "")
+	for _, row := range []string{
+		"varydivl=[]ytab{{Zm_o,2,argList{Yml}},}",
+		"{ANOPW,ydivl,Pe,opBytes{0x0f,0x1f,00}},",
+		"{ANOPL,ydivl,Px,opBytes{0x0f,0x1f,00}},",
+	} {
+		if !strings.Contains(compact, row) {
+			t.Fatal("complete sized-NOP Go row or opcode attributes changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"NOPW", "NOPL"} {
+			code := assembleX87ControlBytes(t, arch, "TEXT f(SB),4,$0-0\n"+op+" AX\nRET\n")
+			want := []byte{0x0f, 0x1f, 0xc0, 0xc3}
+			if op == "NOPW" {
+				want = append([]byte{0x66}, want...)
+			}
+			if !bytes.Equal(code, want) {
+				t.Fatalf("original %s/%s bytes %x, want %x", arch, op, code, want)
+			}
+			operands := strings.Fields("AX CX DX BX SP BP SI DI")
+			if arch == "amd64" {
+				operands = append(operands, strings.Fields("R8 R9 R10 R11 R12 R13 R14 R15 g")...)
+				operands = append(operands, "(g)", "(AX)(g*2)")
+			}
+			operands = append(operands, "(AX)", "4096(BP)", "(AX)(DX*8)", "external(SB)", "value+0(FP)")
+			var original strings.Builder
+			original.WriteString("TEXT f(SB),4,$0-0\n")
+			for _, operand := range operands {
+				original.WriteString(op + " " + operand + "\n")
+			}
+			original.WriteString("RET\n")
+			goAssemblerOracleOutput(t, arch, original.String(), "", true)
+			for _, operand := range operands {
+				t.Run(arch+"/"+op+"/"+operand, func(t *testing.T) {
+					instruction := x86ScalarLaneInstruction(t, op+" "+operand)
+					effect, known, err := x86TypedGPByteEffect(instruction.Op, instruction, arch)
+					if !known || err != nil || len(effect.operands) != 0 || effect.flagsRead != 0 ||
+						effect.flagsDefined != 0 || effect.flagsKilled != 0 || effect.dynamicMemory || effect.requiresResultProof {
+						t.Fatal("sized NOP lacks its complete no-read/no-write effect", known, effect, err)
+					}
+					if _, _, memory := x86InstructionMemoryShape(instruction, 0, arch); memory {
+						t.Fatal("ignored ModRM operand invented a memory access")
+					}
+					predicate := x86ResultPredicate{kind: x86ResultComparisonBytes, register: 1, width: 16}
+					if after := x86ResultPredicateAfter(instruction, predicate, arch); after != predicate {
+						t.Fatal("inert instruction lost an unchanged source predicate")
+					}
+					for _, consumer := range x86ResultGPSIMDConsumers {
+						for _, initialized := range []bool{false, true} {
+							state := x86ResultState{fp: []bool{false, true}, direction: x86ResultDirectionBackward}
+							if initialized {
+								state.gp[0], state.xmm[0], state.vectorUpper[0] = 0x53, 0x5511, 0xaabbccdd00000000
+								state.pointerGP[3], state.masks[1], state.flags = true, true, x86ByteFlagsAll
+							}
+							before := state.clone()
+							if !consumer.step(instruction, &state, []bool{false, false}, 0, arch) || !reflect.DeepEqual(state, before) {
+								t.Fatal("inert instruction consumed or manufactured state", consumer.name, initialized)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86SizedNOPOriginalProgramPortableAndObjects(t *testing.T) {
+	const owner = "TestAMD64SizedNOPRuntimePreservesState"
+	source := x86X87FunctionLiteral(t, "amd64_lower_nop_width_test.go", owner, "source")
+	driver := x86X87FunctionLiteral(t, "amd64_lower_nop_width_test.go", owner, "mainC")
+	execution := x86ScalarCountHostExecution(t)
+	const declaration = "func sizednopsemantics(out *byte)"
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-macosx", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("unchanged complete original sized-NOP source", api, err)
+				}
+				for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, execution.llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("portable/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "original-sized-nop", text, driver, level)
+				}
+			}
+		})
+	}
+	t.Log("unchanged original literals: Go/LLVM objects and actual-host portable state; not native x86 execution")
+}
diff --git a/x86_source_stack_bool_named_fp_test.go b/x86_source_stack_bool_named_fp_test.go
new file mode 100644
index 000000000..d53bddd47
--- /dev/null
+++ b/x86_source_stack_bool_named_fp_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86PhysicalSourceStackBoolNamedFPStillNeedsCanonicalProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := int64(8)
+		if target.arch == "386" {
+			word = 4
+		}
+		for _, test := range []struct {
+			name, body string
+			accepted   bool
+		}{
+			{"identity", "MOVB x+0(FP),AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+			{"one", "MOVB $1,ret+@WORD(FP)\nBYTE $0xc3", true},
+			{"intermediate", "MOVB $2,ret+@WORD(FP)\nMOVB ret+@WORD(FP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+			{"two", "MOVB $2,ret+@WORD(FP)\nBYTE $0xc3", false},
+			{"three", "MOVB $3,ret+@WORD(FP)\nBYTE $0xc3", false},
+			{"unknown", "MOVB BX,ret+@WORD(FP)\nBYTE $0xc3", false},
+			{"unwritten", "MOVB x+0(FP),AX\nBYTE $0xc3", false},
+		} {
+			source, sig, pkg := x86SourceStackTypedFixture(target.arch, "bool", I1, word, "MOVB", test.body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+test.name+"/"+api, func(t *testing.T) {
+					err := x86PhysicalBoolTranslate(t, target.arch, target.triple, api, source, sig, pkg)
+					if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("named FP/raw RET accepted=%t: %v", test.accepted, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolDefaultModeUsesPublicAMD64Role(t *testing.T) {
+	for _, test := range []struct {
+		body     string
+		accepted bool
+	}{
+		{"MOVB x+0(FP),AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+		{"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3", true},
+		{"MOVB $2,ret+@WORD(FP)\nBYTE $0xc3", false},
+		{"MOVB $2,@RESULT(SP)\nBYTE $0xc3", false},
+		{"MOVB $2,ret+@WORD(FP)\nMOVB ret+@WORD(FP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3", true},
+	} {
+		source, sig, pkg := x86SourceStackTypedFixture("amd64", "bool", I1, 8, "MOVB", test.body)
+		for _, api := range []string{"text", "module"} {
+			t.Run(api+"/"+test.body, func(t *testing.T) {
+				err := x86PhysicalBoolTranslate(t, "", "x86_64-unknown-linux-gnu", api, source, sig, pkg)
+				if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("default-mode accepted=%t: %v", test.accepted, err)
+				}
+			})
+		}
+	}
+	t.Run("Go still requires explicit architecture", func(t *testing.T) {
+		source, sig, pkg := x86SourceStackTypedFixture("amd64", "bool", I1, 8, "MOVB", "MOVB $1,ret+@WORD(FP)\nBYTE $0xc3")
+		if err := x86PhysicalBoolTranslate(t, "", "x86_64-unknown-linux-gnu", "Go", source, sig, pkg); err == nil || !strings.Contains(err.Error(), "empty GOARCH") {
+			t.Fatal("Go API lost its independent explicit architecture requirement", err)
+		}
+	})
+}
diff --git a/x86_source_stack_bool_objects_test.go b/x86_source_stack_bool_objects_test.go
new file mode 100644
index 000000000..a45e8a471
--- /dev/null
+++ b/x86_source_stack_bool_objects_test.go
@@ -0,0 +1,118 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86PhysicalBoolObjectSource(arch string) (string, string, string) {
+	word, suffix := int64(8), "Q"
+	if arch == "386" {
+		word, suffix = 4, "L"
+	}
+	var source, declarations strings.Builder
+	for index, body := range []string{
+		"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB $0,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB $1,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB @WORD(SP),AH\nMOVB AH,BL\nMOVB BL,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB @WORD(SP),AX\nPUSHW AX\nMOVW $0,AX\nPOPW AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB @WORD(SP),AX\nPUSH" + suffix + " AX\nMOV" + suffix + " $0,AX\nPOP" + suffix + " AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB $3,@RESULT(SP)\nMOVB @RESULT(SP),AX\nANDB $1,AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB $2,@RESULT(SP)\nMOVB @RESULT(SP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+		"MOVB x+0(FP),AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3",
+		"MOVB $1,ret+@WORD(FP)\nBYTE $0xc3",
+		"MOVB $2,ret+@WORD(FP)\nMOVB ret+@WORD(FP),AX\nSHRB $1,AX\nANDB $1,AX\nMOVB AX,ret+@WORD(FP)\nBYTE $0xc3",
+	} {
+		name := fmt.Sprintf("PhysicalBool%d", index)
+		text, _, _ := x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB", body)
+		source.WriteString(strings.ReplaceAll(text, "·Value", "·"+name))
+		fmt.Fprintf(&declarations, "func %s(x bool) bool\n", name)
+	}
+	negative := strings.Replace(source.String(), fmt.Sprintf("MOVB $1,%d(SP)", 2*word), fmt.Sprintf("MOVB $3,%d(SP)", 2*word), 1)
+	return source.String(), declarations.String(), negative
+}
+
+func x86PhysicalBoolObjectAPI(t *testing.T, source, declarations, arch, triple, api string) (string, error) {
+	t.Helper()
+	if !strings.HasPrefix(api, "default-") {
+		return x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+	}
+	// Derive the actual declaration under the known AMD64 source mode, then
+	// independently exercise the public Options default without editing it.
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	pkg := mustGoPackage(t, "bitview", "package bitview\n"+declarations)
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, "amd64", nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{TargetTriple: triple, ResolveSym: resolve, Sigs: sigs}
+	if api == "default-text" {
+		return Translate(file, options)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := TranslateModuleInContext(ctx, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func TestX86PhysicalSourceStackBoolFiveTargetOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("physical source-stack bool objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, negative := x86PhysicalBoolObjectSource(target.arch)
+			negativeNamed := strings.Replace(source, fmt.Sprintf("MOVB $1,ret+%d(FP)", goWordSize(target.arch)), fmt.Sprintf("MOVB $3,ret+%d(FP)", goWordSize(target.arch)), 1)
+			if strings.Count(source, "TEXT ·") != 11 || source == negative || source == negativeNamed {
+				t.Fatal("complete physical bool source inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, negative)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, negativeNamed)
+			completeRuntime, _ := x86SourceStackRuntimeSource(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, completeRuntime)
+			apis := []string{"text", "module", "Go"}
+			if target.arch == "amd64" {
+				apis = append(apis, "default-text", "default-module")
+			}
+			for _, api := range apis {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86PhysicalBoolObjectAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete original physical bool source rejected", err)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86UndefinedTrapOptimizedIR(t, input)
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, level)
+							})
+						}
+					}
+					for _, badSource := range []string{negative, negativeNamed} {
+						if bad, err := x86PhysicalBoolObjectAPI(t, badSource, declarations, target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) || bad != "" {
+							t.Fatal("noncanonical complete original physical/named bool source published LLVM", err)
+						}
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_source_stack_bool_result_test.go b/x86_source_stack_bool_result_test.go
new file mode 100644
index 000000000..20975545d
--- /dev/null
+++ b/x86_source_stack_bool_result_test.go
@@ -0,0 +1,274 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86PhysicalBoolTranslate(t *testing.T, arch, triple, api, source string, sig FuncSig, pkg GoPackage) error {
+	t.Helper()
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	if api == "Go" {
+		result, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{GOARCH: arch, TargetTriple: triple})
+		if result != nil && !result.Module.IsNil() {
+			result.Module.Dispose()
+		}
+		return err
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return err
+	}
+	opt := x86SourceStackOptions(arch, triple, sig)
+	if api == "text" {
+		_, err = Translate(file, opt)
+		return err
+	}
+	module, err := TranslateModuleInContext(ctx, file, opt)
+	if !module.IsNil() {
+		module.Dispose()
+	}
+	return err
+}
+
+func TestX86PhysicalSourceStackBoolCompleteResultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := int64(8)
+		if target.arch == "386" {
+			word = 4
+		}
+		// Exact unchanged bool source from both failed complete CI fixtures.
+		source, sig, pkg := x86SourceStackTypedFixture(target.arch, "bool", I1, word, "MOVB",
+			"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				if err := x86PhysicalBoolTranslate(t, target.arch, target.triple, api, source, sig, pkg); err != nil {
+					t.Fatal(err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolNoncanonicalBytesStayContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := int64(8)
+		if target.arch == "386" {
+			word = 4
+		}
+		for _, body := range []string{
+			"MOVB $2,AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+			"MOVB $3,@RESULT(SP)\nBYTE $0xc3",
+			"MOVB $255,AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3",
+			"MOVB BX,@RESULT(SP)\nBYTE $0xc3",
+			"MOVB @WORD(SP),AX\nBYTE $0xc3",
+		} {
+			source, sig, pkg := x86SourceStackTypedFixture(target.arch, "bool", I1, word, "MOVB", body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", target.triple, api, strings.ReplaceAll(body, "\n", ";")), func(t *testing.T) {
+					if err := x86PhysicalBoolTranslate(t, target.arch, target.triple, api, source, sig, pkg); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("noncanonical/undefined physical bool accepted: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolAliasesStackAndCFG(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix := int64(8), "Q"
+		if target.arch == "386" {
+			word, suffix = 4, "L"
+		}
+		read := "MOVB @WORD(SP),AX\n"
+		write := "MOVB AX,@RESULT(SP)\nBYTE $0xc3"
+		for _, test := range []struct {
+			name, body string
+			accepted   bool
+		}{
+			{"zero", "MOVB $0,AX\n" + write, true},
+			{"one", "MOVB $1,AX\n" + write, true},
+			{"high byte alias", "MOVB @WORD(SP),AH\nMOVB AH,BL\nMOVB BL,@RESULT(SP)\nBYTE $0xc3", true},
+			{"word saved value", read + "PUSHW AX\nMOVW $0,AX\nPOPW AX\n" + write, true},
+			{"native saved value", read + "PUSH" + suffix + " AX\nMOV" + suffix + " $0,AX\nPOP" + suffix + " AX\n" + write, true},
+			{"restored frame", read + "PUSH" + suffix + " BP\nMOV" + suffix + " SP,BP\nMOV" + suffix + " BP,SP\nPOP" + suffix + " BP\n" + write, true},
+			{"raw intermediate", "MOVB $3,@RESULT(SP)\nMOVB @RESULT(SP),AX\nANDB $1,AX\n" + write, true},
+			{"observable raw intermediate", "MOVB $2,@RESULT(SP)\nMOVB @RESULT(SP),AX\nSHRB $1,AX\nANDB $1,AX\n" + write, true},
+			{"canonical join", "MOVL $0,AX\nCMPL AX,$0\nJE alternate\nMOVB $0,@RESULT(SP)\nJMP done\nalternate:\nMOVB $1,@RESULT(SP)\ndone:\nBYTE $0xc3", true},
+			{"noncanonical join", "MOVL $0,AX\nCMPL AX,$0\nJE alternate\nMOVB $0,@RESULT(SP)\nJMP done\nalternate:\nMOVB $3,@RESULT(SP)\ndone:\nBYTE $0xc3", false},
+			{"unknown upper byte", read + "MOVB AH,@RESULT(SP)\nBYTE $0xc3", false},
+			{"unknown overwritten value", read + "MOVB BL,AL\n" + write, false},
+			{"partial slot", "MOVW @WORD(SP),AX\n" + write, false},
+			{"padding", "MOVB @WORD+1(SP),AX\n" + write, false},
+			{"unbalanced stack", read + "PUSH" + suffix + " AX\n" + write, false},
+			{"wrong stack width", read + "PUSHW AX\nPOP" + suffix + " AX\n" + write, false},
+			{"input store", "MOVB $2,@WORD(SP)\n" + read + write, false},
+			{"pointer escape", read + "MOVB AX,(BX)\n" + write, false},
+			{"call", read + "CALL ·callee(SB)\n" + write, false},
+		} {
+			source, sig, pkg := x86SourceStackTypedFixture(target.arch, "bool", I1, word, "MOVB", test.body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+test.name+"/"+api, func(t *testing.T) {
+					err := x86PhysicalBoolTranslate(t, target.arch, target.triple, api, source, sig, pkg)
+					if test.accepted && err != nil || !test.accepted && !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("physical bool accepted=%t: %v", test.accepted, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolProofAndSignatureCannotBeRebound(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, triple := int64(8), "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			word, triple = 4, "i386-unknown-linux-gnu"
+		}
+		source, sig, _ := x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+			"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, arch, x86SourceStackOptions(arch, triple, sig))
+		if err != nil {
+			t.Fatal(err)
+		}
+		before := cloneX86ReplayInstrs(file.Funcs[0].Instrs)
+		original := normalized.Funcs[0]
+		for _, change := range []string{"none", "proof missing", "wrong mode", "wrong header", "changed original", "changed access", "removed access", "changed instruction", "changed raw spelling", "signature result offset", "signature type", "signature input type", "signature custom entry", "forged stack", "copied stack token", "changed stack minimum", "changed stack normalized identity"} {
+			t.Run(arch+"/"+change, func(t *testing.T) {
+				fn := original
+				fn.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+				copies, err := cloneFixedLocalSigs(map[string]FuncSig{sig.Name: sig})
+				if err != nil {
+					t.Fatal(err)
+				}
+				declaration := copies[sig.Name]
+				consumer := &amd64Ctx{sig: declaration, fpSourceSig: declaration, fpScalarSource: fn,
+					sourceStack: fn.x86SourceStack, goarch: arch, targetTriple: triple}
+				switch change {
+				case "proof missing":
+					consumer.sourceStack = nil
+				case "wrong mode":
+					consumer.goarch = "arm64"
+				case "wrong header":
+					consumer.fpScalarSource.ArgSize++
+				case "changed original":
+					replay := *fn.x86RawReplay
+					replay.original = cloneX86ReplayInstrs(replay.original)
+					replay.original[1].Raw = "MOVB $1,AX"
+					consumer.fpScalarSource.x86RawReplay = &replay
+				case "changed access":
+					consumer.fpScalarSource.Instrs[1].x86SourceStackFP[0]++
+				case "removed access":
+					consumer.fpScalarSource.Instrs[1].x86SourceStackFP = nil
+				case "changed instruction":
+					consumer.fpScalarSource.Instrs[1].Args[0].Mem.Off++
+				case "changed raw spelling":
+					consumer.fpScalarSource.Instrs[1].Raw = "MOVB $1,AX"
+				case "signature result offset":
+					consumer.fpSourceSig.Frame.Results[0].Offset++
+				case "signature type":
+					consumer.fpSourceSig.Ret = I8
+				case "signature input type":
+					consumer.fpSourceSig.Args[0] = I8
+				case "signature custom entry":
+					consumer.fpSourceSig.ArgRegs = []Reg{AX}
+				case "forged stack":
+					consumer.sourceStack = &x86SourceStackProof{word: word}
+					consumer.fpScalarSource.x86SourceStack = consumer.sourceStack
+				case "copied stack token", "changed stack minimum", "changed stack normalized identity":
+					copy := *consumer.sourceStack
+					consumer.sourceStack = &copy
+					consumer.fpScalarSource.x86SourceStack = &copy
+					if change == "changed stack minimum" {
+						copy.minimum -= word
+					}
+					if change == "changed stack normalized identity" {
+						copy.normalized[0] ^= 1
+					}
+				}
+				err = consumer.checkSourceStackScalarResultInitialization()
+				if change == "none" && err != nil || change != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("changed=%s source-stack result: %v", change, err)
+				}
+			})
+		}
+		if !reflect.DeepEqual(before, file.Funcs[0].Instrs) {
+			t.Fatal("normalization mutated caller source")
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolCloneAndByteBudget(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := int64(8)
+		if arch == "386" {
+			word = 4
+		}
+		source, sig, _ := x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+			"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		initial := x86SourceStackScalarInitial(file.Funcs[0], sig, arch)
+		if initial == nil {
+			t.Fatal("actual scalar bool layout rejected")
+		}
+		copy := initial.clone()
+		copy.bytes.fp[0], copy.bytes.canonicalFP[0], copy.bytes.gp[0] = false, false, 255
+		if !initial.bytes.fp[0] || !initial.bytes.canonicalFP[0] || initial.bytes.gp[0] != 0 {
+			t.Fatal("physical bool CFG state aliases predecessor")
+		}
+		sig.Frame.Results[0].Offset = 4095
+		text := fmt.Sprintf("TEXT ·Value(SB),4,$0-4096\nMOVB %d(SP),AX\n", word) +
+			strings.Repeat("MOVB $1,AX\n", 2048) + fmt.Sprintf("MOVB AX,%d(SP)\nBYTE $0xc3\n", word+4095)
+		file, err = Parse(ArchAMD64, text)
+		if err != nil {
+			t.Fatal(err)
+		}
+		opt := x86SourceStackOptions(arch, "", sig)
+		if _, err := normalizeX86RawFile(file, arch, opt); !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "byte budget") {
+			t.Fatalf("combined physical bool byte-work budget not retained: %v", err)
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackBoolRuntimeFixtureRetainsBothByteRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word := int64(8)
+		if arch == "386" {
+			word = 4
+		}
+		source, sigs := x86SourceStackRuntimeSource(arch)
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		want := len(x86SourceStackRuntimeCases(arch)) + 3
+		if len(file.Funcs) != want || len(sigs) != want {
+			t.Fatal("complete old runtime inventory plus two bool roles differs")
+		}
+		old, _, _ := x86SourceStackTypedFixture(arch, "bool", I1, word, "MOVB",
+			"MOVB @WORD(SP),AX\nMOVB AX,@RESULT(SP)\nBYTE $0xc3")
+		old = strings.ReplaceAll(old, "·Value", "·PhysicalBool")
+		if strings.Count(source, old) != 1 {
+			t.Fatal("original physical bool source changed")
+		}
+		for _, driver := range []string{x86SourceStackGoOracle(arch), x86SourceStackCOracle(arch)} {
+			if strings.Count(driver, "PhysicalBool(") != 3 || strings.Count(driver, "PhysicalBoolIntermediate(") != 3 || strings.Count(driver, "PhysicalBoolNamedFP(") != 3 {
+				t.Fatal("independent original Go/LLVM caller lacks both bool inputs/roles")
+			}
+		}
+	}
+}
diff --git a/x86_source_stack_movsxd_literal_test.go b/x86_source_stack_movsxd_literal_test.go
new file mode 100644
index 000000000..7aa09a54c
--- /dev/null
+++ b/x86_source_stack_movsxd_literal_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Opcode 63's mode64 memory family has a four-byte source for both the
+// default dword copy and effective REX.W sign extension (including 66+REX.W).
+// The ordinary 8B dword load shares that exact four-byte input role. SP/BP
+// and the Go g register retain their independent physical roles.
+func x86SourceStackMOVSXDLiteralProgram() (string, string, string) {
+	var assembly, declarations, driver strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n")
+	var checks strings.Builder
+	count := 0
+	for _, encoding := range []struct {
+		opcode                byte
+		rexW, operandOverride bool
+	}{
+		{opcode: 0x63},
+		{opcode: 0x63, rexW: true},
+		{opcode: 0x63, rexW: true, operandOverride: true},
+		{opcode: 0x8b},
+	} {
+		for _, register := range []byte{0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 15} {
+			name := fmt.Sprintf("Literal%d", count)
+			count++
+			var code []byte
+			if encoding.operandOverride {
+				code = append(code, 0x66)
+			}
+			rex := byte(0x40)
+			if encoding.rexW {
+				rex |= 8
+			}
+			if register >= 8 {
+				rex |= 4
+			}
+			if rex != 0x40 {
+				code = append(code, rex)
+			}
+			// The RIP displacement crosses the complete five-byte result
+			// store and the actual native RET, never executable pool data.
+			code = append(code, encoding.opcode, (register&7)<<3|5, 6, 0, 0, 0,
+				0x48|rex&4, 0x89, (register&7)<<3|0x44, 0x24, 16, 0xc3,
+				0, 0, 0, 0x80)
+			var body strings.Builder
+			for _, value := range code {
+				fmt.Fprintf(&body, "BYTE $%#02x\n", value)
+			}
+			source, _, _ := x86SourceStackNumericalFixture("amd64", body.String())
+			assembly.WriteString(strings.ReplaceAll(source, "Value", name))
+			fmt.Fprintf(&declarations, "func %s(x uint64) uint64\n", name)
+			fmt.Fprintf(&driver, "extern uint64_t %s(uint64_t);\n", name)
+			want := "UINT64_C(0xffffffff80000000)"
+			if !encoding.rexW {
+				want = "UINT64_C(0x80000000)"
+			}
+			fmt.Fprintf(&checks, "if (%s(UINT64_MAX) != %s) {fprintf(stderr,\"%s failed\\n\"); return 1;}\n", name, want, name)
+		}
+	}
+	driver.WriteString("int main(void) {\n" + checks.String() + "return 0;\n}\n")
+	return assembly.String(), declarations.String(), driver.String()
+}
+
+func TestX86SourceStackMOVSXDLiteralCompletePhysicalInputs(t *testing.T) {
+	source, declarations, _ := x86SourceStackMOVSXDLiteralProgram()
+	if strings.Count(source, "TEXT ") != 52 {
+		t.Fatal("39 MOVSXD and 13 ordinary dword-load register programs required")
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+					if err != nil {
+						t.Fatal("exact physical literal/result source rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86SourceStackMOVSXDLiteralPortableValues(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	source, declarations, driver := x86SourceStackMOVSXDLiteralProgram()
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "movsxd-literal", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func TestX86SourceStackMOVSXDLiteralReaderDoesNotEscape(t *testing.T) {
+	for _, prefix := range [][]byte{nil, {0x48}, {0x66, 0x48}} {
+		code := append([]byte(nil), prefix...)
+		code = append(code, 0x63, 0x05, 1, 0, 0, 0, 0xc3, 0, 0, 0, 0x80)
+		decoded, err := decodeX86RawDirectiveGroup(code, 64, 0, "literal", map[string]bool{})
+		if err != nil || len(decoded) != 2 {
+			t.Fatalf("literal decode %x: %v", code, err)
+		}
+		state := &x86SourceStackScalarState{}
+		if !state.step(decoded[0], "amd64") || state.bytes.gp[0] != 0xff {
+			t.Fatalf("exact four-byte literal did not define the complete GP result: %x", code)
+		}
+		if state.bytes.literalMemoryOperand != nil || state.bytes.literalMemoryBytes != 0 ||
+			state.bytes.loweredStaticReads != nil || state.bytes.pointerGP[0] {
+			t.Fatal("temporary literal input escaped as memory or pointer permission")
+		}
+		if x86ResultRead(decoded[0].Args[0], 4, &state.bytes, nil, "amd64") {
+			t.Fatal("a later unbound read borrowed the previous instruction's literal")
+		}
+	}
+}
diff --git a/x86_source_stack_scalar_result.go b/x86_source_stack_scalar_result.go
new file mode 100644
index 000000000..fa3ce7fdf
--- /dev/null
+++ b/x86_source_stack_scalar_result.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+)
+
+// This state belongs only to the already bounded physical source-stack CFG.
+// It grants neither ordinary logical ABI0 entry nor caller/native memory. NUM
+// and canonical bytes stay independent, including intermediate raw 2/3 values.
+type x86SourceStackScalarState struct {
+	bytes           x86ResultState
+	owned           []bool // Immutable actual scalar layout.
+	result          int64
+	width           int64
+	canonicalResult bool
+}
+
+type x86SourceStackScalarProof struct {
+	owner             *x86SourceStackProof
+	minimum           int64
+	word              int64
+	stackIdentity     [32]byte
+	countedIterations [4]int
+	signature         [32]byte
+	function          [32]byte
+	original          []Instr
+	normalized        []Instr
+}
+
+// A cost/denial predicate only. A stack-unobserved raw RET still transports
+// physical ABI0 bool bytes; omitting explicit SP syntax cannot bypass the
+// independent producer. Zero-argument/custom/native entries remain separate.
+func x86SourceStackBoolCandidate(fn Func, sig FuncSig) bool {
+	return fn.FrameSize == 0 && !strings.Contains(fn.Sym, "<") && sig.Ret == I1 &&
+		len(sig.Args) != 0 && len(sig.ArgRegs) == 0 && len(sig.Frame.Results) == 1 && sig.Frame.Results[0].Type == I1
+}
+
+func x86SourceStackScalarArch(arch string) string {
+	if arch == "" {
+		return "amd64" // The existing ArchAMD64 renderer default, not an Options/source rewrite.
+	}
+	return arch
+}
+
+func x86SourceStackScalarInitial(fn Func, sig FuncSig, arch string) *x86SourceStackScalarState {
+	arch = x86SourceStackScalarArch(arch)
+	if (arch != "386" && arch != "amd64") || fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") || fn.ArgSize > 4096 ||
+		!x86SourceStackScalarABI0(sig, fn.ArgSize, arch) || sig.ARMEntry != nil ||
+		sig.ARM64GoRegisterABI != nil || sig.ARM64ClosureABI != nil || sig.WASMContext != "" || sig.WASMNative ||
+		sig.x86CallerRegions != nil || sig.x86FixedLocal != nil || sig.x86BorrowedBoolTail {
+		return nil
+	}
+	result := sig.Frame.Results[0]
+	width := x86FrameScalarBytes(result.Type, arch)
+	if result.Index != 0 || result.Field != -1 || len(result.Fields) != 0 || result.Offset < 0 ||
+		width <= 0 || result.Offset > 4096-width {
+		return nil
+	}
+	state := &x86SourceStackScalarState{result: result.Offset, width: width, canonicalResult: sig.Ret == I1,
+		owned: make([]bool, result.Offset+width)}
+	state.bytes.fp = make([]bool, len(state.owned))
+	state.bytes.canonicalFP = make([]bool, len(state.owned))
+	for offset := result.Offset; offset < result.Offset+width; offset++ {
+		state.owned[offset] = true
+	}
+	for _, slot := range sig.Frame.Params {
+		width := x86FrameScalarBytes(slot.Type, arch)
+		if slot.Offset < 0 || slot.Offset > result.Offset-width {
+			return nil
+		}
+		for offset := slot.Offset; offset < slot.Offset+width; offset++ {
+			if state.owned[offset] {
+				return nil
+			}
+			state.owned[offset], state.bytes.fp[offset] = true, true
+			state.bytes.canonicalFP[offset] = slot.Type == I1
+		}
+	}
+	return state
+}
+
+func (state *x86SourceStackScalarState) clone() *x86SourceStackScalarState {
+	if state == nil {
+		return nil
+	}
+	copy := *state
+	copy.bytes = state.bytes.clone()
+	return &copy
+}
+
+// Run only after the existing physical SP/BP, access and FLAGS producer has
+// checked this exact instruction. Its access annotations are not public FP
+// permission: only this local byte-effect copy uses their exact slot offsets.
+func (state *x86SourceStackScalarState) step(ins Instr, arch string) bool {
+	arch = x86SourceStackScalarArch(arch)
+	if ins.Op == OpTEXT || ins.Op == OpLABEL {
+		return true
+	}
+	if _, stack := amd64StackWidthSpecs[ins.Op]; stack {
+		return true // Its saved NUM/canonical/FLAGS payload was transported together.
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpReg && x86RawReturnStackRegister(operand.Reg) {
+			// The producer allows only its exact SP/BP control effects here.
+			// Physical address arithmetic cannot define numerical status bits.
+			if effect, known, _ := x86TypedInstructionByteEffect(ins.Op, ins, arch); known {
+				state.bytes.flags &^= effect.flagsDefined | effect.flagsKilled
+			}
+			return true
+		}
+	}
+	local := ins
+	local.Args = append([]Operand(nil), ins.Args...)
+	for index, offset := range ins.x86SourceStackFP {
+		if index < 0 || index >= len(local.Args) || local.Args[index].Kind != OpMem {
+			return false
+		}
+		local.Args[index] = Operand{Kind: OpFP, FPOffset: offset}
+	}
+	beforeFP, beforeGP := state.bytes.canonicalFP, state.bytes.canonicalGP
+	next := state.bytes.clone()
+	if arch == "amd64" && x86RawDwordLiteralInput(ins) {
+		// The decoder-bound four-byte input belongs to this instruction
+		// only. Typed MOVL/MOVLQSX effects retain their distinct extension;
+		// the raw-return guard separately checks the actual DATA object.
+		next.literalMemoryOperand, next.literalMemoryBytes = &ins.Args[0], 4
+	}
+	accepted := x86ResultTransfer(local, &next, state.owned, state.result, arch)
+	next.literalMemoryOperand, next.literalMemoryBytes = nil, 0
+	if !accepted {
+		// An unobserved nontrapping scratch result may remain unknown. This
+		// does not excuse later result, store, address or FLAGS observations.
+		next = state.bytes.clone()
+		if !x86LoweredPureGPUnknownTransfer(local, &next, arch) {
+			return false
+		}
+	}
+	state.bytes = next
+	state.bytes.canonicalFP, state.bytes.canonicalGP = x86ABI0CanonicalBytesAfter(local, beforeFP, beforeGP, arch)
+	for offset := range state.bytes.canonicalFP {
+		state.bytes.canonicalFP[offset] = state.bytes.canonicalFP[offset] && state.bytes.fp[offset]
+	}
+	for index := range state.bytes.canonicalGP {
+		state.bytes.canonicalGP[index] &= state.bytes.gp[index]
+	}
+	return true
+}
+
+func (state *x86SourceStackScalarState) complete() bool {
+	for offset := state.result; offset < state.result+state.width; offset++ {
+		if !state.bytes.fp[offset] || state.canonicalResult && !state.bytes.canonicalFP[offset] {
+			return false
+		}
+	}
+	return true
+}
+
+// Only acyclic, fully checked scalar source CFGs use this must-fact join.
+// Physical stack shape, opaque BP/g cells and immutable layout stay exact.
+// Numerical/canonical bytes and FLAGS can only lose knowledge at a join.
+func x86SourceStackScalarMerge(left, right x86SourceStackState) (x86SourceStackState, bool) {
+	result := left
+	if left.scalarResult == nil || right.scalarResult == nil || left.sp != right.sp || left.bp != right.bp ||
+		left.callers != nil || right.callers != nil || left.known != nil || right.known != nil ||
+		left.vectors != nil || right.vectors != nil || left.masks != nil || right.masks != nil || len(left.cells) != len(right.cells) {
+		return result, false
+	}
+	a, b := left.scalarResult, right.scalarResult
+	if a.result != b.result || a.width != b.width || a.canonicalResult != b.canonicalResult || !reflect.DeepEqual(a.owned, b.owned) {
+		return result, false
+	}
+	result.cells = append([]x86SourceStackCell(nil), left.cells...)
+	for index, first := range left.cells {
+		second := right.cells[index]
+		first.known, second.known = 0, 0
+		first.canonical, second.canonical = 0, 0
+		first.scalarFlags, second.scalarFlags = 0, 0
+		first.numericFlags, second.numericFlags = false, false
+		first.partialNumericFlags, second.partialNumericFlags = 0, 0
+		if !reflect.DeepEqual(first, second) {
+			return result, false
+		}
+		cell := &result.cells[index]
+		cell.known &= right.cells[index].known
+		cell.canonical &= right.cells[index].canonical
+		cell.scalarFlags &= right.cells[index].scalarFlags
+		mask := x86SourceStackNumericFlagMask(&x86SourceStackState{
+			numericFlags: cell.numericFlags, partialNumericFlags: cell.partialNumericFlags}) &
+			x86SourceStackNumericFlagMask(&x86SourceStackState{
+				numericFlags: right.cells[index].numericFlags, partialNumericFlags: right.cells[index].partialNumericFlags})
+		cell.numericFlags, cell.partialNumericFlags = mask == x86ByteFlagsAll, 0
+		if !cell.numericFlags {
+			cell.partialNumericFlags = mask
+		}
+	}
+	value := *a
+	value.bytes = a.bytes.intersect(b.bytes)
+	result.scalarResult = &value
+	x86SourceStackSetNumericFlags(&result, x86SourceStackNumericFlagMask(&left)&x86SourceStackNumericFlagMask(&right))
+	result.gOriginal = left.gOriginal && right.gOriginal
+	return result, true
+}
+
+func sealX86SourceStackScalar(fn, original Func, sig FuncSig, stack *x86SourceStackProof) *x86SourceStackScalarProof {
+	function, err := x86CallerSourceFingerprint(fn)
+	if err != nil {
+		return nil
+	}
+	signature, err := x86CallerSourceFingerprint(sig)
+	if err != nil {
+		return nil
+	}
+	raw := original.Instrs
+	if replay := original.x86RawReplay; replay != nil {
+		if replay.validate(original, replay.goarch) != nil {
+			return nil
+		}
+		raw = replay.original
+	}
+	return &x86SourceStackScalarProof{owner: stack, minimum: stack.minimum, word: stack.word,
+		stackIdentity: stack.normalized, countedIterations: stack.countedIterations, signature: signature, function: function,
+		original: cloneX86ReplayInstrs(raw), normalized: cloneX86ReplayInstrs(fn.Instrs)}
+}
+
+func (c *amd64Ctx) checkSourceStackScalarResultInitialization() error {
+	fn, sig, stack := c.fpScalarSource, c.fpSourceSig, c.sourceStack
+	fail := func() error {
+		return goAMD64FrameContext("physical source-stack scalar result lost its complete source/declaration/numerical proof")
+	}
+	if stack == nil || fn.x86SourceStack != stack || stack.scalarResult == nil || stack.word != x86ResultPointerWord(c.goarch) ||
+		fn.FrameSize != 0 || c.frameSize != fn.FrameSize || x86SourceStackScalarInitial(fn, sig, c.goarch) == nil {
+		return fail()
+	}
+	proof := stack.scalarResult
+	if proof.owner != stack || proof.minimum != stack.minimum || proof.word != stack.word || stack.caller != nil ||
+		proof.stackIdentity != stack.normalized || proof.countedIterations != stack.countedIterations {
+		return fail()
+	}
+	function, err := x86CallerSourceFingerprint(fn)
+	if err != nil || function != proof.function || !reflect.DeepEqual(fn.Instrs, proof.normalized) {
+		return fail()
+	}
+	signature, err := x86CallerSourceFingerprint(sig)
+	if err != nil || signature != proof.signature || fn.x86RawReplay == nil ||
+		x86SourceStackScalarArch(fn.x86RawReplay.goarch) != x86SourceStackScalarArch(c.goarch) ||
+		fn.x86RawReplay.validate(fn, fn.x86RawReplay.goarch) != nil || !reflect.DeepEqual(fn.x86RawReplay.original, proof.original) {
+		return fail()
+	}
+	emitted := c.sig
+	if sig.Attrs == "" && emitted.Attrs == c.fpFeatureAttrs {
+		emitted.Attrs = "" // Only the renderer's separate, exact inference handoff.
+	}
+	if !reflect.DeepEqual(emitted, sig) {
+		return fail()
+	}
+	return nil
+}
diff --git a/x86_source_stack_scalar_result_test.go b/x86_source_stack_scalar_result_test.go
new file mode 100644
index 000000000..e0b226d21
--- /dev/null
+++ b/x86_source_stack_scalar_result_test.go
@@ -0,0 +1,288 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86SourceStackRuntimeDeclarations(arch string) string {
+	var declaration strings.Builder
+	for _, row := range x86SourceStackRuntimeCases(arch) {
+		fmt.Fprintf(&declaration, "func %s(x uint%d) uint%d\n", row.name, row.width, row.width)
+	}
+	declaration.WriteString("func PhysicalBool(x bool) bool\n")
+	declaration.WriteString("func PhysicalBoolIntermediate(x bool) bool\n")
+	declaration.WriteString("func PhysicalBoolNamedFP(x bool) bool\n")
+	return declaration.String()
+}
+
+// Share every original CI kernel, including its physical loads, frame-pointer
+// transport, private PUSH/POP, branch join and saved FLAGS. This object owner
+// cannot disappear merely because native x86 execution is inapplicable here.
+func TestX86PhysicalSourceStackScalarRuntimeSourceThreeAPIsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, _ := x86SourceStackRuntimeSource(target.arch)
+			declaration := x86SourceStackRuntimeDeclarations(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("complete physical source stack lost its independent numerical proof", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86PhysicalSourceStackScalarDoesNotInventDataOrStorage(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, suffix, typ, resultType := int64(8), "Q", "uint64", I64
+		if target.arch == "386" {
+			word, suffix, typ, resultType = 4, "L", "uint32", I32
+		}
+		read := "MOV" + suffix + " @WORD(SP),AX\n"
+		write := "MOV" + suffix + " AX,@RESULT(SP)\nBYTE $0xc3"
+		for _, row := range []struct{ name, body string }{
+			{"unknown-result", "MOV" + suffix + " BX,@RESULT(SP)\nBYTE $0xc3"},
+			{"partial-result", read + "MOVB AX,@RESULT(SP)\nBYTE $0xc3"},
+			{"unknown-wide-arithmetic", "MOVB @WORD(SP),AX\nADD" + suffix + " $7,AX\n" + write},
+			{"unknown-saved-data", "PUSH" + suffix + " BX\nPOP" + suffix + " AX\n" + write},
+			{"unknown-flags", read + "CMP" + suffix + " BX,$0\nJE done\ndone:\n" + write},
+			{"unknown-result-on-one-path", read + "CMP" + suffix + " AX,$0\nJE done\nMOV" + suffix + " AX,@RESULT(SP)\ndone:\nBYTE $0xc3"},
+			{"input-write", read + "MOV" + suffix + " AX,@WORD(SP)\n" + write},
+			{"return-pc-write", read + "MOV" + suffix + " AX,0(SP)\n" + write},
+			{"numerical-stack-address", "MOV" + suffix + " SP,AX\n" + write},
+			{"unknown-native-store", read + "MOV" + suffix + " AX,(BX)\n" + write},
+		} {
+			source, _, _ := x86SourceStackTypedFixture(target.arch, typ, resultType, word, "MOV"+suffix, row.body)
+			declaration := "func Value(x " + typ + ") " + typ
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatalf("physical storage created unrelated numerical/address facts: %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackScalarProofCannotBeRebound(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		source, sig, _ := x86SourceStackNumericalFixture(arch,
+			"@MOV @WORD(SP),AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3")
+		file, err := Parse(ArchAMD64, source)
+		if err != nil {
+			t.Fatal(err)
+		}
+		normalized, err := normalizeX86RawFile(file, arch, x86SourceStackOptions(arch, "", sig))
+		if err != nil {
+			t.Fatal(err)
+		}
+		original := normalized.Funcs[0]
+		if original.x86SourceStack == nil || original.x86SourceStack.scalarResult == nil {
+			t.Fatal("complete physical scalar source did not produce its own numerical proof")
+		}
+		for _, change := range []string{"none", "source", "access", "signature", "emitted signature", "copied owner"} {
+			t.Run(arch+"/"+change, func(t *testing.T) {
+				fn := original
+				fn.Instrs = cloneX86ReplayInstrs(original.Instrs)
+				signatures, err := cloneFixedLocalSigs(map[string]FuncSig{sig.Name: sig})
+				if err != nil {
+					t.Fatal(err)
+				}
+				consumer := &amd64Ctx{sig: sig, fpSourceSig: signatures[sig.Name], fpScalarSource: fn,
+					sourceStack: fn.x86SourceStack, goarch: arch}
+				switch change {
+				case "source":
+					consumer.fpScalarSource.Instrs[1].Raw = "MOVL $0,AX"
+				case "access":
+					consumer.fpScalarSource.Instrs[1].x86SourceStackFP[0]++
+				case "signature":
+					consumer.fpSourceSig.Frame.Results[0].Offset++
+				case "emitted signature":
+					consumer.sig.Ret = I8
+				case "copied owner":
+					copy := *consumer.sourceStack
+					consumer.sourceStack = &copy
+					consumer.fpScalarSource.x86SourceStack = &copy
+				}
+				err = consumer.checkSourceStackScalarResultInitialization()
+				if change == "none" && err != nil || change != "none" && !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatalf("physical scalar proof rebound by %s: %v", change, err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86PhysicalSourceStackScalarJoinOnlyIntersectsFacts(t *testing.T) {
+	source, sig, _ := x86SourceStackNumericalFixture("amd64",
+		"@MOV @WORD(SP),AX\n@MOV AX,@RESULT(SP)\nBYTE $0xc3")
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	initial := x86SourceStackScalarInitial(file.Funcs[0], sig, "amd64")
+	if initial == nil {
+		t.Fatal("complete scalar declaration rejected")
+	}
+	left := x86SourceStackState{sp: -8, bp: x86SourceStackAddress{original: true}, gOriginal: true,
+		scalarResult: initial, numericFlags: true,
+		cells: []x86SourceStackCell{{offset: -8, width: 8, flags: true, known: 0x3f,
+			canonical: 0x0f, scalarFlags: x86ByteFlagsAll, numericFlags: true}}}
+	right := left
+	right.scalarResult = initial.clone()
+	right.cells = append([]x86SourceStackCell(nil), left.cells...)
+	left.scalarResult.bytes.gp[0], right.scalarResult.bytes.gp[0] = 0x0f, 0xf0
+	left.scalarResult.bytes.flags, right.scalarResult.bytes.flags = x86ByteFlagsAll, x86ByteFlagCF
+	right.numericFlags, right.partialNumericFlags = false, x86ByteFlagCF
+	right.cells[0].known, right.cells[0].canonical = 0xf3, 0x03
+	right.cells[0].scalarFlags = x86ByteFlagCF
+	right.cells[0].numericFlags, right.cells[0].partialNumericFlags = false, x86ByteFlagCF
+	merged, valid := x86SourceStackScalarMerge(left, right)
+	if !valid || merged.scalarResult.bytes.gp[0] != 0 || merged.scalarResult.bytes.flags != x86ByteFlagCF ||
+		merged.cells[0].known != 0x33 || merged.cells[0].canonical != 0x03 || merged.cells[0].scalarFlags != x86ByteFlagCF ||
+		x86SourceStackNumericFlagMask(&merged) != x86ByteFlagCF || merged.cells[0].numericFlags ||
+		merged.cells[0].partialNumericFlags != x86ByteFlagCF {
+		t.Fatal("scalar join invented numerical/canonical/FLAGS knowledge")
+	}
+	merged.scalarResult.bytes.fp[0], merged.cells[0].known = false, 0xff
+	if !left.scalarResult.bytes.fp[0] || !right.scalarResult.bytes.fp[0] || left.cells[0].known != 0x3f || right.cells[0].known != 0xf3 {
+		t.Fatal("scalar join mutated a predecessor")
+	}
+	for _, change := range []string{"SP", "BP", "cell offset", "cell width", "opaque BP", "layout", "caller"} {
+		t.Run(change, func(t *testing.T) {
+			other := right
+			other.cells = append([]x86SourceStackCell(nil), right.cells...)
+			other.scalarResult = right.scalarResult.clone()
+			switch change {
+			case "SP":
+				other.sp--
+			case "BP":
+				other.bp.original = false
+			case "cell offset":
+				other.cells[0].offset--
+			case "cell width":
+				other.cells[0].width = 2
+			case "opaque BP":
+				other.cells[0].bp = &x86SourceStackAddress{original: true}
+			case "layout":
+				other.scalarResult.width--
+			case "caller":
+				other.callers = map[Reg]x86CallerPointerValue{}
+			}
+			if _, valid := x86SourceStackScalarMerge(left, other); valid {
+				t.Fatal("physical or foreign role merged as scalar bytes")
+			}
+		})
+	}
+}
+
+// Execute the complete kernels whose source word matches the host pointer.
+// Unlike pure GP arithmetic, physical MOVL SP,BP cannot carry a 64-bit host
+// address. Both source widths retain their five-target objects above and their
+// required original-Go/LLVM Linux AMD64/i386 execution owner, without skips here.
+func TestX86PhysicalSourceStackScalarPortableCompleteRuntimeSource(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	source, _ := x86SourceStackRuntimeSource(arch)
+	var adapters, declarations, checks strings.Builder
+	for _, row := range x86SourceStackRuntimeCases(arch) {
+		x86SourceStackPortableAdapter(&adapters, row.name, row.width)
+		fmt.Fprintf(&declarations, "extern uint64_t %sPortable(uint64_t);\n", row.name)
+		fmt.Fprintf(&checks, `    {
+        const uint64_t mask=UINT64_MAX >> %d;
+        const uint64_t value=input & mask;
+        uint64_t want=value+7;
+`, 64-row.width)
+		if row.flags {
+			checks.WriteString("        if (value==0) want++;\n")
+		}
+		if row.name == "WordImmediate" {
+			checks.WriteString("        want=((value & ~UINT64_C(65535)) | 65530)+7;\n")
+		}
+		fmt.Fprintf(&checks, `        uint64_t got=%sPortable(input);
+        if (got!=(want & mask)) {
+            fprintf(stderr,"%s input=%%llx got=%%llx want=%%llx\n",
+                (unsigned long long)input,(unsigned long long)got,(unsigned long long)(want & mask));
+            return 1;
+        }
+    }
+`, row.name, row.name)
+	}
+	for _, name := range []string{"PhysicalBool", "PhysicalBoolIntermediate", "PhysicalBoolNamedFP"} {
+		x86SourceStackPortableAdapter(&adapters, name, 1)
+		fmt.Fprintf(&declarations, "extern uint64_t %sPortable(uint64_t);\n", name)
+	}
+	const body = `int main(void) {
+    const uint64_t inputs[]={0,1,17,253,249,UINT64_C(65530),UINT64_C(0xfffffffc),UINT64_MAX-3};
+    for (unsigned index=0;index<sizeof(inputs)/sizeof(inputs[0]);++index) {
+        const uint64_t input=inputs[index];
+        volatile uint64_t canary[4]={11,23,37,41};
+%s
+        if (PhysicalBoolPortable(input)!=(input & 1) || PhysicalBoolIntermediatePortable(input)!=1 ||
+            PhysicalBoolNamedFPPortable(input)!=1 || canary[0]!=11 || canary[1]!=23 || canary[2]!=37 || canary[3]!=41) {
+            fprintf(stderr,"physical bool/canary input=%%llx\n",(unsigned long long)input);
+            return 1;
+        }
+    }
+    return 0;
+}
+`
+	driver := "#include <stdint.h>\n#include <stdio.h>\n" + declarations.String() + fmt.Sprintf(body, checks.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(arch+"/"+api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, x86SourceStackRuntimeDeclarations(arch), arch, triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ir += adapters.String()
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "source-stack-scalar-values", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
+
+func x86SourceStackPortableAdapter(out *strings.Builder, name string, bits int) {
+	fmt.Fprintf(out, "define i64 @%sPortable(i64 %%input) {\n", name)
+	value := "%input"
+	if bits != 64 {
+		fmt.Fprintf(out, "    %%argument = trunc i64 %%input to i%d\n", bits)
+		value = "%argument"
+	}
+	fmt.Fprintf(out, "    %%value = call i%d @%s(i%d %s)\n", bits, name, bits, value)
+	value = "%value"
+	if bits != 64 {
+		fmt.Fprintf(out, "    %%result = zext i%d %%value to i64\n", bits)
+		value = "%result"
+	}
+	fmt.Fprintf(out, "    ret i64 %s\n}\n", value)
+}
diff --git a/x86_sqrt_caller_test.go b/x86_sqrt_caller_test.go
new file mode 100644
index 000000000..39f97cd90
--- /dev/null
+++ b/x86_sqrt_caller_test.go
@@ -0,0 +1,106 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86SqrtCallerInputAndAliasContract(t *testing.T) {
+	for _, row := range x86SqrtInputRows("amd64") {
+		if strings.Contains(row, "(AX)") {
+			continue
+		}
+		t.Run(row, func(t *testing.T) {
+			ins := x86ScalarLaneInstruction(t, row)
+			for _, missing := range []string{"none", "input", "upper", "destination", "mask"} {
+				state := x86SourceStackState{vectors: map[Reg]uint64{
+					"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+				switch missing {
+				case "input":
+					state.vectors["Z0"] &^= 1
+				case "upper":
+					state.vectors["Z1"] = 0
+				case "destination":
+					state.vectors["Z2"] = 0
+				case "mask":
+					state.masks["K1"] = false
+				}
+				before, masks := x86CloneCallerVectorState(state.vectors, state.masks)
+				want := missing != "input" && (missing != "mask" || !strings.Contains(row, "K1")) &&
+					(missing != "destination" || !strings.Contains(row, "K1") || strings.Contains(row, ".Z"))
+				accepted := x86CallerVectorMoveStep(&ins, &state, nil)
+				if accepted != want || !reflect.DeepEqual(state.masks, masks) || !want && !reflect.DeepEqual(state.vectors, before) {
+					t.Fatal("caller source or mask contract", missing, accepted, want)
+				}
+				if want && missing == "upper" && (strings.HasPrefix(row, "VSQRTSS") || strings.HasPrefix(row, "VSQRTSD")) {
+					low := uint64(0xf)
+					if strings.HasPrefix(row, "VSQRTSD") {
+						low = 0xff
+					}
+					if state.vectors["Z2"] != ^uint64(0xffff)|low {
+						t.Fatal("caller invented scalar passthrough bytes")
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86SqrtCallerCompleteSource(t *testing.T) {
+	for _, op := range []string{"SQRTSS", "SQRTSD", "SQRTPS", "SQRTPD", "VSQRTSS", "VSQRTSD", "VSQRTPS", "VSQRTPD"} {
+		t.Run(op, func(t *testing.T) {
+			args := "X0,X2"
+			if op == "VSQRTSS" || op == "VSQRTSD" {
+				args = "X0,X1,X2"
+			}
+			body := fmt.Sprintf("MOVQ (CX),AX\nCMPQ AX,$4\nJL short\nVMOVUPS (DI),X0\nVPXORD Z1,Z1,Z1\n%s %s\nMOVSS X2,(DX)\nJMP done\nshort:\nMOVL $0,(DX)\ndone:\n", op, args)
+			assembly := strings.Replace(x86CallerFixtureAssembly, "MOVL AX,(DX)", body, 1)
+			goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+			pkg, _ := x86CallerCoreFixture(t, x86CallerFixtureSource, assembly)
+			if err := x86CallerCoreTranslate(t, pkg, assembly, "x86_64-unknown-linux-gnu"); err != nil {
+				t.Fatal("complete source-bound sqrt caller rejected", err)
+			}
+		})
+	}
+}
+
+func TestX86SqrtMemoryShapesAndCallerBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86SqrtInputRows(arch) {
+			if !strings.Contains(row, "(AX)") {
+				continue
+			}
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				want := int64(16)
+				if strings.HasSuffix(row, "Y2") {
+					want = 32
+				} else if strings.HasSuffix(row, "Z2") {
+					want = 64
+				}
+				op := strings.Fields(row)[0]
+				if strings.HasPrefix(op, "SQRTSS") || strings.HasPrefix(op, "VSQRTSS") || strings.Contains(op, "BCST") {
+					want = 4
+					if strings.HasPrefix(op, "VSQRTPD") {
+						want = 8
+					}
+				} else if strings.HasPrefix(op, "SQRTSD") || strings.HasPrefix(op, "VSQRTSD") {
+					want = 8
+				}
+				for index := -1; index <= len(ins.Args); index++ {
+					width, write, valid := x86InstructionMemoryShape(ins, index, arch)
+					if valid != (index == 0) || valid && (width != want || write) {
+						t.Fatal("source tuple differs", index, width, write, valid, want)
+					}
+				}
+				// Numerical and mask inputs do not supply caller pointer backing.
+				state := x86SourceStackState{vectors: map[Reg]uint64{"Z0": ^uint64(0), "Z1": ^uint64(0), "Z2": ^uint64(0)}, masks: map[Reg]bool{"K1": true}}
+				if x86CallerVectorMoveStep(&ins, &state, &x86GoCallerRegionProof{}) {
+					t.Fatal("sqrt invented a caller-memory region")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_sqrt_contract_test.go b/x86_sqrt_contract_test.go
new file mode 100644
index 000000000..32a0fd17e
--- /dev/null
+++ b/x86_sqrt_contract_test.go
@@ -0,0 +1,136 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Preserve every original Go row and every public Context check. The named
+// 386 high banks have no physical binding: retain those exact rows as Context,
+// not as objects using a fictitious software register. All remaining original
+// rows still receive direct-emitter objects; initialized public five-target
+// programs live in TestX86SqrtInitializedFiveTargetObjects.
+func x86SqrtOriginalFormatObjects(t *testing.T, source, name, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	local := *file
+	local.Funcs = append([]Func(nil), file.Funcs...)
+	local.Funcs[0].Instrs = nil
+	contextRows := 0
+	for _, ins := range file.Funcs[0].Instrs {
+		if _, known, err := x86SqrtProperties(ins, arch); known && err != nil {
+			if arch != "386" || !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("original Go row became malformed", ins.Raw, err)
+			}
+			contextRows++
+			continue
+		}
+		local.Funcs[0].Instrs = append(local.Funcs[0].Instrs, ins)
+	}
+	if arch == "386" && contextRows == 0 || arch == "amd64" && contextRows != 0 {
+		t.Fatal("original physical-bank Context partition changed", arch, contextRows)
+	}
+	t.Logf("original source retained; %d unbound mode32 register rows remain Context", contextRows)
+	return x86ScalarFormatObjectUnit(t, &local, signatures, arch, triple, 0)
+}
+
+func TestX86SqrtEveryInputByteAndUpperAlias(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86SqrtInputRows(arch) {
+			if strings.Contains(row, "(AX)") {
+				continue // Native inputs have separate address and access tests.
+			}
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				base := strings.Split(string(ins.Op), ".")[0]
+				legacy := !strings.HasPrefix(base, "V")
+				scalar := strings.HasSuffix(base, "SS") || strings.HasSuffix(base, "SD")
+				width := 16
+				if strings.HasSuffix(row, "Y2") {
+					width = 32
+				} else if strings.HasSuffix(row, "Z2") {
+					width = 64
+				}
+				input := width
+				if scalar {
+					input = 4
+					if strings.HasSuffix(base, "SD") {
+						input = 8
+					}
+				}
+				required := x86CallerVectorByteMask(int64(input))
+				for missing := -1; missing < 192; missing++ {
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+					state.gp[5], state.pointerGP[7], state.callerAddressGP[7], state.masks[1] = 0x53, true, true, true
+					for register := 0; register < 3; register++ {
+						state.xmm[register], state.vectorUpper[register] = 0xffff, ^uint64(0xffff)
+					}
+					want := true
+					if missing >= 0 {
+						register, bit := missing/64, uint(missing%64)
+						value := state.vectorBytes(register) &^ (uint64(1) << bit)
+						state.xmm[register], state.vectorUpper[register] = uint16(value), value&^0xffff
+						want = !(register == 0 && int(bit) < input || register == 2 && int(bit) < input &&
+							strings.Contains(row, "K1") && !strings.Contains(row, ".Z"))
+					}
+					before := state.clone()
+					accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+					if accepted != want {
+						t.Fatalf("missing byte %d: accepted=%t want=%t", missing, accepted, want)
+					}
+					if want {
+						value := required
+						if legacy && scalar {
+							value |= before.vectorBytes(2)
+						} else if scalar {
+							value |= before.vectorBytes(1) & (0xffff &^ required)
+						}
+						before.writeVector(2, width, value, legacy)
+					}
+					if !reflect.DeepEqual(state, before) {
+						t.Fatalf("missing byte %d changed unrelated state or invented copied upper bytes", missing)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SqrtLogicalFieldBoundsAndAddressIdentity(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word := "Q"
+		if target.arch == "386" {
+			word = "L"
+		}
+		for _, body := range []string{
+			"LEA%s x+1(FP),AX\nSQRTSS (AX),X0",
+			"LEA%s x+0(FP),AX\nSQRTSD (AX),X0",
+			"LEA%s ret+RESULT(FP),AX\nSQRTSS (AX),X0",
+			"LEA%s x+0(FP),AX\nMOVL $0,AX\nSQRTSS (AX),X0",
+			"LEA%s x+0(FP),AX\nMOVL $0,CX\nSQRTSS (AX)(CX*1),X0",
+			"LEA%s x+0(FP),AX\nSQRTPS (AX),X0",
+		} {
+			t.Run(target.triple+"/"+body, func(t *testing.T) {
+				declaration := "func view(x float32) float32"
+				source := x86ResultGPSIMDAdmissionSource(t, target.arch, declaration,
+					fmt.Sprintf(body, word)+"\nMOVSS X0,ret+RESULT(FP)")
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if body == "LEA%s x+0(FP),AX\nMOVL $0,AX\nSQRTSS (AX),X0" {
+						x86RequireNumericNativeSourceContext(t, source, declaration, target.arch)
+						if err != nil || x86FMA3PortableVolatileBytes(t, ir) != 4 || !strings.Contains(ir, "asm sideeffect \"sqrtss ") || !strings.Contains(ir, "~{fpsr}") {
+							t.Fatal("explicit numerical overwrite lost its native m32 SQRTSS effect", err)
+						}
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("logical sqrt read escaped its exact declared field", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_sqrt_encoder_test.go b/x86_sqrt_encoder_test.go
new file mode 100644
index 000000000..bc74e5381
--- /dev/null
+++ b/x86_sqrt_encoder_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86SqrtIndependentEncoderAttributes(t *testing.T) {
+	legacy, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"{ASQRTPS, yxm, Pm, opBytes{0x51}}", "{ASQRTPD, yxm, Pe, opBytes{0x51}}",
+		"{ASQRTSS, yxm, Pf3, opBytes{0x51}}", "{ASQRTSD, yxm, Pf2, opBytes{0x51}}",
+	} {
+		if !strings.Contains(string(legacy), row) {
+			t.Fatal("original Go legacy SQRT encoding changed", row)
+		}
+	}
+	start := strings.Index(string(legacy), "var yxm = []ytab{")
+	if start < 0 || strings.SplitN(string(legacy)[start:], "\n}", 2)[0] !=
+		"var yxm = []ytab{\n\t{Zm_r_xm, 1, argList{Yxm, Yxr}}," {
+		t.Fatal("original Go complete yxm operand table changed")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, suffix := range []string{"PS", "PD", "SS", "SD"} {
+		op, table := "VSQRT"+suffix, "_yvcvtdq2ps"
+		scalar := strings.HasPrefix(suffix, "S")
+		prefix, bits, w := "", 32, 0
+		if strings.HasSuffix(suffix, "D") {
+			prefix, bits, w = "66", 64, 1
+		}
+		if scalar {
+			table, prefix = "_yvaddsd", "F3"
+			if bits == 64 {
+				prefix = "F2"
+			}
+		}
+		var expected []goasmrules.X86AVXRule
+		var encoding []string
+		offset := 0
+		add := func(zcase string, advance int, classes string) {
+			expected = append(expected, goasmrules.X86AVXRule{Opcode: op, Ytab: table, Prefix: "Pavx",
+				Classes: strings.Split(classes, ","), RowIndex: len(expected), ZCase: zcase,
+				ZOffset: advance, EncodingOffset: offset})
+			offset += advance
+		}
+		vexWidths, evexWidths := []int{128, 256}, []int{512, 128, 256}
+		if scalar {
+			vexWidths, evexWidths = []int{128}, []int{128}
+		}
+		pp := func(generation string) string {
+			if prefix == "" {
+				return ""
+			}
+			return " | " + generation + prefix
+		}
+		for _, width := range vexWidths {
+			bank := map[int]string{128: "x", 256: "y"}[width]
+			classes := "Y" + bank + "m,Y" + bank + "r"
+			if scalar {
+				classes += ",Yxr"
+			}
+			add("Zvex_rm_v_r", 2, classes)
+			encoding = append(encoding, fmt.Sprintf("avxEscape | vex%d%s | vex0F | vexW0", width, pp("vex")), "0x51")
+		}
+		for _, width := range evexWidths {
+			bank := map[int]string{128: "x", 256: "y", 512: "z"}[width]
+			memory, register := "Y"+bank+"mEvex", "Y"+bank+"rEvex"
+			if bank == "z" {
+				memory, register = "Yzm", "Yzr"
+			}
+			classes, masked := memory+","+register, memory+",Yknot0,"+register
+			zcase := "Zevex_rm_k_r"
+			attributes := fmt.Sprintf("evexN%d | evexBcstN%d", width/8, bits/8)
+			if scalar {
+				classes, masked = memory+","+register+","+register, memory+","+register+",Yknot0,"+register
+				zcase, attributes = "Zevex_rm_v_k_r", fmt.Sprintf("evexN%d", bits/8)
+			}
+			if scalar || width == 512 {
+				attributes += " | evexRoundingEnabled"
+			}
+			attributes += " | evexZeroingEnabled"
+			add("Zevex_rm_v_r", 0, classes)
+			add(zcase, 3, masked)
+			encoding = append(encoding, fmt.Sprintf("avxEscape | evex%d%s | evex0F | evexW%d", width, pp("evex"), w), attributes, "0x51")
+		}
+		for index := range expected {
+			expected[index].OpBytes = encoding
+		}
+		var actual []goasmrules.X86AVXRule
+		for _, rule := range rules {
+			if rule.Opcode == op {
+				actual = append(actual, rule)
+			}
+		}
+		if !reflect.DeepEqual(actual, expected) {
+			t.Fatalf("%s complete original Go encoding rows changed:\ngot %+v\nwant %+v", op, actual, expected)
+		}
+	}
+}
diff --git a/x86_sqrt_feature_test.go b/x86_sqrt_feature_test.go
new file mode 100644
index 000000000..61f9d8461
--- /dev/null
+++ b/x86_sqrt_feature_test.go
@@ -0,0 +1,41 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86SqrtIsolatedNativeFeatures(t *testing.T) {
+	for _, arch := range []string{"", "amd64", "386"} {
+		for _, row := range x86SqrtInputRows("amd64") {
+			if arch == "386" && len(strings.Split(strings.SplitN(row, " ", 2)[1], ",")) == 4 {
+				continue // No named mode32 four-operand spelling.
+			}
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT f(SB),4,$0-0\n"+row+"\nRET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				base := strings.SplitN(row, " ", 2)[0]
+				features := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0])
+				want := []string{"+sse"}
+				if strings.HasPrefix(base, "V") {
+					want = []string{"+avx"}
+					if strings.Contains(row, "Z2") || strings.Contains(row, "K1") || strings.Contains(base, ".") {
+						want = []string{"+avx512f"}
+						if !strings.Contains(row, "Z2") && (strings.HasPrefix(base, "VSQRTPS") || strings.HasPrefix(base, "VSQRTPD")) {
+							want = append(want, "+avx512vl")
+						}
+					}
+				} else if strings.HasSuffix(base, "SD") || strings.HasSuffix(base, "PD") {
+					want = []string{"+sse2"}
+				}
+				for _, feature := range want {
+					if !strings.Contains(","+features+",", ","+feature+",") {
+						t.Fatalf("isolated opcode lacks its own native register class %s: %s", feature, features)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_sqrt_raw_contract_test.go b/x86_sqrt_raw_contract_test.go
new file mode 100644
index 000000000..465c578c4
--- /dev/null
+++ b/x86_sqrt_raw_contract_test.go
@@ -0,0 +1,153 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os/exec"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Intel SDM Vol. 2B SQRTPS/PD/SS/SD: VEX.WIG, scalar EVEX.LIG,
+// packed EVEX.W0/W1, and physical low-bank masking in both modes.
+// Go emits canonical W/L bits, so its named tables cannot witness WIG/LIG.
+// https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-vol-2b-manual.pdf
+func TestX86SqrtRawPhysicalForms(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM 22 llvm-mc required")
+	}
+	for pp, name := range []string{"VSQRTPS", "VSQRTPD", "VSQRTSS", "VSQRTSD"} {
+		for _, mode := range []int{32, 64} {
+			decode := decodedX86SameWidthConversionInstruction
+			arch, triple := "amd64", "x86_64-unknown-linux-gnu"
+			if mode == 32 {
+				arch, triple = "386", "i386-unknown-linux-gnu"
+			}
+			if pp >= 2 {
+				decode = decodedX86VEXBinaryFloatInstruction
+			}
+			check := func(t *testing.T, code []byte, evex bool) Instr {
+				t.Helper()
+				var input strings.Builder
+				for _, value := range code {
+					fmt.Fprintf(&input, "0x%02x ", value)
+				}
+				input.WriteByte('\n')
+				ctx, cancel := runtimeOracleStageContext(t)
+				defer cancel()
+				command := exec.CommandContext(ctx, mc, "-triple="+triple, "-disassemble", "-mattr=+avx,+avx512f,+avx512vl")
+				command.Stdin = strings.NewReader(input.String())
+				output, err := runtimeOracleCombinedOutput(ctx, command)
+				if err != nil || strings.Contains(string(output), "warning") || strings.Count(string(output), strings.ToLower(name)) != 1 {
+					t.Fatalf("independent LLVM decoding of %x: %v\n%s", code, err, output)
+				}
+				ins, length, known, err := decode(code, mode)
+				if !known || err != nil || length != len(code) {
+					t.Fatalf("physical SQRT %x rejected: %v", code, err)
+				}
+				form, known, err := x86SqrtProperties(ins, arch)
+				if !known || err != nil {
+					t.Fatal("decoder/typed grammar disagree", err)
+				}
+				if x86SqrtNativeEVEX(ins, form) != evex {
+					t.Fatal("physical encoding generation lost", ins.Raw)
+				}
+				return ins
+			}
+			for _, wide := range []bool{false, true} {
+				if pp >= 2 && wide {
+					continue // Intel documents VEX.L=1 scalar behavior as unpredictable.
+				}
+				t.Run(fmt.Sprintf("%s/%d/VEX/wide%t", name, mode, wide), func(t *testing.T) {
+					code := []byte{0xc4, 0xe1, 0x78 | byte(pp), 0x51, 0xd1}
+					if pp >= 2 {
+						code[2], code[4] = 0x68|byte(pp), 0xd9
+					}
+					if wide {
+						code[2] |= 4
+					}
+					control := check(t, code, false)
+					code[2] |= 0x80
+					actual := check(t, code, false)
+					if actual.Op != control.Op || !reflect.DeepEqual(actual.Args, control.Args) {
+						t.Fatal("WIG changed operands")
+					}
+				})
+			}
+			for length := byte(0); length < 4; length++ {
+				if pp < 2 && length == 3 {
+					continue // Packed LL=3 remains reserved without embedded rounding.
+				}
+				for _, mask := range []byte{0, 1, 0x81} {
+					for _, memory := range []bool{false, true} {
+						t.Run(fmt.Sprintf("%s/%d/EVEX/LL%d/mask%x/memory%t", name, mode, length, mask, memory), func(t *testing.T) {
+							code := []byte{0x62, 0xf1, 0x7c | byte(pp), 0x08 | length<<5 | mask, 0x51, 0xd1}
+							if pp >= 2 {
+								code[2], code[5] = 0x6c|byte(pp), 0xd9
+								if memory {
+									code[5] = 0x18 // (AX), upper X2, destination X3.
+								}
+							} else if memory {
+								code[5] = 0x10 // (AX), destination X/Y/Z2.
+							}
+							if pp&1 != 0 {
+								code[2] |= 0x80
+							}
+							check(t, code, true)
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86SqrtRawReservedFieldsStayRejected(t *testing.T) {
+	for pp := byte(0); pp < 4; pp++ {
+		for _, mode := range []int{32, 64} {
+			decode := decodedX86SameWidthConversionInstruction
+			code := []byte{0x62, 0xf1, 0x7c | pp, 0x08, 0x51, 0xd1}
+			if pp >= 2 {
+				decode = decodedX86VEXBinaryFloatInstruction
+				code[2], code[5] = 0x6c|pp, 0xd9
+			}
+			if pp&1 != 0 {
+				code[2] |= 0x80
+			}
+			mutations := map[string]func([]byte){
+				"wrong-W":      func(b []byte) { b[2] ^= 0x80 },
+				"fixed-bit":    func(b []byte) { b[2] &^= 4 },
+				"zero-no-mask": func(b []byte) { b[3] |= 0x80 },
+			}
+			if pp < 2 {
+				mutations["packed-LL3"] = func(b []byte) { b[3] |= 0x60 }
+				mutations["packed-vvvv"] = func(b []byte) { b[2] &^= 8 }
+			} else {
+				mutations["scalar-broadcast"] = func(b []byte) { b[3] |= 0x10; b[5] = 0x18 }
+			}
+			if mode == 32 {
+				mutations["high-bank"] = func(b []byte) { b[1] &^= 0x10 }
+			}
+			for name, edit := range mutations {
+				t.Run(fmt.Sprintf("pp%d/mode%d/%s", pp, mode, name), func(t *testing.T) {
+					changed := append([]byte(nil), code...)
+					edit(changed)
+					if _, _, known, err := decode(changed, mode); !known || err == nil {
+						t.Fatal("reserved encoding acquired semantics", changed, known, err)
+					}
+				})
+			}
+			for length := 0; length < len(code); length++ {
+				if _, _, known, err := decode(code[:length], mode); known && err == nil {
+					t.Fatal("truncated encoding accepted", code[:length])
+				}
+			}
+			if pp >= 2 {
+				if _, _, known, err := decode([]byte{0xc4, 0xe1, 0x6c | pp, 0x51, 0xd9}, mode); !known || err == nil {
+					t.Fatal("unpredictable scalar VEX.L1 acquired L0 semantics")
+				}
+			}
+		}
+	}
+}
diff --git a/x86_sqrt_raw_objects_test.go b/x86_sqrt_raw_objects_test.go
new file mode 100644
index 000000000..bb1170a83
--- /dev/null
+++ b/x86_sqrt_raw_objects_test.go
@@ -0,0 +1,78 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86SqrtInitializedRawFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	var codes [][]byte
+	for pp := byte(0); pp < 4; pp++ {
+		for length := byte(0); length < 2; length++ {
+			if pp >= 2 && length != 0 {
+				continue
+			}
+			for w := byte(0); w < 2; w++ {
+				code := []byte{0xc4, 0xe1, 0x78 | pp | length<<2 | w<<7, 0x51, 0xd1}
+				if pp >= 2 {
+					code[2], code[4] = 0x68|pp|w<<7, 0xd9
+				}
+				codes = append(codes, code)
+			}
+		}
+		for length := byte(0); length < 4; length++ {
+			if pp < 2 && length == 3 {
+				continue
+			}
+			for _, mask := range []byte{0, 1, 0x81} {
+				code := []byte{0x62, 0xf1, 0x7c | pp, 0x08 | length<<5 | mask, 0x51, 0xd1}
+				if pp >= 2 {
+					code[2], code[5] = 0x6c|pp, 0xd9
+				}
+				if pp&1 != 0 {
+					code[2] |= 0x80
+				}
+				codes = append(codes, code)
+			}
+		}
+	}
+	if len(codes) != 54 {
+		t.Fatal("physical sqrt fixture inventory changed", len(codes))
+	}
+	var source, declarations strings.Builder
+	for index, code := range codes {
+		fmt.Fprintf(&source, "TEXT ·RawSqrt%d(SB),4,$0\nMOVL $1,AX\nKMOVD AX,K1\n", index)
+		for register := 0; register < 4; register++ {
+			fmt.Fprintf(&source, "VPXORD Z%d,Z%d,Z%d\n", register, register, register)
+		}
+		for _, value := range code {
+			fmt.Fprintf(&source, "BYTE $0x%02x\n", value)
+		}
+		source.WriteString("RET\n")
+		fmt.Fprintf(&declarations, "func RawSqrt%d()\n", index)
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized physical sqrt source rejected", api, err)
+				}
+				if strings.Count(ir, "{evex} vsqrt") != 42 {
+					t.Fatal("physical EVEX generation lost in actual emission", api)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_sqrt_runtime_linux_amd64_test.go b/x86_sqrt_runtime_linux_amd64_test.go
new file mode 100644
index 000000000..70b93d882
--- /dev/null
+++ b/x86_sqrt_runtime_linux_amd64_test.go
@@ -0,0 +1,9 @@
+//go:build linux && amd64 && plan9asm_native_avx512
+
+package plan9asm
+
+import "testing"
+
+func TestCrossLinuxRuntimeMatrixX86ScalarSqrtNativeSemantics(t *testing.T) {
+	x86ScalarSqrtNativeRuntime(t)
+}
diff --git a/x86_sqrt_value_inputs_test.go b/x86_sqrt_value_inputs_test.go
new file mode 100644
index 000000000..bdf2dd861
--- /dev/null
+++ b/x86_sqrt_value_inputs_test.go
@@ -0,0 +1,139 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// Independent syntax axes from Go's yxm, _yvaddsd and _yvcvtdq2ps tables.
+// Scalar VEX/EVEX has a separate upper-lane source; packed sqrt is unary.
+func x86SqrtInputRows(arch string) []string {
+	var rows []string
+	for _, opcode := range []string{"SQRTSS", "SQRTSD", "SQRTPS", "SQRTPD", "VSQRTSS", "VSQRTSD", "VSQRTPS", "VSQRTPD"} {
+		vector := strings.HasPrefix(opcode, "V")
+		scalar := strings.HasSuffix(opcode, "SS") || strings.HasSuffix(opcode, "SD")
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if (!vector || scalar) && bank != "X" {
+				continue
+			}
+			for _, memory := range []bool{false, true} {
+				for _, control := range []string{"", "BCST", "RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+					if control != "" && !vector || control == "BCST" && (!memory || scalar) ||
+						strings.HasSuffix(control, "SAE") && (memory || !scalar && bank != "Z") {
+						continue
+					}
+					for _, mode := range []string{"plain", "merge", "zero"} {
+						if mode != "plain" && (!vector || scalar && arch == "386") {
+							continue
+						}
+						name, first := opcode, bank+"0"
+						if control != "" {
+							name += "." + control
+						}
+						if mode == "zero" {
+							name += ".Z"
+						}
+						if memory {
+							first = "(AX)"
+						}
+						args := first
+						if vector && scalar {
+							args += ",X1"
+						}
+						if mode != "plain" {
+							args += ",K1"
+						}
+						rows = append(rows, name+" "+args+","+bank+"2")
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func TestX86SqrtUnknownVoidInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, instruction := range x86SqrtInputRows(arch) {
+			t.Run(arch+"/"+instruction, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0\n" + instruction + "\nRET\n"
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", arch, triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead sqrt invented numerical inputs or an address", api, err)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86SqrtInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := int(goWordSize(target.arch)), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			for index, instruction := range x86SqrtInputRows(target.arch) {
+				name := fmt.Sprintf("Sqrt%d", index)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte,mask uintptr) uint32\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\nKMOVD CX,K1\n"+
+					"VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\nPEXTRD $0,X2,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+					name, 2*word+4, move, move, word, instruction, 2*word)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("initialized sqrt lacks a numerical continuation", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86SqrtDeadResultsRetainMXCSREffects(t *testing.T) {
+	// Default-rounding sqrt can change MXCSR even when its result is dead.
+	// Intel SDM Vol. 2B, SQRTPS/PD/SS/SD; explicit SAE is a distinct form.
+	observable := regexp.MustCompile(`(?m)call[^\n]*(asm sideeffect[^\n]*sqrt|@llvm\.experimental\.constrained\.sqrt)`)
+	for _, opcode := range []string{"SQRTSS", "SQRTSD", "SQRTPS", "SQRTPD", "VSQRTSS", "VSQRTSD", "VSQRTPS", "VSQRTPD"} {
+		instruction := opcode + " X0,X2"
+		if opcode == "VSQRTSS" || opcode == "VSQRTSD" {
+			instruction = opcode + " X0,X1,X2"
+		}
+		source := "TEXT ·Value(SB),4,$0-8\nMOVQ p+0(FP),AX\nVMOVUPS (AX),Z0\nVPXORD Z1,Z1,Z1\n" + instruction + "\nRET\n"
+		t.Run(opcode, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[64]byte)", "amd64", "x86_64-unknown-linux-gnu", api)
+				if err != nil {
+					t.Fatal("complete native sqrt input rejected", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					if !observable.MatchString(text) {
+						t.Fatal("dead sqrt lost its original floating-point environment effects", api)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_stack_fixture_contract_test.go b/x86_stack_fixture_contract_test.go
new file mode 100644
index 000000000..eb73d1e07
--- /dev/null
+++ b/x86_stack_fixture_contract_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This complete original fixture is rejected by Go itself, not a successful
+// object or an invalid individual opcode. Require its precise ordinary exit
+// and diagnostic; infrastructure failures must never stand in for rejection.
+func x86OriginalUnbalancedStackGoRejection(t *testing.T, source, triple string) {
+	t.Helper()
+	dir := t.TempDir()
+	input, output := filepath.Join(dir, "stack.s"), filepath.Join(dir, "stack.o")
+	original := "#include \"textflag.h\"\n" + source
+	if err := os.WriteFile(input, []byte(original), 0600); err != nil {
+		t.Fatal(err)
+	}
+	goos := "linux"
+	if strings.Contains(triple, "windows") {
+		goos = "windows"
+	}
+	ctx, cancel := runtimeOracleStageContext(t)
+	defer cancel()
+	command := exec.CommandContext(ctx, "go", "tool", "asm", "-I", filepath.Join(runtime.GOROOT(), "pkg", "include"), "-o", output, input)
+	command.Env = append(os.Environ(), "GOOS="+goos, "GOARCH=386", "GOTOOLCHAIN=local")
+	diagnostic, err := runtimeOracleCombinedOutput(ctx, command)
+	exit, ordinary := err.(*exec.ExitError)
+	if ctx.Err() != nil || !ordinary || exit.ProcessState == nil || !exit.ProcessState.Exited() ||
+		exit.ExitCode() != 1 || string(diagnostic) != "asm: stack: unbalanced PUSH/POP\nasm: assembly failed\n" {
+		t.Fatalf("unknown original stack observation: %v; context=%v\n%s", err, ctx.Err(), diagnostic)
+	}
+	if data, err := os.ReadFile(input); err != nil || string(data) != original {
+		t.Fatal("original stack rejection source changed", err)
+	}
+}
+
+// Retain every instruction, original TEXT and original register return in the
+// old stack fixtures. These emitter-only objects establish no public source
+// contract for an entry POP or a stack pointer assigned from an unknown AX.
+func x86OriginalStackFormatObject(t *testing.T, function Func, result LLVMType, arch, triple string) string {
+	t.Helper()
+	if function.FrameSize != 0 || function.ArgSize != 0 || len(function.Instrs) < 2 {
+		t.Fatal("original stack format inventory changed")
+	}
+	sig := FuncSig{Name: "StackFormat", Ret: result}
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\ndefine %s @StackFormat() {\n", triple, result)
+	consumer := newX86Ctx(&ir, function, sig, func(name string) string { return name }, nil, arch, triple, false)
+	if err := consumer.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	if err := consumer.lowerBlocks(); err != nil {
+		t.Fatal("complete original stack format not emitted", err)
+	}
+	ir.WriteString("}\n")
+	return ir.String()
+}
+
+// Independent, initialized counterparts use real Go arguments/results and a
+// balanced private stack. W writes preserve high register bytes; L/Q writes
+// restore the complete source word. No original failing source is rewritten.
+func x86StackFixtureValueProgram(arch string) (string, string, string) {
+	word, suffix, register := 8, "Q", "R12"
+	if arch == "386" {
+		word, suffix, register = 4, "L", "CX"
+	}
+	var source, declarations, driver strings.Builder
+	fmt.Fprintf(&driver, "#include <stdint.h>\n#include <stdio.h>\ntypedef uint%d_t word;\n", word*8)
+	for _, width := range []string{"W", suffix} {
+		name := "PrivateValue" + width
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s value+0(FP),%s\n"+
+			"PUSH%s %s\nMOVW $0,%s\nPOP%s %s\nMOV%s %s,AX\nMOV%s AX,ret+%d(FP)\nRET\n",
+			name, 2*word, suffix, register, width, register, register, width, register, suffix, register, suffix, word)
+		fmt.Fprintf(&declarations, "func %s(value uint%d) uint%d\n", name, word*8, word*8)
+		fmt.Fprintf(&driver, "extern word %s(word);\n", name)
+	}
+	driver.WriteString("int main(void) {\n" +
+		"    const word values[] = {0, 1, 65535, 65536, (word)UINT64_MAX,\n" +
+		"        (word)UINT64_C(0x1122334455667788), (word)UINT64_C(0x8000000080008000)};\n" +
+		"    for (unsigned i = 0; i < sizeof(values) / sizeof(values[0]); i++) {\n")
+	for _, width := range []string{"W", suffix} {
+		fmt.Fprintf(&driver, "        if (PrivateValue%s(values[i]) != values[i]) {\n"+
+			"            fprintf(stderr, \"private-stack %s row=%%u\\n\", i);\n            return 1;\n        }\n", width, width)
+	}
+	driver.WriteString("    }\n    return 0;\n}\n")
+	return source.String(), declarations.String(), driver.String()
+}
+
+func TestX86StackFixtureInitializedPrivateValuesFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, _ := x86StackFixtureValueProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal("initialized private stack lost its declared inputs/result", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86StackFixtureInitializedPrivateValuesPortableRuntime(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc/clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, arch := range []string{"386", "amd64"} {
+		source, declarations, driver := x86StackFixtureValueProgram(arch)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(arch+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+				if err != nil {
+					t.Fatal(err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []int{0, 2} {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "private-stack-fixture", triple, text, driver, nil, level)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_static_discarded_address_test.go b/x86_static_discarded_address_test.go
new file mode 100644
index 000000000..2568af171
--- /dev/null
+++ b/x86_static_discarded_address_test.go
@@ -0,0 +1,91 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86StaticDiscardedSBAddressRows(arch string) []string {
+	widths := []string{"W", "L"}
+	if arch == "amd64" {
+		widths = append(widths, "Q")
+	}
+	var rows []string
+	for _, width := range widths {
+		for _, address := range []string{"pool<>(SB)", "pool<>+4(SB)"} {
+			rows = append(rows, "LEA"+width+" "+address+",DX")
+		}
+		if arch == "386" {
+			rows = append(rows, "LEA"+width+" pool<>(SB)(CX*2),DX",
+				"LEA"+width+" pool<>(SB)(SI)(CX*2),DX")
+		}
+	}
+	return rows
+}
+
+func x86StaticDiscardedSBAddressSource(row string) string {
+	return "DATA pool<>+0(SB)/8,$7\nGLOBL pool<>(SB),16,$32\n" +
+		"TEXT ·view(SB),4,$0-4\nMOVL $1,CX\n" + row +
+		"\nMOVL pool<>(SB),AX\nMOVL AX,ret+0(FP)\nRET\n"
+}
+
+func TestX86StaticIntegerResultDiscardedSBAddresses(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("discarded static addresses require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86StaticDiscardedSBAddressRows(target.arch) {
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				source := x86StaticDiscardedSBAddressSource(row)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+						// This is a routing/definedness regression, not a new
+						// volatility requirement for the existing private global.
+						if err != nil || ir == "" {
+							t.Fatal("discarded unknown address blocked its independent numerical read/result", err)
+						}
+						for _, backend := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, backend)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticIntegerSBAddressesDoNotAcquireNumericalOrStackRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86StaticDiscardedSBAddressRows(target.arch) {
+			original := x86StaticDiscardedSBAddressSource(row)
+			mutations := map[string]string{
+				"address-result": strings.Replace(original, "MOVL AX,ret+0(FP)", "MOVL DX,ret+0(FP)", 1),
+				"address-store":  strings.Replace(original, "MOVL pool<>(SB),AX", "MOVL DX,pool<>(SB)\nMOVL pool<>(SB),AX", 1),
+				"physical-SP":    strings.Replace(original, row, strings.TrimSuffix(row, "DX")+"SP", 1),
+			}
+			if strings.Contains(row, "CX*") {
+				mutations["unknown-index"] = strings.Replace(original, "MOVL $1,CX\n", "", 1)
+			}
+			for name, source := range mutations {
+				t.Run(target.triple+"/"+row+"/"+name, func(t *testing.T) {
+					if source == original {
+						t.Fatal("negative address fixture did not change its source")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal(fmt.Sprintf("%s acquired numerical address bytes or a native stack role", name), err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_static_exchange_test.go b/x86_static_exchange_test.go
new file mode 100644
index 000000000..8755dab51
--- /dev/null
+++ b/x86_static_exchange_test.go
@@ -0,0 +1,276 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type x86StaticExchangeFixture struct {
+	name, source, declaration string
+}
+
+func x86StaticExchangeFixtures(arch string) []x86StaticExchangeFixture {
+	word, move, typ, widths := 8, "MOVQ", "uint64", "BWLQ"
+	if arch == "386" {
+		word, move, typ, widths = 4, "MOVL", "uint32", "BWL"
+	}
+	var fixtures []x86StaticExchangeFixture
+	for _, initialized := range []bool{false, true} {
+		for _, stem := range []string{"XADD", "XCHG"} {
+			for _, width := range widths {
+				registers := []string{"CX"}
+				if arch == "amd64" {
+					registers[0] = "R11"
+				}
+				if width == 'B' {
+					registers = append(registers, "AH")
+				}
+				for _, register := range registers {
+					orders := 1
+					if stem == "XCHG" {
+						orders = 2
+					}
+					for order := 0; order < orders; order++ {
+						name := fmt.Sprintf("Exchange%d", len(fixtures))
+						cell := "·Cell" + name
+						var source strings.Builder
+						if initialized {
+							fmt.Fprintf(&source, "DATA %s+0(SB)/8,$0x12345678\nDATA %s+8(SB)/8,$0x10203040\n", cell, cell)
+						}
+						flags, root := 16, register
+						if initialized {
+							flags = 0
+						}
+						if register == "AH" {
+							root = "AX"
+						}
+						fmt.Fprintf(&source, "GLOBL %s(SB),%d,$16\nTEXT ·%s(SB),4,$0-%d\n%s seed+0(FP),%s\nCLC\n", cell, flags, name, 2*word, move, root)
+						operands := register + "," + cell + "+3(SB)"
+						if order == 1 {
+							operands = cell + "+3(SB)," + register
+						}
+						fmt.Fprintf(&source, "%s%c %s\nSETCS DL\nMOVBLZX DL,DX\n%s %s+3(SB),BX\nXOR%s %s,BX\nXOR%s DX,BX\n%s BX,ret+%d(FP)\nRET\n",
+							stem, width, operands, move, cell, move[3:], root, move[3:], move, word)
+						fixtures = append(fixtures, x86StaticExchangeFixture{name, source.String(), fmt.Sprintf("func %s(seed %s) %s\n", name, typ, typ)})
+					}
+				}
+			}
+		}
+	}
+	return fixtures
+}
+
+func TestX86StaticExchangeCompleteFamilyInitializedObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			fixtures := x86StaticExchangeFixtures(target.arch)
+			want := 30
+			if target.arch == "386" {
+				want = 24
+			}
+			if len(fixtures) != want || want > 32 {
+				t.Fatal("complete DATA/BSS, width and operand-order inventory changed", len(fixtures), want)
+			}
+			var source, declarations strings.Builder
+			for _, fixture := range fixtures {
+				source.WriteString(fixture.source)
+				declarations.WriteString(fixture.declaration)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, fixture := range fixtures {
+				t.Run(fixture.name, func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, fixture.source, fixture.declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Error("actual mutable numerical storage lost its exchange continuation", api, err)
+						}
+					}
+				})
+			}
+			if t.Failed() {
+				return // Every independent source/API ran; failed IR is not object evidence.
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil {
+					t.Fatal("complete initialized exchange source", api, err)
+				}
+				for _, output := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					// Every retained source here is bare. Adjacent LOCK sources and
+					// their per-function target bytes have an independent owner.
+					if strings.Count(output, "asm sideeffect") != want || strings.Count(output, "xadd") != want/3 ||
+						strings.Count(output, "xchg") != 2*want/3 || strings.Count(output, "lock; ") != strings.Count(source.String(), "\nLOCK\n") {
+						t.Fatal("original native exchange, locking or memory effect was lost", api, output)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, output, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86StaticExchangeRejectsMissingSourceRoles(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, fixture := range x86StaticExchangeFixtures(arch) {
+			for _, mutation := range []string{"external", "readonly", "short", "relocated", "missing-register", "pointer-register"} {
+				t.Run(arch+"/"+fixture.name+"/"+mutation, func(t *testing.T) {
+					source := fixture.source
+					cell := "·Cell" + fixture.name
+					declaration := fixture.declaration
+					switch mutation {
+					case "external", "short", "relocated":
+						start := strings.Index(source, "TEXT ")
+						if start < 0 {
+							t.Fatal("fixture lost complete TEXT")
+						}
+						source = source[start:]
+						if mutation == "short" {
+							source = "GLOBL " + cell + "(SB),16,$3\n" + source
+						} else if mutation == "relocated" {
+							word := 4
+							if arch == "amd64" {
+								word = 8
+							}
+							source = fmt.Sprintf("DATA %s+0(SB)/%d,$%s(SB)\nGLOBL %s(SB),16,$16\n", cell, word, cell, cell) + source
+						}
+					case "readonly":
+						source = strings.ReplaceAll(source, "(SB),16,$16", "(SB),8,$16")
+						source = strings.ReplaceAll(source, "(SB),0,$16", "(SB),8,$16")
+					case "missing-register":
+						start := strings.Index(source, " seed+0(FP),")
+						end := strings.Index(source[start:], "\n") + start
+						source = source[:start] + " $0,DX" + source[end:]
+					case "pointer-register":
+						declaration = strings.Replace(declaration, "seed uint", "seed *uint", 1)
+					}
+					if source == fixture.source && declaration == fixture.declaration {
+						t.Fatal("source-role mutation changed nothing", mutation)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, x86AddressMemoryTargets(arch)[0], api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("exchange acquired undefined or unowned numerical storage/input", mutation, api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86StaticExchangeExactEffectsAndInputBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, fixture := range x86StaticExchangeFixtures(arch) {
+			t.Run(arch+"/"+fixture.name, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, fixture.source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				var instruction Instr
+				for _, ins := range file.Funcs[0].Instrs {
+					if strings.HasPrefix(string(ins.Op), "XADD") || strings.HasPrefix(string(ins.Op), "XCHG") {
+						instruction = ins
+						break
+					}
+				}
+				spec, found := amd64ExchangeSpecs[instruction.Op]
+				if !found {
+					t.Fatal("fixture lost the original exchange")
+				}
+				form, err := parseAMD64ExchangeForm(arch, instruction.Op, spec, instruction)
+				if err != nil {
+					t.Fatal(err)
+				}
+				width := int64(spec.bits / 8)
+				index, mask, valid := x86ResultGP(form.register.Reg, width, arch)
+				address, static := x86StaticSBReadAddress(form.other, arch)
+				if !valid || !static {
+					t.Fatal("fixture lost exact typed operands")
+				}
+				resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+				newContext := func() *amd64Ctx {
+					return &amd64Ctx{resolve: resolve,
+						fpStaticAddressValues: x86LoweredStaticAddressValues(file, resolve, nil, arch),
+						fpScalarData:          x86LoweredScalarDataReads(file, resolve, nil, arch)}
+				}
+				for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagsAll} {
+					state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward, boolFrameGP: new([16]x86ResultSlotAddress)}
+					state.gp[index], state.canonicalGP[index] = 0xaa|mask, 0xff
+					state.callerAddressGP[index], state.callerAddressOrigin[index] = true, 9
+					state.resultAddressGP[index] = x86ResultSlotAddress{start: 2, end: 5, valid: true}
+					state.boolFrameGP[index] = x86ResultSlotAddress{start: 3, end: 7, valid: true}
+					state.gp[15], state.pointerGP[15] = 0x55, true
+					want := state.clone()
+					want.gp[index] |= mask
+					if width >= 4 {
+						want.gp[index] = 0xff
+					}
+					want.canonicalGP[index] &^= mask
+					want.callerAddressGP[index], want.callerAddressOrigin[index] = false, 0
+					want.resultAddressGP[index], want.boolFrameGP[index] = x86ResultSlotAddress{}, x86ResultSlotAddress{}
+					if spec.kind == amd64ExchangeAdd {
+						want.flags = x86ByteFlagsAll
+					}
+					query := state.clone()
+					if x86ResultTransfer(instruction, &query, nil, 0, arch) {
+						t.Fatal("standalone query borrowed actual-module storage")
+					}
+					if accepted, known := newContext().scalarStaticExchangeTransfer(instruction, &state, nil, arch); !known || !accepted || !reflect.DeepEqual(state, want) {
+						t.Fatal("exchange changed width, alias, FLAGS, DF or unrelated facts", flags, state, want)
+					}
+				}
+				for _, mutation := range []string{"directory", "object", "readonly", "extent", "pointer", "raw", "address", "segment", "numerical"} {
+					c := newContext()
+					changed := instruction
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					state.gp[index] = 0xff
+					name := resolveAssemblyDataSymbol(address.symbol, resolve)
+					switch mutation {
+					case "directory":
+						c.fpStaticAddressValues = nil
+					case "object":
+						delete(c.fpStaticAddressValues.objects, name)
+					case "readonly":
+						c.fpStaticAddressValues.writable[name] = false
+					case "extent":
+						c.fpScalarData[address] = width - 1
+					case "pointer":
+						state.pointerGP[index] = true
+					case "raw":
+						changed.x86Encoded = true
+					case "address":
+						changed.x86AddressBits = 16
+					case "segment":
+						changed.x86SegmentPrefix = 0x64
+					case "numerical":
+						state.gp[index] &^= mask
+					}
+					before := state.clone()
+					if accepted, _ := c.scalarStaticExchangeTransfer(changed, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("failed static exchange inputs changed state", mutation)
+					}
+				}
+				for bit := uint(0); bit < 8; bit++ {
+					if mask&(1<<bit) == 0 {
+						continue
+					}
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[index] = 0xff &^ (1 << bit)
+					before := state.clone()
+					if accepted, _ := newContext().scalarStaticExchangeTransfer(instruction, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("exchange invented an input byte", bit)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_static_relocation_rmw_test.go b/x86_static_relocation_rmw_test.go
new file mode 100644
index 000000000..7c46d471c
--- /dev/null
+++ b/x86_static_relocation_rmw_test.go
@@ -0,0 +1,143 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Go's non-shared 386 yaddl/Yi32 relocation row is common to all seven
+// binary arithmetic/logical stems. The address is a value, never a cell load.
+func x86StaticRelocationRMWFixture(memory bool) (string, string) {
+	var source, declarations strings.Builder
+	source.WriteString("DATA ·cell+0(SB)/8,$0x1234\nGLOBL ·cell(SB),8,$16\n" +
+		"DATA ·sink+0(SB)/4,$0x12345678\nGLOBL ·sink(SB),16,$4\n")
+	for index, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		name := fmt.Sprintf("relocation%d", index)
+		fmt.Fprintf(&declarations, "func %s(seed uint32) uint32\n", name)
+		destination, load := "AX", ""
+		if memory {
+			destination, load = "·sink(SB)", "MOVL ·sink(SB),AX\n"
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-8\nMOVL seed+0(FP),AX\nCLC\n%sL $·cell+8(SB),%s\n%sMOVL AX,ret+4(FP)\nRET\n",
+			name, stem, destination, load)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86StaticRelocationInitializedCompleteRMWFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86AddressMemoryTargets("386") {
+		for _, memory := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/memory=%t", target, memory), func(t *testing.T) {
+				source, declarations := x86StaticRelocationRMWFixture(memory)
+				x86LEAActualTargetGoObject(t, "386", target, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "386", target, api)
+					if err != nil {
+						t.Fatal("initialized complete relocation/RMW family", api, err)
+					}
+					if !strings.Contains(ir, "ptrtoint ptr") || strings.Contains(ir, "load i32, ptr @cell") ||
+						strings.Contains(ir, "load volatile i32, ptr @cell") {
+						t.Fatal("address relocation became a numerical source-memory read")
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticRelocationRMWCannotInventSourceStorage(t *testing.T) {
+	for _, mutation := range []struct{ name, before, after string }{
+		{"unbound-address", "DATA ·cell+0(SB)/8,$0x1234\nGLOBL ·cell(SB),8,$16\n", ""},
+		{"missing-destination", "DATA ·sink+0(SB)/4,$0x12345678\nGLOBL ·sink(SB),16,$4\n", ""},
+		{"short-destination", "DATA ·sink+0(SB)/4,$0x12345678\nGLOBL ·sink(SB),16,$4", "DATA ·sink+0(SB)/2,$1\nGLOBL ·sink(SB),16,$2"},
+		{"readonly-destination", "GLOBL ·sink(SB),16,$4", "GLOBL ·sink(SB),8,$4"},
+		{"missing-carry", "CLC\n", ""},
+		{"missing-result", "MOVL AX,ret+4(FP)\n", ""},
+	} {
+		t.Run(mutation.name, func(t *testing.T) {
+			source, declarations := x86StaticRelocationRMWFixture(true)
+			changed := strings.ReplaceAll(source, mutation.before, mutation.after)
+			if changed == source {
+				t.Fatal("mutation did not change its exact original source")
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, "386", "i386-unknown-linux-gnu", api)
+				if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("relocation created missing storage/carry/result knowledge", api, err)
+				}
+			}
+		})
+	}
+}
+
+func TestX86StaticNumericRMWCompleteWidthFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		word, goType, move, suffixes := 4, "uint32", "MOVL", "BWL"
+		if arch == "amd64" {
+			word, goType, move, suffixes = 8, "uint64", "MOVQ", "BWLQ"
+		}
+		var source, declarations strings.Builder
+		source.WriteString("DATA ·sink+0(SB)/8,$0x12345678\nGLOBL ·sink(SB),16,$8\n")
+		count := 0
+		for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR", "INC", "DEC", "NEG", "NOT"} {
+			for _, suffix := range suffixes {
+				for _, register := range []bool{false, true} {
+					unary := stem == "INC" || stem == "DEC" || stem == "NEG" || stem == "NOT"
+					if unary && register {
+						continue
+					}
+					name := fmt.Sprintf("numeric%d", count)
+					count++
+					fmt.Fprintf(&declarations, "func %s(seed %s) %s\n", name, goType, goType)
+					operands := "·sink(SB)"
+					if !unary {
+						input := "$5"
+						if register {
+							input = "AX"
+						}
+						operands = input + "," + operands
+					}
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s seed+0(FP),AX\nCLC\n%s%c %s\n%s ·sink(SB),AX\n%s AX,ret+%d(FP)\nRET\n",
+						name, word*2, move, stem, suffix, operands, move, move, word)
+				}
+			}
+		}
+		if count != 18*len(suffixes) {
+			t.Fatal("incomplete independent eleven-stem immediate/register/width matrix", count)
+		}
+		for _, target := range x86AddressMemoryTargets(arch) {
+			t.Run(target, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, arch, target, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, target, api)
+					if err != nil {
+						t.Fatal("complete mutable static numerical family", api, err)
+					}
+					if strings.Count(ir, "store volatile") < count || strings.Count(ir, "load volatile") < count {
+						t.Fatal("static RMW lost its exact paired native access")
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_static_rmw_state_test.go b/x86_static_rmw_state_test.go
new file mode 100644
index 000000000..0dcaf1047
--- /dev/null
+++ b/x86_static_rmw_state_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func x86StaticRMWTestContext(t *testing.T, arch string) *amd64Ctx {
+	t.Helper()
+	source, _ := x86StaticRelocationRMWFixture(true)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	return &amd64Ctx{resolve: resolve,
+		fpStaticAddressValues: x86LoweredStaticAddressValues(file, resolve, nil, arch),
+		fpScalarData:          x86LoweredScalarDataReads(file, resolve, nil, arch),
+	}
+}
+
+func TestX86StaticRMWExactStatusAndNoEscapingFacts(t *testing.T) {
+	for _, stem := range []string{"ADD", "SUB", "ADC", "SBB", "AND", "OR", "XOR"} {
+		for _, memory := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/memory=%t", stem, memory), func(t *testing.T) {
+				context := x86StaticRMWTestContext(t, "386")
+				destination := "AX"
+				if memory {
+					destination = "·sink(SB)"
+				}
+				ins := x86ScalarLaneInstruction(t, stem+"L $·cell+8(SB),"+destination)
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.gp[0], state.gp[2], state.canonicalGP[0] = 0xff, 0x55, 0xff
+				state.callerAddressGP[0], state.callerAddressGP[2] = true, true
+				state.callerAddressOrigin[0], state.callerAddressOrigin[2] = 8, 9
+				state.resultAddressGP[0] = x86ResultSlotAddress{start: 0, end: 4, valid: true}
+				state.pointerGP[2] = true
+				want := state.clone()
+				if stem == "AND" || stem == "OR" || stem == "XOR" {
+					want.flags &^= x86ByteFlagAF
+				}
+				if !memory {
+					want.canonicalGP[0], want.callerAddressGP[0], want.callerAddressOrigin[0] = 0xf0, false, 0
+					want.resultAddressGP[0] = x86ResultSlotAddress{}
+				}
+				query := state.clone()
+				if x86ResultTransfer(ins, &query, nil, 0, "386") {
+					t.Fatal("standalone transfer borrowed an actual module's storage")
+				}
+				accepted, known := context.scalarStaticRMWTransfer(ins, &state, nil, "386")
+				if !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("static operation changed unrelated numerical/address/storage state", accepted, known)
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticRMWRejectsUnboundInputsWithoutPartialState(t *testing.T) {
+	for _, mutation := range []string{"no-directory", "unknown-address", "readonly", "short",
+		"uninitialized-source", "uninitialized-carry", "raw", "address-override", "segment", "unbound-destination"} {
+		t.Run(mutation, func(t *testing.T) {
+			context := x86StaticRMWTestContext(t, "386")
+			ins := x86ScalarLaneInstruction(t, "ADCL $·cell+8(SB),·sink(SB)")
+			state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+			state.gp[2], state.pointerGP[2], state.callerAddressGP[2] = 0x55, true, true
+			switch mutation {
+			case "no-directory":
+				context.fpStaticAddressValues = nil
+			case "unknown-address":
+				delete(context.fpStaticAddressValues.objects, "cell")
+			case "readonly":
+				context.fpStaticAddressValues.writable["sink"] = false
+			case "short":
+				context.fpScalarData[x86StaticSBAddress{"·sink", 0}] = 3
+			case "uninitialized-source":
+				ins.Args[0] = Operand{Kind: OpReg, Reg: AX}
+			case "uninitialized-carry":
+				state.flags &^= x86ByteFlagCF
+			case "raw":
+				ins.x86Encoded = true
+			case "address-override":
+				ins.x86AddressBits = 16
+			case "segment":
+				ins.x86SegmentPrefix = 0x64
+			case "unbound-destination":
+				ins.Args[1] = Operand{Kind: OpSym, Sym: "external(SB)"}
+			}
+			before := state.clone()
+			if accepted, _ := context.scalarStaticRMWTransfer(ins, &state, nil, "386"); accepted || !reflect.DeepEqual(state, before) {
+				t.Fatal("failed static input proof partially changed state")
+			}
+		})
+	}
+}
+
+func TestX86StaticRMWActualMutabilityDirectory(t *testing.T) {
+	for _, flags := range []string{"", "0", "16", "NOPTR", "8", "RODATA|NOPTR", "missing"} {
+		t.Run(flags, func(t *testing.T) {
+			source, _ := x86StaticRelocationRMWFixture(true)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file.Globl[1].Flags = flags
+			resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+			values := x86LoweredStaticAddressValues(file, resolve, nil, "386")
+			want := flags == "" || flags == "0" || flags == "16" || flags == "NOPTR"
+			if values == nil || values.writable["sink"] != want || values.writable["cell"] {
+				t.Fatal("numeric object existence changed actual GLOBL mutability", flags)
+			}
+		})
+	}
+}
+
+func TestX86StaticBitStringNativeContinuationDoesNotExportFacts(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LockScalarOracleForms(arch) {
+			if !strings.HasPrefix(row.op, "BT") {
+				continue
+			}
+			t.Run(arch+"/"+row.text, func(t *testing.T) {
+				context := x86StaticBitStringTestContext(t, arch)
+				ins := x86ScalarLaneInstruction(t, strings.Replace(row.text, "1(SI)", "·sink(SB)", 1))
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				index, _, _ := x86ResultGP(CX, x86ResultPointerWord(arch), arch)
+				state.gp[index], state.canonicalGP[index] = 0xff, 0x55
+				state.callerAddressGP[index], state.callerAddressOrigin[index] = true, 9
+				state.gp[0], state.pointerGP[0] = 0, true
+				want := state.clone()
+				want.flags &^= x86ByteFlagOF | x86ByteFlagSF | x86ByteFlagAF | x86ByteFlagPF
+				query := state.clone()
+				if x86ResultTransfer(ins, &query, nil, 0, arch) {
+					t.Fatal("standalone transfer borrowed an actual module's native storage")
+				}
+				accepted, known := context.scalarStaticRMWTransfer(ins, &state, nil, arch)
+				if !accepted || !known || !reflect.DeepEqual(state, want) {
+					t.Fatal("paired native bit string changed unrelated state or lost CF", accepted, known)
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticBitStringRejectsUnownedOrUndefinedInputs(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86LockScalarOracleForms(arch) {
+			if !strings.HasPrefix(row.op, "BT") || !strings.Contains(row.text, "CX,") {
+				continue
+			}
+			for _, mutation := range []string{"no-directory", "no-object", "readonly", "short-base", "external",
+				"missing-index", "partial-index", "pointer-index", "raw", "address-override", "segment"} {
+				t.Run(arch+"/"+row.text+"/"+mutation, func(t *testing.T) {
+					context := x86StaticBitStringTestContext(t, arch)
+					ins := x86ScalarLaneInstruction(t, strings.Replace(row.text, "1(SI)", "·sink(SB)", 1))
+					form, _, _ := x86LockScalarRMWProperties(ins.Op, ins, arch)
+					state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionForward}
+					index, _, _ := x86ResultGP(CX, x86ResultPointerWord(arch), arch)
+					state.gp[index] = 0xff
+					switch mutation {
+					case "no-directory":
+						context.fpStaticAddressValues = nil
+					case "no-object":
+						delete(context.fpStaticAddressValues.objects, "sink")
+					case "readonly":
+						context.fpStaticAddressValues.writable["sink"] = false
+					case "short-base":
+						context.fpScalarData[x86StaticSBAddress{"·sink", 0}] = int64(form.spec.bits/8 - 1)
+					case "external":
+						ins.Args[1] = Operand{Kind: OpSym, Sym: "external(SB)"}
+					case "missing-index":
+						state.gp[index] = 0
+					case "partial-index":
+						state.gp[index] = 1
+					case "pointer-index":
+						state.gp[index], state.pointerGP[index] = 0, true
+					case "raw":
+						ins.x86Encoded = true
+					case "address-override":
+						ins.x86AddressBits = 16
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					}
+					before := state.clone()
+					if accepted, _ := context.scalarStaticRMWTransfer(ins, &state, nil, arch); accepted || !reflect.DeepEqual(state, before) {
+						t.Fatal("unowned native bit string acquired facts or partially changed state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86StaticBitStringTestContext(t *testing.T, arch string) *amd64Ctx {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "DATA ·sink+0(SB)/8,$0x1234\n"+
+		"DATA ·sink+8(SB)/8,$0x5678\nGLOBL ·sink(SB),16,$16\n"+
+		"TEXT ·base(SB),4,$0-0\nBTSL $1,·sink(SB)\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := func(symbol string) string { return strings.TrimPrefix(symbol, "·") }
+	context := &amd64Ctx{resolve: resolve,
+		fpStaticAddressValues: x86LoweredStaticAddressValues(file, resolve, nil, arch),
+		fpScalarData:          x86LoweredScalarDataReads(file, resolve, nil, arch),
+	}
+	if context.fpScalarData[x86StaticSBAddress{"·sink", 0}] != 16 {
+		t.Fatal("actual complete source did not expose its initialized base word")
+	}
+	return context
+}
diff --git a/x86_static_simd_store_test.go b/x86_static_simd_store_test.go
new file mode 100644
index 000000000..ee553abee
--- /dev/null
+++ b/x86_static_simd_store_test.go
@@ -0,0 +1,84 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+var x86StaticSIMDStoreRows = []struct {
+	op    string
+	width int
+}{
+	{"MOVL", 4}, {"MOVQ", 8}, {"MOVD", 8}, {"MOVDQ2Q", 8},
+	{"VMOVD", 4}, {"VMOVQ", 8},
+}
+
+func x86StaticSIMDStoreSource(op string) string {
+	return "GLOBL slot<>(SB),16,$16\nTEXT ·view(SB),4,$0-4\nPXOR X0,X0\n" +
+		op + " X0,slot<>+4(SB)\nMOVL $7,AX\nMOVL AX,ret+0(FP)\nRET\n"
+}
+
+func TestX86StaticIntegerSIMDSBStoresCompleteMoveFamily(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete static SIMD stores require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86StaticSIMDStoreRows {
+			t.Run(target.triple+"/"+row.op, func(t *testing.T) {
+				source := x86StaticSIMDStoreSource(row.op)
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil || len(file.Funcs) != 1 {
+					t.Fatal("complete static source did not parse", err)
+				}
+				// This checks routing only; a manual signature grants no source,
+				// frame, memory or initialized-result permission to the APIs.
+				if !x86StaticIntegerResultSourceCandidate(file.Funcs[0], FuncSig{Ret: I32}, target.arch) {
+					t.Error("a typed scalar memory move escaped the complete static result route")
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+						if err != nil || !strings.Contains(ir, fmt.Sprintf("store volatile i%d", row.width*8)) {
+							t.Fatal("complete initialized X source lost its exact static store", err)
+						}
+						for _, backend := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, ir, backend)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86StaticIntegerSIMDSBStoresRetainInputResultAndExtentBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86StaticSIMDStoreRows {
+			original := x86StaticSIMDStoreSource(row.op)
+			for name, source := range map[string]string{
+				"unknown-source": strings.Replace(original, "PXOR X0,X0\n", "", 1),
+				"missing-result": strings.Replace(original, "MOVL AX,ret+0(FP)\n", "", 1),
+				"short-extent":   strings.Replace(original, "$16\n", fmt.Sprintf("$%d\n", row.width+3), 1),
+				"unknown-symbol": strings.Replace(original, "X0,slot<>+4(SB)", "X0,externalSlot(SB)", 1),
+			} {
+				t.Run(target.triple+"/"+row.op+"/"+name, func(t *testing.T) {
+					if source == original {
+						t.Fatal("independent negative mutation did not change the source")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func view() uint32\n", target.arch, target.triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("static store acquired unknown bytes, storage or an independent result", err)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_string_instruction_form_test.go b/x86_string_instruction_form_test.go
new file mode 100644
index 000000000..661cd19b0
--- /dev/null
+++ b/x86_string_instruction_form_test.go
@@ -0,0 +1,269 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86StringInstructionCompleteOfficialYnoneRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src", "cmd", "internal", "obj", "x86", "asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	table := string(data)
+	if !strings.Contains(table, "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}") {
+		t.Fatal("complete official zero-operand class changed")
+	}
+
+	// This independent encoder inventory proves the complete operand/encoding
+	// grammar, not prefix adjacency, initialized memory, FLAGS or entry roles.
+	want := map[string]string{
+		"REP":  "{AREP, ynone, Px, opBytes{0xf3}},",
+		"REPN": "{AREPN, ynone, Px, opBytes{0xf2}},",
+	}
+	for _, family := range []struct {
+		name       string
+		byteOpcode byte
+		wideOpcode byte
+	}{
+		{"MOVS", 0xa4, 0xa5},
+		{"STOS", 0xaa, 0xab},
+		{"SCAS", 0xae, 0xaf},
+		{"CMPS", 0xa6, 0xa7},
+		{"LODS", 0xac, 0xad},
+	} {
+		for _, width := range []struct{ suffix, prefix string }{
+			{"B", "Pb"}, {"W", "Pe"}, {"L", "Px"}, {"Q", "Pw"},
+		} {
+			opcode := family.wideOpcode
+			if width.suffix == "B" {
+				opcode = family.byteOpcode
+			}
+			name := family.name + width.suffix
+			want[name] = fmt.Sprintf("{A%s, ynone, %s, opBytes{0x%x}},", name, width.prefix, opcode)
+		}
+	}
+	rows := regexp.MustCompile(`(?m)^\s*\{A((?:MOVS|STOS|SCAS|CMPS|LODS)[BWLQ]|REP|REPN),[^\n]+`).FindAllStringSubmatch(table, -1)
+	if len(rows) != 22 || len(want) != 22 || len(x86StringSpecs) != 20 {
+		t.Fatal("complete two-prefix/twenty-string inventory changed", len(rows), len(want), len(x86StringSpecs))
+	}
+	for _, row := range rows {
+		name := row[1]
+		if strings.TrimSpace(row[0]) != want[name] {
+			t.Fatal("official complete encoding row differs", name, row[0], want[name])
+		}
+		delete(want, name)
+	}
+	if len(want) != 0 {
+		t.Fatal("official family omitted a row", want)
+	}
+}
+
+func TestX86StringInstructionCompleteGrammar(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{"MOVS", "STOS", "SCAS", "CMPS", "LODS"} {
+			for _, width := range []struct {
+				suffix string
+				typ    LLVMType
+				bytes  int
+			}{{"B", I8, 1}, {"W", I16, 2}, {"L", I32, 4}, {"Q", I64, 8}} {
+				for _, prefix := range []string{"", "REP", "REPN"} {
+					op := Op(stem + width.suffix)
+					t.Run(arch+"/"+string(op)+"/"+prefix, func(t *testing.T) {
+						kind, typ, bytes, known := x86StringProperties(op)
+						if !known || kind != strings.ToLower(stem) || typ != width.typ || bytes != width.bytes {
+							t.Fatal("complete independent operation/width differs", kind, typ, bytes, known)
+						}
+						var output strings.Builder
+						ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, "", false)
+						ctx.directionSlot = "%direction"
+						if prefix != "" {
+							if terminated, err := ctx.lowerInstr(0, 0, Instr{Op: Op(prefix), Raw: prefix}, nil, nil); terminated || err != nil || ctx.repeatPrefix != prefix {
+								t.Fatal("existing prefix dispatcher differs", terminated, err, ctx.repeatPrefix)
+							}
+						}
+						ins := Instr{Op: op, Raw: string(op)}
+						before := ins
+						known, terminated, err := ctx.lowerString(ins)
+						if !known || terminated || !reflect.DeepEqual(before, ins) || ctx.repeatPrefix != "" {
+							t.Fatal("string handling/source/prefix identity changed", known, terminated, err, ctx.repeatPrefix)
+						}
+						if arch == "386" && width.suffix == "Q" {
+							if err == nil || output.Len() != 0 {
+								t.Fatal("mode32 qword form emitted", err, output.String())
+							}
+							return
+						}
+						if err != nil || !strings.Contains(output.String(), "call ") || !strings.Contains(output.String(), "load i1, ptr %direction") {
+							t.Fatal("valid existing emitter form changed", err, output.String())
+						}
+						if prefix != "" && (stem == "SCAS" || stem == "CMPS") && strings.Count(output.String(), " = select i1 ") < 6 {
+							t.Fatal("zero-count compare no longer preserves all six old status flags", output.String())
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringInstructionRejectsOperandsAndSuffixes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{"MOVS", "STOS", "SCAS", "CMPS", "LODS"} {
+			for _, width := range []string{"B", "W", "L", "Q"} {
+				for _, mutation := range []struct {
+					name   string
+					suffix string
+					args   []Operand
+				}{
+					{name: "register", args: []Operand{{Kind: OpReg, Reg: AX}}},
+					{name: "immediate", args: []Operand{{Kind: OpImm, Imm: 1}}},
+					{name: "memory", args: []Operand{{Kind: OpMem, Mem: MemRef{Base: DI}}}},
+					{name: "logical-FP", args: []Operand{{Kind: OpFP, FPOffset: 0}}},
+					{name: "two-operands", args: []Operand{{Kind: OpReg, Reg: SI}, {Kind: OpReg, Reg: DI}}},
+					{name: "zero-suffix", suffix: ".Z"},
+					{name: "SAE-suffix", suffix: ".SAE"},
+					{name: "unknown-suffix", suffix: ".invalid"},
+				} {
+					op := Op(stem + width + mutation.suffix)
+					t.Run(arch+"/"+string(op)+"/"+mutation.name, func(t *testing.T) {
+						var output strings.Builder
+						ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, "", false)
+						ctx.repeatPrefix = "REPN"
+						known, terminated, err := ctx.lowerString(Instr{Op: op, Raw: string(op), Args: mutation.args})
+						if !known || terminated || err == nil || output.Len() != 0 {
+							t.Fatal("malformed complete family form reached emitter", known, terminated, err, output.String())
+						}
+						wantPrefix := ""
+						if mutation.suffix != "" {
+							wantPrefix = "REPN"
+						}
+						if ctx.repeatPrefix != wantPrefix {
+							t.Fatal("existing fatal-validation prefix consumption order changed", ctx.repeatPrefix, wantPrefix)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringInstructionDoesNotConsumeOtherFamilies(t *testing.T) {
+	for _, op := range []Op{"REP", "REPN", "REPE", "REPNE", "MOVSS", "MOVSD", "CMPSS", "CMPSD", "INSB", "OUTSB", "SCAS", "NOP"} {
+		t.Run(string(op), func(t *testing.T) {
+			var output strings.Builder
+			ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, "amd64", "", false)
+			ctx.repeatPrefix = "REPN"
+			known, terminated, err := ctx.lowerString(Instr{Op: op, Raw: string(op)})
+			if known || terminated || err != nil || output.Len() != 0 || ctx.repeatPrefix != "REPN" {
+				t.Fatal("unrelated prefix/SIMD/I/O operation borrowed string grammar", known, terminated, err)
+			}
+		})
+	}
+}
+
+func TestX86StringInstructionTypedFormHasOnlyValidatedGrammar(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, stem := range []string{"MOVS", "STOS", "SCAS", "CMPS", "LODS"} {
+			for _, width := range []struct {
+				suffix string
+				typ    LLVMType
+				bytes  int
+			}{{"B", I8, 1}, {"W", I16, 2}, {"L", I32, 4}, {"Q", I64, 8}} {
+				op := Op(stem + width.suffix)
+				t.Run(arch+"/"+string(op), func(t *testing.T) {
+					ins := Instr{Op: op, Raw: string(op)}
+					form, known, err := x86StringInstructionProperties(ins, arch)
+					if !known || (err != nil) != (arch == "386" && width.suffix == "Q") {
+						t.Fatal("complete typed mode restriction differs", known, err)
+					}
+					if form.kind != strings.ToLower(stem) || form.typ != width.typ || form.width != width.bytes {
+						t.Fatal("typed operation/width differs", form)
+					}
+					for _, invalid := range []Instr{
+						{Op: Op(string(op) + ".Z"), Raw: string(op) + ".Z"},
+						{Op: op, Raw: string(op), Args: []Operand{{Kind: OpReg, Reg: AX}}},
+					} {
+						if _, known, err := x86StringInstructionProperties(invalid, arch); !known || err == nil {
+							t.Fatal("typed form lost suffix/operand validation", invalid, known, err)
+						}
+					}
+				})
+			}
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		t.Run("not-x86/"+arch, func(t *testing.T) {
+			ins := Instr{Op: "SCASB", Raw: "SCASB"}
+			if _, known, err := x86StringInstructionProperties(ins, arch); !known || err == nil {
+				t.Fatal("x86 grammar borrowed a different source mode", known, err)
+			}
+		})
+	}
+	for _, op := range []Op{"REP", "REPN", "MOVSS", "CMPSD", "INSB", "OUTSB", "NOP"} {
+		ins := Instr{Op: op, Raw: string(op)}
+		if form, known, err := x86StringInstructionProperties(ins, "amd64"); known || err != nil || form != (x86StringSpec{}) {
+			t.Fatal("another family acquired a typed string form", op, form, known, err)
+		}
+	}
+	for _, test := range []struct {
+		ins   Instr
+		arch  string
+		known bool
+		typ   LLVMType
+		fail  bool
+	}{
+		{Instr{Op: "SCASB", Raw: "SCASQ"}, "386", true, I8, false},
+		{Instr{Op: "SCASQ", Raw: "SCASB"}, "386", true, I64, true},
+		{Instr{Op: "scasb", Raw: "SCASQ"}, "386", true, I8, false},
+		{Instr{Op: "scasb.z", Raw: "SCASB"}, "386", true, "", true},
+		{Instr{Op: "MOVSS", Raw: "SCASB"}, "amd64", false, "", false},
+		{Instr{Raw: "SCASB"}, "amd64", false, "", false},
+	} {
+		form, known, err := x86StringInstructionProperties(test.ins, test.arch)
+		if known != test.known || (err != nil) != test.fail || form.typ != test.typ {
+			t.Fatal("typed form did not derive its one actual instruction head", test, form, known, err)
+		}
+	}
+}
+
+func TestX86StringRepeatPrefixExistingGrammarAndBinding(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, mutation := range []struct {
+				name string
+				ins  Instr
+			}{
+				{"register", Instr{Op: Op(prefix), Raw: prefix, Args: []Operand{{Kind: OpReg, Reg: AX}}}},
+				{"immediate", Instr{Op: Op(prefix), Raw: prefix, Args: []Operand{{Kind: OpImm, Imm: 1}}}},
+				{"suffix", Instr{Op: Op(prefix + ".Z"), Raw: prefix + ".Z"}},
+			} {
+				t.Run(arch+"/"+prefix+"/"+mutation.name, func(t *testing.T) {
+					var output strings.Builder
+					ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, "", false)
+					terminated, err := ctx.lowerInstr(0, 0, mutation.ins, nil, nil)
+					if terminated || err == nil || output.Len() != 0 || ctx.repeatPrefix != "" {
+						t.Fatal("invalid prefix acquired an emitter effect", terminated, err, output.String())
+					}
+				})
+			}
+			for _, follower := range []Op{"NOP", "RET", "REP", "REPN"} {
+				t.Run(arch+"/"+prefix+"/followed-by-"+string(follower), func(t *testing.T) {
+					var output strings.Builder
+					ctx := newX86Ctx(&output, Func{}, FuncSig{Ret: Void}, nil, nil, arch, "", false)
+					ctx.repeatPrefix = prefix
+					terminated, err := ctx.lowerInstr(0, 0, Instr{Op: follower, Raw: string(follower)}, nil, nil)
+					if terminated || err == nil || output.Len() != 0 || ctx.repeatPrefix != "" {
+						t.Fatal("prefix was treated as an independent NOP", terminated, err, output.String())
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_string_memory_effect_test.go b/x86_string_memory_effect_test.go
new file mode 100644
index 000000000..7b0fddcd0
--- /dev/null
+++ b/x86_string_memory_effect_test.go
@@ -0,0 +1,236 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This inventory is independent of x86StringSpecs. It describes architectural
+// memory accesses, not initialized pointee bytes or permission to perform them.
+type x86StringMemoryRow struct {
+	op, kind      string
+	width         int
+	reads, writes int
+}
+
+func x86StringMemoryRows() []x86StringMemoryRow {
+	var rows []x86StringMemoryRow
+	for _, family := range []struct {
+		name, kind    string
+		reads, writes int
+	}{
+		{"MOVS", "movs", 1, 1},
+		{"STOS", "stos", 0, 1},
+		{"SCAS", "scas", 1, 0},
+		{"CMPS", "cmps", 2, 0},
+		{"LODS", "lods", 1, 0},
+	} {
+		for _, width := range []struct {
+			suffix string
+			bytes  int
+		}{{"B", 1}, {"W", 2}, {"L", 4}, {"Q", 8}} {
+			rows = append(rows, x86StringMemoryRow{
+				family.name + width.suffix, family.kind, width.bytes,
+				family.reads, family.writes,
+			})
+		}
+	}
+	return rows
+}
+
+func x86StringMemoryModeRows(arch string) []x86StringMemoryRow {
+	var rows []x86StringMemoryRow
+	for _, row := range x86StringMemoryRows() {
+		if arch != "386" || row.width != 8 {
+			rows = append(rows, row)
+		}
+	}
+	return rows
+}
+
+func x86StringMemoryHelper(row x86StringMemoryRow) string {
+	prefix := "__plan9asm_rep_"
+	if row.kind == "movs" {
+		prefix = "__plan9asm_"
+	}
+	return prefix + strings.ToLower(row.op)
+}
+
+// These generated identifiers contain only ASCII letters, digits and '_'.
+// Accept either of LLVM's equivalent quoted/unquoted identifier renderings.
+func x86StringMemoryFunction(t testing.TB, ir, name string) string {
+	t.Helper()
+	head := regexp.MustCompile(`(?m)^define [^\n]* @(?:"` + regexp.QuoteMeta(name) + `"|` + regexp.QuoteMeta(name) + `)\(`)
+	locations := head.FindAllStringIndex(ir, -1)
+	if len(locations) != 1 {
+		t.Fatalf("complete function %q appears %d times", name, len(locations))
+	}
+	rest := ir[locations[0][0]:]
+	end := strings.Index(rest, "\n}")
+	if end < 0 {
+		t.Fatal("unterminated complete function", name)
+	}
+	return rest[:end+2]
+}
+
+// The returned bodies are local test observations, never reusable source,
+// frame, caller-memory or native-entry permissions.
+func x86StringMemoryFunctions(t testing.TB, ir string, names []string) map[string]string {
+	t.Helper()
+	// Parse once and use LLVM's own symbol index rather than scanning the
+	// whole module with a fresh matcher for every requested definition.
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	module, err := parseIRModuleInContext(ctx, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal("complete function index requires valid LLVM IR", err)
+	}
+	bodies := make(map[string]string, len(names))
+	for _, name := range names {
+		if _, duplicate := bodies[name]; duplicate {
+			t.Fatal("duplicate expected complete function", name)
+		}
+		function := module.NamedFunction(name)
+		if function.IsNil() || function.IsDeclaration() || function.BasicBlocksCount() == 0 {
+			t.Fatal("missing complete indexed function", name)
+		}
+		bodies[name] = function.String()
+	}
+	return bodies
+}
+
+func x86StringMemoryHelperIR(t *testing.T, row x86StringMemoryRow) string {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT helper(SB),4,$0-0\n"+row.op+"\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var ir strings.Builder
+	emitX86StringHelpers(&ir, file)
+	return x86StringMemoryFunction(t, ir.String(), x86StringMemoryHelper(row))
+}
+
+func TestX86StringImplicitMemoryIndependentFamilyEffects(t *testing.T) {
+	rows := x86StringMemoryRows()
+	if len(rows) != 20 {
+		t.Fatal("all five families and four widths must remain independently covered")
+	}
+	seen := make(map[string]bool)
+	for _, row := range rows {
+		if seen[row.op] {
+			t.Fatal("duplicate original spelling", row.op)
+		}
+		seen[row.op] = true
+		for _, arch := range []string{"386", "amd64"} {
+			form, known, err := x86StringInstructionProperties(Instr{Op: Op(row.op), Raw: row.op}, arch)
+			invalid := arch == "386" && row.width == 8
+			if !known || (err != nil) != invalid || form.kind != row.kind ||
+				form.width != row.width || form.typ != LLVMType(fmt.Sprintf("i%d", 8*row.width)) {
+				t.Fatal("typed grammar disagrees with independent mode/width inventory", arch, row, form, err)
+			}
+		}
+	}
+	if len(x86StringMemoryModeRows("386")) != 15 || len(x86StringMemoryModeRows("amd64")) != 20 {
+		t.Fatal("mode filtering lost a complete family")
+	}
+}
+
+func TestX86StringImplicitHelpersKeepObservableNativeAccesses(t *testing.T) {
+	for _, row := range x86StringMemoryRows() {
+		t.Run(row.op, func(t *testing.T) {
+			ir := x86StringMemoryHelperIR(t, row)
+			typ := fmt.Sprintf("i%d", 8*row.width)
+			reads := strings.Count(ir, " = load volatile "+typ+", ptr ")
+			writes := regexp.MustCompile(`(?m)^  store volatile `+typ+` [^\n]+, ptr [^\n]+, align 1$`).FindAllString(ir, -1)
+			if reads != row.reads || len(writes) != row.writes {
+				t.Fatalf("dead outputs must retain every original exact-width native access: got read/write %d/%d, want %d/%d\n%s",
+					reads, len(writes), row.reads, row.writes, ir)
+			}
+			if regexp.MustCompile(`(?m)^  (?:%[^ ]+ = load|store) i\d+ `).MatchString(ir) {
+				t.Fatal("ordinary nonvolatile native access remains in the string helper", ir)
+			}
+		})
+	}
+}
+
+func TestX86StringImplicitHelpersGuardZeroCountBeforeMemory(t *testing.T) {
+	for _, row := range x86StringMemoryRows() {
+		t.Run(row.op, func(t *testing.T) {
+			ir := x86StringMemoryHelperIR(t, row)
+			condition, empty, body := "empty", "empty_exit", "scan"
+			if row.kind == "movs" || row.kind == "stos" {
+				condition, empty, body = "done", "exit", "body"
+			} else if row.kind == "lods" {
+				body = "load"
+			}
+			gate := fmt.Sprintf("%%%s = icmp eq i64 %%left, 0\n  br i1 %%%s, label %%%s, label %%%s",
+				condition, condition, empty, body)
+			gateAt, bodyAt := strings.Index(ir, gate), strings.Index(ir, "\n"+body+":\n")
+			if !strings.Contains(ir, "[ %count, %entry ]") || gateAt < 0 || bodyAt <= gateAt {
+				t.Fatal("zero count must branch around every memory access", ir)
+			}
+			emptyAt := strings.Index(ir, "\n"+empty+":\n")
+			if emptyAt <= bodyAt || strings.Contains(ir[emptyAt:], " load ") || strings.Contains(ir[emptyAt:], " store ") {
+				t.Fatal("empty path performed a memory access", ir)
+			}
+			if row.kind == "scas" || row.kind == "cmps" || row.kind == "lods" {
+				if !strings.Contains(ir[emptyAt:], "i1 false") {
+					t.Fatal("zero iterations must not claim an executed comparison/load", ir)
+				}
+			}
+		})
+	}
+}
+
+func x86StringMemoryFixture(rows []x86StringMemoryRow, arch, prefix string, count int, backward bool) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	for _, row := range rows {
+		name := "stringmem_" + strings.ToLower(row.op)
+		fmt.Fprintf(&declarations, "func %s(dst, src *byte, mode uint32)\n", name)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s dst+0(FP),DI\n%s src+%d(FP),SI\n",
+			name, 2*word+4, move, move, word)
+		fmt.Fprintf(&source, "MOVL mode+%d(FP),BX\nMOVL $19,AX\nMOVL $%d,CX\nCLD\n", 2*word, count)
+		if backward {
+			source.WriteString("STD\n")
+		}
+		if prefix != "" {
+			source.WriteString(prefix + "\n")
+		}
+		source.WriteString(row.op + "\n")
+		// Every implicit result is genuinely dead. The source has a real void
+		// declaration; this is not an uninitialized nonvoid result fixture.
+		source.WriteString("MOVL $0,AX\nMOVL $0,CX\nMOVL $0,SI\nMOVL $0,DI\nCLD\nRET\n")
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86StringImplicitMemoryDoesNotGrantResultOrPointerAuthority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		word, move := 8, "MOVQ"
+		if arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, row := range x86StringMemoryModeRows(arch) {
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				body := fmt.Sprintf("%s dst+0(FP),DI\n%s src+%d(FP),SI\nMOVL $1,CX\nMOVL $19,AX\nCLD\nREP\n%s\nMOVL $7,ret+%d(FP)\nRET",
+					move, move, word, row.op, 2*word)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(dst,src *byte) uint32", body)
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("syntax and paired lowering cannot create public pointee/caller-write/string-loop authority", err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_string_memory_index_test.go b/x86_string_memory_index_test.go
new file mode 100644
index 000000000..cfbd811d3
--- /dev/null
+++ b/x86_string_memory_index_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86StringMemoryIndexFixture(quoted, crlf bool) (string, []string) {
+	var ir strings.Builder
+	ir.WriteString("; complete generated function-index fixture\n")
+	names := make([]string, 212)
+	for index := range names {
+		name := fmt.Sprintf("segment%d", index)
+		names[index] = name
+		symbol := name
+		if quoted {
+			symbol = strconv.Quote(symbol)
+		}
+		fmt.Fprintf(&ir, "define i64 @%s(ptr %%source) {\nentry:\n", symbol)
+		ir.WriteString(strings.Repeat("; retained complete-body payload, not another function definition\n", 32))
+		fmt.Fprintf(&ir, "  %%loaded = load volatile i64, ptr %%source, align 1\n  %%mix = add i64 %%loaded, %d\n  ret i64 %%mix\n}\n", index)
+	}
+	source := ir.String()
+	if crlf {
+		source = strings.ReplaceAll(source, "\n", "\r\n")
+	}
+	return source, names
+}
+
+func TestX86StringMemoryFunctionIndexRetainsAllCompleteBodies(t *testing.T) {
+	for _, quoted := range []bool{false, true} {
+		for _, crlf := range []bool{false, true} {
+			t.Run(fmt.Sprintf("quoted%t/CRLF%t", quoted, crlf), func(t *testing.T) {
+				ir, names := x86StringMemoryIndexFixture(quoted, crlf)
+				bodies := x86StringMemoryFunctions(t, ir, names)
+				if len(bodies) != len(names) {
+					t.Fatal("complete module index lost a function", len(bodies), len(names))
+				}
+				for index, name := range names {
+					body := bodies[name]
+					if !strings.Contains(body, fmt.Sprintf("add i64 %%loaded, %d\n", index)) &&
+						!strings.Contains(body, fmt.Sprintf("add i64 %%loaded, %d\r\n", index)) ||
+						strings.Count(body, "load volatile i64") != 1 ||
+						!strings.Contains(body, "ret i64 %mix") {
+						t.Fatal("index selected, cropped or mixed a different function", name)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86StringMemoryFunctionIndexAvoidsPerFunctionMatcherAllocations(t *testing.T) {
+	ir, names := x86StringMemoryIndexFixture(false, false)
+	var bodies map[string]string
+	allocations := testing.AllocsPerRun(1, func() {
+		bodies = x86StringMemoryFunctions(t, ir, names)
+	})
+	// Leave room for SDK-specific string/interface overhead, not compilation
+	// of a fresh whole-module matcher for each requested function.
+	budget := float64(16*len(names) + 256)
+	if len(bodies) != len(names) || allocations > budget {
+		t.Fatalf("whole-module index allocations=%g, budget=%g, functions=%d", allocations, budget, len(bodies))
+	}
+}
+
+func BenchmarkX86StringMemoryWholeModuleIndex(b *testing.B) {
+	ir, names := x86StringMemoryIndexFixture(false, false)
+	b.Logf("functions=%d bytes=%d fixture-sha256=%x", len(names), len(ir), sha256.Sum256([]byte(ir)))
+	b.SetBytes(int64(len(ir)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for index := 0; index < b.N; index++ {
+		if got := x86StringMemoryFunctions(b, ir, names); len(got) != len(names) {
+			b.Fatal("benchmark omitted complete functions")
+		}
+	}
+}
diff --git a/x86_string_memory_ir_reader_controls_test.go b/x86_string_memory_ir_reader_controls_test.go
new file mode 100644
index 000000000..61931504f
--- /dev/null
+++ b/x86_string_memory_ir_reader_controls_test.go
@@ -0,0 +1,92 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86StringMemoryIRReaderLineEndingsAndMetadata(t *testing.T) {
+	for _, width := range []int{1, 2, 4, 8} {
+		for _, ending := range []string{"LF", "CRLF"} {
+			for _, metadata := range []string{"", ", !alias.scope !7"} {
+				for _, terminalNewline := range []bool{false, true} {
+					name := fmt.Sprintf("width=%d/%s/metadata=%t/newline=%t", width, ending, metadata != "", terminalNewline)
+					t.Run(name, func(t *testing.T) {
+						typ := fmt.Sprintf("i%d", 8*width)
+						body := "  %value = load volatile " + typ + ", ptr %source, align 1" + metadata + "\n" +
+							"  store volatile " + typ + " %value, ptr %destination, align 1" + metadata
+						if terminalNewline {
+							body += "\n"
+						}
+						if ending == "CRLF" {
+							body = strings.ReplaceAll(body, "\n", "\r\n")
+						}
+						if err := x86StringMemoryIRAccessError(body, width, 1, 1); err != nil {
+							t.Fatal(err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringMemoryIRReaderRejectsMemoryMutations(t *testing.T) {
+	for _, width := range []int{1, 2, 4, 8} {
+		typ := fmt.Sprintf("i%d", 8*width)
+		read := "  %value = load volatile " + typ + ", ptr %source, align 1\n"
+		write := "  store volatile " + typ + " %value, ptr %destination, align 1\n"
+		for _, ending := range []string{"LF", "CRLF"} {
+			for _, row := range []struct {
+				name, body    string
+				reads, writes int
+			}{
+				{"missing-read", write, 1, 1},
+				{"missing-write", read, 1, 1},
+				{"duplicate-read", read + read + write, 1, 1},
+				{"duplicate-write", read + write + write, 1, 1},
+				{"nonvolatile-read", strings.Replace(read, "load volatile", "load", 1) + write, 1, 1},
+				{"nonvolatile-write", read + strings.Replace(write, "store volatile", "store", 1), 1, 1},
+				{"wrong-read-width", strings.Replace(read, typ, "i128", 1) + write, 1, 1},
+				{"wrong-write-width", read + strings.Replace(write, typ, "i128", 1), 1, 1},
+				{"wrong-read-alignment", strings.Replace(read, "align 1", "align 16", 1) + write, 1, 1},
+				{"wrong-write-alignment", read + strings.Replace(write, "align 1", "align 16", 1), 1, 1},
+				{"zero-count-extra-volatile-read", read, 0, 0},
+				{"zero-count-extra-volatile-write", write, 0, 0},
+				{"zero-count-nonvolatile-read", strings.Replace(read, "load volatile", "load", 1), 0, 0},
+				{"zero-count-nonvolatile-write", strings.Replace(write, "store volatile", "store", 1), 0, 0},
+				{"zero-count-wrong-read-width", strings.Replace(read, typ, "i128", 1), 0, 0},
+				{"zero-count-wrong-write-width", strings.Replace(write, typ, "i128", 1), 0, 0},
+				{"zero-count-wrong-read-alignment", strings.Replace(read, "align 1", "align 16", 1), 0, 0},
+				{"zero-count-wrong-write-alignment", strings.Replace(write, "align 1", "align 16", 1), 0, 0},
+				{"zero-count-nonvolatile-wrong-read-alignment", strings.ReplaceAll(strings.Replace(read, "load volatile", "load", 1), "align 1", "align 16"), 0, 0},
+				{"zero-count-nonvolatile-wrong-write-alignment", strings.ReplaceAll(strings.Replace(write, "store volatile", "store", 1), "align 1", "align 16"), 0, 0},
+				{"extra-wrong-read-width", read + write + strings.Replace(read, typ, "i128", 1), 1, 1},
+				{"extra-wrong-write-width", read + write + strings.Replace(write, typ, "i128", 1), 1, 1},
+				{"extra-wrong-read-alignment", read + write + strings.Replace(read, "align 1", "align 16", 1), 1, 1},
+				{"extra-wrong-write-alignment", read + write + strings.Replace(write, "align 1", "align 16", 1), 1, 1},
+				{"extra-nonvolatile-wrong-read-alignment", read + write + strings.ReplaceAll(strings.Replace(read, "load volatile", "load", 1), "align 1", "align 16"), 1, 1},
+				{"extra-nonvolatile-wrong-write-alignment", read + write + strings.ReplaceAll(strings.Replace(write, "store volatile", "store", 1), "align 1", "align 16"), 1, 1},
+			} {
+				t.Run(fmt.Sprintf("width=%d/%s/%s", width, ending, row.name), func(t *testing.T) {
+					body := row.body
+					if ending == "CRLF" {
+						body = strings.ReplaceAll(body, "\n", "\r\n")
+					}
+					if err := x86StringMemoryIRAccessError(body, width, row.reads, row.writes); err == nil {
+						t.Fatal("invalid memory observation was accepted", body)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86StringMemoryIRReaderEmptyZeroCount(t *testing.T) {
+	for _, body := range []string{"", "entry:\n  ret void\n", "entry:\r\n  ret void\r\n"} {
+		if err := x86StringMemoryIRAccessError(body, 4, 0, 0); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/x86_string_memory_ir_reader_test.go b/x86_string_memory_ir_reader_test.go
new file mode 100644
index 000000000..7245dcbc7
--- /dev/null
+++ b/x86_string_memory_ir_reader_test.go
@@ -0,0 +1,34 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// Keep this reader independent of the LLVM-backed fixture so its text boundary
+// and strict mutation controls can also run as an explicit Go file pair.
+func x86StringMemoryIRAccessError(body string, width, reads, writes int) error {
+	// LLVM's Windows textual printer uses CRLF. Normalize only that transport
+	// boundary, retaining the same exact volatile width/alignment predicates.
+	body = strings.ReplaceAll(body, "\r\n", "\n")
+	typ := fmt.Sprintf("i%d", 8*width)
+	read := regexp.MustCompile(`(?m)^  %[^\n]+ = load volatile ` + typ + `, ptr [^\n]+, align 1(?:,|$)`)
+	write := regexp.MustCompile(`(?m)^  store volatile ` + typ + ` [^\n]+, ptr [^\n]+, align 1(?:,|$)`)
+	gotReads, gotWrites := len(read.FindAllString(body, -1)), len(write.FindAllString(body, -1))
+	// The observed original helper, or its optimized entry/helper closure,
+	// has no other memory-storage role. Count every load/store instruction
+	// independently before checking the expected volatile type/alignment.
+	// An extra access cannot disappear merely by failing that exact predicate.
+	allReads := regexp.MustCompile(`(?m)^[ \t]*%[^\n=]+ = load\b[^\n]*$`)
+	allWrites := regexp.MustCompile(`(?m)^[ \t]*store\b[^\n]*$`)
+	if totalReads, totalWrites := len(allReads.FindAllString(body, -1)), len(allWrites.FindAllString(body, -1)); totalReads != gotReads || totalWrites != gotWrites {
+		return fmt.Errorf("string memory has an unexpected volatility, width or alignment: total read/write %d/%d, exact %d/%d\n%s",
+			totalReads, totalWrites, gotReads, gotWrites, body)
+	}
+	if gotReads != reads || gotWrites != writes {
+		return fmt.Errorf("lost or invented observable native memory: got read/write %d/%d, want %d/%d\n%s",
+			gotReads, gotWrites, reads, writes, body)
+	}
+	return nil
+}
diff --git a/x86_string_memory_original_go127_test.go b/x86_string_memory_original_go127_test.go
new file mode 100644
index 000000000..b2c1432f5
--- /dev/null
+++ b/x86_string_memory_original_go127_test.go
@@ -0,0 +1,134 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// These are structural original-Go/LLVM observations. They neither execute a
+// fault nor authenticate caller memory, bounds, a frame or an SDK function.
+func TestX86StringImplicitMemoryOriginalGoAndLLVMO0O2(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete implicit string objects require LLVM22 llc")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		rows := x86StringMemoryModeRows(arch)
+		for _, prefix := range []string{"", "REP", "REPN"} {
+			counts := []int{1}
+			if prefix != "" {
+				counts = append(counts, 0)
+			}
+			for _, count := range counts {
+				for _, backward := range []bool{false, true} {
+					name := fmt.Sprintf("%s/prefix=%s/count=%d/backward=%t", arch, prefix, count, backward)
+					t.Run(name, func(t *testing.T) {
+						source, declarations := x86StringMemoryFixture(rows, arch, prefix, count, backward)
+						file, err := Parse(ArchAMD64, source)
+						if err != nil || len(file.Funcs) != len(rows) {
+							t.Fatal("complete original source denominator changed", err)
+						}
+						goAssemblerOracleOutput(t, arch, source, "", true)
+						for _, api := range []string{"text", "module", "Go"} {
+							t.Run(api, func(t *testing.T) {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+								if err != nil {
+									t.Fatal("complete original source did not reach structural inspection", err)
+								}
+								for _, row := range rows {
+									body := x86StringMemoryFunction(t, ir, x86StringMemoryHelper(row))
+									x86StringMemoryCheckAccesses(t, body, row, row.reads, row.writes)
+								}
+								optimized := x86UndefinedTrapOptimizedIR(t, ir)
+								for _, row := range rows {
+									entry := "stringmem_" + strings.ToLower(row.op)
+									body := x86StringMemoryReachableIR(t, optimized, entry, make(map[string]bool))
+									reads, writes := row.reads, row.writes
+									if count == 0 {
+										reads, writes = 0, 0
+									}
+									x86StringMemoryCheckAccesses(t, body, row, reads, writes)
+								}
+								// O0 and O2 inspect the same complete translated source;
+								// no filtering or replacement of a dead-result function.
+								for _, row := range rows {
+									x86StringMemoryFunction(t, optimized, "stringmem_"+strings.ToLower(row.op))
+								}
+								for _, stage := range []struct {
+									name, ir string
+								}{{"ir0", ir}, {"ir2", optimized}} {
+									for _, backend := range []string{"-O0", "-O2"} {
+										t.Run(stage.name+"/backend"+backend[2:], func(t *testing.T) {
+											x86PackedStringCompileObject(t, llc, triple, stage.ir, backend)
+										})
+									}
+								}
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86StringMemoryCheckAccesses(t *testing.T, body string, row x86StringMemoryRow, reads, writes int) {
+	t.Helper()
+	if err := x86StringMemoryIRAccessError(body, row.width, reads, writes); err != nil {
+		t.Errorf("%s %v", row.op, err)
+	}
+}
+
+// O2 may inline or specialize an internal helper. Count its reachable body if
+// it remains instead of requiring one incidental inline decision. Only these
+// fixed internal test-observed helper names are followed; cycles are errors.
+func x86StringMemoryReachableIR(t *testing.T, ir, name string, active map[string]bool) string {
+	t.Helper()
+	if active[name] {
+		t.Fatal("recursive string helper is outside the bounded observation", name)
+	}
+	active[name] = true
+	defer delete(active, name)
+	body := x86StringMemoryFunction(t, ir, name)
+	calls := regexp.MustCompile(`\bcall [^\n]* @"?(__plan9asm_[A-Za-z0-9_.]+)"?\(`).FindAllStringSubmatch(body, -1)
+	var complete strings.Builder
+	complete.WriteString(body)
+	for _, call := range calls {
+		complete.WriteByte('\n')
+		complete.WriteString(x86StringMemoryReachableIR(t, ir, call[1], active))
+	}
+	return complete.String()
+}
+
+func TestX86StringRepeatCFGOriginalGoKeepsCompleteFixtures(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, shape := range []string{"adjacent", "fallthrough-label", "fallthrough-label-chain",
+			"branch-to-prefix", "pc-to-prefix", "loopback-to-prefix",
+			"conditional-bypass", "unreachable-prefix", "backedge-to-body", "pc-bypass", "unknown-indirect"} {
+			t.Run(arch+"/"+shape, func(t *testing.T) {
+				var source strings.Builder
+				for _, prefix := range []string{"REP", "REPN"} {
+					for _, row := range x86StringMemoryModeRows(arch) {
+						one, _ := x86StringRepeatCFGFixture(row, arch, prefix, shape)
+						name := "cfg_" + strings.ToLower(prefix+"_"+row.op)
+						one = strings.Replace(one, "·repeatcfg(SB)", "·"+name+"(SB)", 1)
+						source.WriteString(one)
+					}
+				}
+				file, err := Parse(ArchAMD64, source.String())
+				if err != nil || len(file.Funcs) != 2*len(x86StringMemoryModeRows(arch)) {
+					t.Fatal("original CFG batch lost a prefix, spelling or complete function", err)
+				}
+				goAssemblerOracleOutput(t, arch, source.String(), "", true)
+			})
+		}
+	}
+}
diff --git a/x86_string_repeat_cfg_test.go b/x86_string_repeat_cfg_test.go
new file mode 100644
index 000000000..1429c1d0a
--- /dev/null
+++ b/x86_string_repeat_cfg_test.go
@@ -0,0 +1,216 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86StringRepeatCFGBody(op, prefix, shape string) string {
+	switch shape {
+	case "adjacent":
+		return prefix + "\n" + op + "\n"
+	case "fallthrough-label":
+		return prefix + "\nconsume:\n" + op + "\n"
+	case "fallthrough-label-chain":
+		return prefix + "\nfirst:\nsecond:\nconsume:\n" + op + "\n"
+	case "branch-to-prefix":
+		return "JMP repeat\nrepeat:\n" + prefix + "\n" + op + "\n"
+	case "pc-to-prefix":
+		return "JMP 1(PC)\n" + prefix + "\n" + op + "\n"
+	case "loopback-to-prefix":
+		return "repeat:\n" + prefix + "\n" + op + "\nTESTL BX,BX\nJNE repeat\n"
+	case "conditional-bypass":
+		return "TESTL BX,BX\nJE consume\n" + prefix + "\nconsume:\n" + op + "\n"
+	case "unreachable-prefix":
+		return "JMP consume\n" + prefix + "\nconsume:\n" + op + "\n"
+	case "backedge-to-body":
+		return prefix + "\nconsume:\n" + op + "\nTESTL BX,BX\nJNE consume\n"
+	case "pc-bypass":
+		return "JMP 2(PC)\n" + prefix + "\n" + op + "\n"
+	case "unknown-indirect":
+		return "JMP BX\n" + prefix + "\n" + op + "\n"
+	default:
+		panic("unknown independent repeat CFG fixture")
+	}
+}
+
+func x86StringRepeatCFGFixture(row x86StringMemoryRow, arch, prefix, shape string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	return fmt.Sprintf(`TEXT ·repeatcfg(SB),4,$0-%d
+%s dst+0(FP),DI
+%s src+%d(FP),SI
+MOVL mode+%d(FP),BX
+MOVL $3,CX
+MOVL $19,AX
+CLD
+%sCLD
+RET
+`, 2*word+4, move, move, word, 2*word, x86StringRepeatCFGBody(row.op, prefix, shape)),
+		"func repeatcfg(dst,src *byte,mode uint32)\n"
+}
+
+func TestX86StringRepeatCFGAcceptsOnlyUnambiguousAdjacency(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, shape := range []string{"adjacent", "fallthrough-label", "fallthrough-label-chain",
+				"branch-to-prefix", "pc-to-prefix", "loopback-to-prefix"} {
+				for _, row := range x86StringMemoryModeRows(arch) {
+					// Repeat the complete family through the text consumer. The
+					// tool-backed owner separately retains all three public APIs.
+					t.Run(arch+"/"+prefix+"/"+shape+"/"+row.op, func(t *testing.T) {
+						source, declarations := x86StringRepeatCFGFixture(row, arch, prefix, shape)
+						if shape == "loopback-to-prefix" {
+							file, err := Parse(ArchAMD64, source)
+							if err != nil {
+								t.Fatal(err)
+							}
+							if _, err := x86ResultStringMemorySourcePlan(file.Funcs[0], arch); err != nil {
+								t.Fatal("the original loop lost its unambiguous prefix binding", err)
+							}
+							for _, api := range []string{"text", "module", "Go"} {
+								ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("prefix binding granted a reusable updated native cursor", api, err)
+								}
+							}
+							// The original Go loop remains unchanged in its object
+							// owner above. This separate positive replenishes the
+							// declared inputs on every iteration; it does not certify
+							// the original loop's updated-cursor memory contract.
+							begin := strings.IndexByte(source, '\n') + 1
+							label := strings.Index(source, "repeat:\n")
+							if begin <= 0 || label <= begin {
+								t.Fatal("complete independent loop fixture changed")
+							}
+							source = strings.Replace(source, "repeat:\n", "repeat:\n"+source[begin:label], 1)
+						}
+						ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, "text")
+						if err != nil || !strings.Contains(ir, "@"+x86StringMemoryHelper(row)+"(") {
+							t.Fatal("a uniquely executed prefix lost its complete typed follower", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringRepeatCFGRejectsBypassedOrAmbiguousPrefix(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			triple = "i386-unknown-linux-gnu"
+		}
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, shape := range []string{"conditional-bypass", "unreachable-prefix", "backedge-to-body", "pc-bypass", "unknown-indirect"} {
+				for _, row := range x86StringMemoryModeRows(arch) {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(arch+"/"+prefix+"/"+shape+"/"+row.op+"/"+api, func(t *testing.T) {
+							source, declarations := x86StringRepeatCFGFixture(row, arch, prefix, shape)
+							_, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api)
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("lexical source order cannot give an incoming edge the skipped REP/REPN byte", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringRepeatCFGFixtureKeepsActualBranchAndPrefixNodes(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, shape := range []string{"adjacent", "fallthrough-label", "fallthrough-label-chain",
+				"branch-to-prefix", "pc-to-prefix", "loopback-to-prefix",
+				"conditional-bypass", "unreachable-prefix", "backedge-to-body", "pc-bypass", "unknown-indirect"} {
+				for _, row := range x86StringMemoryModeRows(arch) {
+					source, _ := x86StringRepeatCFGFixture(row, arch, prefix, shape)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil || len(file.Funcs) != 1 {
+						t.Fatal("complete independent CFG fixture did not parse", err)
+					}
+					prefixes, followers := 0, 0
+					for _, ins := range file.Funcs[0].Instrs {
+						if ins.Op == Op(prefix) {
+							prefixes++
+						}
+						if ins.Op == Op(row.op) {
+							followers++
+						}
+					}
+					if prefixes != 1 || followers != 1 {
+						t.Fatal("fixture removed or duplicated the original prefix/follower", arch, prefix, shape, row)
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86StringRepeatCFGPortGrammarRemainsIndependent(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, prefix := range []string{"REP", "REPN"} {
+			for _, op := range []string{"INSB", "INSW", "INSL", "OUTSB", "OUTSW", "OUTSL"} {
+				sourceForShape := func(shape string) string {
+					return "TEXT port(SB),4,$0-0\nMOVL $3,CX\nMOVL $0,DX\nCLD\n" +
+						x86StringRepeatCFGBody(op, prefix, shape) + "RET\n"
+				}
+				for _, shape := range []string{"adjacent", "fallthrough-label-chain", "branch-to-prefix", "conditional-bypass"} {
+					t.Run(arch+"/"+prefix+"/"+op+"/"+shape, func(t *testing.T) {
+						file, err := Parse(ArchAMD64, sourceForShape(shape))
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir, err := Translate(file, Options{Goarch: arch, TargetTriple: testTargetTriple("linux", arch),
+							Sigs: map[string]FuncSig{"port": {Name: "port", Ret: Void}}})
+						if shape == "conditional-bypass" {
+							if !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("port I/O acquired a skipped prefix", err)
+							}
+							return
+						}
+						if err != nil || !strings.Contains(ir, "asm sideeffect") ||
+							!strings.Contains(ir, "; "+strings.ToLower(op)) {
+							t.Fatal("existing complete native port-I/O emitter changed", err)
+						}
+					})
+				}
+				if prefix == "REP" {
+					t.Run(arch+"/"+op+"/unspecified-target", func(t *testing.T) {
+						file, err := Parse(ArchAMD64, sourceForShape("adjacent"))
+						if err != nil {
+							t.Fatal(err)
+						}
+						ir, err := Translate(file, Options{Goarch: arch,
+							Sigs: map[string]FuncSig{"port": {Name: "port", Ret: Void}}})
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "native inline assembly") {
+							t.Fatal("native port-I/O escaped its explicit target requirement", ir != "", err)
+						}
+					})
+				}
+			}
+			for _, follower := range []string{"REP", "REPN", "NOP", "INB", "OUTL", "INSB AX", "OUTSL $1"} {
+				source := "TEXT bad(SB),4,$0-0\nJMP done\n" + prefix + "\n" + follower + "\ndone:\nRET\n"
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if _, err := Translate(file, Options{Goarch: arch, TargetTriple: testTargetTriple("linux", arch),
+					Sigs: map[string]FuncSig{"bad": {Name: "bad", Ret: Void}}}); err == nil {
+					t.Fatal("dead or malformed nonstring follower was silently skipped", arch, prefix, follower)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_symbol_declarations_test.go b/x86_symbol_declarations_test.go
new file mode 100644
index 000000000..ea05631c0
--- /dev/null
+++ b/x86_symbol_declarations_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86SymbolDeclarationsCompleteOperandRoles(t *testing.T) {
+	for _, row := range []struct {
+		name, op, operand string
+		want              bool
+	}{
+		{"plain read", "MOVL", "·cell(SB)", true},
+		{"plain address", "PUSHL", "$·cell(SB)", true},
+		{"base read", "MOVL", "·cell(SB)(AX)", true},
+		{"index read", "MOVL", "·cell+8(SB)(CX*4)", true},
+		{"base and index read", "MOVL", "·cell-8(SB)(AX)(CX*4)", true},
+		{"base write", "POPL", "·cell(SB)(AX)", true},
+		{"base address", "PUSHL", "$·cell(SB)(AX)", true},
+		{"index address", "PUSHL", "$·cell+8(SB)(CX*4)", true},
+		{"base and index address", "PUSHL", "$·cell-8(SB)(R8)(X1*4)", true},
+		{"indirect call", "CALL", "*·cell(SB)", true},
+		// The shared parser discards '*' on OpMem. Go's named grouped
+		// CALL progedit gives this its branch role, not an indirect read.
+		{"starred grouped branch", "CALL", "*·cell(SB)(AX)", false},
+		{"direct call", "CALL", "·cell(SB)", false},
+		{"grouped branch", "JMP", "·cell(SB)(AX)", false},
+		{"parameter read", "MOVL", "cell+0(FP)(AX)", false},
+		{"parameter address", "PUSHL", "$cell+0(FP)(AX)", false},
+		{"auto read", "MOVL", "cell-8(SP)(AX)", false},
+		{"auto address", "PUSHL", "$cell-8(SP)(AX)", false},
+		{"unnamed read", "MOVL", "8(AX)(CX*4)", false},
+		{"unnamed address", "PUSHL", "$8(AX)(CX*4)", false},
+		{"integer", "PUSHL", "$8", false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			operand, err := parseOperandForArch(ArchAMD64, row.operand)
+			if err != nil {
+				t.Fatal(err)
+			}
+			file := &File{Arch: ArchAMD64, Funcs: []Func{{
+				Sym: "·Value", Instrs: []Instr{{Op: Op(row.op), Args: []Operand{operand}}},
+			}}}
+			var output strings.Builder
+			emitExternSBGlobals(&output, file, testResolveSym("example"), nil)
+			want := ""
+			if row.want {
+				want = "@\"example.cell\" = external global i8\n\n"
+			}
+			if output.String() != want {
+				t.Fatalf("reference collection changed %s identity: got %q, want %q", row.operand, output.String(), want)
+			}
+		})
+	}
+}
+
+func TestX86SymbolDeclarationsPreserveDefinitionsAndNamespace(t *testing.T) {
+	const source = `TEXT ·Value(SB),4,$0-0
+PUSHL $·cell(SB)(AX)
+PUSHL $·cell+8(SB)(CX*4)
+PUSHL $other·cell-8(SB)(R8)(X1*4)
+PUSHL $private<>(SB)(AX)
+PUSHL $·defined(SB)(AX)
+PUSHL $·Value(SB)(AX)
+PUSHL $·helper(SB)(AX)
+RET
+GLOBL ·defined(SB),16,$8
+`
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var output strings.Builder
+	emitExternSBGlobals(&output, file, testResolveSym("example"), map[string]FuncSig{
+		"example.helper": {Name: "example.helper", Ret: Void},
+	})
+	const want = "@\"example.cell\" = external global i8\n" +
+		"@\"example.private\" = external global i8\n" +
+		"@\"other.cell\" = external global i8\n\n"
+	if output.String() != want {
+		t.Fatalf("declaration ownership, deduplication, ordering or namespace changed: got %q, want %q", output.String(), want)
+	}
+}
diff --git a/x86_symbolic_displacement.go b/x86_symbolic_displacement.go
new file mode 100644
index 000000000..46e2e7875
--- /dev/null
+++ b/x86_symbolic_displacement.go
@@ -0,0 +1,46 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go's symbolReference consumes one symbol, optional ABI/static attributes,
+// and then the entire signed constant expression before (SB). An unresolved
+// suffix must not become part of a different external symbol, even if a later
+// suffix is numerical (name+UNKNOWN+4). Keep this before raw normalization and
+// every lowerer, shared by the inventory probe and the full translation APIs.
+func validateX86SymbolDisplacement(operand Operand) error {
+	var source string
+	switch operand.Kind {
+	case OpSym:
+		source = strings.TrimSpace(operand.Sym)
+	case OpMem:
+		source = strings.TrimSpace(operand.Mem.Sym)
+	default:
+		return nil
+	}
+	source = strings.TrimSpace(strings.TrimPrefix(source, "*"))
+	source = strings.TrimSpace(strings.TrimPrefix(source, "$"))
+	group := x86SymbolPseudoGroup.FindStringSubmatchIndex(source)
+	if group == nil || source[group[2]:group[3]] != "SB" {
+		return nil
+	}
+	prefix := strings.TrimSpace(source[:group[0]])
+	separator := strings.IndexAny(prefix, "+-")
+	if separator < 1 {
+		return nil
+	}
+	expression := strings.TrimSpace(prefix[separator:])
+	if _, resolved := parseImmExpr(expression); resolved {
+		return nil
+	}
+	name := strings.TrimSpace(prefix[:separator])
+	for _, attribute := range []string{"<>", "<ABI0>", "<ABIInternal>"} {
+		name = strings.TrimSuffix(name, attribute)
+	}
+	if validPPIdentifier(name) && memoryOffsetExpressionNeedsContext(expression) {
+		return fmt.Errorf("%w: unresolved x86 symbol displacement %q in %q", ErrProbeNeedsContext, expression, source)
+	}
+	return fmt.Errorf("invalid x86 symbol displacement %q in %q", expression, source)
+}
diff --git a/x86_symbolic_displacement_test.go b/x86_symbolic_displacement_test.go
new file mode 100644
index 000000000..f412d8dc4
--- /dev/null
+++ b/x86_symbolic_displacement_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86SymbolicDisplacementsRequireConstants(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, body := range []string{
+			"CMPB ·flag+OFFSET(SB),$1",
+			"CMPW ·flag-OFFSET(SB),$1",
+			"CMPL ·flag+(OFFSET+4)(SB),$1",
+			"TESTB $1,·flag+OFFSET+4(SB)",
+			"TESTW $1,·flag-OFFSET+4(SB)",
+			"TESTL $1,·flag<>+OFFSET(SB)",
+			"MOVL ·flag+OFFSET(SB),AX",
+			"MOVL AX,·flag+OFFSET(SB)",
+			"LEAL ·flag+OFFSET(SB),AX",
+			"MOVL $·flag+OFFSET(SB),AX",
+		} {
+			t.Run(target.triple+"/"+body, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-0\n" + body + "\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", false)
+				goAssemblerOracleOutput(t, target.arch, "#define OFFSET 8\n"+source, "", true)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if err := ProbeInstruction(ArchAMD64, target.arch, file.Funcs[0].Instrs[1]); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Errorf("unresolved symbol displacement is not contextual: %v", err)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "OFFSET") {
+							t.Fatalf("unresolved offset became an external symbol or lost its diagnostic: %v (IR bytes=%d)", err, len(ir))
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ResolvedSymbolCompareDisplacementsFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, opcode := range []string{"CMPB", "CMPW", "CMPL", "CMPQ", "TESTB", "TESTW", "TESTL", "TESTQ"} {
+			if target.arch == "386" && strings.HasSuffix(opcode, "Q") {
+				continue // There is no Q-width Go encoder row in mode32.
+			}
+			t.Run(target.triple+"/"+opcode, func(t *testing.T) {
+				operands := "·flag<>+OFFSET(SB),$1"
+				if strings.HasPrefix(opcode, "TEST") {
+					operands = "$1,·flag<>+OFFSET(SB)"
+				}
+				source := "#define OFFSET (2*4)\nDATA ·flag<>+8(SB)/8,$17\nGLOBL ·flag<>(SB),8,$16\n" +
+					"TEXT ·view(SB),4,$0-0\n" + opcode + " " + operands + "\nRET\n"
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func view()\n", target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatalf("resolved source lost its translation: %v", err)
+						}
+						compileLLVMToObject(t, llc, target.triple, "symbol-offset.ll", "symbol-offset.o", ir)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_target_features_test.go b/x86_target_features_test.go
new file mode 100644
index 000000000..aa7c632ab
--- /dev/null
+++ b/x86_target_features_test.go
@@ -0,0 +1,105 @@
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Feature inference is independent of private SDK CPU layouts and is checked
+// on every supported Go version and host. The complete current SDK CRC32
+// source has its own actual-source/header/storage three-API object oracle.
+func TestX86CRC32AndCLMULTargetFeatures(t *testing.T) {
+	llc, _, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM 22 llc/clang not found")
+	}
+	const source = `TEXT ·CRC(SB),4,$0-24
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),CX
+CRC32Q AX,CX
+MOVQ CX,ret+16(FP)
+RET
+
+TEXT ·CLMUL(SB),4,$0-24
+MOVQ a+0(FP),AX
+MOVQ b+8(FP),CX
+MOVQ AX,X0
+MOVQ CX,X1
+PCLMULQDQ $0,X1,X0
+PEXTRQ $0,X0,AX
+MOVQ AX,ret+16(FP)
+RET
+`
+	if _, err := x86ScalarLiteralGoListing(t, "amd64", source); err != nil {
+		t.Fatal(err)
+	}
+	pkg := mustGoPackage(t, "literal", `package literal
+func CRC(a, b uint64) uint64
+func CLMUL(a, b uint64) uint64
+`)
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+		FileName: "features_amd64.s", GOARCH: "amd64", GOOS: "linux",
+		TargetTriple: "x86_64-unknown-linux-gnu", ResolveSym: testResolveSym(pkg.Path),
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ir := translated.Module.String()
+	translated.Module.Dispose()
+	requireCRC32TargetFeatures(t, ir)
+	compileLLVMToObject(t, llc, "x86_64-unknown-linux-gnu", "features.ll", "features.o", ir)
+}
+
+func requireCRC32TargetFeatures(t *testing.T, ir string) {
+	t.Helper()
+	if !hasTargetFeatures(ir, "+crc32", "+sse4.2") {
+		t.Fatal("missing crc32 target-features attribute")
+	}
+	if !hasTargetFeatures(ir, "+pclmul", "+sse4.1") {
+		t.Fatal("missing pclmul target-features attribute")
+	}
+}
+
+func hasTargetFeatures(ir string, features ...string) bool {
+	const marker = `"target-features"="`
+	for _, line := range strings.Split(ir, "\n") {
+		start := strings.Index(line, marker)
+		if start < 0 {
+			continue
+		}
+		value := line[start+len(marker):]
+		if end := strings.IndexByte(value, '"'); end >= 0 {
+			value = value[:end]
+		}
+		available := map[string]bool{}
+		for _, feature := range strings.Split(value, ",") {
+			available[feature] = true
+		}
+		for _, feature := range features {
+			if !available[feature] {
+				goto nextLine
+			}
+		}
+		return true
+	nextLine:
+	}
+	return false
+}
+
+func TestHasTargetFeaturesAllowsExtrasButRequiresOneExactSet(t *testing.T) {
+	ir := `attributes #7 = { "target-features"="+crc32,+sse4.2" }
+attributes #8 = { "target-features"="+bmi2,+pclmul,+sse4.1" }`
+	if !hasTargetFeatures(ir, "+pclmul", "+sse4.1") {
+		t.Fatal("extra target feature prevented matching the required set")
+	}
+	if hasTargetFeatures(ir, "+crc32", "+pclmul") {
+		t.Fatal("features from separate attributes were combined")
+	}
+	if hasTargetFeatures(ir, "+sse4") {
+		t.Fatal("partial feature name matched")
+	}
+}
diff --git a/x86_terminal_prefix_c_unix_test.go b/x86_terminal_prefix_c_unix_test.go
new file mode 100644
index 000000000..287627250
--- /dev/null
+++ b/x86_terminal_prefix_c_unix_test.go
@@ -0,0 +1,39 @@
+//go:build darwin || (linux && amd64)
+
+package plan9asm
+
+import (
+	"os"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/nativeoracle"
+)
+
+// Validate the real fork/wait signal fixture and translated x86 callbacks even
+// when this host cannot execute them. The Linux counterpart owns actual faults.
+func TestX86TerminalPrefixFaultCFixtureCompileLinkOnly(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 compiler/backend required for the actual C fault fixture")
+	}
+	triple := testTargetTriple(runtime.GOOS, "amd64")
+	compiler := []string{clang, "-target", triple}
+	if runtime.GOOS == "darwin" {
+		stage, cancel := runtimeOracleStageContext(t)
+		flags, err := nativeoracle.DarwinClangFlags(stage, os.Environ())
+		cancel()
+		if err != nil {
+			t.Fatal("actual macOS SDK required", err)
+		}
+		compiler = append(compiler, flags...)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: triple, compiler: compiler}
+	source, declarations := x86TerminalPrefixReadSource()
+	ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, "Go")
+	if err != nil {
+		t.Fatal("C fixture's actual translated callbacks rejected", err)
+	}
+	path := execution.compileLLVM(t, "terminal-prefix-fixture", ir, x86TerminalPrefixReadC(), "-O2")
+	t.Logf("actual C fault fixture compiled and linked target=%s executable=%s; NOT executed", triple, path)
+}
diff --git a/x86_terminal_prefix_objects_test.go b/x86_terminal_prefix_objects_test.go
new file mode 100644
index 000000000..a4a2f7d55
--- /dev/null
+++ b/x86_terminal_prefix_objects_test.go
@@ -0,0 +1,89 @@
+package plan9asm
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86TerminalPrefixReadSource() (string, string) {
+	var source, declarations strings.Builder
+	for index, family := range x86TerminalPrefixMechanismFixtures() {
+		fmt.Fprintf(&source, "TEXT ·TerminalRead%d(SB),4,$0-8\nMOVQ p+0(FP),AX\nMOVQ (AX),CX\n%s\nRET\n", index, family.instruction)
+		fmt.Fprintf(&declarations, "func TerminalRead%d(p *uint64)\n", index)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86ArchitecturalTerminalPrefixReadFaultOrderObjects(t *testing.T) {
+	llc, objdump := findLLVM22Tool("llc"), findLLVM22Tool("llvm-objdump")
+	if llc == "" || objdump == "" {
+		t.Fatal("LLVM22 llc and llvm-objdump required")
+	}
+	source, declarations := x86TerminalPrefixReadSource()
+	const triple = "x86_64-unknown-linux-gnu"
+	x86LEAActualTargetGoObject(t, "amd64", triple, source)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("original declared native-address prefix was not admitted", api, err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend-O0", "-O0", ir},
+				{"backend-O2", "-O2", ir},
+				{"IR-O2-backend-O2", "-O2", x86UndefinedTrapOptimizedIR(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					listing := x86FourSourceNativeObjectListing(t, llc, objdump, triple, pipeline.level, pipeline.ir)
+					sections := regexp.MustCompile(`(?m)^[0-9a-f]+ <(terminalread[0-7])>:\r?\n`).FindAllStringSubmatchIndex(listing, -1)
+					if len(sections) != 8 {
+						t.Fatal("all eight terminal mechanisms must remain visible in the actual object", len(sections))
+					}
+					for index, section := range sections {
+						name := listing[section[2]:section[3]]
+						end := len(listing)
+						if index+1 < len(sections) {
+							end = sections[index+1][0]
+						}
+						body := listing[section[1]:end]
+						t.Run(name, func(t *testing.T) {
+							var reads [][]int
+							for _, read := range regexp.MustCompile(`\bmovq\s+\(%(r[a-z0-9]+)\),\s*%[a-z0-9]+`).FindAllStringSubmatchIndex(body, -1) {
+								base := body[read[2]:read[3]]
+								if base != "rsp" && base != "rbp" {
+									reads = append(reads, read)
+								}
+							}
+							traps := regexp.MustCompile(`\bud2\b`).FindAllStringIndex(body, -1)
+							if len(reads) != 1 || len(traps) != 1 || reads[0][1] >= traps[0][0] {
+								t.Fatal("actual external qword read must survive before the architectural fault", name, body)
+							}
+							// Baseline AMD64 SSE2 scratch initialization is legal;
+							// the faulting original terminal requires no AVX ISA.
+							if strings.Contains(body, "%ymm") || strings.Contains(body, "%zmm") || strings.Contains(body, "\tv") {
+								t.Fatal("extra AVX ISA cannot precede the ordinary x86 fault counterpart", name, body)
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86ArchitecturalTerminalDoesNotAddUnexecutedNativeFeatures(t *testing.T) {
+	for _, family := range x86TerminalPrefixMechanismFixtures() {
+		t.Run(family.name, func(t *testing.T) {
+			terminal := x86ScalarLaneInstruction(t, family.instruction)
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", Func{Instrs: []Instr{terminal}}); got != "" {
+				t.Fatal("architectural #UD does not execute the source vector/non-temporal opcode", family.name, got)
+			}
+			ordinary := x86ScalarLaneInstruction(t, "RDRANDQ AX")
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, "amd64", Func{Instrs: []Instr{ordinary, terminal}}); got != "+rdrnd" {
+				t.Fatal("terminal feature projection changed an ordinary preceding instruction", family.name, got)
+			}
+		})
+	}
+}
diff --git a/x86_terminal_prefix_obligation_test.go b/x86_terminal_prefix_obligation_test.go
new file mode 100644
index 000000000..9e25e070f
--- /dev/null
+++ b/x86_terminal_prefix_obligation_test.go
@@ -0,0 +1,123 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// One concrete original-Go representative for each existing terminal mechanism.
+// Complete opcode/width/byte catalogs keep their existing independent owners.
+// These rows are not a production classifier or a native execution oracle.
+func x86TerminalPrefixMechanismFixtures() []struct{ name, instruction string } {
+	return []struct{ name, instruction string }{
+		{"undefined", "UNDEF"},
+		{"packed-move", "VMOVUPS.Z X1,K1,(AX)"},
+		{"compact", "VCOMPRESSPS.Z X1,K1,(AX)"},
+		{"single-source-narrow", "VPMOVDB.Z X1,K1,(AX)"},
+		{"insert-extract", "VEXTRACTF32X4.Z $0,Y1,K1,(AX)"},
+		{"named-half", "VCVTPS2PH.Z $7,X1,K1,(AX)"},
+		{"scalar-nontemporal", "MOVNTIL CX,AX"},
+		{"vector-nontemporal", "MOVNTPS X1,AX"},
+	}
+}
+
+func TestX86ArchitecturalTerminalKeepsPrefixMemoryObligations(t *testing.T) {
+	for _, family := range x86TerminalPrefixMechanismFixtures() {
+		for _, result := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/result=%t", family.name, result), func(t *testing.T) {
+				frame, returns := 0, ""
+				if result {
+					frame, returns = 8, " uint64"
+				}
+				declaration := "func TerminalPrefix()" + returns + "\n"
+				base := fmt.Sprintf("TEXT ·TerminalPrefix(SB),4,$0-%d\n%s\nRET\n", frame, family.instruction)
+				prefixes := []struct{ name, source string }{
+					{"pure-terminal", ""},
+					{"read", "MOVQ (AX),CX\n"},
+					{"known-data-store", "MOVQ $1,CX\nMOVQ CX,(AX)\n"},
+				}
+				for _, prefix := range prefixes {
+					source := strings.Replace(base, family.instruction, prefix.source+family.instruction, 1)
+					goAssemblerOracleOutput(t, "amd64", source, "", true)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					// Validate the original positive before judging its mutations.
+					const triple = "x86_64-unknown-linux-gnu"
+					ir, err := x86ScalarFPBitViewAPI(t, base, declaration, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete terminal positive was not admitted before prefix controls", family.name, api, err)
+					}
+					if _, err := x86OfficialMoveFaultBody(ir, "TerminalPrefix"); err != nil {
+						t.Fatal("terminal body must not need an incoming numerical/mask/address value", family.name, api, err)
+					}
+					for _, prefix := range prefixes {
+						t.Run(api+"/"+prefix.name, func(t *testing.T) {
+							source := strings.Replace(base, family.instruction, prefix.source+family.instruction, 1)
+							text, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+							if prefix.source == "" {
+								if err != nil || text == "" {
+									t.Fatal("pure terminal must retain its original no-input continuation", family.name, api, err)
+								}
+								return
+							}
+							if text != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("later architectural terminal authorized an earlier unknown address", family.name, prefix.name, api, err)
+							}
+						})
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86ArchitecturalTerminalKnownPrefixesRemainAdmitted(t *testing.T) {
+	for _, family := range x86TerminalPrefixMechanismFixtures() {
+		for _, prefix := range []struct{ name, declaration, source string }{
+			{"scalar-parameter", "x uint64", "MOVQ x+0(FP),CX\n"},
+			{"caller-read", "p *[8]byte", "MOVQ p+0(FP),AX\nMOVQ (AX),CX\n"},
+			{"caller-write", "p *[8]byte", "MOVQ p+0(FP),AX\nMOVQ $1,CX\nMOVQ CX,(AX)\n"},
+		} {
+			t.Run(family.name+"/"+prefix.name, func(t *testing.T) {
+				source := "TEXT ·TerminalPrefix(SB),4,$0-8\n" + prefix.source + family.instruction + "\nRET\n"
+				declaration := "func TerminalPrefix(" + prefix.declaration + ")\n"
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						text, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil || text == "" {
+							t.Fatal("terminal prefix lost an original declared numerical/address input", family.name, prefix.name, api, err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86ArchitecturalTerminalMixedReturnStillNeedsWrittenResults(t *testing.T) {
+	for _, complete := range []bool{true, false} {
+		write := ""
+		if complete {
+			write = "MOVQ $17,ret+8(FP)\n"
+		}
+		source := "TEXT ·MixedTerminal(SB),4,$0-16\nMOVQ x+0(FP),AX\nCMPQ AX,$0\nJE terminal\n" +
+			write + "RET\nterminal:\nUNDEF\n"
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(fmt.Sprintf("written=%t/%s", complete, api), func(t *testing.T) {
+				text, err := x86ScalarFPBitViewAPI(t, source, "func MixedTerminal(x uint64) uint64\n",
+					"amd64", "x86_64-unknown-linux-gnu", api)
+				if complete {
+					if err != nil || text == "" {
+						t.Fatal("complete normal return and separate terminal branch must both close", api, err)
+					}
+				} else if text != "" || !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("one trapping branch authorized another path's unwritten return", api, err)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_terminal_prefix_runtime_unix_test.go b/x86_terminal_prefix_runtime_unix_test.go
new file mode 100644
index 000000000..0ea9a05c9
--- /dev/null
+++ b/x86_terminal_prefix_runtime_unix_test.go
@@ -0,0 +1,121 @@
+//go:build unix
+
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86TerminalPrefixReadC() string {
+	var prototypes, names strings.Builder
+	for index := range x86TerminalPrefixMechanismFixtures() {
+		fmt.Fprintf(&prototypes, "extern void TerminalRead%d(uint64_t *);\n", index)
+		fmt.Fprintf(&names, "TerminalRead%d,\n", index)
+	}
+	return strings.NewReplacer("@PROTOTYPES@", prototypes.String(), "@FUNCTIONS@", names.String()).Replace(`
+#include <stdint.h>
+#include <signal.h>
+#include <stdio.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+@PROTOTYPES@
+int main(void) {
+    void (*functions[])(uint64_t *) = {@FUNCTIONS@};
+    unsigned observed = 0;
+    for (unsigned index = 0; index < sizeof(functions)/sizeof(functions[0]); ++index) {
+        for (int valid = 0; valid < 2; ++valid) {
+            pid_t child = fork();
+            if (child < 0) return 1;
+            if (child == 0) {
+                struct rlimit no_core = {0, 0};
+                if (setrlimit(RLIMIT_CORE, &no_core)) _exit(120);
+                uint64_t value = UINT64_C(0x123456789abcdef0);
+                functions[index](valid ? &value : (uint64_t *)0);
+                _exit(91);
+            }
+            int status = 0;
+            if (waitpid(child, &status, 0) != child) return 2;
+            int expected = valid ? SIGILL : SIGSEGV;
+            if (!WIFSIGNALED(status) || WTERMSIG(status) != expected) {
+                fprintf(stderr, "terminal-prefix index=%u valid=%d status=%x expected=%d\n", index, valid, status, expected);
+                return 3;
+            }
+            ++observed;
+        }
+    }
+    printf("terminal-prefix faults %u\n", observed);
+    return 0;
+}
+`)
+}
+
+func TestCrossLinuxRuntimeMatrixX86TerminalPrefixReadFaultOrder(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, declarations := x86TerminalPrefixReadSource()
+	var names strings.Builder
+	for index := range x86TerminalPrefixMechanismFixtures() {
+		fmt.Fprintf(&names, "TerminalRead%d,\n", index)
+	}
+	driver := strings.Replace(`package main
+import("os";"strconv";"syscall")
+func main() {
+    if err := syscall.Setrlimit(syscall.RLIMIT_CORE, &syscall.Rlimit{}); err != nil { panic(err) }
+    index, err := strconv.Atoi(os.Args[1]); if err != nil { panic(err) }
+    functions := []func(*uint64){@FUNCTIONS@}
+    value := uint64(0x123456789abcdef0)
+    pointer := &value
+    if os.Args[2] == "null" { pointer = nil }
+    functions[index](pointer)
+    os.Exit(91)
+}
+`, "@FUNCTIONS@", names.String(), 1)
+	goos := runtime.GOOS
+	if strings.Contains(execution.triple, "linux") {
+		goos = "linux"
+	}
+	original := x86OrderingHintBuildOriginal(t, t.TempDir(), goos, "amd64", "package main\n"+declarations, source, driver)
+	for index := range x86TerminalPrefixMechanismFixtures() {
+		for _, address := range []string{"null", "valid"} {
+			t.Run(fmt.Sprintf("original/%d/%s", index, address), func(t *testing.T) {
+				arguments := execution.command(original, fmt.Sprint(index), address)
+				stage, cancel := runtimeOracleStageContext(t)
+				command := exec.CommandContext(stage, arguments[0], arguments[1:]...)
+				command.Env = append(os.Environ(), "GOTRACEBACK=system")
+				output, err := runtimeOracleCombinedOutput(stage, command)
+				cancel()
+				exit, completed := err.(*exec.ExitError)
+				signal := "SIGSEGV"
+				if address == "valid" {
+					signal = "SIGILL: illegal instruction"
+				}
+				if !completed || exit.ProcessState == nil || !exit.ProcessState.Exited() || exit.ExitCode() != 2 ||
+					!strings.Contains(string(output), signal) || !strings.Contains(string(output), fmt.Sprint("main.TerminalRead", index)) {
+					t.Fatalf("original Go prefix/fault order lost a completed exact signal: %v\n%s", err, output)
+				}
+			})
+		}
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations, "amd64", execution.triple, api)
+		if err != nil {
+			t.Fatal("original prefix functions rejected", api, err)
+		}
+		for _, pipeline := range []struct{ name, level, ir string }{
+			{"backend-O0", "-O0", ir}, {"backend-O2", "-O2", ir},
+			{"IR-O2-backend-O2", "-O2", x86UndefinedTrapOptimizedIR(t, ir)},
+		} {
+			t.Run(api+"/"+pipeline.name, func(t *testing.T) {
+				output := execution.compileAndRunLLVM(t, "terminal-prefix", pipeline.ir, x86TerminalPrefixReadC(), pipeline.level)
+				if string(output) != "terminal-prefix faults 16\n" {
+					t.Fatalf("independent eight-mechanism null/valid-pointer fault observations: %q", output)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_ternary_gp_grammar_test.go b/x86_ternary_gp_grammar_test.go
new file mode 100644
index 000000000..83d44901a
--- /dev/null
+++ b/x86_ternary_gp_grammar_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86YmlYrlYrlCompleteIndependentGoRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/avx_optabs.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	table := regexp.MustCompile(`(?s)var _yandnl = \[\]ytab\{(.*?)\n\}`).FindStringSubmatch(text)
+	if len(table) != 2 || strings.Join(strings.Fields(table[1]), "") != "{zcase:Zvex_rm_v_r,zoffset:2,args:argList{Yml,Yrl,Yrl}}," {
+		t.Fatal("complete Go encoder operand classes, zcase or offset changed")
+	}
+	rows := regexp.MustCompile(`(?s)\{as: A((?:ANDN|PDEP|PEXT)[LQ]), ytab: _yandnl, prefix: Pavx, op: opBytes\{\s*([^,]+), (0x[0-9A-Fa-f]+),\s*\}\}`).FindAllStringSubmatch(text, -1)
+	if len(rows) != 6 || len(x86TernaryGPSpecs) != len(rows) {
+		t.Fatal("complete six-member grammar differs from Go", len(rows))
+	}
+	for _, row := range rows {
+		spec, ok := x86TernaryGPSpecs[Op(row[1])]
+		bits, prefix, operation, opcode := 32, 0, x86TernaryANDN, "0xF2"
+		attributes := "avxEscape|vex128|"
+		if strings.HasPrefix(row[1], "PDEP") {
+			prefix, operation, opcode = 3, x86TernaryPDEP, "0xF5"
+			attributes += "vexF2|"
+		} else if strings.HasPrefix(row[1], "PEXT") {
+			prefix, operation, opcode = 2, x86TernaryPEXT, "0xF5"
+			attributes += "vexF3|"
+		}
+		attributes += "vex0F38|vexW0"
+		if strings.HasSuffix(row[1], "Q") {
+			bits = 64
+			attributes = strings.Replace(attributes, "vexW0", "vexW1", 1)
+		}
+		if !ok || spec.bits != bits || spec.operation != operation || spec.prefix != prefix ||
+			strings.Join(strings.Fields(row[2]), "") != attributes || row[3] != opcode {
+			t.Fatal("typed spec or complete physical encoding differs from Go", row, spec)
+		}
+	}
+}
+
+func TestX86YmlYrlYrlRejectsBeforeEmission(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, name := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			ins := x86YMMReadSource(t, name+" AX,BX,CX")
+			for _, control := range []struct {
+				name   string
+				change func(*Instr)
+			}{
+				{"dispatch", func(i *Instr) { i.Op = "MOVL" }},
+				{"arity", func(i *Instr) { i.Args = i.Args[:2] }},
+				{"first", func(i *Instr) { i.Args[0].Reg = "X0" }},
+				{"second", func(i *Instr) { i.Args[1].Reg = "X0" }},
+				{"destination", func(i *Instr) { i.Args[2].Reg = "X0" }},
+				{"immediate", func(i *Instr) { i.Args[0] = Operand{Kind: OpImm, Imm: 1} }},
+			} {
+				t.Run(fmt.Sprintf("%s/%s/%s", arch, name, control.name), func(t *testing.T) {
+					bad := ins
+					bad.Args = append([]Operand(nil), ins.Args...)
+					control.change(&bad)
+					var ir strings.Builder
+					consumer := &amd64Ctx{b: &ir, goarch: arch}
+					lower := consumer.lowerParallelBitDepositExtract
+					if strings.HasPrefix(name, "ANDN") {
+						lower = consumer.lowerANDN
+					}
+					known, terminated, err := lower(Op(name), bad)
+					if !known || terminated || err == nil || ir.Len() != 0 {
+						t.Fatal("invalid source emitted before the complete grammar rejected it", known, err, ir.String())
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_ternary_gp_input_test.go b/x86_ternary_gp_input_test.go
new file mode 100644
index 000000000..a5263bd62
--- /dev/null
+++ b/x86_ternary_gp_input_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86YmlYrlYrlOrderedInputBytesAndDistinctStatus(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			width, flags := 4, uint8(x86ByteFlagsAll)
+			if arch == "amd64" && strings.HasSuffix(op, "Q") {
+				width = 8
+			}
+			if strings.HasPrefix(op, "ANDN") {
+				flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagSF | x86ByteFlagZF
+			}
+			for _, destination := range []struct {
+				reg   string
+				index int
+			}{{"CX", 1}, {"AX", 0}, {"BX", 3}} {
+				ins := x86YMMReadSource(t, op+" AX,BX,"+destination.reg)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || len(effect.operands) != 3 || !effect.requiresResultProof {
+					t.Fatal("complete source grammar lacks its ordered numerical effect", arch, op, known, err)
+				}
+				for ordinal, operand := range effect.operands {
+					if operand.index != ordinal || operand.width != int64(width) || operand.read != (ordinal < 2) || operand.write != (ordinal == 2) || !reflect.DeepEqual(operand.operand, ins.Args[ordinal]) {
+						t.Fatal("source read/overwrite or mode32 WIG width differs", arch, op, operand)
+					}
+				}
+				for missing := -1; missing < width*2; missing++ {
+					t.Run(fmt.Sprintf("%s/%s/%s/missing=%d", arch, op, destination.reg, missing), func(t *testing.T) {
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.gp[3] = 0xff, 0xff
+						if missing >= 0 {
+							index := 0
+							if missing >= width {
+								index = 3
+							}
+							state.gp[index] &^= 1 << uint(missing%width)
+						}
+						before := state.clone()
+						accepted := x86ResultTransfer(ins, &state, nil, 0, arch)
+						if accepted != (missing < 0) || !accepted && !reflect.DeepEqual(before, state) {
+							t.Fatal("aliased write hid missing input or changed rejected state", accepted)
+						}
+						if accepted {
+							before.gp[destination.index], before.flags = 0xff, flags
+							if !reflect.DeepEqual(before, state) {
+								t.Fatal("ternary GP effect changed unrelated state or undefined status knowledge")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_ternary_gp_native_fault_test.go b/x86_ternary_gp_native_fault_test.go
new file mode 100644
index 000000000..84083d152
--- /dev/null
+++ b/x86_ternary_gp_native_fault_test.go
@@ -0,0 +1,59 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryGPDeadReadPortableFaultBoundaries(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	var source, declarations, prototypes, rows strings.Builder
+	count := 0
+	for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+		bytes, second := 4, "0"
+		if strings.HasSuffix(op, "Q") {
+			bytes = 8
+		}
+		if strings.HasPrefix(op, "ANDN") {
+			second = "-1" // The numerical ANDN result is zero for every memory value.
+		}
+		for _, raw := range []bool{false, true} {
+			name := fmt.Sprint("Dead", count)
+			line := op + " (AX),BX,CX"
+			if raw {
+				line = x86RawNumericalInstruction(t, "amd64", line)
+			}
+			fmt.Fprintf(&source, "TEXT %s(SB),4,$0-8\nMOVQ source+0(FP),AX\nMOVQ $%s,BX\n%s\nRET\n", name, second, line)
+			fmt.Fprintf(&declarations, "func %s(source *byte)\n", name)
+			fmt.Fprintf(&prototypes, "extern void %s(const uint8_t*);\nstatic int run%s(const uint8_t *p) { %s(p); return 0; }\n", name, name, name)
+			fmt.Fprintf(&rows, "{run%s,%d,%d},\n", name, bytes, bytes-1)
+			count++
+		}
+	}
+	if count != 12 {
+		t.Fatal("complete named/raw dead-read fault directory changed", count)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := x86MemoryFaultDriver(prototypes.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal("original dead source rejected", err)
+			}
+			for _, optimize := range []bool{false, true} {
+				text := ir
+				if optimize {
+					text = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					executable := execution.compileLLVM(t, "ternary-dead-read", text, driver, level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, count)
+				}
+			}
+		})
+	}
+	// The reference is a volatile byte access, not the original BMI opcode.
+	t.Log("NULL, partial-page and complete-page native extents match portable translated dead reads")
+}
diff --git a/x86_ternary_gp_native_input_test.go b/x86_ternary_gp_native_input_test.go
new file mode 100644
index 000000000..cf805aab5
--- /dev/null
+++ b/x86_ternary_gp_native_input_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryGPDeadNativeReadsKeepExactWidthAndInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if word == 4 {
+			move = "MOVL"
+		}
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			bits := 32
+			if word == 8 && strings.HasSuffix(op, "Q") {
+				bits = 64
+			}
+			for _, raw := range []bool{false, true} {
+				line := op + " 3(AX)(DX*2),BX,CX"
+				if raw {
+					line = x86RawNumericalInstruction(t, target.arch, line)
+				}
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\nMOVL $1,DX\nMOVL $7,BX\n%s\nRET\n", word, move, line)
+				variants := []struct{ name, source string }{
+					{"initialized", source},
+					{"unknown-address", strings.Replace(source, move+" p+0(FP),AX", move+" p+0(FP),DI", 1)},
+					{"numerical-address", strings.Replace(source, move+" p+0(FP),AX", "MOVL $1,AX", 1)},
+					{"unknown-index", strings.Replace(source, "MOVL $1,DX\n", "", 1)},
+					{"unknown-second", strings.Replace(source, "MOVL $7,BX\n", "", 1)},
+				}
+				for _, variant := range variants {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/%s", target.triple, op, raw, variant.name), func(t *testing.T) {
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, variant.source, "func Value(p *[16]byte)", target.arch, target.triple, api)
+							if variant.name != "initialized" && variant.name != "numerical-address" {
+								if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("dead ternary GP borrowed an unknown native input", api, err)
+								}
+								continue
+							}
+							if err != nil {
+								t.Fatal("initialized dead native source rejected", api, err)
+							}
+							if variant.name == "numerical-address" {
+								x86RequireNumericNativeSourceContext(t, variant.source, "func Value(p *[16]byte)", target.arch)
+								x86NumericNativeAddressObject(t, ir, target.triple)
+							}
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								// A literal NUM address may justify stronger O2 alignment;
+								// the emitter still starts with the exact unaligned read.
+								if strings.Count(text, fmt.Sprintf("load volatile i%d,", bits)) != 1 || !strings.Contains(ir, ", align 1") || strings.Contains(text, "dereferenceable") {
+									t.Fatal("dead native ternary GP lost its exact unaligned volatile read", api)
+								}
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86TernaryGPUnusedBoolCannotHideMissingData(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			for _, raw := range []bool{false, true} {
+				line := op + " AX,BX,CX"
+				if raw {
+					line = x86RawNumericalInstruction(t, target.arch, line)
+				}
+				for _, missing := range []string{"", "MOVL $7,AX\n", "MOVL $3,BX\n"} {
+					source := "TEXT ·Value(SB),4,$0-1\nMOVL $7,AX\nMOVL $3,BX\n" + line + "\nRET\n"
+					if missing != "" {
+						source = strings.Replace(source, missing, "", 1)
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(unused bool)", target.arch, target.triple, api)
+						if missing == "" {
+							if err != nil || ir == "" {
+								t.Fatal("initialized Void/bool inputs rejected", target.triple, op, api, err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("unused bool hid a missing data input", target.triple, op, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_ternary_gp_original_driver_test.go b/x86_ternary_gp_original_driver_test.go
new file mode 100644
index 000000000..8c0d8fabe
--- /dev/null
+++ b/x86_ternary_gp_original_driver_test.go
@@ -0,0 +1,48 @@
+package plan9asm
+
+const x86ANDNOriginalRuntimeDriver = `
+#include <stdint.h>
+#include <string.h>
+extern void andnsemantics(uint8_t *);
+int main(void) {
+  uint8_t out[40] = {0};
+  andnsemantics(out);
+  const uint64_t want[3] = {UINT64_C(0x30), 0, UINT64_C(0x80000000)};
+  for (int i = 0; i < 3; i++) {
+    uint64_t got;
+    memcpy(&got, out + i * 8, sizeof(got));
+    if (got != want[i]) return 10 + i;
+  }
+  const uint8_t flags[12] = {0,0,0,0, 0,1,0,0, 0,0,1,0};
+  for (int i = 0; i < 12; i++) if (out[24+i] != flags[i]) return 30+i;
+  return 0;
+}
+`
+
+func x86ParallelBitsOriginalRuntimeDriver(declarations, checks string) string {
+	return `#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+` + declarations + `
+static uint64_t reference(uint64_t value,uint64_t mask,int bits,int deposit) {
+ if(bits==32) {value=(uint32_t)value;mask=(uint32_t)mask;}
+ uint64_t result=0,cursor=1;
+ while(mask) {uint64_t low=mask&(-mask);if(deposit ? (value&cursor)!=0 : (value&low)!=0) result|=deposit?low:cursor;mask&=mask-1;cursor<<=1;}
+ return result;
+}
+static int check(void (*fn)(uint64_t,const void *,void *),int bits,int deposit) {
+ uint64_t state=0x9e3779b97f4a7c15ULL;
+ for(int i=0;i<256;i++) {
+  state^=state<<13;state^=state>>7;state^=state<<17;uint64_t value=state;
+  state^=state<<13;state^=state>>7;state^=state<<17;uint64_t mask=state;
+  if(i==0)mask=0;if(i==1)mask=~(uint64_t)0;if(i>=2&&i<66)mask=(uint64_t)1<<(i-2);
+  uint8_t storage[9],out[16]={0};memcpy(storage+1,&mask,8);
+  fn(value,storage+1,out);uint64_t actual;memcpy(&actual,out,8);
+  const uint8_t flags[5]={0,0,1,1,1};
+  if(actual!=reference(value,mask,bits,deposit)||memcmp(out+8,flags,5)) {fprintf(stderr,"parallel bits mismatch bits=%d deposit=%d case=%d\n",bits,deposit,i);return 1;}
+ }
+ return 0;
+}
+int main(void) {
+` + checks + "return 0;\n}\n"
+}
diff --git a/x86_ternary_gp_original_fixture_test.go b/x86_ternary_gp_original_fixture_test.go
new file mode 100644
index 000000000..b9fb5e449
--- /dev/null
+++ b/x86_ternary_gp_original_fixture_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+const x86ANDNOriginalRuntimeSource = `TEXT andnsemantics(SB),$0-8
+	MOVQ out+0(FP), DI
+	MOVQ $0xf0, AX
+	MOVQ $0xcc, BX
+	ANDNQ AX, BX, CX
+	MOVQ CX, 0(DI)
+	SETCS 24(DI)
+	SETEQ 25(DI)
+	SETMI 26(DI)
+	SETOS 27(DI)
+	MOVQ $0, AX
+	MOVQ $0, BX
+	ANDNQ AX, BX, CX
+	MOVQ CX, 8(DI)
+	SETCS 28(DI)
+	SETEQ 29(DI)
+	SETMI 30(DI)
+	SETOS 31(DI)
+	MOVL $0x80000000, AX
+	MOVL $0, BX
+	ANDNL AX, BX, CX
+	MOVQ CX, 16(DI)
+	SETCS 32(DI)
+	SETEQ 33(DI)
+	SETMI 34(DI)
+	SETOS 35(DI)
+	RET
+`
+
+func x86ParallelBitsOriginalRuntimeFixture(t *testing.T) (source, decl, checks *strings.Builder, sigs map[string]FuncSig) {
+	t.Helper()
+	source, decl, checks = &strings.Builder{}, &strings.Builder{}, &strings.Builder{}
+	sigs = make(map[string]FuncSig)
+	index := 0
+	for _, op := range []string{"PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+		for _, memory := range []bool{false, true} {
+			for dst := 8; dst <= 10; dst++ {
+				name := fmt.Sprintf("parallelbits%d", index)
+				index++
+				fmt.Fprintf(source, "TEXT %s(SB),4,$0-24\n"+
+					"MOVQ value+0(FP),R8\nMOVQ mask+8(FP),SI\n"+
+					"MOVQ (SI),R9\nMOVQ out+16(FP),DI\nMOVQ $-1,R10\n"+
+					"MOVL $2147483647,CX\nADDL $1,CX\n", name)
+				mask := "R9"
+				if memory {
+					mask = "(SI)"
+				}
+				code := assembleX87ControlBytes(t, "amd64", fmt.Sprintf("TEXT probe(SB),4,$0-0\n%s %s,R8,R%d\nRET\n", op, mask, dst))
+				for _, b := range code[:len(code)-1] {
+					fmt.Fprintf(source, "BYTE $%#02x\n", b)
+				}
+				fmt.Fprintf(source, "MOVQ R%d,(DI)\nSETCS 8(DI)\nSETEQ 9(DI)\n"+
+					"SETPS 10(DI)\nSETMI 11(DI)\nSETOS 12(DI)\nRET\n", dst)
+				sigs[name] = FuncSig{
+					Name: name, Args: []LLVMType{I64, Ptr, Ptr}, Ret: Void,
+					Frame: FrameLayout{Params: []FrameSlot{
+						{Offset: 0, Type: I64, Index: 0, Field: -1},
+						{Offset: 8, Type: Ptr, Index: 1, Field: -1},
+						{Offset: 16, Type: Ptr, Index: 2, Field: -1},
+					}},
+				}
+				fmt.Fprintf(decl, "extern void %s(uint64_t,const void *,void *);\n", name)
+				bits, deposit := 32, 0
+				if strings.HasSuffix(op, "Q") {
+					bits = 64
+				}
+				if strings.HasPrefix(op, "PDEP") {
+					deposit = 1
+				}
+				fmt.Fprintf(checks, "if(check(%s,%d,%d)) return %d;\n", name, bits, deposit, index)
+			}
+		}
+	}
+	return
+}
diff --git a/x86_ternary_gp_original_objects_test.go b/x86_ternary_gp_original_objects_test.go
new file mode 100644
index 000000000..d68acda2a
--- /dev/null
+++ b/x86_ternary_gp_original_objects_test.go
@@ -0,0 +1,63 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryGPOriginalRuntimeObjects(t *testing.T) {
+	parallel, _, _, _ := x86ParallelBitsOriginalRuntimeFixture(t)
+	for _, row := range []struct{ name, source, declaration string }{
+		{"ANDN", x86ANDNOriginalRuntimeSource, "func andnsemantics(out *[40]byte)"},
+		{"parallel", parallel.String(), x86ParallelBitsOriginalDeclarations()},
+	} {
+		for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+			t.Run(row.name+"/"+triple, func(t *testing.T) {
+				x86RawNumericalFamilyObjects(t, row.source, row.declaration, "amd64", triple)
+			})
+		}
+	}
+}
+
+func TestX86YmlYrlYrlInitializedFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move := goWordSize(target.arch), "MOVQ"
+			if word == 4 {
+				move = "MOVL"
+			}
+			var source, declarations strings.Builder
+			count := 0
+			for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+				for _, memory := range []bool{false, true} {
+					for _, raw := range []bool{false, true} {
+						name, first := fmt.Sprintf("Value%d", count), "AX"
+						if memory {
+							first = "(SI)"
+						}
+						line := op + " " + first + ",BX,CX"
+						if raw {
+							line = x86RawNumericalInstruction(t, target.arch, line)
+						}
+						fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s value+0(FP),AX\n%s input+%d(FP),SI\n%s $-1,BX\n%s\n%s CX,ret+%d(FP)\nRET\n", name, word*3, move, move, word, move, line, move, word*2)
+						fmt.Fprintf(&declarations, "func %s(value uintptr,input *[8]byte) uintptr\n", name)
+						count++
+					}
+				}
+			}
+			if count != 24 {
+				t.Fatal("complete six-member named/raw register/memory grammar changed", count)
+			}
+			x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+		})
+	}
+}
+
+func x86ParallelBitsOriginalDeclarations() string {
+	var declarations string
+	for index := 0; index < 24; index++ {
+		declarations += fmt.Sprintf("func parallelbits%d(value uint64,mask *uint64,out *[16]byte)\n", index)
+	}
+	return declarations
+}
diff --git a/x86_ternary_gp_portable_runtime_test.go b/x86_ternary_gp_portable_runtime_test.go
new file mode 100644
index 000000000..63957bb89
--- /dev/null
+++ b/x86_ternary_gp_portable_runtime_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86ANDNOriginalPortableValuesAndStatus(t *testing.T) {
+	driver := strings.Replace(x86ANDNOriginalRuntimeDriver, "uint8_t out[40] = {0};", "uint8_t storage[42];\n  memset(storage,0xc3,sizeof(storage));\n  uint8_t *out=storage+1;", 1)
+	driver = strings.Replace(driver, "  return 0;", "  if(storage[0]!=0xc3 || storage[41]!=0xc3) return 1;\n  for(int byte=36;byte<40;byte++) if(out[byte]!=0xc3) return 1;\n  return 0;", 1)
+	if driver == x86ANDNOriginalRuntimeDriver || !strings.Contains(driver, "storage[41]") {
+		t.Fatal("independent original ANDN driver lost its unaligned canaries")
+	}
+	for _, raw := range []bool{false, true} {
+		source := x86ANDNOriginalRuntimeSource
+		if raw {
+			lines := strings.Split(source, "\n")
+			for index, line := range lines {
+				if strings.HasPrefix(strings.TrimSpace(line), "ANDN") {
+					lines[index] = x86RawNumericalInstruction(t, "amd64", strings.TrimSpace(line))
+				}
+			}
+			source = strings.Join(lines, "\n")
+		}
+		t.Run(fmt.Sprint("raw=", raw), func(t *testing.T) {
+			x86TernaryGPOriginalPortableExecution(t, source, "func andnsemantics(out *[40]byte)", driver)
+		})
+	}
+}
+
+func TestX86ParallelBitsOriginalPortableValuesAndStatus(t *testing.T) {
+	source, prototypes, checks, _ := x86ParallelBitsOriginalRuntimeFixture(t)
+	driver := x86ParallelBitsOriginalRuntimeDriver(prototypes.String(), checks.String())
+	driver = strings.Replace(driver, "uint8_t storage[9],out[16]={0};memcpy(storage+1,&mask,8);",
+		"uint8_t storage[10],before[10],outStorage[18];\n  memset(storage,0xc3,sizeof(storage));\n  memset(outStorage,0xc3,sizeof(outStorage));\n  uint8_t *out=outStorage+1;\n  memcpy(storage+1,&mask,8);\n  memcpy(before,storage,sizeof(storage));", 1)
+	driver = strings.Replace(driver, "fn(value,storage+1,out);uint64_t actual;",
+		"fn(value,storage+1,out);\n  if(memcmp(storage,before,sizeof(storage)) || outStorage[0]!=0xc3 || outStorage[17]!=0xc3) return 1;\n  for(int byte=13;byte<16;byte++) if(out[byte]!=0xc3) return 1;\n  uint64_t actual;", 1)
+	if !strings.Contains(driver, "outStorage[17]") || !strings.Contains(driver, "before,sizeof(storage)") {
+		t.Fatal("independent parallel-bit driver lost its input/output canaries")
+	}
+	x86TernaryGPOriginalPortableExecution(t, source.String(), x86ParallelBitsOriginalDeclarations(), driver)
+}
+
+// Execute the original source's numerical values on the actual host. This is
+// distinct from execution of the original BMI1/BMI2 physical opcode bytes.
+func x86TernaryGPOriginalPortableExecution(t *testing.T, source, declaration, driver string) {
+	t.Helper()
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+			if err != nil {
+				t.Fatal("original source lost its ordered numerical inputs", err)
+			}
+			for index, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					compileAndRunRuntimeTestForTarget(t, llc, clang,
+						fmt.Sprintf("ternary-%s-ir%d-%s", api, index, level[1:]), triple, text, driver, nil)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_ternary_gp_raw_origin_test.go b/x86_ternary_gp_raw_origin_test.go
new file mode 100644
index 000000000..4e3f5820a
--- /dev/null
+++ b/x86_ternary_gp_raw_origin_test.go
@@ -0,0 +1,82 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86TernaryGPRawOriginCannotSupplyInputsOrMemory(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"ANDNL", "ANDNQ", "PDEPL", "PDEPQ", "PEXTL", "PEXTQ"} {
+			for _, first := range []string{"AX", "(AX)"} {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, op+" "+first+",BX,CX")+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				if !x86RawTernaryGPSource(ins, arch) {
+					t.Fatal("complete original ternary source not recognized", arch, op, first)
+				}
+				for _, control := range []struct {
+					name   string
+					change func(*Instr)
+				}{
+					{"origin", func(i *Instr) { i.x86SourceRaw = nil }},
+					{"opcode", func(i *Instr) { i.Op = "MOVL" }},
+					{"operand", func(i *Instr) { i.Args[1].Reg = DX }},
+					{"source-operand", func(i *Instr) { i.x86SourceRaw.args[1].Reg = DX }},
+					{"vector", func(i *Instr) { i.x86VectorBytes = 16 }},
+					{"address", func(i *Instr) { i.x86AddressBits = 16 }},
+					{"override", func(i *Instr) { i.x86UnboundAddressOverride = true }},
+					{"segment", func(i *Instr) { i.x86SegmentPrefix = 0x64 }},
+					{"literal", func(i *Instr) { i.x86RIPLiteral = true }},
+				} {
+					t.Run(arch+"/"+op+"/"+first+"/"+control.name, func(t *testing.T) {
+						changed := ins
+						changed.Args = append([]Operand(nil), ins.Args...)
+						origin := *ins.x86SourceRaw
+						origin.args = append([]Operand(nil), origin.args...)
+						changed.x86SourceRaw = &origin
+						control.change(&changed)
+						state := x86ResultState{flags: x86ByteFlagsAll}
+						state.gp[0], state.gp[3] = 0xff, 0xff
+						before := state.clone()
+						accepted, _ := x86LoweredTernaryGPResultStep(changed, &state, nil, 0, arch)
+						if control.name == "origin" && first == "(AX)" {
+							want := before.clone()
+							want.gp[1] = 0xff
+							if strings.HasPrefix(op, "ANDN") {
+								want.flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+							}
+							if !accepted || x86RawTernaryGPSource(changed, arch) || !reflect.DeepEqual(state, want) {
+								t.Fatal("fresh named NUM read changed source/result/status roles")
+							}
+							return
+						}
+						if accepted || x86RawTernaryGPSource(changed, arch) || !reflect.DeepEqual(before, state) {
+							t.Fatal("changed raw source borrowed a numerical continuation", accepted)
+						}
+					})
+				}
+				if first == "(AX)" {
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					state.gp[0], state.gp[3] = 0xff, 0xff
+					before := state.clone()
+					want := before.clone()
+					want.gp[1] = 0xff
+					if strings.HasPrefix(op, "ANDN") {
+						want.flags = x86ByteFlagCF | x86ByteFlagOF | x86ByteFlagZF | x86ByteFlagSF
+					}
+					if accepted, known := x86LoweredTernaryGPResultStep(ins, &state, nil, 0, arch); !accepted || !known || !reflect.DeepEqual(want, state) {
+						t.Fatal("raw full NUM address lost its exact result/status transition", arch, op)
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_test_independent_flags_runtime_test.go b/x86_test_independent_flags_runtime_test.go
new file mode 100644
index 000000000..1927f19da
--- /dev/null
+++ b/x86_test_independent_flags_runtime_test.go
@@ -0,0 +1,88 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestCrossLinuxRuntimeMatrixX86TESTIndependentCarryFlags(t *testing.T) {
+	execution := x86FloatCompareExecutionTools(t)
+	source, declaration := x86TESTIndependentFlagSource("amd64")
+	goAssemblerOracleOutput(t, "amd64", source, "", true)
+	var prototypes, originals, pairs strings.Builder
+	for index, body := range x86TESTIndependentFlagCases("amd64") {
+		name, original := fmt.Sprintf("testFlags%d", index), fmt.Sprintf("original%d", index)
+		// The test-only SysV wrapper initializes actual physical scratch to
+		// diverse values. The translated function has no such numerical input.
+		// Only CF/OF are independent of these otherwise unavailable bits.
+		actual := x86PackedShiftActualGoBytes(t, "amd64", "TEXT native(SB),4,$0-0\n"+
+			"PUSHQ BX\nMOVQ DI,AX\nMOVQ DI,DX\nNOTQ DX\n"+body+"\n"+
+			x86TESTIndependentFlagPack+"MOVL DI,CX\nSHLQ $32,CX\nORQ CX,AX\nPOPQ BX\nRET\n")
+		if len(actual) == 0 || actual[len(actual)-1] != 0xc3 {
+			t.Fatal("incomplete original Go program", body, actual)
+		}
+		var bytes []string
+		for _, b := range actual {
+			bytes = append(bytes, fmt.Sprintf("0x%02x", b))
+		}
+		symbol := original
+		if strings.Contains(execution.triple, "apple") {
+			symbol = "_" + symbol
+		}
+		fmt.Fprintf(&originals, "__asm__(%q);\n", ".text\n.globl "+symbol+"\n"+symbol+":\n.byte "+strings.Join(bytes, ",")+"\n")
+		fmt.Fprintf(&prototypes, "extern uint64_t %s(uint64_t);\n", name)
+		prototypes.WriteString(x86OriginalSysVDeclaration("uint64_t", original, "uint64_t"))
+		fmt.Fprintf(&pairs, "{%s,%s},\n", name, original)
+	}
+	main := `#include <stdint.h>
+#include <stdio.h>
+` + prototypes.String() + originals.String() +
+		x86OriginalSysVPointer("uint64_t", "original_program", "uint64_t") + `
+typedef uint64_t (*program)(uint64_t);
+struct pair { program translated; original_program original; };
+static const struct pair pairs[]={
+` + pairs.String() + `};
+int main(void) {
+    const uint64_t seeds[]={0,1,127,128,255,256,32767,32768,65535,65536,
+        UINT64_C(0xffffffff),UINT64_C(0x100000000),UINT64_MAX,
+        UINT64_C(0x0123456789abcdef),UINT64_C(0x8000000000000000)};
+    for(unsigned i=0;i<sizeof(pairs)/sizeof(*pairs);++i) {
+        for(unsigned s=0;s<sizeof(seeds)/sizeof(*seeds);++s) {
+            uint64_t want=((uint64_t)(uint32_t)seeds[s]<<32)|UINT32_C(0x01010000);
+            uint64_t original=pairs[i].original(seeds[s]);
+            uint64_t translated=pairs[i].translated(seeds[s]);
+            if(original!=want || translated!=want) {
+                fprintf(stderr,"TEST=%u seed=%u Go=%llx LLVM=%llx want=%llx\n",
+                    i,s,(unsigned long long)original,(unsigned long long)translated,
+                    (unsigned long long)want);
+                return 1;
+            }
+        }
+    }
+    printf("%zu TEST programs x 15 scratch values: CF=OF=0\n",sizeof(pairs)/sizeof(*pairs));
+    return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", execution.triple, api)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir},
+				{"IR_O2/backend_O2", "-O2", x86MulDivRoundOptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					out := execution.compileAndRunLLVM(t, "test-independent-flags", pipeline.ir, main, pipeline.level)
+					want := fmt.Sprintf("%d TEST programs x 15 scratch values: CF=OF=0\n", len(x86TESTIndependentFlagCases("amd64")))
+					if string(out) != want {
+						t.Fatalf("unexpected original-Go/LLVM receipt: %q", out)
+					}
+					t.Log(strings.TrimSpace(string(out)))
+				})
+			}
+		})
+	}
+}
diff --git a/x86_test_independent_flags_test.go b/x86_test_independent_flags_test.go
new file mode 100644
index 000000000..7f06ff8a7
--- /dev/null
+++ b/x86_test_independent_flags_test.go
@@ -0,0 +1,213 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent inventory of the non-memory Go TEST rows. The existing compare
+// grammar still owns mode, immediate direction, register classes and memory.
+func x86TESTIndependentFlagCases(arch string) []string {
+	var cases []string
+	for _, suffix := range []string{"B", "W", "L", "Q"} {
+		if arch == "386" && suffix == "Q" {
+			continue
+		}
+		a, b := "AX", "DX"
+		if suffix == "B" {
+			a, b = "AL", "DL"
+		}
+		for _, operands := range []string{a + "," + a, b + "," + a, "$0," + a, "$-1," + a} {
+			cases = append(cases, "TEST"+suffix+" "+operands)
+		}
+	}
+	return append(cases, "TESTB AH,AL")
+}
+
+func TestX86TESTIndependentFlagsExactAvailability(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, body := range x86TESTIndependentFlagCases(arch) {
+			for _, flags := range []uint8{0, x86ByteFlagsAll} {
+				t.Run(fmt.Sprintf("%s/%s/flags%x", arch, body, flags), func(t *testing.T) {
+					ins := x86PureGPUnknownInstruction(t, body)
+					state := x86ResultState{flags: flags}
+					// Unrelated partial numerical bytes must survive exactly;
+					// TEST does not initialize even its own operand registers.
+					state.gp[3] = 0x5a
+					before := state.clone()
+					strict := state.clone()
+					if x86ScalarFPResultTransfer(ins, &strict, nil, 0, arch) {
+						t.Fatal("strict observer accepted unavailable TEST data")
+					}
+					if !x86LoweredPureGPUnknownTransfer(ins, &state, arch) {
+						t.Fatal("TEST lost its data-independent CF/OF writes")
+					}
+					before.flags = x86ByteFlagCF | x86ByteFlagOF
+					if !reflect.DeepEqual(state, before) {
+						t.Fatalf("TEST manufactured numerical/data-dependent availability: got GP=%x flags=%x, want GP=%x flags=%x",
+							state.gp, state.flags, before.gp, before.flags)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86TESTIndependentFlagsKeepStrictBoundaries(t *testing.T) {
+	for _, body := range []string{
+		"CMPB AL,AL", "CMPW AX,AX", "CMPL AX,AX", "CMPQ AX,AX",
+		"TESTB AL,(DX)", "TESTW AX,(DX)", "TESTL AX,(DX)", "TESTQ AX,(DX)",
+		"TESTB $0,(DX)", "TESTW $0,(DX)", "TESTL $0,(DX)", "TESTQ $0,(DX)",
+		"TESTL x+0(FP),AX", "TESTL $MISSING,AX", "TESTL $1.0,AX",
+	} {
+		t.Run(body, func(t *testing.T) {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			before := state.clone()
+			if x86LoweredPureGPUnknownTransfer(x86PureGPUnknownInstruction(t, body), &state, "amd64") ||
+				!reflect.DeepEqual(state, before) {
+				t.Fatal("TEST fallback skipped memory/grammar or accepted a data-dependent CMP")
+			}
+		})
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		for _, body := range x86TESTIndependentFlagCases(arch) {
+			ins := x86PureGPUnknownInstruction(t, body)
+			for _, mutation := range []string{"known", "pointer", "raw", "origin", "address", "segment"} {
+				t.Run(arch+"/"+body+"/"+mutation, func(t *testing.T) {
+					copy := ins
+					state := x86ResultState{flags: x86ByteFlagsAll}
+					switch mutation {
+					case "known":
+						for i := range state.gp {
+							state.gp[i] = 0xff
+						}
+					case "pointer":
+						state.pointerGP[0] = true
+					case "raw":
+						copy.x86Encoded = true
+					case "origin":
+						copy.x86SourceRaw = &x86SourceRawInstruction{}
+					case "address":
+						copy.x86AddressBits = 32
+					case "segment":
+						copy.x86SegmentPrefix = 0x64
+					}
+					before := state.clone()
+					if x86LoweredPureGPUnknownTransfer(copy, &state, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("unpaired TEST or opaque pointer acquired fallback", mutation)
+					}
+				})
+			}
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint32",
+				body+"\nMOVL $37,ret0+0(FP)\nRET")
+			for _, check := range []func(Func, FuncSig, string) error{
+				CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+			} {
+				if err := check(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("declaration-only observer acquired lowering permission", arch, body, err)
+				}
+			}
+		}
+	}
+}
+
+// Read all four CF/OF predicates before any packing arithmetic changes FLAGS.
+// CF=OF=0 therefore gives the independently specified result 0x01010000.
+const x86TESTIndependentFlagPack = `SETCS AL
+SETOS BL
+SETCC CL
+SETOC DL
+MOVBLZX AL,AX
+MOVBLZX BL,BX
+MOVBLZX CL,CX
+MOVBLZX DL,DX
+SHLL $8,BX
+SHLL $16,CX
+SHLL $24,DX
+ORL BX,AX
+ORL CX,AX
+ORL DX,AX
+`
+
+func x86TESTIndependentFlagSource(arch string) (string, string) {
+	var source, declarations strings.Builder
+	for index, body := range x86TESTIndependentFlagCases(arch) {
+		fmt.Fprintf(&declarations, "func testFlags%d(seed uint64) uint64\n", index)
+		// The actual scalar bit view selects the paired whole-source observer;
+		// the seed is deliberately not imported as AX/DX numerical authority.
+		fmt.Fprintf(&source, "TEXT ·testFlags%d(SB),4,$0-16\nMOVSS seed+0(FP),X0\n%s\n%sMOVL AX,ret+8(FP)\nMOVSS X0,ret+12(FP)\nRET\n",
+			index, body, x86TESTIndependentFlagPack)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86TESTIndependentFlagsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declaration := x86TESTIndependentFlagSource(target.arch)
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil {
+						t.Fatal(err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "test-flags.ll", "test-flags.o", ir)
+				})
+			}
+		})
+	}
+}
+
+func TestX86TESTIndependentFlagsDoNotGrantDependentInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for name, body := range map[string]string{
+			"numerical": "MOVL AX,CX",
+			"address":   "MOVL (AX),CX",
+			"store":     "MOVL AX,(DX)",
+			"memory":    "TESTL $0,(AX)",
+			"ZF":        "SETEQ CL",
+			"SF":        "SETMI CL",
+			"PF":        "SETPS CL",
+			"AF":        "LAHF",
+			"branchZF":  "JE done\ndone:",
+		} {
+			t.Run(target.triple+"/"+name, func(t *testing.T) {
+				source := "TEXT ·view(SB),4,$0-12\nMOVSS seed+0(FP),X0\nTESTL AX,AX\n" +
+					body + "\nMOVSS X0,ret+8(FP)\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view(seed uint64) uint32\n",
+						target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("TEST supplied unavailable data/flags", api, err)
+					}
+				}
+			})
+		}
+		for _, body := range x86TESTIndependentFlagCases(target.arch) {
+			t.Run(target.triple+"/pointer/"+body, func(t *testing.T) {
+				word, move := 8, "MOVQ"
+				if target.arch == "386" {
+					word, move = 4, "MOVL"
+				}
+				// A genuine incoming caller address already has a separate,
+				// legal TEST predicate role. That is not NUM: even an output
+				// subsequently overwritten must not import its pointer bits.
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\nMOVSS seed+%d(FP),X0\n%s p+0(FP),AX\n%s\nSETCS CL\nMOVL AX,ret+%d(FP)\nMOVSS X0,ret+%d(FP)\nRET\n",
+					word+12, word, move, body, word+8, word+8)
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, "func view(p *uint32,seed uint64) uint32\n",
+						target.arch, target.triple, api); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("TEST treated incoming pointer bits as a numerical input", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_text_argument_extent.go b/x86_text_argument_extent.go
new file mode 100644
index 000000000..4aebbc556
--- /dev/null
+++ b/x86_text_argument_extent.go
@@ -0,0 +1,29 @@
+package plan9asm
+
+import "strings"
+
+// Only the actual retained TEXT may distinguish unspecified args from zero.
+// This does not infer a layout: the ordinary typed declaration and every FP
+// access still need their complete independent bounds and input checks.
+func x86TEXTArgumentsUnspecified(fn Func) bool {
+	if fn.ArgSize != 0 || len(fn.Instrs) == 0 || fn.Instrs[0].Op != OpTEXT {
+		return false
+	}
+	op, rest := splitOpcode(fn.Instrs[0].Raw)
+	parts := strings.Split(rest, ",")
+	if !strings.EqualFold(op, "TEXT") || len(parts) < 2 || len(parts) > 3 ||
+		!strings.HasPrefix(strings.TrimSpace(parts[len(parts)-1]), "$") {
+		return false
+	}
+	frame, err := parseTEXTFrameSpec(parts)
+	return err == nil && !frame.argsSpecified && frame.frameSize == fn.FrameSize
+}
+
+// The native listing must retain the original TEXT's specified/unspecified
+// distinction. An omitted size obtains its layout only from the Go declaration.
+func goAMD64FrameArgumentsMatch(fn Func, native int64) bool {
+	if x86TEXTArgumentsUnspecified(fn) {
+		return native == -0x80000000 // objabi.ArgsSizeUnknown
+	}
+	return native == fn.ArgSize
+}
diff --git a/x86_text_argument_extent_go127_test.go b/x86_text_argument_extent_go127_test.go
new file mode 100644
index 000000000..ca2491f78
--- /dev/null
+++ b/x86_text_argument_extent_go127_test.go
@@ -0,0 +1,49 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// This consumes the complete original function and its SDK declaration, not
+// a rewritten $0-32 header. Objects do not claim execution or package linkage.
+func TestX86OmittedTEXTOriginalSubtleXORObjects(t *testing.T) {
+	directory := filepath.Join(runtime.GOROOT(), "src/crypto/internal/fips140/subtle")
+	source, err := os.ReadFile(filepath.Join(directory, "xor_amd64.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declaration, err := os.ReadFile(filepath.Join(directory, "xor_asm.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(source), "TEXT ·xorBytes(SB), NOSPLIT, $0\n") {
+		t.Fatal("actual omitted-TEXT source fixture changed")
+	}
+	pkg := mustGoPackage(t, "subtle", string(declaration))
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, string(source))
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewPackageAPI(t, string(source), pkg, "amd64", triple, api)
+				if err != nil {
+					t.Fatal("unchanged complete SDK xorBytes source rejected", api, err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_text_argument_extent_test.go b/x86_text_argument_extent_test.go
new file mode 100644
index 000000000..b08166d92
--- /dev/null
+++ b/x86_text_argument_extent_test.go
@@ -0,0 +1,124 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// cmd/asm preserves an omitted argument size as ArgsSizeUnknown, not zero.
+// An ordinary typed declaration still bounds every actual FP input; omission
+// grants neither an unbounded frame nor an explicit extent mismatch.
+func TestX86OmittedTEXTArgsKeepTypedVoidExtent(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct {
+			extent string
+			valid  bool
+		}{
+			{"$0", true}, {"$0-4", true}, {"$0-8", true},
+			{"$0-0", false}, {"$0-3", false}, {"$0-4097", false},
+		} {
+			t.Run(target.triple+"/"+row.extent, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4," + row.extent + "\nKMOVD value+0(FP),K1\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(value uint32)\n", target.arch, target.triple, api)
+					if !row.valid {
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("explicit TEXT mismatch gained typed argument authority", api, err)
+						}
+						continue
+					}
+					if err != nil {
+						t.Fatal("valid omitted or matching argument extent rejected", api, err)
+					}
+					compileLLVMToObject(t, llc, target.triple, "text-extent.ll", "text-extent.o", ir)
+				}
+			})
+		}
+	}
+}
+
+func TestParseTEXTArgumentSizeOmission(t *testing.T) {
+	for _, arch := range []Arch{ArchAMD64, ArchARM, ArchARM64, ArchWASM} {
+		for _, row := range []struct {
+			text        string
+			frame, args int64
+			specified   bool
+		}{
+			{"$0", 0, 0, false}, {"$-8", -8, 0, false},
+			{"$0-0", 0, 0, true}, {"$-8-4", -8, 4, true},
+			{"$16-8", 16, 8, true},
+		} {
+			file, err := Parse(arch, "TEXT ·Value(SB),4,"+row.text+"\nRET\n")
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatal("valid original TEXT failed", arch, row.text, err)
+			}
+			fn := file.Funcs[0]
+			_, rest := splitOpcode(fn.Instrs[0].Raw)
+			actual, err := parseTEXTFrameSpec(strings.Split(rest, ","))
+			if err != nil || actual.frameSize != row.frame || actual.argSize != row.args ||
+				actual.argsSpecified != row.specified || fn.FrameSize != row.frame || fn.ArgSize != row.args {
+				t.Fatal("TEXT lost its independent frame/argument-size axes", arch, row, actual, err)
+			}
+		}
+		if _, err := Parse(arch, "TEXT ·Value(SB),4,$0-\nRET\n"); err == nil {
+			t.Fatal("an explicit but missing argument integer became omission", arch)
+		}
+	}
+}
+
+func TestX86OmittedTEXTRequiresMatchingOriginalHeader(t *testing.T) {
+	for _, mutate := range []struct {
+		name  string
+		apply func(*Func)
+	}{
+		{"no-header", func(fn *Func) { fn.Instrs = fn.Instrs[1:] }},
+		{"empty-original", func(fn *Func) { fn.Instrs[0].Raw = "" }},
+		{"wrong-opcode", func(fn *Func) { fn.Instrs[0].Raw = "DATA ·Value(SB),4,$0" }},
+		{"explicit-zero", func(fn *Func) { fn.Instrs[0].Raw += "-0" }},
+		{"explicit-nonzero", func(fn *Func) { fn.Instrs[0].Raw += "-4" }},
+		{"dangling-argument", func(fn *Func) { fn.Instrs[0].Raw += "-" }},
+		{"changed-frame", func(fn *Func) { fn.FrameSize = 8 }},
+		{"changed-arguments", func(fn *Func) { fn.ArgSize = 4 }},
+	} {
+		t.Run(mutate.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0\nRET\n")
+			if err != nil || !x86TEXTArgumentsUnspecified(file.Funcs[0]) {
+				t.Fatal("original omitted-argument control rejected", err)
+			}
+			mutate.apply(&file.Funcs[0])
+			if x86TEXTArgumentsUnspecified(file.Funcs[0]) {
+				t.Fatal("missing or mismatched source header acquired omission")
+			}
+		})
+	}
+}
+
+func TestX86OmittedTEXTDoesNotInventInputOrStorage(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, declaration, body string }{
+			{"empty-declaration", "func Value()", "KMOVD value+0(FP),K1"},
+			{"partial-input", "func Value(value uint16)", "KMOVD value+0(FP),K1"},
+			{"past-input", "func Value(value uint32)", "KMOVD value+4(FP),K1"},
+			{"unknown-register", "func Value(value uint32)", "KMOVD AX,K1"},
+			{"physical-stack", "func Value(value uint32)", "KMOVD (SP),K1"},
+			{"unknown-memory", "func Value(value uint32)", "KMOVD (AX),K1"},
+			{"input-store", "func Value(value uint32)", "KMOVD value+0(FP),K1\nKMOVD K1,value+0(FP)"},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				source := "TEXT ·Value(SB),4,$0\n" + row.body + "\nRET\n"
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("unknown extent created an input or storage role", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_typed_byte_effects.go b/x86_typed_byte_effects.go
new file mode 100644
index 000000000..bd45740c9
--- /dev/null
+++ b/x86_typed_byte_effects.go
@@ -0,0 +1,282 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+// A descriptor records operand roles and machine effects only. Neither a
+// numerical input nor a native memory/frame/source capability can be obtained
+// from this record. Consumers must independently prove every required byte.
+type x86TypedByteOperand struct {
+	index         int
+	operand       Operand
+	width         int64
+	read          bool
+	write         bool
+	requiredBytes uint64 // Optional vector-register read mask; zero requires the full width.
+}
+
+type x86TypedByteEffect struct {
+	operands            []x86TypedByteOperand
+	vector              x86TypedVectorEffect
+	flagsRead           uint8
+	flagsDefined        uint8
+	flagsKilled         uint8
+	dynamicMemory       bool // A register-indexed bit string has no fixed base span.
+	requiresResultProof bool // Mandatory NUM/result obligation, independent of cost-only storage routing.
+}
+
+// Zero is deliberately unknown: an existing operand dependency alone does
+// not establish memory alignment or what happens to the upper vector alias.
+type x86TypedVectorEffect struct {
+	upperWrite      x86TypedVectorUpperWrite
+	memoryAlignment int64
+}
+
+type x86TypedVectorUpperWrite uint8
+
+const (
+	x86TypedVectorUpperUnknown x86TypedVectorUpperWrite = iota
+	x86TypedVectorUpperPreserve
+	x86TypedVectorUpperZero
+)
+
+const (
+	x86ByteFlagCF uint8 = 1 << iota
+	x86ByteFlagPF
+	x86ByteFlagAF
+	x86ByteFlagZF
+	x86ByteFlagSF
+	x86ByteFlagOF
+	x86ByteFlagsAll = x86ByteFlagCF | x86ByteFlagPF | x86ByteFlagAF | x86ByteFlagZF | x86ByteFlagSF | x86ByteFlagOF
+)
+
+type x86ExplicitIMULForm struct {
+	bits        int
+	immediate   Operand
+	source      Operand
+	destination Operand
+	three       bool
+}
+
+// Go's complete yimul/yimul3 explicit axis is W/L/Q: register or memory
+// source, the two immediate classes, and a Yrl result. One-operand IMUL is
+// a separate implicit-accumulator effect and is not silently admitted here.
+func x86ExplicitIMULProperties(op Op, ins Instr, arch string) (x86ExplicitIMULForm, bool, error) {
+	name := strings.ToUpper(string(op))
+	stem, bits, three, recognized := x86ScalarMultiplyDivideProperties(name)
+	if !recognized || stem != "IMUL" || bits == 8 {
+		return x86ExplicitIMULForm{}, false, nil
+	}
+	if !three && len(ins.Args) == 1 {
+		return x86ExplicitIMULForm{}, false, nil
+	}
+	fail := func(reason string) (x86ExplicitIMULForm, bool, error) {
+		return x86ExplicitIMULForm{}, true, fmt.Errorf("%s %s %s: %q", arch, op, reason, ins.Raw)
+	}
+	if arch != "amd64" && arch != "386" || arch == "386" && bits == 64 ||
+		ins.Op != "" && !strings.EqualFold(string(ins.Op), name) ||
+		three && len(ins.Args) != 3 || !three && len(ins.Args) != 2 {
+		return fail("has an unbound mode, dispatch identity or operand count")
+	}
+	sourceIndex := 0
+	if three {
+		sourceIndex = 1
+	}
+	if projected, segment, err := x86NamedSegmentMemorySource(ins, ins.Args[sourceIndex], arch); segment {
+		if err != nil {
+			return x86ExplicitIMULForm{}, true, err
+		}
+		ins.Args = append([]Operand(nil), ins.Args...)
+		ins.Args[sourceIndex] = projected
+	}
+	if err := validateX86ExplicitIMUL(arch, name, bits, ins, three); err != nil {
+		return x86ExplicitIMULForm{}, true, err
+	}
+	form := x86ExplicitIMULForm{bits: bits, source: ins.Args[0], destination: ins.Args[1], three: three}
+	if three {
+		form.immediate, form.source, form.destination = ins.Args[0], ins.Args[1], ins.Args[2]
+	}
+	for _, operand := range ins.Args {
+		if operand.Kind == OpImm && (operand.ImmRaw != "" || operand.ImmIsFloat) {
+			return fail("requires a resolved integer immediate")
+		}
+		if err := x86NamedMultiplyMemoryError(operand, arch); err != nil {
+			return fail(err.Error())
+		}
+	}
+	// These copies retain Go's actual encoded immediate, including W truncation
+	// and Q sign extension. Effects and lowering must not use different literal
+	// values; the original source/operands remain unchanged.
+	if form.source.Kind == OpImm {
+		form.source.Imm = x86IMULEncodedImmediate(form.source.Imm, bits)
+	}
+	if form.immediate.Kind == OpImm {
+		form.immediate.Imm = x86IMULEncodedImmediate(form.immediate.Imm, bits)
+	}
+	return form, true, nil
+}
+
+func x86TypedGPByteEffect(op Op, ins Instr, arch string) (x86TypedByteEffect, bool, error) {
+	if arch != "amd64" && arch != "386" {
+		return x86TypedByteEffect{}, false, nil
+	}
+	if effect, known, err := x86TypedScalarMoveAliasEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if op == ins.Op && x86PreservesNumericalSourceState(ins) {
+		return x86TypedByteEffect{}, true, nil
+	}
+	if known, err := x86SizedNOPProperties(ins, arch); known {
+		if op != ins.Op {
+			return x86TypedByteEffect{}, true, fmt.Errorf("sized NOP dispatch/source identity mismatch")
+		}
+		return x86TypedByteEffect{}, true, err
+	}
+	if effect, known, err := x86TypedAHFlagsEffect(op, ins, arch); known {
+		return effect, true, err
+	}
+	if effect, known, err := x86TypedSelfCompareByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedCarryControlByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedCounterControlByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedByteSwapEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarBitFieldByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedBLSByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedADXByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedTernaryGPByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMULXByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedMOVBEByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedLEAByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedBitTestByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarShiftByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedScalarBitCountByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if effect, known, err := x86TypedConditionalMoveByteEffect(op, ins, arch); known {
+		return effect, known, err
+	}
+	if form, recognized, err := x86LockScalarRMWProperties(op, ins, arch); recognized {
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		width := int64(form.spec.bits / 8)
+		zero := x86ScalarXORZeroRegister(form, width)
+		destinationIndex := 1
+		effect := x86TypedByteEffect{flagsDefined: form.spec.flagsDefined, flagsKilled: form.spec.flagsKilled}
+		if form.spec.unary {
+			destinationIndex = 0
+		} else {
+			effect.operands = append(effect.operands, x86TypedByteOperand{index: 0, operand: form.source, width: width, read: !zero})
+		}
+		if form.spec.stem == "ADC" || form.spec.stem == "SBB" {
+			effect.flagsRead = x86ByteFlagCF
+		}
+		effect.dynamicMemory = form.spec.bitString && form.source.Kind == OpReg && isAMD64MemoryOperand(form.destination)
+		effect.operands = append(effect.operands, x86TypedByteOperand{index: destinationIndex, operand: form.destination, width: width, read: !zero, write: true})
+		return effect, true, nil
+	}
+	if form, recognized, err := x86ScalarExtensionProperties(op, ins, arch); recognized {
+		if err != nil {
+			return x86TypedByteEffect{}, true, err
+		}
+		return x86TypedByteEffect{operands: []x86TypedByteOperand{
+			{index: 0, operand: form.source, width: int64(form.spec.sourceBits / 8), read: true},
+			{index: 1, operand: Operand{Kind: OpReg, Reg: form.result}, width: int64(form.spec.destinationBits / 8), write: true},
+		}}, true, nil
+	}
+	form, recognized, err := x86ExplicitIMULProperties(op, ins, arch)
+	if !recognized || err != nil {
+		return x86TypedByteEffect{}, recognized, err
+	}
+	return x86ExplicitIMULByteEffect(form), true, nil
+}
+
+func x86ExplicitIMULByteEffect(form x86ExplicitIMULForm) x86TypedByteEffect {
+	width := int64(form.bits / 8)
+	sourceIndex, destinationIndex := 0, 1
+	if form.three {
+		sourceIndex, destinationIndex = 1, 2
+	}
+	effect := x86TypedByteEffect{operands: []x86TypedByteOperand{
+		{index: sourceIndex, operand: form.source, width: width, read: true},
+		{index: destinationIndex, operand: form.destination, width: width, read: !form.three, write: true},
+	}, flagsDefined: x86ByteFlagCF | x86ByteFlagOF, flagsKilled: x86ByteFlagsAll}
+	if form.three {
+		effect.operands = append([]x86TypedByteOperand{{index: 0, operand: form.immediate, width: width, read: true}}, effect.operands...)
+	}
+	return effect
+}
+
+// Only a validated XOR row selecting the same physical GP bytes is independent
+// of its incoming value. AL/AX byte aliases are equivalent; AH/AL are not.
+// The grammar has already applied Go's actual REX byte view. This supplies no
+// memory, stack, caller or backing authority and defines no unwritten bytes.
+func x86ScalarXORZeroRegister(form x86LockScalarRMWForm, width int64) bool {
+	if form.spec.stem != "XOR" ||
+		!reflect.DeepEqual(form.source, Operand{Kind: OpReg, Reg: form.source.Reg}) ||
+		!reflect.DeepEqual(form.destination, Operand{Kind: OpReg, Reg: form.destination.Reg}) {
+		return false
+	}
+	source, sourceValid := x86CallerGP(form.source.Reg)
+	destination, destinationValid := x86CallerGP(form.destination.Reg)
+	mask := x86CallerByteMask(form.source.Reg, width)
+	return sourceValid && destinationValid && source == destination && mask != 0 &&
+		mask == x86CallerByteMask(form.destination.Reg, width)
+}
+
+func x86ByteConditionFlags(condition string) uint8 {
+	switch condition {
+	case "CC", "CS":
+		return x86ByteFlagCF
+	case "EQ", "NE":
+		return x86ByteFlagZF
+	case "GE", "LT":
+		return x86ByteFlagSF | x86ByteFlagOF
+	case "GT", "LE":
+		return x86ByteFlagSF | x86ByteFlagOF | x86ByteFlagZF
+	case "HI", "LS":
+		return x86ByteFlagCF | x86ByteFlagZF
+	case "MI", "PL":
+		return x86ByteFlagSF
+	case "OC", "OS":
+		return x86ByteFlagOF
+	case "PC", "PS":
+		return x86ByteFlagPF
+	}
+	return 0
+}
+
+func x86ByteBranchFlags(op Op) uint8 {
+	if spec, counter := x86CounterControlPropertiesForOpcode(op); counter {
+		return x86ByteConditionFlags(spec.condition)
+	}
+	return x86ByteConditionFlags(x86BranchCondition(op))
+}
diff --git a/x86_typed_byte_effects_test.go b/x86_typed_byte_effects_test.go
new file mode 100644
index 000000000..f4dd62202
--- /dev/null
+++ b/x86_typed_byte_effects_test.go
@@ -0,0 +1,217 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86TypedByteEffectsBindCompleteExplicitMultiplyTables(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for table, rows := range map[string]string{
+		"yimul":  `{Zm_o,2,argList{Yml}},{Zib_rr,1,argList{Yi8,Yrl}},{Zil_rr,1,argList{Yi32,Yrl}},{Zm_r,2,argList{Yml,Yrl}},`,
+		"yimul3": `{Zibm_r,2,argList{Yi8,Yml,Yrl}},{Zibm_r,2,argList{Yi32,Yml,Yrl}},`,
+	} {
+		match := regexp.MustCompile(`(?s)var ` + table + ` = \[\]ytab\{(.*?)\n\}`).FindSubmatch(data)
+		if len(match) != 2 || regexp.MustCompile(`\s+`).ReplaceAllString(string(match[1]), "") != rows {
+			t.Fatalf("complete actual Go %s rows changed", table)
+		}
+	}
+	rows := regexp.MustCompile(`\{A(IMUL3?[WLQ]), (yimul3?), (P[ewx]),`).FindAllStringSubmatch(string(data), -1)
+	if len(rows) != 6 {
+		t.Fatalf("explicit multiplication opcode directory changed: %v", rows)
+	}
+	for _, row := range rows {
+		wantTable, wantPrefix := "yimul", map[byte]string{'W': "Pe", 'L': "Px", 'Q': "Pw"}[row[1][len(row[1])-1]]
+		if strings.HasPrefix(row[1], "IMUL3") {
+			wantTable = "yimul3"
+		}
+		if row[2] != wantTable || row[3] != wantPrefix {
+			t.Fatalf("Go width/class row changed: %v", row)
+		}
+	}
+}
+
+func TestX86TypedByteEffectsExplicitMultiplyRolesWidthAndIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, suffix := range []string{"W", "L", "Q"} {
+			if suffix == "Q" && arch == "386" {
+				continue // Actual rejection rows are retained in the full form directory.
+			}
+			for _, body := range []string{
+				"IMUL" + suffix + " AX,BX", "IMUL" + suffix + " $-128,BX",
+				"IMUL" + suffix + " $4294967295,BX", "IMUL" + suffix + " x+0(FP),BX",
+				"IMUL3" + suffix + " $127,AX,BX", "IMUL3" + suffix + " $2147483648,x+0(FP),BX",
+			} {
+				t.Run(arch+"/"+body, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+body+"\nRET\n")
+					if err != nil {
+						t.Fatal(err)
+					}
+					ins := file.Funcs[0].Instrs[1]
+					before := fmt.Sprintf("%#v", ins)
+					form, recognized, err := x86TypedGPByteEffect(ins.Op, ins, arch)
+					if !recognized || err != nil || form.flagsDefined != x86ByteFlagCF|x86ByteFlagOF || form.flagsKilled != x86ByteFlagsAll {
+						t.Fatalf("explicit typed effect missing or flags inherited: %#v %v", form, err)
+					}
+					last := form.operands[len(form.operands)-1]
+					if last.width != map[string]int64{"W": 2, "L": 4, "Q": 8}[suffix] || !last.write || last.read == strings.HasPrefix(body, "IMUL3") {
+						t.Fatalf("wrong old-destination dependency: %#v", last)
+					}
+					for index, operand := range ins.Args {
+						if operand.Kind != OpFP {
+							continue
+						}
+						width, write, known := X86FPAccessBytes(ins, index, arch)
+						if !known || write || width != last.width {
+							t.Fatalf("descriptor/native width disagreement: %d %t %t", width, write, known)
+						}
+						mutated := ins
+						for _, invalid := range []Op{Op(strings.ToLower(string(ins.Op))), ins.Op + ".BAD"} {
+							mutated.Op = invalid
+							if _, _, known := X86FPAccessBytes(mutated, index, arch); known {
+								t.Fatal("constructed opcode acquired original FP width")
+							}
+						}
+					}
+					if after := fmt.Sprintf("%#v", ins); before != after {
+						t.Fatal("descriptor rewrote caller-owned instruction")
+					}
+				})
+			}
+		}
+	}
+	for _, body := range []string{
+		"IMULL $1.0,AX", "IMUL3L $MISSING,AX,BX", "IMUL3L AX,BX,CX", "IMULL X0,AX",
+		"IMUL3L $1,AX,(BX)", "IMULQ $4294967296,AX", "IMUL3Q $-2147483649,AX,BX",
+	} {
+		file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+body+"\nRET\n")
+		if err != nil {
+			t.Fatal(err)
+		}
+		ins := file.Funcs[0].Instrs[1]
+		if _, recognized, err := x86TypedGPByteEffect(ins.Op, ins, "amd64"); !recognized || err == nil {
+			t.Fatalf("invalid explicit form acquired effects: %s %v", body, err)
+		}
+	}
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\nIMUL3L $7,AX,BX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	ins := file.Funcs[0].Instrs[1]
+	for _, identity := range []Op{"", "imul3l", "IMUL3L"} {
+		copy := ins
+		copy.Op = identity
+		if _, recognized, err := x86TypedGPByteEffect("IMUL3L", copy, "amd64"); !recognized || err != nil {
+			t.Fatalf("matching/legacy helper dispatch regressed: %s %v", identity, err)
+		}
+	}
+	ins.Op = "IMULL"
+	if _, recognized, err := x86TypedGPByteEffect("IMUL3L", ins, "amd64"); !recognized || err == nil {
+		t.Fatal("contradictory dispatch identity acquired effects")
+	}
+}
+
+func TestX86TypedByteEffectsMultiplyBranchAliasesRevokeUndefinedFlags(t *testing.T) {
+	for _, branch := range []string{
+		"JE", "JEQ", "JZ", "JNE", "JNZ", "JL", "JLT", "JNGE", "JGE", "JNL", "JLE", "JNG", "JG", "JGT", "JNLE",
+		"JS", "JMI", "JNS", "JPL", "JA", "JHI", "JNBE", "JBE", "JLS", "JNA", "JP", "JPE", "JPS", "JNP", "JPO", "JPC",
+		"JAE", "JHS", "JNB", "JB", "JLO", "JNAE", "JC", "JCS", "JNC", "JCC", "JO", "JOS", "JNO", "JOC",
+	} {
+		t.Run(branch, func(t *testing.T) {
+			body := "MOVL $1,AX\nCMPL AX,$0\nIMUL3L $7,AX,BX\n" + branch + " other\nMOVB $1,ret0+0(FP)\nRET\nother:\nMOVB $2,ret0+0(FP)\nRET"
+			_, file, sig, source := x86ResultInitializationFixture(t, "amd64", "func Value() uint8", body)
+			goAssemblerOracleOutput(t, "amd64", source, "", true)
+			err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, "amd64")
+			required := x86ByteBranchFlags(Op(branch))
+			defined := required != 0 && required&^(x86ByteFlagCF|x86ByteFlagOF) == 0
+			if defined != (err == nil) {
+				t.Fatalf("branch reused undefined flags: %s %v", branch, err)
+			}
+		})
+	}
+}
+
+func TestX86TypedByteEffectsThreeAPIFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range []struct{ arch, triple string }{
+		{"amd64", "x86_64-apple-darwin"}, {"amd64", "x86_64-unknown-linux-gnu"}, {"amd64", "x86_64-pc-windows-msvc"},
+		{"386", "i386-unknown-linux-gnu"}, {"386", "i686-pc-windows-msvc"},
+	} {
+		t.Run(target.triple, func(t *testing.T) {
+			word, move, typ := 8, "MOVQ", "uint64"
+			if target.arch == "386" {
+				word, move, typ = 4, "MOVL", "uint32"
+			}
+			var body strings.Builder
+			fmt.Fprintf(&body, "%s x+0(FP),AX\n%s $0,BX\n%s AX,spill-16(SP)\n", move, move, move)
+			for _, op := range x86ExtensionTestOperations {
+				if target.arch == "386" && (op == "MOVBQSX" || op == "MOVBQZX" || op == "MOVWQSX" || op == "MOVWQZX" || op == "MOVLQSX") {
+					continue // Five exact current/old 386 rejected rows are tested independently.
+				}
+				fmt.Fprintf(&body, "%s spill-16(SP),BX\n", op)
+			}
+			for _, width := range []string{"W", "L", "Q"} {
+				if target.arch == "386" && width == "Q" {
+					continue
+				}
+				fmt.Fprintf(&body, "IMUL%s AX,BX\nIMUL%s $-7,BX\nIMUL3%s $65537,spill-16(SP),BX\n", width, width, width)
+			}
+			fmt.Fprintf(&body, "%s BX,ret0+%d(FP)\nRET", move, word)
+			pkg, _, sig, source := x86ResultInitializationFixture(t, target.arch, "func Value(x "+typ+") "+typ, body.String())
+			source = strings.Replace(source, ",$0-", ",$32-", 1)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			goAssemblerOracleOutput(t, target.arch, source, "", true)
+			if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch); err != nil {
+				t.Fatal(err)
+			}
+			options := Options{Goarch: target.arch, TargetTriple: target.triple, Sigs: map[string]FuncSig{"Value": sig},
+				ResolveSym: func(symbol string) string { return strings.TrimPrefix(symbol, "·") }}
+			before := fmt.Sprintf("%#v %#v", file, sig)
+			ir, err := Translate(file, options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, ir, "text")
+			ctx := llvm.NewContext()
+			defer ctx.Dispose()
+			module, err := TranslateModuleInContext(ctx, file, options)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, module.String(), "module")
+			translated, err := translateGoModuleInContext(ctx, pkg, []byte(source), GoModuleOptions{
+				GOARCH: target.arch, TargetTriple: target.triple, ResolveSym: options.ResolveSym,
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			x86ResultInitializationObject(t, llc, target.triple, translated.Module.String(), "typed-go")
+			if !reflect.DeepEqual(before, fmt.Sprintf("%#v %#v", file, sig)) {
+				t.Fatal("effect observation or API rewrote original input")
+			}
+		})
+	}
+}
diff --git a/x86_typed_mandatory_void_test.go b/x86_typed_mandatory_void_test.go
new file mode 100644
index 000000000..807022552
--- /dev/null
+++ b/x86_typed_mandatory_void_test.go
@@ -0,0 +1,113 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86MandatoryDescriptorObligationIndependentOfResultLayout(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		rows := []string{
+			"BEXTRL BX,AX,CX", "BZHIL BX,AX,CX", "BLSIL BX,AX",
+			"LAHF", "SAHF", "RDTSC", "RDTSCP", "CMPL AX,AX",
+			"VPCOMPRESSB X0,X1", "VPEXPANDQ X0,X1",
+		}
+		for _, op := range []string{"CRC32B", "CRC32W", "CRC32L", "MULB", "MULW", "MULL", "IMULB", "IMULW", "IMULL"} {
+			operand := "BX"
+			if strings.HasPrefix(op, "CRC32") {
+				operand += ",AX"
+			}
+			rows = append(rows, op+" "+operand)
+		}
+		if arch == "amd64" {
+			rows = append(rows, "CRC32Q BX,AX", "MULQ BX", "IMULQ BX")
+			for _, op := range x86ImmediateCompareResultMembers {
+				rows = append(rows, op+" $0,Z0,Z1,K2")
+			}
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof {
+					t.Fatal("independent mandatory descriptor witness changed", known, err)
+				}
+				fn := Func{Sym: "Value", Instrs: []Instr{ins}}
+				for _, result := range []LLVMType{Void, I32} {
+					if !x86TypedFPResultNeedsProof(fn, FuncSig{Name: "Value", Ret: result}, arch) {
+						t.Fatal("mandatory descriptor bypassed by Void or missing result layout", result)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MandatoryRawDescriptorCannotBypassResultLayout(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		// These decoded forms retain actual registered mandatory descriptors.
+		// Raw CRC/MUL have distinct unregistered physical roles; their named
+		// descriptors cannot serve as a witness for this metadata contract.
+		for _, row := range []string{"LAHF", "SAHF", "CMOVLLE BX,AX"} {
+			t.Run(arch+"/"+row, func(t *testing.T) {
+				file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				file, err = normalizeX86RawFile(file, arch)
+				if err != nil {
+					t.Fatal(err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || x86ResultNamedPredicateInstruction(ins) {
+					t.Fatal("raw mandatory descriptor witness changed", known, err)
+				}
+				for _, result := range []LLVMType{Void, I32} {
+					if !x86TypedFPResultNeedsProof(file.Funcs[0], FuncSig{Name: "Value", Ret: result}, arch) {
+						t.Fatal("raw syntax bypassed a mandatory descriptor", result)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86MandatoryCRCAndImplicitMultiplyVoidThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		var rows []string
+		for _, suffix := range []string{"B", "W", "L", "Q"} {
+			if target.arch == "386" && suffix == "Q" {
+				continue // These three Q spellings have no Go mode32 row.
+			}
+			rows = append(rows, "CRC32"+suffix+" BX,AX", "MUL"+suffix+" BX", "IMUL"+suffix+" BX")
+		}
+		var original strings.Builder
+		for index, row := range rows {
+			for _, initialized := range []bool{false, true} {
+				body := row + "\nRET\n"
+				if initialized {
+					body = "MOVL $3,AX\nMOVL $7,BX\n" + body
+				}
+				source := "TEXT Value(SB),4,$0-0\n" + body
+				name := fmt.Sprintf("Value%d_%t", index, initialized)
+				original.WriteString(strings.Replace(source, "Value(SB)", name+"(SB)", 1))
+				t.Run(fmt.Sprintf("%s/%s/initialized-%t", target.triple, row, initialized), func(t *testing.T) {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+						if initialized {
+							if err != nil || ir == "" {
+								t.Fatal("initialized mandatory inputs rejected", api, err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("dead numerical output hid missing inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, original.String())
+	}
+}
diff --git a/x86_typed_result_mixed_bool_test.go b/x86_typed_result_mixed_bool_test.go
new file mode 100644
index 000000000..f5116d7c6
--- /dev/null
+++ b/x86_typed_result_mixed_bool_test.go
@@ -0,0 +1,127 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestX86TypedNumericalMixedBoolCanonicalCompositionThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		operations := []string{"CRC32B BX,AX", "CRC32W BX,AX", "CRC32L BX,AX", "MULL BX", "BSWAPL AX"}
+		inputType, inputMove, inputOffset := "uint32", "MOVL", 4
+		if target.arch == "amd64" {
+			operations = append(operations, "CRC32Q BX,AX", "BSWAPQ AX")
+			inputType, inputMove, inputOffset = "uint64", "MOVQ", 8
+		}
+		for _, boolFirst := range []bool{false, true} {
+			declaration := fmt.Sprintf("func Value(crc,value %s) (uint32,bool)", inputType)
+			if boolFirst {
+				declaration = fmt.Sprintf("func Value(crc,value %s) (bool,uint32)", inputType)
+			}
+			_, _, sig, _ := x86ResultInitializationFixture(t, target.arch, declaration, "RET")
+			var boolean, number int64
+			for _, slot := range sig.Frame.Results {
+				if slot.Type == I1 {
+					boolean = slot.Offset
+				} else {
+					number = slot.Offset
+				}
+			}
+			for _, operation := range operations {
+				scenarios := []string{"canonical-mask", "raw-two", "unmasked-number", "unknown-accumulator", "missing-number"}
+				if operation == "BSWAPQ AX" {
+					// A prior MOVL makes the high half zero; BSWAPQ then
+					// legitimately produces a canonical low byte without AND.
+					scenarios = append(scenarios, "zero-extended-input")
+				}
+				for _, scenario := range scenarios {
+					body := fmt.Sprintf("%s value+%d(FP),BX\n", inputMove, inputOffset)
+					if scenario != "unknown-accumulator" {
+						move := inputMove
+						if scenario == "zero-extended-input" {
+							move = "MOVL"
+						}
+						body += move + " crc+0(FP),AX\n"
+					}
+					body += operation + "\n"
+					if scenario != "missing-number" {
+						body += fmt.Sprintf("MOVL AX,ret+%d(FP)\n", number)
+					}
+					switch scenario {
+					case "raw-two":
+						body += "MOVL $2,AX\n"
+					case "unmasked-number", "zero-extended-input":
+						// Initialized arithmetic bytes alone never witness zero/one.
+					default:
+						body += "ANDL $1,AX\n"
+					}
+					body += fmt.Sprintf("MOVB AX,ret+%d(FP)\nRET", boolean)
+					_, file, sig, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					if scenario == "missing-number" && !errors.Is(CheckX86ABI0ResultInitialization(file.Funcs[0], sig, target.arch), ErrProbeNeedsContext) {
+						t.Fatal("the strict numerical-result audit must retain its original failure")
+					}
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/bool-first=%t/%s/%s/%s", target.triple, boolFirst, operation, scenario, api), func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if scenario == "canonical-mask" || scenario == "zero-extended-input" || scenario == "missing-number" {
+								if err != nil || ir == "" {
+									t.Fatalf("complete typed NUM/canonical tuple rejected: output=%t error=%v", ir != "", err)
+								}
+								if scenario == "missing-number" {
+									llc := findLLVM22Tool("llc")
+									if llc == "" {
+										t.Fatal("LLVM22 llc required")
+									}
+									x86ResultInitializationObject(t, llc, target.triple, ir, "typed-partial-numeric-tuple")
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatalf("unproved arithmetic bool tuple accepted: output=%t error=%v", ir != "", err)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86TypedNumericalMixedBoolRequiresLiveCachedCanonicalRole(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, raw := range []int{1, 2} {
+			t.Run(fmt.Sprintf("%s/raw=%d", arch, raw), func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch,
+					"func Value() (bool,uint32)",
+					fmt.Sprintf("MOVL $7,AX\nBSWAPL AX\nMOVL AX,ret+4(FP)\nMOVB $%d,ret+0(FP)\nRET", raw))
+				fn := file.Funcs[0]
+				fn.x86ResultFlowBudget = &x86ResultFlowBudget{}
+				consumer := &amd64Ctx{goarch: arch, sig: sig, fpResults: sig.Frame.Results, fpScalarSource: fn}
+				if raw == 2 {
+					// A stale private role bit cannot turn a failed complete proof
+					// into a canonical result or physical-I8 storage permission.
+					consumer.fpMixedBoolBytes = true
+					if err := consumer.integerEffectResultInitialized("test"); !errors.Is(err, ErrProbeNeedsContext) || consumer.abi0BoolResultByteStorage() {
+						t.Fatal("failed canonical proof borrowed a role bit", err)
+					}
+					return
+				}
+				if err := consumer.scalarFPResultInitialized(); err != nil {
+					t.Fatal("independent whole canonical proof failed", err)
+				}
+				used := *fn.x86ResultFlowBudget
+				if err := consumer.integerEffectResultInitialized("test"); !errors.Is(err, ErrProbeNeedsContext) || consumer.abi0BoolResultByteStorage() {
+					t.Fatal("initialization alone created a live canonical storage role", err)
+				}
+				if err := consumer.validateMixedBoolResultRole(); err != nil || !consumer.fpMixedBoolBytes || !consumer.abi0BoolResultByteStorage() {
+					t.Fatal("actual canonical tuple did not acquire its existing role", err)
+				}
+				if err := consumer.integerEffectResultInitialized("test"); err != nil {
+					t.Fatal("generic NUM consumer discarded the proved canonical role", err)
+				}
+				if used != *fn.x86ResultFlowBudget {
+					t.Fatal("composition repeated or bypassed the shared whole-proof budget")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_typed_result_obligation.go b/x86_typed_result_obligation.go
new file mode 100644
index 000000000..ecc1a7fb1
--- /dev/null
+++ b/x86_typed_result_obligation.go
@@ -0,0 +1,270 @@
+package plan9asm
+
+// Unlike a MOV-store cost selector, a registered numerical family has its own
+// whole-result obligation. Missing result stores, unused bool inputs and other
+// storage operations cannot substitute for initialized source/result bytes.
+// Independently bound entry/storage roles are consumed by the complete cached
+// proof; this syntax-only routing decision never grants one.
+func x86TypedFPResultNeedsProof(fn Func, sig FuncSig, arch string) bool {
+	if arch != "386" && arch != "amd64" {
+		return false
+	}
+	if amd64RegisterTupleResultNeedsProof(fn, sig, arch) {
+		return true // Plain MOV/RET and invalid layouts cannot bypass register-result initialization.
+	}
+	if len(sig.Frame.Results) > 1 && len(x86ScalarTupleResultTypes(sig, arch)) != 0 &&
+		x86OrdinaryScalarCodegenSource(fn, sig, arch) {
+		return true // Every lowering route keeps tuple input/layout checks before its output-only exception.
+	}
+	if x86LogicalScalarResultNeedsProof(sig, arch) {
+		return true // An absent or partial AX write must not borrow implementation zeroes.
+	}
+	if x86StaticIntegerResultSourceCandidate(fn, sig, arch) {
+		return true
+	}
+	for _, ins := range x86X87FlowInstructions(fn) {
+		if _, known, err := x86X87EnvironmentReadProperties(ins, arch); known && err == nil {
+			return true // Dead environment reads retain input and stack obligations for Void.
+		}
+		if form, known, err := x86X87ValueProperties(ins, arch); known && err == nil &&
+			(form.spec.kind == x86X87FloatMove || form.spec.kind == x86X87IntegerMove || form.spec.kind == x86X87Round ||
+				form.spec.kind == x86X87ConditionalMove) && (form.memoryBytes() == 10 || x86ResultNamedPredicateInstruction(ins)) {
+			return true // Input/control/stack obligations also apply to Void; private slots cannot supply unknown facts.
+		}
+	}
+	opaqueAddressResult := x86OpaqueAddressPointerResultRole(fn, sig, arch)
+	for ordinal, ins := range fn.Instrs {
+		if ins.Op == "SYSCALL" {
+			return true // Every source argument and the target-aware raw transition remain obligations, including Void.
+		}
+		if form, known, err := x86ScalarCompareProperties(ins.Op, ins, arch); known && err == nil && form.memory >= 0 {
+			return true // Dead compare/test FLAGS do not remove the original faulting read or its inputs.
+		}
+		if _, terminal, err := x86UndefinedTrapProperties(ins.Op, ins, arch); terminal && err == nil {
+			return true // Only this instruction has no inputs; earlier effects still need complete proof.
+		}
+		if form, known, err := x86NamedHalfProperties(ins.Op, ins, arch); known && err == nil && !form.undefinedOpcode() {
+			return true // Void still consumes active source, merge, mask and native address inputs.
+		}
+		if _, known, err := x86ExplicitMaskMoveProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Dead loads/stores retain actual masks, data and address obligations.
+		}
+		if form, known, err := x86VSIBProperties(ins, arch); known && err == nil && !form.prefetch {
+			return true // Dead indexed accesses retain index, mask, merge/data and address inputs.
+		}
+		if _, known, err := x86FloatMinMaxProperties(ins, arch); known && err == nil {
+			return true // Dead MIN/MAX still consumes actual lane, merge and mask inputs.
+		}
+		if form, known, err := amd64PackedVectorMoveProperties(ins, arch); known && err == nil && !form.undefinedOpcode() &&
+			(ins.x86SourceRaw != nil || ins.x86Encoded ||
+				form.ordinaryMemory(ins, arch) && x86ResultNamedPredicateInstruction(ins)) {
+			return true // Raw/native move inputs, masks and addresses remain obligations even for Void.
+		}
+		if form, known, err := amd64ScalarVectorMoveProperties(ins, arch); known && err == nil &&
+			(!form.spec.legacy || form.memoryWrite) && !form.spec.rawOnly &&
+			(ins.x86SourceRaw != nil || ins.x86Encoded ||
+				form.memory >= 0 && x86ScalarVectorMoveOrdinaryMemory(ins.Args[form.memory], form.spec.bits, arch) &&
+					x86ResultNamedPredicateInstruction(ins)) {
+			return true // Scalar dead reads/writes retain exact active native effects and source bytes.
+		}
+		if _, known, err := x86DuplicateMoveProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Dead duplicate moves still need selected bytes, masks, merges and native accesses.
+		}
+		if _, known, err := x86MOVBEProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Both native directions retain their complete input obligations, including Void.
+		}
+		if _, known, err := x86TernaryGPProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Both actual input words remain mandatory for named/raw dead outputs.
+		}
+		if _, known, err := x86ADXProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Both input words and the selected CF/OF chain remain obligations for raw/named Void.
+		}
+		if _, known, err := x86MULXProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Unknown scratch products stay unknown; observable results and native inputs need complete proof.
+		}
+		if _, known, err := x86ScalarShiftProperties(ins.Op, ins, arch); known && err == nil {
+			return true // A paired ISA choice needs actual inputs; Void/unused bool cannot opt out.
+		}
+		if _, known, err := x86AccumulatorSignExtendProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Raw/named implicit AX inputs remain mandatory even for a dead Void result.
+		}
+		if _, known, err := x86ImplicitDivideProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Trapping division still needs its divisor and complete AX or DX:AX even for Void.
+		}
+		if form, known, err := x86PackedPhysicalProperties(ins.Op, ins, arch, ""); known && err == nil &&
+			(form.spec.family == x86PackedDwordProduct || x86ResultNamedPredicateInstruction(ins)) {
+			return true // Dword products also retain the existing raw-input obligation.
+		}
+		if _, known, err := x86FP16BinaryProperties(ins, arch); known && err == nil {
+			return true // Dead raw arithmetic still needs source, merge and mask inputs.
+		}
+		if _, known, err := amd64FMA3Properties(ins, arch); known && err == nil {
+			return true // All three FMA inputs remain mandatory even for dead or zero-masked results.
+		}
+		if _, known, err := x86FP16ConversionProperties(ins, arch); known && err == nil {
+			return true // Raw conversion masks and numerical inputs remain mandatory for Void.
+		}
+		if _, known, err := x86EnqueueProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Void and unused status do not supply either command or device address.
+		}
+		if _, known, err := x86HardwareRandomProperties(ins.Op, ins, arch); known && err == nil {
+			return true // A random write cannot invent a physical stack or an unwritten ABI result, including raw Void sources.
+		}
+		if _, valid := x86RawVMOVWResultForm(ins, arch); valid {
+			return true // Raw GP/X/m16 moves still require inputs and addresses for Void.
+		}
+		if sig.Ret != Void && x86EndBranchPreservesSourceState(ins) {
+			return true // End markers preserve existing result bytes; they never supply an ABI return value.
+		}
+		if _, known, err := x86FloatingHelperProperties(ins, arch); known && err == nil {
+			return true // Dead native floating helpers retain every input, mask and exception obligation.
+		}
+		if _, known, err := x86SqrtProperties(ins, arch); known && err == nil {
+			return true // Dead square roots still consume numerical inputs and masks.
+		}
+		if _, known, err := x86PackedSADProperties(ins, arch); known && err == nil {
+			return true // Dead SAD outputs still need selected input bytes, masks and native addresses.
+		}
+		if spec, _, known, err := x86ImplicitSystemProperties(ins.Op, ins, arch); known && err == nil && spec.writesCarry {
+			return true // Named/raw waits need deadline/control bytes, including Void.
+		}
+		if form, known, err := x86ScalarShiftProperties(ins.Op, ins, arch); known && err == nil &&
+			form.hasMemory() && x86ResultNamedPredicateInstruction(ins) {
+			return true // Dead native accesses and undefined W counts remain obligations for Void.
+		}
+		if _, known, err := x86CPUQueryProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Named/raw implicit query inputs remain required even for dead Void outputs.
+		}
+		if _, known, err := x86BLSProperties(ins.Op, ins, arch); known && err == nil {
+			return true // BLS sources remain required for Void, including dead native reads.
+		}
+		if _, known, err := x86PackedLogicalProperties(ins, arch); known && err == nil {
+			return true // Dead logical results cannot excuse actual native inputs or masks.
+		}
+		if _, known, err := x86PackedIntegerCompareProperties(ins.Op, ins, arch); known && err == nil {
+			return true // EQ/GT share source obligations, not logical writeback or caller authority.
+		}
+		if _, known, err := x86PackedIntegerAddProperties(ins, arch); known && err == nil {
+			return true // Native add inputs/masks remain obligations without a result or unrelated KMOV.
+		}
+		if _, known, err := x86PackedSubtractProperties(ins, arch); known && err == nil {
+			return true // Subtract shares the same whole-source obligation, not add's caller authority.
+		}
+		if _, known, err := x86ScalarBitFieldProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Each family's exact control/source bytes remain required even for dead results.
+		}
+		if _, known, err := x86BroadcastProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Dead scalar/block/mask broadcasts still require their actual input bytes.
+		}
+		if _, known, err := x86FloatCompareProperties(ins, arch); known && err == nil {
+			return true // Dead comparisons still consume real vector/mask inputs and native FP effects.
+		}
+		if form, known, err := x86NonTemporalVectorProperties(ins.Op, ins, arch); known && err == nil && !form.trap {
+			return true // Dead non-temporal accesses still need real memory and complete inputs, including Void.
+		}
+		if form, known, err := x86MOVNTIProperties(ins.Op, ins, arch); known && err == nil && !form.trap {
+			return true // Cache-policy stores retain real address/value inputs even when Void or overwritten.
+		}
+		if _, known, err := x86ScalarBitCountProperties(ins.Op, ins, arch); known && err == nil &&
+			isAMD64MemoryOperand(ins.Args[0]) && x86ResultNamedPredicateInstruction(ins) {
+			return true // A dead count still performs its exact native read, including Void.
+		}
+		if _, known, err := x86ScalarBitScanProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Dead scans retain source bytes and addresses, including Void and unused bool.
+		}
+		if _, known, err := x86NativeMMXInstruction(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Actual MMX inputs and the closed x87-mode continuation remain obligations for Void.
+		}
+		if _, known, err := x86PackedShiftProperties(ins.Op, ins, arch); known && err == nil {
+			return true // Native accesses and masks stay obligations even with dead numerical outputs.
+		}
+		if _, known, err := x86PackedUnpackProperties(ins, arch); known && err == nil {
+			return true // Named/physical permutations cannot borrow implementation entry bytes.
+		}
+		if _, known, err := x86PackedNarrowProperties(ins, arch); known && err == nil {
+			return true // Named or physical PACK retains address, mask and result obligations even for Void.
+		}
+		if _, known, err := x86StackWidthProperties(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Private transport must not hide unknown result bytes or unbalanced storage.
+		}
+		if _, known, err := x86ScalarMemoryRMWProperties(ins.Op, ins, arch); known && err == nil &&
+			x86ResultNamedPredicateInstruction(ins) && (ordinal == 0 || fn.Instrs[ordinal-1].Op != "LOCK") {
+			return true // Ordinary memory RMW inputs remain obligations even for Void or missing results.
+		}
+		if _, known, err := x86AHFlagsProperties(ins.Op, ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Dead AH/FLAGS transfers still need their actual source byte or five flags.
+		}
+		if _, known, err := x86SignedPackedFloatProperties(ins, arch); known && err == nil {
+			return true // Complete conversion inputs stay required for Void without a KMOV routing prerequisite.
+		}
+		if _, known, err := x86PackedConversionProperties(ins, arch); known && err == nil {
+			return true // Named/raw dead conversions still retain all numerical, mask and native access inputs.
+		}
+		if _, known, err := x86ScalarNativeStoreProperties(ins.Op, ins, arch); known && err == nil &&
+			x86ResultNamedPredicateInstruction(ins) {
+			return true // Register and immediate stores retain data/address obligations, including Void.
+		}
+		if _, known, err := x86ScalarStaticStoreProperties(ins.Op, ins, arch); known && err == nil &&
+			x86ResultNamedPredicateInstruction(ins) {
+			return true // Static syntax still needs complete NUM inputs and actual writable storage for Void.
+		}
+		if form, known, err := x86GPSIMDTransferProperties(ins, arch); known && err == nil &&
+			form.memoryWrite && x86ResultNamedPredicateInstruction(ins) {
+			return true // SIMD stores need their actual source bytes and address, including Void.
+		}
+		if form, known, err := x86InsertExtractProperties(ins, arch); known && err == nil &&
+			form.memoryWrite && x86ResultNamedPredicateInstruction(ins) {
+			return true // Block and PS scalar stores need selected bytes and addresses even for Void.
+		}
+		if form, known, err := x86ScalarLaneProperties(ins, arch); known && err == nil &&
+			!form.insert && form.memory >= 0 && x86ResultNamedPredicateInstruction(ins) {
+			return true // All B/W/D/Q extraction stores retain their selected input bytes, including Void.
+		}
+		if _, _, known, err := x86OtherFixedVectorValueProperties(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Complete value inputs and native addresses stay required without results or masks.
+		}
+		if _, known, err := x86ConditionalSetProperties(ins.Op, ins, arch); known && err == nil &&
+			x86ResultNamedPredicateInstruction(ins) {
+			return true // Every conditional byte write consumes actual predicate FLAGS, even for Void.
+		}
+		if _, known, err := x86MaskValueProperties(ins.Op, ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // KADD/KSHIFT/KUNPCK retain their complete input obligation for Void.
+		}
+		if _, known, err := x86MaskLogicalProperties(ins.Op, ins, arch); known && err == nil && x86MaskLogicalPreservesStorage(ins) {
+			return true // Logical masks retain actual inputs and FLAGS even for dead Void outputs.
+		}
+		if _, known, err := x86MaskVectorProperties(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Register data moves require source values even for dead outputs and Void.
+		}
+		if amd64MaskMoveOperandsValid(ins, arch) && x86ResultNamedPredicateInstruction(ins) {
+			return true // Mask inputs/results cannot borrow zeroed implementation slots, even for Void.
+		}
+		if form, known, err := x86PackedCompactProperties(ins.Op, ins, arch); known && err == nil &&
+			!form.undefinedOpcode() && (x86ResultNamedPredicateInstruction(ins) || x86RawCompactSource(ins, arch)) {
+			return true // Named and exact raw compact/expand inputs remain obligations even for Void.
+		}
+		if _, _, _, known := x86StaticAddressValueMove(ins, arch); known && !opaqueAddressResult {
+			return true // The address source cannot hide an unwritten result.
+		}
+		if x86NamedSegmentMOVNeedsProof(ins, arch) {
+			return true // Source/input effects remain mandatory even with no result.
+		}
+		if _, known, err := x86StringInstructionProperties(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Implicit data/address/count/DF inputs remain mandatory, including Void.
+		}
+		if effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch); known && err == nil &&
+			effect.requiresResultProof {
+			return true // Mandatory input checks cannot be bypassed by raw syntax, Void or an absent result layout.
+		}
+		if x86GPFaultingReadNeedsProof(ins, arch) {
+			return true // A dead native read still needs its whole-source input proof.
+		}
+		if sig.Ret == Void || len(sig.Frame.Results) == 0 {
+			continue
+		}
+		if _, known, err := x86X87WordProperties(ins, arch); known && err == nil && x86ResultNamedPredicateInstruction(ins) {
+			return true // Word results need the same whole proof without a GP-to-FP MOV.
+		}
+	}
+	return false
+}
diff --git a/x86_unaligned_load_contract_test.go b/x86_unaligned_load_contract_test.go
new file mode 100644
index 000000000..994d6e5d9
--- /dev/null
+++ b/x86_unaligned_load_contract_test.go
@@ -0,0 +1,128 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86UnalignedLoadCompleteOfficialRowsAndTypedEffects(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	legacy := strings.Join(strings.Fields(string(data)), "")
+	for _, expected := range []string{
+		"varylddqu=[]ytab{{Zm_r,1,argList{Ym,Yxr}},}",
+		"{ALDDQU,ylddqu,Pf2,opBytes{0xf0}}",
+	} {
+		if !strings.Contains(legacy, expected) {
+			t.Fatal("complete official legacy LDDQU grammar changed", expected)
+		}
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	var actual []goasmrules.X86AVXRule
+	for _, rule := range rules {
+		if rule.Opcode == "VLDDQU" {
+			actual = append(actual, rule)
+		}
+	}
+	opbytes := []string{"avxEscape | vex128 | vexF2 | vex0F | vexW0", "0xF0",
+		"avxEscape | vex256 | vexF2 | vex0F | vexW0", "0xF0"}
+	var expected []goasmrules.X86AVXRule
+	for index, bank := range []string{"Yxr", "Yyr"} {
+		expected = append(expected, goasmrules.X86AVXRule{
+			Opcode: "VLDDQU", Ytab: "_yvlddqu", Prefix: "Pavx", Classes: []string{"Ym", bank},
+			RowIndex: index, ZCase: "Zvex_rm_v_r", ZOffset: 2, EncodingOffset: index * 2, OpBytes: opbytes,
+		})
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatal("complete original VEX LDDQU rows/attributes changed", actual)
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		var rows []string
+		for _, shape := range []struct{ op, bank string }{{"LDDQU", "X"}, {"VLDDQU", "X"}, {"VLDDQU", "Y"}} {
+			for _, memory := range []string{"1(AX)", "-16(BX)(CX*2)", "value+0(FP)", "table<>(SB)"} {
+				rows = append(rows, shape.op+" "+memory+","+shape.bank+"1")
+			}
+		}
+		requireX86GoAssemblerResult(t, arch, "TEXT forms(SB),4,$0-64\n"+strings.Join(rows, "\n")+"\nRET\n", true)
+		for _, row := range rows {
+			ins := x86ScalarLaneInstruction(t, row)
+			effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+			if !known || err != nil || !effect.requiresResultProof || len(effect.operands) != 2 ||
+				effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+				t.Fatal("complete LDDQU memory/byte effect is not registered", arch, row, known, err)
+			}
+		}
+	}
+}
+
+func TestX86UnalignedLoadInitializedNativeInputsAndWholeUpperBytes(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete LDDQU objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, move := goWordSize(target.arch), "MOVQ"
+		if word == 4 {
+			move = "MOVL"
+		}
+		var source, declarations strings.Builder
+		for index, row := range []string{"LDDQU 1(SI),X0", "VLDDQU 1(SI),X0", "VLDDQU 1(SI),Y0"} {
+			name := fmt.Sprint("Unaligned", index)
+			fmt.Fprintf(&declarations, "func %s(out *[72]byte,input *[128]byte,old *[64]byte)\n", name)
+			fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s input+%d(FP),SI\n"+
+				"%s old+%d(FP),BX\nVMOVUPS (BX),Z0\nSTC\n%s\nVMOVUPS Z0,(DI)\nSETCS 64(DI)\nSTMXCSR 68(DI)\nRET\n",
+				name, 3*word, move, move, word, move, 2*word, row)
+		}
+		x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("initialized LDDQU source and observable upper bytes rejected", err)
+				}
+				if !strings.Contains(ir, "asm sideeffect \"lddqu ") ||
+					strings.Count(ir, "asm sideeffect \"vlddqu ") != 2 || !strings.Contains(ir, "+sse3") {
+					t.Fatal("LDDQU lost its original implementation-defined access or required ISA")
+				}
+				for _, pipeline := range []struct{ ir, level string }{
+					{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+				} {
+					x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnalignedLoadOriginalPhysicalWIGMemoryForms(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for word := 0; word < 2; word++ {
+			for length, bank := range []string{"X", "Y"} {
+				code := []byte{0xc4, 0xe1, byte(0x7b | word<<7 | length<<2), 0xf0, 0x40, 0x01}
+				source := "TEXT Value(SB),4,$0-0\n" + x86RawDisplacementDirectives(code) + "RET\n"
+				requireX86GoAssemblerResult(t, arch, source, true)
+				file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+				if err != nil || len(file.Funcs[0].Instrs) != 3 {
+					t.Fatal("complete physical VEX.WIG LDDQU was not decoded", arch, word, length, err)
+				}
+				ins := file.Funcs[0].Instrs[1]
+				want := x86ScalarLaneInstruction(t, "VLDDQU 1(AX),"+bank+"0")
+				if ins.Op != want.Op || !reflect.DeepEqual(ins.Args, want.Args) || ins.x86SourceRaw == nil {
+					t.Fatal("physical WIG changed the complete memory or vector identity", ins.Raw)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_unbound_format_test.go b/x86_unbound_format_test.go
new file mode 100644
index 000000000..bb50790c2
--- /dev/null
+++ b/x86_unbound_format_test.go
@@ -0,0 +1,81 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// An original format-only function can lack numerical inputs, native addresses
+// or a closed physical register state. Preserve its complete Go object and
+// public Context result instead of treating a direct emitter as a public ABI.
+func x86UnboundVoidFormatSource(t *testing.T, source, name, arch, triple string) (*File, map[string]FuncSig) {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	if len(file.Funcs) != 1 || strings.TrimPrefix(file.Funcs[0].Sym, "·") != name {
+		t.Fatal("single original format source lost its function identity", name)
+	}
+	return file, signatures
+}
+
+func x86UnboundVoidFormatSources(t *testing.T, source, arch, triple string) (*File, map[string]FuncSig) {
+	t.Helper()
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var declarations strings.Builder
+	signatures := make(map[string]FuncSig)
+	for _, function := range file.Funcs {
+		if function.FrameSize != 0 || function.ArgSize != 0 {
+			t.Fatal("unbound Void format unit cannot impersonate a frame or typed input")
+		}
+		name := strings.TrimPrefix(function.Sym, "·")
+		fmt.Fprintf(&declarations, "func %s()\n", name)
+		signatures[name] = FuncSig{Name: name, Ret: Void}
+	}
+	if len(signatures) == 0 || len(signatures) != len(file.Funcs) {
+		t.Fatal("incomplete or duplicate original Void format inventory")
+	}
+	x86LEAActualTargetGoObject(t, arch, triple, "#include \"textflag.h\"\n"+source)
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86ScalarFPBitViewAPI(t, source, declarations.String(), arch, triple, api)
+		if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("original format fixture invented its missing source inputs", api, err)
+		}
+	}
+	return file, signatures
+}
+
+func x86UnboundVoidScalarFormatObject(t *testing.T, source, name, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSource(t, source, name, arch, triple)
+	return x86ScalarFormatObjectUnit(t, file, signatures, arch, triple, 0)
+}
+
+func x86UnboundVoidRawScalarFormatObject(t *testing.T, source, arch, triple string) string {
+	t.Helper()
+	file, signatures := x86UnboundVoidFormatSources(t, source, arch, triple)
+	normalized, err := normalizeX86RawFile(file, arch)
+	if err != nil {
+		t.Fatal("original format bytes could not be decoded", err)
+	}
+	return x86ScalarFormatObjectUnit(t, normalized, signatures, arch, triple, 0)
+}
+
+// Encoder probes may retain a terminal UD2 instead of an unproved native RET.
+// That removes a return obligation, not the numerical/native input obligations
+// of preceding instructions. Preserve every original format and its fault.
+func x86UnboundVoidRawProbeObject(t *testing.T, file *File, arch, triple string) string {
+	t.Helper()
+	var source strings.Builder
+	for _, function := range file.Funcs {
+		text, valid := x86RawReplaySourceText(function)
+		if !valid {
+			t.Fatal("raw format probe lost its complete original source")
+		}
+		source.WriteString(text)
+	}
+	return x86UnboundVoidRawScalarFormatObject(t, source.String(), arch, triple)
+}
diff --git a/x86_unsigned_range.go b/x86_unsigned_range.go
new file mode 100644
index 000000000..63178368e
--- /dev/null
+++ b/x86_unsigned_range.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import "math"
+
+// An unsigned numerical envelope is independent of initialized bytes and
+// storage provenance. Excluding an interior value retains its convex hull.
+type x86UnsignedRange struct{ minimum, maximum uint64 }
+
+func (value x86UnsignedRange) hull(other x86UnsignedRange) x86UnsignedRange {
+	if other.minimum < value.minimum {
+		value.minimum = other.minimum
+	}
+	if other.maximum > value.maximum {
+		value.maximum = other.maximum
+	}
+	return value
+}
+
+func (value x86UnsignedRange) refine(op Op, taken bool, bound uint64) (x86UnsignedRange, bool) {
+	less, equal, greater := true, true, true
+	switch x86BranchCondition(op) {
+	case "CS":
+		equal, greater = false, false
+	case "LS":
+		greater = false
+	case "HI":
+		less, equal = false, false
+	case "CC":
+		less = false
+	case "EQ":
+		less, greater = false, false
+	case "NE":
+		equal = false
+	default:
+		return value, true
+	}
+	if !taken {
+		less, equal, greater = !less, !equal, !greater
+	}
+	if !less && value.minimum < bound {
+		value.minimum = bound
+	}
+	if !greater && value.maximum > bound {
+		value.maximum = bound
+	}
+	if !equal {
+		if value.minimum == bound {
+			if bound == math.MaxUint64 {
+				return value, false
+			}
+			value.minimum++
+		}
+		if value.maximum == bound {
+			if bound == 0 {
+				return value, false
+			}
+			value.maximum--
+		}
+	}
+	return value, value.minimum <= value.maximum
+}
diff --git a/x86_unsigned_scalar_integer_float_boundaries_test.go b/x86_unsigned_scalar_integer_float_boundaries_test.go
new file mode 100644
index 000000000..773511424
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_boundaries_test.go
@@ -0,0 +1,157 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestX86UnsignedScalarIntegerFloatPublicInputAndAuthorityBoundaries(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, triple, word := "MOVQ", "x86_64-unknown-linux-gnu", 8
+		if arch == "386" {
+			move, triple, word = "MOVL", "i386-unknown-linux-gnu", 4
+		}
+		for _, member := range x86UnsignedScalarIntegerFloatOracle {
+			input := member.input
+			if arch == "386" {
+				input = 4
+			}
+			for _, sourceKind := range []string{"GP", "FP", "native"} {
+				row := x86UnsignedScalarIntegerFloatRow{op: member.op, source: sourceKind, input: input, output: member.output, destination: 1}
+				source, declaration, _ := x86UnsignedScalarIntegerFloatProgram(0, row, arch)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(arch+"/"+member.op+"/"+sourceKind+"/"+api, func(t *testing.T) {
+						if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api); err != nil || ir == "" {
+							t.Fatal("legitimate initialized unsigned baseline failed before any negative", err)
+						}
+						mutations := map[string]string{
+							"unknown-upper":          strings.Replace(source, "VMOVDQU64 (SI),Z0\n", "", 1),
+							"missing-output-pointer": strings.Replace(source, move+" out+8(FP),DI\n", "", 1),
+						}
+						if sourceKind == "GP" {
+							load := fmt.Sprintf("MOV%s value+0(FP),CX\n", map[int]string{4: "L", 8: "Q"}[input])
+							mutations["missing-integer"] = strings.Replace(source, load, "", 1)
+							mutations["partial-integer"] = strings.Replace(source, load, "MOVB value+0(FP),CX\n", 1)
+							mutations["opaque-pointer-as-integer"] = strings.Replace(source, load, fmt.Sprintf("%s p+%d(FP),CX\n", move, 8+word), 1)
+						} else if sourceKind == "native" {
+							mutations["missing-native-address"] = strings.Replace(source, fmt.Sprintf("%s p+%d(FP),BX\n", move, 8+word), "", 1)
+						}
+						for name, changed := range mutations {
+							if changed == source {
+								t.Fatal("unsigned input mutation did not apply", name)
+							}
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, triple, api)
+							if arch == "amd64" && name == "unknown-upper" {
+								x86VectorScratchCodegenControl(t, changed, declaration, arch, triple, ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("unknown data, upper bytes or opaque/native address gained authority", name, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatDeadInputsAndNativeEffects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		move, word := "MOVQ", goWordSize(target.arch)
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, member := range x86UnsignedScalarIntegerFloatOracle {
+			t.Run(target.triple+"/"+member.op, func(t *testing.T) {
+				declaration := "func view(p *byte)\n"
+				source := fmt.Sprintf("TEXT ·view(SB),4,$0-%d\n%s p+0(FP),BX\n%s (BX),X0,X1\nRET\n", word, move, member.op)
+				goAssemblerOracleOutput(t, target.arch, source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if err != nil || ir == "" {
+							t.Fatal("dead native unsigned read lost its complete incoming pointer", err)
+						}
+						op := member.op
+						if target.arch == "386" && strings.HasSuffix(op, "Q") {
+							op = strings.TrimSuffix(op, "Q") + "L"
+						}
+						for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							x86ScalarPrecisionRequireNativeEffects(t, text, map[string][]string{"view": {op}})
+						}
+						missing := strings.Replace(source, move+" p+0(FP),BX\n", "", 1)
+						if ir, err := x86ScalarFPBitViewAPI(t, missing, declaration, target.arch, target.triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void waived an actual native source address", err)
+						}
+					})
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatSourceIdentityAndPhysicalBankBoundaries(t *testing.T) {
+	for _, member := range x86UnsignedScalarIntegerFloatOracle {
+		for _, change := range []string{"encoded", "origin", "address-size", "address-override", "segment", "pointer-GP", "caller-address-GP", "standalone-native-read", "high-bank-mode32"} {
+			t.Run(member.op+"/"+change, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, member.op+" CX,X0,X1")
+				state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+				state.gp[1], state.xmm[0], state.xmm[16] = 0xff, 0xffff, 0xffff
+				arch := "amd64"
+				switch change {
+				case "encoded":
+					ins.x86Encoded = true
+				case "origin":
+					ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op, args: ins.Args}
+				case "address-size":
+					ins.x86AddressBits = 16
+				case "address-override":
+					ins.x86UnboundAddressOverride = true
+				case "segment":
+					ins.x86SegmentPrefix = 0x64
+				case "pointer-GP":
+					state.pointerGP[1] = true
+				case "caller-address-GP":
+					state.callerAddressGP[1] = true
+				case "standalone-native-read":
+					ins.Args[0] = x86ScalarLaneInstruction(t, member.op+" (BX),X0,X1").Args[0]
+					state.pointerGP[3] = true
+				case "high-bank-mode32":
+					arch, ins.Args[1].Reg = "386", "X16"
+				}
+				before := state.clone()
+				if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+					t.Fatal("unsigned numerical transfer borrowed raw/physical or pointer authority", change)
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatTargetCannotBorrowPortableArithmetic(t *testing.T) {
+	for _, member := range x86UnsignedScalarIntegerFloatOracle {
+		body := "MOVL value+0(FP),CX\n"
+		if member.input == 8 {
+			body = "MOVQ value+0(FP),CX\n"
+		}
+		declaration := "func view(value uint64) uint64\n"
+		source := x86ResultGPSIMDAdmissionSource(t, "amd64", declaration,
+			body+"PXOR X0,X0\n"+member.op+" CX,X0,X1\nMOVQ X1,ret+RESULT(FP)")
+		goAssemblerOracleOutput(t, "amd64", source, "", true)
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(member.op+"/"+api, func(t *testing.T) {
+				if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api); err != nil || ir == "" {
+					t.Fatal("initialized native-target control failed before cross-target negatives", err)
+				}
+				for _, triple := range []string{"aarch64-unknown-linux-gnu", "wasm32-unknown-unknown"} {
+					if ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api); ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("pure arithmetic falsely certified original native MXCSR effects on a foreign target", triple, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_contract_test.go b/x86_unsigned_scalar_integer_float_contract_test.go
new file mode 100644
index 000000000..e04489fa3
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_contract_test.go
@@ -0,0 +1,186 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+// Independent Go and ISA directory. The signed legacy/VEX family and raw FP16
+// conversions retain their own owners. EVEX.W1 is WIG in non-64-bit mode.
+var x86UnsignedScalarIntegerFloatOracle = []struct {
+	op            string
+	input, output int
+	rounding      bool
+}{
+	{"VCVTUSI2SDL", 4, 8, false}, {"VCVTUSI2SDQ", 8, 8, true},
+	{"VCVTUSI2SSL", 4, 4, true}, {"VCVTUSI2SSQ", 8, 4, true},
+}
+
+type x86UnsignedScalarIntegerFloatRow struct {
+	op, control, source string
+	input, output       int
+	upper, destination  int
+}
+
+func x86UnsignedScalarIntegerFloatRows(arch string) []x86UnsignedScalarIntegerFloatRow {
+	var rows []x86UnsignedScalarIntegerFloatRow
+	for _, member := range x86UnsignedScalarIntegerFloatOracle {
+		input := member.input
+		if arch == "386" {
+			input = 4
+		}
+		base := x86UnsignedScalarIntegerFloatRow{op: member.op, input: input, output: member.output, upper: 0, destination: 1}
+		for _, source := range []string{"GP", "FP", "native"} {
+			row := base
+			row.source = source
+			rows = append(rows, row)
+		}
+		if member.rounding {
+			for _, control := range []string{"RN_SAE", "RD_SAE", "RU_SAE", "RZ_SAE"} {
+				row := base
+				row.source, row.control = "GP", control
+				rows = append(rows, row)
+			}
+		}
+		alias := base
+		alias.source, alias.upper = "GP", alias.destination
+		rows = append(rows, alias)
+		if arch == "amd64" {
+			high := base
+			high.source, high.upper, high.destination = "GP", 29, 30
+			rows = append(rows, high)
+		}
+	}
+	return rows
+}
+
+func (row x86UnsignedScalarIntegerFloatRow) instruction() string {
+	source := "CX"
+	if row.source == "FP" {
+		source = "value+0(FP)"
+	} else if row.source == "native" {
+		source = "(BX)"
+	}
+	op := row.op
+	if row.control != "" {
+		op += "." + row.control
+	}
+	return fmt.Sprintf("%s %s,X%d,X%d", op, source, row.upper, row.destination)
+}
+
+func TestX86UnsignedScalarIntegerFloatCompleteIndependentGoRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := make(map[string]int)
+	for _, rule := range rules {
+		if !strings.HasPrefix(rule.Opcode, "VCVTUSI2S") {
+			continue
+		}
+		counts[rule.Opcode]++
+		var input, output int
+		var rounding bool
+		for _, member := range x86UnsignedScalarIntegerFloatOracle {
+			if rule.Opcode == member.op {
+				input, output, rounding = member.input, member.output, member.rounding
+			}
+		}
+		if input == 0 {
+			t.Fatal("new official unsigned scalar member is absent from the independent directory", rule)
+		}
+		prefix, width := "evexF3", "evexW0"
+		if output == 8 {
+			prefix = "evexF2"
+		}
+		if input == 8 {
+			width = "evexW1"
+		}
+		attributes := fmt.Sprintf("evexN%d", input)
+		if rounding {
+			attributes += " | evexRoundingEnabled"
+		}
+		if rule.RowIndex != 0 || rule.Ytab != "_yvcvtusi2sdl" || rule.Prefix != "Pavx" ||
+			rule.ZCase != "Zevex_rm_v_r" || rule.ZOffset != 3 || rule.EncodingOffset != 0 ||
+			strings.Join(rule.Classes, ",") != "Yml,YxrEvex,YxrEvex" ||
+			!reflect.DeepEqual(rule.OpBytes, []string{"avxEscape | evex128 | " + prefix + " | evex0F | " + width, attributes, "0x7B"}) {
+			t.Fatal("complete unsigned scalar Go row or opcode controls changed", rule)
+		}
+	}
+	if !reflect.DeepEqual(counts, map[string]int{"VCVTUSI2SDL": 1, "VCVTUSI2SDQ": 1, "VCVTUSI2SSL": 1, "VCVTUSI2SSQ": 1}) {
+		t.Fatal("complete unsigned scalar Go family changed", counts)
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatExactFPWidthsAndControls(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86UnsignedScalarIntegerFloatRows(arch) {
+			if row.source != "FP" {
+				continue
+			}
+			t.Run(arch+"/"+row.op, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				for index := range ins.Args {
+					width, write, known := X86FPAccessBytes(ins, index, arch)
+					if index == 0 {
+						if !known || write || width != int64(row.input) {
+							t.Fatal("unsigned source lost its actual scalar width or acquired a write", width, write, known)
+						}
+					} else if known || width != 0 || write {
+						t.Fatal("upper/destination acquired an FP memory access", index)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatEveryByteAndIndependentState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, member := range x86UnsignedScalarIntegerFloatOracle {
+			input := member.input
+			if arch == "386" {
+				input = 4
+			}
+			for _, source := range []string{"GP", "FP"} {
+				for missing := -1; missing < input; missing++ {
+					t.Run(fmt.Sprintf("%s/%s/%s/missing%d", arch, member.op, source, missing), func(t *testing.T) {
+						row := x86UnsignedScalarIntegerFloatRow{op: member.op, source: source, upper: 0, destination: 1}
+						ins := x86ScalarLaneInstruction(t, row.instruction())
+						state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward,
+							fp: make([]bool, 16), auto: make([]bool, 8)}
+						owned := make([]bool, 16)
+						for index := range owned {
+							state.fp[index], owned[index] = true, true
+							if index < len(state.auto) {
+								state.auto[index] = true
+							}
+						}
+						state.gp[1], state.xmm[0], state.xmm[1] = 0xff, 0xa5c3, 0xffff
+						state.vectorUpper[1], state.pointerGP[7], state.masks[2] = 0x123456780000, true, true
+						if missing >= 0 {
+							if source == "FP" {
+								state.fp[missing] = false
+							} else {
+								state.gp[1] &^= 1 << uint(missing)
+							}
+						}
+						before, expected := state.clone(), state.clone()
+						low := x86CallerVectorByteMask(int64(member.output))
+						expected.writeVector(1, 16, low|state.vectorBytes(0)&(0xffff&^low), false)
+						accepted := x86ResultTransfer(ins, &state, owned, 0, arch)
+						if accepted != (missing < 0) || accepted && !reflect.DeepEqual(state, expected) ||
+							!accepted && !reflect.DeepEqual(state, before) {
+							t.Fatal("unsigned conversion lost an actual input, sparse upper bytes, alias clearing or unrelated state", accepted, missing)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_controls_test.go b/x86_unsigned_scalar_integer_float_controls_test.go
new file mode 100644
index 000000000..d0d5a5503
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_controls_test.go
@@ -0,0 +1,65 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86UnsignedScalarIntegerFloatCompleteMinimalNativeProfiles(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, row := range x86UnsignedScalarIntegerFloatRows(arch) {
+			instruction := x86ScalarLaneInstruction(t, row.instruction())
+			if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, Func{Instrs: []Instr{instruction}}); got != "+avx512f" {
+				t.Fatal("an isolated unsigned scalar conversion borrowed a sibling's ISA or an unneeded VL profile", arch, row.instruction(), got)
+			}
+		}
+	}
+}
+
+func TestX86UnsignedScalarIntegerFloatInvalidControlGrammarMatchesGo(t *testing.T) {
+	for _, member := range x86UnsignedScalarIntegerFloatOracle {
+		bad := []string{
+			member.op + ".SAE CX,X0,X1", member.op + ".Z CX,X0,X1",
+			member.op + ".BCST (BX),X0,X1", member.op + " CX,X0,K1,X1",
+			member.op + " X0,X0,X1", member.op + " $7,X0,X1",
+			member.op + " CX,Y0,X1", member.op + " CX,X0,Y1",
+		}
+		if member.rounding {
+			bad = append(bad, member.op+".RN_SAE (BX),X0,X1")
+		} else {
+			bad = append(bad, member.op+".RN_SAE CX,X0,X1")
+		}
+		for index, instruction := range bad {
+			t.Run(fmt.Sprint(member.op, "/", index), func(t *testing.T) {
+				goAssemblerOracleOutput(t, "amd64", "TEXT rejected(SB),4,$0-0\n"+instruction+"\nRET\n", "", false)
+				assertX86ScalarIntegerFloatRejected(t, "amd64", "x86_64-unknown-linux-gnu", instruction)
+			})
+		}
+	}
+}
+
+// Private format objects retain the complete original table and original
+// source independently of initialized programs. They grant no public success.
+func TestX86UnsignedScalarIntegerFloatUnboundFormatsKeepContextAndObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original unsigned scalar format objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source strings.Builder
+			for index, row := range x86UnsignedScalarIntegerFloatRows(target.arch) {
+				if row.source == "FP" {
+					continue // No invented FP frame for a bare format witness.
+				}
+				fmt.Fprintf(&source, "TEXT ·UnsignedFormat%d(SB),4,$0-0\n%s\nRET\n", index, row.instruction())
+			}
+			file, signatures := x86UnboundVoidFormatSources(t, source.String(), target.arch, target.triple)
+			ir := x86ScalarFormatObjectUnit(t, file, signatures, target.arch, target.triple, 0)
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				compileLLVMToObject(t, llc, target.triple, "unsigned-original-formats.ll", "unsigned-original-formats.o", text)
+			}
+		})
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_feature_prior_test.go b/x86_unsigned_scalar_integer_float_feature_prior_test.go
new file mode 100644
index 000000000..c24779c50
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_feature_prior_test.go
@@ -0,0 +1,64 @@
+package plan9asm
+
+import "testing"
+
+// Go's complete unsigned _yvcvtusi2sdl family is EVEX-only. Intel SDM
+// VCVTUSI2SD/SS lists AVX512F (not VL) in both physical modes; non-64-bit
+// mode ignores W1. These are object/feature observations, not initialized
+// public inputs or an actual AVX512 execution claim.
+func TestX86UnsignedScalarIntegerFloatActualGoFeaturePrior(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			op string
+			pp byte
+			w  byte
+		}{
+			{"VCVTUSI2SDL", 3, 0}, {"VCVTUSI2SDQ", 3, 1},
+			{"VCVTUSI2SSL", 2, 0}, {"VCVTUSI2SSQ", 2, 1},
+		} {
+			for _, operand := range []string{"AX", "(BX)"} {
+				instruction := row.op + " " + operand + ",X0,X1"
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					source := "TEXT physical(SB),4,$0-0\n" + instruction + "\nRET\n"
+					code := x86OrderingHintGoBytes(t, arch, source)
+					if len(code) != 7 || code[0] != 0x62 || code[1]&7 != 1 ||
+						code[2]&3 != row.pp || code[2]>>7 != row.w || code[4] != 0x7b || code[6] != 0xc3 {
+						t.Fatalf("actual %s unsigned scalar EVEX prefix/opcode changed: %x", arch, code)
+					}
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					form, known, err := x86UnsignedIntegerFloatProperties(file.Funcs[0].Instrs[1], arch)
+					width := 32
+					if arch == "amd64" && row.w != 0 {
+						width = 64
+					}
+					if !known || err != nil || form.sourceBits != width {
+						t.Fatal("actual named unsigned row lost its physical mode width", form, known, err)
+					}
+					if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0]); got != "+avx512f" {
+						t.Fatal("actual EVEX unsigned source lost its isolated scalar F profile", instruction, arch, got)
+					}
+				})
+			}
+			t.Run(arch+"/"+row.op+"/invalid-zeroing", func(t *testing.T) {
+				instruction := row.op + ".Z AX,X0,X1"
+				source := "TEXT invalid(SB),4,$0-0\n" + instruction + "\nRET\n"
+				goAssemblerOracleOutput(t, arch, source, "", false)
+				file, err := Parse(ArchAMD64, source)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, arch, file.Funcs[0]); got != "" {
+					t.Fatal("Go-rejected unsigned suffix acquired a feature profile", instruction, arch, got)
+				}
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+				}
+				assertX86ScalarIntegerFloatRejected(t, arch, triple, instruction)
+			})
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_named_tuple_test.go b/x86_unsigned_scalar_integer_float_named_tuple_test.go
new file mode 100644
index 000000000..bec48a5b0
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_named_tuple_test.go
@@ -0,0 +1,151 @@
+package plan9asm
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// Follow only the actual native memory operand, not another offset or a comment
+// elsewhere in the function. Base/index register loads are symbolic variables;
+// this observer measures the constant displacement, never their numerical value.
+func x86UnsignedScalarNativeDisplacement(t *testing.T, ir string) int64 {
+	t.Helper()
+	definitions := make(map[string]string)
+	definition := regexp.MustCompile(`^\s*(%[-A-Za-z0-9._]+) = (.*)$`)
+	argument := regexp.MustCompile(`ptr elementtype\(\[4 x i8\]\) (%[-A-Za-z0-9._]+)\)`)
+	pointer, calls := "", 0
+	for _, line := range strings.Split(ir, "\n") {
+		if match := definition.FindStringSubmatch(line); match != nil {
+			definitions[match[1]] = match[2]
+		}
+		if !strings.Contains(line, `asm sideeffect "vcvtusi2s`) {
+			continue
+		}
+		calls++
+		match := argument.FindStringSubmatch(line)
+		if match == nil {
+			t.Fatal("actual scalar memory opcode lost its exact m32 operand", line)
+		}
+		pointer = match[1]
+	}
+	if calls != 1 {
+		t.Fatal("named-source displacement observer needs exactly one actual scalar native memory call", calls)
+	}
+	cast := regexp.MustCompile(`^inttoptr i64 (%[-A-Za-z0-9._]+) to ptr$`).FindStringSubmatch(definitions[pointer])
+	if cast == nil {
+		t.Fatal("actual scalar native memory pointer lost its original address expression", pointer, definitions[pointer])
+	}
+	add := regexp.MustCompile(`^add i64 (%[-A-Za-z0-9._]+), (%[-A-Za-z0-9._]+|-?[0-9]+)$`)
+	var displacement func(string, int) int64
+	displacement = func(value string, depth int) int64 {
+		if depth > 16 {
+			t.Fatal("native pointer expression exceeds this bounded independent fixture")
+		}
+		if number, err := strconv.ParseInt(value, 10, 64); err == nil {
+			return number
+		}
+		if match := add.FindStringSubmatch(definitions[value]); match != nil {
+			return displacement(match[1], depth+1) + displacement(match[2], depth+1)
+		}
+		if strings.HasPrefix(definitions[value], "load i64,") || strings.HasPrefix(definitions[value], "mul i64 ") {
+			return 0 // Independently initialized symbolic base/index, not a literal offset.
+		}
+		t.Fatal("unmodeled native address expression in independent source fixture", value, definitions[value])
+		return 0
+	}
+	return displacement(cast[1], 0)
+}
+
+func TestX86UnsignedScalarIntegerFloatNamed386QProducerDisplacements(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("named Go386 producer displacement prior requires LLVM22 llvm-mc")
+	}
+	offsets := []int64{0, 1, -1, 4, -4, 7, -7, 8, -8, 16, -16,
+		1008, 1016, 1017, 1024, -1016, -1024, -1025, -1032}
+	for _, op := range []string{"VCVTUSI2SDQ", "VCVTUSI2SSQ"} {
+		for _, indexed := range []bool{false, true} {
+			for _, offset := range offsets {
+				t.Run(fmt.Sprintf("%s/indexed=%t/offset%d", op, indexed, offset), func(t *testing.T) {
+					address := fmt.Sprintf("%d(BX)", offset)
+					if indexed {
+						address += "(SI*2)"
+					}
+					instruction := op + " " + address + ",X0,X1"
+					code := x86OrderingHintGoBytes(t, "386", "TEXT actual(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if len(code) < 7 || code[0] != 0x62 || code[2]&0x80 == 0 || code[4] != 0x7b || code[len(code)-1] != 0xc3 {
+						t.Fatal("actual Go producer lost its complete W1 scalar opcode and return", code)
+					}
+					modrm, displacementAt := code[5], 6
+					if modrm&7 == 4 {
+						displacementAt++ // The independent SIB input is retained.
+					}
+					actual, end := int64(0), displacementAt
+					switch modrm >> 6 {
+					case 0:
+					case 1:
+						actual, end = int64(int8(code[displacementAt]))*4, displacementAt+1
+					case 2:
+						if displacementAt+4 > len(code)-1 {
+							t.Fatal("actual Go producer truncated its complete disp32", code)
+						}
+						actual, end = int64(int32(binary.LittleEndian.Uint32(code[displacementAt:]))), displacementAt+4
+					default:
+						t.Fatal("actual Go memory producer became a register", code)
+					}
+					if end != len(code)-1 {
+						t.Fatal("independent complete original memory instruction has unaccounted bytes", code, end)
+					}
+					want := offset
+					if offset != 0 && offset%8 == 0 && offset/8 >= -128 && offset/8 <= 127 {
+						want = offset / 2 // Actual producer N8, independently observed physical N4.
+					}
+					if actual != want {
+						t.Fatal("actual Go table producer changed its compressed/uncompressed boundary", code, actual, want)
+					}
+					var input strings.Builder
+					for _, value := range code[:len(code)-1] {
+						fmt.Fprintf(&input, "0x%02x ", value)
+					}
+					ctx, cancel := runtimeOracleStageContext(t)
+					defer cancel()
+					command := exec.CommandContext(ctx, mc, "--disassemble", "--triple=i386-unknown-linux-gnu", "--mattr=+avx512f")
+					command.Stdin = strings.NewReader(input.String() + "\n")
+					output, err := runtimeOracleCombinedOutput(ctx, command)
+					prefix := ""
+					if actual != 0 {
+						prefix = fmt.Sprint(actual)
+					}
+					if err != nil || strings.Contains(string(output), "warning:") ||
+						!strings.Contains(string(output), prefix+"(%ebx") || !strings.Contains(string(output), "vcvtusi2s") {
+						t.Fatal("LLVM did not independently confirm the actual Go physical m32 address", err, string(output))
+					}
+					declaration := "func view(p *byte) uint32\n"
+					source := x86ResultGPSIMDAdmissionSource(t, "386", declaration,
+						"MOVL p+0(FP),BX\nMOVL $0,SI\nPXOR X0,X0\n"+instruction+"\nMOVL X1,AX\nMOVL AX,ret+RESULT(FP)")
+					goAssemblerOracleOutput(t, "386", source, "", true)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "386", "i386-unknown-linux-gnu", api)
+							if actual != offset && ir == "" && errors.Is(err, ErrProbeNeedsContext) {
+								return // Safe source-encoder Context, not a claimed numerical success.
+							}
+							if err != nil || ir == "" {
+								t.Fatal("unambiguous initialized Go386 memory producer lost its numerical continuation", err)
+							}
+							if got := x86UnsignedScalarNativeDisplacement(t, ir); got != actual {
+								t.Fatal("translation substituted the written source displacement for actual Go machine semantics", got, actual, instruction)
+							}
+						})
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_objects_test.go b/x86_unsigned_scalar_integer_float_objects_test.go
new file mode 100644
index 000000000..e51c6e98c
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_objects_test.go
@@ -0,0 +1,164 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86UnsignedScalarIntegerFloatOriginal(t *testing.T) (string, string) {
+	t.Helper()
+	const path = "amd64_lower_scalar_integer_float_test.go"
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]string{
+		"source": "a6867dc62b3626812081e7aeff427689528d6e12feef4f3e190f95f078d754c8",
+		"mainC":  "b62cf67cbb3b65a2890d63cdce289a7b6c7e4dae587b5ffc2417cbb0d461ea74",
+	}
+	values, count := make(map[string]string), 0
+	for _, declaration := range file.Decls {
+		function, ok := declaration.(*ast.FuncDecl)
+		if !ok || function.Name.Name != "qualifyAMD64ScalarIntegerFloatRuntimeSemantics" {
+			continue
+		}
+		count++
+		ast.Inspect(function.Body, func(node ast.Node) bool {
+			assignment, ok := node.(*ast.AssignStmt)
+			if !ok || assignment.Tok != token.DEFINE || len(assignment.Lhs) != 1 || len(assignment.Rhs) != 1 {
+				return true
+			}
+			name, ok := assignment.Lhs[0].(*ast.Ident)
+			if !ok || want[name.Name] == "" {
+				return true
+			}
+			literal, ok := assignment.Rhs[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING || values[name.Name] != "" {
+				t.Fatal("original unsigned conversion payload lost its unique complete literal", name.Name)
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil || fmt.Sprintf("%x", sha256.Sum256([]byte(value))) != want[name.Name] {
+				t.Fatal("original initialized ASM, independent C inputs or observations changed", name.Name, err)
+			}
+			values[name.Name] = value
+			return false
+		})
+	}
+	if count != 1 || len(values) != 2 {
+		t.Fatal("complete original scalar integer conversion source/reference disappeared", count)
+	}
+	return values["source"], values["mainC"]
+}
+
+func TestX86UnsignedScalarIntegerFloatOriginalInitializedThreeAPIObjects(t *testing.T) {
+	source, _ := x86UnsignedScalarIntegerFloatOriginal(t)
+	declaration := "func scalarintegerfloat(out *[128]byte,signed32 *int32,signed64 *int64,unsigned32 *uint32,unsigned64 *uint64,passthrough32 *[4]float32,passthrough64 *[2]float64)"
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("original scalar conversion objects require LLVM22 llc")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "amd64", triple, "#include \"textflag.h\"\n"+source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original complete initialized scalar integer conversion rejected", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						x86ScalarPrecisionRequireNativeEffects(t, text,
+							map[string][]string{"scalarintegerfloat": {"VCVTUSI2SDL", "VCVTUSI2SDQ", "VCVTUSI2SSL", "VCVTUSI2SSQ"}})
+						compileLLVMToObject(t, llc, triple, "original-unsigned-scalar.ll", "original-unsigned-scalar.o", text)
+					}
+				})
+			}
+		})
+	}
+}
+
+// The complete physical 64-byte observation exposes both scalar passthrough
+// and nonzero wider aliases. These are object fixtures, not AVX512 execution.
+// Place the FP integer first: in mode32 its physical ABI0 offset is +4, so a
+// nominal W1 producer cannot silently borrow an N8 compressed displacement.
+func x86UnsignedScalarIntegerFloatProgram(index int, row x86UnsignedScalarIntegerFloatRow, arch string) (string, string, string) {
+	word, move := int(goWordSize(arch)), "MOVQ"
+	if arch == "386" {
+		move = "MOVL"
+	}
+	name := fmt.Sprint("UnsignedScalar", index)
+	preparation := ""
+	if row.source == "GP" {
+		preparation = fmt.Sprintf("MOV%s value+0(FP),CX\n", map[int]string{4: "L", 8: "Q"}[row.input])
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+8(FP),DI\n%s p+%d(FP),BX\n"+
+		"%s upper+%d(FP),SI\n%s old+%d(FP),DX\nVMOVDQU64 (SI),Z%d\nVMOVDQU64 (DX),Z%d\n%s"+
+		"STC\n%s\nVMOVDQU64 Z%d,(DI)\nSETCS 64(DI)\nSTMXCSR 68(DI)\nRET\n",
+		name, 8+4*word, move, move, 8+word, move, 8+2*word, move, 8+3*word,
+		row.upper, row.destination, preparation, row.instruction(), row.destination)
+	declaration := fmt.Sprintf("func %s(value uint64,out *[80]byte,p *byte,upper,old *[64]byte)\n", name)
+	return source, declaration, name
+}
+
+func TestX86UnsignedScalarIntegerFloatCompleteInitializedFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("unsigned scalar complete objects require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86UnsignedScalarIntegerFloatRows(target.arch)
+			want := 32
+			if target.arch == "386" {
+				want = 28
+			}
+			if len(rows) != want {
+				t.Fatal("independent complete unsigned shape denominator changed", len(rows), want)
+			}
+			var source, declarations strings.Builder
+			functions := make(map[string][]string)
+			for index, row := range rows {
+				body, declaration, name := x86UnsignedScalarIntegerFloatProgram(index, row, target.arch)
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+				op := row.op
+				if target.arch == "386" {
+					op = strings.TrimSuffix(op, "Q")
+					if !strings.HasSuffix(op, "L") {
+						op += "L"
+					}
+				}
+				functions[name] = []string{op}
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete initialized unsigned scalar matrix remains unclosed", err)
+					}
+					for _, pipeline := range []struct{ name, level, ir string }{
+						{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+						{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+					} {
+						t.Run(pipeline.name, func(t *testing.T) {
+							x86ScalarPrecisionRequireNativeEffects(t, pipeline.ir, functions)
+							x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+						})
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_owner_go127_test.go b/x86_unsigned_scalar_integer_float_owner_go127_test.go
new file mode 100644
index 000000000..bba2f9c85
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_owner_go127_test.go
@@ -0,0 +1,23 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestX86UnsignedScalarIntegerFloatExistingCompleteOwnersRemainFirst(t *testing.T) {
+	owners := x86CaptureNativeFamilyOwnerOracle(t)
+	for _, member := range x86UnsignedScalarIntegerFloatOracle {
+		for _, kind := range []string{"GP", "FP", "native"} {
+			t.Run(member.op+"/"+kind, func(t *testing.T) {
+				row := x86UnsignedScalarIntegerFloatRow{op: member.op, source: kind, input: member.input, output: member.output, destination: 1}
+				source, declaration, name := x86UnsignedScalarIntegerFloatProgram(0, row, "amd64")
+				source = strings.Replace(source, "·"+name+"(SB)", "·Value(SB)", 1)
+				declaration = strings.Replace(declaration, "func "+name+"(", "func Value(", 1)
+				owners.checkProgram(t, source, declaration, row.instruction())
+			})
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_integer_float_physical_test.go b/x86_unsigned_scalar_integer_float_physical_test.go
new file mode 100644
index 000000000..dcff73043
--- /dev/null
+++ b/x86_unsigned_scalar_integer_float_physical_test.go
@@ -0,0 +1,77 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os/exec"
+	"strings"
+	"testing"
+)
+
+// Intel SDM VCVTUSI2SD/SS explicitly ignores W in non-64-bit mode. Keep the
+// raw byte producer independent of Go's canonical N8 table: a disp8 of three
+// means +12 for physical mode32, not +24. This observes encodings, not entry
+// registers, initialized values, source backing or native CPU execution.
+func TestX86UnsignedScalarIntegerFloatPhysicalModeAndCompressedTuple(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc is required for independent unsigned scalar physical decoding")
+	}
+	for _, mode := range []int{32, 64} {
+		arch, triple := "amd64", "x86_64-unknown-linux-gnu"
+		if mode == 32 {
+			arch, triple = "386", "i386-unknown-linux-gnu"
+		}
+		for _, pp := range []byte{2, 3} {
+			for _, wide := range []bool{false, true} {
+				for _, memory := range []bool{false, true} {
+					for length := byte(0); length < 3; length++ {
+						t.Run(fmt.Sprintf("%s/pp%d/W1=%t/memory=%t/LL%d", arch, pp, wide, memory, length), func(t *testing.T) {
+							code := encodeX86EVEXScalarIntegerFloat(true, pp, wide, length, false, 2, 1, 3)
+							if memory {
+								code[5] = 0x53 // disp8(BX), X1 -> X2.
+								code = append(code, 3)
+							}
+							var input, directives strings.Builder
+							for _, value := range code {
+								fmt.Fprintf(&input, "0x%02x ", value)
+								fmt.Fprintf(&directives, "BYTE $0x%02x\n", value)
+							}
+							source := "TEXT physical(SB),4,$0-0\n" + directives.String() + "RET\n"
+							actual := x86OrderingHintGoBytes(t, arch, source)
+							if !bytes.Equal(actual, append(append([]byte(nil), code...), 0xc3)) {
+								t.Fatal("actual Go changed the complete original scalar physical bytes", actual, code)
+							}
+							ctx, cancel := runtimeOracleStageContext(t)
+							defer cancel()
+							command := exec.CommandContext(ctx, mc, "--disassemble", "--triple="+triple, "--mattr=+avx512f")
+							command.Stdin = strings.NewReader(input.String() + "\n")
+							output, err := runtimeOracleCombinedOutput(ctx, command)
+							stem := "vcvtusi2ss"
+							if pp == 3 {
+								stem = "vcvtusi2sd"
+							}
+							width := 4
+							if wide && mode == 64 {
+								width = 8
+							}
+							if err != nil || strings.Contains(string(output), "warning:") || !strings.Contains(string(output), stem) ||
+								memory && !strings.Contains(string(output), fmt.Sprint(3*width)+"(") {
+								t.Fatal("independent LLVM physical scalar opcode/tuple prior failed", err, string(output))
+							}
+							ins, length, known, err := decodedX86ScalarIntegerFloatInstruction(code, mode)
+							if !known || err != nil || length != len(code) || ins.Op != scalarIntegerFloatRawOp(true, pp, wide) ||
+								len(ins.Args) != 3 || ins.Args[1].Reg != "X1" || ins.Args[2].Reg != "X2" {
+								t.Fatal("physical source identity or scalar upper/destination changed", ins, length, known, err)
+							}
+							if memory && (ins.Args[0].Kind != OpMem || ins.Args[0].Mem.Base != BX || ins.Args[0].Mem.Off != int64(3*width)) ||
+								!memory && (ins.Args[0].Kind != OpReg || ins.Args[0].Reg != BX) {
+								t.Fatal("WIG mode32 acquired the nominal Q source width/displacement", ins.Args[0], width)
+							}
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_unsigned_scalar_runtime_preflight_policy_test.go b/x86_unsigned_scalar_runtime_preflight_policy_test.go
new file mode 100644
index 000000000..ab9b4c3e0
--- /dev/null
+++ b/x86_unsigned_scalar_runtime_preflight_policy_test.go
@@ -0,0 +1,126 @@
+package plan9asm
+
+import (
+	"bytes"
+	"go/ast"
+	"go/format"
+	"go/token"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86UnsignedScalarOriginalRuntimeOwnsAllocationPreflight(t *testing.T) {
+	// These are the existing complete literal pins, not a digest of mutable
+	// test-driver formatting. The separate object matrix owns the original Go
+	// bytes and all three initialized public APIs on each x86 target.
+	x86UnsignedScalarIntegerFloatOriginal(t)
+	_, file, set := x86OriginalFloatingPolicyFile(t, "amd64_lower_scalar_integer_float_test.go")
+	owner := x86OriginalFloatingPolicyFunction(t, file, "TestAMD64ScalarIntegerFloatRuntimeSemantics")
+	var calls []*ast.CallExpr
+	boundary := owner.End()
+	ast.Inspect(owner.Body, func(node ast.Node) bool {
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		name, ok := call.Fun.(*ast.Ident)
+		if !ok {
+			return true
+		}
+		if name.Name == "x86OriginalFloatingRuntimeRequireCPU" {
+			calls = append(calls, call)
+		}
+		if name.Name == "compileAndRunRuntimeTestForTarget" && call.Pos() < boundary {
+			boundary = call.Pos()
+		}
+		return true
+	})
+	if len(calls) != 1 || boundary == owner.End() || calls[0].End() >= boundary {
+		t.Fatal("original unsigned runtime must own one actual-allocation CPU/opcode preflight before execution")
+	}
+	topLevel := false
+	for _, statement := range owner.Body.List {
+		if expression, ok := statement.(*ast.ExprStmt); ok && expression.X == calls[0] {
+			topLevel = true
+		}
+	}
+	if !topLevel {
+		t.Fatal("unsigned allocation preflight must not be conditional, deferred or delegated to another owner")
+	}
+	var actual bytes.Buffer
+	if err := format.Node(&actual, set, calls[0]); err != nil {
+		t.Fatal(err)
+	}
+	const want = `x86OriginalFloatingRuntimeRequireCPU(t, "unsigned-scalar-integer", clang, triple, runPrefix)`
+	if actual.String() != want {
+		t.Fatal("unsigned preflight substituted its own profile, compiler, target or execution route", actual.String())
+	}
+}
+
+func TestX86UnsignedScalarOriginalRuntimeCompleteOpcodeProfile(t *testing.T) {
+	_, file, _ := x86OriginalFloatingPolicyFile(t, "x86_original_floating_runtime_preflight_test.go")
+	driver := x86OriginalFloatingPolicyFunction(t, file, "x86OriginalFloatingRuntimeRequireCPU")
+	profiles := 0
+	ast.Inspect(driver.Body, func(node ast.Node) bool {
+		clause, ok := node.(*ast.CaseClause)
+		if !ok {
+			return true
+		}
+		for _, expression := range clause.List {
+			literal, ok := expression.(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				continue
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil || value != "unsigned-scalar-integer" {
+				continue
+			}
+			profiles++
+			var body bytes.Buffer
+			for _, statement := range clause.Body {
+				if err := format.Node(&body, token.NewFileSet(), statement); err != nil {
+					t.Fatal(err)
+				}
+			}
+			if strings.Join(strings.Fields(body.String()), "") != "required=3" {
+				t.Fatal("unsigned opcode diagnostic borrowed another capability profile", body.String())
+			}
+		}
+		return true
+	})
+	if profiles != 1 {
+		t.Fatal("independent unsigned scalar execution profile is missing or duplicated", profiles)
+	}
+	_, opcodes := x86OriginalFloatingPolicyDriver(t)
+	const opening = "__attribute__((target(\"avx512f\")))\nstatic int original_unsigned_scalar_integer(void) {"
+	start := strings.Index(opcodes, opening)
+	if start < 0 || strings.Count(opcodes, "static int original_unsigned_scalar_integer(void)") != 1 {
+		t.Fatal("unsigned scalar original-opcode probe must have its own exact F-only target function")
+	}
+	rest := opcodes[start+len(opening):]
+	end := strings.Index(rest, "\n}\n")
+	if end < 0 {
+		t.Fatal("complete unsigned scalar original-opcode function disappeared")
+	}
+	probe := rest[:end]
+	for _, required := range []string{
+		"vcvtusi2sdl ", "vcvtusi2sdq ", "vcvtusi2ssl ", "vcvtusi2ssq ",
+		"%{rz-sae%}", "%{rd-sae%}", "%{rn-sae%}",
+		"vmovss ", "vmovsd ",
+	} {
+		if !strings.Contains(probe, required) {
+			t.Fatal("unsigned profile lost an original width, actual opcode, result observation or embedded control", required)
+		}
+	}
+	mainStart := strings.LastIndex(opcodes, "int main(void)")
+	if mainStart < 0 {
+		t.Fatal("actual unsigned allocation preflight main is missing")
+	}
+	main := opcodes[mainStart:]
+	guard := strings.Index(main, "if (!original_floating_required_state(")
+	probeCall := strings.Index(main, "if (profile==3 && !original_unsigned_scalar_integer()) return 81;")
+	if guard < 0 || probeCall <= guard {
+		t.Fatal("unsigned original opcodes must execute only after their own actual CPUID/XCR0 guard and fail on wrong results")
+	}
+}
diff --git a/x86_vector_compare_native_continuation_test.go b/x86_vector_compare_native_continuation_test.go
new file mode 100644
index 000000000..75db7fe37
--- /dev/null
+++ b/x86_vector_compare_native_continuation_test.go
@@ -0,0 +1,160 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent ymm/yxm_q4, _yvpcmpeqb and _yvpcmpb native-source shapes.
+// MMX's physical state and raw mode32 EVEX entries have separate owners.
+func x86CompareNativeRows(arch string) []string {
+	var rows []string
+	for _, op := range []string{"PCMPEQB", "PCMPEQW", "PCMPEQL", "PCMPEQQ", "PCMPGTB", "PCMPGTW", "PCMPGTL", "PCMPGTQ"} {
+		rows = append(rows, op+" 3(AX)(DX*2),X2")
+	}
+	for _, op := range []string{"VPCMPEQB", "VPCMPEQW", "VPCMPEQD", "VPCMPEQQ", "VPCMPGTB", "VPCMPGTW", "VPCMPGTD", "VPCMPGTQ",
+		"VPCMPB", "VPCMPW", "VPCMPD", "VPCMPQ", "VPCMPUB", "VPCMPUW", "VPCMPUD", "VPCMPUQ"} {
+		immediate := !strings.HasPrefix(op, "VPCMPEQ") && !strings.HasPrefix(op, "VPCMPGT")
+		if arch == "386" && immediate {
+			continue // Go's named mode32 frontend rejects the leading-immediate arity.
+		}
+		prefix := ""
+		if immediate {
+			prefix = "$4,"
+		}
+		for _, bank := range []string{"X", "Y", "Z"} {
+			if bank != "Z" && !immediate {
+				rows = append(rows, fmt.Sprintf("%s 3(AX)(DX*2),%s1,%s2", op, bank, bank))
+			}
+			for _, mask := range []string{"", "K1,"} {
+				if arch == "386" && mask != "" {
+					continue // A fourth named operand has no mode32 Go source encoding.
+				}
+				operands := fmt.Sprintf("%s3(AX)(DX*2),%s1,%sK2", prefix, bank, mask)
+				rows = append(rows, op+" "+operands)
+				if strings.HasSuffix(op, "D") || strings.HasSuffix(op, "Q") {
+					rows = append(rows, op+".BCST "+operands)
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func x86CompareNativeFixture(arch, row string) (string, string) {
+	word, move, maskMove := 8, "MOVQ", "KMOVQ"
+	if arch == "386" {
+		word, move, maskMove = 4, "MOVL", "KMOVD"
+	}
+	finish := "PEXTRD $0,X2,AX\n"
+	if strings.HasSuffix(row, "K2") {
+		finish = "KMOVD K2,AX\n"
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\n%s CX,K1\n"+
+			"MOVL $1,DX\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n%s\n%sMOVL AX,ret+%d(FP)\nRET\n",
+			2*word+4, move, move, word, maskMove, row, finish, 2*word),
+		"func Value(p *[128]byte,mask uintptr) uint32"
+}
+
+func TestX86CompareNativeCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			rows := x86CompareNativeRows(target.arch)
+			want := 168
+			if target.arch == "386" {
+				want = 60
+			}
+			if len(rows) != want {
+				t.Fatal("complete independent native compare inventory changed", len(rows), want)
+			}
+			for start := 0; start < len(rows); start += 64 {
+				end := start + 64
+				if end > len(rows) {
+					end = len(rows)
+				}
+				t.Run(fmt.Sprint(start/64), func(t *testing.T) {
+					var source, declarations strings.Builder
+					var names []string
+					for index := start; index < end; index++ {
+						body, declaration := x86CompareNativeFixture(target.arch, rows[index])
+						name := fmt.Sprintf("CompareNative%d", index)
+						names = append(names, name)
+						source.WriteString(strings.ReplaceAll(body, "Value", name))
+						declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+					}
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(api, func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+							if err != nil {
+								t.Fatal("initialized native compare cannot publish its result", err)
+							}
+							for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+								x86CompactExpandRequireAllDefinitions(t, text, names)
+								for _, level := range []string{"-O0", "-O2"} {
+									x86PackedStringCompileObject(t, llc, target.triple, text, level)
+								}
+							}
+						})
+					}
+				})
+			}
+		})
+	}
+}
+
+func TestX86CompareNativeCannotBorrowInputFacts(t *testing.T) {
+	for _, row := range x86CompareNativeRows("amd64") {
+		source, declaration := x86CompareNativeFixture("amd64", row)
+		pkg := mustGoPackage(t, "compare", "package compare\n"+declaration)
+		file := mustParseX86RawReturn(t, source)
+		signatures, err := goSigsForAsmFile(pkg, file, func(name string) string {
+			return strings.TrimPrefix(name, "·")
+		}, "amd64", nil, nil, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := CheckX86ABI0ResultInitialization(file.Funcs[0], signatures["Value"], "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("declaration-only compare borrowed its paired native emitter", row, err)
+		}
+		variants := map[string]string{
+			"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+			"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+			"numeric-pointer": strings.Replace(source, "MOVL $1,DX", "MOVL $42,AX\nMOVL $1,DX", 1),
+		}
+		if strings.Contains(row, "K1,") {
+			variants["unknown-mask"] = strings.Replace(source, "KMOVQ CX,K1\n", "", 1)
+		}
+		vector := "Z1"
+		if !strings.HasPrefix(row, "V") {
+			vector = "Z2"
+		}
+		variants["unknown-vector"] = strings.Replace(source, fmt.Sprintf("VPXORD %s,%s,%s\n", vector, vector, vector), "", 1)
+		for name, changed := range variants {
+			t.Run(row+"/"+name, func(t *testing.T) {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if name == "numeric-pointer" {
+						originalIR, originalErr := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil || originalErr != nil || ir == "" {
+							t.Fatal("complete NUM compare source rejected", err, originalErr)
+						}
+						x86RequireSameNativeMemoryEffects(t, originalIR, ir)
+						x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if name == "unknown-vector" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("compare acquired missing native/vector/mask inputs", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_vector_scratch_codegen_controls_test.go b/x86_vector_scratch_codegen_controls_test.go
new file mode 100644
index 000000000..f8f68bdc1
--- /dev/null
+++ b/x86_vector_scratch_codegen_controls_test.go
@@ -0,0 +1,80 @@
+package plan9asm
+
+import (
+	"errors"
+	"go/types"
+	"strings"
+	"testing"
+)
+
+// These designated ordinary ABI0 controls choose the emitter's existing vector
+// scratch values. They do not prove arbitrary physical entry registers, caller
+// memory, or a reusable source/storage permission.
+func x86VectorScratchCodegenControl(t *testing.T, source, declaration, arch, triple, ir string, codegenErr error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "scratch", "package scratch\n"+declaration)
+	x86VectorScratchCodegenPackageControl(t, source, pkg, arch, triple, ir, codegenErr)
+}
+
+func x86VectorScratchCodegenPackageControl(t *testing.T, source string, pkg GoPackage, arch, triple, ir string, codegenErr error) {
+	t.Helper()
+	if arch != "amd64" || codegenErr != nil || ir == "" {
+		t.Fatal("ordinary AMD64 scratch code generation failed", arch, codegenErr)
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resolve := testResolveSym(pkg.Path)
+	signatures, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	storage, err := bindGoReadOnlyStorage(pkg, file, types.SizesFor("gc", arch), arch, resolve)
+	if err != nil {
+		t.Fatal(err)
+	}
+	values := x86LoweredStaticAddressValues(file, resolve, signatures, arch)
+	usedScratch := false
+	for _, fn := range file.Funcs {
+		sig := signatures[resolve(fn.Sym)]
+		if len(sig.Frame.Params) == 0 && len(sig.Frame.Results) == 0 || !x86OrdinaryScalarCodegenSource(fn, sig, arch) {
+			t.Fatal("scratch control lacks a typed logical frame or acquired a private entry role")
+		}
+		for _, query := range []func(Func, FuncSig, string) error{
+			CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization,
+		} {
+			if err := query(fn, sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("ordinary scratch choice escaped into a strict source query", err)
+			}
+		}
+		var output strings.Builder
+		consumer := newX86Ctx(&output, fn, sig, resolve, signatures, arch, triple, false)
+		// Reconstruct only the ordinary immutable inputs used by Translate.
+		// This grants no SDK, raw, caller-memory or fixed-frame owner.
+		consumer.goReadOnlyStorage = storage
+		consumer.fpStaticAddressValues = values
+		consumer.fpScalarData = x86LoweredScalarDataReads(file, resolve, signatures, arch)
+		consumer.fpShiftLiterals = x86LoweredShiftLiterals(file, resolve, values, arch)
+		if err := consumer.scalarFPResultInitialized(); err != nil {
+			t.Fatal("lowering-owned scratch plan lost its paired check", err)
+		}
+		cached := consumer.fpScalarCheckErr
+		if !consumer.fpScalarChecked {
+			t.Fatal("code generation omitted its source audit")
+		}
+		if cached != nil {
+			if !errors.Is(cached, ErrProbeNeedsContext) {
+				t.Fatal("scratch source lost its lowering-only audit error", cached)
+			}
+			usedScratch = true
+		}
+		if err := consumer.scalarFPResultInitialized(); err != nil || consumer.fpScalarCheckErr != cached || output.Len() != 0 {
+			t.Fatal("cached strict error was replaced or emitted code", err)
+		}
+	}
+	if !usedScratch {
+		t.Fatal("the complete source did not exercise lowering-owned vector scratch")
+	}
+	x86NumericNativeAddressObject(t, ir, triple)
+}
diff --git a/x86_vector_test_native_input_test.go b/x86_vector_test_native_input_test.go
new file mode 100644
index 000000000..213ee84f0
--- /dev/null
+++ b/x86_vector_test_native_input_test.go
@@ -0,0 +1,69 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86VectorTestInputRows() []string {
+	return []string{
+		"PTEST (SI),X1",
+		"VPTEST (SI),X1", "VPTEST (SI),Y1",
+		"VTESTPD (SI),X1", "VTESTPD (SI),Y1",
+		"VTESTPS (SI),X1", "VTESTPS (SI),Y1",
+	}
+}
+
+func TestX86VectorTestPairedNativeCompleteFamilyFiveTargetObjects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			for _, raw := range []bool{false, true} {
+				var source, declarations strings.Builder
+				for index, row := range x86VectorTestInputRows() {
+					operation := row
+					if raw {
+						operation = x86RawNumericalInstruction(t, target.arch, row)
+					}
+					name := fmt.Sprint("VectorTest", index)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s out+0(FP),DI\n"+
+						"MOV%s input+%d(FP),SI\nMOV%s old+%d(FP),BX\nVMOVUPS (BX),Y1\n"+
+						"PUSH%s $0\nPOPF%s\n%s\nPUSHF%s\nPOP%s AX\nMOV%s AX,(DI)\nRET\n",
+						name, 3*word, suffix, suffix, word, suffix, 2*word, suffix, suffix,
+						operation, suffix, suffix, suffix)
+					fmt.Fprintf(&declarations, "func %s(out *[16]byte,input,old *[32]byte)\n", name)
+				}
+				x86RawNumericalFamilyObjects(t, source.String(), declarations.String(), target.arch, target.triple)
+			}
+		})
+	}
+}
+
+func TestX86VectorTestDeadInputsCannotBorrowVoidOrBool(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86VectorTestInputRows() {
+			for _, raw := range []bool{false, true} {
+				operation := row
+				if raw {
+					operation = x86RawNumericalInstruction(t, target.arch, row)
+				}
+				source := "TEXT ·Value(SB),4,$0\n" + operation + "\nRET\n"
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+				for _, declaration := range []string{"func Value()", "func Value(unused bool)"} {
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("vector test borrowed native inputs from Void or unused bool", row, raw,
+								target.triple, declaration, api, err)
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_vector_test_native_object_test.go b/x86_vector_test_native_object_test.go
new file mode 100644
index 000000000..fa39bffb6
--- /dev/null
+++ b/x86_vector_test_native_object_test.go
@@ -0,0 +1,85 @@
+package plan9asm
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86VectorTestDeadNativeReadsKeepExactOpcodesAndFeatures(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			declarations.WriteString("package deadvector\n")
+			word, suffix := goWordSize(target.arch), "Q"
+			if word == 4 {
+				suffix = "L"
+			}
+			for index, row := range x86VectorTestInputRows() {
+				ins := x86ScalarLaneInstruction(t, row)
+				want := "+avx"
+				if strings.HasPrefix(row, "PTEST") {
+					want = "+sse4.1"
+				}
+				if got := inferFuncTargetFeaturesForGOARCH(ArchAMD64, target.arch, Func{Instrs: []Instr{ins}}); got != want {
+					t.Fatal("isolated native vector test borrowed sibling ISA features", row, got, want)
+				}
+				move, bank := "MOVUPS", "X"
+				if strings.HasSuffix(row, "Y1") {
+					move, bank = "VMOVUPS", "Y"
+				}
+				name := fmt.Sprint("Dead", index)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOV%s input+0(FP),SI\n"+
+					"MOV%s old+%d(FP),BX\n%s (BX),%s1\n%s\nRET\n",
+					name, 2*word, suffix, suffix, word, move, bank, row)
+				fmt.Fprintf(&declarations, "func %s(input,old *[32]byte)\n", name)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86OrderingHintTranslateAPI(t, api, source.String(), declarations.String(), target.arch, target.triple)
+				if err != nil {
+					t.Fatal("initialized dead memory effects lost their actual incoming pointers", api, err)
+				}
+				// Original MOVUPS input producers retain their own native
+				// instructions and SSE feature; do not count them as PTESTs.
+				tests := regexp.MustCompile(`asm sideeffect "(?:v?ptest|vtestpd|vtestps) `)
+				if len(tests.FindAllString(ir, -1)) != 7 || !strings.Contains(ir, "+sse4.1") ||
+					!strings.Contains(ir, "+avx") || strings.Contains(ir, "+avx2") {
+					t.Fatal("native vector-test opcode or minimal carrier features lost", api)
+				}
+				for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					file := filepath.Join(t.TempDir(), "dead.ll")
+					if err := os.WriteFile(file, []byte(input), 0600); err != nil {
+						t.Fatal(err)
+					}
+					for _, level := range []string{"-O0", "-O2"} {
+						ctx, cancel := runtimeOracleStageContext(t)
+						command := exec.CommandContext(ctx, llc, level, "-mtriple="+target.triple, "-filetype=asm", file, "-o", "-")
+						output, err := runtimeOracleCombinedOutput(ctx, command)
+						cancel()
+						if err != nil {
+							t.Fatal("complete dead vector-test native assembly", err, string(output))
+						}
+						for _, op := range []struct {
+							name  string
+							count int
+						}{{"ptest", 1}, {"vptest", 2}, {"vtestpd", 2}, {"vtestps", 2}} {
+							pattern := regexp.MustCompile(`(?m)^\s+` + op.name + `\s+[^\n]*\(`)
+							if got := len(pattern.FindAll(output, -1)); got != op.count {
+								t.Fatal("dead full-width source instruction disappeared or duplicated", api, level, op.name, got)
+							}
+						}
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_vector_test_native_state_test.go b/x86_vector_test_native_state_test.go
new file mode 100644
index 000000000..f95ad6282
--- /dev/null
+++ b/x86_vector_test_native_state_test.go
@@ -0,0 +1,150 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86VectorTestCompleteIndependentEncoderRows(t *testing.T) {
+	data, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !regexp.MustCompile(`(?s)var yxm_q4 = \[\]ytab\{\s*\{Zm_r, 1, argList\{Yxm, Yxr\}\},\s*\}`).Match(data) ||
+		!strings.Contains(string(data), "{APTEST, yxm_q4, Pq4, opBytes{0x17}}") {
+		t.Fatal("complete legacy PTEST row, prefix or opcode changed")
+	}
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	counts := map[string]int{}
+	opcodes := map[string]string{"VPTEST": "0x17", "VTESTPD": "0x0F", "VTESTPS": "0x0E"}
+	for _, rule := range rules {
+		opcode, wanted := opcodes[rule.Opcode]
+		if !wanted {
+			continue
+		}
+		index := counts[rule.Opcode]
+		counts[rule.Opcode]++
+		classes := []string{"Yxm,Yxr", "Yym,Yyr"}
+		bytes := []string{"avxEscape | vex128 | vex66 | vex0F38 | vexW0", opcode,
+			"avxEscape | vex256 | vex66 | vex0F38 | vexW0", opcode}
+		if index >= 2 || rule.RowIndex != index || rule.Ytab != "_yvptest" || rule.Prefix != "Pavx" ||
+			rule.ZCase != "Zvex_rm_v_r" || rule.ZOffset != 2 || rule.EncodingOffset != 2*index ||
+			strings.Join(rule.Classes, ",") != classes[index] || !reflect.DeepEqual(rule.OpBytes, bytes) {
+			t.Fatal("complete vector-test encoder grammar or attributes changed", rule)
+		}
+	}
+	for name := range opcodes {
+		if counts[name] != 2 {
+			t.Fatal("incomplete VEX vector-test inventory", counts)
+		}
+	}
+	if len(amd64VectorTestSpecs) != 4 {
+		t.Fatal("unaccounted vector-test family member")
+	}
+}
+
+func TestX86VectorTestPairedBytesFlagsAndStandaloneBoundary(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86VectorTestInputRows() {
+			ins := x86ScalarLaneInstruction(t, row)
+			width := amd64VectorByteWidth(ins.Args[1].Reg)
+			for missing := -1; missing < width; missing++ {
+				state := x86ResultState{flags: x86ByteFlagAF, direction: x86ResultDirectionEither}
+				state.pointerGP[6], state.gp[3] = true, 0x55
+				state.xmm[1], state.vectorUpper[1], state.masks[2] = 0xffff, ^uint64(0)&^0xffff, true
+				if missing >= 0 {
+					state.writeVector(1, width, state.vectorBytes(1)&^(uint64(1)<<uint(missing)), true)
+				}
+				before := state.clone()
+				if accepted, known := x86ResultVectorTestStep(ins, &state, nil, arch); !known || accepted ||
+					!reflect.DeepEqual(state, before) {
+					t.Fatal("standalone vector test acquired native backing or changed a failed state", arch, row)
+				}
+				accepted, known := x86LoweredVectorTestResultStep(ins, &state, nil, arch)
+				want := before.clone()
+				if missing < 0 {
+					want.flags = x86ByteFlagsAll
+				}
+				if !known || accepted != (missing < 0) || !reflect.DeepEqual(state, want) {
+					t.Fatal("vector-test bytes/FLAGS changed unrelated state or invented missing inputs", arch, row, missing)
+				}
+			}
+		}
+	}
+}
+
+func TestX86VectorTestRawIdentityRetainsSeparateControlEffects(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86VectorTestInputRows() {
+			file, err := Parse(ArchAMD64, "TEXT Value(SB),4,$0-0\n"+x86RawNumericalInstruction(t, arch, row)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			file, err = normalizeX86RawFile(file, arch)
+			if err != nil {
+				t.Fatal(err)
+			}
+			ins := file.Funcs[0].Instrs[1]
+			if !x86RawVectorTestSource(ins, arch) || !x86ResultPreservesPrivateStorage(ins, arch) ||
+				x86PreservesNumericalSourceState(ins) ||
+				x86ResultDirectionAfterSource(ins, x86ResultDirectionEither, arch) != x86ResultDirectionEither {
+				t.Fatal("exact vector test confused arithmetic FLAGS, private controls and inert-source roles", row)
+			}
+			for _, change := range []func(*Instr){
+				func(ins *Instr) { ins.Args[1].Reg = "X3" },
+				func(ins *Instr) { ins.x86AddressBits = 16 },
+				func(ins *Instr) { ins.x86UnboundAddressOverride = true },
+				func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+				func(ins *Instr) { ins.x86RIPLiteral = true },
+			} {
+				changed := ins
+				changed.Args = append([]Operand(nil), ins.Args...)
+				change(&changed)
+				if x86RawVectorTestSource(changed, arch) || x86ResultPreservesPrivateStorage(changed, arch) ||
+					x86ResultDirectionAfterSource(changed, x86ResultDirectionEither, arch) != x86ResultDirectionUnknown {
+					t.Fatal("changed original vector test borrowed private controls", arch, row)
+				}
+			}
+		}
+	}
+}
+
+func TestX86VectorTestLogicalFPBytesDoNotAcquireLegacyNativeStorage(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range x86VectorTestInputRows() {
+			width := 16
+			if strings.HasSuffix(row, "Y1") {
+				width = 32
+			}
+			parameters := "a,b uint64"
+			if width == 32 {
+				parameters = "a,b,c,d uint64"
+			}
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\nVPXORD Y1,Y1,Y1\n%s\nRET\n",
+				width, strings.Replace(row, "(SI)", "a+0(FP)", 1))
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source, "func Value("+parameters+")", target.arch, target.triple, api)
+				if strings.HasPrefix(row, "PTEST") {
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("logical FP values supplied legacy native storage", target, api)
+					}
+				} else if err != nil || ir == "" {
+					t.Fatal("complete numerical FP span lost its virtual-value consumer", target, api, row, err)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_vector_value_mode32_memory_test.go b/x86_vector_value_mode32_memory_test.go
new file mode 100644
index 000000000..987a7a4bc
--- /dev/null
+++ b/x86_vector_value_mode32_memory_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86VectorValueMemoryGrammarError(ins Instr, arch string) error {
+	if _, _, known, err := x86IndexedPermuteProperties(ins.Op, ins, arch); known {
+		return err
+	}
+	if _, known, err := x86GFNIProperties(ins.Op, ins, arch); known {
+		return err
+	}
+	if _, known, err := x86PackedBitCountProperties(ins.Op, ins, arch); known {
+		return err
+	}
+	return fmt.Errorf("unregistered vector value fixture %s", ins.Op)
+}
+
+func TestX86VectorValueMode32HighGPAddressesNeedPhysicalContext(t *testing.T) {
+	for _, bank := range []string{"X", "Y", "Z"} {
+		var instructions []string
+		for _, op := range x86IndexedPermuteResultNames {
+			instructions = append(instructions, fmt.Sprintf("%s ADDRESS,%s1,%s2", op, bank, bank))
+		}
+		instructions = append(instructions, fmt.Sprintf("VGF2P8MULB ADDRESS,%s1,%s2", bank, bank))
+		for _, member := range x86BitCountResultOracle {
+			instructions = append(instructions, fmt.Sprintf("%s ADDRESS,%s2", member.name, bank))
+		}
+		if len(instructions) != 21 {
+			t.Fatal("complete named mode32 value family changed", len(instructions))
+		}
+		for _, template := range instructions {
+			for _, memory := range []string{"8(R9)", "8(R14)", "16(R15)"} {
+				instruction := strings.Replace(template, "ADDRESS", memory, 1)
+				t.Run(bank+"/"+instruction, func(t *testing.T) {
+					goAssemblerOracleOutput(t, "386", "TEXT ·Value(SB),4,$0-0\n"+instruction+"\nRET\n", "", true)
+					ins := x86ScalarLaneInstruction(t, instruction)
+					if err := x86VectorValueMemoryGrammarError(ins, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("Go-accepted extended address must retain its unbound physical mode32 role", err)
+					}
+					if err := x86VectorValueMemoryGrammarError(ins, "amd64"); err != nil {
+						t.Fatal("valid AMD64 address lost its complete operand grammar", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86VectorValueMode32AddressContextDoesNotHideInvalidFormats(t *testing.T) {
+	for _, instruction := range []string{
+		"VPERMB.BAD 8(R9),X1,X2",
+		"VPERMB 8(R9),X1,K0,X2",
+		"VGF2P8MULB.BCST 8(R9),X1,X2",
+		"VGF2P8AFFINEQB $0,8(R9),X1,X2",
+		"VPLZCNTD.BAD 8(R9),X1",
+		"VPOPCNTB.BCST 8(R9),X1",
+		"VPOPCNTB 8(R9),AX",
+		"VPOPCNTB 8(AX)(R9*3),X1",
+		"VPOPCNTB 8(AX)(R9*2),X1",
+		"VPOPCNTB 8(R12),X1",
+		"VPLZCNTD 8(R9)(CX*2),X1",
+		"VPOPCNTQ 8(R9),K0,X1",
+	} {
+		t.Run(instruction, func(t *testing.T) {
+			if strings.Contains(instruction, "*3)") {
+				_, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+instruction+"\nRET\n")
+				if err == nil || errors.Is(err, ErrProbeNeedsContext) || !strings.Contains(err.Error(), "(R9*3)") {
+					t.Fatal("invalid source scale did not retain its fixture-bound parser rejection", err)
+				}
+				return
+			}
+			ins := x86ScalarLaneInstruction(t, instruction)
+			if err := x86VectorValueMemoryGrammarError(ins, "386"); err == nil || errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("invalid format was hidden by an unrelated address context", err)
+			}
+		})
+	}
+}
diff --git a/x86_vector_value_native_fault_unix_test.go b/x86_vector_value_native_fault_unix_test.go
new file mode 100644
index 000000000..1ae6f613e
--- /dev/null
+++ b/x86_vector_value_native_fault_unix_test.go
@@ -0,0 +1,121 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VectorValueNativePortableFaults(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	var source, declarations, prototypes, checks strings.Builder
+	count := 0
+	for _, member := range x86NativeVectorValueMembers() {
+		for _, mode := range []string{"plain", "merge", "zero"} {
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !member.broadcast {
+					continue
+				}
+				body, declaration := x86NativeVectorValueFixture(member, "amd64", "Z", mode, broadcast, true)
+				name := fmt.Sprintf("FaultValue%d", count)
+				count++
+				source.WriteString(strings.ReplaceAll(body, "Value", name))
+				declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+				fmt.Fprintf(&prototypes, "extern uint32_t %s(uint8_t *,uintptr_t);\n", name)
+				bits := 8
+				if member.unary {
+					switch member.name[len(member.name)-1] {
+					case 'W':
+						bits = 16
+					case 'D':
+						bits = 32
+					case 'Q':
+						bits = 64
+					}
+				}
+				// E4 can suppress inactive unary lane reads. Indexed permutes
+				// and GFNI are E4NF, including zero masks and dead results.
+				suppresses := member.unary && mode != "plain"
+				zeroFault, tailFault := 1, 1
+				if suppresses {
+					zeroFault = 0
+					if !broadcast {
+						tailFault = 0
+					}
+				}
+				width := 64
+				if broadcast {
+					width = bits / 8
+					if member.immediate || strings.HasSuffix(member.name, "Q") || strings.HasSuffix(member.name, "PD") {
+						width = 8
+					} else {
+						width = 4
+					}
+				}
+				fmt.Fprintf(&checks, "if(observe(%s,0,0,%d,\"%s/null-zero\"))return 1;\n", name, zeroFault, name)
+				fmt.Fprintf(&checks, "if(observe(%s,0,UINTPTR_MAX,1,\"%s/null-active\"))return 1;\n", name, name)
+				fmt.Fprintf(&checks, "if(observe(%s,storage+page-%d-5,UINTPTR_MAX,0,\"%s/exact-width\"))return 1;\n", name, width, name)
+				fmt.Fprintf(&checks, "if(observe(%s,storage+page-%d-4,UINTPTR_MAX,1,\"%s/last-byte\"))return 1;\n", name, width, name)
+				if !broadcast {
+					fmt.Fprintf(&checks, "if(observe(%s,storage+page-%d-5,1,%d,\"%s/one-lane\"))return 1;\n", name, bits/8, tailFault, name)
+				}
+			}
+		}
+	}
+	if count != 111 {
+		t.Fatal("complete native fault denominator changed", count)
+	}
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <unistd.h>\n#include <signal.h>\n" +
+		"#include <errno.h>\n#include <string.h>\n#include <sys/mman.h>\n#include <sys/wait.h>\n#include <sys/resource.h>\n" +
+		numericalRuntimeFaultObservationC + prototypes.String() + `
+static uint8_t *protected_region;
+static size_t protected_bytes;
+static int observe(uint32_t (*fn)(uint8_t *,uintptr_t),uint8_t *p,uintptr_t mask,int fault,const char *name) {
+ pid_t child=fork();
+ if(child<0)return 1;
+ if(child==0) {
+  struct rlimit observed;
+  if(getrlimit(RLIMIT_CORE,&observed)||observed.rlim_cur||observed.rlim_max)_exit(120);
+  numerical_fault_begin(p ? protected_region : 0,protected_bytes);
+  _exit(fn(p,mask)==7?0:1);
+ }
+ int status;
+ pid_t waited;
+ do {waited=waitpid(child,&status,0);} while(waited<0&&errno==EINTR);
+ if(waited!=child)return 1;
+ if(fault ? numerical_fault_status(status) :
+             (WIFEXITED(status)&&WEXITSTATUS(status)==0))return 0;
+ fprintf(stderr,"%s mask=%llx expected fault=%d wait=%x\n",name,(unsigned long long)mask,fault,status);
+ return 1;
+}
+int main(void) {
+ struct rlimit no_core={0,0};
+ if(setrlimit(RLIMIT_CORE,&no_core))return 1;
+ long page=sysconf(_SC_PAGESIZE);
+ if(page<128)return 1;
+ uint8_t *storage=mmap(0,2*page,PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON,-1,0);
+ if(storage==MAP_FAILED||mprotect(storage+page,page,PROT_NONE))return 1;
+ protected_region=storage+page;
+ protected_bytes=(size_t)page;
+` + checks.String() + "return munmap(storage,2*page)!=0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete portable native fault source rejected", err)
+			}
+			for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+				for _, level := range []int{0, 2} {
+					compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "vector-value-faults", triple, text, driver, nil, level)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_vector_value_native_test.go b/x86_vector_value_native_test.go
new file mode 100644
index 000000000..ca9852c2a
--- /dev/null
+++ b/x86_vector_value_native_test.go
@@ -0,0 +1,249 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Independent current-Go opcode/attribute inventories are shared with the
+// existing exhaustive register and same-file DATA oracles, not production maps.
+func x86NativeVectorValueMembers() []x86FixedLaneValueOracle {
+	var members []x86FixedLaneValueOracle
+	for _, name := range x86IndexedPermuteResultNames {
+		members = append(members, x86FixedLaneValueOracle{name: name,
+			broadcast: !strings.HasSuffix(name, "B") && !strings.HasSuffix(name, "W")})
+	}
+	members = append(members, x86GFNIResultOracle...)
+	return append(members, x86BitCountResultOracle...)
+}
+
+func x86NativeVectorValueFixture(member x86FixedLaneValueOracle, arch, bank, mode string, broadcast, dead bool) (string, string) {
+	word, move, maskMove := 8, "MOVQ", "KMOVQ"
+	if arch == "386" {
+		word, move, maskMove = 4, "MOVL", "KMOVD"
+	}
+	op, immediate, mask := member.name, "", ""
+	if broadcast {
+		op += ".BCST"
+	}
+	if member.immediate {
+		immediate = "$99,"
+	}
+	if mode != "plain" {
+		mask = "K1,"
+	}
+	if mode == "zero" {
+		op += ".Z"
+	}
+	second := bank + "1,"
+	if member.unary {
+		second = ""
+	}
+	result := "PEXTRD $0,X2,AX\n"
+	if dead {
+		result = "MOVL $7,AX\n"
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s p+0(FP),AX\n%s mask+%d(FP),CX\n"+
+		"%s CX,K1\nMOVL $1,DX\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"+
+		"%s %s3(AX)(DX*2),%s%s%s2\n%sMOVL AX,ret+%d(FP)\nRET\n",
+		2*word+4, move, move, word, maskMove, op, immediate, second, mask, bank, result, 2*word)
+	return source, "func Value(p *[128]byte,mask uintptr) uint32"
+}
+
+func TestX86VectorValueNativeCompleteFiveTargetsThreeAPIs(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	members := x86NativeVectorValueMembers()
+	if len(members) != 23 {
+		t.Fatal("complete native value-family denominator changed", len(members))
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			var source, declarations strings.Builder
+			var names []string
+			for _, member := range members {
+				if target.arch == "386" && member.immediate {
+					continue // Original cmd/asm named four-operand boundary stays separate.
+				}
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if target.arch == "386" && !member.unary && mode != "plain" {
+						continue // No physical mode32 arity is invented by a numerical proof.
+					}
+					for _, broadcast := range []bool{false, true} {
+						if broadcast && !member.broadcast {
+							continue
+						}
+						body, declaration := x86NativeVectorValueFixture(member, target.arch, "Z", mode, broadcast, false)
+						name := fmt.Sprintf("NativeValue%d", len(names))
+						names = append(names, name)
+						source.WriteString(strings.ReplaceAll(body, "Value", name))
+						declarations.WriteString(strings.ReplaceAll(declaration, "Value", name) + "\n")
+					}
+				}
+			}
+			want := 111
+			if target.arch == "386" {
+				want = 53
+			}
+			if len(names) != want {
+				t.Fatal("complete native mode/broadcast denominator changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+				if err != nil || ir == "" {
+					t.Fatal("complete initialized native value source rejected", api, err)
+				}
+				x86CompactExpandRequireAllDefinitions(t, ir, names)
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					for _, level := range []string{"-O0", "-O2"} {
+						x86PackedStringCompileObject(t, llc, target.triple, text, level)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86VectorValueNativeMissingInputsStayContext(t *testing.T) {
+	for _, member := range x86NativeVectorValueMembers() {
+		t.Run(member.name, func(t *testing.T) {
+			source, declaration := x86NativeVectorValueFixture(member, "amd64", "Z", "merge", false, false)
+			body := strings.SplitN(source, "\n", 2)[1]
+			_, file, sig, _ := x86ResultInitializationFixture(t, "amd64", declaration, body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if err := check(file.Funcs[0], sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone query borrowed native continued execution", err)
+				}
+			}
+			variants := map[string]string{
+				"unknown-pointer": strings.Replace(source, "p+0(FP),AX", "p+0(FP),DI", 1),
+				"numeric-pointer": strings.Replace(source, "MOVL $1,DX", "MOVL $42,AX\nMOVL $1,DX", 1),
+				"unknown-index":   strings.Replace(source, "MOVL $1,DX\n", "", 1),
+				"unknown-mask":    strings.Replace(source, "KMOVQ CX,K1\n", "", 1),
+				"unknown-merge":   strings.Replace(source, "VPXORD Z2,Z2,Z2\n", "", 1),
+			}
+			if !member.unary {
+				variants["unknown-vector"] = strings.Replace(source, "VPXORD Z1,Z1,Z1\n", "", 1)
+			}
+			for name, changed := range variants {
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					if name == "numeric-pointer" {
+						if err != nil || ir == "" {
+							t.Fatal("vector value lost its initialized numeric address", api, err)
+						}
+						pointerIR, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+						if err != nil {
+							t.Fatal(err)
+						}
+						x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+						x86RequireNumericNativeSourceContext(t, changed, declaration, "amd64")
+						x86NumericNativeAddressObject(t, ir, "x86_64-unknown-linux-gnu")
+					} else if name == "unknown-vector" || name == "unknown-merge" {
+						x86VectorScratchCodegenControl(t, changed, declaration, "amd64", "x86_64-unknown-linux-gnu", ir, err)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("native result invented a pointer, index, mask, merge or vector", name, api, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86VectorValueNativeDeadEmitterKeepsInputRead(t *testing.T) {
+	for _, member := range x86NativeVectorValueMembers() {
+		for axis, bank := range []string{"X", "Y", "Z"} {
+			width := 16 << axis
+			for _, broadcast := range []bool{false, true} {
+				if broadcast && !member.broadcast {
+					continue
+				}
+				t.Run(fmt.Sprintf("%s/%s/broadcast%t", member.name, bank, broadcast), func(t *testing.T) {
+					source, _ := x86NativeVectorValueFixture(member, "amd64", bank, "plain", broadcast, true)
+					file, err := Parse(ArchAMD64, source)
+					if err != nil {
+						t.Fatal(err)
+					}
+					var ins Instr
+					matches := 0
+					for _, instruction := range file.Funcs[0].Instrs {
+						base, _, _ := strings.Cut(string(instruction.Op), ".")
+						if base == member.name {
+							ins = instruction
+							matches++
+						}
+					}
+					if matches != 1 {
+						t.Fatal("emitter fixture must retain its exact original value opcode", matches)
+					}
+					consumer, output := newAMD64CtxWithFuncForTest(t, file.Funcs[0], FuncSig{Ret: Void}, nil)
+					var known bool
+					if _, _, known, _ = x86IndexedPermuteProperties(ins.Op, ins, "amd64"); known {
+						_, _, err = consumer.lowerIndexedPermute(ins.Op, ins)
+					} else if _, known, _ = x86GFNIProperties(ins.Op, ins, "amd64"); known {
+						_, _, err = consumer.lowerGFNI(ins.Op, ins)
+					} else {
+						_, _, err = consumer.lowerPackedBitCount(ins.Op, ins)
+					}
+					if err != nil {
+						t.Fatal("unbound instruction-emitter unit failed", ins.Raw, err)
+					}
+					if broadcast {
+						width = 4
+						if strings.HasSuffix(member.name, "Q") || strings.HasSuffix(member.name, "PD") || member.immediate {
+							width = 8
+						}
+					}
+					if strings.Count(output.String(), fmt.Sprintf("load volatile <%d x i8>", width)) != 1 {
+						t.Fatal("dead native input lost its exact observable width", ins.Raw, output.String())
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86VectorValueVoidInputsCannotBorrowImplementationSlots(t *testing.T) {
+	for _, member := range x86NativeVectorValueMembers() {
+		immediate, second := "", "Z1,"
+		if member.immediate {
+			immediate = "$99,"
+		}
+		if member.unary {
+			second = ""
+		}
+		for _, variant := range []string{"unknown-registers", "known-registers", "native-pointer", "unknown-pointer"} {
+			t.Run(member.name+"/"+variant, func(t *testing.T) {
+				prefix, input, args, declaration := "", "Z0", 0, "func Value()"
+				if variant != "unknown-registers" {
+					prefix = "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\nVPXORD Z2,Z2,Z2\n"
+				}
+				if variant == "native-pointer" || variant == "unknown-pointer" {
+					prefix = "MOVQ p+0(FP),AX\nMOVL $1,DX\n" + prefix
+					input, args, declaration = "3(AX)(DX*2)", 8, "func Value(p *[128]byte)"
+					if variant == "unknown-pointer" {
+						prefix = strings.Replace(prefix, "p+0(FP),AX", "p+0(FP),DI", 1)
+					}
+				}
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s%s %s%s,%sZ2\nRET\n",
+					args, prefix, member.name, immediate, input, second)
+				goAssemblerOracleOutput(t, "amd64", source, "", true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, "amd64", "x86_64-unknown-linux-gnu", api)
+					known := variant == "known-registers" || variant == "native-pointer"
+					if known && (ir == "" || err != nil) {
+						t.Fatal("complete initialized Void control was lost", api, err)
+					}
+					if !known && (ir != "" || !errors.Is(err, ErrProbeNeedsContext)) {
+						t.Fatal("Void value family borrowed zeroed implementation slots or an unknown address", api, err)
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_vector_value_upper_writeback_test.go b/x86_vector_value_upper_writeback_test.go
new file mode 100644
index 000000000..5624489c0
--- /dev/null
+++ b/x86_vector_value_upper_writeback_test.go
@@ -0,0 +1,261 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+type x86VectorUpperOracle struct {
+	name      string
+	binary    bool
+	immediate bool
+}
+
+// Seed every physical byte, not only the X view. These original instructions
+// are accepted by both named frontends, including 386's three-operand limit.
+const x86VectorNonzeroUpperSeed = "VPXORD Z0,Z0,Z0\nVPXORD Z1,Z1,Z1\n" +
+	"VPXORD Z2,Z2,Z2\nVPXORD Z7,Z7,Z7\nMOVL $-1,AX\nVPBROADCASTD AX,Z2\n" +
+	"MOVL $0,AX\nKMOVD AX,K1\nVPCOMPRESSQ Z0,K1,Z7\n"
+
+func x86VectorUpperMembers() []x86VectorUpperOracle {
+	var members []x86VectorUpperOracle
+	for _, op := range x86CompactExpandResultMembers {
+		members = append(members, x86VectorUpperOracle{name: op})
+	}
+	for _, op := range x86IndexedPermuteResultNames {
+		members = append(members, x86VectorUpperOracle{name: op, binary: true})
+	}
+	for _, row := range x86GFNIResultOracle {
+		members = append(members, x86VectorUpperOracle{name: row.name, binary: true, immediate: row.immediate})
+	}
+	for _, row := range x86BitCountResultOracle {
+		members = append(members, x86VectorUpperOracle{name: row.name})
+	}
+	return members
+}
+
+func x86VectorUpperFixture(arch string) (string, string, []string) {
+	var source, declarations strings.Builder
+	var names []string
+	for _, member := range x86VectorUpperMembers() {
+		for _, bank := range []string{"X", "Y"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				arity := 2
+				if member.binary {
+					arity++
+				}
+				if member.immediate {
+					arity++
+				}
+				if mode != "plain" {
+					arity++
+				}
+				if arch == "386" && arity > 3 {
+					continue // Original named frontend limit, not an execution skip.
+				}
+				op, mask, second, immediate := member.name, "", "", ""
+				if mode != "plain" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					op += ".Z"
+				}
+				if member.binary {
+					second = bank + "1,"
+				}
+				if member.immediate {
+					immediate = "$0,"
+				}
+				name := "Value" + member.name + bank + mode
+				names = append(names, name)
+				fmt.Fprintf(&declarations, "func %s() uint32\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-4\n"+x86VectorNonzeroUpperSeed+
+					"%s %s%s0,%s%s%s2\nVEXTRACTI32X4 $3,Z2,X3\nPEXTRD $0,X3,AX\nMOVL AX,ret+0(FP)\nRET\n",
+					name, op, immediate, bank, second, mask, bank)
+			}
+		}
+	}
+	return source.String(), declarations.String(), names
+}
+
+func x86VectorUpperNativeFixture(arch string) (string, string, []string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	var source, declarations strings.Builder
+	var names []string
+	for _, member := range x86CompactExpandResultMembers {
+		if !strings.Contains(member, "EXPAND") {
+			continue // Compression has no memory-to-vector encoding.
+		}
+		for _, bank := range []string{"X", "Y"} {
+			for _, mode := range []string{"plain", "merge", "zero"} {
+				op, mask := member, ""
+				if mode != "plain" {
+					mask = "K1,"
+				}
+				if mode == "zero" {
+					op += ".Z"
+				}
+				name := "Native" + member + bank + mode
+				names = append(names, name)
+				fmt.Fprintf(&declarations, "func %s(p *[64]byte) uint32\n", name)
+				fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s p+0(FP),DI\n"+
+					x86VectorNonzeroUpperSeed+
+					"%s (DI),%s%s2\nVEXTRACTI32X4 $3,Z2,X3\nPEXTRD $0,X3,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+					name, word+4, move, op, mask, bank, word)
+			}
+		}
+	}
+	return source.String(), declarations.String(), names
+}
+
+func x86VectorUpperRequireZeroReturns(t *testing.T, ir string, names []string) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+		t.Fatal(err)
+	}
+	options := llvm.NewPassBuilderOptions()
+	defer options.Dispose()
+	if err := module.RunPasses("default<O2>", llvm.TargetMachine{}, options); err != nil {
+		t.Fatal(err)
+	}
+	for _, name := range names {
+		t.Run(name, func(t *testing.T) {
+			function := module.NamedFunction(name)
+			if function.IsNil() || function.FirstBasicBlock().IsNil() {
+				t.Fatal("original nonzero-upper source body disappeared")
+			}
+			returns := 0
+			for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+				terminator := block.LastInstruction()
+				if terminator.IsNil() || terminator.InstructionOpcode() != llvm.Ret {
+					continue
+				}
+				returns++
+				if terminator.OperandsCount() != 1 || terminator.Operand(0).IsAConstantInt().IsNil() || terminator.Operand(0).ZExtValue() != 0 {
+					t.Fatal("VEX/EVEX write retained old nonzero upper bytes", terminator.String())
+				}
+			}
+			if returns != 1 {
+				t.Fatal("missing exact independent upper-quarter result", returns)
+			}
+		})
+	}
+}
+
+func TestX86VectorValueFamiliesClearNonzeroUpperAliases(t *testing.T) {
+	if len(x86VectorUpperMembers()) != 35 {
+		t.Fatal("complete independently inventoried family changed")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86VectorUpperFixture(target.arch)
+			want := 210
+			if target.arch == "386" {
+				want = 138
+			}
+			if len(names) != want {
+				t.Fatal("whole-family write-width/mask denominator changed", len(names), want)
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized nonzero-upper source rejected", err)
+					}
+					x86VectorUpperRequireZeroReturns(t, ir, names)
+				})
+			}
+		})
+	}
+}
+
+func TestX86CompactNativeExpandClearsNonzeroUpperAliases(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations, names := x86VectorUpperNativeFixture(target.arch)
+			if len(names) != 36 {
+				t.Fatal("complete native expand upper-alias denominator changed", len(names))
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("initialized native expand source rejected", err)
+					}
+					x86VectorUpperRequireZeroReturns(t, ir, names)
+				})
+			}
+		})
+	}
+}
+
+func TestX86VectorValueUpperAliasesPortableRuntime(t *testing.T) {
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	source, declarations, names := x86VectorUpperFixture("amd64")
+	nativeSource, nativeDeclarations, nativeNames := x86VectorUpperNativeFixture("amd64")
+	if len(names) != 210 || len(nativeNames) != 36 {
+		t.Fatal("complete runtime family denominator changed", len(names), len(nativeNames))
+	}
+	var prototypes, checks strings.Builder
+	for _, name := range names {
+		fmt.Fprintf(&prototypes, "extern uint32_t %s(void);\n", name)
+		fmt.Fprintf(&checks, "if(check(%s(),\"%s\")) return 1;\n", name, name)
+	}
+	for _, name := range nativeNames {
+		fmt.Fprintf(&prototypes, "extern uint32_t %s(const uint8_t*);\n", name)
+		fmt.Fprintf(&checks, "if(check(%s(input),\"%s\")) return 1;\n", name, name)
+	}
+	oracle := "#include <stdint.h>\n#include <stdio.h>\n" + prototypes.String() + `
+static int check(uint32_t value,const char *name) {
+    if(value==0) return 0;
+    fprintf(stderr,"%s retained old upper quarter: %x\n",name,value);
+    return 1;
+}
+int main(void) {
+    uint8_t input[64]={0};
+` + checks.String() + "return 0;\n}\n"
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source+nativeSource, declarations+nativeDeclarations, "amd64", triple, api)
+			if err != nil || ir == "" {
+				t.Fatal("complete portable upper-alias source rejected", err)
+			}
+			for _, optimized := range []bool{false, true} {
+				objectIR := ir
+				if optimized {
+					objectIR = x86DwordProductIROptimize(t, ir)
+				}
+				for _, level := range []int{0, 2} {
+					t.Run(fmt.Sprintf("IR-O2=%t/backend-O%d", optimized, level), func(t *testing.T) {
+						compileAndRunRuntimeTestWithCompiler(t, llc, []string{clang}, "vector-upper", triple, objectIR, oracle, nil, level)
+					})
+				}
+			}
+		})
+	}
+	if !t.Failed() {
+		t.Log("246 complete-family programs passed on the actual host; portable LLVM, not original-Go/native AVX512")
+	}
+}
diff --git a/x86_vnni_complete_family_test.go b/x86_vnni_complete_family_test.go
new file mode 100644
index 000000000..c3faafc69
--- /dev/null
+++ b/x86_vnni_complete_family_test.go
@@ -0,0 +1,220 @@
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"errors"
+	"fmt"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// Independent Go/Intel integer directory. BF16 has different arithmetic,
+// native requirements and exceptions and must not inherit these rules.
+var x86VNNIIntegerMembers = []struct {
+	op     string
+	opcode byte
+}{{"VPDPBUSD", 0x50}, {"VPDPBUSDS", 0x51}, {"VPDPWSSD", 0x52}, {"VPDPWSSDS", 0x53}}
+
+type x86VNNIOracleRow struct {
+	op, bank, input, mode string
+}
+
+func x86VNNIOracleRows(arch string) []x86VNNIOracleRow {
+	var rows []x86VNNIOracleRow
+	for _, member := range x86VNNIIntegerMembers {
+		for _, bank := range []string{"X", "Y", "Z"} {
+			for _, input := range []string{"register", "full", "broadcast"} {
+				for _, mode := range []string{"plain", "merge", "zero"} {
+					if arch != "386" || mode == "plain" {
+						rows = append(rows, x86VNNIOracleRow{member.op, bank, input, mode})
+					}
+				}
+			}
+		}
+	}
+	return rows
+}
+
+func (row x86VNNIOracleRow) instruction() string {
+	op, first, mask := row.op, row.bank+"2", ""
+	if row.input != "register" {
+		first = "(AX)"
+	}
+	if row.input == "broadcast" {
+		op += ".BCST"
+	}
+	if row.mode != "plain" {
+		mask = "K1,"
+	}
+	if row.mode == "zero" {
+		op += ".Z"
+	}
+	return op + " " + first + "," + row.bank + "1," + mask + row.bank + "0"
+}
+
+func TestX86VNNIIntegerEveryInputByteAccumulatorAndState(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range x86VNNIOracleRows(arch) {
+			if row.input != "register" {
+				continue // Native memory has its separately paired source owner.
+			}
+			t.Run(arch+"/"+row.instruction(), func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row.instruction())
+				width := amd64VectorByteWidth(Reg(row.bank + "0"))
+				effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+				if !known || err != nil || !effect.requiresResultProof || effect.flagsRead != 0 || effect.flagsDefined != 0 || effect.flagsKilled != 0 {
+					t.Fatal("integer dot product lost its complete typed input/FLAGS owner", known, err)
+				}
+				destination := len(ins.Args) - 1
+				seen := make(map[int]bool)
+				for _, operand := range effect.operands {
+					wantWidth := int64(width)
+					if operand.index == 2 && destination == 3 {
+						wantWidth = 8
+					}
+					if seen[operand.index] || operand.index < 0 || operand.index > destination ||
+						!reflect.DeepEqual(operand.operand, ins.Args[operand.index]) ||
+						!operand.read || operand.write != (operand.index == destination) || operand.width != wantWidth {
+						t.Fatal("typed byte roles lost an input, old accumulator or exact physical width", operand)
+					}
+					seen[operand.index] = true
+				}
+				if len(seen) != len(ins.Args) {
+					t.Fatal("typed byte roles omitted an arithmetic or mask input")
+				}
+				for _, result := range []LLVMType{Void, I32} {
+					if !x86TypedFPResultNeedsProof(Func{Instrs: []Instr{ins}}, FuncSig{Ret: result}, arch) {
+						t.Fatal("Void or absent result layout waived the integer-dot inputs", result)
+					}
+				}
+				for input := 0; input < 3; input++ {
+					for missing := -1; missing < 64; missing++ {
+						state := x86FMA3ResultInputState()
+						if missing >= 0 {
+							state.writeVector(input, 64, state.vectorBytes(input)&^(uint64(1)<<uint(missing)), false)
+						}
+						before := state.clone()
+						// Every corresponding four source bytes (or two words)
+						// and every old dword are needed, even with EVEX.z.
+						// Use the same complete active-input boundary for direct
+						// and whole-source observers, including Void programs.
+						want := missing < 0 || missing >= width
+						if want {
+							before.writeVector(0, width, x86CallerVectorByteMask(int64(width)), false)
+						}
+						if accepted := x86ScalarFPResultTransfer(ins, &state, nil, 0, arch); accepted != want || !reflect.DeepEqual(state, before) {
+							t.Fatal("integer dot product borrowed an active input or changed aliases/FLAGS/DF/pointer state", input, missing, accepted, want)
+						}
+					}
+				}
+				if row.mode != "plain" {
+					state := x86FMA3ResultInputState()
+					state.masks[1] = false
+					before := state.clone()
+					if x86ScalarFPResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+						t.Fatal("an absent mask changed the numerical state")
+					}
+				}
+			})
+		}
+	}
+}
+
+func x86VNNIOriginalConformance(t *testing.T) string {
+	t.Helper()
+	data, err := os.ReadFile("testdata/conformance/amd64/conformance_amd64.s")
+	if err != nil {
+		t.Fatal(err)
+	}
+	start := strings.Index(string(data), "TEXT ·packedDotProductSemantics(SB)")
+	if start < 0 {
+		t.Fatal("original complete integer-dot conformance entry disappeared")
+	}
+	end := strings.Index(string(data[start:]), "\n// packedIntegerMinMaxSemantics")
+	if end < 0 {
+		t.Fatal("original integer-dot source boundary disappeared")
+	}
+	body := string(data[start : start+end])
+	if fmt.Sprintf("%x", sha256.Sum256([]byte(body))) != "4096e21a32435046699e0e1a02379246b7ba6e1be681f8868515e838e511b410" {
+		t.Fatal("original complete six-pointer ASM program changed")
+	}
+	data, err = os.ReadFile("amd64_conformance_test.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	function, err := x86SegmentMOVSourceFunction(data, "amd64ConformanceRuntimeC")
+	if err != nil || fmt.Sprintf("%x", sha256.Sum256(function)) != "41b0fc284d1aea9a9d24d613f84a6f4ad416d25a84dfa9664f81c7f1a9eef1b4" {
+		t.Fatal("original whole C reference/observations changed", err)
+	}
+	return "#include \"textflag.h\"\n" + body
+}
+
+func TestX86VNNIIntegerOriginalInitializedConformanceObjects(t *testing.T) {
+	source := x86VNNIOriginalConformance(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "amd64" {
+			continue // Preserve the real original MOVQ ABI0 program, not a rewritten mode32 source.
+		}
+		t.Run(target.triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source,
+						"func packedDotProductSemantics(out,signedBytes,unsignedBytes,wordsA,wordsB,accumulator *byte)",
+						target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("original complete initialized integer-dot program lost its public owner", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, target.triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
+
+func (row x86VNNIOracleRow) program(arch, name string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	source := fmt.Sprintf("TEXT ·%s(SB),4,$0-%d\n%s out+0(FP),DI\n%s a+%d(FP),AX\n%s b+%d(FP),BX\n%s old+%d(FP),CX\n"+
+		"VMOVUPS (AX),Z2\nVMOVUPS (BX),Z1\nVMOVUPS (CX),Z0\nKMOVQ mask+%d(FP),K1\n%s\nVMOVUPS Z0,(DI)\nRET\n",
+		name, 4*word+8, move, move, word, move, 2*word, move, 3*word, 4*word, row.instruction())
+	return source, "func " + name + "(out,a,b,old *byte,mask uint64)\n"
+}
+
+func TestX86VNNIIntegerVoidAndMissingNativeInputs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		triple := testTargetTriple("linux", arch)
+		for _, member := range x86VNNIIntegerMembers {
+			for _, unused := range []bool{false, true} {
+				size, declaration := 0, "func Missing()"
+				if unused {
+					size, declaration = 1, "func Missing(unused bool)"
+				}
+				source := fmt.Sprintf("TEXT ·Missing(SB),4,$0-%d\n%s X2,X1,X0\nRET\n", size, member.op)
+				x86LEAActualTargetGoObject(t, arch, triple, source)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/unused=%t/%s", arch, member.op, unused, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, declaration, arch, triple, api)
+						if arch == "amd64" && unused {
+							x86VectorScratchCodegenControl(t, source, declaration, arch, triple, ir, err)
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("Void or unused bool supplied missing dot-product sources/accumulator", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_vnni_complete_objects_test.go b/x86_vnni_complete_objects_test.go
new file mode 100644
index 000000000..788e4e980
--- /dev/null
+++ b/x86_vnni_complete_objects_test.go
@@ -0,0 +1,67 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// Keep targets independently scheduled: each AMD64 root retains 108 original
+// initialized witnesses, each mode32 root 36, with at most 36 functions per
+// capture. Objects establish translation/encoding, not VNNI CPU execution.
+func TestX86VNNIIntegerCompleteLinuxAMD64Objects(t *testing.T) {
+	x86VNNICompleteTargetObjects(t, "amd64", "x86_64-unknown-linux-gnu")
+}
+
+func TestX86VNNIIntegerCompleteDarwinAMD64Objects(t *testing.T) {
+	x86VNNICompleteTargetObjects(t, "amd64", "x86_64-apple-darwin")
+}
+
+func TestX86VNNIIntegerCompleteWindowsAMD64Objects(t *testing.T) {
+	x86VNNICompleteTargetObjects(t, "amd64", "x86_64-pc-windows-msvc")
+}
+
+func TestX86VNNIIntegerCompleteLinux386Objects(t *testing.T) {
+	x86VNNICompleteTargetObjects(t, "386", "i386-unknown-linux-gnu")
+}
+
+func TestX86VNNIIntegerCompleteWindows386Objects(t *testing.T) {
+	x86VNNICompleteTargetObjects(t, "386", "i386-pc-windows-msvc")
+}
+
+func x86VNNICompleteTargetObjects(t *testing.T, arch, triple string) {
+	t.Helper()
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	rows := x86VNNIOracleRows(arch)
+	for start := 0; start < len(rows); start += 36 {
+		end := start + 36
+		if end > len(rows) {
+			end = len(rows)
+		}
+		t.Run(fmt.Sprint("batch-", start), func(t *testing.T) {
+			var source, declarations strings.Builder
+			for i := start; i < end; i++ {
+				body, declaration := rows[i].program(arch, fmt.Sprint("Dot", i))
+				source.WriteString(body)
+				declarations.WriteString(declaration)
+			}
+			x86LEAActualTargetGoObject(t, arch, triple, source.String())
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), arch, triple, api)
+					if ir == "" || err != nil {
+						t.Fatal("complete initialized integer-dot family lost its public numerical owner", err)
+					}
+					for _, pipeline := range []struct{ ir, level string }{
+						{ir, "-O0"}, {ir, "-O2"}, {x86DwordProductIROptimize(t, ir), "-O2"},
+					} {
+						x86PackedStringCompileObject(t, llc, triple, pipeline.ir, pipeline.level)
+					}
+				})
+			}
+		})
+	}
+}
diff --git a/x86_vnni_go_rows_test.go b/x86_vnni_go_rows_test.go
new file mode 100644
index 000000000..772e34dc7
--- /dev/null
+++ b/x86_vnni_go_rows_test.go
@@ -0,0 +1,60 @@
+package plan9asm
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86VNNIIntegerIndependentCompleteGoEncoderRows(t *testing.T) {
+	rules, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	classes := []string{"YxmEvex,YxrEvex,YxrEvex", "YxmEvex,YxrEvex,Yknot0,YxrEvex",
+		"YymEvex,YyrEvex,YyrEvex", "YymEvex,YyrEvex,Yknot0,YyrEvex", "Yzm,Yzr,Yzr", "Yzm,Yzr,Yknot0,Yzr"}
+	for _, member := range x86VNNIIntegerMembers {
+		count := 0
+		var attributes []string
+		for _, bits := range []int{128, 256, 512} {
+			attributes = append(attributes, fmt.Sprintf("avxEscape | evex%d | evex66 | evex0F38 | evexW0", bits),
+				fmt.Sprintf("evexN%d | evexBcstN4 | evexZeroingEnabled", bits/8), fmt.Sprintf("0x%X", member.opcode))
+		}
+		for _, rule := range rules {
+			if rule.Opcode != member.op {
+				continue
+			}
+			zcase := "Zevex_rm_v_r"
+			if count%2 != 0 {
+				zcase = "Zevex_rm_v_k_r"
+			}
+			if count >= 6 || rule.RowIndex != count || rule.Ytab != "_yvblendmpd" || rule.Prefix != "Pavx" ||
+				rule.ZCase != zcase || rule.ZOffset != count%2*3 || rule.EncodingOffset != count/2*3 ||
+				strings.Join(rule.Classes, ",") != classes[count] || !reflect.DeepEqual(rule.OpBytes, attributes) {
+				t.Fatal("complete independent integer-dot Go row/width/tuple/W0 attributes changed", rule)
+			}
+			count++
+		}
+		if count != 6 {
+			t.Fatal("integer-dot official row denominator changed", member.op, count)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		rows, want := x86VNNIOracleRows(arch), 108
+		if arch == "386" {
+			want = 36
+		}
+		if len(rows) != want {
+			t.Fatal("independent concrete syntax denominator changed", arch, len(rows), want)
+		}
+		var source strings.Builder
+		for i, row := range rows {
+			fmt.Fprintf(&source, "TEXT VNNI%d(SB),4,$0-0\n%s\nRET\n", i, row.instruction())
+		}
+		x86LEAActualTargetGoObject(t, arch, testTargetTriple("linux", arch), source.String())
+	}
+}
diff --git a/x86_vnni_native_inputs_test.go b/x86_vnni_native_inputs_test.go
new file mode 100644
index 000000000..1bd79fe59
--- /dev/null
+++ b/x86_vnni_native_inputs_test.go
@@ -0,0 +1,148 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func TestX86VNNIIntegerNativeInputsCannotBorrowMemoryOrFlags(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, member := range x86VNNIIntegerMembers {
+			for _, input := range []string{"register", "full", "broadcast"} {
+				mode := "zero"
+				if arch == "386" {
+					mode = "plain"
+				}
+				row := x86VNNIOracleRow{member.op, "Z", input, mode}
+				original, declaration := row.program(arch, "Value")
+				// A memory instruction must establish its own address, not be
+				// rejected first by an unnecessary vector seed at that address.
+				if input != "register" {
+					original = strings.Replace(original, "VMOVUPS (AX),Z2\n", "", 1)
+				}
+				original = strings.Replace(original, row.instruction(), "STC\n"+row.instruction(), 1)
+				original = strings.Replace(original, "RET\n", "SETCS 64(DI)\nRET\n", 1)
+				for _, control := range []string{"initialized", "old", "second", "first", "mask", "address", "numeric-address", "index", "FLAGS"} {
+					if control == "mask" && mode == "plain" || input == "register" && (control == "address" || control == "numeric-address" || control == "index") {
+						continue // These inputs are absent from this independent format.
+					}
+					changed := original
+					switch control {
+					case "old":
+						changed = strings.Replace(changed, "VMOVUPS (CX),Z0\n", "", 1)
+					case "second":
+						changed = strings.Replace(changed, "VMOVUPS (BX),Z1\n", "", 1)
+					case "first":
+						if input == "register" {
+							changed = strings.Replace(changed, "VMOVUPS (AX),Z2\n", "", 1)
+						} else {
+							changed = strings.Replace(changed, "(AX),Z1", "(SI),Z1", 1)
+						}
+					case "mask":
+						line := fmt.Sprintf("KMOVQ mask+%d(FP),K1\n", 4*goWordSize(arch))
+						changed = strings.Replace(changed, line, "", 1)
+					case "address", "numeric-address":
+						line := fmt.Sprintf("MOVQ a+%d(FP),AX\n", goWordSize(arch))
+						if arch == "386" {
+							line = strings.Replace(line, "MOVQ", "MOVL", 1)
+						}
+						replacement := ""
+						if control == "numeric-address" {
+							replacement = "MOVL $42,AX\n"
+						}
+						changed = strings.Replace(changed, line, replacement, 1)
+					case "index":
+						changed = strings.Replace(changed, "(AX),Z1", "(AX)(SI*2),Z1", 1)
+					case "FLAGS":
+						changed = strings.Replace(changed, "STC\n", "", 1)
+					}
+					if control != "initialized" && changed == original {
+						t.Fatal("independent missing-input mutation did not change its actual source", control)
+					}
+					t.Run(arch+"/"+row.instruction()+"/"+control, func(t *testing.T) {
+						x86LEAActualTargetGoObject(t, arch, testTargetTriple("linux", arch), changed)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, arch, testTargetTriple("linux", arch), api)
+							if control == "initialized" || control == "numeric-address" {
+								if err != nil || ir == "" {
+									t.Fatal("real initialized integer-dot native read lost its paired source owner", api, err)
+								}
+								_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, strings.Join(strings.Split(changed, "\n")[1:], "\n"))
+								if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+									t.Fatal("standalone declaration query borrowed native backing", err)
+								}
+								if control == "numeric-address" {
+									pointerIR, err := x86ScalarFPBitViewAPI(t, original, declaration, arch, testTargetTriple("linux", arch), api)
+									if err != nil {
+										t.Fatal(err)
+									}
+									x86RequireSameNativeMemoryEffects(t, pointerIR, ir)
+									x86NumericNativeAddressObject(t, ir, testTargetTriple("linux", arch))
+								}
+							} else if arch == "amd64" && (control == "old" || control == "second" || control == "first" && input == "register") {
+								x86VectorScratchCodegenControl(t, changed, declaration, arch, testTargetTriple("linux", arch), ir, err)
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Fatal("integer-dot borrowed absent accumulator/mask/source/FLAGS/address permission", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+// Direct private emitter units are independent of the public source proof.
+// A dead arithmetic result still owns every required native access, but none
+// of these units is a public numerical or original-VNNI runtime certificate.
+func TestX86VNNIIntegerDeadAccessRetainsExactNativeTuple(t *testing.T) {
+	var original strings.Builder
+	var rows []x86VNNIOracleRow
+	for _, row := range x86VNNIOracleRows("amd64") {
+		if row.input != "register" {
+			fmt.Fprintf(&original, "TEXT DotAccess%d(SB),4,$0-0\n%s\nRET\n", len(rows), row.instruction())
+			rows = append(rows, row)
+		}
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", original.String())
+	for _, row := range rows {
+		t.Run(row.instruction(), func(t *testing.T) {
+			file := mustParseX86RawReturn(t, "TEXT DotAccess(SB),4,$0-0\n"+row.instruction()+"\nRET\n")
+			ir := x86SingleInstructionFormatObjectUnits(t, file, map[string]FuncSig{"DotAccess": {Name: "DotAccess", Ret: Void}},
+				"amd64", "x86_64-unknown-linux-gnu", func(c *amd64Ctx, ins Instr) (bool, bool, error) {
+					return c.lowerPackedDotProduct(ins.Op, ins)
+				})
+			_, body, found := strings.Cut(ir, "define void @InstructionFormat0(")
+			body, _, ended := strings.Cut(body, "\n}")
+			if !found || !ended || strings.Count(ir, "\ndefine ") != 1 {
+				t.Fatal("dead VNNI access lost its sole complete instruction body")
+			}
+			if strings.Contains(body, "asm sideeffect") && strings.Contains(body, strings.ToLower(row.op)) && strings.Contains(body, "~{memory}") {
+				return // An original native opcode may own the complete access.
+			}
+			width := amd64VectorByteWidth(Reg(row.bank + "0"))
+			loadType, count := "(?:i32|<4 x i8>)", 1
+			if row.mode == "plain" && row.input != "broadcast" {
+				loadType = fmt.Sprintf("(?:<%d x i32>|<%d x i8>)", width/4, width)
+			} else if row.input != "broadcast" {
+				loadType, count = "i32", width/4
+			}
+			// This unit contains exactly one operation, no parameters and
+			// no producer loads. Every observed volatile load belongs to its
+			// actual source: m32 has either a scalar or byte-vector bit view.
+			// The common prelude declares unrelated masked-load intrinsics;
+			// only this complete owned body can execute a source read.
+			load := regexp.MustCompile(`(?m)^\s+%[^\n]+ = load volatile ` + loadType + `, [^\n]*, align 1$`)
+			reads := load.FindAllString(body, -1)
+			volatile := strings.Count(body, "load volatile ")
+			masked := strings.Contains(body, "@llvm.masked.load")
+			conditional := strings.Contains(body, "br i1")
+			if len(reads) != count || volatile != count || masked || row.mode != "plain" && !conditional {
+				t.Fatalf("dead VNNI access lost its exact volatile tuple/fault suppression: want=%d matched=%q volatile=%d masked=%t conditional=%t", count, reads, volatile, masked, conditional)
+			}
+		})
+	}
+}
diff --git a/x86_vnni_raw_replay_test.go b/x86_vnni_raw_replay_test.go
new file mode 100644
index 000000000..c42acf492
--- /dev/null
+++ b/x86_vnni_raw_replay_test.go
@@ -0,0 +1,130 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+func x86VNNIVEXCode(opcode byte, bank string, memory bool) []byte {
+	prefix, modrm := byte(0x71), byte(0xc2) // VEX.128.66.0F38.W0, X2,X1,X0.
+	if bank == "Y" {
+		prefix |= 4
+	}
+	if memory {
+		modrm = 0 // (AX),X1,X0; VEX has no compressed displacement.
+	}
+	return []byte{0xc4, 0xe2, prefix, opcode, modrm}
+}
+
+func TestX86VNNIIntegerVEXPhysicalPriorAndWholeProducerReplay(t *testing.T) {
+	mc := findLLVM22Tool("llvm-mc")
+	if mc == "" {
+		t.Fatal("LLVM22 llvm-mc required for independent raw VNNI instruction prior")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		triple := testTargetTriple("linux", arch)
+		t.Run(arch, func(t *testing.T) {
+			var input strings.Builder
+			for _, member := range x86VNNIIntegerMembers {
+				for _, bank := range []string{"X", "Y"} {
+					for _, memory := range []bool{false, true} {
+						for _, value := range x86VNNIVEXCode(member.opcode, bank, memory) {
+							fmt.Fprintf(&input, "0x%02x ", value)
+						}
+						input.WriteByte('\n')
+					}
+				}
+			}
+			stage, cancel := runtimeOracleStageContext(t)
+			command := exec.CommandContext(stage, mc, "--disassemble", "--triple="+triple, "--mattr=+avxvnni")
+			command.Stdin = strings.NewReader(input.String())
+			output, err := runtimeOracleCombinedOutput(stage, command)
+			cancel()
+			if err != nil || strings.Contains(string(output), "warning") || strings.Contains(string(output), "invalid") {
+				t.Fatalf("independent LLVM22 rejected original VEX VNNI bytes: %v\n%s", err, output)
+			}
+			for _, member := range x86VNNIIntegerMembers {
+				if got := len(regexp.MustCompile(`(?m)\b`+strings.ToLower(member.op)+`[ \t]+`).FindAll(output, -1)); got != 4 {
+					t.Fatal("independent VEX instruction denominator changed", member.op, got, string(output))
+				}
+				for _, bank := range []string{"X", "Y"} {
+					for _, memory := range []bool{false, true} {
+						input := "register"
+						if memory {
+							input = "full"
+						}
+						row := x86VNNIOracleRow{member.op, bank, input, "plain"}
+						named, declaration := row.program(arch, "Value")
+						source := strings.Replace(named, row.instruction()+"\n", x86RawDisplacementDirectives(x86VNNIVEXCode(member.opcode, bank, memory)), 1)
+						t.Run(fmt.Sprintf("%s/%s/memory=%t", member.op, bank, memory), func(t *testing.T) {
+							x86LEAActualTargetGoObject(t, arch, triple, source)
+							file, err := normalizeX86RawFile(mustParseX86RawReturn(t, source), arch)
+							if err != nil {
+								t.Fatal("complete physically validated VEX source could not normalize", err)
+							}
+							original, ordinal := file.Funcs[0], -1
+							for i, ins := range original.Instrs {
+								if ins.Op == Op(member.op) && ins.x86SourceRaw != nil {
+									ordinal = i
+								}
+							}
+							if ordinal < 0 || original.x86RawReplay == nil || original.x86RawReplay.validate(original, arch) != nil {
+								t.Fatal("original VEX source lost its complete immutable producer replay")
+							}
+							state := x86FMA3ResultInputState()
+							state.pointerGP[0] = true
+							before := state.clone()
+							if x86ScalarFPResultTransfer(original.Instrs[ordinal], &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+								t.Fatal("standalone raw source borrowed the named numerical or native memory contract")
+							}
+							check := x86LegacyFloatReplayCheck(t, arch, named, declaration)
+							for _, mutation := range []string{"original", "origin-only", "missing-replay", "producer", "operand", "encoded", "vector-width", "original-bytes"} {
+								t.Run(mutation, func(t *testing.T) {
+									candidate := original
+									candidate.Instrs = cloneX86ReplayInstrs(original.Instrs)
+									ins := &candidate.Instrs[ordinal]
+									switch mutation {
+									case "origin-only":
+										ins.x86SourceRaw = nil
+										// VEX was decoded with the legacy grammar flag false:
+										// do not add another mutation to conceal its erasure.
+									case "missing-replay":
+										candidate.x86RawReplay = nil
+									case "producer":
+										candidate.Instrs[1].Raw += " changed"
+									case "operand":
+										ins.Args[1].Reg = Reg(bank + "7")
+									case "encoded":
+										ins.x86Encoded = !ins.x86Encoded
+									case "vector-width":
+										ins.x86VectorBytes = 7
+									case "original-bytes":
+										replay := *original.x86RawReplay
+										replay.source = strings.Replace(replay.source, "BYTE $", "BYTE $1+", 1)
+										candidate.x86RawReplay = &replay
+									}
+									failure := check(candidate)
+									if mutation == "original" {
+										if failure != nil {
+											t.Fatal("initialized raw VEX producer lost its paired lowering owner", failure)
+										}
+									} else if !errors.Is(failure, ErrProbeNeedsContext) {
+										t.Fatal("edited VEX generation or producer borrowed a named instruction contract", failure)
+									}
+									if original.x86RawReplay.validate(original, arch) != nil {
+										t.Fatal("cloned source mutation damaged its independently sealed original")
+									}
+								})
+							}
+						})
+					}
+				}
+			}
+		})
+	}
+}
diff --git a/x86_vsib_dead_fault_unix_test.go b/x86_vsib_dead_fault_unix_test.go
new file mode 100644
index 000000000..1d432d88d
--- /dev/null
+++ b/x86_vsib_dead_fault_unix_test.go
@@ -0,0 +1,82 @@
+//go:build darwin || linux
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86VSIBDeadGatherActiveLanesKeepMemoryFaults(t *testing.T) {
+	if runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64" {
+		t.Skip("portable VSIB fault execution requires its native 64-bit host counterpart")
+	}
+	llc, clang, found := findLlcAndClang(t)
+	if !found {
+		t.Fatal("LLVM22 llc and clang required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	var source, declarations, prototypes, rows strings.Builder
+	for index, instruction := range []string{
+		"VGATHERDPS X1,(AX)(X0*1),X2",
+		"VGATHERDPD X1,(AX)(X0*1),X2",
+		"VGATHERDPS (AX)(X16*1),K1,X18",
+		"VGATHERDPD (AX)(X16*1),K1,X18",
+	} {
+		name := fmt.Sprint("DeadGather", index)
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-16\nMOVQ p+0(FP),AX\nMOVQ mask+8(FP),CX\n", name)
+		if index < 2 {
+			source.WriteString("VPXOR Y0,Y0,Y0\nVPXOR Y2,Y2,Y2\nVMOVQ CX,X1\nVPSHUFD $0,X1,X1\n")
+		} else {
+			source.WriteString("VPXORD Z16,Z16,Z16\nVPXORD Z18,Z18,Z18\nKMOVQ CX,K1\n")
+		}
+		fmt.Fprintln(&source, instruction)
+		source.WriteString("RET\n") // Both the gathered result and updated mask are dead.
+		fmt.Fprintf(&declarations, "func %s(p *uint64,mask uint64)\n", name)
+		fmt.Fprintf(&prototypes, "extern void %s(uint64_t *,uint64_t);\n", name)
+		fmt.Fprintf(&rows, "%s,\n", name)
+	}
+	x86LEAActualTargetGoObject(t, "amd64", "x86_64-unknown-linux-gnu", source.String())
+	driver := "#include <stdint.h>\n#include <stdio.h>\n#include <signal.h>\n#include <sys/resource.h>\n#include <sys/wait.h>\n#include <unistd.h>\n" + prototypes.String() + `
+int main(void) {
+    void (*functions[])(uint64_t *,uint64_t) = {` + rows.String() + `};
+    unsigned observations = 0;
+    for (unsigned row = 0; row < sizeof(functions)/sizeof(functions[0]); ++row) {
+        for (int active = 0; active < 2; ++active) {
+            for (int valid = 0; valid < 2; ++valid) {
+                pid_t child = fork();
+                if (child < 0) return 1;
+                if (!child) {
+                    struct rlimit limit = {0,0};
+                    if (setrlimit(RLIMIT_CORE,&limit)) _exit(120);
+                    uint64_t value = UINT64_C(0x0123456789abcdef);
+                    functions[row](valid ? &value : (uint64_t *)0,active ? UINT64_MAX : 0);
+                    _exit(0);
+                }
+                int status = 0;
+                if (waitpid(child,&status,0) != child) return 2;
+                int fault = WIFSIGNALED(status) && (WTERMSIG(status) == SIGSEGV || WTERMSIG(status) == SIGBUS);
+                int normal = WIFEXITED(status) && WEXITSTATUS(status) == 0;
+                if ((active && !valid) ? !fault : !normal) {
+                    fprintf(stderr,"dead-gather row=%u active=%d valid=%d status=%x\n",row,active,valid,status);
+                    return 3;
+                }
+                ++observations;
+            }
+        }
+    }
+    return observations == 16 ? 0 : 4;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), "amd64", triple, api)
+			if err != nil {
+				t.Fatal("initialized dead-result VSIB source rejected", err)
+			}
+			x86ConflictFunnelPortableRuntime(t, llc, clang, "dead-gather", triple, ir, driver)
+		})
+	}
+}
diff --git a/x86_vsib_mandatory_inputs_test.go b/x86_vsib_mandatory_inputs_test.go
new file mode 100644
index 000000000..630b7902d
--- /dev/null
+++ b/x86_vsib_mandatory_inputs_test.go
@@ -0,0 +1,103 @@
+package plan9asm
+
+import (
+	"errors"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func TestX86VSIBDataRowsRequireProofWithoutResults(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86IndexedMemoryRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dataRows, hintRows := 0, 0
+	for _, row := range rows {
+		ins := x86ScalarLaneInstruction(t, row.Witnesses[0].Instruction)
+		form, known, err := x86VSIBProperties(ins, "amd64")
+		if !known || err != nil {
+			t.Fatal("original official VSIB row", row.ID, err)
+		}
+		if form.prefetch {
+			hintRows++
+			continue // Elided hints have no numerical continuation to prove.
+		}
+		dataRows++
+		ins = x86VSIBModeRoleInstruction(t, ins, 2, 1)
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(row.ID+"/"+arch, func(t *testing.T) {
+				fn := Func{Sym: "Value", Instrs: []Instr{ins}}
+				for _, result := range []LLVMType{Void, I32} {
+					if !x86TypedFPResultNeedsProof(fn, FuncSig{Name: "Value", Ret: result}, arch) {
+						t.Fatal("dead VSIB output bypassed index, mask, data and address obligations", result)
+					}
+				}
+			})
+		}
+	}
+	if dataRows != 64 || hintRows != 16 {
+		t.Fatal("incomplete official VSIB closure", dataRows, hintRows)
+	}
+}
+
+func TestX86VSIBVoidUnknownInputsThreeAPIs(t *testing.T) {
+	rows := []string{
+		"VGATHERDPS X1,(AX)(X0*1),X2",
+		"VGATHERDPS (AX)(X0*1),K1,X2",
+		"VPSCATTERDD X2,K1,(AX)(X0*1)",
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range rows {
+			for _, raw := range []bool{false, true} {
+				kind, body := "named", row+"\n"
+				if raw {
+					kind, body = "raw", x86RawNumericalInstruction(t, target.arch, row)
+				}
+				t.Run(target.triple+"/"+row+"/"+kind, func(t *testing.T) {
+					source := "TEXT Value(SB),4,$0-0\n" + body + "RET\n"
+					requireX86GoAssemblerResult(t, target.arch, source, true)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("implementation slots supplied unknown VSIB inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86VSIBElidedHintsNeedNoDataProof(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []string{"VGATHERPF0DPS K1,(AX)(Z0*1)", "VSCATTERPF1QPD K1,(AX)(Z0*1)"} {
+			t.Run(target.triple+"/"+row, func(t *testing.T) {
+				ins := x86ScalarLaneInstruction(t, row)
+				fn := Func{Sym: "Value", Instrs: []Instr{ins}}
+				if x86TypedFPResultNeedsProof(fn, FuncSig{Name: "Value", Ret: Void}, target.arch) {
+					t.Fatal("elided hint acquired a numerical input obligation")
+				}
+				source := "TEXT Value(SB),4,$0-0\n" + row + "\nRET\n"
+				requireX86GoAssemblerResult(t, target.arch, source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value()", target.arch, target.triple, api)
+					if err != nil || !strings.Contains(ir, "ret void") {
+						t.Fatal("elided hint lost its ordinary continuation", api, err)
+					}
+					x86PackedStringCompileObject(t, llc, target.triple, ir, "-O2")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_vsib_mode32_roles_test.go b/x86_vsib_mode32_roles_test.go
new file mode 100644
index 000000000..372ecf069
--- /dev/null
+++ b/x86_vsib_mode32_roles_test.go
@@ -0,0 +1,182 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/plan9asm/internal/goasmrules"
+)
+
+func x86VSIBModeRoleInstruction(t *testing.T, original Instr, data, mask int) Instr {
+	t.Helper()
+	form, known, err := x86VSIBProperties(original, "amd64")
+	if !known || err != nil || form.prefetch {
+		t.Fatal("expected an existing complete data VSIB form", err)
+	}
+	destination := fmt.Sprintf("%s%d", string(form.data.Reg)[:1], data)
+	index := string(form.memory.Mem.Index)[:1] + "0"
+	memory := fmt.Sprintf("(AX)(%s*1)", index)
+	operands := memory + ",K1," + destination
+	if form.scatter {
+		operands = destination + ",K1," + memory
+	} else if !form.evex {
+		operands = fmt.Sprintf("%s%d,%s,%s", string(form.mask.Reg)[:1], mask, memory, destination)
+	}
+	return x86ScalarLaneInstruction(t, string(form.opcode)+" "+operands)
+}
+
+// These are explicit controlled model facts, not a Go source/entry certificate.
+// The complete input state isolates the VSIB NUM transition from earlier loads.
+func TestX86VSIBMode32NumericalRegisterRoles(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86IndexedMemoryRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dataRows := 0
+	for _, row := range rows {
+		original := x86ScalarLaneInstruction(t, row.Witnesses[0].Instruction)
+		form, known, err := x86VSIBProperties(original, "amd64")
+		if !known || err != nil {
+			t.Fatal("original official form", row.ID, err)
+		}
+		if form.prefetch {
+			continue
+		}
+		dataRows++
+		roles := []string{"data"}
+		if !form.evex {
+			roles = append(roles, "vector-mask")
+		}
+		for _, role := range roles {
+			for _, bank := range []int{7, 8, 15, 16, 31} {
+				data, mask := 2, 1
+				if role == "data" {
+					data = bank
+				} else {
+					mask = bank
+				}
+				ins := x86VSIBModeRoleInstruction(t, original, data, mask)
+				for _, arch := range []string{"386", "amd64"} {
+					t.Run(fmt.Sprintf("%s/%s/%s/%d", row.ID, arch, role, bank), func(t *testing.T) {
+						// Retain the old physical Go-format class. In particular,
+						// 386 X/Y data and VEX-mask high aliases are not deleted.
+						_, matched, parseError := x86VSIBProperties(ins, arch)
+						formatAllowed := bank < 16 || form.evex && role == "data"
+						if arch == "386" && role == "data" && form.dataBytes == 64 && bank >= 8 {
+							formatAllowed = false
+						}
+						if !matched || formatAllowed != (parseError == nil) {
+							t.Fatal("physical format boundary changed", parseError, formatAllowed)
+						}
+						if !formatAllowed {
+							return // A physical rejection is distinct from the NUM guard.
+						}
+						state := x86ResultState{flags: x86ByteFlagsAll, masks: [8]bool{1: true}}
+						state.pointerGP[0] = true
+						for number := 0; number < 32; number++ {
+							state.writeVector(number, 64, ^uint64(0), false)
+						}
+						baseline := state.clone()
+						low := x86VSIBModeRoleInstruction(t, original, 2, 1)
+						if accepted, recognized := x86ResultVSIBStep(low, &baseline, arch, true); !accepted || !recognized {
+							t.Fatal("complete low-bank numerical input must precede the guard")
+						}
+						before := state.clone()
+						accepted, recognized := x86ResultVSIBStep(ins, &state, arch, true)
+						want := arch == "amd64" || bank < 8
+						if !recognized || accepted != want {
+							t.Fatal("numerical bank availability differs from source format", accepted, want)
+						}
+						if !want && !reflect.DeepEqual(state, before) {
+							t.Fatal("rejected numerical bank changed source facts")
+						}
+					})
+				}
+			}
+		}
+	}
+	if dataRows != 64 {
+		t.Fatal("complete gather/scatter source-row closure", dataRows)
+	}
+}
+
+// Actual public sources are independent of the controlled state above. High
+// source rejection can occur at an earlier initializer; it is not attributed
+// to the VSIB guard without the controlled-transition evidence.
+func TestX86VSIBMode32InitializedPublicSourceRoles(t *testing.T) {
+	avx, err := goasmrules.LoadX86AVXRules(runtime.GOROOT())
+	if err != nil {
+		t.Fatal(err)
+	}
+	rows, err := goasmrules.X86IndexedMemoryRows(goasmrules.X86LegacyCatalog{}, avx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	selected := 0
+	for _, row := range rows {
+		if row.Opcode != "VGATHERDPS" && row.Opcode != "VPSCATTERDD" {
+			continue
+		}
+		if !strings.HasSuffix(row.ID, "/0") && !(row.Opcode == "VGATHERDPS" && strings.HasSuffix(row.ID, "/2")) {
+			continue
+		}
+		selected++
+		w := row.Witnesses[0]
+		original := x86ScalarLaneInstruction(t, w.Instruction)
+		low := x86VSIBModeRoleInstruction(t, original, 2, 1)
+		form, _, _ := x86VSIBProperties(low, "amd64")
+		oldIndex, oldData := w.Second, w.Destination
+		w.Second, w.Destination = string(form.memory.Mem.Index), string(form.data.Reg)
+		w.Instruction = strings.ReplaceAll(w.Instruction, oldIndex, w.Second)
+		w.Instruction = strings.ReplaceAll(w.Instruction, oldData, w.Destination)
+		for _, arch := range []string{"amd64", "386"} {
+			t.Run(row.ID+"/"+arch, func(t *testing.T) {
+				cases := []x86OfficialPackedCase{{row: row.ID, witness: w}}
+				source, declarations := x86OfficialVSIBAssembly(cases)
+				triple := "x86_64-unknown-linux-gnu"
+				if arch == "386" {
+					triple = "i386-unknown-linux-gnu"
+					source = strings.NewReplacer(
+						"$0-24", "$0-12", "MOVQ out+0(FP),DX", "MOVL out+0(FP),DX",
+						"MOVQ data+8(FP),AX", "MOVL data+4(FP),AX",
+						"MOVQ seed+16(FP),BX", "MOVL seed+8(FP),BX",
+						"MOVQ $1,R9\nKMOVQ R9,K1", "MOVL $1,CX\nKMOVW CX,K1",
+						"MOVQ DX,AX", "MOVL DX,AX",
+					).Replace(source)
+				}
+				requireX86GoAssemblerResult(t, arch, source, true)
+				for _, api := range []string{"text", "module", "Go"} {
+					if _, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, triple, api); err != nil {
+						t.Fatal("complete low-bank public source", api, err)
+					}
+					if arch != "386" {
+						continue
+					}
+					// Preserve the result carrier width rather than introducing Z8
+					// into a mode32 X/Y data observation through the initializer.
+					high := strings.NewReplacer("X2", "X8", "Y2", "Y8", "Z2", string(form.data.Reg)[:1]+"8").Replace(source)
+					if ir, err := x86ScalarFPBitViewAPI(t, high, declarations, arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("mode32 high data acquired public NUM", api, err)
+					}
+					if !form.evex {
+						high = strings.NewReplacer("X1", "X8", "Y1", "Y8").Replace(source)
+						if ir, err := x86ScalarFPBitViewAPI(t, high, declarations, arch, triple, api); !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("mode32 high VEX mask acquired public NUM", api, err)
+						}
+					}
+				}
+			})
+		}
+	}
+	if selected != 3 {
+		t.Fatal("expected one VEX gather, EVEX gather and scatter source", selected)
+	}
+}
diff --git a/x86_waitpkg_result_test.go b/x86_waitpkg_result_test.go
new file mode 100644
index 000000000..10a22d5e6
--- /dev/null
+++ b/x86_waitpkg_result_test.go
@@ -0,0 +1,275 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86WaitPKGCompleteGoRowsAndNUMInputs(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var ywrfsbase = []ytab{\n\t{Zm_o, 2, argList{Yrl}},\n}",
+		"{ATPAUSE, ywrfsbase, Pq, opBytes{0xae, 06}}",
+		"{AUMWAIT, ywrfsbase, Pf2, opBytes{0xae, 06}}",
+	} {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("complete Go WAITPKG encoding changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		registers := []Reg{AX, CX, DX, BX, SP, BP, SI, DI}
+		if arch == "amd64" {
+			registers = append(registers, "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15")
+		}
+		for _, op := range []string{"UMWAIT", "TPAUSE"} {
+			for _, register := range registers {
+				t.Run(arch+"/"+op+"/"+string(register), func(t *testing.T) {
+					ins := x86ScalarLaneInstruction(t, op+" "+string(register))
+					requireX86GoAssemblerResult(t, arch, "TEXT wait(SB),4,$0-0\n"+ins.Raw+"\nRET\n", true)
+					before := x86ResultState{direction: x86ResultDirectionBackward}
+					before.xmm[2], before.masks[1] = 0x1234, true
+					before.valueStack = &x86ResultValueStack{bytes: []uint8{1, 2}, id: true}
+					inputs := []int{0, 2}
+					index, _, valid := x86ResultGP(register, 4, arch)
+					if !valid {
+						// AMD64 BP is a physical-frame role, not an ordinary NUM input.
+						state := before.clone()
+						if x86ResultTransfer(ins, &state, nil, 0, arch) {
+							t.Fatal("physical frame acquired ordinary numerical inputs")
+						}
+						return
+					}
+					inputs = append(inputs, index)
+					for _, input := range inputs {
+						before.gp[input] = 0x0f
+					}
+					state, want := before.clone(), before.clone()
+					want.flags = x86ByteFlagsAll
+					if !x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, want) {
+						t.Error("wait must read EDX:EAX/control, define status and preserve unrelated state")
+					}
+					effect, known, err := x86TypedInstructionByteEffect(ins.Op, ins, arch)
+					if !known || err != nil || !effect.requiresResultProof {
+						t.Error("missing mandatory wait input descriptor", err)
+					}
+					for _, input := range inputs {
+						for missing := uint(0); missing < 4; missing++ {
+							state := before.clone()
+							state.gp[input] &^= 1 << missing
+							unchanged := state.clone()
+							if x86ResultTransfer(ins, &state, nil, 0, arch) || !reflect.DeepEqual(state, unchanged) {
+								t.Error("wait accepted missing data or partially updated status", input, missing)
+							}
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86WaitPKGRawIdentityAndStorageBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"UMWAIT", "TPAUSE"} {
+			file, err := Parse(ArchAMD64, "TEXT wait(SB),4,$0-0\n"+x86WaitPKGBody(op, true)+"RET\n")
+			if err != nil {
+				t.Fatal(err)
+			}
+			fn, err := decodeX86RawDirectives(file.Funcs[0], arch)
+			if err != nil || len(fn.Instrs) != 3 {
+				t.Fatal("wait lost its complete original source", err)
+			}
+			original := fn.Instrs[1]
+			for _, mutation := range []string{"unchanged", "opcode", "operand", "origin-opcode", "origin-operand",
+				"missing-origin", "address-size", "segment", "unbound-address", "raw-return", "constructed-operand"} {
+				t.Run(arch+"/"+op+"/"+mutation, func(t *testing.T) {
+					ins := original
+					ins.Args = append([]Operand(nil), original.Args...)
+					origin := *original.x86SourceRaw
+					ins.x86SourceRaw = &origin
+					switch mutation {
+					case "opcode":
+						ins.Op = "UMONITOR"
+					case "operand":
+						ins.Args[0].Reg = AX
+					case "origin-opcode":
+						origin.op = "NOP"
+					case "origin-operand":
+						origin.args = []Operand{{Kind: OpReg, Reg: AX}}
+					case "missing-origin":
+						ins.x86SourceRaw = nil
+					case "address-size":
+						ins.x86AddressBits = 32
+					case "segment":
+						ins.x86SegmentPrefix = 0x64
+					case "unbound-address":
+						ins.x86UnboundAddressOverride = true
+					case "raw-return":
+						ins.x86RawNearReturn = new(x86RawNearReturnForm)
+					case "constructed-operand":
+						ins.Args[0].ImmRaw = "$unknown"
+					}
+					valid := mutation == "unchanged"
+					if x86WaitPackagePreservesStorage(ins) != valid {
+						t.Fatal("wait storage identity did not retain its exact source boundary")
+					}
+					state := x86ResultState{direction: x86ResultDirectionBackward,
+						valueStack: &x86ResultValueStack{bytes: []uint8{1, 2, 3, 4}, id: true}}
+					state.gp[0], state.gp[2], state.gp[3] = 0x0f, 0x0f, 0x0f
+					state.callerAddressGP[7] = true
+					if valid {
+						if !x86ResultValueStackContinuation(ins, &state, arch) ||
+							x86ResultDirectionAfter(ins, state.direction) != state.direction ||
+							x86ResultCallerAddressesAfter(ins, state.callerAddressGP, nil, arch) != state.callerAddressGP {
+							t.Fatal("wait destroyed unrelated private storage/DF/address identity")
+						}
+					}
+					unchanged := state.clone()
+					if x86ResultTransfer(ins, &state, nil, 0, arch) != valid || !valid && !reflect.DeepEqual(state, unchanged) {
+						t.Fatal("mismatched raw wait acquired numerical state")
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86WaitPKGVoidInputsThreeAPIs(t *testing.T) {
+	x86WaitPKGVoidInputsThreeAPIs(t, false)
+}
+
+func TestX86RawWaitPKGVoidInputsThreeAPIs(t *testing.T) {
+	x86WaitPKGVoidInputsThreeAPIs(t, true)
+}
+
+func TestX86WaitPKGEntryAndJoinInputsThreeAPIs(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVL", 4, "i386-unknown-linux-gnu"
+		if arch == "amd64" {
+			move, word, triple = "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		}
+		for _, op := range []string{"UMWAIT", "TPAUSE"} {
+			for _, raw := range []bool{false, true} {
+				for _, row := range []struct {
+					name, declaration, setup string
+					frame                    int
+					valid                    bool
+				}{
+					{"pointer-control", "p *uint32", move + " p+0(FP),BX\nMOVL $0,AX\nMOVL $0,DX\n", word, false},
+					{"unused-bool", "unused bool", "", 1, false},
+					{"complete-unused-bool", "unused bool", "MOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\n", 1, true},
+					{"missing-join", "selector uint32", "MOVL selector+0(FP),AX\nMOVL $0,DX\nCMPL AX,$0\nJE ready\nMOVL $0,BX\nready:\n", 4, false},
+					{"complete-join", "selector uint32", "MOVL selector+0(FP),AX\nMOVL $0,DX\nMOVL $0,BX\nCMPL AX,$0\nJE ready\nMOVL $1,BX\nready:\n", 4, true},
+				} {
+					t.Run(fmt.Sprintf("%s/%s/raw=%t/%s", arch, op, raw, row.name), func(t *testing.T) {
+						source := fmt.Sprintf("TEXT ·Wait(SB),4,$0-%d\n%s%sRET\n", row.frame, row.setup, x86WaitPKGBody(op, raw))
+						x86LEAActualTargetGoObject(t, arch, triple, source)
+						for _, api := range []string{"text", "module", "Go"} {
+							ir, err := x86ScalarFPBitViewAPI(t, source, "func Wait("+row.declaration+")", arch, triple, api)
+							if row.valid {
+								if err != nil || ir == "" {
+									t.Error("complete wait lost entry/CFG inputs", api, err)
+								}
+							} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+								t.Error("wait borrowed numerical inputs from pointer/bool/missing CFG path", api, err)
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func x86WaitPKGBody(op string, raw bool) string {
+	if !raw {
+		return op + " BX\n"
+	}
+	prefix := byte(0xf2)
+	if op == "TPAUSE" {
+		prefix = 0x66
+	}
+	return x86RawDisplacementDirectives([]byte{prefix, 0x0f, 0xae, 0xf3})
+}
+
+func x86WaitPKGVoidInputsThreeAPIs(t *testing.T, raw bool) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"UMWAIT", "TPAUSE"} {
+			for _, setup := range []struct {
+				name, source string
+				valid        bool
+			}{
+				{"none", "", false},
+				{"deadline-only", "MOVL $0,AX\nMOVL $0,DX\n", false},
+				{"no-ax", "MOVL $0,DX\nMOVL $0,BX\n", false},
+				{"no-dx", "MOVL $0,AX\nMOVL $0,BX\n", false},
+				{"partial-control", "MOVL $0,AX\nMOVL $0,DX\nMOVB $0,BL\n", false},
+				{"complete", "MOVL $0,AX\nMOVL $0,DX\nMOVL $0,BX\n", true},
+			} {
+				t.Run(target.triple+"/"+op+"/"+setup.name, func(t *testing.T) {
+					source := "TEXT ·Wait(SB),4,$0-0\n" + setup.source + x86WaitPKGBody(op, raw) + "RET\n"
+					x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+					for _, api := range []string{"text", "module", "Go"} {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Wait()", target.arch, target.triple, api)
+						if setup.valid {
+							if err != nil || !strings.Contains(ir, fmt.Sprintf("asm sideeffect %q", strings.ToLower(op)+" $1; setc $0")) {
+								t.Error("initialized wait lost its native opcode", api, err)
+							}
+						} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Error("Void wait borrowed uninitialized inputs", api, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+// Execute no WAITPKG instruction on the host: these objects retain actual
+// native operations, their flags consumers and all original argument/result
+// bytes. Native CPU availability and execution are separate requirements.
+func TestX86WaitPKGInitializedStatusFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM 22 llc required")
+	}
+	for _, target := range x86RawReturnTargets {
+		word, value, offset := "L", "uint32", 12
+		if target.arch == "amd64" {
+			word, value, offset = "Q", "uint64", 16
+		}
+		for _, raw := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/raw=%t", target.triple, raw), func(t *testing.T) {
+				var source, declarations strings.Builder
+				for _, op := range []string{"UMWAIT", "TPAUSE"} {
+					fmt.Fprintf(&declarations, "func %s(control,low,high uint32) %s\n", op, value)
+					fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\nMOVL control+0(FP),BX\nMOVL low+4(FP),AX\nMOVL high+8(FP),DX\nPUSH%s $0x8d7\nPOPF%s\n%sPUSHF%s\nPOP%s CX\nMOV%s CX,ret+%d(FP)\nRET\n",
+						op, offset+int(x86ResultPointerWord(target.arch)), word, word, x86WaitPKGBody(op, raw), word, word, word, offset)
+				}
+				x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, source.String(), declarations.String(), target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Error("initialized wait/status program rejected", api, err)
+						continue
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_conditional_original_source_test.go b/x86_x87_conditional_original_source_test.go
new file mode 100644
index 000000000..c5ca6942f
--- /dev/null
+++ b/x86_x87_conditional_original_source_test.go
@@ -0,0 +1,53 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestX86X87ConditionalOriginalRuntimeSourcePortableBoundary(t *testing.T) {
+	source := x86X87ENVLiteral(t, "amd64_lower_x87_conditional_move_test.go", "TestAMD64X87ConditionalMoveRuntimeConditions")
+	// Actual Go syntax/object acceptance is independent of a native pointer
+	// extent, caller write envelope, or a portable numerical proof.
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+source, "", true)
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, source, "func x87conditionalmovesemantics(data *byte)",
+					"amd64", triple, api, X87Software)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" ||
+					!strings.Contains(err.Error(), "logical x87 value stack is not balanced at RET") {
+					t.Fatal("original x87 source acquired an unobserved empty stack at RET", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87ConditionalBalancedOriginalSourceObjects(t *testing.T) {
+	source := x86X87ENVLiteral(t, "amd64_lower_x87_conditional_move_test.go", "TestAMD64X87ConditionalMoveRuntimeConditions")
+	balanced := strings.Replace(source, "\tRET\n", "\tFINIT\n\tRET\n", 1)
+	if balanced == source || strings.Count(source, "\tRET\n") != 1 {
+		t.Fatal("original x87 conditional fixture lost its unique RET")
+	}
+	goAssemblerOracleOutput(t, "amd64", "#include \"textflag.h\"\n"+balanced, "", true)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc required")
+	}
+	for _, triple := range []string{"x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, balanced, "func x87conditionalmovesemantics(data *byte)",
+					"amd64", triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("independently balanced original source rejected", err)
+				}
+				for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+					compileLLVMToObject(t, llc, triple, "x87-balanced.ll", "x87-balanced.o", text)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_conditional_scalar_runtime_test.go b/x86_x87_conditional_scalar_runtime_test.go
new file mode 100644
index 000000000..9f2fcfe74
--- /dev/null
+++ b/x86_x87_conditional_scalar_runtime_test.go
@@ -0,0 +1,135 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func x86X87ConditionalScalarCounterpart() (assembly, declaration string) {
+	var source, types strings.Builder
+	for _, op := range x87ConditionalMoveGo127Ops {
+		name := "conditional" + op
+		fmt.Fprintf(&types, "func %s(a, b float64, predicate uint32) float64\n", name)
+		fmt.Fprintf(&source, "TEXT %s(SB),4,$0-32\nFINIT\nFMOVD a+0(FP),F0\nFMOVD b+8(FP),F0\n"+
+			"MOVL predicate+16(FP),AX\nCMPL AX,$1\n%s F1,F0\nFMOVDP F0,ret+24(FP)\nFINIT\nRET\n", name, op)
+	}
+	return source.String(), types.String()
+}
+
+func x86X87ConditionalScalarC(main string) string {
+	var source strings.Builder
+	source.WriteString(`#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+typedef double (*conditional_fn)(double, double, uint32_t);
+`)
+	for _, op := range x87ConditionalMoveGo127Ops {
+		fmt.Fprintf(&source, "extern double conditional%s(double, double, uint32_t);\n", op)
+	}
+	source.WriteString("static conditional_fn functions[] = {\n")
+	for _, op := range x87ConditionalMoveGo127Ops {
+		fmt.Fprintf(&source, "  conditional%s,\n", op)
+	}
+	// Independent Intel condition names, not the lowerer's predicate table.
+	source.WriteString(`};
+static int selected(unsigned op, uint32_t input) {
+  uint32_t difference = input - UINT32_C(1);
+  unsigned parity = 0;
+  for (unsigned bit = 0; bit < 8; ++bit) parity ^= (difference >> bit) & 1u;
+  int cf = input < 1, zf = input == 1, pf = parity == 0;
+  switch (op) {
+  case 0: case 7: return !cf;          /* CC, NB */
+  case 1: case 5: return cf;           /* CS, B */
+  case 2: case 9: return zf;           /* EQ, E */
+  case 3: case 8: return !cf && !zf;   /* HI, NBE */
+  case 4: case 6: return cf || zf;     /* LS, BE */
+  case 10: return !zf;                /* NE */
+  case 11: return !pf;                /* NU */
+  case 12: case 13: return pf;        /* U, UN */
+  default: abort();
+  }
+}
+void x87conditionalmovesemantics(uint8_t *raw) {
+  double *data = (double *)raw;
+  data[0] = conditionalFCMOVB(data[8], data[9], 0);
+  data[1] = conditionalFCMOVNB(data[8], data[9], 0);
+  data[2] = conditionalFCMOVE(data[8], data[9], 1);
+  data[3] = conditionalFCMOVNE(data[8], data[9], 1);
+  data[4] = conditionalFCMOVBE(data[8], data[9], 1);
+  data[5] = conditionalFCMOVNBE(data[8], data[9], 1);
+  data[6] = conditionalFCMOVU(data[8], data[9], 1);
+  data[7] = conditionalFCMOVNU(data[8], data[9], 1);
+  volatile uint32_t predicates[] = {0, 1, 2, 3, 255};
+  volatile uint64_t bits[][2] = {
+    {UINT64_C(0x3ff4000000000000), UINT64_C(0x4023000000000000)},
+    {UINT64_C(0x8000000000000000), UINT64_C(0)},
+    {UINT64_C(0x7ff8000000000042), UINT64_C(0x7ff0000000000000)},
+    {UINT64_C(1), UINT64_C(0xc000000000000000)}
+  };
+  for (unsigned op = 0; op < 14; ++op) {
+    for (unsigned p = 0; p < 5; ++p) {
+      for (unsigned pair = 0; pair < 4; ++pair) {
+        uint32_t predicate = predicates[p];
+        uint64_t a_bits = bits[pair][0], b_bits = bits[pair][1], got_bits;
+        double a, b, got;
+        memcpy(&a, &a_bits, sizeof(a));
+        memcpy(&b, &b_bits, sizeof(b));
+        got = functions[op](a, b, predicate);
+        memcpy(&got_bits, &got, sizeof(got_bits));
+        uint64_t expected = selected(op, predicate) ? a_bits : b_bits;
+        if (got_bits != expected) {
+          fprintf(stderr, "conditional op=%u predicate=%u pair=%u got=%llx expected=%llx\n",
+            op, predicate, pair, (unsigned long long)got_bits, (unsigned long long)expected);
+          exit(1);
+        }
+      }
+    }
+  }
+}
+`)
+	source.WriteString(main)
+	return source.String()
+}
+
+func TestX86X87ConditionalScalarCounterpartCompleteGoObject(t *testing.T) {
+	assembly, _ := x86X87ConditionalScalarCounterpart()
+	goAssemblerOracleOutput(t, "amd64", assembly, "", true)
+	file, err := Parse(ArchAMD64, assembly)
+	if err != nil || len(file.Funcs) != 14 {
+		t.Fatal("typed runtime counterpart lost a complete Go conditional family", err)
+	}
+	for index, function := range file.Funcs {
+		if function.Sym != "conditional"+x87ConditionalMoveGo127Ops[index] || function.ArgSize != 32 || function.FrameSize != 0 {
+			t.Fatal("typed scalar function changed its identity or ABI0 layout", function.Sym)
+		}
+	}
+}
+
+func TestX86X87ConditionalMoveHostSoftwareThreeAPIs(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	main := x86X87FunctionLiteral(t, "amd64_lower_x87_conditional_move_test.go",
+		"TestAMD64X87ConditionalMoveRuntimeConditions", "mainC")
+	assembly, declaration := x86X87ConditionalScalarCounterpart()
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/IR-O2-%t", api, optimized), func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, assembly, declaration, "amd64", triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("complete typed conditional source did not reach Software execution", err)
+				}
+				if optimized {
+					ir = x86DwordProductIROptimize(t, ir)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "x87-conditional-scalar", triple, ir,
+					x86X87ConditionalScalarC(main), nil)
+			})
+		}
+	}
+}
diff --git a/x86_x87_conditional_value_test.go b/x86_x87_conditional_value_test.go
new file mode 100644
index 000000000..818165262
--- /dev/null
+++ b/x86_x87_conditional_value_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86X87ConditionalValueWholeGoRegisterGrammar(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range x87ConditionalMoveGo127Ops {
+			for _, row := range []struct {
+				operands string
+				good     bool
+			}{
+				{"F0,F0", true}, {"F7,F0", true}, {"F8,F0", false},
+				{"F1,F2", false}, {"0(AX),F0", false}, {"F1", false},
+			} {
+				t.Run(arch+"/"+op+"/"+row.operands, func(t *testing.T) {
+					_, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, op+" "+row.operands), arch)
+					if !known || (err == nil) != row.good {
+						t.Fatal("conditional value grammar differs from the complete yfcmv register row", known, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87ConditionalValueNeedsFlagsAndBothReachingValues(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			op    string
+			flags uint8
+		}{
+			{"FCMOVB", x86ByteFlagCF}, {"FCMOVCS", x86ByteFlagCF},
+			{"FCMOVNB", x86ByteFlagCF}, {"FCMOVCC", x86ByteFlagCF},
+			{"FCMOVBE", x86ByteFlagCF | x86ByteFlagZF}, {"FCMOVLS", x86ByteFlagCF | x86ByteFlagZF},
+			{"FCMOVNBE", x86ByteFlagCF | x86ByteFlagZF}, {"FCMOVHI", x86ByteFlagCF | x86ByteFlagZF},
+			{"FCMOVE", x86ByteFlagZF}, {"FCMOVEQ", x86ByteFlagZF}, {"FCMOVNE", x86ByteFlagZF},
+			{"FCMOVNU", x86ByteFlagPF}, {"FCMOVU", x86ByteFlagPF}, {"FCMOVUN", x86ByteFlagPF},
+		} {
+			for _, mutation := range []string{"none", "missing-flags", "unknown-source", "unknown-destination", "unknown-stack"} {
+				t.Run(fmt.Sprintf("%s/%s/%s", arch, row.op, mutation), func(t *testing.T) {
+					state := x86ResultState{flags: row.flags, x87: &x86ResultX87State{slots: 3, depth: 2, integer: [8]uint8{4, 8}}}
+					switch mutation {
+					case "missing-flags":
+						state.flags = 0
+					case "unknown-source":
+						state.x87.slots &^= 2
+					case "unknown-destination":
+						state.x87.slots &^= 1
+					case "unknown-stack":
+						state.x87.invalid = true
+					}
+					before := state.clone()
+					accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, row.op+" F1,F0"), &state, nil, 0, arch)
+					if !known || accepted != (mutation == "none") {
+						t.Fatal("conditional value used missing FLAGS/source/destination/shape", accepted, known)
+					}
+					if accepted && (state.x87.integer != [8]uint8{8, 8} || state.x87.slots != 3 || state.x87.depth != 2 ||
+						state.flags != before.flags || state.gp != before.gp) {
+						t.Fatal("conditional result did not join precisely the two source ranges or changed unrelated state")
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_x87_environment_backing_test.go b/x86_x87_environment_backing_test.go
new file mode 100644
index 000000000..fb5e827be
--- /dev/null
+++ b/x86_x87_environment_backing_test.go
@@ -0,0 +1,55 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86X87ENVLogicalBytesCannotImpersonateNativeBacking(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, triple := "MOVQ", "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, triple = "MOVL", "i386-unknown-linux-gnu"
+		}
+		var initializedAUTO strings.Builder
+		for offset := -28; offset < 0; offset += 4 {
+			fmt.Fprintf(&initializedAUTO, "MOVL $0,env%d(SP)\n", offset)
+		}
+		for _, row := range []struct {
+			name, declaration, prefix, read string
+			frame                           int
+			good                            bool
+		}{
+			{"separate-FP-fields", "func Value(a,b,c,d,e,f,g uint32) uint16", "", "a+0(FP)", 0, false},
+			{"initialized-AUTO", "func Value() uint16", initializedAUTO.String(), "env-28(SP)", 32, false},
+			{"actual-pointer", "func Value(env *byte) uint16", move + " env+0(FP),BX\n", "(BX)", 0, true},
+			{"NUM-is-not-pointer", "func Value(env *byte) uint16", move + " $32,BX\n", "(BX)", 0, false},
+			{"physical-SP", "func Value() uint16", "", "0(SP)", 0, false},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				_, _, sig, _ := x86ResultInitializationFixture(t, arch, row.declaration, "RET")
+				if len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Type != I16 {
+					t.Fatal("actual typed result layout changed")
+				}
+				result := sig.Frame.Results[0].Offset
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$%d-%d\n%sFLDENV %s\nFCLEX\nXORL AX,AX\nFSTSW AX\nMOVW AX,ret+%d(FP)\nFINIT\nRET\n",
+					row.frame, result+2, row.prefix, row.read, result)
+				ir, err := x86X87InitializedWordAPI(t, source, row.declaration, arch, triple, "text", X87Software)
+				if row.good {
+					if err != nil || ir == "" {
+						t.Fatal("actual reaching-pointer control rejected", err)
+					}
+					return
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatalf("logical initialized bytes supplied an unproved native ENV backing: output=%t error=%v", ir != "", err)
+				}
+				// This is a source-role boundary, not a claim that the Go
+				// assembler rejects the syntax or that a later guard ran.
+				t.Logf("FIRST_CONTEXT %s: %v", row.name, err)
+			})
+		}
+	}
+}
diff --git a/x86_x87_environment_bounded_test.go b/x86_x87_environment_bounded_test.go
new file mode 100644
index 000000000..67b130ae5
--- /dev/null
+++ b/x86_x87_environment_bounded_test.go
@@ -0,0 +1,418 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Keep the old complete literal independent of the bounded counterpart. A
+// pointer declaration does not authenticate the caller's dynamic Tag/TOP.
+const x86X87ENVOriginalSource = `TEXT clearModeledStatus(SB),4,$0-16
+MOVQ env+0(FP),BX
+FLDENV (BX)
+BYTE $0xdb; BYTE $0xe2
+XORL AX,AX
+FSTSW AX
+MOVQ AX,ret+8(FP)
+RET
+`
+
+func x86X87ENVBoundedSource() string {
+	return strings.Replace(x86X87ENVOriginalSource, "MOVQ AX,ret+8(FP)\nRET\n",
+		"MOVQ AX,ret+8(FP)\nFINIT\nRET\n", 1)
+}
+
+func x86X87ENVLiteral(t *testing.T, path, function string) string {
+	t.Helper()
+	return x86X87FunctionLiteral(t, path, function, "source")
+}
+
+func x86X87FunctionLiteral(t *testing.T, path, function, name string) string {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	file, err := parser.ParseFile(token.NewFileSet(), path, data, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var values []string
+	for _, declaration := range file.Decls {
+		fn, ok := declaration.(*ast.FuncDecl)
+		if !ok || fn.Name.Name != function {
+			continue
+		}
+		ast.Inspect(fn.Body, func(node ast.Node) bool {
+			spec, ok := node.(*ast.ValueSpec)
+			if !ok || len(spec.Names) != 1 || spec.Names[0].Name != name || len(spec.Values) != 1 {
+				return true
+			}
+			literal, ok := spec.Values[0].(*ast.BasicLit)
+			if !ok || literal.Kind != token.STRING {
+				t.Fatal("old source stopped being an independent complete literal")
+			}
+			value, err := strconv.Unquote(literal.Value)
+			if err != nil {
+				t.Fatal(err)
+			}
+			values = append(values, value)
+			return false
+		})
+	}
+	if len(values) != 1 {
+		t.Fatal("old complete source literal missing or duplicated", path, function)
+	}
+	return values[0]
+}
+
+func TestX86X87ENVBoundedCounterpartPreservesCompleteOriginal(t *testing.T) {
+	for _, owner := range []struct{ file, function string }{
+		{"x86_x87_environment_source_test.go", "TestX86X87SoftwareEnvironmentClearCompleteSourceThreeAPIs"},
+		{"amd64_raw_x87_control_test.go", "TestX86RawX87SoftwareClearPreservesAllStatusFields"},
+	} {
+		t.Run(owner.function, func(t *testing.T) {
+			if got := x86X87ENVLiteral(t, owner.file, owner.function); got != x86X87ENVOriginalSource {
+				t.Fatal("complete old environment source changed")
+			}
+		})
+	}
+	bounded := x86X87ENVBoundedSource()
+	if strings.Count(bounded, "FINIT\n") != 1 || strings.Replace(bounded, "FINIT\n", "", 1) != x86X87ENVOriginalSource ||
+		!strings.Contains(bounded, "FSTSW AX\nMOVQ AX,ret+8(FP)\nFINIT\nRET\n") {
+		t.Fatal("counterpart must add only one FINIT after the captured result write")
+	}
+}
+
+func TestX86X87ENVBoundedCounterpartThreeAPIs(t *testing.T) {
+	for _, triple := range []string{"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc"} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, x86X87ENVBoundedSource(), "func clearModeledStatus(env *byte) uint64",
+					"amd64", triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("bounded counterpart rejected before any read/value observation; original is not certified", err)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87ENVOriginalQueryAndSourceBoundaries(t *testing.T) {
+	const declaration = "func clearModeledStatus(env *byte) uint64"
+	for _, source := range []struct{ name, text string }{
+		{"original-unknown-shape", x86X87ENVOriginalSource},
+		{"bounded-counterpart", x86X87ENVBoundedSource()},
+	} {
+		t.Run("query/"+source.name, func(t *testing.T) {
+			_, _, sig, _ := x86ResultInitializationFixture(t, "amd64", "func Value(env *byte) uint64", "RET")
+			sig.Name = "clearModeledStatus"
+			file, err := Parse(ArchAMD64, source.text)
+			if err != nil {
+				t.Fatal(err)
+			}
+			normalized, err := normalizeX86RawFile(file, "amd64")
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, fn := range []Func{file.Funcs[0], normalized.Funcs[0]} {
+				if err := CheckX86ABI0ResultInitialization(fn, sig, "amd64"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("standalone original/decoded query borrowed a paired environment read", err)
+				}
+			}
+		})
+	}
+	for _, mutation := range []struct{ name, source string }{
+		{"original-unknown-shape", x86X87ENVOriginalSource},
+		{"one-path-misses-init", strings.Replace(x86X87ENVBoundedSource(), "FINIT\nRET", "TESTL AX,AX\nJE done\nFINIT\ndone:\nRET", 1)},
+		{"init-does-not-create-F0", strings.Replace(x86X87ENVBoundedSource(), "FINIT\nRET", "FINIT\nFTST\nRET", 1)},
+		{"nonempty-after-init", strings.Replace(x86X87ENVBoundedSource(), "FINIT\nRET", "FINIT\nFLD1\nRET", 1)},
+		{"unknown-address", strings.Replace(x86X87ENVBoundedSource(), "MOVQ env+0(FP),BX\n", "", 1)},
+		{"NUM-is-not-pointer", strings.Replace(x86X87ENVBoundedSource(), "MOVQ env+0(FP),BX", "MOVQ $32,BX", 1)},
+		{"FRSTOR-is-not-ENV28", strings.Replace(x86X87ENVBoundedSource(), "FLDENV", "FRSTOR", 1)},
+		{"read-does-not-authorize-ENV-store", strings.Replace(x86X87ENVBoundedSource(), "FLDENV (BX)\n", "FLDENV (BX)\nFSTENV (BX)\n", 1)},
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(mutation.name+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, mutation.source, declaration, "amd64", "x86_64-unknown-linux-gnu", api, X87Software)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+					t.Fatal("environment source borrowed unknown shape/value/address or another restore footprint", err)
+				}
+				// An earlier Context is not evidence that a later stack/shape
+				// guard ran. Preserve this exact first diagnostic in the raw log.
+				t.Logf("FIRST_CONTEXT %s: %v", mutation.name, err)
+			})
+		}
+	}
+}
+
+func x86X87ENVReadIR(t *testing.T, segment Reg, dead bool) string {
+	t.Helper()
+	var body strings.Builder
+	ctx := &amd64Ctx{b: &body, goarch: "amd64", x87Mode: X87Software,
+		regSlot: map[Reg]string{BX: "%base"}, x87ControlSlot: "%cw", x87StatusSlot: "%sw"}
+	source := Operand{Kind: OpMem, Mem: MemRef{Base: BX, Segment: segment}}
+	if err := ctx.loadX87Environment(source); err != nil {
+		t.Fatal(err)
+	}
+	result := "ret i16 0\n"
+	if !dead {
+		result = "%result = load i16, ptr %sw\nret i16 %result\n"
+	}
+	return "define i16 @EnvRead(i64 %address) {\n%base = alloca i64\nstore i64 %address, ptr %base\n" +
+		"%cw = alloca i16\n%sw = alloca i16\n" + body.String() + result + "}\n"
+}
+
+func x86X87ENVTypeBytes(typ llvm.Type) int {
+	switch typ.TypeKind() {
+	case llvm.IntegerTypeKind:
+		if bits := typ.IntTypeWidth(); bits > 0 && bits <= 224 && bits%8 == 0 {
+			return bits / 8
+		}
+	case llvm.ArrayTypeKind:
+		if typ.ArrayLength() <= 28 {
+			return typ.ArrayLength() * x86X87ENVTypeBytes(typ.ElementType())
+		}
+	case llvm.VectorTypeKind:
+		if typ.VectorSize() <= 28 {
+			return typ.VectorSize() * x86X87ENVTypeBytes(typ.ElementType())
+		}
+	}
+	return 0
+}
+
+func x86X87ENVReadOffset(pointer llvm.Value, roots map[llvm.Value]bool, remaining *int) (int, bool) {
+	if *remaining == 0 {
+		return 0, false // Unknown/cyclic pointer graphs cannot manufacture an offset.
+	}
+	*remaining--
+	if roots[pointer] {
+		return 0, true
+	}
+	if !pointer.IsAIntToPtrInst().IsNil() {
+		return 0, true
+	}
+	if !pointer.IsASelectInst().IsNil() {
+		first, firstOK := x86X87ENVReadOffset(pointer.Operand(1), roots, remaining)
+		last, lastOK := x86X87ENVReadOffset(pointer.Operand(2), roots, remaining)
+		return first, firstOK && lastOK && first == last
+	}
+	if !pointer.IsAPHINode().IsNil() {
+		if pointer.IncomingCount() == 0 {
+			return 0, false
+		}
+		first, valid := x86X87ENVReadOffset(pointer.IncomingValue(0), roots, remaining)
+		for index := 1; valid && index < pointer.IncomingCount(); index++ {
+			other, known := x86X87ENVReadOffset(pointer.IncomingValue(index), roots, remaining)
+			valid = known && other == first
+		}
+		return first, valid
+	}
+	if pointer.IsAGetElementPtrInst().IsNil() || pointer.OperandsCount() != 2 ||
+		pointer.GEPSourceElementType().TypeKind() != llvm.IntegerTypeKind || pointer.GEPSourceElementType().IntTypeWidth() != 8 ||
+		pointer.Operand(1).IsAConstantInt().IsNil() {
+		return 0, false
+	}
+	delta := pointer.Operand(1).SExtValue()
+	if delta < -28 || delta > 28 {
+		return 0, false // Bound arithmetic before narrowing or adding offsets.
+	}
+	base, valid := x86X87ENVReadOffset(pointer.Operand(0), roots, remaining)
+	return base + int(delta), valid
+}
+
+func x86X87ENVReadFootprint(ir string, addressSpace int) error {
+	return x86X87ENVReadFootprintOf(ir, addressSpace, "EnvRead")
+}
+
+func x86X87ENVReadFootprintOf(ir string, addressSpace int, name string) error {
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		return err
+	}
+	function := module.NamedFunction(name)
+	if function.IsNil() {
+		return fmt.Errorf("missing complete environment read")
+	}
+	roots := make(map[llvm.Value]bool)
+	for index := 0; index < function.ParamsCount(); index++ {
+		parameter := function.Param(index)
+		if parameter.Type().TypeKind() == llvm.PointerTypeKind {
+			roots[parameter] = true
+		}
+	}
+	var seen [28]int
+	for block := function.FirstBasicBlock(); !block.IsNil(); block = llvm.NextBasicBlock(block) {
+		for ins := block.FirstInstruction(); !ins.IsNil(); ins = llvm.NextInstruction(ins) {
+			if ins.IsALoadInst().IsNil() || x86GPSIMDStoreTargetsBackingAlloca(ins.Operand(0)) {
+				continue
+			}
+			pointer := ins.Operand(0)
+			remaining := 256
+			offset, valid := x86X87ENVReadOffset(pointer, roots, &remaining)
+			width := x86X87ENVTypeBytes(ins.Type())
+			if !valid || width <= 0 || offset < 0 || offset > 28-width || !ins.IsVolatile() || ins.Alignment() != 1 ||
+				pointer.Type().PointerAddressSpace() != addressSpace {
+				return fmt.Errorf("wrong ENV28 extent/volatility/address space: %s", ins.String())
+			}
+			for index := offset; index < offset+width; index++ {
+				seen[index]++
+			}
+		}
+	}
+	for offset, count := range seen {
+		if count != 1 {
+			return fmt.Errorf("ENV byte %d read %d times, want exactly once", offset, count)
+		}
+	}
+	return nil
+}
+
+// A direct emitter observation, not native entry or source admission. The
+// independent public complete-source owner above must also pass separately.
+func TestX86X87ENVSoftwareReadRetainsAll28BytesAndAddressSpace(t *testing.T) {
+	for _, segment := range []Reg{"", FS, GS} {
+		space := map[Reg]int{"": 0, FS: 257, GS: 256}[segment]
+		for _, dead := range []bool{false, true} {
+			for _, optimized := range []bool{false, true} {
+				t.Run(fmt.Sprintf("AS%d/dead%t/O2-%t", space, dead, optimized), func(t *testing.T) {
+					ir := x86X87ENVReadIR(t, segment, dead)
+					if optimized {
+						ir = x86MulDivRoundOptimize(t, ir)
+					}
+					if err := x86X87ENVReadFootprint(ir, space); err != nil {
+						t.Fatal(err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87ENVReadFootprintCheckerHasIndependentControls(t *testing.T) {
+	const reference = `define i16 @EnvRead(i64 %address) {
+%p = inttoptr i64 %address to ptr addrspace(257)
+%v = load volatile i224, ptr addrspace(257) %p, align 1
+ret i16 0
+}
+`
+	if err := x86X87ENVReadFootprint(reference, 257); err != nil {
+		t.Fatal("independent full-28 reference was rejected", err)
+	}
+	for _, change := range []struct{ name, from, to string }{
+		{"missing-volatility", "load volatile", "load"},
+		{"word-only", "i224", "i16"},
+		{"short-ENV", "i224", "i208"},
+		{"FRSTOR-sized", "i224", "i864"},
+		{"wrong-address-space", "257", "256"},
+		{"invented-alignment", "align 1", "align 2"},
+		{"duplicate-read", "ret i16 0", "%again = load volatile i224, ptr addrspace(257) %p, align 1\nret i16 0"},
+		{"missing-read", "%v = load volatile i224, ptr addrspace(257) %p, align 1", "; no read"},
+	} {
+		t.Run(change.name, func(t *testing.T) {
+			modified := strings.ReplaceAll(reference, change.from, change.to)
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := parseIRModuleInContext(context, modified)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal("checker control must be valid LLVM IR, not a parser rejection", err)
+			}
+			if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("checker control is not valid LLVM IR", err)
+			}
+			if err := x86X87ENVReadFootprint(modified, 257); err == nil {
+				t.Fatal("wrong ENV footprint escaped its independent reader")
+			}
+		})
+	}
+}
+
+func TestX86X87ENVFinalFINITPreservesCapturedBytesNotValues(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		t.Run(arch, func(t *testing.T) {
+			state := x86ResultState{fp: []bool{true, true}, gp: [16]uint8{0: 0xff},
+				x87: &x86ResultX87State{invalid: true, status: 0xffff, gp: [16]uint16{0: 0xffff},
+					word: &x86ResultX87WordState{control: 0xffff}}}
+			before := state.clone()
+			if accepted, known := x86ResultX87WordStep(x86X87ValueInstruction(t, "FINIT"), &state, nil, 0, arch); !known || !accepted {
+				t.Fatal("explicit final initialize did not recover a known empty shape")
+			}
+			if state.x87.invalid || state.x87.depth != 0 || state.x87.slots != 0 || state.gp != before.gp ||
+				state.x87.gp != before.x87.gp || len(state.fp) != 2 || !state.fp[0] || !state.fp[1] ||
+				state.x87.read(Operand{Kind: OpReg, Reg: "F0"}) {
+				t.Fatal("FINIT changed captured bytes or manufactured an initialized x87 value")
+			}
+		})
+	}
+}
+
+// This executes Software semantics on the actual host target. It is neither
+// original Go execution nor an x86 hardware ENV/Tag/exception oracle. The old
+// host-gated hardware oracle and the original complete source remain unchanged.
+func TestX86X87ENVBoundedHostSoftwareCapturedStatusExecution(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc/clang are required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	const mainC = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint64_t clearModeledStatus(const void *);
+int main(void) {
+  unsigned char storage[64], before[64];
+  unsigned char *env=storage+17; /* unaligned, with canaries on both sides */
+  const uint16_t control=0x037f, tags=0xffff;
+  for (unsigned status=0; status<=0xffff; status++) {
+    const uint16_t input=(uint16_t)status;
+    memset(storage,0xa5,sizeof(storage)); memset(env,0,28);
+    memcpy(env,&control,2); memcpy(env+4,&input,2); memcpy(env+8,&tags,2);
+    memcpy(before,storage,sizeof(storage));
+    const uint64_t got=clearModeledStatus(env), expected=status&0x7f00;
+    if (got!=expected || memcmp(storage,before,sizeof(storage))) {
+      fprintf(stderr,"Software status=%x got=%llx expected=%llx or input changed\n",
+              status,(unsigned long long)got,(unsigned long long)expected);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/IR-O2-%t", api, optimized), func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, x86X87ENVBoundedSource(), "func clearModeledStatus(env *byte) uint64",
+					"amd64", triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("source rejected: host Software numerical execution was not reached", err)
+				}
+				if strings.Contains(ir, "asm sideeffect") {
+					t.Fatal("host Software oracle must not execute hardware x87 inline assembly")
+				}
+				if optimized {
+					ir = x86MulDivRoundOptimize(t, ir)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "env-bounded-software", triple, ir, mainC, nil)
+			})
+		}
+	}
+}
diff --git a/x86_x87_environment_fault_unix_test.go b/x86_x87_environment_fault_unix_test.go
new file mode 100644
index 000000000..02e014326
--- /dev/null
+++ b/x86_x87_environment_fault_unix_test.go
@@ -0,0 +1,79 @@
+//go:build linux || darwin
+
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"testing"
+)
+
+// This is host-executed Software memory semantics, not original-Go or native
+// x87 environment execution. Both live and dead observations must read exactly
+// 28 bytes without borrowing the mapped page's extra accessible storage.
+func TestX86X87ENVSoftwareLiveDeadGuardPageFootprint(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	const driver = `
+#include <errno.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+#include <unistd.h>
+extern uint16_t EnvRead(uint64_t address);
+static int probe(unsigned char *input, int fault) {
+  pid_t child=fork();
+  if (child<0) return 1;
+  if (!child) {
+    struct rlimit limit={0,0};
+    if (setrlimit(RLIMIT_CORE,&limit)) _exit(3);
+    volatile uint16_t value=EnvRead((uint64_t)(uintptr_t)input);
+    (void)value;
+    _exit(0);
+  }
+  int status=0;
+  pid_t waited;
+  do { waited=waitpid(child,&status,0); } while (waited<0 && errno==EINTR);
+  if (waited!=child) return 1;
+  return fault ? !(WIFSIGNALED(status) &&
+      (WTERMSIG(status)==SIGSEGV || WTERMSIG(status)==SIGBUS)) :
+      !(WIFEXITED(status) && WEXITSTATUS(status)==0);
+}
+int main(void) {
+  const long page=sysconf(_SC_PAGESIZE);
+  if (page<64) return 2;
+  unsigned char *area=mmap(0,(size_t)page*3,PROT_READ|PROT_WRITE,
+      MAP_PRIVATE|MAP_ANON,-1,0);
+  if (area==MAP_FAILED) return 2;
+  memset(area+page,0x5a,(size_t)page);
+  if (mprotect(area,(size_t)page,PROT_NONE) ||
+      mprotect(area+page*2,(size_t)page,PROT_NONE)) return 2;
+  unsigned char *end=area+page*2;
+  if (probe(area+page,0) || probe(end-28,0) || probe(end-27,1) ||
+      probe(area+page-1,1)) {
+    fprintf(stderr,"ENV28 live/dead read has an incorrect boundary\n");
+    return 1;
+  }
+  return munmap(area,(size_t)page*3) ? 2 : 0;
+}
+`
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	for _, dead := range []bool{false, true} {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("dead%t/IR-O2-%t", dead, optimized), func(t *testing.T) {
+				ir := x86X87ENVReadIR(t, "", dead)
+				if optimized {
+					ir = x86MulDivRoundOptimize(t, ir)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "env28-fault", triple, ir, driver, nil)
+			})
+		}
+	}
+}
diff --git a/x86_x87_environment_input_obligation_test.go b/x86_x87_environment_input_obligation_test.go
new file mode 100644
index 000000000..f5c31ea63
--- /dev/null
+++ b/x86_x87_environment_input_obligation_test.go
@@ -0,0 +1,131 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// This is a separate mode32 counterpart, not the original amd64 literal with
+// a partial uint64 store. The real Go result is uint32 at ABI0 offset four.
+const x86X87ENV386BoundedSource = `TEXT ·Value(SB),4,$0-8
+MOVL env+0(FP),BX
+FLDENV (BX)
+BYTE $0xdb; BYTE $0xe2
+XORL AX,AX
+FSTSW AX
+MOVL AX,ret+4(FP)
+FINIT
+RET
+`
+
+func TestX86X87ENV386BoundedWholeSourceThreeAPIs(t *testing.T) {
+	const declaration = "func Value(env *byte) uint32"
+	_, _, sig, _ := x86ResultInitializationFixture(t, "386", declaration, "RET")
+	if sig.Ret != I32 || len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Offset != 4 ||
+		sig.Frame.Results[0].Type != I32 || len(sig.Frame.Params) != 1 || sig.Frame.Params[0].Type != Ptr {
+		t.Fatal("mode32 counterpart lost its complete actual uint32 result layout", sig)
+	}
+	file, err := Parse(ArchAMD64, x86X87ENV386BoundedSource)
+	if err != nil || len(file.Funcs) != 1 || file.Funcs[0].ArgSize != 8 || file.Funcs[0].FrameSize != 0 ||
+		strings.Count(x86X87ENV386BoundedSource, "FINIT\n") != 1 ||
+		!strings.Contains(x86X87ENV386BoundedSource, "FSTSW AX\nMOVL AX,ret+4(FP)\nFINIT\nRET\n") {
+		t.Fatal("complete mode32 source/header/capture ordering changed", err)
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc"} {
+		for _, bounded := range []bool{true, false} {
+			source, name := x86X87ENV386BoundedSource, "bounded-uint32"
+			if !bounded {
+				source, name = strings.Replace(source, "FINIT\n", "", 1), "unknown-shape-at-RET"
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(triple+"/"+name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source, declaration, "386", triple, api, X87Software)
+					if bounded {
+						if err != nil || ir == "" {
+							t.Fatalf("bounded mode32 counterpart rejected before numerical observation: %v\n%s", err, source)
+						}
+					} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("mode32 return borrowed unknown Tag/TOP as an empty stack", err)
+					} else {
+						t.Logf("FIRST_CONTEXT unknown-shape-at-RET (later guard not inferred): %v", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func x86X87ENVVoidSource(t *testing.T, arch, declaration, body string) string {
+	t.Helper()
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+	if sig.Ret != Void || len(sig.Frame.Results) != 0 {
+		t.Fatal("Void ENV fixture acquired a fabricated result")
+	}
+	var extent int64
+	for _, slot := range sig.Frame.Params {
+		if end := slot.Offset + x86FrameScalarBytes(slot.Type, arch); end > extent {
+			extent = end
+		}
+	}
+	return fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", extent, body)
+}
+
+// Only the actual-pointer and unknown-base pair is repeated through all APIs.
+// Each additional row isolates one source/input obligation on a named API;
+// there is no Cartesian object/native matrix or new memory-owner producer.
+func TestX86X87ENVVoidSourceInputsCannotHideBehindNoResult(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		move, word, triple := "MOVQ", 8, "x86_64-unknown-linux-gnu"
+		if arch == "386" {
+			move, word, triple = "MOVL", 4, "i386-unknown-linux-gnu"
+		}
+		pointer := move + " env+0(FP),BX\n"
+		readAndReset := "FLDENV (BX)\nFINIT\nRET\n"
+		branch := fmt.Sprintf("MOVL gate+%d(FP),AX\nTESTL AX,AX\nJE joined\n", word)
+		for _, row := range []struct {
+			name, declaration, body string
+			good                    bool
+			apis                    []string
+		}{
+			// FINIT discards both loaded words and restores a known empty
+			// shape. The complete native read must still occur on both IR axes.
+			{"actual-pointer-dead-read", "func Value(env *byte)", pointer + readAndReset, true, []string{"text", "module", "Go"}},
+			{"unknown-base-dead-read", "func Value(env *byte)", readAndReset, false, []string{"text", "module", "Go"}},
+			{"NUM-is-not-native-address", "func Value(env *byte)", move + " $32,BX\n" + readAndReset, false, []string{"text"}},
+			{"partial-base", "func Value(env *byte)", "MOVW $32,BX\n" + readAndReset, false, []string{"module"}},
+			{"revoked-pointer", "func Value(env *byte)", pointer + "MOVB $0,BL\n" + readAndReset, false, []string{"Go"}},
+			{"pointer-NUM-join", "func Value(env *byte,gate uint32)", pointer + branch + move + " $32,BX\njoined:\n" + readAndReset, false, []string{"module"}},
+			{"two-actual-pointers-join", "func Value(env,other *byte,gate uint32)", pointer + fmt.Sprintf("MOVL gate+%d(FP),AX\nTESTL AX,AX\nJE joined\n", 2*word) +
+				fmt.Sprintf("%s other+%d(FP),BX\njoined:\n", move, word) + readAndReset, true, []string{"text"}},
+			{"missing-final-reset", "func Value(env *byte)", pointer + "FLDENV (BX)\nRET\n", false, []string{"Go"}},
+		} {
+			source := x86X87ENVVoidSource(t, arch, row.declaration, row.body)
+			for _, api := range row.apis {
+				t.Run(arch+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source, row.declaration, arch, triple, api, X87Software)
+					if !row.good {
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("Void source/input obligation bypassed: output=%t error=%v\n%s", ir != "", err, source)
+						}
+						t.Logf("FIRST_CONTEXT %s (later guard not inferred): %v", row.name, err)
+						return
+					}
+					if err != nil || ir == "" {
+						t.Fatalf("actual pointer source rejected before its dead-read observation: %v\n%s", err, source)
+					}
+					for _, optimized := range []bool{false, true} {
+						input := ir
+						if optimized {
+							input = x86MulDivRoundOptimize(t, input)
+						}
+						if err := x86X87ENVReadFootprintOf(input, 0, "Value"); err != nil {
+							t.Fatalf("Void ENV dead read O2=%t: %v", optimized, err)
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_x87_environment_objects_test.go b/x86_x87_environment_objects_test.go
new file mode 100644
index 000000000..d52d3395b
--- /dev/null
+++ b/x86_x87_environment_objects_test.go
@@ -0,0 +1,35 @@
+package plan9asm
+
+import "testing"
+
+func TestX86X87ENVBoundedFiveTargetCompleteObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required for the complete environment objects")
+	}
+	for _, target := range x86RawReturnTargets {
+		source, declaration := x86X87ENVBoundedSource(), "func clearModeledStatus(env *byte) uint64"
+		if target.arch == "386" {
+			source, declaration = x86X87ENV386BoundedSource, "func Value(env *byte) uint32"
+		}
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("whole source did not reach the object compiler", err)
+				}
+				for _, level := range []string{"0", "2"} {
+					input := ir
+					if level == "2" {
+						input = x86DwordProductIROptimize(t, input)
+					}
+					for _, backend := range []string{"0", "2"} {
+						t.Run("IR"+level+"/backend"+backend, func(t *testing.T) {
+							x86PackedStringCompileObject(t, llc, target.triple, input, "-O"+backend)
+						})
+					}
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_environment_reader_pointer_test.go b/x86_x87_environment_reader_pointer_test.go
new file mode 100644
index 000000000..1a42e0fd8
--- /dev/null
+++ b/x86_x87_environment_reader_pointer_test.go
@@ -0,0 +1,73 @@
+package plan9asm
+
+import (
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// These independent IR fixtures exercise only footprint observation. They
+// cannot produce an input-pointer, source, raw or native-memory permission.
+func TestX86X87ENVFootprintReaderHandlesOptimizedPointerValues(t *testing.T) {
+	for _, row := range []struct {
+		name, body string
+		good       bool
+	}{
+		{"pointer-argument", `entry:
+%v = load volatile i224, ptr %a, align 1
+ret void`, true},
+		{"selected-arguments", `entry:
+%p = select i1 %gate, ptr %a, ptr %b
+%v = load volatile i224, ptr %p, align 1
+ret void`, true},
+		{"joined-arguments", `entry:
+br i1 %gate, label %left, label %right
+left:
+br label %join
+right:
+br label %join
+join:
+%p = phi ptr [%a, %left], [%b, %right]
+%v = load volatile i224, ptr %p, align 1
+ret void`, true},
+		{"selected-different-offsets", `entry:
+%offset = getelementptr i8, ptr %b, i64 1
+%p = select i1 %gate, ptr %a, ptr %offset
+%v = load volatile i224, ptr %p, align 1
+ret void`, false},
+		{"selected-null", `entry:
+%p = select i1 %gate, ptr %a, ptr null
+%v = load volatile i224, ptr %p, align 1
+ret void`, false},
+		{"joined-different-offsets", `entry:
+%offset = getelementptr i8, ptr %b, i64 1
+br i1 %gate, label %left, label %right
+left:
+br label %join
+right:
+br label %join
+join:
+%p = phi ptr [%a, %left], [%offset, %right]
+%v = load volatile i224, ptr %p, align 1
+ret void`, false},
+	} {
+		t.Run(row.name, func(t *testing.T) {
+			ir := "define void @EnvRead(ptr %a, ptr %b, i1 %gate) {\n" + row.body + "\n}\n"
+			context := llvm.NewContext()
+			defer context.Dispose()
+			module, err := parseIRModuleInContext(context, ir)
+			if !module.IsNil() {
+				defer module.Dispose()
+			}
+			if err != nil {
+				t.Fatal("independent reader fixture must parse", err)
+			}
+			if err := llvm.VerifyModule(module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal("independent reader fixture must be valid LLVM IR", err)
+			}
+			if err := x86X87ENVReadFootprint(ir, 0); (err == nil) != row.good {
+				t.Fatal("footprint reader confused pointer normalization with a complete read", err)
+			}
+		})
+	}
+}
diff --git a/x86_x87_environment_source_test.go b/x86_x87_environment_source_test.go
new file mode 100644
index 000000000..011000981
--- /dev/null
+++ b/x86_x87_environment_source_test.go
@@ -0,0 +1,39 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+// This is the complete original source from the host-gated software status
+// oracle, not a manufactured word initializer or an environment permission.
+// Keep it independently visible on hosts that cannot execute the old oracle.
+func TestX86X87SoftwareEnvironmentClearCompleteSourceThreeAPIs(t *testing.T) {
+	const source = `TEXT clearModeledStatus(SB),4,$0-16
+MOVQ env+0(FP),BX
+FLDENV (BX)
+BYTE $0xdb; BYTE $0xe2
+XORL AX,AX
+FSTSW AX
+MOVQ AX,ret+8(FP)
+RET
+`
+	for _, triple := range []string{
+		"x86_64-apple-darwin", "x86_64-unknown-linux-gnu", "x86_64-pc-windows-msvc",
+	} {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, source, "func clearModeledStatus(env *byte) uint64",
+					"amd64", triple, api, X87Software)
+				if !errors.Is(err, ErrProbeNeedsContext) || ir != "" ||
+					!strings.Contains(err.Error(), "logical x87 value stack is not balanced at RET") {
+					t.Fatal("original environment supplied an unobserved empty Tag/TOP at RET", err)
+				}
+				// The separately named bounded counterpart adds a real FINIT
+				// only after capturing/writing the result. Its successful
+				// objects and runtime oracle do not certify this old source.
+			})
+		}
+	}
+}
diff --git a/x86_x87_float_storage_test.go b/x86_x87_float_storage_test.go
new file mode 100644
index 000000000..c6d176da1
--- /dev/null
+++ b/x86_x87_float_storage_test.go
@@ -0,0 +1,102 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// These controls belong to the existing private-role owner, not another source
+// observer. Every case still uses an actual typed declaration and all three
+// translation APIs. O2 constants are logical byte/value checks, not execution.
+func x86X87FloatingStoresUseOnlyCheckedByteRoles(t *testing.T) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			width, scalar, tuple := 4, "float", "{ i16, i16 }"
+			want := []uint64{0, 0x3f80}
+			declaration := "func Value(gate uint64) (lo,hi uint16)"
+			if strings.HasPrefix(op, "FMOVD") {
+				width, scalar, tuple = 8, "double", "{ i32, i32 }"
+				want, declaration = []uint64{0, 0x3ff00000}, "func Value(gate uint64) (lo,hi uint32)"
+			}
+			pop := "FMOVDP F0,F0\n"
+			if strings.HasSuffix(op, "P") {
+				pop = ""
+			}
+			body := "MOVL gate+4(FP),AX\nFLD1\n" + op + " F0,lo+8(FP)\n" + pop + "RET"
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+op+"/cross-fields/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("checked x87 store did not span every independent numerical field", err)
+					}
+					probe := fmt.Sprintf("\ndefine %s @Probe() {\n %%r = call %s @Value(i64 0)\n ret %s %%r\n}\n", tuple, tuple, tuple)
+					x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", want)
+				})
+			}
+			if width == 4 {
+				for _, interior := range []int{0, 1, 4} {
+					declaration := "func Value(gate uint64) float64"
+					body := fmt.Sprintf("MOVL gate+4(FP),AX\nMOVL $0,ret+8(FP)\nMOVL $0,ret+12(FP)\nFLD1\n%s F0,ret+%d(FP)\n%sRET",
+						op, 8+interior, pop)
+					_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/%s/interior-%d/%s", target.triple, op, interior, api), func(t *testing.T) {
+							ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+							if err != nil || ir == "" {
+								t.Fatal("checked x87 store lost the untouched double-result bytes", err)
+							}
+							probe := "\ndefine i64 @Probe() {\n %r = call double @Value(i64 0)\n %b = bitcast double %r to i64\n ret i64 %b\n}\n"
+							x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{uint64(0x3f800000) << uint(8*interior)})
+						})
+					}
+				}
+			}
+			// A source-defined F0 is necessary but never supplies permission to
+			// write padding, pointers or parameters. An incomplete numerical
+			// tuple remains a failed audit, independently of code generation.
+			paddedOffset := 16
+			if target.arch == "386" {
+				paddedOffset = 12
+			}
+			paddedTail := fmt.Sprintf("MOVB $0,a+8(FP)\nMOVL $0,b+%d(FP)\nMOVL $0,b+%d(FP)\n", paddedOffset, paddedOffset+4)
+			partialDeclaration := "func Value(gate uint64) uint64"
+			if width == 8 {
+				partialDeclaration = "func Value(gate uint64) (a,b,c uint32)"
+			}
+			for _, row := range []struct{ name, declaration, body string }{
+				{"padding", "func Value(gate uint64) (a byte,b uint64)", "FLD1\n" + op + " F0,padding+9(FP)\n" + pop + paddedTail},
+				{"pointer", "func Value(gate uint64) *byte", "FLD1\n" + op + " F0,ret+8(FP)\n" + pop},
+				{"parameter-write", "func Value(gate uint64) uint64", "FLD1\n" + op + " F0,gate+0(FP)\n" + pop + "MOVL $0,ret+8(FP)\nMOVL $0,ret+12(FP)\n"},
+				{"unknown-F0", "func Value(gate uint64) float64", op + " F0,ret+8(FP)\n" + pop + "MOVL $0,ret+12(FP)\n"},
+				{"partial-result", partialDeclaration, "FLD1\n" + op + " F0,ret+8(FP)\n" + pop},
+				{"outside-result", "func Value(gate uint64) uint64", fmt.Sprintf("FLD1\n%s F0,ret+%d(FP)\n%sMOVL $0,ret+8(FP)\nMOVL $0,ret+12(FP)\n", op, 17-width, pop)},
+			} {
+				body := "MOVL gate+4(FP),AX\n" + row.body + "RET"
+				_, _, _, source := x86ResultInitializationFixture(t, target.arch, row.declaration, body)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/reject-"+row.name+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, row.declaration, target.arch, target.triple, api)
+						if width == 8 && row.name == "partial-result" {
+							x86PartialTupleCodegenControl(t, source, row.declaration, target.arch, target.triple, ir, err)
+							probe := "\ndefine { i32, i32 } @Probe() {\n" +
+								" %r = call { i32, i32, i32 } @Value(i64 0)\n" +
+								" %lo = extractvalue { i32, i32, i32 } %r, 0\n" +
+								" %hi = extractvalue { i32, i32, i32 } %r, 1\n" +
+								" %a = insertvalue { i32, i32 } undef, i32 %lo, 0\n" +
+								" %b = insertvalue { i32, i32 } %a, i32 %hi, 1\n ret { i32, i32 } %b\n}\n"
+							x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{0, 0x3ff00000})
+							return
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("%s store supplied missing %s authority: output=%t error=%v", scalar, row.name, ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_initialized_word_go_test.go b/x86_x87_initialized_word_go_test.go
new file mode 100644
index 000000000..1b652a1ed
--- /dev/null
+++ b/x86_x87_initialized_word_go_test.go
@@ -0,0 +1,68 @@
+package plan9asm
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86X87InitClearWordCompleteGoRowsAndBytes(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}",
+		"var ystsw = []ytab{\n\t{Zo_m, 2, argList{Ym}},\n\t{Zlit, 1, argList{Yax}},\n}",
+		"var ysvrs_mo = []ytab{\n\t{Zm_o, 2, argList{Ym}},\n}",
+		"var ysvrs_om = []ytab{\n\t{Zo_m, 2, argList{Ym}},\n}",
+		"{AFCLEX, ynone, Px, opBytes{0xdb, 0xe2}}",
+		"{AFINIT, ynone, Px, opBytes{0xdb, 0xe3}}",
+		"{AFSTCW, ysvrs_om, Px, opBytes{0xd9, 07, 0xd9, 07}}",
+		"{AFSTSW, ystsw, Px, opBytes{0xdd, 07, 0xdf, 0xe0}}",
+		"{AFLDCW, ysvrs_mo, Px, opBytes{0xd9, 05, 0xd9, 05}}",
+		"{AWAIT, ynone, Px, opBytes{0x9b}}",
+	} {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("selected complete Go init/clear/word grammar changed", row)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			bytes  []byte
+		}{
+			{"FINIT", []byte{0xdb, 0xe3}},
+			{"FCLEX", []byte{0xdb, 0xe2}},
+			{"FSTCW (AX)", []byte{0xd9, 0x38}},
+			{"FSTSW (AX)", []byte{0xdd, 0x38}},
+			{"FSTSW AX", []byte{0xdf, 0xe0}},
+			{"FLDCW (AX)", []byte{0xd9, 0x28}},
+			{"WAIT\nFINIT", []byte{0x9b, 0xdb, 0xe3}},
+			{"WAIT\nFCLEX", []byte{0x9b, 0xdb, 0xe2}},
+			{"FSTCW -7(BX)(CX*4)", []byte{0xd9, 0x7c, 0x8b, 0xf9}},
+			{"FSTSW -7(BX)(CX*4)", []byte{0xdd, 0x7c, 0x8b, 0xf9}},
+			{"FLDCW -7(BX)(CX*4)", []byte{0xd9, 0x6c, 0x8b, 0xf9}},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				source := "TEXT probe(SB),4,$0-0\n" + row.source + "\nRET\n"
+				got := x86OrderingHintGoBytes(t, arch, source)
+				want := append(append([]byte(nil), row.bytes...), 0xc3)
+				if !bytes.Equal(got, want) {
+					t.Fatalf("actual Go word row bytes=%x want=%x", got, want)
+				}
+			})
+		}
+		for _, source := range []string{
+			"FINIT AX", "FCLEX AX", "FSTCW AX", "FSTSW BX", "FLDCW AX",
+			"FINIT.Z", "FSTSW.Z AX", "FNINIT", "FNCLEX",
+		} {
+			t.Run(arch+"/Go-rejects/"+source, func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT probe(SB),4,$0-0\n"+source+"\nRET\n", "", false)
+			})
+		}
+	}
+}
diff --git a/x86_x87_initialized_word_test.go b/x86_x87_initialized_word_test.go
new file mode 100644
index 000000000..ca8079b57
--- /dev/null
+++ b/x86_x87_initialized_word_test.go
@@ -0,0 +1,202 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// This test-only mode adapter uses the same actual Go declaration derivation
+// and three existing translation APIs. It supplies no new source/word role.
+func x86X87InitializedWordAPI(t *testing.T, source, declaration, arch, triple, api string, mode X87Mode) (string, error) {
+	t.Helper()
+	pkg := mustGoPackage(t, "wordinit", "package wordinit\n"+declaration)
+	resolve := func(symbol string) string { return strings.TrimPrefix(goStripABISuffix(symbol), "·") }
+	context := llvm.NewContext()
+	defer context.Dispose()
+	if api == "Go" {
+		translated, err := translateGoModuleInContext(context, pkg, []byte(source), GoModuleOptions{
+			GOARCH: arch, TargetTriple: triple, ResolveSym: resolve, X87Mode: mode,
+		})
+		if translated != nil && !translated.Module.IsNil() {
+			defer translated.Module.Dispose()
+			return translated.Module.String(), err
+		}
+		return "", err
+	}
+	file, err := Parse(ArchAMD64, source)
+	if err != nil {
+		return "", err
+	}
+	sigs, err := goSigsForAsmFile(pkg, file, resolve, arch, nil, nil, nil)
+	if err != nil {
+		return "", err
+	}
+	options := Options{Goarch: arch, TargetTriple: triple, ResolveSym: resolve, Sigs: sigs, X87Mode: mode}
+	if api == "text" {
+		return Translate(file, options)
+	}
+	if api != "module" {
+		t.Fatal("unknown initialized-word API", api)
+	}
+	module, err := TranslateModuleInContext(context, file, options)
+	if !module.IsNil() {
+		defer module.Dispose()
+		return module.String(), err
+	}
+	return "", err
+}
+
+func x86X87InitializedWordValue(t *testing.T, ir string, expected uint64) {
+	t.Helper()
+	for index, input := range []uint16{0, 0xffff, 0x5a5a} {
+		name := fmt.Sprintf("WordProbe%d", index)
+		probe := fmt.Sprintf("\ndefine i16 @%s() {\n %%r = call i16 @Value(i16 %d)\n ret i16 %%r\n}\n", name, input)
+		// Exact logical LLVM values, not hardware FP80, rounding, trapping,
+		// original Go execution or a native ABI conformance claim.
+		x86ScalarFPNamedConstantResult(t, ir+probe, name, []uint64{expected})
+	}
+}
+
+func TestX86X87InitializedWordsUseExistingNaturalStorageThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		result := 8
+		if target.arch == "386" {
+			result = 4
+		}
+		for _, op := range []string{"FSTCW", "FSTSW"} {
+			kinds := []string{"param", "result"}
+			if op == "FSTSW" {
+				kinds = append(kinds, "AX")
+			}
+			for _, kind := range kinds {
+				body := "FINIT\n"
+				switch kind {
+				case "param":
+					body += op + " input+0(FP)\nMOVW input+0(FP),AX\n"
+					body += fmt.Sprintf("MOVW AX,ret+%d(FP)\n", result)
+				case "result":
+					body += fmt.Sprintf("%s ret+%d(FP)\n", op, result)
+				case "AX":
+					body += fmt.Sprintf("FSTSW AX\nMOVW AX,ret+%d(FP)\n", result)
+				}
+				declaration := "func Value(input uint16) uint16"
+				_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body+"RET")
+				for _, mode := range []X87Mode{X87Auto, X87Software} {
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(fmt.Sprintf("%s/%s/%s/mode%d/%s", target.triple, op, kind, mode, api), func(t *testing.T) {
+							ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, api, mode)
+							if err != nil || ir == "" {
+								t.Fatal("explicit initialization lost the complete existing word-store role", err)
+							}
+							want := uint64(0)
+							if op == "FSTCW" {
+								want = 0x037f
+								if !strings.Contains(ir, "i16 895") {
+									t.Fatal("explicit default control-word producer missing from actual IR")
+								}
+							}
+							if mode == X87Software || op == "FSTSW" {
+								x86X87InitializedWordValue(t, ir, want)
+							} else if !strings.Contains(ir, `asm sideeffect "fninit"`) ||
+								!strings.Contains(ir, `asm sideeffect "fnstcw $0"`) {
+								t.Fatal("hardware control-word path lost its real initialize/read operations")
+							}
+							// A hardware FNSTCW result is opaque to LLVM O2. The
+							// original object/runtime owner, not constant folding,
+							// independently checks that path's expected 0x037f.
+						})
+					}
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87ClearOnlyDefinesItsArchitecturalStatusBits(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, prefix, mask, suffix string }{
+			{"entry-cleared-bits", "FCLEX\n", "0x80ff", ""},
+			{"initialized-full-word", "FINIT\nFCLEX\n", "0xffff", ""},
+			{"compare-conditions", "FLD1\nFTST\nFCLEX\n", "0x4500", "FMOVDP F0,F0\n"},
+		} {
+			result := 8
+			if target.arch == "386" {
+				result = 4
+			}
+			body := row.prefix + "FSTSW AX\nANDW $" + row.mask + ",AX\n" +
+				fmt.Sprintf("MOVW AX,ret+%d(FP)\n", result) + row.suffix + "RET"
+			declaration := "func Value(input uint16) uint16"
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, body)
+			for _, mode := range []X87Mode{X87Auto, X87Software} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, row.name, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, api, mode)
+						if err != nil || ir == "" {
+							t.Fatal("known cleared bits require an independent status-bit proof", err)
+						}
+						x86X87InitializedWordValue(t, ir, 0)
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87WordInitializationCannotBorrowUnknownOrForeignRoles(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, declaration, body string }{
+			// Deliberately no extra GP/FP probe: these exact stores must not
+			// publish the implementation alloca's initial status/control word.
+			{"entry-control", "func Value() uint16", "FSTCW ret+0(FP)\nRET"},
+			{"entry-status", "func Value() uint16", "FSTSW ret+0(FP)\nRET"},
+			{"cleared-partial-status", "func Value() uint16", "FCLEX\nFSTSW ret+0(FP)\nRET"},
+			{"compare-partial-status", "func Value() uint16", "FLD1\nFTST\nFSTSW ret+0(FP)\nFMOVDP F0,F0\nRET"},
+			{"clear-does-not-define-conditions", "func Value() uint16", "FCLEX\nFSTSW AX\nANDW $0x4500,AX\nMOVW AX,ret+0(FP)\nRET"},
+			{"control-load-is-not-environment-authority", "func Value(input uint16) uint16", "FLDCW input+0(FP)\nFSTCW ret+RESULT(FP)\nRET"},
+			{"initialized-unknown-F0", "func Value(gate uint64) float64", "MOVL gate+4(FP),AX\nFINIT\nFMOVDP F0,ret+8(FP)\nRET"},
+			{"initialized-unknown-F1", "func Value() uint16", "FINIT\nFLD1\nFADDD F1,F0\nFSTCW ret+0(FP)\nFMOVDP F0,F0\nRET"},
+			{"partial-result", "func Value() uint32", "FINIT\nFSTCW ret+0(FP)\nRET"},
+			{"parameter-padding", "func Value(input byte) uint16", "FINIT\nFSTCW input+0(FP)\nMOVW $0,ret+RESULT(FP)\nRET"},
+			{"partial-parameter", "func Value(input uint32) uint16", "FINIT\nFSTCW input+0(FP)\nMOVW $0,ret+RESULT(FP)\nRET"},
+			{"interior-parameter", "func Value(input uint32) uint16", "FINIT\nFSTCW input+1(FP)\nMOVW $0,ret+RESULT(FP)\nRET"},
+			{"cross-parameter", "func Value(a,b byte) uint16", "FINIT\nFSTCW a+0(FP)\nMOVW $0,ret+RESULT(FP)\nRET"},
+			{"pointer-parameter", "func Value(input *byte) uint16", "FINIT\nFSTCW input+0(FP)\nMOVW $0,ret+RESULT(FP)\nRET"},
+		} {
+			result := "8"
+			if target.arch == "386" {
+				result = "4"
+			}
+			body := strings.ReplaceAll(row.body, "RESULT", result)
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, row.declaration, body)
+			for _, mode := range []X87Mode{X87Auto, X87Software} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, row.name, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, row.declaration, target.arch, target.triple, api, mode)
+						// A hardware FNSTCW reads an actual complete word, not the
+						// private alloca's default. A typed FLDCW input likewise
+						// writes known control bytes in either mode. Neither fact
+						// supplies x87 values, Tag/TOP or an environment extent.
+						if row.name == "entry-control" && mode != X87Software || row.name == "control-load-is-not-environment-authority" {
+							if err != nil || ir == "" {
+								t.Fatal("existing defined control-word path was rejected", err)
+							}
+							if mode != X87Software {
+								x86X87HardwareWordRead(t, ir, 1)
+							} else {
+								x86X87SoftwareControlRoundTrip(t, ir)
+							}
+							return
+						}
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("unknown/foreign word state became NUM: output=%t error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_integer_effects_test.go b/x86_x87_integer_effects_test.go
new file mode 100644
index 000000000..df9e2705f
--- /dev/null
+++ b/x86_x87_integer_effects_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestX86X87IntegerRoundCompleteTypedRows(t *testing.T) {
+	// Independent nine Go encoder directions, not derived from the effect map.
+	rows := []struct {
+		op         string
+		width      int64
+		load, push bool
+		pop        uint8
+	}{
+		{"FMOVW", 2, true, true, 0}, {"FMOVW", 2, false, false, 0},
+		{"FMOVWP", 2, false, false, 1},
+		{"FMOVL", 4, true, true, 0}, {"FMOVL", 4, false, false, 0},
+		{"FMOVLP", 4, false, false, 1},
+		{"FMOVV", 8, true, true, 0}, {"FMOVVP", 8, false, false, 1},
+		{"FRNDINT", 0, false, false, 0},
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for rowIndex, row := range rows {
+			memory := []string{"(AX)", "-7(BX)(CX*4)", "value+0(FP)", "local-8(SP)", "·value(SB)"}
+			if row.width == 0 {
+				memory = []string{""}
+			}
+			for _, operand := range memory {
+				source := row.op
+				index := 1
+				if row.width != 0 {
+					if row.load {
+						source += " " + operand + ",F0"
+						index = 0
+					} else {
+						source += " F0," + operand
+					}
+				}
+				t.Run(fmt.Sprintf("%s/row%d/%s", arch, rowIndex, source), func(t *testing.T) {
+					ins := x86X87ValueInstruction(t, source)
+					form, known, err := x86X87ValueProperties(ins, arch)
+					if !known || err != nil || form.memoryBytes() != row.width || form.push != row.push || form.spec.pop != row.pop {
+						t.Fatal("complete integer/round direction lost its width, push or pop", known, err, form)
+					}
+					if operand == "value+0(FP)" {
+						width, write, known := X86FPAccessBytes(ins, index, arch)
+						if !known || width != row.width || write == row.load {
+							t.Fatal("FP observation diverged from the complete typed row", width, write, known)
+						}
+					}
+				})
+			}
+		}
+		for _, source := range []string{
+			"FMOVW value+0(FP),F1", "FMOVW F1,value+0(FP)", "FMOVW F0,F1",
+			"FMOVL value+0(FP),F1", "FMOVL F1,value+0(FP)", "FMOVL F0,F1",
+			"FMOVV F0,value+0(FP)", "FMOVVP value+0(FP),F0",
+			"FMOVWP value+0(FP),F0", "FMOVLP value+0(FP),F0",
+			"FMOVW $1,F0", "FMOVL $(1.0),F0", "FMOVV AX,F0",
+			"FRNDINT F0", "FMOVWP", "FMOVV.Z value+0(FP),F0",
+		} {
+			t.Run(arch+"/invalid/"+source, func(t *testing.T) {
+				ins := x86X87ValueInstruction(t, source)
+				if _, known, err := x86X87ValueProperties(ins, arch); !known || err == nil {
+					t.Fatal("malformed/nonexistent integer row was accepted", known, err)
+				}
+				for index := range ins.Args {
+					if width, _, known := X86FPAccessBytes(ins, index, arch); known || width != 0 {
+						t.Fatal("rejected integer row leaked a width observation", width, known)
+					}
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87IntegerRoundWholeResultObligationHasNoStoreProbe(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, source := range []string{
+			"FMOVW input+0(FP),F0", "FMOVW F0,input+0(FP)", "FMOVWP F0,input+0(FP)",
+			"FMOVL input+0(FP),F0", "FMOVL F0,input+0(FP)", "FMOVLP F0,input+0(FP)",
+			"FMOVV input+0(FP),F0", "FMOVVP F0,input+0(FP)", "FRNDINT",
+		} {
+			t.Run(arch+"/"+source, func(t *testing.T) {
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(input uint64) uint64", source+"\nRET")
+				if !x86TypedFPResultNeedsProof(file.Funcs[0], sig, arch) {
+					t.Fatal("integer/round family evaded its result obligation without a result store")
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_integer_input_obligation_test.go b/x86_x87_integer_input_obligation_test.go
new file mode 100644
index 000000000..4937b68a5
--- /dev/null
+++ b/x86_x87_integer_input_obligation_test.go
@@ -0,0 +1,190 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86X87IntegerInputRow struct {
+	name, instruction, inputType string
+	load, pop                    bool
+}
+
+// Independent complete nine directions. The initializer and scratch are source
+// text, not synthesized initial F0/CW facts or a new source/storage producer.
+var x86X87IntegerInputRows = []x86X87IntegerInputRow{
+	{"load-W", "FMOVW input+0(FP),F0", "int16", true, false},
+	{"store-W", "FMOVW F0,converted-8(SP)", "int64", false, false},
+	{"store-WP", "FMOVWP F0,converted-8(SP)", "int64", false, true},
+	{"load-L", "FMOVL input+0(FP),F0", "int32", true, false},
+	{"store-L", "FMOVL F0,converted-8(SP)", "int64", false, false},
+	{"store-LP", "FMOVLP F0,converted-8(SP)", "int64", false, true},
+	{"load-V", "FMOVV input+0(FP),F0", "int64", true, false},
+	{"store-VP", "FMOVVP F0,converted-8(SP)", "int64", false, true},
+	{"round", "FRNDINT", "float64", false, false},
+}
+
+type x86X87IntegerInputCase struct {
+	name, body string
+	good       bool
+}
+
+func x86X87IntegerInputCases(row x86X87IntegerInputRow) []x86X87IntegerInputCase {
+	preload, discard := "FLD1\n", "FMOVDP F0,F0\n"
+	if row.load {
+		preload = ""
+	}
+	if row.pop {
+		discard = ""
+	}
+	core := preload + row.instruction + "\n" + discard
+	unknownAUTO := "FINIT\nFMOVD unread-16(SP),F0\n" + row.instruction + "\n" + discard
+	bareSP := "FINIT\nMOVL $0,-16(SP)\nMOVL $0,-12(SP)\nFMOVD -16(SP),F0\n" + row.instruction + "\n" + discard
+	if row.load {
+		unknownAUTO = "FINIT\n" + strings.Replace(row.instruction, "input+0(FP)", "unread-16(SP)", 1) + "\n" + discard
+		bareSP = "FINIT\nMOVL $0,-16(SP)\nMOVL $0,-12(SP)\n" +
+			strings.Replace(row.instruction, "input+0(FP)", "-16(SP)", 1) + "\n" + discard
+	}
+	cases := []x86X87IntegerInputCase{
+		{"initialized-balanced", "FINIT\n" + core, true},
+		{"uninitialized-named-AUTO", unknownAUTO, false},
+		{"bare-SP-not-AUTO", bareSP, false},
+		// FINIT after the conversion empties the stack, so this negative
+		// cannot be explained only by an unbalanced stack at RET. The ninth
+		// independently authored push is itself outside the value domain.
+		{"ninth-push", "FINIT\n" + strings.Repeat("FLD1\n", 9) + core + "FINIT\n", false},
+	}
+	if !row.load {
+		cases = append(cases,
+			x86X87IntegerInputCase{"unknown-F0", "FINIT\n" + row.instruction + "\n" + discard, false},
+			// A fractional value makes RC an actual input. This does not
+			// depend on a default virtual CW, integer-load range or a private
+			// alloca's initial contents. Only Software is tested here.
+			x86X87IntegerInputCase{"unknown-CW", "FMOVD $(2.5),F0\n" + row.instruction + "\n" + discard, false},
+		)
+	}
+	return cases
+}
+
+func x86X87IntegerInputSource(t *testing.T, arch, declaration, body string, independentAUTO bool, resultWrite string) string {
+	t.Helper()
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+	var extent int64
+	for _, slots := range [][]FrameSlot{sig.Frame.Params, sig.Frame.Results} {
+		for _, slot := range slots {
+			end := slot.Offset + x86FrameScalarBytes(slot.Type, arch)
+			if end > extent {
+				extent = end
+			}
+		}
+	}
+	if len(sig.Frame.Results) == 0 {
+		if sig.Ret != Void || resultWrite != "" {
+			t.Fatal("Void fixture acquired a fabricated result slot or store")
+		}
+	} else {
+		if sig.Ret != I32 || len(sig.Frame.Results) != 1 || sig.Frame.Results[0].Type != I32 {
+			t.Fatal("independent result fixture lost its actual I32 declaration", sig)
+		}
+		destination := fmt.Sprintf("ret+%d(FP)", sig.Frame.Results[0].Offset)
+		switch resultWrite {
+		case "complete":
+			if independentAUTO {
+				body += "MOVL $7,result-4(SP)\nMOVL result-4(SP),AX\nMOVL AX," + destination + "\n"
+			} else {
+				body += "MOVL $7," + destination + "\n"
+			}
+		case "partial":
+			body += "MOVW $7," + destination + "\n"
+		case "missing":
+		default:
+			t.Fatal("unknown result boundary", resultWrite)
+		}
+	}
+	source := fmt.Sprintf("TEXT ·Value(SB),4,$16-%d\n%sRET\n", extent, body)
+	file, err := Parse(ArchAMD64, source)
+	if err != nil || len(file.Funcs) != 1 || file.Funcs[0].FrameSize != 16 || file.Funcs[0].ArgSize != extent {
+		t.Fatal("whole input-obligation fixture lost its complete original source/header", err)
+	}
+	return source
+}
+
+func x86X87CheckIntegerInputCase(t *testing.T, source, declaration, arch, triple, api string, good bool) {
+	t.Helper()
+	ir, err := x86X87InitializedWordAPI(t, source, declaration, arch, triple, api, X87Software)
+	if good {
+		if err != nil || ir == "" {
+			t.Fatal("initialized/balanced source did not retain its old independent storage role", err)
+		}
+	} else if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+		t.Fatalf("integer/round source obligation was bypassed: output=%t error=%v\ncomplete source:\n%s", ir != "", err, source)
+	} else {
+		t.Logf("actual first Context (not an inferred later boundary): %v", err)
+	}
+}
+
+func TestX86X87IntegerRoundVoidInputsNeedWholeProof(t *testing.T) {
+	if len(x86X87IntegerInputRows) != 9 {
+		t.Fatal("complete seven-name/nine-direction input denominator changed")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, profile := range []struct{ name, declarationFormat string }{
+			{"Void", "func Value(input %s)"},
+			{"Void-unused-bool", "func Value(input %s,gate bool)"},
+		} {
+			for _, row := range x86X87IntegerInputRows {
+				declaration := fmt.Sprintf(profile.declarationFormat, row.inputType)
+				for _, test := range x86X87IntegerInputCases(row) {
+					source := x86X87IntegerInputSource(t, target.arch, declaration, test.body, false, "")
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+profile.name+"/"+row.name+"/"+test.name+"/"+api, func(t *testing.T) {
+							x86X87CheckIntegerInputCase(t, source, declaration, target.arch, target.triple, api, test.good)
+						})
+					}
+				}
+			}
+		}
+	}
+	// Source/effect observation only: no backend, native execution or permission
+	// to use an incoming native pointer or write caller storage is supplied.
+}
+
+func TestX86X87IntegerRoundIndependentStorageCannotBypassInputs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, profile := range []struct {
+			name, declarationFormat string
+			independentAUTO         bool
+		}{
+			{"natural-I32-result", "func Value(input %s) uint32", false},
+			{"unused-bool-and-AUTO-result", "func Value(input %s,gate bool) uint32", true},
+		} {
+			for _, row := range x86X87IntegerInputRows {
+				declaration := fmt.Sprintf(profile.declarationFormat, row.inputType)
+				cases := x86X87IntegerInputCases(row)
+				// Result stores are independently complete for every input
+				// negative above. These two controls instead hold all inputs
+				// valid and remove only the result's required initialized bytes.
+				cases = append(cases,
+					x86X87IntegerInputCase{"missing-result", cases[0].body, false},
+					x86X87IntegerInputCase{"partial-result", cases[0].body, false},
+				)
+				for _, test := range cases {
+					resultWrite := "complete"
+					if test.name == "missing-result" {
+						resultWrite = "missing"
+					} else if test.name == "partial-result" {
+						resultWrite = "partial"
+					}
+					source := x86X87IntegerInputSource(t, target.arch, declaration, test.body, profile.independentAUTO, resultWrite)
+					for _, api := range []string{"text", "module", "Go"} {
+						t.Run(target.triple+"/"+profile.name+"/"+row.name+"/"+test.name+"/"+api, func(t *testing.T) {
+							x86X87CheckIntegerInputCase(t, source, declaration, target.arch, target.triple, api, test.good)
+						})
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_integer_rounding_go_test.go b/x86_x87_integer_rounding_go_test.go
new file mode 100644
index 000000000..9fefa6600
--- /dev/null
+++ b/x86_x87_integer_rounding_go_test.go
@@ -0,0 +1,93 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86X87IntegerRoundingCompleteGoRowsAndBytes(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{
+		"var yfmvf = []ytab{\n\t{Zm_o, 2, argList{Ym, Yf0}},\n\t{Zo_m, 2, argList{Yf0, Ym}},\n}",
+		"var yfmvx = []ytab{\n\t{Zm_o, 2, argList{Ym, Yf0}},\n}",
+		"var yfmvp = []ytab{\n\t{Zo_m, 2, argList{Yf0, Ym}},\n}",
+		"var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}",
+		"{AFMOVW, yfmvf, Px, opBytes{0xdf, 00, 0xdf, 02}}",
+		"{AFMOVWP, yfmvp, Px, opBytes{0xdf, 03}}",
+		"{AFMOVL, yfmvf, Px, opBytes{0xdb, 00, 0xdb, 02}}",
+		"{AFMOVLP, yfmvp, Px, opBytes{0xdb, 03}}",
+		"{AFMOVV, yfmvx, Px, opBytes{0xdf, 05}}",
+		"{AFMOVVP, yfmvp, Px, opBytes{0xdf, 07}}",
+		"{AFRNDINT, ynone, Px, opBytes{0xd9, 0xfc}}",
+	} {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("actual selected complete integer-rounding Go row changed", row)
+		}
+	}
+	// Nine actual rows, not a generated view of a future effect descriptor.
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			op         string
+			first, ext byte
+			load       bool
+		}{
+			{"FMOVW", 0xdf, 0, true}, {"FMOVW", 0xdf, 2, false},
+			{"FMOVWP", 0xdf, 3, false},
+			{"FMOVL", 0xdb, 0, true}, {"FMOVL", 0xdb, 2, false},
+			{"FMOVLP", 0xdb, 3, false},
+			{"FMOVV", 0xdf, 5, true}, {"FMOVVP", 0xdf, 7, false},
+		} {
+			instruction := func(memory string) string {
+				if row.load {
+					return row.op + " " + memory + ",F0"
+				}
+				return row.op + " F0," + memory
+			}
+			for _, memory := range []string{"(AX)", "-7(BX)(CX*4)"} {
+				text := instruction(memory)
+				t.Run(arch+"/bytes/"+text, func(t *testing.T) {
+					want := []byte{row.first, row.ext << 3, 0xc3}
+					if memory != "(AX)" {
+						want = []byte{row.first, 0x44 | row.ext<<3, 0x8b, 0xf9, 0xc3}
+					}
+					got := x86OrderingHintGoBytes(t, arch, "TEXT probe(SB),4,$0-0\n"+text+"\nRET\n")
+					if !bytes.Equal(got, want) {
+						t.Fatalf("actual Go integer row=%x, independent expected=%x", got, want)
+					}
+				})
+			}
+			for _, memory := range []string{"value+0(FP)", "value-8(SP)"} {
+				text := instruction(memory)
+				t.Run(arch+"/pseudo-memory/"+text, func(t *testing.T) {
+					// This original object validates Go format only, not native
+					// storage ownership or a callable/initialized x87 entry.
+					goAssemblerOracleOutput(t, arch, "TEXT probe(SB),4,$16-32\n"+text+"\nRET\n", "", true)
+				})
+			}
+		}
+		t.Run(arch+"/bytes/FRNDINT", func(t *testing.T) {
+			got := x86OrderingHintGoBytes(t, arch, "TEXT probe(SB),4,$0-0\nFRNDINT\nRET\n")
+			if !bytes.Equal(got, []byte{0xd9, 0xfc, 0xc3}) {
+				t.Fatalf("actual Go no-operand rounding=%x", got)
+			}
+		})
+		for _, source := range []string{
+			"FMOVW (AX),F1", "FMOVW F1,(AX)", "FMOVW F0,F1",
+			"FMOVL (AX),F1", "FMOVL F1,(AX)", "FMOVL F0,F1",
+			"FMOVV F0,(AX)", "FMOVVP (AX),F0", "FMOVWP (AX),F0", "FMOVLP (AX),F0",
+			"FMOVW $1,F0", "FMOVV AX,F0", "FRNDINT F0", "FMOVWP", "FMOVV.Z (AX),F0",
+		} {
+			t.Run(fmt.Sprintf("%s/Go-rejects/%s", arch, source), func(t *testing.T) {
+				goAssemblerOracleOutput(t, arch, "TEXT probe(SB),4,$0-0\n"+source+"\nRET\n", "", false)
+			})
+		}
+	}
+}
diff --git a/x86_x87_integer_rounding_linux_amd64_test.go b/x86_x87_integer_rounding_linux_amd64_test.go
new file mode 100644
index 000000000..f9359d095
--- /dev/null
+++ b/x86_x87_integer_rounding_linux_amd64_test.go
@@ -0,0 +1,212 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// A mandatory actual-Linux owner, not a portable test with a host skip.
+// Both ISAs use direct execution; missing tools or i386 compatibility fail.
+func TestCrossLinuxRuntimeMatrixX86X87SignedI64IdentityOriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, clang, found := findLlcAndClang(t)
+	compiler386, compilerErr := exec.LookPath("i686-linux-gnu-gcc")
+	if !found || compilerErr != nil {
+		t.Fatal("native x87 I64 identity requires LLVM22 and static i686 toolchain", compilerErr)
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		t.Run(arch, func(t *testing.T) {
+			execution := x86FloatCompareExecution{llc: llc, triple: "x86_64-unknown-linux-gnu",
+				compiler: []string{clang, "-target", "x86_64-unknown-linux-gnu"}}
+			stack := "movq %%rsp,%0"
+			if arch == "386" {
+				execution.triple = "i386-unknown-linux-gnu"
+				execution.compiler = []string{compiler386, "-static", "-no-pie", "-maccumulate-outgoing-args"}
+				stack = "movl %%esp,%0"
+			}
+			x86X87RunSignedI64Identity(t, arch, stack, execution)
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+func x86X87RunSignedI64Identity(t *testing.T, arch, stack string, execution x86FloatCompareExecution) {
+	t.Helper()
+	if len(execution.prefix) != 0 || execution.preserveArgv0 {
+		t.Fatal("mandatory original/LLVM identity owner requires direct native transport")
+	}
+	var goInputs strings.Builder
+	for _, value := range x86X87SignedI64IdentityInputs {
+		fmt.Fprintf(&goInputs, "0x%x,\n", uint64(value))
+	}
+	originalDriver := `package main
+import "fmt"
+` + x86X87SignedI64IdentityDeclaration + `
+func main() {
+    inputs := []uint64{` + goInputs.String() + `}
+    for _, input := range inputs {
+        value := Value(int64(input))
+        if uint64(value) != input {
+            panic(fmt.Sprintf("original Go I64 identity input=%016x got=%016x", input, uint64(value)))
+        }
+        fmt.Printf("%016x\n", uint64(value))
+    }
+}
+`
+	formatted, err := format.Source([]byte(originalDriver))
+	if err != nil {
+		t.Fatal("actual Go integer oracle driver is malformed", err)
+	}
+	dir := t.TempDir()
+	sources := map[string]string{
+		"go.mod":  "module x87identity\n\ngo 1.20\n",
+		"main.go": string(formatted), "identity_" + arch + ".s": x86X87SignedI64IdentitySource,
+	}
+	for name, source := range sources {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(source), 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("original complete input=%s sha256=%x", name, sha256.Sum256([]byte(source)))
+	}
+	driver, driverHash := x86LEAActualSDKDriver(t)
+	original := filepath.Join(dir, "original")
+	command := exec.Command(driver, "build", "-p=1", "-o", original, ".")
+	command.Dir = dir
+	command.Env = append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOOS=linux", "GOARCH="+arch, "CGO_ENABLED=0", "GOFLAGS=", "GOMAXPROCS=2")
+	x86FloatCompareCaptureCommand(t, command)
+	verifySource := func() {
+		for name, source := range sources {
+			actual, err := os.ReadFile(filepath.Join(dir, name))
+			if err != nil || string(actual) != source {
+				t.Fatal("complete original identity source changed", name, err)
+			}
+		}
+		if actual, hash := x86LEAActualSDKDriver(t); actual != driver || hash != driverHash {
+			t.Fatal("original compiler driver changed around observation")
+		}
+	}
+	run := func(executable string, args ...string) []byte {
+		if arch == "amd64" {
+			return execution.run(t, executable, args...)
+		}
+		sealed, err := x87IA32StaticExecutable(executable)
+		if err != nil {
+			t.Fatal("original/LLVM i386 execution needs its complete static ELF", err)
+		}
+		return x87IA32RunDirect(t, sealed, args, os.Environ())
+	}
+	verifySource()
+	records := run(original)
+	var expected strings.Builder
+	for _, value := range x86X87SignedI64IdentityInputs {
+		fmt.Fprintf(&expected, "%016x\n", uint64(value))
+	}
+	if string(records) != expected.String() {
+		t.Fatalf("actual original Go did not execute the complete exact I64 inventory: %s", records)
+	}
+	reference := filepath.Join(dir, "original.records")
+	if err := os.WriteFile(reference, records, 0600); err != nil {
+		t.Fatal(err)
+	}
+	verifyRecords := func() {
+		actual, err := os.ReadFile(reference)
+		if err != nil || string(actual) != string(records) {
+			t.Fatal("original identity records changed around LLVM execution", err)
+		}
+	}
+	want := fmt.Sprintf("x87 I64 original-Go/LLVM identity checks=%d\n", len(x86X87SignedI64IdentityInputs))
+	for _, api := range []string{"text", "module", "Go"} {
+		ir, err := x86X87InitializedWordAPI(t, x86X87SignedI64IdentitySource,
+			x86X87SignedI64IdentityDeclaration, arch, execution.triple, api, X87Hardware)
+		if err != nil || ir == "" {
+			t.Fatal("complete hardware integer identity did not translate", err)
+		}
+		// The output-array canaries below test this explicit observer's
+		// boundary, not the original Go caller's ABI0 outgoing stack slots.
+		ir += `
+define void @ObserveIdentity(ptr %output, i64 %input) {
+entry:
+  %value = call i64 @Value(i64 %input)
+  %middle = getelementptr i64, ptr %output, i32 1
+  store i64 %value, ptr %middle, align 1
+  ret void
+}
+`
+		for _, optimized := range []bool{false, true} {
+			input := ir
+			if optimized {
+				input = x86MulDivRoundOptimize(t, input)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				t.Run(fmt.Sprintf("%s/IR_O2=%t/backend%s", api, optimized, level), func(t *testing.T) {
+					executable := execution.compileLLVM(t, "x87-i64", input, x86X87I64NativeDriver(stack), level)
+					verifySource()
+					verifyRecords()
+					if actual := run(executable, reference); string(actual) != want {
+						t.Fatal("original Go/LLVM full-bit identity or explicit observer/SP boundary mismatch", string(actual))
+					}
+					verifyRecords()
+					verifySource()
+				})
+			}
+		}
+	}
+	verifyRecords()
+	verifySource()
+}
+
+func x86X87I64NativeDriver(stack string) string {
+	return `#include <stdint.h>
+#include <stdio.h>
+
+extern void ObserveIdentity(uint64_t *, int64_t);
+
+static __attribute__((always_inline)) inline uintptr_t stack_pointer(void) {
+    uintptr_t value;
+    __asm__ volatile("` + stack + `" : "=r"(value) : : "memory");
+    return value;
+}
+
+int main(int argc, char **argv) {
+    if (argc != 2)
+        return 1;
+    FILE *reference = fopen(argv[1], "r");
+    if (!reference)
+        return 2;
+
+    unsigned checks = 0;
+    unsigned long long expected;
+    while (fscanf(reference, "%llx", &expected) == 1) {
+        const uint64_t left = UINT64_C(0x1122334455667788),
+            right = UINT64_C(0x8877665544332211);
+        volatile uint64_t output[] = {left, 0, right};
+        const uintptr_t before = stack_pointer();
+        ObserveIdentity((uint64_t *)output, (int64_t)(uint64_t)expected);
+        const uintptr_t after = stack_pointer();
+        if (output[0] != left || output[2] != right || output[1] != (uint64_t)expected || before != after) {
+            fprintf(stderr, "x87 I64 input=%016llx got=%016llx SP=%llx/%llx or explicit observer boundary changed\n",
+                expected, (unsigned long long)output[1],
+                (unsigned long long)before, (unsigned long long)after);
+            fclose(reference);
+            return 3;
+        }
+        checks++;
+    }
+    const int complete = feof(reference);
+    const int close_result = fclose(reference);
+    if (!complete || close_result)
+        return 4;
+    printf("x87 I64 original-Go/LLVM identity checks=%u\n", checks);
+    return 0;
+}
+`
+}
diff --git a/x86_x87_integer_rounding_test.go b/x86_x87_integer_rounding_test.go
new file mode 100644
index 000000000..bc4322c66
--- /dev/null
+++ b/x86_x87_integer_rounding_test.go
@@ -0,0 +1,283 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+const x86X87SignedI64IdentitySource = "TEXT ·Value(SB),4,$0-16\nFMOVV input+0(FP),F0\nFMOVVP F0,ret+8(FP)\nRET\n"
+const x86X87SignedI64IdentityDeclaration = "func Value(input int64) int64"
+
+// Every signed I64 is exactly representable by the original x87 integer
+// load/store pair. Its identity does not depend on the ambient RC selection.
+// There is deliberately no word opcode to turn a lost-bit regression into
+// an unrelated source-proof failure.
+var x86X87SignedI64IdentityInputs = []int64{
+	0, 1, -1,
+	1<<53 - 1, 1 << 53, 1<<53 + 1, -(1<<53 + 1),
+	1<<63 - 1, -1 << 63,
+	0x5555555555555555, -0x5555555555555555,
+}
+
+func TestX86X87SignedI64IdentityFixtureHasNoWordProbe(t *testing.T) {
+	file, err := Parse(ArchAMD64, x86X87SignedI64IdentitySource)
+	if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 4 {
+		t.Fatal("integer identity source must retain exactly its complete original body", err)
+	}
+	fn := file.Funcs[0]
+	if fn.FrameSize != 0 || fn.ArgSize != 16 || fn.Instrs[1].Op != "FMOVV" ||
+		fn.Instrs[2].Op != "FMOVVP" || fn.Instrs[3].Op != OpRET {
+		t.Fatal("identity source acquired an unrelated instruction/storage probe")
+	}
+	for _, ins := range fn.Instrs {
+		if _, word, _ := x86X87WordProperties(ins, "amd64"); word {
+			t.Fatal("word obligation cannot replace the numerical precision counterexample")
+		}
+	}
+	for _, target := range x86RawReturnTargets {
+		_, _, sig, _ := x86ResultInitializationFixture(t, target.arch,
+			x86X87SignedI64IdentityDeclaration, "NOP\nRET")
+		if len(sig.Frame.Params) != 1 || len(sig.Frame.Results) != 1 ||
+			sig.Frame.Params[0].Offset != 0 || sig.Frame.Params[0].Type != I64 ||
+			sig.Frame.Results[0].Offset != 8 || sig.Frame.Results[0].Type != I64 {
+			t.Fatal("actual typed integer identity layout changed", target.arch, sig.Frame)
+		}
+	}
+}
+
+func x86X87InlineActualValue(t *testing.T, ir, parameter string, resultBits int) string {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal("actual translated identity IR is malformed", err)
+	}
+	function := module.NamedFunction("Value")
+	if function.IsNil() || function.ParamsCount() != 1 || function.Param(0).Type().String() != parameter ||
+		function.GlobalValueType().ReturnType().TypeKind() != llvm.IntegerTypeKind ||
+		function.GlobalValueType().ReturnType().IntTypeWidth() != resultBits {
+		t.Fatal("constant observer lost the actual translated parameter/result types")
+	}
+	// This test-only optimization request changes neither the source body nor
+	// its signature. It ensures the observer checks the real translated call,
+	// not the optimizer's heuristic decision about a large software helper.
+	function.AddFunctionAttr(context.CreateEnumAttribute(llvm.AttributeKindID("alwaysinline"), 0))
+	return module.String()
+}
+
+func TestX86X87SignedI64IdentityRetainsAllBitsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, api := range []string{"text", "module", "Go"} {
+			t.Run(target.triple+"/"+api, func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, x86X87SignedI64IdentitySource,
+					x86X87SignedI64IdentityDeclaration, target.arch, target.triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("complete original integer identity did not reach its numerical consumer", err)
+				}
+				for _, input := range x86X87SignedI64IdentityInputs {
+					t.Run(fmt.Sprintf("input=%016x", uint64(input)), func(t *testing.T) {
+						probe := x86X87InlineActualValue(t, ir, "i64", 64) +
+							fmt.Sprintf("\ndefine i64 @IdentityProbe() {\n %%r = call i64 @Value(i64 %d)\n ret i64 %%r\n}\n", input)
+						x86ScalarFPNamedConstantResult(t, probe, "IdentityProbe", []uint64{uint64(input)})
+					})
+				}
+			})
+		}
+	}
+	// This is LLVM O2 constant-state evidence on the local host, not execution
+	// of original Go opcodes or of the Auto/Hardware inline assembly.
+}
+
+func TestX86X87SoftwareRoundedIntegerBoundariesNeverBecomePoison(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.triple != "x86_64-unknown-linux-gnu" && target.triple != "i386-unknown-linux-gnu" {
+			continue // Full five-target direction grammar is independently tested above.
+		}
+		for _, row := range []struct {
+			op, typ string
+			bits    int
+		}{
+			{"FMOVW", "int16", 16},
+			{"FMOVWP", "int16", 16},
+			{"FMOVL", "int32", 32},
+			{"FMOVLP", "int32", 32},
+			{"FMOVVP", "int64", 64},
+		} {
+			lower, upper := -math.Ldexp(1, row.bits-1), math.Ldexp(1, row.bits-1)
+			below := lower - 1
+			if row.bits == 64 {
+				below = math.Nextafter(lower, math.Inf(-1))
+			}
+			values := []float64{0, math.Copysign(0, -1), 1.5, -1.5, 2.5, -2.5,
+				math.NaN(), math.Inf(1), math.Inf(-1), lower, upper, below, math.Nextafter(upper, 0)}
+			for mode := 0; mode < 4; mode++ {
+				declaration := "func Value(input float64) " + row.typ
+				body := fmt.Sprintf("MOVW $%d,control-2(SP)\nFLDCW control-2(SP)\nFMOVD input+0(FP),F0\n%s F0,ret+RESULT(FP)\n",
+					0x037f|mode<<10, row.op)
+				if !strings.HasSuffix(row.op, "P") {
+					// Keep the non-pop store's real direction and balance only
+					// afterwards; do not replace it with its popping sibling.
+					body += "FINIT\n"
+				}
+				source := x86X87IntegerRoundingSource(t, target.arch, declaration, body, 16)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/RC%d/%s", target.triple, row.op, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, api, X87Software)
+						if err != nil || ir == "" {
+							t.Fatal("source-defined masked CW did not reach integer conversion", err)
+						}
+						ir = x86X87InlineActualValue(t, ir, "double", row.bits)
+						for index, value := range values {
+							t.Run(fmt.Sprintf("sample%d=%016x", index, math.Float64bits(value)), func(t *testing.T) {
+								rounded := []func(float64) float64{math.RoundToEven, math.Floor, math.Ceil, math.Trunc}[mode](value)
+								want := uint64(1) << uint(row.bits-1) // Masked invalid: integer indefinite, not saturation.
+								if !math.IsNaN(rounded) && rounded >= lower && rounded < upper {
+									want = uint64(int64(rounded))
+									if row.bits < 64 {
+										want &= uint64(1)<<uint(row.bits) - 1
+									}
+								}
+								probe := fmt.Sprintf("\ndefine i%d @RoundProbe() {\n %%r = call i%d @Value(double 0x%016X)\n ret i%d %%r\n}\n",
+									row.bits, row.bits, math.Float64bits(value), row.bits)
+								x86ScalarFPNamedConstantResult(t, ir+probe, "RoundProbe", []uint64{want})
+							})
+						}
+					})
+				}
+			}
+		}
+	}
+	// FINIT plus an explicit known masked CW defines every control used here.
+	// No default Software environment or unmasked trap contract is inferred.
+}
+
+type x86X87IntegerRoundingCase struct {
+	name, declaration, body string
+}
+
+func x86X87IntegerRoundingCases() []x86X87IntegerRoundingCase {
+	var rows []x86X87IntegerRoundingCase
+	for _, width := range []struct {
+		name, typ string
+	}{{"W", "int16"}, {"L", "int32"}, {"V", "int64"}} {
+		load, pop := "FMOV"+width.name, "FMOV"+width.name+"P"
+		rows = append(rows, x86X87IntegerRoundingCase{
+			name: "load-" + load, declaration: fmt.Sprintf("func Value(input %s) %s", width.typ, width.typ),
+			body: load + " input+0(FP),F0\n" + pop + " F0,ret+RESULT(FP)\n",
+		})
+		rows = append(rows, x86X87IntegerRoundingCase{
+			name: "store-pop-" + pop, declaration: "func Value(input float64) " + width.typ,
+			body: "FMOVD input+0(FP),F0\n" + pop + " F0,ret+RESULT(FP)\n",
+		})
+		if width.name != "V" {
+			rows = append(rows, x86X87IntegerRoundingCase{
+				name: "store-nonpop-" + load, declaration: "func Value(input float64) " + width.typ,
+				body: "FMOVD input+0(FP),F0\n" + load + " F0,ret+RESULT(FP)\nFINIT\n",
+			})
+		}
+	}
+	return append(rows, x86X87IntegerRoundingCase{
+		name: "round-FRNDINT", declaration: "func Value(input float64) float64",
+		body: "FMOVD input+0(FP),F0\nFRNDINT\nFMOVDP F0,ret+RESULT(FP)\n",
+	})
+}
+
+func x86X87IntegerRoundingSource(t *testing.T, arch, declaration, body string, frame int) string {
+	t.Helper()
+	_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "NOP\nRET")
+	if len(sig.Frame.Results) != 1 {
+		t.Fatal("rounding fixture needs its actual single declared result")
+	}
+	body = strings.ReplaceAll(body, "RESULT", fmt.Sprint(sig.Frame.Results[0].Offset))
+	_, _, _, source := x86ResultInitializationFixture(t, arch, declaration, "FINIT\n"+body+"RET")
+	if frame != 0 {
+		source = strings.Replace(source, ",4,$0-", fmt.Sprintf(",4,$%d-", frame), 1)
+	}
+	return source
+}
+
+func TestX86X87IntegerRoundingCompleteDirectionsThreeAPIs(t *testing.T) {
+	rows := x86X87IntegerRoundingCases()
+	if len(rows) != 9 {
+		t.Fatal("complete seven-name, nine-direction denominator changed")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, row := range rows {
+			source := x86X87IntegerRoundingSource(t, target.arch, row.declaration, row.body, 0)
+			for _, mode := range []X87Mode{X87Auto, X87Hardware, X87Software} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, row.name, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, row.declaration, target.arch, target.triple, api, mode)
+						if err != nil || ir == "" {
+							t.Fatal("explicitly initialized complete integer-rounding row was rejected", err)
+						}
+					})
+				}
+			}
+		}
+	}
+	// All Software control-dependent cases start FINIT. This does not decide
+	// the separate API contract for an uninitialized virtual control word.
+}
+
+func TestX86X87IntegerRoundingBoundStorageAndStack(t *testing.T) {
+	rows := []struct {
+		name, declaration, body string
+		good                    bool
+	}{
+		{"AUTO-W", "func Value(input int16) int16", "MOVW input+0(FP),AX\nMOVW AX,cell-2(SP)\nFMOVW cell-2(SP),F0\nFMOVWP F0,ret+RESULT(FP)\n", true},
+		{"AUTO-L", "func Value(input int32) int32", "MOVL input+0(FP),AX\nMOVL AX,cell-4(SP)\nFMOVL cell-4(SP),F0\nFMOVLP F0,ret+RESULT(FP)\n", true},
+		{"AUTO-V", "func Value(input int64) int64", "MOVL input+0(FP),AX\nMOVL AX,cell-8(SP)\nMOVL input_hi+4(FP),AX\nMOVL AX,cell-4(SP)\nFMOVV cell-8(SP),F0\nFMOVVP F0,ret+RESULT(FP)\n", true},
+		{"AUTO-FRNDINT", "func Value(input float64) float64", "FMOVD input+0(FP),F0\nFMOVDP F0,cell-8(SP)\nFMOVD cell-8(SP),F0\nFRNDINT\nFMOVDP F0,ret+RESULT(FP)\n", true},
+		{"unknown-F0", "func Value(input int16) int16", "FMOVWP F0,ret+RESULT(FP)\n", false},
+		{"missing-result", "func Value(input int64) int64", "FMOVV input+0(FP),F0\nFINIT\n", false},
+		{"partial-result", "func Value(input int16) int64", "FMOVW input+0(FP),F0\nFMOVWP F0,ret+RESULT(FP)\n", false},
+		{"unbalanced-nonpop", "func Value(input int16) int16", "FMOVW input+0(FP),F0\nFMOVW F0,ret+RESULT(FP)\n", false},
+		{"overflow-stack", "func Value(input int16) int16", strings.Repeat("FLD1\n", 9) + "FMOVWP F0,ret+RESULT(FP)\nFINIT\n", false},
+		{"unwritten-AUTO", "func Value(input int16) int16", "FMOVW cell-2(SP),F0\nFMOVWP F0,ret+RESULT(FP)\n", false},
+		{"padding", "func Value(a byte,b int64) int16", "FMOVW a+0(FP),F0\nFMOVWP F0,ret+RESULT(FP)\n", false},
+		// A typed pointer alone supplies neither NUM pointee bytes nor the
+		// independently paired native-read role. This is not invalid Go syntax.
+		{"independent-native-read-role-unproved", "func Value(input *byte) int16", "MOVE input+0(FP),BX\nFMOVW (BX),F0\nFMOVWP F0,ret+RESULT(FP)\n", false},
+		// The existing exact natural I16 parameter writer is a private shadow,
+		// not a caller/native-frame write. A defined F0 may use that same role.
+		{"whole-natural-I16-shadow", "func Value(input int16) int16", "FMOVW input+0(FP),F0\nFMOVWP F0,input+0(FP)\nMOVW input+0(FP),AX\nMOVW AX,ret+RESULT(FP)\n", true},
+		{"unknown-CALL", "func Value(input int16) int16", "CALL ·unknown(SB)\nFINIT\nFMOVW input+0(FP),F0\nFMOVWP F0,ret+RESULT(FP)\n", false},
+	}
+	for _, target := range x86RawReturnTargets {
+		move := "MOVQ"
+		if target.arch == "386" {
+			move = "MOVL"
+		}
+		for _, row := range rows {
+			body := strings.ReplaceAll(row.body, "MOVE", move)
+			source := x86X87IntegerRoundingSource(t, target.arch, row.declaration, body, 16)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source, row.declaration,
+						target.arch, target.triple, api, X87Software)
+					if row.good && (err != nil || ir == "") ||
+						!row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+						t.Fatal("rounding changed independent storage/initialized-byte/stack authority", row.good, err)
+					}
+					if row.name == "whole-natural-I16-shadow" {
+						actual := x86X87InlineActualValue(t, ir, "i16", 16)
+						for _, input := range []uint16{0, 7, 0x7fff, 0x8000, 0xfffe} {
+							probe := fmt.Sprintf("\ndefine i16 @ShadowProbe() {\n %%r = call i16 @Value(i16 %d)\n ret i16 %%r\n}\n", input)
+							x86ScalarFPNamedConstantResult(t, actual+probe, "ShadowProbe", []uint64{uint64(input)})
+						}
+					}
+				})
+			}
+		}
+	}
+}
diff --git a/x86_x87_integer_state_test.go b/x86_x87_integer_state_test.go
new file mode 100644
index 000000000..4831ae71b
--- /dev/null
+++ b/x86_x87_integer_state_test.go
@@ -0,0 +1,371 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// These unit fixtures describe independently owned logical bytes only. They
+// carry no original instruction, native pointer, caller or entry authority.
+func x86X87IntegerStateFixture() (x86ResultState, []bool) {
+	state := x86ResultState{
+		fp: make([]bool, 32),
+		x87: &x86ResultX87State{word: &x86ResultX87WordState{
+			layout: &x86X87WordLayout{parameters: map[int64]bool{0: true}},
+		}},
+		flags:     x86ByteFlagsAll,
+		direction: x86ResultDirectionForward,
+	}
+	owned := make([]bool, len(state.fp))
+	for offset := range owned {
+		owned[offset] = true
+		state.fp[offset] = offset < 16
+	}
+	return state, owned
+}
+
+func x86X87IntegerStateStep(t *testing.T, state *x86ResultState, owned []bool, arch, source string) {
+	t.Helper()
+	if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, source), state, owned, 16, arch); !known || !accepted {
+		t.Fatal("independent typed x87 state transfer rejected", arch, source, known, accepted)
+	}
+}
+
+func TestX86X87IntegerSourceFactsFollowExactCells(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			width  uint8
+		}{
+			{"FMOVW input+0(FP),F0", 2},
+			{"FMOVL input+0(FP),F0", 4},
+			{"FMOVV input+0(FP),F0", 8},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				state, owned := x86X87IntegerStateFixture()
+				step := func(source string) { x86X87IntegerStateStep(t, &state, owned, arch, source) }
+				step(row.source)
+				if state.x87.depth != 1 || state.x87.integer != [8]uint8{row.width} {
+					t.Fatal("integer load did not push exactly its source signed bound", *state.x87)
+				}
+				step("FMOVD F0,F0") // Go's first matching row reads old F0, then pushes it.
+				if state.x87.depth != 2 || state.x87.integer != [8]uint8{row.width, row.width} {
+					t.Fatal("register FLD lost its read-before-push source identity", *state.x87)
+				}
+				step("FLD1")
+				step("FMOVD F1,F0")
+				if state.x87.integer != [8]uint8{row.width, 0, row.width, row.width} {
+					t.Fatal("register FLD read the shifted rather than original source cell", *state.x87)
+				}
+				step("FXCHD F0,F1")
+				if state.x87.integer != [8]uint8{0, row.width, row.width, row.width} {
+					t.Fatal("FXCH changed unrelated cells or manufactured an integer bound", *state.x87)
+				}
+				step("FMOVD F0,F2")
+				if state.x87.integer != [8]uint8{0, row.width, 0, row.width} {
+					t.Fatal("non-pop register copy retained a stale overwritten-cell bound", *state.x87)
+				}
+				step("FMOVDP F0,F1")
+				if state.x87.depth != 3 || state.x87.integer != [8]uint8{0, 0, row.width} {
+					t.Fatal("pop copy did not write before shifting exact cells", *state.x87)
+				}
+				if state.flags != x86ByteFlagsAll || state.direction != x86ResultDirectionForward {
+					t.Fatal("value-availability transfers changed integer FLAGS or DF")
+				}
+			})
+		}
+		for _, source := range []string{"FABS", "FCHS", "FSQRT", "FADDD F0,F1", "FADDDP F0,F1"} {
+			t.Run(arch+"/revoke/"+source, func(t *testing.T) {
+				state, owned := x86X87IntegerStateFixture()
+				state.x87.slots, state.x87.depth = 7, 3
+				state.x87.integer = [8]uint8{2, 4, 8}
+				x86X87IntegerStateStep(t, &state, owned, arch, source)
+				want := [8]uint8{0, 4, 8}
+				if source == "FADDD F0,F1" {
+					want = [8]uint8{2, 0, 8}
+				} else if source == "FADDDP F0,F1" {
+					want = [8]uint8{0, 8}
+				}
+				if state.x87.integer != want {
+					t.Fatal("arithmetic/unary effect did not revoke only its actual written cell", source, state.x87.integer, want)
+				}
+			})
+		}
+		t.Run(arch+"/float-memory-roundtrip", func(t *testing.T) {
+			state, owned := x86X87IntegerStateFixture()
+			x86X87IntegerStateStep(t, &state, owned, arch, "FMOVV input+0(FP),F0")
+			x86X87IntegerStateStep(t, &state, owned, arch, "FMOVDP F0,output+16(FP)")
+			x86X87IntegerStateStep(t, &state, owned, arch, "FMOVD output+16(FP),F0")
+			if state.x87.depth != 1 || state.x87.integer != [8]uint8{} {
+				t.Fatal("double-memory roundtrip inherited an exact I64 source fact", *state.x87)
+			}
+		})
+		for _, source := range []string{"FMOVD F1,F0", "FMOVDP F0,F1", "FXCHD F0,F1", "FADDDP F0,F1"} {
+			t.Run(arch+"/read-before-write/"+source, func(t *testing.T) {
+				state, owned := x86X87IntegerStateFixture()
+				state.x87.slots, state.x87.depth = 1, 1
+				state.x87.integer[0] = 8
+				// A destination F1 may be created by a store/copy, but every
+				// actual input must exist before a push, pop or overwrite.
+				if source == "FMOVDP F0,F1" {
+					state.x87.slots = 0
+				}
+				if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, source), &state, owned, 16, arch); !known || accepted {
+					t.Fatal("an output/push supplied its own missing input", source, known, accepted)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87IntegerSourceFactCloneJoinAndRevoke(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, first := range []uint8{0, 2, 4, 8} {
+			for _, last := range []uint8{0, 2, 4, 8} {
+				t.Run(fmt.Sprintf("%s/join/%d/%d", arch, first, last), func(t *testing.T) {
+					state, _ := x86X87IntegerStateFixture()
+					state.x87.slots, state.x87.depth = 3, 2
+					state.x87.integer = [8]uint8{first, 2}
+					other := state.clone()
+					other.x87.integer[0] = last
+					if state.x87.integer[0] != first || other.x87.word == state.x87.word {
+						t.Fatal("CFG clone shared mutable integer/control state")
+					}
+					want := first
+					if first == 0 || last == 0 {
+						want = 0
+					} else if last > want {
+						want = last // Both paths fit the common wider signed range.
+					}
+					for _, joined := range []x86ResultState{state.intersect(other), other.intersect(state)} {
+						if joined.x87.invalid || joined.x87.integer != [8]uint8{want, 2} {
+							t.Fatal("join invented a narrower or one-sided signed bound", joined.x87)
+						}
+					}
+					other.x87.slots &^= 1
+					if joined := state.intersect(other); joined.x87.integer[0] != 0 {
+						t.Fatal("unavailable joined cell retained a signed source fact")
+					}
+				})
+			}
+		}
+		for _, axis := range []string{"different-depth", "foreign-layout", "unknown-shape", "missing-domain", "CALL", "FINIT"} {
+			t.Run(arch+"/"+axis, func(t *testing.T) {
+				state, owned := x86X87IntegerStateFixture()
+				state.x87.slots, state.x87.depth = 3, 2
+				state.x87.integer = [8]uint8{2, 8}
+				layout := state.x87.word.layout
+				other := state.clone()
+				switch axis {
+				case "different-depth":
+					other.x87.depth++
+					state = state.intersect(other)
+				case "foreign-layout":
+					other.x87.word.layout = &x86X87WordLayout{parameters: map[int64]bool{0: true}}
+					state = state.intersect(other)
+				case "unknown-shape":
+					other.x87.revoke()
+					state = state.intersect(other)
+				case "missing-domain":
+					other.x87 = nil
+					state = state.intersect(other)
+				case "CALL":
+					x86ResultX87After(Instr{Op: OpCALL}, &state, arch)
+				case "FINIT":
+					x86X87IntegerStateStep(t, &state, owned, arch, "FINIT")
+				}
+				if state.x87.integer != [8]uint8{} || state.x87.slots != 0 || state.x87.depth != 0 {
+					t.Fatal("shape/control boundary retained a mutable integer fact", axis, *state.x87)
+				}
+				if axis == "FINIT" {
+					if state.x87.invalid || state.x87.word.control != 0xffff || state.x87.read(Operand{Kind: OpReg, Reg: "F0"}) {
+						t.Fatal("FINIT did not reset shape, or invented an F0 value")
+					}
+				} else if !state.x87.invalid {
+					t.Fatal("unrelated/unknown states acquired a common known shape", axis)
+				}
+				if axis == "CALL" && (state.x87.word == nil || state.x87.word.layout != layout) {
+					t.Fatal("CALL erased immutable actual layout rather than mutable facts")
+				}
+			})
+		}
+	}
+	for _, shape := range []bool{false, true} {
+		plan, state, owned := x86ABI0BoolCallDomainState(t)
+		state.shapeOnly = shape
+		state.x87 = &x86ResultX87State{slots: 3, depth: 2, integer: [8]uint8{2, 8}}
+		for ordinal := range plan.calls {
+			if accepted, known := x86ABI0BoolCallStep(ordinal, plan.function.Instrs[ordinal], &state, owned, 4, "386"); !known || !accepted {
+				t.Fatal("existing independently closed typed CALL no longer accepted", shape, known, accepted)
+			}
+			if !state.x87.invalid || state.x87.integer != [8]uint8{} {
+				t.Fatal("direct typed CALL retained integer facts without the outer post-transfer hook", shape)
+			}
+		}
+	}
+}
+
+func TestX86X87IntegerRoundingKeepsModeAndWidthBoundaries(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, sourceWidth := range []uint8{0, 2, 4, 8} {
+			for _, row := range []struct {
+				source   string
+				width    uint8
+				pop      uint8
+				hardware bool
+			}{
+				{"FMOVW F0,output+16(FP)", 2, 0, false},
+				{"FMOVWP F0,output+16(FP)", 2, 1, false},
+				{"FMOVL F0,output+16(FP)", 4, 0, false},
+				{"FMOVLP F0,output+16(FP)", 4, 1, false},
+				{"FMOVVP F0,output+16(FP)", 8, 1, true},
+				{"FRNDINT", 0, 0, true},
+			} {
+				for _, control := range []bool{false, true} {
+					t.Run(fmt.Sprintf("%s/source%d/control%t/%s", arch, sourceWidth, control, row.source), func(t *testing.T) {
+						state, owned := x86X87IntegerStateFixture()
+						state.x87.slots, state.x87.depth = 1, 1
+						state.x87.integer[0] = sourceWidth
+						if control {
+							state.x87.word.control = 0xffff
+						}
+						ins := x86X87ValueInstruction(t, row.source)
+						infallible := row.width != 0 && sourceWidth != 0 && sourceWidth <= row.width
+						strict := state.clone()
+						if accepted, known := x86ResultX87ValueStep(ins, &strict, owned, 16, arch); !known || accepted != (control || infallible) {
+							t.Fatal("standalone observer inferred ambient control or rejected an exact integer range", known, accepted)
+						}
+						for _, mode := range []X87Mode{X87Auto, X87Hardware, X87Software} {
+							consumer := amd64Ctx{x87Mode: mode}
+							next := state.clone()
+							accepted, known := consumer.x87HardwareRoundingResultStep(ins, &next, owned, 16, arch)
+							wantKnown := row.hardware && mode != X87Software
+							if known != wantKnown || accepted != wantKnown {
+								t.Fatal("paired adapter covered a software W/L store or lost its actual native operation", mode, known, accepted)
+							}
+							if wantKnown && (next.x87.depth != 1-row.pop || row.width == 0 && next.x87.integer[0] != sourceWidth) {
+								t.Fatal("paired native step changed unrelated stack/integer state", mode, next.x87)
+							}
+							if mode != X87Software && row.hardware {
+								next = state.clone()
+								next.x87.slots = 0
+								if accepted, known := consumer.x87HardwareRoundingResultStep(ins, &next, owned, 16, arch); !known || accepted {
+									t.Fatal("ambient hardware control created a missing F0 value")
+								}
+							}
+							if !row.hardware {
+								next = state.clone()
+								accepted, known := x86ResultX87ValueStepWithHardwareRounding(ins, &next, owned, 16, arch, true)
+								if !known || accepted != (control || infallible) {
+									t.Fatal("internal hardware flag leaked to a nonnative W/L emitter")
+								}
+							}
+							if strict.flags != x86ByteFlagsAll || strict.direction != x86ResultDirectionForward {
+								t.Fatal("rounding defined integer FLAGS or DF")
+							}
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87IntegerStoresReuseOnlyNaturalWordShadow(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			accept bool
+		}{
+			{"FMOVW F0,input+0(FP)", true},
+			{"FMOVWP F0,input+0(FP)", true},
+			{"FMOVW F0,input+1(FP)", false},
+			{"FMOVW F0,input+2(FP)", false},
+			{"FMOVL F0,input+0(FP)", false},
+			{"FMOVLP F0,input+0(FP)", false},
+			{"FMOVVP F0,input+0(FP)", false},
+			{"FMOVW F0,(AX)", false},
+		} {
+			for _, inputKnown := range []bool{false, true} {
+				t.Run(fmt.Sprintf("%s/defined%t/%s", arch, inputKnown, row.source), func(t *testing.T) {
+					state, owned := x86X87IntegerStateFixture()
+					state.x87.slots, state.x87.depth = 1, 1
+					if !inputKnown {
+						state.x87.slots = 0
+					}
+					state.x87.word.control = 0xffff
+					for index := range state.fp {
+						state.fp[index] = false
+					}
+					accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, row.source), &state, owned, 16, arch)
+					if !known || accepted != (row.accept && inputKnown) {
+						t.Fatal("integer store enlarged an independent parameter/native role", known, accepted)
+					}
+					for offset, initialized := range state.fp {
+						if initialized != (accepted && offset < 2) {
+							t.Fatal("natural word writer changed a byte outside its exact old slot", offset, initialized)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87IntegerSourceFactsStayPrivateAndBounded(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct{ typ, load, store string }{
+			{"int16", "FMOVW", "FMOVWP"},
+			{"int32", "FMOVL", "FMOVLP"},
+			{"int64", "FMOVV", "FMOVVP"},
+		} {
+			t.Run(arch+"/private/"+row.typ, func(t *testing.T) {
+				declaration := "func Value(input " + row.typ + ") " + row.typ
+				_, _, sig, _ := x86ResultInitializationFixture(t, arch, declaration, "RET")
+				body := fmt.Sprintf("%s input+0(FP),F0\n%s F0,ret+%d(FP)\nRET", row.load, row.store, sig.Frame.Results[0].Offset)
+				_, file, sig, _ := x86ResultInitializationFixture(t, arch, declaration, body)
+				// No CW probe or FINIT: source integer load/store of equal
+				// width is infallible under any rounding mode. This is not a
+				// certificate that the old double representation preserves I64.
+				if err := checkX86ScalarFPResultInitialization(file.Funcs[0], sig, arch); err != nil {
+					t.Fatal("integer source fact failed before the independent numerical observer", err)
+				}
+				if err := CheckX86ABI0ResultInitialization(file.Funcs[0], sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("private source integer effects widened the public declaration query", err)
+				}
+			})
+		}
+		t.Run(arch+"/eight-cells", func(t *testing.T) {
+			state, owned := x86X87IntegerStateFixture()
+			if len(state.x87.integer) != 8 {
+				t.Fatal("source fact escaped the fixed existing eight-cell stack")
+			}
+			for index := 0; index < 8; index++ {
+				x86X87IntegerStateStep(t, &state, owned, arch, "FMOVW input+0(FP),F0")
+			}
+			before := *state.x87
+			if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, "FMOVW input+0(FP),F0"), &state, owned, 16, arch); !known || accepted {
+				t.Fatal("ninth push manufactured an extra source cell", known, accepted)
+			}
+			if *state.x87 != before {
+				t.Fatal("failed push changed existing signed-width facts")
+			}
+			for index := 0; index < 8; index++ {
+				x86X87IntegerStateStep(t, &state, owned, arch, "FMOVWP F0,output+16(FP)")
+			}
+			if state.x87.integer != [8]uint8{} || state.x87.depth != 0 || state.x87.slots != 0 {
+				t.Fatal("pop retained facts outside the actual remaining stack")
+			}
+		})
+		t.Run(arch+"/shape-is-not-values", func(t *testing.T) {
+			state, owned := x86X87IntegerStateFixture()
+			state.shapeOnly = true
+			x86X87IntegerStateStep(t, &state, owned, arch, "FMOVV input+0(FP),F0")
+			x86X87IntegerStateStep(t, &state, owned, arch, "FRNDINT")
+			if state.x87.integer != [8]uint8{} || state.x87.depth != 0 || state.x87.slots != 0 || state.x87.word.control != 0 {
+				t.Fatal("dead-source shape pass created live values or ambient control")
+			}
+		})
+	}
+}
diff --git a/x86_x87_integer_transport_value_test.go b/x86_x87_integer_transport_value_test.go
new file mode 100644
index 000000000..f14ffae32
--- /dev/null
+++ b/x86_x87_integer_transport_value_test.go
@@ -0,0 +1,50 @@
+package plan9asm
+
+import (
+	"fmt"
+	"testing"
+)
+
+// An integer is an x87 value, not a remembered adjacent load/store pair.
+// Observe it after the shared stack operations and a source-authored join.
+func TestX86X87SignedIntegerValuesSurviveWholeStackTransport(t *testing.T) {
+	const declaration = "func Value(input int64) int64"
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, body string }{
+			{"copy-pop-exchange", `FMOVV input+0(FP),F0
+FLD1
+FXCHD F1,F0
+FMOVDP F0,F1
+FMOVVP F0,ret+8(FP)
+RET`},
+			{"conditional-and-join", `FINIT
+FMOVV input+0(FP),F0
+FLD1
+MOVL $0,AX
+CMPL AX,AX
+FCMOVEQ F1,F0
+JE joined
+FXCHD F1,F0
+joined:
+FMOVDP F0,F1
+FRNDINT
+FMOVVP F0,ret+8(FP)
+RET`},
+		} {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, row.body)
+				ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, "text", X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("whole source did not reach the integer value observation", err)
+				}
+				ir = x86X87InlineActualValue(t, ir, "i64", 64)
+				for _, input := range x86X87SignedI64IdentityInputs {
+					t.Run(fmt.Sprintf("input=%016x", uint64(input)), func(t *testing.T) {
+						probe := ir + fmt.Sprintf("\ndefine i64 @TransportProbe() {\n %%r = call i64 @Value(i64 %d)\n ret i64 %%r\n}\n", input)
+						x86ScalarFPNamedConstantResult(t, probe, "TransportProbe", []uint64{uint64(input)})
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_integer_value_objects_test.go b/x86_x87_integer_value_objects_test.go
new file mode 100644
index 000000000..3f16c4209
--- /dev/null
+++ b/x86_x87_integer_value_objects_test.go
@@ -0,0 +1,83 @@
+package plan9asm
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+func TestX86X87ExactIntegerCarrierFiveTargetObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		for _, mode := range []X87Mode{X87Software, X87Hardware} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/mode%d/%s", target.triple, mode, api), func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, x86X87SignedI64IdentitySource,
+						x86X87SignedI64IdentityDeclaration, target.arch, target.triple, api, mode)
+					if err != nil || ir == "" {
+						t.Fatal("complete identity did not reach object compilation", err)
+					}
+					if mode == X87Hardware && !strings.Contains(ir, "fildll $2") {
+						t.Fatal("hardware integer path projected the exact payload through double")
+					}
+					for _, level := range []string{"0", "2"} {
+						input := ir
+						if level == "2" {
+							input = x86DwordProductIROptimize(t, input)
+						}
+						for _, backend := range []string{"0", "2"} {
+							t.Run("IR"+level+"/backend"+backend, func(t *testing.T) {
+								x86PackedStringCompileObject(t, llc, target.triple, input, "-O"+backend)
+							})
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87ExactIntegerCarrierHostSoftwareExecution(t *testing.T) {
+	llc, clang, ok := findLlcAndClang(t)
+	if !ok {
+		t.Fatal("LLVM22 llc and clang are required")
+	}
+	triple := testTargetTriple(runtime.GOOS, runtime.GOARCH)
+	const driver = `
+#include <stdint.h>
+#include <stdio.h>
+extern int64_t Value(int64_t);
+int main(void) {
+  volatile int64_t input[]={0,1,-1,INT64_C(9007199254740993),
+    -INT64_C(9007199254740993),INT64_MAX,INT64_MIN,
+    INT64_C(0x5555555555555555),-INT64_C(0x5555555555555555)};
+  for (unsigned i=0;i<sizeof(input)/sizeof(input[0]);i++) {
+    int64_t value=input[i], got=Value(value);
+    if(got!=value) {
+      fprintf(stderr,"input[%u]=%lld got=%lld\n",i,(long long)value,(long long)got);
+      return 1;
+    }
+  }
+  return 0;
+}
+`
+	for _, api := range []string{"text", "module", "Go"} {
+		for _, optimized := range []bool{false, true} {
+			t.Run(fmt.Sprintf("%s/IR-O2-%t", api, optimized), func(t *testing.T) {
+				ir, err := x86X87InitializedWordAPI(t, x86X87SignedI64IdentitySource,
+					x86X87SignedI64IdentityDeclaration, "amd64", triple, api, X87Software)
+				if err != nil || ir == "" {
+					t.Fatal("complete identity did not reach host Software execution", err)
+				}
+				if optimized {
+					ir = x86DwordProductIROptimize(t, ir)
+				}
+				compileAndRunRuntimeTestForTarget(t, llc, clang, "x87-exact-integer", triple, ir, driver, nil)
+			})
+		}
+	}
+}
diff --git a/x86_x87_legacy_bounded_scratch_test.go b/x86_x87_legacy_bounded_scratch_test.go
new file mode 100644
index 000000000..c16b10c3c
--- /dev/null
+++ b/x86_x87_legacy_bounded_scratch_test.go
@@ -0,0 +1,229 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+// Keep the complete original function as an independent fixture, including
+// its old unbound physical-SP spelling. The original 19-TEXT source and every
+// signature in TestTranslate386InstructionFamilies remain unchanged.
+const x86X87LegacyOriginalMathSource = `TEXT x87math(SB),NOSPLIT,$0-24
+	FMOVD a+0(FP), F0
+	FABS
+	FMOVD b+8(FP), F0
+	FUCOMI F0, F1
+	FXCHD F0, F1
+	FDIVD F1, F0
+	FMULD F0, F0
+	FLD1
+	FADDDP F0, F1
+	FSQRT
+	FMULDP F0, F1
+	FTST
+	FSTSW AX
+	FSTCW -2(SP)
+	MOVW -2(SP), AX
+	FLDCW -2(SP)
+	FRNDINT
+	FMOVDP F0, ret+16(FP)
+	RET
+`
+
+const x86X87LegacyOriginalRoundingSource = `TEXT round(SB),NOSPLIT,$0-16
+	FMOVD value+0(FP), F0
+	FSTCW -2(SP)
+	FLDCW -2(SP)
+	FRNDINT
+	FMOVVP F0, ret+8(FP)
+	RET
+`
+
+func x86X87InstructionFamiliesBoundedCounterpart(t *testing.T, original string) string {
+	t.Helper()
+	if strings.Count(original, x86X87LegacyOriginalMathSource) != 1 {
+		t.Fatal("bounded counterpart must retain the exact complete original x87math body")
+	}
+	bounded := strings.Replace(x86X87LegacyOriginalMathSource, "$0-24", "$4-24", 1)
+	bounded = strings.ReplaceAll(bounded, "-2(SP)", "savedCW-2(SP)")
+	if strings.Count(bounded, "savedCW-2(SP)") != 3 {
+		t.Fatal("x87math scratch must retain all three original accesses")
+	}
+	return strings.Replace(original, x86X87LegacyOriginalMathSource, bounded, 1)
+}
+
+func x86X87LegacyBoundedRoundingSource(mode X87Mode) string {
+	source := strings.Replace(x86X87LegacyOriginalRoundingSource, "$0-16", "$4-16", 1)
+	source = strings.ReplaceAll(source, "-2(SP)", "control-2(SP)")
+	if mode == X87Software {
+		// This source, not a new Software API default, initializes the control
+		// word before the first value load. Auto/Hardware retain real FNSTCW.
+		source = strings.Replace(source, "\tFMOVD", "\tFINIT\n\tFMOVD", 1)
+	}
+	return source
+}
+
+type x86X87LegacyScratchCase struct {
+	name, symbol, declaration, source, word, floatParameter string
+	mode                                                    X87Mode
+}
+
+func x86X87LegacyScratchCases(t *testing.T) []x86X87LegacyScratchCase {
+	t.Helper()
+	var rows []x86X87LegacyScratchCase
+	for _, mode := range []X87Mode{X87Auto, X87Hardware} {
+		rows = append(rows, x86X87LegacyScratchCase{
+			name: fmt.Sprintf("complete-x87math/mode%d", mode), symbol: "x87math",
+			declaration: "func x87math(a,b float64) float64",
+			source:      x86X87InstructionFamiliesBoundedCounterpart(t, x86X87LegacyOriginalMathSource),
+			word:        "savedCW", floatParameter: "a", mode: mode,
+		})
+	}
+	for _, mode := range []X87Mode{X87Auto, X87Hardware, X87Software} {
+		rows = append(rows, x86X87LegacyScratchCase{
+			name: fmt.Sprintf("complete-round/mode%d", mode), symbol: "round",
+			declaration: "func round(value float64) int64",
+			source:      x86X87LegacyBoundedRoundingSource(mode),
+			word:        "control", floatParameter: "value", mode: mode,
+		})
+	}
+	return rows
+}
+
+func TestX86X87LegacyBoundedScratchFixturesPreserveSourceRoles(t *testing.T) {
+	for _, row := range x86X87LegacyScratchCases(t) {
+		t.Run(row.name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, row.source)
+			if err != nil || len(file.Funcs) != 1 || file.Funcs[0].Sym != row.symbol || file.Funcs[0].FrameSize != 4 {
+				t.Fatal("bounded counterpart lost its complete original TEXT", err)
+			}
+			original := x86X87LegacyOriginalRoundingSource
+			if row.symbol == "x87math" {
+				original = x86X87LegacyOriginalMathSource
+			}
+			restored := strings.Replace(row.source, "$4-", "$0-", 1)
+			restored = strings.ReplaceAll(restored, row.word+"-2(SP)", "-2(SP)")
+			if row.mode == X87Software {
+				if !strings.Contains(restored, "\tFINIT\n\tFMOVD") || strings.Count(restored, "FINIT") != 1 {
+					t.Fatal("Software control initialization must precede the first value load")
+				}
+				restored = strings.Replace(restored, "\tFINIT\n", "", 1)
+			} else if strings.Contains(restored, "FINIT") {
+				t.Fatal("Auto/Hardware acquired a synthetic control default")
+			}
+			if restored != original {
+				t.Fatal("bounded counterpart changed an original non-scratch instruction")
+			}
+		})
+	}
+}
+
+func TestX86X87LegacyBoundedScratchCompleteOriginalGoObjects(t *testing.T) {
+	// Original objects establish actual Go source format, not safe native SP
+	// backing, numerical results, portable proof or executed x87 semantics.
+	rows := []struct{ name, source string }{
+		{"original-complete-x87math", x86X87LegacyOriginalMathSource},
+		{"bounded-complete-x87math", x86X87InstructionFamiliesBoundedCounterpart(t, x86X87LegacyOriginalMathSource)},
+		{"original-complete-round", x86X87LegacyOriginalRoundingSource},
+		{"bounded-round-real-control", x86X87LegacyBoundedRoundingSource(X87Auto)},
+		{"bounded-round-explicit-Software-init", x86X87LegacyBoundedRoundingSource(X87Software)},
+	}
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range rows {
+			t.Run(target.triple+"/"+row.name, func(t *testing.T) {
+				x86LEAActualTargetGoObject(t, target.arch, target.triple,
+					strings.ReplaceAll(row.source, ",NOSPLIT,", ",4,"))
+			})
+		}
+	}
+}
+
+func TestX86X87LegacyBoundedScratchCompleteThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range x86X87LegacyScratchCases(t) {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, row.source, row.declaration,
+						target.arch, target.triple, api, row.mode)
+					if err != nil || ir == "" {
+						t.Fatal("complete bounded original source remains unclosed", err)
+					}
+					x86X87LegacyScratchIRIdentity(t, ir, row)
+				})
+			}
+		}
+	}
+}
+
+func x86X87LegacyScratchIRIdentity(t *testing.T, ir string, row x86X87LegacyScratchCase) {
+	t.Helper()
+	context := llvm.NewContext()
+	defer context.Dispose()
+	module, err := parseIRModuleInContext(context, ir)
+	if !module.IsNil() {
+		defer module.Dispose()
+	}
+	if err != nil {
+		t.Fatal("actual complete counterpart IR is malformed", err)
+	}
+	function := module.NamedFunction(row.symbol)
+	parameters, result := 1, "i64"
+	if row.symbol == "x87math" {
+		parameters, result = 2, "double"
+	}
+	if function.IsNil() || function.FirstBasicBlock().IsNil() || function.ParamsCount() != parameters ||
+		function.GlobalValueType().ReturnType().String() != result {
+		t.Fatal("complete counterpart lost its real declared function identity")
+	}
+}
+
+func x86X87LegacyScratchMutations(row x86X87LegacyScratchCase) map[string]string {
+	cell := row.word + "-2(SP)"
+	write := "\tFSTCW " + cell + "\n"
+	return map[string]string{
+		"zero-frame":        strings.Replace(row.source, "$4-", "$0-", 1),
+		"physical-SP-role":  strings.ReplaceAll(row.source, cell, "-2(SP)"),
+		"outside-frame":     strings.ReplaceAll(row.source, cell, row.word+"-6(SP)"),
+		"missing-CW-write":  strings.Replace(row.source, write, "", 1),
+		"partial-CW-write":  strings.Replace(row.source, write, "\tMOVB $127,"+cell+"\n", 1),
+		"one-path-no-write": strings.Replace(row.source, write, "\tMOVL "+row.floatParameter+"+0(FP),AX\n\tTESTL AX,AX\n\tJE noControlWrite\n"+write+"noControlWrite:\n", 1),
+		"CALL-SP-escape":    strings.Replace(row.source, write, "\tLEAL "+cell+",AX\n\tCALL ·escape(SB)\n"+write, 1),
+	}
+}
+
+func TestX86X87LegacyBoundedScratchSingleMutationBoundaries(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range x86X87LegacyScratchCases(t) {
+			for name, source := range x86X87LegacyScratchMutations(row) {
+				if source == row.source {
+					t.Fatal("single-axis mutation did not change the complete source", row.name, name)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+row.name+"/"+name+"/"+api, func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, row.declaration,
+							target.arch, target.triple, api, row.mode)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatal("changed scratch source acquired unsupported storage or initialization", err)
+						}
+						// A first unrelated x87/CALL Context is not evidence that
+						// this particular scratch/escape obligation was checked.
+						t.Logf("observed first Context for %s: %v", name, err)
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_lowerer_object_unit_test.go b/x86_x87_lowerer_object_unit_test.go
new file mode 100644
index 000000000..b8d3181a1
--- /dev/null
+++ b/x86_x87_lowerer_object_unit_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func x86X87UnboundOriginalAPI(t *testing.T, file *File, options Options, api string) (string, error) {
+	t.Helper()
+	if api == "text" {
+		return Translate(file, options)
+	}
+	var module llvm.Module
+	var err error
+	if api == "module" {
+		module, err = TranslateModule(file, options)
+	} else if api == "owned-module" {
+		context := llvm.NewContext()
+		defer context.Dispose()
+		module, err = TranslateModuleInContext(context, file, options)
+	} else {
+		t.Fatal("unknown complete-original API", api)
+	}
+	if !module.IsNil() {
+		defer module.Dispose()
+		if err == nil {
+			return module.String(), nil
+		}
+	}
+	return "", err
+}
+
+// This deliberately tests the instruction emitter, not Translate or a source
+// permission. Keep every instruction of the complete original zero-argument
+// fixture, including its final RET. Unknown entry registers/private zero slots
+// are not executable input, pointee backing, or an x87 initialization proof.
+// Public APIs must independently reject these original fixtures below.
+func x86X87LowererObjectUnit(t *testing.T, original *File, arch, triple string) string {
+	t.Helper()
+	return x86ZeroArgumentLowererObjectUnit(t, original, arch, triple, "X87LowererObjectUnit",
+		func(consumer *amd64Ctx, instruction Instr) (bool, bool, error) {
+			return consumer.lowerX87(instruction.Op, instruction)
+		})
+}
+
+func x86ZeroArgumentLowererObjectUnit(t *testing.T, original *File, arch, triple, name string,
+	lower func(*amd64Ctx, Instr) (bool, bool, error)) string {
+	t.Helper()
+	if original == nil || len(original.Funcs) != 1 || len(original.Data) != 0 || len(original.Globl) != 0 {
+		t.Fatal("instruction emitter unit requires one complete original TEXT without DATA")
+	}
+	file, err := normalizeX86RawFile(original, arch)
+	if err != nil || len(file.Funcs) != 1 {
+		t.Fatal("complete original raw source did not normalize", err)
+	}
+	function := file.Funcs[0]
+	if function.ArgSize != 0 || function.FrameSize != 0 {
+		t.Fatal("emitter unit cannot impersonate a typed or backed source frame")
+	}
+	var ir strings.Builder
+	fmt.Fprintf(&ir, "target triple = %q\n", triple)
+	emitAMD64Prelude(&ir, arch, file)
+	emitExternSBGlobals(&ir, file, func(symbol string) string { return symbol }, nil)
+	attributes := newFeatureAttrRegistry()
+	features := attributes.ref(inferFuncTargetFeaturesForGOARCH(file.Arch, arch, function))
+	fmt.Fprintf(&ir, "define void %s() %s {\n", llvmGlobal(name), features)
+	consumer := newX86Ctx(&ir, function, FuncSig{Name: name, Ret: Void},
+		func(name string) string { return name }, nil, arch, triple, false)
+	consumer.x87Mode = X87Software
+	if err := consumer.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	text, returns, emitted := 0, 0, 0
+	for ordinal, instruction := range function.Instrs {
+		switch instruction.Op {
+		case OpTEXT:
+			text++
+			if ordinal != 0 {
+				t.Fatal("emitter unit lost its original TEXT order")
+			}
+		case OpRET:
+			returns++
+			if ordinal != len(function.Instrs)-1 || len(instruction.Args) != 0 {
+				t.Fatal("emitter unit cannot omit a source continuation")
+			}
+			ir.WriteString("  ret void\n")
+		default:
+			known, terminated, err := lower(consumer, instruction)
+			if !known || err != nil {
+				t.Fatalf("complete original instruction %d was not emitted: %s: %v", ordinal, instruction.Raw, err)
+			}
+			if terminated {
+				// The complete format-only source can contain an invalid
+				// encoding before later rows. Retain those original rows in
+				// explicitly unreachable emitter-unit blocks, not by turning
+				// #UD into a returning operation or claiming native execution.
+				fmt.Fprintf(&ir, "%s_emitter_only_unreachable:\n", consumer.newTmp())
+			}
+			emitted++
+		}
+	}
+	if text != 1 || returns != 1 || emitted != len(function.Instrs)-2 {
+		t.Fatal("emitter unit did not consume every original instruction")
+	}
+	ir.WriteString("}\n")
+	attributes.emit(&ir)
+	t.Logf("emitter-only object source: all %d normalized instructions; no public translation or execution claim", emitted)
+	return ir.String()
+}
diff --git a/x86_x87_native_move_result_test.go b/x86_x87_native_move_result_test.go
new file mode 100644
index 000000000..dc61306dd
--- /dev/null
+++ b/x86_x87_native_move_result_test.go
@@ -0,0 +1,175 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86X87NativeMoveProgram(arch, op string) (string, string) {
+	word, move := 8, "MOVQ"
+	if arch == "386" {
+		word, move = 4, "MOVL"
+	}
+	load := strings.TrimSuffix(op, "P")
+	body := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s src+0(FP),SI\n%s dst+%d(FP),DI\nFINIT\n%s 1(SI),F0\n%s F0,1(DI)\nFINIT\nMOVL $7,AX\nMOVL AX,ret+%d(FP)\nRET\n",
+		2*word+4, move, move, word, load, op, 2*word)
+	return body, "func Value(src,dst *byte) uint32"
+}
+
+func TestX86X87NativeFloatingMoveCompleteFamilyThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			source, declaration := x86X87NativeMoveProgram(target.arch, op)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declaration, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete x87 native floating move has an unclosed input/output rule", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87NativeFloatingMoveMissingInputsAndDeadEffects(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			source, declaration := x86X87NativeMoveProgram(target.arch, op)
+			for _, row := range []struct{ name, before, after string }{
+				{"unknown-read-base", "1(SI),F0", "1(BX),F0"},
+				{"unknown-read-index", "1(SI),F0", "1(SI)(CX*1),F0"},
+				{"unknown-write-base", "F0,1(DI)", "F0,1(BX)"},
+				{"unknown-F0", strings.TrimSuffix(op, "P") + " 1(SI),F0\n", ""},
+			} {
+				changed := strings.Replace(source, row.before, row.after, 1)
+				if changed == source {
+					t.Fatal("independent x87 mutation lost its source", row.name)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+op+"/"+row.name+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, changed, declaration, target.arch, target.triple, api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("x87 move invented source bytes or a native address", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86StackNativeValueReadsCompleteWidthsThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move, suffix := 8, "MOVQ", "Q"
+		if target.arch == "386" {
+			word, move, suffix = 4, "MOVL", "L"
+		}
+		for _, width := range []string{"W", suffix} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s src+0(FP),SI\nPUSH%s 1(SI)\nPOP%s AX\nMOVWLZX AX,AX\nMOVL AX,ret+%d(FP)\nRET\n", word+4, move, width, width, word)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+width+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(src *byte) uint32", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("native PUSH value did not consume its exact-width input", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87NativeFloatingMoveCannotBypassVoidProof(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move := 8, "MOVQ"
+		if target.arch == "386" {
+			word, move = 4, "MOVL"
+		}
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s dst+0(FP),DI\nFINIT\n%s F0,1(DI)\nFINIT\nRET\n", word, move, op)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(dst *byte)", target.arch, target.triple, api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("discarded x87 results supplied unknown F0 bytes", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87NativeFloatingMoveOriginalGoAndLLVMObjects(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("x87 native floating moves require LLVM22 llc")
+	}
+	for _, target := range x86RawReturnTargets {
+		var source, declarations strings.Builder
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			text, declaration := x86X87NativeMoveProgram(target.arch, op)
+			source.WriteString(strings.ReplaceAll(text, "Value", op))
+			declarations.WriteString(strings.ReplaceAll(declaration, "Value", op) + "\n")
+		}
+		requireX86GoAssemblerResult(t, target.arch, source.String(), true)
+		for _, mode := range []X87Mode{X87Auto, X87Hardware, X87Software} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(fmt.Sprintf("%s/mode%d/%s", target.triple, mode, api), func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source.String(), declarations.String(), target.arch, target.triple, api, mode)
+					if err != nil || ir == "" {
+						t.Fatal("complete original floating move source", err)
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						for _, operation := range []string{"load", "store"} {
+							for _, typ := range []string{"float", "double"} {
+								if strings.Count(text, operation+" volatile "+typ) != 2 {
+									t.Fatal("native floating move lost its exact width or observable access", operation, typ)
+								}
+							}
+						}
+						for _, level := range []string{"-O0", "-O2"} {
+							x86PackedStringCompileObject(t, llc, target.triple, text, level)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87AndStackNativeReadsDoNotSupplyStandaloneBacking(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+			source, declaration := x86X87NativeMoveProgram(arch, op)
+			file, err := Parse(ArchAMD64, source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			pkg := mustGoPackage(t, "nativeinputs", "package nativeinputs\n"+declaration)
+			sigs, err := goSigsForAsmFile(pkg, file, func(name string) string { return strings.TrimPrefix(name, "·") }, arch, nil, nil, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if !errors.Is(check(file.Funcs[0], sigs["Value"], arch), ErrProbeNeedsContext) {
+					t.Fatal("unpaired query acquired a native floating read/write", arch, op)
+				}
+			}
+		}
+		word, move, suffix := 8, "MOVQ", "Q"
+		if arch == "386" {
+			word, move, suffix = 4, "MOVL", "L"
+		}
+		for _, width := range []string{"W", suffix} {
+			body := fmt.Sprintf("%s src+0(FP),SI\nPUSH%s 1(SI)\nPOP%s AX\nMOVWLZX AX,AX\nMOVL AX,ret+%d(FP)\nRET", move, width, width, word)
+			_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value(src *byte) uint32", body)
+			for _, check := range []func(Func, FuncSig, string) error{CheckX86ABI0ResultInitialization, checkX86ScalarFPResultInitialization} {
+				if !errors.Is(check(file.Funcs[0], sig, arch), ErrProbeNeedsContext) {
+					t.Fatal("unpaired query acquired a native PUSH read", arch, width)
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_native_move_runtime_test.go b/x86_x87_native_move_runtime_test.go
new file mode 100644
index 000000000..5fe7df6c0
--- /dev/null
+++ b/x86_x87_native_move_runtime_test.go
@@ -0,0 +1,154 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestX86X87NativeFloatingMovesPortableValuesAndCanaries(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	var source, declarations strings.Builder
+	for _, op := range []string{"FMOVF", "FMOVFP", "FMOVD", "FMOVDP"} {
+		text, declaration := x86X87NativeMoveProgram(arch, op)
+		source.WriteString(strings.ReplaceAll(text, "Value", op))
+		declarations.WriteString(strings.ReplaceAll(declaration, "Value", op) + "\n")
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86X87InitializedWordAPI(t, source.String(), declarations.String(), arch, execution.triple, api, X87Software)
+			if err != nil || ir == "" {
+				t.Fatal("portable original floating move program", err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					execution.compileAndRunLLVM(t, "x87-floating-moves", text, x86X87NativeMoveValueDriver, level)
+				}
+			}
+		})
+	}
+}
+
+const x86X87NativeMoveValueDriver = `
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+extern uint32_t FMOVF(const uint8_t*,uint8_t*), FMOVFP(const uint8_t*,uint8_t*);
+extern uint32_t FMOVD(const uint8_t*,uint8_t*), FMOVDP(const uint8_t*,uint8_t*);
+int main(void) {
+    const uint64_t values[]={0,UINT64_C(0x8000000000000000),1,
+        UINT64_C(0x0010000000000000),UINT64_C(0x3ff0000000000000),
+        UINT64_C(0xbff0000000000000),UINT64_C(0x7fefffffffffffff),
+        UINT64_C(0x7ff0000000000000),UINT64_C(0xfff0000000000000)};
+    uint32_t (*calls[])(const uint8_t*,uint8_t*)={FMOVF,FMOVFP,FMOVD,FMOVDP};
+    for(unsigned op=0;op<4;++op) for(unsigned row=0;row<257;++row) {
+        uint64_t bits=values[row%(sizeof(values)/sizeof(values[0]))];
+        if(op<2) {
+            const uint32_t small[]={0,0x80000000,1,0x00800000,0x3f800000,
+                0xbf800000,0x7f7fffff,0x7f800000,0xff800000};
+            bits=small[row%(sizeof(small)/sizeof(small[0]))];
+        }
+        const unsigned width=op<2 ? 4 : 8;
+        uint8_t input[18],before[18],output[18],want[18];
+        memset(input,0x5c,sizeof(input)); memset(output,0xa7,sizeof(output));
+        memcpy(input+1,&bits,width); memcpy(before,input,sizeof(input));
+        memcpy(want,output,sizeof(output)); memcpy(want+1,&bits,width);
+        if(calls[op](input,output)!=7 || memcmp(input,before,sizeof(input)) ||
+            memcmp(output,want,sizeof(output))) {
+            fprintf(stderr,"floating native move op=%u row=%u\n",op,row); return 1;
+        }
+    }
+    return 0;
+}
+`
+
+func TestX86StackNativeReadWidthsRemainObservable(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		word, move, suffix := 8, "MOVQ", "Q"
+		if target.arch == "386" {
+			word, move, suffix = 4, "MOVL", "L"
+		}
+		for _, width := range []string{"W", suffix} {
+			source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s src+0(FP),SI\nPUSH%s 1(SI)\nPOP%s AX\nMOVL $7,AX\nMOVL AX,ret+%d(FP)\nRET\n", word+4, move, width, width, word)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+width+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(src *byte) uint32", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("dead PUSH input", err)
+					}
+					bits := 16
+					if width != "W" {
+						bits = word * 8
+					}
+					for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+						if strings.Count(text, fmt.Sprintf("load volatile i%d,", bits)) != 1 {
+							t.Fatal("discarded PUSH lost its exact native read width", width)
+						}
+					}
+				})
+			}
+		}
+	}
+}
+
+func TestX87DirectFlagCompareOriginalProgramPortable(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch := "amd64"
+	if strconv.IntSize == 32 {
+		arch = "386"
+	}
+	requireX86GoAssemblerResult(t, arch, x87FlagCompareAssembly(arch), true)
+	x87DirectFlagCompareRuntimeWithMode(t, arch, execution.triple, X87Software, func(t *testing.T, ir, main string) {
+		for _, level := range []string{"-O0", "-O2"} {
+			execution.compileAndRunLLVM(t, "original-x87-direct-flags", ir, main, level)
+		}
+	})
+}
+
+func TestX86X87AndStackNativeDeadAccessFaults(t *testing.T) {
+	execution := x86ScalarCountHostExecution(t)
+	arch, word, move, suffix := "amd64", 8, "MOVQ", "Q"
+	if strconv.IntSize == 32 {
+		arch, word, move, suffix = "386", 4, "MOVL", "L"
+	}
+	var source, declarations, prototypes, callbacks, rows strings.Builder
+	add := func(body string, bytes int) {
+		name := fmt.Sprintf("nativeDeadAccess%d", strings.Count(declarations.String(), "func "))
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s input+0(FP),SI\n%sMOVL $7,AX\nMOVL AX,ret+%d(FP)\nRET\n", name, word+4, move, body, word)
+		fmt.Fprintf(&declarations, "func %s(input *byte) uint32\n", name)
+		fmt.Fprintf(&prototypes, "extern uint32_t %s(const uint8_t*);\n", name)
+		fmt.Fprintf(&callbacks, "static int run%s(const uint8_t *p) {return %s((const uint8_t*)((uintptr_t)p-1))==7 ? 0 : 91;}\n", name, name)
+		fmt.Fprintf(&rows, "{run%s,%d,%d},\n", name, bytes, bytes-1)
+	}
+	for _, row := range []struct {
+		op    string
+		bytes int
+	}{{"FMOVF", 4}, {"FMOVD", 8}} {
+		add("FINIT\n"+row.op+" 1(SI),F0\nFINIT\n", row.bytes)
+		for _, pop := range []string{"", "P"} {
+			add("FINIT\nFLD1\n"+row.op+pop+" F0,1(SI)\nFINIT\n", row.bytes)
+		}
+	}
+	add("PUSHW 1(SI)\nPOPW AX\n", 2)
+	add("PUSH"+suffix+" 1(SI)\nPOP"+suffix+" AX\n", word)
+	driver := x86MemoryFaultDriver(prototypes.String()+callbacks.String(), rows.String())
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86X87InitializedWordAPI(t, source.String(), declarations.String(), arch, execution.triple, api, X87Software)
+			if err != nil || ir == "" {
+				t.Fatal("native dead-access source", err)
+			}
+			for _, text := range []string{ir, x86MulDivRoundOptimize(t, ir)} {
+				for _, level := range []string{"-O0", "-O2"} {
+					executable := execution.compileLLVM(t, "x87-stack-dead-faults", text, driver, level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, 8)
+				}
+			}
+		})
+	}
+}
diff --git a/x86_x87_raw_clear_bounded_test.go b/x86_x87_raw_clear_bounded_test.go
new file mode 100644
index 000000000..97813c16c
--- /dev/null
+++ b/x86_x87_raw_clear_bounded_test.go
@@ -0,0 +1,140 @@
+package plan9asm
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func x86X87RawClearBody(masked bool) string {
+	if masked {
+		// Unlike FINIT followed by clear, this cannot pass if DB E2 is
+		// replaced with NOP: entry exception bits are initially unknown.
+		return "BYTE $0xdb; BYTE $0xe2\nFSTSW AX\nANDW $0x80ff,AX\nMOVW AX,ret+0(FP)\nFINIT\nRET"
+	}
+	return "FINIT\nBYTE $0xdb; BYTE $0xe2\nFSTSW AX\nMOVW AX,ret+0(FP)\nRET"
+}
+
+func TestX86X87RawClearBoundedInitializedAndMaskedThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, masked := range []bool{false, true} {
+			name := "initialized-word"
+			if masked {
+				name = "only-cleared-bits"
+			}
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, "func Value() uint16", x86X87RawClearBody(masked))
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source, "func Value() uint16", target.arch, target.triple, api, X87Software)
+					if err != nil || ir == "" {
+						t.Fatal("raw clear was rejected before its numerical oracle; no value observation executed", err)
+					}
+					x86ScalarFPNamedConstantResult(t, ir, "Value", []uint64{0})
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87RawClearCannotInventWordOrValueFacts(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		for _, row := range []struct{ name, body string }{
+			{"NOP-is-not-clear", strings.Replace(x86X87RawClearBody(true), "BYTE $0xdb; BYTE $0xe2", "BYTE $0x90", 1)},
+			{"clear-is-not-whole-status", strings.Replace(x86X87RawClearBody(true), "ANDW $0x80ff,AX\n", "", 1)},
+			{"clear-does-not-create-F0", "FINIT\nBYTE $0xdb; BYTE $0xe2\nFTST\nMOVW $0,ret+0(FP)\nRET"},
+			{"clear-does-not-empty-stack", "FINIT\nFLD1\nBYTE $0xdb; BYTE $0xe2\nMOVW $0,ret+0(FP)\nRET"},
+		} {
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, "func Value() uint16", row.body)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86X87InitializedWordAPI(t, source, "func Value() uint16", target.arch, target.triple, api, X87Software)
+					if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+						t.Fatal("raw clear granted an unknown status/value/stack fact", err)
+					}
+					t.Logf("FIRST_CONTEXT %s: %v", row.name, err)
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87RawClearRequiresWholeReplayIdentity(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		_, file, sig, _ := x86ResultInitializationFixture(t, arch, "func Value() uint16", x86X87RawClearBody(true))
+		normalized, err := normalizeX86RawFile(file, arch)
+		if err != nil || normalized == nil || len(normalized.Funcs) != 1 {
+			t.Fatal("raw fixture normalization failed", err)
+		}
+		fn := normalized.Funcs[0]
+		clear := -1
+		for ordinal, ins := range fn.Instrs {
+			if ins.Op == "FCLEX" && ins.x86SourceRaw != nil {
+				clear = ordinal
+			}
+		}
+		if clear < 0 || fn.x86RawReplay == nil {
+			t.Fatal("fixture lacks the actual complete raw decoder replay")
+		}
+		t.Run(arch+"/standalone-query", func(t *testing.T) {
+			if err := CheckX86ABI0ResultInitialization(fn, sig, arch); !errors.Is(err, ErrProbeNeedsContext) {
+				t.Fatal("standalone declaration query acquired the private raw-clear role", err)
+			}
+		})
+		for _, change := range []string{"none", "missing-replay", "wrong-mode", "raw-source", "original-instruction", "decoded-instruction",
+			"normalized-snapshot", "normalized-op", "original-op", "original-args", "ordinal", "copied-token", "address-size", "raw-return"} {
+			t.Run(arch+"/"+change, func(t *testing.T) {
+				candidate := fn
+				candidate.Instrs = cloneX86ReplayInstrs(fn.Instrs)
+				replay := *fn.x86RawReplay
+				replay.original = cloneX86ReplayInstrs(replay.original)
+				replay.decoded = cloneX86ReplayInstrs(replay.decoded)
+				replay.normalized = cloneX86ReplayInstrs(replay.normalized)
+				candidate.x86RawReplay = &replay
+				mode := arch
+				switch change {
+				case "missing-replay":
+					candidate.x86RawReplay = nil
+				case "wrong-mode":
+					mode = "386"
+					if arch == "386" {
+						mode = "amd64"
+					}
+				case "raw-source":
+					replay.source = strings.Replace(replay.source, "BYTE $0xe2", "BYTE $0xe3", 1)
+				case "original-instruction":
+					replay.original[1].Raw = "BYTE $0x90"
+				case "decoded-instruction":
+					replay.decoded[clear].Op = "NOP"
+				case "normalized-snapshot":
+					replay.normalized[clear].Op = "NOP"
+				case "normalized-op":
+					candidate.Instrs[clear].Op = "NOP"
+				case "original-op":
+					candidate.Instrs[clear].x86SourceRaw.op = "NOP"
+				case "original-args":
+					candidate.Instrs[clear].x86SourceRaw.args = []Operand{{Kind: OpReg, Reg: AX}}
+				case "ordinal":
+					candidate.Instrs[clear], candidate.Instrs[clear+1] = candidate.Instrs[clear+1], candidate.Instrs[clear]
+				case "copied-token":
+					candidate.Sym += "Copy"
+				case "address-size":
+					candidate.Instrs[clear].x86AddressBits = 32
+				case "raw-return":
+					candidate.Instrs[clear].x86RawNearReturn = new(x86RawNearReturnForm)
+				}
+				consumer := &amd64Ctx{fpScalarSource: candidate, sig: sig, fpSourceSig: sig, goarch: mode, x87Mode: X87Software}
+				err := consumer.checkLoweredScalarFPResultInitialization()
+				if change == "none" {
+					if err != nil {
+						t.Fatal("authentic raw clear never reached a positive paired proof", err)
+					}
+					return
+				}
+				if !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed source/mode/ordinal borrowed a raw-clear replay", err)
+				}
+				t.Logf("FIRST_CONTEXT %s: %v", change, err)
+			})
+		}
+	}
+}
diff --git a/x86_x87_scoped_control_scratch.go b/x86_x87_scoped_control_scratch.go
new file mode 100644
index 000000000..abc73ea2e
--- /dev/null
+++ b/x86_x87_scoped_control_scratch.go
@@ -0,0 +1,134 @@
+package plan9asm
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// A complete mode32 rounding leaf can keep two private control words below
+// its unchanged SP, within one 386 word. This is not a TEXT/AUTO frame or
+// caller-memory authority; a larger negative offset gains no storage rights.
+// The closed grammar preserves the saved word, changes only rounding-control
+// bits in the second word, and restores control before its sole return.
+// Initialization still comes from the paired FNSTCW/result-byte observer.
+func x86X87ScopedControlScratchExtent(fn Func, arch string) (int, bool) {
+	if arch != "386" || fn.FrameSize != 0 || strings.Contains(fn.Sym, "<") ||
+		len(fn.Instrs) < 11 || len(fn.Instrs) > 12 || len(fn.X86RawText) != 0 ||
+		fn.x86RawReplay != nil || fn.x86SourceStack != nil || fn.x86FixedLocal != nil ||
+		fn.x86DirectTailRoot != nil || fn.x86ContinuationFlow != nil || fn.x86BoolCalls != nil {
+		return 0, false
+	}
+	instructions := fn.Instrs
+	if instructions[0].Op != OpTEXT {
+		return 0, false
+	}
+	text := splitTopLevelCSV(strings.TrimSpace(strings.TrimPrefix(instructions[0].Raw, "TEXT")))
+	if len(text) != 3 || strings.TrimSpace(text[1]) != "NOSPLIT" && strings.TrimSpace(text[1]) != "4" {
+		return 0, false
+	}
+	// Replay every original instruction, not a rewritten positive TEXT or a
+	// projection that hides physical SP, raw instructions, labels or calls.
+	var source strings.Builder
+	for _, ins := range instructions {
+		if !x86ResultNamedPredicateInstruction(ins) || ins.Raw == "" || len(ins.Raw) > (1<<20)-source.Len()-1 {
+			return 0, false
+		}
+		source.WriteString(ins.Raw)
+		source.WriteByte('\n')
+	}
+	parsed, err := Parse(ArchAMD64, source.String())
+	if err != nil || len(parsed.Funcs) != 1 || len(parsed.Data) != 0 || len(parsed.Globl) != 0 || len(parsed.UnlinkedPrelude) != 0 {
+		return 0, false
+	}
+	original := parsed.Funcs[0]
+	if original.Sym != fn.Sym || original.FrameSize != fn.FrameSize || original.ArgSize != fn.ArgSize ||
+		!reflect.DeepEqual(original.Instrs, instructions) {
+		return 0, false
+	}
+	load, save, copy := instructions[1], instructions[2], instructions[3]
+	if load.Op != "FMOVD" || len(load.Args) != 2 || load.Args[0].Kind != OpFP || !isX87F0(load.Args[1]) ||
+		save.Op != "FSTCW" || len(save.Args) != 1 ||
+		copy.Op != "MOVW" || len(copy.Args) != 2 || copy.Args[0].Kind != OpMem || copy.Args[0].Mem != save.Args[0].Mem ||
+		copy.Args[1].Kind != OpReg {
+		return 0, false
+	}
+	saved, valid := x86X87ScopedControlCell(save, 0)
+	register := copy.Args[1]
+	if _, _, gp := x86ResultGP(register.Reg, 2, arch); !valid || !gp || register.Reg == SP {
+		return 0, false
+	}
+	index := 4
+	cleared := false
+	if instructions[index].Op == "ANDW" {
+		ins := instructions[index]
+		if len(ins.Args) != 2 || ins.Args[0].Kind != OpImm || ins.Args[0].ImmRaw != "" || ins.Args[0].ImmIsFloat ||
+			ins.Args[0].Imm != 0xf3ff || ins.Args[1].Kind != OpReg || ins.Args[1].Reg != register.Reg {
+			return 0, false
+		}
+		cleared = true
+		index++
+	}
+	selectMode := instructions[index]
+	if selectMode.Op != "ORW" || len(selectMode.Args) != 2 || selectMode.Args[0].Kind != OpImm ||
+		selectMode.Args[0].ImmRaw != "" || selectMode.Args[0].ImmIsFloat ||
+		selectMode.Args[1].Kind != OpReg || selectMode.Args[1].Reg != register.Reg || selectMode.Args[0].Imm&^0x0c00 != 0 ||
+		!cleared && selectMode.Args[0].Imm != 0x0c00 || len(instructions) != index+7 {
+		return 0, false
+	}
+	store, change := instructions[index+1], instructions[index+2]
+	round, restore := instructions[index+3], instructions[index+4]
+	result, ret := instructions[index+5], instructions[index+6]
+	if store.Op != "MOVW" || len(store.Args) != 2 || store.Args[0].Kind != OpReg || store.Args[0].Reg != register.Reg ||
+		change.Op != "FLDCW" || len(change.Args) != 1 || change.Args[0].Kind != OpMem || change.Args[0].Mem != store.Args[1].Mem ||
+		round.Op != "FRNDINT" || len(round.Args) != 0 ||
+		restore.Op != "FLDCW" || len(restore.Args) != 1 || restore.Args[0].Kind != OpMem || restore.Args[0].Mem != save.Args[0].Mem ||
+		result.Op != "FMOVDP" || len(result.Args) != 2 || !isX87F0(result.Args[0]) || result.Args[1].Kind != OpFP ||
+		ret.Op != OpRET || len(ret.Args) != 0 {
+		return 0, false
+	}
+	temporary, valid := x86X87ScopedControlCell(store, 1)
+	if !valid || saved < temporary+2 && temporary < saved+2 {
+		return 0, false
+	}
+	for _, consumer := range []struct {
+		instruction Instr
+		offset      int64
+	}{{copy, saved}, {change, temporary}, {restore, saved}} {
+		if offset, valid := x86X87ScopedControlCell(consumer.instruction, 0); !valid || offset != consumer.offset {
+			return 0, false
+		}
+	}
+	for _, instruction := range []Instr{save, change, restore} {
+		if _, known, err := x86X87WordProperties(instruction, arch); !known || err != nil {
+			return 0, false
+		}
+	}
+	if temporary < saved {
+		saved = temporary
+	}
+	return int(-saved), true
+}
+
+func x86X87ScopedControlCell(ins Instr, index int) (int64, bool) {
+	arg := ins.Args[index]
+	if arg.Kind != OpMem || arg.Mem.Base != SP || arg.Mem.Off < -4 || arg.Mem.Off > -2 ||
+		arg.Mem.Sym != "" || arg.Mem.OffRaw != "" || arg.Mem.Index != "" || arg.Mem.IndexExt != "" ||
+		arg.Mem.Segment != "" || arg.Mem.Scale != 0 {
+		return 0, false
+	}
+	fields := strings.Fields(ins.Raw)
+	if len(fields) < 2 {
+		return 0, false
+	}
+	operands := splitTopLevelCSV(strings.TrimSpace(ins.Raw[len(fields[0]):]))
+	if len(operands) != len(ins.Args) {
+		return 0, false
+	}
+	literal := x86ResultAUTOLiteral.FindStringSubmatch(operands[index])
+	if literal == nil {
+		return 0, false
+	}
+	offset, err := strconv.ParseInt(strings.TrimSpace(literal[1]), 0, 64)
+	return offset, err == nil && offset == arg.Mem.Off
+}
diff --git a/x86_x87_scoped_control_scratch_test.go b/x86_x87_scoped_control_scratch_test.go
new file mode 100644
index 000000000..730eac2de
--- /dev/null
+++ b/x86_x87_scoped_control_scratch_test.go
@@ -0,0 +1,195 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+type x86ScopedRoundingCase struct {
+	name, source, declaration string
+	mode                      int
+}
+
+func x86ScopedRoundingCases() []x86ScopedRoundingCase {
+	var rows []x86ScopedRoundingCase
+	for mode := 0; mode < 5; mode++ {
+		for _, register := range []string{"AX", "BX", "CX", "DX", "SI", "DI", "BP"} {
+			for _, cells := range [][2]int{{-2, -4}, {-4, -2}} {
+				name := fmt.Sprintf("Round%d", len(rows))
+				clear := fmt.Sprintf("ANDW $0xf3ff,%s\n", register)
+				selection := mode
+				if mode == 4 {
+					clear, selection = "", 3
+				}
+				source := fmt.Sprintf(`TEXT ·%s(SB),4,$0-16
+FMOVD input+0(FP),F0
+FSTCW %d(SP)
+MOVW %d(SP),%s
+%sORW $%d,%s
+MOVW %s,%d(SP)
+FLDCW %d(SP)
+FRNDINT
+FLDCW %d(SP)
+FMOVDP F0,ret+8(FP)
+RET
+`, name, cells[0], cells[0], register, clear, selection<<10, register,
+					register, cells[1], cells[1], cells[0])
+				rows = append(rows, x86ScopedRoundingCase{name, source,
+					fmt.Sprintf("func %s(input float64) float64\n", name), selection})
+			}
+		}
+	}
+	return rows
+}
+
+func x86ScopedRoundingBundle(t *testing.T) (string, string) {
+	t.Helper()
+	var source, declarations strings.Builder
+	rows := x86ScopedRoundingCases()
+	if len(rows) != 70 {
+		t.Fatal("complete scoped-control family inventory changed", len(rows))
+	}
+	for _, row := range rows {
+		source.WriteString(row.source)
+		declarations.WriteString(row.declaration)
+	}
+	return source.String(), declarations.String()
+}
+
+func TestX86X87ScopedRoundingCompleteFamilyObjects(t *testing.T) {
+	source, declarations := x86ScopedRoundingBundle(t)
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("scoped rounding requires LLVM22 llc")
+	}
+	for _, triple := range []string{"i386-unknown-linux-gnu", "i686-pc-windows-msvc", "i686-w64-windows-gnu"} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, source)
+			for _, mode := range []X87Mode{X87Auto, X87Hardware} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("mode%d/%s", mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, declarations, "386", triple, api, mode)
+						if err != nil || ir == "" {
+							t.Fatal("complete scoped rounding family cannot translate", err)
+						}
+						x86X87HardwareWordRead(t, ir, 70)
+						for _, input := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+							for _, level := range []string{"-O0", "-O2"} {
+								x86PackedStringCompileObject(t, llc, triple, input, level)
+							}
+						}
+					})
+				}
+			}
+		})
+	}
+}
+
+func TestX86X87ScopedRoundingScratchSourceBoundaries(t *testing.T) {
+	row := x86ScopedRoundingCases()[0]
+	for name, source := range map[string]string{
+		"read-named-AUTO":        strings.Replace(row.source, "MOVW -2(SP)", "MOVW saved-2(SP)", 1),
+		"change-named-AUTO":      strings.Replace(row.source, "FLDCW -4(SP)", "FLDCW temporary-4(SP)", 1),
+		"restore-named-AUTO":     strings.Replace(row.source, "FLDCW -2(SP)", "FLDCW saved-2(SP)", 1),
+		"overlap-saved":          strings.ReplaceAll(row.source, "-4(SP)", "-2(SP)"),
+		"partial-overlap":        strings.ReplaceAll(row.source, "-4(SP)", "-3(SP)"),
+		"outside-bound":          strings.ReplaceAll(row.source, "-4(SP)", "-4097(SP)"),
+		"second-stack-word":      strings.ReplaceAll(row.source, "-4(SP)", "-6(SP)"),
+		"touch-return-address":   strings.ReplaceAll(row.source, "-4(SP)", "-1(SP)"),
+		"incoming-SP":            strings.ReplaceAll(row.source, "-4(SP)", "0(SP)"),
+		"changed-exception-mask": strings.Replace(row.source, "$0xf3ff", "$0xf3fe", 1),
+		"changed-precision":      strings.Replace(row.source, "ORW $0,", "ORW $256,", 1),
+		"unknown-RC":             strings.Replace(row.source, "ORW $0,", "ORW $missing,", 1),
+		"missing-save":           strings.Replace(row.source, "FSTCW -2(SP)\n", "", 1),
+		"partial-save":           strings.Replace(row.source, "FSTCW -2(SP)", "MOVB $127,-2(SP)", 1),
+		"overwrite-saved":        strings.Replace(row.source, "FRNDINT\n", "FRNDINT\nMOVW $0,-2(SP)\n", 1),
+		"missing-restore":        strings.Replace(row.source, "FLDCW -2(SP)\n", "", 1),
+		"wrong-restore":          strings.Replace(row.source, "FLDCW -2(SP)", "FLDCW -4(SP)", 1),
+		"early-return":           strings.Replace(row.source, "FRNDINT\n", "FRNDINT\nRET\n", 1),
+		"stack-change":           strings.Replace(row.source, "FRNDINT\n", "PUSHL AX\nFRNDINT\nPOPL AX\n", 1),
+		"stack-escape":           strings.Replace(row.source, "FRNDINT\n", "LEAL -2(SP),AX\nCALL ·escape(SB)\nFRNDINT\n", 1),
+		"dead-extra-access":      row.source + "MOVW -6(SP),AX\n",
+		"nonzero-TEXT":           strings.Replace(row.source, "$0-16", "$4-16", 1),
+		"split-TEXT":             strings.Replace(row.source, ",4,$0", ",0,$0", 1),
+	} {
+		t.Run(name, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, source)
+			if err != nil || len(file.Funcs) != 1 {
+				t.Fatal("source boundary must reach the translator, not fail parsing", err)
+			}
+			if extent, ok := x86X87ScopedControlScratchExtent(file.Funcs[0], "386"); ok || extent != 0 {
+				t.Fatal("changed source borrowed private control-word storage", extent)
+			}
+			for _, api := range []string{"text", "module", "Go"} {
+				ir, err := x86X87InitializedWordAPI(t, source, row.declaration, "386", "i686-pc-windows-msvc", api, X87Hardware)
+				if err == nil || ir != "" {
+					t.Fatal("changed source was published", api, err)
+				}
+			}
+		})
+	}
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run("unknown-software-control/"+api, func(t *testing.T) {
+			ir, err := x86X87InitializedWordAPI(t, row.source, row.declaration, "386", "i686-pc-windows-msvc", api, X87Software)
+			if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+				t.Fatal("private scratch manufactured ambient Software control", err)
+			}
+		})
+	}
+}
+
+func TestX86X87ScopedRoundingScratchReplayAndStorageBoundaries(t *testing.T) {
+	row := x86ScopedRoundingCases()[0]
+	for _, mutation := range []string{"none", "frame", "argument-extent", "symbol", "operand", "literal"} {
+		t.Run(mutation, func(t *testing.T) {
+			file, err := Parse(ArchAMD64, row.source)
+			if err != nil {
+				t.Fatal(err)
+			}
+			function := file.Funcs[0]
+			switch mutation {
+			case "frame":
+				function.FrameSize = 4
+			case "argument-extent":
+				function.ArgSize = 32
+			case "symbol":
+				function.Sym = "·Another"
+			case "operand":
+				function.Instrs[2].Args[0].Mem.Off = -4
+			case "literal":
+				function.Instrs[2].Raw = "FSTCW -4(SP)"
+			}
+			extent, recognized := x86X87ScopedControlScratchExtent(function, "386")
+			if mutation == "none" {
+				if !recognized || extent != 4 {
+					t.Fatal("complete unchanged scope lost its private word", extent, recognized)
+				}
+				if _, err := x86ResultAUTOExtent(function, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("physical scratch manufactured a standalone logical AUTO frame", err)
+				}
+				resolve := func(name string) string { return strings.TrimPrefix(name, "·") }
+				pkg := mustGoPackage(t, "rounding", "package rounding\n"+row.declaration)
+				sigs, err := goSigsForAsmFile(pkg, file, resolve, "386", nil, nil, nil)
+				if err != nil {
+					t.Fatal(err)
+				}
+				consumer := newX86Ctx(new(strings.Builder), function, sigs[row.name], resolve, nil,
+					"386", "i686-pc-windows-msvc", false)
+				if err := consumer.scalarFPResultInitialized(); err != nil {
+					t.Fatal("complete scope failed its actual typed result proof", err)
+				}
+				if err := consumer.prepareLogicalAUTOStorage(); err != nil || consumer.logicalAUTOExtent != 0 || consumer.logicalAUTOBase != "" {
+					t.Fatal("scoped scratch acquired named AUTO storage", err)
+				}
+				consumer.frameSize = 4
+				if err := consumer.prepareLogicalAUTOStorage(); !errors.Is(err, ErrProbeNeedsContext) {
+					t.Fatal("changed emitter frame reused a source proof", err)
+				}
+			} else if recognized || extent != 0 {
+				t.Fatal("mutated parsed source retained a scratch role", extent, recognized)
+			}
+		})
+	}
+}
diff --git a/x86_x87_scoped_rounding_linux_amd64_test.go b/x86_x87_scoped_rounding_linux_amd64_test.go
new file mode 100644
index 000000000..9e608ec84
--- /dev/null
+++ b/x86_x87_scoped_rounding_linux_amd64_test.go
@@ -0,0 +1,312 @@
+//go:build linux && amd64
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"go/format"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// Only quiet NaNs are included: their sign/payload must survive this exact
+// FLD/FRNDINT/FSTP path. Signaling-NaN quieting is a different observation.
+var x86ScopedRoundingInputs = []uint64{
+	0, 0x8000000000000000, 1, 0x8000000000000001,
+	0x3fe0000000000000, 0xbfe0000000000000,
+	0x3ff8000000000000, 0xbff8000000000000,
+	0x4004000000000000, 0xc004000000000000,
+	0x400e000000000000, 0xc00e000000000000,
+	0x432fffffffffffff, 0xc32fffffffffffff,
+	0x4330000000000000, 0xc330000000000000,
+	0x7fefffffffffffff, 0xffefffffffffffff,
+	0x7ff0000000000000, 0xfff0000000000000,
+	0x7ff8000000000001, 0xfff8000000004321,
+}
+
+func TestCrossLinuxRuntimeMatrixX86X87ScopedRoundingOriginalGoAndLLVM(t *testing.T) {
+	x87IA32RequireNativeHost(t)
+	llc, _, found := findLlcAndClang(t)
+	compiler, compilerErr := exec.LookPath("i686-linux-gnu-gcc")
+	if !found || compilerErr != nil {
+		t.Fatal("scoped rounding requires LLVM22 and the static native i386 toolchain", compilerErr)
+	}
+	execution := x86FloatCompareExecution{llc: llc, triple: "i386-unknown-linux-gnu",
+		compiler: []string{compiler, "-static", "-no-pie", "-maccumulate-outgoing-args"}}
+	source, declarations := x86ScopedRoundingBundle(t)
+	rows := x86ScopedRoundingCases()
+	if len(rows) != 5*7*2 {
+		t.Fatal("native scope inventory must retain five spellings, seven GP registers and both word layouts", len(rows))
+	}
+	dir := t.TempDir()
+	goDriver, observers := x86ScopedRoundingOriginalDriver(t)
+	sources := map[string]string{
+		"go.mod": "module scopedrounding\n\ngo 1.20\n", "main.go": goDriver,
+		"rounding_386.s": source, "observe_386.s": observers,
+	}
+	for name, contents := range sources {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0600); err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("complete original input=%s sha256=%x", name, sha256.Sum256([]byte(contents)))
+	}
+	goTool, toolHash := x86LEAActualSDKDriver(t)
+	verifySource := func() {
+		for name, contents := range sources {
+			actual, err := os.ReadFile(filepath.Join(dir, name))
+			if err != nil || string(actual) != contents {
+				t.Fatal("complete original scoped-rounding source changed", name, err)
+			}
+		}
+		if actual, hash := x86LEAActualSDKDriver(t); actual != goTool || hash != toolHash {
+			t.Fatal("original scoped-rounding Go tool changed")
+		}
+	}
+	original := filepath.Join(dir, "original")
+	environment := append(os.Environ(), "GOENV=off", "GOWORK=off", "GOTOOLCHAIN=local",
+		"GOOS=linux", "GOARCH=386", "CGO_ENABLED=0", "GOFLAGS=", "GOEXPERIMENT=", "GOMAXPROCS=2")
+	verifySource()
+	output, err := x87IA32Capture(t, goTool, []string{"build", "-p=1", "-o", original, "."}, dir, environment)
+	if err != nil || len(output) != 0 {
+		t.Fatalf("complete original Go scoped-rounding build failed: %v\n%s", err, output)
+	}
+	run := func(path string, args ...string) []byte {
+		sealed, err := x87IA32StaticExecutable(path)
+		if err != nil {
+			t.Fatal("scoped rounding requires direct static ELF32 execution", err)
+		}
+		return x87IA32RunDirect(t, sealed, args, os.Environ())
+	}
+	verifySource()
+	records := run(original)
+	x86ScopedRoundingCheckRecords(t, records)
+	reference := filepath.Join(dir, "original.records")
+	if err := os.WriteFile(reference, records, 0600); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("actual original scoped-rounding records sha256=%x", sha256.Sum256(records))
+	verifyRecords := func() {
+		actual, err := os.ReadFile(reference)
+		if err != nil || string(actual) != string(records) {
+			t.Fatal("original scoped-rounding records changed", err)
+		}
+	}
+	want := fmt.Sprintf("scoped rounding original-Go/LLVM checks=%d\n", len(rows)*4*len(x86ScopedRoundingInputs))
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86X87InitializedWordAPI(t, source, declarations, "386", execution.triple, api, X87Hardware)
+			if err != nil || ir == "" {
+				t.Fatal("complete original scoped-rounding source cannot translate", api, err)
+			}
+			for _, optimized := range []bool{false, true} {
+				input := ir
+				if optimized {
+					input = x86MulDivRoundOptimize(t, input)
+				}
+				for _, level := range []string{"-O0", "-O2"} {
+					t.Run(fmt.Sprintf("IR_O2=%t/backend%s", optimized, level), func(t *testing.T) {
+						executable := execution.compileLLVM(t, "scoped-rounding", input, x86ScopedRoundingNativeDriver(), level)
+						verifySource()
+						verifyRecords()
+						if actual := run(executable, reference); string(actual) != want {
+							t.Fatal("scoped rounding values, CW, SP or complete inventory differ", string(actual))
+						}
+						verifyRecords()
+						verifySource()
+					})
+				}
+			}
+		})
+	}
+	x87IA32RequireNativeHost(t)
+}
+
+func x86ScopedRoundingOriginalDriver(t *testing.T) (string, string) {
+	t.Helper()
+	var driver, observers, calls strings.Builder
+	driver.WriteString("package main\nimport \"fmt\"\n")
+	observers.WriteString("#include \"funcdata.h\"\n")
+	for index, row := range x86ScopedRoundingCases() {
+		driver.WriteString(row.declaration)
+		fmt.Fprintf(&driver, "func Observe%d(input uint64, control uint32) (bits uint64, before, after uint32)\n", index)
+		fmt.Fprintf(&calls, "Observe%d,\n", index)
+		// A normal small split caller, not a new backing contract for the
+		// leaf: no SP rewriting, no source modification and no large reserve.
+		fmt.Fprintf(&observers, `TEXT ·Observe%d(SB),0,$32-28
+NO_LOCAL_POINTERS
+MOVL input+0(FP),AX
+MOVL input_hi+4(FP),DX
+MOVL AX,0(SP)
+MOVL DX,4(SP)
+FSTCW saved-2(SP)
+MOVL control+8(FP),CX
+MOVW CX,selected-4(SP)
+FLDCW selected-4(SP)
+FSTCW beforeCW-6(SP)
+CALL ·%s(SB)
+FSTCW afterCW-8(SP)
+FLDCW saved-2(SP)
+MOVL 8(SP),AX
+MOVL 12(SP),DX
+MOVL AX,bits+12(FP)
+MOVL DX,bits_hi+16(FP)
+MOVWLZX beforeCW-6(SP),AX
+MOVL AX,before+20(FP)
+MOVWLZX afterCW-8(SP),AX
+MOVL AX,after+24(FP)
+RET
+`, index, row.name)
+	}
+	driver.WriteString("func main() {\ninputs := []uint64{\n")
+	for _, input := range x86ScopedRoundingInputs {
+		fmt.Fprintf(&driver, "0x%016x,\n", input)
+	}
+	driver.WriteString("}\nfunctions := []func(uint64,uint32)(uint64,uint32,uint32){\n" + calls.String() + "}\n")
+	driver.WriteString(`for row, call := range functions {
+    for ambient := 0; ambient < 4; ambient++ {
+        control := uint32(0x037f | ambient<<10)
+        for _, input := range inputs {
+            value, before, after := call(input, control)
+            if before != control || after != control {
+                panic(fmt.Sprintf("original CW row=%d before=%04x after=%04x want=%04x", row,before,after,control))
+            }
+            fmt.Printf("%d %d %016x %04x %04x %016x\n", row,ambient,input,before,after,value)
+        }
+    }
+}
+}
+`)
+	formatted, err := format.Source([]byte(driver.String()))
+	if err != nil {
+		t.Fatal("original scoped-rounding driver is malformed", err)
+	}
+	return string(formatted), observers.String()
+}
+
+func x86ScopedRoundingCheckRecords(t *testing.T, records []byte) {
+	t.Helper()
+	lines := strings.Split(strings.TrimSuffix(string(records), "\n"), "\n")
+	want := len(x86ScopedRoundingCases()) * 4 * len(x86ScopedRoundingInputs)
+	if !strings.HasSuffix(string(records), "\n") || len(lines) != want {
+		t.Fatal("original scoped-rounding inventory is incomplete", len(lines), want)
+	}
+	index := 0
+	for row := range x86ScopedRoundingCases() {
+		for ambient := 0; ambient < 4; ambient++ {
+			for _, input := range x86ScopedRoundingInputs {
+				var actualRow, actualAmbient int
+				var actualInput, before, after, value uint64
+				count, err := fmt.Sscanf(lines[index], "%d %d %x %x %x %x", &actualRow, &actualAmbient, &actualInput, &before, &after, &value)
+				control := uint64(0x037f | ambient<<10)
+				canonical := fmt.Sprintf("%d %d %016x %04x %04x %016x", row, ambient, input, control, control, value)
+				if err != nil || count != 6 || actualRow != row || actualAmbient != ambient || actualInput != input ||
+					before != control || after != control || lines[index] != canonical {
+					t.Fatal("original record lost its exact input/control/order", index, lines[index], err)
+				}
+				index++
+			}
+		}
+	}
+}
+
+func x86ScopedRoundingNativeDriver() string {
+	var driver, functions, modes, inputs strings.Builder
+	driver.WriteString("#include <stdint.h>\n#include <stdio.h>\n#include <string.h>\n")
+	for _, row := range x86ScopedRoundingCases() {
+		fmt.Fprintf(&driver, "extern double %s(double);\n", row.name)
+		fmt.Fprintf(&functions, "%s,\n", row.name)
+		fmt.Fprintf(&modes, "%d,", row.mode)
+	}
+	for _, input := range x86ScopedRoundingInputs {
+		fmt.Fprintf(&inputs, "UINT64_C(0x%016x),\n", input)
+	}
+	driver.WriteString("static double (*const functions[])(double)={\n" + functions.String() + "};\n")
+	driver.WriteString("static const unsigned modes[]={" + modes.String() + "};\n")
+	driver.WriteString("static const uint64_t inputs[]={\n" + inputs.String() + "};\n")
+	driver.WriteString(`
+/* An integer IEEE-754 oracle: ambient x87 RC cannot change its arithmetic. */
+static uint64_t expected_bits(uint64_t bits, unsigned mode) {
+    const uint64_t sign=bits&UINT64_C(0x8000000000000000);
+    const uint64_t magnitude=bits&UINT64_C(0x7fffffffffffffff);
+    const unsigned exponent=(unsigned)(magnitude>>52);
+    if (!magnitude || exponent>=1075)
+        return bits; /* Also retain both infinities and quiet-NaN payloads. */
+    if (exponent<1023) {
+        const int increment=mode==0 ? magnitude>UINT64_C(0x3fe0000000000000) :
+            mode==1 ? sign!=0 : mode==2 ? sign==0 : 0;
+        return sign|(increment?UINT64_C(0x3ff0000000000000):0);
+    }
+    const unsigned shift=1075-exponent;
+    const uint64_t unit=UINT64_C(1)<<shift, fraction=magnitude&(unit-1);
+    uint64_t integer=magnitude&~(unit-1);
+    const int increment=mode==0 ? fraction>unit/2 ||
+        (fraction==unit/2 && ((integer>>shift)&1)) :
+        mode==1 ? fraction && sign : mode==2 ? fraction && !sign : 0;
+    if (increment)
+        integer+=unit;
+    return sign|integer;
+}
+
+static __attribute__((always_inline)) inline uintptr_t stack_pointer(void) {
+    uintptr_t value;
+    __asm__ volatile("movl %%esp,%0" : "=r"(value) : : "memory");
+    return value;
+}
+
+int main(int argc,char **argv) {
+    if (argc!=2) return 1;
+    FILE *reference=fopen(argv[1],"r");
+    if (!reference) return 2;
+    unsigned checks=0;
+    for (unsigned row=0;row<sizeof(functions)/sizeof(functions[0]);row++) {
+        for (unsigned ambient=0;ambient<4;ambient++) {
+            const uint16_t control=(uint16_t)(0x037f|(ambient<<10));
+            for (unsigned sample=0;sample<sizeof(inputs)/sizeof(inputs[0]);sample++) {
+                unsigned recorded_row,recorded_ambient,recorded_before,recorded_after;
+                unsigned long long recorded_input,recorded_value;
+                if (fscanf(reference,"%u %u %llx %x %x %llx",
+                    &recorded_row,&recorded_ambient,&recorded_input,
+                    &recorded_before,&recorded_after,&recorded_value)!=6) return 3;
+                const uint64_t want=expected_bits(inputs[sample],modes[row]);
+                if (recorded_row!=row || recorded_ambient!=ambient || recorded_input!=inputs[sample] ||
+                    recorded_before!=control || recorded_after!=control || recorded_value!=want) {
+                    fprintf(stderr,"original numerical/control mismatch row=%u ambient=%u sample=%u got=%016llx want=%016llx\n",
+                        row,ambient,sample,recorded_value,(unsigned long long)want);
+                    return 4;
+                }
+                double input;
+                memcpy(&input,&inputs[sample],sizeof(input));
+                uint16_t saved,before,after;
+                __asm__ volatile("fnstcw %0" : "=m"(saved) : : "memory");
+                __asm__ volatile("fldcw %0" : : "m"(control) : "memory");
+                __asm__ volatile("fnstcw %0" : "=m"(before) : : "memory");
+                const uintptr_t sp_before=stack_pointer();
+                volatile double value=functions[row](input);
+                const uintptr_t sp_after=stack_pointer();
+                __asm__ volatile("fnstcw %0" : "=m"(after) : : "memory");
+                __asm__ volatile("fldcw %0" : : "m"(saved) : "memory");
+                uint64_t bits;
+                memcpy(&bits,(const void *)&value,sizeof(bits));
+                if (bits!=want || before!=control || after!=control || sp_before!=sp_after) {
+                    fprintf(stderr,"LLVM numerical/CW/SP mismatch row=%u ambient=%u sample=%u got=%016llx want=%016llx CW=%04x/%04x\n",
+                        row,ambient,sample,(unsigned long long)bits,(unsigned long long)want,before,after);
+                    return 5;
+                }
+                checks++;
+            }
+        }
+    }
+    int trailing;
+    do { trailing=fgetc(reference); } while (trailing=='\n' || trailing==' ' || trailing=='\t');
+    const int complete=trailing==EOF && !ferror(reference);
+    if (fclose(reference) || !complete) return 6;
+    printf("scoped rounding original-Go/LLVM checks=%u\n",checks);
+    return 0;
+}
+`)
+	return driver.String()
+}
diff --git a/x86_x87_sdk_rounding_go127_test.go b/x86_x87_sdk_rounding_go127_test.go
new file mode 100644
index 000000000..90d38e8fc
--- /dev/null
+++ b/x86_x87_sdk_rounding_go127_test.go
@@ -0,0 +1,72 @@
+//go:build go1.27
+
+package plan9asm
+
+import (
+	"crypto/sha256"
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/xgo-dev/llvm"
+)
+
+func TestX86X87Mode32CompleteSDKRoundingObjects(t *testing.T) {
+	directory := filepath.Join(runtime.GOROOT(), "src", "math")
+	source, err := os.ReadFile(filepath.Join(directory, "floor_386.s"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	declarations, err := os.ReadFile(filepath.Join(directory, "floor_asm.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("complete SDK rounding assembly sha256=%x declarations sha256=%x",
+		sha256.Sum256(source), sha256.Sum256(declarations))
+	pkg := mustGoPackage(t, "math", string(declarations))
+	file, err := Parse(ArchAMD64, string(source))
+	if err != nil || len(file.Funcs) != 3 {
+		t.Fatal("complete SDK rounding source lost its three TEXTs", err)
+	}
+	names := []string{"archCeil", "archFloor", "archTrunc"}
+	for index, function := range file.Funcs {
+		if function.Sym != "·"+names[index] || function.FrameSize != 0 {
+			t.Fatal("the original zero-frame SDK source changed", function.Sym, function.FrameSize)
+		}
+	}
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete SDK rounding objects require LLVM22 llc")
+	}
+	for _, triple := range []string{
+		"i386-unknown-linux-gnu", "i686-pc-windows-msvc", "i686-w64-windows-gnu",
+	} {
+		t.Run(triple, func(t *testing.T) {
+			x86LEAActualTargetGoObject(t, "386", triple, string(source))
+			context := llvm.NewContext()
+			defer context.Dispose()
+			translated, err := translateGoModuleInContext(context, pkg, source, GoModuleOptions{
+				GOARCH: "386", TargetTriple: triple, ResolveSym: testResolveSym("math"),
+			})
+			if translated != nil && !translated.Module.IsNil() {
+				defer translated.Module.Dispose()
+			}
+			if err != nil || translated == nil || translated.Module.IsNil() {
+				t.Fatal("complete actual SDK rounding source cannot translate", err)
+			}
+			for _, name := range names {
+				function := translated.Module.NamedFunction("math." + name)
+				if function.IsNil() || function.IsDeclaration() || function.BasicBlocksCount() == 0 {
+					t.Fatal("complete SDK rounding module lost a definition", name)
+				}
+			}
+			if err := llvm.VerifyModule(translated.Module, llvm.ReturnStatusAction); err != nil {
+				t.Fatal(err)
+			}
+			for _, level := range []string{"-O0", "-O2"} {
+				x86PackedStringCompileObject(t, llc, triple, translated.Module.String(), level)
+			}
+		})
+	}
+}
diff --git a/x86_x87_tenbyte_obligation_test.go b/x86_x87_tenbyte_obligation_test.go
new file mode 100644
index 000000000..3f30f7adf
--- /dev/null
+++ b/x86_x87_tenbyte_obligation_test.go
@@ -0,0 +1,282 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"golang.org/x/arch/x86/x86asm"
+)
+
+// A dead ten-byte load remains an actual memory/input effect. FINIT or a
+// different typed instruction must not be needed to select its obligation.
+// This semantic RED is independent of the original-table formatter feature.
+func TestX86OfficialLegacyX87TenByteDeadInputsNeedContext(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, op := range []string{"FMOVB", "FMOVX"} {
+			source := "TEXT ·TenByte(SB),4,$0-0\n" + op + " (AX),F0\nRET\n"
+			goAssemblerOracleOutput(t, arch, source, "", true)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(arch+"/"+op+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, "func TenByte()", arch, testTargetTriple("linux", arch), api)
+					if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("X87_TEN_BYTE_INPUT_NOT_PROVED: dead BCD/extended load borrowed an unknown native address or x87 entry", err)
+					}
+				})
+			}
+		}
+	}
+}
+
+type x86X87TenByteFormat struct {
+	op            string
+	store         bool
+	opcode, digit byte
+}
+
+// Independent complete Go table axes: B/X times load versus store-and-pop.
+// This is a test oracle, not a production spelling or numerical permission.
+func x86X87TenByteFormats() []x86X87TenByteFormat {
+	var rows []x86X87TenByteFormat
+	for _, format := range []struct {
+		suffix        string
+		opcode, digit byte
+	}{
+		{"B", 0xdf, 4}, {"X", 0xdb, 5},
+	} {
+		for _, store := range []bool{false, true} {
+			op, digit := "FMOV"+format.suffix, format.digit
+			if store {
+				op += "P"
+				digit += 2
+			}
+			rows = append(rows, x86X87TenByteFormat{op, store, format.opcode, digit})
+		}
+	}
+	return rows
+}
+
+func (format x86X87TenByteFormat) instruction(address string) string {
+	if format.store {
+		return format.op + " F0," + address
+	}
+	return format.op + " " + address + ",F0"
+}
+
+func TestX86X87TenByteCompleteGoFormats(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, format := range x86X87TenByteFormats() {
+			for _, address := range []string{"(AX)", "7(AX)"} {
+				instruction := format.instruction(address)
+				t.Run(arch+"/"+instruction, func(t *testing.T) {
+					code := []byte{format.opcode, format.digit << 3}
+					if address == "7(AX)" {
+						code[1] |= 0x40
+						code = append(code, 7)
+					}
+					code = append(code, 0xc3)
+					actual := x86OrderingHintGoBytes(t, arch, "TEXT probe(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if !reflect.DeepEqual(actual, code) {
+						t.Fatal("actual complete Go ten-byte row differs", actual, code)
+					}
+					form, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, instruction), arch)
+					wantPop := uint8(0)
+					if format.store {
+						wantPop = 1
+					}
+					if !known || err != nil || form.memoryBytes() != 10 || form.push == format.store ||
+						form.spec.pop != wantPop {
+						t.Fatal("X87_TEN_BYTE_TYPED_FORMAT_FEATURE_GAP", instruction, known, err)
+					}
+				})
+			}
+			reversed := format.op + " F0,(AX)"
+			if format.store {
+				reversed = format.op + " (AX),F0"
+			}
+			for _, instruction := range []string{
+				reversed,
+				format.op + " AX,F0", format.op + " F1,(AX)", format.op + " (AX),F1",
+				format.instruction("(AX)") + ",F2", format.instruction("(AX)(CX*3)"),
+			} {
+				t.Run(arch+"/malformed/"+instruction, func(t *testing.T) {
+					file, err := Parse(ArchAMD64, "TEXT probe(SB),4,$0-0\n"+instruction+"\nRET\n")
+					if err != nil {
+						return
+					}
+					if _, known, err := x86X87ValueProperties(file.Funcs[0].Instrs[1], arch); !known || err == nil {
+						t.Fatal("malformed ten-byte shape escaped its complete typed family", known, err)
+					}
+				})
+			}
+		}
+	}
+}
+
+// A known pointer and logical F0 do not certify arbitrary packed BCD or
+// extended numerical conversion. Reject without revoking the unrelated cells,
+// prior control/status knownness, captured bits or the exact old state.
+func TestX86X87TenByteUnprovedPrecisionKeepsPriorState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		for _, format := range x86X87TenByteFormats() {
+			t.Run(arch+"/"+format.op, func(t *testing.T) {
+				state := x86ResultState{x87: &x86ResultX87State{slots: 3, depth: 2, status: 0x4500,
+					word: &x86ResultX87WordState{control: 0xffff}}}
+				state.pointerGP[0] = true
+				state.x87.integer[1], state.x87.gp[3] = 4, 0x4000
+				before := state.clone()
+				accepted, known := x86ResultX87ValueStepWithMemory(x86X87ValueInstruction(t, format.instruction("(AX)")),
+					&state, nil, 0, arch, false, true)
+				if accepted || !known || !reflect.DeepEqual(before, state) {
+					t.Fatal("X87_TEN_BYTE_UNPROVED_VALUE_OR_STATE_WIDENED", accepted, known)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87TenByteDefinedInputsDoNotGrantNumericalPrecision(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		move, word := "MOVQ", 8
+		if arch == "386" {
+			move, word = "MOVL", 4
+		}
+		for _, format := range x86X87TenByteFormats() {
+			for _, pointer := range []bool{false, true} {
+				body := "FINIT\n"
+				if pointer {
+					body += move + " p+0(FP),AX\n"
+				}
+				if format.store {
+					body += "FLDPI\n"
+				}
+				body += format.instruction("(AX)") + "\nFINIT\nRET\n"
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word, body)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/pointer=%t/%s", arch, format.op, pointer, api), func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[10]byte)", arch, testTargetTriple("linux", arch), api)
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+							t.Fatal("X87_TEN_BYTE_DEFINED_INPUT_IS_NOT_PRECISION", err, source)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87TenByteRawAliasObservationAndInputBoundary(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		mode, move, word := 64, "MOVQ", 8
+		if arch == "386" {
+			mode, move, word = 32, "MOVL", 4
+		}
+		for _, row := range []struct {
+			code  []byte
+			store bool
+			op    x86asm.Op
+		}{
+			{[]byte{0xdf, 0x20}, false, x86asm.FBLD}, {[]byte{0xdf, 0x30}, true, x86asm.FBSTP},
+			{[]byte{0xdb, 0x28}, false, x86asm.FLD}, {[]byte{0xdb, 0x38}, true, x86asm.FSTP},
+		} {
+			t.Run(fmt.Sprintf("%s/%x", arch, row.code), func(t *testing.T) {
+				decoded, err := x86asm.Decode(row.code, mode)
+				// x/arch v0.14.0 omits all M80 forms from its MemBytes table.
+				// Preserve that actual metadata; the original opcode/ModRM tuple
+				// above establishes the ten-byte format independently.
+				base := x86asm.RAX
+				if arch == "386" {
+					base = x86asm.EAX
+				}
+				if err != nil || decoded.Op != row.op || decoded.Len != len(row.code) || decoded.MemBytes != 0 ||
+					decoded.Args[0] != (x86asm.Mem{Base: base}) || decoded.Args[1] != nil {
+					t.Fatalf("original raw decoder observation: %+v, MemBytes=%d, args=%v, err=%v", decoded, decoded.MemBytes, decoded.Args, err)
+				}
+				var raw strings.Builder
+				for _, code := range row.code {
+					fmt.Fprintf(&raw, "BYTE $0x%02x\n", code)
+				}
+				body := fmt.Sprintf("FINIT\n%s p+0(FP),AX\n", move)
+				if row.store {
+					body += "FLDPI\n"
+				}
+				body += raw.String()
+				body += "FINIT\nRET\n"
+				source := fmt.Sprintf("TEXT ·Value(SB),4,$0-%d\n%s", word, body)
+				goAssemblerOracleOutput(t, arch, source, "", true)
+				original, err := Parse(ArchAMD64, "TEXT ·Raw(SB),4,$0-0\n"+raw.String()+"RET\n")
+				if err != nil {
+					t.Fatal(err)
+				}
+				normalized, err := normalizeX86RawFile(original, arch)
+				if err != nil {
+					t.Fatal("exact decoded source normalization prerequisite", decoded.Op, err)
+				}
+				var opcode Op
+				found := 0
+				for _, ins := range normalized.Funcs[0].Instrs {
+					if ins.x86SourceRaw == nil {
+						continue
+					}
+					found++
+					opcode = ins.Op
+					before := ins
+					before.Args = append([]Operand(nil), ins.Args...)
+					origin := *ins.x86SourceRaw
+					origin.args = append([]Operand(nil), origin.args...)
+					before.x86SourceRaw = &origin
+					if origin.op != ins.Op || !reflect.DeepEqual(origin.args, ins.Args) || origin.addressBits != ins.x86AddressBits {
+						t.Fatal("normalized raw identity differs", row.code, ins)
+					}
+					t.Run("typed", func(t *testing.T) {
+						form, known, err := x86X87ValueProperties(ins, arch)
+						if row.op == x86asm.FBLD || row.op == x86asm.FBSTP {
+							if len(ins.Args) != 1 {
+								t.Fatal("BCD decoder alias lost its single original memory operand", row.code, ins)
+							}
+							wantPop := uint8(0)
+							if row.store {
+								wantPop = 1
+							}
+							if !known || err != nil || form.memoryBytes() != 10 || form.push == row.store || form.spec.pop != wantPop {
+								t.Fatal("X87_TEN_BYTE_RAW_TYPED_ALIAS_FEATURE_GAP", row.code, known, err)
+							}
+							memory, f0 := ins.Args[0], Operand{Kind: OpReg, Reg: "F0"}
+							wantSource, wantDestination := memory, f0
+							if row.store {
+								wantSource, wantDestination = f0, memory
+							}
+							if !reflect.DeepEqual(form.source, wantSource) || !reflect.DeepEqual(form.destination, wantDestination) {
+								t.Fatal("derived typed alias changed exact source/destination", row.code, form)
+							}
+							if !x86TypedFPResultNeedsProof(normalized.Funcs[0], FuncSig{Name: "Raw", Ret: Void}, arch) {
+								t.Fatal("X87_TEN_BYTE_RAW_VOID_OBLIGATION_MISSING", row.code)
+							}
+						} else if opcode != "FLD" && opcode != "FSTP" {
+							t.Fatal("extended decoder boundary acquired an invented source alias", row.code, opcode)
+						}
+					})
+					if !reflect.DeepEqual(before, ins) {
+						t.Fatal("typed alias query changed original raw source", row.code)
+					}
+				}
+				if found != 1 {
+					t.Fatal("exact two-byte raw source did not retain one decoded instruction", row.code, found)
+				}
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, source, "func Value(p *[10]byte)", arch, testTargetTriple("linux", arch), api)
+						unsupported := (opcode == "FLD" || opcode == "FSTP") && err != nil &&
+							strings.HasSuffix(err.Error(), "amd64: unsupported instruction "+string(opcode))
+						if ir != "" || !errors.Is(err, ErrProbeNeedsContext) && !unsupported {
+							t.Fatal("X87_TEN_BYTE_RAW_REJECTION_CLASS_DIFFERS", opcode, err)
+						}
+						t.Logf("raw source retained: code=%x decoder=%s memory=%d; no numerical/native claim: %v", row.code, decoded.Op, decoded.MemBytes, err)
+					})
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_value_flow_test.go b/x86_x87_value_flow_test.go
new file mode 100644
index 000000000..3f76eadc5
--- /dev/null
+++ b/x86_x87_value_flow_test.go
@@ -0,0 +1,258 @@
+package plan9asm
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"testing"
+)
+
+type x86X87ValueFixture struct {
+	name, body string
+	want       float64
+	bits       uint64
+	bitResult  bool
+}
+
+// All parameters have their actual classic 386 scalar layout. The first
+// source half forces the existing byte-view/whole-source consumer to run;
+// neither a mnemonic nor a floating declaration authenticates an x87 input.
+const x86X87ValueDeclaration = "func Value(gate uint64, f float32, d float64, w int16, l int32) float64"
+
+func x86X87ValueSource(body string) string {
+	return "TEXT ·Value(SB),4,$0-36\nMOVL gate+4(FP),AX\n" + body + "RET\n"
+}
+
+func x86X87ValueFixturesThreeAPIs(t *testing.T, fixtures []x86X87ValueFixture) {
+	t.Helper()
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range fixtures {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, x86X87ValueSource(row.body), x86X87ValueDeclaration,
+						target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("complete typed logical x87 value flow did not close", err)
+					}
+					probe := "\ndefine i64 @Probe() {\n" +
+						" %r = call double @Value(i64 0, float 2.000000e+00, double 4.000000e+00, i16 2, i32 2)\n" +
+						" %b = bitcast double %r to i64\n ret i64 %b\n}\n"
+					want := row.bits
+					if !row.bitResult {
+						want = math.Float64bits(row.want)
+					}
+					// This is optimized logical-double evidence, not execution of
+					// physical x87, its control word, exceptions or 80-bit values.
+					x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{want})
+				})
+			}
+		}
+	}
+}
+
+func TestX86X87FloatingMovesConstantsAndUnaryValueFlow(t *testing.T) {
+	rows := []x86X87ValueFixture{
+		{name: "FMOVD/memory-push", body: "FMOVD d+12(FP),F0\nFMOVDP F0,ret+28(FP)\n", want: 4},
+		{name: "FMOVF/memory-push", body: "FMOVF f+8(FP),F0\nFMOVDP F0,ret+28(FP)\n", want: 2},
+		{name: "FMOVD/memory-store", body: "FLD1\nFMOVD F0,ret+28(FP)\nFMOVDP F0,F0\n", want: 1},
+		{name: "FMOVDP/memory-store-pop", body: "FLD1\nFMOVDP F0,ret+28(FP)\n", want: 1},
+		{name: "FMOVF/memory-store", body: "FLD1\nFMOVF F0,ret+28(FP)\nMOVL $0,ret+32(FP)\nFMOVDP F0,F0\n", bits: 0x3f800000, bitResult: true},
+		{name: "FMOVFP/memory-store-pop", body: "FLD1\nFMOVFP F0,ret+28(FP)\nMOVL $0,ret+32(FP)\n", bits: 0x3f800000, bitResult: true},
+		{name: "FABS", body: "FLD1\nFCHS\nFABS\nFMOVDP F0,ret+28(FP)\n", want: 1},
+		{name: "FCHS", body: "FLD1\nFCHS\nFMOVDP F0,ret+28(FP)\n", want: -1},
+		{name: "FSQRT", body: "FMOVD d+12(FP),F0\nFSQRT\nFMOVDP F0,ret+28(FP)\n", want: 2},
+	}
+	for _, constant := range []struct {
+		op   string
+		want float64
+	}{
+		{"FLD1", 1}, {"FLDL2E", math.Log2E}, {"FLDL2T", math.Log2E * math.Ln10},
+		{"FLDLG2", math.Log10E * math.Ln2}, {"FLDLN2", math.Ln2}, {"FLDPI", math.Pi}, {"FLDZ", 0},
+	} {
+		rows = append(rows, x86X87ValueFixture{
+			name: constant.op, body: constant.op + "\nFMOVDP F0,ret+28(FP)\n", want: constant.want,
+		})
+	}
+	for lane := 1; lane < 8; lane++ {
+		// Every referenced ST(i) is source-defined. The two exchange rows
+		// and both store rows use their own exact operand direction.
+		push := strings.Repeat("FLD1\n", lane) + "FMOVD d+12(FP),F0\n"
+		for _, instruction := range []string{
+			fmt.Sprintf("FXCHD F0,F%d", lane), fmt.Sprintf("FXCHD F%d,F0", lane),
+		} {
+			rows = append(rows, x86X87ValueFixture{
+				name: instruction, want: 1,
+				body: push + instruction + "\nFMOVDP F0,ret+28(FP)\n" + strings.Repeat("FMOVDP F0,F0\n", lane),
+			})
+		}
+		for _, op := range []string{"FMOVD", "FMOVDP"} {
+			// Store 4 into an already authored destination, then pop each
+			// shallower value before observing that exact destination.
+			pops := lane
+			if op == "FMOVDP" {
+				pops--
+			}
+			rows = append(rows, x86X87ValueFixture{
+				name: fmt.Sprintf("%s/F0-to-F%d", op, lane), want: 4,
+				body: push + fmt.Sprintf("%s F0,F%d\n", op, lane) +
+					strings.Repeat("FMOVDP F0,F0\n", pops) + "FMOVDP F0,ret+28(FP)\n",
+			})
+		}
+	}
+	x86X87ValueFixturesThreeAPIs(t, rows)
+}
+
+func TestX86X87ArithmeticCompleteValueDependencies(t *testing.T) {
+	var rows []x86X87ValueFixture
+	for _, operation := range []struct {
+		stem             string
+		memory2, memory4 float64
+		regToF0, f0ToReg float64
+		alias            float64
+	}{
+		{"FADD", 3, 5, 5, 5, 2},
+		{"FMUL", 2, 4, 4, 4, 1},
+		{"FSUB", -1, -3, -3, 3, 0},
+		{"FSUBR", 1, 3, 3, -3, 0},
+		{"FDIV", 0.5, 0.25, 0.25, 4, 1},
+		{"FDIVR", 2, 4, 4, 0.25, 1},
+	} {
+		for _, source := range []struct{ suffix, operand string }{
+			{"W", "w+20(FP)"}, {"L", "l+24(FP)"}, {"F", "f+8(FP)"}, {"D", "d+12(FP)"},
+		} {
+			want := operation.memory2
+			if source.suffix == "D" {
+				want = operation.memory4
+			}
+			op := operation.stem + source.suffix
+			rows = append(rows, x86X87ValueFixture{
+				name: op + "/memory", want: want,
+				body: "FLD1\n" + op + " " + source.operand + ",F0\nFMOVDP F0,ret+28(FP)\n",
+			})
+		}
+		for _, source := range []struct {
+			form, instruction, tail string
+			want                    float64
+		}{
+			{"D/reg-to-F0", operation.stem + "D F1,F0\n", "FMOVDP F0,ret+28(FP)\nFMOVDP F0,F0\n", operation.regToF0},
+			{"D/F0-to-reg", operation.stem + "D F0,F1\n", "FMOVDP F0,F0\nFMOVDP F0,ret+28(FP)\n", operation.f0ToReg},
+			{"DP/F0-to-reg", operation.stem + "DP F0,F1\n", "FMOVDP F0,ret+28(FP)\n", operation.f0ToReg},
+		} {
+			rows = append(rows, x86X87ValueFixture{
+				name: operation.stem + source.form, want: source.want,
+				body: "FMOVD d+12(FP),F0\nFLD1\n" + source.instruction + source.tail,
+			})
+		}
+		for _, suffix := range []string{"D", "DP"} {
+			tail := "FMOVDP F0,ret+28(FP)\n"
+			push := "FLD1\n"
+			want := operation.alias
+			if suffix == "DP" {
+				push = "FLD1\nFLD1\n"
+				// F0,F0 writes the old top, then pops it. The next original
+				// cell is still 1, independent of the discarded arithmetic.
+				want = 1
+			}
+			rows = append(rows, x86X87ValueFixture{
+				name: operation.stem + suffix + "/F0-alias", want: want,
+				body: push + operation.stem + suffix + " F0,F0\n" + tail,
+			})
+		}
+	}
+	x86X87ValueFixturesThreeAPIs(t, rows)
+}
+
+func x86X87StatusResultStores(mask uint16) string {
+	return fmt.Sprintf("FSTSW AX\nANDW $%d,AX\nMOVW AX,ret+28(FP)\nMOVW $0,ret+30(FP)\nMOVL $0,ret+32(FP)\n", mask)
+}
+
+func TestX86X87CompareAndStatusNeedIndependentDefinedBits(t *testing.T) {
+	var rows []x86X87ValueFixture
+	for _, form := range []struct {
+		op, operand string
+		pops        int
+	}{
+		{"FCOMW", "w+20(FP),F0", 0}, {"FCOMWP", "w+20(FP),F0", 1},
+		{"FCOML", "l+24(FP),F0", 0}, {"FCOMLP", "l+24(FP),F0", 1},
+		{"FCOMF", "f+8(FP),F0", 0}, {"FCOMFP", "f+8(FP),F0", 1},
+		{"FCOMD", "d+12(FP),F0", 0}, {"FCOMDP", "d+12(FP),F0", 1},
+		{"FCOMDPP", "F0,F1", 2},
+		{"FUCOM", "F0,F1", 0}, {"FUCOMP", "F0,F1", 1}, {"FUCOMPP", "F0,F1", 2},
+	} {
+		// The source-created stack is [1,4]. Every compare observes 1<rhs;
+		// the two-pop row intentionally uses its actual F1 encoding.
+		rows = append(rows, x86X87ValueFixture{
+			name: form.op, bits: 0x100, bitResult: true,
+			body: "FMOVD d+12(FP),F0\nFLD1\n" + form.op + " " + form.operand + "\n" +
+				x86X87StatusResultStores(0x4500) + strings.Repeat("FMOVDP F0,F0\n", 2-form.pops),
+		})
+	}
+	for _, op := range []string{"FCOMI", "FCOMIP", "FUCOMI", "FUCOMIP"} {
+		operands := "F1,F0"
+		if strings.HasPrefix(op, "FUCOM") {
+			operands = "F0,F1"
+		}
+		body := "FMOVD d+12(FP),F0\nFLD1\n" + op + " " + operands + "\n"
+		for offset, condition := range []string{"EQ", "CS", "PS", "OS", "MI", "LT"} {
+			// LT=SF xor OF also checks both architecturally cleared flags.
+			body += fmt.Sprintf("SET%s AX\nMOVB AX,ret+%d(FP)\n", condition, 28+offset)
+		}
+		body += "MOVW $0,ret+34(FP)\n"
+		pops := 2
+		if strings.HasSuffix(op, "IP") {
+			pops--
+		}
+		rows = append(rows, x86X87ValueFixture{
+			name: op, body: body + strings.Repeat("FMOVDP F0,F0\n", pops), bits: 0x100, bitResult: true,
+		})
+	}
+	for _, source := range []struct {
+		name, body string
+		status     uint16
+	}{
+		{"zero", "FLDZ\n", 0x4000}, {"positive", "FLD1\n", 0}, {"negative", "FLD1\nFCHS\n", 0x100},
+		{"negative-zero", "FLDZ\nFCHS\n", 0x4000},
+		{"unordered", "FLDZ\nFLDZ\nFDIVDP F0,F1\n", 0x4500},
+	} {
+		for _, mask := range []uint16{0, 0x100, 0x400, 0x4000, 0x4500} {
+			rows = append(rows, x86X87ValueFixture{
+				name: fmt.Sprintf("FTST/%s/mask-%04x", source.name, mask), bits: uint64(source.status & mask), bitResult: true,
+				body: source.body + "FTST\n" + x86X87StatusResultStores(mask) + "FMOVDP F0,F0\n",
+			})
+		}
+	}
+	x86X87ValueFixturesThreeAPIs(t, rows)
+}
+
+// Register-source FMOVD selects Go's FLD ST(i) row, including the ambiguous
+// F0,F0 spelling. A following pop must reveal the previous top, not an entry
+// alloca's initial zero. This root does not use the new byte-view trigger, so
+// its wrong-value counterexample remains separate from missing x87 proof.
+func TestX86X87RegisterFloatingLoadUsesActualGoPush(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, row := range []struct {
+			name, body string
+		}{
+			{"F0-alias", "FLD1\nFMOVD F0,F0\nFMOVDP F0,F0\nFMOVDP F0,ret+0(FP)\n"},
+			{"F1-source", "FLDZ\nFLD1\nFMOVD F1,F0\nFMOVDP F0,F0\nFMOVDP F0,ret+0(FP)\nFMOVDP F0,F0\n"},
+		} {
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(target.triple+"/"+row.name+"/"+api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, "TEXT ·Value(SB),4,$0-8\n"+row.body+"RET\n",
+						"func Value() float64", target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("logical register-load fixture did not translate", err)
+					}
+					probe := "\ndefine i64 @Probe() {\n %r = call double @Value()\n %b = bitcast double %r to i64\n ret i64 %b\n}\n"
+					x86ScalarFPNamedConstantResult(t, ir+probe, "Probe", []uint64{0x3ff0000000000000})
+				})
+			}
+		}
+	}
+}
diff --git a/x86_x87_value_forms.go b/x86_x87_value_forms.go
new file mode 100644
index 000000000..cb2b080d7
--- /dev/null
+++ b/x86_x87_value_forms.go
@@ -0,0 +1,317 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86X87ValueKind uint8
+
+const (
+	x86X87FloatMove x86X87ValueKind = iota
+	x86X87Constant
+	x86X87Unary
+	x86X87Exchange
+	x86X87Arithmetic
+	x86X87Compare
+	x86X87Test
+	x86X87Status
+	x86X87IntegerMove
+	x86X87Round
+	x86X87ConditionalMove
+)
+
+type x86X87ValueSpec struct {
+	kind        x86X87ValueKind
+	width       byte // W/L/V signed integer memory, F/D floating memory, B/X ten-byte format.
+	stem        string
+	pop         uint8
+	reverse     bool
+	directFlags bool
+	flags       uint8 // Required integer predicates; FCMOV preserves those flags.
+}
+
+// These are value-availability forms, not a physical x87 entry/control-word,
+// native-memory or caller-state contract. The Go rows are shared by both x86
+// modes. BCD/extended forms retain input obligations but no numerical value
+// permission. Environment and transcendental state remain independent.
+var x86X87ValueSpecs = func() map[Op]x86X87ValueSpec {
+	forms := map[Op]x86X87ValueSpec{
+		"FMOVD":   {kind: x86X87FloatMove, width: 'D'},
+		"FMOVDP":  {kind: x86X87FloatMove, width: 'D', pop: 1},
+		"FMOVF":   {kind: x86X87FloatMove, width: 'F'},
+		"FMOVFP":  {kind: x86X87FloatMove, width: 'F', pop: 1},
+		"FMOVB":   {kind: x86X87FloatMove, width: 'B'},
+		"FMOVBP":  {kind: x86X87FloatMove, width: 'B', pop: 1},
+		"FMOVX":   {kind: x86X87FloatMove, width: 'X'},
+		"FMOVXP":  {kind: x86X87FloatMove, width: 'X', pop: 1},
+		"FXCHD":   {kind: x86X87Exchange},
+		"FTST":    {kind: x86X87Test},
+		"FSTSW":   {kind: x86X87Status},
+		"FMOVW":   {kind: x86X87IntegerMove, width: 'W'},
+		"FMOVWP":  {kind: x86X87IntegerMove, width: 'W', pop: 1},
+		"FMOVL":   {kind: x86X87IntegerMove, width: 'L'},
+		"FMOVLP":  {kind: x86X87IntegerMove, width: 'L', pop: 1},
+		"FMOVV":   {kind: x86X87IntegerMove, width: 'V'},
+		"FMOVVP":  {kind: x86X87IntegerMove, width: 'V', pop: 1},
+		"FRNDINT": {kind: x86X87Round},
+	}
+	for _, op := range []Op{"FLD1", "FLDL2E", "FLDL2T", "FLDLG2", "FLDLN2", "FLDPI", "FLDZ"} {
+		forms[op] = x86X87ValueSpec{kind: x86X87Constant}
+	}
+	for _, op := range []Op{"FABS", "FCHS", "FSQRT"} {
+		forms[op] = x86X87ValueSpec{kind: x86X87Unary}
+	}
+	for _, row := range []struct {
+		ops   []Op
+		flags uint8
+	}{
+		{[]Op{"FCMOVCC", "FCMOVCS", "FCMOVB", "FCMOVNB"}, x86ByteFlagCF},
+		{[]Op{"FCMOVEQ", "FCMOVE", "FCMOVNE"}, x86ByteFlagZF},
+		{[]Op{"FCMOVHI", "FCMOVLS", "FCMOVBE", "FCMOVNBE"}, x86ByteFlagCF | x86ByteFlagZF},
+		{[]Op{"FCMOVNU", "FCMOVU", "FCMOVUN"}, x86ByteFlagPF},
+	} {
+		for _, op := range row.ops {
+			forms[op] = x86X87ValueSpec{kind: x86X87ConditionalMove, flags: row.flags}
+		}
+	}
+	for _, stem := range []string{"FADD", "FMUL", "FSUB", "FSUBR", "FDIV", "FDIVR"} {
+		for _, suffix := range []string{"W", "L", "F", "D", "DP"} {
+			spec := x86X87ValueSpec{kind: x86X87Arithmetic, width: suffix[0], stem: stem,
+				reverse: stem == "FSUBR" || stem == "FDIVR"}
+			if suffix == "DP" {
+				spec.pop = 1
+			}
+			forms[Op(stem+suffix)] = spec
+		}
+	}
+	for _, row := range []struct {
+		op    Op
+		width byte
+		pop   uint8
+	}{
+		{"FCOMW", 'W', 0}, {"FCOMWP", 'W', 1},
+		{"FCOML", 'L', 0}, {"FCOMLP", 'L', 1},
+		{"FCOMF", 'F', 0}, {"FCOMFP", 'F', 1},
+		{"FCOMD", 'D', 0}, {"FCOMDP", 'D', 1}, {"FCOMDPP", 'D', 2},
+		{"FCOMI", 'D', 0}, {"FCOMIP", 'D', 1},
+		{"FUCOM", 'D', 0}, {"FUCOMP", 'D', 1}, {"FUCOMPP", 'D', 2},
+		{"FUCOMI", 'D', 0}, {"FUCOMIP", 'D', 1},
+	} {
+		forms[row.op] = x86X87ValueSpec{kind: x86X87Compare, width: row.width, pop: row.pop,
+			directFlags: row.op == "FCOMI" || row.op == "FCOMIP" || row.op == "FUCOMI" || row.op == "FUCOMIP"}
+	}
+	return forms
+}()
+
+// Decoder spellings share the original BCD format. This projection neither
+// rewrites the instruction nor grants a raw source or numerical entry role.
+func x86X87ValueSpecForName(name Op) (x86X87ValueSpec, bool) {
+	switch name {
+	case "FBLD":
+		name = "FMOVB"
+	case "FBSTP":
+		name = "FMOVBP"
+	}
+	spec, known := x86X87ValueSpecs[name]
+	return spec, known
+}
+
+type x86X87ValueForm struct {
+	spec                x86X87ValueSpec
+	source, destination Operand
+	left, right         Operand // Ordered comparison dependencies, independent of spelling.
+	push                bool
+	unprovedEncoding    bool // Go's documented botch row is not a NUM/effect witness.
+}
+
+func (form x86X87ValueForm) memoryBytes() int64 {
+	switch form.spec.width {
+	case 'W':
+		return 2
+	case 'L', 'F':
+		return 4
+	case 'D', 'V':
+		return 8
+	case 'B', 'X':
+		return 10
+	}
+	return 0
+}
+
+// One actual instruction head selects the complete Go form. Source FLOAT
+// rewrites are validated separately from the underlying memory encoding; a
+// resolved integer immediate is not an x87 memory value.
+func x86X87ValueProperties(ins Instr, arch string) (x86X87ValueForm, bool, error) {
+	name, suffix, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	spec, known := x86X87ValueSpecForName(Op(name))
+	if !known {
+		return x86X87ValueForm{}, false, nil
+	}
+	form := x86X87ValueForm{spec: spec}
+	fail := func(reason string) (x86X87ValueForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, ins.Op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted || suffix != "" {
+		return fail("is outside the Go x87 value mode/suffix grammar")
+	}
+	for _, operand := range ins.Args {
+		// Ym's scalar address grammar is independent of MUL's numerical
+		// effects or conditional native-read role.
+		if err := x86NamedMultiplyMemoryError(operand, arch); err != nil {
+			return fail(err.Error())
+		}
+	}
+	memory := func(operand Operand) bool {
+		if !isX87MemoryOperand(operand) {
+			return false
+		}
+		if operand.Kind == OpSym {
+			symbol := strings.TrimSpace(operand.Sym)
+			_, integer := parseInt(symbol)
+			return !strings.HasPrefix(symbol, "$") && (strings.HasSuffix(symbol, "(SB)") || integer == nil)
+		}
+		return true
+	}
+	constant := func(operand Operand) bool {
+		return operand.Kind == OpImm && (spec.width == 'F' || spec.width == 'D') &&
+			x86FloatArithmeticLiteral(ins, true, true)
+	}
+	register := func(operand Operand) bool {
+		_, valid := x87OperandReg(operand)
+		return valid
+	}
+	if spec.kind == x86X87Constant || spec.kind == x86X87Unary || spec.kind == x86X87Test || spec.kind == x86X87Round {
+		if len(ins.Args) != 0 {
+			return fail("takes no operands")
+		}
+		return form, true, nil
+	}
+	if spec.kind == x86X87Status {
+		word, _, err := x86X87WordProperties(ins, arch)
+		form.destination = word.operand
+		return form, true, err
+	}
+	operands := ins.Args
+	decoderMemoryAlias := name == "FBLD" || name == "FBSTP"
+	if decoderMemoryAlias {
+		if len(operands) != 1 {
+			return fail("expects its original decoder memory operand")
+		}
+		f0 := Operand{Kind: OpReg, Reg: "F0"}
+		if spec.pop != 0 {
+			operands = []Operand{f0, operands[0]}
+		} else {
+			operands = []Operand{operands[0], f0}
+		}
+	}
+	if len(operands) != 2 {
+		switch spec.kind {
+		case x86X87Compare:
+			return fail("expects lhs, rhs")
+		case x86X87Exchange:
+			return fail("expects Fsrc, Fdst")
+		case x86X87FloatMove:
+			if spec.pop != 0 {
+				return fail("expects F0 source and memory or x87-register destination")
+			}
+		}
+		return fail("expects src, dst")
+	}
+	first, last := operands[0], operands[1]
+	form.source, form.destination = first, last
+	switch spec.kind {
+	case x86X87ConditionalMove:
+		if !register(first) || !isX87F0(last) {
+			return fail("expects x87-register source and F0 destination")
+		}
+	case x86X87IntegerMove:
+		if spec.pop != 0 {
+			if !isX87F0(first) || !memory(last) {
+				return fail("expects F0 source and signed integer memory destination")
+			}
+			return form, true, nil
+		}
+		if memory(first) && isX87F0(last) {
+			form.push = true
+			return form, true, nil
+		}
+		// yfmvx has only the m64 load row; Go has no non-pop FIST m64.
+		if spec.width != 'V' && isX87F0(first) && memory(last) {
+			return form, true, nil
+		}
+		return fail("expects signed integer memory,F0 or the registered F0,memory store row")
+	case x86X87FloatMove:
+		loadShape := "memory,F0, Freg,F0, F0,memory, or F0,Freg"
+		storeShape := "F0 source and memory or x87-register destination"
+		if form.memoryBytes() == 10 {
+			loadShape, storeShape = "memory source and F0 destination", "F0 source and memory destination"
+			if decoderMemoryAlias {
+				loadShape, storeShape = "memory source", "memory destination"
+			}
+		}
+		if spec.pop != 0 {
+			if !isX87F0(first) || !(memory(last) || spec.width == 'D' && register(last)) {
+				return fail("expects " + storeShape)
+			}
+			return form, true, nil
+		}
+		if isX87F0(last) && (memory(first) || constant(first) || spec.width == 'D' && register(first)) {
+			// yfmvd's Yrf,Yf0 row is FLD ST(i), before its overlapping
+			// Yf0,Yrf store row. F0,F0 therefore pushes as well.
+			form.push = true
+			return form, true, nil
+		}
+		if (spec.width == 'F' || spec.width == 'D') && isX87F0(first) && (memory(last) || spec.width == 'D' && register(last)) {
+			return form, true, nil
+		}
+		return fail("expects " + loadShape)
+	case x86X87Exchange:
+		if !register(first) || !register(last) || !isX87F0(first) && !isX87F0(last) {
+			return fail("expects x87 registers with one F0 operand")
+		}
+	case x86X87Arithmetic:
+		if spec.pop != 0 {
+			if !isX87F0(first) || !register(last) {
+				return fail("expects F0 source and x87-register destination")
+			}
+		} else if spec.width == 'D' {
+			if !(isX87F0(last) && (memory(first) || constant(first) || register(first)) || isX87F0(first) && register(last)) {
+				return fail("expects memory,F0, Freg,F0, or F0,Freg")
+			}
+		} else if !isX87F0(last) || !(memory(first) || spec.width == 'F' && constant(first)) {
+			return fail("expects memory source and F0 destination")
+		}
+	case x86X87Compare:
+		switch {
+		case name == "FCOMI" || name == "FCOMIP":
+			if !register(first) || !isX87F0(last) {
+				return fail("expects x87-register source and F0 destination")
+			}
+			form.left, form.right = last, first
+		case strings.HasPrefix(name, "FUCOM") || name == "FCOMDPP":
+			if !isX87F0(first) || !register(last) {
+				return fail("expects F0 source and x87-register destination")
+			}
+			form.left, form.right = first, last
+		default:
+			if isX87F0(last) && (memory(first) || constant(first) || spec.width == 'D' && register(first)) {
+				form.left, form.right = last, first
+			} else if spec.width == 'D' && isX87F0(first) && register(last) {
+				// Retain Go's complete reverse FCOMD/DP grammar without
+				// interpreting its undocumented DC /2,/3 register encoding
+				// as a new logical compare proof.
+				form.left, form.right, form.unprovedEncoding = last, first, true
+			} else {
+				return fail("expects memory source or x87-register source and F0 destination")
+			}
+		}
+		if spec.pop == 2 && form.right.Reg != "F1" {
+			// ycompp's Go table explicitly notes that its two-pop row is
+			// really F0,F1. Recognizing another encoded row is not a proof
+			// that the legacy mathematical spelling matches that opcode.
+			form.unprovedEncoding = true
+		}
+	}
+	return form, true, nil
+}
diff --git a/x86_x87_value_forms_test.go b/x86_x87_value_forms_test.go
new file mode 100644
index 000000000..2e08a0bb2
--- /dev/null
+++ b/x86_x87_value_forms_test.go
@@ -0,0 +1,244 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86X87ValueInstruction(t *testing.T, source string) Instr {
+	t.Helper()
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\n"+source+"\nRET\n")
+	if err != nil || len(file.Funcs) != 1 || len(file.Funcs[0].Instrs) != 3 {
+		t.Fatalf("invalid independent instruction fixture %q: %v", source, err)
+	}
+	return file.Funcs[0].Instrs[1]
+}
+
+func TestX86X87ValueCompleteGrammarAndMode(t *testing.T) {
+	names := strings.Fields(`
+		FMOVF FMOVFP FMOVD FMOVDP FMOVB FMOVBP FMOVX FMOVXP FXCHD FTST FSTSW
+		FMOVW FMOVWP FMOVL FMOVLP FMOVV FMOVVP FRNDINT
+		FLD1 FLDL2E FLDL2T FLDLG2 FLDLN2 FLDPI FLDZ FABS FCHS FSQRT
+		FADDW FADDL FADDF FADDD FADDDP FMULW FMULL FMULF FMULD FMULDP
+		FSUBW FSUBL FSUBF FSUBD FSUBDP FSUBRW FSUBRL FSUBRF FSUBRD FSUBRDP
+		FDIVW FDIVL FDIVF FDIVD FDIVDP FDIVRW FDIVRL FDIVRF FDIVRD FDIVRDP
+		FCOMW FCOMWP FCOML FCOMLP FCOMF FCOMFP FCOMD FCOMDP FCOMDPP
+		FCOMI FCOMIP FUCOM FUCOMP FUCOMPP FUCOMI FUCOMIP
+		FCMOVCC FCMOVCS FCMOVEQ FCMOVHI FCMOVLS FCMOVB FCMOVBE
+		FCMOVNB FCMOVNBE FCMOVE FCMOVNE FCMOVNU FCMOVU FCMOVUN
+	`)
+	if len(names) != 88 || len(x86X87ValueSpecs) != len(names) {
+		t.Fatal("complete independent x87 value-family denominator changed", len(names), len(x86X87ValueSpecs))
+	}
+	for _, name := range names {
+		if _, exists := x86X87ValueSpecs[Op(name)]; !exists {
+			t.Fatal("missing complete Go value mnemonic", name)
+		}
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, source := range []string{
+			"FMOVD 0(AX),F0", "FMOVD F7,F0", "FMOVD F0,F7", "FMOVD F0,F0",
+			"FMOVDP F0,F7", "FMOVF 0(AX),F0", "FMOVF $(2.0),F0", "FMOVD $(2.0),F0",
+			"FMOVFP F0,0(AX)", "FXCHD F0,F7", "FXCHD F7,F0", "FSTSW AX", "FSTSW 0(AX)",
+			"FADDD F7,F0", "FADDD F0,F7", "FADDDP F0,F7", "FADDF $(2.0),F0",
+			"FCOMD F7,F0", "FCOMDPP F0,F1", "FUCOMPP F0,F1", "FCOMI F7,F0", "FUCOMI F0,F7",
+		} {
+			t.Run(arch+"/"+source, func(t *testing.T) {
+				_, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, source), arch)
+				if !known || err != nil {
+					t.Fatal("complete typed Go form rejected", err)
+				}
+			})
+		}
+		for _, source := range []string{
+			"FMOVD F1,F2", "FMOVD $2,F0", "FMOVF F1,F0", "FMOVFP 0(AX),F0",
+			"FXCHD F1,F2", "FADDL F1,F0", "FADDDP F1,F0", "FCOMI F0,F1", "FUCOMI F1,F0",
+			"FSTSW BX", "FTST F0", "FLD1 F0", "FMOVD.Z 0(AX),F0", "FMOVD 0(AX)(SP*2),F0",
+		} {
+			t.Run(arch+"/invalid/"+source, func(t *testing.T) {
+				_, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, source), arch)
+				if !known || err == nil {
+					t.Fatal("malformed typed form was not rejected", err)
+				}
+			})
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		if _, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, "FLD1"), arch); !known || err == nil {
+			t.Fatal("typed parser inferred a missing or foreign x86 mode", arch, known, err)
+		}
+	}
+}
+
+// These Go rows are recognized but are not yet numerical witnesses. The reverse
+// FCOMD/DP register rows and non-F1 two-pop rows have table-level botch notes;
+// the existing independent byte oracle deliberately does not certify them.
+func TestX86X87UnobservedEncodingRowsRetainContext(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		if target.arch != "386" {
+			continue
+		}
+		for _, op := range []string{"FCOMD", "FCOMDP", "FCOMDPP", "FUCOMPP"} {
+			for lane := 0; lane < 8; lane++ {
+				pops := 0
+				switch op {
+				case "FCOMD", "FCOMDP":
+					if lane == 0 {
+						continue // F0,F0 uses the earlier ordinary register row.
+					}
+					if op == "FCOMDP" {
+						pops = 1
+					}
+				default:
+					if lane == 1 {
+						continue // The documented two-pop dependency is exactly F0,F1.
+					}
+					pops = 2
+				}
+				instruction := fmt.Sprintf("%s F0,F%d", op, lane)
+				form, known, err := x86X87ValueProperties(x86X87ValueInstruction(t, instruction), target.arch)
+				if !known || err != nil || !form.unprovedEncoding {
+					t.Fatal("unobserved Go row lost its explicit proof boundary", instruction, known, err)
+				}
+				body := strings.Repeat("FLD1\n", 8) + instruction + "\nFMOVDP F0,ret+28(FP)\n" +
+					strings.Repeat("FMOVDP F0,F0\n", 7-pops)
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(target.triple+"/"+instruction+"/"+api, func(t *testing.T) {
+						ir, err := x86ScalarFPBitViewAPI(t, x86X87ValueSource(body), x86X87ValueDeclaration,
+							target.arch, target.triple, api)
+						if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+							t.Fatalf("unobserved encoding supplied a logical effect: output=%t error=%v", ir != "", err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87ValueStateCloneJoinAndCallRevocation(t *testing.T) {
+	f0 := Operand{Kind: OpReg, Reg: "F0"}
+	for _, arch := range []string{"386", "amd64"} {
+		state := x86ResultState{x87: new(x86ResultX87State)}
+		step := func(source string) {
+			t.Helper()
+			if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, source), &state, nil, 0, arch); !known || !accepted {
+				t.Fatal("independent logical state transfer rejected", source, known, accepted)
+			}
+		}
+		step("FLD1")
+		step("FTST")
+		step("FSTSW AX")
+		if !state.x87.read(f0) || state.x87.gp[0] != 0x4500 || state.gp[0] != 0 || state.x87.status != 0 {
+			t.Fatal("status capture became whole NUM or a fresh x87 status", arch, *state.x87)
+		}
+		copy := state.clone()
+		copy.x87.slots, copy.x87.gp[0] = 0, 0
+		if !state.x87.read(f0) || state.x87.gp[0] != 0x4500 {
+			t.Fatal("cloned x87 state shared mutable cells", arch)
+		}
+		joined := state.intersect(copy)
+		if joined.x87.read(f0) || joined.x87.gp[0] != 0 {
+			t.Fatal("join manufactured availability or captured bits", arch)
+		}
+		copy.x87.depth = 0
+		if joined := state.intersect(copy); !joined.x87.invalid {
+			t.Fatal("different authored stack shapes joined as an empty known stack", arch)
+		}
+		x86ResultX87After(Instr{Op: OpCALL}, &state, arch)
+		if !state.x87.invalid || state.x87.read(f0) || state.x87.gp[0] != 0 {
+			t.Fatal("CALL retained availability or manufactured an empty-stack fact", arch)
+		}
+		if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, "FLD1"), &state, nil, 0, arch); !known || accepted {
+			t.Fatal("new push revived an unknown post-CALL stack shape", arch)
+		}
+	}
+	// Exercise the existing typed CALL producer without the universal outer
+	// post-transfer hook. It must independently revoke the same optional domain.
+	for _, shape := range []bool{false, true} {
+		plan, state, owned := x86ABI0BoolCallDomainState(t)
+		state.shapeOnly = shape
+		state.x87 = &x86ResultX87State{slots: 3, depth: 2, status: 0x4500, gp: [16]uint16{0x4500}}
+		for ordinal := range plan.calls {
+			if accepted, known := x86ABI0BoolCallStep(ordinal, plan.function.Instrs[ordinal], &state, owned, 4, "386"); !known || !accepted || !state.x87.invalid || state.x87.slots != 0 || state.x87.gp[0] != 0 {
+				t.Fatal("direct typed CALL retained an independent x87 fact", shape, known, accepted, state.x87)
+			}
+		}
+	}
+}
+
+func TestX86X87CapturedStatusRevokesOnEveryGPOverwrite(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, source := range []string{
+			"MOVB BX,AL", "MOVB BX,AH", "MOVW BX,AX", "MOVL BX,AX",
+			"ADDL $1,AX", "LEAL 1(AX),AX", "INCL AX", "BSFL BX,AX", "SETEQ AH",
+		} {
+			t.Run(arch+"/"+source, func(t *testing.T) {
+				state := x86ResultState{x87: &x86ResultX87State{gp: [16]uint16{0x4500}}}
+				x86ResultX87After(x86X87ValueInstruction(t, source), &state, arch)
+				remaining := uint16(0)
+				if source == "MOVB BX,AL" {
+					remaining = 0x4500 // Only the untouched AH bits survive.
+				}
+				if state.x87.gp[0] != remaining {
+					t.Fatal("GP overwrite retained stale captured status", source, state.x87.gp[0], remaining)
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87ValueStateConsumesSharedBudgetAndPrivateRole(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\nFLD1\nFMOVDP F0,F0\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The complete no-FP state includes native MMX and the separate string
+	// counter. This optional domain adds
+	// exactly 45: slots/depth/invalid, status16, sixteen captured words and
+	// eight source signed-width facts. This does not raise the shared limit.
+	const payload = x86IndependentResultBasePayload + 45
+	const limit = (64 << 20) / 8
+	for _, room := range []int{3*payload - 1, 3 * payload} {
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = &x86ResultFlowBudget{bytes: limit - room}
+		err := checkX86ScalarFPResultInitialization(fn, FuncSig{Name: "Value", Ret: Void}, "386")
+		visits := 0
+		if room == 3*payload {
+			visits = 3
+		}
+		if fn.x86ResultFlowBudget.visits != visits || fn.x86ResultFlowBudget.bytes != limit+3*payload-room+8*payload*visits {
+			t.Fatal("logical x87 source work differs from its exact complete-state charge", fn.x86ResultFlowBudget.bytes)
+		}
+		if room == 3*payload && err != nil || room != 3*payload && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("logical x87 state escaped or raised the existing shared budget", room, err)
+		}
+	}
+	_, resultFile, sig, _ := x86ResultInitializationFixture(t, "386", "func Value() float64",
+		"FLD1\nFMOVDP F0,ret+0(FP)\nRET")
+	if err := checkX86ScalarFPResultInitialization(resultFile.Funcs[0], sig, "386"); err != nil {
+		t.Fatal("private mapped result proof did not consume its own x87 value", err)
+	}
+	if err := CheckX86ABI0ResultInitialization(resultFile.Funcs[0], sig, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("private logical effect widened the declaration-only query", err)
+	}
+	x86X87FloatingStoresUseOnlyCheckedByteRoles(t)
+}
+
+func TestX86X87LegacyDirectHelperBindsDispatchAndDefaultMode(t *testing.T) {
+	var body strings.Builder
+	fn := Func{Instrs: []Instr{{Op: "FLD1"}}}
+	consumer := newAMD64Ctx(&body, fn, FuncSig{Name: "Value", Ret: Void}, testResolveSym("example"), nil, false)
+	if err := consumer.emitEntryAllocas(); err != nil {
+		t.Fatal(err)
+	}
+	consumer.goarch = "" // Old private direct-helper callers used the default mode.
+	if known, terminated, err := consumer.lowerX87("FLD1", Instr{Raw: "FLD1"}); !known || terminated || err != nil {
+		t.Fatal("legacy private default-mode dispatch was lost", known, terminated, err)
+	}
+	if known, _, err := consumer.lowerX87("FLD1", Instr{Op: "FLDZ", Raw: "FLDZ"}); !known || err == nil {
+		t.Fatal("conflicting dispatch/source heads acquired a typed form", known, err)
+	}
+}
diff --git a/x86_x87_value_go_test.go b/x86_x87_value_go_test.go
new file mode 100644
index 000000000..ceefaca2f
--- /dev/null
+++ b/x86_x87_value_go_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+)
+
+type x86X87GoByteCase struct {
+	instruction string
+	want        []byte
+}
+
+// This tool-backed owner is deliberately separate from the in-process value
+// tests. It observes actual selected-Go bytes, not manufactured wrapper TEXT
+// or a claim about the software x87 stack. In particular yfmvd's Yrf,Yf0 row
+// precedes Yf0,Yrf, so F0,F0 is a load/push, not a store/no-push.
+func TestX86X87FloatingMoveActualGoRowsAndPriority(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		var rows []x86X87GoByteCase
+		for _, row := range []struct {
+			instruction string
+			first, last byte
+		}{
+			{"FMOVD 0(AX),F0", 0xdd, 0x00},
+			{"FMOVD F0,0(AX)", 0xdd, 0x10},
+			{"FMOVDP F0,0(AX)", 0xdd, 0x18},
+			{"FMOVF 0(AX),F0", 0xd9, 0x00},
+			{"FMOVF F0,0(AX)", 0xd9, 0x10},
+			{"FMOVFP F0,0(AX)", 0xd9, 0x18},
+		} {
+			rows = append(rows, x86X87GoByteCase{row.instruction, []byte{row.first, row.last, 0xc3}})
+		}
+		for lane := 0; lane < 8; lane++ {
+			for _, row := range []struct {
+				instruction string
+				first, last byte
+			}{
+				{fmt.Sprintf("FMOVD F%d,F0", lane), 0xd9, 0xc0 + byte(lane)},
+				{fmt.Sprintf("FMOVDP F0,F%d", lane), 0xdd, 0xd8 + byte(lane)},
+				{fmt.Sprintf("FXCHD F0,F%d", lane), 0xd9, 0xc8 + byte(lane)},
+			} {
+				rows = append(rows, x86X87GoByteCase{row.instruction, []byte{row.first, row.last, 0xc3}})
+			}
+			// F0,F0 has already selected the earlier load row above.
+			if lane != 0 {
+				rows = append(rows, x86X87GoByteCase{fmt.Sprintf("FMOVD F0,F%d", lane), []byte{0xdd, 0xd0 + byte(lane), 0xc3}})
+				rows = append(rows, x86X87GoByteCase{fmt.Sprintf("FXCHD F%d,F0", lane), []byte{0xd9, 0xc8 + byte(lane), 0xc3}})
+			}
+		}
+		for _, row := range rows {
+			t.Run(arch+"/"+row.instruction, func(t *testing.T) {
+				source := "TEXT probe(SB),4,$0-0\n" + row.instruction + "\nRET\n"
+				got := x86OrderingHintGoBytes(t, arch, source)
+				if !bytes.Equal(got, row.want) {
+					t.Fatalf("selected Go x87 row bytes=%x, independent expected=%x", got, row.want)
+				}
+			})
+		}
+	}
+}
diff --git a/x86_x87_word_forms.go b/x86_x87_word_forms.go
new file mode 100644
index 000000000..435d49ab5
--- /dev/null
+++ b/x86_x87_word_forms.go
@@ -0,0 +1,76 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+)
+
+type x86X87WordKind uint8
+
+const (
+	x86X87Initialize x86X87WordKind = iota
+	x86X87Clear
+	x86X87StoreControl
+	x86X87StoreStatus
+	x86X87LoadControl
+)
+
+// These are the complete Go init/clear/m16-word rows, not Intel's spelling
+// aliases or an environment/rounding/trapping permission. Go FINIT and FCLEX
+// themselves encode the no-wait DB E3 and DB E2 forms; WAIT is separate.
+var x86X87WordSpecs = map[Op]x86X87WordKind{
+	"FINIT": x86X87Initialize,
+	"FCLEX": x86X87Clear,
+	"FSTCW": x86X87StoreControl,
+	"FSTSW": x86X87StoreStatus,
+	"FLDCW": x86X87LoadControl,
+}
+
+type x86X87WordForm struct {
+	kind    x86X87WordKind
+	operand Operand
+}
+
+func x86X87WordProperties(ins Instr, arch string) (x86X87WordForm, bool, error) {
+	name, _, dotted := strings.Cut(strings.ToUpper(string(ins.Op)), ".")
+	kind, known := x86X87WordSpecs[Op(name)]
+	if !known {
+		return x86X87WordForm{}, false, nil
+	}
+	form := x86X87WordForm{kind: kind}
+	fail := func(reason string) (x86X87WordForm, bool, error) {
+		return form, true, fmt.Errorf("%s %s %s: %q", arch, ins.Op, reason, ins.Raw)
+	}
+	if arch != "386" && arch != "amd64" || dotted {
+		return fail("requires its actual x86 mode and unsuffixed Go row")
+	}
+	if kind == x86X87Initialize || kind == x86X87Clear {
+		if len(ins.Args) != 0 {
+			return fail("takes no operands")
+		}
+		return form, true, nil
+	}
+	if len(ins.Args) == 1 {
+		form.operand = ins.Args[0]
+		if err := x86NamedMultiplyMemoryError(form.operand, arch); err != nil {
+			return fail(err.Error()) // Ym address grammar only, no numerical MUL role.
+		}
+		memory := isX87MemoryOperand(form.operand)
+		if form.operand.Kind == OpSym {
+			symbol := strings.TrimSpace(form.operand.Sym)
+			_, integer := parseInt(symbol)
+			memory = !strings.HasPrefix(symbol, "$") && (strings.HasSuffix(symbol, "(SB)") || integer == nil)
+		}
+		if memory || kind == x86X87StoreStatus && form.operand.Kind == OpReg && form.operand.Reg == AX {
+			return form, true, nil
+		}
+	}
+	switch kind {
+	case x86X87LoadControl:
+		return fail("expects memory source")
+	case x86X87StoreStatus:
+		return fail("expects memory destination or AX")
+	default:
+		return fail("expects memory destination")
+	}
+}
diff --git a/x86_x87_word_layout_test.go b/x86_x87_word_layout_test.go
new file mode 100644
index 000000000..be2c062ae
--- /dev/null
+++ b/x86_x87_word_layout_test.go
@@ -0,0 +1,112 @@
+package plan9asm
+
+import "testing"
+
+func TestX86X87WordUnknownShapeJoinKeepsOnlySharedLayout(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			name                    string
+			leftCall, rightCall     bool
+			foreign, missing, depth bool
+			shared                  bool
+		}{
+			{name: "both-calls", leftCall: true, rightCall: true, shared: true},
+			{name: "left-call", leftCall: true, shared: true},
+			{name: "right-call", rightCall: true, shared: true},
+			{name: "different-depth", depth: true, shared: true},
+			{name: "foreign-layout", leftCall: true, foreign: true},
+			{name: "missing-layout", leftCall: true, missing: true},
+		} {
+			t.Run(arch+"/"+row.name, func(t *testing.T) {
+				layout := &x86X87WordLayout{parameters: map[int64]bool{0: true}}
+				left := x86ResultState{x87: &x86ResultX87State{
+					slots: 1, depth: 1, status: 0xffff,
+					word: &x86ResultX87WordState{control: 0xffff, layout: layout},
+				}}
+				left.x87.gp[0] = 0xffff
+				right := left.clone()
+				if row.foreign {
+					right.x87.word.layout = &x86X87WordLayout{parameters: map[int64]bool{0: true}}
+				}
+				if row.missing {
+					right.x87.word = nil
+				}
+				if row.depth {
+					right.x87.depth = 2
+				}
+				if row.leftCall {
+					x86ResultX87After(Instr{Op: OpCALL}, &left, arch)
+				}
+				if row.rightCall {
+					x86ResultX87After(Instr{Op: OpCALL}, &right, arch)
+				}
+				joined := left.intersect(right)
+				if !joined.x87.invalid || joined.x87.slots != 0 || joined.x87.depth != 0 ||
+					joined.x87.status != 0 || joined.x87.gp != [16]uint16{} {
+					t.Fatal("unknown shape join retained mutable x87 facts")
+				}
+				if !row.shared {
+					if joined.x87.word != nil {
+						t.Fatal("foreign or one-sided layout acquired shared source metadata")
+					}
+					return
+				}
+				if joined.x87.word == nil || joined.x87.word.layout != layout || joined.x87.word.control != 0 {
+					t.Fatal("unknown shape join erased immutable layout or retained control knownness")
+				}
+				accepted, known := x86ResultX87WordStep(x86X87ValueInstruction(t, "FINIT"), &joined, nil, 0, arch)
+				if !known || !accepted || joined.x87.invalid || joined.x87.slots != 0 || joined.x87.depth != 0 ||
+					joined.x87.status != 0xffff || joined.x87.word.control != 0xffff || joined.x87.word.layout != layout {
+					t.Fatal("FINIT did not restore only its empty shape and known words")
+				}
+				if joined.x87.read(Operand{Kind: OpReg, Reg: "F0"}) {
+					t.Fatal("FINIT created a value in the empty x87 stack")
+				}
+			})
+		}
+	}
+}
+
+func TestX86X87WordFPAccessWidthAndDirectionOnly(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		for _, row := range []struct {
+			source string
+			write  bool
+		}{
+			{"FSTCW value+0(FP)", true},
+			{"FSTSW value+0(FP)", true},
+			{"FLDCW value+0(FP)", false},
+		} {
+			t.Run(arch+"/"+row.source, func(t *testing.T) {
+				ins := x86X87ValueInstruction(t, row.source)
+				width, write, known := X86FPAccessBytes(ins, 0, arch)
+				if !known || width != 2 || write != row.write {
+					t.Fatal("complete Go Ym word row lost its exact m16 direction", width, write, known)
+				}
+				for _, invalid := range []Instr{
+					{Op: ins.Op, Args: append(ins.Args, Operand{Kind: OpReg, Reg: AX})},
+					{Op: Op(string(ins.Op) + ".Z"), Args: ins.Args},
+				} {
+					if width, _, known := X86FPAccessBytes(invalid, 0, arch); known || width != 0 {
+						t.Fatal("malformed row gained an FP access width")
+					}
+				}
+				for _, foreign := range []string{"", "arm", "arm64", "wasm"} {
+					if width, _, known := X86FPAccessBytes(ins, 0, foreign); known || width != 0 {
+						t.Fatal("missing or foreign mode inferred an x86 width")
+					}
+				}
+				for _, index := range []int{-1, 1} {
+					if width, _, known := X86FPAccessBytes(ins, index, arch); known || width != 0 {
+						t.Fatal("unbound operand index gained a width")
+					}
+				}
+			})
+		}
+		for _, source := range []string{"FINIT", "FCLEX", "FSTSW AX", "FSTCW (AX)", "FLDCW (AX)"} {
+			if width, _, known := X86FPAccessBytes(x86X87ValueInstruction(t, source), 0, arch); known || width != 0 {
+				t.Fatal("non-FP row acquired a logical FP access", arch, source)
+			}
+		}
+	}
+}
diff --git a/x86_x87_word_modes_objects_test.go b/x86_x87_word_modes_objects_test.go
new file mode 100644
index 000000000..abc5a0af1
--- /dev/null
+++ b/x86_x87_word_modes_objects_test.go
@@ -0,0 +1,56 @@
+package plan9asm
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func TestX86X87HardwareControlCaptureOriginalGoAndLLVMFiveTargets(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("LLVM22 llc is required")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			result := 8
+			if target.arch == "386" {
+				result = 4
+			}
+			var source, declarations strings.Builder
+			for index, kind := range []string{"entry-result", "entry-param", "load-result", "load-param"} {
+				name := fmt.Sprintf("Capture%d", index)
+				declaration := "func Value(input uint16) uint16"
+				_, _, _, original := x86ResultInitializationFixture(t, target.arch, declaration, x86X87HardwareCaptureBody(kind, result))
+				source.WriteString(strings.ReplaceAll(original, "·Value(SB)", "·"+name+"(SB)"))
+				declarations.WriteString(strings.Replace(declaration, "Value", name, 1) + "\n")
+			}
+			if strings.Count(source.String(), "TEXT ") != 4 {
+				t.Fatal("complete source word-capture inventory changed")
+			}
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source.String())
+			for _, mode := range []X87Mode{X87Auto, X87Hardware} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("mode%d/%s", mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source.String(), declarations.String(), target.arch, target.triple, api, mode)
+						if err != nil || ir == "" {
+							t.Fatal("complete hardware word-capture source did not translate", err)
+						}
+						for _, optimized := range []bool{false, true} {
+							input := ir
+							if optimized {
+								input = x86MulDivRoundOptimize(t, input)
+							}
+							x86X87HardwareWordRead(t, input, 4)
+							for _, backend := range []string{"-O0", "-O2"} {
+								t.Run(fmt.Sprintf("IR-O2-%t/backend%s", optimized, backend), func(t *testing.T) {
+									x86PackedStringCompileObject(t, llc, target.triple, input, backend)
+								})
+							}
+						}
+					})
+				}
+			}
+		})
+	}
+}
diff --git a/x86_x87_word_modes_test.go b/x86_x87_word_modes_test.go
new file mode 100644
index 000000000..3b7735c2d
--- /dev/null
+++ b/x86_x87_word_modes_test.go
@@ -0,0 +1,152 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+)
+
+func x86X87HardwareWordRead(t *testing.T, ir string, expected int) {
+	t.Helper()
+	count := 0
+	for _, line := range strings.Split(ir, "\n") {
+		if !strings.Contains(line, `asm sideeffect "fnstcw $0"`) {
+			continue
+		}
+		if !strings.Contains(line, `"=*m,~{dirflag},~{fpsr},~{flags}"`) || !strings.Contains(line, "elementtype(i16)") {
+			t.Fatal("actual control capture lost its complete i16 write constraint", line)
+		}
+		count++
+	}
+	if count != expected {
+		t.Fatal("actual hardware control reads differ from full source inventory", count, expected)
+	}
+}
+
+func x86X87SoftwareControlRoundTrip(t *testing.T, ir string) {
+	t.Helper()
+	if strings.Contains(ir, "fnstcw") || strings.Contains(ir, "fldcw") {
+		t.Fatal("explicit Software mode borrowed an actual hardware word operation")
+	}
+	for index, input := range []uint16{0, 0xffff, 0x5a5a} {
+		name := fmt.Sprintf("ControlInput%d", index)
+		probe := fmt.Sprintf("\ndefine i16 @%s() {\n %%r = call i16 @Value(i16 %d)\n ret i16 %%r\n}\n", name, input)
+		x86ScalarFPNamedConstantResult(t, ir+probe, name, []uint64{uint64(input)})
+	}
+}
+
+func x86X87HardwareCaptureBody(kind string, result int) string {
+	prefix := ""
+	if strings.HasPrefix(kind, "load-") {
+		prefix = "FLDCW input+0(FP)\n"
+	}
+	if strings.HasSuffix(kind, "param") {
+		return prefix + "FSTCW input+0(FP)\nMOVW input+0(FP),AX\n" + fmt.Sprintf("MOVW AX,ret+%d(FP)\nRET\n", result)
+	}
+	return prefix + fmt.Sprintf("FSTCW ret+%d(FP)\nRET\n", result)
+}
+
+func TestX86X87HardwareControlCaptureNeedsNoSyntheticDefaultThreeAPIs(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		result := 8
+		if target.arch == "386" {
+			result = 4
+		}
+		for _, kind := range []string{"entry-result", "entry-param", "load-result", "load-param"} {
+			const declaration = "func Value(input uint16) uint16"
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, declaration, x86X87HardwareCaptureBody(kind, result))
+			for _, mode := range []X87Mode{X87Auto, X87Hardware} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, kind, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, declaration, target.arch, target.triple, api, mode)
+						if err != nil || ir == "" {
+							t.Fatal("actual hardware word capture lost its existing storage role", err)
+						}
+						x86X87HardwareWordRead(t, ir, 1)
+						if strings.HasPrefix(kind, "load-") && !strings.Contains(ir, `asm sideeffect "fldcw $0"`) {
+							t.Fatal("known typed input was not applied through the actual control-word emitter")
+						}
+						// Ambient hardware control is not a fixed 0x037f value.
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87TypedCallInitRestoresWordsNotValuesThreeAPIs(t *testing.T) {
+	for _, row := range []struct {
+		name, prefix string
+		good         bool
+	}{
+		{"independent-void-call-init", "CALL ·notify(SB)\nFINIT\n", true},
+		{"call-does-not-initialize-status", "CALL ·notify(SB)\n", false},
+		{"init-does-not-initialize-F0", "CALL ·notify(SB)\nFINIT\nFTST\n", false},
+		{"unknown-call-stays-unclosed", "CALL ·unknown(SB)\nFINIT\n", false},
+	} {
+		source := "TEXT ·probe(SB),4,$0-5\n" + row.prefix +
+			"FSTSW AX\nTESTW AX,AX\nSETEQ ret+4(FP)\nRET\nTEXT ·notify(SB),4,$0-0\nRET\n"
+		for _, target := range x86RawReturnTargets {
+			if target.arch != "386" {
+				continue // This existing typed CALL contract is mode32 only.
+			}
+			for _, mode := range []X87Mode{X87Auto, X87Software} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, row.name, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, x86ABI0BoolVoidCallDeclarations,
+							target.arch, target.triple, api, mode)
+						if row.good && (err != nil || ir == "") || !row.good && (!errors.Is(err, ErrProbeNeedsContext) || ir != "") {
+							t.Fatal("FINIT changed CALL authority or invented x87 values", row.good, len(ir), err)
+						}
+					})
+				}
+			}
+		}
+	}
+}
+
+func TestX86X87ControlLoadsNeedOnlyTheirDefinedBoundWord(t *testing.T) {
+	for _, target := range x86RawReturnTargets {
+		result, move := 8, "MOVQ"
+		if target.arch == "386" {
+			result, move = 4, "MOVL"
+		}
+		for _, row := range []struct {
+			name, declaration, body string
+			good                    bool
+		}{
+			{"known-AUTO", "func Value(input uint16) uint16", "MOVW input+0(FP),AX\nMOVW AX,control-2(SP)\nFLDCW control-2(SP)\n", true},
+			{"unknown-AUTO", "func Value(input uint16) uint16", "FLDCW control-2(SP)\n", false},
+			{"partial-AUTO", "func Value(input uint16) uint16", "MOVB $1,control-2(SP)\nFLDCW control-2(SP)\n", false},
+			{"pointer-is-not-word-backing", "func Value(input *byte) uint16", move + " input+0(FP),BX\nFLDCW (BX)\n", false},
+		} {
+			_, _, _, source := x86ResultInitializationFixture(t, target.arch, row.declaration,
+				row.body+fmt.Sprintf("FSTCW ret+%d(FP)\nRET\n", result))
+			// The logical AUTO role requires an original positive bounded TEXT,
+			// not a zero-frame access or a guessed physical stack allocation.
+			source = strings.Replace(source, ",4,$0-", ",4,$4-", 1)
+			for _, mode := range []X87Mode{X87Auto, X87Hardware, X87Software} {
+				for _, api := range []string{"text", "module", "Go"} {
+					t.Run(fmt.Sprintf("%s/%s/mode%d/%s", target.triple, row.name, mode, api), func(t *testing.T) {
+						ir, err := x86X87InitializedWordAPI(t, source, row.declaration, target.arch, target.triple, api, mode)
+						if !row.good {
+							if !errors.Is(err, ErrProbeNeedsContext) || ir != "" {
+								t.Fatal("control load invented source bytes or native backing", len(ir), err)
+							}
+							return
+						}
+						if err != nil || ir == "" {
+							t.Fatal("complete known AUTO word was treated as unknown environment state", err)
+						}
+						if mode == X87Software {
+							x86X87SoftwareControlRoundTrip(t, ir)
+						} else {
+							x86X87HardwareWordRead(t, ir, 1)
+						}
+					})
+				}
+			}
+		}
+	}
+}
diff --git a/x86_x87_word_state_test.go b/x86_x87_word_state_test.go
new file mode 100644
index 000000000..9b65c2c02
--- /dev/null
+++ b/x86_x87_word_state_test.go
@@ -0,0 +1,167 @@
+package plan9asm
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestX86X87WordCompleteTypedGrammar(t *testing.T) {
+	if len(x86X87WordSpecs) != 5 {
+		t.Fatal("complete Go init/clear/word denominator changed")
+	}
+	for _, arch := range []string{"386", "amd64"} {
+		for _, source := range []string{
+			"FINIT", "FCLEX", "FSTCW (AX)", "FSTSW (AX)", "FSTSW AX", "FLDCW (AX)",
+			"FSTCW input+0(FP)", "FSTSW -2(SP)", "FLDCW ·control(SB)",
+			"FSTCW -7(BX)(CX*4)", "FSTSW -7(BX)(CX*4)", "FLDCW -7(BX)(CX*4)",
+		} {
+			t.Run(arch+"/valid/"+source, func(t *testing.T) {
+				if _, known, err := x86X87WordProperties(x86X87ValueInstruction(t, source), arch); !known || err != nil {
+					t.Fatal("complete typed Go word form rejected", known, err)
+				}
+			})
+		}
+		for _, source := range []string{
+			"FINIT AX", "FCLEX AX", "FSTCW AX", "FSTSW BX", "FLDCW AX",
+			"FSTCW", "FSTSW", "FLDCW", "FINIT.Z", "FCLEX.Z", "FSTSW.Z AX",
+			"FSTCW $0", "FLDCW $0", "FSTSW 0(AX)(SP*2)",
+		} {
+			t.Run(arch+"/invalid/"+source, func(t *testing.T) {
+				if _, known, err := x86X87WordProperties(x86X87ValueInstruction(t, source), arch); !known || err == nil {
+					t.Fatal("malformed word row was not rejected", known, err)
+				}
+			})
+		}
+	}
+	for _, arch := range []string{"", "arm", "arm64", "wasm"} {
+		if _, known, err := x86X87WordProperties(x86X87ValueInstruction(t, "FINIT"), arch); !known || err == nil {
+			t.Fatal("word parser inferred a missing or foreign x86 mode", arch, known, err)
+		}
+	}
+	for _, source := range []string{"FNINIT", "FNCLEX", "FLDENV (AX)", "WAIT"} {
+		if _, known, _ := x86X87WordProperties(x86X87ValueInstruction(t, source), "amd64"); known {
+			t.Fatal("separate named/raw/environment family entered the word descriptor", source)
+		}
+	}
+}
+
+func TestX86X87WordStateKnownBitsAliasesAndCallRevocation(t *testing.T) {
+	for _, arch := range []string{"386", "amd64"} {
+		layout := &x86X87WordLayout{parameters: map[int64]bool{0: true}}
+		state := x86ResultState{x87: &x86ResultX87State{
+			slots: 3, depth: 2, status: 0x4500,
+			word: &x86ResultX87WordState{layout: layout},
+		}}
+		step := func(source string) {
+			t.Helper()
+			if accepted, known := x86ResultX87ValueStep(x86X87ValueInstruction(t, source), &state, nil, 0, arch); !known || !accepted {
+				t.Fatal("independent word transfer rejected", arch, source, known, accepted)
+			}
+		}
+		step("FCLEX")
+		if state.x87.status != 0xc5ff || state.x87.word.control != 0 || state.x87.slots != 3 || state.x87.depth != 2 {
+			t.Fatal("FCLEX invented control, TOP, condition or stack facts", arch, *state.x87)
+		}
+		step("FINIT")
+		if state.x87.status != 0xffff || state.x87.word.control != 0xffff || state.x87.slots != 0 || state.x87.depth != 0 {
+			t.Fatal("FINIT failed to define its words while leaving all x87 values unavailable", arch, *state.x87)
+		}
+		copy := state.clone()
+		copy.x87.word.control, copy.x87.status = 0x00ff, 0x80ff
+		if state.x87.word.control != 0xffff || state.x87.status != 0xffff || copy.x87.word.layout != layout {
+			t.Fatal("word clone shared mutable state or lost its actual layout", arch)
+		}
+		joined := state.intersect(copy)
+		if joined.x87.invalid || joined.x87.word.control != 0x00ff || joined.x87.status != 0x80ff {
+			t.Fatal("word join manufactured known bits", arch)
+		}
+		copy.x87.word.layout = &x86X87WordLayout{parameters: map[int64]bool{0: true}}
+		if joined := state.intersect(copy); !joined.x87.invalid {
+			t.Fatal("equal-looking foreign layouts acquired the original word role", arch)
+		}
+		for _, bits := range []uint16{0, 0x00ff, 0xff00, 0x4500, 0x80ff, 0xffff} {
+			state.x87.status = bits
+			state.gp[0], state.canonicalGP[0] = 0xff, 0xff
+			state.pointerGP[0], state.callerAddressGP[0] = true, true
+			state.callerAddressOrigin[0] = 1
+			state.resultAddressGP[0] = x86ResultSlotAddress{valid: true}
+			state.boolFrameGP = new([16]x86ResultSlotAddress)
+			state.boolFrameGP[0] = x86ResultSlotAddress{valid: true}
+			state.flags, state.direction = x86ByteFlagsAll, x86ResultDirectionForward
+			step("FSTSW AX")
+			want := uint8(0xfc)
+			if bits&0xff == 0xff {
+				want |= 1
+			}
+			if bits&0xff00 == 0xff00 {
+				want |= 2
+			}
+			if state.gp[0] != want || state.canonicalGP[0] != 0xfc || state.x87.gp[0] != bits ||
+				state.x87.status != 0 || state.pointerGP[0] || state.callerAddressGP[0] ||
+				state.callerAddressOrigin[0] != 0 || state.resultAddressGP[0].valid || state.boolFrameGP[0].valid ||
+				state.flags != x86ByteFlagsAll || state.direction != x86ResultDirectionForward {
+				t.Fatal("status capture manufactured bytes/roles or changed unwritten state", arch, bits)
+			}
+		}
+		x86ResultX87After(Instr{Op: OpCALL}, &state, arch)
+		if !state.x87.invalid || state.x87.word == nil || state.x87.word.control != 0 ||
+			state.x87.word.layout != layout || state.x87.status != 0 || state.x87.gp[0] != 0 {
+			t.Fatal("outer CALL retained hardware facts or erased immutable argument layout", arch)
+		}
+		step("FINIT")
+		if state.x87.invalid || state.x87.depth != 0 || state.x87.slots != 0 || state.x87.status != 0xffff ||
+			state.x87.word.control != 0xffff || state.x87.word.layout != layout {
+			t.Fatal("FINIT failed to restore empty shape and words without inventing an F0 value", arch)
+		}
+	}
+	// The direct typed CALL consumer must revoke without relying on After.
+	for _, shape := range []bool{false, true} {
+		plan, state, owned := x86ABI0BoolCallDomainState(t)
+		state.shapeOnly = shape
+		layout := &x86X87WordLayout{parameters: map[int64]bool{}}
+		state.x87 = &x86ResultX87State{status: 0xffff, word: &x86ResultX87WordState{control: 0xffff, layout: layout}}
+		for ordinal := range plan.calls {
+			if accepted, known := x86ABI0BoolCallStep(ordinal, plan.function.Instrs[ordinal], &state, owned, 4, "386"); !known || !accepted {
+				t.Fatal("independently closed typed CALL no longer accepted", shape, known, accepted)
+			}
+			if !state.x87.invalid || state.x87.word == nil || state.x87.word.control != 0 ||
+				state.x87.word.layout != layout || state.x87.status != 0 {
+				t.Fatal("direct typed CALL retained hardware facts or erased immutable source layout", shape)
+			}
+		}
+	}
+}
+
+func TestX86X87WordStateConsumesSharedBudgetAndPrivateRole(t *testing.T) {
+	file, err := Parse(ArchAMD64, "TEXT ·Value(SB),4,$0-0\nFINIT\nFCLEX\nRET\n")
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Complete no-FP state, logical x87 payload45 and two-byte control
+	// knownness remain independently charged. Immutable layout metadata
+	// is not a CFG copy.
+	const payload = x86IndependentResultBasePayload + 45 + 2
+	const limit = (64 << 20) / 8
+	for _, room := range []int{3*payload - 1, 3 * payload} {
+		fn := file.Funcs[0]
+		fn.x86ResultFlowBudget = &x86ResultFlowBudget{bytes: limit - room}
+		err := checkX86ScalarFPResultInitialization(fn, FuncSig{Name: "Value", Ret: Void}, "386")
+		visits := 0
+		if room == 3*payload {
+			visits = 3
+		}
+		if fn.x86ResultFlowBudget.visits != visits || fn.x86ResultFlowBudget.bytes != limit+3*payload-room+8*payload*visits {
+			t.Fatal("word source work differs from its exact complete-state charge", fn.x86ResultFlowBudget.bytes)
+		}
+		if room == 3*payload && err != nil || room != 3*payload && !errors.Is(err, ErrProbeNeedsContext) {
+			t.Fatal("initialized word state escaped or raised the existing shared budget", room, err)
+		}
+	}
+	_, resultFile, sig, _ := x86ResultInitializationFixture(t, "386", "func Value() uint16", "FINIT\nFSTSW ret+0(FP)\nRET")
+	if err := checkX86ScalarFPResultInitialization(resultFile.Funcs[0], sig, "386"); err != nil {
+		t.Fatal("private word result did not consume its explicit initializer", err)
+	}
+	if err := CheckX86ABI0ResultInitialization(resultFile.Funcs[0], sig, "386"); !errors.Is(err, ErrProbeNeedsContext) {
+		t.Fatal("private word effect widened the declaration-only result query", err)
+	}
+}
diff --git a/x86_xlat_complete_contract_test.go b/x86_xlat_complete_contract_test.go
new file mode 100644
index 000000000..4709caa21
--- /dev/null
+++ b/x86_xlat_complete_contract_test.go
@@ -0,0 +1,231 @@
+package plan9asm
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func x86XLATProgram(arch string) (string, string) {
+	word, move, push, pop, typ := 8, "MOVQ", "PUSHFQ", "POPQ", "uint64"
+	if arch == "386" {
+		word, move, push, pop, typ = 4, "MOVL", "PUSHFL", "POPL", "uint32"
+	}
+	var source strings.Builder
+	for _, name := range []string{"XLATValue", "XLATFlags", "XLATDead"} {
+		result := word
+		if name == "XLATFlags" {
+			result = 4
+		} else if name == "XLATDead" {
+			result = 0
+		}
+		fmt.Fprintf(&source, "TEXT ·%s(SB),4,$0-%d\n%s table+0(FP),BX\n%s input+%d(FP),AX\n",
+			name, 2*word+result, move, move, word)
+		if name == "XLATFlags" {
+			source.WriteString("MOVL $0x7fffffff,DX\nADDL $1,DX\nSTC\n")
+		}
+		source.WriteString("XLAT\n")
+		if name == "XLATValue" {
+			fmt.Fprintf(&source, "%s AX,ret+%d(FP)\n", move, 2*word)
+		} else if name == "XLATFlags" {
+			fmt.Fprintf(&source, "%s\n%s CX\nANDL $0x8d5,CX\nMOVL CX,ret+%d(FP)\n", push, pop, 2*word)
+		}
+		source.WriteString("RET\n")
+	}
+	// No full AX definition: XLAT needs exactly AL for its unsigned index.
+	fmt.Fprintf(&source, "TEXT ·XLATLowOnly(SB),4,$0-%d\n%s table+0(FP),BX\nMOVB $255,AL\nXLAT\nRET\n", word, move)
+	declarations := fmt.Sprintf("func XLATValue(table *byte,input %s) %s\nfunc XLATFlags(table *byte,input %s) uint32\n"+
+		"func XLATDead(table *byte,input %s)\nfunc XLATLowOnly(table *byte)\n", typ, typ, typ, typ)
+	return source.String(), declarations
+}
+
+func TestX86XLATCompleteGoGrammarAndImplicitTypedInputs(t *testing.T) {
+	table, err := os.ReadFile(filepath.Join(runtime.GOROOT(), "src/cmd/internal/obj/x86/asm6.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, row := range []string{"{AXLAT, ynone, Px, opBytes{0xd7}}", "var ynone = []ytab{\n\t{Zlit, 1, argList{}},\n}"} {
+		if !strings.Contains(string(table), row) {
+			t.Fatal("independent complete Go XLAT encoder/zero-operand row changed", row)
+		}
+	}
+	for _, arch := range []string{"amd64", "386"} {
+		instruction := x86ScalarLaneInstruction(t, "XLAT")
+		effect, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, arch)
+		if !known || err != nil || !effect.requiresResultProof || effect.flagsRead|effect.flagsDefined|effect.flagsKilled != 0 {
+			t.Fatal("XLAT lost its complete implicit AL/address/native-byte input contract", arch, effect, known, err)
+		}
+		al, base := false, false
+		for _, operand := range effect.operands {
+			al = al || operand.index == -1 && operand.operand.Kind == OpReg && operand.operand.Reg == AL &&
+				operand.width == 1 && operand.read && operand.write
+			base = base || operand.index == -1 && operand.operand.Kind == OpReg && operand.operand.Reg == BX &&
+				operand.width == x86ResultPointerWord(arch) && operand.read && !operand.write
+		}
+		if !al || !base {
+			t.Fatal("XLAT consumed full AX, lost AL's write or hid the implicit base", arch, effect)
+		}
+		for _, source := range []string{"XLAT AX", "XLAT (BX)", "XLAT.P", "XLAT.Z"} {
+			instruction := x86ScalarLaneInstruction(t, source)
+			if _, known, err := x86TypedInstructionByteEffect(instruction.Op, instruction, arch); !known || err == nil {
+				t.Fatal("XLAT accepted a non-Go operand or suffix", source, known, err)
+			}
+		}
+	}
+}
+
+func TestX86XLATInitializedPublicObjectsAndActualInputRevocations(t *testing.T) {
+	llc := findLLVM22Tool("llc")
+	if llc == "" {
+		t.Fatal("complete initialized XLAT objects require LLVM22")
+	}
+	for _, target := range x86RawReturnTargets {
+		t.Run(target.triple, func(t *testing.T) {
+			source, declarations := x86XLATProgram(target.arch)
+			x86LEAActualTargetGoObject(t, target.arch, target.triple, source)
+			for _, api := range []string{"text", "module", "Go"} {
+				t.Run(api, func(t *testing.T) {
+					ir, err := x86ScalarFPBitViewAPI(t, source, declarations, target.arch, target.triple, api)
+					if err != nil || ir == "" {
+						t.Fatal("legitimate initialized XLAT lost its public result/native access", err)
+					}
+					for _, text := range []string{ir, x86DwordProductIROptimize(t, ir)} {
+						if strings.Count(text, "load volatile i8,") != 4 {
+							t.Fatal("XLAT did not retain one exact m8 read per original opcode, including Void/dead", text)
+						}
+						compileLLVMToObject(t, llc, target.triple, "xlat-initialized.ll", "xlat-initialized.o", text)
+					}
+				})
+			}
+			move := "MOVQ"
+			if target.arch == "386" {
+				move = "MOVL"
+			}
+			for _, mutation := range []struct{ name, before, after string }{
+				{"missing AL", "MOVB $255,AL\n", ""},
+				{"NUM is not pointer", move + " table+0(FP),BX\n", move + " $1,BX\n"},
+				{"partial table", move + " table+0(FP),BX\n", "MOVB $1,BX\n"},
+				{"index is not whole AX", "MOVB $255,AL\n", "MOVB $255,AH\n"},
+			} {
+				changed := strings.ReplaceAll(source, mutation.before, mutation.after)
+				for _, api := range []string{"text", "module", "Go"} {
+					ir, err := x86ScalarFPBitViewAPI(t, changed, declarations, target.arch, target.triple, api)
+					if mutation.name == "NUM is not pointer" {
+						if err != nil || strings.Count(ir, "load volatile i8,") != 4 {
+							t.Fatal("NUM table lost one original faulting XLAT byte access", api, err)
+						}
+						x86RequireNumericNativeSourceContext(t, changed, declarations, target.arch)
+						x86NumericNativeAddressObject(t, ir, target.triple)
+					} else if ir != "" || !errors.Is(err, ErrProbeNeedsContext) {
+						t.Fatal("dead XLAT invented an unsigned AL input or native table base", mutation.name, api, err)
+					}
+				}
+			}
+		})
+	}
+}
+
+func TestX86XLATStandaloneDoesNotGrantNativeOrPhysicalAddressRights(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		instruction := x86ScalarLaneInstruction(t, "XLAT")
+		state := x86ResultState{flags: x86ByteFlagsAll, direction: x86ResultDirectionBackward}
+		state.gp[0], state.pointerGP[3], state.callerAddressGP[3] = 1, true, true
+		before := state.clone()
+		if x86ResultTransfer(instruction, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+			t.Fatal("standalone XLAT query invented a numerical native read or changed its caller", arch)
+		}
+		for _, restriction := range []func(*Instr){
+			func(ins *Instr) { ins.x86Encoded = true },
+			func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op} },
+			func(ins *Instr) { ins.x86AddressBits = 32 },
+			func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+		} {
+			changed, state := instruction, before.clone()
+			restriction(&changed)
+			if x86ResultTransfer(changed, &state, nil, 0, arch) || !reflect.DeepEqual(state, before) {
+				t.Fatal("XLAT imported an unbound physical address/source contract", arch)
+			}
+		}
+	}
+}
+
+func TestX86XLATAll256UnsignedIndicesUpperBytesAndFlagsPortable(t *testing.T) {
+	execution, arch, typ := x86ScalarCountHostExecution(t), "amd64", "uint64_t"
+	if strconv.IntSize == 32 {
+		arch, typ = "386", "uint32_t"
+	}
+	source, declarations := x86XLATProgram(arch)
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil {
+				t.Fatal("initialized XLAT failed before the independent complete unsigned-index oracle", err)
+			}
+			x86PhysicalSPRunPrivateMath(t, execution, "xlat-public-values", ir, fmt.Sprintf(x86XLATValueC, typ))
+		})
+	}
+}
+
+const x86XLATValueC = `
+#include <stdint.h>
+#include <string.h>
+typedef %s word;
+extern word XLATValue(const uint8_t *,word);
+extern uint32_t XLATFlags(const uint8_t *,word);
+extern void XLATDead(const uint8_t *,word),XLATLowOnly(const uint8_t *);
+
+int main(void) {
+    uint8_t table[256],before[256];
+    for(unsigned i=0;i<256;i++) table[i]=(uint8_t)(i*73+19);
+    memcpy(before,table,sizeof(table));
+    const uint64_t uppers[]={0,UINT64_C(0x1122334455667700),UINT64_C(0x8000000080000000),UINT64_MAX&~UINT64_C(255)};
+    for(unsigned high=0;high<4;high++)
+        for(unsigned low=0;low<256;low++) {
+            word input=(word)(uppers[high]|low);
+            word want=(input&~(word)255)|table[low];
+            if(XLATValue(table,input)!=want || XLATFlags(table,input)!=0x895) return 1;
+            XLATDead(table,input);
+            if(memcmp(table,before,sizeof(table))) return 2;
+        }
+    XLATLowOnly(table);
+    return memcmp(table,before,sizeof(table))?3:0;
+}
+`
+
+func TestX86XLATDeadNativeByteAccessFaults(t *testing.T) {
+	execution, arch, typ := x86ScalarCountHostExecution(t), "amd64", "uint64_t"
+	if strconv.IntSize == 32 {
+		arch, typ = "386", "uint32_t"
+	}
+	source, declarations := x86XLATProgram(arch)
+	driver := x86MemoryFaultDriver(fmt.Sprintf(`
+extern void XLATDead(const uint8_t *,%s);
+static int run_dead(const uint8_t *p) {
+    XLATDead((const uint8_t *)((uintptr_t)p-255),255);
+    return 0;
+}
+`, typ), "{run_dead,1,0},")
+	for _, api := range []string{"text", "module", "Go"} {
+		t.Run(api, func(t *testing.T) {
+			ir, err := x86ScalarFPBitViewAPI(t, source, declarations, arch, execution.triple, api)
+			if err != nil {
+				t.Fatal("dead XLAT failed before its independent exact-byte fault observer", err)
+			}
+			for _, pipeline := range []struct{ name, level, ir string }{
+				{"backend_O0", "-O0", ir}, {"backend_O2", "-O2", ir},
+				{"IR_O2/backend_O2", "-O2", x86DwordProductIROptimize(t, ir)},
+			} {
+				t.Run(pipeline.name, func(t *testing.T) {
+					executable := execution.compileLLVM(t, "xlat-dead-faults", pipeline.ir, driver, pipeline.level)
+					x86CheckMemoryFaultMatrix(t, execution, executable, 1)
+				})
+			}
+		})
+	}
+}
diff --git a/x86_xlat_paired_state_test.go b/x86_xlat_paired_state_test.go
new file mode 100644
index 000000000..74737fd50
--- /dev/null
+++ b/x86_xlat_paired_state_test.go
@@ -0,0 +1,61 @@
+package plan9asm
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestX86XLATPairedByteInputsAliasesAndUnrelatedState(t *testing.T) {
+	for _, arch := range []string{"amd64", "386"} {
+		instruction := x86ScalarLaneInstruction(t, "XLAT")
+		for _, knownAX := range []uint8{0, 1, 3, 0x55, 0xfe, 0xff} {
+			for _, pointer := range []bool{false, true} {
+				for _, flags := range []uint8{0, x86ByteFlagCF, x86ByteFlagsAll} {
+					state := x86ResultState{flags: flags, direction: x86ResultDirectionBackward}
+					state.gp[0], state.gp[3], state.gp[7] = knownAX, 0xff, 0xa5
+					state.pointerGP[0], state.callerAddressGP[0], state.pointerGP[3] = true, true, pointer
+					state.canonicalGP[0], state.callerAddressOrigin[0] = 0xff, 17
+					state.resultAddressGP[0] = x86ResultSlotAddress{start: 8, end: 16, valid: true}
+					before, expected := state.clone(), state.clone()
+					// BX has complete numerical bits in both pointer cases.
+					valid := knownAX&1 != 0
+					if valid {
+						expected.gp[0] |= 1
+						expected.canonicalGP[0] &^= 1
+						expected.pointerGP[0], expected.callerAddressGP[0], expected.callerAddressOrigin[0] = false, false, 0
+						expected.resultAddressGP[0] = x86ResultSlotAddress{}
+					}
+					accepted, known := x86ResultXLATStep(instruction, &state, nil, arch, true)
+					if !known || accepted != valid || !reflect.DeepEqual(state, expected) {
+						t.Fatal("XLAT invented AL/BX input, defined AX high bytes or lost FLAGS/DF/unrelated facts", arch, knownAX, pointer, flags, accepted, valid)
+					}
+					if !valid && !reflect.DeepEqual(state, before) {
+						t.Fatal("rejected XLAT partially changed its source state")
+					}
+				}
+			}
+		}
+		for _, available := range []uint8{0, 1} {
+			state := x86ResultState{flags: x86ByteFlagsAll}
+			state.gp[0], state.gp[3] = 1, available
+			before := state.clone()
+			if accepted, known := x86ResultXLATStep(instruction, &state, nil, arch, true); !known || accepted || !reflect.DeepEqual(state, before) {
+				t.Fatal("XLAT acquired unknown or partial numerical table address bytes", available)
+			}
+		}
+		for _, edit := range []func(*Instr){
+			func(ins *Instr) { ins.x86Encoded = true },
+			func(ins *Instr) { ins.x86SourceRaw = &x86SourceRawInstruction{op: ins.Op} },
+			func(ins *Instr) { ins.x86AddressBits = 32 },
+			func(ins *Instr) { ins.x86SegmentPrefix = 0x64 },
+		} {
+			changed := instruction
+			edit(&changed)
+			state := x86ResultState{gp: [16]uint8{0: 0xff}, pointerGP: [16]bool{3: true}}
+			before := state.clone()
+			if accepted, known := x86ResultXLATStep(changed, &state, nil, arch, true); accepted || !known || !reflect.DeepEqual(state, before) {
+				t.Fatal("paired XLAT accepted an unbound physical mode, origin or segment", arch)
+			}
+		}
+	}
+}